From 1b5e307f6bf1e3c98c27196a4fdf51b2c74aeee6 Mon Sep 17 00:00:00 2001
From: Josh Story <story@hey.com>
Date: Wed, 8 Nov 2023 11:36:54 -0800
Subject: [PATCH] Update React from 2983249dd to 7508dcd5c (#58216)

Updated React from 2983249dd to 7508dcd5c.

- https://github.com/facebook/react/pull/27672
- https://github.com/facebook/react/pull/27132
- https://github.com/facebook/react/pull/27646
- https://github.com/facebook/react/pull/26446
---
 package.json                                  |    20 +-
 ...t-dom-server-legacy.browser.development.js |   223 +-
 ...ct-dom-server-legacy.browser.production.js |  8893 +++++
 ...om-server-legacy.browser.production.min.js |   343 +-
 ...eact-dom-server-legacy.node.development.js |   223 +-
 ...react-dom-server-legacy.node.production.js |  8941 +++++
 ...t-dom-server-legacy.node.production.min.js |   361 +-
 ...t-dom-server-rendering-stub.development.js |     2 +-
 ...ct-dom-server-rendering-stub.production.js |   243 +
 ...om-server-rendering-stub.production.min.js |    22 +-
 .../react-dom-server.browser.development.js   |   232 +-
 .../react-dom-server.browser.production.js    |  9107 +++++
 ...react-dom-server.browser.production.min.js |    92 +-
 .../cjs/react-dom-server.bun.production.js    |  8730 +++++
 .../cjs/react-dom-server.edge.development.js  |   232 +-
 .../cjs/react-dom-server.edge.production.js   |  9106 +++++
 .../react-dom-server.edge.production.min.js   |   132 +-
 .../cjs/react-dom-server.node.development.js  |   232 +-
 .../cjs/react-dom-server.node.production.js   |  9052 +++++
 .../react-dom-server.node.production.min.js   |    46 +-
 .../cjs/react-dom-test-utils.production.js    |  1532 +
 .../react-dom-unstable_testing.development.js |   196 +-
 .../react-dom-unstable_testing.production.js  | 28514 +++++++++++++++
 ...act-dom-unstable_testing.production.min.js |    29 +-
 .../cjs/react-dom.development.js              |   196 +-
 .../cjs/react-dom.production.js               | 27812 +++++++++++++++
 .../cjs/react-dom.production.min.js           |   259 +-
 .../cjs/react-dom.profiling.js                | 29142 ++++++++++++++++
 .../cjs/react-dom.profiling.min.js            |   369 +-
 .../cjs/react-dom.shared-subset.production.js |   164 +
 .../react-dom.shared-subset.production.min.js |    20 +-
 .../react-dom-experimental/package.json       |     4 +-
 ...t-dom-server-legacy.browser.development.js |   223 +-
 ...ct-dom-server-legacy.browser.production.js |  8626 +++++
 ...om-server-legacy.browser.production.min.js |   290 +-
 ...eact-dom-server-legacy.node.development.js |   223 +-
 ...react-dom-server-legacy.node.production.js |  8674 +++++
 ...t-dom-server-legacy.node.production.min.js |   357 +-
 ...t-dom-server-rendering-stub.development.js |     2 +-
 ...ct-dom-server-rendering-stub.production.js |   243 +
 ...om-server-rendering-stub.production.min.js |    22 +-
 .../react-dom-server.browser.development.js   |   225 +-
 .../react-dom-server.browser.production.js    |  8615 +++++
 ...react-dom-server.browser.production.min.js |    90 +-
 .../cjs/react-dom-server.bun.production.js    |  8463 +++++
 .../cjs/react-dom-server.edge.development.js  |   225 +-
 .../cjs/react-dom-server.edge.production.js   |  8614 +++++
 .../react-dom-server.edge.production.min.js   |   128 +-
 .../cjs/react-dom-server.node.development.js  |   225 +-
 .../cjs/react-dom-server.node.production.js   |  8583 +++++
 .../react-dom-server.node.production.min.js   |   214 +-
 .../cjs/react-dom-test-utils.production.js    |  1532 +
 .../react-dom/cjs/react-dom.development.js    |   209 +-
 .../react-dom/cjs/react-dom.production.js     | 27570 +++++++++++++++
 .../react-dom/cjs/react-dom.production.min.js |   263 +-
 .../react-dom/cjs/react-dom.profiling.js      | 28900 +++++++++++++++
 .../react-dom/cjs/react-dom.profiling.min.js  |   333 +-
 .../cjs/react-dom.shared-subset.production.js |   164 +
 .../react-dom.shared-subset.production.min.js |    20 +-
 .../next/src/compiled/react-dom/package.json  |     4 +-
 .../cjs/react-jsx-dev-runtime.development.js  |   198 +-
 .../cjs/react-jsx-dev-runtime.production.js   |    18 +
 .../react-jsx-dev-runtime.production.min.js   |    20 +-
 .../cjs/react-jsx-dev-runtime.profiling.js    |    18 +
 .../react-jsx-dev-runtime.profiling.min.js    |    20 +-
 .../cjs/react-jsx-runtime.development.js      |   198 +-
 .../cjs/react-jsx-runtime.production.js       |   142 +
 .../cjs/react-jsx-runtime.production.min.js   |    20 +-
 .../cjs/react-jsx-runtime.profiling.js        |   142 +
 .../cjs/react-jsx-runtime.profiling.min.js    |    20 +-
 .../cjs/react.development.js                  |   198 +-
 .../cjs/react.production.js                   |  1227 +
 .../cjs/react.production.min.js               |    22 +-
 .../cjs/react.shared-subset.development.js    |   198 +-
 .../cjs/react.shared-subset.production.js     |  1322 +
 .../cjs/react.shared-subset.production.min.js |    22 +-
 ...dom-turbopack-client.browser.production.js |  1795 +
 ...turbopack-client.browser.production.min.js |    20 +-
 ...er-dom-turbopack-client.edge.production.js |  2024 ++
 ...om-turbopack-client.edge.production.min.js |    20 +-
 ...er-dom-turbopack-client.node.production.js |  1983 ++
 ...om-turbopack-client.node.production.min.js |    20 +-
 ...bopack-client.node.unbundled.production.js |  1938 +
 ...ck-client.node.unbundled.production.min.js |    20 +-
 ...eact-server-dom-turbopack-node-register.js |    19 +-
 ...dom-turbopack-server.browser.production.js |  3387 ++
 ...turbopack-server.browser.production.min.js |    20 +-
 ...er-dom-turbopack-server.edge.production.js |  3397 ++
 ...om-turbopack-server.edge.production.min.js |    20 +-
 ...er-dom-turbopack-server.node.production.js |  3600 ++
 ...om-turbopack-server.node.production.min.js |    20 +-
 ...bopack-server.node.unbundled.production.js |  3529 ++
 ...ck-server.node.unbundled.production.min.js |    20 +-
 .../package.json                              |     4 +-
 ...dom-turbopack-client.browser.production.js |  1617 +
 ...turbopack-client.browser.production.min.js |    20 +-
 ...er-dom-turbopack-client.edge.production.js |  1846 +
 ...om-turbopack-client.edge.production.min.js |    20 +-
 ...er-dom-turbopack-client.node.production.js |  1805 +
 ...om-turbopack-client.node.production.min.js |    20 +-
 ...bopack-client.node.unbundled.production.js |  1760 +
 ...ck-client.node.unbundled.production.min.js |    20 +-
 ...eact-server-dom-turbopack-node-register.js |    19 +-
 ...dom-turbopack-server.browser.production.js |  3050 ++
 ...turbopack-server.browser.production.min.js |    20 +-
 ...er-dom-turbopack-server.edge.production.js |  3060 ++
 ...om-turbopack-server.edge.production.min.js |    20 +-
 ...er-dom-turbopack-server.node.production.js |  3269 ++
 ...om-turbopack-server.node.production.min.js |    20 +-
 ...bopack-server.node.unbundled.production.js |  3198 ++
 ...ck-server.node.unbundled.production.min.js |    20 +-
 .../react-server-dom-turbopack/package.json   |     4 +-
 ...r-dom-webpack-client.browser.production.js |  1816 +
 ...m-webpack-client.browser.production.min.js |    20 +-
 ...rver-dom-webpack-client.edge.production.js |  2026 ++
 ...-dom-webpack-client.edge.production.min.js |    20 +-
 ...rver-dom-webpack-client.node.production.js |  1985 ++
 ...-dom-webpack-client.node.production.min.js |    20 +-
 ...ebpack-client.node.unbundled.production.js |  1938 +
 ...ck-client.node.unbundled.production.min.js |    20 +-
 .../react-server-dom-webpack-node-register.js |    19 +-
 .../cjs/react-server-dom-webpack-plugin.js    |    19 +-
 ...r-dom-webpack-server.browser.production.js |  3476 ++
 ...m-webpack-server.browser.production.min.js |    20 +-
 ...rver-dom-webpack-server.edge.production.js |  3467 ++
 ...-dom-webpack-server.edge.production.min.js |    20 +-
 ...rver-dom-webpack-server.node.production.js |  3677 ++
 ...-dom-webpack-server.node.production.min.js |    20 +-
 ...ebpack-server.node.unbundled.production.js |  3604 ++
 ...ck-server.node.unbundled.production.min.js |    20 +-
 .../package.json                              |     4 +-
 ...r-dom-webpack-client.browser.production.js |  1638 +
 ...m-webpack-client.browser.production.min.js |    20 +-
 ...rver-dom-webpack-client.edge.production.js |  1848 +
 ...-dom-webpack-client.edge.production.min.js |    20 +-
 ...rver-dom-webpack-client.node.production.js |  1807 +
 ...-dom-webpack-client.node.production.min.js |    20 +-
 ...ebpack-client.node.unbundled.production.js |  1760 +
 ...ck-client.node.unbundled.production.min.js |    20 +-
 .../react-server-dom-webpack-node-register.js |    19 +-
 .../cjs/react-server-dom-webpack-plugin.js    |    19 +-
 ...r-dom-webpack-server.browser.production.js |  3139 ++
 ...m-webpack-server.browser.production.min.js |    20 +-
 ...rver-dom-webpack-server.edge.production.js |  3130 ++
 ...-dom-webpack-server.edge.production.min.js |    20 +-
 ...rver-dom-webpack-server.node.production.js |  3346 ++
 ...-dom-webpack-server.node.production.min.js |    20 +-
 ...ebpack-server.node.unbundled.production.js |  3273 ++
 ...ck-server.node.unbundled.production.min.js |    20 +-
 .../react-server-dom-webpack/package.json     |     4 +-
 .../cjs/react-jsx-dev-runtime.development.js  |   198 +-
 .../cjs/react-jsx-dev-runtime.production.js   |    18 +
 .../react-jsx-dev-runtime.production.min.js   |    20 +-
 .../cjs/react-jsx-dev-runtime.profiling.js    |    18 +
 .../react-jsx-dev-runtime.profiling.min.js    |    20 +-
 .../cjs/react-jsx-runtime.development.js      |   198 +-
 .../react/cjs/react-jsx-runtime.production.js |   142 +
 .../cjs/react-jsx-runtime.production.min.js   |    20 +-
 .../react/cjs/react-jsx-runtime.profiling.js  |   142 +
 .../cjs/react-jsx-runtime.profiling.min.js    |    20 +-
 .../compiled/react/cjs/react.development.js   |   198 +-
 .../compiled/react/cjs/react.production.js    |  1101 +
 .../react/cjs/react.production.min.js         |    22 +-
 .../cjs/react.shared-subset.development.js    |   200 +-
 .../cjs/react.shared-subset.production.js     |  1107 +
 .../cjs/react.shared-subset.production.min.js |    22 +-
 .../cjs/scheduler-unstable_mock.production.js |   704 +
 .../scheduler-unstable_mock.production.min.js |    20 +-
 ...scheduler-unstable_post_task.production.js |   202 +
 ...duler-unstable_post_task.production.min.js |    20 +-
 .../cjs/scheduler.native.production.js        |   533 +
 .../cjs/scheduler.native.production.min.js    |    20 +-
 .../cjs/scheduler.production.js               |   602 +
 .../cjs/scheduler.production.min.js           |    20 +-
 .../cjs/scheduler-unstable_mock.production.js |   704 +
 .../scheduler-unstable_mock.production.min.js |    20 +-
 ...scheduler-unstable_post_task.production.js |   202 +
 ...duler-unstable_post_task.production.min.js |    20 +-
 .../cjs/scheduler.native.production.js        |   533 +
 .../cjs/scheduler.native.production.min.js    |    20 +-
 .../scheduler/cjs/scheduler.production.js     |   602 +
 .../scheduler/cjs/scheduler.production.min.js |    20 +-
 pnpm-lock.yaml                                |   104 +-
 183 files changed, 349291 insertions(+), 3750 deletions(-)
 create mode 100644 packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.browser.production.js
 create mode 100644 packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.node.production.js
 create mode 100644 packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-rendering-stub.production.js
 create mode 100644 packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.browser.production.js
 create mode 100644 packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.bun.production.js
 create mode 100644 packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.edge.production.js
 create mode 100644 packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.node.production.js
 create mode 100644 packages/next/src/compiled/react-dom-experimental/cjs/react-dom-test-utils.production.js
 create mode 100644 packages/next/src/compiled/react-dom-experimental/cjs/react-dom-unstable_testing.production.js
 create mode 100644 packages/next/src/compiled/react-dom-experimental/cjs/react-dom.production.js
 create mode 100644 packages/next/src/compiled/react-dom-experimental/cjs/react-dom.profiling.js
 create mode 100644 packages/next/src/compiled/react-dom-experimental/cjs/react-dom.shared-subset.production.js
 create mode 100644 packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.browser.production.js
 create mode 100644 packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.node.production.js
 create mode 100644 packages/next/src/compiled/react-dom/cjs/react-dom-server-rendering-stub.production.js
 create mode 100644 packages/next/src/compiled/react-dom/cjs/react-dom-server.browser.production.js
 create mode 100644 packages/next/src/compiled/react-dom/cjs/react-dom-server.bun.production.js
 create mode 100644 packages/next/src/compiled/react-dom/cjs/react-dom-server.edge.production.js
 create mode 100644 packages/next/src/compiled/react-dom/cjs/react-dom-server.node.production.js
 create mode 100644 packages/next/src/compiled/react-dom/cjs/react-dom-test-utils.production.js
 create mode 100644 packages/next/src/compiled/react-dom/cjs/react-dom.production.js
 create mode 100644 packages/next/src/compiled/react-dom/cjs/react-dom.profiling.js
 create mode 100644 packages/next/src/compiled/react-dom/cjs/react-dom.shared-subset.production.js
 create mode 100644 packages/next/src/compiled/react-experimental/cjs/react-jsx-dev-runtime.production.js
 create mode 100644 packages/next/src/compiled/react-experimental/cjs/react-jsx-dev-runtime.profiling.js
 create mode 100644 packages/next/src/compiled/react-experimental/cjs/react-jsx-runtime.production.js
 create mode 100644 packages/next/src/compiled/react-experimental/cjs/react-jsx-runtime.profiling.js
 create mode 100644 packages/next/src/compiled/react-experimental/cjs/react.production.js
 create mode 100644 packages/next/src/compiled/react-experimental/cjs/react.shared-subset.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.browser.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.edge.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.node.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.node.unbundled.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.browser.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.edge.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.node.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.node.unbundled.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.browser.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.edge.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.node.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.node.unbundled.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.browser.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.edge.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.node.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.node.unbundled.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.browser.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.edge.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.node.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.node.unbundled.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.browser.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.edge.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.node.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.node.unbundled.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.browser.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.edge.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.node.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.node.unbundled.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.browser.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.edge.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.node.production.js
 create mode 100644 packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.node.unbundled.production.js
 create mode 100644 packages/next/src/compiled/react/cjs/react-jsx-dev-runtime.production.js
 create mode 100644 packages/next/src/compiled/react/cjs/react-jsx-dev-runtime.profiling.js
 create mode 100644 packages/next/src/compiled/react/cjs/react-jsx-runtime.production.js
 create mode 100644 packages/next/src/compiled/react/cjs/react-jsx-runtime.profiling.js
 create mode 100644 packages/next/src/compiled/react/cjs/react.production.js
 create mode 100644 packages/next/src/compiled/react/cjs/react.shared-subset.production.js
 create mode 100644 packages/next/src/compiled/scheduler-experimental/cjs/scheduler-unstable_mock.production.js
 create mode 100644 packages/next/src/compiled/scheduler-experimental/cjs/scheduler-unstable_post_task.production.js
 create mode 100644 packages/next/src/compiled/scheduler-experimental/cjs/scheduler.native.production.js
 create mode 100644 packages/next/src/compiled/scheduler-experimental/cjs/scheduler.production.js
 create mode 100644 packages/next/src/compiled/scheduler/cjs/scheduler-unstable_mock.production.js
 create mode 100644 packages/next/src/compiled/scheduler/cjs/scheduler-unstable_post_task.production.js
 create mode 100644 packages/next/src/compiled/scheduler/cjs/scheduler.native.production.js
 create mode 100644 packages/next/src/compiled/scheduler/cjs/scheduler.production.js

diff --git a/package.json b/package.json
index 6c7256ad09f7b..4369ad7ef1cd8 100644
--- a/package.json
+++ b/package.json
@@ -193,16 +193,16 @@
     "random-seed": "0.3.0",
     "react": "18.2.0",
     "react-17": "npm:react@17.0.2",
-    "react-builtin": "npm:react@18.3.0-canary-2983249dd-20231107",
+    "react-builtin": "npm:react@18.3.0-canary-7508dcd5c-20231108",
     "react-dom": "18.2.0",
     "react-dom-17": "npm:react-dom@17.0.2",
-    "react-dom-builtin": "npm:react-dom@18.3.0-canary-2983249dd-20231107",
-    "react-dom-experimental-builtin": "npm:react-dom@0.0.0-experimental-2983249dd-20231107",
-    "react-experimental-builtin": "npm:react@0.0.0-experimental-2983249dd-20231107",
-    "react-server-dom-turbopack": "18.3.0-canary-2983249dd-20231107",
-    "react-server-dom-turbopack-experimental": "npm:react-server-dom-turbopack@0.0.0-experimental-2983249dd-20231107",
-    "react-server-dom-webpack": "18.3.0-canary-2983249dd-20231107",
-    "react-server-dom-webpack-experimental": "npm:react-server-dom-webpack@0.0.0-experimental-2983249dd-20231107",
+    "react-dom-builtin": "npm:react-dom@18.3.0-canary-7508dcd5c-20231108",
+    "react-dom-experimental-builtin": "npm:react-dom@0.0.0-experimental-7508dcd5c-20231108",
+    "react-experimental-builtin": "npm:react@0.0.0-experimental-7508dcd5c-20231108",
+    "react-server-dom-turbopack": "18.3.0-canary-7508dcd5c-20231108",
+    "react-server-dom-turbopack-experimental": "npm:react-server-dom-turbopack@0.0.0-experimental-7508dcd5c-20231108",
+    "react-server-dom-webpack": "18.3.0-canary-7508dcd5c-20231108",
+    "react-server-dom-webpack-experimental": "npm:react-server-dom-webpack@0.0.0-experimental-7508dcd5c-20231108",
     "react-ssr-prepass": "1.0.8",
     "react-virtualized": "9.22.3",
     "relay-compiler": "13.0.2",
@@ -212,8 +212,8 @@
     "resolve-from": "5.0.0",
     "sass": "1.54.0",
     "satori": "0.10.6",
-    "scheduler-builtin": "npm:scheduler@0.24.0-canary-2983249dd-20231107",
-    "scheduler-experimental-builtin": "npm:scheduler@0.0.0-experimental-2983249dd-20231107",
+    "scheduler-builtin": "npm:scheduler@0.24.0-canary-7508dcd5c-20231108",
+    "scheduler-experimental-builtin": "npm:scheduler@0.0.0-experimental-7508dcd5c-20231108",
     "seedrandom": "3.0.5",
     "selenium-webdriver": "4.0.0-beta.4",
     "semver": "7.3.7",
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.browser.development.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.browser.development.js
index e42b81e70af15..d8e36fda156f3 100644
--- a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.browser.development.js
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.browser.development.js
@@ -17,7 +17,7 @@ if (process.env.NODE_ENV !== "production") {
 var React = require("next/dist/compiled/react-experimental");
 var ReactDOM = require('react-dom');
 
-var ReactVersion = '18.3.0-experimental-2983249dd-20231107';
+var ReactVersion = '18.3.0-experimental-7508dcd5c-20231108';
 
 var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
 
@@ -1736,11 +1736,14 @@ var DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS = 2000; // Allows us to keep tr
 // if passed externalRuntimeConfig and the enableFizzExternalRuntime feature flag
 // is set, the server will send instructions via data attributes (instead of inline scripts)
 
-function createRenderState$1(resumableState, nonce, bootstrapScriptContent, bootstrapScripts, bootstrapModules, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
+function createRenderState$1(resumableState, nonce, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
   var inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
   var idPrefix = resumableState.idPrefix;
   var bootstrapChunks = [];
   var externalRuntimeScript = null;
+  var bootstrapScriptContent = resumableState.bootstrapScriptContent,
+      bootstrapScripts = resumableState.bootstrapScripts,
+      bootstrapModules = resumableState.bootstrapModules;
 
   if (bootstrapScriptContent !== undefined) {
     bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapAndImportMapScriptContent(bootstrapScriptContent)), endInlineScript);
@@ -1929,7 +1932,7 @@ function createRenderState$1(resumableState, nonce, bootstrapScriptContent, boot
 
   return renderState;
 }
-function createResumableState(identifierPrefix, externalRuntimeConfig) {
+function createResumableState(identifierPrefix, externalRuntimeConfig, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
   var idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
   var streamingFormat = ScriptStreamingFormat;
 
@@ -1943,6 +1946,9 @@ function createResumableState(identifierPrefix, externalRuntimeConfig) {
     idPrefix: idPrefix,
     nextFormID: 0,
     streamingFormat: streamingFormat,
+    bootstrapScriptContent: bootstrapScriptContent,
+    bootstrapScripts: bootstrapScripts,
+    bootstrapModules: bootstrapModules,
     instructions: NothingSent,
     hasBody: false,
     hasHtml: false,
@@ -4409,7 +4415,10 @@ function pushEndInstance(target, type, props, resumableState, formatContext) {
   target.push(endChunkForTag(type));
 }
 
-function writeBootstrap(destination, renderState) {
+function writeBootstrap(destination, renderState, resumableState) {
+  resumableState.bootstrapScriptContent = undefined;
+  resumableState.bootstrapScripts = undefined;
+  resumableState.bootstrapModules = undefined;
   var bootstrapChunks = renderState.bootstrapChunks;
   var i = 0;
 
@@ -4426,8 +4435,8 @@ function writeBootstrap(destination, renderState) {
   return true;
 }
 
-function writeCompletedRoot(destination, renderState) {
-  return writeBootstrap(destination, renderState);
+function writeCompletedRoot(destination, renderState, resumableState) {
+  return writeBootstrap(destination, renderState, resumableState);
 } // Structural Nodes
 // A placeholder is a node inside a hidden partial tree that can be filled in later, but before
 // display. It's never visible to users. We use the template tag because it can be used in every
@@ -4784,7 +4793,7 @@ function writeCompletedBoundaryInstruction(destination, resumableState, renderSt
     writeMore = writeChunkAndReturn(destination, completeBoundaryDataEnd);
   }
 
-  return writeBootstrap(destination, renderState) && writeMore;
+  return writeBootstrap(destination, renderState, resumableState) && writeMore;
 }
 var clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
 var clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
@@ -6520,7 +6529,7 @@ function emitEarlyPreloads(renderState, resumableState, shellComplete) {
 }
 
 function createRenderState(resumableState, generateStaticMarkup) {
-  var renderState = createRenderState$1(resumableState, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+  var renderState = createRenderState$1(resumableState, undefined, undefined, undefined, undefined, undefined);
   return {
     // Keep this in sync with ReactFizzConfigDOM
     placeholderPrefix: renderState.placeholderPrefix,
@@ -6876,6 +6885,18 @@ var componentFrameCache;
   var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
   componentFrameCache = new PossiblyWeakMap();
 }
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
@@ -6891,7 +6912,6 @@ function describeNativeComponentFrame(fn, construct) {
     }
   }
 
-  var control;
   reentry = true;
   var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
 
@@ -6905,81 +6925,140 @@ function describeNativeComponentFrame(fn, construct) {
     ReactCurrentDispatcher$1.current = null;
     disableLogs();
   }
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
 
-  try {
-    // This should throw.
-    if (construct) {
-      // Something should be setting the props in the constructor.
-      var Fake = function () {
-        throw Error();
-      }; // $FlowFixMe[prop-missing]
 
+  var RunInRootFrame = {
+    DetermineComponentFrameRoot: function () {
+      var control;
 
-      Object.defineProperty(Fake.prototype, 'props', {
-        set: function () {
-          // We use a throwing setter instead of frozen or non-writable props
-          // because that won't throw in a non-strict mode function.
-          throw Error();
-        }
-      });
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          var Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
 
-      if (typeof Reflect === 'object' && Reflect.construct) {
-        // We construct a different control for this case to include any extra
-        // frames added by the construct call.
-        try {
-          Reflect.construct(Fake, []);
-        } catch (x) {
-          control = x;
-        }
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
 
-        Reflect.construct(fn, [], Fake);
-      } else {
-        try {
-          Fake.call();
-        } catch (x) {
-          control = x;
-        } // $FlowFixMe[prop-missing] found when upgrading Flow
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
 
 
-        fn.call(Fake.prototype);
-      }
-    } else {
-      try {
-        throw Error();
-      } catch (x) {
-        control = x;
-      } // TODO(luna): This will currently only throw if the function component
-      // tries to access React/ReactDOM/props. We should probably make this throw
-      // in simple components too
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
 
 
-      var maybePromise = fn(); // If the function component returns a promise, it's likely an async
-      // component, which we don't yet support. Attach a noop catch handler to
-      // silence the error.
-      // TODO: Implement component stacks for async client components?
+          var maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
 
-      if (maybePromise && typeof maybePromise.catch === 'function') {
-        maybePromise.catch(function () {});
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(function () {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
       }
+
+      return [null, null];
     }
-  } catch (sample) {
-    // This is inlined manually because closure doesn't do it for us.
-    if (sample && control && typeof sample.stack === 'string') {
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
+
+  try {
+    var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
+
+    if (sampleStack && controlStack) {
       // This extracts the first frame from the sample that isn't also in the control.
       // Skipping one frame that we assume is the frame that calls the two.
-      var sampleLines = sample.stack.split('\n');
-      var controlLines = control.stack.split('\n');
-      var s = sampleLines.length - 1;
-      var c = controlLines.length - 1;
-
-      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
-        // We expect at least one stack frame to be shared.
-        // Typically this will be the root most one. However, stack frames may be
-        // cut off due to maximum stack limits. In this case, one maybe cut off
-        // earlier than the other. We assume that the sample is longer or the same
-        // and there for cut off earlier. So we should find the root most frame in
-        // the sample somewhere in the control.
-        c--;
+      var sampleLines = sampleStack.split('\n');
+      var controlLines = controlStack.split('\n');
+      var s = 0;
+      var c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
       }
 
       for (; s >= 1 && c >= 0; s--, c--) {
@@ -7008,7 +7087,7 @@ function describeNativeComponentFrame(fn, construct) {
                   _frame = _frame.replace('<anonymous>', fn.displayName);
                 }
 
-                {
+                if (true) {
                   if (typeof fn === 'function') {
                     componentFrameCache.set(fn, _frame);
                   }
@@ -11612,7 +11691,7 @@ function flushCompletedQueues(request, destination) {
 
         flushSegment(request, destination, completedRootSegment);
         request.completedRootSegment = null;
-        writeCompletedRoot(destination, request.renderState);
+        writeCompletedRoot(destination, request.renderState, request.resumableState);
       } else {
         // We haven't flushed the root yet so we don't need to check any other branches further down
         return;
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.browser.production.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.browser.production.js
new file mode 100644
index 0000000000000..cf7ea12fc4dca
--- /dev/null
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.browser.production.js
@@ -0,0 +1,8893 @@
+/**
+ * @license React
+ * react-dom-server-legacy.browser.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require("next/dist/compiled/react-experimental");
+var ReactDOM = require('react-dom');
+
+// Do not require this module directly! Use normal `invariant` calls with
+// template literal strings. The messages will be replaced with error codes
+// during build.
+function formatProdErrorMessage(code) {
+  let url = 'https://reactjs.org/docs/error-decoder.html?invariant=' + code;
+
+  for (let i = 1; i < arguments.length; i++) {
+    url += '&args[]=' + encodeURIComponent(arguments[i]);
+  }
+
+  return "Minified React error #" + code + "; visit " + url + " for the full message or " + 'use the non-minified dev environment for full errors and additional ' + 'helpful warnings.';
+}
+
+var ReactVersion = '18.3.0-experimental-7508dcd5c-20231108';
+
+// A pure JS implementation of a string hashing function. We do not use it for
+// security or obfuscation purposes, only to create compact hashes. So we
+// prioritize speed over collision avoidance. For example, we use this to hash
+// the component key path used by useFormState for MPA-style submissions.
+//
+// In environments where built-in hashing functions are available, we prefer
+// those instead. Like Node's crypto module, or Bun.hash. Unfortunately this
+// does not include the web standard crypto API because those methods are all
+// async. For our purposes, we need it to be sync because the cost of context
+// switching is too high to be worth it.
+//
+// The most popular hashing algorithm that meets these requirements in the JS
+// ecosystem is MurmurHash3, and almost all implementations I could find used
+// some version of the implementation by Gary Court inlined below.
+function createFastHashJS(key) {
+  return murmurhash3_32_gc(key, 0);
+}
+/* eslint-disable prefer-const, no-fallthrough */
+
+/**
+ * @license
+ *
+ * JS Implementation of MurmurHash3 (r136) (as of May 20, 2011)
+ *
+ * Copyright (c) 2011 Gary Court
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+function murmurhash3_32_gc(key, seed) {
+  let remainder, bytes, h1, h1b, c1, c2, k1, i;
+  remainder = key.length & 3; // key.length % 4
+
+  bytes = key.length - remainder;
+  h1 = seed;
+  c1 = 0xcc9e2d51;
+  c2 = 0x1b873593;
+  i = 0;
+
+  while (i < bytes) {
+    k1 = key.charCodeAt(i) & 0xff | (key.charCodeAt(++i) & 0xff) << 8 | (key.charCodeAt(++i) & 0xff) << 16 | (key.charCodeAt(++i) & 0xff) << 24;
+    ++i;
+    k1 = (k1 & 0xffff) * c1 + (((k1 >>> 16) * c1 & 0xffff) << 16) & 0xffffffff;
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = (k1 & 0xffff) * c2 + (((k1 >>> 16) * c2 & 0xffff) << 16) & 0xffffffff;
+    h1 ^= k1;
+    h1 = h1 << 13 | h1 >>> 19;
+    h1b = (h1 & 0xffff) * 5 + (((h1 >>> 16) * 5 & 0xffff) << 16) & 0xffffffff;
+    h1 = (h1b & 0xffff) + 0x6b64 + (((h1b >>> 16) + 0xe654 & 0xffff) << 16);
+  }
+
+  k1 = 0;
+
+  switch (remainder) {
+    case 3:
+      k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
+
+    case 2:
+      k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
+
+    case 1:
+      k1 ^= key.charCodeAt(i) & 0xff;
+      k1 = (k1 & 0xffff) * c1 + (((k1 >>> 16) * c1 & 0xffff) << 16) & 0xffffffff;
+      k1 = k1 << 15 | k1 >>> 17;
+      k1 = (k1 & 0xffff) * c2 + (((k1 >>> 16) * c2 & 0xffff) << 16) & 0xffffffff;
+      h1 ^= k1;
+  }
+
+  h1 ^= key.length;
+  h1 ^= h1 >>> 16;
+  h1 = (h1 & 0xffff) * 0x85ebca6b + (((h1 >>> 16) * 0x85ebca6b & 0xffff) << 16) & 0xffffffff;
+  h1 ^= h1 >>> 13;
+  h1 = (h1 & 0xffff) * 0xc2b2ae35 + (((h1 >>> 16) * 0xc2b2ae35 & 0xffff) << 16) & 0xffffffff;
+  h1 ^= h1 >>> 16;
+  return h1 >>> 0;
+}
+
+function scheduleWork(callback) {
+  callback();
+}
+function beginWriting(destination) {}
+function writeChunk(destination, chunk) {
+  writeChunkAndReturn(destination, chunk);
+}
+function writeChunkAndReturn(destination, chunk) {
+  return destination.push(chunk);
+}
+function completeWriting(destination) {}
+function close(destination) {
+  destination.push(null);
+}
+function stringToChunk(content) {
+  return content;
+}
+function stringToPrecomputedChunk(content) {
+  return content;
+}
+function clonePrecomputedChunk(chunk) {
+  return chunk;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+  destination.destroy(error);
+}
+
+const assign = Object.assign;
+
+// -----------------------------------------------------------------------------
+const enableFloat = true; // Enables unstable_useMemoCache hook, intended as a compilation target for
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/* eslint-disable max-len */
+
+const ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
+/* eslint-enable max-len */
+
+const ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
+const VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+const illegalAttributeNameCache = {};
+const validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+  if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+    return true;
+  }
+
+  if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+    return false;
+  }
+
+  if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+    validatedAttributeNameCache[attributeName] = true;
+    return true;
+  }
+
+  illegalAttributeNameCache[attributeName] = true;
+
+  return false;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+const unitlessNumbers = new Set(['animationIterationCount', 'aspectRatio', 'borderImageOutset', 'borderImageSlice', 'borderImageWidth', 'boxFlex', 'boxFlexGroup', 'boxOrdinalGroup', 'columnCount', 'columns', 'flex', 'flexGrow', 'flexPositive', 'flexShrink', 'flexNegative', 'flexOrder', 'gridArea', 'gridRow', 'gridRowEnd', 'gridRowSpan', 'gridRowStart', 'gridColumn', 'gridColumnEnd', 'gridColumnSpan', 'gridColumnStart', 'fontWeight', 'lineClamp', 'lineHeight', 'opacity', 'order', 'orphans', 'scale', 'tabSize', 'widows', 'zIndex', 'zoom', 'fillOpacity', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'MozBoxFlexGroup', 'MozLineClamp', 'msAnimationIterationCount', 'msFlex', 'msZoom', 'msFlexGrow', 'msFlexNegative', 'msFlexOrder', 'msFlexPositive', 'msFlexShrink', 'msGridColumn', 'msGridColumnSpan', 'msGridRow', 'msGridRowSpan', 'WebkitAnimationIterationCount', 'WebkitBoxFlex', 'WebKitBoxFlexGroup', 'WebkitBoxOrdinalGroup', 'WebkitColumnCount', 'WebkitColumns', 'WebkitFlex', 'WebkitFlexGrow', 'WebkitFlexPositive', 'WebkitFlexShrink', 'WebkitLineClamp']);
+function isUnitlessNumber (name) {
+  return unitlessNumbers.has(name);
+}
+
+const aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+  return aliases.get(name) || name;
+}
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// code copied and modified from escape-html
+const matchHtmlRegExp = /["'&<>]/;
+/**
+ * Escapes special characters and HTML entities in a given html string.
+ *
+ * @param  {string} string HTML string to escape for later insertion
+ * @return {string}
+ * @public
+ */
+
+function escapeHtml(string) {
+
+  const str = '' + string;
+  const match = matchHtmlRegExp.exec(str);
+
+  if (!match) {
+    return str;
+  }
+
+  let escape;
+  let html = '';
+  let index;
+  let lastIndex = 0;
+
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        // "
+        escape = '&quot;';
+        break;
+
+      case 38:
+        // &
+        escape = '&amp;';
+        break;
+
+      case 39:
+        // '
+        escape = '&#x27;'; // modified from escape-html; used to be '&#39'
+
+        break;
+
+      case 60:
+        // <
+        escape = '&lt;';
+        break;
+
+      case 62:
+        // >
+        escape = '&gt;';
+        break;
+
+      default:
+        continue;
+    }
+
+    if (lastIndex !== index) {
+      html += str.slice(lastIndex, index);
+    }
+
+    lastIndex = index + 1;
+    html += escape;
+  }
+
+  return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+} // end code copied and modified from escape-html
+
+/**
+ * Escapes text to prevent scripting attacks.
+ *
+ * @param {*} text Text value to escape.
+ * @return {string} An escaped string.
+ */
+
+
+function escapeTextForBrowser(text) {
+  if (typeof text === 'boolean' || typeof text === 'number') {
+    // this shortcircuit helps perf for types that we know will never have
+    // special characters, especially given that this function is used often
+    // for numeric dom ids.
+    return '' + text;
+  }
+
+  return escapeHtml(text);
+}
+
+const uppercasePattern = /([A-Z])/g;
+const msPattern = /^ms-/;
+/**
+ * Hyphenates a camelcased CSS property name, for example:
+ *
+ *   > hyphenateStyleName('backgroundColor')
+ *   < "background-color"
+ *   > hyphenateStyleName('MozTransition')
+ *   < "-moz-transition"
+ *   > hyphenateStyleName('msTransition')
+ *   < "-ms-transition"
+ *
+ * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
+ * is converted to `-ms-`.
+ */
+
+function hyphenateStyleName(name) {
+  return name.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern, '-ms-');
+}
+
+function sanitizeURL(url) {
+
+  return url;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+// The build script is at scripts/rollup/generate-inline-fizz-runtime.js.
+// Run `yarn generate-inline-fizz-runtime` to generate.
+const clientRenderBoundary = '$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};';
+const completeBoundary = '$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};';
+const completeBoundaryWithStyles = '$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};';
+const completeSegment = '$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};';
+const formReplaying = 'addEventListener("submit",function(a){if(!a.defaultPrevented){var c=a.target,d=a.submitter,e=c.action,b=d;if(d){var f=d.getAttribute("formAction");null!=f&&(e=f,b=null)}"javascript:throw new Error(\'A React form was unexpectedly submitted.\')"===e&&(a.preventDefault(),b?(a=document.createElement("input"),a.name=b.name,a.value=b.value,b.parentNode.insertBefore(a,b),b=new FormData(c),a.parentNode.removeChild(a)):b=new FormData(c),a=c.getRootNode(),(a.$$reactFormReplay=a.$$reactFormReplay||[]).push(c,\nd,b))}});';
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+// same object across all transitions.
+
+const sharedNotPendingObject = {
+  pending: false,
+  data: null,
+  method: null,
+  action: null
+};
+const NotPending = sharedNotPendingObject;
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+const ReactDOMServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMServerDispatcher;
+} // We make every property of the descriptor optional because it is not a contract that
+const ScriptStreamingFormat = 0;
+const DataStreamingFormat = 1;
+const NothingSent
+/*                      */
+= 0b00000;
+const SentCompleteSegmentFunction
+/*      */
+= 0b00001;
+const SentCompleteBoundaryFunction
+/*     */
+= 0b00010;
+const SentClientRenderFunction
+/*         */
+= 0b00100;
+const SentStyleInsertionFunction
+/*       */
+= 0b01000;
+const SentFormReplayingRuntime
+/*         */
+= 0b10000; // Per request, global state that is not contextual to the rendering subtree.
+// This cannot be resumed and therefore should only contain things that are
+// temporary working state or are never used in the prerender pass.
+// Credentials here are things that affect whether a browser will make a request
+// as well as things that affect which connection the browser will use for that request.
+// We want these to be aligned across preloads and resources because otherwise the preload
+// will be wasted.
+// We investigated whether referrerPolicy should be included here but from experimentation
+// it seems that browsers do not treat this as part of the http cache key and does not affect
+// which connection is used.
+
+const EXISTS = null; // This constant is to mark preloads that have no unique credentials
+// to convey. It should never be checked by identity and we should not
+// assume Preload values in ResumableState equal this value because they
+// will have come from some parsed input.
+
+const PRELOAD_NO_CREDS = [];
+// This is resumable and therefore should be serializable.
+
+
+const dataElementQuotedEnd = stringToPrecomputedChunk('"></template>');
+const startInlineScript = stringToPrecomputedChunk('<script>');
+const endInlineScript = stringToPrecomputedChunk('</script>');
+const startScriptSrc = stringToPrecomputedChunk('<script src="');
+const startModuleSrc = stringToPrecomputedChunk('<script type="module" src="');
+const scriptNonce = stringToPrecomputedChunk('" nonce="');
+const scriptIntegirty = stringToPrecomputedChunk('" integrity="');
+const scriptCrossOrigin = stringToPrecomputedChunk('" crossorigin="');
+const endAsyncScript = stringToPrecomputedChunk('" async=""></script>');
+/**
+ * This escaping function is designed to work with bootstrapScriptContent and importMap only.
+ * because we know we are escaping the entire script. We can avoid for instance
+ * escaping html comment string sequences that are valid javascript as well because
+ * if there are no sebsequent <script sequences the html parser will never enter
+ * script data double escaped state (see: https://www.w3.org/TR/html53/syntax.html#script-data-double-escaped-state)
+ *
+ * While untrusted script content should be made safe before using this api it will
+ * ensure that the script cannot be early terminated or never terminated state
+ */
+
+function escapeBootstrapAndImportMapScriptContent(scriptText) {
+
+  return ('' + scriptText).replace(scriptRegex, scriptReplacer);
+}
+
+const scriptRegex = /(<\/|<)(s)(cript)/gi;
+
+const scriptReplacer = (match, prefix, s, suffix) => "" + prefix + (s === 's' ? '\\u0073' : '\\u0053') + suffix;
+
+const importMapScriptStart = stringToPrecomputedChunk('<script type="importmap">');
+const importMapScriptEnd = stringToPrecomputedChunk('</script>'); // Since we store headers as strings we deal with their length in utf16 code units
+// rather than visual characters or the utf8 encoding that is used for most binary
+// serialization. Some common HTTP servers only allow for headers to be 4kB in length.
+// We choose a default length that is likely to be well under this already limited length however
+// pathological cases may still cause the utf-8 encoding of the headers to approach this limit.
+// It should also be noted that this maximum is a soft maximum. we have not reached the limit we will
+// allow one more header to be captured which means in practice if the limit is approached it will be exceeded
+
+const DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS = 2000; // Allows us to keep track of what we've already written so we can refer back to it.
+// if passed externalRuntimeConfig and the enableFizzExternalRuntime feature flag
+// is set, the server will send instructions via data attributes (instead of inline scripts)
+
+function createRenderState$1(resumableState, nonce, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
+  const inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
+  const idPrefix = resumableState.idPrefix;
+  const bootstrapChunks = [];
+  let externalRuntimeScript = null;
+  const bootstrapScriptContent = resumableState.bootstrapScriptContent,
+        bootstrapScripts = resumableState.bootstrapScripts,
+        bootstrapModules = resumableState.bootstrapModules;
+
+  if (bootstrapScriptContent !== undefined) {
+    bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapAndImportMapScriptContent(bootstrapScriptContent)), endInlineScript);
+  }
+
+  {
+
+    if (externalRuntimeConfig !== undefined) {
+      if (typeof externalRuntimeConfig === 'string') {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig,
+          async: true,
+          integrity: undefined,
+          nonce: nonce
+        });
+      } else {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig.src,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig.src,
+          async: true,
+          integrity: externalRuntimeConfig.integrity,
+          nonce: nonce
+        });
+      }
+    }
+  }
+
+  const importMapChunks = [];
+
+  if (importMap !== undefined) {
+    const map = importMap;
+    importMapChunks.push(importMapScriptStart);
+    importMapChunks.push(stringToChunk(escapeBootstrapAndImportMapScriptContent(JSON.stringify(map))));
+    importMapChunks.push(importMapScriptEnd);
+  }
+
+  const headers = onHeaders ? {
+    preconnects: '',
+    fontPreloads: '',
+    highImagePreloads: '',
+    remainingCapacity: typeof maxHeadersLength === 'number' ? maxHeadersLength : DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS
+  } : null;
+  const renderState = {
+    placeholderPrefix: stringToPrecomputedChunk(idPrefix + 'P:'),
+    segmentPrefix: stringToPrecomputedChunk(idPrefix + 'S:'),
+    boundaryPrefix: stringToPrecomputedChunk(idPrefix + 'B:'),
+    startInlineScript: inlineScriptWithNonce,
+    htmlChunks: null,
+    headChunks: null,
+    externalRuntimeScript: externalRuntimeScript,
+    bootstrapChunks: bootstrapChunks,
+    onHeaders,
+    headers,
+    resets: {
+      font: {},
+      dns: {},
+      connect: {
+        default: {},
+        anonymous: {},
+        credentials: {}
+      },
+      image: {},
+      style: {}
+    },
+    charsetChunks: [],
+    preconnectChunks: [],
+    importMapChunks,
+    preloadChunks: [],
+    hoistableChunks: [],
+    // cleared on flush
+    preconnects: new Set(),
+    fontPreloads: new Set(),
+    highImagePreloads: new Set(),
+    // usedImagePreloads: new Set(),
+    styles: new Map(),
+    bootstrapScripts: new Set(),
+    scripts: new Set(),
+    bulkPreloads: new Set(),
+    preloads: {
+      images: new Map(),
+      stylesheets: new Map(),
+      scripts: new Map(),
+      moduleScripts: new Map()
+    },
+    nonce,
+    // like a module global for currently rendering boundary
+    boundaryResources: null,
+    stylesToHoist: false
+  };
+
+  if (bootstrapScripts !== undefined) {
+    for (let i = 0; i < bootstrapScripts.length; i++) {
+      const scriptConfig = bootstrapScripts[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'preload',
+        as: 'script',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startScriptSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  if (bootstrapModules !== undefined) {
+    for (let i = 0; i < bootstrapModules.length; i++) {
+      const scriptConfig = bootstrapModules[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'modulepreload',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startModuleSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  return renderState;
+}
+function createResumableState(identifierPrefix, externalRuntimeConfig, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
+  const idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
+  let streamingFormat = ScriptStreamingFormat;
+
+  {
+    if (externalRuntimeConfig !== undefined) {
+      streamingFormat = DataStreamingFormat;
+    }
+  }
+
+  return {
+    idPrefix: idPrefix,
+    nextFormID: 0,
+    streamingFormat,
+    bootstrapScriptContent,
+    bootstrapScripts,
+    bootstrapModules,
+    instructions: NothingSent,
+    hasBody: false,
+    hasHtml: false,
+    // @TODO add bootstrap script to implicit preloads
+    // persistent
+    unknownResources: {},
+    dnsResources: {},
+    connectResources: {
+      default: {},
+      anonymous: {},
+      credentials: {}
+    },
+    imageResources: {},
+    styleResources: {},
+    scriptResources: {},
+    moduleUnknownResources: {},
+    moduleScriptResources: {}
+  };
+}
+// modes. We only include the variants as they matter for the sake of our purposes.
+// We don't actually provide the namespace therefore we use constants instead of the string.
+
+const ROOT_HTML_MODE = 0; // Used for the root most element tag.
+// We have a less than HTML_HTML_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const HTML_HTML_MODE = 1; // Used for the <html> if it is at the top level.
+
+const HTML_MODE = 2;
+const SVG_MODE = 3;
+const MATHML_MODE = 4;
+const HTML_TABLE_MODE = 5;
+const HTML_TABLE_BODY_MODE = 6;
+const HTML_TABLE_ROW_MODE = 7;
+const HTML_COLGROUP_MODE = 8; // We have a greater than HTML_TABLE_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const NO_SCOPE =
+/*         */
+0b00;
+const NOSCRIPT_SCOPE =
+/*   */
+0b01;
+const PICTURE_SCOPE =
+/*    */
+0b10; // Lets us keep track of contextual state and pick it back up after suspending.
+
+function createFormatContext(insertionMode, selectedValue, tagScope) {
+  return {
+    insertionMode,
+    selectedValue,
+    tagScope
+  };
+}
+
+function createRootFormatContext(namespaceURI) {
+  const insertionMode = namespaceURI === 'http://www.w3.org/2000/svg' ? SVG_MODE : namespaceURI === 'http://www.w3.org/1998/Math/MathML' ? MATHML_MODE : ROOT_HTML_MODE;
+  return createFormatContext(insertionMode, null, NO_SCOPE);
+}
+function getChildFormatContext(parentContext, type, props) {
+  switch (type) {
+    case 'noscript':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | NOSCRIPT_SCOPE);
+
+    case 'select':
+      return createFormatContext(HTML_MODE, props.value != null ? props.value : props.defaultValue, parentContext.tagScope);
+
+    case 'svg':
+      return createFormatContext(SVG_MODE, null, parentContext.tagScope);
+
+    case 'picture':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | PICTURE_SCOPE);
+
+    case 'math':
+      return createFormatContext(MATHML_MODE, null, parentContext.tagScope);
+
+    case 'foreignObject':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    // Table parents are special in that their children can only be created at all if they're
+    // wrapped in a table parent. So we need to encode that we're entering this mode.
+
+    case 'table':
+      return createFormatContext(HTML_TABLE_MODE, null, parentContext.tagScope);
+
+    case 'thead':
+    case 'tbody':
+    case 'tfoot':
+      return createFormatContext(HTML_TABLE_BODY_MODE, null, parentContext.tagScope);
+
+    case 'colgroup':
+      return createFormatContext(HTML_COLGROUP_MODE, null, parentContext.tagScope);
+
+    case 'tr':
+      return createFormatContext(HTML_TABLE_ROW_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode >= HTML_TABLE_MODE) {
+    // Whatever tag this was, it wasn't a table parent or other special parent, so we must have
+    // entered plain HTML again.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode === ROOT_HTML_MODE) {
+    if (type === 'html') {
+      // We've emitted the root and is now in <html> mode.
+      return createFormatContext(HTML_HTML_MODE, null, parentContext.tagScope);
+    } else {
+      // We've emitted the root and is now in plain HTML mode.
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    }
+  } else if (parentContext.insertionMode === HTML_HTML_MODE) {
+    // We've emitted the document element and is now in plain HTML mode.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  return parentContext;
+}
+function makeId(resumableState, treeId, localId) {
+  const idPrefix = resumableState.idPrefix;
+  let id = ':' + idPrefix + 'R' + treeId; // Unless this is the first id at this level, append a number at the end
+  // that represents the position of this useId hook among all the useId
+  // hooks for this fiber.
+
+  if (localId > 0) {
+    id += 'H' + localId.toString(32);
+  }
+
+  return id + ':';
+}
+
+function encodeHTMLTextNode(text) {
+  return escapeTextForBrowser(text);
+}
+
+const textSeparator = stringToPrecomputedChunk('<!-- -->');
+function pushTextInstance$1(target, text, renderState, textEmbedded) {
+  if (text === '') {
+    // Empty text doesn't have a DOM node representation and the hydration is aware of this.
+    return textEmbedded;
+  }
+
+  if (textEmbedded) {
+    target.push(textSeparator);
+  }
+
+  target.push(stringToChunk(encodeHTMLTextNode(text)));
+  return true;
+} // Called when Fizz is done with a Segment. Currently the only purpose is to conditionally
+// emit a text separator when we don't know for sure it is safe to omit
+
+function pushSegmentFinale$1(target, renderState, lastPushedText, textEmbedded) {
+  if (lastPushedText && textEmbedded) {
+    target.push(textSeparator);
+  }
+}
+const styleNameCache = new Map();
+
+function processStyleName(styleName) {
+  const chunk = styleNameCache.get(styleName);
+
+  if (chunk !== undefined) {
+    return chunk;
+  }
+
+  const result = stringToPrecomputedChunk(escapeTextForBrowser(hyphenateStyleName(styleName)));
+  styleNameCache.set(styleName, result);
+  return result;
+}
+
+const styleAttributeStart = stringToPrecomputedChunk(' style="');
+const styleAssign = stringToPrecomputedChunk(':');
+const styleSeparator = stringToPrecomputedChunk(';');
+
+function pushStyleAttribute(target, style) {
+  if (typeof style !== 'object') {
+    throw Error(formatProdErrorMessage(62));
+  }
+
+  let isFirst = true;
+
+  for (const styleName in style) {
+    if (!hasOwnProperty.call(style, styleName)) {
+      continue;
+    } // If you provide unsafe user data here they can inject arbitrary CSS
+    // which may be problematic (I couldn't repro this):
+    // https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet
+    // http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/
+    // This is not an XSS hole but instead a potential CSS injection issue
+    // which has lead to a greater discussion about how we're going to
+    // trust URLs moving forward. See #2115901
+
+
+    const styleValue = style[styleName];
+
+    if (styleValue == null || typeof styleValue === 'boolean' || styleValue === '') {
+      // TODO: We used to set empty string as a style with an empty value. Does that ever make sense?
+      continue;
+    }
+
+    let nameChunk;
+    let valueChunk;
+    const isCustomProperty = styleName.indexOf('--') === 0;
+
+    if (isCustomProperty) {
+      nameChunk = stringToChunk(escapeTextForBrowser(styleName));
+
+      valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+    } else {
+
+      nameChunk = processStyleName(styleName);
+
+      if (typeof styleValue === 'number') {
+        if (styleValue !== 0 && !isUnitlessNumber(styleName)) {
+          valueChunk = stringToChunk(styleValue + 'px'); // Presumes implicit 'px' suffix for unitless numbers
+        } else {
+          valueChunk = stringToChunk('' + styleValue);
+        }
+      } else {
+
+        valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+      }
+    }
+
+    if (isFirst) {
+      isFirst = false; // If it's first, we don't need any separators prefixed.
+
+      target.push(styleAttributeStart, nameChunk, styleAssign, valueChunk);
+    } else {
+      target.push(styleSeparator, nameChunk, styleAssign, valueChunk);
+    }
+  }
+
+  if (!isFirst) {
+    target.push(attributeEnd);
+  }
+}
+
+const attributeSeparator = stringToPrecomputedChunk(' ');
+const attributeAssign = stringToPrecomputedChunk('="');
+const attributeEnd = stringToPrecomputedChunk('"');
+const attributeEmptyString = stringToPrecomputedChunk('=""');
+
+function pushBooleanAttribute(target, name, value) // not null or undefined
+{
+  if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+    target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+  }
+}
+
+function pushStringAttribute(target, name, value) // not null or undefined
+{
+  if (typeof value !== 'function' && typeof value !== 'symbol' && typeof value !== 'boolean') {
+    target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+  }
+}
+
+function makeFormFieldPrefix(resumableState) {
+  const id = resumableState.nextFormID++;
+  return resumableState.idPrefix + id;
+} // Since this will likely be repeated a lot in the HTML, we use a more concise message
+// than on the client and hopefully it's googleable.
+
+
+const actionJavaScriptURL = stringToPrecomputedChunk(escapeTextForBrowser( // eslint-disable-next-line no-script-url
+"javascript:throw new Error('A React form was unexpectedly submitted.')"));
+const startHiddenInputChunk = stringToPrecomputedChunk('<input type="hidden"');
+
+function pushAdditionalFormField(value, key) {
+  const target = this;
+  target.push(startHiddenInputChunk);
+
+  if (typeof value !== 'string') {
+    throw Error(formatProdErrorMessage(480));
+  }
+
+  pushStringAttribute(target, 'name', key);
+  pushStringAttribute(target, 'value', value);
+  target.push(endOfStartTagSelfClosing);
+}
+
+function pushAdditionalFormFields(target, formData) {
+  if (formData !== null) {
+    // $FlowFixMe[prop-missing]: FormData has forEach.
+    formData.forEach(pushAdditionalFormField, target);
+  }
+}
+
+function pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name) {
+  let formData = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      name = customFields.name;
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('formAction'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      name = null;
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (name != null) {
+    pushAttribute(target, 'name', name);
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'formAction', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'formEncType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'formMethod', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'formTarget', formTarget);
+  }
+
+  return formData;
+}
+
+function pushAttribute(target, name, value) // not null or undefined
+{
+  switch (name) {
+    // These are very common props and therefore are in the beginning of the switch.
+    // TODO: aria-label is a very common prop but allows booleans so is not like the others
+    // but should ideally go in this list too.
+    case 'className':
+      {
+        pushStringAttribute(target, 'class', value);
+        break;
+      }
+
+    case 'tabIndex':
+      {
+        pushStringAttribute(target, 'tabindex', value);
+        break;
+      }
+
+    case 'dir':
+    case 'role':
+    case 'viewBox':
+    case 'width':
+    case 'height':
+      {
+        pushStringAttribute(target, name, value);
+        break;
+      }
+
+    case 'style':
+      {
+        pushStyleAttribute(target, value);
+        return;
+      }
+
+    case 'src':
+    case 'href':
+      {
+        {
+          if (value === '') {
+
+            return;
+          }
+        }
+      }
+    // Fall through to the last case which shouldn't remove empty strings.
+
+    case 'action':
+    case 'formAction':
+      {
+        // TODO: Consider only special casing these for each tag.
+        if (value == null || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'defaultValue':
+    case 'defaultChecked': // These shouldn't be set as attributes on generic HTML elements.
+
+    case 'innerHTML': // Must use dangerouslySetInnerHTML instead.
+
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+      // Ignored. These are built-in to React on the client.
+      return;
+
+    case 'autoFocus':
+    case 'multiple':
+    case 'muted':
+      {
+        pushBooleanAttribute(target, name.toLowerCase(), value);
+        return;
+      }
+
+    case 'xlinkHref':
+      {
+        if (typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk('xlink:href'), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'contentEditable':
+    case 'spellCheck':
+    case 'draggable':
+    case 'value':
+    case 'autoReverse':
+    case 'externalResourcesRequired':
+    case 'focusable':
+    case 'preserveAlpha':
+      {
+        // Booleanish String
+        // These are "enumerated" attributes that accept "true" and "false".
+        // In React, we let users pass `true` and `false` even though technically
+        // these aren't boolean attributes (they are coerced to strings).
+        if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'allowFullScreen':
+    case 'async':
+    case 'autoPlay':
+    case 'controls':
+    case 'default':
+    case 'defer':
+    case 'disabled':
+    case 'disablePictureInPicture':
+    case 'disableRemotePlayback':
+    case 'formNoValidate':
+    case 'hidden':
+    case 'loop':
+    case 'noModule':
+    case 'noValidate':
+    case 'open':
+    case 'playsInline':
+    case 'readOnly':
+    case 'required':
+    case 'reversed':
+    case 'scoped':
+    case 'seamless':
+    case 'itemScope':
+      {
+        // Boolean
+        if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        }
+
+        return;
+      }
+
+    case 'capture':
+    case 'download':
+      {
+        // Overloaded Boolean
+        if (value === true) {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        } else if (value === false) ; else if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'cols':
+    case 'rows':
+    case 'size':
+    case 'span':
+      {
+        // These are HTML attributes that must be positive numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value) && value >= 1) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'rowSpan':
+    case 'start':
+      {
+        // These are HTML attributes that must be numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value)) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'xlinkActuate':
+      pushStringAttribute(target, 'xlink:actuate', value);
+      return;
+
+    case 'xlinkArcrole':
+      pushStringAttribute(target, 'xlink:arcrole', value);
+      return;
+
+    case 'xlinkRole':
+      pushStringAttribute(target, 'xlink:role', value);
+      return;
+
+    case 'xlinkShow':
+      pushStringAttribute(target, 'xlink:show', value);
+      return;
+
+    case 'xlinkTitle':
+      pushStringAttribute(target, 'xlink:title', value);
+      return;
+
+    case 'xlinkType':
+      pushStringAttribute(target, 'xlink:type', value);
+      return;
+
+    case 'xmlBase':
+      pushStringAttribute(target, 'xml:base', value);
+      return;
+
+    case 'xmlLang':
+      pushStringAttribute(target, 'xml:lang', value);
+      return;
+
+    case 'xmlSpace':
+      pushStringAttribute(target, 'xml:space', value);
+      return;
+
+    default:
+      if ( // shouldIgnoreAttribute
+      // We have already filtered out null/undefined and reserved words.
+      name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+        return;
+      }
+
+      const attributeName = getAttributeAlias(name);
+
+      if (isAttributeNameSafe(attributeName)) {
+        // shouldRemoveAttribute
+        switch (typeof value) {
+          case 'function':
+          case 'symbol':
+            // eslint-disable-line
+            return;
+
+          case 'boolean':
+            {
+              const prefix = attributeName.toLowerCase().slice(0, 5);
+
+              if (prefix !== 'data-' && prefix !== 'aria-') {
+                return;
+              }
+            }
+        }
+
+        target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+      }
+
+  }
+}
+
+const endOfStartTag = stringToPrecomputedChunk('>');
+const endOfStartTagSelfClosing = stringToPrecomputedChunk('/>');
+
+function pushInnerHTML(target, innerHTML, children) {
+  if (innerHTML != null) {
+    if (children != null) {
+      throw Error(formatProdErrorMessage(60));
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw Error(formatProdErrorMessage(61));
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+
+      target.push(stringToChunk('' + html));
+    }
+  }
+} // TODO: Move these to RenderState so that we warn for every request.
+
+function pushStartSelect(target, props) {
+
+  target.push(startChunkForTag('select'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          // TODO: This doesn't really make sense for select since it can't use the controlled
+          // value in the innerHTML.
+          innerHTML = propValue;
+          break;
+
+        case 'defaultValue':
+        case 'value':
+          // These are set on the Context instead and applied to the nested options.
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+function flattenOptionChildren(children) {
+  let content = ''; // Flatten children and warn if they aren't strings or numbers;
+  // invalid types are ignored.
+
+  React.Children.forEach(children, function (child) {
+    if (child == null) {
+      return;
+    }
+
+    content += child;
+  });
+  return content;
+}
+
+const selectedMarkerAttribute = stringToPrecomputedChunk(' selected=""');
+
+function pushStartOption(target, props, formatContext) {
+  const selectedValue = formatContext.selectedValue;
+  target.push(startChunkForTag('option'));
+  let children = null;
+  let value = null;
+  let selected = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'selected':
+          // ignore
+          selected = propValue;
+
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+        // We intentionally fallthrough to also set the attribute on the node.
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (selectedValue != null) {
+    let stringValue;
+
+    if (value !== null) {
+
+      stringValue = '' + value;
+    } else {
+
+      stringValue = flattenOptionChildren(children);
+    }
+
+    if (isArray(selectedValue)) {
+      // multiple
+      for (let i = 0; i < selectedValue.length; i++) {
+
+        const v = '' + selectedValue[i];
+
+        if (v === stringValue) {
+          target.push(selectedMarkerAttribute);
+          break;
+        }
+      }
+    } else {
+
+      if ('' + selectedValue === stringValue) {
+        target.push(selectedMarkerAttribute);
+      }
+    }
+  } else if (selected) {
+    target.push(selectedMarkerAttribute);
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const formReplayingRuntimeScript = stringToPrecomputedChunk(formReplaying);
+
+function injectFormReplayingRuntime(resumableState, renderState) {
+  // If we haven't sent it yet, inject the runtime that tracks submitted JS actions
+  // for later replaying by Fiber. If we use an external runtime, we don't need
+  // to emit anything. It's always used.
+  if ((resumableState.instructions & SentFormReplayingRuntime) === NothingSent && (!renderState.externalRuntimeScript)) {
+    resumableState.instructions |= SentFormReplayingRuntime;
+    renderState.bootstrapChunks.unshift(renderState.startInlineScript, formReplayingRuntimeScript, endInlineScript);
+  }
+}
+
+const formStateMarkerIsMatching = stringToPrecomputedChunk('<!--F!-->');
+const formStateMarkerIsNotMatching = stringToPrecomputedChunk('<!--F-->');
+function pushFormStateMarkerIsMatching(target) {
+  target.push(formStateMarkerIsMatching);
+}
+function pushFormStateMarkerIsNotMatching(target) {
+  target.push(formStateMarkerIsNotMatching);
+}
+
+function pushStartForm(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('form'));
+  let children = null;
+  let innerHTML = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'action':
+          formAction = propValue;
+          break;
+
+        case 'encType':
+          formEncType = propValue;
+          break;
+
+        case 'method':
+          formMethod = propValue;
+          break;
+
+        case 'target':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  let formData = null;
+  let formActionName = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+      formActionName = customFields.name;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('action'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'action', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'encType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'method', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'target', formTarget);
+  }
+
+  target.push(endOfStartTag);
+
+  if (formActionName !== null) {
+    target.push(startHiddenInputChunk);
+    pushStringAttribute(target, 'name', formActionName);
+    target.push(endOfStartTagSelfClosing);
+    pushAdditionalFormFields(target, formData);
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushInput(target, props, resumableState, renderState) {
+
+  target.push(startChunkForTag('input'));
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+  let value = null;
+  let defaultValue = null;
+  let checked = null;
+  let defaultChecked = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(399, 'input'));
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        case 'defaultChecked':
+          defaultChecked = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'checked':
+          checked = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+
+  if (checked !== null) {
+    pushBooleanAttribute(target, 'checked', checked);
+  } else if (defaultChecked !== null) {
+    pushBooleanAttribute(target, 'checked', defaultChecked);
+  }
+
+  if (value !== null) {
+    pushAttribute(target, 'value', value);
+  } else if (defaultValue !== null) {
+    pushAttribute(target, 'value', defaultValue);
+  }
+
+  target.push(endOfStartTagSelfClosing); // We place any additional hidden form fields after the input.
+
+  pushAdditionalFormFields(target, formData);
+  return null;
+}
+
+function pushStartButton(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('button'));
+  let children = null;
+  let innerHTML = null;
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+  target.push(endOfStartTag); // We place any additional hidden form fields we need to include inside the button itself.
+
+  pushAdditionalFormFields(target, formData);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartTextArea(target, props) {
+
+  target.push(startChunkForTag('textarea'));
+  let value = null;
+  let defaultValue = null;
+  let children = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(91));
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (value === null && defaultValue !== null) {
+    value = defaultValue;
+  }
+
+  target.push(endOfStartTag); // TODO (yungsters): Remove support for children content in <textarea>.
+
+  if (children != null) {
+
+    if (value != null) {
+      throw Error(formatProdErrorMessage(92));
+    }
+
+    if (isArray(children)) {
+      if (children.length > 1) {
+        throw Error(formatProdErrorMessage(93));
+      } // TODO: remove the coercion and the DEV check below because it will
+
+      value = '' + children[0];
+    }
+
+    value = '' + children;
+  }
+
+  if (typeof value === 'string' && value[0] === '\n') {
+    // text/html ignores the first character in these tags if it's a newline
+    // Prefer to break application/xml over text/html (for now) by adding
+    // a newline specifically to get eaten by the parser. (Alternately for
+    // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+    // \r is normalized out by HTMLTextAreaElement#value.)
+    // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+    // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+    // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+    // See: Parsing of "textarea" "listing" and "pre" elements
+    //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+    target.push(leadingNewline);
+  } // ToString and push directly instead of recurse over children.
+  // We don't really support complex children in the value anyway.
+  // This also currently avoids a trailing comment node which breaks textarea.
+
+
+  if (value !== null) {
+
+    target.push(stringToChunk(encodeHTMLTextNode('' + value)));
+  }
+
+  return null;
+}
+
+function pushMeta(target, props, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      return pushSelfClosing(target, props, 'meta');
+    } else {
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      if (typeof props.charSet === 'string') {
+        return pushSelfClosing(renderState.charsetChunks, props, 'meta');
+      } else if (props.name === 'viewport') {
+        // "viewport" isn't related to preconnect but it has the right priority
+        return pushSelfClosing(renderState.preconnectChunks, props, 'meta');
+      } else {
+        return pushSelfClosing(renderState.hoistableChunks, props, 'meta');
+      }
+    }
+  }
+}
+
+function pushLink(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const rel = props.rel;
+    const href = props.href;
+    const precedence = props.precedence;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof rel !== 'string' || typeof href !== 'string' || href === '') {
+
+      pushLinkImpl(target, props);
+      return null;
+    }
+
+    if (props.rel === 'stylesheet') {
+      // This <link> may hoistable as a Stylesheet Resource, otherwise it will emit in place
+      const key = getResourceKey(href);
+
+      if (typeof precedence !== 'string' || props.disabled != null || props.onLoad || props.onError) {
+
+        return pushLinkImpl(target, props);
+      } else {
+        // This stylesheet refers to a Resource and we create a new one if necessary
+        let styleQueue = renderState.styles.get(precedence);
+        const hasKey = resumableState.styleResources.hasOwnProperty(key);
+        const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+        if (resourceState !== EXISTS) {
+          // We are going to create this resource now so it is marked as Exists
+          resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+          // to create a StyleQueue
+
+          if (!styleQueue) {
+            styleQueue = {
+              precedence: stringToChunk(escapeTextForBrowser(precedence)),
+              rules: [],
+              hrefs: [],
+              sheets: new Map()
+            };
+            renderState.styles.set(precedence, styleQueue);
+          }
+
+          const resource = {
+            state: PENDING$1,
+            props: stylesheetPropsFromRawProps(props)
+          };
+
+          if (resourceState) {
+            // When resourceState is truty it is a Preload state. We cast it for clarity
+            const preloadState = resourceState;
+
+            if (preloadState.length === 2) {
+              adoptPreloadCredentials(resource.props, preloadState);
+            }
+
+            const preloadResource = renderState.preloads.stylesheets.get(key);
+
+            if (preloadResource && preloadResource.length > 0) {
+              // The Preload for this resource was created in this render pass and has not flushed yet so
+              // we need to clear it to avoid it flushing.
+              preloadResource.length = 0;
+            } else {
+              // Either the preload resource from this render already flushed in this render pass
+              // or the preload flushed in a prior pass (prerender). In either case we need to mark
+              // this resource as already having been preloaded.
+              resource.state = PRELOADED;
+            }
+          } // We add the newly created resource to our StyleQueue and if necessary
+          // track the resource with the currently rendering boundary
+
+
+          styleQueue.sheets.set(key, resource);
+
+          if (renderState.boundaryResources) {
+            renderState.boundaryResources.stylesheets.add(resource);
+          }
+        } else {
+          // We need to track whether this boundary should wait on this resource or not.
+          // Typically this resource should always exist since we either had it or just created
+          // it. However, it's possible when you resume that the style has already been emitted
+          // and then it wouldn't be recreated in the RenderState and there's no need to track
+          // it again since we should've hoisted it to the shell already.
+          if (styleQueue) {
+            const resource = styleQueue.sheets.get(key);
+
+            if (resource) {
+              if (renderState.boundaryResources) {
+                renderState.boundaryResources.stylesheets.add(resource);
+              }
+            }
+          }
+        }
+
+        if (textEmbedded) {
+          // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+          // to be safe and assume text will follow by inserting a textSeparator
+          target.push(textSeparator);
+        }
+
+        return null;
+      }
+    } else if (props.onLoad || props.onError) {
+      // When using load handlers we cannot hoist and need to emit links in place
+      return pushLinkImpl(target, props);
+    } else {
+      // We can hoist this link so we may need to emit a text separator.
+      // @TODO refactor text separators so we don't have to defensively add
+      // them when we don't end up emitting a tag as a result of pushStartInstance
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      switch (props.rel) {
+        case 'preconnect':
+        case 'dns-prefetch':
+          return pushLinkImpl(renderState.preconnectChunks, props);
+
+        case 'preload':
+          return pushLinkImpl(renderState.preloadChunks, props);
+
+        default:
+          return pushLinkImpl(renderState.hoistableChunks, props);
+      }
+    }
+  }
+}
+
+function pushLinkImpl(target, props) {
+  target.push(startChunkForTag('link'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(399, 'link'));
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStyle(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+
+  {
+    const precedence = props.precedence;
+    const href = props.href;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof precedence !== 'string' || typeof href !== 'string' || href === '') {
+      // This style tag is not able to be turned into a Style Resource
+      return pushStyleImpl(target, props);
+    }
+
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS;
+
+      if (!styleQueue) {
+        // This is the first time we've encountered this precedence we need
+        // to create a StyleQueue.
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [stringToChunk(escapeTextForBrowser(href))],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      } else {
+        // We have seen this precedence before and need to track this href
+        styleQueue.hrefs.push(stringToChunk(escapeTextForBrowser(href)));
+      }
+
+      pushStyleContents(styleQueue.rules, props);
+    }
+
+    if (styleQueue) {
+      // We need to track whether this boundary should wait on this resource or not.
+      // Typically this resource should always exist since we either had it or just created
+      // it. However, it's possible when you resume that the style has already been emitted
+      // and then it wouldn't be recreated in the RenderState and there's no need to track
+      // it again since we should've hoisted it to the shell already.
+      if (renderState.boundaryResources) {
+        renderState.boundaryResources.styles.add(styleQueue);
+      }
+    }
+
+    if (textEmbedded) {
+      // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+  }
+}
+
+function pushStyleImpl(target, props) {
+  target.push(startChunkForTag('style'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('style'));
+  return null;
+}
+
+function pushStyleContents(target, props) {
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+      }
+    }
+  }
+
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  return;
+}
+
+function pushImg(target, props, resumableState, renderState, pictureTagInScope) {
+  const src = props.src,
+        srcSet = props.srcSet;
+
+  if (props.loading !== 'lazy' && (src || srcSet) && (typeof src === 'string' || src == null) && (typeof srcSet === 'string' || srcSet == null) && props.fetchPriority !== 'low' && pictureTagInScope === false && // We exclude data URIs in src and srcSet since these should not be preloaded
+  !(typeof src === 'string' && src[4] === ':' && (src[0] === 'd' || src[0] === 'D') && (src[1] === 'a' || src[1] === 'A') && (src[2] === 't' || src[2] === 'T') && (src[3] === 'a' || src[3] === 'A')) && !(typeof srcSet === 'string' && srcSet[4] === ':' && (srcSet[0] === 'd' || srcSet[0] === 'D') && (srcSet[1] === 'a' || srcSet[1] === 'A') && (srcSet[2] === 't' || srcSet[2] === 'T') && (srcSet[3] === 'a' || srcSet[3] === 'A'))) {
+    // We have a suspensey image and ought to preload it to optimize the loading of display blocking
+    // resumableState.
+    const sizes = typeof props.sizes === 'string' ? props.sizes : undefined;
+    const key = getImageResourceKey(src, srcSet, sizes);
+    const promotablePreloads = renderState.preloads.images;
+    let resource = promotablePreloads.get(key);
+
+    if (resource) {
+      // We consider whether this preload can be promoted to higher priority flushing queue.
+      // The only time a resource will exist here is if it was created during this render
+      // and was not already in the high priority queue.
+      if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+        // Delete the resource from the map since we are promoting it and don't want to
+        // reenter this branch in a second pass for duplicate img hrefs.
+        promotablePreloads.delete(key); // $FlowFixMe - Flow should understand that this is a Resource if the condition was true
+
+        renderState.highImagePreloads.add(resource);
+      }
+    } else if (!resumableState.imageResources.hasOwnProperty(key)) {
+      // We must construct a new preload resource
+      resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+      const crossOrigin = getCrossOriginString(props.crossOrigin);
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // this is a hueristic similar to capping element preloads to 10 unless explicitly
+      // fetchPriority="high". We use length here which means it will fit fewer images when
+      // the urls are long and more when short. arguably byte size is a better hueristic because
+      // it directly translates to how much we send down before content is actually seen.
+      // We could unify the counts and also make it so the total is tracked regardless of
+      // flushing output but since the headers are likely to be go earlier than content
+      // they don't really conflict so for now I've kept them separate
+      props.fetchPriority === 'high' || headers.highImagePreloads.length < 500) && ( // We manually construct the options for the preload only from strings. We don't want to pollute
+      // the params list with arbitrary props and if we copied everything over as it we might get
+      // coercion errors. We have checks for this in Dev but it seems safer to just only accept values
+      // that are strings
+      header = getPreloadAsHeader(src, 'image', {
+        imageSrcSet: props.srcSet,
+        imageSizes: props.sizes,
+        crossOrigin,
+        integrity: props.integrity,
+        nonce: props.nonce,
+        type: props.type,
+        fetchPriority: props.fetchPriority,
+        referrerPolicy: props.refererPolicy
+      }), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // If we postpone in the shell we will still emit this preload so we track
+        // it to make sure we don't reset it.
+        renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+        if (headers.highImagePreloads) {
+          headers.highImagePreloads += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.highImagePreloads += header;
+      } else {
+        resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preload',
+          as: 'image',
+          // There is a bug in Safari where imageSrcSet is not respected on preload links
+          // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+          // This harms older browers that do not support imageSrcSet by making their preloads not work
+          // but this population is shrinking fast and is already small so we accept this tradeoff.
+          href: srcSet ? undefined : src,
+          imageSrcSet: srcSet,
+          imageSizes: sizes,
+          crossOrigin: crossOrigin,
+          integrity: props.integrity,
+          type: props.type,
+          fetchPriority: props.fetchPriority,
+          referrerPolicy: props.referrerPolicy
+        });
+
+        if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+          renderState.highImagePreloads.add(resource);
+        } else {
+          renderState.bulkPreloads.add(resource); // We can bump the priority up if the same img is rendered later
+          // with fetchPriority="high"
+
+          promotablePreloads.set(key, resource);
+        }
+      }
+    }
+  }
+
+  return pushSelfClosing(target, props, 'img');
+}
+
+function pushSelfClosing(target, props, tag) {
+  target.push(startChunkForTag(tag));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(399, tag));
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStartMenuItem(target, props) {
+  target.push(startChunkForTag('menuitem'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(400));
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  return null;
+}
+
+function pushTitle(target, props, renderState, insertionMode, noscriptTagInScope) {
+
+  {
+    if (insertionMode !== SVG_MODE && !noscriptTagInScope && props.itemProp == null) {
+      pushTitleImpl(renderState.hoistableChunks, props);
+      return null;
+    } else {
+      return pushTitleImpl(target, props);
+    }
+  }
+}
+
+function pushTitleImpl(target, props) {
+  target.push(startChunkForTag('title'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('title'));
+  return null;
+}
+
+function pushStartHead(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode < HTML_MODE && renderState.headChunks === null) {
+      // This <head> is the Document.head and should be part of the preamble
+      renderState.headChunks = [];
+      return pushStartGenericElement(renderState.headChunks, props, 'head');
+    } else {
+      // This <head> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'head');
+    }
+  }
+}
+
+function pushStartHtml(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode === ROOT_HTML_MODE && renderState.htmlChunks === null) {
+      // This <html> is the Document.documentElement and should be part of the preamble
+      renderState.htmlChunks = [doctypeChunk];
+      return pushStartGenericElement(renderState.htmlChunks, props, 'html');
+    } else {
+      // This <html> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'html');
+    }
+  }
+}
+
+function pushScript(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const asyncProp = props.async;
+
+    if (typeof props.src !== 'string' || !props.src || !(asyncProp && typeof asyncProp !== 'function' && typeof asyncProp !== 'symbol') || props.onLoad || props.onError || insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      // This script will not be a resource, we bailout early and emit it in place.
+      return pushScriptImpl(target, props);
+    }
+
+    const src = props.src;
+    const key = getResourceKey(src); // We can make this <script> into a ScriptResource
+
+    let resources, preloads;
+
+    if (props.type === 'module') {
+      resources = resumableState.moduleScriptResources;
+      preloads = renderState.preloads.moduleScripts;
+    } else {
+      resources = resumableState.scriptResources;
+      preloads = renderState.preloads.scripts;
+    }
+
+    const hasKey = resources.hasOwnProperty(key);
+    const resourceState = hasKey ? resources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resources[key] = EXISTS;
+      let scriptProps = props;
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          scriptProps = assign({}, props);
+          adoptPreloadCredentials(scriptProps, preloadState);
+        }
+
+        const preloadResource = preloads.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, scriptProps);
+    }
+
+    if (textEmbedded) {
+      // This script follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+
+    return null;
+  }
+}
+
+function pushScriptImpl(target, props) {
+  target.push(startChunkForTag('script'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+  }
+
+  target.push(endChunkForTag('script'));
+  return null;
+}
+
+function pushStartGenericElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartCustomElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      let propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      let attributeName = propKey;
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'style':
+          pushStyleAttribute(target, propValue);
+          break;
+
+        case 'suppressContentEditableWarning':
+        case 'suppressHydrationWarning':
+          // Ignored. These are built-in to React on the client.
+          break;
+
+        case 'className':
+          {
+            // className gets rendered as class on the client, so it should be
+            // rendered as class on the server.
+            attributeName = 'class';
+          }
+
+        // intentional fallthrough
+
+        default:
+          if (isAttributeNameSafe(propKey) && typeof propValue !== 'function' && typeof propValue !== 'symbol') {
+            {
+              if (propValue === false) {
+                continue;
+              } else if (propValue === true) {
+                propValue = '';
+              } else if (typeof propValue === 'object') {
+                continue;
+              }
+            }
+
+            target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(propValue)), attributeEnd);
+          }
+
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const leadingNewline = stringToPrecomputedChunk('\n');
+
+function pushStartPreformattedElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag); // text/html ignores the first character in these tags if it's a newline
+  // Prefer to break application/xml over text/html (for now) by adding
+  // a newline specifically to get eaten by the parser. (Alternately for
+  // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+  // \r is normalized out by HTMLTextAreaElement#value.)
+  // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+  // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+  // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+  // See: Parsing of "textarea" "listing" and "pre" elements
+  //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+  // TODO: This doesn't deal with the case where the child is an array
+  // or component that returns a string.
+
+  if (innerHTML != null) {
+    if (children != null) {
+      throw Error(formatProdErrorMessage(60));
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw Error(formatProdErrorMessage(61));
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+      if (typeof html === 'string' && html.length > 0 && html[0] === '\n') {
+        target.push(leadingNewline, stringToChunk(html));
+      } else {
+
+        target.push(stringToChunk('' + html));
+      }
+    }
+  }
+
+  if (typeof children === 'string' && children[0] === '\n') {
+    target.push(leadingNewline);
+  }
+
+  return children;
+} // We accept any tag to be rendered but since this gets injected into arbitrary
+// HTML, we want to make sure that it's a safe tag.
+// http://www.w3.org/TR/REC-xml/#NT-Name
+
+
+const VALID_TAG_REGEX = /^[a-zA-Z][a-zA-Z:_\.\-\d]*$/; // Simplified subset
+
+const validatedTagCache = new Map();
+
+function startChunkForTag(tag) {
+  let tagStartChunk = validatedTagCache.get(tag);
+
+  if (tagStartChunk === undefined) {
+    if (!VALID_TAG_REGEX.test(tag)) {
+      throw Error(formatProdErrorMessage(65, tag));
+    }
+
+    tagStartChunk = stringToPrecomputedChunk('<' + tag);
+    validatedTagCache.set(tag, tagStartChunk);
+  }
+
+  return tagStartChunk;
+}
+function pushStartInstance(target, type, props, resumableState, renderState, formatContext, textEmbedded) {
+
+  switch (type) {
+    case 'div':
+    case 'span':
+    case 'svg':
+    case 'path':
+    case 'a':
+    case 'g':
+    case 'p':
+    case 'li':
+      // Fast track very common tags
+      break;
+    // Special tags
+
+    case 'select':
+      return pushStartSelect(target, props);
+
+    case 'option':
+      return pushStartOption(target, props, formatContext);
+
+    case 'textarea':
+      return pushStartTextArea(target, props);
+
+    case 'input':
+      return pushInput(target, props, resumableState, renderState);
+
+    case 'button':
+      return pushStartButton(target, props, resumableState, renderState);
+
+    case 'form':
+      return pushStartForm(target, props, resumableState, renderState);
+
+    case 'menuitem':
+      return pushStartMenuItem(target, props);
+
+    case 'title':
+      return pushTitle(target, props, renderState, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'link':
+      return pushLink(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'script':
+      return pushScript(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'style':
+      return pushStyle(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'meta':
+      return pushMeta(target, props, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+    // Newline eating tags
+
+    case 'listing':
+    case 'pre':
+      {
+        return pushStartPreformattedElement(target, props, type);
+      }
+
+    case 'img':
+      {
+        return pushImg(target, props, resumableState, renderState, !!(formatContext.tagScope & PICTURE_SCOPE)) ;
+      }
+    // Omitted close tags
+
+    case 'base':
+    case 'area':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'keygen':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        return pushSelfClosing(target, props, type);
+      }
+    // These are reserved SVG and MathML elements, that are never custom elements.
+    // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+
+    case 'annotation-xml':
+    case 'color-profile':
+    case 'font-face':
+    case 'font-face-src':
+    case 'font-face-uri':
+    case 'font-face-format':
+    case 'font-face-name':
+    case 'missing-glyph':
+      {
+        break;
+      }
+    // Preamble start tags
+
+    case 'head':
+      return pushStartHead(target, props, renderState, formatContext.insertionMode);
+
+    case 'html':
+      {
+        return pushStartHtml(target, props, renderState, formatContext.insertionMode);
+      }
+
+    default:
+      {
+        if (type.indexOf('-') !== -1) {
+          // Custom element
+          return pushStartCustomElement(target, props, type);
+        }
+      }
+  } // Generic element
+
+
+  return pushStartGenericElement(target, props, type);
+}
+const endTagCache = new Map();
+
+function endChunkForTag(tag) {
+  let chunk = endTagCache.get(tag);
+
+  if (chunk === undefined) {
+    chunk = stringToPrecomputedChunk('</' + tag + '>');
+    endTagCache.set(tag, chunk);
+  }
+
+  return chunk;
+}
+
+function pushEndInstance(target, type, props, resumableState, formatContext) {
+  switch (type) {
+    // When float is on we expect title and script tags to always be pushed in
+    // a unit and never return children. when we end up pushing the end tag we
+    // want to ensure there is no extra closing tag pushed
+    case 'title':
+    case 'style':
+    case 'script':
+    // Omitted close tags
+    // TODO: Instead of repeating this switch we could try to pass a flag from above.
+    // That would require returning a tuple. Which might be ok if it gets inlined.
+
+    case 'area':
+    case 'base':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'img':
+    case 'input':
+    case 'keygen':
+    case 'link':
+    case 'meta':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        // No close tag needed.
+        return;
+      }
+    // Postamble end tags
+    // When float is enabled we omit the end tags for body and html when
+    // they represent the Document.body and Document.documentElement Nodes.
+    // This is so we can withhold them until the postamble when we know
+    // we won't emit any more tags
+
+    case 'body':
+      {
+        if (formatContext.insertionMode <= HTML_HTML_MODE) {
+          resumableState.hasBody = true;
+          return;
+        }
+
+        break;
+      }
+
+    case 'html':
+      if (formatContext.insertionMode === ROOT_HTML_MODE) {
+        resumableState.hasHtml = true;
+        return;
+      }
+
+      break;
+  }
+
+  target.push(endChunkForTag(type));
+}
+
+function writeBootstrap(destination, renderState, resumableState) {
+  resumableState.bootstrapScriptContent = undefined;
+  resumableState.bootstrapScripts = undefined;
+  resumableState.bootstrapModules = undefined;
+  const bootstrapChunks = renderState.bootstrapChunks;
+  let i = 0;
+
+  for (; i < bootstrapChunks.length - 1; i++) {
+    writeChunk(destination, bootstrapChunks[i]);
+  }
+
+  if (i < bootstrapChunks.length) {
+    const lastChunk = bootstrapChunks[i];
+    bootstrapChunks.length = 0;
+    return writeChunkAndReturn(destination, lastChunk);
+  }
+
+  return true;
+}
+
+function writeCompletedRoot(destination, renderState, resumableState) {
+  return writeBootstrap(destination, renderState, resumableState);
+} // Structural Nodes
+// A placeholder is a node inside a hidden partial tree that can be filled in later, but before
+// display. It's never visible to users. We use the template tag because it can be used in every
+// type of parent. <script> tags also work in every other tag except <colgroup>.
+
+const placeholder1 = stringToPrecomputedChunk('<template id="');
+const placeholder2 = stringToPrecomputedChunk('"></template>');
+function writePlaceholder(destination, renderState, id) {
+  writeChunk(destination, placeholder1);
+  writeChunk(destination, renderState.placeholderPrefix);
+  const formattedID = stringToChunk(id.toString(16));
+  writeChunk(destination, formattedID);
+  return writeChunkAndReturn(destination, placeholder2);
+} // Suspense boundaries are encoded as comments.
+
+const startCompletedSuspenseBoundary = stringToPrecomputedChunk('<!--$-->');
+const startPendingSuspenseBoundary1 = stringToPrecomputedChunk('<!--$?--><template id="');
+const startPendingSuspenseBoundary2 = stringToPrecomputedChunk('"></template>');
+const startClientRenderedSuspenseBoundary = stringToPrecomputedChunk('<!--$!-->');
+const endSuspenseBoundary = stringToPrecomputedChunk('<!--/$-->');
+const clientRenderedSuspenseBoundaryError1 = stringToPrecomputedChunk('<template');
+const clientRenderedSuspenseBoundaryErrorAttrInterstitial = stringToPrecomputedChunk('"');
+const clientRenderedSuspenseBoundaryError1A = stringToPrecomputedChunk(' data-dgst="');
+const clientRenderedSuspenseBoundaryError2 = stringToPrecomputedChunk('></template>');
+function writeStartCompletedSuspenseBoundary$1(destination, renderState) {
+  return writeChunkAndReturn(destination, startCompletedSuspenseBoundary);
+}
+function writeStartPendingSuspenseBoundary(destination, renderState, id) {
+  writeChunk(destination, startPendingSuspenseBoundary1);
+
+  if (id === null) {
+    throw Error(formatProdErrorMessage(395));
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+  return writeChunkAndReturn(destination, startPendingSuspenseBoundary2);
+}
+function writeStartClientRenderedSuspenseBoundary$1(destination, renderState, errorDigest, errorMesssage, errorComponentStack) {
+  let result;
+  result = writeChunkAndReturn(destination, startClientRenderedSuspenseBoundary);
+  writeChunk(destination, clientRenderedSuspenseBoundaryError1);
+
+  if (errorDigest) {
+    writeChunk(destination, clientRenderedSuspenseBoundaryError1A);
+    writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest)));
+    writeChunk(destination, clientRenderedSuspenseBoundaryErrorAttrInterstitial);
+  }
+
+  result = writeChunkAndReturn(destination, clientRenderedSuspenseBoundaryError2);
+  return result;
+}
+function writeEndCompletedSuspenseBoundary$1(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndPendingSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndClientRenderedSuspenseBoundary$1(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+const startSegmentHTML = stringToPrecomputedChunk('<div hidden id="');
+const startSegmentHTML2 = stringToPrecomputedChunk('">');
+const endSegmentHTML = stringToPrecomputedChunk('</div>');
+const startSegmentSVG = stringToPrecomputedChunk('<svg aria-hidden="true" style="display:none" id="');
+const startSegmentSVG2 = stringToPrecomputedChunk('">');
+const endSegmentSVG = stringToPrecomputedChunk('</svg>');
+const startSegmentMathML = stringToPrecomputedChunk('<math aria-hidden="true" style="display:none" id="');
+const startSegmentMathML2 = stringToPrecomputedChunk('">');
+const endSegmentMathML = stringToPrecomputedChunk('</math>');
+const startSegmentTable = stringToPrecomputedChunk('<table hidden id="');
+const startSegmentTable2 = stringToPrecomputedChunk('">');
+const endSegmentTable = stringToPrecomputedChunk('</table>');
+const startSegmentTableBody = stringToPrecomputedChunk('<table hidden><tbody id="');
+const startSegmentTableBody2 = stringToPrecomputedChunk('">');
+const endSegmentTableBody = stringToPrecomputedChunk('</tbody></table>');
+const startSegmentTableRow = stringToPrecomputedChunk('<table hidden><tr id="');
+const startSegmentTableRow2 = stringToPrecomputedChunk('">');
+const endSegmentTableRow = stringToPrecomputedChunk('</tr></table>');
+const startSegmentColGroup = stringToPrecomputedChunk('<table hidden><colgroup id="');
+const startSegmentColGroup2 = stringToPrecomputedChunk('">');
+const endSegmentColGroup = stringToPrecomputedChunk('</colgroup></table>');
+function writeStartSegment(destination, renderState, formatContext, id) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        writeChunk(destination, startSegmentHTML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentHTML2);
+      }
+
+    case SVG_MODE:
+      {
+        writeChunk(destination, startSegmentSVG);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentSVG2);
+      }
+
+    case MATHML_MODE:
+      {
+        writeChunk(destination, startSegmentMathML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentMathML2);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        writeChunk(destination, startSegmentTable);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTable2);
+      }
+    // TODO: For the rest of these, there will be extra wrapper nodes that never
+    // get deleted from the document. We need to delete the table too as part
+    // of the injected scripts. They are invisible though so it's not too terrible
+    // and it's kind of an edge case to suspend in a table. Totally supported though.
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        writeChunk(destination, startSegmentTableBody);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableBody2);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        writeChunk(destination, startSegmentTableRow);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableRow2);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        writeChunk(destination, startSegmentColGroup);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentColGroup2);
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(397));
+      }
+  }
+}
+function writeEndSegment(destination, formatContext) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentHTML);
+      }
+
+    case SVG_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentSVG);
+      }
+
+    case MATHML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentMathML);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTable);
+      }
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableBody);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableRow);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentColGroup);
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(397));
+      }
+  }
+}
+const completeSegmentScript1Full = stringToPrecomputedChunk(completeSegment + '$RS("');
+const completeSegmentScript1Partial = stringToPrecomputedChunk('$RS("');
+const completeSegmentScript2 = stringToPrecomputedChunk('","');
+const completeSegmentScriptEnd = stringToPrecomputedChunk('")</script>');
+const completeSegmentData1 = stringToPrecomputedChunk('<template data-rsi="" data-sid="');
+const completeSegmentData2 = stringToPrecomputedChunk('" data-pid="');
+const completeSegmentDataEnd = dataElementQuotedEnd;
+function writeCompletedSegmentInstruction(destination, resumableState, renderState, contentSegmentID) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentCompleteSegmentFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentCompleteSegmentFunction;
+      writeChunk(destination, completeSegmentScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, completeSegmentScript1Partial);
+    }
+  } else {
+    writeChunk(destination, completeSegmentData1);
+  } // Write function arguments, which are string literals
+
+
+  writeChunk(destination, renderState.segmentPrefix);
+  const formattedID = stringToChunk(contentSegmentID.toString(16));
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    writeChunk(destination, completeSegmentScript2);
+  } else {
+    writeChunk(destination, completeSegmentData2);
+  }
+
+  writeChunk(destination, renderState.placeholderPrefix);
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    return writeChunkAndReturn(destination, completeSegmentScriptEnd);
+  } else {
+    return writeChunkAndReturn(destination, completeSegmentDataEnd);
+  }
+}
+const completeBoundaryScript1Full = stringToPrecomputedChunk(completeBoundary + '$RC("');
+const completeBoundaryScript1Partial = stringToPrecomputedChunk('$RC("');
+const completeBoundaryWithStylesScript1FullBoth = stringToPrecomputedChunk(completeBoundary + completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1FullPartial = stringToPrecomputedChunk(completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1Partial = stringToPrecomputedChunk('$RR("');
+const completeBoundaryScript2 = stringToPrecomputedChunk('","');
+const completeBoundaryScript3a = stringToPrecomputedChunk('",');
+const completeBoundaryScript3b = stringToPrecomputedChunk('"');
+const completeBoundaryScriptEnd = stringToPrecomputedChunk(')</script>');
+const completeBoundaryData1 = stringToPrecomputedChunk('<template data-rci="" data-bid="');
+const completeBoundaryWithStylesData1 = stringToPrecomputedChunk('<template data-rri="" data-bid="');
+const completeBoundaryData2 = stringToPrecomputedChunk('" data-sid="');
+const completeBoundaryData3a = stringToPrecomputedChunk('" data-sty="');
+const completeBoundaryDataEnd = dataElementQuotedEnd;
+function writeCompletedBoundaryInstruction(destination, resumableState, renderState, id, boundaryResources) {
+  let requiresStyleInsertion;
+
+  {
+    requiresStyleInsertion = renderState.stylesToHoist; // If necessary stylesheets will be flushed with this instruction.
+    // Any style tags not yet hoisted in the Document will also be hoisted.
+    // We reset this state since after this instruction executes all styles
+    // up to this point will have been hoisted
+
+    renderState.stylesToHoist = false;
+  }
+
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if (requiresStyleInsertion) {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction | SentCompleteBoundaryFunction;
+        writeChunk(destination, clonePrecomputedChunk(completeBoundaryWithStylesScript1FullBoth));
+      } else if ((resumableState.instructions & SentStyleInsertionFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction;
+        writeChunk(destination, completeBoundaryWithStylesScript1FullPartial);
+      } else {
+        writeChunk(destination, completeBoundaryWithStylesScript1Partial);
+      }
+    } else {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentCompleteBoundaryFunction;
+        writeChunk(destination, completeBoundaryScript1Full);
+      } else {
+        writeChunk(destination, completeBoundaryScript1Partial);
+      }
+    }
+  } else {
+    if (requiresStyleInsertion) {
+      writeChunk(destination, completeBoundaryWithStylesData1);
+    } else {
+      writeChunk(destination, completeBoundaryData1);
+    }
+  }
+
+  const idChunk = stringToChunk(id.toString(16));
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, idChunk); // Write function arguments, which are string and array literals
+
+  if (scriptFormat) {
+    writeChunk(destination, completeBoundaryScript2);
+  } else {
+    writeChunk(destination, completeBoundaryData2);
+  }
+
+  writeChunk(destination, renderState.segmentPrefix);
+  writeChunk(destination, idChunk);
+
+  if (requiresStyleInsertion) {
+    // Script and data writers must format this differently:
+    //  - script writer emits an array literal, whose string elements are
+    //    escaped for javascript  e.g. ["A", "B"]
+    //  - data writer emits a string literal, which is escaped as html
+    //    e.g. [&#34;A&#34;, &#34;B&#34;]
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3a); // boundaryResources encodes an array literal
+
+      writeStyleResourceDependenciesInJS(destination, boundaryResources);
+    } else {
+      writeChunk(destination, completeBoundaryData3a);
+      writeStyleResourceDependenciesInAttr(destination, boundaryResources);
+    }
+  } else {
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3b);
+    }
+  }
+
+  let writeMore;
+
+  if (scriptFormat) {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryScriptEnd);
+  } else {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryDataEnd);
+  }
+
+  return writeBootstrap(destination, renderState, resumableState) && writeMore;
+}
+const clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
+const clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
+const clientRenderScript1A = stringToPrecomputedChunk('"');
+const clientRenderErrorScriptArgInterstitial = stringToPrecomputedChunk(',');
+const clientRenderScriptEnd = stringToPrecomputedChunk(')</script>');
+const clientRenderData1 = stringToPrecomputedChunk('<template data-rxi="" data-bid="');
+const clientRenderData2 = stringToPrecomputedChunk('" data-dgst="');
+const clientRenderData3 = stringToPrecomputedChunk('" data-msg="');
+const clientRenderData4 = stringToPrecomputedChunk('" data-stck="');
+const clientRenderDataEnd = dataElementQuotedEnd;
+function writeClientRenderBoundaryInstruction(destination, resumableState, renderState, id, errorDigest, errorMessage, errorComponentStack) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentClientRenderFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentClientRenderFunction;
+      writeChunk(destination, clientRenderScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, clientRenderScript1Partial);
+    }
+  } else {
+    // <template data-rxi="" data-bid="
+    writeChunk(destination, clientRenderData1);
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+
+  if (scriptFormat) {
+    // " needs to be inserted for scripts, since ArgInterstitual does not contain
+    // leading or trailing quotes
+    writeChunk(destination, clientRenderScript1A);
+  }
+
+  if (errorDigest || errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorDigest || '')));
+    } else {
+      // " data-dgst="HTMLString
+      writeChunk(destination, clientRenderData2);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest || '')));
+    }
+  }
+
+  if (errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorMessage || '')));
+    } else {
+      // " data-msg="HTMLString
+      writeChunk(destination, clientRenderData3);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorMessage || '')));
+    }
+  }
+
+  if (errorComponentStack) {
+    // ,"JSONString"
+    if (scriptFormat) {
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorComponentStack)));
+    } else {
+      // " data-stck="HTMLString
+      writeChunk(destination, clientRenderData4);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorComponentStack)));
+    }
+  }
+
+  if (scriptFormat) {
+    // ></script>
+    return writeChunkAndReturn(destination, clientRenderScriptEnd);
+  } else {
+    // "></template>
+    return writeChunkAndReturn(destination, clientRenderDataEnd);
+  }
+}
+const regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
+
+function escapeJSStringsForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInInstructionScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const regexForJSStringsInScripts = /[&><\u2028\u2029]/g;
+
+function escapeJSObjectForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '&':
+        return '\\u0026';
+
+      case '>':
+        return '\\u003e';
+
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const lateStyleTagResourceOpen1 = stringToPrecomputedChunk('<style media="not all" data-precedence="');
+const lateStyleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const lateStyleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const lateStyleTagTemplateClose = stringToPrecomputedChunk('</style>'); // Tracks whether the boundary currently flushing is flushign style tags or has any
+// stylesheet dependencies not flushed in the Preamble.
+
+let currentlyRenderingBoundaryHasStylesToHoist = false; // Acts as a return value for the forEach execution of style tag flushing.
+
+let destinationHasCapacity = true;
+
+function flushStyleTagsLateForBoundary(styleQueue) {
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs;
+
+  let i = 0;
+
+  if (hrefs.length) {
+    writeChunk(this, lateStyleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    writeChunk(this, lateStyleTagResourceOpen2);
+
+    for (; i < hrefs.length - 1; i++) {
+      writeChunk(this, hrefs[i]);
+      writeChunk(this, spaceSeparator);
+    }
+
+    writeChunk(this, hrefs[i]);
+    writeChunk(this, lateStyleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    destinationHasCapacity = writeChunkAndReturn(this, lateStyleTagTemplateClose); // We wrote style tags for this boundary and we may need to emit a script
+    // to hoist them.
+
+    currentlyRenderingBoundaryHasStylesToHoist = true; // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function hasStylesToHoist(stylesheet) {
+  // We need to reveal boundaries with styles whenever a stylesheet it depends on is either
+  // not flushed or flushed after the preamble (shell).
+  if (stylesheet.state !== PREAMBLE) {
+    currentlyRenderingBoundaryHasStylesToHoist = true;
+    return true;
+  }
+
+  return false;
+}
+
+function writeResourcesForBoundary(destination, boundaryResources, renderState) {
+  // Reset these on each invocation, they are only safe to read in this function
+  currentlyRenderingBoundaryHasStylesToHoist = false;
+  destinationHasCapacity = true; // Flush style tags for each precedence this boundary depends on
+
+  boundaryResources.styles.forEach(flushStyleTagsLateForBoundary, destination); // Determine if this boundary has stylesheets that need to be awaited upon completion
+
+  boundaryResources.stylesheets.forEach(hasStylesToHoist);
+
+  if (currentlyRenderingBoundaryHasStylesToHoist) {
+    renderState.stylesToHoist = true;
+  }
+
+  return destinationHasCapacity;
+}
+
+function flushResource(resource) {
+  for (let i = 0; i < resource.length; i++) {
+    writeChunk(this, resource[i]);
+  }
+
+  resource.length = 0;
+}
+
+const stylesheetFlushingQueue = [];
+
+function flushStyleInPreamble(stylesheet, key, map) {
+  // We still need to encode stylesheet chunks
+  // because unlike most Hoistables and Resources we do not eagerly encode
+  // them during render. This is because if we flush late we have to send a
+  // different encoding and we don't want to encode multiple times
+  pushLinkImpl(stylesheetFlushingQueue, stylesheet.props);
+
+  for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+    writeChunk(this, stylesheetFlushingQueue[i]);
+  }
+
+  stylesheetFlushingQueue.length = 0;
+  stylesheet.state = PREAMBLE;
+}
+
+const styleTagResourceOpen1 = stringToPrecomputedChunk('<style data-precedence="');
+const styleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const spaceSeparator = stringToPrecomputedChunk(' ');
+const styleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const styleTagResourceClose = stringToPrecomputedChunk('</style>');
+
+function flushStylesInPreamble(styleQueue, precedence) {
+  const hasStylesheets = styleQueue.sheets.size > 0;
+  styleQueue.sheets.forEach(flushStyleInPreamble, this);
+  styleQueue.sheets.clear();
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs; // If we don't emit any stylesheets at this precedence we still need to maintain the precedence
+  // order so even if there are no rules for style tags at this precedence we emit an empty style
+  // tag with the data-precedence attribute
+
+  if (!hasStylesheets || hrefs.length) {
+    writeChunk(this, styleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    let i = 0;
+
+    if (hrefs.length) {
+      writeChunk(this, styleTagResourceOpen2);
+
+      for (; i < hrefs.length - 1; i++) {
+        writeChunk(this, hrefs[i]);
+        writeChunk(this, spaceSeparator);
+      }
+
+      writeChunk(this, hrefs[i]);
+    }
+
+    writeChunk(this, styleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    writeChunk(this, styleTagResourceClose); // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function preloadLateStyle(stylesheet) {
+  if (stylesheet.state === PENDING$1) {
+    stylesheet.state = PRELOADED;
+    const preloadProps = preloadAsStylePropsFromProps(stylesheet.props.href, stylesheet.props);
+    pushLinkImpl(stylesheetFlushingQueue, preloadProps);
+
+    for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+      writeChunk(this, stylesheetFlushingQueue[i]);
+    }
+
+    stylesheetFlushingQueue.length = 0;
+  }
+}
+
+function preloadLateStyles(styleQueue) {
+  styleQueue.sheets.forEach(preloadLateStyle, this);
+  styleQueue.sheets.clear();
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+
+function writePreamble(destination, resumableState, renderState, willFlushAllSegments) {
+  // This function must be called exactly once on every request
+  if (!willFlushAllSegments && renderState.externalRuntimeScript) {
+    // If the root segment is incomplete due to suspended tasks
+    // (e.g. willFlushAllSegments = false) and we are using data
+    // streaming format, ensure the external runtime is sent.
+    // (User code could choose to send this even earlier by calling
+    //  preinit(...), if they know they will suspend).
+    const _renderState$external = renderState.externalRuntimeScript,
+          src = _renderState$external.src,
+          chunks = _renderState$external.chunks;
+    internalPreinitScript(resumableState, renderState, src, chunks);
+  }
+
+  const htmlChunks = renderState.htmlChunks;
+  const headChunks = renderState.headChunks;
+  let i = 0; // Emit open tags before Hoistables and Resources
+
+  if (htmlChunks) {
+    // We have an <html> to emit as part of the preamble
+    for (i = 0; i < htmlChunks.length; i++) {
+      writeChunk(destination, htmlChunks[i]);
+    }
+
+    if (headChunks) {
+      for (i = 0; i < headChunks.length; i++) {
+        writeChunk(destination, headChunks[i]);
+      }
+    } else {
+      // We did not render a head but we emitted an <html> so we emit one now
+      writeChunk(destination, startChunkForTag('head'));
+      writeChunk(destination, endOfStartTag);
+    }
+  } else if (headChunks) {
+    // We do not have an <html> but we do have a <head>
+    for (i = 0; i < headChunks.length; i++) {
+      writeChunk(destination, headChunks[i]);
+    }
+  } // Emit high priority Hoistables
+
+
+  const charsetChunks = renderState.charsetChunks;
+
+  for (i = 0; i < charsetChunks.length; i++) {
+    writeChunk(destination, charsetChunks[i]);
+  }
+
+  charsetChunks.length = 0; // emit preconnect resources
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Flush unblocked stylesheets by precedence
+
+  renderState.styles.forEach(flushStylesInPreamble, destination);
+  const importMapChunks = renderState.importMapChunks;
+
+  for (i = 0; i < importMapChunks.length; i++) {
+    writeChunk(destination, importMapChunks[i]);
+  }
+
+  importMapChunks.length = 0;
+  renderState.bootstrapScripts.forEach(flushResource, destination);
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0; // Flush closing head if necessary
+
+  if (htmlChunks && headChunks === null) {
+    // We have an <html> rendered but no <head> rendered. We however inserted
+    // a <head> up above so we need to emit the </head> now. This is safe because
+    // if the main content contained the </head> it would also have provided a
+    // <head>. This means that all the content inside <html> is either <body> or
+    // invalid HTML
+    writeChunk(destination, endChunkForTag('head'));
+  }
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+function writeHoistables(destination, resumableState, renderState) {
+  let i = 0; // Emit high priority Hoistables
+  // We omit charsetChunks because we have already sent the shell and if it wasn't
+  // already sent it is too late now.
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Preload any stylesheets. these will emit in a render instruction that follows this
+  // but we want to kick off preloading as soon as possible
+
+  renderState.styles.forEach(preloadLateStyles, destination); // We only hoist importmaps that are configured through createResponse and that will
+  // always flush in the preamble. Generally we don't expect people to render them as
+  // tags when using React but if you do they are going to be treated like regular inline
+  // scripts and flush after other hoistables which is problematic
+  // bootstrap scripts should flush above script priority but these can only flush in the preamble
+  // so we elide the code here for performance
+
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0;
+}
+function writePostamble(destination, resumableState) {
+  if (resumableState.hasBody) {
+    writeChunk(destination, endChunkForTag('body'));
+  }
+
+  if (resumableState.hasHtml) {
+    writeChunk(destination, endChunkForTag('html'));
+  }
+}
+const arrayFirstOpenBracket = stringToPrecomputedChunk('[');
+const arraySubsequentOpenBracket = stringToPrecomputedChunk(',[');
+const arrayInterstitial = stringToPrecomputedChunk(',');
+const arrayCloseBracket = stringToPrecomputedChunk(']'); // This function writes a 2D array of strings to be embedded in javascript.
+// E.g.
+//  [["JS_escaped_string1", "JS_escaped_string2"]]
+
+function writeStyleResourceDependenciesInJS(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInJS(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInJS(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInJS(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+}
+
+function writeStyleResourceDependencyInJS(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedPrecedence)));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(399, 'link'));
+
+        default:
+          writeStyleResourceAttributeInJS(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInJS(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeName)));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeValue)));
+} // This function writes a 2D array of strings to be embedded in an attribute
+// value and read with JSON.parse in ReactDOMServerExternalRuntime.js
+// E.g.
+//  [[&quot;JSON_escaped_string1&quot;, &quot;JSON_escaped_string2&quot;]]
+
+
+function writeStyleResourceDependenciesInAttr(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInAttr(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInAttr(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInAttr(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+}
+
+function writeStyleResourceDependencyInAttr(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedPrecedence))));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(399, 'link'));
+
+        default:
+          writeStyleResourceAttributeInAttr(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInAttr(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeName))));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeValue))));
+}
+/**
+ * Resources
+ */
+
+
+const PENDING$1 = 0;
+const PRELOADED = 1;
+const PREAMBLE = 2;
+const LATE = 3;
+function createBoundaryResources() {
+  return {
+    styles: new Set(),
+    stylesheets: new Set()
+  };
+}
+function setCurrentlyRenderingBoundaryResourcesTarget(renderState, boundaryResources) {
+  renderState.boundaryResources = boundaryResources;
+}
+
+function getResourceKey(href) {
+  return href;
+}
+
+function getImageResourceKey(href, imageSrcSet, imageSizes) {
+  if (imageSrcSet) {
+    return imageSrcSet + '\n' + (imageSizes || '');
+  }
+
+  return href;
+}
+
+function prefetchDNS(href) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const key = getResourceKey(href);
+
+    if (!resumableState.dnsResources.hasOwnProperty(key)) {
+      resumableState.dnsResources[key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPrefetchDNSAsHeader(href), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this as resettable in case we are prerendering and postpone in the Shell
+        renderState.resets.dns[key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        // Encode as element
+        const resource = [];
+        pushLinkImpl(resource, {
+          href,
+          rel: 'dns-prefetch'
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preconnect(href, crossOrigin) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const bucket = crossOrigin === 'use-credentials' ? 'credentials' : typeof crossOrigin === 'string' ? 'anonymous' : 'default';
+    const key = getResourceKey(href);
+
+    if (!resumableState.connectResources[bucket].hasOwnProperty(key)) {
+      resumableState.connectResources[bucket][key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPreconnectAsHeader(href, crossOrigin), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this in resettableState in case we are prerending and postpone in the Shell
+        renderState.resets.connect[bucket][key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        const resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preconnect',
+          href,
+          crossOrigin
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preload(href, as, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (as && href) {
+    switch (as) {
+      case 'image':
+        {
+          let imageSrcSet, imageSizes, fetchPriority;
+
+          if (options) {
+            imageSrcSet = options.imageSrcSet;
+            imageSizes = options.imageSizes;
+            fetchPriority = options.fetchPriority;
+          }
+
+          const key = getImageResourceKey(href, imageSrcSet, imageSizes);
+
+          if (resumableState.imageResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && fetchPriority === 'high' && ( // Compute the header since we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit a preload as a header so we
+            // track this to make sure we don't reset it.
+            renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+            if (headers.highImagePreloads) {
+              headers.highImagePreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.highImagePreloads += header;
+          } else {
+            // If we don't have headers to write to we have to encode as elements to flush in the head
+            // When we have imageSrcSet the browser probably cannot load the right version from headers
+            // (this should be verified by testing). For now we assume these need to go in the head
+            // as elements even if headers are available.
+            const resource = [];
+            pushLinkImpl(resource, assign({
+              rel: 'preload',
+              // There is a bug in Safari where imageSrcSet is not respected on preload links
+              // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+              // This harms older browers that do not support imageSrcSet by making their preloads not work
+              // but this population is shrinking fast and is already small so we accept this tradeoff.
+              href: imageSrcSet ? undefined : href,
+              as
+            }, options));
+
+            if (fetchPriority === 'high') {
+              renderState.highImagePreloads.add(resource);
+            } else {
+              renderState.bulkPreloads.add(resource); // Stash the resource in case we need to promote it to higher priority
+              // when an img tag is rendered
+
+              renderState.preloads.images.set(key, resource);
+            }
+          }
+
+          break;
+        }
+
+      case 'style':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.styleResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.styleResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.stylesheets.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          break;
+        }
+
+      case 'script':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.scriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          renderState.preloads.scripts.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.scriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          break;
+        }
+
+      default:
+        {
+          const key = getResourceKey(href);
+          const hasAsType = resumableState.unknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.unknownResources[as] = resources;
+          }
+
+          resources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && as === 'font' && ( // We compute the header here because we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit this preload so we
+            // track it here to prevent it from being reset.
+            renderState.resets.font[key] = PRELOAD_NO_CREDS;
+
+            if (headers.fontPreloads) {
+              headers.fontPreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.fontPreloads += header;
+          } else {
+            // We either don't have headers or we are preloading something that does
+            // not warrant elevated priority so we encode as an element.
+            const resource = [];
+
+            const props = assign({
+              rel: 'preload',
+              href,
+              as
+            }, options);
+
+            pushLinkImpl(resource, props);
+
+            switch (as) {
+              case 'font':
+                renderState.fontPreloads.add(resource);
+                break;
+              // intentional fall through
+
+              default:
+                renderState.bulkPreloads.add(resource);
+            }
+          }
+        }
+    } // If we got this far we created a new resource
+
+
+    flushResources(request);
+  }
+}
+
+function preloadModule(href, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    const key = getResourceKey(href);
+    const as = options && typeof options.as === 'string' ? options.as : 'script';
+    let resource;
+
+    switch (as) {
+      case 'script':
+        {
+          if (resumableState.moduleScriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resource = [];
+          resumableState.moduleScriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.moduleScripts.set(key, resource);
+          break;
+        }
+
+      default:
+        {
+          const hasAsType = resumableState.moduleUnknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.moduleUnknownResources[as] = resources;
+          }
+
+          resource = [];
+          resources[key] = PRELOAD_NO_CREDS;
+        }
+    }
+
+    pushLinkImpl(resource, assign({
+      rel: 'modulepreload',
+      href
+    }, options));
+    renderState.bulkPreloads.add(resource); // If we got this far we created a new resource
+
+    flushResources(request);
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    precedence = precedence || 'default';
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+      // to create a StyleQueue
+
+      if (!styleQueue) {
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      }
+
+      const resource = {
+        state: PENDING$1,
+        props: assign({
+          rel: 'stylesheet',
+          href,
+          'data-precedence': precedence
+        }, options)
+      };
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(resource.props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.stylesheets.get(key);
+
+        if (preloadResource && preloadResource.length > 0) {
+          // The Preload for this resource was created in this render pass and has not flushed yet so
+          // we need to clear it to avoid it flushing.
+          preloadResource.length = 0;
+        } else {
+          // Either the preload resource from this render already flushed in this render pass
+          // or the preload flushed in a prior pass (prerender). In either case we need to mark
+          // this resource as already having been preloaded.
+          resource.state = PRELOADED;
+        }
+      } // We add the newly created resource to our StyleQueue and if necessary
+      // track the resource with the currently rendering boundary
+
+
+      styleQueue.sheets.set(key, resource); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+  }
+}
+
+function preinitScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.scriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.scriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.scriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.scripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+}
+
+function preinitModuleScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.moduleScriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.moduleScriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.moduleScriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        type: 'module',
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.moduleScripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+} // This function is only safe to call at Request start time since it assumes
+// that each module has not already been preloaded. If we find a need to preload
+// scripts at any other point in time we will need to check whether the preload
+// already exists and not assume it
+
+
+function preloadBootstrapScriptOrModule(resumableState, renderState, href, props) {
+
+  const key = getResourceKey(href);
+  // used to preinit the resource. If a script can be preinited then it shouldn't
+  // be a bootstrap script/module and if it is a bootstrap script/module then it
+  // must not be safe to emit early. To avoid possibly allowing for preinits of
+  // bootstrap scripts/modules we occlude these keys.
+
+
+  resumableState.scriptResources[key] = EXISTS;
+  resumableState.moduleScriptResources[key] = EXISTS;
+  const resource = [];
+  pushLinkImpl(resource, props);
+  renderState.bootstrapScripts.add(resource);
+}
+
+function internalPreinitScript(resumableState, renderState, src, chunks) {
+  const key = getResourceKey(src);
+
+  if (!resumableState.scriptResources.hasOwnProperty(key)) {
+    const resource = chunks;
+    resumableState.scriptResources[key] = EXISTS;
+    renderState.scripts.add(resource);
+  }
+
+  return;
+}
+
+function preloadAsStylePropsFromProps(href, props) {
+  return {
+    rel: 'preload',
+    as: 'style',
+    href: href,
+    crossOrigin: props.crossOrigin,
+    fetchPriority: props.fetchPriority,
+    integrity: props.integrity,
+    media: props.media,
+    hrefLang: props.hrefLang,
+    referrerPolicy: props.referrerPolicy
+  };
+}
+
+function stylesheetPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    'data-precedence': rawProps.precedence,
+    precedence: null
+  });
+}
+
+function adoptPreloadCredentials(target, preloadState) {
+  if (target.crossOrigin == null) target.crossOrigin = preloadState[0];
+  if (target.integrity == null) target.integrity = preloadState[1];
+}
+
+function getPrefetchDNSAsHeader(href) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  return "<" + escapedHref + ">; rel=dns-prefetch";
+}
+
+function getPreconnectAsHeader(href, crossOrigin) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  let value = "<" + escapedHref + ">; rel=preconnect";
+
+  if (typeof crossOrigin === 'string') {
+    const escapedCrossOrigin = escapeStringForLinkHeaderQuotedParamValueContext(crossOrigin);
+    value += "; crossorigin=\"" + escapedCrossOrigin + "\"";
+  }
+
+  return value;
+}
+
+function getPreloadAsHeader(href, as, params) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  const escapedAs = escapeStringForLinkHeaderQuotedParamValueContext(as);
+  let value = "<" + escapedHref + ">; rel=preload; as=\"" + escapedAs + "\"";
+
+  for (const paramName in params) {
+    if (hasOwnProperty.call(params, paramName)) {
+      const paramValue = params[paramName];
+
+      if (typeof paramValue === 'string') {
+        value += "; " + paramName.toLowerCase() + "=\"" + escapeStringForLinkHeaderQuotedParamValueContext(paramValue) + "\"";
+      }
+    }
+  }
+
+  return value;
+}
+
+function getStylesheetPreloadAsHeader(stylesheet) {
+  const props = stylesheet.props;
+  const preloadOptions = {
+    crossOrigin: props.crossOrigin,
+    integrity: props.integrity,
+    nonce: props.nonce,
+    type: props.type,
+    fetchPriority: props.fetchPriority,
+    referrerPolicy: props.referrerPolicy,
+    media: props.media
+  };
+  return getPreloadAsHeader(props.href, 'style', preloadOptions);
+} // This escaping function is only safe to use for href values being written into
+// a "Link" header in between `<` and `>` characters. The primary concern with the href is
+// to escape the bounding characters as well as new lines. This is unsafe to use in any other
+// context
+
+
+const regexForHrefInLinkHeaderURLContext = /[<>\r\n]/g;
+
+function escapeHrefForLinkHeaderURLContext(hrefInput) {
+
+  const coercedHref = '' + hrefInput;
+  return coercedHref.replace(regexForHrefInLinkHeaderURLContext, escapeHrefForLinkHeaderURLContextReplacer);
+}
+
+function escapeHrefForLinkHeaderURLContextReplacer(match) {
+  switch (match) {
+    case '<':
+      return '%3C';
+
+    case '>':
+      return '%3E';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeLinkHrefForHeaderContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+} // This escaping function is only safe to use for quoted param values in an HTTP header.
+// It is unsafe to use for any value not inside quote marks in parater value position.
+
+
+const regexForLinkHeaderQuotedParamValueContext = /["';,\r\n]/g;
+
+function escapeStringForLinkHeaderQuotedParamValueContext(value, name) {
+
+  const coerced = '' + value;
+  return coerced.replace(regexForLinkHeaderQuotedParamValueContext, escapeStringForLinkHeaderQuotedParamValueContextReplacer);
+}
+
+function escapeStringForLinkHeaderQuotedParamValueContextReplacer(match) {
+  switch (match) {
+    case '"':
+      return '%22';
+
+    case "'":
+      return '%27';
+
+    case ';':
+      return '%3B';
+
+    case ',':
+      return '%2C';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeStringForLinkHeaderQuotedParamValueContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+}
+
+function hoistStyleQueueDependency(styleQueue) {
+  this.styles.add(styleQueue);
+}
+
+function hoistStylesheetDependency(stylesheet) {
+  this.stylesheets.add(stylesheet);
+}
+
+function hoistResources(renderState, source) {
+  const currentBoundaryResources = renderState.boundaryResources;
+
+  if (currentBoundaryResources) {
+    source.styles.forEach(hoistStyleQueueDependency, currentBoundaryResources);
+    source.stylesheets.forEach(hoistStylesheetDependency, currentBoundaryResources);
+  }
+} // This function is called at various times depending on whether we are rendering
+// or prerendering. In this implementation we only actually emit headers once and
+// subsequent calls are ignored. We track whether the request has a completed shell
+// to determine whether we will follow headers with a flush including stylesheets.
+// In the context of prerrender we don't have a completed shell when the request finishes
+// with a postpone in the shell. In the context of a render we don't have a completed shell
+// if this is called before the shell finishes rendering which usually will happen anytime
+// anything suspends in the shell.
+
+function emitEarlyPreloads(renderState, resumableState, shellComplete) {
+  const onHeaders = renderState.onHeaders;
+
+  if (onHeaders) {
+    const headers = renderState.headers;
+
+    if (headers) {
+      let linkHeader = headers.preconnects;
+
+      if (headers.fontPreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.fontPreloads;
+      }
+
+      if (headers.highImagePreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.highImagePreloads;
+      }
+
+      if (!shellComplete) {
+        // We use raw iterators because we want to be able to halt iteration
+        // We could refactor renderState to store these dually in arrays to
+        // make this more efficient at the cost of additional memory and
+        // write overhead. However this code only runs once per request so
+        // for now I consider this sufficient.
+        const queueIter = renderState.styles.values();
+
+        outer: for (let queueStep = queueIter.next(); headers.remainingCapacity > 0 && !queueStep.done; queueStep = queueIter.next()) {
+          const sheets = queueStep.value.sheets;
+          const sheetIter = sheets.values();
+
+          for (let sheetStep = sheetIter.next(); headers.remainingCapacity > 0 && !sheetStep.done; sheetStep = sheetIter.next()) {
+            const sheet = sheetStep.value;
+            const props = sheet.props;
+            const key = getResourceKey(props.href);
+            const header = getStylesheetPreloadAsHeader(sheet); // We mutate the capacity b/c we don't want to keep checking if later headers will fit.
+            // This means that a particularly long header might close out the header queue where later
+            // headers could still fit. We could in the future alter the behavior here based on prerender vs render
+            // since during prerender we aren't as concerned with pure runtime performance.
+
+            if ((headers.remainingCapacity -= header.length) >= 2) {
+              renderState.resets.style[key] = PRELOAD_NO_CREDS;
+
+              if (linkHeader) {
+                linkHeader += ', ';
+              }
+
+              linkHeader += header; // We already track that the resource exists in resumableState however
+              // if the resumableState resets because we postponed in the shell
+              // which is what is happening in this branch if we are prerendering
+              // then we will end up resetting the resumableState. When it resets we
+              // want to record the fact that this stylesheet was already preloaded
+
+              renderState.resets.style[key] = typeof props.crossOrigin === 'string' || typeof props.integrity === 'string' ? [props.crossOrigin, props.integrity] : PRELOAD_NO_CREDS;
+            } else {
+              break outer;
+            }
+          }
+        }
+      }
+
+      if (linkHeader) {
+        onHeaders({
+          Link: linkHeader
+        });
+      } else {
+        // We still call this with no headers because a user may be using it as a signal that
+        // it React will not provide any headers
+        onHeaders({});
+      }
+
+      renderState.headers = null;
+      return;
+    }
+  }
+}
+
+function createRenderState(resumableState, generateStaticMarkup) {
+  const renderState = createRenderState$1(resumableState, undefined, undefined, undefined, undefined, undefined);
+  return {
+    // Keep this in sync with ReactFizzConfigDOM
+    placeholderPrefix: renderState.placeholderPrefix,
+    segmentPrefix: renderState.segmentPrefix,
+    boundaryPrefix: renderState.boundaryPrefix,
+    startInlineScript: renderState.startInlineScript,
+    htmlChunks: renderState.htmlChunks,
+    headChunks: renderState.headChunks,
+    externalRuntimeScript: renderState.externalRuntimeScript,
+    bootstrapChunks: renderState.bootstrapChunks,
+    onHeaders: renderState.onHeaders,
+    headers: renderState.headers,
+    resets: renderState.resets,
+    charsetChunks: renderState.charsetChunks,
+    preconnectChunks: renderState.preconnectChunks,
+    importMapChunks: renderState.importMapChunks,
+    preloadChunks: renderState.preloadChunks,
+    hoistableChunks: renderState.hoistableChunks,
+    preconnects: renderState.preconnects,
+    fontPreloads: renderState.fontPreloads,
+    highImagePreloads: renderState.highImagePreloads,
+    // usedImagePreloads: renderState.usedImagePreloads,
+    styles: renderState.styles,
+    bootstrapScripts: renderState.bootstrapScripts,
+    scripts: renderState.scripts,
+    bulkPreloads: renderState.bulkPreloads,
+    preloads: renderState.preloads,
+    boundaryResources: renderState.boundaryResources,
+    stylesToHoist: renderState.stylesToHoist,
+    // This is an extra field for the legacy renderer
+    generateStaticMarkup
+  };
+}
+
+const doctypeChunk = stringToPrecomputedChunk('');
+function pushTextInstance(target, text, renderState, textEmbedded) {
+  if (renderState.generateStaticMarkup) {
+    target.push(stringToChunk(escapeTextForBrowser(text)));
+    return false;
+  } else {
+    return pushTextInstance$1(target, text, renderState, textEmbedded);
+  }
+}
+function pushSegmentFinale(target, renderState, lastPushedText, textEmbedded) {
+  if (renderState.generateStaticMarkup) {
+    return;
+  } else {
+    return pushSegmentFinale$1(target, renderState, lastPushedText, textEmbedded);
+  }
+}
+function writeStartCompletedSuspenseBoundary(destination, renderState) {
+  if (renderState.generateStaticMarkup) {
+    // A completed boundary is done and doesn't need a representation in the HTML
+    // if we're not going to be hydrating it.
+    return true;
+  }
+
+  return writeStartCompletedSuspenseBoundary$1(destination);
+}
+function writeStartClientRenderedSuspenseBoundary(destination, renderState, // flushing these error arguments are not currently supported in this legacy streaming format.
+errorDigest, errorMessage, errorComponentStack) {
+  if (renderState.generateStaticMarkup) {
+    // A client rendered boundary is done and doesn't need a representation in the HTML
+    // since we'll never hydrate it. This is arguably an error in static generation.
+    return true;
+  }
+
+  return writeStartClientRenderedSuspenseBoundary$1(destination, renderState, errorDigest);
+}
+function writeEndCompletedSuspenseBoundary(destination, renderState) {
+  if (renderState.generateStaticMarkup) {
+    return true;
+  }
+
+  return writeEndCompletedSuspenseBoundary$1(destination);
+}
+function writeEndClientRenderedSuspenseBoundary(destination, renderState) {
+  if (renderState.generateStaticMarkup) {
+    return true;
+  }
+
+  return writeEndClientRenderedSuspenseBoundary$1(destination);
+}
+const NotPendingTransition = NotPending;
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+const REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_CONTEXT_TYPE = Symbol.for('react.context');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SCOPE_TYPE = Symbol.for('react.scope');
+const REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');
+const REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+const REACT_LEGACY_HIDDEN_TYPE = Symbol.for('react.legacy_hidden');
+const REACT_CACHE_TYPE = Symbol.for('react.cache');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+function getWrappedName(outerType, innerType, wrapperName) {
+  const displayName = outerType.displayName;
+
+  if (displayName) {
+    return displayName;
+  }
+
+  const functionName = innerType.displayName || innerType.name || '';
+  return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
+} // Keep in sync with react-reconciler/getComponentNameFromFiber
+
+
+function getContextName(type) {
+  return type.displayName || 'Context';
+} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+
+function getComponentNameFromType(type) {
+  if (type == null) {
+    // Host root, text node or just invalid type.
+    return null;
+  }
+
+  if (typeof type === 'function') {
+    return type.displayName || type.name || null;
+  }
+
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_FRAGMENT_TYPE:
+      return 'Fragment';
+
+    case REACT_PORTAL_TYPE:
+      return 'Portal';
+
+    case REACT_PROFILER_TYPE:
+      return 'Profiler';
+
+    case REACT_STRICT_MODE_TYPE:
+      return 'StrictMode';
+
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+
+    case REACT_CACHE_TYPE:
+      {
+        return 'Cache';
+      }
+
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        const context = type;
+        return getContextName(context) + '.Consumer';
+
+      case REACT_PROVIDER_TYPE:
+        const provider = type;
+        return getContextName(provider._context) + '.Provider';
+
+      case REACT_FORWARD_REF_TYPE:
+        return getWrappedName(type, type.render, 'ForwardRef');
+
+      case REACT_MEMO_TYPE:
+        const outerName = type.displayName || null;
+
+        if (outerName !== null) {
+          return outerName;
+        }
+
+        return getComponentNameFromType(type.type) || 'Memo';
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            return getComponentNameFromType(init(payload));
+          } catch (x) {
+            return null;
+          }
+        }
+
+      case REACT_SERVER_CONTEXT_TYPE:
+        {
+          const context2 = type;
+          return (context2.displayName || context2._globalName) + '.Provider';
+        }
+
+    }
+  }
+
+  return null;
+}
+
+const emptyContextObject = {};
+
+function getMaskedContext(type, unmaskedContext) {
+  {
+    const contextTypes = type.contextTypes;
+
+    if (!contextTypes) {
+      return emptyContextObject;
+    }
+
+    const context = {};
+
+    for (const key in contextTypes) {
+      context[key] = unmaskedContext[key];
+    }
+
+    return context;
+  }
+}
+function processChildContext(instance, type, parentContext, childContextTypes) {
+  {
+    // TODO (bvaughn) Replace this behavior with an invariant() in the future.
+    // It has only been added in Fiber to match the (unintentional) behavior in Stack.
+    if (typeof instance.getChildContext !== 'function') {
+
+      return parentContext;
+    }
+
+    const childContext = instance.getChildContext();
+
+    for (const contextKey in childContext) {
+      if (!(contextKey in childContextTypes)) {
+        throw Error(formatProdErrorMessage(108, getComponentNameFromType(type) || 'Unknown', contextKey));
+      }
+    }
+
+    return assign({}, parentContext, childContext);
+  }
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue2 = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue2 = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw Error(formatProdErrorMessage(401));
+      }
+    } else {
+      if (parentNext === null) {
+        throw Error(formatProdErrorMessage(401));
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext);
+    } // On the way back, we push the new ones that weren't common.
+
+
+    pushNode(next);
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw Error(formatProdErrorMessage(402));
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw Error(formatProdErrorMessage(402));
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function pushProvider(context, nextValue) {
+  let prevValue;
+
+  {
+    prevValue = context._currentValue2;
+    context._currentValue2 = nextValue;
+  }
+
+  const prevNode = currentActiveSnapshot;
+  const newNode = {
+    parent: prevNode,
+    depth: prevNode === null ? 0 : prevNode.depth + 1,
+    context: context,
+    parentValue: prevValue,
+    value: nextValue
+  };
+  currentActiveSnapshot = newNode;
+  return newNode;
+}
+function popProvider(context) {
+  const prevSnapshot = currentActiveSnapshot;
+
+  if (prevSnapshot === null) {
+    throw Error(formatProdErrorMessage(403));
+  }
+
+  {
+    const value = prevSnapshot.parentValue;
+
+    if (value === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      prevSnapshot.context._currentValue2 = prevSnapshot.context._defaultValue;
+    } else {
+      prevSnapshot.context._currentValue2 = value;
+    }
+  }
+
+  return currentActiveSnapshot = prevSnapshot.parent;
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue2;
+  return value;
+}
+
+/**
+ * `ReactInstanceMap` maintains a mapping from a public facing stateful
+ * instance (key) and the internal representation (value). This allows public
+ * methods to accept the user facing instance as an argument and map them back
+ * to internal methods.
+ *
+ * Note that this module is currently shared and assumed to be stateless.
+ * If this becomes an actual Map, that will break.
+ */
+function get(key) {
+  return key._reactInternals;
+}
+function set(key, value) {
+  key._reactInternals = value;
+}
+
+const classComponentUpdater = {
+  isMounted(inst) {
+    return false;
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueSetState(inst, payload, callback) {
+    const internals = get(inst);
+
+    if (internals.queue === null) ; else {
+      internals.queue.push(payload);
+    }
+  },
+
+  enqueueReplaceState(inst, payload, callback) {
+    const internals = get(inst);
+    internals.replace = true;
+    internals.queue = [payload];
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueForceUpdate(inst, callback) {
+  }
+
+};
+
+function applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, prevState, nextProps) {
+  const partialState = getDerivedStateFromProps(nextProps, prevState);
+
+
+  const newState = partialState === null || partialState === undefined ? prevState : assign({}, prevState, partialState);
+  return newState;
+}
+
+function constructClassInstance(ctor, props, maskedLegacyContext) {
+  let context = emptyContextObject;
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    context = readContext$1(contextType);
+  } else {
+    context = maskedLegacyContext;
+  }
+
+  const instance = new ctor(props, context);
+
+  return instance;
+}
+
+function callComponentWillMount(type, instance) {
+  const oldState = instance.state;
+
+  if (typeof instance.componentWillMount === 'function') {
+
+    instance.componentWillMount();
+  }
+
+  if (typeof instance.UNSAFE_componentWillMount === 'function') {
+    instance.UNSAFE_componentWillMount();
+  }
+
+  if (oldState !== instance.state) {
+
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+}
+
+function processUpdateQueue(internalInstance, inst, props, maskedLegacyContext) {
+  if (internalInstance.queue !== null && internalInstance.queue.length > 0) {
+    const oldQueue = internalInstance.queue;
+    const oldReplace = internalInstance.replace;
+    internalInstance.queue = null;
+    internalInstance.replace = false;
+
+    if (oldReplace && oldQueue.length === 1) {
+      inst.state = oldQueue[0];
+    } else {
+      let nextState = oldReplace ? oldQueue[0] : inst.state;
+      let dontMutate = true;
+
+      for (let i = oldReplace ? 1 : 0; i < oldQueue.length; i++) {
+        const partial = oldQueue[i];
+        const partialState = typeof partial === 'function' ? partial.call(inst, nextState, props, maskedLegacyContext) : partial;
+
+        if (partialState != null) {
+          if (dontMutate) {
+            dontMutate = false;
+            nextState = assign({}, nextState, partialState);
+          } else {
+            assign(nextState, partialState);
+          }
+        }
+      }
+
+      inst.state = nextState;
+    }
+  } else {
+    internalInstance.queue = null;
+  }
+} // Invokes the mount life-cycles on a previously never rendered instance.
+
+
+function mountClassInstance(instance, ctor, newProps, maskedLegacyContext) {
+
+  const initialState = instance.state !== undefined ? instance.state : null;
+  instance.updater = classComponentUpdater;
+  instance.props = newProps;
+  instance.state = initialState; // We don't bother initializing the refs object on the server, since we're not going to resolve them anyway.
+  // The internal instance will be used to manage updates that happen during this mount.
+
+  const internalInstance = {
+    queue: [],
+    replace: false
+  };
+  set(instance, internalInstance);
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    instance.context = readContext$1(contextType);
+  } else {
+    instance.context = maskedLegacyContext;
+  }
+
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    instance.state = applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, initialState, newProps);
+  } // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+
+  if (typeof ctor.getDerivedStateFromProps !== 'function' && typeof instance.getSnapshotBeforeUpdate !== 'function' && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
+    callComponentWillMount(ctor, instance); // If we had additional state updates during this life-cycle, let's
+    // process them now.
+
+    processUpdateQueue(internalInstance, instance, newProps, maskedLegacyContext);
+  }
+}
+
+// Ids are base 32 strings whose binary representation corresponds to the
+// position of a node in a tree.
+// Every time the tree forks into multiple children, we add additional bits to
+// the left of the sequence that represent the position of the child within the
+// current level of children.
+//
+//      00101       00010001011010101
+//      ╰─┬─╯       ╰───────┬───────╯
+//   Fork 5 of 20       Parent id
+//
+// The leading 0s are important. In the above example, you only need 3 bits to
+// represent slot 5. However, you need 5 bits to represent all the forks at
+// the current level, so we must account for the empty bits at the end.
+//
+// For this same reason, slots are 1-indexed instead of 0-indexed. Otherwise,
+// the zeroth id at a level would be indistinguishable from its parent.
+//
+// If a node has only one child, and does not materialize an id (i.e. does not
+// contain a useId hook), then we don't need to allocate any space in the
+// sequence. It's treated as a transparent indirection. For example, these two
+// trees produce the same ids:
+//
+// <>                          <>
+//   <Indirection>               <A />
+//     <A />                     <B />
+//   </Indirection>            </>
+//   <B />
+// </>
+//
+// However, we cannot skip any node that materializes an id. Otherwise, a parent
+// id that does not fork would be indistinguishable from its child id. For
+// example, this tree does not fork, but the parent and child must have
+// different ids.
+//
+// <Parent>
+//   <Child />
+// </Parent>
+//
+// To handle this scenario, every time we materialize an id, we allocate a
+// new level with a single slot. You can think of this as a fork with only one
+// prong, or an array of children with length 1.
+//
+// It's possible for the size of the sequence to exceed 32 bits, the max
+// size for bitwise operations. When this happens, we make more room by
+// converting the right part of the id to a string and storing it in an overflow
+// variable. We use a base 32 string representation, because 32 is the largest
+// power of 2 that is supported by toString(). We want the base to be large so
+// that the resulting ids are compact, and we want the base to be a power of 2
+// because every log2(base) bits corresponds to a single character, i.e. every
+// log2(32) = 5 bits. That means we can lop bits off the end 5 at a time without
+// affecting the final result.
+const emptyTreeContext = {
+  id: 1,
+  overflow: ''
+};
+function getTreeId(context) {
+  const overflow = context.overflow;
+  const idWithLeadingBit = context.id;
+  const id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
+  return id.toString(32) + overflow;
+}
+function pushTreeContext(baseContext, totalChildren, index) {
+  const baseIdWithLeadingBit = baseContext.id;
+  const baseOverflow = baseContext.overflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
+  // of the id; we use it to account for leading 0s.
+
+  const baseLength = getBitLength(baseIdWithLeadingBit) - 1;
+  const baseId = baseIdWithLeadingBit & ~(1 << baseLength);
+  const slot = index + 1;
+  const length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
+  // consideration the leading 1 we use to mark the end of the sequence.
+
+  if (length > 30) {
+    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
+    // This branch assumes the length of the base id is greater than 5; it won't
+    // work for smaller ids, because you need 5 bits per character.
+    //
+    // We encode the id in multiple steps: first the base id, then the
+    // remaining digits.
+    //
+    // Each 5 bit sequence corresponds to a single base 32 character. So for
+    // example, if the current id is 23 bits long, we can convert 20 of those
+    // bits into a string of 4 characters, with 3 bits left over.
+    //
+    // First calculate how many bits in the base id represent a complete
+    // sequence of characters.
+    const numberOfOverflowBits = baseLength - baseLength % 5; // Then create a bitmask that selects only those bits.
+
+    const newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
+
+    const newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
+
+    const restOfBaseId = baseId >> numberOfOverflowBits;
+    const restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
+    // we made more room, this time it won't overflow.
+
+    const restOfLength = getBitLength(totalChildren) + restOfBaseLength;
+    const restOfNewBits = slot << restOfBaseLength;
+    const id = restOfNewBits | restOfBaseId;
+    const overflow = newOverflow + baseOverflow;
+    return {
+      id: 1 << restOfLength | id,
+      overflow
+    };
+  } else {
+    // Normal path
+    const newBits = slot << baseLength;
+    const id = newBits | baseId;
+    const overflow = baseOverflow;
+    return {
+      id: 1 << length | id,
+      overflow
+    };
+  }
+}
+
+function getBitLength(number) {
+  return 32 - clz32(number);
+}
+
+function getLeadingBit(id) {
+  return 1 << getBitLength(id) - 1;
+} // TODO: Math.clz32 is supported in Node 12+. Maybe we can drop the fallback.
+
+
+const 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
+
+const log = Math.log;
+const LN2 = Math.LN2;
+
+function clz32Fallback(x) {
+  const asUint = x >>> 0;
+
+  if (asUint === 0) {
+    return 32;
+  }
+
+  return 31 - (log(asUint) / LN2 | 0) | 0;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFlightWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = Error(formatProdErrorMessage(460));
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop$2() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop$2, noop$2);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw Error(formatProdErrorMessage(459));
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+
+const objectIs = // $FlowFixMe[method-unbinding]
+typeof Object.is === 'function' ? Object.is : is;
+
+let currentlyRenderingComponent = null;
+let currentlyRenderingTask = null;
+let currentlyRenderingRequest = null;
+let currentlyRenderingKeyPath = null;
+let firstWorkInProgressHook = null;
+let workInProgressHook = null; // Whether the work-in-progress hook is a re-rendered hook
+
+let isReRender = false; // Whether an update was scheduled during the currently executing render pass.
+
+let didScheduleRenderPhaseUpdate = false; // Counts the number of useId hooks in this component
+
+let localIdCounter = 0; // Chunks that should be pushed to the stream once the component
+// finishes rendering.
+// Counts the number of useFormState calls in this component
+
+let formStateCounter = 0; // The index of the useFormState hook that matches the one passed in at the
+// root during an MPA navigation, if any.
+
+let formStateMatchingIndex = -1; // Counts the number of use(thenable) calls in this component
+
+let thenableIndexCounter = 0;
+let thenableState = null; // Lazily created map of render-phase updates
+
+let renderPhaseUpdates = null; // Counter to prevent infinite loops.
+
+let numberOfReRenders = 0;
+const RE_RENDER_LIMIT = 25;
+
+function resolveCurrentlyRenderingComponent() {
+  if (currentlyRenderingComponent === null) {
+    throw Error(formatProdErrorMessage(321));
+  }
+
+  return currentlyRenderingComponent;
+}
+
+function areHookInputsEqual(nextDeps, prevDeps) {
+  if (prevDeps === null) {
+
+    return false;
+  }
+
+
+  for (let i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    if (objectIs(nextDeps[i], prevDeps[i])) {
+      continue;
+    }
+
+    return false;
+  }
+
+  return true;
+}
+
+function createHook() {
+  if (numberOfReRenders > 0) {
+    throw Error(formatProdErrorMessage(312));
+  }
+
+  return {
+    memoizedState: null,
+    queue: null,
+    next: null
+  };
+}
+
+function createWorkInProgressHook() {
+  if (workInProgressHook === null) {
+    // This is the first hook in the list
+    if (firstWorkInProgressHook === null) {
+      isReRender = false;
+      firstWorkInProgressHook = workInProgressHook = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = firstWorkInProgressHook;
+    }
+  } else {
+    if (workInProgressHook.next === null) {
+      isReRender = false; // Append to the end of the list
+
+      workInProgressHook = workInProgressHook.next = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = workInProgressHook.next;
+    }
+  }
+
+  return workInProgressHook;
+}
+
+function prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState) {
+  currentlyRenderingComponent = componentIdentity;
+  currentlyRenderingTask = task;
+  currentlyRenderingRequest = request;
+  currentlyRenderingKeyPath = keyPath;
+  // didScheduleRenderPhaseUpdate = false;
+  // firstWorkInProgressHook = null;
+  // numberOfReRenders = 0;
+  // renderPhaseUpdates = null;
+  // workInProgressHook = null;
+
+
+  localIdCounter = 0;
+  formStateCounter = 0;
+  formStateMatchingIndex = -1;
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function finishHooks(Component, props, children, refOrContext) {
+  // This must be called after every function component to prevent hooks from
+  // being used in classes.
+  while (didScheduleRenderPhaseUpdate) {
+    // Updates were scheduled during the render phase. They are stored in
+    // the `renderPhaseUpdates` map. Call the component again, reusing the
+    // work-in-progress hooks and applying the additional updates on top. Keep
+    // restarting until no more updates are scheduled.
+    didScheduleRenderPhaseUpdate = false;
+    localIdCounter = 0;
+    formStateCounter = 0;
+    formStateMatchingIndex = -1;
+    thenableIndexCounter = 0;
+    numberOfReRenders += 1; // Start over from the beginning of the list
+
+    workInProgressHook = null;
+    children = Component(props, refOrContext);
+  }
+
+  resetHooksState();
+  return children;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+function checkDidRenderIdHook() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  const didRenderIdHook = localIdCounter !== 0;
+  return didRenderIdHook;
+}
+function getFormStateCount() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateCounter;
+}
+function getFormStateMatchingIndex() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateMatchingIndex;
+} // Reset the internal hooks state if an error occurs while rendering a component
+
+function resetHooksState() {
+
+  currentlyRenderingComponent = null;
+  currentlyRenderingTask = null;
+  currentlyRenderingRequest = null;
+  currentlyRenderingKeyPath = null;
+  didScheduleRenderPhaseUpdate = false;
+  firstWorkInProgressHook = null;
+  numberOfReRenders = 0;
+  renderPhaseUpdates = null;
+  workInProgressHook = null;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+function useContext(context) {
+
+  resolveCurrentlyRenderingComponent();
+  return readContext$1(context);
+}
+
+function basicStateReducer(state, action) {
+  // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
+  return typeof action === 'function' ? action(state) : action;
+}
+
+function useState(initialState) {
+
+  return useReducer(basicStateReducer, // useReducer has a special case to support lazy useState initializers
+  initialState);
+}
+function useReducer(reducer, initialArg, init) {
+
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+
+  if (isReRender) {
+    // This is a re-render. Apply the new render phase updates to the previous
+    // current hook.
+    const queue = workInProgressHook.queue;
+    const dispatch = queue.dispatch;
+
+    if (renderPhaseUpdates !== null) {
+      // Render phase updates are stored in a map of queue -> linked list
+      const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+      if (firstRenderPhaseUpdate !== undefined) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        renderPhaseUpdates.delete(queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+        let newState = workInProgressHook.memoizedState;
+        let update = firstRenderPhaseUpdate;
+
+        do {
+          // Process this render phase update. We don't have to check the
+          // priority because it will always be the same as the current
+          // render's.
+          const action = update.action;
+
+          newState = reducer(newState, action);
+
+
+          update = update.next;
+        } while (update !== null); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+        workInProgressHook.memoizedState = newState;
+        return [newState, dispatch];
+      }
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    return [workInProgressHook.memoizedState, dispatch];
+  } else {
+
+    let initialState;
+
+    if (reducer === basicStateReducer) {
+      // Special case for `useState`.
+      initialState = typeof initialArg === 'function' ? initialArg() : initialArg;
+    } else {
+      initialState = init !== undefined ? init(initialArg) : initialArg;
+    }
+
+
+    workInProgressHook.memoizedState = initialState; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    const queue = workInProgressHook.queue = {
+      last: null,
+      dispatch: null
+    };
+    const dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingComponent, queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    return [workInProgressHook.memoizedState, dispatch];
+  }
+}
+
+function useMemo(nextCreate, deps) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+
+  if (workInProgressHook !== null) {
+    const prevState = workInProgressHook.memoizedState;
+
+    if (prevState !== null) {
+      if (nextDeps !== null) {
+        const prevDeps = prevState[1];
+
+        if (areHookInputsEqual(nextDeps, prevDeps)) {
+          return prevState[0];
+        }
+      }
+    }
+  }
+
+  const nextValue = nextCreate();
+
+
+  workInProgressHook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
+
+function useRef(initialValue) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const previousRef = workInProgressHook.memoizedState;
+
+  if (previousRef === null) {
+    const ref = {
+      current: initialValue
+    };
+
+
+    workInProgressHook.memoizedState = ref;
+    return ref;
+  } else {
+    return previousRef;
+  }
+}
+
+function dispatchAction(componentIdentity, queue, action) {
+  if (numberOfReRenders >= RE_RENDER_LIMIT) {
+    throw Error(formatProdErrorMessage(301));
+  }
+
+  if (componentIdentity === currentlyRenderingComponent) {
+    // This is a render phase update. Stash it in a lazily-created map of
+    // queue -> linked list of updates. After this render pass, we'll restart
+    // and apply the stashed updates on top of the work-in-progress hook.
+    didScheduleRenderPhaseUpdate = true;
+    const update = {
+      action,
+      next: null
+    };
+
+    if (renderPhaseUpdates === null) {
+      renderPhaseUpdates = new Map();
+    }
+
+    const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+    if (firstRenderPhaseUpdate === undefined) {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      renderPhaseUpdates.set(queue, update);
+    } else {
+      // Append the update to the end of the list.
+      let lastRenderPhaseUpdate = firstRenderPhaseUpdate;
+
+      while (lastRenderPhaseUpdate.next !== null) {
+        lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+      }
+
+      lastRenderPhaseUpdate.next = update;
+    }
+  }
+}
+
+function useCallback(callback, deps) {
+  return useMemo(() => callback, deps);
+}
+
+function throwOnUseEffectEventCall() {
+  throw Error(formatProdErrorMessage(440));
+}
+
+function useEffectEvent(callback) {
+  // $FlowIgnore[incompatible-return]
+  return throwOnUseEffectEventCall;
+}
+
+function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  if (getServerSnapshot === undefined) {
+    throw Error(formatProdErrorMessage(407));
+  }
+
+  return getServerSnapshot();
+}
+
+function useDeferredValue(value, initialValue) {
+  resolveCurrentlyRenderingComponent();
+
+  {
+    return initialValue !== undefined ? initialValue : value;
+  }
+}
+
+function unsupportedStartTransition() {
+  throw Error(formatProdErrorMessage(394));
+}
+
+function useTransition() {
+  resolveCurrentlyRenderingComponent();
+  return [false, unsupportedStartTransition];
+}
+
+function useHostTransitionStatus() {
+  resolveCurrentlyRenderingComponent();
+  return NotPendingTransition;
+}
+
+function unsupportedSetOptimisticState() {
+  throw Error(formatProdErrorMessage(479));
+}
+
+function useOptimistic(passthrough, reducer) {
+  resolveCurrentlyRenderingComponent();
+  return [passthrough, unsupportedSetOptimisticState];
+}
+
+function createPostbackFormStateKey(permalink, componentKeyPath, hookIndex) {
+  if (permalink !== undefined) {
+    // Don't bother to hash a permalink-based key since it's already short.
+    return 'p' + permalink;
+  } else {
+    // Append a node to the key path that represents the form state hook.
+    const keyPath = [componentKeyPath, null, hookIndex]; // Key paths are hashed to reduce the size. It does not need to be secure,
+    // and it's more important that it's fast than that it's completely
+    // collision-free.
+
+    const keyPathHash = createFastHashJS(JSON.stringify(keyPath));
+    return 'k' + keyPathHash;
+  }
+}
+
+function useFormState(action, initialState, permalink) {
+  resolveCurrentlyRenderingComponent(); // Count the number of useFormState hooks per component. We also use this to
+  // track the position of this useFormState hook relative to the other ones in
+  // this component, so we can generate a unique key for each one.
+
+  const formStateHookIndex = formStateCounter++;
+  const request = currentlyRenderingRequest; // $FlowIgnore[prop-missing]
+
+  const formAction = action.$$FORM_ACTION;
+
+  if (typeof formAction === 'function') {
+    // This is a server action. These have additional features to enable
+    // MPA-style form submissions with progressive enhancement.
+    // TODO: If the same permalink is passed to multiple useFormStates, and
+    // they all have the same action signature, Fizz will pass the postback
+    // state to all of them. We should probably only pass it to the first one,
+    // and/or warn.
+    // The key is lazily generated and deduped so the that the keypath doesn't
+    // get JSON.stringify-ed unnecessarily, and at most once.
+    let nextPostbackStateKey = null; // Determine the current form state. If we received state during an MPA form
+    // submission, then we will reuse that, if the action identity matches.
+    // Otherwise we'll use the initial state argument. We will emit a comment
+    // marker into the stream that indicates whether the state was reused.
+
+    let state = initialState;
+    const componentKeyPath = currentlyRenderingKeyPath;
+    const postbackFormState = getFormState(request); // $FlowIgnore[prop-missing]
+
+    const isSignatureEqual = action.$$IS_SIGNATURE_EQUAL;
+
+    if (postbackFormState !== null && typeof isSignatureEqual === 'function') {
+      const postbackKey = postbackFormState[1];
+      const postbackReferenceId = postbackFormState[2];
+      const postbackBoundArity = postbackFormState[3];
+
+      if (isSignatureEqual.call(action, postbackReferenceId, postbackBoundArity)) {
+        nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+
+        if (postbackKey === nextPostbackStateKey) {
+          // This was a match
+          formStateMatchingIndex = formStateHookIndex; // Reuse the state that was submitted by the form.
+
+          state = postbackFormState[0];
+        }
+      }
+    } // Bind the state to the first argument of the action.
+
+
+    const boundAction = action.bind(null, state); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    }; // $FlowIgnore[prop-missing]
+
+
+    if (typeof boundAction.$$FORM_ACTION === 'function') {
+      // $FlowIgnore[prop-missing]
+      dispatch.$$FORM_ACTION = prefix => {
+        const metadata = boundAction.$$FORM_ACTION(prefix); // Override the action URL
+
+        if (permalink !== undefined) {
+
+          permalink += '';
+          metadata.action = permalink;
+        }
+
+        const formData = metadata.data;
+
+        if (formData) {
+          if (nextPostbackStateKey === null) {
+            nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+          }
+
+          formData.append('$ACTION_KEY', nextPostbackStateKey);
+        }
+
+        return metadata;
+      };
+    }
+
+    return [state, dispatch];
+  } else {
+    // This is not a server action, so the implementation is much simpler.
+    // Bind the state to the first argument of the action.
+    const boundAction = action.bind(null, initialState); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    };
+
+    return [initialState, dispatch];
+  }
+}
+
+function useId() {
+  const task = currentlyRenderingTask;
+  const treeId = getTreeId(task.treeContext);
+  const resumableState = currentResumableState;
+
+  if (resumableState === null) {
+    throw Error(formatProdErrorMessage(404));
+  }
+
+  const localId = localIdCounter++;
+  return makeId(resumableState, treeId, localId);
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable;
+      return unwrapThenable(thenable);
+    } else if (usable.$$typeof === REACT_CONTEXT_TYPE || usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+  throw Error(formatProdErrorMessage(438, String(usable)));
+}
+
+function unwrapThenable(thenable) {
+  const index = thenableIndexCounter;
+  thenableIndexCounter += 1;
+
+  if (thenableState === null) {
+    thenableState = createThenableState();
+  }
+
+  return trackUsedThenable(thenableState, thenable, index);
+}
+
+function unsupportedRefresh() {
+  throw Error(formatProdErrorMessage(393));
+}
+
+function useCacheRefresh() {
+  return unsupportedRefresh;
+}
+
+function useMemoCache(size) {
+  const data = new Array(size);
+
+  for (let i = 0; i < size; i++) {
+    data[i] = REACT_MEMO_CACHE_SENTINEL;
+  }
+
+  return data;
+}
+
+function noop$1() {}
+
+const HooksDispatcher = {
+  readContext,
+  use,
+  useContext,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+  useInsertionEffect: noop$1,
+  useLayoutEffect: noop$1,
+  useCallback,
+  // useImperativeHandle is not run in the server environment
+  useImperativeHandle: noop$1,
+  // Effects are not run in the server environment.
+  useEffect: noop$1,
+  // Debugging effect
+  useDebugValue: noop$1,
+  useDeferredValue,
+  useTransition,
+  useId,
+  // Subscriptions are not setup in a server environment.
+  useSyncExternalStore
+};
+
+{
+  HooksDispatcher.useCacheRefresh = useCacheRefresh;
+}
+
+{
+  HooksDispatcher.useEffectEvent = useEffectEvent;
+}
+
+{
+  HooksDispatcher.useMemoCache = useMemoCache;
+}
+
+{
+  HooksDispatcher.useHostTransitionStatus = useHostTransitionStatus;
+}
+
+{
+  HooksDispatcher.useOptimistic = useOptimistic;
+  HooksDispatcher.useFormState = useFormState;
+}
+
+let currentResumableState = null;
+function setCurrentResumableState(resumableState) {
+  currentResumableState = resumableState;
+}
+
+function getCacheSignal() {
+  throw Error(formatProdErrorMessage(248));
+}
+
+function getCacheForType(resourceType) {
+  throw Error(formatProdErrorMessage(248));
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal,
+  getCacheForType
+};
+
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+const ReactCurrentCache = ReactSharedInternals.ReactCurrentCache;
+// The name might be minified but we assume that it's going to be the same generated name. Typically
+// because it's just the same compiled output in practice.
+// resume with segmentID at the index
+
+const CLIENT_RENDERED = 4; // if it errors or infinitely suspends
+
+const PENDING = 0;
+const COMPLETED = 1;
+const FLUSHED = 2;
+const ABORTED = 3;
+const ERRORED = 4;
+const POSTPONED = 5;
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2; // This is a default heuristic for how to split up the HTML content into progressive
+// loading. Our goal is to be able to display additional new content about every 500ms.
+// Faster than that is unnecessary and should be throttled on the client. It also
+// adds unnecessary overhead to do more splits. We don't know if it's a higher or lower
+// end device but higher end suffer less from the overhead than lower end does from
+// not getting small enough pieces. We error on the side of low end.
+// We base this on low end 3G speeds which is about 500kbits per second. We assume
+// that there can be a reasonable drop off from max bandwidth which leaves you with
+// as little as 80%. We can receive half of that each 500ms - at best. In practice,
+// a little bandwidth is lost to processing and contention - e.g. CSS and images that
+// are downloaded along with the main content. So we estimate about half of that to be
+// the lower end throughput. In other words, we expect that you can at least show
+// about 12.5kb of content per 500ms. Not counting starting latency for the first
+// paint.
+// 500 * 1024 / 8 * .8 * 0.5 / 2
+
+const DEFAULT_PROGRESSIVE_CHUNK_SIZE = 12800;
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+
+  return null;
+}
+
+function noop() {}
+
+function createRequest(children, resumableState, renderState, rootFormatContext, progressiveChunkSize, onError, onAllReady, onShellReady, onShellError, onFatalError, onPostpone, formState) {
+  prepareHostDispatcher();
+  const pingedTasks = [];
+  const abortSet = new Set();
+  const request = {
+    destination: null,
+    flushScheduled: false,
+    resumableState,
+    renderState,
+    rootFormatContext,
+    progressiveChunkSize: progressiveChunkSize === undefined ? DEFAULT_PROGRESSIVE_CHUNK_SIZE : progressiveChunkSize,
+    status: OPEN,
+    fatalError: null,
+    nextSegmentId: 0,
+    allPendingTasks: 0,
+    pendingRootTasks: 0,
+    completedRootSegment: null,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    clientRenderedBoundaries: [],
+    completedBoundaries: [],
+    partialBoundaries: [],
+    trackedPostpones: null,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? noop : onPostpone,
+    onAllReady: onAllReady === undefined ? noop : onAllReady,
+    onShellReady: onShellReady === undefined ? noop : onShellReady,
+    onShellError: onShellError === undefined ? noop : onShellError,
+    onFatalError: onFatalError === undefined ? noop : onFatalError,
+    formState: formState === undefined ? null : formState
+  }; // This segment represents the root fallback.
+
+  const rootSegment = createPendingSegment(request, 0, null, rootFormatContext, // Root segments are never embedded in Text on either edge
+  false, false); // There is no parent so conceptually, we're unblocked to flush this segment.
+
+  rootSegment.parentFlushed = true;
+  const rootTask = createRenderTask(request, null, children, -1, null, rootSegment, abortSet, null, rootFormatContext, emptyContextObject, rootContextSnapshot, emptyTreeContext);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  return null;
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (request.pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createSuspenseBoundary(request, fallbackAbortableTasks) {
+  return {
+    status: PENDING,
+    rootSegmentID: -1,
+    parentFlushed: false,
+    pendingTasks: 0,
+    completedSegments: [],
+    byteSize: 0,
+    fallbackAbortableTasks,
+    errorDigest: null,
+    resources: createBoundaryResources(),
+    trackedContentKeyPath: null,
+    trackedFallbackNode: null
+  };
+}
+
+function createRenderTask(request, thenableState, node, childIndex, blockedBoundary, blockedSegment, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  const task = {
+    replay: null,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createReplayTask(request, thenableState, replay, node, childIndex, blockedBoundary, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  replay.pendingTasks++;
+  const task = {
+    replay,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment: null,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createPendingSegment(request, index, boundary, parentFormatContext, lastPushedText, textEmbedded) {
+  return {
+    status: PENDING,
+    id: -1,
+    // lazily assigned later
+    index,
+    parentFlushed: false,
+    chunks: [],
+    children: [],
+    parentFormatContext,
+    boundary,
+    lastPushedText,
+    textEmbedded
+  };
+} // DEV-only global reference to the currently executing task
+
+function popComponentStackInDEV(task) {
+} // stash the component stack of an unwinding error until it is processed
+
+function logPostpone(request, reason) {
+  // If this callback errors, we intentionally let that error bubble up to become a fatal error
+  // so that someone fixes the error reporting instead of hiding it.
+  request.onPostpone(reason);
+}
+
+function logRecoverableError(request, error) {
+  // If this callback errors, we intentionally let that error bubble up to become a fatal error
+  // so that someone fixes the error reporting instead of hiding it.
+  const errorDigest = request.onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest;
+}
+
+function fatalError(request, error) {
+  // This is called outside error handling code such as if the root errors outside
+  // a suspense boundary or if the root suspense boundary's fallback errors.
+  // It's also called if React itself or its host configs errors.
+  const onShellError = request.onShellError;
+  onShellError(error);
+  const onFatalError = request.onFatalError;
+  onFatalError(error);
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function renderSuspenseBoundary(request, someTask, keyPath, props) {
+  if (someTask.replay !== null) {
+    // If we're replaying through this pass, it means we're replaying through
+    // an already completed Suspense boundary. It's too late to do anything about it
+    // so we can just render through it.
+    const prevKeyPath = someTask.keyPath;
+    someTask.keyPath = keyPath;
+    const content = props.children;
+
+    try {
+      renderNode(request, someTask, content, -1);
+    } finally {
+      someTask.keyPath = prevKeyPath;
+    }
+
+    return;
+  } // $FlowFixMe: Refined.
+
+
+  const task = someTask;
+  const prevKeyPath = task.keyPath;
+  const parentBoundary = task.blockedBoundary;
+  const parentSegment = task.blockedSegment; // Each time we enter a suspense boundary, we split out into a new segment for
+  // the fallback so that we can later replace that segment with the content.
+  // This also lets us split out the main content even if it doesn't suspend,
+  // in case it ends up generating a large subtree of content.
+
+  const fallback = props.fallback;
+  const content = props.children;
+  const fallbackAbortSet = new Set();
+  const newBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+
+  if (request.trackedPostpones !== null) {
+    newBoundary.trackedContentKeyPath = keyPath;
+  }
+
+  const insertionIndex = parentSegment.chunks.length; // The children of the boundary segment is actually the fallback.
+
+  const boundarySegment = createPendingSegment(request, insertionIndex, newBoundary, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false);
+  parentSegment.children.push(boundarySegment); // The parentSegment has a child Segment at this index so we reset the lastPushedText marker on the parent
+
+  parentSegment.lastPushedText = false; // This segment is the actual child content. We can start rendering that immediately.
+
+  const contentRootSegment = createPendingSegment(request, 0, null, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false); // We mark the root segment as having its parent flushed. It's not really flushed but there is
+  // no parent segment so there's nothing to wait on.
+
+  contentRootSegment.parentFlushed = true; // Currently this is running synchronously. We could instead schedule this to pingedTasks.
+  // I suspect that there might be some efficiency benefits from not creating the suspended task
+  // and instead just using the stack if possible.
+  // TODO: Call this directly instead of messing with saving and restoring contexts.
+  // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and which segment
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = newBoundary;
+  task.blockedSegment = contentRootSegment;
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, newBoundary.resources);
+  }
+
+  task.keyPath = keyPath;
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+    pushSegmentFinale(contentRootSegment.chunks, request.renderState, contentRootSegment.lastPushedText, contentRootSegment.textEmbedded);
+    contentRootSegment.status = COMPLETED;
+    queueCompletedSegment(newBoundary, contentRootSegment);
+
+    if (newBoundary.pendingTasks === 0 && newBoundary.status === PENDING) {
+      newBoundary.status = COMPLETED; // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    contentRootSegment.status = ERRORED;
+    newBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+      const postponeInstance = error;
+      logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+      errorDigest = 'POSTPONE';
+    } else {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    newBoundary.errorDigest = errorDigest;
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.blockedSegment = parentSegment;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]];
+  const trackedPostpones = request.trackedPostpones;
+
+  if (trackedPostpones !== null) {
+    // We create a detached replay node to track any postpones inside the fallback.
+    const fallbackReplayNode = [fallbackKeyPath[1], fallbackKeyPath[2], [], null];
+    trackedPostpones.workingMap.set(fallbackKeyPath, fallbackReplayNode);
+
+    if (newBoundary.status === POSTPONED) {
+      // This must exist now.
+      const boundaryReplayNode = trackedPostpones.workingMap.get(keyPath);
+      boundaryReplayNode[4] = fallbackReplayNode;
+    } else {
+      // We might not inject it into the postponed tree, unless the content actually
+      // postpones too. We need to keep track of it until that happpens.
+      newBoundary.trackedFallbackNode = fallbackReplayNode;
+    }
+  } // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+
+  const suspendedFallbackTask = createRenderTask(request, null, fallback, -1, parentBoundary, boundarySegment, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function replaySuspenseBoundary(request, task, keyPath, props, id, childNodes, childSlots, fallbackNodes, fallbackSlots) {
+  const prevKeyPath = task.keyPath;
+  const previousReplaySet = task.replay;
+  const parentBoundary = task.blockedBoundary;
+  const content = props.children;
+  const fallback = props.fallback;
+  const fallbackAbortSet = new Set();
+  const resumedBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = id; // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and replay node
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = resumedBoundary;
+  task.replay = {
+    nodes: childNodes,
+    slots: childSlots,
+    pendingTasks: 1
+  };
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, resumedBoundary.resources);
+  }
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw Error(formatProdErrorMessage(488));
+    }
+
+    task.replay.pendingTasks--;
+
+    if (resumedBoundary.pendingTasks === 0 && resumedBoundary.status === PENDING) {
+      resumedBoundary.status = COMPLETED;
+      request.completedBoundaries.push(resumedBoundary); // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    resumedBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+      const postponeInstance = error;
+      logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+      errorDigest = 'POSTPONE';
+    } else {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    resumedBoundary.errorDigest = errorDigest;
+
+    task.replay.pendingTasks--; // The parent already flushed in the prerender so we need to schedule this to be emitted.
+
+    request.clientRenderedBoundaries.push(resumedBoundary); // We don't need to decrement any task numbers because we didn't spawn any new task.
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.replay = previousReplaySet;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]]; // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+  const fallbackReplay = {
+    nodes: fallbackNodes,
+    slots: fallbackSlots,
+    pendingTasks: 0
+  };
+  const suspendedFallbackTask = createReplayTask(request, null, fallbackReplay, fallback, -1, parentBoundary, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function renderHostElement(request, task, keyPath, type, props) {
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    const children = props.children; // TODO: Make this a Config for replaying.
+
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+  } else {
+    // Render
+    const children = pushStartInstance(segment.chunks, type, props, request.resumableState, request.renderState, task.formatContext, segment.lastPushedText);
+    segment.lastPushedText = false;
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+    pushEndInstance(segment.chunks, type, props, request.resumableState, prevContext);
+    segment.lastPushedText = false;
+  }
+}
+
+function shouldConstruct(Component) {
+  return Component.prototype && Component.prototype.isReactComponent;
+}
+
+function renderWithHooks(request, task, keyPath, prevThenableState, Component, props, secondArg) {
+  const componentIdentity = {};
+  prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState);
+  const result = Component(props, secondArg);
+  return finishHooks(Component, props, result, secondArg);
+}
+
+function finishClassComponent(request, task, keyPath, instance, Component, props) {
+  const nextChildren = instance.render();
+
+  {
+    const childContextTypes = Component.childContextTypes;
+
+    if (childContextTypes !== null && childContextTypes !== undefined) {
+      const previousContext = task.legacyContext;
+      const mergedContext = processChildContext(instance, Component, previousContext, childContextTypes);
+      task.legacyContext = mergedContext;
+      renderNodeDestructive(request, task, null, nextChildren, -1);
+      task.legacyContext = previousContext;
+      return;
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, nextChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderClassComponent(request, task, keyPath, Component, props) {
+  const maskedContext = getMaskedContext(Component, task.legacyContext) ;
+  const instance = constructClassInstance(Component, props, maskedContext);
+  mountClassInstance(instance, Component, props, maskedContext);
+  finishClassComponent(request, task, keyPath, instance, Component);
+}
+// components for some reason.
+
+function renderIndeterminateComponent(request, task, keyPath, prevThenableState, Component, props) {
+  let legacyContext;
+
+  {
+    legacyContext = getMaskedContext(Component, task.legacyContext);
+  }
+
+  const value = renderWithHooks(request, task, keyPath, prevThenableState, Component, props, legacyContext);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+
+  if ( // Run these checks in production only if the flag is off.
+  // Eventually we'll delete this branch altogether.
+  typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) {
+
+    mountClassInstance(value, Component, props, legacyContext);
+    finishClassComponent(request, task, keyPath, value, Component);
+  } else {
+
+    finishFunctionComponent(request, task, keyPath, value, hasId, formStateCount, formStateMatchingIndex);
+  }
+}
+
+function finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex) {
+  let didEmitFormStateMarkers = false;
+
+  if (formStateCount !== 0 && request.formState !== null) {
+    // For each useFormState hook, emit a marker that indicates whether we
+    // rendered using the form state passed at the root. We only emit these
+    // markers if form state is passed at the root.
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      didEmitFormStateMarkers = true;
+      const target = segment.chunks;
+
+      for (let i = 0; i < formStateCount; i++) {
+        if (i === formStateMatchingIndex) {
+          pushFormStateMarkerIsMatching(target);
+        } else {
+          pushFormStateMarkerIsNotMatching(target);
+        }
+      }
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+
+  if (hasId) {
+    // This component materialized an id. We treat this as its own level, with
+    // a single "child" slot.
+    const prevTreeContext = task.treeContext;
+    const totalChildren = 1;
+    const index = 0; // Modify the id context. Because we'll need to reset this if something
+    // suspends or errors, we'll use the non-destructive render path.
+
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, index);
+    renderNode(request, task, children, -1); // Like the other contexts, this does not need to be in a finally block
+    // because renderNode takes care of unwinding the stack.
+
+    task.treeContext = prevTreeContext;
+  } else if (didEmitFormStateMarkers) {
+    // If there were formState hooks, we must use the non-destructive path
+    // because this component is not a pure indirection; we emitted markers
+    // to the stream.
+    renderNode(request, task, children, -1);
+  } else {
+    // We're now successfully past this task, and we haven't modified the
+    // context stack. We don't have to pop back to the previous task every
+    // again, so we can use the destructive recursive form.
+    renderNodeDestructive(request, task, null, children, -1);
+  }
+
+  task.keyPath = prevKeyPath;
+}
+
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    // Resolve default props. Taken from ReactElement
+    const props = assign({}, baseProps);
+    const defaultProps = Component.defaultProps;
+
+    for (const propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+
+    return props;
+  }
+
+  return baseProps;
+}
+
+function renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref) {
+  const children = renderWithHooks(request, task, keyPath, prevThenableState, type.render, props, ref);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+  finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex);
+}
+
+function renderMemo(request, task, keyPath, prevThenableState, type, props, ref) {
+  const innerType = type.type;
+  const resolvedProps = resolveDefaultProps(innerType, props);
+  renderElement(request, task, keyPath, prevThenableState, innerType, resolvedProps, ref);
+}
+
+function renderContextConsumer(request, task, keyPath, context, props) {
+
+  const render = props.children;
+
+  const newValue = readContext$1(context);
+  const newChildren = render(newValue);
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, newChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderContextProvider(request, task, keyPath, type, props) {
+  const context = type._context;
+  const value = props.value;
+  const children = props.children;
+
+  const prevKeyPath = task.keyPath;
+  task.context = pushProvider(context, value);
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, children, -1);
+  task.context = popProvider();
+  task.keyPath = prevKeyPath;
+}
+
+function renderLazyComponent(request, task, keyPath, prevThenableState, lazyComponent, props, ref) {
+  const payload = lazyComponent._payload;
+  const init = lazyComponent._init;
+  const Component = init(payload);
+  const resolvedProps = resolveDefaultProps(Component, props);
+  renderElement(request, task, keyPath, prevThenableState, Component, resolvedProps, ref);
+}
+
+function renderOffscreen(request, task, keyPath, props) {
+  const mode = props.mode;
+
+  if (mode === 'hidden') ; else {
+    // A visible Offscreen boundary is treated exactly like a fragment: a
+    // pure indirection.
+    const prevKeyPath = task.keyPath;
+    task.keyPath = keyPath;
+    renderNodeDestructive(request, task, null, props.children, -1);
+    task.keyPath = prevKeyPath;
+  }
+}
+
+function renderElement(request, task, keyPath, prevThenableState, type, props, ref) {
+  if (typeof type === 'function') {
+    if (shouldConstruct(type)) {
+      renderClassComponent(request, task, keyPath, type, props);
+      return;
+    } else {
+      renderIndeterminateComponent(request, task, keyPath, prevThenableState, type, props);
+      return;
+    }
+  }
+
+  if (typeof type === 'string') {
+    renderHostElement(request, task, keyPath, type, props);
+    return;
+  }
+
+  switch (type) {
+    // LegacyHidden acts the same as a fragment. This only works because we
+    // currently assume that every instance of LegacyHidden is accompanied by a
+    // host component wrapper. In the hidden mode, the host component is given a
+    // `hidden` attribute, which ensures that the initial HTML is not visible.
+    // To support the use of LegacyHidden as a true fragment, without an extra
+    // DOM node, we would have to hide the initial HTML in some other way.
+    // TODO: Delete in LegacyHidden. It's an unstable API only used in the
+    // www build. As a migration step, we could add a special prop to Offscreen
+    // that simulates the old behavior (no hiding, no change to effects).
+    case REACT_LEGACY_HIDDEN_TYPE:
+    case REACT_DEBUG_TRACING_MODE_TYPE:
+    case REACT_STRICT_MODE_TYPE:
+    case REACT_PROFILER_TYPE:
+    case REACT_FRAGMENT_TYPE:
+      {
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_OFFSCREEN_TYPE:
+      {
+        renderOffscreen(request, task, keyPath, props);
+        return;
+      }
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      {
+
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_SCOPE_TYPE:
+      {
+
+        throw Error(formatProdErrorMessage(343));
+      }
+
+    case REACT_SUSPENSE_TYPE:
+      {
+        {
+          renderSuspenseBoundary(request, task, keyPath, props);
+        }
+
+        return;
+      }
+  }
+
+  if (typeof type === 'object' && type !== null) {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        {
+          renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          renderMemo(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_PROVIDER_TYPE:
+        {
+          renderContextProvider(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_CONTEXT_TYPE:
+        {
+          renderContextConsumer(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_LAZY_TYPE:
+        {
+          renderLazyComponent(request, task, keyPath, prevThenableState, type, props);
+          return;
+        }
+    }
+  }
+
+  let info = '';
+
+  throw Error(formatProdErrorMessage(130, type == null ? type : typeof type, info));
+}
+
+function resumeNode(request, task, segmentId, node, childIndex) {
+  const prevReplay = task.replay;
+  const blockedBoundary = task.blockedBoundary;
+  const resumedSegment = createPendingSegment(request, 0, null, task.formatContext, false, false);
+  resumedSegment.id = segmentId;
+  resumedSegment.parentFlushed = true;
+
+  try {
+    // Convert the current ReplayTask to a RenderTask.
+    const renderTask = task;
+    renderTask.replay = null;
+    renderTask.blockedSegment = resumedSegment;
+    renderNode(request, task, node, childIndex);
+    resumedSegment.status = COMPLETED;
+
+    if (blockedBoundary === null) {
+      request.completedRootSegment = resumedSegment;
+    } else {
+      queueCompletedSegment(blockedBoundary, resumedSegment);
+
+      if (blockedBoundary.parentFlushed) {
+        request.partialBoundaries.push(blockedBoundary);
+      }
+    }
+  } finally {
+    // Restore to a ReplayTask.
+    task.replay = prevReplay;
+    task.blockedSegment = null;
+  }
+}
+
+function replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, replay) {
+  // We're replaying. Find the path to follow.
+  const replayNodes = replay.nodes;
+
+  for (let i = 0; i < replayNodes.length; i++) {
+    // Flow doesn't support refinement on tuples so we do it manually here.
+    const node = replayNodes[i];
+
+    if (keyOrIndex !== node[1]) {
+      continue;
+    }
+
+    if (node.length === 4) {
+      // Matched a replayable path.
+      // Let's double check that the component name matches as a precaution.
+      if (name !== null && name !== node[0]) {
+        throw Error(formatProdErrorMessage(490, node[0], name));
+      }
+
+      const childNodes = node[2];
+      const childSlots = node[3];
+      const currentNode = task.node;
+      task.replay = {
+        nodes: childNodes,
+        slots: childSlots,
+        pendingTasks: 1
+      };
+
+      try {
+        renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+
+        if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0 // TODO check remaining slots
+        ) {
+            throw Error(formatProdErrorMessage(488));
+          }
+
+        task.replay.pendingTasks--;
+      } catch (x) {
+        if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+          // Suspend
+          if (task.node === currentNode) {
+            // This same element suspended so we need to pop the replay we just added.
+            task.replay = replay;
+          }
+
+          throw x;
+        }
+
+        task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+        // during a replay. That's because this component didn't actually error
+        // in the original prerender. What's unable to complete is the child
+        // replay nodes which might be Suspense boundaries which are able to
+        // absorb the error and we can still continue with siblings.
+
+        erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+      }
+
+      task.replay = replay;
+    } else {
+      // Let's double check that the component type matches.
+      if (type !== REACT_SUSPENSE_TYPE) {
+        const expectedType = 'Suspense';
+        throw Error(formatProdErrorMessage(490, expectedType, getComponentNameFromType(type) || 'Unknown'));
+      } // Matched a replayable path.
+
+
+      replaySuspenseBoundary(request, task, keyPath, props, node[5], node[2], node[3], node[4] === null ? [] : node[4][2], node[4] === null ? null : node[4][3]);
+    } // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+
+    replayNodes.splice(i, 1);
+    return;
+  } // We didn't find any matching nodes. We assume that this element was already
+  // rendered in the prelude and skip it.
+
+} // $FlowFixMe[missing-local-annot]
+
+function renderNodeDestructive(request, task, // The thenable state reused from the previous attempt, if any. This is almost
+// always null, except when called by retryTask.
+prevThenableState, node, childIndex) {
+  {
+    return renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex);
+  }
+} // This function by it self renders a node and consumes the task by mutating it
+// to update the current execution state.
+
+
+function renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex) {
+  if (task.replay !== null && typeof task.replay.slots === 'number') {
+    // TODO: Figure out a cheaper place than this hot path to do this check.
+    const resumeSegmentID = task.replay.slots;
+    resumeNode(request, task, resumeSegmentID, node, childIndex);
+    return;
+  } // Stash the node we're working on. We'll pick up from this task in case
+  // something suspends.
+
+
+  task.node = node;
+  task.childIndex = childIndex; // Handle object types
+
+  if (typeof node === 'object' && node !== null) {
+    switch (node.$$typeof) {
+      case REACT_ELEMENT_TYPE:
+        {
+          const element = node;
+          const type = element.type;
+          const key = element.key;
+          const props = element.props;
+          const ref = element.ref;
+          const name = getComponentNameFromType(type);
+          const keyOrIndex = key == null ? childIndex === -1 ? 0 : childIndex : key;
+          const keyPath = [task.keyPath, name, keyOrIndex];
+
+          if (task.replay !== null) {
+            replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, task.replay); // No matches found for this node. We assume it's already emitted in the
+            // prelude and skip it during the replay.
+          } else {
+            // We're doing a plain render.
+            renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+          }
+
+          return;
+        }
+
+      case REACT_PORTAL_TYPE:
+        throw Error(formatProdErrorMessage(257));
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyNode = node;
+          const payload = lazyNode._payload;
+          const init = lazyNode._init;
+          let resolvedNode;
+
+          {
+            resolvedNode = init(payload);
+          }
+
+          renderNodeDestructive(request, task, null, resolvedNode, childIndex);
+          return;
+        }
+    }
+
+    if (isArray(node)) {
+      renderChildrenArray(request, task, node, childIndex);
+      return;
+    }
+
+    const iteratorFn = getIteratorFn(node);
+
+    if (iteratorFn) {
+
+      const iterator = iteratorFn.call(node);
+
+      if (iterator) {
+        // We need to know how many total children are in this set, so that we
+        // can allocate enough id slots to acommodate them. So we must exhaust
+        // the iterator before we start recursively rendering the children.
+        // TODO: This is not great but I think it's inherent to the id
+        // generation algorithm.
+        let step = iterator.next(); // If there are not entries, we need to push an empty so we start by checking that.
+
+        if (!step.done) {
+          const children = [];
+
+          do {
+            children.push(step.value);
+            step = iterator.next();
+          } while (!step.done);
+
+          renderChildrenArray(request, task, children, childIndex);
+          return;
+        }
+
+        return;
+      }
+    } // Usables are a valid React node type. When React encounters a Usable in
+    // a child position, it unwraps it using the same algorithm as `use`. For
+    // example, for promises, React will throw an exception to unwind the
+    // stack, then replay the component once the promise resolves.
+    //
+    // A difference from `use` is that React will keep unwrapping the value
+    // until it reaches a non-Usable type.
+    //
+    // e.g. Usable<Usable<Usable<T>>> should resolve to T
+
+
+    const maybeUsable = node;
+
+    if (typeof maybeUsable.then === 'function') {
+      const thenable = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, unwrapThenable(thenable), childIndex);
+    }
+
+    if (maybeUsable.$$typeof === REACT_CONTEXT_TYPE || maybeUsable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, readContext$1(context), childIndex);
+    } // $FlowFixMe[method-unbinding]
+
+
+    const childString = Object.prototype.toString.call(node);
+    throw Error(formatProdErrorMessage(31, childString === '[object Object]' ? 'object with keys {' + Object.keys(node).join(', ') + '}' : childString));
+  }
+
+  if (typeof node === 'string') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+
+  if (typeof node === 'number') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, '' + node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+}
+
+function replayFragment(request, task, children, childIndex) {
+  // If we're supposed follow this array, we'd expect to see a ReplayNode matching
+  // this fragment.
+  const replay = task.replay;
+  const replayNodes = replay.nodes;
+
+  for (let j = 0; j < replayNodes.length; j++) {
+    const node = replayNodes[j];
+
+    if (node[1] !== childIndex) {
+      continue;
+    } // Matched a replayable path.
+
+
+    const childNodes = node[2];
+    const childSlots = node[3];
+    task.replay = {
+      nodes: childNodes,
+      slots: childSlots,
+      pendingTasks: 1
+    };
+
+    try {
+      renderChildrenArray(request, task, children, -1);
+
+      if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+        throw Error(formatProdErrorMessage(488));
+      }
+
+      task.replay.pendingTasks--;
+    } catch (x) {
+      if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+        // Suspend
+        throw x;
+      }
+
+      task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+      // during a replay. That's because this component didn't actually error
+      // in the original prerender. What's unable to complete is the child
+      // replay nodes which might be Suspense boundaries which are able to
+      // absorb the error and we can still continue with siblings.
+      // This is an error, stash the component stack if it is null.
+
+      erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+    }
+
+    task.replay = replay; // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+    replayNodes.splice(j, 1);
+    break;
+  }
+}
+
+function renderChildrenArray(request, task, children, childIndex) {
+  const prevKeyPath = task.keyPath;
+
+  if (childIndex !== -1) {
+    task.keyPath = [task.keyPath, 'Fragment', childIndex];
+
+    if (task.replay !== null) {
+      replayFragment(request, // $FlowFixMe: Refined.
+      task, children, childIndex);
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  const prevTreeContext = task.treeContext;
+  const totalChildren = children.length;
+
+  if (task.replay !== null) {
+    // Replay
+    // First we need to check if we have any resume slots at this level.
+    const resumeSlots = task.replay.slots;
+
+    if (resumeSlots !== null && typeof resumeSlots === 'object') {
+      for (let i = 0; i < totalChildren; i++) {
+        const node = children[i];
+        task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+        // up and render the sibling if something suspends.
+
+        const resumeSegmentID = resumeSlots[i]; // TODO: If this errors we should still continue with the next sibling.
+
+        if (typeof resumeSegmentID === 'number') {
+          resumeNode(request, task, resumeSegmentID, node, i); // We finished rendering this node, so now we can consume this
+          // slot. This must happen after in case we rerender this task.
+
+          delete resumeSlots[i];
+        } else {
+          renderNode(request, task, node, i);
+        }
+      }
+
+      task.treeContext = prevTreeContext;
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  for (let i = 0; i < totalChildren; i++) {
+    const node = children[i];
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+    // up and render the sibling if something suspends.
+
+    renderNode(request, task, node, i);
+  } // Because this context is always set right before rendering every child, we
+  // only need to reset it to the previous value at the very end.
+
+
+  task.treeContext = prevTreeContext;
+  task.keyPath = prevKeyPath;
+}
+
+function trackPostpone(request, trackedPostpones, task, segment) {
+  segment.status = POSTPONED;
+  const keyPath = task.keyPath;
+  const boundary = task.blockedBoundary;
+
+  if (boundary === null) {
+    segment.id = request.nextSegmentId++;
+    trackedPostpones.rootSlots = segment.id;
+
+    if (request.completedRootSegment !== null) {
+      // Postpone the root if this was a deeper segment.
+      request.completedRootSegment.status = POSTPONED;
+    }
+
+    return;
+  }
+
+  if (boundary !== null && boundary.status === PENDING) {
+    boundary.status = POSTPONED; // We need to eagerly assign it an ID because we'll need to refer to
+    // it before flushing and we know that we can't inline it.
+
+    boundary.rootSegmentID = request.nextSegmentId++;
+    const boundaryKeyPath = boundary.trackedContentKeyPath;
+
+    if (boundaryKeyPath === null) {
+      throw Error(formatProdErrorMessage(486));
+    }
+
+    const fallbackReplayNode = boundary.trackedFallbackNode;
+    const children = [];
+
+    if (boundaryKeyPath === keyPath && task.childIndex === -1) {
+      // Since we postponed directly in the Suspense boundary we can't have written anything
+      // to its segment. Therefore this will end up becoming the root segment.
+      segment.id = boundary.rootSegmentID; // We postponed directly inside the Suspense boundary so we mark this for resuming.
+
+      const boundaryNode = [boundaryKeyPath[1], boundaryKeyPath[2], children, boundary.rootSegmentID, fallbackReplayNode, boundary.rootSegmentID];
+      trackedPostpones.workingMap.set(boundaryKeyPath, boundaryNode);
+      addToReplayParent(boundaryNode, boundaryKeyPath[0], trackedPostpones);
+      return;
+    } else {
+      let boundaryNode = trackedPostpones.workingMap.get(boundaryKeyPath);
+
+      if (boundaryNode === undefined) {
+        boundaryNode = [boundaryKeyPath[1], boundaryKeyPath[2], children, null, fallbackReplayNode, boundary.rootSegmentID];
+        trackedPostpones.workingMap.set(boundaryKeyPath, boundaryNode);
+        addToReplayParent(boundaryNode, boundaryKeyPath[0], trackedPostpones);
+      } else {
+        // Upgrade to ReplaySuspenseBoundary.
+        const suspenseBoundary = boundaryNode;
+        suspenseBoundary[4] = fallbackReplayNode;
+        suspenseBoundary[5] = boundary.rootSegmentID;
+      } // Fall through to add the child node.
+
+    }
+  } // We know that this will leave a hole so we might as well assign an ID now.
+  // We might have one already if we had a parent that gave us its ID.
+
+
+  if (segment.id === -1) {
+    if (segment.parentFlushed && boundary !== null) {
+      // If this segment's parent was already flushed, it means we really just
+      // skipped the parent and this segment is now the root.
+      segment.id = boundary.rootSegmentID;
+    } else {
+      segment.id = request.nextSegmentId++;
+    }
+  }
+
+  if (task.childIndex === -1) {
+    // Resume starting from directly inside the previous parent element.
+    if (keyPath === null) {
+      trackedPostpones.rootSlots = segment.id;
+    } else {
+      const workingMap = trackedPostpones.workingMap;
+      let resumableNode = workingMap.get(keyPath);
+
+      if (resumableNode === undefined) {
+        resumableNode = [keyPath[1], keyPath[2], [], segment.id];
+        addToReplayParent(resumableNode, keyPath[0], trackedPostpones);
+      } else {
+        resumableNode[3] = segment.id;
+      }
+    }
+  } else {
+    let slots;
+
+    if (keyPath === null) {
+      slots = trackedPostpones.rootSlots;
+
+      if (slots === null) {
+        slots = trackedPostpones.rootSlots = {};
+      } else if (typeof slots === 'number') {
+        throw Error(formatProdErrorMessage(491));
+      }
+    } else {
+      const workingMap = trackedPostpones.workingMap;
+      let resumableNode = workingMap.get(keyPath);
+
+      if (resumableNode === undefined) {
+        slots = {};
+        resumableNode = [keyPath[1], keyPath[2], [], slots];
+        workingMap.set(keyPath, resumableNode);
+        addToReplayParent(resumableNode, keyPath[0], trackedPostpones);
+      } else {
+        slots = resumableNode[3];
+
+        if (slots === null) {
+          slots = resumableNode[3] = {};
+        } else if (typeof slots === 'number') {
+          throw Error(formatProdErrorMessage(491));
+        }
+      }
+    }
+
+    slots[task.childIndex] = segment.id;
+  }
+}
+
+function injectPostponedHole(request, task, reason) {
+  logPostpone(request, reason); // Something suspended, we'll need to create a new segment and resolve it later.
+
+  const segment = task.blockedSegment;
+  const insertionIndex = segment.chunks.length;
+  const newSegment = createPendingSegment(request, insertionIndex, null, task.formatContext, // Adopt the parent segment's leading text embed
+  segment.lastPushedText, // Assume we are text embedded at the trailing edge
+  true);
+  segment.children.push(newSegment); // Reset lastPushedText for current Segment since the new Segment "consumed" it
+
+  segment.lastPushedText = false;
+  return newSegment;
+}
+
+function spawnNewSuspendedReplayTask(request, task, thenableState, x) {
+  const newTask = createReplayTask(request, thenableState, task.replay, task.node, task.childIndex, task.blockedBoundary, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+}
+
+function spawnNewSuspendedRenderTask(request, task, thenableState, x) {
+  // Something suspended, we'll need to create a new segment and resolve it later.
+  const segment = task.blockedSegment;
+  const insertionIndex = segment.chunks.length;
+  const newSegment = createPendingSegment(request, insertionIndex, null, task.formatContext, // Adopt the parent segment's leading text embed
+  segment.lastPushedText, // Assume we are text embedded at the trailing edge
+  true);
+  segment.children.push(newSegment); // Reset lastPushedText for current Segment since the new Segment "consumed" it
+
+  segment.lastPushedText = false;
+  const newTask = createRenderTask(request, thenableState, task.node, task.childIndex, task.blockedBoundary, newSegment, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+} // This is a non-destructive form of rendering a node. If it suspends it spawns
+// a new task and restores the context of this task to what it was before.
+
+
+function renderNode(request, task, node, childIndex) {
+  // Snapshot the current context in case something throws to interrupt the
+  // process.
+  const previousFormatContext = task.formatContext;
+  const previousLegacyContext = task.legacyContext;
+  const previousContext = task.context;
+  const previousKeyPath = task.keyPath;
+  const previousTreeContext = task.treeContext;
+
+  let x; // Store how much we've pushed at this point so we can reset it in case something
+  // suspended partially through writing something.
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState();
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedReplayTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+      } // TODO: Abort any undiscovered Suspense boundaries in the ReplayNode.
+
+    }
+  } else {
+    // Render
+    const childrenLength = segment.children.length;
+    const chunkLength = segment.chunks.length;
+
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState(); // Reset the write pointers to where we started.
+
+      segment.children.length = childrenLength;
+      segment.chunks.length = chunkLength;
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedRenderTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+
+        if (request.trackedPostpones !== null && x.$$typeof === REACT_POSTPONE_TYPE && task.blockedBoundary !== null // bubble if we're postponing in the shell
+        ) {
+            // If we're tracking postpones, we inject a hole here and continue rendering
+            // sibling. Similar to suspending. If we're not tracking, we treat it more like
+            // an error. Notably this doesn't spawn a new task since nothing will fill it
+            // in during this prerender.
+            const postponeInstance = x;
+            const trackedPostpones = request.trackedPostpones;
+            const postponedSegment = injectPostponedHole(request, task, // We don't use ReplayTasks in prerenders.
+            postponeInstance.message);
+            trackPostpone(request, trackedPostpones, task, postponedSegment); // Restore the context. We assume that this will be restored by the inner
+            // functions in case nothing throws so we don't use "finally" here.
+
+            task.formatContext = previousFormatContext;
+            task.legacyContext = previousLegacyContext;
+            task.context = previousContext;
+            task.keyPath = previousKeyPath;
+            task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+            switchContext(previousContext);
+            return;
+          }
+      }
+    }
+  } // Restore the context. We assume that this will be restored by the inner
+  // functions in case nothing throws so we don't use "finally" here.
+
+
+  task.formatContext = previousFormatContext;
+  task.legacyContext = previousLegacyContext;
+  task.context = previousContext;
+  task.keyPath = previousKeyPath;
+  task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+  switchContext(previousContext);
+  // Let's terminate the rest of the tree and don't render any siblings.
+
+
+  throw x;
+}
+
+function erroredReplay(request, boundary, error, replayNodes, resumeSlots) {
+  // Erroring during a replay doesn't actually cause an error by itself because
+  // that component has already rendered. What causes the error is the resumable
+  // points that we did not yet finish which will be below the point of the reset.
+  // For example, if we're replaying a path to a Suspense boundary that is not done
+  // that doesn't error the parent Suspense boundary.
+  // This might be a bit strange that the error in a parent gets thrown at a child.
+  // We log it only once and reuse the digest.
+  let errorDigest;
+
+  if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+    const postponeInstance = error;
+    logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+    errorDigest = 'POSTPONE';
+  } else {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  abortRemainingReplayNodes(request, boundary, replayNodes, resumeSlots, error, errorDigest);
+}
+
+function erroredTask(request, boundary, error) {
+  // Report the error to a global handler.
+  let errorDigest;
+
+  if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+    const postponeInstance = error;
+    logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+    errorDigest = 'POSTPONE';
+  } else {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  if (boundary === null) {
+    fatalError(request, error);
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+      // so we can flush it, if the parent already flushed.
+
+
+      if (boundary.parentFlushed) {
+        // We don't have a preference where in the queue this goes since it's likely
+        // to error on the client anyway. However, intentionally client-rendered
+        // boundaries should be flushed earlier so that they can start on the client.
+        // We reuse the same queue for errors.
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function abortTaskSoft(task) {
+  // This aborts task without aborting the parent boundary that it blocks.
+  // It's used for when we didn't need this task to complete the tree.
+  // If task was needed, then it should use abortTask instead.
+  const request = this;
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+    finishedTask(request, boundary, segment);
+  }
+}
+
+function abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest) {
+  const resumedBoundary = createSuspenseBoundary(request, new Set());
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = rootSegmentID;
+  resumedBoundary.status = CLIENT_RENDERED;
+  resumedBoundary.errorDigest = errorDigest;
+
+  if (resumedBoundary.parentFlushed) {
+    request.clientRenderedBoundaries.push(resumedBoundary);
+  }
+}
+
+function abortRemainingReplayNodes(request, boundary, nodes, slots, error, errorDigest) {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+
+    if (node.length === 4) {
+      abortRemainingReplayNodes(request, boundary, node[2], node[3], error, errorDigest);
+    } else {
+      const boundaryNode = node;
+      const rootSegmentID = boundaryNode[5];
+      abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest);
+    }
+  } // Empty the set, since we've cleared it now.
+
+
+  nodes.length = 0;
+
+  if (slots !== null) {
+    // We had something still to resume in the parent boundary. We must trigger
+    // the error on the parent boundary since it's not able to complete.
+    if (boundary === null) {
+      throw Error(formatProdErrorMessage(487));
+    } else if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // Empty the set
+
+
+    if (typeof slots === 'object') {
+      for (const index in slots) {
+        delete slots[index];
+      }
+    }
+  }
+}
+
+function abortTask(task, request, error) {
+  // This aborts the task and aborts the parent that it blocks, putting it into
+  // client rendered mode.
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+  }
+
+  if (boundary === null) {
+    if (request.status !== CLOSING && request.status !== CLOSED) {
+      const replay = task.replay;
+
+      if (replay === null) {
+        // We didn't complete the root so we have nothing to show. We can close
+        // the request;
+        logRecoverableError(request, error);
+        fatalError(request, error);
+        return;
+      } else {
+        // If the shell aborts during a replay, that's not a fatal error. Instead
+        // we should be able to recover by client rendering all the root boundaries in
+        // the ReplaySet.
+        replay.pendingTasks--;
+
+        if (replay.pendingTasks === 0 && replay.nodes.length > 0) {
+          const errorDigest = logRecoverableError(request, error);
+          abortRemainingReplayNodes(request, null, replay.nodes, replay.slots, error, errorDigest);
+        }
+
+        request.pendingRootTasks--;
+
+        if (request.pendingRootTasks === 0) {
+          completeShell(request);
+        }
+      }
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = logRecoverableError(request, error);
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // If this boundary was still pending then we haven't already cancelled its fallbacks.
+    // We'll need to abort the fallbacks, which will also error that parent boundary.
+
+
+    boundary.fallbackAbortableTasks.forEach(fallbackTask => abortTask(fallbackTask, request, error));
+    boundary.fallbackAbortableTasks.clear();
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeShell(request) {
+  if (request.trackedPostpones === null) {
+    // We only emit early preloads on shell completion for renders. For prerenders
+    // we wait for the entire Request to finish because we are not responding to a
+    // live request and can wait for as much data as possible.
+    // we should only be calling completeShell when the shell is complete so we
+    // just use a literal here
+    const shellComplete = true;
+    emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  } // We have completed the shell so the shell can't error anymore.
+
+
+  request.onShellError = noop;
+  const onShellReady = request.onShellReady;
+  onShellReady();
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeAll(request) {
+  // During a render the shell must be complete if the entire request is finished
+  // however during a Prerender it is possible that the shell is incomplete because
+  // it postponed. We cannot use rootPendingTasks in the prerender case because
+  // those hit zero even when the shell postpones. Instead we look at the completedRootSegment
+  const shellComplete = request.trackedPostpones === null ? // Render, we assume it is completed
+  true : // Prerender Request, we use the state of the root segment
+  request.completedRootSegment === null || request.completedRootSegment.status !== POSTPONED;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  const onAllReady = request.onAllReady;
+  onAllReady();
+}
+
+function queueCompletedSegment(boundary, segment) {
+  if (segment.chunks.length === 0 && segment.children.length === 1 && segment.children[0].boundary === null) {
+    // This is an empty segment. There's nothing to write, so we can instead transfer the ID
+    // to the child. That way any existing references point to the child.
+    const childSegment = segment.children[0];
+    childSegment.id = segment.id;
+    childSegment.parentFlushed = true;
+
+    if (childSegment.status === COMPLETED) {
+      queueCompletedSegment(boundary, childSegment);
+    }
+  } else {
+    const completedSegments = boundary.completedSegments;
+    completedSegments.push(segment);
+  }
+}
+
+function finishedTask(request, boundary, segment) {
+  if (boundary === null) {
+    if (segment !== null && segment.parentFlushed) {
+      if (request.completedRootSegment !== null) {
+        throw Error(formatProdErrorMessage(389));
+      }
+
+      request.completedRootSegment = segment;
+    }
+
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status === CLIENT_RENDERED) ; else if (boundary.pendingTasks === 0) {
+      if (boundary.status === PENDING) {
+        boundary.status = COMPLETED;
+      } // This must have been the last segment we were waiting on. This boundary is now complete.
+
+
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent segment already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+        }
+      }
+
+      if (boundary.parentFlushed) {
+        // The segment might be part of a segment that didn't flush yet, but if the boundary's
+        // parent flushed, we need to schedule the boundary to be emitted.
+        request.completedBoundaries.push(boundary);
+      } // We can now cancel any pending task on the fallback since we won't need to show it anymore.
+      // This needs to happen after we read the parentFlushed flags because aborting can finish
+      // work which can trigger user code, which can start flushing, which can change those flags.
+      // If the boundary was POSTPONED, we still need to finish the fallback first.
+
+
+      if (boundary.status === COMPLETED) {
+        boundary.fallbackAbortableTasks.forEach(abortTaskSoft, request);
+        boundary.fallbackAbortableTasks.clear();
+      }
+    } else {
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+          const completedSegments = boundary.completedSegments;
+
+          if (completedSegments.length === 1) {
+            // This is the first time since we last flushed that we completed anything.
+            // We can schedule this boundary to emit its partially completed segments early
+            // in case the parent has already been flushed.
+            if (boundary.parentFlushed) {
+              request.partialBoundaries.push(boundary);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function retryTask(request, task) {
+  {
+    const blockedBoundary = task.blockedBoundary;
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, blockedBoundary ? blockedBoundary.resources : null);
+  }
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    retryReplayTask(request, // $FlowFixMe: Refined.
+    task);
+  } else {
+    retryRenderTask(request, // $FlowFixMe: Refined.
+    task, segment);
+  }
+}
+
+function retryRenderTask(request, task, segment) {
+  if (segment.status !== PENDING) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  const childrenLength = segment.children.length;
+  const chunkLength = segment.chunks.length;
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+    pushSegmentFinale(segment.chunks, request.renderState, segment.lastPushedText, segment.textEmbedded);
+    task.abortSet.delete(task);
+    segment.status = COMPLETED;
+    finishedTask(request, task.blockedBoundary, segment);
+  } catch (thrownValue) {
+    resetHooksState(); // Reset the write pointers to where we started.
+
+    segment.children.length = childrenLength;
+    segment.chunks.length = chunkLength;
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      } else if (request.trackedPostpones !== null && x.$$typeof === REACT_POSTPONE_TYPE) {
+        // If we're tracking postpones, we mark this segment as postponed and finish
+        // the task without filling it in. If we're not tracking, we treat it more like
+        // an error.
+        const trackedPostpones = request.trackedPostpones;
+        task.abortSet.delete(task);
+        const postponeInstance = x;
+        logPostpone(request, postponeInstance.message);
+        trackPostpone(request, trackedPostpones, task, segment);
+        finishedTask(request, task.blockedBoundary, segment);
+        return;
+      }
+    }
+
+    task.abortSet.delete(task);
+    segment.status = ERRORED;
+    erroredTask(request, task.blockedBoundary, x);
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function retryReplayTask(request, task) {
+  if (task.replay.pendingTasks === 0) {
+    // There are no pending tasks working on this set, so we must have aborted.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw Error(formatProdErrorMessage(488));
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    finishedTask(request, task.blockedBoundary, null);
+  } catch (thrownValue) {
+    resetHooksState();
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    erroredReplay(request, task.blockedBoundary, x, task.replay.nodes, task.replay.slots);
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+
+    request.allPendingTasks--;
+
+    if (request.allPendingTasks === 0) {
+      completeAll(request);
+    }
+
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function performWork(request) {
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  const prevContext = getActiveContext();
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  let prevCacheDispatcher;
+
+  {
+    prevCacheDispatcher = ReactCurrentCache.current;
+    ReactCurrentCache.current = DefaultCacheDispatcher;
+  }
+
+  const prevRequest = currentRequest;
+  currentRequest = request;
+
+  const prevResumableState = currentResumableState;
+  setCurrentResumableState(request.resumableState);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    let i;
+
+    for (i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    pingedTasks.splice(0, i);
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    setCurrentResumableState(prevResumableState);
+    ReactCurrentDispatcher.current = prevDispatcher;
+
+    {
+      ReactCurrentCache.current = prevCacheDispatcher;
+    }
+
+    if (prevDispatcher === HooksDispatcher) {
+      // This means that we were in a reentrant work loop. This could happen
+      // in a renderer that supports synchronous work like renderToString,
+      // when it's called from within another renderer.
+      // Normally we don't bother switching the contexts to their root/default
+      // values when leaving because we'll likely need the same or similar
+      // context again. However, when we're inside a synchronous loop like this
+      // we'll to restore the context to what it was before returning.
+      switchContext(prevContext);
+    }
+
+    currentRequest = prevRequest;
+  }
+}
+
+function flushSubtree(request, destination, segment) {
+  segment.parentFlushed = true;
+
+  switch (segment.status) {
+    case PENDING:
+      {
+        // We're emitting a placeholder for this segment to be filled in later.
+        // Therefore we'll need to assign it an ID - to refer to it by.
+        segment.id = request.nextSegmentId++; // Fallthrough
+      }
+
+    case POSTPONED:
+      {
+        const segmentID = segment.id; // When this segment finally completes it won't be embedded in text since it will flush separately
+
+        segment.lastPushedText = false;
+        segment.textEmbedded = false;
+        return writePlaceholder(destination, request.renderState, segmentID);
+      }
+
+    case COMPLETED:
+      {
+        segment.status = FLUSHED;
+        let r = true;
+        const chunks = segment.chunks;
+        let chunkIdx = 0;
+        const children = segment.children;
+
+        for (let childIdx = 0; childIdx < children.length; childIdx++) {
+          const nextChild = children[childIdx]; // Write all the chunks up until the next child.
+
+          for (; chunkIdx < nextChild.index; chunkIdx++) {
+            writeChunk(destination, chunks[chunkIdx]);
+          }
+
+          r = flushSegment(request, destination, nextChild);
+        } // Finally just write all the remaining chunks
+
+
+        for (; chunkIdx < chunks.length - 1; chunkIdx++) {
+          writeChunk(destination, chunks[chunkIdx]);
+        }
+
+        if (chunkIdx < chunks.length) {
+          r = writeChunkAndReturn(destination, chunks[chunkIdx]);
+        }
+
+        return r;
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(390));
+      }
+  }
+}
+
+function flushSegment(request, destination, segment) {
+  const boundary = segment.boundary;
+
+  if (boundary === null) {
+    // Not a suspense boundary.
+    return flushSubtree(request, destination, segment);
+  }
+
+  boundary.parentFlushed = true; // This segment is a Suspense boundary. We need to decide whether to
+  // emit the content or the fallback now.
+
+  if (boundary.status === CLIENT_RENDERED) {
+    // Emit a client rendered suspense boundary wrapper.
+    // We never queue the inner boundary so we'll never emit its content or partial segments.
+    writeStartClientRenderedSuspenseBoundary(destination, request.renderState, boundary.errorDigest); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndClientRenderedSuspenseBoundary(destination, request.renderState);
+  } else if (boundary.status !== COMPLETED) {
+    if (boundary.status === PENDING) {
+      // For pending boundaries we lazily assign an ID to the boundary
+      // and root segment.
+      boundary.rootSegmentID = request.nextSegmentId++;
+    }
+
+    if (boundary.completedSegments.length > 0) {
+      // If this is at least partially complete, we can queue it to be partially emitted early.
+      request.partialBoundaries.push(boundary);
+    } // This boundary is still loading. Emit a pending suspense boundary wrapper.
+
+
+    const id = boundary.rootSegmentID;
+    writeStartPendingSuspenseBoundary(destination, request.renderState, id); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else if (boundary.byteSize > request.progressiveChunkSize) {
+    // This boundary is large and will be emitted separately so that we can progressively show
+    // other content. We add it to the queue during the flush because we have to ensure that
+    // the parent flushes first so that there's something to inject it into.
+    // We also have to make sure that it's emitted into the queue in a deterministic slot.
+    // I.e. we can't insert it here when it completes.
+    // Assign an ID to refer to the future content by.
+    boundary.rootSegmentID = request.nextSegmentId++;
+    request.completedBoundaries.push(boundary); // Emit a pending rendered suspense boundary wrapper.
+
+    writeStartPendingSuspenseBoundary(destination, request.renderState, boundary.rootSegmentID); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else {
+    {
+      hoistResources(request.renderState, boundary.resources);
+    } // We can inline this boundary's content as a complete boundary.
+
+
+    writeStartCompletedSuspenseBoundary(destination, request.renderState);
+    const completedSegments = boundary.completedSegments;
+
+    if (completedSegments.length !== 1) {
+      throw Error(formatProdErrorMessage(391));
+    }
+
+    const contentSegment = completedSegments[0];
+    flushSegment(request, destination, contentSegment);
+    return writeEndCompletedSuspenseBoundary(destination, request.renderState);
+  }
+}
+
+function flushClientRenderedBoundary(request, destination, boundary) {
+  return writeClientRenderBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.errorDigest, boundary.errorMessage, boundary.errorComponentStack);
+}
+
+function flushSegmentContainer(request, destination, segment) {
+  writeStartSegment(destination, request.renderState, segment.parentFormatContext, segment.id);
+  flushSegment(request, destination, segment);
+  return writeEndSegment(destination, segment.parentFormatContext);
+}
+
+function flushCompletedBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+    flushPartiallyCompletedSegment(request, destination, boundary, segment);
+  }
+
+  completedSegments.length = 0;
+
+  {
+    writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+
+  return writeCompletedBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.resources);
+}
+
+function flushPartialBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+
+    if (!flushPartiallyCompletedSegment(request, destination, boundary, segment)) {
+      i++;
+      completedSegments.splice(0, i); // Only write as much as the buffer wants. Something higher priority
+      // might want to write later.
+
+      return false;
+    }
+  }
+
+  completedSegments.splice(0, i);
+
+  {
+    // The way this is structured we only write resources for partial boundaries
+    // if there is no backpressure. Later before we complete the boundary we
+    // will write resources regardless of backpressure before we emit the
+    // completion instruction
+    return writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+}
+
+function flushPartiallyCompletedSegment(request, destination, boundary, segment) {
+  if (segment.status === FLUSHED) {
+    // We've already flushed this inline.
+    return true;
+  }
+
+  const segmentID = segment.id;
+
+  if (segmentID === -1) {
+    // This segment wasn't previously referred to. This happens at the root of
+    // a boundary. We make kind of a leap here and assume this is the root.
+    const rootSegmentID = segment.id = boundary.rootSegmentID;
+
+    if (rootSegmentID === -1) {
+      throw Error(formatProdErrorMessage(392));
+    }
+
+    return flushSegmentContainer(request, destination, segment);
+  } else if (segmentID === boundary.rootSegmentID) {
+    // When we emit postponed boundaries, we might have assigned the ID already
+    // but it's still the root segment so we can't inject it into the parent yet.
+    return flushSegmentContainer(request, destination, segment);
+  } else {
+    flushSegmentContainer(request, destination, segment);
+    return writeCompletedSegmentInstruction(destination, request.resumableState, request.renderState, segmentID);
+  }
+}
+
+function flushCompletedQueues(request, destination) {
+
+  try {
+    // The structure of this is to go through each queue one by one and write
+    // until the sink tells us to stop. When we should stop, we still finish writing
+    // that item fully and then yield. At that point we remove the already completed
+    // items up until the point we completed them.
+    let i;
+    const completedRootSegment = request.completedRootSegment;
+
+    if (completedRootSegment !== null) {
+      if (completedRootSegment.status === POSTPONED) {
+        // We postponed the root, so we write nothing.
+        return;
+      } else if (request.pendingRootTasks === 0) {
+        if (enableFloat) {
+          writePreamble(destination, request.resumableState, request.renderState, request.allPendingTasks === 0 && request.trackedPostpones === null);
+        }
+
+        flushSegment(request, destination, completedRootSegment);
+        request.completedRootSegment = null;
+        writeCompletedRoot(destination, request.renderState, request.resumableState);
+      } else {
+        // We haven't flushed the root yet so we don't need to check any other branches further down
+        return;
+      }
+    }
+
+    if (enableFloat) {
+      writeHoistables(destination, request.resumableState, request.renderState);
+    } // We emit client rendering instructions for already emitted boundaries first.
+    // This is so that we can signal to the client to start client rendering them as
+    // soon as possible.
+
+
+    const clientRenderedBoundaries = request.clientRenderedBoundaries;
+
+    for (i = 0; i < clientRenderedBoundaries.length; i++) {
+      const boundary = clientRenderedBoundaries[i];
+
+      if (!flushClientRenderedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        clientRenderedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    clientRenderedBoundaries.splice(0, i); // Next we emit any complete boundaries. It's better to favor boundaries
+    // that are completely done since we can actually show them, than it is to emit
+    // any individual segments from a partially complete boundary.
+
+    const completedBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < completedBoundaries.length; i++) {
+      const boundary = completedBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        completedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    completedBoundaries.splice(0, i); // Allow anything written so far to flush to the underlying sink before
+    // we continue with lower priorities.
+
+    completeWriting(destination);
+    beginWriting(destination); // TODO: Here we'll emit data used by hydration.
+    // Next we emit any segments of any boundaries that are partially complete
+    // but not deeply complete.
+
+    const partialBoundaries = request.partialBoundaries;
+
+    for (i = 0; i < partialBoundaries.length; i++) {
+      const boundary = partialBoundaries[i];
+
+      if (!flushPartialBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        partialBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    partialBoundaries.splice(0, i); // Next we check the completed boundaries again. This may have had
+    // boundaries added to it in case they were too larged to be inlined.
+    // New ones might be added in this loop.
+
+    const largeBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < largeBoundaries.length; i++) {
+      const boundary = largeBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        largeBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    largeBoundaries.splice(0, i);
+  } finally {
+    if (request.allPendingTasks === 0 && request.pingedTasks.length === 0 && request.clientRenderedBoundaries.length === 0 && request.completedBoundaries.length === 0 // We don't need to check any partially completed segments because
+    // either they have pending task or they're complete.
+    ) {
+        request.flushScheduled = false;
+
+        {
+          // We write the trailing tags but only if don't have any data to resume.
+          // If we need to resume we'll write the postamble in the resume instead.
+          if (request.trackedPostpones === null) {
+            writePostamble(destination, request.resumableState);
+          }
+        }
+
+
+        close(destination); // We need to stop flowing now because we do not want any async contexts which might call
+        // float methods to initiate any flushes after this point
+
+        stopFlowing(request);
+      }
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  {
+    scheduleWork(() => performWork(request));
+  }
+
+  if (request.trackedPostpones === null) {
+    // this is either a regular render or a resume. For regular render we want
+    // to call emitEarlyPreloads after the first performWork because we want
+    // are responding to a live request and need to balance sending something early
+    // (i.e. don't want for the shell to finish) but we need something to send.
+    // The only implementation of this is for DOM at the moment and during resumes nothing
+    // actually emits but the code paths here are the same.
+    // During a prerender we don't want to be too aggressive in emitting early preloads
+    // because we aren't responding to a live request and we can wait for the prerender to
+    // postpone before we emit anything.
+    {
+      scheduleWork(() => enqueueEarlyPreloadsAfterInitialWork(request));
+    }
+  }
+}
+
+function enqueueEarlyPreloadsAfterInitialWork(request) {
+  const shellComplete = request.pendingRootTasks === 0;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    request.flushScheduled = true;
+    scheduleWork(() => {
+      // We need to existence check destination again here because it might go away
+      // in between the enqueueFlush call and the work execution
+      const destination = request.destination;
+
+      if (destination) {
+        flushCompletedQueues(request, destination);
+      } else {
+        request.flushScheduled = false;
+      }
+    });
+  }
+} // This function is intented to only be called during the pipe function for the Node builds.
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedQueues(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function stopFlowing(request) {
+  request.destination = null;
+} // This is called to early terminate a request. It puts all pending boundaries in client rendered state.
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      const error = reason === undefined ? Error(formatProdErrorMessage(432)) : reason;
+      abortableTasks.forEach(task => abortTask(task, request, error));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function flushResources(request) {
+  enqueueFlush(request);
+}
+function getFormState(request) {
+  return request.formState;
+}
+function getResumableState(request) {
+  return request.resumableState;
+}
+function getRenderState(request) {
+  return request.renderState;
+}
+
+function addToReplayParent(node, parentKeyPath, trackedPostpones) {
+  if (parentKeyPath === null) {
+    trackedPostpones.rootNodes.push(node);
+  } else {
+    const workingMap = trackedPostpones.workingMap;
+    let parentNode = workingMap.get(parentKeyPath);
+
+    if (parentNode === undefined) {
+      parentNode = [parentKeyPath[1], parentKeyPath[2], [], null];
+      workingMap.set(parentKeyPath, parentNode);
+      addToReplayParent(parentNode, parentKeyPath[0], trackedPostpones);
+    }
+
+    parentNode[2].push(node);
+  }
+} // Returns the state of a postponed request or null if nothing was postponed.
+
+function onError() {// Non-fatal errors are ignored.
+}
+
+function renderToStringImpl(children, options, generateStaticMarkup, abortReason) {
+  let didFatal = false;
+  let fatalError = null;
+  let result = '';
+  const destination = {
+    // $FlowFixMe[missing-local-annot]
+    push(chunk) {
+      if (chunk !== null) {
+        result += chunk;
+      }
+
+      return true;
+    },
+
+    // $FlowFixMe[missing-local-annot]
+    destroy(error) {
+      didFatal = true;
+      fatalError = error;
+    }
+
+  };
+  let readyToStream = false;
+
+  function onShellReady() {
+    readyToStream = true;
+  }
+
+  const resumableState = createResumableState(options ? options.identifierPrefix : undefined, undefined);
+  const request = createRequest(children, resumableState, createRenderState(resumableState, generateStaticMarkup), createRootFormatContext(), Infinity, onError, undefined, onShellReady, undefined, undefined, undefined);
+  startWork(request); // If anything suspended and is still pending, we'll abort it before writing.
+  // That way we write only client-rendered boundaries from the start.
+
+  abort(request, abortReason);
+  startFlowing(request, destination);
+
+  if (didFatal && fatalError !== abortReason) {
+    throw fatalError;
+  }
+
+  if (!readyToStream) {
+    // Note: This error message is the one we use on the client. It doesn't
+    // really make sense here. But this is the legacy server renderer, anyway.
+    // We're going to delete it soon.
+    throw Error(formatProdErrorMessage(426));
+  }
+
+  return result;
+}
+
+function renderToString(children, options) {
+  return renderToStringImpl(children, options, false, 'The server used "renderToString" which does not support Suspense. If you intended for this Suspense boundary to render the fallback content on the server consider throwing an Error somewhere within the Suspense boundary. If you intended to have the server wait for the suspended component please switch to "renderToReadableStream" which supports Suspense on the server');
+}
+
+function renderToStaticMarkup(children, options) {
+  return renderToStringImpl(children, options, true, 'The server used "renderToStaticMarkup" which does not support Suspense. If you intended to have the server wait for the suspended component please switch to "renderToReadableStream" which supports Suspense on the server');
+}
+
+function renderToNodeStream() {
+  throw Error(formatProdErrorMessage(207));
+}
+
+function renderToStaticNodeStream() {
+  throw Error(formatProdErrorMessage(208));
+}
+
+exports.renderToNodeStream = renderToNodeStream;
+exports.renderToStaticMarkup = renderToStaticMarkup;
+exports.renderToStaticNodeStream = renderToStaticNodeStream;
+exports.renderToString = renderToString;
+exports.version = ReactVersion;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.browser.production.min.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.browser.production.min.js
index 079b43fbee5ec..b68bb5714cc38 100644
--- a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.browser.production.min.js
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.browser.production.min.js
@@ -1,13 +1,11 @@
-/**
- * @license React
- * react-dom-server-legacy.browser.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
 /*
+ React
+ react-dom-server-legacy.browser.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
 
 
  JS Implementation of MurmurHash3 (r136) (as of May 20, 2011)
@@ -31,175 +29,180 @@
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
 */
-'use strict';var da=require("next/dist/compiled/react-experimental"),ia=require("react-dom");function p(a){for(var b="https://reactjs.org/docs/error-decoder.html?invariant="+a,c=1;c<arguments.length;c++)b+="&args[]="+encodeURIComponent(arguments[c]);return"Minified React error #"+a+"; visit "+b+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}
-function ja(a,b){var c=a.length&3;var d=a.length-c;var e=b;for(b=0;b<d;){var f=a.charCodeAt(b)&255|(a.charCodeAt(++b)&255)<<8|(a.charCodeAt(++b)&255)<<16|(a.charCodeAt(++b)&255)<<24;++b;f=3432918353*(f&65535)+((3432918353*(f>>>16)&65535)<<16)&4294967295;f=f<<15|f>>>17;f=461845907*(f&65535)+((461845907*(f>>>16)&65535)<<16)&4294967295;e^=f;e=e<<13|e>>>19;e=5*(e&65535)+((5*(e>>>16)&65535)<<16)&4294967295;e=(e&65535)+27492+(((e>>>16)+58964&65535)<<16)}f=0;switch(c){case 3:f^=(a.charCodeAt(b+2)&255)<<
+'use strict';var aa=require("next/dist/compiled/react-experimental"),da=require("react-dom");function q(a){for(var b="https://reactjs.org/docs/error-decoder.html?invariant="+a,c=1;c<arguments.length;c++)b+="&args[]="+encodeURIComponent(arguments[c]);return"Minified React error #"+a+"; visit "+b+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}
+function ia(a,b){var c=a.length&3;var d=a.length-c;var e=b;for(b=0;b<d;){var f=a.charCodeAt(b)&255|(a.charCodeAt(++b)&255)<<8|(a.charCodeAt(++b)&255)<<16|(a.charCodeAt(++b)&255)<<24;++b;f=3432918353*(f&65535)+((3432918353*(f>>>16)&65535)<<16)&4294967295;f=f<<15|f>>>17;f=461845907*(f&65535)+((461845907*(f>>>16)&65535)<<16)&4294967295;e^=f;e=e<<13|e>>>19;e=5*(e&65535)+((5*(e>>>16)&65535)<<16)&4294967295;e=(e&65535)+27492+(((e>>>16)+58964&65535)<<16)}f=0;switch(c){case 3:f^=(a.charCodeAt(b+2)&255)<<
 16;case 2:f^=(a.charCodeAt(b+1)&255)<<8;case 1:f^=a.charCodeAt(b)&255,f=3432918353*(f&65535)+((3432918353*(f>>>16)&65535)<<16)&4294967295,f=f<<15|f>>>17,e^=461845907*(f&65535)+((461845907*(f>>>16)&65535)<<16)&4294967295}e^=a.length;e^=e>>>16;e=2246822507*(e&65535)+((2246822507*(e>>>16)&65535)<<16)&4294967295;e^=e>>>13;e=3266489909*(e&65535)+((3266489909*(e>>>16)&65535)<<16)&4294967295;return(e^e>>>16)>>>0}
-var t=Object.assign,x=Object.prototype.hasOwnProperty,ka=RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"),wa={},xa={};
-function ya(a){if(x.call(xa,a))return!0;if(x.call(wa,a))return!1;if(ka.test(a))return xa[a]=!0;wa[a]=!0;return!1}
-var za=new Set("animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp".split(" ")),Aa=
+var r=Object.assign,z=Object.prototype.hasOwnProperty,ja=RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"),ka={},wa={};
+function xa(a){if(z.call(wa,a))return!0;if(z.call(ka,a))return!1;if(ja.test(a))return wa[a]=!0;ka[a]=!0;return!1}
+var ya=new Set("animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp".split(" ")),za=
 new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv","http-equiv"],["crossOrigin","crossorigin"],["accentHeight","accent-height"],["alignmentBaseline","alignment-baseline"],["arabicForm","arabic-form"],["baselineShift","baseline-shift"],["capHeight","cap-height"],["clipPath","clip-path"],["clipRule","clip-rule"],["colorInterpolation","color-interpolation"],["colorInterpolationFilters","color-interpolation-filters"],["colorProfile","color-profile"],["colorRendering","color-rendering"],
 ["dominantBaseline","dominant-baseline"],["enableBackground","enable-background"],["fillOpacity","fill-opacity"],["fillRule","fill-rule"],["floodColor","flood-color"],["floodOpacity","flood-opacity"],["fontFamily","font-family"],["fontSize","font-size"],["fontSizeAdjust","font-size-adjust"],["fontStretch","font-stretch"],["fontStyle","font-style"],["fontVariant","font-variant"],["fontWeight","font-weight"],["glyphName","glyph-name"],["glyphOrientationHorizontal","glyph-orientation-horizontal"],["glyphOrientationVertical",
 "glyph-orientation-vertical"],["horizAdvX","horiz-adv-x"],["horizOriginX","horiz-origin-x"],["imageRendering","image-rendering"],["letterSpacing","letter-spacing"],["lightingColor","lighting-color"],["markerEnd","marker-end"],["markerMid","marker-mid"],["markerStart","marker-start"],["overlinePosition","overline-position"],["overlineThickness","overline-thickness"],["paintOrder","paint-order"],["panose-1","panose-1"],["pointerEvents","pointer-events"],["renderingIntent","rendering-intent"],["shapeRendering",
 "shape-rendering"],["stopColor","stop-color"],["stopOpacity","stop-opacity"],["strikethroughPosition","strikethrough-position"],["strikethroughThickness","strikethrough-thickness"],["strokeDasharray","stroke-dasharray"],["strokeDashoffset","stroke-dashoffset"],["strokeLinecap","stroke-linecap"],["strokeLinejoin","stroke-linejoin"],["strokeMiterlimit","stroke-miterlimit"],["strokeOpacity","stroke-opacity"],["strokeWidth","stroke-width"],["textAnchor","text-anchor"],["textDecoration","text-decoration"],
 ["textRendering","text-rendering"],["transformOrigin","transform-origin"],["underlinePosition","underline-position"],["underlineThickness","underline-thickness"],["unicodeBidi","unicode-bidi"],["unicodeRange","unicode-range"],["unitsPerEm","units-per-em"],["vAlphabetic","v-alphabetic"],["vHanging","v-hanging"],["vIdeographic","v-ideographic"],["vMathematical","v-mathematical"],["vectorEffect","vector-effect"],["vertAdvY","vert-adv-y"],["vertOriginX","vert-origin-x"],["vertOriginY","vert-origin-y"],
-["wordSpacing","word-spacing"],["writingMode","writing-mode"],["xmlnsXlink","xmlns:xlink"],["xHeight","x-height"]]),Ba=/["'&<>]/;
-function y(a){if("boolean"===typeof a||"number"===typeof a)return""+a;a=""+a;var b=Ba.exec(a);if(b){var c="",d,e=0;for(d=b.index;d<a.length;d++){switch(a.charCodeAt(d)){case 34:b="&quot;";break;case 38:b="&amp;";break;case 39:b="&#x27;";break;case 60:b="&lt;";break;case 62:b="&gt;";break;default:continue}e!==d&&(c+=a.slice(e,d));e=d+1;c+=b}a=e!==d?c+a.slice(e,d):c}return a}
-var Ia=/([A-Z])/g,Ja=/^ms-/,Ka=Array.isArray,La=da.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,Ma={pending:!1,data:null,method:null,action:null},Na=ia.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Dispatcher,lb={prefetchDNS:Oa,preconnect:Pa,preload:gb,preloadModule:hb,preinitStyle:ib,preinitScript:jb,preinitModuleScript:kb},z=[];
-function mb(a,b){var c=0;void 0!==b&&(c=1);return{idPrefix:void 0===a?"":a,nextFormID:0,streamingFormat:c,instructions:0,hasBody:!1,hasHtml:!1,unknownResources:{},dnsResources:{},connectResources:{default:{},anonymous:{},credentials:{}},imageResources:{},styleResources:{},scriptResources:{},moduleUnknownResources:{},moduleScriptResources:{}}}function G(a,b,c){return{insertionMode:a,selectedValue:b,tagScope:c}}
-function nb(a,b,c){switch(b){case "noscript":return G(2,null,a.tagScope|1);case "select":return G(2,null!=c.value?c.value:c.defaultValue,a.tagScope);case "svg":return G(3,null,a.tagScope);case "picture":return G(2,null,a.tagScope|2);case "math":return G(4,null,a.tagScope);case "foreignObject":return G(2,null,a.tagScope);case "table":return G(5,null,a.tagScope);case "thead":case "tbody":case "tfoot":return G(6,null,a.tagScope);case "colgroup":return G(8,null,a.tagScope);case "tr":return G(7,null,a.tagScope)}return 5<=
-a.insertionMode?G(2,null,a.tagScope):0===a.insertionMode?"html"===b?G(1,null,a.tagScope):G(2,null,a.tagScope):1===a.insertionMode?G(2,null,a.tagScope):a}var ob=new Map;
-function pb(a,b){if("object"!==typeof b)throw Error(p(62));var c=!0,d;for(d in b)if(x.call(b,d)){var e=b[d];if(null!=e&&"boolean"!==typeof e&&""!==e){if(0===d.indexOf("--")){var f=y(d);e=y((""+e).trim())}else f=ob.get(d),void 0===f&&(f=y(d.replace(Ia,"-$1").toLowerCase().replace(Ja,"-ms-")),ob.set(d,f)),e="number"===typeof e?0===e||za.has(d)?""+e:e+"px":y((""+e).trim());c?(c=!1,a.push(' style="',f,":",e)):a.push(";",f,":",e)}}c||a.push('"')}
-function qb(a,b,c){c&&"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'=""')}function H(a,b,c){"function"!==typeof c&&"symbol"!==typeof c&&"boolean"!==typeof c&&a.push(" ",b,'="',y(c),'"')}function Bb(a){var b=a.nextFormID++;return a.idPrefix+b}var Cb=y("javascript:throw new Error('A React form was unexpectedly submitted.')");function Db(a,b){this.push('<input type="hidden"');if("string"!==typeof a)throw Error(p(480));H(this,"name",b);H(this,"value",a);this.push("/>")}
-function Eb(a,b,c,d,e,f,g,h){var k=null;"function"===typeof d&&("function"===typeof d.$$FORM_ACTION?(e=Bb(b),b=d.$$FORM_ACTION(e),h=b.name,d=b.action||"",e=b.encType,f=b.method,g=b.target,k=b.data):(a.push(" ","formAction",'="',Cb,'"'),g=f=e=d=h=null,Fb(b,c)));null!=h&&I(a,"name",h);null!=d&&I(a,"formAction",d);null!=e&&I(a,"formEncType",e);null!=f&&I(a,"formMethod",f);null!=g&&I(a,"formTarget",g);return k}
-function I(a,b,c){switch(b){case "className":H(a,"class",c);break;case "tabIndex":H(a,"tabindex",c);break;case "dir":case "role":case "viewBox":case "width":case "height":H(a,b,c);break;case "style":pb(a,c);break;case "src":case "href":if(""===c)break;case "action":case "formAction":if(null==c||"function"===typeof c||"symbol"===typeof c||"boolean"===typeof c)break;a.push(" ",b,'="',y(""+c),'"');break;case "defaultValue":case "defaultChecked":case "innerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":break;
-case "autoFocus":case "multiple":case "muted":qb(a,b.toLowerCase(),c);break;case "xlinkHref":if("function"===typeof c||"symbol"===typeof c||"boolean"===typeof c)break;a.push(" ","xlink:href",'="',y(""+c),'"');break;case "contentEditable":case "spellCheck":case "draggable":case "value":case "autoReverse":case "externalResourcesRequired":case "focusable":case "preserveAlpha":"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'="',y(c),'"');break;case "allowFullScreen":case "async":case "autoPlay":case "controls":case "default":case "defer":case "disabled":case "disablePictureInPicture":case "disableRemotePlayback":case "formNoValidate":case "hidden":case "loop":case "noModule":case "noValidate":case "open":case "playsInline":case "readOnly":case "required":case "reversed":case "scoped":case "seamless":case "itemScope":c&&
-"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'=""');break;case "capture":case "download":!0===c?a.push(" ",b,'=""'):!1!==c&&"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'="',y(c),'"');break;case "cols":case "rows":case "size":case "span":"function"!==typeof c&&"symbol"!==typeof c&&!isNaN(c)&&1<=c&&a.push(" ",b,'="',y(c),'"');break;case "rowSpan":case "start":"function"===typeof c||"symbol"===typeof c||isNaN(c)||a.push(" ",b,'="',y(c),'"');break;case "xlinkActuate":H(a,"xlink:actuate",
-c);break;case "xlinkArcrole":H(a,"xlink:arcrole",c);break;case "xlinkRole":H(a,"xlink:role",c);break;case "xlinkShow":H(a,"xlink:show",c);break;case "xlinkTitle":H(a,"xlink:title",c);break;case "xlinkType":H(a,"xlink:type",c);break;case "xmlBase":H(a,"xml:base",c);break;case "xmlLang":H(a,"xml:lang",c);break;case "xmlSpace":H(a,"xml:space",c);break;default:if(!(2<b.length)||"o"!==b[0]&&"O"!==b[0]||"n"!==b[1]&&"N"!==b[1])if(b=Aa.get(b)||b,ya(b)){switch(typeof c){case "function":case "symbol":return;
-case "boolean":var d=b.toLowerCase().slice(0,5);if("data-"!==d&&"aria-"!==d)return}a.push(" ",b,'="',y(c),'"')}}}function K(a,b,c){if(null!=b){if(null!=c)throw Error(p(60));if("object"!==typeof b||!("__html"in b))throw Error(p(61));b=b.__html;null!==b&&void 0!==b&&a.push(""+b)}}function Gb(a){var b="";da.Children.forEach(a,function(c){null!=c&&(b+=c)});return b}
-function Fb(a,b){0!==(a.instructions&16)||b.externalRuntimeScript||(a.instructions|=16,b.bootstrapChunks.unshift(b.startInlineScript,'addEventListener("submit",function(a){if(!a.defaultPrevented){var c=a.target,d=a.submitter,e=c.action,b=d;if(d){var f=d.getAttribute("formAction");null!=f&&(e=f,b=null)}"javascript:throw new Error(\'A React form was unexpectedly submitted.\')"===e&&(a.preventDefault(),b?(a=document.createElement("input"),a.name=b.name,a.value=b.value,b.parentNode.insertBefore(a,b),b=new FormData(c),a.parentNode.removeChild(a)):b=new FormData(c),a=c.getRootNode(),(a.$$reactFormReplay=a.$$reactFormReplay||[]).push(c,\nd,b))}});',"\x3c/script>"))}
-function Hb(a,b,c,d,e,f,g){var h=b.rel,k=b.href,l=b.precedence;if(3===f||g||null!=b.itemProp||"string"!==typeof h||"string"!==typeof k||""===k)return L(a,b),null;if("stylesheet"===b.rel){if("string"!==typeof l||null!=b.disabled||b.onLoad||b.onError)return L(a,b);f=d.styles.get(l);g=c.styleResources.hasOwnProperty(k)?c.styleResources[k]:void 0;null!==g?(c.styleResources[k]=null,f||(f={precedence:y(l),rules:[],hrefs:[],sheets:new Map},d.styles.set(l,f)),b={state:0,props:t({},b,{"data-precedence":b.precedence,
-precedence:null})},g&&(2===g.length&&Ib(b.props,g),(c=d.preloads.stylesheets.get(k))&&0<c.length?c.length=0:b.state=1),f.sheets.set(k,b),d.boundaryResources&&d.boundaryResources.stylesheets.add(b)):f&&(k=f.sheets.get(k))&&d.boundaryResources&&d.boundaryResources.stylesheets.add(k);e&&a.push("\x3c!-- --\x3e");return null}if(b.onLoad||b.onError)return L(a,b);e&&a.push("\x3c!-- --\x3e");switch(b.rel){case "preconnect":case "dns-prefetch":return L(d.preconnectChunks,b);case "preload":return L(d.preloadChunks,
-b);default:return L(d.hoistableChunks,b)}}function L(a,b){a.push(M("link"));for(var c in b)if(x.call(b,c)){var d=b[c];if(null!=d)switch(c){case "children":case "dangerouslySetInnerHTML":throw Error(p(399,"link"));default:I(a,c,d)}}a.push("/>");return null}function Jb(a,b,c){a.push(M(c));for(var d in b)if(x.call(b,d)){var e=b[d];if(null!=e)switch(d){case "children":case "dangerouslySetInnerHTML":throw Error(p(399,c));default:I(a,d,e)}}a.push("/>");return null}
-function Kb(a,b){a.push(M("title"));var c=null,d=null,e;for(e in b)if(x.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:I(a,e,f)}}a.push(">");b=Array.isArray(c)?2>c.length?c[0]:null:c;"function"!==typeof b&&"symbol"!==typeof b&&null!==b&&void 0!==b&&a.push(y(""+b));K(a,d,c);a.push(Lb("title"));return null}
-function Mb(a,b){a.push(M("script"));var c=null,d=null,e;for(e in b)if(x.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:I(a,e,f)}}a.push(">");K(a,d,c);"string"===typeof c&&a.push(y(c));a.push(Lb("script"));return null}
-function Nb(a,b,c){a.push(M(c));var d=c=null,e;for(e in b)if(x.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:I(a,e,f)}}a.push(">");K(a,d,c);return"string"===typeof c?(a.push(y(c)),null):c}var Ob=/^[a-zA-Z][a-zA-Z:_\.\-\d]*$/,Pb=new Map;function M(a){var b=Pb.get(a);if(void 0===b){if(!Ob.test(a))throw Error(p(65,a));b="<"+a;Pb.set(a,b)}return b}
-function Qb(a,b,c,d,e,f,g){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "select":a.push(M("select"));var h=null,k=null,l;for(l in c)if(x.call(c,l)){var n=c[l];if(null!=n)switch(l){case "children":h=n;break;case "dangerouslySetInnerHTML":k=n;break;case "defaultValue":case "value":break;default:I(a,l,n)}}a.push(">");K(a,k,h);return h;case "option":var r=f.selectedValue;a.push(M("option"));var m=null,C=null,D=null,Q=null,v;for(v in c)if(x.call(c,
-v)){var A=c[v];if(null!=A)switch(v){case "children":m=A;break;case "selected":D=A;break;case "dangerouslySetInnerHTML":Q=A;break;case "value":C=A;default:I(a,v,A)}}if(null!=r){var q=null!==C?""+C:Gb(m);if(Ka(r))for(var aa=0;aa<r.length;aa++){if(""+r[aa]===q){a.push(' selected=""');break}}else""+r===q&&a.push(' selected=""')}else D&&a.push(' selected=""');a.push(">");K(a,Q,m);return m;case "textarea":a.push(M("textarea"));var u=null,U=null,E=null,B;for(B in c)if(x.call(c,B)){var w=c[B];if(null!=w)switch(B){case "children":E=
-w;break;case "value":u=w;break;case "defaultValue":U=w;break;case "dangerouslySetInnerHTML":throw Error(p(91));default:I(a,B,w)}}null===u&&null!==U&&(u=U);a.push(">");if(null!=E){if(null!=u)throw Error(p(92));if(Ka(E)){if(1<E.length)throw Error(p(93));u=""+E[0]}u=""+E}"string"===typeof u&&"\n"===u[0]&&a.push("\n");null!==u&&a.push(y(""+u));return null;case "input":a.push(M("input"));var Qa=null,rb=null,Ca=null,la=null,ea=null,V=null,Ra=null,Sa=null,Ta=null,ma;for(ma in c)if(x.call(c,ma)){var O=c[ma];
-if(null!=O)switch(ma){case "children":case "dangerouslySetInnerHTML":throw Error(p(399,"input"));case "name":Qa=O;break;case "formAction":rb=O;break;case "formEncType":Ca=O;break;case "formMethod":la=O;break;case "formTarget":ea=O;break;case "defaultChecked":Ta=O;break;case "defaultValue":Ra=O;break;case "checked":Sa=O;break;case "value":V=O;break;default:I(a,ma,O)}}var sb=Eb(a,d,e,rb,Ca,la,ea,Qa);null!==Sa?qb(a,"checked",Sa):null!==Ta&&qb(a,"checked",Ta);null!==V?I(a,"value",V):null!==Ra&&I(a,"value",
-Ra);a.push("/>");null!==sb&&sb.forEach(Db,a);return null;case "button":a.push(M("button"));var na=null,oa=null,ba=null,pa=null,qa=null,Ua=null,ra=null,Va;for(Va in c)if(x.call(c,Va)){var ca=c[Va];if(null!=ca)switch(Va){case "children":na=ca;break;case "dangerouslySetInnerHTML":oa=ca;break;case "name":ba=ca;break;case "formAction":pa=ca;break;case "formEncType":qa=ca;break;case "formMethod":Ua=ca;break;case "formTarget":ra=ca;break;default:I(a,Va,ca)}}var Qc=Eb(a,d,e,pa,qa,Ua,ra,ba);a.push(">");null!==
-Qc&&Qc.forEach(Db,a);K(a,oa,na);if("string"===typeof na){a.push(y(na));var Rc=null}else Rc=na;return Rc;case "form":a.push(M("form"));var Wa=null,Sc=null,fa=null,Xa=null,Ya=null,Za=null,$a;for($a in c)if(x.call(c,$a)){var ha=c[$a];if(null!=ha)switch($a){case "children":Wa=ha;break;case "dangerouslySetInnerHTML":Sc=ha;break;case "action":fa=ha;break;case "encType":Xa=ha;break;case "method":Ya=ha;break;case "target":Za=ha;break;default:I(a,$a,ha)}}var Zb=null,$b=null;if("function"===typeof fa)if("function"===
-typeof fa.$$FORM_ACTION){var ve=Bb(d),Da=fa.$$FORM_ACTION(ve);fa=Da.action||"";Xa=Da.encType;Ya=Da.method;Za=Da.target;Zb=Da.data;$b=Da.name}else a.push(" ","action",'="',Cb,'"'),Za=Ya=Xa=fa=null,Fb(d,e);null!=fa&&I(a,"action",fa);null!=Xa&&I(a,"encType",Xa);null!=Ya&&I(a,"method",Ya);null!=Za&&I(a,"target",Za);a.push(">");null!==$b&&(a.push('<input type="hidden"'),H(a,"name",$b),a.push("/>"),null!==Zb&&Zb.forEach(Db,a));K(a,Sc,Wa);if("string"===typeof Wa){a.push(y(Wa));var Tc=null}else Tc=Wa;return Tc;
-case "menuitem":a.push(M("menuitem"));for(var tb in c)if(x.call(c,tb)){var Uc=c[tb];if(null!=Uc)switch(tb){case "children":case "dangerouslySetInnerHTML":throw Error(p(400));default:I(a,tb,Uc)}}a.push(">");return null;case "title":if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp)var Vc=Kb(a,c);else Kb(e.hoistableChunks,c),Vc=null;return Vc;case "link":return Hb(a,c,d,e,g,f.insertionMode,!!(f.tagScope&1));case "script":var ac=c.async;if("string"!==typeof c.src||!c.src||!ac||"function"===typeof ac||
-"symbol"===typeof ac||c.onLoad||c.onError||3===f.insertionMode||f.tagScope&1||null!=c.itemProp)var Wc=Mb(a,c);else{var ub=c.src;if("module"===c.type){var vb=d.moduleScriptResources;var Xc=e.preloads.moduleScripts}else vb=d.scriptResources,Xc=e.preloads.scripts;var wb=vb.hasOwnProperty(ub)?vb[ub]:void 0;if(null!==wb){vb[ub]=null;var bc=c;if(wb){2===wb.length&&(bc=t({},c),Ib(bc,wb));var Yc=Xc.get(ub);Yc&&(Yc.length=0)}var Zc=[];e.scripts.add(Zc);Mb(Zc,bc)}g&&a.push("\x3c!-- --\x3e");Wc=null}return Wc;
-case "style":var xb=c.precedence,sa=c.href;if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp||"string"!==typeof xb||"string"!==typeof sa||""===sa){a.push(M("style"));var Ea=null,$c=null,ab;for(ab in c)if(x.call(c,ab)){var yb=c[ab];if(null!=yb)switch(ab){case "children":Ea=yb;break;case "dangerouslySetInnerHTML":$c=yb;break;default:I(a,ab,yb)}}a.push(">");var bb=Array.isArray(Ea)?2>Ea.length?Ea[0]:null:Ea;"function"!==typeof bb&&"symbol"!==typeof bb&&null!==bb&&void 0!==bb&&a.push(y(""+bb));K(a,
-$c,Ea);a.push(Lb("style"));var ad=null}else{var ta=e.styles.get(xb);if(null!==(d.styleResources.hasOwnProperty(sa)?d.styleResources[sa]:void 0)){d.styleResources[sa]=null;ta?ta.hrefs.push(y(sa)):(ta={precedence:y(xb),rules:[],hrefs:[y(sa)],sheets:new Map},e.styles.set(xb,ta));var bd=ta.rules,Fa=null,cd=null,zb;for(zb in c)if(x.call(c,zb)){var cc=c[zb];if(null!=cc)switch(zb){case "children":Fa=cc;break;case "dangerouslySetInnerHTML":cd=cc}}var cb=Array.isArray(Fa)?2>Fa.length?Fa[0]:null:Fa;"function"!==
-typeof cb&&"symbol"!==typeof cb&&null!==cb&&void 0!==cb&&bd.push(y(""+cb));K(bd,cd,Fa)}ta&&e.boundaryResources&&e.boundaryResources.styles.add(ta);g&&a.push("\x3c!-- --\x3e");ad=void 0}return ad;case "meta":if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp)var dd=Jb(a,c,"meta");else g&&a.push("\x3c!-- --\x3e"),dd="string"===typeof c.charSet?Jb(e.charsetChunks,c,"meta"):"viewport"===c.name?Jb(e.preconnectChunks,c,"meta"):Jb(e.hoistableChunks,c,"meta");return dd;case "listing":case "pre":a.push(M(b));
-var db=null,eb=null,fb;for(fb in c)if(x.call(c,fb)){var Ab=c[fb];if(null!=Ab)switch(fb){case "children":db=Ab;break;case "dangerouslySetInnerHTML":eb=Ab;break;default:I(a,fb,Ab)}}a.push(">");if(null!=eb){if(null!=db)throw Error(p(60));if("object"!==typeof eb||!("__html"in eb))throw Error(p(61));var ua=eb.__html;null!==ua&&void 0!==ua&&("string"===typeof ua&&0<ua.length&&"\n"===ua[0]?a.push("\n",ua):a.push(""+ua))}"string"===typeof db&&"\n"===db[0]&&a.push("\n");return db;case "img":var J=c.src,F=
-c.srcSet;if(!("lazy"===c.loading||!J&&!F||"string"!==typeof J&&null!=J||"string"!==typeof F&&null!=F)&&"low"!==c.fetchPriority&&!1===!!(f.tagScope&2)&&("string"!==typeof J||":"!==J[4]||"d"!==J[0]&&"D"!==J[0]||"a"!==J[1]&&"A"!==J[1]||"t"!==J[2]&&"T"!==J[2]||"a"!==J[3]&&"A"!==J[3])&&("string"!==typeof F||":"!==F[4]||"d"!==F[0]&&"D"!==F[0]||"a"!==F[1]&&"A"!==F[1]||"t"!==F[2]&&"T"!==F[2]||"a"!==F[3]&&"A"!==F[3])){var ed="string"===typeof c.sizes?c.sizes:void 0,Ga=F?F+"\n"+(ed||""):J,dc=e.preloads.images,
-va=dc.get(Ga);if(va){if("high"===c.fetchPriority||10>e.highImagePreloads.size)dc.delete(Ga),e.highImagePreloads.add(va)}else if(!d.imageResources.hasOwnProperty(Ga)){d.imageResources[Ga]=z;var ec=c.crossOrigin;var fd="string"===typeof ec?"use-credentials"===ec?ec:"":void 0;var W=e.headers,fc;W&&0<W.remainingCapacity&&("high"===c.fetchPriority||500>W.highImagePreloads.length)&&(fc=Rb(J,"image",{imageSrcSet:c.srcSet,imageSizes:c.sizes,crossOrigin:fd,integrity:c.integrity,nonce:c.nonce,type:c.type,fetchPriority:c.fetchPriority,
-referrerPolicy:c.refererPolicy}),2<=(W.remainingCapacity-=fc.length))?(e.resets.image[Ga]=z,W.highImagePreloads&&(W.highImagePreloads+=", "),W.highImagePreloads+=fc):(va=[],L(va,{rel:"preload",as:"image",href:F?void 0:J,imageSrcSet:F,imageSizes:ed,crossOrigin:fd,integrity:c.integrity,type:c.type,fetchPriority:c.fetchPriority,referrerPolicy:c.referrerPolicy}),"high"===c.fetchPriority||10>e.highImagePreloads.size?e.highImagePreloads.add(va):(e.bulkPreloads.add(va),dc.set(Ga,va)))}}return Jb(a,c,"img");
-case "base":case "area":case "br":case "col":case "embed":case "hr":case "keygen":case "param":case "source":case "track":case "wbr":return Jb(a,c,b);case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph":break;case "head":if(2>f.insertionMode&&null===e.headChunks){e.headChunks=[];var gd=Nb(e.headChunks,c,"head")}else gd=Nb(a,c,"head");return gd;case "html":if(0===f.insertionMode&&null===
-e.htmlChunks){e.htmlChunks=[""];var hd=Nb(e.htmlChunks,c,"html")}else hd=Nb(a,c,"html");return hd;default:if(-1!==b.indexOf("-")){a.push(M(b));var gc=null,id=null,Ha;for(Ha in c)if(x.call(c,Ha)){var R=c[Ha];if(null!=R){var jd=Ha;switch(Ha){case "children":gc=R;break;case "dangerouslySetInnerHTML":id=R;break;case "style":pb(a,R);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":break;case "className":jd="class";default:if(ya(Ha)&&"function"!==typeof R&&"symbol"!==typeof R&&
-!1!==R){if(!0===R)R="";else if("object"===typeof R)continue;a.push(" ",jd,'="',y(R),'"')}}}}a.push(">");K(a,id,gc);return gc}}return Nb(a,c,b)}var Sb=new Map;function Lb(a){var b=Sb.get(a);void 0===b&&(b="</"+a+">",Sb.set(a,b));return b}function Tb(a,b){b=b.bootstrapChunks;for(var c=0;c<b.length-1;c++)a.push(b[c]);return c<b.length?(c=b[c],b.length=0,a.push(c)):!0}
-function Ub(a,b,c){a.push('\x3c!--$?--\x3e<template id="');if(null===c)throw Error(p(395));a.push(b.boundaryPrefix);b=c.toString(16);a.push(b);return a.push('"></template>')}
-function Vb(a,b,c,d){switch(c.insertionMode){case 0:case 1:case 2:return a.push('<div hidden id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 3:return a.push('<svg aria-hidden="true" style="display:none" id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 4:return a.push('<math aria-hidden="true" style="display:none" id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 5:return a.push('<table hidden id="'),a.push(b.segmentPrefix),
-b=d.toString(16),a.push(b),a.push('">');case 6:return a.push('<table hidden><tbody id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 7:return a.push('<table hidden><tr id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 8:return a.push('<table hidden><colgroup id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');default:throw Error(p(397));}}
-function Wb(a,b){switch(b.insertionMode){case 0:case 1:case 2:return a.push("</div>");case 3:return a.push("</svg>");case 4:return a.push("</math>");case 5:return a.push("</table>");case 6:return a.push("</tbody></table>");case 7:return a.push("</tr></table>");case 8:return a.push("</colgroup></table>");default:throw Error(p(397));}}var Xb=/[<\u2028\u2029]/g;
-function Yb(a){return JSON.stringify(a).replace(Xb,function(b){switch(b){case "<":return"\\u003c";case "\u2028":return"\\u2028";case "\u2029":return"\\u2029";default:throw Error("escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}})}var hc=/[&><\u2028\u2029]/g;
-function ic(a){return JSON.stringify(a).replace(hc,function(b){switch(b){case "&":return"\\u0026";case ">":return"\\u003e";case "<":return"\\u003c";case "\u2028":return"\\u2028";case "\u2029":return"\\u2029";default:throw Error("escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}})}var jc=!1,kc=!0;
-function lc(a){var b=a.rules,c=a.hrefs,d=0;if(c.length){this.push('<style media="not all" data-precedence="');this.push(a.precedence);for(this.push('" data-href="');d<c.length-1;d++)this.push(c[d]),this.push(" ");this.push(c[d]);this.push('">');for(d=0;d<b.length;d++)this.push(b[d]);kc=this.push("</style>");jc=!0;b.length=0;c.length=0}}function mc(a){return 2!==a.state?jc=!0:!1}function nc(a,b,c){jc=!1;kc=!0;b.styles.forEach(lc,a);b.stylesheets.forEach(mc);jc&&(c.stylesToHoist=!0);return kc}
-function N(a){for(var b=0;b<a.length;b++)this.push(a[b]);a.length=0}var oc=[];function pc(a){L(oc,a.props);for(var b=0;b<oc.length;b++)this.push(oc[b]);oc.length=0;a.state=2}
-function qc(a){var b=0<a.sheets.size;a.sheets.forEach(pc,this);a.sheets.clear();var c=a.rules,d=a.hrefs;if(!b||d.length){this.push('<style data-precedence="');this.push(a.precedence);a=0;if(d.length){for(this.push('" data-href="');a<d.length-1;a++)this.push(d[a]),this.push(" ");this.push(d[a])}this.push('">');for(a=0;a<c.length;a++)this.push(c[a]);this.push("</style>");c.length=0;d.length=0}}
-function rc(a){if(0===a.state){a.state=1;var b=a.props;L(oc,{rel:"preload",as:"style",href:a.props.href,crossOrigin:b.crossOrigin,fetchPriority:b.fetchPriority,integrity:b.integrity,media:b.media,hrefLang:b.hrefLang,referrerPolicy:b.referrerPolicy});for(a=0;a<oc.length;a++)this.push(oc[a]);oc.length=0}}function sc(a){a.sheets.forEach(rc,this);a.sheets.clear()}
-function tc(a,b){a.push("[");var c="[";b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)a.push(c),d=ic(""+d.props.href),a.push(d),a.push("]"),c=",[";else{a.push(c);var e=d.props["data-precedence"],f=d.props,g=ic(""+d.props.href);a.push(g);e=""+e;a.push(",");e=ic(e);a.push(e);for(var h in f)if(x.call(f,h)&&(g=f[h],null!=g))switch(h){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error(p(399,"link"));default:a:{e=
-a;var k=h.toLowerCase();switch(typeof g){case "function":case "symbol":break a}switch(h){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":k="class";g=""+g;break;case "hidden":if(!1===g)break a;g="";break;case "src":case "href":g=""+g;break;default:if(2<h.length&&("o"===h[0]||"O"===h[0])&&("n"===h[1]||"N"===h[1])||!ya(h))break a;g=""+g}e.push(",");k=ic(k);e.push(k);e.push(",");g=ic(g);e.push(g)}}a.push("]");
+["wordSpacing","word-spacing"],["writingMode","writing-mode"],["xmlnsXlink","xmlns:xlink"],["xHeight","x-height"]]),Aa=/["'&<>]/;
+function A(a){if("boolean"===typeof a||"number"===typeof a)return""+a;a=""+a;var b=Aa.exec(a);if(b){var c="",d,e=0;for(d=b.index;d<a.length;d++){switch(a.charCodeAt(d)){case 34:b="&quot;";break;case 38:b="&amp;";break;case 39:b="&#x27;";break;case 60:b="&lt;";break;case 62:b="&gt;";break;default:continue}e!==d&&(c+=a.slice(e,d));e=d+1;c+=b}a=e!==d?c+a.slice(e,d):c}return a}
+var Ba=/([A-Z])/g,Ia=/^ms-/,Ja=Array.isArray,Ka=aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,La={pending:!1,data:null,method:null,action:null},Ma=da.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Dispatcher,kb={prefetchDNS:Na,preconnect:Oa,preload:Pa,preloadModule:gb,preinitStyle:hb,preinitScript:ib,preinitModuleScript:jb},B=[],lb=/(<\/|<)(s)(cript)/gi;function mb(a,b,c,d){return""+b+("s"===c?"\\u0073":"\\u0053")+d}
+function nb(a,b,c,d,e){var f=0;void 0!==b&&(f=1);return{idPrefix:void 0===a?"":a,nextFormID:0,streamingFormat:f,bootstrapScriptContent:c,bootstrapScripts:d,bootstrapModules:e,instructions:0,hasBody:!1,hasHtml:!1,unknownResources:{},dnsResources:{},connectResources:{default:{},anonymous:{},credentials:{}},imageResources:{},styleResources:{},scriptResources:{},moduleUnknownResources:{},moduleScriptResources:{}}}function G(a,b,c){return{insertionMode:a,selectedValue:b,tagScope:c}}
+function ob(a,b,c){switch(b){case "noscript":return G(2,null,a.tagScope|1);case "select":return G(2,null!=c.value?c.value:c.defaultValue,a.tagScope);case "svg":return G(3,null,a.tagScope);case "picture":return G(2,null,a.tagScope|2);case "math":return G(4,null,a.tagScope);case "foreignObject":return G(2,null,a.tagScope);case "table":return G(5,null,a.tagScope);case "thead":case "tbody":case "tfoot":return G(6,null,a.tagScope);case "colgroup":return G(8,null,a.tagScope);case "tr":return G(7,null,a.tagScope)}return 5<=
+a.insertionMode?G(2,null,a.tagScope):0===a.insertionMode?"html"===b?G(1,null,a.tagScope):G(2,null,a.tagScope):1===a.insertionMode?G(2,null,a.tagScope):a}var pb=new Map;
+function qb(a,b){if("object"!==typeof b)throw Error(q(62));var c=!0,d;for(d in b)if(z.call(b,d)){var e=b[d];if(null!=e&&"boolean"!==typeof e&&""!==e){if(0===d.indexOf("--")){var f=A(d);e=A((""+e).trim())}else f=pb.get(d),void 0===f&&(f=A(d.replace(Ba,"-$1").toLowerCase().replace(Ia,"-ms-")),pb.set(d,f)),e="number"===typeof e?0===e||ya.has(d)?""+e:e+"px":A((""+e).trim());c?(c=!1,a.push(' style="',f,":",e)):a.push(";",f,":",e)}}c||a.push('"')}
+function Bb(a,b,c){c&&"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'=""')}function J(a,b,c){"function"!==typeof c&&"symbol"!==typeof c&&"boolean"!==typeof c&&a.push(" ",b,'="',A(c),'"')}function Cb(a){var b=a.nextFormID++;return a.idPrefix+b}var Db=A("javascript:throw new Error('A React form was unexpectedly submitted.')");function Eb(a,b){this.push('<input type="hidden"');if("string"!==typeof a)throw Error(q(480));J(this,"name",b);J(this,"value",a);this.push("/>")}
+function Fb(a,b,c,d,e,f,g,h){var k=null;"function"===typeof d&&("function"===typeof d.$$FORM_ACTION?(e=Cb(b),b=d.$$FORM_ACTION(e),h=b.name,d=b.action||"",e=b.encType,f=b.method,g=b.target,k=b.data):(a.push(" ","formAction",'="',Db,'"'),g=f=e=d=h=null,Gb(b,c)));null!=h&&K(a,"name",h);null!=d&&K(a,"formAction",d);null!=e&&K(a,"formEncType",e);null!=f&&K(a,"formMethod",f);null!=g&&K(a,"formTarget",g);return k}
+function K(a,b,c){switch(b){case "className":J(a,"class",c);break;case "tabIndex":J(a,"tabindex",c);break;case "dir":case "role":case "viewBox":case "width":case "height":J(a,b,c);break;case "style":qb(a,c);break;case "src":case "href":if(""===c)break;case "action":case "formAction":if(null==c||"function"===typeof c||"symbol"===typeof c||"boolean"===typeof c)break;a.push(" ",b,'="',A(""+c),'"');break;case "defaultValue":case "defaultChecked":case "innerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":break;
+case "autoFocus":case "multiple":case "muted":Bb(a,b.toLowerCase(),c);break;case "xlinkHref":if("function"===typeof c||"symbol"===typeof c||"boolean"===typeof c)break;a.push(" ","xlink:href",'="',A(""+c),'"');break;case "contentEditable":case "spellCheck":case "draggable":case "value":case "autoReverse":case "externalResourcesRequired":case "focusable":case "preserveAlpha":"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'="',A(c),'"');break;case "allowFullScreen":case "async":case "autoPlay":case "controls":case "default":case "defer":case "disabled":case "disablePictureInPicture":case "disableRemotePlayback":case "formNoValidate":case "hidden":case "loop":case "noModule":case "noValidate":case "open":case "playsInline":case "readOnly":case "required":case "reversed":case "scoped":case "seamless":case "itemScope":c&&
+"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'=""');break;case "capture":case "download":!0===c?a.push(" ",b,'=""'):!1!==c&&"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'="',A(c),'"');break;case "cols":case "rows":case "size":case "span":"function"!==typeof c&&"symbol"!==typeof c&&!isNaN(c)&&1<=c&&a.push(" ",b,'="',A(c),'"');break;case "rowSpan":case "start":"function"===typeof c||"symbol"===typeof c||isNaN(c)||a.push(" ",b,'="',A(c),'"');break;case "xlinkActuate":J(a,"xlink:actuate",
+c);break;case "xlinkArcrole":J(a,"xlink:arcrole",c);break;case "xlinkRole":J(a,"xlink:role",c);break;case "xlinkShow":J(a,"xlink:show",c);break;case "xlinkTitle":J(a,"xlink:title",c);break;case "xlinkType":J(a,"xlink:type",c);break;case "xmlBase":J(a,"xml:base",c);break;case "xmlLang":J(a,"xml:lang",c);break;case "xmlSpace":J(a,"xml:space",c);break;default:if(!(2<b.length)||"o"!==b[0]&&"O"!==b[0]||"n"!==b[1]&&"N"!==b[1])if(b=za.get(b)||b,xa(b)){switch(typeof c){case "function":case "symbol":return;
+case "boolean":var d=b.toLowerCase().slice(0,5);if("data-"!==d&&"aria-"!==d)return}a.push(" ",b,'="',A(c),'"')}}}function M(a,b,c){if(null!=b){if(null!=c)throw Error(q(60));if("object"!==typeof b||!("__html"in b))throw Error(q(61));b=b.__html;null!==b&&void 0!==b&&a.push(""+b)}}function Hb(a){var b="";aa.Children.forEach(a,function(c){null!=c&&(b+=c)});return b}
+function Gb(a,b){0!==(a.instructions&16)||b.externalRuntimeScript||(a.instructions|=16,b.bootstrapChunks.unshift(b.startInlineScript,'addEventListener("submit",function(a){if(!a.defaultPrevented){var c=a.target,d=a.submitter,e=c.action,b=d;if(d){var f=d.getAttribute("formAction");null!=f&&(e=f,b=null)}"javascript:throw new Error(\'A React form was unexpectedly submitted.\')"===e&&(a.preventDefault(),b?(a=document.createElement("input"),a.name=b.name,a.value=b.value,b.parentNode.insertBefore(a,b),b=new FormData(c),a.parentNode.removeChild(a)):b=new FormData(c),a=c.getRootNode(),(a.$$reactFormReplay=a.$$reactFormReplay||[]).push(c,\nd,b))}});',"\x3c/script>"))}
+function Ib(a,b,c,d,e,f,g){var h=b.rel,k=b.href,l=b.precedence;if(3===f||g||null!=b.itemProp||"string"!==typeof h||"string"!==typeof k||""===k)return N(a,b),null;if("stylesheet"===b.rel){if("string"!==typeof l||null!=b.disabled||b.onLoad||b.onError)return N(a,b);f=d.styles.get(l);g=c.styleResources.hasOwnProperty(k)?c.styleResources[k]:void 0;null!==g?(c.styleResources[k]=null,f||(f={precedence:A(l),rules:[],hrefs:[],sheets:new Map},d.styles.set(l,f)),b={state:0,props:r({},b,{"data-precedence":b.precedence,
+precedence:null})},g&&(2===g.length&&Jb(b.props,g),(c=d.preloads.stylesheets.get(k))&&0<c.length?c.length=0:b.state=1),f.sheets.set(k,b),d.boundaryResources&&d.boundaryResources.stylesheets.add(b)):f&&(k=f.sheets.get(k))&&d.boundaryResources&&d.boundaryResources.stylesheets.add(k);e&&a.push("\x3c!-- --\x3e");return null}if(b.onLoad||b.onError)return N(a,b);e&&a.push("\x3c!-- --\x3e");switch(b.rel){case "preconnect":case "dns-prefetch":return N(d.preconnectChunks,b);case "preload":return N(d.preloadChunks,
+b);default:return N(d.hoistableChunks,b)}}function N(a,b){a.push(O("link"));for(var c in b)if(z.call(b,c)){var d=b[c];if(null!=d)switch(c){case "children":case "dangerouslySetInnerHTML":throw Error(q(399,"link"));default:K(a,c,d)}}a.push("/>");return null}function Kb(a,b,c){a.push(O(c));for(var d in b)if(z.call(b,d)){var e=b[d];if(null!=e)switch(d){case "children":case "dangerouslySetInnerHTML":throw Error(q(399,c));default:K(a,d,e)}}a.push("/>");return null}
+function Lb(a,b){a.push(O("title"));var c=null,d=null,e;for(e in b)if(z.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:K(a,e,f)}}a.push(">");b=Array.isArray(c)?2>c.length?c[0]:null:c;"function"!==typeof b&&"symbol"!==typeof b&&null!==b&&void 0!==b&&a.push(A(""+b));M(a,d,c);a.push(Mb("title"));return null}
+function Nb(a,b){a.push(O("script"));var c=null,d=null,e;for(e in b)if(z.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:K(a,e,f)}}a.push(">");M(a,d,c);"string"===typeof c&&a.push(A(c));a.push(Mb("script"));return null}
+function Ob(a,b,c){a.push(O(c));var d=c=null,e;for(e in b)if(z.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:K(a,e,f)}}a.push(">");M(a,d,c);return"string"===typeof c?(a.push(A(c)),null):c}var Pb=/^[a-zA-Z][a-zA-Z:_\.\-\d]*$/,Qb=new Map;function O(a){var b=Qb.get(a);if(void 0===b){if(!Pb.test(a))throw Error(q(65,a));b="<"+a;Qb.set(a,b)}return b}
+function Rb(a,b,c,d,e,f,g){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "select":a.push(O("select"));var h=null,k=null,l;for(l in c)if(z.call(c,l)){var n=c[l];if(null!=n)switch(l){case "children":h=n;break;case "dangerouslySetInnerHTML":k=n;break;case "defaultValue":case "value":break;default:K(a,l,n)}}a.push(">");M(a,k,h);return h;case "option":var t=f.selectedValue;a.push(O("option"));var m=null,C=null,F=null,Q=null,w;for(w in c)if(z.call(c,
+w)){var u=c[w];if(null!=u)switch(w){case "children":m=u;break;case "selected":F=u;break;case "dangerouslySetInnerHTML":Q=u;break;case "value":C=u;default:K(a,w,u)}}if(null!=t){var p=null!==C?""+C:Hb(m);if(Ja(t))for(var H=0;H<t.length;H++){if(""+t[H]===p){a.push(' selected=""');break}}else""+t===p&&a.push(' selected=""')}else F&&a.push(' selected=""');a.push(">");M(a,Q,m);return m;case "textarea":a.push(O("textarea"));var v=null,x=null,E=null,D;for(D in c)if(z.call(c,D)){var y=c[D];if(null!=y)switch(D){case "children":E=
+y;break;case "value":v=y;break;case "defaultValue":x=y;break;case "dangerouslySetInnerHTML":throw Error(q(91));default:K(a,D,y)}}null===v&&null!==x&&(v=x);a.push(">");if(null!=E){if(null!=v)throw Error(q(92));if(Ja(E)){if(1<E.length)throw Error(q(93));v=""+E[0]}v=""+E}"string"===typeof v&&"\n"===v[0]&&a.push("\n");null!==v&&a.push(A(""+v));return null;case "input":a.push(O("input"));var Qa=null,rb=null,Ca=null,la=null,ea=null,W=null,Ra=null,Sa=null,Ta=null,ma;for(ma in c)if(z.call(c,ma)){var R=c[ma];
+if(null!=R)switch(ma){case "children":case "dangerouslySetInnerHTML":throw Error(q(399,"input"));case "name":Qa=R;break;case "formAction":rb=R;break;case "formEncType":Ca=R;break;case "formMethod":la=R;break;case "formTarget":ea=R;break;case "defaultChecked":Ta=R;break;case "defaultValue":Ra=R;break;case "checked":Sa=R;break;case "value":W=R;break;default:K(a,ma,R)}}var sb=Fb(a,d,e,rb,Ca,la,ea,Qa);null!==Sa?Bb(a,"checked",Sa):null!==Ta&&Bb(a,"checked",Ta);null!==W?K(a,"value",W):null!==Ra&&K(a,"value",
+Ra);a.push("/>");null!==sb&&sb.forEach(Eb,a);return null;case "button":a.push(O("button"));var na=null,oa=null,ba=null,pa=null,qa=null,Ua=null,ra=null,Va;for(Va in c)if(z.call(c,Va)){var ca=c[Va];if(null!=ca)switch(Va){case "children":na=ca;break;case "dangerouslySetInnerHTML":oa=ca;break;case "name":ba=ca;break;case "formAction":pa=ca;break;case "formEncType":qa=ca;break;case "formMethod":Ua=ca;break;case "formTarget":ra=ca;break;default:K(a,Va,ca)}}var Qc=Fb(a,d,e,pa,qa,Ua,ra,ba);a.push(">");null!==
+Qc&&Qc.forEach(Eb,a);M(a,oa,na);if("string"===typeof na){a.push(A(na));var Rc=null}else Rc=na;return Rc;case "form":a.push(O("form"));var Wa=null,Sc=null,fa=null,Xa=null,Ya=null,Za=null,$a;for($a in c)if(z.call(c,$a)){var ha=c[$a];if(null!=ha)switch($a){case "children":Wa=ha;break;case "dangerouslySetInnerHTML":Sc=ha;break;case "action":fa=ha;break;case "encType":Xa=ha;break;case "method":Ya=ha;break;case "target":Za=ha;break;default:K(a,$a,ha)}}var Zb=null,$b=null;if("function"===typeof fa)if("function"===
+typeof fa.$$FORM_ACTION){var xe=Cb(d),Da=fa.$$FORM_ACTION(xe);fa=Da.action||"";Xa=Da.encType;Ya=Da.method;Za=Da.target;Zb=Da.data;$b=Da.name}else a.push(" ","action",'="',Db,'"'),Za=Ya=Xa=fa=null,Gb(d,e);null!=fa&&K(a,"action",fa);null!=Xa&&K(a,"encType",Xa);null!=Ya&&K(a,"method",Ya);null!=Za&&K(a,"target",Za);a.push(">");null!==$b&&(a.push('<input type="hidden"'),J(a,"name",$b),a.push("/>"),null!==Zb&&Zb.forEach(Eb,a));M(a,Sc,Wa);if("string"===typeof Wa){a.push(A(Wa));var Tc=null}else Tc=Wa;return Tc;
+case "menuitem":a.push(O("menuitem"));for(var tb in c)if(z.call(c,tb)){var Uc=c[tb];if(null!=Uc)switch(tb){case "children":case "dangerouslySetInnerHTML":throw Error(q(400));default:K(a,tb,Uc)}}a.push(">");return null;case "title":if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp)var Vc=Lb(a,c);else Lb(e.hoistableChunks,c),Vc=null;return Vc;case "link":return Ib(a,c,d,e,g,f.insertionMode,!!(f.tagScope&1));case "script":var ac=c.async;if("string"!==typeof c.src||!c.src||!ac||"function"===typeof ac||
+"symbol"===typeof ac||c.onLoad||c.onError||3===f.insertionMode||f.tagScope&1||null!=c.itemProp)var Wc=Nb(a,c);else{var ub=c.src;if("module"===c.type){var vb=d.moduleScriptResources;var Xc=e.preloads.moduleScripts}else vb=d.scriptResources,Xc=e.preloads.scripts;var wb=vb.hasOwnProperty(ub)?vb[ub]:void 0;if(null!==wb){vb[ub]=null;var bc=c;if(wb){2===wb.length&&(bc=r({},c),Jb(bc,wb));var Yc=Xc.get(ub);Yc&&(Yc.length=0)}var Zc=[];e.scripts.add(Zc);Nb(Zc,bc)}g&&a.push("\x3c!-- --\x3e");Wc=null}return Wc;
+case "style":var xb=c.precedence,sa=c.href;if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp||"string"!==typeof xb||"string"!==typeof sa||""===sa){a.push(O("style"));var Ea=null,$c=null,ab;for(ab in c)if(z.call(c,ab)){var yb=c[ab];if(null!=yb)switch(ab){case "children":Ea=yb;break;case "dangerouslySetInnerHTML":$c=yb;break;default:K(a,ab,yb)}}a.push(">");var bb=Array.isArray(Ea)?2>Ea.length?Ea[0]:null:Ea;"function"!==typeof bb&&"symbol"!==typeof bb&&null!==bb&&void 0!==bb&&a.push(A(""+bb));M(a,
+$c,Ea);a.push(Mb("style"));var ad=null}else{var ta=e.styles.get(xb);if(null!==(d.styleResources.hasOwnProperty(sa)?d.styleResources[sa]:void 0)){d.styleResources[sa]=null;ta?ta.hrefs.push(A(sa)):(ta={precedence:A(xb),rules:[],hrefs:[A(sa)],sheets:new Map},e.styles.set(xb,ta));var bd=ta.rules,Fa=null,cd=null,zb;for(zb in c)if(z.call(c,zb)){var cc=c[zb];if(null!=cc)switch(zb){case "children":Fa=cc;break;case "dangerouslySetInnerHTML":cd=cc}}var cb=Array.isArray(Fa)?2>Fa.length?Fa[0]:null:Fa;"function"!==
+typeof cb&&"symbol"!==typeof cb&&null!==cb&&void 0!==cb&&bd.push(A(""+cb));M(bd,cd,Fa)}ta&&e.boundaryResources&&e.boundaryResources.styles.add(ta);g&&a.push("\x3c!-- --\x3e");ad=void 0}return ad;case "meta":if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp)var dd=Kb(a,c,"meta");else g&&a.push("\x3c!-- --\x3e"),dd="string"===typeof c.charSet?Kb(e.charsetChunks,c,"meta"):"viewport"===c.name?Kb(e.preconnectChunks,c,"meta"):Kb(e.hoistableChunks,c,"meta");return dd;case "listing":case "pre":a.push(O(b));
+var db=null,eb=null,fb;for(fb in c)if(z.call(c,fb)){var Ab=c[fb];if(null!=Ab)switch(fb){case "children":db=Ab;break;case "dangerouslySetInnerHTML":eb=Ab;break;default:K(a,fb,Ab)}}a.push(">");if(null!=eb){if(null!=db)throw Error(q(60));if("object"!==typeof eb||!("__html"in eb))throw Error(q(61));var ua=eb.__html;null!==ua&&void 0!==ua&&("string"===typeof ua&&0<ua.length&&"\n"===ua[0]?a.push("\n",ua):a.push(""+ua))}"string"===typeof db&&"\n"===db[0]&&a.push("\n");return db;case "img":var L=c.src,I=
+c.srcSet;if(!("lazy"===c.loading||!L&&!I||"string"!==typeof L&&null!=L||"string"!==typeof I&&null!=I)&&"low"!==c.fetchPriority&&!1===!!(f.tagScope&2)&&("string"!==typeof L||":"!==L[4]||"d"!==L[0]&&"D"!==L[0]||"a"!==L[1]&&"A"!==L[1]||"t"!==L[2]&&"T"!==L[2]||"a"!==L[3]&&"A"!==L[3])&&("string"!==typeof I||":"!==I[4]||"d"!==I[0]&&"D"!==I[0]||"a"!==I[1]&&"A"!==I[1]||"t"!==I[2]&&"T"!==I[2]||"a"!==I[3]&&"A"!==I[3])){var ed="string"===typeof c.sizes?c.sizes:void 0,Ga=I?I+"\n"+(ed||""):L,dc=e.preloads.images,
+va=dc.get(Ga);if(va){if("high"===c.fetchPriority||10>e.highImagePreloads.size)dc.delete(Ga),e.highImagePreloads.add(va)}else if(!d.imageResources.hasOwnProperty(Ga)){d.imageResources[Ga]=B;var ec=c.crossOrigin;var fd="string"===typeof ec?"use-credentials"===ec?ec:"":void 0;var X=e.headers,fc;X&&0<X.remainingCapacity&&("high"===c.fetchPriority||500>X.highImagePreloads.length)&&(fc=Sb(L,"image",{imageSrcSet:c.srcSet,imageSizes:c.sizes,crossOrigin:fd,integrity:c.integrity,nonce:c.nonce,type:c.type,fetchPriority:c.fetchPriority,
+referrerPolicy:c.refererPolicy}),2<=(X.remainingCapacity-=fc.length))?(e.resets.image[Ga]=B,X.highImagePreloads&&(X.highImagePreloads+=", "),X.highImagePreloads+=fc):(va=[],N(va,{rel:"preload",as:"image",href:I?void 0:L,imageSrcSet:I,imageSizes:ed,crossOrigin:fd,integrity:c.integrity,type:c.type,fetchPriority:c.fetchPriority,referrerPolicy:c.referrerPolicy}),"high"===c.fetchPriority||10>e.highImagePreloads.size?e.highImagePreloads.add(va):(e.bulkPreloads.add(va),dc.set(Ga,va)))}}return Kb(a,c,"img");
+case "base":case "area":case "br":case "col":case "embed":case "hr":case "keygen":case "param":case "source":case "track":case "wbr":return Kb(a,c,b);case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph":break;case "head":if(2>f.insertionMode&&null===e.headChunks){e.headChunks=[];var gd=Ob(e.headChunks,c,"head")}else gd=Ob(a,c,"head");return gd;case "html":if(0===f.insertionMode&&null===
+e.htmlChunks){e.htmlChunks=[""];var hd=Ob(e.htmlChunks,c,"html")}else hd=Ob(a,c,"html");return hd;default:if(-1!==b.indexOf("-")){a.push(O(b));var gc=null,id=null,Ha;for(Ha in c)if(z.call(c,Ha)){var T=c[Ha];if(null!=T){var jd=Ha;switch(Ha){case "children":gc=T;break;case "dangerouslySetInnerHTML":id=T;break;case "style":qb(a,T);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":break;case "className":jd="class";default:if(xa(Ha)&&"function"!==typeof T&&"symbol"!==typeof T&&
+!1!==T){if(!0===T)T="";else if("object"===typeof T)continue;a.push(" ",jd,'="',A(T),'"')}}}}a.push(">");M(a,id,gc);return gc}}return Ob(a,c,b)}var Tb=new Map;function Mb(a){var b=Tb.get(a);void 0===b&&(b="</"+a+">",Tb.set(a,b));return b}function Ub(a,b,c){c.bootstrapScriptContent=void 0;c.bootstrapScripts=void 0;c.bootstrapModules=void 0;b=b.bootstrapChunks;for(c=0;c<b.length-1;c++)a.push(b[c]);return c<b.length?(c=b[c],b.length=0,a.push(c)):!0}
+function Vb(a,b,c){a.push('\x3c!--$?--\x3e<template id="');if(null===c)throw Error(q(395));a.push(b.boundaryPrefix);b=c.toString(16);a.push(b);return a.push('"></template>')}
+function Wb(a,b,c,d){switch(c.insertionMode){case 0:case 1:case 2:return a.push('<div hidden id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 3:return a.push('<svg aria-hidden="true" style="display:none" id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 4:return a.push('<math aria-hidden="true" style="display:none" id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 5:return a.push('<table hidden id="'),a.push(b.segmentPrefix),
+b=d.toString(16),a.push(b),a.push('">');case 6:return a.push('<table hidden><tbody id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 7:return a.push('<table hidden><tr id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 8:return a.push('<table hidden><colgroup id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');default:throw Error(q(397));}}
+function Xb(a,b){switch(b.insertionMode){case 0:case 1:case 2:return a.push("</div>");case 3:return a.push("</svg>");case 4:return a.push("</math>");case 5:return a.push("</table>");case 6:return a.push("</tbody></table>");case 7:return a.push("</tr></table>");case 8:return a.push("</colgroup></table>");default:throw Error(q(397));}}var Yb=/[<\u2028\u2029]/g;
+function hc(a){return JSON.stringify(a).replace(Yb,function(b){switch(b){case "<":return"\\u003c";case "\u2028":return"\\u2028";case "\u2029":return"\\u2029";default:throw Error("escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}})}var ic=/[&><\u2028\u2029]/g;
+function jc(a){return JSON.stringify(a).replace(ic,function(b){switch(b){case "&":return"\\u0026";case ">":return"\\u003e";case "<":return"\\u003c";case "\u2028":return"\\u2028";case "\u2029":return"\\u2029";default:throw Error("escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}})}var kc=!1,lc=!0;
+function mc(a){var b=a.rules,c=a.hrefs,d=0;if(c.length){this.push('<style media="not all" data-precedence="');this.push(a.precedence);for(this.push('" data-href="');d<c.length-1;d++)this.push(c[d]),this.push(" ");this.push(c[d]);this.push('">');for(d=0;d<b.length;d++)this.push(b[d]);lc=this.push("</style>");kc=!0;b.length=0;c.length=0}}function nc(a){return 2!==a.state?kc=!0:!1}function oc(a,b,c){kc=!1;lc=!0;b.styles.forEach(mc,a);b.stylesheets.forEach(nc);kc&&(c.stylesToHoist=!0);return lc}
+function P(a){for(var b=0;b<a.length;b++)this.push(a[b]);a.length=0}var pc=[];function qc(a){N(pc,a.props);for(var b=0;b<pc.length;b++)this.push(pc[b]);pc.length=0;a.state=2}
+function rc(a){var b=0<a.sheets.size;a.sheets.forEach(qc,this);a.sheets.clear();var c=a.rules,d=a.hrefs;if(!b||d.length){this.push('<style data-precedence="');this.push(a.precedence);a=0;if(d.length){for(this.push('" data-href="');a<d.length-1;a++)this.push(d[a]),this.push(" ");this.push(d[a])}this.push('">');for(a=0;a<c.length;a++)this.push(c[a]);this.push("</style>");c.length=0;d.length=0}}
+function sc(a){if(0===a.state){a.state=1;var b=a.props;N(pc,{rel:"preload",as:"style",href:a.props.href,crossOrigin:b.crossOrigin,fetchPriority:b.fetchPriority,integrity:b.integrity,media:b.media,hrefLang:b.hrefLang,referrerPolicy:b.referrerPolicy});for(a=0;a<pc.length;a++)this.push(pc[a]);pc.length=0}}function tc(a){a.sheets.forEach(sc,this);a.sheets.clear()}
+function uc(a,b){a.push("[");var c="[";b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)a.push(c),d=jc(""+d.props.href),a.push(d),a.push("]"),c=",[";else{a.push(c);var e=d.props["data-precedence"],f=d.props,g=jc(""+d.props.href);a.push(g);e=""+e;a.push(",");e=jc(e);a.push(e);for(var h in f)if(z.call(f,h)&&(g=f[h],null!=g))switch(h){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error(q(399,"link"));default:a:{e=
+a;var k=h.toLowerCase();switch(typeof g){case "function":case "symbol":break a}switch(h){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":k="class";g=""+g;break;case "hidden":if(!1===g)break a;g="";break;case "src":case "href":g=""+g;break;default:if(2<h.length&&("o"===h[0]||"O"===h[0])&&("n"===h[1]||"N"===h[1])||!xa(h))break a;g=""+g}e.push(",");k=jc(k);e.push(k);e.push(",");g=jc(g);e.push(g)}}a.push("]");
 c=",[";d.state=3}});a.push("]")}
-function uc(a,b){a.push("[");var c="[";b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)a.push(c),d=y(JSON.stringify(""+d.props.href)),a.push(d),a.push("]"),c=",[";else{a.push(c);var e=d.props["data-precedence"],f=d.props,g=y(JSON.stringify(""+d.props.href));a.push(g);e=""+e;a.push(",");e=y(JSON.stringify(e));a.push(e);for(var h in f)if(x.call(f,h)&&(g=f[h],null!=g))switch(h){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error(p(399,"link"));
-default:a:{e=a;var k=h.toLowerCase();switch(typeof g){case "function":case "symbol":break a}switch(h){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":k="class";g=""+g;break;case "hidden":if(!1===g)break a;g="";break;case "src":case "href":g=""+g;break;default:if(2<h.length&&("o"===h[0]||"O"===h[0])&&("n"===h[1]||"N"===h[1])||!ya(h))break a;g=""+g}e.push(",");k=y(JSON.stringify(k));e.push(k);
-e.push(",");g=y(JSON.stringify(g));e.push(g)}}a.push("]");c=",[";d.state=3}});a.push("]")}
-function Oa(a){var b=P?P:null;if(b){var c=b.resumableState,d=b.renderState;if("string"===typeof a&&a){if(!c.dnsResources.hasOwnProperty(a)){c.dnsResources[a]=null;c=d.headers;var e,f;if(f=c&&0<c.remainingCapacity)f=(e="<"+(""+a).replace(vc,wc)+">; rel=dns-prefetch",2<=(c.remainingCapacity-=e.length));f?(d.resets.dns[a]=null,c.preconnects&&(c.preconnects+=", "),c.preconnects+=e):(e=[],L(e,{href:a,rel:"dns-prefetch"}),d.preconnects.add(e))}xc(b)}}}
-function Pa(a,b){var c=P?P:null;if(c){var d=c.resumableState,e=c.renderState;if("string"===typeof a&&a){var f="use-credentials"===b?"credentials":"string"===typeof b?"anonymous":"default";if(!d.connectResources[f].hasOwnProperty(a)){d.connectResources[f][a]=null;d=e.headers;var g,h;if(h=d&&0<d.remainingCapacity){h="<"+(""+a).replace(vc,wc)+">; rel=preconnect";if("string"===typeof b){var k=(""+b).replace(yc,zc);h+='; crossorigin="'+k+'"'}h=(g=h,2<=(d.remainingCapacity-=g.length))}h?(e.resets.connect[f][a]=
-null,d.preconnects&&(d.preconnects+=", "),d.preconnects+=g):(f=[],L(f,{rel:"preconnect",href:a,crossOrigin:b}),e.preconnects.add(f))}xc(c)}}}
-function gb(a,b,c){var d=P?P:null;if(d){var e=d.resumableState,f=d.renderState;if(b&&a){switch(b){case "image":if(c){var g=c.imageSrcSet;var h=c.imageSizes;var k=c.fetchPriority}var l=g?g+"\n"+(h||""):a;if(e.imageResources.hasOwnProperty(l))return;e.imageResources[l]=z;e=f.headers;var n;e&&0<e.remainingCapacity&&"high"===k&&(n=Rb(a,b,c),2<=(e.remainingCapacity-=n.length))?(f.resets.image[l]=z,e.highImagePreloads&&(e.highImagePreloads+=", "),e.highImagePreloads+=n):(e=[],L(e,t({rel:"preload",href:g?
-void 0:a,as:b},c)),"high"===k?f.highImagePreloads.add(e):(f.bulkPreloads.add(e),f.preloads.images.set(l,e)));break;case "style":if(e.styleResources.hasOwnProperty(a))return;g=[];L(g,t({rel:"preload",href:a,as:b},c));e.styleResources[a]=!c||"string"!==typeof c.crossOrigin&&"string"!==typeof c.integrity?z:[c.crossOrigin,c.integrity];f.preloads.stylesheets.set(a,g);f.bulkPreloads.add(g);break;case "script":if(e.scriptResources.hasOwnProperty(a))return;g=[];f.preloads.scripts.set(a,g);f.bulkPreloads.add(g);
-L(g,t({rel:"preload",href:a,as:b},c));e.scriptResources[a]=!c||"string"!==typeof c.crossOrigin&&"string"!==typeof c.integrity?z:[c.crossOrigin,c.integrity];break;default:if(e.unknownResources.hasOwnProperty(b)){if(g=e.unknownResources[b],g.hasOwnProperty(a))return}else g={},e.unknownResources[b]=g;g[a]=z;if((e=f.headers)&&0<e.remainingCapacity&&"font"===b&&(l=Rb(a,b,c),2<=(e.remainingCapacity-=l.length)))f.resets.font[a]=z,e.fontPreloads&&(e.fontPreloads+=", "),e.fontPreloads+=l;else switch(e=[],
-a=t({rel:"preload",href:a,as:b},c),L(e,a),b){case "font":f.fontPreloads.add(e);break;default:f.bulkPreloads.add(e)}}xc(d)}}}
-function hb(a,b){var c=P?P:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=b&&"string"===typeof b.as?b.as:"script";switch(f){case "script":if(d.moduleScriptResources.hasOwnProperty(a))return;f=[];d.moduleScriptResources[a]=!b||"string"!==typeof b.crossOrigin&&"string"!==typeof b.integrity?z:[b.crossOrigin,b.integrity];e.preloads.moduleScripts.set(a,f);break;default:if(d.moduleUnknownResources.hasOwnProperty(f)){var g=d.unknownResources[f];if(g.hasOwnProperty(a))return}else g={},d.moduleUnknownResources[f]=
-g;f=[];g[a]=z}L(f,t({rel:"modulepreload",href:a},b));e.bulkPreloads.add(f);xc(c)}}}
-function ib(a,b,c){var d=P?P:null;if(d){var e=d.resumableState,f=d.renderState;if(a){b=b||"default";var g=f.styles.get(b),h=e.styleResources.hasOwnProperty(a)?e.styleResources[a]:void 0;null!==h&&(e.styleResources[a]=null,g||(g={precedence:y(b),rules:[],hrefs:[],sheets:new Map},f.styles.set(b,g)),b={state:0,props:t({rel:"stylesheet",href:a,"data-precedence":b},c)},h&&(2===h.length&&Ib(b.props,h),(f=f.preloads.stylesheets.get(a))&&0<f.length?f.length=0:b.state=1),g.sheets.set(a,b),xc(d))}}}
-function jb(a,b){var c=P?P:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=d.scriptResources.hasOwnProperty(a)?d.scriptResources[a]:void 0;null!==f&&(d.scriptResources[a]=null,b=t({src:a,async:!0},b),f&&(2===f.length&&Ib(b,f),a=e.preloads.scripts.get(a))&&(a.length=0),a=[],e.scripts.add(a),Mb(a,b),xc(c))}}}
-function kb(a,b){var c=P?P:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=d.moduleScriptResources.hasOwnProperty(a)?d.moduleScriptResources[a]:void 0;null!==f&&(d.moduleScriptResources[a]=null,b=t({src:a,type:"module",async:!0},b),f&&(2===f.length&&Ib(b,f),a=e.preloads.moduleScripts.get(a))&&(a.length=0),a=[],e.scripts.add(a),Mb(a,b),xc(c))}}}function Ib(a,b){null==a.crossOrigin&&(a.crossOrigin=b[0]);null==a.integrity&&(a.integrity=b[1])}
-function Rb(a,b,c){a=(""+a).replace(vc,wc);b=(""+b).replace(yc,zc);b="<"+a+'>; rel=preload; as="'+b+'"';for(var d in c)x.call(c,d)&&(a=c[d],"string"===typeof a&&(b+="; "+d.toLowerCase()+'="'+(""+a).replace(yc,zc)+'"'));return b}var vc=/[<>\r\n]/g;
-function wc(a){switch(a){case "<":return"%3C";case ">":return"%3E";case "\n":return"%0A";case "\r":return"%0D";default:throw Error("escapeLinkHrefForHeaderContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}}var yc=/["';,\r\n]/g;
-function zc(a){switch(a){case '"':return"%22";case "'":return"%27";case ";":return"%3B";case ",":return"%2C";case "\n":return"%0A";case "\r":return"%0D";default:throw Error("escapeStringForLinkHeaderQuotedParamValueContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}}function Ac(a){this.styles.add(a)}function Bc(a){this.stylesheets.add(a)}
-function Cc(a,b,c){if(b=a.onHeaders){var d=a.headers;if(d){var e=d.preconnects;d.fontPreloads&&(e&&(e+=", "),e+=d.fontPreloads);d.highImagePreloads&&(e&&(e+=", "),e+=d.highImagePreloads);if(!c){c=a.styles.values();var f=c.next();a:for(;0<d.remainingCapacity&&!f.done;f=c.next()){f=f.value.sheets.values();for(var g=f.next();0<d.remainingCapacity&&!g.done;g=f.next()){var h=g.value;g=h.props;var k=g.href;h=h.props;h=Rb(h.href,"style",{crossOrigin:h.crossOrigin,integrity:h.integrity,nonce:h.nonce,type:h.type,
-fetchPriority:h.fetchPriority,referrerPolicy:h.referrerPolicy,media:h.media});if(2<=(d.remainingCapacity-=h.length))a.resets.style[k]=z,e&&(e+=", "),e+=h,a.resets.style[k]="string"===typeof g.crossOrigin||"string"===typeof g.integrity?[g.crossOrigin,g.integrity]:z;else break a}}}e?b({Link:e}):b({});a.headers=null}}}
-function Dc(a,b){var c=a.idPrefix;a=c+"P:";var d=c+"S:";c+="B:";var e=new Set,f=new Set,g=new Set,h=new Map,k=new Set,l=new Set,n=new Set,r={images:new Map,stylesheets:new Map,scripts:new Map,moduleScripts:new Map};return{placeholderPrefix:a,segmentPrefix:d,boundaryPrefix:c,startInlineScript:"<script>",htmlChunks:null,headChunks:null,externalRuntimeScript:null,bootstrapChunks:[],onHeaders:void 0,headers:null,resets:{font:{},dns:{},connect:{default:{},anonymous:{},credentials:{}},image:{},style:{}},
-charsetChunks:[],preconnectChunks:[],importMapChunks:[],preloadChunks:[],hoistableChunks:[],preconnects:e,fontPreloads:f,highImagePreloads:g,styles:h,bootstrapScripts:k,scripts:l,bulkPreloads:n,preloads:r,boundaryResources:null,stylesToHoist:!1,generateStaticMarkup:b}}function Ec(a,b,c,d){if(c.generateStaticMarkup)return a.push(y(b)),!1;""===b?a=d:(d&&a.push("\x3c!-- --\x3e"),a.push(y(b)),a=!0);return a}
-var Fc=Symbol.for("react.element"),Gc=Symbol.for("react.portal"),Hc=Symbol.for("react.fragment"),Ic=Symbol.for("react.strict_mode"),Jc=Symbol.for("react.profiler"),Kc=Symbol.for("react.provider"),Lc=Symbol.for("react.context"),Mc=Symbol.for("react.server_context"),Nc=Symbol.for("react.forward_ref"),Oc=Symbol.for("react.suspense"),Pc=Symbol.for("react.suspense_list"),kd=Symbol.for("react.memo"),ld=Symbol.for("react.lazy"),md=Symbol.for("react.scope"),nd=Symbol.for("react.debug_trace_mode"),od=Symbol.for("react.offscreen"),
-pd=Symbol.for("react.legacy_hidden"),qd=Symbol.for("react.cache"),rd=Symbol.for("react.default_value"),sd=Symbol.for("react.memo_cache_sentinel"),td=Symbol.for("react.postpone"),ud=Symbol.iterator;
-function vd(a){if(null==a)return null;if("function"===typeof a)return a.displayName||a.name||null;if("string"===typeof a)return a;switch(a){case Hc:return"Fragment";case Gc:return"Portal";case Jc:return"Profiler";case Ic:return"StrictMode";case Oc:return"Suspense";case Pc:return"SuspenseList";case qd:return"Cache"}if("object"===typeof a)switch(a.$$typeof){case Lc:return(a.displayName||"Context")+".Consumer";case Kc:return(a._context.displayName||"Context")+".Provider";case Nc:var b=a.render;a=a.displayName;
-a||(a=b.displayName||b.name||"",a=""!==a?"ForwardRef("+a+")":"ForwardRef");return a;case kd:return b=a.displayName||null,null!==b?b:vd(a.type)||"Memo";case ld:b=a._payload;a=a._init;try{return vd(a(b))}catch(c){break}case Mc:return(a.displayName||a._globalName)+".Provider"}return null}var wd={};function xd(a,b){a=a.contextTypes;if(!a)return wd;var c={},d;for(d in a)c[d]=b[d];return c}var yd=null;
-function zd(a,b){if(a!==b){a.context._currentValue2=a.parentValue;a=a.parent;var c=b.parent;if(null===a){if(null!==c)throw Error(p(401));}else{if(null===c)throw Error(p(401));zd(a,c)}b.context._currentValue2=b.value}}function Ad(a){a.context._currentValue2=a.parentValue;a=a.parent;null!==a&&Ad(a)}function Bd(a){var b=a.parent;null!==b&&Bd(b);a.context._currentValue2=a.value}
-function Cd(a,b){a.context._currentValue2=a.parentValue;a=a.parent;if(null===a)throw Error(p(402));a.depth===b.depth?zd(a,b):Cd(a,b)}function Dd(a,b){var c=b.parent;if(null===c)throw Error(p(402));a.depth===c.depth?zd(a,c):Dd(a,c);b.context._currentValue2=b.value}function Ed(a){var b=yd;b!==a&&(null===b?Bd(a):null===a?Ad(b):b.depth===a.depth?zd(b,a):b.depth>a.depth?Cd(b,a):Dd(b,a),yd=a)}
-var Fd={isMounted:function(){return!1},enqueueSetState:function(a,b){a=a._reactInternals;null!==a.queue&&a.queue.push(b)},enqueueReplaceState:function(a,b){a=a._reactInternals;a.replace=!0;a.queue=[b]},enqueueForceUpdate:function(){}};
-function Gd(a,b,c,d){var e=void 0!==a.state?a.state:null;a.updater=Fd;a.props=c;a.state=e;var f={queue:[],replace:!1};a._reactInternals=f;var g=b.contextType;a.context="object"===typeof g&&null!==g?g._currentValue2:d;g=b.getDerivedStateFromProps;"function"===typeof g&&(g=g(c,e),e=null===g||void 0===g?e:t({},e,g),a.state=e);if("function"!==typeof b.getDerivedStateFromProps&&"function"!==typeof a.getSnapshotBeforeUpdate&&("function"===typeof a.UNSAFE_componentWillMount||"function"===typeof a.componentWillMount))if(b=
-a.state,"function"===typeof a.componentWillMount&&a.componentWillMount(),"function"===typeof a.UNSAFE_componentWillMount&&a.UNSAFE_componentWillMount(),b!==a.state&&Fd.enqueueReplaceState(a,a.state,null),null!==f.queue&&0<f.queue.length)if(b=f.queue,g=f.replace,f.queue=null,f.replace=!1,g&&1===b.length)a.state=b[0];else{f=g?b[0]:a.state;e=!0;for(g=g?1:0;g<b.length;g++){var h=b[g];h="function"===typeof h?h.call(a,f,c,d):h;null!=h&&(e?(e=!1,f=t({},f,h)):t(f,h))}a.state=f}else f.queue=null}
-var Hd={id:1,overflow:""};function Id(a,b,c){var d=a.id;a=a.overflow;var e=32-Jd(d)-1;d&=~(1<<e);c+=1;var f=32-Jd(b)+e;if(30<f){var g=e-e%5;f=(d&(1<<g)-1).toString(32);d>>=g;e-=g;return{id:1<<32-Jd(b)+e|c<<e|d,overflow:f+a}}return{id:1<<f|c<<e|d,overflow:a}}var Jd=Math.clz32?Math.clz32:Kd,Ld=Math.log,Md=Math.LN2;function Kd(a){a>>>=0;return 0===a?32:31-(Ld(a)/Md|0)|0}var Nd=Error(p(460));function Od(){}
-function Pd(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(Od,Od),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;default:if("string"!==typeof b.status)switch(a=b,a.status="pending",a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}}),b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;}Qd=b;throw Nd;}}var Qd=null;
-function Rd(){if(null===Qd)throw Error(p(459));var a=Qd;Qd=null;return a}function Sd(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var Td="function"===typeof Object.is?Object.is:Sd,S=null,Ud=null,Vd=null,Wd=null,Xd=null,T=null,Yd=!1,Zd=!1,$d=0,ae=0,be=-1,ce=0,de=null,ee=null,fe=0;function ge(){if(null===S)throw Error(p(321));return S}function he(){if(0<fe)throw Error(p(312));return{memoizedState:null,queue:null,next:null}}
-function ie(){null===T?null===Xd?(Yd=!1,Xd=T=he()):(Yd=!0,T=Xd):null===T.next?(Yd=!1,T=T.next=he()):(Yd=!0,T=T.next);return T}function je(a,b,c,d){for(;Zd;)Zd=!1,ae=$d=0,be=-1,ce=0,fe+=1,T=null,c=a(b,d);ke();return c}function le(){var a=de;de=null;return a}function ke(){Wd=Vd=Ud=S=null;Zd=!1;Xd=null;fe=0;T=ee=null}function me(a,b){return"function"===typeof b?b(a):b}
-function ne(a,b,c){S=ge();T=ie();if(Yd){var d=T.queue;b=d.dispatch;if(null!==ee&&(c=ee.get(d),void 0!==c)){ee.delete(d);d=T.memoizedState;do d=a(d,c.action),c=c.next;while(null!==c);T.memoizedState=d;return[d,b]}return[T.memoizedState,b]}a=a===me?"function"===typeof b?b():b:void 0!==c?c(b):b;T.memoizedState=a;a=T.queue={last:null,dispatch:null};a=a.dispatch=oe.bind(null,S,a);return[T.memoizedState,a]}
-function pe(a,b){S=ge();T=ie();b=void 0===b?null:b;if(null!==T){var c=T.memoizedState;if(null!==c&&null!==b){var d=c[1];a:if(null===d)d=!1;else{for(var e=0;e<d.length&&e<b.length;e++)if(!Td(b[e],d[e])){d=!1;break a}d=!0}if(d)return c[0]}}a=a();T.memoizedState=[a,b];return a}function oe(a,b,c){if(25<=fe)throw Error(p(301));if(a===S)if(Zd=!0,a={action:c,next:null},null===ee&&(ee=new Map),c=ee.get(b),void 0===c)ee.set(b,a);else{for(b=c;null!==b.next;)b=b.next;b.next=a}}
-function qe(){throw Error(p(440));}function re(){throw Error(p(394));}function se(){throw Error(p(479));}function te(a){var b=ce;ce+=1;null===de&&(de=[]);return Pd(de,a,b)}function ue(){throw Error(p(393));}function we(){}
-var ye={readContext:function(a){return a._currentValue2},use:function(a){if(null!==a&&"object"===typeof a){if("function"===typeof a.then)return te(a);if(a.$$typeof===Lc||a.$$typeof===Mc)return a._currentValue2}throw Error(p(438,String(a)));},useContext:function(a){ge();return a._currentValue2},useMemo:pe,useReducer:ne,useRef:function(a){S=ge();T=ie();var b=T.memoizedState;return null===b?(a={current:a},T.memoizedState=a):b},useState:function(a){return ne(me,a)},useInsertionEffect:we,useLayoutEffect:we,
-useCallback:function(a,b){return pe(function(){return a},b)},useImperativeHandle:we,useEffect:we,useDebugValue:we,useDeferredValue:function(a,b){ge();return void 0!==b?b:a},useTransition:function(){ge();return[!1,re]},useId:function(){var a=Ud.treeContext;var b=a.overflow;a=a.id;a=(a&~(1<<32-Jd(a)-1)).toString(32)+b;var c=xe;if(null===c)throw Error(p(404));b=$d++;a=":"+c.idPrefix+"R"+a;0<b&&(a+="H"+b.toString(32));return a+":"},useSyncExternalStore:function(a,b,c){if(void 0===c)throw Error(p(407));
-return c()},useCacheRefresh:function(){return ue},useEffectEvent:function(){return qe},useMemoCache:function(a){for(var b=Array(a),c=0;c<a;c++)b[c]=sd;return b},useHostTransitionStatus:function(){ge();return Ma},useOptimistic:function(a){ge();return[a,se]},useFormState:function(a,b,c){ge();var d=ae++,e=Vd;if("function"===typeof a.$$FORM_ACTION){var f=null,g=Wd;e=e.formState;var h=a.$$IS_SIGNATURE_EQUAL;if(null!==e&&"function"===typeof h){var k=e[1];h.call(a,e[2],e[3])&&(f=void 0!==c?"p"+c:"k"+ja(JSON.stringify([g,
-null,d]),0),k===f&&(be=d,b=e[0]))}var l=a.bind(null,b);a=function(r){l(r)};"function"===typeof l.$$FORM_ACTION&&(a.$$FORM_ACTION=function(r){r=l.$$FORM_ACTION(r);void 0!==c&&(c+="",r.action=c);var m=r.data;m&&(null===f&&(f=void 0!==c?"p"+c:"k"+ja(JSON.stringify([g,null,d]),0)),m.append("$ACTION_KEY",f));return r});return[b,a]}var n=a.bind(null,b);return[b,function(r){n(r)}]}},xe=null,ze={getCacheSignal:function(){throw Error(p(248));},getCacheForType:function(){throw Error(p(248));}},Ae=La.ReactCurrentDispatcher,
-Be=La.ReactCurrentCache;function Ce(a){console.error(a);return null}function De(){}
-function Ee(a,b,c,d,e,f,g,h,k,l,n,r){Na.current=lb;var m=[],C=new Set;b={destination:null,flushScheduled:!1,resumableState:b,renderState:c,rootFormatContext:d,progressiveChunkSize:void 0===e?12800:e,status:0,fatalError:null,nextSegmentId:0,allPendingTasks:0,pendingRootTasks:0,completedRootSegment:null,abortableTasks:C,pingedTasks:m,clientRenderedBoundaries:[],completedBoundaries:[],partialBoundaries:[],trackedPostpones:null,onError:void 0===f?Ce:f,onPostpone:void 0===n?De:n,onAllReady:void 0===g?
-De:g,onShellReady:void 0===h?De:h,onShellError:void 0===k?De:k,onFatalError:void 0===l?De:l,formState:void 0===r?null:r};c=Fe(b,0,null,d,!1,!1);c.parentFlushed=!0;a=Ge(b,null,a,-1,null,c,C,null,d,wd,null,Hd);m.push(a);return b}var P=null;function He(a,b){a.pingedTasks.push(b);1===a.pingedTasks.length&&(a.flushScheduled=null!==a.destination,Ie(a))}
-function Je(a,b){return{status:0,rootSegmentID:-1,parentFlushed:!1,pendingTasks:0,completedSegments:[],byteSize:0,fallbackAbortableTasks:b,errorDigest:null,resources:{styles:new Set,stylesheets:new Set},trackedContentKeyPath:null,trackedFallbackNode:null}}
-function Ge(a,b,c,d,e,f,g,h,k,l,n,r){a.allPendingTasks++;null===e?a.pendingRootTasks++:e.pendingTasks++;var m={replay:null,node:c,childIndex:d,ping:function(){return He(a,m)},blockedBoundary:e,blockedSegment:f,abortSet:g,keyPath:h,formatContext:k,legacyContext:l,context:n,treeContext:r,thenableState:b};g.add(m);return m}
-function Ke(a,b,c,d,e,f,g,h,k,l,n,r){a.allPendingTasks++;null===f?a.pendingRootTasks++:f.pendingTasks++;c.pendingTasks++;var m={replay:c,node:d,childIndex:e,ping:function(){return He(a,m)},blockedBoundary:f,blockedSegment:null,abortSet:g,keyPath:h,formatContext:k,legacyContext:l,context:n,treeContext:r,thenableState:b};g.add(m);return m}function Fe(a,b,c,d,e,f){return{status:0,id:-1,index:b,parentFlushed:!1,chunks:[],children:[],parentFormatContext:d,boundary:c,lastPushedText:e,textEmbedded:f}}
-function X(a,b){a=a.onError(b);if(null!=a&&"string"!==typeof a)throw Error('onError returned something with a type other than "string". onError should return a string and may return null or undefined but must not return anything else. It received something of type "'+typeof a+'" instead');return a}function Le(a,b){var c=a.onShellError;c(b);c=a.onFatalError;c(b);null!==a.destination?(a.status=2,a.destination.destroy(b)):(a.status=1,a.fatalError=b)}
-function Me(a,b,c,d,e){var f=d.render(),g=e.childContextTypes;if(null!==g&&void 0!==g){c=b.legacyContext;if("function"!==typeof d.getChildContext)e=c;else{d=d.getChildContext();for(var h in d)if(!(h in g))throw Error(p(108,vd(e)||"Unknown",h));e=t({},c,d)}b.legacyContext=e;Y(a,b,null,f,-1);b.legacyContext=c}else e=b.keyPath,b.keyPath=c,Y(a,b,null,f,-1),b.keyPath=e}
-function Ne(a,b,c,d,e,f,g){var h=!1;if(0!==f&&null!==a.formState){var k=b.blockedSegment;if(null!==k){h=!0;k=k.chunks;for(var l=0;l<f;l++)l===g?k.push("\x3c!--F!--\x3e"):k.push("\x3c!--F--\x3e")}}f=b.keyPath;b.keyPath=c;e?(c=b.treeContext,b.treeContext=Id(c,1,0),Z(a,b,d,-1),b.treeContext=c):h?Z(a,b,d,-1):Y(a,b,null,d,-1);b.keyPath=f}function Oe(a,b){if(a&&a.defaultProps){b=t({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}
-function Pe(a,b,c,d,e,f,g){if("function"===typeof e)if(e.prototype&&e.prototype.isReactComponent){d=xd(e,b.legacyContext);var h=e.contextType;h=new e(f,"object"===typeof h&&null!==h?h._currentValue2:d);Gd(h,e,f,d);Me(a,b,c,h,e)}else{h=xd(e,b.legacyContext);S={};Ud=b;Vd=a;Wd=c;ae=$d=0;be=-1;ce=0;de=d;d=e(f,h);d=je(e,f,d,h);g=0!==$d;var k=ae,l=be;"object"===typeof d&&null!==d&&"function"===typeof d.render&&void 0===d.$$typeof?(Gd(d,e,f,h),Me(a,b,c,d,e)):Ne(a,b,c,d,g,k,l)}else if("string"===typeof e)if(d=
-b.blockedSegment,null===d)d=f.children,h=b.formatContext,g=b.keyPath,b.formatContext=nb(h,e,f),b.keyPath=c,Z(a,b,d,-1),b.formatContext=h,b.keyPath=g;else{g=Qb(d.chunks,e,f,a.resumableState,a.renderState,b.formatContext,d.lastPushedText);d.lastPushedText=!1;h=b.formatContext;k=b.keyPath;b.formatContext=nb(h,e,f);b.keyPath=c;Z(a,b,g,-1);b.formatContext=h;b.keyPath=k;a:{b=d.chunks;a=a.resumableState;switch(e){case "title":case "style":case "script":case "area":case "base":case "br":case "col":case "embed":case "hr":case "img":case "input":case "keygen":case "link":case "meta":case "param":case "source":case "track":case "wbr":break a;
-case "body":if(1>=h.insertionMode){a.hasBody=!0;break a}break;case "html":if(0===h.insertionMode){a.hasHtml=!0;break a}}b.push(Lb(e))}d.lastPushedText=!1}else{switch(e){case pd:case nd:case Ic:case Jc:case Hc:e=b.keyPath;b.keyPath=c;Y(a,b,null,f.children,-1);b.keyPath=e;return;case od:"hidden"!==f.mode&&(e=b.keyPath,b.keyPath=c,Y(a,b,null,f.children,-1),b.keyPath=e);return;case Pc:e=b.keyPath;b.keyPath=c;Y(a,b,null,f.children,-1);b.keyPath=e;return;case md:throw Error(p(343));case Oc:a:if(null!==
-b.replay){e=b.keyPath;b.keyPath=c;c=f.children;try{Z(a,b,c,-1)}finally{b.keyPath=e}}else{l=b.keyPath;e=b.blockedBoundary;var n=b.blockedSegment;d=f.fallback;var r=f.children;f=new Set;g=Je(a,f);null!==a.trackedPostpones&&(g.trackedContentKeyPath=c);k=Fe(a,n.chunks.length,g,b.formatContext,!1,!1);n.children.push(k);n.lastPushedText=!1;var m=Fe(a,0,null,b.formatContext,!1,!1);m.parentFlushed=!0;b.blockedBoundary=g;b.blockedSegment=m;a.renderState.boundaryResources=g.resources;b.keyPath=c;try{if(Z(a,
-b,r,-1),a.renderState.generateStaticMarkup||m.lastPushedText&&m.textEmbedded&&m.chunks.push("\x3c!-- --\x3e"),m.status=1,Qe(g,m),0===g.pendingTasks&&0===g.status){g.status=1;break a}}catch(C){m.status=4,g.status=4,"object"===typeof C&&null!==C&&C.$$typeof===td?(a.onPostpone(C.message),h="POSTPONE"):h=X(a,C),g.errorDigest=h}finally{a.renderState.boundaryResources=e?e.resources:null,b.blockedBoundary=e,b.blockedSegment=n,b.keyPath=l}h=[c[0],"Suspense Fallback",c[2]];l=a.trackedPostpones;null!==l&&(n=
-[h[1],h[2],[],null],l.workingMap.set(h,n),5===g.status?l.workingMap.get(c)[4]=n:g.trackedFallbackNode=n);b=Ge(a,null,d,-1,e,k,f,h,b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}return}if("object"===typeof e&&null!==e)switch(e.$$typeof){case Nc:e=e.render;S={};Ud=b;Vd=a;Wd=c;ae=$d=0;be=-1;ce=0;de=d;d=e(f,g);f=je(e,f,d,g);Ne(a,b,c,f,0!==$d,ae,be);return;case kd:e=e.type;f=Oe(e,f);Pe(a,b,c,d,e,f,g);return;case Kc:h=f.children;d=b.keyPath;e=e._context;f=f.value;g=e._currentValue2;
-e._currentValue2=f;k=yd;yd=f={parent:k,depth:null===k?0:k.depth+1,context:e,parentValue:g,value:f};b.context=f;b.keyPath=c;Y(a,b,null,h,-1);a=yd;if(null===a)throw Error(p(403));c=a.parentValue;a.context._currentValue2=c===rd?a.context._defaultValue:c;a=yd=a.parent;b.context=a;b.keyPath=d;return;case Lc:f=f.children;f=f(e._currentValue2);e=b.keyPath;b.keyPath=c;Y(a,b,null,f,-1);b.keyPath=e;return;case ld:h=e._init;e=h(e._payload);f=Oe(e,f);Pe(a,b,c,d,e,f,void 0);return}throw Error(p(130,null==e?e:
-typeof e,""));}}function Re(a,b,c,d,e){var f=b.replay,g=b.blockedBoundary,h=Fe(a,0,null,b.formatContext,!1,!1);h.id=c;h.parentFlushed=!0;try{b.replay=null,b.blockedSegment=h,Z(a,b,d,e),h.status=1,null===g?a.completedRootSegment=h:(Qe(g,h),g.parentFlushed&&a.partialBoundaries.push(g))}finally{b.replay=f,b.blockedSegment=null}}
-function Y(a,b,c,d,e){if(null!==b.replay&&"number"===typeof b.replay.slots)Re(a,b,b.replay.slots,d,e);else{b.node=d;b.childIndex=e;if("object"===typeof d&&null!==d){switch(d.$$typeof){case Fc:var f=d.type,g=d.key,h=d.props,k=d.ref,l=vd(f),n=null==g?-1===e?0:e:g;g=[b.keyPath,l,n];if(null!==b.replay)a:{var r=b.replay;e=r.nodes;for(d=0;d<e.length;d++){var m=e[d];if(n===m[1]){if(4===m.length){if(null!==l&&l!==m[0])throw Error(p(490,m[0],l));l=m[2];m=m[3];n=b.node;b.replay={nodes:l,slots:m,pendingTasks:1};
-try{Pe(a,b,g,c,f,h,k);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error(p(488));b.replay.pendingTasks--}catch(q){if("object"===typeof q&&null!==q&&(q===Nd||"function"===typeof q.then))throw b.node===n&&(b.replay=r),q;b.replay.pendingTasks--;Se(a,b.blockedBoundary,q,l,m)}b.replay=r}else{if(f!==Oc)throw Error(p(490,"Suspense",vd(f)||"Unknown"));b:{c=void 0;f=m[5];k=m[2];r=m[3];l=null===m[4]?[]:m[4][2];m=null===m[4]?null:m[4][3];n=b.keyPath;var C=b.replay,D=b.blockedBoundary,Q=h.children;
-h=h.fallback;var v=new Set,A=Je(a,v);A.parentFlushed=!0;A.rootSegmentID=f;b.blockedBoundary=A;b.replay={nodes:k,slots:r,pendingTasks:1};a.renderState.boundaryResources=A.resources;try{Z(a,b,Q,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error(p(488));b.replay.pendingTasks--;if(0===A.pendingTasks&&0===A.status){A.status=1;a.completedBoundaries.push(A);break b}}catch(q){A.status=4,"object"===typeof q&&null!==q&&q.$$typeof===td?(a.onPostpone(q.message),c="POSTPONE"):c=X(a,q),A.errorDigest=
-c,b.replay.pendingTasks--,a.clientRenderedBoundaries.push(A)}finally{a.renderState.boundaryResources=D?D.resources:null,b.blockedBoundary=D,b.replay=C,b.keyPath=n}h=Ke(a,null,{nodes:l,slots:m,pendingTasks:0},h,-1,D,v,[g[0],"Suspense Fallback",g[2]],b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(h)}}e.splice(d,1);break a}}}else Pe(a,b,g,c,f,h,k);return;case Gc:throw Error(p(257));case ld:h=d._init;d=h(d._payload);Y(a,b,null,d,e);return}if(Ka(d)){Te(a,b,d,e);return}null===
-d||"object"!==typeof d?h=null:(h=ud&&d[ud]||d["@@iterator"],h="function"===typeof h?h:null);if(h&&(h=h.call(d))){d=h.next();if(!d.done){g=[];do g.push(d.value),d=h.next();while(!d.done);Te(a,b,g,e)}return}if("function"===typeof d.then)return Y(a,b,null,te(d),e);if(d.$$typeof===Lc||d.$$typeof===Mc)return Y(a,b,null,d._currentValue2,e);e=Object.prototype.toString.call(d);throw Error(p(31,"[object Object]"===e?"object with keys {"+Object.keys(d).join(", ")+"}":e));}"string"===typeof d?(e=b.blockedSegment,
-null!==e&&(e.lastPushedText=Ec(e.chunks,d,a.renderState,e.lastPushedText))):"number"===typeof d&&(e=b.blockedSegment,null!==e&&(e.lastPushedText=Ec(e.chunks,""+d,a.renderState,e.lastPushedText)))}}
-function Te(a,b,c,d){var e=b.keyPath;if(-1!==d&&(b.keyPath=[b.keyPath,"Fragment",d],null!==b.replay)){for(var f=b.replay,g=f.nodes,h=0;h<g.length;h++){var k=g[h];if(k[1]===d){d=k[2];k=k[3];b.replay={nodes:d,slots:k,pendingTasks:1};try{Te(a,b,c,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error(p(488));b.replay.pendingTasks--}catch(n){if("object"===typeof n&&null!==n&&(n===Nd||"function"===typeof n.then))throw n;b.replay.pendingTasks--;Se(a,b.blockedBoundary,n,d,k)}b.replay=f;g.splice(h,
-1);break}}b.keyPath=e;return}f=b.treeContext;g=c.length;if(null!==b.replay&&(h=b.replay.slots,null!==h&&"object"===typeof h)){for(k=0;k<g;k++){d=c[k];b.treeContext=Id(f,g,k);var l=h[k];"number"===typeof l?(Re(a,b,l,d,k),delete h[k]):Z(a,b,d,k)}b.treeContext=f;b.keyPath=e;return}for(h=0;h<g;h++)k=c[h],b.treeContext=Id(f,g,h),Z(a,b,k,h);b.treeContext=f;b.keyPath=e}
-function Ue(a,b,c,d){d.status=5;var e=c.keyPath,f=c.blockedBoundary;if(null===f)d.id=a.nextSegmentId++,b.rootSlots=d.id,null!==a.completedRootSegment&&(a.completedRootSegment.status=5);else{if(null!==f&&0===f.status){f.status=5;f.rootSegmentID=a.nextSegmentId++;var g=f.trackedContentKeyPath;if(null===g)throw Error(p(486));var h=f.trackedFallbackNode,k=[];if(g===e&&-1===c.childIndex){d.id=f.rootSegmentID;d=[g[1],g[2],k,f.rootSegmentID,h,f.rootSegmentID];b.workingMap.set(g,d);Ve(d,g[0],b);return}var l=
-b.workingMap.get(g);void 0===l?(l=[g[1],g[2],k,null,h,f.rootSegmentID],b.workingMap.set(g,l),Ve(l,g[0],b)):(g=l,g[4]=h,g[5]=f.rootSegmentID)}-1===d.id&&(d.id=d.parentFlushed&&null!==f?f.rootSegmentID:a.nextSegmentId++);if(-1===c.childIndex)null===e?b.rootSlots=d.id:(c=b.workingMap.get(e),void 0===c?(c=[e[1],e[2],[],d.id],Ve(c,e[0],b)):c[3]=d.id);else{if(null===e)if(a=b.rootSlots,null===a)a=b.rootSlots={};else{if("number"===typeof a)throw Error(p(491));}else if(f=b.workingMap,g=f.get(e),void 0===g)a=
-{},g=[e[1],e[2],[],a],f.set(e,g),Ve(g,e[0],b);else if(a=g[3],null===a)a=g[3]={};else if("number"===typeof a)throw Error(p(491));a[c.childIndex]=d.id}}}
-function Z(a,b,c,d){var e=b.formatContext,f=b.legacyContext,g=b.context,h=b.keyPath,k=b.treeContext,l=b.blockedSegment;if(null===l)try{return Y(a,b,null,c,d)}catch(m){if(ke(),d=m===Nd?Rd():m,"object"===typeof d&&null!==d&&"function"===typeof d.then){c=d;d=le();a=Ke(a,d,b.replay,b.node,b.childIndex,b.blockedBoundary,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Ed(g);return}}else{var n=
-l.children.length,r=l.chunks.length;try{return Y(a,b,null,c,d)}catch(m){if(ke(),l.children.length=n,l.chunks.length=r,d=m===Nd?Rd():m,"object"===typeof d&&null!==d){if("function"===typeof d.then){c=d;d=le();l=b.blockedSegment;n=Fe(a,l.chunks.length,null,b.formatContext,l.lastPushedText,!0);l.children.push(n);l.lastPushedText=!1;a=Ge(a,d,b.node,b.childIndex,b.blockedBoundary,n,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=
-f;b.context=g;b.keyPath=h;b.treeContext=k;Ed(g);return}if(null!==a.trackedPostpones&&d.$$typeof===td&&null!==b.blockedBoundary){c=a.trackedPostpones;a.onPostpone(d.message);d=b.blockedSegment;l=Fe(a,d.chunks.length,null,b.formatContext,d.lastPushedText,!0);d.children.push(l);d.lastPushedText=!1;Ue(a,c,b,l);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Ed(g);return}}}}b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Ed(g);throw d;}
-function Se(a,b,c,d,e){if("object"===typeof c&&null!==c&&c.$$typeof===td){a.onPostpone(c.message);var f="POSTPONE"}else f=X(a,c);We(a,b,d,e,c,f)}function Xe(a){var b=a.blockedBoundary;a=a.blockedSegment;null!==a&&(a.status=3,Ye(this,b,a))}
-function We(a,b,c,d,e,f){for(var g=0;g<c.length;g++){var h=c[g];if(4===h.length)We(a,b,h[2],h[3],e,f);else{h=h[5];var k=a,l=f,n=Je(k,new Set);n.parentFlushed=!0;n.rootSegmentID=h;n.status=4;n.errorDigest=l;n.parentFlushed&&k.clientRenderedBoundaries.push(n)}}c.length=0;if(null!==d){if(null===b)throw Error(p(487));4!==b.status&&(b.status=4,b.errorDigest=f,b.parentFlushed&&a.clientRenderedBoundaries.push(b));if("object"===typeof d)for(var r in d)delete d[r]}}
-function Ze(a,b,c){var d=a.blockedBoundary,e=a.blockedSegment;null!==e&&(e.status=3);if(null===d){if(1!==b.status&&2!==b.status){a=a.replay;if(null===a){X(b,c);Le(b,c);return}a.pendingTasks--;0===a.pendingTasks&&0<a.nodes.length&&(d=X(b,c),We(b,null,a.nodes,a.slots,c,d));b.pendingRootTasks--;0===b.pendingRootTasks&&$e(b)}}else d.pendingTasks--,4!==d.status&&(d.status=4,d.errorDigest=X(b,c),d.parentFlushed&&b.clientRenderedBoundaries.push(d)),d.fallbackAbortableTasks.forEach(function(f){return Ze(f,
-b,c)}),d.fallbackAbortableTasks.clear();b.allPendingTasks--;0===b.allPendingTasks&&af(b)}function $e(a){null===a.trackedPostpones&&Cc(a.renderState,a.resumableState,!0);a.onShellError=De;a=a.onShellReady;a()}function af(a){Cc(a.renderState,a.resumableState,null===a.trackedPostpones?!0:null===a.completedRootSegment||5!==a.completedRootSegment.status);a=a.onAllReady;a()}
-function Qe(a,b){if(0===b.chunks.length&&1===b.children.length&&null===b.children[0].boundary){var c=b.children[0];c.id=b.id;c.parentFlushed=!0;1===c.status&&Qe(a,c)}else a.completedSegments.push(b)}
-function Ye(a,b,c){if(null===b){if(null!==c&&c.parentFlushed){if(null!==a.completedRootSegment)throw Error(p(389));a.completedRootSegment=c}a.pendingRootTasks--;0===a.pendingRootTasks&&$e(a)}else b.pendingTasks--,4!==b.status&&(0===b.pendingTasks?(0===b.status&&(b.status=1),null!==c&&c.parentFlushed&&1===c.status&&Qe(b,c),b.parentFlushed&&a.completedBoundaries.push(b),1===b.status&&(b.fallbackAbortableTasks.forEach(Xe,a),b.fallbackAbortableTasks.clear())):null!==c&&c.parentFlushed&&1===c.status&&
-(Qe(b,c),1===b.completedSegments.length&&b.parentFlushed&&a.partialBoundaries.push(b)));a.allPendingTasks--;0===a.allPendingTasks&&af(a)}
-function Ie(a){if(2!==a.status){var b=yd,c=Ae.current;Ae.current=ye;var d=Be.current;Be.current=ze;var e=P;P=a;var f=xe;xe=a.resumableState;try{var g=a.pingedTasks,h;for(h=0;h<g.length;h++){var k=g[h],l=a,n=k.blockedBoundary;l.renderState.boundaryResources=n?n.resources:null;var r=k.blockedSegment;if(null===r){var m=l;if(0!==k.replay.pendingTasks){Ed(k.context);try{var C=k.thenableState;k.thenableState=null;Y(m,k,C,k.node,k.childIndex);if(1===k.replay.pendingTasks&&0<k.replay.nodes.length)throw Error(p(488));
-k.replay.pendingTasks--;k.abortSet.delete(k);Ye(m,k.blockedBoundary,null)}catch(w){ke();var D=w===Nd?Rd():w;if("object"===typeof D&&null!==D&&"function"===typeof D.then){var Q=k.ping;D.then(Q,Q);k.thenableState=le()}else k.replay.pendingTasks--,k.abortSet.delete(k),Se(m,k.blockedBoundary,D,k.replay.nodes,k.replay.slots),m.pendingRootTasks--,0===m.pendingRootTasks&&$e(m),m.allPendingTasks--,0===m.allPendingTasks&&af(m)}finally{m.renderState.boundaryResources=null}}}else a:{m=void 0;var v=r;if(0===
-v.status){Ed(k.context);var A=v.children.length,q=v.chunks.length;try{var aa=k.thenableState;k.thenableState=null;Y(l,k,aa,k.node,k.childIndex);l.renderState.generateStaticMarkup||v.lastPushedText&&v.textEmbedded&&v.chunks.push("\x3c!-- --\x3e");k.abortSet.delete(k);v.status=1;Ye(l,k.blockedBoundary,v)}catch(w){ke();v.children.length=A;v.chunks.length=q;var u=w===Nd?Rd():w;if("object"===typeof u&&null!==u){if("function"===typeof u.then){var U=k.ping;u.then(U,U);k.thenableState=le();break a}if(null!==
-l.trackedPostpones&&u.$$typeof===td){var E=l.trackedPostpones;k.abortSet.delete(k);l.onPostpone(u.message);Ue(l,E,k,v);Ye(l,k.blockedBoundary,v);break a}}k.abortSet.delete(k);v.status=4;var B=k.blockedBoundary;"object"===typeof u&&null!==u&&u.$$typeof===td?(l.onPostpone(u.message),m="POSTPONE"):m=X(l,u);null===B?Le(l,u):(B.pendingTasks--,4!==B.status&&(B.status=4,B.errorDigest=m,B.parentFlushed&&l.clientRenderedBoundaries.push(B)));l.allPendingTasks--;0===l.allPendingTasks&&af(l)}finally{l.renderState.boundaryResources=
-null}}}}g.splice(0,h);null!==a.destination&&bf(a,a.destination)}catch(w){X(a,w),Le(a,w)}finally{xe=f,Ae.current=c,Be.current=d,c===ye&&Ed(b),P=e}}}
-function cf(a,b,c){c.parentFlushed=!0;switch(c.status){case 0:c.id=a.nextSegmentId++;case 5:var d=c.id;c.lastPushedText=!1;c.textEmbedded=!1;a=a.renderState;b.push('<template id="');b.push(a.placeholderPrefix);a=d.toString(16);b.push(a);return b.push('"></template>');case 1:c.status=2;var e=!0;d=c.chunks;var f=0;c=c.children;for(var g=0;g<c.length;g++){for(e=c[g];f<e.index;f++)b.push(d[f]);e=df(a,b,e)}for(;f<d.length-1;f++)b.push(d[f]);f<d.length&&(e=b.push(d[f]));return e;default:throw Error(p(390));
+function vc(a,b){a.push("[");var c="[";b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)a.push(c),d=A(JSON.stringify(""+d.props.href)),a.push(d),a.push("]"),c=",[";else{a.push(c);var e=d.props["data-precedence"],f=d.props,g=A(JSON.stringify(""+d.props.href));a.push(g);e=""+e;a.push(",");e=A(JSON.stringify(e));a.push(e);for(var h in f)if(z.call(f,h)&&(g=f[h],null!=g))switch(h){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error(q(399,"link"));
+default:a:{e=a;var k=h.toLowerCase();switch(typeof g){case "function":case "symbol":break a}switch(h){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":k="class";g=""+g;break;case "hidden":if(!1===g)break a;g="";break;case "src":case "href":g=""+g;break;default:if(2<h.length&&("o"===h[0]||"O"===h[0])&&("n"===h[1]||"N"===h[1])||!xa(h))break a;g=""+g}e.push(",");k=A(JSON.stringify(k));e.push(k);
+e.push(",");g=A(JSON.stringify(g));e.push(g)}}a.push("]");c=",[";d.state=3}});a.push("]")}
+function Na(a){var b=S?S:null;if(b){var c=b.resumableState,d=b.renderState;if("string"===typeof a&&a){if(!c.dnsResources.hasOwnProperty(a)){c.dnsResources[a]=null;c=d.headers;var e,f;if(f=c&&0<c.remainingCapacity)f=(e="<"+(""+a).replace(wc,xc)+">; rel=dns-prefetch",2<=(c.remainingCapacity-=e.length));f?(d.resets.dns[a]=null,c.preconnects&&(c.preconnects+=", "),c.preconnects+=e):(e=[],N(e,{href:a,rel:"dns-prefetch"}),d.preconnects.add(e))}yc(b)}}}
+function Oa(a,b){var c=S?S:null;if(c){var d=c.resumableState,e=c.renderState;if("string"===typeof a&&a){var f="use-credentials"===b?"credentials":"string"===typeof b?"anonymous":"default";if(!d.connectResources[f].hasOwnProperty(a)){d.connectResources[f][a]=null;d=e.headers;var g,h;if(h=d&&0<d.remainingCapacity){h="<"+(""+a).replace(wc,xc)+">; rel=preconnect";if("string"===typeof b){var k=(""+b).replace(zc,Ac);h+='; crossorigin="'+k+'"'}h=(g=h,2<=(d.remainingCapacity-=g.length))}h?(e.resets.connect[f][a]=
+null,d.preconnects&&(d.preconnects+=", "),d.preconnects+=g):(f=[],N(f,{rel:"preconnect",href:a,crossOrigin:b}),e.preconnects.add(f))}yc(c)}}}
+function Pa(a,b,c){var d=S?S:null;if(d){var e=d.resumableState,f=d.renderState;if(b&&a){switch(b){case "image":if(c){var g=c.imageSrcSet;var h=c.imageSizes;var k=c.fetchPriority}var l=g?g+"\n"+(h||""):a;if(e.imageResources.hasOwnProperty(l))return;e.imageResources[l]=B;e=f.headers;var n;e&&0<e.remainingCapacity&&"high"===k&&(n=Sb(a,b,c),2<=(e.remainingCapacity-=n.length))?(f.resets.image[l]=B,e.highImagePreloads&&(e.highImagePreloads+=", "),e.highImagePreloads+=n):(e=[],N(e,r({rel:"preload",href:g?
+void 0:a,as:b},c)),"high"===k?f.highImagePreloads.add(e):(f.bulkPreloads.add(e),f.preloads.images.set(l,e)));break;case "style":if(e.styleResources.hasOwnProperty(a))return;g=[];N(g,r({rel:"preload",href:a,as:b},c));e.styleResources[a]=!c||"string"!==typeof c.crossOrigin&&"string"!==typeof c.integrity?B:[c.crossOrigin,c.integrity];f.preloads.stylesheets.set(a,g);f.bulkPreloads.add(g);break;case "script":if(e.scriptResources.hasOwnProperty(a))return;g=[];f.preloads.scripts.set(a,g);f.bulkPreloads.add(g);
+N(g,r({rel:"preload",href:a,as:b},c));e.scriptResources[a]=!c||"string"!==typeof c.crossOrigin&&"string"!==typeof c.integrity?B:[c.crossOrigin,c.integrity];break;default:if(e.unknownResources.hasOwnProperty(b)){if(g=e.unknownResources[b],g.hasOwnProperty(a))return}else g={},e.unknownResources[b]=g;g[a]=B;if((e=f.headers)&&0<e.remainingCapacity&&"font"===b&&(l=Sb(a,b,c),2<=(e.remainingCapacity-=l.length)))f.resets.font[a]=B,e.fontPreloads&&(e.fontPreloads+=", "),e.fontPreloads+=l;else switch(e=[],
+a=r({rel:"preload",href:a,as:b},c),N(e,a),b){case "font":f.fontPreloads.add(e);break;default:f.bulkPreloads.add(e)}}yc(d)}}}
+function gb(a,b){var c=S?S:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=b&&"string"===typeof b.as?b.as:"script";switch(f){case "script":if(d.moduleScriptResources.hasOwnProperty(a))return;f=[];d.moduleScriptResources[a]=!b||"string"!==typeof b.crossOrigin&&"string"!==typeof b.integrity?B:[b.crossOrigin,b.integrity];e.preloads.moduleScripts.set(a,f);break;default:if(d.moduleUnknownResources.hasOwnProperty(f)){var g=d.unknownResources[f];if(g.hasOwnProperty(a))return}else g={},d.moduleUnknownResources[f]=
+g;f=[];g[a]=B}N(f,r({rel:"modulepreload",href:a},b));e.bulkPreloads.add(f);yc(c)}}}
+function hb(a,b,c){var d=S?S:null;if(d){var e=d.resumableState,f=d.renderState;if(a){b=b||"default";var g=f.styles.get(b),h=e.styleResources.hasOwnProperty(a)?e.styleResources[a]:void 0;null!==h&&(e.styleResources[a]=null,g||(g={precedence:A(b),rules:[],hrefs:[],sheets:new Map},f.styles.set(b,g)),b={state:0,props:r({rel:"stylesheet",href:a,"data-precedence":b},c)},h&&(2===h.length&&Jb(b.props,h),(f=f.preloads.stylesheets.get(a))&&0<f.length?f.length=0:b.state=1),g.sheets.set(a,b),yc(d))}}}
+function ib(a,b){var c=S?S:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=d.scriptResources.hasOwnProperty(a)?d.scriptResources[a]:void 0;null!==f&&(d.scriptResources[a]=null,b=r({src:a,async:!0},b),f&&(2===f.length&&Jb(b,f),a=e.preloads.scripts.get(a))&&(a.length=0),a=[],e.scripts.add(a),Nb(a,b),yc(c))}}}
+function jb(a,b){var c=S?S:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=d.moduleScriptResources.hasOwnProperty(a)?d.moduleScriptResources[a]:void 0;null!==f&&(d.moduleScriptResources[a]=null,b=r({src:a,type:"module",async:!0},b),f&&(2===f.length&&Jb(b,f),a=e.preloads.moduleScripts.get(a))&&(a.length=0),a=[],e.scripts.add(a),Nb(a,b),yc(c))}}}function Jb(a,b){null==a.crossOrigin&&(a.crossOrigin=b[0]);null==a.integrity&&(a.integrity=b[1])}
+function Sb(a,b,c){a=(""+a).replace(wc,xc);b=(""+b).replace(zc,Ac);b="<"+a+'>; rel=preload; as="'+b+'"';for(var d in c)z.call(c,d)&&(a=c[d],"string"===typeof a&&(b+="; "+d.toLowerCase()+'="'+(""+a).replace(zc,Ac)+'"'));return b}var wc=/[<>\r\n]/g;
+function xc(a){switch(a){case "<":return"%3C";case ">":return"%3E";case "\n":return"%0A";case "\r":return"%0D";default:throw Error("escapeLinkHrefForHeaderContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}}var zc=/["';,\r\n]/g;
+function Ac(a){switch(a){case '"':return"%22";case "'":return"%27";case ";":return"%3B";case ",":return"%2C";case "\n":return"%0A";case "\r":return"%0D";default:throw Error("escapeStringForLinkHeaderQuotedParamValueContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}}function Bc(a){this.styles.add(a)}function Cc(a){this.stylesheets.add(a)}
+function Dc(a,b,c){if(b=a.onHeaders){var d=a.headers;if(d){var e=d.preconnects;d.fontPreloads&&(e&&(e+=", "),e+=d.fontPreloads);d.highImagePreloads&&(e&&(e+=", "),e+=d.highImagePreloads);if(!c){c=a.styles.values();var f=c.next();a:for(;0<d.remainingCapacity&&!f.done;f=c.next()){f=f.value.sheets.values();for(var g=f.next();0<d.remainingCapacity&&!g.done;g=f.next()){var h=g.value;g=h.props;var k=g.href;h=h.props;h=Sb(h.href,"style",{crossOrigin:h.crossOrigin,integrity:h.integrity,nonce:h.nonce,type:h.type,
+fetchPriority:h.fetchPriority,referrerPolicy:h.referrerPolicy,media:h.media});if(2<=(d.remainingCapacity-=h.length))a.resets.style[k]=B,e&&(e+=", "),e+=h,a.resets.style[k]="string"===typeof g.crossOrigin||"string"===typeof g.integrity?[g.crossOrigin,g.integrity]:B;else break a}}}e?b({Link:e}):b({});a.headers=null}}}
+function Ec(a,b){var c=a.idPrefix,d=[],e=a.bootstrapScriptContent,f=a.bootstrapScripts,g=a.bootstrapModules;void 0!==e&&d.push("<script>",(""+e).replace(lb,mb),"\x3c/script>");e=c+"P:";var h=c+"S:";c+="B:";var k=new Set,l=new Set,n=new Set,t=new Map,m=new Set,C=new Set,F=new Set,Q={images:new Map,stylesheets:new Map,scripts:new Map,moduleScripts:new Map};if(void 0!==f)for(var w=0;w<f.length;w++){var u=f[w],p,H=void 0,v=void 0,x={rel:"preload",as:"script",fetchPriority:"low",nonce:void 0};"string"===
+typeof u?x.href=p=u:(x.href=p=u.src,x.integrity=v="string"===typeof u.integrity?u.integrity:void 0,x.crossOrigin=H="string"===typeof u||null==u.crossOrigin?void 0:"use-credentials"===u.crossOrigin?"use-credentials":"");u=a;var E=p;u.scriptResources[E]=null;u.moduleScriptResources[E]=null;u=[];N(u,x);m.add(u);d.push('<script src="',A(p));"string"===typeof v&&d.push('" integrity="',A(v));"string"===typeof H&&d.push('" crossorigin="',A(H));d.push('" async="">\x3c/script>')}if(void 0!==g)for(f=0;f<g.length;f++)x=
+g[f],H=p=void 0,v={rel:"modulepreload",fetchPriority:"low",nonce:void 0},"string"===typeof x?v.href=w=x:(v.href=w=x.src,v.integrity=H="string"===typeof x.integrity?x.integrity:void 0,v.crossOrigin=p="string"===typeof x||null==x.crossOrigin?void 0:"use-credentials"===x.crossOrigin?"use-credentials":""),x=a,u=w,x.scriptResources[u]=null,x.moduleScriptResources[u]=null,x=[],N(x,v),m.add(x),d.push('<script type="module" src="',A(w)),"string"===typeof H&&d.push('" integrity="',A(H)),"string"===typeof p&&
+d.push('" crossorigin="',A(p)),d.push('" async="">\x3c/script>');return{placeholderPrefix:e,segmentPrefix:h,boundaryPrefix:c,startInlineScript:"<script>",htmlChunks:null,headChunks:null,externalRuntimeScript:null,bootstrapChunks:d,onHeaders:void 0,headers:null,resets:{font:{},dns:{},connect:{default:{},anonymous:{},credentials:{}},image:{},style:{}},charsetChunks:[],preconnectChunks:[],importMapChunks:[],preloadChunks:[],hoistableChunks:[],preconnects:k,fontPreloads:l,highImagePreloads:n,styles:t,
+bootstrapScripts:m,scripts:C,bulkPreloads:F,preloads:Q,boundaryResources:null,stylesToHoist:!1,generateStaticMarkup:b}}function Fc(a,b,c,d){if(c.generateStaticMarkup)return a.push(A(b)),!1;""===b?a=d:(d&&a.push("\x3c!-- --\x3e"),a.push(A(b)),a=!0);return a}
+var Gc=Symbol.for("react.element"),Hc=Symbol.for("react.portal"),Ic=Symbol.for("react.fragment"),Jc=Symbol.for("react.strict_mode"),Kc=Symbol.for("react.profiler"),Lc=Symbol.for("react.provider"),Mc=Symbol.for("react.context"),Nc=Symbol.for("react.server_context"),Oc=Symbol.for("react.forward_ref"),Pc=Symbol.for("react.suspense"),kd=Symbol.for("react.suspense_list"),ld=Symbol.for("react.memo"),md=Symbol.for("react.lazy"),nd=Symbol.for("react.scope"),od=Symbol.for("react.debug_trace_mode"),pd=Symbol.for("react.offscreen"),
+qd=Symbol.for("react.legacy_hidden"),rd=Symbol.for("react.cache"),sd=Symbol.for("react.default_value"),td=Symbol.for("react.memo_cache_sentinel"),ud=Symbol.for("react.postpone"),vd=Symbol.iterator;
+function wd(a){if(null==a)return null;if("function"===typeof a)return a.displayName||a.name||null;if("string"===typeof a)return a;switch(a){case Ic:return"Fragment";case Hc:return"Portal";case Kc:return"Profiler";case Jc:return"StrictMode";case Pc:return"Suspense";case kd:return"SuspenseList";case rd:return"Cache"}if("object"===typeof a)switch(a.$$typeof){case Mc:return(a.displayName||"Context")+".Consumer";case Lc:return(a._context.displayName||"Context")+".Provider";case Oc:var b=a.render;a=a.displayName;
+a||(a=b.displayName||b.name||"",a=""!==a?"ForwardRef("+a+")":"ForwardRef");return a;case ld:return b=a.displayName||null,null!==b?b:wd(a.type)||"Memo";case md:b=a._payload;a=a._init;try{return wd(a(b))}catch(c){break}case Nc:return(a.displayName||a._globalName)+".Provider"}return null}var xd={};function yd(a,b){a=a.contextTypes;if(!a)return xd;var c={},d;for(d in a)c[d]=b[d];return c}var zd=null;
+function Ad(a,b){if(a!==b){a.context._currentValue2=a.parentValue;a=a.parent;var c=b.parent;if(null===a){if(null!==c)throw Error(q(401));}else{if(null===c)throw Error(q(401));Ad(a,c)}b.context._currentValue2=b.value}}function Bd(a){a.context._currentValue2=a.parentValue;a=a.parent;null!==a&&Bd(a)}function Cd(a){var b=a.parent;null!==b&&Cd(b);a.context._currentValue2=a.value}
+function Dd(a,b){a.context._currentValue2=a.parentValue;a=a.parent;if(null===a)throw Error(q(402));a.depth===b.depth?Ad(a,b):Dd(a,b)}function Ed(a,b){var c=b.parent;if(null===c)throw Error(q(402));a.depth===c.depth?Ad(a,c):Ed(a,c);b.context._currentValue2=b.value}function Fd(a){var b=zd;b!==a&&(null===b?Cd(a):null===a?Bd(b):b.depth===a.depth?Ad(b,a):b.depth>a.depth?Dd(b,a):Ed(b,a),zd=a)}
+var Gd={isMounted:function(){return!1},enqueueSetState:function(a,b){a=a._reactInternals;null!==a.queue&&a.queue.push(b)},enqueueReplaceState:function(a,b){a=a._reactInternals;a.replace=!0;a.queue=[b]},enqueueForceUpdate:function(){}};
+function Hd(a,b,c,d){var e=void 0!==a.state?a.state:null;a.updater=Gd;a.props=c;a.state=e;var f={queue:[],replace:!1};a._reactInternals=f;var g=b.contextType;a.context="object"===typeof g&&null!==g?g._currentValue2:d;g=b.getDerivedStateFromProps;"function"===typeof g&&(g=g(c,e),e=null===g||void 0===g?e:r({},e,g),a.state=e);if("function"!==typeof b.getDerivedStateFromProps&&"function"!==typeof a.getSnapshotBeforeUpdate&&("function"===typeof a.UNSAFE_componentWillMount||"function"===typeof a.componentWillMount))if(b=
+a.state,"function"===typeof a.componentWillMount&&a.componentWillMount(),"function"===typeof a.UNSAFE_componentWillMount&&a.UNSAFE_componentWillMount(),b!==a.state&&Gd.enqueueReplaceState(a,a.state,null),null!==f.queue&&0<f.queue.length)if(b=f.queue,g=f.replace,f.queue=null,f.replace=!1,g&&1===b.length)a.state=b[0];else{f=g?b[0]:a.state;e=!0;for(g=g?1:0;g<b.length;g++){var h=b[g];h="function"===typeof h?h.call(a,f,c,d):h;null!=h&&(e?(e=!1,f=r({},f,h)):r(f,h))}a.state=f}else f.queue=null}
+var Id={id:1,overflow:""};function Jd(a,b,c){var d=a.id;a=a.overflow;var e=32-Kd(d)-1;d&=~(1<<e);c+=1;var f=32-Kd(b)+e;if(30<f){var g=e-e%5;f=(d&(1<<g)-1).toString(32);d>>=g;e-=g;return{id:1<<32-Kd(b)+e|c<<e|d,overflow:f+a}}return{id:1<<f|c<<e|d,overflow:a}}var Kd=Math.clz32?Math.clz32:Ld,Md=Math.log,Nd=Math.LN2;function Ld(a){a>>>=0;return 0===a?32:31-(Md(a)/Nd|0)|0}var Od=Error(q(460));function Pd(){}
+function Qd(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(Pd,Pd),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;default:if("string"!==typeof b.status)switch(a=b,a.status="pending",a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}}),b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;}Rd=b;throw Od;}}var Rd=null;
+function Sd(){if(null===Rd)throw Error(q(459));var a=Rd;Rd=null;return a}function Td(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var Ud="function"===typeof Object.is?Object.is:Td,U=null,Vd=null,Wd=null,Xd=null,Yd=null,V=null,Zd=!1,$d=!1,ae=0,be=0,ce=-1,de=0,ee=null,fe=null,ge=0;function he(){if(null===U)throw Error(q(321));return U}function ie(){if(0<ge)throw Error(q(312));return{memoizedState:null,queue:null,next:null}}
+function je(){null===V?null===Yd?(Zd=!1,Yd=V=ie()):(Zd=!0,V=Yd):null===V.next?(Zd=!1,V=V.next=ie()):(Zd=!0,V=V.next);return V}function ke(a,b,c,d){for(;$d;)$d=!1,be=ae=0,ce=-1,de=0,ge+=1,V=null,c=a(b,d);le();return c}function me(){var a=ee;ee=null;return a}function le(){Xd=Wd=Vd=U=null;$d=!1;Yd=null;ge=0;V=fe=null}function ne(a,b){return"function"===typeof b?b(a):b}
+function oe(a,b,c){U=he();V=je();if(Zd){var d=V.queue;b=d.dispatch;if(null!==fe&&(c=fe.get(d),void 0!==c)){fe.delete(d);d=V.memoizedState;do d=a(d,c.action),c=c.next;while(null!==c);V.memoizedState=d;return[d,b]}return[V.memoizedState,b]}a=a===ne?"function"===typeof b?b():b:void 0!==c?c(b):b;V.memoizedState=a;a=V.queue={last:null,dispatch:null};a=a.dispatch=pe.bind(null,U,a);return[V.memoizedState,a]}
+function qe(a,b){U=he();V=je();b=void 0===b?null:b;if(null!==V){var c=V.memoizedState;if(null!==c&&null!==b){var d=c[1];a:if(null===d)d=!1;else{for(var e=0;e<d.length&&e<b.length;e++)if(!Ud(b[e],d[e])){d=!1;break a}d=!0}if(d)return c[0]}}a=a();V.memoizedState=[a,b];return a}function pe(a,b,c){if(25<=ge)throw Error(q(301));if(a===U)if($d=!0,a={action:c,next:null},null===fe&&(fe=new Map),c=fe.get(b),void 0===c)fe.set(b,a);else{for(b=c;null!==b.next;)b=b.next;b.next=a}}
+function re(){throw Error(q(440));}function se(){throw Error(q(394));}function te(){throw Error(q(479));}function ue(a){var b=de;de+=1;null===ee&&(ee=[]);return Qd(ee,a,b)}function ve(){throw Error(q(393));}function we(){}
+var ze={readContext:function(a){return a._currentValue2},use:function(a){if(null!==a&&"object"===typeof a){if("function"===typeof a.then)return ue(a);if(a.$$typeof===Mc||a.$$typeof===Nc)return a._currentValue2}throw Error(q(438,String(a)));},useContext:function(a){he();return a._currentValue2},useMemo:qe,useReducer:oe,useRef:function(a){U=he();V=je();var b=V.memoizedState;return null===b?(a={current:a},V.memoizedState=a):b},useState:function(a){return oe(ne,a)},useInsertionEffect:we,useLayoutEffect:we,
+useCallback:function(a,b){return qe(function(){return a},b)},useImperativeHandle:we,useEffect:we,useDebugValue:we,useDeferredValue:function(a,b){he();return void 0!==b?b:a},useTransition:function(){he();return[!1,se]},useId:function(){var a=Vd.treeContext;var b=a.overflow;a=a.id;a=(a&~(1<<32-Kd(a)-1)).toString(32)+b;var c=ye;if(null===c)throw Error(q(404));b=ae++;a=":"+c.idPrefix+"R"+a;0<b&&(a+="H"+b.toString(32));return a+":"},useSyncExternalStore:function(a,b,c){if(void 0===c)throw Error(q(407));
+return c()},useCacheRefresh:function(){return ve},useEffectEvent:function(){return re},useMemoCache:function(a){for(var b=Array(a),c=0;c<a;c++)b[c]=td;return b},useHostTransitionStatus:function(){he();return La},useOptimistic:function(a){he();return[a,te]},useFormState:function(a,b,c){he();var d=be++,e=Wd;if("function"===typeof a.$$FORM_ACTION){var f=null,g=Xd;e=e.formState;var h=a.$$IS_SIGNATURE_EQUAL;if(null!==e&&"function"===typeof h){var k=e[1];h.call(a,e[2],e[3])&&(f=void 0!==c?"p"+c:"k"+ia(JSON.stringify([g,
+null,d]),0),k===f&&(ce=d,b=e[0]))}var l=a.bind(null,b);a=function(t){l(t)};"function"===typeof l.$$FORM_ACTION&&(a.$$FORM_ACTION=function(t){t=l.$$FORM_ACTION(t);void 0!==c&&(c+="",t.action=c);var m=t.data;m&&(null===f&&(f=void 0!==c?"p"+c:"k"+ia(JSON.stringify([g,null,d]),0)),m.append("$ACTION_KEY",f));return t});return[b,a]}var n=a.bind(null,b);return[b,function(t){n(t)}]}},ye=null,Ae={getCacheSignal:function(){throw Error(q(248));},getCacheForType:function(){throw Error(q(248));}},Be=Ka.ReactCurrentDispatcher,
+Ce=Ka.ReactCurrentCache;function De(a){console.error(a);return null}function Ee(){}
+function Fe(a,b,c,d,e,f,g,h,k,l,n,t){Ma.current=kb;var m=[],C=new Set;b={destination:null,flushScheduled:!1,resumableState:b,renderState:c,rootFormatContext:d,progressiveChunkSize:void 0===e?12800:e,status:0,fatalError:null,nextSegmentId:0,allPendingTasks:0,pendingRootTasks:0,completedRootSegment:null,abortableTasks:C,pingedTasks:m,clientRenderedBoundaries:[],completedBoundaries:[],partialBoundaries:[],trackedPostpones:null,onError:void 0===f?De:f,onPostpone:void 0===n?Ee:n,onAllReady:void 0===g?
+Ee:g,onShellReady:void 0===h?Ee:h,onShellError:void 0===k?Ee:k,onFatalError:void 0===l?Ee:l,formState:void 0===t?null:t};c=Ge(b,0,null,d,!1,!1);c.parentFlushed=!0;a=He(b,null,a,-1,null,c,C,null,d,xd,null,Id);m.push(a);return b}var S=null;function Ie(a,b){a.pingedTasks.push(b);1===a.pingedTasks.length&&(a.flushScheduled=null!==a.destination,Je(a))}
+function Ke(a,b){return{status:0,rootSegmentID:-1,parentFlushed:!1,pendingTasks:0,completedSegments:[],byteSize:0,fallbackAbortableTasks:b,errorDigest:null,resources:{styles:new Set,stylesheets:new Set},trackedContentKeyPath:null,trackedFallbackNode:null}}
+function He(a,b,c,d,e,f,g,h,k,l,n,t){a.allPendingTasks++;null===e?a.pendingRootTasks++:e.pendingTasks++;var m={replay:null,node:c,childIndex:d,ping:function(){return Ie(a,m)},blockedBoundary:e,blockedSegment:f,abortSet:g,keyPath:h,formatContext:k,legacyContext:l,context:n,treeContext:t,thenableState:b};g.add(m);return m}
+function Le(a,b,c,d,e,f,g,h,k,l,n,t){a.allPendingTasks++;null===f?a.pendingRootTasks++:f.pendingTasks++;c.pendingTasks++;var m={replay:c,node:d,childIndex:e,ping:function(){return Ie(a,m)},blockedBoundary:f,blockedSegment:null,abortSet:g,keyPath:h,formatContext:k,legacyContext:l,context:n,treeContext:t,thenableState:b};g.add(m);return m}function Ge(a,b,c,d,e,f){return{status:0,id:-1,index:b,parentFlushed:!1,chunks:[],children:[],parentFormatContext:d,boundary:c,lastPushedText:e,textEmbedded:f}}
+function Y(a,b){a=a.onError(b);if(null!=a&&"string"!==typeof a)throw Error('onError returned something with a type other than "string". onError should return a string and may return null or undefined but must not return anything else. It received something of type "'+typeof a+'" instead');return a}function Me(a,b){var c=a.onShellError;c(b);c=a.onFatalError;c(b);null!==a.destination?(a.status=2,a.destination.destroy(b)):(a.status=1,a.fatalError=b)}
+function Ne(a,b,c,d,e){var f=d.render(),g=e.childContextTypes;if(null!==g&&void 0!==g){c=b.legacyContext;if("function"!==typeof d.getChildContext)e=c;else{d=d.getChildContext();for(var h in d)if(!(h in g))throw Error(q(108,wd(e)||"Unknown",h));e=r({},c,d)}b.legacyContext=e;Z(a,b,null,f,-1);b.legacyContext=c}else e=b.keyPath,b.keyPath=c,Z(a,b,null,f,-1),b.keyPath=e}
+function Oe(a,b,c,d,e,f,g){var h=!1;if(0!==f&&null!==a.formState){var k=b.blockedSegment;if(null!==k){h=!0;k=k.chunks;for(var l=0;l<f;l++)l===g?k.push("\x3c!--F!--\x3e"):k.push("\x3c!--F--\x3e")}}f=b.keyPath;b.keyPath=c;e?(c=b.treeContext,b.treeContext=Jd(c,1,0),Pe(a,b,d,-1),b.treeContext=c):h?Pe(a,b,d,-1):Z(a,b,null,d,-1);b.keyPath=f}function Qe(a,b){if(a&&a.defaultProps){b=r({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}
+function Re(a,b,c,d,e,f,g){if("function"===typeof e)if(e.prototype&&e.prototype.isReactComponent){d=yd(e,b.legacyContext);var h=e.contextType;h=new e(f,"object"===typeof h&&null!==h?h._currentValue2:d);Hd(h,e,f,d);Ne(a,b,c,h,e)}else{h=yd(e,b.legacyContext);U={};Vd=b;Wd=a;Xd=c;be=ae=0;ce=-1;de=0;ee=d;d=e(f,h);d=ke(e,f,d,h);g=0!==ae;var k=be,l=ce;"object"===typeof d&&null!==d&&"function"===typeof d.render&&void 0===d.$$typeof?(Hd(d,e,f,h),Ne(a,b,c,d,e)):Oe(a,b,c,d,g,k,l)}else if("string"===typeof e)if(d=
+b.blockedSegment,null===d)d=f.children,h=b.formatContext,g=b.keyPath,b.formatContext=ob(h,e,f),b.keyPath=c,Pe(a,b,d,-1),b.formatContext=h,b.keyPath=g;else{g=Rb(d.chunks,e,f,a.resumableState,a.renderState,b.formatContext,d.lastPushedText);d.lastPushedText=!1;h=b.formatContext;k=b.keyPath;b.formatContext=ob(h,e,f);b.keyPath=c;Pe(a,b,g,-1);b.formatContext=h;b.keyPath=k;a:{b=d.chunks;a=a.resumableState;switch(e){case "title":case "style":case "script":case "area":case "base":case "br":case "col":case "embed":case "hr":case "img":case "input":case "keygen":case "link":case "meta":case "param":case "source":case "track":case "wbr":break a;
+case "body":if(1>=h.insertionMode){a.hasBody=!0;break a}break;case "html":if(0===h.insertionMode){a.hasHtml=!0;break a}}b.push(Mb(e))}d.lastPushedText=!1}else{switch(e){case qd:case od:case Jc:case Kc:case Ic:e=b.keyPath;b.keyPath=c;Z(a,b,null,f.children,-1);b.keyPath=e;return;case pd:"hidden"!==f.mode&&(e=b.keyPath,b.keyPath=c,Z(a,b,null,f.children,-1),b.keyPath=e);return;case kd:e=b.keyPath;b.keyPath=c;Z(a,b,null,f.children,-1);b.keyPath=e;return;case nd:throw Error(q(343));case Pc:a:if(null!==
+b.replay){e=b.keyPath;b.keyPath=c;c=f.children;try{Pe(a,b,c,-1)}finally{b.keyPath=e}}else{l=b.keyPath;e=b.blockedBoundary;var n=b.blockedSegment;d=f.fallback;var t=f.children;f=new Set;g=Ke(a,f);null!==a.trackedPostpones&&(g.trackedContentKeyPath=c);k=Ge(a,n.chunks.length,g,b.formatContext,!1,!1);n.children.push(k);n.lastPushedText=!1;var m=Ge(a,0,null,b.formatContext,!1,!1);m.parentFlushed=!0;b.blockedBoundary=g;b.blockedSegment=m;a.renderState.boundaryResources=g.resources;b.keyPath=c;try{if(Pe(a,
+b,t,-1),a.renderState.generateStaticMarkup||m.lastPushedText&&m.textEmbedded&&m.chunks.push("\x3c!-- --\x3e"),m.status=1,Se(g,m),0===g.pendingTasks&&0===g.status){g.status=1;break a}}catch(C){m.status=4,g.status=4,"object"===typeof C&&null!==C&&C.$$typeof===ud?(a.onPostpone(C.message),h="POSTPONE"):h=Y(a,C),g.errorDigest=h}finally{a.renderState.boundaryResources=e?e.resources:null,b.blockedBoundary=e,b.blockedSegment=n,b.keyPath=l}h=[c[0],"Suspense Fallback",c[2]];l=a.trackedPostpones;null!==l&&(n=
+[h[1],h[2],[],null],l.workingMap.set(h,n),5===g.status?l.workingMap.get(c)[4]=n:g.trackedFallbackNode=n);b=He(a,null,d,-1,e,k,f,h,b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}return}if("object"===typeof e&&null!==e)switch(e.$$typeof){case Oc:e=e.render;U={};Vd=b;Wd=a;Xd=c;be=ae=0;ce=-1;de=0;ee=d;d=e(f,g);f=ke(e,f,d,g);Oe(a,b,c,f,0!==ae,be,ce);return;case ld:e=e.type;f=Qe(e,f);Re(a,b,c,d,e,f,g);return;case Lc:h=f.children;d=b.keyPath;e=e._context;f=f.value;g=e._currentValue2;
+e._currentValue2=f;k=zd;zd=f={parent:k,depth:null===k?0:k.depth+1,context:e,parentValue:g,value:f};b.context=f;b.keyPath=c;Z(a,b,null,h,-1);a=zd;if(null===a)throw Error(q(403));c=a.parentValue;a.context._currentValue2=c===sd?a.context._defaultValue:c;a=zd=a.parent;b.context=a;b.keyPath=d;return;case Mc:f=f.children;f=f(e._currentValue2);e=b.keyPath;b.keyPath=c;Z(a,b,null,f,-1);b.keyPath=e;return;case md:h=e._init;e=h(e._payload);f=Qe(e,f);Re(a,b,c,d,e,f,void 0);return}throw Error(q(130,null==e?e:
+typeof e,""));}}function Te(a,b,c,d,e){var f=b.replay,g=b.blockedBoundary,h=Ge(a,0,null,b.formatContext,!1,!1);h.id=c;h.parentFlushed=!0;try{b.replay=null,b.blockedSegment=h,Pe(a,b,d,e),h.status=1,null===g?a.completedRootSegment=h:(Se(g,h),g.parentFlushed&&a.partialBoundaries.push(g))}finally{b.replay=f,b.blockedSegment=null}}
+function Z(a,b,c,d,e){if(null!==b.replay&&"number"===typeof b.replay.slots)Te(a,b,b.replay.slots,d,e);else{b.node=d;b.childIndex=e;if("object"===typeof d&&null!==d){switch(d.$$typeof){case Gc:var f=d.type,g=d.key,h=d.props,k=d.ref,l=wd(f),n=null==g?-1===e?0:e:g;g=[b.keyPath,l,n];if(null!==b.replay)a:{var t=b.replay;e=t.nodes;for(d=0;d<e.length;d++){var m=e[d];if(n===m[1]){if(4===m.length){if(null!==l&&l!==m[0])throw Error(q(490,m[0],l));l=m[2];m=m[3];n=b.node;b.replay={nodes:l,slots:m,pendingTasks:1};
+try{Re(a,b,g,c,f,h,k);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error(q(488));b.replay.pendingTasks--}catch(p){if("object"===typeof p&&null!==p&&(p===Od||"function"===typeof p.then))throw b.node===n&&(b.replay=t),p;b.replay.pendingTasks--;Ue(a,b.blockedBoundary,p,l,m)}b.replay=t}else{if(f!==Pc)throw Error(q(490,"Suspense",wd(f)||"Unknown"));b:{c=void 0;f=m[5];k=m[2];t=m[3];l=null===m[4]?[]:m[4][2];m=null===m[4]?null:m[4][3];n=b.keyPath;var C=b.replay,F=b.blockedBoundary,Q=h.children;
+h=h.fallback;var w=new Set,u=Ke(a,w);u.parentFlushed=!0;u.rootSegmentID=f;b.blockedBoundary=u;b.replay={nodes:k,slots:t,pendingTasks:1};a.renderState.boundaryResources=u.resources;try{Pe(a,b,Q,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error(q(488));b.replay.pendingTasks--;if(0===u.pendingTasks&&0===u.status){u.status=1;a.completedBoundaries.push(u);break b}}catch(p){u.status=4,"object"===typeof p&&null!==p&&p.$$typeof===ud?(a.onPostpone(p.message),c="POSTPONE"):c=Y(a,p),u.errorDigest=
+c,b.replay.pendingTasks--,a.clientRenderedBoundaries.push(u)}finally{a.renderState.boundaryResources=F?F.resources:null,b.blockedBoundary=F,b.replay=C,b.keyPath=n}h=Le(a,null,{nodes:l,slots:m,pendingTasks:0},h,-1,F,w,[g[0],"Suspense Fallback",g[2]],b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(h)}}e.splice(d,1);break a}}}else Re(a,b,g,c,f,h,k);return;case Hc:throw Error(q(257));case md:h=d._init;d=h(d._payload);Z(a,b,null,d,e);return}if(Ja(d)){Ve(a,b,d,e);return}null===
+d||"object"!==typeof d?h=null:(h=vd&&d[vd]||d["@@iterator"],h="function"===typeof h?h:null);if(h&&(h=h.call(d))){d=h.next();if(!d.done){g=[];do g.push(d.value),d=h.next();while(!d.done);Ve(a,b,g,e)}return}if("function"===typeof d.then)return Z(a,b,null,ue(d),e);if(d.$$typeof===Mc||d.$$typeof===Nc)return Z(a,b,null,d._currentValue2,e);e=Object.prototype.toString.call(d);throw Error(q(31,"[object Object]"===e?"object with keys {"+Object.keys(d).join(", ")+"}":e));}"string"===typeof d?(e=b.blockedSegment,
+null!==e&&(e.lastPushedText=Fc(e.chunks,d,a.renderState,e.lastPushedText))):"number"===typeof d&&(e=b.blockedSegment,null!==e&&(e.lastPushedText=Fc(e.chunks,""+d,a.renderState,e.lastPushedText)))}}
+function Ve(a,b,c,d){var e=b.keyPath;if(-1!==d&&(b.keyPath=[b.keyPath,"Fragment",d],null!==b.replay)){for(var f=b.replay,g=f.nodes,h=0;h<g.length;h++){var k=g[h];if(k[1]===d){d=k[2];k=k[3];b.replay={nodes:d,slots:k,pendingTasks:1};try{Ve(a,b,c,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error(q(488));b.replay.pendingTasks--}catch(n){if("object"===typeof n&&null!==n&&(n===Od||"function"===typeof n.then))throw n;b.replay.pendingTasks--;Ue(a,b.blockedBoundary,n,d,k)}b.replay=f;g.splice(h,
+1);break}}b.keyPath=e;return}f=b.treeContext;g=c.length;if(null!==b.replay&&(h=b.replay.slots,null!==h&&"object"===typeof h)){for(k=0;k<g;k++){d=c[k];b.treeContext=Jd(f,g,k);var l=h[k];"number"===typeof l?(Te(a,b,l,d,k),delete h[k]):Pe(a,b,d,k)}b.treeContext=f;b.keyPath=e;return}for(h=0;h<g;h++)k=c[h],b.treeContext=Jd(f,g,h),Pe(a,b,k,h);b.treeContext=f;b.keyPath=e}
+function We(a,b,c,d){d.status=5;var e=c.keyPath,f=c.blockedBoundary;if(null===f)d.id=a.nextSegmentId++,b.rootSlots=d.id,null!==a.completedRootSegment&&(a.completedRootSegment.status=5);else{if(null!==f&&0===f.status){f.status=5;f.rootSegmentID=a.nextSegmentId++;var g=f.trackedContentKeyPath;if(null===g)throw Error(q(486));var h=f.trackedFallbackNode,k=[];if(g===e&&-1===c.childIndex){d.id=f.rootSegmentID;d=[g[1],g[2],k,f.rootSegmentID,h,f.rootSegmentID];b.workingMap.set(g,d);Xe(d,g[0],b);return}var l=
+b.workingMap.get(g);void 0===l?(l=[g[1],g[2],k,null,h,f.rootSegmentID],b.workingMap.set(g,l),Xe(l,g[0],b)):(g=l,g[4]=h,g[5]=f.rootSegmentID)}-1===d.id&&(d.id=d.parentFlushed&&null!==f?f.rootSegmentID:a.nextSegmentId++);if(-1===c.childIndex)null===e?b.rootSlots=d.id:(c=b.workingMap.get(e),void 0===c?(c=[e[1],e[2],[],d.id],Xe(c,e[0],b)):c[3]=d.id);else{if(null===e)if(a=b.rootSlots,null===a)a=b.rootSlots={};else{if("number"===typeof a)throw Error(q(491));}else if(f=b.workingMap,g=f.get(e),void 0===g)a=
+{},g=[e[1],e[2],[],a],f.set(e,g),Xe(g,e[0],b);else if(a=g[3],null===a)a=g[3]={};else if("number"===typeof a)throw Error(q(491));a[c.childIndex]=d.id}}}
+function Pe(a,b,c,d){var e=b.formatContext,f=b.legacyContext,g=b.context,h=b.keyPath,k=b.treeContext,l=b.blockedSegment;if(null===l)try{return Z(a,b,null,c,d)}catch(m){if(le(),d=m===Od?Sd():m,"object"===typeof d&&null!==d&&"function"===typeof d.then){c=d;d=me();a=Le(a,d,b.replay,b.node,b.childIndex,b.blockedBoundary,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Fd(g);return}}else{var n=
+l.children.length,t=l.chunks.length;try{return Z(a,b,null,c,d)}catch(m){if(le(),l.children.length=n,l.chunks.length=t,d=m===Od?Sd():m,"object"===typeof d&&null!==d){if("function"===typeof d.then){c=d;d=me();l=b.blockedSegment;n=Ge(a,l.chunks.length,null,b.formatContext,l.lastPushedText,!0);l.children.push(n);l.lastPushedText=!1;a=He(a,d,b.node,b.childIndex,b.blockedBoundary,n,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=
+f;b.context=g;b.keyPath=h;b.treeContext=k;Fd(g);return}if(null!==a.trackedPostpones&&d.$$typeof===ud&&null!==b.blockedBoundary){c=a.trackedPostpones;a.onPostpone(d.message);d=b.blockedSegment;l=Ge(a,d.chunks.length,null,b.formatContext,d.lastPushedText,!0);d.children.push(l);d.lastPushedText=!1;We(a,c,b,l);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Fd(g);return}}}}b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Fd(g);throw d;}
+function Ue(a,b,c,d,e){if("object"===typeof c&&null!==c&&c.$$typeof===ud){a.onPostpone(c.message);var f="POSTPONE"}else f=Y(a,c);Ye(a,b,d,e,c,f)}function Ze(a){var b=a.blockedBoundary;a=a.blockedSegment;null!==a&&(a.status=3,$e(this,b,a))}
+function Ye(a,b,c,d,e,f){for(var g=0;g<c.length;g++){var h=c[g];if(4===h.length)Ye(a,b,h[2],h[3],e,f);else{h=h[5];var k=a,l=f,n=Ke(k,new Set);n.parentFlushed=!0;n.rootSegmentID=h;n.status=4;n.errorDigest=l;n.parentFlushed&&k.clientRenderedBoundaries.push(n)}}c.length=0;if(null!==d){if(null===b)throw Error(q(487));4!==b.status&&(b.status=4,b.errorDigest=f,b.parentFlushed&&a.clientRenderedBoundaries.push(b));if("object"===typeof d)for(var t in d)delete d[t]}}
+function af(a,b,c){var d=a.blockedBoundary,e=a.blockedSegment;null!==e&&(e.status=3);if(null===d){if(1!==b.status&&2!==b.status){a=a.replay;if(null===a){Y(b,c);Me(b,c);return}a.pendingTasks--;0===a.pendingTasks&&0<a.nodes.length&&(d=Y(b,c),Ye(b,null,a.nodes,a.slots,c,d));b.pendingRootTasks--;0===b.pendingRootTasks&&bf(b)}}else d.pendingTasks--,4!==d.status&&(d.status=4,d.errorDigest=Y(b,c),d.parentFlushed&&b.clientRenderedBoundaries.push(d)),d.fallbackAbortableTasks.forEach(function(f){return af(f,
+b,c)}),d.fallbackAbortableTasks.clear();b.allPendingTasks--;0===b.allPendingTasks&&cf(b)}function bf(a){null===a.trackedPostpones&&Dc(a.renderState,a.resumableState,!0);a.onShellError=Ee;a=a.onShellReady;a()}function cf(a){Dc(a.renderState,a.resumableState,null===a.trackedPostpones?!0:null===a.completedRootSegment||5!==a.completedRootSegment.status);a=a.onAllReady;a()}
+function Se(a,b){if(0===b.chunks.length&&1===b.children.length&&null===b.children[0].boundary){var c=b.children[0];c.id=b.id;c.parentFlushed=!0;1===c.status&&Se(a,c)}else a.completedSegments.push(b)}
+function $e(a,b,c){if(null===b){if(null!==c&&c.parentFlushed){if(null!==a.completedRootSegment)throw Error(q(389));a.completedRootSegment=c}a.pendingRootTasks--;0===a.pendingRootTasks&&bf(a)}else b.pendingTasks--,4!==b.status&&(0===b.pendingTasks?(0===b.status&&(b.status=1),null!==c&&c.parentFlushed&&1===c.status&&Se(b,c),b.parentFlushed&&a.completedBoundaries.push(b),1===b.status&&(b.fallbackAbortableTasks.forEach(Ze,a),b.fallbackAbortableTasks.clear())):null!==c&&c.parentFlushed&&1===c.status&&
+(Se(b,c),1===b.completedSegments.length&&b.parentFlushed&&a.partialBoundaries.push(b)));a.allPendingTasks--;0===a.allPendingTasks&&cf(a)}
+function Je(a){if(2!==a.status){var b=zd,c=Be.current;Be.current=ze;var d=Ce.current;Ce.current=Ae;var e=S;S=a;var f=ye;ye=a.resumableState;try{var g=a.pingedTasks,h;for(h=0;h<g.length;h++){var k=g[h],l=a,n=k.blockedBoundary;l.renderState.boundaryResources=n?n.resources:null;var t=k.blockedSegment;if(null===t){var m=l;if(0!==k.replay.pendingTasks){Fd(k.context);try{var C=k.thenableState;k.thenableState=null;Z(m,k,C,k.node,k.childIndex);if(1===k.replay.pendingTasks&&0<k.replay.nodes.length)throw Error(q(488));
+k.replay.pendingTasks--;k.abortSet.delete(k);$e(m,k.blockedBoundary,null)}catch(y){le();var F=y===Od?Sd():y;if("object"===typeof F&&null!==F&&"function"===typeof F.then){var Q=k.ping;F.then(Q,Q);k.thenableState=me()}else k.replay.pendingTasks--,k.abortSet.delete(k),Ue(m,k.blockedBoundary,F,k.replay.nodes,k.replay.slots),m.pendingRootTasks--,0===m.pendingRootTasks&&bf(m),m.allPendingTasks--,0===m.allPendingTasks&&cf(m)}finally{m.renderState.boundaryResources=null}}}else a:{m=void 0;var w=t;if(0===
+w.status){Fd(k.context);var u=w.children.length,p=w.chunks.length;try{var H=k.thenableState;k.thenableState=null;Z(l,k,H,k.node,k.childIndex);l.renderState.generateStaticMarkup||w.lastPushedText&&w.textEmbedded&&w.chunks.push("\x3c!-- --\x3e");k.abortSet.delete(k);w.status=1;$e(l,k.blockedBoundary,w)}catch(y){le();w.children.length=u;w.chunks.length=p;var v=y===Od?Sd():y;if("object"===typeof v&&null!==v){if("function"===typeof v.then){var x=k.ping;v.then(x,x);k.thenableState=me();break a}if(null!==
+l.trackedPostpones&&v.$$typeof===ud){var E=l.trackedPostpones;k.abortSet.delete(k);l.onPostpone(v.message);We(l,E,k,w);$e(l,k.blockedBoundary,w);break a}}k.abortSet.delete(k);w.status=4;var D=k.blockedBoundary;"object"===typeof v&&null!==v&&v.$$typeof===ud?(l.onPostpone(v.message),m="POSTPONE"):m=Y(l,v);null===D?Me(l,v):(D.pendingTasks--,4!==D.status&&(D.status=4,D.errorDigest=m,D.parentFlushed&&l.clientRenderedBoundaries.push(D)));l.allPendingTasks--;0===l.allPendingTasks&&cf(l)}finally{l.renderState.boundaryResources=
+null}}}}g.splice(0,h);null!==a.destination&&df(a,a.destination)}catch(y){Y(a,y),Me(a,y)}finally{ye=f,Be.current=c,Ce.current=d,c===ze&&Fd(b),S=e}}}
+function ef(a,b,c){c.parentFlushed=!0;switch(c.status){case 0:c.id=a.nextSegmentId++;case 5:var d=c.id;c.lastPushedText=!1;c.textEmbedded=!1;a=a.renderState;b.push('<template id="');b.push(a.placeholderPrefix);a=d.toString(16);b.push(a);return b.push('"></template>');case 1:c.status=2;var e=!0;d=c.chunks;var f=0;c=c.children;for(var g=0;g<c.length;g++){for(e=c[g];f<e.index;f++)b.push(d[f]);e=ff(a,b,e)}for(;f<d.length-1;f++)b.push(d[f]);f<d.length&&(e=b.push(d[f]));return e;default:throw Error(q(390));
 }}
-function df(a,b,c){var d=c.boundary;if(null===d)return cf(a,b,c);d.parentFlushed=!0;if(4===d.status)return a.renderState.generateStaticMarkup||(d=d.errorDigest,b.push("\x3c!--$!--\x3e"),b.push("<template"),d&&(b.push(' data-dgst="'),d=y(d),b.push(d),b.push('"')),b.push("></template>")),cf(a,b,c),a=a.renderState.generateStaticMarkup?!0:b.push("\x3c!--/$--\x3e"),a;if(1!==d.status)return 0===d.status&&(d.rootSegmentID=a.nextSegmentId++),0<d.completedSegments.length&&a.partialBoundaries.push(d),Ub(b,a.renderState,
-d.rootSegmentID),cf(a,b,c),b.push("\x3c!--/$--\x3e");if(d.byteSize>a.progressiveChunkSize)return d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),Ub(b,a.renderState,d.rootSegmentID),cf(a,b,c),b.push("\x3c!--/$--\x3e");c=d.resources;var e=a.renderState.boundaryResources;e&&(c.styles.forEach(Ac,e),c.stylesheets.forEach(Bc,e));a.renderState.generateStaticMarkup||b.push("\x3c!--$--\x3e");c=d.completedSegments;if(1!==c.length)throw Error(p(391));df(a,b,c[0]);a=a.renderState.generateStaticMarkup?
-!0:b.push("\x3c!--/$--\x3e");return a}function ef(a,b,c){Vb(b,a.renderState,c.parentFormatContext,c.id);df(a,b,c);return Wb(b,c.parentFormatContext)}
-function ff(a,b,c){a.renderState.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e<d.length;e++)gf(a,b,c,d[e]);d.length=0;nc(b,c.resources,a.renderState);d=a.resumableState;a=a.renderState;e=c.rootSegmentID;c=c.resources;var f=a.stylesToHoist;a.stylesToHoist=!1;var g=0===d.streamingFormat;g?(b.push(a.startInlineScript),f?0===(d.instructions&2)?(d.instructions|=10,b.push('$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};$RR("')):
+function ff(a,b,c){var d=c.boundary;if(null===d)return ef(a,b,c);d.parentFlushed=!0;if(4===d.status)return a.renderState.generateStaticMarkup||(d=d.errorDigest,b.push("\x3c!--$!--\x3e"),b.push("<template"),d&&(b.push(' data-dgst="'),d=A(d),b.push(d),b.push('"')),b.push("></template>")),ef(a,b,c),a=a.renderState.generateStaticMarkup?!0:b.push("\x3c!--/$--\x3e"),a;if(1!==d.status)return 0===d.status&&(d.rootSegmentID=a.nextSegmentId++),0<d.completedSegments.length&&a.partialBoundaries.push(d),Vb(b,a.renderState,
+d.rootSegmentID),ef(a,b,c),b.push("\x3c!--/$--\x3e");if(d.byteSize>a.progressiveChunkSize)return d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),Vb(b,a.renderState,d.rootSegmentID),ef(a,b,c),b.push("\x3c!--/$--\x3e");c=d.resources;var e=a.renderState.boundaryResources;e&&(c.styles.forEach(Bc,e),c.stylesheets.forEach(Cc,e));a.renderState.generateStaticMarkup||b.push("\x3c!--$--\x3e");c=d.completedSegments;if(1!==c.length)throw Error(q(391));ff(a,b,c[0]);a=a.renderState.generateStaticMarkup?
+!0:b.push("\x3c!--/$--\x3e");return a}function gf(a,b,c){Wb(b,a.renderState,c.parentFormatContext,c.id);ff(a,b,c);return Xb(b,c.parentFormatContext)}
+function hf(a,b,c){a.renderState.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e<d.length;e++)jf(a,b,c,d[e]);d.length=0;oc(b,c.resources,a.renderState);d=a.resumableState;a=a.renderState;e=c.rootSegmentID;c=c.resources;var f=a.stylesToHoist;a.stylesToHoist=!1;var g=0===d.streamingFormat;g?(b.push(a.startInlineScript),f?0===(d.instructions&2)?(d.instructions|=10,b.push('$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};$RR("')):
 0===(d.instructions&8)?(d.instructions|=8,b.push('$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};$RR("')):
 b.push('$RR("'):0===(d.instructions&2)?(d.instructions|=2,b.push('$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};$RC("')):
-b.push('$RC("')):f?b.push('<template data-rri="" data-bid="'):b.push('<template data-rci="" data-bid="');d=e.toString(16);b.push(a.boundaryPrefix);b.push(d);g?b.push('","'):b.push('" data-sid="');b.push(a.segmentPrefix);b.push(d);f?g?(b.push('",'),tc(b,c)):(b.push('" data-sty="'),uc(b,c)):g&&b.push('"');d=g?b.push(")\x3c/script>"):b.push('"></template>');return Tb(b,a)&&d}
-function gf(a,b,c,d){if(2===d.status)return!0;var e=d.id;if(-1===e){if(-1===(d.id=c.rootSegmentID))throw Error(p(392));return ef(a,b,d)}if(e===c.rootSegmentID)return ef(a,b,d);ef(a,b,d);c=a.resumableState;a=a.renderState;(d=0===c.streamingFormat)?(b.push(a.startInlineScript),0===(c.instructions&1)?(c.instructions|=1,b.push('$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};$RS("')):
+b.push('$RC("')):f?b.push('<template data-rri="" data-bid="'):b.push('<template data-rci="" data-bid="');e=e.toString(16);b.push(a.boundaryPrefix);b.push(e);g?b.push('","'):b.push('" data-sid="');b.push(a.segmentPrefix);b.push(e);f?g?(b.push('",'),uc(b,c)):(b.push('" data-sty="'),vc(b,c)):g&&b.push('"');c=g?b.push(")\x3c/script>"):b.push('"></template>');return Ub(b,a,d)&&c}
+function jf(a,b,c,d){if(2===d.status)return!0;var e=d.id;if(-1===e){if(-1===(d.id=c.rootSegmentID))throw Error(q(392));return gf(a,b,d)}if(e===c.rootSegmentID)return gf(a,b,d);gf(a,b,d);c=a.resumableState;a=a.renderState;(d=0===c.streamingFormat)?(b.push(a.startInlineScript),0===(c.instructions&1)?(c.instructions|=1,b.push('$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};$RS("')):
 b.push('$RS("')):b.push('<template data-rsi="" data-sid="');b.push(a.segmentPrefix);e=e.toString(16);b.push(e);d?b.push('","'):b.push('" data-pid="');b.push(a.placeholderPrefix);b.push(e);b=d?b.push('")\x3c/script>'):b.push('"></template>');return b}
-function bf(a,b){try{var c,d=a.completedRootSegment;if(null!==d)if(5!==d.status&&0===a.pendingRootTasks){var e=a.renderState;if((0!==a.allPendingTasks||null!==a.trackedPostpones)&&e.externalRuntimeScript){var f=e.externalRuntimeScript,g=a.resumableState,h=f.src,k=f.chunks;g.scriptResources.hasOwnProperty(h)||(g.scriptResources[h]=null,e.scripts.add(k))}var l=e.htmlChunks,n=e.headChunks;f=0;if(l){for(f=0;f<l.length;f++)b.push(l[f]);if(n)for(f=0;f<n.length;f++)b.push(n[f]);else{var r=M("head");b.push(r);
-b.push(">")}}else if(n)for(f=0;f<n.length;f++)b.push(n[f]);var m=e.charsetChunks;for(f=0;f<m.length;f++)b.push(m[f]);m.length=0;e.preconnects.forEach(N,b);e.preconnects.clear();var C=e.preconnectChunks;for(f=0;f<C.length;f++)b.push(C[f]);C.length=0;e.fontPreloads.forEach(N,b);e.fontPreloads.clear();e.highImagePreloads.forEach(N,b);e.highImagePreloads.clear();e.styles.forEach(qc,b);var D=e.importMapChunks;for(f=0;f<D.length;f++)b.push(D[f]);D.length=0;e.bootstrapScripts.forEach(N,b);e.scripts.forEach(N,
-b);e.scripts.clear();e.bulkPreloads.forEach(N,b);e.bulkPreloads.clear();var Q=e.preloadChunks;for(f=0;f<Q.length;f++)b.push(Q[f]);Q.length=0;var v=e.hoistableChunks;for(f=0;f<v.length;f++)b.push(v[f]);v.length=0;if(l&&null===n){var A=Lb("head");b.push(A)}df(a,b,d);a.completedRootSegment=null;Tb(b,a.renderState)}else return;var q=a.renderState;d=0;q.preconnects.forEach(N,b);q.preconnects.clear();var aa=q.preconnectChunks;for(d=0;d<aa.length;d++)b.push(aa[d]);aa.length=0;q.fontPreloads.forEach(N,b);
-q.fontPreloads.clear();q.highImagePreloads.forEach(N,b);q.highImagePreloads.clear();q.styles.forEach(sc,b);q.scripts.forEach(N,b);q.scripts.clear();q.bulkPreloads.forEach(N,b);q.bulkPreloads.clear();var u=q.preloadChunks;for(d=0;d<u.length;d++)b.push(u[d]);u.length=0;var U=q.hoistableChunks;for(d=0;d<U.length;d++)b.push(U[d]);U.length=0;var E=a.clientRenderedBoundaries;for(c=0;c<E.length;c++){var B=E[c];q=b;var w=a.resumableState,Qa=a.renderState,rb=B.rootSegmentID,Ca=B.errorDigest,la=B.errorMessage,
-ea=B.errorComponentStack,V=0===w.streamingFormat;V?(q.push(Qa.startInlineScript),0===(w.instructions&4)?(w.instructions|=4,q.push('$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};;$RX("')):q.push('$RX("')):q.push('<template data-rxi="" data-bid="');q.push(Qa.boundaryPrefix);var Ra=rb.toString(16);q.push(Ra);V&&q.push('"');if(Ca||la||ea)if(V){q.push(",");var Sa=Yb(Ca||"");
-q.push(Sa)}else{q.push('" data-dgst="');var Ta=y(Ca||"");q.push(Ta)}if(la||ea)if(V){q.push(",");var ma=Yb(la||"");q.push(ma)}else{q.push('" data-msg="');var O=y(la||"");q.push(O)}if(ea)if(V){q.push(",");var sb=Yb(ea);q.push(sb)}else{q.push('" data-stck="');var na=y(ea);q.push(na)}if(V?!q.push(")\x3c/script>"):!q.push('"></template>')){a.destination=null;c++;E.splice(0,c);return}}E.splice(0,c);var oa=a.completedBoundaries;for(c=0;c<oa.length;c++)if(!ff(a,b,oa[c])){a.destination=null;c++;oa.splice(0,
-c);return}oa.splice(0,c);var ba=a.partialBoundaries;for(c=0;c<ba.length;c++){var pa=ba[c];a:{E=a;B=b;E.renderState.boundaryResources=pa.resources;var qa=pa.completedSegments;for(w=0;w<qa.length;w++)if(!gf(E,B,pa,qa[w])){w++;qa.splice(0,w);var Ua=!1;break a}qa.splice(0,w);Ua=nc(B,pa.resources,E.renderState)}if(!Ua){a.destination=null;c++;ba.splice(0,c);return}}ba.splice(0,c);var ra=a.completedBoundaries;for(c=0;c<ra.length;c++)if(!ff(a,b,ra[c])){a.destination=null;c++;ra.splice(0,c);return}ra.splice(0,
-c)}finally{0===a.allPendingTasks&&0===a.pingedTasks.length&&0===a.clientRenderedBoundaries.length&&0===a.completedBoundaries.length&&(a.flushScheduled=!1,null===a.trackedPostpones&&(c=a.resumableState,c.hasBody&&(ba=Lb("body"),b.push(ba)),c.hasHtml&&(c=Lb("html"),b.push(c))),b.push(null),a.destination=null)}}function xc(a){if(!1===a.flushScheduled&&0===a.pingedTasks.length&&null!==a.destination){a.flushScheduled=!0;var b=a.destination;b?bf(a,b):a.flushScheduled=!1}}
-function hf(a,b){try{var c=a.abortableTasks;if(0<c.size){var d=void 0===b?Error(p(432)):b;c.forEach(function(e){return Ze(e,a,d)});c.clear()}null!==a.destination&&bf(a,a.destination)}catch(e){X(a,e),Le(a,e)}}function Ve(a,b,c){if(null===b)c.rootNodes.push(a);else{var d=c.workingMap,e=d.get(b);void 0===e&&(e=[b[1],b[2],[],null],d.set(b,e),Ve(e,b[0],c));e[2].push(a)}}function jf(){}
-function kf(a,b,c,d){var e=!1,f=null,g="",h={push:function(l){null!==l&&(g+=l);return!0},destroy:function(l){e=!0;f=l}},k=!1;b=mb(b?b.identifierPrefix:void 0,void 0);a=Ee(a,b,Dc(b,c),G(0,null,0),Infinity,jf,void 0,function(){k=!0},void 0,void 0,void 0);a.flushScheduled=null!==a.destination;Ie(a);null===a.trackedPostpones&&Cc(a.renderState,a.resumableState,0===a.pendingRootTasks);hf(a,d);if(1===a.status)a.status=2,h.destroy(a.fatalError);else if(2!==a.status&&null===a.destination){a.destination=h;
-try{bf(a,h)}catch(l){X(a,l),Le(a,l)}}if(e&&f!==d)throw f;if(!k)throw Error(p(426));return g}exports.renderToNodeStream=function(){throw Error(p(207));};exports.renderToStaticMarkup=function(a,b){return kf(a,b,!0,'The server used "renderToStaticMarkup" which does not support Suspense. If you intended to have the server wait for the suspended component please switch to "renderToReadableStream" which supports Suspense on the server')};exports.renderToStaticNodeStream=function(){throw Error(p(208));};
-exports.renderToString=function(a,b){return kf(a,b,!1,'The server used "renderToString" which does not support Suspense. If you intended for this Suspense boundary to render the fallback content on the server consider throwing an Error somewhere within the Suspense boundary. If you intended to have the server wait for the suspended component please switch to "renderToReadableStream" which supports Suspense on the server')};exports.version="18.3.0-experimental-2983249dd-20231107";
+function df(a,b){try{var c,d=a.completedRootSegment;if(null!==d)if(5!==d.status&&0===a.pendingRootTasks){var e=a.renderState;if((0!==a.allPendingTasks||null!==a.trackedPostpones)&&e.externalRuntimeScript){var f=e.externalRuntimeScript,g=a.resumableState,h=f.src,k=f.chunks;g.scriptResources.hasOwnProperty(h)||(g.scriptResources[h]=null,e.scripts.add(k))}var l=e.htmlChunks,n=e.headChunks;f=0;if(l){for(f=0;f<l.length;f++)b.push(l[f]);if(n)for(f=0;f<n.length;f++)b.push(n[f]);else{var t=O("head");b.push(t);
+b.push(">")}}else if(n)for(f=0;f<n.length;f++)b.push(n[f]);var m=e.charsetChunks;for(f=0;f<m.length;f++)b.push(m[f]);m.length=0;e.preconnects.forEach(P,b);e.preconnects.clear();var C=e.preconnectChunks;for(f=0;f<C.length;f++)b.push(C[f]);C.length=0;e.fontPreloads.forEach(P,b);e.fontPreloads.clear();e.highImagePreloads.forEach(P,b);e.highImagePreloads.clear();e.styles.forEach(rc,b);var F=e.importMapChunks;for(f=0;f<F.length;f++)b.push(F[f]);F.length=0;e.bootstrapScripts.forEach(P,b);e.scripts.forEach(P,
+b);e.scripts.clear();e.bulkPreloads.forEach(P,b);e.bulkPreloads.clear();var Q=e.preloadChunks;for(f=0;f<Q.length;f++)b.push(Q[f]);Q.length=0;var w=e.hoistableChunks;for(f=0;f<w.length;f++)b.push(w[f]);w.length=0;if(l&&null===n){var u=Mb("head");b.push(u)}ff(a,b,d);a.completedRootSegment=null;Ub(b,a.renderState,a.resumableState)}else return;var p=a.renderState;d=0;p.preconnects.forEach(P,b);p.preconnects.clear();var H=p.preconnectChunks;for(d=0;d<H.length;d++)b.push(H[d]);H.length=0;p.fontPreloads.forEach(P,
+b);p.fontPreloads.clear();p.highImagePreloads.forEach(P,b);p.highImagePreloads.clear();p.styles.forEach(tc,b);p.scripts.forEach(P,b);p.scripts.clear();p.bulkPreloads.forEach(P,b);p.bulkPreloads.clear();var v=p.preloadChunks;for(d=0;d<v.length;d++)b.push(v[d]);v.length=0;var x=p.hoistableChunks;for(d=0;d<x.length;d++)b.push(x[d]);x.length=0;var E=a.clientRenderedBoundaries;for(c=0;c<E.length;c++){var D=E[c];p=b;var y=a.resumableState,Qa=a.renderState,rb=D.rootSegmentID,Ca=D.errorDigest,la=D.errorMessage,
+ea=D.errorComponentStack,W=0===y.streamingFormat;W?(p.push(Qa.startInlineScript),0===(y.instructions&4)?(y.instructions|=4,p.push('$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};;$RX("')):p.push('$RX("')):p.push('<template data-rxi="" data-bid="');p.push(Qa.boundaryPrefix);var Ra=rb.toString(16);p.push(Ra);W&&p.push('"');if(Ca||la||ea)if(W){p.push(",");var Sa=hc(Ca||"");
+p.push(Sa)}else{p.push('" data-dgst="');var Ta=A(Ca||"");p.push(Ta)}if(la||ea)if(W){p.push(",");var ma=hc(la||"");p.push(ma)}else{p.push('" data-msg="');var R=A(la||"");p.push(R)}if(ea)if(W){p.push(",");var sb=hc(ea);p.push(sb)}else{p.push('" data-stck="');var na=A(ea);p.push(na)}if(W?!p.push(")\x3c/script>"):!p.push('"></template>')){a.destination=null;c++;E.splice(0,c);return}}E.splice(0,c);var oa=a.completedBoundaries;for(c=0;c<oa.length;c++)if(!hf(a,b,oa[c])){a.destination=null;c++;oa.splice(0,
+c);return}oa.splice(0,c);var ba=a.partialBoundaries;for(c=0;c<ba.length;c++){var pa=ba[c];a:{E=a;D=b;E.renderState.boundaryResources=pa.resources;var qa=pa.completedSegments;for(y=0;y<qa.length;y++)if(!jf(E,D,pa,qa[y])){y++;qa.splice(0,y);var Ua=!1;break a}qa.splice(0,y);Ua=oc(D,pa.resources,E.renderState)}if(!Ua){a.destination=null;c++;ba.splice(0,c);return}}ba.splice(0,c);var ra=a.completedBoundaries;for(c=0;c<ra.length;c++)if(!hf(a,b,ra[c])){a.destination=null;c++;ra.splice(0,c);return}ra.splice(0,
+c)}finally{0===a.allPendingTasks&&0===a.pingedTasks.length&&0===a.clientRenderedBoundaries.length&&0===a.completedBoundaries.length&&(a.flushScheduled=!1,null===a.trackedPostpones&&(c=a.resumableState,c.hasBody&&(ba=Mb("body"),b.push(ba)),c.hasHtml&&(c=Mb("html"),b.push(c))),b.push(null),a.destination=null)}}function yc(a){if(!1===a.flushScheduled&&0===a.pingedTasks.length&&null!==a.destination){a.flushScheduled=!0;var b=a.destination;b?df(a,b):a.flushScheduled=!1}}
+function kf(a,b){try{var c=a.abortableTasks;if(0<c.size){var d=void 0===b?Error(q(432)):b;c.forEach(function(e){return af(e,a,d)});c.clear()}null!==a.destination&&df(a,a.destination)}catch(e){Y(a,e),Me(a,e)}}function Xe(a,b,c){if(null===b)c.rootNodes.push(a);else{var d=c.workingMap,e=d.get(b);void 0===e&&(e=[b[1],b[2],[],null],d.set(b,e),Xe(e,b[0],c));e[2].push(a)}}function lf(){}
+function mf(a,b,c,d){var e=!1,f=null,g="",h={push:function(l){null!==l&&(g+=l);return!0},destroy:function(l){e=!0;f=l}},k=!1;b=nb(b?b.identifierPrefix:void 0,void 0);a=Fe(a,b,Ec(b,c),G(0,null,0),Infinity,lf,void 0,function(){k=!0},void 0,void 0,void 0);a.flushScheduled=null!==a.destination;Je(a);null===a.trackedPostpones&&Dc(a.renderState,a.resumableState,0===a.pendingRootTasks);kf(a,d);if(1===a.status)a.status=2,h.destroy(a.fatalError);else if(2!==a.status&&null===a.destination){a.destination=h;
+try{df(a,h)}catch(l){Y(a,l),Me(a,l)}}if(e&&f!==d)throw f;if(!k)throw Error(q(426));return g}exports.renderToNodeStream=function(){throw Error(q(207));};exports.renderToStaticMarkup=function(a,b){return mf(a,b,!0,'The server used "renderToStaticMarkup" which does not support Suspense. If you intended to have the server wait for the suspended component please switch to "renderToReadableStream" which supports Suspense on the server')};exports.renderToStaticNodeStream=function(){throw Error(q(208));};
+exports.renderToString=function(a,b){return mf(a,b,!1,'The server used "renderToString" which does not support Suspense. If you intended for this Suspense boundary to render the fallback content on the server consider throwing an Error somewhere within the Suspense boundary. If you intended to have the server wait for the suspended component please switch to "renderToReadableStream" which supports Suspense on the server')};exports.version="18.3.0-experimental-7508dcd5c-20231108";
+
+//# sourceMappingURL=react-dom-server-legacy.browser.production.min.js.map
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.node.development.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.node.development.js
index f179fa46a8bf7..6b06bd5298771 100644
--- a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.node.development.js
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.node.development.js
@@ -18,7 +18,7 @@ var React = require("next/dist/compiled/react-experimental");
 var ReactDOM = require('react-dom');
 var stream = require('stream');
 
-var ReactVersion = '18.3.0-experimental-2983249dd-20231107';
+var ReactVersion = '18.3.0-experimental-7508dcd5c-20231108';
 
 var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
 
@@ -1737,11 +1737,14 @@ var DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS = 2000; // Allows us to keep tr
 // if passed externalRuntimeConfig and the enableFizzExternalRuntime feature flag
 // is set, the server will send instructions via data attributes (instead of inline scripts)
 
-function createRenderState$1(resumableState, nonce, bootstrapScriptContent, bootstrapScripts, bootstrapModules, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
+function createRenderState$1(resumableState, nonce, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
   var inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
   var idPrefix = resumableState.idPrefix;
   var bootstrapChunks = [];
   var externalRuntimeScript = null;
+  var bootstrapScriptContent = resumableState.bootstrapScriptContent,
+      bootstrapScripts = resumableState.bootstrapScripts,
+      bootstrapModules = resumableState.bootstrapModules;
 
   if (bootstrapScriptContent !== undefined) {
     bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapAndImportMapScriptContent(bootstrapScriptContent)), endInlineScript);
@@ -1930,7 +1933,7 @@ function createRenderState$1(resumableState, nonce, bootstrapScriptContent, boot
 
   return renderState;
 }
-function createResumableState(identifierPrefix, externalRuntimeConfig) {
+function createResumableState(identifierPrefix, externalRuntimeConfig, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
   var idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
   var streamingFormat = ScriptStreamingFormat;
 
@@ -1944,6 +1947,9 @@ function createResumableState(identifierPrefix, externalRuntimeConfig) {
     idPrefix: idPrefix,
     nextFormID: 0,
     streamingFormat: streamingFormat,
+    bootstrapScriptContent: bootstrapScriptContent,
+    bootstrapScripts: bootstrapScripts,
+    bootstrapModules: bootstrapModules,
     instructions: NothingSent,
     hasBody: false,
     hasHtml: false,
@@ -4410,7 +4416,10 @@ function pushEndInstance(target, type, props, resumableState, formatContext) {
   target.push(endChunkForTag(type));
 }
 
-function writeBootstrap(destination, renderState) {
+function writeBootstrap(destination, renderState, resumableState) {
+  resumableState.bootstrapScriptContent = undefined;
+  resumableState.bootstrapScripts = undefined;
+  resumableState.bootstrapModules = undefined;
   var bootstrapChunks = renderState.bootstrapChunks;
   var i = 0;
 
@@ -4427,8 +4436,8 @@ function writeBootstrap(destination, renderState) {
   return true;
 }
 
-function writeCompletedRoot(destination, renderState) {
-  return writeBootstrap(destination, renderState);
+function writeCompletedRoot(destination, renderState, resumableState) {
+  return writeBootstrap(destination, renderState, resumableState);
 } // Structural Nodes
 // A placeholder is a node inside a hidden partial tree that can be filled in later, but before
 // display. It's never visible to users. We use the template tag because it can be used in every
@@ -4785,7 +4794,7 @@ function writeCompletedBoundaryInstruction(destination, resumableState, renderSt
     writeMore = writeChunkAndReturn(destination, completeBoundaryDataEnd);
   }
 
-  return writeBootstrap(destination, renderState) && writeMore;
+  return writeBootstrap(destination, renderState, resumableState) && writeMore;
 }
 var clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
 var clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
@@ -6521,7 +6530,7 @@ function emitEarlyPreloads(renderState, resumableState, shellComplete) {
 }
 
 function createRenderState(resumableState, generateStaticMarkup) {
-  var renderState = createRenderState$1(resumableState, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+  var renderState = createRenderState$1(resumableState, undefined, undefined, undefined, undefined, undefined);
   return {
     // Keep this in sync with ReactFizzConfigDOM
     placeholderPrefix: renderState.placeholderPrefix,
@@ -6877,6 +6886,18 @@ var componentFrameCache;
   var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
   componentFrameCache = new PossiblyWeakMap();
 }
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
@@ -6892,7 +6913,6 @@ function describeNativeComponentFrame(fn, construct) {
     }
   }
 
-  var control;
   reentry = true;
   var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
 
@@ -6906,81 +6926,140 @@ function describeNativeComponentFrame(fn, construct) {
     ReactCurrentDispatcher$1.current = null;
     disableLogs();
   }
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
 
-  try {
-    // This should throw.
-    if (construct) {
-      // Something should be setting the props in the constructor.
-      var Fake = function () {
-        throw Error();
-      }; // $FlowFixMe[prop-missing]
 
+  var RunInRootFrame = {
+    DetermineComponentFrameRoot: function () {
+      var control;
 
-      Object.defineProperty(Fake.prototype, 'props', {
-        set: function () {
-          // We use a throwing setter instead of frozen or non-writable props
-          // because that won't throw in a non-strict mode function.
-          throw Error();
-        }
-      });
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          var Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
 
-      if (typeof Reflect === 'object' && Reflect.construct) {
-        // We construct a different control for this case to include any extra
-        // frames added by the construct call.
-        try {
-          Reflect.construct(Fake, []);
-        } catch (x) {
-          control = x;
-        }
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
 
-        Reflect.construct(fn, [], Fake);
-      } else {
-        try {
-          Fake.call();
-        } catch (x) {
-          control = x;
-        } // $FlowFixMe[prop-missing] found when upgrading Flow
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
 
 
-        fn.call(Fake.prototype);
-      }
-    } else {
-      try {
-        throw Error();
-      } catch (x) {
-        control = x;
-      } // TODO(luna): This will currently only throw if the function component
-      // tries to access React/ReactDOM/props. We should probably make this throw
-      // in simple components too
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
 
 
-      var maybePromise = fn(); // If the function component returns a promise, it's likely an async
-      // component, which we don't yet support. Attach a noop catch handler to
-      // silence the error.
-      // TODO: Implement component stacks for async client components?
+          var maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
 
-      if (maybePromise && typeof maybePromise.catch === 'function') {
-        maybePromise.catch(function () {});
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(function () {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
       }
+
+      return [null, null];
     }
-  } catch (sample) {
-    // This is inlined manually because closure doesn't do it for us.
-    if (sample && control && typeof sample.stack === 'string') {
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
+
+  try {
+    var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
+
+    if (sampleStack && controlStack) {
       // This extracts the first frame from the sample that isn't also in the control.
       // Skipping one frame that we assume is the frame that calls the two.
-      var sampleLines = sample.stack.split('\n');
-      var controlLines = control.stack.split('\n');
-      var s = sampleLines.length - 1;
-      var c = controlLines.length - 1;
-
-      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
-        // We expect at least one stack frame to be shared.
-        // Typically this will be the root most one. However, stack frames may be
-        // cut off due to maximum stack limits. In this case, one maybe cut off
-        // earlier than the other. We assume that the sample is longer or the same
-        // and there for cut off earlier. So we should find the root most frame in
-        // the sample somewhere in the control.
-        c--;
+      var sampleLines = sampleStack.split('\n');
+      var controlLines = controlStack.split('\n');
+      var s = 0;
+      var c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
       }
 
       for (; s >= 1 && c >= 0; s--, c--) {
@@ -7009,7 +7088,7 @@ function describeNativeComponentFrame(fn, construct) {
                   _frame = _frame.replace('<anonymous>', fn.displayName);
                 }
 
-                {
+                if (true) {
                   if (typeof fn === 'function') {
                     componentFrameCache.set(fn, _frame);
                   }
@@ -11613,7 +11692,7 @@ function flushCompletedQueues(request, destination) {
 
         flushSegment(request, destination, completedRootSegment);
         request.completedRootSegment = null;
-        writeCompletedRoot(destination, request.renderState);
+        writeCompletedRoot(destination, request.renderState, request.resumableState);
       } else {
         // We haven't flushed the root yet so we don't need to check any other branches further down
         return;
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.node.production.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.node.production.js
new file mode 100644
index 0000000000000..b93e24acb4a3a
--- /dev/null
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.node.production.js
@@ -0,0 +1,8941 @@
+/**
+ * @license React
+ * react-dom-server-legacy.node.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require("next/dist/compiled/react-experimental");
+var ReactDOM = require('react-dom');
+var stream = require('stream');
+
+var ReactVersion = '18.3.0-experimental-7508dcd5c-20231108';
+
+// A pure JS implementation of a string hashing function. We do not use it for
+// security or obfuscation purposes, only to create compact hashes. So we
+// prioritize speed over collision avoidance. For example, we use this to hash
+// the component key path used by useFormState for MPA-style submissions.
+//
+// In environments where built-in hashing functions are available, we prefer
+// those instead. Like Node's crypto module, or Bun.hash. Unfortunately this
+// does not include the web standard crypto API because those methods are all
+// async. For our purposes, we need it to be sync because the cost of context
+// switching is too high to be worth it.
+//
+// The most popular hashing algorithm that meets these requirements in the JS
+// ecosystem is MurmurHash3, and almost all implementations I could find used
+// some version of the implementation by Gary Court inlined below.
+function createFastHashJS(key) {
+  return murmurhash3_32_gc(key, 0);
+}
+/* eslint-disable prefer-const, no-fallthrough */
+
+/**
+ * @license
+ *
+ * JS Implementation of MurmurHash3 (r136) (as of May 20, 2011)
+ *
+ * Copyright (c) 2011 Gary Court
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+function murmurhash3_32_gc(key, seed) {
+  let remainder, bytes, h1, h1b, c1, c2, k1, i;
+  remainder = key.length & 3; // key.length % 4
+
+  bytes = key.length - remainder;
+  h1 = seed;
+  c1 = 0xcc9e2d51;
+  c2 = 0x1b873593;
+  i = 0;
+
+  while (i < bytes) {
+    k1 = key.charCodeAt(i) & 0xff | (key.charCodeAt(++i) & 0xff) << 8 | (key.charCodeAt(++i) & 0xff) << 16 | (key.charCodeAt(++i) & 0xff) << 24;
+    ++i;
+    k1 = (k1 & 0xffff) * c1 + (((k1 >>> 16) * c1 & 0xffff) << 16) & 0xffffffff;
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = (k1 & 0xffff) * c2 + (((k1 >>> 16) * c2 & 0xffff) << 16) & 0xffffffff;
+    h1 ^= k1;
+    h1 = h1 << 13 | h1 >>> 19;
+    h1b = (h1 & 0xffff) * 5 + (((h1 >>> 16) * 5 & 0xffff) << 16) & 0xffffffff;
+    h1 = (h1b & 0xffff) + 0x6b64 + (((h1b >>> 16) + 0xe654 & 0xffff) << 16);
+  }
+
+  k1 = 0;
+
+  switch (remainder) {
+    case 3:
+      k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
+
+    case 2:
+      k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
+
+    case 1:
+      k1 ^= key.charCodeAt(i) & 0xff;
+      k1 = (k1 & 0xffff) * c1 + (((k1 >>> 16) * c1 & 0xffff) << 16) & 0xffffffff;
+      k1 = k1 << 15 | k1 >>> 17;
+      k1 = (k1 & 0xffff) * c2 + (((k1 >>> 16) * c2 & 0xffff) << 16) & 0xffffffff;
+      h1 ^= k1;
+  }
+
+  h1 ^= key.length;
+  h1 ^= h1 >>> 16;
+  h1 = (h1 & 0xffff) * 0x85ebca6b + (((h1 >>> 16) * 0x85ebca6b & 0xffff) << 16) & 0xffffffff;
+  h1 ^= h1 >>> 13;
+  h1 = (h1 & 0xffff) * 0xc2b2ae35 + (((h1 >>> 16) * 0xc2b2ae35 & 0xffff) << 16) & 0xffffffff;
+  h1 ^= h1 >>> 16;
+  return h1 >>> 0;
+}
+
+function scheduleWork(callback) {
+  callback();
+}
+function beginWriting(destination) {}
+function writeChunk(destination, chunk) {
+  writeChunkAndReturn(destination, chunk);
+}
+function writeChunkAndReturn(destination, chunk) {
+  return destination.push(chunk);
+}
+function completeWriting(destination) {}
+function close(destination) {
+  destination.push(null);
+}
+function stringToChunk(content) {
+  return content;
+}
+function stringToPrecomputedChunk(content) {
+  return content;
+}
+function clonePrecomputedChunk(chunk) {
+  return chunk;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+  destination.destroy(error);
+}
+
+const assign = Object.assign;
+
+// -----------------------------------------------------------------------------
+const enableFloat = true; // Enables unstable_useMemoCache hook, intended as a compilation target for
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/* eslint-disable max-len */
+
+const ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
+/* eslint-enable max-len */
+
+const ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
+const VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+const illegalAttributeNameCache = {};
+const validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+  if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+    return true;
+  }
+
+  if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+    return false;
+  }
+
+  if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+    validatedAttributeNameCache[attributeName] = true;
+    return true;
+  }
+
+  illegalAttributeNameCache[attributeName] = true;
+
+  return false;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+const unitlessNumbers = new Set(['animationIterationCount', 'aspectRatio', 'borderImageOutset', 'borderImageSlice', 'borderImageWidth', 'boxFlex', 'boxFlexGroup', 'boxOrdinalGroup', 'columnCount', 'columns', 'flex', 'flexGrow', 'flexPositive', 'flexShrink', 'flexNegative', 'flexOrder', 'gridArea', 'gridRow', 'gridRowEnd', 'gridRowSpan', 'gridRowStart', 'gridColumn', 'gridColumnEnd', 'gridColumnSpan', 'gridColumnStart', 'fontWeight', 'lineClamp', 'lineHeight', 'opacity', 'order', 'orphans', 'scale', 'tabSize', 'widows', 'zIndex', 'zoom', 'fillOpacity', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'MozBoxFlexGroup', 'MozLineClamp', 'msAnimationIterationCount', 'msFlex', 'msZoom', 'msFlexGrow', 'msFlexNegative', 'msFlexOrder', 'msFlexPositive', 'msFlexShrink', 'msGridColumn', 'msGridColumnSpan', 'msGridRow', 'msGridRowSpan', 'WebkitAnimationIterationCount', 'WebkitBoxFlex', 'WebKitBoxFlexGroup', 'WebkitBoxOrdinalGroup', 'WebkitColumnCount', 'WebkitColumns', 'WebkitFlex', 'WebkitFlexGrow', 'WebkitFlexPositive', 'WebkitFlexShrink', 'WebkitLineClamp']);
+function isUnitlessNumber (name) {
+  return unitlessNumbers.has(name);
+}
+
+const aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+  return aliases.get(name) || name;
+}
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// code copied and modified from escape-html
+const matchHtmlRegExp = /["'&<>]/;
+/**
+ * Escapes special characters and HTML entities in a given html string.
+ *
+ * @param  {string} string HTML string to escape for later insertion
+ * @return {string}
+ * @public
+ */
+
+function escapeHtml(string) {
+
+  const str = '' + string;
+  const match = matchHtmlRegExp.exec(str);
+
+  if (!match) {
+    return str;
+  }
+
+  let escape;
+  let html = '';
+  let index;
+  let lastIndex = 0;
+
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        // "
+        escape = '&quot;';
+        break;
+
+      case 38:
+        // &
+        escape = '&amp;';
+        break;
+
+      case 39:
+        // '
+        escape = '&#x27;'; // modified from escape-html; used to be '&#39'
+
+        break;
+
+      case 60:
+        // <
+        escape = '&lt;';
+        break;
+
+      case 62:
+        // >
+        escape = '&gt;';
+        break;
+
+      default:
+        continue;
+    }
+
+    if (lastIndex !== index) {
+      html += str.slice(lastIndex, index);
+    }
+
+    lastIndex = index + 1;
+    html += escape;
+  }
+
+  return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+} // end code copied and modified from escape-html
+
+/**
+ * Escapes text to prevent scripting attacks.
+ *
+ * @param {*} text Text value to escape.
+ * @return {string} An escaped string.
+ */
+
+
+function escapeTextForBrowser(text) {
+  if (typeof text === 'boolean' || typeof text === 'number') {
+    // this shortcircuit helps perf for types that we know will never have
+    // special characters, especially given that this function is used often
+    // for numeric dom ids.
+    return '' + text;
+  }
+
+  return escapeHtml(text);
+}
+
+const uppercasePattern = /([A-Z])/g;
+const msPattern = /^ms-/;
+/**
+ * Hyphenates a camelcased CSS property name, for example:
+ *
+ *   > hyphenateStyleName('backgroundColor')
+ *   < "background-color"
+ *   > hyphenateStyleName('MozTransition')
+ *   < "-moz-transition"
+ *   > hyphenateStyleName('msTransition')
+ *   < "-ms-transition"
+ *
+ * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
+ * is converted to `-ms-`.
+ */
+
+function hyphenateStyleName(name) {
+  return name.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern, '-ms-');
+}
+
+function sanitizeURL(url) {
+
+  return url;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+// The build script is at scripts/rollup/generate-inline-fizz-runtime.js.
+// Run `yarn generate-inline-fizz-runtime` to generate.
+const clientRenderBoundary = '$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};';
+const completeBoundary = '$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};';
+const completeBoundaryWithStyles = '$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};';
+const completeSegment = '$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};';
+const formReplaying = 'addEventListener("submit",function(a){if(!a.defaultPrevented){var c=a.target,d=a.submitter,e=c.action,b=d;if(d){var f=d.getAttribute("formAction");null!=f&&(e=f,b=null)}"javascript:throw new Error(\'A React form was unexpectedly submitted.\')"===e&&(a.preventDefault(),b?(a=document.createElement("input"),a.name=b.name,a.value=b.value,b.parentNode.insertBefore(a,b),b=new FormData(c),a.parentNode.removeChild(a)):b=new FormData(c),a=c.getRootNode(),(a.$$reactFormReplay=a.$$reactFormReplay||[]).push(c,\nd,b))}});';
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+// same object across all transitions.
+
+const sharedNotPendingObject = {
+  pending: false,
+  data: null,
+  method: null,
+  action: null
+};
+const NotPending = sharedNotPendingObject;
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+const ReactDOMServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMServerDispatcher;
+} // We make every property of the descriptor optional because it is not a contract that
+const ScriptStreamingFormat = 0;
+const DataStreamingFormat = 1;
+const NothingSent
+/*                      */
+= 0b00000;
+const SentCompleteSegmentFunction
+/*      */
+= 0b00001;
+const SentCompleteBoundaryFunction
+/*     */
+= 0b00010;
+const SentClientRenderFunction
+/*         */
+= 0b00100;
+const SentStyleInsertionFunction
+/*       */
+= 0b01000;
+const SentFormReplayingRuntime
+/*         */
+= 0b10000; // Per request, global state that is not contextual to the rendering subtree.
+// This cannot be resumed and therefore should only contain things that are
+// temporary working state or are never used in the prerender pass.
+// Credentials here are things that affect whether a browser will make a request
+// as well as things that affect which connection the browser will use for that request.
+// We want these to be aligned across preloads and resources because otherwise the preload
+// will be wasted.
+// We investigated whether referrerPolicy should be included here but from experimentation
+// it seems that browsers do not treat this as part of the http cache key and does not affect
+// which connection is used.
+
+const EXISTS = null; // This constant is to mark preloads that have no unique credentials
+// to convey. It should never be checked by identity and we should not
+// assume Preload values in ResumableState equal this value because they
+// will have come from some parsed input.
+
+const PRELOAD_NO_CREDS = [];
+// This is resumable and therefore should be serializable.
+
+
+const dataElementQuotedEnd = stringToPrecomputedChunk('"></template>');
+const startInlineScript = stringToPrecomputedChunk('<script>');
+const endInlineScript = stringToPrecomputedChunk('</script>');
+const startScriptSrc = stringToPrecomputedChunk('<script src="');
+const startModuleSrc = stringToPrecomputedChunk('<script type="module" src="');
+const scriptNonce = stringToPrecomputedChunk('" nonce="');
+const scriptIntegirty = stringToPrecomputedChunk('" integrity="');
+const scriptCrossOrigin = stringToPrecomputedChunk('" crossorigin="');
+const endAsyncScript = stringToPrecomputedChunk('" async=""></script>');
+/**
+ * This escaping function is designed to work with bootstrapScriptContent and importMap only.
+ * because we know we are escaping the entire script. We can avoid for instance
+ * escaping html comment string sequences that are valid javascript as well because
+ * if there are no sebsequent <script sequences the html parser will never enter
+ * script data double escaped state (see: https://www.w3.org/TR/html53/syntax.html#script-data-double-escaped-state)
+ *
+ * While untrusted script content should be made safe before using this api it will
+ * ensure that the script cannot be early terminated or never terminated state
+ */
+
+function escapeBootstrapAndImportMapScriptContent(scriptText) {
+
+  return ('' + scriptText).replace(scriptRegex, scriptReplacer);
+}
+
+const scriptRegex = /(<\/|<)(s)(cript)/gi;
+
+const scriptReplacer = (match, prefix, s, suffix) => "" + prefix + (s === 's' ? '\\u0073' : '\\u0053') + suffix;
+
+const importMapScriptStart = stringToPrecomputedChunk('<script type="importmap">');
+const importMapScriptEnd = stringToPrecomputedChunk('</script>'); // Since we store headers as strings we deal with their length in utf16 code units
+// rather than visual characters or the utf8 encoding that is used for most binary
+// serialization. Some common HTTP servers only allow for headers to be 4kB in length.
+// We choose a default length that is likely to be well under this already limited length however
+// pathological cases may still cause the utf-8 encoding of the headers to approach this limit.
+// It should also be noted that this maximum is a soft maximum. we have not reached the limit we will
+// allow one more header to be captured which means in practice if the limit is approached it will be exceeded
+
+const DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS = 2000; // Allows us to keep track of what we've already written so we can refer back to it.
+// if passed externalRuntimeConfig and the enableFizzExternalRuntime feature flag
+// is set, the server will send instructions via data attributes (instead of inline scripts)
+
+function createRenderState$1(resumableState, nonce, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
+  const inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
+  const idPrefix = resumableState.idPrefix;
+  const bootstrapChunks = [];
+  let externalRuntimeScript = null;
+  const bootstrapScriptContent = resumableState.bootstrapScriptContent,
+        bootstrapScripts = resumableState.bootstrapScripts,
+        bootstrapModules = resumableState.bootstrapModules;
+
+  if (bootstrapScriptContent !== undefined) {
+    bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapAndImportMapScriptContent(bootstrapScriptContent)), endInlineScript);
+  }
+
+  {
+
+    if (externalRuntimeConfig !== undefined) {
+      if (typeof externalRuntimeConfig === 'string') {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig,
+          async: true,
+          integrity: undefined,
+          nonce: nonce
+        });
+      } else {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig.src,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig.src,
+          async: true,
+          integrity: externalRuntimeConfig.integrity,
+          nonce: nonce
+        });
+      }
+    }
+  }
+
+  const importMapChunks = [];
+
+  if (importMap !== undefined) {
+    const map = importMap;
+    importMapChunks.push(importMapScriptStart);
+    importMapChunks.push(stringToChunk(escapeBootstrapAndImportMapScriptContent(JSON.stringify(map))));
+    importMapChunks.push(importMapScriptEnd);
+  }
+
+  const headers = onHeaders ? {
+    preconnects: '',
+    fontPreloads: '',
+    highImagePreloads: '',
+    remainingCapacity: typeof maxHeadersLength === 'number' ? maxHeadersLength : DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS
+  } : null;
+  const renderState = {
+    placeholderPrefix: stringToPrecomputedChunk(idPrefix + 'P:'),
+    segmentPrefix: stringToPrecomputedChunk(idPrefix + 'S:'),
+    boundaryPrefix: stringToPrecomputedChunk(idPrefix + 'B:'),
+    startInlineScript: inlineScriptWithNonce,
+    htmlChunks: null,
+    headChunks: null,
+    externalRuntimeScript: externalRuntimeScript,
+    bootstrapChunks: bootstrapChunks,
+    onHeaders,
+    headers,
+    resets: {
+      font: {},
+      dns: {},
+      connect: {
+        default: {},
+        anonymous: {},
+        credentials: {}
+      },
+      image: {},
+      style: {}
+    },
+    charsetChunks: [],
+    preconnectChunks: [],
+    importMapChunks,
+    preloadChunks: [],
+    hoistableChunks: [],
+    // cleared on flush
+    preconnects: new Set(),
+    fontPreloads: new Set(),
+    highImagePreloads: new Set(),
+    // usedImagePreloads: new Set(),
+    styles: new Map(),
+    bootstrapScripts: new Set(),
+    scripts: new Set(),
+    bulkPreloads: new Set(),
+    preloads: {
+      images: new Map(),
+      stylesheets: new Map(),
+      scripts: new Map(),
+      moduleScripts: new Map()
+    },
+    nonce,
+    // like a module global for currently rendering boundary
+    boundaryResources: null,
+    stylesToHoist: false
+  };
+
+  if (bootstrapScripts !== undefined) {
+    for (let i = 0; i < bootstrapScripts.length; i++) {
+      const scriptConfig = bootstrapScripts[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'preload',
+        as: 'script',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startScriptSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  if (bootstrapModules !== undefined) {
+    for (let i = 0; i < bootstrapModules.length; i++) {
+      const scriptConfig = bootstrapModules[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'modulepreload',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startModuleSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  return renderState;
+}
+function createResumableState(identifierPrefix, externalRuntimeConfig, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
+  const idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
+  let streamingFormat = ScriptStreamingFormat;
+
+  {
+    if (externalRuntimeConfig !== undefined) {
+      streamingFormat = DataStreamingFormat;
+    }
+  }
+
+  return {
+    idPrefix: idPrefix,
+    nextFormID: 0,
+    streamingFormat,
+    bootstrapScriptContent,
+    bootstrapScripts,
+    bootstrapModules,
+    instructions: NothingSent,
+    hasBody: false,
+    hasHtml: false,
+    // @TODO add bootstrap script to implicit preloads
+    // persistent
+    unknownResources: {},
+    dnsResources: {},
+    connectResources: {
+      default: {},
+      anonymous: {},
+      credentials: {}
+    },
+    imageResources: {},
+    styleResources: {},
+    scriptResources: {},
+    moduleUnknownResources: {},
+    moduleScriptResources: {}
+  };
+}
+// modes. We only include the variants as they matter for the sake of our purposes.
+// We don't actually provide the namespace therefore we use constants instead of the string.
+
+const ROOT_HTML_MODE = 0; // Used for the root most element tag.
+// We have a less than HTML_HTML_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const HTML_HTML_MODE = 1; // Used for the <html> if it is at the top level.
+
+const HTML_MODE = 2;
+const SVG_MODE = 3;
+const MATHML_MODE = 4;
+const HTML_TABLE_MODE = 5;
+const HTML_TABLE_BODY_MODE = 6;
+const HTML_TABLE_ROW_MODE = 7;
+const HTML_COLGROUP_MODE = 8; // We have a greater than HTML_TABLE_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const NO_SCOPE =
+/*         */
+0b00;
+const NOSCRIPT_SCOPE =
+/*   */
+0b01;
+const PICTURE_SCOPE =
+/*    */
+0b10; // Lets us keep track of contextual state and pick it back up after suspending.
+
+function createFormatContext(insertionMode, selectedValue, tagScope) {
+  return {
+    insertionMode,
+    selectedValue,
+    tagScope
+  };
+}
+
+function createRootFormatContext(namespaceURI) {
+  const insertionMode = namespaceURI === 'http://www.w3.org/2000/svg' ? SVG_MODE : namespaceURI === 'http://www.w3.org/1998/Math/MathML' ? MATHML_MODE : ROOT_HTML_MODE;
+  return createFormatContext(insertionMode, null, NO_SCOPE);
+}
+function getChildFormatContext(parentContext, type, props) {
+  switch (type) {
+    case 'noscript':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | NOSCRIPT_SCOPE);
+
+    case 'select':
+      return createFormatContext(HTML_MODE, props.value != null ? props.value : props.defaultValue, parentContext.tagScope);
+
+    case 'svg':
+      return createFormatContext(SVG_MODE, null, parentContext.tagScope);
+
+    case 'picture':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | PICTURE_SCOPE);
+
+    case 'math':
+      return createFormatContext(MATHML_MODE, null, parentContext.tagScope);
+
+    case 'foreignObject':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    // Table parents are special in that their children can only be created at all if they're
+    // wrapped in a table parent. So we need to encode that we're entering this mode.
+
+    case 'table':
+      return createFormatContext(HTML_TABLE_MODE, null, parentContext.tagScope);
+
+    case 'thead':
+    case 'tbody':
+    case 'tfoot':
+      return createFormatContext(HTML_TABLE_BODY_MODE, null, parentContext.tagScope);
+
+    case 'colgroup':
+      return createFormatContext(HTML_COLGROUP_MODE, null, parentContext.tagScope);
+
+    case 'tr':
+      return createFormatContext(HTML_TABLE_ROW_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode >= HTML_TABLE_MODE) {
+    // Whatever tag this was, it wasn't a table parent or other special parent, so we must have
+    // entered plain HTML again.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode === ROOT_HTML_MODE) {
+    if (type === 'html') {
+      // We've emitted the root and is now in <html> mode.
+      return createFormatContext(HTML_HTML_MODE, null, parentContext.tagScope);
+    } else {
+      // We've emitted the root and is now in plain HTML mode.
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    }
+  } else if (parentContext.insertionMode === HTML_HTML_MODE) {
+    // We've emitted the document element and is now in plain HTML mode.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  return parentContext;
+}
+function makeId(resumableState, treeId, localId) {
+  const idPrefix = resumableState.idPrefix;
+  let id = ':' + idPrefix + 'R' + treeId; // Unless this is the first id at this level, append a number at the end
+  // that represents the position of this useId hook among all the useId
+  // hooks for this fiber.
+
+  if (localId > 0) {
+    id += 'H' + localId.toString(32);
+  }
+
+  return id + ':';
+}
+
+function encodeHTMLTextNode(text) {
+  return escapeTextForBrowser(text);
+}
+
+const textSeparator = stringToPrecomputedChunk('<!-- -->');
+function pushTextInstance$1(target, text, renderState, textEmbedded) {
+  if (text === '') {
+    // Empty text doesn't have a DOM node representation and the hydration is aware of this.
+    return textEmbedded;
+  }
+
+  if (textEmbedded) {
+    target.push(textSeparator);
+  }
+
+  target.push(stringToChunk(encodeHTMLTextNode(text)));
+  return true;
+} // Called when Fizz is done with a Segment. Currently the only purpose is to conditionally
+// emit a text separator when we don't know for sure it is safe to omit
+
+function pushSegmentFinale$1(target, renderState, lastPushedText, textEmbedded) {
+  if (lastPushedText && textEmbedded) {
+    target.push(textSeparator);
+  }
+}
+const styleNameCache = new Map();
+
+function processStyleName(styleName) {
+  const chunk = styleNameCache.get(styleName);
+
+  if (chunk !== undefined) {
+    return chunk;
+  }
+
+  const result = stringToPrecomputedChunk(escapeTextForBrowser(hyphenateStyleName(styleName)));
+  styleNameCache.set(styleName, result);
+  return result;
+}
+
+const styleAttributeStart = stringToPrecomputedChunk(' style="');
+const styleAssign = stringToPrecomputedChunk(':');
+const styleSeparator = stringToPrecomputedChunk(';');
+
+function pushStyleAttribute(target, style) {
+  if (typeof style !== 'object') {
+    throw new Error('The `style` prop expects a mapping from style properties to values, ' + "not a string. For example, style={{marginRight: spacing + 'em'}} when " + 'using JSX.');
+  }
+
+  let isFirst = true;
+
+  for (const styleName in style) {
+    if (!hasOwnProperty.call(style, styleName)) {
+      continue;
+    } // If you provide unsafe user data here they can inject arbitrary CSS
+    // which may be problematic (I couldn't repro this):
+    // https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet
+    // http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/
+    // This is not an XSS hole but instead a potential CSS injection issue
+    // which has lead to a greater discussion about how we're going to
+    // trust URLs moving forward. See #2115901
+
+
+    const styleValue = style[styleName];
+
+    if (styleValue == null || typeof styleValue === 'boolean' || styleValue === '') {
+      // TODO: We used to set empty string as a style with an empty value. Does that ever make sense?
+      continue;
+    }
+
+    let nameChunk;
+    let valueChunk;
+    const isCustomProperty = styleName.indexOf('--') === 0;
+
+    if (isCustomProperty) {
+      nameChunk = stringToChunk(escapeTextForBrowser(styleName));
+
+      valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+    } else {
+
+      nameChunk = processStyleName(styleName);
+
+      if (typeof styleValue === 'number') {
+        if (styleValue !== 0 && !isUnitlessNumber(styleName)) {
+          valueChunk = stringToChunk(styleValue + 'px'); // Presumes implicit 'px' suffix for unitless numbers
+        } else {
+          valueChunk = stringToChunk('' + styleValue);
+        }
+      } else {
+
+        valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+      }
+    }
+
+    if (isFirst) {
+      isFirst = false; // If it's first, we don't need any separators prefixed.
+
+      target.push(styleAttributeStart, nameChunk, styleAssign, valueChunk);
+    } else {
+      target.push(styleSeparator, nameChunk, styleAssign, valueChunk);
+    }
+  }
+
+  if (!isFirst) {
+    target.push(attributeEnd);
+  }
+}
+
+const attributeSeparator = stringToPrecomputedChunk(' ');
+const attributeAssign = stringToPrecomputedChunk('="');
+const attributeEnd = stringToPrecomputedChunk('"');
+const attributeEmptyString = stringToPrecomputedChunk('=""');
+
+function pushBooleanAttribute(target, name, value) // not null or undefined
+{
+  if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+    target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+  }
+}
+
+function pushStringAttribute(target, name, value) // not null or undefined
+{
+  if (typeof value !== 'function' && typeof value !== 'symbol' && typeof value !== 'boolean') {
+    target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+  }
+}
+
+function makeFormFieldPrefix(resumableState) {
+  const id = resumableState.nextFormID++;
+  return resumableState.idPrefix + id;
+} // Since this will likely be repeated a lot in the HTML, we use a more concise message
+// than on the client and hopefully it's googleable.
+
+
+const actionJavaScriptURL = stringToPrecomputedChunk(escapeTextForBrowser( // eslint-disable-next-line no-script-url
+"javascript:throw new Error('A React form was unexpectedly submitted.')"));
+const startHiddenInputChunk = stringToPrecomputedChunk('<input type="hidden"');
+
+function pushAdditionalFormField(value, key) {
+  const target = this;
+  target.push(startHiddenInputChunk);
+
+  if (typeof value !== 'string') {
+    throw new Error('File/Blob fields are not yet supported in progressive forms. ' + 'It probably means you are closing over binary data or FormData in a Server Action.');
+  }
+
+  pushStringAttribute(target, 'name', key);
+  pushStringAttribute(target, 'value', value);
+  target.push(endOfStartTagSelfClosing);
+}
+
+function pushAdditionalFormFields(target, formData) {
+  if (formData !== null) {
+    // $FlowFixMe[prop-missing]: FormData has forEach.
+    formData.forEach(pushAdditionalFormField, target);
+  }
+}
+
+function pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name) {
+  let formData = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      name = customFields.name;
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('formAction'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      name = null;
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (name != null) {
+    pushAttribute(target, 'name', name);
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'formAction', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'formEncType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'formMethod', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'formTarget', formTarget);
+  }
+
+  return formData;
+}
+
+function pushAttribute(target, name, value) // not null or undefined
+{
+  switch (name) {
+    // These are very common props and therefore are in the beginning of the switch.
+    // TODO: aria-label is a very common prop but allows booleans so is not like the others
+    // but should ideally go in this list too.
+    case 'className':
+      {
+        pushStringAttribute(target, 'class', value);
+        break;
+      }
+
+    case 'tabIndex':
+      {
+        pushStringAttribute(target, 'tabindex', value);
+        break;
+      }
+
+    case 'dir':
+    case 'role':
+    case 'viewBox':
+    case 'width':
+    case 'height':
+      {
+        pushStringAttribute(target, name, value);
+        break;
+      }
+
+    case 'style':
+      {
+        pushStyleAttribute(target, value);
+        return;
+      }
+
+    case 'src':
+    case 'href':
+      {
+        {
+          if (value === '') {
+
+            return;
+          }
+        }
+      }
+    // Fall through to the last case which shouldn't remove empty strings.
+
+    case 'action':
+    case 'formAction':
+      {
+        // TODO: Consider only special casing these for each tag.
+        if (value == null || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'defaultValue':
+    case 'defaultChecked': // These shouldn't be set as attributes on generic HTML elements.
+
+    case 'innerHTML': // Must use dangerouslySetInnerHTML instead.
+
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+      // Ignored. These are built-in to React on the client.
+      return;
+
+    case 'autoFocus':
+    case 'multiple':
+    case 'muted':
+      {
+        pushBooleanAttribute(target, name.toLowerCase(), value);
+        return;
+      }
+
+    case 'xlinkHref':
+      {
+        if (typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk('xlink:href'), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'contentEditable':
+    case 'spellCheck':
+    case 'draggable':
+    case 'value':
+    case 'autoReverse':
+    case 'externalResourcesRequired':
+    case 'focusable':
+    case 'preserveAlpha':
+      {
+        // Booleanish String
+        // These are "enumerated" attributes that accept "true" and "false".
+        // In React, we let users pass `true` and `false` even though technically
+        // these aren't boolean attributes (they are coerced to strings).
+        if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'allowFullScreen':
+    case 'async':
+    case 'autoPlay':
+    case 'controls':
+    case 'default':
+    case 'defer':
+    case 'disabled':
+    case 'disablePictureInPicture':
+    case 'disableRemotePlayback':
+    case 'formNoValidate':
+    case 'hidden':
+    case 'loop':
+    case 'noModule':
+    case 'noValidate':
+    case 'open':
+    case 'playsInline':
+    case 'readOnly':
+    case 'required':
+    case 'reversed':
+    case 'scoped':
+    case 'seamless':
+    case 'itemScope':
+      {
+        // Boolean
+        if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        }
+
+        return;
+      }
+
+    case 'capture':
+    case 'download':
+      {
+        // Overloaded Boolean
+        if (value === true) {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        } else if (value === false) ; else if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'cols':
+    case 'rows':
+    case 'size':
+    case 'span':
+      {
+        // These are HTML attributes that must be positive numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value) && value >= 1) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'rowSpan':
+    case 'start':
+      {
+        // These are HTML attributes that must be numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value)) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'xlinkActuate':
+      pushStringAttribute(target, 'xlink:actuate', value);
+      return;
+
+    case 'xlinkArcrole':
+      pushStringAttribute(target, 'xlink:arcrole', value);
+      return;
+
+    case 'xlinkRole':
+      pushStringAttribute(target, 'xlink:role', value);
+      return;
+
+    case 'xlinkShow':
+      pushStringAttribute(target, 'xlink:show', value);
+      return;
+
+    case 'xlinkTitle':
+      pushStringAttribute(target, 'xlink:title', value);
+      return;
+
+    case 'xlinkType':
+      pushStringAttribute(target, 'xlink:type', value);
+      return;
+
+    case 'xmlBase':
+      pushStringAttribute(target, 'xml:base', value);
+      return;
+
+    case 'xmlLang':
+      pushStringAttribute(target, 'xml:lang', value);
+      return;
+
+    case 'xmlSpace':
+      pushStringAttribute(target, 'xml:space', value);
+      return;
+
+    default:
+      if ( // shouldIgnoreAttribute
+      // We have already filtered out null/undefined and reserved words.
+      name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+        return;
+      }
+
+      const attributeName = getAttributeAlias(name);
+
+      if (isAttributeNameSafe(attributeName)) {
+        // shouldRemoveAttribute
+        switch (typeof value) {
+          case 'function':
+          case 'symbol':
+            // eslint-disable-line
+            return;
+
+          case 'boolean':
+            {
+              const prefix = attributeName.toLowerCase().slice(0, 5);
+
+              if (prefix !== 'data-' && prefix !== 'aria-') {
+                return;
+              }
+            }
+        }
+
+        target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+      }
+
+  }
+}
+
+const endOfStartTag = stringToPrecomputedChunk('>');
+const endOfStartTagSelfClosing = stringToPrecomputedChunk('/>');
+
+function pushInnerHTML(target, innerHTML, children) {
+  if (innerHTML != null) {
+    if (children != null) {
+      throw new Error('Can only set one of `children` or `props.dangerouslySetInnerHTML`.');
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw new Error('`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. ' + 'Please visit https://reactjs.org/link/dangerously-set-inner-html ' + 'for more information.');
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+
+      target.push(stringToChunk('' + html));
+    }
+  }
+} // TODO: Move these to RenderState so that we warn for every request.
+
+function pushStartSelect(target, props) {
+
+  target.push(startChunkForTag('select'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          // TODO: This doesn't really make sense for select since it can't use the controlled
+          // value in the innerHTML.
+          innerHTML = propValue;
+          break;
+
+        case 'defaultValue':
+        case 'value':
+          // These are set on the Context instead and applied to the nested options.
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+function flattenOptionChildren(children) {
+  let content = ''; // Flatten children and warn if they aren't strings or numbers;
+  // invalid types are ignored.
+
+  React.Children.forEach(children, function (child) {
+    if (child == null) {
+      return;
+    }
+
+    content += child;
+  });
+  return content;
+}
+
+const selectedMarkerAttribute = stringToPrecomputedChunk(' selected=""');
+
+function pushStartOption(target, props, formatContext) {
+  const selectedValue = formatContext.selectedValue;
+  target.push(startChunkForTag('option'));
+  let children = null;
+  let value = null;
+  let selected = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'selected':
+          // ignore
+          selected = propValue;
+
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+        // We intentionally fallthrough to also set the attribute on the node.
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (selectedValue != null) {
+    let stringValue;
+
+    if (value !== null) {
+
+      stringValue = '' + value;
+    } else {
+
+      stringValue = flattenOptionChildren(children);
+    }
+
+    if (isArray(selectedValue)) {
+      // multiple
+      for (let i = 0; i < selectedValue.length; i++) {
+
+        const v = '' + selectedValue[i];
+
+        if (v === stringValue) {
+          target.push(selectedMarkerAttribute);
+          break;
+        }
+      }
+    } else {
+
+      if ('' + selectedValue === stringValue) {
+        target.push(selectedMarkerAttribute);
+      }
+    }
+  } else if (selected) {
+    target.push(selectedMarkerAttribute);
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const formReplayingRuntimeScript = stringToPrecomputedChunk(formReplaying);
+
+function injectFormReplayingRuntime(resumableState, renderState) {
+  // If we haven't sent it yet, inject the runtime that tracks submitted JS actions
+  // for later replaying by Fiber. If we use an external runtime, we don't need
+  // to emit anything. It's always used.
+  if ((resumableState.instructions & SentFormReplayingRuntime) === NothingSent && (!renderState.externalRuntimeScript)) {
+    resumableState.instructions |= SentFormReplayingRuntime;
+    renderState.bootstrapChunks.unshift(renderState.startInlineScript, formReplayingRuntimeScript, endInlineScript);
+  }
+}
+
+const formStateMarkerIsMatching = stringToPrecomputedChunk('<!--F!-->');
+const formStateMarkerIsNotMatching = stringToPrecomputedChunk('<!--F-->');
+function pushFormStateMarkerIsMatching(target) {
+  target.push(formStateMarkerIsMatching);
+}
+function pushFormStateMarkerIsNotMatching(target) {
+  target.push(formStateMarkerIsNotMatching);
+}
+
+function pushStartForm(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('form'));
+  let children = null;
+  let innerHTML = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'action':
+          formAction = propValue;
+          break;
+
+        case 'encType':
+          formEncType = propValue;
+          break;
+
+        case 'method':
+          formMethod = propValue;
+          break;
+
+        case 'target':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  let formData = null;
+  let formActionName = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+      formActionName = customFields.name;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('action'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'action', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'encType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'method', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'target', formTarget);
+  }
+
+  target.push(endOfStartTag);
+
+  if (formActionName !== null) {
+    target.push(startHiddenInputChunk);
+    pushStringAttribute(target, 'name', formActionName);
+    target.push(endOfStartTagSelfClosing);
+    pushAdditionalFormFields(target, formData);
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushInput(target, props, resumableState, renderState) {
+
+  target.push(startChunkForTag('input'));
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+  let value = null;
+  let defaultValue = null;
+  let checked = null;
+  let defaultChecked = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('input' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        case 'defaultChecked':
+          defaultChecked = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'checked':
+          checked = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+
+  if (checked !== null) {
+    pushBooleanAttribute(target, 'checked', checked);
+  } else if (defaultChecked !== null) {
+    pushBooleanAttribute(target, 'checked', defaultChecked);
+  }
+
+  if (value !== null) {
+    pushAttribute(target, 'value', value);
+  } else if (defaultValue !== null) {
+    pushAttribute(target, 'value', defaultValue);
+  }
+
+  target.push(endOfStartTagSelfClosing); // We place any additional hidden form fields after the input.
+
+  pushAdditionalFormFields(target, formData);
+  return null;
+}
+
+function pushStartButton(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('button'));
+  let children = null;
+  let innerHTML = null;
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+  target.push(endOfStartTag); // We place any additional hidden form fields we need to include inside the button itself.
+
+  pushAdditionalFormFields(target, formData);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartTextArea(target, props) {
+
+  target.push(startChunkForTag('textarea'));
+  let value = null;
+  let defaultValue = null;
+  let children = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          throw new Error('`dangerouslySetInnerHTML` does not make sense on <textarea>.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (value === null && defaultValue !== null) {
+    value = defaultValue;
+  }
+
+  target.push(endOfStartTag); // TODO (yungsters): Remove support for children content in <textarea>.
+
+  if (children != null) {
+
+    if (value != null) {
+      throw new Error('If you supply `defaultValue` on a <textarea>, do not pass children.');
+    }
+
+    if (isArray(children)) {
+      if (children.length > 1) {
+        throw new Error('<textarea> can only have at most one child.');
+      } // TODO: remove the coercion and the DEV check below because it will
+
+      value = '' + children[0];
+    }
+
+    value = '' + children;
+  }
+
+  if (typeof value === 'string' && value[0] === '\n') {
+    // text/html ignores the first character in these tags if it's a newline
+    // Prefer to break application/xml over text/html (for now) by adding
+    // a newline specifically to get eaten by the parser. (Alternately for
+    // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+    // \r is normalized out by HTMLTextAreaElement#value.)
+    // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+    // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+    // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+    // See: Parsing of "textarea" "listing" and "pre" elements
+    //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+    target.push(leadingNewline);
+  } // ToString and push directly instead of recurse over children.
+  // We don't really support complex children in the value anyway.
+  // This also currently avoids a trailing comment node which breaks textarea.
+
+
+  if (value !== null) {
+
+    target.push(stringToChunk(encodeHTMLTextNode('' + value)));
+  }
+
+  return null;
+}
+
+function pushMeta(target, props, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      return pushSelfClosing(target, props, 'meta');
+    } else {
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      if (typeof props.charSet === 'string') {
+        return pushSelfClosing(renderState.charsetChunks, props, 'meta');
+      } else if (props.name === 'viewport') {
+        // "viewport" isn't related to preconnect but it has the right priority
+        return pushSelfClosing(renderState.preconnectChunks, props, 'meta');
+      } else {
+        return pushSelfClosing(renderState.hoistableChunks, props, 'meta');
+      }
+    }
+  }
+}
+
+function pushLink(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const rel = props.rel;
+    const href = props.href;
+    const precedence = props.precedence;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof rel !== 'string' || typeof href !== 'string' || href === '') {
+
+      pushLinkImpl(target, props);
+      return null;
+    }
+
+    if (props.rel === 'stylesheet') {
+      // This <link> may hoistable as a Stylesheet Resource, otherwise it will emit in place
+      const key = getResourceKey(href);
+
+      if (typeof precedence !== 'string' || props.disabled != null || props.onLoad || props.onError) {
+
+        return pushLinkImpl(target, props);
+      } else {
+        // This stylesheet refers to a Resource and we create a new one if necessary
+        let styleQueue = renderState.styles.get(precedence);
+        const hasKey = resumableState.styleResources.hasOwnProperty(key);
+        const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+        if (resourceState !== EXISTS) {
+          // We are going to create this resource now so it is marked as Exists
+          resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+          // to create a StyleQueue
+
+          if (!styleQueue) {
+            styleQueue = {
+              precedence: stringToChunk(escapeTextForBrowser(precedence)),
+              rules: [],
+              hrefs: [],
+              sheets: new Map()
+            };
+            renderState.styles.set(precedence, styleQueue);
+          }
+
+          const resource = {
+            state: PENDING$1,
+            props: stylesheetPropsFromRawProps(props)
+          };
+
+          if (resourceState) {
+            // When resourceState is truty it is a Preload state. We cast it for clarity
+            const preloadState = resourceState;
+
+            if (preloadState.length === 2) {
+              adoptPreloadCredentials(resource.props, preloadState);
+            }
+
+            const preloadResource = renderState.preloads.stylesheets.get(key);
+
+            if (preloadResource && preloadResource.length > 0) {
+              // The Preload for this resource was created in this render pass and has not flushed yet so
+              // we need to clear it to avoid it flushing.
+              preloadResource.length = 0;
+            } else {
+              // Either the preload resource from this render already flushed in this render pass
+              // or the preload flushed in a prior pass (prerender). In either case we need to mark
+              // this resource as already having been preloaded.
+              resource.state = PRELOADED;
+            }
+          } // We add the newly created resource to our StyleQueue and if necessary
+          // track the resource with the currently rendering boundary
+
+
+          styleQueue.sheets.set(key, resource);
+
+          if (renderState.boundaryResources) {
+            renderState.boundaryResources.stylesheets.add(resource);
+          }
+        } else {
+          // We need to track whether this boundary should wait on this resource or not.
+          // Typically this resource should always exist since we either had it or just created
+          // it. However, it's possible when you resume that the style has already been emitted
+          // and then it wouldn't be recreated in the RenderState and there's no need to track
+          // it again since we should've hoisted it to the shell already.
+          if (styleQueue) {
+            const resource = styleQueue.sheets.get(key);
+
+            if (resource) {
+              if (renderState.boundaryResources) {
+                renderState.boundaryResources.stylesheets.add(resource);
+              }
+            }
+          }
+        }
+
+        if (textEmbedded) {
+          // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+          // to be safe and assume text will follow by inserting a textSeparator
+          target.push(textSeparator);
+        }
+
+        return null;
+      }
+    } else if (props.onLoad || props.onError) {
+      // When using load handlers we cannot hoist and need to emit links in place
+      return pushLinkImpl(target, props);
+    } else {
+      // We can hoist this link so we may need to emit a text separator.
+      // @TODO refactor text separators so we don't have to defensively add
+      // them when we don't end up emitting a tag as a result of pushStartInstance
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      switch (props.rel) {
+        case 'preconnect':
+        case 'dns-prefetch':
+          return pushLinkImpl(renderState.preconnectChunks, props);
+
+        case 'preload':
+          return pushLinkImpl(renderState.preloadChunks, props);
+
+        default:
+          return pushLinkImpl(renderState.hoistableChunks, props);
+      }
+    }
+  }
+}
+
+function pushLinkImpl(target, props) {
+  target.push(startChunkForTag('link'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStyle(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+
+  {
+    const precedence = props.precedence;
+    const href = props.href;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof precedence !== 'string' || typeof href !== 'string' || href === '') {
+      // This style tag is not able to be turned into a Style Resource
+      return pushStyleImpl(target, props);
+    }
+
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS;
+
+      if (!styleQueue) {
+        // This is the first time we've encountered this precedence we need
+        // to create a StyleQueue.
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [stringToChunk(escapeTextForBrowser(href))],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      } else {
+        // We have seen this precedence before and need to track this href
+        styleQueue.hrefs.push(stringToChunk(escapeTextForBrowser(href)));
+      }
+
+      pushStyleContents(styleQueue.rules, props);
+    }
+
+    if (styleQueue) {
+      // We need to track whether this boundary should wait on this resource or not.
+      // Typically this resource should always exist since we either had it or just created
+      // it. However, it's possible when you resume that the style has already been emitted
+      // and then it wouldn't be recreated in the RenderState and there's no need to track
+      // it again since we should've hoisted it to the shell already.
+      if (renderState.boundaryResources) {
+        renderState.boundaryResources.styles.add(styleQueue);
+      }
+    }
+
+    if (textEmbedded) {
+      // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+  }
+}
+
+function pushStyleImpl(target, props) {
+  target.push(startChunkForTag('style'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('style'));
+  return null;
+}
+
+function pushStyleContents(target, props) {
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+      }
+    }
+  }
+
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  return;
+}
+
+function pushImg(target, props, resumableState, renderState, pictureTagInScope) {
+  const src = props.src,
+        srcSet = props.srcSet;
+
+  if (props.loading !== 'lazy' && (src || srcSet) && (typeof src === 'string' || src == null) && (typeof srcSet === 'string' || srcSet == null) && props.fetchPriority !== 'low' && pictureTagInScope === false && // We exclude data URIs in src and srcSet since these should not be preloaded
+  !(typeof src === 'string' && src[4] === ':' && (src[0] === 'd' || src[0] === 'D') && (src[1] === 'a' || src[1] === 'A') && (src[2] === 't' || src[2] === 'T') && (src[3] === 'a' || src[3] === 'A')) && !(typeof srcSet === 'string' && srcSet[4] === ':' && (srcSet[0] === 'd' || srcSet[0] === 'D') && (srcSet[1] === 'a' || srcSet[1] === 'A') && (srcSet[2] === 't' || srcSet[2] === 'T') && (srcSet[3] === 'a' || srcSet[3] === 'A'))) {
+    // We have a suspensey image and ought to preload it to optimize the loading of display blocking
+    // resumableState.
+    const sizes = typeof props.sizes === 'string' ? props.sizes : undefined;
+    const key = getImageResourceKey(src, srcSet, sizes);
+    const promotablePreloads = renderState.preloads.images;
+    let resource = promotablePreloads.get(key);
+
+    if (resource) {
+      // We consider whether this preload can be promoted to higher priority flushing queue.
+      // The only time a resource will exist here is if it was created during this render
+      // and was not already in the high priority queue.
+      if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+        // Delete the resource from the map since we are promoting it and don't want to
+        // reenter this branch in a second pass for duplicate img hrefs.
+        promotablePreloads.delete(key); // $FlowFixMe - Flow should understand that this is a Resource if the condition was true
+
+        renderState.highImagePreloads.add(resource);
+      }
+    } else if (!resumableState.imageResources.hasOwnProperty(key)) {
+      // We must construct a new preload resource
+      resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+      const crossOrigin = getCrossOriginString(props.crossOrigin);
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // this is a hueristic similar to capping element preloads to 10 unless explicitly
+      // fetchPriority="high". We use length here which means it will fit fewer images when
+      // the urls are long and more when short. arguably byte size is a better hueristic because
+      // it directly translates to how much we send down before content is actually seen.
+      // We could unify the counts and also make it so the total is tracked regardless of
+      // flushing output but since the headers are likely to be go earlier than content
+      // they don't really conflict so for now I've kept them separate
+      props.fetchPriority === 'high' || headers.highImagePreloads.length < 500) && ( // We manually construct the options for the preload only from strings. We don't want to pollute
+      // the params list with arbitrary props and if we copied everything over as it we might get
+      // coercion errors. We have checks for this in Dev but it seems safer to just only accept values
+      // that are strings
+      header = getPreloadAsHeader(src, 'image', {
+        imageSrcSet: props.srcSet,
+        imageSizes: props.sizes,
+        crossOrigin,
+        integrity: props.integrity,
+        nonce: props.nonce,
+        type: props.type,
+        fetchPriority: props.fetchPriority,
+        referrerPolicy: props.refererPolicy
+      }), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // If we postpone in the shell we will still emit this preload so we track
+        // it to make sure we don't reset it.
+        renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+        if (headers.highImagePreloads) {
+          headers.highImagePreloads += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.highImagePreloads += header;
+      } else {
+        resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preload',
+          as: 'image',
+          // There is a bug in Safari where imageSrcSet is not respected on preload links
+          // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+          // This harms older browers that do not support imageSrcSet by making their preloads not work
+          // but this population is shrinking fast and is already small so we accept this tradeoff.
+          href: srcSet ? undefined : src,
+          imageSrcSet: srcSet,
+          imageSizes: sizes,
+          crossOrigin: crossOrigin,
+          integrity: props.integrity,
+          type: props.type,
+          fetchPriority: props.fetchPriority,
+          referrerPolicy: props.referrerPolicy
+        });
+
+        if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+          renderState.highImagePreloads.add(resource);
+        } else {
+          renderState.bulkPreloads.add(resource); // We can bump the priority up if the same img is rendered later
+          // with fetchPriority="high"
+
+          promotablePreloads.set(key, resource);
+        }
+      }
+    }
+  }
+
+  return pushSelfClosing(target, props, 'img');
+}
+
+function pushSelfClosing(target, props, tag) {
+  target.push(startChunkForTag(tag));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error(tag + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStartMenuItem(target, props) {
+  target.push(startChunkForTag('menuitem'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('menuitems cannot have `children` nor `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  return null;
+}
+
+function pushTitle(target, props, renderState, insertionMode, noscriptTagInScope) {
+
+  {
+    if (insertionMode !== SVG_MODE && !noscriptTagInScope && props.itemProp == null) {
+      pushTitleImpl(renderState.hoistableChunks, props);
+      return null;
+    } else {
+      return pushTitleImpl(target, props);
+    }
+  }
+}
+
+function pushTitleImpl(target, props) {
+  target.push(startChunkForTag('title'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('title'));
+  return null;
+}
+
+function pushStartHead(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode < HTML_MODE && renderState.headChunks === null) {
+      // This <head> is the Document.head and should be part of the preamble
+      renderState.headChunks = [];
+      return pushStartGenericElement(renderState.headChunks, props, 'head');
+    } else {
+      // This <head> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'head');
+    }
+  }
+}
+
+function pushStartHtml(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode === ROOT_HTML_MODE && renderState.htmlChunks === null) {
+      // This <html> is the Document.documentElement and should be part of the preamble
+      renderState.htmlChunks = [doctypeChunk];
+      return pushStartGenericElement(renderState.htmlChunks, props, 'html');
+    } else {
+      // This <html> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'html');
+    }
+  }
+}
+
+function pushScript(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const asyncProp = props.async;
+
+    if (typeof props.src !== 'string' || !props.src || !(asyncProp && typeof asyncProp !== 'function' && typeof asyncProp !== 'symbol') || props.onLoad || props.onError || insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      // This script will not be a resource, we bailout early and emit it in place.
+      return pushScriptImpl(target, props);
+    }
+
+    const src = props.src;
+    const key = getResourceKey(src); // We can make this <script> into a ScriptResource
+
+    let resources, preloads;
+
+    if (props.type === 'module') {
+      resources = resumableState.moduleScriptResources;
+      preloads = renderState.preloads.moduleScripts;
+    } else {
+      resources = resumableState.scriptResources;
+      preloads = renderState.preloads.scripts;
+    }
+
+    const hasKey = resources.hasOwnProperty(key);
+    const resourceState = hasKey ? resources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resources[key] = EXISTS;
+      let scriptProps = props;
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          scriptProps = assign({}, props);
+          adoptPreloadCredentials(scriptProps, preloadState);
+        }
+
+        const preloadResource = preloads.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, scriptProps);
+    }
+
+    if (textEmbedded) {
+      // This script follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+
+    return null;
+  }
+}
+
+function pushScriptImpl(target, props) {
+  target.push(startChunkForTag('script'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+  }
+
+  target.push(endChunkForTag('script'));
+  return null;
+}
+
+function pushStartGenericElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartCustomElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      let propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      let attributeName = propKey;
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'style':
+          pushStyleAttribute(target, propValue);
+          break;
+
+        case 'suppressContentEditableWarning':
+        case 'suppressHydrationWarning':
+          // Ignored. These are built-in to React on the client.
+          break;
+
+        case 'className':
+          {
+            // className gets rendered as class on the client, so it should be
+            // rendered as class on the server.
+            attributeName = 'class';
+          }
+
+        // intentional fallthrough
+
+        default:
+          if (isAttributeNameSafe(propKey) && typeof propValue !== 'function' && typeof propValue !== 'symbol') {
+            {
+              if (propValue === false) {
+                continue;
+              } else if (propValue === true) {
+                propValue = '';
+              } else if (typeof propValue === 'object') {
+                continue;
+              }
+            }
+
+            target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(propValue)), attributeEnd);
+          }
+
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const leadingNewline = stringToPrecomputedChunk('\n');
+
+function pushStartPreformattedElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag); // text/html ignores the first character in these tags if it's a newline
+  // Prefer to break application/xml over text/html (for now) by adding
+  // a newline specifically to get eaten by the parser. (Alternately for
+  // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+  // \r is normalized out by HTMLTextAreaElement#value.)
+  // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+  // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+  // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+  // See: Parsing of "textarea" "listing" and "pre" elements
+  //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+  // TODO: This doesn't deal with the case where the child is an array
+  // or component that returns a string.
+
+  if (innerHTML != null) {
+    if (children != null) {
+      throw new Error('Can only set one of `children` or `props.dangerouslySetInnerHTML`.');
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw new Error('`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. ' + 'Please visit https://reactjs.org/link/dangerously-set-inner-html ' + 'for more information.');
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+      if (typeof html === 'string' && html.length > 0 && html[0] === '\n') {
+        target.push(leadingNewline, stringToChunk(html));
+      } else {
+
+        target.push(stringToChunk('' + html));
+      }
+    }
+  }
+
+  if (typeof children === 'string' && children[0] === '\n') {
+    target.push(leadingNewline);
+  }
+
+  return children;
+} // We accept any tag to be rendered but since this gets injected into arbitrary
+// HTML, we want to make sure that it's a safe tag.
+// http://www.w3.org/TR/REC-xml/#NT-Name
+
+
+const VALID_TAG_REGEX = /^[a-zA-Z][a-zA-Z:_\.\-\d]*$/; // Simplified subset
+
+const validatedTagCache = new Map();
+
+function startChunkForTag(tag) {
+  let tagStartChunk = validatedTagCache.get(tag);
+
+  if (tagStartChunk === undefined) {
+    if (!VALID_TAG_REGEX.test(tag)) {
+      throw new Error("Invalid tag: " + tag);
+    }
+
+    tagStartChunk = stringToPrecomputedChunk('<' + tag);
+    validatedTagCache.set(tag, tagStartChunk);
+  }
+
+  return tagStartChunk;
+}
+function pushStartInstance(target, type, props, resumableState, renderState, formatContext, textEmbedded) {
+
+  switch (type) {
+    case 'div':
+    case 'span':
+    case 'svg':
+    case 'path':
+    case 'a':
+    case 'g':
+    case 'p':
+    case 'li':
+      // Fast track very common tags
+      break;
+    // Special tags
+
+    case 'select':
+      return pushStartSelect(target, props);
+
+    case 'option':
+      return pushStartOption(target, props, formatContext);
+
+    case 'textarea':
+      return pushStartTextArea(target, props);
+
+    case 'input':
+      return pushInput(target, props, resumableState, renderState);
+
+    case 'button':
+      return pushStartButton(target, props, resumableState, renderState);
+
+    case 'form':
+      return pushStartForm(target, props, resumableState, renderState);
+
+    case 'menuitem':
+      return pushStartMenuItem(target, props);
+
+    case 'title':
+      return pushTitle(target, props, renderState, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'link':
+      return pushLink(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'script':
+      return pushScript(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'style':
+      return pushStyle(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'meta':
+      return pushMeta(target, props, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+    // Newline eating tags
+
+    case 'listing':
+    case 'pre':
+      {
+        return pushStartPreformattedElement(target, props, type);
+      }
+
+    case 'img':
+      {
+        return pushImg(target, props, resumableState, renderState, !!(formatContext.tagScope & PICTURE_SCOPE)) ;
+      }
+    // Omitted close tags
+
+    case 'base':
+    case 'area':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'keygen':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        return pushSelfClosing(target, props, type);
+      }
+    // These are reserved SVG and MathML elements, that are never custom elements.
+    // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+
+    case 'annotation-xml':
+    case 'color-profile':
+    case 'font-face':
+    case 'font-face-src':
+    case 'font-face-uri':
+    case 'font-face-format':
+    case 'font-face-name':
+    case 'missing-glyph':
+      {
+        break;
+      }
+    // Preamble start tags
+
+    case 'head':
+      return pushStartHead(target, props, renderState, formatContext.insertionMode);
+
+    case 'html':
+      {
+        return pushStartHtml(target, props, renderState, formatContext.insertionMode);
+      }
+
+    default:
+      {
+        if (type.indexOf('-') !== -1) {
+          // Custom element
+          return pushStartCustomElement(target, props, type);
+        }
+      }
+  } // Generic element
+
+
+  return pushStartGenericElement(target, props, type);
+}
+const endTagCache = new Map();
+
+function endChunkForTag(tag) {
+  let chunk = endTagCache.get(tag);
+
+  if (chunk === undefined) {
+    chunk = stringToPrecomputedChunk('</' + tag + '>');
+    endTagCache.set(tag, chunk);
+  }
+
+  return chunk;
+}
+
+function pushEndInstance(target, type, props, resumableState, formatContext) {
+  switch (type) {
+    // When float is on we expect title and script tags to always be pushed in
+    // a unit and never return children. when we end up pushing the end tag we
+    // want to ensure there is no extra closing tag pushed
+    case 'title':
+    case 'style':
+    case 'script':
+    // Omitted close tags
+    // TODO: Instead of repeating this switch we could try to pass a flag from above.
+    // That would require returning a tuple. Which might be ok if it gets inlined.
+
+    case 'area':
+    case 'base':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'img':
+    case 'input':
+    case 'keygen':
+    case 'link':
+    case 'meta':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        // No close tag needed.
+        return;
+      }
+    // Postamble end tags
+    // When float is enabled we omit the end tags for body and html when
+    // they represent the Document.body and Document.documentElement Nodes.
+    // This is so we can withhold them until the postamble when we know
+    // we won't emit any more tags
+
+    case 'body':
+      {
+        if (formatContext.insertionMode <= HTML_HTML_MODE) {
+          resumableState.hasBody = true;
+          return;
+        }
+
+        break;
+      }
+
+    case 'html':
+      if (formatContext.insertionMode === ROOT_HTML_MODE) {
+        resumableState.hasHtml = true;
+        return;
+      }
+
+      break;
+  }
+
+  target.push(endChunkForTag(type));
+}
+
+function writeBootstrap(destination, renderState, resumableState) {
+  resumableState.bootstrapScriptContent = undefined;
+  resumableState.bootstrapScripts = undefined;
+  resumableState.bootstrapModules = undefined;
+  const bootstrapChunks = renderState.bootstrapChunks;
+  let i = 0;
+
+  for (; i < bootstrapChunks.length - 1; i++) {
+    writeChunk(destination, bootstrapChunks[i]);
+  }
+
+  if (i < bootstrapChunks.length) {
+    const lastChunk = bootstrapChunks[i];
+    bootstrapChunks.length = 0;
+    return writeChunkAndReturn(destination, lastChunk);
+  }
+
+  return true;
+}
+
+function writeCompletedRoot(destination, renderState, resumableState) {
+  return writeBootstrap(destination, renderState, resumableState);
+} // Structural Nodes
+// A placeholder is a node inside a hidden partial tree that can be filled in later, but before
+// display. It's never visible to users. We use the template tag because it can be used in every
+// type of parent. <script> tags also work in every other tag except <colgroup>.
+
+const placeholder1 = stringToPrecomputedChunk('<template id="');
+const placeholder2 = stringToPrecomputedChunk('"></template>');
+function writePlaceholder(destination, renderState, id) {
+  writeChunk(destination, placeholder1);
+  writeChunk(destination, renderState.placeholderPrefix);
+  const formattedID = stringToChunk(id.toString(16));
+  writeChunk(destination, formattedID);
+  return writeChunkAndReturn(destination, placeholder2);
+} // Suspense boundaries are encoded as comments.
+
+const startCompletedSuspenseBoundary = stringToPrecomputedChunk('<!--$-->');
+const startPendingSuspenseBoundary1 = stringToPrecomputedChunk('<!--$?--><template id="');
+const startPendingSuspenseBoundary2 = stringToPrecomputedChunk('"></template>');
+const startClientRenderedSuspenseBoundary = stringToPrecomputedChunk('<!--$!-->');
+const endSuspenseBoundary = stringToPrecomputedChunk('<!--/$-->');
+const clientRenderedSuspenseBoundaryError1 = stringToPrecomputedChunk('<template');
+const clientRenderedSuspenseBoundaryErrorAttrInterstitial = stringToPrecomputedChunk('"');
+const clientRenderedSuspenseBoundaryError1A = stringToPrecomputedChunk(' data-dgst="');
+const clientRenderedSuspenseBoundaryError2 = stringToPrecomputedChunk('></template>');
+function writeStartCompletedSuspenseBoundary$1(destination, renderState) {
+  return writeChunkAndReturn(destination, startCompletedSuspenseBoundary);
+}
+function writeStartPendingSuspenseBoundary(destination, renderState, id) {
+  writeChunk(destination, startPendingSuspenseBoundary1);
+
+  if (id === null) {
+    throw new Error('An ID must have been assigned before we can complete the boundary.');
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+  return writeChunkAndReturn(destination, startPendingSuspenseBoundary2);
+}
+function writeStartClientRenderedSuspenseBoundary$1(destination, renderState, errorDigest, errorMesssage, errorComponentStack) {
+  let result;
+  result = writeChunkAndReturn(destination, startClientRenderedSuspenseBoundary);
+  writeChunk(destination, clientRenderedSuspenseBoundaryError1);
+
+  if (errorDigest) {
+    writeChunk(destination, clientRenderedSuspenseBoundaryError1A);
+    writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest)));
+    writeChunk(destination, clientRenderedSuspenseBoundaryErrorAttrInterstitial);
+  }
+
+  result = writeChunkAndReturn(destination, clientRenderedSuspenseBoundaryError2);
+  return result;
+}
+function writeEndCompletedSuspenseBoundary$1(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndPendingSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndClientRenderedSuspenseBoundary$1(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+const startSegmentHTML = stringToPrecomputedChunk('<div hidden id="');
+const startSegmentHTML2 = stringToPrecomputedChunk('">');
+const endSegmentHTML = stringToPrecomputedChunk('</div>');
+const startSegmentSVG = stringToPrecomputedChunk('<svg aria-hidden="true" style="display:none" id="');
+const startSegmentSVG2 = stringToPrecomputedChunk('">');
+const endSegmentSVG = stringToPrecomputedChunk('</svg>');
+const startSegmentMathML = stringToPrecomputedChunk('<math aria-hidden="true" style="display:none" id="');
+const startSegmentMathML2 = stringToPrecomputedChunk('">');
+const endSegmentMathML = stringToPrecomputedChunk('</math>');
+const startSegmentTable = stringToPrecomputedChunk('<table hidden id="');
+const startSegmentTable2 = stringToPrecomputedChunk('">');
+const endSegmentTable = stringToPrecomputedChunk('</table>');
+const startSegmentTableBody = stringToPrecomputedChunk('<table hidden><tbody id="');
+const startSegmentTableBody2 = stringToPrecomputedChunk('">');
+const endSegmentTableBody = stringToPrecomputedChunk('</tbody></table>');
+const startSegmentTableRow = stringToPrecomputedChunk('<table hidden><tr id="');
+const startSegmentTableRow2 = stringToPrecomputedChunk('">');
+const endSegmentTableRow = stringToPrecomputedChunk('</tr></table>');
+const startSegmentColGroup = stringToPrecomputedChunk('<table hidden><colgroup id="');
+const startSegmentColGroup2 = stringToPrecomputedChunk('">');
+const endSegmentColGroup = stringToPrecomputedChunk('</colgroup></table>');
+function writeStartSegment(destination, renderState, formatContext, id) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        writeChunk(destination, startSegmentHTML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentHTML2);
+      }
+
+    case SVG_MODE:
+      {
+        writeChunk(destination, startSegmentSVG);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentSVG2);
+      }
+
+    case MATHML_MODE:
+      {
+        writeChunk(destination, startSegmentMathML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentMathML2);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        writeChunk(destination, startSegmentTable);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTable2);
+      }
+    // TODO: For the rest of these, there will be extra wrapper nodes that never
+    // get deleted from the document. We need to delete the table too as part
+    // of the injected scripts. They are invisible though so it's not too terrible
+    // and it's kind of an edge case to suspend in a table. Totally supported though.
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        writeChunk(destination, startSegmentTableBody);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableBody2);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        writeChunk(destination, startSegmentTableRow);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableRow2);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        writeChunk(destination, startSegmentColGroup);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentColGroup2);
+      }
+
+    default:
+      {
+        throw new Error('Unknown insertion mode. This is a bug in React.');
+      }
+  }
+}
+function writeEndSegment(destination, formatContext) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentHTML);
+      }
+
+    case SVG_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentSVG);
+      }
+
+    case MATHML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentMathML);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTable);
+      }
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableBody);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableRow);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentColGroup);
+      }
+
+    default:
+      {
+        throw new Error('Unknown insertion mode. This is a bug in React.');
+      }
+  }
+}
+const completeSegmentScript1Full = stringToPrecomputedChunk(completeSegment + '$RS("');
+const completeSegmentScript1Partial = stringToPrecomputedChunk('$RS("');
+const completeSegmentScript2 = stringToPrecomputedChunk('","');
+const completeSegmentScriptEnd = stringToPrecomputedChunk('")</script>');
+const completeSegmentData1 = stringToPrecomputedChunk('<template data-rsi="" data-sid="');
+const completeSegmentData2 = stringToPrecomputedChunk('" data-pid="');
+const completeSegmentDataEnd = dataElementQuotedEnd;
+function writeCompletedSegmentInstruction(destination, resumableState, renderState, contentSegmentID) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentCompleteSegmentFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentCompleteSegmentFunction;
+      writeChunk(destination, completeSegmentScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, completeSegmentScript1Partial);
+    }
+  } else {
+    writeChunk(destination, completeSegmentData1);
+  } // Write function arguments, which are string literals
+
+
+  writeChunk(destination, renderState.segmentPrefix);
+  const formattedID = stringToChunk(contentSegmentID.toString(16));
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    writeChunk(destination, completeSegmentScript2);
+  } else {
+    writeChunk(destination, completeSegmentData2);
+  }
+
+  writeChunk(destination, renderState.placeholderPrefix);
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    return writeChunkAndReturn(destination, completeSegmentScriptEnd);
+  } else {
+    return writeChunkAndReturn(destination, completeSegmentDataEnd);
+  }
+}
+const completeBoundaryScript1Full = stringToPrecomputedChunk(completeBoundary + '$RC("');
+const completeBoundaryScript1Partial = stringToPrecomputedChunk('$RC("');
+const completeBoundaryWithStylesScript1FullBoth = stringToPrecomputedChunk(completeBoundary + completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1FullPartial = stringToPrecomputedChunk(completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1Partial = stringToPrecomputedChunk('$RR("');
+const completeBoundaryScript2 = stringToPrecomputedChunk('","');
+const completeBoundaryScript3a = stringToPrecomputedChunk('",');
+const completeBoundaryScript3b = stringToPrecomputedChunk('"');
+const completeBoundaryScriptEnd = stringToPrecomputedChunk(')</script>');
+const completeBoundaryData1 = stringToPrecomputedChunk('<template data-rci="" data-bid="');
+const completeBoundaryWithStylesData1 = stringToPrecomputedChunk('<template data-rri="" data-bid="');
+const completeBoundaryData2 = stringToPrecomputedChunk('" data-sid="');
+const completeBoundaryData3a = stringToPrecomputedChunk('" data-sty="');
+const completeBoundaryDataEnd = dataElementQuotedEnd;
+function writeCompletedBoundaryInstruction(destination, resumableState, renderState, id, boundaryResources) {
+  let requiresStyleInsertion;
+
+  {
+    requiresStyleInsertion = renderState.stylesToHoist; // If necessary stylesheets will be flushed with this instruction.
+    // Any style tags not yet hoisted in the Document will also be hoisted.
+    // We reset this state since after this instruction executes all styles
+    // up to this point will have been hoisted
+
+    renderState.stylesToHoist = false;
+  }
+
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if (requiresStyleInsertion) {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction | SentCompleteBoundaryFunction;
+        writeChunk(destination, clonePrecomputedChunk(completeBoundaryWithStylesScript1FullBoth));
+      } else if ((resumableState.instructions & SentStyleInsertionFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction;
+        writeChunk(destination, completeBoundaryWithStylesScript1FullPartial);
+      } else {
+        writeChunk(destination, completeBoundaryWithStylesScript1Partial);
+      }
+    } else {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentCompleteBoundaryFunction;
+        writeChunk(destination, completeBoundaryScript1Full);
+      } else {
+        writeChunk(destination, completeBoundaryScript1Partial);
+      }
+    }
+  } else {
+    if (requiresStyleInsertion) {
+      writeChunk(destination, completeBoundaryWithStylesData1);
+    } else {
+      writeChunk(destination, completeBoundaryData1);
+    }
+  }
+
+  const idChunk = stringToChunk(id.toString(16));
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, idChunk); // Write function arguments, which are string and array literals
+
+  if (scriptFormat) {
+    writeChunk(destination, completeBoundaryScript2);
+  } else {
+    writeChunk(destination, completeBoundaryData2);
+  }
+
+  writeChunk(destination, renderState.segmentPrefix);
+  writeChunk(destination, idChunk);
+
+  if (requiresStyleInsertion) {
+    // Script and data writers must format this differently:
+    //  - script writer emits an array literal, whose string elements are
+    //    escaped for javascript  e.g. ["A", "B"]
+    //  - data writer emits a string literal, which is escaped as html
+    //    e.g. [&#34;A&#34;, &#34;B&#34;]
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3a); // boundaryResources encodes an array literal
+
+      writeStyleResourceDependenciesInJS(destination, boundaryResources);
+    } else {
+      writeChunk(destination, completeBoundaryData3a);
+      writeStyleResourceDependenciesInAttr(destination, boundaryResources);
+    }
+  } else {
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3b);
+    }
+  }
+
+  let writeMore;
+
+  if (scriptFormat) {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryScriptEnd);
+  } else {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryDataEnd);
+  }
+
+  return writeBootstrap(destination, renderState, resumableState) && writeMore;
+}
+const clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
+const clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
+const clientRenderScript1A = stringToPrecomputedChunk('"');
+const clientRenderErrorScriptArgInterstitial = stringToPrecomputedChunk(',');
+const clientRenderScriptEnd = stringToPrecomputedChunk(')</script>');
+const clientRenderData1 = stringToPrecomputedChunk('<template data-rxi="" data-bid="');
+const clientRenderData2 = stringToPrecomputedChunk('" data-dgst="');
+const clientRenderData3 = stringToPrecomputedChunk('" data-msg="');
+const clientRenderData4 = stringToPrecomputedChunk('" data-stck="');
+const clientRenderDataEnd = dataElementQuotedEnd;
+function writeClientRenderBoundaryInstruction(destination, resumableState, renderState, id, errorDigest, errorMessage, errorComponentStack) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentClientRenderFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentClientRenderFunction;
+      writeChunk(destination, clientRenderScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, clientRenderScript1Partial);
+    }
+  } else {
+    // <template data-rxi="" data-bid="
+    writeChunk(destination, clientRenderData1);
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+
+  if (scriptFormat) {
+    // " needs to be inserted for scripts, since ArgInterstitual does not contain
+    // leading or trailing quotes
+    writeChunk(destination, clientRenderScript1A);
+  }
+
+  if (errorDigest || errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorDigest || '')));
+    } else {
+      // " data-dgst="HTMLString
+      writeChunk(destination, clientRenderData2);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest || '')));
+    }
+  }
+
+  if (errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorMessage || '')));
+    } else {
+      // " data-msg="HTMLString
+      writeChunk(destination, clientRenderData3);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorMessage || '')));
+    }
+  }
+
+  if (errorComponentStack) {
+    // ,"JSONString"
+    if (scriptFormat) {
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorComponentStack)));
+    } else {
+      // " data-stck="HTMLString
+      writeChunk(destination, clientRenderData4);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorComponentStack)));
+    }
+  }
+
+  if (scriptFormat) {
+    // ></script>
+    return writeChunkAndReturn(destination, clientRenderScriptEnd);
+  } else {
+    // "></template>
+    return writeChunkAndReturn(destination, clientRenderDataEnd);
+  }
+}
+const regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
+
+function escapeJSStringsForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInInstructionScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const regexForJSStringsInScripts = /[&><\u2028\u2029]/g;
+
+function escapeJSObjectForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '&':
+        return '\\u0026';
+
+      case '>':
+        return '\\u003e';
+
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const lateStyleTagResourceOpen1 = stringToPrecomputedChunk('<style media="not all" data-precedence="');
+const lateStyleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const lateStyleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const lateStyleTagTemplateClose = stringToPrecomputedChunk('</style>'); // Tracks whether the boundary currently flushing is flushign style tags or has any
+// stylesheet dependencies not flushed in the Preamble.
+
+let currentlyRenderingBoundaryHasStylesToHoist = false; // Acts as a return value for the forEach execution of style tag flushing.
+
+let destinationHasCapacity = true;
+
+function flushStyleTagsLateForBoundary(styleQueue) {
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs;
+
+  let i = 0;
+
+  if (hrefs.length) {
+    writeChunk(this, lateStyleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    writeChunk(this, lateStyleTagResourceOpen2);
+
+    for (; i < hrefs.length - 1; i++) {
+      writeChunk(this, hrefs[i]);
+      writeChunk(this, spaceSeparator);
+    }
+
+    writeChunk(this, hrefs[i]);
+    writeChunk(this, lateStyleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    destinationHasCapacity = writeChunkAndReturn(this, lateStyleTagTemplateClose); // We wrote style tags for this boundary and we may need to emit a script
+    // to hoist them.
+
+    currentlyRenderingBoundaryHasStylesToHoist = true; // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function hasStylesToHoist(stylesheet) {
+  // We need to reveal boundaries with styles whenever a stylesheet it depends on is either
+  // not flushed or flushed after the preamble (shell).
+  if (stylesheet.state !== PREAMBLE) {
+    currentlyRenderingBoundaryHasStylesToHoist = true;
+    return true;
+  }
+
+  return false;
+}
+
+function writeResourcesForBoundary(destination, boundaryResources, renderState) {
+  // Reset these on each invocation, they are only safe to read in this function
+  currentlyRenderingBoundaryHasStylesToHoist = false;
+  destinationHasCapacity = true; // Flush style tags for each precedence this boundary depends on
+
+  boundaryResources.styles.forEach(flushStyleTagsLateForBoundary, destination); // Determine if this boundary has stylesheets that need to be awaited upon completion
+
+  boundaryResources.stylesheets.forEach(hasStylesToHoist);
+
+  if (currentlyRenderingBoundaryHasStylesToHoist) {
+    renderState.stylesToHoist = true;
+  }
+
+  return destinationHasCapacity;
+}
+
+function flushResource(resource) {
+  for (let i = 0; i < resource.length; i++) {
+    writeChunk(this, resource[i]);
+  }
+
+  resource.length = 0;
+}
+
+const stylesheetFlushingQueue = [];
+
+function flushStyleInPreamble(stylesheet, key, map) {
+  // We still need to encode stylesheet chunks
+  // because unlike most Hoistables and Resources we do not eagerly encode
+  // them during render. This is because if we flush late we have to send a
+  // different encoding and we don't want to encode multiple times
+  pushLinkImpl(stylesheetFlushingQueue, stylesheet.props);
+
+  for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+    writeChunk(this, stylesheetFlushingQueue[i]);
+  }
+
+  stylesheetFlushingQueue.length = 0;
+  stylesheet.state = PREAMBLE;
+}
+
+const styleTagResourceOpen1 = stringToPrecomputedChunk('<style data-precedence="');
+const styleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const spaceSeparator = stringToPrecomputedChunk(' ');
+const styleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const styleTagResourceClose = stringToPrecomputedChunk('</style>');
+
+function flushStylesInPreamble(styleQueue, precedence) {
+  const hasStylesheets = styleQueue.sheets.size > 0;
+  styleQueue.sheets.forEach(flushStyleInPreamble, this);
+  styleQueue.sheets.clear();
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs; // If we don't emit any stylesheets at this precedence we still need to maintain the precedence
+  // order so even if there are no rules for style tags at this precedence we emit an empty style
+  // tag with the data-precedence attribute
+
+  if (!hasStylesheets || hrefs.length) {
+    writeChunk(this, styleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    let i = 0;
+
+    if (hrefs.length) {
+      writeChunk(this, styleTagResourceOpen2);
+
+      for (; i < hrefs.length - 1; i++) {
+        writeChunk(this, hrefs[i]);
+        writeChunk(this, spaceSeparator);
+      }
+
+      writeChunk(this, hrefs[i]);
+    }
+
+    writeChunk(this, styleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    writeChunk(this, styleTagResourceClose); // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function preloadLateStyle(stylesheet) {
+  if (stylesheet.state === PENDING$1) {
+    stylesheet.state = PRELOADED;
+    const preloadProps = preloadAsStylePropsFromProps(stylesheet.props.href, stylesheet.props);
+    pushLinkImpl(stylesheetFlushingQueue, preloadProps);
+
+    for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+      writeChunk(this, stylesheetFlushingQueue[i]);
+    }
+
+    stylesheetFlushingQueue.length = 0;
+  }
+}
+
+function preloadLateStyles(styleQueue) {
+  styleQueue.sheets.forEach(preloadLateStyle, this);
+  styleQueue.sheets.clear();
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+
+function writePreamble(destination, resumableState, renderState, willFlushAllSegments) {
+  // This function must be called exactly once on every request
+  if (!willFlushAllSegments && renderState.externalRuntimeScript) {
+    // If the root segment is incomplete due to suspended tasks
+    // (e.g. willFlushAllSegments = false) and we are using data
+    // streaming format, ensure the external runtime is sent.
+    // (User code could choose to send this even earlier by calling
+    //  preinit(...), if they know they will suspend).
+    const _renderState$external = renderState.externalRuntimeScript,
+          src = _renderState$external.src,
+          chunks = _renderState$external.chunks;
+    internalPreinitScript(resumableState, renderState, src, chunks);
+  }
+
+  const htmlChunks = renderState.htmlChunks;
+  const headChunks = renderState.headChunks;
+  let i = 0; // Emit open tags before Hoistables and Resources
+
+  if (htmlChunks) {
+    // We have an <html> to emit as part of the preamble
+    for (i = 0; i < htmlChunks.length; i++) {
+      writeChunk(destination, htmlChunks[i]);
+    }
+
+    if (headChunks) {
+      for (i = 0; i < headChunks.length; i++) {
+        writeChunk(destination, headChunks[i]);
+      }
+    } else {
+      // We did not render a head but we emitted an <html> so we emit one now
+      writeChunk(destination, startChunkForTag('head'));
+      writeChunk(destination, endOfStartTag);
+    }
+  } else if (headChunks) {
+    // We do not have an <html> but we do have a <head>
+    for (i = 0; i < headChunks.length; i++) {
+      writeChunk(destination, headChunks[i]);
+    }
+  } // Emit high priority Hoistables
+
+
+  const charsetChunks = renderState.charsetChunks;
+
+  for (i = 0; i < charsetChunks.length; i++) {
+    writeChunk(destination, charsetChunks[i]);
+  }
+
+  charsetChunks.length = 0; // emit preconnect resources
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Flush unblocked stylesheets by precedence
+
+  renderState.styles.forEach(flushStylesInPreamble, destination);
+  const importMapChunks = renderState.importMapChunks;
+
+  for (i = 0; i < importMapChunks.length; i++) {
+    writeChunk(destination, importMapChunks[i]);
+  }
+
+  importMapChunks.length = 0;
+  renderState.bootstrapScripts.forEach(flushResource, destination);
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0; // Flush closing head if necessary
+
+  if (htmlChunks && headChunks === null) {
+    // We have an <html> rendered but no <head> rendered. We however inserted
+    // a <head> up above so we need to emit the </head> now. This is safe because
+    // if the main content contained the </head> it would also have provided a
+    // <head>. This means that all the content inside <html> is either <body> or
+    // invalid HTML
+    writeChunk(destination, endChunkForTag('head'));
+  }
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+function writeHoistables(destination, resumableState, renderState) {
+  let i = 0; // Emit high priority Hoistables
+  // We omit charsetChunks because we have already sent the shell and if it wasn't
+  // already sent it is too late now.
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Preload any stylesheets. these will emit in a render instruction that follows this
+  // but we want to kick off preloading as soon as possible
+
+  renderState.styles.forEach(preloadLateStyles, destination); // We only hoist importmaps that are configured through createResponse and that will
+  // always flush in the preamble. Generally we don't expect people to render them as
+  // tags when using React but if you do they are going to be treated like regular inline
+  // scripts and flush after other hoistables which is problematic
+  // bootstrap scripts should flush above script priority but these can only flush in the preamble
+  // so we elide the code here for performance
+
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0;
+}
+function writePostamble(destination, resumableState) {
+  if (resumableState.hasBody) {
+    writeChunk(destination, endChunkForTag('body'));
+  }
+
+  if (resumableState.hasHtml) {
+    writeChunk(destination, endChunkForTag('html'));
+  }
+}
+const arrayFirstOpenBracket = stringToPrecomputedChunk('[');
+const arraySubsequentOpenBracket = stringToPrecomputedChunk(',[');
+const arrayInterstitial = stringToPrecomputedChunk(',');
+const arrayCloseBracket = stringToPrecomputedChunk(']'); // This function writes a 2D array of strings to be embedded in javascript.
+// E.g.
+//  [["JS_escaped_string1", "JS_escaped_string2"]]
+
+function writeStyleResourceDependenciesInJS(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInJS(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInJS(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInJS(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+}
+
+function writeStyleResourceDependencyInJS(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedPrecedence)));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          writeStyleResourceAttributeInJS(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInJS(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeName)));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeValue)));
+} // This function writes a 2D array of strings to be embedded in an attribute
+// value and read with JSON.parse in ReactDOMServerExternalRuntime.js
+// E.g.
+//  [[&quot;JSON_escaped_string1&quot;, &quot;JSON_escaped_string2&quot;]]
+
+
+function writeStyleResourceDependenciesInAttr(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInAttr(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInAttr(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInAttr(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+}
+
+function writeStyleResourceDependencyInAttr(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedPrecedence))));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          writeStyleResourceAttributeInAttr(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInAttr(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeName))));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeValue))));
+}
+/**
+ * Resources
+ */
+
+
+const PENDING$1 = 0;
+const PRELOADED = 1;
+const PREAMBLE = 2;
+const LATE = 3;
+function createBoundaryResources() {
+  return {
+    styles: new Set(),
+    stylesheets: new Set()
+  };
+}
+function setCurrentlyRenderingBoundaryResourcesTarget(renderState, boundaryResources) {
+  renderState.boundaryResources = boundaryResources;
+}
+
+function getResourceKey(href) {
+  return href;
+}
+
+function getImageResourceKey(href, imageSrcSet, imageSizes) {
+  if (imageSrcSet) {
+    return imageSrcSet + '\n' + (imageSizes || '');
+  }
+
+  return href;
+}
+
+function prefetchDNS(href) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const key = getResourceKey(href);
+
+    if (!resumableState.dnsResources.hasOwnProperty(key)) {
+      resumableState.dnsResources[key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPrefetchDNSAsHeader(href), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this as resettable in case we are prerendering and postpone in the Shell
+        renderState.resets.dns[key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        // Encode as element
+        const resource = [];
+        pushLinkImpl(resource, {
+          href,
+          rel: 'dns-prefetch'
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preconnect(href, crossOrigin) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const bucket = crossOrigin === 'use-credentials' ? 'credentials' : typeof crossOrigin === 'string' ? 'anonymous' : 'default';
+    const key = getResourceKey(href);
+
+    if (!resumableState.connectResources[bucket].hasOwnProperty(key)) {
+      resumableState.connectResources[bucket][key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPreconnectAsHeader(href, crossOrigin), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this in resettableState in case we are prerending and postpone in the Shell
+        renderState.resets.connect[bucket][key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        const resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preconnect',
+          href,
+          crossOrigin
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preload(href, as, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (as && href) {
+    switch (as) {
+      case 'image':
+        {
+          let imageSrcSet, imageSizes, fetchPriority;
+
+          if (options) {
+            imageSrcSet = options.imageSrcSet;
+            imageSizes = options.imageSizes;
+            fetchPriority = options.fetchPriority;
+          }
+
+          const key = getImageResourceKey(href, imageSrcSet, imageSizes);
+
+          if (resumableState.imageResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && fetchPriority === 'high' && ( // Compute the header since we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit a preload as a header so we
+            // track this to make sure we don't reset it.
+            renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+            if (headers.highImagePreloads) {
+              headers.highImagePreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.highImagePreloads += header;
+          } else {
+            // If we don't have headers to write to we have to encode as elements to flush in the head
+            // When we have imageSrcSet the browser probably cannot load the right version from headers
+            // (this should be verified by testing). For now we assume these need to go in the head
+            // as elements even if headers are available.
+            const resource = [];
+            pushLinkImpl(resource, assign({
+              rel: 'preload',
+              // There is a bug in Safari where imageSrcSet is not respected on preload links
+              // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+              // This harms older browers that do not support imageSrcSet by making their preloads not work
+              // but this population is shrinking fast and is already small so we accept this tradeoff.
+              href: imageSrcSet ? undefined : href,
+              as
+            }, options));
+
+            if (fetchPriority === 'high') {
+              renderState.highImagePreloads.add(resource);
+            } else {
+              renderState.bulkPreloads.add(resource); // Stash the resource in case we need to promote it to higher priority
+              // when an img tag is rendered
+
+              renderState.preloads.images.set(key, resource);
+            }
+          }
+
+          break;
+        }
+
+      case 'style':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.styleResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.styleResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.stylesheets.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          break;
+        }
+
+      case 'script':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.scriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          renderState.preloads.scripts.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.scriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          break;
+        }
+
+      default:
+        {
+          const key = getResourceKey(href);
+          const hasAsType = resumableState.unknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.unknownResources[as] = resources;
+          }
+
+          resources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && as === 'font' && ( // We compute the header here because we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit this preload so we
+            // track it here to prevent it from being reset.
+            renderState.resets.font[key] = PRELOAD_NO_CREDS;
+
+            if (headers.fontPreloads) {
+              headers.fontPreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.fontPreloads += header;
+          } else {
+            // We either don't have headers or we are preloading something that does
+            // not warrant elevated priority so we encode as an element.
+            const resource = [];
+
+            const props = assign({
+              rel: 'preload',
+              href,
+              as
+            }, options);
+
+            pushLinkImpl(resource, props);
+
+            switch (as) {
+              case 'font':
+                renderState.fontPreloads.add(resource);
+                break;
+              // intentional fall through
+
+              default:
+                renderState.bulkPreloads.add(resource);
+            }
+          }
+        }
+    } // If we got this far we created a new resource
+
+
+    flushResources(request);
+  }
+}
+
+function preloadModule(href, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    const key = getResourceKey(href);
+    const as = options && typeof options.as === 'string' ? options.as : 'script';
+    let resource;
+
+    switch (as) {
+      case 'script':
+        {
+          if (resumableState.moduleScriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resource = [];
+          resumableState.moduleScriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.moduleScripts.set(key, resource);
+          break;
+        }
+
+      default:
+        {
+          const hasAsType = resumableState.moduleUnknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.moduleUnknownResources[as] = resources;
+          }
+
+          resource = [];
+          resources[key] = PRELOAD_NO_CREDS;
+        }
+    }
+
+    pushLinkImpl(resource, assign({
+      rel: 'modulepreload',
+      href
+    }, options));
+    renderState.bulkPreloads.add(resource); // If we got this far we created a new resource
+
+    flushResources(request);
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    precedence = precedence || 'default';
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+      // to create a StyleQueue
+
+      if (!styleQueue) {
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      }
+
+      const resource = {
+        state: PENDING$1,
+        props: assign({
+          rel: 'stylesheet',
+          href,
+          'data-precedence': precedence
+        }, options)
+      };
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(resource.props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.stylesheets.get(key);
+
+        if (preloadResource && preloadResource.length > 0) {
+          // The Preload for this resource was created in this render pass and has not flushed yet so
+          // we need to clear it to avoid it flushing.
+          preloadResource.length = 0;
+        } else {
+          // Either the preload resource from this render already flushed in this render pass
+          // or the preload flushed in a prior pass (prerender). In either case we need to mark
+          // this resource as already having been preloaded.
+          resource.state = PRELOADED;
+        }
+      } // We add the newly created resource to our StyleQueue and if necessary
+      // track the resource with the currently rendering boundary
+
+
+      styleQueue.sheets.set(key, resource); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+  }
+}
+
+function preinitScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.scriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.scriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.scriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.scripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+}
+
+function preinitModuleScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.moduleScriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.moduleScriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.moduleScriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        type: 'module',
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.moduleScripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+} // This function is only safe to call at Request start time since it assumes
+// that each module has not already been preloaded. If we find a need to preload
+// scripts at any other point in time we will need to check whether the preload
+// already exists and not assume it
+
+
+function preloadBootstrapScriptOrModule(resumableState, renderState, href, props) {
+
+  const key = getResourceKey(href);
+  // used to preinit the resource. If a script can be preinited then it shouldn't
+  // be a bootstrap script/module and if it is a bootstrap script/module then it
+  // must not be safe to emit early. To avoid possibly allowing for preinits of
+  // bootstrap scripts/modules we occlude these keys.
+
+
+  resumableState.scriptResources[key] = EXISTS;
+  resumableState.moduleScriptResources[key] = EXISTS;
+  const resource = [];
+  pushLinkImpl(resource, props);
+  renderState.bootstrapScripts.add(resource);
+}
+
+function internalPreinitScript(resumableState, renderState, src, chunks) {
+  const key = getResourceKey(src);
+
+  if (!resumableState.scriptResources.hasOwnProperty(key)) {
+    const resource = chunks;
+    resumableState.scriptResources[key] = EXISTS;
+    renderState.scripts.add(resource);
+  }
+
+  return;
+}
+
+function preloadAsStylePropsFromProps(href, props) {
+  return {
+    rel: 'preload',
+    as: 'style',
+    href: href,
+    crossOrigin: props.crossOrigin,
+    fetchPriority: props.fetchPriority,
+    integrity: props.integrity,
+    media: props.media,
+    hrefLang: props.hrefLang,
+    referrerPolicy: props.referrerPolicy
+  };
+}
+
+function stylesheetPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    'data-precedence': rawProps.precedence,
+    precedence: null
+  });
+}
+
+function adoptPreloadCredentials(target, preloadState) {
+  if (target.crossOrigin == null) target.crossOrigin = preloadState[0];
+  if (target.integrity == null) target.integrity = preloadState[1];
+}
+
+function getPrefetchDNSAsHeader(href) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  return "<" + escapedHref + ">; rel=dns-prefetch";
+}
+
+function getPreconnectAsHeader(href, crossOrigin) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  let value = "<" + escapedHref + ">; rel=preconnect";
+
+  if (typeof crossOrigin === 'string') {
+    const escapedCrossOrigin = escapeStringForLinkHeaderQuotedParamValueContext(crossOrigin);
+    value += "; crossorigin=\"" + escapedCrossOrigin + "\"";
+  }
+
+  return value;
+}
+
+function getPreloadAsHeader(href, as, params) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  const escapedAs = escapeStringForLinkHeaderQuotedParamValueContext(as);
+  let value = "<" + escapedHref + ">; rel=preload; as=\"" + escapedAs + "\"";
+
+  for (const paramName in params) {
+    if (hasOwnProperty.call(params, paramName)) {
+      const paramValue = params[paramName];
+
+      if (typeof paramValue === 'string') {
+        value += "; " + paramName.toLowerCase() + "=\"" + escapeStringForLinkHeaderQuotedParamValueContext(paramValue) + "\"";
+      }
+    }
+  }
+
+  return value;
+}
+
+function getStylesheetPreloadAsHeader(stylesheet) {
+  const props = stylesheet.props;
+  const preloadOptions = {
+    crossOrigin: props.crossOrigin,
+    integrity: props.integrity,
+    nonce: props.nonce,
+    type: props.type,
+    fetchPriority: props.fetchPriority,
+    referrerPolicy: props.referrerPolicy,
+    media: props.media
+  };
+  return getPreloadAsHeader(props.href, 'style', preloadOptions);
+} // This escaping function is only safe to use for href values being written into
+// a "Link" header in between `<` and `>` characters. The primary concern with the href is
+// to escape the bounding characters as well as new lines. This is unsafe to use in any other
+// context
+
+
+const regexForHrefInLinkHeaderURLContext = /[<>\r\n]/g;
+
+function escapeHrefForLinkHeaderURLContext(hrefInput) {
+
+  const coercedHref = '' + hrefInput;
+  return coercedHref.replace(regexForHrefInLinkHeaderURLContext, escapeHrefForLinkHeaderURLContextReplacer);
+}
+
+function escapeHrefForLinkHeaderURLContextReplacer(match) {
+  switch (match) {
+    case '<':
+      return '%3C';
+
+    case '>':
+      return '%3E';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeLinkHrefForHeaderContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+} // This escaping function is only safe to use for quoted param values in an HTTP header.
+// It is unsafe to use for any value not inside quote marks in parater value position.
+
+
+const regexForLinkHeaderQuotedParamValueContext = /["';,\r\n]/g;
+
+function escapeStringForLinkHeaderQuotedParamValueContext(value, name) {
+
+  const coerced = '' + value;
+  return coerced.replace(regexForLinkHeaderQuotedParamValueContext, escapeStringForLinkHeaderQuotedParamValueContextReplacer);
+}
+
+function escapeStringForLinkHeaderQuotedParamValueContextReplacer(match) {
+  switch (match) {
+    case '"':
+      return '%22';
+
+    case "'":
+      return '%27';
+
+    case ';':
+      return '%3B';
+
+    case ',':
+      return '%2C';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeStringForLinkHeaderQuotedParamValueContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+}
+
+function hoistStyleQueueDependency(styleQueue) {
+  this.styles.add(styleQueue);
+}
+
+function hoistStylesheetDependency(stylesheet) {
+  this.stylesheets.add(stylesheet);
+}
+
+function hoistResources(renderState, source) {
+  const currentBoundaryResources = renderState.boundaryResources;
+
+  if (currentBoundaryResources) {
+    source.styles.forEach(hoistStyleQueueDependency, currentBoundaryResources);
+    source.stylesheets.forEach(hoistStylesheetDependency, currentBoundaryResources);
+  }
+} // This function is called at various times depending on whether we are rendering
+// or prerendering. In this implementation we only actually emit headers once and
+// subsequent calls are ignored. We track whether the request has a completed shell
+// to determine whether we will follow headers with a flush including stylesheets.
+// In the context of prerrender we don't have a completed shell when the request finishes
+// with a postpone in the shell. In the context of a render we don't have a completed shell
+// if this is called before the shell finishes rendering which usually will happen anytime
+// anything suspends in the shell.
+
+function emitEarlyPreloads(renderState, resumableState, shellComplete) {
+  const onHeaders = renderState.onHeaders;
+
+  if (onHeaders) {
+    const headers = renderState.headers;
+
+    if (headers) {
+      let linkHeader = headers.preconnects;
+
+      if (headers.fontPreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.fontPreloads;
+      }
+
+      if (headers.highImagePreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.highImagePreloads;
+      }
+
+      if (!shellComplete) {
+        // We use raw iterators because we want to be able to halt iteration
+        // We could refactor renderState to store these dually in arrays to
+        // make this more efficient at the cost of additional memory and
+        // write overhead. However this code only runs once per request so
+        // for now I consider this sufficient.
+        const queueIter = renderState.styles.values();
+
+        outer: for (let queueStep = queueIter.next(); headers.remainingCapacity > 0 && !queueStep.done; queueStep = queueIter.next()) {
+          const sheets = queueStep.value.sheets;
+          const sheetIter = sheets.values();
+
+          for (let sheetStep = sheetIter.next(); headers.remainingCapacity > 0 && !sheetStep.done; sheetStep = sheetIter.next()) {
+            const sheet = sheetStep.value;
+            const props = sheet.props;
+            const key = getResourceKey(props.href);
+            const header = getStylesheetPreloadAsHeader(sheet); // We mutate the capacity b/c we don't want to keep checking if later headers will fit.
+            // This means that a particularly long header might close out the header queue where later
+            // headers could still fit. We could in the future alter the behavior here based on prerender vs render
+            // since during prerender we aren't as concerned with pure runtime performance.
+
+            if ((headers.remainingCapacity -= header.length) >= 2) {
+              renderState.resets.style[key] = PRELOAD_NO_CREDS;
+
+              if (linkHeader) {
+                linkHeader += ', ';
+              }
+
+              linkHeader += header; // We already track that the resource exists in resumableState however
+              // if the resumableState resets because we postponed in the shell
+              // which is what is happening in this branch if we are prerendering
+              // then we will end up resetting the resumableState. When it resets we
+              // want to record the fact that this stylesheet was already preloaded
+
+              renderState.resets.style[key] = typeof props.crossOrigin === 'string' || typeof props.integrity === 'string' ? [props.crossOrigin, props.integrity] : PRELOAD_NO_CREDS;
+            } else {
+              break outer;
+            }
+          }
+        }
+      }
+
+      if (linkHeader) {
+        onHeaders({
+          Link: linkHeader
+        });
+      } else {
+        // We still call this with no headers because a user may be using it as a signal that
+        // it React will not provide any headers
+        onHeaders({});
+      }
+
+      renderState.headers = null;
+      return;
+    }
+  }
+}
+
+function createRenderState(resumableState, generateStaticMarkup) {
+  const renderState = createRenderState$1(resumableState, undefined, undefined, undefined, undefined, undefined);
+  return {
+    // Keep this in sync with ReactFizzConfigDOM
+    placeholderPrefix: renderState.placeholderPrefix,
+    segmentPrefix: renderState.segmentPrefix,
+    boundaryPrefix: renderState.boundaryPrefix,
+    startInlineScript: renderState.startInlineScript,
+    htmlChunks: renderState.htmlChunks,
+    headChunks: renderState.headChunks,
+    externalRuntimeScript: renderState.externalRuntimeScript,
+    bootstrapChunks: renderState.bootstrapChunks,
+    onHeaders: renderState.onHeaders,
+    headers: renderState.headers,
+    resets: renderState.resets,
+    charsetChunks: renderState.charsetChunks,
+    preconnectChunks: renderState.preconnectChunks,
+    importMapChunks: renderState.importMapChunks,
+    preloadChunks: renderState.preloadChunks,
+    hoistableChunks: renderState.hoistableChunks,
+    preconnects: renderState.preconnects,
+    fontPreloads: renderState.fontPreloads,
+    highImagePreloads: renderState.highImagePreloads,
+    // usedImagePreloads: renderState.usedImagePreloads,
+    styles: renderState.styles,
+    bootstrapScripts: renderState.bootstrapScripts,
+    scripts: renderState.scripts,
+    bulkPreloads: renderState.bulkPreloads,
+    preloads: renderState.preloads,
+    boundaryResources: renderState.boundaryResources,
+    stylesToHoist: renderState.stylesToHoist,
+    // This is an extra field for the legacy renderer
+    generateStaticMarkup
+  };
+}
+
+const doctypeChunk = stringToPrecomputedChunk('');
+function pushTextInstance(target, text, renderState, textEmbedded) {
+  if (renderState.generateStaticMarkup) {
+    target.push(stringToChunk(escapeTextForBrowser(text)));
+    return false;
+  } else {
+    return pushTextInstance$1(target, text, renderState, textEmbedded);
+  }
+}
+function pushSegmentFinale(target, renderState, lastPushedText, textEmbedded) {
+  if (renderState.generateStaticMarkup) {
+    return;
+  } else {
+    return pushSegmentFinale$1(target, renderState, lastPushedText, textEmbedded);
+  }
+}
+function writeStartCompletedSuspenseBoundary(destination, renderState) {
+  if (renderState.generateStaticMarkup) {
+    // A completed boundary is done and doesn't need a representation in the HTML
+    // if we're not going to be hydrating it.
+    return true;
+  }
+
+  return writeStartCompletedSuspenseBoundary$1(destination);
+}
+function writeStartClientRenderedSuspenseBoundary(destination, renderState, // flushing these error arguments are not currently supported in this legacy streaming format.
+errorDigest, errorMessage, errorComponentStack) {
+  if (renderState.generateStaticMarkup) {
+    // A client rendered boundary is done and doesn't need a representation in the HTML
+    // since we'll never hydrate it. This is arguably an error in static generation.
+    return true;
+  }
+
+  return writeStartClientRenderedSuspenseBoundary$1(destination, renderState, errorDigest);
+}
+function writeEndCompletedSuspenseBoundary(destination, renderState) {
+  if (renderState.generateStaticMarkup) {
+    return true;
+  }
+
+  return writeEndCompletedSuspenseBoundary$1(destination);
+}
+function writeEndClientRenderedSuspenseBoundary(destination, renderState) {
+  if (renderState.generateStaticMarkup) {
+    return true;
+  }
+
+  return writeEndClientRenderedSuspenseBoundary$1(destination);
+}
+const NotPendingTransition = NotPending;
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+const REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_CONTEXT_TYPE = Symbol.for('react.context');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SCOPE_TYPE = Symbol.for('react.scope');
+const REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');
+const REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+const REACT_LEGACY_HIDDEN_TYPE = Symbol.for('react.legacy_hidden');
+const REACT_CACHE_TYPE = Symbol.for('react.cache');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+function getWrappedName(outerType, innerType, wrapperName) {
+  const displayName = outerType.displayName;
+
+  if (displayName) {
+    return displayName;
+  }
+
+  const functionName = innerType.displayName || innerType.name || '';
+  return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
+} // Keep in sync with react-reconciler/getComponentNameFromFiber
+
+
+function getContextName(type) {
+  return type.displayName || 'Context';
+} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+
+function getComponentNameFromType(type) {
+  if (type == null) {
+    // Host root, text node or just invalid type.
+    return null;
+  }
+
+  if (typeof type === 'function') {
+    return type.displayName || type.name || null;
+  }
+
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_FRAGMENT_TYPE:
+      return 'Fragment';
+
+    case REACT_PORTAL_TYPE:
+      return 'Portal';
+
+    case REACT_PROFILER_TYPE:
+      return 'Profiler';
+
+    case REACT_STRICT_MODE_TYPE:
+      return 'StrictMode';
+
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+
+    case REACT_CACHE_TYPE:
+      {
+        return 'Cache';
+      }
+
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        const context = type;
+        return getContextName(context) + '.Consumer';
+
+      case REACT_PROVIDER_TYPE:
+        const provider = type;
+        return getContextName(provider._context) + '.Provider';
+
+      case REACT_FORWARD_REF_TYPE:
+        return getWrappedName(type, type.render, 'ForwardRef');
+
+      case REACT_MEMO_TYPE:
+        const outerName = type.displayName || null;
+
+        if (outerName !== null) {
+          return outerName;
+        }
+
+        return getComponentNameFromType(type.type) || 'Memo';
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            return getComponentNameFromType(init(payload));
+          } catch (x) {
+            return null;
+          }
+        }
+
+      case REACT_SERVER_CONTEXT_TYPE:
+        {
+          const context2 = type;
+          return (context2.displayName || context2._globalName) + '.Provider';
+        }
+
+    }
+  }
+
+  return null;
+}
+
+const emptyContextObject = {};
+
+function getMaskedContext(type, unmaskedContext) {
+  {
+    const contextTypes = type.contextTypes;
+
+    if (!contextTypes) {
+      return emptyContextObject;
+    }
+
+    const context = {};
+
+    for (const key in contextTypes) {
+      context[key] = unmaskedContext[key];
+    }
+
+    return context;
+  }
+}
+function processChildContext(instance, type, parentContext, childContextTypes) {
+  {
+    // TODO (bvaughn) Replace this behavior with an invariant() in the future.
+    // It has only been added in Fiber to match the (unintentional) behavior in Stack.
+    if (typeof instance.getChildContext !== 'function') {
+
+      return parentContext;
+    }
+
+    const childContext = instance.getChildContext();
+
+    for (const contextKey in childContext) {
+      if (!(contextKey in childContextTypes)) {
+        throw new Error((getComponentNameFromType(type) || 'Unknown') + ".getChildContext(): key \"" + contextKey + "\" is not defined in childContextTypes.");
+      }
+    }
+
+    return assign({}, parentContext, childContext);
+  }
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue2 = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue2 = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext);
+    } // On the way back, we push the new ones that weren't common.
+
+
+    pushNode(next);
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function pushProvider(context, nextValue) {
+  let prevValue;
+
+  {
+    prevValue = context._currentValue2;
+    context._currentValue2 = nextValue;
+  }
+
+  const prevNode = currentActiveSnapshot;
+  const newNode = {
+    parent: prevNode,
+    depth: prevNode === null ? 0 : prevNode.depth + 1,
+    context: context,
+    parentValue: prevValue,
+    value: nextValue
+  };
+  currentActiveSnapshot = newNode;
+  return newNode;
+}
+function popProvider(context) {
+  const prevSnapshot = currentActiveSnapshot;
+
+  if (prevSnapshot === null) {
+    throw new Error('Tried to pop a Context at the root of the app. This is a bug in React.');
+  }
+
+  {
+    const value = prevSnapshot.parentValue;
+
+    if (value === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      prevSnapshot.context._currentValue2 = prevSnapshot.context._defaultValue;
+    } else {
+      prevSnapshot.context._currentValue2 = value;
+    }
+  }
+
+  return currentActiveSnapshot = prevSnapshot.parent;
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue2;
+  return value;
+}
+
+/**
+ * `ReactInstanceMap` maintains a mapping from a public facing stateful
+ * instance (key) and the internal representation (value). This allows public
+ * methods to accept the user facing instance as an argument and map them back
+ * to internal methods.
+ *
+ * Note that this module is currently shared and assumed to be stateless.
+ * If this becomes an actual Map, that will break.
+ */
+function get(key) {
+  return key._reactInternals;
+}
+function set(key, value) {
+  key._reactInternals = value;
+}
+
+const classComponentUpdater = {
+  isMounted(inst) {
+    return false;
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueSetState(inst, payload, callback) {
+    const internals = get(inst);
+
+    if (internals.queue === null) ; else {
+      internals.queue.push(payload);
+    }
+  },
+
+  enqueueReplaceState(inst, payload, callback) {
+    const internals = get(inst);
+    internals.replace = true;
+    internals.queue = [payload];
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueForceUpdate(inst, callback) {
+  }
+
+};
+
+function applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, prevState, nextProps) {
+  const partialState = getDerivedStateFromProps(nextProps, prevState);
+
+
+  const newState = partialState === null || partialState === undefined ? prevState : assign({}, prevState, partialState);
+  return newState;
+}
+
+function constructClassInstance(ctor, props, maskedLegacyContext) {
+  let context = emptyContextObject;
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    context = readContext$1(contextType);
+  } else {
+    context = maskedLegacyContext;
+  }
+
+  const instance = new ctor(props, context);
+
+  return instance;
+}
+
+function callComponentWillMount(type, instance) {
+  const oldState = instance.state;
+
+  if (typeof instance.componentWillMount === 'function') {
+
+    instance.componentWillMount();
+  }
+
+  if (typeof instance.UNSAFE_componentWillMount === 'function') {
+    instance.UNSAFE_componentWillMount();
+  }
+
+  if (oldState !== instance.state) {
+
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+}
+
+function processUpdateQueue(internalInstance, inst, props, maskedLegacyContext) {
+  if (internalInstance.queue !== null && internalInstance.queue.length > 0) {
+    const oldQueue = internalInstance.queue;
+    const oldReplace = internalInstance.replace;
+    internalInstance.queue = null;
+    internalInstance.replace = false;
+
+    if (oldReplace && oldQueue.length === 1) {
+      inst.state = oldQueue[0];
+    } else {
+      let nextState = oldReplace ? oldQueue[0] : inst.state;
+      let dontMutate = true;
+
+      for (let i = oldReplace ? 1 : 0; i < oldQueue.length; i++) {
+        const partial = oldQueue[i];
+        const partialState = typeof partial === 'function' ? partial.call(inst, nextState, props, maskedLegacyContext) : partial;
+
+        if (partialState != null) {
+          if (dontMutate) {
+            dontMutate = false;
+            nextState = assign({}, nextState, partialState);
+          } else {
+            assign(nextState, partialState);
+          }
+        }
+      }
+
+      inst.state = nextState;
+    }
+  } else {
+    internalInstance.queue = null;
+  }
+} // Invokes the mount life-cycles on a previously never rendered instance.
+
+
+function mountClassInstance(instance, ctor, newProps, maskedLegacyContext) {
+
+  const initialState = instance.state !== undefined ? instance.state : null;
+  instance.updater = classComponentUpdater;
+  instance.props = newProps;
+  instance.state = initialState; // We don't bother initializing the refs object on the server, since we're not going to resolve them anyway.
+  // The internal instance will be used to manage updates that happen during this mount.
+
+  const internalInstance = {
+    queue: [],
+    replace: false
+  };
+  set(instance, internalInstance);
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    instance.context = readContext$1(contextType);
+  } else {
+    instance.context = maskedLegacyContext;
+  }
+
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    instance.state = applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, initialState, newProps);
+  } // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+
+  if (typeof ctor.getDerivedStateFromProps !== 'function' && typeof instance.getSnapshotBeforeUpdate !== 'function' && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
+    callComponentWillMount(ctor, instance); // If we had additional state updates during this life-cycle, let's
+    // process them now.
+
+    processUpdateQueue(internalInstance, instance, newProps, maskedLegacyContext);
+  }
+}
+
+// Ids are base 32 strings whose binary representation corresponds to the
+// position of a node in a tree.
+// Every time the tree forks into multiple children, we add additional bits to
+// the left of the sequence that represent the position of the child within the
+// current level of children.
+//
+//      00101       00010001011010101
+//      ╰─┬─╯       ╰───────┬───────╯
+//   Fork 5 of 20       Parent id
+//
+// The leading 0s are important. In the above example, you only need 3 bits to
+// represent slot 5. However, you need 5 bits to represent all the forks at
+// the current level, so we must account for the empty bits at the end.
+//
+// For this same reason, slots are 1-indexed instead of 0-indexed. Otherwise,
+// the zeroth id at a level would be indistinguishable from its parent.
+//
+// If a node has only one child, and does not materialize an id (i.e. does not
+// contain a useId hook), then we don't need to allocate any space in the
+// sequence. It's treated as a transparent indirection. For example, these two
+// trees produce the same ids:
+//
+// <>                          <>
+//   <Indirection>               <A />
+//     <A />                     <B />
+//   </Indirection>            </>
+//   <B />
+// </>
+//
+// However, we cannot skip any node that materializes an id. Otherwise, a parent
+// id that does not fork would be indistinguishable from its child id. For
+// example, this tree does not fork, but the parent and child must have
+// different ids.
+//
+// <Parent>
+//   <Child />
+// </Parent>
+//
+// To handle this scenario, every time we materialize an id, we allocate a
+// new level with a single slot. You can think of this as a fork with only one
+// prong, or an array of children with length 1.
+//
+// It's possible for the size of the sequence to exceed 32 bits, the max
+// size for bitwise operations. When this happens, we make more room by
+// converting the right part of the id to a string and storing it in an overflow
+// variable. We use a base 32 string representation, because 32 is the largest
+// power of 2 that is supported by toString(). We want the base to be large so
+// that the resulting ids are compact, and we want the base to be a power of 2
+// because every log2(base) bits corresponds to a single character, i.e. every
+// log2(32) = 5 bits. That means we can lop bits off the end 5 at a time without
+// affecting the final result.
+const emptyTreeContext = {
+  id: 1,
+  overflow: ''
+};
+function getTreeId(context) {
+  const overflow = context.overflow;
+  const idWithLeadingBit = context.id;
+  const id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
+  return id.toString(32) + overflow;
+}
+function pushTreeContext(baseContext, totalChildren, index) {
+  const baseIdWithLeadingBit = baseContext.id;
+  const baseOverflow = baseContext.overflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
+  // of the id; we use it to account for leading 0s.
+
+  const baseLength = getBitLength(baseIdWithLeadingBit) - 1;
+  const baseId = baseIdWithLeadingBit & ~(1 << baseLength);
+  const slot = index + 1;
+  const length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
+  // consideration the leading 1 we use to mark the end of the sequence.
+
+  if (length > 30) {
+    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
+    // This branch assumes the length of the base id is greater than 5; it won't
+    // work for smaller ids, because you need 5 bits per character.
+    //
+    // We encode the id in multiple steps: first the base id, then the
+    // remaining digits.
+    //
+    // Each 5 bit sequence corresponds to a single base 32 character. So for
+    // example, if the current id is 23 bits long, we can convert 20 of those
+    // bits into a string of 4 characters, with 3 bits left over.
+    //
+    // First calculate how many bits in the base id represent a complete
+    // sequence of characters.
+    const numberOfOverflowBits = baseLength - baseLength % 5; // Then create a bitmask that selects only those bits.
+
+    const newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
+
+    const newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
+
+    const restOfBaseId = baseId >> numberOfOverflowBits;
+    const restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
+    // we made more room, this time it won't overflow.
+
+    const restOfLength = getBitLength(totalChildren) + restOfBaseLength;
+    const restOfNewBits = slot << restOfBaseLength;
+    const id = restOfNewBits | restOfBaseId;
+    const overflow = newOverflow + baseOverflow;
+    return {
+      id: 1 << restOfLength | id,
+      overflow
+    };
+  } else {
+    // Normal path
+    const newBits = slot << baseLength;
+    const id = newBits | baseId;
+    const overflow = baseOverflow;
+    return {
+      id: 1 << length | id,
+      overflow
+    };
+  }
+}
+
+function getBitLength(number) {
+  return 32 - clz32(number);
+}
+
+function getLeadingBit(id) {
+  return 1 << getBitLength(id) - 1;
+} // TODO: Math.clz32 is supported in Node 12+. Maybe we can drop the fallback.
+
+
+const 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
+
+const log = Math.log;
+const LN2 = Math.LN2;
+
+function clz32Fallback(x) {
+  const asUint = x >>> 0;
+
+  if (asUint === 0) {
+    return 32;
+  }
+
+  return 31 - (log(asUint) / LN2 | 0) | 0;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFlightWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop$2() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop$2, noop$2);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+
+const objectIs = // $FlowFixMe[method-unbinding]
+typeof Object.is === 'function' ? Object.is : is;
+
+let currentlyRenderingComponent = null;
+let currentlyRenderingTask = null;
+let currentlyRenderingRequest = null;
+let currentlyRenderingKeyPath = null;
+let firstWorkInProgressHook = null;
+let workInProgressHook = null; // Whether the work-in-progress hook is a re-rendered hook
+
+let isReRender = false; // Whether an update was scheduled during the currently executing render pass.
+
+let didScheduleRenderPhaseUpdate = false; // Counts the number of useId hooks in this component
+
+let localIdCounter = 0; // Chunks that should be pushed to the stream once the component
+// finishes rendering.
+// Counts the number of useFormState calls in this component
+
+let formStateCounter = 0; // The index of the useFormState hook that matches the one passed in at the
+// root during an MPA navigation, if any.
+
+let formStateMatchingIndex = -1; // Counts the number of use(thenable) calls in this component
+
+let thenableIndexCounter = 0;
+let thenableState = null; // Lazily created map of render-phase updates
+
+let renderPhaseUpdates = null; // Counter to prevent infinite loops.
+
+let numberOfReRenders = 0;
+const RE_RENDER_LIMIT = 25;
+
+function resolveCurrentlyRenderingComponent() {
+  if (currentlyRenderingComponent === null) {
+    throw new Error('Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for' + ' one of the following reasons:\n' + '1. You might have mismatching versions of React and the renderer (such as React DOM)\n' + '2. You might be breaking the Rules of Hooks\n' + '3. You might have more than one copy of React in the same app\n' + 'See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.');
+  }
+
+  return currentlyRenderingComponent;
+}
+
+function areHookInputsEqual(nextDeps, prevDeps) {
+  if (prevDeps === null) {
+
+    return false;
+  }
+
+
+  for (let i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    if (objectIs(nextDeps[i], prevDeps[i])) {
+      continue;
+    }
+
+    return false;
+  }
+
+  return true;
+}
+
+function createHook() {
+  if (numberOfReRenders > 0) {
+    throw new Error('Rendered more hooks than during the previous render');
+  }
+
+  return {
+    memoizedState: null,
+    queue: null,
+    next: null
+  };
+}
+
+function createWorkInProgressHook() {
+  if (workInProgressHook === null) {
+    // This is the first hook in the list
+    if (firstWorkInProgressHook === null) {
+      isReRender = false;
+      firstWorkInProgressHook = workInProgressHook = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = firstWorkInProgressHook;
+    }
+  } else {
+    if (workInProgressHook.next === null) {
+      isReRender = false; // Append to the end of the list
+
+      workInProgressHook = workInProgressHook.next = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = workInProgressHook.next;
+    }
+  }
+
+  return workInProgressHook;
+}
+
+function prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState) {
+  currentlyRenderingComponent = componentIdentity;
+  currentlyRenderingTask = task;
+  currentlyRenderingRequest = request;
+  currentlyRenderingKeyPath = keyPath;
+  // didScheduleRenderPhaseUpdate = false;
+  // firstWorkInProgressHook = null;
+  // numberOfReRenders = 0;
+  // renderPhaseUpdates = null;
+  // workInProgressHook = null;
+
+
+  localIdCounter = 0;
+  formStateCounter = 0;
+  formStateMatchingIndex = -1;
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function finishHooks(Component, props, children, refOrContext) {
+  // This must be called after every function component to prevent hooks from
+  // being used in classes.
+  while (didScheduleRenderPhaseUpdate) {
+    // Updates were scheduled during the render phase. They are stored in
+    // the `renderPhaseUpdates` map. Call the component again, reusing the
+    // work-in-progress hooks and applying the additional updates on top. Keep
+    // restarting until no more updates are scheduled.
+    didScheduleRenderPhaseUpdate = false;
+    localIdCounter = 0;
+    formStateCounter = 0;
+    formStateMatchingIndex = -1;
+    thenableIndexCounter = 0;
+    numberOfReRenders += 1; // Start over from the beginning of the list
+
+    workInProgressHook = null;
+    children = Component(props, refOrContext);
+  }
+
+  resetHooksState();
+  return children;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+function checkDidRenderIdHook() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  const didRenderIdHook = localIdCounter !== 0;
+  return didRenderIdHook;
+}
+function getFormStateCount() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateCounter;
+}
+function getFormStateMatchingIndex() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateMatchingIndex;
+} // Reset the internal hooks state if an error occurs while rendering a component
+
+function resetHooksState() {
+
+  currentlyRenderingComponent = null;
+  currentlyRenderingTask = null;
+  currentlyRenderingRequest = null;
+  currentlyRenderingKeyPath = null;
+  didScheduleRenderPhaseUpdate = false;
+  firstWorkInProgressHook = null;
+  numberOfReRenders = 0;
+  renderPhaseUpdates = null;
+  workInProgressHook = null;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+function useContext(context) {
+
+  resolveCurrentlyRenderingComponent();
+  return readContext$1(context);
+}
+
+function basicStateReducer(state, action) {
+  // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
+  return typeof action === 'function' ? action(state) : action;
+}
+
+function useState(initialState) {
+
+  return useReducer(basicStateReducer, // useReducer has a special case to support lazy useState initializers
+  initialState);
+}
+function useReducer(reducer, initialArg, init) {
+
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+
+  if (isReRender) {
+    // This is a re-render. Apply the new render phase updates to the previous
+    // current hook.
+    const queue = workInProgressHook.queue;
+    const dispatch = queue.dispatch;
+
+    if (renderPhaseUpdates !== null) {
+      // Render phase updates are stored in a map of queue -> linked list
+      const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+      if (firstRenderPhaseUpdate !== undefined) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        renderPhaseUpdates.delete(queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+        let newState = workInProgressHook.memoizedState;
+        let update = firstRenderPhaseUpdate;
+
+        do {
+          // Process this render phase update. We don't have to check the
+          // priority because it will always be the same as the current
+          // render's.
+          const action = update.action;
+
+          newState = reducer(newState, action);
+
+
+          update = update.next;
+        } while (update !== null); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+        workInProgressHook.memoizedState = newState;
+        return [newState, dispatch];
+      }
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    return [workInProgressHook.memoizedState, dispatch];
+  } else {
+
+    let initialState;
+
+    if (reducer === basicStateReducer) {
+      // Special case for `useState`.
+      initialState = typeof initialArg === 'function' ? initialArg() : initialArg;
+    } else {
+      initialState = init !== undefined ? init(initialArg) : initialArg;
+    }
+
+
+    workInProgressHook.memoizedState = initialState; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    const queue = workInProgressHook.queue = {
+      last: null,
+      dispatch: null
+    };
+    const dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingComponent, queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    return [workInProgressHook.memoizedState, dispatch];
+  }
+}
+
+function useMemo(nextCreate, deps) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+
+  if (workInProgressHook !== null) {
+    const prevState = workInProgressHook.memoizedState;
+
+    if (prevState !== null) {
+      if (nextDeps !== null) {
+        const prevDeps = prevState[1];
+
+        if (areHookInputsEqual(nextDeps, prevDeps)) {
+          return prevState[0];
+        }
+      }
+    }
+  }
+
+  const nextValue = nextCreate();
+
+
+  workInProgressHook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
+
+function useRef(initialValue) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const previousRef = workInProgressHook.memoizedState;
+
+  if (previousRef === null) {
+    const ref = {
+      current: initialValue
+    };
+
+
+    workInProgressHook.memoizedState = ref;
+    return ref;
+  } else {
+    return previousRef;
+  }
+}
+
+function dispatchAction(componentIdentity, queue, action) {
+  if (numberOfReRenders >= RE_RENDER_LIMIT) {
+    throw new Error('Too many re-renders. React limits the number of renders to prevent ' + 'an infinite loop.');
+  }
+
+  if (componentIdentity === currentlyRenderingComponent) {
+    // This is a render phase update. Stash it in a lazily-created map of
+    // queue -> linked list of updates. After this render pass, we'll restart
+    // and apply the stashed updates on top of the work-in-progress hook.
+    didScheduleRenderPhaseUpdate = true;
+    const update = {
+      action,
+      next: null
+    };
+
+    if (renderPhaseUpdates === null) {
+      renderPhaseUpdates = new Map();
+    }
+
+    const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+    if (firstRenderPhaseUpdate === undefined) {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      renderPhaseUpdates.set(queue, update);
+    } else {
+      // Append the update to the end of the list.
+      let lastRenderPhaseUpdate = firstRenderPhaseUpdate;
+
+      while (lastRenderPhaseUpdate.next !== null) {
+        lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+      }
+
+      lastRenderPhaseUpdate.next = update;
+    }
+  }
+}
+
+function useCallback(callback, deps) {
+  return useMemo(() => callback, deps);
+}
+
+function throwOnUseEffectEventCall() {
+  throw new Error("A function wrapped in useEffectEvent can't be called during rendering.");
+}
+
+function useEffectEvent(callback) {
+  // $FlowIgnore[incompatible-return]
+  return throwOnUseEffectEventCall;
+}
+
+function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  if (getServerSnapshot === undefined) {
+    throw new Error('Missing getServerSnapshot, which is required for ' + 'server-rendered content. Will revert to client rendering.');
+  }
+
+  return getServerSnapshot();
+}
+
+function useDeferredValue(value, initialValue) {
+  resolveCurrentlyRenderingComponent();
+
+  {
+    return initialValue !== undefined ? initialValue : value;
+  }
+}
+
+function unsupportedStartTransition() {
+  throw new Error('startTransition cannot be called during server rendering.');
+}
+
+function useTransition() {
+  resolveCurrentlyRenderingComponent();
+  return [false, unsupportedStartTransition];
+}
+
+function useHostTransitionStatus() {
+  resolveCurrentlyRenderingComponent();
+  return NotPendingTransition;
+}
+
+function unsupportedSetOptimisticState() {
+  throw new Error('Cannot update optimistic state while rendering.');
+}
+
+function useOptimistic(passthrough, reducer) {
+  resolveCurrentlyRenderingComponent();
+  return [passthrough, unsupportedSetOptimisticState];
+}
+
+function createPostbackFormStateKey(permalink, componentKeyPath, hookIndex) {
+  if (permalink !== undefined) {
+    // Don't bother to hash a permalink-based key since it's already short.
+    return 'p' + permalink;
+  } else {
+    // Append a node to the key path that represents the form state hook.
+    const keyPath = [componentKeyPath, null, hookIndex]; // Key paths are hashed to reduce the size. It does not need to be secure,
+    // and it's more important that it's fast than that it's completely
+    // collision-free.
+
+    const keyPathHash = createFastHashJS(JSON.stringify(keyPath));
+    return 'k' + keyPathHash;
+  }
+}
+
+function useFormState(action, initialState, permalink) {
+  resolveCurrentlyRenderingComponent(); // Count the number of useFormState hooks per component. We also use this to
+  // track the position of this useFormState hook relative to the other ones in
+  // this component, so we can generate a unique key for each one.
+
+  const formStateHookIndex = formStateCounter++;
+  const request = currentlyRenderingRequest; // $FlowIgnore[prop-missing]
+
+  const formAction = action.$$FORM_ACTION;
+
+  if (typeof formAction === 'function') {
+    // This is a server action. These have additional features to enable
+    // MPA-style form submissions with progressive enhancement.
+    // TODO: If the same permalink is passed to multiple useFormStates, and
+    // they all have the same action signature, Fizz will pass the postback
+    // state to all of them. We should probably only pass it to the first one,
+    // and/or warn.
+    // The key is lazily generated and deduped so the that the keypath doesn't
+    // get JSON.stringify-ed unnecessarily, and at most once.
+    let nextPostbackStateKey = null; // Determine the current form state. If we received state during an MPA form
+    // submission, then we will reuse that, if the action identity matches.
+    // Otherwise we'll use the initial state argument. We will emit a comment
+    // marker into the stream that indicates whether the state was reused.
+
+    let state = initialState;
+    const componentKeyPath = currentlyRenderingKeyPath;
+    const postbackFormState = getFormState(request); // $FlowIgnore[prop-missing]
+
+    const isSignatureEqual = action.$$IS_SIGNATURE_EQUAL;
+
+    if (postbackFormState !== null && typeof isSignatureEqual === 'function') {
+      const postbackKey = postbackFormState[1];
+      const postbackReferenceId = postbackFormState[2];
+      const postbackBoundArity = postbackFormState[3];
+
+      if (isSignatureEqual.call(action, postbackReferenceId, postbackBoundArity)) {
+        nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+
+        if (postbackKey === nextPostbackStateKey) {
+          // This was a match
+          formStateMatchingIndex = formStateHookIndex; // Reuse the state that was submitted by the form.
+
+          state = postbackFormState[0];
+        }
+      }
+    } // Bind the state to the first argument of the action.
+
+
+    const boundAction = action.bind(null, state); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    }; // $FlowIgnore[prop-missing]
+
+
+    if (typeof boundAction.$$FORM_ACTION === 'function') {
+      // $FlowIgnore[prop-missing]
+      dispatch.$$FORM_ACTION = prefix => {
+        const metadata = boundAction.$$FORM_ACTION(prefix); // Override the action URL
+
+        if (permalink !== undefined) {
+
+          permalink += '';
+          metadata.action = permalink;
+        }
+
+        const formData = metadata.data;
+
+        if (formData) {
+          if (nextPostbackStateKey === null) {
+            nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+          }
+
+          formData.append('$ACTION_KEY', nextPostbackStateKey);
+        }
+
+        return metadata;
+      };
+    }
+
+    return [state, dispatch];
+  } else {
+    // This is not a server action, so the implementation is much simpler.
+    // Bind the state to the first argument of the action.
+    const boundAction = action.bind(null, initialState); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    };
+
+    return [initialState, dispatch];
+  }
+}
+
+function useId() {
+  const task = currentlyRenderingTask;
+  const treeId = getTreeId(task.treeContext);
+  const resumableState = currentResumableState;
+
+  if (resumableState === null) {
+    throw new Error('Invalid hook call. Hooks can only be called inside of the body of a function component.');
+  }
+
+  const localId = localIdCounter++;
+  return makeId(resumableState, treeId, localId);
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable;
+      return unwrapThenable(thenable);
+    } else if (usable.$$typeof === REACT_CONTEXT_TYPE || usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function unwrapThenable(thenable) {
+  const index = thenableIndexCounter;
+  thenableIndexCounter += 1;
+
+  if (thenableState === null) {
+    thenableState = createThenableState();
+  }
+
+  return trackUsedThenable(thenableState, thenable, index);
+}
+
+function unsupportedRefresh() {
+  throw new Error('Cache cannot be refreshed during server rendering.');
+}
+
+function useCacheRefresh() {
+  return unsupportedRefresh;
+}
+
+function useMemoCache(size) {
+  const data = new Array(size);
+
+  for (let i = 0; i < size; i++) {
+    data[i] = REACT_MEMO_CACHE_SENTINEL;
+  }
+
+  return data;
+}
+
+function noop$1() {}
+
+const HooksDispatcher = {
+  readContext,
+  use,
+  useContext,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+  useInsertionEffect: noop$1,
+  useLayoutEffect: noop$1,
+  useCallback,
+  // useImperativeHandle is not run in the server environment
+  useImperativeHandle: noop$1,
+  // Effects are not run in the server environment.
+  useEffect: noop$1,
+  // Debugging effect
+  useDebugValue: noop$1,
+  useDeferredValue,
+  useTransition,
+  useId,
+  // Subscriptions are not setup in a server environment.
+  useSyncExternalStore
+};
+
+{
+  HooksDispatcher.useCacheRefresh = useCacheRefresh;
+}
+
+{
+  HooksDispatcher.useEffectEvent = useEffectEvent;
+}
+
+{
+  HooksDispatcher.useMemoCache = useMemoCache;
+}
+
+{
+  HooksDispatcher.useHostTransitionStatus = useHostTransitionStatus;
+}
+
+{
+  HooksDispatcher.useOptimistic = useOptimistic;
+  HooksDispatcher.useFormState = useFormState;
+}
+
+let currentResumableState = null;
+function setCurrentResumableState(resumableState) {
+  currentResumableState = resumableState;
+}
+
+function getCacheSignal() {
+  throw new Error('Not implemented.');
+}
+
+function getCacheForType(resourceType) {
+  throw new Error('Not implemented.');
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal,
+  getCacheForType
+};
+
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+const ReactCurrentCache = ReactSharedInternals.ReactCurrentCache;
+// The name might be minified but we assume that it's going to be the same generated name. Typically
+// because it's just the same compiled output in practice.
+// resume with segmentID at the index
+
+const CLIENT_RENDERED = 4; // if it errors or infinitely suspends
+
+const PENDING = 0;
+const COMPLETED = 1;
+const FLUSHED = 2;
+const ABORTED = 3;
+const ERRORED = 4;
+const POSTPONED = 5;
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2; // This is a default heuristic for how to split up the HTML content into progressive
+// loading. Our goal is to be able to display additional new content about every 500ms.
+// Faster than that is unnecessary and should be throttled on the client. It also
+// adds unnecessary overhead to do more splits. We don't know if it's a higher or lower
+// end device but higher end suffer less from the overhead than lower end does from
+// not getting small enough pieces. We error on the side of low end.
+// We base this on low end 3G speeds which is about 500kbits per second. We assume
+// that there can be a reasonable drop off from max bandwidth which leaves you with
+// as little as 80%. We can receive half of that each 500ms - at best. In practice,
+// a little bandwidth is lost to processing and contention - e.g. CSS and images that
+// are downloaded along with the main content. So we estimate about half of that to be
+// the lower end throughput. In other words, we expect that you can at least show
+// about 12.5kb of content per 500ms. Not counting starting latency for the first
+// paint.
+// 500 * 1024 / 8 * .8 * 0.5 / 2
+
+const DEFAULT_PROGRESSIVE_CHUNK_SIZE = 12800;
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+
+  return null;
+}
+
+function noop() {}
+
+function createRequest(children, resumableState, renderState, rootFormatContext, progressiveChunkSize, onError, onAllReady, onShellReady, onShellError, onFatalError, onPostpone, formState) {
+  prepareHostDispatcher();
+  const pingedTasks = [];
+  const abortSet = new Set();
+  const request = {
+    destination: null,
+    flushScheduled: false,
+    resumableState,
+    renderState,
+    rootFormatContext,
+    progressiveChunkSize: progressiveChunkSize === undefined ? DEFAULT_PROGRESSIVE_CHUNK_SIZE : progressiveChunkSize,
+    status: OPEN,
+    fatalError: null,
+    nextSegmentId: 0,
+    allPendingTasks: 0,
+    pendingRootTasks: 0,
+    completedRootSegment: null,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    clientRenderedBoundaries: [],
+    completedBoundaries: [],
+    partialBoundaries: [],
+    trackedPostpones: null,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? noop : onPostpone,
+    onAllReady: onAllReady === undefined ? noop : onAllReady,
+    onShellReady: onShellReady === undefined ? noop : onShellReady,
+    onShellError: onShellError === undefined ? noop : onShellError,
+    onFatalError: onFatalError === undefined ? noop : onFatalError,
+    formState: formState === undefined ? null : formState
+  }; // This segment represents the root fallback.
+
+  const rootSegment = createPendingSegment(request, 0, null, rootFormatContext, // Root segments are never embedded in Text on either edge
+  false, false); // There is no parent so conceptually, we're unblocked to flush this segment.
+
+  rootSegment.parentFlushed = true;
+  const rootTask = createRenderTask(request, null, children, -1, null, rootSegment, abortSet, null, rootFormatContext, emptyContextObject, rootContextSnapshot, emptyTreeContext);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  return null;
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (request.pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createSuspenseBoundary(request, fallbackAbortableTasks) {
+  return {
+    status: PENDING,
+    rootSegmentID: -1,
+    parentFlushed: false,
+    pendingTasks: 0,
+    completedSegments: [],
+    byteSize: 0,
+    fallbackAbortableTasks,
+    errorDigest: null,
+    resources: createBoundaryResources(),
+    trackedContentKeyPath: null,
+    trackedFallbackNode: null
+  };
+}
+
+function createRenderTask(request, thenableState, node, childIndex, blockedBoundary, blockedSegment, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  const task = {
+    replay: null,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createReplayTask(request, thenableState, replay, node, childIndex, blockedBoundary, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  replay.pendingTasks++;
+  const task = {
+    replay,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment: null,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createPendingSegment(request, index, boundary, parentFormatContext, lastPushedText, textEmbedded) {
+  return {
+    status: PENDING,
+    id: -1,
+    // lazily assigned later
+    index,
+    parentFlushed: false,
+    chunks: [],
+    children: [],
+    parentFormatContext,
+    boundary,
+    lastPushedText,
+    textEmbedded
+  };
+} // DEV-only global reference to the currently executing task
+
+function popComponentStackInDEV(task) {
+} // stash the component stack of an unwinding error until it is processed
+
+function logPostpone(request, reason) {
+  // If this callback errors, we intentionally let that error bubble up to become a fatal error
+  // so that someone fixes the error reporting instead of hiding it.
+  request.onPostpone(reason);
+}
+
+function logRecoverableError(request, error) {
+  // If this callback errors, we intentionally let that error bubble up to become a fatal error
+  // so that someone fixes the error reporting instead of hiding it.
+  const errorDigest = request.onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest;
+}
+
+function fatalError(request, error) {
+  // This is called outside error handling code such as if the root errors outside
+  // a suspense boundary or if the root suspense boundary's fallback errors.
+  // It's also called if React itself or its host configs errors.
+  const onShellError = request.onShellError;
+  onShellError(error);
+  const onFatalError = request.onFatalError;
+  onFatalError(error);
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function renderSuspenseBoundary(request, someTask, keyPath, props) {
+  if (someTask.replay !== null) {
+    // If we're replaying through this pass, it means we're replaying through
+    // an already completed Suspense boundary. It's too late to do anything about it
+    // so we can just render through it.
+    const prevKeyPath = someTask.keyPath;
+    someTask.keyPath = keyPath;
+    const content = props.children;
+
+    try {
+      renderNode(request, someTask, content, -1);
+    } finally {
+      someTask.keyPath = prevKeyPath;
+    }
+
+    return;
+  } // $FlowFixMe: Refined.
+
+
+  const task = someTask;
+  const prevKeyPath = task.keyPath;
+  const parentBoundary = task.blockedBoundary;
+  const parentSegment = task.blockedSegment; // Each time we enter a suspense boundary, we split out into a new segment for
+  // the fallback so that we can later replace that segment with the content.
+  // This also lets us split out the main content even if it doesn't suspend,
+  // in case it ends up generating a large subtree of content.
+
+  const fallback = props.fallback;
+  const content = props.children;
+  const fallbackAbortSet = new Set();
+  const newBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+
+  if (request.trackedPostpones !== null) {
+    newBoundary.trackedContentKeyPath = keyPath;
+  }
+
+  const insertionIndex = parentSegment.chunks.length; // The children of the boundary segment is actually the fallback.
+
+  const boundarySegment = createPendingSegment(request, insertionIndex, newBoundary, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false);
+  parentSegment.children.push(boundarySegment); // The parentSegment has a child Segment at this index so we reset the lastPushedText marker on the parent
+
+  parentSegment.lastPushedText = false; // This segment is the actual child content. We can start rendering that immediately.
+
+  const contentRootSegment = createPendingSegment(request, 0, null, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false); // We mark the root segment as having its parent flushed. It's not really flushed but there is
+  // no parent segment so there's nothing to wait on.
+
+  contentRootSegment.parentFlushed = true; // Currently this is running synchronously. We could instead schedule this to pingedTasks.
+  // I suspect that there might be some efficiency benefits from not creating the suspended task
+  // and instead just using the stack if possible.
+  // TODO: Call this directly instead of messing with saving and restoring contexts.
+  // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and which segment
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = newBoundary;
+  task.blockedSegment = contentRootSegment;
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, newBoundary.resources);
+  }
+
+  task.keyPath = keyPath;
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+    pushSegmentFinale(contentRootSegment.chunks, request.renderState, contentRootSegment.lastPushedText, contentRootSegment.textEmbedded);
+    contentRootSegment.status = COMPLETED;
+    queueCompletedSegment(newBoundary, contentRootSegment);
+
+    if (newBoundary.pendingTasks === 0 && newBoundary.status === PENDING) {
+      newBoundary.status = COMPLETED; // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    contentRootSegment.status = ERRORED;
+    newBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+      const postponeInstance = error;
+      logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+      errorDigest = 'POSTPONE';
+    } else {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    newBoundary.errorDigest = errorDigest;
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.blockedSegment = parentSegment;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]];
+  const trackedPostpones = request.trackedPostpones;
+
+  if (trackedPostpones !== null) {
+    // We create a detached replay node to track any postpones inside the fallback.
+    const fallbackReplayNode = [fallbackKeyPath[1], fallbackKeyPath[2], [], null];
+    trackedPostpones.workingMap.set(fallbackKeyPath, fallbackReplayNode);
+
+    if (newBoundary.status === POSTPONED) {
+      // This must exist now.
+      const boundaryReplayNode = trackedPostpones.workingMap.get(keyPath);
+      boundaryReplayNode[4] = fallbackReplayNode;
+    } else {
+      // We might not inject it into the postponed tree, unless the content actually
+      // postpones too. We need to keep track of it until that happpens.
+      newBoundary.trackedFallbackNode = fallbackReplayNode;
+    }
+  } // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+
+  const suspendedFallbackTask = createRenderTask(request, null, fallback, -1, parentBoundary, boundarySegment, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function replaySuspenseBoundary(request, task, keyPath, props, id, childNodes, childSlots, fallbackNodes, fallbackSlots) {
+  const prevKeyPath = task.keyPath;
+  const previousReplaySet = task.replay;
+  const parentBoundary = task.blockedBoundary;
+  const content = props.children;
+  const fallback = props.fallback;
+  const fallbackAbortSet = new Set();
+  const resumedBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = id; // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and replay node
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = resumedBoundary;
+  task.replay = {
+    nodes: childNodes,
+    slots: childSlots,
+    pendingTasks: 1
+  };
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, resumedBoundary.resources);
+  }
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+    }
+
+    task.replay.pendingTasks--;
+
+    if (resumedBoundary.pendingTasks === 0 && resumedBoundary.status === PENDING) {
+      resumedBoundary.status = COMPLETED;
+      request.completedBoundaries.push(resumedBoundary); // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    resumedBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+      const postponeInstance = error;
+      logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+      errorDigest = 'POSTPONE';
+    } else {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    resumedBoundary.errorDigest = errorDigest;
+
+    task.replay.pendingTasks--; // The parent already flushed in the prerender so we need to schedule this to be emitted.
+
+    request.clientRenderedBoundaries.push(resumedBoundary); // We don't need to decrement any task numbers because we didn't spawn any new task.
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.replay = previousReplaySet;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]]; // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+  const fallbackReplay = {
+    nodes: fallbackNodes,
+    slots: fallbackSlots,
+    pendingTasks: 0
+  };
+  const suspendedFallbackTask = createReplayTask(request, null, fallbackReplay, fallback, -1, parentBoundary, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function renderHostElement(request, task, keyPath, type, props) {
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    const children = props.children; // TODO: Make this a Config for replaying.
+
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+  } else {
+    // Render
+    const children = pushStartInstance(segment.chunks, type, props, request.resumableState, request.renderState, task.formatContext, segment.lastPushedText);
+    segment.lastPushedText = false;
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+    pushEndInstance(segment.chunks, type, props, request.resumableState, prevContext);
+    segment.lastPushedText = false;
+  }
+}
+
+function shouldConstruct(Component) {
+  return Component.prototype && Component.prototype.isReactComponent;
+}
+
+function renderWithHooks(request, task, keyPath, prevThenableState, Component, props, secondArg) {
+  const componentIdentity = {};
+  prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState);
+  const result = Component(props, secondArg);
+  return finishHooks(Component, props, result, secondArg);
+}
+
+function finishClassComponent(request, task, keyPath, instance, Component, props) {
+  const nextChildren = instance.render();
+
+  {
+    const childContextTypes = Component.childContextTypes;
+
+    if (childContextTypes !== null && childContextTypes !== undefined) {
+      const previousContext = task.legacyContext;
+      const mergedContext = processChildContext(instance, Component, previousContext, childContextTypes);
+      task.legacyContext = mergedContext;
+      renderNodeDestructive(request, task, null, nextChildren, -1);
+      task.legacyContext = previousContext;
+      return;
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, nextChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderClassComponent(request, task, keyPath, Component, props) {
+  const maskedContext = getMaskedContext(Component, task.legacyContext) ;
+  const instance = constructClassInstance(Component, props, maskedContext);
+  mountClassInstance(instance, Component, props, maskedContext);
+  finishClassComponent(request, task, keyPath, instance, Component);
+}
+// components for some reason.
+
+function renderIndeterminateComponent(request, task, keyPath, prevThenableState, Component, props) {
+  let legacyContext;
+
+  {
+    legacyContext = getMaskedContext(Component, task.legacyContext);
+  }
+
+  const value = renderWithHooks(request, task, keyPath, prevThenableState, Component, props, legacyContext);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+
+  if ( // Run these checks in production only if the flag is off.
+  // Eventually we'll delete this branch altogether.
+  typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) {
+
+    mountClassInstance(value, Component, props, legacyContext);
+    finishClassComponent(request, task, keyPath, value, Component);
+  } else {
+
+    finishFunctionComponent(request, task, keyPath, value, hasId, formStateCount, formStateMatchingIndex);
+  }
+}
+
+function finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex) {
+  let didEmitFormStateMarkers = false;
+
+  if (formStateCount !== 0 && request.formState !== null) {
+    // For each useFormState hook, emit a marker that indicates whether we
+    // rendered using the form state passed at the root. We only emit these
+    // markers if form state is passed at the root.
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      didEmitFormStateMarkers = true;
+      const target = segment.chunks;
+
+      for (let i = 0; i < formStateCount; i++) {
+        if (i === formStateMatchingIndex) {
+          pushFormStateMarkerIsMatching(target);
+        } else {
+          pushFormStateMarkerIsNotMatching(target);
+        }
+      }
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+
+  if (hasId) {
+    // This component materialized an id. We treat this as its own level, with
+    // a single "child" slot.
+    const prevTreeContext = task.treeContext;
+    const totalChildren = 1;
+    const index = 0; // Modify the id context. Because we'll need to reset this if something
+    // suspends or errors, we'll use the non-destructive render path.
+
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, index);
+    renderNode(request, task, children, -1); // Like the other contexts, this does not need to be in a finally block
+    // because renderNode takes care of unwinding the stack.
+
+    task.treeContext = prevTreeContext;
+  } else if (didEmitFormStateMarkers) {
+    // If there were formState hooks, we must use the non-destructive path
+    // because this component is not a pure indirection; we emitted markers
+    // to the stream.
+    renderNode(request, task, children, -1);
+  } else {
+    // We're now successfully past this task, and we haven't modified the
+    // context stack. We don't have to pop back to the previous task every
+    // again, so we can use the destructive recursive form.
+    renderNodeDestructive(request, task, null, children, -1);
+  }
+
+  task.keyPath = prevKeyPath;
+}
+
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    // Resolve default props. Taken from ReactElement
+    const props = assign({}, baseProps);
+    const defaultProps = Component.defaultProps;
+
+    for (const propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+
+    return props;
+  }
+
+  return baseProps;
+}
+
+function renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref) {
+  const children = renderWithHooks(request, task, keyPath, prevThenableState, type.render, props, ref);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+  finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex);
+}
+
+function renderMemo(request, task, keyPath, prevThenableState, type, props, ref) {
+  const innerType = type.type;
+  const resolvedProps = resolveDefaultProps(innerType, props);
+  renderElement(request, task, keyPath, prevThenableState, innerType, resolvedProps, ref);
+}
+
+function renderContextConsumer(request, task, keyPath, context, props) {
+
+  const render = props.children;
+
+  const newValue = readContext$1(context);
+  const newChildren = render(newValue);
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, newChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderContextProvider(request, task, keyPath, type, props) {
+  const context = type._context;
+  const value = props.value;
+  const children = props.children;
+
+  const prevKeyPath = task.keyPath;
+  task.context = pushProvider(context, value);
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, children, -1);
+  task.context = popProvider();
+  task.keyPath = prevKeyPath;
+}
+
+function renderLazyComponent(request, task, keyPath, prevThenableState, lazyComponent, props, ref) {
+  const payload = lazyComponent._payload;
+  const init = lazyComponent._init;
+  const Component = init(payload);
+  const resolvedProps = resolveDefaultProps(Component, props);
+  renderElement(request, task, keyPath, prevThenableState, Component, resolvedProps, ref);
+}
+
+function renderOffscreen(request, task, keyPath, props) {
+  const mode = props.mode;
+
+  if (mode === 'hidden') ; else {
+    // A visible Offscreen boundary is treated exactly like a fragment: a
+    // pure indirection.
+    const prevKeyPath = task.keyPath;
+    task.keyPath = keyPath;
+    renderNodeDestructive(request, task, null, props.children, -1);
+    task.keyPath = prevKeyPath;
+  }
+}
+
+function renderElement(request, task, keyPath, prevThenableState, type, props, ref) {
+  if (typeof type === 'function') {
+    if (shouldConstruct(type)) {
+      renderClassComponent(request, task, keyPath, type, props);
+      return;
+    } else {
+      renderIndeterminateComponent(request, task, keyPath, prevThenableState, type, props);
+      return;
+    }
+  }
+
+  if (typeof type === 'string') {
+    renderHostElement(request, task, keyPath, type, props);
+    return;
+  }
+
+  switch (type) {
+    // LegacyHidden acts the same as a fragment. This only works because we
+    // currently assume that every instance of LegacyHidden is accompanied by a
+    // host component wrapper. In the hidden mode, the host component is given a
+    // `hidden` attribute, which ensures that the initial HTML is not visible.
+    // To support the use of LegacyHidden as a true fragment, without an extra
+    // DOM node, we would have to hide the initial HTML in some other way.
+    // TODO: Delete in LegacyHidden. It's an unstable API only used in the
+    // www build. As a migration step, we could add a special prop to Offscreen
+    // that simulates the old behavior (no hiding, no change to effects).
+    case REACT_LEGACY_HIDDEN_TYPE:
+    case REACT_DEBUG_TRACING_MODE_TYPE:
+    case REACT_STRICT_MODE_TYPE:
+    case REACT_PROFILER_TYPE:
+    case REACT_FRAGMENT_TYPE:
+      {
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_OFFSCREEN_TYPE:
+      {
+        renderOffscreen(request, task, keyPath, props);
+        return;
+      }
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      {
+
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_SCOPE_TYPE:
+      {
+
+        throw new Error('ReactDOMServer does not yet support scope components.');
+      }
+
+    case REACT_SUSPENSE_TYPE:
+      {
+        {
+          renderSuspenseBoundary(request, task, keyPath, props);
+        }
+
+        return;
+      }
+  }
+
+  if (typeof type === 'object' && type !== null) {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        {
+          renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          renderMemo(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_PROVIDER_TYPE:
+        {
+          renderContextProvider(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_CONTEXT_TYPE:
+        {
+          renderContextConsumer(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_LAZY_TYPE:
+        {
+          renderLazyComponent(request, task, keyPath, prevThenableState, type, props);
+          return;
+        }
+    }
+  }
+
+  let info = '';
+
+  throw new Error('Element type is invalid: expected a string (for built-in ' + 'components) or a class/function (for composite components) ' + ("but got: " + (type == null ? type : typeof type) + "." + info));
+}
+
+function resumeNode(request, task, segmentId, node, childIndex) {
+  const prevReplay = task.replay;
+  const blockedBoundary = task.blockedBoundary;
+  const resumedSegment = createPendingSegment(request, 0, null, task.formatContext, false, false);
+  resumedSegment.id = segmentId;
+  resumedSegment.parentFlushed = true;
+
+  try {
+    // Convert the current ReplayTask to a RenderTask.
+    const renderTask = task;
+    renderTask.replay = null;
+    renderTask.blockedSegment = resumedSegment;
+    renderNode(request, task, node, childIndex);
+    resumedSegment.status = COMPLETED;
+
+    if (blockedBoundary === null) {
+      request.completedRootSegment = resumedSegment;
+    } else {
+      queueCompletedSegment(blockedBoundary, resumedSegment);
+
+      if (blockedBoundary.parentFlushed) {
+        request.partialBoundaries.push(blockedBoundary);
+      }
+    }
+  } finally {
+    // Restore to a ReplayTask.
+    task.replay = prevReplay;
+    task.blockedSegment = null;
+  }
+}
+
+function replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, replay) {
+  // We're replaying. Find the path to follow.
+  const replayNodes = replay.nodes;
+
+  for (let i = 0; i < replayNodes.length; i++) {
+    // Flow doesn't support refinement on tuples so we do it manually here.
+    const node = replayNodes[i];
+
+    if (keyOrIndex !== node[1]) {
+      continue;
+    }
+
+    if (node.length === 4) {
+      // Matched a replayable path.
+      // Let's double check that the component name matches as a precaution.
+      if (name !== null && name !== node[0]) {
+        throw new Error('Expected the resume to render <' + node[0] + '> in this slot but instead it rendered <' + name + '>. ' + "The tree doesn't match so React will fallback to client rendering.");
+      }
+
+      const childNodes = node[2];
+      const childSlots = node[3];
+      const currentNode = task.node;
+      task.replay = {
+        nodes: childNodes,
+        slots: childSlots,
+        pendingTasks: 1
+      };
+
+      try {
+        renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+
+        if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0 // TODO check remaining slots
+        ) {
+            throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+          }
+
+        task.replay.pendingTasks--;
+      } catch (x) {
+        if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+          // Suspend
+          if (task.node === currentNode) {
+            // This same element suspended so we need to pop the replay we just added.
+            task.replay = replay;
+          }
+
+          throw x;
+        }
+
+        task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+        // during a replay. That's because this component didn't actually error
+        // in the original prerender. What's unable to complete is the child
+        // replay nodes which might be Suspense boundaries which are able to
+        // absorb the error and we can still continue with siblings.
+
+        erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+      }
+
+      task.replay = replay;
+    } else {
+      // Let's double check that the component type matches.
+      if (type !== REACT_SUSPENSE_TYPE) {
+        const expectedType = 'Suspense';
+        throw new Error('Expected the resume to render <' + expectedType + '> in this slot but instead it rendered <' + (getComponentNameFromType(type) || 'Unknown') + '>. ' + "The tree doesn't match so React will fallback to client rendering.");
+      } // Matched a replayable path.
+
+
+      replaySuspenseBoundary(request, task, keyPath, props, node[5], node[2], node[3], node[4] === null ? [] : node[4][2], node[4] === null ? null : node[4][3]);
+    } // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+
+    replayNodes.splice(i, 1);
+    return;
+  } // We didn't find any matching nodes. We assume that this element was already
+  // rendered in the prelude and skip it.
+
+} // $FlowFixMe[missing-local-annot]
+
+function renderNodeDestructive(request, task, // The thenable state reused from the previous attempt, if any. This is almost
+// always null, except when called by retryTask.
+prevThenableState, node, childIndex) {
+  {
+    return renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex);
+  }
+} // This function by it self renders a node and consumes the task by mutating it
+// to update the current execution state.
+
+
+function renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex) {
+  if (task.replay !== null && typeof task.replay.slots === 'number') {
+    // TODO: Figure out a cheaper place than this hot path to do this check.
+    const resumeSegmentID = task.replay.slots;
+    resumeNode(request, task, resumeSegmentID, node, childIndex);
+    return;
+  } // Stash the node we're working on. We'll pick up from this task in case
+  // something suspends.
+
+
+  task.node = node;
+  task.childIndex = childIndex; // Handle object types
+
+  if (typeof node === 'object' && node !== null) {
+    switch (node.$$typeof) {
+      case REACT_ELEMENT_TYPE:
+        {
+          const element = node;
+          const type = element.type;
+          const key = element.key;
+          const props = element.props;
+          const ref = element.ref;
+          const name = getComponentNameFromType(type);
+          const keyOrIndex = key == null ? childIndex === -1 ? 0 : childIndex : key;
+          const keyPath = [task.keyPath, name, keyOrIndex];
+
+          if (task.replay !== null) {
+            replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, task.replay); // No matches found for this node. We assume it's already emitted in the
+            // prelude and skip it during the replay.
+          } else {
+            // We're doing a plain render.
+            renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+          }
+
+          return;
+        }
+
+      case REACT_PORTAL_TYPE:
+        throw new Error('Portals are not currently supported by the server renderer. ' + 'Render them conditionally so that they only appear on the client render.');
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyNode = node;
+          const payload = lazyNode._payload;
+          const init = lazyNode._init;
+          let resolvedNode;
+
+          {
+            resolvedNode = init(payload);
+          }
+
+          renderNodeDestructive(request, task, null, resolvedNode, childIndex);
+          return;
+        }
+    }
+
+    if (isArray(node)) {
+      renderChildrenArray(request, task, node, childIndex);
+      return;
+    }
+
+    const iteratorFn = getIteratorFn(node);
+
+    if (iteratorFn) {
+
+      const iterator = iteratorFn.call(node);
+
+      if (iterator) {
+        // We need to know how many total children are in this set, so that we
+        // can allocate enough id slots to acommodate them. So we must exhaust
+        // the iterator before we start recursively rendering the children.
+        // TODO: This is not great but I think it's inherent to the id
+        // generation algorithm.
+        let step = iterator.next(); // If there are not entries, we need to push an empty so we start by checking that.
+
+        if (!step.done) {
+          const children = [];
+
+          do {
+            children.push(step.value);
+            step = iterator.next();
+          } while (!step.done);
+
+          renderChildrenArray(request, task, children, childIndex);
+          return;
+        }
+
+        return;
+      }
+    } // Usables are a valid React node type. When React encounters a Usable in
+    // a child position, it unwraps it using the same algorithm as `use`. For
+    // example, for promises, React will throw an exception to unwind the
+    // stack, then replay the component once the promise resolves.
+    //
+    // A difference from `use` is that React will keep unwrapping the value
+    // until it reaches a non-Usable type.
+    //
+    // e.g. Usable<Usable<Usable<T>>> should resolve to T
+
+
+    const maybeUsable = node;
+
+    if (typeof maybeUsable.then === 'function') {
+      const thenable = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, unwrapThenable(thenable), childIndex);
+    }
+
+    if (maybeUsable.$$typeof === REACT_CONTEXT_TYPE || maybeUsable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, readContext$1(context), childIndex);
+    } // $FlowFixMe[method-unbinding]
+
+
+    const childString = Object.prototype.toString.call(node);
+    throw new Error("Objects are not valid as a React child (found: " + (childString === '[object Object]' ? 'object with keys {' + Object.keys(node).join(', ') + '}' : childString) + "). " + 'If you meant to render a collection of children, use an array ' + 'instead.');
+  }
+
+  if (typeof node === 'string') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+
+  if (typeof node === 'number') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, '' + node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+}
+
+function replayFragment(request, task, children, childIndex) {
+  // If we're supposed follow this array, we'd expect to see a ReplayNode matching
+  // this fragment.
+  const replay = task.replay;
+  const replayNodes = replay.nodes;
+
+  for (let j = 0; j < replayNodes.length; j++) {
+    const node = replayNodes[j];
+
+    if (node[1] !== childIndex) {
+      continue;
+    } // Matched a replayable path.
+
+
+    const childNodes = node[2];
+    const childSlots = node[3];
+    task.replay = {
+      nodes: childNodes,
+      slots: childSlots,
+      pendingTasks: 1
+    };
+
+    try {
+      renderChildrenArray(request, task, children, -1);
+
+      if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+        throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+      }
+
+      task.replay.pendingTasks--;
+    } catch (x) {
+      if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+        // Suspend
+        throw x;
+      }
+
+      task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+      // during a replay. That's because this component didn't actually error
+      // in the original prerender. What's unable to complete is the child
+      // replay nodes which might be Suspense boundaries which are able to
+      // absorb the error and we can still continue with siblings.
+      // This is an error, stash the component stack if it is null.
+
+      erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+    }
+
+    task.replay = replay; // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+    replayNodes.splice(j, 1);
+    break;
+  }
+}
+
+function renderChildrenArray(request, task, children, childIndex) {
+  const prevKeyPath = task.keyPath;
+
+  if (childIndex !== -1) {
+    task.keyPath = [task.keyPath, 'Fragment', childIndex];
+
+    if (task.replay !== null) {
+      replayFragment(request, // $FlowFixMe: Refined.
+      task, children, childIndex);
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  const prevTreeContext = task.treeContext;
+  const totalChildren = children.length;
+
+  if (task.replay !== null) {
+    // Replay
+    // First we need to check if we have any resume slots at this level.
+    const resumeSlots = task.replay.slots;
+
+    if (resumeSlots !== null && typeof resumeSlots === 'object') {
+      for (let i = 0; i < totalChildren; i++) {
+        const node = children[i];
+        task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+        // up and render the sibling if something suspends.
+
+        const resumeSegmentID = resumeSlots[i]; // TODO: If this errors we should still continue with the next sibling.
+
+        if (typeof resumeSegmentID === 'number') {
+          resumeNode(request, task, resumeSegmentID, node, i); // We finished rendering this node, so now we can consume this
+          // slot. This must happen after in case we rerender this task.
+
+          delete resumeSlots[i];
+        } else {
+          renderNode(request, task, node, i);
+        }
+      }
+
+      task.treeContext = prevTreeContext;
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  for (let i = 0; i < totalChildren; i++) {
+    const node = children[i];
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+    // up and render the sibling if something suspends.
+
+    renderNode(request, task, node, i);
+  } // Because this context is always set right before rendering every child, we
+  // only need to reset it to the previous value at the very end.
+
+
+  task.treeContext = prevTreeContext;
+  task.keyPath = prevKeyPath;
+}
+
+function trackPostpone(request, trackedPostpones, task, segment) {
+  segment.status = POSTPONED;
+  const keyPath = task.keyPath;
+  const boundary = task.blockedBoundary;
+
+  if (boundary === null) {
+    segment.id = request.nextSegmentId++;
+    trackedPostpones.rootSlots = segment.id;
+
+    if (request.completedRootSegment !== null) {
+      // Postpone the root if this was a deeper segment.
+      request.completedRootSegment.status = POSTPONED;
+    }
+
+    return;
+  }
+
+  if (boundary !== null && boundary.status === PENDING) {
+    boundary.status = POSTPONED; // We need to eagerly assign it an ID because we'll need to refer to
+    // it before flushing and we know that we can't inline it.
+
+    boundary.rootSegmentID = request.nextSegmentId++;
+    const boundaryKeyPath = boundary.trackedContentKeyPath;
+
+    if (boundaryKeyPath === null) {
+      throw new Error('It should not be possible to postpone at the root. This is a bug in React.');
+    }
+
+    const fallbackReplayNode = boundary.trackedFallbackNode;
+    const children = [];
+
+    if (boundaryKeyPath === keyPath && task.childIndex === -1) {
+      // Since we postponed directly in the Suspense boundary we can't have written anything
+      // to its segment. Therefore this will end up becoming the root segment.
+      segment.id = boundary.rootSegmentID; // We postponed directly inside the Suspense boundary so we mark this for resuming.
+
+      const boundaryNode = [boundaryKeyPath[1], boundaryKeyPath[2], children, boundary.rootSegmentID, fallbackReplayNode, boundary.rootSegmentID];
+      trackedPostpones.workingMap.set(boundaryKeyPath, boundaryNode);
+      addToReplayParent(boundaryNode, boundaryKeyPath[0], trackedPostpones);
+      return;
+    } else {
+      let boundaryNode = trackedPostpones.workingMap.get(boundaryKeyPath);
+
+      if (boundaryNode === undefined) {
+        boundaryNode = [boundaryKeyPath[1], boundaryKeyPath[2], children, null, fallbackReplayNode, boundary.rootSegmentID];
+        trackedPostpones.workingMap.set(boundaryKeyPath, boundaryNode);
+        addToReplayParent(boundaryNode, boundaryKeyPath[0], trackedPostpones);
+      } else {
+        // Upgrade to ReplaySuspenseBoundary.
+        const suspenseBoundary = boundaryNode;
+        suspenseBoundary[4] = fallbackReplayNode;
+        suspenseBoundary[5] = boundary.rootSegmentID;
+      } // Fall through to add the child node.
+
+    }
+  } // We know that this will leave a hole so we might as well assign an ID now.
+  // We might have one already if we had a parent that gave us its ID.
+
+
+  if (segment.id === -1) {
+    if (segment.parentFlushed && boundary !== null) {
+      // If this segment's parent was already flushed, it means we really just
+      // skipped the parent and this segment is now the root.
+      segment.id = boundary.rootSegmentID;
+    } else {
+      segment.id = request.nextSegmentId++;
+    }
+  }
+
+  if (task.childIndex === -1) {
+    // Resume starting from directly inside the previous parent element.
+    if (keyPath === null) {
+      trackedPostpones.rootSlots = segment.id;
+    } else {
+      const workingMap = trackedPostpones.workingMap;
+      let resumableNode = workingMap.get(keyPath);
+
+      if (resumableNode === undefined) {
+        resumableNode = [keyPath[1], keyPath[2], [], segment.id];
+        addToReplayParent(resumableNode, keyPath[0], trackedPostpones);
+      } else {
+        resumableNode[3] = segment.id;
+      }
+    }
+  } else {
+    let slots;
+
+    if (keyPath === null) {
+      slots = trackedPostpones.rootSlots;
+
+      if (slots === null) {
+        slots = trackedPostpones.rootSlots = {};
+      } else if (typeof slots === 'number') {
+        throw new Error('It should not be possible to postpone both at the root of an element ' + 'as well as a slot below. This is a bug in React.');
+      }
+    } else {
+      const workingMap = trackedPostpones.workingMap;
+      let resumableNode = workingMap.get(keyPath);
+
+      if (resumableNode === undefined) {
+        slots = {};
+        resumableNode = [keyPath[1], keyPath[2], [], slots];
+        workingMap.set(keyPath, resumableNode);
+        addToReplayParent(resumableNode, keyPath[0], trackedPostpones);
+      } else {
+        slots = resumableNode[3];
+
+        if (slots === null) {
+          slots = resumableNode[3] = {};
+        } else if (typeof slots === 'number') {
+          throw new Error('It should not be possible to postpone both at the root of an element ' + 'as well as a slot below. This is a bug in React.');
+        }
+      }
+    }
+
+    slots[task.childIndex] = segment.id;
+  }
+}
+
+function injectPostponedHole(request, task, reason) {
+  logPostpone(request, reason); // Something suspended, we'll need to create a new segment and resolve it later.
+
+  const segment = task.blockedSegment;
+  const insertionIndex = segment.chunks.length;
+  const newSegment = createPendingSegment(request, insertionIndex, null, task.formatContext, // Adopt the parent segment's leading text embed
+  segment.lastPushedText, // Assume we are text embedded at the trailing edge
+  true);
+  segment.children.push(newSegment); // Reset lastPushedText for current Segment since the new Segment "consumed" it
+
+  segment.lastPushedText = false;
+  return newSegment;
+}
+
+function spawnNewSuspendedReplayTask(request, task, thenableState, x) {
+  const newTask = createReplayTask(request, thenableState, task.replay, task.node, task.childIndex, task.blockedBoundary, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+}
+
+function spawnNewSuspendedRenderTask(request, task, thenableState, x) {
+  // Something suspended, we'll need to create a new segment and resolve it later.
+  const segment = task.blockedSegment;
+  const insertionIndex = segment.chunks.length;
+  const newSegment = createPendingSegment(request, insertionIndex, null, task.formatContext, // Adopt the parent segment's leading text embed
+  segment.lastPushedText, // Assume we are text embedded at the trailing edge
+  true);
+  segment.children.push(newSegment); // Reset lastPushedText for current Segment since the new Segment "consumed" it
+
+  segment.lastPushedText = false;
+  const newTask = createRenderTask(request, thenableState, task.node, task.childIndex, task.blockedBoundary, newSegment, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+} // This is a non-destructive form of rendering a node. If it suspends it spawns
+// a new task and restores the context of this task to what it was before.
+
+
+function renderNode(request, task, node, childIndex) {
+  // Snapshot the current context in case something throws to interrupt the
+  // process.
+  const previousFormatContext = task.formatContext;
+  const previousLegacyContext = task.legacyContext;
+  const previousContext = task.context;
+  const previousKeyPath = task.keyPath;
+  const previousTreeContext = task.treeContext;
+
+  let x; // Store how much we've pushed at this point so we can reset it in case something
+  // suspended partially through writing something.
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState();
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedReplayTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+      } // TODO: Abort any undiscovered Suspense boundaries in the ReplayNode.
+
+    }
+  } else {
+    // Render
+    const childrenLength = segment.children.length;
+    const chunkLength = segment.chunks.length;
+
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState(); // Reset the write pointers to where we started.
+
+      segment.children.length = childrenLength;
+      segment.chunks.length = chunkLength;
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedRenderTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+
+        if (request.trackedPostpones !== null && x.$$typeof === REACT_POSTPONE_TYPE && task.blockedBoundary !== null // bubble if we're postponing in the shell
+        ) {
+            // If we're tracking postpones, we inject a hole here and continue rendering
+            // sibling. Similar to suspending. If we're not tracking, we treat it more like
+            // an error. Notably this doesn't spawn a new task since nothing will fill it
+            // in during this prerender.
+            const postponeInstance = x;
+            const trackedPostpones = request.trackedPostpones;
+            const postponedSegment = injectPostponedHole(request, task, // We don't use ReplayTasks in prerenders.
+            postponeInstance.message);
+            trackPostpone(request, trackedPostpones, task, postponedSegment); // Restore the context. We assume that this will be restored by the inner
+            // functions in case nothing throws so we don't use "finally" here.
+
+            task.formatContext = previousFormatContext;
+            task.legacyContext = previousLegacyContext;
+            task.context = previousContext;
+            task.keyPath = previousKeyPath;
+            task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+            switchContext(previousContext);
+            return;
+          }
+      }
+    }
+  } // Restore the context. We assume that this will be restored by the inner
+  // functions in case nothing throws so we don't use "finally" here.
+
+
+  task.formatContext = previousFormatContext;
+  task.legacyContext = previousLegacyContext;
+  task.context = previousContext;
+  task.keyPath = previousKeyPath;
+  task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+  switchContext(previousContext);
+  // Let's terminate the rest of the tree and don't render any siblings.
+
+
+  throw x;
+}
+
+function erroredReplay(request, boundary, error, replayNodes, resumeSlots) {
+  // Erroring during a replay doesn't actually cause an error by itself because
+  // that component has already rendered. What causes the error is the resumable
+  // points that we did not yet finish which will be below the point of the reset.
+  // For example, if we're replaying a path to a Suspense boundary that is not done
+  // that doesn't error the parent Suspense boundary.
+  // This might be a bit strange that the error in a parent gets thrown at a child.
+  // We log it only once and reuse the digest.
+  let errorDigest;
+
+  if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+    const postponeInstance = error;
+    logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+    errorDigest = 'POSTPONE';
+  } else {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  abortRemainingReplayNodes(request, boundary, replayNodes, resumeSlots, error, errorDigest);
+}
+
+function erroredTask(request, boundary, error) {
+  // Report the error to a global handler.
+  let errorDigest;
+
+  if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+    const postponeInstance = error;
+    logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+    errorDigest = 'POSTPONE';
+  } else {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  if (boundary === null) {
+    fatalError(request, error);
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+      // so we can flush it, if the parent already flushed.
+
+
+      if (boundary.parentFlushed) {
+        // We don't have a preference where in the queue this goes since it's likely
+        // to error on the client anyway. However, intentionally client-rendered
+        // boundaries should be flushed earlier so that they can start on the client.
+        // We reuse the same queue for errors.
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function abortTaskSoft(task) {
+  // This aborts task without aborting the parent boundary that it blocks.
+  // It's used for when we didn't need this task to complete the tree.
+  // If task was needed, then it should use abortTask instead.
+  const request = this;
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+    finishedTask(request, boundary, segment);
+  }
+}
+
+function abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest) {
+  const resumedBoundary = createSuspenseBoundary(request, new Set());
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = rootSegmentID;
+  resumedBoundary.status = CLIENT_RENDERED;
+  resumedBoundary.errorDigest = errorDigest;
+
+  if (resumedBoundary.parentFlushed) {
+    request.clientRenderedBoundaries.push(resumedBoundary);
+  }
+}
+
+function abortRemainingReplayNodes(request, boundary, nodes, slots, error, errorDigest) {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+
+    if (node.length === 4) {
+      abortRemainingReplayNodes(request, boundary, node[2], node[3], error, errorDigest);
+    } else {
+      const boundaryNode = node;
+      const rootSegmentID = boundaryNode[5];
+      abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest);
+    }
+  } // Empty the set, since we've cleared it now.
+
+
+  nodes.length = 0;
+
+  if (slots !== null) {
+    // We had something still to resume in the parent boundary. We must trigger
+    // the error on the parent boundary since it's not able to complete.
+    if (boundary === null) {
+      throw new Error('We should not have any resumable nodes in the shell. ' + 'This is a bug in React.');
+    } else if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // Empty the set
+
+
+    if (typeof slots === 'object') {
+      for (const index in slots) {
+        delete slots[index];
+      }
+    }
+  }
+}
+
+function abortTask(task, request, error) {
+  // This aborts the task and aborts the parent that it blocks, putting it into
+  // client rendered mode.
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+  }
+
+  if (boundary === null) {
+    if (request.status !== CLOSING && request.status !== CLOSED) {
+      const replay = task.replay;
+
+      if (replay === null) {
+        // We didn't complete the root so we have nothing to show. We can close
+        // the request;
+        logRecoverableError(request, error);
+        fatalError(request, error);
+        return;
+      } else {
+        // If the shell aborts during a replay, that's not a fatal error. Instead
+        // we should be able to recover by client rendering all the root boundaries in
+        // the ReplaySet.
+        replay.pendingTasks--;
+
+        if (replay.pendingTasks === 0 && replay.nodes.length > 0) {
+          const errorDigest = logRecoverableError(request, error);
+          abortRemainingReplayNodes(request, null, replay.nodes, replay.slots, error, errorDigest);
+        }
+
+        request.pendingRootTasks--;
+
+        if (request.pendingRootTasks === 0) {
+          completeShell(request);
+        }
+      }
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = logRecoverableError(request, error);
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // If this boundary was still pending then we haven't already cancelled its fallbacks.
+    // We'll need to abort the fallbacks, which will also error that parent boundary.
+
+
+    boundary.fallbackAbortableTasks.forEach(fallbackTask => abortTask(fallbackTask, request, error));
+    boundary.fallbackAbortableTasks.clear();
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeShell(request) {
+  if (request.trackedPostpones === null) {
+    // We only emit early preloads on shell completion for renders. For prerenders
+    // we wait for the entire Request to finish because we are not responding to a
+    // live request and can wait for as much data as possible.
+    // we should only be calling completeShell when the shell is complete so we
+    // just use a literal here
+    const shellComplete = true;
+    emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  } // We have completed the shell so the shell can't error anymore.
+
+
+  request.onShellError = noop;
+  const onShellReady = request.onShellReady;
+  onShellReady();
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeAll(request) {
+  // During a render the shell must be complete if the entire request is finished
+  // however during a Prerender it is possible that the shell is incomplete because
+  // it postponed. We cannot use rootPendingTasks in the prerender case because
+  // those hit zero even when the shell postpones. Instead we look at the completedRootSegment
+  const shellComplete = request.trackedPostpones === null ? // Render, we assume it is completed
+  true : // Prerender Request, we use the state of the root segment
+  request.completedRootSegment === null || request.completedRootSegment.status !== POSTPONED;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  const onAllReady = request.onAllReady;
+  onAllReady();
+}
+
+function queueCompletedSegment(boundary, segment) {
+  if (segment.chunks.length === 0 && segment.children.length === 1 && segment.children[0].boundary === null) {
+    // This is an empty segment. There's nothing to write, so we can instead transfer the ID
+    // to the child. That way any existing references point to the child.
+    const childSegment = segment.children[0];
+    childSegment.id = segment.id;
+    childSegment.parentFlushed = true;
+
+    if (childSegment.status === COMPLETED) {
+      queueCompletedSegment(boundary, childSegment);
+    }
+  } else {
+    const completedSegments = boundary.completedSegments;
+    completedSegments.push(segment);
+  }
+}
+
+function finishedTask(request, boundary, segment) {
+  if (boundary === null) {
+    if (segment !== null && segment.parentFlushed) {
+      if (request.completedRootSegment !== null) {
+        throw new Error('There can only be one root segment. This is a bug in React.');
+      }
+
+      request.completedRootSegment = segment;
+    }
+
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status === CLIENT_RENDERED) ; else if (boundary.pendingTasks === 0) {
+      if (boundary.status === PENDING) {
+        boundary.status = COMPLETED;
+      } // This must have been the last segment we were waiting on. This boundary is now complete.
+
+
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent segment already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+        }
+      }
+
+      if (boundary.parentFlushed) {
+        // The segment might be part of a segment that didn't flush yet, but if the boundary's
+        // parent flushed, we need to schedule the boundary to be emitted.
+        request.completedBoundaries.push(boundary);
+      } // We can now cancel any pending task on the fallback since we won't need to show it anymore.
+      // This needs to happen after we read the parentFlushed flags because aborting can finish
+      // work which can trigger user code, which can start flushing, which can change those flags.
+      // If the boundary was POSTPONED, we still need to finish the fallback first.
+
+
+      if (boundary.status === COMPLETED) {
+        boundary.fallbackAbortableTasks.forEach(abortTaskSoft, request);
+        boundary.fallbackAbortableTasks.clear();
+      }
+    } else {
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+          const completedSegments = boundary.completedSegments;
+
+          if (completedSegments.length === 1) {
+            // This is the first time since we last flushed that we completed anything.
+            // We can schedule this boundary to emit its partially completed segments early
+            // in case the parent has already been flushed.
+            if (boundary.parentFlushed) {
+              request.partialBoundaries.push(boundary);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function retryTask(request, task) {
+  {
+    const blockedBoundary = task.blockedBoundary;
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, blockedBoundary ? blockedBoundary.resources : null);
+  }
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    retryReplayTask(request, // $FlowFixMe: Refined.
+    task);
+  } else {
+    retryRenderTask(request, // $FlowFixMe: Refined.
+    task, segment);
+  }
+}
+
+function retryRenderTask(request, task, segment) {
+  if (segment.status !== PENDING) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  const childrenLength = segment.children.length;
+  const chunkLength = segment.chunks.length;
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+    pushSegmentFinale(segment.chunks, request.renderState, segment.lastPushedText, segment.textEmbedded);
+    task.abortSet.delete(task);
+    segment.status = COMPLETED;
+    finishedTask(request, task.blockedBoundary, segment);
+  } catch (thrownValue) {
+    resetHooksState(); // Reset the write pointers to where we started.
+
+    segment.children.length = childrenLength;
+    segment.chunks.length = chunkLength;
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      } else if (request.trackedPostpones !== null && x.$$typeof === REACT_POSTPONE_TYPE) {
+        // If we're tracking postpones, we mark this segment as postponed and finish
+        // the task without filling it in. If we're not tracking, we treat it more like
+        // an error.
+        const trackedPostpones = request.trackedPostpones;
+        task.abortSet.delete(task);
+        const postponeInstance = x;
+        logPostpone(request, postponeInstance.message);
+        trackPostpone(request, trackedPostpones, task, segment);
+        finishedTask(request, task.blockedBoundary, segment);
+        return;
+      }
+    }
+
+    task.abortSet.delete(task);
+    segment.status = ERRORED;
+    erroredTask(request, task.blockedBoundary, x);
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function retryReplayTask(request, task) {
+  if (task.replay.pendingTasks === 0) {
+    // There are no pending tasks working on this set, so we must have aborted.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    finishedTask(request, task.blockedBoundary, null);
+  } catch (thrownValue) {
+    resetHooksState();
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    erroredReplay(request, task.blockedBoundary, x, task.replay.nodes, task.replay.slots);
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+
+    request.allPendingTasks--;
+
+    if (request.allPendingTasks === 0) {
+      completeAll(request);
+    }
+
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function performWork(request) {
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  const prevContext = getActiveContext();
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  let prevCacheDispatcher;
+
+  {
+    prevCacheDispatcher = ReactCurrentCache.current;
+    ReactCurrentCache.current = DefaultCacheDispatcher;
+  }
+
+  const prevRequest = currentRequest;
+  currentRequest = request;
+
+  const prevResumableState = currentResumableState;
+  setCurrentResumableState(request.resumableState);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    let i;
+
+    for (i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    pingedTasks.splice(0, i);
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    setCurrentResumableState(prevResumableState);
+    ReactCurrentDispatcher.current = prevDispatcher;
+
+    {
+      ReactCurrentCache.current = prevCacheDispatcher;
+    }
+
+    if (prevDispatcher === HooksDispatcher) {
+      // This means that we were in a reentrant work loop. This could happen
+      // in a renderer that supports synchronous work like renderToString,
+      // when it's called from within another renderer.
+      // Normally we don't bother switching the contexts to their root/default
+      // values when leaving because we'll likely need the same or similar
+      // context again. However, when we're inside a synchronous loop like this
+      // we'll to restore the context to what it was before returning.
+      switchContext(prevContext);
+    }
+
+    currentRequest = prevRequest;
+  }
+}
+
+function flushSubtree(request, destination, segment) {
+  segment.parentFlushed = true;
+
+  switch (segment.status) {
+    case PENDING:
+      {
+        // We're emitting a placeholder for this segment to be filled in later.
+        // Therefore we'll need to assign it an ID - to refer to it by.
+        segment.id = request.nextSegmentId++; // Fallthrough
+      }
+
+    case POSTPONED:
+      {
+        const segmentID = segment.id; // When this segment finally completes it won't be embedded in text since it will flush separately
+
+        segment.lastPushedText = false;
+        segment.textEmbedded = false;
+        return writePlaceholder(destination, request.renderState, segmentID);
+      }
+
+    case COMPLETED:
+      {
+        segment.status = FLUSHED;
+        let r = true;
+        const chunks = segment.chunks;
+        let chunkIdx = 0;
+        const children = segment.children;
+
+        for (let childIdx = 0; childIdx < children.length; childIdx++) {
+          const nextChild = children[childIdx]; // Write all the chunks up until the next child.
+
+          for (; chunkIdx < nextChild.index; chunkIdx++) {
+            writeChunk(destination, chunks[chunkIdx]);
+          }
+
+          r = flushSegment(request, destination, nextChild);
+        } // Finally just write all the remaining chunks
+
+
+        for (; chunkIdx < chunks.length - 1; chunkIdx++) {
+          writeChunk(destination, chunks[chunkIdx]);
+        }
+
+        if (chunkIdx < chunks.length) {
+          r = writeChunkAndReturn(destination, chunks[chunkIdx]);
+        }
+
+        return r;
+      }
+
+    default:
+      {
+        throw new Error('Aborted, errored or already flushed boundaries should not be flushed again. This is a bug in React.');
+      }
+  }
+}
+
+function flushSegment(request, destination, segment) {
+  const boundary = segment.boundary;
+
+  if (boundary === null) {
+    // Not a suspense boundary.
+    return flushSubtree(request, destination, segment);
+  }
+
+  boundary.parentFlushed = true; // This segment is a Suspense boundary. We need to decide whether to
+  // emit the content or the fallback now.
+
+  if (boundary.status === CLIENT_RENDERED) {
+    // Emit a client rendered suspense boundary wrapper.
+    // We never queue the inner boundary so we'll never emit its content or partial segments.
+    writeStartClientRenderedSuspenseBoundary(destination, request.renderState, boundary.errorDigest); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndClientRenderedSuspenseBoundary(destination, request.renderState);
+  } else if (boundary.status !== COMPLETED) {
+    if (boundary.status === PENDING) {
+      // For pending boundaries we lazily assign an ID to the boundary
+      // and root segment.
+      boundary.rootSegmentID = request.nextSegmentId++;
+    }
+
+    if (boundary.completedSegments.length > 0) {
+      // If this is at least partially complete, we can queue it to be partially emitted early.
+      request.partialBoundaries.push(boundary);
+    } // This boundary is still loading. Emit a pending suspense boundary wrapper.
+
+
+    const id = boundary.rootSegmentID;
+    writeStartPendingSuspenseBoundary(destination, request.renderState, id); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else if (boundary.byteSize > request.progressiveChunkSize) {
+    // This boundary is large and will be emitted separately so that we can progressively show
+    // other content. We add it to the queue during the flush because we have to ensure that
+    // the parent flushes first so that there's something to inject it into.
+    // We also have to make sure that it's emitted into the queue in a deterministic slot.
+    // I.e. we can't insert it here when it completes.
+    // Assign an ID to refer to the future content by.
+    boundary.rootSegmentID = request.nextSegmentId++;
+    request.completedBoundaries.push(boundary); // Emit a pending rendered suspense boundary wrapper.
+
+    writeStartPendingSuspenseBoundary(destination, request.renderState, boundary.rootSegmentID); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else {
+    {
+      hoistResources(request.renderState, boundary.resources);
+    } // We can inline this boundary's content as a complete boundary.
+
+
+    writeStartCompletedSuspenseBoundary(destination, request.renderState);
+    const completedSegments = boundary.completedSegments;
+
+    if (completedSegments.length !== 1) {
+      throw new Error('A previously unvisited boundary must have exactly one root segment. This is a bug in React.');
+    }
+
+    const contentSegment = completedSegments[0];
+    flushSegment(request, destination, contentSegment);
+    return writeEndCompletedSuspenseBoundary(destination, request.renderState);
+  }
+}
+
+function flushClientRenderedBoundary(request, destination, boundary) {
+  return writeClientRenderBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.errorDigest, boundary.errorMessage, boundary.errorComponentStack);
+}
+
+function flushSegmentContainer(request, destination, segment) {
+  writeStartSegment(destination, request.renderState, segment.parentFormatContext, segment.id);
+  flushSegment(request, destination, segment);
+  return writeEndSegment(destination, segment.parentFormatContext);
+}
+
+function flushCompletedBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+    flushPartiallyCompletedSegment(request, destination, boundary, segment);
+  }
+
+  completedSegments.length = 0;
+
+  {
+    writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+
+  return writeCompletedBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.resources);
+}
+
+function flushPartialBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+
+    if (!flushPartiallyCompletedSegment(request, destination, boundary, segment)) {
+      i++;
+      completedSegments.splice(0, i); // Only write as much as the buffer wants. Something higher priority
+      // might want to write later.
+
+      return false;
+    }
+  }
+
+  completedSegments.splice(0, i);
+
+  {
+    // The way this is structured we only write resources for partial boundaries
+    // if there is no backpressure. Later before we complete the boundary we
+    // will write resources regardless of backpressure before we emit the
+    // completion instruction
+    return writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+}
+
+function flushPartiallyCompletedSegment(request, destination, boundary, segment) {
+  if (segment.status === FLUSHED) {
+    // We've already flushed this inline.
+    return true;
+  }
+
+  const segmentID = segment.id;
+
+  if (segmentID === -1) {
+    // This segment wasn't previously referred to. This happens at the root of
+    // a boundary. We make kind of a leap here and assume this is the root.
+    const rootSegmentID = segment.id = boundary.rootSegmentID;
+
+    if (rootSegmentID === -1) {
+      throw new Error('A root segment ID must have been assigned by now. This is a bug in React.');
+    }
+
+    return flushSegmentContainer(request, destination, segment);
+  } else if (segmentID === boundary.rootSegmentID) {
+    // When we emit postponed boundaries, we might have assigned the ID already
+    // but it's still the root segment so we can't inject it into the parent yet.
+    return flushSegmentContainer(request, destination, segment);
+  } else {
+    flushSegmentContainer(request, destination, segment);
+    return writeCompletedSegmentInstruction(destination, request.resumableState, request.renderState, segmentID);
+  }
+}
+
+function flushCompletedQueues(request, destination) {
+
+  try {
+    // The structure of this is to go through each queue one by one and write
+    // until the sink tells us to stop. When we should stop, we still finish writing
+    // that item fully and then yield. At that point we remove the already completed
+    // items up until the point we completed them.
+    let i;
+    const completedRootSegment = request.completedRootSegment;
+
+    if (completedRootSegment !== null) {
+      if (completedRootSegment.status === POSTPONED) {
+        // We postponed the root, so we write nothing.
+        return;
+      } else if (request.pendingRootTasks === 0) {
+        if (enableFloat) {
+          writePreamble(destination, request.resumableState, request.renderState, request.allPendingTasks === 0 && request.trackedPostpones === null);
+        }
+
+        flushSegment(request, destination, completedRootSegment);
+        request.completedRootSegment = null;
+        writeCompletedRoot(destination, request.renderState, request.resumableState);
+      } else {
+        // We haven't flushed the root yet so we don't need to check any other branches further down
+        return;
+      }
+    }
+
+    if (enableFloat) {
+      writeHoistables(destination, request.resumableState, request.renderState);
+    } // We emit client rendering instructions for already emitted boundaries first.
+    // This is so that we can signal to the client to start client rendering them as
+    // soon as possible.
+
+
+    const clientRenderedBoundaries = request.clientRenderedBoundaries;
+
+    for (i = 0; i < clientRenderedBoundaries.length; i++) {
+      const boundary = clientRenderedBoundaries[i];
+
+      if (!flushClientRenderedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        clientRenderedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    clientRenderedBoundaries.splice(0, i); // Next we emit any complete boundaries. It's better to favor boundaries
+    // that are completely done since we can actually show them, than it is to emit
+    // any individual segments from a partially complete boundary.
+
+    const completedBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < completedBoundaries.length; i++) {
+      const boundary = completedBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        completedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    completedBoundaries.splice(0, i); // Allow anything written so far to flush to the underlying sink before
+    // we continue with lower priorities.
+
+    completeWriting(destination);
+    beginWriting(destination); // TODO: Here we'll emit data used by hydration.
+    // Next we emit any segments of any boundaries that are partially complete
+    // but not deeply complete.
+
+    const partialBoundaries = request.partialBoundaries;
+
+    for (i = 0; i < partialBoundaries.length; i++) {
+      const boundary = partialBoundaries[i];
+
+      if (!flushPartialBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        partialBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    partialBoundaries.splice(0, i); // Next we check the completed boundaries again. This may have had
+    // boundaries added to it in case they were too larged to be inlined.
+    // New ones might be added in this loop.
+
+    const largeBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < largeBoundaries.length; i++) {
+      const boundary = largeBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        largeBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    largeBoundaries.splice(0, i);
+  } finally {
+    if (request.allPendingTasks === 0 && request.pingedTasks.length === 0 && request.clientRenderedBoundaries.length === 0 && request.completedBoundaries.length === 0 // We don't need to check any partially completed segments because
+    // either they have pending task or they're complete.
+    ) {
+        request.flushScheduled = false;
+
+        {
+          // We write the trailing tags but only if don't have any data to resume.
+          // If we need to resume we'll write the postamble in the resume instead.
+          if (request.trackedPostpones === null) {
+            writePostamble(destination, request.resumableState);
+          }
+        }
+
+
+        close(destination); // We need to stop flowing now because we do not want any async contexts which might call
+        // float methods to initiate any flushes after this point
+
+        stopFlowing(request);
+      }
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  {
+    scheduleWork(() => performWork(request));
+  }
+
+  if (request.trackedPostpones === null) {
+    // this is either a regular render or a resume. For regular render we want
+    // to call emitEarlyPreloads after the first performWork because we want
+    // are responding to a live request and need to balance sending something early
+    // (i.e. don't want for the shell to finish) but we need something to send.
+    // The only implementation of this is for DOM at the moment and during resumes nothing
+    // actually emits but the code paths here are the same.
+    // During a prerender we don't want to be too aggressive in emitting early preloads
+    // because we aren't responding to a live request and we can wait for the prerender to
+    // postpone before we emit anything.
+    {
+      scheduleWork(() => enqueueEarlyPreloadsAfterInitialWork(request));
+    }
+  }
+}
+
+function enqueueEarlyPreloadsAfterInitialWork(request) {
+  const shellComplete = request.pendingRootTasks === 0;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    request.flushScheduled = true;
+    scheduleWork(() => {
+      // We need to existence check destination again here because it might go away
+      // in between the enqueueFlush call and the work execution
+      const destination = request.destination;
+
+      if (destination) {
+        flushCompletedQueues(request, destination);
+      } else {
+        request.flushScheduled = false;
+      }
+    });
+  }
+} // This function is intented to only be called during the pipe function for the Node builds.
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedQueues(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function stopFlowing(request) {
+  request.destination = null;
+} // This is called to early terminate a request. It puts all pending boundaries in client rendered state.
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+      abortableTasks.forEach(task => abortTask(task, request, error));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function flushResources(request) {
+  enqueueFlush(request);
+}
+function getFormState(request) {
+  return request.formState;
+}
+function getResumableState(request) {
+  return request.resumableState;
+}
+function getRenderState(request) {
+  return request.renderState;
+}
+
+function addToReplayParent(node, parentKeyPath, trackedPostpones) {
+  if (parentKeyPath === null) {
+    trackedPostpones.rootNodes.push(node);
+  } else {
+    const workingMap = trackedPostpones.workingMap;
+    let parentNode = workingMap.get(parentKeyPath);
+
+    if (parentNode === undefined) {
+      parentNode = [parentKeyPath[1], parentKeyPath[2], [], null];
+      workingMap.set(parentKeyPath, parentNode);
+      addToReplayParent(parentNode, parentKeyPath[0], trackedPostpones);
+    }
+
+    parentNode[2].push(node);
+  }
+} // Returns the state of a postponed request or null if nothing was postponed.
+
+function onError$1() {// Non-fatal errors are ignored.
+}
+
+function renderToStringImpl(children, options, generateStaticMarkup, abortReason) {
+  let didFatal = false;
+  let fatalError = null;
+  let result = '';
+  const destination = {
+    // $FlowFixMe[missing-local-annot]
+    push(chunk) {
+      if (chunk !== null) {
+        result += chunk;
+      }
+
+      return true;
+    },
+
+    // $FlowFixMe[missing-local-annot]
+    destroy(error) {
+      didFatal = true;
+      fatalError = error;
+    }
+
+  };
+  let readyToStream = false;
+
+  function onShellReady() {
+    readyToStream = true;
+  }
+
+  const resumableState = createResumableState(options ? options.identifierPrefix : undefined, undefined);
+  const request = createRequest(children, resumableState, createRenderState(resumableState, generateStaticMarkup), createRootFormatContext(), Infinity, onError$1, undefined, onShellReady, undefined, undefined, undefined);
+  startWork(request); // If anything suspended and is still pending, we'll abort it before writing.
+  // That way we write only client-rendered boundaries from the start.
+
+  abort(request, abortReason);
+  startFlowing(request, destination);
+
+  if (didFatal && fatalError !== abortReason) {
+    throw fatalError;
+  }
+
+  if (!readyToStream) {
+    // Note: This error message is the one we use on the client. It doesn't
+    // really make sense here. But this is the legacy server renderer, anyway.
+    // We're going to delete it soon.
+    throw new Error('A component suspended while responding to synchronous input. This ' + 'will cause the UI to be replaced with a loading indicator. To fix, ' + 'updates that suspend should be wrapped with startTransition.');
+  }
+
+  return result;
+}
+
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  subClass.__proto__ = superClass;
+}
+
+let ReactMarkupReadableStream = /*#__PURE__*/function (_Readable) {
+  _inheritsLoose(ReactMarkupReadableStream, _Readable);
+
+  function ReactMarkupReadableStream() {
+    var _this;
+
+    // Calls the stream.Readable(options) constructor. Consider exposing built-in
+    // features like highWaterMark in the future.
+    _this = _Readable.call(this, {}) || this;
+    _this.request = void 0;
+    _this.startedFlowing = void 0;
+    _this.request = null;
+    _this.startedFlowing = false;
+    return _this;
+  } // $FlowFixMe[missing-local-annot]
+
+
+  var _proto = ReactMarkupReadableStream.prototype;
+
+  _proto._destroy = function _destroy(err, callback) {
+    abort(this.request);
+    callback(err);
+  } // $FlowFixMe[missing-local-annot]
+  ;
+
+  _proto._read = function _read(size) {
+    if (this.startedFlowing) {
+      startFlowing(this.request, this);
+    }
+  };
+
+  return ReactMarkupReadableStream;
+}(stream.Readable);
+
+function onError() {// Non-fatal errors are ignored.
+}
+
+function renderToNodeStreamImpl(children, options, generateStaticMarkup) {
+  function onAllReady() {
+    // We wait until everything has loaded before starting to write.
+    // That way we only end up with fully resolved HTML even if we suspend.
+    destination.startedFlowing = true;
+    startFlowing(request, destination);
+  }
+
+  const destination = new ReactMarkupReadableStream();
+  const resumableState = createResumableState(options ? options.identifierPrefix : undefined, undefined);
+  const request = createRequest(children, resumableState, createRenderState(resumableState, false), createRootFormatContext(), Infinity, onError, onAllReady, undefined, undefined, undefined);
+  destination.request = request;
+  startWork(request);
+  return destination;
+}
+
+function renderToNodeStream(children, options) {
+
+  return renderToNodeStreamImpl(children, options);
+}
+
+function renderToStaticNodeStream(children, options) {
+  return renderToNodeStreamImpl(children, options);
+}
+
+function renderToString(children, options) {
+  return renderToStringImpl(children, options, false, 'The server used "renderToString" which does not support Suspense. If you intended for this Suspense boundary to render the fallback content on the server consider throwing an Error somewhere within the Suspense boundary. If you intended to have the server wait for the suspended component please switch to "renderToPipeableStream" which supports Suspense on the server');
+}
+
+function renderToStaticMarkup(children, options) {
+  return renderToStringImpl(children, options, true, 'The server used "renderToStaticMarkup" which does not support Suspense. If you intended to have the server wait for the suspended component please switch to "renderToPipeableStream" which supports Suspense on the server');
+}
+
+exports.renderToNodeStream = renderToNodeStream;
+exports.renderToStaticMarkup = renderToStaticMarkup;
+exports.renderToStaticNodeStream = renderToStaticNodeStream;
+exports.renderToString = renderToString;
+exports.version = ReactVersion;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.node.production.min.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.node.production.min.js
index 754deccb2e493..9078dcab75989 100644
--- a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.node.production.min.js
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.node.production.min.js
@@ -1,13 +1,11 @@
-/**
- * @license React
- * react-dom-server-legacy.node.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
 /*
+ React
+ react-dom-server-legacy.node.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
 
 
  JS Implementation of MurmurHash3 (r136) (as of May 20, 2011)
@@ -34,8 +32,8 @@
 'use strict';var ca=require("next/dist/compiled/react-experimental"),ha=require("react-dom"),ia=require("stream");
 function ja(a,b){var c=a.length&3;var d=a.length-c;var e=b;for(b=0;b<d;){var f=a.charCodeAt(b)&255|(a.charCodeAt(++b)&255)<<8|(a.charCodeAt(++b)&255)<<16|(a.charCodeAt(++b)&255)<<24;++b;f=3432918353*(f&65535)+((3432918353*(f>>>16)&65535)<<16)&4294967295;f=f<<15|f>>>17;f=461845907*(f&65535)+((461845907*(f>>>16)&65535)<<16)&4294967295;e^=f;e=e<<13|e>>>19;e=5*(e&65535)+((5*(e>>>16)&65535)<<16)&4294967295;e=(e&65535)+27492+(((e>>>16)+58964&65535)<<16)}f=0;switch(c){case 3:f^=(a.charCodeAt(b+2)&255)<<
 16;case 2:f^=(a.charCodeAt(b+1)&255)<<8;case 1:f^=a.charCodeAt(b)&255,f=3432918353*(f&65535)+((3432918353*(f>>>16)&65535)<<16)&4294967295,f=f<<15|f>>>17,e^=461845907*(f&65535)+((461845907*(f>>>16)&65535)<<16)&4294967295}e^=a.length;e^=e>>>16;e=2246822507*(e&65535)+((2246822507*(e>>>16)&65535)<<16)&4294967295;e^=e>>>13;e=3266489909*(e&65535)+((3266489909*(e>>>16)&65535)<<16)&4294967295;return(e^e>>>16)>>>0}
-var r=Object.assign,w=Object.prototype.hasOwnProperty,va=RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"),wa={},xa={};
-function ya(a){if(w.call(xa,a))return!0;if(w.call(wa,a))return!1;if(va.test(a))return xa[a]=!0;wa[a]=!0;return!1}
+var q=Object.assign,y=Object.prototype.hasOwnProperty,va=RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"),wa={},xa={};
+function ya(a){if(y.call(xa,a))return!0;if(y.call(wa,a))return!1;if(va.test(a))return xa[a]=!0;wa[a]=!0;return!1}
 var za=new Set("animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp".split(" ")),Aa=
 new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv","http-equiv"],["crossOrigin","crossorigin"],["accentHeight","accent-height"],["alignmentBaseline","alignment-baseline"],["arabicForm","arabic-form"],["baselineShift","baseline-shift"],["capHeight","cap-height"],["clipPath","clip-path"],["clipRule","clip-rule"],["colorInterpolation","color-interpolation"],["colorInterpolationFilters","color-interpolation-filters"],["colorProfile","color-profile"],["colorRendering","color-rendering"],
 ["dominantBaseline","dominant-baseline"],["enableBackground","enable-background"],["fillOpacity","fill-opacity"],["fillRule","fill-rule"],["floodColor","flood-color"],["floodOpacity","flood-opacity"],["fontFamily","font-family"],["fontSize","font-size"],["fontSizeAdjust","font-size-adjust"],["fontStretch","font-stretch"],["fontStyle","font-style"],["fontVariant","font-variant"],["fontWeight","font-weight"],["glyphName","glyph-name"],["glyphOrientationHorizontal","glyph-orientation-horizontal"],["glyphOrientationVertical",
@@ -43,176 +41,181 @@ new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv","http
 "shape-rendering"],["stopColor","stop-color"],["stopOpacity","stop-opacity"],["strikethroughPosition","strikethrough-position"],["strikethroughThickness","strikethrough-thickness"],["strokeDasharray","stroke-dasharray"],["strokeDashoffset","stroke-dashoffset"],["strokeLinecap","stroke-linecap"],["strokeLinejoin","stroke-linejoin"],["strokeMiterlimit","stroke-miterlimit"],["strokeOpacity","stroke-opacity"],["strokeWidth","stroke-width"],["textAnchor","text-anchor"],["textDecoration","text-decoration"],
 ["textRendering","text-rendering"],["transformOrigin","transform-origin"],["underlinePosition","underline-position"],["underlineThickness","underline-thickness"],["unicodeBidi","unicode-bidi"],["unicodeRange","unicode-range"],["unitsPerEm","units-per-em"],["vAlphabetic","v-alphabetic"],["vHanging","v-hanging"],["vIdeographic","v-ideographic"],["vMathematical","v-mathematical"],["vectorEffect","vector-effect"],["vertAdvY","vert-adv-y"],["vertOriginX","vert-origin-x"],["vertOriginY","vert-origin-y"],
 ["wordSpacing","word-spacing"],["writingMode","writing-mode"],["xmlnsXlink","xmlns:xlink"],["xHeight","x-height"]]),Ha=/["'&<>]/;
-function x(a){if("boolean"===typeof a||"number"===typeof a)return""+a;a=""+a;var b=Ha.exec(a);if(b){var c="",d,e=0;for(d=b.index;d<a.length;d++){switch(a.charCodeAt(d)){case 34:b="&quot;";break;case 38:b="&amp;";break;case 39:b="&#x27;";break;case 60:b="&lt;";break;case 62:b="&gt;";break;default:continue}e!==d&&(c+=a.slice(e,d));e=d+1;c+=b}a=e!==d?c+a.slice(e,d):c}return a}
-var Ia=/([A-Z])/g,Ja=/^ms-/,Ka=Array.isArray,La=ca.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,Ma={pending:!1,data:null,method:null,action:null},Na=ha.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Dispatcher,lb={prefetchDNS:Oa,preconnect:fb,preload:gb,preloadModule:hb,preinitStyle:ib,preinitScript:jb,preinitModuleScript:kb},y=[];
-function mb(a,b){var c=0;void 0!==b&&(c=1);return{idPrefix:void 0===a?"":a,nextFormID:0,streamingFormat:c,instructions:0,hasBody:!1,hasHtml:!1,unknownResources:{},dnsResources:{},connectResources:{default:{},anonymous:{},credentials:{}},imageResources:{},styleResources:{},scriptResources:{},moduleUnknownResources:{},moduleScriptResources:{}}}function F(a,b,c){return{insertionMode:a,selectedValue:b,tagScope:c}}
-function nb(a){return F("http://www.w3.org/2000/svg"===a?3:"http://www.w3.org/1998/Math/MathML"===a?4:0,null,0)}
-function ob(a,b,c){switch(b){case "noscript":return F(2,null,a.tagScope|1);case "select":return F(2,null!=c.value?c.value:c.defaultValue,a.tagScope);case "svg":return F(3,null,a.tagScope);case "picture":return F(2,null,a.tagScope|2);case "math":return F(4,null,a.tagScope);case "foreignObject":return F(2,null,a.tagScope);case "table":return F(5,null,a.tagScope);case "thead":case "tbody":case "tfoot":return F(6,null,a.tagScope);case "colgroup":return F(8,null,a.tagScope);case "tr":return F(7,null,a.tagScope)}return 5<=
-a.insertionMode?F(2,null,a.tagScope):0===a.insertionMode?"html"===b?F(1,null,a.tagScope):F(2,null,a.tagScope):1===a.insertionMode?F(2,null,a.tagScope):a}var pb=new Map;
-function Ab(a,b){if("object"!==typeof b)throw Error("The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + 'em'}} when using JSX.");var c=!0,d;for(d in b)if(w.call(b,d)){var e=b[d];if(null!=e&&"boolean"!==typeof e&&""!==e){if(0===d.indexOf("--")){var f=x(d);e=x((""+e).trim())}else f=pb.get(d),void 0===f&&(f=x(d.replace(Ia,"-$1").toLowerCase().replace(Ja,"-ms-")),pb.set(d,f)),e="number"===typeof e?0===e||za.has(d)?""+e:e+"px":
-x((""+e).trim());c?(c=!1,a.push(' style="',f,":",e)):a.push(";",f,":",e)}}c||a.push('"')}function Bb(a,b,c){c&&"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'=""')}function G(a,b,c){"function"!==typeof c&&"symbol"!==typeof c&&"boolean"!==typeof c&&a.push(" ",b,'="',x(c),'"')}function Cb(a){var b=a.nextFormID++;return a.idPrefix+b}var Db=x("javascript:throw new Error('A React form was unexpectedly submitted.')");
-function Eb(a,b){this.push('<input type="hidden"');if("string"!==typeof a)throw Error("File/Blob fields are not yet supported in progressive forms. It probably means you are closing over binary data or FormData in a Server Action.");G(this,"name",b);G(this,"value",a);this.push("/>")}
-function Fb(a,b,c,d,e,f,g,h){var k=null;"function"===typeof d&&("function"===typeof d.$$FORM_ACTION?(e=Cb(b),b=d.$$FORM_ACTION(e),h=b.name,d=b.action||"",e=b.encType,f=b.method,g=b.target,k=b.data):(a.push(" ","formAction",'="',Db,'"'),g=f=e=d=h=null,Gb(b,c)));null!=h&&H(a,"name",h);null!=d&&H(a,"formAction",d);null!=e&&H(a,"formEncType",e);null!=f&&H(a,"formMethod",f);null!=g&&H(a,"formTarget",g);return k}
-function H(a,b,c){switch(b){case "className":G(a,"class",c);break;case "tabIndex":G(a,"tabindex",c);break;case "dir":case "role":case "viewBox":case "width":case "height":G(a,b,c);break;case "style":Ab(a,c);break;case "src":case "href":if(""===c)break;case "action":case "formAction":if(null==c||"function"===typeof c||"symbol"===typeof c||"boolean"===typeof c)break;a.push(" ",b,'="',x(""+c),'"');break;case "defaultValue":case "defaultChecked":case "innerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":break;
-case "autoFocus":case "multiple":case "muted":Bb(a,b.toLowerCase(),c);break;case "xlinkHref":if("function"===typeof c||"symbol"===typeof c||"boolean"===typeof c)break;a.push(" ","xlink:href",'="',x(""+c),'"');break;case "contentEditable":case "spellCheck":case "draggable":case "value":case "autoReverse":case "externalResourcesRequired":case "focusable":case "preserveAlpha":"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'="',x(c),'"');break;case "allowFullScreen":case "async":case "autoPlay":case "controls":case "default":case "defer":case "disabled":case "disablePictureInPicture":case "disableRemotePlayback":case "formNoValidate":case "hidden":case "loop":case "noModule":case "noValidate":case "open":case "playsInline":case "readOnly":case "required":case "reversed":case "scoped":case "seamless":case "itemScope":c&&
-"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'=""');break;case "capture":case "download":!0===c?a.push(" ",b,'=""'):!1!==c&&"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'="',x(c),'"');break;case "cols":case "rows":case "size":case "span":"function"!==typeof c&&"symbol"!==typeof c&&!isNaN(c)&&1<=c&&a.push(" ",b,'="',x(c),'"');break;case "rowSpan":case "start":"function"===typeof c||"symbol"===typeof c||isNaN(c)||a.push(" ",b,'="',x(c),'"');break;case "xlinkActuate":G(a,"xlink:actuate",
-c);break;case "xlinkArcrole":G(a,"xlink:arcrole",c);break;case "xlinkRole":G(a,"xlink:role",c);break;case "xlinkShow":G(a,"xlink:show",c);break;case "xlinkTitle":G(a,"xlink:title",c);break;case "xlinkType":G(a,"xlink:type",c);break;case "xmlBase":G(a,"xml:base",c);break;case "xmlLang":G(a,"xml:lang",c);break;case "xmlSpace":G(a,"xml:space",c);break;default:if(!(2<b.length)||"o"!==b[0]&&"O"!==b[0]||"n"!==b[1]&&"N"!==b[1])if(b=Aa.get(b)||b,ya(b)){switch(typeof c){case "function":case "symbol":return;
-case "boolean":var d=b.toLowerCase().slice(0,5);if("data-"!==d&&"aria-"!==d)return}a.push(" ",b,'="',x(c),'"')}}}function J(a,b,c){if(null!=b){if(null!=c)throw Error("Can only set one of `children` or `props.dangerouslySetInnerHTML`.");if("object"!==typeof b||!("__html"in b))throw Error("`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://reactjs.org/link/dangerously-set-inner-html for more information.");b=b.__html;null!==b&&void 0!==b&&a.push(""+b)}}
-function Hb(a){var b="";ca.Children.forEach(a,function(c){null!=c&&(b+=c)});return b}
-function Gb(a,b){0!==(a.instructions&16)||b.externalRuntimeScript||(a.instructions|=16,b.bootstrapChunks.unshift(b.startInlineScript,'addEventListener("submit",function(a){if(!a.defaultPrevented){var c=a.target,d=a.submitter,e=c.action,b=d;if(d){var f=d.getAttribute("formAction");null!=f&&(e=f,b=null)}"javascript:throw new Error(\'A React form was unexpectedly submitted.\')"===e&&(a.preventDefault(),b?(a=document.createElement("input"),a.name=b.name,a.value=b.value,b.parentNode.insertBefore(a,b),b=new FormData(c),a.parentNode.removeChild(a)):b=new FormData(c),a=c.getRootNode(),(a.$$reactFormReplay=a.$$reactFormReplay||[]).push(c,\nd,b))}});',"\x3c/script>"))}
-function Ib(a,b,c,d,e,f,g){var h=b.rel,k=b.href,l=b.precedence;if(3===f||g||null!=b.itemProp||"string"!==typeof h||"string"!==typeof k||""===k)return K(a,b),null;if("stylesheet"===b.rel){if("string"!==typeof l||null!=b.disabled||b.onLoad||b.onError)return K(a,b);f=d.styles.get(l);g=c.styleResources.hasOwnProperty(k)?c.styleResources[k]:void 0;null!==g?(c.styleResources[k]=null,f||(f={precedence:x(l),rules:[],hrefs:[],sheets:new Map},d.styles.set(l,f)),b={state:0,props:r({},b,{"data-precedence":b.precedence,
-precedence:null})},g&&(2===g.length&&Jb(b.props,g),(c=d.preloads.stylesheets.get(k))&&0<c.length?c.length=0:b.state=1),f.sheets.set(k,b),d.boundaryResources&&d.boundaryResources.stylesheets.add(b)):f&&(k=f.sheets.get(k))&&d.boundaryResources&&d.boundaryResources.stylesheets.add(k);e&&a.push("\x3c!-- --\x3e");return null}if(b.onLoad||b.onError)return K(a,b);e&&a.push("\x3c!-- --\x3e");switch(b.rel){case "preconnect":case "dns-prefetch":return K(d.preconnectChunks,b);case "preload":return K(d.preloadChunks,
-b);default:return K(d.hoistableChunks,b)}}function K(a,b){a.push(L("link"));for(var c in b)if(w.call(b,c)){var d=b[c];if(null!=d)switch(c){case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");default:H(a,c,d)}}a.push("/>");return null}
-function Kb(a,b,c){a.push(L(c));for(var d in b)if(w.call(b,d)){var e=b[d];if(null!=e)switch(d){case "children":case "dangerouslySetInnerHTML":throw Error(c+" is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");default:H(a,d,e)}}a.push("/>");return null}
-function Lb(a,b){a.push(L("title"));var c=null,d=null,e;for(e in b)if(w.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:H(a,e,f)}}a.push(">");b=Array.isArray(c)?2>c.length?c[0]:null:c;"function"!==typeof b&&"symbol"!==typeof b&&null!==b&&void 0!==b&&a.push(x(""+b));J(a,d,c);a.push(Mb("title"));return null}
-function Nb(a,b){a.push(L("script"));var c=null,d=null,e;for(e in b)if(w.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:H(a,e,f)}}a.push(">");J(a,d,c);"string"===typeof c&&a.push(x(c));a.push(Mb("script"));return null}
-function Ob(a,b,c){a.push(L(c));var d=c=null,e;for(e in b)if(w.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:H(a,e,f)}}a.push(">");J(a,d,c);return"string"===typeof c?(a.push(x(c)),null):c}var Pb=/^[a-zA-Z][a-zA-Z:_\.\-\d]*$/,Qb=new Map;function L(a){var b=Qb.get(a);if(void 0===b){if(!Pb.test(a))throw Error("Invalid tag: "+a);b="<"+a;Qb.set(a,b)}return b}
-function Rb(a,b,c,d,e,f,g){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "select":a.push(L("select"));var h=null,k=null,l;for(l in c)if(w.call(c,l)){var n=c[l];if(null!=n)switch(l){case "children":h=n;break;case "dangerouslySetInnerHTML":k=n;break;case "defaultValue":case "value":break;default:H(a,l,n)}}a.push(">");J(a,k,h);return h;case "option":var q=f.selectedValue;a.push(L("option"));var m=null,B=null,C=null,P=null,u;for(u in c)if(w.call(c,
-u)){var z=c[u];if(null!=z)switch(u){case "children":m=z;break;case "selected":C=z;break;case "dangerouslySetInnerHTML":P=z;break;case "value":B=z;default:H(a,u,z)}}if(null!=q){var p=null!==B?""+B:Hb(m);if(Ka(q))for(var Z=0;Z<q.length;Z++){if(""+q[Z]===p){a.push(' selected=""');break}}else""+q===p&&a.push(' selected=""')}else C&&a.push(' selected=""');a.push(">");J(a,P,m);return m;case "textarea":a.push(L("textarea"));var t=null,T=null,D=null,A;for(A in c)if(w.call(c,A)){var v=c[A];if(null!=v)switch(A){case "children":D=
-v;break;case "value":t=v;break;case "defaultValue":T=v;break;case "dangerouslySetInnerHTML":throw Error("`dangerouslySetInnerHTML` does not make sense on <textarea>.");default:H(a,A,v)}}null===t&&null!==T&&(t=T);a.push(">");if(null!=D){if(null!=t)throw Error("If you supply `defaultValue` on a <textarea>, do not pass children.");if(Ka(D)){if(1<D.length)throw Error("<textarea> can only have at most one child.");t=""+D[0]}t=""+D}"string"===typeof t&&"\n"===t[0]&&a.push("\n");null!==t&&a.push(x(""+t));
-return null;case "input":a.push(L("input"));var Pa=null,qb=null,Ba=null,ka=null,da=null,U=null,Qa=null,Ra=null,Sa=null,la;for(la in c)if(w.call(c,la)){var N=c[la];if(null!=N)switch(la){case "children":case "dangerouslySetInnerHTML":throw Error("input is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");case "name":Pa=N;break;case "formAction":qb=N;break;case "formEncType":Ba=N;break;case "formMethod":ka=N;break;case "formTarget":da=N;break;case "defaultChecked":Sa=
-N;break;case "defaultValue":Qa=N;break;case "checked":Ra=N;break;case "value":U=N;break;default:H(a,la,N)}}var rb=Fb(a,d,e,qb,Ba,ka,da,Pa);null!==Ra?Bb(a,"checked",Ra):null!==Sa&&Bb(a,"checked",Sa);null!==U?H(a,"value",U):null!==Qa&&H(a,"value",Qa);a.push("/>");null!==rb&&rb.forEach(Eb,a);return null;case "button":a.push(L("button"));var ma=null,na=null,aa=null,oa=null,pa=null,Ta=null,qa=null,Ua;for(Ua in c)if(w.call(c,Ua)){var ba=c[Ua];if(null!=ba)switch(Ua){case "children":ma=ba;break;case "dangerouslySetInnerHTML":na=
-ba;break;case "name":aa=ba;break;case "formAction":oa=ba;break;case "formEncType":pa=ba;break;case "formMethod":Ta=ba;break;case "formTarget":qa=ba;break;default:H(a,Ua,ba)}}var Sc=Fb(a,d,e,oa,pa,Ta,qa,aa);a.push(">");null!==Sc&&Sc.forEach(Eb,a);J(a,na,ma);if("string"===typeof ma){a.push(x(ma));var Tc=null}else Tc=ma;return Tc;case "form":a.push(L("form"));var Va=null,Uc=null,ea=null,Wa=null,Xa=null,Ya=null,Za;for(Za in c)if(w.call(c,Za)){var fa=c[Za];if(null!=fa)switch(Za){case "children":Va=fa;
-break;case "dangerouslySetInnerHTML":Uc=fa;break;case "action":ea=fa;break;case "encType":Wa=fa;break;case "method":Xa=fa;break;case "target":Ya=fa;break;default:H(a,Za,fa)}}var Yb=null,Zb=null;if("function"===typeof ea)if("function"===typeof ea.$$FORM_ACTION){var Ce=Cb(d),Ca=ea.$$FORM_ACTION(Ce);ea=Ca.action||"";Wa=Ca.encType;Xa=Ca.method;Ya=Ca.target;Yb=Ca.data;Zb=Ca.name}else a.push(" ","action",'="',Db,'"'),Ya=Xa=Wa=ea=null,Gb(d,e);null!=ea&&H(a,"action",ea);null!=Wa&&H(a,"encType",Wa);null!=
-Xa&&H(a,"method",Xa);null!=Ya&&H(a,"target",Ya);a.push(">");null!==Zb&&(a.push('<input type="hidden"'),G(a,"name",Zb),a.push("/>"),null!==Yb&&Yb.forEach(Eb,a));J(a,Uc,Va);if("string"===typeof Va){a.push(x(Va));var Vc=null}else Vc=Va;return Vc;case "menuitem":a.push(L("menuitem"));for(var sb in c)if(w.call(c,sb)){var Wc=c[sb];if(null!=Wc)switch(sb){case "children":case "dangerouslySetInnerHTML":throw Error("menuitems cannot have `children` nor `dangerouslySetInnerHTML`.");default:H(a,sb,Wc)}}a.push(">");
-return null;case "title":if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp)var Xc=Lb(a,c);else Lb(e.hoistableChunks,c),Xc=null;return Xc;case "link":return Ib(a,c,d,e,g,f.insertionMode,!!(f.tagScope&1));case "script":var $b=c.async;if("string"!==typeof c.src||!c.src||!$b||"function"===typeof $b||"symbol"===typeof $b||c.onLoad||c.onError||3===f.insertionMode||f.tagScope&1||null!=c.itemProp)var Yc=Nb(a,c);else{var tb=c.src;if("module"===c.type){var ub=d.moduleScriptResources;var Zc=e.preloads.moduleScripts}else ub=
-d.scriptResources,Zc=e.preloads.scripts;var vb=ub.hasOwnProperty(tb)?ub[tb]:void 0;if(null!==vb){ub[tb]=null;var ac=c;if(vb){2===vb.length&&(ac=r({},c),Jb(ac,vb));var $c=Zc.get(tb);$c&&($c.length=0)}var ad=[];e.scripts.add(ad);Nb(ad,ac)}g&&a.push("\x3c!-- --\x3e");Yc=null}return Yc;case "style":var wb=c.precedence,ra=c.href;if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp||"string"!==typeof wb||"string"!==typeof ra||""===ra){a.push(L("style"));var Da=null,bd=null,$a;for($a in c)if(w.call(c,
-$a)){var xb=c[$a];if(null!=xb)switch($a){case "children":Da=xb;break;case "dangerouslySetInnerHTML":bd=xb;break;default:H(a,$a,xb)}}a.push(">");var ab=Array.isArray(Da)?2>Da.length?Da[0]:null:Da;"function"!==typeof ab&&"symbol"!==typeof ab&&null!==ab&&void 0!==ab&&a.push(x(""+ab));J(a,bd,Da);a.push(Mb("style"));var cd=null}else{var sa=e.styles.get(wb);if(null!==(d.styleResources.hasOwnProperty(ra)?d.styleResources[ra]:void 0)){d.styleResources[ra]=null;sa?sa.hrefs.push(x(ra)):(sa={precedence:x(wb),
-rules:[],hrefs:[x(ra)],sheets:new Map},e.styles.set(wb,sa));var dd=sa.rules,Ea=null,ed=null,yb;for(yb in c)if(w.call(c,yb)){var bc=c[yb];if(null!=bc)switch(yb){case "children":Ea=bc;break;case "dangerouslySetInnerHTML":ed=bc}}var bb=Array.isArray(Ea)?2>Ea.length?Ea[0]:null:Ea;"function"!==typeof bb&&"symbol"!==typeof bb&&null!==bb&&void 0!==bb&&dd.push(x(""+bb));J(dd,ed,Ea)}sa&&e.boundaryResources&&e.boundaryResources.styles.add(sa);g&&a.push("\x3c!-- --\x3e");cd=void 0}return cd;case "meta":if(3===
-f.insertionMode||f.tagScope&1||null!=c.itemProp)var fd=Kb(a,c,"meta");else g&&a.push("\x3c!-- --\x3e"),fd="string"===typeof c.charSet?Kb(e.charsetChunks,c,"meta"):"viewport"===c.name?Kb(e.preconnectChunks,c,"meta"):Kb(e.hoistableChunks,c,"meta");return fd;case "listing":case "pre":a.push(L(b));var cb=null,db=null,eb;for(eb in c)if(w.call(c,eb)){var zb=c[eb];if(null!=zb)switch(eb){case "children":cb=zb;break;case "dangerouslySetInnerHTML":db=zb;break;default:H(a,eb,zb)}}a.push(">");if(null!=db){if(null!=
-cb)throw Error("Can only set one of `children` or `props.dangerouslySetInnerHTML`.");if("object"!==typeof db||!("__html"in db))throw Error("`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://reactjs.org/link/dangerously-set-inner-html for more information.");var ta=db.__html;null!==ta&&void 0!==ta&&("string"===typeof ta&&0<ta.length&&"\n"===ta[0]?a.push("\n",ta):a.push(""+ta))}"string"===typeof cb&&"\n"===cb[0]&&a.push("\n");return cb;case "img":var I=c.src,
-E=c.srcSet;if(!("lazy"===c.loading||!I&&!E||"string"!==typeof I&&null!=I||"string"!==typeof E&&null!=E)&&"low"!==c.fetchPriority&&!1===!!(f.tagScope&2)&&("string"!==typeof I||":"!==I[4]||"d"!==I[0]&&"D"!==I[0]||"a"!==I[1]&&"A"!==I[1]||"t"!==I[2]&&"T"!==I[2]||"a"!==I[3]&&"A"!==I[3])&&("string"!==typeof E||":"!==E[4]||"d"!==E[0]&&"D"!==E[0]||"a"!==E[1]&&"A"!==E[1]||"t"!==E[2]&&"T"!==E[2]||"a"!==E[3]&&"A"!==E[3])){var gd="string"===typeof c.sizes?c.sizes:void 0,Fa=E?E+"\n"+(gd||""):I,cc=e.preloads.images,
-ua=cc.get(Fa);if(ua){if("high"===c.fetchPriority||10>e.highImagePreloads.size)cc.delete(Fa),e.highImagePreloads.add(ua)}else if(!d.imageResources.hasOwnProperty(Fa)){d.imageResources[Fa]=y;var dc=c.crossOrigin;var hd="string"===typeof dc?"use-credentials"===dc?dc:"":void 0;var V=e.headers,ec;V&&0<V.remainingCapacity&&("high"===c.fetchPriority||500>V.highImagePreloads.length)&&(ec=Sb(I,"image",{imageSrcSet:c.srcSet,imageSizes:c.sizes,crossOrigin:hd,integrity:c.integrity,nonce:c.nonce,type:c.type,fetchPriority:c.fetchPriority,
-referrerPolicy:c.refererPolicy}),2<=(V.remainingCapacity-=ec.length))?(e.resets.image[Fa]=y,V.highImagePreloads&&(V.highImagePreloads+=", "),V.highImagePreloads+=ec):(ua=[],K(ua,{rel:"preload",as:"image",href:E?void 0:I,imageSrcSet:E,imageSizes:gd,crossOrigin:hd,integrity:c.integrity,type:c.type,fetchPriority:c.fetchPriority,referrerPolicy:c.referrerPolicy}),"high"===c.fetchPriority||10>e.highImagePreloads.size?e.highImagePreloads.add(ua):(e.bulkPreloads.add(ua),cc.set(Fa,ua)))}}return Kb(a,c,"img");
-case "base":case "area":case "br":case "col":case "embed":case "hr":case "keygen":case "param":case "source":case "track":case "wbr":return Kb(a,c,b);case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph":break;case "head":if(2>f.insertionMode&&null===e.headChunks){e.headChunks=[];var id=Ob(e.headChunks,c,"head")}else id=Ob(a,c,"head");return id;case "html":if(0===f.insertionMode&&null===
-e.htmlChunks){e.htmlChunks=[""];var jd=Ob(e.htmlChunks,c,"html")}else jd=Ob(a,c,"html");return jd;default:if(-1!==b.indexOf("-")){a.push(L(b));var fc=null,kd=null,Ga;for(Ga in c)if(w.call(c,Ga)){var Q=c[Ga];if(null!=Q){var ld=Ga;switch(Ga){case "children":fc=Q;break;case "dangerouslySetInnerHTML":kd=Q;break;case "style":Ab(a,Q);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":break;case "className":ld="class";default:if(ya(Ga)&&"function"!==typeof Q&&"symbol"!==typeof Q&&
-!1!==Q){if(!0===Q)Q="";else if("object"===typeof Q)continue;a.push(" ",ld,'="',x(Q),'"')}}}}a.push(">");J(a,kd,fc);return fc}}return Ob(a,c,b)}var Tb=new Map;function Mb(a){var b=Tb.get(a);void 0===b&&(b="</"+a+">",Tb.set(a,b));return b}function Ub(a,b){b=b.bootstrapChunks;for(var c=0;c<b.length-1;c++)a.push(b[c]);return c<b.length?(c=b[c],b.length=0,a.push(c)):!0}
-function Vb(a,b,c){a.push('\x3c!--$?--\x3e<template id="');if(null===c)throw Error("An ID must have been assigned before we can complete the boundary.");a.push(b.boundaryPrefix);b=c.toString(16);a.push(b);return a.push('"></template>')}
-function Wb(a,b,c,d){switch(c.insertionMode){case 0:case 1:case 2:return a.push('<div hidden id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 3:return a.push('<svg aria-hidden="true" style="display:none" id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 4:return a.push('<math aria-hidden="true" style="display:none" id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 5:return a.push('<table hidden id="'),a.push(b.segmentPrefix),
+function z(a){if("boolean"===typeof a||"number"===typeof a)return""+a;a=""+a;var b=Ha.exec(a);if(b){var c="",d,e=0;for(d=b.index;d<a.length;d++){switch(a.charCodeAt(d)){case 34:b="&quot;";break;case 38:b="&amp;";break;case 39:b="&#x27;";break;case 60:b="&lt;";break;case 62:b="&gt;";break;default:continue}e!==d&&(c+=a.slice(e,d));e=d+1;c+=b}a=e!==d?c+a.slice(e,d):c}return a}
+var Ia=/([A-Z])/g,Ja=/^ms-/,Ka=Array.isArray,La=ca.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,Ma={pending:!1,data:null,method:null,action:null},Na=ha.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Dispatcher,lb={prefetchDNS:Oa,preconnect:fb,preload:gb,preloadModule:hb,preinitStyle:ib,preinitScript:jb,preinitModuleScript:kb},A=[],mb=/(<\/|<)(s)(cript)/gi;function nb(a,b,c,d){return""+b+("s"===c?"\\u0073":"\\u0053")+d}
+function ob(a,b,c,d,e){var f=0;void 0!==b&&(f=1);return{idPrefix:void 0===a?"":a,nextFormID:0,streamingFormat:f,bootstrapScriptContent:c,bootstrapScripts:d,bootstrapModules:e,instructions:0,hasBody:!1,hasHtml:!1,unknownResources:{},dnsResources:{},connectResources:{default:{},anonymous:{},credentials:{}},imageResources:{},styleResources:{},scriptResources:{},moduleUnknownResources:{},moduleScriptResources:{}}}function F(a,b,c){return{insertionMode:a,selectedValue:b,tagScope:c}}
+function pb(a){return F("http://www.w3.org/2000/svg"===a?3:"http://www.w3.org/1998/Math/MathML"===a?4:0,null,0)}
+function Ab(a,b,c){switch(b){case "noscript":return F(2,null,a.tagScope|1);case "select":return F(2,null!=c.value?c.value:c.defaultValue,a.tagScope);case "svg":return F(3,null,a.tagScope);case "picture":return F(2,null,a.tagScope|2);case "math":return F(4,null,a.tagScope);case "foreignObject":return F(2,null,a.tagScope);case "table":return F(5,null,a.tagScope);case "thead":case "tbody":case "tfoot":return F(6,null,a.tagScope);case "colgroup":return F(8,null,a.tagScope);case "tr":return F(7,null,a.tagScope)}return 5<=
+a.insertionMode?F(2,null,a.tagScope):0===a.insertionMode?"html"===b?F(1,null,a.tagScope):F(2,null,a.tagScope):1===a.insertionMode?F(2,null,a.tagScope):a}var Bb=new Map;
+function Cb(a,b){if("object"!==typeof b)throw Error("The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + 'em'}} when using JSX.");var c=!0,d;for(d in b)if(y.call(b,d)){var e=b[d];if(null!=e&&"boolean"!==typeof e&&""!==e){if(0===d.indexOf("--")){var f=z(d);e=z((""+e).trim())}else f=Bb.get(d),void 0===f&&(f=z(d.replace(Ia,"-$1").toLowerCase().replace(Ja,"-ms-")),Bb.set(d,f)),e="number"===typeof e?0===e||za.has(d)?""+e:e+"px":
+z((""+e).trim());c?(c=!1,a.push(' style="',f,":",e)):a.push(";",f,":",e)}}c||a.push('"')}function Db(a,b,c){c&&"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'=""')}function I(a,b,c){"function"!==typeof c&&"symbol"!==typeof c&&"boolean"!==typeof c&&a.push(" ",b,'="',z(c),'"')}function Eb(a){var b=a.nextFormID++;return a.idPrefix+b}var Fb=z("javascript:throw new Error('A React form was unexpectedly submitted.')");
+function Gb(a,b){this.push('<input type="hidden"');if("string"!==typeof a)throw Error("File/Blob fields are not yet supported in progressive forms. It probably means you are closing over binary data or FormData in a Server Action.");I(this,"name",b);I(this,"value",a);this.push("/>")}
+function Hb(a,b,c,d,e,f,g,h){var k=null;"function"===typeof d&&("function"===typeof d.$$FORM_ACTION?(e=Eb(b),b=d.$$FORM_ACTION(e),h=b.name,d=b.action||"",e=b.encType,f=b.method,g=b.target,k=b.data):(a.push(" ","formAction",'="',Fb,'"'),g=f=e=d=h=null,Ib(b,c)));null!=h&&J(a,"name",h);null!=d&&J(a,"formAction",d);null!=e&&J(a,"formEncType",e);null!=f&&J(a,"formMethod",f);null!=g&&J(a,"formTarget",g);return k}
+function J(a,b,c){switch(b){case "className":I(a,"class",c);break;case "tabIndex":I(a,"tabindex",c);break;case "dir":case "role":case "viewBox":case "width":case "height":I(a,b,c);break;case "style":Cb(a,c);break;case "src":case "href":if(""===c)break;case "action":case "formAction":if(null==c||"function"===typeof c||"symbol"===typeof c||"boolean"===typeof c)break;a.push(" ",b,'="',z(""+c),'"');break;case "defaultValue":case "defaultChecked":case "innerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":break;
+case "autoFocus":case "multiple":case "muted":Db(a,b.toLowerCase(),c);break;case "xlinkHref":if("function"===typeof c||"symbol"===typeof c||"boolean"===typeof c)break;a.push(" ","xlink:href",'="',z(""+c),'"');break;case "contentEditable":case "spellCheck":case "draggable":case "value":case "autoReverse":case "externalResourcesRequired":case "focusable":case "preserveAlpha":"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'="',z(c),'"');break;case "allowFullScreen":case "async":case "autoPlay":case "controls":case "default":case "defer":case "disabled":case "disablePictureInPicture":case "disableRemotePlayback":case "formNoValidate":case "hidden":case "loop":case "noModule":case "noValidate":case "open":case "playsInline":case "readOnly":case "required":case "reversed":case "scoped":case "seamless":case "itemScope":c&&
+"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'=""');break;case "capture":case "download":!0===c?a.push(" ",b,'=""'):!1!==c&&"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'="',z(c),'"');break;case "cols":case "rows":case "size":case "span":"function"!==typeof c&&"symbol"!==typeof c&&!isNaN(c)&&1<=c&&a.push(" ",b,'="',z(c),'"');break;case "rowSpan":case "start":"function"===typeof c||"symbol"===typeof c||isNaN(c)||a.push(" ",b,'="',z(c),'"');break;case "xlinkActuate":I(a,"xlink:actuate",
+c);break;case "xlinkArcrole":I(a,"xlink:arcrole",c);break;case "xlinkRole":I(a,"xlink:role",c);break;case "xlinkShow":I(a,"xlink:show",c);break;case "xlinkTitle":I(a,"xlink:title",c);break;case "xlinkType":I(a,"xlink:type",c);break;case "xmlBase":I(a,"xml:base",c);break;case "xmlLang":I(a,"xml:lang",c);break;case "xmlSpace":I(a,"xml:space",c);break;default:if(!(2<b.length)||"o"!==b[0]&&"O"!==b[0]||"n"!==b[1]&&"N"!==b[1])if(b=Aa.get(b)||b,ya(b)){switch(typeof c){case "function":case "symbol":return;
+case "boolean":var d=b.toLowerCase().slice(0,5);if("data-"!==d&&"aria-"!==d)return}a.push(" ",b,'="',z(c),'"')}}}function L(a,b,c){if(null!=b){if(null!=c)throw Error("Can only set one of `children` or `props.dangerouslySetInnerHTML`.");if("object"!==typeof b||!("__html"in b))throw Error("`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://reactjs.org/link/dangerously-set-inner-html for more information.");b=b.__html;null!==b&&void 0!==b&&a.push(""+b)}}
+function Jb(a){var b="";ca.Children.forEach(a,function(c){null!=c&&(b+=c)});return b}
+function Ib(a,b){0!==(a.instructions&16)||b.externalRuntimeScript||(a.instructions|=16,b.bootstrapChunks.unshift(b.startInlineScript,'addEventListener("submit",function(a){if(!a.defaultPrevented){var c=a.target,d=a.submitter,e=c.action,b=d;if(d){var f=d.getAttribute("formAction");null!=f&&(e=f,b=null)}"javascript:throw new Error(\'A React form was unexpectedly submitted.\')"===e&&(a.preventDefault(),b?(a=document.createElement("input"),a.name=b.name,a.value=b.value,b.parentNode.insertBefore(a,b),b=new FormData(c),a.parentNode.removeChild(a)):b=new FormData(c),a=c.getRootNode(),(a.$$reactFormReplay=a.$$reactFormReplay||[]).push(c,\nd,b))}});',"\x3c/script>"))}
+function Kb(a,b,c,d,e,f,g){var h=b.rel,k=b.href,l=b.precedence;if(3===f||g||null!=b.itemProp||"string"!==typeof h||"string"!==typeof k||""===k)return M(a,b),null;if("stylesheet"===b.rel){if("string"!==typeof l||null!=b.disabled||b.onLoad||b.onError)return M(a,b);f=d.styles.get(l);g=c.styleResources.hasOwnProperty(k)?c.styleResources[k]:void 0;null!==g?(c.styleResources[k]=null,f||(f={precedence:z(l),rules:[],hrefs:[],sheets:new Map},d.styles.set(l,f)),b={state:0,props:q({},b,{"data-precedence":b.precedence,
+precedence:null})},g&&(2===g.length&&Lb(b.props,g),(c=d.preloads.stylesheets.get(k))&&0<c.length?c.length=0:b.state=1),f.sheets.set(k,b),d.boundaryResources&&d.boundaryResources.stylesheets.add(b)):f&&(k=f.sheets.get(k))&&d.boundaryResources&&d.boundaryResources.stylesheets.add(k);e&&a.push("\x3c!-- --\x3e");return null}if(b.onLoad||b.onError)return M(a,b);e&&a.push("\x3c!-- --\x3e");switch(b.rel){case "preconnect":case "dns-prefetch":return M(d.preconnectChunks,b);case "preload":return M(d.preloadChunks,
+b);default:return M(d.hoistableChunks,b)}}function M(a,b){a.push(N("link"));for(var c in b)if(y.call(b,c)){var d=b[c];if(null!=d)switch(c){case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");default:J(a,c,d)}}a.push("/>");return null}
+function Mb(a,b,c){a.push(N(c));for(var d in b)if(y.call(b,d)){var e=b[d];if(null!=e)switch(d){case "children":case "dangerouslySetInnerHTML":throw Error(c+" is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");default:J(a,d,e)}}a.push("/>");return null}
+function Nb(a,b){a.push(N("title"));var c=null,d=null,e;for(e in b)if(y.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:J(a,e,f)}}a.push(">");b=Array.isArray(c)?2>c.length?c[0]:null:c;"function"!==typeof b&&"symbol"!==typeof b&&null!==b&&void 0!==b&&a.push(z(""+b));L(a,d,c);a.push(Ob("title"));return null}
+function Pb(a,b){a.push(N("script"));var c=null,d=null,e;for(e in b)if(y.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:J(a,e,f)}}a.push(">");L(a,d,c);"string"===typeof c&&a.push(z(c));a.push(Ob("script"));return null}
+function Qb(a,b,c){a.push(N(c));var d=c=null,e;for(e in b)if(y.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:J(a,e,f)}}a.push(">");L(a,d,c);return"string"===typeof c?(a.push(z(c)),null):c}var Rb=/^[a-zA-Z][a-zA-Z:_\.\-\d]*$/,Sb=new Map;function N(a){var b=Sb.get(a);if(void 0===b){if(!Rb.test(a))throw Error("Invalid tag: "+a);b="<"+a;Sb.set(a,b)}return b}
+function Tb(a,b,c,d,e,f,g){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "select":a.push(N("select"));var h=null,k=null,l;for(l in c)if(y.call(c,l)){var n=c[l];if(null!=n)switch(l){case "children":h=n;break;case "dangerouslySetInnerHTML":k=n;break;case "defaultValue":case "value":break;default:J(a,l,n)}}a.push(">");L(a,k,h);return h;case "option":var r=f.selectedValue;a.push(N("option"));var m=null,B=null,E=null,P=null,v;for(v in c)if(y.call(c,
+v)){var t=c[v];if(null!=t)switch(v){case "children":m=t;break;case "selected":E=t;break;case "dangerouslySetInnerHTML":P=t;break;case "value":B=t;default:J(a,v,t)}}if(null!=r){var p=null!==B?""+B:Jb(m);if(Ka(r))for(var G=0;G<r.length;G++){if(""+r[G]===p){a.push(' selected=""');break}}else""+r===p&&a.push(' selected=""')}else E&&a.push(' selected=""');a.push(">");L(a,P,m);return m;case "textarea":a.push(N("textarea"));var u=null,w=null,D=null,C;for(C in c)if(y.call(c,C)){var x=c[C];if(null!=x)switch(C){case "children":D=
+x;break;case "value":u=x;break;case "defaultValue":w=x;break;case "dangerouslySetInnerHTML":throw Error("`dangerouslySetInnerHTML` does not make sense on <textarea>.");default:J(a,C,x)}}null===u&&null!==w&&(u=w);a.push(">");if(null!=D){if(null!=u)throw Error("If you supply `defaultValue` on a <textarea>, do not pass children.");if(Ka(D)){if(1<D.length)throw Error("<textarea> can only have at most one child.");u=""+D[0]}u=""+D}"string"===typeof u&&"\n"===u[0]&&a.push("\n");null!==u&&a.push(z(""+u));
+return null;case "input":a.push(N("input"));var Pa=null,qb=null,Ba=null,ka=null,da=null,V=null,Qa=null,Ra=null,Sa=null,la;for(la in c)if(y.call(c,la)){var Q=c[la];if(null!=Q)switch(la){case "children":case "dangerouslySetInnerHTML":throw Error("input is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");case "name":Pa=Q;break;case "formAction":qb=Q;break;case "formEncType":Ba=Q;break;case "formMethod":ka=Q;break;case "formTarget":da=Q;break;case "defaultChecked":Sa=
+Q;break;case "defaultValue":Qa=Q;break;case "checked":Ra=Q;break;case "value":V=Q;break;default:J(a,la,Q)}}var rb=Hb(a,d,e,qb,Ba,ka,da,Pa);null!==Ra?Db(a,"checked",Ra):null!==Sa&&Db(a,"checked",Sa);null!==V?J(a,"value",V):null!==Qa&&J(a,"value",Qa);a.push("/>");null!==rb&&rb.forEach(Gb,a);return null;case "button":a.push(N("button"));var ma=null,na=null,aa=null,oa=null,pa=null,Ta=null,qa=null,Ua;for(Ua in c)if(y.call(c,Ua)){var ba=c[Ua];if(null!=ba)switch(Ua){case "children":ma=ba;break;case "dangerouslySetInnerHTML":na=
+ba;break;case "name":aa=ba;break;case "formAction":oa=ba;break;case "formEncType":pa=ba;break;case "formMethod":Ta=ba;break;case "formTarget":qa=ba;break;default:J(a,Ua,ba)}}var Sc=Hb(a,d,e,oa,pa,Ta,qa,aa);a.push(">");null!==Sc&&Sc.forEach(Gb,a);L(a,na,ma);if("string"===typeof ma){a.push(z(ma));var Tc=null}else Tc=ma;return Tc;case "form":a.push(N("form"));var Va=null,Uc=null,ea=null,Wa=null,Xa=null,Ya=null,Za;for(Za in c)if(y.call(c,Za)){var fa=c[Za];if(null!=fa)switch(Za){case "children":Va=fa;
+break;case "dangerouslySetInnerHTML":Uc=fa;break;case "action":ea=fa;break;case "encType":Wa=fa;break;case "method":Xa=fa;break;case "target":Ya=fa;break;default:J(a,Za,fa)}}var Yb=null,Zb=null;if("function"===typeof ea)if("function"===typeof ea.$$FORM_ACTION){var Ee=Eb(d),Ca=ea.$$FORM_ACTION(Ee);ea=Ca.action||"";Wa=Ca.encType;Xa=Ca.method;Ya=Ca.target;Yb=Ca.data;Zb=Ca.name}else a.push(" ","action",'="',Fb,'"'),Ya=Xa=Wa=ea=null,Ib(d,e);null!=ea&&J(a,"action",ea);null!=Wa&&J(a,"encType",Wa);null!=
+Xa&&J(a,"method",Xa);null!=Ya&&J(a,"target",Ya);a.push(">");null!==Zb&&(a.push('<input type="hidden"'),I(a,"name",Zb),a.push("/>"),null!==Yb&&Yb.forEach(Gb,a));L(a,Uc,Va);if("string"===typeof Va){a.push(z(Va));var Vc=null}else Vc=Va;return Vc;case "menuitem":a.push(N("menuitem"));for(var sb in c)if(y.call(c,sb)){var Wc=c[sb];if(null!=Wc)switch(sb){case "children":case "dangerouslySetInnerHTML":throw Error("menuitems cannot have `children` nor `dangerouslySetInnerHTML`.");default:J(a,sb,Wc)}}a.push(">");
+return null;case "title":if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp)var Xc=Nb(a,c);else Nb(e.hoistableChunks,c),Xc=null;return Xc;case "link":return Kb(a,c,d,e,g,f.insertionMode,!!(f.tagScope&1));case "script":var $b=c.async;if("string"!==typeof c.src||!c.src||!$b||"function"===typeof $b||"symbol"===typeof $b||c.onLoad||c.onError||3===f.insertionMode||f.tagScope&1||null!=c.itemProp)var Yc=Pb(a,c);else{var tb=c.src;if("module"===c.type){var ub=d.moduleScriptResources;var Zc=e.preloads.moduleScripts}else ub=
+d.scriptResources,Zc=e.preloads.scripts;var vb=ub.hasOwnProperty(tb)?ub[tb]:void 0;if(null!==vb){ub[tb]=null;var ac=c;if(vb){2===vb.length&&(ac=q({},c),Lb(ac,vb));var $c=Zc.get(tb);$c&&($c.length=0)}var ad=[];e.scripts.add(ad);Pb(ad,ac)}g&&a.push("\x3c!-- --\x3e");Yc=null}return Yc;case "style":var wb=c.precedence,ra=c.href;if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp||"string"!==typeof wb||"string"!==typeof ra||""===ra){a.push(N("style"));var Da=null,bd=null,$a;for($a in c)if(y.call(c,
+$a)){var xb=c[$a];if(null!=xb)switch($a){case "children":Da=xb;break;case "dangerouslySetInnerHTML":bd=xb;break;default:J(a,$a,xb)}}a.push(">");var ab=Array.isArray(Da)?2>Da.length?Da[0]:null:Da;"function"!==typeof ab&&"symbol"!==typeof ab&&null!==ab&&void 0!==ab&&a.push(z(""+ab));L(a,bd,Da);a.push(Ob("style"));var cd=null}else{var sa=e.styles.get(wb);if(null!==(d.styleResources.hasOwnProperty(ra)?d.styleResources[ra]:void 0)){d.styleResources[ra]=null;sa?sa.hrefs.push(z(ra)):(sa={precedence:z(wb),
+rules:[],hrefs:[z(ra)],sheets:new Map},e.styles.set(wb,sa));var dd=sa.rules,Ea=null,ed=null,yb;for(yb in c)if(y.call(c,yb)){var bc=c[yb];if(null!=bc)switch(yb){case "children":Ea=bc;break;case "dangerouslySetInnerHTML":ed=bc}}var bb=Array.isArray(Ea)?2>Ea.length?Ea[0]:null:Ea;"function"!==typeof bb&&"symbol"!==typeof bb&&null!==bb&&void 0!==bb&&dd.push(z(""+bb));L(dd,ed,Ea)}sa&&e.boundaryResources&&e.boundaryResources.styles.add(sa);g&&a.push("\x3c!-- --\x3e");cd=void 0}return cd;case "meta":if(3===
+f.insertionMode||f.tagScope&1||null!=c.itemProp)var fd=Mb(a,c,"meta");else g&&a.push("\x3c!-- --\x3e"),fd="string"===typeof c.charSet?Mb(e.charsetChunks,c,"meta"):"viewport"===c.name?Mb(e.preconnectChunks,c,"meta"):Mb(e.hoistableChunks,c,"meta");return fd;case "listing":case "pre":a.push(N(b));var cb=null,db=null,eb;for(eb in c)if(y.call(c,eb)){var zb=c[eb];if(null!=zb)switch(eb){case "children":cb=zb;break;case "dangerouslySetInnerHTML":db=zb;break;default:J(a,eb,zb)}}a.push(">");if(null!=db){if(null!=
+cb)throw Error("Can only set one of `children` or `props.dangerouslySetInnerHTML`.");if("object"!==typeof db||!("__html"in db))throw Error("`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://reactjs.org/link/dangerously-set-inner-html for more information.");var ta=db.__html;null!==ta&&void 0!==ta&&("string"===typeof ta&&0<ta.length&&"\n"===ta[0]?a.push("\n",ta):a.push(""+ta))}"string"===typeof cb&&"\n"===cb[0]&&a.push("\n");return cb;case "img":var K=c.src,
+H=c.srcSet;if(!("lazy"===c.loading||!K&&!H||"string"!==typeof K&&null!=K||"string"!==typeof H&&null!=H)&&"low"!==c.fetchPriority&&!1===!!(f.tagScope&2)&&("string"!==typeof K||":"!==K[4]||"d"!==K[0]&&"D"!==K[0]||"a"!==K[1]&&"A"!==K[1]||"t"!==K[2]&&"T"!==K[2]||"a"!==K[3]&&"A"!==K[3])&&("string"!==typeof H||":"!==H[4]||"d"!==H[0]&&"D"!==H[0]||"a"!==H[1]&&"A"!==H[1]||"t"!==H[2]&&"T"!==H[2]||"a"!==H[3]&&"A"!==H[3])){var gd="string"===typeof c.sizes?c.sizes:void 0,Fa=H?H+"\n"+(gd||""):K,cc=e.preloads.images,
+ua=cc.get(Fa);if(ua){if("high"===c.fetchPriority||10>e.highImagePreloads.size)cc.delete(Fa),e.highImagePreloads.add(ua)}else if(!d.imageResources.hasOwnProperty(Fa)){d.imageResources[Fa]=A;var dc=c.crossOrigin;var hd="string"===typeof dc?"use-credentials"===dc?dc:"":void 0;var W=e.headers,ec;W&&0<W.remainingCapacity&&("high"===c.fetchPriority||500>W.highImagePreloads.length)&&(ec=Ub(K,"image",{imageSrcSet:c.srcSet,imageSizes:c.sizes,crossOrigin:hd,integrity:c.integrity,nonce:c.nonce,type:c.type,fetchPriority:c.fetchPriority,
+referrerPolicy:c.refererPolicy}),2<=(W.remainingCapacity-=ec.length))?(e.resets.image[Fa]=A,W.highImagePreloads&&(W.highImagePreloads+=", "),W.highImagePreloads+=ec):(ua=[],M(ua,{rel:"preload",as:"image",href:H?void 0:K,imageSrcSet:H,imageSizes:gd,crossOrigin:hd,integrity:c.integrity,type:c.type,fetchPriority:c.fetchPriority,referrerPolicy:c.referrerPolicy}),"high"===c.fetchPriority||10>e.highImagePreloads.size?e.highImagePreloads.add(ua):(e.bulkPreloads.add(ua),cc.set(Fa,ua)))}}return Mb(a,c,"img");
+case "base":case "area":case "br":case "col":case "embed":case "hr":case "keygen":case "param":case "source":case "track":case "wbr":return Mb(a,c,b);case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph":break;case "head":if(2>f.insertionMode&&null===e.headChunks){e.headChunks=[];var id=Qb(e.headChunks,c,"head")}else id=Qb(a,c,"head");return id;case "html":if(0===f.insertionMode&&null===
+e.htmlChunks){e.htmlChunks=[""];var jd=Qb(e.htmlChunks,c,"html")}else jd=Qb(a,c,"html");return jd;default:if(-1!==b.indexOf("-")){a.push(N(b));var fc=null,kd=null,Ga;for(Ga in c)if(y.call(c,Ga)){var S=c[Ga];if(null!=S){var ld=Ga;switch(Ga){case "children":fc=S;break;case "dangerouslySetInnerHTML":kd=S;break;case "style":Cb(a,S);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":break;case "className":ld="class";default:if(ya(Ga)&&"function"!==typeof S&&"symbol"!==typeof S&&
+!1!==S){if(!0===S)S="";else if("object"===typeof S)continue;a.push(" ",ld,'="',z(S),'"')}}}}a.push(">");L(a,kd,fc);return fc}}return Qb(a,c,b)}var Vb=new Map;function Ob(a){var b=Vb.get(a);void 0===b&&(b="</"+a+">",Vb.set(a,b));return b}function Wb(a,b,c){c.bootstrapScriptContent=void 0;c.bootstrapScripts=void 0;c.bootstrapModules=void 0;b=b.bootstrapChunks;for(c=0;c<b.length-1;c++)a.push(b[c]);return c<b.length?(c=b[c],b.length=0,a.push(c)):!0}
+function Xb(a,b,c){a.push('\x3c!--$?--\x3e<template id="');if(null===c)throw Error("An ID must have been assigned before we can complete the boundary.");a.push(b.boundaryPrefix);b=c.toString(16);a.push(b);return a.push('"></template>')}
+function gc(a,b,c,d){switch(c.insertionMode){case 0:case 1:case 2:return a.push('<div hidden id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 3:return a.push('<svg aria-hidden="true" style="display:none" id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 4:return a.push('<math aria-hidden="true" style="display:none" id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 5:return a.push('<table hidden id="'),a.push(b.segmentPrefix),
 b=d.toString(16),a.push(b),a.push('">');case 6:return a.push('<table hidden><tbody id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 7:return a.push('<table hidden><tr id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 8:return a.push('<table hidden><colgroup id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');default:throw Error("Unknown insertion mode. This is a bug in React.");}}
-function Xb(a,b){switch(b.insertionMode){case 0:case 1:case 2:return a.push("</div>");case 3:return a.push("</svg>");case 4:return a.push("</math>");case 5:return a.push("</table>");case 6:return a.push("</tbody></table>");case 7:return a.push("</tr></table>");case 8:return a.push("</colgroup></table>");default:throw Error("Unknown insertion mode. This is a bug in React.");}}var gc=/[<\u2028\u2029]/g;
-function hc(a){return JSON.stringify(a).replace(gc,function(b){switch(b){case "<":return"\\u003c";case "\u2028":return"\\u2028";case "\u2029":return"\\u2029";default:throw Error("escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}})}var ic=/[&><\u2028\u2029]/g;
-function jc(a){return JSON.stringify(a).replace(ic,function(b){switch(b){case "&":return"\\u0026";case ">":return"\\u003e";case "<":return"\\u003c";case "\u2028":return"\\u2028";case "\u2029":return"\\u2029";default:throw Error("escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}})}var kc=!1,lc=!0;
-function mc(a){var b=a.rules,c=a.hrefs,d=0;if(c.length){this.push('<style media="not all" data-precedence="');this.push(a.precedence);for(this.push('" data-href="');d<c.length-1;d++)this.push(c[d]),this.push(" ");this.push(c[d]);this.push('">');for(d=0;d<b.length;d++)this.push(b[d]);lc=this.push("</style>");kc=!0;b.length=0;c.length=0}}function nc(a){return 2!==a.state?kc=!0:!1}function oc(a,b,c){kc=!1;lc=!0;b.styles.forEach(mc,a);b.stylesheets.forEach(nc);kc&&(c.stylesToHoist=!0);return lc}
-function M(a){for(var b=0;b<a.length;b++)this.push(a[b]);a.length=0}var pc=[];function qc(a){K(pc,a.props);for(var b=0;b<pc.length;b++)this.push(pc[b]);pc.length=0;a.state=2}
-function rc(a){var b=0<a.sheets.size;a.sheets.forEach(qc,this);a.sheets.clear();var c=a.rules,d=a.hrefs;if(!b||d.length){this.push('<style data-precedence="');this.push(a.precedence);a=0;if(d.length){for(this.push('" data-href="');a<d.length-1;a++)this.push(d[a]),this.push(" ");this.push(d[a])}this.push('">');for(a=0;a<c.length;a++)this.push(c[a]);this.push("</style>");c.length=0;d.length=0}}
-function sc(a){if(0===a.state){a.state=1;var b=a.props;K(pc,{rel:"preload",as:"style",href:a.props.href,crossOrigin:b.crossOrigin,fetchPriority:b.fetchPriority,integrity:b.integrity,media:b.media,hrefLang:b.hrefLang,referrerPolicy:b.referrerPolicy});for(a=0;a<pc.length;a++)this.push(pc[a]);pc.length=0}}function tc(a){a.sheets.forEach(sc,this);a.sheets.clear()}
-function uc(a,b){a.push("[");var c="[";b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)a.push(c),d=jc(""+d.props.href),a.push(d),a.push("]"),c=",[";else{a.push(c);var e=d.props["data-precedence"],f=d.props,g=jc(""+d.props.href);a.push(g);e=""+e;a.push(",");e=jc(e);a.push(e);for(var h in f)if(w.call(f,h)&&(g=f[h],null!=g))switch(h){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");
-default:a:{e=a;var k=h.toLowerCase();switch(typeof g){case "function":case "symbol":break a}switch(h){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":k="class";g=""+g;break;case "hidden":if(!1===g)break a;g="";break;case "src":case "href":g=""+g;break;default:if(2<h.length&&("o"===h[0]||"O"===h[0])&&("n"===h[1]||"N"===h[1])||!ya(h))break a;g=""+g}e.push(",");k=jc(k);e.push(k);e.push(",");g=
-jc(g);e.push(g)}}a.push("]");c=",[";d.state=3}});a.push("]")}
-function vc(a,b){a.push("[");var c="[";b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)a.push(c),d=x(JSON.stringify(""+d.props.href)),a.push(d),a.push("]"),c=",[";else{a.push(c);var e=d.props["data-precedence"],f=d.props,g=x(JSON.stringify(""+d.props.href));a.push(g);e=""+e;a.push(",");e=x(JSON.stringify(e));a.push(e);for(var h in f)if(w.call(f,h)&&(g=f[h],null!=g))switch(h){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");
-default:a:{e=a;var k=h.toLowerCase();switch(typeof g){case "function":case "symbol":break a}switch(h){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":k="class";g=""+g;break;case "hidden":if(!1===g)break a;g="";break;case "src":case "href":g=""+g;break;default:if(2<h.length&&("o"===h[0]||"O"===h[0])&&("n"===h[1]||"N"===h[1])||!ya(h))break a;g=""+g}e.push(",");k=x(JSON.stringify(k));e.push(k);
-e.push(",");g=x(JSON.stringify(g));e.push(g)}}a.push("]");c=",[";d.state=3}});a.push("]")}
-function Oa(a){var b=O?O:null;if(b){var c=b.resumableState,d=b.renderState;if("string"===typeof a&&a){if(!c.dnsResources.hasOwnProperty(a)){c.dnsResources[a]=null;c=d.headers;var e,f;if(f=c&&0<c.remainingCapacity)f=(e="<"+(""+a).replace(wc,xc)+">; rel=dns-prefetch",2<=(c.remainingCapacity-=e.length));f?(d.resets.dns[a]=null,c.preconnects&&(c.preconnects+=", "),c.preconnects+=e):(e=[],K(e,{href:a,rel:"dns-prefetch"}),d.preconnects.add(e))}yc(b)}}}
-function fb(a,b){var c=O?O:null;if(c){var d=c.resumableState,e=c.renderState;if("string"===typeof a&&a){var f="use-credentials"===b?"credentials":"string"===typeof b?"anonymous":"default";if(!d.connectResources[f].hasOwnProperty(a)){d.connectResources[f][a]=null;d=e.headers;var g,h;if(h=d&&0<d.remainingCapacity){h="<"+(""+a).replace(wc,xc)+">; rel=preconnect";if("string"===typeof b){var k=(""+b).replace(zc,Ac);h+='; crossorigin="'+k+'"'}h=(g=h,2<=(d.remainingCapacity-=g.length))}h?(e.resets.connect[f][a]=
-null,d.preconnects&&(d.preconnects+=", "),d.preconnects+=g):(f=[],K(f,{rel:"preconnect",href:a,crossOrigin:b}),e.preconnects.add(f))}yc(c)}}}
-function gb(a,b,c){var d=O?O:null;if(d){var e=d.resumableState,f=d.renderState;if(b&&a){switch(b){case "image":if(c){var g=c.imageSrcSet;var h=c.imageSizes;var k=c.fetchPriority}var l=g?g+"\n"+(h||""):a;if(e.imageResources.hasOwnProperty(l))return;e.imageResources[l]=y;e=f.headers;var n;e&&0<e.remainingCapacity&&"high"===k&&(n=Sb(a,b,c),2<=(e.remainingCapacity-=n.length))?(f.resets.image[l]=y,e.highImagePreloads&&(e.highImagePreloads+=", "),e.highImagePreloads+=n):(e=[],K(e,r({rel:"preload",href:g?
-void 0:a,as:b},c)),"high"===k?f.highImagePreloads.add(e):(f.bulkPreloads.add(e),f.preloads.images.set(l,e)));break;case "style":if(e.styleResources.hasOwnProperty(a))return;g=[];K(g,r({rel:"preload",href:a,as:b},c));e.styleResources[a]=!c||"string"!==typeof c.crossOrigin&&"string"!==typeof c.integrity?y:[c.crossOrigin,c.integrity];f.preloads.stylesheets.set(a,g);f.bulkPreloads.add(g);break;case "script":if(e.scriptResources.hasOwnProperty(a))return;g=[];f.preloads.scripts.set(a,g);f.bulkPreloads.add(g);
-K(g,r({rel:"preload",href:a,as:b},c));e.scriptResources[a]=!c||"string"!==typeof c.crossOrigin&&"string"!==typeof c.integrity?y:[c.crossOrigin,c.integrity];break;default:if(e.unknownResources.hasOwnProperty(b)){if(g=e.unknownResources[b],g.hasOwnProperty(a))return}else g={},e.unknownResources[b]=g;g[a]=y;if((e=f.headers)&&0<e.remainingCapacity&&"font"===b&&(l=Sb(a,b,c),2<=(e.remainingCapacity-=l.length)))f.resets.font[a]=y,e.fontPreloads&&(e.fontPreloads+=", "),e.fontPreloads+=l;else switch(e=[],
-a=r({rel:"preload",href:a,as:b},c),K(e,a),b){case "font":f.fontPreloads.add(e);break;default:f.bulkPreloads.add(e)}}yc(d)}}}
-function hb(a,b){var c=O?O:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=b&&"string"===typeof b.as?b.as:"script";switch(f){case "script":if(d.moduleScriptResources.hasOwnProperty(a))return;f=[];d.moduleScriptResources[a]=!b||"string"!==typeof b.crossOrigin&&"string"!==typeof b.integrity?y:[b.crossOrigin,b.integrity];e.preloads.moduleScripts.set(a,f);break;default:if(d.moduleUnknownResources.hasOwnProperty(f)){var g=d.unknownResources[f];if(g.hasOwnProperty(a))return}else g={},d.moduleUnknownResources[f]=
-g;f=[];g[a]=y}K(f,r({rel:"modulepreload",href:a},b));e.bulkPreloads.add(f);yc(c)}}}
-function ib(a,b,c){var d=O?O:null;if(d){var e=d.resumableState,f=d.renderState;if(a){b=b||"default";var g=f.styles.get(b),h=e.styleResources.hasOwnProperty(a)?e.styleResources[a]:void 0;null!==h&&(e.styleResources[a]=null,g||(g={precedence:x(b),rules:[],hrefs:[],sheets:new Map},f.styles.set(b,g)),b={state:0,props:r({rel:"stylesheet",href:a,"data-precedence":b},c)},h&&(2===h.length&&Jb(b.props,h),(f=f.preloads.stylesheets.get(a))&&0<f.length?f.length=0:b.state=1),g.sheets.set(a,b),yc(d))}}}
-function jb(a,b){var c=O?O:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=d.scriptResources.hasOwnProperty(a)?d.scriptResources[a]:void 0;null!==f&&(d.scriptResources[a]=null,b=r({src:a,async:!0},b),f&&(2===f.length&&Jb(b,f),a=e.preloads.scripts.get(a))&&(a.length=0),a=[],e.scripts.add(a),Nb(a,b),yc(c))}}}
-function kb(a,b){var c=O?O:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=d.moduleScriptResources.hasOwnProperty(a)?d.moduleScriptResources[a]:void 0;null!==f&&(d.moduleScriptResources[a]=null,b=r({src:a,type:"module",async:!0},b),f&&(2===f.length&&Jb(b,f),a=e.preloads.moduleScripts.get(a))&&(a.length=0),a=[],e.scripts.add(a),Nb(a,b),yc(c))}}}function Jb(a,b){null==a.crossOrigin&&(a.crossOrigin=b[0]);null==a.integrity&&(a.integrity=b[1])}
-function Sb(a,b,c){a=(""+a).replace(wc,xc);b=(""+b).replace(zc,Ac);b="<"+a+'>; rel=preload; as="'+b+'"';for(var d in c)w.call(c,d)&&(a=c[d],"string"===typeof a&&(b+="; "+d.toLowerCase()+'="'+(""+a).replace(zc,Ac)+'"'));return b}var wc=/[<>\r\n]/g;
-function xc(a){switch(a){case "<":return"%3C";case ">":return"%3E";case "\n":return"%0A";case "\r":return"%0D";default:throw Error("escapeLinkHrefForHeaderContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}}var zc=/["';,\r\n]/g;
-function Ac(a){switch(a){case '"':return"%22";case "'":return"%27";case ";":return"%3B";case ",":return"%2C";case "\n":return"%0A";case "\r":return"%0D";default:throw Error("escapeStringForLinkHeaderQuotedParamValueContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}}function Bc(a){this.styles.add(a)}function Cc(a){this.stylesheets.add(a)}
-function Dc(a,b,c){if(b=a.onHeaders){var d=a.headers;if(d){var e=d.preconnects;d.fontPreloads&&(e&&(e+=", "),e+=d.fontPreloads);d.highImagePreloads&&(e&&(e+=", "),e+=d.highImagePreloads);if(!c){c=a.styles.values();var f=c.next();a:for(;0<d.remainingCapacity&&!f.done;f=c.next()){f=f.value.sheets.values();for(var g=f.next();0<d.remainingCapacity&&!g.done;g=f.next()){var h=g.value;g=h.props;var k=g.href;h=h.props;h=Sb(h.href,"style",{crossOrigin:h.crossOrigin,integrity:h.integrity,nonce:h.nonce,type:h.type,
-fetchPriority:h.fetchPriority,referrerPolicy:h.referrerPolicy,media:h.media});if(2<=(d.remainingCapacity-=h.length))a.resets.style[k]=y,e&&(e+=", "),e+=h,a.resets.style[k]="string"===typeof g.crossOrigin||"string"===typeof g.integrity?[g.crossOrigin,g.integrity]:y;else break a}}}e?b({Link:e}):b({});a.headers=null}}}
-function Ec(a,b){var c=a.idPrefix;a=c+"P:";var d=c+"S:";c+="B:";var e=new Set,f=new Set,g=new Set,h=new Map,k=new Set,l=new Set,n=new Set,q={images:new Map,stylesheets:new Map,scripts:new Map,moduleScripts:new Map};return{placeholderPrefix:a,segmentPrefix:d,boundaryPrefix:c,startInlineScript:"<script>",htmlChunks:null,headChunks:null,externalRuntimeScript:null,bootstrapChunks:[],onHeaders:void 0,headers:null,resets:{font:{},dns:{},connect:{default:{},anonymous:{},credentials:{}},image:{},style:{}},
-charsetChunks:[],preconnectChunks:[],importMapChunks:[],preloadChunks:[],hoistableChunks:[],preconnects:e,fontPreloads:f,highImagePreloads:g,styles:h,bootstrapScripts:k,scripts:l,bulkPreloads:n,preloads:q,boundaryResources:null,stylesToHoist:!1,generateStaticMarkup:b}}function Fc(a,b,c,d){if(c.generateStaticMarkup)return a.push(x(b)),!1;""===b?a=d:(d&&a.push("\x3c!-- --\x3e"),a.push(x(b)),a=!0);return a}
-var Gc=Symbol.for("react.element"),Hc=Symbol.for("react.portal"),Ic=Symbol.for("react.fragment"),Jc=Symbol.for("react.strict_mode"),Kc=Symbol.for("react.profiler"),Lc=Symbol.for("react.provider"),Mc=Symbol.for("react.context"),Nc=Symbol.for("react.server_context"),Oc=Symbol.for("react.forward_ref"),Pc=Symbol.for("react.suspense"),Qc=Symbol.for("react.suspense_list"),Rc=Symbol.for("react.memo"),md=Symbol.for("react.lazy"),nd=Symbol.for("react.scope"),od=Symbol.for("react.debug_trace_mode"),pd=Symbol.for("react.offscreen"),
-qd=Symbol.for("react.legacy_hidden"),rd=Symbol.for("react.cache"),sd=Symbol.for("react.default_value"),td=Symbol.for("react.memo_cache_sentinel"),ud=Symbol.for("react.postpone"),vd=Symbol.iterator;
-function wd(a){if(null==a)return null;if("function"===typeof a)return a.displayName||a.name||null;if("string"===typeof a)return a;switch(a){case Ic:return"Fragment";case Hc:return"Portal";case Kc:return"Profiler";case Jc:return"StrictMode";case Pc:return"Suspense";case Qc:return"SuspenseList";case rd:return"Cache"}if("object"===typeof a)switch(a.$$typeof){case Mc:return(a.displayName||"Context")+".Consumer";case Lc:return(a._context.displayName||"Context")+".Provider";case Oc:var b=a.render;a=a.displayName;
-a||(a=b.displayName||b.name||"",a=""!==a?"ForwardRef("+a+")":"ForwardRef");return a;case Rc:return b=a.displayName||null,null!==b?b:wd(a.type)||"Memo";case md:b=a._payload;a=a._init;try{return wd(a(b))}catch(c){break}case Nc:return(a.displayName||a._globalName)+".Provider"}return null}var xd={};function yd(a,b){a=a.contextTypes;if(!a)return xd;var c={},d;for(d in a)c[d]=b[d];return c}var zd=null;
-function Ad(a,b){if(a!==b){a.context._currentValue2=a.parentValue;a=a.parent;var c=b.parent;if(null===a){if(null!==c)throw Error("The stacks must reach the root at the same time. This is a bug in React.");}else{if(null===c)throw Error("The stacks must reach the root at the same time. This is a bug in React.");Ad(a,c)}b.context._currentValue2=b.value}}function Bd(a){a.context._currentValue2=a.parentValue;a=a.parent;null!==a&&Bd(a)}
-function Cd(a){var b=a.parent;null!==b&&Cd(b);a.context._currentValue2=a.value}function Dd(a,b){a.context._currentValue2=a.parentValue;a=a.parent;if(null===a)throw Error("The depth must equal at least at zero before reaching the root. This is a bug in React.");a.depth===b.depth?Ad(a,b):Dd(a,b)}
-function Ed(a,b){var c=b.parent;if(null===c)throw Error("The depth must equal at least at zero before reaching the root. This is a bug in React.");a.depth===c.depth?Ad(a,c):Ed(a,c);b.context._currentValue2=b.value}function Fd(a){var b=zd;b!==a&&(null===b?Cd(a):null===a?Bd(b):b.depth===a.depth?Ad(b,a):b.depth>a.depth?Dd(b,a):Ed(b,a),zd=a)}
-var Gd={isMounted:function(){return!1},enqueueSetState:function(a,b){a=a._reactInternals;null!==a.queue&&a.queue.push(b)},enqueueReplaceState:function(a,b){a=a._reactInternals;a.replace=!0;a.queue=[b]},enqueueForceUpdate:function(){}};
-function Hd(a,b,c,d){var e=void 0!==a.state?a.state:null;a.updater=Gd;a.props=c;a.state=e;var f={queue:[],replace:!1};a._reactInternals=f;var g=b.contextType;a.context="object"===typeof g&&null!==g?g._currentValue2:d;g=b.getDerivedStateFromProps;"function"===typeof g&&(g=g(c,e),e=null===g||void 0===g?e:r({},e,g),a.state=e);if("function"!==typeof b.getDerivedStateFromProps&&"function"!==typeof a.getSnapshotBeforeUpdate&&("function"===typeof a.UNSAFE_componentWillMount||"function"===typeof a.componentWillMount))if(b=
-a.state,"function"===typeof a.componentWillMount&&a.componentWillMount(),"function"===typeof a.UNSAFE_componentWillMount&&a.UNSAFE_componentWillMount(),b!==a.state&&Gd.enqueueReplaceState(a,a.state,null),null!==f.queue&&0<f.queue.length)if(b=f.queue,g=f.replace,f.queue=null,f.replace=!1,g&&1===b.length)a.state=b[0];else{f=g?b[0]:a.state;e=!0;for(g=g?1:0;g<b.length;g++){var h=b[g];h="function"===typeof h?h.call(a,f,c,d):h;null!=h&&(e?(e=!1,f=r({},f,h)):r(f,h))}a.state=f}else f.queue=null}
-var Id={id:1,overflow:""};function Jd(a,b,c){var d=a.id;a=a.overflow;var e=32-Kd(d)-1;d&=~(1<<e);c+=1;var f=32-Kd(b)+e;if(30<f){var g=e-e%5;f=(d&(1<<g)-1).toString(32);d>>=g;e-=g;return{id:1<<32-Kd(b)+e|c<<e|d,overflow:f+a}}return{id:1<<f|c<<e|d,overflow:a}}var Kd=Math.clz32?Math.clz32:Ld,Md=Math.log,Nd=Math.LN2;function Ld(a){a>>>=0;return 0===a?32:31-(Md(a)/Nd|0)|0}var Od=Error("Suspense Exception: This is not a real error! It's an implementation detail of `use` to interrupt the current render. You must either rethrow it immediately, or move the `use` call outside of the `try/catch` block. Capturing without rethrowing will lead to unexpected behavior.\n\nTo handle async errors, wrap your component in an error boundary, or call the promise's `.catch` method and pass the result to `use`");
-function Pd(){}function Qd(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(Pd,Pd),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;default:if("string"!==typeof b.status)switch(a=b,a.status="pending",a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}}),b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;}Rd=b;throw Od;}}var Rd=null;
-function Sd(){if(null===Rd)throw Error("Expected a suspended thenable. This is a bug in React. Please file an issue.");var a=Rd;Rd=null;return a}function Td(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var Ud="function"===typeof Object.is?Object.is:Td,R=null,Vd=null,Wd=null,Xd=null,Yd=null,S=null,Zd=!1,$d=!1,ae=0,be=0,ce=-1,de=0,ee=null,fe=null,ge=0;
-function he(){if(null===R)throw Error("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.");return R}
-function ie(){if(0<ge)throw Error("Rendered more hooks than during the previous render");return{memoizedState:null,queue:null,next:null}}function je(){null===S?null===Yd?(Zd=!1,Yd=S=ie()):(Zd=!0,S=Yd):null===S.next?(Zd=!1,S=S.next=ie()):(Zd=!0,S=S.next);return S}function ke(a,b,c,d){for(;$d;)$d=!1,be=ae=0,ce=-1,de=0,ge+=1,S=null,c=a(b,d);le();return c}function me(){var a=ee;ee=null;return a}function le(){Xd=Wd=Vd=R=null;$d=!1;Yd=null;ge=0;S=fe=null}
-function ne(a,b){return"function"===typeof b?b(a):b}function oe(a,b,c){R=he();S=je();if(Zd){var d=S.queue;b=d.dispatch;if(null!==fe&&(c=fe.get(d),void 0!==c)){fe.delete(d);d=S.memoizedState;do d=a(d,c.action),c=c.next;while(null!==c);S.memoizedState=d;return[d,b]}return[S.memoizedState,b]}a=a===ne?"function"===typeof b?b():b:void 0!==c?c(b):b;S.memoizedState=a;a=S.queue={last:null,dispatch:null};a=a.dispatch=pe.bind(null,R,a);return[S.memoizedState,a]}
-function qe(a,b){R=he();S=je();b=void 0===b?null:b;if(null!==S){var c=S.memoizedState;if(null!==c&&null!==b){var d=c[1];a:if(null===d)d=!1;else{for(var e=0;e<d.length&&e<b.length;e++)if(!Ud(b[e],d[e])){d=!1;break a}d=!0}if(d)return c[0]}}a=a();S.memoizedState=[a,b];return a}
-function pe(a,b,c){if(25<=ge)throw Error("Too many re-renders. React limits the number of renders to prevent an infinite loop.");if(a===R)if($d=!0,a={action:c,next:null},null===fe&&(fe=new Map),c=fe.get(b),void 0===c)fe.set(b,a);else{for(b=c;null!==b.next;)b=b.next;b.next=a}}function re(){throw Error("A function wrapped in useEffectEvent can't be called during rendering.");}function se(){throw Error("startTransition cannot be called during server rendering.");}
-function te(){throw Error("Cannot update optimistic state while rendering.");}function ue(a){var b=de;de+=1;null===ee&&(ee=[]);return Qd(ee,a,b)}function ve(){throw Error("Cache cannot be refreshed during server rendering.");}function we(){}
-var ye={readContext:function(a){return a._currentValue2},use:function(a){if(null!==a&&"object"===typeof a){if("function"===typeof a.then)return ue(a);if(a.$$typeof===Mc||a.$$typeof===Nc)return a._currentValue2}throw Error("An unsupported type was passed to use(): "+String(a));},useContext:function(a){he();return a._currentValue2},useMemo:qe,useReducer:oe,useRef:function(a){R=he();S=je();var b=S.memoizedState;return null===b?(a={current:a},S.memoizedState=a):b},useState:function(a){return oe(ne,a)},
-useInsertionEffect:we,useLayoutEffect:we,useCallback:function(a,b){return qe(function(){return a},b)},useImperativeHandle:we,useEffect:we,useDebugValue:we,useDeferredValue:function(a,b){he();return void 0!==b?b:a},useTransition:function(){he();return[!1,se]},useId:function(){var a=Vd.treeContext;var b=a.overflow;a=a.id;a=(a&~(1<<32-Kd(a)-1)).toString(32)+b;var c=xe;if(null===c)throw Error("Invalid hook call. Hooks can only be called inside of the body of a function component.");b=ae++;a=":"+c.idPrefix+
-"R"+a;0<b&&(a+="H"+b.toString(32));return a+":"},useSyncExternalStore:function(a,b,c){if(void 0===c)throw Error("Missing getServerSnapshot, which is required for server-rendered content. Will revert to client rendering.");return c()},useCacheRefresh:function(){return ve},useEffectEvent:function(){return re},useMemoCache:function(a){for(var b=Array(a),c=0;c<a;c++)b[c]=td;return b},useHostTransitionStatus:function(){he();return Ma},useOptimistic:function(a){he();return[a,te]},useFormState:function(a,
-b,c){he();var d=be++,e=Wd;if("function"===typeof a.$$FORM_ACTION){var f=null,g=Xd;e=e.formState;var h=a.$$IS_SIGNATURE_EQUAL;if(null!==e&&"function"===typeof h){var k=e[1];h.call(a,e[2],e[3])&&(f=void 0!==c?"p"+c:"k"+ja(JSON.stringify([g,null,d]),0),k===f&&(ce=d,b=e[0]))}var l=a.bind(null,b);a=function(q){l(q)};"function"===typeof l.$$FORM_ACTION&&(a.$$FORM_ACTION=function(q){q=l.$$FORM_ACTION(q);void 0!==c&&(c+="",q.action=c);var m=q.data;m&&(null===f&&(f=void 0!==c?"p"+c:"k"+ja(JSON.stringify([g,
-null,d]),0)),m.append("$ACTION_KEY",f));return q});return[b,a]}var n=a.bind(null,b);return[b,function(q){n(q)}]}},xe=null,ze={getCacheSignal:function(){throw Error("Not implemented.");},getCacheForType:function(){throw Error("Not implemented.");}},Ae=La.ReactCurrentDispatcher,Be=La.ReactCurrentCache;function De(a){console.error(a);return null}function Ee(){}
-function Fe(a,b,c,d,e,f,g,h,k,l,n,q){Na.current=lb;var m=[],B=new Set;b={destination:null,flushScheduled:!1,resumableState:b,renderState:c,rootFormatContext:d,progressiveChunkSize:void 0===e?12800:e,status:0,fatalError:null,nextSegmentId:0,allPendingTasks:0,pendingRootTasks:0,completedRootSegment:null,abortableTasks:B,pingedTasks:m,clientRenderedBoundaries:[],completedBoundaries:[],partialBoundaries:[],trackedPostpones:null,onError:void 0===f?De:f,onPostpone:void 0===n?Ee:n,onAllReady:void 0===g?
-Ee:g,onShellReady:void 0===h?Ee:h,onShellError:void 0===k?Ee:k,onFatalError:void 0===l?Ee:l,formState:void 0===q?null:q};c=Ge(b,0,null,d,!1,!1);c.parentFlushed=!0;a=He(b,null,a,-1,null,c,B,null,d,xd,null,Id);m.push(a);return b}var O=null;function Ie(a,b){a.pingedTasks.push(b);1===a.pingedTasks.length&&(a.flushScheduled=null!==a.destination,Je(a))}
-function Ke(a,b){return{status:0,rootSegmentID:-1,parentFlushed:!1,pendingTasks:0,completedSegments:[],byteSize:0,fallbackAbortableTasks:b,errorDigest:null,resources:{styles:new Set,stylesheets:new Set},trackedContentKeyPath:null,trackedFallbackNode:null}}
-function He(a,b,c,d,e,f,g,h,k,l,n,q){a.allPendingTasks++;null===e?a.pendingRootTasks++:e.pendingTasks++;var m={replay:null,node:c,childIndex:d,ping:function(){return Ie(a,m)},blockedBoundary:e,blockedSegment:f,abortSet:g,keyPath:h,formatContext:k,legacyContext:l,context:n,treeContext:q,thenableState:b};g.add(m);return m}
-function Le(a,b,c,d,e,f,g,h,k,l,n,q){a.allPendingTasks++;null===f?a.pendingRootTasks++:f.pendingTasks++;c.pendingTasks++;var m={replay:c,node:d,childIndex:e,ping:function(){return Ie(a,m)},blockedBoundary:f,blockedSegment:null,abortSet:g,keyPath:h,formatContext:k,legacyContext:l,context:n,treeContext:q,thenableState:b};g.add(m);return m}function Ge(a,b,c,d,e,f){return{status:0,id:-1,index:b,parentFlushed:!1,chunks:[],children:[],parentFormatContext:d,boundary:c,lastPushedText:e,textEmbedded:f}}
-function W(a,b){a=a.onError(b);if(null!=a&&"string"!==typeof a)throw Error('onError returned something with a type other than "string". onError should return a string and may return null or undefined but must not return anything else. It received something of type "'+typeof a+'" instead');return a}function Me(a,b){var c=a.onShellError;c(b);c=a.onFatalError;c(b);null!==a.destination?(a.status=2,a.destination.destroy(b)):(a.status=1,a.fatalError=b)}
-function Ne(a,b,c,d,e){var f=d.render(),g=e.childContextTypes;if(null!==g&&void 0!==g){c=b.legacyContext;if("function"!==typeof d.getChildContext)e=c;else{d=d.getChildContext();for(var h in d)if(!(h in g))throw Error((wd(e)||"Unknown")+'.getChildContext(): key "'+h+'" is not defined in childContextTypes.');e=r({},c,d)}b.legacyContext=e;X(a,b,null,f,-1);b.legacyContext=c}else e=b.keyPath,b.keyPath=c,X(a,b,null,f,-1),b.keyPath=e}
-function Oe(a,b,c,d,e,f,g){var h=!1;if(0!==f&&null!==a.formState){var k=b.blockedSegment;if(null!==k){h=!0;k=k.chunks;for(var l=0;l<f;l++)l===g?k.push("\x3c!--F!--\x3e"):k.push("\x3c!--F--\x3e")}}f=b.keyPath;b.keyPath=c;e?(c=b.treeContext,b.treeContext=Jd(c,1,0),Y(a,b,d,-1),b.treeContext=c):h?Y(a,b,d,-1):X(a,b,null,d,-1);b.keyPath=f}function Pe(a,b){if(a&&a.defaultProps){b=r({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}
-function Qe(a,b,c,d,e,f,g){if("function"===typeof e)if(e.prototype&&e.prototype.isReactComponent){d=yd(e,b.legacyContext);var h=e.contextType;h=new e(f,"object"===typeof h&&null!==h?h._currentValue2:d);Hd(h,e,f,d);Ne(a,b,c,h,e)}else{h=yd(e,b.legacyContext);R={};Vd=b;Wd=a;Xd=c;be=ae=0;ce=-1;de=0;ee=d;d=e(f,h);d=ke(e,f,d,h);g=0!==ae;var k=be,l=ce;"object"===typeof d&&null!==d&&"function"===typeof d.render&&void 0===d.$$typeof?(Hd(d,e,f,h),Ne(a,b,c,d,e)):Oe(a,b,c,d,g,k,l)}else if("string"===typeof e)if(d=
-b.blockedSegment,null===d)d=f.children,h=b.formatContext,g=b.keyPath,b.formatContext=ob(h,e,f),b.keyPath=c,Y(a,b,d,-1),b.formatContext=h,b.keyPath=g;else{g=Rb(d.chunks,e,f,a.resumableState,a.renderState,b.formatContext,d.lastPushedText);d.lastPushedText=!1;h=b.formatContext;k=b.keyPath;b.formatContext=ob(h,e,f);b.keyPath=c;Y(a,b,g,-1);b.formatContext=h;b.keyPath=k;a:{b=d.chunks;a=a.resumableState;switch(e){case "title":case "style":case "script":case "area":case "base":case "br":case "col":case "embed":case "hr":case "img":case "input":case "keygen":case "link":case "meta":case "param":case "source":case "track":case "wbr":break a;
-case "body":if(1>=h.insertionMode){a.hasBody=!0;break a}break;case "html":if(0===h.insertionMode){a.hasHtml=!0;break a}}b.push(Mb(e))}d.lastPushedText=!1}else{switch(e){case qd:case od:case Jc:case Kc:case Ic:e=b.keyPath;b.keyPath=c;X(a,b,null,f.children,-1);b.keyPath=e;return;case pd:"hidden"!==f.mode&&(e=b.keyPath,b.keyPath=c,X(a,b,null,f.children,-1),b.keyPath=e);return;case Qc:e=b.keyPath;b.keyPath=c;X(a,b,null,f.children,-1);b.keyPath=e;return;case nd:throw Error("ReactDOMServer does not yet support scope components.");
-case Pc:a:if(null!==b.replay){e=b.keyPath;b.keyPath=c;c=f.children;try{Y(a,b,c,-1)}finally{b.keyPath=e}}else{l=b.keyPath;e=b.blockedBoundary;var n=b.blockedSegment;d=f.fallback;var q=f.children;f=new Set;g=Ke(a,f);null!==a.trackedPostpones&&(g.trackedContentKeyPath=c);k=Ge(a,n.chunks.length,g,b.formatContext,!1,!1);n.children.push(k);n.lastPushedText=!1;var m=Ge(a,0,null,b.formatContext,!1,!1);m.parentFlushed=!0;b.blockedBoundary=g;b.blockedSegment=m;a.renderState.boundaryResources=g.resources;b.keyPath=
-c;try{if(Y(a,b,q,-1),a.renderState.generateStaticMarkup||m.lastPushedText&&m.textEmbedded&&m.chunks.push("\x3c!-- --\x3e"),m.status=1,Re(g,m),0===g.pendingTasks&&0===g.status){g.status=1;break a}}catch(B){m.status=4,g.status=4,"object"===typeof B&&null!==B&&B.$$typeof===ud?(a.onPostpone(B.message),h="POSTPONE"):h=W(a,B),g.errorDigest=h}finally{a.renderState.boundaryResources=e?e.resources:null,b.blockedBoundary=e,b.blockedSegment=n,b.keyPath=l}h=[c[0],"Suspense Fallback",c[2]];l=a.trackedPostpones;
-null!==l&&(n=[h[1],h[2],[],null],l.workingMap.set(h,n),5===g.status?l.workingMap.get(c)[4]=n:g.trackedFallbackNode=n);b=He(a,null,d,-1,e,k,f,h,b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}return}if("object"===typeof e&&null!==e)switch(e.$$typeof){case Oc:e=e.render;R={};Vd=b;Wd=a;Xd=c;be=ae=0;ce=-1;de=0;ee=d;d=e(f,g);f=ke(e,f,d,g);Oe(a,b,c,f,0!==ae,be,ce);return;case Rc:e=e.type;f=Pe(e,f);Qe(a,b,c,d,e,f,g);return;case Lc:h=f.children;d=b.keyPath;e=e._context;f=f.value;
-g=e._currentValue2;e._currentValue2=f;k=zd;zd=f={parent:k,depth:null===k?0:k.depth+1,context:e,parentValue:g,value:f};b.context=f;b.keyPath=c;X(a,b,null,h,-1);a=zd;if(null===a)throw Error("Tried to pop a Context at the root of the app. This is a bug in React.");c=a.parentValue;a.context._currentValue2=c===sd?a.context._defaultValue:c;a=zd=a.parent;b.context=a;b.keyPath=d;return;case Mc:f=f.children;f=f(e._currentValue2);e=b.keyPath;b.keyPath=c;X(a,b,null,f,-1);b.keyPath=e;return;case md:h=e._init;
-e=h(e._payload);f=Pe(e,f);Qe(a,b,c,d,e,f,void 0);return}throw Error("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: "+((null==e?e:typeof e)+"."));}}
-function Se(a,b,c,d,e){var f=b.replay,g=b.blockedBoundary,h=Ge(a,0,null,b.formatContext,!1,!1);h.id=c;h.parentFlushed=!0;try{b.replay=null,b.blockedSegment=h,Y(a,b,d,e),h.status=1,null===g?a.completedRootSegment=h:(Re(g,h),g.parentFlushed&&a.partialBoundaries.push(g))}finally{b.replay=f,b.blockedSegment=null}}
-function X(a,b,c,d,e){if(null!==b.replay&&"number"===typeof b.replay.slots)Se(a,b,b.replay.slots,d,e);else{b.node=d;b.childIndex=e;if("object"===typeof d&&null!==d){switch(d.$$typeof){case Gc:var f=d.type,g=d.key,h=d.props,k=d.ref,l=wd(f),n=null==g?-1===e?0:e:g;g=[b.keyPath,l,n];if(null!==b.replay)a:{var q=b.replay;e=q.nodes;for(d=0;d<e.length;d++){var m=e[d];if(n===m[1]){if(4===m.length){if(null!==l&&l!==m[0])throw Error("Expected the resume to render <"+m[0]+"> in this slot but instead it rendered <"+
-l+">. The tree doesn't match so React will fallback to client rendering.");l=m[2];m=m[3];n=b.node;b.replay={nodes:l,slots:m,pendingTasks:1};try{Qe(a,b,g,c,f,h,k);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--}catch(p){if("object"===typeof p&&null!==p&&(p===Od||"function"===typeof p.then))throw b.node===n&&(b.replay=q),p;b.replay.pendingTasks--;
-Te(a,b.blockedBoundary,p,l,m)}b.replay=q}else{if(f!==Pc)throw Error("Expected the resume to render <Suspense> in this slot but instead it rendered <"+(wd(f)||"Unknown")+">. The tree doesn't match so React will fallback to client rendering.");b:{c=void 0;f=m[5];k=m[2];q=m[3];l=null===m[4]?[]:m[4][2];m=null===m[4]?null:m[4][3];n=b.keyPath;var B=b.replay,C=b.blockedBoundary,P=h.children;h=h.fallback;var u=new Set,z=Ke(a,u);z.parentFlushed=!0;z.rootSegmentID=f;b.blockedBoundary=z;b.replay={nodes:k,slots:q,
-pendingTasks:1};a.renderState.boundaryResources=z.resources;try{Y(a,b,P,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--;if(0===z.pendingTasks&&0===z.status){z.status=1;a.completedBoundaries.push(z);break b}}catch(p){z.status=4,"object"===typeof p&&null!==p&&p.$$typeof===ud?(a.onPostpone(p.message),c="POSTPONE"):c=W(a,p),
-z.errorDigest=c,b.replay.pendingTasks--,a.clientRenderedBoundaries.push(z)}finally{a.renderState.boundaryResources=C?C.resources:null,b.blockedBoundary=C,b.replay=B,b.keyPath=n}h=Le(a,null,{nodes:l,slots:m,pendingTasks:0},h,-1,C,u,[g[0],"Suspense Fallback",g[2]],b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(h)}}e.splice(d,1);break a}}}else Qe(a,b,g,c,f,h,k);return;case Hc:throw Error("Portals are not currently supported by the server renderer. Render them conditionally so that they only appear on the client render.");
-case md:h=d._init;d=h(d._payload);X(a,b,null,d,e);return}if(Ka(d)){Ue(a,b,d,e);return}null===d||"object"!==typeof d?h=null:(h=vd&&d[vd]||d["@@iterator"],h="function"===typeof h?h:null);if(h&&(h=h.call(d))){d=h.next();if(!d.done){g=[];do g.push(d.value),d=h.next();while(!d.done);Ue(a,b,g,e)}return}if("function"===typeof d.then)return X(a,b,null,ue(d),e);if(d.$$typeof===Mc||d.$$typeof===Nc)return X(a,b,null,d._currentValue2,e);e=Object.prototype.toString.call(d);throw Error("Objects are not valid as a React child (found: "+
-("[object Object]"===e?"object with keys {"+Object.keys(d).join(", ")+"}":e)+"). If you meant to render a collection of children, use an array instead.");}"string"===typeof d?(e=b.blockedSegment,null!==e&&(e.lastPushedText=Fc(e.chunks,d,a.renderState,e.lastPushedText))):"number"===typeof d&&(e=b.blockedSegment,null!==e&&(e.lastPushedText=Fc(e.chunks,""+d,a.renderState,e.lastPushedText)))}}
-function Ue(a,b,c,d){var e=b.keyPath;if(-1!==d&&(b.keyPath=[b.keyPath,"Fragment",d],null!==b.replay)){for(var f=b.replay,g=f.nodes,h=0;h<g.length;h++){var k=g[h];if(k[1]===d){d=k[2];k=k[3];b.replay={nodes:d,slots:k,pendingTasks:1};try{Ue(a,b,c,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--}catch(n){if("object"===typeof n&&
-null!==n&&(n===Od||"function"===typeof n.then))throw n;b.replay.pendingTasks--;Te(a,b.blockedBoundary,n,d,k)}b.replay=f;g.splice(h,1);break}}b.keyPath=e;return}f=b.treeContext;g=c.length;if(null!==b.replay&&(h=b.replay.slots,null!==h&&"object"===typeof h)){for(k=0;k<g;k++){d=c[k];b.treeContext=Jd(f,g,k);var l=h[k];"number"===typeof l?(Se(a,b,l,d,k),delete h[k]):Y(a,b,d,k)}b.treeContext=f;b.keyPath=e;return}for(h=0;h<g;h++)k=c[h],b.treeContext=Jd(f,g,h),Y(a,b,k,h);b.treeContext=f;b.keyPath=e}
-function Ve(a,b,c,d){d.status=5;var e=c.keyPath,f=c.blockedBoundary;if(null===f)d.id=a.nextSegmentId++,b.rootSlots=d.id,null!==a.completedRootSegment&&(a.completedRootSegment.status=5);else{if(null!==f&&0===f.status){f.status=5;f.rootSegmentID=a.nextSegmentId++;var g=f.trackedContentKeyPath;if(null===g)throw Error("It should not be possible to postpone at the root. This is a bug in React.");var h=f.trackedFallbackNode,k=[];if(g===e&&-1===c.childIndex){d.id=f.rootSegmentID;d=[g[1],g[2],k,f.rootSegmentID,
-h,f.rootSegmentID];b.workingMap.set(g,d);We(d,g[0],b);return}var l=b.workingMap.get(g);void 0===l?(l=[g[1],g[2],k,null,h,f.rootSegmentID],b.workingMap.set(g,l),We(l,g[0],b)):(g=l,g[4]=h,g[5]=f.rootSegmentID)}-1===d.id&&(d.id=d.parentFlushed&&null!==f?f.rootSegmentID:a.nextSegmentId++);if(-1===c.childIndex)null===e?b.rootSlots=d.id:(c=b.workingMap.get(e),void 0===c?(c=[e[1],e[2],[],d.id],We(c,e[0],b)):c[3]=d.id);else{if(null===e)if(a=b.rootSlots,null===a)a=b.rootSlots={};else{if("number"===typeof a)throw Error("It should not be possible to postpone both at the root of an element as well as a slot below. This is a bug in React.");
-}else if(f=b.workingMap,g=f.get(e),void 0===g)a={},g=[e[1],e[2],[],a],f.set(e,g),We(g,e[0],b);else if(a=g[3],null===a)a=g[3]={};else if("number"===typeof a)throw Error("It should not be possible to postpone both at the root of an element as well as a slot below. This is a bug in React.");a[c.childIndex]=d.id}}}
-function Y(a,b,c,d){var e=b.formatContext,f=b.legacyContext,g=b.context,h=b.keyPath,k=b.treeContext,l=b.blockedSegment;if(null===l)try{return X(a,b,null,c,d)}catch(m){if(le(),d=m===Od?Sd():m,"object"===typeof d&&null!==d&&"function"===typeof d.then){c=d;d=me();a=Le(a,d,b.replay,b.node,b.childIndex,b.blockedBoundary,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Fd(g);return}}else{var n=
-l.children.length,q=l.chunks.length;try{return X(a,b,null,c,d)}catch(m){if(le(),l.children.length=n,l.chunks.length=q,d=m===Od?Sd():m,"object"===typeof d&&null!==d){if("function"===typeof d.then){c=d;d=me();l=b.blockedSegment;n=Ge(a,l.chunks.length,null,b.formatContext,l.lastPushedText,!0);l.children.push(n);l.lastPushedText=!1;a=He(a,d,b.node,b.childIndex,b.blockedBoundary,n,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=
-f;b.context=g;b.keyPath=h;b.treeContext=k;Fd(g);return}if(null!==a.trackedPostpones&&d.$$typeof===ud&&null!==b.blockedBoundary){c=a.trackedPostpones;a.onPostpone(d.message);d=b.blockedSegment;l=Ge(a,d.chunks.length,null,b.formatContext,d.lastPushedText,!0);d.children.push(l);d.lastPushedText=!1;Ve(a,c,b,l);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Fd(g);return}}}}b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Fd(g);throw d;}
-function Te(a,b,c,d,e){if("object"===typeof c&&null!==c&&c.$$typeof===ud){a.onPostpone(c.message);var f="POSTPONE"}else f=W(a,c);Xe(a,b,d,e,c,f)}function Ye(a){var b=a.blockedBoundary;a=a.blockedSegment;null!==a&&(a.status=3,Ze(this,b,a))}
-function Xe(a,b,c,d,e,f){for(var g=0;g<c.length;g++){var h=c[g];if(4===h.length)Xe(a,b,h[2],h[3],e,f);else{h=h[5];var k=a,l=f,n=Ke(k,new Set);n.parentFlushed=!0;n.rootSegmentID=h;n.status=4;n.errorDigest=l;n.parentFlushed&&k.clientRenderedBoundaries.push(n)}}c.length=0;if(null!==d){if(null===b)throw Error("We should not have any resumable nodes in the shell. This is a bug in React.");4!==b.status&&(b.status=4,b.errorDigest=f,b.parentFlushed&&a.clientRenderedBoundaries.push(b));if("object"===typeof d)for(var q in d)delete d[q]}}
-function $e(a,b,c){var d=a.blockedBoundary,e=a.blockedSegment;null!==e&&(e.status=3);if(null===d){if(1!==b.status&&2!==b.status){a=a.replay;if(null===a){W(b,c);Me(b,c);return}a.pendingTasks--;0===a.pendingTasks&&0<a.nodes.length&&(d=W(b,c),Xe(b,null,a.nodes,a.slots,c,d));b.pendingRootTasks--;0===b.pendingRootTasks&&af(b)}}else d.pendingTasks--,4!==d.status&&(d.status=4,d.errorDigest=W(b,c),d.parentFlushed&&b.clientRenderedBoundaries.push(d)),d.fallbackAbortableTasks.forEach(function(f){return $e(f,
-b,c)}),d.fallbackAbortableTasks.clear();b.allPendingTasks--;0===b.allPendingTasks&&bf(b)}function af(a){null===a.trackedPostpones&&Dc(a.renderState,a.resumableState,!0);a.onShellError=Ee;a=a.onShellReady;a()}function bf(a){Dc(a.renderState,a.resumableState,null===a.trackedPostpones?!0:null===a.completedRootSegment||5!==a.completedRootSegment.status);a=a.onAllReady;a()}
-function Re(a,b){if(0===b.chunks.length&&1===b.children.length&&null===b.children[0].boundary){var c=b.children[0];c.id=b.id;c.parentFlushed=!0;1===c.status&&Re(a,c)}else a.completedSegments.push(b)}
-function Ze(a,b,c){if(null===b){if(null!==c&&c.parentFlushed){if(null!==a.completedRootSegment)throw Error("There can only be one root segment. This is a bug in React.");a.completedRootSegment=c}a.pendingRootTasks--;0===a.pendingRootTasks&&af(a)}else b.pendingTasks--,4!==b.status&&(0===b.pendingTasks?(0===b.status&&(b.status=1),null!==c&&c.parentFlushed&&1===c.status&&Re(b,c),b.parentFlushed&&a.completedBoundaries.push(b),1===b.status&&(b.fallbackAbortableTasks.forEach(Ye,a),b.fallbackAbortableTasks.clear())):
-null!==c&&c.parentFlushed&&1===c.status&&(Re(b,c),1===b.completedSegments.length&&b.parentFlushed&&a.partialBoundaries.push(b)));a.allPendingTasks--;0===a.allPendingTasks&&bf(a)}
-function Je(a){if(2!==a.status){var b=zd,c=Ae.current;Ae.current=ye;var d=Be.current;Be.current=ze;var e=O;O=a;var f=xe;xe=a.resumableState;try{var g=a.pingedTasks,h;for(h=0;h<g.length;h++){var k=g[h],l=a,n=k.blockedBoundary;l.renderState.boundaryResources=n?n.resources:null;var q=k.blockedSegment;if(null===q){var m=l;if(0!==k.replay.pendingTasks){Fd(k.context);try{var B=k.thenableState;k.thenableState=null;X(m,k,B,k.node,k.childIndex);if(1===k.replay.pendingTasks&&0<k.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");
-k.replay.pendingTasks--;k.abortSet.delete(k);Ze(m,k.blockedBoundary,null)}catch(v){le();var C=v===Od?Sd():v;if("object"===typeof C&&null!==C&&"function"===typeof C.then){var P=k.ping;C.then(P,P);k.thenableState=me()}else k.replay.pendingTasks--,k.abortSet.delete(k),Te(m,k.blockedBoundary,C,k.replay.nodes,k.replay.slots),m.pendingRootTasks--,0===m.pendingRootTasks&&af(m),m.allPendingTasks--,0===m.allPendingTasks&&bf(m)}finally{m.renderState.boundaryResources=null}}}else a:{m=void 0;var u=q;if(0===
-u.status){Fd(k.context);var z=u.children.length,p=u.chunks.length;try{var Z=k.thenableState;k.thenableState=null;X(l,k,Z,k.node,k.childIndex);l.renderState.generateStaticMarkup||u.lastPushedText&&u.textEmbedded&&u.chunks.push("\x3c!-- --\x3e");k.abortSet.delete(k);u.status=1;Ze(l,k.blockedBoundary,u)}catch(v){le();u.children.length=z;u.chunks.length=p;var t=v===Od?Sd():v;if("object"===typeof t&&null!==t){if("function"===typeof t.then){var T=k.ping;t.then(T,T);k.thenableState=me();break a}if(null!==
-l.trackedPostpones&&t.$$typeof===ud){var D=l.trackedPostpones;k.abortSet.delete(k);l.onPostpone(t.message);Ve(l,D,k,u);Ze(l,k.blockedBoundary,u);break a}}k.abortSet.delete(k);u.status=4;var A=k.blockedBoundary;"object"===typeof t&&null!==t&&t.$$typeof===ud?(l.onPostpone(t.message),m="POSTPONE"):m=W(l,t);null===A?Me(l,t):(A.pendingTasks--,4!==A.status&&(A.status=4,A.errorDigest=m,A.parentFlushed&&l.clientRenderedBoundaries.push(A)));l.allPendingTasks--;0===l.allPendingTasks&&bf(l)}finally{l.renderState.boundaryResources=
-null}}}}g.splice(0,h);null!==a.destination&&cf(a,a.destination)}catch(v){W(a,v),Me(a,v)}finally{xe=f,Ae.current=c,Be.current=d,c===ye&&Fd(b),O=e}}}
-function df(a,b,c){c.parentFlushed=!0;switch(c.status){case 0:c.id=a.nextSegmentId++;case 5:var d=c.id;c.lastPushedText=!1;c.textEmbedded=!1;a=a.renderState;b.push('<template id="');b.push(a.placeholderPrefix);a=d.toString(16);b.push(a);return b.push('"></template>');case 1:c.status=2;var e=!0;d=c.chunks;var f=0;c=c.children;for(var g=0;g<c.length;g++){for(e=c[g];f<e.index;f++)b.push(d[f]);e=ef(a,b,e)}for(;f<d.length-1;f++)b.push(d[f]);f<d.length&&(e=b.push(d[f]));return e;default:throw Error("Aborted, errored or already flushed boundaries should not be flushed again. This is a bug in React.");
+function hc(a,b){switch(b.insertionMode){case 0:case 1:case 2:return a.push("</div>");case 3:return a.push("</svg>");case 4:return a.push("</math>");case 5:return a.push("</table>");case 6:return a.push("</tbody></table>");case 7:return a.push("</tr></table>");case 8:return a.push("</colgroup></table>");default:throw Error("Unknown insertion mode. This is a bug in React.");}}var ic=/[<\u2028\u2029]/g;
+function jc(a){return JSON.stringify(a).replace(ic,function(b){switch(b){case "<":return"\\u003c";case "\u2028":return"\\u2028";case "\u2029":return"\\u2029";default:throw Error("escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}})}var kc=/[&><\u2028\u2029]/g;
+function lc(a){return JSON.stringify(a).replace(kc,function(b){switch(b){case "&":return"\\u0026";case ">":return"\\u003e";case "<":return"\\u003c";case "\u2028":return"\\u2028";case "\u2029":return"\\u2029";default:throw Error("escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}})}var mc=!1,nc=!0;
+function oc(a){var b=a.rules,c=a.hrefs,d=0;if(c.length){this.push('<style media="not all" data-precedence="');this.push(a.precedence);for(this.push('" data-href="');d<c.length-1;d++)this.push(c[d]),this.push(" ");this.push(c[d]);this.push('">');for(d=0;d<b.length;d++)this.push(b[d]);nc=this.push("</style>");mc=!0;b.length=0;c.length=0}}function pc(a){return 2!==a.state?mc=!0:!1}function qc(a,b,c){mc=!1;nc=!0;b.styles.forEach(oc,a);b.stylesheets.forEach(pc);mc&&(c.stylesToHoist=!0);return nc}
+function O(a){for(var b=0;b<a.length;b++)this.push(a[b]);a.length=0}var rc=[];function sc(a){M(rc,a.props);for(var b=0;b<rc.length;b++)this.push(rc[b]);rc.length=0;a.state=2}
+function tc(a){var b=0<a.sheets.size;a.sheets.forEach(sc,this);a.sheets.clear();var c=a.rules,d=a.hrefs;if(!b||d.length){this.push('<style data-precedence="');this.push(a.precedence);a=0;if(d.length){for(this.push('" data-href="');a<d.length-1;a++)this.push(d[a]),this.push(" ");this.push(d[a])}this.push('">');for(a=0;a<c.length;a++)this.push(c[a]);this.push("</style>");c.length=0;d.length=0}}
+function uc(a){if(0===a.state){a.state=1;var b=a.props;M(rc,{rel:"preload",as:"style",href:a.props.href,crossOrigin:b.crossOrigin,fetchPriority:b.fetchPriority,integrity:b.integrity,media:b.media,hrefLang:b.hrefLang,referrerPolicy:b.referrerPolicy});for(a=0;a<rc.length;a++)this.push(rc[a]);rc.length=0}}function vc(a){a.sheets.forEach(uc,this);a.sheets.clear()}
+function wc(a,b){a.push("[");var c="[";b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)a.push(c),d=lc(""+d.props.href),a.push(d),a.push("]"),c=",[";else{a.push(c);var e=d.props["data-precedence"],f=d.props,g=lc(""+d.props.href);a.push(g);e=""+e;a.push(",");e=lc(e);a.push(e);for(var h in f)if(y.call(f,h)&&(g=f[h],null!=g))switch(h){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");
+default:a:{e=a;var k=h.toLowerCase();switch(typeof g){case "function":case "symbol":break a}switch(h){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":k="class";g=""+g;break;case "hidden":if(!1===g)break a;g="";break;case "src":case "href":g=""+g;break;default:if(2<h.length&&("o"===h[0]||"O"===h[0])&&("n"===h[1]||"N"===h[1])||!ya(h))break a;g=""+g}e.push(",");k=lc(k);e.push(k);e.push(",");g=
+lc(g);e.push(g)}}a.push("]");c=",[";d.state=3}});a.push("]")}
+function xc(a,b){a.push("[");var c="[";b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)a.push(c),d=z(JSON.stringify(""+d.props.href)),a.push(d),a.push("]"),c=",[";else{a.push(c);var e=d.props["data-precedence"],f=d.props,g=z(JSON.stringify(""+d.props.href));a.push(g);e=""+e;a.push(",");e=z(JSON.stringify(e));a.push(e);for(var h in f)if(y.call(f,h)&&(g=f[h],null!=g))switch(h){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");
+default:a:{e=a;var k=h.toLowerCase();switch(typeof g){case "function":case "symbol":break a}switch(h){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":k="class";g=""+g;break;case "hidden":if(!1===g)break a;g="";break;case "src":case "href":g=""+g;break;default:if(2<h.length&&("o"===h[0]||"O"===h[0])&&("n"===h[1]||"N"===h[1])||!ya(h))break a;g=""+g}e.push(",");k=z(JSON.stringify(k));e.push(k);
+e.push(",");g=z(JSON.stringify(g));e.push(g)}}a.push("]");c=",[";d.state=3}});a.push("]")}
+function Oa(a){var b=R?R:null;if(b){var c=b.resumableState,d=b.renderState;if("string"===typeof a&&a){if(!c.dnsResources.hasOwnProperty(a)){c.dnsResources[a]=null;c=d.headers;var e,f;if(f=c&&0<c.remainingCapacity)f=(e="<"+(""+a).replace(yc,zc)+">; rel=dns-prefetch",2<=(c.remainingCapacity-=e.length));f?(d.resets.dns[a]=null,c.preconnects&&(c.preconnects+=", "),c.preconnects+=e):(e=[],M(e,{href:a,rel:"dns-prefetch"}),d.preconnects.add(e))}Ac(b)}}}
+function fb(a,b){var c=R?R:null;if(c){var d=c.resumableState,e=c.renderState;if("string"===typeof a&&a){var f="use-credentials"===b?"credentials":"string"===typeof b?"anonymous":"default";if(!d.connectResources[f].hasOwnProperty(a)){d.connectResources[f][a]=null;d=e.headers;var g,h;if(h=d&&0<d.remainingCapacity){h="<"+(""+a).replace(yc,zc)+">; rel=preconnect";if("string"===typeof b){var k=(""+b).replace(Bc,Cc);h+='; crossorigin="'+k+'"'}h=(g=h,2<=(d.remainingCapacity-=g.length))}h?(e.resets.connect[f][a]=
+null,d.preconnects&&(d.preconnects+=", "),d.preconnects+=g):(f=[],M(f,{rel:"preconnect",href:a,crossOrigin:b}),e.preconnects.add(f))}Ac(c)}}}
+function gb(a,b,c){var d=R?R:null;if(d){var e=d.resumableState,f=d.renderState;if(b&&a){switch(b){case "image":if(c){var g=c.imageSrcSet;var h=c.imageSizes;var k=c.fetchPriority}var l=g?g+"\n"+(h||""):a;if(e.imageResources.hasOwnProperty(l))return;e.imageResources[l]=A;e=f.headers;var n;e&&0<e.remainingCapacity&&"high"===k&&(n=Ub(a,b,c),2<=(e.remainingCapacity-=n.length))?(f.resets.image[l]=A,e.highImagePreloads&&(e.highImagePreloads+=", "),e.highImagePreloads+=n):(e=[],M(e,q({rel:"preload",href:g?
+void 0:a,as:b},c)),"high"===k?f.highImagePreloads.add(e):(f.bulkPreloads.add(e),f.preloads.images.set(l,e)));break;case "style":if(e.styleResources.hasOwnProperty(a))return;g=[];M(g,q({rel:"preload",href:a,as:b},c));e.styleResources[a]=!c||"string"!==typeof c.crossOrigin&&"string"!==typeof c.integrity?A:[c.crossOrigin,c.integrity];f.preloads.stylesheets.set(a,g);f.bulkPreloads.add(g);break;case "script":if(e.scriptResources.hasOwnProperty(a))return;g=[];f.preloads.scripts.set(a,g);f.bulkPreloads.add(g);
+M(g,q({rel:"preload",href:a,as:b},c));e.scriptResources[a]=!c||"string"!==typeof c.crossOrigin&&"string"!==typeof c.integrity?A:[c.crossOrigin,c.integrity];break;default:if(e.unknownResources.hasOwnProperty(b)){if(g=e.unknownResources[b],g.hasOwnProperty(a))return}else g={},e.unknownResources[b]=g;g[a]=A;if((e=f.headers)&&0<e.remainingCapacity&&"font"===b&&(l=Ub(a,b,c),2<=(e.remainingCapacity-=l.length)))f.resets.font[a]=A,e.fontPreloads&&(e.fontPreloads+=", "),e.fontPreloads+=l;else switch(e=[],
+a=q({rel:"preload",href:a,as:b},c),M(e,a),b){case "font":f.fontPreloads.add(e);break;default:f.bulkPreloads.add(e)}}Ac(d)}}}
+function hb(a,b){var c=R?R:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=b&&"string"===typeof b.as?b.as:"script";switch(f){case "script":if(d.moduleScriptResources.hasOwnProperty(a))return;f=[];d.moduleScriptResources[a]=!b||"string"!==typeof b.crossOrigin&&"string"!==typeof b.integrity?A:[b.crossOrigin,b.integrity];e.preloads.moduleScripts.set(a,f);break;default:if(d.moduleUnknownResources.hasOwnProperty(f)){var g=d.unknownResources[f];if(g.hasOwnProperty(a))return}else g={},d.moduleUnknownResources[f]=
+g;f=[];g[a]=A}M(f,q({rel:"modulepreload",href:a},b));e.bulkPreloads.add(f);Ac(c)}}}
+function ib(a,b,c){var d=R?R:null;if(d){var e=d.resumableState,f=d.renderState;if(a){b=b||"default";var g=f.styles.get(b),h=e.styleResources.hasOwnProperty(a)?e.styleResources[a]:void 0;null!==h&&(e.styleResources[a]=null,g||(g={precedence:z(b),rules:[],hrefs:[],sheets:new Map},f.styles.set(b,g)),b={state:0,props:q({rel:"stylesheet",href:a,"data-precedence":b},c)},h&&(2===h.length&&Lb(b.props,h),(f=f.preloads.stylesheets.get(a))&&0<f.length?f.length=0:b.state=1),g.sheets.set(a,b),Ac(d))}}}
+function jb(a,b){var c=R?R:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=d.scriptResources.hasOwnProperty(a)?d.scriptResources[a]:void 0;null!==f&&(d.scriptResources[a]=null,b=q({src:a,async:!0},b),f&&(2===f.length&&Lb(b,f),a=e.preloads.scripts.get(a))&&(a.length=0),a=[],e.scripts.add(a),Pb(a,b),Ac(c))}}}
+function kb(a,b){var c=R?R:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=d.moduleScriptResources.hasOwnProperty(a)?d.moduleScriptResources[a]:void 0;null!==f&&(d.moduleScriptResources[a]=null,b=q({src:a,type:"module",async:!0},b),f&&(2===f.length&&Lb(b,f),a=e.preloads.moduleScripts.get(a))&&(a.length=0),a=[],e.scripts.add(a),Pb(a,b),Ac(c))}}}function Lb(a,b){null==a.crossOrigin&&(a.crossOrigin=b[0]);null==a.integrity&&(a.integrity=b[1])}
+function Ub(a,b,c){a=(""+a).replace(yc,zc);b=(""+b).replace(Bc,Cc);b="<"+a+'>; rel=preload; as="'+b+'"';for(var d in c)y.call(c,d)&&(a=c[d],"string"===typeof a&&(b+="; "+d.toLowerCase()+'="'+(""+a).replace(Bc,Cc)+'"'));return b}var yc=/[<>\r\n]/g;
+function zc(a){switch(a){case "<":return"%3C";case ">":return"%3E";case "\n":return"%0A";case "\r":return"%0D";default:throw Error("escapeLinkHrefForHeaderContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}}var Bc=/["';,\r\n]/g;
+function Cc(a){switch(a){case '"':return"%22";case "'":return"%27";case ";":return"%3B";case ",":return"%2C";case "\n":return"%0A";case "\r":return"%0D";default:throw Error("escapeStringForLinkHeaderQuotedParamValueContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}}function Dc(a){this.styles.add(a)}function Ec(a){this.stylesheets.add(a)}
+function Fc(a,b,c){if(b=a.onHeaders){var d=a.headers;if(d){var e=d.preconnects;d.fontPreloads&&(e&&(e+=", "),e+=d.fontPreloads);d.highImagePreloads&&(e&&(e+=", "),e+=d.highImagePreloads);if(!c){c=a.styles.values();var f=c.next();a:for(;0<d.remainingCapacity&&!f.done;f=c.next()){f=f.value.sheets.values();for(var g=f.next();0<d.remainingCapacity&&!g.done;g=f.next()){var h=g.value;g=h.props;var k=g.href;h=h.props;h=Ub(h.href,"style",{crossOrigin:h.crossOrigin,integrity:h.integrity,nonce:h.nonce,type:h.type,
+fetchPriority:h.fetchPriority,referrerPolicy:h.referrerPolicy,media:h.media});if(2<=(d.remainingCapacity-=h.length))a.resets.style[k]=A,e&&(e+=", "),e+=h,a.resets.style[k]="string"===typeof g.crossOrigin||"string"===typeof g.integrity?[g.crossOrigin,g.integrity]:A;else break a}}}e?b({Link:e}):b({});a.headers=null}}}
+function Gc(a,b){var c=a.idPrefix,d=[],e=a.bootstrapScriptContent,f=a.bootstrapScripts,g=a.bootstrapModules;void 0!==e&&d.push("<script>",(""+e).replace(mb,nb),"\x3c/script>");e=c+"P:";var h=c+"S:";c+="B:";var k=new Set,l=new Set,n=new Set,r=new Map,m=new Set,B=new Set,E=new Set,P={images:new Map,stylesheets:new Map,scripts:new Map,moduleScripts:new Map};if(void 0!==f)for(var v=0;v<f.length;v++){var t=f[v],p,G=void 0,u=void 0,w={rel:"preload",as:"script",fetchPriority:"low",nonce:void 0};"string"===
+typeof t?w.href=p=t:(w.href=p=t.src,w.integrity=u="string"===typeof t.integrity?t.integrity:void 0,w.crossOrigin=G="string"===typeof t||null==t.crossOrigin?void 0:"use-credentials"===t.crossOrigin?"use-credentials":"");t=a;var D=p;t.scriptResources[D]=null;t.moduleScriptResources[D]=null;t=[];M(t,w);m.add(t);d.push('<script src="',z(p));"string"===typeof u&&d.push('" integrity="',z(u));"string"===typeof G&&d.push('" crossorigin="',z(G));d.push('" async="">\x3c/script>')}if(void 0!==g)for(f=0;f<g.length;f++)w=
+g[f],G=p=void 0,u={rel:"modulepreload",fetchPriority:"low",nonce:void 0},"string"===typeof w?u.href=v=w:(u.href=v=w.src,u.integrity=G="string"===typeof w.integrity?w.integrity:void 0,u.crossOrigin=p="string"===typeof w||null==w.crossOrigin?void 0:"use-credentials"===w.crossOrigin?"use-credentials":""),w=a,t=v,w.scriptResources[t]=null,w.moduleScriptResources[t]=null,w=[],M(w,u),m.add(w),d.push('<script type="module" src="',z(v)),"string"===typeof G&&d.push('" integrity="',z(G)),"string"===typeof p&&
+d.push('" crossorigin="',z(p)),d.push('" async="">\x3c/script>');return{placeholderPrefix:e,segmentPrefix:h,boundaryPrefix:c,startInlineScript:"<script>",htmlChunks:null,headChunks:null,externalRuntimeScript:null,bootstrapChunks:d,onHeaders:void 0,headers:null,resets:{font:{},dns:{},connect:{default:{},anonymous:{},credentials:{}},image:{},style:{}},charsetChunks:[],preconnectChunks:[],importMapChunks:[],preloadChunks:[],hoistableChunks:[],preconnects:k,fontPreloads:l,highImagePreloads:n,styles:r,
+bootstrapScripts:m,scripts:B,bulkPreloads:E,preloads:P,boundaryResources:null,stylesToHoist:!1,generateStaticMarkup:b}}function Hc(a,b,c,d){if(c.generateStaticMarkup)return a.push(z(b)),!1;""===b?a=d:(d&&a.push("\x3c!-- --\x3e"),a.push(z(b)),a=!0);return a}
+var Ic=Symbol.for("react.element"),Jc=Symbol.for("react.portal"),Kc=Symbol.for("react.fragment"),Lc=Symbol.for("react.strict_mode"),Mc=Symbol.for("react.profiler"),Nc=Symbol.for("react.provider"),Oc=Symbol.for("react.context"),Pc=Symbol.for("react.server_context"),Qc=Symbol.for("react.forward_ref"),Rc=Symbol.for("react.suspense"),md=Symbol.for("react.suspense_list"),nd=Symbol.for("react.memo"),od=Symbol.for("react.lazy"),pd=Symbol.for("react.scope"),qd=Symbol.for("react.debug_trace_mode"),rd=Symbol.for("react.offscreen"),
+sd=Symbol.for("react.legacy_hidden"),td=Symbol.for("react.cache"),ud=Symbol.for("react.default_value"),vd=Symbol.for("react.memo_cache_sentinel"),wd=Symbol.for("react.postpone"),xd=Symbol.iterator;
+function yd(a){if(null==a)return null;if("function"===typeof a)return a.displayName||a.name||null;if("string"===typeof a)return a;switch(a){case Kc:return"Fragment";case Jc:return"Portal";case Mc:return"Profiler";case Lc:return"StrictMode";case Rc:return"Suspense";case md:return"SuspenseList";case td:return"Cache"}if("object"===typeof a)switch(a.$$typeof){case Oc:return(a.displayName||"Context")+".Consumer";case Nc:return(a._context.displayName||"Context")+".Provider";case Qc:var b=a.render;a=a.displayName;
+a||(a=b.displayName||b.name||"",a=""!==a?"ForwardRef("+a+")":"ForwardRef");return a;case nd:return b=a.displayName||null,null!==b?b:yd(a.type)||"Memo";case od:b=a._payload;a=a._init;try{return yd(a(b))}catch(c){break}case Pc:return(a.displayName||a._globalName)+".Provider"}return null}var zd={};function Ad(a,b){a=a.contextTypes;if(!a)return zd;var c={},d;for(d in a)c[d]=b[d];return c}var Bd=null;
+function Cd(a,b){if(a!==b){a.context._currentValue2=a.parentValue;a=a.parent;var c=b.parent;if(null===a){if(null!==c)throw Error("The stacks must reach the root at the same time. This is a bug in React.");}else{if(null===c)throw Error("The stacks must reach the root at the same time. This is a bug in React.");Cd(a,c)}b.context._currentValue2=b.value}}function Dd(a){a.context._currentValue2=a.parentValue;a=a.parent;null!==a&&Dd(a)}
+function Ed(a){var b=a.parent;null!==b&&Ed(b);a.context._currentValue2=a.value}function Fd(a,b){a.context._currentValue2=a.parentValue;a=a.parent;if(null===a)throw Error("The depth must equal at least at zero before reaching the root. This is a bug in React.");a.depth===b.depth?Cd(a,b):Fd(a,b)}
+function Gd(a,b){var c=b.parent;if(null===c)throw Error("The depth must equal at least at zero before reaching the root. This is a bug in React.");a.depth===c.depth?Cd(a,c):Gd(a,c);b.context._currentValue2=b.value}function Hd(a){var b=Bd;b!==a&&(null===b?Ed(a):null===a?Dd(b):b.depth===a.depth?Cd(b,a):b.depth>a.depth?Fd(b,a):Gd(b,a),Bd=a)}
+var Id={isMounted:function(){return!1},enqueueSetState:function(a,b){a=a._reactInternals;null!==a.queue&&a.queue.push(b)},enqueueReplaceState:function(a,b){a=a._reactInternals;a.replace=!0;a.queue=[b]},enqueueForceUpdate:function(){}};
+function Jd(a,b,c,d){var e=void 0!==a.state?a.state:null;a.updater=Id;a.props=c;a.state=e;var f={queue:[],replace:!1};a._reactInternals=f;var g=b.contextType;a.context="object"===typeof g&&null!==g?g._currentValue2:d;g=b.getDerivedStateFromProps;"function"===typeof g&&(g=g(c,e),e=null===g||void 0===g?e:q({},e,g),a.state=e);if("function"!==typeof b.getDerivedStateFromProps&&"function"!==typeof a.getSnapshotBeforeUpdate&&("function"===typeof a.UNSAFE_componentWillMount||"function"===typeof a.componentWillMount))if(b=
+a.state,"function"===typeof a.componentWillMount&&a.componentWillMount(),"function"===typeof a.UNSAFE_componentWillMount&&a.UNSAFE_componentWillMount(),b!==a.state&&Id.enqueueReplaceState(a,a.state,null),null!==f.queue&&0<f.queue.length)if(b=f.queue,g=f.replace,f.queue=null,f.replace=!1,g&&1===b.length)a.state=b[0];else{f=g?b[0]:a.state;e=!0;for(g=g?1:0;g<b.length;g++){var h=b[g];h="function"===typeof h?h.call(a,f,c,d):h;null!=h&&(e?(e=!1,f=q({},f,h)):q(f,h))}a.state=f}else f.queue=null}
+var Kd={id:1,overflow:""};function Ld(a,b,c){var d=a.id;a=a.overflow;var e=32-Md(d)-1;d&=~(1<<e);c+=1;var f=32-Md(b)+e;if(30<f){var g=e-e%5;f=(d&(1<<g)-1).toString(32);d>>=g;e-=g;return{id:1<<32-Md(b)+e|c<<e|d,overflow:f+a}}return{id:1<<f|c<<e|d,overflow:a}}var Md=Math.clz32?Math.clz32:Nd,Od=Math.log,Pd=Math.LN2;function Nd(a){a>>>=0;return 0===a?32:31-(Od(a)/Pd|0)|0}var Qd=Error("Suspense Exception: This is not a real error! It's an implementation detail of `use` to interrupt the current render. You must either rethrow it immediately, or move the `use` call outside of the `try/catch` block. Capturing without rethrowing will lead to unexpected behavior.\n\nTo handle async errors, wrap your component in an error boundary, or call the promise's `.catch` method and pass the result to `use`");
+function Rd(){}function Sd(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(Rd,Rd),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;default:if("string"!==typeof b.status)switch(a=b,a.status="pending",a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}}),b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;}Td=b;throw Qd;}}var Td=null;
+function Ud(){if(null===Td)throw Error("Expected a suspended thenable. This is a bug in React. Please file an issue.");var a=Td;Td=null;return a}function Vd(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var Wd="function"===typeof Object.is?Object.is:Vd,T=null,Xd=null,Yd=null,Zd=null,$d=null,U=null,ae=!1,be=!1,ce=0,de=0,ee=-1,fe=0,ge=null,he=null,ie=0;
+function je(){if(null===T)throw Error("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.");return T}
+function ke(){if(0<ie)throw Error("Rendered more hooks than during the previous render");return{memoizedState:null,queue:null,next:null}}function le(){null===U?null===$d?(ae=!1,$d=U=ke()):(ae=!0,U=$d):null===U.next?(ae=!1,U=U.next=ke()):(ae=!0,U=U.next);return U}function me(a,b,c,d){for(;be;)be=!1,de=ce=0,ee=-1,fe=0,ie+=1,U=null,c=a(b,d);ne();return c}function oe(){var a=ge;ge=null;return a}function ne(){Zd=Yd=Xd=T=null;be=!1;$d=null;ie=0;U=he=null}
+function pe(a,b){return"function"===typeof b?b(a):b}function qe(a,b,c){T=je();U=le();if(ae){var d=U.queue;b=d.dispatch;if(null!==he&&(c=he.get(d),void 0!==c)){he.delete(d);d=U.memoizedState;do d=a(d,c.action),c=c.next;while(null!==c);U.memoizedState=d;return[d,b]}return[U.memoizedState,b]}a=a===pe?"function"===typeof b?b():b:void 0!==c?c(b):b;U.memoizedState=a;a=U.queue={last:null,dispatch:null};a=a.dispatch=re.bind(null,T,a);return[U.memoizedState,a]}
+function se(a,b){T=je();U=le();b=void 0===b?null:b;if(null!==U){var c=U.memoizedState;if(null!==c&&null!==b){var d=c[1];a:if(null===d)d=!1;else{for(var e=0;e<d.length&&e<b.length;e++)if(!Wd(b[e],d[e])){d=!1;break a}d=!0}if(d)return c[0]}}a=a();U.memoizedState=[a,b];return a}
+function re(a,b,c){if(25<=ie)throw Error("Too many re-renders. React limits the number of renders to prevent an infinite loop.");if(a===T)if(be=!0,a={action:c,next:null},null===he&&(he=new Map),c=he.get(b),void 0===c)he.set(b,a);else{for(b=c;null!==b.next;)b=b.next;b.next=a}}function te(){throw Error("A function wrapped in useEffectEvent can't be called during rendering.");}function ue(){throw Error("startTransition cannot be called during server rendering.");}
+function ve(){throw Error("Cannot update optimistic state while rendering.");}function we(a){var b=fe;fe+=1;null===ge&&(ge=[]);return Sd(ge,a,b)}function xe(){throw Error("Cache cannot be refreshed during server rendering.");}function ye(){}
+var Ae={readContext:function(a){return a._currentValue2},use:function(a){if(null!==a&&"object"===typeof a){if("function"===typeof a.then)return we(a);if(a.$$typeof===Oc||a.$$typeof===Pc)return a._currentValue2}throw Error("An unsupported type was passed to use(): "+String(a));},useContext:function(a){je();return a._currentValue2},useMemo:se,useReducer:qe,useRef:function(a){T=je();U=le();var b=U.memoizedState;return null===b?(a={current:a},U.memoizedState=a):b},useState:function(a){return qe(pe,a)},
+useInsertionEffect:ye,useLayoutEffect:ye,useCallback:function(a,b){return se(function(){return a},b)},useImperativeHandle:ye,useEffect:ye,useDebugValue:ye,useDeferredValue:function(a,b){je();return void 0!==b?b:a},useTransition:function(){je();return[!1,ue]},useId:function(){var a=Xd.treeContext;var b=a.overflow;a=a.id;a=(a&~(1<<32-Md(a)-1)).toString(32)+b;var c=ze;if(null===c)throw Error("Invalid hook call. Hooks can only be called inside of the body of a function component.");b=ce++;a=":"+c.idPrefix+
+"R"+a;0<b&&(a+="H"+b.toString(32));return a+":"},useSyncExternalStore:function(a,b,c){if(void 0===c)throw Error("Missing getServerSnapshot, which is required for server-rendered content. Will revert to client rendering.");return c()},useCacheRefresh:function(){return xe},useEffectEvent:function(){return te},useMemoCache:function(a){for(var b=Array(a),c=0;c<a;c++)b[c]=vd;return b},useHostTransitionStatus:function(){je();return Ma},useOptimistic:function(a){je();return[a,ve]},useFormState:function(a,
+b,c){je();var d=de++,e=Yd;if("function"===typeof a.$$FORM_ACTION){var f=null,g=Zd;e=e.formState;var h=a.$$IS_SIGNATURE_EQUAL;if(null!==e&&"function"===typeof h){var k=e[1];h.call(a,e[2],e[3])&&(f=void 0!==c?"p"+c:"k"+ja(JSON.stringify([g,null,d]),0),k===f&&(ee=d,b=e[0]))}var l=a.bind(null,b);a=function(r){l(r)};"function"===typeof l.$$FORM_ACTION&&(a.$$FORM_ACTION=function(r){r=l.$$FORM_ACTION(r);void 0!==c&&(c+="",r.action=c);var m=r.data;m&&(null===f&&(f=void 0!==c?"p"+c:"k"+ja(JSON.stringify([g,
+null,d]),0)),m.append("$ACTION_KEY",f));return r});return[b,a]}var n=a.bind(null,b);return[b,function(r){n(r)}]}},ze=null,Be={getCacheSignal:function(){throw Error("Not implemented.");},getCacheForType:function(){throw Error("Not implemented.");}},Ce=La.ReactCurrentDispatcher,De=La.ReactCurrentCache;function Fe(a){console.error(a);return null}function Ge(){}
+function He(a,b,c,d,e,f,g,h,k,l,n,r){Na.current=lb;var m=[],B=new Set;b={destination:null,flushScheduled:!1,resumableState:b,renderState:c,rootFormatContext:d,progressiveChunkSize:void 0===e?12800:e,status:0,fatalError:null,nextSegmentId:0,allPendingTasks:0,pendingRootTasks:0,completedRootSegment:null,abortableTasks:B,pingedTasks:m,clientRenderedBoundaries:[],completedBoundaries:[],partialBoundaries:[],trackedPostpones:null,onError:void 0===f?Fe:f,onPostpone:void 0===n?Ge:n,onAllReady:void 0===g?
+Ge:g,onShellReady:void 0===h?Ge:h,onShellError:void 0===k?Ge:k,onFatalError:void 0===l?Ge:l,formState:void 0===r?null:r};c=Ie(b,0,null,d,!1,!1);c.parentFlushed=!0;a=Je(b,null,a,-1,null,c,B,null,d,zd,null,Kd);m.push(a);return b}var R=null;function Ke(a,b){a.pingedTasks.push(b);1===a.pingedTasks.length&&(a.flushScheduled=null!==a.destination,Le(a))}
+function Me(a,b){return{status:0,rootSegmentID:-1,parentFlushed:!1,pendingTasks:0,completedSegments:[],byteSize:0,fallbackAbortableTasks:b,errorDigest:null,resources:{styles:new Set,stylesheets:new Set},trackedContentKeyPath:null,trackedFallbackNode:null}}
+function Je(a,b,c,d,e,f,g,h,k,l,n,r){a.allPendingTasks++;null===e?a.pendingRootTasks++:e.pendingTasks++;var m={replay:null,node:c,childIndex:d,ping:function(){return Ke(a,m)},blockedBoundary:e,blockedSegment:f,abortSet:g,keyPath:h,formatContext:k,legacyContext:l,context:n,treeContext:r,thenableState:b};g.add(m);return m}
+function Ne(a,b,c,d,e,f,g,h,k,l,n,r){a.allPendingTasks++;null===f?a.pendingRootTasks++:f.pendingTasks++;c.pendingTasks++;var m={replay:c,node:d,childIndex:e,ping:function(){return Ke(a,m)},blockedBoundary:f,blockedSegment:null,abortSet:g,keyPath:h,formatContext:k,legacyContext:l,context:n,treeContext:r,thenableState:b};g.add(m);return m}function Ie(a,b,c,d,e,f){return{status:0,id:-1,index:b,parentFlushed:!1,chunks:[],children:[],parentFormatContext:d,boundary:c,lastPushedText:e,textEmbedded:f}}
+function X(a,b){a=a.onError(b);if(null!=a&&"string"!==typeof a)throw Error('onError returned something with a type other than "string". onError should return a string and may return null or undefined but must not return anything else. It received something of type "'+typeof a+'" instead');return a}function Oe(a,b){var c=a.onShellError;c(b);c=a.onFatalError;c(b);null!==a.destination?(a.status=2,a.destination.destroy(b)):(a.status=1,a.fatalError=b)}
+function Pe(a,b,c,d,e){var f=d.render(),g=e.childContextTypes;if(null!==g&&void 0!==g){c=b.legacyContext;if("function"!==typeof d.getChildContext)e=c;else{d=d.getChildContext();for(var h in d)if(!(h in g))throw Error((yd(e)||"Unknown")+'.getChildContext(): key "'+h+'" is not defined in childContextTypes.');e=q({},c,d)}b.legacyContext=e;Y(a,b,null,f,-1);b.legacyContext=c}else e=b.keyPath,b.keyPath=c,Y(a,b,null,f,-1),b.keyPath=e}
+function Qe(a,b,c,d,e,f,g){var h=!1;if(0!==f&&null!==a.formState){var k=b.blockedSegment;if(null!==k){h=!0;k=k.chunks;for(var l=0;l<f;l++)l===g?k.push("\x3c!--F!--\x3e"):k.push("\x3c!--F--\x3e")}}f=b.keyPath;b.keyPath=c;e?(c=b.treeContext,b.treeContext=Ld(c,1,0),Z(a,b,d,-1),b.treeContext=c):h?Z(a,b,d,-1):Y(a,b,null,d,-1);b.keyPath=f}function Re(a,b){if(a&&a.defaultProps){b=q({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}
+function Se(a,b,c,d,e,f,g){if("function"===typeof e)if(e.prototype&&e.prototype.isReactComponent){d=Ad(e,b.legacyContext);var h=e.contextType;h=new e(f,"object"===typeof h&&null!==h?h._currentValue2:d);Jd(h,e,f,d);Pe(a,b,c,h,e)}else{h=Ad(e,b.legacyContext);T={};Xd=b;Yd=a;Zd=c;de=ce=0;ee=-1;fe=0;ge=d;d=e(f,h);d=me(e,f,d,h);g=0!==ce;var k=de,l=ee;"object"===typeof d&&null!==d&&"function"===typeof d.render&&void 0===d.$$typeof?(Jd(d,e,f,h),Pe(a,b,c,d,e)):Qe(a,b,c,d,g,k,l)}else if("string"===typeof e)if(d=
+b.blockedSegment,null===d)d=f.children,h=b.formatContext,g=b.keyPath,b.formatContext=Ab(h,e,f),b.keyPath=c,Z(a,b,d,-1),b.formatContext=h,b.keyPath=g;else{g=Tb(d.chunks,e,f,a.resumableState,a.renderState,b.formatContext,d.lastPushedText);d.lastPushedText=!1;h=b.formatContext;k=b.keyPath;b.formatContext=Ab(h,e,f);b.keyPath=c;Z(a,b,g,-1);b.formatContext=h;b.keyPath=k;a:{b=d.chunks;a=a.resumableState;switch(e){case "title":case "style":case "script":case "area":case "base":case "br":case "col":case "embed":case "hr":case "img":case "input":case "keygen":case "link":case "meta":case "param":case "source":case "track":case "wbr":break a;
+case "body":if(1>=h.insertionMode){a.hasBody=!0;break a}break;case "html":if(0===h.insertionMode){a.hasHtml=!0;break a}}b.push(Ob(e))}d.lastPushedText=!1}else{switch(e){case sd:case qd:case Lc:case Mc:case Kc:e=b.keyPath;b.keyPath=c;Y(a,b,null,f.children,-1);b.keyPath=e;return;case rd:"hidden"!==f.mode&&(e=b.keyPath,b.keyPath=c,Y(a,b,null,f.children,-1),b.keyPath=e);return;case md:e=b.keyPath;b.keyPath=c;Y(a,b,null,f.children,-1);b.keyPath=e;return;case pd:throw Error("ReactDOMServer does not yet support scope components.");
+case Rc:a:if(null!==b.replay){e=b.keyPath;b.keyPath=c;c=f.children;try{Z(a,b,c,-1)}finally{b.keyPath=e}}else{l=b.keyPath;e=b.blockedBoundary;var n=b.blockedSegment;d=f.fallback;var r=f.children;f=new Set;g=Me(a,f);null!==a.trackedPostpones&&(g.trackedContentKeyPath=c);k=Ie(a,n.chunks.length,g,b.formatContext,!1,!1);n.children.push(k);n.lastPushedText=!1;var m=Ie(a,0,null,b.formatContext,!1,!1);m.parentFlushed=!0;b.blockedBoundary=g;b.blockedSegment=m;a.renderState.boundaryResources=g.resources;b.keyPath=
+c;try{if(Z(a,b,r,-1),a.renderState.generateStaticMarkup||m.lastPushedText&&m.textEmbedded&&m.chunks.push("\x3c!-- --\x3e"),m.status=1,Te(g,m),0===g.pendingTasks&&0===g.status){g.status=1;break a}}catch(B){m.status=4,g.status=4,"object"===typeof B&&null!==B&&B.$$typeof===wd?(a.onPostpone(B.message),h="POSTPONE"):h=X(a,B),g.errorDigest=h}finally{a.renderState.boundaryResources=e?e.resources:null,b.blockedBoundary=e,b.blockedSegment=n,b.keyPath=l}h=[c[0],"Suspense Fallback",c[2]];l=a.trackedPostpones;
+null!==l&&(n=[h[1],h[2],[],null],l.workingMap.set(h,n),5===g.status?l.workingMap.get(c)[4]=n:g.trackedFallbackNode=n);b=Je(a,null,d,-1,e,k,f,h,b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}return}if("object"===typeof e&&null!==e)switch(e.$$typeof){case Qc:e=e.render;T={};Xd=b;Yd=a;Zd=c;de=ce=0;ee=-1;fe=0;ge=d;d=e(f,g);f=me(e,f,d,g);Qe(a,b,c,f,0!==ce,de,ee);return;case nd:e=e.type;f=Re(e,f);Se(a,b,c,d,e,f,g);return;case Nc:h=f.children;d=b.keyPath;e=e._context;f=f.value;
+g=e._currentValue2;e._currentValue2=f;k=Bd;Bd=f={parent:k,depth:null===k?0:k.depth+1,context:e,parentValue:g,value:f};b.context=f;b.keyPath=c;Y(a,b,null,h,-1);a=Bd;if(null===a)throw Error("Tried to pop a Context at the root of the app. This is a bug in React.");c=a.parentValue;a.context._currentValue2=c===ud?a.context._defaultValue:c;a=Bd=a.parent;b.context=a;b.keyPath=d;return;case Oc:f=f.children;f=f(e._currentValue2);e=b.keyPath;b.keyPath=c;Y(a,b,null,f,-1);b.keyPath=e;return;case od:h=e._init;
+e=h(e._payload);f=Re(e,f);Se(a,b,c,d,e,f,void 0);return}throw Error("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: "+((null==e?e:typeof e)+"."));}}
+function Ue(a,b,c,d,e){var f=b.replay,g=b.blockedBoundary,h=Ie(a,0,null,b.formatContext,!1,!1);h.id=c;h.parentFlushed=!0;try{b.replay=null,b.blockedSegment=h,Z(a,b,d,e),h.status=1,null===g?a.completedRootSegment=h:(Te(g,h),g.parentFlushed&&a.partialBoundaries.push(g))}finally{b.replay=f,b.blockedSegment=null}}
+function Y(a,b,c,d,e){if(null!==b.replay&&"number"===typeof b.replay.slots)Ue(a,b,b.replay.slots,d,e);else{b.node=d;b.childIndex=e;if("object"===typeof d&&null!==d){switch(d.$$typeof){case Ic:var f=d.type,g=d.key,h=d.props,k=d.ref,l=yd(f),n=null==g?-1===e?0:e:g;g=[b.keyPath,l,n];if(null!==b.replay)a:{var r=b.replay;e=r.nodes;for(d=0;d<e.length;d++){var m=e[d];if(n===m[1]){if(4===m.length){if(null!==l&&l!==m[0])throw Error("Expected the resume to render <"+m[0]+"> in this slot but instead it rendered <"+
+l+">. The tree doesn't match so React will fallback to client rendering.");l=m[2];m=m[3];n=b.node;b.replay={nodes:l,slots:m,pendingTasks:1};try{Se(a,b,g,c,f,h,k);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--}catch(p){if("object"===typeof p&&null!==p&&(p===Qd||"function"===typeof p.then))throw b.node===n&&(b.replay=r),p;b.replay.pendingTasks--;
+Ve(a,b.blockedBoundary,p,l,m)}b.replay=r}else{if(f!==Rc)throw Error("Expected the resume to render <Suspense> in this slot but instead it rendered <"+(yd(f)||"Unknown")+">. The tree doesn't match so React will fallback to client rendering.");b:{c=void 0;f=m[5];k=m[2];r=m[3];l=null===m[4]?[]:m[4][2];m=null===m[4]?null:m[4][3];n=b.keyPath;var B=b.replay,E=b.blockedBoundary,P=h.children;h=h.fallback;var v=new Set,t=Me(a,v);t.parentFlushed=!0;t.rootSegmentID=f;b.blockedBoundary=t;b.replay={nodes:k,slots:r,
+pendingTasks:1};a.renderState.boundaryResources=t.resources;try{Z(a,b,P,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--;if(0===t.pendingTasks&&0===t.status){t.status=1;a.completedBoundaries.push(t);break b}}catch(p){t.status=4,"object"===typeof p&&null!==p&&p.$$typeof===wd?(a.onPostpone(p.message),c="POSTPONE"):c=X(a,p),
+t.errorDigest=c,b.replay.pendingTasks--,a.clientRenderedBoundaries.push(t)}finally{a.renderState.boundaryResources=E?E.resources:null,b.blockedBoundary=E,b.replay=B,b.keyPath=n}h=Ne(a,null,{nodes:l,slots:m,pendingTasks:0},h,-1,E,v,[g[0],"Suspense Fallback",g[2]],b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(h)}}e.splice(d,1);break a}}}else Se(a,b,g,c,f,h,k);return;case Jc:throw Error("Portals are not currently supported by the server renderer. Render them conditionally so that they only appear on the client render.");
+case od:h=d._init;d=h(d._payload);Y(a,b,null,d,e);return}if(Ka(d)){We(a,b,d,e);return}null===d||"object"!==typeof d?h=null:(h=xd&&d[xd]||d["@@iterator"],h="function"===typeof h?h:null);if(h&&(h=h.call(d))){d=h.next();if(!d.done){g=[];do g.push(d.value),d=h.next();while(!d.done);We(a,b,g,e)}return}if("function"===typeof d.then)return Y(a,b,null,we(d),e);if(d.$$typeof===Oc||d.$$typeof===Pc)return Y(a,b,null,d._currentValue2,e);e=Object.prototype.toString.call(d);throw Error("Objects are not valid as a React child (found: "+
+("[object Object]"===e?"object with keys {"+Object.keys(d).join(", ")+"}":e)+"). If you meant to render a collection of children, use an array instead.");}"string"===typeof d?(e=b.blockedSegment,null!==e&&(e.lastPushedText=Hc(e.chunks,d,a.renderState,e.lastPushedText))):"number"===typeof d&&(e=b.blockedSegment,null!==e&&(e.lastPushedText=Hc(e.chunks,""+d,a.renderState,e.lastPushedText)))}}
+function We(a,b,c,d){var e=b.keyPath;if(-1!==d&&(b.keyPath=[b.keyPath,"Fragment",d],null!==b.replay)){for(var f=b.replay,g=f.nodes,h=0;h<g.length;h++){var k=g[h];if(k[1]===d){d=k[2];k=k[3];b.replay={nodes:d,slots:k,pendingTasks:1};try{We(a,b,c,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--}catch(n){if("object"===typeof n&&
+null!==n&&(n===Qd||"function"===typeof n.then))throw n;b.replay.pendingTasks--;Ve(a,b.blockedBoundary,n,d,k)}b.replay=f;g.splice(h,1);break}}b.keyPath=e;return}f=b.treeContext;g=c.length;if(null!==b.replay&&(h=b.replay.slots,null!==h&&"object"===typeof h)){for(k=0;k<g;k++){d=c[k];b.treeContext=Ld(f,g,k);var l=h[k];"number"===typeof l?(Ue(a,b,l,d,k),delete h[k]):Z(a,b,d,k)}b.treeContext=f;b.keyPath=e;return}for(h=0;h<g;h++)k=c[h],b.treeContext=Ld(f,g,h),Z(a,b,k,h);b.treeContext=f;b.keyPath=e}
+function Xe(a,b,c,d){d.status=5;var e=c.keyPath,f=c.blockedBoundary;if(null===f)d.id=a.nextSegmentId++,b.rootSlots=d.id,null!==a.completedRootSegment&&(a.completedRootSegment.status=5);else{if(null!==f&&0===f.status){f.status=5;f.rootSegmentID=a.nextSegmentId++;var g=f.trackedContentKeyPath;if(null===g)throw Error("It should not be possible to postpone at the root. This is a bug in React.");var h=f.trackedFallbackNode,k=[];if(g===e&&-1===c.childIndex){d.id=f.rootSegmentID;d=[g[1],g[2],k,f.rootSegmentID,
+h,f.rootSegmentID];b.workingMap.set(g,d);Ye(d,g[0],b);return}var l=b.workingMap.get(g);void 0===l?(l=[g[1],g[2],k,null,h,f.rootSegmentID],b.workingMap.set(g,l),Ye(l,g[0],b)):(g=l,g[4]=h,g[5]=f.rootSegmentID)}-1===d.id&&(d.id=d.parentFlushed&&null!==f?f.rootSegmentID:a.nextSegmentId++);if(-1===c.childIndex)null===e?b.rootSlots=d.id:(c=b.workingMap.get(e),void 0===c?(c=[e[1],e[2],[],d.id],Ye(c,e[0],b)):c[3]=d.id);else{if(null===e)if(a=b.rootSlots,null===a)a=b.rootSlots={};else{if("number"===typeof a)throw Error("It should not be possible to postpone both at the root of an element as well as a slot below. This is a bug in React.");
+}else if(f=b.workingMap,g=f.get(e),void 0===g)a={},g=[e[1],e[2],[],a],f.set(e,g),Ye(g,e[0],b);else if(a=g[3],null===a)a=g[3]={};else if("number"===typeof a)throw Error("It should not be possible to postpone both at the root of an element as well as a slot below. This is a bug in React.");a[c.childIndex]=d.id}}}
+function Z(a,b,c,d){var e=b.formatContext,f=b.legacyContext,g=b.context,h=b.keyPath,k=b.treeContext,l=b.blockedSegment;if(null===l)try{return Y(a,b,null,c,d)}catch(m){if(ne(),d=m===Qd?Ud():m,"object"===typeof d&&null!==d&&"function"===typeof d.then){c=d;d=oe();a=Ne(a,d,b.replay,b.node,b.childIndex,b.blockedBoundary,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Hd(g);return}}else{var n=
+l.children.length,r=l.chunks.length;try{return Y(a,b,null,c,d)}catch(m){if(ne(),l.children.length=n,l.chunks.length=r,d=m===Qd?Ud():m,"object"===typeof d&&null!==d){if("function"===typeof d.then){c=d;d=oe();l=b.blockedSegment;n=Ie(a,l.chunks.length,null,b.formatContext,l.lastPushedText,!0);l.children.push(n);l.lastPushedText=!1;a=Je(a,d,b.node,b.childIndex,b.blockedBoundary,n,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=
+f;b.context=g;b.keyPath=h;b.treeContext=k;Hd(g);return}if(null!==a.trackedPostpones&&d.$$typeof===wd&&null!==b.blockedBoundary){c=a.trackedPostpones;a.onPostpone(d.message);d=b.blockedSegment;l=Ie(a,d.chunks.length,null,b.formatContext,d.lastPushedText,!0);d.children.push(l);d.lastPushedText=!1;Xe(a,c,b,l);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Hd(g);return}}}}b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Hd(g);throw d;}
+function Ve(a,b,c,d,e){if("object"===typeof c&&null!==c&&c.$$typeof===wd){a.onPostpone(c.message);var f="POSTPONE"}else f=X(a,c);Ze(a,b,d,e,c,f)}function $e(a){var b=a.blockedBoundary;a=a.blockedSegment;null!==a&&(a.status=3,af(this,b,a))}
+function Ze(a,b,c,d,e,f){for(var g=0;g<c.length;g++){var h=c[g];if(4===h.length)Ze(a,b,h[2],h[3],e,f);else{h=h[5];var k=a,l=f,n=Me(k,new Set);n.parentFlushed=!0;n.rootSegmentID=h;n.status=4;n.errorDigest=l;n.parentFlushed&&k.clientRenderedBoundaries.push(n)}}c.length=0;if(null!==d){if(null===b)throw Error("We should not have any resumable nodes in the shell. This is a bug in React.");4!==b.status&&(b.status=4,b.errorDigest=f,b.parentFlushed&&a.clientRenderedBoundaries.push(b));if("object"===typeof d)for(var r in d)delete d[r]}}
+function bf(a,b,c){var d=a.blockedBoundary,e=a.blockedSegment;null!==e&&(e.status=3);if(null===d){if(1!==b.status&&2!==b.status){a=a.replay;if(null===a){X(b,c);Oe(b,c);return}a.pendingTasks--;0===a.pendingTasks&&0<a.nodes.length&&(d=X(b,c),Ze(b,null,a.nodes,a.slots,c,d));b.pendingRootTasks--;0===b.pendingRootTasks&&cf(b)}}else d.pendingTasks--,4!==d.status&&(d.status=4,d.errorDigest=X(b,c),d.parentFlushed&&b.clientRenderedBoundaries.push(d)),d.fallbackAbortableTasks.forEach(function(f){return bf(f,
+b,c)}),d.fallbackAbortableTasks.clear();b.allPendingTasks--;0===b.allPendingTasks&&df(b)}function cf(a){null===a.trackedPostpones&&Fc(a.renderState,a.resumableState,!0);a.onShellError=Ge;a=a.onShellReady;a()}function df(a){Fc(a.renderState,a.resumableState,null===a.trackedPostpones?!0:null===a.completedRootSegment||5!==a.completedRootSegment.status);a=a.onAllReady;a()}
+function Te(a,b){if(0===b.chunks.length&&1===b.children.length&&null===b.children[0].boundary){var c=b.children[0];c.id=b.id;c.parentFlushed=!0;1===c.status&&Te(a,c)}else a.completedSegments.push(b)}
+function af(a,b,c){if(null===b){if(null!==c&&c.parentFlushed){if(null!==a.completedRootSegment)throw Error("There can only be one root segment. This is a bug in React.");a.completedRootSegment=c}a.pendingRootTasks--;0===a.pendingRootTasks&&cf(a)}else b.pendingTasks--,4!==b.status&&(0===b.pendingTasks?(0===b.status&&(b.status=1),null!==c&&c.parentFlushed&&1===c.status&&Te(b,c),b.parentFlushed&&a.completedBoundaries.push(b),1===b.status&&(b.fallbackAbortableTasks.forEach($e,a),b.fallbackAbortableTasks.clear())):
+null!==c&&c.parentFlushed&&1===c.status&&(Te(b,c),1===b.completedSegments.length&&b.parentFlushed&&a.partialBoundaries.push(b)));a.allPendingTasks--;0===a.allPendingTasks&&df(a)}
+function Le(a){if(2!==a.status){var b=Bd,c=Ce.current;Ce.current=Ae;var d=De.current;De.current=Be;var e=R;R=a;var f=ze;ze=a.resumableState;try{var g=a.pingedTasks,h;for(h=0;h<g.length;h++){var k=g[h],l=a,n=k.blockedBoundary;l.renderState.boundaryResources=n?n.resources:null;var r=k.blockedSegment;if(null===r){var m=l;if(0!==k.replay.pendingTasks){Hd(k.context);try{var B=k.thenableState;k.thenableState=null;Y(m,k,B,k.node,k.childIndex);if(1===k.replay.pendingTasks&&0<k.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");
+k.replay.pendingTasks--;k.abortSet.delete(k);af(m,k.blockedBoundary,null)}catch(x){ne();var E=x===Qd?Ud():x;if("object"===typeof E&&null!==E&&"function"===typeof E.then){var P=k.ping;E.then(P,P);k.thenableState=oe()}else k.replay.pendingTasks--,k.abortSet.delete(k),Ve(m,k.blockedBoundary,E,k.replay.nodes,k.replay.slots),m.pendingRootTasks--,0===m.pendingRootTasks&&cf(m),m.allPendingTasks--,0===m.allPendingTasks&&df(m)}finally{m.renderState.boundaryResources=null}}}else a:{m=void 0;var v=r;if(0===
+v.status){Hd(k.context);var t=v.children.length,p=v.chunks.length;try{var G=k.thenableState;k.thenableState=null;Y(l,k,G,k.node,k.childIndex);l.renderState.generateStaticMarkup||v.lastPushedText&&v.textEmbedded&&v.chunks.push("\x3c!-- --\x3e");k.abortSet.delete(k);v.status=1;af(l,k.blockedBoundary,v)}catch(x){ne();v.children.length=t;v.chunks.length=p;var u=x===Qd?Ud():x;if("object"===typeof u&&null!==u){if("function"===typeof u.then){var w=k.ping;u.then(w,w);k.thenableState=oe();break a}if(null!==
+l.trackedPostpones&&u.$$typeof===wd){var D=l.trackedPostpones;k.abortSet.delete(k);l.onPostpone(u.message);Xe(l,D,k,v);af(l,k.blockedBoundary,v);break a}}k.abortSet.delete(k);v.status=4;var C=k.blockedBoundary;"object"===typeof u&&null!==u&&u.$$typeof===wd?(l.onPostpone(u.message),m="POSTPONE"):m=X(l,u);null===C?Oe(l,u):(C.pendingTasks--,4!==C.status&&(C.status=4,C.errorDigest=m,C.parentFlushed&&l.clientRenderedBoundaries.push(C)));l.allPendingTasks--;0===l.allPendingTasks&&df(l)}finally{l.renderState.boundaryResources=
+null}}}}g.splice(0,h);null!==a.destination&&ef(a,a.destination)}catch(x){X(a,x),Oe(a,x)}finally{ze=f,Ce.current=c,De.current=d,c===Ae&&Hd(b),R=e}}}
+function ff(a,b,c){c.parentFlushed=!0;switch(c.status){case 0:c.id=a.nextSegmentId++;case 5:var d=c.id;c.lastPushedText=!1;c.textEmbedded=!1;a=a.renderState;b.push('<template id="');b.push(a.placeholderPrefix);a=d.toString(16);b.push(a);return b.push('"></template>');case 1:c.status=2;var e=!0;d=c.chunks;var f=0;c=c.children;for(var g=0;g<c.length;g++){for(e=c[g];f<e.index;f++)b.push(d[f]);e=gf(a,b,e)}for(;f<d.length-1;f++)b.push(d[f]);f<d.length&&(e=b.push(d[f]));return e;default:throw Error("Aborted, errored or already flushed boundaries should not be flushed again. This is a bug in React.");
 }}
-function ef(a,b,c){var d=c.boundary;if(null===d)return df(a,b,c);d.parentFlushed=!0;if(4===d.status)return a.renderState.generateStaticMarkup||(d=d.errorDigest,b.push("\x3c!--$!--\x3e"),b.push("<template"),d&&(b.push(' data-dgst="'),d=x(d),b.push(d),b.push('"')),b.push("></template>")),df(a,b,c),a=a.renderState.generateStaticMarkup?!0:b.push("\x3c!--/$--\x3e"),a;if(1!==d.status)return 0===d.status&&(d.rootSegmentID=a.nextSegmentId++),0<d.completedSegments.length&&a.partialBoundaries.push(d),Vb(b,a.renderState,
-d.rootSegmentID),df(a,b,c),b.push("\x3c!--/$--\x3e");if(d.byteSize>a.progressiveChunkSize)return d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),Vb(b,a.renderState,d.rootSegmentID),df(a,b,c),b.push("\x3c!--/$--\x3e");c=d.resources;var e=a.renderState.boundaryResources;e&&(c.styles.forEach(Bc,e),c.stylesheets.forEach(Cc,e));a.renderState.generateStaticMarkup||b.push("\x3c!--$--\x3e");c=d.completedSegments;if(1!==c.length)throw Error("A previously unvisited boundary must have exactly one root segment. This is a bug in React.");
-ef(a,b,c[0]);a=a.renderState.generateStaticMarkup?!0:b.push("\x3c!--/$--\x3e");return a}function ff(a,b,c){Wb(b,a.renderState,c.parentFormatContext,c.id);ef(a,b,c);return Xb(b,c.parentFormatContext)}
-function gf(a,b,c){a.renderState.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e<d.length;e++)hf(a,b,c,d[e]);d.length=0;oc(b,c.resources,a.renderState);d=a.resumableState;a=a.renderState;e=c.rootSegmentID;c=c.resources;var f=a.stylesToHoist;a.stylesToHoist=!1;var g=0===d.streamingFormat;g?(b.push(a.startInlineScript),f?0===(d.instructions&2)?(d.instructions|=10,b.push('$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};$RR("')):
+function gf(a,b,c){var d=c.boundary;if(null===d)return ff(a,b,c);d.parentFlushed=!0;if(4===d.status)return a.renderState.generateStaticMarkup||(d=d.errorDigest,b.push("\x3c!--$!--\x3e"),b.push("<template"),d&&(b.push(' data-dgst="'),d=z(d),b.push(d),b.push('"')),b.push("></template>")),ff(a,b,c),a=a.renderState.generateStaticMarkup?!0:b.push("\x3c!--/$--\x3e"),a;if(1!==d.status)return 0===d.status&&(d.rootSegmentID=a.nextSegmentId++),0<d.completedSegments.length&&a.partialBoundaries.push(d),Xb(b,a.renderState,
+d.rootSegmentID),ff(a,b,c),b.push("\x3c!--/$--\x3e");if(d.byteSize>a.progressiveChunkSize)return d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),Xb(b,a.renderState,d.rootSegmentID),ff(a,b,c),b.push("\x3c!--/$--\x3e");c=d.resources;var e=a.renderState.boundaryResources;e&&(c.styles.forEach(Dc,e),c.stylesheets.forEach(Ec,e));a.renderState.generateStaticMarkup||b.push("\x3c!--$--\x3e");c=d.completedSegments;if(1!==c.length)throw Error("A previously unvisited boundary must have exactly one root segment. This is a bug in React.");
+gf(a,b,c[0]);a=a.renderState.generateStaticMarkup?!0:b.push("\x3c!--/$--\x3e");return a}function hf(a,b,c){gc(b,a.renderState,c.parentFormatContext,c.id);gf(a,b,c);return hc(b,c.parentFormatContext)}
+function jf(a,b,c){a.renderState.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e<d.length;e++)kf(a,b,c,d[e]);d.length=0;qc(b,c.resources,a.renderState);d=a.resumableState;a=a.renderState;e=c.rootSegmentID;c=c.resources;var f=a.stylesToHoist;a.stylesToHoist=!1;var g=0===d.streamingFormat;g?(b.push(a.startInlineScript),f?0===(d.instructions&2)?(d.instructions|=10,b.push('$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};$RR("')):
 0===(d.instructions&8)?(d.instructions|=8,b.push('$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};$RR("')):
 b.push('$RR("'):0===(d.instructions&2)?(d.instructions|=2,b.push('$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};$RC("')):
-b.push('$RC("')):f?b.push('<template data-rri="" data-bid="'):b.push('<template data-rci="" data-bid="');d=e.toString(16);b.push(a.boundaryPrefix);b.push(d);g?b.push('","'):b.push('" data-sid="');b.push(a.segmentPrefix);b.push(d);f?g?(b.push('",'),uc(b,c)):(b.push('" data-sty="'),vc(b,c)):g&&b.push('"');d=g?b.push(")\x3c/script>"):b.push('"></template>');return Ub(b,a)&&d}
-function hf(a,b,c,d){if(2===d.status)return!0;var e=d.id;if(-1===e){if(-1===(d.id=c.rootSegmentID))throw Error("A root segment ID must have been assigned by now. This is a bug in React.");return ff(a,b,d)}if(e===c.rootSegmentID)return ff(a,b,d);ff(a,b,d);c=a.resumableState;a=a.renderState;(d=0===c.streamingFormat)?(b.push(a.startInlineScript),0===(c.instructions&1)?(c.instructions|=1,b.push('$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};$RS("')):
+b.push('$RC("')):f?b.push('<template data-rri="" data-bid="'):b.push('<template data-rci="" data-bid="');e=e.toString(16);b.push(a.boundaryPrefix);b.push(e);g?b.push('","'):b.push('" data-sid="');b.push(a.segmentPrefix);b.push(e);f?g?(b.push('",'),wc(b,c)):(b.push('" data-sty="'),xc(b,c)):g&&b.push('"');c=g?b.push(")\x3c/script>"):b.push('"></template>');return Wb(b,a,d)&&c}
+function kf(a,b,c,d){if(2===d.status)return!0;var e=d.id;if(-1===e){if(-1===(d.id=c.rootSegmentID))throw Error("A root segment ID must have been assigned by now. This is a bug in React.");return hf(a,b,d)}if(e===c.rootSegmentID)return hf(a,b,d);hf(a,b,d);c=a.resumableState;a=a.renderState;(d=0===c.streamingFormat)?(b.push(a.startInlineScript),0===(c.instructions&1)?(c.instructions|=1,b.push('$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};$RS("')):
 b.push('$RS("')):b.push('<template data-rsi="" data-sid="');b.push(a.segmentPrefix);e=e.toString(16);b.push(e);d?b.push('","'):b.push('" data-pid="');b.push(a.placeholderPrefix);b.push(e);b=d?b.push('")\x3c/script>'):b.push('"></template>');return b}
-function cf(a,b){try{var c,d=a.completedRootSegment;if(null!==d)if(5!==d.status&&0===a.pendingRootTasks){var e=a.renderState;if((0!==a.allPendingTasks||null!==a.trackedPostpones)&&e.externalRuntimeScript){var f=e.externalRuntimeScript,g=a.resumableState,h=f.src,k=f.chunks;g.scriptResources.hasOwnProperty(h)||(g.scriptResources[h]=null,e.scripts.add(k))}var l=e.htmlChunks,n=e.headChunks;f=0;if(l){for(f=0;f<l.length;f++)b.push(l[f]);if(n)for(f=0;f<n.length;f++)b.push(n[f]);else{var q=L("head");b.push(q);
-b.push(">")}}else if(n)for(f=0;f<n.length;f++)b.push(n[f]);var m=e.charsetChunks;for(f=0;f<m.length;f++)b.push(m[f]);m.length=0;e.preconnects.forEach(M,b);e.preconnects.clear();var B=e.preconnectChunks;for(f=0;f<B.length;f++)b.push(B[f]);B.length=0;e.fontPreloads.forEach(M,b);e.fontPreloads.clear();e.highImagePreloads.forEach(M,b);e.highImagePreloads.clear();e.styles.forEach(rc,b);var C=e.importMapChunks;for(f=0;f<C.length;f++)b.push(C[f]);C.length=0;e.bootstrapScripts.forEach(M,b);e.scripts.forEach(M,
-b);e.scripts.clear();e.bulkPreloads.forEach(M,b);e.bulkPreloads.clear();var P=e.preloadChunks;for(f=0;f<P.length;f++)b.push(P[f]);P.length=0;var u=e.hoistableChunks;for(f=0;f<u.length;f++)b.push(u[f]);u.length=0;if(l&&null===n){var z=Mb("head");b.push(z)}ef(a,b,d);a.completedRootSegment=null;Ub(b,a.renderState)}else return;var p=a.renderState;d=0;p.preconnects.forEach(M,b);p.preconnects.clear();var Z=p.preconnectChunks;for(d=0;d<Z.length;d++)b.push(Z[d]);Z.length=0;p.fontPreloads.forEach(M,b);p.fontPreloads.clear();
-p.highImagePreloads.forEach(M,b);p.highImagePreloads.clear();p.styles.forEach(tc,b);p.scripts.forEach(M,b);p.scripts.clear();p.bulkPreloads.forEach(M,b);p.bulkPreloads.clear();var t=p.preloadChunks;for(d=0;d<t.length;d++)b.push(t[d]);t.length=0;var T=p.hoistableChunks;for(d=0;d<T.length;d++)b.push(T[d]);T.length=0;var D=a.clientRenderedBoundaries;for(c=0;c<D.length;c++){var A=D[c];p=b;var v=a.resumableState,Pa=a.renderState,qb=A.rootSegmentID,Ba=A.errorDigest,ka=A.errorMessage,da=A.errorComponentStack,
-U=0===v.streamingFormat;U?(p.push(Pa.startInlineScript),0===(v.instructions&4)?(v.instructions|=4,p.push('$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};;$RX("')):p.push('$RX("')):p.push('<template data-rxi="" data-bid="');p.push(Pa.boundaryPrefix);var Qa=qb.toString(16);p.push(Qa);U&&p.push('"');if(Ba||ka||da)if(U){p.push(",");var Ra=hc(Ba||"");p.push(Ra)}else{p.push('" data-dgst="');
-var Sa=x(Ba||"");p.push(Sa)}if(ka||da)if(U){p.push(",");var la=hc(ka||"");p.push(la)}else{p.push('" data-msg="');var N=x(ka||"");p.push(N)}if(da)if(U){p.push(",");var rb=hc(da);p.push(rb)}else{p.push('" data-stck="');var ma=x(da);p.push(ma)}if(U?!p.push(")\x3c/script>"):!p.push('"></template>')){a.destination=null;c++;D.splice(0,c);return}}D.splice(0,c);var na=a.completedBoundaries;for(c=0;c<na.length;c++)if(!gf(a,b,na[c])){a.destination=null;c++;na.splice(0,c);return}na.splice(0,c);var aa=a.partialBoundaries;
-for(c=0;c<aa.length;c++){var oa=aa[c];a:{D=a;A=b;D.renderState.boundaryResources=oa.resources;var pa=oa.completedSegments;for(v=0;v<pa.length;v++)if(!hf(D,A,oa,pa[v])){v++;pa.splice(0,v);var Ta=!1;break a}pa.splice(0,v);Ta=oc(A,oa.resources,D.renderState)}if(!Ta){a.destination=null;c++;aa.splice(0,c);return}}aa.splice(0,c);var qa=a.completedBoundaries;for(c=0;c<qa.length;c++)if(!gf(a,b,qa[c])){a.destination=null;c++;qa.splice(0,c);return}qa.splice(0,c)}finally{0===a.allPendingTasks&&0===a.pingedTasks.length&&
-0===a.clientRenderedBoundaries.length&&0===a.completedBoundaries.length&&(a.flushScheduled=!1,null===a.trackedPostpones&&(c=a.resumableState,c.hasBody&&(aa=Mb("body"),b.push(aa)),c.hasHtml&&(c=Mb("html"),b.push(c))),b.push(null),a.destination=null)}}function jf(a){a.flushScheduled=null!==a.destination;Je(a);null===a.trackedPostpones&&Dc(a.renderState,a.resumableState,0===a.pendingRootTasks)}
-function yc(a){if(!1===a.flushScheduled&&0===a.pingedTasks.length&&null!==a.destination){a.flushScheduled=!0;var b=a.destination;b?cf(a,b):a.flushScheduled=!1}}function kf(a,b){if(1===a.status)a.status=2,b.destroy(a.fatalError);else if(2!==a.status&&null===a.destination){a.destination=b;try{cf(a,b)}catch(c){W(a,c),Me(a,c)}}}
-function lf(a,b){try{var c=a.abortableTasks;if(0<c.size){var d=void 0===b?Error("The render was aborted by the server without a reason."):b;c.forEach(function(e){return $e(e,a,d)});c.clear()}null!==a.destination&&cf(a,a.destination)}catch(e){W(a,e),Me(a,e)}}function We(a,b,c){if(null===b)c.rootNodes.push(a);else{var d=c.workingMap,e=d.get(b);void 0===e&&(e=[b[1],b[2],[],null],d.set(b,e),We(e,b[0],c));e[2].push(a)}}function mf(){}
-function nf(a,b,c,d){var e=!1,f=null,g="",h=!1;b=mb(b?b.identifierPrefix:void 0,void 0);a=Fe(a,b,Ec(b,c),nb(),Infinity,mf,void 0,function(){h=!0},void 0,void 0,void 0);jf(a);lf(a,d);kf(a,{push:function(k){null!==k&&(g+=k);return!0},destroy:function(k){e=!0;f=k}});if(e&&f!==d)throw f;if(!h)throw Error("A component suspended while responding to synchronous input. This will cause the UI to be replaced with a loading indicator. To fix, updates that suspend should be wrapped with startTransition.");return g}
-function of(a,b){a.prototype=Object.create(b.prototype);a.prototype.constructor=a;a.__proto__=b}var pf=function(a){function b(){var d=a.call(this,{})||this;d.request=null;d.startedFlowing=!1;return d}of(b,a);var c=b.prototype;c._destroy=function(d,e){lf(this.request);e(d)};c._read=function(){this.startedFlowing&&kf(this.request,this)};return b}(ia.Readable);function qf(){}
-function rf(a,b){var c=new pf;b=mb(b?b.identifierPrefix:void 0,void 0);var d=Fe(a,b,Ec(b,!1),nb(),Infinity,qf,function(){c.startedFlowing=!0;kf(d,c)},void 0,void 0,void 0);c.request=d;jf(d);return c}exports.renderToNodeStream=function(a,b){return rf(a,b)};exports.renderToStaticMarkup=function(a,b){return nf(a,b,!0,'The server used "renderToStaticMarkup" which does not support Suspense. If you intended to have the server wait for the suspended component please switch to "renderToPipeableStream" which supports Suspense on the server')};
-exports.renderToStaticNodeStream=function(a,b){return rf(a,b)};exports.renderToString=function(a,b){return nf(a,b,!1,'The server used "renderToString" which does not support Suspense. If you intended for this Suspense boundary to render the fallback content on the server consider throwing an Error somewhere within the Suspense boundary. If you intended to have the server wait for the suspended component please switch to "renderToPipeableStream" which supports Suspense on the server')};
-exports.version="18.3.0-experimental-2983249dd-20231107";
+function ef(a,b){try{var c,d=a.completedRootSegment;if(null!==d)if(5!==d.status&&0===a.pendingRootTasks){var e=a.renderState;if((0!==a.allPendingTasks||null!==a.trackedPostpones)&&e.externalRuntimeScript){var f=e.externalRuntimeScript,g=a.resumableState,h=f.src,k=f.chunks;g.scriptResources.hasOwnProperty(h)||(g.scriptResources[h]=null,e.scripts.add(k))}var l=e.htmlChunks,n=e.headChunks;f=0;if(l){for(f=0;f<l.length;f++)b.push(l[f]);if(n)for(f=0;f<n.length;f++)b.push(n[f]);else{var r=N("head");b.push(r);
+b.push(">")}}else if(n)for(f=0;f<n.length;f++)b.push(n[f]);var m=e.charsetChunks;for(f=0;f<m.length;f++)b.push(m[f]);m.length=0;e.preconnects.forEach(O,b);e.preconnects.clear();var B=e.preconnectChunks;for(f=0;f<B.length;f++)b.push(B[f]);B.length=0;e.fontPreloads.forEach(O,b);e.fontPreloads.clear();e.highImagePreloads.forEach(O,b);e.highImagePreloads.clear();e.styles.forEach(tc,b);var E=e.importMapChunks;for(f=0;f<E.length;f++)b.push(E[f]);E.length=0;e.bootstrapScripts.forEach(O,b);e.scripts.forEach(O,
+b);e.scripts.clear();e.bulkPreloads.forEach(O,b);e.bulkPreloads.clear();var P=e.preloadChunks;for(f=0;f<P.length;f++)b.push(P[f]);P.length=0;var v=e.hoistableChunks;for(f=0;f<v.length;f++)b.push(v[f]);v.length=0;if(l&&null===n){var t=Ob("head");b.push(t)}gf(a,b,d);a.completedRootSegment=null;Wb(b,a.renderState,a.resumableState)}else return;var p=a.renderState;d=0;p.preconnects.forEach(O,b);p.preconnects.clear();var G=p.preconnectChunks;for(d=0;d<G.length;d++)b.push(G[d]);G.length=0;p.fontPreloads.forEach(O,
+b);p.fontPreloads.clear();p.highImagePreloads.forEach(O,b);p.highImagePreloads.clear();p.styles.forEach(vc,b);p.scripts.forEach(O,b);p.scripts.clear();p.bulkPreloads.forEach(O,b);p.bulkPreloads.clear();var u=p.preloadChunks;for(d=0;d<u.length;d++)b.push(u[d]);u.length=0;var w=p.hoistableChunks;for(d=0;d<w.length;d++)b.push(w[d]);w.length=0;var D=a.clientRenderedBoundaries;for(c=0;c<D.length;c++){var C=D[c];p=b;var x=a.resumableState,Pa=a.renderState,qb=C.rootSegmentID,Ba=C.errorDigest,ka=C.errorMessage,
+da=C.errorComponentStack,V=0===x.streamingFormat;V?(p.push(Pa.startInlineScript),0===(x.instructions&4)?(x.instructions|=4,p.push('$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};;$RX("')):p.push('$RX("')):p.push('<template data-rxi="" data-bid="');p.push(Pa.boundaryPrefix);var Qa=qb.toString(16);p.push(Qa);V&&p.push('"');if(Ba||ka||da)if(V){p.push(",");var Ra=jc(Ba||"");
+p.push(Ra)}else{p.push('" data-dgst="');var Sa=z(Ba||"");p.push(Sa)}if(ka||da)if(V){p.push(",");var la=jc(ka||"");p.push(la)}else{p.push('" data-msg="');var Q=z(ka||"");p.push(Q)}if(da)if(V){p.push(",");var rb=jc(da);p.push(rb)}else{p.push('" data-stck="');var ma=z(da);p.push(ma)}if(V?!p.push(")\x3c/script>"):!p.push('"></template>')){a.destination=null;c++;D.splice(0,c);return}}D.splice(0,c);var na=a.completedBoundaries;for(c=0;c<na.length;c++)if(!jf(a,b,na[c])){a.destination=null;c++;na.splice(0,
+c);return}na.splice(0,c);var aa=a.partialBoundaries;for(c=0;c<aa.length;c++){var oa=aa[c];a:{D=a;C=b;D.renderState.boundaryResources=oa.resources;var pa=oa.completedSegments;for(x=0;x<pa.length;x++)if(!kf(D,C,oa,pa[x])){x++;pa.splice(0,x);var Ta=!1;break a}pa.splice(0,x);Ta=qc(C,oa.resources,D.renderState)}if(!Ta){a.destination=null;c++;aa.splice(0,c);return}}aa.splice(0,c);var qa=a.completedBoundaries;for(c=0;c<qa.length;c++)if(!jf(a,b,qa[c])){a.destination=null;c++;qa.splice(0,c);return}qa.splice(0,
+c)}finally{0===a.allPendingTasks&&0===a.pingedTasks.length&&0===a.clientRenderedBoundaries.length&&0===a.completedBoundaries.length&&(a.flushScheduled=!1,null===a.trackedPostpones&&(c=a.resumableState,c.hasBody&&(aa=Ob("body"),b.push(aa)),c.hasHtml&&(c=Ob("html"),b.push(c))),b.push(null),a.destination=null)}}function lf(a){a.flushScheduled=null!==a.destination;Le(a);null===a.trackedPostpones&&Fc(a.renderState,a.resumableState,0===a.pendingRootTasks)}
+function Ac(a){if(!1===a.flushScheduled&&0===a.pingedTasks.length&&null!==a.destination){a.flushScheduled=!0;var b=a.destination;b?ef(a,b):a.flushScheduled=!1}}function mf(a,b){if(1===a.status)a.status=2,b.destroy(a.fatalError);else if(2!==a.status&&null===a.destination){a.destination=b;try{ef(a,b)}catch(c){X(a,c),Oe(a,c)}}}
+function nf(a,b){try{var c=a.abortableTasks;if(0<c.size){var d=void 0===b?Error("The render was aborted by the server without a reason."):b;c.forEach(function(e){return bf(e,a,d)});c.clear()}null!==a.destination&&ef(a,a.destination)}catch(e){X(a,e),Oe(a,e)}}function Ye(a,b,c){if(null===b)c.rootNodes.push(a);else{var d=c.workingMap,e=d.get(b);void 0===e&&(e=[b[1],b[2],[],null],d.set(b,e),Ye(e,b[0],c));e[2].push(a)}}function of(){}
+function pf(a,b,c,d){var e=!1,f=null,g="",h=!1;b=ob(b?b.identifierPrefix:void 0,void 0);a=He(a,b,Gc(b,c),pb(),Infinity,of,void 0,function(){h=!0},void 0,void 0,void 0);lf(a);nf(a,d);mf(a,{push:function(k){null!==k&&(g+=k);return!0},destroy:function(k){e=!0;f=k}});if(e&&f!==d)throw f;if(!h)throw Error("A component suspended while responding to synchronous input. This will cause the UI to be replaced with a loading indicator. To fix, updates that suspend should be wrapped with startTransition.");return g}
+function qf(a,b){a.prototype=Object.create(b.prototype);a.prototype.constructor=a;a.__proto__=b}var rf=function(a){function b(){var d=a.call(this,{})||this;d.request=null;d.startedFlowing=!1;return d}qf(b,a);var c=b.prototype;c._destroy=function(d,e){nf(this.request);e(d)};c._read=function(){this.startedFlowing&&mf(this.request,this)};return b}(ia.Readable);function sf(){}
+function tf(a,b){var c=new rf;b=ob(b?b.identifierPrefix:void 0,void 0);var d=He(a,b,Gc(b,!1),pb(),Infinity,sf,function(){c.startedFlowing=!0;mf(d,c)},void 0,void 0,void 0);c.request=d;lf(d);return c}exports.renderToNodeStream=function(a,b){return tf(a,b)};exports.renderToStaticMarkup=function(a,b){return pf(a,b,!0,'The server used "renderToStaticMarkup" which does not support Suspense. If you intended to have the server wait for the suspended component please switch to "renderToPipeableStream" which supports Suspense on the server')};
+exports.renderToStaticNodeStream=function(a,b){return tf(a,b)};exports.renderToString=function(a,b){return pf(a,b,!1,'The server used "renderToString" which does not support Suspense. If you intended for this Suspense boundary to render the fallback content on the server consider throwing an Error somewhere within the Suspense boundary. If you intended to have the server wait for the suspended component please switch to "renderToPipeableStream" which supports Suspense on the server')};
+exports.version="18.3.0-experimental-7508dcd5c-20231108";
+
+//# sourceMappingURL=react-dom-server-legacy.node.production.min.js.map
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-rendering-stub.development.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-rendering-stub.development.js
index 4fed3a5300c3e..951d67d515d00 100644
--- a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-rendering-stub.development.js
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-rendering-stub.development.js
@@ -55,7 +55,7 @@ function printWarning(level, format, args) {
   }
 }
 
-var ReactVersion = '18.3.0-experimental-2983249dd-20231107';
+var ReactVersion = '18.3.0-experimental-7508dcd5c-20231108';
 
 var Internals = {
   usingClientEntryPoint: false,
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-rendering-stub.production.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-rendering-stub.production.js
new file mode 100644
index 0000000000000..59a3f72e9f3e0
--- /dev/null
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-rendering-stub.production.js
@@ -0,0 +1,243 @@
+/**
+ * @license React
+ * react-dom-server-rendering-stub.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require("next/dist/compiled/react-experimental");
+
+var ReactVersion = '18.3.0-experimental-7508dcd5c-20231108';
+
+const Internals = {
+  usingClientEntryPoint: false,
+  Events: null,
+  Dispatcher: {
+    current: null
+  }
+};
+
+// Do not require this module directly! Use normal `invariant` calls with
+// template literal strings. The messages will be replaced with error codes
+// during build.
+function formatProdErrorMessage(code) {
+  let url = 'https://reactjs.org/docs/error-decoder.html?invariant=' + code;
+
+  for (let i = 1; i < arguments.length; i++) {
+    url += '&args[]=' + encodeURIComponent(arguments[i]);
+  }
+
+  return "Minified React error #" + code + "; visit " + url + " for the full message or " + 'use the non-minified dev environment for full errors and additional ' + 'helpful warnings.';
+}
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+function getCrossOriginStringAs(as, input) {
+  if (as === 'font') {
+    return '';
+  }
+
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+const Dispatcher = Internals.Dispatcher;
+function prefetchDNS(href) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    dispatcher.prefetchDNS(href);
+  } // We don't error because preconnect needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preconnect(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    const crossOrigin = options ? getCrossOriginString(options.crossOrigin) : null;
+    dispatcher.preconnect(href, crossOrigin);
+  } // We don't error because preconnect needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preload(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string' && // We check existence because we cannot enforce this function is actually called with the stated type
+  typeof options === 'object' && options !== null && typeof options.as === 'string') {
+    const as = options.as;
+    const crossOrigin = getCrossOriginStringAs(as, options.crossOrigin);
+    dispatcher.preload(href, as, {
+      crossOrigin,
+      integrity: typeof options.integrity === 'string' ? options.integrity : undefined,
+      nonce: typeof options.nonce === 'string' ? options.nonce : undefined,
+      type: typeof options.type === 'string' ? options.type : undefined,
+      fetchPriority: typeof options.fetchPriority === 'string' ? options.fetchPriority : undefined,
+      referrerPolicy: typeof options.referrerPolicy === 'string' ? options.referrerPolicy : undefined,
+      imageSrcSet: typeof options.imageSrcSet === 'string' ? options.imageSrcSet : undefined,
+      imageSizes: typeof options.imageSizes === 'string' ? options.imageSizes : undefined
+    });
+  } // We don't error because preload needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preloadModule(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    if (options) {
+      const crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);
+      dispatcher.preloadModule(href, {
+        as: typeof options.as === 'string' && options.as !== 'script' ? options.as : undefined,
+        crossOrigin,
+        integrity: typeof options.integrity === 'string' ? options.integrity : undefined
+      });
+    } else {
+      dispatcher.preloadModule(href);
+    }
+  } // We don't error because preload needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preinit(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string' && options && typeof options.as === 'string') {
+    const as = options.as;
+    const crossOrigin = getCrossOriginStringAs(as, options.crossOrigin);
+    const integrity = typeof options.integrity === 'string' ? options.integrity : undefined;
+    const fetchPriority = typeof options.fetchPriority === 'string' ? options.fetchPriority : undefined;
+
+    if (as === 'style') {
+      dispatcher.preinitStyle(href, typeof options.precedence === 'string' ? options.precedence : undefined, {
+        crossOrigin,
+        integrity,
+        fetchPriority
+      });
+    } else if (as === 'script') {
+      dispatcher.preinitScript(href, {
+        crossOrigin,
+        integrity,
+        fetchPriority,
+        nonce: typeof options.nonce === 'string' ? options.nonce : undefined
+      });
+    }
+  } // We don't error because preinit needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preinitModule(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    if (typeof options === 'object' && options !== null) {
+      if (options.as == null || options.as === 'script') {
+        const crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);
+        dispatcher.preinitModuleScript(href, {
+          crossOrigin,
+          integrity: typeof options.integrity === 'string' ? options.integrity : undefined,
+          nonce: typeof options.nonce === 'string' ? options.nonce : undefined
+        });
+      }
+    } else if (options == null) {
+      dispatcher.preinitModuleScript(href);
+    }
+  } // We don't error because preinit needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher; // Since the "not pending" value is always the same, we can reuse the
+
+function resolveDispatcher() {
+  // Copied from react/src/ReactHooks.js. It's the same thing but in a
+  // different package.
+  const dispatcher = ReactCurrentDispatcher.current;
+  // intentionally don't throw our own error because this is in a hot path.
+  // Also helps ensure this is inlined.
+
+
+  return dispatcher;
+}
+
+function useFormStatus() {
+  {
+    const dispatcher = resolveDispatcher(); // $FlowFixMe[not-a-function] We know this exists because of the feature check above.
+
+    return dispatcher.useHostTransitionStatus();
+  }
+}
+function useFormState(action, initialState, permalink) {
+  {
+    const dispatcher = resolveDispatcher(); // $FlowFixMe[not-a-function] This is unstable, thus optional
+
+    return dispatcher.useFormState(action, initialState, permalink);
+  }
+}
+
+function createPortal() {
+  throw Error(formatProdErrorMessage(448));
+}
+function flushSync() {
+  throw Error(formatProdErrorMessage(449));
+} // on the server we just call the callback because there is
+// not update mechanism. Really this should not be called on the
+// server but since the semantics are generally clear enough we
+// can provide this trivial implementation.
+
+function batchedUpdates(fn, a) {
+  return fn(a);
+}
+
+// Export all exports so that they're available in tests.
+function experimental_useFormStatus() {
+
+  return useFormStatus();
+}
+function experimental_useFormState(action, initialState, permalink) {
+
+  return useFormState(action, initialState, permalink);
+}
+
+exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = Internals;
+exports.createPortal = createPortal;
+exports.experimental_useFormState = experimental_useFormState;
+exports.experimental_useFormStatus = experimental_useFormStatus;
+exports.flushSync = flushSync;
+exports.preconnect = preconnect;
+exports.prefetchDNS = prefetchDNS;
+exports.preinit = preinit;
+exports.preinitModule = preinitModule;
+exports.preload = preload;
+exports.preloadModule = preloadModule;
+exports.unstable_batchedUpdates = batchedUpdates;
+exports.useFormState = useFormState;
+exports.useFormStatus = useFormStatus;
+exports.version = ReactVersion;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-rendering-stub.production.min.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-rendering-stub.production.min.js
index 6bdbe745c6ad4..d15febb3b557d 100644
--- a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-rendering-stub.production.min.js
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-rendering-stub.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-dom-server-rendering-stub.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-dom-server-rendering-stub.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var e=require("next/dist/compiled/react-experimental"),f={usingClientEntryPoint:!1,Events:null,Dispatcher:{current:null}};function h(b){for(var a="https://reactjs.org/docs/error-decoder.html?invariant="+b,c=1;c<arguments.length;c++)a+="&args[]="+encodeURIComponent(arguments[c]);return"Minified React error #"+b+"; visit "+a+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}
 function k(b,a){if("font"===b)return"";if("string"===typeof a)return"use-credentials"===a?a:""}var l=f.Dispatcher,m=e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentDispatcher;function n(){return m.current.useHostTransitionStatus()}function r(b,a,c){return m.current.useFormState(b,a,c)}exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=f;exports.createPortal=function(){throw Error(h(448));};exports.experimental_useFormState=function(b,a,c){return r(b,a,c)};
 exports.experimental_useFormStatus=function(){return n()};exports.flushSync=function(){throw Error(h(449));};exports.preconnect=function(b,a){var c=l.current;c&&"string"===typeof b&&(a?(a=a.crossOrigin,a="string"===typeof a?"use-credentials"===a?a:"":void 0):a=null,c.preconnect(b,a))};exports.prefetchDNS=function(b){var a=l.current;a&&"string"===typeof b&&a.prefetchDNS(b)};
@@ -14,4 +14,6 @@ exports.preinit=function(b,a){var c=l.current;if(c&&"string"===typeof b&&a&&"str
 exports.preinitModule=function(b,a){var c=l.current;if(c&&"string"===typeof b)if("object"===typeof a&&null!==a){if(null==a.as||"script"===a.as){var d=k(a.as,a.crossOrigin);c.preinitModuleScript(b,{crossOrigin:d,integrity:"string"===typeof a.integrity?a.integrity:void 0,nonce:"string"===typeof a.nonce?a.nonce:void 0})}}else null==a&&c.preinitModuleScript(b)};
 exports.preload=function(b,a){var c=l.current;if(c&&"string"===typeof b&&"object"===typeof a&&null!==a&&"string"===typeof a.as){var d=a.as,g=k(d,a.crossOrigin);c.preload(b,d,{crossOrigin:g,integrity:"string"===typeof a.integrity?a.integrity:void 0,nonce:"string"===typeof a.nonce?a.nonce:void 0,type:"string"===typeof a.type?a.type:void 0,fetchPriority:"string"===typeof a.fetchPriority?a.fetchPriority:void 0,referrerPolicy:"string"===typeof a.referrerPolicy?a.referrerPolicy:void 0,imageSrcSet:"string"===
 typeof a.imageSrcSet?a.imageSrcSet:void 0,imageSizes:"string"===typeof a.imageSizes?a.imageSizes:void 0})}};exports.preloadModule=function(b,a){var c=l.current;if(c&&"string"===typeof b)if(a){var d=k(a.as,a.crossOrigin);c.preloadModule(b,{as:"string"===typeof a.as&&"script"!==a.as?a.as:void 0,crossOrigin:d,integrity:"string"===typeof a.integrity?a.integrity:void 0})}else c.preloadModule(b)};exports.unstable_batchedUpdates=function(b,a){return b(a)};exports.useFormState=r;exports.useFormStatus=n;
-exports.version="18.3.0-experimental-2983249dd-20231107";
+exports.version="18.3.0-experimental-7508dcd5c-20231108";
+
+//# sourceMappingURL=react-dom-server-rendering-stub.production.min.js.map
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.browser.development.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.browser.development.js
index b129d46d3097b..a41fef465bf4b 100644
--- a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.browser.development.js
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.browser.development.js
@@ -17,7 +17,7 @@ if (process.env.NODE_ENV !== "production") {
 var React = require("next/dist/compiled/react-experimental");
 var ReactDOM = require('react-dom');
 
-var ReactVersion = '18.3.0-experimental-2983249dd-20231107';
+var ReactVersion = '18.3.0-experimental-7508dcd5c-20231108';
 
 var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
 
@@ -1816,11 +1816,14 @@ var DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS = 2000; // Allows us to keep tr
 // if passed externalRuntimeConfig and the enableFizzExternalRuntime feature flag
 // is set, the server will send instructions via data attributes (instead of inline scripts)
 
-function createRenderState(resumableState, nonce, bootstrapScriptContent, bootstrapScripts, bootstrapModules, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
+function createRenderState(resumableState, nonce, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
   var inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
   var idPrefix = resumableState.idPrefix;
   var bootstrapChunks = [];
   var externalRuntimeScript = null;
+  var bootstrapScriptContent = resumableState.bootstrapScriptContent,
+      bootstrapScripts = resumableState.bootstrapScripts,
+      bootstrapModules = resumableState.bootstrapModules;
 
   if (bootstrapScriptContent !== undefined) {
     bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapAndImportMapScriptContent(bootstrapScriptContent)), endInlineScript);
@@ -2010,10 +2013,9 @@ function createRenderState(resumableState, nonce, bootstrapScriptContent, bootst
   return renderState;
 }
 function resumeRenderState(resumableState, nonce) {
-  return createRenderState(resumableState, nonce, // These should have already been flushed in the prerender.
-  undefined, undefined, undefined, undefined, undefined, undefined);
+  return createRenderState(resumableState, nonce, undefined, undefined, undefined, undefined);
 }
-function createResumableState(identifierPrefix, externalRuntimeConfig) {
+function createResumableState(identifierPrefix, externalRuntimeConfig, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
   var idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
   var streamingFormat = ScriptStreamingFormat;
 
@@ -2027,6 +2029,9 @@ function createResumableState(identifierPrefix, externalRuntimeConfig) {
     idPrefix: idPrefix,
     nextFormID: 0,
     streamingFormat: streamingFormat,
+    bootstrapScriptContent: bootstrapScriptContent,
+    bootstrapScripts: bootstrapScripts,
+    bootstrapModules: bootstrapModules,
     instructions: NothingSent,
     hasBody: false,
     hasHtml: false,
@@ -4512,7 +4517,10 @@ function pushEndInstance(target, type, props, resumableState, formatContext) {
   target.push(endChunkForTag(type));
 }
 
-function writeBootstrap(destination, renderState) {
+function writeBootstrap(destination, renderState, resumableState) {
+  resumableState.bootstrapScriptContent = undefined;
+  resumableState.bootstrapScripts = undefined;
+  resumableState.bootstrapModules = undefined;
   var bootstrapChunks = renderState.bootstrapChunks;
   var i = 0;
 
@@ -4529,8 +4537,8 @@ function writeBootstrap(destination, renderState) {
   return true;
 }
 
-function writeCompletedRoot(destination, renderState) {
-  return writeBootstrap(destination, renderState);
+function writeCompletedRoot(destination, renderState, resumableState) {
+  return writeBootstrap(destination, renderState, resumableState);
 } // Structural Nodes
 // A placeholder is a node inside a hidden partial tree that can be filled in later, but before
 // display. It's never visible to users. We use the template tag because it can be used in every
@@ -4887,7 +4895,7 @@ function writeCompletedBoundaryInstruction(destination, resumableState, renderSt
     writeMore = writeChunkAndReturn(destination, completeBoundaryDataEnd);
   }
 
-  return writeBootstrap(destination, renderState) && writeMore;
+  return writeBootstrap(destination, renderState, resumableState) && writeMore;
 }
 var clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
 var clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
@@ -6893,6 +6901,18 @@ var componentFrameCache;
   var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
   componentFrameCache = new PossiblyWeakMap();
 }
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
@@ -6908,7 +6928,6 @@ function describeNativeComponentFrame(fn, construct) {
     }
   }
 
-  var control;
   reentry = true;
   var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
 
@@ -6922,81 +6941,140 @@ function describeNativeComponentFrame(fn, construct) {
     ReactCurrentDispatcher$1.current = null;
     disableLogs();
   }
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
 
-  try {
-    // This should throw.
-    if (construct) {
-      // Something should be setting the props in the constructor.
-      var Fake = function () {
-        throw Error();
-      }; // $FlowFixMe[prop-missing]
 
+  var RunInRootFrame = {
+    DetermineComponentFrameRoot: function () {
+      var control;
 
-      Object.defineProperty(Fake.prototype, 'props', {
-        set: function () {
-          // We use a throwing setter instead of frozen or non-writable props
-          // because that won't throw in a non-strict mode function.
-          throw Error();
-        }
-      });
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          var Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
 
-      if (typeof Reflect === 'object' && Reflect.construct) {
-        // We construct a different control for this case to include any extra
-        // frames added by the construct call.
-        try {
-          Reflect.construct(Fake, []);
-        } catch (x) {
-          control = x;
-        }
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
 
-        Reflect.construct(fn, [], Fake);
-      } else {
-        try {
-          Fake.call();
-        } catch (x) {
-          control = x;
-        } // $FlowFixMe[prop-missing] found when upgrading Flow
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
 
 
-        fn.call(Fake.prototype);
-      }
-    } else {
-      try {
-        throw Error();
-      } catch (x) {
-        control = x;
-      } // TODO(luna): This will currently only throw if the function component
-      // tries to access React/ReactDOM/props. We should probably make this throw
-      // in simple components too
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
 
 
-      var maybePromise = fn(); // If the function component returns a promise, it's likely an async
-      // component, which we don't yet support. Attach a noop catch handler to
-      // silence the error.
-      // TODO: Implement component stacks for async client components?
+          var maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
 
-      if (maybePromise && typeof maybePromise.catch === 'function') {
-        maybePromise.catch(function () {});
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(function () {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
       }
+
+      return [null, null];
     }
-  } catch (sample) {
-    // This is inlined manually because closure doesn't do it for us.
-    if (sample && control && typeof sample.stack === 'string') {
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
+
+  try {
+    var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
+
+    if (sampleStack && controlStack) {
       // This extracts the first frame from the sample that isn't also in the control.
       // Skipping one frame that we assume is the frame that calls the two.
-      var sampleLines = sample.stack.split('\n');
-      var controlLines = control.stack.split('\n');
-      var s = sampleLines.length - 1;
-      var c = controlLines.length - 1;
-
-      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
-        // We expect at least one stack frame to be shared.
-        // Typically this will be the root most one. However, stack frames may be
-        // cut off due to maximum stack limits. In this case, one maybe cut off
-        // earlier than the other. We assume that the sample is longer or the same
-        // and there for cut off earlier. So we should find the root most frame in
-        // the sample somewhere in the control.
-        c--;
+      var sampleLines = sampleStack.split('\n');
+      var controlLines = controlStack.split('\n');
+      var s = 0;
+      var c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
       }
 
       for (; s >= 1 && c >= 0; s--, c--) {
@@ -7025,7 +7103,7 @@ function describeNativeComponentFrame(fn, construct) {
                   _frame = _frame.replace('<anonymous>', fn.displayName);
                 }
 
-                {
+                if (true) {
                   if (typeof fn === 'function') {
                     componentFrameCache.set(fn, _frame);
                   }
@@ -11696,7 +11774,7 @@ function flushCompletedQueues(request, destination) {
 
         flushSegment(request, destination, completedRootSegment);
         request.completedRootSegment = null;
-        writeCompletedRoot(destination, request.renderState);
+        writeCompletedRoot(destination, request.renderState, request.resumableState);
       } else {
         // We haven't flushed the root yet so we don't need to check any other branches further down
         return;
@@ -12012,8 +12090,8 @@ function renderToReadableStream(children, options) {
       };
     }
 
-    var resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined);
-    var request = createRequest(children, resumableState, createRenderState(resumableState, options ? options.nonce : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, onHeadersImpl, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, onShellReady, onShellError, onFatalError, options ? options.onPostpone : undefined, options ? options.formState : undefined);
+    var resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined);
+    var request = createRequest(children, resumableState, createRenderState(resumableState, options ? options.nonce : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, onHeadersImpl, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, onShellReady, onShellError, onFatalError, options ? options.onPostpone : undefined, options ? options.formState : undefined);
 
     if (options && options.signal) {
       var signal = options.signal;
@@ -12125,9 +12203,9 @@ function prerender(children, options) {
       };
     }
 
-    var resources = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined);
+    var resources = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined);
     var request = createPrerenderRequest(children, resources, createRenderState(resources, undefined, // nonce is not compatible with prerendered bootstrap scripts
-    options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, onHeadersImpl, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, undefined, undefined, onFatalError, options ? options.onPostpone : undefined);
+    options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, onHeadersImpl, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, undefined, undefined, onFatalError, options ? options.onPostpone : undefined);
 
     if (options && options.signal) {
       var signal = options.signal;
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.browser.production.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.browser.production.js
new file mode 100644
index 0000000000000..bf271e98ccc66
--- /dev/null
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.browser.production.js
@@ -0,0 +1,9107 @@
+/**
+ * @license React
+ * react-dom-server.browser.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require("next/dist/compiled/react-experimental");
+var ReactDOM = require('react-dom');
+
+var ReactVersion = '18.3.0-experimental-7508dcd5c-20231108';
+
+// Do not require this module directly! Use normal `invariant` calls with
+// template literal strings. The messages will be replaced with error codes
+// during build.
+function formatProdErrorMessage(code) {
+  let url = 'https://reactjs.org/docs/error-decoder.html?invariant=' + code;
+
+  for (let i = 1; i < arguments.length; i++) {
+    url += '&args[]=' + encodeURIComponent(arguments[i]);
+  }
+
+  return "Minified React error #" + code + "; visit " + url + " for the full message or " + 'use the non-minified dev environment for full errors and additional ' + 'helpful warnings.';
+}
+
+// A pure JS implementation of a string hashing function. We do not use it for
+// security or obfuscation purposes, only to create compact hashes. So we
+// prioritize speed over collision avoidance. For example, we use this to hash
+// the component key path used by useFormState for MPA-style submissions.
+//
+// In environments where built-in hashing functions are available, we prefer
+// those instead. Like Node's crypto module, or Bun.hash. Unfortunately this
+// does not include the web standard crypto API because those methods are all
+// async. For our purposes, we need it to be sync because the cost of context
+// switching is too high to be worth it.
+//
+// The most popular hashing algorithm that meets these requirements in the JS
+// ecosystem is MurmurHash3, and almost all implementations I could find used
+// some version of the implementation by Gary Court inlined below.
+function createFastHashJS(key) {
+  return murmurhash3_32_gc(key, 0);
+}
+/* eslint-disable prefer-const, no-fallthrough */
+
+/**
+ * @license
+ *
+ * JS Implementation of MurmurHash3 (r136) (as of May 20, 2011)
+ *
+ * Copyright (c) 2011 Gary Court
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+function murmurhash3_32_gc(key, seed) {
+  let remainder, bytes, h1, h1b, c1, c2, k1, i;
+  remainder = key.length & 3; // key.length % 4
+
+  bytes = key.length - remainder;
+  h1 = seed;
+  c1 = 0xcc9e2d51;
+  c2 = 0x1b873593;
+  i = 0;
+
+  while (i < bytes) {
+    k1 = key.charCodeAt(i) & 0xff | (key.charCodeAt(++i) & 0xff) << 8 | (key.charCodeAt(++i) & 0xff) << 16 | (key.charCodeAt(++i) & 0xff) << 24;
+    ++i;
+    k1 = (k1 & 0xffff) * c1 + (((k1 >>> 16) * c1 & 0xffff) << 16) & 0xffffffff;
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = (k1 & 0xffff) * c2 + (((k1 >>> 16) * c2 & 0xffff) << 16) & 0xffffffff;
+    h1 ^= k1;
+    h1 = h1 << 13 | h1 >>> 19;
+    h1b = (h1 & 0xffff) * 5 + (((h1 >>> 16) * 5 & 0xffff) << 16) & 0xffffffff;
+    h1 = (h1b & 0xffff) + 0x6b64 + (((h1b >>> 16) + 0xe654 & 0xffff) << 16);
+  }
+
+  k1 = 0;
+
+  switch (remainder) {
+    case 3:
+      k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
+
+    case 2:
+      k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
+
+    case 1:
+      k1 ^= key.charCodeAt(i) & 0xff;
+      k1 = (k1 & 0xffff) * c1 + (((k1 >>> 16) * c1 & 0xffff) << 16) & 0xffffffff;
+      k1 = k1 << 15 | k1 >>> 17;
+      k1 = (k1 & 0xffff) * c2 + (((k1 >>> 16) * c2 & 0xffff) << 16) & 0xffffffff;
+      h1 ^= k1;
+  }
+
+  h1 ^= key.length;
+  h1 ^= h1 >>> 16;
+  h1 = (h1 & 0xffff) * 0x85ebca6b + (((h1 >>> 16) * 0x85ebca6b & 0xffff) << 16) & 0xffffffff;
+  h1 ^= h1 >>> 13;
+  h1 = (h1 & 0xffff) * 0xc2b2ae35 + (((h1 >>> 16) * 0xc2b2ae35 & 0xffff) << 16) & 0xffffffff;
+  h1 ^= h1 >>> 16;
+  return h1 >>> 0;
+}
+
+function scheduleWork(callback) {
+  callback();
+}
+const VIEW_SIZE = 512;
+let currentView = null;
+let writtenBytes = 0;
+function beginWriting(destination) {
+  currentView = new Uint8Array(VIEW_SIZE);
+  writtenBytes = 0;
+}
+function writeChunk(destination, chunk) {
+  if (chunk.byteLength === 0) {
+    return;
+  }
+
+  if (chunk.byteLength > VIEW_SIZE) {
+    // one that is cached by the streaming renderer. We will enqueu
+    // it directly and expect it is not re-used
+
+
+    if (writtenBytes > 0) {
+      destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    destination.enqueue(chunk);
+    return;
+  }
+
+  let bytesToWrite = chunk;
+  const allowableBytes = currentView.length - writtenBytes;
+
+  if (allowableBytes < bytesToWrite.byteLength) {
+    // this chunk would overflow the current view. We enqueue a full view
+    // and start a new view with the remaining chunk
+    if (allowableBytes === 0) {
+      // the current view is already full, send it
+      destination.enqueue(currentView);
+    } else {
+      // fill up the current view and apply the remaining chunk bytes
+      // to a new view.
+      currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes); // writtenBytes += allowableBytes; // this can be skipped because we are going to immediately reset the view
+
+      destination.enqueue(currentView);
+      bytesToWrite = bytesToWrite.subarray(allowableBytes);
+    }
+
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+
+  currentView.set(bytesToWrite, writtenBytes);
+  writtenBytes += bytesToWrite.byteLength;
+}
+function writeChunkAndReturn(destination, chunk) {
+  writeChunk(destination, chunk); // in web streams there is no backpressure so we can alwas write more
+
+  return true;
+}
+function completeWriting(destination) {
+  if (currentView && writtenBytes > 0) {
+    destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+    currentView = null;
+    writtenBytes = 0;
+  }
+}
+function close(destination) {
+  destination.close();
+}
+const textEncoder = new TextEncoder();
+function stringToChunk(content) {
+  return textEncoder.encode(content);
+}
+function stringToPrecomputedChunk(content) {
+  const precomputedChunk = textEncoder.encode(content);
+
+  return precomputedChunk;
+}
+function clonePrecomputedChunk(precomputedChunk) {
+  return precomputedChunk.byteLength > VIEW_SIZE ? precomputedChunk.slice() : precomputedChunk;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[method-unbinding]
+  if (typeof destination.error === 'function') {
+    // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+    destination.error(error);
+  } else {
+    // Earlier implementations doesn't support this method. In that environment you're
+    // supposed to throw from a promise returned but we don't return a promise in our
+    // approach. We could fork this implementation but this is environment is an edge
+    // case to begin with. It's even less common to run this in an older environment.
+    // Even then, this is not where errors are supposed to happen and they get reported
+    // to a global callback in addition to this anyway. So it's fine just to close this.
+    destination.close();
+  }
+}
+
+const assign = Object.assign;
+
+// -----------------------------------------------------------------------------
+const enableFloat = true; // Enables unstable_useMemoCache hook, intended as a compilation target for
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/* eslint-disable max-len */
+
+const ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
+/* eslint-enable max-len */
+
+const ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
+const VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+const illegalAttributeNameCache = {};
+const validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+  if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+    return true;
+  }
+
+  if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+    return false;
+  }
+
+  if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+    validatedAttributeNameCache[attributeName] = true;
+    return true;
+  }
+
+  illegalAttributeNameCache[attributeName] = true;
+
+  return false;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+const unitlessNumbers = new Set(['animationIterationCount', 'aspectRatio', 'borderImageOutset', 'borderImageSlice', 'borderImageWidth', 'boxFlex', 'boxFlexGroup', 'boxOrdinalGroup', 'columnCount', 'columns', 'flex', 'flexGrow', 'flexPositive', 'flexShrink', 'flexNegative', 'flexOrder', 'gridArea', 'gridRow', 'gridRowEnd', 'gridRowSpan', 'gridRowStart', 'gridColumn', 'gridColumnEnd', 'gridColumnSpan', 'gridColumnStart', 'fontWeight', 'lineClamp', 'lineHeight', 'opacity', 'order', 'orphans', 'scale', 'tabSize', 'widows', 'zIndex', 'zoom', 'fillOpacity', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'MozBoxFlexGroup', 'MozLineClamp', 'msAnimationIterationCount', 'msFlex', 'msZoom', 'msFlexGrow', 'msFlexNegative', 'msFlexOrder', 'msFlexPositive', 'msFlexShrink', 'msGridColumn', 'msGridColumnSpan', 'msGridRow', 'msGridRowSpan', 'WebkitAnimationIterationCount', 'WebkitBoxFlex', 'WebKitBoxFlexGroup', 'WebkitBoxOrdinalGroup', 'WebkitColumnCount', 'WebkitColumns', 'WebkitFlex', 'WebkitFlexGrow', 'WebkitFlexPositive', 'WebkitFlexShrink', 'WebkitLineClamp']);
+function isUnitlessNumber (name) {
+  return unitlessNumbers.has(name);
+}
+
+const aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+  return aliases.get(name) || name;
+}
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// code copied and modified from escape-html
+const matchHtmlRegExp = /["'&<>]/;
+/**
+ * Escapes special characters and HTML entities in a given html string.
+ *
+ * @param  {string} string HTML string to escape for later insertion
+ * @return {string}
+ * @public
+ */
+
+function escapeHtml(string) {
+
+  const str = '' + string;
+  const match = matchHtmlRegExp.exec(str);
+
+  if (!match) {
+    return str;
+  }
+
+  let escape;
+  let html = '';
+  let index;
+  let lastIndex = 0;
+
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        // "
+        escape = '&quot;';
+        break;
+
+      case 38:
+        // &
+        escape = '&amp;';
+        break;
+
+      case 39:
+        // '
+        escape = '&#x27;'; // modified from escape-html; used to be '&#39'
+
+        break;
+
+      case 60:
+        // <
+        escape = '&lt;';
+        break;
+
+      case 62:
+        // >
+        escape = '&gt;';
+        break;
+
+      default:
+        continue;
+    }
+
+    if (lastIndex !== index) {
+      html += str.slice(lastIndex, index);
+    }
+
+    lastIndex = index + 1;
+    html += escape;
+  }
+
+  return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+} // end code copied and modified from escape-html
+
+/**
+ * Escapes text to prevent scripting attacks.
+ *
+ * @param {*} text Text value to escape.
+ * @return {string} An escaped string.
+ */
+
+
+function escapeTextForBrowser(text) {
+  if (typeof text === 'boolean' || typeof text === 'number') {
+    // this shortcircuit helps perf for types that we know will never have
+    // special characters, especially given that this function is used often
+    // for numeric dom ids.
+    return '' + text;
+  }
+
+  return escapeHtml(text);
+}
+
+const uppercasePattern = /([A-Z])/g;
+const msPattern = /^ms-/;
+/**
+ * Hyphenates a camelcased CSS property name, for example:
+ *
+ *   > hyphenateStyleName('backgroundColor')
+ *   < "background-color"
+ *   > hyphenateStyleName('MozTransition')
+ *   < "-moz-transition"
+ *   > hyphenateStyleName('msTransition')
+ *   < "-ms-transition"
+ *
+ * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
+ * is converted to `-ms-`.
+ */
+
+function hyphenateStyleName(name) {
+  return name.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern, '-ms-');
+}
+
+function sanitizeURL(url) {
+
+  return url;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+// The build script is at scripts/rollup/generate-inline-fizz-runtime.js.
+// Run `yarn generate-inline-fizz-runtime` to generate.
+const clientRenderBoundary = '$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};';
+const completeBoundary = '$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};';
+const completeBoundaryWithStyles = '$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};';
+const completeSegment = '$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};';
+const formReplaying = 'addEventListener("submit",function(a){if(!a.defaultPrevented){var c=a.target,d=a.submitter,e=c.action,b=d;if(d){var f=d.getAttribute("formAction");null!=f&&(e=f,b=null)}"javascript:throw new Error(\'A React form was unexpectedly submitted.\')"===e&&(a.preventDefault(),b?(a=document.createElement("input"),a.name=b.name,a.value=b.value,b.parentNode.insertBefore(a,b),b=new FormData(c),a.parentNode.removeChild(a)):b=new FormData(c),a=c.getRootNode(),(a.$$reactFormReplay=a.$$reactFormReplay||[]).push(c,\nd,b))}});';
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+// same object across all transitions.
+
+const sharedNotPendingObject = {
+  pending: false,
+  data: null,
+  method: null,
+  action: null
+};
+const NotPending = sharedNotPendingObject;
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+const ReactDOMServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMServerDispatcher;
+} // We make every property of the descriptor optional because it is not a contract that
+const ScriptStreamingFormat = 0;
+const DataStreamingFormat = 1;
+const NothingSent
+/*                      */
+= 0b00000;
+const SentCompleteSegmentFunction
+/*      */
+= 0b00001;
+const SentCompleteBoundaryFunction
+/*     */
+= 0b00010;
+const SentClientRenderFunction
+/*         */
+= 0b00100;
+const SentStyleInsertionFunction
+/*       */
+= 0b01000;
+const SentFormReplayingRuntime
+/*         */
+= 0b10000; // Per request, global state that is not contextual to the rendering subtree.
+// This cannot be resumed and therefore should only contain things that are
+// temporary working state or are never used in the prerender pass.
+// Credentials here are things that affect whether a browser will make a request
+// as well as things that affect which connection the browser will use for that request.
+// We want these to be aligned across preloads and resources because otherwise the preload
+// will be wasted.
+// We investigated whether referrerPolicy should be included here but from experimentation
+// it seems that browsers do not treat this as part of the http cache key and does not affect
+// which connection is used.
+
+const EXISTS = null; // This constant is to mark preloads that have no unique credentials
+// to convey. It should never be checked by identity and we should not
+// assume Preload values in ResumableState equal this value because they
+// will have come from some parsed input.
+
+const PRELOAD_NO_CREDS = [];
+// This is resumable and therefore should be serializable.
+
+
+const dataElementQuotedEnd = stringToPrecomputedChunk('"></template>');
+const startInlineScript = stringToPrecomputedChunk('<script>');
+const endInlineScript = stringToPrecomputedChunk('</script>');
+const startScriptSrc = stringToPrecomputedChunk('<script src="');
+const startModuleSrc = stringToPrecomputedChunk('<script type="module" src="');
+const scriptNonce = stringToPrecomputedChunk('" nonce="');
+const scriptIntegirty = stringToPrecomputedChunk('" integrity="');
+const scriptCrossOrigin = stringToPrecomputedChunk('" crossorigin="');
+const endAsyncScript = stringToPrecomputedChunk('" async=""></script>');
+/**
+ * This escaping function is designed to work with bootstrapScriptContent and importMap only.
+ * because we know we are escaping the entire script. We can avoid for instance
+ * escaping html comment string sequences that are valid javascript as well because
+ * if there are no sebsequent <script sequences the html parser will never enter
+ * script data double escaped state (see: https://www.w3.org/TR/html53/syntax.html#script-data-double-escaped-state)
+ *
+ * While untrusted script content should be made safe before using this api it will
+ * ensure that the script cannot be early terminated or never terminated state
+ */
+
+function escapeBootstrapAndImportMapScriptContent(scriptText) {
+
+  return ('' + scriptText).replace(scriptRegex, scriptReplacer);
+}
+
+const scriptRegex = /(<\/|<)(s)(cript)/gi;
+
+const scriptReplacer = (match, prefix, s, suffix) => "" + prefix + (s === 's' ? '\\u0073' : '\\u0053') + suffix;
+
+const importMapScriptStart = stringToPrecomputedChunk('<script type="importmap">');
+const importMapScriptEnd = stringToPrecomputedChunk('</script>'); // Since we store headers as strings we deal with their length in utf16 code units
+// rather than visual characters or the utf8 encoding that is used for most binary
+// serialization. Some common HTTP servers only allow for headers to be 4kB in length.
+// We choose a default length that is likely to be well under this already limited length however
+// pathological cases may still cause the utf-8 encoding of the headers to approach this limit.
+// It should also be noted that this maximum is a soft maximum. we have not reached the limit we will
+// allow one more header to be captured which means in practice if the limit is approached it will be exceeded
+
+const DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS = 2000; // Allows us to keep track of what we've already written so we can refer back to it.
+// if passed externalRuntimeConfig and the enableFizzExternalRuntime feature flag
+// is set, the server will send instructions via data attributes (instead of inline scripts)
+
+function createRenderState(resumableState, nonce, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
+  const inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
+  const idPrefix = resumableState.idPrefix;
+  const bootstrapChunks = [];
+  let externalRuntimeScript = null;
+  const bootstrapScriptContent = resumableState.bootstrapScriptContent,
+        bootstrapScripts = resumableState.bootstrapScripts,
+        bootstrapModules = resumableState.bootstrapModules;
+
+  if (bootstrapScriptContent !== undefined) {
+    bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapAndImportMapScriptContent(bootstrapScriptContent)), endInlineScript);
+  }
+
+  {
+
+    if (externalRuntimeConfig !== undefined) {
+      if (typeof externalRuntimeConfig === 'string') {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig,
+          async: true,
+          integrity: undefined,
+          nonce: nonce
+        });
+      } else {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig.src,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig.src,
+          async: true,
+          integrity: externalRuntimeConfig.integrity,
+          nonce: nonce
+        });
+      }
+    }
+  }
+
+  const importMapChunks = [];
+
+  if (importMap !== undefined) {
+    const map = importMap;
+    importMapChunks.push(importMapScriptStart);
+    importMapChunks.push(stringToChunk(escapeBootstrapAndImportMapScriptContent(JSON.stringify(map))));
+    importMapChunks.push(importMapScriptEnd);
+  }
+
+  const headers = onHeaders ? {
+    preconnects: '',
+    fontPreloads: '',
+    highImagePreloads: '',
+    remainingCapacity: typeof maxHeadersLength === 'number' ? maxHeadersLength : DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS
+  } : null;
+  const renderState = {
+    placeholderPrefix: stringToPrecomputedChunk(idPrefix + 'P:'),
+    segmentPrefix: stringToPrecomputedChunk(idPrefix + 'S:'),
+    boundaryPrefix: stringToPrecomputedChunk(idPrefix + 'B:'),
+    startInlineScript: inlineScriptWithNonce,
+    htmlChunks: null,
+    headChunks: null,
+    externalRuntimeScript: externalRuntimeScript,
+    bootstrapChunks: bootstrapChunks,
+    onHeaders,
+    headers,
+    resets: {
+      font: {},
+      dns: {},
+      connect: {
+        default: {},
+        anonymous: {},
+        credentials: {}
+      },
+      image: {},
+      style: {}
+    },
+    charsetChunks: [],
+    preconnectChunks: [],
+    importMapChunks,
+    preloadChunks: [],
+    hoistableChunks: [],
+    // cleared on flush
+    preconnects: new Set(),
+    fontPreloads: new Set(),
+    highImagePreloads: new Set(),
+    // usedImagePreloads: new Set(),
+    styles: new Map(),
+    bootstrapScripts: new Set(),
+    scripts: new Set(),
+    bulkPreloads: new Set(),
+    preloads: {
+      images: new Map(),
+      stylesheets: new Map(),
+      scripts: new Map(),
+      moduleScripts: new Map()
+    },
+    nonce,
+    // like a module global for currently rendering boundary
+    boundaryResources: null,
+    stylesToHoist: false
+  };
+
+  if (bootstrapScripts !== undefined) {
+    for (let i = 0; i < bootstrapScripts.length; i++) {
+      const scriptConfig = bootstrapScripts[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'preload',
+        as: 'script',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startScriptSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  if (bootstrapModules !== undefined) {
+    for (let i = 0; i < bootstrapModules.length; i++) {
+      const scriptConfig = bootstrapModules[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'modulepreload',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startModuleSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  return renderState;
+}
+function resumeRenderState(resumableState, nonce) {
+  return createRenderState(resumableState, nonce, undefined, undefined, undefined, undefined);
+}
+function createResumableState(identifierPrefix, externalRuntimeConfig, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
+  const idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
+  let streamingFormat = ScriptStreamingFormat;
+
+  {
+    if (externalRuntimeConfig !== undefined) {
+      streamingFormat = DataStreamingFormat;
+    }
+  }
+
+  return {
+    idPrefix: idPrefix,
+    nextFormID: 0,
+    streamingFormat,
+    bootstrapScriptContent,
+    bootstrapScripts,
+    bootstrapModules,
+    instructions: NothingSent,
+    hasBody: false,
+    hasHtml: false,
+    // @TODO add bootstrap script to implicit preloads
+    // persistent
+    unknownResources: {},
+    dnsResources: {},
+    connectResources: {
+      default: {},
+      anonymous: {},
+      credentials: {}
+    },
+    imageResources: {},
+    styleResources: {},
+    scriptResources: {},
+    moduleUnknownResources: {},
+    moduleScriptResources: {}
+  };
+}
+function resetResumableState(resumableState, renderState) {
+  // Resets the resumable state based on what didn't manage to fully flush in the render state.
+  // This currently assumes nothing was flushed.
+  resumableState.nextFormID = 0;
+  resumableState.hasBody = false;
+  resumableState.hasHtml = false;
+  resumableState.unknownResources = {
+    font: renderState.resets.font
+  };
+  resumableState.dnsResources = renderState.resets.dns;
+  resumableState.connectResources = renderState.resets.connect;
+  resumableState.imageResources = renderState.resets.image;
+  resumableState.styleResources = renderState.resets.style;
+  resumableState.scriptResources = {};
+  resumableState.moduleUnknownResources = {};
+  resumableState.moduleScriptResources = {};
+} // Constants for the insertion mode we're currently writing in. We don't encode all HTML5 insertion
+// modes. We only include the variants as they matter for the sake of our purposes.
+// We don't actually provide the namespace therefore we use constants instead of the string.
+
+const ROOT_HTML_MODE = 0; // Used for the root most element tag.
+// We have a less than HTML_HTML_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const HTML_HTML_MODE = 1; // Used for the <html> if it is at the top level.
+
+const HTML_MODE = 2;
+const SVG_MODE = 3;
+const MATHML_MODE = 4;
+const HTML_TABLE_MODE = 5;
+const HTML_TABLE_BODY_MODE = 6;
+const HTML_TABLE_ROW_MODE = 7;
+const HTML_COLGROUP_MODE = 8; // We have a greater than HTML_TABLE_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const NO_SCOPE =
+/*         */
+0b00;
+const NOSCRIPT_SCOPE =
+/*   */
+0b01;
+const PICTURE_SCOPE =
+/*    */
+0b10; // Lets us keep track of contextual state and pick it back up after suspending.
+
+function createFormatContext(insertionMode, selectedValue, tagScope) {
+  return {
+    insertionMode,
+    selectedValue,
+    tagScope
+  };
+}
+
+function createRootFormatContext(namespaceURI) {
+  const insertionMode = namespaceURI === 'http://www.w3.org/2000/svg' ? SVG_MODE : namespaceURI === 'http://www.w3.org/1998/Math/MathML' ? MATHML_MODE : ROOT_HTML_MODE;
+  return createFormatContext(insertionMode, null, NO_SCOPE);
+}
+function getChildFormatContext(parentContext, type, props) {
+  switch (type) {
+    case 'noscript':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | NOSCRIPT_SCOPE);
+
+    case 'select':
+      return createFormatContext(HTML_MODE, props.value != null ? props.value : props.defaultValue, parentContext.tagScope);
+
+    case 'svg':
+      return createFormatContext(SVG_MODE, null, parentContext.tagScope);
+
+    case 'picture':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | PICTURE_SCOPE);
+
+    case 'math':
+      return createFormatContext(MATHML_MODE, null, parentContext.tagScope);
+
+    case 'foreignObject':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    // Table parents are special in that their children can only be created at all if they're
+    // wrapped in a table parent. So we need to encode that we're entering this mode.
+
+    case 'table':
+      return createFormatContext(HTML_TABLE_MODE, null, parentContext.tagScope);
+
+    case 'thead':
+    case 'tbody':
+    case 'tfoot':
+      return createFormatContext(HTML_TABLE_BODY_MODE, null, parentContext.tagScope);
+
+    case 'colgroup':
+      return createFormatContext(HTML_COLGROUP_MODE, null, parentContext.tagScope);
+
+    case 'tr':
+      return createFormatContext(HTML_TABLE_ROW_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode >= HTML_TABLE_MODE) {
+    // Whatever tag this was, it wasn't a table parent or other special parent, so we must have
+    // entered plain HTML again.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode === ROOT_HTML_MODE) {
+    if (type === 'html') {
+      // We've emitted the root and is now in <html> mode.
+      return createFormatContext(HTML_HTML_MODE, null, parentContext.tagScope);
+    } else {
+      // We've emitted the root and is now in plain HTML mode.
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    }
+  } else if (parentContext.insertionMode === HTML_HTML_MODE) {
+    // We've emitted the document element and is now in plain HTML mode.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  return parentContext;
+}
+function makeId(resumableState, treeId, localId) {
+  const idPrefix = resumableState.idPrefix;
+  let id = ':' + idPrefix + 'R' + treeId; // Unless this is the first id at this level, append a number at the end
+  // that represents the position of this useId hook among all the useId
+  // hooks for this fiber.
+
+  if (localId > 0) {
+    id += 'H' + localId.toString(32);
+  }
+
+  return id + ':';
+}
+
+function encodeHTMLTextNode(text) {
+  return escapeTextForBrowser(text);
+}
+
+const textSeparator = stringToPrecomputedChunk('<!-- -->');
+function pushTextInstance(target, text, renderState, textEmbedded) {
+  if (text === '') {
+    // Empty text doesn't have a DOM node representation and the hydration is aware of this.
+    return textEmbedded;
+  }
+
+  if (textEmbedded) {
+    target.push(textSeparator);
+  }
+
+  target.push(stringToChunk(encodeHTMLTextNode(text)));
+  return true;
+} // Called when Fizz is done with a Segment. Currently the only purpose is to conditionally
+// emit a text separator when we don't know for sure it is safe to omit
+
+function pushSegmentFinale(target, renderState, lastPushedText, textEmbedded) {
+  if (lastPushedText && textEmbedded) {
+    target.push(textSeparator);
+  }
+}
+const styleNameCache = new Map();
+
+function processStyleName(styleName) {
+  const chunk = styleNameCache.get(styleName);
+
+  if (chunk !== undefined) {
+    return chunk;
+  }
+
+  const result = stringToPrecomputedChunk(escapeTextForBrowser(hyphenateStyleName(styleName)));
+  styleNameCache.set(styleName, result);
+  return result;
+}
+
+const styleAttributeStart = stringToPrecomputedChunk(' style="');
+const styleAssign = stringToPrecomputedChunk(':');
+const styleSeparator = stringToPrecomputedChunk(';');
+
+function pushStyleAttribute(target, style) {
+  if (typeof style !== 'object') {
+    throw Error(formatProdErrorMessage(62));
+  }
+
+  let isFirst = true;
+
+  for (const styleName in style) {
+    if (!hasOwnProperty.call(style, styleName)) {
+      continue;
+    } // If you provide unsafe user data here they can inject arbitrary CSS
+    // which may be problematic (I couldn't repro this):
+    // https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet
+    // http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/
+    // This is not an XSS hole but instead a potential CSS injection issue
+    // which has lead to a greater discussion about how we're going to
+    // trust URLs moving forward. See #2115901
+
+
+    const styleValue = style[styleName];
+
+    if (styleValue == null || typeof styleValue === 'boolean' || styleValue === '') {
+      // TODO: We used to set empty string as a style with an empty value. Does that ever make sense?
+      continue;
+    }
+
+    let nameChunk;
+    let valueChunk;
+    const isCustomProperty = styleName.indexOf('--') === 0;
+
+    if (isCustomProperty) {
+      nameChunk = stringToChunk(escapeTextForBrowser(styleName));
+
+      valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+    } else {
+
+      nameChunk = processStyleName(styleName);
+
+      if (typeof styleValue === 'number') {
+        if (styleValue !== 0 && !isUnitlessNumber(styleName)) {
+          valueChunk = stringToChunk(styleValue + 'px'); // Presumes implicit 'px' suffix for unitless numbers
+        } else {
+          valueChunk = stringToChunk('' + styleValue);
+        }
+      } else {
+
+        valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+      }
+    }
+
+    if (isFirst) {
+      isFirst = false; // If it's first, we don't need any separators prefixed.
+
+      target.push(styleAttributeStart, nameChunk, styleAssign, valueChunk);
+    } else {
+      target.push(styleSeparator, nameChunk, styleAssign, valueChunk);
+    }
+  }
+
+  if (!isFirst) {
+    target.push(attributeEnd);
+  }
+}
+
+const attributeSeparator = stringToPrecomputedChunk(' ');
+const attributeAssign = stringToPrecomputedChunk('="');
+const attributeEnd = stringToPrecomputedChunk('"');
+const attributeEmptyString = stringToPrecomputedChunk('=""');
+
+function pushBooleanAttribute(target, name, value) // not null or undefined
+{
+  if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+    target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+  }
+}
+
+function pushStringAttribute(target, name, value) // not null or undefined
+{
+  if (typeof value !== 'function' && typeof value !== 'symbol' && typeof value !== 'boolean') {
+    target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+  }
+}
+
+function makeFormFieldPrefix(resumableState) {
+  const id = resumableState.nextFormID++;
+  return resumableState.idPrefix + id;
+} // Since this will likely be repeated a lot in the HTML, we use a more concise message
+// than on the client and hopefully it's googleable.
+
+
+const actionJavaScriptURL = stringToPrecomputedChunk(escapeTextForBrowser( // eslint-disable-next-line no-script-url
+"javascript:throw new Error('A React form was unexpectedly submitted.')"));
+const startHiddenInputChunk = stringToPrecomputedChunk('<input type="hidden"');
+
+function pushAdditionalFormField(value, key) {
+  const target = this;
+  target.push(startHiddenInputChunk);
+
+  if (typeof value !== 'string') {
+    throw Error(formatProdErrorMessage(480));
+  }
+
+  pushStringAttribute(target, 'name', key);
+  pushStringAttribute(target, 'value', value);
+  target.push(endOfStartTagSelfClosing);
+}
+
+function pushAdditionalFormFields(target, formData) {
+  if (formData !== null) {
+    // $FlowFixMe[prop-missing]: FormData has forEach.
+    formData.forEach(pushAdditionalFormField, target);
+  }
+}
+
+function pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name) {
+  let formData = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      name = customFields.name;
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('formAction'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      name = null;
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (name != null) {
+    pushAttribute(target, 'name', name);
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'formAction', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'formEncType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'formMethod', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'formTarget', formTarget);
+  }
+
+  return formData;
+}
+
+function pushAttribute(target, name, value) // not null or undefined
+{
+  switch (name) {
+    // These are very common props and therefore are in the beginning of the switch.
+    // TODO: aria-label is a very common prop but allows booleans so is not like the others
+    // but should ideally go in this list too.
+    case 'className':
+      {
+        pushStringAttribute(target, 'class', value);
+        break;
+      }
+
+    case 'tabIndex':
+      {
+        pushStringAttribute(target, 'tabindex', value);
+        break;
+      }
+
+    case 'dir':
+    case 'role':
+    case 'viewBox':
+    case 'width':
+    case 'height':
+      {
+        pushStringAttribute(target, name, value);
+        break;
+      }
+
+    case 'style':
+      {
+        pushStyleAttribute(target, value);
+        return;
+      }
+
+    case 'src':
+    case 'href':
+      {
+        {
+          if (value === '') {
+
+            return;
+          }
+        }
+      }
+    // Fall through to the last case which shouldn't remove empty strings.
+
+    case 'action':
+    case 'formAction':
+      {
+        // TODO: Consider only special casing these for each tag.
+        if (value == null || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'defaultValue':
+    case 'defaultChecked': // These shouldn't be set as attributes on generic HTML elements.
+
+    case 'innerHTML': // Must use dangerouslySetInnerHTML instead.
+
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+      // Ignored. These are built-in to React on the client.
+      return;
+
+    case 'autoFocus':
+    case 'multiple':
+    case 'muted':
+      {
+        pushBooleanAttribute(target, name.toLowerCase(), value);
+        return;
+      }
+
+    case 'xlinkHref':
+      {
+        if (typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk('xlink:href'), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'contentEditable':
+    case 'spellCheck':
+    case 'draggable':
+    case 'value':
+    case 'autoReverse':
+    case 'externalResourcesRequired':
+    case 'focusable':
+    case 'preserveAlpha':
+      {
+        // Booleanish String
+        // These are "enumerated" attributes that accept "true" and "false".
+        // In React, we let users pass `true` and `false` even though technically
+        // these aren't boolean attributes (they are coerced to strings).
+        if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'allowFullScreen':
+    case 'async':
+    case 'autoPlay':
+    case 'controls':
+    case 'default':
+    case 'defer':
+    case 'disabled':
+    case 'disablePictureInPicture':
+    case 'disableRemotePlayback':
+    case 'formNoValidate':
+    case 'hidden':
+    case 'loop':
+    case 'noModule':
+    case 'noValidate':
+    case 'open':
+    case 'playsInline':
+    case 'readOnly':
+    case 'required':
+    case 'reversed':
+    case 'scoped':
+    case 'seamless':
+    case 'itemScope':
+      {
+        // Boolean
+        if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        }
+
+        return;
+      }
+
+    case 'capture':
+    case 'download':
+      {
+        // Overloaded Boolean
+        if (value === true) {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        } else if (value === false) ; else if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'cols':
+    case 'rows':
+    case 'size':
+    case 'span':
+      {
+        // These are HTML attributes that must be positive numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value) && value >= 1) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'rowSpan':
+    case 'start':
+      {
+        // These are HTML attributes that must be numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value)) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'xlinkActuate':
+      pushStringAttribute(target, 'xlink:actuate', value);
+      return;
+
+    case 'xlinkArcrole':
+      pushStringAttribute(target, 'xlink:arcrole', value);
+      return;
+
+    case 'xlinkRole':
+      pushStringAttribute(target, 'xlink:role', value);
+      return;
+
+    case 'xlinkShow':
+      pushStringAttribute(target, 'xlink:show', value);
+      return;
+
+    case 'xlinkTitle':
+      pushStringAttribute(target, 'xlink:title', value);
+      return;
+
+    case 'xlinkType':
+      pushStringAttribute(target, 'xlink:type', value);
+      return;
+
+    case 'xmlBase':
+      pushStringAttribute(target, 'xml:base', value);
+      return;
+
+    case 'xmlLang':
+      pushStringAttribute(target, 'xml:lang', value);
+      return;
+
+    case 'xmlSpace':
+      pushStringAttribute(target, 'xml:space', value);
+      return;
+
+    default:
+      if ( // shouldIgnoreAttribute
+      // We have already filtered out null/undefined and reserved words.
+      name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+        return;
+      }
+
+      const attributeName = getAttributeAlias(name);
+
+      if (isAttributeNameSafe(attributeName)) {
+        // shouldRemoveAttribute
+        switch (typeof value) {
+          case 'function':
+          case 'symbol':
+            // eslint-disable-line
+            return;
+
+          case 'boolean':
+            {
+              const prefix = attributeName.toLowerCase().slice(0, 5);
+
+              if (prefix !== 'data-' && prefix !== 'aria-') {
+                return;
+              }
+            }
+        }
+
+        target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+      }
+
+  }
+}
+
+const endOfStartTag = stringToPrecomputedChunk('>');
+const endOfStartTagSelfClosing = stringToPrecomputedChunk('/>');
+
+function pushInnerHTML(target, innerHTML, children) {
+  if (innerHTML != null) {
+    if (children != null) {
+      throw Error(formatProdErrorMessage(60));
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw Error(formatProdErrorMessage(61));
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+
+      target.push(stringToChunk('' + html));
+    }
+  }
+} // TODO: Move these to RenderState so that we warn for every request.
+
+function pushStartSelect(target, props) {
+
+  target.push(startChunkForTag('select'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          // TODO: This doesn't really make sense for select since it can't use the controlled
+          // value in the innerHTML.
+          innerHTML = propValue;
+          break;
+
+        case 'defaultValue':
+        case 'value':
+          // These are set on the Context instead and applied to the nested options.
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+function flattenOptionChildren(children) {
+  let content = ''; // Flatten children and warn if they aren't strings or numbers;
+  // invalid types are ignored.
+
+  React.Children.forEach(children, function (child) {
+    if (child == null) {
+      return;
+    }
+
+    content += child;
+  });
+  return content;
+}
+
+const selectedMarkerAttribute = stringToPrecomputedChunk(' selected=""');
+
+function pushStartOption(target, props, formatContext) {
+  const selectedValue = formatContext.selectedValue;
+  target.push(startChunkForTag('option'));
+  let children = null;
+  let value = null;
+  let selected = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'selected':
+          // ignore
+          selected = propValue;
+
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+        // We intentionally fallthrough to also set the attribute on the node.
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (selectedValue != null) {
+    let stringValue;
+
+    if (value !== null) {
+
+      stringValue = '' + value;
+    } else {
+
+      stringValue = flattenOptionChildren(children);
+    }
+
+    if (isArray(selectedValue)) {
+      // multiple
+      for (let i = 0; i < selectedValue.length; i++) {
+
+        const v = '' + selectedValue[i];
+
+        if (v === stringValue) {
+          target.push(selectedMarkerAttribute);
+          break;
+        }
+      }
+    } else {
+
+      if ('' + selectedValue === stringValue) {
+        target.push(selectedMarkerAttribute);
+      }
+    }
+  } else if (selected) {
+    target.push(selectedMarkerAttribute);
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const formReplayingRuntimeScript = stringToPrecomputedChunk(formReplaying);
+
+function injectFormReplayingRuntime(resumableState, renderState) {
+  // If we haven't sent it yet, inject the runtime that tracks submitted JS actions
+  // for later replaying by Fiber. If we use an external runtime, we don't need
+  // to emit anything. It's always used.
+  if ((resumableState.instructions & SentFormReplayingRuntime) === NothingSent && (!renderState.externalRuntimeScript)) {
+    resumableState.instructions |= SentFormReplayingRuntime;
+    renderState.bootstrapChunks.unshift(renderState.startInlineScript, formReplayingRuntimeScript, endInlineScript);
+  }
+}
+
+const formStateMarkerIsMatching = stringToPrecomputedChunk('<!--F!-->');
+const formStateMarkerIsNotMatching = stringToPrecomputedChunk('<!--F-->');
+function pushFormStateMarkerIsMatching(target) {
+  target.push(formStateMarkerIsMatching);
+}
+function pushFormStateMarkerIsNotMatching(target) {
+  target.push(formStateMarkerIsNotMatching);
+}
+
+function pushStartForm(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('form'));
+  let children = null;
+  let innerHTML = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'action':
+          formAction = propValue;
+          break;
+
+        case 'encType':
+          formEncType = propValue;
+          break;
+
+        case 'method':
+          formMethod = propValue;
+          break;
+
+        case 'target':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  let formData = null;
+  let formActionName = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+      formActionName = customFields.name;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('action'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'action', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'encType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'method', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'target', formTarget);
+  }
+
+  target.push(endOfStartTag);
+
+  if (formActionName !== null) {
+    target.push(startHiddenInputChunk);
+    pushStringAttribute(target, 'name', formActionName);
+    target.push(endOfStartTagSelfClosing);
+    pushAdditionalFormFields(target, formData);
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushInput(target, props, resumableState, renderState) {
+
+  target.push(startChunkForTag('input'));
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+  let value = null;
+  let defaultValue = null;
+  let checked = null;
+  let defaultChecked = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(399, 'input'));
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        case 'defaultChecked':
+          defaultChecked = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'checked':
+          checked = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+
+  if (checked !== null) {
+    pushBooleanAttribute(target, 'checked', checked);
+  } else if (defaultChecked !== null) {
+    pushBooleanAttribute(target, 'checked', defaultChecked);
+  }
+
+  if (value !== null) {
+    pushAttribute(target, 'value', value);
+  } else if (defaultValue !== null) {
+    pushAttribute(target, 'value', defaultValue);
+  }
+
+  target.push(endOfStartTagSelfClosing); // We place any additional hidden form fields after the input.
+
+  pushAdditionalFormFields(target, formData);
+  return null;
+}
+
+function pushStartButton(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('button'));
+  let children = null;
+  let innerHTML = null;
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+  target.push(endOfStartTag); // We place any additional hidden form fields we need to include inside the button itself.
+
+  pushAdditionalFormFields(target, formData);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartTextArea(target, props) {
+
+  target.push(startChunkForTag('textarea'));
+  let value = null;
+  let defaultValue = null;
+  let children = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(91));
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (value === null && defaultValue !== null) {
+    value = defaultValue;
+  }
+
+  target.push(endOfStartTag); // TODO (yungsters): Remove support for children content in <textarea>.
+
+  if (children != null) {
+
+    if (value != null) {
+      throw Error(formatProdErrorMessage(92));
+    }
+
+    if (isArray(children)) {
+      if (children.length > 1) {
+        throw Error(formatProdErrorMessage(93));
+      } // TODO: remove the coercion and the DEV check below because it will
+
+      value = '' + children[0];
+    }
+
+    value = '' + children;
+  }
+
+  if (typeof value === 'string' && value[0] === '\n') {
+    // text/html ignores the first character in these tags if it's a newline
+    // Prefer to break application/xml over text/html (for now) by adding
+    // a newline specifically to get eaten by the parser. (Alternately for
+    // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+    // \r is normalized out by HTMLTextAreaElement#value.)
+    // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+    // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+    // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+    // See: Parsing of "textarea" "listing" and "pre" elements
+    //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+    target.push(leadingNewline);
+  } // ToString and push directly instead of recurse over children.
+  // We don't really support complex children in the value anyway.
+  // This also currently avoids a trailing comment node which breaks textarea.
+
+
+  if (value !== null) {
+
+    target.push(stringToChunk(encodeHTMLTextNode('' + value)));
+  }
+
+  return null;
+}
+
+function pushMeta(target, props, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      return pushSelfClosing(target, props, 'meta');
+    } else {
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      if (typeof props.charSet === 'string') {
+        return pushSelfClosing(renderState.charsetChunks, props, 'meta');
+      } else if (props.name === 'viewport') {
+        // "viewport" isn't related to preconnect but it has the right priority
+        return pushSelfClosing(renderState.preconnectChunks, props, 'meta');
+      } else {
+        return pushSelfClosing(renderState.hoistableChunks, props, 'meta');
+      }
+    }
+  }
+}
+
+function pushLink(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const rel = props.rel;
+    const href = props.href;
+    const precedence = props.precedence;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof rel !== 'string' || typeof href !== 'string' || href === '') {
+
+      pushLinkImpl(target, props);
+      return null;
+    }
+
+    if (props.rel === 'stylesheet') {
+      // This <link> may hoistable as a Stylesheet Resource, otherwise it will emit in place
+      const key = getResourceKey(href);
+
+      if (typeof precedence !== 'string' || props.disabled != null || props.onLoad || props.onError) {
+
+        return pushLinkImpl(target, props);
+      } else {
+        // This stylesheet refers to a Resource and we create a new one if necessary
+        let styleQueue = renderState.styles.get(precedence);
+        const hasKey = resumableState.styleResources.hasOwnProperty(key);
+        const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+        if (resourceState !== EXISTS) {
+          // We are going to create this resource now so it is marked as Exists
+          resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+          // to create a StyleQueue
+
+          if (!styleQueue) {
+            styleQueue = {
+              precedence: stringToChunk(escapeTextForBrowser(precedence)),
+              rules: [],
+              hrefs: [],
+              sheets: new Map()
+            };
+            renderState.styles.set(precedence, styleQueue);
+          }
+
+          const resource = {
+            state: PENDING$1,
+            props: stylesheetPropsFromRawProps(props)
+          };
+
+          if (resourceState) {
+            // When resourceState is truty it is a Preload state. We cast it for clarity
+            const preloadState = resourceState;
+
+            if (preloadState.length === 2) {
+              adoptPreloadCredentials(resource.props, preloadState);
+            }
+
+            const preloadResource = renderState.preloads.stylesheets.get(key);
+
+            if (preloadResource && preloadResource.length > 0) {
+              // The Preload for this resource was created in this render pass and has not flushed yet so
+              // we need to clear it to avoid it flushing.
+              preloadResource.length = 0;
+            } else {
+              // Either the preload resource from this render already flushed in this render pass
+              // or the preload flushed in a prior pass (prerender). In either case we need to mark
+              // this resource as already having been preloaded.
+              resource.state = PRELOADED;
+            }
+          } // We add the newly created resource to our StyleQueue and if necessary
+          // track the resource with the currently rendering boundary
+
+
+          styleQueue.sheets.set(key, resource);
+
+          if (renderState.boundaryResources) {
+            renderState.boundaryResources.stylesheets.add(resource);
+          }
+        } else {
+          // We need to track whether this boundary should wait on this resource or not.
+          // Typically this resource should always exist since we either had it or just created
+          // it. However, it's possible when you resume that the style has already been emitted
+          // and then it wouldn't be recreated in the RenderState and there's no need to track
+          // it again since we should've hoisted it to the shell already.
+          if (styleQueue) {
+            const resource = styleQueue.sheets.get(key);
+
+            if (resource) {
+              if (renderState.boundaryResources) {
+                renderState.boundaryResources.stylesheets.add(resource);
+              }
+            }
+          }
+        }
+
+        if (textEmbedded) {
+          // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+          // to be safe and assume text will follow by inserting a textSeparator
+          target.push(textSeparator);
+        }
+
+        return null;
+      }
+    } else if (props.onLoad || props.onError) {
+      // When using load handlers we cannot hoist and need to emit links in place
+      return pushLinkImpl(target, props);
+    } else {
+      // We can hoist this link so we may need to emit a text separator.
+      // @TODO refactor text separators so we don't have to defensively add
+      // them when we don't end up emitting a tag as a result of pushStartInstance
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      switch (props.rel) {
+        case 'preconnect':
+        case 'dns-prefetch':
+          return pushLinkImpl(renderState.preconnectChunks, props);
+
+        case 'preload':
+          return pushLinkImpl(renderState.preloadChunks, props);
+
+        default:
+          return pushLinkImpl(renderState.hoistableChunks, props);
+      }
+    }
+  }
+}
+
+function pushLinkImpl(target, props) {
+  target.push(startChunkForTag('link'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(399, 'link'));
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStyle(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+
+  {
+    const precedence = props.precedence;
+    const href = props.href;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof precedence !== 'string' || typeof href !== 'string' || href === '') {
+      // This style tag is not able to be turned into a Style Resource
+      return pushStyleImpl(target, props);
+    }
+
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS;
+
+      if (!styleQueue) {
+        // This is the first time we've encountered this precedence we need
+        // to create a StyleQueue.
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [stringToChunk(escapeTextForBrowser(href))],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      } else {
+        // We have seen this precedence before and need to track this href
+        styleQueue.hrefs.push(stringToChunk(escapeTextForBrowser(href)));
+      }
+
+      pushStyleContents(styleQueue.rules, props);
+    }
+
+    if (styleQueue) {
+      // We need to track whether this boundary should wait on this resource or not.
+      // Typically this resource should always exist since we either had it or just created
+      // it. However, it's possible when you resume that the style has already been emitted
+      // and then it wouldn't be recreated in the RenderState and there's no need to track
+      // it again since we should've hoisted it to the shell already.
+      if (renderState.boundaryResources) {
+        renderState.boundaryResources.styles.add(styleQueue);
+      }
+    }
+
+    if (textEmbedded) {
+      // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+  }
+}
+
+function pushStyleImpl(target, props) {
+  target.push(startChunkForTag('style'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('style'));
+  return null;
+}
+
+function pushStyleContents(target, props) {
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+      }
+    }
+  }
+
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  return;
+}
+
+function pushImg(target, props, resumableState, renderState, pictureTagInScope) {
+  const src = props.src,
+        srcSet = props.srcSet;
+
+  if (props.loading !== 'lazy' && (src || srcSet) && (typeof src === 'string' || src == null) && (typeof srcSet === 'string' || srcSet == null) && props.fetchPriority !== 'low' && pictureTagInScope === false && // We exclude data URIs in src and srcSet since these should not be preloaded
+  !(typeof src === 'string' && src[4] === ':' && (src[0] === 'd' || src[0] === 'D') && (src[1] === 'a' || src[1] === 'A') && (src[2] === 't' || src[2] === 'T') && (src[3] === 'a' || src[3] === 'A')) && !(typeof srcSet === 'string' && srcSet[4] === ':' && (srcSet[0] === 'd' || srcSet[0] === 'D') && (srcSet[1] === 'a' || srcSet[1] === 'A') && (srcSet[2] === 't' || srcSet[2] === 'T') && (srcSet[3] === 'a' || srcSet[3] === 'A'))) {
+    // We have a suspensey image and ought to preload it to optimize the loading of display blocking
+    // resumableState.
+    const sizes = typeof props.sizes === 'string' ? props.sizes : undefined;
+    const key = getImageResourceKey(src, srcSet, sizes);
+    const promotablePreloads = renderState.preloads.images;
+    let resource = promotablePreloads.get(key);
+
+    if (resource) {
+      // We consider whether this preload can be promoted to higher priority flushing queue.
+      // The only time a resource will exist here is if it was created during this render
+      // and was not already in the high priority queue.
+      if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+        // Delete the resource from the map since we are promoting it and don't want to
+        // reenter this branch in a second pass for duplicate img hrefs.
+        promotablePreloads.delete(key); // $FlowFixMe - Flow should understand that this is a Resource if the condition was true
+
+        renderState.highImagePreloads.add(resource);
+      }
+    } else if (!resumableState.imageResources.hasOwnProperty(key)) {
+      // We must construct a new preload resource
+      resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+      const crossOrigin = getCrossOriginString(props.crossOrigin);
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // this is a hueristic similar to capping element preloads to 10 unless explicitly
+      // fetchPriority="high". We use length here which means it will fit fewer images when
+      // the urls are long and more when short. arguably byte size is a better hueristic because
+      // it directly translates to how much we send down before content is actually seen.
+      // We could unify the counts and also make it so the total is tracked regardless of
+      // flushing output but since the headers are likely to be go earlier than content
+      // they don't really conflict so for now I've kept them separate
+      props.fetchPriority === 'high' || headers.highImagePreloads.length < 500) && ( // We manually construct the options for the preload only from strings. We don't want to pollute
+      // the params list with arbitrary props and if we copied everything over as it we might get
+      // coercion errors. We have checks for this in Dev but it seems safer to just only accept values
+      // that are strings
+      header = getPreloadAsHeader(src, 'image', {
+        imageSrcSet: props.srcSet,
+        imageSizes: props.sizes,
+        crossOrigin,
+        integrity: props.integrity,
+        nonce: props.nonce,
+        type: props.type,
+        fetchPriority: props.fetchPriority,
+        referrerPolicy: props.refererPolicy
+      }), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // If we postpone in the shell we will still emit this preload so we track
+        // it to make sure we don't reset it.
+        renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+        if (headers.highImagePreloads) {
+          headers.highImagePreloads += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.highImagePreloads += header;
+      } else {
+        resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preload',
+          as: 'image',
+          // There is a bug in Safari where imageSrcSet is not respected on preload links
+          // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+          // This harms older browers that do not support imageSrcSet by making their preloads not work
+          // but this population is shrinking fast and is already small so we accept this tradeoff.
+          href: srcSet ? undefined : src,
+          imageSrcSet: srcSet,
+          imageSizes: sizes,
+          crossOrigin: crossOrigin,
+          integrity: props.integrity,
+          type: props.type,
+          fetchPriority: props.fetchPriority,
+          referrerPolicy: props.referrerPolicy
+        });
+
+        if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+          renderState.highImagePreloads.add(resource);
+        } else {
+          renderState.bulkPreloads.add(resource); // We can bump the priority up if the same img is rendered later
+          // with fetchPriority="high"
+
+          promotablePreloads.set(key, resource);
+        }
+      }
+    }
+  }
+
+  return pushSelfClosing(target, props, 'img');
+}
+
+function pushSelfClosing(target, props, tag) {
+  target.push(startChunkForTag(tag));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(399, tag));
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStartMenuItem(target, props) {
+  target.push(startChunkForTag('menuitem'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(400));
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  return null;
+}
+
+function pushTitle(target, props, renderState, insertionMode, noscriptTagInScope) {
+
+  {
+    if (insertionMode !== SVG_MODE && !noscriptTagInScope && props.itemProp == null) {
+      pushTitleImpl(renderState.hoistableChunks, props);
+      return null;
+    } else {
+      return pushTitleImpl(target, props);
+    }
+  }
+}
+
+function pushTitleImpl(target, props) {
+  target.push(startChunkForTag('title'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('title'));
+  return null;
+}
+
+function pushStartHead(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode < HTML_MODE && renderState.headChunks === null) {
+      // This <head> is the Document.head and should be part of the preamble
+      renderState.headChunks = [];
+      return pushStartGenericElement(renderState.headChunks, props, 'head');
+    } else {
+      // This <head> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'head');
+    }
+  }
+}
+
+function pushStartHtml(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode === ROOT_HTML_MODE && renderState.htmlChunks === null) {
+      // This <html> is the Document.documentElement and should be part of the preamble
+      renderState.htmlChunks = [doctypeChunk];
+      return pushStartGenericElement(renderState.htmlChunks, props, 'html');
+    } else {
+      // This <html> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'html');
+    }
+  }
+}
+
+function pushScript(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const asyncProp = props.async;
+
+    if (typeof props.src !== 'string' || !props.src || !(asyncProp && typeof asyncProp !== 'function' && typeof asyncProp !== 'symbol') || props.onLoad || props.onError || insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      // This script will not be a resource, we bailout early and emit it in place.
+      return pushScriptImpl(target, props);
+    }
+
+    const src = props.src;
+    const key = getResourceKey(src); // We can make this <script> into a ScriptResource
+
+    let resources, preloads;
+
+    if (props.type === 'module') {
+      resources = resumableState.moduleScriptResources;
+      preloads = renderState.preloads.moduleScripts;
+    } else {
+      resources = resumableState.scriptResources;
+      preloads = renderState.preloads.scripts;
+    }
+
+    const hasKey = resources.hasOwnProperty(key);
+    const resourceState = hasKey ? resources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resources[key] = EXISTS;
+      let scriptProps = props;
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          scriptProps = assign({}, props);
+          adoptPreloadCredentials(scriptProps, preloadState);
+        }
+
+        const preloadResource = preloads.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, scriptProps);
+    }
+
+    if (textEmbedded) {
+      // This script follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+
+    return null;
+  }
+}
+
+function pushScriptImpl(target, props) {
+  target.push(startChunkForTag('script'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+  }
+
+  target.push(endChunkForTag('script'));
+  return null;
+}
+
+function pushStartGenericElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartCustomElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      let propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      let attributeName = propKey;
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'style':
+          pushStyleAttribute(target, propValue);
+          break;
+
+        case 'suppressContentEditableWarning':
+        case 'suppressHydrationWarning':
+          // Ignored. These are built-in to React on the client.
+          break;
+
+        case 'className':
+          {
+            // className gets rendered as class on the client, so it should be
+            // rendered as class on the server.
+            attributeName = 'class';
+          }
+
+        // intentional fallthrough
+
+        default:
+          if (isAttributeNameSafe(propKey) && typeof propValue !== 'function' && typeof propValue !== 'symbol') {
+            {
+              if (propValue === false) {
+                continue;
+              } else if (propValue === true) {
+                propValue = '';
+              } else if (typeof propValue === 'object') {
+                continue;
+              }
+            }
+
+            target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(propValue)), attributeEnd);
+          }
+
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const leadingNewline = stringToPrecomputedChunk('\n');
+
+function pushStartPreformattedElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag); // text/html ignores the first character in these tags if it's a newline
+  // Prefer to break application/xml over text/html (for now) by adding
+  // a newline specifically to get eaten by the parser. (Alternately for
+  // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+  // \r is normalized out by HTMLTextAreaElement#value.)
+  // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+  // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+  // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+  // See: Parsing of "textarea" "listing" and "pre" elements
+  //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+  // TODO: This doesn't deal with the case where the child is an array
+  // or component that returns a string.
+
+  if (innerHTML != null) {
+    if (children != null) {
+      throw Error(formatProdErrorMessage(60));
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw Error(formatProdErrorMessage(61));
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+      if (typeof html === 'string' && html.length > 0 && html[0] === '\n') {
+        target.push(leadingNewline, stringToChunk(html));
+      } else {
+
+        target.push(stringToChunk('' + html));
+      }
+    }
+  }
+
+  if (typeof children === 'string' && children[0] === '\n') {
+    target.push(leadingNewline);
+  }
+
+  return children;
+} // We accept any tag to be rendered but since this gets injected into arbitrary
+// HTML, we want to make sure that it's a safe tag.
+// http://www.w3.org/TR/REC-xml/#NT-Name
+
+
+const VALID_TAG_REGEX = /^[a-zA-Z][a-zA-Z:_\.\-\d]*$/; // Simplified subset
+
+const validatedTagCache = new Map();
+
+function startChunkForTag(tag) {
+  let tagStartChunk = validatedTagCache.get(tag);
+
+  if (tagStartChunk === undefined) {
+    if (!VALID_TAG_REGEX.test(tag)) {
+      throw Error(formatProdErrorMessage(65, tag));
+    }
+
+    tagStartChunk = stringToPrecomputedChunk('<' + tag);
+    validatedTagCache.set(tag, tagStartChunk);
+  }
+
+  return tagStartChunk;
+}
+
+const doctypeChunk = stringToPrecomputedChunk('<!DOCTYPE html>');
+function pushStartInstance(target, type, props, resumableState, renderState, formatContext, textEmbedded) {
+
+  switch (type) {
+    case 'div':
+    case 'span':
+    case 'svg':
+    case 'path':
+    case 'a':
+    case 'g':
+    case 'p':
+    case 'li':
+      // Fast track very common tags
+      break;
+    // Special tags
+
+    case 'select':
+      return pushStartSelect(target, props);
+
+    case 'option':
+      return pushStartOption(target, props, formatContext);
+
+    case 'textarea':
+      return pushStartTextArea(target, props);
+
+    case 'input':
+      return pushInput(target, props, resumableState, renderState);
+
+    case 'button':
+      return pushStartButton(target, props, resumableState, renderState);
+
+    case 'form':
+      return pushStartForm(target, props, resumableState, renderState);
+
+    case 'menuitem':
+      return pushStartMenuItem(target, props);
+
+    case 'title':
+      return pushTitle(target, props, renderState, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'link':
+      return pushLink(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'script':
+      return pushScript(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'style':
+      return pushStyle(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'meta':
+      return pushMeta(target, props, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+    // Newline eating tags
+
+    case 'listing':
+    case 'pre':
+      {
+        return pushStartPreformattedElement(target, props, type);
+      }
+
+    case 'img':
+      {
+        return pushImg(target, props, resumableState, renderState, !!(formatContext.tagScope & PICTURE_SCOPE)) ;
+      }
+    // Omitted close tags
+
+    case 'base':
+    case 'area':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'keygen':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        return pushSelfClosing(target, props, type);
+      }
+    // These are reserved SVG and MathML elements, that are never custom elements.
+    // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+
+    case 'annotation-xml':
+    case 'color-profile':
+    case 'font-face':
+    case 'font-face-src':
+    case 'font-face-uri':
+    case 'font-face-format':
+    case 'font-face-name':
+    case 'missing-glyph':
+      {
+        break;
+      }
+    // Preamble start tags
+
+    case 'head':
+      return pushStartHead(target, props, renderState, formatContext.insertionMode);
+
+    case 'html':
+      {
+        return pushStartHtml(target, props, renderState, formatContext.insertionMode);
+      }
+
+    default:
+      {
+        if (type.indexOf('-') !== -1) {
+          // Custom element
+          return pushStartCustomElement(target, props, type);
+        }
+      }
+  } // Generic element
+
+
+  return pushStartGenericElement(target, props, type);
+}
+const endTagCache = new Map();
+
+function endChunkForTag(tag) {
+  let chunk = endTagCache.get(tag);
+
+  if (chunk === undefined) {
+    chunk = stringToPrecomputedChunk('</' + tag + '>');
+    endTagCache.set(tag, chunk);
+  }
+
+  return chunk;
+}
+
+function pushEndInstance(target, type, props, resumableState, formatContext) {
+  switch (type) {
+    // When float is on we expect title and script tags to always be pushed in
+    // a unit and never return children. when we end up pushing the end tag we
+    // want to ensure there is no extra closing tag pushed
+    case 'title':
+    case 'style':
+    case 'script':
+    // Omitted close tags
+    // TODO: Instead of repeating this switch we could try to pass a flag from above.
+    // That would require returning a tuple. Which might be ok if it gets inlined.
+
+    case 'area':
+    case 'base':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'img':
+    case 'input':
+    case 'keygen':
+    case 'link':
+    case 'meta':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        // No close tag needed.
+        return;
+      }
+    // Postamble end tags
+    // When float is enabled we omit the end tags for body and html when
+    // they represent the Document.body and Document.documentElement Nodes.
+    // This is so we can withhold them until the postamble when we know
+    // we won't emit any more tags
+
+    case 'body':
+      {
+        if (formatContext.insertionMode <= HTML_HTML_MODE) {
+          resumableState.hasBody = true;
+          return;
+        }
+
+        break;
+      }
+
+    case 'html':
+      if (formatContext.insertionMode === ROOT_HTML_MODE) {
+        resumableState.hasHtml = true;
+        return;
+      }
+
+      break;
+  }
+
+  target.push(endChunkForTag(type));
+}
+
+function writeBootstrap(destination, renderState, resumableState) {
+  resumableState.bootstrapScriptContent = undefined;
+  resumableState.bootstrapScripts = undefined;
+  resumableState.bootstrapModules = undefined;
+  const bootstrapChunks = renderState.bootstrapChunks;
+  let i = 0;
+
+  for (; i < bootstrapChunks.length - 1; i++) {
+    writeChunk(destination, bootstrapChunks[i]);
+  }
+
+  if (i < bootstrapChunks.length) {
+    const lastChunk = bootstrapChunks[i];
+    bootstrapChunks.length = 0;
+    return writeChunkAndReturn(destination, lastChunk);
+  }
+
+  return true;
+}
+
+function writeCompletedRoot(destination, renderState, resumableState) {
+  return writeBootstrap(destination, renderState, resumableState);
+} // Structural Nodes
+// A placeholder is a node inside a hidden partial tree that can be filled in later, but before
+// display. It's never visible to users. We use the template tag because it can be used in every
+// type of parent. <script> tags also work in every other tag except <colgroup>.
+
+const placeholder1 = stringToPrecomputedChunk('<template id="');
+const placeholder2 = stringToPrecomputedChunk('"></template>');
+function writePlaceholder(destination, renderState, id) {
+  writeChunk(destination, placeholder1);
+  writeChunk(destination, renderState.placeholderPrefix);
+  const formattedID = stringToChunk(id.toString(16));
+  writeChunk(destination, formattedID);
+  return writeChunkAndReturn(destination, placeholder2);
+} // Suspense boundaries are encoded as comments.
+
+const startCompletedSuspenseBoundary = stringToPrecomputedChunk('<!--$-->');
+const startPendingSuspenseBoundary1 = stringToPrecomputedChunk('<!--$?--><template id="');
+const startPendingSuspenseBoundary2 = stringToPrecomputedChunk('"></template>');
+const startClientRenderedSuspenseBoundary = stringToPrecomputedChunk('<!--$!-->');
+const endSuspenseBoundary = stringToPrecomputedChunk('<!--/$-->');
+const clientRenderedSuspenseBoundaryError1 = stringToPrecomputedChunk('<template');
+const clientRenderedSuspenseBoundaryErrorAttrInterstitial = stringToPrecomputedChunk('"');
+const clientRenderedSuspenseBoundaryError1A = stringToPrecomputedChunk(' data-dgst="');
+stringToPrecomputedChunk(' data-msg="');
+stringToPrecomputedChunk(' data-stck="');
+const clientRenderedSuspenseBoundaryError2 = stringToPrecomputedChunk('></template>');
+function writeStartCompletedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, startCompletedSuspenseBoundary);
+}
+function writeStartPendingSuspenseBoundary(destination, renderState, id) {
+  writeChunk(destination, startPendingSuspenseBoundary1);
+
+  if (id === null) {
+    throw Error(formatProdErrorMessage(395));
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+  return writeChunkAndReturn(destination, startPendingSuspenseBoundary2);
+}
+function writeStartClientRenderedSuspenseBoundary(destination, renderState, errorDigest, errorMesssage, errorComponentStack) {
+  let result;
+  result = writeChunkAndReturn(destination, startClientRenderedSuspenseBoundary);
+  writeChunk(destination, clientRenderedSuspenseBoundaryError1);
+
+  if (errorDigest) {
+    writeChunk(destination, clientRenderedSuspenseBoundaryError1A);
+    writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest)));
+    writeChunk(destination, clientRenderedSuspenseBoundaryErrorAttrInterstitial);
+  }
+
+  result = writeChunkAndReturn(destination, clientRenderedSuspenseBoundaryError2);
+  return result;
+}
+function writeEndCompletedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndPendingSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndClientRenderedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+const startSegmentHTML = stringToPrecomputedChunk('<div hidden id="');
+const startSegmentHTML2 = stringToPrecomputedChunk('">');
+const endSegmentHTML = stringToPrecomputedChunk('</div>');
+const startSegmentSVG = stringToPrecomputedChunk('<svg aria-hidden="true" style="display:none" id="');
+const startSegmentSVG2 = stringToPrecomputedChunk('">');
+const endSegmentSVG = stringToPrecomputedChunk('</svg>');
+const startSegmentMathML = stringToPrecomputedChunk('<math aria-hidden="true" style="display:none" id="');
+const startSegmentMathML2 = stringToPrecomputedChunk('">');
+const endSegmentMathML = stringToPrecomputedChunk('</math>');
+const startSegmentTable = stringToPrecomputedChunk('<table hidden id="');
+const startSegmentTable2 = stringToPrecomputedChunk('">');
+const endSegmentTable = stringToPrecomputedChunk('</table>');
+const startSegmentTableBody = stringToPrecomputedChunk('<table hidden><tbody id="');
+const startSegmentTableBody2 = stringToPrecomputedChunk('">');
+const endSegmentTableBody = stringToPrecomputedChunk('</tbody></table>');
+const startSegmentTableRow = stringToPrecomputedChunk('<table hidden><tr id="');
+const startSegmentTableRow2 = stringToPrecomputedChunk('">');
+const endSegmentTableRow = stringToPrecomputedChunk('</tr></table>');
+const startSegmentColGroup = stringToPrecomputedChunk('<table hidden><colgroup id="');
+const startSegmentColGroup2 = stringToPrecomputedChunk('">');
+const endSegmentColGroup = stringToPrecomputedChunk('</colgroup></table>');
+function writeStartSegment(destination, renderState, formatContext, id) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        writeChunk(destination, startSegmentHTML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentHTML2);
+      }
+
+    case SVG_MODE:
+      {
+        writeChunk(destination, startSegmentSVG);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentSVG2);
+      }
+
+    case MATHML_MODE:
+      {
+        writeChunk(destination, startSegmentMathML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentMathML2);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        writeChunk(destination, startSegmentTable);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTable2);
+      }
+    // TODO: For the rest of these, there will be extra wrapper nodes that never
+    // get deleted from the document. We need to delete the table too as part
+    // of the injected scripts. They are invisible though so it's not too terrible
+    // and it's kind of an edge case to suspend in a table. Totally supported though.
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        writeChunk(destination, startSegmentTableBody);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableBody2);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        writeChunk(destination, startSegmentTableRow);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableRow2);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        writeChunk(destination, startSegmentColGroup);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentColGroup2);
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(397));
+      }
+  }
+}
+function writeEndSegment(destination, formatContext) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentHTML);
+      }
+
+    case SVG_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentSVG);
+      }
+
+    case MATHML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentMathML);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTable);
+      }
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableBody);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableRow);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentColGroup);
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(397));
+      }
+  }
+}
+const completeSegmentScript1Full = stringToPrecomputedChunk(completeSegment + '$RS("');
+const completeSegmentScript1Partial = stringToPrecomputedChunk('$RS("');
+const completeSegmentScript2 = stringToPrecomputedChunk('","');
+const completeSegmentScriptEnd = stringToPrecomputedChunk('")</script>');
+const completeSegmentData1 = stringToPrecomputedChunk('<template data-rsi="" data-sid="');
+const completeSegmentData2 = stringToPrecomputedChunk('" data-pid="');
+const completeSegmentDataEnd = dataElementQuotedEnd;
+function writeCompletedSegmentInstruction(destination, resumableState, renderState, contentSegmentID) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentCompleteSegmentFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentCompleteSegmentFunction;
+      writeChunk(destination, completeSegmentScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, completeSegmentScript1Partial);
+    }
+  } else {
+    writeChunk(destination, completeSegmentData1);
+  } // Write function arguments, which are string literals
+
+
+  writeChunk(destination, renderState.segmentPrefix);
+  const formattedID = stringToChunk(contentSegmentID.toString(16));
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    writeChunk(destination, completeSegmentScript2);
+  } else {
+    writeChunk(destination, completeSegmentData2);
+  }
+
+  writeChunk(destination, renderState.placeholderPrefix);
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    return writeChunkAndReturn(destination, completeSegmentScriptEnd);
+  } else {
+    return writeChunkAndReturn(destination, completeSegmentDataEnd);
+  }
+}
+const completeBoundaryScript1Full = stringToPrecomputedChunk(completeBoundary + '$RC("');
+const completeBoundaryScript1Partial = stringToPrecomputedChunk('$RC("');
+const completeBoundaryWithStylesScript1FullBoth = stringToPrecomputedChunk(completeBoundary + completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1FullPartial = stringToPrecomputedChunk(completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1Partial = stringToPrecomputedChunk('$RR("');
+const completeBoundaryScript2 = stringToPrecomputedChunk('","');
+const completeBoundaryScript3a = stringToPrecomputedChunk('",');
+const completeBoundaryScript3b = stringToPrecomputedChunk('"');
+const completeBoundaryScriptEnd = stringToPrecomputedChunk(')</script>');
+const completeBoundaryData1 = stringToPrecomputedChunk('<template data-rci="" data-bid="');
+const completeBoundaryWithStylesData1 = stringToPrecomputedChunk('<template data-rri="" data-bid="');
+const completeBoundaryData2 = stringToPrecomputedChunk('" data-sid="');
+const completeBoundaryData3a = stringToPrecomputedChunk('" data-sty="');
+const completeBoundaryDataEnd = dataElementQuotedEnd;
+function writeCompletedBoundaryInstruction(destination, resumableState, renderState, id, boundaryResources) {
+  let requiresStyleInsertion;
+
+  {
+    requiresStyleInsertion = renderState.stylesToHoist; // If necessary stylesheets will be flushed with this instruction.
+    // Any style tags not yet hoisted in the Document will also be hoisted.
+    // We reset this state since after this instruction executes all styles
+    // up to this point will have been hoisted
+
+    renderState.stylesToHoist = false;
+  }
+
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if (requiresStyleInsertion) {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction | SentCompleteBoundaryFunction;
+        writeChunk(destination, clonePrecomputedChunk(completeBoundaryWithStylesScript1FullBoth));
+      } else if ((resumableState.instructions & SentStyleInsertionFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction;
+        writeChunk(destination, completeBoundaryWithStylesScript1FullPartial);
+      } else {
+        writeChunk(destination, completeBoundaryWithStylesScript1Partial);
+      }
+    } else {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentCompleteBoundaryFunction;
+        writeChunk(destination, completeBoundaryScript1Full);
+      } else {
+        writeChunk(destination, completeBoundaryScript1Partial);
+      }
+    }
+  } else {
+    if (requiresStyleInsertion) {
+      writeChunk(destination, completeBoundaryWithStylesData1);
+    } else {
+      writeChunk(destination, completeBoundaryData1);
+    }
+  }
+
+  const idChunk = stringToChunk(id.toString(16));
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, idChunk); // Write function arguments, which are string and array literals
+
+  if (scriptFormat) {
+    writeChunk(destination, completeBoundaryScript2);
+  } else {
+    writeChunk(destination, completeBoundaryData2);
+  }
+
+  writeChunk(destination, renderState.segmentPrefix);
+  writeChunk(destination, idChunk);
+
+  if (requiresStyleInsertion) {
+    // Script and data writers must format this differently:
+    //  - script writer emits an array literal, whose string elements are
+    //    escaped for javascript  e.g. ["A", "B"]
+    //  - data writer emits a string literal, which is escaped as html
+    //    e.g. [&#34;A&#34;, &#34;B&#34;]
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3a); // boundaryResources encodes an array literal
+
+      writeStyleResourceDependenciesInJS(destination, boundaryResources);
+    } else {
+      writeChunk(destination, completeBoundaryData3a);
+      writeStyleResourceDependenciesInAttr(destination, boundaryResources);
+    }
+  } else {
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3b);
+    }
+  }
+
+  let writeMore;
+
+  if (scriptFormat) {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryScriptEnd);
+  } else {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryDataEnd);
+  }
+
+  return writeBootstrap(destination, renderState, resumableState) && writeMore;
+}
+const clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
+const clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
+const clientRenderScript1A = stringToPrecomputedChunk('"');
+const clientRenderErrorScriptArgInterstitial = stringToPrecomputedChunk(',');
+const clientRenderScriptEnd = stringToPrecomputedChunk(')</script>');
+const clientRenderData1 = stringToPrecomputedChunk('<template data-rxi="" data-bid="');
+const clientRenderData2 = stringToPrecomputedChunk('" data-dgst="');
+const clientRenderData3 = stringToPrecomputedChunk('" data-msg="');
+const clientRenderData4 = stringToPrecomputedChunk('" data-stck="');
+const clientRenderDataEnd = dataElementQuotedEnd;
+function writeClientRenderBoundaryInstruction(destination, resumableState, renderState, id, errorDigest, errorMessage, errorComponentStack) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentClientRenderFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentClientRenderFunction;
+      writeChunk(destination, clientRenderScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, clientRenderScript1Partial);
+    }
+  } else {
+    // <template data-rxi="" data-bid="
+    writeChunk(destination, clientRenderData1);
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+
+  if (scriptFormat) {
+    // " needs to be inserted for scripts, since ArgInterstitual does not contain
+    // leading or trailing quotes
+    writeChunk(destination, clientRenderScript1A);
+  }
+
+  if (errorDigest || errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorDigest || '')));
+    } else {
+      // " data-dgst="HTMLString
+      writeChunk(destination, clientRenderData2);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest || '')));
+    }
+  }
+
+  if (errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorMessage || '')));
+    } else {
+      // " data-msg="HTMLString
+      writeChunk(destination, clientRenderData3);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorMessage || '')));
+    }
+  }
+
+  if (errorComponentStack) {
+    // ,"JSONString"
+    if (scriptFormat) {
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorComponentStack)));
+    } else {
+      // " data-stck="HTMLString
+      writeChunk(destination, clientRenderData4);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorComponentStack)));
+    }
+  }
+
+  if (scriptFormat) {
+    // ></script>
+    return writeChunkAndReturn(destination, clientRenderScriptEnd);
+  } else {
+    // "></template>
+    return writeChunkAndReturn(destination, clientRenderDataEnd);
+  }
+}
+const regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
+
+function escapeJSStringsForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInInstructionScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const regexForJSStringsInScripts = /[&><\u2028\u2029]/g;
+
+function escapeJSObjectForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '&':
+        return '\\u0026';
+
+      case '>':
+        return '\\u003e';
+
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const lateStyleTagResourceOpen1 = stringToPrecomputedChunk('<style media="not all" data-precedence="');
+const lateStyleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const lateStyleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const lateStyleTagTemplateClose = stringToPrecomputedChunk('</style>'); // Tracks whether the boundary currently flushing is flushign style tags or has any
+// stylesheet dependencies not flushed in the Preamble.
+
+let currentlyRenderingBoundaryHasStylesToHoist = false; // Acts as a return value for the forEach execution of style tag flushing.
+
+let destinationHasCapacity = true;
+
+function flushStyleTagsLateForBoundary(styleQueue) {
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs;
+
+  let i = 0;
+
+  if (hrefs.length) {
+    writeChunk(this, lateStyleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    writeChunk(this, lateStyleTagResourceOpen2);
+
+    for (; i < hrefs.length - 1; i++) {
+      writeChunk(this, hrefs[i]);
+      writeChunk(this, spaceSeparator);
+    }
+
+    writeChunk(this, hrefs[i]);
+    writeChunk(this, lateStyleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    destinationHasCapacity = writeChunkAndReturn(this, lateStyleTagTemplateClose); // We wrote style tags for this boundary and we may need to emit a script
+    // to hoist them.
+
+    currentlyRenderingBoundaryHasStylesToHoist = true; // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function hasStylesToHoist(stylesheet) {
+  // We need to reveal boundaries with styles whenever a stylesheet it depends on is either
+  // not flushed or flushed after the preamble (shell).
+  if (stylesheet.state !== PREAMBLE) {
+    currentlyRenderingBoundaryHasStylesToHoist = true;
+    return true;
+  }
+
+  return false;
+}
+
+function writeResourcesForBoundary(destination, boundaryResources, renderState) {
+  // Reset these on each invocation, they are only safe to read in this function
+  currentlyRenderingBoundaryHasStylesToHoist = false;
+  destinationHasCapacity = true; // Flush style tags for each precedence this boundary depends on
+
+  boundaryResources.styles.forEach(flushStyleTagsLateForBoundary, destination); // Determine if this boundary has stylesheets that need to be awaited upon completion
+
+  boundaryResources.stylesheets.forEach(hasStylesToHoist);
+
+  if (currentlyRenderingBoundaryHasStylesToHoist) {
+    renderState.stylesToHoist = true;
+  }
+
+  return destinationHasCapacity;
+}
+
+function flushResource(resource) {
+  for (let i = 0; i < resource.length; i++) {
+    writeChunk(this, resource[i]);
+  }
+
+  resource.length = 0;
+}
+
+const stylesheetFlushingQueue = [];
+
+function flushStyleInPreamble(stylesheet, key, map) {
+  // We still need to encode stylesheet chunks
+  // because unlike most Hoistables and Resources we do not eagerly encode
+  // them during render. This is because if we flush late we have to send a
+  // different encoding and we don't want to encode multiple times
+  pushLinkImpl(stylesheetFlushingQueue, stylesheet.props);
+
+  for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+    writeChunk(this, stylesheetFlushingQueue[i]);
+  }
+
+  stylesheetFlushingQueue.length = 0;
+  stylesheet.state = PREAMBLE;
+}
+
+const styleTagResourceOpen1 = stringToPrecomputedChunk('<style data-precedence="');
+const styleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const spaceSeparator = stringToPrecomputedChunk(' ');
+const styleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const styleTagResourceClose = stringToPrecomputedChunk('</style>');
+
+function flushStylesInPreamble(styleQueue, precedence) {
+  const hasStylesheets = styleQueue.sheets.size > 0;
+  styleQueue.sheets.forEach(flushStyleInPreamble, this);
+  styleQueue.sheets.clear();
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs; // If we don't emit any stylesheets at this precedence we still need to maintain the precedence
+  // order so even if there are no rules for style tags at this precedence we emit an empty style
+  // tag with the data-precedence attribute
+
+  if (!hasStylesheets || hrefs.length) {
+    writeChunk(this, styleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    let i = 0;
+
+    if (hrefs.length) {
+      writeChunk(this, styleTagResourceOpen2);
+
+      for (; i < hrefs.length - 1; i++) {
+        writeChunk(this, hrefs[i]);
+        writeChunk(this, spaceSeparator);
+      }
+
+      writeChunk(this, hrefs[i]);
+    }
+
+    writeChunk(this, styleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    writeChunk(this, styleTagResourceClose); // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function preloadLateStyle(stylesheet) {
+  if (stylesheet.state === PENDING$1) {
+    stylesheet.state = PRELOADED;
+    const preloadProps = preloadAsStylePropsFromProps(stylesheet.props.href, stylesheet.props);
+    pushLinkImpl(stylesheetFlushingQueue, preloadProps);
+
+    for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+      writeChunk(this, stylesheetFlushingQueue[i]);
+    }
+
+    stylesheetFlushingQueue.length = 0;
+  }
+}
+
+function preloadLateStyles(styleQueue) {
+  styleQueue.sheets.forEach(preloadLateStyle, this);
+  styleQueue.sheets.clear();
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+
+function writePreamble(destination, resumableState, renderState, willFlushAllSegments) {
+  // This function must be called exactly once on every request
+  if (!willFlushAllSegments && renderState.externalRuntimeScript) {
+    // If the root segment is incomplete due to suspended tasks
+    // (e.g. willFlushAllSegments = false) and we are using data
+    // streaming format, ensure the external runtime is sent.
+    // (User code could choose to send this even earlier by calling
+    //  preinit(...), if they know they will suspend).
+    const _renderState$external = renderState.externalRuntimeScript,
+          src = _renderState$external.src,
+          chunks = _renderState$external.chunks;
+    internalPreinitScript(resumableState, renderState, src, chunks);
+  }
+
+  const htmlChunks = renderState.htmlChunks;
+  const headChunks = renderState.headChunks;
+  let i = 0; // Emit open tags before Hoistables and Resources
+
+  if (htmlChunks) {
+    // We have an <html> to emit as part of the preamble
+    for (i = 0; i < htmlChunks.length; i++) {
+      writeChunk(destination, htmlChunks[i]);
+    }
+
+    if (headChunks) {
+      for (i = 0; i < headChunks.length; i++) {
+        writeChunk(destination, headChunks[i]);
+      }
+    } else {
+      // We did not render a head but we emitted an <html> so we emit one now
+      writeChunk(destination, startChunkForTag('head'));
+      writeChunk(destination, endOfStartTag);
+    }
+  } else if (headChunks) {
+    // We do not have an <html> but we do have a <head>
+    for (i = 0; i < headChunks.length; i++) {
+      writeChunk(destination, headChunks[i]);
+    }
+  } // Emit high priority Hoistables
+
+
+  const charsetChunks = renderState.charsetChunks;
+
+  for (i = 0; i < charsetChunks.length; i++) {
+    writeChunk(destination, charsetChunks[i]);
+  }
+
+  charsetChunks.length = 0; // emit preconnect resources
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Flush unblocked stylesheets by precedence
+
+  renderState.styles.forEach(flushStylesInPreamble, destination);
+  const importMapChunks = renderState.importMapChunks;
+
+  for (i = 0; i < importMapChunks.length; i++) {
+    writeChunk(destination, importMapChunks[i]);
+  }
+
+  importMapChunks.length = 0;
+  renderState.bootstrapScripts.forEach(flushResource, destination);
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0; // Flush closing head if necessary
+
+  if (htmlChunks && headChunks === null) {
+    // We have an <html> rendered but no <head> rendered. We however inserted
+    // a <head> up above so we need to emit the </head> now. This is safe because
+    // if the main content contained the </head> it would also have provided a
+    // <head>. This means that all the content inside <html> is either <body> or
+    // invalid HTML
+    writeChunk(destination, endChunkForTag('head'));
+  }
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+function writeHoistables(destination, resumableState, renderState) {
+  let i = 0; // Emit high priority Hoistables
+  // We omit charsetChunks because we have already sent the shell and if it wasn't
+  // already sent it is too late now.
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Preload any stylesheets. these will emit in a render instruction that follows this
+  // but we want to kick off preloading as soon as possible
+
+  renderState.styles.forEach(preloadLateStyles, destination); // We only hoist importmaps that are configured through createResponse and that will
+  // always flush in the preamble. Generally we don't expect people to render them as
+  // tags when using React but if you do they are going to be treated like regular inline
+  // scripts and flush after other hoistables which is problematic
+  // bootstrap scripts should flush above script priority but these can only flush in the preamble
+  // so we elide the code here for performance
+
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0;
+}
+function writePostamble(destination, resumableState) {
+  if (resumableState.hasBody) {
+    writeChunk(destination, endChunkForTag('body'));
+  }
+
+  if (resumableState.hasHtml) {
+    writeChunk(destination, endChunkForTag('html'));
+  }
+}
+const arrayFirstOpenBracket = stringToPrecomputedChunk('[');
+const arraySubsequentOpenBracket = stringToPrecomputedChunk(',[');
+const arrayInterstitial = stringToPrecomputedChunk(',');
+const arrayCloseBracket = stringToPrecomputedChunk(']'); // This function writes a 2D array of strings to be embedded in javascript.
+// E.g.
+//  [["JS_escaped_string1", "JS_escaped_string2"]]
+
+function writeStyleResourceDependenciesInJS(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInJS(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInJS(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInJS(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+}
+
+function writeStyleResourceDependencyInJS(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedPrecedence)));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(399, 'link'));
+
+        default:
+          writeStyleResourceAttributeInJS(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInJS(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeName)));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeValue)));
+} // This function writes a 2D array of strings to be embedded in an attribute
+// value and read with JSON.parse in ReactDOMServerExternalRuntime.js
+// E.g.
+//  [[&quot;JSON_escaped_string1&quot;, &quot;JSON_escaped_string2&quot;]]
+
+
+function writeStyleResourceDependenciesInAttr(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInAttr(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInAttr(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInAttr(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+}
+
+function writeStyleResourceDependencyInAttr(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedPrecedence))));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(399, 'link'));
+
+        default:
+          writeStyleResourceAttributeInAttr(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInAttr(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeName))));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeValue))));
+}
+/**
+ * Resources
+ */
+
+
+const PENDING$1 = 0;
+const PRELOADED = 1;
+const PREAMBLE = 2;
+const LATE = 3;
+function createBoundaryResources() {
+  return {
+    styles: new Set(),
+    stylesheets: new Set()
+  };
+}
+function setCurrentlyRenderingBoundaryResourcesTarget(renderState, boundaryResources) {
+  renderState.boundaryResources = boundaryResources;
+}
+
+function getResourceKey(href) {
+  return href;
+}
+
+function getImageResourceKey(href, imageSrcSet, imageSizes) {
+  if (imageSrcSet) {
+    return imageSrcSet + '\n' + (imageSizes || '');
+  }
+
+  return href;
+}
+
+function prefetchDNS(href) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const key = getResourceKey(href);
+
+    if (!resumableState.dnsResources.hasOwnProperty(key)) {
+      resumableState.dnsResources[key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPrefetchDNSAsHeader(href), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this as resettable in case we are prerendering and postpone in the Shell
+        renderState.resets.dns[key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        // Encode as element
+        const resource = [];
+        pushLinkImpl(resource, {
+          href,
+          rel: 'dns-prefetch'
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preconnect(href, crossOrigin) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const bucket = crossOrigin === 'use-credentials' ? 'credentials' : typeof crossOrigin === 'string' ? 'anonymous' : 'default';
+    const key = getResourceKey(href);
+
+    if (!resumableState.connectResources[bucket].hasOwnProperty(key)) {
+      resumableState.connectResources[bucket][key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPreconnectAsHeader(href, crossOrigin), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this in resettableState in case we are prerending and postpone in the Shell
+        renderState.resets.connect[bucket][key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        const resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preconnect',
+          href,
+          crossOrigin
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preload(href, as, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (as && href) {
+    switch (as) {
+      case 'image':
+        {
+          let imageSrcSet, imageSizes, fetchPriority;
+
+          if (options) {
+            imageSrcSet = options.imageSrcSet;
+            imageSizes = options.imageSizes;
+            fetchPriority = options.fetchPriority;
+          }
+
+          const key = getImageResourceKey(href, imageSrcSet, imageSizes);
+
+          if (resumableState.imageResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && fetchPriority === 'high' && ( // Compute the header since we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit a preload as a header so we
+            // track this to make sure we don't reset it.
+            renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+            if (headers.highImagePreloads) {
+              headers.highImagePreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.highImagePreloads += header;
+          } else {
+            // If we don't have headers to write to we have to encode as elements to flush in the head
+            // When we have imageSrcSet the browser probably cannot load the right version from headers
+            // (this should be verified by testing). For now we assume these need to go in the head
+            // as elements even if headers are available.
+            const resource = [];
+            pushLinkImpl(resource, assign({
+              rel: 'preload',
+              // There is a bug in Safari where imageSrcSet is not respected on preload links
+              // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+              // This harms older browers that do not support imageSrcSet by making their preloads not work
+              // but this population is shrinking fast and is already small so we accept this tradeoff.
+              href: imageSrcSet ? undefined : href,
+              as
+            }, options));
+
+            if (fetchPriority === 'high') {
+              renderState.highImagePreloads.add(resource);
+            } else {
+              renderState.bulkPreloads.add(resource); // Stash the resource in case we need to promote it to higher priority
+              // when an img tag is rendered
+
+              renderState.preloads.images.set(key, resource);
+            }
+          }
+
+          break;
+        }
+
+      case 'style':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.styleResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.styleResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.stylesheets.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          break;
+        }
+
+      case 'script':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.scriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          renderState.preloads.scripts.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.scriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          break;
+        }
+
+      default:
+        {
+          const key = getResourceKey(href);
+          const hasAsType = resumableState.unknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.unknownResources[as] = resources;
+          }
+
+          resources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && as === 'font' && ( // We compute the header here because we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit this preload so we
+            // track it here to prevent it from being reset.
+            renderState.resets.font[key] = PRELOAD_NO_CREDS;
+
+            if (headers.fontPreloads) {
+              headers.fontPreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.fontPreloads += header;
+          } else {
+            // We either don't have headers or we are preloading something that does
+            // not warrant elevated priority so we encode as an element.
+            const resource = [];
+
+            const props = assign({
+              rel: 'preload',
+              href,
+              as
+            }, options);
+
+            pushLinkImpl(resource, props);
+
+            switch (as) {
+              case 'font':
+                renderState.fontPreloads.add(resource);
+                break;
+              // intentional fall through
+
+              default:
+                renderState.bulkPreloads.add(resource);
+            }
+          }
+        }
+    } // If we got this far we created a new resource
+
+
+    flushResources(request);
+  }
+}
+
+function preloadModule(href, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    const key = getResourceKey(href);
+    const as = options && typeof options.as === 'string' ? options.as : 'script';
+    let resource;
+
+    switch (as) {
+      case 'script':
+        {
+          if (resumableState.moduleScriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resource = [];
+          resumableState.moduleScriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.moduleScripts.set(key, resource);
+          break;
+        }
+
+      default:
+        {
+          const hasAsType = resumableState.moduleUnknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.moduleUnknownResources[as] = resources;
+          }
+
+          resource = [];
+          resources[key] = PRELOAD_NO_CREDS;
+        }
+    }
+
+    pushLinkImpl(resource, assign({
+      rel: 'modulepreload',
+      href
+    }, options));
+    renderState.bulkPreloads.add(resource); // If we got this far we created a new resource
+
+    flushResources(request);
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    precedence = precedence || 'default';
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+      // to create a StyleQueue
+
+      if (!styleQueue) {
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      }
+
+      const resource = {
+        state: PENDING$1,
+        props: assign({
+          rel: 'stylesheet',
+          href,
+          'data-precedence': precedence
+        }, options)
+      };
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(resource.props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.stylesheets.get(key);
+
+        if (preloadResource && preloadResource.length > 0) {
+          // The Preload for this resource was created in this render pass and has not flushed yet so
+          // we need to clear it to avoid it flushing.
+          preloadResource.length = 0;
+        } else {
+          // Either the preload resource from this render already flushed in this render pass
+          // or the preload flushed in a prior pass (prerender). In either case we need to mark
+          // this resource as already having been preloaded.
+          resource.state = PRELOADED;
+        }
+      } // We add the newly created resource to our StyleQueue and if necessary
+      // track the resource with the currently rendering boundary
+
+
+      styleQueue.sheets.set(key, resource); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+  }
+}
+
+function preinitScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.scriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.scriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.scriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.scripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+}
+
+function preinitModuleScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.moduleScriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.moduleScriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.moduleScriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        type: 'module',
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.moduleScripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+} // This function is only safe to call at Request start time since it assumes
+// that each module has not already been preloaded. If we find a need to preload
+// scripts at any other point in time we will need to check whether the preload
+// already exists and not assume it
+
+
+function preloadBootstrapScriptOrModule(resumableState, renderState, href, props) {
+
+  const key = getResourceKey(href);
+  // used to preinit the resource. If a script can be preinited then it shouldn't
+  // be a bootstrap script/module and if it is a bootstrap script/module then it
+  // must not be safe to emit early. To avoid possibly allowing for preinits of
+  // bootstrap scripts/modules we occlude these keys.
+
+
+  resumableState.scriptResources[key] = EXISTS;
+  resumableState.moduleScriptResources[key] = EXISTS;
+  const resource = [];
+  pushLinkImpl(resource, props);
+  renderState.bootstrapScripts.add(resource);
+}
+
+function internalPreinitScript(resumableState, renderState, src, chunks) {
+  const key = getResourceKey(src);
+
+  if (!resumableState.scriptResources.hasOwnProperty(key)) {
+    const resource = chunks;
+    resumableState.scriptResources[key] = EXISTS;
+    renderState.scripts.add(resource);
+  }
+
+  return;
+}
+
+function preloadAsStylePropsFromProps(href, props) {
+  return {
+    rel: 'preload',
+    as: 'style',
+    href: href,
+    crossOrigin: props.crossOrigin,
+    fetchPriority: props.fetchPriority,
+    integrity: props.integrity,
+    media: props.media,
+    hrefLang: props.hrefLang,
+    referrerPolicy: props.referrerPolicy
+  };
+}
+
+function stylesheetPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    'data-precedence': rawProps.precedence,
+    precedence: null
+  });
+}
+
+function adoptPreloadCredentials(target, preloadState) {
+  if (target.crossOrigin == null) target.crossOrigin = preloadState[0];
+  if (target.integrity == null) target.integrity = preloadState[1];
+}
+
+function getPrefetchDNSAsHeader(href) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  return "<" + escapedHref + ">; rel=dns-prefetch";
+}
+
+function getPreconnectAsHeader(href, crossOrigin) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  let value = "<" + escapedHref + ">; rel=preconnect";
+
+  if (typeof crossOrigin === 'string') {
+    const escapedCrossOrigin = escapeStringForLinkHeaderQuotedParamValueContext(crossOrigin);
+    value += "; crossorigin=\"" + escapedCrossOrigin + "\"";
+  }
+
+  return value;
+}
+
+function getPreloadAsHeader(href, as, params) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  const escapedAs = escapeStringForLinkHeaderQuotedParamValueContext(as);
+  let value = "<" + escapedHref + ">; rel=preload; as=\"" + escapedAs + "\"";
+
+  for (const paramName in params) {
+    if (hasOwnProperty.call(params, paramName)) {
+      const paramValue = params[paramName];
+
+      if (typeof paramValue === 'string') {
+        value += "; " + paramName.toLowerCase() + "=\"" + escapeStringForLinkHeaderQuotedParamValueContext(paramValue) + "\"";
+      }
+    }
+  }
+
+  return value;
+}
+
+function getStylesheetPreloadAsHeader(stylesheet) {
+  const props = stylesheet.props;
+  const preloadOptions = {
+    crossOrigin: props.crossOrigin,
+    integrity: props.integrity,
+    nonce: props.nonce,
+    type: props.type,
+    fetchPriority: props.fetchPriority,
+    referrerPolicy: props.referrerPolicy,
+    media: props.media
+  };
+  return getPreloadAsHeader(props.href, 'style', preloadOptions);
+} // This escaping function is only safe to use for href values being written into
+// a "Link" header in between `<` and `>` characters. The primary concern with the href is
+// to escape the bounding characters as well as new lines. This is unsafe to use in any other
+// context
+
+
+const regexForHrefInLinkHeaderURLContext = /[<>\r\n]/g;
+
+function escapeHrefForLinkHeaderURLContext(hrefInput) {
+
+  const coercedHref = '' + hrefInput;
+  return coercedHref.replace(regexForHrefInLinkHeaderURLContext, escapeHrefForLinkHeaderURLContextReplacer);
+}
+
+function escapeHrefForLinkHeaderURLContextReplacer(match) {
+  switch (match) {
+    case '<':
+      return '%3C';
+
+    case '>':
+      return '%3E';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeLinkHrefForHeaderContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+} // This escaping function is only safe to use for quoted param values in an HTTP header.
+// It is unsafe to use for any value not inside quote marks in parater value position.
+
+
+const regexForLinkHeaderQuotedParamValueContext = /["';,\r\n]/g;
+
+function escapeStringForLinkHeaderQuotedParamValueContext(value, name) {
+
+  const coerced = '' + value;
+  return coerced.replace(regexForLinkHeaderQuotedParamValueContext, escapeStringForLinkHeaderQuotedParamValueContextReplacer);
+}
+
+function escapeStringForLinkHeaderQuotedParamValueContextReplacer(match) {
+  switch (match) {
+    case '"':
+      return '%22';
+
+    case "'":
+      return '%27';
+
+    case ';':
+      return '%3B';
+
+    case ',':
+      return '%2C';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeStringForLinkHeaderQuotedParamValueContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+}
+
+function hoistStyleQueueDependency(styleQueue) {
+  this.styles.add(styleQueue);
+}
+
+function hoistStylesheetDependency(stylesheet) {
+  this.stylesheets.add(stylesheet);
+}
+
+function hoistResources(renderState, source) {
+  const currentBoundaryResources = renderState.boundaryResources;
+
+  if (currentBoundaryResources) {
+    source.styles.forEach(hoistStyleQueueDependency, currentBoundaryResources);
+    source.stylesheets.forEach(hoistStylesheetDependency, currentBoundaryResources);
+  }
+} // This function is called at various times depending on whether we are rendering
+// or prerendering. In this implementation we only actually emit headers once and
+// subsequent calls are ignored. We track whether the request has a completed shell
+// to determine whether we will follow headers with a flush including stylesheets.
+// In the context of prerrender we don't have a completed shell when the request finishes
+// with a postpone in the shell. In the context of a render we don't have a completed shell
+// if this is called before the shell finishes rendering which usually will happen anytime
+// anything suspends in the shell.
+
+function emitEarlyPreloads(renderState, resumableState, shellComplete) {
+  const onHeaders = renderState.onHeaders;
+
+  if (onHeaders) {
+    const headers = renderState.headers;
+
+    if (headers) {
+      let linkHeader = headers.preconnects;
+
+      if (headers.fontPreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.fontPreloads;
+      }
+
+      if (headers.highImagePreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.highImagePreloads;
+      }
+
+      if (!shellComplete) {
+        // We use raw iterators because we want to be able to halt iteration
+        // We could refactor renderState to store these dually in arrays to
+        // make this more efficient at the cost of additional memory and
+        // write overhead. However this code only runs once per request so
+        // for now I consider this sufficient.
+        const queueIter = renderState.styles.values();
+
+        outer: for (let queueStep = queueIter.next(); headers.remainingCapacity > 0 && !queueStep.done; queueStep = queueIter.next()) {
+          const sheets = queueStep.value.sheets;
+          const sheetIter = sheets.values();
+
+          for (let sheetStep = sheetIter.next(); headers.remainingCapacity > 0 && !sheetStep.done; sheetStep = sheetIter.next()) {
+            const sheet = sheetStep.value;
+            const props = sheet.props;
+            const key = getResourceKey(props.href);
+            const header = getStylesheetPreloadAsHeader(sheet); // We mutate the capacity b/c we don't want to keep checking if later headers will fit.
+            // This means that a particularly long header might close out the header queue where later
+            // headers could still fit. We could in the future alter the behavior here based on prerender vs render
+            // since during prerender we aren't as concerned with pure runtime performance.
+
+            if ((headers.remainingCapacity -= header.length) >= 2) {
+              renderState.resets.style[key] = PRELOAD_NO_CREDS;
+
+              if (linkHeader) {
+                linkHeader += ', ';
+              }
+
+              linkHeader += header; // We already track that the resource exists in resumableState however
+              // if the resumableState resets because we postponed in the shell
+              // which is what is happening in this branch if we are prerendering
+              // then we will end up resetting the resumableState. When it resets we
+              // want to record the fact that this stylesheet was already preloaded
+
+              renderState.resets.style[key] = typeof props.crossOrigin === 'string' || typeof props.integrity === 'string' ? [props.crossOrigin, props.integrity] : PRELOAD_NO_CREDS;
+            } else {
+              break outer;
+            }
+          }
+        }
+      }
+
+      if (linkHeader) {
+        onHeaders({
+          Link: linkHeader
+        });
+      } else {
+        // We still call this with no headers because a user may be using it as a signal that
+        // it React will not provide any headers
+        onHeaders({});
+      }
+
+      renderState.headers = null;
+      return;
+    }
+  }
+}
+const NotPendingTransition = NotPending;
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+const REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_CONTEXT_TYPE = Symbol.for('react.context');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SCOPE_TYPE = Symbol.for('react.scope');
+const REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');
+const REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+const REACT_LEGACY_HIDDEN_TYPE = Symbol.for('react.legacy_hidden');
+const REACT_CACHE_TYPE = Symbol.for('react.cache');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+function getWrappedName(outerType, innerType, wrapperName) {
+  const displayName = outerType.displayName;
+
+  if (displayName) {
+    return displayName;
+  }
+
+  const functionName = innerType.displayName || innerType.name || '';
+  return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
+} // Keep in sync with react-reconciler/getComponentNameFromFiber
+
+
+function getContextName(type) {
+  return type.displayName || 'Context';
+} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+
+function getComponentNameFromType(type) {
+  if (type == null) {
+    // Host root, text node or just invalid type.
+    return null;
+  }
+
+  if (typeof type === 'function') {
+    return type.displayName || type.name || null;
+  }
+
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_FRAGMENT_TYPE:
+      return 'Fragment';
+
+    case REACT_PORTAL_TYPE:
+      return 'Portal';
+
+    case REACT_PROFILER_TYPE:
+      return 'Profiler';
+
+    case REACT_STRICT_MODE_TYPE:
+      return 'StrictMode';
+
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+
+    case REACT_CACHE_TYPE:
+      {
+        return 'Cache';
+      }
+
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        const context = type;
+        return getContextName(context) + '.Consumer';
+
+      case REACT_PROVIDER_TYPE:
+        const provider = type;
+        return getContextName(provider._context) + '.Provider';
+
+      case REACT_FORWARD_REF_TYPE:
+        return getWrappedName(type, type.render, 'ForwardRef');
+
+      case REACT_MEMO_TYPE:
+        const outerName = type.displayName || null;
+
+        if (outerName !== null) {
+          return outerName;
+        }
+
+        return getComponentNameFromType(type.type) || 'Memo';
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            return getComponentNameFromType(init(payload));
+          } catch (x) {
+            return null;
+          }
+        }
+
+      case REACT_SERVER_CONTEXT_TYPE:
+        {
+          const context2 = type;
+          return (context2.displayName || context2._globalName) + '.Provider';
+        }
+
+    }
+  }
+
+  return null;
+}
+
+const emptyContextObject = {};
+
+function getMaskedContext(type, unmaskedContext) {
+  {
+    const contextTypes = type.contextTypes;
+
+    if (!contextTypes) {
+      return emptyContextObject;
+    }
+
+    const context = {};
+
+    for (const key in contextTypes) {
+      context[key] = unmaskedContext[key];
+    }
+
+    return context;
+  }
+}
+function processChildContext(instance, type, parentContext, childContextTypes) {
+  {
+    // TODO (bvaughn) Replace this behavior with an invariant() in the future.
+    // It has only been added in Fiber to match the (unintentional) behavior in Stack.
+    if (typeof instance.getChildContext !== 'function') {
+
+      return parentContext;
+    }
+
+    const childContext = instance.getChildContext();
+
+    for (const contextKey in childContext) {
+      if (!(contextKey in childContextTypes)) {
+        throw Error(formatProdErrorMessage(108, getComponentNameFromType(type) || 'Unknown', contextKey));
+      }
+    }
+
+    return assign({}, parentContext, childContext);
+  }
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw Error(formatProdErrorMessage(401));
+      }
+    } else {
+      if (parentNext === null) {
+        throw Error(formatProdErrorMessage(401));
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext);
+    } // On the way back, we push the new ones that weren't common.
+
+
+    pushNode(next);
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw Error(formatProdErrorMessage(402));
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw Error(formatProdErrorMessage(402));
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function pushProvider(context, nextValue) {
+  let prevValue;
+
+  {
+    prevValue = context._currentValue;
+    context._currentValue = nextValue;
+  }
+
+  const prevNode = currentActiveSnapshot;
+  const newNode = {
+    parent: prevNode,
+    depth: prevNode === null ? 0 : prevNode.depth + 1,
+    context: context,
+    parentValue: prevValue,
+    value: nextValue
+  };
+  currentActiveSnapshot = newNode;
+  return newNode;
+}
+function popProvider(context) {
+  const prevSnapshot = currentActiveSnapshot;
+
+  if (prevSnapshot === null) {
+    throw Error(formatProdErrorMessage(403));
+  }
+
+  {
+    const value = prevSnapshot.parentValue;
+
+    if (value === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      prevSnapshot.context._currentValue = prevSnapshot.context._defaultValue;
+    } else {
+      prevSnapshot.context._currentValue = value;
+    }
+  }
+
+  return currentActiveSnapshot = prevSnapshot.parent;
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+/**
+ * `ReactInstanceMap` maintains a mapping from a public facing stateful
+ * instance (key) and the internal representation (value). This allows public
+ * methods to accept the user facing instance as an argument and map them back
+ * to internal methods.
+ *
+ * Note that this module is currently shared and assumed to be stateless.
+ * If this becomes an actual Map, that will break.
+ */
+function get(key) {
+  return key._reactInternals;
+}
+function set(key, value) {
+  key._reactInternals = value;
+}
+
+const classComponentUpdater = {
+  isMounted(inst) {
+    return false;
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueSetState(inst, payload, callback) {
+    const internals = get(inst);
+
+    if (internals.queue === null) ; else {
+      internals.queue.push(payload);
+    }
+  },
+
+  enqueueReplaceState(inst, payload, callback) {
+    const internals = get(inst);
+    internals.replace = true;
+    internals.queue = [payload];
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueForceUpdate(inst, callback) {
+  }
+
+};
+
+function applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, prevState, nextProps) {
+  const partialState = getDerivedStateFromProps(nextProps, prevState);
+
+
+  const newState = partialState === null || partialState === undefined ? prevState : assign({}, prevState, partialState);
+  return newState;
+}
+
+function constructClassInstance(ctor, props, maskedLegacyContext) {
+  let context = emptyContextObject;
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    context = readContext$1(contextType);
+  } else {
+    context = maskedLegacyContext;
+  }
+
+  const instance = new ctor(props, context);
+
+  return instance;
+}
+
+function callComponentWillMount(type, instance) {
+  const oldState = instance.state;
+
+  if (typeof instance.componentWillMount === 'function') {
+
+    instance.componentWillMount();
+  }
+
+  if (typeof instance.UNSAFE_componentWillMount === 'function') {
+    instance.UNSAFE_componentWillMount();
+  }
+
+  if (oldState !== instance.state) {
+
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+}
+
+function processUpdateQueue(internalInstance, inst, props, maskedLegacyContext) {
+  if (internalInstance.queue !== null && internalInstance.queue.length > 0) {
+    const oldQueue = internalInstance.queue;
+    const oldReplace = internalInstance.replace;
+    internalInstance.queue = null;
+    internalInstance.replace = false;
+
+    if (oldReplace && oldQueue.length === 1) {
+      inst.state = oldQueue[0];
+    } else {
+      let nextState = oldReplace ? oldQueue[0] : inst.state;
+      let dontMutate = true;
+
+      for (let i = oldReplace ? 1 : 0; i < oldQueue.length; i++) {
+        const partial = oldQueue[i];
+        const partialState = typeof partial === 'function' ? partial.call(inst, nextState, props, maskedLegacyContext) : partial;
+
+        if (partialState != null) {
+          if (dontMutate) {
+            dontMutate = false;
+            nextState = assign({}, nextState, partialState);
+          } else {
+            assign(nextState, partialState);
+          }
+        }
+      }
+
+      inst.state = nextState;
+    }
+  } else {
+    internalInstance.queue = null;
+  }
+} // Invokes the mount life-cycles on a previously never rendered instance.
+
+
+function mountClassInstance(instance, ctor, newProps, maskedLegacyContext) {
+
+  const initialState = instance.state !== undefined ? instance.state : null;
+  instance.updater = classComponentUpdater;
+  instance.props = newProps;
+  instance.state = initialState; // We don't bother initializing the refs object on the server, since we're not going to resolve them anyway.
+  // The internal instance will be used to manage updates that happen during this mount.
+
+  const internalInstance = {
+    queue: [],
+    replace: false
+  };
+  set(instance, internalInstance);
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    instance.context = readContext$1(contextType);
+  } else {
+    instance.context = maskedLegacyContext;
+  }
+
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    instance.state = applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, initialState, newProps);
+  } // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+
+  if (typeof ctor.getDerivedStateFromProps !== 'function' && typeof instance.getSnapshotBeforeUpdate !== 'function' && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
+    callComponentWillMount(ctor, instance); // If we had additional state updates during this life-cycle, let's
+    // process them now.
+
+    processUpdateQueue(internalInstance, instance, newProps, maskedLegacyContext);
+  }
+}
+
+// Ids are base 32 strings whose binary representation corresponds to the
+// position of a node in a tree.
+// Every time the tree forks into multiple children, we add additional bits to
+// the left of the sequence that represent the position of the child within the
+// current level of children.
+//
+//      00101       00010001011010101
+//      ╰─┬─╯       ╰───────┬───────╯
+//   Fork 5 of 20       Parent id
+//
+// The leading 0s are important. In the above example, you only need 3 bits to
+// represent slot 5. However, you need 5 bits to represent all the forks at
+// the current level, so we must account for the empty bits at the end.
+//
+// For this same reason, slots are 1-indexed instead of 0-indexed. Otherwise,
+// the zeroth id at a level would be indistinguishable from its parent.
+//
+// If a node has only one child, and does not materialize an id (i.e. does not
+// contain a useId hook), then we don't need to allocate any space in the
+// sequence. It's treated as a transparent indirection. For example, these two
+// trees produce the same ids:
+//
+// <>                          <>
+//   <Indirection>               <A />
+//     <A />                     <B />
+//   </Indirection>            </>
+//   <B />
+// </>
+//
+// However, we cannot skip any node that materializes an id. Otherwise, a parent
+// id that does not fork would be indistinguishable from its child id. For
+// example, this tree does not fork, but the parent and child must have
+// different ids.
+//
+// <Parent>
+//   <Child />
+// </Parent>
+//
+// To handle this scenario, every time we materialize an id, we allocate a
+// new level with a single slot. You can think of this as a fork with only one
+// prong, or an array of children with length 1.
+//
+// It's possible for the size of the sequence to exceed 32 bits, the max
+// size for bitwise operations. When this happens, we make more room by
+// converting the right part of the id to a string and storing it in an overflow
+// variable. We use a base 32 string representation, because 32 is the largest
+// power of 2 that is supported by toString(). We want the base to be large so
+// that the resulting ids are compact, and we want the base to be a power of 2
+// because every log2(base) bits corresponds to a single character, i.e. every
+// log2(32) = 5 bits. That means we can lop bits off the end 5 at a time without
+// affecting the final result.
+const emptyTreeContext = {
+  id: 1,
+  overflow: ''
+};
+function getTreeId(context) {
+  const overflow = context.overflow;
+  const idWithLeadingBit = context.id;
+  const id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
+  return id.toString(32) + overflow;
+}
+function pushTreeContext(baseContext, totalChildren, index) {
+  const baseIdWithLeadingBit = baseContext.id;
+  const baseOverflow = baseContext.overflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
+  // of the id; we use it to account for leading 0s.
+
+  const baseLength = getBitLength(baseIdWithLeadingBit) - 1;
+  const baseId = baseIdWithLeadingBit & ~(1 << baseLength);
+  const slot = index + 1;
+  const length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
+  // consideration the leading 1 we use to mark the end of the sequence.
+
+  if (length > 30) {
+    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
+    // This branch assumes the length of the base id is greater than 5; it won't
+    // work for smaller ids, because you need 5 bits per character.
+    //
+    // We encode the id in multiple steps: first the base id, then the
+    // remaining digits.
+    //
+    // Each 5 bit sequence corresponds to a single base 32 character. So for
+    // example, if the current id is 23 bits long, we can convert 20 of those
+    // bits into a string of 4 characters, with 3 bits left over.
+    //
+    // First calculate how many bits in the base id represent a complete
+    // sequence of characters.
+    const numberOfOverflowBits = baseLength - baseLength % 5; // Then create a bitmask that selects only those bits.
+
+    const newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
+
+    const newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
+
+    const restOfBaseId = baseId >> numberOfOverflowBits;
+    const restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
+    // we made more room, this time it won't overflow.
+
+    const restOfLength = getBitLength(totalChildren) + restOfBaseLength;
+    const restOfNewBits = slot << restOfBaseLength;
+    const id = restOfNewBits | restOfBaseId;
+    const overflow = newOverflow + baseOverflow;
+    return {
+      id: 1 << restOfLength | id,
+      overflow
+    };
+  } else {
+    // Normal path
+    const newBits = slot << baseLength;
+    const id = newBits | baseId;
+    const overflow = baseOverflow;
+    return {
+      id: 1 << length | id,
+      overflow
+    };
+  }
+}
+
+function getBitLength(number) {
+  return 32 - clz32(number);
+}
+
+function getLeadingBit(id) {
+  return 1 << getBitLength(id) - 1;
+} // TODO: Math.clz32 is supported in Node 12+. Maybe we can drop the fallback.
+
+
+const 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
+
+const log = Math.log;
+const LN2 = Math.LN2;
+
+function clz32Fallback(x) {
+  const asUint = x >>> 0;
+
+  if (asUint === 0) {
+    return 32;
+  }
+
+  return 31 - (log(asUint) / LN2 | 0) | 0;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFlightWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = Error(formatProdErrorMessage(460));
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop$2() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop$2, noop$2);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw Error(formatProdErrorMessage(459));
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+
+const objectIs = // $FlowFixMe[method-unbinding]
+typeof Object.is === 'function' ? Object.is : is;
+
+let currentlyRenderingComponent = null;
+let currentlyRenderingTask = null;
+let currentlyRenderingRequest = null;
+let currentlyRenderingKeyPath = null;
+let firstWorkInProgressHook = null;
+let workInProgressHook = null; // Whether the work-in-progress hook is a re-rendered hook
+
+let isReRender = false; // Whether an update was scheduled during the currently executing render pass.
+
+let didScheduleRenderPhaseUpdate = false; // Counts the number of useId hooks in this component
+
+let localIdCounter = 0; // Chunks that should be pushed to the stream once the component
+// finishes rendering.
+// Counts the number of useFormState calls in this component
+
+let formStateCounter = 0; // The index of the useFormState hook that matches the one passed in at the
+// root during an MPA navigation, if any.
+
+let formStateMatchingIndex = -1; // Counts the number of use(thenable) calls in this component
+
+let thenableIndexCounter = 0;
+let thenableState = null; // Lazily created map of render-phase updates
+
+let renderPhaseUpdates = null; // Counter to prevent infinite loops.
+
+let numberOfReRenders = 0;
+const RE_RENDER_LIMIT = 25;
+
+function resolveCurrentlyRenderingComponent() {
+  if (currentlyRenderingComponent === null) {
+    throw Error(formatProdErrorMessage(321));
+  }
+
+  return currentlyRenderingComponent;
+}
+
+function areHookInputsEqual(nextDeps, prevDeps) {
+  if (prevDeps === null) {
+
+    return false;
+  }
+
+
+  for (let i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    if (objectIs(nextDeps[i], prevDeps[i])) {
+      continue;
+    }
+
+    return false;
+  }
+
+  return true;
+}
+
+function createHook() {
+  if (numberOfReRenders > 0) {
+    throw Error(formatProdErrorMessage(312));
+  }
+
+  return {
+    memoizedState: null,
+    queue: null,
+    next: null
+  };
+}
+
+function createWorkInProgressHook() {
+  if (workInProgressHook === null) {
+    // This is the first hook in the list
+    if (firstWorkInProgressHook === null) {
+      isReRender = false;
+      firstWorkInProgressHook = workInProgressHook = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = firstWorkInProgressHook;
+    }
+  } else {
+    if (workInProgressHook.next === null) {
+      isReRender = false; // Append to the end of the list
+
+      workInProgressHook = workInProgressHook.next = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = workInProgressHook.next;
+    }
+  }
+
+  return workInProgressHook;
+}
+
+function prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState) {
+  currentlyRenderingComponent = componentIdentity;
+  currentlyRenderingTask = task;
+  currentlyRenderingRequest = request;
+  currentlyRenderingKeyPath = keyPath;
+  // didScheduleRenderPhaseUpdate = false;
+  // firstWorkInProgressHook = null;
+  // numberOfReRenders = 0;
+  // renderPhaseUpdates = null;
+  // workInProgressHook = null;
+
+
+  localIdCounter = 0;
+  formStateCounter = 0;
+  formStateMatchingIndex = -1;
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function finishHooks(Component, props, children, refOrContext) {
+  // This must be called after every function component to prevent hooks from
+  // being used in classes.
+  while (didScheduleRenderPhaseUpdate) {
+    // Updates were scheduled during the render phase. They are stored in
+    // the `renderPhaseUpdates` map. Call the component again, reusing the
+    // work-in-progress hooks and applying the additional updates on top. Keep
+    // restarting until no more updates are scheduled.
+    didScheduleRenderPhaseUpdate = false;
+    localIdCounter = 0;
+    formStateCounter = 0;
+    formStateMatchingIndex = -1;
+    thenableIndexCounter = 0;
+    numberOfReRenders += 1; // Start over from the beginning of the list
+
+    workInProgressHook = null;
+    children = Component(props, refOrContext);
+  }
+
+  resetHooksState();
+  return children;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+function checkDidRenderIdHook() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  const didRenderIdHook = localIdCounter !== 0;
+  return didRenderIdHook;
+}
+function getFormStateCount() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateCounter;
+}
+function getFormStateMatchingIndex() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateMatchingIndex;
+} // Reset the internal hooks state if an error occurs while rendering a component
+
+function resetHooksState() {
+
+  currentlyRenderingComponent = null;
+  currentlyRenderingTask = null;
+  currentlyRenderingRequest = null;
+  currentlyRenderingKeyPath = null;
+  didScheduleRenderPhaseUpdate = false;
+  firstWorkInProgressHook = null;
+  numberOfReRenders = 0;
+  renderPhaseUpdates = null;
+  workInProgressHook = null;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+function useContext(context) {
+
+  resolveCurrentlyRenderingComponent();
+  return readContext$1(context);
+}
+
+function basicStateReducer(state, action) {
+  // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
+  return typeof action === 'function' ? action(state) : action;
+}
+
+function useState(initialState) {
+
+  return useReducer(basicStateReducer, // useReducer has a special case to support lazy useState initializers
+  initialState);
+}
+function useReducer(reducer, initialArg, init) {
+
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+
+  if (isReRender) {
+    // This is a re-render. Apply the new render phase updates to the previous
+    // current hook.
+    const queue = workInProgressHook.queue;
+    const dispatch = queue.dispatch;
+
+    if (renderPhaseUpdates !== null) {
+      // Render phase updates are stored in a map of queue -> linked list
+      const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+      if (firstRenderPhaseUpdate !== undefined) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        renderPhaseUpdates.delete(queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+        let newState = workInProgressHook.memoizedState;
+        let update = firstRenderPhaseUpdate;
+
+        do {
+          // Process this render phase update. We don't have to check the
+          // priority because it will always be the same as the current
+          // render's.
+          const action = update.action;
+
+          newState = reducer(newState, action);
+
+
+          update = update.next;
+        } while (update !== null); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+        workInProgressHook.memoizedState = newState;
+        return [newState, dispatch];
+      }
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    return [workInProgressHook.memoizedState, dispatch];
+  } else {
+
+    let initialState;
+
+    if (reducer === basicStateReducer) {
+      // Special case for `useState`.
+      initialState = typeof initialArg === 'function' ? initialArg() : initialArg;
+    } else {
+      initialState = init !== undefined ? init(initialArg) : initialArg;
+    }
+
+
+    workInProgressHook.memoizedState = initialState; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    const queue = workInProgressHook.queue = {
+      last: null,
+      dispatch: null
+    };
+    const dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingComponent, queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    return [workInProgressHook.memoizedState, dispatch];
+  }
+}
+
+function useMemo(nextCreate, deps) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+
+  if (workInProgressHook !== null) {
+    const prevState = workInProgressHook.memoizedState;
+
+    if (prevState !== null) {
+      if (nextDeps !== null) {
+        const prevDeps = prevState[1];
+
+        if (areHookInputsEqual(nextDeps, prevDeps)) {
+          return prevState[0];
+        }
+      }
+    }
+  }
+
+  const nextValue = nextCreate();
+
+
+  workInProgressHook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
+
+function useRef(initialValue) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const previousRef = workInProgressHook.memoizedState;
+
+  if (previousRef === null) {
+    const ref = {
+      current: initialValue
+    };
+
+
+    workInProgressHook.memoizedState = ref;
+    return ref;
+  } else {
+    return previousRef;
+  }
+}
+
+function dispatchAction(componentIdentity, queue, action) {
+  if (numberOfReRenders >= RE_RENDER_LIMIT) {
+    throw Error(formatProdErrorMessage(301));
+  }
+
+  if (componentIdentity === currentlyRenderingComponent) {
+    // This is a render phase update. Stash it in a lazily-created map of
+    // queue -> linked list of updates. After this render pass, we'll restart
+    // and apply the stashed updates on top of the work-in-progress hook.
+    didScheduleRenderPhaseUpdate = true;
+    const update = {
+      action,
+      next: null
+    };
+
+    if (renderPhaseUpdates === null) {
+      renderPhaseUpdates = new Map();
+    }
+
+    const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+    if (firstRenderPhaseUpdate === undefined) {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      renderPhaseUpdates.set(queue, update);
+    } else {
+      // Append the update to the end of the list.
+      let lastRenderPhaseUpdate = firstRenderPhaseUpdate;
+
+      while (lastRenderPhaseUpdate.next !== null) {
+        lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+      }
+
+      lastRenderPhaseUpdate.next = update;
+    }
+  }
+}
+
+function useCallback(callback, deps) {
+  return useMemo(() => callback, deps);
+}
+
+function throwOnUseEffectEventCall() {
+  throw Error(formatProdErrorMessage(440));
+}
+
+function useEffectEvent(callback) {
+  // $FlowIgnore[incompatible-return]
+  return throwOnUseEffectEventCall;
+}
+
+function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  if (getServerSnapshot === undefined) {
+    throw Error(formatProdErrorMessage(407));
+  }
+
+  return getServerSnapshot();
+}
+
+function useDeferredValue(value, initialValue) {
+  resolveCurrentlyRenderingComponent();
+
+  {
+    return initialValue !== undefined ? initialValue : value;
+  }
+}
+
+function unsupportedStartTransition() {
+  throw Error(formatProdErrorMessage(394));
+}
+
+function useTransition() {
+  resolveCurrentlyRenderingComponent();
+  return [false, unsupportedStartTransition];
+}
+
+function useHostTransitionStatus() {
+  resolveCurrentlyRenderingComponent();
+  return NotPendingTransition;
+}
+
+function unsupportedSetOptimisticState() {
+  throw Error(formatProdErrorMessage(479));
+}
+
+function useOptimistic(passthrough, reducer) {
+  resolveCurrentlyRenderingComponent();
+  return [passthrough, unsupportedSetOptimisticState];
+}
+
+function createPostbackFormStateKey(permalink, componentKeyPath, hookIndex) {
+  if (permalink !== undefined) {
+    // Don't bother to hash a permalink-based key since it's already short.
+    return 'p' + permalink;
+  } else {
+    // Append a node to the key path that represents the form state hook.
+    const keyPath = [componentKeyPath, null, hookIndex]; // Key paths are hashed to reduce the size. It does not need to be secure,
+    // and it's more important that it's fast than that it's completely
+    // collision-free.
+
+    const keyPathHash = createFastHashJS(JSON.stringify(keyPath));
+    return 'k' + keyPathHash;
+  }
+}
+
+function useFormState(action, initialState, permalink) {
+  resolveCurrentlyRenderingComponent(); // Count the number of useFormState hooks per component. We also use this to
+  // track the position of this useFormState hook relative to the other ones in
+  // this component, so we can generate a unique key for each one.
+
+  const formStateHookIndex = formStateCounter++;
+  const request = currentlyRenderingRequest; // $FlowIgnore[prop-missing]
+
+  const formAction = action.$$FORM_ACTION;
+
+  if (typeof formAction === 'function') {
+    // This is a server action. These have additional features to enable
+    // MPA-style form submissions with progressive enhancement.
+    // TODO: If the same permalink is passed to multiple useFormStates, and
+    // they all have the same action signature, Fizz will pass the postback
+    // state to all of them. We should probably only pass it to the first one,
+    // and/or warn.
+    // The key is lazily generated and deduped so the that the keypath doesn't
+    // get JSON.stringify-ed unnecessarily, and at most once.
+    let nextPostbackStateKey = null; // Determine the current form state. If we received state during an MPA form
+    // submission, then we will reuse that, if the action identity matches.
+    // Otherwise we'll use the initial state argument. We will emit a comment
+    // marker into the stream that indicates whether the state was reused.
+
+    let state = initialState;
+    const componentKeyPath = currentlyRenderingKeyPath;
+    const postbackFormState = getFormState(request); // $FlowIgnore[prop-missing]
+
+    const isSignatureEqual = action.$$IS_SIGNATURE_EQUAL;
+
+    if (postbackFormState !== null && typeof isSignatureEqual === 'function') {
+      const postbackKey = postbackFormState[1];
+      const postbackReferenceId = postbackFormState[2];
+      const postbackBoundArity = postbackFormState[3];
+
+      if (isSignatureEqual.call(action, postbackReferenceId, postbackBoundArity)) {
+        nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+
+        if (postbackKey === nextPostbackStateKey) {
+          // This was a match
+          formStateMatchingIndex = formStateHookIndex; // Reuse the state that was submitted by the form.
+
+          state = postbackFormState[0];
+        }
+      }
+    } // Bind the state to the first argument of the action.
+
+
+    const boundAction = action.bind(null, state); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    }; // $FlowIgnore[prop-missing]
+
+
+    if (typeof boundAction.$$FORM_ACTION === 'function') {
+      // $FlowIgnore[prop-missing]
+      dispatch.$$FORM_ACTION = prefix => {
+        const metadata = boundAction.$$FORM_ACTION(prefix); // Override the action URL
+
+        if (permalink !== undefined) {
+
+          permalink += '';
+          metadata.action = permalink;
+        }
+
+        const formData = metadata.data;
+
+        if (formData) {
+          if (nextPostbackStateKey === null) {
+            nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+          }
+
+          formData.append('$ACTION_KEY', nextPostbackStateKey);
+        }
+
+        return metadata;
+      };
+    }
+
+    return [state, dispatch];
+  } else {
+    // This is not a server action, so the implementation is much simpler.
+    // Bind the state to the first argument of the action.
+    const boundAction = action.bind(null, initialState); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    };
+
+    return [initialState, dispatch];
+  }
+}
+
+function useId() {
+  const task = currentlyRenderingTask;
+  const treeId = getTreeId(task.treeContext);
+  const resumableState = currentResumableState;
+
+  if (resumableState === null) {
+    throw Error(formatProdErrorMessage(404));
+  }
+
+  const localId = localIdCounter++;
+  return makeId(resumableState, treeId, localId);
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable;
+      return unwrapThenable(thenable);
+    } else if (usable.$$typeof === REACT_CONTEXT_TYPE || usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+  throw Error(formatProdErrorMessage(438, String(usable)));
+}
+
+function unwrapThenable(thenable) {
+  const index = thenableIndexCounter;
+  thenableIndexCounter += 1;
+
+  if (thenableState === null) {
+    thenableState = createThenableState();
+  }
+
+  return trackUsedThenable(thenableState, thenable, index);
+}
+
+function unsupportedRefresh() {
+  throw Error(formatProdErrorMessage(393));
+}
+
+function useCacheRefresh() {
+  return unsupportedRefresh;
+}
+
+function useMemoCache(size) {
+  const data = new Array(size);
+
+  for (let i = 0; i < size; i++) {
+    data[i] = REACT_MEMO_CACHE_SENTINEL;
+  }
+
+  return data;
+}
+
+function noop$1() {}
+
+const HooksDispatcher = {
+  readContext,
+  use,
+  useContext,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+  useInsertionEffect: noop$1,
+  useLayoutEffect: noop$1,
+  useCallback,
+  // useImperativeHandle is not run in the server environment
+  useImperativeHandle: noop$1,
+  // Effects are not run in the server environment.
+  useEffect: noop$1,
+  // Debugging effect
+  useDebugValue: noop$1,
+  useDeferredValue,
+  useTransition,
+  useId,
+  // Subscriptions are not setup in a server environment.
+  useSyncExternalStore
+};
+
+{
+  HooksDispatcher.useCacheRefresh = useCacheRefresh;
+}
+
+{
+  HooksDispatcher.useEffectEvent = useEffectEvent;
+}
+
+{
+  HooksDispatcher.useMemoCache = useMemoCache;
+}
+
+{
+  HooksDispatcher.useHostTransitionStatus = useHostTransitionStatus;
+}
+
+{
+  HooksDispatcher.useOptimistic = useOptimistic;
+  HooksDispatcher.useFormState = useFormState;
+}
+
+let currentResumableState = null;
+function setCurrentResumableState(resumableState) {
+  currentResumableState = resumableState;
+}
+
+function getCacheSignal() {
+  throw Error(formatProdErrorMessage(248));
+}
+
+function getCacheForType(resourceType) {
+  throw Error(formatProdErrorMessage(248));
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal,
+  getCacheForType
+};
+
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+const ReactCurrentCache = ReactSharedInternals.ReactCurrentCache;
+// The name might be minified but we assume that it's going to be the same generated name. Typically
+// because it's just the same compiled output in practice.
+// resume with segmentID at the index
+
+const CLIENT_RENDERED = 4; // if it errors or infinitely suspends
+
+const PENDING = 0;
+const COMPLETED = 1;
+const FLUSHED = 2;
+const ABORTED = 3;
+const ERRORED = 4;
+const POSTPONED = 5;
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2; // This is a default heuristic for how to split up the HTML content into progressive
+// loading. Our goal is to be able to display additional new content about every 500ms.
+// Faster than that is unnecessary and should be throttled on the client. It also
+// adds unnecessary overhead to do more splits. We don't know if it's a higher or lower
+// end device but higher end suffer less from the overhead than lower end does from
+// not getting small enough pieces. We error on the side of low end.
+// We base this on low end 3G speeds which is about 500kbits per second. We assume
+// that there can be a reasonable drop off from max bandwidth which leaves you with
+// as little as 80%. We can receive half of that each 500ms - at best. In practice,
+// a little bandwidth is lost to processing and contention - e.g. CSS and images that
+// are downloaded along with the main content. So we estimate about half of that to be
+// the lower end throughput. In other words, we expect that you can at least show
+// about 12.5kb of content per 500ms. Not counting starting latency for the first
+// paint.
+// 500 * 1024 / 8 * .8 * 0.5 / 2
+
+const DEFAULT_PROGRESSIVE_CHUNK_SIZE = 12800;
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+
+  return null;
+}
+
+function noop() {}
+
+function createRequest(children, resumableState, renderState, rootFormatContext, progressiveChunkSize, onError, onAllReady, onShellReady, onShellError, onFatalError, onPostpone, formState) {
+  prepareHostDispatcher();
+  const pingedTasks = [];
+  const abortSet = new Set();
+  const request = {
+    destination: null,
+    flushScheduled: false,
+    resumableState,
+    renderState,
+    rootFormatContext,
+    progressiveChunkSize: progressiveChunkSize === undefined ? DEFAULT_PROGRESSIVE_CHUNK_SIZE : progressiveChunkSize,
+    status: OPEN,
+    fatalError: null,
+    nextSegmentId: 0,
+    allPendingTasks: 0,
+    pendingRootTasks: 0,
+    completedRootSegment: null,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    clientRenderedBoundaries: [],
+    completedBoundaries: [],
+    partialBoundaries: [],
+    trackedPostpones: null,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? noop : onPostpone,
+    onAllReady: onAllReady === undefined ? noop : onAllReady,
+    onShellReady: onShellReady === undefined ? noop : onShellReady,
+    onShellError: onShellError === undefined ? noop : onShellError,
+    onFatalError: onFatalError === undefined ? noop : onFatalError,
+    formState: formState === undefined ? null : formState
+  }; // This segment represents the root fallback.
+
+  const rootSegment = createPendingSegment(request, 0, null, rootFormatContext, // Root segments are never embedded in Text on either edge
+  false, false); // There is no parent so conceptually, we're unblocked to flush this segment.
+
+  rootSegment.parentFlushed = true;
+  const rootTask = createRenderTask(request, null, children, -1, null, rootSegment, abortSet, null, rootFormatContext, emptyContextObject, rootContextSnapshot, emptyTreeContext);
+  pingedTasks.push(rootTask);
+  return request;
+}
+function createPrerenderRequest(children, resumableState, renderState, rootFormatContext, progressiveChunkSize, onError, onAllReady, onShellReady, onShellError, onFatalError, onPostpone) {
+  const request = createRequest(children, resumableState, renderState, rootFormatContext, progressiveChunkSize, onError, onAllReady, onShellReady, onShellError, onFatalError, onPostpone, undefined); // Start tracking postponed holes during this render.
+
+  request.trackedPostpones = {
+    workingMap: new Map(),
+    rootNodes: [],
+    rootSlots: null
+  };
+  return request;
+}
+function resumeRequest(children, postponedState, renderState, onError, onAllReady, onShellReady, onShellError, onFatalError, onPostpone) {
+  prepareHostDispatcher();
+  const pingedTasks = [];
+  const abortSet = new Set();
+  const request = {
+    destination: null,
+    flushScheduled: false,
+    resumableState: postponedState.resumableState,
+    renderState,
+    rootFormatContext: postponedState.rootFormatContext,
+    progressiveChunkSize: postponedState.progressiveChunkSize,
+    status: OPEN,
+    fatalError: null,
+    nextSegmentId: postponedState.nextSegmentId,
+    allPendingTasks: 0,
+    pendingRootTasks: 0,
+    completedRootSegment: null,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    clientRenderedBoundaries: [],
+    completedBoundaries: [],
+    partialBoundaries: [],
+    trackedPostpones: null,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? noop : onPostpone,
+    onAllReady: onAllReady === undefined ? noop : onAllReady,
+    onShellReady: onShellReady === undefined ? noop : onShellReady,
+    onShellError: onShellError === undefined ? noop : onShellError,
+    onFatalError: onFatalError === undefined ? noop : onFatalError,
+    formState: null
+  };
+
+  if (typeof postponedState.replaySlots === 'number') {
+    const resumedId = postponedState.replaySlots; // We have a resume slot at the very root. This is effectively just a full rerender.
+
+    const rootSegment = createPendingSegment(request, 0, null, postponedState.rootFormatContext, // Root segments are never embedded in Text on either edge
+    false, false);
+    rootSegment.id = resumedId; // There is no parent so conceptually, we're unblocked to flush this segment.
+
+    rootSegment.parentFlushed = true;
+    const rootTask = createRenderTask(request, null, children, -1, null, rootSegment, abortSet, null, postponedState.rootFormatContext, emptyContextObject, rootContextSnapshot, emptyTreeContext);
+    pingedTasks.push(rootTask);
+    return request;
+  }
+
+  const replay = {
+    nodes: postponedState.replayNodes,
+    slots: postponedState.replaySlots,
+    pendingTasks: 0
+  };
+  const rootTask = createReplayTask(request, null, replay, children, -1, null, abortSet, null, postponedState.rootFormatContext, emptyContextObject, rootContextSnapshot, emptyTreeContext);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  return null;
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (request.pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createSuspenseBoundary(request, fallbackAbortableTasks) {
+  return {
+    status: PENDING,
+    rootSegmentID: -1,
+    parentFlushed: false,
+    pendingTasks: 0,
+    completedSegments: [],
+    byteSize: 0,
+    fallbackAbortableTasks,
+    errorDigest: null,
+    resources: createBoundaryResources(),
+    trackedContentKeyPath: null,
+    trackedFallbackNode: null
+  };
+}
+
+function createRenderTask(request, thenableState, node, childIndex, blockedBoundary, blockedSegment, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  const task = {
+    replay: null,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createReplayTask(request, thenableState, replay, node, childIndex, blockedBoundary, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  replay.pendingTasks++;
+  const task = {
+    replay,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment: null,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createPendingSegment(request, index, boundary, parentFormatContext, lastPushedText, textEmbedded) {
+  return {
+    status: PENDING,
+    id: -1,
+    // lazily assigned later
+    index,
+    parentFlushed: false,
+    chunks: [],
+    children: [],
+    parentFormatContext,
+    boundary,
+    lastPushedText,
+    textEmbedded
+  };
+} // DEV-only global reference to the currently executing task
+
+function popComponentStackInDEV(task) {
+} // stash the component stack of an unwinding error until it is processed
+
+function logPostpone(request, reason) {
+  // If this callback errors, we intentionally let that error bubble up to become a fatal error
+  // so that someone fixes the error reporting instead of hiding it.
+  request.onPostpone(reason);
+}
+
+function logRecoverableError(request, error) {
+  // If this callback errors, we intentionally let that error bubble up to become a fatal error
+  // so that someone fixes the error reporting instead of hiding it.
+  const errorDigest = request.onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest;
+}
+
+function fatalError(request, error) {
+  // This is called outside error handling code such as if the root errors outside
+  // a suspense boundary or if the root suspense boundary's fallback errors.
+  // It's also called if React itself or its host configs errors.
+  const onShellError = request.onShellError;
+  onShellError(error);
+  const onFatalError = request.onFatalError;
+  onFatalError(error);
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function renderSuspenseBoundary(request, someTask, keyPath, props) {
+  if (someTask.replay !== null) {
+    // If we're replaying through this pass, it means we're replaying through
+    // an already completed Suspense boundary. It's too late to do anything about it
+    // so we can just render through it.
+    const prevKeyPath = someTask.keyPath;
+    someTask.keyPath = keyPath;
+    const content = props.children;
+
+    try {
+      renderNode(request, someTask, content, -1);
+    } finally {
+      someTask.keyPath = prevKeyPath;
+    }
+
+    return;
+  } // $FlowFixMe: Refined.
+
+
+  const task = someTask;
+  const prevKeyPath = task.keyPath;
+  const parentBoundary = task.blockedBoundary;
+  const parentSegment = task.blockedSegment; // Each time we enter a suspense boundary, we split out into a new segment for
+  // the fallback so that we can later replace that segment with the content.
+  // This also lets us split out the main content even if it doesn't suspend,
+  // in case it ends up generating a large subtree of content.
+
+  const fallback = props.fallback;
+  const content = props.children;
+  const fallbackAbortSet = new Set();
+  const newBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+
+  if (request.trackedPostpones !== null) {
+    newBoundary.trackedContentKeyPath = keyPath;
+  }
+
+  const insertionIndex = parentSegment.chunks.length; // The children of the boundary segment is actually the fallback.
+
+  const boundarySegment = createPendingSegment(request, insertionIndex, newBoundary, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false);
+  parentSegment.children.push(boundarySegment); // The parentSegment has a child Segment at this index so we reset the lastPushedText marker on the parent
+
+  parentSegment.lastPushedText = false; // This segment is the actual child content. We can start rendering that immediately.
+
+  const contentRootSegment = createPendingSegment(request, 0, null, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false); // We mark the root segment as having its parent flushed. It's not really flushed but there is
+  // no parent segment so there's nothing to wait on.
+
+  contentRootSegment.parentFlushed = true; // Currently this is running synchronously. We could instead schedule this to pingedTasks.
+  // I suspect that there might be some efficiency benefits from not creating the suspended task
+  // and instead just using the stack if possible.
+  // TODO: Call this directly instead of messing with saving and restoring contexts.
+  // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and which segment
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = newBoundary;
+  task.blockedSegment = contentRootSegment;
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, newBoundary.resources);
+  }
+
+  task.keyPath = keyPath;
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+    pushSegmentFinale(contentRootSegment.chunks, request.renderState, contentRootSegment.lastPushedText, contentRootSegment.textEmbedded);
+    contentRootSegment.status = COMPLETED;
+    queueCompletedSegment(newBoundary, contentRootSegment);
+
+    if (newBoundary.pendingTasks === 0 && newBoundary.status === PENDING) {
+      newBoundary.status = COMPLETED; // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    contentRootSegment.status = ERRORED;
+    newBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+      const postponeInstance = error;
+      logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+      errorDigest = 'POSTPONE';
+    } else {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    newBoundary.errorDigest = errorDigest;
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.blockedSegment = parentSegment;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]];
+  const trackedPostpones = request.trackedPostpones;
+
+  if (trackedPostpones !== null) {
+    // We create a detached replay node to track any postpones inside the fallback.
+    const fallbackReplayNode = [fallbackKeyPath[1], fallbackKeyPath[2], [], null];
+    trackedPostpones.workingMap.set(fallbackKeyPath, fallbackReplayNode);
+
+    if (newBoundary.status === POSTPONED) {
+      // This must exist now.
+      const boundaryReplayNode = trackedPostpones.workingMap.get(keyPath);
+      boundaryReplayNode[4] = fallbackReplayNode;
+    } else {
+      // We might not inject it into the postponed tree, unless the content actually
+      // postpones too. We need to keep track of it until that happpens.
+      newBoundary.trackedFallbackNode = fallbackReplayNode;
+    }
+  } // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+
+  const suspendedFallbackTask = createRenderTask(request, null, fallback, -1, parentBoundary, boundarySegment, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function replaySuspenseBoundary(request, task, keyPath, props, id, childNodes, childSlots, fallbackNodes, fallbackSlots) {
+  const prevKeyPath = task.keyPath;
+  const previousReplaySet = task.replay;
+  const parentBoundary = task.blockedBoundary;
+  const content = props.children;
+  const fallback = props.fallback;
+  const fallbackAbortSet = new Set();
+  const resumedBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = id; // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and replay node
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = resumedBoundary;
+  task.replay = {
+    nodes: childNodes,
+    slots: childSlots,
+    pendingTasks: 1
+  };
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, resumedBoundary.resources);
+  }
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw Error(formatProdErrorMessage(488));
+    }
+
+    task.replay.pendingTasks--;
+
+    if (resumedBoundary.pendingTasks === 0 && resumedBoundary.status === PENDING) {
+      resumedBoundary.status = COMPLETED;
+      request.completedBoundaries.push(resumedBoundary); // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    resumedBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+      const postponeInstance = error;
+      logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+      errorDigest = 'POSTPONE';
+    } else {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    resumedBoundary.errorDigest = errorDigest;
+
+    task.replay.pendingTasks--; // The parent already flushed in the prerender so we need to schedule this to be emitted.
+
+    request.clientRenderedBoundaries.push(resumedBoundary); // We don't need to decrement any task numbers because we didn't spawn any new task.
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.replay = previousReplaySet;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]]; // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+  const fallbackReplay = {
+    nodes: fallbackNodes,
+    slots: fallbackSlots,
+    pendingTasks: 0
+  };
+  const suspendedFallbackTask = createReplayTask(request, null, fallbackReplay, fallback, -1, parentBoundary, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function renderHostElement(request, task, keyPath, type, props) {
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    const children = props.children; // TODO: Make this a Config for replaying.
+
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+  } else {
+    // Render
+    const children = pushStartInstance(segment.chunks, type, props, request.resumableState, request.renderState, task.formatContext, segment.lastPushedText);
+    segment.lastPushedText = false;
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+    pushEndInstance(segment.chunks, type, props, request.resumableState, prevContext);
+    segment.lastPushedText = false;
+  }
+}
+
+function shouldConstruct(Component) {
+  return Component.prototype && Component.prototype.isReactComponent;
+}
+
+function renderWithHooks(request, task, keyPath, prevThenableState, Component, props, secondArg) {
+  const componentIdentity = {};
+  prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState);
+  const result = Component(props, secondArg);
+  return finishHooks(Component, props, result, secondArg);
+}
+
+function finishClassComponent(request, task, keyPath, instance, Component, props) {
+  const nextChildren = instance.render();
+
+  {
+    const childContextTypes = Component.childContextTypes;
+
+    if (childContextTypes !== null && childContextTypes !== undefined) {
+      const previousContext = task.legacyContext;
+      const mergedContext = processChildContext(instance, Component, previousContext, childContextTypes);
+      task.legacyContext = mergedContext;
+      renderNodeDestructive(request, task, null, nextChildren, -1);
+      task.legacyContext = previousContext;
+      return;
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, nextChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderClassComponent(request, task, keyPath, Component, props) {
+  const maskedContext = getMaskedContext(Component, task.legacyContext) ;
+  const instance = constructClassInstance(Component, props, maskedContext);
+  mountClassInstance(instance, Component, props, maskedContext);
+  finishClassComponent(request, task, keyPath, instance, Component);
+}
+// components for some reason.
+
+function renderIndeterminateComponent(request, task, keyPath, prevThenableState, Component, props) {
+  let legacyContext;
+
+  {
+    legacyContext = getMaskedContext(Component, task.legacyContext);
+  }
+
+  const value = renderWithHooks(request, task, keyPath, prevThenableState, Component, props, legacyContext);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+
+  if ( // Run these checks in production only if the flag is off.
+  // Eventually we'll delete this branch altogether.
+  typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) {
+
+    mountClassInstance(value, Component, props, legacyContext);
+    finishClassComponent(request, task, keyPath, value, Component);
+  } else {
+
+    finishFunctionComponent(request, task, keyPath, value, hasId, formStateCount, formStateMatchingIndex);
+  }
+}
+
+function finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex) {
+  let didEmitFormStateMarkers = false;
+
+  if (formStateCount !== 0 && request.formState !== null) {
+    // For each useFormState hook, emit a marker that indicates whether we
+    // rendered using the form state passed at the root. We only emit these
+    // markers if form state is passed at the root.
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      didEmitFormStateMarkers = true;
+      const target = segment.chunks;
+
+      for (let i = 0; i < formStateCount; i++) {
+        if (i === formStateMatchingIndex) {
+          pushFormStateMarkerIsMatching(target);
+        } else {
+          pushFormStateMarkerIsNotMatching(target);
+        }
+      }
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+
+  if (hasId) {
+    // This component materialized an id. We treat this as its own level, with
+    // a single "child" slot.
+    const prevTreeContext = task.treeContext;
+    const totalChildren = 1;
+    const index = 0; // Modify the id context. Because we'll need to reset this if something
+    // suspends or errors, we'll use the non-destructive render path.
+
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, index);
+    renderNode(request, task, children, -1); // Like the other contexts, this does not need to be in a finally block
+    // because renderNode takes care of unwinding the stack.
+
+    task.treeContext = prevTreeContext;
+  } else if (didEmitFormStateMarkers) {
+    // If there were formState hooks, we must use the non-destructive path
+    // because this component is not a pure indirection; we emitted markers
+    // to the stream.
+    renderNode(request, task, children, -1);
+  } else {
+    // We're now successfully past this task, and we haven't modified the
+    // context stack. We don't have to pop back to the previous task every
+    // again, so we can use the destructive recursive form.
+    renderNodeDestructive(request, task, null, children, -1);
+  }
+
+  task.keyPath = prevKeyPath;
+}
+
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    // Resolve default props. Taken from ReactElement
+    const props = assign({}, baseProps);
+    const defaultProps = Component.defaultProps;
+
+    for (const propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+
+    return props;
+  }
+
+  return baseProps;
+}
+
+function renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref) {
+  const children = renderWithHooks(request, task, keyPath, prevThenableState, type.render, props, ref);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+  finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex);
+}
+
+function renderMemo(request, task, keyPath, prevThenableState, type, props, ref) {
+  const innerType = type.type;
+  const resolvedProps = resolveDefaultProps(innerType, props);
+  renderElement(request, task, keyPath, prevThenableState, innerType, resolvedProps, ref);
+}
+
+function renderContextConsumer(request, task, keyPath, context, props) {
+
+  const render = props.children;
+
+  const newValue = readContext$1(context);
+  const newChildren = render(newValue);
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, newChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderContextProvider(request, task, keyPath, type, props) {
+  const context = type._context;
+  const value = props.value;
+  const children = props.children;
+
+  const prevKeyPath = task.keyPath;
+  task.context = pushProvider(context, value);
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, children, -1);
+  task.context = popProvider();
+  task.keyPath = prevKeyPath;
+}
+
+function renderLazyComponent(request, task, keyPath, prevThenableState, lazyComponent, props, ref) {
+  const payload = lazyComponent._payload;
+  const init = lazyComponent._init;
+  const Component = init(payload);
+  const resolvedProps = resolveDefaultProps(Component, props);
+  renderElement(request, task, keyPath, prevThenableState, Component, resolvedProps, ref);
+}
+
+function renderOffscreen(request, task, keyPath, props) {
+  const mode = props.mode;
+
+  if (mode === 'hidden') ; else {
+    // A visible Offscreen boundary is treated exactly like a fragment: a
+    // pure indirection.
+    const prevKeyPath = task.keyPath;
+    task.keyPath = keyPath;
+    renderNodeDestructive(request, task, null, props.children, -1);
+    task.keyPath = prevKeyPath;
+  }
+}
+
+function renderElement(request, task, keyPath, prevThenableState, type, props, ref) {
+  if (typeof type === 'function') {
+    if (shouldConstruct(type)) {
+      renderClassComponent(request, task, keyPath, type, props);
+      return;
+    } else {
+      renderIndeterminateComponent(request, task, keyPath, prevThenableState, type, props);
+      return;
+    }
+  }
+
+  if (typeof type === 'string') {
+    renderHostElement(request, task, keyPath, type, props);
+    return;
+  }
+
+  switch (type) {
+    // LegacyHidden acts the same as a fragment. This only works because we
+    // currently assume that every instance of LegacyHidden is accompanied by a
+    // host component wrapper. In the hidden mode, the host component is given a
+    // `hidden` attribute, which ensures that the initial HTML is not visible.
+    // To support the use of LegacyHidden as a true fragment, without an extra
+    // DOM node, we would have to hide the initial HTML in some other way.
+    // TODO: Delete in LegacyHidden. It's an unstable API only used in the
+    // www build. As a migration step, we could add a special prop to Offscreen
+    // that simulates the old behavior (no hiding, no change to effects).
+    case REACT_LEGACY_HIDDEN_TYPE:
+    case REACT_DEBUG_TRACING_MODE_TYPE:
+    case REACT_STRICT_MODE_TYPE:
+    case REACT_PROFILER_TYPE:
+    case REACT_FRAGMENT_TYPE:
+      {
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_OFFSCREEN_TYPE:
+      {
+        renderOffscreen(request, task, keyPath, props);
+        return;
+      }
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      {
+
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_SCOPE_TYPE:
+      {
+
+        throw Error(formatProdErrorMessage(343));
+      }
+
+    case REACT_SUSPENSE_TYPE:
+      {
+        {
+          renderSuspenseBoundary(request, task, keyPath, props);
+        }
+
+        return;
+      }
+  }
+
+  if (typeof type === 'object' && type !== null) {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        {
+          renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          renderMemo(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_PROVIDER_TYPE:
+        {
+          renderContextProvider(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_CONTEXT_TYPE:
+        {
+          renderContextConsumer(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_LAZY_TYPE:
+        {
+          renderLazyComponent(request, task, keyPath, prevThenableState, type, props);
+          return;
+        }
+    }
+  }
+
+  let info = '';
+
+  throw Error(formatProdErrorMessage(130, type == null ? type : typeof type, info));
+}
+
+function resumeNode(request, task, segmentId, node, childIndex) {
+  const prevReplay = task.replay;
+  const blockedBoundary = task.blockedBoundary;
+  const resumedSegment = createPendingSegment(request, 0, null, task.formatContext, false, false);
+  resumedSegment.id = segmentId;
+  resumedSegment.parentFlushed = true;
+
+  try {
+    // Convert the current ReplayTask to a RenderTask.
+    const renderTask = task;
+    renderTask.replay = null;
+    renderTask.blockedSegment = resumedSegment;
+    renderNode(request, task, node, childIndex);
+    resumedSegment.status = COMPLETED;
+
+    if (blockedBoundary === null) {
+      request.completedRootSegment = resumedSegment;
+    } else {
+      queueCompletedSegment(blockedBoundary, resumedSegment);
+
+      if (blockedBoundary.parentFlushed) {
+        request.partialBoundaries.push(blockedBoundary);
+      }
+    }
+  } finally {
+    // Restore to a ReplayTask.
+    task.replay = prevReplay;
+    task.blockedSegment = null;
+  }
+}
+
+function replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, replay) {
+  // We're replaying. Find the path to follow.
+  const replayNodes = replay.nodes;
+
+  for (let i = 0; i < replayNodes.length; i++) {
+    // Flow doesn't support refinement on tuples so we do it manually here.
+    const node = replayNodes[i];
+
+    if (keyOrIndex !== node[1]) {
+      continue;
+    }
+
+    if (node.length === 4) {
+      // Matched a replayable path.
+      // Let's double check that the component name matches as a precaution.
+      if (name !== null && name !== node[0]) {
+        throw Error(formatProdErrorMessage(490, node[0], name));
+      }
+
+      const childNodes = node[2];
+      const childSlots = node[3];
+      const currentNode = task.node;
+      task.replay = {
+        nodes: childNodes,
+        slots: childSlots,
+        pendingTasks: 1
+      };
+
+      try {
+        renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+
+        if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0 // TODO check remaining slots
+        ) {
+            throw Error(formatProdErrorMessage(488));
+          }
+
+        task.replay.pendingTasks--;
+      } catch (x) {
+        if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+          // Suspend
+          if (task.node === currentNode) {
+            // This same element suspended so we need to pop the replay we just added.
+            task.replay = replay;
+          }
+
+          throw x;
+        }
+
+        task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+        // during a replay. That's because this component didn't actually error
+        // in the original prerender. What's unable to complete is the child
+        // replay nodes which might be Suspense boundaries which are able to
+        // absorb the error and we can still continue with siblings.
+
+        erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+      }
+
+      task.replay = replay;
+    } else {
+      // Let's double check that the component type matches.
+      if (type !== REACT_SUSPENSE_TYPE) {
+        const expectedType = 'Suspense';
+        throw Error(formatProdErrorMessage(490, expectedType, getComponentNameFromType(type) || 'Unknown'));
+      } // Matched a replayable path.
+
+
+      replaySuspenseBoundary(request, task, keyPath, props, node[5], node[2], node[3], node[4] === null ? [] : node[4][2], node[4] === null ? null : node[4][3]);
+    } // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+
+    replayNodes.splice(i, 1);
+    return;
+  } // We didn't find any matching nodes. We assume that this element was already
+  // rendered in the prelude and skip it.
+
+} // $FlowFixMe[missing-local-annot]
+
+function renderNodeDestructive(request, task, // The thenable state reused from the previous attempt, if any. This is almost
+// always null, except when called by retryTask.
+prevThenableState, node, childIndex) {
+  {
+    return renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex);
+  }
+} // This function by it self renders a node and consumes the task by mutating it
+// to update the current execution state.
+
+
+function renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex) {
+  if (task.replay !== null && typeof task.replay.slots === 'number') {
+    // TODO: Figure out a cheaper place than this hot path to do this check.
+    const resumeSegmentID = task.replay.slots;
+    resumeNode(request, task, resumeSegmentID, node, childIndex);
+    return;
+  } // Stash the node we're working on. We'll pick up from this task in case
+  // something suspends.
+
+
+  task.node = node;
+  task.childIndex = childIndex; // Handle object types
+
+  if (typeof node === 'object' && node !== null) {
+    switch (node.$$typeof) {
+      case REACT_ELEMENT_TYPE:
+        {
+          const element = node;
+          const type = element.type;
+          const key = element.key;
+          const props = element.props;
+          const ref = element.ref;
+          const name = getComponentNameFromType(type);
+          const keyOrIndex = key == null ? childIndex === -1 ? 0 : childIndex : key;
+          const keyPath = [task.keyPath, name, keyOrIndex];
+
+          if (task.replay !== null) {
+            replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, task.replay); // No matches found for this node. We assume it's already emitted in the
+            // prelude and skip it during the replay.
+          } else {
+            // We're doing a plain render.
+            renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+          }
+
+          return;
+        }
+
+      case REACT_PORTAL_TYPE:
+        throw Error(formatProdErrorMessage(257));
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyNode = node;
+          const payload = lazyNode._payload;
+          const init = lazyNode._init;
+          let resolvedNode;
+
+          {
+            resolvedNode = init(payload);
+          }
+
+          renderNodeDestructive(request, task, null, resolvedNode, childIndex);
+          return;
+        }
+    }
+
+    if (isArray(node)) {
+      renderChildrenArray(request, task, node, childIndex);
+      return;
+    }
+
+    const iteratorFn = getIteratorFn(node);
+
+    if (iteratorFn) {
+
+      const iterator = iteratorFn.call(node);
+
+      if (iterator) {
+        // We need to know how many total children are in this set, so that we
+        // can allocate enough id slots to acommodate them. So we must exhaust
+        // the iterator before we start recursively rendering the children.
+        // TODO: This is not great but I think it's inherent to the id
+        // generation algorithm.
+        let step = iterator.next(); // If there are not entries, we need to push an empty so we start by checking that.
+
+        if (!step.done) {
+          const children = [];
+
+          do {
+            children.push(step.value);
+            step = iterator.next();
+          } while (!step.done);
+
+          renderChildrenArray(request, task, children, childIndex);
+          return;
+        }
+
+        return;
+      }
+    } // Usables are a valid React node type. When React encounters a Usable in
+    // a child position, it unwraps it using the same algorithm as `use`. For
+    // example, for promises, React will throw an exception to unwind the
+    // stack, then replay the component once the promise resolves.
+    //
+    // A difference from `use` is that React will keep unwrapping the value
+    // until it reaches a non-Usable type.
+    //
+    // e.g. Usable<Usable<Usable<T>>> should resolve to T
+
+
+    const maybeUsable = node;
+
+    if (typeof maybeUsable.then === 'function') {
+      const thenable = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, unwrapThenable(thenable), childIndex);
+    }
+
+    if (maybeUsable.$$typeof === REACT_CONTEXT_TYPE || maybeUsable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, readContext$1(context), childIndex);
+    } // $FlowFixMe[method-unbinding]
+
+
+    const childString = Object.prototype.toString.call(node);
+    throw Error(formatProdErrorMessage(31, childString === '[object Object]' ? 'object with keys {' + Object.keys(node).join(', ') + '}' : childString));
+  }
+
+  if (typeof node === 'string') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+
+  if (typeof node === 'number') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, '' + node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+}
+
+function replayFragment(request, task, children, childIndex) {
+  // If we're supposed follow this array, we'd expect to see a ReplayNode matching
+  // this fragment.
+  const replay = task.replay;
+  const replayNodes = replay.nodes;
+
+  for (let j = 0; j < replayNodes.length; j++) {
+    const node = replayNodes[j];
+
+    if (node[1] !== childIndex) {
+      continue;
+    } // Matched a replayable path.
+
+
+    const childNodes = node[2];
+    const childSlots = node[3];
+    task.replay = {
+      nodes: childNodes,
+      slots: childSlots,
+      pendingTasks: 1
+    };
+
+    try {
+      renderChildrenArray(request, task, children, -1);
+
+      if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+        throw Error(formatProdErrorMessage(488));
+      }
+
+      task.replay.pendingTasks--;
+    } catch (x) {
+      if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+        // Suspend
+        throw x;
+      }
+
+      task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+      // during a replay. That's because this component didn't actually error
+      // in the original prerender. What's unable to complete is the child
+      // replay nodes which might be Suspense boundaries which are able to
+      // absorb the error and we can still continue with siblings.
+      // This is an error, stash the component stack if it is null.
+
+      erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+    }
+
+    task.replay = replay; // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+    replayNodes.splice(j, 1);
+    break;
+  }
+}
+
+function renderChildrenArray(request, task, children, childIndex) {
+  const prevKeyPath = task.keyPath;
+
+  if (childIndex !== -1) {
+    task.keyPath = [task.keyPath, 'Fragment', childIndex];
+
+    if (task.replay !== null) {
+      replayFragment(request, // $FlowFixMe: Refined.
+      task, children, childIndex);
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  const prevTreeContext = task.treeContext;
+  const totalChildren = children.length;
+
+  if (task.replay !== null) {
+    // Replay
+    // First we need to check if we have any resume slots at this level.
+    const resumeSlots = task.replay.slots;
+
+    if (resumeSlots !== null && typeof resumeSlots === 'object') {
+      for (let i = 0; i < totalChildren; i++) {
+        const node = children[i];
+        task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+        // up and render the sibling if something suspends.
+
+        const resumeSegmentID = resumeSlots[i]; // TODO: If this errors we should still continue with the next sibling.
+
+        if (typeof resumeSegmentID === 'number') {
+          resumeNode(request, task, resumeSegmentID, node, i); // We finished rendering this node, so now we can consume this
+          // slot. This must happen after in case we rerender this task.
+
+          delete resumeSlots[i];
+        } else {
+          renderNode(request, task, node, i);
+        }
+      }
+
+      task.treeContext = prevTreeContext;
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  for (let i = 0; i < totalChildren; i++) {
+    const node = children[i];
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+    // up and render the sibling if something suspends.
+
+    renderNode(request, task, node, i);
+  } // Because this context is always set right before rendering every child, we
+  // only need to reset it to the previous value at the very end.
+
+
+  task.treeContext = prevTreeContext;
+  task.keyPath = prevKeyPath;
+}
+
+function trackPostpone(request, trackedPostpones, task, segment) {
+  segment.status = POSTPONED;
+  const keyPath = task.keyPath;
+  const boundary = task.blockedBoundary;
+
+  if (boundary === null) {
+    segment.id = request.nextSegmentId++;
+    trackedPostpones.rootSlots = segment.id;
+
+    if (request.completedRootSegment !== null) {
+      // Postpone the root if this was a deeper segment.
+      request.completedRootSegment.status = POSTPONED;
+    }
+
+    return;
+  }
+
+  if (boundary !== null && boundary.status === PENDING) {
+    boundary.status = POSTPONED; // We need to eagerly assign it an ID because we'll need to refer to
+    // it before flushing and we know that we can't inline it.
+
+    boundary.rootSegmentID = request.nextSegmentId++;
+    const boundaryKeyPath = boundary.trackedContentKeyPath;
+
+    if (boundaryKeyPath === null) {
+      throw Error(formatProdErrorMessage(486));
+    }
+
+    const fallbackReplayNode = boundary.trackedFallbackNode;
+    const children = [];
+
+    if (boundaryKeyPath === keyPath && task.childIndex === -1) {
+      // Since we postponed directly in the Suspense boundary we can't have written anything
+      // to its segment. Therefore this will end up becoming the root segment.
+      segment.id = boundary.rootSegmentID; // We postponed directly inside the Suspense boundary so we mark this for resuming.
+
+      const boundaryNode = [boundaryKeyPath[1], boundaryKeyPath[2], children, boundary.rootSegmentID, fallbackReplayNode, boundary.rootSegmentID];
+      trackedPostpones.workingMap.set(boundaryKeyPath, boundaryNode);
+      addToReplayParent(boundaryNode, boundaryKeyPath[0], trackedPostpones);
+      return;
+    } else {
+      let boundaryNode = trackedPostpones.workingMap.get(boundaryKeyPath);
+
+      if (boundaryNode === undefined) {
+        boundaryNode = [boundaryKeyPath[1], boundaryKeyPath[2], children, null, fallbackReplayNode, boundary.rootSegmentID];
+        trackedPostpones.workingMap.set(boundaryKeyPath, boundaryNode);
+        addToReplayParent(boundaryNode, boundaryKeyPath[0], trackedPostpones);
+      } else {
+        // Upgrade to ReplaySuspenseBoundary.
+        const suspenseBoundary = boundaryNode;
+        suspenseBoundary[4] = fallbackReplayNode;
+        suspenseBoundary[5] = boundary.rootSegmentID;
+      } // Fall through to add the child node.
+
+    }
+  } // We know that this will leave a hole so we might as well assign an ID now.
+  // We might have one already if we had a parent that gave us its ID.
+
+
+  if (segment.id === -1) {
+    if (segment.parentFlushed && boundary !== null) {
+      // If this segment's parent was already flushed, it means we really just
+      // skipped the parent and this segment is now the root.
+      segment.id = boundary.rootSegmentID;
+    } else {
+      segment.id = request.nextSegmentId++;
+    }
+  }
+
+  if (task.childIndex === -1) {
+    // Resume starting from directly inside the previous parent element.
+    if (keyPath === null) {
+      trackedPostpones.rootSlots = segment.id;
+    } else {
+      const workingMap = trackedPostpones.workingMap;
+      let resumableNode = workingMap.get(keyPath);
+
+      if (resumableNode === undefined) {
+        resumableNode = [keyPath[1], keyPath[2], [], segment.id];
+        addToReplayParent(resumableNode, keyPath[0], trackedPostpones);
+      } else {
+        resumableNode[3] = segment.id;
+      }
+    }
+  } else {
+    let slots;
+
+    if (keyPath === null) {
+      slots = trackedPostpones.rootSlots;
+
+      if (slots === null) {
+        slots = trackedPostpones.rootSlots = {};
+      } else if (typeof slots === 'number') {
+        throw Error(formatProdErrorMessage(491));
+      }
+    } else {
+      const workingMap = trackedPostpones.workingMap;
+      let resumableNode = workingMap.get(keyPath);
+
+      if (resumableNode === undefined) {
+        slots = {};
+        resumableNode = [keyPath[1], keyPath[2], [], slots];
+        workingMap.set(keyPath, resumableNode);
+        addToReplayParent(resumableNode, keyPath[0], trackedPostpones);
+      } else {
+        slots = resumableNode[3];
+
+        if (slots === null) {
+          slots = resumableNode[3] = {};
+        } else if (typeof slots === 'number') {
+          throw Error(formatProdErrorMessage(491));
+        }
+      }
+    }
+
+    slots[task.childIndex] = segment.id;
+  }
+}
+
+function injectPostponedHole(request, task, reason) {
+  logPostpone(request, reason); // Something suspended, we'll need to create a new segment and resolve it later.
+
+  const segment = task.blockedSegment;
+  const insertionIndex = segment.chunks.length;
+  const newSegment = createPendingSegment(request, insertionIndex, null, task.formatContext, // Adopt the parent segment's leading text embed
+  segment.lastPushedText, // Assume we are text embedded at the trailing edge
+  true);
+  segment.children.push(newSegment); // Reset lastPushedText for current Segment since the new Segment "consumed" it
+
+  segment.lastPushedText = false;
+  return newSegment;
+}
+
+function spawnNewSuspendedReplayTask(request, task, thenableState, x) {
+  const newTask = createReplayTask(request, thenableState, task.replay, task.node, task.childIndex, task.blockedBoundary, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+}
+
+function spawnNewSuspendedRenderTask(request, task, thenableState, x) {
+  // Something suspended, we'll need to create a new segment and resolve it later.
+  const segment = task.blockedSegment;
+  const insertionIndex = segment.chunks.length;
+  const newSegment = createPendingSegment(request, insertionIndex, null, task.formatContext, // Adopt the parent segment's leading text embed
+  segment.lastPushedText, // Assume we are text embedded at the trailing edge
+  true);
+  segment.children.push(newSegment); // Reset lastPushedText for current Segment since the new Segment "consumed" it
+
+  segment.lastPushedText = false;
+  const newTask = createRenderTask(request, thenableState, task.node, task.childIndex, task.blockedBoundary, newSegment, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+} // This is a non-destructive form of rendering a node. If it suspends it spawns
+// a new task and restores the context of this task to what it was before.
+
+
+function renderNode(request, task, node, childIndex) {
+  // Snapshot the current context in case something throws to interrupt the
+  // process.
+  const previousFormatContext = task.formatContext;
+  const previousLegacyContext = task.legacyContext;
+  const previousContext = task.context;
+  const previousKeyPath = task.keyPath;
+  const previousTreeContext = task.treeContext;
+
+  let x; // Store how much we've pushed at this point so we can reset it in case something
+  // suspended partially through writing something.
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState();
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedReplayTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+      } // TODO: Abort any undiscovered Suspense boundaries in the ReplayNode.
+
+    }
+  } else {
+    // Render
+    const childrenLength = segment.children.length;
+    const chunkLength = segment.chunks.length;
+
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState(); // Reset the write pointers to where we started.
+
+      segment.children.length = childrenLength;
+      segment.chunks.length = chunkLength;
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedRenderTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+
+        if (request.trackedPostpones !== null && x.$$typeof === REACT_POSTPONE_TYPE && task.blockedBoundary !== null // bubble if we're postponing in the shell
+        ) {
+            // If we're tracking postpones, we inject a hole here and continue rendering
+            // sibling. Similar to suspending. If we're not tracking, we treat it more like
+            // an error. Notably this doesn't spawn a new task since nothing will fill it
+            // in during this prerender.
+            const postponeInstance = x;
+            const trackedPostpones = request.trackedPostpones;
+            const postponedSegment = injectPostponedHole(request, task, // We don't use ReplayTasks in prerenders.
+            postponeInstance.message);
+            trackPostpone(request, trackedPostpones, task, postponedSegment); // Restore the context. We assume that this will be restored by the inner
+            // functions in case nothing throws so we don't use "finally" here.
+
+            task.formatContext = previousFormatContext;
+            task.legacyContext = previousLegacyContext;
+            task.context = previousContext;
+            task.keyPath = previousKeyPath;
+            task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+            switchContext(previousContext);
+            return;
+          }
+      }
+    }
+  } // Restore the context. We assume that this will be restored by the inner
+  // functions in case nothing throws so we don't use "finally" here.
+
+
+  task.formatContext = previousFormatContext;
+  task.legacyContext = previousLegacyContext;
+  task.context = previousContext;
+  task.keyPath = previousKeyPath;
+  task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+  switchContext(previousContext);
+  // Let's terminate the rest of the tree and don't render any siblings.
+
+
+  throw x;
+}
+
+function erroredReplay(request, boundary, error, replayNodes, resumeSlots) {
+  // Erroring during a replay doesn't actually cause an error by itself because
+  // that component has already rendered. What causes the error is the resumable
+  // points that we did not yet finish which will be below the point of the reset.
+  // For example, if we're replaying a path to a Suspense boundary that is not done
+  // that doesn't error the parent Suspense boundary.
+  // This might be a bit strange that the error in a parent gets thrown at a child.
+  // We log it only once and reuse the digest.
+  let errorDigest;
+
+  if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+    const postponeInstance = error;
+    logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+    errorDigest = 'POSTPONE';
+  } else {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  abortRemainingReplayNodes(request, boundary, replayNodes, resumeSlots, error, errorDigest);
+}
+
+function erroredTask(request, boundary, error) {
+  // Report the error to a global handler.
+  let errorDigest;
+
+  if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+    const postponeInstance = error;
+    logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+    errorDigest = 'POSTPONE';
+  } else {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  if (boundary === null) {
+    fatalError(request, error);
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+      // so we can flush it, if the parent already flushed.
+
+
+      if (boundary.parentFlushed) {
+        // We don't have a preference where in the queue this goes since it's likely
+        // to error on the client anyway. However, intentionally client-rendered
+        // boundaries should be flushed earlier so that they can start on the client.
+        // We reuse the same queue for errors.
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function abortTaskSoft(task) {
+  // This aborts task without aborting the parent boundary that it blocks.
+  // It's used for when we didn't need this task to complete the tree.
+  // If task was needed, then it should use abortTask instead.
+  const request = this;
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+    finishedTask(request, boundary, segment);
+  }
+}
+
+function abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest) {
+  const resumedBoundary = createSuspenseBoundary(request, new Set());
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = rootSegmentID;
+  resumedBoundary.status = CLIENT_RENDERED;
+  resumedBoundary.errorDigest = errorDigest;
+
+  if (resumedBoundary.parentFlushed) {
+    request.clientRenderedBoundaries.push(resumedBoundary);
+  }
+}
+
+function abortRemainingReplayNodes(request, boundary, nodes, slots, error, errorDigest) {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+
+    if (node.length === 4) {
+      abortRemainingReplayNodes(request, boundary, node[2], node[3], error, errorDigest);
+    } else {
+      const boundaryNode = node;
+      const rootSegmentID = boundaryNode[5];
+      abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest);
+    }
+  } // Empty the set, since we've cleared it now.
+
+
+  nodes.length = 0;
+
+  if (slots !== null) {
+    // We had something still to resume in the parent boundary. We must trigger
+    // the error on the parent boundary since it's not able to complete.
+    if (boundary === null) {
+      throw Error(formatProdErrorMessage(487));
+    } else if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // Empty the set
+
+
+    if (typeof slots === 'object') {
+      for (const index in slots) {
+        delete slots[index];
+      }
+    }
+  }
+}
+
+function abortTask(task, request, error) {
+  // This aborts the task and aborts the parent that it blocks, putting it into
+  // client rendered mode.
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+  }
+
+  if (boundary === null) {
+    if (request.status !== CLOSING && request.status !== CLOSED) {
+      const replay = task.replay;
+
+      if (replay === null) {
+        // We didn't complete the root so we have nothing to show. We can close
+        // the request;
+        logRecoverableError(request, error);
+        fatalError(request, error);
+        return;
+      } else {
+        // If the shell aborts during a replay, that's not a fatal error. Instead
+        // we should be able to recover by client rendering all the root boundaries in
+        // the ReplaySet.
+        replay.pendingTasks--;
+
+        if (replay.pendingTasks === 0 && replay.nodes.length > 0) {
+          const errorDigest = logRecoverableError(request, error);
+          abortRemainingReplayNodes(request, null, replay.nodes, replay.slots, error, errorDigest);
+        }
+
+        request.pendingRootTasks--;
+
+        if (request.pendingRootTasks === 0) {
+          completeShell(request);
+        }
+      }
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = logRecoverableError(request, error);
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // If this boundary was still pending then we haven't already cancelled its fallbacks.
+    // We'll need to abort the fallbacks, which will also error that parent boundary.
+
+
+    boundary.fallbackAbortableTasks.forEach(fallbackTask => abortTask(fallbackTask, request, error));
+    boundary.fallbackAbortableTasks.clear();
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeShell(request) {
+  if (request.trackedPostpones === null) {
+    // We only emit early preloads on shell completion for renders. For prerenders
+    // we wait for the entire Request to finish because we are not responding to a
+    // live request and can wait for as much data as possible.
+    // we should only be calling completeShell when the shell is complete so we
+    // just use a literal here
+    const shellComplete = true;
+    emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  } // We have completed the shell so the shell can't error anymore.
+
+
+  request.onShellError = noop;
+  const onShellReady = request.onShellReady;
+  onShellReady();
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeAll(request) {
+  // During a render the shell must be complete if the entire request is finished
+  // however during a Prerender it is possible that the shell is incomplete because
+  // it postponed. We cannot use rootPendingTasks in the prerender case because
+  // those hit zero even when the shell postpones. Instead we look at the completedRootSegment
+  const shellComplete = request.trackedPostpones === null ? // Render, we assume it is completed
+  true : // Prerender Request, we use the state of the root segment
+  request.completedRootSegment === null || request.completedRootSegment.status !== POSTPONED;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  const onAllReady = request.onAllReady;
+  onAllReady();
+}
+
+function queueCompletedSegment(boundary, segment) {
+  if (segment.chunks.length === 0 && segment.children.length === 1 && segment.children[0].boundary === null) {
+    // This is an empty segment. There's nothing to write, so we can instead transfer the ID
+    // to the child. That way any existing references point to the child.
+    const childSegment = segment.children[0];
+    childSegment.id = segment.id;
+    childSegment.parentFlushed = true;
+
+    if (childSegment.status === COMPLETED) {
+      queueCompletedSegment(boundary, childSegment);
+    }
+  } else {
+    const completedSegments = boundary.completedSegments;
+    completedSegments.push(segment);
+  }
+}
+
+function finishedTask(request, boundary, segment) {
+  if (boundary === null) {
+    if (segment !== null && segment.parentFlushed) {
+      if (request.completedRootSegment !== null) {
+        throw Error(formatProdErrorMessage(389));
+      }
+
+      request.completedRootSegment = segment;
+    }
+
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status === CLIENT_RENDERED) ; else if (boundary.pendingTasks === 0) {
+      if (boundary.status === PENDING) {
+        boundary.status = COMPLETED;
+      } // This must have been the last segment we were waiting on. This boundary is now complete.
+
+
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent segment already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+        }
+      }
+
+      if (boundary.parentFlushed) {
+        // The segment might be part of a segment that didn't flush yet, but if the boundary's
+        // parent flushed, we need to schedule the boundary to be emitted.
+        request.completedBoundaries.push(boundary);
+      } // We can now cancel any pending task on the fallback since we won't need to show it anymore.
+      // This needs to happen after we read the parentFlushed flags because aborting can finish
+      // work which can trigger user code, which can start flushing, which can change those flags.
+      // If the boundary was POSTPONED, we still need to finish the fallback first.
+
+
+      if (boundary.status === COMPLETED) {
+        boundary.fallbackAbortableTasks.forEach(abortTaskSoft, request);
+        boundary.fallbackAbortableTasks.clear();
+      }
+    } else {
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+          const completedSegments = boundary.completedSegments;
+
+          if (completedSegments.length === 1) {
+            // This is the first time since we last flushed that we completed anything.
+            // We can schedule this boundary to emit its partially completed segments early
+            // in case the parent has already been flushed.
+            if (boundary.parentFlushed) {
+              request.partialBoundaries.push(boundary);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function retryTask(request, task) {
+  {
+    const blockedBoundary = task.blockedBoundary;
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, blockedBoundary ? blockedBoundary.resources : null);
+  }
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    retryReplayTask(request, // $FlowFixMe: Refined.
+    task);
+  } else {
+    retryRenderTask(request, // $FlowFixMe: Refined.
+    task, segment);
+  }
+}
+
+function retryRenderTask(request, task, segment) {
+  if (segment.status !== PENDING) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  const childrenLength = segment.children.length;
+  const chunkLength = segment.chunks.length;
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+    pushSegmentFinale(segment.chunks, request.renderState, segment.lastPushedText, segment.textEmbedded);
+    task.abortSet.delete(task);
+    segment.status = COMPLETED;
+    finishedTask(request, task.blockedBoundary, segment);
+  } catch (thrownValue) {
+    resetHooksState(); // Reset the write pointers to where we started.
+
+    segment.children.length = childrenLength;
+    segment.chunks.length = chunkLength;
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      } else if (request.trackedPostpones !== null && x.$$typeof === REACT_POSTPONE_TYPE) {
+        // If we're tracking postpones, we mark this segment as postponed and finish
+        // the task without filling it in. If we're not tracking, we treat it more like
+        // an error.
+        const trackedPostpones = request.trackedPostpones;
+        task.abortSet.delete(task);
+        const postponeInstance = x;
+        logPostpone(request, postponeInstance.message);
+        trackPostpone(request, trackedPostpones, task, segment);
+        finishedTask(request, task.blockedBoundary, segment);
+        return;
+      }
+    }
+
+    task.abortSet.delete(task);
+    segment.status = ERRORED;
+    erroredTask(request, task.blockedBoundary, x);
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function retryReplayTask(request, task) {
+  if (task.replay.pendingTasks === 0) {
+    // There are no pending tasks working on this set, so we must have aborted.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw Error(formatProdErrorMessage(488));
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    finishedTask(request, task.blockedBoundary, null);
+  } catch (thrownValue) {
+    resetHooksState();
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    erroredReplay(request, task.blockedBoundary, x, task.replay.nodes, task.replay.slots);
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+
+    request.allPendingTasks--;
+
+    if (request.allPendingTasks === 0) {
+      completeAll(request);
+    }
+
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function performWork(request) {
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  const prevContext = getActiveContext();
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  let prevCacheDispatcher;
+
+  {
+    prevCacheDispatcher = ReactCurrentCache.current;
+    ReactCurrentCache.current = DefaultCacheDispatcher;
+  }
+
+  const prevRequest = currentRequest;
+  currentRequest = request;
+
+  const prevResumableState = currentResumableState;
+  setCurrentResumableState(request.resumableState);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    let i;
+
+    for (i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    pingedTasks.splice(0, i);
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    setCurrentResumableState(prevResumableState);
+    ReactCurrentDispatcher.current = prevDispatcher;
+
+    {
+      ReactCurrentCache.current = prevCacheDispatcher;
+    }
+
+    if (prevDispatcher === HooksDispatcher) {
+      // This means that we were in a reentrant work loop. This could happen
+      // in a renderer that supports synchronous work like renderToString,
+      // when it's called from within another renderer.
+      // Normally we don't bother switching the contexts to their root/default
+      // values when leaving because we'll likely need the same or similar
+      // context again. However, when we're inside a synchronous loop like this
+      // we'll to restore the context to what it was before returning.
+      switchContext(prevContext);
+    }
+
+    currentRequest = prevRequest;
+  }
+}
+
+function flushSubtree(request, destination, segment) {
+  segment.parentFlushed = true;
+
+  switch (segment.status) {
+    case PENDING:
+      {
+        // We're emitting a placeholder for this segment to be filled in later.
+        // Therefore we'll need to assign it an ID - to refer to it by.
+        segment.id = request.nextSegmentId++; // Fallthrough
+      }
+
+    case POSTPONED:
+      {
+        const segmentID = segment.id; // When this segment finally completes it won't be embedded in text since it will flush separately
+
+        segment.lastPushedText = false;
+        segment.textEmbedded = false;
+        return writePlaceholder(destination, request.renderState, segmentID);
+      }
+
+    case COMPLETED:
+      {
+        segment.status = FLUSHED;
+        let r = true;
+        const chunks = segment.chunks;
+        let chunkIdx = 0;
+        const children = segment.children;
+
+        for (let childIdx = 0; childIdx < children.length; childIdx++) {
+          const nextChild = children[childIdx]; // Write all the chunks up until the next child.
+
+          for (; chunkIdx < nextChild.index; chunkIdx++) {
+            writeChunk(destination, chunks[chunkIdx]);
+          }
+
+          r = flushSegment(request, destination, nextChild);
+        } // Finally just write all the remaining chunks
+
+
+        for (; chunkIdx < chunks.length - 1; chunkIdx++) {
+          writeChunk(destination, chunks[chunkIdx]);
+        }
+
+        if (chunkIdx < chunks.length) {
+          r = writeChunkAndReturn(destination, chunks[chunkIdx]);
+        }
+
+        return r;
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(390));
+      }
+  }
+}
+
+function flushSegment(request, destination, segment) {
+  const boundary = segment.boundary;
+
+  if (boundary === null) {
+    // Not a suspense boundary.
+    return flushSubtree(request, destination, segment);
+  }
+
+  boundary.parentFlushed = true; // This segment is a Suspense boundary. We need to decide whether to
+  // emit the content or the fallback now.
+
+  if (boundary.status === CLIENT_RENDERED) {
+    // Emit a client rendered suspense boundary wrapper.
+    // We never queue the inner boundary so we'll never emit its content or partial segments.
+    writeStartClientRenderedSuspenseBoundary(destination, request.renderState, boundary.errorDigest); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndClientRenderedSuspenseBoundary(destination);
+  } else if (boundary.status !== COMPLETED) {
+    if (boundary.status === PENDING) {
+      // For pending boundaries we lazily assign an ID to the boundary
+      // and root segment.
+      boundary.rootSegmentID = request.nextSegmentId++;
+    }
+
+    if (boundary.completedSegments.length > 0) {
+      // If this is at least partially complete, we can queue it to be partially emitted early.
+      request.partialBoundaries.push(boundary);
+    } // This boundary is still loading. Emit a pending suspense boundary wrapper.
+
+
+    const id = boundary.rootSegmentID;
+    writeStartPendingSuspenseBoundary(destination, request.renderState, id); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else if (boundary.byteSize > request.progressiveChunkSize) {
+    // This boundary is large and will be emitted separately so that we can progressively show
+    // other content. We add it to the queue during the flush because we have to ensure that
+    // the parent flushes first so that there's something to inject it into.
+    // We also have to make sure that it's emitted into the queue in a deterministic slot.
+    // I.e. we can't insert it here when it completes.
+    // Assign an ID to refer to the future content by.
+    boundary.rootSegmentID = request.nextSegmentId++;
+    request.completedBoundaries.push(boundary); // Emit a pending rendered suspense boundary wrapper.
+
+    writeStartPendingSuspenseBoundary(destination, request.renderState, boundary.rootSegmentID); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else {
+    {
+      hoistResources(request.renderState, boundary.resources);
+    } // We can inline this boundary's content as a complete boundary.
+
+
+    writeStartCompletedSuspenseBoundary(destination);
+    const completedSegments = boundary.completedSegments;
+
+    if (completedSegments.length !== 1) {
+      throw Error(formatProdErrorMessage(391));
+    }
+
+    const contentSegment = completedSegments[0];
+    flushSegment(request, destination, contentSegment);
+    return writeEndCompletedSuspenseBoundary(destination);
+  }
+}
+
+function flushClientRenderedBoundary(request, destination, boundary) {
+  return writeClientRenderBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.errorDigest, boundary.errorMessage, boundary.errorComponentStack);
+}
+
+function flushSegmentContainer(request, destination, segment) {
+  writeStartSegment(destination, request.renderState, segment.parentFormatContext, segment.id);
+  flushSegment(request, destination, segment);
+  return writeEndSegment(destination, segment.parentFormatContext);
+}
+
+function flushCompletedBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+    flushPartiallyCompletedSegment(request, destination, boundary, segment);
+  }
+
+  completedSegments.length = 0;
+
+  {
+    writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+
+  return writeCompletedBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.resources);
+}
+
+function flushPartialBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+
+    if (!flushPartiallyCompletedSegment(request, destination, boundary, segment)) {
+      i++;
+      completedSegments.splice(0, i); // Only write as much as the buffer wants. Something higher priority
+      // might want to write later.
+
+      return false;
+    }
+  }
+
+  completedSegments.splice(0, i);
+
+  {
+    // The way this is structured we only write resources for partial boundaries
+    // if there is no backpressure. Later before we complete the boundary we
+    // will write resources regardless of backpressure before we emit the
+    // completion instruction
+    return writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+}
+
+function flushPartiallyCompletedSegment(request, destination, boundary, segment) {
+  if (segment.status === FLUSHED) {
+    // We've already flushed this inline.
+    return true;
+  }
+
+  const segmentID = segment.id;
+
+  if (segmentID === -1) {
+    // This segment wasn't previously referred to. This happens at the root of
+    // a boundary. We make kind of a leap here and assume this is the root.
+    const rootSegmentID = segment.id = boundary.rootSegmentID;
+
+    if (rootSegmentID === -1) {
+      throw Error(formatProdErrorMessage(392));
+    }
+
+    return flushSegmentContainer(request, destination, segment);
+  } else if (segmentID === boundary.rootSegmentID) {
+    // When we emit postponed boundaries, we might have assigned the ID already
+    // but it's still the root segment so we can't inject it into the parent yet.
+    return flushSegmentContainer(request, destination, segment);
+  } else {
+    flushSegmentContainer(request, destination, segment);
+    return writeCompletedSegmentInstruction(destination, request.resumableState, request.renderState, segmentID);
+  }
+}
+
+function flushCompletedQueues(request, destination) {
+  beginWriting();
+
+  try {
+    // The structure of this is to go through each queue one by one and write
+    // until the sink tells us to stop. When we should stop, we still finish writing
+    // that item fully and then yield. At that point we remove the already completed
+    // items up until the point we completed them.
+    let i;
+    const completedRootSegment = request.completedRootSegment;
+
+    if (completedRootSegment !== null) {
+      if (completedRootSegment.status === POSTPONED) {
+        // We postponed the root, so we write nothing.
+        return;
+      } else if (request.pendingRootTasks === 0) {
+        if (enableFloat) {
+          writePreamble(destination, request.resumableState, request.renderState, request.allPendingTasks === 0 && request.trackedPostpones === null);
+        }
+
+        flushSegment(request, destination, completedRootSegment);
+        request.completedRootSegment = null;
+        writeCompletedRoot(destination, request.renderState, request.resumableState);
+      } else {
+        // We haven't flushed the root yet so we don't need to check any other branches further down
+        return;
+      }
+    }
+
+    if (enableFloat) {
+      writeHoistables(destination, request.resumableState, request.renderState);
+    } // We emit client rendering instructions for already emitted boundaries first.
+    // This is so that we can signal to the client to start client rendering them as
+    // soon as possible.
+
+
+    const clientRenderedBoundaries = request.clientRenderedBoundaries;
+
+    for (i = 0; i < clientRenderedBoundaries.length; i++) {
+      const boundary = clientRenderedBoundaries[i];
+
+      if (!flushClientRenderedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        clientRenderedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    clientRenderedBoundaries.splice(0, i); // Next we emit any complete boundaries. It's better to favor boundaries
+    // that are completely done since we can actually show them, than it is to emit
+    // any individual segments from a partially complete boundary.
+
+    const completedBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < completedBoundaries.length; i++) {
+      const boundary = completedBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        completedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    completedBoundaries.splice(0, i); // Allow anything written so far to flush to the underlying sink before
+    // we continue with lower priorities.
+
+    completeWriting(destination);
+    beginWriting(destination); // TODO: Here we'll emit data used by hydration.
+    // Next we emit any segments of any boundaries that are partially complete
+    // but not deeply complete.
+
+    const partialBoundaries = request.partialBoundaries;
+
+    for (i = 0; i < partialBoundaries.length; i++) {
+      const boundary = partialBoundaries[i];
+
+      if (!flushPartialBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        partialBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    partialBoundaries.splice(0, i); // Next we check the completed boundaries again. This may have had
+    // boundaries added to it in case they were too larged to be inlined.
+    // New ones might be added in this loop.
+
+    const largeBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < largeBoundaries.length; i++) {
+      const boundary = largeBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        largeBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    largeBoundaries.splice(0, i);
+  } finally {
+    if (request.allPendingTasks === 0 && request.pingedTasks.length === 0 && request.clientRenderedBoundaries.length === 0 && request.completedBoundaries.length === 0 // We don't need to check any partially completed segments because
+    // either they have pending task or they're complete.
+    ) {
+        request.flushScheduled = false;
+
+        {
+          // We write the trailing tags but only if don't have any data to resume.
+          // If we need to resume we'll write the postamble in the resume instead.
+          if (request.trackedPostpones === null) {
+            writePostamble(destination, request.resumableState);
+          }
+        }
+
+        completeWriting(destination);
+
+
+        close(destination); // We need to stop flowing now because we do not want any async contexts which might call
+        // float methods to initiate any flushes after this point
+
+        stopFlowing(request);
+      } else {
+      completeWriting(destination);
+    }
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  {
+    scheduleWork(() => performWork(request));
+  }
+
+  if (request.trackedPostpones === null) {
+    // this is either a regular render or a resume. For regular render we want
+    // to call emitEarlyPreloads after the first performWork because we want
+    // are responding to a live request and need to balance sending something early
+    // (i.e. don't want for the shell to finish) but we need something to send.
+    // The only implementation of this is for DOM at the moment and during resumes nothing
+    // actually emits but the code paths here are the same.
+    // During a prerender we don't want to be too aggressive in emitting early preloads
+    // because we aren't responding to a live request and we can wait for the prerender to
+    // postpone before we emit anything.
+    {
+      scheduleWork(() => enqueueEarlyPreloadsAfterInitialWork(request));
+    }
+  }
+}
+
+function enqueueEarlyPreloadsAfterInitialWork(request) {
+  const shellComplete = request.pendingRootTasks === 0;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    request.flushScheduled = true;
+    scheduleWork(() => {
+      // We need to existence check destination again here because it might go away
+      // in between the enqueueFlush call and the work execution
+      const destination = request.destination;
+
+      if (destination) {
+        flushCompletedQueues(request, destination);
+      } else {
+        request.flushScheduled = false;
+      }
+    });
+  }
+} // This function is intented to only be called during the pipe function for the Node builds.
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedQueues(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function stopFlowing(request) {
+  request.destination = null;
+} // This is called to early terminate a request. It puts all pending boundaries in client rendered state.
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      const error = reason === undefined ? Error(formatProdErrorMessage(432)) : reason;
+      abortableTasks.forEach(task => abortTask(task, request, error));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function flushResources(request) {
+  enqueueFlush(request);
+}
+function getFormState(request) {
+  return request.formState;
+}
+function getResumableState(request) {
+  return request.resumableState;
+}
+function getRenderState(request) {
+  return request.renderState;
+}
+
+function addToReplayParent(node, parentKeyPath, trackedPostpones) {
+  if (parentKeyPath === null) {
+    trackedPostpones.rootNodes.push(node);
+  } else {
+    const workingMap = trackedPostpones.workingMap;
+    let parentNode = workingMap.get(parentKeyPath);
+
+    if (parentNode === undefined) {
+      parentNode = [parentKeyPath[1], parentKeyPath[2], [], null];
+      workingMap.set(parentKeyPath, parentNode);
+      addToReplayParent(parentNode, parentKeyPath[0], trackedPostpones);
+    }
+
+    parentNode[2].push(node);
+  }
+} // Returns the state of a postponed request or null if nothing was postponed.
+
+
+function getPostponedState(request) {
+  const trackedPostpones = request.trackedPostpones;
+
+  if (trackedPostpones === null || trackedPostpones.rootNodes.length === 0 && trackedPostpones.rootSlots === null) {
+    // Reset. Let the flushing behave as if we completed the whole document.
+    request.trackedPostpones = null;
+    return null;
+  }
+
+  if (request.completedRootSegment !== null && request.completedRootSegment.status === POSTPONED) {
+    // We postponed the root so we didn't flush anything.
+    resetResumableState(request.resumableState, request.renderState);
+  }
+
+  return {
+    nextSegmentId: request.nextSegmentId,
+    rootFormatContext: request.rootFormatContext,
+    progressiveChunkSize: request.progressiveChunkSize,
+    resumableState: request.resumableState,
+    replayNodes: trackedPostpones.rootNodes,
+    replaySlots: trackedPostpones.rootSlots
+  };
+}
+
+function renderToReadableStream(children, options) {
+  return new Promise((resolve, reject) => {
+    let onFatalError;
+    let onAllReady;
+    const allReady = new Promise((res, rej) => {
+      onAllReady = res;
+      onFatalError = rej;
+    });
+
+    function onShellReady() {
+      const stream = new ReadableStream({
+        type: 'bytes',
+        pull: controller => {
+          startFlowing(request, controller);
+        },
+        cancel: reason => {
+          stopFlowing(request);
+          abort(request, reason);
+        }
+      }, // $FlowFixMe[prop-missing] size() methods are not allowed on byte streams.
+      {
+        highWaterMark: 0
+      }); // TODO: Move to sub-classing ReadableStream.
+
+      stream.allReady = allReady;
+      resolve(stream);
+    }
+
+    function onShellError(error) {
+      // If the shell errors the caller of `renderToReadableStream` won't have access to `allReady`.
+      // However, `allReady` will be rejected by `onFatalError` as well.
+      // So we need to catch the duplicate, uncatchable fatal error in `allReady` to prevent a `UnhandledPromiseRejection`.
+      allReady.catch(() => {});
+      reject(error);
+    }
+
+    const onHeaders = options ? options.onHeaders : undefined;
+    let onHeadersImpl;
+
+    if (onHeaders) {
+      onHeadersImpl = headersDescriptor => {
+        onHeaders(new Headers(headersDescriptor));
+      };
+    }
+
+    const resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined);
+    const request = createRequest(children, resumableState, createRenderState(resumableState, options ? options.nonce : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, onHeadersImpl, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, onShellReady, onShellError, onFatalError, options ? options.onPostpone : undefined, options ? options.formState : undefined);
+
+    if (options && options.signal) {
+      const signal = options.signal;
+
+      if (signal.aborted) {
+        abort(request, signal.reason);
+      } else {
+        const listener = () => {
+          abort(request, signal.reason);
+          signal.removeEventListener('abort', listener);
+        };
+
+        signal.addEventListener('abort', listener);
+      }
+    }
+
+    startWork(request);
+  });
+}
+
+function resume(children, postponedState, options) {
+  return new Promise((resolve, reject) => {
+    let onFatalError;
+    let onAllReady;
+    const allReady = new Promise((res, rej) => {
+      onAllReady = res;
+      onFatalError = rej;
+    });
+
+    function onShellReady() {
+      const stream = new ReadableStream({
+        type: 'bytes',
+        pull: controller => {
+          startFlowing(request, controller);
+        },
+        cancel: reason => {
+          stopFlowing(request);
+          abort(request, reason);
+        }
+      }, // $FlowFixMe[prop-missing] size() methods are not allowed on byte streams.
+      {
+        highWaterMark: 0
+      }); // TODO: Move to sub-classing ReadableStream.
+
+      stream.allReady = allReady;
+      resolve(stream);
+    }
+
+    function onShellError(error) {
+      // If the shell errors the caller of `renderToReadableStream` won't have access to `allReady`.
+      // However, `allReady` will be rejected by `onFatalError` as well.
+      // So we need to catch the duplicate, uncatchable fatal error in `allReady` to prevent a `UnhandledPromiseRejection`.
+      allReady.catch(() => {});
+      reject(error);
+    }
+
+    const request = resumeRequest(children, postponedState, resumeRenderState(postponedState.resumableState, options ? options.nonce : undefined), options ? options.onError : undefined, onAllReady, onShellReady, onShellError, onFatalError, options ? options.onPostpone : undefined);
+
+    if (options && options.signal) {
+      const signal = options.signal;
+
+      if (signal.aborted) {
+        abort(request, signal.reason);
+      } else {
+        const listener = () => {
+          abort(request, signal.reason);
+          signal.removeEventListener('abort', listener);
+        };
+
+        signal.addEventListener('abort', listener);
+      }
+    }
+
+    startWork(request);
+  });
+}
+
+function prerender(children, options) {
+  return new Promise((resolve, reject) => {
+    const onFatalError = reject;
+
+    function onAllReady() {
+      const stream = new ReadableStream({
+        type: 'bytes',
+        pull: controller => {
+          startFlowing(request, controller);
+        },
+        cancel: reason => {
+          stopFlowing(request);
+          abort(request, reason);
+        }
+      }, // $FlowFixMe[prop-missing] size() methods are not allowed on byte streams.
+      {
+        highWaterMark: 0
+      });
+      const result = {
+        postponed: getPostponedState(request),
+        prelude: stream
+      };
+      resolve(result);
+    }
+
+    const onHeaders = options ? options.onHeaders : undefined;
+    let onHeadersImpl;
+
+    if (onHeaders) {
+      onHeadersImpl = headersDescriptor => {
+        onHeaders(new Headers(headersDescriptor));
+      };
+    }
+
+    const resources = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined);
+    const request = createPrerenderRequest(children, resources, createRenderState(resources, undefined, // nonce is not compatible with prerendered bootstrap scripts
+    options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, onHeadersImpl, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, undefined, undefined, onFatalError, options ? options.onPostpone : undefined);
+
+    if (options && options.signal) {
+      const signal = options.signal;
+
+      if (signal.aborted) {
+        abort(request, signal.reason);
+      } else {
+        const listener = () => {
+          abort(request, signal.reason);
+          signal.removeEventListener('abort', listener);
+        };
+
+        signal.addEventListener('abort', listener);
+      }
+    }
+
+    startWork(request);
+  });
+}
+
+exports.prerender = prerender;
+exports.renderToReadableStream = renderToReadableStream;
+exports.resume = resume;
+exports.version = ReactVersion;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.browser.production.min.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.browser.production.min.js
index 11d7b2f83d6df..c7ff75f41e179 100644
--- a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.browser.production.min.js
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.browser.production.min.js
@@ -1,13 +1,11 @@
-/**
- * @license React
- * react-dom-server.browser.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
 /*
+ React
+ react-dom-server.browser.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
 
 
  JS Implementation of MurmurHash3 (r136) (as of May 20, 2011)
@@ -33,8 +31,8 @@
 */
 'use strict';var da=require("next/dist/compiled/react-experimental"),ea=require("react-dom");function l(a){for(var b="https://reactjs.org/docs/error-decoder.html?invariant="+a,c=1;c<arguments.length;c++)b+="&args[]="+encodeURIComponent(arguments[c]);return"Minified React error #"+a+"; visit "+b+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}
 function fa(a,b){var c=a.length&3;var d=a.length-c;var e=b;for(b=0;b<d;){var f=a.charCodeAt(b)&255|(a.charCodeAt(++b)&255)<<8|(a.charCodeAt(++b)&255)<<16|(a.charCodeAt(++b)&255)<<24;++b;f=3432918353*(f&65535)+((3432918353*(f>>>16)&65535)<<16)&4294967295;f=f<<15|f>>>17;f=461845907*(f&65535)+((461845907*(f>>>16)&65535)<<16)&4294967295;e^=f;e=e<<13|e>>>19;e=5*(e&65535)+((5*(e>>>16)&65535)<<16)&4294967295;e=(e&65535)+27492+(((e>>>16)+58964&65535)<<16)}f=0;switch(c){case 3:f^=(a.charCodeAt(b+2)&255)<<
-16;case 2:f^=(a.charCodeAt(b+1)&255)<<8;case 1:f^=a.charCodeAt(b)&255,f=3432918353*(f&65535)+((3432918353*(f>>>16)&65535)<<16)&4294967295,f=f<<15|f>>>17,e^=461845907*(f&65535)+((461845907*(f>>>16)&65535)<<16)&4294967295}e^=a.length;e^=e>>>16;e=2246822507*(e&65535)+((2246822507*(e>>>16)&65535)<<16)&4294967295;e^=e>>>13;e=3266489909*(e&65535)+((3266489909*(e>>>16)&65535)<<16)&4294967295;return(e^e>>>16)>>>0}var n=null,r=0;
-function v(a,b){if(0!==b.byteLength)if(512<b.byteLength)0<r&&(a.enqueue(new Uint8Array(n.buffer,0,r)),n=new Uint8Array(512),r=0),a.enqueue(b);else{var c=n.length-r;c<b.byteLength&&(0===c?a.enqueue(n):(n.set(b.subarray(0,c),r),a.enqueue(n),b=b.subarray(c)),n=new Uint8Array(512),r=0);n.set(b,r);r+=b.byteLength}}function w(a,b){v(a,b);return!0}function ja(a){n&&0<r&&(a.enqueue(new Uint8Array(n.buffer,0,r)),n=null,r=0)}var ka=new TextEncoder;function y(a){return ka.encode(a)}
+16;case 2:f^=(a.charCodeAt(b+1)&255)<<8;case 1:f^=a.charCodeAt(b)&255,f=3432918353*(f&65535)+((3432918353*(f>>>16)&65535)<<16)&4294967295,f=f<<15|f>>>17,e^=461845907*(f&65535)+((461845907*(f>>>16)&65535)<<16)&4294967295}e^=a.length;e^=e>>>16;e=2246822507*(e&65535)+((2246822507*(e>>>16)&65535)<<16)&4294967295;e^=e>>>13;e=3266489909*(e&65535)+((3266489909*(e>>>16)&65535)<<16)&4294967295;return(e^e>>>16)>>>0}var n=null,q=0;
+function v(a,b){if(0!==b.byteLength)if(512<b.byteLength)0<q&&(a.enqueue(new Uint8Array(n.buffer,0,q)),n=new Uint8Array(512),q=0),a.enqueue(b);else{var c=n.length-q;c<b.byteLength&&(0===c?a.enqueue(n):(n.set(b.subarray(0,c),q),a.enqueue(n),b=b.subarray(c)),n=new Uint8Array(512),q=0);n.set(b,q);q+=b.byteLength}}function w(a,b){v(a,b);return!0}function ja(a){n&&0<q&&(a.enqueue(new Uint8Array(n.buffer,0,q)),n=null,q=0)}var ka=new TextEncoder;function y(a){return ka.encode(a)}
 function A(a){return ka.encode(a)}function la(a,b){"function"===typeof a.error?a.error(b):a.close()}
 var B=Object.assign,E=Object.prototype.hasOwnProperty,pa=RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"),qa={},ra={};
 function ya(a){if(E.call(ra,a))return!0;if(E.call(qa,a))return!1;if(pa.test(a))return ra[a]=!0;qa[a]=!0;return!1}
@@ -48,12 +46,12 @@ new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv","http
 function H(a){if("boolean"===typeof a||"number"===typeof a)return""+a;a=""+a;var b=Ha.exec(a);if(b){var c="",d,e=0;for(d=b.index;d<a.length;d++){switch(a.charCodeAt(d)){case 34:b="&quot;";break;case 38:b="&amp;";break;case 39:b="&#x27;";break;case 60:b="&lt;";break;case 62:b="&gt;";break;default:continue}e!==d&&(c+=a.slice(e,d));e=d+1;c+=b}a=e!==d?c+a.slice(e,d):c}return a}
 var Ia=/([A-Z])/g,Ja=/^ms-/,Ka=Array.isArray,La=da.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,Ma={pending:!1,data:null,method:null,action:null},Na=ea.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Dispatcher,bb={prefetchDNS:Oa,preconnect:Wa,preload:Xa,preloadModule:Ya,preinitStyle:Za,preinitScript:$a,preinitModuleScript:ab},J=[],cb=A('"></template>'),db=A("<script>"),rb=A("\x3c/script>"),sb=A('<script src="'),tb=A('<script type="module" src="'),ub=A('" nonce="'),vb=A('" integrity="'),
 wb=A('" crossorigin="'),xb=A('" async="">\x3c/script>'),yb=/(<\/|<)(s)(cript)/gi;function zb(a,b,c,d){return""+b+("s"===c?"\\u0073":"\\u0053")+d}var Ab=A('<script type="importmap">'),Jb=A("\x3c/script>");
-function Kb(a,b,c,d,e,f,g,h,k){var m=void 0===b?db:A('<script nonce="'+H(b)+'">'),p=a.idPrefix,t=[],q=null;void 0!==c&&t.push(m,y((""+c).replace(yb,zb)),rb);void 0!==f&&("string"===typeof f?(q={src:f,chunks:[]},Lb(q.chunks,{src:f,async:!0,integrity:void 0,nonce:b})):(q={src:f.src,chunks:[]},Lb(q.chunks,{src:f.src,async:!0,integrity:f.integrity,nonce:b})));c=[];void 0!==g&&(c.push(Ab),c.push(y((""+JSON.stringify(g)).replace(yb,zb))),c.push(Jb));g=h?{preconnects:"",fontPreloads:"",highImagePreloads:"",
-remainingCapacity:"number"===typeof k?k:2E3}:null;h={placeholderPrefix:A(p+"P:"),segmentPrefix:A(p+"S:"),boundaryPrefix:A(p+"B:"),startInlineScript:m,htmlChunks:null,headChunks:null,externalRuntimeScript:q,bootstrapChunks:t,onHeaders:h,headers:g,resets:{font:{},dns:{},connect:{default:{},anonymous:{},credentials:{}},image:{},style:{}},charsetChunks:[],preconnectChunks:[],importMapChunks:c,preloadChunks:[],hoistableChunks:[],preconnects:new Set,fontPreloads:new Set,highImagePreloads:new Set,styles:new Map,
-bootstrapScripts:new Set,scripts:new Set,bulkPreloads:new Set,preloads:{images:new Map,stylesheets:new Map,scripts:new Map,moduleScripts:new Map},nonce:b,boundaryResources:null,stylesToHoist:!1};if(void 0!==d)for(m=0;m<d.length;m++)c=d[m],g=q=void 0,k={rel:"preload",as:"script",fetchPriority:"low",nonce:b},"string"===typeof c?k.href=p=c:(k.href=p=c.src,k.integrity=g="string"===typeof c.integrity?c.integrity:void 0,k.crossOrigin=q="string"===typeof c||null==c.crossOrigin?void 0:"use-credentials"===
-c.crossOrigin?"use-credentials":""),c=a,f=p,c.scriptResources[f]=null,c.moduleScriptResources[f]=null,c=[],K(c,k),h.bootstrapScripts.add(c),t.push(sb,y(H(p))),b&&t.push(ub,y(H(b))),"string"===typeof g&&t.push(vb,y(H(g))),"string"===typeof q&&t.push(wb,y(H(q))),t.push(xb);if(void 0!==e)for(d=0;d<e.length;d++)k=e[d],q=p=void 0,g={rel:"modulepreload",fetchPriority:"low",nonce:b},"string"===typeof k?g.href=m=k:(g.href=m=k.src,g.integrity=q="string"===typeof k.integrity?k.integrity:void 0,g.crossOrigin=
-p="string"===typeof k||null==k.crossOrigin?void 0:"use-credentials"===k.crossOrigin?"use-credentials":""),k=a,c=m,k.scriptResources[c]=null,k.moduleScriptResources[c]=null,k=[],K(k,g),h.bootstrapScripts.add(k),t.push(tb,y(H(m))),b&&t.push(ub,y(H(b))),"string"===typeof q&&t.push(vb,y(H(q))),"string"===typeof p&&t.push(wb,y(H(p))),t.push(xb);return h}
-function Mb(a,b){var c=0;void 0!==b&&(c=1);return{idPrefix:void 0===a?"":a,nextFormID:0,streamingFormat:c,instructions:0,hasBody:!1,hasHtml:!1,unknownResources:{},dnsResources:{},connectResources:{default:{},anonymous:{},credentials:{}},imageResources:{},styleResources:{},scriptResources:{},moduleUnknownResources:{},moduleScriptResources:{}}}function O(a,b,c){return{insertionMode:a,selectedValue:b,tagScope:c}}
+function Kb(a,b,c,d,e,f){var g=void 0===b?db:A('<script nonce="'+H(b)+'">'),h=a.idPrefix,k=[],m=null,p=a.bootstrapScriptContent,t=a.bootstrapScripts,r=a.bootstrapModules;void 0!==p&&k.push(g,y((""+p).replace(yb,zb)),rb);void 0!==c&&("string"===typeof c?(m={src:c,chunks:[]},Lb(m.chunks,{src:c,async:!0,integrity:void 0,nonce:b})):(m={src:c.src,chunks:[]},Lb(m.chunks,{src:c.src,async:!0,integrity:c.integrity,nonce:b})));c=[];void 0!==d&&(c.push(Ab),c.push(y((""+JSON.stringify(d)).replace(yb,zb))),c.push(Jb));
+d=e?{preconnects:"",fontPreloads:"",highImagePreloads:"",remainingCapacity:"number"===typeof f?f:2E3}:null;e={placeholderPrefix:A(h+"P:"),segmentPrefix:A(h+"S:"),boundaryPrefix:A(h+"B:"),startInlineScript:g,htmlChunks:null,headChunks:null,externalRuntimeScript:m,bootstrapChunks:k,onHeaders:e,headers:d,resets:{font:{},dns:{},connect:{default:{},anonymous:{},credentials:{}},image:{},style:{}},charsetChunks:[],preconnectChunks:[],importMapChunks:c,preloadChunks:[],hoistableChunks:[],preconnects:new Set,
+fontPreloads:new Set,highImagePreloads:new Set,styles:new Map,bootstrapScripts:new Set,scripts:new Set,bulkPreloads:new Set,preloads:{images:new Map,stylesheets:new Map,scripts:new Map,moduleScripts:new Map},nonce:b,boundaryResources:null,stylesToHoist:!1};if(void 0!==t)for(g=0;g<t.length;g++)c=t[g],d=m=void 0,f={rel:"preload",as:"script",fetchPriority:"low",nonce:b},"string"===typeof c?f.href=h=c:(f.href=h=c.src,f.integrity=d="string"===typeof c.integrity?c.integrity:void 0,f.crossOrigin=m="string"===
+typeof c||null==c.crossOrigin?void 0:"use-credentials"===c.crossOrigin?"use-credentials":""),c=a,p=h,c.scriptResources[p]=null,c.moduleScriptResources[p]=null,c=[],K(c,f),e.bootstrapScripts.add(c),k.push(sb,y(H(h))),b&&k.push(ub,y(H(b))),"string"===typeof d&&k.push(vb,y(H(d))),"string"===typeof m&&k.push(wb,y(H(m))),k.push(xb);if(void 0!==r)for(t=0;t<r.length;t++)f=r[t],m=h=void 0,d={rel:"modulepreload",fetchPriority:"low",nonce:b},"string"===typeof f?d.href=g=f:(d.href=g=f.src,d.integrity=m="string"===
+typeof f.integrity?f.integrity:void 0,d.crossOrigin=h="string"===typeof f||null==f.crossOrigin?void 0:"use-credentials"===f.crossOrigin?"use-credentials":""),f=a,c=g,f.scriptResources[c]=null,f.moduleScriptResources[c]=null,f=[],K(f,d),e.bootstrapScripts.add(f),k.push(tb,y(H(g))),b&&k.push(ub,y(H(b))),"string"===typeof m&&k.push(vb,y(H(m))),"string"===typeof h&&k.push(wb,y(H(h))),k.push(xb);return e}
+function Mb(a,b,c,d,e){var f=0;void 0!==b&&(f=1);return{idPrefix:void 0===a?"":a,nextFormID:0,streamingFormat:f,bootstrapScriptContent:c,bootstrapScripts:d,bootstrapModules:e,instructions:0,hasBody:!1,hasHtml:!1,unknownResources:{},dnsResources:{},connectResources:{default:{},anonymous:{},credentials:{}},imageResources:{},styleResources:{},scriptResources:{},moduleUnknownResources:{},moduleScriptResources:{}}}function O(a,b,c){return{insertionMode:a,selectedValue:b,tagScope:c}}
 function Nb(a){return O("http://www.w3.org/2000/svg"===a?3:"http://www.w3.org/1998/Math/MathML"===a?4:0,null,0)}
 function Ob(a,b,c){switch(b){case "noscript":return O(2,null,a.tagScope|1);case "select":return O(2,null!=c.value?c.value:c.defaultValue,a.tagScope);case "svg":return O(3,null,a.tagScope);case "picture":return O(2,null,a.tagScope|2);case "math":return O(4,null,a.tagScope);case "foreignObject":return O(2,null,a.tagScope);case "table":return O(5,null,a.tagScope);case "thead":case "tbody":case "tfoot":return O(6,null,a.tagScope);case "colgroup":return O(8,null,a.tagScope);case "tr":return O(7,null,a.tagScope)}return 5<=
 a.insertionMode?O(2,null,a.tagScope):0===a.insertionMode?"html"===b?O(1,null,a.tagScope):O(2,null,a.tagScope):1===a.insertionMode?O(2,null,a.tagScope):a}var Pb=A("\x3c!-- --\x3e");function Qb(a,b,c,d){if(""===b)return d;d&&a.push(Pb);a.push(y(H(b)));return!0}var Rb=new Map,Sb=A(' style="'),Tb=A(":"),Ub=A(";");
@@ -72,8 +70,8 @@ b)}}function K(a,b){a.push(W("link"));for(var c in b)if(E.call(b,c)){var d=b[c];
 function nc(a,b){a.push(W("title"));var c=null,d=null,e;for(e in b)if(E.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:U(a,e,f)}}a.push(V);b=Array.isArray(c)?2>c.length?c[0]:null:c;"function"!==typeof b&&"symbol"!==typeof b&&null!==b&&void 0!==b&&a.push(y(H(""+b)));ec(a,d,c);a.push(oc("title"));return null}
 function Lb(a,b){a.push(W("script"));var c=null,d=null,e;for(e in b)if(E.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:U(a,e,f)}}a.push(V);ec(a,d,c);"string"===typeof c&&a.push(y(H(c)));a.push(oc("script"));return null}
 function pc(a,b,c){a.push(W(c));var d=c=null,e;for(e in b)if(E.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:U(a,e,f)}}a.push(V);ec(a,d,c);return"string"===typeof c?(a.push(y(H(c))),null):c}var zc=A("\n"),Ac=/^[a-zA-Z][a-zA-Z:_\.\-\d]*$/,Bc=new Map;function W(a){var b=Bc.get(a);if(void 0===b){if(!Ac.test(a))throw Error(l(65,a));b=A("<"+a);Bc.set(a,b)}return b}var Cc=A("<!DOCTYPE html>");
-function Dc(a,b,c,d,e,f,g){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "select":a.push(W("select"));var h=null,k=null,m;for(m in c)if(E.call(c,m)){var p=c[m];if(null!=p)switch(m){case "children":h=p;break;case "dangerouslySetInnerHTML":k=p;break;case "defaultValue":case "value":break;default:U(a,m,p)}}a.push(V);ec(a,k,h);return h;case "option":var t=f.selectedValue;a.push(W("option"));var q=null,z=null,D=null,aa=null,u;for(u in c)if(E.call(c,
-u)){var C=c[u];if(null!=C)switch(u){case "children":q=C;break;case "selected":D=C;break;case "dangerouslySetInnerHTML":aa=C;break;case "value":z=C;default:U(a,u,C)}}if(null!=t){var F=null!==z?""+z:fc(q);if(Ka(t))for(var ma=0;ma<t.length;ma++){if(""+t[ma]===F){a.push(gc);break}}else""+t===F&&a.push(gc)}else D&&a.push(gc);a.push(V);ec(a,aa,q);return q;case "textarea":a.push(W("textarea"));var x=null,T=null,G=null,L;for(L in c)if(E.call(c,L)){var M=c[L];if(null!=M)switch(L){case "children":G=M;break;
+function Dc(a,b,c,d,e,f,g){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "select":a.push(W("select"));var h=null,k=null,m;for(m in c)if(E.call(c,m)){var p=c[m];if(null!=p)switch(m){case "children":h=p;break;case "dangerouslySetInnerHTML":k=p;break;case "defaultValue":case "value":break;default:U(a,m,p)}}a.push(V);ec(a,k,h);return h;case "option":var t=f.selectedValue;a.push(W("option"));var r=null,z=null,D=null,aa=null,u;for(u in c)if(E.call(c,
+u)){var C=c[u];if(null!=C)switch(u){case "children":r=C;break;case "selected":D=C;break;case "dangerouslySetInnerHTML":aa=C;break;case "value":z=C;default:U(a,u,C)}}if(null!=t){var F=null!==z?""+z:fc(r);if(Ka(t))for(var ma=0;ma<t.length;ma++){if(""+t[ma]===F){a.push(gc);break}}else""+t===F&&a.push(gc)}else D&&a.push(gc);a.push(V);ec(a,aa,r);return r;case "textarea":a.push(W("textarea"));var x=null,T=null,G=null,L;for(L in c)if(E.call(c,L)){var M=c[L];if(null!=M)switch(L){case "children":G=M;break;
 case "value":x=M;break;case "defaultValue":T=M;break;case "dangerouslySetInnerHTML":throw Error(l(91));default:U(a,L,M)}}null===x&&null!==T&&(x=T);a.push(V);if(null!=G){if(null!=x)throw Error(l(92));if(Ka(G)){if(1<G.length)throw Error(l(93));x=""+G[0]}x=""+G}"string"===typeof x&&"\n"===x[0]&&a.push(zc);null!==x&&a.push(y(H(""+x)));return null;case "input":a.push(W("input"));var Pa=null,Ba=null,sa=null,na=null,Ca=null,ta=null,ua=null,va=null,Qa=null,ha;for(ha in c)if(E.call(c,ha)){var ba=c[ha];if(null!=
 ba)switch(ha){case "children":case "dangerouslySetInnerHTML":throw Error(l(399,"input"));case "name":Pa=ba;break;case "formAction":Ba=ba;break;case "formEncType":sa=ba;break;case "formMethod":na=ba;break;case "formTarget":Ca=ba;break;case "defaultChecked":Qa=ba;break;case "defaultValue":ua=ba;break;case "checked":va=ba;break;case "value":ta=ba;break;default:U(a,ha,ba)}}var Cd=cc(a,d,e,Ba,sa,na,Ca,Pa);null!==va?Xb(a,"checked",va):null!==Qa&&Xb(a,"checked",Qa);null!==ta?U(a,"value",ta):null!==ua&&U(a,
 "value",ua);a.push(bc);null!==Cd&&Cd.forEach(ac,a);return null;case "button":a.push(W("button"));var eb=null,Dd=null,Ed=null,Fd=null,Gd=null,Hd=null,Id=null,fb;for(fb in c)if(E.call(c,fb)){var oa=c[fb];if(null!=oa)switch(fb){case "children":eb=oa;break;case "dangerouslySetInnerHTML":Dd=oa;break;case "name":Ed=oa;break;case "formAction":Fd=oa;break;case "formEncType":Gd=oa;break;case "formMethod":Hd=oa;break;case "formTarget":Id=oa;break;default:U(a,fb,oa)}}var Jd=cc(a,d,e,Fd,Gd,Hd,Id,Ed);a.push(V);
@@ -90,8 +88,8 @@ e.highImagePreloads.add(Ga)}else if(!d.imageResources.hasOwnProperty(Ua)){d.imag
 xc.length))?(e.resets.image[Ua]=J,ia.highImagePreloads&&(ia.highImagePreloads+=", "),ia.highImagePreloads+=xc):(Ga=[],K(Ga,{rel:"preload",as:"image",href:I?void 0:N,imageSrcSet:I,imageSizes:Yd,crossOrigin:Zd,integrity:c.integrity,type:c.type,fetchPriority:c.fetchPriority,referrerPolicy:c.referrerPolicy}),"high"===c.fetchPriority||10>e.highImagePreloads.size?e.highImagePreloads.add(Ga):(e.bulkPreloads.add(Ga),vc.set(Ua,Ga)))}}return mc(a,c,"img");case "base":case "area":case "br":case "col":case "embed":case "hr":case "keygen":case "param":case "source":case "track":case "wbr":return mc(a,
 c,b);case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph":break;case "head":if(2>f.insertionMode&&null===e.headChunks){e.headChunks=[];var $d=pc(e.headChunks,c,"head")}else $d=pc(a,c,"head");return $d;case "html":if(0===f.insertionMode&&null===e.htmlChunks){e.htmlChunks=[Cc];var ae=pc(e.htmlChunks,c,"html")}else ae=pc(a,c,"html");return ae;default:if(-1!==b.indexOf("-")){a.push(W(b));
 var yc=null,be=null,Va;for(Va in c)if(E.call(c,Va)){var ca=c[Va];if(null!=ca){var ce=Va;switch(Va){case "children":yc=ca;break;case "dangerouslySetInnerHTML":be=ca;break;case "style":Vb(a,ca);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":break;case "className":ce="class";default:if(ya(Va)&&"function"!==typeof ca&&"symbol"!==typeof ca&&!1!==ca){if(!0===ca)ca="";else if("object"===typeof ca)continue;a.push(Q,y(ce),R,y(H(ca)),P)}}}}a.push(V);ec(a,be,yc);return yc}}return pc(a,
-c,b)}var Fc=new Map;function oc(a){var b=Fc.get(a);void 0===b&&(b=A("</"+a+">"),Fc.set(a,b));return b}function Gc(a,b){b=b.bootstrapChunks;for(var c=0;c<b.length-1;c++)v(a,b[c]);return c<b.length?(c=b[c],b.length=0,w(a,c)):!0}var Hc=A('<template id="'),Ic=A('"></template>'),Jc=A("\x3c!--$--\x3e"),Kc=A('\x3c!--$?--\x3e<template id="'),Lc=A('"></template>'),Mc=A("\x3c!--$!--\x3e"),Nc=A("\x3c!--/$--\x3e"),Oc=A("<template"),Pc=A('"'),Qc=A(' data-dgst="');A(' data-msg="');A(' data-stck="');var Rc=A("></template>");
-function Sc(a,b,c){v(a,Kc);if(null===c)throw Error(l(395));v(a,b.boundaryPrefix);v(a,y(c.toString(16)));return w(a,Lc)}
+c,b)}var Fc=new Map;function oc(a){var b=Fc.get(a);void 0===b&&(b=A("</"+a+">"),Fc.set(a,b));return b}function Gc(a,b,c){c.bootstrapScriptContent=void 0;c.bootstrapScripts=void 0;c.bootstrapModules=void 0;b=b.bootstrapChunks;for(c=0;c<b.length-1;c++)v(a,b[c]);return c<b.length?(c=b[c],b.length=0,w(a,c)):!0}
+var Hc=A('<template id="'),Ic=A('"></template>'),Jc=A("\x3c!--$--\x3e"),Kc=A('\x3c!--$?--\x3e<template id="'),Lc=A('"></template>'),Mc=A("\x3c!--$!--\x3e"),Nc=A("\x3c!--/$--\x3e"),Oc=A("<template"),Pc=A('"'),Qc=A(' data-dgst="');A(' data-msg="');A(' data-stck="');var Rc=A("></template>");function Sc(a,b,c){v(a,Kc);if(null===c)throw Error(l(395));v(a,b.boundaryPrefix);v(a,y(c.toString(16)));return w(a,Lc)}
 var Tc=A('<div hidden id="'),Uc=A('">'),Vc=A("</div>"),Wc=A('<svg aria-hidden="true" style="display:none" id="'),Xc=A('">'),Yc=A("</svg>"),Zc=A('<math aria-hidden="true" style="display:none" id="'),$c=A('">'),ad=A("</math>"),bd=A('<table hidden id="'),cd=A('">'),dd=A("</table>"),ed=A('<table hidden><tbody id="'),fd=A('">'),gd=A("</tbody></table>"),hd=A('<table hidden><tr id="'),id=A('">'),jd=A("</tr></table>"),kd=A('<table hidden><colgroup id="'),ld=A('">'),md=A("</colgroup></table>");
 function nd(a,b,c,d){switch(c.insertionMode){case 0:case 1:case 2:return v(a,Tc),v(a,b.segmentPrefix),v(a,y(d.toString(16))),w(a,Uc);case 3:return v(a,Wc),v(a,b.segmentPrefix),v(a,y(d.toString(16))),w(a,Xc);case 4:return v(a,Zc),v(a,b.segmentPrefix),v(a,y(d.toString(16))),w(a,$c);case 5:return v(a,bd),v(a,b.segmentPrefix),v(a,y(d.toString(16))),w(a,cd);case 6:return v(a,ed),v(a,b.segmentPrefix),v(a,y(d.toString(16))),w(a,fd);case 7:return v(a,hd),v(a,b.segmentPrefix),v(a,y(d.toString(16))),w(a,id);
 case 8:return v(a,kd),v(a,b.segmentPrefix),v(a,y(d.toString(16))),w(a,ld);default:throw Error(l(397));}}function od(a,b){switch(b.insertionMode){case 0:case 1:case 2:return w(a,Vc);case 3:return w(a,Yc);case 4:return w(a,ad);case 5:return w(a,dd);case 6:return w(a,gd);case 7:return w(a,jd);case 8:return w(a,md);default:throw Error(l(397));}}
@@ -146,30 +144,30 @@ function xg(){throw Error(l(440));}function yg(){throw Error(l(394));}function z
 var Eg={readContext:function(a){return a._currentValue},use:function(a){if(null!==a&&"object"===typeof a){if("function"===typeof a.then)return Ag(a);if(a.$$typeof===kf||a.$$typeof===lf)return a._currentValue}throw Error(l(438,String(a)));},useContext:function(a){ng();return a._currentValue},useMemo:wg,useReducer:ug,useRef:function(a){$f=ng();Y=pg();var b=Y.memoizedState;return null===b?(a={current:a},Y.memoizedState=a):b},useState:function(a){return ug(tg,a)},useInsertionEffect:Cg,useLayoutEffect:Cg,
 useCallback:function(a,b){return wg(function(){return a},b)},useImperativeHandle:Cg,useEffect:Cg,useDebugValue:Cg,useDeferredValue:function(a,b){ng();return void 0!==b?b:a},useTransition:function(){ng();return[!1,yg]},useId:function(){var a=ag.treeContext;var b=a.overflow;a=a.id;a=(a&~(1<<32-Pf(a)-1)).toString(32)+b;var c=Dg;if(null===c)throw Error(l(404));b=gg++;a=":"+c.idPrefix+"R"+a;0<b&&(a+="H"+b.toString(32));return a+":"},useSyncExternalStore:function(a,b,c){if(void 0===c)throw Error(l(407));
 return c()},useCacheRefresh:function(){return Bg},useEffectEvent:function(){return xg},useMemoCache:function(a){for(var b=Array(a),c=0;c<a;c++)b[c]=yf;return b},useHostTransitionStatus:function(){ng();return Ma},useOptimistic:function(a){ng();return[a,zg]},useFormState:function(a,b,c){ng();var d=hg++,e=bg;if("function"===typeof a.$$FORM_ACTION){var f=null,g=cg;e=e.formState;var h=a.$$IS_SIGNATURE_EQUAL;if(null!==e&&"function"===typeof h){var k=e[1];h.call(a,e[2],e[3])&&(f=void 0!==c?"p"+c:"k"+fa(JSON.stringify([g,
-null,d]),0),k===f&&(ig=d,b=e[0]))}var m=a.bind(null,b);a=function(t){m(t)};"function"===typeof m.$$FORM_ACTION&&(a.$$FORM_ACTION=function(t){t=m.$$FORM_ACTION(t);void 0!==c&&(c+="",t.action=c);var q=t.data;q&&(null===f&&(f=void 0!==c?"p"+c:"k"+fa(JSON.stringify([g,null,d]),0)),q.append("$ACTION_KEY",f));return t});return[b,a]}var p=a.bind(null,b);return[b,function(t){p(t)}]}},Dg=null,Fg={getCacheSignal:function(){throw Error(l(248));},getCacheForType:function(){throw Error(l(248));}},Gg=La.ReactCurrentDispatcher,
+null,d]),0),k===f&&(ig=d,b=e[0]))}var m=a.bind(null,b);a=function(t){m(t)};"function"===typeof m.$$FORM_ACTION&&(a.$$FORM_ACTION=function(t){t=m.$$FORM_ACTION(t);void 0!==c&&(c+="",t.action=c);var r=t.data;r&&(null===f&&(f=void 0!==c?"p"+c:"k"+fa(JSON.stringify([g,null,d]),0)),r.append("$ACTION_KEY",f));return t});return[b,a]}var p=a.bind(null,b);return[b,function(t){p(t)}]}},Dg=null,Fg={getCacheSignal:function(){throw Error(l(248));},getCacheForType:function(){throw Error(l(248));}},Gg=La.ReactCurrentDispatcher,
 Hg=La.ReactCurrentCache;function Ig(a){console.error(a);return null}function Jg(){}
-function Kg(a,b,c,d,e,f,g,h,k,m,p,t){Na.current=bb;var q=[],z=new Set;b={destination:null,flushScheduled:!1,resumableState:b,renderState:c,rootFormatContext:d,progressiveChunkSize:void 0===e?12800:e,status:0,fatalError:null,nextSegmentId:0,allPendingTasks:0,pendingRootTasks:0,completedRootSegment:null,abortableTasks:z,pingedTasks:q,clientRenderedBoundaries:[],completedBoundaries:[],partialBoundaries:[],trackedPostpones:null,onError:void 0===f?Ig:f,onPostpone:void 0===p?Jg:p,onAllReady:void 0===g?
-Jg:g,onShellReady:void 0===h?Jg:h,onShellError:void 0===k?Jg:k,onFatalError:void 0===m?Jg:m,formState:void 0===t?null:t};c=Lg(b,0,null,d,!1,!1);c.parentFlushed=!0;a=Mg(b,null,a,-1,null,c,z,null,d,Cf,null,Nf);q.push(a);return b}function Ng(a,b,c,d,e,f,g,h,k,m,p){a=Kg(a,b,c,d,e,f,g,h,k,m,p,void 0);a.trackedPostpones={workingMap:new Map,rootNodes:[],rootSlots:null};return a}
+function Kg(a,b,c,d,e,f,g,h,k,m,p,t){Na.current=bb;var r=[],z=new Set;b={destination:null,flushScheduled:!1,resumableState:b,renderState:c,rootFormatContext:d,progressiveChunkSize:void 0===e?12800:e,status:0,fatalError:null,nextSegmentId:0,allPendingTasks:0,pendingRootTasks:0,completedRootSegment:null,abortableTasks:z,pingedTasks:r,clientRenderedBoundaries:[],completedBoundaries:[],partialBoundaries:[],trackedPostpones:null,onError:void 0===f?Ig:f,onPostpone:void 0===p?Jg:p,onAllReady:void 0===g?
+Jg:g,onShellReady:void 0===h?Jg:h,onShellError:void 0===k?Jg:k,onFatalError:void 0===m?Jg:m,formState:void 0===t?null:t};c=Lg(b,0,null,d,!1,!1);c.parentFlushed=!0;a=Mg(b,null,a,-1,null,c,z,null,d,Cf,null,Nf);r.push(a);return b}function Ng(a,b,c,d,e,f,g,h,k,m,p){a=Kg(a,b,c,d,e,f,g,h,k,m,p,void 0);a.trackedPostpones={workingMap:new Map,rootNodes:[],rootSlots:null};return a}
 function Og(a,b,c,d,e,f,g,h,k){Na.current=bb;var m=[],p=new Set;c={destination:null,flushScheduled:!1,resumableState:b.resumableState,renderState:c,rootFormatContext:b.rootFormatContext,progressiveChunkSize:b.progressiveChunkSize,status:0,fatalError:null,nextSegmentId:b.nextSegmentId,allPendingTasks:0,pendingRootTasks:0,completedRootSegment:null,abortableTasks:p,pingedTasks:m,clientRenderedBoundaries:[],completedBoundaries:[],partialBoundaries:[],trackedPostpones:null,onError:void 0===d?Ig:d,onPostpone:void 0===
 k?Jg:k,onAllReady:void 0===e?Jg:e,onShellReady:void 0===f?Jg:f,onShellError:void 0===g?Jg:g,onFatalError:void 0===h?Jg:h,formState:null};if("number"===typeof b.replaySlots)return d=b.replaySlots,e=Lg(c,0,null,b.rootFormatContext,!1,!1),e.id=d,e.parentFlushed=!0,a=Mg(c,null,a,-1,null,e,p,null,b.rootFormatContext,Cf,null,Nf),m.push(a),c;a=Pg(c,null,{nodes:b.replayNodes,slots:b.replaySlots,pendingTasks:0},a,-1,null,p,null,b.rootFormatContext,Cf,null,Nf);m.push(a);return c}var X=null;
 function Qg(a,b){a.pingedTasks.push(b);1===a.pingedTasks.length&&(a.flushScheduled=null!==a.destination,Rg(a))}function Sg(a,b){return{status:0,rootSegmentID:-1,parentFlushed:!1,pendingTasks:0,completedSegments:[],byteSize:0,fallbackAbortableTasks:b,errorDigest:null,resources:{styles:new Set,stylesheets:new Set},trackedContentKeyPath:null,trackedFallbackNode:null}}
-function Mg(a,b,c,d,e,f,g,h,k,m,p,t){a.allPendingTasks++;null===e?a.pendingRootTasks++:e.pendingTasks++;var q={replay:null,node:c,childIndex:d,ping:function(){return Qg(a,q)},blockedBoundary:e,blockedSegment:f,abortSet:g,keyPath:h,formatContext:k,legacyContext:m,context:p,treeContext:t,thenableState:b};g.add(q);return q}
-function Pg(a,b,c,d,e,f,g,h,k,m,p,t){a.allPendingTasks++;null===f?a.pendingRootTasks++:f.pendingTasks++;c.pendingTasks++;var q={replay:c,node:d,childIndex:e,ping:function(){return Qg(a,q)},blockedBoundary:f,blockedSegment:null,abortSet:g,keyPath:h,formatContext:k,legacyContext:m,context:p,treeContext:t,thenableState:b};g.add(q);return q}function Lg(a,b,c,d,e,f){return{status:0,id:-1,index:b,parentFlushed:!1,chunks:[],children:[],parentFormatContext:d,boundary:c,lastPushedText:e,textEmbedded:f}}
+function Mg(a,b,c,d,e,f,g,h,k,m,p,t){a.allPendingTasks++;null===e?a.pendingRootTasks++:e.pendingTasks++;var r={replay:null,node:c,childIndex:d,ping:function(){return Qg(a,r)},blockedBoundary:e,blockedSegment:f,abortSet:g,keyPath:h,formatContext:k,legacyContext:m,context:p,treeContext:t,thenableState:b};g.add(r);return r}
+function Pg(a,b,c,d,e,f,g,h,k,m,p,t){a.allPendingTasks++;null===f?a.pendingRootTasks++:f.pendingTasks++;c.pendingTasks++;var r={replay:c,node:d,childIndex:e,ping:function(){return Qg(a,r)},blockedBoundary:f,blockedSegment:null,abortSet:g,keyPath:h,formatContext:k,legacyContext:m,context:p,treeContext:t,thenableState:b};g.add(r);return r}function Lg(a,b,c,d,e,f){return{status:0,id:-1,index:b,parentFlushed:!1,chunks:[],children:[],parentFormatContext:d,boundary:c,lastPushedText:e,textEmbedded:f}}
 function Tg(a,b){a=a.onError(b);if(null!=a&&"string"!==typeof a)throw Error('onError returned something with a type other than "string". onError should return a string and may return null or undefined but must not return anything else. It received something of type "'+typeof a+'" instead');return a}function Ug(a,b){var c=a.onShellError;c(b);c=a.onFatalError;c(b);null!==a.destination?(a.status=2,la(a.destination,b)):(a.status=1,a.fatalError=b)}
 function Vg(a,b,c,d,e){var f=d.render(),g=e.childContextTypes;if(null!==g&&void 0!==g){c=b.legacyContext;if("function"!==typeof d.getChildContext)e=c;else{d=d.getChildContext();for(var h in d)if(!(h in g))throw Error(l(108,Bf(e)||"Unknown",h));e=B({},c,d)}b.legacyContext=e;Z(a,b,null,f,-1);b.legacyContext=c}else e=b.keyPath,b.keyPath=c,Z(a,b,null,f,-1),b.keyPath=e}
 function Wg(a,b,c,d,e,f,g){var h=!1;if(0!==f&&null!==a.formState){var k=b.blockedSegment;if(null!==k){h=!0;k=k.chunks;for(var m=0;m<f;m++)m===g?k.push(ic):k.push(jc)}}f=b.keyPath;b.keyPath=c;e?(c=b.treeContext,b.treeContext=Of(c,1,0),Xg(a,b,d,-1),b.treeContext=c):h?Xg(a,b,d,-1):Z(a,b,null,d,-1);b.keyPath=f}function Yg(a,b){if(a&&a.defaultProps){b=B({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}
 function Zg(a,b,c,d,e,f,g){if("function"===typeof e)if(e.prototype&&e.prototype.isReactComponent){d=Df(e,b.legacyContext);var h=e.contextType;h=new e(f,"object"===typeof h&&null!==h?h._currentValue:d);Mf(h,e,f,d);Vg(a,b,c,h,e)}else{h=Df(e,b.legacyContext);$f={};ag=b;bg=a;cg=c;hg=gg=0;ig=-1;jg=0;kg=d;d=e(f,h);d=qg(e,f,d,h);g=0!==gg;var k=hg,m=ig;"object"===typeof d&&null!==d&&"function"===typeof d.render&&void 0===d.$$typeof?(Mf(d,e,f,h),Vg(a,b,c,d,e)):Wg(a,b,c,d,g,k,m)}else if("string"===typeof e)if(d=
 b.blockedSegment,null===d)d=f.children,h=b.formatContext,g=b.keyPath,b.formatContext=Ob(h,e,f),b.keyPath=c,Xg(a,b,d,-1),b.formatContext=h,b.keyPath=g;else{g=Dc(d.chunks,e,f,a.resumableState,a.renderState,b.formatContext,d.lastPushedText);d.lastPushedText=!1;h=b.formatContext;k=b.keyPath;b.formatContext=Ob(h,e,f);b.keyPath=c;Xg(a,b,g,-1);b.formatContext=h;b.keyPath=k;a:{b=d.chunks;a=a.resumableState;switch(e){case "title":case "style":case "script":case "area":case "base":case "br":case "col":case "embed":case "hr":case "img":case "input":case "keygen":case "link":case "meta":case "param":case "source":case "track":case "wbr":break a;
 case "body":if(1>=h.insertionMode){a.hasBody=!0;break a}break;case "html":if(0===h.insertionMode){a.hasHtml=!0;break a}}b.push(oc(e))}d.lastPushedText=!1}else{switch(e){case uf:case sf:case gf:case hf:case ff:e=b.keyPath;b.keyPath=c;Z(a,b,null,f.children,-1);b.keyPath=e;return;case tf:"hidden"!==f.mode&&(e=b.keyPath,b.keyPath=c,Z(a,b,null,f.children,-1),b.keyPath=e);return;case of:e=b.keyPath;b.keyPath=c;Z(a,b,null,f.children,-1);b.keyPath=e;return;case rf:throw Error(l(343));case nf:a:if(null!==
-b.replay){e=b.keyPath;b.keyPath=c;c=f.children;try{Xg(a,b,c,-1)}finally{b.keyPath=e}}else{m=b.keyPath;e=b.blockedBoundary;var p=b.blockedSegment;d=f.fallback;var t=f.children;f=new Set;g=Sg(a,f);null!==a.trackedPostpones&&(g.trackedContentKeyPath=c);k=Lg(a,p.chunks.length,g,b.formatContext,!1,!1);p.children.push(k);p.lastPushedText=!1;var q=Lg(a,0,null,b.formatContext,!1,!1);q.parentFlushed=!0;b.blockedBoundary=g;b.blockedSegment=q;a.renderState.boundaryResources=g.resources;b.keyPath=c;try{if(Xg(a,
-b,t,-1),q.lastPushedText&&q.textEmbedded&&q.chunks.push(Pb),q.status=1,$g(g,q),0===g.pendingTasks&&0===g.status){g.status=1;break a}}catch(z){q.status=4,g.status=4,"object"===typeof z&&null!==z&&z.$$typeof===zf?(a.onPostpone(z.message),h="POSTPONE"):h=Tg(a,z),g.errorDigest=h}finally{a.renderState.boundaryResources=e?e.resources:null,b.blockedBoundary=e,b.blockedSegment=p,b.keyPath=m}h=[c[0],"Suspense Fallback",c[2]];m=a.trackedPostpones;null!==m&&(p=[h[1],h[2],[],null],m.workingMap.set(h,p),5===g.status?
+b.replay){e=b.keyPath;b.keyPath=c;c=f.children;try{Xg(a,b,c,-1)}finally{b.keyPath=e}}else{m=b.keyPath;e=b.blockedBoundary;var p=b.blockedSegment;d=f.fallback;var t=f.children;f=new Set;g=Sg(a,f);null!==a.trackedPostpones&&(g.trackedContentKeyPath=c);k=Lg(a,p.chunks.length,g,b.formatContext,!1,!1);p.children.push(k);p.lastPushedText=!1;var r=Lg(a,0,null,b.formatContext,!1,!1);r.parentFlushed=!0;b.blockedBoundary=g;b.blockedSegment=r;a.renderState.boundaryResources=g.resources;b.keyPath=c;try{if(Xg(a,
+b,t,-1),r.lastPushedText&&r.textEmbedded&&r.chunks.push(Pb),r.status=1,$g(g,r),0===g.pendingTasks&&0===g.status){g.status=1;break a}}catch(z){r.status=4,g.status=4,"object"===typeof z&&null!==z&&z.$$typeof===zf?(a.onPostpone(z.message),h="POSTPONE"):h=Tg(a,z),g.errorDigest=h}finally{a.renderState.boundaryResources=e?e.resources:null,b.blockedBoundary=e,b.blockedSegment=p,b.keyPath=m}h=[c[0],"Suspense Fallback",c[2]];m=a.trackedPostpones;null!==m&&(p=[h[1],h[2],[],null],m.workingMap.set(h,p),5===g.status?
 m.workingMap.get(c)[4]=p:g.trackedFallbackNode=p);b=Mg(a,null,d,-1,e,k,f,h,b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}return}if("object"===typeof e&&null!==e)switch(e.$$typeof){case mf:e=e.render;$f={};ag=b;bg=a;cg=c;hg=gg=0;ig=-1;jg=0;kg=d;d=e(f,g);f=qg(e,f,d,g);Wg(a,b,c,f,0!==gg,hg,ig);return;case pf:e=e.type;f=Yg(e,f);Zg(a,b,c,d,e,f,g);return;case jf:h=f.children;d=b.keyPath;e=e._context;f=f.value;g=e._currentValue;e._currentValue=f;k=Ef;Ef=f={parent:k,depth:null===
 k?0:k.depth+1,context:e,parentValue:g,value:f};b.context=f;b.keyPath=c;Z(a,b,null,h,-1);a=Ef;if(null===a)throw Error(l(403));c=a.parentValue;a.context._currentValue=c===xf?a.context._defaultValue:c;a=Ef=a.parent;b.context=a;b.keyPath=d;return;case kf:f=f.children;f=f(e._currentValue);e=b.keyPath;b.keyPath=c;Z(a,b,null,f,-1);b.keyPath=e;return;case qf:h=e._init;e=h(e._payload);f=Yg(e,f);Zg(a,b,c,d,e,f,void 0);return}throw Error(l(130,null==e?e:typeof e,""));}}
 function ah(a,b,c,d,e){var f=b.replay,g=b.blockedBoundary,h=Lg(a,0,null,b.formatContext,!1,!1);h.id=c;h.parentFlushed=!0;try{b.replay=null,b.blockedSegment=h,Xg(a,b,d,e),h.status=1,null===g?a.completedRootSegment=h:($g(g,h),g.parentFlushed&&a.partialBoundaries.push(g))}finally{b.replay=f,b.blockedSegment=null}}
-function Z(a,b,c,d,e){if(null!==b.replay&&"number"===typeof b.replay.slots)ah(a,b,b.replay.slots,d,e);else{b.node=d;b.childIndex=e;if("object"===typeof d&&null!==d){switch(d.$$typeof){case df:var f=d.type,g=d.key,h=d.props,k=d.ref,m=Bf(f),p=null==g?-1===e?0:e:g;g=[b.keyPath,m,p];if(null!==b.replay)a:{var t=b.replay;e=t.nodes;for(d=0;d<e.length;d++){var q=e[d];if(p===q[1]){if(4===q.length){if(null!==m&&m!==q[0])throw Error(l(490,q[0],m));m=q[2];q=q[3];p=b.node;b.replay={nodes:m,slots:q,pendingTasks:1};
-try{Zg(a,b,g,c,f,h,k);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error(l(488));b.replay.pendingTasks--}catch(F){if("object"===typeof F&&null!==F&&(F===Tf||"function"===typeof F.then))throw b.node===p&&(b.replay=t),F;b.replay.pendingTasks--;bh(a,b.blockedBoundary,F,m,q)}b.replay=t}else{if(f!==nf)throw Error(l(490,"Suspense",Bf(f)||"Unknown"));b:{c=void 0;f=q[5];k=q[2];t=q[3];m=null===q[4]?[]:q[4][2];q=null===q[4]?null:q[4][3];p=b.keyPath;var z=b.replay,D=b.blockedBoundary,aa=h.children;
+function Z(a,b,c,d,e){if(null!==b.replay&&"number"===typeof b.replay.slots)ah(a,b,b.replay.slots,d,e);else{b.node=d;b.childIndex=e;if("object"===typeof d&&null!==d){switch(d.$$typeof){case df:var f=d.type,g=d.key,h=d.props,k=d.ref,m=Bf(f),p=null==g?-1===e?0:e:g;g=[b.keyPath,m,p];if(null!==b.replay)a:{var t=b.replay;e=t.nodes;for(d=0;d<e.length;d++){var r=e[d];if(p===r[1]){if(4===r.length){if(null!==m&&m!==r[0])throw Error(l(490,r[0],m));m=r[2];r=r[3];p=b.node;b.replay={nodes:m,slots:r,pendingTasks:1};
+try{Zg(a,b,g,c,f,h,k);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error(l(488));b.replay.pendingTasks--}catch(F){if("object"===typeof F&&null!==F&&(F===Tf||"function"===typeof F.then))throw b.node===p&&(b.replay=t),F;b.replay.pendingTasks--;bh(a,b.blockedBoundary,F,m,r)}b.replay=t}else{if(f!==nf)throw Error(l(490,"Suspense",Bf(f)||"Unknown"));b:{c=void 0;f=r[5];k=r[2];t=r[3];m=null===r[4]?[]:r[4][2];r=null===r[4]?null:r[4][3];p=b.keyPath;var z=b.replay,D=b.blockedBoundary,aa=h.children;
 h=h.fallback;var u=new Set,C=Sg(a,u);C.parentFlushed=!0;C.rootSegmentID=f;b.blockedBoundary=C;b.replay={nodes:k,slots:t,pendingTasks:1};a.renderState.boundaryResources=C.resources;try{Xg(a,b,aa,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error(l(488));b.replay.pendingTasks--;if(0===C.pendingTasks&&0===C.status){C.status=1;a.completedBoundaries.push(C);break b}}catch(F){C.status=4,"object"===typeof F&&null!==F&&F.$$typeof===zf?(a.onPostpone(F.message),c="POSTPONE"):c=Tg(a,F),C.errorDigest=
-c,b.replay.pendingTasks--,a.clientRenderedBoundaries.push(C)}finally{a.renderState.boundaryResources=D?D.resources:null,b.blockedBoundary=D,b.replay=z,b.keyPath=p}h=Pg(a,null,{nodes:m,slots:q,pendingTasks:0},h,-1,D,u,[g[0],"Suspense Fallback",g[2]],b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(h)}}e.splice(d,1);break a}}}else Zg(a,b,g,c,f,h,k);return;case ef:throw Error(l(257));case qf:h=d._init;d=h(d._payload);Z(a,b,null,d,e);return}if(Ka(d)){ch(a,b,d,e);return}null===
+c,b.replay.pendingTasks--,a.clientRenderedBoundaries.push(C)}finally{a.renderState.boundaryResources=D?D.resources:null,b.blockedBoundary=D,b.replay=z,b.keyPath=p}h=Pg(a,null,{nodes:m,slots:r,pendingTasks:0},h,-1,D,u,[g[0],"Suspense Fallback",g[2]],b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(h)}}e.splice(d,1);break a}}}else Zg(a,b,g,c,f,h,k);return;case ef:throw Error(l(257));case qf:h=d._init;d=h(d._payload);Z(a,b,null,d,e);return}if(Ka(d)){ch(a,b,d,e);return}null===
 d||"object"!==typeof d?h=null:(h=Af&&d[Af]||d["@@iterator"],h="function"===typeof h?h:null);if(h&&(h=h.call(d))){d=h.next();if(!d.done){g=[];do g.push(d.value),d=h.next();while(!d.done);ch(a,b,g,e)}return}if("function"===typeof d.then)return Z(a,b,null,Ag(d),e);if(d.$$typeof===kf||d.$$typeof===lf)return Z(a,b,null,d._currentValue,e);e=Object.prototype.toString.call(d);throw Error(l(31,"[object Object]"===e?"object with keys {"+Object.keys(d).join(", ")+"}":e));}"string"===typeof d?(e=b.blockedSegment,
 null!==e&&(e.lastPushedText=Qb(e.chunks,d,a.renderState,e.lastPushedText))):"number"===typeof d&&(e=b.blockedSegment,null!==e&&(e.lastPushedText=Qb(e.chunks,""+d,a.renderState,e.lastPushedText)))}}
 function ch(a,b,c,d){var e=b.keyPath;if(-1!==d&&(b.keyPath=[b.keyPath,"Fragment",d],null!==b.replay)){for(var f=b.replay,g=f.nodes,h=0;h<g.length;h++){var k=g[h];if(k[1]===d){d=k[2];k=k[3];b.replay={nodes:d,slots:k,pendingTasks:1};try{ch(a,b,c,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error(l(488));b.replay.pendingTasks--}catch(p){if("object"===typeof p&&null!==p&&(p===Tf||"function"===typeof p.then))throw p;b.replay.pendingTasks--;bh(a,b.blockedBoundary,p,d,k)}b.replay=f;g.splice(h,
@@ -177,8 +175,8 @@ function ch(a,b,c,d){var e=b.keyPath;if(-1!==d&&(b.keyPath=[b.keyPath,"Fragment"
 function dh(a,b,c,d){d.status=5;var e=c.keyPath,f=c.blockedBoundary;if(null===f)d.id=a.nextSegmentId++,b.rootSlots=d.id,null!==a.completedRootSegment&&(a.completedRootSegment.status=5);else{if(null!==f&&0===f.status){f.status=5;f.rootSegmentID=a.nextSegmentId++;var g=f.trackedContentKeyPath;if(null===g)throw Error(l(486));var h=f.trackedFallbackNode,k=[];if(g===e&&-1===c.childIndex){d.id=f.rootSegmentID;d=[g[1],g[2],k,f.rootSegmentID,h,f.rootSegmentID];b.workingMap.set(g,d);eh(d,g[0],b);return}var m=
 b.workingMap.get(g);void 0===m?(m=[g[1],g[2],k,null,h,f.rootSegmentID],b.workingMap.set(g,m),eh(m,g[0],b)):(g=m,g[4]=h,g[5]=f.rootSegmentID)}-1===d.id&&(d.id=d.parentFlushed&&null!==f?f.rootSegmentID:a.nextSegmentId++);if(-1===c.childIndex)null===e?b.rootSlots=d.id:(c=b.workingMap.get(e),void 0===c?(c=[e[1],e[2],[],d.id],eh(c,e[0],b)):c[3]=d.id);else{if(null===e)if(a=b.rootSlots,null===a)a=b.rootSlots={};else{if("number"===typeof a)throw Error(l(491));}else if(f=b.workingMap,g=f.get(e),void 0===g)a=
 {},g=[e[1],e[2],[],a],f.set(e,g),eh(g,e[0],b);else if(a=g[3],null===a)a=g[3]={};else if("number"===typeof a)throw Error(l(491));a[c.childIndex]=d.id}}}
-function Xg(a,b,c,d){var e=b.formatContext,f=b.legacyContext,g=b.context,h=b.keyPath,k=b.treeContext,m=b.blockedSegment;if(null===m)try{return Z(a,b,null,c,d)}catch(q){if(rg(),d=q===Tf?Xf():q,"object"===typeof d&&null!==d&&"function"===typeof d.then){c=d;d=sg();a=Pg(a,d,b.replay,b.node,b.childIndex,b.blockedBoundary,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Kf(g);return}}else{var p=
-m.children.length,t=m.chunks.length;try{return Z(a,b,null,c,d)}catch(q){if(rg(),m.children.length=p,m.chunks.length=t,d=q===Tf?Xf():q,"object"===typeof d&&null!==d){if("function"===typeof d.then){c=d;d=sg();m=b.blockedSegment;p=Lg(a,m.chunks.length,null,b.formatContext,m.lastPushedText,!0);m.children.push(p);m.lastPushedText=!1;a=Mg(a,d,b.node,b.childIndex,b.blockedBoundary,p,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=
+function Xg(a,b,c,d){var e=b.formatContext,f=b.legacyContext,g=b.context,h=b.keyPath,k=b.treeContext,m=b.blockedSegment;if(null===m)try{return Z(a,b,null,c,d)}catch(r){if(rg(),d=r===Tf?Xf():r,"object"===typeof d&&null!==d&&"function"===typeof d.then){c=d;d=sg();a=Pg(a,d,b.replay,b.node,b.childIndex,b.blockedBoundary,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Kf(g);return}}else{var p=
+m.children.length,t=m.chunks.length;try{return Z(a,b,null,c,d)}catch(r){if(rg(),m.children.length=p,m.chunks.length=t,d=r===Tf?Xf():r,"object"===typeof d&&null!==d){if("function"===typeof d.then){c=d;d=sg();m=b.blockedSegment;p=Lg(a,m.chunks.length,null,b.formatContext,m.lastPushedText,!0);m.children.push(p);m.lastPushedText=!1;a=Mg(a,d,b.node,b.childIndex,b.blockedBoundary,p,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=
 f;b.context=g;b.keyPath=h;b.treeContext=k;Kf(g);return}if(null!==a.trackedPostpones&&d.$$typeof===zf&&null!==b.blockedBoundary){c=a.trackedPostpones;a.onPostpone(d.message);d=b.blockedSegment;m=Lg(a,d.chunks.length,null,b.formatContext,d.lastPushedText,!0);d.children.push(m);d.lastPushedText=!1;dh(a,c,b,m);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Kf(g);return}}}}b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Kf(g);throw d;}
 function bh(a,b,c,d,e){if("object"===typeof c&&null!==c&&c.$$typeof===zf){a.onPostpone(c.message);var f="POSTPONE"}else f=Tg(a,c);fh(a,b,d,e,c,f)}function gh(a){var b=a.blockedBoundary;a=a.blockedSegment;null!==a&&(a.status=3,hh(this,b,a))}
 function fh(a,b,c,d,e,f){for(var g=0;g<c.length;g++){var h=c[g];if(4===h.length)fh(a,b,h[2],h[3],e,f);else{h=h[5];var k=a,m=f,p=Sg(k,new Set);p.parentFlushed=!0;p.rootSegmentID=h;p.status=4;p.errorDigest=m;p.parentFlushed&&k.clientRenderedBoundaries.push(p)}}c.length=0;if(null!==d){if(null===b)throw Error(l(487));4!==b.status&&(b.status=4,b.errorDigest=f,b.parentFlushed&&a.clientRenderedBoundaries.push(b));if("object"===typeof d)for(var t in d)delete d[t]}}
@@ -187,31 +185,33 @@ b,c)}),d.fallbackAbortableTasks.clear();b.allPendingTasks--;0===b.allPendingTask
 function $g(a,b){if(0===b.chunks.length&&1===b.children.length&&null===b.children[0].boundary){var c=b.children[0];c.id=b.id;c.parentFlushed=!0;1===c.status&&$g(a,c)}else a.completedSegments.push(b)}
 function hh(a,b,c){if(null===b){if(null!==c&&c.parentFlushed){if(null!==a.completedRootSegment)throw Error(l(389));a.completedRootSegment=c}a.pendingRootTasks--;0===a.pendingRootTasks&&jh(a)}else b.pendingTasks--,4!==b.status&&(0===b.pendingTasks?(0===b.status&&(b.status=1),null!==c&&c.parentFlushed&&1===c.status&&$g(b,c),b.parentFlushed&&a.completedBoundaries.push(b),1===b.status&&(b.fallbackAbortableTasks.forEach(gh,a),b.fallbackAbortableTasks.clear())):null!==c&&c.parentFlushed&&1===c.status&&
 ($g(b,c),1===b.completedSegments.length&&b.parentFlushed&&a.partialBoundaries.push(b)));a.allPendingTasks--;0===a.allPendingTasks&&kh(a)}
-function Rg(a){if(2!==a.status){var b=Ef,c=Gg.current;Gg.current=Eg;var d=Hg.current;Hg.current=Fg;var e=X;X=a;var f=Dg;Dg=a.resumableState;try{var g=a.pingedTasks,h;for(h=0;h<g.length;h++){var k=g[h],m=a,p=k.blockedBoundary;m.renderState.boundaryResources=p?p.resources:null;var t=k.blockedSegment;if(null===t){var q=m;if(0!==k.replay.pendingTasks){Kf(k.context);try{var z=k.thenableState;k.thenableState=null;Z(q,k,z,k.node,k.childIndex);if(1===k.replay.pendingTasks&&0<k.replay.nodes.length)throw Error(l(488));
-k.replay.pendingTasks--;k.abortSet.delete(k);hh(q,k.blockedBoundary,null)}catch(M){rg();var D=M===Tf?Xf():M;if("object"===typeof D&&null!==D&&"function"===typeof D.then){var aa=k.ping;D.then(aa,aa);k.thenableState=sg()}else k.replay.pendingTasks--,k.abortSet.delete(k),bh(q,k.blockedBoundary,D,k.replay.nodes,k.replay.slots),q.pendingRootTasks--,0===q.pendingRootTasks&&jh(q),q.allPendingTasks--,0===q.allPendingTasks&&kh(q)}finally{q.renderState.boundaryResources=null}}}else a:{q=void 0;var u=t;if(0===
+function Rg(a){if(2!==a.status){var b=Ef,c=Gg.current;Gg.current=Eg;var d=Hg.current;Hg.current=Fg;var e=X;X=a;var f=Dg;Dg=a.resumableState;try{var g=a.pingedTasks,h;for(h=0;h<g.length;h++){var k=g[h],m=a,p=k.blockedBoundary;m.renderState.boundaryResources=p?p.resources:null;var t=k.blockedSegment;if(null===t){var r=m;if(0!==k.replay.pendingTasks){Kf(k.context);try{var z=k.thenableState;k.thenableState=null;Z(r,k,z,k.node,k.childIndex);if(1===k.replay.pendingTasks&&0<k.replay.nodes.length)throw Error(l(488));
+k.replay.pendingTasks--;k.abortSet.delete(k);hh(r,k.blockedBoundary,null)}catch(M){rg();var D=M===Tf?Xf():M;if("object"===typeof D&&null!==D&&"function"===typeof D.then){var aa=k.ping;D.then(aa,aa);k.thenableState=sg()}else k.replay.pendingTasks--,k.abortSet.delete(k),bh(r,k.blockedBoundary,D,k.replay.nodes,k.replay.slots),r.pendingRootTasks--,0===r.pendingRootTasks&&jh(r),r.allPendingTasks--,0===r.allPendingTasks&&kh(r)}finally{r.renderState.boundaryResources=null}}}else a:{r=void 0;var u=t;if(0===
 u.status){Kf(k.context);var C=u.children.length,F=u.chunks.length;try{var ma=k.thenableState;k.thenableState=null;Z(m,k,ma,k.node,k.childIndex);u.lastPushedText&&u.textEmbedded&&u.chunks.push(Pb);k.abortSet.delete(k);u.status=1;hh(m,k.blockedBoundary,u)}catch(M){rg();u.children.length=C;u.chunks.length=F;var x=M===Tf?Xf():M;if("object"===typeof x&&null!==x){if("function"===typeof x.then){var T=k.ping;x.then(T,T);k.thenableState=sg();break a}if(null!==m.trackedPostpones&&x.$$typeof===zf){var G=m.trackedPostpones;
-k.abortSet.delete(k);m.onPostpone(x.message);dh(m,G,k,u);hh(m,k.blockedBoundary,u);break a}}k.abortSet.delete(k);u.status=4;var L=k.blockedBoundary;"object"===typeof x&&null!==x&&x.$$typeof===zf?(m.onPostpone(x.message),q="POSTPONE"):q=Tg(m,x);null===L?Ug(m,x):(L.pendingTasks--,4!==L.status&&(L.status=4,L.errorDigest=q,L.parentFlushed&&m.clientRenderedBoundaries.push(L)));m.allPendingTasks--;0===m.allPendingTasks&&kh(m)}finally{m.renderState.boundaryResources=null}}}}g.splice(0,h);null!==a.destination&&
+k.abortSet.delete(k);m.onPostpone(x.message);dh(m,G,k,u);hh(m,k.blockedBoundary,u);break a}}k.abortSet.delete(k);u.status=4;var L=k.blockedBoundary;"object"===typeof x&&null!==x&&x.$$typeof===zf?(m.onPostpone(x.message),r="POSTPONE"):r=Tg(m,x);null===L?Ug(m,x):(L.pendingTasks--,4!==L.status&&(L.status=4,L.errorDigest=r,L.parentFlushed&&m.clientRenderedBoundaries.push(L)));m.allPendingTasks--;0===m.allPendingTasks&&kh(m)}finally{m.renderState.boundaryResources=null}}}}g.splice(0,h);null!==a.destination&&
 lh(a,a.destination)}catch(M){Tg(a,M),Ug(a,M)}finally{Dg=f,Gg.current=c,Hg.current=d,c===Eg&&Kf(b),X=e}}}
 function mh(a,b,c){c.parentFlushed=!0;switch(c.status){case 0:c.id=a.nextSegmentId++;case 5:var d=c.id;c.lastPushedText=!1;c.textEmbedded=!1;a=a.renderState;v(b,Hc);v(b,a.placeholderPrefix);a=y(d.toString(16));v(b,a);return w(b,Ic);case 1:c.status=2;var e=!0;d=c.chunks;var f=0;c=c.children;for(var g=0;g<c.length;g++){for(e=c[g];f<e.index;f++)v(b,d[f]);e=nh(a,b,e)}for(;f<d.length-1;f++)v(b,d[f]);f<d.length&&(e=w(b,d[f]));return e;default:throw Error(l(390));}}
 function nh(a,b,c){var d=c.boundary;if(null===d)return mh(a,b,c);d.parentFlushed=!0;if(4===d.status)d=d.errorDigest,w(b,Mc),v(b,Oc),d&&(v(b,Qc),v(b,y(H(d))),v(b,Pc)),w(b,Rc),mh(a,b,c);else if(1!==d.status)0===d.status&&(d.rootSegmentID=a.nextSegmentId++),0<d.completedSegments.length&&a.partialBoundaries.push(d),Sc(b,a.renderState,d.rootSegmentID),mh(a,b,c);else if(d.byteSize>a.progressiveChunkSize)d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),Sc(b,a.renderState,d.rootSegmentID),
 mh(a,b,c);else{c=d.resources;var e=a.renderState.boundaryResources;e&&(c.styles.forEach(af,e),c.stylesheets.forEach(bf,e));w(b,Jc);d=d.completedSegments;if(1!==d.length)throw Error(l(391));nh(a,b,d[0])}return w(b,Nc)}function oh(a,b,c){nd(b,a.renderState,c.parentFormatContext,c.id);nh(a,b,c);return od(b,c.parentFormatContext)}
 function ph(a,b,c){a.renderState.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e<d.length;e++)qh(a,b,c,d[e]);d.length=0;Fe(b,c.resources,a.renderState);d=a.resumableState;a=a.renderState;e=c.rootSegmentID;c=c.resources;var f=a.stylesToHoist;a.stylesToHoist=!1;var g=0===d.streamingFormat;g?(v(b,a.startInlineScript),f?0===(d.instructions&2)?(d.instructions|=10,v(b,512<xd.byteLength?xd.slice():xd)):0===(d.instructions&8)?(d.instructions|=8,v(b,yd)):v(b,zd):0===(d.instructions&2)?(d.instructions|=
-2,v(b,vd)):v(b,wd)):f?v(b,ge):v(b,fe);d=y(e.toString(16));v(b,a.boundaryPrefix);v(b,d);g?v(b,Ad):v(b,he);v(b,a.segmentPrefix);v(b,d);f?g?(v(b,Bd),Ue(b,c)):(v(b,ie),Ve(b,c)):g&&v(b,de);d=g?w(b,ee):w(b,cb);return Gc(b,a)&&d}
+2,v(b,vd)):v(b,wd)):f?v(b,ge):v(b,fe);e=y(e.toString(16));v(b,a.boundaryPrefix);v(b,e);g?v(b,Ad):v(b,he);v(b,a.segmentPrefix);v(b,e);f?g?(v(b,Bd),Ue(b,c)):(v(b,ie),Ve(b,c)):g&&v(b,de);c=g?w(b,ee):w(b,cb);return Gc(b,a,d)&&c}
 function qh(a,b,c,d){if(2===d.status)return!0;var e=d.id;if(-1===e){if(-1===(d.id=c.rootSegmentID))throw Error(l(392));return oh(a,b,d)}if(e===c.rootSegmentID)return oh(a,b,d);oh(a,b,d);c=a.resumableState;a=a.renderState;(d=0===c.streamingFormat)?(v(b,a.startInlineScript),0===(c.instructions&1)?(c.instructions|=1,v(b,pd)):v(b,qd)):v(b,td);v(b,a.segmentPrefix);e=y(e.toString(16));v(b,e);d?v(b,rd):v(b,ud);v(b,a.placeholderPrefix);v(b,e);b=d?w(b,sd):w(b,cb);return b}
-function lh(a,b){n=new Uint8Array(512);r=0;try{var c,d=a.completedRootSegment;if(null!==d)if(5!==d.status&&0===a.pendingRootTasks){var e=a.renderState;if((0!==a.allPendingTasks||null!==a.trackedPostpones)&&e.externalRuntimeScript){var f=e.externalRuntimeScript,g=a.resumableState,h=f.src,k=f.chunks;g.scriptResources.hasOwnProperty(h)||(g.scriptResources[h]=null,e.scripts.add(k))}var m=e.htmlChunks,p=e.headChunks;f=0;if(m){for(f=0;f<m.length;f++)v(b,m[f]);if(p)for(f=0;f<p.length;f++)v(b,p[f]);else v(b,
-W("head")),v(b,V)}else if(p)for(f=0;f<p.length;f++)v(b,p[f]);var t=e.charsetChunks;for(f=0;f<t.length;f++)v(b,t[f]);t.length=0;e.preconnects.forEach(Ge,b);e.preconnects.clear();var q=e.preconnectChunks;for(f=0;f<q.length;f++)v(b,q[f]);q.length=0;e.fontPreloads.forEach(Ge,b);e.fontPreloads.clear();e.highImagePreloads.forEach(Ge,b);e.highImagePreloads.clear();e.styles.forEach(Ne,b);var z=e.importMapChunks;for(f=0;f<z.length;f++)v(b,z[f]);z.length=0;e.bootstrapScripts.forEach(Ge,b);e.scripts.forEach(Ge,
-b);e.scripts.clear();e.bulkPreloads.forEach(Ge,b);e.bulkPreloads.clear();var D=e.preloadChunks;for(f=0;f<D.length;f++)v(b,D[f]);D.length=0;var aa=e.hoistableChunks;for(f=0;f<aa.length;f++)v(b,aa[f]);aa.length=0;m&&null===p&&v(b,oc("head"));nh(a,b,d);a.completedRootSegment=null;Gc(b,a.renderState)}else return;var u=a.renderState;d=0;u.preconnects.forEach(Ge,b);u.preconnects.clear();var C=u.preconnectChunks;for(d=0;d<C.length;d++)v(b,C[d]);C.length=0;u.fontPreloads.forEach(Ge,b);u.fontPreloads.clear();
+function lh(a,b){n=new Uint8Array(512);q=0;try{var c,d=a.completedRootSegment;if(null!==d)if(5!==d.status&&0===a.pendingRootTasks){var e=a.renderState;if((0!==a.allPendingTasks||null!==a.trackedPostpones)&&e.externalRuntimeScript){var f=e.externalRuntimeScript,g=a.resumableState,h=f.src,k=f.chunks;g.scriptResources.hasOwnProperty(h)||(g.scriptResources[h]=null,e.scripts.add(k))}var m=e.htmlChunks,p=e.headChunks;f=0;if(m){for(f=0;f<m.length;f++)v(b,m[f]);if(p)for(f=0;f<p.length;f++)v(b,p[f]);else v(b,
+W("head")),v(b,V)}else if(p)for(f=0;f<p.length;f++)v(b,p[f]);var t=e.charsetChunks;for(f=0;f<t.length;f++)v(b,t[f]);t.length=0;e.preconnects.forEach(Ge,b);e.preconnects.clear();var r=e.preconnectChunks;for(f=0;f<r.length;f++)v(b,r[f]);r.length=0;e.fontPreloads.forEach(Ge,b);e.fontPreloads.clear();e.highImagePreloads.forEach(Ge,b);e.highImagePreloads.clear();e.styles.forEach(Ne,b);var z=e.importMapChunks;for(f=0;f<z.length;f++)v(b,z[f]);z.length=0;e.bootstrapScripts.forEach(Ge,b);e.scripts.forEach(Ge,
+b);e.scripts.clear();e.bulkPreloads.forEach(Ge,b);e.bulkPreloads.clear();var D=e.preloadChunks;for(f=0;f<D.length;f++)v(b,D[f]);D.length=0;var aa=e.hoistableChunks;for(f=0;f<aa.length;f++)v(b,aa[f]);aa.length=0;m&&null===p&&v(b,oc("head"));nh(a,b,d);a.completedRootSegment=null;Gc(b,a.renderState,a.resumableState)}else return;var u=a.renderState;d=0;u.preconnects.forEach(Ge,b);u.preconnects.clear();var C=u.preconnectChunks;for(d=0;d<C.length;d++)v(b,C[d]);C.length=0;u.fontPreloads.forEach(Ge,b);u.fontPreloads.clear();
 u.highImagePreloads.forEach(Ge,b);u.highImagePreloads.clear();u.styles.forEach(Pe,b);u.scripts.forEach(Ge,b);u.scripts.clear();u.bulkPreloads.forEach(Ge,b);u.bulkPreloads.clear();var F=u.preloadChunks;for(d=0;d<F.length;d++)v(b,F[d]);F.length=0;var ma=u.hoistableChunks;for(d=0;d<ma.length;d++)v(b,ma[d]);ma.length=0;var x=a.clientRenderedBoundaries;for(c=0;c<x.length;c++){var T=x[c];u=b;var G=a.resumableState,L=a.renderState,M=T.rootSegmentID,Pa=T.errorDigest,Ba=T.errorMessage,sa=T.errorComponentStack,
 na=0===G.streamingFormat;na?(v(u,L.startInlineScript),0===(G.instructions&4)?(G.instructions|=4,v(u,je)):v(u,ke)):v(u,oe);v(u,L.boundaryPrefix);v(u,y(M.toString(16)));na&&v(u,le);if(Pa||Ba||sa)na?(v(u,me),v(u,y(te(Pa||"")))):(v(u,pe),v(u,y(H(Pa||""))));if(Ba||sa)na?(v(u,me),v(u,y(te(Ba||"")))):(v(u,qe),v(u,y(H(Ba||""))));sa&&(na?(v(u,me),v(u,y(te(sa)))):(v(u,re),v(u,y(H(sa)))));if(na?!w(u,ne):!w(u,cb)){a.destination=null;c++;x.splice(0,c);return}}x.splice(0,c);var Ca=a.completedBoundaries;for(c=0;c<
-Ca.length;c++)if(!ph(a,b,Ca[c])){a.destination=null;c++;Ca.splice(0,c);return}Ca.splice(0,c);ja(b);n=new Uint8Array(512);r=0;var ta=a.partialBoundaries;for(c=0;c<ta.length;c++){var ua=ta[c];a:{x=a;T=b;x.renderState.boundaryResources=ua.resources;var va=ua.completedSegments;for(G=0;G<va.length;G++)if(!qh(x,T,ua,va[G])){G++;va.splice(0,G);var Qa=!1;break a}va.splice(0,G);Qa=Fe(T,ua.resources,x.renderState)}if(!Qa){a.destination=null;c++;ta.splice(0,c);return}}ta.splice(0,c);var ha=a.completedBoundaries;
+Ca.length;c++)if(!ph(a,b,Ca[c])){a.destination=null;c++;Ca.splice(0,c);return}Ca.splice(0,c);ja(b);n=new Uint8Array(512);q=0;var ta=a.partialBoundaries;for(c=0;c<ta.length;c++){var ua=ta[c];a:{x=a;T=b;x.renderState.boundaryResources=ua.resources;var va=ua.completedSegments;for(G=0;G<va.length;G++)if(!qh(x,T,ua,va[G])){G++;va.splice(0,G);var Qa=!1;break a}va.splice(0,G);Qa=Fe(T,ua.resources,x.renderState)}if(!Qa){a.destination=null;c++;ta.splice(0,c);return}}ta.splice(0,c);var ha=a.completedBoundaries;
 for(c=0;c<ha.length;c++)if(!ph(a,b,ha[c])){a.destination=null;c++;ha.splice(0,c);return}ha.splice(0,c)}finally{0===a.allPendingTasks&&0===a.pingedTasks.length&&0===a.clientRenderedBoundaries.length&&0===a.completedBoundaries.length?(a.flushScheduled=!1,null===a.trackedPostpones&&(c=a.resumableState,c.hasBody&&v(b,oc("body")),c.hasHtml&&v(b,oc("html"))),ja(b),b.close(),a.destination=null):ja(b)}}
 function rh(a){a.flushScheduled=null!==a.destination;Rg(a);null===a.trackedPostpones&&cf(a.renderState,a.resumableState,0===a.pendingRootTasks)}function Ye(a){if(!1===a.flushScheduled&&0===a.pingedTasks.length&&null!==a.destination){a.flushScheduled=!0;var b=a.destination;b?lh(a,b):a.flushScheduled=!1}}function sh(a,b){if(1===a.status)a.status=2,la(b,a.fatalError);else if(2!==a.status&&null===a.destination){a.destination=b;try{lh(a,b)}catch(c){Tg(a,c),Ug(a,c)}}}
 function th(a,b){try{var c=a.abortableTasks;if(0<c.size){var d=void 0===b?Error(l(432)):b;c.forEach(function(e){return ih(e,a,d)});c.clear()}null!==a.destination&&lh(a,a.destination)}catch(e){Tg(a,e),Ug(a,e)}}function eh(a,b,c){if(null===b)c.rootNodes.push(a);else{var d=c.workingMap,e=d.get(b);void 0===e&&(e=[b[1],b[2],[],null],d.set(b,e),eh(e,b[0],c));e[2].push(a)}}
 function uh(a){var b=a.trackedPostpones;if(null===b||0===b.rootNodes.length&&null===b.rootSlots)return a.trackedPostpones=null;if(null!==a.completedRootSegment&&5===a.completedRootSegment.status){var c=a.resumableState,d=a.renderState;c.nextFormID=0;c.hasBody=!1;c.hasHtml=!1;c.unknownResources={font:d.resets.font};c.dnsResources=d.resets.dns;c.connectResources=d.resets.connect;c.imageResources=d.resets.image;c.styleResources=d.resets.style;c.scriptResources={};c.moduleUnknownResources={};c.moduleScriptResources=
 {}}return{nextSegmentId:a.nextSegmentId,rootFormatContext:a.rootFormatContext,progressiveChunkSize:a.progressiveChunkSize,resumableState:a.resumableState,replayNodes:b.rootNodes,replaySlots:b.rootSlots}}
-exports.prerender=function(a,b){return new Promise(function(c,d){var e=b?b.onHeaders:void 0,f;e&&(f=function(p){e(new Headers(p))});var g=Mb(b?b.identifierPrefix:void 0,b?b.unstable_externalRuntimeSrc:void 0),h=Ng(a,g,Kb(g,void 0,b?b.bootstrapScriptContent:void 0,b?b.bootstrapScripts:void 0,b?b.bootstrapModules:void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.importMap:void 0,f,b?b.maxHeadersLength:void 0),Nb(b?b.namespaceURI:void 0),b?b.progressiveChunkSize:void 0,b?b.onError:void 0,function(){var p=
+exports.prerender=function(a,b){return new Promise(function(c,d){var e=b?b.onHeaders:void 0,f;e&&(f=function(p){e(new Headers(p))});var g=Mb(b?b.identifierPrefix:void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.bootstrapScriptContent:void 0,b?b.bootstrapScripts:void 0,b?b.bootstrapModules:void 0),h=Ng(a,g,Kb(g,void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.importMap:void 0,f,b?b.maxHeadersLength:void 0),Nb(b?b.namespaceURI:void 0),b?b.progressiveChunkSize:void 0,b?b.onError:void 0,function(){var p=
 new ReadableStream({type:"bytes",pull:function(t){sh(h,t)},cancel:function(t){h.destination=null;th(h,t)}},{highWaterMark:0});p={postponed:uh(h),prelude:p};c(p)},void 0,void 0,d,b?b.onPostpone:void 0);if(b&&b.signal){var k=b.signal;if(k.aborted)th(h,k.reason);else{var m=function(){th(h,k.reason);k.removeEventListener("abort",m)};k.addEventListener("abort",m)}}rh(h)})};
-exports.renderToReadableStream=function(a,b){return new Promise(function(c,d){var e,f,g=new Promise(function(z,D){f=z;e=D}),h=b?b.onHeaders:void 0,k;h&&(k=function(z){h(new Headers(z))});var m=Mb(b?b.identifierPrefix:void 0,b?b.unstable_externalRuntimeSrc:void 0),p=Kg(a,m,Kb(m,b?b.nonce:void 0,b?b.bootstrapScriptContent:void 0,b?b.bootstrapScripts:void 0,b?b.bootstrapModules:void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.importMap:void 0,k,b?b.maxHeadersLength:void 0),Nb(b?b.namespaceURI:void 0),
-b?b.progressiveChunkSize:void 0,b?b.onError:void 0,f,function(){var z=new ReadableStream({type:"bytes",pull:function(D){sh(p,D)},cancel:function(D){p.destination=null;th(p,D)}},{highWaterMark:0});z.allReady=g;c(z)},function(z){g.catch(function(){});d(z)},e,b?b.onPostpone:void 0,b?b.formState:void 0);if(b&&b.signal){var t=b.signal;if(t.aborted)th(p,t.reason);else{var q=function(){th(p,t.reason);t.removeEventListener("abort",q)};t.addEventListener("abort",q)}}rh(p)})};
-exports.resume=function(a,b,c){return new Promise(function(d,e){var f,g,h=new Promise(function(t,q){g=t;f=q}),k=Og(a,b,Kb(b.resumableState,c?c.nonce:void 0,void 0,void 0,void 0,void 0,void 0,void 0),c?c.onError:void 0,g,function(){var t=new ReadableStream({type:"bytes",pull:function(q){sh(k,q)},cancel:function(q){k.destination=null;th(k,q)}},{highWaterMark:0});t.allReady=h;d(t)},function(t){h.catch(function(){});e(t)},f,c?c.onPostpone:void 0);if(c&&c.signal){var m=c.signal;if(m.aborted)th(k,m.reason);
-else{var p=function(){th(k,m.reason);m.removeEventListener("abort",p)};m.addEventListener("abort",p)}}rh(k)})};exports.version="18.3.0-experimental-2983249dd-20231107";
+exports.renderToReadableStream=function(a,b){return new Promise(function(c,d){var e,f,g=new Promise(function(z,D){f=z;e=D}),h=b?b.onHeaders:void 0,k;h&&(k=function(z){h(new Headers(z))});var m=Mb(b?b.identifierPrefix:void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.bootstrapScriptContent:void 0,b?b.bootstrapScripts:void 0,b?b.bootstrapModules:void 0),p=Kg(a,m,Kb(m,b?b.nonce:void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.importMap:void 0,k,b?b.maxHeadersLength:void 0),Nb(b?b.namespaceURI:void 0),
+b?b.progressiveChunkSize:void 0,b?b.onError:void 0,f,function(){var z=new ReadableStream({type:"bytes",pull:function(D){sh(p,D)},cancel:function(D){p.destination=null;th(p,D)}},{highWaterMark:0});z.allReady=g;c(z)},function(z){g.catch(function(){});d(z)},e,b?b.onPostpone:void 0,b?b.formState:void 0);if(b&&b.signal){var t=b.signal;if(t.aborted)th(p,t.reason);else{var r=function(){th(p,t.reason);t.removeEventListener("abort",r)};t.addEventListener("abort",r)}}rh(p)})};
+exports.resume=function(a,b,c){return new Promise(function(d,e){var f,g,h=new Promise(function(t,r){g=t;f=r}),k=Og(a,b,Kb(b.resumableState,c?c.nonce:void 0,void 0,void 0,void 0,void 0),c?c.onError:void 0,g,function(){var t=new ReadableStream({type:"bytes",pull:function(r){sh(k,r)},cancel:function(r){k.destination=null;th(k,r)}},{highWaterMark:0});t.allReady=h;d(t)},function(t){h.catch(function(){});e(t)},f,c?c.onPostpone:void 0);if(c&&c.signal){var m=c.signal;if(m.aborted)th(k,m.reason);else{var p=
+function(){th(k,m.reason);m.removeEventListener("abort",p)};m.addEventListener("abort",p)}}rh(k)})};exports.version="18.3.0-experimental-7508dcd5c-20231108";
+
+//# sourceMappingURL=react-dom-server.browser.production.min.js.map
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.bun.production.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.bun.production.js
new file mode 100644
index 0000000000000..0edd2406e76d0
--- /dev/null
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.bun.production.js
@@ -0,0 +1,8730 @@
+/**
+* @license React
+ * react-dom-server.bun.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+var React = require("next/dist/compiled/react-experimental");
+var ReactDOM = require('react-dom');
+
+var ReactVersion = '18.3.0-experimental-7508dcd5c-20231108';
+
+/* global Bun */
+function scheduleWork(callback) {
+  callback();
+}
+function beginWriting(destination) {}
+function writeChunk(destination, chunk) {
+  if (chunk.length === 0) {
+    return;
+  }
+
+  destination.write(chunk);
+}
+function writeChunkAndReturn(destination, chunk) {
+  return !!destination.write(chunk);
+}
+function completeWriting(destination) {}
+function close(destination) {
+  destination.end();
+}
+function stringToChunk(content) {
+  return content;
+}
+function stringToPrecomputedChunk(content) {
+  return content;
+}
+function clonePrecomputedChunk(chunk) {
+  return chunk;
+}
+function closeWithError(destination, error) {
+  if (typeof destination.error === 'function') {
+    // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+    destination.error(error);
+  } else {
+    // Earlier implementations doesn't support this method. In that environment you're
+    // supposed to throw from a promise returned but we don't return a promise in our
+    // approach. We could fork this implementation but this is environment is an edge
+    // case to begin with. It's even less common to run this in an older environment.
+    // Even then, this is not where errors are supposed to happen and they get reported
+    // to a global callback in addition to this anyway. So it's fine just to close this.
+    destination.close();
+  }
+}
+function createFastHash(input) {
+  return Bun.hash(input);
+}
+
+const assign = Object.assign;
+
+// -----------------------------------------------------------------------------
+const enableFloat = true; // Enables unstable_useMemoCache hook, intended as a compilation target for
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/* eslint-disable max-len */
+
+const ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
+/* eslint-enable max-len */
+
+const ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
+const VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+const illegalAttributeNameCache = {};
+const validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+  if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+    return true;
+  }
+
+  if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+    return false;
+  }
+
+  if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+    validatedAttributeNameCache[attributeName] = true;
+    return true;
+  }
+
+  illegalAttributeNameCache[attributeName] = true;
+
+  return false;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+const unitlessNumbers = new Set(['animationIterationCount', 'aspectRatio', 'borderImageOutset', 'borderImageSlice', 'borderImageWidth', 'boxFlex', 'boxFlexGroup', 'boxOrdinalGroup', 'columnCount', 'columns', 'flex', 'flexGrow', 'flexPositive', 'flexShrink', 'flexNegative', 'flexOrder', 'gridArea', 'gridRow', 'gridRowEnd', 'gridRowSpan', 'gridRowStart', 'gridColumn', 'gridColumnEnd', 'gridColumnSpan', 'gridColumnStart', 'fontWeight', 'lineClamp', 'lineHeight', 'opacity', 'order', 'orphans', 'scale', 'tabSize', 'widows', 'zIndex', 'zoom', 'fillOpacity', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'MozBoxFlexGroup', 'MozLineClamp', 'msAnimationIterationCount', 'msFlex', 'msZoom', 'msFlexGrow', 'msFlexNegative', 'msFlexOrder', 'msFlexPositive', 'msFlexShrink', 'msGridColumn', 'msGridColumnSpan', 'msGridRow', 'msGridRowSpan', 'WebkitAnimationIterationCount', 'WebkitBoxFlex', 'WebKitBoxFlexGroup', 'WebkitBoxOrdinalGroup', 'WebkitColumnCount', 'WebkitColumns', 'WebkitFlex', 'WebkitFlexGrow', 'WebkitFlexPositive', 'WebkitFlexShrink', 'WebkitLineClamp']);
+function isUnitlessNumber (name) {
+  return unitlessNumbers.has(name);
+}
+
+const aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+  return aliases.get(name) || name;
+}
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// code copied and modified from escape-html
+const matchHtmlRegExp = /["'&<>]/;
+/**
+ * Escapes special characters and HTML entities in a given html string.
+ *
+ * @param  {string} string HTML string to escape for later insertion
+ * @return {string}
+ * @public
+ */
+
+function escapeHtml(string) {
+
+  const str = '' + string;
+  const match = matchHtmlRegExp.exec(str);
+
+  if (!match) {
+    return str;
+  }
+
+  let escape;
+  let html = '';
+  let index;
+  let lastIndex = 0;
+
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        // "
+        escape = '&quot;';
+        break;
+
+      case 38:
+        // &
+        escape = '&amp;';
+        break;
+
+      case 39:
+        // '
+        escape = '&#x27;'; // modified from escape-html; used to be '&#39'
+
+        break;
+
+      case 60:
+        // <
+        escape = '&lt;';
+        break;
+
+      case 62:
+        // >
+        escape = '&gt;';
+        break;
+
+      default:
+        continue;
+    }
+
+    if (lastIndex !== index) {
+      html += str.slice(lastIndex, index);
+    }
+
+    lastIndex = index + 1;
+    html += escape;
+  }
+
+  return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+} // end code copied and modified from escape-html
+
+/**
+ * Escapes text to prevent scripting attacks.
+ *
+ * @param {*} text Text value to escape.
+ * @return {string} An escaped string.
+ */
+
+
+function escapeTextForBrowser(text) {
+  if (typeof text === 'boolean' || typeof text === 'number') {
+    // this shortcircuit helps perf for types that we know will never have
+    // special characters, especially given that this function is used often
+    // for numeric dom ids.
+    return '' + text;
+  }
+
+  return escapeHtml(text);
+}
+
+const uppercasePattern = /([A-Z])/g;
+const msPattern = /^ms-/;
+/**
+ * Hyphenates a camelcased CSS property name, for example:
+ *
+ *   > hyphenateStyleName('backgroundColor')
+ *   < "background-color"
+ *   > hyphenateStyleName('MozTransition')
+ *   < "-moz-transition"
+ *   > hyphenateStyleName('msTransition')
+ *   < "-ms-transition"
+ *
+ * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
+ * is converted to `-ms-`.
+ */
+
+function hyphenateStyleName(name) {
+  return name.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern, '-ms-');
+}
+
+function sanitizeURL(url) {
+
+  return url;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+// The build script is at scripts/rollup/generate-inline-fizz-runtime.js.
+// Run `yarn generate-inline-fizz-runtime` to generate.
+const clientRenderBoundary = '$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};';
+const completeBoundary = '$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};';
+const completeBoundaryWithStyles = '$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};';
+const completeSegment = '$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};';
+const formReplaying = 'addEventListener("submit",function(a){if(!a.defaultPrevented){var c=a.target,d=a.submitter,e=c.action,b=d;if(d){var f=d.getAttribute("formAction");null!=f&&(e=f,b=null)}"javascript:throw new Error(\'A React form was unexpectedly submitted.\')"===e&&(a.preventDefault(),b?(a=document.createElement("input"),a.name=b.name,a.value=b.value,b.parentNode.insertBefore(a,b),b=new FormData(c),a.parentNode.removeChild(a)):b=new FormData(c),a=c.getRootNode(),(a.$$reactFormReplay=a.$$reactFormReplay||[]).push(c,\nd,b))}});';
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+// same object across all transitions.
+
+const sharedNotPendingObject = {
+  pending: false,
+  data: null,
+  method: null,
+  action: null
+};
+const NotPending = sharedNotPendingObject;
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+const ReactDOMServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMServerDispatcher;
+} // We make every property of the descriptor optional because it is not a contract that
+const ScriptStreamingFormat = 0;
+const DataStreamingFormat = 1;
+const NothingSent
+/*                      */
+= 0b00000;
+const SentCompleteSegmentFunction
+/*      */
+= 0b00001;
+const SentCompleteBoundaryFunction
+/*     */
+= 0b00010;
+const SentClientRenderFunction
+/*         */
+= 0b00100;
+const SentStyleInsertionFunction
+/*       */
+= 0b01000;
+const SentFormReplayingRuntime
+/*         */
+= 0b10000; // Per request, global state that is not contextual to the rendering subtree.
+// This cannot be resumed and therefore should only contain things that are
+// temporary working state or are never used in the prerender pass.
+// Credentials here are things that affect whether a browser will make a request
+// as well as things that affect which connection the browser will use for that request.
+// We want these to be aligned across preloads and resources because otherwise the preload
+// will be wasted.
+// We investigated whether referrerPolicy should be included here but from experimentation
+// it seems that browsers do not treat this as part of the http cache key and does not affect
+// which connection is used.
+
+const EXISTS = null; // This constant is to mark preloads that have no unique credentials
+// to convey. It should never be checked by identity and we should not
+// assume Preload values in ResumableState equal this value because they
+// will have come from some parsed input.
+
+const PRELOAD_NO_CREDS = [];
+// This is resumable and therefore should be serializable.
+
+
+const dataElementQuotedEnd = stringToPrecomputedChunk('"></template>');
+const startInlineScript = stringToPrecomputedChunk('<script>');
+const endInlineScript = stringToPrecomputedChunk('</script>');
+const startScriptSrc = stringToPrecomputedChunk('<script src="');
+const startModuleSrc = stringToPrecomputedChunk('<script type="module" src="');
+const scriptNonce = stringToPrecomputedChunk('" nonce="');
+const scriptIntegirty = stringToPrecomputedChunk('" integrity="');
+const scriptCrossOrigin = stringToPrecomputedChunk('" crossorigin="');
+const endAsyncScript = stringToPrecomputedChunk('" async=""></script>');
+/**
+ * This escaping function is designed to work with bootstrapScriptContent and importMap only.
+ * because we know we are escaping the entire script. We can avoid for instance
+ * escaping html comment string sequences that are valid javascript as well because
+ * if there are no sebsequent <script sequences the html parser will never enter
+ * script data double escaped state (see: https://www.w3.org/TR/html53/syntax.html#script-data-double-escaped-state)
+ *
+ * While untrusted script content should be made safe before using this api it will
+ * ensure that the script cannot be early terminated or never terminated state
+ */
+
+function escapeBootstrapAndImportMapScriptContent(scriptText) {
+
+  return ('' + scriptText).replace(scriptRegex, scriptReplacer);
+}
+
+const scriptRegex = /(<\/|<)(s)(cript)/gi;
+
+const scriptReplacer = (match, prefix, s, suffix) => "" + prefix + (s === 's' ? '\\u0073' : '\\u0053') + suffix;
+
+const importMapScriptStart = stringToPrecomputedChunk('<script type="importmap">');
+const importMapScriptEnd = stringToPrecomputedChunk('</script>'); // Since we store headers as strings we deal with their length in utf16 code units
+// rather than visual characters or the utf8 encoding that is used for most binary
+// serialization. Some common HTTP servers only allow for headers to be 4kB in length.
+// We choose a default length that is likely to be well under this already limited length however
+// pathological cases may still cause the utf-8 encoding of the headers to approach this limit.
+// It should also be noted that this maximum is a soft maximum. we have not reached the limit we will
+// allow one more header to be captured which means in practice if the limit is approached it will be exceeded
+
+const DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS = 2000; // Allows us to keep track of what we've already written so we can refer back to it.
+// if passed externalRuntimeConfig and the enableFizzExternalRuntime feature flag
+// is set, the server will send instructions via data attributes (instead of inline scripts)
+
+function createRenderState(resumableState, nonce, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
+  const inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
+  const idPrefix = resumableState.idPrefix;
+  const bootstrapChunks = [];
+  let externalRuntimeScript = null;
+  const bootstrapScriptContent = resumableState.bootstrapScriptContent,
+        bootstrapScripts = resumableState.bootstrapScripts,
+        bootstrapModules = resumableState.bootstrapModules;
+
+  if (bootstrapScriptContent !== undefined) {
+    bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapAndImportMapScriptContent(bootstrapScriptContent)), endInlineScript);
+  }
+
+  {
+
+    if (externalRuntimeConfig !== undefined) {
+      if (typeof externalRuntimeConfig === 'string') {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig,
+          async: true,
+          integrity: undefined,
+          nonce: nonce
+        });
+      } else {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig.src,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig.src,
+          async: true,
+          integrity: externalRuntimeConfig.integrity,
+          nonce: nonce
+        });
+      }
+    }
+  }
+
+  const importMapChunks = [];
+
+  if (importMap !== undefined) {
+    const map = importMap;
+    importMapChunks.push(importMapScriptStart);
+    importMapChunks.push(stringToChunk(escapeBootstrapAndImportMapScriptContent(JSON.stringify(map))));
+    importMapChunks.push(importMapScriptEnd);
+  }
+
+  const headers = onHeaders ? {
+    preconnects: '',
+    fontPreloads: '',
+    highImagePreloads: '',
+    remainingCapacity: typeof maxHeadersLength === 'number' ? maxHeadersLength : DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS
+  } : null;
+  const renderState = {
+    placeholderPrefix: stringToPrecomputedChunk(idPrefix + 'P:'),
+    segmentPrefix: stringToPrecomputedChunk(idPrefix + 'S:'),
+    boundaryPrefix: stringToPrecomputedChunk(idPrefix + 'B:'),
+    startInlineScript: inlineScriptWithNonce,
+    htmlChunks: null,
+    headChunks: null,
+    externalRuntimeScript: externalRuntimeScript,
+    bootstrapChunks: bootstrapChunks,
+    onHeaders,
+    headers,
+    resets: {
+      font: {},
+      dns: {},
+      connect: {
+        default: {},
+        anonymous: {},
+        credentials: {}
+      },
+      image: {},
+      style: {}
+    },
+    charsetChunks: [],
+    preconnectChunks: [],
+    importMapChunks,
+    preloadChunks: [],
+    hoistableChunks: [],
+    // cleared on flush
+    preconnects: new Set(),
+    fontPreloads: new Set(),
+    highImagePreloads: new Set(),
+    // usedImagePreloads: new Set(),
+    styles: new Map(),
+    bootstrapScripts: new Set(),
+    scripts: new Set(),
+    bulkPreloads: new Set(),
+    preloads: {
+      images: new Map(),
+      stylesheets: new Map(),
+      scripts: new Map(),
+      moduleScripts: new Map()
+    },
+    nonce,
+    // like a module global for currently rendering boundary
+    boundaryResources: null,
+    stylesToHoist: false
+  };
+
+  if (bootstrapScripts !== undefined) {
+    for (let i = 0; i < bootstrapScripts.length; i++) {
+      const scriptConfig = bootstrapScripts[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'preload',
+        as: 'script',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startScriptSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  if (bootstrapModules !== undefined) {
+    for (let i = 0; i < bootstrapModules.length; i++) {
+      const scriptConfig = bootstrapModules[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'modulepreload',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startModuleSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  return renderState;
+}
+function createResumableState(identifierPrefix, externalRuntimeConfig, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
+  const idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
+  let streamingFormat = ScriptStreamingFormat;
+
+  {
+    if (externalRuntimeConfig !== undefined) {
+      streamingFormat = DataStreamingFormat;
+    }
+  }
+
+  return {
+    idPrefix: idPrefix,
+    nextFormID: 0,
+    streamingFormat,
+    bootstrapScriptContent,
+    bootstrapScripts,
+    bootstrapModules,
+    instructions: NothingSent,
+    hasBody: false,
+    hasHtml: false,
+    // @TODO add bootstrap script to implicit preloads
+    // persistent
+    unknownResources: {},
+    dnsResources: {},
+    connectResources: {
+      default: {},
+      anonymous: {},
+      credentials: {}
+    },
+    imageResources: {},
+    styleResources: {},
+    scriptResources: {},
+    moduleUnknownResources: {},
+    moduleScriptResources: {}
+  };
+}
+// modes. We only include the variants as they matter for the sake of our purposes.
+// We don't actually provide the namespace therefore we use constants instead of the string.
+
+const ROOT_HTML_MODE = 0; // Used for the root most element tag.
+// We have a less than HTML_HTML_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const HTML_HTML_MODE = 1; // Used for the <html> if it is at the top level.
+
+const HTML_MODE = 2;
+const SVG_MODE = 3;
+const MATHML_MODE = 4;
+const HTML_TABLE_MODE = 5;
+const HTML_TABLE_BODY_MODE = 6;
+const HTML_TABLE_ROW_MODE = 7;
+const HTML_COLGROUP_MODE = 8; // We have a greater than HTML_TABLE_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const NO_SCOPE =
+/*         */
+0b00;
+const NOSCRIPT_SCOPE =
+/*   */
+0b01;
+const PICTURE_SCOPE =
+/*    */
+0b10; // Lets us keep track of contextual state and pick it back up after suspending.
+
+function createFormatContext(insertionMode, selectedValue, tagScope) {
+  return {
+    insertionMode,
+    selectedValue,
+    tagScope
+  };
+}
+
+function createRootFormatContext(namespaceURI) {
+  const insertionMode = namespaceURI === 'http://www.w3.org/2000/svg' ? SVG_MODE : namespaceURI === 'http://www.w3.org/1998/Math/MathML' ? MATHML_MODE : ROOT_HTML_MODE;
+  return createFormatContext(insertionMode, null, NO_SCOPE);
+}
+function getChildFormatContext(parentContext, type, props) {
+  switch (type) {
+    case 'noscript':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | NOSCRIPT_SCOPE);
+
+    case 'select':
+      return createFormatContext(HTML_MODE, props.value != null ? props.value : props.defaultValue, parentContext.tagScope);
+
+    case 'svg':
+      return createFormatContext(SVG_MODE, null, parentContext.tagScope);
+
+    case 'picture':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | PICTURE_SCOPE);
+
+    case 'math':
+      return createFormatContext(MATHML_MODE, null, parentContext.tagScope);
+
+    case 'foreignObject':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    // Table parents are special in that their children can only be created at all if they're
+    // wrapped in a table parent. So we need to encode that we're entering this mode.
+
+    case 'table':
+      return createFormatContext(HTML_TABLE_MODE, null, parentContext.tagScope);
+
+    case 'thead':
+    case 'tbody':
+    case 'tfoot':
+      return createFormatContext(HTML_TABLE_BODY_MODE, null, parentContext.tagScope);
+
+    case 'colgroup':
+      return createFormatContext(HTML_COLGROUP_MODE, null, parentContext.tagScope);
+
+    case 'tr':
+      return createFormatContext(HTML_TABLE_ROW_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode >= HTML_TABLE_MODE) {
+    // Whatever tag this was, it wasn't a table parent or other special parent, so we must have
+    // entered plain HTML again.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode === ROOT_HTML_MODE) {
+    if (type === 'html') {
+      // We've emitted the root and is now in <html> mode.
+      return createFormatContext(HTML_HTML_MODE, null, parentContext.tagScope);
+    } else {
+      // We've emitted the root and is now in plain HTML mode.
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    }
+  } else if (parentContext.insertionMode === HTML_HTML_MODE) {
+    // We've emitted the document element and is now in plain HTML mode.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  return parentContext;
+}
+function makeId(resumableState, treeId, localId) {
+  const idPrefix = resumableState.idPrefix;
+  let id = ':' + idPrefix + 'R' + treeId; // Unless this is the first id at this level, append a number at the end
+  // that represents the position of this useId hook among all the useId
+  // hooks for this fiber.
+
+  if (localId > 0) {
+    id += 'H' + localId.toString(32);
+  }
+
+  return id + ':';
+}
+
+function encodeHTMLTextNode(text) {
+  return escapeTextForBrowser(text);
+}
+
+const textSeparator = stringToPrecomputedChunk('<!-- -->');
+function pushTextInstance(target, text, renderState, textEmbedded) {
+  if (text === '') {
+    // Empty text doesn't have a DOM node representation and the hydration is aware of this.
+    return textEmbedded;
+  }
+
+  if (textEmbedded) {
+    target.push(textSeparator);
+  }
+
+  target.push(stringToChunk(encodeHTMLTextNode(text)));
+  return true;
+} // Called when Fizz is done with a Segment. Currently the only purpose is to conditionally
+// emit a text separator when we don't know for sure it is safe to omit
+
+function pushSegmentFinale(target, renderState, lastPushedText, textEmbedded) {
+  if (lastPushedText && textEmbedded) {
+    target.push(textSeparator);
+  }
+}
+const styleNameCache = new Map();
+
+function processStyleName(styleName) {
+  const chunk = styleNameCache.get(styleName);
+
+  if (chunk !== undefined) {
+    return chunk;
+  }
+
+  const result = stringToPrecomputedChunk(escapeTextForBrowser(hyphenateStyleName(styleName)));
+  styleNameCache.set(styleName, result);
+  return result;
+}
+
+const styleAttributeStart = stringToPrecomputedChunk(' style="');
+const styleAssign = stringToPrecomputedChunk(':');
+const styleSeparator = stringToPrecomputedChunk(';');
+
+function pushStyleAttribute(target, style) {
+  if (typeof style !== 'object') {
+    throw new Error('The `style` prop expects a mapping from style properties to values, ' + "not a string. For example, style={{marginRight: spacing + 'em'}} when " + 'using JSX.');
+  }
+
+  let isFirst = true;
+
+  for (const styleName in style) {
+    if (!hasOwnProperty.call(style, styleName)) {
+      continue;
+    } // If you provide unsafe user data here they can inject arbitrary CSS
+    // which may be problematic (I couldn't repro this):
+    // https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet
+    // http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/
+    // This is not an XSS hole but instead a potential CSS injection issue
+    // which has lead to a greater discussion about how we're going to
+    // trust URLs moving forward. See #2115901
+
+
+    const styleValue = style[styleName];
+
+    if (styleValue == null || typeof styleValue === 'boolean' || styleValue === '') {
+      // TODO: We used to set empty string as a style with an empty value. Does that ever make sense?
+      continue;
+    }
+
+    let nameChunk;
+    let valueChunk;
+    const isCustomProperty = styleName.indexOf('--') === 0;
+
+    if (isCustomProperty) {
+      nameChunk = stringToChunk(escapeTextForBrowser(styleName));
+
+      valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+    } else {
+
+      nameChunk = processStyleName(styleName);
+
+      if (typeof styleValue === 'number') {
+        if (styleValue !== 0 && !isUnitlessNumber(styleName)) {
+          valueChunk = stringToChunk(styleValue + 'px'); // Presumes implicit 'px' suffix for unitless numbers
+        } else {
+          valueChunk = stringToChunk('' + styleValue);
+        }
+      } else {
+
+        valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+      }
+    }
+
+    if (isFirst) {
+      isFirst = false; // If it's first, we don't need any separators prefixed.
+
+      target.push(styleAttributeStart, nameChunk, styleAssign, valueChunk);
+    } else {
+      target.push(styleSeparator, nameChunk, styleAssign, valueChunk);
+    }
+  }
+
+  if (!isFirst) {
+    target.push(attributeEnd);
+  }
+}
+
+const attributeSeparator = stringToPrecomputedChunk(' ');
+const attributeAssign = stringToPrecomputedChunk('="');
+const attributeEnd = stringToPrecomputedChunk('"');
+const attributeEmptyString = stringToPrecomputedChunk('=""');
+
+function pushBooleanAttribute(target, name, value) // not null or undefined
+{
+  if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+    target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+  }
+}
+
+function pushStringAttribute(target, name, value) // not null or undefined
+{
+  if (typeof value !== 'function' && typeof value !== 'symbol' && typeof value !== 'boolean') {
+    target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+  }
+}
+
+function makeFormFieldPrefix(resumableState) {
+  const id = resumableState.nextFormID++;
+  return resumableState.idPrefix + id;
+} // Since this will likely be repeated a lot in the HTML, we use a more concise message
+// than on the client and hopefully it's googleable.
+
+
+const actionJavaScriptURL = stringToPrecomputedChunk(escapeTextForBrowser( // eslint-disable-next-line no-script-url
+"javascript:throw new Error('A React form was unexpectedly submitted.')"));
+const startHiddenInputChunk = stringToPrecomputedChunk('<input type="hidden"');
+
+function pushAdditionalFormField(value, key) {
+  const target = this;
+  target.push(startHiddenInputChunk);
+
+  if (typeof value !== 'string') {
+    throw new Error('File/Blob fields are not yet supported in progressive forms. ' + 'It probably means you are closing over binary data or FormData in a Server Action.');
+  }
+
+  pushStringAttribute(target, 'name', key);
+  pushStringAttribute(target, 'value', value);
+  target.push(endOfStartTagSelfClosing);
+}
+
+function pushAdditionalFormFields(target, formData) {
+  if (formData !== null) {
+    // $FlowFixMe[prop-missing]: FormData has forEach.
+    formData.forEach(pushAdditionalFormField, target);
+  }
+}
+
+function pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name) {
+  let formData = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      name = customFields.name;
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('formAction'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      name = null;
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (name != null) {
+    pushAttribute(target, 'name', name);
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'formAction', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'formEncType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'formMethod', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'formTarget', formTarget);
+  }
+
+  return formData;
+}
+
+function pushAttribute(target, name, value) // not null or undefined
+{
+  switch (name) {
+    // These are very common props and therefore are in the beginning of the switch.
+    // TODO: aria-label is a very common prop but allows booleans so is not like the others
+    // but should ideally go in this list too.
+    case 'className':
+      {
+        pushStringAttribute(target, 'class', value);
+        break;
+      }
+
+    case 'tabIndex':
+      {
+        pushStringAttribute(target, 'tabindex', value);
+        break;
+      }
+
+    case 'dir':
+    case 'role':
+    case 'viewBox':
+    case 'width':
+    case 'height':
+      {
+        pushStringAttribute(target, name, value);
+        break;
+      }
+
+    case 'style':
+      {
+        pushStyleAttribute(target, value);
+        return;
+      }
+
+    case 'src':
+    case 'href':
+      {
+        {
+          if (value === '') {
+
+            return;
+          }
+        }
+      }
+    // Fall through to the last case which shouldn't remove empty strings.
+
+    case 'action':
+    case 'formAction':
+      {
+        // TODO: Consider only special casing these for each tag.
+        if (value == null || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'defaultValue':
+    case 'defaultChecked': // These shouldn't be set as attributes on generic HTML elements.
+
+    case 'innerHTML': // Must use dangerouslySetInnerHTML instead.
+
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+      // Ignored. These are built-in to React on the client.
+      return;
+
+    case 'autoFocus':
+    case 'multiple':
+    case 'muted':
+      {
+        pushBooleanAttribute(target, name.toLowerCase(), value);
+        return;
+      }
+
+    case 'xlinkHref':
+      {
+        if (typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk('xlink:href'), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'contentEditable':
+    case 'spellCheck':
+    case 'draggable':
+    case 'value':
+    case 'autoReverse':
+    case 'externalResourcesRequired':
+    case 'focusable':
+    case 'preserveAlpha':
+      {
+        // Booleanish String
+        // These are "enumerated" attributes that accept "true" and "false".
+        // In React, we let users pass `true` and `false` even though technically
+        // these aren't boolean attributes (they are coerced to strings).
+        if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'allowFullScreen':
+    case 'async':
+    case 'autoPlay':
+    case 'controls':
+    case 'default':
+    case 'defer':
+    case 'disabled':
+    case 'disablePictureInPicture':
+    case 'disableRemotePlayback':
+    case 'formNoValidate':
+    case 'hidden':
+    case 'loop':
+    case 'noModule':
+    case 'noValidate':
+    case 'open':
+    case 'playsInline':
+    case 'readOnly':
+    case 'required':
+    case 'reversed':
+    case 'scoped':
+    case 'seamless':
+    case 'itemScope':
+      {
+        // Boolean
+        if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        }
+
+        return;
+      }
+
+    case 'capture':
+    case 'download':
+      {
+        // Overloaded Boolean
+        if (value === true) {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        } else if (value === false) ; else if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'cols':
+    case 'rows':
+    case 'size':
+    case 'span':
+      {
+        // These are HTML attributes that must be positive numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value) && value >= 1) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'rowSpan':
+    case 'start':
+      {
+        // These are HTML attributes that must be numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value)) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'xlinkActuate':
+      pushStringAttribute(target, 'xlink:actuate', value);
+      return;
+
+    case 'xlinkArcrole':
+      pushStringAttribute(target, 'xlink:arcrole', value);
+      return;
+
+    case 'xlinkRole':
+      pushStringAttribute(target, 'xlink:role', value);
+      return;
+
+    case 'xlinkShow':
+      pushStringAttribute(target, 'xlink:show', value);
+      return;
+
+    case 'xlinkTitle':
+      pushStringAttribute(target, 'xlink:title', value);
+      return;
+
+    case 'xlinkType':
+      pushStringAttribute(target, 'xlink:type', value);
+      return;
+
+    case 'xmlBase':
+      pushStringAttribute(target, 'xml:base', value);
+      return;
+
+    case 'xmlLang':
+      pushStringAttribute(target, 'xml:lang', value);
+      return;
+
+    case 'xmlSpace':
+      pushStringAttribute(target, 'xml:space', value);
+      return;
+
+    default:
+      if ( // shouldIgnoreAttribute
+      // We have already filtered out null/undefined and reserved words.
+      name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+        return;
+      }
+
+      const attributeName = getAttributeAlias(name);
+
+      if (isAttributeNameSafe(attributeName)) {
+        // shouldRemoveAttribute
+        switch (typeof value) {
+          case 'function':
+          case 'symbol':
+            // eslint-disable-line
+            return;
+
+          case 'boolean':
+            {
+              const prefix = attributeName.toLowerCase().slice(0, 5);
+
+              if (prefix !== 'data-' && prefix !== 'aria-') {
+                return;
+              }
+            }
+        }
+
+        target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+      }
+
+  }
+}
+
+const endOfStartTag = stringToPrecomputedChunk('>');
+const endOfStartTagSelfClosing = stringToPrecomputedChunk('/>');
+
+function pushInnerHTML(target, innerHTML, children) {
+  if (innerHTML != null) {
+    if (children != null) {
+      throw new Error('Can only set one of `children` or `props.dangerouslySetInnerHTML`.');
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw new Error('`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. ' + 'Please visit https://reactjs.org/link/dangerously-set-inner-html ' + 'for more information.');
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+
+      target.push(stringToChunk('' + html));
+    }
+  }
+} // TODO: Move these to RenderState so that we warn for every request.
+
+function pushStartSelect(target, props) {
+
+  target.push(startChunkForTag('select'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          // TODO: This doesn't really make sense for select since it can't use the controlled
+          // value in the innerHTML.
+          innerHTML = propValue;
+          break;
+
+        case 'defaultValue':
+        case 'value':
+          // These are set on the Context instead and applied to the nested options.
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+function flattenOptionChildren(children) {
+  let content = ''; // Flatten children and warn if they aren't strings or numbers;
+  // invalid types are ignored.
+
+  React.Children.forEach(children, function (child) {
+    if (child == null) {
+      return;
+    }
+
+    content += child;
+  });
+  return content;
+}
+
+const selectedMarkerAttribute = stringToPrecomputedChunk(' selected=""');
+
+function pushStartOption(target, props, formatContext) {
+  const selectedValue = formatContext.selectedValue;
+  target.push(startChunkForTag('option'));
+  let children = null;
+  let value = null;
+  let selected = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'selected':
+          // ignore
+          selected = propValue;
+
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+        // We intentionally fallthrough to also set the attribute on the node.
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (selectedValue != null) {
+    let stringValue;
+
+    if (value !== null) {
+
+      stringValue = '' + value;
+    } else {
+
+      stringValue = flattenOptionChildren(children);
+    }
+
+    if (isArray(selectedValue)) {
+      // multiple
+      for (let i = 0; i < selectedValue.length; i++) {
+
+        const v = '' + selectedValue[i];
+
+        if (v === stringValue) {
+          target.push(selectedMarkerAttribute);
+          break;
+        }
+      }
+    } else {
+
+      if ('' + selectedValue === stringValue) {
+        target.push(selectedMarkerAttribute);
+      }
+    }
+  } else if (selected) {
+    target.push(selectedMarkerAttribute);
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const formReplayingRuntimeScript = stringToPrecomputedChunk(formReplaying);
+
+function injectFormReplayingRuntime(resumableState, renderState) {
+  // If we haven't sent it yet, inject the runtime that tracks submitted JS actions
+  // for later replaying by Fiber. If we use an external runtime, we don't need
+  // to emit anything. It's always used.
+  if ((resumableState.instructions & SentFormReplayingRuntime) === NothingSent && (!renderState.externalRuntimeScript)) {
+    resumableState.instructions |= SentFormReplayingRuntime;
+    renderState.bootstrapChunks.unshift(renderState.startInlineScript, formReplayingRuntimeScript, endInlineScript);
+  }
+}
+
+const formStateMarkerIsMatching = stringToPrecomputedChunk('<!--F!-->');
+const formStateMarkerIsNotMatching = stringToPrecomputedChunk('<!--F-->');
+function pushFormStateMarkerIsMatching(target) {
+  target.push(formStateMarkerIsMatching);
+}
+function pushFormStateMarkerIsNotMatching(target) {
+  target.push(formStateMarkerIsNotMatching);
+}
+
+function pushStartForm(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('form'));
+  let children = null;
+  let innerHTML = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'action':
+          formAction = propValue;
+          break;
+
+        case 'encType':
+          formEncType = propValue;
+          break;
+
+        case 'method':
+          formMethod = propValue;
+          break;
+
+        case 'target':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  let formData = null;
+  let formActionName = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+      formActionName = customFields.name;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('action'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'action', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'encType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'method', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'target', formTarget);
+  }
+
+  target.push(endOfStartTag);
+
+  if (formActionName !== null) {
+    target.push(startHiddenInputChunk);
+    pushStringAttribute(target, 'name', formActionName);
+    target.push(endOfStartTagSelfClosing);
+    pushAdditionalFormFields(target, formData);
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushInput(target, props, resumableState, renderState) {
+
+  target.push(startChunkForTag('input'));
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+  let value = null;
+  let defaultValue = null;
+  let checked = null;
+  let defaultChecked = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('input' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        case 'defaultChecked':
+          defaultChecked = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'checked':
+          checked = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+
+  if (checked !== null) {
+    pushBooleanAttribute(target, 'checked', checked);
+  } else if (defaultChecked !== null) {
+    pushBooleanAttribute(target, 'checked', defaultChecked);
+  }
+
+  if (value !== null) {
+    pushAttribute(target, 'value', value);
+  } else if (defaultValue !== null) {
+    pushAttribute(target, 'value', defaultValue);
+  }
+
+  target.push(endOfStartTagSelfClosing); // We place any additional hidden form fields after the input.
+
+  pushAdditionalFormFields(target, formData);
+  return null;
+}
+
+function pushStartButton(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('button'));
+  let children = null;
+  let innerHTML = null;
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+  target.push(endOfStartTag); // We place any additional hidden form fields we need to include inside the button itself.
+
+  pushAdditionalFormFields(target, formData);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartTextArea(target, props) {
+
+  target.push(startChunkForTag('textarea'));
+  let value = null;
+  let defaultValue = null;
+  let children = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          throw new Error('`dangerouslySetInnerHTML` does not make sense on <textarea>.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (value === null && defaultValue !== null) {
+    value = defaultValue;
+  }
+
+  target.push(endOfStartTag); // TODO (yungsters): Remove support for children content in <textarea>.
+
+  if (children != null) {
+
+    if (value != null) {
+      throw new Error('If you supply `defaultValue` on a <textarea>, do not pass children.');
+    }
+
+    if (isArray(children)) {
+      if (children.length > 1) {
+        throw new Error('<textarea> can only have at most one child.');
+      } // TODO: remove the coercion and the DEV check below because it will
+
+      value = '' + children[0];
+    }
+
+    value = '' + children;
+  }
+
+  if (typeof value === 'string' && value[0] === '\n') {
+    // text/html ignores the first character in these tags if it's a newline
+    // Prefer to break application/xml over text/html (for now) by adding
+    // a newline specifically to get eaten by the parser. (Alternately for
+    // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+    // \r is normalized out by HTMLTextAreaElement#value.)
+    // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+    // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+    // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+    // See: Parsing of "textarea" "listing" and "pre" elements
+    //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+    target.push(leadingNewline);
+  } // ToString and push directly instead of recurse over children.
+  // We don't really support complex children in the value anyway.
+  // This also currently avoids a trailing comment node which breaks textarea.
+
+
+  if (value !== null) {
+
+    target.push(stringToChunk(encodeHTMLTextNode('' + value)));
+  }
+
+  return null;
+}
+
+function pushMeta(target, props, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      return pushSelfClosing(target, props, 'meta');
+    } else {
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      if (typeof props.charSet === 'string') {
+        return pushSelfClosing(renderState.charsetChunks, props, 'meta');
+      } else if (props.name === 'viewport') {
+        // "viewport" isn't related to preconnect but it has the right priority
+        return pushSelfClosing(renderState.preconnectChunks, props, 'meta');
+      } else {
+        return pushSelfClosing(renderState.hoistableChunks, props, 'meta');
+      }
+    }
+  }
+}
+
+function pushLink(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const rel = props.rel;
+    const href = props.href;
+    const precedence = props.precedence;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof rel !== 'string' || typeof href !== 'string' || href === '') {
+
+      pushLinkImpl(target, props);
+      return null;
+    }
+
+    if (props.rel === 'stylesheet') {
+      // This <link> may hoistable as a Stylesheet Resource, otherwise it will emit in place
+      const key = getResourceKey(href);
+
+      if (typeof precedence !== 'string' || props.disabled != null || props.onLoad || props.onError) {
+
+        return pushLinkImpl(target, props);
+      } else {
+        // This stylesheet refers to a Resource and we create a new one if necessary
+        let styleQueue = renderState.styles.get(precedence);
+        const hasKey = resumableState.styleResources.hasOwnProperty(key);
+        const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+        if (resourceState !== EXISTS) {
+          // We are going to create this resource now so it is marked as Exists
+          resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+          // to create a StyleQueue
+
+          if (!styleQueue) {
+            styleQueue = {
+              precedence: stringToChunk(escapeTextForBrowser(precedence)),
+              rules: [],
+              hrefs: [],
+              sheets: new Map()
+            };
+            renderState.styles.set(precedence, styleQueue);
+          }
+
+          const resource = {
+            state: PENDING$1,
+            props: stylesheetPropsFromRawProps(props)
+          };
+
+          if (resourceState) {
+            // When resourceState is truty it is a Preload state. We cast it for clarity
+            const preloadState = resourceState;
+
+            if (preloadState.length === 2) {
+              adoptPreloadCredentials(resource.props, preloadState);
+            }
+
+            const preloadResource = renderState.preloads.stylesheets.get(key);
+
+            if (preloadResource && preloadResource.length > 0) {
+              // The Preload for this resource was created in this render pass and has not flushed yet so
+              // we need to clear it to avoid it flushing.
+              preloadResource.length = 0;
+            } else {
+              // Either the preload resource from this render already flushed in this render pass
+              // or the preload flushed in a prior pass (prerender). In either case we need to mark
+              // this resource as already having been preloaded.
+              resource.state = PRELOADED;
+            }
+          } // We add the newly created resource to our StyleQueue and if necessary
+          // track the resource with the currently rendering boundary
+
+
+          styleQueue.sheets.set(key, resource);
+
+          if (renderState.boundaryResources) {
+            renderState.boundaryResources.stylesheets.add(resource);
+          }
+        } else {
+          // We need to track whether this boundary should wait on this resource or not.
+          // Typically this resource should always exist since we either had it or just created
+          // it. However, it's possible when you resume that the style has already been emitted
+          // and then it wouldn't be recreated in the RenderState and there's no need to track
+          // it again since we should've hoisted it to the shell already.
+          if (styleQueue) {
+            const resource = styleQueue.sheets.get(key);
+
+            if (resource) {
+              if (renderState.boundaryResources) {
+                renderState.boundaryResources.stylesheets.add(resource);
+              }
+            }
+          }
+        }
+
+        if (textEmbedded) {
+          // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+          // to be safe and assume text will follow by inserting a textSeparator
+          target.push(textSeparator);
+        }
+
+        return null;
+      }
+    } else if (props.onLoad || props.onError) {
+      // When using load handlers we cannot hoist and need to emit links in place
+      return pushLinkImpl(target, props);
+    } else {
+      // We can hoist this link so we may need to emit a text separator.
+      // @TODO refactor text separators so we don't have to defensively add
+      // them when we don't end up emitting a tag as a result of pushStartInstance
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      switch (props.rel) {
+        case 'preconnect':
+        case 'dns-prefetch':
+          return pushLinkImpl(renderState.preconnectChunks, props);
+
+        case 'preload':
+          return pushLinkImpl(renderState.preloadChunks, props);
+
+        default:
+          return pushLinkImpl(renderState.hoistableChunks, props);
+      }
+    }
+  }
+}
+
+function pushLinkImpl(target, props) {
+  target.push(startChunkForTag('link'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStyle(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+
+  {
+    const precedence = props.precedence;
+    const href = props.href;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof precedence !== 'string' || typeof href !== 'string' || href === '') {
+      // This style tag is not able to be turned into a Style Resource
+      return pushStyleImpl(target, props);
+    }
+
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS;
+
+      if (!styleQueue) {
+        // This is the first time we've encountered this precedence we need
+        // to create a StyleQueue.
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [stringToChunk(escapeTextForBrowser(href))],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      } else {
+        // We have seen this precedence before and need to track this href
+        styleQueue.hrefs.push(stringToChunk(escapeTextForBrowser(href)));
+      }
+
+      pushStyleContents(styleQueue.rules, props);
+    }
+
+    if (styleQueue) {
+      // We need to track whether this boundary should wait on this resource or not.
+      // Typically this resource should always exist since we either had it or just created
+      // it. However, it's possible when you resume that the style has already been emitted
+      // and then it wouldn't be recreated in the RenderState and there's no need to track
+      // it again since we should've hoisted it to the shell already.
+      if (renderState.boundaryResources) {
+        renderState.boundaryResources.styles.add(styleQueue);
+      }
+    }
+
+    if (textEmbedded) {
+      // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+  }
+}
+
+function pushStyleImpl(target, props) {
+  target.push(startChunkForTag('style'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('style'));
+  return null;
+}
+
+function pushStyleContents(target, props) {
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+      }
+    }
+  }
+
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  return;
+}
+
+function pushImg(target, props, resumableState, renderState, pictureTagInScope) {
+  const src = props.src,
+        srcSet = props.srcSet;
+
+  if (props.loading !== 'lazy' && (src || srcSet) && (typeof src === 'string' || src == null) && (typeof srcSet === 'string' || srcSet == null) && props.fetchPriority !== 'low' && pictureTagInScope === false && // We exclude data URIs in src and srcSet since these should not be preloaded
+  !(typeof src === 'string' && src[4] === ':' && (src[0] === 'd' || src[0] === 'D') && (src[1] === 'a' || src[1] === 'A') && (src[2] === 't' || src[2] === 'T') && (src[3] === 'a' || src[3] === 'A')) && !(typeof srcSet === 'string' && srcSet[4] === ':' && (srcSet[0] === 'd' || srcSet[0] === 'D') && (srcSet[1] === 'a' || srcSet[1] === 'A') && (srcSet[2] === 't' || srcSet[2] === 'T') && (srcSet[3] === 'a' || srcSet[3] === 'A'))) {
+    // We have a suspensey image and ought to preload it to optimize the loading of display blocking
+    // resumableState.
+    const sizes = typeof props.sizes === 'string' ? props.sizes : undefined;
+    const key = getImageResourceKey(src, srcSet, sizes);
+    const promotablePreloads = renderState.preloads.images;
+    let resource = promotablePreloads.get(key);
+
+    if (resource) {
+      // We consider whether this preload can be promoted to higher priority flushing queue.
+      // The only time a resource will exist here is if it was created during this render
+      // and was not already in the high priority queue.
+      if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+        // Delete the resource from the map since we are promoting it and don't want to
+        // reenter this branch in a second pass for duplicate img hrefs.
+        promotablePreloads.delete(key); // $FlowFixMe - Flow should understand that this is a Resource if the condition was true
+
+        renderState.highImagePreloads.add(resource);
+      }
+    } else if (!resumableState.imageResources.hasOwnProperty(key)) {
+      // We must construct a new preload resource
+      resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+      const crossOrigin = getCrossOriginString(props.crossOrigin);
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // this is a hueristic similar to capping element preloads to 10 unless explicitly
+      // fetchPriority="high". We use length here which means it will fit fewer images when
+      // the urls are long and more when short. arguably byte size is a better hueristic because
+      // it directly translates to how much we send down before content is actually seen.
+      // We could unify the counts and also make it so the total is tracked regardless of
+      // flushing output but since the headers are likely to be go earlier than content
+      // they don't really conflict so for now I've kept them separate
+      props.fetchPriority === 'high' || headers.highImagePreloads.length < 500) && ( // We manually construct the options for the preload only from strings. We don't want to pollute
+      // the params list with arbitrary props and if we copied everything over as it we might get
+      // coercion errors. We have checks for this in Dev but it seems safer to just only accept values
+      // that are strings
+      header = getPreloadAsHeader(src, 'image', {
+        imageSrcSet: props.srcSet,
+        imageSizes: props.sizes,
+        crossOrigin,
+        integrity: props.integrity,
+        nonce: props.nonce,
+        type: props.type,
+        fetchPriority: props.fetchPriority,
+        referrerPolicy: props.refererPolicy
+      }), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // If we postpone in the shell we will still emit this preload so we track
+        // it to make sure we don't reset it.
+        renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+        if (headers.highImagePreloads) {
+          headers.highImagePreloads += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.highImagePreloads += header;
+      } else {
+        resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preload',
+          as: 'image',
+          // There is a bug in Safari where imageSrcSet is not respected on preload links
+          // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+          // This harms older browers that do not support imageSrcSet by making their preloads not work
+          // but this population is shrinking fast and is already small so we accept this tradeoff.
+          href: srcSet ? undefined : src,
+          imageSrcSet: srcSet,
+          imageSizes: sizes,
+          crossOrigin: crossOrigin,
+          integrity: props.integrity,
+          type: props.type,
+          fetchPriority: props.fetchPriority,
+          referrerPolicy: props.referrerPolicy
+        });
+
+        if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+          renderState.highImagePreloads.add(resource);
+        } else {
+          renderState.bulkPreloads.add(resource); // We can bump the priority up if the same img is rendered later
+          // with fetchPriority="high"
+
+          promotablePreloads.set(key, resource);
+        }
+      }
+    }
+  }
+
+  return pushSelfClosing(target, props, 'img');
+}
+
+function pushSelfClosing(target, props, tag) {
+  target.push(startChunkForTag(tag));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error(tag + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStartMenuItem(target, props) {
+  target.push(startChunkForTag('menuitem'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('menuitems cannot have `children` nor `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  return null;
+}
+
+function pushTitle(target, props, renderState, insertionMode, noscriptTagInScope) {
+
+  {
+    if (insertionMode !== SVG_MODE && !noscriptTagInScope && props.itemProp == null) {
+      pushTitleImpl(renderState.hoistableChunks, props);
+      return null;
+    } else {
+      return pushTitleImpl(target, props);
+    }
+  }
+}
+
+function pushTitleImpl(target, props) {
+  target.push(startChunkForTag('title'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('title'));
+  return null;
+}
+
+function pushStartHead(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode < HTML_MODE && renderState.headChunks === null) {
+      // This <head> is the Document.head and should be part of the preamble
+      renderState.headChunks = [];
+      return pushStartGenericElement(renderState.headChunks, props, 'head');
+    } else {
+      // This <head> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'head');
+    }
+  }
+}
+
+function pushStartHtml(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode === ROOT_HTML_MODE && renderState.htmlChunks === null) {
+      // This <html> is the Document.documentElement and should be part of the preamble
+      renderState.htmlChunks = [doctypeChunk];
+      return pushStartGenericElement(renderState.htmlChunks, props, 'html');
+    } else {
+      // This <html> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'html');
+    }
+  }
+}
+
+function pushScript(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const asyncProp = props.async;
+
+    if (typeof props.src !== 'string' || !props.src || !(asyncProp && typeof asyncProp !== 'function' && typeof asyncProp !== 'symbol') || props.onLoad || props.onError || insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      // This script will not be a resource, we bailout early and emit it in place.
+      return pushScriptImpl(target, props);
+    }
+
+    const src = props.src;
+    const key = getResourceKey(src); // We can make this <script> into a ScriptResource
+
+    let resources, preloads;
+
+    if (props.type === 'module') {
+      resources = resumableState.moduleScriptResources;
+      preloads = renderState.preloads.moduleScripts;
+    } else {
+      resources = resumableState.scriptResources;
+      preloads = renderState.preloads.scripts;
+    }
+
+    const hasKey = resources.hasOwnProperty(key);
+    const resourceState = hasKey ? resources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resources[key] = EXISTS;
+      let scriptProps = props;
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          scriptProps = assign({}, props);
+          adoptPreloadCredentials(scriptProps, preloadState);
+        }
+
+        const preloadResource = preloads.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, scriptProps);
+    }
+
+    if (textEmbedded) {
+      // This script follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+
+    return null;
+  }
+}
+
+function pushScriptImpl(target, props) {
+  target.push(startChunkForTag('script'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+  }
+
+  target.push(endChunkForTag('script'));
+  return null;
+}
+
+function pushStartGenericElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartCustomElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      let propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      let attributeName = propKey;
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'style':
+          pushStyleAttribute(target, propValue);
+          break;
+
+        case 'suppressContentEditableWarning':
+        case 'suppressHydrationWarning':
+          // Ignored. These are built-in to React on the client.
+          break;
+
+        case 'className':
+          {
+            // className gets rendered as class on the client, so it should be
+            // rendered as class on the server.
+            attributeName = 'class';
+          }
+
+        // intentional fallthrough
+
+        default:
+          if (isAttributeNameSafe(propKey) && typeof propValue !== 'function' && typeof propValue !== 'symbol') {
+            {
+              if (propValue === false) {
+                continue;
+              } else if (propValue === true) {
+                propValue = '';
+              } else if (typeof propValue === 'object') {
+                continue;
+              }
+            }
+
+            target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(propValue)), attributeEnd);
+          }
+
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const leadingNewline = stringToPrecomputedChunk('\n');
+
+function pushStartPreformattedElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag); // text/html ignores the first character in these tags if it's a newline
+  // Prefer to break application/xml over text/html (for now) by adding
+  // a newline specifically to get eaten by the parser. (Alternately for
+  // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+  // \r is normalized out by HTMLTextAreaElement#value.)
+  // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+  // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+  // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+  // See: Parsing of "textarea" "listing" and "pre" elements
+  //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+  // TODO: This doesn't deal with the case where the child is an array
+  // or component that returns a string.
+
+  if (innerHTML != null) {
+    if (children != null) {
+      throw new Error('Can only set one of `children` or `props.dangerouslySetInnerHTML`.');
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw new Error('`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. ' + 'Please visit https://reactjs.org/link/dangerously-set-inner-html ' + 'for more information.');
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+      if (typeof html === 'string' && html.length > 0 && html[0] === '\n') {
+        target.push(leadingNewline, stringToChunk(html));
+      } else {
+
+        target.push(stringToChunk('' + html));
+      }
+    }
+  }
+
+  if (typeof children === 'string' && children[0] === '\n') {
+    target.push(leadingNewline);
+  }
+
+  return children;
+} // We accept any tag to be rendered but since this gets injected into arbitrary
+// HTML, we want to make sure that it's a safe tag.
+// http://www.w3.org/TR/REC-xml/#NT-Name
+
+
+const VALID_TAG_REGEX = /^[a-zA-Z][a-zA-Z:_\.\-\d]*$/; // Simplified subset
+
+const validatedTagCache = new Map();
+
+function startChunkForTag(tag) {
+  let tagStartChunk = validatedTagCache.get(tag);
+
+  if (tagStartChunk === undefined) {
+    if (!VALID_TAG_REGEX.test(tag)) {
+      throw new Error("Invalid tag: " + tag);
+    }
+
+    tagStartChunk = stringToPrecomputedChunk('<' + tag);
+    validatedTagCache.set(tag, tagStartChunk);
+  }
+
+  return tagStartChunk;
+}
+
+const doctypeChunk = stringToPrecomputedChunk('<!DOCTYPE html>');
+function pushStartInstance(target, type, props, resumableState, renderState, formatContext, textEmbedded) {
+
+  switch (type) {
+    case 'div':
+    case 'span':
+    case 'svg':
+    case 'path':
+    case 'a':
+    case 'g':
+    case 'p':
+    case 'li':
+      // Fast track very common tags
+      break;
+    // Special tags
+
+    case 'select':
+      return pushStartSelect(target, props);
+
+    case 'option':
+      return pushStartOption(target, props, formatContext);
+
+    case 'textarea':
+      return pushStartTextArea(target, props);
+
+    case 'input':
+      return pushInput(target, props, resumableState, renderState);
+
+    case 'button':
+      return pushStartButton(target, props, resumableState, renderState);
+
+    case 'form':
+      return pushStartForm(target, props, resumableState, renderState);
+
+    case 'menuitem':
+      return pushStartMenuItem(target, props);
+
+    case 'title':
+      return pushTitle(target, props, renderState, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'link':
+      return pushLink(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'script':
+      return pushScript(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'style':
+      return pushStyle(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'meta':
+      return pushMeta(target, props, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+    // Newline eating tags
+
+    case 'listing':
+    case 'pre':
+      {
+        return pushStartPreformattedElement(target, props, type);
+      }
+
+    case 'img':
+      {
+        return pushImg(target, props, resumableState, renderState, !!(formatContext.tagScope & PICTURE_SCOPE)) ;
+      }
+    // Omitted close tags
+
+    case 'base':
+    case 'area':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'keygen':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        return pushSelfClosing(target, props, type);
+      }
+    // These are reserved SVG and MathML elements, that are never custom elements.
+    // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+
+    case 'annotation-xml':
+    case 'color-profile':
+    case 'font-face':
+    case 'font-face-src':
+    case 'font-face-uri':
+    case 'font-face-format':
+    case 'font-face-name':
+    case 'missing-glyph':
+      {
+        break;
+      }
+    // Preamble start tags
+
+    case 'head':
+      return pushStartHead(target, props, renderState, formatContext.insertionMode);
+
+    case 'html':
+      {
+        return pushStartHtml(target, props, renderState, formatContext.insertionMode);
+      }
+
+    default:
+      {
+        if (type.indexOf('-') !== -1) {
+          // Custom element
+          return pushStartCustomElement(target, props, type);
+        }
+      }
+  } // Generic element
+
+
+  return pushStartGenericElement(target, props, type);
+}
+const endTagCache = new Map();
+
+function endChunkForTag(tag) {
+  let chunk = endTagCache.get(tag);
+
+  if (chunk === undefined) {
+    chunk = stringToPrecomputedChunk('</' + tag + '>');
+    endTagCache.set(tag, chunk);
+  }
+
+  return chunk;
+}
+
+function pushEndInstance(target, type, props, resumableState, formatContext) {
+  switch (type) {
+    // When float is on we expect title and script tags to always be pushed in
+    // a unit and never return children. when we end up pushing the end tag we
+    // want to ensure there is no extra closing tag pushed
+    case 'title':
+    case 'style':
+    case 'script':
+    // Omitted close tags
+    // TODO: Instead of repeating this switch we could try to pass a flag from above.
+    // That would require returning a tuple. Which might be ok if it gets inlined.
+
+    case 'area':
+    case 'base':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'img':
+    case 'input':
+    case 'keygen':
+    case 'link':
+    case 'meta':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        // No close tag needed.
+        return;
+      }
+    // Postamble end tags
+    // When float is enabled we omit the end tags for body and html when
+    // they represent the Document.body and Document.documentElement Nodes.
+    // This is so we can withhold them until the postamble when we know
+    // we won't emit any more tags
+
+    case 'body':
+      {
+        if (formatContext.insertionMode <= HTML_HTML_MODE) {
+          resumableState.hasBody = true;
+          return;
+        }
+
+        break;
+      }
+
+    case 'html':
+      if (formatContext.insertionMode === ROOT_HTML_MODE) {
+        resumableState.hasHtml = true;
+        return;
+      }
+
+      break;
+  }
+
+  target.push(endChunkForTag(type));
+}
+
+function writeBootstrap(destination, renderState, resumableState) {
+  resumableState.bootstrapScriptContent = undefined;
+  resumableState.bootstrapScripts = undefined;
+  resumableState.bootstrapModules = undefined;
+  const bootstrapChunks = renderState.bootstrapChunks;
+  let i = 0;
+
+  for (; i < bootstrapChunks.length - 1; i++) {
+    writeChunk(destination, bootstrapChunks[i]);
+  }
+
+  if (i < bootstrapChunks.length) {
+    const lastChunk = bootstrapChunks[i];
+    bootstrapChunks.length = 0;
+    return writeChunkAndReturn(destination, lastChunk);
+  }
+
+  return true;
+}
+
+function writeCompletedRoot(destination, renderState, resumableState) {
+  return writeBootstrap(destination, renderState, resumableState);
+} // Structural Nodes
+// A placeholder is a node inside a hidden partial tree that can be filled in later, but before
+// display. It's never visible to users. We use the template tag because it can be used in every
+// type of parent. <script> tags also work in every other tag except <colgroup>.
+
+const placeholder1 = stringToPrecomputedChunk('<template id="');
+const placeholder2 = stringToPrecomputedChunk('"></template>');
+function writePlaceholder(destination, renderState, id) {
+  writeChunk(destination, placeholder1);
+  writeChunk(destination, renderState.placeholderPrefix);
+  const formattedID = stringToChunk(id.toString(16));
+  writeChunk(destination, formattedID);
+  return writeChunkAndReturn(destination, placeholder2);
+} // Suspense boundaries are encoded as comments.
+
+const startCompletedSuspenseBoundary = stringToPrecomputedChunk('<!--$-->');
+const startPendingSuspenseBoundary1 = stringToPrecomputedChunk('<!--$?--><template id="');
+const startPendingSuspenseBoundary2 = stringToPrecomputedChunk('"></template>');
+const startClientRenderedSuspenseBoundary = stringToPrecomputedChunk('<!--$!-->');
+const endSuspenseBoundary = stringToPrecomputedChunk('<!--/$-->');
+const clientRenderedSuspenseBoundaryError1 = stringToPrecomputedChunk('<template');
+const clientRenderedSuspenseBoundaryErrorAttrInterstitial = stringToPrecomputedChunk('"');
+const clientRenderedSuspenseBoundaryError1A = stringToPrecomputedChunk(' data-dgst="');
+const clientRenderedSuspenseBoundaryError2 = stringToPrecomputedChunk('></template>');
+function writeStartCompletedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, startCompletedSuspenseBoundary);
+}
+function writeStartPendingSuspenseBoundary(destination, renderState, id) {
+  writeChunk(destination, startPendingSuspenseBoundary1);
+
+  if (id === null) {
+    throw new Error('An ID must have been assigned before we can complete the boundary.');
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+  return writeChunkAndReturn(destination, startPendingSuspenseBoundary2);
+}
+function writeStartClientRenderedSuspenseBoundary(destination, renderState, errorDigest, errorMesssage, errorComponentStack) {
+  let result;
+  result = writeChunkAndReturn(destination, startClientRenderedSuspenseBoundary);
+  writeChunk(destination, clientRenderedSuspenseBoundaryError1);
+
+  if (errorDigest) {
+    writeChunk(destination, clientRenderedSuspenseBoundaryError1A);
+    writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest)));
+    writeChunk(destination, clientRenderedSuspenseBoundaryErrorAttrInterstitial);
+  }
+
+  result = writeChunkAndReturn(destination, clientRenderedSuspenseBoundaryError2);
+  return result;
+}
+function writeEndCompletedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndPendingSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndClientRenderedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+const startSegmentHTML = stringToPrecomputedChunk('<div hidden id="');
+const startSegmentHTML2 = stringToPrecomputedChunk('">');
+const endSegmentHTML = stringToPrecomputedChunk('</div>');
+const startSegmentSVG = stringToPrecomputedChunk('<svg aria-hidden="true" style="display:none" id="');
+const startSegmentSVG2 = stringToPrecomputedChunk('">');
+const endSegmentSVG = stringToPrecomputedChunk('</svg>');
+const startSegmentMathML = stringToPrecomputedChunk('<math aria-hidden="true" style="display:none" id="');
+const startSegmentMathML2 = stringToPrecomputedChunk('">');
+const endSegmentMathML = stringToPrecomputedChunk('</math>');
+const startSegmentTable = stringToPrecomputedChunk('<table hidden id="');
+const startSegmentTable2 = stringToPrecomputedChunk('">');
+const endSegmentTable = stringToPrecomputedChunk('</table>');
+const startSegmentTableBody = stringToPrecomputedChunk('<table hidden><tbody id="');
+const startSegmentTableBody2 = stringToPrecomputedChunk('">');
+const endSegmentTableBody = stringToPrecomputedChunk('</tbody></table>');
+const startSegmentTableRow = stringToPrecomputedChunk('<table hidden><tr id="');
+const startSegmentTableRow2 = stringToPrecomputedChunk('">');
+const endSegmentTableRow = stringToPrecomputedChunk('</tr></table>');
+const startSegmentColGroup = stringToPrecomputedChunk('<table hidden><colgroup id="');
+const startSegmentColGroup2 = stringToPrecomputedChunk('">');
+const endSegmentColGroup = stringToPrecomputedChunk('</colgroup></table>');
+function writeStartSegment(destination, renderState, formatContext, id) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        writeChunk(destination, startSegmentHTML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentHTML2);
+      }
+
+    case SVG_MODE:
+      {
+        writeChunk(destination, startSegmentSVG);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentSVG2);
+      }
+
+    case MATHML_MODE:
+      {
+        writeChunk(destination, startSegmentMathML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentMathML2);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        writeChunk(destination, startSegmentTable);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTable2);
+      }
+    // TODO: For the rest of these, there will be extra wrapper nodes that never
+    // get deleted from the document. We need to delete the table too as part
+    // of the injected scripts. They are invisible though so it's not too terrible
+    // and it's kind of an edge case to suspend in a table. Totally supported though.
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        writeChunk(destination, startSegmentTableBody);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableBody2);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        writeChunk(destination, startSegmentTableRow);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableRow2);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        writeChunk(destination, startSegmentColGroup);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentColGroup2);
+      }
+
+    default:
+      {
+        throw new Error('Unknown insertion mode. This is a bug in React.');
+      }
+  }
+}
+function writeEndSegment(destination, formatContext) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentHTML);
+      }
+
+    case SVG_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentSVG);
+      }
+
+    case MATHML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentMathML);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTable);
+      }
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableBody);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableRow);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentColGroup);
+      }
+
+    default:
+      {
+        throw new Error('Unknown insertion mode. This is a bug in React.');
+      }
+  }
+}
+const completeSegmentScript1Full = stringToPrecomputedChunk(completeSegment + '$RS("');
+const completeSegmentScript1Partial = stringToPrecomputedChunk('$RS("');
+const completeSegmentScript2 = stringToPrecomputedChunk('","');
+const completeSegmentScriptEnd = stringToPrecomputedChunk('")</script>');
+const completeSegmentData1 = stringToPrecomputedChunk('<template data-rsi="" data-sid="');
+const completeSegmentData2 = stringToPrecomputedChunk('" data-pid="');
+const completeSegmentDataEnd = dataElementQuotedEnd;
+function writeCompletedSegmentInstruction(destination, resumableState, renderState, contentSegmentID) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentCompleteSegmentFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentCompleteSegmentFunction;
+      writeChunk(destination, completeSegmentScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, completeSegmentScript1Partial);
+    }
+  } else {
+    writeChunk(destination, completeSegmentData1);
+  } // Write function arguments, which are string literals
+
+
+  writeChunk(destination, renderState.segmentPrefix);
+  const formattedID = stringToChunk(contentSegmentID.toString(16));
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    writeChunk(destination, completeSegmentScript2);
+  } else {
+    writeChunk(destination, completeSegmentData2);
+  }
+
+  writeChunk(destination, renderState.placeholderPrefix);
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    return writeChunkAndReturn(destination, completeSegmentScriptEnd);
+  } else {
+    return writeChunkAndReturn(destination, completeSegmentDataEnd);
+  }
+}
+const completeBoundaryScript1Full = stringToPrecomputedChunk(completeBoundary + '$RC("');
+const completeBoundaryScript1Partial = stringToPrecomputedChunk('$RC("');
+const completeBoundaryWithStylesScript1FullBoth = stringToPrecomputedChunk(completeBoundary + completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1FullPartial = stringToPrecomputedChunk(completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1Partial = stringToPrecomputedChunk('$RR("');
+const completeBoundaryScript2 = stringToPrecomputedChunk('","');
+const completeBoundaryScript3a = stringToPrecomputedChunk('",');
+const completeBoundaryScript3b = stringToPrecomputedChunk('"');
+const completeBoundaryScriptEnd = stringToPrecomputedChunk(')</script>');
+const completeBoundaryData1 = stringToPrecomputedChunk('<template data-rci="" data-bid="');
+const completeBoundaryWithStylesData1 = stringToPrecomputedChunk('<template data-rri="" data-bid="');
+const completeBoundaryData2 = stringToPrecomputedChunk('" data-sid="');
+const completeBoundaryData3a = stringToPrecomputedChunk('" data-sty="');
+const completeBoundaryDataEnd = dataElementQuotedEnd;
+function writeCompletedBoundaryInstruction(destination, resumableState, renderState, id, boundaryResources) {
+  let requiresStyleInsertion;
+
+  {
+    requiresStyleInsertion = renderState.stylesToHoist; // If necessary stylesheets will be flushed with this instruction.
+    // Any style tags not yet hoisted in the Document will also be hoisted.
+    // We reset this state since after this instruction executes all styles
+    // up to this point will have been hoisted
+
+    renderState.stylesToHoist = false;
+  }
+
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if (requiresStyleInsertion) {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction | SentCompleteBoundaryFunction;
+        writeChunk(destination, clonePrecomputedChunk(completeBoundaryWithStylesScript1FullBoth));
+      } else if ((resumableState.instructions & SentStyleInsertionFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction;
+        writeChunk(destination, completeBoundaryWithStylesScript1FullPartial);
+      } else {
+        writeChunk(destination, completeBoundaryWithStylesScript1Partial);
+      }
+    } else {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentCompleteBoundaryFunction;
+        writeChunk(destination, completeBoundaryScript1Full);
+      } else {
+        writeChunk(destination, completeBoundaryScript1Partial);
+      }
+    }
+  } else {
+    if (requiresStyleInsertion) {
+      writeChunk(destination, completeBoundaryWithStylesData1);
+    } else {
+      writeChunk(destination, completeBoundaryData1);
+    }
+  }
+
+  const idChunk = stringToChunk(id.toString(16));
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, idChunk); // Write function arguments, which are string and array literals
+
+  if (scriptFormat) {
+    writeChunk(destination, completeBoundaryScript2);
+  } else {
+    writeChunk(destination, completeBoundaryData2);
+  }
+
+  writeChunk(destination, renderState.segmentPrefix);
+  writeChunk(destination, idChunk);
+
+  if (requiresStyleInsertion) {
+    // Script and data writers must format this differently:
+    //  - script writer emits an array literal, whose string elements are
+    //    escaped for javascript  e.g. ["A", "B"]
+    //  - data writer emits a string literal, which is escaped as html
+    //    e.g. [&#34;A&#34;, &#34;B&#34;]
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3a); // boundaryResources encodes an array literal
+
+      writeStyleResourceDependenciesInJS(destination, boundaryResources);
+    } else {
+      writeChunk(destination, completeBoundaryData3a);
+      writeStyleResourceDependenciesInAttr(destination, boundaryResources);
+    }
+  } else {
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3b);
+    }
+  }
+
+  let writeMore;
+
+  if (scriptFormat) {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryScriptEnd);
+  } else {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryDataEnd);
+  }
+
+  return writeBootstrap(destination, renderState, resumableState) && writeMore;
+}
+const clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
+const clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
+const clientRenderScript1A = stringToPrecomputedChunk('"');
+const clientRenderErrorScriptArgInterstitial = stringToPrecomputedChunk(',');
+const clientRenderScriptEnd = stringToPrecomputedChunk(')</script>');
+const clientRenderData1 = stringToPrecomputedChunk('<template data-rxi="" data-bid="');
+const clientRenderData2 = stringToPrecomputedChunk('" data-dgst="');
+const clientRenderData3 = stringToPrecomputedChunk('" data-msg="');
+const clientRenderData4 = stringToPrecomputedChunk('" data-stck="');
+const clientRenderDataEnd = dataElementQuotedEnd;
+function writeClientRenderBoundaryInstruction(destination, resumableState, renderState, id, errorDigest, errorMessage, errorComponentStack) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentClientRenderFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentClientRenderFunction;
+      writeChunk(destination, clientRenderScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, clientRenderScript1Partial);
+    }
+  } else {
+    // <template data-rxi="" data-bid="
+    writeChunk(destination, clientRenderData1);
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+
+  if (scriptFormat) {
+    // " needs to be inserted for scripts, since ArgInterstitual does not contain
+    // leading or trailing quotes
+    writeChunk(destination, clientRenderScript1A);
+  }
+
+  if (errorDigest || errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorDigest || '')));
+    } else {
+      // " data-dgst="HTMLString
+      writeChunk(destination, clientRenderData2);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest || '')));
+    }
+  }
+
+  if (errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorMessage || '')));
+    } else {
+      // " data-msg="HTMLString
+      writeChunk(destination, clientRenderData3);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorMessage || '')));
+    }
+  }
+
+  if (errorComponentStack) {
+    // ,"JSONString"
+    if (scriptFormat) {
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorComponentStack)));
+    } else {
+      // " data-stck="HTMLString
+      writeChunk(destination, clientRenderData4);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorComponentStack)));
+    }
+  }
+
+  if (scriptFormat) {
+    // ></script>
+    return writeChunkAndReturn(destination, clientRenderScriptEnd);
+  } else {
+    // "></template>
+    return writeChunkAndReturn(destination, clientRenderDataEnd);
+  }
+}
+const regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
+
+function escapeJSStringsForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInInstructionScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const regexForJSStringsInScripts = /[&><\u2028\u2029]/g;
+
+function escapeJSObjectForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '&':
+        return '\\u0026';
+
+      case '>':
+        return '\\u003e';
+
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const lateStyleTagResourceOpen1 = stringToPrecomputedChunk('<style media="not all" data-precedence="');
+const lateStyleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const lateStyleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const lateStyleTagTemplateClose = stringToPrecomputedChunk('</style>'); // Tracks whether the boundary currently flushing is flushign style tags or has any
+// stylesheet dependencies not flushed in the Preamble.
+
+let currentlyRenderingBoundaryHasStylesToHoist = false; // Acts as a return value for the forEach execution of style tag flushing.
+
+let destinationHasCapacity = true;
+
+function flushStyleTagsLateForBoundary(styleQueue) {
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs;
+
+  let i = 0;
+
+  if (hrefs.length) {
+    writeChunk(this, lateStyleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    writeChunk(this, lateStyleTagResourceOpen2);
+
+    for (; i < hrefs.length - 1; i++) {
+      writeChunk(this, hrefs[i]);
+      writeChunk(this, spaceSeparator);
+    }
+
+    writeChunk(this, hrefs[i]);
+    writeChunk(this, lateStyleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    destinationHasCapacity = writeChunkAndReturn(this, lateStyleTagTemplateClose); // We wrote style tags for this boundary and we may need to emit a script
+    // to hoist them.
+
+    currentlyRenderingBoundaryHasStylesToHoist = true; // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function hasStylesToHoist(stylesheet) {
+  // We need to reveal boundaries with styles whenever a stylesheet it depends on is either
+  // not flushed or flushed after the preamble (shell).
+  if (stylesheet.state !== PREAMBLE) {
+    currentlyRenderingBoundaryHasStylesToHoist = true;
+    return true;
+  }
+
+  return false;
+}
+
+function writeResourcesForBoundary(destination, boundaryResources, renderState) {
+  // Reset these on each invocation, they are only safe to read in this function
+  currentlyRenderingBoundaryHasStylesToHoist = false;
+  destinationHasCapacity = true; // Flush style tags for each precedence this boundary depends on
+
+  boundaryResources.styles.forEach(flushStyleTagsLateForBoundary, destination); // Determine if this boundary has stylesheets that need to be awaited upon completion
+
+  boundaryResources.stylesheets.forEach(hasStylesToHoist);
+
+  if (currentlyRenderingBoundaryHasStylesToHoist) {
+    renderState.stylesToHoist = true;
+  }
+
+  return destinationHasCapacity;
+}
+
+function flushResource(resource) {
+  for (let i = 0; i < resource.length; i++) {
+    writeChunk(this, resource[i]);
+  }
+
+  resource.length = 0;
+}
+
+const stylesheetFlushingQueue = [];
+
+function flushStyleInPreamble(stylesheet, key, map) {
+  // We still need to encode stylesheet chunks
+  // because unlike most Hoistables and Resources we do not eagerly encode
+  // them during render. This is because if we flush late we have to send a
+  // different encoding and we don't want to encode multiple times
+  pushLinkImpl(stylesheetFlushingQueue, stylesheet.props);
+
+  for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+    writeChunk(this, stylesheetFlushingQueue[i]);
+  }
+
+  stylesheetFlushingQueue.length = 0;
+  stylesheet.state = PREAMBLE;
+}
+
+const styleTagResourceOpen1 = stringToPrecomputedChunk('<style data-precedence="');
+const styleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const spaceSeparator = stringToPrecomputedChunk(' ');
+const styleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const styleTagResourceClose = stringToPrecomputedChunk('</style>');
+
+function flushStylesInPreamble(styleQueue, precedence) {
+  const hasStylesheets = styleQueue.sheets.size > 0;
+  styleQueue.sheets.forEach(flushStyleInPreamble, this);
+  styleQueue.sheets.clear();
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs; // If we don't emit any stylesheets at this precedence we still need to maintain the precedence
+  // order so even if there are no rules for style tags at this precedence we emit an empty style
+  // tag with the data-precedence attribute
+
+  if (!hasStylesheets || hrefs.length) {
+    writeChunk(this, styleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    let i = 0;
+
+    if (hrefs.length) {
+      writeChunk(this, styleTagResourceOpen2);
+
+      for (; i < hrefs.length - 1; i++) {
+        writeChunk(this, hrefs[i]);
+        writeChunk(this, spaceSeparator);
+      }
+
+      writeChunk(this, hrefs[i]);
+    }
+
+    writeChunk(this, styleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    writeChunk(this, styleTagResourceClose); // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function preloadLateStyle(stylesheet) {
+  if (stylesheet.state === PENDING$1) {
+    stylesheet.state = PRELOADED;
+    const preloadProps = preloadAsStylePropsFromProps(stylesheet.props.href, stylesheet.props);
+    pushLinkImpl(stylesheetFlushingQueue, preloadProps);
+
+    for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+      writeChunk(this, stylesheetFlushingQueue[i]);
+    }
+
+    stylesheetFlushingQueue.length = 0;
+  }
+}
+
+function preloadLateStyles(styleQueue) {
+  styleQueue.sheets.forEach(preloadLateStyle, this);
+  styleQueue.sheets.clear();
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+
+function writePreamble(destination, resumableState, renderState, willFlushAllSegments) {
+  // This function must be called exactly once on every request
+  if (!willFlushAllSegments && renderState.externalRuntimeScript) {
+    // If the root segment is incomplete due to suspended tasks
+    // (e.g. willFlushAllSegments = false) and we are using data
+    // streaming format, ensure the external runtime is sent.
+    // (User code could choose to send this even earlier by calling
+    //  preinit(...), if they know they will suspend).
+    const _renderState$external = renderState.externalRuntimeScript,
+          src = _renderState$external.src,
+          chunks = _renderState$external.chunks;
+    internalPreinitScript(resumableState, renderState, src, chunks);
+  }
+
+  const htmlChunks = renderState.htmlChunks;
+  const headChunks = renderState.headChunks;
+  let i = 0; // Emit open tags before Hoistables and Resources
+
+  if (htmlChunks) {
+    // We have an <html> to emit as part of the preamble
+    for (i = 0; i < htmlChunks.length; i++) {
+      writeChunk(destination, htmlChunks[i]);
+    }
+
+    if (headChunks) {
+      for (i = 0; i < headChunks.length; i++) {
+        writeChunk(destination, headChunks[i]);
+      }
+    } else {
+      // We did not render a head but we emitted an <html> so we emit one now
+      writeChunk(destination, startChunkForTag('head'));
+      writeChunk(destination, endOfStartTag);
+    }
+  } else if (headChunks) {
+    // We do not have an <html> but we do have a <head>
+    for (i = 0; i < headChunks.length; i++) {
+      writeChunk(destination, headChunks[i]);
+    }
+  } // Emit high priority Hoistables
+
+
+  const charsetChunks = renderState.charsetChunks;
+
+  for (i = 0; i < charsetChunks.length; i++) {
+    writeChunk(destination, charsetChunks[i]);
+  }
+
+  charsetChunks.length = 0; // emit preconnect resources
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Flush unblocked stylesheets by precedence
+
+  renderState.styles.forEach(flushStylesInPreamble, destination);
+  const importMapChunks = renderState.importMapChunks;
+
+  for (i = 0; i < importMapChunks.length; i++) {
+    writeChunk(destination, importMapChunks[i]);
+  }
+
+  importMapChunks.length = 0;
+  renderState.bootstrapScripts.forEach(flushResource, destination);
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0; // Flush closing head if necessary
+
+  if (htmlChunks && headChunks === null) {
+    // We have an <html> rendered but no <head> rendered. We however inserted
+    // a <head> up above so we need to emit the </head> now. This is safe because
+    // if the main content contained the </head> it would also have provided a
+    // <head>. This means that all the content inside <html> is either <body> or
+    // invalid HTML
+    writeChunk(destination, endChunkForTag('head'));
+  }
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+function writeHoistables(destination, resumableState, renderState) {
+  let i = 0; // Emit high priority Hoistables
+  // We omit charsetChunks because we have already sent the shell and if it wasn't
+  // already sent it is too late now.
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Preload any stylesheets. these will emit in a render instruction that follows this
+  // but we want to kick off preloading as soon as possible
+
+  renderState.styles.forEach(preloadLateStyles, destination); // We only hoist importmaps that are configured through createResponse and that will
+  // always flush in the preamble. Generally we don't expect people to render them as
+  // tags when using React but if you do they are going to be treated like regular inline
+  // scripts and flush after other hoistables which is problematic
+  // bootstrap scripts should flush above script priority but these can only flush in the preamble
+  // so we elide the code here for performance
+
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0;
+}
+function writePostamble(destination, resumableState) {
+  if (resumableState.hasBody) {
+    writeChunk(destination, endChunkForTag('body'));
+  }
+
+  if (resumableState.hasHtml) {
+    writeChunk(destination, endChunkForTag('html'));
+  }
+}
+const arrayFirstOpenBracket = stringToPrecomputedChunk('[');
+const arraySubsequentOpenBracket = stringToPrecomputedChunk(',[');
+const arrayInterstitial = stringToPrecomputedChunk(',');
+const arrayCloseBracket = stringToPrecomputedChunk(']'); // This function writes a 2D array of strings to be embedded in javascript.
+// E.g.
+//  [["JS_escaped_string1", "JS_escaped_string2"]]
+
+function writeStyleResourceDependenciesInJS(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInJS(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInJS(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInJS(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+}
+
+function writeStyleResourceDependencyInJS(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedPrecedence)));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          writeStyleResourceAttributeInJS(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInJS(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeName)));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeValue)));
+} // This function writes a 2D array of strings to be embedded in an attribute
+// value and read with JSON.parse in ReactDOMServerExternalRuntime.js
+// E.g.
+//  [[&quot;JSON_escaped_string1&quot;, &quot;JSON_escaped_string2&quot;]]
+
+
+function writeStyleResourceDependenciesInAttr(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInAttr(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInAttr(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInAttr(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+}
+
+function writeStyleResourceDependencyInAttr(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedPrecedence))));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          writeStyleResourceAttributeInAttr(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInAttr(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeName))));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeValue))));
+}
+/**
+ * Resources
+ */
+
+
+const PENDING$1 = 0;
+const PRELOADED = 1;
+const PREAMBLE = 2;
+const LATE = 3;
+function createBoundaryResources() {
+  return {
+    styles: new Set(),
+    stylesheets: new Set()
+  };
+}
+function setCurrentlyRenderingBoundaryResourcesTarget(renderState, boundaryResources) {
+  renderState.boundaryResources = boundaryResources;
+}
+
+function getResourceKey(href) {
+  return href;
+}
+
+function getImageResourceKey(href, imageSrcSet, imageSizes) {
+  if (imageSrcSet) {
+    return imageSrcSet + '\n' + (imageSizes || '');
+  }
+
+  return href;
+}
+
+function prefetchDNS(href) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const key = getResourceKey(href);
+
+    if (!resumableState.dnsResources.hasOwnProperty(key)) {
+      resumableState.dnsResources[key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPrefetchDNSAsHeader(href), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this as resettable in case we are prerendering and postpone in the Shell
+        renderState.resets.dns[key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        // Encode as element
+        const resource = [];
+        pushLinkImpl(resource, {
+          href,
+          rel: 'dns-prefetch'
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preconnect(href, crossOrigin) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const bucket = crossOrigin === 'use-credentials' ? 'credentials' : typeof crossOrigin === 'string' ? 'anonymous' : 'default';
+    const key = getResourceKey(href);
+
+    if (!resumableState.connectResources[bucket].hasOwnProperty(key)) {
+      resumableState.connectResources[bucket][key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPreconnectAsHeader(href, crossOrigin), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this in resettableState in case we are prerending and postpone in the Shell
+        renderState.resets.connect[bucket][key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        const resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preconnect',
+          href,
+          crossOrigin
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preload(href, as, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (as && href) {
+    switch (as) {
+      case 'image':
+        {
+          let imageSrcSet, imageSizes, fetchPriority;
+
+          if (options) {
+            imageSrcSet = options.imageSrcSet;
+            imageSizes = options.imageSizes;
+            fetchPriority = options.fetchPriority;
+          }
+
+          const key = getImageResourceKey(href, imageSrcSet, imageSizes);
+
+          if (resumableState.imageResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && fetchPriority === 'high' && ( // Compute the header since we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit a preload as a header so we
+            // track this to make sure we don't reset it.
+            renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+            if (headers.highImagePreloads) {
+              headers.highImagePreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.highImagePreloads += header;
+          } else {
+            // If we don't have headers to write to we have to encode as elements to flush in the head
+            // When we have imageSrcSet the browser probably cannot load the right version from headers
+            // (this should be verified by testing). For now we assume these need to go in the head
+            // as elements even if headers are available.
+            const resource = [];
+            pushLinkImpl(resource, assign({
+              rel: 'preload',
+              // There is a bug in Safari where imageSrcSet is not respected on preload links
+              // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+              // This harms older browers that do not support imageSrcSet by making their preloads not work
+              // but this population is shrinking fast and is already small so we accept this tradeoff.
+              href: imageSrcSet ? undefined : href,
+              as
+            }, options));
+
+            if (fetchPriority === 'high') {
+              renderState.highImagePreloads.add(resource);
+            } else {
+              renderState.bulkPreloads.add(resource); // Stash the resource in case we need to promote it to higher priority
+              // when an img tag is rendered
+
+              renderState.preloads.images.set(key, resource);
+            }
+          }
+
+          break;
+        }
+
+      case 'style':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.styleResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.styleResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.stylesheets.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          break;
+        }
+
+      case 'script':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.scriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          renderState.preloads.scripts.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.scriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          break;
+        }
+
+      default:
+        {
+          const key = getResourceKey(href);
+          const hasAsType = resumableState.unknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.unknownResources[as] = resources;
+          }
+
+          resources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && as === 'font' && ( // We compute the header here because we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit this preload so we
+            // track it here to prevent it from being reset.
+            renderState.resets.font[key] = PRELOAD_NO_CREDS;
+
+            if (headers.fontPreloads) {
+              headers.fontPreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.fontPreloads += header;
+          } else {
+            // We either don't have headers or we are preloading something that does
+            // not warrant elevated priority so we encode as an element.
+            const resource = [];
+
+            const props = assign({
+              rel: 'preload',
+              href,
+              as
+            }, options);
+
+            pushLinkImpl(resource, props);
+
+            switch (as) {
+              case 'font':
+                renderState.fontPreloads.add(resource);
+                break;
+              // intentional fall through
+
+              default:
+                renderState.bulkPreloads.add(resource);
+            }
+          }
+        }
+    } // If we got this far we created a new resource
+
+
+    flushResources(request);
+  }
+}
+
+function preloadModule(href, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    const key = getResourceKey(href);
+    const as = options && typeof options.as === 'string' ? options.as : 'script';
+    let resource;
+
+    switch (as) {
+      case 'script':
+        {
+          if (resumableState.moduleScriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resource = [];
+          resumableState.moduleScriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.moduleScripts.set(key, resource);
+          break;
+        }
+
+      default:
+        {
+          const hasAsType = resumableState.moduleUnknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.moduleUnknownResources[as] = resources;
+          }
+
+          resource = [];
+          resources[key] = PRELOAD_NO_CREDS;
+        }
+    }
+
+    pushLinkImpl(resource, assign({
+      rel: 'modulepreload',
+      href
+    }, options));
+    renderState.bulkPreloads.add(resource); // If we got this far we created a new resource
+
+    flushResources(request);
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    precedence = precedence || 'default';
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+      // to create a StyleQueue
+
+      if (!styleQueue) {
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      }
+
+      const resource = {
+        state: PENDING$1,
+        props: assign({
+          rel: 'stylesheet',
+          href,
+          'data-precedence': precedence
+        }, options)
+      };
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(resource.props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.stylesheets.get(key);
+
+        if (preloadResource && preloadResource.length > 0) {
+          // The Preload for this resource was created in this render pass and has not flushed yet so
+          // we need to clear it to avoid it flushing.
+          preloadResource.length = 0;
+        } else {
+          // Either the preload resource from this render already flushed in this render pass
+          // or the preload flushed in a prior pass (prerender). In either case we need to mark
+          // this resource as already having been preloaded.
+          resource.state = PRELOADED;
+        }
+      } // We add the newly created resource to our StyleQueue and if necessary
+      // track the resource with the currently rendering boundary
+
+
+      styleQueue.sheets.set(key, resource); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+  }
+}
+
+function preinitScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.scriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.scriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.scriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.scripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+}
+
+function preinitModuleScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.moduleScriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.moduleScriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.moduleScriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        type: 'module',
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.moduleScripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+} // This function is only safe to call at Request start time since it assumes
+// that each module has not already been preloaded. If we find a need to preload
+// scripts at any other point in time we will need to check whether the preload
+// already exists and not assume it
+
+
+function preloadBootstrapScriptOrModule(resumableState, renderState, href, props) {
+
+  const key = getResourceKey(href);
+  // used to preinit the resource. If a script can be preinited then it shouldn't
+  // be a bootstrap script/module and if it is a bootstrap script/module then it
+  // must not be safe to emit early. To avoid possibly allowing for preinits of
+  // bootstrap scripts/modules we occlude these keys.
+
+
+  resumableState.scriptResources[key] = EXISTS;
+  resumableState.moduleScriptResources[key] = EXISTS;
+  const resource = [];
+  pushLinkImpl(resource, props);
+  renderState.bootstrapScripts.add(resource);
+}
+
+function internalPreinitScript(resumableState, renderState, src, chunks) {
+  const key = getResourceKey(src);
+
+  if (!resumableState.scriptResources.hasOwnProperty(key)) {
+    const resource = chunks;
+    resumableState.scriptResources[key] = EXISTS;
+    renderState.scripts.add(resource);
+  }
+
+  return;
+}
+
+function preloadAsStylePropsFromProps(href, props) {
+  return {
+    rel: 'preload',
+    as: 'style',
+    href: href,
+    crossOrigin: props.crossOrigin,
+    fetchPriority: props.fetchPriority,
+    integrity: props.integrity,
+    media: props.media,
+    hrefLang: props.hrefLang,
+    referrerPolicy: props.referrerPolicy
+  };
+}
+
+function stylesheetPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    'data-precedence': rawProps.precedence,
+    precedence: null
+  });
+}
+
+function adoptPreloadCredentials(target, preloadState) {
+  if (target.crossOrigin == null) target.crossOrigin = preloadState[0];
+  if (target.integrity == null) target.integrity = preloadState[1];
+}
+
+function getPrefetchDNSAsHeader(href) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  return "<" + escapedHref + ">; rel=dns-prefetch";
+}
+
+function getPreconnectAsHeader(href, crossOrigin) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  let value = "<" + escapedHref + ">; rel=preconnect";
+
+  if (typeof crossOrigin === 'string') {
+    const escapedCrossOrigin = escapeStringForLinkHeaderQuotedParamValueContext(crossOrigin);
+    value += "; crossorigin=\"" + escapedCrossOrigin + "\"";
+  }
+
+  return value;
+}
+
+function getPreloadAsHeader(href, as, params) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  const escapedAs = escapeStringForLinkHeaderQuotedParamValueContext(as);
+  let value = "<" + escapedHref + ">; rel=preload; as=\"" + escapedAs + "\"";
+
+  for (const paramName in params) {
+    if (hasOwnProperty.call(params, paramName)) {
+      const paramValue = params[paramName];
+
+      if (typeof paramValue === 'string') {
+        value += "; " + paramName.toLowerCase() + "=\"" + escapeStringForLinkHeaderQuotedParamValueContext(paramValue) + "\"";
+      }
+    }
+  }
+
+  return value;
+}
+
+function getStylesheetPreloadAsHeader(stylesheet) {
+  const props = stylesheet.props;
+  const preloadOptions = {
+    crossOrigin: props.crossOrigin,
+    integrity: props.integrity,
+    nonce: props.nonce,
+    type: props.type,
+    fetchPriority: props.fetchPriority,
+    referrerPolicy: props.referrerPolicy,
+    media: props.media
+  };
+  return getPreloadAsHeader(props.href, 'style', preloadOptions);
+} // This escaping function is only safe to use for href values being written into
+// a "Link" header in between `<` and `>` characters. The primary concern with the href is
+// to escape the bounding characters as well as new lines. This is unsafe to use in any other
+// context
+
+
+const regexForHrefInLinkHeaderURLContext = /[<>\r\n]/g;
+
+function escapeHrefForLinkHeaderURLContext(hrefInput) {
+
+  const coercedHref = '' + hrefInput;
+  return coercedHref.replace(regexForHrefInLinkHeaderURLContext, escapeHrefForLinkHeaderURLContextReplacer);
+}
+
+function escapeHrefForLinkHeaderURLContextReplacer(match) {
+  switch (match) {
+    case '<':
+      return '%3C';
+
+    case '>':
+      return '%3E';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeLinkHrefForHeaderContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+} // This escaping function is only safe to use for quoted param values in an HTTP header.
+// It is unsafe to use for any value not inside quote marks in parater value position.
+
+
+const regexForLinkHeaderQuotedParamValueContext = /["';,\r\n]/g;
+
+function escapeStringForLinkHeaderQuotedParamValueContext(value, name) {
+
+  const coerced = '' + value;
+  return coerced.replace(regexForLinkHeaderQuotedParamValueContext, escapeStringForLinkHeaderQuotedParamValueContextReplacer);
+}
+
+function escapeStringForLinkHeaderQuotedParamValueContextReplacer(match) {
+  switch (match) {
+    case '"':
+      return '%22';
+
+    case "'":
+      return '%27';
+
+    case ';':
+      return '%3B';
+
+    case ',':
+      return '%2C';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeStringForLinkHeaderQuotedParamValueContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+}
+
+function hoistStyleQueueDependency(styleQueue) {
+  this.styles.add(styleQueue);
+}
+
+function hoistStylesheetDependency(stylesheet) {
+  this.stylesheets.add(stylesheet);
+}
+
+function hoistResources(renderState, source) {
+  const currentBoundaryResources = renderState.boundaryResources;
+
+  if (currentBoundaryResources) {
+    source.styles.forEach(hoistStyleQueueDependency, currentBoundaryResources);
+    source.stylesheets.forEach(hoistStylesheetDependency, currentBoundaryResources);
+  }
+} // This function is called at various times depending on whether we are rendering
+// or prerendering. In this implementation we only actually emit headers once and
+// subsequent calls are ignored. We track whether the request has a completed shell
+// to determine whether we will follow headers with a flush including stylesheets.
+// In the context of prerrender we don't have a completed shell when the request finishes
+// with a postpone in the shell. In the context of a render we don't have a completed shell
+// if this is called before the shell finishes rendering which usually will happen anytime
+// anything suspends in the shell.
+
+function emitEarlyPreloads(renderState, resumableState, shellComplete) {
+  const onHeaders = renderState.onHeaders;
+
+  if (onHeaders) {
+    const headers = renderState.headers;
+
+    if (headers) {
+      let linkHeader = headers.preconnects;
+
+      if (headers.fontPreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.fontPreloads;
+      }
+
+      if (headers.highImagePreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.highImagePreloads;
+      }
+
+      if (!shellComplete) {
+        // We use raw iterators because we want to be able to halt iteration
+        // We could refactor renderState to store these dually in arrays to
+        // make this more efficient at the cost of additional memory and
+        // write overhead. However this code only runs once per request so
+        // for now I consider this sufficient.
+        const queueIter = renderState.styles.values();
+
+        outer: for (let queueStep = queueIter.next(); headers.remainingCapacity > 0 && !queueStep.done; queueStep = queueIter.next()) {
+          const sheets = queueStep.value.sheets;
+          const sheetIter = sheets.values();
+
+          for (let sheetStep = sheetIter.next(); headers.remainingCapacity > 0 && !sheetStep.done; sheetStep = sheetIter.next()) {
+            const sheet = sheetStep.value;
+            const props = sheet.props;
+            const key = getResourceKey(props.href);
+            const header = getStylesheetPreloadAsHeader(sheet); // We mutate the capacity b/c we don't want to keep checking if later headers will fit.
+            // This means that a particularly long header might close out the header queue where later
+            // headers could still fit. We could in the future alter the behavior here based on prerender vs render
+            // since during prerender we aren't as concerned with pure runtime performance.
+
+            if ((headers.remainingCapacity -= header.length) >= 2) {
+              renderState.resets.style[key] = PRELOAD_NO_CREDS;
+
+              if (linkHeader) {
+                linkHeader += ', ';
+              }
+
+              linkHeader += header; // We already track that the resource exists in resumableState however
+              // if the resumableState resets because we postponed in the shell
+              // which is what is happening in this branch if we are prerendering
+              // then we will end up resetting the resumableState. When it resets we
+              // want to record the fact that this stylesheet was already preloaded
+
+              renderState.resets.style[key] = typeof props.crossOrigin === 'string' || typeof props.integrity === 'string' ? [props.crossOrigin, props.integrity] : PRELOAD_NO_CREDS;
+            } else {
+              break outer;
+            }
+          }
+        }
+      }
+
+      if (linkHeader) {
+        onHeaders({
+          Link: linkHeader
+        });
+      } else {
+        // We still call this with no headers because a user may be using it as a signal that
+        // it React will not provide any headers
+        onHeaders({});
+      }
+
+      renderState.headers = null;
+      return;
+    }
+  }
+}
+const NotPendingTransition = NotPending;
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+const REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_CONTEXT_TYPE = Symbol.for('react.context');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SCOPE_TYPE = Symbol.for('react.scope');
+const REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');
+const REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+const REACT_LEGACY_HIDDEN_TYPE = Symbol.for('react.legacy_hidden');
+const REACT_CACHE_TYPE = Symbol.for('react.cache');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+function getWrappedName(outerType, innerType, wrapperName) {
+  const displayName = outerType.displayName;
+
+  if (displayName) {
+    return displayName;
+  }
+
+  const functionName = innerType.displayName || innerType.name || '';
+  return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
+} // Keep in sync with react-reconciler/getComponentNameFromFiber
+
+
+function getContextName(type) {
+  return type.displayName || 'Context';
+} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+
+function getComponentNameFromType(type) {
+  if (type == null) {
+    // Host root, text node or just invalid type.
+    return null;
+  }
+
+  if (typeof type === 'function') {
+    return type.displayName || type.name || null;
+  }
+
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_FRAGMENT_TYPE:
+      return 'Fragment';
+
+    case REACT_PORTAL_TYPE:
+      return 'Portal';
+
+    case REACT_PROFILER_TYPE:
+      return 'Profiler';
+
+    case REACT_STRICT_MODE_TYPE:
+      return 'StrictMode';
+
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+
+    case REACT_CACHE_TYPE:
+      {
+        return 'Cache';
+      }
+
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        const context = type;
+        return getContextName(context) + '.Consumer';
+
+      case REACT_PROVIDER_TYPE:
+        const provider = type;
+        return getContextName(provider._context) + '.Provider';
+
+      case REACT_FORWARD_REF_TYPE:
+        return getWrappedName(type, type.render, 'ForwardRef');
+
+      case REACT_MEMO_TYPE:
+        const outerName = type.displayName || null;
+
+        if (outerName !== null) {
+          return outerName;
+        }
+
+        return getComponentNameFromType(type.type) || 'Memo';
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            return getComponentNameFromType(init(payload));
+          } catch (x) {
+            return null;
+          }
+        }
+
+      case REACT_SERVER_CONTEXT_TYPE:
+        {
+          const context2 = type;
+          return (context2.displayName || context2._globalName) + '.Provider';
+        }
+
+    }
+  }
+
+  return null;
+}
+
+const emptyContextObject = {};
+
+function getMaskedContext(type, unmaskedContext) {
+  {
+    const contextTypes = type.contextTypes;
+
+    if (!contextTypes) {
+      return emptyContextObject;
+    }
+
+    const context = {};
+
+    for (const key in contextTypes) {
+      context[key] = unmaskedContext[key];
+    }
+
+    return context;
+  }
+}
+function processChildContext(instance, type, parentContext, childContextTypes) {
+  {
+    // TODO (bvaughn) Replace this behavior with an invariant() in the future.
+    // It has only been added in Fiber to match the (unintentional) behavior in Stack.
+    if (typeof instance.getChildContext !== 'function') {
+
+      return parentContext;
+    }
+
+    const childContext = instance.getChildContext();
+
+    for (const contextKey in childContext) {
+      if (!(contextKey in childContextTypes)) {
+        throw new Error((getComponentNameFromType(type) || 'Unknown') + ".getChildContext(): key \"" + contextKey + "\" is not defined in childContextTypes.");
+      }
+    }
+
+    return assign({}, parentContext, childContext);
+  }
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext);
+    } // On the way back, we push the new ones that weren't common.
+
+
+    pushNode(next);
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function pushProvider(context, nextValue) {
+  let prevValue;
+
+  {
+    prevValue = context._currentValue;
+    context._currentValue = nextValue;
+  }
+
+  const prevNode = currentActiveSnapshot;
+  const newNode = {
+    parent: prevNode,
+    depth: prevNode === null ? 0 : prevNode.depth + 1,
+    context: context,
+    parentValue: prevValue,
+    value: nextValue
+  };
+  currentActiveSnapshot = newNode;
+  return newNode;
+}
+function popProvider(context) {
+  const prevSnapshot = currentActiveSnapshot;
+
+  if (prevSnapshot === null) {
+    throw new Error('Tried to pop a Context at the root of the app. This is a bug in React.');
+  }
+
+  {
+    const value = prevSnapshot.parentValue;
+
+    if (value === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      prevSnapshot.context._currentValue = prevSnapshot.context._defaultValue;
+    } else {
+      prevSnapshot.context._currentValue = value;
+    }
+  }
+
+  return currentActiveSnapshot = prevSnapshot.parent;
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+/**
+ * `ReactInstanceMap` maintains a mapping from a public facing stateful
+ * instance (key) and the internal representation (value). This allows public
+ * methods to accept the user facing instance as an argument and map them back
+ * to internal methods.
+ *
+ * Note that this module is currently shared and assumed to be stateless.
+ * If this becomes an actual Map, that will break.
+ */
+function get(key) {
+  return key._reactInternals;
+}
+function set(key, value) {
+  key._reactInternals = value;
+}
+
+const classComponentUpdater = {
+  isMounted(inst) {
+    return false;
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueSetState(inst, payload, callback) {
+    const internals = get(inst);
+
+    if (internals.queue === null) ; else {
+      internals.queue.push(payload);
+    }
+  },
+
+  enqueueReplaceState(inst, payload, callback) {
+    const internals = get(inst);
+    internals.replace = true;
+    internals.queue = [payload];
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueForceUpdate(inst, callback) {
+  }
+
+};
+
+function applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, prevState, nextProps) {
+  const partialState = getDerivedStateFromProps(nextProps, prevState);
+
+
+  const newState = partialState === null || partialState === undefined ? prevState : assign({}, prevState, partialState);
+  return newState;
+}
+
+function constructClassInstance(ctor, props, maskedLegacyContext) {
+  let context = emptyContextObject;
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    context = readContext$1(contextType);
+  } else {
+    context = maskedLegacyContext;
+  }
+
+  const instance = new ctor(props, context);
+
+  return instance;
+}
+
+function callComponentWillMount(type, instance) {
+  const oldState = instance.state;
+
+  if (typeof instance.componentWillMount === 'function') {
+
+    instance.componentWillMount();
+  }
+
+  if (typeof instance.UNSAFE_componentWillMount === 'function') {
+    instance.UNSAFE_componentWillMount();
+  }
+
+  if (oldState !== instance.state) {
+
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+}
+
+function processUpdateQueue(internalInstance, inst, props, maskedLegacyContext) {
+  if (internalInstance.queue !== null && internalInstance.queue.length > 0) {
+    const oldQueue = internalInstance.queue;
+    const oldReplace = internalInstance.replace;
+    internalInstance.queue = null;
+    internalInstance.replace = false;
+
+    if (oldReplace && oldQueue.length === 1) {
+      inst.state = oldQueue[0];
+    } else {
+      let nextState = oldReplace ? oldQueue[0] : inst.state;
+      let dontMutate = true;
+
+      for (let i = oldReplace ? 1 : 0; i < oldQueue.length; i++) {
+        const partial = oldQueue[i];
+        const partialState = typeof partial === 'function' ? partial.call(inst, nextState, props, maskedLegacyContext) : partial;
+
+        if (partialState != null) {
+          if (dontMutate) {
+            dontMutate = false;
+            nextState = assign({}, nextState, partialState);
+          } else {
+            assign(nextState, partialState);
+          }
+        }
+      }
+
+      inst.state = nextState;
+    }
+  } else {
+    internalInstance.queue = null;
+  }
+} // Invokes the mount life-cycles on a previously never rendered instance.
+
+
+function mountClassInstance(instance, ctor, newProps, maskedLegacyContext) {
+
+  const initialState = instance.state !== undefined ? instance.state : null;
+  instance.updater = classComponentUpdater;
+  instance.props = newProps;
+  instance.state = initialState; // We don't bother initializing the refs object on the server, since we're not going to resolve them anyway.
+  // The internal instance will be used to manage updates that happen during this mount.
+
+  const internalInstance = {
+    queue: [],
+    replace: false
+  };
+  set(instance, internalInstance);
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    instance.context = readContext$1(contextType);
+  } else {
+    instance.context = maskedLegacyContext;
+  }
+
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    instance.state = applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, initialState, newProps);
+  } // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+
+  if (typeof ctor.getDerivedStateFromProps !== 'function' && typeof instance.getSnapshotBeforeUpdate !== 'function' && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
+    callComponentWillMount(ctor, instance); // If we had additional state updates during this life-cycle, let's
+    // process them now.
+
+    processUpdateQueue(internalInstance, instance, newProps, maskedLegacyContext);
+  }
+}
+
+// Ids are base 32 strings whose binary representation corresponds to the
+// position of a node in a tree.
+// Every time the tree forks into multiple children, we add additional bits to
+// the left of the sequence that represent the position of the child within the
+// current level of children.
+//
+//      00101       00010001011010101
+//      ╰─┬─╯       ╰───────┬───────╯
+//   Fork 5 of 20       Parent id
+//
+// The leading 0s are important. In the above example, you only need 3 bits to
+// represent slot 5. However, you need 5 bits to represent all the forks at
+// the current level, so we must account for the empty bits at the end.
+//
+// For this same reason, slots are 1-indexed instead of 0-indexed. Otherwise,
+// the zeroth id at a level would be indistinguishable from its parent.
+//
+// If a node has only one child, and does not materialize an id (i.e. does not
+// contain a useId hook), then we don't need to allocate any space in the
+// sequence. It's treated as a transparent indirection. For example, these two
+// trees produce the same ids:
+//
+// <>                          <>
+//   <Indirection>               <A />
+//     <A />                     <B />
+//   </Indirection>            </>
+//   <B />
+// </>
+//
+// However, we cannot skip any node that materializes an id. Otherwise, a parent
+// id that does not fork would be indistinguishable from its child id. For
+// example, this tree does not fork, but the parent and child must have
+// different ids.
+//
+// <Parent>
+//   <Child />
+// </Parent>
+//
+// To handle this scenario, every time we materialize an id, we allocate a
+// new level with a single slot. You can think of this as a fork with only one
+// prong, or an array of children with length 1.
+//
+// It's possible for the size of the sequence to exceed 32 bits, the max
+// size for bitwise operations. When this happens, we make more room by
+// converting the right part of the id to a string and storing it in an overflow
+// variable. We use a base 32 string representation, because 32 is the largest
+// power of 2 that is supported by toString(). We want the base to be large so
+// that the resulting ids are compact, and we want the base to be a power of 2
+// because every log2(base) bits corresponds to a single character, i.e. every
+// log2(32) = 5 bits. That means we can lop bits off the end 5 at a time without
+// affecting the final result.
+const emptyTreeContext = {
+  id: 1,
+  overflow: ''
+};
+function getTreeId(context) {
+  const overflow = context.overflow;
+  const idWithLeadingBit = context.id;
+  const id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
+  return id.toString(32) + overflow;
+}
+function pushTreeContext(baseContext, totalChildren, index) {
+  const baseIdWithLeadingBit = baseContext.id;
+  const baseOverflow = baseContext.overflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
+  // of the id; we use it to account for leading 0s.
+
+  const baseLength = getBitLength(baseIdWithLeadingBit) - 1;
+  const baseId = baseIdWithLeadingBit & ~(1 << baseLength);
+  const slot = index + 1;
+  const length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
+  // consideration the leading 1 we use to mark the end of the sequence.
+
+  if (length > 30) {
+    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
+    // This branch assumes the length of the base id is greater than 5; it won't
+    // work for smaller ids, because you need 5 bits per character.
+    //
+    // We encode the id in multiple steps: first the base id, then the
+    // remaining digits.
+    //
+    // Each 5 bit sequence corresponds to a single base 32 character. So for
+    // example, if the current id is 23 bits long, we can convert 20 of those
+    // bits into a string of 4 characters, with 3 bits left over.
+    //
+    // First calculate how many bits in the base id represent a complete
+    // sequence of characters.
+    const numberOfOverflowBits = baseLength - baseLength % 5; // Then create a bitmask that selects only those bits.
+
+    const newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
+
+    const newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
+
+    const restOfBaseId = baseId >> numberOfOverflowBits;
+    const restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
+    // we made more room, this time it won't overflow.
+
+    const restOfLength = getBitLength(totalChildren) + restOfBaseLength;
+    const restOfNewBits = slot << restOfBaseLength;
+    const id = restOfNewBits | restOfBaseId;
+    const overflow = newOverflow + baseOverflow;
+    return {
+      id: 1 << restOfLength | id,
+      overflow
+    };
+  } else {
+    // Normal path
+    const newBits = slot << baseLength;
+    const id = newBits | baseId;
+    const overflow = baseOverflow;
+    return {
+      id: 1 << length | id,
+      overflow
+    };
+  }
+}
+
+function getBitLength(number) {
+  return 32 - clz32(number);
+}
+
+function getLeadingBit(id) {
+  return 1 << getBitLength(id) - 1;
+} // TODO: Math.clz32 is supported in Node 12+. Maybe we can drop the fallback.
+
+
+const 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
+
+const log = Math.log;
+const LN2 = Math.LN2;
+
+function clz32Fallback(x) {
+  const asUint = x >>> 0;
+
+  if (asUint === 0) {
+    return 32;
+  }
+
+  return 31 - (log(asUint) / LN2 | 0) | 0;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFlightWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop$2() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop$2, noop$2);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+
+const objectIs = // $FlowFixMe[method-unbinding]
+typeof Object.is === 'function' ? Object.is : is;
+
+let currentlyRenderingComponent = null;
+let currentlyRenderingTask = null;
+let currentlyRenderingRequest = null;
+let currentlyRenderingKeyPath = null;
+let firstWorkInProgressHook = null;
+let workInProgressHook = null; // Whether the work-in-progress hook is a re-rendered hook
+
+let isReRender = false; // Whether an update was scheduled during the currently executing render pass.
+
+let didScheduleRenderPhaseUpdate = false; // Counts the number of useId hooks in this component
+
+let localIdCounter = 0; // Chunks that should be pushed to the stream once the component
+// finishes rendering.
+// Counts the number of useFormState calls in this component
+
+let formStateCounter = 0; // The index of the useFormState hook that matches the one passed in at the
+// root during an MPA navigation, if any.
+
+let formStateMatchingIndex = -1; // Counts the number of use(thenable) calls in this component
+
+let thenableIndexCounter = 0;
+let thenableState = null; // Lazily created map of render-phase updates
+
+let renderPhaseUpdates = null; // Counter to prevent infinite loops.
+
+let numberOfReRenders = 0;
+const RE_RENDER_LIMIT = 25;
+
+function resolveCurrentlyRenderingComponent() {
+  if (currentlyRenderingComponent === null) {
+    throw new Error('Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for' + ' one of the following reasons:\n' + '1. You might have mismatching versions of React and the renderer (such as React DOM)\n' + '2. You might be breaking the Rules of Hooks\n' + '3. You might have more than one copy of React in the same app\n' + 'See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.');
+  }
+
+  return currentlyRenderingComponent;
+}
+
+function areHookInputsEqual(nextDeps, prevDeps) {
+  if (prevDeps === null) {
+
+    return false;
+  }
+
+
+  for (let i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    if (objectIs(nextDeps[i], prevDeps[i])) {
+      continue;
+    }
+
+    return false;
+  }
+
+  return true;
+}
+
+function createHook() {
+  if (numberOfReRenders > 0) {
+    throw new Error('Rendered more hooks than during the previous render');
+  }
+
+  return {
+    memoizedState: null,
+    queue: null,
+    next: null
+  };
+}
+
+function createWorkInProgressHook() {
+  if (workInProgressHook === null) {
+    // This is the first hook in the list
+    if (firstWorkInProgressHook === null) {
+      isReRender = false;
+      firstWorkInProgressHook = workInProgressHook = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = firstWorkInProgressHook;
+    }
+  } else {
+    if (workInProgressHook.next === null) {
+      isReRender = false; // Append to the end of the list
+
+      workInProgressHook = workInProgressHook.next = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = workInProgressHook.next;
+    }
+  }
+
+  return workInProgressHook;
+}
+
+function prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState) {
+  currentlyRenderingComponent = componentIdentity;
+  currentlyRenderingTask = task;
+  currentlyRenderingRequest = request;
+  currentlyRenderingKeyPath = keyPath;
+  // didScheduleRenderPhaseUpdate = false;
+  // firstWorkInProgressHook = null;
+  // numberOfReRenders = 0;
+  // renderPhaseUpdates = null;
+  // workInProgressHook = null;
+
+
+  localIdCounter = 0;
+  formStateCounter = 0;
+  formStateMatchingIndex = -1;
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function finishHooks(Component, props, children, refOrContext) {
+  // This must be called after every function component to prevent hooks from
+  // being used in classes.
+  while (didScheduleRenderPhaseUpdate) {
+    // Updates were scheduled during the render phase. They are stored in
+    // the `renderPhaseUpdates` map. Call the component again, reusing the
+    // work-in-progress hooks and applying the additional updates on top. Keep
+    // restarting until no more updates are scheduled.
+    didScheduleRenderPhaseUpdate = false;
+    localIdCounter = 0;
+    formStateCounter = 0;
+    formStateMatchingIndex = -1;
+    thenableIndexCounter = 0;
+    numberOfReRenders += 1; // Start over from the beginning of the list
+
+    workInProgressHook = null;
+    children = Component(props, refOrContext);
+  }
+
+  resetHooksState();
+  return children;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+function checkDidRenderIdHook() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  const didRenderIdHook = localIdCounter !== 0;
+  return didRenderIdHook;
+}
+function getFormStateCount() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateCounter;
+}
+function getFormStateMatchingIndex() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateMatchingIndex;
+} // Reset the internal hooks state if an error occurs while rendering a component
+
+function resetHooksState() {
+
+  currentlyRenderingComponent = null;
+  currentlyRenderingTask = null;
+  currentlyRenderingRequest = null;
+  currentlyRenderingKeyPath = null;
+  didScheduleRenderPhaseUpdate = false;
+  firstWorkInProgressHook = null;
+  numberOfReRenders = 0;
+  renderPhaseUpdates = null;
+  workInProgressHook = null;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+function useContext(context) {
+
+  resolveCurrentlyRenderingComponent();
+  return readContext$1(context);
+}
+
+function basicStateReducer(state, action) {
+  // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
+  return typeof action === 'function' ? action(state) : action;
+}
+
+function useState(initialState) {
+
+  return useReducer(basicStateReducer, // useReducer has a special case to support lazy useState initializers
+  initialState);
+}
+function useReducer(reducer, initialArg, init) {
+
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+
+  if (isReRender) {
+    // This is a re-render. Apply the new render phase updates to the previous
+    // current hook.
+    const queue = workInProgressHook.queue;
+    const dispatch = queue.dispatch;
+
+    if (renderPhaseUpdates !== null) {
+      // Render phase updates are stored in a map of queue -> linked list
+      const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+      if (firstRenderPhaseUpdate !== undefined) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        renderPhaseUpdates.delete(queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+        let newState = workInProgressHook.memoizedState;
+        let update = firstRenderPhaseUpdate;
+
+        do {
+          // Process this render phase update. We don't have to check the
+          // priority because it will always be the same as the current
+          // render's.
+          const action = update.action;
+
+          newState = reducer(newState, action);
+
+
+          update = update.next;
+        } while (update !== null); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+        workInProgressHook.memoizedState = newState;
+        return [newState, dispatch];
+      }
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    return [workInProgressHook.memoizedState, dispatch];
+  } else {
+
+    let initialState;
+
+    if (reducer === basicStateReducer) {
+      // Special case for `useState`.
+      initialState = typeof initialArg === 'function' ? initialArg() : initialArg;
+    } else {
+      initialState = init !== undefined ? init(initialArg) : initialArg;
+    }
+
+
+    workInProgressHook.memoizedState = initialState; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    const queue = workInProgressHook.queue = {
+      last: null,
+      dispatch: null
+    };
+    const dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingComponent, queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    return [workInProgressHook.memoizedState, dispatch];
+  }
+}
+
+function useMemo(nextCreate, deps) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+
+  if (workInProgressHook !== null) {
+    const prevState = workInProgressHook.memoizedState;
+
+    if (prevState !== null) {
+      if (nextDeps !== null) {
+        const prevDeps = prevState[1];
+
+        if (areHookInputsEqual(nextDeps, prevDeps)) {
+          return prevState[0];
+        }
+      }
+    }
+  }
+
+  const nextValue = nextCreate();
+
+
+  workInProgressHook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
+
+function useRef(initialValue) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const previousRef = workInProgressHook.memoizedState;
+
+  if (previousRef === null) {
+    const ref = {
+      current: initialValue
+    };
+
+
+    workInProgressHook.memoizedState = ref;
+    return ref;
+  } else {
+    return previousRef;
+  }
+}
+
+function dispatchAction(componentIdentity, queue, action) {
+  if (numberOfReRenders >= RE_RENDER_LIMIT) {
+    throw new Error('Too many re-renders. React limits the number of renders to prevent ' + 'an infinite loop.');
+  }
+
+  if (componentIdentity === currentlyRenderingComponent) {
+    // This is a render phase update. Stash it in a lazily-created map of
+    // queue -> linked list of updates. After this render pass, we'll restart
+    // and apply the stashed updates on top of the work-in-progress hook.
+    didScheduleRenderPhaseUpdate = true;
+    const update = {
+      action,
+      next: null
+    };
+
+    if (renderPhaseUpdates === null) {
+      renderPhaseUpdates = new Map();
+    }
+
+    const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+    if (firstRenderPhaseUpdate === undefined) {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      renderPhaseUpdates.set(queue, update);
+    } else {
+      // Append the update to the end of the list.
+      let lastRenderPhaseUpdate = firstRenderPhaseUpdate;
+
+      while (lastRenderPhaseUpdate.next !== null) {
+        lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+      }
+
+      lastRenderPhaseUpdate.next = update;
+    }
+  }
+}
+
+function useCallback(callback, deps) {
+  return useMemo(() => callback, deps);
+}
+
+function throwOnUseEffectEventCall() {
+  throw new Error("A function wrapped in useEffectEvent can't be called during rendering.");
+}
+
+function useEffectEvent(callback) {
+  // $FlowIgnore[incompatible-return]
+  return throwOnUseEffectEventCall;
+}
+
+function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  if (getServerSnapshot === undefined) {
+    throw new Error('Missing getServerSnapshot, which is required for ' + 'server-rendered content. Will revert to client rendering.');
+  }
+
+  return getServerSnapshot();
+}
+
+function useDeferredValue(value, initialValue) {
+  resolveCurrentlyRenderingComponent();
+
+  {
+    return initialValue !== undefined ? initialValue : value;
+  }
+}
+
+function unsupportedStartTransition() {
+  throw new Error('startTransition cannot be called during server rendering.');
+}
+
+function useTransition() {
+  resolveCurrentlyRenderingComponent();
+  return [false, unsupportedStartTransition];
+}
+
+function useHostTransitionStatus() {
+  resolveCurrentlyRenderingComponent();
+  return NotPendingTransition;
+}
+
+function unsupportedSetOptimisticState() {
+  throw new Error('Cannot update optimistic state while rendering.');
+}
+
+function useOptimistic(passthrough, reducer) {
+  resolveCurrentlyRenderingComponent();
+  return [passthrough, unsupportedSetOptimisticState];
+}
+
+function createPostbackFormStateKey(permalink, componentKeyPath, hookIndex) {
+  if (permalink !== undefined) {
+    // Don't bother to hash a permalink-based key since it's already short.
+    return 'p' + permalink;
+  } else {
+    // Append a node to the key path that represents the form state hook.
+    const keyPath = [componentKeyPath, null, hookIndex]; // Key paths are hashed to reduce the size. It does not need to be secure,
+    // and it's more important that it's fast than that it's completely
+    // collision-free.
+
+    const keyPathHash = createFastHash(JSON.stringify(keyPath));
+    return 'k' + keyPathHash;
+  }
+}
+
+function useFormState(action, initialState, permalink) {
+  resolveCurrentlyRenderingComponent(); // Count the number of useFormState hooks per component. We also use this to
+  // track the position of this useFormState hook relative to the other ones in
+  // this component, so we can generate a unique key for each one.
+
+  const formStateHookIndex = formStateCounter++;
+  const request = currentlyRenderingRequest; // $FlowIgnore[prop-missing]
+
+  const formAction = action.$$FORM_ACTION;
+
+  if (typeof formAction === 'function') {
+    // This is a server action. These have additional features to enable
+    // MPA-style form submissions with progressive enhancement.
+    // TODO: If the same permalink is passed to multiple useFormStates, and
+    // they all have the same action signature, Fizz will pass the postback
+    // state to all of them. We should probably only pass it to the first one,
+    // and/or warn.
+    // The key is lazily generated and deduped so the that the keypath doesn't
+    // get JSON.stringify-ed unnecessarily, and at most once.
+    let nextPostbackStateKey = null; // Determine the current form state. If we received state during an MPA form
+    // submission, then we will reuse that, if the action identity matches.
+    // Otherwise we'll use the initial state argument. We will emit a comment
+    // marker into the stream that indicates whether the state was reused.
+
+    let state = initialState;
+    const componentKeyPath = currentlyRenderingKeyPath;
+    const postbackFormState = getFormState(request); // $FlowIgnore[prop-missing]
+
+    const isSignatureEqual = action.$$IS_SIGNATURE_EQUAL;
+
+    if (postbackFormState !== null && typeof isSignatureEqual === 'function') {
+      const postbackKey = postbackFormState[1];
+      const postbackReferenceId = postbackFormState[2];
+      const postbackBoundArity = postbackFormState[3];
+
+      if (isSignatureEqual.call(action, postbackReferenceId, postbackBoundArity)) {
+        nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+
+        if (postbackKey === nextPostbackStateKey) {
+          // This was a match
+          formStateMatchingIndex = formStateHookIndex; // Reuse the state that was submitted by the form.
+
+          state = postbackFormState[0];
+        }
+      }
+    } // Bind the state to the first argument of the action.
+
+
+    const boundAction = action.bind(null, state); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    }; // $FlowIgnore[prop-missing]
+
+
+    if (typeof boundAction.$$FORM_ACTION === 'function') {
+      // $FlowIgnore[prop-missing]
+      dispatch.$$FORM_ACTION = prefix => {
+        const metadata = boundAction.$$FORM_ACTION(prefix); // Override the action URL
+
+        if (permalink !== undefined) {
+
+          permalink += '';
+          metadata.action = permalink;
+        }
+
+        const formData = metadata.data;
+
+        if (formData) {
+          if (nextPostbackStateKey === null) {
+            nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+          }
+
+          formData.append('$ACTION_KEY', nextPostbackStateKey);
+        }
+
+        return metadata;
+      };
+    }
+
+    return [state, dispatch];
+  } else {
+    // This is not a server action, so the implementation is much simpler.
+    // Bind the state to the first argument of the action.
+    const boundAction = action.bind(null, initialState); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    };
+
+    return [initialState, dispatch];
+  }
+}
+
+function useId() {
+  const task = currentlyRenderingTask;
+  const treeId = getTreeId(task.treeContext);
+  const resumableState = currentResumableState;
+
+  if (resumableState === null) {
+    throw new Error('Invalid hook call. Hooks can only be called inside of the body of a function component.');
+  }
+
+  const localId = localIdCounter++;
+  return makeId(resumableState, treeId, localId);
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable;
+      return unwrapThenable(thenable);
+    } else if (usable.$$typeof === REACT_CONTEXT_TYPE || usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function unwrapThenable(thenable) {
+  const index = thenableIndexCounter;
+  thenableIndexCounter += 1;
+
+  if (thenableState === null) {
+    thenableState = createThenableState();
+  }
+
+  return trackUsedThenable(thenableState, thenable, index);
+}
+
+function unsupportedRefresh() {
+  throw new Error('Cache cannot be refreshed during server rendering.');
+}
+
+function useCacheRefresh() {
+  return unsupportedRefresh;
+}
+
+function useMemoCache(size) {
+  const data = new Array(size);
+
+  for (let i = 0; i < size; i++) {
+    data[i] = REACT_MEMO_CACHE_SENTINEL;
+  }
+
+  return data;
+}
+
+function noop$1() {}
+
+const HooksDispatcher = {
+  readContext,
+  use,
+  useContext,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+  useInsertionEffect: noop$1,
+  useLayoutEffect: noop$1,
+  useCallback,
+  // useImperativeHandle is not run in the server environment
+  useImperativeHandle: noop$1,
+  // Effects are not run in the server environment.
+  useEffect: noop$1,
+  // Debugging effect
+  useDebugValue: noop$1,
+  useDeferredValue,
+  useTransition,
+  useId,
+  // Subscriptions are not setup in a server environment.
+  useSyncExternalStore
+};
+
+{
+  HooksDispatcher.useCacheRefresh = useCacheRefresh;
+}
+
+{
+  HooksDispatcher.useEffectEvent = useEffectEvent;
+}
+
+{
+  HooksDispatcher.useMemoCache = useMemoCache;
+}
+
+{
+  HooksDispatcher.useHostTransitionStatus = useHostTransitionStatus;
+}
+
+{
+  HooksDispatcher.useOptimistic = useOptimistic;
+  HooksDispatcher.useFormState = useFormState;
+}
+
+let currentResumableState = null;
+function setCurrentResumableState(resumableState) {
+  currentResumableState = resumableState;
+}
+
+function getCacheSignal() {
+  throw new Error('Not implemented.');
+}
+
+function getCacheForType(resourceType) {
+  throw new Error('Not implemented.');
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal,
+  getCacheForType
+};
+
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+const ReactCurrentCache = ReactSharedInternals.ReactCurrentCache;
+// The name might be minified but we assume that it's going to be the same generated name. Typically
+// because it's just the same compiled output in practice.
+// resume with segmentID at the index
+
+const CLIENT_RENDERED = 4; // if it errors or infinitely suspends
+
+const PENDING = 0;
+const COMPLETED = 1;
+const FLUSHED = 2;
+const ABORTED = 3;
+const ERRORED = 4;
+const POSTPONED = 5;
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2; // This is a default heuristic for how to split up the HTML content into progressive
+// loading. Our goal is to be able to display additional new content about every 500ms.
+// Faster than that is unnecessary and should be throttled on the client. It also
+// adds unnecessary overhead to do more splits. We don't know if it's a higher or lower
+// end device but higher end suffer less from the overhead than lower end does from
+// not getting small enough pieces. We error on the side of low end.
+// We base this on low end 3G speeds which is about 500kbits per second. We assume
+// that there can be a reasonable drop off from max bandwidth which leaves you with
+// as little as 80%. We can receive half of that each 500ms - at best. In practice,
+// a little bandwidth is lost to processing and contention - e.g. CSS and images that
+// are downloaded along with the main content. So we estimate about half of that to be
+// the lower end throughput. In other words, we expect that you can at least show
+// about 12.5kb of content per 500ms. Not counting starting latency for the first
+// paint.
+// 500 * 1024 / 8 * .8 * 0.5 / 2
+
+const DEFAULT_PROGRESSIVE_CHUNK_SIZE = 12800;
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+
+  return null;
+}
+
+function noop() {}
+
+function createRequest(children, resumableState, renderState, rootFormatContext, progressiveChunkSize, onError, onAllReady, onShellReady, onShellError, onFatalError, onPostpone, formState) {
+  prepareHostDispatcher();
+  const pingedTasks = [];
+  const abortSet = new Set();
+  const request = {
+    destination: null,
+    flushScheduled: false,
+    resumableState,
+    renderState,
+    rootFormatContext,
+    progressiveChunkSize: progressiveChunkSize === undefined ? DEFAULT_PROGRESSIVE_CHUNK_SIZE : progressiveChunkSize,
+    status: OPEN,
+    fatalError: null,
+    nextSegmentId: 0,
+    allPendingTasks: 0,
+    pendingRootTasks: 0,
+    completedRootSegment: null,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    clientRenderedBoundaries: [],
+    completedBoundaries: [],
+    partialBoundaries: [],
+    trackedPostpones: null,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? noop : onPostpone,
+    onAllReady: onAllReady === undefined ? noop : onAllReady,
+    onShellReady: onShellReady === undefined ? noop : onShellReady,
+    onShellError: onShellError === undefined ? noop : onShellError,
+    onFatalError: onFatalError === undefined ? noop : onFatalError,
+    formState: formState === undefined ? null : formState
+  }; // This segment represents the root fallback.
+
+  const rootSegment = createPendingSegment(request, 0, null, rootFormatContext, // Root segments are never embedded in Text on either edge
+  false, false); // There is no parent so conceptually, we're unblocked to flush this segment.
+
+  rootSegment.parentFlushed = true;
+  const rootTask = createRenderTask(request, null, children, -1, null, rootSegment, abortSet, null, rootFormatContext, emptyContextObject, rootContextSnapshot, emptyTreeContext);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  return null;
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (request.pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createSuspenseBoundary(request, fallbackAbortableTasks) {
+  return {
+    status: PENDING,
+    rootSegmentID: -1,
+    parentFlushed: false,
+    pendingTasks: 0,
+    completedSegments: [],
+    byteSize: 0,
+    fallbackAbortableTasks,
+    errorDigest: null,
+    resources: createBoundaryResources(),
+    trackedContentKeyPath: null,
+    trackedFallbackNode: null
+  };
+}
+
+function createRenderTask(request, thenableState, node, childIndex, blockedBoundary, blockedSegment, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  const task = {
+    replay: null,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createReplayTask(request, thenableState, replay, node, childIndex, blockedBoundary, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  replay.pendingTasks++;
+  const task = {
+    replay,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment: null,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createPendingSegment(request, index, boundary, parentFormatContext, lastPushedText, textEmbedded) {
+  return {
+    status: PENDING,
+    id: -1,
+    // lazily assigned later
+    index,
+    parentFlushed: false,
+    chunks: [],
+    children: [],
+    parentFormatContext,
+    boundary,
+    lastPushedText,
+    textEmbedded
+  };
+} // DEV-only global reference to the currently executing task
+
+function popComponentStackInDEV(task) {
+} // stash the component stack of an unwinding error until it is processed
+
+function logPostpone(request, reason) {
+  // If this callback errors, we intentionally let that error bubble up to become a fatal error
+  // so that someone fixes the error reporting instead of hiding it.
+  request.onPostpone(reason);
+}
+
+function logRecoverableError(request, error) {
+  // If this callback errors, we intentionally let that error bubble up to become a fatal error
+  // so that someone fixes the error reporting instead of hiding it.
+  const errorDigest = request.onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest;
+}
+
+function fatalError(request, error) {
+  // This is called outside error handling code such as if the root errors outside
+  // a suspense boundary or if the root suspense boundary's fallback errors.
+  // It's also called if React itself or its host configs errors.
+  const onShellError = request.onShellError;
+  onShellError(error);
+  const onFatalError = request.onFatalError;
+  onFatalError(error);
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function renderSuspenseBoundary(request, someTask, keyPath, props) {
+  if (someTask.replay !== null) {
+    // If we're replaying through this pass, it means we're replaying through
+    // an already completed Suspense boundary. It's too late to do anything about it
+    // so we can just render through it.
+    const prevKeyPath = someTask.keyPath;
+    someTask.keyPath = keyPath;
+    const content = props.children;
+
+    try {
+      renderNode(request, someTask, content, -1);
+    } finally {
+      someTask.keyPath = prevKeyPath;
+    }
+
+    return;
+  } // $FlowFixMe: Refined.
+
+
+  const task = someTask;
+  const prevKeyPath = task.keyPath;
+  const parentBoundary = task.blockedBoundary;
+  const parentSegment = task.blockedSegment; // Each time we enter a suspense boundary, we split out into a new segment for
+  // the fallback so that we can later replace that segment with the content.
+  // This also lets us split out the main content even if it doesn't suspend,
+  // in case it ends up generating a large subtree of content.
+
+  const fallback = props.fallback;
+  const content = props.children;
+  const fallbackAbortSet = new Set();
+  const newBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+
+  if (request.trackedPostpones !== null) {
+    newBoundary.trackedContentKeyPath = keyPath;
+  }
+
+  const insertionIndex = parentSegment.chunks.length; // The children of the boundary segment is actually the fallback.
+
+  const boundarySegment = createPendingSegment(request, insertionIndex, newBoundary, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false);
+  parentSegment.children.push(boundarySegment); // The parentSegment has a child Segment at this index so we reset the lastPushedText marker on the parent
+
+  parentSegment.lastPushedText = false; // This segment is the actual child content. We can start rendering that immediately.
+
+  const contentRootSegment = createPendingSegment(request, 0, null, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false); // We mark the root segment as having its parent flushed. It's not really flushed but there is
+  // no parent segment so there's nothing to wait on.
+
+  contentRootSegment.parentFlushed = true; // Currently this is running synchronously. We could instead schedule this to pingedTasks.
+  // I suspect that there might be some efficiency benefits from not creating the suspended task
+  // and instead just using the stack if possible.
+  // TODO: Call this directly instead of messing with saving and restoring contexts.
+  // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and which segment
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = newBoundary;
+  task.blockedSegment = contentRootSegment;
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, newBoundary.resources);
+  }
+
+  task.keyPath = keyPath;
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+    pushSegmentFinale(contentRootSegment.chunks, request.renderState, contentRootSegment.lastPushedText, contentRootSegment.textEmbedded);
+    contentRootSegment.status = COMPLETED;
+    queueCompletedSegment(newBoundary, contentRootSegment);
+
+    if (newBoundary.pendingTasks === 0 && newBoundary.status === PENDING) {
+      newBoundary.status = COMPLETED; // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    contentRootSegment.status = ERRORED;
+    newBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+      const postponeInstance = error;
+      logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+      errorDigest = 'POSTPONE';
+    } else {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    newBoundary.errorDigest = errorDigest;
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.blockedSegment = parentSegment;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]];
+  const trackedPostpones = request.trackedPostpones;
+
+  if (trackedPostpones !== null) {
+    // We create a detached replay node to track any postpones inside the fallback.
+    const fallbackReplayNode = [fallbackKeyPath[1], fallbackKeyPath[2], [], null];
+    trackedPostpones.workingMap.set(fallbackKeyPath, fallbackReplayNode);
+
+    if (newBoundary.status === POSTPONED) {
+      // This must exist now.
+      const boundaryReplayNode = trackedPostpones.workingMap.get(keyPath);
+      boundaryReplayNode[4] = fallbackReplayNode;
+    } else {
+      // We might not inject it into the postponed tree, unless the content actually
+      // postpones too. We need to keep track of it until that happpens.
+      newBoundary.trackedFallbackNode = fallbackReplayNode;
+    }
+  } // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+
+  const suspendedFallbackTask = createRenderTask(request, null, fallback, -1, parentBoundary, boundarySegment, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function replaySuspenseBoundary(request, task, keyPath, props, id, childNodes, childSlots, fallbackNodes, fallbackSlots) {
+  const prevKeyPath = task.keyPath;
+  const previousReplaySet = task.replay;
+  const parentBoundary = task.blockedBoundary;
+  const content = props.children;
+  const fallback = props.fallback;
+  const fallbackAbortSet = new Set();
+  const resumedBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = id; // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and replay node
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = resumedBoundary;
+  task.replay = {
+    nodes: childNodes,
+    slots: childSlots,
+    pendingTasks: 1
+  };
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, resumedBoundary.resources);
+  }
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+    }
+
+    task.replay.pendingTasks--;
+
+    if (resumedBoundary.pendingTasks === 0 && resumedBoundary.status === PENDING) {
+      resumedBoundary.status = COMPLETED;
+      request.completedBoundaries.push(resumedBoundary); // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    resumedBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+      const postponeInstance = error;
+      logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+      errorDigest = 'POSTPONE';
+    } else {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    resumedBoundary.errorDigest = errorDigest;
+
+    task.replay.pendingTasks--; // The parent already flushed in the prerender so we need to schedule this to be emitted.
+
+    request.clientRenderedBoundaries.push(resumedBoundary); // We don't need to decrement any task numbers because we didn't spawn any new task.
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.replay = previousReplaySet;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]]; // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+  const fallbackReplay = {
+    nodes: fallbackNodes,
+    slots: fallbackSlots,
+    pendingTasks: 0
+  };
+  const suspendedFallbackTask = createReplayTask(request, null, fallbackReplay, fallback, -1, parentBoundary, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function renderHostElement(request, task, keyPath, type, props) {
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    const children = props.children; // TODO: Make this a Config for replaying.
+
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+  } else {
+    // Render
+    const children = pushStartInstance(segment.chunks, type, props, request.resumableState, request.renderState, task.formatContext, segment.lastPushedText);
+    segment.lastPushedText = false;
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+    pushEndInstance(segment.chunks, type, props, request.resumableState, prevContext);
+    segment.lastPushedText = false;
+  }
+}
+
+function shouldConstruct(Component) {
+  return Component.prototype && Component.prototype.isReactComponent;
+}
+
+function renderWithHooks(request, task, keyPath, prevThenableState, Component, props, secondArg) {
+  const componentIdentity = {};
+  prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState);
+  const result = Component(props, secondArg);
+  return finishHooks(Component, props, result, secondArg);
+}
+
+function finishClassComponent(request, task, keyPath, instance, Component, props) {
+  const nextChildren = instance.render();
+
+  {
+    const childContextTypes = Component.childContextTypes;
+
+    if (childContextTypes !== null && childContextTypes !== undefined) {
+      const previousContext = task.legacyContext;
+      const mergedContext = processChildContext(instance, Component, previousContext, childContextTypes);
+      task.legacyContext = mergedContext;
+      renderNodeDestructive(request, task, null, nextChildren, -1);
+      task.legacyContext = previousContext;
+      return;
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, nextChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderClassComponent(request, task, keyPath, Component, props) {
+  const maskedContext = getMaskedContext(Component, task.legacyContext) ;
+  const instance = constructClassInstance(Component, props, maskedContext);
+  mountClassInstance(instance, Component, props, maskedContext);
+  finishClassComponent(request, task, keyPath, instance, Component);
+}
+// components for some reason.
+
+function renderIndeterminateComponent(request, task, keyPath, prevThenableState, Component, props) {
+  let legacyContext;
+
+  {
+    legacyContext = getMaskedContext(Component, task.legacyContext);
+  }
+
+  const value = renderWithHooks(request, task, keyPath, prevThenableState, Component, props, legacyContext);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+
+  if ( // Run these checks in production only if the flag is off.
+  // Eventually we'll delete this branch altogether.
+  typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) {
+
+    mountClassInstance(value, Component, props, legacyContext);
+    finishClassComponent(request, task, keyPath, value, Component);
+  } else {
+
+    finishFunctionComponent(request, task, keyPath, value, hasId, formStateCount, formStateMatchingIndex);
+  }
+}
+
+function finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex) {
+  let didEmitFormStateMarkers = false;
+
+  if (formStateCount !== 0 && request.formState !== null) {
+    // For each useFormState hook, emit a marker that indicates whether we
+    // rendered using the form state passed at the root. We only emit these
+    // markers if form state is passed at the root.
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      didEmitFormStateMarkers = true;
+      const target = segment.chunks;
+
+      for (let i = 0; i < formStateCount; i++) {
+        if (i === formStateMatchingIndex) {
+          pushFormStateMarkerIsMatching(target);
+        } else {
+          pushFormStateMarkerIsNotMatching(target);
+        }
+      }
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+
+  if (hasId) {
+    // This component materialized an id. We treat this as its own level, with
+    // a single "child" slot.
+    const prevTreeContext = task.treeContext;
+    const totalChildren = 1;
+    const index = 0; // Modify the id context. Because we'll need to reset this if something
+    // suspends or errors, we'll use the non-destructive render path.
+
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, index);
+    renderNode(request, task, children, -1); // Like the other contexts, this does not need to be in a finally block
+    // because renderNode takes care of unwinding the stack.
+
+    task.treeContext = prevTreeContext;
+  } else if (didEmitFormStateMarkers) {
+    // If there were formState hooks, we must use the non-destructive path
+    // because this component is not a pure indirection; we emitted markers
+    // to the stream.
+    renderNode(request, task, children, -1);
+  } else {
+    // We're now successfully past this task, and we haven't modified the
+    // context stack. We don't have to pop back to the previous task every
+    // again, so we can use the destructive recursive form.
+    renderNodeDestructive(request, task, null, children, -1);
+  }
+
+  task.keyPath = prevKeyPath;
+}
+
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    // Resolve default props. Taken from ReactElement
+    const props = assign({}, baseProps);
+    const defaultProps = Component.defaultProps;
+
+    for (const propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+
+    return props;
+  }
+
+  return baseProps;
+}
+
+function renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref) {
+  const children = renderWithHooks(request, task, keyPath, prevThenableState, type.render, props, ref);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+  finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex);
+}
+
+function renderMemo(request, task, keyPath, prevThenableState, type, props, ref) {
+  const innerType = type.type;
+  const resolvedProps = resolveDefaultProps(innerType, props);
+  renderElement(request, task, keyPath, prevThenableState, innerType, resolvedProps, ref);
+}
+
+function renderContextConsumer(request, task, keyPath, context, props) {
+
+  const render = props.children;
+
+  const newValue = readContext$1(context);
+  const newChildren = render(newValue);
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, newChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderContextProvider(request, task, keyPath, type, props) {
+  const context = type._context;
+  const value = props.value;
+  const children = props.children;
+
+  const prevKeyPath = task.keyPath;
+  task.context = pushProvider(context, value);
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, children, -1);
+  task.context = popProvider();
+  task.keyPath = prevKeyPath;
+}
+
+function renderLazyComponent(request, task, keyPath, prevThenableState, lazyComponent, props, ref) {
+  const payload = lazyComponent._payload;
+  const init = lazyComponent._init;
+  const Component = init(payload);
+  const resolvedProps = resolveDefaultProps(Component, props);
+  renderElement(request, task, keyPath, prevThenableState, Component, resolvedProps, ref);
+}
+
+function renderOffscreen(request, task, keyPath, props) {
+  const mode = props.mode;
+
+  if (mode === 'hidden') ; else {
+    // A visible Offscreen boundary is treated exactly like a fragment: a
+    // pure indirection.
+    const prevKeyPath = task.keyPath;
+    task.keyPath = keyPath;
+    renderNodeDestructive(request, task, null, props.children, -1);
+    task.keyPath = prevKeyPath;
+  }
+}
+
+function renderElement(request, task, keyPath, prevThenableState, type, props, ref) {
+  if (typeof type === 'function') {
+    if (shouldConstruct(type)) {
+      renderClassComponent(request, task, keyPath, type, props);
+      return;
+    } else {
+      renderIndeterminateComponent(request, task, keyPath, prevThenableState, type, props);
+      return;
+    }
+  }
+
+  if (typeof type === 'string') {
+    renderHostElement(request, task, keyPath, type, props);
+    return;
+  }
+
+  switch (type) {
+    // LegacyHidden acts the same as a fragment. This only works because we
+    // currently assume that every instance of LegacyHidden is accompanied by a
+    // host component wrapper. In the hidden mode, the host component is given a
+    // `hidden` attribute, which ensures that the initial HTML is not visible.
+    // To support the use of LegacyHidden as a true fragment, without an extra
+    // DOM node, we would have to hide the initial HTML in some other way.
+    // TODO: Delete in LegacyHidden. It's an unstable API only used in the
+    // www build. As a migration step, we could add a special prop to Offscreen
+    // that simulates the old behavior (no hiding, no change to effects).
+    case REACT_LEGACY_HIDDEN_TYPE:
+    case REACT_DEBUG_TRACING_MODE_TYPE:
+    case REACT_STRICT_MODE_TYPE:
+    case REACT_PROFILER_TYPE:
+    case REACT_FRAGMENT_TYPE:
+      {
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_OFFSCREEN_TYPE:
+      {
+        renderOffscreen(request, task, keyPath, props);
+        return;
+      }
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      {
+
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_SCOPE_TYPE:
+      {
+
+        throw new Error('ReactDOMServer does not yet support scope components.');
+      }
+
+    case REACT_SUSPENSE_TYPE:
+      {
+        {
+          renderSuspenseBoundary(request, task, keyPath, props);
+        }
+
+        return;
+      }
+  }
+
+  if (typeof type === 'object' && type !== null) {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        {
+          renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          renderMemo(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_PROVIDER_TYPE:
+        {
+          renderContextProvider(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_CONTEXT_TYPE:
+        {
+          renderContextConsumer(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_LAZY_TYPE:
+        {
+          renderLazyComponent(request, task, keyPath, prevThenableState, type, props);
+          return;
+        }
+    }
+  }
+
+  let info = '';
+
+  throw new Error('Element type is invalid: expected a string (for built-in ' + 'components) or a class/function (for composite components) ' + ("but got: " + (type == null ? type : typeof type) + "." + info));
+}
+
+function resumeNode(request, task, segmentId, node, childIndex) {
+  const prevReplay = task.replay;
+  const blockedBoundary = task.blockedBoundary;
+  const resumedSegment = createPendingSegment(request, 0, null, task.formatContext, false, false);
+  resumedSegment.id = segmentId;
+  resumedSegment.parentFlushed = true;
+
+  try {
+    // Convert the current ReplayTask to a RenderTask.
+    const renderTask = task;
+    renderTask.replay = null;
+    renderTask.blockedSegment = resumedSegment;
+    renderNode(request, task, node, childIndex);
+    resumedSegment.status = COMPLETED;
+
+    if (blockedBoundary === null) {
+      request.completedRootSegment = resumedSegment;
+    } else {
+      queueCompletedSegment(blockedBoundary, resumedSegment);
+
+      if (blockedBoundary.parentFlushed) {
+        request.partialBoundaries.push(blockedBoundary);
+      }
+    }
+  } finally {
+    // Restore to a ReplayTask.
+    task.replay = prevReplay;
+    task.blockedSegment = null;
+  }
+}
+
+function replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, replay) {
+  // We're replaying. Find the path to follow.
+  const replayNodes = replay.nodes;
+
+  for (let i = 0; i < replayNodes.length; i++) {
+    // Flow doesn't support refinement on tuples so we do it manually here.
+    const node = replayNodes[i];
+
+    if (keyOrIndex !== node[1]) {
+      continue;
+    }
+
+    if (node.length === 4) {
+      // Matched a replayable path.
+      // Let's double check that the component name matches as a precaution.
+      if (name !== null && name !== node[0]) {
+        throw new Error('Expected the resume to render <' + node[0] + '> in this slot but instead it rendered <' + name + '>. ' + "The tree doesn't match so React will fallback to client rendering.");
+      }
+
+      const childNodes = node[2];
+      const childSlots = node[3];
+      const currentNode = task.node;
+      task.replay = {
+        nodes: childNodes,
+        slots: childSlots,
+        pendingTasks: 1
+      };
+
+      try {
+        renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+
+        if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0 // TODO check remaining slots
+        ) {
+            throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+          }
+
+        task.replay.pendingTasks--;
+      } catch (x) {
+        if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+          // Suspend
+          if (task.node === currentNode) {
+            // This same element suspended so we need to pop the replay we just added.
+            task.replay = replay;
+          }
+
+          throw x;
+        }
+
+        task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+        // during a replay. That's because this component didn't actually error
+        // in the original prerender. What's unable to complete is the child
+        // replay nodes which might be Suspense boundaries which are able to
+        // absorb the error and we can still continue with siblings.
+
+        erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+      }
+
+      task.replay = replay;
+    } else {
+      // Let's double check that the component type matches.
+      if (type !== REACT_SUSPENSE_TYPE) {
+        const expectedType = 'Suspense';
+        throw new Error('Expected the resume to render <' + expectedType + '> in this slot but instead it rendered <' + (getComponentNameFromType(type) || 'Unknown') + '>. ' + "The tree doesn't match so React will fallback to client rendering.");
+      } // Matched a replayable path.
+
+
+      replaySuspenseBoundary(request, task, keyPath, props, node[5], node[2], node[3], node[4] === null ? [] : node[4][2], node[4] === null ? null : node[4][3]);
+    } // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+
+    replayNodes.splice(i, 1);
+    return;
+  } // We didn't find any matching nodes. We assume that this element was already
+  // rendered in the prelude and skip it.
+
+} // $FlowFixMe[missing-local-annot]
+
+function renderNodeDestructive(request, task, // The thenable state reused from the previous attempt, if any. This is almost
+// always null, except when called by retryTask.
+prevThenableState, node, childIndex) {
+  {
+    return renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex);
+  }
+} // This function by it self renders a node and consumes the task by mutating it
+// to update the current execution state.
+
+
+function renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex) {
+  if (task.replay !== null && typeof task.replay.slots === 'number') {
+    // TODO: Figure out a cheaper place than this hot path to do this check.
+    const resumeSegmentID = task.replay.slots;
+    resumeNode(request, task, resumeSegmentID, node, childIndex);
+    return;
+  } // Stash the node we're working on. We'll pick up from this task in case
+  // something suspends.
+
+
+  task.node = node;
+  task.childIndex = childIndex; // Handle object types
+
+  if (typeof node === 'object' && node !== null) {
+    switch (node.$$typeof) {
+      case REACT_ELEMENT_TYPE:
+        {
+          const element = node;
+          const type = element.type;
+          const key = element.key;
+          const props = element.props;
+          const ref = element.ref;
+          const name = getComponentNameFromType(type);
+          const keyOrIndex = key == null ? childIndex === -1 ? 0 : childIndex : key;
+          const keyPath = [task.keyPath, name, keyOrIndex];
+
+          if (task.replay !== null) {
+            replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, task.replay); // No matches found for this node. We assume it's already emitted in the
+            // prelude and skip it during the replay.
+          } else {
+            // We're doing a plain render.
+            renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+          }
+
+          return;
+        }
+
+      case REACT_PORTAL_TYPE:
+        throw new Error('Portals are not currently supported by the server renderer. ' + 'Render them conditionally so that they only appear on the client render.');
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyNode = node;
+          const payload = lazyNode._payload;
+          const init = lazyNode._init;
+          let resolvedNode;
+
+          {
+            resolvedNode = init(payload);
+          }
+
+          renderNodeDestructive(request, task, null, resolvedNode, childIndex);
+          return;
+        }
+    }
+
+    if (isArray(node)) {
+      renderChildrenArray(request, task, node, childIndex);
+      return;
+    }
+
+    const iteratorFn = getIteratorFn(node);
+
+    if (iteratorFn) {
+
+      const iterator = iteratorFn.call(node);
+
+      if (iterator) {
+        // We need to know how many total children are in this set, so that we
+        // can allocate enough id slots to acommodate them. So we must exhaust
+        // the iterator before we start recursively rendering the children.
+        // TODO: This is not great but I think it's inherent to the id
+        // generation algorithm.
+        let step = iterator.next(); // If there are not entries, we need to push an empty so we start by checking that.
+
+        if (!step.done) {
+          const children = [];
+
+          do {
+            children.push(step.value);
+            step = iterator.next();
+          } while (!step.done);
+
+          renderChildrenArray(request, task, children, childIndex);
+          return;
+        }
+
+        return;
+      }
+    } // Usables are a valid React node type. When React encounters a Usable in
+    // a child position, it unwraps it using the same algorithm as `use`. For
+    // example, for promises, React will throw an exception to unwind the
+    // stack, then replay the component once the promise resolves.
+    //
+    // A difference from `use` is that React will keep unwrapping the value
+    // until it reaches a non-Usable type.
+    //
+    // e.g. Usable<Usable<Usable<T>>> should resolve to T
+
+
+    const maybeUsable = node;
+
+    if (typeof maybeUsable.then === 'function') {
+      const thenable = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, unwrapThenable(thenable), childIndex);
+    }
+
+    if (maybeUsable.$$typeof === REACT_CONTEXT_TYPE || maybeUsable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, readContext$1(context), childIndex);
+    } // $FlowFixMe[method-unbinding]
+
+
+    const childString = Object.prototype.toString.call(node);
+    throw new Error("Objects are not valid as a React child (found: " + (childString === '[object Object]' ? 'object with keys {' + Object.keys(node).join(', ') + '}' : childString) + "). " + 'If you meant to render a collection of children, use an array ' + 'instead.');
+  }
+
+  if (typeof node === 'string') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+
+  if (typeof node === 'number') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, '' + node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+}
+
+function replayFragment(request, task, children, childIndex) {
+  // If we're supposed follow this array, we'd expect to see a ReplayNode matching
+  // this fragment.
+  const replay = task.replay;
+  const replayNodes = replay.nodes;
+
+  for (let j = 0; j < replayNodes.length; j++) {
+    const node = replayNodes[j];
+
+    if (node[1] !== childIndex) {
+      continue;
+    } // Matched a replayable path.
+
+
+    const childNodes = node[2];
+    const childSlots = node[3];
+    task.replay = {
+      nodes: childNodes,
+      slots: childSlots,
+      pendingTasks: 1
+    };
+
+    try {
+      renderChildrenArray(request, task, children, -1);
+
+      if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+        throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+      }
+
+      task.replay.pendingTasks--;
+    } catch (x) {
+      if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+        // Suspend
+        throw x;
+      }
+
+      task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+      // during a replay. That's because this component didn't actually error
+      // in the original prerender. What's unable to complete is the child
+      // replay nodes which might be Suspense boundaries which are able to
+      // absorb the error and we can still continue with siblings.
+      // This is an error, stash the component stack if it is null.
+
+      erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+    }
+
+    task.replay = replay; // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+    replayNodes.splice(j, 1);
+    break;
+  }
+}
+
+function renderChildrenArray(request, task, children, childIndex) {
+  const prevKeyPath = task.keyPath;
+
+  if (childIndex !== -1) {
+    task.keyPath = [task.keyPath, 'Fragment', childIndex];
+
+    if (task.replay !== null) {
+      replayFragment(request, // $FlowFixMe: Refined.
+      task, children, childIndex);
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  const prevTreeContext = task.treeContext;
+  const totalChildren = children.length;
+
+  if (task.replay !== null) {
+    // Replay
+    // First we need to check if we have any resume slots at this level.
+    const resumeSlots = task.replay.slots;
+
+    if (resumeSlots !== null && typeof resumeSlots === 'object') {
+      for (let i = 0; i < totalChildren; i++) {
+        const node = children[i];
+        task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+        // up and render the sibling if something suspends.
+
+        const resumeSegmentID = resumeSlots[i]; // TODO: If this errors we should still continue with the next sibling.
+
+        if (typeof resumeSegmentID === 'number') {
+          resumeNode(request, task, resumeSegmentID, node, i); // We finished rendering this node, so now we can consume this
+          // slot. This must happen after in case we rerender this task.
+
+          delete resumeSlots[i];
+        } else {
+          renderNode(request, task, node, i);
+        }
+      }
+
+      task.treeContext = prevTreeContext;
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  for (let i = 0; i < totalChildren; i++) {
+    const node = children[i];
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+    // up and render the sibling if something suspends.
+
+    renderNode(request, task, node, i);
+  } // Because this context is always set right before rendering every child, we
+  // only need to reset it to the previous value at the very end.
+
+
+  task.treeContext = prevTreeContext;
+  task.keyPath = prevKeyPath;
+}
+
+function trackPostpone(request, trackedPostpones, task, segment) {
+  segment.status = POSTPONED;
+  const keyPath = task.keyPath;
+  const boundary = task.blockedBoundary;
+
+  if (boundary === null) {
+    segment.id = request.nextSegmentId++;
+    trackedPostpones.rootSlots = segment.id;
+
+    if (request.completedRootSegment !== null) {
+      // Postpone the root if this was a deeper segment.
+      request.completedRootSegment.status = POSTPONED;
+    }
+
+    return;
+  }
+
+  if (boundary !== null && boundary.status === PENDING) {
+    boundary.status = POSTPONED; // We need to eagerly assign it an ID because we'll need to refer to
+    // it before flushing and we know that we can't inline it.
+
+    boundary.rootSegmentID = request.nextSegmentId++;
+    const boundaryKeyPath = boundary.trackedContentKeyPath;
+
+    if (boundaryKeyPath === null) {
+      throw new Error('It should not be possible to postpone at the root. This is a bug in React.');
+    }
+
+    const fallbackReplayNode = boundary.trackedFallbackNode;
+    const children = [];
+
+    if (boundaryKeyPath === keyPath && task.childIndex === -1) {
+      // Since we postponed directly in the Suspense boundary we can't have written anything
+      // to its segment. Therefore this will end up becoming the root segment.
+      segment.id = boundary.rootSegmentID; // We postponed directly inside the Suspense boundary so we mark this for resuming.
+
+      const boundaryNode = [boundaryKeyPath[1], boundaryKeyPath[2], children, boundary.rootSegmentID, fallbackReplayNode, boundary.rootSegmentID];
+      trackedPostpones.workingMap.set(boundaryKeyPath, boundaryNode);
+      addToReplayParent(boundaryNode, boundaryKeyPath[0], trackedPostpones);
+      return;
+    } else {
+      let boundaryNode = trackedPostpones.workingMap.get(boundaryKeyPath);
+
+      if (boundaryNode === undefined) {
+        boundaryNode = [boundaryKeyPath[1], boundaryKeyPath[2], children, null, fallbackReplayNode, boundary.rootSegmentID];
+        trackedPostpones.workingMap.set(boundaryKeyPath, boundaryNode);
+        addToReplayParent(boundaryNode, boundaryKeyPath[0], trackedPostpones);
+      } else {
+        // Upgrade to ReplaySuspenseBoundary.
+        const suspenseBoundary = boundaryNode;
+        suspenseBoundary[4] = fallbackReplayNode;
+        suspenseBoundary[5] = boundary.rootSegmentID;
+      } // Fall through to add the child node.
+
+    }
+  } // We know that this will leave a hole so we might as well assign an ID now.
+  // We might have one already if we had a parent that gave us its ID.
+
+
+  if (segment.id === -1) {
+    if (segment.parentFlushed && boundary !== null) {
+      // If this segment's parent was already flushed, it means we really just
+      // skipped the parent and this segment is now the root.
+      segment.id = boundary.rootSegmentID;
+    } else {
+      segment.id = request.nextSegmentId++;
+    }
+  }
+
+  if (task.childIndex === -1) {
+    // Resume starting from directly inside the previous parent element.
+    if (keyPath === null) {
+      trackedPostpones.rootSlots = segment.id;
+    } else {
+      const workingMap = trackedPostpones.workingMap;
+      let resumableNode = workingMap.get(keyPath);
+
+      if (resumableNode === undefined) {
+        resumableNode = [keyPath[1], keyPath[2], [], segment.id];
+        addToReplayParent(resumableNode, keyPath[0], trackedPostpones);
+      } else {
+        resumableNode[3] = segment.id;
+      }
+    }
+  } else {
+    let slots;
+
+    if (keyPath === null) {
+      slots = trackedPostpones.rootSlots;
+
+      if (slots === null) {
+        slots = trackedPostpones.rootSlots = {};
+      } else if (typeof slots === 'number') {
+        throw new Error('It should not be possible to postpone both at the root of an element ' + 'as well as a slot below. This is a bug in React.');
+      }
+    } else {
+      const workingMap = trackedPostpones.workingMap;
+      let resumableNode = workingMap.get(keyPath);
+
+      if (resumableNode === undefined) {
+        slots = {};
+        resumableNode = [keyPath[1], keyPath[2], [], slots];
+        workingMap.set(keyPath, resumableNode);
+        addToReplayParent(resumableNode, keyPath[0], trackedPostpones);
+      } else {
+        slots = resumableNode[3];
+
+        if (slots === null) {
+          slots = resumableNode[3] = {};
+        } else if (typeof slots === 'number') {
+          throw new Error('It should not be possible to postpone both at the root of an element ' + 'as well as a slot below. This is a bug in React.');
+        }
+      }
+    }
+
+    slots[task.childIndex] = segment.id;
+  }
+}
+
+function injectPostponedHole(request, task, reason) {
+  logPostpone(request, reason); // Something suspended, we'll need to create a new segment and resolve it later.
+
+  const segment = task.blockedSegment;
+  const insertionIndex = segment.chunks.length;
+  const newSegment = createPendingSegment(request, insertionIndex, null, task.formatContext, // Adopt the parent segment's leading text embed
+  segment.lastPushedText, // Assume we are text embedded at the trailing edge
+  true);
+  segment.children.push(newSegment); // Reset lastPushedText for current Segment since the new Segment "consumed" it
+
+  segment.lastPushedText = false;
+  return newSegment;
+}
+
+function spawnNewSuspendedReplayTask(request, task, thenableState, x) {
+  const newTask = createReplayTask(request, thenableState, task.replay, task.node, task.childIndex, task.blockedBoundary, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+}
+
+function spawnNewSuspendedRenderTask(request, task, thenableState, x) {
+  // Something suspended, we'll need to create a new segment and resolve it later.
+  const segment = task.blockedSegment;
+  const insertionIndex = segment.chunks.length;
+  const newSegment = createPendingSegment(request, insertionIndex, null, task.formatContext, // Adopt the parent segment's leading text embed
+  segment.lastPushedText, // Assume we are text embedded at the trailing edge
+  true);
+  segment.children.push(newSegment); // Reset lastPushedText for current Segment since the new Segment "consumed" it
+
+  segment.lastPushedText = false;
+  const newTask = createRenderTask(request, thenableState, task.node, task.childIndex, task.blockedBoundary, newSegment, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+} // This is a non-destructive form of rendering a node. If it suspends it spawns
+// a new task and restores the context of this task to what it was before.
+
+
+function renderNode(request, task, node, childIndex) {
+  // Snapshot the current context in case something throws to interrupt the
+  // process.
+  const previousFormatContext = task.formatContext;
+  const previousLegacyContext = task.legacyContext;
+  const previousContext = task.context;
+  const previousKeyPath = task.keyPath;
+  const previousTreeContext = task.treeContext;
+
+  let x; // Store how much we've pushed at this point so we can reset it in case something
+  // suspended partially through writing something.
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState();
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedReplayTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+      } // TODO: Abort any undiscovered Suspense boundaries in the ReplayNode.
+
+    }
+  } else {
+    // Render
+    const childrenLength = segment.children.length;
+    const chunkLength = segment.chunks.length;
+
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState(); // Reset the write pointers to where we started.
+
+      segment.children.length = childrenLength;
+      segment.chunks.length = chunkLength;
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedRenderTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+
+        if (request.trackedPostpones !== null && x.$$typeof === REACT_POSTPONE_TYPE && task.blockedBoundary !== null // bubble if we're postponing in the shell
+        ) {
+            // If we're tracking postpones, we inject a hole here and continue rendering
+            // sibling. Similar to suspending. If we're not tracking, we treat it more like
+            // an error. Notably this doesn't spawn a new task since nothing will fill it
+            // in during this prerender.
+            const postponeInstance = x;
+            const trackedPostpones = request.trackedPostpones;
+            const postponedSegment = injectPostponedHole(request, task, // We don't use ReplayTasks in prerenders.
+            postponeInstance.message);
+            trackPostpone(request, trackedPostpones, task, postponedSegment); // Restore the context. We assume that this will be restored by the inner
+            // functions in case nothing throws so we don't use "finally" here.
+
+            task.formatContext = previousFormatContext;
+            task.legacyContext = previousLegacyContext;
+            task.context = previousContext;
+            task.keyPath = previousKeyPath;
+            task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+            switchContext(previousContext);
+            return;
+          }
+      }
+    }
+  } // Restore the context. We assume that this will be restored by the inner
+  // functions in case nothing throws so we don't use "finally" here.
+
+
+  task.formatContext = previousFormatContext;
+  task.legacyContext = previousLegacyContext;
+  task.context = previousContext;
+  task.keyPath = previousKeyPath;
+  task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+  switchContext(previousContext);
+  // Let's terminate the rest of the tree and don't render any siblings.
+
+
+  throw x;
+}
+
+function erroredReplay(request, boundary, error, replayNodes, resumeSlots) {
+  // Erroring during a replay doesn't actually cause an error by itself because
+  // that component has already rendered. What causes the error is the resumable
+  // points that we did not yet finish which will be below the point of the reset.
+  // For example, if we're replaying a path to a Suspense boundary that is not done
+  // that doesn't error the parent Suspense boundary.
+  // This might be a bit strange that the error in a parent gets thrown at a child.
+  // We log it only once and reuse the digest.
+  let errorDigest;
+
+  if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+    const postponeInstance = error;
+    logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+    errorDigest = 'POSTPONE';
+  } else {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  abortRemainingReplayNodes(request, boundary, replayNodes, resumeSlots, error, errorDigest);
+}
+
+function erroredTask(request, boundary, error) {
+  // Report the error to a global handler.
+  let errorDigest;
+
+  if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+    const postponeInstance = error;
+    logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+    errorDigest = 'POSTPONE';
+  } else {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  if (boundary === null) {
+    fatalError(request, error);
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+      // so we can flush it, if the parent already flushed.
+
+
+      if (boundary.parentFlushed) {
+        // We don't have a preference where in the queue this goes since it's likely
+        // to error on the client anyway. However, intentionally client-rendered
+        // boundaries should be flushed earlier so that they can start on the client.
+        // We reuse the same queue for errors.
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function abortTaskSoft(task) {
+  // This aborts task without aborting the parent boundary that it blocks.
+  // It's used for when we didn't need this task to complete the tree.
+  // If task was needed, then it should use abortTask instead.
+  const request = this;
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+    finishedTask(request, boundary, segment);
+  }
+}
+
+function abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest) {
+  const resumedBoundary = createSuspenseBoundary(request, new Set());
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = rootSegmentID;
+  resumedBoundary.status = CLIENT_RENDERED;
+  resumedBoundary.errorDigest = errorDigest;
+
+  if (resumedBoundary.parentFlushed) {
+    request.clientRenderedBoundaries.push(resumedBoundary);
+  }
+}
+
+function abortRemainingReplayNodes(request, boundary, nodes, slots, error, errorDigest) {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+
+    if (node.length === 4) {
+      abortRemainingReplayNodes(request, boundary, node[2], node[3], error, errorDigest);
+    } else {
+      const boundaryNode = node;
+      const rootSegmentID = boundaryNode[5];
+      abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest);
+    }
+  } // Empty the set, since we've cleared it now.
+
+
+  nodes.length = 0;
+
+  if (slots !== null) {
+    // We had something still to resume in the parent boundary. We must trigger
+    // the error on the parent boundary since it's not able to complete.
+    if (boundary === null) {
+      throw new Error('We should not have any resumable nodes in the shell. ' + 'This is a bug in React.');
+    } else if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // Empty the set
+
+
+    if (typeof slots === 'object') {
+      for (const index in slots) {
+        delete slots[index];
+      }
+    }
+  }
+}
+
+function abortTask(task, request, error) {
+  // This aborts the task and aborts the parent that it blocks, putting it into
+  // client rendered mode.
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+  }
+
+  if (boundary === null) {
+    if (request.status !== CLOSING && request.status !== CLOSED) {
+      const replay = task.replay;
+
+      if (replay === null) {
+        // We didn't complete the root so we have nothing to show. We can close
+        // the request;
+        logRecoverableError(request, error);
+        fatalError(request, error);
+        return;
+      } else {
+        // If the shell aborts during a replay, that's not a fatal error. Instead
+        // we should be able to recover by client rendering all the root boundaries in
+        // the ReplaySet.
+        replay.pendingTasks--;
+
+        if (replay.pendingTasks === 0 && replay.nodes.length > 0) {
+          const errorDigest = logRecoverableError(request, error);
+          abortRemainingReplayNodes(request, null, replay.nodes, replay.slots, error, errorDigest);
+        }
+
+        request.pendingRootTasks--;
+
+        if (request.pendingRootTasks === 0) {
+          completeShell(request);
+        }
+      }
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = logRecoverableError(request, error);
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // If this boundary was still pending then we haven't already cancelled its fallbacks.
+    // We'll need to abort the fallbacks, which will also error that parent boundary.
+
+
+    boundary.fallbackAbortableTasks.forEach(fallbackTask => abortTask(fallbackTask, request, error));
+    boundary.fallbackAbortableTasks.clear();
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeShell(request) {
+  if (request.trackedPostpones === null) {
+    // We only emit early preloads on shell completion for renders. For prerenders
+    // we wait for the entire Request to finish because we are not responding to a
+    // live request and can wait for as much data as possible.
+    // we should only be calling completeShell when the shell is complete so we
+    // just use a literal here
+    const shellComplete = true;
+    emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  } // We have completed the shell so the shell can't error anymore.
+
+
+  request.onShellError = noop;
+  const onShellReady = request.onShellReady;
+  onShellReady();
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeAll(request) {
+  // During a render the shell must be complete if the entire request is finished
+  // however during a Prerender it is possible that the shell is incomplete because
+  // it postponed. We cannot use rootPendingTasks in the prerender case because
+  // those hit zero even when the shell postpones. Instead we look at the completedRootSegment
+  const shellComplete = request.trackedPostpones === null ? // Render, we assume it is completed
+  true : // Prerender Request, we use the state of the root segment
+  request.completedRootSegment === null || request.completedRootSegment.status !== POSTPONED;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  const onAllReady = request.onAllReady;
+  onAllReady();
+}
+
+function queueCompletedSegment(boundary, segment) {
+  if (segment.chunks.length === 0 && segment.children.length === 1 && segment.children[0].boundary === null) {
+    // This is an empty segment. There's nothing to write, so we can instead transfer the ID
+    // to the child. That way any existing references point to the child.
+    const childSegment = segment.children[0];
+    childSegment.id = segment.id;
+    childSegment.parentFlushed = true;
+
+    if (childSegment.status === COMPLETED) {
+      queueCompletedSegment(boundary, childSegment);
+    }
+  } else {
+    const completedSegments = boundary.completedSegments;
+    completedSegments.push(segment);
+  }
+}
+
+function finishedTask(request, boundary, segment) {
+  if (boundary === null) {
+    if (segment !== null && segment.parentFlushed) {
+      if (request.completedRootSegment !== null) {
+        throw new Error('There can only be one root segment. This is a bug in React.');
+      }
+
+      request.completedRootSegment = segment;
+    }
+
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status === CLIENT_RENDERED) ; else if (boundary.pendingTasks === 0) {
+      if (boundary.status === PENDING) {
+        boundary.status = COMPLETED;
+      } // This must have been the last segment we were waiting on. This boundary is now complete.
+
+
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent segment already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+        }
+      }
+
+      if (boundary.parentFlushed) {
+        // The segment might be part of a segment that didn't flush yet, but if the boundary's
+        // parent flushed, we need to schedule the boundary to be emitted.
+        request.completedBoundaries.push(boundary);
+      } // We can now cancel any pending task on the fallback since we won't need to show it anymore.
+      // This needs to happen after we read the parentFlushed flags because aborting can finish
+      // work which can trigger user code, which can start flushing, which can change those flags.
+      // If the boundary was POSTPONED, we still need to finish the fallback first.
+
+
+      if (boundary.status === COMPLETED) {
+        boundary.fallbackAbortableTasks.forEach(abortTaskSoft, request);
+        boundary.fallbackAbortableTasks.clear();
+      }
+    } else {
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+          const completedSegments = boundary.completedSegments;
+
+          if (completedSegments.length === 1) {
+            // This is the first time since we last flushed that we completed anything.
+            // We can schedule this boundary to emit its partially completed segments early
+            // in case the parent has already been flushed.
+            if (boundary.parentFlushed) {
+              request.partialBoundaries.push(boundary);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function retryTask(request, task) {
+  {
+    const blockedBoundary = task.blockedBoundary;
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, blockedBoundary ? blockedBoundary.resources : null);
+  }
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    retryReplayTask(request, // $FlowFixMe: Refined.
+    task);
+  } else {
+    retryRenderTask(request, // $FlowFixMe: Refined.
+    task, segment);
+  }
+}
+
+function retryRenderTask(request, task, segment) {
+  if (segment.status !== PENDING) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  const childrenLength = segment.children.length;
+  const chunkLength = segment.chunks.length;
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+    pushSegmentFinale(segment.chunks, request.renderState, segment.lastPushedText, segment.textEmbedded);
+    task.abortSet.delete(task);
+    segment.status = COMPLETED;
+    finishedTask(request, task.blockedBoundary, segment);
+  } catch (thrownValue) {
+    resetHooksState(); // Reset the write pointers to where we started.
+
+    segment.children.length = childrenLength;
+    segment.chunks.length = chunkLength;
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      } else if (request.trackedPostpones !== null && x.$$typeof === REACT_POSTPONE_TYPE) {
+        // If we're tracking postpones, we mark this segment as postponed and finish
+        // the task without filling it in. If we're not tracking, we treat it more like
+        // an error.
+        const trackedPostpones = request.trackedPostpones;
+        task.abortSet.delete(task);
+        const postponeInstance = x;
+        logPostpone(request, postponeInstance.message);
+        trackPostpone(request, trackedPostpones, task, segment);
+        finishedTask(request, task.blockedBoundary, segment);
+        return;
+      }
+    }
+
+    task.abortSet.delete(task);
+    segment.status = ERRORED;
+    erroredTask(request, task.blockedBoundary, x);
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function retryReplayTask(request, task) {
+  if (task.replay.pendingTasks === 0) {
+    // There are no pending tasks working on this set, so we must have aborted.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    finishedTask(request, task.blockedBoundary, null);
+  } catch (thrownValue) {
+    resetHooksState();
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    erroredReplay(request, task.blockedBoundary, x, task.replay.nodes, task.replay.slots);
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+
+    request.allPendingTasks--;
+
+    if (request.allPendingTasks === 0) {
+      completeAll(request);
+    }
+
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function performWork(request) {
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  const prevContext = getActiveContext();
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  let prevCacheDispatcher;
+
+  {
+    prevCacheDispatcher = ReactCurrentCache.current;
+    ReactCurrentCache.current = DefaultCacheDispatcher;
+  }
+
+  const prevRequest = currentRequest;
+  currentRequest = request;
+
+  const prevResumableState = currentResumableState;
+  setCurrentResumableState(request.resumableState);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    let i;
+
+    for (i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    pingedTasks.splice(0, i);
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    setCurrentResumableState(prevResumableState);
+    ReactCurrentDispatcher.current = prevDispatcher;
+
+    {
+      ReactCurrentCache.current = prevCacheDispatcher;
+    }
+
+    if (prevDispatcher === HooksDispatcher) {
+      // This means that we were in a reentrant work loop. This could happen
+      // in a renderer that supports synchronous work like renderToString,
+      // when it's called from within another renderer.
+      // Normally we don't bother switching the contexts to their root/default
+      // values when leaving because we'll likely need the same or similar
+      // context again. However, when we're inside a synchronous loop like this
+      // we'll to restore the context to what it was before returning.
+      switchContext(prevContext);
+    }
+
+    currentRequest = prevRequest;
+  }
+}
+
+function flushSubtree(request, destination, segment) {
+  segment.parentFlushed = true;
+
+  switch (segment.status) {
+    case PENDING:
+      {
+        // We're emitting a placeholder for this segment to be filled in later.
+        // Therefore we'll need to assign it an ID - to refer to it by.
+        segment.id = request.nextSegmentId++; // Fallthrough
+      }
+
+    case POSTPONED:
+      {
+        const segmentID = segment.id; // When this segment finally completes it won't be embedded in text since it will flush separately
+
+        segment.lastPushedText = false;
+        segment.textEmbedded = false;
+        return writePlaceholder(destination, request.renderState, segmentID);
+      }
+
+    case COMPLETED:
+      {
+        segment.status = FLUSHED;
+        let r = true;
+        const chunks = segment.chunks;
+        let chunkIdx = 0;
+        const children = segment.children;
+
+        for (let childIdx = 0; childIdx < children.length; childIdx++) {
+          const nextChild = children[childIdx]; // Write all the chunks up until the next child.
+
+          for (; chunkIdx < nextChild.index; chunkIdx++) {
+            writeChunk(destination, chunks[chunkIdx]);
+          }
+
+          r = flushSegment(request, destination, nextChild);
+        } // Finally just write all the remaining chunks
+
+
+        for (; chunkIdx < chunks.length - 1; chunkIdx++) {
+          writeChunk(destination, chunks[chunkIdx]);
+        }
+
+        if (chunkIdx < chunks.length) {
+          r = writeChunkAndReturn(destination, chunks[chunkIdx]);
+        }
+
+        return r;
+      }
+
+    default:
+      {
+        throw new Error('Aborted, errored or already flushed boundaries should not be flushed again. This is a bug in React.');
+      }
+  }
+}
+
+function flushSegment(request, destination, segment) {
+  const boundary = segment.boundary;
+
+  if (boundary === null) {
+    // Not a suspense boundary.
+    return flushSubtree(request, destination, segment);
+  }
+
+  boundary.parentFlushed = true; // This segment is a Suspense boundary. We need to decide whether to
+  // emit the content or the fallback now.
+
+  if (boundary.status === CLIENT_RENDERED) {
+    // Emit a client rendered suspense boundary wrapper.
+    // We never queue the inner boundary so we'll never emit its content or partial segments.
+    writeStartClientRenderedSuspenseBoundary(destination, request.renderState, boundary.errorDigest); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndClientRenderedSuspenseBoundary(destination);
+  } else if (boundary.status !== COMPLETED) {
+    if (boundary.status === PENDING) {
+      // For pending boundaries we lazily assign an ID to the boundary
+      // and root segment.
+      boundary.rootSegmentID = request.nextSegmentId++;
+    }
+
+    if (boundary.completedSegments.length > 0) {
+      // If this is at least partially complete, we can queue it to be partially emitted early.
+      request.partialBoundaries.push(boundary);
+    } // This boundary is still loading. Emit a pending suspense boundary wrapper.
+
+
+    const id = boundary.rootSegmentID;
+    writeStartPendingSuspenseBoundary(destination, request.renderState, id); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else if (boundary.byteSize > request.progressiveChunkSize) {
+    // This boundary is large and will be emitted separately so that we can progressively show
+    // other content. We add it to the queue during the flush because we have to ensure that
+    // the parent flushes first so that there's something to inject it into.
+    // We also have to make sure that it's emitted into the queue in a deterministic slot.
+    // I.e. we can't insert it here when it completes.
+    // Assign an ID to refer to the future content by.
+    boundary.rootSegmentID = request.nextSegmentId++;
+    request.completedBoundaries.push(boundary); // Emit a pending rendered suspense boundary wrapper.
+
+    writeStartPendingSuspenseBoundary(destination, request.renderState, boundary.rootSegmentID); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else {
+    {
+      hoistResources(request.renderState, boundary.resources);
+    } // We can inline this boundary's content as a complete boundary.
+
+
+    writeStartCompletedSuspenseBoundary(destination);
+    const completedSegments = boundary.completedSegments;
+
+    if (completedSegments.length !== 1) {
+      throw new Error('A previously unvisited boundary must have exactly one root segment. This is a bug in React.');
+    }
+
+    const contentSegment = completedSegments[0];
+    flushSegment(request, destination, contentSegment);
+    return writeEndCompletedSuspenseBoundary(destination);
+  }
+}
+
+function flushClientRenderedBoundary(request, destination, boundary) {
+  return writeClientRenderBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.errorDigest, boundary.errorMessage, boundary.errorComponentStack);
+}
+
+function flushSegmentContainer(request, destination, segment) {
+  writeStartSegment(destination, request.renderState, segment.parentFormatContext, segment.id);
+  flushSegment(request, destination, segment);
+  return writeEndSegment(destination, segment.parentFormatContext);
+}
+
+function flushCompletedBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+    flushPartiallyCompletedSegment(request, destination, boundary, segment);
+  }
+
+  completedSegments.length = 0;
+
+  {
+    writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+
+  return writeCompletedBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.resources);
+}
+
+function flushPartialBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+
+    if (!flushPartiallyCompletedSegment(request, destination, boundary, segment)) {
+      i++;
+      completedSegments.splice(0, i); // Only write as much as the buffer wants. Something higher priority
+      // might want to write later.
+
+      return false;
+    }
+  }
+
+  completedSegments.splice(0, i);
+
+  {
+    // The way this is structured we only write resources for partial boundaries
+    // if there is no backpressure. Later before we complete the boundary we
+    // will write resources regardless of backpressure before we emit the
+    // completion instruction
+    return writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+}
+
+function flushPartiallyCompletedSegment(request, destination, boundary, segment) {
+  if (segment.status === FLUSHED) {
+    // We've already flushed this inline.
+    return true;
+  }
+
+  const segmentID = segment.id;
+
+  if (segmentID === -1) {
+    // This segment wasn't previously referred to. This happens at the root of
+    // a boundary. We make kind of a leap here and assume this is the root.
+    const rootSegmentID = segment.id = boundary.rootSegmentID;
+
+    if (rootSegmentID === -1) {
+      throw new Error('A root segment ID must have been assigned by now. This is a bug in React.');
+    }
+
+    return flushSegmentContainer(request, destination, segment);
+  } else if (segmentID === boundary.rootSegmentID) {
+    // When we emit postponed boundaries, we might have assigned the ID already
+    // but it's still the root segment so we can't inject it into the parent yet.
+    return flushSegmentContainer(request, destination, segment);
+  } else {
+    flushSegmentContainer(request, destination, segment);
+    return writeCompletedSegmentInstruction(destination, request.resumableState, request.renderState, segmentID);
+  }
+}
+
+function flushCompletedQueues(request, destination) {
+
+  try {
+    // The structure of this is to go through each queue one by one and write
+    // until the sink tells us to stop. When we should stop, we still finish writing
+    // that item fully and then yield. At that point we remove the already completed
+    // items up until the point we completed them.
+    let i;
+    const completedRootSegment = request.completedRootSegment;
+
+    if (completedRootSegment !== null) {
+      if (completedRootSegment.status === POSTPONED) {
+        // We postponed the root, so we write nothing.
+        return;
+      } else if (request.pendingRootTasks === 0) {
+        if (enableFloat) {
+          writePreamble(destination, request.resumableState, request.renderState, request.allPendingTasks === 0 && request.trackedPostpones === null);
+        }
+
+        flushSegment(request, destination, completedRootSegment);
+        request.completedRootSegment = null;
+        writeCompletedRoot(destination, request.renderState, request.resumableState);
+      } else {
+        // We haven't flushed the root yet so we don't need to check any other branches further down
+        return;
+      }
+    }
+
+    if (enableFloat) {
+      writeHoistables(destination, request.resumableState, request.renderState);
+    } // We emit client rendering instructions for already emitted boundaries first.
+    // This is so that we can signal to the client to start client rendering them as
+    // soon as possible.
+
+
+    const clientRenderedBoundaries = request.clientRenderedBoundaries;
+
+    for (i = 0; i < clientRenderedBoundaries.length; i++) {
+      const boundary = clientRenderedBoundaries[i];
+
+      if (!flushClientRenderedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        clientRenderedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    clientRenderedBoundaries.splice(0, i); // Next we emit any complete boundaries. It's better to favor boundaries
+    // that are completely done since we can actually show them, than it is to emit
+    // any individual segments from a partially complete boundary.
+
+    const completedBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < completedBoundaries.length; i++) {
+      const boundary = completedBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        completedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    completedBoundaries.splice(0, i); // Allow anything written so far to flush to the underlying sink before
+    // we continue with lower priorities.
+
+    completeWriting(destination);
+    beginWriting(destination); // TODO: Here we'll emit data used by hydration.
+    // Next we emit any segments of any boundaries that are partially complete
+    // but not deeply complete.
+
+    const partialBoundaries = request.partialBoundaries;
+
+    for (i = 0; i < partialBoundaries.length; i++) {
+      const boundary = partialBoundaries[i];
+
+      if (!flushPartialBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        partialBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    partialBoundaries.splice(0, i); // Next we check the completed boundaries again. This may have had
+    // boundaries added to it in case they were too larged to be inlined.
+    // New ones might be added in this loop.
+
+    const largeBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < largeBoundaries.length; i++) {
+      const boundary = largeBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        largeBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    largeBoundaries.splice(0, i);
+  } finally {
+    if (request.allPendingTasks === 0 && request.pingedTasks.length === 0 && request.clientRenderedBoundaries.length === 0 && request.completedBoundaries.length === 0 // We don't need to check any partially completed segments because
+    // either they have pending task or they're complete.
+    ) {
+        request.flushScheduled = false;
+
+        {
+          // We write the trailing tags but only if don't have any data to resume.
+          // If we need to resume we'll write the postamble in the resume instead.
+          if (request.trackedPostpones === null) {
+            writePostamble(destination, request.resumableState);
+          }
+        }
+
+
+        close(destination); // We need to stop flowing now because we do not want any async contexts which might call
+        // float methods to initiate any flushes after this point
+
+        stopFlowing(request);
+      }
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  {
+    scheduleWork(() => performWork(request));
+  }
+
+  if (request.trackedPostpones === null) {
+    // this is either a regular render or a resume. For regular render we want
+    // to call emitEarlyPreloads after the first performWork because we want
+    // are responding to a live request and need to balance sending something early
+    // (i.e. don't want for the shell to finish) but we need something to send.
+    // The only implementation of this is for DOM at the moment and during resumes nothing
+    // actually emits but the code paths here are the same.
+    // During a prerender we don't want to be too aggressive in emitting early preloads
+    // because we aren't responding to a live request and we can wait for the prerender to
+    // postpone before we emit anything.
+    {
+      scheduleWork(() => enqueueEarlyPreloadsAfterInitialWork(request));
+    }
+  }
+}
+
+function enqueueEarlyPreloadsAfterInitialWork(request) {
+  const shellComplete = request.pendingRootTasks === 0;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    request.flushScheduled = true;
+    scheduleWork(() => {
+      // We need to existence check destination again here because it might go away
+      // in between the enqueueFlush call and the work execution
+      const destination = request.destination;
+
+      if (destination) {
+        flushCompletedQueues(request, destination);
+      } else {
+        request.flushScheduled = false;
+      }
+    });
+  }
+} // This function is intented to only be called during the pipe function for the Node builds.
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedQueues(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function stopFlowing(request) {
+  request.destination = null;
+} // This is called to early terminate a request. It puts all pending boundaries in client rendered state.
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+      abortableTasks.forEach(task => abortTask(task, request, error));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function flushResources(request) {
+  enqueueFlush(request);
+}
+function getFormState(request) {
+  return request.formState;
+}
+function getResumableState(request) {
+  return request.resumableState;
+}
+function getRenderState(request) {
+  return request.renderState;
+}
+
+function addToReplayParent(node, parentKeyPath, trackedPostpones) {
+  if (parentKeyPath === null) {
+    trackedPostpones.rootNodes.push(node);
+  } else {
+    const workingMap = trackedPostpones.workingMap;
+    let parentNode = workingMap.get(parentKeyPath);
+
+    if (parentNode === undefined) {
+      parentNode = [parentKeyPath[1], parentKeyPath[2], [], null];
+      workingMap.set(parentKeyPath, parentNode);
+      addToReplayParent(parentNode, parentKeyPath[0], trackedPostpones);
+    }
+
+    parentNode[2].push(node);
+  }
+} // Returns the state of a postponed request or null if nothing was postponed.
+
+function renderToReadableStream(children, options) {
+  return new Promise((resolve, reject) => {
+    let onFatalError;
+    let onAllReady;
+    const allReady = new Promise((res, rej) => {
+      onAllReady = res;
+      onFatalError = rej;
+    });
+
+    function onShellReady() {
+      const stream = new ReadableStream({
+        type: 'direct',
+        pull: controller => {
+          // $FlowIgnore
+          startFlowing(request, controller);
+        },
+        cancel: reason => {
+          stopFlowing(request);
+          abort(request, reason);
+        }
+      }, // $FlowFixMe[prop-missing] size() methods are not allowed on byte streams.
+      {
+        highWaterMark: 2048
+      }); // TODO: Move to sub-classing ReadableStream.
+
+      stream.allReady = allReady;
+      resolve(stream);
+    }
+
+    function onShellError(error) {
+      // If the shell errors the caller of `renderToReadableStream` won't have access to `allReady`.
+      // However, `allReady` will be rejected by `onFatalError` as well.
+      // So we need to catch the duplicate, uncatchable fatal error in `allReady` to prevent a `UnhandledPromiseRejection`.
+      allReady.catch(() => {});
+      reject(error);
+    }
+
+    const onHeaders = options ? options.onHeaders : undefined;
+    let onHeadersImpl;
+
+    if (onHeaders) {
+      onHeadersImpl = headersDescriptor => {
+        onHeaders(new Headers(headersDescriptor));
+      };
+    }
+
+    const resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined);
+    const request = createRequest(children, resumableState, createRenderState(resumableState, options ? options.nonce : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, onHeadersImpl, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, onShellReady, onShellError, onFatalError, options ? options.onPostpone : undefined, options ? options.formState : undefined);
+
+    if (options && options.signal) {
+      const signal = options.signal;
+
+      if (signal.aborted) {
+        abort(request, signal.reason);
+      } else {
+        const listener = () => {
+          abort(request, signal.reason);
+          signal.removeEventListener('abort', listener);
+        };
+
+        signal.addEventListener('abort', listener);
+      }
+    }
+
+    startWork(request);
+  });
+}
+
+function renderToNodeStream() {
+  throw new Error('ReactDOMServer.renderToNodeStream(): The Node Stream API is not available ' + 'in Bun. Use ReactDOMServer.renderToReadableStream() instead.');
+}
+
+function renderToStaticNodeStream() {
+  throw new Error('ReactDOMServer.renderToStaticNodeStream(): The Node Stream API is not available ' + 'in Bun. Use ReactDOMServer.renderToReadableStream() instead.');
+}
+
+exports.renderToNodeStream = renderToNodeStream;
+exports.renderToReadableStream = renderToReadableStream;
+exports.renderToStaticNodeStream = renderToStaticNodeStream;
+exports.version = ReactVersion;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.edge.development.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.edge.development.js
index a3c84b86590cf..3f40932a6c3cc 100644
--- a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.edge.development.js
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.edge.development.js
@@ -17,7 +17,7 @@ if (process.env.NODE_ENV !== "production") {
 var React = require("next/dist/compiled/react-experimental");
 var ReactDOM = require('react-dom');
 
-var ReactVersion = '18.3.0-experimental-2983249dd-20231107';
+var ReactVersion = '18.3.0-experimental-7508dcd5c-20231108';
 
 var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
 
@@ -1816,11 +1816,14 @@ var DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS = 2000; // Allows us to keep tr
 // if passed externalRuntimeConfig and the enableFizzExternalRuntime feature flag
 // is set, the server will send instructions via data attributes (instead of inline scripts)
 
-function createRenderState(resumableState, nonce, bootstrapScriptContent, bootstrapScripts, bootstrapModules, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
+function createRenderState(resumableState, nonce, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
   var inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
   var idPrefix = resumableState.idPrefix;
   var bootstrapChunks = [];
   var externalRuntimeScript = null;
+  var bootstrapScriptContent = resumableState.bootstrapScriptContent,
+      bootstrapScripts = resumableState.bootstrapScripts,
+      bootstrapModules = resumableState.bootstrapModules;
 
   if (bootstrapScriptContent !== undefined) {
     bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapAndImportMapScriptContent(bootstrapScriptContent)), endInlineScript);
@@ -2010,10 +2013,9 @@ function createRenderState(resumableState, nonce, bootstrapScriptContent, bootst
   return renderState;
 }
 function resumeRenderState(resumableState, nonce) {
-  return createRenderState(resumableState, nonce, // These should have already been flushed in the prerender.
-  undefined, undefined, undefined, undefined, undefined, undefined);
+  return createRenderState(resumableState, nonce, undefined, undefined, undefined, undefined);
 }
-function createResumableState(identifierPrefix, externalRuntimeConfig) {
+function createResumableState(identifierPrefix, externalRuntimeConfig, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
   var idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
   var streamingFormat = ScriptStreamingFormat;
 
@@ -2027,6 +2029,9 @@ function createResumableState(identifierPrefix, externalRuntimeConfig) {
     idPrefix: idPrefix,
     nextFormID: 0,
     streamingFormat: streamingFormat,
+    bootstrapScriptContent: bootstrapScriptContent,
+    bootstrapScripts: bootstrapScripts,
+    bootstrapModules: bootstrapModules,
     instructions: NothingSent,
     hasBody: false,
     hasHtml: false,
@@ -4512,7 +4517,10 @@ function pushEndInstance(target, type, props, resumableState, formatContext) {
   target.push(endChunkForTag(type));
 }
 
-function writeBootstrap(destination, renderState) {
+function writeBootstrap(destination, renderState, resumableState) {
+  resumableState.bootstrapScriptContent = undefined;
+  resumableState.bootstrapScripts = undefined;
+  resumableState.bootstrapModules = undefined;
   var bootstrapChunks = renderState.bootstrapChunks;
   var i = 0;
 
@@ -4529,8 +4537,8 @@ function writeBootstrap(destination, renderState) {
   return true;
 }
 
-function writeCompletedRoot(destination, renderState) {
-  return writeBootstrap(destination, renderState);
+function writeCompletedRoot(destination, renderState, resumableState) {
+  return writeBootstrap(destination, renderState, resumableState);
 } // Structural Nodes
 // A placeholder is a node inside a hidden partial tree that can be filled in later, but before
 // display. It's never visible to users. We use the template tag because it can be used in every
@@ -4887,7 +4895,7 @@ function writeCompletedBoundaryInstruction(destination, resumableState, renderSt
     writeMore = writeChunkAndReturn(destination, completeBoundaryDataEnd);
   }
 
-  return writeBootstrap(destination, renderState) && writeMore;
+  return writeBootstrap(destination, renderState, resumableState) && writeMore;
 }
 var clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
 var clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
@@ -6896,6 +6904,18 @@ var componentFrameCache;
   var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
   componentFrameCache = new PossiblyWeakMap();
 }
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
@@ -6911,7 +6931,6 @@ function describeNativeComponentFrame(fn, construct) {
     }
   }
 
-  var control;
   reentry = true;
   var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
 
@@ -6925,81 +6944,140 @@ function describeNativeComponentFrame(fn, construct) {
     ReactCurrentDispatcher$1.current = null;
     disableLogs();
   }
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
 
-  try {
-    // This should throw.
-    if (construct) {
-      // Something should be setting the props in the constructor.
-      var Fake = function () {
-        throw Error();
-      }; // $FlowFixMe[prop-missing]
 
+  var RunInRootFrame = {
+    DetermineComponentFrameRoot: function () {
+      var control;
 
-      Object.defineProperty(Fake.prototype, 'props', {
-        set: function () {
-          // We use a throwing setter instead of frozen or non-writable props
-          // because that won't throw in a non-strict mode function.
-          throw Error();
-        }
-      });
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          var Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
 
-      if (typeof Reflect === 'object' && Reflect.construct) {
-        // We construct a different control for this case to include any extra
-        // frames added by the construct call.
-        try {
-          Reflect.construct(Fake, []);
-        } catch (x) {
-          control = x;
-        }
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
 
-        Reflect.construct(fn, [], Fake);
-      } else {
-        try {
-          Fake.call();
-        } catch (x) {
-          control = x;
-        } // $FlowFixMe[prop-missing] found when upgrading Flow
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
 
 
-        fn.call(Fake.prototype);
-      }
-    } else {
-      try {
-        throw Error();
-      } catch (x) {
-        control = x;
-      } // TODO(luna): This will currently only throw if the function component
-      // tries to access React/ReactDOM/props. We should probably make this throw
-      // in simple components too
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
 
 
-      var maybePromise = fn(); // If the function component returns a promise, it's likely an async
-      // component, which we don't yet support. Attach a noop catch handler to
-      // silence the error.
-      // TODO: Implement component stacks for async client components?
+          var maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
 
-      if (maybePromise && typeof maybePromise.catch === 'function') {
-        maybePromise.catch(function () {});
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(function () {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
       }
+
+      return [null, null];
     }
-  } catch (sample) {
-    // This is inlined manually because closure doesn't do it for us.
-    if (sample && control && typeof sample.stack === 'string') {
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
+
+  try {
+    var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
+
+    if (sampleStack && controlStack) {
       // This extracts the first frame from the sample that isn't also in the control.
       // Skipping one frame that we assume is the frame that calls the two.
-      var sampleLines = sample.stack.split('\n');
-      var controlLines = control.stack.split('\n');
-      var s = sampleLines.length - 1;
-      var c = controlLines.length - 1;
-
-      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
-        // We expect at least one stack frame to be shared.
-        // Typically this will be the root most one. However, stack frames may be
-        // cut off due to maximum stack limits. In this case, one maybe cut off
-        // earlier than the other. We assume that the sample is longer or the same
-        // and there for cut off earlier. So we should find the root most frame in
-        // the sample somewhere in the control.
-        c--;
+      var sampleLines = sampleStack.split('\n');
+      var controlLines = controlStack.split('\n');
+      var s = 0;
+      var c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
       }
 
       for (; s >= 1 && c >= 0; s--, c--) {
@@ -7028,7 +7106,7 @@ function describeNativeComponentFrame(fn, construct) {
                   _frame = _frame.replace('<anonymous>', fn.displayName);
                 }
 
-                {
+                if (true) {
                   if (typeof fn === 'function') {
                     componentFrameCache.set(fn, _frame);
                   }
@@ -11704,7 +11782,7 @@ function flushCompletedQueues(request, destination) {
 
         flushSegment(request, destination, completedRootSegment);
         request.completedRootSegment = null;
-        writeCompletedRoot(destination, request.renderState);
+        writeCompletedRoot(destination, request.renderState, request.resumableState);
       } else {
         // We haven't flushed the root yet so we don't need to check any other branches further down
         return;
@@ -12028,8 +12106,8 @@ function renderToReadableStream(children, options) {
       };
     }
 
-    var resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined);
-    var request = createRequest(children, resumableState, createRenderState(resumableState, options ? options.nonce : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, onHeadersImpl, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, onShellReady, onShellError, onFatalError, options ? options.onPostpone : undefined, options ? options.formState : undefined);
+    var resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined);
+    var request = createRequest(children, resumableState, createRenderState(resumableState, options ? options.nonce : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, onHeadersImpl, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, onShellReady, onShellError, onFatalError, options ? options.onPostpone : undefined, options ? options.formState : undefined);
 
     if (options && options.signal) {
       var signal = options.signal;
@@ -12141,9 +12219,9 @@ function prerender(children, options) {
       };
     }
 
-    var resources = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined);
+    var resources = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined);
     var request = createPrerenderRequest(children, resources, createRenderState(resources, undefined, // nonce is not compatible with prerendered bootstrap scripts
-    options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, onHeadersImpl, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, undefined, undefined, onFatalError, options ? options.onPostpone : undefined);
+    options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, onHeadersImpl, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, undefined, undefined, onFatalError, options ? options.onPostpone : undefined);
 
     if (options && options.signal) {
       var signal = options.signal;
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.edge.production.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.edge.production.js
new file mode 100644
index 0000000000000..15b3b97a5c213
--- /dev/null
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.edge.production.js
@@ -0,0 +1,9106 @@
+/**
+ * @license React
+ * react-dom-server.edge.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require("next/dist/compiled/react-experimental");
+var ReactDOM = require('react-dom');
+
+var ReactVersion = '18.3.0-experimental-7508dcd5c-20231108';
+
+// A pure JS implementation of a string hashing function. We do not use it for
+// security or obfuscation purposes, only to create compact hashes. So we
+// prioritize speed over collision avoidance. For example, we use this to hash
+// the component key path used by useFormState for MPA-style submissions.
+//
+// In environments where built-in hashing functions are available, we prefer
+// those instead. Like Node's crypto module, or Bun.hash. Unfortunately this
+// does not include the web standard crypto API because those methods are all
+// async. For our purposes, we need it to be sync because the cost of context
+// switching is too high to be worth it.
+//
+// The most popular hashing algorithm that meets these requirements in the JS
+// ecosystem is MurmurHash3, and almost all implementations I could find used
+// some version of the implementation by Gary Court inlined below.
+function createFastHashJS(key) {
+  return murmurhash3_32_gc(key, 0);
+}
+/* eslint-disable prefer-const, no-fallthrough */
+
+/**
+ * @license
+ *
+ * JS Implementation of MurmurHash3 (r136) (as of May 20, 2011)
+ *
+ * Copyright (c) 2011 Gary Court
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+function murmurhash3_32_gc(key, seed) {
+  let remainder, bytes, h1, h1b, c1, c2, k1, i;
+  remainder = key.length & 3; // key.length % 4
+
+  bytes = key.length - remainder;
+  h1 = seed;
+  c1 = 0xcc9e2d51;
+  c2 = 0x1b873593;
+  i = 0;
+
+  while (i < bytes) {
+    k1 = key.charCodeAt(i) & 0xff | (key.charCodeAt(++i) & 0xff) << 8 | (key.charCodeAt(++i) & 0xff) << 16 | (key.charCodeAt(++i) & 0xff) << 24;
+    ++i;
+    k1 = (k1 & 0xffff) * c1 + (((k1 >>> 16) * c1 & 0xffff) << 16) & 0xffffffff;
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = (k1 & 0xffff) * c2 + (((k1 >>> 16) * c2 & 0xffff) << 16) & 0xffffffff;
+    h1 ^= k1;
+    h1 = h1 << 13 | h1 >>> 19;
+    h1b = (h1 & 0xffff) * 5 + (((h1 >>> 16) * 5 & 0xffff) << 16) & 0xffffffff;
+    h1 = (h1b & 0xffff) + 0x6b64 + (((h1b >>> 16) + 0xe654 & 0xffff) << 16);
+  }
+
+  k1 = 0;
+
+  switch (remainder) {
+    case 3:
+      k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
+
+    case 2:
+      k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
+
+    case 1:
+      k1 ^= key.charCodeAt(i) & 0xff;
+      k1 = (k1 & 0xffff) * c1 + (((k1 >>> 16) * c1 & 0xffff) << 16) & 0xffffffff;
+      k1 = k1 << 15 | k1 >>> 17;
+      k1 = (k1 & 0xffff) * c2 + (((k1 >>> 16) * c2 & 0xffff) << 16) & 0xffffffff;
+      h1 ^= k1;
+  }
+
+  h1 ^= key.length;
+  h1 ^= h1 >>> 16;
+  h1 = (h1 & 0xffff) * 0x85ebca6b + (((h1 >>> 16) * 0x85ebca6b & 0xffff) << 16) & 0xffffffff;
+  h1 ^= h1 >>> 13;
+  h1 = (h1 & 0xffff) * 0xc2b2ae35 + (((h1 >>> 16) * 0xc2b2ae35 & 0xffff) << 16) & 0xffffffff;
+  h1 ^= h1 >>> 16;
+  return h1 >>> 0;
+}
+
+function scheduleWork(callback) {
+  setTimeout(callback, 0);
+}
+const VIEW_SIZE = 512;
+let currentView = null;
+let writtenBytes = 0;
+function beginWriting(destination) {
+  currentView = new Uint8Array(VIEW_SIZE);
+  writtenBytes = 0;
+}
+function writeChunk(destination, chunk) {
+  if (chunk.byteLength === 0) {
+    return;
+  }
+
+  if (chunk.byteLength > VIEW_SIZE) {
+    // one that is cached by the streaming renderer. We will enqueu
+    // it directly and expect it is not re-used
+
+
+    if (writtenBytes > 0) {
+      destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    destination.enqueue(chunk);
+    return;
+  }
+
+  let bytesToWrite = chunk;
+  const allowableBytes = currentView.length - writtenBytes;
+
+  if (allowableBytes < bytesToWrite.byteLength) {
+    // this chunk would overflow the current view. We enqueue a full view
+    // and start a new view with the remaining chunk
+    if (allowableBytes === 0) {
+      // the current view is already full, send it
+      destination.enqueue(currentView);
+    } else {
+      // fill up the current view and apply the remaining chunk bytes
+      // to a new view.
+      currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes); // writtenBytes += allowableBytes; // this can be skipped because we are going to immediately reset the view
+
+      destination.enqueue(currentView);
+      bytesToWrite = bytesToWrite.subarray(allowableBytes);
+    }
+
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+
+  currentView.set(bytesToWrite, writtenBytes);
+  writtenBytes += bytesToWrite.byteLength;
+}
+function writeChunkAndReturn(destination, chunk) {
+  writeChunk(destination, chunk); // in web streams there is no backpressure so we can alwas write more
+
+  return true;
+}
+function completeWriting(destination) {
+  if (currentView && writtenBytes > 0) {
+    destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+    currentView = null;
+    writtenBytes = 0;
+  }
+}
+function close(destination) {
+  destination.close();
+}
+const textEncoder = new TextEncoder();
+function stringToChunk(content) {
+  return textEncoder.encode(content);
+}
+function stringToPrecomputedChunk(content) {
+  const precomputedChunk = textEncoder.encode(content);
+
+  return precomputedChunk;
+}
+function clonePrecomputedChunk(precomputedChunk) {
+  return precomputedChunk.byteLength > VIEW_SIZE ? precomputedChunk.slice() : precomputedChunk;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[method-unbinding]
+  if (typeof destination.error === 'function') {
+    // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+    destination.error(error);
+  } else {
+    // Earlier implementations doesn't support this method. In that environment you're
+    // supposed to throw from a promise returned but we don't return a promise in our
+    // approach. We could fork this implementation but this is environment is an edge
+    // case to begin with. It's even less common to run this in an older environment.
+    // Even then, this is not where errors are supposed to happen and they get reported
+    // to a global callback in addition to this anyway. So it's fine just to close this.
+    destination.close();
+  }
+}
+
+const assign = Object.assign;
+
+// -----------------------------------------------------------------------------
+const enableFloat = true; // Enables unstable_useMemoCache hook, intended as a compilation target for
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/* eslint-disable max-len */
+
+const ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
+/* eslint-enable max-len */
+
+const ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
+const VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+const illegalAttributeNameCache = {};
+const validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+  if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+    return true;
+  }
+
+  if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+    return false;
+  }
+
+  if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+    validatedAttributeNameCache[attributeName] = true;
+    return true;
+  }
+
+  illegalAttributeNameCache[attributeName] = true;
+
+  return false;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+const unitlessNumbers = new Set(['animationIterationCount', 'aspectRatio', 'borderImageOutset', 'borderImageSlice', 'borderImageWidth', 'boxFlex', 'boxFlexGroup', 'boxOrdinalGroup', 'columnCount', 'columns', 'flex', 'flexGrow', 'flexPositive', 'flexShrink', 'flexNegative', 'flexOrder', 'gridArea', 'gridRow', 'gridRowEnd', 'gridRowSpan', 'gridRowStart', 'gridColumn', 'gridColumnEnd', 'gridColumnSpan', 'gridColumnStart', 'fontWeight', 'lineClamp', 'lineHeight', 'opacity', 'order', 'orphans', 'scale', 'tabSize', 'widows', 'zIndex', 'zoom', 'fillOpacity', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'MozBoxFlexGroup', 'MozLineClamp', 'msAnimationIterationCount', 'msFlex', 'msZoom', 'msFlexGrow', 'msFlexNegative', 'msFlexOrder', 'msFlexPositive', 'msFlexShrink', 'msGridColumn', 'msGridColumnSpan', 'msGridRow', 'msGridRowSpan', 'WebkitAnimationIterationCount', 'WebkitBoxFlex', 'WebKitBoxFlexGroup', 'WebkitBoxOrdinalGroup', 'WebkitColumnCount', 'WebkitColumns', 'WebkitFlex', 'WebkitFlexGrow', 'WebkitFlexPositive', 'WebkitFlexShrink', 'WebkitLineClamp']);
+function isUnitlessNumber (name) {
+  return unitlessNumbers.has(name);
+}
+
+const aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+  return aliases.get(name) || name;
+}
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// code copied and modified from escape-html
+const matchHtmlRegExp = /["'&<>]/;
+/**
+ * Escapes special characters and HTML entities in a given html string.
+ *
+ * @param  {string} string HTML string to escape for later insertion
+ * @return {string}
+ * @public
+ */
+
+function escapeHtml(string) {
+
+  const str = '' + string;
+  const match = matchHtmlRegExp.exec(str);
+
+  if (!match) {
+    return str;
+  }
+
+  let escape;
+  let html = '';
+  let index;
+  let lastIndex = 0;
+
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        // "
+        escape = '&quot;';
+        break;
+
+      case 38:
+        // &
+        escape = '&amp;';
+        break;
+
+      case 39:
+        // '
+        escape = '&#x27;'; // modified from escape-html; used to be '&#39'
+
+        break;
+
+      case 60:
+        // <
+        escape = '&lt;';
+        break;
+
+      case 62:
+        // >
+        escape = '&gt;';
+        break;
+
+      default:
+        continue;
+    }
+
+    if (lastIndex !== index) {
+      html += str.slice(lastIndex, index);
+    }
+
+    lastIndex = index + 1;
+    html += escape;
+  }
+
+  return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+} // end code copied and modified from escape-html
+
+/**
+ * Escapes text to prevent scripting attacks.
+ *
+ * @param {*} text Text value to escape.
+ * @return {string} An escaped string.
+ */
+
+
+function escapeTextForBrowser(text) {
+  if (typeof text === 'boolean' || typeof text === 'number') {
+    // this shortcircuit helps perf for types that we know will never have
+    // special characters, especially given that this function is used often
+    // for numeric dom ids.
+    return '' + text;
+  }
+
+  return escapeHtml(text);
+}
+
+const uppercasePattern = /([A-Z])/g;
+const msPattern = /^ms-/;
+/**
+ * Hyphenates a camelcased CSS property name, for example:
+ *
+ *   > hyphenateStyleName('backgroundColor')
+ *   < "background-color"
+ *   > hyphenateStyleName('MozTransition')
+ *   < "-moz-transition"
+ *   > hyphenateStyleName('msTransition')
+ *   < "-ms-transition"
+ *
+ * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
+ * is converted to `-ms-`.
+ */
+
+function hyphenateStyleName(name) {
+  return name.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern, '-ms-');
+}
+
+function sanitizeURL(url) {
+
+  return url;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+// The build script is at scripts/rollup/generate-inline-fizz-runtime.js.
+// Run `yarn generate-inline-fizz-runtime` to generate.
+const clientRenderBoundary = '$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};';
+const completeBoundary = '$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};';
+const completeBoundaryWithStyles = '$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};';
+const completeSegment = '$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};';
+const formReplaying = 'addEventListener("submit",function(a){if(!a.defaultPrevented){var c=a.target,d=a.submitter,e=c.action,b=d;if(d){var f=d.getAttribute("formAction");null!=f&&(e=f,b=null)}"javascript:throw new Error(\'A React form was unexpectedly submitted.\')"===e&&(a.preventDefault(),b?(a=document.createElement("input"),a.name=b.name,a.value=b.value,b.parentNode.insertBefore(a,b),b=new FormData(c),a.parentNode.removeChild(a)):b=new FormData(c),a=c.getRootNode(),(a.$$reactFormReplay=a.$$reactFormReplay||[]).push(c,\nd,b))}});';
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+// same object across all transitions.
+
+const sharedNotPendingObject = {
+  pending: false,
+  data: null,
+  method: null,
+  action: null
+};
+const NotPending = sharedNotPendingObject;
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+const ReactDOMServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMServerDispatcher;
+} // We make every property of the descriptor optional because it is not a contract that
+const ScriptStreamingFormat = 0;
+const DataStreamingFormat = 1;
+const NothingSent
+/*                      */
+= 0b00000;
+const SentCompleteSegmentFunction
+/*      */
+= 0b00001;
+const SentCompleteBoundaryFunction
+/*     */
+= 0b00010;
+const SentClientRenderFunction
+/*         */
+= 0b00100;
+const SentStyleInsertionFunction
+/*       */
+= 0b01000;
+const SentFormReplayingRuntime
+/*         */
+= 0b10000; // Per request, global state that is not contextual to the rendering subtree.
+// This cannot be resumed and therefore should only contain things that are
+// temporary working state or are never used in the prerender pass.
+// Credentials here are things that affect whether a browser will make a request
+// as well as things that affect which connection the browser will use for that request.
+// We want these to be aligned across preloads and resources because otherwise the preload
+// will be wasted.
+// We investigated whether referrerPolicy should be included here but from experimentation
+// it seems that browsers do not treat this as part of the http cache key and does not affect
+// which connection is used.
+
+const EXISTS = null; // This constant is to mark preloads that have no unique credentials
+// to convey. It should never be checked by identity and we should not
+// assume Preload values in ResumableState equal this value because they
+// will have come from some parsed input.
+
+const PRELOAD_NO_CREDS = [];
+// This is resumable and therefore should be serializable.
+
+
+const dataElementQuotedEnd = stringToPrecomputedChunk('"></template>');
+const startInlineScript = stringToPrecomputedChunk('<script>');
+const endInlineScript = stringToPrecomputedChunk('</script>');
+const startScriptSrc = stringToPrecomputedChunk('<script src="');
+const startModuleSrc = stringToPrecomputedChunk('<script type="module" src="');
+const scriptNonce = stringToPrecomputedChunk('" nonce="');
+const scriptIntegirty = stringToPrecomputedChunk('" integrity="');
+const scriptCrossOrigin = stringToPrecomputedChunk('" crossorigin="');
+const endAsyncScript = stringToPrecomputedChunk('" async=""></script>');
+/**
+ * This escaping function is designed to work with bootstrapScriptContent and importMap only.
+ * because we know we are escaping the entire script. We can avoid for instance
+ * escaping html comment string sequences that are valid javascript as well because
+ * if there are no sebsequent <script sequences the html parser will never enter
+ * script data double escaped state (see: https://www.w3.org/TR/html53/syntax.html#script-data-double-escaped-state)
+ *
+ * While untrusted script content should be made safe before using this api it will
+ * ensure that the script cannot be early terminated or never terminated state
+ */
+
+function escapeBootstrapAndImportMapScriptContent(scriptText) {
+
+  return ('' + scriptText).replace(scriptRegex, scriptReplacer);
+}
+
+const scriptRegex = /(<\/|<)(s)(cript)/gi;
+
+const scriptReplacer = (match, prefix, s, suffix) => "" + prefix + (s === 's' ? '\\u0073' : '\\u0053') + suffix;
+
+const importMapScriptStart = stringToPrecomputedChunk('<script type="importmap">');
+const importMapScriptEnd = stringToPrecomputedChunk('</script>'); // Since we store headers as strings we deal with their length in utf16 code units
+// rather than visual characters or the utf8 encoding that is used for most binary
+// serialization. Some common HTTP servers only allow for headers to be 4kB in length.
+// We choose a default length that is likely to be well under this already limited length however
+// pathological cases may still cause the utf-8 encoding of the headers to approach this limit.
+// It should also be noted that this maximum is a soft maximum. we have not reached the limit we will
+// allow one more header to be captured which means in practice if the limit is approached it will be exceeded
+
+const DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS = 2000; // Allows us to keep track of what we've already written so we can refer back to it.
+// if passed externalRuntimeConfig and the enableFizzExternalRuntime feature flag
+// is set, the server will send instructions via data attributes (instead of inline scripts)
+
+function createRenderState(resumableState, nonce, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
+  const inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
+  const idPrefix = resumableState.idPrefix;
+  const bootstrapChunks = [];
+  let externalRuntimeScript = null;
+  const bootstrapScriptContent = resumableState.bootstrapScriptContent,
+        bootstrapScripts = resumableState.bootstrapScripts,
+        bootstrapModules = resumableState.bootstrapModules;
+
+  if (bootstrapScriptContent !== undefined) {
+    bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapAndImportMapScriptContent(bootstrapScriptContent)), endInlineScript);
+  }
+
+  {
+
+    if (externalRuntimeConfig !== undefined) {
+      if (typeof externalRuntimeConfig === 'string') {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig,
+          async: true,
+          integrity: undefined,
+          nonce: nonce
+        });
+      } else {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig.src,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig.src,
+          async: true,
+          integrity: externalRuntimeConfig.integrity,
+          nonce: nonce
+        });
+      }
+    }
+  }
+
+  const importMapChunks = [];
+
+  if (importMap !== undefined) {
+    const map = importMap;
+    importMapChunks.push(importMapScriptStart);
+    importMapChunks.push(stringToChunk(escapeBootstrapAndImportMapScriptContent(JSON.stringify(map))));
+    importMapChunks.push(importMapScriptEnd);
+  }
+
+  const headers = onHeaders ? {
+    preconnects: '',
+    fontPreloads: '',
+    highImagePreloads: '',
+    remainingCapacity: typeof maxHeadersLength === 'number' ? maxHeadersLength : DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS
+  } : null;
+  const renderState = {
+    placeholderPrefix: stringToPrecomputedChunk(idPrefix + 'P:'),
+    segmentPrefix: stringToPrecomputedChunk(idPrefix + 'S:'),
+    boundaryPrefix: stringToPrecomputedChunk(idPrefix + 'B:'),
+    startInlineScript: inlineScriptWithNonce,
+    htmlChunks: null,
+    headChunks: null,
+    externalRuntimeScript: externalRuntimeScript,
+    bootstrapChunks: bootstrapChunks,
+    onHeaders,
+    headers,
+    resets: {
+      font: {},
+      dns: {},
+      connect: {
+        default: {},
+        anonymous: {},
+        credentials: {}
+      },
+      image: {},
+      style: {}
+    },
+    charsetChunks: [],
+    preconnectChunks: [],
+    importMapChunks,
+    preloadChunks: [],
+    hoistableChunks: [],
+    // cleared on flush
+    preconnects: new Set(),
+    fontPreloads: new Set(),
+    highImagePreloads: new Set(),
+    // usedImagePreloads: new Set(),
+    styles: new Map(),
+    bootstrapScripts: new Set(),
+    scripts: new Set(),
+    bulkPreloads: new Set(),
+    preloads: {
+      images: new Map(),
+      stylesheets: new Map(),
+      scripts: new Map(),
+      moduleScripts: new Map()
+    },
+    nonce,
+    // like a module global for currently rendering boundary
+    boundaryResources: null,
+    stylesToHoist: false
+  };
+
+  if (bootstrapScripts !== undefined) {
+    for (let i = 0; i < bootstrapScripts.length; i++) {
+      const scriptConfig = bootstrapScripts[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'preload',
+        as: 'script',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startScriptSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  if (bootstrapModules !== undefined) {
+    for (let i = 0; i < bootstrapModules.length; i++) {
+      const scriptConfig = bootstrapModules[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'modulepreload',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startModuleSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  return renderState;
+}
+function resumeRenderState(resumableState, nonce) {
+  return createRenderState(resumableState, nonce, undefined, undefined, undefined, undefined);
+}
+function createResumableState(identifierPrefix, externalRuntimeConfig, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
+  const idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
+  let streamingFormat = ScriptStreamingFormat;
+
+  {
+    if (externalRuntimeConfig !== undefined) {
+      streamingFormat = DataStreamingFormat;
+    }
+  }
+
+  return {
+    idPrefix: idPrefix,
+    nextFormID: 0,
+    streamingFormat,
+    bootstrapScriptContent,
+    bootstrapScripts,
+    bootstrapModules,
+    instructions: NothingSent,
+    hasBody: false,
+    hasHtml: false,
+    // @TODO add bootstrap script to implicit preloads
+    // persistent
+    unknownResources: {},
+    dnsResources: {},
+    connectResources: {
+      default: {},
+      anonymous: {},
+      credentials: {}
+    },
+    imageResources: {},
+    styleResources: {},
+    scriptResources: {},
+    moduleUnknownResources: {},
+    moduleScriptResources: {}
+  };
+}
+function resetResumableState(resumableState, renderState) {
+  // Resets the resumable state based on what didn't manage to fully flush in the render state.
+  // This currently assumes nothing was flushed.
+  resumableState.nextFormID = 0;
+  resumableState.hasBody = false;
+  resumableState.hasHtml = false;
+  resumableState.unknownResources = {
+    font: renderState.resets.font
+  };
+  resumableState.dnsResources = renderState.resets.dns;
+  resumableState.connectResources = renderState.resets.connect;
+  resumableState.imageResources = renderState.resets.image;
+  resumableState.styleResources = renderState.resets.style;
+  resumableState.scriptResources = {};
+  resumableState.moduleUnknownResources = {};
+  resumableState.moduleScriptResources = {};
+} // Constants for the insertion mode we're currently writing in. We don't encode all HTML5 insertion
+// modes. We only include the variants as they matter for the sake of our purposes.
+// We don't actually provide the namespace therefore we use constants instead of the string.
+
+const ROOT_HTML_MODE = 0; // Used for the root most element tag.
+// We have a less than HTML_HTML_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const HTML_HTML_MODE = 1; // Used for the <html> if it is at the top level.
+
+const HTML_MODE = 2;
+const SVG_MODE = 3;
+const MATHML_MODE = 4;
+const HTML_TABLE_MODE = 5;
+const HTML_TABLE_BODY_MODE = 6;
+const HTML_TABLE_ROW_MODE = 7;
+const HTML_COLGROUP_MODE = 8; // We have a greater than HTML_TABLE_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const NO_SCOPE =
+/*         */
+0b00;
+const NOSCRIPT_SCOPE =
+/*   */
+0b01;
+const PICTURE_SCOPE =
+/*    */
+0b10; // Lets us keep track of contextual state and pick it back up after suspending.
+
+function createFormatContext(insertionMode, selectedValue, tagScope) {
+  return {
+    insertionMode,
+    selectedValue,
+    tagScope
+  };
+}
+
+function createRootFormatContext(namespaceURI) {
+  const insertionMode = namespaceURI === 'http://www.w3.org/2000/svg' ? SVG_MODE : namespaceURI === 'http://www.w3.org/1998/Math/MathML' ? MATHML_MODE : ROOT_HTML_MODE;
+  return createFormatContext(insertionMode, null, NO_SCOPE);
+}
+function getChildFormatContext(parentContext, type, props) {
+  switch (type) {
+    case 'noscript':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | NOSCRIPT_SCOPE);
+
+    case 'select':
+      return createFormatContext(HTML_MODE, props.value != null ? props.value : props.defaultValue, parentContext.tagScope);
+
+    case 'svg':
+      return createFormatContext(SVG_MODE, null, parentContext.tagScope);
+
+    case 'picture':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | PICTURE_SCOPE);
+
+    case 'math':
+      return createFormatContext(MATHML_MODE, null, parentContext.tagScope);
+
+    case 'foreignObject':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    // Table parents are special in that their children can only be created at all if they're
+    // wrapped in a table parent. So we need to encode that we're entering this mode.
+
+    case 'table':
+      return createFormatContext(HTML_TABLE_MODE, null, parentContext.tagScope);
+
+    case 'thead':
+    case 'tbody':
+    case 'tfoot':
+      return createFormatContext(HTML_TABLE_BODY_MODE, null, parentContext.tagScope);
+
+    case 'colgroup':
+      return createFormatContext(HTML_COLGROUP_MODE, null, parentContext.tagScope);
+
+    case 'tr':
+      return createFormatContext(HTML_TABLE_ROW_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode >= HTML_TABLE_MODE) {
+    // Whatever tag this was, it wasn't a table parent or other special parent, so we must have
+    // entered plain HTML again.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode === ROOT_HTML_MODE) {
+    if (type === 'html') {
+      // We've emitted the root and is now in <html> mode.
+      return createFormatContext(HTML_HTML_MODE, null, parentContext.tagScope);
+    } else {
+      // We've emitted the root and is now in plain HTML mode.
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    }
+  } else if (parentContext.insertionMode === HTML_HTML_MODE) {
+    // We've emitted the document element and is now in plain HTML mode.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  return parentContext;
+}
+function makeId(resumableState, treeId, localId) {
+  const idPrefix = resumableState.idPrefix;
+  let id = ':' + idPrefix + 'R' + treeId; // Unless this is the first id at this level, append a number at the end
+  // that represents the position of this useId hook among all the useId
+  // hooks for this fiber.
+
+  if (localId > 0) {
+    id += 'H' + localId.toString(32);
+  }
+
+  return id + ':';
+}
+
+function encodeHTMLTextNode(text) {
+  return escapeTextForBrowser(text);
+}
+
+const textSeparator = stringToPrecomputedChunk('<!-- -->');
+function pushTextInstance(target, text, renderState, textEmbedded) {
+  if (text === '') {
+    // Empty text doesn't have a DOM node representation and the hydration is aware of this.
+    return textEmbedded;
+  }
+
+  if (textEmbedded) {
+    target.push(textSeparator);
+  }
+
+  target.push(stringToChunk(encodeHTMLTextNode(text)));
+  return true;
+} // Called when Fizz is done with a Segment. Currently the only purpose is to conditionally
+// emit a text separator when we don't know for sure it is safe to omit
+
+function pushSegmentFinale(target, renderState, lastPushedText, textEmbedded) {
+  if (lastPushedText && textEmbedded) {
+    target.push(textSeparator);
+  }
+}
+const styleNameCache = new Map();
+
+function processStyleName(styleName) {
+  const chunk = styleNameCache.get(styleName);
+
+  if (chunk !== undefined) {
+    return chunk;
+  }
+
+  const result = stringToPrecomputedChunk(escapeTextForBrowser(hyphenateStyleName(styleName)));
+  styleNameCache.set(styleName, result);
+  return result;
+}
+
+const styleAttributeStart = stringToPrecomputedChunk(' style="');
+const styleAssign = stringToPrecomputedChunk(':');
+const styleSeparator = stringToPrecomputedChunk(';');
+
+function pushStyleAttribute(target, style) {
+  if (typeof style !== 'object') {
+    throw new Error('The `style` prop expects a mapping from style properties to values, ' + "not a string. For example, style={{marginRight: spacing + 'em'}} when " + 'using JSX.');
+  }
+
+  let isFirst = true;
+
+  for (const styleName in style) {
+    if (!hasOwnProperty.call(style, styleName)) {
+      continue;
+    } // If you provide unsafe user data here they can inject arbitrary CSS
+    // which may be problematic (I couldn't repro this):
+    // https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet
+    // http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/
+    // This is not an XSS hole but instead a potential CSS injection issue
+    // which has lead to a greater discussion about how we're going to
+    // trust URLs moving forward. See #2115901
+
+
+    const styleValue = style[styleName];
+
+    if (styleValue == null || typeof styleValue === 'boolean' || styleValue === '') {
+      // TODO: We used to set empty string as a style with an empty value. Does that ever make sense?
+      continue;
+    }
+
+    let nameChunk;
+    let valueChunk;
+    const isCustomProperty = styleName.indexOf('--') === 0;
+
+    if (isCustomProperty) {
+      nameChunk = stringToChunk(escapeTextForBrowser(styleName));
+
+      valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+    } else {
+
+      nameChunk = processStyleName(styleName);
+
+      if (typeof styleValue === 'number') {
+        if (styleValue !== 0 && !isUnitlessNumber(styleName)) {
+          valueChunk = stringToChunk(styleValue + 'px'); // Presumes implicit 'px' suffix for unitless numbers
+        } else {
+          valueChunk = stringToChunk('' + styleValue);
+        }
+      } else {
+
+        valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+      }
+    }
+
+    if (isFirst) {
+      isFirst = false; // If it's first, we don't need any separators prefixed.
+
+      target.push(styleAttributeStart, nameChunk, styleAssign, valueChunk);
+    } else {
+      target.push(styleSeparator, nameChunk, styleAssign, valueChunk);
+    }
+  }
+
+  if (!isFirst) {
+    target.push(attributeEnd);
+  }
+}
+
+const attributeSeparator = stringToPrecomputedChunk(' ');
+const attributeAssign = stringToPrecomputedChunk('="');
+const attributeEnd = stringToPrecomputedChunk('"');
+const attributeEmptyString = stringToPrecomputedChunk('=""');
+
+function pushBooleanAttribute(target, name, value) // not null or undefined
+{
+  if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+    target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+  }
+}
+
+function pushStringAttribute(target, name, value) // not null or undefined
+{
+  if (typeof value !== 'function' && typeof value !== 'symbol' && typeof value !== 'boolean') {
+    target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+  }
+}
+
+function makeFormFieldPrefix(resumableState) {
+  const id = resumableState.nextFormID++;
+  return resumableState.idPrefix + id;
+} // Since this will likely be repeated a lot in the HTML, we use a more concise message
+// than on the client and hopefully it's googleable.
+
+
+const actionJavaScriptURL = stringToPrecomputedChunk(escapeTextForBrowser( // eslint-disable-next-line no-script-url
+"javascript:throw new Error('A React form was unexpectedly submitted.')"));
+const startHiddenInputChunk = stringToPrecomputedChunk('<input type="hidden"');
+
+function pushAdditionalFormField(value, key) {
+  const target = this;
+  target.push(startHiddenInputChunk);
+
+  if (typeof value !== 'string') {
+    throw new Error('File/Blob fields are not yet supported in progressive forms. ' + 'It probably means you are closing over binary data or FormData in a Server Action.');
+  }
+
+  pushStringAttribute(target, 'name', key);
+  pushStringAttribute(target, 'value', value);
+  target.push(endOfStartTagSelfClosing);
+}
+
+function pushAdditionalFormFields(target, formData) {
+  if (formData !== null) {
+    // $FlowFixMe[prop-missing]: FormData has forEach.
+    formData.forEach(pushAdditionalFormField, target);
+  }
+}
+
+function pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name) {
+  let formData = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      name = customFields.name;
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('formAction'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      name = null;
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (name != null) {
+    pushAttribute(target, 'name', name);
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'formAction', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'formEncType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'formMethod', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'formTarget', formTarget);
+  }
+
+  return formData;
+}
+
+function pushAttribute(target, name, value) // not null or undefined
+{
+  switch (name) {
+    // These are very common props and therefore are in the beginning of the switch.
+    // TODO: aria-label is a very common prop but allows booleans so is not like the others
+    // but should ideally go in this list too.
+    case 'className':
+      {
+        pushStringAttribute(target, 'class', value);
+        break;
+      }
+
+    case 'tabIndex':
+      {
+        pushStringAttribute(target, 'tabindex', value);
+        break;
+      }
+
+    case 'dir':
+    case 'role':
+    case 'viewBox':
+    case 'width':
+    case 'height':
+      {
+        pushStringAttribute(target, name, value);
+        break;
+      }
+
+    case 'style':
+      {
+        pushStyleAttribute(target, value);
+        return;
+      }
+
+    case 'src':
+    case 'href':
+      {
+        {
+          if (value === '') {
+
+            return;
+          }
+        }
+      }
+    // Fall through to the last case which shouldn't remove empty strings.
+
+    case 'action':
+    case 'formAction':
+      {
+        // TODO: Consider only special casing these for each tag.
+        if (value == null || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'defaultValue':
+    case 'defaultChecked': // These shouldn't be set as attributes on generic HTML elements.
+
+    case 'innerHTML': // Must use dangerouslySetInnerHTML instead.
+
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+      // Ignored. These are built-in to React on the client.
+      return;
+
+    case 'autoFocus':
+    case 'multiple':
+    case 'muted':
+      {
+        pushBooleanAttribute(target, name.toLowerCase(), value);
+        return;
+      }
+
+    case 'xlinkHref':
+      {
+        if (typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk('xlink:href'), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'contentEditable':
+    case 'spellCheck':
+    case 'draggable':
+    case 'value':
+    case 'autoReverse':
+    case 'externalResourcesRequired':
+    case 'focusable':
+    case 'preserveAlpha':
+      {
+        // Booleanish String
+        // These are "enumerated" attributes that accept "true" and "false".
+        // In React, we let users pass `true` and `false` even though technically
+        // these aren't boolean attributes (they are coerced to strings).
+        if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'allowFullScreen':
+    case 'async':
+    case 'autoPlay':
+    case 'controls':
+    case 'default':
+    case 'defer':
+    case 'disabled':
+    case 'disablePictureInPicture':
+    case 'disableRemotePlayback':
+    case 'formNoValidate':
+    case 'hidden':
+    case 'loop':
+    case 'noModule':
+    case 'noValidate':
+    case 'open':
+    case 'playsInline':
+    case 'readOnly':
+    case 'required':
+    case 'reversed':
+    case 'scoped':
+    case 'seamless':
+    case 'itemScope':
+      {
+        // Boolean
+        if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        }
+
+        return;
+      }
+
+    case 'capture':
+    case 'download':
+      {
+        // Overloaded Boolean
+        if (value === true) {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        } else if (value === false) ; else if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'cols':
+    case 'rows':
+    case 'size':
+    case 'span':
+      {
+        // These are HTML attributes that must be positive numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value) && value >= 1) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'rowSpan':
+    case 'start':
+      {
+        // These are HTML attributes that must be numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value)) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'xlinkActuate':
+      pushStringAttribute(target, 'xlink:actuate', value);
+      return;
+
+    case 'xlinkArcrole':
+      pushStringAttribute(target, 'xlink:arcrole', value);
+      return;
+
+    case 'xlinkRole':
+      pushStringAttribute(target, 'xlink:role', value);
+      return;
+
+    case 'xlinkShow':
+      pushStringAttribute(target, 'xlink:show', value);
+      return;
+
+    case 'xlinkTitle':
+      pushStringAttribute(target, 'xlink:title', value);
+      return;
+
+    case 'xlinkType':
+      pushStringAttribute(target, 'xlink:type', value);
+      return;
+
+    case 'xmlBase':
+      pushStringAttribute(target, 'xml:base', value);
+      return;
+
+    case 'xmlLang':
+      pushStringAttribute(target, 'xml:lang', value);
+      return;
+
+    case 'xmlSpace':
+      pushStringAttribute(target, 'xml:space', value);
+      return;
+
+    default:
+      if ( // shouldIgnoreAttribute
+      // We have already filtered out null/undefined and reserved words.
+      name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+        return;
+      }
+
+      const attributeName = getAttributeAlias(name);
+
+      if (isAttributeNameSafe(attributeName)) {
+        // shouldRemoveAttribute
+        switch (typeof value) {
+          case 'function':
+          case 'symbol':
+            // eslint-disable-line
+            return;
+
+          case 'boolean':
+            {
+              const prefix = attributeName.toLowerCase().slice(0, 5);
+
+              if (prefix !== 'data-' && prefix !== 'aria-') {
+                return;
+              }
+            }
+        }
+
+        target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+      }
+
+  }
+}
+
+const endOfStartTag = stringToPrecomputedChunk('>');
+const endOfStartTagSelfClosing = stringToPrecomputedChunk('/>');
+
+function pushInnerHTML(target, innerHTML, children) {
+  if (innerHTML != null) {
+    if (children != null) {
+      throw new Error('Can only set one of `children` or `props.dangerouslySetInnerHTML`.');
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw new Error('`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. ' + 'Please visit https://reactjs.org/link/dangerously-set-inner-html ' + 'for more information.');
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+
+      target.push(stringToChunk('' + html));
+    }
+  }
+} // TODO: Move these to RenderState so that we warn for every request.
+
+function pushStartSelect(target, props) {
+
+  target.push(startChunkForTag('select'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          // TODO: This doesn't really make sense for select since it can't use the controlled
+          // value in the innerHTML.
+          innerHTML = propValue;
+          break;
+
+        case 'defaultValue':
+        case 'value':
+          // These are set on the Context instead and applied to the nested options.
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+function flattenOptionChildren(children) {
+  let content = ''; // Flatten children and warn if they aren't strings or numbers;
+  // invalid types are ignored.
+
+  React.Children.forEach(children, function (child) {
+    if (child == null) {
+      return;
+    }
+
+    content += child;
+  });
+  return content;
+}
+
+const selectedMarkerAttribute = stringToPrecomputedChunk(' selected=""');
+
+function pushStartOption(target, props, formatContext) {
+  const selectedValue = formatContext.selectedValue;
+  target.push(startChunkForTag('option'));
+  let children = null;
+  let value = null;
+  let selected = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'selected':
+          // ignore
+          selected = propValue;
+
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+        // We intentionally fallthrough to also set the attribute on the node.
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (selectedValue != null) {
+    let stringValue;
+
+    if (value !== null) {
+
+      stringValue = '' + value;
+    } else {
+
+      stringValue = flattenOptionChildren(children);
+    }
+
+    if (isArray(selectedValue)) {
+      // multiple
+      for (let i = 0; i < selectedValue.length; i++) {
+
+        const v = '' + selectedValue[i];
+
+        if (v === stringValue) {
+          target.push(selectedMarkerAttribute);
+          break;
+        }
+      }
+    } else {
+
+      if ('' + selectedValue === stringValue) {
+        target.push(selectedMarkerAttribute);
+      }
+    }
+  } else if (selected) {
+    target.push(selectedMarkerAttribute);
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const formReplayingRuntimeScript = stringToPrecomputedChunk(formReplaying);
+
+function injectFormReplayingRuntime(resumableState, renderState) {
+  // If we haven't sent it yet, inject the runtime that tracks submitted JS actions
+  // for later replaying by Fiber. If we use an external runtime, we don't need
+  // to emit anything. It's always used.
+  if ((resumableState.instructions & SentFormReplayingRuntime) === NothingSent && (!renderState.externalRuntimeScript)) {
+    resumableState.instructions |= SentFormReplayingRuntime;
+    renderState.bootstrapChunks.unshift(renderState.startInlineScript, formReplayingRuntimeScript, endInlineScript);
+  }
+}
+
+const formStateMarkerIsMatching = stringToPrecomputedChunk('<!--F!-->');
+const formStateMarkerIsNotMatching = stringToPrecomputedChunk('<!--F-->');
+function pushFormStateMarkerIsMatching(target) {
+  target.push(formStateMarkerIsMatching);
+}
+function pushFormStateMarkerIsNotMatching(target) {
+  target.push(formStateMarkerIsNotMatching);
+}
+
+function pushStartForm(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('form'));
+  let children = null;
+  let innerHTML = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'action':
+          formAction = propValue;
+          break;
+
+        case 'encType':
+          formEncType = propValue;
+          break;
+
+        case 'method':
+          formMethod = propValue;
+          break;
+
+        case 'target':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  let formData = null;
+  let formActionName = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+      formActionName = customFields.name;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('action'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'action', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'encType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'method', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'target', formTarget);
+  }
+
+  target.push(endOfStartTag);
+
+  if (formActionName !== null) {
+    target.push(startHiddenInputChunk);
+    pushStringAttribute(target, 'name', formActionName);
+    target.push(endOfStartTagSelfClosing);
+    pushAdditionalFormFields(target, formData);
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushInput(target, props, resumableState, renderState) {
+
+  target.push(startChunkForTag('input'));
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+  let value = null;
+  let defaultValue = null;
+  let checked = null;
+  let defaultChecked = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('input' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        case 'defaultChecked':
+          defaultChecked = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'checked':
+          checked = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+
+  if (checked !== null) {
+    pushBooleanAttribute(target, 'checked', checked);
+  } else if (defaultChecked !== null) {
+    pushBooleanAttribute(target, 'checked', defaultChecked);
+  }
+
+  if (value !== null) {
+    pushAttribute(target, 'value', value);
+  } else if (defaultValue !== null) {
+    pushAttribute(target, 'value', defaultValue);
+  }
+
+  target.push(endOfStartTagSelfClosing); // We place any additional hidden form fields after the input.
+
+  pushAdditionalFormFields(target, formData);
+  return null;
+}
+
+function pushStartButton(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('button'));
+  let children = null;
+  let innerHTML = null;
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+  target.push(endOfStartTag); // We place any additional hidden form fields we need to include inside the button itself.
+
+  pushAdditionalFormFields(target, formData);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartTextArea(target, props) {
+
+  target.push(startChunkForTag('textarea'));
+  let value = null;
+  let defaultValue = null;
+  let children = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          throw new Error('`dangerouslySetInnerHTML` does not make sense on <textarea>.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (value === null && defaultValue !== null) {
+    value = defaultValue;
+  }
+
+  target.push(endOfStartTag); // TODO (yungsters): Remove support for children content in <textarea>.
+
+  if (children != null) {
+
+    if (value != null) {
+      throw new Error('If you supply `defaultValue` on a <textarea>, do not pass children.');
+    }
+
+    if (isArray(children)) {
+      if (children.length > 1) {
+        throw new Error('<textarea> can only have at most one child.');
+      } // TODO: remove the coercion and the DEV check below because it will
+
+      value = '' + children[0];
+    }
+
+    value = '' + children;
+  }
+
+  if (typeof value === 'string' && value[0] === '\n') {
+    // text/html ignores the first character in these tags if it's a newline
+    // Prefer to break application/xml over text/html (for now) by adding
+    // a newline specifically to get eaten by the parser. (Alternately for
+    // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+    // \r is normalized out by HTMLTextAreaElement#value.)
+    // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+    // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+    // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+    // See: Parsing of "textarea" "listing" and "pre" elements
+    //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+    target.push(leadingNewline);
+  } // ToString and push directly instead of recurse over children.
+  // We don't really support complex children in the value anyway.
+  // This also currently avoids a trailing comment node which breaks textarea.
+
+
+  if (value !== null) {
+
+    target.push(stringToChunk(encodeHTMLTextNode('' + value)));
+  }
+
+  return null;
+}
+
+function pushMeta(target, props, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      return pushSelfClosing(target, props, 'meta');
+    } else {
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      if (typeof props.charSet === 'string') {
+        return pushSelfClosing(renderState.charsetChunks, props, 'meta');
+      } else if (props.name === 'viewport') {
+        // "viewport" isn't related to preconnect but it has the right priority
+        return pushSelfClosing(renderState.preconnectChunks, props, 'meta');
+      } else {
+        return pushSelfClosing(renderState.hoistableChunks, props, 'meta');
+      }
+    }
+  }
+}
+
+function pushLink(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const rel = props.rel;
+    const href = props.href;
+    const precedence = props.precedence;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof rel !== 'string' || typeof href !== 'string' || href === '') {
+
+      pushLinkImpl(target, props);
+      return null;
+    }
+
+    if (props.rel === 'stylesheet') {
+      // This <link> may hoistable as a Stylesheet Resource, otherwise it will emit in place
+      const key = getResourceKey(href);
+
+      if (typeof precedence !== 'string' || props.disabled != null || props.onLoad || props.onError) {
+
+        return pushLinkImpl(target, props);
+      } else {
+        // This stylesheet refers to a Resource and we create a new one if necessary
+        let styleQueue = renderState.styles.get(precedence);
+        const hasKey = resumableState.styleResources.hasOwnProperty(key);
+        const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+        if (resourceState !== EXISTS) {
+          // We are going to create this resource now so it is marked as Exists
+          resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+          // to create a StyleQueue
+
+          if (!styleQueue) {
+            styleQueue = {
+              precedence: stringToChunk(escapeTextForBrowser(precedence)),
+              rules: [],
+              hrefs: [],
+              sheets: new Map()
+            };
+            renderState.styles.set(precedence, styleQueue);
+          }
+
+          const resource = {
+            state: PENDING$1,
+            props: stylesheetPropsFromRawProps(props)
+          };
+
+          if (resourceState) {
+            // When resourceState is truty it is a Preload state. We cast it for clarity
+            const preloadState = resourceState;
+
+            if (preloadState.length === 2) {
+              adoptPreloadCredentials(resource.props, preloadState);
+            }
+
+            const preloadResource = renderState.preloads.stylesheets.get(key);
+
+            if (preloadResource && preloadResource.length > 0) {
+              // The Preload for this resource was created in this render pass and has not flushed yet so
+              // we need to clear it to avoid it flushing.
+              preloadResource.length = 0;
+            } else {
+              // Either the preload resource from this render already flushed in this render pass
+              // or the preload flushed in a prior pass (prerender). In either case we need to mark
+              // this resource as already having been preloaded.
+              resource.state = PRELOADED;
+            }
+          } // We add the newly created resource to our StyleQueue and if necessary
+          // track the resource with the currently rendering boundary
+
+
+          styleQueue.sheets.set(key, resource);
+
+          if (renderState.boundaryResources) {
+            renderState.boundaryResources.stylesheets.add(resource);
+          }
+        } else {
+          // We need to track whether this boundary should wait on this resource or not.
+          // Typically this resource should always exist since we either had it or just created
+          // it. However, it's possible when you resume that the style has already been emitted
+          // and then it wouldn't be recreated in the RenderState and there's no need to track
+          // it again since we should've hoisted it to the shell already.
+          if (styleQueue) {
+            const resource = styleQueue.sheets.get(key);
+
+            if (resource) {
+              if (renderState.boundaryResources) {
+                renderState.boundaryResources.stylesheets.add(resource);
+              }
+            }
+          }
+        }
+
+        if (textEmbedded) {
+          // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+          // to be safe and assume text will follow by inserting a textSeparator
+          target.push(textSeparator);
+        }
+
+        return null;
+      }
+    } else if (props.onLoad || props.onError) {
+      // When using load handlers we cannot hoist and need to emit links in place
+      return pushLinkImpl(target, props);
+    } else {
+      // We can hoist this link so we may need to emit a text separator.
+      // @TODO refactor text separators so we don't have to defensively add
+      // them when we don't end up emitting a tag as a result of pushStartInstance
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      switch (props.rel) {
+        case 'preconnect':
+        case 'dns-prefetch':
+          return pushLinkImpl(renderState.preconnectChunks, props);
+
+        case 'preload':
+          return pushLinkImpl(renderState.preloadChunks, props);
+
+        default:
+          return pushLinkImpl(renderState.hoistableChunks, props);
+      }
+    }
+  }
+}
+
+function pushLinkImpl(target, props) {
+  target.push(startChunkForTag('link'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStyle(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+
+  {
+    const precedence = props.precedence;
+    const href = props.href;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof precedence !== 'string' || typeof href !== 'string' || href === '') {
+      // This style tag is not able to be turned into a Style Resource
+      return pushStyleImpl(target, props);
+    }
+
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS;
+
+      if (!styleQueue) {
+        // This is the first time we've encountered this precedence we need
+        // to create a StyleQueue.
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [stringToChunk(escapeTextForBrowser(href))],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      } else {
+        // We have seen this precedence before and need to track this href
+        styleQueue.hrefs.push(stringToChunk(escapeTextForBrowser(href)));
+      }
+
+      pushStyleContents(styleQueue.rules, props);
+    }
+
+    if (styleQueue) {
+      // We need to track whether this boundary should wait on this resource or not.
+      // Typically this resource should always exist since we either had it or just created
+      // it. However, it's possible when you resume that the style has already been emitted
+      // and then it wouldn't be recreated in the RenderState and there's no need to track
+      // it again since we should've hoisted it to the shell already.
+      if (renderState.boundaryResources) {
+        renderState.boundaryResources.styles.add(styleQueue);
+      }
+    }
+
+    if (textEmbedded) {
+      // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+  }
+}
+
+function pushStyleImpl(target, props) {
+  target.push(startChunkForTag('style'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('style'));
+  return null;
+}
+
+function pushStyleContents(target, props) {
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+      }
+    }
+  }
+
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  return;
+}
+
+function pushImg(target, props, resumableState, renderState, pictureTagInScope) {
+  const src = props.src,
+        srcSet = props.srcSet;
+
+  if (props.loading !== 'lazy' && (src || srcSet) && (typeof src === 'string' || src == null) && (typeof srcSet === 'string' || srcSet == null) && props.fetchPriority !== 'low' && pictureTagInScope === false && // We exclude data URIs in src and srcSet since these should not be preloaded
+  !(typeof src === 'string' && src[4] === ':' && (src[0] === 'd' || src[0] === 'D') && (src[1] === 'a' || src[1] === 'A') && (src[2] === 't' || src[2] === 'T') && (src[3] === 'a' || src[3] === 'A')) && !(typeof srcSet === 'string' && srcSet[4] === ':' && (srcSet[0] === 'd' || srcSet[0] === 'D') && (srcSet[1] === 'a' || srcSet[1] === 'A') && (srcSet[2] === 't' || srcSet[2] === 'T') && (srcSet[3] === 'a' || srcSet[3] === 'A'))) {
+    // We have a suspensey image and ought to preload it to optimize the loading of display blocking
+    // resumableState.
+    const sizes = typeof props.sizes === 'string' ? props.sizes : undefined;
+    const key = getImageResourceKey(src, srcSet, sizes);
+    const promotablePreloads = renderState.preloads.images;
+    let resource = promotablePreloads.get(key);
+
+    if (resource) {
+      // We consider whether this preload can be promoted to higher priority flushing queue.
+      // The only time a resource will exist here is if it was created during this render
+      // and was not already in the high priority queue.
+      if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+        // Delete the resource from the map since we are promoting it and don't want to
+        // reenter this branch in a second pass for duplicate img hrefs.
+        promotablePreloads.delete(key); // $FlowFixMe - Flow should understand that this is a Resource if the condition was true
+
+        renderState.highImagePreloads.add(resource);
+      }
+    } else if (!resumableState.imageResources.hasOwnProperty(key)) {
+      // We must construct a new preload resource
+      resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+      const crossOrigin = getCrossOriginString(props.crossOrigin);
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // this is a hueristic similar to capping element preloads to 10 unless explicitly
+      // fetchPriority="high". We use length here which means it will fit fewer images when
+      // the urls are long and more when short. arguably byte size is a better hueristic because
+      // it directly translates to how much we send down before content is actually seen.
+      // We could unify the counts and also make it so the total is tracked regardless of
+      // flushing output but since the headers are likely to be go earlier than content
+      // they don't really conflict so for now I've kept them separate
+      props.fetchPriority === 'high' || headers.highImagePreloads.length < 500) && ( // We manually construct the options for the preload only from strings. We don't want to pollute
+      // the params list with arbitrary props and if we copied everything over as it we might get
+      // coercion errors. We have checks for this in Dev but it seems safer to just only accept values
+      // that are strings
+      header = getPreloadAsHeader(src, 'image', {
+        imageSrcSet: props.srcSet,
+        imageSizes: props.sizes,
+        crossOrigin,
+        integrity: props.integrity,
+        nonce: props.nonce,
+        type: props.type,
+        fetchPriority: props.fetchPriority,
+        referrerPolicy: props.refererPolicy
+      }), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // If we postpone in the shell we will still emit this preload so we track
+        // it to make sure we don't reset it.
+        renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+        if (headers.highImagePreloads) {
+          headers.highImagePreloads += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.highImagePreloads += header;
+      } else {
+        resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preload',
+          as: 'image',
+          // There is a bug in Safari where imageSrcSet is not respected on preload links
+          // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+          // This harms older browers that do not support imageSrcSet by making their preloads not work
+          // but this population is shrinking fast and is already small so we accept this tradeoff.
+          href: srcSet ? undefined : src,
+          imageSrcSet: srcSet,
+          imageSizes: sizes,
+          crossOrigin: crossOrigin,
+          integrity: props.integrity,
+          type: props.type,
+          fetchPriority: props.fetchPriority,
+          referrerPolicy: props.referrerPolicy
+        });
+
+        if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+          renderState.highImagePreloads.add(resource);
+        } else {
+          renderState.bulkPreloads.add(resource); // We can bump the priority up if the same img is rendered later
+          // with fetchPriority="high"
+
+          promotablePreloads.set(key, resource);
+        }
+      }
+    }
+  }
+
+  return pushSelfClosing(target, props, 'img');
+}
+
+function pushSelfClosing(target, props, tag) {
+  target.push(startChunkForTag(tag));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error(tag + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStartMenuItem(target, props) {
+  target.push(startChunkForTag('menuitem'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('menuitems cannot have `children` nor `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  return null;
+}
+
+function pushTitle(target, props, renderState, insertionMode, noscriptTagInScope) {
+
+  {
+    if (insertionMode !== SVG_MODE && !noscriptTagInScope && props.itemProp == null) {
+      pushTitleImpl(renderState.hoistableChunks, props);
+      return null;
+    } else {
+      return pushTitleImpl(target, props);
+    }
+  }
+}
+
+function pushTitleImpl(target, props) {
+  target.push(startChunkForTag('title'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('title'));
+  return null;
+}
+
+function pushStartHead(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode < HTML_MODE && renderState.headChunks === null) {
+      // This <head> is the Document.head and should be part of the preamble
+      renderState.headChunks = [];
+      return pushStartGenericElement(renderState.headChunks, props, 'head');
+    } else {
+      // This <head> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'head');
+    }
+  }
+}
+
+function pushStartHtml(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode === ROOT_HTML_MODE && renderState.htmlChunks === null) {
+      // This <html> is the Document.documentElement and should be part of the preamble
+      renderState.htmlChunks = [doctypeChunk];
+      return pushStartGenericElement(renderState.htmlChunks, props, 'html');
+    } else {
+      // This <html> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'html');
+    }
+  }
+}
+
+function pushScript(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const asyncProp = props.async;
+
+    if (typeof props.src !== 'string' || !props.src || !(asyncProp && typeof asyncProp !== 'function' && typeof asyncProp !== 'symbol') || props.onLoad || props.onError || insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      // This script will not be a resource, we bailout early and emit it in place.
+      return pushScriptImpl(target, props);
+    }
+
+    const src = props.src;
+    const key = getResourceKey(src); // We can make this <script> into a ScriptResource
+
+    let resources, preloads;
+
+    if (props.type === 'module') {
+      resources = resumableState.moduleScriptResources;
+      preloads = renderState.preloads.moduleScripts;
+    } else {
+      resources = resumableState.scriptResources;
+      preloads = renderState.preloads.scripts;
+    }
+
+    const hasKey = resources.hasOwnProperty(key);
+    const resourceState = hasKey ? resources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resources[key] = EXISTS;
+      let scriptProps = props;
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          scriptProps = assign({}, props);
+          adoptPreloadCredentials(scriptProps, preloadState);
+        }
+
+        const preloadResource = preloads.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, scriptProps);
+    }
+
+    if (textEmbedded) {
+      // This script follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+
+    return null;
+  }
+}
+
+function pushScriptImpl(target, props) {
+  target.push(startChunkForTag('script'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+  }
+
+  target.push(endChunkForTag('script'));
+  return null;
+}
+
+function pushStartGenericElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartCustomElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      let propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      let attributeName = propKey;
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'style':
+          pushStyleAttribute(target, propValue);
+          break;
+
+        case 'suppressContentEditableWarning':
+        case 'suppressHydrationWarning':
+          // Ignored. These are built-in to React on the client.
+          break;
+
+        case 'className':
+          {
+            // className gets rendered as class on the client, so it should be
+            // rendered as class on the server.
+            attributeName = 'class';
+          }
+
+        // intentional fallthrough
+
+        default:
+          if (isAttributeNameSafe(propKey) && typeof propValue !== 'function' && typeof propValue !== 'symbol') {
+            {
+              if (propValue === false) {
+                continue;
+              } else if (propValue === true) {
+                propValue = '';
+              } else if (typeof propValue === 'object') {
+                continue;
+              }
+            }
+
+            target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(propValue)), attributeEnd);
+          }
+
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const leadingNewline = stringToPrecomputedChunk('\n');
+
+function pushStartPreformattedElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag); // text/html ignores the first character in these tags if it's a newline
+  // Prefer to break application/xml over text/html (for now) by adding
+  // a newline specifically to get eaten by the parser. (Alternately for
+  // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+  // \r is normalized out by HTMLTextAreaElement#value.)
+  // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+  // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+  // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+  // See: Parsing of "textarea" "listing" and "pre" elements
+  //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+  // TODO: This doesn't deal with the case where the child is an array
+  // or component that returns a string.
+
+  if (innerHTML != null) {
+    if (children != null) {
+      throw new Error('Can only set one of `children` or `props.dangerouslySetInnerHTML`.');
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw new Error('`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. ' + 'Please visit https://reactjs.org/link/dangerously-set-inner-html ' + 'for more information.');
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+      if (typeof html === 'string' && html.length > 0 && html[0] === '\n') {
+        target.push(leadingNewline, stringToChunk(html));
+      } else {
+
+        target.push(stringToChunk('' + html));
+      }
+    }
+  }
+
+  if (typeof children === 'string' && children[0] === '\n') {
+    target.push(leadingNewline);
+  }
+
+  return children;
+} // We accept any tag to be rendered but since this gets injected into arbitrary
+// HTML, we want to make sure that it's a safe tag.
+// http://www.w3.org/TR/REC-xml/#NT-Name
+
+
+const VALID_TAG_REGEX = /^[a-zA-Z][a-zA-Z:_\.\-\d]*$/; // Simplified subset
+
+const validatedTagCache = new Map();
+
+function startChunkForTag(tag) {
+  let tagStartChunk = validatedTagCache.get(tag);
+
+  if (tagStartChunk === undefined) {
+    if (!VALID_TAG_REGEX.test(tag)) {
+      throw new Error("Invalid tag: " + tag);
+    }
+
+    tagStartChunk = stringToPrecomputedChunk('<' + tag);
+    validatedTagCache.set(tag, tagStartChunk);
+  }
+
+  return tagStartChunk;
+}
+
+const doctypeChunk = stringToPrecomputedChunk('<!DOCTYPE html>');
+function pushStartInstance(target, type, props, resumableState, renderState, formatContext, textEmbedded) {
+
+  switch (type) {
+    case 'div':
+    case 'span':
+    case 'svg':
+    case 'path':
+    case 'a':
+    case 'g':
+    case 'p':
+    case 'li':
+      // Fast track very common tags
+      break;
+    // Special tags
+
+    case 'select':
+      return pushStartSelect(target, props);
+
+    case 'option':
+      return pushStartOption(target, props, formatContext);
+
+    case 'textarea':
+      return pushStartTextArea(target, props);
+
+    case 'input':
+      return pushInput(target, props, resumableState, renderState);
+
+    case 'button':
+      return pushStartButton(target, props, resumableState, renderState);
+
+    case 'form':
+      return pushStartForm(target, props, resumableState, renderState);
+
+    case 'menuitem':
+      return pushStartMenuItem(target, props);
+
+    case 'title':
+      return pushTitle(target, props, renderState, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'link':
+      return pushLink(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'script':
+      return pushScript(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'style':
+      return pushStyle(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'meta':
+      return pushMeta(target, props, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+    // Newline eating tags
+
+    case 'listing':
+    case 'pre':
+      {
+        return pushStartPreformattedElement(target, props, type);
+      }
+
+    case 'img':
+      {
+        return pushImg(target, props, resumableState, renderState, !!(formatContext.tagScope & PICTURE_SCOPE)) ;
+      }
+    // Omitted close tags
+
+    case 'base':
+    case 'area':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'keygen':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        return pushSelfClosing(target, props, type);
+      }
+    // These are reserved SVG and MathML elements, that are never custom elements.
+    // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+
+    case 'annotation-xml':
+    case 'color-profile':
+    case 'font-face':
+    case 'font-face-src':
+    case 'font-face-uri':
+    case 'font-face-format':
+    case 'font-face-name':
+    case 'missing-glyph':
+      {
+        break;
+      }
+    // Preamble start tags
+
+    case 'head':
+      return pushStartHead(target, props, renderState, formatContext.insertionMode);
+
+    case 'html':
+      {
+        return pushStartHtml(target, props, renderState, formatContext.insertionMode);
+      }
+
+    default:
+      {
+        if (type.indexOf('-') !== -1) {
+          // Custom element
+          return pushStartCustomElement(target, props, type);
+        }
+      }
+  } // Generic element
+
+
+  return pushStartGenericElement(target, props, type);
+}
+const endTagCache = new Map();
+
+function endChunkForTag(tag) {
+  let chunk = endTagCache.get(tag);
+
+  if (chunk === undefined) {
+    chunk = stringToPrecomputedChunk('</' + tag + '>');
+    endTagCache.set(tag, chunk);
+  }
+
+  return chunk;
+}
+
+function pushEndInstance(target, type, props, resumableState, formatContext) {
+  switch (type) {
+    // When float is on we expect title and script tags to always be pushed in
+    // a unit and never return children. when we end up pushing the end tag we
+    // want to ensure there is no extra closing tag pushed
+    case 'title':
+    case 'style':
+    case 'script':
+    // Omitted close tags
+    // TODO: Instead of repeating this switch we could try to pass a flag from above.
+    // That would require returning a tuple. Which might be ok if it gets inlined.
+
+    case 'area':
+    case 'base':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'img':
+    case 'input':
+    case 'keygen':
+    case 'link':
+    case 'meta':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        // No close tag needed.
+        return;
+      }
+    // Postamble end tags
+    // When float is enabled we omit the end tags for body and html when
+    // they represent the Document.body and Document.documentElement Nodes.
+    // This is so we can withhold them until the postamble when we know
+    // we won't emit any more tags
+
+    case 'body':
+      {
+        if (formatContext.insertionMode <= HTML_HTML_MODE) {
+          resumableState.hasBody = true;
+          return;
+        }
+
+        break;
+      }
+
+    case 'html':
+      if (formatContext.insertionMode === ROOT_HTML_MODE) {
+        resumableState.hasHtml = true;
+        return;
+      }
+
+      break;
+  }
+
+  target.push(endChunkForTag(type));
+}
+
+function writeBootstrap(destination, renderState, resumableState) {
+  resumableState.bootstrapScriptContent = undefined;
+  resumableState.bootstrapScripts = undefined;
+  resumableState.bootstrapModules = undefined;
+  const bootstrapChunks = renderState.bootstrapChunks;
+  let i = 0;
+
+  for (; i < bootstrapChunks.length - 1; i++) {
+    writeChunk(destination, bootstrapChunks[i]);
+  }
+
+  if (i < bootstrapChunks.length) {
+    const lastChunk = bootstrapChunks[i];
+    bootstrapChunks.length = 0;
+    return writeChunkAndReturn(destination, lastChunk);
+  }
+
+  return true;
+}
+
+function writeCompletedRoot(destination, renderState, resumableState) {
+  return writeBootstrap(destination, renderState, resumableState);
+} // Structural Nodes
+// A placeholder is a node inside a hidden partial tree that can be filled in later, but before
+// display. It's never visible to users. We use the template tag because it can be used in every
+// type of parent. <script> tags also work in every other tag except <colgroup>.
+
+const placeholder1 = stringToPrecomputedChunk('<template id="');
+const placeholder2 = stringToPrecomputedChunk('"></template>');
+function writePlaceholder(destination, renderState, id) {
+  writeChunk(destination, placeholder1);
+  writeChunk(destination, renderState.placeholderPrefix);
+  const formattedID = stringToChunk(id.toString(16));
+  writeChunk(destination, formattedID);
+  return writeChunkAndReturn(destination, placeholder2);
+} // Suspense boundaries are encoded as comments.
+
+const startCompletedSuspenseBoundary = stringToPrecomputedChunk('<!--$-->');
+const startPendingSuspenseBoundary1 = stringToPrecomputedChunk('<!--$?--><template id="');
+const startPendingSuspenseBoundary2 = stringToPrecomputedChunk('"></template>');
+const startClientRenderedSuspenseBoundary = stringToPrecomputedChunk('<!--$!-->');
+const endSuspenseBoundary = stringToPrecomputedChunk('<!--/$-->');
+const clientRenderedSuspenseBoundaryError1 = stringToPrecomputedChunk('<template');
+const clientRenderedSuspenseBoundaryErrorAttrInterstitial = stringToPrecomputedChunk('"');
+const clientRenderedSuspenseBoundaryError1A = stringToPrecomputedChunk(' data-dgst="');
+stringToPrecomputedChunk(' data-msg="');
+stringToPrecomputedChunk(' data-stck="');
+const clientRenderedSuspenseBoundaryError2 = stringToPrecomputedChunk('></template>');
+function writeStartCompletedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, startCompletedSuspenseBoundary);
+}
+function writeStartPendingSuspenseBoundary(destination, renderState, id) {
+  writeChunk(destination, startPendingSuspenseBoundary1);
+
+  if (id === null) {
+    throw new Error('An ID must have been assigned before we can complete the boundary.');
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+  return writeChunkAndReturn(destination, startPendingSuspenseBoundary2);
+}
+function writeStartClientRenderedSuspenseBoundary(destination, renderState, errorDigest, errorMesssage, errorComponentStack) {
+  let result;
+  result = writeChunkAndReturn(destination, startClientRenderedSuspenseBoundary);
+  writeChunk(destination, clientRenderedSuspenseBoundaryError1);
+
+  if (errorDigest) {
+    writeChunk(destination, clientRenderedSuspenseBoundaryError1A);
+    writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest)));
+    writeChunk(destination, clientRenderedSuspenseBoundaryErrorAttrInterstitial);
+  }
+
+  result = writeChunkAndReturn(destination, clientRenderedSuspenseBoundaryError2);
+  return result;
+}
+function writeEndCompletedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndPendingSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndClientRenderedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+const startSegmentHTML = stringToPrecomputedChunk('<div hidden id="');
+const startSegmentHTML2 = stringToPrecomputedChunk('">');
+const endSegmentHTML = stringToPrecomputedChunk('</div>');
+const startSegmentSVG = stringToPrecomputedChunk('<svg aria-hidden="true" style="display:none" id="');
+const startSegmentSVG2 = stringToPrecomputedChunk('">');
+const endSegmentSVG = stringToPrecomputedChunk('</svg>');
+const startSegmentMathML = stringToPrecomputedChunk('<math aria-hidden="true" style="display:none" id="');
+const startSegmentMathML2 = stringToPrecomputedChunk('">');
+const endSegmentMathML = stringToPrecomputedChunk('</math>');
+const startSegmentTable = stringToPrecomputedChunk('<table hidden id="');
+const startSegmentTable2 = stringToPrecomputedChunk('">');
+const endSegmentTable = stringToPrecomputedChunk('</table>');
+const startSegmentTableBody = stringToPrecomputedChunk('<table hidden><tbody id="');
+const startSegmentTableBody2 = stringToPrecomputedChunk('">');
+const endSegmentTableBody = stringToPrecomputedChunk('</tbody></table>');
+const startSegmentTableRow = stringToPrecomputedChunk('<table hidden><tr id="');
+const startSegmentTableRow2 = stringToPrecomputedChunk('">');
+const endSegmentTableRow = stringToPrecomputedChunk('</tr></table>');
+const startSegmentColGroup = stringToPrecomputedChunk('<table hidden><colgroup id="');
+const startSegmentColGroup2 = stringToPrecomputedChunk('">');
+const endSegmentColGroup = stringToPrecomputedChunk('</colgroup></table>');
+function writeStartSegment(destination, renderState, formatContext, id) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        writeChunk(destination, startSegmentHTML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentHTML2);
+      }
+
+    case SVG_MODE:
+      {
+        writeChunk(destination, startSegmentSVG);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentSVG2);
+      }
+
+    case MATHML_MODE:
+      {
+        writeChunk(destination, startSegmentMathML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentMathML2);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        writeChunk(destination, startSegmentTable);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTable2);
+      }
+    // TODO: For the rest of these, there will be extra wrapper nodes that never
+    // get deleted from the document. We need to delete the table too as part
+    // of the injected scripts. They are invisible though so it's not too terrible
+    // and it's kind of an edge case to suspend in a table. Totally supported though.
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        writeChunk(destination, startSegmentTableBody);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableBody2);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        writeChunk(destination, startSegmentTableRow);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableRow2);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        writeChunk(destination, startSegmentColGroup);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentColGroup2);
+      }
+
+    default:
+      {
+        throw new Error('Unknown insertion mode. This is a bug in React.');
+      }
+  }
+}
+function writeEndSegment(destination, formatContext) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentHTML);
+      }
+
+    case SVG_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentSVG);
+      }
+
+    case MATHML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentMathML);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTable);
+      }
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableBody);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableRow);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentColGroup);
+      }
+
+    default:
+      {
+        throw new Error('Unknown insertion mode. This is a bug in React.');
+      }
+  }
+}
+const completeSegmentScript1Full = stringToPrecomputedChunk(completeSegment + '$RS("');
+const completeSegmentScript1Partial = stringToPrecomputedChunk('$RS("');
+const completeSegmentScript2 = stringToPrecomputedChunk('","');
+const completeSegmentScriptEnd = stringToPrecomputedChunk('")</script>');
+const completeSegmentData1 = stringToPrecomputedChunk('<template data-rsi="" data-sid="');
+const completeSegmentData2 = stringToPrecomputedChunk('" data-pid="');
+const completeSegmentDataEnd = dataElementQuotedEnd;
+function writeCompletedSegmentInstruction(destination, resumableState, renderState, contentSegmentID) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentCompleteSegmentFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentCompleteSegmentFunction;
+      writeChunk(destination, completeSegmentScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, completeSegmentScript1Partial);
+    }
+  } else {
+    writeChunk(destination, completeSegmentData1);
+  } // Write function arguments, which are string literals
+
+
+  writeChunk(destination, renderState.segmentPrefix);
+  const formattedID = stringToChunk(contentSegmentID.toString(16));
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    writeChunk(destination, completeSegmentScript2);
+  } else {
+    writeChunk(destination, completeSegmentData2);
+  }
+
+  writeChunk(destination, renderState.placeholderPrefix);
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    return writeChunkAndReturn(destination, completeSegmentScriptEnd);
+  } else {
+    return writeChunkAndReturn(destination, completeSegmentDataEnd);
+  }
+}
+const completeBoundaryScript1Full = stringToPrecomputedChunk(completeBoundary + '$RC("');
+const completeBoundaryScript1Partial = stringToPrecomputedChunk('$RC("');
+const completeBoundaryWithStylesScript1FullBoth = stringToPrecomputedChunk(completeBoundary + completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1FullPartial = stringToPrecomputedChunk(completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1Partial = stringToPrecomputedChunk('$RR("');
+const completeBoundaryScript2 = stringToPrecomputedChunk('","');
+const completeBoundaryScript3a = stringToPrecomputedChunk('",');
+const completeBoundaryScript3b = stringToPrecomputedChunk('"');
+const completeBoundaryScriptEnd = stringToPrecomputedChunk(')</script>');
+const completeBoundaryData1 = stringToPrecomputedChunk('<template data-rci="" data-bid="');
+const completeBoundaryWithStylesData1 = stringToPrecomputedChunk('<template data-rri="" data-bid="');
+const completeBoundaryData2 = stringToPrecomputedChunk('" data-sid="');
+const completeBoundaryData3a = stringToPrecomputedChunk('" data-sty="');
+const completeBoundaryDataEnd = dataElementQuotedEnd;
+function writeCompletedBoundaryInstruction(destination, resumableState, renderState, id, boundaryResources) {
+  let requiresStyleInsertion;
+
+  {
+    requiresStyleInsertion = renderState.stylesToHoist; // If necessary stylesheets will be flushed with this instruction.
+    // Any style tags not yet hoisted in the Document will also be hoisted.
+    // We reset this state since after this instruction executes all styles
+    // up to this point will have been hoisted
+
+    renderState.stylesToHoist = false;
+  }
+
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if (requiresStyleInsertion) {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction | SentCompleteBoundaryFunction;
+        writeChunk(destination, clonePrecomputedChunk(completeBoundaryWithStylesScript1FullBoth));
+      } else if ((resumableState.instructions & SentStyleInsertionFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction;
+        writeChunk(destination, completeBoundaryWithStylesScript1FullPartial);
+      } else {
+        writeChunk(destination, completeBoundaryWithStylesScript1Partial);
+      }
+    } else {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentCompleteBoundaryFunction;
+        writeChunk(destination, completeBoundaryScript1Full);
+      } else {
+        writeChunk(destination, completeBoundaryScript1Partial);
+      }
+    }
+  } else {
+    if (requiresStyleInsertion) {
+      writeChunk(destination, completeBoundaryWithStylesData1);
+    } else {
+      writeChunk(destination, completeBoundaryData1);
+    }
+  }
+
+  const idChunk = stringToChunk(id.toString(16));
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, idChunk); // Write function arguments, which are string and array literals
+
+  if (scriptFormat) {
+    writeChunk(destination, completeBoundaryScript2);
+  } else {
+    writeChunk(destination, completeBoundaryData2);
+  }
+
+  writeChunk(destination, renderState.segmentPrefix);
+  writeChunk(destination, idChunk);
+
+  if (requiresStyleInsertion) {
+    // Script and data writers must format this differently:
+    //  - script writer emits an array literal, whose string elements are
+    //    escaped for javascript  e.g. ["A", "B"]
+    //  - data writer emits a string literal, which is escaped as html
+    //    e.g. [&#34;A&#34;, &#34;B&#34;]
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3a); // boundaryResources encodes an array literal
+
+      writeStyleResourceDependenciesInJS(destination, boundaryResources);
+    } else {
+      writeChunk(destination, completeBoundaryData3a);
+      writeStyleResourceDependenciesInAttr(destination, boundaryResources);
+    }
+  } else {
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3b);
+    }
+  }
+
+  let writeMore;
+
+  if (scriptFormat) {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryScriptEnd);
+  } else {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryDataEnd);
+  }
+
+  return writeBootstrap(destination, renderState, resumableState) && writeMore;
+}
+const clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
+const clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
+const clientRenderScript1A = stringToPrecomputedChunk('"');
+const clientRenderErrorScriptArgInterstitial = stringToPrecomputedChunk(',');
+const clientRenderScriptEnd = stringToPrecomputedChunk(')</script>');
+const clientRenderData1 = stringToPrecomputedChunk('<template data-rxi="" data-bid="');
+const clientRenderData2 = stringToPrecomputedChunk('" data-dgst="');
+const clientRenderData3 = stringToPrecomputedChunk('" data-msg="');
+const clientRenderData4 = stringToPrecomputedChunk('" data-stck="');
+const clientRenderDataEnd = dataElementQuotedEnd;
+function writeClientRenderBoundaryInstruction(destination, resumableState, renderState, id, errorDigest, errorMessage, errorComponentStack) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentClientRenderFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentClientRenderFunction;
+      writeChunk(destination, clientRenderScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, clientRenderScript1Partial);
+    }
+  } else {
+    // <template data-rxi="" data-bid="
+    writeChunk(destination, clientRenderData1);
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+
+  if (scriptFormat) {
+    // " needs to be inserted for scripts, since ArgInterstitual does not contain
+    // leading or trailing quotes
+    writeChunk(destination, clientRenderScript1A);
+  }
+
+  if (errorDigest || errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorDigest || '')));
+    } else {
+      // " data-dgst="HTMLString
+      writeChunk(destination, clientRenderData2);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest || '')));
+    }
+  }
+
+  if (errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorMessage || '')));
+    } else {
+      // " data-msg="HTMLString
+      writeChunk(destination, clientRenderData3);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorMessage || '')));
+    }
+  }
+
+  if (errorComponentStack) {
+    // ,"JSONString"
+    if (scriptFormat) {
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorComponentStack)));
+    } else {
+      // " data-stck="HTMLString
+      writeChunk(destination, clientRenderData4);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorComponentStack)));
+    }
+  }
+
+  if (scriptFormat) {
+    // ></script>
+    return writeChunkAndReturn(destination, clientRenderScriptEnd);
+  } else {
+    // "></template>
+    return writeChunkAndReturn(destination, clientRenderDataEnd);
+  }
+}
+const regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
+
+function escapeJSStringsForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInInstructionScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const regexForJSStringsInScripts = /[&><\u2028\u2029]/g;
+
+function escapeJSObjectForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '&':
+        return '\\u0026';
+
+      case '>':
+        return '\\u003e';
+
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const lateStyleTagResourceOpen1 = stringToPrecomputedChunk('<style media="not all" data-precedence="');
+const lateStyleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const lateStyleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const lateStyleTagTemplateClose = stringToPrecomputedChunk('</style>'); // Tracks whether the boundary currently flushing is flushign style tags or has any
+// stylesheet dependencies not flushed in the Preamble.
+
+let currentlyRenderingBoundaryHasStylesToHoist = false; // Acts as a return value for the forEach execution of style tag flushing.
+
+let destinationHasCapacity = true;
+
+function flushStyleTagsLateForBoundary(styleQueue) {
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs;
+
+  let i = 0;
+
+  if (hrefs.length) {
+    writeChunk(this, lateStyleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    writeChunk(this, lateStyleTagResourceOpen2);
+
+    for (; i < hrefs.length - 1; i++) {
+      writeChunk(this, hrefs[i]);
+      writeChunk(this, spaceSeparator);
+    }
+
+    writeChunk(this, hrefs[i]);
+    writeChunk(this, lateStyleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    destinationHasCapacity = writeChunkAndReturn(this, lateStyleTagTemplateClose); // We wrote style tags for this boundary and we may need to emit a script
+    // to hoist them.
+
+    currentlyRenderingBoundaryHasStylesToHoist = true; // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function hasStylesToHoist(stylesheet) {
+  // We need to reveal boundaries with styles whenever a stylesheet it depends on is either
+  // not flushed or flushed after the preamble (shell).
+  if (stylesheet.state !== PREAMBLE) {
+    currentlyRenderingBoundaryHasStylesToHoist = true;
+    return true;
+  }
+
+  return false;
+}
+
+function writeResourcesForBoundary(destination, boundaryResources, renderState) {
+  // Reset these on each invocation, they are only safe to read in this function
+  currentlyRenderingBoundaryHasStylesToHoist = false;
+  destinationHasCapacity = true; // Flush style tags for each precedence this boundary depends on
+
+  boundaryResources.styles.forEach(flushStyleTagsLateForBoundary, destination); // Determine if this boundary has stylesheets that need to be awaited upon completion
+
+  boundaryResources.stylesheets.forEach(hasStylesToHoist);
+
+  if (currentlyRenderingBoundaryHasStylesToHoist) {
+    renderState.stylesToHoist = true;
+  }
+
+  return destinationHasCapacity;
+}
+
+function flushResource(resource) {
+  for (let i = 0; i < resource.length; i++) {
+    writeChunk(this, resource[i]);
+  }
+
+  resource.length = 0;
+}
+
+const stylesheetFlushingQueue = [];
+
+function flushStyleInPreamble(stylesheet, key, map) {
+  // We still need to encode stylesheet chunks
+  // because unlike most Hoistables and Resources we do not eagerly encode
+  // them during render. This is because if we flush late we have to send a
+  // different encoding and we don't want to encode multiple times
+  pushLinkImpl(stylesheetFlushingQueue, stylesheet.props);
+
+  for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+    writeChunk(this, stylesheetFlushingQueue[i]);
+  }
+
+  stylesheetFlushingQueue.length = 0;
+  stylesheet.state = PREAMBLE;
+}
+
+const styleTagResourceOpen1 = stringToPrecomputedChunk('<style data-precedence="');
+const styleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const spaceSeparator = stringToPrecomputedChunk(' ');
+const styleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const styleTagResourceClose = stringToPrecomputedChunk('</style>');
+
+function flushStylesInPreamble(styleQueue, precedence) {
+  const hasStylesheets = styleQueue.sheets.size > 0;
+  styleQueue.sheets.forEach(flushStyleInPreamble, this);
+  styleQueue.sheets.clear();
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs; // If we don't emit any stylesheets at this precedence we still need to maintain the precedence
+  // order so even if there are no rules for style tags at this precedence we emit an empty style
+  // tag with the data-precedence attribute
+
+  if (!hasStylesheets || hrefs.length) {
+    writeChunk(this, styleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    let i = 0;
+
+    if (hrefs.length) {
+      writeChunk(this, styleTagResourceOpen2);
+
+      for (; i < hrefs.length - 1; i++) {
+        writeChunk(this, hrefs[i]);
+        writeChunk(this, spaceSeparator);
+      }
+
+      writeChunk(this, hrefs[i]);
+    }
+
+    writeChunk(this, styleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    writeChunk(this, styleTagResourceClose); // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function preloadLateStyle(stylesheet) {
+  if (stylesheet.state === PENDING$1) {
+    stylesheet.state = PRELOADED;
+    const preloadProps = preloadAsStylePropsFromProps(stylesheet.props.href, stylesheet.props);
+    pushLinkImpl(stylesheetFlushingQueue, preloadProps);
+
+    for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+      writeChunk(this, stylesheetFlushingQueue[i]);
+    }
+
+    stylesheetFlushingQueue.length = 0;
+  }
+}
+
+function preloadLateStyles(styleQueue) {
+  styleQueue.sheets.forEach(preloadLateStyle, this);
+  styleQueue.sheets.clear();
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+
+function writePreamble(destination, resumableState, renderState, willFlushAllSegments) {
+  // This function must be called exactly once on every request
+  if (!willFlushAllSegments && renderState.externalRuntimeScript) {
+    // If the root segment is incomplete due to suspended tasks
+    // (e.g. willFlushAllSegments = false) and we are using data
+    // streaming format, ensure the external runtime is sent.
+    // (User code could choose to send this even earlier by calling
+    //  preinit(...), if they know they will suspend).
+    const _renderState$external = renderState.externalRuntimeScript,
+          src = _renderState$external.src,
+          chunks = _renderState$external.chunks;
+    internalPreinitScript(resumableState, renderState, src, chunks);
+  }
+
+  const htmlChunks = renderState.htmlChunks;
+  const headChunks = renderState.headChunks;
+  let i = 0; // Emit open tags before Hoistables and Resources
+
+  if (htmlChunks) {
+    // We have an <html> to emit as part of the preamble
+    for (i = 0; i < htmlChunks.length; i++) {
+      writeChunk(destination, htmlChunks[i]);
+    }
+
+    if (headChunks) {
+      for (i = 0; i < headChunks.length; i++) {
+        writeChunk(destination, headChunks[i]);
+      }
+    } else {
+      // We did not render a head but we emitted an <html> so we emit one now
+      writeChunk(destination, startChunkForTag('head'));
+      writeChunk(destination, endOfStartTag);
+    }
+  } else if (headChunks) {
+    // We do not have an <html> but we do have a <head>
+    for (i = 0; i < headChunks.length; i++) {
+      writeChunk(destination, headChunks[i]);
+    }
+  } // Emit high priority Hoistables
+
+
+  const charsetChunks = renderState.charsetChunks;
+
+  for (i = 0; i < charsetChunks.length; i++) {
+    writeChunk(destination, charsetChunks[i]);
+  }
+
+  charsetChunks.length = 0; // emit preconnect resources
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Flush unblocked stylesheets by precedence
+
+  renderState.styles.forEach(flushStylesInPreamble, destination);
+  const importMapChunks = renderState.importMapChunks;
+
+  for (i = 0; i < importMapChunks.length; i++) {
+    writeChunk(destination, importMapChunks[i]);
+  }
+
+  importMapChunks.length = 0;
+  renderState.bootstrapScripts.forEach(flushResource, destination);
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0; // Flush closing head if necessary
+
+  if (htmlChunks && headChunks === null) {
+    // We have an <html> rendered but no <head> rendered. We however inserted
+    // a <head> up above so we need to emit the </head> now. This is safe because
+    // if the main content contained the </head> it would also have provided a
+    // <head>. This means that all the content inside <html> is either <body> or
+    // invalid HTML
+    writeChunk(destination, endChunkForTag('head'));
+  }
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+function writeHoistables(destination, resumableState, renderState) {
+  let i = 0; // Emit high priority Hoistables
+  // We omit charsetChunks because we have already sent the shell and if it wasn't
+  // already sent it is too late now.
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Preload any stylesheets. these will emit in a render instruction that follows this
+  // but we want to kick off preloading as soon as possible
+
+  renderState.styles.forEach(preloadLateStyles, destination); // We only hoist importmaps that are configured through createResponse and that will
+  // always flush in the preamble. Generally we don't expect people to render them as
+  // tags when using React but if you do they are going to be treated like regular inline
+  // scripts and flush after other hoistables which is problematic
+  // bootstrap scripts should flush above script priority but these can only flush in the preamble
+  // so we elide the code here for performance
+
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0;
+}
+function writePostamble(destination, resumableState) {
+  if (resumableState.hasBody) {
+    writeChunk(destination, endChunkForTag('body'));
+  }
+
+  if (resumableState.hasHtml) {
+    writeChunk(destination, endChunkForTag('html'));
+  }
+}
+const arrayFirstOpenBracket = stringToPrecomputedChunk('[');
+const arraySubsequentOpenBracket = stringToPrecomputedChunk(',[');
+const arrayInterstitial = stringToPrecomputedChunk(',');
+const arrayCloseBracket = stringToPrecomputedChunk(']'); // This function writes a 2D array of strings to be embedded in javascript.
+// E.g.
+//  [["JS_escaped_string1", "JS_escaped_string2"]]
+
+function writeStyleResourceDependenciesInJS(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInJS(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInJS(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInJS(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+}
+
+function writeStyleResourceDependencyInJS(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedPrecedence)));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          writeStyleResourceAttributeInJS(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInJS(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeName)));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeValue)));
+} // This function writes a 2D array of strings to be embedded in an attribute
+// value and read with JSON.parse in ReactDOMServerExternalRuntime.js
+// E.g.
+//  [[&quot;JSON_escaped_string1&quot;, &quot;JSON_escaped_string2&quot;]]
+
+
+function writeStyleResourceDependenciesInAttr(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInAttr(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInAttr(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInAttr(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+}
+
+function writeStyleResourceDependencyInAttr(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedPrecedence))));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          writeStyleResourceAttributeInAttr(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInAttr(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeName))));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeValue))));
+}
+/**
+ * Resources
+ */
+
+
+const PENDING$1 = 0;
+const PRELOADED = 1;
+const PREAMBLE = 2;
+const LATE = 3;
+function createBoundaryResources() {
+  return {
+    styles: new Set(),
+    stylesheets: new Set()
+  };
+}
+function setCurrentlyRenderingBoundaryResourcesTarget(renderState, boundaryResources) {
+  renderState.boundaryResources = boundaryResources;
+}
+
+function getResourceKey(href) {
+  return href;
+}
+
+function getImageResourceKey(href, imageSrcSet, imageSizes) {
+  if (imageSrcSet) {
+    return imageSrcSet + '\n' + (imageSizes || '');
+  }
+
+  return href;
+}
+
+function prefetchDNS(href) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const key = getResourceKey(href);
+
+    if (!resumableState.dnsResources.hasOwnProperty(key)) {
+      resumableState.dnsResources[key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPrefetchDNSAsHeader(href), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this as resettable in case we are prerendering and postpone in the Shell
+        renderState.resets.dns[key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        // Encode as element
+        const resource = [];
+        pushLinkImpl(resource, {
+          href,
+          rel: 'dns-prefetch'
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preconnect(href, crossOrigin) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const bucket = crossOrigin === 'use-credentials' ? 'credentials' : typeof crossOrigin === 'string' ? 'anonymous' : 'default';
+    const key = getResourceKey(href);
+
+    if (!resumableState.connectResources[bucket].hasOwnProperty(key)) {
+      resumableState.connectResources[bucket][key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPreconnectAsHeader(href, crossOrigin), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this in resettableState in case we are prerending and postpone in the Shell
+        renderState.resets.connect[bucket][key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        const resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preconnect',
+          href,
+          crossOrigin
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preload(href, as, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (as && href) {
+    switch (as) {
+      case 'image':
+        {
+          let imageSrcSet, imageSizes, fetchPriority;
+
+          if (options) {
+            imageSrcSet = options.imageSrcSet;
+            imageSizes = options.imageSizes;
+            fetchPriority = options.fetchPriority;
+          }
+
+          const key = getImageResourceKey(href, imageSrcSet, imageSizes);
+
+          if (resumableState.imageResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && fetchPriority === 'high' && ( // Compute the header since we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit a preload as a header so we
+            // track this to make sure we don't reset it.
+            renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+            if (headers.highImagePreloads) {
+              headers.highImagePreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.highImagePreloads += header;
+          } else {
+            // If we don't have headers to write to we have to encode as elements to flush in the head
+            // When we have imageSrcSet the browser probably cannot load the right version from headers
+            // (this should be verified by testing). For now we assume these need to go in the head
+            // as elements even if headers are available.
+            const resource = [];
+            pushLinkImpl(resource, assign({
+              rel: 'preload',
+              // There is a bug in Safari where imageSrcSet is not respected on preload links
+              // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+              // This harms older browers that do not support imageSrcSet by making their preloads not work
+              // but this population is shrinking fast and is already small so we accept this tradeoff.
+              href: imageSrcSet ? undefined : href,
+              as
+            }, options));
+
+            if (fetchPriority === 'high') {
+              renderState.highImagePreloads.add(resource);
+            } else {
+              renderState.bulkPreloads.add(resource); // Stash the resource in case we need to promote it to higher priority
+              // when an img tag is rendered
+
+              renderState.preloads.images.set(key, resource);
+            }
+          }
+
+          break;
+        }
+
+      case 'style':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.styleResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.styleResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.stylesheets.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          break;
+        }
+
+      case 'script':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.scriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          renderState.preloads.scripts.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.scriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          break;
+        }
+
+      default:
+        {
+          const key = getResourceKey(href);
+          const hasAsType = resumableState.unknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.unknownResources[as] = resources;
+          }
+
+          resources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && as === 'font' && ( // We compute the header here because we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit this preload so we
+            // track it here to prevent it from being reset.
+            renderState.resets.font[key] = PRELOAD_NO_CREDS;
+
+            if (headers.fontPreloads) {
+              headers.fontPreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.fontPreloads += header;
+          } else {
+            // We either don't have headers or we are preloading something that does
+            // not warrant elevated priority so we encode as an element.
+            const resource = [];
+
+            const props = assign({
+              rel: 'preload',
+              href,
+              as
+            }, options);
+
+            pushLinkImpl(resource, props);
+
+            switch (as) {
+              case 'font':
+                renderState.fontPreloads.add(resource);
+                break;
+              // intentional fall through
+
+              default:
+                renderState.bulkPreloads.add(resource);
+            }
+          }
+        }
+    } // If we got this far we created a new resource
+
+
+    flushResources(request);
+  }
+}
+
+function preloadModule(href, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    const key = getResourceKey(href);
+    const as = options && typeof options.as === 'string' ? options.as : 'script';
+    let resource;
+
+    switch (as) {
+      case 'script':
+        {
+          if (resumableState.moduleScriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resource = [];
+          resumableState.moduleScriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.moduleScripts.set(key, resource);
+          break;
+        }
+
+      default:
+        {
+          const hasAsType = resumableState.moduleUnknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.moduleUnknownResources[as] = resources;
+          }
+
+          resource = [];
+          resources[key] = PRELOAD_NO_CREDS;
+        }
+    }
+
+    pushLinkImpl(resource, assign({
+      rel: 'modulepreload',
+      href
+    }, options));
+    renderState.bulkPreloads.add(resource); // If we got this far we created a new resource
+
+    flushResources(request);
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    precedence = precedence || 'default';
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+      // to create a StyleQueue
+
+      if (!styleQueue) {
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      }
+
+      const resource = {
+        state: PENDING$1,
+        props: assign({
+          rel: 'stylesheet',
+          href,
+          'data-precedence': precedence
+        }, options)
+      };
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(resource.props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.stylesheets.get(key);
+
+        if (preloadResource && preloadResource.length > 0) {
+          // The Preload for this resource was created in this render pass and has not flushed yet so
+          // we need to clear it to avoid it flushing.
+          preloadResource.length = 0;
+        } else {
+          // Either the preload resource from this render already flushed in this render pass
+          // or the preload flushed in a prior pass (prerender). In either case we need to mark
+          // this resource as already having been preloaded.
+          resource.state = PRELOADED;
+        }
+      } // We add the newly created resource to our StyleQueue and if necessary
+      // track the resource with the currently rendering boundary
+
+
+      styleQueue.sheets.set(key, resource); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+  }
+}
+
+function preinitScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.scriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.scriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.scriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.scripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+}
+
+function preinitModuleScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.moduleScriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.moduleScriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.moduleScriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        type: 'module',
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.moduleScripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+} // This function is only safe to call at Request start time since it assumes
+// that each module has not already been preloaded. If we find a need to preload
+// scripts at any other point in time we will need to check whether the preload
+// already exists and not assume it
+
+
+function preloadBootstrapScriptOrModule(resumableState, renderState, href, props) {
+
+  const key = getResourceKey(href);
+  // used to preinit the resource. If a script can be preinited then it shouldn't
+  // be a bootstrap script/module and if it is a bootstrap script/module then it
+  // must not be safe to emit early. To avoid possibly allowing for preinits of
+  // bootstrap scripts/modules we occlude these keys.
+
+
+  resumableState.scriptResources[key] = EXISTS;
+  resumableState.moduleScriptResources[key] = EXISTS;
+  const resource = [];
+  pushLinkImpl(resource, props);
+  renderState.bootstrapScripts.add(resource);
+}
+
+function internalPreinitScript(resumableState, renderState, src, chunks) {
+  const key = getResourceKey(src);
+
+  if (!resumableState.scriptResources.hasOwnProperty(key)) {
+    const resource = chunks;
+    resumableState.scriptResources[key] = EXISTS;
+    renderState.scripts.add(resource);
+  }
+
+  return;
+}
+
+function preloadAsStylePropsFromProps(href, props) {
+  return {
+    rel: 'preload',
+    as: 'style',
+    href: href,
+    crossOrigin: props.crossOrigin,
+    fetchPriority: props.fetchPriority,
+    integrity: props.integrity,
+    media: props.media,
+    hrefLang: props.hrefLang,
+    referrerPolicy: props.referrerPolicy
+  };
+}
+
+function stylesheetPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    'data-precedence': rawProps.precedence,
+    precedence: null
+  });
+}
+
+function adoptPreloadCredentials(target, preloadState) {
+  if (target.crossOrigin == null) target.crossOrigin = preloadState[0];
+  if (target.integrity == null) target.integrity = preloadState[1];
+}
+
+function getPrefetchDNSAsHeader(href) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  return "<" + escapedHref + ">; rel=dns-prefetch";
+}
+
+function getPreconnectAsHeader(href, crossOrigin) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  let value = "<" + escapedHref + ">; rel=preconnect";
+
+  if (typeof crossOrigin === 'string') {
+    const escapedCrossOrigin = escapeStringForLinkHeaderQuotedParamValueContext(crossOrigin);
+    value += "; crossorigin=\"" + escapedCrossOrigin + "\"";
+  }
+
+  return value;
+}
+
+function getPreloadAsHeader(href, as, params) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  const escapedAs = escapeStringForLinkHeaderQuotedParamValueContext(as);
+  let value = "<" + escapedHref + ">; rel=preload; as=\"" + escapedAs + "\"";
+
+  for (const paramName in params) {
+    if (hasOwnProperty.call(params, paramName)) {
+      const paramValue = params[paramName];
+
+      if (typeof paramValue === 'string') {
+        value += "; " + paramName.toLowerCase() + "=\"" + escapeStringForLinkHeaderQuotedParamValueContext(paramValue) + "\"";
+      }
+    }
+  }
+
+  return value;
+}
+
+function getStylesheetPreloadAsHeader(stylesheet) {
+  const props = stylesheet.props;
+  const preloadOptions = {
+    crossOrigin: props.crossOrigin,
+    integrity: props.integrity,
+    nonce: props.nonce,
+    type: props.type,
+    fetchPriority: props.fetchPriority,
+    referrerPolicy: props.referrerPolicy,
+    media: props.media
+  };
+  return getPreloadAsHeader(props.href, 'style', preloadOptions);
+} // This escaping function is only safe to use for href values being written into
+// a "Link" header in between `<` and `>` characters. The primary concern with the href is
+// to escape the bounding characters as well as new lines. This is unsafe to use in any other
+// context
+
+
+const regexForHrefInLinkHeaderURLContext = /[<>\r\n]/g;
+
+function escapeHrefForLinkHeaderURLContext(hrefInput) {
+
+  const coercedHref = '' + hrefInput;
+  return coercedHref.replace(regexForHrefInLinkHeaderURLContext, escapeHrefForLinkHeaderURLContextReplacer);
+}
+
+function escapeHrefForLinkHeaderURLContextReplacer(match) {
+  switch (match) {
+    case '<':
+      return '%3C';
+
+    case '>':
+      return '%3E';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeLinkHrefForHeaderContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+} // This escaping function is only safe to use for quoted param values in an HTTP header.
+// It is unsafe to use for any value not inside quote marks in parater value position.
+
+
+const regexForLinkHeaderQuotedParamValueContext = /["';,\r\n]/g;
+
+function escapeStringForLinkHeaderQuotedParamValueContext(value, name) {
+
+  const coerced = '' + value;
+  return coerced.replace(regexForLinkHeaderQuotedParamValueContext, escapeStringForLinkHeaderQuotedParamValueContextReplacer);
+}
+
+function escapeStringForLinkHeaderQuotedParamValueContextReplacer(match) {
+  switch (match) {
+    case '"':
+      return '%22';
+
+    case "'":
+      return '%27';
+
+    case ';':
+      return '%3B';
+
+    case ',':
+      return '%2C';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeStringForLinkHeaderQuotedParamValueContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+}
+
+function hoistStyleQueueDependency(styleQueue) {
+  this.styles.add(styleQueue);
+}
+
+function hoistStylesheetDependency(stylesheet) {
+  this.stylesheets.add(stylesheet);
+}
+
+function hoistResources(renderState, source) {
+  const currentBoundaryResources = renderState.boundaryResources;
+
+  if (currentBoundaryResources) {
+    source.styles.forEach(hoistStyleQueueDependency, currentBoundaryResources);
+    source.stylesheets.forEach(hoistStylesheetDependency, currentBoundaryResources);
+  }
+} // This function is called at various times depending on whether we are rendering
+// or prerendering. In this implementation we only actually emit headers once and
+// subsequent calls are ignored. We track whether the request has a completed shell
+// to determine whether we will follow headers with a flush including stylesheets.
+// In the context of prerrender we don't have a completed shell when the request finishes
+// with a postpone in the shell. In the context of a render we don't have a completed shell
+// if this is called before the shell finishes rendering which usually will happen anytime
+// anything suspends in the shell.
+
+function emitEarlyPreloads(renderState, resumableState, shellComplete) {
+  const onHeaders = renderState.onHeaders;
+
+  if (onHeaders) {
+    const headers = renderState.headers;
+
+    if (headers) {
+      let linkHeader = headers.preconnects;
+
+      if (headers.fontPreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.fontPreloads;
+      }
+
+      if (headers.highImagePreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.highImagePreloads;
+      }
+
+      if (!shellComplete) {
+        // We use raw iterators because we want to be able to halt iteration
+        // We could refactor renderState to store these dually in arrays to
+        // make this more efficient at the cost of additional memory and
+        // write overhead. However this code only runs once per request so
+        // for now I consider this sufficient.
+        const queueIter = renderState.styles.values();
+
+        outer: for (let queueStep = queueIter.next(); headers.remainingCapacity > 0 && !queueStep.done; queueStep = queueIter.next()) {
+          const sheets = queueStep.value.sheets;
+          const sheetIter = sheets.values();
+
+          for (let sheetStep = sheetIter.next(); headers.remainingCapacity > 0 && !sheetStep.done; sheetStep = sheetIter.next()) {
+            const sheet = sheetStep.value;
+            const props = sheet.props;
+            const key = getResourceKey(props.href);
+            const header = getStylesheetPreloadAsHeader(sheet); // We mutate the capacity b/c we don't want to keep checking if later headers will fit.
+            // This means that a particularly long header might close out the header queue where later
+            // headers could still fit. We could in the future alter the behavior here based on prerender vs render
+            // since during prerender we aren't as concerned with pure runtime performance.
+
+            if ((headers.remainingCapacity -= header.length) >= 2) {
+              renderState.resets.style[key] = PRELOAD_NO_CREDS;
+
+              if (linkHeader) {
+                linkHeader += ', ';
+              }
+
+              linkHeader += header; // We already track that the resource exists in resumableState however
+              // if the resumableState resets because we postponed in the shell
+              // which is what is happening in this branch if we are prerendering
+              // then we will end up resetting the resumableState. When it resets we
+              // want to record the fact that this stylesheet was already preloaded
+
+              renderState.resets.style[key] = typeof props.crossOrigin === 'string' || typeof props.integrity === 'string' ? [props.crossOrigin, props.integrity] : PRELOAD_NO_CREDS;
+            } else {
+              break outer;
+            }
+          }
+        }
+      }
+
+      if (linkHeader) {
+        onHeaders({
+          Link: linkHeader
+        });
+      } else {
+        // We still call this with no headers because a user may be using it as a signal that
+        // it React will not provide any headers
+        onHeaders({});
+      }
+
+      renderState.headers = null;
+      return;
+    }
+  }
+}
+const NotPendingTransition = NotPending;
+
+const supportsRequestStorage = typeof AsyncLocalStorage === 'function';
+const requestStorage = supportsRequestStorage ? new AsyncLocalStorage() : null;
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+const REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_CONTEXT_TYPE = Symbol.for('react.context');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SCOPE_TYPE = Symbol.for('react.scope');
+const REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');
+const REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+const REACT_LEGACY_HIDDEN_TYPE = Symbol.for('react.legacy_hidden');
+const REACT_CACHE_TYPE = Symbol.for('react.cache');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+function getWrappedName(outerType, innerType, wrapperName) {
+  const displayName = outerType.displayName;
+
+  if (displayName) {
+    return displayName;
+  }
+
+  const functionName = innerType.displayName || innerType.name || '';
+  return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
+} // Keep in sync with react-reconciler/getComponentNameFromFiber
+
+
+function getContextName(type) {
+  return type.displayName || 'Context';
+} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+
+function getComponentNameFromType(type) {
+  if (type == null) {
+    // Host root, text node or just invalid type.
+    return null;
+  }
+
+  if (typeof type === 'function') {
+    return type.displayName || type.name || null;
+  }
+
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_FRAGMENT_TYPE:
+      return 'Fragment';
+
+    case REACT_PORTAL_TYPE:
+      return 'Portal';
+
+    case REACT_PROFILER_TYPE:
+      return 'Profiler';
+
+    case REACT_STRICT_MODE_TYPE:
+      return 'StrictMode';
+
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+
+    case REACT_CACHE_TYPE:
+      {
+        return 'Cache';
+      }
+
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        const context = type;
+        return getContextName(context) + '.Consumer';
+
+      case REACT_PROVIDER_TYPE:
+        const provider = type;
+        return getContextName(provider._context) + '.Provider';
+
+      case REACT_FORWARD_REF_TYPE:
+        return getWrappedName(type, type.render, 'ForwardRef');
+
+      case REACT_MEMO_TYPE:
+        const outerName = type.displayName || null;
+
+        if (outerName !== null) {
+          return outerName;
+        }
+
+        return getComponentNameFromType(type.type) || 'Memo';
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            return getComponentNameFromType(init(payload));
+          } catch (x) {
+            return null;
+          }
+        }
+
+      case REACT_SERVER_CONTEXT_TYPE:
+        {
+          const context2 = type;
+          return (context2.displayName || context2._globalName) + '.Provider';
+        }
+
+    }
+  }
+
+  return null;
+}
+
+const emptyContextObject = {};
+
+function getMaskedContext(type, unmaskedContext) {
+  {
+    const contextTypes = type.contextTypes;
+
+    if (!contextTypes) {
+      return emptyContextObject;
+    }
+
+    const context = {};
+
+    for (const key in contextTypes) {
+      context[key] = unmaskedContext[key];
+    }
+
+    return context;
+  }
+}
+function processChildContext(instance, type, parentContext, childContextTypes) {
+  {
+    // TODO (bvaughn) Replace this behavior with an invariant() in the future.
+    // It has only been added in Fiber to match the (unintentional) behavior in Stack.
+    if (typeof instance.getChildContext !== 'function') {
+
+      return parentContext;
+    }
+
+    const childContext = instance.getChildContext();
+
+    for (const contextKey in childContext) {
+      if (!(contextKey in childContextTypes)) {
+        throw new Error((getComponentNameFromType(type) || 'Unknown') + ".getChildContext(): key \"" + contextKey + "\" is not defined in childContextTypes.");
+      }
+    }
+
+    return assign({}, parentContext, childContext);
+  }
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext);
+    } // On the way back, we push the new ones that weren't common.
+
+
+    pushNode(next);
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function pushProvider(context, nextValue) {
+  let prevValue;
+
+  {
+    prevValue = context._currentValue;
+    context._currentValue = nextValue;
+  }
+
+  const prevNode = currentActiveSnapshot;
+  const newNode = {
+    parent: prevNode,
+    depth: prevNode === null ? 0 : prevNode.depth + 1,
+    context: context,
+    parentValue: prevValue,
+    value: nextValue
+  };
+  currentActiveSnapshot = newNode;
+  return newNode;
+}
+function popProvider(context) {
+  const prevSnapshot = currentActiveSnapshot;
+
+  if (prevSnapshot === null) {
+    throw new Error('Tried to pop a Context at the root of the app. This is a bug in React.');
+  }
+
+  {
+    const value = prevSnapshot.parentValue;
+
+    if (value === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      prevSnapshot.context._currentValue = prevSnapshot.context._defaultValue;
+    } else {
+      prevSnapshot.context._currentValue = value;
+    }
+  }
+
+  return currentActiveSnapshot = prevSnapshot.parent;
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+/**
+ * `ReactInstanceMap` maintains a mapping from a public facing stateful
+ * instance (key) and the internal representation (value). This allows public
+ * methods to accept the user facing instance as an argument and map them back
+ * to internal methods.
+ *
+ * Note that this module is currently shared and assumed to be stateless.
+ * If this becomes an actual Map, that will break.
+ */
+function get(key) {
+  return key._reactInternals;
+}
+function set(key, value) {
+  key._reactInternals = value;
+}
+
+const classComponentUpdater = {
+  isMounted(inst) {
+    return false;
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueSetState(inst, payload, callback) {
+    const internals = get(inst);
+
+    if (internals.queue === null) ; else {
+      internals.queue.push(payload);
+    }
+  },
+
+  enqueueReplaceState(inst, payload, callback) {
+    const internals = get(inst);
+    internals.replace = true;
+    internals.queue = [payload];
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueForceUpdate(inst, callback) {
+  }
+
+};
+
+function applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, prevState, nextProps) {
+  const partialState = getDerivedStateFromProps(nextProps, prevState);
+
+
+  const newState = partialState === null || partialState === undefined ? prevState : assign({}, prevState, partialState);
+  return newState;
+}
+
+function constructClassInstance(ctor, props, maskedLegacyContext) {
+  let context = emptyContextObject;
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    context = readContext$1(contextType);
+  } else {
+    context = maskedLegacyContext;
+  }
+
+  const instance = new ctor(props, context);
+
+  return instance;
+}
+
+function callComponentWillMount(type, instance) {
+  const oldState = instance.state;
+
+  if (typeof instance.componentWillMount === 'function') {
+
+    instance.componentWillMount();
+  }
+
+  if (typeof instance.UNSAFE_componentWillMount === 'function') {
+    instance.UNSAFE_componentWillMount();
+  }
+
+  if (oldState !== instance.state) {
+
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+}
+
+function processUpdateQueue(internalInstance, inst, props, maskedLegacyContext) {
+  if (internalInstance.queue !== null && internalInstance.queue.length > 0) {
+    const oldQueue = internalInstance.queue;
+    const oldReplace = internalInstance.replace;
+    internalInstance.queue = null;
+    internalInstance.replace = false;
+
+    if (oldReplace && oldQueue.length === 1) {
+      inst.state = oldQueue[0];
+    } else {
+      let nextState = oldReplace ? oldQueue[0] : inst.state;
+      let dontMutate = true;
+
+      for (let i = oldReplace ? 1 : 0; i < oldQueue.length; i++) {
+        const partial = oldQueue[i];
+        const partialState = typeof partial === 'function' ? partial.call(inst, nextState, props, maskedLegacyContext) : partial;
+
+        if (partialState != null) {
+          if (dontMutate) {
+            dontMutate = false;
+            nextState = assign({}, nextState, partialState);
+          } else {
+            assign(nextState, partialState);
+          }
+        }
+      }
+
+      inst.state = nextState;
+    }
+  } else {
+    internalInstance.queue = null;
+  }
+} // Invokes the mount life-cycles on a previously never rendered instance.
+
+
+function mountClassInstance(instance, ctor, newProps, maskedLegacyContext) {
+
+  const initialState = instance.state !== undefined ? instance.state : null;
+  instance.updater = classComponentUpdater;
+  instance.props = newProps;
+  instance.state = initialState; // We don't bother initializing the refs object on the server, since we're not going to resolve them anyway.
+  // The internal instance will be used to manage updates that happen during this mount.
+
+  const internalInstance = {
+    queue: [],
+    replace: false
+  };
+  set(instance, internalInstance);
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    instance.context = readContext$1(contextType);
+  } else {
+    instance.context = maskedLegacyContext;
+  }
+
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    instance.state = applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, initialState, newProps);
+  } // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+
+  if (typeof ctor.getDerivedStateFromProps !== 'function' && typeof instance.getSnapshotBeforeUpdate !== 'function' && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
+    callComponentWillMount(ctor, instance); // If we had additional state updates during this life-cycle, let's
+    // process them now.
+
+    processUpdateQueue(internalInstance, instance, newProps, maskedLegacyContext);
+  }
+}
+
+// Ids are base 32 strings whose binary representation corresponds to the
+// position of a node in a tree.
+// Every time the tree forks into multiple children, we add additional bits to
+// the left of the sequence that represent the position of the child within the
+// current level of children.
+//
+//      00101       00010001011010101
+//      ╰─┬─╯       ╰───────┬───────╯
+//   Fork 5 of 20       Parent id
+//
+// The leading 0s are important. In the above example, you only need 3 bits to
+// represent slot 5. However, you need 5 bits to represent all the forks at
+// the current level, so we must account for the empty bits at the end.
+//
+// For this same reason, slots are 1-indexed instead of 0-indexed. Otherwise,
+// the zeroth id at a level would be indistinguishable from its parent.
+//
+// If a node has only one child, and does not materialize an id (i.e. does not
+// contain a useId hook), then we don't need to allocate any space in the
+// sequence. It's treated as a transparent indirection. For example, these two
+// trees produce the same ids:
+//
+// <>                          <>
+//   <Indirection>               <A />
+//     <A />                     <B />
+//   </Indirection>            </>
+//   <B />
+// </>
+//
+// However, we cannot skip any node that materializes an id. Otherwise, a parent
+// id that does not fork would be indistinguishable from its child id. For
+// example, this tree does not fork, but the parent and child must have
+// different ids.
+//
+// <Parent>
+//   <Child />
+// </Parent>
+//
+// To handle this scenario, every time we materialize an id, we allocate a
+// new level with a single slot. You can think of this as a fork with only one
+// prong, or an array of children with length 1.
+//
+// It's possible for the size of the sequence to exceed 32 bits, the max
+// size for bitwise operations. When this happens, we make more room by
+// converting the right part of the id to a string and storing it in an overflow
+// variable. We use a base 32 string representation, because 32 is the largest
+// power of 2 that is supported by toString(). We want the base to be large so
+// that the resulting ids are compact, and we want the base to be a power of 2
+// because every log2(base) bits corresponds to a single character, i.e. every
+// log2(32) = 5 bits. That means we can lop bits off the end 5 at a time without
+// affecting the final result.
+const emptyTreeContext = {
+  id: 1,
+  overflow: ''
+};
+function getTreeId(context) {
+  const overflow = context.overflow;
+  const idWithLeadingBit = context.id;
+  const id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
+  return id.toString(32) + overflow;
+}
+function pushTreeContext(baseContext, totalChildren, index) {
+  const baseIdWithLeadingBit = baseContext.id;
+  const baseOverflow = baseContext.overflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
+  // of the id; we use it to account for leading 0s.
+
+  const baseLength = getBitLength(baseIdWithLeadingBit) - 1;
+  const baseId = baseIdWithLeadingBit & ~(1 << baseLength);
+  const slot = index + 1;
+  const length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
+  // consideration the leading 1 we use to mark the end of the sequence.
+
+  if (length > 30) {
+    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
+    // This branch assumes the length of the base id is greater than 5; it won't
+    // work for smaller ids, because you need 5 bits per character.
+    //
+    // We encode the id in multiple steps: first the base id, then the
+    // remaining digits.
+    //
+    // Each 5 bit sequence corresponds to a single base 32 character. So for
+    // example, if the current id is 23 bits long, we can convert 20 of those
+    // bits into a string of 4 characters, with 3 bits left over.
+    //
+    // First calculate how many bits in the base id represent a complete
+    // sequence of characters.
+    const numberOfOverflowBits = baseLength - baseLength % 5; // Then create a bitmask that selects only those bits.
+
+    const newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
+
+    const newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
+
+    const restOfBaseId = baseId >> numberOfOverflowBits;
+    const restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
+    // we made more room, this time it won't overflow.
+
+    const restOfLength = getBitLength(totalChildren) + restOfBaseLength;
+    const restOfNewBits = slot << restOfBaseLength;
+    const id = restOfNewBits | restOfBaseId;
+    const overflow = newOverflow + baseOverflow;
+    return {
+      id: 1 << restOfLength | id,
+      overflow
+    };
+  } else {
+    // Normal path
+    const newBits = slot << baseLength;
+    const id = newBits | baseId;
+    const overflow = baseOverflow;
+    return {
+      id: 1 << length | id,
+      overflow
+    };
+  }
+}
+
+function getBitLength(number) {
+  return 32 - clz32(number);
+}
+
+function getLeadingBit(id) {
+  return 1 << getBitLength(id) - 1;
+} // TODO: Math.clz32 is supported in Node 12+. Maybe we can drop the fallback.
+
+
+const 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
+
+const log = Math.log;
+const LN2 = Math.LN2;
+
+function clz32Fallback(x) {
+  const asUint = x >>> 0;
+
+  if (asUint === 0) {
+    return 32;
+  }
+
+  return 31 - (log(asUint) / LN2 | 0) | 0;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFlightWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop$2() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop$2, noop$2);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+
+const objectIs = // $FlowFixMe[method-unbinding]
+typeof Object.is === 'function' ? Object.is : is;
+
+let currentlyRenderingComponent = null;
+let currentlyRenderingTask = null;
+let currentlyRenderingRequest = null;
+let currentlyRenderingKeyPath = null;
+let firstWorkInProgressHook = null;
+let workInProgressHook = null; // Whether the work-in-progress hook is a re-rendered hook
+
+let isReRender = false; // Whether an update was scheduled during the currently executing render pass.
+
+let didScheduleRenderPhaseUpdate = false; // Counts the number of useId hooks in this component
+
+let localIdCounter = 0; // Chunks that should be pushed to the stream once the component
+// finishes rendering.
+// Counts the number of useFormState calls in this component
+
+let formStateCounter = 0; // The index of the useFormState hook that matches the one passed in at the
+// root during an MPA navigation, if any.
+
+let formStateMatchingIndex = -1; // Counts the number of use(thenable) calls in this component
+
+let thenableIndexCounter = 0;
+let thenableState = null; // Lazily created map of render-phase updates
+
+let renderPhaseUpdates = null; // Counter to prevent infinite loops.
+
+let numberOfReRenders = 0;
+const RE_RENDER_LIMIT = 25;
+
+function resolveCurrentlyRenderingComponent() {
+  if (currentlyRenderingComponent === null) {
+    throw new Error('Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for' + ' one of the following reasons:\n' + '1. You might have mismatching versions of React and the renderer (such as React DOM)\n' + '2. You might be breaking the Rules of Hooks\n' + '3. You might have more than one copy of React in the same app\n' + 'See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.');
+  }
+
+  return currentlyRenderingComponent;
+}
+
+function areHookInputsEqual(nextDeps, prevDeps) {
+  if (prevDeps === null) {
+
+    return false;
+  }
+
+
+  for (let i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    if (objectIs(nextDeps[i], prevDeps[i])) {
+      continue;
+    }
+
+    return false;
+  }
+
+  return true;
+}
+
+function createHook() {
+  if (numberOfReRenders > 0) {
+    throw new Error('Rendered more hooks than during the previous render');
+  }
+
+  return {
+    memoizedState: null,
+    queue: null,
+    next: null
+  };
+}
+
+function createWorkInProgressHook() {
+  if (workInProgressHook === null) {
+    // This is the first hook in the list
+    if (firstWorkInProgressHook === null) {
+      isReRender = false;
+      firstWorkInProgressHook = workInProgressHook = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = firstWorkInProgressHook;
+    }
+  } else {
+    if (workInProgressHook.next === null) {
+      isReRender = false; // Append to the end of the list
+
+      workInProgressHook = workInProgressHook.next = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = workInProgressHook.next;
+    }
+  }
+
+  return workInProgressHook;
+}
+
+function prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState) {
+  currentlyRenderingComponent = componentIdentity;
+  currentlyRenderingTask = task;
+  currentlyRenderingRequest = request;
+  currentlyRenderingKeyPath = keyPath;
+  // didScheduleRenderPhaseUpdate = false;
+  // firstWorkInProgressHook = null;
+  // numberOfReRenders = 0;
+  // renderPhaseUpdates = null;
+  // workInProgressHook = null;
+
+
+  localIdCounter = 0;
+  formStateCounter = 0;
+  formStateMatchingIndex = -1;
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function finishHooks(Component, props, children, refOrContext) {
+  // This must be called after every function component to prevent hooks from
+  // being used in classes.
+  while (didScheduleRenderPhaseUpdate) {
+    // Updates were scheduled during the render phase. They are stored in
+    // the `renderPhaseUpdates` map. Call the component again, reusing the
+    // work-in-progress hooks and applying the additional updates on top. Keep
+    // restarting until no more updates are scheduled.
+    didScheduleRenderPhaseUpdate = false;
+    localIdCounter = 0;
+    formStateCounter = 0;
+    formStateMatchingIndex = -1;
+    thenableIndexCounter = 0;
+    numberOfReRenders += 1; // Start over from the beginning of the list
+
+    workInProgressHook = null;
+    children = Component(props, refOrContext);
+  }
+
+  resetHooksState();
+  return children;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+function checkDidRenderIdHook() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  const didRenderIdHook = localIdCounter !== 0;
+  return didRenderIdHook;
+}
+function getFormStateCount() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateCounter;
+}
+function getFormStateMatchingIndex() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateMatchingIndex;
+} // Reset the internal hooks state if an error occurs while rendering a component
+
+function resetHooksState() {
+
+  currentlyRenderingComponent = null;
+  currentlyRenderingTask = null;
+  currentlyRenderingRequest = null;
+  currentlyRenderingKeyPath = null;
+  didScheduleRenderPhaseUpdate = false;
+  firstWorkInProgressHook = null;
+  numberOfReRenders = 0;
+  renderPhaseUpdates = null;
+  workInProgressHook = null;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+function useContext(context) {
+
+  resolveCurrentlyRenderingComponent();
+  return readContext$1(context);
+}
+
+function basicStateReducer(state, action) {
+  // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
+  return typeof action === 'function' ? action(state) : action;
+}
+
+function useState(initialState) {
+
+  return useReducer(basicStateReducer, // useReducer has a special case to support lazy useState initializers
+  initialState);
+}
+function useReducer(reducer, initialArg, init) {
+
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+
+  if (isReRender) {
+    // This is a re-render. Apply the new render phase updates to the previous
+    // current hook.
+    const queue = workInProgressHook.queue;
+    const dispatch = queue.dispatch;
+
+    if (renderPhaseUpdates !== null) {
+      // Render phase updates are stored in a map of queue -> linked list
+      const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+      if (firstRenderPhaseUpdate !== undefined) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        renderPhaseUpdates.delete(queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+        let newState = workInProgressHook.memoizedState;
+        let update = firstRenderPhaseUpdate;
+
+        do {
+          // Process this render phase update. We don't have to check the
+          // priority because it will always be the same as the current
+          // render's.
+          const action = update.action;
+
+          newState = reducer(newState, action);
+
+
+          update = update.next;
+        } while (update !== null); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+        workInProgressHook.memoizedState = newState;
+        return [newState, dispatch];
+      }
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    return [workInProgressHook.memoizedState, dispatch];
+  } else {
+
+    let initialState;
+
+    if (reducer === basicStateReducer) {
+      // Special case for `useState`.
+      initialState = typeof initialArg === 'function' ? initialArg() : initialArg;
+    } else {
+      initialState = init !== undefined ? init(initialArg) : initialArg;
+    }
+
+
+    workInProgressHook.memoizedState = initialState; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    const queue = workInProgressHook.queue = {
+      last: null,
+      dispatch: null
+    };
+    const dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingComponent, queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    return [workInProgressHook.memoizedState, dispatch];
+  }
+}
+
+function useMemo(nextCreate, deps) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+
+  if (workInProgressHook !== null) {
+    const prevState = workInProgressHook.memoizedState;
+
+    if (prevState !== null) {
+      if (nextDeps !== null) {
+        const prevDeps = prevState[1];
+
+        if (areHookInputsEqual(nextDeps, prevDeps)) {
+          return prevState[0];
+        }
+      }
+    }
+  }
+
+  const nextValue = nextCreate();
+
+
+  workInProgressHook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
+
+function useRef(initialValue) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const previousRef = workInProgressHook.memoizedState;
+
+  if (previousRef === null) {
+    const ref = {
+      current: initialValue
+    };
+
+
+    workInProgressHook.memoizedState = ref;
+    return ref;
+  } else {
+    return previousRef;
+  }
+}
+
+function dispatchAction(componentIdentity, queue, action) {
+  if (numberOfReRenders >= RE_RENDER_LIMIT) {
+    throw new Error('Too many re-renders. React limits the number of renders to prevent ' + 'an infinite loop.');
+  }
+
+  if (componentIdentity === currentlyRenderingComponent) {
+    // This is a render phase update. Stash it in a lazily-created map of
+    // queue -> linked list of updates. After this render pass, we'll restart
+    // and apply the stashed updates on top of the work-in-progress hook.
+    didScheduleRenderPhaseUpdate = true;
+    const update = {
+      action,
+      next: null
+    };
+
+    if (renderPhaseUpdates === null) {
+      renderPhaseUpdates = new Map();
+    }
+
+    const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+    if (firstRenderPhaseUpdate === undefined) {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      renderPhaseUpdates.set(queue, update);
+    } else {
+      // Append the update to the end of the list.
+      let lastRenderPhaseUpdate = firstRenderPhaseUpdate;
+
+      while (lastRenderPhaseUpdate.next !== null) {
+        lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+      }
+
+      lastRenderPhaseUpdate.next = update;
+    }
+  }
+}
+
+function useCallback(callback, deps) {
+  return useMemo(() => callback, deps);
+}
+
+function throwOnUseEffectEventCall() {
+  throw new Error("A function wrapped in useEffectEvent can't be called during rendering.");
+}
+
+function useEffectEvent(callback) {
+  // $FlowIgnore[incompatible-return]
+  return throwOnUseEffectEventCall;
+}
+
+function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  if (getServerSnapshot === undefined) {
+    throw new Error('Missing getServerSnapshot, which is required for ' + 'server-rendered content. Will revert to client rendering.');
+  }
+
+  return getServerSnapshot();
+}
+
+function useDeferredValue(value, initialValue) {
+  resolveCurrentlyRenderingComponent();
+
+  {
+    return initialValue !== undefined ? initialValue : value;
+  }
+}
+
+function unsupportedStartTransition() {
+  throw new Error('startTransition cannot be called during server rendering.');
+}
+
+function useTransition() {
+  resolveCurrentlyRenderingComponent();
+  return [false, unsupportedStartTransition];
+}
+
+function useHostTransitionStatus() {
+  resolveCurrentlyRenderingComponent();
+  return NotPendingTransition;
+}
+
+function unsupportedSetOptimisticState() {
+  throw new Error('Cannot update optimistic state while rendering.');
+}
+
+function useOptimistic(passthrough, reducer) {
+  resolveCurrentlyRenderingComponent();
+  return [passthrough, unsupportedSetOptimisticState];
+}
+
+function createPostbackFormStateKey(permalink, componentKeyPath, hookIndex) {
+  if (permalink !== undefined) {
+    // Don't bother to hash a permalink-based key since it's already short.
+    return 'p' + permalink;
+  } else {
+    // Append a node to the key path that represents the form state hook.
+    const keyPath = [componentKeyPath, null, hookIndex]; // Key paths are hashed to reduce the size. It does not need to be secure,
+    // and it's more important that it's fast than that it's completely
+    // collision-free.
+
+    const keyPathHash = createFastHashJS(JSON.stringify(keyPath));
+    return 'k' + keyPathHash;
+  }
+}
+
+function useFormState(action, initialState, permalink) {
+  resolveCurrentlyRenderingComponent(); // Count the number of useFormState hooks per component. We also use this to
+  // track the position of this useFormState hook relative to the other ones in
+  // this component, so we can generate a unique key for each one.
+
+  const formStateHookIndex = formStateCounter++;
+  const request = currentlyRenderingRequest; // $FlowIgnore[prop-missing]
+
+  const formAction = action.$$FORM_ACTION;
+
+  if (typeof formAction === 'function') {
+    // This is a server action. These have additional features to enable
+    // MPA-style form submissions with progressive enhancement.
+    // TODO: If the same permalink is passed to multiple useFormStates, and
+    // they all have the same action signature, Fizz will pass the postback
+    // state to all of them. We should probably only pass it to the first one,
+    // and/or warn.
+    // The key is lazily generated and deduped so the that the keypath doesn't
+    // get JSON.stringify-ed unnecessarily, and at most once.
+    let nextPostbackStateKey = null; // Determine the current form state. If we received state during an MPA form
+    // submission, then we will reuse that, if the action identity matches.
+    // Otherwise we'll use the initial state argument. We will emit a comment
+    // marker into the stream that indicates whether the state was reused.
+
+    let state = initialState;
+    const componentKeyPath = currentlyRenderingKeyPath;
+    const postbackFormState = getFormState(request); // $FlowIgnore[prop-missing]
+
+    const isSignatureEqual = action.$$IS_SIGNATURE_EQUAL;
+
+    if (postbackFormState !== null && typeof isSignatureEqual === 'function') {
+      const postbackKey = postbackFormState[1];
+      const postbackReferenceId = postbackFormState[2];
+      const postbackBoundArity = postbackFormState[3];
+
+      if (isSignatureEqual.call(action, postbackReferenceId, postbackBoundArity)) {
+        nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+
+        if (postbackKey === nextPostbackStateKey) {
+          // This was a match
+          formStateMatchingIndex = formStateHookIndex; // Reuse the state that was submitted by the form.
+
+          state = postbackFormState[0];
+        }
+      }
+    } // Bind the state to the first argument of the action.
+
+
+    const boundAction = action.bind(null, state); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    }; // $FlowIgnore[prop-missing]
+
+
+    if (typeof boundAction.$$FORM_ACTION === 'function') {
+      // $FlowIgnore[prop-missing]
+      dispatch.$$FORM_ACTION = prefix => {
+        const metadata = boundAction.$$FORM_ACTION(prefix); // Override the action URL
+
+        if (permalink !== undefined) {
+
+          permalink += '';
+          metadata.action = permalink;
+        }
+
+        const formData = metadata.data;
+
+        if (formData) {
+          if (nextPostbackStateKey === null) {
+            nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+          }
+
+          formData.append('$ACTION_KEY', nextPostbackStateKey);
+        }
+
+        return metadata;
+      };
+    }
+
+    return [state, dispatch];
+  } else {
+    // This is not a server action, so the implementation is much simpler.
+    // Bind the state to the first argument of the action.
+    const boundAction = action.bind(null, initialState); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    };
+
+    return [initialState, dispatch];
+  }
+}
+
+function useId() {
+  const task = currentlyRenderingTask;
+  const treeId = getTreeId(task.treeContext);
+  const resumableState = currentResumableState;
+
+  if (resumableState === null) {
+    throw new Error('Invalid hook call. Hooks can only be called inside of the body of a function component.');
+  }
+
+  const localId = localIdCounter++;
+  return makeId(resumableState, treeId, localId);
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable;
+      return unwrapThenable(thenable);
+    } else if (usable.$$typeof === REACT_CONTEXT_TYPE || usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function unwrapThenable(thenable) {
+  const index = thenableIndexCounter;
+  thenableIndexCounter += 1;
+
+  if (thenableState === null) {
+    thenableState = createThenableState();
+  }
+
+  return trackUsedThenable(thenableState, thenable, index);
+}
+
+function unsupportedRefresh() {
+  throw new Error('Cache cannot be refreshed during server rendering.');
+}
+
+function useCacheRefresh() {
+  return unsupportedRefresh;
+}
+
+function useMemoCache(size) {
+  const data = new Array(size);
+
+  for (let i = 0; i < size; i++) {
+    data[i] = REACT_MEMO_CACHE_SENTINEL;
+  }
+
+  return data;
+}
+
+function noop$1() {}
+
+const HooksDispatcher = {
+  readContext,
+  use,
+  useContext,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+  useInsertionEffect: noop$1,
+  useLayoutEffect: noop$1,
+  useCallback,
+  // useImperativeHandle is not run in the server environment
+  useImperativeHandle: noop$1,
+  // Effects are not run in the server environment.
+  useEffect: noop$1,
+  // Debugging effect
+  useDebugValue: noop$1,
+  useDeferredValue,
+  useTransition,
+  useId,
+  // Subscriptions are not setup in a server environment.
+  useSyncExternalStore
+};
+
+{
+  HooksDispatcher.useCacheRefresh = useCacheRefresh;
+}
+
+{
+  HooksDispatcher.useEffectEvent = useEffectEvent;
+}
+
+{
+  HooksDispatcher.useMemoCache = useMemoCache;
+}
+
+{
+  HooksDispatcher.useHostTransitionStatus = useHostTransitionStatus;
+}
+
+{
+  HooksDispatcher.useOptimistic = useOptimistic;
+  HooksDispatcher.useFormState = useFormState;
+}
+
+let currentResumableState = null;
+function setCurrentResumableState(resumableState) {
+  currentResumableState = resumableState;
+}
+
+function getCacheSignal() {
+  throw new Error('Not implemented.');
+}
+
+function getCacheForType(resourceType) {
+  throw new Error('Not implemented.');
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal,
+  getCacheForType
+};
+
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+const ReactCurrentCache = ReactSharedInternals.ReactCurrentCache;
+// The name might be minified but we assume that it's going to be the same generated name. Typically
+// because it's just the same compiled output in practice.
+// resume with segmentID at the index
+
+const CLIENT_RENDERED = 4; // if it errors or infinitely suspends
+
+const PENDING = 0;
+const COMPLETED = 1;
+const FLUSHED = 2;
+const ABORTED = 3;
+const ERRORED = 4;
+const POSTPONED = 5;
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2; // This is a default heuristic for how to split up the HTML content into progressive
+// loading. Our goal is to be able to display additional new content about every 500ms.
+// Faster than that is unnecessary and should be throttled on the client. It also
+// adds unnecessary overhead to do more splits. We don't know if it's a higher or lower
+// end device but higher end suffer less from the overhead than lower end does from
+// not getting small enough pieces. We error on the side of low end.
+// We base this on low end 3G speeds which is about 500kbits per second. We assume
+// that there can be a reasonable drop off from max bandwidth which leaves you with
+// as little as 80%. We can receive half of that each 500ms - at best. In practice,
+// a little bandwidth is lost to processing and contention - e.g. CSS and images that
+// are downloaded along with the main content. So we estimate about half of that to be
+// the lower end throughput. In other words, we expect that you can at least show
+// about 12.5kb of content per 500ms. Not counting starting latency for the first
+// paint.
+// 500 * 1024 / 8 * .8 * 0.5 / 2
+
+const DEFAULT_PROGRESSIVE_CHUNK_SIZE = 12800;
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+
+  return null;
+}
+
+function noop() {}
+
+function createRequest(children, resumableState, renderState, rootFormatContext, progressiveChunkSize, onError, onAllReady, onShellReady, onShellError, onFatalError, onPostpone, formState) {
+  prepareHostDispatcher();
+  const pingedTasks = [];
+  const abortSet = new Set();
+  const request = {
+    destination: null,
+    flushScheduled: false,
+    resumableState,
+    renderState,
+    rootFormatContext,
+    progressiveChunkSize: progressiveChunkSize === undefined ? DEFAULT_PROGRESSIVE_CHUNK_SIZE : progressiveChunkSize,
+    status: OPEN,
+    fatalError: null,
+    nextSegmentId: 0,
+    allPendingTasks: 0,
+    pendingRootTasks: 0,
+    completedRootSegment: null,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    clientRenderedBoundaries: [],
+    completedBoundaries: [],
+    partialBoundaries: [],
+    trackedPostpones: null,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? noop : onPostpone,
+    onAllReady: onAllReady === undefined ? noop : onAllReady,
+    onShellReady: onShellReady === undefined ? noop : onShellReady,
+    onShellError: onShellError === undefined ? noop : onShellError,
+    onFatalError: onFatalError === undefined ? noop : onFatalError,
+    formState: formState === undefined ? null : formState
+  }; // This segment represents the root fallback.
+
+  const rootSegment = createPendingSegment(request, 0, null, rootFormatContext, // Root segments are never embedded in Text on either edge
+  false, false); // There is no parent so conceptually, we're unblocked to flush this segment.
+
+  rootSegment.parentFlushed = true;
+  const rootTask = createRenderTask(request, null, children, -1, null, rootSegment, abortSet, null, rootFormatContext, emptyContextObject, rootContextSnapshot, emptyTreeContext);
+  pingedTasks.push(rootTask);
+  return request;
+}
+function createPrerenderRequest(children, resumableState, renderState, rootFormatContext, progressiveChunkSize, onError, onAllReady, onShellReady, onShellError, onFatalError, onPostpone) {
+  const request = createRequest(children, resumableState, renderState, rootFormatContext, progressiveChunkSize, onError, onAllReady, onShellReady, onShellError, onFatalError, onPostpone, undefined); // Start tracking postponed holes during this render.
+
+  request.trackedPostpones = {
+    workingMap: new Map(),
+    rootNodes: [],
+    rootSlots: null
+  };
+  return request;
+}
+function resumeRequest(children, postponedState, renderState, onError, onAllReady, onShellReady, onShellError, onFatalError, onPostpone) {
+  prepareHostDispatcher();
+  const pingedTasks = [];
+  const abortSet = new Set();
+  const request = {
+    destination: null,
+    flushScheduled: false,
+    resumableState: postponedState.resumableState,
+    renderState,
+    rootFormatContext: postponedState.rootFormatContext,
+    progressiveChunkSize: postponedState.progressiveChunkSize,
+    status: OPEN,
+    fatalError: null,
+    nextSegmentId: postponedState.nextSegmentId,
+    allPendingTasks: 0,
+    pendingRootTasks: 0,
+    completedRootSegment: null,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    clientRenderedBoundaries: [],
+    completedBoundaries: [],
+    partialBoundaries: [],
+    trackedPostpones: null,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? noop : onPostpone,
+    onAllReady: onAllReady === undefined ? noop : onAllReady,
+    onShellReady: onShellReady === undefined ? noop : onShellReady,
+    onShellError: onShellError === undefined ? noop : onShellError,
+    onFatalError: onFatalError === undefined ? noop : onFatalError,
+    formState: null
+  };
+
+  if (typeof postponedState.replaySlots === 'number') {
+    const resumedId = postponedState.replaySlots; // We have a resume slot at the very root. This is effectively just a full rerender.
+
+    const rootSegment = createPendingSegment(request, 0, null, postponedState.rootFormatContext, // Root segments are never embedded in Text on either edge
+    false, false);
+    rootSegment.id = resumedId; // There is no parent so conceptually, we're unblocked to flush this segment.
+
+    rootSegment.parentFlushed = true;
+    const rootTask = createRenderTask(request, null, children, -1, null, rootSegment, abortSet, null, postponedState.rootFormatContext, emptyContextObject, rootContextSnapshot, emptyTreeContext);
+    pingedTasks.push(rootTask);
+    return request;
+  }
+
+  const replay = {
+    nodes: postponedState.replayNodes,
+    slots: postponedState.replaySlots,
+    pendingTasks: 0
+  };
+  const rootTask = createReplayTask(request, null, replay, children, -1, null, abortSet, null, postponedState.rootFormatContext, emptyContextObject, rootContextSnapshot, emptyTreeContext);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  if (supportsRequestStorage) {
+    const store = requestStorage.getStore();
+    if (store) return store;
+  }
+
+  return null;
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (request.pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createSuspenseBoundary(request, fallbackAbortableTasks) {
+  return {
+    status: PENDING,
+    rootSegmentID: -1,
+    parentFlushed: false,
+    pendingTasks: 0,
+    completedSegments: [],
+    byteSize: 0,
+    fallbackAbortableTasks,
+    errorDigest: null,
+    resources: createBoundaryResources(),
+    trackedContentKeyPath: null,
+    trackedFallbackNode: null
+  };
+}
+
+function createRenderTask(request, thenableState, node, childIndex, blockedBoundary, blockedSegment, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  const task = {
+    replay: null,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createReplayTask(request, thenableState, replay, node, childIndex, blockedBoundary, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  replay.pendingTasks++;
+  const task = {
+    replay,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment: null,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createPendingSegment(request, index, boundary, parentFormatContext, lastPushedText, textEmbedded) {
+  return {
+    status: PENDING,
+    id: -1,
+    // lazily assigned later
+    index,
+    parentFlushed: false,
+    chunks: [],
+    children: [],
+    parentFormatContext,
+    boundary,
+    lastPushedText,
+    textEmbedded
+  };
+} // DEV-only global reference to the currently executing task
+
+function popComponentStackInDEV(task) {
+} // stash the component stack of an unwinding error until it is processed
+
+function logPostpone(request, reason) {
+  // If this callback errors, we intentionally let that error bubble up to become a fatal error
+  // so that someone fixes the error reporting instead of hiding it.
+  request.onPostpone(reason);
+}
+
+function logRecoverableError(request, error) {
+  // If this callback errors, we intentionally let that error bubble up to become a fatal error
+  // so that someone fixes the error reporting instead of hiding it.
+  const errorDigest = request.onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest;
+}
+
+function fatalError(request, error) {
+  // This is called outside error handling code such as if the root errors outside
+  // a suspense boundary or if the root suspense boundary's fallback errors.
+  // It's also called if React itself or its host configs errors.
+  const onShellError = request.onShellError;
+  onShellError(error);
+  const onFatalError = request.onFatalError;
+  onFatalError(error);
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function renderSuspenseBoundary(request, someTask, keyPath, props) {
+  if (someTask.replay !== null) {
+    // If we're replaying through this pass, it means we're replaying through
+    // an already completed Suspense boundary. It's too late to do anything about it
+    // so we can just render through it.
+    const prevKeyPath = someTask.keyPath;
+    someTask.keyPath = keyPath;
+    const content = props.children;
+
+    try {
+      renderNode(request, someTask, content, -1);
+    } finally {
+      someTask.keyPath = prevKeyPath;
+    }
+
+    return;
+  } // $FlowFixMe: Refined.
+
+
+  const task = someTask;
+  const prevKeyPath = task.keyPath;
+  const parentBoundary = task.blockedBoundary;
+  const parentSegment = task.blockedSegment; // Each time we enter a suspense boundary, we split out into a new segment for
+  // the fallback so that we can later replace that segment with the content.
+  // This also lets us split out the main content even if it doesn't suspend,
+  // in case it ends up generating a large subtree of content.
+
+  const fallback = props.fallback;
+  const content = props.children;
+  const fallbackAbortSet = new Set();
+  const newBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+
+  if (request.trackedPostpones !== null) {
+    newBoundary.trackedContentKeyPath = keyPath;
+  }
+
+  const insertionIndex = parentSegment.chunks.length; // The children of the boundary segment is actually the fallback.
+
+  const boundarySegment = createPendingSegment(request, insertionIndex, newBoundary, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false);
+  parentSegment.children.push(boundarySegment); // The parentSegment has a child Segment at this index so we reset the lastPushedText marker on the parent
+
+  parentSegment.lastPushedText = false; // This segment is the actual child content. We can start rendering that immediately.
+
+  const contentRootSegment = createPendingSegment(request, 0, null, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false); // We mark the root segment as having its parent flushed. It's not really flushed but there is
+  // no parent segment so there's nothing to wait on.
+
+  contentRootSegment.parentFlushed = true; // Currently this is running synchronously. We could instead schedule this to pingedTasks.
+  // I suspect that there might be some efficiency benefits from not creating the suspended task
+  // and instead just using the stack if possible.
+  // TODO: Call this directly instead of messing with saving and restoring contexts.
+  // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and which segment
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = newBoundary;
+  task.blockedSegment = contentRootSegment;
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, newBoundary.resources);
+  }
+
+  task.keyPath = keyPath;
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+    pushSegmentFinale(contentRootSegment.chunks, request.renderState, contentRootSegment.lastPushedText, contentRootSegment.textEmbedded);
+    contentRootSegment.status = COMPLETED;
+    queueCompletedSegment(newBoundary, contentRootSegment);
+
+    if (newBoundary.pendingTasks === 0 && newBoundary.status === PENDING) {
+      newBoundary.status = COMPLETED; // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    contentRootSegment.status = ERRORED;
+    newBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+      const postponeInstance = error;
+      logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+      errorDigest = 'POSTPONE';
+    } else {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    newBoundary.errorDigest = errorDigest;
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.blockedSegment = parentSegment;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]];
+  const trackedPostpones = request.trackedPostpones;
+
+  if (trackedPostpones !== null) {
+    // We create a detached replay node to track any postpones inside the fallback.
+    const fallbackReplayNode = [fallbackKeyPath[1], fallbackKeyPath[2], [], null];
+    trackedPostpones.workingMap.set(fallbackKeyPath, fallbackReplayNode);
+
+    if (newBoundary.status === POSTPONED) {
+      // This must exist now.
+      const boundaryReplayNode = trackedPostpones.workingMap.get(keyPath);
+      boundaryReplayNode[4] = fallbackReplayNode;
+    } else {
+      // We might not inject it into the postponed tree, unless the content actually
+      // postpones too. We need to keep track of it until that happpens.
+      newBoundary.trackedFallbackNode = fallbackReplayNode;
+    }
+  } // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+
+  const suspendedFallbackTask = createRenderTask(request, null, fallback, -1, parentBoundary, boundarySegment, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function replaySuspenseBoundary(request, task, keyPath, props, id, childNodes, childSlots, fallbackNodes, fallbackSlots) {
+  const prevKeyPath = task.keyPath;
+  const previousReplaySet = task.replay;
+  const parentBoundary = task.blockedBoundary;
+  const content = props.children;
+  const fallback = props.fallback;
+  const fallbackAbortSet = new Set();
+  const resumedBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = id; // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and replay node
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = resumedBoundary;
+  task.replay = {
+    nodes: childNodes,
+    slots: childSlots,
+    pendingTasks: 1
+  };
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, resumedBoundary.resources);
+  }
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+    }
+
+    task.replay.pendingTasks--;
+
+    if (resumedBoundary.pendingTasks === 0 && resumedBoundary.status === PENDING) {
+      resumedBoundary.status = COMPLETED;
+      request.completedBoundaries.push(resumedBoundary); // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    resumedBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+      const postponeInstance = error;
+      logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+      errorDigest = 'POSTPONE';
+    } else {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    resumedBoundary.errorDigest = errorDigest;
+
+    task.replay.pendingTasks--; // The parent already flushed in the prerender so we need to schedule this to be emitted.
+
+    request.clientRenderedBoundaries.push(resumedBoundary); // We don't need to decrement any task numbers because we didn't spawn any new task.
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.replay = previousReplaySet;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]]; // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+  const fallbackReplay = {
+    nodes: fallbackNodes,
+    slots: fallbackSlots,
+    pendingTasks: 0
+  };
+  const suspendedFallbackTask = createReplayTask(request, null, fallbackReplay, fallback, -1, parentBoundary, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function renderHostElement(request, task, keyPath, type, props) {
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    const children = props.children; // TODO: Make this a Config for replaying.
+
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+  } else {
+    // Render
+    const children = pushStartInstance(segment.chunks, type, props, request.resumableState, request.renderState, task.formatContext, segment.lastPushedText);
+    segment.lastPushedText = false;
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+    pushEndInstance(segment.chunks, type, props, request.resumableState, prevContext);
+    segment.lastPushedText = false;
+  }
+}
+
+function shouldConstruct(Component) {
+  return Component.prototype && Component.prototype.isReactComponent;
+}
+
+function renderWithHooks(request, task, keyPath, prevThenableState, Component, props, secondArg) {
+  const componentIdentity = {};
+  prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState);
+  const result = Component(props, secondArg);
+  return finishHooks(Component, props, result, secondArg);
+}
+
+function finishClassComponent(request, task, keyPath, instance, Component, props) {
+  const nextChildren = instance.render();
+
+  {
+    const childContextTypes = Component.childContextTypes;
+
+    if (childContextTypes !== null && childContextTypes !== undefined) {
+      const previousContext = task.legacyContext;
+      const mergedContext = processChildContext(instance, Component, previousContext, childContextTypes);
+      task.legacyContext = mergedContext;
+      renderNodeDestructive(request, task, null, nextChildren, -1);
+      task.legacyContext = previousContext;
+      return;
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, nextChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderClassComponent(request, task, keyPath, Component, props) {
+  const maskedContext = getMaskedContext(Component, task.legacyContext) ;
+  const instance = constructClassInstance(Component, props, maskedContext);
+  mountClassInstance(instance, Component, props, maskedContext);
+  finishClassComponent(request, task, keyPath, instance, Component);
+}
+// components for some reason.
+
+function renderIndeterminateComponent(request, task, keyPath, prevThenableState, Component, props) {
+  let legacyContext;
+
+  {
+    legacyContext = getMaskedContext(Component, task.legacyContext);
+  }
+
+  const value = renderWithHooks(request, task, keyPath, prevThenableState, Component, props, legacyContext);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+
+  if ( // Run these checks in production only if the flag is off.
+  // Eventually we'll delete this branch altogether.
+  typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) {
+
+    mountClassInstance(value, Component, props, legacyContext);
+    finishClassComponent(request, task, keyPath, value, Component);
+  } else {
+
+    finishFunctionComponent(request, task, keyPath, value, hasId, formStateCount, formStateMatchingIndex);
+  }
+}
+
+function finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex) {
+  let didEmitFormStateMarkers = false;
+
+  if (formStateCount !== 0 && request.formState !== null) {
+    // For each useFormState hook, emit a marker that indicates whether we
+    // rendered using the form state passed at the root. We only emit these
+    // markers if form state is passed at the root.
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      didEmitFormStateMarkers = true;
+      const target = segment.chunks;
+
+      for (let i = 0; i < formStateCount; i++) {
+        if (i === formStateMatchingIndex) {
+          pushFormStateMarkerIsMatching(target);
+        } else {
+          pushFormStateMarkerIsNotMatching(target);
+        }
+      }
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+
+  if (hasId) {
+    // This component materialized an id. We treat this as its own level, with
+    // a single "child" slot.
+    const prevTreeContext = task.treeContext;
+    const totalChildren = 1;
+    const index = 0; // Modify the id context. Because we'll need to reset this if something
+    // suspends or errors, we'll use the non-destructive render path.
+
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, index);
+    renderNode(request, task, children, -1); // Like the other contexts, this does not need to be in a finally block
+    // because renderNode takes care of unwinding the stack.
+
+    task.treeContext = prevTreeContext;
+  } else if (didEmitFormStateMarkers) {
+    // If there were formState hooks, we must use the non-destructive path
+    // because this component is not a pure indirection; we emitted markers
+    // to the stream.
+    renderNode(request, task, children, -1);
+  } else {
+    // We're now successfully past this task, and we haven't modified the
+    // context stack. We don't have to pop back to the previous task every
+    // again, so we can use the destructive recursive form.
+    renderNodeDestructive(request, task, null, children, -1);
+  }
+
+  task.keyPath = prevKeyPath;
+}
+
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    // Resolve default props. Taken from ReactElement
+    const props = assign({}, baseProps);
+    const defaultProps = Component.defaultProps;
+
+    for (const propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+
+    return props;
+  }
+
+  return baseProps;
+}
+
+function renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref) {
+  const children = renderWithHooks(request, task, keyPath, prevThenableState, type.render, props, ref);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+  finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex);
+}
+
+function renderMemo(request, task, keyPath, prevThenableState, type, props, ref) {
+  const innerType = type.type;
+  const resolvedProps = resolveDefaultProps(innerType, props);
+  renderElement(request, task, keyPath, prevThenableState, innerType, resolvedProps, ref);
+}
+
+function renderContextConsumer(request, task, keyPath, context, props) {
+
+  const render = props.children;
+
+  const newValue = readContext$1(context);
+  const newChildren = render(newValue);
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, newChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderContextProvider(request, task, keyPath, type, props) {
+  const context = type._context;
+  const value = props.value;
+  const children = props.children;
+
+  const prevKeyPath = task.keyPath;
+  task.context = pushProvider(context, value);
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, children, -1);
+  task.context = popProvider();
+  task.keyPath = prevKeyPath;
+}
+
+function renderLazyComponent(request, task, keyPath, prevThenableState, lazyComponent, props, ref) {
+  const payload = lazyComponent._payload;
+  const init = lazyComponent._init;
+  const Component = init(payload);
+  const resolvedProps = resolveDefaultProps(Component, props);
+  renderElement(request, task, keyPath, prevThenableState, Component, resolvedProps, ref);
+}
+
+function renderOffscreen(request, task, keyPath, props) {
+  const mode = props.mode;
+
+  if (mode === 'hidden') ; else {
+    // A visible Offscreen boundary is treated exactly like a fragment: a
+    // pure indirection.
+    const prevKeyPath = task.keyPath;
+    task.keyPath = keyPath;
+    renderNodeDestructive(request, task, null, props.children, -1);
+    task.keyPath = prevKeyPath;
+  }
+}
+
+function renderElement(request, task, keyPath, prevThenableState, type, props, ref) {
+  if (typeof type === 'function') {
+    if (shouldConstruct(type)) {
+      renderClassComponent(request, task, keyPath, type, props);
+      return;
+    } else {
+      renderIndeterminateComponent(request, task, keyPath, prevThenableState, type, props);
+      return;
+    }
+  }
+
+  if (typeof type === 'string') {
+    renderHostElement(request, task, keyPath, type, props);
+    return;
+  }
+
+  switch (type) {
+    // LegacyHidden acts the same as a fragment. This only works because we
+    // currently assume that every instance of LegacyHidden is accompanied by a
+    // host component wrapper. In the hidden mode, the host component is given a
+    // `hidden` attribute, which ensures that the initial HTML is not visible.
+    // To support the use of LegacyHidden as a true fragment, without an extra
+    // DOM node, we would have to hide the initial HTML in some other way.
+    // TODO: Delete in LegacyHidden. It's an unstable API only used in the
+    // www build. As a migration step, we could add a special prop to Offscreen
+    // that simulates the old behavior (no hiding, no change to effects).
+    case REACT_LEGACY_HIDDEN_TYPE:
+    case REACT_DEBUG_TRACING_MODE_TYPE:
+    case REACT_STRICT_MODE_TYPE:
+    case REACT_PROFILER_TYPE:
+    case REACT_FRAGMENT_TYPE:
+      {
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_OFFSCREEN_TYPE:
+      {
+        renderOffscreen(request, task, keyPath, props);
+        return;
+      }
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      {
+
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_SCOPE_TYPE:
+      {
+
+        throw new Error('ReactDOMServer does not yet support scope components.');
+      }
+
+    case REACT_SUSPENSE_TYPE:
+      {
+        {
+          renderSuspenseBoundary(request, task, keyPath, props);
+        }
+
+        return;
+      }
+  }
+
+  if (typeof type === 'object' && type !== null) {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        {
+          renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          renderMemo(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_PROVIDER_TYPE:
+        {
+          renderContextProvider(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_CONTEXT_TYPE:
+        {
+          renderContextConsumer(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_LAZY_TYPE:
+        {
+          renderLazyComponent(request, task, keyPath, prevThenableState, type, props);
+          return;
+        }
+    }
+  }
+
+  let info = '';
+
+  throw new Error('Element type is invalid: expected a string (for built-in ' + 'components) or a class/function (for composite components) ' + ("but got: " + (type == null ? type : typeof type) + "." + info));
+}
+
+function resumeNode(request, task, segmentId, node, childIndex) {
+  const prevReplay = task.replay;
+  const blockedBoundary = task.blockedBoundary;
+  const resumedSegment = createPendingSegment(request, 0, null, task.formatContext, false, false);
+  resumedSegment.id = segmentId;
+  resumedSegment.parentFlushed = true;
+
+  try {
+    // Convert the current ReplayTask to a RenderTask.
+    const renderTask = task;
+    renderTask.replay = null;
+    renderTask.blockedSegment = resumedSegment;
+    renderNode(request, task, node, childIndex);
+    resumedSegment.status = COMPLETED;
+
+    if (blockedBoundary === null) {
+      request.completedRootSegment = resumedSegment;
+    } else {
+      queueCompletedSegment(blockedBoundary, resumedSegment);
+
+      if (blockedBoundary.parentFlushed) {
+        request.partialBoundaries.push(blockedBoundary);
+      }
+    }
+  } finally {
+    // Restore to a ReplayTask.
+    task.replay = prevReplay;
+    task.blockedSegment = null;
+  }
+}
+
+function replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, replay) {
+  // We're replaying. Find the path to follow.
+  const replayNodes = replay.nodes;
+
+  for (let i = 0; i < replayNodes.length; i++) {
+    // Flow doesn't support refinement on tuples so we do it manually here.
+    const node = replayNodes[i];
+
+    if (keyOrIndex !== node[1]) {
+      continue;
+    }
+
+    if (node.length === 4) {
+      // Matched a replayable path.
+      // Let's double check that the component name matches as a precaution.
+      if (name !== null && name !== node[0]) {
+        throw new Error('Expected the resume to render <' + node[0] + '> in this slot but instead it rendered <' + name + '>. ' + "The tree doesn't match so React will fallback to client rendering.");
+      }
+
+      const childNodes = node[2];
+      const childSlots = node[3];
+      const currentNode = task.node;
+      task.replay = {
+        nodes: childNodes,
+        slots: childSlots,
+        pendingTasks: 1
+      };
+
+      try {
+        renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+
+        if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0 // TODO check remaining slots
+        ) {
+            throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+          }
+
+        task.replay.pendingTasks--;
+      } catch (x) {
+        if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+          // Suspend
+          if (task.node === currentNode) {
+            // This same element suspended so we need to pop the replay we just added.
+            task.replay = replay;
+          }
+
+          throw x;
+        }
+
+        task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+        // during a replay. That's because this component didn't actually error
+        // in the original prerender. What's unable to complete is the child
+        // replay nodes which might be Suspense boundaries which are able to
+        // absorb the error and we can still continue with siblings.
+
+        erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+      }
+
+      task.replay = replay;
+    } else {
+      // Let's double check that the component type matches.
+      if (type !== REACT_SUSPENSE_TYPE) {
+        const expectedType = 'Suspense';
+        throw new Error('Expected the resume to render <' + expectedType + '> in this slot but instead it rendered <' + (getComponentNameFromType(type) || 'Unknown') + '>. ' + "The tree doesn't match so React will fallback to client rendering.");
+      } // Matched a replayable path.
+
+
+      replaySuspenseBoundary(request, task, keyPath, props, node[5], node[2], node[3], node[4] === null ? [] : node[4][2], node[4] === null ? null : node[4][3]);
+    } // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+
+    replayNodes.splice(i, 1);
+    return;
+  } // We didn't find any matching nodes. We assume that this element was already
+  // rendered in the prelude and skip it.
+
+} // $FlowFixMe[missing-local-annot]
+
+function renderNodeDestructive(request, task, // The thenable state reused from the previous attempt, if any. This is almost
+// always null, except when called by retryTask.
+prevThenableState, node, childIndex) {
+  {
+    return renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex);
+  }
+} // This function by it self renders a node and consumes the task by mutating it
+// to update the current execution state.
+
+
+function renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex) {
+  if (task.replay !== null && typeof task.replay.slots === 'number') {
+    // TODO: Figure out a cheaper place than this hot path to do this check.
+    const resumeSegmentID = task.replay.slots;
+    resumeNode(request, task, resumeSegmentID, node, childIndex);
+    return;
+  } // Stash the node we're working on. We'll pick up from this task in case
+  // something suspends.
+
+
+  task.node = node;
+  task.childIndex = childIndex; // Handle object types
+
+  if (typeof node === 'object' && node !== null) {
+    switch (node.$$typeof) {
+      case REACT_ELEMENT_TYPE:
+        {
+          const element = node;
+          const type = element.type;
+          const key = element.key;
+          const props = element.props;
+          const ref = element.ref;
+          const name = getComponentNameFromType(type);
+          const keyOrIndex = key == null ? childIndex === -1 ? 0 : childIndex : key;
+          const keyPath = [task.keyPath, name, keyOrIndex];
+
+          if (task.replay !== null) {
+            replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, task.replay); // No matches found for this node. We assume it's already emitted in the
+            // prelude and skip it during the replay.
+          } else {
+            // We're doing a plain render.
+            renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+          }
+
+          return;
+        }
+
+      case REACT_PORTAL_TYPE:
+        throw new Error('Portals are not currently supported by the server renderer. ' + 'Render them conditionally so that they only appear on the client render.');
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyNode = node;
+          const payload = lazyNode._payload;
+          const init = lazyNode._init;
+          let resolvedNode;
+
+          {
+            resolvedNode = init(payload);
+          }
+
+          renderNodeDestructive(request, task, null, resolvedNode, childIndex);
+          return;
+        }
+    }
+
+    if (isArray(node)) {
+      renderChildrenArray(request, task, node, childIndex);
+      return;
+    }
+
+    const iteratorFn = getIteratorFn(node);
+
+    if (iteratorFn) {
+
+      const iterator = iteratorFn.call(node);
+
+      if (iterator) {
+        // We need to know how many total children are in this set, so that we
+        // can allocate enough id slots to acommodate them. So we must exhaust
+        // the iterator before we start recursively rendering the children.
+        // TODO: This is not great but I think it's inherent to the id
+        // generation algorithm.
+        let step = iterator.next(); // If there are not entries, we need to push an empty so we start by checking that.
+
+        if (!step.done) {
+          const children = [];
+
+          do {
+            children.push(step.value);
+            step = iterator.next();
+          } while (!step.done);
+
+          renderChildrenArray(request, task, children, childIndex);
+          return;
+        }
+
+        return;
+      }
+    } // Usables are a valid React node type. When React encounters a Usable in
+    // a child position, it unwraps it using the same algorithm as `use`. For
+    // example, for promises, React will throw an exception to unwind the
+    // stack, then replay the component once the promise resolves.
+    //
+    // A difference from `use` is that React will keep unwrapping the value
+    // until it reaches a non-Usable type.
+    //
+    // e.g. Usable<Usable<Usable<T>>> should resolve to T
+
+
+    const maybeUsable = node;
+
+    if (typeof maybeUsable.then === 'function') {
+      const thenable = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, unwrapThenable(thenable), childIndex);
+    }
+
+    if (maybeUsable.$$typeof === REACT_CONTEXT_TYPE || maybeUsable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, readContext$1(context), childIndex);
+    } // $FlowFixMe[method-unbinding]
+
+
+    const childString = Object.prototype.toString.call(node);
+    throw new Error("Objects are not valid as a React child (found: " + (childString === '[object Object]' ? 'object with keys {' + Object.keys(node).join(', ') + '}' : childString) + "). " + 'If you meant to render a collection of children, use an array ' + 'instead.');
+  }
+
+  if (typeof node === 'string') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+
+  if (typeof node === 'number') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, '' + node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+}
+
+function replayFragment(request, task, children, childIndex) {
+  // If we're supposed follow this array, we'd expect to see a ReplayNode matching
+  // this fragment.
+  const replay = task.replay;
+  const replayNodes = replay.nodes;
+
+  for (let j = 0; j < replayNodes.length; j++) {
+    const node = replayNodes[j];
+
+    if (node[1] !== childIndex) {
+      continue;
+    } // Matched a replayable path.
+
+
+    const childNodes = node[2];
+    const childSlots = node[3];
+    task.replay = {
+      nodes: childNodes,
+      slots: childSlots,
+      pendingTasks: 1
+    };
+
+    try {
+      renderChildrenArray(request, task, children, -1);
+
+      if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+        throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+      }
+
+      task.replay.pendingTasks--;
+    } catch (x) {
+      if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+        // Suspend
+        throw x;
+      }
+
+      task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+      // during a replay. That's because this component didn't actually error
+      // in the original prerender. What's unable to complete is the child
+      // replay nodes which might be Suspense boundaries which are able to
+      // absorb the error and we can still continue with siblings.
+      // This is an error, stash the component stack if it is null.
+
+      erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+    }
+
+    task.replay = replay; // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+    replayNodes.splice(j, 1);
+    break;
+  }
+}
+
+function renderChildrenArray(request, task, children, childIndex) {
+  const prevKeyPath = task.keyPath;
+
+  if (childIndex !== -1) {
+    task.keyPath = [task.keyPath, 'Fragment', childIndex];
+
+    if (task.replay !== null) {
+      replayFragment(request, // $FlowFixMe: Refined.
+      task, children, childIndex);
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  const prevTreeContext = task.treeContext;
+  const totalChildren = children.length;
+
+  if (task.replay !== null) {
+    // Replay
+    // First we need to check if we have any resume slots at this level.
+    const resumeSlots = task.replay.slots;
+
+    if (resumeSlots !== null && typeof resumeSlots === 'object') {
+      for (let i = 0; i < totalChildren; i++) {
+        const node = children[i];
+        task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+        // up and render the sibling if something suspends.
+
+        const resumeSegmentID = resumeSlots[i]; // TODO: If this errors we should still continue with the next sibling.
+
+        if (typeof resumeSegmentID === 'number') {
+          resumeNode(request, task, resumeSegmentID, node, i); // We finished rendering this node, so now we can consume this
+          // slot. This must happen after in case we rerender this task.
+
+          delete resumeSlots[i];
+        } else {
+          renderNode(request, task, node, i);
+        }
+      }
+
+      task.treeContext = prevTreeContext;
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  for (let i = 0; i < totalChildren; i++) {
+    const node = children[i];
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+    // up and render the sibling if something suspends.
+
+    renderNode(request, task, node, i);
+  } // Because this context is always set right before rendering every child, we
+  // only need to reset it to the previous value at the very end.
+
+
+  task.treeContext = prevTreeContext;
+  task.keyPath = prevKeyPath;
+}
+
+function trackPostpone(request, trackedPostpones, task, segment) {
+  segment.status = POSTPONED;
+  const keyPath = task.keyPath;
+  const boundary = task.blockedBoundary;
+
+  if (boundary === null) {
+    segment.id = request.nextSegmentId++;
+    trackedPostpones.rootSlots = segment.id;
+
+    if (request.completedRootSegment !== null) {
+      // Postpone the root if this was a deeper segment.
+      request.completedRootSegment.status = POSTPONED;
+    }
+
+    return;
+  }
+
+  if (boundary !== null && boundary.status === PENDING) {
+    boundary.status = POSTPONED; // We need to eagerly assign it an ID because we'll need to refer to
+    // it before flushing and we know that we can't inline it.
+
+    boundary.rootSegmentID = request.nextSegmentId++;
+    const boundaryKeyPath = boundary.trackedContentKeyPath;
+
+    if (boundaryKeyPath === null) {
+      throw new Error('It should not be possible to postpone at the root. This is a bug in React.');
+    }
+
+    const fallbackReplayNode = boundary.trackedFallbackNode;
+    const children = [];
+
+    if (boundaryKeyPath === keyPath && task.childIndex === -1) {
+      // Since we postponed directly in the Suspense boundary we can't have written anything
+      // to its segment. Therefore this will end up becoming the root segment.
+      segment.id = boundary.rootSegmentID; // We postponed directly inside the Suspense boundary so we mark this for resuming.
+
+      const boundaryNode = [boundaryKeyPath[1], boundaryKeyPath[2], children, boundary.rootSegmentID, fallbackReplayNode, boundary.rootSegmentID];
+      trackedPostpones.workingMap.set(boundaryKeyPath, boundaryNode);
+      addToReplayParent(boundaryNode, boundaryKeyPath[0], trackedPostpones);
+      return;
+    } else {
+      let boundaryNode = trackedPostpones.workingMap.get(boundaryKeyPath);
+
+      if (boundaryNode === undefined) {
+        boundaryNode = [boundaryKeyPath[1], boundaryKeyPath[2], children, null, fallbackReplayNode, boundary.rootSegmentID];
+        trackedPostpones.workingMap.set(boundaryKeyPath, boundaryNode);
+        addToReplayParent(boundaryNode, boundaryKeyPath[0], trackedPostpones);
+      } else {
+        // Upgrade to ReplaySuspenseBoundary.
+        const suspenseBoundary = boundaryNode;
+        suspenseBoundary[4] = fallbackReplayNode;
+        suspenseBoundary[5] = boundary.rootSegmentID;
+      } // Fall through to add the child node.
+
+    }
+  } // We know that this will leave a hole so we might as well assign an ID now.
+  // We might have one already if we had a parent that gave us its ID.
+
+
+  if (segment.id === -1) {
+    if (segment.parentFlushed && boundary !== null) {
+      // If this segment's parent was already flushed, it means we really just
+      // skipped the parent and this segment is now the root.
+      segment.id = boundary.rootSegmentID;
+    } else {
+      segment.id = request.nextSegmentId++;
+    }
+  }
+
+  if (task.childIndex === -1) {
+    // Resume starting from directly inside the previous parent element.
+    if (keyPath === null) {
+      trackedPostpones.rootSlots = segment.id;
+    } else {
+      const workingMap = trackedPostpones.workingMap;
+      let resumableNode = workingMap.get(keyPath);
+
+      if (resumableNode === undefined) {
+        resumableNode = [keyPath[1], keyPath[2], [], segment.id];
+        addToReplayParent(resumableNode, keyPath[0], trackedPostpones);
+      } else {
+        resumableNode[3] = segment.id;
+      }
+    }
+  } else {
+    let slots;
+
+    if (keyPath === null) {
+      slots = trackedPostpones.rootSlots;
+
+      if (slots === null) {
+        slots = trackedPostpones.rootSlots = {};
+      } else if (typeof slots === 'number') {
+        throw new Error('It should not be possible to postpone both at the root of an element ' + 'as well as a slot below. This is a bug in React.');
+      }
+    } else {
+      const workingMap = trackedPostpones.workingMap;
+      let resumableNode = workingMap.get(keyPath);
+
+      if (resumableNode === undefined) {
+        slots = {};
+        resumableNode = [keyPath[1], keyPath[2], [], slots];
+        workingMap.set(keyPath, resumableNode);
+        addToReplayParent(resumableNode, keyPath[0], trackedPostpones);
+      } else {
+        slots = resumableNode[3];
+
+        if (slots === null) {
+          slots = resumableNode[3] = {};
+        } else if (typeof slots === 'number') {
+          throw new Error('It should not be possible to postpone both at the root of an element ' + 'as well as a slot below. This is a bug in React.');
+        }
+      }
+    }
+
+    slots[task.childIndex] = segment.id;
+  }
+}
+
+function injectPostponedHole(request, task, reason) {
+  logPostpone(request, reason); // Something suspended, we'll need to create a new segment and resolve it later.
+
+  const segment = task.blockedSegment;
+  const insertionIndex = segment.chunks.length;
+  const newSegment = createPendingSegment(request, insertionIndex, null, task.formatContext, // Adopt the parent segment's leading text embed
+  segment.lastPushedText, // Assume we are text embedded at the trailing edge
+  true);
+  segment.children.push(newSegment); // Reset lastPushedText for current Segment since the new Segment "consumed" it
+
+  segment.lastPushedText = false;
+  return newSegment;
+}
+
+function spawnNewSuspendedReplayTask(request, task, thenableState, x) {
+  const newTask = createReplayTask(request, thenableState, task.replay, task.node, task.childIndex, task.blockedBoundary, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+}
+
+function spawnNewSuspendedRenderTask(request, task, thenableState, x) {
+  // Something suspended, we'll need to create a new segment and resolve it later.
+  const segment = task.blockedSegment;
+  const insertionIndex = segment.chunks.length;
+  const newSegment = createPendingSegment(request, insertionIndex, null, task.formatContext, // Adopt the parent segment's leading text embed
+  segment.lastPushedText, // Assume we are text embedded at the trailing edge
+  true);
+  segment.children.push(newSegment); // Reset lastPushedText for current Segment since the new Segment "consumed" it
+
+  segment.lastPushedText = false;
+  const newTask = createRenderTask(request, thenableState, task.node, task.childIndex, task.blockedBoundary, newSegment, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+} // This is a non-destructive form of rendering a node. If it suspends it spawns
+// a new task and restores the context of this task to what it was before.
+
+
+function renderNode(request, task, node, childIndex) {
+  // Snapshot the current context in case something throws to interrupt the
+  // process.
+  const previousFormatContext = task.formatContext;
+  const previousLegacyContext = task.legacyContext;
+  const previousContext = task.context;
+  const previousKeyPath = task.keyPath;
+  const previousTreeContext = task.treeContext;
+
+  let x; // Store how much we've pushed at this point so we can reset it in case something
+  // suspended partially through writing something.
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState();
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedReplayTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+      } // TODO: Abort any undiscovered Suspense boundaries in the ReplayNode.
+
+    }
+  } else {
+    // Render
+    const childrenLength = segment.children.length;
+    const chunkLength = segment.chunks.length;
+
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState(); // Reset the write pointers to where we started.
+
+      segment.children.length = childrenLength;
+      segment.chunks.length = chunkLength;
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedRenderTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+
+        if (request.trackedPostpones !== null && x.$$typeof === REACT_POSTPONE_TYPE && task.blockedBoundary !== null // bubble if we're postponing in the shell
+        ) {
+            // If we're tracking postpones, we inject a hole here and continue rendering
+            // sibling. Similar to suspending. If we're not tracking, we treat it more like
+            // an error. Notably this doesn't spawn a new task since nothing will fill it
+            // in during this prerender.
+            const postponeInstance = x;
+            const trackedPostpones = request.trackedPostpones;
+            const postponedSegment = injectPostponedHole(request, task, // We don't use ReplayTasks in prerenders.
+            postponeInstance.message);
+            trackPostpone(request, trackedPostpones, task, postponedSegment); // Restore the context. We assume that this will be restored by the inner
+            // functions in case nothing throws so we don't use "finally" here.
+
+            task.formatContext = previousFormatContext;
+            task.legacyContext = previousLegacyContext;
+            task.context = previousContext;
+            task.keyPath = previousKeyPath;
+            task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+            switchContext(previousContext);
+            return;
+          }
+      }
+    }
+  } // Restore the context. We assume that this will be restored by the inner
+  // functions in case nothing throws so we don't use "finally" here.
+
+
+  task.formatContext = previousFormatContext;
+  task.legacyContext = previousLegacyContext;
+  task.context = previousContext;
+  task.keyPath = previousKeyPath;
+  task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+  switchContext(previousContext);
+  // Let's terminate the rest of the tree and don't render any siblings.
+
+
+  throw x;
+}
+
+function erroredReplay(request, boundary, error, replayNodes, resumeSlots) {
+  // Erroring during a replay doesn't actually cause an error by itself because
+  // that component has already rendered. What causes the error is the resumable
+  // points that we did not yet finish which will be below the point of the reset.
+  // For example, if we're replaying a path to a Suspense boundary that is not done
+  // that doesn't error the parent Suspense boundary.
+  // This might be a bit strange that the error in a parent gets thrown at a child.
+  // We log it only once and reuse the digest.
+  let errorDigest;
+
+  if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+    const postponeInstance = error;
+    logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+    errorDigest = 'POSTPONE';
+  } else {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  abortRemainingReplayNodes(request, boundary, replayNodes, resumeSlots, error, errorDigest);
+}
+
+function erroredTask(request, boundary, error) {
+  // Report the error to a global handler.
+  let errorDigest;
+
+  if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+    const postponeInstance = error;
+    logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+    errorDigest = 'POSTPONE';
+  } else {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  if (boundary === null) {
+    fatalError(request, error);
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+      // so we can flush it, if the parent already flushed.
+
+
+      if (boundary.parentFlushed) {
+        // We don't have a preference where in the queue this goes since it's likely
+        // to error on the client anyway. However, intentionally client-rendered
+        // boundaries should be flushed earlier so that they can start on the client.
+        // We reuse the same queue for errors.
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function abortTaskSoft(task) {
+  // This aborts task without aborting the parent boundary that it blocks.
+  // It's used for when we didn't need this task to complete the tree.
+  // If task was needed, then it should use abortTask instead.
+  const request = this;
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+    finishedTask(request, boundary, segment);
+  }
+}
+
+function abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest) {
+  const resumedBoundary = createSuspenseBoundary(request, new Set());
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = rootSegmentID;
+  resumedBoundary.status = CLIENT_RENDERED;
+  resumedBoundary.errorDigest = errorDigest;
+
+  if (resumedBoundary.parentFlushed) {
+    request.clientRenderedBoundaries.push(resumedBoundary);
+  }
+}
+
+function abortRemainingReplayNodes(request, boundary, nodes, slots, error, errorDigest) {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+
+    if (node.length === 4) {
+      abortRemainingReplayNodes(request, boundary, node[2], node[3], error, errorDigest);
+    } else {
+      const boundaryNode = node;
+      const rootSegmentID = boundaryNode[5];
+      abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest);
+    }
+  } // Empty the set, since we've cleared it now.
+
+
+  nodes.length = 0;
+
+  if (slots !== null) {
+    // We had something still to resume in the parent boundary. We must trigger
+    // the error on the parent boundary since it's not able to complete.
+    if (boundary === null) {
+      throw new Error('We should not have any resumable nodes in the shell. ' + 'This is a bug in React.');
+    } else if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // Empty the set
+
+
+    if (typeof slots === 'object') {
+      for (const index in slots) {
+        delete slots[index];
+      }
+    }
+  }
+}
+
+function abortTask(task, request, error) {
+  // This aborts the task and aborts the parent that it blocks, putting it into
+  // client rendered mode.
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+  }
+
+  if (boundary === null) {
+    if (request.status !== CLOSING && request.status !== CLOSED) {
+      const replay = task.replay;
+
+      if (replay === null) {
+        // We didn't complete the root so we have nothing to show. We can close
+        // the request;
+        logRecoverableError(request, error);
+        fatalError(request, error);
+        return;
+      } else {
+        // If the shell aborts during a replay, that's not a fatal error. Instead
+        // we should be able to recover by client rendering all the root boundaries in
+        // the ReplaySet.
+        replay.pendingTasks--;
+
+        if (replay.pendingTasks === 0 && replay.nodes.length > 0) {
+          const errorDigest = logRecoverableError(request, error);
+          abortRemainingReplayNodes(request, null, replay.nodes, replay.slots, error, errorDigest);
+        }
+
+        request.pendingRootTasks--;
+
+        if (request.pendingRootTasks === 0) {
+          completeShell(request);
+        }
+      }
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = logRecoverableError(request, error);
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // If this boundary was still pending then we haven't already cancelled its fallbacks.
+    // We'll need to abort the fallbacks, which will also error that parent boundary.
+
+
+    boundary.fallbackAbortableTasks.forEach(fallbackTask => abortTask(fallbackTask, request, error));
+    boundary.fallbackAbortableTasks.clear();
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeShell(request) {
+  if (request.trackedPostpones === null) {
+    // We only emit early preloads on shell completion for renders. For prerenders
+    // we wait for the entire Request to finish because we are not responding to a
+    // live request and can wait for as much data as possible.
+    // we should only be calling completeShell when the shell is complete so we
+    // just use a literal here
+    const shellComplete = true;
+    emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  } // We have completed the shell so the shell can't error anymore.
+
+
+  request.onShellError = noop;
+  const onShellReady = request.onShellReady;
+  onShellReady();
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeAll(request) {
+  // During a render the shell must be complete if the entire request is finished
+  // however during a Prerender it is possible that the shell is incomplete because
+  // it postponed. We cannot use rootPendingTasks in the prerender case because
+  // those hit zero even when the shell postpones. Instead we look at the completedRootSegment
+  const shellComplete = request.trackedPostpones === null ? // Render, we assume it is completed
+  true : // Prerender Request, we use the state of the root segment
+  request.completedRootSegment === null || request.completedRootSegment.status !== POSTPONED;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  const onAllReady = request.onAllReady;
+  onAllReady();
+}
+
+function queueCompletedSegment(boundary, segment) {
+  if (segment.chunks.length === 0 && segment.children.length === 1 && segment.children[0].boundary === null) {
+    // This is an empty segment. There's nothing to write, so we can instead transfer the ID
+    // to the child. That way any existing references point to the child.
+    const childSegment = segment.children[0];
+    childSegment.id = segment.id;
+    childSegment.parentFlushed = true;
+
+    if (childSegment.status === COMPLETED) {
+      queueCompletedSegment(boundary, childSegment);
+    }
+  } else {
+    const completedSegments = boundary.completedSegments;
+    completedSegments.push(segment);
+  }
+}
+
+function finishedTask(request, boundary, segment) {
+  if (boundary === null) {
+    if (segment !== null && segment.parentFlushed) {
+      if (request.completedRootSegment !== null) {
+        throw new Error('There can only be one root segment. This is a bug in React.');
+      }
+
+      request.completedRootSegment = segment;
+    }
+
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status === CLIENT_RENDERED) ; else if (boundary.pendingTasks === 0) {
+      if (boundary.status === PENDING) {
+        boundary.status = COMPLETED;
+      } // This must have been the last segment we were waiting on. This boundary is now complete.
+
+
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent segment already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+        }
+      }
+
+      if (boundary.parentFlushed) {
+        // The segment might be part of a segment that didn't flush yet, but if the boundary's
+        // parent flushed, we need to schedule the boundary to be emitted.
+        request.completedBoundaries.push(boundary);
+      } // We can now cancel any pending task on the fallback since we won't need to show it anymore.
+      // This needs to happen after we read the parentFlushed flags because aborting can finish
+      // work which can trigger user code, which can start flushing, which can change those flags.
+      // If the boundary was POSTPONED, we still need to finish the fallback first.
+
+
+      if (boundary.status === COMPLETED) {
+        boundary.fallbackAbortableTasks.forEach(abortTaskSoft, request);
+        boundary.fallbackAbortableTasks.clear();
+      }
+    } else {
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+          const completedSegments = boundary.completedSegments;
+
+          if (completedSegments.length === 1) {
+            // This is the first time since we last flushed that we completed anything.
+            // We can schedule this boundary to emit its partially completed segments early
+            // in case the parent has already been flushed.
+            if (boundary.parentFlushed) {
+              request.partialBoundaries.push(boundary);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function retryTask(request, task) {
+  {
+    const blockedBoundary = task.blockedBoundary;
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, blockedBoundary ? blockedBoundary.resources : null);
+  }
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    retryReplayTask(request, // $FlowFixMe: Refined.
+    task);
+  } else {
+    retryRenderTask(request, // $FlowFixMe: Refined.
+    task, segment);
+  }
+}
+
+function retryRenderTask(request, task, segment) {
+  if (segment.status !== PENDING) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  const childrenLength = segment.children.length;
+  const chunkLength = segment.chunks.length;
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+    pushSegmentFinale(segment.chunks, request.renderState, segment.lastPushedText, segment.textEmbedded);
+    task.abortSet.delete(task);
+    segment.status = COMPLETED;
+    finishedTask(request, task.blockedBoundary, segment);
+  } catch (thrownValue) {
+    resetHooksState(); // Reset the write pointers to where we started.
+
+    segment.children.length = childrenLength;
+    segment.chunks.length = chunkLength;
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      } else if (request.trackedPostpones !== null && x.$$typeof === REACT_POSTPONE_TYPE) {
+        // If we're tracking postpones, we mark this segment as postponed and finish
+        // the task without filling it in. If we're not tracking, we treat it more like
+        // an error.
+        const trackedPostpones = request.trackedPostpones;
+        task.abortSet.delete(task);
+        const postponeInstance = x;
+        logPostpone(request, postponeInstance.message);
+        trackPostpone(request, trackedPostpones, task, segment);
+        finishedTask(request, task.blockedBoundary, segment);
+        return;
+      }
+    }
+
+    task.abortSet.delete(task);
+    segment.status = ERRORED;
+    erroredTask(request, task.blockedBoundary, x);
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function retryReplayTask(request, task) {
+  if (task.replay.pendingTasks === 0) {
+    // There are no pending tasks working on this set, so we must have aborted.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    finishedTask(request, task.blockedBoundary, null);
+  } catch (thrownValue) {
+    resetHooksState();
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    erroredReplay(request, task.blockedBoundary, x, task.replay.nodes, task.replay.slots);
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+
+    request.allPendingTasks--;
+
+    if (request.allPendingTasks === 0) {
+      completeAll(request);
+    }
+
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function performWork(request) {
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  const prevContext = getActiveContext();
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  let prevCacheDispatcher;
+
+  {
+    prevCacheDispatcher = ReactCurrentCache.current;
+    ReactCurrentCache.current = DefaultCacheDispatcher;
+  }
+
+  const prevRequest = currentRequest;
+  currentRequest = request;
+
+  const prevResumableState = currentResumableState;
+  setCurrentResumableState(request.resumableState);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    let i;
+
+    for (i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    pingedTasks.splice(0, i);
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    setCurrentResumableState(prevResumableState);
+    ReactCurrentDispatcher.current = prevDispatcher;
+
+    {
+      ReactCurrentCache.current = prevCacheDispatcher;
+    }
+
+    if (prevDispatcher === HooksDispatcher) {
+      // This means that we were in a reentrant work loop. This could happen
+      // in a renderer that supports synchronous work like renderToString,
+      // when it's called from within another renderer.
+      // Normally we don't bother switching the contexts to their root/default
+      // values when leaving because we'll likely need the same or similar
+      // context again. However, when we're inside a synchronous loop like this
+      // we'll to restore the context to what it was before returning.
+      switchContext(prevContext);
+    }
+
+    currentRequest = prevRequest;
+  }
+}
+
+function flushSubtree(request, destination, segment) {
+  segment.parentFlushed = true;
+
+  switch (segment.status) {
+    case PENDING:
+      {
+        // We're emitting a placeholder for this segment to be filled in later.
+        // Therefore we'll need to assign it an ID - to refer to it by.
+        segment.id = request.nextSegmentId++; // Fallthrough
+      }
+
+    case POSTPONED:
+      {
+        const segmentID = segment.id; // When this segment finally completes it won't be embedded in text since it will flush separately
+
+        segment.lastPushedText = false;
+        segment.textEmbedded = false;
+        return writePlaceholder(destination, request.renderState, segmentID);
+      }
+
+    case COMPLETED:
+      {
+        segment.status = FLUSHED;
+        let r = true;
+        const chunks = segment.chunks;
+        let chunkIdx = 0;
+        const children = segment.children;
+
+        for (let childIdx = 0; childIdx < children.length; childIdx++) {
+          const nextChild = children[childIdx]; // Write all the chunks up until the next child.
+
+          for (; chunkIdx < nextChild.index; chunkIdx++) {
+            writeChunk(destination, chunks[chunkIdx]);
+          }
+
+          r = flushSegment(request, destination, nextChild);
+        } // Finally just write all the remaining chunks
+
+
+        for (; chunkIdx < chunks.length - 1; chunkIdx++) {
+          writeChunk(destination, chunks[chunkIdx]);
+        }
+
+        if (chunkIdx < chunks.length) {
+          r = writeChunkAndReturn(destination, chunks[chunkIdx]);
+        }
+
+        return r;
+      }
+
+    default:
+      {
+        throw new Error('Aborted, errored or already flushed boundaries should not be flushed again. This is a bug in React.');
+      }
+  }
+}
+
+function flushSegment(request, destination, segment) {
+  const boundary = segment.boundary;
+
+  if (boundary === null) {
+    // Not a suspense boundary.
+    return flushSubtree(request, destination, segment);
+  }
+
+  boundary.parentFlushed = true; // This segment is a Suspense boundary. We need to decide whether to
+  // emit the content or the fallback now.
+
+  if (boundary.status === CLIENT_RENDERED) {
+    // Emit a client rendered suspense boundary wrapper.
+    // We never queue the inner boundary so we'll never emit its content or partial segments.
+    writeStartClientRenderedSuspenseBoundary(destination, request.renderState, boundary.errorDigest); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndClientRenderedSuspenseBoundary(destination);
+  } else if (boundary.status !== COMPLETED) {
+    if (boundary.status === PENDING) {
+      // For pending boundaries we lazily assign an ID to the boundary
+      // and root segment.
+      boundary.rootSegmentID = request.nextSegmentId++;
+    }
+
+    if (boundary.completedSegments.length > 0) {
+      // If this is at least partially complete, we can queue it to be partially emitted early.
+      request.partialBoundaries.push(boundary);
+    } // This boundary is still loading. Emit a pending suspense boundary wrapper.
+
+
+    const id = boundary.rootSegmentID;
+    writeStartPendingSuspenseBoundary(destination, request.renderState, id); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else if (boundary.byteSize > request.progressiveChunkSize) {
+    // This boundary is large and will be emitted separately so that we can progressively show
+    // other content. We add it to the queue during the flush because we have to ensure that
+    // the parent flushes first so that there's something to inject it into.
+    // We also have to make sure that it's emitted into the queue in a deterministic slot.
+    // I.e. we can't insert it here when it completes.
+    // Assign an ID to refer to the future content by.
+    boundary.rootSegmentID = request.nextSegmentId++;
+    request.completedBoundaries.push(boundary); // Emit a pending rendered suspense boundary wrapper.
+
+    writeStartPendingSuspenseBoundary(destination, request.renderState, boundary.rootSegmentID); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else {
+    {
+      hoistResources(request.renderState, boundary.resources);
+    } // We can inline this boundary's content as a complete boundary.
+
+
+    writeStartCompletedSuspenseBoundary(destination);
+    const completedSegments = boundary.completedSegments;
+
+    if (completedSegments.length !== 1) {
+      throw new Error('A previously unvisited boundary must have exactly one root segment. This is a bug in React.');
+    }
+
+    const contentSegment = completedSegments[0];
+    flushSegment(request, destination, contentSegment);
+    return writeEndCompletedSuspenseBoundary(destination);
+  }
+}
+
+function flushClientRenderedBoundary(request, destination, boundary) {
+  return writeClientRenderBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.errorDigest, boundary.errorMessage, boundary.errorComponentStack);
+}
+
+function flushSegmentContainer(request, destination, segment) {
+  writeStartSegment(destination, request.renderState, segment.parentFormatContext, segment.id);
+  flushSegment(request, destination, segment);
+  return writeEndSegment(destination, segment.parentFormatContext);
+}
+
+function flushCompletedBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+    flushPartiallyCompletedSegment(request, destination, boundary, segment);
+  }
+
+  completedSegments.length = 0;
+
+  {
+    writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+
+  return writeCompletedBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.resources);
+}
+
+function flushPartialBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+
+    if (!flushPartiallyCompletedSegment(request, destination, boundary, segment)) {
+      i++;
+      completedSegments.splice(0, i); // Only write as much as the buffer wants. Something higher priority
+      // might want to write later.
+
+      return false;
+    }
+  }
+
+  completedSegments.splice(0, i);
+
+  {
+    // The way this is structured we only write resources for partial boundaries
+    // if there is no backpressure. Later before we complete the boundary we
+    // will write resources regardless of backpressure before we emit the
+    // completion instruction
+    return writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+}
+
+function flushPartiallyCompletedSegment(request, destination, boundary, segment) {
+  if (segment.status === FLUSHED) {
+    // We've already flushed this inline.
+    return true;
+  }
+
+  const segmentID = segment.id;
+
+  if (segmentID === -1) {
+    // This segment wasn't previously referred to. This happens at the root of
+    // a boundary. We make kind of a leap here and assume this is the root.
+    const rootSegmentID = segment.id = boundary.rootSegmentID;
+
+    if (rootSegmentID === -1) {
+      throw new Error('A root segment ID must have been assigned by now. This is a bug in React.');
+    }
+
+    return flushSegmentContainer(request, destination, segment);
+  } else if (segmentID === boundary.rootSegmentID) {
+    // When we emit postponed boundaries, we might have assigned the ID already
+    // but it's still the root segment so we can't inject it into the parent yet.
+    return flushSegmentContainer(request, destination, segment);
+  } else {
+    flushSegmentContainer(request, destination, segment);
+    return writeCompletedSegmentInstruction(destination, request.resumableState, request.renderState, segmentID);
+  }
+}
+
+function flushCompletedQueues(request, destination) {
+  beginWriting();
+
+  try {
+    // The structure of this is to go through each queue one by one and write
+    // until the sink tells us to stop. When we should stop, we still finish writing
+    // that item fully and then yield. At that point we remove the already completed
+    // items up until the point we completed them.
+    let i;
+    const completedRootSegment = request.completedRootSegment;
+
+    if (completedRootSegment !== null) {
+      if (completedRootSegment.status === POSTPONED) {
+        // We postponed the root, so we write nothing.
+        return;
+      } else if (request.pendingRootTasks === 0) {
+        if (enableFloat) {
+          writePreamble(destination, request.resumableState, request.renderState, request.allPendingTasks === 0 && request.trackedPostpones === null);
+        }
+
+        flushSegment(request, destination, completedRootSegment);
+        request.completedRootSegment = null;
+        writeCompletedRoot(destination, request.renderState, request.resumableState);
+      } else {
+        // We haven't flushed the root yet so we don't need to check any other branches further down
+        return;
+      }
+    }
+
+    if (enableFloat) {
+      writeHoistables(destination, request.resumableState, request.renderState);
+    } // We emit client rendering instructions for already emitted boundaries first.
+    // This is so that we can signal to the client to start client rendering them as
+    // soon as possible.
+
+
+    const clientRenderedBoundaries = request.clientRenderedBoundaries;
+
+    for (i = 0; i < clientRenderedBoundaries.length; i++) {
+      const boundary = clientRenderedBoundaries[i];
+
+      if (!flushClientRenderedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        clientRenderedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    clientRenderedBoundaries.splice(0, i); // Next we emit any complete boundaries. It's better to favor boundaries
+    // that are completely done since we can actually show them, than it is to emit
+    // any individual segments from a partially complete boundary.
+
+    const completedBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < completedBoundaries.length; i++) {
+      const boundary = completedBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        completedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    completedBoundaries.splice(0, i); // Allow anything written so far to flush to the underlying sink before
+    // we continue with lower priorities.
+
+    completeWriting(destination);
+    beginWriting(destination); // TODO: Here we'll emit data used by hydration.
+    // Next we emit any segments of any boundaries that are partially complete
+    // but not deeply complete.
+
+    const partialBoundaries = request.partialBoundaries;
+
+    for (i = 0; i < partialBoundaries.length; i++) {
+      const boundary = partialBoundaries[i];
+
+      if (!flushPartialBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        partialBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    partialBoundaries.splice(0, i); // Next we check the completed boundaries again. This may have had
+    // boundaries added to it in case they were too larged to be inlined.
+    // New ones might be added in this loop.
+
+    const largeBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < largeBoundaries.length; i++) {
+      const boundary = largeBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        largeBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    largeBoundaries.splice(0, i);
+  } finally {
+    if (request.allPendingTasks === 0 && request.pingedTasks.length === 0 && request.clientRenderedBoundaries.length === 0 && request.completedBoundaries.length === 0 // We don't need to check any partially completed segments because
+    // either they have pending task or they're complete.
+    ) {
+        request.flushScheduled = false;
+
+        {
+          // We write the trailing tags but only if don't have any data to resume.
+          // If we need to resume we'll write the postamble in the resume instead.
+          if (request.trackedPostpones === null) {
+            writePostamble(destination, request.resumableState);
+          }
+        }
+
+        completeWriting(destination);
+
+
+        close(destination); // We need to stop flowing now because we do not want any async contexts which might call
+        // float methods to initiate any flushes after this point
+
+        stopFlowing(request);
+      } else {
+      completeWriting(destination);
+    }
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  if (supportsRequestStorage) {
+    scheduleWork(() => requestStorage.run(request, performWork, request));
+  } else {
+    scheduleWork(() => performWork(request));
+  }
+
+  if (request.trackedPostpones === null) {
+    // this is either a regular render or a resume. For regular render we want
+    // to call emitEarlyPreloads after the first performWork because we want
+    // are responding to a live request and need to balance sending something early
+    // (i.e. don't want for the shell to finish) but we need something to send.
+    // The only implementation of this is for DOM at the moment and during resumes nothing
+    // actually emits but the code paths here are the same.
+    // During a prerender we don't want to be too aggressive in emitting early preloads
+    // because we aren't responding to a live request and we can wait for the prerender to
+    // postpone before we emit anything.
+    if (supportsRequestStorage) {
+      scheduleWork(() => requestStorage.run(request, enqueueEarlyPreloadsAfterInitialWork, request));
+    } else {
+      scheduleWork(() => enqueueEarlyPreloadsAfterInitialWork(request));
+    }
+  }
+}
+
+function enqueueEarlyPreloadsAfterInitialWork(request) {
+  const shellComplete = request.pendingRootTasks === 0;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    request.flushScheduled = true;
+    scheduleWork(() => {
+      // We need to existence check destination again here because it might go away
+      // in between the enqueueFlush call and the work execution
+      const destination = request.destination;
+
+      if (destination) {
+        flushCompletedQueues(request, destination);
+      } else {
+        request.flushScheduled = false;
+      }
+    });
+  }
+} // This function is intented to only be called during the pipe function for the Node builds.
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedQueues(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function stopFlowing(request) {
+  request.destination = null;
+} // This is called to early terminate a request. It puts all pending boundaries in client rendered state.
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+      abortableTasks.forEach(task => abortTask(task, request, error));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function flushResources(request) {
+  enqueueFlush(request);
+}
+function getFormState(request) {
+  return request.formState;
+}
+function getResumableState(request) {
+  return request.resumableState;
+}
+function getRenderState(request) {
+  return request.renderState;
+}
+
+function addToReplayParent(node, parentKeyPath, trackedPostpones) {
+  if (parentKeyPath === null) {
+    trackedPostpones.rootNodes.push(node);
+  } else {
+    const workingMap = trackedPostpones.workingMap;
+    let parentNode = workingMap.get(parentKeyPath);
+
+    if (parentNode === undefined) {
+      parentNode = [parentKeyPath[1], parentKeyPath[2], [], null];
+      workingMap.set(parentKeyPath, parentNode);
+      addToReplayParent(parentNode, parentKeyPath[0], trackedPostpones);
+    }
+
+    parentNode[2].push(node);
+  }
+} // Returns the state of a postponed request or null if nothing was postponed.
+
+
+function getPostponedState(request) {
+  const trackedPostpones = request.trackedPostpones;
+
+  if (trackedPostpones === null || trackedPostpones.rootNodes.length === 0 && trackedPostpones.rootSlots === null) {
+    // Reset. Let the flushing behave as if we completed the whole document.
+    request.trackedPostpones = null;
+    return null;
+  }
+
+  if (request.completedRootSegment !== null && request.completedRootSegment.status === POSTPONED) {
+    // We postponed the root so we didn't flush anything.
+    resetResumableState(request.resumableState, request.renderState);
+  }
+
+  return {
+    nextSegmentId: request.nextSegmentId,
+    rootFormatContext: request.rootFormatContext,
+    progressiveChunkSize: request.progressiveChunkSize,
+    resumableState: request.resumableState,
+    replayNodes: trackedPostpones.rootNodes,
+    replaySlots: trackedPostpones.rootSlots
+  };
+}
+
+function renderToReadableStream(children, options) {
+  return new Promise((resolve, reject) => {
+    let onFatalError;
+    let onAllReady;
+    const allReady = new Promise((res, rej) => {
+      onAllReady = res;
+      onFatalError = rej;
+    });
+
+    function onShellReady() {
+      const stream = new ReadableStream({
+        type: 'bytes',
+        pull: controller => {
+          startFlowing(request, controller);
+        },
+        cancel: reason => {
+          stopFlowing(request);
+          abort(request, reason);
+        }
+      }, // $FlowFixMe[prop-missing] size() methods are not allowed on byte streams.
+      {
+        highWaterMark: 0
+      }); // TODO: Move to sub-classing ReadableStream.
+
+      stream.allReady = allReady;
+      resolve(stream);
+    }
+
+    function onShellError(error) {
+      // If the shell errors the caller of `renderToReadableStream` won't have access to `allReady`.
+      // However, `allReady` will be rejected by `onFatalError` as well.
+      // So we need to catch the duplicate, uncatchable fatal error in `allReady` to prevent a `UnhandledPromiseRejection`.
+      allReady.catch(() => {});
+      reject(error);
+    }
+
+    const onHeaders = options ? options.onHeaders : undefined;
+    let onHeadersImpl;
+
+    if (onHeaders) {
+      onHeadersImpl = headersDescriptor => {
+        onHeaders(new Headers(headersDescriptor));
+      };
+    }
+
+    const resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined);
+    const request = createRequest(children, resumableState, createRenderState(resumableState, options ? options.nonce : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, onHeadersImpl, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, onShellReady, onShellError, onFatalError, options ? options.onPostpone : undefined, options ? options.formState : undefined);
+
+    if (options && options.signal) {
+      const signal = options.signal;
+
+      if (signal.aborted) {
+        abort(request, signal.reason);
+      } else {
+        const listener = () => {
+          abort(request, signal.reason);
+          signal.removeEventListener('abort', listener);
+        };
+
+        signal.addEventListener('abort', listener);
+      }
+    }
+
+    startWork(request);
+  });
+}
+
+function resume(children, postponedState, options) {
+  return new Promise((resolve, reject) => {
+    let onFatalError;
+    let onAllReady;
+    const allReady = new Promise((res, rej) => {
+      onAllReady = res;
+      onFatalError = rej;
+    });
+
+    function onShellReady() {
+      const stream = new ReadableStream({
+        type: 'bytes',
+        pull: controller => {
+          startFlowing(request, controller);
+        },
+        cancel: reason => {
+          stopFlowing(request);
+          abort(request, reason);
+        }
+      }, // $FlowFixMe[prop-missing] size() methods are not allowed on byte streams.
+      {
+        highWaterMark: 0
+      }); // TODO: Move to sub-classing ReadableStream.
+
+      stream.allReady = allReady;
+      resolve(stream);
+    }
+
+    function onShellError(error) {
+      // If the shell errors the caller of `renderToReadableStream` won't have access to `allReady`.
+      // However, `allReady` will be rejected by `onFatalError` as well.
+      // So we need to catch the duplicate, uncatchable fatal error in `allReady` to prevent a `UnhandledPromiseRejection`.
+      allReady.catch(() => {});
+      reject(error);
+    }
+
+    const request = resumeRequest(children, postponedState, resumeRenderState(postponedState.resumableState, options ? options.nonce : undefined), options ? options.onError : undefined, onAllReady, onShellReady, onShellError, onFatalError, options ? options.onPostpone : undefined);
+
+    if (options && options.signal) {
+      const signal = options.signal;
+
+      if (signal.aborted) {
+        abort(request, signal.reason);
+      } else {
+        const listener = () => {
+          abort(request, signal.reason);
+          signal.removeEventListener('abort', listener);
+        };
+
+        signal.addEventListener('abort', listener);
+      }
+    }
+
+    startWork(request);
+  });
+}
+
+function prerender(children, options) {
+  return new Promise((resolve, reject) => {
+    const onFatalError = reject;
+
+    function onAllReady() {
+      const stream = new ReadableStream({
+        type: 'bytes',
+        pull: controller => {
+          startFlowing(request, controller);
+        },
+        cancel: reason => {
+          stopFlowing(request);
+          abort(request, reason);
+        }
+      }, // $FlowFixMe[prop-missing] size() methods are not allowed on byte streams.
+      {
+        highWaterMark: 0
+      });
+      const result = {
+        postponed: getPostponedState(request),
+        prelude: stream
+      };
+      resolve(result);
+    }
+
+    const onHeaders = options ? options.onHeaders : undefined;
+    let onHeadersImpl;
+
+    if (onHeaders) {
+      onHeadersImpl = headersDescriptor => {
+        onHeaders(new Headers(headersDescriptor));
+      };
+    }
+
+    const resources = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined);
+    const request = createPrerenderRequest(children, resources, createRenderState(resources, undefined, // nonce is not compatible with prerendered bootstrap scripts
+    options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, onHeadersImpl, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, undefined, undefined, onFatalError, options ? options.onPostpone : undefined);
+
+    if (options && options.signal) {
+      const signal = options.signal;
+
+      if (signal.aborted) {
+        abort(request, signal.reason);
+      } else {
+        const listener = () => {
+          abort(request, signal.reason);
+          signal.removeEventListener('abort', listener);
+        };
+
+        signal.addEventListener('abort', listener);
+      }
+    }
+
+    startWork(request);
+  });
+}
+
+exports.prerender = prerender;
+exports.renderToReadableStream = renderToReadableStream;
+exports.resume = resume;
+exports.version = ReactVersion;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.edge.production.min.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.edge.production.min.js
index e37f59d388d48..f941804353d6b 100644
--- a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.edge.production.min.js
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.edge.production.min.js
@@ -1,13 +1,11 @@
-/**
- * @license React
- * react-dom-server.edge.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
 /*
+ React
+ react-dom-server.edge.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
 
 
  JS Implementation of MurmurHash3 (r136) (as of May 20, 2011)
@@ -34,7 +32,7 @@
 'use strict';var ba=require("next/dist/compiled/react-experimental"),ca=require("react-dom");
 function da(a,b){var c=a.length&3;var d=a.length-c;var e=b;for(b=0;b<d;){var f=a.charCodeAt(b)&255|(a.charCodeAt(++b)&255)<<8|(a.charCodeAt(++b)&255)<<16|(a.charCodeAt(++b)&255)<<24;++b;f=3432918353*(f&65535)+((3432918353*(f>>>16)&65535)<<16)&4294967295;f=f<<15|f>>>17;f=461845907*(f&65535)+((461845907*(f>>>16)&65535)<<16)&4294967295;e^=f;e=e<<13|e>>>19;e=5*(e&65535)+((5*(e>>>16)&65535)<<16)&4294967295;e=(e&65535)+27492+(((e>>>16)+58964&65535)<<16)}f=0;switch(c){case 3:f^=(a.charCodeAt(b+2)&255)<<
 16;case 2:f^=(a.charCodeAt(b+1)&255)<<8;case 1:f^=a.charCodeAt(b)&255,f=3432918353*(f&65535)+((3432918353*(f>>>16)&65535)<<16)&4294967295,f=f<<15|f>>>17,e^=461845907*(f&65535)+((461845907*(f>>>16)&65535)<<16)&4294967295}e^=a.length;e^=e>>>16;e=2246822507*(e&65535)+((2246822507*(e>>>16)&65535)<<16)&4294967295;e^=e>>>13;e=3266489909*(e&65535)+((3266489909*(e>>>16)&65535)<<16)&4294967295;return(e^e>>>16)>>>0}var l=null,n=0;
-function r(a,b){if(0!==b.byteLength)if(512<b.byteLength)0<n&&(a.enqueue(new Uint8Array(l.buffer,0,n)),l=new Uint8Array(512),n=0),a.enqueue(b);else{var c=l.length-n;c<b.byteLength&&(0===c?a.enqueue(l):(l.set(b.subarray(0,c),n),a.enqueue(l),b=b.subarray(c)),l=new Uint8Array(512),n=0);l.set(b,n);n+=b.byteLength}}function v(a,b){r(a,b);return!0}function ha(a){l&&0<n&&(a.enqueue(new Uint8Array(l.buffer,0,n)),l=null,n=0)}var ia=new TextEncoder;function x(a){return ia.encode(a)}
+function q(a,b){if(0!==b.byteLength)if(512<b.byteLength)0<n&&(a.enqueue(new Uint8Array(l.buffer,0,n)),l=new Uint8Array(512),n=0),a.enqueue(b);else{var c=l.length-n;c<b.byteLength&&(0===c?a.enqueue(l):(l.set(b.subarray(0,c),n),a.enqueue(l),b=b.subarray(c)),l=new Uint8Array(512),n=0);l.set(b,n);n+=b.byteLength}}function v(a,b){q(a,b);return!0}function ha(a){l&&0<n&&(a.enqueue(new Uint8Array(l.buffer,0,n)),l=null,n=0)}var ia=new TextEncoder;function x(a){return ia.encode(a)}
 function z(a){return ia.encode(a)}function ja(a,b){"function"===typeof a.error?a.error(b):a.close()}
 var A=Object.assign,D=Object.prototype.hasOwnProperty,na=RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"),oa={},pa={};
 function wa(a){if(D.call(pa,a))return!0;if(D.call(oa,a))return!1;if(na.test(a))return pa[a]=!0;oa[a]=!0;return!1}
@@ -48,12 +46,12 @@ new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv","http
 function G(a){if("boolean"===typeof a||"number"===typeof a)return""+a;a=""+a;var b=Fa.exec(a);if(b){var c="",d,e=0;for(d=b.index;d<a.length;d++){switch(a.charCodeAt(d)){case 34:b="&quot;";break;case 38:b="&amp;";break;case 39:b="&#x27;";break;case 60:b="&lt;";break;case 62:b="&gt;";break;default:continue}e!==d&&(c+=a.slice(e,d));e=d+1;c+=b}a=e!==d?c+a.slice(e,d):c}return a}
 var Ga=/([A-Z])/g,Ha=/^ms-/,Ia=Array.isArray,Ja=ba.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,Ka={pending:!1,data:null,method:null,action:null},La=ca.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Dispatcher,$a={prefetchDNS:Ma,preconnect:Na,preload:Va,preloadModule:Wa,preinitStyle:Xa,preinitScript:Ya,preinitModuleScript:Za},I=[],ab=z('"></template>'),bb=z("<script>"),cb=z("\x3c/script>"),qb=z('<script src="'),rb=z('<script type="module" src="'),sb=z('" nonce="'),tb=z('" integrity="'),
 ub=z('" crossorigin="'),vb=z('" async="">\x3c/script>'),wb=/(<\/|<)(s)(cript)/gi;function xb(a,b,c,d){return""+b+("s"===c?"\\u0073":"\\u0053")+d}var yb=z('<script type="importmap">'),zb=z("\x3c/script>");
-function Ab(a,b,c,d,e,f,g,h,k){var m=void 0===b?bb:z('<script nonce="'+G(b)+'">'),p=a.idPrefix,t=[],q=null;void 0!==c&&t.push(m,x((""+c).replace(wb,xb)),cb);void 0!==f&&("string"===typeof f?(q={src:f,chunks:[]},Jb(q.chunks,{src:f,async:!0,integrity:void 0,nonce:b})):(q={src:f.src,chunks:[]},Jb(q.chunks,{src:f.src,async:!0,integrity:f.integrity,nonce:b})));c=[];void 0!==g&&(c.push(yb),c.push(x((""+JSON.stringify(g)).replace(wb,xb))),c.push(zb));g=h?{preconnects:"",fontPreloads:"",highImagePreloads:"",
-remainingCapacity:"number"===typeof k?k:2E3}:null;h={placeholderPrefix:z(p+"P:"),segmentPrefix:z(p+"S:"),boundaryPrefix:z(p+"B:"),startInlineScript:m,htmlChunks:null,headChunks:null,externalRuntimeScript:q,bootstrapChunks:t,onHeaders:h,headers:g,resets:{font:{},dns:{},connect:{default:{},anonymous:{},credentials:{}},image:{},style:{}},charsetChunks:[],preconnectChunks:[],importMapChunks:c,preloadChunks:[],hoistableChunks:[],preconnects:new Set,fontPreloads:new Set,highImagePreloads:new Set,styles:new Map,
-bootstrapScripts:new Set,scripts:new Set,bulkPreloads:new Set,preloads:{images:new Map,stylesheets:new Map,scripts:new Map,moduleScripts:new Map},nonce:b,boundaryResources:null,stylesToHoist:!1};if(void 0!==d)for(m=0;m<d.length;m++)c=d[m],g=q=void 0,k={rel:"preload",as:"script",fetchPriority:"low",nonce:b},"string"===typeof c?k.href=p=c:(k.href=p=c.src,k.integrity=g="string"===typeof c.integrity?c.integrity:void 0,k.crossOrigin=q="string"===typeof c||null==c.crossOrigin?void 0:"use-credentials"===
-c.crossOrigin?"use-credentials":""),c=a,f=p,c.scriptResources[f]=null,c.moduleScriptResources[f]=null,c=[],M(c,k),h.bootstrapScripts.add(c),t.push(qb,x(G(p))),b&&t.push(sb,x(G(b))),"string"===typeof g&&t.push(tb,x(G(g))),"string"===typeof q&&t.push(ub,x(G(q))),t.push(vb);if(void 0!==e)for(d=0;d<e.length;d++)k=e[d],q=p=void 0,g={rel:"modulepreload",fetchPriority:"low",nonce:b},"string"===typeof k?g.href=m=k:(g.href=m=k.src,g.integrity=q="string"===typeof k.integrity?k.integrity:void 0,g.crossOrigin=
-p="string"===typeof k||null==k.crossOrigin?void 0:"use-credentials"===k.crossOrigin?"use-credentials":""),k=a,c=m,k.scriptResources[c]=null,k.moduleScriptResources[c]=null,k=[],M(k,g),h.bootstrapScripts.add(k),t.push(rb,x(G(m))),b&&t.push(sb,x(G(b))),"string"===typeof q&&t.push(tb,x(G(q))),"string"===typeof p&&t.push(ub,x(G(p))),t.push(vb);return h}
-function Kb(a,b){var c=0;void 0!==b&&(c=1);return{idPrefix:void 0===a?"":a,nextFormID:0,streamingFormat:c,instructions:0,hasBody:!1,hasHtml:!1,unknownResources:{},dnsResources:{},connectResources:{default:{},anonymous:{},credentials:{}},imageResources:{},styleResources:{},scriptResources:{},moduleUnknownResources:{},moduleScriptResources:{}}}function N(a,b,c){return{insertionMode:a,selectedValue:b,tagScope:c}}
+function Ab(a,b,c,d,e,f){var g=void 0===b?bb:z('<script nonce="'+G(b)+'">'),h=a.idPrefix,k=[],m=null,p=a.bootstrapScriptContent,t=a.bootstrapScripts,r=a.bootstrapModules;void 0!==p&&k.push(g,x((""+p).replace(wb,xb)),cb);void 0!==c&&("string"===typeof c?(m={src:c,chunks:[]},Jb(m.chunks,{src:c,async:!0,integrity:void 0,nonce:b})):(m={src:c.src,chunks:[]},Jb(m.chunks,{src:c.src,async:!0,integrity:c.integrity,nonce:b})));c=[];void 0!==d&&(c.push(yb),c.push(x((""+JSON.stringify(d)).replace(wb,xb))),c.push(zb));
+d=e?{preconnects:"",fontPreloads:"",highImagePreloads:"",remainingCapacity:"number"===typeof f?f:2E3}:null;e={placeholderPrefix:z(h+"P:"),segmentPrefix:z(h+"S:"),boundaryPrefix:z(h+"B:"),startInlineScript:g,htmlChunks:null,headChunks:null,externalRuntimeScript:m,bootstrapChunks:k,onHeaders:e,headers:d,resets:{font:{},dns:{},connect:{default:{},anonymous:{},credentials:{}},image:{},style:{}},charsetChunks:[],preconnectChunks:[],importMapChunks:c,preloadChunks:[],hoistableChunks:[],preconnects:new Set,
+fontPreloads:new Set,highImagePreloads:new Set,styles:new Map,bootstrapScripts:new Set,scripts:new Set,bulkPreloads:new Set,preloads:{images:new Map,stylesheets:new Map,scripts:new Map,moduleScripts:new Map},nonce:b,boundaryResources:null,stylesToHoist:!1};if(void 0!==t)for(g=0;g<t.length;g++)c=t[g],d=m=void 0,f={rel:"preload",as:"script",fetchPriority:"low",nonce:b},"string"===typeof c?f.href=h=c:(f.href=h=c.src,f.integrity=d="string"===typeof c.integrity?c.integrity:void 0,f.crossOrigin=m="string"===
+typeof c||null==c.crossOrigin?void 0:"use-credentials"===c.crossOrigin?"use-credentials":""),c=a,p=h,c.scriptResources[p]=null,c.moduleScriptResources[p]=null,c=[],M(c,f),e.bootstrapScripts.add(c),k.push(qb,x(G(h))),b&&k.push(sb,x(G(b))),"string"===typeof d&&k.push(tb,x(G(d))),"string"===typeof m&&k.push(ub,x(G(m))),k.push(vb);if(void 0!==r)for(t=0;t<r.length;t++)f=r[t],m=h=void 0,d={rel:"modulepreload",fetchPriority:"low",nonce:b},"string"===typeof f?d.href=g=f:(d.href=g=f.src,d.integrity=m="string"===
+typeof f.integrity?f.integrity:void 0,d.crossOrigin=h="string"===typeof f||null==f.crossOrigin?void 0:"use-credentials"===f.crossOrigin?"use-credentials":""),f=a,c=g,f.scriptResources[c]=null,f.moduleScriptResources[c]=null,f=[],M(f,d),e.bootstrapScripts.add(f),k.push(rb,x(G(g))),b&&k.push(sb,x(G(b))),"string"===typeof m&&k.push(tb,x(G(m))),"string"===typeof h&&k.push(ub,x(G(h))),k.push(vb);return e}
+function Kb(a,b,c,d,e){var f=0;void 0!==b&&(f=1);return{idPrefix:void 0===a?"":a,nextFormID:0,streamingFormat:f,bootstrapScriptContent:c,bootstrapScripts:d,bootstrapModules:e,instructions:0,hasBody:!1,hasHtml:!1,unknownResources:{},dnsResources:{},connectResources:{default:{},anonymous:{},credentials:{}},imageResources:{},styleResources:{},scriptResources:{},moduleUnknownResources:{},moduleScriptResources:{}}}function N(a,b,c){return{insertionMode:a,selectedValue:b,tagScope:c}}
 function Lb(a){return N("http://www.w3.org/2000/svg"===a?3:"http://www.w3.org/1998/Math/MathML"===a?4:0,null,0)}
 function Mb(a,b,c){switch(b){case "noscript":return N(2,null,a.tagScope|1);case "select":return N(2,null!=c.value?c.value:c.defaultValue,a.tagScope);case "svg":return N(3,null,a.tagScope);case "picture":return N(2,null,a.tagScope|2);case "math":return N(4,null,a.tagScope);case "foreignObject":return N(2,null,a.tagScope);case "table":return N(5,null,a.tagScope);case "thead":case "tbody":case "tfoot":return N(6,null,a.tagScope);case "colgroup":return N(8,null,a.tagScope);case "tr":return N(7,null,a.tagScope)}return 5<=
 a.insertionMode?N(2,null,a.tagScope):0===a.insertionMode?"html"===b?N(1,null,a.tagScope):N(2,null,a.tagScope):1===a.insertionMode?N(2,null,a.tagScope):a}var Nb=z("\x3c!-- --\x3e");function Ob(a,b,c,d){if(""===b)return d;d&&a.push(Nb);a.push(x(G(b)));return!0}var Pb=new Map,Qb=z(' style="'),Rb=z(":"),Sb=z(";");
@@ -75,8 +73,8 @@ function kc(a,b,c){a.push(V(c));for(var d in b)if(D.call(b,d)){var e=b[d];if(nul
 function lc(a,b){a.push(V("title"));var c=null,d=null,e;for(e in b)if(D.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:T(a,e,f)}}a.push(U);b=Array.isArray(c)?2>c.length?c[0]:null:c;"function"!==typeof b&&"symbol"!==typeof b&&null!==b&&void 0!==b&&a.push(x(G(""+b)));cc(a,d,c);a.push(mc("title"));return null}
 function Jb(a,b){a.push(V("script"));var c=null,d=null,e;for(e in b)if(D.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:T(a,e,f)}}a.push(U);cc(a,d,c);"string"===typeof c&&a.push(x(G(c)));a.push(mc("script"));return null}
 function nc(a,b,c){a.push(V(c));var d=c=null,e;for(e in b)if(D.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:T(a,e,f)}}a.push(U);cc(a,d,c);return"string"===typeof c?(a.push(x(G(c))),null):c}var oc=z("\n"),pc=/^[a-zA-Z][a-zA-Z:_\.\-\d]*$/,qc=new Map;function V(a){var b=qc.get(a);if(void 0===b){if(!pc.test(a))throw Error("Invalid tag: "+a);b=z("<"+a);qc.set(a,b)}return b}var Ac=z("<!DOCTYPE html>");
-function Bc(a,b,c,d,e,f,g){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "select":a.push(V("select"));var h=null,k=null,m;for(m in c)if(D.call(c,m)){var p=c[m];if(null!=p)switch(m){case "children":h=p;break;case "dangerouslySetInnerHTML":k=p;break;case "defaultValue":case "value":break;default:T(a,m,p)}}a.push(U);cc(a,k,h);return h;case "option":var t=f.selectedValue;a.push(V("option"));var q=null,y=null,C=null,Y=null,u;for(u in c)if(D.call(c,
-u)){var B=c[u];if(null!=B)switch(u){case "children":q=B;break;case "selected":C=B;break;case "dangerouslySetInnerHTML":Y=B;break;case "value":y=B;default:T(a,u,B)}}if(null!=t){var E=null!==y?""+y:dc(q);if(Ia(t))for(var ka=0;ka<t.length;ka++){if(""+t[ka]===E){a.push(ec);break}}else""+t===E&&a.push(ec)}else C&&a.push(ec);a.push(U);cc(a,Y,q);return q;case "textarea":a.push(V("textarea"));var w=null,R=null,F=null,J;for(J in c)if(D.call(c,J)){var K=c[J];if(null!=K)switch(J){case "children":F=K;break;case "value":w=
+function Bc(a,b,c,d,e,f,g){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "select":a.push(V("select"));var h=null,k=null,m;for(m in c)if(D.call(c,m)){var p=c[m];if(null!=p)switch(m){case "children":h=p;break;case "dangerouslySetInnerHTML":k=p;break;case "defaultValue":case "value":break;default:T(a,m,p)}}a.push(U);cc(a,k,h);return h;case "option":var t=f.selectedValue;a.push(V("option"));var r=null,y=null,C=null,Y=null,u;for(u in c)if(D.call(c,
+u)){var B=c[u];if(null!=B)switch(u){case "children":r=B;break;case "selected":C=B;break;case "dangerouslySetInnerHTML":Y=B;break;case "value":y=B;default:T(a,u,B)}}if(null!=t){var E=null!==y?""+y:dc(r);if(Ia(t))for(var ka=0;ka<t.length;ka++){if(""+t[ka]===E){a.push(ec);break}}else""+t===E&&a.push(ec)}else C&&a.push(ec);a.push(U);cc(a,Y,r);return r;case "textarea":a.push(V("textarea"));var w=null,R=null,F=null,J;for(J in c)if(D.call(c,J)){var K=c[J];if(null!=K)switch(J){case "children":F=K;break;case "value":w=
 K;break;case "defaultValue":R=K;break;case "dangerouslySetInnerHTML":throw Error("`dangerouslySetInnerHTML` does not make sense on <textarea>.");default:T(a,J,K)}}null===w&&null!==R&&(w=R);a.push(U);if(null!=F){if(null!=w)throw Error("If you supply `defaultValue` on a <textarea>, do not pass children.");if(Ia(F)){if(1<F.length)throw Error("<textarea> can only have at most one child.");w=""+F[0]}w=""+F}"string"===typeof w&&"\n"===w[0]&&a.push(oc);null!==w&&a.push(x(G(""+w)));return null;case "input":a.push(V("input"));
 var Oa=null,za=null,qa=null,la=null,Aa=null,ra=null,sa=null,ta=null,Pa=null,ea;for(ea in c)if(D.call(c,ea)){var Z=c[ea];if(null!=Z)switch(ea){case "children":case "dangerouslySetInnerHTML":throw Error("input is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");case "name":Oa=Z;break;case "formAction":za=Z;break;case "formEncType":qa=Z;break;case "formMethod":la=Z;break;case "formTarget":Aa=Z;break;case "defaultChecked":Pa=Z;break;case "defaultValue":sa=Z;break;
 case "checked":ta=Z;break;case "value":ra=Z;break;default:T(a,ea,Z)}}var Fd=ac(a,d,e,za,qa,la,Aa,Oa);null!==ta?Vb(a,"checked",ta):null!==Pa&&Vb(a,"checked",Pa);null!==ra?T(a,"value",ra):null!==sa&&T(a,"value",sa);a.push($b);null!==Fd&&Fd.forEach(Zb,a);return null;case "button":a.push(V("button"));var db=null,Gd=null,Hd=null,Id=null,Jd=null,Kd=null,Ld=null,eb;for(eb in c)if(D.call(c,eb)){var ma=c[eb];if(null!=ma)switch(eb){case "children":db=ma;break;case "dangerouslySetInnerHTML":Gd=ma;break;case "name":Hd=
@@ -94,27 +92,27 @@ e.highImagePreloads.add(Ea)}else if(!d.imageResources.hasOwnProperty(Ta)){d.imag
 yc.length))?(e.resets.image[Ta]=I,fa.highImagePreloads&&(fa.highImagePreloads+=", "),fa.highImagePreloads+=yc):(Ea=[],M(Ea,{rel:"preload",as:"image",href:H?void 0:L,imageSrcSet:H,imageSizes:ae,crossOrigin:be,integrity:c.integrity,type:c.type,fetchPriority:c.fetchPriority,referrerPolicy:c.referrerPolicy}),"high"===c.fetchPriority||10>e.highImagePreloads.size?e.highImagePreloads.add(Ea):(e.bulkPreloads.add(Ea),wc.set(Ta,Ea)))}}return kc(a,c,"img");case "base":case "area":case "br":case "col":case "embed":case "hr":case "keygen":case "param":case "source":case "track":case "wbr":return kc(a,
 c,b);case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph":break;case "head":if(2>f.insertionMode&&null===e.headChunks){e.headChunks=[];var ce=nc(e.headChunks,c,"head")}else ce=nc(a,c,"head");return ce;case "html":if(0===f.insertionMode&&null===e.htmlChunks){e.htmlChunks=[Ac];var de=nc(e.htmlChunks,c,"html")}else de=nc(a,c,"html");return de;default:if(-1!==b.indexOf("-")){a.push(V(b));
 var zc=null,ee=null,Ua;for(Ua in c)if(D.call(c,Ua)){var aa=c[Ua];if(null!=aa){var fe=Ua;switch(Ua){case "children":zc=aa;break;case "dangerouslySetInnerHTML":ee=aa;break;case "style":Tb(a,aa);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":break;case "className":fe="class";default:if(wa(Ua)&&"function"!==typeof aa&&"symbol"!==typeof aa&&!1!==aa){if(!0===aa)aa="";else if("object"===typeof aa)continue;a.push(P,x(fe),Q,x(G(aa)),O)}}}}a.push(U);cc(a,ee,zc);return zc}}return nc(a,
-c,b)}var Dc=new Map;function mc(a){var b=Dc.get(a);void 0===b&&(b=z("</"+a+">"),Dc.set(a,b));return b}function Ec(a,b){b=b.bootstrapChunks;for(var c=0;c<b.length-1;c++)r(a,b[c]);return c<b.length?(c=b[c],b.length=0,v(a,c)):!0}var Fc=z('<template id="'),Gc=z('"></template>'),Hc=z("\x3c!--$--\x3e"),Ic=z('\x3c!--$?--\x3e<template id="'),Jc=z('"></template>'),Kc=z("\x3c!--$!--\x3e"),Lc=z("\x3c!--/$--\x3e"),Mc=z("<template"),Nc=z('"'),Oc=z(' data-dgst="');z(' data-msg="');z(' data-stck="');var Pc=z("></template>");
-function Qc(a,b,c){r(a,Ic);if(null===c)throw Error("An ID must have been assigned before we can complete the boundary.");r(a,b.boundaryPrefix);r(a,x(c.toString(16)));return v(a,Jc)}
+c,b)}var Dc=new Map;function mc(a){var b=Dc.get(a);void 0===b&&(b=z("</"+a+">"),Dc.set(a,b));return b}function Ec(a,b,c){c.bootstrapScriptContent=void 0;c.bootstrapScripts=void 0;c.bootstrapModules=void 0;b=b.bootstrapChunks;for(c=0;c<b.length-1;c++)q(a,b[c]);return c<b.length?(c=b[c],b.length=0,v(a,c)):!0}
+var Fc=z('<template id="'),Gc=z('"></template>'),Hc=z("\x3c!--$--\x3e"),Ic=z('\x3c!--$?--\x3e<template id="'),Jc=z('"></template>'),Kc=z("\x3c!--$!--\x3e"),Lc=z("\x3c!--/$--\x3e"),Mc=z("<template"),Nc=z('"'),Oc=z(' data-dgst="');z(' data-msg="');z(' data-stck="');var Pc=z("></template>");function Qc(a,b,c){q(a,Ic);if(null===c)throw Error("An ID must have been assigned before we can complete the boundary.");q(a,b.boundaryPrefix);q(a,x(c.toString(16)));return v(a,Jc)}
 var Rc=z('<div hidden id="'),Sc=z('">'),Tc=z("</div>"),Uc=z('<svg aria-hidden="true" style="display:none" id="'),Vc=z('">'),Wc=z("</svg>"),Xc=z('<math aria-hidden="true" style="display:none" id="'),Yc=z('">'),Zc=z("</math>"),$c=z('<table hidden id="'),ad=z('">'),bd=z("</table>"),cd=z('<table hidden><tbody id="'),dd=z('">'),ed=z("</tbody></table>"),fd=z('<table hidden><tr id="'),gd=z('">'),hd=z("</tr></table>"),id=z('<table hidden><colgroup id="'),jd=z('">'),kd=z("</colgroup></table>");
-function ld(a,b,c,d){switch(c.insertionMode){case 0:case 1:case 2:return r(a,Rc),r(a,b.segmentPrefix),r(a,x(d.toString(16))),v(a,Sc);case 3:return r(a,Uc),r(a,b.segmentPrefix),r(a,x(d.toString(16))),v(a,Vc);case 4:return r(a,Xc),r(a,b.segmentPrefix),r(a,x(d.toString(16))),v(a,Yc);case 5:return r(a,$c),r(a,b.segmentPrefix),r(a,x(d.toString(16))),v(a,ad);case 6:return r(a,cd),r(a,b.segmentPrefix),r(a,x(d.toString(16))),v(a,dd);case 7:return r(a,fd),r(a,b.segmentPrefix),r(a,x(d.toString(16))),v(a,gd);
-case 8:return r(a,id),r(a,b.segmentPrefix),r(a,x(d.toString(16))),v(a,jd);default:throw Error("Unknown insertion mode. This is a bug in React.");}}function md(a,b){switch(b.insertionMode){case 0:case 1:case 2:return v(a,Tc);case 3:return v(a,Wc);case 4:return v(a,Zc);case 5:return v(a,bd);case 6:return v(a,ed);case 7:return v(a,hd);case 8:return v(a,kd);default:throw Error("Unknown insertion mode. This is a bug in React.");}}
+function ld(a,b,c,d){switch(c.insertionMode){case 0:case 1:case 2:return q(a,Rc),q(a,b.segmentPrefix),q(a,x(d.toString(16))),v(a,Sc);case 3:return q(a,Uc),q(a,b.segmentPrefix),q(a,x(d.toString(16))),v(a,Vc);case 4:return q(a,Xc),q(a,b.segmentPrefix),q(a,x(d.toString(16))),v(a,Yc);case 5:return q(a,$c),q(a,b.segmentPrefix),q(a,x(d.toString(16))),v(a,ad);case 6:return q(a,cd),q(a,b.segmentPrefix),q(a,x(d.toString(16))),v(a,dd);case 7:return q(a,fd),q(a,b.segmentPrefix),q(a,x(d.toString(16))),v(a,gd);
+case 8:return q(a,id),q(a,b.segmentPrefix),q(a,x(d.toString(16))),v(a,jd);default:throw Error("Unknown insertion mode. This is a bug in React.");}}function md(a,b){switch(b.insertionMode){case 0:case 1:case 2:return v(a,Tc);case 3:return v(a,Wc);case 4:return v(a,Zc);case 5:return v(a,bd);case 6:return v(a,ed);case 7:return v(a,hd);case 8:return v(a,kd);default:throw Error("Unknown insertion mode. This is a bug in React.");}}
 var nd=z('$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};$RS("'),od=z('$RS("'),pd=z('","'),qd=z('")\x3c/script>'),rd=z('<template data-rsi="" data-sid="'),sd=z('" data-pid="'),td=z('$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};$RC("'),
 ud=z('$RC("'),vd=z('$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};$RR("'),
 wd=z('$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};$RR("'),
 xd=z('$RR("'),yd=z('","'),zd=z('",'),Ad=z('"'),Bd=z(")\x3c/script>"),Cd=z('<template data-rci="" data-bid="'),Dd=z('<template data-rri="" data-bid="'),Ed=z('" data-sid="'),ge=z('" data-sty="'),he=z('$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};;$RX("'),ie=z('$RX("'),je=z('"'),ke=z(","),le=z(")\x3c/script>"),me=z('<template data-rxi="" data-bid="'),ne=z('" data-dgst="'),
 oe=z('" data-msg="'),pe=z('" data-stck="'),qe=/[<\u2028\u2029]/g;function re(a){return JSON.stringify(a).replace(qe,function(b){switch(b){case "<":return"\\u003c";case "\u2028":return"\\u2028";case "\u2029":return"\\u2029";default:throw Error("escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}})}var se=/[&><\u2028\u2029]/g;
 function te(a){return JSON.stringify(a).replace(se,function(b){switch(b){case "&":return"\\u0026";case ">":return"\\u003e";case "<":return"\\u003c";case "\u2028":return"\\u2028";case "\u2029":return"\\u2029";default:throw Error("escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}})}
-var ue=z('<style media="not all" data-precedence="'),ve=z('" data-href="'),we=z('">'),xe=z("</style>"),ye=!1,ze=!0;function Ae(a){var b=a.rules,c=a.hrefs,d=0;if(c.length){r(this,ue);r(this,a.precedence);for(r(this,ve);d<c.length-1;d++)r(this,c[d]),r(this,Be);r(this,c[d]);r(this,we);for(d=0;d<b.length;d++)r(this,b[d]);ze=v(this,xe);ye=!0;b.length=0;c.length=0}}function Ce(a){return 2!==a.state?ye=!0:!1}
-function De(a,b,c){ye=!1;ze=!0;b.styles.forEach(Ae,a);b.stylesheets.forEach(Ce);ye&&(c.stylesToHoist=!0);return ze}function Ee(a){for(var b=0;b<a.length;b++)r(this,a[b]);a.length=0}var Fe=[];function Ge(a){M(Fe,a.props);for(var b=0;b<Fe.length;b++)r(this,Fe[b]);Fe.length=0;a.state=2}var He=z('<style data-precedence="'),Ie=z('" data-href="'),Be=z(" "),Je=z('">'),Ke=z("</style>");
-function Le(a){var b=0<a.sheets.size;a.sheets.forEach(Ge,this);a.sheets.clear();var c=a.rules,d=a.hrefs;if(!b||d.length){r(this,He);r(this,a.precedence);a=0;if(d.length){for(r(this,Ie);a<d.length-1;a++)r(this,d[a]),r(this,Be);r(this,d[a])}r(this,Je);for(a=0;a<c.length;a++)r(this,c[a]);r(this,Ke);c.length=0;d.length=0}}
-function Me(a){if(0===a.state){a.state=1;var b=a.props;M(Fe,{rel:"preload",as:"style",href:a.props.href,crossOrigin:b.crossOrigin,fetchPriority:b.fetchPriority,integrity:b.integrity,media:b.media,hrefLang:b.hrefLang,referrerPolicy:b.referrerPolicy});for(a=0;a<Fe.length;a++)r(this,Fe[a]);Fe.length=0}}function Ne(a){a.sheets.forEach(Me,this);a.sheets.clear()}var Oe=z("["),Pe=z(",["),Qe=z(","),Re=z("]");
-function Se(a,b){r(a,Oe);var c=Oe;b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)r(a,c),r(a,x(te(""+d.props.href))),r(a,Re),c=Pe;else{r(a,c);var e=d.props["data-precedence"],f=d.props;r(a,x(te(""+d.props.href)));e=""+e;r(a,Qe);r(a,x(te(e)));for(var g in f)if(D.call(f,g)){var h=f[g];if(null!=h)switch(g){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");
-default:a:{e=a;var k=g.toLowerCase();switch(typeof h){case "function":case "symbol":break a}switch(g){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":k="class";h=""+h;break;case "hidden":if(!1===h)break a;h="";break;case "src":case "href":h=""+h;break;default:if(2<g.length&&("o"===g[0]||"O"===g[0])&&("n"===g[1]||"N"===g[1])||!wa(g))break a;h=""+h}r(e,Qe);r(e,x(te(k)));r(e,Qe);r(e,x(te(h)))}}}r(a,
-Re);c=Pe;d.state=3}});r(a,Re)}
-function Te(a,b){r(a,Oe);var c=Oe;b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)r(a,c),r(a,x(G(JSON.stringify(""+d.props.href)))),r(a,Re),c=Pe;else{r(a,c);var e=d.props["data-precedence"],f=d.props;r(a,x(G(JSON.stringify(""+d.props.href))));e=""+e;r(a,Qe);r(a,x(G(JSON.stringify(e))));for(var g in f)if(D.call(f,g)){var h=f[g];if(null!=h)switch(g){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");default:a:{e=
-a;var k=g.toLowerCase();switch(typeof h){case "function":case "symbol":break a}switch(g){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":k="class";h=""+h;break;case "hidden":if(!1===h)break a;h="";break;case "src":case "href":h=""+h;break;default:if(2<g.length&&("o"===g[0]||"O"===g[0])&&("n"===g[1]||"N"===g[1])||!wa(g))break a;h=""+h}r(e,Qe);r(e,x(G(JSON.stringify(k))));r(e,Qe);r(e,x(G(JSON.stringify(h))))}}}r(a,
-Re);c=Pe;d.state=3}});r(a,Re)}function Ma(a){var b=Ue();if(b){var c=b.resumableState,d=b.renderState;if("string"===typeof a&&a){if(!c.dnsResources.hasOwnProperty(a)){c.dnsResources[a]=null;c=d.headers;var e,f;if(f=c&&0<c.remainingCapacity)f=(e="<"+(""+a).replace(Ve,We)+">; rel=dns-prefetch",2<=(c.remainingCapacity-=e.length));f?(d.resets.dns[a]=null,c.preconnects&&(c.preconnects+=", "),c.preconnects+=e):(e=[],M(e,{href:a,rel:"dns-prefetch"}),d.preconnects.add(e))}Xe(b)}}}
+var ue=z('<style media="not all" data-precedence="'),ve=z('" data-href="'),we=z('">'),xe=z("</style>"),ye=!1,ze=!0;function Ae(a){var b=a.rules,c=a.hrefs,d=0;if(c.length){q(this,ue);q(this,a.precedence);for(q(this,ve);d<c.length-1;d++)q(this,c[d]),q(this,Be);q(this,c[d]);q(this,we);for(d=0;d<b.length;d++)q(this,b[d]);ze=v(this,xe);ye=!0;b.length=0;c.length=0}}function Ce(a){return 2!==a.state?ye=!0:!1}
+function De(a,b,c){ye=!1;ze=!0;b.styles.forEach(Ae,a);b.stylesheets.forEach(Ce);ye&&(c.stylesToHoist=!0);return ze}function Ee(a){for(var b=0;b<a.length;b++)q(this,a[b]);a.length=0}var Fe=[];function Ge(a){M(Fe,a.props);for(var b=0;b<Fe.length;b++)q(this,Fe[b]);Fe.length=0;a.state=2}var He=z('<style data-precedence="'),Ie=z('" data-href="'),Be=z(" "),Je=z('">'),Ke=z("</style>");
+function Le(a){var b=0<a.sheets.size;a.sheets.forEach(Ge,this);a.sheets.clear();var c=a.rules,d=a.hrefs;if(!b||d.length){q(this,He);q(this,a.precedence);a=0;if(d.length){for(q(this,Ie);a<d.length-1;a++)q(this,d[a]),q(this,Be);q(this,d[a])}q(this,Je);for(a=0;a<c.length;a++)q(this,c[a]);q(this,Ke);c.length=0;d.length=0}}
+function Me(a){if(0===a.state){a.state=1;var b=a.props;M(Fe,{rel:"preload",as:"style",href:a.props.href,crossOrigin:b.crossOrigin,fetchPriority:b.fetchPriority,integrity:b.integrity,media:b.media,hrefLang:b.hrefLang,referrerPolicy:b.referrerPolicy});for(a=0;a<Fe.length;a++)q(this,Fe[a]);Fe.length=0}}function Ne(a){a.sheets.forEach(Me,this);a.sheets.clear()}var Oe=z("["),Pe=z(",["),Qe=z(","),Re=z("]");
+function Se(a,b){q(a,Oe);var c=Oe;b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)q(a,c),q(a,x(te(""+d.props.href))),q(a,Re),c=Pe;else{q(a,c);var e=d.props["data-precedence"],f=d.props;q(a,x(te(""+d.props.href)));e=""+e;q(a,Qe);q(a,x(te(e)));for(var g in f)if(D.call(f,g)){var h=f[g];if(null!=h)switch(g){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");
+default:a:{e=a;var k=g.toLowerCase();switch(typeof h){case "function":case "symbol":break a}switch(g){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":k="class";h=""+h;break;case "hidden":if(!1===h)break a;h="";break;case "src":case "href":h=""+h;break;default:if(2<g.length&&("o"===g[0]||"O"===g[0])&&("n"===g[1]||"N"===g[1])||!wa(g))break a;h=""+h}q(e,Qe);q(e,x(te(k)));q(e,Qe);q(e,x(te(h)))}}}q(a,
+Re);c=Pe;d.state=3}});q(a,Re)}
+function Te(a,b){q(a,Oe);var c=Oe;b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)q(a,c),q(a,x(G(JSON.stringify(""+d.props.href)))),q(a,Re),c=Pe;else{q(a,c);var e=d.props["data-precedence"],f=d.props;q(a,x(G(JSON.stringify(""+d.props.href))));e=""+e;q(a,Qe);q(a,x(G(JSON.stringify(e))));for(var g in f)if(D.call(f,g)){var h=f[g];if(null!=h)switch(g){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");default:a:{e=
+a;var k=g.toLowerCase();switch(typeof h){case "function":case "symbol":break a}switch(g){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":k="class";h=""+h;break;case "hidden":if(!1===h)break a;h="";break;case "src":case "href":h=""+h;break;default:if(2<g.length&&("o"===g[0]||"O"===g[0])&&("n"===g[1]||"N"===g[1])||!wa(g))break a;h=""+h}q(e,Qe);q(e,x(G(JSON.stringify(k))));q(e,Qe);q(e,x(G(JSON.stringify(h))))}}}q(a,
+Re);c=Pe;d.state=3}});q(a,Re)}function Ma(a){var b=Ue();if(b){var c=b.resumableState,d=b.renderState;if("string"===typeof a&&a){if(!c.dnsResources.hasOwnProperty(a)){c.dnsResources[a]=null;c=d.headers;var e,f;if(f=c&&0<c.remainingCapacity)f=(e="<"+(""+a).replace(Ve,We)+">; rel=dns-prefetch",2<=(c.remainingCapacity-=e.length));f?(d.resets.dns[a]=null,c.preconnects&&(c.preconnects+=", "),c.preconnects+=e):(e=[],M(e,{href:a,rel:"dns-prefetch"}),d.preconnects.add(e))}Xe(b)}}}
 function Na(a,b){var c=Ue();if(c){var d=c.resumableState,e=c.renderState;if("string"===typeof a&&a){var f="use-credentials"===b?"credentials":"string"===typeof b?"anonymous":"default";if(!d.connectResources[f].hasOwnProperty(a)){d.connectResources[f][a]=null;d=e.headers;var g,h;if(h=d&&0<d.remainingCapacity){h="<"+(""+a).replace(Ve,We)+">; rel=preconnect";if("string"===typeof b){var k=(""+b).replace(Ye,Ze);h+='; crossorigin="'+k+'"'}h=(g=h,2<=(d.remainingCapacity-=g.length))}h?(e.resets.connect[f][a]=
 null,d.preconnects&&(d.preconnects+=", "),d.preconnects+=g):(f=[],M(f,{rel:"preconnect",href:a,crossOrigin:b}),e.preconnects.add(f))}Xe(c)}}}
 function Va(a,b,c){var d=Ue();if(d){var e=d.resumableState,f=d.renderState;if(b&&a){switch(b){case "image":if(c){var g=c.imageSrcSet;var h=c.imageSizes;var k=c.fetchPriority}var m=g?g+"\n"+(h||""):a;if(e.imageResources.hasOwnProperty(m))return;e.imageResources[m]=I;e=f.headers;var p;e&&0<e.remainingCapacity&&"high"===k&&(p=Cc(a,b,c),2<=(e.remainingCapacity-=p.length))?(f.resets.image[m]=I,e.highImagePreloads&&(e.highImagePreloads+=", "),e.highImagePreloads+=p):(e=[],M(e,A({rel:"preload",href:g?void 0:
@@ -153,31 +151,31 @@ function Ag(){throw Error("Cannot update optimistic state while rendering.");}fu
 var Fg={readContext:function(a){return a._currentValue},use:function(a){if(null!==a&&"object"===typeof a){if("function"===typeof a.then)return Bg(a);if(a.$$typeof===lf||a.$$typeof===mf)return a._currentValue}throw Error("An unsupported type was passed to use(): "+String(a));},useContext:function(a){og();return a._currentValue},useMemo:xg,useReducer:vg,useRef:function(a){ag=og();W=qg();var b=W.memoizedState;return null===b?(a={current:a},W.memoizedState=a):b},useState:function(a){return vg(ug,a)},
 useInsertionEffect:Dg,useLayoutEffect:Dg,useCallback:function(a,b){return xg(function(){return a},b)},useImperativeHandle:Dg,useEffect:Dg,useDebugValue:Dg,useDeferredValue:function(a,b){og();return void 0!==b?b:a},useTransition:function(){og();return[!1,zg]},useId:function(){var a=bg.treeContext;var b=a.overflow;a=a.id;a=(a&~(1<<32-Qf(a)-1)).toString(32)+b;var c=Eg;if(null===c)throw Error("Invalid hook call. Hooks can only be called inside of the body of a function component.");b=hg++;a=":"+c.idPrefix+
 "R"+a;0<b&&(a+="H"+b.toString(32));return a+":"},useSyncExternalStore:function(a,b,c){if(void 0===c)throw Error("Missing getServerSnapshot, which is required for server-rendered content. Will revert to client rendering.");return c()},useCacheRefresh:function(){return Cg},useEffectEvent:function(){return yg},useMemoCache:function(a){for(var b=Array(a),c=0;c<a;c++)b[c]=yf;return b},useHostTransitionStatus:function(){og();return Ka},useOptimistic:function(a){og();return[a,Ag]},useFormState:function(a,
-b,c){og();var d=ig++,e=cg;if("function"===typeof a.$$FORM_ACTION){var f=null,g=dg;e=e.formState;var h=a.$$IS_SIGNATURE_EQUAL;if(null!==e&&"function"===typeof h){var k=e[1];h.call(a,e[2],e[3])&&(f=void 0!==c?"p"+c:"k"+da(JSON.stringify([g,null,d]),0),k===f&&(jg=d,b=e[0]))}var m=a.bind(null,b);a=function(t){m(t)};"function"===typeof m.$$FORM_ACTION&&(a.$$FORM_ACTION=function(t){t=m.$$FORM_ACTION(t);void 0!==c&&(c+="",t.action=c);var q=t.data;q&&(null===f&&(f=void 0!==c?"p"+c:"k"+da(JSON.stringify([g,
-null,d]),0)),q.append("$ACTION_KEY",f));return t});return[b,a]}var p=a.bind(null,b);return[b,function(t){p(t)}]}},Eg=null,Gg={getCacheSignal:function(){throw Error("Not implemented.");},getCacheForType:function(){throw Error("Not implemented.");}},Hg=Ja.ReactCurrentDispatcher,Ig=Ja.ReactCurrentCache;function Jg(a){console.error(a);return null}function Kg(){}
-function Lg(a,b,c,d,e,f,g,h,k,m,p,t){La.current=$a;var q=[],y=new Set;b={destination:null,flushScheduled:!1,resumableState:b,renderState:c,rootFormatContext:d,progressiveChunkSize:void 0===e?12800:e,status:0,fatalError:null,nextSegmentId:0,allPendingTasks:0,pendingRootTasks:0,completedRootSegment:null,abortableTasks:y,pingedTasks:q,clientRenderedBoundaries:[],completedBoundaries:[],partialBoundaries:[],trackedPostpones:null,onError:void 0===f?Jg:f,onPostpone:void 0===p?Kg:p,onAllReady:void 0===g?
-Kg:g,onShellReady:void 0===h?Kg:h,onShellError:void 0===k?Kg:k,onFatalError:void 0===m?Kg:m,formState:void 0===t?null:t};c=Mg(b,0,null,d,!1,!1);c.parentFlushed=!0;a=Ng(b,null,a,-1,null,c,y,null,d,Df,null,Of);q.push(a);return b}function Og(a,b,c,d,e,f,g,h,k,m,p){a=Lg(a,b,c,d,e,f,g,h,k,m,p,void 0);a.trackedPostpones={workingMap:new Map,rootNodes:[],rootSlots:null};return a}
+b,c){og();var d=ig++,e=cg;if("function"===typeof a.$$FORM_ACTION){var f=null,g=dg;e=e.formState;var h=a.$$IS_SIGNATURE_EQUAL;if(null!==e&&"function"===typeof h){var k=e[1];h.call(a,e[2],e[3])&&(f=void 0!==c?"p"+c:"k"+da(JSON.stringify([g,null,d]),0),k===f&&(jg=d,b=e[0]))}var m=a.bind(null,b);a=function(t){m(t)};"function"===typeof m.$$FORM_ACTION&&(a.$$FORM_ACTION=function(t){t=m.$$FORM_ACTION(t);void 0!==c&&(c+="",t.action=c);var r=t.data;r&&(null===f&&(f=void 0!==c?"p"+c:"k"+da(JSON.stringify([g,
+null,d]),0)),r.append("$ACTION_KEY",f));return t});return[b,a]}var p=a.bind(null,b);return[b,function(t){p(t)}]}},Eg=null,Gg={getCacheSignal:function(){throw Error("Not implemented.");},getCacheForType:function(){throw Error("Not implemented.");}},Hg=Ja.ReactCurrentDispatcher,Ig=Ja.ReactCurrentCache;function Jg(a){console.error(a);return null}function Kg(){}
+function Lg(a,b,c,d,e,f,g,h,k,m,p,t){La.current=$a;var r=[],y=new Set;b={destination:null,flushScheduled:!1,resumableState:b,renderState:c,rootFormatContext:d,progressiveChunkSize:void 0===e?12800:e,status:0,fatalError:null,nextSegmentId:0,allPendingTasks:0,pendingRootTasks:0,completedRootSegment:null,abortableTasks:y,pingedTasks:r,clientRenderedBoundaries:[],completedBoundaries:[],partialBoundaries:[],trackedPostpones:null,onError:void 0===f?Jg:f,onPostpone:void 0===p?Kg:p,onAllReady:void 0===g?
+Kg:g,onShellReady:void 0===h?Kg:h,onShellError:void 0===k?Kg:k,onFatalError:void 0===m?Kg:m,formState:void 0===t?null:t};c=Mg(b,0,null,d,!1,!1);c.parentFlushed=!0;a=Ng(b,null,a,-1,null,c,y,null,d,Df,null,Of);r.push(a);return b}function Og(a,b,c,d,e,f,g,h,k,m,p){a=Lg(a,b,c,d,e,f,g,h,k,m,p,void 0);a.trackedPostpones={workingMap:new Map,rootNodes:[],rootSlots:null};return a}
 function Pg(a,b,c,d,e,f,g,h,k){La.current=$a;var m=[],p=new Set;c={destination:null,flushScheduled:!1,resumableState:b.resumableState,renderState:c,rootFormatContext:b.rootFormatContext,progressiveChunkSize:b.progressiveChunkSize,status:0,fatalError:null,nextSegmentId:b.nextSegmentId,allPendingTasks:0,pendingRootTasks:0,completedRootSegment:null,abortableTasks:p,pingedTasks:m,clientRenderedBoundaries:[],completedBoundaries:[],partialBoundaries:[],trackedPostpones:null,onError:void 0===d?Jg:d,onPostpone:void 0===
 k?Kg:k,onAllReady:void 0===e?Kg:e,onShellReady:void 0===f?Kg:f,onShellError:void 0===g?Kg:g,onFatalError:void 0===h?Kg:h,formState:null};if("number"===typeof b.replaySlots)return d=b.replaySlots,e=Mg(c,0,null,b.rootFormatContext,!1,!1),e.id=d,e.parentFlushed=!0,a=Ng(c,null,a,-1,null,e,p,null,b.rootFormatContext,Df,null,Of),m.push(a),c;a=Qg(c,null,{nodes:b.replayNodes,slots:b.replaySlots,pendingTasks:0},a,-1,null,p,null,b.rootFormatContext,Df,null,Of);m.push(a);return c}var Rg=null;
 function Ue(){if(Rg)return Rg;if(cf){var a=df.getStore();if(a)return a}return null}function Sg(a,b){a.pingedTasks.push(b);1===a.pingedTasks.length&&(a.flushScheduled=null!==a.destination,setTimeout(function(){return Tg(a)},0))}function Ug(a,b){return{status:0,rootSegmentID:-1,parentFlushed:!1,pendingTasks:0,completedSegments:[],byteSize:0,fallbackAbortableTasks:b,errorDigest:null,resources:{styles:new Set,stylesheets:new Set},trackedContentKeyPath:null,trackedFallbackNode:null}}
-function Ng(a,b,c,d,e,f,g,h,k,m,p,t){a.allPendingTasks++;null===e?a.pendingRootTasks++:e.pendingTasks++;var q={replay:null,node:c,childIndex:d,ping:function(){return Sg(a,q)},blockedBoundary:e,blockedSegment:f,abortSet:g,keyPath:h,formatContext:k,legacyContext:m,context:p,treeContext:t,thenableState:b};g.add(q);return q}
-function Qg(a,b,c,d,e,f,g,h,k,m,p,t){a.allPendingTasks++;null===f?a.pendingRootTasks++:f.pendingTasks++;c.pendingTasks++;var q={replay:c,node:d,childIndex:e,ping:function(){return Sg(a,q)},blockedBoundary:f,blockedSegment:null,abortSet:g,keyPath:h,formatContext:k,legacyContext:m,context:p,treeContext:t,thenableState:b};g.add(q);return q}function Mg(a,b,c,d,e,f){return{status:0,id:-1,index:b,parentFlushed:!1,chunks:[],children:[],parentFormatContext:d,boundary:c,lastPushedText:e,textEmbedded:f}}
+function Ng(a,b,c,d,e,f,g,h,k,m,p,t){a.allPendingTasks++;null===e?a.pendingRootTasks++:e.pendingTasks++;var r={replay:null,node:c,childIndex:d,ping:function(){return Sg(a,r)},blockedBoundary:e,blockedSegment:f,abortSet:g,keyPath:h,formatContext:k,legacyContext:m,context:p,treeContext:t,thenableState:b};g.add(r);return r}
+function Qg(a,b,c,d,e,f,g,h,k,m,p,t){a.allPendingTasks++;null===f?a.pendingRootTasks++:f.pendingTasks++;c.pendingTasks++;var r={replay:c,node:d,childIndex:e,ping:function(){return Sg(a,r)},blockedBoundary:f,blockedSegment:null,abortSet:g,keyPath:h,formatContext:k,legacyContext:m,context:p,treeContext:t,thenableState:b};g.add(r);return r}function Mg(a,b,c,d,e,f){return{status:0,id:-1,index:b,parentFlushed:!1,chunks:[],children:[],parentFormatContext:d,boundary:c,lastPushedText:e,textEmbedded:f}}
 function Vg(a,b){a=a.onError(b);if(null!=a&&"string"!==typeof a)throw Error('onError returned something with a type other than "string". onError should return a string and may return null or undefined but must not return anything else. It received something of type "'+typeof a+'" instead');return a}function Wg(a,b){var c=a.onShellError;c(b);c=a.onFatalError;c(b);null!==a.destination?(a.status=2,ja(a.destination,b)):(a.status=1,a.fatalError=b)}
 function Xg(a,b,c,d,e){var f=d.render(),g=e.childContextTypes;if(null!==g&&void 0!==g){c=b.legacyContext;if("function"!==typeof d.getChildContext)e=c;else{d=d.getChildContext();for(var h in d)if(!(h in g))throw Error((Cf(e)||"Unknown")+'.getChildContext(): key "'+h+'" is not defined in childContextTypes.');e=A({},c,d)}b.legacyContext=e;X(a,b,null,f,-1);b.legacyContext=c}else e=b.keyPath,b.keyPath=c,X(a,b,null,f,-1),b.keyPath=e}
 function Yg(a,b,c,d,e,f,g){var h=!1;if(0!==f&&null!==a.formState){var k=b.blockedSegment;if(null!==k){h=!0;k=k.chunks;for(var m=0;m<f;m++)m===g?k.push(gc):k.push(hc)}}f=b.keyPath;b.keyPath=c;e?(c=b.treeContext,b.treeContext=Pf(c,1,0),Zg(a,b,d,-1),b.treeContext=c):h?Zg(a,b,d,-1):X(a,b,null,d,-1);b.keyPath=f}function $g(a,b){if(a&&a.defaultProps){b=A({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}
 function ah(a,b,c,d,e,f,g){if("function"===typeof e)if(e.prototype&&e.prototype.isReactComponent){d=Ef(e,b.legacyContext);var h=e.contextType;h=new e(f,"object"===typeof h&&null!==h?h._currentValue:d);Nf(h,e,f,d);Xg(a,b,c,h,e)}else{h=Ef(e,b.legacyContext);ag={};bg=b;cg=a;dg=c;ig=hg=0;jg=-1;kg=0;lg=d;d=e(f,h);d=rg(e,f,d,h);g=0!==hg;var k=ig,m=jg;"object"===typeof d&&null!==d&&"function"===typeof d.render&&void 0===d.$$typeof?(Nf(d,e,f,h),Xg(a,b,c,d,e)):Yg(a,b,c,d,g,k,m)}else if("string"===typeof e)if(d=
 b.blockedSegment,null===d)d=f.children,h=b.formatContext,g=b.keyPath,b.formatContext=Mb(h,e,f),b.keyPath=c,Zg(a,b,d,-1),b.formatContext=h,b.keyPath=g;else{g=Bc(d.chunks,e,f,a.resumableState,a.renderState,b.formatContext,d.lastPushedText);d.lastPushedText=!1;h=b.formatContext;k=b.keyPath;b.formatContext=Mb(h,e,f);b.keyPath=c;Zg(a,b,g,-1);b.formatContext=h;b.keyPath=k;a:{b=d.chunks;a=a.resumableState;switch(e){case "title":case "style":case "script":case "area":case "base":case "br":case "col":case "embed":case "hr":case "img":case "input":case "keygen":case "link":case "meta":case "param":case "source":case "track":case "wbr":break a;
 case "body":if(1>=h.insertionMode){a.hasBody=!0;break a}break;case "html":if(0===h.insertionMode){a.hasHtml=!0;break a}}b.push(mc(e))}d.lastPushedText=!1}else{switch(e){case vf:case tf:case hf:case jf:case gf:e=b.keyPath;b.keyPath=c;X(a,b,null,f.children,-1);b.keyPath=e;return;case uf:"hidden"!==f.mode&&(e=b.keyPath,b.keyPath=c,X(a,b,null,f.children,-1),b.keyPath=e);return;case pf:e=b.keyPath;b.keyPath=c;X(a,b,null,f.children,-1);b.keyPath=e;return;case sf:throw Error("ReactDOMServer does not yet support scope components.");
-case of:a:if(null!==b.replay){e=b.keyPath;b.keyPath=c;c=f.children;try{Zg(a,b,c,-1)}finally{b.keyPath=e}}else{m=b.keyPath;e=b.blockedBoundary;var p=b.blockedSegment;d=f.fallback;var t=f.children;f=new Set;g=Ug(a,f);null!==a.trackedPostpones&&(g.trackedContentKeyPath=c);k=Mg(a,p.chunks.length,g,b.formatContext,!1,!1);p.children.push(k);p.lastPushedText=!1;var q=Mg(a,0,null,b.formatContext,!1,!1);q.parentFlushed=!0;b.blockedBoundary=g;b.blockedSegment=q;a.renderState.boundaryResources=g.resources;b.keyPath=
-c;try{if(Zg(a,b,t,-1),q.lastPushedText&&q.textEmbedded&&q.chunks.push(Nb),q.status=1,bh(g,q),0===g.pendingTasks&&0===g.status){g.status=1;break a}}catch(y){q.status=4,g.status=4,"object"===typeof y&&null!==y&&y.$$typeof===Af?(a.onPostpone(y.message),h="POSTPONE"):h=Vg(a,y),g.errorDigest=h}finally{a.renderState.boundaryResources=e?e.resources:null,b.blockedBoundary=e,b.blockedSegment=p,b.keyPath=m}h=[c[0],"Suspense Fallback",c[2]];m=a.trackedPostpones;null!==m&&(p=[h[1],h[2],[],null],m.workingMap.set(h,
+case of:a:if(null!==b.replay){e=b.keyPath;b.keyPath=c;c=f.children;try{Zg(a,b,c,-1)}finally{b.keyPath=e}}else{m=b.keyPath;e=b.blockedBoundary;var p=b.blockedSegment;d=f.fallback;var t=f.children;f=new Set;g=Ug(a,f);null!==a.trackedPostpones&&(g.trackedContentKeyPath=c);k=Mg(a,p.chunks.length,g,b.formatContext,!1,!1);p.children.push(k);p.lastPushedText=!1;var r=Mg(a,0,null,b.formatContext,!1,!1);r.parentFlushed=!0;b.blockedBoundary=g;b.blockedSegment=r;a.renderState.boundaryResources=g.resources;b.keyPath=
+c;try{if(Zg(a,b,t,-1),r.lastPushedText&&r.textEmbedded&&r.chunks.push(Nb),r.status=1,bh(g,r),0===g.pendingTasks&&0===g.status){g.status=1;break a}}catch(y){r.status=4,g.status=4,"object"===typeof y&&null!==y&&y.$$typeof===Af?(a.onPostpone(y.message),h="POSTPONE"):h=Vg(a,y),g.errorDigest=h}finally{a.renderState.boundaryResources=e?e.resources:null,b.blockedBoundary=e,b.blockedSegment=p,b.keyPath=m}h=[c[0],"Suspense Fallback",c[2]];m=a.trackedPostpones;null!==m&&(p=[h[1],h[2],[],null],m.workingMap.set(h,
 p),5===g.status?m.workingMap.get(c)[4]=p:g.trackedFallbackNode=p);b=Ng(a,null,d,-1,e,k,f,h,b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}return}if("object"===typeof e&&null!==e)switch(e.$$typeof){case nf:e=e.render;ag={};bg=b;cg=a;dg=c;ig=hg=0;jg=-1;kg=0;lg=d;d=e(f,g);f=rg(e,f,d,g);Yg(a,b,c,f,0!==hg,ig,jg);return;case qf:e=e.type;f=$g(e,f);ah(a,b,c,d,e,f,g);return;case kf:h=f.children;d=b.keyPath;e=e._context;f=f.value;g=e._currentValue;e._currentValue=f;k=Ff;Ff=f=
 {parent:k,depth:null===k?0:k.depth+1,context:e,parentValue:g,value:f};b.context=f;b.keyPath=c;X(a,b,null,h,-1);a=Ff;if(null===a)throw Error("Tried to pop a Context at the root of the app. This is a bug in React.");c=a.parentValue;a.context._currentValue=c===xf?a.context._defaultValue:c;a=Ff=a.parent;b.context=a;b.keyPath=d;return;case lf:f=f.children;f=f(e._currentValue);e=b.keyPath;b.keyPath=c;X(a,b,null,f,-1);b.keyPath=e;return;case rf:h=e._init;e=h(e._payload);f=$g(e,f);ah(a,b,c,d,e,f,void 0);
 return}throw Error("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: "+((null==e?e:typeof e)+"."));}}function ch(a,b,c,d,e){var f=b.replay,g=b.blockedBoundary,h=Mg(a,0,null,b.formatContext,!1,!1);h.id=c;h.parentFlushed=!0;try{b.replay=null,b.blockedSegment=h,Zg(a,b,d,e),h.status=1,null===g?a.completedRootSegment=h:(bh(g,h),g.parentFlushed&&a.partialBoundaries.push(g))}finally{b.replay=f,b.blockedSegment=null}}
-function X(a,b,c,d,e){if(null!==b.replay&&"number"===typeof b.replay.slots)ch(a,b,b.replay.slots,d,e);else{b.node=d;b.childIndex=e;if("object"===typeof d&&null!==d){switch(d.$$typeof){case ef:var f=d.type,g=d.key,h=d.props,k=d.ref,m=Cf(f),p=null==g?-1===e?0:e:g;g=[b.keyPath,m,p];if(null!==b.replay)a:{var t=b.replay;e=t.nodes;for(d=0;d<e.length;d++){var q=e[d];if(p===q[1]){if(4===q.length){if(null!==m&&m!==q[0])throw Error("Expected the resume to render <"+q[0]+"> in this slot but instead it rendered <"+
-m+">. The tree doesn't match so React will fallback to client rendering.");m=q[2];q=q[3];p=b.node;b.replay={nodes:m,slots:q,pendingTasks:1};try{ah(a,b,g,c,f,h,k);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--}catch(E){if("object"===typeof E&&null!==E&&(E===Uf||"function"===typeof E.then))throw b.node===p&&(b.replay=t),E;b.replay.pendingTasks--;
-dh(a,b.blockedBoundary,E,m,q)}b.replay=t}else{if(f!==of)throw Error("Expected the resume to render <Suspense> in this slot but instead it rendered <"+(Cf(f)||"Unknown")+">. The tree doesn't match so React will fallback to client rendering.");b:{c=void 0;f=q[5];k=q[2];t=q[3];m=null===q[4]?[]:q[4][2];q=null===q[4]?null:q[4][3];p=b.keyPath;var y=b.replay,C=b.blockedBoundary,Y=h.children;h=h.fallback;var u=new Set,B=Ug(a,u);B.parentFlushed=!0;B.rootSegmentID=f;b.blockedBoundary=B;b.replay={nodes:k,slots:t,
+function X(a,b,c,d,e){if(null!==b.replay&&"number"===typeof b.replay.slots)ch(a,b,b.replay.slots,d,e);else{b.node=d;b.childIndex=e;if("object"===typeof d&&null!==d){switch(d.$$typeof){case ef:var f=d.type,g=d.key,h=d.props,k=d.ref,m=Cf(f),p=null==g?-1===e?0:e:g;g=[b.keyPath,m,p];if(null!==b.replay)a:{var t=b.replay;e=t.nodes;for(d=0;d<e.length;d++){var r=e[d];if(p===r[1]){if(4===r.length){if(null!==m&&m!==r[0])throw Error("Expected the resume to render <"+r[0]+"> in this slot but instead it rendered <"+
+m+">. The tree doesn't match so React will fallback to client rendering.");m=r[2];r=r[3];p=b.node;b.replay={nodes:m,slots:r,pendingTasks:1};try{ah(a,b,g,c,f,h,k);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--}catch(E){if("object"===typeof E&&null!==E&&(E===Uf||"function"===typeof E.then))throw b.node===p&&(b.replay=t),E;b.replay.pendingTasks--;
+dh(a,b.blockedBoundary,E,m,r)}b.replay=t}else{if(f!==of)throw Error("Expected the resume to render <Suspense> in this slot but instead it rendered <"+(Cf(f)||"Unknown")+">. The tree doesn't match so React will fallback to client rendering.");b:{c=void 0;f=r[5];k=r[2];t=r[3];m=null===r[4]?[]:r[4][2];r=null===r[4]?null:r[4][3];p=b.keyPath;var y=b.replay,C=b.blockedBoundary,Y=h.children;h=h.fallback;var u=new Set,B=Ug(a,u);B.parentFlushed=!0;B.rootSegmentID=f;b.blockedBoundary=B;b.replay={nodes:k,slots:t,
 pendingTasks:1};a.renderState.boundaryResources=B.resources;try{Zg(a,b,Y,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--;if(0===B.pendingTasks&&0===B.status){B.status=1;a.completedBoundaries.push(B);break b}}catch(E){B.status=4,"object"===typeof E&&null!==E&&E.$$typeof===Af?(a.onPostpone(E.message),c="POSTPONE"):c=Vg(a,
-E),B.errorDigest=c,b.replay.pendingTasks--,a.clientRenderedBoundaries.push(B)}finally{a.renderState.boundaryResources=C?C.resources:null,b.blockedBoundary=C,b.replay=y,b.keyPath=p}h=Qg(a,null,{nodes:m,slots:q,pendingTasks:0},h,-1,C,u,[g[0],"Suspense Fallback",g[2]],b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(h)}}e.splice(d,1);break a}}}else ah(a,b,g,c,f,h,k);return;case ff:throw Error("Portals are not currently supported by the server renderer. Render them conditionally so that they only appear on the client render.");
+E),B.errorDigest=c,b.replay.pendingTasks--,a.clientRenderedBoundaries.push(B)}finally{a.renderState.boundaryResources=C?C.resources:null,b.blockedBoundary=C,b.replay=y,b.keyPath=p}h=Qg(a,null,{nodes:m,slots:r,pendingTasks:0},h,-1,C,u,[g[0],"Suspense Fallback",g[2]],b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(h)}}e.splice(d,1);break a}}}else ah(a,b,g,c,f,h,k);return;case ff:throw Error("Portals are not currently supported by the server renderer. Render them conditionally so that they only appear on the client render.");
 case rf:h=d._init;d=h(d._payload);X(a,b,null,d,e);return}if(Ia(d)){eh(a,b,d,e);return}null===d||"object"!==typeof d?h=null:(h=Bf&&d[Bf]||d["@@iterator"],h="function"===typeof h?h:null);if(h&&(h=h.call(d))){d=h.next();if(!d.done){g=[];do g.push(d.value),d=h.next();while(!d.done);eh(a,b,g,e)}return}if("function"===typeof d.then)return X(a,b,null,Bg(d),e);if(d.$$typeof===lf||d.$$typeof===mf)return X(a,b,null,d._currentValue,e);e=Object.prototype.toString.call(d);throw Error("Objects are not valid as a React child (found: "+
 ("[object Object]"===e?"object with keys {"+Object.keys(d).join(", ")+"}":e)+"). If you meant to render a collection of children, use an array instead.");}"string"===typeof d?(e=b.blockedSegment,null!==e&&(e.lastPushedText=Ob(e.chunks,d,a.renderState,e.lastPushedText))):"number"===typeof d&&(e=b.blockedSegment,null!==e&&(e.lastPushedText=Ob(e.chunks,""+d,a.renderState,e.lastPushedText)))}}
 function eh(a,b,c,d){var e=b.keyPath;if(-1!==d&&(b.keyPath=[b.keyPath,"Fragment",d],null!==b.replay)){for(var f=b.replay,g=f.nodes,h=0;h<g.length;h++){var k=g[h];if(k[1]===d){d=k[2];k=k[3];b.replay={nodes:d,slots:k,pendingTasks:1};try{eh(a,b,c,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--}catch(p){if("object"===typeof p&&
@@ -185,8 +183,8 @@ null!==p&&(p===Uf||"function"===typeof p.then))throw p;b.replay.pendingTasks--;d
 function fh(a,b,c,d){d.status=5;var e=c.keyPath,f=c.blockedBoundary;if(null===f)d.id=a.nextSegmentId++,b.rootSlots=d.id,null!==a.completedRootSegment&&(a.completedRootSegment.status=5);else{if(null!==f&&0===f.status){f.status=5;f.rootSegmentID=a.nextSegmentId++;var g=f.trackedContentKeyPath;if(null===g)throw Error("It should not be possible to postpone at the root. This is a bug in React.");var h=f.trackedFallbackNode,k=[];if(g===e&&-1===c.childIndex){d.id=f.rootSegmentID;d=[g[1],g[2],k,f.rootSegmentID,
 h,f.rootSegmentID];b.workingMap.set(g,d);gh(d,g[0],b);return}var m=b.workingMap.get(g);void 0===m?(m=[g[1],g[2],k,null,h,f.rootSegmentID],b.workingMap.set(g,m),gh(m,g[0],b)):(g=m,g[4]=h,g[5]=f.rootSegmentID)}-1===d.id&&(d.id=d.parentFlushed&&null!==f?f.rootSegmentID:a.nextSegmentId++);if(-1===c.childIndex)null===e?b.rootSlots=d.id:(c=b.workingMap.get(e),void 0===c?(c=[e[1],e[2],[],d.id],gh(c,e[0],b)):c[3]=d.id);else{if(null===e)if(a=b.rootSlots,null===a)a=b.rootSlots={};else{if("number"===typeof a)throw Error("It should not be possible to postpone both at the root of an element as well as a slot below. This is a bug in React.");
 }else if(f=b.workingMap,g=f.get(e),void 0===g)a={},g=[e[1],e[2],[],a],f.set(e,g),gh(g,e[0],b);else if(a=g[3],null===a)a=g[3]={};else if("number"===typeof a)throw Error("It should not be possible to postpone both at the root of an element as well as a slot below. This is a bug in React.");a[c.childIndex]=d.id}}}
-function Zg(a,b,c,d){var e=b.formatContext,f=b.legacyContext,g=b.context,h=b.keyPath,k=b.treeContext,m=b.blockedSegment;if(null===m)try{return X(a,b,null,c,d)}catch(q){if(sg(),d=q===Uf?Yf():q,"object"===typeof d&&null!==d&&"function"===typeof d.then){c=d;d=tg();a=Qg(a,d,b.replay,b.node,b.childIndex,b.blockedBoundary,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Lf(g);return}}else{var p=
-m.children.length,t=m.chunks.length;try{return X(a,b,null,c,d)}catch(q){if(sg(),m.children.length=p,m.chunks.length=t,d=q===Uf?Yf():q,"object"===typeof d&&null!==d){if("function"===typeof d.then){c=d;d=tg();m=b.blockedSegment;p=Mg(a,m.chunks.length,null,b.formatContext,m.lastPushedText,!0);m.children.push(p);m.lastPushedText=!1;a=Ng(a,d,b.node,b.childIndex,b.blockedBoundary,p,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=
+function Zg(a,b,c,d){var e=b.formatContext,f=b.legacyContext,g=b.context,h=b.keyPath,k=b.treeContext,m=b.blockedSegment;if(null===m)try{return X(a,b,null,c,d)}catch(r){if(sg(),d=r===Uf?Yf():r,"object"===typeof d&&null!==d&&"function"===typeof d.then){c=d;d=tg();a=Qg(a,d,b.replay,b.node,b.childIndex,b.blockedBoundary,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Lf(g);return}}else{var p=
+m.children.length,t=m.chunks.length;try{return X(a,b,null,c,d)}catch(r){if(sg(),m.children.length=p,m.chunks.length=t,d=r===Uf?Yf():r,"object"===typeof d&&null!==d){if("function"===typeof d.then){c=d;d=tg();m=b.blockedSegment;p=Mg(a,m.chunks.length,null,b.formatContext,m.lastPushedText,!0);m.children.push(p);m.lastPushedText=!1;a=Ng(a,d,b.node,b.childIndex,b.blockedBoundary,p,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=
 f;b.context=g;b.keyPath=h;b.treeContext=k;Lf(g);return}if(null!==a.trackedPostpones&&d.$$typeof===Af&&null!==b.blockedBoundary){c=a.trackedPostpones;a.onPostpone(d.message);d=b.blockedSegment;m=Mg(a,d.chunks.length,null,b.formatContext,d.lastPushedText,!0);d.children.push(m);d.lastPushedText=!1;fh(a,c,b,m);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Lf(g);return}}}}b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Lf(g);throw d;}
 function dh(a,b,c,d,e){if("object"===typeof c&&null!==c&&c.$$typeof===Af){a.onPostpone(c.message);var f="POSTPONE"}else f=Vg(a,c);hh(a,b,d,e,c,f)}function ih(a){var b=a.blockedBoundary;a=a.blockedSegment;null!==a&&(a.status=3,jh(this,b,a))}
 function hh(a,b,c,d,e,f){for(var g=0;g<c.length;g++){var h=c[g];if(4===h.length)hh(a,b,h[2],h[3],e,f);else{h=h[5];var k=a,m=f,p=Ug(k,new Set);p.parentFlushed=!0;p.rootSegmentID=h;p.status=4;p.errorDigest=m;p.parentFlushed&&k.clientRenderedBoundaries.push(p)}}c.length=0;if(null!==d){if(null===b)throw Error("We should not have any resumable nodes in the shell. This is a bug in React.");4!==b.status&&(b.status=4,b.errorDigest=f,b.parentFlushed&&a.clientRenderedBoundaries.push(b));if("object"===typeof d)for(var t in d)delete d[t]}}
@@ -195,34 +193,36 @@ b,c)}),d.fallbackAbortableTasks.clear();b.allPendingTasks--;0===b.allPendingTask
 function bh(a,b){if(0===b.chunks.length&&1===b.children.length&&null===b.children[0].boundary){var c=b.children[0];c.id=b.id;c.parentFlushed=!0;1===c.status&&bh(a,c)}else a.completedSegments.push(b)}
 function jh(a,b,c){if(null===b){if(null!==c&&c.parentFlushed){if(null!==a.completedRootSegment)throw Error("There can only be one root segment. This is a bug in React.");a.completedRootSegment=c}a.pendingRootTasks--;0===a.pendingRootTasks&&lh(a)}else b.pendingTasks--,4!==b.status&&(0===b.pendingTasks?(0===b.status&&(b.status=1),null!==c&&c.parentFlushed&&1===c.status&&bh(b,c),b.parentFlushed&&a.completedBoundaries.push(b),1===b.status&&(b.fallbackAbortableTasks.forEach(ih,a),b.fallbackAbortableTasks.clear())):
 null!==c&&c.parentFlushed&&1===c.status&&(bh(b,c),1===b.completedSegments.length&&b.parentFlushed&&a.partialBoundaries.push(b)));a.allPendingTasks--;0===a.allPendingTasks&&mh(a)}
-function Tg(a){if(2!==a.status){var b=Ff,c=Hg.current;Hg.current=Fg;var d=Ig.current;Ig.current=Gg;var e=Rg;Rg=a;var f=Eg;Eg=a.resumableState;try{var g=a.pingedTasks,h;for(h=0;h<g.length;h++){var k=g[h],m=a,p=k.blockedBoundary;m.renderState.boundaryResources=p?p.resources:null;var t=k.blockedSegment;if(null===t){var q=m;if(0!==k.replay.pendingTasks){Lf(k.context);try{var y=k.thenableState;k.thenableState=null;X(q,k,y,k.node,k.childIndex);if(1===k.replay.pendingTasks&&0<k.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");
-k.replay.pendingTasks--;k.abortSet.delete(k);jh(q,k.blockedBoundary,null)}catch(K){sg();var C=K===Uf?Yf():K;if("object"===typeof C&&null!==C&&"function"===typeof C.then){var Y=k.ping;C.then(Y,Y);k.thenableState=tg()}else k.replay.pendingTasks--,k.abortSet.delete(k),dh(q,k.blockedBoundary,C,k.replay.nodes,k.replay.slots),q.pendingRootTasks--,0===q.pendingRootTasks&&lh(q),q.allPendingTasks--,0===q.allPendingTasks&&mh(q)}finally{q.renderState.boundaryResources=null}}}else a:{q=void 0;var u=t;if(0===
+function Tg(a){if(2!==a.status){var b=Ff,c=Hg.current;Hg.current=Fg;var d=Ig.current;Ig.current=Gg;var e=Rg;Rg=a;var f=Eg;Eg=a.resumableState;try{var g=a.pingedTasks,h;for(h=0;h<g.length;h++){var k=g[h],m=a,p=k.blockedBoundary;m.renderState.boundaryResources=p?p.resources:null;var t=k.blockedSegment;if(null===t){var r=m;if(0!==k.replay.pendingTasks){Lf(k.context);try{var y=k.thenableState;k.thenableState=null;X(r,k,y,k.node,k.childIndex);if(1===k.replay.pendingTasks&&0<k.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");
+k.replay.pendingTasks--;k.abortSet.delete(k);jh(r,k.blockedBoundary,null)}catch(K){sg();var C=K===Uf?Yf():K;if("object"===typeof C&&null!==C&&"function"===typeof C.then){var Y=k.ping;C.then(Y,Y);k.thenableState=tg()}else k.replay.pendingTasks--,k.abortSet.delete(k),dh(r,k.blockedBoundary,C,k.replay.nodes,k.replay.slots),r.pendingRootTasks--,0===r.pendingRootTasks&&lh(r),r.allPendingTasks--,0===r.allPendingTasks&&mh(r)}finally{r.renderState.boundaryResources=null}}}else a:{r=void 0;var u=t;if(0===
 u.status){Lf(k.context);var B=u.children.length,E=u.chunks.length;try{var ka=k.thenableState;k.thenableState=null;X(m,k,ka,k.node,k.childIndex);u.lastPushedText&&u.textEmbedded&&u.chunks.push(Nb);k.abortSet.delete(k);u.status=1;jh(m,k.blockedBoundary,u)}catch(K){sg();u.children.length=B;u.chunks.length=E;var w=K===Uf?Yf():K;if("object"===typeof w&&null!==w){if("function"===typeof w.then){var R=k.ping;w.then(R,R);k.thenableState=tg();break a}if(null!==m.trackedPostpones&&w.$$typeof===Af){var F=m.trackedPostpones;
-k.abortSet.delete(k);m.onPostpone(w.message);fh(m,F,k,u);jh(m,k.blockedBoundary,u);break a}}k.abortSet.delete(k);u.status=4;var J=k.blockedBoundary;"object"===typeof w&&null!==w&&w.$$typeof===Af?(m.onPostpone(w.message),q="POSTPONE"):q=Vg(m,w);null===J?Wg(m,w):(J.pendingTasks--,4!==J.status&&(J.status=4,J.errorDigest=q,J.parentFlushed&&m.clientRenderedBoundaries.push(J)));m.allPendingTasks--;0===m.allPendingTasks&&mh(m)}finally{m.renderState.boundaryResources=null}}}}g.splice(0,h);null!==a.destination&&
+k.abortSet.delete(k);m.onPostpone(w.message);fh(m,F,k,u);jh(m,k.blockedBoundary,u);break a}}k.abortSet.delete(k);u.status=4;var J=k.blockedBoundary;"object"===typeof w&&null!==w&&w.$$typeof===Af?(m.onPostpone(w.message),r="POSTPONE"):r=Vg(m,w);null===J?Wg(m,w):(J.pendingTasks--,4!==J.status&&(J.status=4,J.errorDigest=r,J.parentFlushed&&m.clientRenderedBoundaries.push(J)));m.allPendingTasks--;0===m.allPendingTasks&&mh(m)}finally{m.renderState.boundaryResources=null}}}}g.splice(0,h);null!==a.destination&&
 nh(a,a.destination)}catch(K){Vg(a,K),Wg(a,K)}finally{Eg=f,Hg.current=c,Ig.current=d,c===Fg&&Lf(b),Rg=e}}}
-function oh(a,b,c){c.parentFlushed=!0;switch(c.status){case 0:c.id=a.nextSegmentId++;case 5:var d=c.id;c.lastPushedText=!1;c.textEmbedded=!1;a=a.renderState;r(b,Fc);r(b,a.placeholderPrefix);a=x(d.toString(16));r(b,a);return v(b,Gc);case 1:c.status=2;var e=!0;d=c.chunks;var f=0;c=c.children;for(var g=0;g<c.length;g++){for(e=c[g];f<e.index;f++)r(b,d[f]);e=ph(a,b,e)}for(;f<d.length-1;f++)r(b,d[f]);f<d.length&&(e=v(b,d[f]));return e;default:throw Error("Aborted, errored or already flushed boundaries should not be flushed again. This is a bug in React.");
+function oh(a,b,c){c.parentFlushed=!0;switch(c.status){case 0:c.id=a.nextSegmentId++;case 5:var d=c.id;c.lastPushedText=!1;c.textEmbedded=!1;a=a.renderState;q(b,Fc);q(b,a.placeholderPrefix);a=x(d.toString(16));q(b,a);return v(b,Gc);case 1:c.status=2;var e=!0;d=c.chunks;var f=0;c=c.children;for(var g=0;g<c.length;g++){for(e=c[g];f<e.index;f++)q(b,d[f]);e=ph(a,b,e)}for(;f<d.length-1;f++)q(b,d[f]);f<d.length&&(e=v(b,d[f]));return e;default:throw Error("Aborted, errored or already flushed boundaries should not be flushed again. This is a bug in React.");
 }}
-function ph(a,b,c){var d=c.boundary;if(null===d)return oh(a,b,c);d.parentFlushed=!0;if(4===d.status)d=d.errorDigest,v(b,Kc),r(b,Mc),d&&(r(b,Oc),r(b,x(G(d))),r(b,Nc)),v(b,Pc),oh(a,b,c);else if(1!==d.status)0===d.status&&(d.rootSegmentID=a.nextSegmentId++),0<d.completedSegments.length&&a.partialBoundaries.push(d),Qc(b,a.renderState,d.rootSegmentID),oh(a,b,c);else if(d.byteSize>a.progressiveChunkSize)d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),Qc(b,a.renderState,d.rootSegmentID),oh(a,
+function ph(a,b,c){var d=c.boundary;if(null===d)return oh(a,b,c);d.parentFlushed=!0;if(4===d.status)d=d.errorDigest,v(b,Kc),q(b,Mc),d&&(q(b,Oc),q(b,x(G(d))),q(b,Nc)),v(b,Pc),oh(a,b,c);else if(1!==d.status)0===d.status&&(d.rootSegmentID=a.nextSegmentId++),0<d.completedSegments.length&&a.partialBoundaries.push(d),Qc(b,a.renderState,d.rootSegmentID),oh(a,b,c);else if(d.byteSize>a.progressiveChunkSize)d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),Qc(b,a.renderState,d.rootSegmentID),oh(a,
 b,c);else{c=d.resources;var e=a.renderState.boundaryResources;e&&(c.styles.forEach($e,e),c.stylesheets.forEach(af,e));v(b,Hc);d=d.completedSegments;if(1!==d.length)throw Error("A previously unvisited boundary must have exactly one root segment. This is a bug in React.");ph(a,b,d[0])}return v(b,Lc)}function qh(a,b,c){ld(b,a.renderState,c.parentFormatContext,c.id);ph(a,b,c);return md(b,c.parentFormatContext)}
-function rh(a,b,c){a.renderState.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e<d.length;e++)sh(a,b,c,d[e]);d.length=0;De(b,c.resources,a.renderState);d=a.resumableState;a=a.renderState;e=c.rootSegmentID;c=c.resources;var f=a.stylesToHoist;a.stylesToHoist=!1;var g=0===d.streamingFormat;g?(r(b,a.startInlineScript),f?0===(d.instructions&2)?(d.instructions|=10,r(b,512<vd.byteLength?vd.slice():vd)):0===(d.instructions&8)?(d.instructions|=8,r(b,wd)):r(b,xd):0===(d.instructions&2)?(d.instructions|=
-2,r(b,td)):r(b,ud)):f?r(b,Dd):r(b,Cd);d=x(e.toString(16));r(b,a.boundaryPrefix);r(b,d);g?r(b,yd):r(b,Ed);r(b,a.segmentPrefix);r(b,d);f?g?(r(b,zd),Se(b,c)):(r(b,ge),Te(b,c)):g&&r(b,Ad);d=g?v(b,Bd):v(b,ab);return Ec(b,a)&&d}
-function sh(a,b,c,d){if(2===d.status)return!0;var e=d.id;if(-1===e){if(-1===(d.id=c.rootSegmentID))throw Error("A root segment ID must have been assigned by now. This is a bug in React.");return qh(a,b,d)}if(e===c.rootSegmentID)return qh(a,b,d);qh(a,b,d);c=a.resumableState;a=a.renderState;(d=0===c.streamingFormat)?(r(b,a.startInlineScript),0===(c.instructions&1)?(c.instructions|=1,r(b,nd)):r(b,od)):r(b,rd);r(b,a.segmentPrefix);e=x(e.toString(16));r(b,e);d?r(b,pd):r(b,sd);r(b,a.placeholderPrefix);
-r(b,e);b=d?v(b,qd):v(b,ab);return b}
-function nh(a,b){l=new Uint8Array(512);n=0;try{var c,d=a.completedRootSegment;if(null!==d)if(5!==d.status&&0===a.pendingRootTasks){var e=a.renderState;if((0!==a.allPendingTasks||null!==a.trackedPostpones)&&e.externalRuntimeScript){var f=e.externalRuntimeScript,g=a.resumableState,h=f.src,k=f.chunks;g.scriptResources.hasOwnProperty(h)||(g.scriptResources[h]=null,e.scripts.add(k))}var m=e.htmlChunks,p=e.headChunks;f=0;if(m){for(f=0;f<m.length;f++)r(b,m[f]);if(p)for(f=0;f<p.length;f++)r(b,p[f]);else r(b,
-V("head")),r(b,U)}else if(p)for(f=0;f<p.length;f++)r(b,p[f]);var t=e.charsetChunks;for(f=0;f<t.length;f++)r(b,t[f]);t.length=0;e.preconnects.forEach(Ee,b);e.preconnects.clear();var q=e.preconnectChunks;for(f=0;f<q.length;f++)r(b,q[f]);q.length=0;e.fontPreloads.forEach(Ee,b);e.fontPreloads.clear();e.highImagePreloads.forEach(Ee,b);e.highImagePreloads.clear();e.styles.forEach(Le,b);var y=e.importMapChunks;for(f=0;f<y.length;f++)r(b,y[f]);y.length=0;e.bootstrapScripts.forEach(Ee,b);e.scripts.forEach(Ee,
-b);e.scripts.clear();e.bulkPreloads.forEach(Ee,b);e.bulkPreloads.clear();var C=e.preloadChunks;for(f=0;f<C.length;f++)r(b,C[f]);C.length=0;var Y=e.hoistableChunks;for(f=0;f<Y.length;f++)r(b,Y[f]);Y.length=0;m&&null===p&&r(b,mc("head"));ph(a,b,d);a.completedRootSegment=null;Ec(b,a.renderState)}else return;var u=a.renderState;d=0;u.preconnects.forEach(Ee,b);u.preconnects.clear();var B=u.preconnectChunks;for(d=0;d<B.length;d++)r(b,B[d]);B.length=0;u.fontPreloads.forEach(Ee,b);u.fontPreloads.clear();
-u.highImagePreloads.forEach(Ee,b);u.highImagePreloads.clear();u.styles.forEach(Ne,b);u.scripts.forEach(Ee,b);u.scripts.clear();u.bulkPreloads.forEach(Ee,b);u.bulkPreloads.clear();var E=u.preloadChunks;for(d=0;d<E.length;d++)r(b,E[d]);E.length=0;var ka=u.hoistableChunks;for(d=0;d<ka.length;d++)r(b,ka[d]);ka.length=0;var w=a.clientRenderedBoundaries;for(c=0;c<w.length;c++){var R=w[c];u=b;var F=a.resumableState,J=a.renderState,K=R.rootSegmentID,Oa=R.errorDigest,za=R.errorMessage,qa=R.errorComponentStack,
-la=0===F.streamingFormat;la?(r(u,J.startInlineScript),0===(F.instructions&4)?(F.instructions|=4,r(u,he)):r(u,ie)):r(u,me);r(u,J.boundaryPrefix);r(u,x(K.toString(16)));la&&r(u,je);if(Oa||za||qa)la?(r(u,ke),r(u,x(re(Oa||"")))):(r(u,ne),r(u,x(G(Oa||""))));if(za||qa)la?(r(u,ke),r(u,x(re(za||"")))):(r(u,oe),r(u,x(G(za||""))));qa&&(la?(r(u,ke),r(u,x(re(qa)))):(r(u,pe),r(u,x(G(qa)))));if(la?!v(u,le):!v(u,ab)){a.destination=null;c++;w.splice(0,c);return}}w.splice(0,c);var Aa=a.completedBoundaries;for(c=0;c<
+function rh(a,b,c){a.renderState.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e<d.length;e++)sh(a,b,c,d[e]);d.length=0;De(b,c.resources,a.renderState);d=a.resumableState;a=a.renderState;e=c.rootSegmentID;c=c.resources;var f=a.stylesToHoist;a.stylesToHoist=!1;var g=0===d.streamingFormat;g?(q(b,a.startInlineScript),f?0===(d.instructions&2)?(d.instructions|=10,q(b,512<vd.byteLength?vd.slice():vd)):0===(d.instructions&8)?(d.instructions|=8,q(b,wd)):q(b,xd):0===(d.instructions&2)?(d.instructions|=
+2,q(b,td)):q(b,ud)):f?q(b,Dd):q(b,Cd);e=x(e.toString(16));q(b,a.boundaryPrefix);q(b,e);g?q(b,yd):q(b,Ed);q(b,a.segmentPrefix);q(b,e);f?g?(q(b,zd),Se(b,c)):(q(b,ge),Te(b,c)):g&&q(b,Ad);c=g?v(b,Bd):v(b,ab);return Ec(b,a,d)&&c}
+function sh(a,b,c,d){if(2===d.status)return!0;var e=d.id;if(-1===e){if(-1===(d.id=c.rootSegmentID))throw Error("A root segment ID must have been assigned by now. This is a bug in React.");return qh(a,b,d)}if(e===c.rootSegmentID)return qh(a,b,d);qh(a,b,d);c=a.resumableState;a=a.renderState;(d=0===c.streamingFormat)?(q(b,a.startInlineScript),0===(c.instructions&1)?(c.instructions|=1,q(b,nd)):q(b,od)):q(b,rd);q(b,a.segmentPrefix);e=x(e.toString(16));q(b,e);d?q(b,pd):q(b,sd);q(b,a.placeholderPrefix);
+q(b,e);b=d?v(b,qd):v(b,ab);return b}
+function nh(a,b){l=new Uint8Array(512);n=0;try{var c,d=a.completedRootSegment;if(null!==d)if(5!==d.status&&0===a.pendingRootTasks){var e=a.renderState;if((0!==a.allPendingTasks||null!==a.trackedPostpones)&&e.externalRuntimeScript){var f=e.externalRuntimeScript,g=a.resumableState,h=f.src,k=f.chunks;g.scriptResources.hasOwnProperty(h)||(g.scriptResources[h]=null,e.scripts.add(k))}var m=e.htmlChunks,p=e.headChunks;f=0;if(m){for(f=0;f<m.length;f++)q(b,m[f]);if(p)for(f=0;f<p.length;f++)q(b,p[f]);else q(b,
+V("head")),q(b,U)}else if(p)for(f=0;f<p.length;f++)q(b,p[f]);var t=e.charsetChunks;for(f=0;f<t.length;f++)q(b,t[f]);t.length=0;e.preconnects.forEach(Ee,b);e.preconnects.clear();var r=e.preconnectChunks;for(f=0;f<r.length;f++)q(b,r[f]);r.length=0;e.fontPreloads.forEach(Ee,b);e.fontPreloads.clear();e.highImagePreloads.forEach(Ee,b);e.highImagePreloads.clear();e.styles.forEach(Le,b);var y=e.importMapChunks;for(f=0;f<y.length;f++)q(b,y[f]);y.length=0;e.bootstrapScripts.forEach(Ee,b);e.scripts.forEach(Ee,
+b);e.scripts.clear();e.bulkPreloads.forEach(Ee,b);e.bulkPreloads.clear();var C=e.preloadChunks;for(f=0;f<C.length;f++)q(b,C[f]);C.length=0;var Y=e.hoistableChunks;for(f=0;f<Y.length;f++)q(b,Y[f]);Y.length=0;m&&null===p&&q(b,mc("head"));ph(a,b,d);a.completedRootSegment=null;Ec(b,a.renderState,a.resumableState)}else return;var u=a.renderState;d=0;u.preconnects.forEach(Ee,b);u.preconnects.clear();var B=u.preconnectChunks;for(d=0;d<B.length;d++)q(b,B[d]);B.length=0;u.fontPreloads.forEach(Ee,b);u.fontPreloads.clear();
+u.highImagePreloads.forEach(Ee,b);u.highImagePreloads.clear();u.styles.forEach(Ne,b);u.scripts.forEach(Ee,b);u.scripts.clear();u.bulkPreloads.forEach(Ee,b);u.bulkPreloads.clear();var E=u.preloadChunks;for(d=0;d<E.length;d++)q(b,E[d]);E.length=0;var ka=u.hoistableChunks;for(d=0;d<ka.length;d++)q(b,ka[d]);ka.length=0;var w=a.clientRenderedBoundaries;for(c=0;c<w.length;c++){var R=w[c];u=b;var F=a.resumableState,J=a.renderState,K=R.rootSegmentID,Oa=R.errorDigest,za=R.errorMessage,qa=R.errorComponentStack,
+la=0===F.streamingFormat;la?(q(u,J.startInlineScript),0===(F.instructions&4)?(F.instructions|=4,q(u,he)):q(u,ie)):q(u,me);q(u,J.boundaryPrefix);q(u,x(K.toString(16)));la&&q(u,je);if(Oa||za||qa)la?(q(u,ke),q(u,x(re(Oa||"")))):(q(u,ne),q(u,x(G(Oa||""))));if(za||qa)la?(q(u,ke),q(u,x(re(za||"")))):(q(u,oe),q(u,x(G(za||""))));qa&&(la?(q(u,ke),q(u,x(re(qa)))):(q(u,pe),q(u,x(G(qa)))));if(la?!v(u,le):!v(u,ab)){a.destination=null;c++;w.splice(0,c);return}}w.splice(0,c);var Aa=a.completedBoundaries;for(c=0;c<
 Aa.length;c++)if(!rh(a,b,Aa[c])){a.destination=null;c++;Aa.splice(0,c);return}Aa.splice(0,c);ha(b);l=new Uint8Array(512);n=0;var ra=a.partialBoundaries;for(c=0;c<ra.length;c++){var sa=ra[c];a:{w=a;R=b;w.renderState.boundaryResources=sa.resources;var ta=sa.completedSegments;for(F=0;F<ta.length;F++)if(!sh(w,R,sa,ta[F])){F++;ta.splice(0,F);var Pa=!1;break a}ta.splice(0,F);Pa=De(R,sa.resources,w.renderState)}if(!Pa){a.destination=null;c++;ra.splice(0,c);return}}ra.splice(0,c);var ea=a.completedBoundaries;
-for(c=0;c<ea.length;c++)if(!rh(a,b,ea[c])){a.destination=null;c++;ea.splice(0,c);return}ea.splice(0,c)}finally{0===a.allPendingTasks&&0===a.pingedTasks.length&&0===a.clientRenderedBoundaries.length&&0===a.completedBoundaries.length?(a.flushScheduled=!1,null===a.trackedPostpones&&(c=a.resumableState,c.hasBody&&r(b,mc("body")),c.hasHtml&&r(b,mc("html"))),ha(b),b.close(),a.destination=null):ha(b)}}
+for(c=0;c<ea.length;c++)if(!rh(a,b,ea[c])){a.destination=null;c++;ea.splice(0,c);return}ea.splice(0,c)}finally{0===a.allPendingTasks&&0===a.pingedTasks.length&&0===a.clientRenderedBoundaries.length&&0===a.completedBoundaries.length?(a.flushScheduled=!1,null===a.trackedPostpones&&(c=a.resumableState,c.hasBody&&q(b,mc("body")),c.hasHtml&&q(b,mc("html"))),ha(b),b.close(),a.destination=null):ha(b)}}
 function th(a){a.flushScheduled=null!==a.destination;cf?setTimeout(function(){return df.run(a,Tg,a)},0):setTimeout(function(){return Tg(a)},0);null===a.trackedPostpones&&(cf?setTimeout(function(){return df.run(a,uh,a)},0):setTimeout(function(){return uh(a)},0))}function uh(a){bf(a.renderState,a.resumableState,0===a.pendingRootTasks)}
 function Xe(a){!1===a.flushScheduled&&0===a.pingedTasks.length&&null!==a.destination&&(a.flushScheduled=!0,setTimeout(function(){var b=a.destination;b?nh(a,b):a.flushScheduled=!1},0))}function vh(a,b){if(1===a.status)a.status=2,ja(b,a.fatalError);else if(2!==a.status&&null===a.destination){a.destination=b;try{nh(a,b)}catch(c){Vg(a,c),Wg(a,c)}}}
 function wh(a,b){try{var c=a.abortableTasks;if(0<c.size){var d=void 0===b?Error("The render was aborted by the server without a reason."):b;c.forEach(function(e){return kh(e,a,d)});c.clear()}null!==a.destination&&nh(a,a.destination)}catch(e){Vg(a,e),Wg(a,e)}}function gh(a,b,c){if(null===b)c.rootNodes.push(a);else{var d=c.workingMap,e=d.get(b);void 0===e&&(e=[b[1],b[2],[],null],d.set(b,e),gh(e,b[0],c));e[2].push(a)}}
 function xh(a){var b=a.trackedPostpones;if(null===b||0===b.rootNodes.length&&null===b.rootSlots)return a.trackedPostpones=null;if(null!==a.completedRootSegment&&5===a.completedRootSegment.status){var c=a.resumableState,d=a.renderState;c.nextFormID=0;c.hasBody=!1;c.hasHtml=!1;c.unknownResources={font:d.resets.font};c.dnsResources=d.resets.dns;c.connectResources=d.resets.connect;c.imageResources=d.resets.image;c.styleResources=d.resets.style;c.scriptResources={};c.moduleUnknownResources={};c.moduleScriptResources=
 {}}return{nextSegmentId:a.nextSegmentId,rootFormatContext:a.rootFormatContext,progressiveChunkSize:a.progressiveChunkSize,resumableState:a.resumableState,replayNodes:b.rootNodes,replaySlots:b.rootSlots}}
-exports.prerender=function(a,b){return new Promise(function(c,d){var e=b?b.onHeaders:void 0,f;e&&(f=function(p){e(new Headers(p))});var g=Kb(b?b.identifierPrefix:void 0,b?b.unstable_externalRuntimeSrc:void 0),h=Og(a,g,Ab(g,void 0,b?b.bootstrapScriptContent:void 0,b?b.bootstrapScripts:void 0,b?b.bootstrapModules:void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.importMap:void 0,f,b?b.maxHeadersLength:void 0),Lb(b?b.namespaceURI:void 0),b?b.progressiveChunkSize:void 0,b?b.onError:void 0,function(){var p=
+exports.prerender=function(a,b){return new Promise(function(c,d){var e=b?b.onHeaders:void 0,f;e&&(f=function(p){e(new Headers(p))});var g=Kb(b?b.identifierPrefix:void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.bootstrapScriptContent:void 0,b?b.bootstrapScripts:void 0,b?b.bootstrapModules:void 0),h=Og(a,g,Ab(g,void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.importMap:void 0,f,b?b.maxHeadersLength:void 0),Lb(b?b.namespaceURI:void 0),b?b.progressiveChunkSize:void 0,b?b.onError:void 0,function(){var p=
 new ReadableStream({type:"bytes",pull:function(t){vh(h,t)},cancel:function(t){h.destination=null;wh(h,t)}},{highWaterMark:0});p={postponed:xh(h),prelude:p};c(p)},void 0,void 0,d,b?b.onPostpone:void 0);if(b&&b.signal){var k=b.signal;if(k.aborted)wh(h,k.reason);else{var m=function(){wh(h,k.reason);k.removeEventListener("abort",m)};k.addEventListener("abort",m)}}th(h)})};
-exports.renderToReadableStream=function(a,b){return new Promise(function(c,d){var e,f,g=new Promise(function(y,C){f=y;e=C}),h=b?b.onHeaders:void 0,k;h&&(k=function(y){h(new Headers(y))});var m=Kb(b?b.identifierPrefix:void 0,b?b.unstable_externalRuntimeSrc:void 0),p=Lg(a,m,Ab(m,b?b.nonce:void 0,b?b.bootstrapScriptContent:void 0,b?b.bootstrapScripts:void 0,b?b.bootstrapModules:void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.importMap:void 0,k,b?b.maxHeadersLength:void 0),Lb(b?b.namespaceURI:void 0),
-b?b.progressiveChunkSize:void 0,b?b.onError:void 0,f,function(){var y=new ReadableStream({type:"bytes",pull:function(C){vh(p,C)},cancel:function(C){p.destination=null;wh(p,C)}},{highWaterMark:0});y.allReady=g;c(y)},function(y){g.catch(function(){});d(y)},e,b?b.onPostpone:void 0,b?b.formState:void 0);if(b&&b.signal){var t=b.signal;if(t.aborted)wh(p,t.reason);else{var q=function(){wh(p,t.reason);t.removeEventListener("abort",q)};t.addEventListener("abort",q)}}th(p)})};
-exports.resume=function(a,b,c){return new Promise(function(d,e){var f,g,h=new Promise(function(t,q){g=t;f=q}),k=Pg(a,b,Ab(b.resumableState,c?c.nonce:void 0,void 0,void 0,void 0,void 0,void 0,void 0),c?c.onError:void 0,g,function(){var t=new ReadableStream({type:"bytes",pull:function(q){vh(k,q)},cancel:function(q){k.destination=null;wh(k,q)}},{highWaterMark:0});t.allReady=h;d(t)},function(t){h.catch(function(){});e(t)},f,c?c.onPostpone:void 0);if(c&&c.signal){var m=c.signal;if(m.aborted)wh(k,m.reason);
-else{var p=function(){wh(k,m.reason);m.removeEventListener("abort",p)};m.addEventListener("abort",p)}}th(k)})};exports.version="18.3.0-experimental-2983249dd-20231107";
+exports.renderToReadableStream=function(a,b){return new Promise(function(c,d){var e,f,g=new Promise(function(y,C){f=y;e=C}),h=b?b.onHeaders:void 0,k;h&&(k=function(y){h(new Headers(y))});var m=Kb(b?b.identifierPrefix:void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.bootstrapScriptContent:void 0,b?b.bootstrapScripts:void 0,b?b.bootstrapModules:void 0),p=Lg(a,m,Ab(m,b?b.nonce:void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.importMap:void 0,k,b?b.maxHeadersLength:void 0),Lb(b?b.namespaceURI:void 0),
+b?b.progressiveChunkSize:void 0,b?b.onError:void 0,f,function(){var y=new ReadableStream({type:"bytes",pull:function(C){vh(p,C)},cancel:function(C){p.destination=null;wh(p,C)}},{highWaterMark:0});y.allReady=g;c(y)},function(y){g.catch(function(){});d(y)},e,b?b.onPostpone:void 0,b?b.formState:void 0);if(b&&b.signal){var t=b.signal;if(t.aborted)wh(p,t.reason);else{var r=function(){wh(p,t.reason);t.removeEventListener("abort",r)};t.addEventListener("abort",r)}}th(p)})};
+exports.resume=function(a,b,c){return new Promise(function(d,e){var f,g,h=new Promise(function(t,r){g=t;f=r}),k=Pg(a,b,Ab(b.resumableState,c?c.nonce:void 0,void 0,void 0,void 0,void 0),c?c.onError:void 0,g,function(){var t=new ReadableStream({type:"bytes",pull:function(r){vh(k,r)},cancel:function(r){k.destination=null;wh(k,r)}},{highWaterMark:0});t.allReady=h;d(t)},function(t){h.catch(function(){});e(t)},f,c?c.onPostpone:void 0);if(c&&c.signal){var m=c.signal;if(m.aborted)wh(k,m.reason);else{var p=
+function(){wh(k,m.reason);m.removeEventListener("abort",p)};m.addEventListener("abort",p)}}th(k)})};exports.version="18.3.0-experimental-7508dcd5c-20231108";
+
+//# sourceMappingURL=react-dom-server.edge.production.min.js.map
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.node.development.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.node.development.js
index e20a3f1bf6243..3f0386870ce06 100644
--- a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.node.development.js
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.node.development.js
@@ -21,7 +21,7 @@ var async_hooks = require('async_hooks');
 var ReactDOM = require('react-dom');
 var stream = require('stream');
 
-var ReactVersion = '18.3.0-experimental-2983249dd-20231107';
+var ReactVersion = '18.3.0-experimental-7508dcd5c-20231108';
 
 var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
 
@@ -1799,11 +1799,14 @@ var DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS = 2000; // Allows us to keep tr
 // if passed externalRuntimeConfig and the enableFizzExternalRuntime feature flag
 // is set, the server will send instructions via data attributes (instead of inline scripts)
 
-function createRenderState(resumableState, nonce, bootstrapScriptContent, bootstrapScripts, bootstrapModules, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
+function createRenderState(resumableState, nonce, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
   var inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
   var idPrefix = resumableState.idPrefix;
   var bootstrapChunks = [];
   var externalRuntimeScript = null;
+  var bootstrapScriptContent = resumableState.bootstrapScriptContent,
+      bootstrapScripts = resumableState.bootstrapScripts,
+      bootstrapModules = resumableState.bootstrapModules;
 
   if (bootstrapScriptContent !== undefined) {
     bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapAndImportMapScriptContent(bootstrapScriptContent)), endInlineScript);
@@ -1993,10 +1996,9 @@ function createRenderState(resumableState, nonce, bootstrapScriptContent, bootst
   return renderState;
 }
 function resumeRenderState(resumableState, nonce) {
-  return createRenderState(resumableState, nonce, // These should have already been flushed in the prerender.
-  undefined, undefined, undefined, undefined, undefined, undefined);
+  return createRenderState(resumableState, nonce, undefined, undefined, undefined, undefined);
 }
-function createResumableState(identifierPrefix, externalRuntimeConfig) {
+function createResumableState(identifierPrefix, externalRuntimeConfig, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
   var idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
   var streamingFormat = ScriptStreamingFormat;
 
@@ -2010,6 +2012,9 @@ function createResumableState(identifierPrefix, externalRuntimeConfig) {
     idPrefix: idPrefix,
     nextFormID: 0,
     streamingFormat: streamingFormat,
+    bootstrapScriptContent: bootstrapScriptContent,
+    bootstrapScripts: bootstrapScripts,
+    bootstrapModules: bootstrapModules,
     instructions: NothingSent,
     hasBody: false,
     hasHtml: false,
@@ -4495,7 +4500,10 @@ function pushEndInstance(target, type, props, resumableState, formatContext) {
   target.push(endChunkForTag(type));
 }
 
-function writeBootstrap(destination, renderState) {
+function writeBootstrap(destination, renderState, resumableState) {
+  resumableState.bootstrapScriptContent = undefined;
+  resumableState.bootstrapScripts = undefined;
+  resumableState.bootstrapModules = undefined;
   var bootstrapChunks = renderState.bootstrapChunks;
   var i = 0;
 
@@ -4512,8 +4520,8 @@ function writeBootstrap(destination, renderState) {
   return true;
 }
 
-function writeCompletedRoot(destination, renderState) {
-  return writeBootstrap(destination, renderState);
+function writeCompletedRoot(destination, renderState, resumableState) {
+  return writeBootstrap(destination, renderState, resumableState);
 } // Structural Nodes
 // A placeholder is a node inside a hidden partial tree that can be filled in later, but before
 // display. It's never visible to users. We use the template tag because it can be used in every
@@ -4870,7 +4878,7 @@ function writeCompletedBoundaryInstruction(destination, resumableState, renderSt
     writeMore = writeChunkAndReturn(destination, completeBoundaryDataEnd);
   }
 
-  return writeBootstrap(destination, renderState) && writeMore;
+  return writeBootstrap(destination, renderState, resumableState) && writeMore;
 }
 var clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
 var clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
@@ -6878,6 +6886,18 @@ var componentFrameCache;
   var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
   componentFrameCache = new PossiblyWeakMap();
 }
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
@@ -6893,7 +6913,6 @@ function describeNativeComponentFrame(fn, construct) {
     }
   }
 
-  var control;
   reentry = true;
   var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
 
@@ -6907,81 +6926,140 @@ function describeNativeComponentFrame(fn, construct) {
     ReactCurrentDispatcher$1.current = null;
     disableLogs();
   }
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
 
-  try {
-    // This should throw.
-    if (construct) {
-      // Something should be setting the props in the constructor.
-      var Fake = function () {
-        throw Error();
-      }; // $FlowFixMe[prop-missing]
 
+  var RunInRootFrame = {
+    DetermineComponentFrameRoot: function () {
+      var control;
 
-      Object.defineProperty(Fake.prototype, 'props', {
-        set: function () {
-          // We use a throwing setter instead of frozen or non-writable props
-          // because that won't throw in a non-strict mode function.
-          throw Error();
-        }
-      });
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          var Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
 
-      if (typeof Reflect === 'object' && Reflect.construct) {
-        // We construct a different control for this case to include any extra
-        // frames added by the construct call.
-        try {
-          Reflect.construct(Fake, []);
-        } catch (x) {
-          control = x;
-        }
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
 
-        Reflect.construct(fn, [], Fake);
-      } else {
-        try {
-          Fake.call();
-        } catch (x) {
-          control = x;
-        } // $FlowFixMe[prop-missing] found when upgrading Flow
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
 
 
-        fn.call(Fake.prototype);
-      }
-    } else {
-      try {
-        throw Error();
-      } catch (x) {
-        control = x;
-      } // TODO(luna): This will currently only throw if the function component
-      // tries to access React/ReactDOM/props. We should probably make this throw
-      // in simple components too
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
 
 
-      var maybePromise = fn(); // If the function component returns a promise, it's likely an async
-      // component, which we don't yet support. Attach a noop catch handler to
-      // silence the error.
-      // TODO: Implement component stacks for async client components?
+          var maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
 
-      if (maybePromise && typeof maybePromise.catch === 'function') {
-        maybePromise.catch(function () {});
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(function () {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
       }
+
+      return [null, null];
     }
-  } catch (sample) {
-    // This is inlined manually because closure doesn't do it for us.
-    if (sample && control && typeof sample.stack === 'string') {
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
+
+  try {
+    var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
+
+    if (sampleStack && controlStack) {
       // This extracts the first frame from the sample that isn't also in the control.
       // Skipping one frame that we assume is the frame that calls the two.
-      var sampleLines = sample.stack.split('\n');
-      var controlLines = control.stack.split('\n');
-      var s = sampleLines.length - 1;
-      var c = controlLines.length - 1;
-
-      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
-        // We expect at least one stack frame to be shared.
-        // Typically this will be the root most one. However, stack frames may be
-        // cut off due to maximum stack limits. In this case, one maybe cut off
-        // earlier than the other. We assume that the sample is longer or the same
-        // and there for cut off earlier. So we should find the root most frame in
-        // the sample somewhere in the control.
-        c--;
+      var sampleLines = sampleStack.split('\n');
+      var controlLines = controlStack.split('\n');
+      var s = 0;
+      var c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
       }
 
       for (; s >= 1 && c >= 0; s--, c--) {
@@ -7010,7 +7088,7 @@ function describeNativeComponentFrame(fn, construct) {
                   _frame = _frame.replace('<anonymous>', fn.displayName);
                 }
 
-                {
+                if (true) {
                   if (typeof fn === 'function') {
                     componentFrameCache.set(fn, _frame);
                   }
@@ -11686,7 +11764,7 @@ function flushCompletedQueues(request, destination) {
 
         flushSegment(request, destination, completedRootSegment);
         request.completedRootSegment = null;
-        writeCompletedRoot(destination, request.renderState);
+        writeCompletedRoot(destination, request.renderState, request.resumableState);
       } else {
         // We haven't flushed the root yet so we don't need to check any other branches further down
         return;
@@ -11990,8 +12068,8 @@ function createCancelHandler(request, reason) {
 }
 
 function createRequestImpl(children, options) {
-  var resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined);
-  return createRequest(children, resumableState, createRenderState(resumableState, options ? options.nonce : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, options ? options.onHeaders : undefined, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, options ? options.onAllReady : undefined, options ? options.onShellReady : undefined, options ? options.onShellError : undefined, undefined, options ? options.onPostpone : undefined, options ? options.formState : undefined);
+  var resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined);
+  return createRequest(children, resumableState, createRenderState(resumableState, options ? options.nonce : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, options ? options.onHeaders : undefined, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, options ? options.onAllReady : undefined, options ? options.onShellReady : undefined, options ? options.onShellError : undefined, undefined, options ? options.onPostpone : undefined, options ? options.formState : undefined);
 }
 
 function renderToPipeableStream(children, options) {
@@ -12079,9 +12157,9 @@ function prerenderToNodeStream(children, options) {
       resolve(result);
     }
 
-    var resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined);
+    var resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined);
     var request = createPrerenderRequest(children, resumableState, createRenderState(resumableState, undefined, // nonce is not compatible with prerendered bootstrap scripts
-    options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, options ? options.onHeaders : undefined, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, undefined, undefined, onFatalError, options ? options.onPostpone : undefined);
+    options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, options ? options.onHeaders : undefined, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, undefined, undefined, onFatalError, options ? options.onPostpone : undefined);
 
     if (options && options.signal) {
       var signal = options.signal;
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.node.production.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.node.production.js
new file mode 100644
index 0000000000000..f52554119f92f
--- /dev/null
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.node.production.js
@@ -0,0 +1,9052 @@
+/**
+ * @license React
+ * react-dom-server.node.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var util = require('util');
+var crypto = require('crypto');
+var async_hooks = require('async_hooks');
+var React = require("next/dist/compiled/react-experimental");
+var ReactDOM = require('react-dom');
+var stream = require('stream');
+
+var ReactVersion = '18.3.0-experimental-7508dcd5c-20231108';
+
+function scheduleWork(callback) {
+  setImmediate(callback);
+}
+function flushBuffered(destination) {
+  // If we don't have any more data to send right now.
+  // Flush whatever is in the buffer to the wire.
+  if (typeof destination.flush === 'function') {
+    // By convention the Zlib streams provide a flush function for this purpose.
+    // For Express, compression middleware adds this method.
+    destination.flush();
+  }
+}
+const VIEW_SIZE = 2048;
+let currentView = null;
+let writtenBytes = 0;
+let destinationHasCapacity$1 = true;
+function beginWriting(destination) {
+  currentView = new Uint8Array(VIEW_SIZE);
+  writtenBytes = 0;
+  destinationHasCapacity$1 = true;
+}
+
+function writeStringChunk(destination, stringChunk) {
+  if (stringChunk.length === 0) {
+    return;
+  } // maximum possible view needed to encode entire string
+
+
+  if (stringChunk.length * 3 > VIEW_SIZE) {
+    if (writtenBytes > 0) {
+      writeToDestination(destination, currentView.subarray(0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    writeToDestination(destination, textEncoder.encode(stringChunk));
+    return;
+  }
+
+  let target = currentView;
+
+  if (writtenBytes > 0) {
+    target = currentView.subarray(writtenBytes);
+  }
+
+  const _textEncoder$encodeIn = textEncoder.encodeInto(stringChunk, target),
+        read = _textEncoder$encodeIn.read,
+        written = _textEncoder$encodeIn.written;
+
+  writtenBytes += written;
+
+  if (read < stringChunk.length) {
+    writeToDestination(destination, currentView.subarray(0, writtenBytes));
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = textEncoder.encodeInto(stringChunk.slice(read), currentView).written;
+  }
+
+  if (writtenBytes === VIEW_SIZE) {
+    writeToDestination(destination, currentView);
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+}
+
+function writeViewChunk(destination, chunk) {
+  if (chunk.byteLength === 0) {
+    return;
+  }
+
+  if (chunk.byteLength > VIEW_SIZE) {
+    // one that is cached by the streaming renderer. We will enqueu
+    // it directly and expect it is not re-used
+
+
+    if (writtenBytes > 0) {
+      writeToDestination(destination, currentView.subarray(0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    writeToDestination(destination, chunk);
+    return;
+  }
+
+  let bytesToWrite = chunk;
+  const allowableBytes = currentView.length - writtenBytes;
+
+  if (allowableBytes < bytesToWrite.byteLength) {
+    // this chunk would overflow the current view. We enqueue a full view
+    // and start a new view with the remaining chunk
+    if (allowableBytes === 0) {
+      // the current view is already full, send it
+      writeToDestination(destination, currentView);
+    } else {
+      // fill up the current view and apply the remaining chunk bytes
+      // to a new view.
+      currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes);
+      writtenBytes += allowableBytes;
+      writeToDestination(destination, currentView);
+      bytesToWrite = bytesToWrite.subarray(allowableBytes);
+    }
+
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+
+  currentView.set(bytesToWrite, writtenBytes);
+  writtenBytes += bytesToWrite.byteLength;
+
+  if (writtenBytes === VIEW_SIZE) {
+    writeToDestination(destination, currentView);
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+}
+
+function writeChunk(destination, chunk) {
+  if (typeof chunk === 'string') {
+    writeStringChunk(destination, chunk);
+  } else {
+    writeViewChunk(destination, chunk);
+  }
+}
+
+function writeToDestination(destination, view) {
+  const currentHasCapacity = destination.write(view);
+  destinationHasCapacity$1 = destinationHasCapacity$1 && currentHasCapacity;
+}
+
+function writeChunkAndReturn(destination, chunk) {
+  writeChunk(destination, chunk);
+  return destinationHasCapacity$1;
+}
+function completeWriting(destination) {
+  if (currentView && writtenBytes > 0) {
+    destination.write(currentView.subarray(0, writtenBytes));
+  }
+
+  currentView = null;
+  writtenBytes = 0;
+  destinationHasCapacity$1 = true;
+}
+function close(destination) {
+  destination.end();
+}
+const textEncoder = new util.TextEncoder();
+function stringToChunk(content) {
+  return content;
+}
+function stringToPrecomputedChunk(content) {
+  const precomputedChunk = textEncoder.encode(content);
+
+  return precomputedChunk;
+}
+function clonePrecomputedChunk(precomputedChunk) {
+  return precomputedChunk.length > VIEW_SIZE ? precomputedChunk.slice() : precomputedChunk;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+  destination.destroy(error);
+}
+function createFastHash(input) {
+  const hash = crypto.createHash('md5');
+  hash.update(input);
+  return hash.digest('hex');
+}
+
+const assign = Object.assign;
+
+// -----------------------------------------------------------------------------
+const enableFloat = true; // Enables unstable_useMemoCache hook, intended as a compilation target for
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/* eslint-disable max-len */
+
+const ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
+/* eslint-enable max-len */
+
+const ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
+const VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+const illegalAttributeNameCache = {};
+const validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+  if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+    return true;
+  }
+
+  if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+    return false;
+  }
+
+  if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+    validatedAttributeNameCache[attributeName] = true;
+    return true;
+  }
+
+  illegalAttributeNameCache[attributeName] = true;
+
+  return false;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+const unitlessNumbers = new Set(['animationIterationCount', 'aspectRatio', 'borderImageOutset', 'borderImageSlice', 'borderImageWidth', 'boxFlex', 'boxFlexGroup', 'boxOrdinalGroup', 'columnCount', 'columns', 'flex', 'flexGrow', 'flexPositive', 'flexShrink', 'flexNegative', 'flexOrder', 'gridArea', 'gridRow', 'gridRowEnd', 'gridRowSpan', 'gridRowStart', 'gridColumn', 'gridColumnEnd', 'gridColumnSpan', 'gridColumnStart', 'fontWeight', 'lineClamp', 'lineHeight', 'opacity', 'order', 'orphans', 'scale', 'tabSize', 'widows', 'zIndex', 'zoom', 'fillOpacity', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'MozBoxFlexGroup', 'MozLineClamp', 'msAnimationIterationCount', 'msFlex', 'msZoom', 'msFlexGrow', 'msFlexNegative', 'msFlexOrder', 'msFlexPositive', 'msFlexShrink', 'msGridColumn', 'msGridColumnSpan', 'msGridRow', 'msGridRowSpan', 'WebkitAnimationIterationCount', 'WebkitBoxFlex', 'WebKitBoxFlexGroup', 'WebkitBoxOrdinalGroup', 'WebkitColumnCount', 'WebkitColumns', 'WebkitFlex', 'WebkitFlexGrow', 'WebkitFlexPositive', 'WebkitFlexShrink', 'WebkitLineClamp']);
+function isUnitlessNumber (name) {
+  return unitlessNumbers.has(name);
+}
+
+const aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+  return aliases.get(name) || name;
+}
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// code copied and modified from escape-html
+const matchHtmlRegExp = /["'&<>]/;
+/**
+ * Escapes special characters and HTML entities in a given html string.
+ *
+ * @param  {string} string HTML string to escape for later insertion
+ * @return {string}
+ * @public
+ */
+
+function escapeHtml(string) {
+
+  const str = '' + string;
+  const match = matchHtmlRegExp.exec(str);
+
+  if (!match) {
+    return str;
+  }
+
+  let escape;
+  let html = '';
+  let index;
+  let lastIndex = 0;
+
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        // "
+        escape = '&quot;';
+        break;
+
+      case 38:
+        // &
+        escape = '&amp;';
+        break;
+
+      case 39:
+        // '
+        escape = '&#x27;'; // modified from escape-html; used to be '&#39'
+
+        break;
+
+      case 60:
+        // <
+        escape = '&lt;';
+        break;
+
+      case 62:
+        // >
+        escape = '&gt;';
+        break;
+
+      default:
+        continue;
+    }
+
+    if (lastIndex !== index) {
+      html += str.slice(lastIndex, index);
+    }
+
+    lastIndex = index + 1;
+    html += escape;
+  }
+
+  return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+} // end code copied and modified from escape-html
+
+/**
+ * Escapes text to prevent scripting attacks.
+ *
+ * @param {*} text Text value to escape.
+ * @return {string} An escaped string.
+ */
+
+
+function escapeTextForBrowser(text) {
+  if (typeof text === 'boolean' || typeof text === 'number') {
+    // this shortcircuit helps perf for types that we know will never have
+    // special characters, especially given that this function is used often
+    // for numeric dom ids.
+    return '' + text;
+  }
+
+  return escapeHtml(text);
+}
+
+const uppercasePattern = /([A-Z])/g;
+const msPattern = /^ms-/;
+/**
+ * Hyphenates a camelcased CSS property name, for example:
+ *
+ *   > hyphenateStyleName('backgroundColor')
+ *   < "background-color"
+ *   > hyphenateStyleName('MozTransition')
+ *   < "-moz-transition"
+ *   > hyphenateStyleName('msTransition')
+ *   < "-ms-transition"
+ *
+ * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
+ * is converted to `-ms-`.
+ */
+
+function hyphenateStyleName(name) {
+  return name.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern, '-ms-');
+}
+
+function sanitizeURL(url) {
+
+  return url;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+// The build script is at scripts/rollup/generate-inline-fizz-runtime.js.
+// Run `yarn generate-inline-fizz-runtime` to generate.
+const clientRenderBoundary = '$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};';
+const completeBoundary = '$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};';
+const completeBoundaryWithStyles = '$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};';
+const completeSegment = '$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};';
+const formReplaying = 'addEventListener("submit",function(a){if(!a.defaultPrevented){var c=a.target,d=a.submitter,e=c.action,b=d;if(d){var f=d.getAttribute("formAction");null!=f&&(e=f,b=null)}"javascript:throw new Error(\'A React form was unexpectedly submitted.\')"===e&&(a.preventDefault(),b?(a=document.createElement("input"),a.name=b.name,a.value=b.value,b.parentNode.insertBefore(a,b),b=new FormData(c),a.parentNode.removeChild(a)):b=new FormData(c),a=c.getRootNode(),(a.$$reactFormReplay=a.$$reactFormReplay||[]).push(c,\nd,b))}});';
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+// same object across all transitions.
+
+const sharedNotPendingObject = {
+  pending: false,
+  data: null,
+  method: null,
+  action: null
+};
+const NotPending = sharedNotPendingObject;
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+const ReactDOMServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMServerDispatcher;
+} // We make every property of the descriptor optional because it is not a contract that
+const ScriptStreamingFormat = 0;
+const DataStreamingFormat = 1;
+const NothingSent
+/*                      */
+= 0b00000;
+const SentCompleteSegmentFunction
+/*      */
+= 0b00001;
+const SentCompleteBoundaryFunction
+/*     */
+= 0b00010;
+const SentClientRenderFunction
+/*         */
+= 0b00100;
+const SentStyleInsertionFunction
+/*       */
+= 0b01000;
+const SentFormReplayingRuntime
+/*         */
+= 0b10000; // Per request, global state that is not contextual to the rendering subtree.
+// This cannot be resumed and therefore should only contain things that are
+// temporary working state or are never used in the prerender pass.
+// Credentials here are things that affect whether a browser will make a request
+// as well as things that affect which connection the browser will use for that request.
+// We want these to be aligned across preloads and resources because otherwise the preload
+// will be wasted.
+// We investigated whether referrerPolicy should be included here but from experimentation
+// it seems that browsers do not treat this as part of the http cache key and does not affect
+// which connection is used.
+
+const EXISTS = null; // This constant is to mark preloads that have no unique credentials
+// to convey. It should never be checked by identity and we should not
+// assume Preload values in ResumableState equal this value because they
+// will have come from some parsed input.
+
+const PRELOAD_NO_CREDS = [];
+// This is resumable and therefore should be serializable.
+
+
+const dataElementQuotedEnd = stringToPrecomputedChunk('"></template>');
+const startInlineScript = stringToPrecomputedChunk('<script>');
+const endInlineScript = stringToPrecomputedChunk('</script>');
+const startScriptSrc = stringToPrecomputedChunk('<script src="');
+const startModuleSrc = stringToPrecomputedChunk('<script type="module" src="');
+const scriptNonce = stringToPrecomputedChunk('" nonce="');
+const scriptIntegirty = stringToPrecomputedChunk('" integrity="');
+const scriptCrossOrigin = stringToPrecomputedChunk('" crossorigin="');
+const endAsyncScript = stringToPrecomputedChunk('" async=""></script>');
+/**
+ * This escaping function is designed to work with bootstrapScriptContent and importMap only.
+ * because we know we are escaping the entire script. We can avoid for instance
+ * escaping html comment string sequences that are valid javascript as well because
+ * if there are no sebsequent <script sequences the html parser will never enter
+ * script data double escaped state (see: https://www.w3.org/TR/html53/syntax.html#script-data-double-escaped-state)
+ *
+ * While untrusted script content should be made safe before using this api it will
+ * ensure that the script cannot be early terminated or never terminated state
+ */
+
+function escapeBootstrapAndImportMapScriptContent(scriptText) {
+
+  return ('' + scriptText).replace(scriptRegex, scriptReplacer);
+}
+
+const scriptRegex = /(<\/|<)(s)(cript)/gi;
+
+const scriptReplacer = (match, prefix, s, suffix) => "" + prefix + (s === 's' ? '\\u0073' : '\\u0053') + suffix;
+
+const importMapScriptStart = stringToPrecomputedChunk('<script type="importmap">');
+const importMapScriptEnd = stringToPrecomputedChunk('</script>'); // Since we store headers as strings we deal with their length in utf16 code units
+// rather than visual characters or the utf8 encoding that is used for most binary
+// serialization. Some common HTTP servers only allow for headers to be 4kB in length.
+// We choose a default length that is likely to be well under this already limited length however
+// pathological cases may still cause the utf-8 encoding of the headers to approach this limit.
+// It should also be noted that this maximum is a soft maximum. we have not reached the limit we will
+// allow one more header to be captured which means in practice if the limit is approached it will be exceeded
+
+const DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS = 2000; // Allows us to keep track of what we've already written so we can refer back to it.
+// if passed externalRuntimeConfig and the enableFizzExternalRuntime feature flag
+// is set, the server will send instructions via data attributes (instead of inline scripts)
+
+function createRenderState(resumableState, nonce, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
+  const inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
+  const idPrefix = resumableState.idPrefix;
+  const bootstrapChunks = [];
+  let externalRuntimeScript = null;
+  const bootstrapScriptContent = resumableState.bootstrapScriptContent,
+        bootstrapScripts = resumableState.bootstrapScripts,
+        bootstrapModules = resumableState.bootstrapModules;
+
+  if (bootstrapScriptContent !== undefined) {
+    bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapAndImportMapScriptContent(bootstrapScriptContent)), endInlineScript);
+  }
+
+  {
+
+    if (externalRuntimeConfig !== undefined) {
+      if (typeof externalRuntimeConfig === 'string') {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig,
+          async: true,
+          integrity: undefined,
+          nonce: nonce
+        });
+      } else {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig.src,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig.src,
+          async: true,
+          integrity: externalRuntimeConfig.integrity,
+          nonce: nonce
+        });
+      }
+    }
+  }
+
+  const importMapChunks = [];
+
+  if (importMap !== undefined) {
+    const map = importMap;
+    importMapChunks.push(importMapScriptStart);
+    importMapChunks.push(stringToChunk(escapeBootstrapAndImportMapScriptContent(JSON.stringify(map))));
+    importMapChunks.push(importMapScriptEnd);
+  }
+
+  const headers = onHeaders ? {
+    preconnects: '',
+    fontPreloads: '',
+    highImagePreloads: '',
+    remainingCapacity: typeof maxHeadersLength === 'number' ? maxHeadersLength : DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS
+  } : null;
+  const renderState = {
+    placeholderPrefix: stringToPrecomputedChunk(idPrefix + 'P:'),
+    segmentPrefix: stringToPrecomputedChunk(idPrefix + 'S:'),
+    boundaryPrefix: stringToPrecomputedChunk(idPrefix + 'B:'),
+    startInlineScript: inlineScriptWithNonce,
+    htmlChunks: null,
+    headChunks: null,
+    externalRuntimeScript: externalRuntimeScript,
+    bootstrapChunks: bootstrapChunks,
+    onHeaders,
+    headers,
+    resets: {
+      font: {},
+      dns: {},
+      connect: {
+        default: {},
+        anonymous: {},
+        credentials: {}
+      },
+      image: {},
+      style: {}
+    },
+    charsetChunks: [],
+    preconnectChunks: [],
+    importMapChunks,
+    preloadChunks: [],
+    hoistableChunks: [],
+    // cleared on flush
+    preconnects: new Set(),
+    fontPreloads: new Set(),
+    highImagePreloads: new Set(),
+    // usedImagePreloads: new Set(),
+    styles: new Map(),
+    bootstrapScripts: new Set(),
+    scripts: new Set(),
+    bulkPreloads: new Set(),
+    preloads: {
+      images: new Map(),
+      stylesheets: new Map(),
+      scripts: new Map(),
+      moduleScripts: new Map()
+    },
+    nonce,
+    // like a module global for currently rendering boundary
+    boundaryResources: null,
+    stylesToHoist: false
+  };
+
+  if (bootstrapScripts !== undefined) {
+    for (let i = 0; i < bootstrapScripts.length; i++) {
+      const scriptConfig = bootstrapScripts[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'preload',
+        as: 'script',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startScriptSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  if (bootstrapModules !== undefined) {
+    for (let i = 0; i < bootstrapModules.length; i++) {
+      const scriptConfig = bootstrapModules[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'modulepreload',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startModuleSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  return renderState;
+}
+function resumeRenderState(resumableState, nonce) {
+  return createRenderState(resumableState, nonce, undefined, undefined, undefined, undefined);
+}
+function createResumableState(identifierPrefix, externalRuntimeConfig, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
+  const idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
+  let streamingFormat = ScriptStreamingFormat;
+
+  {
+    if (externalRuntimeConfig !== undefined) {
+      streamingFormat = DataStreamingFormat;
+    }
+  }
+
+  return {
+    idPrefix: idPrefix,
+    nextFormID: 0,
+    streamingFormat,
+    bootstrapScriptContent,
+    bootstrapScripts,
+    bootstrapModules,
+    instructions: NothingSent,
+    hasBody: false,
+    hasHtml: false,
+    // @TODO add bootstrap script to implicit preloads
+    // persistent
+    unknownResources: {},
+    dnsResources: {},
+    connectResources: {
+      default: {},
+      anonymous: {},
+      credentials: {}
+    },
+    imageResources: {},
+    styleResources: {},
+    scriptResources: {},
+    moduleUnknownResources: {},
+    moduleScriptResources: {}
+  };
+}
+function resetResumableState(resumableState, renderState) {
+  // Resets the resumable state based on what didn't manage to fully flush in the render state.
+  // This currently assumes nothing was flushed.
+  resumableState.nextFormID = 0;
+  resumableState.hasBody = false;
+  resumableState.hasHtml = false;
+  resumableState.unknownResources = {
+    font: renderState.resets.font
+  };
+  resumableState.dnsResources = renderState.resets.dns;
+  resumableState.connectResources = renderState.resets.connect;
+  resumableState.imageResources = renderState.resets.image;
+  resumableState.styleResources = renderState.resets.style;
+  resumableState.scriptResources = {};
+  resumableState.moduleUnknownResources = {};
+  resumableState.moduleScriptResources = {};
+} // Constants for the insertion mode we're currently writing in. We don't encode all HTML5 insertion
+// modes. We only include the variants as they matter for the sake of our purposes.
+// We don't actually provide the namespace therefore we use constants instead of the string.
+
+const ROOT_HTML_MODE = 0; // Used for the root most element tag.
+// We have a less than HTML_HTML_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const HTML_HTML_MODE = 1; // Used for the <html> if it is at the top level.
+
+const HTML_MODE = 2;
+const SVG_MODE = 3;
+const MATHML_MODE = 4;
+const HTML_TABLE_MODE = 5;
+const HTML_TABLE_BODY_MODE = 6;
+const HTML_TABLE_ROW_MODE = 7;
+const HTML_COLGROUP_MODE = 8; // We have a greater than HTML_TABLE_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const NO_SCOPE =
+/*         */
+0b00;
+const NOSCRIPT_SCOPE =
+/*   */
+0b01;
+const PICTURE_SCOPE =
+/*    */
+0b10; // Lets us keep track of contextual state and pick it back up after suspending.
+
+function createFormatContext(insertionMode, selectedValue, tagScope) {
+  return {
+    insertionMode,
+    selectedValue,
+    tagScope
+  };
+}
+
+function createRootFormatContext(namespaceURI) {
+  const insertionMode = namespaceURI === 'http://www.w3.org/2000/svg' ? SVG_MODE : namespaceURI === 'http://www.w3.org/1998/Math/MathML' ? MATHML_MODE : ROOT_HTML_MODE;
+  return createFormatContext(insertionMode, null, NO_SCOPE);
+}
+function getChildFormatContext(parentContext, type, props) {
+  switch (type) {
+    case 'noscript':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | NOSCRIPT_SCOPE);
+
+    case 'select':
+      return createFormatContext(HTML_MODE, props.value != null ? props.value : props.defaultValue, parentContext.tagScope);
+
+    case 'svg':
+      return createFormatContext(SVG_MODE, null, parentContext.tagScope);
+
+    case 'picture':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | PICTURE_SCOPE);
+
+    case 'math':
+      return createFormatContext(MATHML_MODE, null, parentContext.tagScope);
+
+    case 'foreignObject':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    // Table parents are special in that their children can only be created at all if they're
+    // wrapped in a table parent. So we need to encode that we're entering this mode.
+
+    case 'table':
+      return createFormatContext(HTML_TABLE_MODE, null, parentContext.tagScope);
+
+    case 'thead':
+    case 'tbody':
+    case 'tfoot':
+      return createFormatContext(HTML_TABLE_BODY_MODE, null, parentContext.tagScope);
+
+    case 'colgroup':
+      return createFormatContext(HTML_COLGROUP_MODE, null, parentContext.tagScope);
+
+    case 'tr':
+      return createFormatContext(HTML_TABLE_ROW_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode >= HTML_TABLE_MODE) {
+    // Whatever tag this was, it wasn't a table parent or other special parent, so we must have
+    // entered plain HTML again.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode === ROOT_HTML_MODE) {
+    if (type === 'html') {
+      // We've emitted the root and is now in <html> mode.
+      return createFormatContext(HTML_HTML_MODE, null, parentContext.tagScope);
+    } else {
+      // We've emitted the root and is now in plain HTML mode.
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    }
+  } else if (parentContext.insertionMode === HTML_HTML_MODE) {
+    // We've emitted the document element and is now in plain HTML mode.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  return parentContext;
+}
+function makeId(resumableState, treeId, localId) {
+  const idPrefix = resumableState.idPrefix;
+  let id = ':' + idPrefix + 'R' + treeId; // Unless this is the first id at this level, append a number at the end
+  // that represents the position of this useId hook among all the useId
+  // hooks for this fiber.
+
+  if (localId > 0) {
+    id += 'H' + localId.toString(32);
+  }
+
+  return id + ':';
+}
+
+function encodeHTMLTextNode(text) {
+  return escapeTextForBrowser(text);
+}
+
+const textSeparator = stringToPrecomputedChunk('<!-- -->');
+function pushTextInstance(target, text, renderState, textEmbedded) {
+  if (text === '') {
+    // Empty text doesn't have a DOM node representation and the hydration is aware of this.
+    return textEmbedded;
+  }
+
+  if (textEmbedded) {
+    target.push(textSeparator);
+  }
+
+  target.push(stringToChunk(encodeHTMLTextNode(text)));
+  return true;
+} // Called when Fizz is done with a Segment. Currently the only purpose is to conditionally
+// emit a text separator when we don't know for sure it is safe to omit
+
+function pushSegmentFinale(target, renderState, lastPushedText, textEmbedded) {
+  if (lastPushedText && textEmbedded) {
+    target.push(textSeparator);
+  }
+}
+const styleNameCache = new Map();
+
+function processStyleName(styleName) {
+  const chunk = styleNameCache.get(styleName);
+
+  if (chunk !== undefined) {
+    return chunk;
+  }
+
+  const result = stringToPrecomputedChunk(escapeTextForBrowser(hyphenateStyleName(styleName)));
+  styleNameCache.set(styleName, result);
+  return result;
+}
+
+const styleAttributeStart = stringToPrecomputedChunk(' style="');
+const styleAssign = stringToPrecomputedChunk(':');
+const styleSeparator = stringToPrecomputedChunk(';');
+
+function pushStyleAttribute(target, style) {
+  if (typeof style !== 'object') {
+    throw new Error('The `style` prop expects a mapping from style properties to values, ' + "not a string. For example, style={{marginRight: spacing + 'em'}} when " + 'using JSX.');
+  }
+
+  let isFirst = true;
+
+  for (const styleName in style) {
+    if (!hasOwnProperty.call(style, styleName)) {
+      continue;
+    } // If you provide unsafe user data here they can inject arbitrary CSS
+    // which may be problematic (I couldn't repro this):
+    // https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet
+    // http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/
+    // This is not an XSS hole but instead a potential CSS injection issue
+    // which has lead to a greater discussion about how we're going to
+    // trust URLs moving forward. See #2115901
+
+
+    const styleValue = style[styleName];
+
+    if (styleValue == null || typeof styleValue === 'boolean' || styleValue === '') {
+      // TODO: We used to set empty string as a style with an empty value. Does that ever make sense?
+      continue;
+    }
+
+    let nameChunk;
+    let valueChunk;
+    const isCustomProperty = styleName.indexOf('--') === 0;
+
+    if (isCustomProperty) {
+      nameChunk = stringToChunk(escapeTextForBrowser(styleName));
+
+      valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+    } else {
+
+      nameChunk = processStyleName(styleName);
+
+      if (typeof styleValue === 'number') {
+        if (styleValue !== 0 && !isUnitlessNumber(styleName)) {
+          valueChunk = stringToChunk(styleValue + 'px'); // Presumes implicit 'px' suffix for unitless numbers
+        } else {
+          valueChunk = stringToChunk('' + styleValue);
+        }
+      } else {
+
+        valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+      }
+    }
+
+    if (isFirst) {
+      isFirst = false; // If it's first, we don't need any separators prefixed.
+
+      target.push(styleAttributeStart, nameChunk, styleAssign, valueChunk);
+    } else {
+      target.push(styleSeparator, nameChunk, styleAssign, valueChunk);
+    }
+  }
+
+  if (!isFirst) {
+    target.push(attributeEnd);
+  }
+}
+
+const attributeSeparator = stringToPrecomputedChunk(' ');
+const attributeAssign = stringToPrecomputedChunk('="');
+const attributeEnd = stringToPrecomputedChunk('"');
+const attributeEmptyString = stringToPrecomputedChunk('=""');
+
+function pushBooleanAttribute(target, name, value) // not null or undefined
+{
+  if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+    target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+  }
+}
+
+function pushStringAttribute(target, name, value) // not null or undefined
+{
+  if (typeof value !== 'function' && typeof value !== 'symbol' && typeof value !== 'boolean') {
+    target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+  }
+}
+
+function makeFormFieldPrefix(resumableState) {
+  const id = resumableState.nextFormID++;
+  return resumableState.idPrefix + id;
+} // Since this will likely be repeated a lot in the HTML, we use a more concise message
+// than on the client and hopefully it's googleable.
+
+
+const actionJavaScriptURL = stringToPrecomputedChunk(escapeTextForBrowser( // eslint-disable-next-line no-script-url
+"javascript:throw new Error('A React form was unexpectedly submitted.')"));
+const startHiddenInputChunk = stringToPrecomputedChunk('<input type="hidden"');
+
+function pushAdditionalFormField(value, key) {
+  const target = this;
+  target.push(startHiddenInputChunk);
+
+  if (typeof value !== 'string') {
+    throw new Error('File/Blob fields are not yet supported in progressive forms. ' + 'It probably means you are closing over binary data or FormData in a Server Action.');
+  }
+
+  pushStringAttribute(target, 'name', key);
+  pushStringAttribute(target, 'value', value);
+  target.push(endOfStartTagSelfClosing);
+}
+
+function pushAdditionalFormFields(target, formData) {
+  if (formData !== null) {
+    // $FlowFixMe[prop-missing]: FormData has forEach.
+    formData.forEach(pushAdditionalFormField, target);
+  }
+}
+
+function pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name) {
+  let formData = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      name = customFields.name;
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('formAction'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      name = null;
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (name != null) {
+    pushAttribute(target, 'name', name);
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'formAction', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'formEncType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'formMethod', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'formTarget', formTarget);
+  }
+
+  return formData;
+}
+
+function pushAttribute(target, name, value) // not null or undefined
+{
+  switch (name) {
+    // These are very common props and therefore are in the beginning of the switch.
+    // TODO: aria-label is a very common prop but allows booleans so is not like the others
+    // but should ideally go in this list too.
+    case 'className':
+      {
+        pushStringAttribute(target, 'class', value);
+        break;
+      }
+
+    case 'tabIndex':
+      {
+        pushStringAttribute(target, 'tabindex', value);
+        break;
+      }
+
+    case 'dir':
+    case 'role':
+    case 'viewBox':
+    case 'width':
+    case 'height':
+      {
+        pushStringAttribute(target, name, value);
+        break;
+      }
+
+    case 'style':
+      {
+        pushStyleAttribute(target, value);
+        return;
+      }
+
+    case 'src':
+    case 'href':
+      {
+        {
+          if (value === '') {
+
+            return;
+          }
+        }
+      }
+    // Fall through to the last case which shouldn't remove empty strings.
+
+    case 'action':
+    case 'formAction':
+      {
+        // TODO: Consider only special casing these for each tag.
+        if (value == null || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'defaultValue':
+    case 'defaultChecked': // These shouldn't be set as attributes on generic HTML elements.
+
+    case 'innerHTML': // Must use dangerouslySetInnerHTML instead.
+
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+      // Ignored. These are built-in to React on the client.
+      return;
+
+    case 'autoFocus':
+    case 'multiple':
+    case 'muted':
+      {
+        pushBooleanAttribute(target, name.toLowerCase(), value);
+        return;
+      }
+
+    case 'xlinkHref':
+      {
+        if (typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk('xlink:href'), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'contentEditable':
+    case 'spellCheck':
+    case 'draggable':
+    case 'value':
+    case 'autoReverse':
+    case 'externalResourcesRequired':
+    case 'focusable':
+    case 'preserveAlpha':
+      {
+        // Booleanish String
+        // These are "enumerated" attributes that accept "true" and "false".
+        // In React, we let users pass `true` and `false` even though technically
+        // these aren't boolean attributes (they are coerced to strings).
+        if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'allowFullScreen':
+    case 'async':
+    case 'autoPlay':
+    case 'controls':
+    case 'default':
+    case 'defer':
+    case 'disabled':
+    case 'disablePictureInPicture':
+    case 'disableRemotePlayback':
+    case 'formNoValidate':
+    case 'hidden':
+    case 'loop':
+    case 'noModule':
+    case 'noValidate':
+    case 'open':
+    case 'playsInline':
+    case 'readOnly':
+    case 'required':
+    case 'reversed':
+    case 'scoped':
+    case 'seamless':
+    case 'itemScope':
+      {
+        // Boolean
+        if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        }
+
+        return;
+      }
+
+    case 'capture':
+    case 'download':
+      {
+        // Overloaded Boolean
+        if (value === true) {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        } else if (value === false) ; else if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'cols':
+    case 'rows':
+    case 'size':
+    case 'span':
+      {
+        // These are HTML attributes that must be positive numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value) && value >= 1) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'rowSpan':
+    case 'start':
+      {
+        // These are HTML attributes that must be numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value)) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'xlinkActuate':
+      pushStringAttribute(target, 'xlink:actuate', value);
+      return;
+
+    case 'xlinkArcrole':
+      pushStringAttribute(target, 'xlink:arcrole', value);
+      return;
+
+    case 'xlinkRole':
+      pushStringAttribute(target, 'xlink:role', value);
+      return;
+
+    case 'xlinkShow':
+      pushStringAttribute(target, 'xlink:show', value);
+      return;
+
+    case 'xlinkTitle':
+      pushStringAttribute(target, 'xlink:title', value);
+      return;
+
+    case 'xlinkType':
+      pushStringAttribute(target, 'xlink:type', value);
+      return;
+
+    case 'xmlBase':
+      pushStringAttribute(target, 'xml:base', value);
+      return;
+
+    case 'xmlLang':
+      pushStringAttribute(target, 'xml:lang', value);
+      return;
+
+    case 'xmlSpace':
+      pushStringAttribute(target, 'xml:space', value);
+      return;
+
+    default:
+      if ( // shouldIgnoreAttribute
+      // We have already filtered out null/undefined and reserved words.
+      name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+        return;
+      }
+
+      const attributeName = getAttributeAlias(name);
+
+      if (isAttributeNameSafe(attributeName)) {
+        // shouldRemoveAttribute
+        switch (typeof value) {
+          case 'function':
+          case 'symbol':
+            // eslint-disable-line
+            return;
+
+          case 'boolean':
+            {
+              const prefix = attributeName.toLowerCase().slice(0, 5);
+
+              if (prefix !== 'data-' && prefix !== 'aria-') {
+                return;
+              }
+            }
+        }
+
+        target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+      }
+
+  }
+}
+
+const endOfStartTag = stringToPrecomputedChunk('>');
+const endOfStartTagSelfClosing = stringToPrecomputedChunk('/>');
+
+function pushInnerHTML(target, innerHTML, children) {
+  if (innerHTML != null) {
+    if (children != null) {
+      throw new Error('Can only set one of `children` or `props.dangerouslySetInnerHTML`.');
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw new Error('`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. ' + 'Please visit https://reactjs.org/link/dangerously-set-inner-html ' + 'for more information.');
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+
+      target.push(stringToChunk('' + html));
+    }
+  }
+} // TODO: Move these to RenderState so that we warn for every request.
+
+function pushStartSelect(target, props) {
+
+  target.push(startChunkForTag('select'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          // TODO: This doesn't really make sense for select since it can't use the controlled
+          // value in the innerHTML.
+          innerHTML = propValue;
+          break;
+
+        case 'defaultValue':
+        case 'value':
+          // These are set on the Context instead and applied to the nested options.
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+function flattenOptionChildren(children) {
+  let content = ''; // Flatten children and warn if they aren't strings or numbers;
+  // invalid types are ignored.
+
+  React.Children.forEach(children, function (child) {
+    if (child == null) {
+      return;
+    }
+
+    content += child;
+  });
+  return content;
+}
+
+const selectedMarkerAttribute = stringToPrecomputedChunk(' selected=""');
+
+function pushStartOption(target, props, formatContext) {
+  const selectedValue = formatContext.selectedValue;
+  target.push(startChunkForTag('option'));
+  let children = null;
+  let value = null;
+  let selected = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'selected':
+          // ignore
+          selected = propValue;
+
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+        // We intentionally fallthrough to also set the attribute on the node.
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (selectedValue != null) {
+    let stringValue;
+
+    if (value !== null) {
+
+      stringValue = '' + value;
+    } else {
+
+      stringValue = flattenOptionChildren(children);
+    }
+
+    if (isArray(selectedValue)) {
+      // multiple
+      for (let i = 0; i < selectedValue.length; i++) {
+
+        const v = '' + selectedValue[i];
+
+        if (v === stringValue) {
+          target.push(selectedMarkerAttribute);
+          break;
+        }
+      }
+    } else {
+
+      if ('' + selectedValue === stringValue) {
+        target.push(selectedMarkerAttribute);
+      }
+    }
+  } else if (selected) {
+    target.push(selectedMarkerAttribute);
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const formReplayingRuntimeScript = stringToPrecomputedChunk(formReplaying);
+
+function injectFormReplayingRuntime(resumableState, renderState) {
+  // If we haven't sent it yet, inject the runtime that tracks submitted JS actions
+  // for later replaying by Fiber. If we use an external runtime, we don't need
+  // to emit anything. It's always used.
+  if ((resumableState.instructions & SentFormReplayingRuntime) === NothingSent && (!renderState.externalRuntimeScript)) {
+    resumableState.instructions |= SentFormReplayingRuntime;
+    renderState.bootstrapChunks.unshift(renderState.startInlineScript, formReplayingRuntimeScript, endInlineScript);
+  }
+}
+
+const formStateMarkerIsMatching = stringToPrecomputedChunk('<!--F!-->');
+const formStateMarkerIsNotMatching = stringToPrecomputedChunk('<!--F-->');
+function pushFormStateMarkerIsMatching(target) {
+  target.push(formStateMarkerIsMatching);
+}
+function pushFormStateMarkerIsNotMatching(target) {
+  target.push(formStateMarkerIsNotMatching);
+}
+
+function pushStartForm(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('form'));
+  let children = null;
+  let innerHTML = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'action':
+          formAction = propValue;
+          break;
+
+        case 'encType':
+          formEncType = propValue;
+          break;
+
+        case 'method':
+          formMethod = propValue;
+          break;
+
+        case 'target':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  let formData = null;
+  let formActionName = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+      formActionName = customFields.name;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('action'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'action', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'encType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'method', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'target', formTarget);
+  }
+
+  target.push(endOfStartTag);
+
+  if (formActionName !== null) {
+    target.push(startHiddenInputChunk);
+    pushStringAttribute(target, 'name', formActionName);
+    target.push(endOfStartTagSelfClosing);
+    pushAdditionalFormFields(target, formData);
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushInput(target, props, resumableState, renderState) {
+
+  target.push(startChunkForTag('input'));
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+  let value = null;
+  let defaultValue = null;
+  let checked = null;
+  let defaultChecked = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('input' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        case 'defaultChecked':
+          defaultChecked = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'checked':
+          checked = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+
+  if (checked !== null) {
+    pushBooleanAttribute(target, 'checked', checked);
+  } else if (defaultChecked !== null) {
+    pushBooleanAttribute(target, 'checked', defaultChecked);
+  }
+
+  if (value !== null) {
+    pushAttribute(target, 'value', value);
+  } else if (defaultValue !== null) {
+    pushAttribute(target, 'value', defaultValue);
+  }
+
+  target.push(endOfStartTagSelfClosing); // We place any additional hidden form fields after the input.
+
+  pushAdditionalFormFields(target, formData);
+  return null;
+}
+
+function pushStartButton(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('button'));
+  let children = null;
+  let innerHTML = null;
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+  target.push(endOfStartTag); // We place any additional hidden form fields we need to include inside the button itself.
+
+  pushAdditionalFormFields(target, formData);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartTextArea(target, props) {
+
+  target.push(startChunkForTag('textarea'));
+  let value = null;
+  let defaultValue = null;
+  let children = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          throw new Error('`dangerouslySetInnerHTML` does not make sense on <textarea>.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (value === null && defaultValue !== null) {
+    value = defaultValue;
+  }
+
+  target.push(endOfStartTag); // TODO (yungsters): Remove support for children content in <textarea>.
+
+  if (children != null) {
+
+    if (value != null) {
+      throw new Error('If you supply `defaultValue` on a <textarea>, do not pass children.');
+    }
+
+    if (isArray(children)) {
+      if (children.length > 1) {
+        throw new Error('<textarea> can only have at most one child.');
+      } // TODO: remove the coercion and the DEV check below because it will
+
+      value = '' + children[0];
+    }
+
+    value = '' + children;
+  }
+
+  if (typeof value === 'string' && value[0] === '\n') {
+    // text/html ignores the first character in these tags if it's a newline
+    // Prefer to break application/xml over text/html (for now) by adding
+    // a newline specifically to get eaten by the parser. (Alternately for
+    // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+    // \r is normalized out by HTMLTextAreaElement#value.)
+    // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+    // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+    // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+    // See: Parsing of "textarea" "listing" and "pre" elements
+    //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+    target.push(leadingNewline);
+  } // ToString and push directly instead of recurse over children.
+  // We don't really support complex children in the value anyway.
+  // This also currently avoids a trailing comment node which breaks textarea.
+
+
+  if (value !== null) {
+
+    target.push(stringToChunk(encodeHTMLTextNode('' + value)));
+  }
+
+  return null;
+}
+
+function pushMeta(target, props, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      return pushSelfClosing(target, props, 'meta');
+    } else {
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      if (typeof props.charSet === 'string') {
+        return pushSelfClosing(renderState.charsetChunks, props, 'meta');
+      } else if (props.name === 'viewport') {
+        // "viewport" isn't related to preconnect but it has the right priority
+        return pushSelfClosing(renderState.preconnectChunks, props, 'meta');
+      } else {
+        return pushSelfClosing(renderState.hoistableChunks, props, 'meta');
+      }
+    }
+  }
+}
+
+function pushLink(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const rel = props.rel;
+    const href = props.href;
+    const precedence = props.precedence;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof rel !== 'string' || typeof href !== 'string' || href === '') {
+
+      pushLinkImpl(target, props);
+      return null;
+    }
+
+    if (props.rel === 'stylesheet') {
+      // This <link> may hoistable as a Stylesheet Resource, otherwise it will emit in place
+      const key = getResourceKey(href);
+
+      if (typeof precedence !== 'string' || props.disabled != null || props.onLoad || props.onError) {
+
+        return pushLinkImpl(target, props);
+      } else {
+        // This stylesheet refers to a Resource and we create a new one if necessary
+        let styleQueue = renderState.styles.get(precedence);
+        const hasKey = resumableState.styleResources.hasOwnProperty(key);
+        const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+        if (resourceState !== EXISTS) {
+          // We are going to create this resource now so it is marked as Exists
+          resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+          // to create a StyleQueue
+
+          if (!styleQueue) {
+            styleQueue = {
+              precedence: stringToChunk(escapeTextForBrowser(precedence)),
+              rules: [],
+              hrefs: [],
+              sheets: new Map()
+            };
+            renderState.styles.set(precedence, styleQueue);
+          }
+
+          const resource = {
+            state: PENDING$1,
+            props: stylesheetPropsFromRawProps(props)
+          };
+
+          if (resourceState) {
+            // When resourceState is truty it is a Preload state. We cast it for clarity
+            const preloadState = resourceState;
+
+            if (preloadState.length === 2) {
+              adoptPreloadCredentials(resource.props, preloadState);
+            }
+
+            const preloadResource = renderState.preloads.stylesheets.get(key);
+
+            if (preloadResource && preloadResource.length > 0) {
+              // The Preload for this resource was created in this render pass and has not flushed yet so
+              // we need to clear it to avoid it flushing.
+              preloadResource.length = 0;
+            } else {
+              // Either the preload resource from this render already flushed in this render pass
+              // or the preload flushed in a prior pass (prerender). In either case we need to mark
+              // this resource as already having been preloaded.
+              resource.state = PRELOADED;
+            }
+          } // We add the newly created resource to our StyleQueue and if necessary
+          // track the resource with the currently rendering boundary
+
+
+          styleQueue.sheets.set(key, resource);
+
+          if (renderState.boundaryResources) {
+            renderState.boundaryResources.stylesheets.add(resource);
+          }
+        } else {
+          // We need to track whether this boundary should wait on this resource or not.
+          // Typically this resource should always exist since we either had it or just created
+          // it. However, it's possible when you resume that the style has already been emitted
+          // and then it wouldn't be recreated in the RenderState and there's no need to track
+          // it again since we should've hoisted it to the shell already.
+          if (styleQueue) {
+            const resource = styleQueue.sheets.get(key);
+
+            if (resource) {
+              if (renderState.boundaryResources) {
+                renderState.boundaryResources.stylesheets.add(resource);
+              }
+            }
+          }
+        }
+
+        if (textEmbedded) {
+          // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+          // to be safe and assume text will follow by inserting a textSeparator
+          target.push(textSeparator);
+        }
+
+        return null;
+      }
+    } else if (props.onLoad || props.onError) {
+      // When using load handlers we cannot hoist and need to emit links in place
+      return pushLinkImpl(target, props);
+    } else {
+      // We can hoist this link so we may need to emit a text separator.
+      // @TODO refactor text separators so we don't have to defensively add
+      // them when we don't end up emitting a tag as a result of pushStartInstance
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      switch (props.rel) {
+        case 'preconnect':
+        case 'dns-prefetch':
+          return pushLinkImpl(renderState.preconnectChunks, props);
+
+        case 'preload':
+          return pushLinkImpl(renderState.preloadChunks, props);
+
+        default:
+          return pushLinkImpl(renderState.hoistableChunks, props);
+      }
+    }
+  }
+}
+
+function pushLinkImpl(target, props) {
+  target.push(startChunkForTag('link'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStyle(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+
+  {
+    const precedence = props.precedence;
+    const href = props.href;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof precedence !== 'string' || typeof href !== 'string' || href === '') {
+      // This style tag is not able to be turned into a Style Resource
+      return pushStyleImpl(target, props);
+    }
+
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS;
+
+      if (!styleQueue) {
+        // This is the first time we've encountered this precedence we need
+        // to create a StyleQueue.
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [stringToChunk(escapeTextForBrowser(href))],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      } else {
+        // We have seen this precedence before and need to track this href
+        styleQueue.hrefs.push(stringToChunk(escapeTextForBrowser(href)));
+      }
+
+      pushStyleContents(styleQueue.rules, props);
+    }
+
+    if (styleQueue) {
+      // We need to track whether this boundary should wait on this resource or not.
+      // Typically this resource should always exist since we either had it or just created
+      // it. However, it's possible when you resume that the style has already been emitted
+      // and then it wouldn't be recreated in the RenderState and there's no need to track
+      // it again since we should've hoisted it to the shell already.
+      if (renderState.boundaryResources) {
+        renderState.boundaryResources.styles.add(styleQueue);
+      }
+    }
+
+    if (textEmbedded) {
+      // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+  }
+}
+
+function pushStyleImpl(target, props) {
+  target.push(startChunkForTag('style'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('style'));
+  return null;
+}
+
+function pushStyleContents(target, props) {
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+      }
+    }
+  }
+
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  return;
+}
+
+function pushImg(target, props, resumableState, renderState, pictureTagInScope) {
+  const src = props.src,
+        srcSet = props.srcSet;
+
+  if (props.loading !== 'lazy' && (src || srcSet) && (typeof src === 'string' || src == null) && (typeof srcSet === 'string' || srcSet == null) && props.fetchPriority !== 'low' && pictureTagInScope === false && // We exclude data URIs in src and srcSet since these should not be preloaded
+  !(typeof src === 'string' && src[4] === ':' && (src[0] === 'd' || src[0] === 'D') && (src[1] === 'a' || src[1] === 'A') && (src[2] === 't' || src[2] === 'T') && (src[3] === 'a' || src[3] === 'A')) && !(typeof srcSet === 'string' && srcSet[4] === ':' && (srcSet[0] === 'd' || srcSet[0] === 'D') && (srcSet[1] === 'a' || srcSet[1] === 'A') && (srcSet[2] === 't' || srcSet[2] === 'T') && (srcSet[3] === 'a' || srcSet[3] === 'A'))) {
+    // We have a suspensey image and ought to preload it to optimize the loading of display blocking
+    // resumableState.
+    const sizes = typeof props.sizes === 'string' ? props.sizes : undefined;
+    const key = getImageResourceKey(src, srcSet, sizes);
+    const promotablePreloads = renderState.preloads.images;
+    let resource = promotablePreloads.get(key);
+
+    if (resource) {
+      // We consider whether this preload can be promoted to higher priority flushing queue.
+      // The only time a resource will exist here is if it was created during this render
+      // and was not already in the high priority queue.
+      if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+        // Delete the resource from the map since we are promoting it and don't want to
+        // reenter this branch in a second pass for duplicate img hrefs.
+        promotablePreloads.delete(key); // $FlowFixMe - Flow should understand that this is a Resource if the condition was true
+
+        renderState.highImagePreloads.add(resource);
+      }
+    } else if (!resumableState.imageResources.hasOwnProperty(key)) {
+      // We must construct a new preload resource
+      resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+      const crossOrigin = getCrossOriginString(props.crossOrigin);
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // this is a hueristic similar to capping element preloads to 10 unless explicitly
+      // fetchPriority="high". We use length here which means it will fit fewer images when
+      // the urls are long and more when short. arguably byte size is a better hueristic because
+      // it directly translates to how much we send down before content is actually seen.
+      // We could unify the counts and also make it so the total is tracked regardless of
+      // flushing output but since the headers are likely to be go earlier than content
+      // they don't really conflict so for now I've kept them separate
+      props.fetchPriority === 'high' || headers.highImagePreloads.length < 500) && ( // We manually construct the options for the preload only from strings. We don't want to pollute
+      // the params list with arbitrary props and if we copied everything over as it we might get
+      // coercion errors. We have checks for this in Dev but it seems safer to just only accept values
+      // that are strings
+      header = getPreloadAsHeader(src, 'image', {
+        imageSrcSet: props.srcSet,
+        imageSizes: props.sizes,
+        crossOrigin,
+        integrity: props.integrity,
+        nonce: props.nonce,
+        type: props.type,
+        fetchPriority: props.fetchPriority,
+        referrerPolicy: props.refererPolicy
+      }), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // If we postpone in the shell we will still emit this preload so we track
+        // it to make sure we don't reset it.
+        renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+        if (headers.highImagePreloads) {
+          headers.highImagePreloads += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.highImagePreloads += header;
+      } else {
+        resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preload',
+          as: 'image',
+          // There is a bug in Safari where imageSrcSet is not respected on preload links
+          // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+          // This harms older browers that do not support imageSrcSet by making their preloads not work
+          // but this population is shrinking fast and is already small so we accept this tradeoff.
+          href: srcSet ? undefined : src,
+          imageSrcSet: srcSet,
+          imageSizes: sizes,
+          crossOrigin: crossOrigin,
+          integrity: props.integrity,
+          type: props.type,
+          fetchPriority: props.fetchPriority,
+          referrerPolicy: props.referrerPolicy
+        });
+
+        if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+          renderState.highImagePreloads.add(resource);
+        } else {
+          renderState.bulkPreloads.add(resource); // We can bump the priority up if the same img is rendered later
+          // with fetchPriority="high"
+
+          promotablePreloads.set(key, resource);
+        }
+      }
+    }
+  }
+
+  return pushSelfClosing(target, props, 'img');
+}
+
+function pushSelfClosing(target, props, tag) {
+  target.push(startChunkForTag(tag));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error(tag + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStartMenuItem(target, props) {
+  target.push(startChunkForTag('menuitem'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('menuitems cannot have `children` nor `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  return null;
+}
+
+function pushTitle(target, props, renderState, insertionMode, noscriptTagInScope) {
+
+  {
+    if (insertionMode !== SVG_MODE && !noscriptTagInScope && props.itemProp == null) {
+      pushTitleImpl(renderState.hoistableChunks, props);
+      return null;
+    } else {
+      return pushTitleImpl(target, props);
+    }
+  }
+}
+
+function pushTitleImpl(target, props) {
+  target.push(startChunkForTag('title'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('title'));
+  return null;
+}
+
+function pushStartHead(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode < HTML_MODE && renderState.headChunks === null) {
+      // This <head> is the Document.head and should be part of the preamble
+      renderState.headChunks = [];
+      return pushStartGenericElement(renderState.headChunks, props, 'head');
+    } else {
+      // This <head> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'head');
+    }
+  }
+}
+
+function pushStartHtml(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode === ROOT_HTML_MODE && renderState.htmlChunks === null) {
+      // This <html> is the Document.documentElement and should be part of the preamble
+      renderState.htmlChunks = [doctypeChunk];
+      return pushStartGenericElement(renderState.htmlChunks, props, 'html');
+    } else {
+      // This <html> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'html');
+    }
+  }
+}
+
+function pushScript(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const asyncProp = props.async;
+
+    if (typeof props.src !== 'string' || !props.src || !(asyncProp && typeof asyncProp !== 'function' && typeof asyncProp !== 'symbol') || props.onLoad || props.onError || insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      // This script will not be a resource, we bailout early and emit it in place.
+      return pushScriptImpl(target, props);
+    }
+
+    const src = props.src;
+    const key = getResourceKey(src); // We can make this <script> into a ScriptResource
+
+    let resources, preloads;
+
+    if (props.type === 'module') {
+      resources = resumableState.moduleScriptResources;
+      preloads = renderState.preloads.moduleScripts;
+    } else {
+      resources = resumableState.scriptResources;
+      preloads = renderState.preloads.scripts;
+    }
+
+    const hasKey = resources.hasOwnProperty(key);
+    const resourceState = hasKey ? resources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resources[key] = EXISTS;
+      let scriptProps = props;
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          scriptProps = assign({}, props);
+          adoptPreloadCredentials(scriptProps, preloadState);
+        }
+
+        const preloadResource = preloads.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, scriptProps);
+    }
+
+    if (textEmbedded) {
+      // This script follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+
+    return null;
+  }
+}
+
+function pushScriptImpl(target, props) {
+  target.push(startChunkForTag('script'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+  }
+
+  target.push(endChunkForTag('script'));
+  return null;
+}
+
+function pushStartGenericElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartCustomElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      let propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      let attributeName = propKey;
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'style':
+          pushStyleAttribute(target, propValue);
+          break;
+
+        case 'suppressContentEditableWarning':
+        case 'suppressHydrationWarning':
+          // Ignored. These are built-in to React on the client.
+          break;
+
+        case 'className':
+          {
+            // className gets rendered as class on the client, so it should be
+            // rendered as class on the server.
+            attributeName = 'class';
+          }
+
+        // intentional fallthrough
+
+        default:
+          if (isAttributeNameSafe(propKey) && typeof propValue !== 'function' && typeof propValue !== 'symbol') {
+            {
+              if (propValue === false) {
+                continue;
+              } else if (propValue === true) {
+                propValue = '';
+              } else if (typeof propValue === 'object') {
+                continue;
+              }
+            }
+
+            target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(propValue)), attributeEnd);
+          }
+
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const leadingNewline = stringToPrecomputedChunk('\n');
+
+function pushStartPreformattedElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag); // text/html ignores the first character in these tags if it's a newline
+  // Prefer to break application/xml over text/html (for now) by adding
+  // a newline specifically to get eaten by the parser. (Alternately for
+  // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+  // \r is normalized out by HTMLTextAreaElement#value.)
+  // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+  // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+  // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+  // See: Parsing of "textarea" "listing" and "pre" elements
+  //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+  // TODO: This doesn't deal with the case where the child is an array
+  // or component that returns a string.
+
+  if (innerHTML != null) {
+    if (children != null) {
+      throw new Error('Can only set one of `children` or `props.dangerouslySetInnerHTML`.');
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw new Error('`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. ' + 'Please visit https://reactjs.org/link/dangerously-set-inner-html ' + 'for more information.');
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+      if (typeof html === 'string' && html.length > 0 && html[0] === '\n') {
+        target.push(leadingNewline, stringToChunk(html));
+      } else {
+
+        target.push(stringToChunk('' + html));
+      }
+    }
+  }
+
+  if (typeof children === 'string' && children[0] === '\n') {
+    target.push(leadingNewline);
+  }
+
+  return children;
+} // We accept any tag to be rendered but since this gets injected into arbitrary
+// HTML, we want to make sure that it's a safe tag.
+// http://www.w3.org/TR/REC-xml/#NT-Name
+
+
+const VALID_TAG_REGEX = /^[a-zA-Z][a-zA-Z:_\.\-\d]*$/; // Simplified subset
+
+const validatedTagCache = new Map();
+
+function startChunkForTag(tag) {
+  let tagStartChunk = validatedTagCache.get(tag);
+
+  if (tagStartChunk === undefined) {
+    if (!VALID_TAG_REGEX.test(tag)) {
+      throw new Error("Invalid tag: " + tag);
+    }
+
+    tagStartChunk = stringToPrecomputedChunk('<' + tag);
+    validatedTagCache.set(tag, tagStartChunk);
+  }
+
+  return tagStartChunk;
+}
+
+const doctypeChunk = stringToPrecomputedChunk('<!DOCTYPE html>');
+function pushStartInstance(target, type, props, resumableState, renderState, formatContext, textEmbedded) {
+
+  switch (type) {
+    case 'div':
+    case 'span':
+    case 'svg':
+    case 'path':
+    case 'a':
+    case 'g':
+    case 'p':
+    case 'li':
+      // Fast track very common tags
+      break;
+    // Special tags
+
+    case 'select':
+      return pushStartSelect(target, props);
+
+    case 'option':
+      return pushStartOption(target, props, formatContext);
+
+    case 'textarea':
+      return pushStartTextArea(target, props);
+
+    case 'input':
+      return pushInput(target, props, resumableState, renderState);
+
+    case 'button':
+      return pushStartButton(target, props, resumableState, renderState);
+
+    case 'form':
+      return pushStartForm(target, props, resumableState, renderState);
+
+    case 'menuitem':
+      return pushStartMenuItem(target, props);
+
+    case 'title':
+      return pushTitle(target, props, renderState, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'link':
+      return pushLink(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'script':
+      return pushScript(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'style':
+      return pushStyle(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'meta':
+      return pushMeta(target, props, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+    // Newline eating tags
+
+    case 'listing':
+    case 'pre':
+      {
+        return pushStartPreformattedElement(target, props, type);
+      }
+
+    case 'img':
+      {
+        return pushImg(target, props, resumableState, renderState, !!(formatContext.tagScope & PICTURE_SCOPE)) ;
+      }
+    // Omitted close tags
+
+    case 'base':
+    case 'area':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'keygen':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        return pushSelfClosing(target, props, type);
+      }
+    // These are reserved SVG and MathML elements, that are never custom elements.
+    // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+
+    case 'annotation-xml':
+    case 'color-profile':
+    case 'font-face':
+    case 'font-face-src':
+    case 'font-face-uri':
+    case 'font-face-format':
+    case 'font-face-name':
+    case 'missing-glyph':
+      {
+        break;
+      }
+    // Preamble start tags
+
+    case 'head':
+      return pushStartHead(target, props, renderState, formatContext.insertionMode);
+
+    case 'html':
+      {
+        return pushStartHtml(target, props, renderState, formatContext.insertionMode);
+      }
+
+    default:
+      {
+        if (type.indexOf('-') !== -1) {
+          // Custom element
+          return pushStartCustomElement(target, props, type);
+        }
+      }
+  } // Generic element
+
+
+  return pushStartGenericElement(target, props, type);
+}
+const endTagCache = new Map();
+
+function endChunkForTag(tag) {
+  let chunk = endTagCache.get(tag);
+
+  if (chunk === undefined) {
+    chunk = stringToPrecomputedChunk('</' + tag + '>');
+    endTagCache.set(tag, chunk);
+  }
+
+  return chunk;
+}
+
+function pushEndInstance(target, type, props, resumableState, formatContext) {
+  switch (type) {
+    // When float is on we expect title and script tags to always be pushed in
+    // a unit and never return children. when we end up pushing the end tag we
+    // want to ensure there is no extra closing tag pushed
+    case 'title':
+    case 'style':
+    case 'script':
+    // Omitted close tags
+    // TODO: Instead of repeating this switch we could try to pass a flag from above.
+    // That would require returning a tuple. Which might be ok if it gets inlined.
+
+    case 'area':
+    case 'base':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'img':
+    case 'input':
+    case 'keygen':
+    case 'link':
+    case 'meta':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        // No close tag needed.
+        return;
+      }
+    // Postamble end tags
+    // When float is enabled we omit the end tags for body and html when
+    // they represent the Document.body and Document.documentElement Nodes.
+    // This is so we can withhold them until the postamble when we know
+    // we won't emit any more tags
+
+    case 'body':
+      {
+        if (formatContext.insertionMode <= HTML_HTML_MODE) {
+          resumableState.hasBody = true;
+          return;
+        }
+
+        break;
+      }
+
+    case 'html':
+      if (formatContext.insertionMode === ROOT_HTML_MODE) {
+        resumableState.hasHtml = true;
+        return;
+      }
+
+      break;
+  }
+
+  target.push(endChunkForTag(type));
+}
+
+function writeBootstrap(destination, renderState, resumableState) {
+  resumableState.bootstrapScriptContent = undefined;
+  resumableState.bootstrapScripts = undefined;
+  resumableState.bootstrapModules = undefined;
+  const bootstrapChunks = renderState.bootstrapChunks;
+  let i = 0;
+
+  for (; i < bootstrapChunks.length - 1; i++) {
+    writeChunk(destination, bootstrapChunks[i]);
+  }
+
+  if (i < bootstrapChunks.length) {
+    const lastChunk = bootstrapChunks[i];
+    bootstrapChunks.length = 0;
+    return writeChunkAndReturn(destination, lastChunk);
+  }
+
+  return true;
+}
+
+function writeCompletedRoot(destination, renderState, resumableState) {
+  return writeBootstrap(destination, renderState, resumableState);
+} // Structural Nodes
+// A placeholder is a node inside a hidden partial tree that can be filled in later, but before
+// display. It's never visible to users. We use the template tag because it can be used in every
+// type of parent. <script> tags also work in every other tag except <colgroup>.
+
+const placeholder1 = stringToPrecomputedChunk('<template id="');
+const placeholder2 = stringToPrecomputedChunk('"></template>');
+function writePlaceholder(destination, renderState, id) {
+  writeChunk(destination, placeholder1);
+  writeChunk(destination, renderState.placeholderPrefix);
+  const formattedID = stringToChunk(id.toString(16));
+  writeChunk(destination, formattedID);
+  return writeChunkAndReturn(destination, placeholder2);
+} // Suspense boundaries are encoded as comments.
+
+const startCompletedSuspenseBoundary = stringToPrecomputedChunk('<!--$-->');
+const startPendingSuspenseBoundary1 = stringToPrecomputedChunk('<!--$?--><template id="');
+const startPendingSuspenseBoundary2 = stringToPrecomputedChunk('"></template>');
+const startClientRenderedSuspenseBoundary = stringToPrecomputedChunk('<!--$!-->');
+const endSuspenseBoundary = stringToPrecomputedChunk('<!--/$-->');
+const clientRenderedSuspenseBoundaryError1 = stringToPrecomputedChunk('<template');
+const clientRenderedSuspenseBoundaryErrorAttrInterstitial = stringToPrecomputedChunk('"');
+const clientRenderedSuspenseBoundaryError1A = stringToPrecomputedChunk(' data-dgst="');
+stringToPrecomputedChunk(' data-msg="');
+stringToPrecomputedChunk(' data-stck="');
+const clientRenderedSuspenseBoundaryError2 = stringToPrecomputedChunk('></template>');
+function writeStartCompletedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, startCompletedSuspenseBoundary);
+}
+function writeStartPendingSuspenseBoundary(destination, renderState, id) {
+  writeChunk(destination, startPendingSuspenseBoundary1);
+
+  if (id === null) {
+    throw new Error('An ID must have been assigned before we can complete the boundary.');
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+  return writeChunkAndReturn(destination, startPendingSuspenseBoundary2);
+}
+function writeStartClientRenderedSuspenseBoundary(destination, renderState, errorDigest, errorMesssage, errorComponentStack) {
+  let result;
+  result = writeChunkAndReturn(destination, startClientRenderedSuspenseBoundary);
+  writeChunk(destination, clientRenderedSuspenseBoundaryError1);
+
+  if (errorDigest) {
+    writeChunk(destination, clientRenderedSuspenseBoundaryError1A);
+    writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest)));
+    writeChunk(destination, clientRenderedSuspenseBoundaryErrorAttrInterstitial);
+  }
+
+  result = writeChunkAndReturn(destination, clientRenderedSuspenseBoundaryError2);
+  return result;
+}
+function writeEndCompletedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndPendingSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndClientRenderedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+const startSegmentHTML = stringToPrecomputedChunk('<div hidden id="');
+const startSegmentHTML2 = stringToPrecomputedChunk('">');
+const endSegmentHTML = stringToPrecomputedChunk('</div>');
+const startSegmentSVG = stringToPrecomputedChunk('<svg aria-hidden="true" style="display:none" id="');
+const startSegmentSVG2 = stringToPrecomputedChunk('">');
+const endSegmentSVG = stringToPrecomputedChunk('</svg>');
+const startSegmentMathML = stringToPrecomputedChunk('<math aria-hidden="true" style="display:none" id="');
+const startSegmentMathML2 = stringToPrecomputedChunk('">');
+const endSegmentMathML = stringToPrecomputedChunk('</math>');
+const startSegmentTable = stringToPrecomputedChunk('<table hidden id="');
+const startSegmentTable2 = stringToPrecomputedChunk('">');
+const endSegmentTable = stringToPrecomputedChunk('</table>');
+const startSegmentTableBody = stringToPrecomputedChunk('<table hidden><tbody id="');
+const startSegmentTableBody2 = stringToPrecomputedChunk('">');
+const endSegmentTableBody = stringToPrecomputedChunk('</tbody></table>');
+const startSegmentTableRow = stringToPrecomputedChunk('<table hidden><tr id="');
+const startSegmentTableRow2 = stringToPrecomputedChunk('">');
+const endSegmentTableRow = stringToPrecomputedChunk('</tr></table>');
+const startSegmentColGroup = stringToPrecomputedChunk('<table hidden><colgroup id="');
+const startSegmentColGroup2 = stringToPrecomputedChunk('">');
+const endSegmentColGroup = stringToPrecomputedChunk('</colgroup></table>');
+function writeStartSegment(destination, renderState, formatContext, id) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        writeChunk(destination, startSegmentHTML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentHTML2);
+      }
+
+    case SVG_MODE:
+      {
+        writeChunk(destination, startSegmentSVG);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentSVG2);
+      }
+
+    case MATHML_MODE:
+      {
+        writeChunk(destination, startSegmentMathML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentMathML2);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        writeChunk(destination, startSegmentTable);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTable2);
+      }
+    // TODO: For the rest of these, there will be extra wrapper nodes that never
+    // get deleted from the document. We need to delete the table too as part
+    // of the injected scripts. They are invisible though so it's not too terrible
+    // and it's kind of an edge case to suspend in a table. Totally supported though.
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        writeChunk(destination, startSegmentTableBody);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableBody2);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        writeChunk(destination, startSegmentTableRow);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableRow2);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        writeChunk(destination, startSegmentColGroup);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentColGroup2);
+      }
+
+    default:
+      {
+        throw new Error('Unknown insertion mode. This is a bug in React.');
+      }
+  }
+}
+function writeEndSegment(destination, formatContext) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentHTML);
+      }
+
+    case SVG_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentSVG);
+      }
+
+    case MATHML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentMathML);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTable);
+      }
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableBody);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableRow);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentColGroup);
+      }
+
+    default:
+      {
+        throw new Error('Unknown insertion mode. This is a bug in React.');
+      }
+  }
+}
+const completeSegmentScript1Full = stringToPrecomputedChunk(completeSegment + '$RS("');
+const completeSegmentScript1Partial = stringToPrecomputedChunk('$RS("');
+const completeSegmentScript2 = stringToPrecomputedChunk('","');
+const completeSegmentScriptEnd = stringToPrecomputedChunk('")</script>');
+const completeSegmentData1 = stringToPrecomputedChunk('<template data-rsi="" data-sid="');
+const completeSegmentData2 = stringToPrecomputedChunk('" data-pid="');
+const completeSegmentDataEnd = dataElementQuotedEnd;
+function writeCompletedSegmentInstruction(destination, resumableState, renderState, contentSegmentID) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentCompleteSegmentFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentCompleteSegmentFunction;
+      writeChunk(destination, completeSegmentScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, completeSegmentScript1Partial);
+    }
+  } else {
+    writeChunk(destination, completeSegmentData1);
+  } // Write function arguments, which are string literals
+
+
+  writeChunk(destination, renderState.segmentPrefix);
+  const formattedID = stringToChunk(contentSegmentID.toString(16));
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    writeChunk(destination, completeSegmentScript2);
+  } else {
+    writeChunk(destination, completeSegmentData2);
+  }
+
+  writeChunk(destination, renderState.placeholderPrefix);
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    return writeChunkAndReturn(destination, completeSegmentScriptEnd);
+  } else {
+    return writeChunkAndReturn(destination, completeSegmentDataEnd);
+  }
+}
+const completeBoundaryScript1Full = stringToPrecomputedChunk(completeBoundary + '$RC("');
+const completeBoundaryScript1Partial = stringToPrecomputedChunk('$RC("');
+const completeBoundaryWithStylesScript1FullBoth = stringToPrecomputedChunk(completeBoundary + completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1FullPartial = stringToPrecomputedChunk(completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1Partial = stringToPrecomputedChunk('$RR("');
+const completeBoundaryScript2 = stringToPrecomputedChunk('","');
+const completeBoundaryScript3a = stringToPrecomputedChunk('",');
+const completeBoundaryScript3b = stringToPrecomputedChunk('"');
+const completeBoundaryScriptEnd = stringToPrecomputedChunk(')</script>');
+const completeBoundaryData1 = stringToPrecomputedChunk('<template data-rci="" data-bid="');
+const completeBoundaryWithStylesData1 = stringToPrecomputedChunk('<template data-rri="" data-bid="');
+const completeBoundaryData2 = stringToPrecomputedChunk('" data-sid="');
+const completeBoundaryData3a = stringToPrecomputedChunk('" data-sty="');
+const completeBoundaryDataEnd = dataElementQuotedEnd;
+function writeCompletedBoundaryInstruction(destination, resumableState, renderState, id, boundaryResources) {
+  let requiresStyleInsertion;
+
+  {
+    requiresStyleInsertion = renderState.stylesToHoist; // If necessary stylesheets will be flushed with this instruction.
+    // Any style tags not yet hoisted in the Document will also be hoisted.
+    // We reset this state since after this instruction executes all styles
+    // up to this point will have been hoisted
+
+    renderState.stylesToHoist = false;
+  }
+
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if (requiresStyleInsertion) {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction | SentCompleteBoundaryFunction;
+        writeChunk(destination, clonePrecomputedChunk(completeBoundaryWithStylesScript1FullBoth));
+      } else if ((resumableState.instructions & SentStyleInsertionFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction;
+        writeChunk(destination, completeBoundaryWithStylesScript1FullPartial);
+      } else {
+        writeChunk(destination, completeBoundaryWithStylesScript1Partial);
+      }
+    } else {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentCompleteBoundaryFunction;
+        writeChunk(destination, completeBoundaryScript1Full);
+      } else {
+        writeChunk(destination, completeBoundaryScript1Partial);
+      }
+    }
+  } else {
+    if (requiresStyleInsertion) {
+      writeChunk(destination, completeBoundaryWithStylesData1);
+    } else {
+      writeChunk(destination, completeBoundaryData1);
+    }
+  }
+
+  const idChunk = stringToChunk(id.toString(16));
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, idChunk); // Write function arguments, which are string and array literals
+
+  if (scriptFormat) {
+    writeChunk(destination, completeBoundaryScript2);
+  } else {
+    writeChunk(destination, completeBoundaryData2);
+  }
+
+  writeChunk(destination, renderState.segmentPrefix);
+  writeChunk(destination, idChunk);
+
+  if (requiresStyleInsertion) {
+    // Script and data writers must format this differently:
+    //  - script writer emits an array literal, whose string elements are
+    //    escaped for javascript  e.g. ["A", "B"]
+    //  - data writer emits a string literal, which is escaped as html
+    //    e.g. [&#34;A&#34;, &#34;B&#34;]
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3a); // boundaryResources encodes an array literal
+
+      writeStyleResourceDependenciesInJS(destination, boundaryResources);
+    } else {
+      writeChunk(destination, completeBoundaryData3a);
+      writeStyleResourceDependenciesInAttr(destination, boundaryResources);
+    }
+  } else {
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3b);
+    }
+  }
+
+  let writeMore;
+
+  if (scriptFormat) {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryScriptEnd);
+  } else {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryDataEnd);
+  }
+
+  return writeBootstrap(destination, renderState, resumableState) && writeMore;
+}
+const clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
+const clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
+const clientRenderScript1A = stringToPrecomputedChunk('"');
+const clientRenderErrorScriptArgInterstitial = stringToPrecomputedChunk(',');
+const clientRenderScriptEnd = stringToPrecomputedChunk(')</script>');
+const clientRenderData1 = stringToPrecomputedChunk('<template data-rxi="" data-bid="');
+const clientRenderData2 = stringToPrecomputedChunk('" data-dgst="');
+const clientRenderData3 = stringToPrecomputedChunk('" data-msg="');
+const clientRenderData4 = stringToPrecomputedChunk('" data-stck="');
+const clientRenderDataEnd = dataElementQuotedEnd;
+function writeClientRenderBoundaryInstruction(destination, resumableState, renderState, id, errorDigest, errorMessage, errorComponentStack) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentClientRenderFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentClientRenderFunction;
+      writeChunk(destination, clientRenderScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, clientRenderScript1Partial);
+    }
+  } else {
+    // <template data-rxi="" data-bid="
+    writeChunk(destination, clientRenderData1);
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+
+  if (scriptFormat) {
+    // " needs to be inserted for scripts, since ArgInterstitual does not contain
+    // leading or trailing quotes
+    writeChunk(destination, clientRenderScript1A);
+  }
+
+  if (errorDigest || errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorDigest || '')));
+    } else {
+      // " data-dgst="HTMLString
+      writeChunk(destination, clientRenderData2);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest || '')));
+    }
+  }
+
+  if (errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorMessage || '')));
+    } else {
+      // " data-msg="HTMLString
+      writeChunk(destination, clientRenderData3);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorMessage || '')));
+    }
+  }
+
+  if (errorComponentStack) {
+    // ,"JSONString"
+    if (scriptFormat) {
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorComponentStack)));
+    } else {
+      // " data-stck="HTMLString
+      writeChunk(destination, clientRenderData4);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorComponentStack)));
+    }
+  }
+
+  if (scriptFormat) {
+    // ></script>
+    return writeChunkAndReturn(destination, clientRenderScriptEnd);
+  } else {
+    // "></template>
+    return writeChunkAndReturn(destination, clientRenderDataEnd);
+  }
+}
+const regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
+
+function escapeJSStringsForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInInstructionScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const regexForJSStringsInScripts = /[&><\u2028\u2029]/g;
+
+function escapeJSObjectForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '&':
+        return '\\u0026';
+
+      case '>':
+        return '\\u003e';
+
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const lateStyleTagResourceOpen1 = stringToPrecomputedChunk('<style media="not all" data-precedence="');
+const lateStyleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const lateStyleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const lateStyleTagTemplateClose = stringToPrecomputedChunk('</style>'); // Tracks whether the boundary currently flushing is flushign style tags or has any
+// stylesheet dependencies not flushed in the Preamble.
+
+let currentlyRenderingBoundaryHasStylesToHoist = false; // Acts as a return value for the forEach execution of style tag flushing.
+
+let destinationHasCapacity = true;
+
+function flushStyleTagsLateForBoundary(styleQueue) {
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs;
+
+  let i = 0;
+
+  if (hrefs.length) {
+    writeChunk(this, lateStyleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    writeChunk(this, lateStyleTagResourceOpen2);
+
+    for (; i < hrefs.length - 1; i++) {
+      writeChunk(this, hrefs[i]);
+      writeChunk(this, spaceSeparator);
+    }
+
+    writeChunk(this, hrefs[i]);
+    writeChunk(this, lateStyleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    destinationHasCapacity = writeChunkAndReturn(this, lateStyleTagTemplateClose); // We wrote style tags for this boundary and we may need to emit a script
+    // to hoist them.
+
+    currentlyRenderingBoundaryHasStylesToHoist = true; // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function hasStylesToHoist(stylesheet) {
+  // We need to reveal boundaries with styles whenever a stylesheet it depends on is either
+  // not flushed or flushed after the preamble (shell).
+  if (stylesheet.state !== PREAMBLE) {
+    currentlyRenderingBoundaryHasStylesToHoist = true;
+    return true;
+  }
+
+  return false;
+}
+
+function writeResourcesForBoundary(destination, boundaryResources, renderState) {
+  // Reset these on each invocation, they are only safe to read in this function
+  currentlyRenderingBoundaryHasStylesToHoist = false;
+  destinationHasCapacity = true; // Flush style tags for each precedence this boundary depends on
+
+  boundaryResources.styles.forEach(flushStyleTagsLateForBoundary, destination); // Determine if this boundary has stylesheets that need to be awaited upon completion
+
+  boundaryResources.stylesheets.forEach(hasStylesToHoist);
+
+  if (currentlyRenderingBoundaryHasStylesToHoist) {
+    renderState.stylesToHoist = true;
+  }
+
+  return destinationHasCapacity;
+}
+
+function flushResource(resource) {
+  for (let i = 0; i < resource.length; i++) {
+    writeChunk(this, resource[i]);
+  }
+
+  resource.length = 0;
+}
+
+const stylesheetFlushingQueue = [];
+
+function flushStyleInPreamble(stylesheet, key, map) {
+  // We still need to encode stylesheet chunks
+  // because unlike most Hoistables and Resources we do not eagerly encode
+  // them during render. This is because if we flush late we have to send a
+  // different encoding and we don't want to encode multiple times
+  pushLinkImpl(stylesheetFlushingQueue, stylesheet.props);
+
+  for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+    writeChunk(this, stylesheetFlushingQueue[i]);
+  }
+
+  stylesheetFlushingQueue.length = 0;
+  stylesheet.state = PREAMBLE;
+}
+
+const styleTagResourceOpen1 = stringToPrecomputedChunk('<style data-precedence="');
+const styleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const spaceSeparator = stringToPrecomputedChunk(' ');
+const styleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const styleTagResourceClose = stringToPrecomputedChunk('</style>');
+
+function flushStylesInPreamble(styleQueue, precedence) {
+  const hasStylesheets = styleQueue.sheets.size > 0;
+  styleQueue.sheets.forEach(flushStyleInPreamble, this);
+  styleQueue.sheets.clear();
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs; // If we don't emit any stylesheets at this precedence we still need to maintain the precedence
+  // order so even if there are no rules for style tags at this precedence we emit an empty style
+  // tag with the data-precedence attribute
+
+  if (!hasStylesheets || hrefs.length) {
+    writeChunk(this, styleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    let i = 0;
+
+    if (hrefs.length) {
+      writeChunk(this, styleTagResourceOpen2);
+
+      for (; i < hrefs.length - 1; i++) {
+        writeChunk(this, hrefs[i]);
+        writeChunk(this, spaceSeparator);
+      }
+
+      writeChunk(this, hrefs[i]);
+    }
+
+    writeChunk(this, styleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    writeChunk(this, styleTagResourceClose); // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function preloadLateStyle(stylesheet) {
+  if (stylesheet.state === PENDING$1) {
+    stylesheet.state = PRELOADED;
+    const preloadProps = preloadAsStylePropsFromProps(stylesheet.props.href, stylesheet.props);
+    pushLinkImpl(stylesheetFlushingQueue, preloadProps);
+
+    for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+      writeChunk(this, stylesheetFlushingQueue[i]);
+    }
+
+    stylesheetFlushingQueue.length = 0;
+  }
+}
+
+function preloadLateStyles(styleQueue) {
+  styleQueue.sheets.forEach(preloadLateStyle, this);
+  styleQueue.sheets.clear();
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+
+function writePreamble(destination, resumableState, renderState, willFlushAllSegments) {
+  // This function must be called exactly once on every request
+  if (!willFlushAllSegments && renderState.externalRuntimeScript) {
+    // If the root segment is incomplete due to suspended tasks
+    // (e.g. willFlushAllSegments = false) and we are using data
+    // streaming format, ensure the external runtime is sent.
+    // (User code could choose to send this even earlier by calling
+    //  preinit(...), if they know they will suspend).
+    const _renderState$external = renderState.externalRuntimeScript,
+          src = _renderState$external.src,
+          chunks = _renderState$external.chunks;
+    internalPreinitScript(resumableState, renderState, src, chunks);
+  }
+
+  const htmlChunks = renderState.htmlChunks;
+  const headChunks = renderState.headChunks;
+  let i = 0; // Emit open tags before Hoistables and Resources
+
+  if (htmlChunks) {
+    // We have an <html> to emit as part of the preamble
+    for (i = 0; i < htmlChunks.length; i++) {
+      writeChunk(destination, htmlChunks[i]);
+    }
+
+    if (headChunks) {
+      for (i = 0; i < headChunks.length; i++) {
+        writeChunk(destination, headChunks[i]);
+      }
+    } else {
+      // We did not render a head but we emitted an <html> so we emit one now
+      writeChunk(destination, startChunkForTag('head'));
+      writeChunk(destination, endOfStartTag);
+    }
+  } else if (headChunks) {
+    // We do not have an <html> but we do have a <head>
+    for (i = 0; i < headChunks.length; i++) {
+      writeChunk(destination, headChunks[i]);
+    }
+  } // Emit high priority Hoistables
+
+
+  const charsetChunks = renderState.charsetChunks;
+
+  for (i = 0; i < charsetChunks.length; i++) {
+    writeChunk(destination, charsetChunks[i]);
+  }
+
+  charsetChunks.length = 0; // emit preconnect resources
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Flush unblocked stylesheets by precedence
+
+  renderState.styles.forEach(flushStylesInPreamble, destination);
+  const importMapChunks = renderState.importMapChunks;
+
+  for (i = 0; i < importMapChunks.length; i++) {
+    writeChunk(destination, importMapChunks[i]);
+  }
+
+  importMapChunks.length = 0;
+  renderState.bootstrapScripts.forEach(flushResource, destination);
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0; // Flush closing head if necessary
+
+  if (htmlChunks && headChunks === null) {
+    // We have an <html> rendered but no <head> rendered. We however inserted
+    // a <head> up above so we need to emit the </head> now. This is safe because
+    // if the main content contained the </head> it would also have provided a
+    // <head>. This means that all the content inside <html> is either <body> or
+    // invalid HTML
+    writeChunk(destination, endChunkForTag('head'));
+  }
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+function writeHoistables(destination, resumableState, renderState) {
+  let i = 0; // Emit high priority Hoistables
+  // We omit charsetChunks because we have already sent the shell and if it wasn't
+  // already sent it is too late now.
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Preload any stylesheets. these will emit in a render instruction that follows this
+  // but we want to kick off preloading as soon as possible
+
+  renderState.styles.forEach(preloadLateStyles, destination); // We only hoist importmaps that are configured through createResponse and that will
+  // always flush in the preamble. Generally we don't expect people to render them as
+  // tags when using React but if you do they are going to be treated like regular inline
+  // scripts and flush after other hoistables which is problematic
+  // bootstrap scripts should flush above script priority but these can only flush in the preamble
+  // so we elide the code here for performance
+
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0;
+}
+function writePostamble(destination, resumableState) {
+  if (resumableState.hasBody) {
+    writeChunk(destination, endChunkForTag('body'));
+  }
+
+  if (resumableState.hasHtml) {
+    writeChunk(destination, endChunkForTag('html'));
+  }
+}
+const arrayFirstOpenBracket = stringToPrecomputedChunk('[');
+const arraySubsequentOpenBracket = stringToPrecomputedChunk(',[');
+const arrayInterstitial = stringToPrecomputedChunk(',');
+const arrayCloseBracket = stringToPrecomputedChunk(']'); // This function writes a 2D array of strings to be embedded in javascript.
+// E.g.
+//  [["JS_escaped_string1", "JS_escaped_string2"]]
+
+function writeStyleResourceDependenciesInJS(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInJS(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInJS(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInJS(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+}
+
+function writeStyleResourceDependencyInJS(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedPrecedence)));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          writeStyleResourceAttributeInJS(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInJS(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeName)));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeValue)));
+} // This function writes a 2D array of strings to be embedded in an attribute
+// value and read with JSON.parse in ReactDOMServerExternalRuntime.js
+// E.g.
+//  [[&quot;JSON_escaped_string1&quot;, &quot;JSON_escaped_string2&quot;]]
+
+
+function writeStyleResourceDependenciesInAttr(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInAttr(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInAttr(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInAttr(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+}
+
+function writeStyleResourceDependencyInAttr(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedPrecedence))));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          writeStyleResourceAttributeInAttr(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInAttr(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeName))));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeValue))));
+}
+/**
+ * Resources
+ */
+
+
+const PENDING$1 = 0;
+const PRELOADED = 1;
+const PREAMBLE = 2;
+const LATE = 3;
+function createBoundaryResources() {
+  return {
+    styles: new Set(),
+    stylesheets: new Set()
+  };
+}
+function setCurrentlyRenderingBoundaryResourcesTarget(renderState, boundaryResources) {
+  renderState.boundaryResources = boundaryResources;
+}
+
+function getResourceKey(href) {
+  return href;
+}
+
+function getImageResourceKey(href, imageSrcSet, imageSizes) {
+  if (imageSrcSet) {
+    return imageSrcSet + '\n' + (imageSizes || '');
+  }
+
+  return href;
+}
+
+function prefetchDNS(href) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const key = getResourceKey(href);
+
+    if (!resumableState.dnsResources.hasOwnProperty(key)) {
+      resumableState.dnsResources[key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPrefetchDNSAsHeader(href), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this as resettable in case we are prerendering and postpone in the Shell
+        renderState.resets.dns[key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        // Encode as element
+        const resource = [];
+        pushLinkImpl(resource, {
+          href,
+          rel: 'dns-prefetch'
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preconnect(href, crossOrigin) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const bucket = crossOrigin === 'use-credentials' ? 'credentials' : typeof crossOrigin === 'string' ? 'anonymous' : 'default';
+    const key = getResourceKey(href);
+
+    if (!resumableState.connectResources[bucket].hasOwnProperty(key)) {
+      resumableState.connectResources[bucket][key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPreconnectAsHeader(href, crossOrigin), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this in resettableState in case we are prerending and postpone in the Shell
+        renderState.resets.connect[bucket][key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        const resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preconnect',
+          href,
+          crossOrigin
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preload(href, as, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (as && href) {
+    switch (as) {
+      case 'image':
+        {
+          let imageSrcSet, imageSizes, fetchPriority;
+
+          if (options) {
+            imageSrcSet = options.imageSrcSet;
+            imageSizes = options.imageSizes;
+            fetchPriority = options.fetchPriority;
+          }
+
+          const key = getImageResourceKey(href, imageSrcSet, imageSizes);
+
+          if (resumableState.imageResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && fetchPriority === 'high' && ( // Compute the header since we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit a preload as a header so we
+            // track this to make sure we don't reset it.
+            renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+            if (headers.highImagePreloads) {
+              headers.highImagePreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.highImagePreloads += header;
+          } else {
+            // If we don't have headers to write to we have to encode as elements to flush in the head
+            // When we have imageSrcSet the browser probably cannot load the right version from headers
+            // (this should be verified by testing). For now we assume these need to go in the head
+            // as elements even if headers are available.
+            const resource = [];
+            pushLinkImpl(resource, assign({
+              rel: 'preload',
+              // There is a bug in Safari where imageSrcSet is not respected on preload links
+              // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+              // This harms older browers that do not support imageSrcSet by making their preloads not work
+              // but this population is shrinking fast and is already small so we accept this tradeoff.
+              href: imageSrcSet ? undefined : href,
+              as
+            }, options));
+
+            if (fetchPriority === 'high') {
+              renderState.highImagePreloads.add(resource);
+            } else {
+              renderState.bulkPreloads.add(resource); // Stash the resource in case we need to promote it to higher priority
+              // when an img tag is rendered
+
+              renderState.preloads.images.set(key, resource);
+            }
+          }
+
+          break;
+        }
+
+      case 'style':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.styleResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.styleResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.stylesheets.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          break;
+        }
+
+      case 'script':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.scriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          renderState.preloads.scripts.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.scriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          break;
+        }
+
+      default:
+        {
+          const key = getResourceKey(href);
+          const hasAsType = resumableState.unknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.unknownResources[as] = resources;
+          }
+
+          resources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && as === 'font' && ( // We compute the header here because we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit this preload so we
+            // track it here to prevent it from being reset.
+            renderState.resets.font[key] = PRELOAD_NO_CREDS;
+
+            if (headers.fontPreloads) {
+              headers.fontPreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.fontPreloads += header;
+          } else {
+            // We either don't have headers or we are preloading something that does
+            // not warrant elevated priority so we encode as an element.
+            const resource = [];
+
+            const props = assign({
+              rel: 'preload',
+              href,
+              as
+            }, options);
+
+            pushLinkImpl(resource, props);
+
+            switch (as) {
+              case 'font':
+                renderState.fontPreloads.add(resource);
+                break;
+              // intentional fall through
+
+              default:
+                renderState.bulkPreloads.add(resource);
+            }
+          }
+        }
+    } // If we got this far we created a new resource
+
+
+    flushResources(request);
+  }
+}
+
+function preloadModule(href, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    const key = getResourceKey(href);
+    const as = options && typeof options.as === 'string' ? options.as : 'script';
+    let resource;
+
+    switch (as) {
+      case 'script':
+        {
+          if (resumableState.moduleScriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resource = [];
+          resumableState.moduleScriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.moduleScripts.set(key, resource);
+          break;
+        }
+
+      default:
+        {
+          const hasAsType = resumableState.moduleUnknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.moduleUnknownResources[as] = resources;
+          }
+
+          resource = [];
+          resources[key] = PRELOAD_NO_CREDS;
+        }
+    }
+
+    pushLinkImpl(resource, assign({
+      rel: 'modulepreload',
+      href
+    }, options));
+    renderState.bulkPreloads.add(resource); // If we got this far we created a new resource
+
+    flushResources(request);
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    precedence = precedence || 'default';
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+      // to create a StyleQueue
+
+      if (!styleQueue) {
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      }
+
+      const resource = {
+        state: PENDING$1,
+        props: assign({
+          rel: 'stylesheet',
+          href,
+          'data-precedence': precedence
+        }, options)
+      };
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(resource.props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.stylesheets.get(key);
+
+        if (preloadResource && preloadResource.length > 0) {
+          // The Preload for this resource was created in this render pass and has not flushed yet so
+          // we need to clear it to avoid it flushing.
+          preloadResource.length = 0;
+        } else {
+          // Either the preload resource from this render already flushed in this render pass
+          // or the preload flushed in a prior pass (prerender). In either case we need to mark
+          // this resource as already having been preloaded.
+          resource.state = PRELOADED;
+        }
+      } // We add the newly created resource to our StyleQueue and if necessary
+      // track the resource with the currently rendering boundary
+
+
+      styleQueue.sheets.set(key, resource); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+  }
+}
+
+function preinitScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.scriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.scriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.scriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.scripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+}
+
+function preinitModuleScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.moduleScriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.moduleScriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.moduleScriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        type: 'module',
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.moduleScripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+} // This function is only safe to call at Request start time since it assumes
+// that each module has not already been preloaded. If we find a need to preload
+// scripts at any other point in time we will need to check whether the preload
+// already exists and not assume it
+
+
+function preloadBootstrapScriptOrModule(resumableState, renderState, href, props) {
+
+  const key = getResourceKey(href);
+  // used to preinit the resource. If a script can be preinited then it shouldn't
+  // be a bootstrap script/module and if it is a bootstrap script/module then it
+  // must not be safe to emit early. To avoid possibly allowing for preinits of
+  // bootstrap scripts/modules we occlude these keys.
+
+
+  resumableState.scriptResources[key] = EXISTS;
+  resumableState.moduleScriptResources[key] = EXISTS;
+  const resource = [];
+  pushLinkImpl(resource, props);
+  renderState.bootstrapScripts.add(resource);
+}
+
+function internalPreinitScript(resumableState, renderState, src, chunks) {
+  const key = getResourceKey(src);
+
+  if (!resumableState.scriptResources.hasOwnProperty(key)) {
+    const resource = chunks;
+    resumableState.scriptResources[key] = EXISTS;
+    renderState.scripts.add(resource);
+  }
+
+  return;
+}
+
+function preloadAsStylePropsFromProps(href, props) {
+  return {
+    rel: 'preload',
+    as: 'style',
+    href: href,
+    crossOrigin: props.crossOrigin,
+    fetchPriority: props.fetchPriority,
+    integrity: props.integrity,
+    media: props.media,
+    hrefLang: props.hrefLang,
+    referrerPolicy: props.referrerPolicy
+  };
+}
+
+function stylesheetPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    'data-precedence': rawProps.precedence,
+    precedence: null
+  });
+}
+
+function adoptPreloadCredentials(target, preloadState) {
+  if (target.crossOrigin == null) target.crossOrigin = preloadState[0];
+  if (target.integrity == null) target.integrity = preloadState[1];
+}
+
+function getPrefetchDNSAsHeader(href) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  return "<" + escapedHref + ">; rel=dns-prefetch";
+}
+
+function getPreconnectAsHeader(href, crossOrigin) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  let value = "<" + escapedHref + ">; rel=preconnect";
+
+  if (typeof crossOrigin === 'string') {
+    const escapedCrossOrigin = escapeStringForLinkHeaderQuotedParamValueContext(crossOrigin);
+    value += "; crossorigin=\"" + escapedCrossOrigin + "\"";
+  }
+
+  return value;
+}
+
+function getPreloadAsHeader(href, as, params) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  const escapedAs = escapeStringForLinkHeaderQuotedParamValueContext(as);
+  let value = "<" + escapedHref + ">; rel=preload; as=\"" + escapedAs + "\"";
+
+  for (const paramName in params) {
+    if (hasOwnProperty.call(params, paramName)) {
+      const paramValue = params[paramName];
+
+      if (typeof paramValue === 'string') {
+        value += "; " + paramName.toLowerCase() + "=\"" + escapeStringForLinkHeaderQuotedParamValueContext(paramValue) + "\"";
+      }
+    }
+  }
+
+  return value;
+}
+
+function getStylesheetPreloadAsHeader(stylesheet) {
+  const props = stylesheet.props;
+  const preloadOptions = {
+    crossOrigin: props.crossOrigin,
+    integrity: props.integrity,
+    nonce: props.nonce,
+    type: props.type,
+    fetchPriority: props.fetchPriority,
+    referrerPolicy: props.referrerPolicy,
+    media: props.media
+  };
+  return getPreloadAsHeader(props.href, 'style', preloadOptions);
+} // This escaping function is only safe to use for href values being written into
+// a "Link" header in between `<` and `>` characters. The primary concern with the href is
+// to escape the bounding characters as well as new lines. This is unsafe to use in any other
+// context
+
+
+const regexForHrefInLinkHeaderURLContext = /[<>\r\n]/g;
+
+function escapeHrefForLinkHeaderURLContext(hrefInput) {
+
+  const coercedHref = '' + hrefInput;
+  return coercedHref.replace(regexForHrefInLinkHeaderURLContext, escapeHrefForLinkHeaderURLContextReplacer);
+}
+
+function escapeHrefForLinkHeaderURLContextReplacer(match) {
+  switch (match) {
+    case '<':
+      return '%3C';
+
+    case '>':
+      return '%3E';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeLinkHrefForHeaderContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+} // This escaping function is only safe to use for quoted param values in an HTTP header.
+// It is unsafe to use for any value not inside quote marks in parater value position.
+
+
+const regexForLinkHeaderQuotedParamValueContext = /["';,\r\n]/g;
+
+function escapeStringForLinkHeaderQuotedParamValueContext(value, name) {
+
+  const coerced = '' + value;
+  return coerced.replace(regexForLinkHeaderQuotedParamValueContext, escapeStringForLinkHeaderQuotedParamValueContextReplacer);
+}
+
+function escapeStringForLinkHeaderQuotedParamValueContextReplacer(match) {
+  switch (match) {
+    case '"':
+      return '%22';
+
+    case "'":
+      return '%27';
+
+    case ';':
+      return '%3B';
+
+    case ',':
+      return '%2C';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeStringForLinkHeaderQuotedParamValueContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+}
+
+function hoistStyleQueueDependency(styleQueue) {
+  this.styles.add(styleQueue);
+}
+
+function hoistStylesheetDependency(stylesheet) {
+  this.stylesheets.add(stylesheet);
+}
+
+function hoistResources(renderState, source) {
+  const currentBoundaryResources = renderState.boundaryResources;
+
+  if (currentBoundaryResources) {
+    source.styles.forEach(hoistStyleQueueDependency, currentBoundaryResources);
+    source.stylesheets.forEach(hoistStylesheetDependency, currentBoundaryResources);
+  }
+} // This function is called at various times depending on whether we are rendering
+// or prerendering. In this implementation we only actually emit headers once and
+// subsequent calls are ignored. We track whether the request has a completed shell
+// to determine whether we will follow headers with a flush including stylesheets.
+// In the context of prerrender we don't have a completed shell when the request finishes
+// with a postpone in the shell. In the context of a render we don't have a completed shell
+// if this is called before the shell finishes rendering which usually will happen anytime
+// anything suspends in the shell.
+
+function emitEarlyPreloads(renderState, resumableState, shellComplete) {
+  const onHeaders = renderState.onHeaders;
+
+  if (onHeaders) {
+    const headers = renderState.headers;
+
+    if (headers) {
+      let linkHeader = headers.preconnects;
+
+      if (headers.fontPreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.fontPreloads;
+      }
+
+      if (headers.highImagePreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.highImagePreloads;
+      }
+
+      if (!shellComplete) {
+        // We use raw iterators because we want to be able to halt iteration
+        // We could refactor renderState to store these dually in arrays to
+        // make this more efficient at the cost of additional memory and
+        // write overhead. However this code only runs once per request so
+        // for now I consider this sufficient.
+        const queueIter = renderState.styles.values();
+
+        outer: for (let queueStep = queueIter.next(); headers.remainingCapacity > 0 && !queueStep.done; queueStep = queueIter.next()) {
+          const sheets = queueStep.value.sheets;
+          const sheetIter = sheets.values();
+
+          for (let sheetStep = sheetIter.next(); headers.remainingCapacity > 0 && !sheetStep.done; sheetStep = sheetIter.next()) {
+            const sheet = sheetStep.value;
+            const props = sheet.props;
+            const key = getResourceKey(props.href);
+            const header = getStylesheetPreloadAsHeader(sheet); // We mutate the capacity b/c we don't want to keep checking if later headers will fit.
+            // This means that a particularly long header might close out the header queue where later
+            // headers could still fit. We could in the future alter the behavior here based on prerender vs render
+            // since during prerender we aren't as concerned with pure runtime performance.
+
+            if ((headers.remainingCapacity -= header.length) >= 2) {
+              renderState.resets.style[key] = PRELOAD_NO_CREDS;
+
+              if (linkHeader) {
+                linkHeader += ', ';
+              }
+
+              linkHeader += header; // We already track that the resource exists in resumableState however
+              // if the resumableState resets because we postponed in the shell
+              // which is what is happening in this branch if we are prerendering
+              // then we will end up resetting the resumableState. When it resets we
+              // want to record the fact that this stylesheet was already preloaded
+
+              renderState.resets.style[key] = typeof props.crossOrigin === 'string' || typeof props.integrity === 'string' ? [props.crossOrigin, props.integrity] : PRELOAD_NO_CREDS;
+            } else {
+              break outer;
+            }
+          }
+        }
+      }
+
+      if (linkHeader) {
+        onHeaders({
+          Link: linkHeader
+        });
+      } else {
+        // We still call this with no headers because a user may be using it as a signal that
+        // it React will not provide any headers
+        onHeaders({});
+      }
+
+      renderState.headers = null;
+      return;
+    }
+  }
+}
+const NotPendingTransition = NotPending;
+
+const requestStorage = new async_hooks.AsyncLocalStorage();
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+const REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_CONTEXT_TYPE = Symbol.for('react.context');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SCOPE_TYPE = Symbol.for('react.scope');
+const REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');
+const REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+const REACT_LEGACY_HIDDEN_TYPE = Symbol.for('react.legacy_hidden');
+const REACT_CACHE_TYPE = Symbol.for('react.cache');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+function getWrappedName(outerType, innerType, wrapperName) {
+  const displayName = outerType.displayName;
+
+  if (displayName) {
+    return displayName;
+  }
+
+  const functionName = innerType.displayName || innerType.name || '';
+  return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
+} // Keep in sync with react-reconciler/getComponentNameFromFiber
+
+
+function getContextName(type) {
+  return type.displayName || 'Context';
+} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+
+function getComponentNameFromType(type) {
+  if (type == null) {
+    // Host root, text node or just invalid type.
+    return null;
+  }
+
+  if (typeof type === 'function') {
+    return type.displayName || type.name || null;
+  }
+
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_FRAGMENT_TYPE:
+      return 'Fragment';
+
+    case REACT_PORTAL_TYPE:
+      return 'Portal';
+
+    case REACT_PROFILER_TYPE:
+      return 'Profiler';
+
+    case REACT_STRICT_MODE_TYPE:
+      return 'StrictMode';
+
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+
+    case REACT_CACHE_TYPE:
+      {
+        return 'Cache';
+      }
+
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        const context = type;
+        return getContextName(context) + '.Consumer';
+
+      case REACT_PROVIDER_TYPE:
+        const provider = type;
+        return getContextName(provider._context) + '.Provider';
+
+      case REACT_FORWARD_REF_TYPE:
+        return getWrappedName(type, type.render, 'ForwardRef');
+
+      case REACT_MEMO_TYPE:
+        const outerName = type.displayName || null;
+
+        if (outerName !== null) {
+          return outerName;
+        }
+
+        return getComponentNameFromType(type.type) || 'Memo';
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            return getComponentNameFromType(init(payload));
+          } catch (x) {
+            return null;
+          }
+        }
+
+      case REACT_SERVER_CONTEXT_TYPE:
+        {
+          const context2 = type;
+          return (context2.displayName || context2._globalName) + '.Provider';
+        }
+
+    }
+  }
+
+  return null;
+}
+
+const emptyContextObject = {};
+
+function getMaskedContext(type, unmaskedContext) {
+  {
+    const contextTypes = type.contextTypes;
+
+    if (!contextTypes) {
+      return emptyContextObject;
+    }
+
+    const context = {};
+
+    for (const key in contextTypes) {
+      context[key] = unmaskedContext[key];
+    }
+
+    return context;
+  }
+}
+function processChildContext(instance, type, parentContext, childContextTypes) {
+  {
+    // TODO (bvaughn) Replace this behavior with an invariant() in the future.
+    // It has only been added in Fiber to match the (unintentional) behavior in Stack.
+    if (typeof instance.getChildContext !== 'function') {
+
+      return parentContext;
+    }
+
+    const childContext = instance.getChildContext();
+
+    for (const contextKey in childContext) {
+      if (!(contextKey in childContextTypes)) {
+        throw new Error((getComponentNameFromType(type) || 'Unknown') + ".getChildContext(): key \"" + contextKey + "\" is not defined in childContextTypes.");
+      }
+    }
+
+    return assign({}, parentContext, childContext);
+  }
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext);
+    } // On the way back, we push the new ones that weren't common.
+
+
+    pushNode(next);
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function pushProvider(context, nextValue) {
+  let prevValue;
+
+  {
+    prevValue = context._currentValue;
+    context._currentValue = nextValue;
+  }
+
+  const prevNode = currentActiveSnapshot;
+  const newNode = {
+    parent: prevNode,
+    depth: prevNode === null ? 0 : prevNode.depth + 1,
+    context: context,
+    parentValue: prevValue,
+    value: nextValue
+  };
+  currentActiveSnapshot = newNode;
+  return newNode;
+}
+function popProvider(context) {
+  const prevSnapshot = currentActiveSnapshot;
+
+  if (prevSnapshot === null) {
+    throw new Error('Tried to pop a Context at the root of the app. This is a bug in React.');
+  }
+
+  {
+    const value = prevSnapshot.parentValue;
+
+    if (value === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      prevSnapshot.context._currentValue = prevSnapshot.context._defaultValue;
+    } else {
+      prevSnapshot.context._currentValue = value;
+    }
+  }
+
+  return currentActiveSnapshot = prevSnapshot.parent;
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+/**
+ * `ReactInstanceMap` maintains a mapping from a public facing stateful
+ * instance (key) and the internal representation (value). This allows public
+ * methods to accept the user facing instance as an argument and map them back
+ * to internal methods.
+ *
+ * Note that this module is currently shared and assumed to be stateless.
+ * If this becomes an actual Map, that will break.
+ */
+function get(key) {
+  return key._reactInternals;
+}
+function set(key, value) {
+  key._reactInternals = value;
+}
+
+const classComponentUpdater = {
+  isMounted(inst) {
+    return false;
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueSetState(inst, payload, callback) {
+    const internals = get(inst);
+
+    if (internals.queue === null) ; else {
+      internals.queue.push(payload);
+    }
+  },
+
+  enqueueReplaceState(inst, payload, callback) {
+    const internals = get(inst);
+    internals.replace = true;
+    internals.queue = [payload];
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueForceUpdate(inst, callback) {
+  }
+
+};
+
+function applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, prevState, nextProps) {
+  const partialState = getDerivedStateFromProps(nextProps, prevState);
+
+
+  const newState = partialState === null || partialState === undefined ? prevState : assign({}, prevState, partialState);
+  return newState;
+}
+
+function constructClassInstance(ctor, props, maskedLegacyContext) {
+  let context = emptyContextObject;
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    context = readContext$1(contextType);
+  } else {
+    context = maskedLegacyContext;
+  }
+
+  const instance = new ctor(props, context);
+
+  return instance;
+}
+
+function callComponentWillMount(type, instance) {
+  const oldState = instance.state;
+
+  if (typeof instance.componentWillMount === 'function') {
+
+    instance.componentWillMount();
+  }
+
+  if (typeof instance.UNSAFE_componentWillMount === 'function') {
+    instance.UNSAFE_componentWillMount();
+  }
+
+  if (oldState !== instance.state) {
+
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+}
+
+function processUpdateQueue(internalInstance, inst, props, maskedLegacyContext) {
+  if (internalInstance.queue !== null && internalInstance.queue.length > 0) {
+    const oldQueue = internalInstance.queue;
+    const oldReplace = internalInstance.replace;
+    internalInstance.queue = null;
+    internalInstance.replace = false;
+
+    if (oldReplace && oldQueue.length === 1) {
+      inst.state = oldQueue[0];
+    } else {
+      let nextState = oldReplace ? oldQueue[0] : inst.state;
+      let dontMutate = true;
+
+      for (let i = oldReplace ? 1 : 0; i < oldQueue.length; i++) {
+        const partial = oldQueue[i];
+        const partialState = typeof partial === 'function' ? partial.call(inst, nextState, props, maskedLegacyContext) : partial;
+
+        if (partialState != null) {
+          if (dontMutate) {
+            dontMutate = false;
+            nextState = assign({}, nextState, partialState);
+          } else {
+            assign(nextState, partialState);
+          }
+        }
+      }
+
+      inst.state = nextState;
+    }
+  } else {
+    internalInstance.queue = null;
+  }
+} // Invokes the mount life-cycles on a previously never rendered instance.
+
+
+function mountClassInstance(instance, ctor, newProps, maskedLegacyContext) {
+
+  const initialState = instance.state !== undefined ? instance.state : null;
+  instance.updater = classComponentUpdater;
+  instance.props = newProps;
+  instance.state = initialState; // We don't bother initializing the refs object on the server, since we're not going to resolve them anyway.
+  // The internal instance will be used to manage updates that happen during this mount.
+
+  const internalInstance = {
+    queue: [],
+    replace: false
+  };
+  set(instance, internalInstance);
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    instance.context = readContext$1(contextType);
+  } else {
+    instance.context = maskedLegacyContext;
+  }
+
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    instance.state = applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, initialState, newProps);
+  } // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+
+  if (typeof ctor.getDerivedStateFromProps !== 'function' && typeof instance.getSnapshotBeforeUpdate !== 'function' && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
+    callComponentWillMount(ctor, instance); // If we had additional state updates during this life-cycle, let's
+    // process them now.
+
+    processUpdateQueue(internalInstance, instance, newProps, maskedLegacyContext);
+  }
+}
+
+// Ids are base 32 strings whose binary representation corresponds to the
+// position of a node in a tree.
+// Every time the tree forks into multiple children, we add additional bits to
+// the left of the sequence that represent the position of the child within the
+// current level of children.
+//
+//      00101       00010001011010101
+//      ╰─┬─╯       ╰───────┬───────╯
+//   Fork 5 of 20       Parent id
+//
+// The leading 0s are important. In the above example, you only need 3 bits to
+// represent slot 5. However, you need 5 bits to represent all the forks at
+// the current level, so we must account for the empty bits at the end.
+//
+// For this same reason, slots are 1-indexed instead of 0-indexed. Otherwise,
+// the zeroth id at a level would be indistinguishable from its parent.
+//
+// If a node has only one child, and does not materialize an id (i.e. does not
+// contain a useId hook), then we don't need to allocate any space in the
+// sequence. It's treated as a transparent indirection. For example, these two
+// trees produce the same ids:
+//
+// <>                          <>
+//   <Indirection>               <A />
+//     <A />                     <B />
+//   </Indirection>            </>
+//   <B />
+// </>
+//
+// However, we cannot skip any node that materializes an id. Otherwise, a parent
+// id that does not fork would be indistinguishable from its child id. For
+// example, this tree does not fork, but the parent and child must have
+// different ids.
+//
+// <Parent>
+//   <Child />
+// </Parent>
+//
+// To handle this scenario, every time we materialize an id, we allocate a
+// new level with a single slot. You can think of this as a fork with only one
+// prong, or an array of children with length 1.
+//
+// It's possible for the size of the sequence to exceed 32 bits, the max
+// size for bitwise operations. When this happens, we make more room by
+// converting the right part of the id to a string and storing it in an overflow
+// variable. We use a base 32 string representation, because 32 is the largest
+// power of 2 that is supported by toString(). We want the base to be large so
+// that the resulting ids are compact, and we want the base to be a power of 2
+// because every log2(base) bits corresponds to a single character, i.e. every
+// log2(32) = 5 bits. That means we can lop bits off the end 5 at a time without
+// affecting the final result.
+const emptyTreeContext = {
+  id: 1,
+  overflow: ''
+};
+function getTreeId(context) {
+  const overflow = context.overflow;
+  const idWithLeadingBit = context.id;
+  const id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
+  return id.toString(32) + overflow;
+}
+function pushTreeContext(baseContext, totalChildren, index) {
+  const baseIdWithLeadingBit = baseContext.id;
+  const baseOverflow = baseContext.overflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
+  // of the id; we use it to account for leading 0s.
+
+  const baseLength = getBitLength(baseIdWithLeadingBit) - 1;
+  const baseId = baseIdWithLeadingBit & ~(1 << baseLength);
+  const slot = index + 1;
+  const length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
+  // consideration the leading 1 we use to mark the end of the sequence.
+
+  if (length > 30) {
+    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
+    // This branch assumes the length of the base id is greater than 5; it won't
+    // work for smaller ids, because you need 5 bits per character.
+    //
+    // We encode the id in multiple steps: first the base id, then the
+    // remaining digits.
+    //
+    // Each 5 bit sequence corresponds to a single base 32 character. So for
+    // example, if the current id is 23 bits long, we can convert 20 of those
+    // bits into a string of 4 characters, with 3 bits left over.
+    //
+    // First calculate how many bits in the base id represent a complete
+    // sequence of characters.
+    const numberOfOverflowBits = baseLength - baseLength % 5; // Then create a bitmask that selects only those bits.
+
+    const newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
+
+    const newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
+
+    const restOfBaseId = baseId >> numberOfOverflowBits;
+    const restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
+    // we made more room, this time it won't overflow.
+
+    const restOfLength = getBitLength(totalChildren) + restOfBaseLength;
+    const restOfNewBits = slot << restOfBaseLength;
+    const id = restOfNewBits | restOfBaseId;
+    const overflow = newOverflow + baseOverflow;
+    return {
+      id: 1 << restOfLength | id,
+      overflow
+    };
+  } else {
+    // Normal path
+    const newBits = slot << baseLength;
+    const id = newBits | baseId;
+    const overflow = baseOverflow;
+    return {
+      id: 1 << length | id,
+      overflow
+    };
+  }
+}
+
+function getBitLength(number) {
+  return 32 - clz32(number);
+}
+
+function getLeadingBit(id) {
+  return 1 << getBitLength(id) - 1;
+} // TODO: Math.clz32 is supported in Node 12+. Maybe we can drop the fallback.
+
+
+const 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
+
+const log = Math.log;
+const LN2 = Math.LN2;
+
+function clz32Fallback(x) {
+  const asUint = x >>> 0;
+
+  if (asUint === 0) {
+    return 32;
+  }
+
+  return 31 - (log(asUint) / LN2 | 0) | 0;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFlightWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop$2() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop$2, noop$2);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+
+const objectIs = // $FlowFixMe[method-unbinding]
+typeof Object.is === 'function' ? Object.is : is;
+
+let currentlyRenderingComponent = null;
+let currentlyRenderingTask = null;
+let currentlyRenderingRequest = null;
+let currentlyRenderingKeyPath = null;
+let firstWorkInProgressHook = null;
+let workInProgressHook = null; // Whether the work-in-progress hook is a re-rendered hook
+
+let isReRender = false; // Whether an update was scheduled during the currently executing render pass.
+
+let didScheduleRenderPhaseUpdate = false; // Counts the number of useId hooks in this component
+
+let localIdCounter = 0; // Chunks that should be pushed to the stream once the component
+// finishes rendering.
+// Counts the number of useFormState calls in this component
+
+let formStateCounter = 0; // The index of the useFormState hook that matches the one passed in at the
+// root during an MPA navigation, if any.
+
+let formStateMatchingIndex = -1; // Counts the number of use(thenable) calls in this component
+
+let thenableIndexCounter = 0;
+let thenableState = null; // Lazily created map of render-phase updates
+
+let renderPhaseUpdates = null; // Counter to prevent infinite loops.
+
+let numberOfReRenders = 0;
+const RE_RENDER_LIMIT = 25;
+
+function resolveCurrentlyRenderingComponent() {
+  if (currentlyRenderingComponent === null) {
+    throw new Error('Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for' + ' one of the following reasons:\n' + '1. You might have mismatching versions of React and the renderer (such as React DOM)\n' + '2. You might be breaking the Rules of Hooks\n' + '3. You might have more than one copy of React in the same app\n' + 'See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.');
+  }
+
+  return currentlyRenderingComponent;
+}
+
+function areHookInputsEqual(nextDeps, prevDeps) {
+  if (prevDeps === null) {
+
+    return false;
+  }
+
+
+  for (let i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    if (objectIs(nextDeps[i], prevDeps[i])) {
+      continue;
+    }
+
+    return false;
+  }
+
+  return true;
+}
+
+function createHook() {
+  if (numberOfReRenders > 0) {
+    throw new Error('Rendered more hooks than during the previous render');
+  }
+
+  return {
+    memoizedState: null,
+    queue: null,
+    next: null
+  };
+}
+
+function createWorkInProgressHook() {
+  if (workInProgressHook === null) {
+    // This is the first hook in the list
+    if (firstWorkInProgressHook === null) {
+      isReRender = false;
+      firstWorkInProgressHook = workInProgressHook = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = firstWorkInProgressHook;
+    }
+  } else {
+    if (workInProgressHook.next === null) {
+      isReRender = false; // Append to the end of the list
+
+      workInProgressHook = workInProgressHook.next = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = workInProgressHook.next;
+    }
+  }
+
+  return workInProgressHook;
+}
+
+function prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState) {
+  currentlyRenderingComponent = componentIdentity;
+  currentlyRenderingTask = task;
+  currentlyRenderingRequest = request;
+  currentlyRenderingKeyPath = keyPath;
+  // didScheduleRenderPhaseUpdate = false;
+  // firstWorkInProgressHook = null;
+  // numberOfReRenders = 0;
+  // renderPhaseUpdates = null;
+  // workInProgressHook = null;
+
+
+  localIdCounter = 0;
+  formStateCounter = 0;
+  formStateMatchingIndex = -1;
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function finishHooks(Component, props, children, refOrContext) {
+  // This must be called after every function component to prevent hooks from
+  // being used in classes.
+  while (didScheduleRenderPhaseUpdate) {
+    // Updates were scheduled during the render phase. They are stored in
+    // the `renderPhaseUpdates` map. Call the component again, reusing the
+    // work-in-progress hooks and applying the additional updates on top. Keep
+    // restarting until no more updates are scheduled.
+    didScheduleRenderPhaseUpdate = false;
+    localIdCounter = 0;
+    formStateCounter = 0;
+    formStateMatchingIndex = -1;
+    thenableIndexCounter = 0;
+    numberOfReRenders += 1; // Start over from the beginning of the list
+
+    workInProgressHook = null;
+    children = Component(props, refOrContext);
+  }
+
+  resetHooksState();
+  return children;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+function checkDidRenderIdHook() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  const didRenderIdHook = localIdCounter !== 0;
+  return didRenderIdHook;
+}
+function getFormStateCount() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateCounter;
+}
+function getFormStateMatchingIndex() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateMatchingIndex;
+} // Reset the internal hooks state if an error occurs while rendering a component
+
+function resetHooksState() {
+
+  currentlyRenderingComponent = null;
+  currentlyRenderingTask = null;
+  currentlyRenderingRequest = null;
+  currentlyRenderingKeyPath = null;
+  didScheduleRenderPhaseUpdate = false;
+  firstWorkInProgressHook = null;
+  numberOfReRenders = 0;
+  renderPhaseUpdates = null;
+  workInProgressHook = null;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+function useContext(context) {
+
+  resolveCurrentlyRenderingComponent();
+  return readContext$1(context);
+}
+
+function basicStateReducer(state, action) {
+  // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
+  return typeof action === 'function' ? action(state) : action;
+}
+
+function useState(initialState) {
+
+  return useReducer(basicStateReducer, // useReducer has a special case to support lazy useState initializers
+  initialState);
+}
+function useReducer(reducer, initialArg, init) {
+
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+
+  if (isReRender) {
+    // This is a re-render. Apply the new render phase updates to the previous
+    // current hook.
+    const queue = workInProgressHook.queue;
+    const dispatch = queue.dispatch;
+
+    if (renderPhaseUpdates !== null) {
+      // Render phase updates are stored in a map of queue -> linked list
+      const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+      if (firstRenderPhaseUpdate !== undefined) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        renderPhaseUpdates.delete(queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+        let newState = workInProgressHook.memoizedState;
+        let update = firstRenderPhaseUpdate;
+
+        do {
+          // Process this render phase update. We don't have to check the
+          // priority because it will always be the same as the current
+          // render's.
+          const action = update.action;
+
+          newState = reducer(newState, action);
+
+
+          update = update.next;
+        } while (update !== null); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+        workInProgressHook.memoizedState = newState;
+        return [newState, dispatch];
+      }
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    return [workInProgressHook.memoizedState, dispatch];
+  } else {
+
+    let initialState;
+
+    if (reducer === basicStateReducer) {
+      // Special case for `useState`.
+      initialState = typeof initialArg === 'function' ? initialArg() : initialArg;
+    } else {
+      initialState = init !== undefined ? init(initialArg) : initialArg;
+    }
+
+
+    workInProgressHook.memoizedState = initialState; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    const queue = workInProgressHook.queue = {
+      last: null,
+      dispatch: null
+    };
+    const dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingComponent, queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    return [workInProgressHook.memoizedState, dispatch];
+  }
+}
+
+function useMemo(nextCreate, deps) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+
+  if (workInProgressHook !== null) {
+    const prevState = workInProgressHook.memoizedState;
+
+    if (prevState !== null) {
+      if (nextDeps !== null) {
+        const prevDeps = prevState[1];
+
+        if (areHookInputsEqual(nextDeps, prevDeps)) {
+          return prevState[0];
+        }
+      }
+    }
+  }
+
+  const nextValue = nextCreate();
+
+
+  workInProgressHook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
+
+function useRef(initialValue) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const previousRef = workInProgressHook.memoizedState;
+
+  if (previousRef === null) {
+    const ref = {
+      current: initialValue
+    };
+
+
+    workInProgressHook.memoizedState = ref;
+    return ref;
+  } else {
+    return previousRef;
+  }
+}
+
+function dispatchAction(componentIdentity, queue, action) {
+  if (numberOfReRenders >= RE_RENDER_LIMIT) {
+    throw new Error('Too many re-renders. React limits the number of renders to prevent ' + 'an infinite loop.');
+  }
+
+  if (componentIdentity === currentlyRenderingComponent) {
+    // This is a render phase update. Stash it in a lazily-created map of
+    // queue -> linked list of updates. After this render pass, we'll restart
+    // and apply the stashed updates on top of the work-in-progress hook.
+    didScheduleRenderPhaseUpdate = true;
+    const update = {
+      action,
+      next: null
+    };
+
+    if (renderPhaseUpdates === null) {
+      renderPhaseUpdates = new Map();
+    }
+
+    const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+    if (firstRenderPhaseUpdate === undefined) {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      renderPhaseUpdates.set(queue, update);
+    } else {
+      // Append the update to the end of the list.
+      let lastRenderPhaseUpdate = firstRenderPhaseUpdate;
+
+      while (lastRenderPhaseUpdate.next !== null) {
+        lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+      }
+
+      lastRenderPhaseUpdate.next = update;
+    }
+  }
+}
+
+function useCallback(callback, deps) {
+  return useMemo(() => callback, deps);
+}
+
+function throwOnUseEffectEventCall() {
+  throw new Error("A function wrapped in useEffectEvent can't be called during rendering.");
+}
+
+function useEffectEvent(callback) {
+  // $FlowIgnore[incompatible-return]
+  return throwOnUseEffectEventCall;
+}
+
+function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  if (getServerSnapshot === undefined) {
+    throw new Error('Missing getServerSnapshot, which is required for ' + 'server-rendered content. Will revert to client rendering.');
+  }
+
+  return getServerSnapshot();
+}
+
+function useDeferredValue(value, initialValue) {
+  resolveCurrentlyRenderingComponent();
+
+  {
+    return initialValue !== undefined ? initialValue : value;
+  }
+}
+
+function unsupportedStartTransition() {
+  throw new Error('startTransition cannot be called during server rendering.');
+}
+
+function useTransition() {
+  resolveCurrentlyRenderingComponent();
+  return [false, unsupportedStartTransition];
+}
+
+function useHostTransitionStatus() {
+  resolveCurrentlyRenderingComponent();
+  return NotPendingTransition;
+}
+
+function unsupportedSetOptimisticState() {
+  throw new Error('Cannot update optimistic state while rendering.');
+}
+
+function useOptimistic(passthrough, reducer) {
+  resolveCurrentlyRenderingComponent();
+  return [passthrough, unsupportedSetOptimisticState];
+}
+
+function createPostbackFormStateKey(permalink, componentKeyPath, hookIndex) {
+  if (permalink !== undefined) {
+    // Don't bother to hash a permalink-based key since it's already short.
+    return 'p' + permalink;
+  } else {
+    // Append a node to the key path that represents the form state hook.
+    const keyPath = [componentKeyPath, null, hookIndex]; // Key paths are hashed to reduce the size. It does not need to be secure,
+    // and it's more important that it's fast than that it's completely
+    // collision-free.
+
+    const keyPathHash = createFastHash(JSON.stringify(keyPath));
+    return 'k' + keyPathHash;
+  }
+}
+
+function useFormState(action, initialState, permalink) {
+  resolveCurrentlyRenderingComponent(); // Count the number of useFormState hooks per component. We also use this to
+  // track the position of this useFormState hook relative to the other ones in
+  // this component, so we can generate a unique key for each one.
+
+  const formStateHookIndex = formStateCounter++;
+  const request = currentlyRenderingRequest; // $FlowIgnore[prop-missing]
+
+  const formAction = action.$$FORM_ACTION;
+
+  if (typeof formAction === 'function') {
+    // This is a server action. These have additional features to enable
+    // MPA-style form submissions with progressive enhancement.
+    // TODO: If the same permalink is passed to multiple useFormStates, and
+    // they all have the same action signature, Fizz will pass the postback
+    // state to all of them. We should probably only pass it to the first one,
+    // and/or warn.
+    // The key is lazily generated and deduped so the that the keypath doesn't
+    // get JSON.stringify-ed unnecessarily, and at most once.
+    let nextPostbackStateKey = null; // Determine the current form state. If we received state during an MPA form
+    // submission, then we will reuse that, if the action identity matches.
+    // Otherwise we'll use the initial state argument. We will emit a comment
+    // marker into the stream that indicates whether the state was reused.
+
+    let state = initialState;
+    const componentKeyPath = currentlyRenderingKeyPath;
+    const postbackFormState = getFormState(request); // $FlowIgnore[prop-missing]
+
+    const isSignatureEqual = action.$$IS_SIGNATURE_EQUAL;
+
+    if (postbackFormState !== null && typeof isSignatureEqual === 'function') {
+      const postbackKey = postbackFormState[1];
+      const postbackReferenceId = postbackFormState[2];
+      const postbackBoundArity = postbackFormState[3];
+
+      if (isSignatureEqual.call(action, postbackReferenceId, postbackBoundArity)) {
+        nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+
+        if (postbackKey === nextPostbackStateKey) {
+          // This was a match
+          formStateMatchingIndex = formStateHookIndex; // Reuse the state that was submitted by the form.
+
+          state = postbackFormState[0];
+        }
+      }
+    } // Bind the state to the first argument of the action.
+
+
+    const boundAction = action.bind(null, state); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    }; // $FlowIgnore[prop-missing]
+
+
+    if (typeof boundAction.$$FORM_ACTION === 'function') {
+      // $FlowIgnore[prop-missing]
+      dispatch.$$FORM_ACTION = prefix => {
+        const metadata = boundAction.$$FORM_ACTION(prefix); // Override the action URL
+
+        if (permalink !== undefined) {
+
+          permalink += '';
+          metadata.action = permalink;
+        }
+
+        const formData = metadata.data;
+
+        if (formData) {
+          if (nextPostbackStateKey === null) {
+            nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+          }
+
+          formData.append('$ACTION_KEY', nextPostbackStateKey);
+        }
+
+        return metadata;
+      };
+    }
+
+    return [state, dispatch];
+  } else {
+    // This is not a server action, so the implementation is much simpler.
+    // Bind the state to the first argument of the action.
+    const boundAction = action.bind(null, initialState); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    };
+
+    return [initialState, dispatch];
+  }
+}
+
+function useId() {
+  const task = currentlyRenderingTask;
+  const treeId = getTreeId(task.treeContext);
+  const resumableState = currentResumableState;
+
+  if (resumableState === null) {
+    throw new Error('Invalid hook call. Hooks can only be called inside of the body of a function component.');
+  }
+
+  const localId = localIdCounter++;
+  return makeId(resumableState, treeId, localId);
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable;
+      return unwrapThenable(thenable);
+    } else if (usable.$$typeof === REACT_CONTEXT_TYPE || usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function unwrapThenable(thenable) {
+  const index = thenableIndexCounter;
+  thenableIndexCounter += 1;
+
+  if (thenableState === null) {
+    thenableState = createThenableState();
+  }
+
+  return trackUsedThenable(thenableState, thenable, index);
+}
+
+function unsupportedRefresh() {
+  throw new Error('Cache cannot be refreshed during server rendering.');
+}
+
+function useCacheRefresh() {
+  return unsupportedRefresh;
+}
+
+function useMemoCache(size) {
+  const data = new Array(size);
+
+  for (let i = 0; i < size; i++) {
+    data[i] = REACT_MEMO_CACHE_SENTINEL;
+  }
+
+  return data;
+}
+
+function noop$1() {}
+
+const HooksDispatcher = {
+  readContext,
+  use,
+  useContext,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+  useInsertionEffect: noop$1,
+  useLayoutEffect: noop$1,
+  useCallback,
+  // useImperativeHandle is not run in the server environment
+  useImperativeHandle: noop$1,
+  // Effects are not run in the server environment.
+  useEffect: noop$1,
+  // Debugging effect
+  useDebugValue: noop$1,
+  useDeferredValue,
+  useTransition,
+  useId,
+  // Subscriptions are not setup in a server environment.
+  useSyncExternalStore
+};
+
+{
+  HooksDispatcher.useCacheRefresh = useCacheRefresh;
+}
+
+{
+  HooksDispatcher.useEffectEvent = useEffectEvent;
+}
+
+{
+  HooksDispatcher.useMemoCache = useMemoCache;
+}
+
+{
+  HooksDispatcher.useHostTransitionStatus = useHostTransitionStatus;
+}
+
+{
+  HooksDispatcher.useOptimistic = useOptimistic;
+  HooksDispatcher.useFormState = useFormState;
+}
+
+let currentResumableState = null;
+function setCurrentResumableState(resumableState) {
+  currentResumableState = resumableState;
+}
+
+function getCacheSignal() {
+  throw new Error('Not implemented.');
+}
+
+function getCacheForType(resourceType) {
+  throw new Error('Not implemented.');
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal,
+  getCacheForType
+};
+
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+const ReactCurrentCache = ReactSharedInternals.ReactCurrentCache;
+// The name might be minified but we assume that it's going to be the same generated name. Typically
+// because it's just the same compiled output in practice.
+// resume with segmentID at the index
+
+const CLIENT_RENDERED = 4; // if it errors or infinitely suspends
+
+const PENDING = 0;
+const COMPLETED = 1;
+const FLUSHED = 2;
+const ABORTED = 3;
+const ERRORED = 4;
+const POSTPONED = 5;
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2; // This is a default heuristic for how to split up the HTML content into progressive
+// loading. Our goal is to be able to display additional new content about every 500ms.
+// Faster than that is unnecessary and should be throttled on the client. It also
+// adds unnecessary overhead to do more splits. We don't know if it's a higher or lower
+// end device but higher end suffer less from the overhead than lower end does from
+// not getting small enough pieces. We error on the side of low end.
+// We base this on low end 3G speeds which is about 500kbits per second. We assume
+// that there can be a reasonable drop off from max bandwidth which leaves you with
+// as little as 80%. We can receive half of that each 500ms - at best. In practice,
+// a little bandwidth is lost to processing and contention - e.g. CSS and images that
+// are downloaded along with the main content. So we estimate about half of that to be
+// the lower end throughput. In other words, we expect that you can at least show
+// about 12.5kb of content per 500ms. Not counting starting latency for the first
+// paint.
+// 500 * 1024 / 8 * .8 * 0.5 / 2
+
+const DEFAULT_PROGRESSIVE_CHUNK_SIZE = 12800;
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+
+  return null;
+}
+
+function noop() {}
+
+function createRequest(children, resumableState, renderState, rootFormatContext, progressiveChunkSize, onError, onAllReady, onShellReady, onShellError, onFatalError, onPostpone, formState) {
+  prepareHostDispatcher();
+  const pingedTasks = [];
+  const abortSet = new Set();
+  const request = {
+    destination: null,
+    flushScheduled: false,
+    resumableState,
+    renderState,
+    rootFormatContext,
+    progressiveChunkSize: progressiveChunkSize === undefined ? DEFAULT_PROGRESSIVE_CHUNK_SIZE : progressiveChunkSize,
+    status: OPEN,
+    fatalError: null,
+    nextSegmentId: 0,
+    allPendingTasks: 0,
+    pendingRootTasks: 0,
+    completedRootSegment: null,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    clientRenderedBoundaries: [],
+    completedBoundaries: [],
+    partialBoundaries: [],
+    trackedPostpones: null,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? noop : onPostpone,
+    onAllReady: onAllReady === undefined ? noop : onAllReady,
+    onShellReady: onShellReady === undefined ? noop : onShellReady,
+    onShellError: onShellError === undefined ? noop : onShellError,
+    onFatalError: onFatalError === undefined ? noop : onFatalError,
+    formState: formState === undefined ? null : formState
+  }; // This segment represents the root fallback.
+
+  const rootSegment = createPendingSegment(request, 0, null, rootFormatContext, // Root segments are never embedded in Text on either edge
+  false, false); // There is no parent so conceptually, we're unblocked to flush this segment.
+
+  rootSegment.parentFlushed = true;
+  const rootTask = createRenderTask(request, null, children, -1, null, rootSegment, abortSet, null, rootFormatContext, emptyContextObject, rootContextSnapshot, emptyTreeContext);
+  pingedTasks.push(rootTask);
+  return request;
+}
+function createPrerenderRequest(children, resumableState, renderState, rootFormatContext, progressiveChunkSize, onError, onAllReady, onShellReady, onShellError, onFatalError, onPostpone) {
+  const request = createRequest(children, resumableState, renderState, rootFormatContext, progressiveChunkSize, onError, onAllReady, onShellReady, onShellError, onFatalError, onPostpone, undefined); // Start tracking postponed holes during this render.
+
+  request.trackedPostpones = {
+    workingMap: new Map(),
+    rootNodes: [],
+    rootSlots: null
+  };
+  return request;
+}
+function resumeRequest(children, postponedState, renderState, onError, onAllReady, onShellReady, onShellError, onFatalError, onPostpone) {
+  prepareHostDispatcher();
+  const pingedTasks = [];
+  const abortSet = new Set();
+  const request = {
+    destination: null,
+    flushScheduled: false,
+    resumableState: postponedState.resumableState,
+    renderState,
+    rootFormatContext: postponedState.rootFormatContext,
+    progressiveChunkSize: postponedState.progressiveChunkSize,
+    status: OPEN,
+    fatalError: null,
+    nextSegmentId: postponedState.nextSegmentId,
+    allPendingTasks: 0,
+    pendingRootTasks: 0,
+    completedRootSegment: null,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    clientRenderedBoundaries: [],
+    completedBoundaries: [],
+    partialBoundaries: [],
+    trackedPostpones: null,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? noop : onPostpone,
+    onAllReady: onAllReady === undefined ? noop : onAllReady,
+    onShellReady: onShellReady === undefined ? noop : onShellReady,
+    onShellError: onShellError === undefined ? noop : onShellError,
+    onFatalError: onFatalError === undefined ? noop : onFatalError,
+    formState: null
+  };
+
+  if (typeof postponedState.replaySlots === 'number') {
+    const resumedId = postponedState.replaySlots; // We have a resume slot at the very root. This is effectively just a full rerender.
+
+    const rootSegment = createPendingSegment(request, 0, null, postponedState.rootFormatContext, // Root segments are never embedded in Text on either edge
+    false, false);
+    rootSegment.id = resumedId; // There is no parent so conceptually, we're unblocked to flush this segment.
+
+    rootSegment.parentFlushed = true;
+    const rootTask = createRenderTask(request, null, children, -1, null, rootSegment, abortSet, null, postponedState.rootFormatContext, emptyContextObject, rootContextSnapshot, emptyTreeContext);
+    pingedTasks.push(rootTask);
+    return request;
+  }
+
+  const replay = {
+    nodes: postponedState.replayNodes,
+    slots: postponedState.replaySlots,
+    pendingTasks: 0
+  };
+  const rootTask = createReplayTask(request, null, replay, children, -1, null, abortSet, null, postponedState.rootFormatContext, emptyContextObject, rootContextSnapshot, emptyTreeContext);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  {
+    const store = requestStorage.getStore();
+    if (store) return store;
+  }
+
+  return null;
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (request.pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createSuspenseBoundary(request, fallbackAbortableTasks) {
+  return {
+    status: PENDING,
+    rootSegmentID: -1,
+    parentFlushed: false,
+    pendingTasks: 0,
+    completedSegments: [],
+    byteSize: 0,
+    fallbackAbortableTasks,
+    errorDigest: null,
+    resources: createBoundaryResources(),
+    trackedContentKeyPath: null,
+    trackedFallbackNode: null
+  };
+}
+
+function createRenderTask(request, thenableState, node, childIndex, blockedBoundary, blockedSegment, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  const task = {
+    replay: null,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createReplayTask(request, thenableState, replay, node, childIndex, blockedBoundary, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  replay.pendingTasks++;
+  const task = {
+    replay,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment: null,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createPendingSegment(request, index, boundary, parentFormatContext, lastPushedText, textEmbedded) {
+  return {
+    status: PENDING,
+    id: -1,
+    // lazily assigned later
+    index,
+    parentFlushed: false,
+    chunks: [],
+    children: [],
+    parentFormatContext,
+    boundary,
+    lastPushedText,
+    textEmbedded
+  };
+} // DEV-only global reference to the currently executing task
+
+function popComponentStackInDEV(task) {
+} // stash the component stack of an unwinding error until it is processed
+
+function logPostpone(request, reason) {
+  // If this callback errors, we intentionally let that error bubble up to become a fatal error
+  // so that someone fixes the error reporting instead of hiding it.
+  request.onPostpone(reason);
+}
+
+function logRecoverableError(request, error) {
+  // If this callback errors, we intentionally let that error bubble up to become a fatal error
+  // so that someone fixes the error reporting instead of hiding it.
+  const errorDigest = request.onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest;
+}
+
+function fatalError(request, error) {
+  // This is called outside error handling code such as if the root errors outside
+  // a suspense boundary or if the root suspense boundary's fallback errors.
+  // It's also called if React itself or its host configs errors.
+  const onShellError = request.onShellError;
+  onShellError(error);
+  const onFatalError = request.onFatalError;
+  onFatalError(error);
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function renderSuspenseBoundary(request, someTask, keyPath, props) {
+  if (someTask.replay !== null) {
+    // If we're replaying through this pass, it means we're replaying through
+    // an already completed Suspense boundary. It's too late to do anything about it
+    // so we can just render through it.
+    const prevKeyPath = someTask.keyPath;
+    someTask.keyPath = keyPath;
+    const content = props.children;
+
+    try {
+      renderNode(request, someTask, content, -1);
+    } finally {
+      someTask.keyPath = prevKeyPath;
+    }
+
+    return;
+  } // $FlowFixMe: Refined.
+
+
+  const task = someTask;
+  const prevKeyPath = task.keyPath;
+  const parentBoundary = task.blockedBoundary;
+  const parentSegment = task.blockedSegment; // Each time we enter a suspense boundary, we split out into a new segment for
+  // the fallback so that we can later replace that segment with the content.
+  // This also lets us split out the main content even if it doesn't suspend,
+  // in case it ends up generating a large subtree of content.
+
+  const fallback = props.fallback;
+  const content = props.children;
+  const fallbackAbortSet = new Set();
+  const newBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+
+  if (request.trackedPostpones !== null) {
+    newBoundary.trackedContentKeyPath = keyPath;
+  }
+
+  const insertionIndex = parentSegment.chunks.length; // The children of the boundary segment is actually the fallback.
+
+  const boundarySegment = createPendingSegment(request, insertionIndex, newBoundary, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false);
+  parentSegment.children.push(boundarySegment); // The parentSegment has a child Segment at this index so we reset the lastPushedText marker on the parent
+
+  parentSegment.lastPushedText = false; // This segment is the actual child content. We can start rendering that immediately.
+
+  const contentRootSegment = createPendingSegment(request, 0, null, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false); // We mark the root segment as having its parent flushed. It's not really flushed but there is
+  // no parent segment so there's nothing to wait on.
+
+  contentRootSegment.parentFlushed = true; // Currently this is running synchronously. We could instead schedule this to pingedTasks.
+  // I suspect that there might be some efficiency benefits from not creating the suspended task
+  // and instead just using the stack if possible.
+  // TODO: Call this directly instead of messing with saving and restoring contexts.
+  // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and which segment
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = newBoundary;
+  task.blockedSegment = contentRootSegment;
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, newBoundary.resources);
+  }
+
+  task.keyPath = keyPath;
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+    pushSegmentFinale(contentRootSegment.chunks, request.renderState, contentRootSegment.lastPushedText, contentRootSegment.textEmbedded);
+    contentRootSegment.status = COMPLETED;
+    queueCompletedSegment(newBoundary, contentRootSegment);
+
+    if (newBoundary.pendingTasks === 0 && newBoundary.status === PENDING) {
+      newBoundary.status = COMPLETED; // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    contentRootSegment.status = ERRORED;
+    newBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+      const postponeInstance = error;
+      logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+      errorDigest = 'POSTPONE';
+    } else {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    newBoundary.errorDigest = errorDigest;
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.blockedSegment = parentSegment;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]];
+  const trackedPostpones = request.trackedPostpones;
+
+  if (trackedPostpones !== null) {
+    // We create a detached replay node to track any postpones inside the fallback.
+    const fallbackReplayNode = [fallbackKeyPath[1], fallbackKeyPath[2], [], null];
+    trackedPostpones.workingMap.set(fallbackKeyPath, fallbackReplayNode);
+
+    if (newBoundary.status === POSTPONED) {
+      // This must exist now.
+      const boundaryReplayNode = trackedPostpones.workingMap.get(keyPath);
+      boundaryReplayNode[4] = fallbackReplayNode;
+    } else {
+      // We might not inject it into the postponed tree, unless the content actually
+      // postpones too. We need to keep track of it until that happpens.
+      newBoundary.trackedFallbackNode = fallbackReplayNode;
+    }
+  } // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+
+  const suspendedFallbackTask = createRenderTask(request, null, fallback, -1, parentBoundary, boundarySegment, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function replaySuspenseBoundary(request, task, keyPath, props, id, childNodes, childSlots, fallbackNodes, fallbackSlots) {
+  const prevKeyPath = task.keyPath;
+  const previousReplaySet = task.replay;
+  const parentBoundary = task.blockedBoundary;
+  const content = props.children;
+  const fallback = props.fallback;
+  const fallbackAbortSet = new Set();
+  const resumedBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = id; // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and replay node
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = resumedBoundary;
+  task.replay = {
+    nodes: childNodes,
+    slots: childSlots,
+    pendingTasks: 1
+  };
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, resumedBoundary.resources);
+  }
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+    }
+
+    task.replay.pendingTasks--;
+
+    if (resumedBoundary.pendingTasks === 0 && resumedBoundary.status === PENDING) {
+      resumedBoundary.status = COMPLETED;
+      request.completedBoundaries.push(resumedBoundary); // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    resumedBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+      const postponeInstance = error;
+      logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+      errorDigest = 'POSTPONE';
+    } else {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    resumedBoundary.errorDigest = errorDigest;
+
+    task.replay.pendingTasks--; // The parent already flushed in the prerender so we need to schedule this to be emitted.
+
+    request.clientRenderedBoundaries.push(resumedBoundary); // We don't need to decrement any task numbers because we didn't spawn any new task.
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.replay = previousReplaySet;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]]; // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+  const fallbackReplay = {
+    nodes: fallbackNodes,
+    slots: fallbackSlots,
+    pendingTasks: 0
+  };
+  const suspendedFallbackTask = createReplayTask(request, null, fallbackReplay, fallback, -1, parentBoundary, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function renderHostElement(request, task, keyPath, type, props) {
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    const children = props.children; // TODO: Make this a Config for replaying.
+
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+  } else {
+    // Render
+    const children = pushStartInstance(segment.chunks, type, props, request.resumableState, request.renderState, task.formatContext, segment.lastPushedText);
+    segment.lastPushedText = false;
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+    pushEndInstance(segment.chunks, type, props, request.resumableState, prevContext);
+    segment.lastPushedText = false;
+  }
+}
+
+function shouldConstruct(Component) {
+  return Component.prototype && Component.prototype.isReactComponent;
+}
+
+function renderWithHooks(request, task, keyPath, prevThenableState, Component, props, secondArg) {
+  const componentIdentity = {};
+  prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState);
+  const result = Component(props, secondArg);
+  return finishHooks(Component, props, result, secondArg);
+}
+
+function finishClassComponent(request, task, keyPath, instance, Component, props) {
+  const nextChildren = instance.render();
+
+  {
+    const childContextTypes = Component.childContextTypes;
+
+    if (childContextTypes !== null && childContextTypes !== undefined) {
+      const previousContext = task.legacyContext;
+      const mergedContext = processChildContext(instance, Component, previousContext, childContextTypes);
+      task.legacyContext = mergedContext;
+      renderNodeDestructive(request, task, null, nextChildren, -1);
+      task.legacyContext = previousContext;
+      return;
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, nextChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderClassComponent(request, task, keyPath, Component, props) {
+  const maskedContext = getMaskedContext(Component, task.legacyContext) ;
+  const instance = constructClassInstance(Component, props, maskedContext);
+  mountClassInstance(instance, Component, props, maskedContext);
+  finishClassComponent(request, task, keyPath, instance, Component);
+}
+// components for some reason.
+
+function renderIndeterminateComponent(request, task, keyPath, prevThenableState, Component, props) {
+  let legacyContext;
+
+  {
+    legacyContext = getMaskedContext(Component, task.legacyContext);
+  }
+
+  const value = renderWithHooks(request, task, keyPath, prevThenableState, Component, props, legacyContext);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+
+  if ( // Run these checks in production only if the flag is off.
+  // Eventually we'll delete this branch altogether.
+  typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) {
+
+    mountClassInstance(value, Component, props, legacyContext);
+    finishClassComponent(request, task, keyPath, value, Component);
+  } else {
+
+    finishFunctionComponent(request, task, keyPath, value, hasId, formStateCount, formStateMatchingIndex);
+  }
+}
+
+function finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex) {
+  let didEmitFormStateMarkers = false;
+
+  if (formStateCount !== 0 && request.formState !== null) {
+    // For each useFormState hook, emit a marker that indicates whether we
+    // rendered using the form state passed at the root. We only emit these
+    // markers if form state is passed at the root.
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      didEmitFormStateMarkers = true;
+      const target = segment.chunks;
+
+      for (let i = 0; i < formStateCount; i++) {
+        if (i === formStateMatchingIndex) {
+          pushFormStateMarkerIsMatching(target);
+        } else {
+          pushFormStateMarkerIsNotMatching(target);
+        }
+      }
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+
+  if (hasId) {
+    // This component materialized an id. We treat this as its own level, with
+    // a single "child" slot.
+    const prevTreeContext = task.treeContext;
+    const totalChildren = 1;
+    const index = 0; // Modify the id context. Because we'll need to reset this if something
+    // suspends or errors, we'll use the non-destructive render path.
+
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, index);
+    renderNode(request, task, children, -1); // Like the other contexts, this does not need to be in a finally block
+    // because renderNode takes care of unwinding the stack.
+
+    task.treeContext = prevTreeContext;
+  } else if (didEmitFormStateMarkers) {
+    // If there were formState hooks, we must use the non-destructive path
+    // because this component is not a pure indirection; we emitted markers
+    // to the stream.
+    renderNode(request, task, children, -1);
+  } else {
+    // We're now successfully past this task, and we haven't modified the
+    // context stack. We don't have to pop back to the previous task every
+    // again, so we can use the destructive recursive form.
+    renderNodeDestructive(request, task, null, children, -1);
+  }
+
+  task.keyPath = prevKeyPath;
+}
+
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    // Resolve default props. Taken from ReactElement
+    const props = assign({}, baseProps);
+    const defaultProps = Component.defaultProps;
+
+    for (const propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+
+    return props;
+  }
+
+  return baseProps;
+}
+
+function renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref) {
+  const children = renderWithHooks(request, task, keyPath, prevThenableState, type.render, props, ref);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+  finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex);
+}
+
+function renderMemo(request, task, keyPath, prevThenableState, type, props, ref) {
+  const innerType = type.type;
+  const resolvedProps = resolveDefaultProps(innerType, props);
+  renderElement(request, task, keyPath, prevThenableState, innerType, resolvedProps, ref);
+}
+
+function renderContextConsumer(request, task, keyPath, context, props) {
+
+  const render = props.children;
+
+  const newValue = readContext$1(context);
+  const newChildren = render(newValue);
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, newChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderContextProvider(request, task, keyPath, type, props) {
+  const context = type._context;
+  const value = props.value;
+  const children = props.children;
+
+  const prevKeyPath = task.keyPath;
+  task.context = pushProvider(context, value);
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, children, -1);
+  task.context = popProvider();
+  task.keyPath = prevKeyPath;
+}
+
+function renderLazyComponent(request, task, keyPath, prevThenableState, lazyComponent, props, ref) {
+  const payload = lazyComponent._payload;
+  const init = lazyComponent._init;
+  const Component = init(payload);
+  const resolvedProps = resolveDefaultProps(Component, props);
+  renderElement(request, task, keyPath, prevThenableState, Component, resolvedProps, ref);
+}
+
+function renderOffscreen(request, task, keyPath, props) {
+  const mode = props.mode;
+
+  if (mode === 'hidden') ; else {
+    // A visible Offscreen boundary is treated exactly like a fragment: a
+    // pure indirection.
+    const prevKeyPath = task.keyPath;
+    task.keyPath = keyPath;
+    renderNodeDestructive(request, task, null, props.children, -1);
+    task.keyPath = prevKeyPath;
+  }
+}
+
+function renderElement(request, task, keyPath, prevThenableState, type, props, ref) {
+  if (typeof type === 'function') {
+    if (shouldConstruct(type)) {
+      renderClassComponent(request, task, keyPath, type, props);
+      return;
+    } else {
+      renderIndeterminateComponent(request, task, keyPath, prevThenableState, type, props);
+      return;
+    }
+  }
+
+  if (typeof type === 'string') {
+    renderHostElement(request, task, keyPath, type, props);
+    return;
+  }
+
+  switch (type) {
+    // LegacyHidden acts the same as a fragment. This only works because we
+    // currently assume that every instance of LegacyHidden is accompanied by a
+    // host component wrapper. In the hidden mode, the host component is given a
+    // `hidden` attribute, which ensures that the initial HTML is not visible.
+    // To support the use of LegacyHidden as a true fragment, without an extra
+    // DOM node, we would have to hide the initial HTML in some other way.
+    // TODO: Delete in LegacyHidden. It's an unstable API only used in the
+    // www build. As a migration step, we could add a special prop to Offscreen
+    // that simulates the old behavior (no hiding, no change to effects).
+    case REACT_LEGACY_HIDDEN_TYPE:
+    case REACT_DEBUG_TRACING_MODE_TYPE:
+    case REACT_STRICT_MODE_TYPE:
+    case REACT_PROFILER_TYPE:
+    case REACT_FRAGMENT_TYPE:
+      {
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_OFFSCREEN_TYPE:
+      {
+        renderOffscreen(request, task, keyPath, props);
+        return;
+      }
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      {
+
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_SCOPE_TYPE:
+      {
+
+        throw new Error('ReactDOMServer does not yet support scope components.');
+      }
+
+    case REACT_SUSPENSE_TYPE:
+      {
+        {
+          renderSuspenseBoundary(request, task, keyPath, props);
+        }
+
+        return;
+      }
+  }
+
+  if (typeof type === 'object' && type !== null) {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        {
+          renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          renderMemo(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_PROVIDER_TYPE:
+        {
+          renderContextProvider(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_CONTEXT_TYPE:
+        {
+          renderContextConsumer(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_LAZY_TYPE:
+        {
+          renderLazyComponent(request, task, keyPath, prevThenableState, type, props);
+          return;
+        }
+    }
+  }
+
+  let info = '';
+
+  throw new Error('Element type is invalid: expected a string (for built-in ' + 'components) or a class/function (for composite components) ' + ("but got: " + (type == null ? type : typeof type) + "." + info));
+}
+
+function resumeNode(request, task, segmentId, node, childIndex) {
+  const prevReplay = task.replay;
+  const blockedBoundary = task.blockedBoundary;
+  const resumedSegment = createPendingSegment(request, 0, null, task.formatContext, false, false);
+  resumedSegment.id = segmentId;
+  resumedSegment.parentFlushed = true;
+
+  try {
+    // Convert the current ReplayTask to a RenderTask.
+    const renderTask = task;
+    renderTask.replay = null;
+    renderTask.blockedSegment = resumedSegment;
+    renderNode(request, task, node, childIndex);
+    resumedSegment.status = COMPLETED;
+
+    if (blockedBoundary === null) {
+      request.completedRootSegment = resumedSegment;
+    } else {
+      queueCompletedSegment(blockedBoundary, resumedSegment);
+
+      if (blockedBoundary.parentFlushed) {
+        request.partialBoundaries.push(blockedBoundary);
+      }
+    }
+  } finally {
+    // Restore to a ReplayTask.
+    task.replay = prevReplay;
+    task.blockedSegment = null;
+  }
+}
+
+function replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, replay) {
+  // We're replaying. Find the path to follow.
+  const replayNodes = replay.nodes;
+
+  for (let i = 0; i < replayNodes.length; i++) {
+    // Flow doesn't support refinement on tuples so we do it manually here.
+    const node = replayNodes[i];
+
+    if (keyOrIndex !== node[1]) {
+      continue;
+    }
+
+    if (node.length === 4) {
+      // Matched a replayable path.
+      // Let's double check that the component name matches as a precaution.
+      if (name !== null && name !== node[0]) {
+        throw new Error('Expected the resume to render <' + node[0] + '> in this slot but instead it rendered <' + name + '>. ' + "The tree doesn't match so React will fallback to client rendering.");
+      }
+
+      const childNodes = node[2];
+      const childSlots = node[3];
+      const currentNode = task.node;
+      task.replay = {
+        nodes: childNodes,
+        slots: childSlots,
+        pendingTasks: 1
+      };
+
+      try {
+        renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+
+        if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0 // TODO check remaining slots
+        ) {
+            throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+          }
+
+        task.replay.pendingTasks--;
+      } catch (x) {
+        if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+          // Suspend
+          if (task.node === currentNode) {
+            // This same element suspended so we need to pop the replay we just added.
+            task.replay = replay;
+          }
+
+          throw x;
+        }
+
+        task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+        // during a replay. That's because this component didn't actually error
+        // in the original prerender. What's unable to complete is the child
+        // replay nodes which might be Suspense boundaries which are able to
+        // absorb the error and we can still continue with siblings.
+
+        erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+      }
+
+      task.replay = replay;
+    } else {
+      // Let's double check that the component type matches.
+      if (type !== REACT_SUSPENSE_TYPE) {
+        const expectedType = 'Suspense';
+        throw new Error('Expected the resume to render <' + expectedType + '> in this slot but instead it rendered <' + (getComponentNameFromType(type) || 'Unknown') + '>. ' + "The tree doesn't match so React will fallback to client rendering.");
+      } // Matched a replayable path.
+
+
+      replaySuspenseBoundary(request, task, keyPath, props, node[5], node[2], node[3], node[4] === null ? [] : node[4][2], node[4] === null ? null : node[4][3]);
+    } // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+
+    replayNodes.splice(i, 1);
+    return;
+  } // We didn't find any matching nodes. We assume that this element was already
+  // rendered in the prelude and skip it.
+
+} // $FlowFixMe[missing-local-annot]
+
+function renderNodeDestructive(request, task, // The thenable state reused from the previous attempt, if any. This is almost
+// always null, except when called by retryTask.
+prevThenableState, node, childIndex) {
+  {
+    return renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex);
+  }
+} // This function by it self renders a node and consumes the task by mutating it
+// to update the current execution state.
+
+
+function renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex) {
+  if (task.replay !== null && typeof task.replay.slots === 'number') {
+    // TODO: Figure out a cheaper place than this hot path to do this check.
+    const resumeSegmentID = task.replay.slots;
+    resumeNode(request, task, resumeSegmentID, node, childIndex);
+    return;
+  } // Stash the node we're working on. We'll pick up from this task in case
+  // something suspends.
+
+
+  task.node = node;
+  task.childIndex = childIndex; // Handle object types
+
+  if (typeof node === 'object' && node !== null) {
+    switch (node.$$typeof) {
+      case REACT_ELEMENT_TYPE:
+        {
+          const element = node;
+          const type = element.type;
+          const key = element.key;
+          const props = element.props;
+          const ref = element.ref;
+          const name = getComponentNameFromType(type);
+          const keyOrIndex = key == null ? childIndex === -1 ? 0 : childIndex : key;
+          const keyPath = [task.keyPath, name, keyOrIndex];
+
+          if (task.replay !== null) {
+            replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, task.replay); // No matches found for this node. We assume it's already emitted in the
+            // prelude and skip it during the replay.
+          } else {
+            // We're doing a plain render.
+            renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+          }
+
+          return;
+        }
+
+      case REACT_PORTAL_TYPE:
+        throw new Error('Portals are not currently supported by the server renderer. ' + 'Render them conditionally so that they only appear on the client render.');
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyNode = node;
+          const payload = lazyNode._payload;
+          const init = lazyNode._init;
+          let resolvedNode;
+
+          {
+            resolvedNode = init(payload);
+          }
+
+          renderNodeDestructive(request, task, null, resolvedNode, childIndex);
+          return;
+        }
+    }
+
+    if (isArray(node)) {
+      renderChildrenArray(request, task, node, childIndex);
+      return;
+    }
+
+    const iteratorFn = getIteratorFn(node);
+
+    if (iteratorFn) {
+
+      const iterator = iteratorFn.call(node);
+
+      if (iterator) {
+        // We need to know how many total children are in this set, so that we
+        // can allocate enough id slots to acommodate them. So we must exhaust
+        // the iterator before we start recursively rendering the children.
+        // TODO: This is not great but I think it's inherent to the id
+        // generation algorithm.
+        let step = iterator.next(); // If there are not entries, we need to push an empty so we start by checking that.
+
+        if (!step.done) {
+          const children = [];
+
+          do {
+            children.push(step.value);
+            step = iterator.next();
+          } while (!step.done);
+
+          renderChildrenArray(request, task, children, childIndex);
+          return;
+        }
+
+        return;
+      }
+    } // Usables are a valid React node type. When React encounters a Usable in
+    // a child position, it unwraps it using the same algorithm as `use`. For
+    // example, for promises, React will throw an exception to unwind the
+    // stack, then replay the component once the promise resolves.
+    //
+    // A difference from `use` is that React will keep unwrapping the value
+    // until it reaches a non-Usable type.
+    //
+    // e.g. Usable<Usable<Usable<T>>> should resolve to T
+
+
+    const maybeUsable = node;
+
+    if (typeof maybeUsable.then === 'function') {
+      const thenable = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, unwrapThenable(thenable), childIndex);
+    }
+
+    if (maybeUsable.$$typeof === REACT_CONTEXT_TYPE || maybeUsable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, readContext$1(context), childIndex);
+    } // $FlowFixMe[method-unbinding]
+
+
+    const childString = Object.prototype.toString.call(node);
+    throw new Error("Objects are not valid as a React child (found: " + (childString === '[object Object]' ? 'object with keys {' + Object.keys(node).join(', ') + '}' : childString) + "). " + 'If you meant to render a collection of children, use an array ' + 'instead.');
+  }
+
+  if (typeof node === 'string') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+
+  if (typeof node === 'number') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, '' + node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+}
+
+function replayFragment(request, task, children, childIndex) {
+  // If we're supposed follow this array, we'd expect to see a ReplayNode matching
+  // this fragment.
+  const replay = task.replay;
+  const replayNodes = replay.nodes;
+
+  for (let j = 0; j < replayNodes.length; j++) {
+    const node = replayNodes[j];
+
+    if (node[1] !== childIndex) {
+      continue;
+    } // Matched a replayable path.
+
+
+    const childNodes = node[2];
+    const childSlots = node[3];
+    task.replay = {
+      nodes: childNodes,
+      slots: childSlots,
+      pendingTasks: 1
+    };
+
+    try {
+      renderChildrenArray(request, task, children, -1);
+
+      if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+        throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+      }
+
+      task.replay.pendingTasks--;
+    } catch (x) {
+      if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+        // Suspend
+        throw x;
+      }
+
+      task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+      // during a replay. That's because this component didn't actually error
+      // in the original prerender. What's unable to complete is the child
+      // replay nodes which might be Suspense boundaries which are able to
+      // absorb the error and we can still continue with siblings.
+      // This is an error, stash the component stack if it is null.
+
+      erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+    }
+
+    task.replay = replay; // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+    replayNodes.splice(j, 1);
+    break;
+  }
+}
+
+function renderChildrenArray(request, task, children, childIndex) {
+  const prevKeyPath = task.keyPath;
+
+  if (childIndex !== -1) {
+    task.keyPath = [task.keyPath, 'Fragment', childIndex];
+
+    if (task.replay !== null) {
+      replayFragment(request, // $FlowFixMe: Refined.
+      task, children, childIndex);
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  const prevTreeContext = task.treeContext;
+  const totalChildren = children.length;
+
+  if (task.replay !== null) {
+    // Replay
+    // First we need to check if we have any resume slots at this level.
+    const resumeSlots = task.replay.slots;
+
+    if (resumeSlots !== null && typeof resumeSlots === 'object') {
+      for (let i = 0; i < totalChildren; i++) {
+        const node = children[i];
+        task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+        // up and render the sibling if something suspends.
+
+        const resumeSegmentID = resumeSlots[i]; // TODO: If this errors we should still continue with the next sibling.
+
+        if (typeof resumeSegmentID === 'number') {
+          resumeNode(request, task, resumeSegmentID, node, i); // We finished rendering this node, so now we can consume this
+          // slot. This must happen after in case we rerender this task.
+
+          delete resumeSlots[i];
+        } else {
+          renderNode(request, task, node, i);
+        }
+      }
+
+      task.treeContext = prevTreeContext;
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  for (let i = 0; i < totalChildren; i++) {
+    const node = children[i];
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+    // up and render the sibling if something suspends.
+
+    renderNode(request, task, node, i);
+  } // Because this context is always set right before rendering every child, we
+  // only need to reset it to the previous value at the very end.
+
+
+  task.treeContext = prevTreeContext;
+  task.keyPath = prevKeyPath;
+}
+
+function trackPostpone(request, trackedPostpones, task, segment) {
+  segment.status = POSTPONED;
+  const keyPath = task.keyPath;
+  const boundary = task.blockedBoundary;
+
+  if (boundary === null) {
+    segment.id = request.nextSegmentId++;
+    trackedPostpones.rootSlots = segment.id;
+
+    if (request.completedRootSegment !== null) {
+      // Postpone the root if this was a deeper segment.
+      request.completedRootSegment.status = POSTPONED;
+    }
+
+    return;
+  }
+
+  if (boundary !== null && boundary.status === PENDING) {
+    boundary.status = POSTPONED; // We need to eagerly assign it an ID because we'll need to refer to
+    // it before flushing and we know that we can't inline it.
+
+    boundary.rootSegmentID = request.nextSegmentId++;
+    const boundaryKeyPath = boundary.trackedContentKeyPath;
+
+    if (boundaryKeyPath === null) {
+      throw new Error('It should not be possible to postpone at the root. This is a bug in React.');
+    }
+
+    const fallbackReplayNode = boundary.trackedFallbackNode;
+    const children = [];
+
+    if (boundaryKeyPath === keyPath && task.childIndex === -1) {
+      // Since we postponed directly in the Suspense boundary we can't have written anything
+      // to its segment. Therefore this will end up becoming the root segment.
+      segment.id = boundary.rootSegmentID; // We postponed directly inside the Suspense boundary so we mark this for resuming.
+
+      const boundaryNode = [boundaryKeyPath[1], boundaryKeyPath[2], children, boundary.rootSegmentID, fallbackReplayNode, boundary.rootSegmentID];
+      trackedPostpones.workingMap.set(boundaryKeyPath, boundaryNode);
+      addToReplayParent(boundaryNode, boundaryKeyPath[0], trackedPostpones);
+      return;
+    } else {
+      let boundaryNode = trackedPostpones.workingMap.get(boundaryKeyPath);
+
+      if (boundaryNode === undefined) {
+        boundaryNode = [boundaryKeyPath[1], boundaryKeyPath[2], children, null, fallbackReplayNode, boundary.rootSegmentID];
+        trackedPostpones.workingMap.set(boundaryKeyPath, boundaryNode);
+        addToReplayParent(boundaryNode, boundaryKeyPath[0], trackedPostpones);
+      } else {
+        // Upgrade to ReplaySuspenseBoundary.
+        const suspenseBoundary = boundaryNode;
+        suspenseBoundary[4] = fallbackReplayNode;
+        suspenseBoundary[5] = boundary.rootSegmentID;
+      } // Fall through to add the child node.
+
+    }
+  } // We know that this will leave a hole so we might as well assign an ID now.
+  // We might have one already if we had a parent that gave us its ID.
+
+
+  if (segment.id === -1) {
+    if (segment.parentFlushed && boundary !== null) {
+      // If this segment's parent was already flushed, it means we really just
+      // skipped the parent and this segment is now the root.
+      segment.id = boundary.rootSegmentID;
+    } else {
+      segment.id = request.nextSegmentId++;
+    }
+  }
+
+  if (task.childIndex === -1) {
+    // Resume starting from directly inside the previous parent element.
+    if (keyPath === null) {
+      trackedPostpones.rootSlots = segment.id;
+    } else {
+      const workingMap = trackedPostpones.workingMap;
+      let resumableNode = workingMap.get(keyPath);
+
+      if (resumableNode === undefined) {
+        resumableNode = [keyPath[1], keyPath[2], [], segment.id];
+        addToReplayParent(resumableNode, keyPath[0], trackedPostpones);
+      } else {
+        resumableNode[3] = segment.id;
+      }
+    }
+  } else {
+    let slots;
+
+    if (keyPath === null) {
+      slots = trackedPostpones.rootSlots;
+
+      if (slots === null) {
+        slots = trackedPostpones.rootSlots = {};
+      } else if (typeof slots === 'number') {
+        throw new Error('It should not be possible to postpone both at the root of an element ' + 'as well as a slot below. This is a bug in React.');
+      }
+    } else {
+      const workingMap = trackedPostpones.workingMap;
+      let resumableNode = workingMap.get(keyPath);
+
+      if (resumableNode === undefined) {
+        slots = {};
+        resumableNode = [keyPath[1], keyPath[2], [], slots];
+        workingMap.set(keyPath, resumableNode);
+        addToReplayParent(resumableNode, keyPath[0], trackedPostpones);
+      } else {
+        slots = resumableNode[3];
+
+        if (slots === null) {
+          slots = resumableNode[3] = {};
+        } else if (typeof slots === 'number') {
+          throw new Error('It should not be possible to postpone both at the root of an element ' + 'as well as a slot below. This is a bug in React.');
+        }
+      }
+    }
+
+    slots[task.childIndex] = segment.id;
+  }
+}
+
+function injectPostponedHole(request, task, reason) {
+  logPostpone(request, reason); // Something suspended, we'll need to create a new segment and resolve it later.
+
+  const segment = task.blockedSegment;
+  const insertionIndex = segment.chunks.length;
+  const newSegment = createPendingSegment(request, insertionIndex, null, task.formatContext, // Adopt the parent segment's leading text embed
+  segment.lastPushedText, // Assume we are text embedded at the trailing edge
+  true);
+  segment.children.push(newSegment); // Reset lastPushedText for current Segment since the new Segment "consumed" it
+
+  segment.lastPushedText = false;
+  return newSegment;
+}
+
+function spawnNewSuspendedReplayTask(request, task, thenableState, x) {
+  const newTask = createReplayTask(request, thenableState, task.replay, task.node, task.childIndex, task.blockedBoundary, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+}
+
+function spawnNewSuspendedRenderTask(request, task, thenableState, x) {
+  // Something suspended, we'll need to create a new segment and resolve it later.
+  const segment = task.blockedSegment;
+  const insertionIndex = segment.chunks.length;
+  const newSegment = createPendingSegment(request, insertionIndex, null, task.formatContext, // Adopt the parent segment's leading text embed
+  segment.lastPushedText, // Assume we are text embedded at the trailing edge
+  true);
+  segment.children.push(newSegment); // Reset lastPushedText for current Segment since the new Segment "consumed" it
+
+  segment.lastPushedText = false;
+  const newTask = createRenderTask(request, thenableState, task.node, task.childIndex, task.blockedBoundary, newSegment, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+} // This is a non-destructive form of rendering a node. If it suspends it spawns
+// a new task and restores the context of this task to what it was before.
+
+
+function renderNode(request, task, node, childIndex) {
+  // Snapshot the current context in case something throws to interrupt the
+  // process.
+  const previousFormatContext = task.formatContext;
+  const previousLegacyContext = task.legacyContext;
+  const previousContext = task.context;
+  const previousKeyPath = task.keyPath;
+  const previousTreeContext = task.treeContext;
+
+  let x; // Store how much we've pushed at this point so we can reset it in case something
+  // suspended partially through writing something.
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState();
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedReplayTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+      } // TODO: Abort any undiscovered Suspense boundaries in the ReplayNode.
+
+    }
+  } else {
+    // Render
+    const childrenLength = segment.children.length;
+    const chunkLength = segment.chunks.length;
+
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState(); // Reset the write pointers to where we started.
+
+      segment.children.length = childrenLength;
+      segment.chunks.length = chunkLength;
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedRenderTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+
+        if (request.trackedPostpones !== null && x.$$typeof === REACT_POSTPONE_TYPE && task.blockedBoundary !== null // bubble if we're postponing in the shell
+        ) {
+            // If we're tracking postpones, we inject a hole here and continue rendering
+            // sibling. Similar to suspending. If we're not tracking, we treat it more like
+            // an error. Notably this doesn't spawn a new task since nothing will fill it
+            // in during this prerender.
+            const postponeInstance = x;
+            const trackedPostpones = request.trackedPostpones;
+            const postponedSegment = injectPostponedHole(request, task, // We don't use ReplayTasks in prerenders.
+            postponeInstance.message);
+            trackPostpone(request, trackedPostpones, task, postponedSegment); // Restore the context. We assume that this will be restored by the inner
+            // functions in case nothing throws so we don't use "finally" here.
+
+            task.formatContext = previousFormatContext;
+            task.legacyContext = previousLegacyContext;
+            task.context = previousContext;
+            task.keyPath = previousKeyPath;
+            task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+            switchContext(previousContext);
+            return;
+          }
+      }
+    }
+  } // Restore the context. We assume that this will be restored by the inner
+  // functions in case nothing throws so we don't use "finally" here.
+
+
+  task.formatContext = previousFormatContext;
+  task.legacyContext = previousLegacyContext;
+  task.context = previousContext;
+  task.keyPath = previousKeyPath;
+  task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+  switchContext(previousContext);
+  // Let's terminate the rest of the tree and don't render any siblings.
+
+
+  throw x;
+}
+
+function erroredReplay(request, boundary, error, replayNodes, resumeSlots) {
+  // Erroring during a replay doesn't actually cause an error by itself because
+  // that component has already rendered. What causes the error is the resumable
+  // points that we did not yet finish which will be below the point of the reset.
+  // For example, if we're replaying a path to a Suspense boundary that is not done
+  // that doesn't error the parent Suspense boundary.
+  // This might be a bit strange that the error in a parent gets thrown at a child.
+  // We log it only once and reuse the digest.
+  let errorDigest;
+
+  if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+    const postponeInstance = error;
+    logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+    errorDigest = 'POSTPONE';
+  } else {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  abortRemainingReplayNodes(request, boundary, replayNodes, resumeSlots, error, errorDigest);
+}
+
+function erroredTask(request, boundary, error) {
+  // Report the error to a global handler.
+  let errorDigest;
+
+  if (typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE) {
+    const postponeInstance = error;
+    logPostpone(request, postponeInstance.message); // TODO: Figure out a better signal than a magic digest value.
+
+    errorDigest = 'POSTPONE';
+  } else {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  if (boundary === null) {
+    fatalError(request, error);
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+      // so we can flush it, if the parent already flushed.
+
+
+      if (boundary.parentFlushed) {
+        // We don't have a preference where in the queue this goes since it's likely
+        // to error on the client anyway. However, intentionally client-rendered
+        // boundaries should be flushed earlier so that they can start on the client.
+        // We reuse the same queue for errors.
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function abortTaskSoft(task) {
+  // This aborts task without aborting the parent boundary that it blocks.
+  // It's used for when we didn't need this task to complete the tree.
+  // If task was needed, then it should use abortTask instead.
+  const request = this;
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+    finishedTask(request, boundary, segment);
+  }
+}
+
+function abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest) {
+  const resumedBoundary = createSuspenseBoundary(request, new Set());
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = rootSegmentID;
+  resumedBoundary.status = CLIENT_RENDERED;
+  resumedBoundary.errorDigest = errorDigest;
+
+  if (resumedBoundary.parentFlushed) {
+    request.clientRenderedBoundaries.push(resumedBoundary);
+  }
+}
+
+function abortRemainingReplayNodes(request, boundary, nodes, slots, error, errorDigest) {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+
+    if (node.length === 4) {
+      abortRemainingReplayNodes(request, boundary, node[2], node[3], error, errorDigest);
+    } else {
+      const boundaryNode = node;
+      const rootSegmentID = boundaryNode[5];
+      abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest);
+    }
+  } // Empty the set, since we've cleared it now.
+
+
+  nodes.length = 0;
+
+  if (slots !== null) {
+    // We had something still to resume in the parent boundary. We must trigger
+    // the error on the parent boundary since it's not able to complete.
+    if (boundary === null) {
+      throw new Error('We should not have any resumable nodes in the shell. ' + 'This is a bug in React.');
+    } else if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // Empty the set
+
+
+    if (typeof slots === 'object') {
+      for (const index in slots) {
+        delete slots[index];
+      }
+    }
+  }
+}
+
+function abortTask(task, request, error) {
+  // This aborts the task and aborts the parent that it blocks, putting it into
+  // client rendered mode.
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+  }
+
+  if (boundary === null) {
+    if (request.status !== CLOSING && request.status !== CLOSED) {
+      const replay = task.replay;
+
+      if (replay === null) {
+        // We didn't complete the root so we have nothing to show. We can close
+        // the request;
+        logRecoverableError(request, error);
+        fatalError(request, error);
+        return;
+      } else {
+        // If the shell aborts during a replay, that's not a fatal error. Instead
+        // we should be able to recover by client rendering all the root boundaries in
+        // the ReplaySet.
+        replay.pendingTasks--;
+
+        if (replay.pendingTasks === 0 && replay.nodes.length > 0) {
+          const errorDigest = logRecoverableError(request, error);
+          abortRemainingReplayNodes(request, null, replay.nodes, replay.slots, error, errorDigest);
+        }
+
+        request.pendingRootTasks--;
+
+        if (request.pendingRootTasks === 0) {
+          completeShell(request);
+        }
+      }
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = logRecoverableError(request, error);
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // If this boundary was still pending then we haven't already cancelled its fallbacks.
+    // We'll need to abort the fallbacks, which will also error that parent boundary.
+
+
+    boundary.fallbackAbortableTasks.forEach(fallbackTask => abortTask(fallbackTask, request, error));
+    boundary.fallbackAbortableTasks.clear();
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeShell(request) {
+  if (request.trackedPostpones === null) {
+    // We only emit early preloads on shell completion for renders. For prerenders
+    // we wait for the entire Request to finish because we are not responding to a
+    // live request and can wait for as much data as possible.
+    // we should only be calling completeShell when the shell is complete so we
+    // just use a literal here
+    const shellComplete = true;
+    emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  } // We have completed the shell so the shell can't error anymore.
+
+
+  request.onShellError = noop;
+  const onShellReady = request.onShellReady;
+  onShellReady();
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeAll(request) {
+  // During a render the shell must be complete if the entire request is finished
+  // however during a Prerender it is possible that the shell is incomplete because
+  // it postponed. We cannot use rootPendingTasks in the prerender case because
+  // those hit zero even when the shell postpones. Instead we look at the completedRootSegment
+  const shellComplete = request.trackedPostpones === null ? // Render, we assume it is completed
+  true : // Prerender Request, we use the state of the root segment
+  request.completedRootSegment === null || request.completedRootSegment.status !== POSTPONED;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  const onAllReady = request.onAllReady;
+  onAllReady();
+}
+
+function queueCompletedSegment(boundary, segment) {
+  if (segment.chunks.length === 0 && segment.children.length === 1 && segment.children[0].boundary === null) {
+    // This is an empty segment. There's nothing to write, so we can instead transfer the ID
+    // to the child. That way any existing references point to the child.
+    const childSegment = segment.children[0];
+    childSegment.id = segment.id;
+    childSegment.parentFlushed = true;
+
+    if (childSegment.status === COMPLETED) {
+      queueCompletedSegment(boundary, childSegment);
+    }
+  } else {
+    const completedSegments = boundary.completedSegments;
+    completedSegments.push(segment);
+  }
+}
+
+function finishedTask(request, boundary, segment) {
+  if (boundary === null) {
+    if (segment !== null && segment.parentFlushed) {
+      if (request.completedRootSegment !== null) {
+        throw new Error('There can only be one root segment. This is a bug in React.');
+      }
+
+      request.completedRootSegment = segment;
+    }
+
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status === CLIENT_RENDERED) ; else if (boundary.pendingTasks === 0) {
+      if (boundary.status === PENDING) {
+        boundary.status = COMPLETED;
+      } // This must have been the last segment we were waiting on. This boundary is now complete.
+
+
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent segment already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+        }
+      }
+
+      if (boundary.parentFlushed) {
+        // The segment might be part of a segment that didn't flush yet, but if the boundary's
+        // parent flushed, we need to schedule the boundary to be emitted.
+        request.completedBoundaries.push(boundary);
+      } // We can now cancel any pending task on the fallback since we won't need to show it anymore.
+      // This needs to happen after we read the parentFlushed flags because aborting can finish
+      // work which can trigger user code, which can start flushing, which can change those flags.
+      // If the boundary was POSTPONED, we still need to finish the fallback first.
+
+
+      if (boundary.status === COMPLETED) {
+        boundary.fallbackAbortableTasks.forEach(abortTaskSoft, request);
+        boundary.fallbackAbortableTasks.clear();
+      }
+    } else {
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+          const completedSegments = boundary.completedSegments;
+
+          if (completedSegments.length === 1) {
+            // This is the first time since we last flushed that we completed anything.
+            // We can schedule this boundary to emit its partially completed segments early
+            // in case the parent has already been flushed.
+            if (boundary.parentFlushed) {
+              request.partialBoundaries.push(boundary);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function retryTask(request, task) {
+  {
+    const blockedBoundary = task.blockedBoundary;
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, blockedBoundary ? blockedBoundary.resources : null);
+  }
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    retryReplayTask(request, // $FlowFixMe: Refined.
+    task);
+  } else {
+    retryRenderTask(request, // $FlowFixMe: Refined.
+    task, segment);
+  }
+}
+
+function retryRenderTask(request, task, segment) {
+  if (segment.status !== PENDING) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  const childrenLength = segment.children.length;
+  const chunkLength = segment.chunks.length;
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+    pushSegmentFinale(segment.chunks, request.renderState, segment.lastPushedText, segment.textEmbedded);
+    task.abortSet.delete(task);
+    segment.status = COMPLETED;
+    finishedTask(request, task.blockedBoundary, segment);
+  } catch (thrownValue) {
+    resetHooksState(); // Reset the write pointers to where we started.
+
+    segment.children.length = childrenLength;
+    segment.chunks.length = chunkLength;
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      } else if (request.trackedPostpones !== null && x.$$typeof === REACT_POSTPONE_TYPE) {
+        // If we're tracking postpones, we mark this segment as postponed and finish
+        // the task without filling it in. If we're not tracking, we treat it more like
+        // an error.
+        const trackedPostpones = request.trackedPostpones;
+        task.abortSet.delete(task);
+        const postponeInstance = x;
+        logPostpone(request, postponeInstance.message);
+        trackPostpone(request, trackedPostpones, task, segment);
+        finishedTask(request, task.blockedBoundary, segment);
+        return;
+      }
+    }
+
+    task.abortSet.delete(task);
+    segment.status = ERRORED;
+    erroredTask(request, task.blockedBoundary, x);
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function retryReplayTask(request, task) {
+  if (task.replay.pendingTasks === 0) {
+    // There are no pending tasks working on this set, so we must have aborted.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    finishedTask(request, task.blockedBoundary, null);
+  } catch (thrownValue) {
+    resetHooksState();
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    erroredReplay(request, task.blockedBoundary, x, task.replay.nodes, task.replay.slots);
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+
+    request.allPendingTasks--;
+
+    if (request.allPendingTasks === 0) {
+      completeAll(request);
+    }
+
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function performWork(request) {
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  const prevContext = getActiveContext();
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  let prevCacheDispatcher;
+
+  {
+    prevCacheDispatcher = ReactCurrentCache.current;
+    ReactCurrentCache.current = DefaultCacheDispatcher;
+  }
+
+  const prevRequest = currentRequest;
+  currentRequest = request;
+
+  const prevResumableState = currentResumableState;
+  setCurrentResumableState(request.resumableState);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    let i;
+
+    for (i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    pingedTasks.splice(0, i);
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    setCurrentResumableState(prevResumableState);
+    ReactCurrentDispatcher.current = prevDispatcher;
+
+    {
+      ReactCurrentCache.current = prevCacheDispatcher;
+    }
+
+    if (prevDispatcher === HooksDispatcher) {
+      // This means that we were in a reentrant work loop. This could happen
+      // in a renderer that supports synchronous work like renderToString,
+      // when it's called from within another renderer.
+      // Normally we don't bother switching the contexts to their root/default
+      // values when leaving because we'll likely need the same or similar
+      // context again. However, when we're inside a synchronous loop like this
+      // we'll to restore the context to what it was before returning.
+      switchContext(prevContext);
+    }
+
+    currentRequest = prevRequest;
+  }
+}
+
+function flushSubtree(request, destination, segment) {
+  segment.parentFlushed = true;
+
+  switch (segment.status) {
+    case PENDING:
+      {
+        // We're emitting a placeholder for this segment to be filled in later.
+        // Therefore we'll need to assign it an ID - to refer to it by.
+        segment.id = request.nextSegmentId++; // Fallthrough
+      }
+
+    case POSTPONED:
+      {
+        const segmentID = segment.id; // When this segment finally completes it won't be embedded in text since it will flush separately
+
+        segment.lastPushedText = false;
+        segment.textEmbedded = false;
+        return writePlaceholder(destination, request.renderState, segmentID);
+      }
+
+    case COMPLETED:
+      {
+        segment.status = FLUSHED;
+        let r = true;
+        const chunks = segment.chunks;
+        let chunkIdx = 0;
+        const children = segment.children;
+
+        for (let childIdx = 0; childIdx < children.length; childIdx++) {
+          const nextChild = children[childIdx]; // Write all the chunks up until the next child.
+
+          for (; chunkIdx < nextChild.index; chunkIdx++) {
+            writeChunk(destination, chunks[chunkIdx]);
+          }
+
+          r = flushSegment(request, destination, nextChild);
+        } // Finally just write all the remaining chunks
+
+
+        for (; chunkIdx < chunks.length - 1; chunkIdx++) {
+          writeChunk(destination, chunks[chunkIdx]);
+        }
+
+        if (chunkIdx < chunks.length) {
+          r = writeChunkAndReturn(destination, chunks[chunkIdx]);
+        }
+
+        return r;
+      }
+
+    default:
+      {
+        throw new Error('Aborted, errored or already flushed boundaries should not be flushed again. This is a bug in React.');
+      }
+  }
+}
+
+function flushSegment(request, destination, segment) {
+  const boundary = segment.boundary;
+
+  if (boundary === null) {
+    // Not a suspense boundary.
+    return flushSubtree(request, destination, segment);
+  }
+
+  boundary.parentFlushed = true; // This segment is a Suspense boundary. We need to decide whether to
+  // emit the content or the fallback now.
+
+  if (boundary.status === CLIENT_RENDERED) {
+    // Emit a client rendered suspense boundary wrapper.
+    // We never queue the inner boundary so we'll never emit its content or partial segments.
+    writeStartClientRenderedSuspenseBoundary(destination, request.renderState, boundary.errorDigest); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndClientRenderedSuspenseBoundary(destination);
+  } else if (boundary.status !== COMPLETED) {
+    if (boundary.status === PENDING) {
+      // For pending boundaries we lazily assign an ID to the boundary
+      // and root segment.
+      boundary.rootSegmentID = request.nextSegmentId++;
+    }
+
+    if (boundary.completedSegments.length > 0) {
+      // If this is at least partially complete, we can queue it to be partially emitted early.
+      request.partialBoundaries.push(boundary);
+    } // This boundary is still loading. Emit a pending suspense boundary wrapper.
+
+
+    const id = boundary.rootSegmentID;
+    writeStartPendingSuspenseBoundary(destination, request.renderState, id); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else if (boundary.byteSize > request.progressiveChunkSize) {
+    // This boundary is large and will be emitted separately so that we can progressively show
+    // other content. We add it to the queue during the flush because we have to ensure that
+    // the parent flushes first so that there's something to inject it into.
+    // We also have to make sure that it's emitted into the queue in a deterministic slot.
+    // I.e. we can't insert it here when it completes.
+    // Assign an ID to refer to the future content by.
+    boundary.rootSegmentID = request.nextSegmentId++;
+    request.completedBoundaries.push(boundary); // Emit a pending rendered suspense boundary wrapper.
+
+    writeStartPendingSuspenseBoundary(destination, request.renderState, boundary.rootSegmentID); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else {
+    {
+      hoistResources(request.renderState, boundary.resources);
+    } // We can inline this boundary's content as a complete boundary.
+
+
+    writeStartCompletedSuspenseBoundary(destination);
+    const completedSegments = boundary.completedSegments;
+
+    if (completedSegments.length !== 1) {
+      throw new Error('A previously unvisited boundary must have exactly one root segment. This is a bug in React.');
+    }
+
+    const contentSegment = completedSegments[0];
+    flushSegment(request, destination, contentSegment);
+    return writeEndCompletedSuspenseBoundary(destination);
+  }
+}
+
+function flushClientRenderedBoundary(request, destination, boundary) {
+  return writeClientRenderBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.errorDigest, boundary.errorMessage, boundary.errorComponentStack);
+}
+
+function flushSegmentContainer(request, destination, segment) {
+  writeStartSegment(destination, request.renderState, segment.parentFormatContext, segment.id);
+  flushSegment(request, destination, segment);
+  return writeEndSegment(destination, segment.parentFormatContext);
+}
+
+function flushCompletedBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+    flushPartiallyCompletedSegment(request, destination, boundary, segment);
+  }
+
+  completedSegments.length = 0;
+
+  {
+    writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+
+  return writeCompletedBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.resources);
+}
+
+function flushPartialBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+
+    if (!flushPartiallyCompletedSegment(request, destination, boundary, segment)) {
+      i++;
+      completedSegments.splice(0, i); // Only write as much as the buffer wants. Something higher priority
+      // might want to write later.
+
+      return false;
+    }
+  }
+
+  completedSegments.splice(0, i);
+
+  {
+    // The way this is structured we only write resources for partial boundaries
+    // if there is no backpressure. Later before we complete the boundary we
+    // will write resources regardless of backpressure before we emit the
+    // completion instruction
+    return writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+}
+
+function flushPartiallyCompletedSegment(request, destination, boundary, segment) {
+  if (segment.status === FLUSHED) {
+    // We've already flushed this inline.
+    return true;
+  }
+
+  const segmentID = segment.id;
+
+  if (segmentID === -1) {
+    // This segment wasn't previously referred to. This happens at the root of
+    // a boundary. We make kind of a leap here and assume this is the root.
+    const rootSegmentID = segment.id = boundary.rootSegmentID;
+
+    if (rootSegmentID === -1) {
+      throw new Error('A root segment ID must have been assigned by now. This is a bug in React.');
+    }
+
+    return flushSegmentContainer(request, destination, segment);
+  } else if (segmentID === boundary.rootSegmentID) {
+    // When we emit postponed boundaries, we might have assigned the ID already
+    // but it's still the root segment so we can't inject it into the parent yet.
+    return flushSegmentContainer(request, destination, segment);
+  } else {
+    flushSegmentContainer(request, destination, segment);
+    return writeCompletedSegmentInstruction(destination, request.resumableState, request.renderState, segmentID);
+  }
+}
+
+function flushCompletedQueues(request, destination) {
+  beginWriting();
+
+  try {
+    // The structure of this is to go through each queue one by one and write
+    // until the sink tells us to stop. When we should stop, we still finish writing
+    // that item fully and then yield. At that point we remove the already completed
+    // items up until the point we completed them.
+    let i;
+    const completedRootSegment = request.completedRootSegment;
+
+    if (completedRootSegment !== null) {
+      if (completedRootSegment.status === POSTPONED) {
+        // We postponed the root, so we write nothing.
+        return;
+      } else if (request.pendingRootTasks === 0) {
+        if (enableFloat) {
+          writePreamble(destination, request.resumableState, request.renderState, request.allPendingTasks === 0 && request.trackedPostpones === null);
+        }
+
+        flushSegment(request, destination, completedRootSegment);
+        request.completedRootSegment = null;
+        writeCompletedRoot(destination, request.renderState, request.resumableState);
+      } else {
+        // We haven't flushed the root yet so we don't need to check any other branches further down
+        return;
+      }
+    }
+
+    if (enableFloat) {
+      writeHoistables(destination, request.resumableState, request.renderState);
+    } // We emit client rendering instructions for already emitted boundaries first.
+    // This is so that we can signal to the client to start client rendering them as
+    // soon as possible.
+
+
+    const clientRenderedBoundaries = request.clientRenderedBoundaries;
+
+    for (i = 0; i < clientRenderedBoundaries.length; i++) {
+      const boundary = clientRenderedBoundaries[i];
+
+      if (!flushClientRenderedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        clientRenderedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    clientRenderedBoundaries.splice(0, i); // Next we emit any complete boundaries. It's better to favor boundaries
+    // that are completely done since we can actually show them, than it is to emit
+    // any individual segments from a partially complete boundary.
+
+    const completedBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < completedBoundaries.length; i++) {
+      const boundary = completedBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        completedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    completedBoundaries.splice(0, i); // Allow anything written so far to flush to the underlying sink before
+    // we continue with lower priorities.
+
+    completeWriting(destination);
+    beginWriting(destination); // TODO: Here we'll emit data used by hydration.
+    // Next we emit any segments of any boundaries that are partially complete
+    // but not deeply complete.
+
+    const partialBoundaries = request.partialBoundaries;
+
+    for (i = 0; i < partialBoundaries.length; i++) {
+      const boundary = partialBoundaries[i];
+
+      if (!flushPartialBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        partialBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    partialBoundaries.splice(0, i); // Next we check the completed boundaries again. This may have had
+    // boundaries added to it in case they were too larged to be inlined.
+    // New ones might be added in this loop.
+
+    const largeBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < largeBoundaries.length; i++) {
+      const boundary = largeBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        largeBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    largeBoundaries.splice(0, i);
+  } finally {
+    if (request.allPendingTasks === 0 && request.pingedTasks.length === 0 && request.clientRenderedBoundaries.length === 0 && request.completedBoundaries.length === 0 // We don't need to check any partially completed segments because
+    // either they have pending task or they're complete.
+    ) {
+        request.flushScheduled = false;
+
+        {
+          // We write the trailing tags but only if don't have any data to resume.
+          // If we need to resume we'll write the postamble in the resume instead.
+          if (request.trackedPostpones === null) {
+            writePostamble(destination, request.resumableState);
+          }
+        }
+
+        completeWriting(destination);
+        flushBuffered(destination);
+
+
+        close(destination); // We need to stop flowing now because we do not want any async contexts which might call
+        // float methods to initiate any flushes after this point
+
+        stopFlowing(request);
+      } else {
+      completeWriting(destination);
+      flushBuffered(destination);
+    }
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  {
+    scheduleWork(() => requestStorage.run(request, performWork, request));
+  }
+
+  if (request.trackedPostpones === null) {
+    // this is either a regular render or a resume. For regular render we want
+    // to call emitEarlyPreloads after the first performWork because we want
+    // are responding to a live request and need to balance sending something early
+    // (i.e. don't want for the shell to finish) but we need something to send.
+    // The only implementation of this is for DOM at the moment and during resumes nothing
+    // actually emits but the code paths here are the same.
+    // During a prerender we don't want to be too aggressive in emitting early preloads
+    // because we aren't responding to a live request and we can wait for the prerender to
+    // postpone before we emit anything.
+    {
+      scheduleWork(() => requestStorage.run(request, enqueueEarlyPreloadsAfterInitialWork, request));
+    }
+  }
+}
+
+function enqueueEarlyPreloadsAfterInitialWork(request) {
+  const shellComplete = request.pendingRootTasks === 0;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    request.flushScheduled = true;
+    scheduleWork(() => {
+      // We need to existence check destination again here because it might go away
+      // in between the enqueueFlush call and the work execution
+      const destination = request.destination;
+
+      if (destination) {
+        flushCompletedQueues(request, destination);
+      } else {
+        request.flushScheduled = false;
+      }
+    });
+  }
+} // This function is intented to only be called during the pipe function for the Node builds.
+// The reason we need this is because `renderToPipeableStream` is the only API which allows
+// you to start flowing before the shell is complete and we've had a chance to emit early
+// preloads already. This is really just defensive programming to ensure that we give hosts an
+// opportunity to flush early preloads before streaming begins in case they are in an environment
+// that only supports a single call to emitEarlyPreloads like the DOM renderers. It's unfortunate
+// to put this Node only function directly in ReactFizzServer but it'd be more ackward to factor it
+// by moving the implementation into ReactServerStreamConfigNode and even then we may not be able to
+// eliminate all the wasted branching.
+
+
+function prepareForStartFlowingIfBeforeAllReady(request) {
+  const shellComplete = request.trackedPostpones === null ? // Render Request, we define shell complete by the pending root tasks
+  request.pendingRootTasks === 0 : // Prerender Request, we define shell complete by completedRootSegemtn
+  request.completedRootSegment === null ? request.pendingRootTasks === 0 : request.completedRootSegment.status !== POSTPONED;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+}
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedQueues(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function stopFlowing(request) {
+  request.destination = null;
+} // This is called to early terminate a request. It puts all pending boundaries in client rendered state.
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+      abortableTasks.forEach(task => abortTask(task, request, error));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function flushResources(request) {
+  enqueueFlush(request);
+}
+function getFormState(request) {
+  return request.formState;
+}
+function getResumableState(request) {
+  return request.resumableState;
+}
+function getRenderState(request) {
+  return request.renderState;
+}
+
+function addToReplayParent(node, parentKeyPath, trackedPostpones) {
+  if (parentKeyPath === null) {
+    trackedPostpones.rootNodes.push(node);
+  } else {
+    const workingMap = trackedPostpones.workingMap;
+    let parentNode = workingMap.get(parentKeyPath);
+
+    if (parentNode === undefined) {
+      parentNode = [parentKeyPath[1], parentKeyPath[2], [], null];
+      workingMap.set(parentKeyPath, parentNode);
+      addToReplayParent(parentNode, parentKeyPath[0], trackedPostpones);
+    }
+
+    parentNode[2].push(node);
+  }
+} // Returns the state of a postponed request or null if nothing was postponed.
+
+
+function getPostponedState(request) {
+  const trackedPostpones = request.trackedPostpones;
+
+  if (trackedPostpones === null || trackedPostpones.rootNodes.length === 0 && trackedPostpones.rootSlots === null) {
+    // Reset. Let the flushing behave as if we completed the whole document.
+    request.trackedPostpones = null;
+    return null;
+  }
+
+  if (request.completedRootSegment !== null && request.completedRootSegment.status === POSTPONED) {
+    // We postponed the root so we didn't flush anything.
+    resetResumableState(request.resumableState, request.renderState);
+  }
+
+  return {
+    nextSegmentId: request.nextSegmentId,
+    rootFormatContext: request.rootFormatContext,
+    progressiveChunkSize: request.progressiveChunkSize,
+    resumableState: request.resumableState,
+    replayNodes: trackedPostpones.rootNodes,
+    replaySlots: trackedPostpones.rootSlots
+  };
+}
+
+function createDrainHandler(destination, request) {
+  return () => startFlowing(request, destination);
+}
+
+function createCancelHandler(request, reason) {
+  return () => {
+    stopFlowing(request); // eslint-disable-next-line react-internal/prod-error-codes
+
+    abort(request, new Error(reason));
+  };
+}
+
+function createRequestImpl(children, options) {
+  const resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined);
+  return createRequest(children, resumableState, createRenderState(resumableState, options ? options.nonce : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, options ? options.onHeaders : undefined, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, options ? options.onAllReady : undefined, options ? options.onShellReady : undefined, options ? options.onShellError : undefined, undefined, options ? options.onPostpone : undefined, options ? options.formState : undefined);
+}
+
+function renderToPipeableStream(children, options) {
+  const request = createRequestImpl(children, options);
+  let hasStartedFlowing = false;
+  startWork(request);
+  return {
+    pipe(destination) {
+      if (hasStartedFlowing) {
+        throw new Error('React currently only supports piping to one writable stream.');
+      }
+
+      hasStartedFlowing = true;
+      prepareForStartFlowingIfBeforeAllReady(request);
+      startFlowing(request, destination);
+      destination.on('drain', createDrainHandler(destination, request));
+      destination.on('error', createCancelHandler(request, 'The destination stream errored while writing data.'));
+      destination.on('close', createCancelHandler(request, 'The destination stream closed early.'));
+      return destination;
+    },
+
+    abort(reason) {
+      abort(request, reason);
+    }
+
+  };
+}
+
+function resumeRequestImpl(children, postponedState, options) {
+  return resumeRequest(children, postponedState, resumeRenderState(postponedState.resumableState, options ? options.nonce : undefined), options ? options.onError : undefined, options ? options.onAllReady : undefined, options ? options.onShellReady : undefined, options ? options.onShellError : undefined, undefined, options ? options.onPostpone : undefined);
+}
+
+function resumeToPipeableStream(children, postponedState, options) {
+  const request = resumeRequestImpl(children, postponedState, options);
+  let hasStartedFlowing = false;
+  startWork(request);
+  return {
+    pipe(destination) {
+      if (hasStartedFlowing) {
+        throw new Error('React currently only supports piping to one writable stream.');
+      }
+
+      hasStartedFlowing = true;
+      startFlowing(request, destination);
+      destination.on('drain', createDrainHandler(destination, request));
+      destination.on('error', createCancelHandler(request, 'The destination stream errored while writing data.'));
+      destination.on('close', createCancelHandler(request, 'The destination stream closed early.'));
+      return destination;
+    },
+
+    abort(reason) {
+      abort(request, reason);
+    }
+
+  };
+}
+
+function createFakeWritable(readable) {
+  // The current host config expects a Writable so we create
+  // a fake writable for now to push into the Readable.
+  return {
+    write(chunk) {
+      return readable.push(chunk);
+    },
+
+    end() {
+      readable.push(null);
+    },
+
+    destroy(error) {
+      readable.destroy(error);
+    }
+
+  };
+}
+
+function prerenderToNodeStream(children, options) {
+  return new Promise((resolve, reject) => {
+    const onFatalError = reject;
+
+    function onAllReady() {
+      const readable = new stream.Readable({
+        read() {
+          startFlowing(request, writable);
+        }
+
+      });
+      const writable = createFakeWritable(readable);
+      const result = {
+        postponed: getPostponedState(request),
+        prelude: readable
+      };
+      resolve(result);
+    }
+
+    const resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined);
+    const request = createPrerenderRequest(children, resumableState, createRenderState(resumableState, undefined, // nonce is not compatible with prerendered bootstrap scripts
+    options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, options ? options.onHeaders : undefined, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, undefined, undefined, onFatalError, options ? options.onPostpone : undefined);
+
+    if (options && options.signal) {
+      const signal = options.signal;
+
+      if (signal.aborted) {
+        abort(request, signal.reason);
+      } else {
+        const listener = () => {
+          abort(request, signal.reason);
+          signal.removeEventListener('abort', listener);
+        };
+
+        signal.addEventListener('abort', listener);
+      }
+    }
+
+    startWork(request);
+  });
+}
+
+exports.prerenderToNodeStream = prerenderToNodeStream;
+exports.renderToPipeableStream = renderToPipeableStream;
+exports.resumeToPipeableStream = resumeToPipeableStream;
+exports.version = ReactVersion;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.node.production.min.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.node.production.min.js
index a30bb28865ee6..f001509504061 100644
--- a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.node.production.min.js
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server.node.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-dom-server.node.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-dom-server.node.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var aa=require("util"),ba=require("crypto"),ca=require("async_hooks"),fa=require("next/dist/compiled/react-experimental"),ha=require("react-dom"),ia=require("stream");function ja(a){"function"===typeof a.flush&&a.flush()}var l=null,n=0,na=!0;
 function u(a,b){if("string"===typeof b){if(0!==b.length)if(2048<3*b.length)0<n&&(oa(a,l.subarray(0,n)),l=new Uint8Array(2048),n=0),oa(a,va.encode(b));else{var c=l;0<n&&(c=l.subarray(n));c=va.encodeInto(b,c);var d=c.read;n+=c.written;d<b.length&&(oa(a,l.subarray(0,n)),l=new Uint8Array(2048),n=va.encodeInto(b.slice(d),l).written);2048===n&&(oa(a,l),l=new Uint8Array(2048),n=0)}}else 0!==b.byteLength&&(2048<b.byteLength?(0<n&&(oa(a,l.subarray(0,n)),l=new Uint8Array(2048),n=0),oa(a,b)):(c=l.length-n,c<
 b.byteLength&&(0===c?oa(a,l):(l.set(b.subarray(0,c),n),n+=c,oa(a,l),b=b.subarray(c)),l=new Uint8Array(2048),n=0),l.set(b,n),n+=b.byteLength,2048===n&&(oa(a,l),l=new Uint8Array(2048),n=0)))}function oa(a,b){a=a.write(b);na=na&&a}function w(a,b){u(a,b);return na}function wa(a){l&&0<n&&a.write(l.subarray(0,n));l=null;n=0;na=!0}var va=new aa.TextEncoder;function x(a){return va.encode(a)}
@@ -22,12 +22,12 @@ new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv","http
 function A(a){if("boolean"===typeof a||"number"===typeof a)return""+a;a=""+a;var b=Ja.exec(a);if(b){var c="",d,e=0;for(d=b.index;d<a.length;d++){switch(a.charCodeAt(d)){case 34:b="&quot;";break;case 38:b="&amp;";break;case 39:b="&#x27;";break;case 60:b="&lt;";break;case 62:b="&gt;";break;default:continue}e!==d&&(c+=a.slice(e,d));e=d+1;c+=b}a=e!==d?c+a.slice(e,d):c}return a}
 var Ka=/([A-Z])/g,La=/^ms-/,Ma=Array.isArray,Na=fa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,Va={pending:!1,data:null,method:null,action:null},Wa=ha.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Dispatcher,qb={prefetchDNS:Xa,preconnect:Ya,preload:Za,preloadModule:$a,preinitStyle:ab,preinitScript:bb,preinitModuleScript:cb},C=[],rb=x('"></template>'),sb=x("<script>"),tb=x("\x3c/script>"),ub=x('<script src="'),vb=x('<script type="module" src="'),wb=x('" nonce="'),xb=x('" integrity="'),
 yb=x('" crossorigin="'),zb=x('" async="">\x3c/script>'),Ab=/(<\/|<)(s)(cript)/gi;function Bb(a,b,c,d){return""+b+("s"===c?"\\u0073":"\\u0053")+d}var Cb=x('<script type="importmap">'),Lb=x("\x3c/script>");
-function Mb(a,b,c,d,e,f,g,h,k){var m=void 0===b?sb:x('<script nonce="'+A(b)+'">'),q=a.idPrefix,t=[],p=null;void 0!==c&&t.push(m,(""+c).replace(Ab,Bb),tb);void 0!==f&&("string"===typeof f?(p={src:f,chunks:[]},Nb(p.chunks,{src:f,async:!0,integrity:void 0,nonce:b})):(p={src:f.src,chunks:[]},Nb(p.chunks,{src:f.src,async:!0,integrity:f.integrity,nonce:b})));c=[];void 0!==g&&(c.push(Cb),c.push((""+JSON.stringify(g)).replace(Ab,Bb)),c.push(Lb));g=h?{preconnects:"",fontPreloads:"",highImagePreloads:"",remainingCapacity:"number"===
-typeof k?k:2E3}:null;h={placeholderPrefix:x(q+"P:"),segmentPrefix:x(q+"S:"),boundaryPrefix:x(q+"B:"),startInlineScript:m,htmlChunks:null,headChunks:null,externalRuntimeScript:p,bootstrapChunks:t,onHeaders:h,headers:g,resets:{font:{},dns:{},connect:{default:{},anonymous:{},credentials:{}},image:{},style:{}},charsetChunks:[],preconnectChunks:[],importMapChunks:c,preloadChunks:[],hoistableChunks:[],preconnects:new Set,fontPreloads:new Set,highImagePreloads:new Set,styles:new Map,bootstrapScripts:new Set,
-scripts:new Set,bulkPreloads:new Set,preloads:{images:new Map,stylesheets:new Map,scripts:new Map,moduleScripts:new Map},nonce:b,boundaryResources:null,stylesToHoist:!1};if(void 0!==d)for(m=0;m<d.length;m++)c=d[m],g=p=void 0,k={rel:"preload",as:"script",fetchPriority:"low",nonce:b},"string"===typeof c?k.href=q=c:(k.href=q=c.src,k.integrity=g="string"===typeof c.integrity?c.integrity:void 0,k.crossOrigin=p="string"===typeof c||null==c.crossOrigin?void 0:"use-credentials"===c.crossOrigin?"use-credentials":
-""),c=a,f=q,c.scriptResources[f]=null,c.moduleScriptResources[f]=null,c=[],G(c,k),h.bootstrapScripts.add(c),t.push(ub,A(q)),b&&t.push(wb,A(b)),"string"===typeof g&&t.push(xb,A(g)),"string"===typeof p&&t.push(yb,A(p)),t.push(zb);if(void 0!==e)for(d=0;d<e.length;d++)k=e[d],p=q=void 0,g={rel:"modulepreload",fetchPriority:"low",nonce:b},"string"===typeof k?g.href=m=k:(g.href=m=k.src,g.integrity=p="string"===typeof k.integrity?k.integrity:void 0,g.crossOrigin=q="string"===typeof k||null==k.crossOrigin?
-void 0:"use-credentials"===k.crossOrigin?"use-credentials":""),k=a,c=m,k.scriptResources[c]=null,k.moduleScriptResources[c]=null,k=[],G(k,g),h.bootstrapScripts.add(k),t.push(vb,A(m)),b&&t.push(wb,A(b)),"string"===typeof p&&t.push(xb,A(p)),"string"===typeof q&&t.push(yb,A(q)),t.push(zb);return h}
-function Ob(a,b){var c=0;void 0!==b&&(c=1);return{idPrefix:void 0===a?"":a,nextFormID:0,streamingFormat:c,instructions:0,hasBody:!1,hasHtml:!1,unknownResources:{},dnsResources:{},connectResources:{default:{},anonymous:{},credentials:{}},imageResources:{},styleResources:{},scriptResources:{},moduleUnknownResources:{},moduleScriptResources:{}}}function J(a,b,c){return{insertionMode:a,selectedValue:b,tagScope:c}}
+function Mb(a,b,c,d,e,f){var g=void 0===b?sb:x('<script nonce="'+A(b)+'">'),h=a.idPrefix,k=[],m=null,q=a.bootstrapScriptContent,t=a.bootstrapScripts,p=a.bootstrapModules;void 0!==q&&k.push(g,(""+q).replace(Ab,Bb),tb);void 0!==c&&("string"===typeof c?(m={src:c,chunks:[]},Nb(m.chunks,{src:c,async:!0,integrity:void 0,nonce:b})):(m={src:c.src,chunks:[]},Nb(m.chunks,{src:c.src,async:!0,integrity:c.integrity,nonce:b})));c=[];void 0!==d&&(c.push(Cb),c.push((""+JSON.stringify(d)).replace(Ab,Bb)),c.push(Lb));
+d=e?{preconnects:"",fontPreloads:"",highImagePreloads:"",remainingCapacity:"number"===typeof f?f:2E3}:null;e={placeholderPrefix:x(h+"P:"),segmentPrefix:x(h+"S:"),boundaryPrefix:x(h+"B:"),startInlineScript:g,htmlChunks:null,headChunks:null,externalRuntimeScript:m,bootstrapChunks:k,onHeaders:e,headers:d,resets:{font:{},dns:{},connect:{default:{},anonymous:{},credentials:{}},image:{},style:{}},charsetChunks:[],preconnectChunks:[],importMapChunks:c,preloadChunks:[],hoistableChunks:[],preconnects:new Set,
+fontPreloads:new Set,highImagePreloads:new Set,styles:new Map,bootstrapScripts:new Set,scripts:new Set,bulkPreloads:new Set,preloads:{images:new Map,stylesheets:new Map,scripts:new Map,moduleScripts:new Map},nonce:b,boundaryResources:null,stylesToHoist:!1};if(void 0!==t)for(g=0;g<t.length;g++)c=t[g],d=m=void 0,f={rel:"preload",as:"script",fetchPriority:"low",nonce:b},"string"===typeof c?f.href=h=c:(f.href=h=c.src,f.integrity=d="string"===typeof c.integrity?c.integrity:void 0,f.crossOrigin=m="string"===
+typeof c||null==c.crossOrigin?void 0:"use-credentials"===c.crossOrigin?"use-credentials":""),c=a,q=h,c.scriptResources[q]=null,c.moduleScriptResources[q]=null,c=[],G(c,f),e.bootstrapScripts.add(c),k.push(ub,A(h)),b&&k.push(wb,A(b)),"string"===typeof d&&k.push(xb,A(d)),"string"===typeof m&&k.push(yb,A(m)),k.push(zb);if(void 0!==p)for(t=0;t<p.length;t++)f=p[t],m=h=void 0,d={rel:"modulepreload",fetchPriority:"low",nonce:b},"string"===typeof f?d.href=g=f:(d.href=g=f.src,d.integrity=m="string"===typeof f.integrity?
+f.integrity:void 0,d.crossOrigin=h="string"===typeof f||null==f.crossOrigin?void 0:"use-credentials"===f.crossOrigin?"use-credentials":""),f=a,c=g,f.scriptResources[c]=null,f.moduleScriptResources[c]=null,f=[],G(f,d),e.bootstrapScripts.add(f),k.push(vb,A(g)),b&&k.push(wb,A(b)),"string"===typeof m&&k.push(xb,A(m)),"string"===typeof h&&k.push(yb,A(h)),k.push(zb);return e}
+function Ob(a,b,c,d,e){var f=0;void 0!==b&&(f=1);return{idPrefix:void 0===a?"":a,nextFormID:0,streamingFormat:f,bootstrapScriptContent:c,bootstrapScripts:d,bootstrapModules:e,instructions:0,hasBody:!1,hasHtml:!1,unknownResources:{},dnsResources:{},connectResources:{default:{},anonymous:{},credentials:{}},imageResources:{},styleResources:{},scriptResources:{},moduleUnknownResources:{},moduleScriptResources:{}}}function J(a,b,c){return{insertionMode:a,selectedValue:b,tagScope:c}}
 function Pb(a){return J("http://www.w3.org/2000/svg"===a?3:"http://www.w3.org/1998/Math/MathML"===a?4:0,null,0)}
 function Qb(a,b,c){switch(b){case "noscript":return J(2,null,a.tagScope|1);case "select":return J(2,null!=c.value?c.value:c.defaultValue,a.tagScope);case "svg":return J(3,null,a.tagScope);case "picture":return J(2,null,a.tagScope|2);case "math":return J(4,null,a.tagScope);case "foreignObject":return J(2,null,a.tagScope);case "table":return J(5,null,a.tagScope);case "thead":case "tbody":case "tfoot":return J(6,null,a.tagScope);case "colgroup":return J(8,null,a.tagScope);case "tr":return J(7,null,a.tagScope)}return 5<=
 a.insertionMode?J(2,null,a.tagScope):0===a.insertionMode?"html"===b?J(1,null,a.tagScope):J(2,null,a.tagScope):1===a.insertionMode?J(2,null,a.tagScope):a}var Rb=x("\x3c!-- --\x3e");function Sb(a,b,c,d){if(""===b)return d;d&&a.push(Rb);a.push(A(b));return!0}var Tb=new Map,Ub=x(' style="'),Vb=x(":"),Wb=x(";");
@@ -68,7 +68,7 @@ C;var Bc=c.crossOrigin;var ae="string"===typeof Bc?"use-credentials"===Bc?Bc:"":
 Cc):(Da=[],G(Da,{rel:"preload",as:"image",href:I?void 0:M,imageSrcSet:I,imageSizes:$d,crossOrigin:ae,integrity:c.integrity,type:c.type,fetchPriority:c.fetchPriority,referrerPolicy:c.referrerPolicy}),"high"===c.fetchPriority||10>e.highImagePreloads.size?e.highImagePreloads.add(Da):(e.bulkPreloads.add(Da),Ac.set(Ta,Da)))}}return oc(a,c,"img");case "base":case "area":case "br":case "col":case "embed":case "hr":case "keygen":case "param":case "source":case "track":case "wbr":return oc(a,c,b);case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph":break;
 case "head":if(2>f.insertionMode&&null===e.headChunks){e.headChunks=[];var be=rc(e.headChunks,c,"head")}else be=rc(a,c,"head");return be;case "html":if(0===f.insertionMode&&null===e.htmlChunks){e.htmlChunks=[Ec];var ce=rc(e.htmlChunks,c,"html")}else ce=rc(a,c,"html");return ce;default:if(-1!==b.indexOf("-")){a.push(U(b));var Dc=null,de=null,Ua;for(Ua in c)if(z.call(c,Ua)){var Z=c[Ua];if(null!=Z){var ee=Ua;switch(Ua){case "children":Dc=Z;break;case "dangerouslySetInnerHTML":de=Z;break;case "style":Xb(a,
 Z);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":break;case "className":ee="class";default:if(Ga(Ua)&&"function"!==typeof Z&&"symbol"!==typeof Z&&!1!==Z){if(!0===Z)Z="";else if("object"===typeof Z)continue;a.push(O,ee,P,A(Z),N)}}}}a.push(T);gc(a,de,Dc);return Dc}}return rc(a,c,b)}var Hc=new Map;function qc(a){var b=Hc.get(a);void 0===b&&(b=x("</"+a+">"),Hc.set(a,b));return b}
-function Ic(a,b){b=b.bootstrapChunks;for(var c=0;c<b.length-1;c++)u(a,b[c]);return c<b.length?(c=b[c],b.length=0,w(a,c)):!0}var Jc=x('<template id="'),Kc=x('"></template>'),Lc=x("\x3c!--$--\x3e"),Mc=x('\x3c!--$?--\x3e<template id="'),Nc=x('"></template>'),Oc=x("\x3c!--$!--\x3e"),Pc=x("\x3c!--/$--\x3e"),Qc=x("<template"),Rc=x('"'),Sc=x(' data-dgst="');x(' data-msg="');x(' data-stck="');var Tc=x("></template>");
+function Ic(a,b,c){c.bootstrapScriptContent=void 0;c.bootstrapScripts=void 0;c.bootstrapModules=void 0;b=b.bootstrapChunks;for(c=0;c<b.length-1;c++)u(a,b[c]);return c<b.length?(c=b[c],b.length=0,w(a,c)):!0}var Jc=x('<template id="'),Kc=x('"></template>'),Lc=x("\x3c!--$--\x3e"),Mc=x('\x3c!--$?--\x3e<template id="'),Nc=x('"></template>'),Oc=x("\x3c!--$!--\x3e"),Pc=x("\x3c!--/$--\x3e"),Qc=x("<template"),Rc=x('"'),Sc=x(' data-dgst="');x(' data-msg="');x(' data-stck="');var Tc=x("></template>");
 function Uc(a,b,c){u(a,Mc);if(null===c)throw Error("An ID must have been assigned before we can complete the boundary.");u(a,b.boundaryPrefix);u(a,c.toString(16));return w(a,Nc)}
 var Vc=x('<div hidden id="'),Wc=x('">'),Xc=x("</div>"),Yc=x('<svg aria-hidden="true" style="display:none" id="'),Zc=x('">'),$c=x("</svg>"),ad=x('<math aria-hidden="true" style="display:none" id="'),bd=x('">'),cd=x("</math>"),dd=x('<table hidden id="'),ed=x('">'),fd=x("</table>"),gd=x('<table hidden><tbody id="'),hd=x('">'),id=x("</tbody></table>"),jd=x('<table hidden><tr id="'),kd=x('">'),ld=x("</tr></table>"),md=x('<table hidden><colgroup id="'),nd=x('">'),od=x("</colgroup></table>");
 function pd(a,b,c,d){switch(c.insertionMode){case 0:case 1:case 2:return u(a,Vc),u(a,b.segmentPrefix),u(a,d.toString(16)),w(a,Wc);case 3:return u(a,Yc),u(a,b.segmentPrefix),u(a,d.toString(16)),w(a,Zc);case 4:return u(a,ad),u(a,b.segmentPrefix),u(a,d.toString(16)),w(a,bd);case 5:return u(a,dd),u(a,b.segmentPrefix),u(a,d.toString(16)),w(a,ed);case 6:return u(a,gd),u(a,b.segmentPrefix),u(a,d.toString(16)),w(a,hd);case 7:return u(a,jd),u(a,b.segmentPrefix),u(a,d.toString(16)),w(a,kd);case 8:return u(a,
@@ -177,12 +177,12 @@ function rh(a,b,c){c.parentFlushed=!0;switch(c.status){case 0:c.id=a.nextSegment
 function sh(a,b,c){var d=c.boundary;if(null===d)return rh(a,b,c);d.parentFlushed=!0;if(4===d.status)d=d.errorDigest,w(b,Oc),u(b,Qc),d&&(u(b,Sc),u(b,A(d)),u(b,Rc)),w(b,Tc),rh(a,b,c);else if(1!==d.status)0===d.status&&(d.rootSegmentID=a.nextSegmentId++),0<d.completedSegments.length&&a.partialBoundaries.push(d),Uc(b,a.renderState,d.rootSegmentID),rh(a,b,c);else if(d.byteSize>a.progressiveChunkSize)d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),Uc(b,a.renderState,d.rootSegmentID),rh(a,b,
 c);else{c=d.resources;var e=a.renderState.boundaryResources;e&&(c.styles.forEach(df,e),c.stylesheets.forEach(ef,e));w(b,Lc);d=d.completedSegments;if(1!==d.length)throw Error("A previously unvisited boundary must have exactly one root segment. This is a bug in React.");sh(a,b,d[0])}return w(b,Pc)}function th(a,b,c){pd(b,a.renderState,c.parentFormatContext,c.id);sh(a,b,c);return qd(b,c.parentFormatContext)}
 function uh(a,b,c){a.renderState.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e<d.length;e++)vh(a,b,c,d[e]);d.length=0;He(b,c.resources,a.renderState);d=a.resumableState;a=a.renderState;e=c.rootSegmentID;c=c.resources;var f=a.stylesToHoist;a.stylesToHoist=!1;var g=0===d.streamingFormat;g?(u(b,a.startInlineScript),f?0===(d.instructions&2)?(d.instructions|=10,u(b,2048<zd.length?zd.slice():zd)):0===(d.instructions&8)?(d.instructions|=8,u(b,Ad)):u(b,Bd):0===(d.instructions&2)?(d.instructions|=
-2,u(b,xd)):u(b,yd)):f?u(b,ie):u(b,he);d=e.toString(16);u(b,a.boundaryPrefix);u(b,d);g?u(b,Cd):u(b,je);u(b,a.segmentPrefix);u(b,d);f?g?(u(b,Dd),We(b,c)):(u(b,ke),Xe(b,c)):g&&u(b,fe);d=g?w(b,ge):w(b,rb);return Ic(b,a)&&d}
+2,u(b,xd)):u(b,yd)):f?u(b,ie):u(b,he);e=e.toString(16);u(b,a.boundaryPrefix);u(b,e);g?u(b,Cd):u(b,je);u(b,a.segmentPrefix);u(b,e);f?g?(u(b,Dd),We(b,c)):(u(b,ke),Xe(b,c)):g&&u(b,fe);c=g?w(b,ge):w(b,rb);return Ic(b,a,d)&&c}
 function vh(a,b,c,d){if(2===d.status)return!0;var e=d.id;if(-1===e){if(-1===(d.id=c.rootSegmentID))throw Error("A root segment ID must have been assigned by now. This is a bug in React.");return th(a,b,d)}if(e===c.rootSegmentID)return th(a,b,d);th(a,b,d);c=a.resumableState;a=a.renderState;(d=0===c.streamingFormat)?(u(b,a.startInlineScript),0===(c.instructions&1)?(c.instructions|=1,u(b,rd)):u(b,sd)):u(b,vd);u(b,a.segmentPrefix);e=e.toString(16);u(b,e);d?u(b,td):u(b,wd);u(b,a.placeholderPrefix);u(b,
 e);b=d?w(b,ud):w(b,rb);return b}
 function qh(a,b){l=new Uint8Array(2048);n=0;na=!0;try{var c,d=a.completedRootSegment;if(null!==d)if(5!==d.status&&0===a.pendingRootTasks){var e=a.renderState;if((0!==a.allPendingTasks||null!==a.trackedPostpones)&&e.externalRuntimeScript){var f=e.externalRuntimeScript,g=a.resumableState,h=f.src,k=f.chunks;g.scriptResources.hasOwnProperty(h)||(g.scriptResources[h]=null,e.scripts.add(k))}var m=e.htmlChunks,q=e.headChunks;f=0;if(m){for(f=0;f<m.length;f++)u(b,m[f]);if(q)for(f=0;f<q.length;f++)u(b,q[f]);
 else u(b,U("head")),u(b,T)}else if(q)for(f=0;f<q.length;f++)u(b,q[f]);var t=e.charsetChunks;for(f=0;f<t.length;f++)u(b,t[f]);t.length=0;e.preconnects.forEach(Ie,b);e.preconnects.clear();var p=e.preconnectChunks;for(f=0;f<p.length;f++)u(b,p[f]);p.length=0;e.fontPreloads.forEach(Ie,b);e.fontPreloads.clear();e.highImagePreloads.forEach(Ie,b);e.highImagePreloads.clear();e.styles.forEach(Pe,b);var E=e.importMapChunks;for(f=0;f<E.length;f++)u(b,E[f]);E.length=0;e.bootstrapScripts.forEach(Ie,b);e.scripts.forEach(Ie,
-b);e.scripts.clear();e.bulkPreloads.forEach(Ie,b);e.bulkPreloads.clear();var H=e.preloadChunks;for(f=0;f<H.length;f++)u(b,H[f]);H.length=0;var X=e.hoistableChunks;for(f=0;f<X.length;f++)u(b,X[f]);X.length=0;m&&null===q&&u(b,qc("head"));sh(a,b,d);a.completedRootSegment=null;Ic(b,a.renderState)}else return;var r=a.renderState;d=0;r.preconnects.forEach(Ie,b);r.preconnects.clear();var B=r.preconnectChunks;for(d=0;d<B.length;d++)u(b,B[d]);B.length=0;r.fontPreloads.forEach(Ie,b);r.fontPreloads.clear();
+b);e.scripts.clear();e.bulkPreloads.forEach(Ie,b);e.bulkPreloads.clear();var H=e.preloadChunks;for(f=0;f<H.length;f++)u(b,H[f]);H.length=0;var X=e.hoistableChunks;for(f=0;f<X.length;f++)u(b,X[f]);X.length=0;m&&null===q&&u(b,qc("head"));sh(a,b,d);a.completedRootSegment=null;Ic(b,a.renderState,a.resumableState)}else return;var r=a.renderState;d=0;r.preconnects.forEach(Ie,b);r.preconnects.clear();var B=r.preconnectChunks;for(d=0;d<B.length;d++)u(b,B[d]);B.length=0;r.fontPreloads.forEach(Ie,b);r.fontPreloads.clear();
 r.highImagePreloads.forEach(Ie,b);r.highImagePreloads.clear();r.styles.forEach(Re,b);r.scripts.forEach(Ie,b);r.scripts.clear();r.bulkPreloads.forEach(Ie,b);r.bulkPreloads.clear();var D=r.preloadChunks;for(d=0;d<D.length;d++)u(b,D[d]);D.length=0;var ka=r.hoistableChunks;for(d=0;d<ka.length;d++)u(b,ka[d]);ka.length=0;var v=a.clientRenderedBoundaries;for(c=0;c<v.length;c++){var S=v[c];r=b;var F=a.resumableState,K=a.renderState,L=S.rootSegmentID,Oa=S.errorDigest,ya=S.errorMessage,pa=S.errorComponentStack,
 la=0===F.streamingFormat;la?(u(r,K.startInlineScript),0===(F.instructions&4)?(F.instructions|=4,u(r,le)):u(r,me)):u(r,qe);u(r,K.boundaryPrefix);u(r,L.toString(16));la&&u(r,ne);if(Oa||ya||pa)la?(u(r,oe),u(r,ve(Oa||""))):(u(r,re),u(r,A(Oa||"")));if(ya||pa)la?(u(r,oe),u(r,ve(ya||""))):(u(r,se),u(r,A(ya||"")));pa&&(la?(u(r,oe),u(r,ve(pa))):(u(r,te),u(r,A(pa))));if(la?!w(r,pe):!w(r,rb)){a.destination=null;c++;v.splice(0,c);return}}v.splice(0,c);var za=a.completedBoundaries;for(c=0;c<za.length;c++)if(!uh(a,
 b,za[c])){a.destination=null;c++;za.splice(0,c);return}za.splice(0,c);wa(b);l=new Uint8Array(2048);n=0;na=!0;var qa=a.partialBoundaries;for(c=0;c<qa.length;c++){var ra=qa[c];a:{v=a;S=b;v.renderState.boundaryResources=ra.resources;var sa=ra.completedSegments;for(F=0;F<sa.length;F++)if(!vh(v,S,ra,sa[F])){F++;sa.splice(0,F);var Pa=!1;break a}sa.splice(0,F);Pa=He(S,ra.resources,v.renderState)}if(!Pa){a.destination=null;c++;qa.splice(0,c);return}}qa.splice(0,c);var da=a.completedBoundaries;for(c=0;c<da.length;c++)if(!uh(a,
@@ -192,12 +192,14 @@ function yh(a,b){if(1===a.status)a.status=2,b.destroy(a.fatalError);else if(2!==
 function jh(a,b,c){if(null===b)c.rootNodes.push(a);else{var d=c.workingMap,e=d.get(b);void 0===e&&(e=[b[1],b[2],[],null],d.set(b,e),jh(e,b[0],c));e[2].push(a)}}
 function Ah(a){var b=a.trackedPostpones;if(null===b||0===b.rootNodes.length&&null===b.rootSlots)return a.trackedPostpones=null;if(null!==a.completedRootSegment&&5===a.completedRootSegment.status){var c=a.resumableState,d=a.renderState;c.nextFormID=0;c.hasBody=!1;c.hasHtml=!1;c.unknownResources={font:d.resets.font};c.dnsResources=d.resets.dns;c.connectResources=d.resets.connect;c.imageResources=d.resets.image;c.styleResources=d.resets.style;c.scriptResources={};c.moduleUnknownResources={};c.moduleScriptResources=
 {}}return{nextSegmentId:a.nextSegmentId,rootFormatContext:a.rootFormatContext,progressiveChunkSize:a.progressiveChunkSize,resumableState:a.resumableState,replayNodes:b.rootNodes,replaySlots:b.rootSlots}}function Bh(a,b){return function(){return yh(b,a)}}function Ch(a,b){return function(){a.destination=null;zh(a,Error(b))}}
-function Dh(a,b){var c=Ob(b?b.identifierPrefix:void 0,b?b.unstable_externalRuntimeSrc:void 0);return Pg(a,c,Mb(c,b?b.nonce:void 0,b?b.bootstrapScriptContent:void 0,b?b.bootstrapScripts:void 0,b?b.bootstrapModules:void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.importMap:void 0,b?b.onHeaders:void 0,b?b.maxHeadersLength:void 0),Pb(b?b.namespaceURI:void 0),b?b.progressiveChunkSize:void 0,b?b.onError:void 0,b?b.onAllReady:void 0,b?b.onShellReady:void 0,b?b.onShellError:void 0,void 0,b?b.onPostpone:
+function Dh(a,b){var c=Ob(b?b.identifierPrefix:void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.bootstrapScriptContent:void 0,b?b.bootstrapScripts:void 0,b?b.bootstrapModules:void 0);return Pg(a,c,Mb(c,b?b.nonce:void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.importMap:void 0,b?b.onHeaders:void 0,b?b.maxHeadersLength:void 0),Pb(b?b.namespaceURI:void 0),b?b.progressiveChunkSize:void 0,b?b.onError:void 0,b?b.onAllReady:void 0,b?b.onShellReady:void 0,b?b.onShellError:void 0,void 0,b?b.onPostpone:
 void 0,b?b.formState:void 0)}
-function Eh(a,b,c){var d=Mb(b.resumableState,c?c.nonce:void 0,void 0,void 0,void 0,void 0,void 0,void 0),e=c?c.onError:void 0,f=c?c.onAllReady:void 0,g=c?c.onShellReady:void 0,h=c?c.onShellError:void 0,k=c?c.onPostpone:void 0;Wa.current=qb;c=[];var m=new Set;d={destination:null,flushScheduled:!1,resumableState:b.resumableState,renderState:d,rootFormatContext:b.rootFormatContext,progressiveChunkSize:b.progressiveChunkSize,status:0,fatalError:null,nextSegmentId:b.nextSegmentId,allPendingTasks:0,pendingRootTasks:0,
+function Eh(a,b,c){var d=Mb(b.resumableState,c?c.nonce:void 0,void 0,void 0,void 0,void 0),e=c?c.onError:void 0,f=c?c.onAllReady:void 0,g=c?c.onShellReady:void 0,h=c?c.onShellError:void 0,k=c?c.onPostpone:void 0;Wa.current=qb;c=[];var m=new Set;d={destination:null,flushScheduled:!1,resumableState:b.resumableState,renderState:d,rootFormatContext:b.rootFormatContext,progressiveChunkSize:b.progressiveChunkSize,status:0,fatalError:null,nextSegmentId:b.nextSegmentId,allPendingTasks:0,pendingRootTasks:0,
 completedRootSegment:null,abortableTasks:m,pingedTasks:c,clientRenderedBoundaries:[],completedBoundaries:[],partialBoundaries:[],trackedPostpones:null,onError:void 0===e?Ng:e,onPostpone:void 0===k?Og:k,onAllReady:void 0===f?Og:f,onShellReady:void 0===g?Og:g,onShellError:void 0===h?Og:h,onFatalError:Og,formState:null};"number"===typeof b.replaySlots?(e=b.replaySlots,f=Qg(d,0,null,b.rootFormatContext,!1,!1),f.id=e,f.parentFlushed=!0,a=Rg(d,null,a,-1,null,f,m,null,b.rootFormatContext,Gf,null,Rf),c.push(a)):
 (a=Xg(d,null,{nodes:b.replayNodes,slots:b.replaySlots,pendingTasks:0},a,-1,null,m,null,b.rootFormatContext,Gf,null,Rf),c.push(a));return d}function Fh(a){return{write:function(b){return a.push(b)},end:function(){a.push(null)},destroy:function(b){a.destroy(b)}}}
-exports.prerenderToNodeStream=function(a,b){return new Promise(function(c,d){var e=Ob(b?b.identifierPrefix:void 0,b?b.unstable_externalRuntimeSrc:void 0),f=Sg(a,e,Mb(e,void 0,b?b.bootstrapScriptContent:void 0,b?b.bootstrapScripts:void 0,b?b.bootstrapModules:void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.importMap:void 0,b?b.onHeaders:void 0,b?b.maxHeadersLength:void 0),Pb(b?b.namespaceURI:void 0),b?b.progressiveChunkSize:void 0,b?b.onError:void 0,function(){var k=new ia.Readable({read:function(){yh(f,
+exports.prerenderToNodeStream=function(a,b){return new Promise(function(c,d){var e=Ob(b?b.identifierPrefix:void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.bootstrapScriptContent:void 0,b?b.bootstrapScripts:void 0,b?b.bootstrapModules:void 0),f=Sg(a,e,Mb(e,void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.importMap:void 0,b?b.onHeaders:void 0,b?b.maxHeadersLength:void 0),Pb(b?b.namespaceURI:void 0),b?b.progressiveChunkSize:void 0,b?b.onError:void 0,function(){var k=new ia.Readable({read:function(){yh(f,
 m)}}),m=Fh(k);k={postponed:Ah(f),prelude:k};c(k)},void 0,void 0,d,b?b.onPostpone:void 0);if(b&&b.signal){var g=b.signal;if(g.aborted)zh(f,g.reason);else{var h=function(){zh(f,g.reason);g.removeEventListener("abort",h)};g.addEventListener("abort",h)}}wh(f)})};
 exports.renderToPipeableStream=function(a,b){var c=Dh(a,b),d=!1;wh(c);return{pipe:function(e){if(d)throw Error("React currently only supports piping to one writable stream.");d=!0;ff(c.renderState,c.resumableState,null===c.trackedPostpones?0===c.pendingRootTasks:null===c.completedRootSegment?0===c.pendingRootTasks:5!==c.completedRootSegment.status);yh(c,e);e.on("drain",Bh(e,c));e.on("error",Ch(c,"The destination stream errored while writing data."));e.on("close",Ch(c,"The destination stream closed early."));
-return e},abort:function(e){zh(c,e)}}};exports.resumeToPipeableStream=function(a,b,c){var d=Eh(a,b,c),e=!1;wh(d);return{pipe:function(f){if(e)throw Error("React currently only supports piping to one writable stream.");e=!0;yh(d,f);f.on("drain",Bh(f,d));f.on("error",Ch(d,"The destination stream errored while writing data."));f.on("close",Ch(d,"The destination stream closed early."));return f},abort:function(f){zh(d,f)}}};exports.version="18.3.0-experimental-2983249dd-20231107";
+return e},abort:function(e){zh(c,e)}}};exports.resumeToPipeableStream=function(a,b,c){var d=Eh(a,b,c),e=!1;wh(d);return{pipe:function(f){if(e)throw Error("React currently only supports piping to one writable stream.");e=!0;yh(d,f);f.on("drain",Bh(f,d));f.on("error",Ch(d,"The destination stream errored while writing data."));f.on("close",Ch(d,"The destination stream closed early."));return f},abort:function(f){zh(d,f)}}};exports.version="18.3.0-experimental-7508dcd5c-20231108";
+
+//# sourceMappingURL=react-dom-server.node.production.min.js.map
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-test-utils.production.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-test-utils.production.js
new file mode 100644
index 0000000000000..93d518d4e73f3
--- /dev/null
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-test-utils.production.js
@@ -0,0 +1,1532 @@
+/**
+ * @license React
+ * react-dom-test-utils.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require("next/dist/compiled/react-experimental");
+var ReactDOM = require('react-dom');
+
+/**
+ * `ReactInstanceMap` maintains a mapping from a public facing stateful
+ * instance (key) and the internal representation (value). This allows public
+ * methods to accept the user facing instance as an argument and map them back
+ * to internal methods.
+ *
+ * Note that this module is currently shared and assumed to be stateless.
+ * If this becomes an actual Map, that will break.
+ */
+function get(key) {
+  return key._reactInternals;
+}
+
+const FunctionComponent = 0;
+const ClassComponent = 1;
+
+const HostRoot = 3; // Root of a host tree. Could be nested inside another node.
+
+const HostComponent = 5;
+const HostText = 6;
+const HostHoistable = 26;
+const HostSingleton = 27;
+
+const NoFlags =
+/*                      */
+0b0000000000000000000000000000;
+const Placement =
+/*                    */
+0b0000000000000000000000000010;
+const Hydrating =
+/*                    */
+0b0000000000000001000000000000; // You can change the rest (and add more).
+
+function getNearestMountedFiber(fiber) {
+  let node = fiber;
+  let nearestMounted = fiber;
+
+  if (!fiber.alternate) {
+    // If there is no alternate, this might be a new tree that isn't inserted
+    // yet. If it is, then it will have a pending insertion effect on it.
+    let nextNode = node;
+
+    do {
+      node = nextNode;
+
+      if ((node.flags & (Placement | Hydrating)) !== NoFlags) {
+        // This is an insertion or in-progress hydration. The nearest possible
+        // mounted fiber is the parent but we need to continue to figure out
+        // if that one is still mounted.
+        nearestMounted = node.return;
+      } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+      nextNode = node.return;
+    } while (nextNode);
+  } else {
+    while (node.return) {
+      node = node.return;
+    }
+  }
+
+  if (node.tag === HostRoot) {
+    // TODO: Check if this was a nested HostRoot when used with
+    // renderContainerIntoSubtree.
+    return nearestMounted;
+  } // If we didn't hit the root, that means that we're in an disconnected tree
+  // that has been unmounted.
+
+
+  return null;
+}
+
+function assertIsMounted(fiber) {
+  if (getNearestMountedFiber(fiber) !== fiber) {
+    throw new Error('Unable to find node on an unmounted component.');
+  }
+}
+
+function findCurrentFiberUsingSlowPath(fiber) {
+  const alternate = fiber.alternate;
+
+  if (!alternate) {
+    // If there is no alternate, then we only need to check if it is mounted.
+    const nearestMounted = getNearestMountedFiber(fiber);
+
+    if (nearestMounted === null) {
+      throw new Error('Unable to find node on an unmounted component.');
+    }
+
+    if (nearestMounted !== fiber) {
+      return null;
+    }
+
+    return fiber;
+  } // If we have two possible branches, we'll walk backwards up to the root
+  // to see what path the root points to. On the way we may hit one of the
+  // special cases and we'll deal with them.
+
+
+  let a = fiber;
+  let b = alternate;
+
+  while (true) {
+    const parentA = a.return;
+
+    if (parentA === null) {
+      // We're at the root.
+      break;
+    }
+
+    const parentB = parentA.alternate;
+
+    if (parentB === null) {
+      // There is no alternate. This is an unusual case. Currently, it only
+      // happens when a Suspense component is hidden. An extra fragment fiber
+      // is inserted in between the Suspense fiber and its children. Skip
+      // over this extra fragment fiber and proceed to the next parent.
+      const nextParent = parentA.return;
+
+      if (nextParent !== null) {
+        a = b = nextParent;
+        continue;
+      } // If there's no parent, we're at the root.
+
+
+      break;
+    } // If both copies of the parent fiber point to the same child, we can
+    // assume that the child is current. This happens when we bailout on low
+    // priority: the bailed out fiber's child reuses the current child.
+
+
+    if (parentA.child === parentB.child) {
+      let child = parentA.child;
+
+      while (child) {
+        if (child === a) {
+          // We've determined that A is the current branch.
+          assertIsMounted(parentA);
+          return fiber;
+        }
+
+        if (child === b) {
+          // We've determined that B is the current branch.
+          assertIsMounted(parentA);
+          return alternate;
+        }
+
+        child = child.sibling;
+      } // We should never have an alternate for any mounting node. So the only
+      // way this could possibly happen is if this was unmounted, if at all.
+
+
+      throw new Error('Unable to find node on an unmounted component.');
+    }
+
+    if (a.return !== b.return) {
+      // The return pointer of A and the return pointer of B point to different
+      // fibers. We assume that return pointers never criss-cross, so A must
+      // belong to the child set of A.return, and B must belong to the child
+      // set of B.return.
+      a = parentA;
+      b = parentB;
+    } else {
+      // The return pointers point to the same fiber. We'll have to use the
+      // default, slow path: scan the child sets of each parent alternate to see
+      // which child belongs to which set.
+      //
+      // Search parent A's child set
+      let didFindChild = false;
+      let child = parentA.child;
+
+      while (child) {
+        if (child === a) {
+          didFindChild = true;
+          a = parentA;
+          b = parentB;
+          break;
+        }
+
+        if (child === b) {
+          didFindChild = true;
+          b = parentA;
+          a = parentB;
+          break;
+        }
+
+        child = child.sibling;
+      }
+
+      if (!didFindChild) {
+        // Search parent B's child set
+        child = parentB.child;
+
+        while (child) {
+          if (child === a) {
+            didFindChild = true;
+            a = parentB;
+            b = parentA;
+            break;
+          }
+
+          if (child === b) {
+            didFindChild = true;
+            b = parentB;
+            a = parentA;
+            break;
+          }
+
+          child = child.sibling;
+        }
+
+        if (!didFindChild) {
+          throw new Error('Child was not found in either parent set. This indicates a bug ' + 'in React related to the return pointer. Please file an issue.');
+        }
+      }
+    }
+
+    if (a.alternate !== b) {
+      throw new Error("Return fibers should always be each others' alternates. " + 'This error is likely caused by a bug in React. Please file an issue.');
+    }
+  } // If the root is not a host container, we're in a disconnected tree. I.e.
+  // unmounted.
+
+
+  if (a.tag !== HostRoot) {
+    throw new Error('Unable to find node on an unmounted component.');
+  }
+
+  if (a.stateNode.current === a) {
+    // We've determined that A is the current branch.
+    return fiber;
+  } // Otherwise B has to be current branch.
+
+
+  return alternate;
+}
+
+const assign = Object.assign;
+
+/**
+ * `charCode` represents the actual "character code" and is safe to use with
+ * `String.fromCharCode`. As such, only keys that correspond to printable
+ * characters produce a valid `charCode`, the only exception to this is Enter.
+ * The Tab-key is considered non-printable and does not have a `charCode`,
+ * presumably because it does not produce a tab-character in browsers.
+ *
+ * @param {object} nativeEvent Native browser event.
+ * @return {number} Normalized `charCode` property.
+ */
+function getEventCharCode(nativeEvent) {
+  let charCode;
+  const keyCode = nativeEvent.keyCode;
+
+  if ('charCode' in nativeEvent) {
+    charCode = nativeEvent.charCode; // FF does not set `charCode` for the Enter-key, check against `keyCode`.
+
+    if (charCode === 0 && keyCode === 13) {
+      charCode = 13;
+    }
+  } else {
+    // IE8 does not implement `charCode`, but `keyCode` has the correct value.
+    charCode = keyCode;
+  } // IE and Edge (on Windows) and Chrome / Safari (on Windows and Linux)
+  // report Enter as charCode 10 when ctrl is pressed.
+
+
+  if (charCode === 10) {
+    charCode = 13;
+  } // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
+  // Must not discard the (non-)printable Enter-key.
+
+
+  if (charCode >= 32 || charCode === 13) {
+    return charCode;
+  }
+
+  return 0;
+}
+
+function functionThatReturnsTrue() {
+  return true;
+}
+
+function functionThatReturnsFalse() {
+  return false;
+} // This is intentionally a factory so that we have different returned constructors.
+// If we had a single constructor, it would be megamorphic and engines would deopt.
+
+
+function createSyntheticEvent(Interface) {
+  /**
+   * Synthetic events are dispatched by event plugins, typically in response to a
+   * top-level event delegation handler.
+   *
+   * These systems should generally use pooling to reduce the frequency of garbage
+   * collection. The system should check `isPersistent` to determine whether the
+   * event should be released into the pool after being dispatched. Users that
+   * need a persisted event should invoke `persist`.
+   *
+   * Synthetic events (and subclasses) implement the DOM Level 3 Events API by
+   * normalizing browser quirks. Subclasses do not necessarily have to implement a
+   * DOM interface; custom application-specific events can also subclass this.
+   */
+  // $FlowFixMe[missing-this-annot]
+  function SyntheticBaseEvent(reactName, reactEventType, targetInst, nativeEvent, nativeEventTarget) {
+    this._reactName = reactName;
+    this._targetInst = targetInst;
+    this.type = reactEventType;
+    this.nativeEvent = nativeEvent;
+    this.target = nativeEventTarget;
+    this.currentTarget = null;
+
+    for (const propName in Interface) {
+      if (!Interface.hasOwnProperty(propName)) {
+        continue;
+      }
+
+      const normalize = Interface[propName];
+
+      if (normalize) {
+        this[propName] = normalize(nativeEvent);
+      } else {
+        this[propName] = nativeEvent[propName];
+      }
+    }
+
+    const defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
+
+    if (defaultPrevented) {
+      this.isDefaultPrevented = functionThatReturnsTrue;
+    } else {
+      this.isDefaultPrevented = functionThatReturnsFalse;
+    }
+
+    this.isPropagationStopped = functionThatReturnsFalse;
+    return this;
+  } // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+  assign(SyntheticBaseEvent.prototype, {
+    // $FlowFixMe[missing-this-annot]
+    preventDefault: function () {
+      this.defaultPrevented = true;
+      const event = this.nativeEvent;
+
+      if (!event) {
+        return;
+      }
+
+      if (event.preventDefault) {
+        event.preventDefault(); // $FlowFixMe[illegal-typeof] - flow is not aware of `unknown` in IE
+      } else if (typeof event.returnValue !== 'unknown') {
+        event.returnValue = false;
+      }
+
+      this.isDefaultPrevented = functionThatReturnsTrue;
+    },
+    // $FlowFixMe[missing-this-annot]
+    stopPropagation: function () {
+      const event = this.nativeEvent;
+
+      if (!event) {
+        return;
+      }
+
+      if (event.stopPropagation) {
+        event.stopPropagation(); // $FlowFixMe[illegal-typeof] - flow is not aware of `unknown` in IE
+      } else if (typeof event.cancelBubble !== 'unknown') {
+        // The ChangeEventPlugin registers a "propertychange" event for
+        // IE. This event does not support bubbling or cancelling, and
+        // any references to cancelBubble throw "Member not found".  A
+        // typeof check of "unknown" circumvents this issue (and is also
+        // IE specific).
+        event.cancelBubble = true;
+      }
+
+      this.isPropagationStopped = functionThatReturnsTrue;
+    },
+
+    /**
+     * We release all dispatched `SyntheticEvent`s after each event loop, adding
+     * them back into the pool. This allows a way to hold onto a reference that
+     * won't be added back into the pool.
+     */
+    persist: function () {// Modern event system doesn't use pooling.
+    },
+
+    /**
+     * Checks if this event should be released back into the pool.
+     *
+     * @return {boolean} True if this should not be released, false otherwise.
+     */
+    isPersistent: functionThatReturnsTrue
+  });
+  return SyntheticBaseEvent;
+}
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+
+const EventInterface = {
+  eventPhase: 0,
+  bubbles: 0,
+  cancelable: 0,
+  timeStamp: function (event) {
+    return event.timeStamp || Date.now();
+  },
+  defaultPrevented: 0,
+  isTrusted: 0
+};
+const SyntheticEvent = createSyntheticEvent(EventInterface);
+
+const UIEventInterface = assign({}, EventInterface, {
+  view: 0,
+  detail: 0
+});
+
+createSyntheticEvent(UIEventInterface);
+let lastMovementX;
+let lastMovementY;
+let lastMouseEvent;
+
+function updateMouseMovementPolyfillState(event) {
+  if (event !== lastMouseEvent) {
+    if (lastMouseEvent && event.type === 'mousemove') {
+      // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+      lastMovementX = event.screenX - lastMouseEvent.screenX; // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+
+      lastMovementY = event.screenY - lastMouseEvent.screenY;
+    } else {
+      lastMovementX = 0;
+      lastMovementY = 0;
+    }
+
+    lastMouseEvent = event;
+  }
+}
+/**
+ * @interface MouseEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+
+const MouseEventInterface = assign({}, UIEventInterface, {
+  screenX: 0,
+  screenY: 0,
+  clientX: 0,
+  clientY: 0,
+  pageX: 0,
+  pageY: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  altKey: 0,
+  metaKey: 0,
+  getModifierState: getEventModifierState,
+  button: 0,
+  buttons: 0,
+  relatedTarget: function (event) {
+    if (event.relatedTarget === undefined) return event.fromElement === event.srcElement ? event.toElement : event.fromElement;
+    return event.relatedTarget;
+  },
+  movementX: function (event) {
+    if ('movementX' in event) {
+      return event.movementX;
+    }
+
+    updateMouseMovementPolyfillState(event);
+    return lastMovementX;
+  },
+  movementY: function (event) {
+    if ('movementY' in event) {
+      return event.movementY;
+    } // Don't need to call updateMouseMovementPolyfillState() here
+    // because it's guaranteed to have already run when movementX
+    // was copied.
+
+
+    return lastMovementY;
+  }
+});
+
+createSyntheticEvent(MouseEventInterface);
+/**
+ * @interface DragEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+const DragEventInterface = assign({}, MouseEventInterface, {
+  dataTransfer: 0
+});
+
+createSyntheticEvent(DragEventInterface);
+/**
+ * @interface FocusEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+const FocusEventInterface = assign({}, UIEventInterface, {
+  relatedTarget: 0
+});
+
+createSyntheticEvent(FocusEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent
+ */
+
+const AnimationEventInterface = assign({}, EventInterface, {
+  animationName: 0,
+  elapsedTime: 0,
+  pseudoElement: 0
+});
+
+createSyntheticEvent(AnimationEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/clipboard-apis/
+ */
+
+const ClipboardEventInterface = assign({}, EventInterface, {
+  clipboardData: function (event) {
+    return 'clipboardData' in event ? event.clipboardData : window.clipboardData;
+  }
+});
+
+createSyntheticEvent(ClipboardEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents
+ */
+
+const CompositionEventInterface = assign({}, EventInterface, {
+  data: 0
+});
+
+createSyntheticEvent(CompositionEventInterface);
+/**
+ * Normalization of deprecated HTML5 `key` values
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
+ */
+
+const normalizeKey = {
+  Esc: 'Escape',
+  Spacebar: ' ',
+  Left: 'ArrowLeft',
+  Up: 'ArrowUp',
+  Right: 'ArrowRight',
+  Down: 'ArrowDown',
+  Del: 'Delete',
+  Win: 'OS',
+  Menu: 'ContextMenu',
+  Apps: 'ContextMenu',
+  Scroll: 'ScrollLock',
+  MozPrintableKey: 'Unidentified'
+};
+/**
+ * Translation from legacy `keyCode` to HTML5 `key`
+ * Only special keys supported, all others depend on keyboard layout or browser
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
+ */
+
+const translateToKey = {
+  '8': 'Backspace',
+  '9': 'Tab',
+  '12': 'Clear',
+  '13': 'Enter',
+  '16': 'Shift',
+  '17': 'Control',
+  '18': 'Alt',
+  '19': 'Pause',
+  '20': 'CapsLock',
+  '27': 'Escape',
+  '32': ' ',
+  '33': 'PageUp',
+  '34': 'PageDown',
+  '35': 'End',
+  '36': 'Home',
+  '37': 'ArrowLeft',
+  '38': 'ArrowUp',
+  '39': 'ArrowRight',
+  '40': 'ArrowDown',
+  '45': 'Insert',
+  '46': 'Delete',
+  '112': 'F1',
+  '113': 'F2',
+  '114': 'F3',
+  '115': 'F4',
+  '116': 'F5',
+  '117': 'F6',
+  '118': 'F7',
+  '119': 'F8',
+  '120': 'F9',
+  '121': 'F10',
+  '122': 'F11',
+  '123': 'F12',
+  '144': 'NumLock',
+  '145': 'ScrollLock',
+  '224': 'Meta'
+};
+/**
+ * @param {object} nativeEvent Native browser event.
+ * @return {string} Normalized `key` property.
+ */
+
+function getEventKey(nativeEvent) {
+  if (nativeEvent.key) {
+    // Normalize inconsistent values reported by browsers due to
+    // implementations of a working draft specification.
+    // FireFox implements `key` but returns `MozPrintableKey` for all
+    // printable characters (normalized to `Unidentified`), ignore it.
+    const key = // $FlowFixMe[invalid-computed-prop] unable to index with a `mixed` value
+    normalizeKey[nativeEvent.key] || nativeEvent.key;
+
+    if (key !== 'Unidentified') {
+      return key;
+    }
+  } // Browser does not implement `key`, polyfill as much of it as we can.
+
+
+  if (nativeEvent.type === 'keypress') {
+    const charCode = getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
+    nativeEvent); // The enter-key is technically both printable and non-printable and can
+    // thus be captured by `keypress`, no other non-printable key should.
+
+    return charCode === 13 ? 'Enter' : String.fromCharCode(charCode);
+  }
+
+  if (nativeEvent.type === 'keydown' || nativeEvent.type === 'keyup') {
+    // While user keyboard layout determines the actual meaning of each
+    // `keyCode` value, almost all function keys have a universal value.
+    // $FlowFixMe[invalid-computed-prop] unable to index with a `mixed` value
+    return translateToKey[nativeEvent.keyCode] || 'Unidentified';
+  }
+
+  return '';
+}
+/**
+ * Translation from modifier key to the associated property in the event.
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers
+ */
+
+
+const modifierKeyToProp = {
+  Alt: 'altKey',
+  Control: 'ctrlKey',
+  Meta: 'metaKey',
+  Shift: 'shiftKey'
+}; // Older browsers (Safari <= 10, iOS Safari <= 10.2) do not support
+// getModifierState. If getModifierState is not supported, we map it to a set of
+// modifier keys exposed by the event. In this case, Lock-keys are not supported.
+// $FlowFixMe[missing-local-annot]
+// $FlowFixMe[missing-this-annot]
+
+function modifierStateGetter(keyArg) {
+  const syntheticEvent = this;
+  const nativeEvent = syntheticEvent.nativeEvent;
+
+  if (nativeEvent.getModifierState) {
+    return nativeEvent.getModifierState(keyArg);
+  }
+
+  const keyProp = modifierKeyToProp[keyArg];
+  return keyProp ? !!nativeEvent[keyProp] : false;
+}
+
+function getEventModifierState(nativeEvent) {
+  return modifierStateGetter;
+}
+/**
+ * @interface KeyboardEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+
+const KeyboardEventInterface = assign({}, UIEventInterface, {
+  key: getEventKey,
+  code: 0,
+  location: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  altKey: 0,
+  metaKey: 0,
+  repeat: 0,
+  locale: 0,
+  getModifierState: getEventModifierState,
+  // Legacy Interface
+  charCode: function (event) {
+    // `charCode` is the result of a KeyPress event and represents the value of
+    // the actual printable character.
+    // KeyPress is deprecated, but its replacement is not yet final and not
+    // implemented in any major browser. Only KeyPress has charCode.
+    if (event.type === 'keypress') {
+      return getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
+      event);
+    }
+
+    return 0;
+  },
+  keyCode: function (event) {
+    // `keyCode` is the result of a KeyDown/Up event and represents the value of
+    // physical keyboard key.
+    // The actual meaning of the value depends on the users' keyboard layout
+    // which cannot be detected. Assuming that it is a US keyboard layout
+    // provides a surprisingly accurate mapping for US and European users.
+    // Due to this, it is left to the user to implement at this time.
+    if (event.type === 'keydown' || event.type === 'keyup') {
+      return event.keyCode;
+    }
+
+    return 0;
+  },
+  which: function (event) {
+    // `which` is an alias for either `keyCode` or `charCode` depending on the
+    // type of the event.
+    if (event.type === 'keypress') {
+      return getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
+      event);
+    }
+
+    if (event.type === 'keydown' || event.type === 'keyup') {
+      return event.keyCode;
+    }
+
+    return 0;
+  }
+});
+
+createSyntheticEvent(KeyboardEventInterface);
+/**
+ * @interface PointerEvent
+ * @see http://www.w3.org/TR/pointerevents/
+ */
+
+const PointerEventInterface = assign({}, MouseEventInterface, {
+  pointerId: 0,
+  width: 0,
+  height: 0,
+  pressure: 0,
+  tangentialPressure: 0,
+  tiltX: 0,
+  tiltY: 0,
+  twist: 0,
+  pointerType: 0,
+  isPrimary: 0
+});
+
+createSyntheticEvent(PointerEventInterface);
+/**
+ * @interface TouchEvent
+ * @see http://www.w3.org/TR/touch-events/
+ */
+
+const TouchEventInterface = assign({}, UIEventInterface, {
+  touches: 0,
+  targetTouches: 0,
+  changedTouches: 0,
+  altKey: 0,
+  metaKey: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  getModifierState: getEventModifierState
+});
+
+createSyntheticEvent(TouchEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent
+ */
+
+const TransitionEventInterface = assign({}, EventInterface, {
+  propertyName: 0,
+  elapsedTime: 0,
+  pseudoElement: 0
+});
+
+createSyntheticEvent(TransitionEventInterface);
+/**
+ * @interface WheelEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+const WheelEventInterface = assign({}, MouseEventInterface, {
+  deltaX(event) {
+    return 'deltaX' in event ? event.deltaX : // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).
+    'wheelDeltaX' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+    -event.wheelDeltaX : 0;
+  },
+
+  deltaY(event) {
+    return 'deltaY' in event ? event.deltaY : // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
+    'wheelDeltaY' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+    -event.wheelDeltaY : // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
+    'wheelDelta' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+    -event.wheelDelta : 0;
+  },
+
+  deltaZ: 0,
+  // Browsers without "deltaMode" is reporting in raw wheel delta where one
+  // notch on the scroll is always +/- 120, roughly equivalent to pixels.
+  // A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or
+  // ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.
+  deltaMode: 0
+});
+
+createSyntheticEvent(WheelEventInterface);
+
+/**
+ * HTML nodeType values that represent the type of the node
+ */
+const ELEMENT_NODE = 1;
+
+function invokeGuardedCallbackImpl(name, func, context) {
+  {
+    // $FlowFixMe[method-unbinding]
+    const funcArgs = Array.prototype.slice.call(arguments, 3);
+
+    try {
+      // $FlowFixMe[incompatible-call] Flow doesn't understand the arguments splicing.
+      func.apply(context, funcArgs);
+    } catch (error) {
+      this.onError(error);
+    }
+  }
+}
+
+let hasError = false;
+let caughtError = null; // Used by event system to capture/rethrow the first error.
+
+let hasRethrowError = false;
+let rethrowError = null;
+const reporter = {
+  onError(error) {
+    hasError = true;
+    caughtError = error;
+  }
+
+};
+/**
+ * Call a function while guarding against errors that happens within it.
+ * Returns an error if it throws, otherwise null.
+ *
+ * In production, this is implemented using a try-catch. The reason we don't
+ * use a try-catch directly is so that we can swap out a different
+ * implementation in DEV mode.
+ *
+ * @param {String} name of the guard to use for logging or debugging
+ * @param {Function} func The function to invoke
+ * @param {*} context The context to use when calling the function
+ * @param {...*} args Arguments for function
+ */
+
+function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+  hasError = false;
+  caughtError = null;
+  invokeGuardedCallbackImpl.apply(reporter, arguments);
+}
+/**
+ * Same as invokeGuardedCallback, but instead of returning an error, it stores
+ * it in a global so it can be rethrown by `rethrowCaughtError` later.
+ * TODO: See if caughtError and rethrowError can be unified.
+ *
+ * @param {String} name of the guard to use for logging or debugging
+ * @param {Function} func The function to invoke
+ * @param {*} context The context to use when calling the function
+ * @param {...*} args Arguments for function
+ */
+
+function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
+  invokeGuardedCallback.apply(this, arguments);
+
+  if (hasError) {
+    const error = clearCaughtError();
+
+    if (!hasRethrowError) {
+      hasRethrowError = true;
+      rethrowError = error;
+    }
+  }
+}
+/**
+ * During execution of guarded functions we will capture the first error which
+ * we will rethrow to be handled by the top level error handler.
+ */
+
+function rethrowCaughtError() {
+  if (hasRethrowError) {
+    const error = rethrowError;
+    hasRethrowError = false;
+    rethrowError = null;
+    throw error;
+  }
+}
+function clearCaughtError() {
+  if (hasError) {
+    const error = caughtError;
+    hasError = false;
+    caughtError = null;
+    return error;
+  } else {
+    throw new Error('clearCaughtError was called but no error was captured. This error ' + 'is likely caused by a bug in React. Please file an issue.');
+  }
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const SecretInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+const EventInternals = SecretInternals.Events;
+const getInstanceFromNode = EventInternals[0];
+const getNodeFromInstance = EventInternals[1];
+const getFiberCurrentPropsFromNode = EventInternals[2];
+const enqueueStateRestore = EventInternals[3];
+const restoreStateIfNeeded = EventInternals[4];
+const act = React.unstable_act;
+
+function Event(suffix) {}
+/**
+ * @class ReactTestUtils
+ */
+
+function findAllInRenderedFiberTreeInternal(fiber, test) {
+  if (!fiber) {
+    return [];
+  }
+
+  const currentParent = findCurrentFiberUsingSlowPath(fiber);
+
+  if (!currentParent) {
+    return [];
+  }
+
+  let node = currentParent;
+  const ret = [];
+
+  while (true) {
+    if (node.tag === HostComponent || node.tag === HostText || node.tag === ClassComponent || node.tag === FunctionComponent || (node.tag === HostHoistable ) || (node.tag === HostSingleton )) {
+      const publicInst = node.stateNode;
+
+      if (test(publicInst)) {
+        ret.push(publicInst);
+      }
+    }
+
+    if (node.child) {
+      node.child.return = node;
+      node = node.child;
+      continue;
+    }
+
+    if (node === currentParent) {
+      return ret;
+    }
+
+    while (!node.sibling) {
+      if (!node.return || node.return === currentParent) {
+        return ret;
+      }
+
+      node = node.return;
+    }
+
+    node.sibling.return = node.return;
+    node = node.sibling;
+  }
+}
+
+function validateClassInstance(inst, methodName) {
+  if (!inst) {
+    // This is probably too relaxed but it's existing behavior.
+    return;
+  }
+
+  if (get(inst)) {
+    // This is a public instance indeed.
+    return;
+  }
+
+  let received;
+  const stringified = String(inst);
+
+  if (isArray(inst)) {
+    received = 'an array';
+  } else if (inst && inst.nodeType === ELEMENT_NODE && inst.tagName) {
+    received = 'a DOM node';
+  } else if (stringified === '[object Object]') {
+    received = 'object with keys {' + Object.keys(inst).join(', ') + '}';
+  } else {
+    received = stringified;
+  }
+
+  throw new Error(methodName + "(...): the first argument must be a React class instance. " + ("Instead received: " + received + "."));
+}
+/**
+ * Utilities for making it easy to test React components.
+ *
+ * See https://reactjs.org/docs/test-utils.html
+ *
+ * Todo: Support the entire DOM.scry query syntax. For now, these simple
+ * utilities will suffice for testing purposes.
+ * @lends ReactTestUtils
+ */
+
+
+function renderIntoDocument(element) {
+  const div = document.createElement('div'); // None of our tests actually require attaching the container to the
+  // DOM, and doing so creates a mess that we rely on test isolation to
+  // clean up, so we're going to stop honoring the name of this method
+  // (and probably rename it eventually) if no problems arise.
+  // document.documentElement.appendChild(div);
+
+  return ReactDOM.render(element, div);
+}
+
+function isElement(element) {
+  return React.isValidElement(element);
+}
+
+function isElementOfType(inst, convenienceConstructor) {
+  return React.isValidElement(inst) && inst.type === convenienceConstructor;
+}
+
+function isDOMComponent(inst) {
+  return !!(inst && inst.nodeType === ELEMENT_NODE && inst.tagName);
+}
+
+function isDOMComponentElement(inst) {
+  return !!(inst && React.isValidElement(inst) && !!inst.tagName);
+}
+
+function isCompositeComponent(inst) {
+  if (isDOMComponent(inst)) {
+    // Accessing inst.setState warns; just return false as that'll be what
+    // this returns when we have DOM nodes as refs directly
+    return false;
+  }
+
+  return inst != null && typeof inst.render === 'function' && typeof inst.setState === 'function';
+}
+
+function isCompositeComponentWithType(inst, type) {
+  if (!isCompositeComponent(inst)) {
+    return false;
+  }
+
+  const internalInstance = get(inst);
+  const constructor = internalInstance.type;
+  return constructor === type;
+}
+
+function findAllInRenderedTree(inst, test) {
+  validateClassInstance(inst, 'findAllInRenderedTree');
+
+  if (!inst) {
+    return [];
+  }
+
+  const internalInstance = get(inst);
+  return findAllInRenderedFiberTreeInternal(internalInstance, test);
+}
+/**
+ * Finds all instances of components in the rendered tree that are DOM
+ * components with the class name matching `className`.
+ * @return {array} an array of all the matches.
+ */
+
+
+function scryRenderedDOMComponentsWithClass(root, classNames) {
+  validateClassInstance(root, 'scryRenderedDOMComponentsWithClass');
+  return findAllInRenderedTree(root, function (inst) {
+    if (isDOMComponent(inst)) {
+      let className = inst.className;
+
+      if (typeof className !== 'string') {
+        // SVG, probably.
+        className = inst.getAttribute('class') || '';
+      }
+
+      const classList = className.split(/\s+/);
+
+      if (!isArray(classNames)) {
+        if (classNames === undefined) {
+          throw new Error('TestUtils.scryRenderedDOMComponentsWithClass expects a ' + 'className as a second argument.');
+        }
+
+        classNames = classNames.split(/\s+/);
+      }
+
+      return classNames.every(function (name) {
+        return classList.indexOf(name) !== -1;
+      });
+    }
+
+    return false;
+  });
+}
+/**
+ * Like scryRenderedDOMComponentsWithClass but expects there to be one result,
+ * and returns that one result, or throws exception if there is any other
+ * number of matches besides one.
+ * @return {!ReactDOMComponent} The one match.
+ */
+
+
+function findRenderedDOMComponentWithClass(root, className) {
+  validateClassInstance(root, 'findRenderedDOMComponentWithClass');
+  const all = scryRenderedDOMComponentsWithClass(root, className);
+
+  if (all.length !== 1) {
+    throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for class:' + className);
+  }
+
+  return all[0];
+}
+/**
+ * Finds all instances of components in the rendered tree that are DOM
+ * components with the tag name matching `tagName`.
+ * @return {array} an array of all the matches.
+ */
+
+
+function scryRenderedDOMComponentsWithTag(root, tagName) {
+  validateClassInstance(root, 'scryRenderedDOMComponentsWithTag');
+  return findAllInRenderedTree(root, function (inst) {
+    return isDOMComponent(inst) && inst.tagName.toUpperCase() === tagName.toUpperCase();
+  });
+}
+/**
+ * Like scryRenderedDOMComponentsWithTag but expects there to be one result,
+ * and returns that one result, or throws exception if there is any other
+ * number of matches besides one.
+ * @return {!ReactDOMComponent} The one match.
+ */
+
+
+function findRenderedDOMComponentWithTag(root, tagName) {
+  validateClassInstance(root, 'findRenderedDOMComponentWithTag');
+  const all = scryRenderedDOMComponentsWithTag(root, tagName);
+
+  if (all.length !== 1) {
+    throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for tag:' + tagName);
+  }
+
+  return all[0];
+}
+/**
+ * Finds all instances of components with type equal to `componentType`.
+ * @return {array} an array of all the matches.
+ */
+
+
+function scryRenderedComponentsWithType(root, componentType) {
+  validateClassInstance(root, 'scryRenderedComponentsWithType');
+  return findAllInRenderedTree(root, function (inst) {
+    return isCompositeComponentWithType(inst, componentType);
+  });
+}
+/**
+ * Same as `scryRenderedComponentsWithType` but expects there to be one result
+ * and returns that one result, or throws exception if there is any other
+ * number of matches besides one.
+ * @return {!ReactComponent} The one match.
+ */
+
+
+function findRenderedComponentWithType(root, componentType) {
+  validateClassInstance(root, 'findRenderedComponentWithType');
+  const all = scryRenderedComponentsWithType(root, componentType);
+
+  if (all.length !== 1) {
+    throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for componentType:' + componentType);
+  }
+
+  return all[0];
+}
+/**
+ * Pass a mocked component module to this method to augment it with
+ * useful methods that allow it to be used as a dummy React component.
+ * Instead of rendering as usual, the component will become a simple
+ * <div> containing any provided children.
+ *
+ * @param {object} module the mock function object exported from a
+ *                        module that defines the component to be mocked
+ * @param {?string} mockTagName optional dummy root tag name to return
+ *                              from render method (overrides
+ *                              module.mockTagName if provided)
+ * @return {object} the ReactTestUtils object (for chaining)
+ */
+
+
+function mockComponent(module, mockTagName) {
+
+  mockTagName = mockTagName || module.mockTagName || 'div';
+  module.prototype.render.mockImplementation(function () {
+    return React.createElement(mockTagName, null, this.props.children);
+  });
+  return this;
+}
+
+function nativeTouchData(x, y) {
+  return {
+    touches: [{
+      pageX: x,
+      pageY: y
+    }]
+  };
+} // Start of inline: the below functions were inlined from
+// EventPropagator.js, as they deviated from ReactDOM's newer
+// implementations.
+
+/**
+ * Dispatch the event to the listener.
+ * @param {SyntheticEvent} event SyntheticEvent to handle
+ * @param {function} listener Application-level callback
+ * @param {*} inst Internal component instance
+ */
+
+
+function executeDispatch(event, listener, inst) {
+  const type = event.type || 'unknown-event';
+  event.currentTarget = getNodeFromInstance(inst);
+  invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
+  event.currentTarget = null;
+}
+/**
+ * Standard/simple iteration through an event's collected dispatches.
+ */
+
+
+function executeDispatchesInOrder(event) {
+  const dispatchListeners = event._dispatchListeners;
+  const dispatchInstances = event._dispatchInstances;
+
+  if (isArray(dispatchListeners)) {
+    for (let i = 0; i < dispatchListeners.length; i++) {
+      if (event.isPropagationStopped()) {
+        break;
+      } // Listeners and Instances are two parallel arrays that are always in sync.
+
+
+      executeDispatch(event, dispatchListeners[i], dispatchInstances[i]);
+    }
+  } else if (dispatchListeners) {
+    executeDispatch(event, dispatchListeners, dispatchInstances);
+  }
+
+  event._dispatchListeners = null;
+  event._dispatchInstances = null;
+}
+/**
+ * Dispatches an event and releases it back into the pool, unless persistent.
+ *
+ * @param {?object} event Synthetic event to be dispatched.
+ * @private
+ */
+
+
+function executeDispatchesAndRelease(event
+/* ReactSyntheticEvent */
+) {
+  if (event) {
+    executeDispatchesInOrder(event);
+
+    if (!event.isPersistent()) {
+      event.constructor.release(event);
+    }
+  }
+}
+
+function isInteractive(tag) {
+  return tag === 'button' || tag === 'input' || tag === 'select' || tag === 'textarea';
+}
+
+function getParent(inst) {
+  do {
+    inst = inst.return; // TODO: If this is a HostRoot we might want to bail out.
+    // That is depending on if we want nested subtrees (layers) to bubble
+    // events to their parent. We could also go through parentNode on the
+    // host node but that wouldn't work for React Native and doesn't let us
+    // do the portal feature.
+  } while (inst && inst.tag !== HostComponent && (inst.tag !== HostSingleton));
+
+  if (inst) {
+    return inst;
+  }
+
+  return null;
+}
+/**
+ * Simulates the traversal of a two-phase, capture/bubble event dispatch.
+ */
+
+
+function traverseTwoPhase(inst, fn, arg) {
+  const path = [];
+
+  while (inst) {
+    path.push(inst);
+    inst = getParent(inst);
+  }
+
+  let i;
+
+  for (i = path.length; i-- > 0;) {
+    fn(path[i], 'captured', arg);
+  }
+
+  for (i = 0; i < path.length; i++) {
+    fn(path[i], 'bubbled', arg);
+  }
+}
+
+function shouldPreventMouseEvent(name, type, props) {
+  switch (name) {
+    case 'onClick':
+    case 'onClickCapture':
+    case 'onDoubleClick':
+    case 'onDoubleClickCapture':
+    case 'onMouseDown':
+    case 'onMouseDownCapture':
+    case 'onMouseMove':
+    case 'onMouseMoveCapture':
+    case 'onMouseUp':
+    case 'onMouseUpCapture':
+    case 'onMouseEnter':
+      return !!(props.disabled && isInteractive(type));
+
+    default:
+      return false;
+  }
+}
+/**
+ * @param {object} inst The instance, which is the source of events.
+ * @param {string} registrationName Name of listener (e.g. `onClick`).
+ * @return {?function} The stored callback.
+ */
+
+
+function getListener(inst
+/* Fiber */
+, registrationName) {
+  // TODO: shouldPreventMouseEvent is DOM-specific and definitely should not
+  // live here; needs to be moved to a better place soon
+  const stateNode = inst.stateNode;
+
+  if (!stateNode) {
+    // Work in progress (ex: onload events in incremental mode).
+    return null;
+  }
+
+  const props = getFiberCurrentPropsFromNode(stateNode);
+
+  if (!props) {
+    // Work in progress.
+    return null;
+  }
+
+  const listener = props[registrationName];
+
+  if (shouldPreventMouseEvent(registrationName, inst.type, props)) {
+    return null;
+  }
+
+  if (listener && typeof listener !== 'function') {
+    throw new Error("Expected `" + registrationName + "` listener to be a function, instead got a value of `" + typeof listener + "` type.");
+  }
+
+  return listener;
+}
+
+function listenerAtPhase(inst, event, propagationPhase) {
+  let registrationName = event._reactName;
+
+  if (propagationPhase === 'captured') {
+    registrationName += 'Capture';
+  }
+
+  return getListener(inst, registrationName);
+}
+
+function accumulateDispatches(inst, ignoredDirection, event) {
+  if (inst && event && event._reactName) {
+    const registrationName = event._reactName;
+    const listener = getListener(inst, registrationName);
+
+    if (listener) {
+      if (event._dispatchListeners == null) {
+        event._dispatchListeners = [];
+      }
+
+      if (event._dispatchInstances == null) {
+        event._dispatchInstances = [];
+      }
+
+      event._dispatchListeners.push(listener);
+
+      event._dispatchInstances.push(inst);
+    }
+  }
+}
+
+function accumulateDirectionalDispatches(inst, phase, event) {
+
+  const listener = listenerAtPhase(inst, event, phase);
+
+  if (listener) {
+    if (event._dispatchListeners == null) {
+      event._dispatchListeners = [];
+    }
+
+    if (event._dispatchInstances == null) {
+      event._dispatchInstances = [];
+    }
+
+    event._dispatchListeners.push(listener);
+
+    event._dispatchInstances.push(inst);
+  }
+}
+
+function accumulateDirectDispatchesSingle(event) {
+  if (event && event._reactName) {
+    accumulateDispatches(event._targetInst, null, event);
+  }
+}
+
+function accumulateTwoPhaseDispatchesSingle(event) {
+  if (event && event._reactName) {
+    traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
+  }
+} // End of inline
+
+
+const Simulate = {};
+const directDispatchEventTypes = new Set(['mouseEnter', 'mouseLeave', 'pointerEnter', 'pointerLeave']);
+/**
+ * Exports:
+ *
+ * - `Simulate.click(Element)`
+ * - `Simulate.mouseMove(Element)`
+ * - `Simulate.change(Element)`
+ * - ... (All keys from event plugin `eventTypes` objects)
+ */
+
+function makeSimulator(eventType) {
+  return function (domNode, eventData) {
+    if (React.isValidElement(domNode)) {
+      throw new Error('TestUtils.Simulate expected a DOM node as the first argument but received ' + 'a React element. Pass the DOM node you wish to simulate the event on instead. ' + 'Note that TestUtils.Simulate will not work if you are using shallow rendering.');
+    }
+
+    if (isCompositeComponent(domNode)) {
+      throw new Error('TestUtils.Simulate expected a DOM node as the first argument but received ' + 'a component instance. Pass the DOM node you wish to simulate the event on instead.');
+    }
+
+    const reactName = 'on' + eventType[0].toUpperCase() + eventType.slice(1);
+    const fakeNativeEvent = new Event();
+    fakeNativeEvent.target = domNode;
+    fakeNativeEvent.type = eventType.toLowerCase();
+    const targetInst = getInstanceFromNode(domNode);
+    const event = new SyntheticEvent(reactName, fakeNativeEvent.type, targetInst, fakeNativeEvent, domNode); // Since we aren't using pooling, always persist the event. This will make
+    // sure it's marked and won't warn when setting additional properties.
+
+    event.persist();
+    assign(event, eventData);
+
+    if (directDispatchEventTypes.has(eventType)) {
+      accumulateDirectDispatchesSingle(event);
+    } else {
+      accumulateTwoPhaseDispatchesSingle(event);
+    }
+
+    ReactDOM.unstable_batchedUpdates(function () {
+      // Normally extractEvent enqueues a state restore, but we'll just always
+      // do that since we're by-passing it here.
+      enqueueStateRestore(domNode);
+      executeDispatchesAndRelease(event);
+      rethrowCaughtError();
+    });
+    restoreStateIfNeeded();
+  };
+} // A one-time snapshot with no plans to update. We'll probably want to deprecate Simulate API.
+
+
+const simulatedEventTypes = ['blur', 'cancel', 'click', 'close', 'contextMenu', 'copy', 'cut', 'auxClick', 'doubleClick', 'dragEnd', 'dragStart', 'drop', 'focus', 'input', 'invalid', 'keyDown', 'keyPress', 'keyUp', 'mouseDown', 'mouseUp', 'paste', 'pause', 'play', 'pointerCancel', 'pointerDown', 'pointerUp', 'rateChange', 'reset', 'resize', 'seeked', 'submit', 'touchCancel', 'touchEnd', 'touchStart', 'volumeChange', 'drag', 'dragEnter', 'dragExit', 'dragLeave', 'dragOver', 'mouseMove', 'mouseOut', 'mouseOver', 'pointerMove', 'pointerOut', 'pointerOver', 'scroll', 'toggle', 'touchMove', 'wheel', 'abort', 'animationEnd', 'animationIteration', 'animationStart', 'canPlay', 'canPlayThrough', 'durationChange', 'emptied', 'encrypted', 'ended', 'error', 'gotPointerCapture', 'load', 'loadedData', 'loadedMetadata', 'loadStart', 'lostPointerCapture', 'playing', 'progress', 'seeking', 'stalled', 'suspend', 'timeUpdate', 'transitionEnd', 'waiting', 'mouseEnter', 'mouseLeave', 'pointerEnter', 'pointerLeave', 'change', 'select', 'beforeInput', 'compositionEnd', 'compositionStart', 'compositionUpdate'];
+
+function buildSimulators() {
+  simulatedEventTypes.forEach(eventType => {
+    Simulate[eventType] = makeSimulator(eventType);
+  });
+}
+
+buildSimulators();
+
+exports.Simulate = Simulate;
+exports.act = act;
+exports.findAllInRenderedTree = findAllInRenderedTree;
+exports.findRenderedComponentWithType = findRenderedComponentWithType;
+exports.findRenderedDOMComponentWithClass = findRenderedDOMComponentWithClass;
+exports.findRenderedDOMComponentWithTag = findRenderedDOMComponentWithTag;
+exports.isCompositeComponent = isCompositeComponent;
+exports.isCompositeComponentWithType = isCompositeComponentWithType;
+exports.isDOMComponent = isDOMComponent;
+exports.isDOMComponentElement = isDOMComponentElement;
+exports.isElement = isElement;
+exports.isElementOfType = isElementOfType;
+exports.mockComponent = mockComponent;
+exports.nativeTouchData = nativeTouchData;
+exports.renderIntoDocument = renderIntoDocument;
+exports.scryRenderedComponentsWithType = scryRenderedComponentsWithType;
+exports.scryRenderedDOMComponentsWithClass = scryRenderedDOMComponentsWithClass;
+exports.scryRenderedDOMComponentsWithTag = scryRenderedDOMComponentsWithTag;
+exports.traverseTwoPhase = traverseTwoPhase;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-unstable_testing.development.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-unstable_testing.development.js
index 2a152c997812d..17868b6638f11 100644
--- a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-unstable_testing.development.js
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-unstable_testing.development.js
@@ -2826,6 +2826,18 @@ var componentFrameCache;
   var PossiblyWeakMap$1 = typeof WeakMap === 'function' ? WeakMap : Map;
   componentFrameCache = new PossiblyWeakMap$1();
 }
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
@@ -2841,7 +2853,6 @@ function describeNativeComponentFrame(fn, construct) {
     }
   }
 
-  var control;
   reentry = true;
   var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
 
@@ -2855,81 +2866,140 @@ function describeNativeComponentFrame(fn, construct) {
     ReactCurrentDispatcher$2.current = null;
     disableLogs();
   }
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
 
-  try {
-    // This should throw.
-    if (construct) {
-      // Something should be setting the props in the constructor.
-      var Fake = function () {
-        throw Error();
-      }; // $FlowFixMe[prop-missing]
 
+  var RunInRootFrame = {
+    DetermineComponentFrameRoot: function () {
+      var control;
 
-      Object.defineProperty(Fake.prototype, 'props', {
-        set: function () {
-          // We use a throwing setter instead of frozen or non-writable props
-          // because that won't throw in a non-strict mode function.
-          throw Error();
-        }
-      });
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          var Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
 
-      if (typeof Reflect === 'object' && Reflect.construct) {
-        // We construct a different control for this case to include any extra
-        // frames added by the construct call.
-        try {
-          Reflect.construct(Fake, []);
-        } catch (x) {
-          control = x;
-        }
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
 
-        Reflect.construct(fn, [], Fake);
-      } else {
-        try {
-          Fake.call();
-        } catch (x) {
-          control = x;
-        } // $FlowFixMe[prop-missing] found when upgrading Flow
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
 
 
-        fn.call(Fake.prototype);
-      }
-    } else {
-      try {
-        throw Error();
-      } catch (x) {
-        control = x;
-      } // TODO(luna): This will currently only throw if the function component
-      // tries to access React/ReactDOM/props. We should probably make this throw
-      // in simple components too
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
 
 
-      var maybePromise = fn(); // If the function component returns a promise, it's likely an async
-      // component, which we don't yet support. Attach a noop catch handler to
-      // silence the error.
-      // TODO: Implement component stacks for async client components?
+          var maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
 
-      if (maybePromise && typeof maybePromise.catch === 'function') {
-        maybePromise.catch(function () {});
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(function () {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
       }
+
+      return [null, null];
     }
-  } catch (sample) {
-    // This is inlined manually because closure doesn't do it for us.
-    if (sample && control && typeof sample.stack === 'string') {
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
+
+  try {
+    var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
+
+    if (sampleStack && controlStack) {
       // This extracts the first frame from the sample that isn't also in the control.
       // Skipping one frame that we assume is the frame that calls the two.
-      var sampleLines = sample.stack.split('\n');
-      var controlLines = control.stack.split('\n');
-      var s = sampleLines.length - 1;
-      var c = controlLines.length - 1;
+      var sampleLines = sampleStack.split('\n');
+      var controlLines = controlStack.split('\n');
+      var s = 0;
+      var c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
 
-      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
-        // We expect at least one stack frame to be shared.
-        // Typically this will be the root most one. However, stack frames may be
-        // cut off due to maximum stack limits. In this case, one maybe cut off
-        // earlier than the other. We assume that the sample is longer or the same
-        // and there for cut off earlier. So we should find the root most frame in
-        // the sample somewhere in the control.
-        c--;
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
       }
 
       for (; s >= 1 && c >= 0; s--, c--) {
@@ -2958,7 +3028,7 @@ function describeNativeComponentFrame(fn, construct) {
                   _frame = _frame.replace('<anonymous>', fn.displayName);
                 }
 
-                {
+                if (true) {
                   if (typeof fn === 'function') {
                     componentFrameCache.set(fn, _frame);
                   }
@@ -28840,7 +28910,7 @@ identifierPrefix, onRecoverableError, transitionCallbacks, formState) {
   return root;
 }
 
-var ReactVersion = '18.3.0-experimental-2983249dd-20231107';
+var ReactVersion = '18.3.0-experimental-7508dcd5c-20231108';
 
 function createPortal$1(children, containerInfo, // TODO: figure out the API for cross-renderer implementation.
 implementation) {
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-unstable_testing.production.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-unstable_testing.production.js
new file mode 100644
index 0000000000000..92a8b6e74eef8
--- /dev/null
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-unstable_testing.production.js
@@ -0,0 +1,28514 @@
+/**
+ * @license React
+ * react-dom-unstable_testing.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require("next/dist/compiled/react-experimental");
+var Scheduler = require("next/dist/compiled/scheduler-experimental");
+
+const Internals = {
+  usingClientEntryPoint: false,
+  Events: null,
+  Dispatcher: {
+    current: null
+  }
+};
+
+// Do not require this module directly! Use normal `invariant` calls with
+// template literal strings. The messages will be replaced with error codes
+// during build.
+function formatProdErrorMessage(code) {
+  let url = 'https://reactjs.org/docs/error-decoder.html?invariant=' + code;
+
+  for (let i = 1; i < arguments.length; i++) {
+    url += '&args[]=' + encodeURIComponent(arguments[i]);
+  }
+
+  return "Minified React error #" + code + "; visit " + url + " for the full message or " + 'use the non-minified dev environment for full errors and additional ' + 'helpful warnings.';
+}
+
+const assign = Object.assign;
+
+// -----------------------------------------------------------------------------
+// Killswitch
+//
+// Flags that exist solely to turn off a change in case it causes a regression
+// when it rolls out to prod. We should remove these as soon as possible.
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+// Land or remove (moderate effort)
+//
+// Flags that can be probably deleted or landed, but might require extra effort
+// like migrating internal callers or performance testing.
+// -----------------------------------------------------------------------------
+// TODO: Finish rolling out in www
+
+const enableClientRenderFallbackOnTextMismatch = true;
+const enableFormActions = true;
+const enableAsyncActions = true; // Not sure if www still uses this. We don't have a replacement but whatever we
+// Slated for removal in the future (significant effort)
+//
+// These are experiments that didn't work out, and never shipped, but we can't
+// delete from the codebase until we migrate internal callers.
+// -----------------------------------------------------------------------------
+// Add a callback property to suspense to notify which promises are currently
+// in the update queue. This allows reporting and tracing of what is causing
+// the user to see a loading state.
+//
+// Also allows hydration callbacks to fire when a dehydrated boundary gets
+// hydrated or deleted.
+//
+// This will eventually be replaced by the Transition Tracing proposal.
+
+const enableSuspenseCallback = false; // Experimental Scope support.
+
+const enableLazyContextPropagation = false; // FB-only usage. The new API has different semantics.
+
+const enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber
+const enableHostSingletons = true;
+const alwaysThrottleRetries = true;
+// Chopping Block
+//
+// Planned feature deprecations and breaking changes. Sorted roughly in order of
+// when we plan to enable them.
+// -----------------------------------------------------------------------------
+// This flag enables Strict Effects by default. We're not turning this on until
+// after 18 because it requires migration work. Recommendation is to use
+// <StrictMode /> to gradually upgrade components.
+// If TRUE, trees rendered with createRoot will be StrictEffectsMode.
+// If FALSE, these trees will be StrictLegacyMode.
+
+const createRootStrictEffectsByDefault = false;
+// React DOM Chopping Block
+//
+// Similar to main Chopping Block but only flags related to React DOM. These are
+// grouped because we will likely batch all of them into a single major release.
+// -----------------------------------------------------------------------------
+// Disable support for comment nodes as React DOM containers. Already disabled
+// in open source, but www codebase still relies on it. Need to remove.
+
+const disableCommentsAsDOMContainers = true; // Disable javascript: URL strings in href for XSS protection.
+// Debugging and DevTools
+// -----------------------------------------------------------------------------
+// Adds user timing marks for e.g. state updates, suspense, and work loop stuff,
+// for an experimental timeline tool.
+
+const enableSchedulingProfiler = false; // Helps identify side effects in render-phase lifecycle hooks and setState
+
+const enableProfilerTimer = false; // Record durations for commit and passive effects phases.
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactCurrentDispatcher$2 = ReactSharedInternals.ReactCurrentDispatcher; // Since the "not pending" value is always the same, we can reuse the
+// same object across all transitions.
+
+const sharedNotPendingObject = {
+  pending: false,
+  data: null,
+  method: null,
+  action: null
+};
+const NotPending = sharedNotPendingObject;
+
+function resolveDispatcher() {
+  // Copied from react/src/ReactHooks.js. It's the same thing but in a
+  // different package.
+  const dispatcher = ReactCurrentDispatcher$2.current;
+  // intentionally don't throw our own error because this is in a hot path.
+  // Also helps ensure this is inlined.
+
+
+  return dispatcher;
+}
+
+function useFormStatus() {
+  {
+    const dispatcher = resolveDispatcher(); // $FlowFixMe[not-a-function] We know this exists because of the feature check above.
+
+    return dispatcher.useHostTransitionStatus();
+  }
+}
+function useFormState(action, initialState, permalink) {
+  {
+    const dispatcher = resolveDispatcher(); // $FlowFixMe[not-a-function] This is unstable, thus optional
+
+    return dispatcher.useFormState(action, initialState, permalink);
+  }
+}
+
+const valueStack = [];
+
+let index = -1;
+
+function createCursor(defaultValue) {
+  return {
+    current: defaultValue
+  };
+}
+
+function pop(cursor, fiber) {
+  if (index < 0) {
+
+    return;
+  }
+
+  cursor.current = valueStack[index];
+  valueStack[index] = null;
+
+  index--;
+}
+
+function push(cursor, value, fiber) {
+  index++;
+  valueStack[index] = cursor.current;
+
+  cursor.current = value;
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+const REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_CONTEXT_TYPE = Symbol.for('react.context');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SCOPE_TYPE = Symbol.for('react.scope');
+const REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');
+const REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+const REACT_LEGACY_HIDDEN_TYPE = Symbol.for('react.legacy_hidden');
+const REACT_CACHE_TYPE = Symbol.for('react.cache');
+const REACT_TRACING_MARKER_TYPE = Symbol.for('react.tracing_marker');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+const contextStackCursor$1 = createCursor(null);
+const contextFiberStackCursor = createCursor(null);
+const rootInstanceStackCursor = createCursor(null); // Represents the nearest host transition provider (in React DOM, a <form />)
+// NOTE: Since forms cannot be nested, and this feature is only implemented by
+// React DOM, we don't technically need this to be a stack. It could be a single
+// module variable instead.
+
+const hostTransitionProviderCursor = createCursor(null); // TODO: This should initialize to NotPendingTransition, a constant
+// imported from the fiber config. However, because of a cycle in the module
+// graph, that value isn't defined during this module's initialization. I can't
+// think of a way to work around this without moving that value out of the
+// fiber config. For now, the "no provider" case is handled when reading,
+// inside useHostTransitionStatus.
+
+const HostTransitionContext = {
+  $$typeof: REACT_CONTEXT_TYPE,
+  _currentValue: null,
+  _currentValue2: null,
+  _threadCount: 0,
+  Provider: null,
+  Consumer: null,
+  _defaultValue: null,
+  _globalName: null
+};
+
+function requiredContext(c) {
+
+  return c;
+}
+
+function getCurrentRootHostContainer() {
+  return rootInstanceStackCursor.current;
+}
+
+function getRootHostContainer() {
+  const rootInstance = requiredContext(rootInstanceStackCursor.current);
+  return rootInstance;
+}
+
+function pushHostContainer(fiber, nextRootInstance) {
+  // Push current root instance onto the stack;
+  // This allows us to reset root when portals are popped.
+  push(rootInstanceStackCursor, nextRootInstance); // Track the context and the Fiber that provided it.
+  // This enables us to pop only Fibers that provide unique contexts.
+
+  push(contextFiberStackCursor, fiber); // Finally, we need to push the host context to the stack.
+  // However, we can't just call getRootHostContext() and push it because
+  // we'd have a different number of entries on the stack depending on
+  // whether getRootHostContext() throws somewhere in renderer code or not.
+  // So we push an empty value first. This lets us safely unwind on errors.
+
+  push(contextStackCursor$1, null);
+  const nextRootContext = getRootHostContext(nextRootInstance); // Now that we know this function doesn't throw, replace it.
+
+  pop(contextStackCursor$1);
+  push(contextStackCursor$1, nextRootContext);
+}
+
+function popHostContainer(fiber) {
+  pop(contextStackCursor$1);
+  pop(contextFiberStackCursor);
+  pop(rootInstanceStackCursor);
+}
+
+function getHostContext() {
+  const context = requiredContext(contextStackCursor$1.current);
+  return context;
+}
+
+function pushHostContext(fiber) {
+  {
+    const stateHook = fiber.memoizedState;
+
+    if (stateHook !== null) {
+      // Only provide context if this fiber has been upgraded by a host
+      // transition. We use the same optimization for regular host context below.
+      push(hostTransitionProviderCursor, fiber);
+    }
+  }
+
+  const context = requiredContext(contextStackCursor$1.current);
+  const nextContext = getChildHostContext(context, fiber.type); // Don't push this Fiber's context unless it's unique.
+
+  if (context !== nextContext) {
+    // Track the context and the Fiber that provided it.
+    // This enables us to pop only Fibers that provide unique contexts.
+    push(contextFiberStackCursor, fiber);
+    push(contextStackCursor$1, nextContext);
+  }
+}
+
+function popHostContext(fiber) {
+  if (contextFiberStackCursor.current === fiber) {
+    // Do not pop unless this Fiber provided the current context.
+    // pushHostContext() only pushes Fibers that provide unique contexts.
+    pop(contextStackCursor$1);
+    pop(contextFiberStackCursor);
+  }
+
+  {
+    if (hostTransitionProviderCursor.current === fiber) {
+      // Do not pop unless this Fiber provided the current context. This is mostly
+      // a performance optimization, but conveniently it also prevents a potential
+      // data race where a host provider is upgraded (i.e. memoizedState becomes
+      // non-null) during a concurrent event. This is a bit of a flaw in the way
+      // we upgrade host components, but because we're accounting for it here, it
+      // should be fine.
+      pop(hostTransitionProviderCursor); // When popping the transition provider, we reset the context value back
+      // to `null`. We can do this because you're not allowd to nest forms. If
+      // we allowed for multiple nested host transition providers, then we'd
+      // need to reset this to the parent provider's status.
+
+      {
+        HostTransitionContext._currentValue = null;
+      }
+    }
+  }
+}
+
+const NoFlags$1 =
+/*                      */
+0b0000000000000000000000000000;
+const PerformedWork =
+/*                */
+0b0000000000000000000000000001;
+const Placement =
+/*                    */
+0b0000000000000000000000000010;
+const DidCapture =
+/*                   */
+0b0000000000000000000010000000;
+const Hydrating =
+/*                    */
+0b0000000000000001000000000000; // You can change the rest (and add more).
+
+const Update =
+/*                       */
+0b0000000000000000000000000100;
+/* Skipped value:                                 0b0000000000000000000000001000; */
+
+const ChildDeletion =
+/*                */
+0b0000000000000000000000010000;
+const ContentReset =
+/*                 */
+0b0000000000000000000000100000;
+const Callback =
+/*                     */
+0b0000000000000000000001000000;
+/* Used by DidCapture:                            0b0000000000000000000010000000; */
+
+const ForceClientRender =
+/*            */
+0b0000000000000000000100000000;
+const Ref =
+/*                          */
+0b0000000000000000001000000000;
+const Snapshot =
+/*                     */
+0b0000000000000000010000000000;
+const Passive$1 =
+/*                      */
+0b0000000000000000100000000000;
+/* Used by Hydrating:                             0b0000000000000001000000000000; */
+
+const Visibility =
+/*                   */
+0b0000000000000010000000000000;
+const StoreConsistency =
+/*             */
+0b0000000000000100000000000000; // It's OK to reuse these bits because these flags are mutually exclusive for
+// different fiber types. We should really be doing this for as many flags as
+// possible, because we're about to run out of bits.
+
+const ScheduleRetry = StoreConsistency;
+const ShouldSuspendCommit = Visibility;
+const LifecycleEffectMask = Passive$1 | Update | Callback | Ref | Snapshot | StoreConsistency; // Union of all commit flags (flags with the lifetime of a particular commit)
+
+const HostEffectMask =
+/*               */
+0b0000000000000111111111111111; // These are not really side effects, but we still reuse this field.
+
+const Incomplete =
+/*                   */
+0b0000000000001000000000000000;
+const ShouldCapture =
+/*                */
+0b0000000000010000000000000000;
+const ForceUpdateForLegacySuspense =
+/* */
+0b0000000000100000000000000000;
+const Forked =
+/*                       */
+0b0000000100000000000000000000; // Static tags describe aspects of a fiber that are not specific to a render,
+// e.g. a fiber uses a passive effect (even if there are no updates on this particular render).
+// This enables us to defer more work in the unmount case,
+// since we can defer traversing the tree during layout to look for Passive effects,
+// and instead rely on the static flag as a signal that there may be cleanup work.
+
+const RefStatic =
+/*                    */
+0b0000001000000000000000000000;
+const LayoutStatic =
+/*                 */
+0b0000010000000000000000000000;
+const PassiveStatic =
+/*                */
+0b0000100000000000000000000000;
+const MaySuspendCommit =
+/*             */
+0b0001000000000000000000000000; // Flag used to identify newly inserted fibers. It isn't reset after commit unlike `Placement`.
+
+const PlacementDEV =
+/*                 */
+0b0010000000000000000000000000;
+// don't contain effects, by checking subtreeFlags.
+
+const BeforeMutationMask = // TODO: Remove Update flag from before mutation phase by re-landing Visibility
+// flag logic (see #20043)
+Update | Snapshot | (0);
+const MutationMask = Placement | Update | ChildDeletion | ContentReset | Ref | Hydrating | Visibility;
+const LayoutMask = Update | Callback | Ref | Visibility; // TODO: Split into PassiveMountMask and PassiveUnmountMask
+
+const PassiveMask = Passive$1 | Visibility | ChildDeletion; // Union of tags that don't get reset on clones.
+// This allows certain concepts to persist without recalculating them,
+// e.g. whether a subtree contains passive effects or portals.
+
+const StaticMask = LayoutStatic | PassiveStatic | RefStatic | MaySuspendCommit;
+
+// This module only exists as an ESM wrapper around the external CommonJS
+const scheduleCallback$3 = Scheduler.unstable_scheduleCallback;
+const cancelCallback$1 = Scheduler.unstable_cancelCallback;
+const shouldYield = Scheduler.unstable_shouldYield;
+const requestPaint = Scheduler.unstable_requestPaint;
+const now = Scheduler.unstable_now;
+const getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel;
+const ImmediatePriority = Scheduler.unstable_ImmediatePriority;
+const UserBlockingPriority = Scheduler.unstable_UserBlockingPriority;
+const NormalPriority$1 = Scheduler.unstable_NormalPriority;
+const LowPriority = Scheduler.unstable_LowPriority;
+const IdlePriority = Scheduler.unstable_IdlePriority; // this doesn't actually exist on the scheduler, but it *does*
+
+let rendererID = null;
+let injectedHook = null;
+function injectInternals(internals) {
+  if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {
+    // No DevTools
+    return false;
+  }
+
+  const hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+
+  if (hook.isDisabled) {
+    // This isn't a real property on the hook, but it can be set to opt out
+    // of DevTools integration and associated warnings and logs.
+    // https://github.com/facebook/react/issues/3877
+    return true;
+  }
+
+  if (!hook.supportsFiber) {
+
+
+    return true;
+  }
+
+  try {
+    if (enableSchedulingProfiler) ;
+
+    rendererID = hook.inject(internals); // We have successfully injected, so now it is safe to set up hooks.
+
+    injectedHook = hook;
+  } catch (err) {
+  }
+
+  if (hook.checkDCE) {
+    // This is the real DevTools.
+    return true;
+  } else {
+    // This is likely a hook installed by Fast Refresh runtime.
+    return false;
+  }
+}
+function onCommitRoot(root, eventPriority) {
+  if (injectedHook && typeof injectedHook.onCommitFiberRoot === 'function') {
+    try {
+      const didError = (root.current.flags & DidCapture) === DidCapture;
+
+      if (enableProfilerTimer) ; else {
+        injectedHook.onCommitFiberRoot(rendererID, root, undefined, didError);
+      }
+    } catch (err) {
+    }
+  }
+}
+function onPostCommitRoot(root) {
+  if (injectedHook && typeof injectedHook.onPostCommitFiberRoot === 'function') {
+    try {
+      injectedHook.onPostCommitFiberRoot(rendererID, root);
+    } catch (err) {
+    }
+  }
+}
+function onCommitUnmount(fiber) {
+  if (injectedHook && typeof injectedHook.onCommitFiberUnmount === 'function') {
+    try {
+      injectedHook.onCommitFiberUnmount(rendererID, fiber);
+    } catch (err) {
+    }
+  }
+}
+
+function injectProfilingHooks(profilingHooks) {
+}
+
+function getLaneLabelMap() {
+  {
+    return null;
+  }
+}
+
+const NoMode =
+/*                         */
+0b0000000; // TODO: Remove ConcurrentMode by reading from the root tag instead
+
+const ConcurrentMode =
+/*                 */
+0b0000001;
+const ProfileMode =
+/*                    */
+0b0000010;
+const StrictLegacyMode =
+/*               */
+0b0001000;
+const StrictEffectsMode =
+/*              */
+0b0010000;
+
+// TODO: This is pretty well supported by browsers. Maybe we can drop it.
+const 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
+
+const log = Math.log;
+const LN2 = Math.LN2;
+
+function clz32Fallback(x) {
+  const asUint = x >>> 0;
+
+  if (asUint === 0) {
+    return 32;
+  }
+
+  return 31 - (log(asUint) / LN2 | 0) | 0;
+}
+
+// TODO: Ideally these types would be opaque but that doesn't work well with
+// If those values are changed that package should be rebuilt and redeployed.
+
+const TotalLanes = 31;
+const NoLanes =
+/*                        */
+0b0000000000000000000000000000000;
+const NoLane =
+/*                          */
+0b0000000000000000000000000000000;
+const SyncHydrationLane =
+/*               */
+0b0000000000000000000000000000001;
+const SyncLane =
+/*                        */
+0b0000000000000000000000000000010;
+const SyncLaneIndex = 1;
+const InputContinuousHydrationLane =
+/*    */
+0b0000000000000000000000000000100;
+const InputContinuousLane =
+/*             */
+0b0000000000000000000000000001000;
+const DefaultHydrationLane =
+/*            */
+0b0000000000000000000000000010000;
+const DefaultLane =
+/*                     */
+0b0000000000000000000000000100000;
+const SyncUpdateLanes = SyncLane | InputContinuousLane | DefaultLane ;
+const TransitionHydrationLane =
+/*                */
+0b0000000000000000000000001000000;
+const TransitionLanes =
+/*                       */
+0b0000000001111111111111110000000;
+const TransitionLane1 =
+/*                        */
+0b0000000000000000000000010000000;
+const TransitionLane2 =
+/*                        */
+0b0000000000000000000000100000000;
+const TransitionLane3 =
+/*                        */
+0b0000000000000000000001000000000;
+const TransitionLane4 =
+/*                        */
+0b0000000000000000000010000000000;
+const TransitionLane5 =
+/*                        */
+0b0000000000000000000100000000000;
+const TransitionLane6 =
+/*                        */
+0b0000000000000000001000000000000;
+const TransitionLane7 =
+/*                        */
+0b0000000000000000010000000000000;
+const TransitionLane8 =
+/*                        */
+0b0000000000000000100000000000000;
+const TransitionLane9 =
+/*                        */
+0b0000000000000001000000000000000;
+const TransitionLane10 =
+/*                       */
+0b0000000000000010000000000000000;
+const TransitionLane11 =
+/*                       */
+0b0000000000000100000000000000000;
+const TransitionLane12 =
+/*                       */
+0b0000000000001000000000000000000;
+const TransitionLane13 =
+/*                       */
+0b0000000000010000000000000000000;
+const TransitionLane14 =
+/*                       */
+0b0000000000100000000000000000000;
+const TransitionLane15 =
+/*                       */
+0b0000000001000000000000000000000;
+const RetryLanes =
+/*                            */
+0b0000011110000000000000000000000;
+const RetryLane1 =
+/*                             */
+0b0000000010000000000000000000000;
+const RetryLane2 =
+/*                             */
+0b0000000100000000000000000000000;
+const RetryLane3 =
+/*                             */
+0b0000001000000000000000000000000;
+const RetryLane4 =
+/*                             */
+0b0000010000000000000000000000000;
+const SomeRetryLane = RetryLane1;
+const SelectiveHydrationLane =
+/*          */
+0b0000100000000000000000000000000;
+const NonIdleLanes =
+/*                          */
+0b0000111111111111111111111111111;
+const IdleHydrationLane =
+/*               */
+0b0001000000000000000000000000000;
+const IdleLane =
+/*                        */
+0b0010000000000000000000000000000;
+const OffscreenLane =
+/*                   */
+0b0100000000000000000000000000000;
+const DeferredLane =
+/*                    */
+0b1000000000000000000000000000000; // Any lane that might schedule an update. This is used to detect infinite
+// update loops, so it doesn't include hydration lanes or retries.
+
+const UpdateLanes = SyncLane | InputContinuousLane | DefaultLane | TransitionLanes; // This function is used for the experimental timeline (react-devtools-timeline)
+const NoTimestamp = -1;
+let nextTransitionLane = TransitionLane1;
+let nextRetryLane = RetryLane1;
+
+function getHighestPriorityLanes(lanes) {
+  {
+    const pendingSyncLanes = lanes & SyncUpdateLanes;
+
+    if (pendingSyncLanes !== 0) {
+      return pendingSyncLanes;
+    }
+  }
+
+  switch (getHighestPriorityLane(lanes)) {
+    case SyncHydrationLane:
+      return SyncHydrationLane;
+
+    case SyncLane:
+      return SyncLane;
+
+    case InputContinuousHydrationLane:
+      return InputContinuousHydrationLane;
+
+    case InputContinuousLane:
+      return InputContinuousLane;
+
+    case DefaultHydrationLane:
+      return DefaultHydrationLane;
+
+    case DefaultLane:
+      return DefaultLane;
+
+    case TransitionHydrationLane:
+      return TransitionHydrationLane;
+
+    case TransitionLane1:
+    case TransitionLane2:
+    case TransitionLane3:
+    case TransitionLane4:
+    case TransitionLane5:
+    case TransitionLane6:
+    case TransitionLane7:
+    case TransitionLane8:
+    case TransitionLane9:
+    case TransitionLane10:
+    case TransitionLane11:
+    case TransitionLane12:
+    case TransitionLane13:
+    case TransitionLane14:
+    case TransitionLane15:
+      return lanes & TransitionLanes;
+
+    case RetryLane1:
+    case RetryLane2:
+    case RetryLane3:
+    case RetryLane4:
+      return lanes & RetryLanes;
+
+    case SelectiveHydrationLane:
+      return SelectiveHydrationLane;
+
+    case IdleHydrationLane:
+      return IdleHydrationLane;
+
+    case IdleLane:
+      return IdleLane;
+
+    case OffscreenLane:
+      return OffscreenLane;
+
+    case DeferredLane:
+      // This shouldn't be reachable because deferred work is always entangled
+      // with something else.
+      return NoLanes;
+
+    default:
+
+
+      return lanes;
+  }
+}
+
+function getNextLanes(root, wipLanes) {
+  // Early bailout if there's no pending work left.
+  const pendingLanes = root.pendingLanes;
+
+  if (pendingLanes === NoLanes) {
+    return NoLanes;
+  }
+
+  let nextLanes = NoLanes;
+  const suspendedLanes = root.suspendedLanes;
+  const pingedLanes = root.pingedLanes; // Do not work on any idle work until all the non-idle work has finished,
+  // even if the work is suspended.
+
+  const nonIdlePendingLanes = pendingLanes & NonIdleLanes;
+
+  if (nonIdlePendingLanes !== NoLanes) {
+    const nonIdleUnblockedLanes = nonIdlePendingLanes & ~suspendedLanes;
+
+    if (nonIdleUnblockedLanes !== NoLanes) {
+      nextLanes = getHighestPriorityLanes(nonIdleUnblockedLanes);
+    } else {
+      const nonIdlePingedLanes = nonIdlePendingLanes & pingedLanes;
+
+      if (nonIdlePingedLanes !== NoLanes) {
+        nextLanes = getHighestPriorityLanes(nonIdlePingedLanes);
+      }
+    }
+  } else {
+    // The only remaining work is Idle.
+    const unblockedLanes = pendingLanes & ~suspendedLanes;
+
+    if (unblockedLanes !== NoLanes) {
+      nextLanes = getHighestPriorityLanes(unblockedLanes);
+    } else {
+      if (pingedLanes !== NoLanes) {
+        nextLanes = getHighestPriorityLanes(pingedLanes);
+      }
+    }
+  }
+
+  if (nextLanes === NoLanes) {
+    // This should only be reachable if we're suspended
+    // TODO: Consider warning in this path if a fallback timer is not scheduled.
+    return NoLanes;
+  } // If we're already in the middle of a render, switching lanes will interrupt
+  // it and we'll lose our progress. We should only do this if the new lanes are
+  // higher priority.
+
+
+  if (wipLanes !== NoLanes && wipLanes !== nextLanes && // If we already suspended with a delay, then interrupting is fine. Don't
+  // bother waiting until the root is complete.
+  (wipLanes & suspendedLanes) === NoLanes) {
+    const nextLane = getHighestPriorityLane(nextLanes);
+    const wipLane = getHighestPriorityLane(wipLanes);
+
+    if ( // Tests whether the next lane is equal or lower priority than the wip
+    // one. This works because the bits decrease in priority as you go left.
+    nextLane >= wipLane || // Default priority updates should not interrupt transition updates. The
+    // only difference between default updates and transition updates is that
+    // default updates do not support refresh transitions.
+    nextLane === DefaultLane && (wipLane & TransitionLanes) !== NoLanes) {
+      // Keep working on the existing in-progress tree. Do not interrupt.
+      return wipLanes;
+    }
+  }
+
+  return nextLanes;
+}
+function getEntangledLanes(root, renderLanes) {
+  let entangledLanes = renderLanes;
+
+  if ((entangledLanes & InputContinuousLane) !== NoLanes) {
+    // When updates are sync by default, we entangle continuous priority updates
+    // and default updates, so they render in the same batch. The only reason
+    // they use separate lanes is because continuous updates should interrupt
+    // transitions, but default updates should not.
+    entangledLanes |= entangledLanes & DefaultLane;
+  } // Check for entangled lanes and add them to the batch.
+  //
+  // A lane is said to be entangled with another when it's not allowed to render
+  // in a batch that does not also include the other lane. Typically we do this
+  // when multiple updates have the same source, and we only want to respond to
+  // the most recent event from that source.
+  //
+  // Note that we apply entanglements *after* checking for partial work above.
+  // This means that if a lane is entangled during an interleaved event while
+  // it's already rendering, we won't interrupt it. This is intentional, since
+  // entanglement is usually "best effort": we'll try our best to render the
+  // lanes in the same batch, but it's not worth throwing out partially
+  // completed work in order to do it.
+  // TODO: Reconsider this. The counter-argument is that the partial work
+  // represents an intermediate state, which we don't want to show to the user.
+  // And by spending extra time finishing it, we're increasing the amount of
+  // time it takes to show the final state, which is what they are actually
+  // waiting for.
+  //
+  // For those exceptions where entanglement is semantically important,
+  // we should ensure that there is no partial work at the
+  // time we apply the entanglement.
+
+
+  const allEntangledLanes = root.entangledLanes;
+
+  if (allEntangledLanes !== NoLanes) {
+    const entanglements = root.entanglements;
+    let lanes = entangledLanes & allEntangledLanes;
+
+    while (lanes > 0) {
+      const index = pickArbitraryLaneIndex(lanes);
+      const lane = 1 << index;
+      entangledLanes |= entanglements[index];
+      lanes &= ~lane;
+    }
+  }
+
+  return entangledLanes;
+}
+
+function computeExpirationTime(lane, currentTime) {
+  switch (lane) {
+    case SyncHydrationLane:
+    case SyncLane:
+    case InputContinuousHydrationLane:
+    case InputContinuousLane:
+      // User interactions should expire slightly more quickly.
+      //
+      // NOTE: This is set to the corresponding constant as in Scheduler.js.
+      // When we made it larger, a product metric in www regressed, suggesting
+      // there's a user interaction that's being starved by a series of
+      // synchronous updates. If that theory is correct, the proper solution is
+      // to fix the starvation. However, this scenario supports the idea that
+      // expiration times are an important safeguard when starvation
+      // does happen.
+      return currentTime + 250;
+
+    case DefaultHydrationLane:
+    case DefaultLane:
+    case TransitionHydrationLane:
+    case TransitionLane1:
+    case TransitionLane2:
+    case TransitionLane3:
+    case TransitionLane4:
+    case TransitionLane5:
+    case TransitionLane6:
+    case TransitionLane7:
+    case TransitionLane8:
+    case TransitionLane9:
+    case TransitionLane10:
+    case TransitionLane11:
+    case TransitionLane12:
+    case TransitionLane13:
+    case TransitionLane14:
+    case TransitionLane15:
+      return currentTime + 5000;
+
+    case RetryLane1:
+    case RetryLane2:
+    case RetryLane3:
+    case RetryLane4:
+      // TODO: Retries should be allowed to expire if they are CPU bound for
+      // too long, but when I made this change it caused a spike in browser
+      // crashes. There must be some other underlying bug; not super urgent but
+      // ideally should figure out why and fix it. Unfortunately we don't have
+      // a repro for the crashes, only detected via production metrics.
+      return NoTimestamp;
+
+    case SelectiveHydrationLane:
+    case IdleHydrationLane:
+    case IdleLane:
+    case OffscreenLane:
+    case DeferredLane:
+      // Anything idle priority or lower should never expire.
+      return NoTimestamp;
+
+    default:
+
+      return NoTimestamp;
+  }
+}
+
+function markStarvedLanesAsExpired(root, currentTime) {
+  // TODO: This gets called every time we yield. We can optimize by storing
+  // the earliest expiration time on the root. Then use that to quickly bail out
+  // of this function.
+  const pendingLanes = root.pendingLanes;
+  const suspendedLanes = root.suspendedLanes;
+  const pingedLanes = root.pingedLanes;
+  const expirationTimes = root.expirationTimes; // Iterate through the pending lanes and check if we've reached their
+  // expiration time. If so, we'll assume the update is being starved and mark
+  // it as expired to force it to finish.
+  // TODO: We should be able to replace this with upgradePendingLanesToSync
+  //
+  // We exclude retry lanes because those must always be time sliced, in order
+  // to unwrap uncached promises.
+  // TODO: Write a test for this
+
+  let lanes = pendingLanes & ~RetryLanes;
+
+  while (lanes > 0) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+    const expirationTime = expirationTimes[index];
+
+    if (expirationTime === NoTimestamp) {
+      // Found a pending lane with no expiration time. If it's not suspended, or
+      // if it's pinged, assume it's CPU-bound. Compute a new expiration time
+      // using the current time.
+      if ((lane & suspendedLanes) === NoLanes || (lane & pingedLanes) !== NoLanes) {
+        // Assumes timestamps are monotonically increasing.
+        expirationTimes[index] = computeExpirationTime(lane, currentTime);
+      }
+    } else if (expirationTime <= currentTime) {
+      // This lane expired
+      root.expiredLanes |= lane;
+    }
+
+    lanes &= ~lane;
+  }
+} // This returns the highest priority pending lanes regardless of whether they
+// are suspended.
+
+function getHighestPriorityPendingLanes(root) {
+  return getHighestPriorityLanes(root.pendingLanes);
+}
+function getLanesToRetrySynchronouslyOnError(root, originallyAttemptedLanes) {
+  if (root.errorRecoveryDisabledLanes & originallyAttemptedLanes) {
+    // The error recovery mechanism is disabled until these lanes are cleared.
+    return NoLanes;
+  }
+
+  const everythingButOffscreen = root.pendingLanes & ~OffscreenLane;
+
+  if (everythingButOffscreen !== NoLanes) {
+    return everythingButOffscreen;
+  }
+
+  if (everythingButOffscreen & OffscreenLane) {
+    return OffscreenLane;
+  }
+
+  return NoLanes;
+}
+function includesSyncLane(lanes) {
+  return (lanes & (SyncLane | SyncHydrationLane)) !== NoLanes;
+}
+function includesNonIdleWork(lanes) {
+  return (lanes & NonIdleLanes) !== NoLanes;
+}
+function includesOnlyRetries(lanes) {
+  return (lanes & RetryLanes) === lanes;
+}
+function includesOnlyNonUrgentLanes(lanes) {
+  // TODO: Should hydration lanes be included here? This function is only
+  // used in `updateDeferredValueImpl`.
+  const UrgentLanes = SyncLane | InputContinuousLane | DefaultLane;
+  return (lanes & UrgentLanes) === NoLanes;
+}
+function includesOnlyTransitions(lanes) {
+  return (lanes & TransitionLanes) === lanes;
+}
+function includesBlockingLane(root, lanes) {
+
+  const SyncDefaultLanes = InputContinuousHydrationLane | InputContinuousLane | DefaultHydrationLane | DefaultLane;
+  return (lanes & SyncDefaultLanes) !== NoLanes;
+}
+function includesExpiredLane(root, lanes) {
+  // This is a separate check from includesBlockingLane because a lane can
+  // expire after a render has already started.
+  return (lanes & root.expiredLanes) !== NoLanes;
+}
+function isTransitionLane(lane) {
+  return (lane & TransitionLanes) !== NoLanes;
+}
+function claimNextTransitionLane() {
+  // Cycle through the lanes, assigning each new transition to the next lane.
+  // In most cases, this means every transition gets its own lane, until we
+  // run out of lanes and cycle back to the beginning.
+  const lane = nextTransitionLane;
+  nextTransitionLane <<= 1;
+
+  if ((nextTransitionLane & TransitionLanes) === NoLanes) {
+    nextTransitionLane = TransitionLane1;
+  }
+
+  return lane;
+}
+function claimNextRetryLane() {
+  const lane = nextRetryLane;
+  nextRetryLane <<= 1;
+
+  if ((nextRetryLane & RetryLanes) === NoLanes) {
+    nextRetryLane = RetryLane1;
+  }
+
+  return lane;
+}
+function getHighestPriorityLane(lanes) {
+  return lanes & -lanes;
+}
+function pickArbitraryLane(lanes) {
+  // This wrapper function gets inlined. Only exists so to communicate that it
+  // doesn't matter which bit is selected; you can pick any bit without
+  // affecting the algorithms where its used. Here I'm using
+  // getHighestPriorityLane because it requires the fewest operations.
+  return getHighestPriorityLane(lanes);
+}
+
+function pickArbitraryLaneIndex(lanes) {
+  return 31 - clz32(lanes);
+}
+
+function laneToIndex(lane) {
+  return pickArbitraryLaneIndex(lane);
+}
+
+function includesSomeLane(a, b) {
+  return (a & b) !== NoLanes;
+}
+function isSubsetOfLanes(set, subset) {
+  return (set & subset) === subset;
+}
+function mergeLanes(a, b) {
+  return a | b;
+}
+function removeLanes(set, subset) {
+  return set & ~subset;
+}
+function intersectLanes(a, b) {
+  return a & b;
+} // Seems redundant, but it changes the type from a single lane (used for
+// updates) to a group of lanes (used for flushing work).
+
+function laneToLanes(lane) {
+  return lane;
+}
+function higherPriorityLane(a, b) {
+  // This works because the bit ranges decrease in priority as you go left.
+  return a !== NoLane && a < b ? a : b;
+}
+function createLaneMap(initial) {
+  // Intentionally pushing one by one.
+  // https://v8.dev/blog/elements-kinds#avoid-creating-holes
+  const laneMap = [];
+
+  for (let i = 0; i < TotalLanes; i++) {
+    laneMap.push(initial);
+  }
+
+  return laneMap;
+}
+function markRootUpdated(root, updateLane) {
+  root.pendingLanes |= updateLane; // If there are any suspended transitions, it's possible this new update
+  // could unblock them. Clear the suspended lanes so that we can try rendering
+  // them again.
+  //
+  // TODO: We really only need to unsuspend only lanes that are in the
+  // `subtreeLanes` of the updated fiber, or the update lanes of the return
+  // path. This would exclude suspended updates in an unrelated sibling tree,
+  // since there's no way for this update to unblock it.
+  //
+  // We don't do this if the incoming update is idle, because we never process
+  // idle updates until after all the regular updates have finished; there's no
+  // way it could unblock a transition.
+
+  if (updateLane !== IdleLane) {
+    root.suspendedLanes = NoLanes;
+    root.pingedLanes = NoLanes;
+  }
+}
+function markRootSuspended$1(root, suspendedLanes, spawnedLane) {
+  root.suspendedLanes |= suspendedLanes;
+  root.pingedLanes &= ~suspendedLanes; // The suspended lanes are no longer CPU-bound. Clear their expiration times.
+
+  const expirationTimes = root.expirationTimes;
+  let lanes = suspendedLanes;
+
+  while (lanes > 0) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+    expirationTimes[index] = NoTimestamp;
+    lanes &= ~lane;
+  }
+
+  if (spawnedLane !== NoLane) {
+    markSpawnedDeferredLane(root, spawnedLane, suspendedLanes);
+  }
+}
+function markRootPinged(root, pingedLanes) {
+  root.pingedLanes |= root.suspendedLanes & pingedLanes;
+}
+function markRootFinished(root, remainingLanes, spawnedLane) {
+  const noLongerPendingLanes = root.pendingLanes & ~remainingLanes;
+  root.pendingLanes = remainingLanes; // Let's try everything again
+
+  root.suspendedLanes = NoLanes;
+  root.pingedLanes = NoLanes;
+  root.expiredLanes &= remainingLanes;
+  root.entangledLanes &= remainingLanes;
+  root.errorRecoveryDisabledLanes &= remainingLanes;
+  root.shellSuspendCounter = 0;
+  const entanglements = root.entanglements;
+  const expirationTimes = root.expirationTimes;
+  const hiddenUpdates = root.hiddenUpdates; // Clear the lanes that no longer have pending work
+
+  let lanes = noLongerPendingLanes;
+
+  while (lanes > 0) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+    entanglements[index] = NoLanes;
+    expirationTimes[index] = NoTimestamp;
+    const hiddenUpdatesForLane = hiddenUpdates[index];
+
+    if (hiddenUpdatesForLane !== null) {
+      hiddenUpdates[index] = null; // "Hidden" updates are updates that were made to a hidden component. They
+      // have special logic associated with them because they may be entangled
+      // with updates that occur outside that tree. But once the outer tree
+      // commits, they behave like regular updates.
+
+      for (let i = 0; i < hiddenUpdatesForLane.length; i++) {
+        const update = hiddenUpdatesForLane[i];
+
+        if (update !== null) {
+          update.lane &= ~OffscreenLane;
+        }
+      }
+    }
+
+    lanes &= ~lane;
+  }
+
+  if (spawnedLane !== NoLane) {
+    markSpawnedDeferredLane(root, spawnedLane, // This render finished successfully without suspending, so we don't need
+    // to entangle the spawned task with the parent task.
+    NoLanes);
+  }
+}
+
+function markSpawnedDeferredLane(root, spawnedLane, entangledLanes) {
+  // This render spawned a deferred task. Mark it as pending.
+  root.pendingLanes |= spawnedLane;
+  root.suspendedLanes &= ~spawnedLane; // Entangle the spawned lane with the DeferredLane bit so that we know it
+  // was the result of another render. This lets us avoid a useDeferredValue
+  // waterfall — only the first level will defer.
+
+  const spawnedLaneIndex = laneToIndex(spawnedLane);
+  root.entangledLanes |= spawnedLane;
+  root.entanglements[spawnedLaneIndex] |= DeferredLane | // If the parent render task suspended, we must also entangle those lanes
+  // with the spawned task, so that the deferred task includes all the same
+  // updates that the parent task did. We can exclude any lane that is not
+  // used for updates (e.g. Offscreen).
+  entangledLanes & UpdateLanes;
+}
+
+function markRootEntangled(root, entangledLanes) {
+  // In addition to entangling each of the given lanes with each other, we also
+  // have to consider _transitive_ entanglements. For each lane that is already
+  // entangled with *any* of the given lanes, that lane is now transitively
+  // entangled with *all* the given lanes.
+  //
+  // Translated: If C is entangled with A, then entangling A with B also
+  // entangles C with B.
+  //
+  // If this is hard to grasp, it might help to intentionally break this
+  // function and look at the tests that fail in ReactTransition-test.js. Try
+  // commenting out one of the conditions below.
+  const rootEntangledLanes = root.entangledLanes |= entangledLanes;
+  const entanglements = root.entanglements;
+  let lanes = rootEntangledLanes;
+
+  while (lanes) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+
+    if ( // Is this one of the newly entangled lanes?
+    lane & entangledLanes | // Is this lane transitively entangled with the newly entangled lanes?
+    entanglements[index] & entangledLanes) {
+      entanglements[index] |= entangledLanes;
+    }
+
+    lanes &= ~lane;
+  }
+}
+function upgradePendingLaneToSync(root, lane) {
+  // Since we're upgrading the priority of the given lane, there is now pending
+  // sync work.
+  root.pendingLanes |= SyncLane; // Entangle the sync lane with the lane we're upgrading. This means SyncLane
+  // will not be allowed to finish without also finishing the given lane.
+
+  root.entangledLanes |= SyncLane;
+  root.entanglements[SyncLaneIndex] |= lane;
+}
+function upgradePendingLanesToSync(root, lanesToUpgrade) {
+  // Same as upgradePendingLaneToSync but accepts multiple lanes, so it's a
+  // bit slower.
+  root.pendingLanes |= SyncLane;
+  root.entangledLanes |= SyncLane;
+  let lanes = lanesToUpgrade;
+
+  while (lanes) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+    root.entanglements[SyncLaneIndex] |= lane;
+    lanes &= ~lane;
+  }
+}
+function markHiddenUpdate(root, update, lane) {
+  const index = laneToIndex(lane);
+  const hiddenUpdates = root.hiddenUpdates;
+  const hiddenUpdatesForLane = hiddenUpdates[index];
+
+  if (hiddenUpdatesForLane === null) {
+    hiddenUpdates[index] = [update];
+  } else {
+    hiddenUpdatesForLane.push(update);
+  }
+
+  update.lane = lane | OffscreenLane;
+}
+function getBumpedLaneForHydration(root, renderLanes) {
+  const renderLane = getHighestPriorityLane(renderLanes);
+  let lane;
+
+  if ((renderLane & SyncUpdateLanes) !== NoLane) {
+    lane = SyncHydrationLane;
+  } else {
+    switch (renderLane) {
+      case SyncLane:
+        lane = SyncHydrationLane;
+        break;
+
+      case InputContinuousLane:
+        lane = InputContinuousHydrationLane;
+        break;
+
+      case DefaultLane:
+        lane = DefaultHydrationLane;
+        break;
+
+      case TransitionLane1:
+      case TransitionLane2:
+      case TransitionLane3:
+      case TransitionLane4:
+      case TransitionLane5:
+      case TransitionLane6:
+      case TransitionLane7:
+      case TransitionLane8:
+      case TransitionLane9:
+      case TransitionLane10:
+      case TransitionLane11:
+      case TransitionLane12:
+      case TransitionLane13:
+      case TransitionLane14:
+      case TransitionLane15:
+      case RetryLane1:
+      case RetryLane2:
+      case RetryLane3:
+      case RetryLane4:
+        lane = TransitionHydrationLane;
+        break;
+
+      case IdleLane:
+        lane = IdleHydrationLane;
+        break;
+
+      default:
+        // Everything else is already either a hydration lane, or shouldn't
+        // be retried at a hydration lane.
+        lane = NoLane;
+        break;
+    }
+  } // Check if the lane we chose is suspended. If so, that indicates that we
+  // already attempted and failed to hydrate at that level. Also check if we're
+  // already rendering that lane, which is rare but could happen.
+
+
+  if ((lane & (root.suspendedLanes | renderLanes)) !== NoLane) {
+    // Give up trying to hydrate and fall back to client render.
+    return NoLane;
+  }
+
+  return lane;
+}
+function getTransitionsForLanes(root, lanes) {
+  {
+    return null;
+  }
+}
+
+const DiscreteEventPriority = SyncLane;
+const ContinuousEventPriority = InputContinuousLane;
+const DefaultEventPriority = DefaultLane;
+const IdleEventPriority = IdleLane;
+let currentUpdatePriority = NoLane;
+function getCurrentUpdatePriority() {
+  return currentUpdatePriority;
+}
+function setCurrentUpdatePriority(newPriority) {
+  currentUpdatePriority = newPriority;
+}
+function runWithPriority(priority, fn) {
+  const previousPriority = currentUpdatePriority;
+
+  try {
+    currentUpdatePriority = priority;
+    return fn();
+  } finally {
+    currentUpdatePriority = previousPriority;
+  }
+}
+function higherEventPriority(a, b) {
+  return a !== 0 && a < b ? a : b;
+}
+function lowerEventPriority(a, b) {
+  return a === 0 || a > b ? a : b;
+}
+function isHigherEventPriority(a, b) {
+  return a !== 0 && a < b;
+}
+function lanesToEventPriority(lanes) {
+  const lane = getHighestPriorityLane(lanes);
+
+  if (!isHigherEventPriority(DiscreteEventPriority, lane)) {
+    return DiscreteEventPriority;
+  }
+
+  if (!isHigherEventPriority(ContinuousEventPriority, lane)) {
+    return ContinuousEventPriority;
+  }
+
+  if (includesNonIdleWork(lane)) {
+    return DefaultEventPriority;
+  }
+
+  return IdleEventPriority;
+}
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+const FunctionComponent = 0;
+const ClassComponent = 1;
+const IndeterminateComponent = 2; // Before we know whether it is function or class
+
+const HostRoot = 3; // Root of a host tree. Could be nested inside another node.
+
+const HostPortal = 4; // A subtree. Could be an entry point to a different renderer.
+
+const HostComponent = 5;
+const HostText = 6;
+const Fragment = 7;
+const Mode = 8;
+const ContextConsumer = 9;
+const ContextProvider = 10;
+const ForwardRef = 11;
+const Profiler = 12;
+const SuspenseComponent = 13;
+const MemoComponent = 14;
+const SimpleMemoComponent = 15;
+const LazyComponent = 16;
+const IncompleteClassComponent = 17;
+const DehydratedFragment = 18;
+const SuspenseListComponent = 19;
+const ScopeComponent = 21;
+const OffscreenComponent = 22;
+const LegacyHiddenComponent = 23;
+const CacheComponent = 24;
+const TracingMarkerComponent = 25;
+const HostHoistable = 26;
+const HostSingleton = 27;
+
+const randomKey = Math.random().toString(36).slice(2);
+const internalInstanceKey = '__reactFiber$' + randomKey;
+const internalPropsKey = '__reactProps$' + randomKey;
+const internalContainerInstanceKey = '__reactContainer$' + randomKey;
+const internalEventHandlersKey = '__reactEvents$' + randomKey;
+const internalEventHandlerListenersKey = '__reactListeners$' + randomKey;
+const internalEventHandlesSetKey = '__reactHandles$' + randomKey;
+const internalRootNodeResourcesKey = '__reactResources$' + randomKey;
+const internalHoistableMarker = '__reactMarker$' + randomKey;
+function detachDeletedInstance(node) {
+  // TODO: This function is only called on host components. I don't think all of
+  // these fields are relevant.
+  delete node[internalInstanceKey];
+  delete node[internalPropsKey];
+  delete node[internalEventHandlersKey];
+  delete node[internalEventHandlerListenersKey];
+  delete node[internalEventHandlesSetKey];
+}
+function precacheFiberNode(hostInst, node) {
+  node[internalInstanceKey] = hostInst;
+}
+function markContainerAsRoot(hostRoot, node) {
+  // $FlowFixMe[prop-missing]
+  node[internalContainerInstanceKey] = hostRoot;
+}
+function unmarkContainerAsRoot(node) {
+  // $FlowFixMe[prop-missing]
+  node[internalContainerInstanceKey] = null;
+}
+function isContainerMarkedAsRoot(node) {
+  // $FlowFixMe[prop-missing]
+  return !!node[internalContainerInstanceKey];
+} // Given a DOM node, return the closest HostComponent or HostText fiber ancestor.
+// If the target node is part of a hydrated or not yet rendered subtree, then
+// this may also return a SuspenseComponent or HostRoot to indicate that.
+// Conceptually the HostRoot fiber is a child of the Container node. So if you
+// pass the Container node as the targetNode, you will not actually get the
+// HostRoot back. To get to the HostRoot, you need to pass a child of it.
+// The same thing applies to Suspense boundaries.
+
+function getClosestInstanceFromNode(targetNode) {
+  let targetInst = targetNode[internalInstanceKey];
+
+  if (targetInst) {
+    // Don't return HostRoot or SuspenseComponent here.
+    return targetInst;
+  } // If the direct event target isn't a React owned DOM node, we need to look
+  // to see if one of its parents is a React owned DOM node.
+
+
+  let parentNode = targetNode.parentNode;
+
+  while (parentNode) {
+    // We'll check if this is a container root that could include
+    // React nodes in the future. We need to check this first because
+    // if we're a child of a dehydrated container, we need to first
+    // find that inner container before moving on to finding the parent
+    // instance. Note that we don't check this field on  the targetNode
+    // itself because the fibers are conceptually between the container
+    // node and the first child. It isn't surrounding the container node.
+    // If it's not a container, we check if it's an instance.
+    targetInst = parentNode[internalContainerInstanceKey] || parentNode[internalInstanceKey];
+
+    if (targetInst) {
+      // Since this wasn't the direct target of the event, we might have
+      // stepped past dehydrated DOM nodes to get here. However they could
+      // also have been non-React nodes. We need to answer which one.
+      // If we the instance doesn't have any children, then there can't be
+      // a nested suspense boundary within it. So we can use this as a fast
+      // bailout. Most of the time, when people add non-React children to
+      // the tree, it is using a ref to a child-less DOM node.
+      // Normally we'd only need to check one of the fibers because if it
+      // has ever gone from having children to deleting them or vice versa
+      // it would have deleted the dehydrated boundary nested inside already.
+      // However, since the HostRoot starts out with an alternate it might
+      // have one on the alternate so we need to check in case this was a
+      // root.
+      const alternate = targetInst.alternate;
+
+      if (targetInst.child !== null || alternate !== null && alternate.child !== null) {
+        // Next we need to figure out if the node that skipped past is
+        // nested within a dehydrated boundary and if so, which one.
+        let suspenseInstance = getParentSuspenseInstance(targetNode);
+
+        while (suspenseInstance !== null) {
+          // We found a suspense instance. That means that we haven't
+          // hydrated it yet. Even though we leave the comments in the
+          // DOM after hydrating, and there are boundaries in the DOM
+          // that could already be hydrated, we wouldn't have found them
+          // through this pass since if the target is hydrated it would
+          // have had an internalInstanceKey on it.
+          // Let's get the fiber associated with the SuspenseComponent
+          // as the deepest instance.
+          // $FlowFixMe[prop-missing]
+          const targetSuspenseInst = suspenseInstance[internalInstanceKey];
+
+          if (targetSuspenseInst) {
+            return targetSuspenseInst;
+          } // If we don't find a Fiber on the comment, it might be because
+          // we haven't gotten to hydrate it yet. There might still be a
+          // parent boundary that hasn't above this one so we need to find
+          // the outer most that is known.
+
+
+          suspenseInstance = getParentSuspenseInstance(suspenseInstance); // If we don't find one, then that should mean that the parent
+          // host component also hasn't hydrated yet. We can return it
+          // below since it will bail out on the isMounted check later.
+        }
+      }
+
+      return targetInst;
+    }
+
+    targetNode = parentNode;
+    parentNode = targetNode.parentNode;
+  }
+
+  return null;
+}
+/**
+ * Given a DOM node, return the ReactDOMComponent or ReactDOMTextComponent
+ * instance, or null if the node was not rendered by this React.
+ */
+
+function getInstanceFromNode$1(node) {
+  const inst = node[internalInstanceKey] || node[internalContainerInstanceKey];
+
+  if (inst) {
+    const tag = inst.tag;
+
+    if (tag === HostComponent || tag === HostText || tag === SuspenseComponent || (tag === HostHoistable ) || (tag === HostSingleton ) || tag === HostRoot) {
+      return inst;
+    } else {
+      return null;
+    }
+  }
+
+  return null;
+}
+/**
+ * Given a ReactDOMComponent or ReactDOMTextComponent, return the corresponding
+ * DOM node.
+ */
+
+function getNodeFromInstance(inst) {
+  const tag = inst.tag;
+
+  if (tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton ) || tag === HostText) {
+    // In Fiber this, is just the state node right now. We assume it will be
+    // a host component or host text.
+    return inst.stateNode;
+  } // Without this first invariant, passing a non-DOM-component triggers the next
+  // invariant for a missing parent, which is super confusing.
+
+
+  throw Error(formatProdErrorMessage(33));
+}
+function getFiberCurrentPropsFromNode(node) {
+  return node[internalPropsKey] || null;
+}
+function updateFiberProps(node, props) {
+  node[internalPropsKey] = props;
+}
+function getEventListenerSet(node) {
+  let elementListenerSet = node[internalEventHandlersKey];
+
+  if (elementListenerSet === undefined) {
+    elementListenerSet = node[internalEventHandlersKey] = new Set();
+  }
+
+  return elementListenerSet;
+}
+function getResourcesFromRoot(root) {
+  let resources = root[internalRootNodeResourcesKey];
+
+  if (!resources) {
+    resources = root[internalRootNodeResourcesKey] = {
+      hoistableStyles: new Map(),
+      hoistableScripts: new Map()
+    };
+  }
+
+  return resources;
+}
+function isMarkedHoistable(node) {
+  return !!node[internalHoistableMarker];
+}
+function markNodeAsHoistable(node) {
+  node[internalHoistableMarker] = true;
+}
+function isOwnedInstance(node) {
+  return !!(node[internalHoistableMarker] || node[internalInstanceKey]);
+}
+
+// Below code forked from dom-accessibility-api
+const tagToRoleMappings = {
+  ARTICLE: 'article',
+  ASIDE: 'complementary',
+  BODY: 'document',
+  BUTTON: 'button',
+  DATALIST: 'listbox',
+  DD: 'definition',
+  DETAILS: 'group',
+  DIALOG: 'dialog',
+  DT: 'term',
+  FIELDSET: 'group',
+  FIGURE: 'figure',
+  // WARNING: Only with an accessible name
+  FORM: 'form',
+  FOOTER: 'contentinfo',
+  H1: 'heading',
+  H2: 'heading',
+  H3: 'heading',
+  H4: 'heading',
+  H5: 'heading',
+  H6: 'heading',
+  HEADER: 'banner',
+  HR: 'separator',
+  LEGEND: 'legend',
+  LI: 'listitem',
+  MATH: 'math',
+  MAIN: 'main',
+  MENU: 'list',
+  NAV: 'navigation',
+  OL: 'list',
+  OPTGROUP: 'group',
+  // WARNING: Only in certain context
+  OPTION: 'option',
+  OUTPUT: 'status',
+  PROGRESS: 'progressbar',
+  // WARNING: Only with an accessible name
+  SECTION: 'region',
+  SUMMARY: 'button',
+  TABLE: 'table',
+  TBODY: 'rowgroup',
+  TEXTAREA: 'textbox',
+  TFOOT: 'rowgroup',
+  // WARNING: Only in certain context
+  TD: 'cell',
+  TH: 'columnheader',
+  THEAD: 'rowgroup',
+  TR: 'row',
+  UL: 'list'
+};
+
+function getImplicitRole(element) {
+  const mappedByTag = tagToRoleMappings[element.tagName];
+
+  if (mappedByTag !== undefined) {
+    return mappedByTag;
+  }
+
+  switch (element.tagName) {
+    case 'A':
+    case 'AREA':
+    case 'LINK':
+      if (element.hasAttribute('href')) {
+        return 'link';
+      }
+
+      break;
+
+    case 'IMG':
+      if ((element.getAttribute('alt') || '').length > 0) {
+        return 'img';
+      }
+
+      break;
+
+    case 'INPUT':
+      {
+        const type = element.type;
+
+        switch (type) {
+          case 'button':
+          case 'image':
+          case 'reset':
+          case 'submit':
+            return 'button';
+
+          case 'checkbox':
+          case 'radio':
+            return type;
+
+          case 'range':
+            return 'slider';
+
+          case 'email':
+          case 'tel':
+          case 'text':
+          case 'url':
+            if (element.hasAttribute('list')) {
+              return 'combobox';
+            }
+
+            return 'textbox';
+
+          case 'search':
+            if (element.hasAttribute('list')) {
+              return 'combobox';
+            }
+
+            return 'searchbox';
+
+          default:
+            return null;
+        }
+      }
+
+    case 'SELECT':
+      if (element.hasAttribute('multiple') || element.size > 1) {
+        return 'listbox';
+      }
+
+      return 'combobox';
+  }
+
+  return null;
+}
+
+function getExplicitRoles(element) {
+  const role = element.getAttribute('role');
+
+  if (role) {
+    return role.trim().split(' ');
+  }
+
+  return null;
+} // https://w3c.github.io/html-aria/#document-conformance-requirements-for-use-of-aria-attributes-in-html
+
+
+function hasRole(element, role) {
+  const explicitRoles = getExplicitRoles(element);
+
+  if (explicitRoles !== null && explicitRoles.indexOf(role) >= 0) {
+    return true;
+  }
+
+  return role === getImplicitRole(element);
+}
+
+const allNativeEvents = new Set();
+/**
+ * Mapping from registration name to event name
+ */
+
+
+const registrationNameDependencies = {};
+
+function registerTwoPhaseEvent(registrationName, dependencies) {
+  registerDirectEvent(registrationName, dependencies);
+  registerDirectEvent(registrationName + 'Capture', dependencies);
+}
+function registerDirectEvent(registrationName, dependencies) {
+
+  registrationNameDependencies[registrationName] = dependencies;
+
+  for (let i = 0; i < dependencies.length; i++) {
+    allNativeEvents.add(dependencies[i]);
+  }
+}
+
+const canUseDOM = !!(typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined');
+
+/* eslint-disable max-len */
+
+const ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
+/* eslint-enable max-len */
+
+const ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
+const VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+const illegalAttributeNameCache = {};
+const validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+  if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+    return true;
+  }
+
+  if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+    return false;
+  }
+
+  if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+    validatedAttributeNameCache[attributeName] = true;
+    return true;
+  }
+
+  illegalAttributeNameCache[attributeName] = true;
+
+  return false;
+}
+
+function setValueForAttribute(node, name, value) {
+  if (isAttributeNameSafe(name)) {
+    // If the prop isn't in the special list, treat it as a simple attribute.
+    // shouldRemoveAttribute
+    if (value === null) {
+      node.removeAttribute(name);
+      return;
+    }
+
+    switch (typeof value) {
+      case 'undefined':
+      case 'function':
+      case 'symbol':
+        // eslint-disable-line
+        node.removeAttribute(name);
+        return;
+
+      case 'boolean':
+        {
+          const prefix = name.toLowerCase().slice(0, 5);
+
+          if (prefix !== 'data-' && prefix !== 'aria-') {
+            node.removeAttribute(name);
+            return;
+          }
+        }
+    }
+
+    node.setAttribute(name, '' + value);
+  }
+}
+function setValueForKnownAttribute(node, name, value) {
+  if (value === null) {
+    node.removeAttribute(name);
+    return;
+  }
+
+  switch (typeof value) {
+    case 'undefined':
+    case 'function':
+    case 'symbol':
+    case 'boolean':
+      {
+        node.removeAttribute(name);
+        return;
+      }
+  }
+
+  node.setAttribute(name, '' + value);
+}
+function setValueForNamespacedAttribute(node, namespace, name, value) {
+  if (value === null) {
+    node.removeAttribute(name);
+    return;
+  }
+
+  switch (typeof value) {
+    case 'undefined':
+    case 'function':
+    case 'symbol':
+    case 'boolean':
+      {
+        node.removeAttribute(name);
+        return;
+      }
+  }
+
+  node.setAttributeNS(namespace, name, '' + value);
+}
+function setValueForPropertyOnCustomComponent(node, name, value) {
+  if (name[0] === 'o' && name[1] === 'n') {
+    const useCapture = name.endsWith('Capture');
+    const eventName = name.slice(2, useCapture ? name.length - 7 : undefined);
+    const prevProps = getFiberCurrentPropsFromNode(node);
+    const 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[incompatible-cast] value can't be casted to EventListener.
+
+
+      node.addEventListener(eventName, value, useCapture);
+      return;
+    }
+  }
+
+  if (name in node) {
+    node[name] = value;
+    return;
+  }
+
+  if (value === true) {
+    node.setAttribute(name, '');
+    return;
+  } // From here, it's the same as any attribute
+
+
+  setValueForAttribute(node, name, value);
+}
+
+let prefix;
+function describeBuiltInComponentFrame(name, source, ownerFn) {
+  {
+    if (prefix === undefined) {
+      // Extract the VM specific prefix used by each line.
+      try {
+        throw Error();
+      } catch (x) {
+        const match = x.stack.trim().match(/\n( *(at )?)/);
+        prefix = match && match[1] || '';
+      }
+    } // We use the prefix to ensure our stacks line up with native stack frames.
+
+
+    return '\n' + prefix + name;
+  }
+}
+let reentry = false;
+let componentFrameCache;
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
+
+function describeNativeComponentFrame(fn, construct) {
+  // If something asked for a stack inside a fake render, it should get ignored.
+  if (!fn || reentry) {
+    return '';
+  }
+
+  reentry = true;
+  const previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
+
+  Error.prepareStackTrace = undefined;
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
+
+
+  const RunInRootFrame = {
+    DetermineComponentFrameRoot() {
+      let control;
+
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          const Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
+
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
+
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
+
+
+          const maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
+
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(() => {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
+      }
+
+      return [null, null];
+    }
+
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  const namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
+
+  try {
+    const _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+          sampleStack = _RunInRootFrame$Deter[0],
+          controlStack = _RunInRootFrame$Deter[1];
+
+    if (sampleStack && controlStack) {
+      // This extracts the first frame from the sample that isn't also in the control.
+      // Skipping one frame that we assume is the frame that calls the two.
+      const sampleLines = sampleStack.split('\n');
+      const controlLines = controlStack.split('\n');
+      let s = 0;
+      let c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
+      }
+
+      for (; s >= 1 && c >= 0; s--, c--) {
+        // Next we find the first one that isn't the same which should be the
+        // frame that called our sample function and the control.
+        if (sampleLines[s] !== controlLines[c]) {
+          // In V8, the first line is describing the message but other VMs don't.
+          // If we're about to return the first line, and the control is also on the same
+          // line, that's a pretty good indicator that our sample threw at same line as
+          // the control. I.e. before we entered the sample frame. So we ignore this result.
+          // This can happen if you passed a class to function component, or non-function.
+          if (s !== 1 || c !== 1) {
+            do {
+              s--;
+              c--; // We may still have similar intermediate frames from the construct call.
+              // The next one that isn't the same should be our match though.
+
+              if (c < 0 || sampleLines[s] !== controlLines[c]) {
+                // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
+                let frame = '\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled "<anonymous>"
+                // but we have a user-provided "displayName"
+                // splice it in to make the stack more readable.
+
+                if (fn.displayName && frame.includes('<anonymous>')) {
+                  frame = frame.replace('<anonymous>', fn.displayName);
+                }
+
+                if (false) ; // Return the line we found.
+
+
+                return frame;
+              }
+            } while (s >= 1 && c >= 0);
+          }
+
+          break;
+        }
+      }
+    }
+  } finally {
+    reentry = false;
+
+    Error.prepareStackTrace = previousPrepareStackTrace;
+  } // Fallback to just using the name if we couldn't make it throw.
+
+
+  const name = fn ? fn.displayName || fn.name : '';
+  const syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';
+
+  return syntheticFrame;
+}
+
+function describeClassComponentFrame(ctor, source, ownerFn) {
+  {
+    return describeNativeComponentFrame(ctor, true);
+  }
+}
+function describeFunctionComponentFrame(fn, source, ownerFn) {
+  {
+    return describeNativeComponentFrame(fn, false);
+  }
+}
+
+function describeFiber(fiber) {
+
+  switch (fiber.tag) {
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      return describeBuiltInComponentFrame(fiber.type);
+
+    case LazyComponent:
+      return describeBuiltInComponentFrame('Lazy');
+
+    case SuspenseComponent:
+      return describeBuiltInComponentFrame('Suspense');
+
+    case SuspenseListComponent:
+      return describeBuiltInComponentFrame('SuspenseList');
+
+    case FunctionComponent:
+    case IndeterminateComponent:
+    case SimpleMemoComponent:
+      return describeFunctionComponentFrame(fiber.type);
+
+    case ForwardRef:
+      return describeFunctionComponentFrame(fiber.type.render);
+
+    case ClassComponent:
+      return describeClassComponentFrame(fiber.type);
+
+    default:
+      return '';
+  }
+}
+
+function getStackByFiberInDevAndProd(workInProgress) {
+  try {
+    let info = '';
+    let node = workInProgress;
+
+    do {
+      info += describeFiber(node); // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+      node = node.return;
+    } while (node);
+
+    return info;
+  } catch (x) {
+    return '\nError generating stack: ' + x.message + '\n' + x.stack;
+  }
+}
+
+function getWrappedName$1(outerType, innerType, wrapperName) {
+  const displayName = outerType.displayName;
+
+  if (displayName) {
+    return displayName;
+  }
+
+  const functionName = innerType.displayName || innerType.name || '';
+  return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
+} // Keep in sync with react-reconciler/getComponentNameFromFiber
+
+
+function getContextName$1(type) {
+  return type.displayName || 'Context';
+} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+
+function getComponentNameFromType(type) {
+  if (type == null) {
+    // Host root, text node or just invalid type.
+    return null;
+  }
+
+  if (typeof type === 'function') {
+    return type.displayName || type.name || null;
+  }
+
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_FRAGMENT_TYPE:
+      return 'Fragment';
+
+    case REACT_PORTAL_TYPE:
+      return 'Portal';
+
+    case REACT_PROFILER_TYPE:
+      return 'Profiler';
+
+    case REACT_STRICT_MODE_TYPE:
+      return 'StrictMode';
+
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+
+    case REACT_CACHE_TYPE:
+      {
+        return 'Cache';
+      }
+
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        const context = type;
+        return getContextName$1(context) + '.Consumer';
+
+      case REACT_PROVIDER_TYPE:
+        const provider = type;
+        return getContextName$1(provider._context) + '.Provider';
+
+      case REACT_FORWARD_REF_TYPE:
+        return getWrappedName$1(type, type.render, 'ForwardRef');
+
+      case REACT_MEMO_TYPE:
+        const outerName = type.displayName || null;
+
+        if (outerName !== null) {
+          return outerName;
+        }
+
+        return getComponentNameFromType(type.type) || 'Memo';
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            return getComponentNameFromType(init(payload));
+          } catch (x) {
+            return null;
+          }
+        }
+
+      case REACT_SERVER_CONTEXT_TYPE:
+        {
+          const context2 = type;
+          return (context2.displayName || context2._globalName) + '.Provider';
+        }
+
+    }
+  }
+
+  return null;
+}
+
+function getWrappedName(outerType, innerType, wrapperName) {
+  const functionName = innerType.displayName || innerType.name || '';
+  return outerType.displayName || (functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName);
+} // Keep in sync with shared/getComponentNameFromType
+
+
+function getContextName(type) {
+  return type.displayName || 'Context';
+}
+
+function getComponentNameFromFiber(fiber) {
+  const tag = fiber.tag,
+        type = fiber.type;
+
+  switch (tag) {
+    case CacheComponent:
+      return 'Cache';
+
+    case ContextConsumer:
+      const context = type;
+      return getContextName(context) + '.Consumer';
+
+    case ContextProvider:
+      const provider = type;
+      return getContextName(provider._context) + '.Provider';
+
+    case DehydratedFragment:
+      return 'DehydratedFragment';
+
+    case ForwardRef:
+      return getWrappedName(type, type.render, 'ForwardRef');
+
+    case Fragment:
+      return 'Fragment';
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      // Host component type is the display name (e.g. "div", "View")
+      return type;
+
+    case HostPortal:
+      return 'Portal';
+
+    case HostRoot:
+      return 'Root';
+
+    case HostText:
+      return 'Text';
+
+    case LazyComponent:
+      // Name comes from the type in this case; we don't have a tag.
+      return getComponentNameFromType(type);
+
+    case Mode:
+      if (type === REACT_STRICT_MODE_TYPE) {
+        // Don't be less specific than shared/getComponentNameFromType
+        return 'StrictMode';
+      }
+
+      return 'Mode';
+
+    case OffscreenComponent:
+      return 'Offscreen';
+
+    case Profiler:
+      return 'Profiler';
+
+    case ScopeComponent:
+      return 'Scope';
+
+    case SuspenseComponent:
+      return 'Suspense';
+
+    case SuspenseListComponent:
+      return 'SuspenseList';
+
+    case TracingMarkerComponent:
+      return 'TracingMarker';
+    // The display name for this tags come from the user-provided type:
+
+    case ClassComponent:
+    case FunctionComponent:
+    case IncompleteClassComponent:
+    case IndeterminateComponent:
+    case MemoComponent:
+    case SimpleMemoComponent:
+      if (typeof type === 'function') {
+        return type.displayName || type.name || null;
+      }
+
+      if (typeof type === 'string') {
+        return type;
+      }
+
+      break;
+
+  }
+
+  return null;
+}
+
+// around this limitation, we use an opaque type that can only be obtained by
+// passing the value through getToStringValue first.
+
+function toString(value) {
+  // The coercion safety check is performed in getToStringValue().
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  return '' + value;
+}
+function getToStringValue(value) {
+  switch (typeof value) {
+    case 'boolean':
+    case 'number':
+    case 'string':
+    case 'undefined':
+      return value;
+
+    case 'object':
+
+      return value;
+
+    default:
+      // function, symbol are assigned as empty strings
+      return '';
+  }
+}
+
+function isCheckable(elem) {
+  const type = elem.type;
+  const nodeName = elem.nodeName;
+  return nodeName && nodeName.toLowerCase() === 'input' && (type === 'checkbox' || type === 'radio');
+}
+
+function getTracker(node) {
+  return node._valueTracker;
+}
+
+function detachTracker(node) {
+  node._valueTracker = null;
+}
+
+function getValueFromNode(node) {
+  let value = '';
+
+  if (!node) {
+    return value;
+  }
+
+  if (isCheckable(node)) {
+    value = node.checked ? 'true' : 'false';
+  } else {
+    value = node.value;
+  }
+
+  return value;
+}
+
+function trackValueOnNode(node) {
+  const valueField = isCheckable(node) ? 'checked' : 'value';
+  const descriptor = Object.getOwnPropertyDescriptor(node.constructor.prototype, valueField);
+
+  let currentValue = '' + node[valueField]; // if someone has already defined a value or Safari, then bail
+  // and don't track value will cause over reporting of changes,
+  // but it's better then a hard failure
+  // (needed for certain tests that spyOn input values and Safari)
+
+  if (node.hasOwnProperty(valueField) || typeof descriptor === 'undefined' || typeof descriptor.get !== 'function' || typeof descriptor.set !== 'function') {
+    return;
+  }
+
+  const get = descriptor.get,
+        set = descriptor.set;
+  Object.defineProperty(node, valueField, {
+    configurable: true,
+    // $FlowFixMe[missing-this-annot]
+    get: function () {
+      return get.call(this);
+    },
+    // $FlowFixMe[missing-local-annot]
+    // $FlowFixMe[missing-this-annot]
+    set: function (value) {
+
+      currentValue = '' + value;
+      set.call(this, value);
+    }
+  }); // We could've passed this the first time
+  // but it triggers a bug in IE11 and Edge 14/15.
+  // Calling defineProperty() again should be equivalent.
+  // https://github.com/facebook/react/issues/11768
+
+  Object.defineProperty(node, valueField, {
+    enumerable: descriptor.enumerable
+  });
+  const tracker = {
+    getValue() {
+      return currentValue;
+    },
+
+    setValue(value) {
+
+      currentValue = '' + value;
+    },
+
+    stopTracking() {
+      detachTracker(node);
+      delete node[valueField];
+    }
+
+  };
+  return tracker;
+}
+
+function track(node) {
+  if (getTracker(node)) {
+    return;
+  }
+
+  node._valueTracker = trackValueOnNode(node);
+}
+function updateValueIfChanged(node) {
+  if (!node) {
+    return false;
+  }
+
+  const tracker = getTracker(node); // if there is no tracker at this point it's unlikely
+  // that trying again will succeed
+
+  if (!tracker) {
+    return true;
+  }
+
+  const lastValue = tracker.getValue();
+  const nextValue = getValueFromNode(node);
+
+  if (nextValue !== lastValue) {
+    tracker.setValue(nextValue);
+    return true;
+  }
+
+  return false;
+}
+
+function getActiveElement(doc) {
+  doc = doc || (typeof document !== 'undefined' ? document : undefined);
+
+  if (typeof doc === 'undefined') {
+    return null;
+  }
+
+  try {
+    return doc.activeElement || doc.body;
+  } catch (e) {
+    return doc.body;
+  }
+}
+
+// When passing user input into querySelector(All) the embedded string must not alter
+// the semantics of the query. This escape function is safe to use when we know the
+// provided value is going to be wrapped in double quotes as part of an attribute selector
+// Do not use it anywhere else
+// we escape double quotes and backslashes
+const escapeSelectorAttributeValueInsideDoubleQuotesRegex = /[\n\"\\]/g;
+function escapeSelectorAttributeValueInsideDoubleQuotes(value) {
+  return value.replace(escapeSelectorAttributeValueInsideDoubleQuotesRegex, ch => '\\' + ch.charCodeAt(0).toString(16) + ' ');
+}
+
+function updateInput(element, value, defaultValue, lastDefaultValue, checked, defaultChecked, type, name) {
+  const node = element; // Temporarily disconnect the input from any radio buttons.
+  // Changing the type or name as the same time as changing the checked value
+  // needs to be atomically applied. We can only ensure that by disconnecting
+  // the name while do the mutations and then reapply the name after that's done.
+
+  node.name = '';
+
+  if (type != null && typeof type !== 'function' && typeof type !== 'symbol' && typeof type !== 'boolean') {
+
+    node.type = type;
+  } else {
+    node.removeAttribute('type');
+  }
+
+  if (value != null) {
+    if (type === 'number') {
+      if ( // $FlowFixMe[incompatible-type]
+      value === 0 && node.value === '' || // We explicitly want to coerce to number here if possible.
+      // eslint-disable-next-line
+      node.value != value) {
+        node.value = toString(getToStringValue(value));
+      }
+    } else if (node.value !== toString(getToStringValue(value))) {
+      node.value = toString(getToStringValue(value));
+    }
+  } else if (type === 'submit' || type === 'reset') {
+    // Submit/reset inputs need the attribute removed completely to avoid
+    // blank-text buttons.
+    node.removeAttribute('value');
+  }
+
+  {
+    // When syncing the value attribute, the value comes from a cascade of
+    // properties:
+    //  1. The value React property
+    //  2. The defaultValue React property
+    //  3. Otherwise there should be no change
+    if (value != null) {
+      setDefaultValue(node, type, getToStringValue(value));
+    } else if (defaultValue != null) {
+      setDefaultValue(node, type, getToStringValue(defaultValue));
+    } else if (lastDefaultValue != null) {
+      node.removeAttribute('value');
+    }
+  }
+
+  {
+    // 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 (checked == null && defaultChecked != null) {
+      node.defaultChecked = !!defaultChecked;
+    }
+  }
+
+  if (checked != null) {
+    // Important to set this even if it's not a change in order to update input
+    // value tracking with radio buttons
+    // TODO: Should really update input value tracking for the whole radio
+    // button group in an effect or something (similar to #27024)
+    node.checked = checked && typeof checked !== 'function' && typeof checked !== 'symbol';
+  }
+
+  if (name != null && typeof name !== 'function' && typeof name !== 'symbol' && typeof name !== 'boolean') {
+
+    node.name = toString(getToStringValue(name));
+  } else {
+    node.removeAttribute('name');
+  }
+}
+function initInput(element, value, defaultValue, checked, defaultChecked, type, name, isHydrating) {
+  const node = element;
+
+  if (type != null && typeof type !== 'function' && typeof type !== 'symbol' && typeof type !== 'boolean') {
+
+    node.type = type;
+  }
+
+  if (value != null || defaultValue != null) {
+    const isButton = type === 'submit' || type === 'reset'; // Avoid setting value attribute on submit/reset inputs as it overrides the
+    // default value provided by the browser. See: #12872
+
+    if (isButton && (value === undefined || value === null)) {
+      return;
+    }
+
+    const defaultValueStr = defaultValue != null ? toString(getToStringValue(defaultValue)) : '';
+    const initialValue = value != null ? toString(getToStringValue(value)) : defaultValueStr; // Do not assign value if it is already set. This prevents user text input
+    // from being lost during SSR hydration.
+
+    if (!isHydrating) {
+      {
+        // When syncing the value attribute, the value property should use
+        // the wrapperState._initialValue property. This uses:
+        //
+        //   1. The value React property when present
+        //   2. The defaultValue React property when present
+        //   3. An empty string
+        if (initialValue !== node.value) {
+          node.value = initialValue;
+        }
+      }
+    }
+
+    {
+      // Otherwise, the value attribute is synchronized to the property,
+      // so we assign defaultValue to the same thing as the value property
+      // assignment step above.
+      node.defaultValue = initialValue;
+    }
+  } // Normally, we'd just do `node.checked = node.checked` upon initial mount, less this bug
+  // this is needed to work around a chrome bug where setting defaultChecked
+  // will sometimes influence the value of checked (even after detachment).
+  // Reference: https://bugs.chromium.org/p/chromium/issues/detail?id=608416
+  // We need to temporarily unset name to avoid disrupting radio button groups.
+
+
+  const checkedOrDefault = checked != null ? checked : defaultChecked; // TODO: This 'function' or 'symbol' check isn't replicated in other places
+  // so this semantic is inconsistent.
+
+  const initialChecked = typeof checkedOrDefault !== 'function' && typeof checkedOrDefault !== 'symbol' && !!checkedOrDefault;
+
+  if (isHydrating) {
+    // Detach .checked from .defaultChecked but leave user input alone
+    node.checked = node.checked;
+  } else {
+    node.checked = !!initialChecked;
+  }
+
+  {
+    // When syncing the checked attribute, both the checked property and
+    // attribute are assigned at the same time using defaultChecked. This uses:
+    //
+    //   1. The checked React property when present
+    //   2. The defaultChecked React property when present
+    //   3. Otherwise, false
+    node.defaultChecked = !node.defaultChecked;
+    node.defaultChecked = !!initialChecked;
+  } // Name needs to be set at the end so that it applies atomically to connected radio buttons.
+
+
+  if (name != null && typeof name !== 'function' && typeof name !== 'symbol' && typeof name !== 'boolean') {
+
+    node.name = name;
+  }
+}
+function restoreControlledInputState(element, props) {
+  const rootNode = element;
+  updateInput(rootNode, props.value, props.defaultValue, props.defaultValue, props.checked, props.defaultChecked, props.type, props.name);
+  const name = props.name;
+
+  if (props.type === 'radio' && name != null) {
+    let queryRoot = rootNode;
+
+    while (queryRoot.parentNode) {
+      queryRoot = queryRoot.parentNode;
+    } // If `rootNode.form` was non-null, then we could try `form.elements`,
+
+    const group = queryRoot.querySelectorAll('input[name="' + escapeSelectorAttributeValueInsideDoubleQuotes('' + name) + '"][type="radio"]');
+
+    for (let i = 0; i < group.length; i++) {
+      const otherNode = group[i];
+
+      if (otherNode === rootNode || otherNode.form !== rootNode.form) {
+        continue;
+      } // This will throw if radio buttons rendered by different copies of React
+      // and the same name are rendered into the same form (same as #1939).
+      // That's probably okay; we don't support it just as we don't support
+      // mixing React radio buttons with non-React ones.
+
+
+      const otherProps = getFiberCurrentPropsFromNode(otherNode);
+
+      if (!otherProps) {
+        throw Error(formatProdErrorMessage(90));
+      } // If this is a controlled radio button group, forcing the input that
+      // was previously checked to update will cause it to be come re-checked
+      // as appropriate.
+
+
+      updateInput(otherNode, otherProps.value, otherProps.defaultValue, otherProps.defaultValue, otherProps.checked, otherProps.defaultChecked, otherProps.type, otherProps.name);
+    } // If any updateInput() call set .checked to true, an input in this group
+    // (often, `rootNode` itself) may have become unchecked
+
+
+    for (let i = 0; i < group.length; i++) {
+      const otherNode = group[i];
+
+      if (otherNode.form !== rootNode.form) {
+        continue;
+      }
+
+      updateValueIfChanged(otherNode);
+    }
+  }
+} // In Chrome, assigning defaultValue to certain input types triggers input validation.
+// For number inputs, the display value loses trailing decimal points. For email inputs,
+// Chrome raises "The specified value <x> is not a valid email address".
+//
+// Here we check to see if the defaultValue has actually changed, avoiding these problems
+// when the user is inputting text
+//
+// https://github.com/facebook/react/issues/7253
+
+function setDefaultValue(node, type, value) {
+  if ( // Focused number inputs synchronize on blur. See ChangeEventPlugin.js
+  type !== 'number' || getActiveElement(node.ownerDocument) !== node) {
+    if (node.defaultValue !== toString(value)) {
+      node.defaultValue = toString(value);
+    }
+  }
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+// TODO: direct imports like some-package/src/* are bad. Fix me.
+
+function updateOptions(node, multiple, propValue, setDefaultSelected) {
+  const options = node.options;
+
+  if (multiple) {
+    const selectedValues = propValue;
+    const selectedValue = {};
+
+    for (let i = 0; i < selectedValues.length; i++) {
+      // Prefix to avoid chaos with special keys.
+      selectedValue['$' + selectedValues[i]] = true;
+    }
+
+    for (let i = 0; i < options.length; i++) {
+      const selected = selectedValue.hasOwnProperty('$' + options[i].value);
+
+      if (options[i].selected !== selected) {
+        options[i].selected = selected;
+      }
+
+      if (selected && setDefaultSelected) {
+        options[i].defaultSelected = true;
+      }
+    }
+  } else {
+    // Do not set `select.value` as exact behavior isn't consistent across all
+    // browsers for all cases.
+    const selectedValue = toString(getToStringValue(propValue));
+    let defaultSelected = null;
+
+    for (let i = 0; i < options.length; i++) {
+      if (options[i].value === selectedValue) {
+        options[i].selected = true;
+
+        if (setDefaultSelected) {
+          options[i].defaultSelected = true;
+        }
+
+        return;
+      }
+
+      if (defaultSelected === null && !options[i].disabled) {
+        defaultSelected = options[i];
+      }
+    }
+
+    if (defaultSelected !== null) {
+      defaultSelected.selected = true;
+    }
+  }
+}
+function initSelect(element, value, defaultValue, multiple) {
+  const node = element;
+  node.multiple = !!multiple;
+
+  if (value != null) {
+    updateOptions(node, !!multiple, value, false);
+  } else if (defaultValue != null) {
+    updateOptions(node, !!multiple, defaultValue, true);
+  }
+}
+function updateSelect(element, value, defaultValue, multiple, wasMultiple) {
+  const node = element;
+
+  if (value != null) {
+    updateOptions(node, !!multiple, value, false);
+  } else if (!!wasMultiple !== !!multiple) {
+    // For simplicity, reapply `defaultValue` if `multiple` is toggled.
+    if (defaultValue != null) {
+      updateOptions(node, !!multiple, defaultValue, true);
+    } else {
+      // Revert the select back to its default unselected state.
+      updateOptions(node, !!multiple, multiple ? [] : '', false);
+    }
+  }
+}
+function restoreControlledSelectState(element, props) {
+  const node = element;
+  const value = props.value;
+
+  if (value != null) {
+    updateOptions(node, !!props.multiple, value, false);
+  }
+}
+
+function updateTextarea(element, value, defaultValue) {
+  const node = element;
+
+  if (value != null) {
+    // Cast `value` to a string to ensure the value is set correctly. While
+    // browsers typically do this as necessary, jsdom doesn't.
+    const newValue = toString(getToStringValue(value)); // To avoid side effects (such as losing text selection), only set value if changed
+
+    if (newValue !== node.value) {
+      node.value = newValue;
+    } // TOOO: This should respect disableInputAttributeSyncing flag.
+
+
+    if (defaultValue == null) {
+      if (node.defaultValue !== newValue) {
+        node.defaultValue = newValue;
+      }
+
+      return;
+    }
+  }
+
+  if (defaultValue != null) {
+    node.defaultValue = toString(getToStringValue(defaultValue));
+  } else {
+    node.defaultValue = '';
+  }
+}
+function initTextarea(element, value, defaultValue, children) {
+  const node = element;
+  let initialValue = value; // Only bother fetching default value if we're going to use it
+
+  if (initialValue == null) {
+    if (children != null) {
+      {
+        if (defaultValue != null) {
+          throw Error(formatProdErrorMessage(92));
+        }
+
+        if (isArray(children)) {
+          if (children.length > 1) {
+            throw Error(formatProdErrorMessage(93));
+          }
+
+          children = children[0];
+        }
+
+        defaultValue = children;
+      }
+    }
+
+    if (defaultValue == null) {
+      defaultValue = '';
+    }
+
+    initialValue = defaultValue;
+  }
+
+  const stringValue = getToStringValue(initialValue);
+  node.defaultValue = stringValue; // This will be toString:ed.
+  // This is in postMount because we need access to the DOM node, which is not
+  // available until after the component has mounted.
+
+  const textContent = node.textContent; // Only set node.value if textContent is equal to the expected
+  // initial value. In IE10/IE11 there is a bug where the placeholder attribute
+  // will populate textContent as well.
+  // https://developer.microsoft.com/microsoft-edge/platform/issues/101525/
+
+  if (textContent === stringValue) {
+    if (textContent !== '' && textContent !== null) {
+      node.value = textContent;
+    }
+  }
+}
+function restoreControlledTextareaState(element, props) {
+  // DOM component is still mounted; update
+  updateTextarea(element, props.value, props.defaultValue);
+}
+
+const MATH_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
+const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
+
+/* globals MSApp */
+
+if (typeof MSApp !== 'undefined' && MSApp.execUnsafeLocalFunction) ;
+
+/**
+ * HTML nodeType values that represent the type of the node
+ */
+const ELEMENT_NODE = 1;
+const TEXT_NODE = 3;
+const COMMENT_NODE = 8;
+const DOCUMENT_NODE = 9;
+const DOCUMENT_TYPE_NODE = 10;
+const DOCUMENT_FRAGMENT_NODE = 11;
+
+/**
+ * Set the textContent property of a node. For text updates, it's faster
+ * to set the `nodeValue` of the Text node directly instead of using
+ * `.textContent` which will remove the existing node and create a new one.
+ *
+ * @param {DOMElement} node
+ * @param {string} text
+ * @internal
+ */
+
+function setTextContent(node, text) {
+  if (text) {
+    const firstChild = node.firstChild;
+
+    if (firstChild && firstChild === node.lastChild && firstChild.nodeType === TEXT_NODE) {
+      firstChild.nodeValue = text;
+      return;
+    }
+  }
+
+  node.textContent = text;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+const unitlessNumbers = new Set(['animationIterationCount', 'aspectRatio', 'borderImageOutset', 'borderImageSlice', 'borderImageWidth', 'boxFlex', 'boxFlexGroup', 'boxOrdinalGroup', 'columnCount', 'columns', 'flex', 'flexGrow', 'flexPositive', 'flexShrink', 'flexNegative', 'flexOrder', 'gridArea', 'gridRow', 'gridRowEnd', 'gridRowSpan', 'gridRowStart', 'gridColumn', 'gridColumnEnd', 'gridColumnSpan', 'gridColumnStart', 'fontWeight', 'lineClamp', 'lineHeight', 'opacity', 'order', 'orphans', 'scale', 'tabSize', 'widows', 'zIndex', 'zoom', 'fillOpacity', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'MozBoxFlexGroup', 'MozLineClamp', 'msAnimationIterationCount', 'msFlex', 'msZoom', 'msFlexGrow', 'msFlexNegative', 'msFlexOrder', 'msFlexPositive', 'msFlexShrink', 'msGridColumn', 'msGridColumnSpan', 'msGridRow', 'msGridRowSpan', 'WebkitAnimationIterationCount', 'WebkitBoxFlex', 'WebKitBoxFlexGroup', 'WebkitBoxOrdinalGroup', 'WebkitColumnCount', 'WebkitColumns', 'WebkitFlex', 'WebkitFlexGrow', 'WebkitFlexPositive', 'WebkitFlexShrink', 'WebkitLineClamp']);
+function isUnitlessNumber (name) {
+  return unitlessNumbers.has(name);
+}
+
+function setValueForStyle(style, styleName, value) {
+  const isCustomProperty = styleName.indexOf('--') === 0;
+
+  if (value == null || typeof value === 'boolean' || value === '') {
+    if (isCustomProperty) {
+      style.setProperty(styleName, '');
+    } else if (styleName === 'float') {
+      style.cssFloat = '';
+    } else {
+      style[styleName] = '';
+    }
+  } else if (isCustomProperty) {
+    style.setProperty(styleName, value);
+  } else if (typeof value === 'number' && value !== 0 && !isUnitlessNumber(styleName)) {
+    style[styleName] = value + 'px'; // Presumes implicit 'px' suffix for unitless numbers
+  } else {
+    if (styleName === 'float') {
+      style.cssFloat = value;
+    } else {
+
+      style[styleName] = ('' + value).trim();
+    }
+  }
+}
+/**
+ * Sets the value for multiple styles on a node.  If a value is specified as
+ * '' (empty string), the corresponding style property will be unset.
+ *
+ * @param {DOMElement} node
+ * @param {object} styles
+ */
+
+
+function setValueForStyles(node, styles, prevStyles) {
+  if (styles != null && typeof styles !== 'object') {
+    throw Error(formatProdErrorMessage(62));
+  }
+
+  const style = node.style;
+
+  if (prevStyles != null) {
+
+    for (const styleName in prevStyles) {
+      if (prevStyles.hasOwnProperty(styleName) && (styles == null || !styles.hasOwnProperty(styleName))) {
+        // Clear style
+        const isCustomProperty = styleName.indexOf('--') === 0;
+
+        if (isCustomProperty) {
+          style.setProperty(styleName, '');
+        } else if (styleName === 'float') {
+          style.cssFloat = '';
+        } else {
+          style[styleName] = '';
+        }
+      }
+    }
+
+    for (const styleName in styles) {
+      const value = styles[styleName];
+
+      if (styles.hasOwnProperty(styleName) && prevStyles[styleName] !== value) {
+        setValueForStyle(style, styleName, value);
+      }
+    }
+  } else {
+    for (const styleName in styles) {
+      if (styles.hasOwnProperty(styleName)) {
+        const value = styles[styleName];
+        setValueForStyle(style, styleName, value);
+      }
+    }
+  }
+}
+
+function isCustomElement(tagName, props) {
+  if (tagName.indexOf('-') === -1) {
+    return false;
+  }
+
+  switch (tagName) {
+    // These are reserved SVG and MathML elements.
+    // We don't mind this list too much because we expect it to never grow.
+    // The alternative is to track the namespace in a few places which is convoluted.
+    // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+    case 'annotation-xml':
+    case 'color-profile':
+    case 'font-face':
+    case 'font-face-src':
+    case 'font-face-uri':
+    case 'font-face-format':
+    case 'font-face-name':
+    case 'missing-glyph':
+      return false;
+
+    default:
+      return true;
+  }
+}
+
+const aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+  return aliases.get(name) || name;
+}
+
+function sanitizeURL(url) {
+
+  return url;
+}
+
+const IS_EVENT_HANDLE_NON_MANAGED_NODE = 1;
+const IS_NON_DELEGATED = 1 << 1;
+const IS_CAPTURE_PHASE = 1 << 2;
+// 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.
+// We also don't want to defer during event replaying.
+
+const SHOULD_NOT_PROCESS_POLYFILL_EVENT_PLUGINS = IS_EVENT_HANDLE_NON_MANAGED_NODE | IS_NON_DELEGATED | IS_CAPTURE_PHASE;
+
+// This exists to avoid circular dependency between ReactDOMEventReplaying
+// and DOMPluginEventSystem.
+let currentReplayingEvent = null;
+function setReplayingEvent(event) {
+
+  currentReplayingEvent = event;
+}
+function resetReplayingEvent() {
+
+  currentReplayingEvent = null;
+}
+function isReplayingEvent(event) {
+  return event === currentReplayingEvent;
+}
+
+/**
+ * Gets the target node from a native browser event by accounting for
+ * inconsistencies in browser DOM APIs.
+ *
+ * @param {object} nativeEvent Native browser event.
+ * @return {DOMEventTarget} Target node.
+ */
+
+function getEventTarget(nativeEvent) {
+  // Fallback to nativeEvent.srcElement for IE9
+  // https://github.com/facebook/react/issues/12506
+  let target = nativeEvent.target || nativeEvent.srcElement || window; // Normalize SVG <use> element events #4963
+
+  if (target.correspondingUseElement) {
+    target = target.correspondingUseElement;
+  } // Safari may fire events on text nodes (Node.TEXT_NODE is 3).
+  // @see http://www.quirksmode.org/js/events_properties.html
+
+
+  return target.nodeType === TEXT_NODE ? target.parentNode : target;
+}
+
+let restoreTarget = null;
+let restoreQueue = null;
+
+function restoreStateOfTarget(target) {
+  // We perform this translation at the end of the event loop so that we
+  // always receive the correct fiber here
+  const internalInstance = getInstanceFromNode$1(target);
+
+  if (!internalInstance) {
+    // Unmounted
+    return;
+  }
+
+  const stateNode = internalInstance.stateNode; // Guard against Fiber being unmounted.
+
+  if (stateNode) {
+    const props = getFiberCurrentPropsFromNode(stateNode);
+    restoreControlledState(internalInstance.stateNode, internalInstance.type, props);
+  }
+}
+
+function enqueueStateRestore(target) {
+  if (restoreTarget) {
+    if (restoreQueue) {
+      restoreQueue.push(target);
+    } else {
+      restoreQueue = [target];
+    }
+  } else {
+    restoreTarget = target;
+  }
+}
+function needsStateRestore() {
+  return restoreTarget !== null || restoreQueue !== null;
+}
+function restoreStateIfNeeded() {
+  if (!restoreTarget) {
+    return;
+  }
+
+  const target = restoreTarget;
+  const queuedTargets = restoreQueue;
+  restoreTarget = null;
+  restoreQueue = null;
+  restoreStateOfTarget(target);
+
+  if (queuedTargets) {
+    for (let i = 0; i < queuedTargets.length; i++) {
+      restoreStateOfTarget(queuedTargets[i]);
+    }
+  }
+}
+
+/**
+ * `ReactInstanceMap` maintains a mapping from a public facing stateful
+ * instance (key) and the internal representation (value). This allows public
+ * methods to accept the user facing instance as an argument and map them back
+ * to internal methods.
+ *
+ * Note that this module is currently shared and assumed to be stateless.
+ * If this becomes an actual Map, that will break.
+ */
+function get(key) {
+  return key._reactInternals;
+}
+function has(key) {
+  return key._reactInternals !== undefined;
+}
+function set(key, value) {
+  key._reactInternals = value;
+}
+
+function getNearestMountedFiber(fiber) {
+  let node = fiber;
+  let nearestMounted = fiber;
+
+  if (!fiber.alternate) {
+    // If there is no alternate, this might be a new tree that isn't inserted
+    // yet. If it is, then it will have a pending insertion effect on it.
+    let nextNode = node;
+
+    do {
+      node = nextNode;
+
+      if ((node.flags & (Placement | Hydrating)) !== NoFlags$1) {
+        // This is an insertion or in-progress hydration. The nearest possible
+        // mounted fiber is the parent but we need to continue to figure out
+        // if that one is still mounted.
+        nearestMounted = node.return;
+      } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+      nextNode = node.return;
+    } while (nextNode);
+  } else {
+    while (node.return) {
+      node = node.return;
+    }
+  }
+
+  if (node.tag === HostRoot) {
+    // TODO: Check if this was a nested HostRoot when used with
+    // renderContainerIntoSubtree.
+    return nearestMounted;
+  } // If we didn't hit the root, that means that we're in an disconnected tree
+  // that has been unmounted.
+
+
+  return null;
+}
+function getSuspenseInstanceFromFiber(fiber) {
+  if (fiber.tag === SuspenseComponent) {
+    let suspenseState = fiber.memoizedState;
+
+    if (suspenseState === null) {
+      const current = fiber.alternate;
+
+      if (current !== null) {
+        suspenseState = current.memoizedState;
+      }
+    }
+
+    if (suspenseState !== null) {
+      return suspenseState.dehydrated;
+    }
+  }
+
+  return null;
+}
+function getContainerFromFiber(fiber) {
+  return fiber.tag === HostRoot ? fiber.stateNode.containerInfo : null;
+}
+function isFiberMounted(fiber) {
+  return getNearestMountedFiber(fiber) === fiber;
+}
+function isMounted(component) {
+
+  const fiber = get(component);
+
+  if (!fiber) {
+    return false;
+  }
+
+  return getNearestMountedFiber(fiber) === fiber;
+}
+
+function assertIsMounted(fiber) {
+  if (getNearestMountedFiber(fiber) !== fiber) {
+    throw Error(formatProdErrorMessage(188));
+  }
+}
+
+function findCurrentFiberUsingSlowPath(fiber) {
+  const alternate = fiber.alternate;
+
+  if (!alternate) {
+    // If there is no alternate, then we only need to check if it is mounted.
+    const nearestMounted = getNearestMountedFiber(fiber);
+
+    if (nearestMounted === null) {
+      throw Error(formatProdErrorMessage(188));
+    }
+
+    if (nearestMounted !== fiber) {
+      return null;
+    }
+
+    return fiber;
+  } // If we have two possible branches, we'll walk backwards up to the root
+  // to see what path the root points to. On the way we may hit one of the
+  // special cases and we'll deal with them.
+
+
+  let a = fiber;
+  let b = alternate;
+
+  while (true) {
+    const parentA = a.return;
+
+    if (parentA === null) {
+      // We're at the root.
+      break;
+    }
+
+    const parentB = parentA.alternate;
+
+    if (parentB === null) {
+      // There is no alternate. This is an unusual case. Currently, it only
+      // happens when a Suspense component is hidden. An extra fragment fiber
+      // is inserted in between the Suspense fiber and its children. Skip
+      // over this extra fragment fiber and proceed to the next parent.
+      const nextParent = parentA.return;
+
+      if (nextParent !== null) {
+        a = b = nextParent;
+        continue;
+      } // If there's no parent, we're at the root.
+
+
+      break;
+    } // If both copies of the parent fiber point to the same child, we can
+    // assume that the child is current. This happens when we bailout on low
+    // priority: the bailed out fiber's child reuses the current child.
+
+
+    if (parentA.child === parentB.child) {
+      let child = parentA.child;
+
+      while (child) {
+        if (child === a) {
+          // We've determined that A is the current branch.
+          assertIsMounted(parentA);
+          return fiber;
+        }
+
+        if (child === b) {
+          // We've determined that B is the current branch.
+          assertIsMounted(parentA);
+          return alternate;
+        }
+
+        child = child.sibling;
+      } // We should never have an alternate for any mounting node. So the only
+      // way this could possibly happen is if this was unmounted, if at all.
+
+
+      throw Error(formatProdErrorMessage(188));
+    }
+
+    if (a.return !== b.return) {
+      // The return pointer of A and the return pointer of B point to different
+      // fibers. We assume that return pointers never criss-cross, so A must
+      // belong to the child set of A.return, and B must belong to the child
+      // set of B.return.
+      a = parentA;
+      b = parentB;
+    } else {
+      // The return pointers point to the same fiber. We'll have to use the
+      // default, slow path: scan the child sets of each parent alternate to see
+      // which child belongs to which set.
+      //
+      // Search parent A's child set
+      let didFindChild = false;
+      let child = parentA.child;
+
+      while (child) {
+        if (child === a) {
+          didFindChild = true;
+          a = parentA;
+          b = parentB;
+          break;
+        }
+
+        if (child === b) {
+          didFindChild = true;
+          b = parentA;
+          a = parentB;
+          break;
+        }
+
+        child = child.sibling;
+      }
+
+      if (!didFindChild) {
+        // Search parent B's child set
+        child = parentB.child;
+
+        while (child) {
+          if (child === a) {
+            didFindChild = true;
+            a = parentB;
+            b = parentA;
+            break;
+          }
+
+          if (child === b) {
+            didFindChild = true;
+            b = parentB;
+            a = parentA;
+            break;
+          }
+
+          child = child.sibling;
+        }
+
+        if (!didFindChild) {
+          throw Error(formatProdErrorMessage(189));
+        }
+      }
+    }
+
+    if (a.alternate !== b) {
+      throw Error(formatProdErrorMessage(190));
+    }
+  } // If the root is not a host container, we're in a disconnected tree. I.e.
+  // unmounted.
+
+
+  if (a.tag !== HostRoot) {
+    throw Error(formatProdErrorMessage(188));
+  }
+
+  if (a.stateNode.current === a) {
+    // We've determined that A is the current branch.
+    return fiber;
+  } // Otherwise B has to be current branch.
+
+
+  return alternate;
+}
+function findCurrentHostFiber(parent) {
+  const currentParent = findCurrentFiberUsingSlowPath(parent);
+  return currentParent !== null ? findCurrentHostFiberImpl(currentParent) : null;
+}
+
+function findCurrentHostFiberImpl(node) {
+  // Next we'll drill down this component to find the first HostComponent/Text.
+  const tag = node.tag;
+
+  if (tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton ) || tag === HostText) {
+    return node;
+  }
+
+  let child = node.child;
+
+  while (child !== null) {
+    const match = findCurrentHostFiberImpl(child);
+
+    if (match !== null) {
+      return match;
+    }
+
+    child = child.sibling;
+  }
+
+  return null;
+}
+
+const emptyContextObject = {};
+
+
+const contextStackCursor = createCursor(emptyContextObject); // A cursor to a boolean indicating whether the context has changed.
+
+const didPerformWorkStackCursor = createCursor(false); // Keep track of the previous context object that was on the stack.
+// We use this to get access to the parent context after we have already
+// pushed the next context provider, and now need to merge their contexts.
+
+let previousContext = emptyContextObject;
+
+function getUnmaskedContext(workInProgress, Component, didPushOwnContextIfProvider) {
+  {
+    if (didPushOwnContextIfProvider && isContextProvider(Component)) {
+      // If the fiber is a context provider itself, when we read its context
+      // we may have already pushed its own child context on the stack. A context
+      // provider should not "see" its own child context. Therefore we read the
+      // previous (parent) context instead for a context provider.
+      return previousContext;
+    }
+
+    return contextStackCursor.current;
+  }
+}
+
+function cacheContext(workInProgress, unmaskedContext, maskedContext) {
+  {
+    const instance = workInProgress.stateNode;
+    instance.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext;
+    instance.__reactInternalMemoizedMaskedChildContext = maskedContext;
+  }
+}
+
+function getMaskedContext(workInProgress, unmaskedContext) {
+  {
+    const type = workInProgress.type;
+    const contextTypes = type.contextTypes;
+
+    if (!contextTypes) {
+      return emptyContextObject;
+    } // Avoid recreating masked context unless unmasked context has changed.
+    // Failing to do this will result in unnecessary calls to componentWillReceiveProps.
+    // This may trigger infinite loops if componentWillReceiveProps calls setState.
+
+
+    const instance = workInProgress.stateNode;
+
+    if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) {
+      return instance.__reactInternalMemoizedMaskedChildContext;
+    }
+
+    const context = {};
+
+    for (const key in contextTypes) {
+      context[key] = unmaskedContext[key];
+    }
+    // Context is created before the class component is instantiated so check for instance.
+
+
+    if (instance) {
+      cacheContext(workInProgress, unmaskedContext, context);
+    }
+
+    return context;
+  }
+}
+
+function hasContextChanged() {
+  {
+    return didPerformWorkStackCursor.current;
+  }
+}
+
+function isContextProvider(type) {
+  {
+    const childContextTypes = type.childContextTypes;
+    return childContextTypes !== null && childContextTypes !== undefined;
+  }
+}
+
+function popContext(fiber) {
+  {
+    pop(didPerformWorkStackCursor);
+    pop(contextStackCursor);
+  }
+}
+
+function popTopLevelContextObject(fiber) {
+  {
+    pop(didPerformWorkStackCursor);
+    pop(contextStackCursor);
+  }
+}
+
+function pushTopLevelContextObject(fiber, context, didChange) {
+  {
+    if (contextStackCursor.current !== emptyContextObject) {
+      throw Error(formatProdErrorMessage(168));
+    }
+
+    push(contextStackCursor, context);
+    push(didPerformWorkStackCursor, didChange);
+  }
+}
+
+function processChildContext(fiber, type, parentContext) {
+  {
+    const instance = fiber.stateNode;
+    const childContextTypes = type.childContextTypes; // TODO (bvaughn) Replace this behavior with an invariant() in the future.
+    // It has only been added in Fiber to match the (unintentional) behavior in Stack.
+
+    if (typeof instance.getChildContext !== 'function') {
+
+      return parentContext;
+    }
+
+    const childContext = instance.getChildContext();
+
+    for (const contextKey in childContext) {
+      if (!(contextKey in childContextTypes)) {
+        throw Error(formatProdErrorMessage(108, getComponentNameFromFiber(fiber) || 'Unknown', contextKey));
+      }
+    }
+
+    return assign({}, parentContext, childContext);
+  }
+}
+
+function pushContextProvider(workInProgress) {
+  {
+    const instance = workInProgress.stateNode; // We push the context as early as possible to ensure stack integrity.
+    // If the instance does not exist yet, we will push null at first,
+    // and replace it on the stack later when invalidating the context.
+
+    const memoizedMergedChildContext = instance && instance.__reactInternalMemoizedMergedChildContext || emptyContextObject; // Remember the parent context so we can merge with it later.
+    // Inherit the parent's did-perform-work value to avoid inadvertently blocking updates.
+
+    previousContext = contextStackCursor.current;
+    push(contextStackCursor, memoizedMergedChildContext);
+    push(didPerformWorkStackCursor, didPerformWorkStackCursor.current);
+    return true;
+  }
+}
+
+function invalidateContextProvider(workInProgress, type, didChange) {
+  {
+    const instance = workInProgress.stateNode;
+
+    if (!instance) {
+      throw Error(formatProdErrorMessage(169));
+    }
+
+    if (didChange) {
+      // Merge parent and own context.
+      // Skip this if we're not updating due to sCU.
+      // This avoids unnecessarily recomputing memoized values.
+      const mergedContext = processChildContext(workInProgress, type, previousContext);
+      instance.__reactInternalMemoizedMergedChildContext = mergedContext; // Replace the old (or empty) context with the new one.
+      // It is important to unwind the context in the reverse order.
+
+      pop(didPerformWorkStackCursor);
+      pop(contextStackCursor); // Now push the new context and mark that it has changed.
+
+      push(contextStackCursor, mergedContext);
+      push(didPerformWorkStackCursor, didChange);
+    } else {
+      pop(didPerformWorkStackCursor);
+      push(didPerformWorkStackCursor, didChange);
+    }
+  }
+}
+
+function findCurrentUnmaskedContext(fiber) {
+  {
+    // Currently this is only used with renderSubtreeIntoContainer; not sure if it
+    // makes sense elsewhere
+    if (!isFiberMounted(fiber) || fiber.tag !== ClassComponent) {
+      throw Error(formatProdErrorMessage(170));
+    }
+
+    let node = fiber;
+
+    do {
+      switch (node.tag) {
+        case HostRoot:
+          return node.stateNode.context;
+
+        case ClassComponent:
+          {
+            const Component = node.type;
+
+            if (isContextProvider(Component)) {
+              return node.stateNode.__reactInternalMemoizedMergedChildContext;
+            }
+
+            break;
+          }
+      } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+      node = node.return;
+    } while (node !== null);
+
+    throw Error(formatProdErrorMessage(171));
+  }
+}
+
+const LegacyRoot = 0;
+const ConcurrentRoot = 1;
+
+// We use the existence of the state object as an indicator that the component
+// is hidden.
+const OffscreenVisible =
+/*                     */
+0b001;
+const OffscreenDetached =
+/*                    */
+0b010;
+const OffscreenPassiveEffectsConnected =
+/*     */
+0b100;
+function isOffscreenManual(offscreenFiber) {
+  return offscreenFiber.memoizedProps !== null && offscreenFiber.memoizedProps.mode === 'manual';
+}
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+
+const objectIs = // $FlowFixMe[method-unbinding]
+typeof Object.is === 'function' ? Object.is : is;
+
+// This is imported by the event replaying implementation in React DOM. It's
+// in a separate file to break a circular dependency between the renderer and
+// the reconciler.
+function isRootDehydrated(root) {
+  const currentState = root.current.memoizedState;
+  return currentState.isDehydrated;
+}
+
+// Ids are base 32 strings whose binary representation corresponds to the
+// 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.
+
+const forkStack = [];
+let forkStackIndex = 0;
+let treeForkProvider = null;
+let treeForkCount = 0;
+const idStack = [];
+let idStackIndex = 0;
+let treeContextProvider = null;
+let treeContextId = 1;
+let treeContextOverflow = '';
+function isForkedChild(workInProgress) {
+  return (workInProgress.flags & Forked) !== NoFlags$1;
+}
+function getForksAtLevel(workInProgress) {
+  return treeForkCount;
+}
+function getTreeId() {
+  const overflow = treeContextOverflow;
+  const idWithLeadingBit = treeContextId;
+  const id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
+  return id.toString(32) + overflow;
+}
+function pushTreeFork(workInProgress, totalChildren) {
+  forkStack[forkStackIndex++] = treeForkCount;
+  forkStack[forkStackIndex++] = treeForkProvider;
+  treeForkProvider = workInProgress;
+  treeForkCount = totalChildren;
+}
+function pushTreeId(workInProgress, totalChildren, index) {
+  idStack[idStackIndex++] = treeContextId;
+  idStack[idStackIndex++] = treeContextOverflow;
+  idStack[idStackIndex++] = treeContextProvider;
+  treeContextProvider = workInProgress;
+  const baseIdWithLeadingBit = treeContextId;
+  const baseOverflow = treeContextOverflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
+  // of the id; we use it to account for leading 0s.
+
+  const baseLength = getBitLength(baseIdWithLeadingBit) - 1;
+  const baseId = baseIdWithLeadingBit & ~(1 << baseLength);
+  const slot = index + 1;
+  const length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
+  // consideration the leading 1 we use to mark the end of the sequence.
+
+  if (length > 30) {
+    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
+    // This branch assumes the length of the base id is greater than 5; it won't
+    // work for smaller ids, because you need 5 bits per character.
+    //
+    // We encode the id in multiple steps: first the base id, then the
+    // remaining digits.
+    //
+    // Each 5 bit sequence corresponds to a single base 32 character. So for
+    // example, if the current id is 23 bits long, we can convert 20 of those
+    // bits into a string of 4 characters, with 3 bits left over.
+    //
+    // First calculate how many bits in the base id represent a complete
+    // sequence of characters.
+    const numberOfOverflowBits = baseLength - baseLength % 5; // Then create a bitmask that selects only those bits.
+
+    const newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
+
+    const newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
+
+    const restOfBaseId = baseId >> numberOfOverflowBits;
+    const restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
+    // we made more room, this time it won't overflow.
+
+    const restOfLength = getBitLength(totalChildren) + restOfBaseLength;
+    const restOfNewBits = slot << restOfBaseLength;
+    const id = restOfNewBits | restOfBaseId;
+    const overflow = newOverflow + baseOverflow;
+    treeContextId = 1 << restOfLength | id;
+    treeContextOverflow = overflow;
+  } else {
+    // Normal path
+    const newBits = slot << baseLength;
+    const id = newBits | baseId;
+    const overflow = baseOverflow;
+    treeContextId = 1 << length | id;
+    treeContextOverflow = overflow;
+  }
+}
+function pushMaterializedTreeId(workInProgress) {
+  // in its children.
+
+  const returnFiber = workInProgress.return;
+
+  if (returnFiber !== null) {
+    const numberOfForks = 1;
+    const slotIndex = 0;
+    pushTreeFork(workInProgress, numberOfForks);
+    pushTreeId(workInProgress, numberOfForks, slotIndex);
+  }
+}
+
+function getBitLength(number) {
+  return 32 - clz32(number);
+}
+
+function getLeadingBit(id) {
+  return 1 << getBitLength(id) - 1;
+}
+
+function popTreeContext(workInProgress) {
+  // Restore the previous values.
+  // This is a bit more complicated than other context-like modules in Fiber
+  // because the same Fiber may appear on the stack multiple times and for
+  // different reasons. We have to keep popping until the work-in-progress is
+  // no longer at the top of the stack.
+  while (workInProgress === treeForkProvider) {
+    treeForkProvider = forkStack[--forkStackIndex];
+    forkStack[forkStackIndex] = null;
+    treeForkCount = forkStack[--forkStackIndex];
+    forkStack[forkStackIndex] = null;
+  }
+
+  while (workInProgress === treeContextProvider) {
+    treeContextProvider = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+    treeContextOverflow = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+    treeContextId = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+  }
+}
+function getSuspendedTreeContext() {
+
+  if (treeContextProvider !== null) {
+    return {
+      id: treeContextId,
+      overflow: treeContextOverflow
+    };
+  } else {
+    return null;
+  }
+}
+function restoreSuspendedTreeContext(workInProgress, suspendedContext) {
+  idStack[idStackIndex++] = treeContextId;
+  idStack[idStackIndex++] = treeContextOverflow;
+  idStack[idStackIndex++] = treeContextProvider;
+  treeContextId = suspendedContext.id;
+  treeContextOverflow = suspendedContext.overflow;
+  treeContextProvider = workInProgress;
+}
+
+// This may have been an insertion or a hydration.
+
+let hydrationParentFiber = null;
+let nextHydratableInstance = null;
+let isHydrating = false; // This flag allows for warning supression when we expect there to be mismatches
+
+let hydrationErrors = null;
+let rootOrSingletonContext = false;
+
+function enterHydrationState(fiber) {
+
+  const parentInstance = fiber.stateNode.containerInfo;
+  nextHydratableInstance = getFirstHydratableChildWithinContainer(parentInstance);
+  hydrationParentFiber = fiber;
+  isHydrating = true;
+  hydrationErrors = null;
+  rootOrSingletonContext = true;
+  return true;
+}
+
+function reenterHydrationStateFromDehydratedSuspenseInstance(fiber, suspenseInstance, treeContext) {
+
+  nextHydratableInstance = getFirstHydratableChildWithinSuspenseInstance(suspenseInstance);
+  hydrationParentFiber = fiber;
+  isHydrating = true;
+  hydrationErrors = null;
+  rootOrSingletonContext = false;
+
+  if (treeContext !== null) {
+    restoreSuspendedTreeContext(fiber, treeContext);
+  }
+
+  return true;
+}
+
+function deleteHydratableInstance(returnFiber, instance) {
+  const childToDelete = createFiberFromHostInstanceForDeletion();
+  childToDelete.stateNode = instance;
+  childToDelete.return = returnFiber;
+  const deletions = returnFiber.deletions;
+
+  if (deletions === null) {
+    returnFiber.deletions = [childToDelete];
+    returnFiber.flags |= ChildDeletion;
+  } else {
+    deletions.push(childToDelete);
+  }
+}
+
+function insertNonHydratedInstance(returnFiber, fiber) {
+  fiber.flags = fiber.flags & ~Hydrating | Placement;
+}
+
+function tryHydrateInstance(fiber, nextInstance) {
+  // fiber is a HostComponent Fiber
+  const instance = canHydrateInstance(nextInstance, fiber.type, fiber.pendingProps, rootOrSingletonContext);
+
+  if (instance !== null) {
+    fiber.stateNode = instance;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = getFirstHydratableChild(instance);
+    rootOrSingletonContext = false;
+    return true;
+  }
+
+  return false;
+}
+
+function tryHydrateText(fiber, nextInstance) {
+  // fiber is a HostText Fiber
+  const text = fiber.pendingProps;
+  const textInstance = canHydrateTextInstance(nextInstance, text, rootOrSingletonContext);
+
+  if (textInstance !== null) {
+    fiber.stateNode = textInstance;
+    hydrationParentFiber = fiber; // Text Instances don't have children so there's nothing to hydrate.
+
+    nextHydratableInstance = null;
+    return true;
+  }
+
+  return false;
+}
+
+function tryHydrateSuspense(fiber, nextInstance) {
+  // fiber is a SuspenseComponent Fiber
+  const suspenseInstance = canHydrateSuspenseInstance(nextInstance, rootOrSingletonContext);
+
+  if (suspenseInstance !== null) {
+    const suspenseState = {
+      dehydrated: suspenseInstance,
+      treeContext: getSuspendedTreeContext(),
+      retryLane: OffscreenLane
+    };
+    fiber.memoizedState = suspenseState; // Store the dehydrated fragment as a child fiber.
+    // This simplifies the code for getHostSibling and deleting nodes,
+    // since it doesn't have to consider all Suspense boundaries and
+    // check if they're dehydrated ones or not.
+
+    const dehydratedFragment = createFiberFromDehydratedFragment(suspenseInstance);
+    dehydratedFragment.return = fiber;
+    fiber.child = dehydratedFragment;
+    hydrationParentFiber = fiber; // While a Suspense Instance does have children, we won't step into
+    // it during the first pass. Instead, we'll reenter it later.
+
+    nextHydratableInstance = null;
+    return true;
+  }
+
+  return false;
+}
+
+function shouldClientRenderOnMismatch(fiber) {
+  return (fiber.mode & ConcurrentMode) !== NoMode && (fiber.flags & DidCapture) === NoFlags$1;
+}
+
+function throwOnHydrationMismatch(fiber) {
+  throw Error(formatProdErrorMessage(418));
+}
+
+function claimHydratableSingleton(fiber) {
+  {
+    if (!isHydrating) {
+      return;
+    }
+
+    const currentRootContainer = getRootHostContainer();
+    const instance = fiber.stateNode = resolveSingletonInstance(fiber.type, fiber.pendingProps, currentRootContainer);
+    hydrationParentFiber = fiber;
+    rootOrSingletonContext = true;
+    nextHydratableInstance = getFirstHydratableChild(instance);
+  }
+}
+
+function tryToClaimNextHydratableInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
+
+  const initialInstance = nextHydratableInstance;
+  const nextInstance = nextHydratableInstance;
+
+  if (!nextInstance) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
+
+
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
+    return;
+  }
+
+  const firstAttemptedInstance = nextInstance;
+
+  if (!tryHydrateInstance(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
+
+
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    const prevHydrationParentFiber = hydrationParentFiber;
+
+    if (!nextHydratableInstance || !tryHydrateInstance(fiber, nextHydratableInstance)) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
+
+
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+  }
+}
+
+function tryToClaimNextHydratableTextInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
+
+  const text = fiber.pendingProps;
+  const isHydratable = isHydratableText(text);
+  const initialInstance = nextHydratableInstance;
+  const nextInstance = nextHydratableInstance;
+
+  if (!nextInstance || !isHydratable) {
+    // We exclude non hydrabable text because we know there are no matching hydratables.
+    // We either throw or insert depending on the render mode.
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
+
+
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
+    return;
+  }
+
+  const firstAttemptedInstance = nextInstance;
+
+  if (!tryHydrateText(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
+
+
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    const prevHydrationParentFiber = hydrationParentFiber;
+
+    if (!nextHydratableInstance || !tryHydrateText(fiber, nextHydratableInstance)) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
+
+
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+  }
+}
+
+function tryToClaimNextHydratableSuspenseInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
+
+  const initialInstance = nextHydratableInstance;
+  const nextInstance = nextHydratableInstance;
+
+  if (!nextInstance) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
+
+
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
+    return;
+  }
+
+  const firstAttemptedInstance = nextInstance;
+
+  if (!tryHydrateSuspense(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
+
+
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    const prevHydrationParentFiber = hydrationParentFiber;
+
+    if (!nextHydratableInstance || !tryHydrateSuspense(fiber, nextHydratableInstance)) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
+
+
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+  }
+}
+
+function tryToClaimNextHydratableFormMarkerInstance(fiber) {
+  if (!isHydrating) {
+    return false;
+  }
+
+  if (nextHydratableInstance) {
+    const markerInstance = canHydrateFormStateMarker(nextHydratableInstance, rootOrSingletonContext);
+
+    if (markerInstance) {
+      // Found the marker instance.
+      nextHydratableInstance = getNextHydratableSibling(markerInstance); // Return true if this marker instance should use the state passed
+      // to hydrateRoot.
+      // TODO: As an optimization, Fizz should only emit these markers if form
+      // state is passed at the root.
+
+      return isFormStateMarkerMatching(markerInstance);
+    }
+  } // Should have found a marker instance. Throw an error to trigger client
+  // rendering. We don't bother to check if we're in a concurrent root because
+  // useFormState is a new API, so backwards compat is not an issue.
+
+
+  throwOnHydrationMismatch();
+  return false;
+}
+
+function prepareToHydrateHostInstance(fiber, hostContext) {
+
+  const instance = fiber.stateNode;
+  hydrateInstance(instance, fiber.type, fiber.memoizedProps, hostContext, fiber);
+}
+
+function prepareToHydrateHostTextInstance(fiber) {
+
+  const textInstance = fiber.stateNode;
+  const textContent = fiber.memoizedProps;
+  const shouldUpdate = hydrateTextInstance(textInstance, textContent, fiber);
+
+  if (shouldUpdate) {
+    // We assume that prepareToHydrateHostTextInstance is called in a context where the
+    // hydration parent is the parent host component of this host text.
+    const returnFiber = hydrationParentFiber;
+
+    if (returnFiber !== null) {
+      switch (returnFiber.tag) {
+        case HostRoot:
+          {
+            const parentContainer = returnFiber.stateNode.containerInfo;
+            const isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
+            didNotMatchHydratedContainerTextInstance(parentContainer, textInstance, textContent, // TODO: Delete this argument when we remove the legacy root API.
+            isConcurrentMode);
+
+            if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {
+              // In concurrent mode we never update the mismatched text,
+              // even if the error was ignored.
+              return false;
+            }
+
+            break;
+          }
+
+        case HostSingleton:
+        case HostComponent:
+          {
+            const parentType = returnFiber.type;
+            const parentProps = returnFiber.memoizedProps;
+            const parentInstance = returnFiber.stateNode;
+            const isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
+            didNotMatchHydratedTextInstance(parentType, parentProps, parentInstance, textInstance, textContent, // TODO: Delete this argument when we remove the legacy root API.
+            isConcurrentMode);
+
+            if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {
+              // In concurrent mode we never update the mismatched text,
+              // even if the error was ignored.
+              return false;
+            }
+
+            break;
+          }
+      }
+    }
+  }
+
+  return shouldUpdate;
+}
+
+function prepareToHydrateHostSuspenseInstance(fiber) {
+
+  const suspenseState = fiber.memoizedState;
+  const suspenseInstance = suspenseState !== null ? suspenseState.dehydrated : null;
+
+  if (!suspenseInstance) {
+    throw Error(formatProdErrorMessage(317));
+  }
+
+  hydrateSuspenseInstance(suspenseInstance, fiber);
+}
+
+function skipPastDehydratedSuspenseInstance(fiber) {
+
+  const suspenseState = fiber.memoizedState;
+  const suspenseInstance = suspenseState !== null ? suspenseState.dehydrated : null;
+
+  if (!suspenseInstance) {
+    throw Error(formatProdErrorMessage(317));
+  }
+
+  return getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance);
+}
+
+function popToNextHostParent(fiber) {
+  hydrationParentFiber = fiber.return;
+
+  while (hydrationParentFiber) {
+    switch (hydrationParentFiber.tag) {
+      case HostRoot:
+      case HostSingleton:
+        rootOrSingletonContext = true;
+        return;
+
+      case HostComponent:
+      case SuspenseComponent:
+        rootOrSingletonContext = false;
+        return;
+
+      default:
+        hydrationParentFiber = hydrationParentFiber.return;
+    }
+  }
+}
+
+function popHydrationState(fiber) {
+
+  if (fiber !== hydrationParentFiber) {
+    // We're deeper than the current hydration context, inside an inserted
+    // tree.
+    return false;
+  }
+
+  if (!isHydrating) {
+    // If we're not currently hydrating but we're in a hydration context, then
+    // we were an insertion and now need to pop up reenter hydration of our
+    // siblings.
+    popToNextHostParent(fiber);
+    isHydrating = true;
+    return false;
+  }
+
+  let shouldClear = false;
+
+  {
+    // With float we never clear the Root, or Singleton instances. We also do not clear Instances
+    // that have singleton text content
+    if (fiber.tag !== HostRoot && fiber.tag !== HostSingleton && !(fiber.tag === HostComponent && (!shouldDeleteUnhydratedTailInstances(fiber.type) || shouldSetTextContent(fiber.type, fiber.memoizedProps)))) {
+      shouldClear = true;
+    }
+  }
+
+  if (shouldClear) {
+    let nextInstance = nextHydratableInstance;
+
+    if (nextInstance) {
+      if (shouldClientRenderOnMismatch(fiber)) {
+        warnIfUnhydratedTailNodes();
+        throwOnHydrationMismatch();
+      } else {
+        while (nextInstance) {
+          deleteHydratableInstance(fiber, nextInstance);
+          nextInstance = getNextHydratableSibling(nextInstance);
+        }
+      }
+    }
+  }
+
+  popToNextHostParent(fiber);
+
+  if (fiber.tag === SuspenseComponent) {
+    nextHydratableInstance = skipPastDehydratedSuspenseInstance(fiber);
+  } else {
+    nextHydratableInstance = hydrationParentFiber ? getNextHydratableSibling(fiber.stateNode) : null;
+  }
+
+  return true;
+}
+
+function hasUnhydratedTailNodes() {
+  return isHydrating && nextHydratableInstance !== null;
+}
+
+function warnIfUnhydratedTailNodes(fiber) {
+  let nextInstance = nextHydratableInstance;
+
+  while (nextInstance) {
+    nextInstance = getNextHydratableSibling(nextInstance);
+  }
+}
+
+function resetHydrationState() {
+
+  hydrationParentFiber = null;
+  nextHydratableInstance = null;
+  isHydrating = false;
+}
+
+function upgradeHydrationErrorsToRecoverable() {
+  if (hydrationErrors !== null) {
+    // Successfully completed a forced client render. The errors that occurred
+    // during the hydration attempt are now recovered. We will log them in
+    // commit phase, once the entire tree has finished.
+    queueRecoverableErrors(hydrationErrors);
+    hydrationErrors = null;
+  }
+}
+
+function getIsHydrating() {
+  return isHydrating;
+}
+
+function queueHydrationError(error) {
+  if (hydrationErrors === null) {
+    hydrationErrors = [error];
+  } else {
+    hydrationErrors.push(error);
+  }
+}
+
+// we wait until the current render is over (either finished or interrupted)
+// before adding it to the fiber/hook queue. Push to this array so we can
+// access the queue, fiber, update, et al later.
+
+const concurrentQueues = [];
+let concurrentQueuesIndex = 0;
+let concurrentlyUpdatedLanes = NoLanes;
+function finishQueueingConcurrentUpdates() {
+  const endIndex = concurrentQueuesIndex;
+  concurrentQueuesIndex = 0;
+  concurrentlyUpdatedLanes = NoLanes;
+  let i = 0;
+
+  while (i < endIndex) {
+    const fiber = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    const queue = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    const update = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    const lane = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+
+    if (queue !== null && update !== null) {
+      const pending = queue.pending;
+
+      if (pending === null) {
+        // This is the first update. Create a circular list.
+        update.next = update;
+      } else {
+        update.next = pending.next;
+        pending.next = update;
+      }
+
+      queue.pending = update;
+    }
+
+    if (lane !== NoLane) {
+      markUpdateLaneFromFiberToRoot(fiber, update, lane);
+    }
+  }
+}
+function getConcurrentlyUpdatedLanes() {
+  return concurrentlyUpdatedLanes;
+}
+
+function enqueueUpdate$1(fiber, queue, update, lane) {
+  // Don't update the `childLanes` on the return path yet. If we already in
+  // the middle of rendering, wait until after it has completed.
+  concurrentQueues[concurrentQueuesIndex++] = fiber;
+  concurrentQueues[concurrentQueuesIndex++] = queue;
+  concurrentQueues[concurrentQueuesIndex++] = update;
+  concurrentQueues[concurrentQueuesIndex++] = lane;
+  concurrentlyUpdatedLanes = mergeLanes(concurrentlyUpdatedLanes, lane); // The fiber's `lane` field is used in some places to check if any work is
+  // scheduled, to perform an eager bailout, so we need to update it immediately.
+  // TODO: We should probably move this to the "shared" queue instead.
+
+  fiber.lanes = mergeLanes(fiber.lanes, lane);
+  const alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, lane);
+  }
+}
+
+function enqueueConcurrentHookUpdate(fiber, queue, update, lane) {
+  const concurrentQueue = queue;
+  const concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane);
+  return getRootForUpdatedFiber(fiber);
+}
+function enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update) {
+  // This function is used to queue an update that doesn't need a rerender. The
+  // only reason we queue it is in case there's a subsequent higher priority
+  // update that causes it to be rebased.
+  const lane = NoLane;
+  const concurrentQueue = queue;
+  const concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane); // Usually we can rely on the upcoming render phase to process the concurrent
+  // queue. However, since this is a bail out, we're not scheduling any work
+  // here. So the update we just queued will leak until something else happens
+  // to schedule work (if ever).
+  //
+  // Check if we're currently in the middle of rendering a tree, and if not,
+  // process the queue immediately to prevent a leak.
+
+  const isConcurrentlyRendering = getWorkInProgressRoot() !== null;
+
+  if (!isConcurrentlyRendering) {
+    finishQueueingConcurrentUpdates();
+  }
+}
+function enqueueConcurrentClassUpdate(fiber, queue, update, lane) {
+  const concurrentQueue = queue;
+  const concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane);
+  return getRootForUpdatedFiber(fiber);
+}
+function enqueueConcurrentRenderForLane(fiber, lane) {
+  enqueueUpdate$1(fiber, null, null, lane);
+  return getRootForUpdatedFiber(fiber);
+} // Calling this function outside this module should only be done for backwards
+// compatibility and should always be accompanied by a warning.
+
+function unsafe_markUpdateLaneFromFiberToRoot(sourceFiber, lane) {
+  // NOTE: For Hyrum's Law reasons, if an infinite update loop is detected, it
+  // should throw before `markUpdateLaneFromFiberToRoot` is called. But this is
+  // undefined behavior and we can change it if we need to; it just so happens
+  // that, at the time of this writing, there's an internal product test that
+  // happens to rely on this.
+  const root = getRootForUpdatedFiber(sourceFiber);
+  markUpdateLaneFromFiberToRoot(sourceFiber, null, lane);
+  return root;
+}
+
+function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
+  // Update the source fiber's lanes
+  sourceFiber.lanes = mergeLanes(sourceFiber.lanes, lane);
+  let alternate = sourceFiber.alternate;
+
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, lane);
+  } // Walk the parent path to the root and update the child lanes.
+
+
+  let isHidden = false;
+  let parent = sourceFiber.return;
+  let node = sourceFiber;
+
+  while (parent !== null) {
+    parent.childLanes = mergeLanes(parent.childLanes, lane);
+    alternate = parent.alternate;
+
+    if (alternate !== null) {
+      alternate.childLanes = mergeLanes(alternate.childLanes, lane);
+    }
+
+    if (parent.tag === OffscreenComponent) {
+      // Check if this offscreen boundary is currently hidden.
+      //
+      // The instance may be null if the Offscreen parent was unmounted. Usually
+      // the parent wouldn't be reachable in that case because we disconnect
+      // fibers from the tree when they are deleted. However, there's a weird
+      // edge case where setState is called on a fiber that was interrupted
+      // before it ever mounted. Because it never mounts, it also never gets
+      // deleted. Because it never gets deleted, its return pointer never gets
+      // disconnected. Which means it may be attached to a deleted Offscreen
+      // parent node. (This discovery suggests it may be better for memory usage
+      // if we don't attach the `return` pointer until the commit phase, though
+      // in order to do that we'd need some other way to track the return
+      // pointer during the initial render, like on the stack.)
+      //
+      // This case is always accompanied by a warning, but we still need to
+      // account for it. (There may be other cases that we haven't discovered,
+      // too.)
+      const offscreenInstance = parent.stateNode;
+
+      if (offscreenInstance !== null && !(offscreenInstance._visibility & OffscreenVisible)) {
+        isHidden = true;
+      }
+    }
+
+    node = parent;
+    parent = parent.return;
+  }
+
+  if (isHidden && update !== null && node.tag === HostRoot) {
+    const root = node.stateNode;
+    markHiddenUpdate(root, update, lane);
+  }
+}
+
+function getRootForUpdatedFiber(sourceFiber) {
+  // TODO: We will detect and infinite update loop and throw even if this fiber
+  // has already unmounted. This isn't really necessary but it happens to be the
+  // current behavior we've used for several release cycles. Consider not
+  // performing this check if the updated fiber already unmounted, since it's
+  // not possible for that to cause an infinite update loop.
+  throwIfInfiniteUpdateLoopDetected(); // When a setState happens, we must ensure the root is scheduled. Because
+  let node = sourceFiber;
+  let parent = node.return;
+
+  while (parent !== null) {
+    node = parent;
+    parent = node.return;
+  }
+
+  return node.tag === HostRoot ? node.stateNode : null;
+}
+
+const UpdateState = 0;
+const ReplaceState = 1;
+const ForceUpdate = 2;
+const CaptureUpdate = 3; // Global state that is reset at the beginning of calling `processUpdateQueue`.
+// It should only be read right after calling `processUpdateQueue`, via
+// `checkHasForceUpdateAfterProcessing`.
+
+let hasForceUpdate = false;
+
+function initializeUpdateQueue(fiber) {
+  const queue = {
+    baseState: fiber.memoizedState,
+    firstBaseUpdate: null,
+    lastBaseUpdate: null,
+    shared: {
+      pending: null,
+      lanes: NoLanes,
+      hiddenCallbacks: null
+    },
+    callbacks: null
+  };
+  fiber.updateQueue = queue;
+}
+function cloneUpdateQueue(current, workInProgress) {
+  // Clone the update queue from current. Unless it's already a clone.
+  const queue = workInProgress.updateQueue;
+  const currentQueue = current.updateQueue;
+
+  if (queue === currentQueue) {
+    const clone = {
+      baseState: currentQueue.baseState,
+      firstBaseUpdate: currentQueue.firstBaseUpdate,
+      lastBaseUpdate: currentQueue.lastBaseUpdate,
+      shared: currentQueue.shared,
+      callbacks: null
+    };
+    workInProgress.updateQueue = clone;
+  }
+}
+function createUpdate(lane) {
+  const update = {
+    lane,
+    tag: UpdateState,
+    payload: null,
+    callback: null,
+    next: null
+  };
+  return update;
+}
+function enqueueUpdate(fiber, update, lane) {
+  const updateQueue = fiber.updateQueue;
+
+  if (updateQueue === null) {
+    // Only occurs if the fiber has been unmounted.
+    return null;
+  }
+
+  const sharedQueue = updateQueue.shared;
+
+  if (isUnsafeClassRenderPhaseUpdate()) {
+    // This is an unsafe render phase update. Add directly to the update
+    // queue so we can process it immediately during the current render.
+    const pending = sharedQueue.pending;
+
+    if (pending === null) {
+      // This is the first update. Create a circular list.
+      update.next = update;
+    } else {
+      update.next = pending.next;
+      pending.next = update;
+    }
+
+    sharedQueue.pending = update; // Update the childLanes even though we're most likely already rendering
+    // this fiber. This is for backwards compatibility in the case where you
+    // update a different component during render phase than the one that is
+    // currently renderings (a pattern that is accompanied by a warning).
+
+    return unsafe_markUpdateLaneFromFiberToRoot(fiber, lane);
+  } else {
+    return enqueueConcurrentClassUpdate(fiber, sharedQueue, update, lane);
+  }
+}
+function entangleTransitions(root, fiber, lane) {
+  const updateQueue = fiber.updateQueue;
+
+  if (updateQueue === null) {
+    // Only occurs if the fiber has been unmounted.
+    return;
+  }
+
+  const sharedQueue = updateQueue.shared;
+
+  if (isTransitionLane(lane)) {
+    let queueLanes = sharedQueue.lanes; // If any entangled lanes are no longer pending on the root, then they must
+    // have finished. We can remove them from the shared queue, which represents
+    // a superset of the actually pending lanes. In some cases we may entangle
+    // more than we need to, but that's OK. In fact it's worse if we *don't*
+    // entangle when we should.
+
+    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.
+
+    const newQueueLanes = mergeLanes(queueLanes, lane);
+    sharedQueue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if
+    // the lane finished since the last time we entangled it. So we need to
+    // entangle it again, just to be sure.
+
+    markRootEntangled(root, newQueueLanes);
+  }
+}
+function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
+  // Captured updates are updates that are thrown by a child during the render
+  // phase. They should be discarded if the render is aborted. Therefore,
+  // we should only put them on the work-in-progress queue, not the current one.
+  let queue = workInProgress.updateQueue; // Check if the work-in-progress queue is a clone.
+
+  const current = workInProgress.alternate;
+
+  if (current !== null) {
+    const currentQueue = current.updateQueue;
+
+    if (queue === currentQueue) {
+      // The work-in-progress queue is the same as current. This happens when
+      // we bail out on a parent fiber that then captures an error thrown by
+      // a child. Since we want to append the update only to the work-in
+      // -progress queue, we need to clone the updates. We usually clone during
+      // processUpdateQueue, but that didn't happen in this case because we
+      // skipped over the parent when we bailed out.
+      let newFirst = null;
+      let newLast = null;
+      const firstBaseUpdate = queue.firstBaseUpdate;
+
+      if (firstBaseUpdate !== null) {
+        // Loop through the updates and clone them.
+        let update = firstBaseUpdate;
+
+        do {
+          const clone = {
+            lane: update.lane,
+            tag: update.tag,
+            payload: update.payload,
+            // When this update is rebased, we should not fire its
+            // callback again.
+            callback: null,
+            next: null
+          };
+
+          if (newLast === null) {
+            newFirst = newLast = clone;
+          } else {
+            newLast.next = clone;
+            newLast = clone;
+          } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+          update = update.next;
+        } while (update !== null); // Append the captured update the end of the cloned list.
+
+
+        if (newLast === null) {
+          newFirst = newLast = capturedUpdate;
+        } else {
+          newLast.next = capturedUpdate;
+          newLast = capturedUpdate;
+        }
+      } else {
+        // There are no base updates.
+        newFirst = newLast = capturedUpdate;
+      }
+
+      queue = {
+        baseState: currentQueue.baseState,
+        firstBaseUpdate: newFirst,
+        lastBaseUpdate: newLast,
+        shared: currentQueue.shared,
+        callbacks: currentQueue.callbacks
+      };
+      workInProgress.updateQueue = queue;
+      return;
+    }
+  } // Append the update to the end of the list.
+
+
+  const lastBaseUpdate = queue.lastBaseUpdate;
+
+  if (lastBaseUpdate === null) {
+    queue.firstBaseUpdate = capturedUpdate;
+  } else {
+    lastBaseUpdate.next = capturedUpdate;
+  }
+
+  queue.lastBaseUpdate = capturedUpdate;
+}
+
+function getStateFromUpdate(workInProgress, queue, update, prevState, nextProps, instance) {
+  switch (update.tag) {
+    case ReplaceState:
+      {
+        const payload = update.payload;
+
+        if (typeof payload === 'function') {
+
+          const nextState = payload.call(instance, prevState, nextProps);
+
+          return nextState;
+        } // State object
+
+
+        return payload;
+      }
+
+    case CaptureUpdate:
+      {
+        workInProgress.flags = workInProgress.flags & ~ShouldCapture | DidCapture;
+      }
+    // Intentional fallthrough
+
+    case UpdateState:
+      {
+        const payload = update.payload;
+        let partialState;
+
+        if (typeof payload === 'function') {
+
+          partialState = payload.call(instance, prevState, nextProps);
+        } else {
+          // Partial state object
+          partialState = payload;
+        }
+
+        if (partialState === null || partialState === undefined) {
+          // Null and undefined are treated as no-ops.
+          return prevState;
+        } // Merge the partial state and the previous state.
+
+
+        return assign({}, prevState, partialState);
+      }
+
+    case ForceUpdate:
+      {
+        hasForceUpdate = true;
+        return prevState;
+      }
+  }
+
+  return prevState;
+}
+
+function processUpdateQueue(workInProgress, props, instance, renderLanes) {
+  // This is always non-null on a ClassComponent or HostRoot
+  const queue = workInProgress.updateQueue;
+  hasForceUpdate = false;
+
+  let firstBaseUpdate = queue.firstBaseUpdate;
+  let lastBaseUpdate = queue.lastBaseUpdate; // Check if there are pending updates. If so, transfer them to the base queue.
+
+  let pendingQueue = queue.shared.pending;
+
+  if (pendingQueue !== null) {
+    queue.shared.pending = null; // The pending queue is circular. Disconnect the pointer between first
+    // and last so that it's non-circular.
+
+    const lastPendingUpdate = pendingQueue;
+    const firstPendingUpdate = lastPendingUpdate.next;
+    lastPendingUpdate.next = null; // Append pending updates to base queue
+
+    if (lastBaseUpdate === null) {
+      firstBaseUpdate = firstPendingUpdate;
+    } else {
+      lastBaseUpdate.next = firstPendingUpdate;
+    }
+
+    lastBaseUpdate = lastPendingUpdate; // If there's a current queue, and it's different from the base queue, then
+    // we need to transfer the updates to that queue, too. Because the base
+    // queue is a singly-linked list with no cycles, we can append to both
+    // lists and take advantage of structural sharing.
+    // TODO: Pass `current` as argument
+
+    const current = workInProgress.alternate;
+
+    if (current !== null) {
+      // This is always non-null on a ClassComponent or HostRoot
+      const currentQueue = current.updateQueue;
+      const currentLastBaseUpdate = currentQueue.lastBaseUpdate;
+
+      if (currentLastBaseUpdate !== lastBaseUpdate) {
+        if (currentLastBaseUpdate === null) {
+          currentQueue.firstBaseUpdate = firstPendingUpdate;
+        } else {
+          currentLastBaseUpdate.next = firstPendingUpdate;
+        }
+
+        currentQueue.lastBaseUpdate = lastPendingUpdate;
+      }
+    }
+  } // These values may change as we process the queue.
+
+
+  if (firstBaseUpdate !== null) {
+    // Iterate through the list of updates to compute the result.
+    let newState = queue.baseState; // TODO: Don't need to accumulate this. Instead, we can remove renderLanes
+    // from the original lanes.
+
+    let newLanes = NoLanes;
+    let newBaseState = null;
+    let newFirstBaseUpdate = null;
+    let newLastBaseUpdate = null;
+    let update = firstBaseUpdate;
+
+    do {
+      // An extra OffscreenLane bit is added to updates that were made to
+      // a hidden tree, so that we can distinguish them from updates that were
+      // already there when the tree was hidden.
+      const updateLane = removeLanes(update.lane, OffscreenLane);
+      const isHiddenUpdate = updateLane !== update.lane; // Check if this update was made while the tree was hidden. If so, then
+      // it's not a "base" update and we should disregard the extra base lanes
+      // that were added to renderLanes when we entered the Offscreen tree.
+
+      const shouldSkipUpdate = isHiddenUpdate ? !isSubsetOfLanes(getWorkInProgressRootRenderLanes(), updateLane) : !isSubsetOfLanes(renderLanes, updateLane);
+
+      if (shouldSkipUpdate) {
+        // Priority is insufficient. Skip this update. If this is the first
+        // skipped update, the previous update/state is the new base
+        // update/state.
+        const clone = {
+          lane: updateLane,
+          tag: update.tag,
+          payload: update.payload,
+          callback: update.callback,
+          next: null
+        };
+
+        if (newLastBaseUpdate === null) {
+          newFirstBaseUpdate = newLastBaseUpdate = clone;
+          newBaseState = newState;
+        } else {
+          newLastBaseUpdate = newLastBaseUpdate.next = clone;
+        } // Update the remaining priority in the queue.
+
+
+        newLanes = mergeLanes(newLanes, updateLane);
+      } else {
+        // This update does have sufficient priority.
+        if (newLastBaseUpdate !== null) {
+          const clone = {
+            // This update is going to be committed so we never want uncommit
+            // it. Using NoLane works because 0 is a subset of all bitmasks, so
+            // this will never be skipped by the check above.
+            lane: NoLane,
+            tag: update.tag,
+            payload: update.payload,
+            // When this update is rebased, we should not fire its
+            // callback again.
+            callback: null,
+            next: null
+          };
+          newLastBaseUpdate = newLastBaseUpdate.next = clone;
+        } // Process this update.
+
+
+        newState = getStateFromUpdate(workInProgress, queue, update, newState, props, instance);
+        const callback = update.callback;
+
+        if (callback !== null) {
+          workInProgress.flags |= Callback;
+
+          if (isHiddenUpdate) {
+            workInProgress.flags |= Visibility;
+          }
+
+          const callbacks = queue.callbacks;
+
+          if (callbacks === null) {
+            queue.callbacks = [callback];
+          } else {
+            callbacks.push(callback);
+          }
+        }
+      } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+      update = update.next;
+
+      if (update === null) {
+        pendingQueue = queue.shared.pending;
+
+        if (pendingQueue === null) {
+          break;
+        } else {
+          // An update was scheduled from inside a reducer. Add the new
+          // pending updates to the end of the list and keep processing.
+          const lastPendingUpdate = pendingQueue; // Intentionally unsound. Pending updates form a circular list, but we
+          // unravel them when transferring them to the base queue.
+
+          const firstPendingUpdate = lastPendingUpdate.next;
+          lastPendingUpdate.next = null;
+          update = firstPendingUpdate;
+          queue.lastBaseUpdate = lastPendingUpdate;
+          queue.shared.pending = null;
+        }
+      }
+    } while (true);
+
+    if (newLastBaseUpdate === null) {
+      newBaseState = newState;
+    }
+
+    queue.baseState = newBaseState;
+    queue.firstBaseUpdate = newFirstBaseUpdate;
+    queue.lastBaseUpdate = newLastBaseUpdate;
+
+    if (firstBaseUpdate === null) {
+      // `queue.lanes` is used for entangling transitions. We can set it back to
+      // zero once the queue is empty.
+      queue.shared.lanes = NoLanes;
+    } // Set the remaining expiration time to be whatever is remaining in the queue.
+    // This should be fine because the only two other things that contribute to
+    // expiration time are props and context. We're already in the middle of the
+    // begin phase by the time we start processing the queue, so we've already
+    // dealt with the props. Context in components that specify
+    // shouldComponentUpdate is tricky; but we'll have to account for
+    // that regardless.
+
+
+    markSkippedUpdateLanes(newLanes);
+    workInProgress.lanes = newLanes;
+    workInProgress.memoizedState = newState;
+  }
+}
+
+function callCallback(callback, context) {
+  if (typeof callback !== 'function') {
+    throw Error(formatProdErrorMessage(191, callback));
+  }
+
+  callback.call(context);
+}
+
+function resetHasForceUpdateBeforeProcessing() {
+  hasForceUpdate = false;
+}
+function checkHasForceUpdateAfterProcessing() {
+  return hasForceUpdate;
+}
+function deferHiddenCallbacks(updateQueue) {
+  // When an update finishes on a hidden component, its callback should not
+  // be fired until/unless the component is made visible again. Stash the
+  // callback on the shared queue object so it can be fired later.
+  const newHiddenCallbacks = updateQueue.callbacks;
+
+  if (newHiddenCallbacks !== null) {
+    const existingHiddenCallbacks = updateQueue.shared.hiddenCallbacks;
+
+    if (existingHiddenCallbacks === null) {
+      updateQueue.shared.hiddenCallbacks = newHiddenCallbacks;
+    } else {
+      updateQueue.shared.hiddenCallbacks = existingHiddenCallbacks.concat(newHiddenCallbacks);
+    }
+  }
+}
+function commitHiddenCallbacks(updateQueue, context) {
+  // This component is switching from hidden -> visible. Commit any callbacks
+  // that were previously deferred.
+  const hiddenCallbacks = updateQueue.shared.hiddenCallbacks;
+
+  if (hiddenCallbacks !== null) {
+    updateQueue.shared.hiddenCallbacks = null;
+
+    for (let i = 0; i < hiddenCallbacks.length; i++) {
+      const callback = hiddenCallbacks[i];
+      callCallback(callback, context);
+    }
+  }
+}
+function commitCallbacks(updateQueue, context) {
+  const callbacks = updateQueue.callbacks;
+
+  if (callbacks !== null) {
+    updateQueue.callbacks = null;
+
+    for (let i = 0; i < callbacks.length; i++) {
+      const callback = callbacks[i];
+      callCallback(callback, context);
+    }
+  }
+}
+
+/**
+ * Performs equality by iterating through keys on an object and returning false
+ * when any key has values which are not strictly equal between the arguments.
+ * Returns true when the values of all keys are strictly equal.
+ */
+
+function shallowEqual(objA, objB) {
+  if (objectIs(objA, objB)) {
+    return true;
+  }
+
+  if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
+    return false;
+  }
+
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+
+  if (keysA.length !== keysB.length) {
+    return false;
+  } // Test for A's keys different from B.
+
+
+  for (let i = 0; i < keysA.length; i++) {
+    const currentKey = keysA[i];
+
+    if (!hasOwnProperty.call(objB, currentKey) || // $FlowFixMe[incompatible-use] lost refinement of `objB`
+    !objectIs(objA[currentKey], objB[currentKey])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+// detect this is caught by userspace, we'll log a warning in development.
+
+const SuspenseException = Error(formatProdErrorMessage(460));
+const SuspenseyCommitException = Error(formatProdErrorMessage(474)); // This is a noop thenable that we use to trigger a fallback in throwException.
+// TODO: It would be better to refactor throwException into multiple functions
+// so we can trigger a fallback directly without having to check the type. But
+// for now this will do.
+
+const noopSuspenseyCommitThenable = {
+  then() {
+  }
+
+};
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+function isThenableResolved(thenable) {
+  const status = thenable.status;
+  return status === 'fulfilled' || status === 'rejected';
+}
+
+function noop$2() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop$2, noop$2);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        checkIfUseWrappedInAsyncCatch(rejectedError);
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          // Attach a dummy listener, to ensure that any lazy initialization can
+          // happen. Flight lazily parses JSON when the value is actually awaited.
+          thenable.then(noop$2, noop$2);
+        } else {
+          // This is an uncached thenable that we haven't seen before.
+          // Detect infinite ping loops caused by uncached promises.
+          const root = getWorkInProgressRoot();
+
+          if (root !== null && root.shellSuspendCounter > 100) {
+            // This root has suspended repeatedly in the shell without making any
+            // progress (i.e. committing something). This is highly suggestive of
+            // an infinite ping loop, often caused by an accidental Async Client
+            // Component.
+            //
+            // During a transition, we can suspend the work loop until the promise
+            // to resolve, but this is a sync render, so that's not an option. We
+            // also can't show a fallback, because none was provided. So our last
+            // resort is to throw an error.
+            //
+            // TODO: Remove this error in a future release. Other ways of handling
+            // this case include forcing a concurrent render, or putting the whole
+            // root into offscreen mode.
+            throw Error(formatProdErrorMessage(482));
+          }
+
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously.
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                const rejectedError = rejectedThenable.reason;
+                checkIfUseWrappedInAsyncCatch(rejectedError);
+                throw rejectedError;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+
+        throw SuspenseException;
+      }
+  }
+}
+function suspendCommit() {
+  // This extra indirection only exists so it can handle passing
+  // noopSuspenseyCommitThenable through to throwException.
+  // TODO: Factor the thenable check out of throwException
+  suspendedThenable = noopSuspenseyCommitThenable;
+  throw SuspenseyCommitException;
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw Error(formatProdErrorMessage(459));
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+
+  return thenable;
+}
+function checkIfUseWrappedInAsyncCatch(rejectedReason) {
+  // This check runs in prod, too, because it prevents a more confusing
+  // downstream error, where SuspenseException is caught by a promise and
+  // thrown asynchronously.
+  // TODO: Another way to prevent SuspenseException from leaking into an async
+  // execution context is to check the dispatcher every time `use` is called,
+  // or some equivalent. That might be preferable for other reasons, too, since
+  // it matches how we prevent similar mistakes for other hooks.
+  if (rejectedReason === SuspenseException) {
+    throw Error(formatProdErrorMessage(483));
+  }
+}
+
+let thenableState$1 = null;
+let thenableIndexCounter$1 = 0;
+
+function unwrapThenable(thenable) {
+  const index = thenableIndexCounter$1;
+  thenableIndexCounter$1 += 1;
+
+  if (thenableState$1 === null) {
+    thenableState$1 = createThenableState();
+  }
+
+  return trackUsedThenable(thenableState$1, thenable, index);
+}
+
+function coerceRef(returnFiber, current, element) {
+  const mixedRef = element.ref;
+
+  if (mixedRef !== null && typeof mixedRef !== 'function' && typeof mixedRef !== 'object') {
+
+    if (element._owner) {
+      const owner = element._owner;
+      let inst;
+
+      if (owner) {
+        const ownerFiber = owner;
+
+        if (ownerFiber.tag !== ClassComponent) {
+          throw Error(formatProdErrorMessage(309));
+        }
+
+        inst = ownerFiber.stateNode;
+      }
+
+      if (!inst) {
+        throw Error(formatProdErrorMessage(147, mixedRef));
+      } // Assigning this to a const so Flow knows it won't change in the closure
+
+
+      const resolvedInst = inst;
+
+      const stringRef = '' + mixedRef; // Check if previous string ref matches new string ref
+
+      if (current !== null && current.ref !== null && typeof current.ref === 'function' && current.ref._stringRef === stringRef) {
+        return current.ref;
+      }
+
+      const ref = function (value) {
+        const refs = resolvedInst.refs;
+
+        if (value === null) {
+          delete refs[stringRef];
+        } else {
+          refs[stringRef] = value;
+        }
+      };
+
+      ref._stringRef = stringRef;
+      return ref;
+    } else {
+      if (typeof mixedRef !== 'string') {
+        throw Error(formatProdErrorMessage(284));
+      }
+
+      if (!element._owner) {
+        throw Error(formatProdErrorMessage(290, mixedRef));
+      }
+    }
+  }
+
+  return mixedRef;
+}
+
+function throwOnInvalidObjectType(returnFiber, newChild) {
+  // $FlowFixMe[method-unbinding]
+  const childString = Object.prototype.toString.call(newChild);
+  throw Error(formatProdErrorMessage(31, childString === '[object Object]' ? 'object with keys {' + Object.keys(newChild).join(', ') + '}' : childString));
+}
+
+function resolveLazy(lazyType) {
+  const payload = lazyType._payload;
+  const init = lazyType._init;
+  return init(payload);
+} // This wrapper function exists because I expect to clone the code in each path
+// to be able to optimize each path individually by branching early. This needs
+// a compiler or we can do it manually. Helpers that don't need this branching
+// live outside of this function.
+
+
+function createChildReconciler(shouldTrackSideEffects) {
+  function deleteChild(returnFiber, childToDelete) {
+    if (!shouldTrackSideEffects) {
+      // Noop.
+      return;
+    }
+
+    const deletions = returnFiber.deletions;
+
+    if (deletions === null) {
+      returnFiber.deletions = [childToDelete];
+      returnFiber.flags |= ChildDeletion;
+    } else {
+      deletions.push(childToDelete);
+    }
+  }
+
+  function deleteRemainingChildren(returnFiber, currentFirstChild) {
+    if (!shouldTrackSideEffects) {
+      // Noop.
+      return null;
+    } // TODO: For the shouldClone case, this could be micro-optimized a bit by
+    // assuming that after the first child we've already added everything.
+
+
+    let childToDelete = currentFirstChild;
+
+    while (childToDelete !== null) {
+      deleteChild(returnFiber, childToDelete);
+      childToDelete = childToDelete.sibling;
+    }
+
+    return null;
+  }
+
+  function mapRemainingChildren(returnFiber, currentFirstChild) {
+    // Add the remaining children to a temporary map so that we can find them by
+    // keys quickly. Implicit (null) keys get added to this set with their index
+    // instead.
+    const existingChildren = new Map();
+    let existingChild = currentFirstChild;
+
+    while (existingChild !== null) {
+      if (existingChild.key !== null) {
+        existingChildren.set(existingChild.key, existingChild);
+      } else {
+        existingChildren.set(existingChild.index, existingChild);
+      }
+
+      existingChild = existingChild.sibling;
+    }
+
+    return existingChildren;
+  }
+
+  function useFiber(fiber, pendingProps) {
+    // We currently set sibling to null and index to 0 here because it is easy
+    // to forget to do before returning it. E.g. for the single child case.
+    const clone = createWorkInProgress(fiber, pendingProps);
+    clone.index = 0;
+    clone.sibling = null;
+    return clone;
+  }
+
+  function placeChild(newFiber, lastPlacedIndex, newIndex) {
+    newFiber.index = newIndex;
+
+    if (!shouldTrackSideEffects) {
+      // During hydration, the useId algorithm needs to know which fibers are
+      // part of a list of children (arrays, iterators).
+      newFiber.flags |= Forked;
+      return lastPlacedIndex;
+    }
+
+    const current = newFiber.alternate;
+
+    if (current !== null) {
+      const oldIndex = current.index;
+
+      if (oldIndex < lastPlacedIndex) {
+        // This is a move.
+        newFiber.flags |= Placement | PlacementDEV;
+        return lastPlacedIndex;
+      } else {
+        // This item can stay in place.
+        return oldIndex;
+      }
+    } else {
+      // This is an insertion.
+      newFiber.flags |= Placement | PlacementDEV;
+      return lastPlacedIndex;
+    }
+  }
+
+  function placeSingleChild(newFiber) {
+    // This is simpler for the single child case. We only need to do a
+    // placement for inserting new children.
+    if (shouldTrackSideEffects && newFiber.alternate === null) {
+      newFiber.flags |= Placement | PlacementDEV;
+    }
+
+    return newFiber;
+  }
+
+  function updateTextNode(returnFiber, current, textContent, lanes) {
+    if (current === null || current.tag !== HostText) {
+      // Insert
+      const created = createFiberFromText(textContent, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      const existing = useFiber(current, textContent);
+      existing.return = returnFiber;
+      return existing;
+    }
+  }
+
+  function updateElement(returnFiber, current, element, lanes) {
+    const elementType = element.type;
+
+    if (elementType === REACT_FRAGMENT_TYPE) {
+      return updateFragment(returnFiber, current, element.props.children, lanes, element.key);
+    }
+
+    if (current !== null) {
+      if (current.elementType === elementType || ( // Keep this check inline so it only runs on the false path:
+      false) || // Lazy types should reconcile their resolved type.
+      // We need to do this after the Hot Reloading check above,
+      // because hot reloading has different semantics than prod because
+      // it doesn't resuspend. So we can't let the call below suspend.
+      typeof elementType === 'object' && elementType !== null && elementType.$$typeof === REACT_LAZY_TYPE && resolveLazy(elementType) === current.type) {
+        // Move based on index
+        const existing = useFiber(current, element.props);
+        existing.ref = coerceRef(returnFiber, current, element);
+        existing.return = returnFiber;
+
+        return existing;
+      }
+    } // Insert
+
+
+    const created = createFiberFromElement(element, returnFiber.mode, lanes);
+    created.ref = coerceRef(returnFiber, current, element);
+    created.return = returnFiber;
+    return created;
+  }
+
+  function updatePortal(returnFiber, current, portal, lanes) {
+    if (current === null || current.tag !== HostPortal || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation) {
+      // Insert
+      const created = createFiberFromPortal(portal, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      const existing = useFiber(current, portal.children || []);
+      existing.return = returnFiber;
+      return existing;
+    }
+  }
+
+  function updateFragment(returnFiber, current, fragment, lanes, key) {
+    if (current === null || current.tag !== Fragment) {
+      // Insert
+      const created = createFiberFromFragment(fragment, returnFiber.mode, lanes, key);
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      const existing = useFiber(current, fragment);
+      existing.return = returnFiber;
+      return existing;
+    }
+  }
+
+  function createChild(returnFiber, newChild, lanes) {
+    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {
+      // Text nodes don't have keys. If the previous node is implicitly keyed
+      // we can continue to replace it without aborting even if it is not a text
+      // node.
+      const created = createFiberFromText('' + newChild, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    }
+
+    if (typeof newChild === 'object' && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const created = createFiberFromElement(newChild, returnFiber.mode, lanes);
+            created.ref = coerceRef(returnFiber, null, newChild);
+            created.return = returnFiber;
+            return created;
+          }
+
+        case REACT_PORTAL_TYPE:
+          {
+            const created = createFiberFromPortal(newChild, returnFiber.mode, lanes);
+            created.return = returnFiber;
+            return created;
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = newChild._payload;
+            const init = newChild._init;
+            return createChild(returnFiber, init(payload), lanes);
+          }
+      }
+
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        const created = createFiberFromFragment(newChild, returnFiber.mode, lanes, null);
+        created.return = returnFiber;
+        return created;
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
+
+
+      if (typeof newChild.then === 'function') {
+        const thenable = newChild;
+        return createChild(returnFiber, unwrapThenable(thenable), lanes);
+      }
+
+      if (newChild.$$typeof === REACT_CONTEXT_TYPE || newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+        const context = newChild;
+        return createChild(returnFiber, readContextDuringReconcilation(returnFiber, context, lanes), lanes);
+      }
+
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+
+    return null;
+  }
+
+  function updateSlot(returnFiber, oldFiber, newChild, lanes) {
+    // Update the fiber if the keys match, otherwise return null.
+    const key = oldFiber !== null ? oldFiber.key : null;
+
+    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {
+      // Text nodes don't have keys. If the previous node is implicitly keyed
+      // we can continue to replace it without aborting even if it is not a text
+      // node.
+      if (key !== null) {
+        return null;
+      }
+
+      return updateTextNode(returnFiber, oldFiber, '' + newChild, lanes);
+    }
+
+    if (typeof newChild === 'object' && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            if (newChild.key === key) {
+              return updateElement(returnFiber, oldFiber, newChild, lanes);
+            } else {
+              return null;
+            }
+          }
+
+        case REACT_PORTAL_TYPE:
+          {
+            if (newChild.key === key) {
+              return updatePortal(returnFiber, oldFiber, newChild, lanes);
+            } else {
+              return null;
+            }
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = newChild._payload;
+            const init = newChild._init;
+            return updateSlot(returnFiber, oldFiber, init(payload), lanes);
+          }
+      }
+
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        if (key !== null) {
+          return null;
+        }
+
+        return updateFragment(returnFiber, oldFiber, newChild, lanes, null);
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
+
+
+      if (typeof newChild.then === 'function') {
+        const thenable = newChild;
+        return updateSlot(returnFiber, oldFiber, unwrapThenable(thenable), lanes);
+      }
+
+      if (newChild.$$typeof === REACT_CONTEXT_TYPE || newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+        const context = newChild;
+        return updateSlot(returnFiber, oldFiber, readContextDuringReconcilation(returnFiber, context, lanes), lanes);
+      }
+
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+
+    return null;
+  }
+
+  function updateFromMap(existingChildren, returnFiber, newIdx, newChild, lanes) {
+    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {
+      // Text nodes don't have keys, so we neither have to check the old nor
+      // new node for the key. If both are text nodes, they match.
+      const matchedFiber = existingChildren.get(newIdx) || null;
+      return updateTextNode(returnFiber, matchedFiber, '' + newChild, lanes);
+    }
+
+    if (typeof newChild === 'object' && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const matchedFiber = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;
+            return updateElement(returnFiber, matchedFiber, newChild, lanes);
+          }
+
+        case REACT_PORTAL_TYPE:
+          {
+            const matchedFiber = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;
+            return updatePortal(returnFiber, matchedFiber, newChild, lanes);
+          }
+
+        case REACT_LAZY_TYPE:
+          const payload = newChild._payload;
+          const init = newChild._init;
+          return updateFromMap(existingChildren, returnFiber, newIdx, init(payload), lanes);
+      }
+
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        const matchedFiber = existingChildren.get(newIdx) || null;
+        return updateFragment(returnFiber, matchedFiber, newChild, lanes, null);
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
+
+
+      if (typeof newChild.then === 'function') {
+        const thenable = newChild;
+        return updateFromMap(existingChildren, returnFiber, newIdx, unwrapThenable(thenable), lanes);
+      }
+
+      if (newChild.$$typeof === REACT_CONTEXT_TYPE || newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+        const context = newChild;
+        return updateFromMap(existingChildren, returnFiber, newIdx, readContextDuringReconcilation(returnFiber, context, lanes), lanes);
+      }
+
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+
+    return null;
+  }
+
+  function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, lanes) {
+
+    let resultingFirstChild = null;
+    let previousNewFiber = null;
+    let oldFiber = currentFirstChild;
+    let lastPlacedIndex = 0;
+    let newIdx = 0;
+    let nextOldFiber = null;
+
+    for (; oldFiber !== null && newIdx < newChildren.length; newIdx++) {
+      if (oldFiber.index > newIdx) {
+        nextOldFiber = oldFiber;
+        oldFiber = null;
+      } else {
+        nextOldFiber = oldFiber.sibling;
+      }
+
+      const newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], lanes);
+
+      if (newFiber === null) {
+        // TODO: This breaks on empty slots like null children. That's
+        // unfortunate because it triggers the slow path all the time. We need
+        // a better way to communicate whether this was a miss or null,
+        // boolean, undefined, etc.
+        if (oldFiber === null) {
+          oldFiber = nextOldFiber;
+        }
+
+        break;
+      }
+
+      if (shouldTrackSideEffects) {
+        if (oldFiber && newFiber.alternate === null) {
+          // We matched the slot, but we didn't reuse the existing fiber, so we
+          // need to delete the existing child.
+          deleteChild(returnFiber, oldFiber);
+        }
+      }
+
+      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+      if (previousNewFiber === null) {
+        // TODO: Move out of the loop. This only happens for the first run.
+        resultingFirstChild = newFiber;
+      } else {
+        // TODO: Defer siblings if we're not at the right index for this slot.
+        // I.e. if we had null values before, then we want to defer this
+        // for each null value. However, we also don't want to call updateSlot
+        // with the previous one.
+        previousNewFiber.sibling = newFiber;
+      }
+
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
+    }
+
+    if (newIdx === newChildren.length) {
+      // We've reached the end of the new children. We can delete the rest.
+      deleteRemainingChildren(returnFiber, oldFiber);
+
+      if (getIsHydrating()) {
+        const numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
+
+      return resultingFirstChild;
+    }
+
+    if (oldFiber === null) {
+      // If we don't have any more existing children we can choose a fast path
+      // since the rest will all be insertions.
+      for (; newIdx < newChildren.length; newIdx++) {
+        const newFiber = createChild(returnFiber, newChildren[newIdx], lanes);
+
+        if (newFiber === null) {
+          continue;
+        }
+
+        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          // TODO: Move out of the loop. This only happens for the first run.
+          resultingFirstChild = newFiber;
+        } else {
+          previousNewFiber.sibling = newFiber;
+        }
+
+        previousNewFiber = newFiber;
+      }
+
+      if (getIsHydrating()) {
+        const numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
+
+      return resultingFirstChild;
+    } // Add all children to a key map for quick lookups.
+
+
+    const existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
+
+    for (; newIdx < newChildren.length; newIdx++) {
+      const newFiber = updateFromMap(existingChildren, returnFiber, newIdx, newChildren[newIdx], lanes);
+
+      if (newFiber !== null) {
+        if (shouldTrackSideEffects) {
+          if (newFiber.alternate !== null) {
+            // The new fiber is a work in progress, but if there exists a
+            // current, that means that we reused the fiber. We need to delete
+            // it from the child list so that we don't add it to the deletion
+            // list.
+            existingChildren.delete(newFiber.key === null ? newIdx : newFiber.key);
+          }
+        }
+
+        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          resultingFirstChild = newFiber;
+        } else {
+          previousNewFiber.sibling = newFiber;
+        }
+
+        previousNewFiber = newFiber;
+      }
+    }
+
+    if (shouldTrackSideEffects) {
+      // Any existing children that weren't consumed above were deleted. We need
+      // to add them to the deletion list.
+      existingChildren.forEach(child => deleteChild(returnFiber, child));
+    }
+
+    if (getIsHydrating()) {
+      const numberOfForks = newIdx;
+      pushTreeFork(returnFiber, numberOfForks);
+    }
+
+    return resultingFirstChild;
+  }
+
+  function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildrenIterable, lanes) {
+    // This is the same implementation as reconcileChildrenArray(),
+    // but using the iterator instead.
+    const iteratorFn = getIteratorFn(newChildrenIterable);
+
+    if (typeof iteratorFn !== 'function') {
+      throw Error(formatProdErrorMessage(150));
+    }
+
+    const newChildren = iteratorFn.call(newChildrenIterable);
+
+    if (newChildren == null) {
+      throw Error(formatProdErrorMessage(151));
+    }
+
+    let resultingFirstChild = null;
+    let previousNewFiber = null;
+    let oldFiber = currentFirstChild;
+    let lastPlacedIndex = 0;
+    let newIdx = 0;
+    let nextOldFiber = null;
+    let step = newChildren.next();
+
+    for (; oldFiber !== null && !step.done; newIdx++, step = newChildren.next()) {
+      if (oldFiber.index > newIdx) {
+        nextOldFiber = oldFiber;
+        oldFiber = null;
+      } else {
+        nextOldFiber = oldFiber.sibling;
+      }
+
+      const newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
+
+      if (newFiber === null) {
+        // TODO: This breaks on empty slots like null children. That's
+        // unfortunate because it triggers the slow path all the time. We need
+        // a better way to communicate whether this was a miss or null,
+        // boolean, undefined, etc.
+        if (oldFiber === null) {
+          oldFiber = nextOldFiber;
+        }
+
+        break;
+      }
+
+      if (shouldTrackSideEffects) {
+        if (oldFiber && newFiber.alternate === null) {
+          // We matched the slot, but we didn't reuse the existing fiber, so we
+          // need to delete the existing child.
+          deleteChild(returnFiber, oldFiber);
+        }
+      }
+
+      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+      if (previousNewFiber === null) {
+        // TODO: Move out of the loop. This only happens for the first run.
+        resultingFirstChild = newFiber;
+      } else {
+        // TODO: Defer siblings if we're not at the right index for this slot.
+        // I.e. if we had null values before, then we want to defer this
+        // for each null value. However, we also don't want to call updateSlot
+        // with the previous one.
+        previousNewFiber.sibling = newFiber;
+      }
+
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
+    }
+
+    if (step.done) {
+      // We've reached the end of the new children. We can delete the rest.
+      deleteRemainingChildren(returnFiber, oldFiber);
+
+      if (getIsHydrating()) {
+        const numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
+
+      return resultingFirstChild;
+    }
+
+    if (oldFiber === null) {
+      // If we don't have any more existing children we can choose a fast path
+      // since the rest will all be insertions.
+      for (; !step.done; newIdx++, step = newChildren.next()) {
+        const newFiber = createChild(returnFiber, step.value, lanes);
+
+        if (newFiber === null) {
+          continue;
+        }
+
+        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          // TODO: Move out of the loop. This only happens for the first run.
+          resultingFirstChild = newFiber;
+        } else {
+          previousNewFiber.sibling = newFiber;
+        }
+
+        previousNewFiber = newFiber;
+      }
+
+      if (getIsHydrating()) {
+        const numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
+
+      return resultingFirstChild;
+    } // Add all children to a key map for quick lookups.
+
+
+    const existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
+
+    for (; !step.done; newIdx++, step = newChildren.next()) {
+      const newFiber = updateFromMap(existingChildren, returnFiber, newIdx, step.value, lanes);
+
+      if (newFiber !== null) {
+        if (shouldTrackSideEffects) {
+          if (newFiber.alternate !== null) {
+            // The new fiber is a work in progress, but if there exists a
+            // current, that means that we reused the fiber. We need to delete
+            // it from the child list so that we don't add it to the deletion
+            // list.
+            existingChildren.delete(newFiber.key === null ? newIdx : newFiber.key);
+          }
+        }
+
+        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          resultingFirstChild = newFiber;
+        } else {
+          previousNewFiber.sibling = newFiber;
+        }
+
+        previousNewFiber = newFiber;
+      }
+    }
+
+    if (shouldTrackSideEffects) {
+      // Any existing children that weren't consumed above were deleted. We need
+      // to add them to the deletion list.
+      existingChildren.forEach(child => deleteChild(returnFiber, child));
+    }
+
+    if (getIsHydrating()) {
+      const numberOfForks = newIdx;
+      pushTreeFork(returnFiber, numberOfForks);
+    }
+
+    return resultingFirstChild;
+  }
+
+  function reconcileSingleTextNode(returnFiber, currentFirstChild, textContent, lanes) {
+    // There's no need to check for keys on text nodes since we don't have a
+    // way to define them.
+    if (currentFirstChild !== null && currentFirstChild.tag === HostText) {
+      // We already have an existing node so let's just update it and delete
+      // the rest.
+      deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+      const existing = useFiber(currentFirstChild, textContent);
+      existing.return = returnFiber;
+      return existing;
+    } // The existing first child is not a text node so we need to create one
+    // and delete the existing ones.
+
+
+    deleteRemainingChildren(returnFiber, currentFirstChild);
+    const created = createFiberFromText(textContent, returnFiber.mode, lanes);
+    created.return = returnFiber;
+    return created;
+  }
+
+  function reconcileSingleElement(returnFiber, currentFirstChild, element, lanes) {
+    const key = element.key;
+    let child = currentFirstChild;
+
+    while (child !== null) {
+      // TODO: If key === null and child.key === null, then this only applies to
+      // the first item in the list.
+      if (child.key === key) {
+        const elementType = element.type;
+
+        if (elementType === REACT_FRAGMENT_TYPE) {
+          if (child.tag === Fragment) {
+            deleteRemainingChildren(returnFiber, child.sibling);
+            const existing = useFiber(child, element.props.children);
+            existing.return = returnFiber;
+
+            return existing;
+          }
+        } else {
+          if (child.elementType === elementType || ( // Keep this check inline so it only runs on the false path:
+          false) || // Lazy types should reconcile their resolved type.
+          // We need to do this after the Hot Reloading check above,
+          // because hot reloading has different semantics than prod because
+          // it doesn't resuspend. So we can't let the call below suspend.
+          typeof elementType === 'object' && elementType !== null && elementType.$$typeof === REACT_LAZY_TYPE && resolveLazy(elementType) === child.type) {
+            deleteRemainingChildren(returnFiber, child.sibling);
+            const existing = useFiber(child, element.props);
+            existing.ref = coerceRef(returnFiber, child, element);
+            existing.return = returnFiber;
+
+            return existing;
+          }
+        } // Didn't match.
+
+
+        deleteRemainingChildren(returnFiber, child);
+        break;
+      } else {
+        deleteChild(returnFiber, child);
+      }
+
+      child = child.sibling;
+    }
+
+    if (element.type === REACT_FRAGMENT_TYPE) {
+      const created = createFiberFromFragment(element.props.children, returnFiber.mode, lanes, element.key);
+      created.return = returnFiber;
+      return created;
+    } else {
+      const created = createFiberFromElement(element, returnFiber.mode, lanes);
+      created.ref = coerceRef(returnFiber, currentFirstChild, element);
+      created.return = returnFiber;
+      return created;
+    }
+  }
+
+  function reconcileSinglePortal(returnFiber, currentFirstChild, portal, lanes) {
+    const key = portal.key;
+    let child = currentFirstChild;
+
+    while (child !== null) {
+      // TODO: If key === null and child.key === null, then this only applies to
+      // the first item in the list.
+      if (child.key === key) {
+        if (child.tag === HostPortal && child.stateNode.containerInfo === portal.containerInfo && child.stateNode.implementation === portal.implementation) {
+          deleteRemainingChildren(returnFiber, child.sibling);
+          const existing = useFiber(child, portal.children || []);
+          existing.return = returnFiber;
+          return existing;
+        } else {
+          deleteRemainingChildren(returnFiber, child);
+          break;
+        }
+      } else {
+        deleteChild(returnFiber, child);
+      }
+
+      child = child.sibling;
+    }
+
+    const created = createFiberFromPortal(portal, returnFiber.mode, lanes);
+    created.return = returnFiber;
+    return created;
+  } // This API will tag the children with the side-effect of the reconciliation
+  // itself. They will be added to the side-effect list as we pass through the
+  // children and the parent.
+
+
+  function reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes) {
+    // This function is not recursive.
+    // If the top level item is an array, we treat it as a set of children,
+    // not as a fragment. Nested arrays on the other hand will be treated as
+    // fragment nodes. Recursion happens at the normal flow.
+    // Handle top level unkeyed fragments as if they were arrays.
+    // This leads to an ambiguity between <>{[...]}</> and <>...</>.
+    // We treat the ambiguous cases above the same.
+    // TODO: Let's use recursion like we do for Usable nodes?
+    const isUnkeyedTopLevelFragment = typeof newChild === 'object' && newChild !== null && newChild.type === REACT_FRAGMENT_TYPE && newChild.key === null;
+
+    if (isUnkeyedTopLevelFragment) {
+      newChild = newChild.props.children;
+    } // Handle object types
+
+
+    if (typeof newChild === 'object' && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          return placeSingleChild(reconcileSingleElement(returnFiber, currentFirstChild, newChild, lanes));
+
+        case REACT_PORTAL_TYPE:
+          return placeSingleChild(reconcileSinglePortal(returnFiber, currentFirstChild, newChild, lanes));
+
+        case REACT_LAZY_TYPE:
+          const payload = newChild._payload;
+          const init = newChild._init; // TODO: This function is supposed to be non-recursive.
+
+          return reconcileChildFibers(returnFiber, currentFirstChild, init(payload), lanes);
+      }
+
+      if (isArray(newChild)) {
+        return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, lanes);
+      }
+
+      if (getIteratorFn(newChild)) {
+        return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, lanes);
+      } // Usables are a valid React node type. When React encounters a Usable in
+      // a child position, it unwraps it using the same algorithm as `use`. For
+      // example, for promises, React will throw an exception to unwind the
+      // stack, then replay the component once the promise resolves.
+      //
+      // A difference from `use` is that React will keep unwrapping the value
+      // until it reaches a non-Usable type.
+      //
+      // e.g. Usable<Usable<Usable<T>>> should resolve to T
+      //
+      // The structure is a bit unfortunate. Ideally, we shouldn't need to
+      // replay the entire begin phase of the parent fiber in order to reconcile
+      // the children again. This would require a somewhat significant refactor,
+      // because reconcilation happens deep within the begin phase, and
+      // depending on the type of work, not always at the end. We should
+      // consider as an future improvement.
+
+
+      if (typeof newChild.then === 'function') {
+        const thenable = newChild;
+        return reconcileChildFibersImpl(returnFiber, currentFirstChild, unwrapThenable(thenable), lanes);
+      }
+
+      if (newChild.$$typeof === REACT_CONTEXT_TYPE || newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+        const context = newChild;
+        return reconcileChildFibersImpl(returnFiber, currentFirstChild, readContextDuringReconcilation(returnFiber, context, lanes), lanes);
+      }
+
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+
+    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {
+      return placeSingleChild(reconcileSingleTextNode(returnFiber, currentFirstChild, '' + newChild, lanes));
+    }
+
+
+    return deleteRemainingChildren(returnFiber, currentFirstChild);
+  }
+
+  function reconcileChildFibers(returnFiber, currentFirstChild, newChild, lanes) {
+    // This indirection only exists so we can reset `thenableState` at the end.
+    // It should get inlined by Closure.
+    thenableIndexCounter$1 = 0;
+    const firstChildFiber = reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes);
+    thenableState$1 = null; // Don't bother to reset `thenableIndexCounter` to 0 because it always gets
+    // set at the beginning.
+
+    return firstChildFiber;
+  }
+
+  return reconcileChildFibers;
+}
+
+const reconcileChildFibers = createChildReconciler(true);
+const mountChildFibers = createChildReconciler(false);
+function resetChildReconcilerOnUnwind() {
+  // On unwind, clear any pending thenables that were used.
+  thenableState$1 = null;
+  thenableIndexCounter$1 = 0;
+}
+function cloneChildFibers(current, workInProgress) {
+  if (current !== null && workInProgress.child !== current.child) {
+    throw Error(formatProdErrorMessage(153));
+  }
+
+  if (workInProgress.child === null) {
+    return;
+  }
+
+  let currentChild = workInProgress.child;
+  let newChild = createWorkInProgress(currentChild, currentChild.pendingProps);
+  workInProgress.child = newChild;
+  newChild.return = workInProgress;
+
+  while (currentChild.sibling !== null) {
+    currentChild = currentChild.sibling;
+    newChild = newChild.sibling = createWorkInProgress(currentChild, currentChild.pendingProps);
+    newChild.return = workInProgress;
+  }
+
+  newChild.sibling = null;
+} // Reset a workInProgress child set to prepare it for a second pass.
+
+function resetChildFibers(workInProgress, lanes) {
+  let child = workInProgress.child;
+
+  while (child !== null) {
+    resetWorkInProgress(child, lanes);
+    child = child.sibling;
+  }
+}
+
+// TODO: This isn't being used yet, but it's intended to replace the
+// InvisibleParentContext that is currently managed by SuspenseContext.
+
+const currentTreeHiddenStackCursor = createCursor(null);
+const prevEntangledRenderLanesCursor = createCursor(NoLanes);
+function pushHiddenContext(fiber, context) {
+  const prevEntangledRenderLanes = getEntangledRenderLanes();
+  push(prevEntangledRenderLanesCursor, prevEntangledRenderLanes);
+  push(currentTreeHiddenStackCursor, context); // When rendering a subtree that's currently hidden, we must include all
+  // lanes that would have rendered if the hidden subtree hadn't been deferred.
+  // That is, in order to reveal content from hidden -> visible, we must commit
+  // all the updates that we skipped when we originally hid the tree.
+
+  setEntangledRenderLanes(mergeLanes(prevEntangledRenderLanes, context.baseLanes));
+}
+function reuseHiddenContextOnStack(fiber) {
+  // This subtree is not currently hidden, so we don't need to add any lanes
+  // to the render lanes. But we still need to push something to avoid a
+  // context mismatch. Reuse the existing context on the stack.
+  push(prevEntangledRenderLanesCursor, getEntangledRenderLanes());
+  push(currentTreeHiddenStackCursor, currentTreeHiddenStackCursor.current);
+}
+function popHiddenContext(fiber) {
+  // Restore the previous render lanes from the stack
+  setEntangledRenderLanes(prevEntangledRenderLanesCursor.current);
+  pop(currentTreeHiddenStackCursor);
+  pop(prevEntangledRenderLanesCursor);
+}
+function isCurrentTreeHidden() {
+  return currentTreeHiddenStackCursor.current !== null;
+}
+
+// suspends, i.e. it's the nearest `catch` block on the stack.
+
+const suspenseHandlerStackCursor = createCursor(null); // Represents the outermost boundary that is not visible in the current tree.
+// Everything above this is the "shell". When this is null, it means we're
+// rendering in the shell of the app. If it's non-null, it means we're rendering
+// deeper than the shell, inside a new tree that wasn't already visible.
+//
+// The main way we use this concept is to determine whether showing a fallback
+// would result in a desirable or undesirable loading state. Activing a fallback
+// in the shell is considered an undersirable loading state, because it would
+// mean hiding visible (albeit stale) content in the current tree — we prefer to
+// show the stale content, rather than switch to a fallback. But showing a
+// fallback in a new tree is fine, because there's no stale content to
+// prefer instead.
+
+let shellBoundary = null;
+function getShellBoundary() {
+  return shellBoundary;
+}
+function pushPrimaryTreeSuspenseHandler(handler) {
+  // TODO: Pass as argument
+  const current = handler.alternate;
+  // propagated a single level. For example, when ForceSuspenseFallback is set,
+  // it should only force the nearest Suspense boundary into fallback mode.
+
+  pushSuspenseListContext(handler, setDefaultShallowSuspenseListContext(suspenseStackCursor.current)); // Experimental feature: Some Suspense boundaries are marked as having an
+  // to push a nested Suspense handler, because it will get replaced by the
+  // outer fallback, anyway. Consider this as a future optimization.
+
+
+  push(suspenseHandlerStackCursor, handler);
+
+  if (shellBoundary === null) {
+    if (current === null || isCurrentTreeHidden()) {
+      // This boundary is not visible in the current UI.
+      shellBoundary = handler;
+    } else {
+      const prevState = current.memoizedState;
+
+      if (prevState !== null) {
+        // This boundary is showing a fallback in the current UI.
+        shellBoundary = handler;
+      }
+    }
+  }
+}
+function pushFallbackTreeSuspenseHandler(fiber) {
+  // We're about to render the fallback. If something in the fallback suspends,
+  // it's akin to throwing inside of a `catch` block. This boundary should not
+  // capture. Reuse the existing handler on the stack.
+  reuseSuspenseHandlerOnStack(fiber);
+}
+function pushOffscreenSuspenseHandler(fiber) {
+  if (fiber.tag === OffscreenComponent) {
+    // A SuspenseList context is only pushed here to avoid a push/pop mismatch.
+    // Reuse the current value on the stack.
+    // TODO: We can avoid needing to push here by by forking popSuspenseHandler
+    // into separate functions for Suspense and Offscreen.
+    pushSuspenseListContext(fiber, suspenseStackCursor.current);
+    push(suspenseHandlerStackCursor, fiber);
+
+    if (shellBoundary !== null) ; else {
+      const current = fiber.alternate;
+
+      if (current !== null) {
+        const prevState = current.memoizedState;
+
+        if (prevState !== null) {
+          // This is the first boundary in the stack that's already showing
+          // a fallback. So everything outside is considered the shell.
+          shellBoundary = fiber;
+        }
+      }
+    }
+  } else {
+    // This is a LegacyHidden component.
+    reuseSuspenseHandlerOnStack(fiber);
+  }
+}
+function reuseSuspenseHandlerOnStack(fiber) {
+  pushSuspenseListContext(fiber, suspenseStackCursor.current);
+  push(suspenseHandlerStackCursor, getSuspenseHandler());
+}
+function getSuspenseHandler() {
+  return suspenseHandlerStackCursor.current;
+}
+function popSuspenseHandler(fiber) {
+  pop(suspenseHandlerStackCursor);
+
+  if (shellBoundary === fiber) {
+    // Popping back into the shell.
+    shellBoundary = null;
+  }
+
+  popSuspenseListContext();
+} // SuspenseList context
+// TODO: Move to a separate module? We may change the SuspenseList
+// implementation to hide/show in the commit phase, anyway.
+
+const DefaultSuspenseContext = 0b00;
+const SubtreeSuspenseContextMask = 0b01; // ForceSuspenseFallback can be used by SuspenseList to force newly added
+// items into their fallback state during one of the render passes.
+
+const ForceSuspenseFallback = 0b10;
+const suspenseStackCursor = createCursor(DefaultSuspenseContext);
+function hasSuspenseListContext(parentContext, flag) {
+  return (parentContext & flag) !== 0;
+}
+function setDefaultShallowSuspenseListContext(parentContext) {
+  return parentContext & SubtreeSuspenseContextMask;
+}
+function setShallowSuspenseListContext(parentContext, shallowContext) {
+  return parentContext & SubtreeSuspenseContextMask | shallowContext;
+}
+function pushSuspenseListContext(fiber, newContext) {
+  push(suspenseStackCursor, newContext);
+}
+function popSuspenseListContext(fiber) {
+  pop(suspenseStackCursor);
+}
+
+// A non-null SuspenseState means that it is blocked for one reason or another.
+// - A non-null dehydrated field means it's blocked pending hydration.
+//   - A non-null dehydrated field can use isSuspenseInstancePending or
+//     isSuspenseInstanceFallback to query the reason for being dehydrated.
+// - A null dehydrated field means it's blocked by something suspending and
+//   we're currently showing a fallback instead.
+
+function findFirstSuspended(row) {
+  let node = row;
+
+  while (node !== null) {
+    if (node.tag === SuspenseComponent) {
+      const state = node.memoizedState;
+
+      if (state !== null) {
+        const dehydrated = state.dehydrated;
+
+        if (dehydrated === null || isSuspenseInstancePending(dehydrated) || isSuspenseInstanceFallback(dehydrated)) {
+          return node;
+        }
+      }
+    } else if (node.tag === SuspenseListComponent && // revealOrder undefined can't be trusted because it don't
+    // keep track of whether it suspended or not.
+    node.memoizedProps.revealOrder !== undefined) {
+      const didSuspend = (node.flags & DidCapture) !== NoFlags$1;
+
+      if (didSuspend) {
+        return node;
+      }
+    } else if (node.child !== null) {
+      node.child.return = node;
+      node = node.child;
+      continue;
+    }
+
+    if (node === row) {
+      return null;
+    }
+
+    while (node.sibling === null) {
+      if (node.return === null || node.return === row) {
+        return null;
+      }
+
+      node = node.return;
+    }
+
+    node.sibling.return = node.return;
+    node = node.sibling;
+  }
+
+  return null;
+}
+
+const NoFlags =
+/*   */
+0b0000; // Represents whether effect should fire.
+
+const HasEffect =
+/* */
+0b0001; // Represents the phase in which the effect (not the clean-up) fires.
+
+const Insertion =
+/* */
+0b0010;
+const Layout =
+/*    */
+0b0100;
+const Passive =
+/*   */
+0b1000;
+
+// there's only a single root, but we do support multi root apps, hence this
+// extra complexity. But this module is optimized for the single root case.
+
+let firstScheduledRoot = null;
+let lastScheduledRoot = null; // Used to prevent redundant mircotasks from being scheduled.
+
+let didScheduleMicrotask = false; // `act` "microtasks" are scheduled on the `act` queue instead of an actual
+
+let mightHavePendingSyncWork = false;
+let isFlushingWork = false;
+let currentEventTransitionLane = NoLane;
+function ensureRootIsScheduled(root) {
+  // This function is called whenever a root receives an update. It does two
+  // things 1) it ensures the root is in the root schedule, and 2) it ensures
+  // there's a pending microtask to process the root schedule.
+  //
+  // Most of the actual scheduling logic does not happen until
+  // `scheduleTaskForRootDuringMicrotask` runs.
+  // Add the root to the schedule
+  if (root === lastScheduledRoot || root.next !== null) ; else {
+    if (lastScheduledRoot === null) {
+      firstScheduledRoot = lastScheduledRoot = root;
+    } else {
+      lastScheduledRoot.next = root;
+      lastScheduledRoot = root;
+    }
+  } // Any time a root received an update, we set this to true until the next time
+  // we process the schedule. If it's false, then we can quickly exit flushSync
+  // without consulting the schedule.
+
+
+  mightHavePendingSyncWork = true; // At the end of the current event, go through each of the roots and ensure
+  // there's a task scheduled for each one at the correct priority.
+
+  {
+    if (!didScheduleMicrotask) {
+      didScheduleMicrotask = true;
+      scheduleImmediateTask(processRootScheduleInMicrotask);
+    }
+  }
+}
+function flushSyncWorkOnAllRoots() {
+  // This is allowed to be called synchronously, but the caller should check
+  // the execution context first.
+  flushSyncWorkAcrossRoots_impl(false);
+}
+function flushSyncWorkOnLegacyRootsOnly() {
+  // This is allowed to be called synchronously, but the caller should check
+  // the execution context first.
+  flushSyncWorkAcrossRoots_impl(true);
+}
+
+function flushSyncWorkAcrossRoots_impl(onlyLegacy) {
+  if (isFlushingWork) {
+    // Prevent reentrancy.
+    // TODO: Is this overly defensive? The callers must check the execution
+    // context first regardless.
+    return;
+  }
+
+  if (!mightHavePendingSyncWork) {
+    // Fast path. There's no sync work to do.
+    return;
+  } // There may or may not be synchronous work scheduled. Let's check.
+
+
+  let didPerformSomeWork;
+  let errors = null;
+  isFlushingWork = true;
+
+  do {
+    didPerformSomeWork = false;
+    let root = firstScheduledRoot;
+
+    while (root !== null) {
+      if (onlyLegacy && root.tag !== LegacyRoot) ; else {
+        const workInProgressRoot = getWorkInProgressRoot();
+        const workInProgressRootRenderLanes = getWorkInProgressRootRenderLanes();
+        const nextLanes = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes);
+
+        if (includesSyncLane(nextLanes)) {
+          // This root has pending sync work. Flush it now.
+          try {
+            didPerformSomeWork = true;
+            performSyncWorkOnRoot(root, nextLanes);
+          } catch (error) {
+            // Collect errors so we can rethrow them at the end
+            if (errors === null) {
+              errors = [error];
+            } else {
+              errors.push(error);
+            }
+          }
+        }
+      }
+
+      root = root.next;
+    }
+  } while (didPerformSomeWork);
+
+  isFlushingWork = false; // If any errors were thrown, rethrow them right before exiting.
+  // TODO: Consider returning these to the caller, to allow them to decide
+  // how/when to rethrow.
+
+  if (errors !== null) {
+    if (errors.length > 1) {
+      if (typeof AggregateError === 'function') {
+        // eslint-disable-next-line no-undef
+        throw new AggregateError(errors);
+      } else {
+        for (let i = 1; i < errors.length; i++) {
+          scheduleImmediateTask(throwError.bind(null, errors[i]));
+        }
+
+        const firstError = errors[0];
+        throw firstError;
+      }
+    } else {
+      const error = errors[0];
+      throw error;
+    }
+  }
+}
+
+function throwError(error) {
+  throw error;
+}
+
+function processRootScheduleInMicrotask() {
+  // This function is always called inside a microtask. It should never be
+  // called synchronously.
+  didScheduleMicrotask = false;
+
+
+  mightHavePendingSyncWork = false;
+  const currentTime = now();
+  let prev = null;
+  let root = firstScheduledRoot;
+
+  while (root !== null) {
+    const next = root.next;
+
+    if (currentEventTransitionLane !== NoLane && shouldAttemptEagerTransition()) {
+      // A transition was scheduled during an event, but we're going to try to
+      // render it synchronously anyway. We do this during a popstate event to
+      // preserve the scroll position of the previous page.
+      upgradePendingLaneToSync(root, currentEventTransitionLane);
+    }
+
+    const nextLanes = scheduleTaskForRootDuringMicrotask(root, currentTime);
+
+    if (nextLanes === NoLane) {
+      // This root has no more pending work. Remove it from the schedule. To
+      // guard against subtle reentrancy bugs, this microtask is the only place
+      // we do this — you can add roots to the schedule whenever, but you can
+      // only remove them here.
+      // Null this out so we know it's been removed from the schedule.
+      root.next = null;
+
+      if (prev === null) {
+        // This is the new head of the list
+        firstScheduledRoot = next;
+      } else {
+        prev.next = next;
+      }
+
+      if (next === null) {
+        // This is the new tail of the list
+        lastScheduledRoot = prev;
+      }
+    } else {
+      // This root still has work. Keep it in the list.
+      prev = root;
+
+      if (includesSyncLane(nextLanes)) {
+        mightHavePendingSyncWork = true;
+      }
+    }
+
+    root = next;
+  }
+
+  currentEventTransitionLane = NoLane; // At the end of the microtask, flush any pending synchronous work. This has
+  // to come at the end, because it does actual rendering work that might throw.
+
+  flushSyncWorkOnAllRoots();
+}
+
+function scheduleTaskForRootDuringMicrotask(root, currentTime) {
+  // This function is always called inside a microtask, or at the very end of a
+  // rendering task right before we yield to the main thread. It should never be
+  // called synchronously.
+  //
+  // TODO: Unless enableDeferRootSchedulingToMicrotask is off. We need to land
+  // that ASAP to unblock additional features we have planned.
+  //
+  // This function also never performs React work synchronously; it should
+  // only schedule work to be performed later, in a separate task or microtask.
+  // Check if any lanes are being starved by other work. If so, mark them as
+  // expired so we know to work on those next.
+  markStarvedLanesAsExpired(root, currentTime); // Determine the next lanes to work on, and their priority.
+
+  const workInProgressRoot = getWorkInProgressRoot();
+  const workInProgressRootRenderLanes = getWorkInProgressRootRenderLanes();
+  const nextLanes = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes);
+  const existingCallbackNode = root.callbackNode;
+
+  if ( // Check if there's nothing to work on
+  nextLanes === NoLanes || // If this root is currently suspended and waiting for data to resolve, don't
+  // schedule a task to render it. We'll either wait for a ping, or wait to
+  // receive an update.
+  //
+  // Suspended render phase
+  root === workInProgressRoot && isWorkLoopSuspendedOnData() || // Suspended commit phase
+  root.cancelPendingCommit !== null) {
+    // Fast path: There's nothing to work on.
+    if (existingCallbackNode !== null) {
+      cancelCallback(existingCallbackNode);
+    }
+
+    root.callbackNode = null;
+    root.callbackPriority = NoLane;
+    return NoLane;
+  } // Schedule a new callback in the host environment.
+
+
+  if (includesSyncLane(nextLanes)) {
+    // Synchronous work is always flushed at the end of the microtask, so we
+    // don't need to schedule an additional task.
+    if (existingCallbackNode !== null) {
+      cancelCallback(existingCallbackNode);
+    }
+
+    root.callbackPriority = SyncLane;
+    root.callbackNode = null;
+    return SyncLane;
+  } else {
+    // We use the highest priority lane to represent the priority of the callback.
+    const existingCallbackPriority = root.callbackPriority;
+    const newCallbackPriority = getHighestPriorityLane(nextLanes);
+
+    if (newCallbackPriority === existingCallbackPriority && // Special case related to `act`. If the currently scheduled task is a
+    // Scheduler task, rather than an `act` task, cancel it and re-schedule
+    // on the `act` queue.
+    !(false  )) {
+      // The priority hasn't changed. We can reuse the existing task.
+      return newCallbackPriority;
+    } else {
+      // Cancel the existing callback. We'll schedule a new one below.
+      cancelCallback(existingCallbackNode);
+    }
+
+    let schedulerPriorityLevel;
+
+    switch (lanesToEventPriority(nextLanes)) {
+      case DiscreteEventPriority:
+        schedulerPriorityLevel = ImmediatePriority;
+        break;
+
+      case ContinuousEventPriority:
+        schedulerPriorityLevel = UserBlockingPriority;
+        break;
+
+      case DefaultEventPriority:
+        schedulerPriorityLevel = NormalPriority$1;
+        break;
+
+      case IdleEventPriority:
+        schedulerPriorityLevel = IdlePriority;
+        break;
+
+      default:
+        schedulerPriorityLevel = NormalPriority$1;
+        break;
+    }
+
+    const newCallbackNode = scheduleCallback$2(schedulerPriorityLevel, performConcurrentWorkOnRoot.bind(null, root));
+    root.callbackPriority = newCallbackPriority;
+    root.callbackNode = newCallbackNode;
+    return newCallbackPriority;
+  }
+}
+
+function getContinuationForRoot(root, originalCallbackNode) {
+  // This is called at the end of `performConcurrentWorkOnRoot` to determine
+  // if we need to schedule a continuation task.
+  //
+  // Usually `scheduleTaskForRootDuringMicrotask` only runs inside a microtask;
+  // however, since most of the logic for determining if we need a continuation
+  // versus a new task is the same, we cheat a bit and call it here. This is
+  // only safe to do because we know we're at the end of the browser task.
+  // So although it's not an actual microtask, it might as well be.
+  scheduleTaskForRootDuringMicrotask(root, now());
+
+  if (root.callbackNode === originalCallbackNode) {
+    // The task node scheduled for this root is the same one that's
+    // currently executed. Need to return a continuation.
+    return performConcurrentWorkOnRoot.bind(null, root);
+  }
+
+  return null;
+}
+
+function scheduleCallback$2(priorityLevel, callback) {
+  {
+    return scheduleCallback$3(priorityLevel, callback);
+  }
+}
+
+function cancelCallback(callbackNode) {
+  if (callbackNode !== null) {
+    cancelCallback$1(callbackNode);
+  }
+}
+
+function scheduleImmediateTask(cb) {
+  // Alternatively, can we move this check to the host config?
+
+
+  {
+    scheduleMicrotask(() => {
+      // In Safari, appending an iframe forces microtasks to run.
+      // https://github.com/facebook/react/issues/22459
+      // We don't support running callbacks in the middle of render
+      // or commit so we need to check against that.
+      const executionContext = getExecutionContext();
+
+      if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+        // Note that this would still prematurely flush the callbacks
+        // if this happens outside render or commit phase (e.g. in an event).
+        // Intentionally using a macrotask instead of a microtask here. This is
+        // wrong semantically but it prevents an infinite loop. The bug is
+        // Safari's, not ours, so we just do our best to not crash even though
+        // the behavior isn't completely correct.
+        scheduleCallback$3(ImmediatePriority, cb);
+        return;
+      }
+
+      cb();
+    });
+  }
+}
+
+function requestTransitionLane() {
+  // The algorithm for assigning an update to a lane should be stable for all
+  // updates at the same priority within the same event. To do this, the
+  // inputs to the algorithm must be the same.
+  //
+  // The trick we use is to cache the first of each of these inputs within an
+  // event. Then reset the cached values once we can be sure the event is
+  // over. Our heuristic for that is whenever we enter a concurrent work loop.
+  if (currentEventTransitionLane === NoLane) {
+    // All transitions within the same event are assigned the same lane.
+    currentEventTransitionLane = claimNextTransitionLane();
+  }
+
+  return currentEventTransitionLane;
+}
+
+// transition updates that occur while the async action is still in progress
+// are treated as part of the action.
+//
+// The ideal behavior would be to treat each async function as an independent
+// action. However, without a mechanism like AsyncContext, we can't tell which
+// action an update corresponds to. So instead, we entangle them all into one.
+// The listeners to notify once the entangled scope completes.
+
+let currentEntangledListeners = null; // The number of pending async actions in the entangled scope.
+
+let currentEntangledPendingCount = 0; // The transition lane shared by all updates in the entangled scope.
+
+let currentEntangledLane = NoLane;
+function requestAsyncActionContext(actionReturnValue, // If this is provided, this resulting thenable resolves to this value instead
+// of the return value of the action. This is a perf trick to avoid composing
+// an extra async function.
+overrideReturnValue) {
+  // This is an async action.
+  //
+  // Return a thenable that resolves once the action scope (i.e. the async
+  // function passed to startTransition) has finished running.
+  const thenable = actionReturnValue;
+  let entangledListeners;
+
+  if (currentEntangledListeners === null) {
+    // There's no outer async action scope. Create a new one.
+    entangledListeners = currentEntangledListeners = [];
+    currentEntangledPendingCount = 0;
+    currentEntangledLane = requestTransitionLane();
+  } else {
+    entangledListeners = currentEntangledListeners;
+  }
+
+  currentEntangledPendingCount++; // Create a thenable that represents the result of this action, but doesn't
+  // resolve until the entire entangled scope has finished.
+  //
+  // Expressed using promises:
+  //   const [thisResult] = await Promise.all([thisAction, entangledAction]);
+  //   return thisResult;
+
+  const resultThenable = createResultThenable(entangledListeners);
+  let resultStatus = 'pending';
+  let resultValue;
+  let rejectedReason;
+  thenable.then(value => {
+    resultStatus = 'fulfilled';
+    resultValue = overrideReturnValue !== null ? overrideReturnValue : value;
+    pingEngtangledActionScope();
+  }, error => {
+    resultStatus = 'rejected';
+    rejectedReason = error;
+    pingEngtangledActionScope();
+  }); // Attach a listener to fill in the result.
+
+  entangledListeners.push(() => {
+    switch (resultStatus) {
+      case 'fulfilled':
+        {
+          const fulfilledThenable = resultThenable;
+          fulfilledThenable.status = 'fulfilled';
+          fulfilledThenable.value = resultValue;
+          break;
+        }
+
+      case 'rejected':
+        {
+          const rejectedThenable = resultThenable;
+          rejectedThenable.status = 'rejected';
+          rejectedThenable.reason = rejectedReason;
+          break;
+        }
+
+      case 'pending':
+      default:
+        {
+          // The listener above should have been called first, so `resultStatus`
+          // should already be set to the correct value.
+          throw Error(formatProdErrorMessage(478));
+        }
+    }
+  });
+  return resultThenable;
+}
+function requestSyncActionContext(actionReturnValue, // If this is provided, this resulting thenable resolves to this value instead
+// of the return value of the action. This is a perf trick to avoid composing
+// an extra async function.
+overrideReturnValue) {
+  const resultValue = overrideReturnValue !== null ? overrideReturnValue : actionReturnValue; // This is not an async action, but it may be part of an outer async action.
+
+  if (currentEntangledListeners === null) {
+    return resultValue;
+  } else {
+    // Return a thenable that does not resolve until the entangled actions
+    // have finished.
+    const entangledListeners = currentEntangledListeners;
+    const resultThenable = createResultThenable(entangledListeners);
+    entangledListeners.push(() => {
+      const fulfilledThenable = resultThenable;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = resultValue;
+    });
+    return resultThenable;
+  }
+}
+
+function pingEngtangledActionScope() {
+  if (currentEntangledListeners !== null && --currentEntangledPendingCount === 0) {
+    // All the actions have finished. Close the entangled async action scope
+    // and notify all the listeners.
+    const listeners = currentEntangledListeners;
+    currentEntangledListeners = null;
+    currentEntangledLane = NoLane;
+
+    for (let i = 0; i < listeners.length; i++) {
+      const listener = listeners[i];
+      listener();
+    }
+  }
+}
+
+function createResultThenable(entangledListeners) {
+  // Waits for the entangled async action to complete, then resolves to the
+  // result of an individual action.
+  const resultThenable = {
+    status: 'pending',
+    value: null,
+    reason: null,
+
+    then(resolve) {
+      // This is a bit of a cheat. `resolve` expects a value of type `S` to be
+      // passed, but because we're instrumenting the `status` field ourselves,
+      // and we know this thenable will only be used by React, we also know
+      // the value isn't actually needed. So we add the resolve function
+      // directly to the entangled listeners.
+      //
+      // This is also why we don't need to check if the thenable is still
+      // pending; the Suspense implementation already performs that check.
+      const ping = resolve;
+      entangledListeners.push(ping);
+    }
+
+  };
+  return resultThenable;
+}
+
+function peekEntangledActionLane() {
+  return currentEntangledLane;
+}
+
+const ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
+      ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig;
+// lifetime of an effect. In Rust terms, a RefCell. We use it to store the
+// "destroy" function that is returned from an effect, because that is stateful.
+// The field is `undefined` if the effect is unmounted, or if the effect ran
+// but is not stateful. We don't explicitly track whether the effect is mounted
+// or unmounted because that can be inferred by the hiddenness of the fiber in
+// the tree, i.e. whether there is a hidden Offscreen fiber above it.
+//
+// It's unfortunate that this is stored on a separate object, because it adds
+// more memory per effect instance, but it's conceptually sound. I think there's
+// likely a better data structure we could use for effects; perhaps just one
+// array of effect instances per fiber. But I think this is OK for now despite
+// the additional memory and we can follow up with performance
+// optimizations later.
+// These are set right before calling the component.
+
+
+let renderLanes = NoLanes; // The work-in-progress fiber. I've named it differently to distinguish it from
+// the work-in-progress hook.
+
+let currentlyRenderingFiber$1 = null; // Hooks are stored as a linked list on the fiber's memoizedState field. The
+// current hook list is the list that belongs to the current fiber. The
+// work-in-progress hook list is a new list that will be added to the
+// work-in-progress fiber.
+
+let currentHook = null;
+let workInProgressHook = null; // Whether an update was scheduled at any point during the render phase. This
+// does not get reset if we do another render pass; only when we're completely
+// finished evaluating this component. This is an optimization so we know
+// whether we need to clear render phase updates after a throw.
+
+let didScheduleRenderPhaseUpdate = false; // Where an update was scheduled only during the current render pass. This
+// gets reset after each attempt.
+// TODO: Maybe there's some way to consolidate this with
+// `didScheduleRenderPhaseUpdate`. Or with `numberOfReRenders`.
+
+let didScheduleRenderPhaseUpdateDuringThisPass = false;
+let shouldDoubleInvokeUserFnsInHooksDEV = false; // Counts the number of useId hooks in this component.
+
+let localIdCounter = 0; // Counts number of `use`-d thenables
+
+let thenableIndexCounter = 0;
+let thenableState = null; // Used for ids that are generated completely client-side (i.e. not during
+// hydration). This counter is global, so client ids are not stable across
+// render attempts.
+
+let globalClientIdCounter = 0;
+const RE_RENDER_LIMIT = 25; // In DEV, this is the name of the currently executing primitive hook
+
+function throwInvalidHookError() {
+  throw Error(formatProdErrorMessage(321));
+}
+
+function areHookInputsEqual(nextDeps, prevDeps) {
+
+  if (prevDeps === null) {
+
+    return false;
+  }
+
+
+  for (let i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    if (objectIs(nextDeps[i], prevDeps[i])) {
+      continue;
+    }
+
+    return false;
+  }
+
+  return true;
+}
+
+function renderWithHooks(current, workInProgress, Component, props, secondArg, nextRenderLanes) {
+  renderLanes = nextRenderLanes;
+  currentlyRenderingFiber$1 = workInProgress;
+
+  workInProgress.memoizedState = null;
+  workInProgress.updateQueue = null;
+  workInProgress.lanes = NoLanes; // The following should have already been reset
+  // currentHook = null;
+  // workInProgressHook = null;
+  // didScheduleRenderPhaseUpdate = false;
+  // localIdCounter = 0;
+  // thenableIndexCounter = 0;
+  // thenableState = null;
+  // TODO Warn if no hooks are used at all during mount, then some are used during update.
+  // Currently we will identify the update render as a mount because memoizedState === null.
+  // This is tricky because it's valid for certain types of components (e.g. React.lazy)
+  // Using memoizedState to differentiate between mount/update only works if at least one stateful hook is used.
+  // Non-stateful hooks (e.g. context) don't get added to memoizedState,
+  // so memoizedState would be null during updates and mounts.
+
+  {
+    ReactCurrentDispatcher$1.current = current === null || current.memoizedState === null ? HooksDispatcherOnMount : HooksDispatcherOnUpdate;
+  } // In Strict Mode, during development, user functions are double invoked to
+  // help detect side effects. The logic for how this is implemented for in
+  // hook components is a bit complex so let's break it down.
+  //
+  // We will invoke the entire component function twice. However, during the
+  // second invocation of the component, the hook state from the first
+  // invocation will be reused. That means things like `useMemo` functions won't
+  // run again, because the deps will match and the memoized result will
+  // be reused.
+  //
+  // We want memoized functions to run twice, too, so account for this, user
+  // functions are double invoked during the *first* invocation of the component
+  // function, and are *not* double invoked during the second incovation:
+  //
+  // - First execution of component function: user functions are double invoked
+  // - Second execution of component function (in Strict Mode, during
+  //   development): user functions are not double invoked.
+  //
+  // This is intentional for a few reasons; most importantly, it's because of
+  // how `use` works when something suspends: it reuses the promise that was
+  // passed during the first attempt. This is itself a form of memoization.
+  // We need to be able to memoize the reactive inputs to the `use` call using
+  // a hook (i.e. `useMemo`), which means, the reactive inputs to `use` must
+  // come from the same component invocation as the output.
+  //
+  // There are plenty of tests to ensure this behavior is correct.
+
+
+  const shouldDoubleRenderDEV = false  ;
+  shouldDoubleInvokeUserFnsInHooksDEV = shouldDoubleRenderDEV;
+  let children = Component(props, secondArg);
+  shouldDoubleInvokeUserFnsInHooksDEV = false; // Check if there was a render phase update
+
+  if (didScheduleRenderPhaseUpdateDuringThisPass) {
+    // Keep rendering until the component stabilizes (there are no more render
+    // phase updates).
+    children = renderWithHooksAgain(workInProgress, Component, props, secondArg);
+  }
+
+  finishRenderingHooks();
+  return children;
+}
+
+function finishRenderingHooks(current, workInProgress, Component) {
+  // at the beginning of the render phase and there's no re-entrance.
+
+
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher; // This check uses currentHook so that it works the same in DEV and prod bundles.
+  // hookTypesDev could catch more cases (e.g. context) but only in DEV bundles.
+
+  const didRenderTooFewHooks = currentHook !== null && currentHook.next !== null;
+  renderLanes = NoLanes;
+  currentlyRenderingFiber$1 = null;
+  currentHook = null;
+  workInProgressHook = null;
+
+  didScheduleRenderPhaseUpdate = false; // This is reset by checkDidRenderIdHook
+  // localIdCounter = 0;
+
+  thenableIndexCounter = 0;
+  thenableState = null;
+
+  if (didRenderTooFewHooks) {
+    throw Error(formatProdErrorMessage(300));
+  }
+}
+
+function replaySuspendedComponentWithHooks(current, workInProgress, Component, props, secondArg) {
+
+  const children = renderWithHooksAgain(workInProgress, Component, props, secondArg);
+  finishRenderingHooks();
+  return children;
+}
+
+function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
+  // This is used to perform another render pass. It's used when setState is
+  // called during render, and for double invoking components in Strict Mode
+  // during development.
+  //
+  // The state from the previous pass is reused whenever possible. So, state
+  // updates that were already processed are not processed again, and memoized
+  // functions (`useMemo`) are not invoked again.
+  //
+  // Keep rendering in a loop for as long as render phase updates continue to
+  // be scheduled. Use a counter to prevent infinite loops.
+  currentlyRenderingFiber$1 = workInProgress;
+  let numberOfReRenders = 0;
+  let children;
+
+  do {
+    if (didScheduleRenderPhaseUpdateDuringThisPass) {
+      // It's possible that a use() value depended on a state that was updated in
+      // this rerender, so we need to watch for different thenables this time.
+      thenableState = null;
+    }
+
+    thenableIndexCounter = 0;
+    didScheduleRenderPhaseUpdateDuringThisPass = false;
+
+    if (numberOfReRenders >= RE_RENDER_LIMIT) {
+      throw Error(formatProdErrorMessage(301));
+    }
+
+    numberOfReRenders += 1;
+
+
+    currentHook = null;
+    workInProgressHook = null;
+    workInProgress.updateQueue = null;
+
+    ReactCurrentDispatcher$1.current = HooksDispatcherOnRerender;
+    children = Component(props, secondArg);
+  } while (didScheduleRenderPhaseUpdateDuringThisPass);
+
+  return children;
+}
+
+function renderTransitionAwareHostComponentWithHooks(current, workInProgress, lanes) {
+
+  return renderWithHooks(current, workInProgress, TransitionAwareHostComponent, null, null, lanes);
+}
+function TransitionAwareHostComponent() {
+
+  const dispatcher = ReactCurrentDispatcher$1.current;
+
+  const _dispatcher$useState = dispatcher.useState(),
+        maybeThenable = _dispatcher$useState[0];
+
+  if (typeof maybeThenable.then === 'function') {
+    const thenable = maybeThenable;
+    return useThenable(thenable);
+  } else {
+    const status = maybeThenable;
+    return status;
+  }
+}
+function checkDidRenderIdHook() {
+  // This should be called immediately after every renderWithHooks call.
+  // Conceptually, it's part of the return value of renderWithHooks; it's only a
+  // separate function to avoid using an array tuple.
+  const didRenderIdHook = localIdCounter !== 0;
+  localIdCounter = 0;
+  return didRenderIdHook;
+}
+function bailoutHooks(current, workInProgress, lanes) {
+  workInProgress.updateQueue = current.updateQueue; // TODO: Don't need to reset the flags here, because they're reset in the
+  // complete phase (bubbleProperties).
+
+  {
+    workInProgress.flags &= ~(Passive$1 | Update);
+  }
+
+  current.lanes = removeLanes(current.lanes, lanes);
+}
+function resetHooksAfterThrow() {
+  // This is called immediaetly after a throw. It shouldn't reset the entire
+  // module state, because the work loop might decide to replay the component
+  // again without rewinding.
+  //
+  // It should only reset things like the current dispatcher, to prevent hooks
+  // from being called outside of a component.
+  currentlyRenderingFiber$1 = null; // We can assume the previous dispatcher is always this one, since we set it
+  // at the beginning of the render phase and there's no re-entrance.
+
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+}
+function resetHooksOnUnwind(workInProgress) {
+  if (didScheduleRenderPhaseUpdate) {
+    // There were render phase updates. These are only valid for this render
+    // phase, which we are now aborting. Remove the updates from the queues so
+    // they do not persist to the next render. Do not remove updates from hooks
+    // that weren't processed.
+    //
+    // Only reset the updates from the queue if it has a clone. If it does
+    // not have a clone, that means it wasn't processed, and the updates were
+    // scheduled before we entered the render phase.
+    let hook = workInProgress.memoizedState;
+
+    while (hook !== null) {
+      const queue = hook.queue;
+
+      if (queue !== null) {
+        queue.pending = null;
+      }
+
+      hook = hook.next;
+    }
+
+    didScheduleRenderPhaseUpdate = false;
+  }
+
+  renderLanes = NoLanes;
+  currentlyRenderingFiber$1 = null;
+  currentHook = null;
+  workInProgressHook = null;
+
+  didScheduleRenderPhaseUpdateDuringThisPass = false;
+  localIdCounter = 0;
+  thenableIndexCounter = 0;
+  thenableState = null;
+}
+
+function mountWorkInProgressHook() {
+  const hook = {
+    memoizedState: null,
+    baseState: null,
+    baseQueue: null,
+    queue: null,
+    next: null
+  };
+
+  if (workInProgressHook === null) {
+    // This is the first hook in the list
+    currentlyRenderingFiber$1.memoizedState = workInProgressHook = hook;
+  } else {
+    // Append to the end of the list
+    workInProgressHook = workInProgressHook.next = hook;
+  }
+
+  return workInProgressHook;
+}
+
+function updateWorkInProgressHook() {
+  // This function is used both for updates and for re-renders triggered by a
+  // render phase update. It assumes there is either a current hook we can
+  // clone, or a work-in-progress hook from a previous render pass that we can
+  // use as a base.
+  let nextCurrentHook;
+
+  if (currentHook === null) {
+    const current = currentlyRenderingFiber$1.alternate;
+
+    if (current !== null) {
+      nextCurrentHook = current.memoizedState;
+    } else {
+      nextCurrentHook = null;
+    }
+  } else {
+    nextCurrentHook = currentHook.next;
+  }
+
+  let nextWorkInProgressHook;
+
+  if (workInProgressHook === null) {
+    nextWorkInProgressHook = currentlyRenderingFiber$1.memoizedState;
+  } else {
+    nextWorkInProgressHook = workInProgressHook.next;
+  }
+
+  if (nextWorkInProgressHook !== null) {
+    // There's already a work-in-progress. Reuse it.
+    workInProgressHook = nextWorkInProgressHook;
+    nextWorkInProgressHook = workInProgressHook.next;
+    currentHook = nextCurrentHook;
+  } else {
+    // Clone from the current hook.
+    if (nextCurrentHook === null) {
+      const currentFiber = currentlyRenderingFiber$1.alternate;
+
+      if (currentFiber === null) {
+        // This is the initial render. This branch is reached when the component
+        // suspends, resumes, then renders an additional hook.
+        // Should never be reached because we should switch to the mount dispatcher first.
+        throw Error(formatProdErrorMessage(467));
+      } else {
+        // This is an update. We should always have a current hook.
+        throw Error(formatProdErrorMessage(310));
+      }
+    }
+
+    currentHook = nextCurrentHook;
+    const newHook = {
+      memoizedState: currentHook.memoizedState,
+      baseState: currentHook.baseState,
+      baseQueue: currentHook.baseQueue,
+      queue: currentHook.queue,
+      next: null
+    };
+
+    if (workInProgressHook === null) {
+      // This is the first hook in the list.
+      currentlyRenderingFiber$1.memoizedState = workInProgressHook = newHook;
+    } else {
+      // Append to the end of the list.
+      workInProgressHook = workInProgressHook.next = newHook;
+    }
+  }
+
+  return workInProgressHook;
+} // NOTE: defining two versions of this function to avoid size impact when this feature is disabled.
+// Previously this function was inlined, the additional `memoCache` property makes it not inlined.
+
+
+let createFunctionComponentUpdateQueue;
+
+{
+  createFunctionComponentUpdateQueue = () => {
+    return {
+      lastEffect: null,
+      events: null,
+      stores: null,
+      memoCache: null
+    };
+  };
+}
+
+function useThenable(thenable) {
+  // Track the position of the thenable within this fiber.
+  const index = thenableIndexCounter;
+  thenableIndexCounter += 1;
+
+  if (thenableState === null) {
+    thenableState = createThenableState();
+  }
+
+  const result = trackUsedThenable(thenableState, thenable, index);
+
+  if (currentlyRenderingFiber$1.alternate === null && (workInProgressHook === null ? currentlyRenderingFiber$1.memoizedState === null : workInProgressHook.next === null)) {
+    // Initial render, and either this is the first time the component is
+    // called, or there were no Hooks called after this use() the previous
+    // time (perhaps because it threw). Subsequent Hook calls should use the
+    // mount dispatcher.
+    {
+      ReactCurrentDispatcher$1.current = HooksDispatcherOnMount;
+    }
+  }
+
+  return result;
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable;
+      return useThenable(thenable);
+    } else if (usable.$$typeof === REACT_CONTEXT_TYPE || usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+  throw Error(formatProdErrorMessage(438, String(usable)));
+}
+
+function useMemoCache(size) {
+  let memoCache = null; // Fast-path, load memo cache from wip fiber if already prepared
+
+  let updateQueue = currentlyRenderingFiber$1.updateQueue;
+
+  if (updateQueue !== null) {
+    memoCache = updateQueue.memoCache;
+  } // Otherwise clone from the current fiber
+
+
+  if (memoCache == null) {
+    const current = currentlyRenderingFiber$1.alternate;
+
+    if (current !== null) {
+      const currentUpdateQueue = current.updateQueue;
+
+      if (currentUpdateQueue !== null) {
+        const currentMemoCache = currentUpdateQueue.memoCache;
+
+        if (currentMemoCache != null) {
+          memoCache = {
+            data: currentMemoCache.data.map(array => 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;
+  let data = memoCache.data[memoCache.index];
+
+  if (data === undefined) {
+    data = memoCache.data[memoCache.index] = new Array(size);
+
+    for (let i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL;
+    }
+  }
+
+  memoCache.index++;
+  return data;
+}
+
+function basicStateReducer(state, action) {
+  // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
+  return typeof action === 'function' ? action(state) : action;
+}
+
+function mountReducer(reducer, initialArg, init) {
+  const hook = mountWorkInProgressHook();
+  let initialState;
+
+  if (init !== undefined) {
+    initialState = init(initialArg);
+  } else {
+    initialState = initialArg;
+  }
+
+  hook.memoizedState = hook.baseState = initialState;
+  const queue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    lastRenderedReducer: reducer,
+    lastRenderedState: initialState
+  };
+  hook.queue = queue;
+  const dispatch = queue.dispatch = dispatchReducerAction.bind(null, currentlyRenderingFiber$1, queue);
+  return [hook.memoizedState, dispatch];
+}
+
+function updateReducer(reducer, initialArg, init) {
+  const hook = updateWorkInProgressHook();
+  return updateReducerImpl(hook, currentHook, reducer);
+}
+
+function updateReducerImpl(hook, current, reducer) {
+  const queue = hook.queue;
+
+  if (queue === null) {
+    throw Error(formatProdErrorMessage(311));
+  }
+
+  queue.lastRenderedReducer = reducer; // The last rebase update that is NOT part of the base state.
+
+  let baseQueue = hook.baseQueue; // The last pending update that hasn't been processed yet.
+
+  const pendingQueue = queue.pending;
+
+  if (pendingQueue !== null) {
+    // We have new updates that haven't been processed yet.
+    // We'll add them to the base queue.
+    if (baseQueue !== null) {
+      // Merge the pending queue and the base queue.
+      const baseFirst = baseQueue.next;
+      const pendingFirst = pendingQueue.next;
+      baseQueue.next = pendingFirst;
+      pendingQueue.next = baseFirst;
+    }
+
+    current.baseQueue = baseQueue = pendingQueue;
+    queue.pending = null;
+  }
+
+  if (baseQueue !== null) {
+    // We have a queue to process.
+    const first = baseQueue.next;
+    let newState = hook.baseState;
+    let newBaseState = null;
+    let newBaseQueueFirst = null;
+    let newBaseQueueLast = null;
+    let update = first;
+
+    do {
+      // An extra OffscreenLane bit is added to updates that were made to
+      // a hidden tree, so that we can distinguish them from updates that were
+      // already there when the tree was hidden.
+      const updateLane = removeLanes(update.lane, OffscreenLane);
+      const isHiddenUpdate = updateLane !== update.lane; // Check if this update was made while the tree was hidden. If so, then
+      // it's not a "base" update and we should disregard the extra base lanes
+      // that were added to renderLanes when we entered the Offscreen tree.
+
+      const shouldSkipUpdate = isHiddenUpdate ? !isSubsetOfLanes(getWorkInProgressRootRenderLanes(), updateLane) : !isSubsetOfLanes(renderLanes, updateLane);
+
+      if (shouldSkipUpdate) {
+        // Priority is insufficient. Skip this update. If this is the first
+        // skipped update, the previous update/state is the new base
+        // update/state.
+        const clone = {
+          lane: updateLane,
+          revertLane: update.revertLane,
+          action: update.action,
+          hasEagerState: update.hasEagerState,
+          eagerState: update.eagerState,
+          next: null
+        };
+
+        if (newBaseQueueLast === null) {
+          newBaseQueueFirst = newBaseQueueLast = clone;
+          newBaseState = newState;
+        } else {
+          newBaseQueueLast = newBaseQueueLast.next = clone;
+        } // Update the remaining priority in the queue.
+        // TODO: Don't need to accumulate this. Instead, we can remove
+        // renderLanes from the original lanes.
+
+
+        currentlyRenderingFiber$1.lanes = mergeLanes(currentlyRenderingFiber$1.lanes, updateLane);
+        markSkippedUpdateLanes(updateLane);
+      } else {
+        // This update does have sufficient priority.
+        // Check if this is an optimistic update.
+        const revertLane = update.revertLane;
+
+        if (revertLane === NoLane) {
+          // This is not an optimistic update, and we're going to apply it now.
+          // But, if there were earlier updates that were skipped, we need to
+          // leave this update in the queue so it can be rebased later.
+          if (newBaseQueueLast !== null) {
+            const clone = {
+              // This update is going to be committed so we never want uncommit
+              // it. Using NoLane works because 0 is a subset of all bitmasks, so
+              // this will never be skipped by the check above.
+              lane: NoLane,
+              revertLane: NoLane,
+              action: update.action,
+              hasEagerState: update.hasEagerState,
+              eagerState: update.eagerState,
+              next: null
+            };
+            newBaseQueueLast = newBaseQueueLast.next = clone;
+          }
+        } else {
+          // This is an optimistic update. If the "revert" priority is
+          // sufficient, don't apply the update. Otherwise, apply the update,
+          // but leave it in the queue so it can be either reverted or
+          // rebased in a subsequent render.
+          if (isSubsetOfLanes(renderLanes, revertLane)) {
+            // The transition that this optimistic update is associated with
+            // has finished. Pretend the update doesn't exist by skipping
+            // over it.
+            update = update.next;
+            continue;
+          } else {
+            const clone = {
+              // Once we commit an optimistic update, we shouldn't uncommit it
+              // until the transition it is associated with has finished
+              // (represented by revertLane). Using NoLane here works because 0
+              // is a subset of all bitmasks, so this will never be skipped by
+              // the check above.
+              lane: NoLane,
+              // Reuse the same revertLane so we know when the transition
+              // has finished.
+              revertLane: update.revertLane,
+              action: update.action,
+              hasEagerState: update.hasEagerState,
+              eagerState: update.eagerState,
+              next: null
+            };
+
+            if (newBaseQueueLast === null) {
+              newBaseQueueFirst = newBaseQueueLast = clone;
+              newBaseState = newState;
+            } else {
+              newBaseQueueLast = newBaseQueueLast.next = clone;
+            } // Update the remaining priority in the queue.
+            // TODO: Don't need to accumulate this. Instead, we can remove
+            // renderLanes from the original lanes.
+
+
+            currentlyRenderingFiber$1.lanes = mergeLanes(currentlyRenderingFiber$1.lanes, revertLane);
+            markSkippedUpdateLanes(revertLane);
+          }
+        } // Process this update.
+
+
+        const action = update.action;
+
+        if (shouldDoubleInvokeUserFnsInHooksDEV) {
+          reducer(newState, action);
+        }
+
+        if (update.hasEagerState) {
+          // If this update is a state update (not a reducer) and was processed eagerly,
+          // we can use the eagerly computed state
+          newState = update.eagerState;
+        } else {
+          newState = reducer(newState, action);
+        }
+      }
+
+      update = update.next;
+    } while (update !== null && update !== first);
+
+    if (newBaseQueueLast === null) {
+      newBaseState = newState;
+    } else {
+      newBaseQueueLast.next = newBaseQueueFirst;
+    } // Mark that the fiber performed work, but only if the new state is
+    // different from the current state.
+
+
+    if (!objectIs(newState, hook.memoizedState)) {
+      markWorkInProgressReceivedUpdate();
+    }
+
+    hook.memoizedState = newState;
+    hook.baseState = newBaseState;
+    hook.baseQueue = newBaseQueueLast;
+    queue.lastRenderedState = newState;
+  }
+
+  if (baseQueue === null) {
+    // `queue.lanes` is used for entangling transitions. We can set it back to
+    // zero once the queue is empty.
+    queue.lanes = NoLanes;
+  }
+
+  const dispatch = queue.dispatch;
+  return [hook.memoizedState, dispatch];
+}
+
+function rerenderReducer(reducer, initialArg, init) {
+  const hook = updateWorkInProgressHook();
+  const queue = hook.queue;
+
+  if (queue === null) {
+    throw Error(formatProdErrorMessage(311));
+  }
+
+  queue.lastRenderedReducer = reducer; // This is a re-render. Apply the new render phase updates to the previous
+  // work-in-progress hook.
+
+  const dispatch = queue.dispatch;
+  const lastRenderPhaseUpdate = queue.pending;
+  let newState = hook.memoizedState;
+
+  if (lastRenderPhaseUpdate !== null) {
+    // The queue doesn't persist past this render pass.
+    queue.pending = null;
+    const firstRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+    let update = firstRenderPhaseUpdate;
+
+    do {
+      // Process this render phase update. We don't have to check the
+      // priority because it will always be the same as the current
+      // render's.
+      const action = update.action;
+      newState = reducer(newState, action);
+      update = update.next;
+    } while (update !== firstRenderPhaseUpdate); // Mark that the fiber performed work, but only if the new state is
+    // different from the current state.
+
+
+    if (!objectIs(newState, hook.memoizedState)) {
+      markWorkInProgressReceivedUpdate();
+    }
+
+    hook.memoizedState = newState; // Don't persist the state accumulated from the render phase updates to
+    // the base state unless the queue is empty.
+    // TODO: Not sure if this is the desired semantics, but it's what we
+    // do for gDSFP. I can't remember why.
+
+    if (hook.baseQueue === null) {
+      hook.baseState = newState;
+    }
+
+    queue.lastRenderedState = newState;
+  }
+
+  return [newState, dispatch];
+}
+
+function mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  const fiber = currentlyRenderingFiber$1;
+  const hook = mountWorkInProgressHook();
+  let nextSnapshot;
+  const isHydrating = getIsHydrating();
+
+  if (isHydrating) {
+    if (getServerSnapshot === undefined) {
+      throw Error(formatProdErrorMessage(407));
+    }
+
+    nextSnapshot = getServerSnapshot();
+  } else {
+    nextSnapshot = getSnapshot();
+    // Right before committing, we will walk the tree and check if any of the
+    // stores were mutated.
+    //
+    // We won't do this if we're hydrating server-rendered content, because if
+    // the content is stale, it's already visible anyway. Instead we'll patch
+    // it up in a passive effect.
+
+
+    const root = getWorkInProgressRoot();
+
+    if (root === null) {
+      throw Error(formatProdErrorMessage(349));
+    }
+
+    const rootRenderLanes = getWorkInProgressRootRenderLanes();
+
+    if (!includesBlockingLane(root, rootRenderLanes)) {
+      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+    }
+  } // Read the current snapshot from the store on every render. This breaks the
+  // normal rules of React, and only works because store updates are
+  // always synchronous.
+
+
+  hook.memoizedState = nextSnapshot;
+  const inst = {
+    value: nextSnapshot,
+    getSnapshot
+  };
+  hook.queue = inst; // Schedule an effect to subscribe to the store.
+
+  mountEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [subscribe]); // Schedule an effect to update the mutable instance fields. We will update
+  // this whenever subscribe, getSnapshot, or value changes. Because there's no
+  // clean-up function, and we track the deps correctly, we can call pushEffect
+  // directly, without storing any additional state. For the same reason, we
+  // don't need to set a static flag, either.
+
+  fiber.flags |= Passive$1;
+  pushEffect(HasEffect | Passive, updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot), createEffectInstance(), null);
+  return nextSnapshot;
+}
+
+function updateSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  const fiber = currentlyRenderingFiber$1;
+  const hook = updateWorkInProgressHook(); // Read the current snapshot from the store on every render. This breaks the
+  // normal rules of React, and only works because store updates are
+  // always synchronous.
+
+  let nextSnapshot;
+  const isHydrating = getIsHydrating();
+
+  if (isHydrating) {
+    // Needed for strict mode double render
+    if (getServerSnapshot === undefined) {
+      throw Error(formatProdErrorMessage(407));
+    }
+
+    nextSnapshot = getServerSnapshot();
+  } else {
+    nextSnapshot = getSnapshot();
+  }
+
+  const prevSnapshot = (currentHook || hook).memoizedState;
+  const snapshotChanged = !objectIs(prevSnapshot, nextSnapshot);
+
+  if (snapshotChanged) {
+    hook.memoizedState = nextSnapshot;
+    markWorkInProgressReceivedUpdate();
+  }
+
+  const inst = hook.queue;
+  updateEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [subscribe]); // Whenever getSnapshot or subscribe changes, we need to check in the
+  // commit phase if there was an interleaved mutation. In concurrent mode
+  // this can happen all the time, but even in synchronous mode, an earlier
+  // effect may have mutated the store.
+
+  if (inst.getSnapshot !== getSnapshot || snapshotChanged || // Check if the subscribe function changed. We can save some memory by
+  // checking whether we scheduled a subscription effect above.
+  workInProgressHook !== null && workInProgressHook.memoizedState.tag & HasEffect) {
+    fiber.flags |= Passive$1;
+    pushEffect(HasEffect | Passive, updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot), createEffectInstance(), null); // Unless we're rendering a blocking lane, schedule a consistency check.
+    // Right before committing, we will walk the tree and check if any of the
+    // stores were mutated.
+
+    const root = getWorkInProgressRoot();
+
+    if (root === null) {
+      throw Error(formatProdErrorMessage(349));
+    }
+
+    if (!isHydrating && !includesBlockingLane(root, renderLanes)) {
+      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+    }
+  }
+
+  return nextSnapshot;
+}
+
+function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
+  fiber.flags |= StoreConsistency;
+  const check = {
+    getSnapshot,
+    value: renderedSnapshot
+  };
+  let componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.stores = [check];
+  } else {
+    const stores = componentUpdateQueue.stores;
+
+    if (stores === null) {
+      componentUpdateQueue.stores = [check];
+    } else {
+      stores.push(check);
+    }
+  }
+}
+
+function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
+  // These are updated in the passive phase
+  inst.value = nextSnapshot;
+  inst.getSnapshot = getSnapshot; // Something may have been mutated in between render and commit. This could
+  // have been in an event that fired before the passive effects, or it could
+  // have been in a layout effect. In that case, we would have used the old
+  // snapsho and getSnapshot values to bail out. We need to check one more time.
+
+  if (checkIfSnapshotChanged(inst)) {
+    // Force a re-render.
+    forceStoreRerender(fiber);
+  }
+}
+
+function subscribeToStore(fiber, inst, subscribe) {
+  const handleStoreChange = () => {
+    // The store changed. Check if the snapshot changed since the last time we
+    // read from the store.
+    if (checkIfSnapshotChanged(inst)) {
+      // Force a re-render.
+      forceStoreRerender(fiber);
+    }
+  }; // Subscribe to the store and return a clean-up function.
+
+
+  return subscribe(handleStoreChange);
+}
+
+function checkIfSnapshotChanged(inst) {
+  const latestGetSnapshot = inst.getSnapshot;
+  const prevValue = inst.value;
+
+  try {
+    const nextValue = latestGetSnapshot();
+    return !objectIs(prevValue, nextValue);
+  } catch (error) {
+    return true;
+  }
+}
+
+function forceStoreRerender(fiber) {
+  const root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, fiber, SyncLane);
+  }
+}
+
+function mountStateImpl(initialState) {
+  const hook = mountWorkInProgressHook();
+
+  if (typeof initialState === 'function') {
+    // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
+    initialState = initialState();
+  }
+
+  hook.memoizedState = hook.baseState = initialState;
+  const queue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    lastRenderedReducer: basicStateReducer,
+    lastRenderedState: initialState
+  };
+  hook.queue = queue;
+  return hook;
+}
+
+function mountState(initialState) {
+  const hook = mountStateImpl(initialState);
+  const queue = hook.queue;
+  const dispatch = dispatchSetState.bind(null, currentlyRenderingFiber$1, queue);
+  queue.dispatch = dispatch;
+  return [hook.memoizedState, dispatch];
+}
+
+function updateState(initialState) {
+  return updateReducer(basicStateReducer);
+}
+
+function rerenderState(initialState) {
+  return rerenderReducer(basicStateReducer);
+}
+
+function mountOptimistic(passthrough, reducer) {
+  const hook = mountWorkInProgressHook();
+  hook.memoizedState = hook.baseState = passthrough;
+  const queue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    // Optimistic state does not use the eager update optimization.
+    lastRenderedReducer: null,
+    lastRenderedState: null
+  };
+  hook.queue = queue; // This is different than the normal setState function.
+
+  const dispatch = dispatchOptimisticSetState.bind(null, currentlyRenderingFiber$1, true, queue);
+  queue.dispatch = dispatch;
+  return [passthrough, dispatch];
+}
+
+function updateOptimistic(passthrough, reducer) {
+  const hook = updateWorkInProgressHook();
+  return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
+}
+
+function updateOptimisticImpl(hook, current, passthrough, reducer) {
+  // Optimistic updates are always rebased on top of the latest value passed in
+  // as an argument. It's called a passthrough because if there are no pending
+  // updates, it will be returned as-is.
+  //
+  // Reset the base state to the passthrough. Future updates will be applied
+  // on top of this.
+  hook.baseState = passthrough; // If a reducer is not provided, default to the same one used by useState.
+
+  const resolvedReducer = typeof reducer === 'function' ? reducer : basicStateReducer;
+  return updateReducerImpl(hook, currentHook, resolvedReducer);
+}
+
+function rerenderOptimistic(passthrough, reducer) {
+  // Unlike useState, useOptimistic doesn't support render phase updates.
+  // Also unlike useState, we need to replay all pending updates again in case
+  // the passthrough value changed.
+  //
+  // So instead of a forked re-render implementation that knows how to handle
+  // render phase udpates, we can use the same implementation as during a
+  // regular mount or update.
+  const hook = updateWorkInProgressHook();
+
+  if (currentHook !== null) {
+    // This is an update. Process the update queue.
+    return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
+  } // This is a mount. No updates to process.
+  // Reset the base state to the passthrough. Future updates will be applied
+  // on top of this.
+
+
+  hook.baseState = passthrough;
+  const dispatch = hook.queue.dispatch;
+  return [passthrough, dispatch];
+} // useFormState actions run sequentially, because each action receives the
+// previous state as an argument. We store pending actions on a queue.
+
+
+function dispatchFormState(fiber, actionQueue, setState, payload) {
+  if (isRenderPhaseUpdate(fiber)) {
+    throw Error(formatProdErrorMessage(485));
+  }
+
+  const last = actionQueue.pending;
+
+  if (last === null) {
+    // There are no pending actions; this is the first one. We can run
+    // it immediately.
+    const newLast = {
+      payload,
+      next: null // circular
+
+    };
+    newLast.next = actionQueue.pending = newLast;
+    runFormStateAction(actionQueue, setState, payload);
+  } else {
+    // There's already an action running. Add to the queue.
+    const first = last.next;
+    const newLast = {
+      payload,
+      next: first
+    };
+    actionQueue.pending = last.next = newLast;
+  }
+}
+
+function runFormStateAction(actionQueue, setState, payload) {
+  const action = actionQueue.action;
+  const prevState = actionQueue.state; // This is a fork of startTransition
+
+  const prevTransition = ReactCurrentBatchConfig$3.transition;
+  ReactCurrentBatchConfig$3.transition = {};
+
+  try {
+    const returnValue = action(prevState, payload);
+
+    if (returnValue !== null && typeof returnValue === 'object' && // $FlowFixMe[method-unbinding]
+    typeof returnValue.then === 'function') {
+      const thenable = returnValue; // Attach a listener to read the return state of the action. As soon as
+      // this resolves, we can run the next action in the sequence.
+
+      thenable.then(nextState => {
+        actionQueue.state = nextState;
+        finishRunningFormStateAction(actionQueue, setState);
+      }, () => finishRunningFormStateAction(actionQueue, setState));
+      const entangledResult = requestAsyncActionContext(thenable, null);
+      setState(entangledResult);
+    } else {
+      // This is either `returnValue` or a thenable that resolves to
+      // `returnValue`, depending on whether we're inside an async action scope.
+      const entangledResult = requestSyncActionContext(returnValue, null);
+      setState(entangledResult);
+      const nextState = returnValue;
+      actionQueue.state = nextState;
+      finishRunningFormStateAction(actionQueue, setState);
+    }
+  } catch (error) {
+    // This is a trick to get the `useFormState` hook to rethrow the error.
+    // When it unwraps the thenable with the `use` algorithm, the error
+    // will be thrown.
+    const rejectedThenable = {
+      then() {},
+
+      status: 'rejected',
+      reason: error // $FlowFixMe: Not sure why this doesn't work
+
+    };
+    setState(rejectedThenable);
+    finishRunningFormStateAction(actionQueue, setState);
+  } finally {
+    ReactCurrentBatchConfig$3.transition = prevTransition;
+  }
+}
+
+function finishRunningFormStateAction(actionQueue, setState) {
+  // The action finished running. Pop it from the queue and run the next pending
+  // action, if there are any.
+  const last = actionQueue.pending;
+
+  if (last !== null) {
+    const first = last.next;
+
+    if (first === last) {
+      // This was the last action in the queue.
+      actionQueue.pending = null;
+    } else {
+      // Remove the first node from the circular queue.
+      const next = first.next;
+      last.next = next; // Run the next action.
+
+      runFormStateAction(actionQueue, setState, next.payload);
+    }
+  }
+}
+
+function formStateReducer(oldState, newState) {
+  return newState;
+}
+
+function mountFormState(action, initialStateProp, permalink) {
+  let initialState = initialStateProp;
+
+  if (getIsHydrating()) {
+    const root = getWorkInProgressRoot();
+    const ssrFormState = root.formState; // If a formState option was passed to the root, there are form state
+    // markers that we need to hydrate. These indicate whether the form state
+    // matches this hook instance.
+
+    if (ssrFormState !== null) {
+      const isMatching = tryToClaimNextHydratableFormMarkerInstance();
+
+      if (isMatching) {
+        initialState = ssrFormState[0];
+      }
+    }
+  } // State hook. The state is stored in a thenable which is then unwrapped by
+  // the `use` algorithm during render.
+
+
+  const stateHook = mountWorkInProgressHook();
+  stateHook.memoizedState = stateHook.baseState = initialState; // TODO: Typing this "correctly" results in recursion limit errors
+  // const stateQueue: UpdateQueue<S | Awaited<S>, S | Awaited<S>> = {
+
+  const stateQueue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    lastRenderedReducer: formStateReducer,
+    lastRenderedState: initialState
+  };
+  stateHook.queue = stateQueue;
+  const setState = dispatchSetState.bind(null, currentlyRenderingFiber$1, stateQueue);
+  stateQueue.dispatch = setState; // Action queue hook. This is used to queue pending actions. The queue is
+  // shared between all instances of the hook. Similar to a regular state queue,
+  // but different because the actions are run sequentially, and they run in
+  // an event instead of during render.
+
+  const actionQueueHook = mountWorkInProgressHook();
+  const actionQueue = {
+    state: initialState,
+    dispatch: null,
+    // circular
+    action,
+    pending: null
+  };
+  actionQueueHook.queue = actionQueue;
+  const dispatch = dispatchFormState.bind(null, currentlyRenderingFiber$1, actionQueue, setState);
+  actionQueue.dispatch = dispatch; // Stash the action function on the memoized state of the hook. We'll use this
+  // to detect when the action function changes so we can update it in
+  // an effect.
+
+  actionQueueHook.memoizedState = action;
+  return [initialState, dispatch];
+}
+
+function updateFormState(action, initialState, permalink) {
+  const stateHook = updateWorkInProgressHook();
+  const currentStateHook = currentHook;
+  return updateFormStateImpl(stateHook, currentStateHook, action);
+}
+
+function updateFormStateImpl(stateHook, currentStateHook, action, initialState, permalink) {
+  const _updateReducerImpl = updateReducerImpl(stateHook, currentStateHook, formStateReducer),
+        actionResult = _updateReducerImpl[0]; // This will suspend until the action finishes.
+
+
+  const state = typeof actionResult === 'object' && actionResult !== null && // $FlowFixMe[method-unbinding]
+  typeof actionResult.then === 'function' ? useThenable(actionResult) : actionResult;
+  const actionQueueHook = updateWorkInProgressHook();
+  const actionQueue = actionQueueHook.queue;
+  const dispatch = actionQueue.dispatch; // Check if a new action was passed. If so, update it in an effect.
+
+  const prevAction = actionQueueHook.memoizedState;
+
+  if (action !== prevAction) {
+    currentlyRenderingFiber$1.flags |= Passive$1;
+    pushEffect(HasEffect | Passive, formStateActionEffect.bind(null, actionQueue, action), createEffectInstance(), null);
+  }
+
+  return [state, dispatch];
+}
+
+function formStateActionEffect(actionQueue, action) {
+  actionQueue.action = action;
+}
+
+function rerenderFormState(action, initialState, permalink) {
+  // Unlike useState, useFormState doesn't support render phase updates.
+  // Also unlike useState, we need to replay all pending updates again in case
+  // the passthrough value changed.
+  //
+  // So instead of a forked re-render implementation that knows how to handle
+  // render phase udpates, we can use the same implementation as during a
+  // regular mount or update.
+  const stateHook = updateWorkInProgressHook();
+  const currentStateHook = currentHook;
+
+  if (currentStateHook !== null) {
+    // This is an update. Process the update queue.
+    return updateFormStateImpl(stateHook, currentStateHook, action);
+  } // This is a mount. No updates to process.
+
+
+  const state = stateHook.memoizedState;
+  const actionQueueHook = updateWorkInProgressHook();
+  const actionQueue = actionQueueHook.queue;
+  const dispatch = actionQueue.dispatch; // This may have changed during the rerender.
+
+  actionQueueHook.memoizedState = action;
+  return [state, dispatch];
+}
+
+function pushEffect(tag, create, inst, deps) {
+  const effect = {
+    tag,
+    create,
+    inst,
+    deps,
+    // Circular
+    next: null
+  };
+  let componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.lastEffect = effect.next = effect;
+  } else {
+    const lastEffect = componentUpdateQueue.lastEffect;
+
+    if (lastEffect === null) {
+      componentUpdateQueue.lastEffect = effect.next = effect;
+    } else {
+      const firstEffect = lastEffect.next;
+      lastEffect.next = effect;
+      effect.next = firstEffect;
+      componentUpdateQueue.lastEffect = effect;
+    }
+  }
+
+  return effect;
+}
+
+function createEffectInstance() {
+  return {
+    destroy: undefined
+  };
+}
+
+function mountRef(initialValue) {
+  const hook = mountWorkInProgressHook();
+
+  {
+    const ref = {
+      current: initialValue
+    };
+    hook.memoizedState = ref;
+    return ref;
+  }
+}
+
+function updateRef(initialValue) {
+  const hook = updateWorkInProgressHook();
+  return hook.memoizedState;
+}
+
+function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
+  const hook = mountWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(HasEffect | hookFlags, create, createEffectInstance(), nextDeps);
+}
+
+function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
+  const hook = updateWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  const effect = hook.memoizedState;
+  const inst = effect.inst; // currentHook is null on initial mount when rerendering after a render phase
+  // state update or for strict mode.
+
+  if (currentHook !== null) {
+    if (nextDeps !== null) {
+      const prevEffect = currentHook.memoizedState;
+      const prevDeps = prevEffect.deps;
+
+      if (areHookInputsEqual(nextDeps, prevDeps)) {
+        hook.memoizedState = pushEffect(hookFlags, create, inst, nextDeps);
+        return;
+      }
+    }
+  }
+
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(HasEffect | hookFlags, create, inst, nextDeps);
+}
+
+function mountEffect(create, deps) {
+  {
+    mountEffectImpl(Passive$1 | PassiveStatic, Passive, create, deps);
+  }
+}
+
+function updateEffect(create, deps) {
+  updateEffectImpl(Passive$1, Passive, create, deps);
+}
+
+function useEffectEventImpl(payload) {
+  currentlyRenderingFiber$1.flags |= Update;
+  let componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.events = [payload];
+  } else {
+    const events = componentUpdateQueue.events;
+
+    if (events === null) {
+      componentUpdateQueue.events = [payload];
+    } else {
+      events.push(payload);
+    }
+  }
+}
+
+function mountEvent(callback) {
+  const hook = mountWorkInProgressHook();
+  const ref = {
+    impl: callback
+  };
+  hook.memoizedState = ref; // $FlowIgnore[incompatible-return]
+
+  return function eventFn() {
+    if (isInvalidExecutionContextForEventFunction()) {
+      throw Error(formatProdErrorMessage(440));
+    }
+
+    return ref.impl.apply(undefined, arguments);
+  };
+}
+
+function updateEvent(callback) {
+  const hook = updateWorkInProgressHook();
+  const ref = hook.memoizedState;
+  useEffectEventImpl({
+    ref,
+    nextImpl: callback
+  }); // $FlowIgnore[incompatible-return]
+
+  return function eventFn() {
+    if (isInvalidExecutionContextForEventFunction()) {
+      throw Error(formatProdErrorMessage(440));
+    }
+
+    return ref.impl.apply(undefined, arguments);
+  };
+}
+
+function mountInsertionEffect(create, deps) {
+  mountEffectImpl(Update, Insertion, create, deps);
+}
+
+function updateInsertionEffect(create, deps) {
+  return updateEffectImpl(Update, Insertion, create, deps);
+}
+
+function mountLayoutEffect(create, deps) {
+  let fiberFlags = Update | LayoutStatic;
+
+  return mountEffectImpl(fiberFlags, Layout, create, deps);
+}
+
+function updateLayoutEffect(create, deps) {
+  return updateEffectImpl(Update, Layout, create, deps);
+}
+
+function imperativeHandleEffect(create, ref) {
+  if (typeof ref === 'function') {
+    const refCallback = ref;
+    const inst = create();
+    refCallback(inst);
+    return () => {
+      refCallback(null);
+    };
+  } else if (ref !== null && ref !== undefined) {
+    const refObject = ref;
+
+    const inst = create();
+    refObject.current = inst;
+    return () => {
+      refObject.current = null;
+    };
+  }
+}
+
+function mountImperativeHandle(ref, create, deps) {
+
+
+  const effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+  let fiberFlags = Update | LayoutStatic;
+
+  mountEffectImpl(fiberFlags, Layout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
+}
+
+function updateImperativeHandle(ref, create, deps) {
+
+
+  const effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+  updateEffectImpl(Update, Layout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
+}
+
+function mountDebugValue(value, formatterFn) {// This hook is normally a no-op.
+  // The react-debug-hooks package injects its own implementation
+  // so that e.g. DevTools can display custom hook values.
+}
+
+const updateDebugValue = mountDebugValue;
+
+function mountCallback(callback, deps) {
+  const hook = mountWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  hook.memoizedState = [callback, nextDeps];
+  return callback;
+}
+
+function updateCallback(callback, deps) {
+  const hook = updateWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  const prevState = hook.memoizedState;
+
+  if (nextDeps !== null) {
+    const prevDeps = prevState[1];
+
+    if (areHookInputsEqual(nextDeps, prevDeps)) {
+      return prevState[0];
+    }
+  }
+
+  hook.memoizedState = [callback, nextDeps];
+  return callback;
+}
+
+function mountMemo(nextCreate, deps) {
+  const hook = mountWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+
+  if (shouldDoubleInvokeUserFnsInHooksDEV) {
+    nextCreate();
+  }
+
+  const nextValue = nextCreate();
+  hook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
+
+function updateMemo(nextCreate, deps) {
+  const hook = updateWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  const prevState = hook.memoizedState; // Assume these are defined. If they're not, areHookInputsEqual will warn.
+
+  if (nextDeps !== null) {
+    const prevDeps = prevState[1];
+
+    if (areHookInputsEqual(nextDeps, prevDeps)) {
+      return prevState[0];
+    }
+  }
+
+  if (shouldDoubleInvokeUserFnsInHooksDEV) {
+    nextCreate();
+  }
+
+  const nextValue = nextCreate();
+  hook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
+
+function mountDeferredValue(value, initialValue) {
+  const hook = mountWorkInProgressHook();
+  return mountDeferredValueImpl(hook, value, initialValue);
+}
+
+function updateDeferredValue(value, initialValue) {
+  const hook = updateWorkInProgressHook();
+  const resolvedCurrentHook = currentHook;
+  const prevValue = resolvedCurrentHook.memoizedState;
+  return updateDeferredValueImpl(hook, prevValue, value, initialValue);
+}
+
+function rerenderDeferredValue(value, initialValue) {
+  const hook = updateWorkInProgressHook();
+
+  if (currentHook === null) {
+    // This is a rerender during a mount.
+    return mountDeferredValueImpl(hook, value, initialValue);
+  } else {
+    // This is a rerender during an update.
+    const prevValue = currentHook.memoizedState;
+    return updateDeferredValueImpl(hook, prevValue, value, initialValue);
+  }
+}
+
+function mountDeferredValueImpl(hook, value, initialValue) {
+  if (// When `initialValue` is provided, we defer the initial render even if the
+  // current render is not synchronous.
+  initialValue !== undefined && // However, to avoid waterfalls, we do not defer if this render
+  // was itself spawned by an earlier useDeferredValue. Check if DeferredLane
+  // is part of the render lanes.
+  !includesSomeLane(renderLanes, DeferredLane)) {
+    // Render with the initial value
+    hook.memoizedState = initialValue; // Schedule a deferred render to switch to the final value.
+
+    const deferredLane = requestDeferredLane();
+    currentlyRenderingFiber$1.lanes = mergeLanes(currentlyRenderingFiber$1.lanes, deferredLane);
+    markSkippedUpdateLanes(deferredLane);
+    return initialValue;
+  } else {
+    hook.memoizedState = value;
+    return value;
+  }
+}
+
+function updateDeferredValueImpl(hook, prevValue, value, initialValue) {
+  if (objectIs(value, prevValue)) {
+    // The incoming value is referentially identical to the currently rendered
+    // value, so we can bail out quickly.
+    return value;
+  } else {
+    // Received a new value that's different from the current value.
+    // Check if we're inside a hidden tree
+    if (isCurrentTreeHidden()) {
+      // Revealing a prerendered tree is considered the same as mounting new
+      // one, so we reuse the "mount" path in this case.
+      const resultValue = mountDeferredValueImpl(hook, value, initialValue); // Unlike during an actual mount, we need to mark this as an update if
+      // the value changed.
+
+      if (!objectIs(resultValue, prevValue)) {
+        markWorkInProgressReceivedUpdate();
+      }
+
+      return resultValue;
+    }
+
+    const shouldDeferValue = !includesOnlyNonUrgentLanes(renderLanes);
+
+    if (shouldDeferValue) {
+      // This is an urgent update. Since the value has changed, keep using the
+      // previous value and spawn a deferred render to update it later.
+      // Schedule a deferred render
+      const deferredLane = requestDeferredLane();
+      currentlyRenderingFiber$1.lanes = mergeLanes(currentlyRenderingFiber$1.lanes, deferredLane);
+      markSkippedUpdateLanes(deferredLane); // Reuse the previous value. We do not need to mark this as an update,
+      // because we did not render a new value.
+
+      return prevValue;
+    } else {
+      // This is not an urgent update, so we can use the latest value regardless
+      // of what it is. No need to defer it.
+      // Mark this as an update to prevent the fiber from bailing out.
+      markWorkInProgressReceivedUpdate();
+      hook.memoizedState = value;
+      return value;
+    }
+  }
+}
+
+function startTransition(fiber, queue, pendingState, finishedState, callback, options) {
+  const previousPriority = getCurrentUpdatePriority();
+  setCurrentUpdatePriority(higherEventPriority(previousPriority, ContinuousEventPriority));
+  const prevTransition = ReactCurrentBatchConfig$3.transition;
+  const currentTransition = {};
+
+  {
+    // We don't really need to use an optimistic update here, because we
+    // schedule a second "revert" update below (which we use to suspend the
+    // transition until the async action scope has finished). But we'll use an
+    // optimistic update anyway to make it less likely the behavior accidentally
+    // diverges; for example, both an optimistic update and this one should
+    // share the same lane.
+    ReactCurrentBatchConfig$3.transition = currentTransition;
+    dispatchOptimisticSetState(fiber, false, queue, pendingState);
+  }
+
+  try {
+    if (enableAsyncActions) {
+      const returnValue = callback(); // Check if we're inside an async action scope. If so, we'll entangle
+      // this new action with the existing scope.
+      //
+      // If we're not already inside an async action scope, and this action is
+      // async, then we'll create a new async scope.
+      //
+      // In the async case, the resulting render will suspend until the async
+      // action scope has finished.
+
+      if (returnValue !== null && typeof returnValue === 'object' && typeof returnValue.then === 'function') {
+        const thenable = returnValue; // This is a thenable that resolves to `finishedState` once the async
+        // action scope has finished.
+
+        const entangledResult = requestAsyncActionContext(thenable, finishedState);
+        dispatchSetState(fiber, queue, entangledResult);
+      } else {
+        // This is either `finishedState` or a thenable that resolves to
+        // `finishedState`, depending on whether we're inside an async
+        // action scope.
+        const entangledResult = requestSyncActionContext(returnValue, finishedState);
+        dispatchSetState(fiber, queue, entangledResult);
+      }
+    }
+  } catch (error) {
+    {
+      // This is a trick to get the `useTransition` hook to rethrow the error.
+      // When it unwraps the thenable with the `use` algorithm, the error
+      // will be thrown.
+      const rejectedThenable = {
+        then() {},
+
+        status: 'rejected',
+        reason: error
+      };
+      dispatchSetState(fiber, queue, rejectedThenable);
+    }
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$3.transition = prevTransition;
+  }
+}
+
+function startHostTransition(formFiber, pendingState, callback, formData) {
+
+  if (formFiber.tag !== HostComponent) {
+    throw Error(formatProdErrorMessage(476));
+  }
+
+  let queue;
+
+  if (formFiber.memoizedState === null) {
+    // Upgrade this host component fiber to be stateful. We're going to pretend
+    // it was stateful all along so we can reuse most of the implementation
+    // for function components and useTransition.
+    //
+    // Create the state hook used by TransitionAwareHostComponent. This is
+    // essentially an inlined version of mountState.
+    const newQueue = {
+      pending: null,
+      lanes: NoLanes,
+      // We're going to cheat and intentionally not create a bound dispatch
+      // method, because we can call it directly in startTransition.
+      dispatch: null,
+      lastRenderedReducer: basicStateReducer,
+      lastRenderedState: NotPendingTransition
+    };
+    queue = newQueue;
+    const stateHook = {
+      memoizedState: NotPendingTransition,
+      baseState: NotPendingTransition,
+      baseQueue: null,
+      queue: newQueue,
+      next: null
+    }; // Add the state hook to both fiber alternates. The idea is that the fiber
+    // had this hook all along.
+
+    formFiber.memoizedState = stateHook;
+    const alternate = formFiber.alternate;
+
+    if (alternate !== null) {
+      alternate.memoizedState = stateHook;
+    }
+  } else {
+    // This fiber was already upgraded to be stateful.
+    const stateHook = formFiber.memoizedState;
+    queue = stateHook.queue;
+  }
+
+  startTransition(formFiber, queue, pendingState, NotPendingTransition, // TODO: We can avoid this extra wrapper, somehow. Figure out layering
+  // once more of this function is implemented.
+  () => callback(formData));
+}
+
+function mountTransition() {
+  const stateHook = mountStateImpl(false); // The `start` method never changes.
+
+  const start = startTransition.bind(null, currentlyRenderingFiber$1, stateHook.queue, true, false);
+  const hook = mountWorkInProgressHook();
+  hook.memoizedState = start;
+  return [false, start];
+}
+
+function updateTransition() {
+  const _updateState = updateState(),
+        booleanOrThenable = _updateState[0];
+
+  const hook = updateWorkInProgressHook();
+  const start = hook.memoizedState;
+  const isPending = typeof booleanOrThenable === 'boolean' ? booleanOrThenable : // This will suspend until the async action scope has finished.
+  useThenable(booleanOrThenable);
+  return [isPending, start];
+}
+
+function rerenderTransition() {
+  const _rerenderState = rerenderState(),
+        booleanOrThenable = _rerenderState[0];
+
+  const hook = updateWorkInProgressHook();
+  const start = hook.memoizedState;
+  const isPending = typeof booleanOrThenable === 'boolean' ? booleanOrThenable : // This will suspend until the async action scope has finished.
+  useThenable(booleanOrThenable);
+  return [isPending, start];
+}
+
+function useHostTransitionStatus() {
+
+  const status = readContext(HostTransitionContext);
+  return status !== null ? status : NotPendingTransition;
+}
+
+function mountId() {
+  const hook = mountWorkInProgressHook();
+  const root = getWorkInProgressRoot(); // TODO: In Fizz, id generation is specific to each server config. Maybe we
+  // should do this in Fiber, too? Deferring this decision for now because
+  // there's no other place to store the prefix except for an internal field on
+  // the public createRoot object, which the fiber tree does not currently have
+  // a reference to.
+
+  const identifierPrefix = root.identifierPrefix;
+  let id;
+
+  if (getIsHydrating()) {
+    const treeId = getTreeId(); // Use a captial R prefix for server-generated ids.
+
+    id = ':' + identifierPrefix + 'R' + treeId; // Unless this is the first id at this level, append a number at the end
+    // that represents the position of this useId hook among all the useId
+    // hooks for this fiber.
+
+    const localId = localIdCounter++;
+
+    if (localId > 0) {
+      id += 'H' + localId.toString(32);
+    }
+
+    id += ':';
+  } else {
+    // Use a lowercase r prefix for client-generated ids.
+    const globalClientId = globalClientIdCounter++;
+    id = ':' + identifierPrefix + 'r' + globalClientId.toString(32) + ':';
+  }
+
+  hook.memoizedState = id;
+  return id;
+}
+
+function updateId() {
+  const hook = updateWorkInProgressHook();
+  const id = hook.memoizedState;
+  return id;
+}
+
+function mountRefresh() {
+  const hook = mountWorkInProgressHook();
+  const refresh = hook.memoizedState = refreshCache.bind(null, currentlyRenderingFiber$1);
+  return refresh;
+}
+
+function updateRefresh() {
+  const hook = updateWorkInProgressHook();
+  return hook.memoizedState;
+}
+
+function refreshCache(fiber, seedKey, seedValue) {
+  // TODO: Consider warning if the refresh is at discrete priority, or if we
+  // otherwise suspect that it wasn't batched properly.
+
+
+  let provider = fiber.return;
+
+  while (provider !== null) {
+    switch (provider.tag) {
+      case CacheComponent:
+      case HostRoot:
+        {
+          // Schedule an update on the cache boundary to trigger a refresh.
+          const lane = requestUpdateLane(provider);
+          const refreshUpdate = createUpdate(lane);
+          const root = enqueueUpdate(provider, refreshUpdate, lane);
+
+          if (root !== null) {
+            scheduleUpdateOnFiber(root, provider, lane);
+            entangleTransitions(root, provider, lane);
+          } // TODO: If a refresh never commits, the new cache created here must be
+          // released. A simple case is start refreshing a cache boundary, but then
+          // unmount that boundary before the refresh completes.
+
+
+          const seededCache = createCache();
+
+          if (seedKey !== null && seedKey !== undefined && root !== null) {
+            {
+              // Seed the cache with the value passed by the caller. This could be
+              // from a server mutation, or it could be a streaming response.
+              seededCache.data.set(seedKey, seedValue);
+            }
+          }
+
+          const payload = {
+            cache: seededCache
+          };
+          refreshUpdate.payload = payload;
+          return;
+        }
+    }
+
+    provider = provider.return;
+  } // TODO: Warn if unmounted?
+
+}
+
+function dispatchReducerAction(fiber, queue, action) {
+
+  const lane = requestUpdateLane(fiber);
+  const update = {
+    lane,
+    revertLane: NoLane,
+    action,
+    hasEagerState: false,
+    eagerState: null,
+    next: null
+  };
+
+  if (isRenderPhaseUpdate(fiber)) {
+    enqueueRenderPhaseUpdate(queue, update);
+  } else {
+    const root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitionUpdate(root, queue, lane);
+    }
+  }
+}
+
+function dispatchSetState(fiber, queue, action) {
+
+  const lane = requestUpdateLane(fiber);
+  const update = {
+    lane,
+    revertLane: NoLane,
+    action,
+    hasEagerState: false,
+    eagerState: null,
+    next: null
+  };
+
+  if (isRenderPhaseUpdate(fiber)) {
+    enqueueRenderPhaseUpdate(queue, update);
+  } else {
+    const alternate = fiber.alternate;
+
+    if (fiber.lanes === NoLanes && (alternate === null || alternate.lanes === NoLanes)) {
+      // The queue is currently empty, which means we can eagerly compute the
+      // next state before entering the render phase. If the new state is the
+      // same as the current state, we may be able to bail out entirely.
+      const lastRenderedReducer = queue.lastRenderedReducer;
+
+      if (lastRenderedReducer !== null) {
+
+        try {
+          const currentState = queue.lastRenderedState;
+          const eagerState = lastRenderedReducer(currentState, action); // Stash the eagerly computed state, and the reducer used to compute
+          // it, on the update object. If the reducer hasn't changed by the
+          // time we enter the render phase, then the eager state can be used
+          // without calling the reducer again.
+
+          update.hasEagerState = true;
+          update.eagerState = eagerState;
+
+          if (objectIs(eagerState, currentState)) {
+            // Fast path. We can bail out without scheduling React to re-render.
+            // It's still possible that we'll need to rebase this update later,
+            // if the component re-renders for a different reason and by that
+            // time the reducer has changed.
+            // TODO: Do we still need to entangle transitions in this case?
+            enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update);
+            return;
+          }
+        } catch (error) {// Suppress the error. It will throw again in the render phase.
+        } finally {
+        }
+      }
+    }
+
+    const root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitionUpdate(root, queue, lane);
+    }
+  }
+}
+
+function dispatchOptimisticSetState(fiber, throwIfDuringRender, queue, action) {
+
+  const update = {
+    // An optimistic update commits synchronously.
+    lane: SyncLane,
+    // After committing, the optimistic update is "reverted" using the same
+    // lane as the transition it's associated with.
+    revertLane: requestTransitionLane(),
+    action,
+    hasEagerState: false,
+    eagerState: null,
+    next: null
+  };
+
+  if (isRenderPhaseUpdate(fiber)) {
+    // When calling startTransition during render, this warns instead of
+    // throwing because throwing would be a breaking change. setOptimisticState
+    // is a new API so it's OK to throw.
+    if (throwIfDuringRender) {
+      throw Error(formatProdErrorMessage(479));
+    }
+  } else {
+    const root = enqueueConcurrentHookUpdate(fiber, queue, update, SyncLane);
+
+    if (root !== null) {
+      // NOTE: The optimistic update implementation assumes that the transition
+      // will never be attempted before the optimistic update. This currently
+      // holds because the optimistic update is always synchronous. If we ever
+      // change that, we'll need to account for this.
+      scheduleUpdateOnFiber(root, fiber, SyncLane); // Optimistic updates are always synchronous, so we don't need to call
+      // entangleTransitionUpdate here.
+    }
+  }
+}
+
+function isRenderPhaseUpdate(fiber) {
+  const alternate = fiber.alternate;
+  return fiber === currentlyRenderingFiber$1 || alternate !== null && alternate === currentlyRenderingFiber$1;
+}
+
+function enqueueRenderPhaseUpdate(queue, update) {
+  // This is a render phase update. Stash it in a lazily-created map of
+  // queue -> linked list of updates. After this render pass, we'll restart
+  // and apply the stashed updates on top of the work-in-progress hook.
+  didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate = true;
+  const pending = queue.pending;
+
+  if (pending === null) {
+    // This is the first update. Create a circular list.
+    update.next = update;
+  } else {
+    update.next = pending.next;
+    pending.next = update;
+  }
+
+  queue.pending = update;
+} // TODO: Move to ReactFiberConcurrentUpdates?
+
+
+function entangleTransitionUpdate(root, queue, lane) {
+  if (isTransitionLane(lane)) {
+    let queueLanes = queue.lanes; // If any entangled lanes are no longer pending on the root, then they
+    // must have finished. We can remove them from the shared queue, which
+    // represents a superset of the actually pending lanes. In some cases we
+    // may entangle more than we need to, but that's OK. In fact it's worse if
+    // we *don't* entangle when we should.
+
+    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.
+
+    const newQueueLanes = mergeLanes(queueLanes, lane);
+    queue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if
+    // the lane finished since the last time we entangled it. So we need to
+    // entangle it again, just to be sure.
+
+    markRootEntangled(root, newQueueLanes);
+  }
+}
+
+const ContextOnlyDispatcher = {
+  readContext,
+  use,
+  useCallback: throwInvalidHookError,
+  useContext: throwInvalidHookError,
+  useEffect: throwInvalidHookError,
+  useImperativeHandle: throwInvalidHookError,
+  useInsertionEffect: throwInvalidHookError,
+  useLayoutEffect: throwInvalidHookError,
+  useMemo: throwInvalidHookError,
+  useReducer: throwInvalidHookError,
+  useRef: throwInvalidHookError,
+  useState: throwInvalidHookError,
+  useDebugValue: throwInvalidHookError,
+  useDeferredValue: throwInvalidHookError,
+  useTransition: throwInvalidHookError,
+  useSyncExternalStore: throwInvalidHookError,
+  useId: throwInvalidHookError
+};
+
+{
+  ContextOnlyDispatcher.useCacheRefresh = throwInvalidHookError;
+}
+
+{
+  ContextOnlyDispatcher.useMemoCache = throwInvalidHookError;
+}
+
+{
+  ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
+}
+
+{
+  ContextOnlyDispatcher.useHostTransitionStatus = throwInvalidHookError;
+  ContextOnlyDispatcher.useFormState = throwInvalidHookError;
+}
+
+{
+  ContextOnlyDispatcher.useOptimistic = throwInvalidHookError;
+}
+
+const HooksDispatcherOnMount = {
+  readContext,
+  use,
+  useCallback: mountCallback,
+  useContext: readContext,
+  useEffect: mountEffect,
+  useImperativeHandle: mountImperativeHandle,
+  useLayoutEffect: mountLayoutEffect,
+  useInsertionEffect: mountInsertionEffect,
+  useMemo: mountMemo,
+  useReducer: mountReducer,
+  useRef: mountRef,
+  useState: mountState,
+  useDebugValue: mountDebugValue,
+  useDeferredValue: mountDeferredValue,
+  useTransition: mountTransition,
+  useSyncExternalStore: mountSyncExternalStore,
+  useId: mountId
+};
+
+{
+  HooksDispatcherOnMount.useCacheRefresh = mountRefresh;
+}
+
+{
+  HooksDispatcherOnMount.useMemoCache = useMemoCache;
+}
+
+{
+  HooksDispatcherOnMount.useEffectEvent = mountEvent;
+}
+
+{
+  HooksDispatcherOnMount.useHostTransitionStatus = useHostTransitionStatus;
+  HooksDispatcherOnMount.useFormState = mountFormState;
+}
+
+{
+  HooksDispatcherOnMount.useOptimistic = mountOptimistic;
+}
+
+const HooksDispatcherOnUpdate = {
+  readContext,
+  use,
+  useCallback: updateCallback,
+  useContext: readContext,
+  useEffect: updateEffect,
+  useImperativeHandle: updateImperativeHandle,
+  useInsertionEffect: updateInsertionEffect,
+  useLayoutEffect: updateLayoutEffect,
+  useMemo: updateMemo,
+  useReducer: updateReducer,
+  useRef: updateRef,
+  useState: updateState,
+  useDebugValue: updateDebugValue,
+  useDeferredValue: updateDeferredValue,
+  useTransition: updateTransition,
+  useSyncExternalStore: updateSyncExternalStore,
+  useId: updateId
+};
+
+{
+  HooksDispatcherOnUpdate.useCacheRefresh = updateRefresh;
+}
+
+{
+  HooksDispatcherOnUpdate.useMemoCache = useMemoCache;
+}
+
+{
+  HooksDispatcherOnUpdate.useEffectEvent = updateEvent;
+}
+
+{
+  HooksDispatcherOnUpdate.useHostTransitionStatus = useHostTransitionStatus;
+  HooksDispatcherOnUpdate.useFormState = updateFormState;
+}
+
+{
+  HooksDispatcherOnUpdate.useOptimistic = updateOptimistic;
+}
+
+const HooksDispatcherOnRerender = {
+  readContext,
+  use,
+  useCallback: updateCallback,
+  useContext: readContext,
+  useEffect: updateEffect,
+  useImperativeHandle: updateImperativeHandle,
+  useInsertionEffect: updateInsertionEffect,
+  useLayoutEffect: updateLayoutEffect,
+  useMemo: updateMemo,
+  useReducer: rerenderReducer,
+  useRef: updateRef,
+  useState: rerenderState,
+  useDebugValue: updateDebugValue,
+  useDeferredValue: rerenderDeferredValue,
+  useTransition: rerenderTransition,
+  useSyncExternalStore: updateSyncExternalStore,
+  useId: updateId
+};
+
+{
+  HooksDispatcherOnRerender.useCacheRefresh = updateRefresh;
+}
+
+{
+  HooksDispatcherOnRerender.useMemoCache = useMemoCache;
+}
+
+{
+  HooksDispatcherOnRerender.useEffectEvent = updateEvent;
+}
+
+{
+  HooksDispatcherOnRerender.useHostTransitionStatus = useHostTransitionStatus;
+  HooksDispatcherOnRerender.useFormState = rerenderFormState;
+}
+
+{
+  HooksDispatcherOnRerender.useOptimistic = rerenderOptimistic;
+}
+
+function recordLayoutEffectDuration(fiber) {
+  {
+    return;
+  }
+}
+
+function startLayoutEffectTimer() {
+  {
+    return;
+  }
+}
+
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    // Resolve default props. Taken from ReactElement
+    const props = assign({}, baseProps);
+    const defaultProps = Component.defaultProps;
+
+    for (const propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+
+    return props;
+  }
+
+  return baseProps;
+}
+
+function applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, nextProps) {
+  const prevState = workInProgress.memoizedState;
+  let partialState = getDerivedStateFromProps(nextProps, prevState);
+
+
+  const memoizedState = partialState === null || partialState === undefined ? prevState : assign({}, prevState, partialState);
+  workInProgress.memoizedState = memoizedState; // Once the update queue is empty, persist the derived state onto the
+  // base state.
+
+  if (workInProgress.lanes === NoLanes) {
+    // Queue is always non-null for classes
+    const updateQueue = workInProgress.updateQueue;
+    updateQueue.baseState = memoizedState;
+  }
+}
+
+const classComponentUpdater = {
+  isMounted,
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueSetState(inst, payload, callback) {
+    const fiber = get(inst);
+    const lane = requestUpdateLane(fiber);
+    const update = createUpdate(lane);
+    update.payload = payload;
+
+    if (callback !== undefined && callback !== null) {
+
+      update.callback = callback;
+    }
+
+    const root = enqueueUpdate(fiber, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitions(root, fiber, lane);
+    }
+  },
+
+  enqueueReplaceState(inst, payload, callback) {
+    const fiber = get(inst);
+    const lane = requestUpdateLane(fiber);
+    const update = createUpdate(lane);
+    update.tag = ReplaceState;
+    update.payload = payload;
+
+    if (callback !== undefined && callback !== null) {
+
+      update.callback = callback;
+    }
+
+    const root = enqueueUpdate(fiber, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitions(root, fiber, lane);
+    }
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueForceUpdate(inst, callback) {
+    const fiber = get(inst);
+    const lane = requestUpdateLane(fiber);
+    const update = createUpdate(lane);
+    update.tag = ForceUpdate;
+
+    if (callback !== undefined && callback !== null) {
+
+      update.callback = callback;
+    }
+
+    const root = enqueueUpdate(fiber, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitions(root, fiber, lane);
+    }
+  }
+
+};
+
+function checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {
+  const instance = workInProgress.stateNode;
+
+  if (typeof instance.shouldComponentUpdate === 'function') {
+    let shouldUpdate = instance.shouldComponentUpdate(newProps, newState, nextContext);
+
+    return shouldUpdate;
+  }
+
+  if (ctor.prototype && ctor.prototype.isPureReactComponent) {
+    return !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState);
+  }
+
+  return true;
+}
+
+function adoptClassInstance(workInProgress, instance) {
+  instance.updater = classComponentUpdater;
+  workInProgress.stateNode = instance; // The instance needs access to the fiber so that it can schedule updates
+
+  set(instance, workInProgress);
+}
+
+function constructClassInstance(workInProgress, ctor, props) {
+  let isLegacyContextConsumer = false;
+  let unmaskedContext = emptyContextObject;
+  let context = emptyContextObject;
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    context = readContext(contextType);
+  } else {
+    unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    const contextTypes = ctor.contextTypes;
+    isLegacyContextConsumer = contextTypes !== null && contextTypes !== undefined;
+    context = isLegacyContextConsumer ? getMaskedContext(workInProgress, unmaskedContext) : emptyContextObject;
+  }
+
+  let instance = new ctor(props, context); // Instantiate twice to help detect side-effects.
+
+  workInProgress.memoizedState = instance.state !== null && instance.state !== undefined ? instance.state : null;
+  adoptClassInstance(workInProgress, instance);
+  // ReactFiberContext usually updates this cache but can't for newly-created instances.
+
+
+  if (isLegacyContextConsumer) {
+    cacheContext(workInProgress, unmaskedContext, context);
+  }
+
+  return instance;
+}
+
+function callComponentWillMount(workInProgress, instance) {
+  const oldState = instance.state;
+
+  if (typeof instance.componentWillMount === 'function') {
+    instance.componentWillMount();
+  }
+
+  if (typeof instance.UNSAFE_componentWillMount === 'function') {
+    instance.UNSAFE_componentWillMount();
+  }
+
+  if (oldState !== instance.state) {
+
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+}
+
+function callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {
+  const oldState = instance.state;
+
+  if (typeof instance.componentWillReceiveProps === 'function') {
+    instance.componentWillReceiveProps(newProps, nextContext);
+  }
+
+  if (typeof instance.UNSAFE_componentWillReceiveProps === 'function') {
+    instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+  }
+
+  if (instance.state !== oldState) {
+
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+} // Invokes the mount life-cycles on a previously never rendered instance.
+
+
+function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+
+  const instance = workInProgress.stateNode;
+  instance.props = newProps;
+  instance.state = workInProgress.memoizedState;
+  instance.refs = {};
+  initializeUpdateQueue(workInProgress);
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    instance.context = readContext(contextType);
+  } else {
+    const unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    instance.context = getMaskedContext(workInProgress, unmaskedContext);
+  }
+
+  instance.state = workInProgress.memoizedState;
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+    instance.state = workInProgress.memoizedState;
+  } // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+
+  if (typeof ctor.getDerivedStateFromProps !== 'function' && typeof instance.getSnapshotBeforeUpdate !== 'function' && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
+    callComponentWillMount(workInProgress, instance); // If we had additional state updates during this life-cycle, let's
+    // process them now.
+
+    processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+    instance.state = workInProgress.memoizedState;
+  }
+
+  if (typeof instance.componentDidMount === 'function') {
+    workInProgress.flags |= Update | LayoutStatic;
+  }
+}
+
+function resumeMountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+  const instance = workInProgress.stateNode;
+  const oldProps = workInProgress.memoizedProps;
+  instance.props = oldProps;
+  const oldContext = instance.context;
+  const contextType = ctor.contextType;
+  let nextContext = emptyContextObject;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    nextContext = readContext(contextType);
+  } else {
+    const nextLegacyUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    nextContext = getMaskedContext(workInProgress, nextLegacyUnmaskedContext);
+  }
+
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+  const hasNewLifecycles = typeof getDerivedStateFromProps === 'function' || typeof instance.getSnapshotBeforeUpdate === 'function'; // Note: During these life-cycles, instance.props/instance.state are what
+  // ever the previously attempted to render - not the "current". However,
+  // during componentDidUpdate we pass the "current" props.
+  // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+  if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === 'function' || typeof instance.componentWillReceiveProps === 'function')) {
+    if (oldProps !== newProps || oldContext !== nextContext) {
+      callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
+    }
+  }
+
+  resetHasForceUpdateBeforeProcessing();
+  const oldState = workInProgress.memoizedState;
+  let newState = instance.state = oldState;
+  processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+  newState = workInProgress.memoizedState;
+
+  if (oldProps === newProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing()) {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidMount === 'function') {
+      workInProgress.flags |= Update | LayoutStatic;
+    }
+
+    return false;
+  }
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+    newState = workInProgress.memoizedState;
+  }
+
+  const shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext);
+
+  if (shouldUpdate) {
+    // In order to support react-lifecycles-compat polyfilled components,
+    // Unsafe lifecycles should not be invoked for components using the new APIs.
+    if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
+      if (typeof instance.componentWillMount === 'function') {
+        instance.componentWillMount();
+      }
+
+      if (typeof instance.UNSAFE_componentWillMount === 'function') {
+        instance.UNSAFE_componentWillMount();
+      }
+    }
+
+    if (typeof instance.componentDidMount === 'function') {
+      workInProgress.flags |= Update | LayoutStatic;
+    }
+  } else {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidMount === 'function') {
+      workInProgress.flags |= Update | LayoutStatic;
+    }
+    // memoized state to indicate that this work can be reused.
+
+
+    workInProgress.memoizedProps = newProps;
+    workInProgress.memoizedState = newState;
+  } // Update the existing instance's state, props, and context pointers even
+  // if shouldComponentUpdate returns false.
+
+
+  instance.props = newProps;
+  instance.state = newState;
+  instance.context = nextContext;
+  return shouldUpdate;
+} // Invokes the update life-cycles and returns false if it shouldn't rerender.
+
+
+function updateClassInstance(current, workInProgress, ctor, newProps, renderLanes) {
+  const instance = workInProgress.stateNode;
+  cloneUpdateQueue(current, workInProgress);
+  const unresolvedOldProps = workInProgress.memoizedProps;
+  const oldProps = workInProgress.type === workInProgress.elementType ? unresolvedOldProps : resolveDefaultProps(workInProgress.type, unresolvedOldProps);
+  instance.props = oldProps;
+  const unresolvedNewProps = workInProgress.pendingProps;
+  const oldContext = instance.context;
+  const contextType = ctor.contextType;
+  let nextContext = emptyContextObject;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    nextContext = readContext(contextType);
+  } else {
+    const nextUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    nextContext = getMaskedContext(workInProgress, nextUnmaskedContext);
+  }
+
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+  const hasNewLifecycles = typeof getDerivedStateFromProps === 'function' || typeof instance.getSnapshotBeforeUpdate === 'function'; // Note: During these life-cycles, instance.props/instance.state are what
+  // ever the previously attempted to render - not the "current". However,
+  // during componentDidUpdate we pass the "current" props.
+  // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+  if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === 'function' || typeof instance.componentWillReceiveProps === 'function')) {
+    if (unresolvedOldProps !== unresolvedNewProps || oldContext !== nextContext) {
+      callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
+    }
+  }
+
+  resetHasForceUpdateBeforeProcessing();
+  const oldState = workInProgress.memoizedState;
+  let newState = instance.state = oldState;
+  processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+  newState = workInProgress.memoizedState;
+
+  if (unresolvedOldProps === unresolvedNewProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing() && !(enableLazyContextPropagation   )) {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidUpdate === 'function') {
+      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+        workInProgress.flags |= Update;
+      }
+    }
+
+    if (typeof instance.getSnapshotBeforeUpdate === 'function') {
+      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+        workInProgress.flags |= Snapshot;
+      }
+    }
+
+    return false;
+  }
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+    newState = workInProgress.memoizedState;
+  }
+
+  const shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) || // TODO: In some cases, we'll end up checking if context has changed twice,
+  // both before and after `shouldComponentUpdate` has been called. Not ideal,
+  // but I'm loath to refactor this function. This only happens for memoized
+  // components so it's not that common.
+  enableLazyContextPropagation   ;
+
+  if (shouldUpdate) {
+    // In order to support react-lifecycles-compat polyfilled components,
+    // Unsafe lifecycles should not be invoked for components using the new APIs.
+    if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillUpdate === 'function' || typeof instance.componentWillUpdate === 'function')) {
+      if (typeof instance.componentWillUpdate === 'function') {
+        instance.componentWillUpdate(newProps, newState, nextContext);
+      }
+
+      if (typeof instance.UNSAFE_componentWillUpdate === 'function') {
+        instance.UNSAFE_componentWillUpdate(newProps, newState, nextContext);
+      }
+    }
+
+    if (typeof instance.componentDidUpdate === 'function') {
+      workInProgress.flags |= Update;
+    }
+
+    if (typeof instance.getSnapshotBeforeUpdate === 'function') {
+      workInProgress.flags |= Snapshot;
+    }
+  } else {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidUpdate === 'function') {
+      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+        workInProgress.flags |= Update;
+      }
+    }
+
+    if (typeof instance.getSnapshotBeforeUpdate === 'function') {
+      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+        workInProgress.flags |= Snapshot;
+      }
+    } // If shouldComponentUpdate returned false, we should still update the
+    // memoized props/state to indicate that this work can be reused.
+
+
+    workInProgress.memoizedProps = newProps;
+    workInProgress.memoizedState = newState;
+  } // Update the existing instance's state, props, and context pointers even
+  // if shouldComponentUpdate returns false.
+
+
+  instance.props = newProps;
+  instance.state = newState;
+  instance.context = nextContext;
+  return shouldUpdate;
+}
+
+function createCapturedValueAtFiber(value, source) {
+  // If the value is an error, call this function immediately after it is thrown
+  // so the stack is accurate.
+  return {
+    value,
+    source,
+    stack: getStackByFiberInDevAndProd(source),
+    digest: null
+  };
+}
+function createCapturedValue(value, digest, stack) {
+  return {
+    value,
+    source: null,
+    stack: stack != null ? stack : null,
+    digest: digest != null ? digest : null
+  };
+}
+
+// This module is forked in different environments.
+// By default, return `true` to log errors to the console.
+// Forks can return `false` if this isn't desirable.
+function showErrorDialog(boundary, errorInfo) {
+  return true;
+}
+
+function logCapturedError(boundary, errorInfo) {
+  try {
+    const logError = showErrorDialog(boundary, errorInfo); // Allow injected showErrorDialog() to prevent default console.error logging.
+    // This enables renderers like ReactNative to better manage redbox behavior.
+
+    if (logError === false) ;
+
+    const error = errorInfo.value;
+
+    if (false) ; else {
+      // In production, we print the error directly.
+      // This will include the message, the JS stack, and anything the browser wants to show.
+      // We pass the error object instead of custom message so that the browser displays the error natively.
+      console['error'](error); // Don't transform to our wrapper
+    }
+  } catch (e) {
+    // This method must not throw, or React internal state will get messed up.
+    // If console.error is overridden, or logCapturedError() shows a dialog that throws,
+    // we want to report this error outside of the normal stack as a last resort.
+    // https://github.com/facebook/react/issues/13188
+    setTimeout(() => {
+      throw e;
+    });
+  }
+}
+
+function createRootErrorUpdate(fiber, errorInfo, lane) {
+  const update = createUpdate(lane); // Unmount the root by rendering null.
+
+  update.tag = CaptureUpdate; // Caution: React DevTools currently depends on this property
+  // being called "element".
+
+  update.payload = {
+    element: null
+  };
+  const error = errorInfo.value;
+
+  update.callback = () => {
+    onUncaughtError(error);
+    logCapturedError(fiber, errorInfo);
+  };
+
+  return update;
+}
+
+function createClassErrorUpdate(fiber, errorInfo, lane) {
+  const update = createUpdate(lane);
+  update.tag = CaptureUpdate;
+  const getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+
+  if (typeof getDerivedStateFromError === 'function') {
+    const error = errorInfo.value;
+
+    update.payload = () => {
+      return getDerivedStateFromError(error);
+    };
+
+    update.callback = () => {
+
+      logCapturedError(fiber, errorInfo);
+    };
+  }
+
+  const inst = fiber.stateNode;
+
+  if (inst !== null && typeof inst.componentDidCatch === 'function') {
+    // $FlowFixMe[missing-this-annot]
+    update.callback = function callback() {
+
+      logCapturedError(fiber, errorInfo);
+
+      if (typeof getDerivedStateFromError !== 'function') {
+        // To preserve the preexisting retry behavior of error boundaries,
+        // we keep track of which ones already failed during this batch.
+        // This gets reset before we yield back to the browser.
+        // TODO: Warn in strict mode if getDerivedStateFromError is
+        // not defined.
+        markLegacyErrorBoundaryAsFailed(this);
+      }
+
+      const error = errorInfo.value;
+      const stack = errorInfo.stack;
+      this.componentDidCatch(error, {
+        componentStack: stack !== null ? stack : ''
+      });
+    };
+  }
+
+  return update;
+}
+
+function resetSuspendedComponent(sourceFiber, rootRenderLanes) {
+  // A legacy mode Suspense quirk, only relevant to hook components.
+
+
+  const tag = sourceFiber.tag;
+
+  if ((sourceFiber.mode & ConcurrentMode) === NoMode && (tag === FunctionComponent || tag === ForwardRef || tag === SimpleMemoComponent)) {
+    const currentSource = sourceFiber.alternate;
+
+    if (currentSource) {
+      sourceFiber.updateQueue = currentSource.updateQueue;
+      sourceFiber.memoizedState = currentSource.memoizedState;
+      sourceFiber.lanes = currentSource.lanes;
+    } else {
+      sourceFiber.updateQueue = null;
+      sourceFiber.memoizedState = null;
+    }
+  }
+}
+
+function markSuspenseBoundaryShouldCapture(suspenseBoundary, returnFiber, sourceFiber, root, rootRenderLanes) {
+  // This marks a Suspense boundary so that when we're unwinding the stack,
+  // it captures the suspended "exception" and does a second (fallback) pass.
+  if ((suspenseBoundary.mode & ConcurrentMode) === NoMode) {
+    // Legacy Mode Suspense
+    //
+    // If the boundary is in legacy mode, we should *not*
+    // suspend the commit. Pretend as if the suspended component rendered
+    // null and keep rendering. When the Suspense boundary completes,
+    // we'll do a second pass to render the fallback.
+    if (suspenseBoundary === returnFiber) {
+      // Special case where we suspended while reconciling the children of
+      // a Suspense boundary's inner Offscreen wrapper fiber. This happens
+      // when a React.lazy component is a direct child of a
+      // Suspense boundary.
+      //
+      // Suspense boundaries are implemented as multiple fibers, but they
+      // are a single conceptual unit. The legacy mode behavior where we
+      // pretend the suspended fiber committed as `null` won't work,
+      // because in this case the "suspended" fiber is the inner
+      // Offscreen wrapper.
+      //
+      // Because the contents of the boundary haven't started rendering
+      // yet (i.e. nothing in the tree has partially rendered) we can
+      // switch to the regular, concurrent mode behavior: mark the
+      // boundary with ShouldCapture and enter the unwind phase.
+      suspenseBoundary.flags |= ShouldCapture;
+    } else {
+      suspenseBoundary.flags |= DidCapture;
+      sourceFiber.flags |= ForceUpdateForLegacySuspense; // We're going to commit this fiber even though it didn't complete.
+      // But we shouldn't call any lifecycle methods or callbacks. Remove
+      // all lifecycle effect tags.
+
+      sourceFiber.flags &= ~(LifecycleEffectMask | Incomplete);
+
+      if (sourceFiber.tag === ClassComponent) {
+        const currentSourceFiber = sourceFiber.alternate;
+
+        if (currentSourceFiber === null) {
+          // This is a new mount. Change the tag so it's not mistaken for a
+          // completed class component. For example, we should not call
+          // componentWillUnmount if it is deleted.
+          sourceFiber.tag = IncompleteClassComponent;
+        } else {
+          // When we try rendering again, we should not reuse the current fiber,
+          // since it's known to be in an inconsistent state. Use a force update to
+          // prevent a bail out.
+          const update = createUpdate(SyncLane);
+          update.tag = ForceUpdate;
+          enqueueUpdate(sourceFiber, update, SyncLane);
+        }
+      } // The source fiber did not complete. Mark it with Sync priority to
+      // indicate that it still has pending work.
+
+
+      sourceFiber.lanes = mergeLanes(sourceFiber.lanes, SyncLane);
+    }
+
+    return suspenseBoundary;
+  } // Confirmed that the boundary is in a concurrent mode tree. Continue
+  // with the normal suspend path.
+  //
+  // After this we'll use a set of heuristics to determine whether this
+  // render pass will run to completion or restart or "suspend" the commit.
+  // The actual logic for this is spread out in different places.
+  //
+  // This first principle is that if we're going to suspend when we complete
+  // a root, then we should also restart if we get an update or ping that
+  // might unsuspend it, and vice versa. The only reason to suspend is
+  // because you think you might want to restart before committing. However,
+  // it doesn't make sense to restart only while in the period we're suspended.
+  //
+  // Restarting too aggressively is also not good because it starves out any
+  // intermediate loading state. So we use heuristics to determine when.
+  // Suspense Heuristics
+  //
+  // If nothing threw a Promise or all the same fallbacks are already showing,
+  // then don't suspend/restart.
+  //
+  // If this is an initial render of a new tree of Suspense boundaries and
+  // those trigger a fallback, then don't suspend/restart. We want to ensure
+  // that we can show the initial loading state as quickly as possible.
+  //
+  // If we hit a "Delayed" case, such as when we'd switch from content back into
+  // a fallback, then we should always suspend/restart. Transitions apply
+  // to this case. If none is defined, JND is used instead.
+  //
+  // If we're already showing a fallback and it gets "retried", allowing us to show
+  // another level, but there's still an inner boundary that would show a fallback,
+  // then we suspend/restart for 500ms since the last time we showed a fallback
+  // anywhere in the tree. This effectively throttles progressive loading into a
+  // consistent train of commits. This also gives us an opportunity to restart to
+  // get to the completed state slightly earlier.
+  //
+  // If there's ambiguity due to batching it's resolved in preference of:
+  // 1) "delayed", 2) "initial render", 3) "retry".
+  //
+  // We want to ensure that a "busy" state doesn't get force committed. We want to
+  // ensure that new initial loading states can commit as soon as possible.
+
+
+  suspenseBoundary.flags |= ShouldCapture; // TODO: I think we can remove this, since we now use `DidCapture` in
+  // the begin phase to prevent an early bailout.
+
+  suspenseBoundary.lanes = rootRenderLanes;
+  return suspenseBoundary;
+}
+
+function throwException(root, returnFiber, sourceFiber, value, rootRenderLanes) {
+  // The source fiber did not complete.
+  sourceFiber.flags |= Incomplete;
+
+  if (value !== null && typeof value === 'object') {
+    if (value.$$typeof === REACT_POSTPONE_TYPE) {
+      // Act as if this is an infinitely suspending promise.
+      value = {
+        then: function () {}
+      };
+    }
+
+    if (typeof value.then === 'function') {
+      // This is a wakeable. The component suspended.
+      const wakeable = value;
+      resetSuspendedComponent(sourceFiber);
+
+
+      const suspenseBoundary = getSuspenseHandler();
+
+      if (suspenseBoundary !== null) {
+        switch (suspenseBoundary.tag) {
+          case SuspenseComponent:
+            {
+              // If this suspense boundary is not already showing a fallback, mark
+              // the in-progress render as suspended. We try to perform this logic
+              // as soon as soon as possible during the render phase, so the work
+              // loop can know things like whether it's OK to switch to other tasks,
+              // or whether it can wait for data to resolve before continuing.
+              // TODO: Most of these checks are already performed when entering a
+              // Suspense boundary. We should track the information on the stack so
+              // we don't have to recompute it on demand. This would also allow us
+              // to unify with `use` which needs to perform this logic even sooner,
+              // before `throwException` is called.
+              if (sourceFiber.mode & ConcurrentMode) {
+                if (getShellBoundary() === null) {
+                  // Suspended in the "shell" of the app. This is an undesirable
+                  // loading state. We should avoid committing this tree.
+                  renderDidSuspendDelayIfPossible();
+                } else {
+                  // If we suspended deeper than the shell, we don't need to delay
+                  // the commmit. However, we still call renderDidSuspend if this is
+                  // a new boundary, to tell the work loop that a new fallback has
+                  // appeared during this render.
+                  // TODO: Theoretically we should be able to delete this branch.
+                  // It's currently used for two things: 1) to throttle the
+                  // appearance of successive loading states, and 2) in
+                  // SuspenseList, to determine whether the children include any
+                  // pending fallbacks. For 1, we should apply throttling to all
+                  // retries, not just ones that render an additional fallback. For
+                  // 2, we should check subtreeFlags instead. Then we can delete
+                  // this branch.
+                  const current = suspenseBoundary.alternate;
+
+                  if (current === null) {
+                    renderDidSuspend();
+                  }
+                }
+              }
+
+              suspenseBoundary.flags &= ~ForceClientRender;
+              markSuspenseBoundaryShouldCapture(suspenseBoundary, returnFiber, sourceFiber, root, rootRenderLanes); // Retry listener
+              //
+              // If the fallback does commit, we need to attach a different type of
+              // listener. This one schedules an update on the Suspense boundary to
+              // turn the fallback state off.
+              //
+              // Stash the wakeable on the boundary fiber so we can access it in the
+              // commit phase.
+              //
+              // When the wakeable resolves, we'll attempt to render the boundary
+              // again ("retry").
+              // Check if this is a Suspensey resource. We do not attach retry
+              // listeners to these, because we don't actually need them for
+              // rendering. Only for committing. Instead, if a fallback commits
+              // and the only thing that suspended was a Suspensey resource, we
+              // retry immediately.
+              // TODO: Refactor throwException so that we don't have to do this type
+              // check. The caller already knows what the cause was.
+
+              const isSuspenseyResource = wakeable === noopSuspenseyCommitThenable;
+
+              if (isSuspenseyResource) {
+                suspenseBoundary.flags |= ScheduleRetry;
+              } else {
+                const retryQueue = suspenseBoundary.updateQueue;
+
+                if (retryQueue === null) {
+                  suspenseBoundary.updateQueue = new Set([wakeable]);
+                } else {
+                  retryQueue.add(wakeable);
+                } // We only attach ping listeners in concurrent mode. Legacy
+                // Suspense always commits fallbacks synchronously, so there are
+                // no pings.
+
+
+                if (suspenseBoundary.mode & ConcurrentMode) {
+                  attachPingListener(root, wakeable, rootRenderLanes);
+                }
+              }
+
+              return;
+            }
+
+          case OffscreenComponent:
+            {
+              if (suspenseBoundary.mode & ConcurrentMode) {
+                suspenseBoundary.flags |= ShouldCapture;
+                const isSuspenseyResource = wakeable === noopSuspenseyCommitThenable;
+
+                if (isSuspenseyResource) {
+                  suspenseBoundary.flags |= ScheduleRetry;
+                } else {
+                  const offscreenQueue = suspenseBoundary.updateQueue;
+
+                  if (offscreenQueue === null) {
+                    const newOffscreenQueue = {
+                      transitions: null,
+                      markerInstances: null,
+                      retryQueue: new Set([wakeable])
+                    };
+                    suspenseBoundary.updateQueue = newOffscreenQueue;
+                  } else {
+                    const retryQueue = offscreenQueue.retryQueue;
+
+                    if (retryQueue === null) {
+                      offscreenQueue.retryQueue = new Set([wakeable]);
+                    } else {
+                      retryQueue.add(wakeable);
+                    }
+                  }
+
+                  attachPingListener(root, wakeable, rootRenderLanes);
+                }
+
+                return;
+              }
+            }
+        }
+
+        throw Error(formatProdErrorMessage(435, suspenseBoundary.tag));
+      } else {
+        // No boundary was found. Unless this is a sync update, this is OK.
+        // We can suspend and wait for more data to arrive.
+        if (root.tag === ConcurrentRoot) {
+          // In a concurrent root, suspending without a Suspense boundary is
+          // allowed. It will suspend indefinitely without committing.
+          //
+          // TODO: Should we have different behavior for discrete updates? What
+          // about flushSync? Maybe it should put the tree into an inert state,
+          // and potentially log a warning. Revisit this for a future release.
+          attachPingListener(root, wakeable, rootRenderLanes);
+          renderDidSuspendDelayIfPossible();
+          return;
+        } else {
+          // In a legacy root, suspending without a boundary is always an error.
+          const uncaughtSuspenseError = Error(formatProdErrorMessage(426));
+          value = uncaughtSuspenseError;
+        }
+      }
+    }
+  } // This is a regular error, not a Suspense wakeable.
+
+
+  if (getIsHydrating() && sourceFiber.mode & ConcurrentMode) {
+    const suspenseBoundary = getSuspenseHandler(); // If the error was thrown during hydration, we may be able to recover by
+    // discarding the dehydrated content and switching to a client render.
+    // Instead of surfacing the error, find the nearest Suspense boundary
+    // and render it again without hydration.
+
+    if (suspenseBoundary !== null) {
+      if ((suspenseBoundary.flags & ShouldCapture) === NoFlags$1) {
+        // Set a flag to indicate that we should try rendering the normal
+        // children again, not the fallback.
+        suspenseBoundary.flags |= ForceClientRender;
+      }
+
+      markSuspenseBoundaryShouldCapture(suspenseBoundary, returnFiber, sourceFiber, root, rootRenderLanes); // Even though the user may not be affected by this error, we should
+      // still log it so it can be fixed.
+
+      queueHydrationError(createCapturedValueAtFiber(value, sourceFiber));
+      return;
+    }
+  }
+
+  value = createCapturedValueAtFiber(value, sourceFiber);
+  renderDidError(value); // We didn't find a boundary that could handle this type of exception. Start
+  // over and traverse parent path again, this time treating the exception
+  // as an error.
+
+  let workInProgress = returnFiber;
+
+  do {
+    switch (workInProgress.tag) {
+      case HostRoot:
+        {
+          const errorInfo = value;
+          workInProgress.flags |= ShouldCapture;
+          const lane = pickArbitraryLane(rootRenderLanes);
+          workInProgress.lanes = mergeLanes(workInProgress.lanes, lane);
+          const update = createRootErrorUpdate(workInProgress, errorInfo, lane);
+          enqueueCapturedUpdate(workInProgress, update);
+          return;
+        }
+
+      case ClassComponent:
+        // Capture and retry
+        const errorInfo = value;
+        const ctor = workInProgress.type;
+        const instance = workInProgress.stateNode;
+
+        if ((workInProgress.flags & DidCapture) === NoFlags$1 && (typeof ctor.getDerivedStateFromError === 'function' || instance !== null && typeof instance.componentDidCatch === 'function' && !isAlreadyFailedLegacyErrorBoundary(instance))) {
+          workInProgress.flags |= ShouldCapture;
+          const lane = pickArbitraryLane(rootRenderLanes);
+          workInProgress.lanes = mergeLanes(workInProgress.lanes, lane); // Schedule the error boundary to re-render using updated state
+
+          const update = createClassErrorUpdate(workInProgress, errorInfo, lane);
+          enqueueCapturedUpdate(workInProgress, update);
+          return;
+        }
+
+        break;
+    } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+    workInProgress = workInProgress.return;
+  } while (workInProgress !== null);
+}
+
+const ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner; // A special exception that's used to unwind the stack when an update flows
+// into a dehydrated boundary.
+
+const SelectiveHydrationException = Error(formatProdErrorMessage(461));
+let didReceiveUpdate = false;
+
+function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
+  if (current === null) {
+    // If this is a fresh new component that hasn't been rendered yet, we
+    // won't update its child set by applying minimal side-effects. Instead,
+    // we will add them all to the child before it gets rendered. That means
+    // we can optimize this reconciliation pass by not tracking side-effects.
+    workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderLanes);
+  } else {
+    // If the current child is the same as the work in progress, it means that
+    // we haven't yet started any work on these children. Therefore, we use
+    // the clone algorithm to create a copy of all the current children.
+    // If we had any progressed work already, that is invalid at this point so
+    // let's throw it out.
+    workInProgress.child = reconcileChildFibers(workInProgress, current.child, nextChildren, renderLanes);
+  }
+}
+
+function forceUnmountCurrentAndReconcile(current, workInProgress, nextChildren, renderLanes) {
+  // This function is fork of reconcileChildren. It's used in cases where we
+  // want to reconcile without matching against the existing set. This has the
+  // effect of all current children being unmounted; even if the type and key
+  // are the same, the old child is unmounted and a new child is created.
+  //
+  // To do this, we're going to go through the reconcile algorithm twice. In
+  // the first pass, we schedule a deletion for all the current children by
+  // passing null.
+  workInProgress.child = reconcileChildFibers(workInProgress, current.child, null, renderLanes); // In the second pass, we mount the new children. The trick here is that we
+  // pass null in place of where we usually pass the current child set. This has
+  // the effect of remounting all children regardless of whether their
+  // identities match.
+
+  workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderLanes);
+}
+
+function updateForwardRef(current, workInProgress, Component, nextProps, renderLanes) {
+
+  const render = Component.render;
+  const ref = workInProgress.ref; // The rest is a fork of updateFunctionComponent
+
+  let nextChildren;
+  let hasId;
+  prepareToReadContext(workInProgress, renderLanes);
+
+  {
+    nextChildren = renderWithHooks(current, workInProgress, render, nextProps, ref, renderLanes);
+    hasId = checkDidRenderIdHook();
+  }
+
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateMemoComponent(current, workInProgress, Component, nextProps, renderLanes) {
+  if (current === null) {
+    const type = Component.type;
+
+    if (isSimpleFunctionComponent(type) && Component.compare === null && // SimpleMemoComponent codepath doesn't resolve outer props either.
+    Component.defaultProps === undefined) {
+      let resolvedType = type;
+      // and with only the default shallow comparison, we upgrade it
+      // to a SimpleMemoComponent to allow fast path updates.
+
+
+      workInProgress.tag = SimpleMemoComponent;
+      workInProgress.type = resolvedType;
+
+      return updateSimpleMemoComponent(current, workInProgress, resolvedType, nextProps, renderLanes);
+    }
+
+    const child = createFiberFromTypeAndProps(Component.type, null, nextProps, null, workInProgress, workInProgress.mode, renderLanes);
+    child.ref = workInProgress.ref;
+    child.return = workInProgress;
+    workInProgress.child = child;
+    return child;
+  }
+
+  const currentChild = current.child; // This is always exactly one child
+
+  const hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(current, renderLanes);
+
+  if (!hasScheduledUpdateOrContext) {
+    // This will be the props with resolved defaultProps,
+    // unlike current.memoizedProps which will be the unresolved ones.
+    const prevProps = currentChild.memoizedProps; // Default to shallow comparison
+
+    let compare = Component.compare;
+    compare = compare !== null ? compare : shallowEqual;
+
+    if (compare(prevProps, nextProps) && current.ref === workInProgress.ref) {
+      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    }
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+  const newChild = createWorkInProgress(currentChild, nextProps);
+  newChild.ref = workInProgress.ref;
+  newChild.return = workInProgress;
+  workInProgress.child = newChild;
+  return newChild;
+}
+
+function updateSimpleMemoComponent(current, workInProgress, Component, nextProps, renderLanes) {
+
+  if (current !== null) {
+    const prevProps = current.memoizedProps;
+
+    if (shallowEqual(prevProps, nextProps) && current.ref === workInProgress.ref && ( // Prevent bailout if the implementation changed due to hot reload.
+    true)) {
+      didReceiveUpdate = false; // The props are shallowly equal. Reuse the previous props object, like we
+      // would during a normal fiber bailout.
+      //
+      // We don't have strong guarantees that the props object is referentially
+      // equal during updates where we can't bail out anyway — like if the props
+      // are shallowly equal, but there's a local state or context update in the
+      // same batch.
+      //
+      // However, as a principle, we should aim to make the behavior consistent
+      // across different ways of memoizing a component. For example, React.memo
+      // has a different internal Fiber layout if you pass a normal function
+      // component (SimpleMemoComponent) versus if you pass a different type
+      // like forwardRef (MemoComponent). But this is an implementation detail.
+      // Wrapping a component in forwardRef (or React.lazy, etc) shouldn't
+      // affect whether the props object is reused during a bailout.
+
+      workInProgress.pendingProps = nextProps = prevProps;
+
+      if (!checkScheduledUpdateOrContext(current, renderLanes)) {
+        // The pending lanes were cleared at the beginning of beginWork. We're
+        // about to bail out, but there might be other lanes that weren't
+        // included in the current render. Usually, the priority level of the
+        // remaining updates is accumulated during the evaluation of the
+        // component (i.e. when processing the update queue). But since since
+        // we're bailing out early *without* evaluating the component, we need
+        // to account for it here, too. Reset to the value of the current fiber.
+        // NOTE: This only applies to SimpleMemoComponent, not MemoComponent,
+        // because a MemoComponent fiber does not have hooks or an update queue;
+        // rather, it wraps around an inner component, which may or may not
+        // contains hooks.
+        // TODO: Move the reset at in beginWork out of the common path so that
+        // this is no longer necessary.
+        workInProgress.lanes = current.lanes;
+        return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+      } else if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags$1) {
+        // This is a special case that only exists for legacy mode.
+        // See https://github.com/facebook/react/pull/19216.
+        didReceiveUpdate = true;
+      }
+    }
+  }
+
+  return updateFunctionComponent(current, workInProgress, Component, nextProps, renderLanes);
+}
+
+function updateOffscreenComponent(current, workInProgress, renderLanes) {
+  const nextProps = workInProgress.pendingProps;
+  const nextChildren = nextProps.children;
+  const nextIsDetached = (workInProgress.stateNode._pendingVisibility & OffscreenDetached) !== 0;
+  const prevState = current !== null ? current.memoizedState : null;
+  markRef$1(current, workInProgress);
+
+  if (nextProps.mode === 'hidden' || enableLegacyHidden  || nextIsDetached) {
+    // Rendering a hidden tree.
+    const didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
+
+    if (didSuspend) {
+      // Something suspended inside a hidden tree
+      // Include the base lanes from the last render
+      const nextBaseLanes = prevState !== null ? mergeLanes(prevState.baseLanes, renderLanes) : renderLanes;
+
+      if (current !== null) {
+        // Reset to the current children
+        let currentChild = workInProgress.child = current.child; // The current render suspended, but there may be other lanes with
+        // pending work. We can't read `childLanes` from the current Offscreen
+        // fiber because we reset it when it was deferred; however, we can read
+        // the pending lanes from the child fibers.
+
+        let currentChildLanes = NoLanes;
+
+        while (currentChild !== null) {
+          currentChildLanes = mergeLanes(mergeLanes(currentChildLanes, currentChild.lanes), currentChild.childLanes);
+          currentChild = currentChild.sibling;
+        }
+
+        const lanesWeJustAttempted = nextBaseLanes;
+        const remainingChildLanes = removeLanes(currentChildLanes, lanesWeJustAttempted);
+        workInProgress.childLanes = remainingChildLanes;
+      } else {
+        workInProgress.childLanes = NoLanes;
+        workInProgress.child = null;
+      }
+
+      return deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes);
+    }
+
+    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+      // In legacy sync mode, don't defer the subtree. Render it now.
+      // TODO: Consider how Offscreen should work with transitions in the future
+      const nextState = {
+        baseLanes: NoLanes,
+        cachePool: null
+      };
+      workInProgress.memoizedState = nextState;
+
+      {
+        // push the cache pool even though we're going to bail out
+        // because otherwise there'd be a context mismatch
+        if (current !== null) {
+          pushTransition(workInProgress, null);
+        }
+      }
+
+      reuseHiddenContextOnStack();
+      pushOffscreenSuspenseHandler(workInProgress);
+    } else if (!includesSomeLane(renderLanes, OffscreenLane)) {
+      // We're hidden, and we're not rendering at Offscreen. We will bail out
+      // and resume this tree later.
+      // Schedule this fiber to re-render at Offscreen priority
+      workInProgress.lanes = workInProgress.childLanes = laneToLanes(OffscreenLane); // Include the base lanes from the last render
+
+      const nextBaseLanes = prevState !== null ? mergeLanes(prevState.baseLanes, renderLanes) : renderLanes;
+      return deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes);
+    } else {
+      // This is the second render. The surrounding visible content has already
+      // committed. Now we resume rendering the hidden tree.
+      // Rendering at offscreen, so we can clear the base lanes.
+      const nextState = {
+        baseLanes: NoLanes,
+        cachePool: null
+      };
+      workInProgress.memoizedState = nextState;
+
+      if (current !== null) {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        const 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);
+      } // Push the lanes that were skipped when we bailed out.
+
+
+      if (prevState !== null) {
+        pushHiddenContext(workInProgress, prevState);
+      } else {
+        reuseHiddenContextOnStack();
+      }
+
+      pushOffscreenSuspenseHandler(workInProgress);
+    }
+  } else {
+    // Rendering a visible tree.
+    if (prevState !== null) {
+      // We're going from hidden -> visible.
+      let prevCachePool = null;
+
+      {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        prevCachePool = prevState.cachePool;
+      }
+
+      pushTransition(workInProgress, prevCachePool); // Push the lanes that were skipped when we bailed out.
+
+      pushHiddenContext(workInProgress, prevState);
+      reuseSuspenseHandlerOnStack(workInProgress); // Since we're not hidden anymore, reset the state
+
+      workInProgress.memoizedState = null;
+    } else {
+      // We weren't previously hidden, and we still aren't, so there's nothing
+      // special to do. Need to push to the stack regardless, though, to avoid
+      // a push/pop misalignment.
+      {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        if (current !== null) {
+          pushTransition(workInProgress, null);
+        }
+      } // We're about to bail out, but we need to push this to the stack anyway
+      // to avoid a push/pop misalignment.
+
+
+      reuseHiddenContextOnStack();
+      reuseSuspenseHandlerOnStack(workInProgress);
+    }
+  }
+
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes, renderLanes) {
+  const nextState = {
+    baseLanes: nextBaseLanes,
+    // Save the cache pool so we can resume later.
+    cachePool: getOffscreenDeferredCache() 
+  };
+  workInProgress.memoizedState = nextState;
+
+  {
+    // push the cache pool even though we're going to bail out
+    // because otherwise there'd be a context mismatch
+    if (current !== null) {
+      pushTransition(workInProgress, null);
+    }
+  } // We're about to bail out, but we need to push this to the stack anyway
+  // to avoid a push/pop misalignment.
+
+
+  reuseHiddenContextOnStack();
+  pushOffscreenSuspenseHandler(workInProgress);
+
+  return null;
+} // Note: These happen to have identical begin phases, for now. We shouldn't hold
+
+function updateCacheComponent(current, workInProgress, renderLanes) {
+
+  prepareToReadContext(workInProgress, renderLanes);
+  const parentCache = readContext(CacheContext);
+
+  if (current === null) {
+    // Initial mount. Request a fresh cache from the pool.
+    const freshCache = requestCacheFromPool(renderLanes);
+    const initialState = {
+      parent: parentCache,
+      cache: freshCache
+    };
+    workInProgress.memoizedState = initialState;
+    initializeUpdateQueue(workInProgress);
+    pushCacheProvider(workInProgress, freshCache);
+  } else {
+    // Check for updates
+    if (includesSomeLane(current.lanes, renderLanes)) {
+      cloneUpdateQueue(current, workInProgress);
+      processUpdateQueue(workInProgress, null, null, renderLanes);
+    }
+
+    const prevState = current.memoizedState;
+    const nextState = workInProgress.memoizedState; // Compare the new parent cache to the previous to see detect there was
+    // a refresh.
+
+    if (prevState.parent !== parentCache) {
+      // Refresh in parent. Update the parent.
+      const derivedState = {
+        parent: parentCache,
+        cache: parentCache
+      }; // Copied from getDerivedStateFromProps implementation. Once the update
+      // queue is empty, persist the derived state onto the base state.
+
+      workInProgress.memoizedState = derivedState;
+
+      if (workInProgress.lanes === NoLanes) {
+        const updateQueue = workInProgress.updateQueue;
+        workInProgress.memoizedState = updateQueue.baseState = derivedState;
+      }
+
+      pushCacheProvider(workInProgress, parentCache); // No need to propagate a context change because the refreshed parent
+      // already did.
+    } else {
+      // The parent didn't refresh. Now check if this cache did.
+      const nextCache = nextState.cache;
+      pushCacheProvider(workInProgress, nextCache);
+
+      if (nextCache !== prevState.cache) {
+        // This cache refreshed. Propagate a context change.
+        propagateContextChange(workInProgress, CacheContext, renderLanes);
+      }
+    }
+  }
+
+  const nextChildren = workInProgress.pendingProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+} // This should only be called if the name changes
+
+function updateFragment(current, workInProgress, renderLanes) {
+  const nextChildren = workInProgress.pendingProps;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateMode(current, workInProgress, renderLanes) {
+  const nextChildren = workInProgress.pendingProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateProfiler(current, workInProgress, renderLanes) {
+
+  const nextProps = workInProgress.pendingProps;
+  const nextChildren = nextProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function markRef$1(current, workInProgress) {
+  const ref = workInProgress.ref;
+
+  if (current === null && ref !== null || current !== null && current.ref !== ref) {
+    // Schedule a Ref effect
+    workInProgress.flags |= Ref;
+    workInProgress.flags |= RefStatic;
+  }
+}
+
+function updateFunctionComponent(current, workInProgress, Component, nextProps, renderLanes) {
+
+  let context;
+
+  {
+    const unmaskedContext = getUnmaskedContext(workInProgress, Component, true);
+    context = getMaskedContext(workInProgress, unmaskedContext);
+  }
+
+  let nextChildren;
+  let hasId;
+  prepareToReadContext(workInProgress, renderLanes);
+
+  {
+    nextChildren = renderWithHooks(current, workInProgress, Component, nextProps, context, renderLanes);
+    hasId = checkDidRenderIdHook();
+  }
+
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function replayFunctionComponent(current, workInProgress, nextProps, Component, secondArg, renderLanes) {
+  // This function is used to replay a component that previously suspended,
+  // after its data resolves. It's a simplified version of
+  // updateFunctionComponent that reuses the hooks from the previous attempt.
+  prepareToReadContext(workInProgress, renderLanes);
+
+  const nextChildren = replaySuspendedComponentWithHooks(current, workInProgress, Component, nextProps, secondArg);
+  const hasId = checkDidRenderIdHook();
+
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateClassComponent(current, workInProgress, Component, nextProps, renderLanes) {
+  // During mounting we don't know the child context yet as the instance doesn't exist.
+  // We will invalidate the child context in finishClassComponent() right after rendering.
+
+
+  let hasContext;
+
+  if (isContextProvider(Component)) {
+    hasContext = true;
+    pushContextProvider(workInProgress);
+  } else {
+    hasContext = false;
+  }
+
+  prepareToReadContext(workInProgress, renderLanes);
+  const instance = workInProgress.stateNode;
+  let shouldUpdate;
+
+  if (instance === null) {
+    resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress); // In the initial pass we might need to construct the instance.
+
+    constructClassInstance(workInProgress, Component, nextProps);
+    mountClassInstance(workInProgress, Component, nextProps, renderLanes);
+    shouldUpdate = true;
+  } else if (current === null) {
+    // In a resume, we'll already have an instance we can reuse.
+    shouldUpdate = resumeMountClassInstance(workInProgress, Component, nextProps, renderLanes);
+  } else {
+    shouldUpdate = updateClassInstance(current, workInProgress, Component, nextProps, renderLanes);
+  }
+
+  const nextUnitOfWork = finishClassComponent(current, workInProgress, Component, shouldUpdate, hasContext, renderLanes);
+
+  return nextUnitOfWork;
+}
+
+function finishClassComponent(current, workInProgress, Component, shouldUpdate, hasContext, renderLanes) {
+  // Refs should update even if shouldComponentUpdate returns false
+  markRef$1(current, workInProgress);
+  const didCaptureError = (workInProgress.flags & DidCapture) !== NoFlags$1;
+
+  if (!shouldUpdate && !didCaptureError) {
+    // Context providers should defer to sCU for rendering
+    if (hasContext) {
+      invalidateContextProvider(workInProgress, Component, false);
+    }
+
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+
+  const instance = workInProgress.stateNode; // Rerender
+
+  ReactCurrentOwner$1.current = workInProgress;
+  let nextChildren;
+
+  if (didCaptureError && typeof Component.getDerivedStateFromError !== 'function') {
+    // If we captured an error, but getDerivedStateFromError is not defined,
+    // unmount all the children. componentDidCatch will schedule an update to
+    // re-render a fallback. This is temporary until we migrate everyone to
+    // the new API.
+    // TODO: Warn in a future release.
+    nextChildren = null;
+  } else {
+
+    {
+      nextChildren = instance.render();
+    }
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+
+  if (current !== null && didCaptureError) {
+    // If we're recovering from an error, reconcile without reusing any of
+    // the existing children. Conceptually, the normal children and the children
+    // that are shown on error are two different sets, so we shouldn't reuse
+    // normal children even if their identities match.
+    forceUnmountCurrentAndReconcile(current, workInProgress, nextChildren, renderLanes);
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  } // Memoize state using the values we just used to render.
+  // TODO: Restructure so we never read values from the instance.
+
+
+  workInProgress.memoizedState = instance.state; // The context might have changed so we need to recalculate it.
+
+  if (hasContext) {
+    invalidateContextProvider(workInProgress, Component, true);
+  }
+
+  return workInProgress.child;
+}
+
+function pushHostRootContext(workInProgress) {
+  const root = workInProgress.stateNode;
+
+  if (root.pendingContext) {
+    pushTopLevelContextObject(workInProgress, root.pendingContext, root.pendingContext !== root.context);
+  } else if (root.context) {
+    // Should always be set
+    pushTopLevelContextObject(workInProgress, root.context, false);
+  }
+
+  pushHostContainer(workInProgress, root.containerInfo);
+}
+
+function updateHostRoot(current, workInProgress, renderLanes) {
+  pushHostRootContext(workInProgress);
+
+  if (current === null) {
+    throw Error(formatProdErrorMessage(387));
+  }
+
+  const nextProps = workInProgress.pendingProps;
+  const prevState = workInProgress.memoizedState;
+  const prevChildren = prevState.element;
+  cloneUpdateQueue(current, workInProgress);
+  processUpdateQueue(workInProgress, nextProps, null, renderLanes);
+  const nextState = workInProgress.memoizedState;
+
+  {
+    const nextCache = nextState.cache;
+    pushCacheProvider(workInProgress, nextCache);
+
+    if (nextCache !== prevState.cache) {
+      // The root cache refreshed.
+      propagateContextChange(workInProgress, CacheContext, renderLanes);
+    }
+  } // Caution: React DevTools currently depends on this property
+  // being called "element".
+
+
+  const nextChildren = nextState.element;
+
+  if (prevState.isDehydrated) {
+    // This is a hydration root whose shell has not yet hydrated. We should
+    // attempt to hydrate.
+    // Flip isDehydrated to false to indicate that when this render
+    // finishes, the root will no longer be dehydrated.
+    const overrideState = {
+      element: nextChildren,
+      isDehydrated: false,
+      cache: nextState.cache
+    };
+    const updateQueue = workInProgress.updateQueue; // `baseState` can always be the last state because the root doesn't
+    // have reducer functions so it doesn't need rebasing.
+
+    updateQueue.baseState = overrideState;
+    workInProgress.memoizedState = overrideState;
+
+    if (workInProgress.flags & ForceClientRender) {
+      // Something errored during a previous attempt to hydrate the shell, so we
+      // forced a client render.
+      const recoverableError = createCapturedValueAtFiber(Error(formatProdErrorMessage(423)), workInProgress);
+      return mountHostRootWithoutHydrating(current, workInProgress, nextChildren, renderLanes, recoverableError);
+    } else if (nextChildren !== prevChildren) {
+      const recoverableError = createCapturedValueAtFiber(Error(formatProdErrorMessage(424)), workInProgress);
+      return mountHostRootWithoutHydrating(current, workInProgress, nextChildren, renderLanes, recoverableError);
+    } else {
+      // The outermost shell has not hydrated yet. Start hydrating.
+      enterHydrationState(workInProgress);
+      const child = mountChildFibers(workInProgress, null, nextChildren, renderLanes);
+      workInProgress.child = child;
+      let node = child;
+
+      while (node) {
+        // Mark each child as hydrating. This is a fast path to know whether this
+        // tree is part of a hydrating tree. This is used to determine if a child
+        // node has fully mounted yet, and for scheduling event replaying.
+        // Conceptually this is similar to Placement in that a new subtree is
+        // inserted into the React tree here. It just happens to not need DOM
+        // mutations because it already exists.
+        node.flags = node.flags & ~Placement | Hydrating;
+        node = node.sibling;
+      }
+    }
+  } else {
+    // Root is not dehydrated. Either this is a client-only root, or it
+    // already hydrated.
+    resetHydrationState();
+
+    if (nextChildren === prevChildren) {
+      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    }
+
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  }
+
+  return workInProgress.child;
+}
+
+function mountHostRootWithoutHydrating(current, workInProgress, nextChildren, renderLanes, recoverableError) {
+  // Revert to client rendering.
+  resetHydrationState();
+  queueHydrationError(recoverableError);
+  workInProgress.flags |= ForceClientRender;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateHostComponent$1(current, workInProgress, renderLanes) {
+  pushHostContext(workInProgress);
+
+  if (current === null) {
+    tryToClaimNextHydratableInstance(workInProgress);
+  }
+
+  const type = workInProgress.type;
+  const nextProps = workInProgress.pendingProps;
+  const prevProps = current !== null ? current.memoizedProps : null;
+  let nextChildren = nextProps.children;
+  const isDirectTextChild = shouldSetTextContent(type, nextProps);
+
+  if (isDirectTextChild) {
+    // We special case a direct text child of a host node. This is a common
+    // case. We won't handle it as a reified child. We will instead handle
+    // this in the host environment that also has access to this prop. That
+    // avoids allocating another HostText fiber and traversing it.
+    nextChildren = null;
+  } else if (prevProps !== null && shouldSetTextContent(type, prevProps)) {
+    // If we're switching from a direct text child to a normal child, or to
+    // empty, we need to schedule the text content to be reset.
+    workInProgress.flags |= ContentReset;
+  }
+
+  {
+    const memoizedState = workInProgress.memoizedState;
+
+    if (memoizedState !== null) {
+      // This fiber has been upgraded to a stateful component. The only way
+      // happens currently is for form actions. We use hooks to track the
+      // pending and error state of the form.
+      //
+      // Once a fiber is upgraded to be stateful, it remains stateful for the
+      // rest of its lifetime.
+      const newState = renderTransitionAwareHostComponentWithHooks(current, workInProgress, renderLanes); // If the transition state changed, propagate the change to all the
+      // descendents. We use Context as an implementation detail for this.
+      //
+      // This is intentionally set here instead of pushHostContext because
+      // pushHostContext gets called before we process the state hook, to avoid
+      // a state mismatch in the event that something suspends.
+      //
+      // NOTE: This assumes that there cannot be nested transition providers,
+      // because the only renderer that implements this feature is React DOM,
+      // and forms cannot be nested. If we did support nested providers, then
+      // we would need to push a context value even for host fibers that
+      // haven't been upgraded yet.
+
+      {
+        HostTransitionContext._currentValue = newState;
+      }
+
+      {
+        if (didReceiveUpdate) {
+          if (current !== null) {
+            const oldStateHook = current.memoizedState;
+            const oldState = oldStateHook.memoizedState; // This uses regular equality instead of Object.is because we assume
+            // that host transition state doesn't include NaN as a valid type.
+
+            if (oldState !== newState) {
+              propagateContextChange(workInProgress, HostTransitionContext, renderLanes);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  markRef$1(current, workInProgress);
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateHostHoistable(current, workInProgress, renderLanes) {
+  markRef$1(current, workInProgress);
+  const currentProps = current === null ? null : current.memoizedProps;
+  const resource = workInProgress.memoizedState = getResource(workInProgress.type, currentProps, workInProgress.pendingProps);
+
+  if (current === null) {
+    if (!getIsHydrating() && resource === null) {
+      // This is not a Resource Hoistable and we aren't hydrating so we construct the instance.
+      workInProgress.stateNode = createHoistableInstance(workInProgress.type, workInProgress.pendingProps, getRootHostContainer(), workInProgress);
+    }
+  } // Resources never have reconciler managed children. It is possible for
+  // the host implementation of getResource to consider children in the
+  // resource construction but they will otherwise be discarded. In practice
+  // this precludes all but the simplest children and Host specific warnings
+  // should be implemented to warn when children are passsed when otherwise not
+  // expected
+
+
+  return null;
+}
+
+function updateHostSingleton(current, workInProgress, renderLanes) {
+  pushHostContext(workInProgress);
+
+  if (current === null) {
+    claimHydratableSingleton(workInProgress);
+  }
+
+  const nextChildren = workInProgress.pendingProps.children;
+
+  if (current === null && !getIsHydrating()) {
+    // Similar to Portals we append Singleton children in the commit phase. So we
+    // Track insertions even on mount.
+    // TODO: Consider unifying this with how the root works.
+    workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderLanes);
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  }
+
+  markRef$1(current, workInProgress);
+  return workInProgress.child;
+}
+
+function updateHostText$1(current, workInProgress) {
+  if (current === null) {
+    tryToClaimNextHydratableTextInstance(workInProgress);
+  } // Nothing to do here. This is terminal. We'll do the completion step
+  // immediately after.
+
+
+  return null;
+}
+
+function mountLazyComponent(_current, workInProgress, elementType, renderLanes) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);
+  const props = workInProgress.pendingProps;
+  const lazyComponent = elementType;
+  const payload = lazyComponent._payload;
+  const init = lazyComponent._init;
+  let Component = init(payload); // Store the unwrapped component in the type.
+
+  workInProgress.type = Component;
+  const resolvedTag = workInProgress.tag = resolveLazyComponentTag(Component);
+  const resolvedProps = resolveDefaultProps(Component, props);
+  let child;
+
+  switch (resolvedTag) {
+    case FunctionComponent:
+      {
+
+        child = updateFunctionComponent(null, workInProgress, Component, resolvedProps, renderLanes);
+        return child;
+      }
+
+    case ClassComponent:
+      {
+
+        child = updateClassComponent(null, workInProgress, Component, resolvedProps, renderLanes);
+        return child;
+      }
+
+    case ForwardRef:
+      {
+
+        child = updateForwardRef(null, workInProgress, Component, resolvedProps, renderLanes);
+        return child;
+      }
+
+    case MemoComponent:
+      {
+
+        child = updateMemoComponent(null, workInProgress, Component, resolveDefaultProps(Component.type, resolvedProps), // The inner type can have defaults too
+        renderLanes);
+        return child;
+      }
+  }
+
+  let hint = '';
+  // because the fact that it's a separate type of work is an
+  // implementation detail.
+
+
+  throw Error(formatProdErrorMessage(306, Component, hint));
+}
+
+function mountIncompleteClassComponent(_current, workInProgress, Component, nextProps, renderLanes) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress); // Promote the fiber to a class and try rendering again.
+
+  workInProgress.tag = ClassComponent; // The rest of this function is a fork of `updateClassComponent`
+  // Push context providers early to prevent context stack mismatches.
+  // During mounting we don't know the child context yet as the instance doesn't exist.
+  // We will invalidate the child context in finishClassComponent() right after rendering.
+
+  let hasContext;
+
+  if (isContextProvider(Component)) {
+    hasContext = true;
+    pushContextProvider(workInProgress);
+  } else {
+    hasContext = false;
+  }
+
+  prepareToReadContext(workInProgress, renderLanes);
+  constructClassInstance(workInProgress, Component, nextProps);
+  mountClassInstance(workInProgress, Component, nextProps, renderLanes);
+  return finishClassComponent(null, workInProgress, Component, true, hasContext, renderLanes);
+}
+
+function mountIndeterminateComponent(_current, workInProgress, Component, renderLanes) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);
+  const props = workInProgress.pendingProps;
+  let context;
+
+  {
+    const unmaskedContext = getUnmaskedContext(workInProgress, Component, false);
+    context = getMaskedContext(workInProgress, unmaskedContext);
+  }
+
+  prepareToReadContext(workInProgress, renderLanes);
+  let value;
+  let hasId;
+
+  {
+    value = renderWithHooks(null, workInProgress, Component, props, context, renderLanes);
+    hasId = checkDidRenderIdHook();
+  }
+
+
+  workInProgress.flags |= PerformedWork;
+
+  if ( // Run these checks in production only if the flag is off.
+  // Eventually we'll delete this branch altogether.
+  typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) {
+
+
+    workInProgress.tag = ClassComponent; // Throw out any hooks that were used.
+
+    workInProgress.memoizedState = null;
+    workInProgress.updateQueue = null; // Push context providers early to prevent context stack mismatches.
+    // During mounting we don't know the child context yet as the instance doesn't exist.
+    // We will invalidate the child context in finishClassComponent() right after rendering.
+
+    let hasContext = false;
+
+    if (isContextProvider(Component)) {
+      hasContext = true;
+      pushContextProvider(workInProgress);
+    } else {
+      hasContext = false;
+    }
+
+    workInProgress.memoizedState = value.state !== null && value.state !== undefined ? value.state : null;
+    initializeUpdateQueue(workInProgress);
+    adoptClassInstance(workInProgress, value);
+    mountClassInstance(workInProgress, Component, props, renderLanes);
+    return finishClassComponent(null, workInProgress, Component, true, hasContext, renderLanes);
+  } else {
+    // Proceed under the assumption that this is a function component
+    workInProgress.tag = FunctionComponent;
+
+    if (getIsHydrating() && hasId) {
+      pushMaterializedTreeId(workInProgress);
+    }
+
+    reconcileChildren(null, workInProgress, value, renderLanes);
+
+    return workInProgress.child;
+  }
+}
+
+const SUSPENDED_MARKER = {
+  dehydrated: null,
+  treeContext: null,
+  retryLane: NoLane
+};
+
+function mountSuspenseOffscreenState(renderLanes) {
+  return {
+    baseLanes: renderLanes,
+    cachePool: getSuspendedCache()
+  };
+}
+
+function updateSuspenseOffscreenState(prevOffscreenState, renderLanes) {
+  let cachePool = null;
+
+  {
+    const prevCachePool = prevOffscreenState.cachePool;
+
+    if (prevCachePool !== null) {
+      const parentCache = CacheContext._currentValue ;
+
+      if (prevCachePool.parent !== parentCache) {
+        // Detected a refresh in the parent. This overrides any previously
+        // suspended cache.
+        cachePool = {
+          parent: parentCache,
+          pool: parentCache
+        };
+      } else {
+        // We can reuse the cache from last time. The only thing that would have
+        // overridden it is a parent refresh, which we checked for above.
+        cachePool = prevCachePool;
+      }
+    } else {
+      // If there's no previous cache pool, grab the current one.
+      cachePool = getSuspendedCache();
+    }
+  }
+
+  return {
+    baseLanes: mergeLanes(prevOffscreenState.baseLanes, renderLanes),
+    cachePool
+  };
+} // TODO: Probably should inline this back
+
+
+function shouldRemainOnFallback(current, workInProgress, renderLanes) {
+  // If we're already showing a fallback, there are cases where we need to
+  // remain on that fallback regardless of whether the content has resolved.
+  // For example, SuspenseList coordinates when nested content appears.
+  // TODO: For compatibility with offscreen prerendering, this should also check
+  // whether the current fiber (if it exists) was visible in the previous tree.
+  if (current !== null) {
+    const suspenseState = current.memoizedState;
+
+    if (suspenseState === null) {
+      // Currently showing content. Don't hide it, even if ForceSuspenseFallback
+      // is true. More precise name might be "ForceRemainSuspenseFallback".
+      // Note: This is a factoring smell. Can't remain on a fallback if there's
+      // no fallback to remain on.
+      return false;
+    }
+  } // Not currently showing content. Consult the Suspense context.
+
+
+  const suspenseContext = suspenseStackCursor.current;
+  return hasSuspenseListContext(suspenseContext, ForceSuspenseFallback);
+}
+
+function getRemainingWorkInPrimaryTree(current, renderLanes) {
+  // TODO: Should not remove render lanes that were pinged during this render
+  return removeLanes(current.childLanes, renderLanes);
+}
+
+function updateSuspenseComponent(current, workInProgress, renderLanes) {
+  const nextProps = workInProgress.pendingProps; // This is used by DevTools to force a boundary to suspend.
+
+  let showFallback = false;
+  const didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
+
+  if (didSuspend || shouldRemainOnFallback(current)) {
+    // Something in this boundary's subtree already suspended. Switch to
+    // rendering the fallback children.
+    showFallback = true;
+    workInProgress.flags &= ~DidCapture;
+  } // OK, the next part is confusing. We're about to reconcile the Suspense
+  // boundary's children. This involves some custom reconciliation logic. Two
+  // main reasons this is so complicated.
+  //
+  // First, Legacy Mode has different semantics for backwards compatibility. The
+  // primary tree will commit in an inconsistent state, so when we do the
+  // second pass to render the fallback, we do some exceedingly, uh, clever
+  // hacks to make that not totally break. Like transferring effects and
+  // deletions from hidden tree. In Concurrent Mode, it's much simpler,
+  // because we bailout on the primary tree completely and leave it in its old
+  // state, no effects. Same as what we do for Offscreen (except that
+  // Offscreen doesn't have the first render pass).
+  //
+  // Second is hydration. During hydration, the Suspense fiber has a slightly
+  // different layout, where the child points to a dehydrated fragment, which
+  // contains the DOM rendered by the server.
+  //
+  // Third, even if you set all that aside, Suspense is like error boundaries in
+  // that we first we try to render one tree, and if that fails, we render again
+  // and switch to a different tree. Like a try/catch block. So we have to track
+  // which branch we're currently rendering. Ideally we would model this using
+  // a stack.
+
+
+  if (current === null) {
+    // Initial mount
+    // Special path for hydration
+    // If we're currently hydrating, try to hydrate this boundary.
+    if (getIsHydrating()) {
+      // We must push the suspense handler context *before* attempting to
+      // hydrate, to avoid a mismatch in case it errors.
+      if (showFallback) {
+        pushPrimaryTreeSuspenseHandler(workInProgress);
+      } else {
+        pushFallbackTreeSuspenseHandler(workInProgress);
+      }
+
+      tryToClaimNextHydratableSuspenseInstance(workInProgress); // This could've been a dehydrated suspense component.
+
+      const suspenseState = workInProgress.memoizedState;
+
+      if (suspenseState !== null) {
+        const dehydrated = suspenseState.dehydrated;
+
+        if (dehydrated !== null) {
+          return mountDehydratedSuspenseComponent(workInProgress, dehydrated);
+        }
+      } // If hydration didn't succeed, fall through to the normal Suspense path.
+      // To avoid a stack mismatch we need to pop the Suspense handler that we
+      // pushed above. This will become less awkward when move the hydration
+      // logic to its own fiber.
+
+
+      popSuspenseHandler(workInProgress);
+    }
+
+    const nextPrimaryChildren = nextProps.children;
+    const nextFallbackChildren = nextProps.fallback;
+
+    if (showFallback) {
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      const fallbackFragment = mountSuspenseFallbackChildren(workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);
+      const primaryChildFragment = workInProgress.child;
+      primaryChildFragment.memoizedState = mountSuspenseOffscreenState(renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+
+      return fallbackFragment;
+    } else if (typeof nextProps.unstable_expectedLoadTime === 'number') {
+      // This is a CPU-bound tree. Skip this tree and show a placeholder to
+      // unblock the surrounding content. Then immediately retry after the
+      // initial commit.
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      const fallbackFragment = mountSuspenseFallbackChildren(workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);
+      const primaryChildFragment = workInProgress.child;
+      primaryChildFragment.memoizedState = mountSuspenseOffscreenState(renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER; // TODO: Transition Tracing is not yet implemented for CPU Suspense.
+      // Since nothing actually suspended, there will nothing to ping this to
+      // get it started back up to attempt the next item. While in terms of
+      // priority this work has the same priority as this current render, it's
+      // not part of the same transition once the transition has committed. If
+      // it's sync, we still want to yield so that it can be painted.
+      // Conceptually, this is really the same as pinging. We can use any
+      // RetryLane even if it's the one currently rendering since we're leaving
+      // it behind on this node.
+
+      workInProgress.lanes = SomeRetryLane;
+      return fallbackFragment;
+    } else {
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      return mountSuspensePrimaryChildren(workInProgress, nextPrimaryChildren);
+    }
+  } else {
+    // This is an update.
+    // Special path for hydration
+    const prevState = current.memoizedState;
+
+    if (prevState !== null) {
+      const dehydrated = prevState.dehydrated;
+
+      if (dehydrated !== null) {
+        return updateDehydratedSuspenseComponent(current, workInProgress, didSuspend, nextProps, dehydrated, prevState, renderLanes);
+      }
+    }
+
+    if (showFallback) {
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      const nextFallbackChildren = nextProps.fallback;
+      const nextPrimaryChildren = nextProps.children;
+      const fallbackChildFragment = updateSuspenseFallbackChildren(current, workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);
+      const primaryChildFragment = workInProgress.child;
+      const prevOffscreenState = current.child.memoizedState;
+      primaryChildFragment.memoizedState = prevOffscreenState === null ? mountSuspenseOffscreenState(renderLanes) : updateSuspenseOffscreenState(prevOffscreenState, renderLanes);
+
+      primaryChildFragment.childLanes = getRemainingWorkInPrimaryTree(current, renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+      return fallbackChildFragment;
+    } else {
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      const nextPrimaryChildren = nextProps.children;
+      const primaryChildFragment = updateSuspensePrimaryChildren(current, workInProgress, nextPrimaryChildren, renderLanes);
+      workInProgress.memoizedState = null;
+      return primaryChildFragment;
+    }
+  }
+}
+
+function mountSuspensePrimaryChildren(workInProgress, primaryChildren, renderLanes) {
+  const mode = workInProgress.mode;
+  const primaryChildProps = {
+    mode: 'visible',
+    children: primaryChildren
+  };
+  const primaryChildFragment = mountWorkInProgressOffscreenFiber(primaryChildProps, mode);
+  primaryChildFragment.return = workInProgress;
+  workInProgress.child = primaryChildFragment;
+  return primaryChildFragment;
+}
+
+function mountSuspenseFallbackChildren(workInProgress, primaryChildren, fallbackChildren, renderLanes) {
+  const mode = workInProgress.mode;
+  const progressedPrimaryFragment = workInProgress.child;
+  const primaryChildProps = {
+    mode: 'hidden',
+    children: primaryChildren
+  };
+  let primaryChildFragment;
+  let fallbackChildFragment;
+
+  if ((mode & ConcurrentMode) === NoMode && progressedPrimaryFragment !== null) {
+    // In legacy mode, we commit the primary tree as if it successfully
+    // completed, even though it's in an inconsistent state.
+    primaryChildFragment = progressedPrimaryFragment;
+    primaryChildFragment.childLanes = NoLanes;
+    primaryChildFragment.pendingProps = primaryChildProps;
+
+    fallbackChildFragment = createFiberFromFragment(fallbackChildren, mode, renderLanes, null);
+  } else {
+    primaryChildFragment = mountWorkInProgressOffscreenFiber(primaryChildProps, mode);
+    fallbackChildFragment = createFiberFromFragment(fallbackChildren, mode, renderLanes, null);
+  }
+
+  primaryChildFragment.return = workInProgress;
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
+  return fallbackChildFragment;
+}
+
+function mountWorkInProgressOffscreenFiber(offscreenProps, mode, renderLanes) {
+  // The props argument to `createFiberFromOffscreen` is `any` typed, so we use
+  // this wrapper function to constrain it.
+  return createFiberFromOffscreen(offscreenProps, mode, NoLanes, null);
+}
+
+function updateWorkInProgressOffscreenFiber(current, offscreenProps) {
+  // The props argument to `createWorkInProgress` is `any` typed, so we use this
+  // wrapper function to constrain it.
+  return createWorkInProgress(current, offscreenProps);
+}
+
+function updateSuspensePrimaryChildren(current, workInProgress, primaryChildren, renderLanes) {
+  const currentPrimaryChildFragment = current.child;
+  const currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
+  const primaryChildFragment = updateWorkInProgressOffscreenFiber(currentPrimaryChildFragment, {
+    mode: 'visible',
+    children: primaryChildren
+  });
+
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    primaryChildFragment.lanes = renderLanes;
+  }
+
+  primaryChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = null;
+
+  if (currentFallbackChildFragment !== null) {
+    // Delete the fallback child fragment
+    const deletions = workInProgress.deletions;
+
+    if (deletions === null) {
+      workInProgress.deletions = [currentFallbackChildFragment];
+      workInProgress.flags |= ChildDeletion;
+    } else {
+      deletions.push(currentFallbackChildFragment);
+    }
+  }
+
+  workInProgress.child = primaryChildFragment;
+  return primaryChildFragment;
+}
+
+function updateSuspenseFallbackChildren(current, workInProgress, primaryChildren, fallbackChildren, renderLanes) {
+  const mode = workInProgress.mode;
+  const currentPrimaryChildFragment = current.child;
+  const currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
+  const primaryChildProps = {
+    mode: 'hidden',
+    children: primaryChildren
+  };
+  let primaryChildFragment;
+
+  if ( // In legacy mode, we commit the primary tree as if it successfully
+  // completed, even though it's in an inconsistent state.
+  (mode & ConcurrentMode) === NoMode && // Make sure we're on the second pass, i.e. the primary child fragment was
+  // already cloned. In legacy mode, the only case where this isn't true is
+  // when DevTools forces us to display a fallback; we skip the first render
+  // pass entirely and go straight to rendering the fallback. (In Concurrent
+  // Mode, SuspenseList can also trigger this scenario, but this is a legacy-
+  // only codepath.)
+  workInProgress.child !== currentPrimaryChildFragment) {
+    const progressedPrimaryFragment = workInProgress.child;
+    primaryChildFragment = progressedPrimaryFragment;
+    primaryChildFragment.childLanes = NoLanes;
+    primaryChildFragment.pendingProps = primaryChildProps;
+    // However, since we're going to remain on the fallback, we no longer want
+    // to delete it.
+
+
+    workInProgress.deletions = null;
+  } else {
+    primaryChildFragment = updateWorkInProgressOffscreenFiber(currentPrimaryChildFragment, primaryChildProps); // Since we're reusing a current tree, we need to reuse the flags, too.
+    // (We don't do this in legacy mode, because in legacy mode we don't re-use
+    // the current tree; see previous branch.)
+
+    primaryChildFragment.subtreeFlags = currentPrimaryChildFragment.subtreeFlags & StaticMask;
+  }
+
+  let fallbackChildFragment;
+
+  if (currentFallbackChildFragment !== null) {
+    fallbackChildFragment = createWorkInProgress(currentFallbackChildFragment, fallbackChildren);
+  } else {
+    fallbackChildFragment = createFiberFromFragment(fallbackChildren, mode, renderLanes, null); // Needs a placement effect because the parent (the Suspense boundary) already
+    // mounted but this is a new fiber.
+
+    fallbackChildFragment.flags |= Placement;
+  }
+
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
+  return fallbackChildFragment;
+}
+
+function retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, recoverableError) {
+  // Falling back to client rendering. Because this has performance
+  // implications, it's considered a recoverable error, even though the user
+  // likely won't observe anything wrong with the UI.
+  //
+  // The error is passed in as an argument to enforce that every caller provide
+  // a custom message, or explicitly opt out (currently the only path that opts
+  // out is legacy mode; every concurrent path provides an error).
+  if (recoverableError !== null) {
+    queueHydrationError(recoverableError);
+  } // This will add the old fiber to the deletion list
+
+
+  reconcileChildFibers(workInProgress, current.child, null, renderLanes); // We're now not suspended nor dehydrated.
+
+  const nextProps = workInProgress.pendingProps;
+  const primaryChildren = nextProps.children;
+  const primaryChildFragment = mountSuspensePrimaryChildren(workInProgress, primaryChildren); // Needs a placement effect because the parent (the Suspense boundary) already
+  // mounted but this is a new fiber.
+
+  primaryChildFragment.flags |= Placement;
+  workInProgress.memoizedState = null;
+  return primaryChildFragment;
+}
+
+function mountSuspenseFallbackAfterRetryWithoutHydrating(current, workInProgress, primaryChildren, fallbackChildren, renderLanes) {
+  const fiberMode = workInProgress.mode;
+  const primaryChildProps = {
+    mode: 'visible',
+    children: primaryChildren
+  };
+  const primaryChildFragment = mountWorkInProgressOffscreenFiber(primaryChildProps, fiberMode);
+  const fallbackChildFragment = createFiberFromFragment(fallbackChildren, fiberMode, renderLanes, null); // Needs a placement effect because the parent (the Suspense
+  // boundary) already mounted but this is a new fiber.
+
+  fallbackChildFragment.flags |= Placement;
+  primaryChildFragment.return = workInProgress;
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
+
+  if ((workInProgress.mode & ConcurrentMode) !== NoMode) {
+    // We will have dropped the effect list which contains the
+    // deletion. We need to reconcile to delete the current child.
+    reconcileChildFibers(workInProgress, current.child, null, renderLanes);
+  }
+
+  return fallbackChildFragment;
+}
+
+function mountDehydratedSuspenseComponent(workInProgress, suspenseInstance, renderLanes) {
+  // During the first pass, we'll bail out and not drill into the children.
+  // Instead, we'll leave the content in place and try to hydrate it later.
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+
+    workInProgress.lanes = laneToLanes(SyncLane);
+  } else if (isSuspenseInstanceFallback(suspenseInstance)) {
+    // This is a client-only boundary. Since we won't get any content from the server
+    // for this, we need to schedule that at a higher priority based on when it would
+    // have timed out. In theory we could render it in this pass but it would have the
+    // wrong priority associated with it and will prevent hydration of parent path.
+    // Instead, we'll leave work left on it to render it in a separate commit.
+    // TODO This time should be the time at which the server rendered response that is
+    // a parent to this boundary was displayed. However, since we currently don't have
+    // a protocol to transfer that time, we'll just estimate it by using the current
+    // time. This will mean that Suspense timeouts are slightly shifted to later than
+    // they should be.
+    // Schedule a normal pri update to render this content.
+    workInProgress.lanes = laneToLanes(DefaultHydrationLane);
+  } else {
+    // We'll continue hydrating the rest at offscreen priority since we'll already
+    // be showing the right content coming from the server, it is no rush.
+    workInProgress.lanes = laneToLanes(OffscreenLane);
+  }
+
+  return null;
+}
+
+function updateDehydratedSuspenseComponent(current, workInProgress, didSuspend, nextProps, suspenseInstance, suspenseState, renderLanes) {
+  if (!didSuspend) {
+    // This is the first render pass. Attempt to hydrate.
+    pushPrimaryTreeSuspenseHandler(workInProgress); // We should never be hydrating at this point because it is the first pass,
+
+    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, null);
+    }
+
+    if (isSuspenseInstanceFallback(suspenseInstance)) {
+      // This boundary is in a permanent fallback state. In this case, we'll never
+      // get an update and we'll never be able to hydrate the final content. Let's just try the
+      // client side render instead.
+      let digest;
+      let stack;
+
+      {
+        var _getSuspenseInstanceF2 = getSuspenseInstanceFallbackErrorDetails(suspenseInstance);
+
+        digest = _getSuspenseInstanceF2.digest;
+      }
+
+      let capturedValue = null; // TODO: Figure out a better signal than encoding a magic digest value.
+
+      if (digest !== 'POSTPONE') {
+        let error;
+
+        {
+          error = Error(formatProdErrorMessage(419));
+        }
+
+        error.digest = digest;
+        capturedValue = createCapturedValue(error, digest, stack);
+      }
+
+      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, capturedValue);
+    }
+    // any context has changed, we need to treat is as if the input might have changed.
+
+
+    const hasContextChanged = includesSomeLane(renderLanes, current.childLanes);
+
+    if (didReceiveUpdate || hasContextChanged) {
+      // This boundary has changed since the first render. This means that we are now unable to
+      // hydrate it. We might still be able to hydrate it using a higher priority lane.
+      const root = getWorkInProgressRoot();
+
+      if (root !== null) {
+        const attemptHydrationAtLane = getBumpedLaneForHydration(root, renderLanes);
+
+        if (attemptHydrationAtLane !== NoLane && attemptHydrationAtLane !== suspenseState.retryLane) {
+          // Intentionally mutating since this render will get interrupted. This
+          // is one of the very rare times where we mutate the current tree
+          // during the render phase.
+          suspenseState.retryLane = attemptHydrationAtLane;
+          enqueueConcurrentRenderForLane(current, attemptHydrationAtLane);
+          scheduleUpdateOnFiber(root, current, attemptHydrationAtLane); // Throw a special object that signals to the work loop that it should
+          // interrupt the current render.
+          //
+          // Because we're inside a React-only execution stack, we don't
+          // strictly need to throw here — we could instead modify some internal
+          // work loop state. But using an exception means we don't need to
+          // check for this case on every iteration of the work loop. So doing
+          // it this way moves the check out of the fast path.
+
+          throw SelectiveHydrationException;
+        }
+      } // If we did not selectively hydrate, we'll continue rendering without
+      // hydrating. Mark this tree as suspended to prevent it from committing
+      // outside a transition.
+      //
+      // This path should only happen if the hydration lane already suspended.
+      // Currently, it also happens during sync updates because there is no
+      // hydration lane for sync updates.
+      // TODO: We should ideally have a sync hydration lane that we can apply to do
+      // a pass where we hydrate this subtree in place using the previous Context and then
+      // reapply the update afterwards.
+
+
+      if (isSuspenseInstancePending(suspenseInstance)) ; else {
+        renderDidSuspendDelayIfPossible();
+      }
+
+      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, null);
+    } else if (isSuspenseInstancePending(suspenseInstance)) {
+      // This component is still pending more data from the server, so we can't hydrate its
+      // content. We treat it as if this component suspended itself. It might seem as if
+      // we could just try to render it client-side instead. However, this will perform a
+      // lot of unnecessary work and is unlikely to complete since it often will suspend
+      // on missing data anyway. Additionally, the server might be able to render more
+      // than we can on the client yet. In that case we'd end up with more fallback states
+      // on the client than if we just leave it alone. If the server times out or errors
+      // these should update this boundary to the permanent Fallback state instead.
+      // Mark it as having captured (i.e. suspended).
+      workInProgress.flags |= DidCapture; // Leave the child in place. I.e. the dehydrated fragment.
+
+      workInProgress.child = current.child; // Register a callback to retry this boundary once the server has sent the result.
+
+      const retry = retryDehydratedSuspenseBoundary.bind(null, current);
+      registerSuspenseInstanceRetry(suspenseInstance, retry);
+      return null;
+    } else {
+      // This is the first attempt.
+      reenterHydrationStateFromDehydratedSuspenseInstance(workInProgress, suspenseInstance, suspenseState.treeContext);
+      const primaryChildren = nextProps.children;
+      const primaryChildFragment = mountSuspensePrimaryChildren(workInProgress, primaryChildren); // Mark the children as hydrating. This is a fast path to know whether this
+      // tree is part of a hydrating tree. This is used to determine if a child
+      // node has fully mounted yet, and for scheduling event replaying.
+      // Conceptually this is similar to Placement in that a new subtree is
+      // inserted into the React tree here. It just happens to not need DOM
+      // mutations because it already exists.
+
+      primaryChildFragment.flags |= Hydrating;
+      return primaryChildFragment;
+    }
+  } else {
+    // This is the second render pass. We already attempted to hydrated, but
+    // something either suspended or errored.
+    if (workInProgress.flags & ForceClientRender) {
+      // Something errored during hydration. Try again without hydrating.
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      workInProgress.flags &= ~ForceClientRender;
+      const capturedValue = createCapturedValue(Error(formatProdErrorMessage(422)));
+      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, capturedValue);
+    } else if (workInProgress.memoizedState !== null) {
+      // Something suspended and we should still be in dehydrated mode.
+      // Leave the existing child in place.
+      // Push to avoid a mismatch
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      workInProgress.child = current.child; // The dehydrated completion pass expects this flag to be there
+      // but the normal suspense pass doesn't.
+
+      workInProgress.flags |= DidCapture;
+      return null;
+    } else {
+      // Suspended but we should no longer be in dehydrated mode.
+      // Therefore we now have to render the fallback.
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      const nextPrimaryChildren = nextProps.children;
+      const nextFallbackChildren = nextProps.fallback;
+      const fallbackChildFragment = mountSuspenseFallbackAfterRetryWithoutHydrating(current, workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);
+      const primaryChildFragment = workInProgress.child;
+      primaryChildFragment.memoizedState = mountSuspenseOffscreenState(renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+      return fallbackChildFragment;
+    }
+  }
+}
+
+function scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {
+  fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
+  const alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+  }
+
+  scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);
+}
+
+function propagateSuspenseContextChange(workInProgress, firstChild, renderLanes) {
+  // Mark any Suspense boundaries with fallbacks as having work to do.
+  // If they were previously forced into fallbacks, they may now be able
+  // to unblock.
+  let node = firstChild;
+
+  while (node !== null) {
+    if (node.tag === SuspenseComponent) {
+      const state = node.memoizedState;
+
+      if (state !== null) {
+        scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);
+      }
+    } else if (node.tag === SuspenseListComponent) {
+      // If the tail is hidden there might not be an Suspense boundaries
+      // to schedule work on. In this case we have to schedule it on the
+      // list itself.
+      // We don't have to traverse to the children of the list since
+      // the list will propagate the change when it rerenders.
+      scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);
+    } else if (node.child !== null) {
+      node.child.return = node;
+      node = node.child;
+      continue;
+    }
+
+    if (node === workInProgress) {
+      return;
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    while (node.sibling === null) {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      if (node.return === null || node.return === workInProgress) {
+        return;
+      }
+
+      node = node.return;
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    node.sibling.return = node.return;
+    node = node.sibling;
+  }
+}
+
+function findLastContentRow(firstChild) {
+  // This is going to find the last row among these children that is already
+  // showing content on the screen, as opposed to being in fallback state or
+  // new. If a row has multiple Suspense boundaries, any of them being in the
+  // fallback state, counts as the whole row being in a fallback state.
+  // Note that the "rows" will be workInProgress, but any nested children
+  // will still be current since we haven't rendered them yet. The mounted
+  // order may not be the same as the new order. We use the new order.
+  let row = firstChild;
+  let lastContentRow = null;
+
+  while (row !== null) {
+    const currentRow = row.alternate; // New rows can't be content rows.
+
+    if (currentRow !== null && findFirstSuspended(currentRow) === null) {
+      lastContentRow = row;
+    }
+
+    row = row.sibling;
+  }
+
+  return lastContentRow;
+}
+
+function initSuspenseListRenderState(workInProgress, isBackwards, tail, lastContentRow, tailMode) {
+  const renderState = workInProgress.memoizedState;
+
+  if (renderState === null) {
+    workInProgress.memoizedState = {
+      isBackwards: isBackwards,
+      rendering: null,
+      renderingStartTime: 0,
+      last: lastContentRow,
+      tail: tail,
+      tailMode: tailMode
+    };
+  } else {
+    // We can reuse the existing object from previous renders.
+    renderState.isBackwards = isBackwards;
+    renderState.rendering = null;
+    renderState.renderingStartTime = 0;
+    renderState.last = lastContentRow;
+    renderState.tail = tail;
+    renderState.tailMode = tailMode;
+  }
+} // This can end up rendering this component multiple passes.
+// The first pass splits the children fibers into two sets. A head and tail.
+// We first render the head. If anything is in fallback state, we do another
+// pass through beginWork to rerender all children (including the tail) with
+// the force suspend context. If the first render didn't have anything in
+// in fallback state. Then we render each row in the tail one-by-one.
+// That happens in the completeWork phase without going back to beginWork.
+
+
+function updateSuspenseListComponent(current, workInProgress, renderLanes) {
+  const nextProps = workInProgress.pendingProps;
+  const revealOrder = nextProps.revealOrder;
+  const tailMode = nextProps.tail;
+  const newChildren = nextProps.children;
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  let suspenseContext = suspenseStackCursor.current;
+  const shouldForceFallback = hasSuspenseListContext(suspenseContext, ForceSuspenseFallback);
+
+  if (shouldForceFallback) {
+    suspenseContext = setShallowSuspenseListContext(suspenseContext, ForceSuspenseFallback);
+    workInProgress.flags |= DidCapture;
+  } else {
+    const didSuspendBefore = current !== null && (current.flags & DidCapture) !== NoFlags$1;
+
+    if (didSuspendBefore) {
+      // If we previously forced a fallback, we need to schedule work
+      // on any nested boundaries to let them know to try to render
+      // again. This is the same as context updating.
+      propagateSuspenseContextChange(workInProgress, workInProgress.child, renderLanes);
+    }
+
+    suspenseContext = setDefaultShallowSuspenseListContext(suspenseContext);
+  }
+
+  pushSuspenseListContext(workInProgress, suspenseContext);
+
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    // In legacy mode, SuspenseList doesn't work so we just
+    // use make it a noop by treating it as the default revealOrder.
+    workInProgress.memoizedState = null;
+  } else {
+    switch (revealOrder) {
+      case 'forwards':
+        {
+          const lastContentRow = findLastContentRow(workInProgress.child);
+          let tail;
+
+          if (lastContentRow === null) {
+            // The whole list is part of the tail.
+            // TODO: We could fast path by just rendering the tail now.
+            tail = workInProgress.child;
+            workInProgress.child = null;
+          } else {
+            // Disconnect the tail rows after the content row.
+            // We're going to render them separately later.
+            tail = lastContentRow.sibling;
+            lastContentRow.sibling = null;
+          }
+
+          initSuspenseListRenderState(workInProgress, false, // isBackwards
+          tail, lastContentRow, tailMode);
+          break;
+        }
+
+      case 'backwards':
+        {
+          // We're going to find the first row that has existing content.
+          // At the same time we're going to reverse the list of everything
+          // we pass in the meantime. That's going to be our tail in reverse
+          // order.
+          let tail = null;
+          let row = workInProgress.child;
+          workInProgress.child = null;
+
+          while (row !== null) {
+            const currentRow = row.alternate; // New rows can't be content rows.
+
+            if (currentRow !== null && findFirstSuspended(currentRow) === null) {
+              // This is the beginning of the main content.
+              workInProgress.child = row;
+              break;
+            }
+
+            const nextRow = row.sibling;
+            row.sibling = tail;
+            tail = row;
+            row = nextRow;
+          } // TODO: If workInProgress.child is null, we can continue on the tail immediately.
+
+
+          initSuspenseListRenderState(workInProgress, true, // isBackwards
+          tail, null, // last
+          tailMode);
+          break;
+        }
+
+      case 'together':
+        {
+          initSuspenseListRenderState(workInProgress, false, // isBackwards
+          null, // tail
+          null, // last
+          undefined);
+          break;
+        }
+
+      default:
+        {
+          // The default reveal order is the same as not having
+          // a boundary.
+          workInProgress.memoizedState = null;
+        }
+    }
+  }
+
+  return workInProgress.child;
+}
+
+function updatePortalComponent(current, workInProgress, renderLanes) {
+  pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+  const nextChildren = workInProgress.pendingProps;
+
+  if (current === null) {
+    // Portals are special because we don't append the children during mount
+    // but at commit. Therefore we need to track insertions which the normal
+    // flow doesn't do during mount. This doesn't happen at the root because
+    // the root always starts with a "current" with a null child.
+    // TODO: Consider unifying this with how the root works.
+    workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderLanes);
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  }
+
+  return workInProgress.child;
+}
+
+function updateContextProvider(current, workInProgress, renderLanes) {
+  const providerType = workInProgress.type;
+  const context = providerType._context;
+  const newProps = workInProgress.pendingProps;
+  const oldProps = workInProgress.memoizedProps;
+  const newValue = newProps.value;
+
+  pushProvider(workInProgress, context, newValue);
+
+  {
+    if (oldProps !== null) {
+      const oldValue = oldProps.value;
+
+      if (objectIs(oldValue, newValue)) {
+        // No change. Bailout early if children are the same.
+        if (oldProps.children === newProps.children && !hasContextChanged()) {
+          return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+        }
+      } else {
+        // The context value changed. Search for matching consumers and schedule
+        // them to update.
+        propagateContextChange(workInProgress, context, renderLanes);
+      }
+    }
+  }
+
+  const newChildren = newProps.children;
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateContextConsumer(current, workInProgress, renderLanes) {
+  let context = workInProgress.type; // The logic below for Context differs depending on PROD or DEV mode. In
+
+  const newProps = workInProgress.pendingProps;
+  const render = newProps.children;
+
+  prepareToReadContext(workInProgress, renderLanes);
+  const newValue = readContext(context);
+
+  let newChildren;
+
+  {
+    newChildren = render(newValue);
+  }
+
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function markWorkInProgressReceivedUpdate() {
+  didReceiveUpdate = true;
+}
+
+function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    if (current !== null) {
+      // A lazy component only mounts if it suspended inside a non-
+      // concurrent tree, in an inconsistent state. We want to treat it like
+      // a new mount, even though an empty version of it already committed.
+      // Disconnect the alternate pointers.
+      current.alternate = null;
+      workInProgress.alternate = null; // Since this is conceptually a new fiber, schedule a Placement effect
+
+      workInProgress.flags |= Placement;
+    }
+  }
+}
+
+function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
+  if (current !== null) {
+    // Reuse previous dependencies
+    workInProgress.dependencies = current.dependencies;
+  }
+
+  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.
+    {
+      return null;
+    }
+  } // This fiber doesn't have work, but its subtree does. Clone the child
+  // fibers and continue.
+
+
+  cloneChildFibers(current, workInProgress);
+  return workInProgress.child;
+}
+
+function checkScheduledUpdateOrContext(current, renderLanes) {
+  // Before performing an early bailout, we must check if there are pending
+  // updates or context.
+  const updateLanes = current.lanes;
+
+  if (includesSomeLane(updateLanes, renderLanes)) {
+    return true;
+  } // No pending update, but because context is propagated lazily, we need
+
+  return false;
+}
+
+function attemptEarlyBailoutIfNoScheduledUpdate(current, workInProgress, renderLanes) {
+  // This fiber does not have any pending work. Bailout without entering
+  // the begin phase. There's still some bookkeeping we that needs to be done
+  // in this optimized path, mostly pushing stuff onto the stack.
+  switch (workInProgress.tag) {
+    case HostRoot:
+      pushHostRootContext(workInProgress);
+
+      {
+        const cache = current.memoizedState.cache;
+        pushCacheProvider(workInProgress, cache);
+      }
+
+      resetHydrationState();
+      break;
+
+    case HostSingleton:
+    case HostComponent:
+      pushHostContext(workInProgress);
+      break;
+
+    case ClassComponent:
+      {
+        const Component = workInProgress.type;
+
+        if (isContextProvider(Component)) {
+          pushContextProvider(workInProgress);
+        }
+
+        break;
+      }
+
+    case HostPortal:
+      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+      break;
+
+    case ContextProvider:
+      {
+        const newValue = workInProgress.memoizedProps.value;
+        const context = workInProgress.type._context;
+        pushProvider(workInProgress, context, newValue);
+        break;
+      }
+
+    case Profiler:
+
+      break;
+
+    case SuspenseComponent:
+      {
+        const state = workInProgress.memoizedState;
+
+        if (state !== null) {
+          if (state.dehydrated !== null) {
+            // We're not going to render the children, so this is just to maintain
+            // push/pop symmetry
+            pushPrimaryTreeSuspenseHandler(workInProgress); // We know that this component will suspend again because if it has
+            // been unsuspended it has committed as a resolved Suspense component.
+            // If it needs to be retried, it should have work scheduled on it.
+
+            workInProgress.flags |= DidCapture; // We should never render the children of a dehydrated boundary until we
+            // upgrade it. We return null instead of bailoutOnAlreadyFinishedWork.
+
+            return null;
+          } // If this boundary is currently timed out, we need to decide
+          // whether to retry the primary children, or to skip over it and
+          // go straight to the fallback. Check the priority of the primary
+          // child fragment.
+
+
+          const primaryChildFragment = workInProgress.child;
+          const primaryChildLanes = primaryChildFragment.childLanes;
+
+          if (includesSomeLane(renderLanes, primaryChildLanes)) {
+            // The primary children have pending work. Use the normal path
+            // to attempt to render the primary children again.
+            return updateSuspenseComponent(current, workInProgress, renderLanes);
+          } else {
+            // The primary child fragment does not have pending work marked
+            // on it
+            pushPrimaryTreeSuspenseHandler(workInProgress); // The primary children do not have pending work with sufficient
+            // priority. Bailout.
+
+            const child = bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+
+            if (child !== null) {
+              // The fallback children have pending work. Skip over the
+              // primary children and work on the fallback.
+              return child.sibling;
+            } else {
+              // Note: We can return `null` here because we already checked
+              // whether there were nested context consumers, via the call to
+              // `bailoutOnAlreadyFinishedWork` above.
+              return null;
+            }
+          }
+        } else {
+          pushPrimaryTreeSuspenseHandler(workInProgress);
+        }
+
+        break;
+      }
+
+    case SuspenseListComponent:
+      {
+        const didSuspendBefore = (current.flags & DidCapture) !== NoFlags$1;
+        let hasChildWork = includesSomeLane(renderLanes, workInProgress.childLanes);
+
+        if (didSuspendBefore) {
+          if (hasChildWork) {
+            // If something was in fallback state last time, and we have all the
+            // same children then we're still in progressive loading state.
+            // Something might get unblocked by state updates or retries in the
+            // tree which will affect the tail. So we need to use the normal
+            // path to compute the correct tail.
+            return updateSuspenseListComponent(current, workInProgress, renderLanes);
+          } // If none of the children had any work, that means that none of
+          // them got retried so they'll still be blocked in the same way
+          // as before. We can fast bail out.
+
+
+          workInProgress.flags |= DidCapture;
+        } // If nothing suspended before and we're rendering the same children,
+        // then the tail doesn't matter. Anything new that suspends will work
+        // in the "together" mode, so we can continue from the state we had.
+
+
+        const renderState = workInProgress.memoizedState;
+
+        if (renderState !== null) {
+          // Reset to the "together" mode in case we've started a different
+          // update in the past but didn't complete it.
+          renderState.rendering = null;
+          renderState.tail = null;
+          renderState.lastEffect = null;
+        }
+
+        pushSuspenseListContext(workInProgress, suspenseStackCursor.current);
+
+        if (hasChildWork) {
+          break;
+        } else {
+          // If none of the children had any work, that means that none of
+          // them got retried so they'll still be blocked in the same way
+          // as before. We can fast bail out.
+          return null;
+        }
+      }
+
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      {
+        // Need to check if the tree still needs to be deferred. This is
+        // almost identical to the logic used in the normal update path,
+        // so we'll just enter that. The only difference is we'll bail out
+        // at the next level instead of this one, because the child props
+        // have not changed. Which is fine.
+        // TODO: Probably should refactor `beginWork` to split the bailout
+        // path from the normal path. I'm tempted to do a labeled break here
+        // but I won't :)
+        workInProgress.lanes = NoLanes;
+        return updateOffscreenComponent(current, workInProgress, renderLanes);
+      }
+
+    case CacheComponent:
+      {
+        {
+          const cache = current.memoizedState.cache;
+          pushCacheProvider(workInProgress, cache);
+        }
+
+        break;
+      }
+  }
+
+  return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+}
+
+function beginWork$1(current, workInProgress, renderLanes) {
+
+  if (current !== null) {
+    const oldProps = current.memoizedProps;
+    const newProps = workInProgress.pendingProps;
+
+    if (oldProps !== newProps || hasContextChanged() || ( // Force a re-render if the implementation changed due to hot reload:
+    false)) {
+      // If props or context changed, mark the fiber as having performed work.
+      // This may be unset if the props are determined to be equal later (memo).
+      didReceiveUpdate = true;
+    } else {
+      // Neither props nor legacy context changes. Check if there's a pending
+      // update or context change.
+      const hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(current, renderLanes);
+
+      if (!hasScheduledUpdateOrContext && // If this is the second pass of an error or suspense boundary, there
+      // may not be work scheduled on `current`, so we check for this flag.
+      (workInProgress.flags & DidCapture) === NoFlags$1) {
+        // No pending updates or context. Bail out now.
+        didReceiveUpdate = false;
+        return attemptEarlyBailoutIfNoScheduledUpdate(current, workInProgress, renderLanes);
+      }
+
+      if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags$1) {
+        // This is a special case that only exists for legacy mode.
+        // See https://github.com/facebook/react/pull/19216.
+        didReceiveUpdate = true;
+      } else {
+        // An update was scheduled on this fiber, but there are no new props
+        // nor legacy context. Set this to false. If an update queue or context
+        // consumer produces a changed value, it will set this to true. Otherwise,
+        // the component will assume the children have not changed and bail out.
+        didReceiveUpdate = false;
+      }
+    }
+  } else {
+    didReceiveUpdate = false;
+
+    if (getIsHydrating() && isForkedChild(workInProgress)) {
+      // Check if this child belongs to a list of muliple children in
+      // its parent.
+      //
+      // In a true multi-threaded implementation, we would render children on
+      // parallel threads. This would represent the beginning of a new render
+      // thread for this subtree.
+      //
+      // We only use this for id generation during hydration, which is why the
+      // logic is located in this special branch.
+      const slotIndex = workInProgress.index;
+      const numberOfForks = getForksAtLevel();
+      pushTreeId(workInProgress, numberOfForks, slotIndex);
+    }
+  } // Before entering the begin phase, clear pending update priority.
+  // TODO: This assumes that we're about to evaluate the component and process
+  // the update queue. However, there's an exception: SimpleMemoComponent
+  // sometimes bails out later in the begin phase. This indicates that we should
+  // move this assignment out of the common path and into each branch.
+
+
+  workInProgress.lanes = NoLanes;
+
+  switch (workInProgress.tag) {
+    case IndeterminateComponent:
+      {
+        return mountIndeterminateComponent(current, workInProgress, workInProgress.type, renderLanes);
+      }
+
+    case LazyComponent:
+      {
+        const elementType = workInProgress.elementType;
+        return mountLazyComponent(current, workInProgress, elementType, renderLanes);
+      }
+
+    case FunctionComponent:
+      {
+        const Component = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps;
+        const resolvedProps = workInProgress.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        return updateFunctionComponent(current, workInProgress, Component, resolvedProps, renderLanes);
+      }
+
+    case ClassComponent:
+      {
+        const Component = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps;
+        const resolvedProps = workInProgress.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        return updateClassComponent(current, workInProgress, Component, resolvedProps, renderLanes);
+      }
+
+    case HostRoot:
+      return updateHostRoot(current, workInProgress, renderLanes);
+
+    case HostHoistable:
+      {
+        return updateHostHoistable(current, workInProgress);
+      }
+
+    // Fall through
+
+    case HostSingleton:
+      {
+        return updateHostSingleton(current, workInProgress, renderLanes);
+      }
+
+    // Fall through
+
+    case HostComponent:
+      return updateHostComponent$1(current, workInProgress, renderLanes);
+
+    case HostText:
+      return updateHostText$1(current, workInProgress);
+
+    case SuspenseComponent:
+      return updateSuspenseComponent(current, workInProgress, renderLanes);
+
+    case HostPortal:
+      return updatePortalComponent(current, workInProgress, renderLanes);
+
+    case ForwardRef:
+      {
+        const type = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps;
+        const resolvedProps = workInProgress.elementType === type ? unresolvedProps : resolveDefaultProps(type, unresolvedProps);
+        return updateForwardRef(current, workInProgress, type, resolvedProps, renderLanes);
+      }
+
+    case Fragment:
+      return updateFragment(current, workInProgress, renderLanes);
+
+    case Mode:
+      return updateMode(current, workInProgress, renderLanes);
+
+    case Profiler:
+      return updateProfiler(current, workInProgress, renderLanes);
+
+    case ContextProvider:
+      return updateContextProvider(current, workInProgress, renderLanes);
+
+    case ContextConsumer:
+      return updateContextConsumer(current, workInProgress, renderLanes);
+
+    case MemoComponent:
+      {
+        const type = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps; // Resolve outer props first, then resolve inner props.
+
+        let resolvedProps = resolveDefaultProps(type, unresolvedProps);
+
+        resolvedProps = resolveDefaultProps(type.type, resolvedProps);
+        return updateMemoComponent(current, workInProgress, type, resolvedProps, renderLanes);
+      }
+
+    case SimpleMemoComponent:
+      {
+        return updateSimpleMemoComponent(current, workInProgress, workInProgress.type, workInProgress.pendingProps, renderLanes);
+      }
+
+    case IncompleteClassComponent:
+      {
+        const Component = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps;
+        const resolvedProps = workInProgress.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        return mountIncompleteClassComponent(current, workInProgress, Component, resolvedProps, renderLanes);
+      }
+
+    case SuspenseListComponent:
+      {
+        return updateSuspenseListComponent(current, workInProgress, renderLanes);
+      }
+
+    case ScopeComponent:
+      {
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        return updateOffscreenComponent(current, workInProgress, renderLanes);
+      }
+
+    case LegacyHiddenComponent:
+      {
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        {
+          return updateCacheComponent(current, workInProgress, renderLanes);
+        }
+      }
+  }
+
+  throw Error(formatProdErrorMessage(156, workInProgress.tag));
+}
+
+const valueCursor = createCursor(null);
+
+let currentlyRenderingFiber = null;
+let lastContextDependency = null;
+let lastFullyObservedContext = null;
+function resetContextDependencies() {
+  // This is called right before React yields execution, to ensure `readContext`
+  // cannot be called outside the render phase.
+  currentlyRenderingFiber = null;
+  lastContextDependency = null;
+  lastFullyObservedContext = null;
+}
+function pushProvider(providerFiber, context, nextValue) {
+  {
+    push(valueCursor, context._currentValue);
+    context._currentValue = nextValue;
+  }
+}
+function popProvider(context, providerFiber) {
+  const currentValue = valueCursor.current;
+
+  {
+    if (currentValue === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      context._currentValue = context._defaultValue;
+    } else {
+      context._currentValue = currentValue;
+    }
+  }
+
+  pop(valueCursor);
+}
+function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
+  // Update the child lanes of all the ancestors, including the alternates.
+  let node = parent;
+
+  while (node !== null) {
+    const alternate = node.alternate;
+
+    if (!isSubsetOfLanes(node.childLanes, renderLanes)) {
+      node.childLanes = mergeLanes(node.childLanes, renderLanes);
+
+      if (alternate !== null) {
+        alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
+      }
+    } else if (alternate !== null && !isSubsetOfLanes(alternate.childLanes, renderLanes)) {
+      alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
+    } else ;
+
+    if (node === propagationRoot) {
+      break;
+    }
+
+    node = node.return;
+  }
+}
+function propagateContextChange(workInProgress, context, renderLanes) {
+  {
+    propagateContextChange_eager(workInProgress, context, renderLanes);
+  }
+}
+
+function propagateContextChange_eager(workInProgress, context, renderLanes) {
+
+  let 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) {
+    let nextFiber; // Visit this fiber.
+
+    const list = fiber.dependencies;
+
+    if (list !== null) {
+      nextFiber = fiber.child;
+      let dependency = list.firstContext;
+
+      while (dependency !== null) {
+        // Check if the context matches.
+        if (dependency.context === context) {
+          // Match! Schedule an update on this fiber.
+          if (fiber.tag === ClassComponent) {
+            // Schedule a force update on the work-in-progress.
+            const lane = pickArbitraryLane(renderLanes);
+            const update = createUpdate(lane);
+            update.tag = ForceUpdate; // TODO: Because we don't have a work-in-progress, this will add the
+            // update to the current fiber, too, which means it will persist even if
+            // this render is thrown away. Since it's a race condition, not sure it's
+            // worth fixing.
+            // Inlined `enqueueUpdate` to remove interleaved update check
+
+            const updateQueue = fiber.updateQueue;
+
+            if (updateQueue === null) ; else {
+              const sharedQueue = updateQueue.shared;
+              const pending = sharedQueue.pending;
+
+              if (pending === null) {
+                // This is the first update. Create a circular list.
+                update.next = update;
+              } else {
+                update.next = pending.next;
+                pending.next = update;
+              }
+
+              sharedQueue.pending = update;
+            }
+          }
+
+          fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
+          const alternate = fiber.alternate;
+
+          if (alternate !== null) {
+            alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+          }
+
+          scheduleContextWorkOnParentPath(fiber.return, renderLanes, workInProgress); // Mark the updated lanes on the list, too.
+
+          list.lanes = mergeLanes(list.lanes, renderLanes); // Since we already found a match, we can stop traversing the
+          // dependency list.
+
+          break;
+        }
+
+        dependency = dependency.next;
+      }
+    } else if (fiber.tag === ContextProvider) {
+      // Don't scan deeper if this is a matching provider
+      nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
+    } else if (fiber.tag === DehydratedFragment) {
+      // If a dehydrated suspense boundary is in this subtree, we don't know
+      // if it will have any context consumers in it. The best we can do is
+      // mark it as having updates.
+      const parentSuspense = fiber.return;
+
+      if (parentSuspense === null) {
+        throw Error(formatProdErrorMessage(341));
+      }
+
+      parentSuspense.lanes = mergeLanes(parentSuspense.lanes, renderLanes);
+      const alternate = parentSuspense.alternate;
+
+      if (alternate !== null) {
+        alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+      } // This is intentionally passing this fiber as the parent
+      // because we want to schedule this fiber as having work
+      // on its children. We'll use the childLanes on
+      // this fiber to indicate that a context has changed.
+
+
+      scheduleContextWorkOnParentPath(parentSuspense, renderLanes, workInProgress);
+      nextFiber = fiber.sibling;
+    } else {
+      // Traverse down.
+      nextFiber = fiber.child;
+    }
+
+    if (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;
+        }
+
+        const 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 prepareToReadContext(workInProgress, renderLanes) {
+  currentlyRenderingFiber = workInProgress;
+  lastContextDependency = null;
+  lastFullyObservedContext = null;
+  const dependencies = workInProgress.dependencies;
+
+  if (dependencies !== null) {
+    {
+      const firstContext = dependencies.firstContext;
+
+      if (firstContext !== null) {
+        if (includesSomeLane(dependencies.lanes, renderLanes)) {
+          // Context list has a pending update. Mark that this fiber performed work.
+          markWorkInProgressReceivedUpdate();
+        } // Reset the work-in-progress list
+
+
+        dependencies.firstContext = null;
+      }
+    }
+  }
+}
+function readContext(context) {
+
+  return readContextForConsumer(currentlyRenderingFiber, context);
+}
+function readContextDuringReconcilation(consumer, context, renderLanes) {
+  if (currentlyRenderingFiber === null) {
+    prepareToReadContext(consumer, renderLanes);
+  }
+
+  return readContextForConsumer(consumer, context);
+}
+
+function readContextForConsumer(consumer, context) {
+  const value = context._currentValue ;
+
+  if (lastFullyObservedContext === context) ; else {
+    const contextItem = {
+      context: context,
+      memoizedValue: value,
+      next: null
+    };
+
+    if (lastContextDependency === null) {
+      if (consumer === null) {
+        throw Error(formatProdErrorMessage(308));
+      } // This is the first dependency for this component. Create a new list.
+
+
+      lastContextDependency = contextItem;
+      consumer.dependencies = {
+        lanes: NoLanes,
+        firstContext: contextItem
+      };
+    } else {
+      // Append a new context item.
+      lastContextDependency = lastContextDependency.next = contextItem;
+    }
+  }
+
+  return value;
+}
+
+// replace it with a lightweight shim that only has the features we use.
+
+const AbortControllerLocal = typeof AbortController !== 'undefined' ? AbortController : // $FlowFixMe[missing-this-annot]
+// $FlowFixMe[prop-missing]
+function AbortControllerShim() {
+  const listeners = [];
+  const signal = this.signal = {
+    aborted: false,
+    addEventListener: (type, listener) => {
+      listeners.push(listener);
+    }
+  };
+
+  this.abort = () => {
+    signal.aborted = true;
+    listeners.forEach(listener => listener());
+  };
+} ; // Intentionally not named imports because Rollup would
+// use dynamic dispatch for CommonJS interop named imports.
+
+const scheduleCallback$1 = Scheduler.unstable_scheduleCallback,
+      NormalPriority = Scheduler.unstable_NormalPriority;
+const CacheContext = {
+  $$typeof: REACT_CONTEXT_TYPE,
+  // We don't use Consumer/Provider for Cache components. So we'll cheat.
+  Consumer: null,
+  Provider: null,
+  // We'll initialize these at the root.
+  _currentValue: null,
+  _currentValue2: null,
+  _threadCount: 0,
+  _defaultValue: null,
+  _globalName: null
+} ;
+// for retaining the cache once it is in use (retainCache), and releasing the cache
+// once it is no longer needed (releaseCache).
+
+
+function createCache() {
+
+  const cache = {
+    controller: new AbortControllerLocal(),
+    data: new Map(),
+    refCount: 0
+  };
+  return cache;
+}
+function retainCache(cache) {
+
+  cache.refCount++;
+} // Cleanup a cache instance, potentially freeing it if there are no more references
+
+function releaseCache(cache) {
+
+  cache.refCount--;
+
+  if (cache.refCount === 0) {
+    scheduleCallback$1(NormalPriority, () => {
+      cache.controller.abort();
+    });
+  }
+}
+function pushCacheProvider(workInProgress, cache) {
+
+  pushProvider(workInProgress, CacheContext, cache);
+}
+function popCacheProvider(workInProgress, cache) {
+
+  popProvider(CacheContext);
+}
+
+const ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig;
+const NoTransition = null;
+function requestCurrentTransition() {
+  return ReactCurrentBatchConfig$2.transition;
+} // When retrying a Suspense/Offscreen boundary, we restore the cache that was
+// used during the previous render by placing it here, on the stack.
+
+const resumedCache = createCursor(null); // During the render/synchronous commit phase, we don't actually process the
+
+function peekCacheFromPool() {
+  // If we're rendering inside a Suspense boundary that is currently hidden,
+  // we should use the same cache that we used during the previous render, if
+  // one exists.
+
+
+  const cacheResumedFromPreviousRender = resumedCache.current;
+
+  if (cacheResumedFromPreviousRender !== null) {
+    return cacheResumedFromPreviousRender;
+  } // Otherwise, check the root's cache pool.
+
+
+  const root = getWorkInProgressRoot();
+  const cacheFromRootCachePool = root.pooledCache;
+  return cacheFromRootCachePool;
+}
+
+function requestCacheFromPool(renderLanes) {
+  // Similar to previous function, except if there's not already a cache in the
+  // pool, we allocate a new one.
+  const cacheFromPool = peekCacheFromPool();
+
+  if (cacheFromPool !== null) {
+    return cacheFromPool;
+  } // Create a fresh cache and add it to the root cache pool. A cache can have
+  // multiple owners:
+  // - A cache pool that lives on the FiberRoot. This is where all fresh caches
+  //   are originally created (TODO: except during refreshes, until we implement
+  //   this correctly). The root takes ownership immediately when the cache is
+  //   created. Conceptually, root.pooledCache is an Option<Arc<Cache>> (owned),
+  //   and the return value of this function is a &Arc<Cache> (borrowed).
+  // - One of several fiber types: host root, cache boundary, suspense
+  //   component. These retain and release in the commit phase.
+
+
+  const root = getWorkInProgressRoot();
+  const freshCache = createCache();
+  root.pooledCache = freshCache;
+  retainCache(freshCache);
+
+  if (freshCache !== null) {
+    root.pooledCacheLanes |= renderLanes;
+  }
+
+  return freshCache;
+}
+function pushTransition(offscreenWorkInProgress, prevCachePool, newTransitions) {
+  {
+    if (prevCachePool === null) {
+      push(resumedCache, resumedCache.current);
+    } else {
+      push(resumedCache, prevCachePool.pool);
+    }
+  }
+}
+function popTransition(workInProgress, current) {
+  if (current !== null) {
+
+    {
+      pop(resumedCache);
+    }
+  }
+}
+function getSuspendedCache() {
+  // cache that would have been used to render fresh data during this render,
+  // if there was any, so that we can resume rendering with the same cache when
+  // we receive more data.
+
+
+  const cacheFromPool = peekCacheFromPool();
+
+  if (cacheFromPool === null) {
+    return null;
+  }
+
+  return {
+    // We must also save the parent, so that when we resume we can detect
+    // a refresh.
+    parent: CacheContext._currentValue ,
+    pool: cacheFromPool
+  };
+}
+function getOffscreenDeferredCache() {
+
+  const cacheFromPool = peekCacheFromPool();
+
+  if (cacheFromPool === null) {
+    return null;
+  }
+
+  return {
+    // We must also store the parent, so that when we resume we can detect
+    // a refresh.
+    parent: CacheContext._currentValue ,
+    pool: cacheFromPool
+  };
+}
+
+function markUpdate(workInProgress) {
+  // Tag the fiber with an update effect. This turns a Placement into
+  // a PlacementAndUpdate.
+  workInProgress.flags |= Update;
+}
+
+function markRef(workInProgress) {
+  workInProgress.flags |= Ref | RefStatic;
+}
+
+function appendAllChildren(parent, workInProgress, needsVisibilityToggle, isHidden) {
+  {
+    // We only have the top Fiber that was created but we need recurse down its
+    // children to find all the terminal nodes.
+    let node = workInProgress.child;
+
+    while (node !== null) {
+      if (node.tag === HostComponent || node.tag === HostText) {
+        appendInitialChild(parent, node.stateNode);
+      } else if (node.tag === HostPortal || (node.tag === HostSingleton )) ; else if (node.child !== null) {
+        node.child.return = node;
+        node = node.child;
+        continue;
+      }
+
+      if (node === workInProgress) {
+        return;
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+      while (node.sibling === null) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        if (node.return === null || node.return === workInProgress) {
+          return;
+        }
+
+        node = node.return;
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+      node.sibling.return = node.return;
+      node = node.sibling;
+    }
+  }
+} // An unfortunate fork of appendAllChildren because we have two different parent types.
+
+function updateHostComponent(current, workInProgress, type, newProps, renderLanes) {
+  {
+    // If we have an alternate, that means this is an update and we need to
+    // schedule a side-effect to do the updates.
+    const oldProps = current.memoizedProps;
+
+    if (oldProps === newProps) {
+      // In mutation mode, this is sufficient for a bailout because
+      // we won't touch this node even if children changed.
+      return;
+    }
+
+    markUpdate(workInProgress);
+  }
+} // This function must be called at the very end of the complete phase, because
+// it might throw to suspend, and if the resource immediately loads, the work
+// loop will resume rendering as if the work-in-progress completed. So it must
+// fully complete.
+// TODO: This should ideally move to begin phase, but currently the instance is
+// not created until the complete phase. For our existing use cases, host nodes
+// that suspend don't have children, so it doesn't matter. But that might not
+// always be true in the future.
+
+
+function preloadInstanceAndSuspendIfNeeded(workInProgress, type, props, renderLanes) {
+  {
+    // If this flag was set previously, we can remove it. The flag
+    // represents whether this particular set of props might ever need to
+    // suspend. The safest thing to do is for maySuspendCommit to always
+    // return true, but if the renderer is reasonably confident that the
+    // underlying resource won't be evicted, it can return false as a
+    // performance optimization.
+    workInProgress.flags &= ~MaySuspendCommit;
+    return;
+  } // Mark this fiber with a flag. This gets set on all host instances
+}
+
+function preloadResourceAndSuspendIfNeeded(workInProgress, resource, type, props, renderLanes) {
+  // This is a fork of preloadInstanceAndSuspendIfNeeded, but for resources.
+  if (!mayResourceSuspendCommit(resource)) {
+    workInProgress.flags &= ~MaySuspendCommit;
+    return;
+  }
+
+  workInProgress.flags |= MaySuspendCommit;
+  const rootRenderLanes = getWorkInProgressRootRenderLanes();
+
+  if (!includesOnlyNonUrgentLanes(rootRenderLanes)) ; else {
+    const isReady = preloadResource(resource);
+
+    if (!isReady) {
+      if (shouldRemainOnPreviousScreen()) {
+        workInProgress.flags |= ShouldSuspendCommit;
+      } else {
+        suspendCommit();
+      }
+    }
+  }
+}
+
+function scheduleRetryEffect(workInProgress, retryQueue) {
+  const wakeables = retryQueue;
+
+  if (wakeables !== null) {
+    // Schedule an effect to attach a retry listener to the promise.
+    // TODO: Move to passive phase
+    workInProgress.flags |= Update;
+  } else {
+    // This boundary suspended, but no wakeables were added to the retry
+    // queue. Check if the renderer suspended commit. If so, this means
+    // that once the fallback is committed, we can immediately retry
+    // rendering again, because rendering wasn't actually blocked. Only
+    // the commit phase.
+    // TODO: Consider a model where we always schedule an immediate retry, even
+    // for normal Suspense. That way the retry can partially render up to the
+    // first thing that suspends.
+    if (workInProgress.flags & ScheduleRetry) {
+      const retryLane = // TODO: This check should probably be moved into claimNextRetryLane
+      // I also suspect that we need some further consolidation of offscreen
+      // and retry lanes.
+      workInProgress.tag !== OffscreenComponent ? claimNextRetryLane() : OffscreenLane;
+      workInProgress.lanes = mergeLanes(workInProgress.lanes, retryLane);
+    }
+  }
+}
+
+function updateHostText(current, workInProgress, oldText, newText) {
+  {
+    // If the text differs, mark it as an update. All the work in done in commitWork.
+    if (oldText !== newText) {
+      markUpdate(workInProgress);
+    }
+  }
+}
+
+function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
+  if (getIsHydrating()) {
+    // If we're hydrating, we should consume as many items as we can
+    // so we don't leave any behind.
+    return;
+  }
+
+  switch (renderState.tailMode) {
+    case 'hidden':
+      {
+        // Any insertions at the end of the tail list after this point
+        // should be invisible. If there are already mounted boundaries
+        // anything before them are not considered for collapsing.
+        // Therefore we need to go through the whole tail to find if
+        // there are any.
+        let tailNode = renderState.tail;
+        let lastTailNode = null;
+
+        while (tailNode !== null) {
+          if (tailNode.alternate !== null) {
+            lastTailNode = tailNode;
+          }
+
+          tailNode = tailNode.sibling;
+        } // Next we're simply going to delete all insertions after the
+        // last rendered item.
+
+
+        if (lastTailNode === null) {
+          // All remaining items in the tail are insertions.
+          renderState.tail = null;
+        } else {
+          // Detach the insertion after the last node that was already
+          // inserted.
+          lastTailNode.sibling = null;
+        }
+
+        break;
+      }
+
+    case 'collapsed':
+      {
+        // Any insertions at the end of the tail list after this point
+        // should be invisible. If there are already mounted boundaries
+        // anything before them are not considered for collapsing.
+        // Therefore we need to go through the whole tail to find if
+        // there are any.
+        let tailNode = renderState.tail;
+        let lastTailNode = null;
+
+        while (tailNode !== null) {
+          if (tailNode.alternate !== null) {
+            lastTailNode = tailNode;
+          }
+
+          tailNode = tailNode.sibling;
+        } // Next we're simply going to delete all insertions after the
+        // last rendered item.
+
+
+        if (lastTailNode === null) {
+          // All remaining items in the tail are insertions.
+          if (!hasRenderedATailFallback && renderState.tail !== null) {
+            // We suspended during the head. We want to show at least one
+            // row at the tail. So we'll keep on and cut off the rest.
+            renderState.tail.sibling = null;
+          } else {
+            renderState.tail = null;
+          }
+        } else {
+          // Detach the insertion after the last node that was already
+          // inserted.
+          lastTailNode.sibling = null;
+        }
+
+        break;
+      }
+  }
+}
+
+function bubbleProperties(completedWork) {
+  const didBailout = completedWork.alternate !== null && completedWork.alternate.child === completedWork.child;
+  let newChildLanes = NoLanes;
+  let subtreeFlags = NoFlags$1;
+
+  if (!didBailout) {
+    // Bubble up the earliest expiration time.
+    {
+      let child = completedWork.child;
+
+      while (child !== null) {
+        newChildLanes = mergeLanes(newChildLanes, mergeLanes(child.lanes, child.childLanes));
+        subtreeFlags |= child.subtreeFlags;
+        subtreeFlags |= child.flags; // Update the return pointer so the tree is consistent. This is a code
+        // smell because it assumes the commit phase is never concurrent with
+        // the render phase. Will address during refactor to alternate model.
+
+        child.return = completedWork;
+        child = child.sibling;
+      }
+    }
+
+    completedWork.subtreeFlags |= subtreeFlags;
+  } else {
+    // Bubble up the earliest expiration time.
+    {
+      let child = completedWork.child;
+
+      while (child !== null) {
+        newChildLanes = mergeLanes(newChildLanes, mergeLanes(child.lanes, child.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 |= child.subtreeFlags & StaticMask;
+        subtreeFlags |= child.flags & StaticMask; // Update the return pointer so the tree is consistent. This is a code
+        // smell because it assumes the commit phase is never concurrent with
+        // the render phase. Will address during refactor to alternate model.
+
+        child.return = completedWork;
+        child = child.sibling;
+      }
+    }
+
+    completedWork.subtreeFlags |= subtreeFlags;
+  }
+
+  completedWork.childLanes = newChildLanes;
+  return didBailout;
+}
+
+function completeDehydratedSuspenseBoundary(current, workInProgress, nextState) {
+  if (hasUnhydratedTailNodes() && (workInProgress.mode & ConcurrentMode) !== NoMode && (workInProgress.flags & DidCapture) === NoFlags$1) {
+    warnIfUnhydratedTailNodes();
+    resetHydrationState();
+    workInProgress.flags |= ForceClientRender | DidCapture;
+    return false;
+  }
+
+  const wasHydrated = popHydrationState(workInProgress);
+
+  if (nextState !== null && nextState.dehydrated !== null) {
+    // We might be inside a hydration state the first time we're picking up this
+    // Suspense boundary, and also after we've reentered it for further hydration.
+    if (current === null) {
+      if (!wasHydrated) {
+        throw Error(formatProdErrorMessage(318));
+      }
+
+      prepareToHydrateHostSuspenseInstance(workInProgress);
+      bubbleProperties(workInProgress);
+
+      return false;
+    } else {
+      // We might have reentered this boundary to hydrate it. If so, we need to reset the hydration
+      // state since we're now exiting out of it. popHydrationState doesn't do that for us.
+      resetHydrationState();
+
+      if ((workInProgress.flags & DidCapture) === NoFlags$1) {
+        // This boundary did not suspend so it's now hydrated and unsuspended.
+        workInProgress.memoizedState = null;
+      } // If nothing suspended, we need to schedule an effect to mark this boundary
+      // as having hydrated so events know that they're free to be invoked.
+      // It's also a signal to replay events and the suspense callback.
+      // If something suspended, schedule an effect to attach retry listeners.
+      // So we might as well always mark this.
+
+
+      workInProgress.flags |= Update;
+      bubbleProperties(workInProgress);
+
+      return false;
+    }
+  } else {
+    // Successfully completed this tree. If this was a forced client render,
+    // there may have been recoverable errors during first hydration
+    // attempt. If so, add them to a queue so we can log them in the
+    // commit phase.
+    upgradeHydrationErrorsToRecoverable(); // Fall through to normal Suspense path
+
+    return true;
+  }
+}
+
+function completeWork(current, workInProgress, renderLanes) {
+  const newProps = workInProgress.pendingProps; // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
+
+  popTreeContext(workInProgress);
+
+  switch (workInProgress.tag) {
+    case IndeterminateComponent:
+    case LazyComponent:
+    case SimpleMemoComponent:
+    case FunctionComponent:
+    case ForwardRef:
+    case Fragment:
+    case Mode:
+    case Profiler:
+    case ContextConsumer:
+    case MemoComponent:
+      bubbleProperties(workInProgress);
+      return null;
+
+    case ClassComponent:
+      {
+        const Component = workInProgress.type;
+
+        if (isContextProvider(Component)) {
+          popContext();
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
+
+    case HostRoot:
+      {
+        const fiberRoot = workInProgress.stateNode;
+
+        {
+          let previousCache = null;
+
+          if (current !== null) {
+            previousCache = current.memoizedState.cache;
+          }
+
+          const cache = workInProgress.memoizedState.cache;
+
+          if (cache !== previousCache) {
+            // Run passive effects to retain/release the cache.
+            workInProgress.flags |= Passive$1;
+          }
+
+          popCacheProvider();
+        }
+        popHostContainer();
+        popTopLevelContextObject();
+
+        if (fiberRoot.pendingContext) {
+          fiberRoot.context = fiberRoot.pendingContext;
+          fiberRoot.pendingContext = null;
+        }
+
+        if (current === null || current.child === null) {
+          // If we hydrated, pop so that we can delete any remaining children
+          // that weren't hydrated.
+          const wasHydrated = popHydrationState(workInProgress);
+
+          if (wasHydrated) {
+            // If we hydrated, then we'll need to schedule an update for
+            // the commit side-effects on the root.
+            markUpdate(workInProgress);
+          } else {
+            if (current !== null) {
+              const prevState = current.memoizedState;
+
+              if ( // Check if this is a client root
+              !prevState.isDehydrated || // Check if we reverted to client rendering (e.g. due to an error)
+              (workInProgress.flags & ForceClientRender) !== NoFlags$1) {
+                // Schedule an effect to clear this container at the start of the
+                // next commit. This handles the case of React rendering into a
+                // container with previous children. It's also safe to do for
+                // updates too, because current.child would only be null if the
+                // previous render was null (so the container would already
+                // be empty).
+                workInProgress.flags |= Snapshot; // If this was a forced client render, there may have been
+                // recoverable errors during first hydration attempt. If so, add
+                // them to a queue so we can log them in the commit phase.
+
+                upgradeHydrationErrorsToRecoverable();
+              }
+            }
+          }
+        }
+        bubbleProperties(workInProgress);
+
+        return null;
+      }
+
+    case HostHoistable:
+      {
+        {
+          const nextResource = workInProgress.memoizedState;
+
+          if (current === null) {
+            // We are mounting and must Update this Hoistable in this commit
+            // @TODO refactor this block to create the instance here in complete
+            // phase if we are not hydrating.
+            markUpdate(workInProgress);
+
+            if (workInProgress.ref !== null) {
+              markRef(workInProgress);
+            }
+
+            if (nextResource !== null) {
+              // This is a Hoistable Resource
+              // This must come at the very end of the complete phase.
+              bubbleProperties(workInProgress);
+              preloadResourceAndSuspendIfNeeded(workInProgress, nextResource);
+              return null;
+            } else {
+              // This is a Hoistable Instance
+              // This must come at the very end of the complete phase.
+              bubbleProperties(workInProgress);
+              preloadInstanceAndSuspendIfNeeded(workInProgress);
+              return null;
+            }
+          } else {
+            // We are updating.
+            const currentResource = current.memoizedState;
+
+            if (nextResource !== currentResource) {
+              // We are transitioning to, from, or between Hoistable Resources
+              // and require an update
+              markUpdate(workInProgress);
+            }
+
+            if (current.ref !== workInProgress.ref) {
+              markRef(workInProgress);
+            }
+
+            if (nextResource !== null) {
+              // This is a Hoistable Resource
+              // This must come at the very end of the complete phase.
+              bubbleProperties(workInProgress);
+
+              if (nextResource === currentResource) {
+                workInProgress.flags &= ~MaySuspendCommit;
+              } else {
+                preloadResourceAndSuspendIfNeeded(workInProgress, nextResource);
+              }
+
+              return null;
+            } else {
+              // This is a Hoistable Instance
+              // We may have props to update on the Hoistable instance.
+              {
+                const oldProps = current.memoizedProps;
+
+                if (oldProps !== newProps) {
+                  markUpdate(workInProgress);
+                }
+              } // This must come at the very end of the complete phase.
+
+
+              bubbleProperties(workInProgress);
+              preloadInstanceAndSuspendIfNeeded(workInProgress);
+              return null;
+            }
+          }
+        } // Fall through
+
+      }
+
+    case HostSingleton:
+      {
+        {
+          popHostContext(workInProgress);
+          const rootContainerInstance = getRootHostContainer();
+          const type = workInProgress.type;
+
+          if (current !== null && workInProgress.stateNode != null) {
+            {
+              const oldProps = current.memoizedProps;
+
+              if (oldProps !== newProps) {
+                markUpdate(workInProgress);
+              }
+            }
+
+            if (current.ref !== workInProgress.ref) {
+              markRef(workInProgress);
+            }
+          } else {
+            if (!newProps) {
+              if (workInProgress.stateNode === null) {
+                throw Error(formatProdErrorMessage(166));
+              } // This can happen when we abort work.
+
+
+              bubbleProperties(workInProgress);
+              return null;
+            }
+
+            const currentHostContext = getHostContext();
+            const wasHydrated = popHydrationState(workInProgress);
+            let instance;
+
+            if (wasHydrated) {
+              // We ignore the boolean indicating there is an updateQueue because
+              // it is used only to set text children and HostSingletons do not
+              // use them.
+              prepareToHydrateHostInstance(workInProgress, currentHostContext);
+              instance = workInProgress.stateNode;
+            } else {
+              instance = resolveSingletonInstance(type, newProps, rootContainerInstance);
+              workInProgress.stateNode = instance;
+              markUpdate(workInProgress);
+            }
+
+            if (workInProgress.ref !== null) {
+              // If there is a ref on a host node we need to schedule a callback
+              markRef(workInProgress);
+            }
+          }
+
+          bubbleProperties(workInProgress);
+          return null;
+        } // Fall through
+
+      }
+
+    case HostComponent:
+      {
+        popHostContext(workInProgress);
+        const type = workInProgress.type;
+
+        if (current !== null && workInProgress.stateNode != null) {
+          updateHostComponent(current, workInProgress, type, newProps);
+
+          if (current.ref !== workInProgress.ref) {
+            markRef(workInProgress);
+          }
+        } else {
+          if (!newProps) {
+            if (workInProgress.stateNode === null) {
+              throw Error(formatProdErrorMessage(166));
+            } // This can happen when we abort work.
+
+
+            bubbleProperties(workInProgress);
+            return null;
+          }
+
+          const currentHostContext = getHostContext(); // TODO: Move createInstance to beginWork and keep it on a context
+          // "stack" as the parent. Then append children as we go in beginWork
+          // or completeWork depending on whether we want to add them top->down or
+          // bottom->up. Top->down is faster in IE11.
+
+          const wasHydrated = popHydrationState(workInProgress);
+
+          if (wasHydrated) {
+            // TODO: Move this and createInstance step into the beginPhase
+            // to consolidate.
+            prepareToHydrateHostInstance(workInProgress, currentHostContext);
+          } else {
+            const rootContainerInstance = getRootHostContainer();
+            const instance = createInstance(type, newProps, rootContainerInstance, currentHostContext, workInProgress); // TODO: For persistent renderers, we should pass children as part
+            // of the initial instance creation
+
+            appendAllChildren(instance, workInProgress);
+            workInProgress.stateNode = instance; // Certain renderers require commit-time effects for initial mount.
+            // (eg DOM renderer supports auto-focus for certain elements).
+            // Make sure such renderers get scheduled for later work.
+
+            if (finalizeInitialChildren(instance, type, newProps)) {
+              markUpdate(workInProgress);
+            }
+          }
+
+          if (workInProgress.ref !== null) {
+            // If there is a ref on a host node we need to schedule a callback
+            markRef(workInProgress);
+          }
+        }
+
+        bubbleProperties(workInProgress); // This must come at the very end of the complete phase, because it might
+        // throw to suspend, and if the resource immediately loads, the work loop
+        // will resume rendering as if the work-in-progress completed. So it must
+        // fully complete.
+
+        preloadInstanceAndSuspendIfNeeded(workInProgress);
+        return null;
+      }
+
+    case HostText:
+      {
+        const newText = newProps;
+
+        if (current && workInProgress.stateNode != null) {
+          const oldText = current.memoizedProps; // If we have an alternate, that means this is an update and we need
+          // to schedule a side-effect to do the updates.
+
+          updateHostText(current, workInProgress, oldText, newText);
+        } else {
+          if (typeof newText !== 'string') {
+            if (workInProgress.stateNode === null) {
+              throw Error(formatProdErrorMessage(166));
+            } // This can happen when we abort work.
+
+          }
+
+          const rootContainerInstance = getRootHostContainer();
+          const currentHostContext = getHostContext();
+          const wasHydrated = popHydrationState(workInProgress);
+
+          if (wasHydrated) {
+            if (prepareToHydrateHostTextInstance(workInProgress)) {
+              markUpdate(workInProgress);
+            }
+          } else {
+            workInProgress.stateNode = createTextInstance(newText, rootContainerInstance, currentHostContext, workInProgress);
+          }
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
+
+    case SuspenseComponent:
+      {
+        popSuspenseHandler(workInProgress);
+        const nextState = workInProgress.memoizedState; // Special path for dehydrated boundaries. We may eventually move this
+        // to its own fiber type so that we can add other kinds of hydration
+        // boundaries that aren't associated with a Suspense tree. In anticipation
+        // of such a refactor, all the hydration logic is contained in
+        // this branch.
+
+        if (current === null || current.memoizedState !== null && current.memoizedState.dehydrated !== null) {
+          const fallthroughToNormalSuspensePath = completeDehydratedSuspenseBoundary(current, workInProgress, nextState);
+
+          if (!fallthroughToNormalSuspensePath) {
+            if (workInProgress.flags & ForceClientRender) {
+              // Special case. There were remaining unhydrated nodes. We treat
+              // this as a mismatch. Revert to client rendering.
+              return workInProgress;
+            } else {
+              // Did not finish hydrating, either because this is the initial
+              // render or because something suspended.
+              return null;
+            }
+          } // Continue with the normal Suspense path.
+
+        }
+
+        if ((workInProgress.flags & DidCapture) !== NoFlags$1) {
+          // Something suspended. Re-render with the fallback children.
+          workInProgress.lanes = renderLanes; // Do not reset the effect list.
+
+
+          return workInProgress;
+        }
+
+        const nextDidTimeout = nextState !== null;
+        const prevDidTimeout = current !== null && current.memoizedState !== null;
+
+        if (nextDidTimeout) {
+          const offscreenFiber = workInProgress.child;
+          let previousCache = null;
+
+          if (offscreenFiber.alternate !== null && offscreenFiber.alternate.memoizedState !== null && offscreenFiber.alternate.memoizedState.cachePool !== null) {
+            previousCache = offscreenFiber.alternate.memoizedState.cachePool.pool;
+          }
+
+          let cache = null;
+
+          if (offscreenFiber.memoizedState !== null && offscreenFiber.memoizedState.cachePool !== null) {
+            cache = offscreenFiber.memoizedState.cachePool.pool;
+          }
+
+          if (cache !== previousCache) {
+            // Run passive effects to retain/release the cache.
+            offscreenFiber.flags |= Passive$1;
+          }
+        } // If the suspended state of the boundary changes, we need to schedule
+        // a passive effect, which is when we process the transitions
+
+
+        if (nextDidTimeout !== prevDidTimeout) {
+          // an effect to toggle the subtree's visibility. When we switch from
+          // fallback -> primary, the inner Offscreen fiber schedules this effect
+          // as part of its normal complete phase. But when we switch from
+          // primary -> fallback, the inner Offscreen fiber does not have a complete
+          // phase. So we need to schedule its effect here.
+          //
+          // We also use this flag to connect/disconnect the effects, but the same
+          // logic applies: when re-connecting, the Offscreen fiber's complete
+          // phase will handle scheduling the effect. It's only when the fallback
+          // is active that we have to do anything special.
+
+
+          if (nextDidTimeout) {
+            const offscreenFiber = workInProgress.child;
+            offscreenFiber.flags |= Visibility;
+          }
+        }
+
+        const retryQueue = workInProgress.updateQueue;
+        scheduleRetryEffect(workInProgress, retryQueue);
+
+        bubbleProperties(workInProgress);
+
+        return null;
+      }
+
+    case HostPortal:
+      popHostContainer();
+
+      if (current === null) {
+        preparePortalMount(workInProgress.stateNode.containerInfo);
+      }
+
+      bubbleProperties(workInProgress);
+      return null;
+
+    case ContextProvider:
+      // Pop provider fiber
+      const context = workInProgress.type._context;
+      popProvider(context);
+      bubbleProperties(workInProgress);
+      return null;
+
+    case IncompleteClassComponent:
+      {
+        // Same as class component case. I put it down here so that the tags are
+        // sequential to ensure this switch is compiled to a jump table.
+        const Component = workInProgress.type;
+
+        if (isContextProvider(Component)) {
+          popContext();
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
+
+    case SuspenseListComponent:
+      {
+        popSuspenseListContext();
+        const renderState = workInProgress.memoizedState;
+
+        if (renderState === null) {
+          // We're running in the default, "independent" mode.
+          // We don't do anything in this mode.
+          bubbleProperties(workInProgress);
+          return null;
+        }
+
+        let didSuspendAlready = (workInProgress.flags & DidCapture) !== NoFlags$1;
+        const renderedTail = renderState.rendering;
+
+        if (renderedTail === null) {
+          // We just rendered the head.
+          if (!didSuspendAlready) {
+            // This is the first pass. We need to figure out if anything is still
+            // suspended in the rendered set.
+            // If new content unsuspended, but there's still some content that
+            // didn't. Then we need to do a second pass that forces everything
+            // to keep showing their fallbacks.
+            // We might be suspended if something in this render pass suspended, or
+            // something in the previous committed pass suspended. Otherwise,
+            // there's no chance so we can skip the expensive call to
+            // findFirstSuspended.
+            const cannotBeSuspended = renderHasNotSuspendedYet() && (current === null || (current.flags & DidCapture) === NoFlags$1);
+
+            if (!cannotBeSuspended) {
+              let row = workInProgress.child;
+
+              while (row !== null) {
+                const suspended = findFirstSuspended(row);
+
+                if (suspended !== null) {
+                  didSuspendAlready = true;
+                  workInProgress.flags |= DidCapture;
+                  cutOffTailIfNeeded(renderState, false); // If this is a newly suspended tree, it might not get committed as
+                  // part of the second pass. In that case nothing will subscribe to
+                  // its thenables. Instead, we'll transfer its thenables to the
+                  // SuspenseList so that it can retry if they resolve.
+                  // There might be multiple of these in the list but since we're
+                  // going to wait for all of them anyway, it doesn't really matter
+                  // which ones gets to ping. In theory we could get clever and keep
+                  // track of how many dependencies remain but it gets tricky because
+                  // in the meantime, we can add/remove/change items and dependencies.
+                  // We might bail out of the loop before finding any but that
+                  // doesn't matter since that means that the other boundaries that
+                  // we did find already has their listeners attached.
+
+                  const retryQueue = suspended.updateQueue;
+                  workInProgress.updateQueue = retryQueue;
+                  scheduleRetryEffect(workInProgress, retryQueue); // Rerender the whole list, but this time, we'll force fallbacks
+                  // to stay in place.
+                  // Reset the effect flags before doing the second pass since that's now invalid.
+                  // Reset the child fibers to their original state.
+
+                  workInProgress.subtreeFlags = NoFlags$1;
+                  resetChildFibers(workInProgress, renderLanes); // Set up the Suspense List Context to force suspense and
+                  // immediately rerender the children.
+
+                  pushSuspenseListContext(workInProgress, setShallowSuspenseListContext(suspenseStackCursor.current, ForceSuspenseFallback)); // Don't bubble properties in this case.
+
+                  return workInProgress.child;
+                }
+
+                row = row.sibling;
+              }
+            }
+
+            if (renderState.tail !== null && now() > getRenderTargetTime()) {
+              // We have already passed our CPU deadline but we still have rows
+              // left in the tail. We'll just give up further attempts to render
+              // the main content and only render fallbacks.
+              workInProgress.flags |= DidCapture;
+              didSuspendAlready = true;
+              cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
+              // to get it started back up to attempt the next item. While in terms
+              // of priority this work has the same priority as this current render,
+              // it's not part of the same transition once the transition has
+              // committed. If it's sync, we still want to yield so that it can be
+              // painted. Conceptually, this is really the same as pinging.
+              // We can use any RetryLane even if it's the one currently rendering
+              // since we're leaving it behind on this node.
+
+              workInProgress.lanes = SomeRetryLane;
+            }
+          } else {
+            cutOffTailIfNeeded(renderState, false);
+          } // Next we're going to render the tail.
+
+        } else {
+          // Append the rendered row to the child list.
+          if (!didSuspendAlready) {
+            const suspended = findFirstSuspended(renderedTail);
+
+            if (suspended !== null) {
+              workInProgress.flags |= DidCapture;
+              didSuspendAlready = true; // Ensure we transfer the update queue to the parent so that it doesn't
+              // get lost if this row ends up dropped during a second pass.
+
+              const retryQueue = suspended.updateQueue;
+              workInProgress.updateQueue = retryQueue;
+              scheduleRetryEffect(workInProgress, retryQueue);
+              cutOffTailIfNeeded(renderState, true); // This might have been modified.
+
+              if (renderState.tail === null && renderState.tailMode === 'hidden' && !renderedTail.alternate && !getIsHydrating() // We don't cut it if we're hydrating.
+              ) {
+                  // We're done.
+                  bubbleProperties(workInProgress);
+                  return null;
+                }
+            } else if ( // The time it took to render last row is greater than the remaining
+            // time we have to render. So rendering one more row would likely
+            // exceed it.
+            now() * 2 - renderState.renderingStartTime > getRenderTargetTime() && renderLanes !== OffscreenLane) {
+              // We have now passed our CPU deadline and we'll just give up further
+              // attempts to render the main content and only render fallbacks.
+              // The assumption is that this is usually faster.
+              workInProgress.flags |= DidCapture;
+              didSuspendAlready = true;
+              cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
+              // to get it started back up to attempt the next item. While in terms
+              // of priority this work has the same priority as this current render,
+              // it's not part of the same transition once the transition has
+              // committed. If it's sync, we still want to yield so that it can be
+              // painted. Conceptually, this is really the same as pinging.
+              // We can use any RetryLane even if it's the one currently rendering
+              // since we're leaving it behind on this node.
+
+              workInProgress.lanes = SomeRetryLane;
+            }
+          }
+
+          if (renderState.isBackwards) {
+            // The effect list of the backwards tail will have been added
+            // to the end. This breaks the guarantee that life-cycles fire in
+            // sibling order but that isn't a strong guarantee promised by React.
+            // Especially since these might also just pop in during future commits.
+            // Append to the beginning of the list.
+            renderedTail.sibling = workInProgress.child;
+            workInProgress.child = renderedTail;
+          } else {
+            const previousSibling = renderState.last;
+
+            if (previousSibling !== null) {
+              previousSibling.sibling = renderedTail;
+            } else {
+              workInProgress.child = renderedTail;
+            }
+
+            renderState.last = renderedTail;
+          }
+        }
+
+        if (renderState.tail !== null) {
+          // We still have tail rows to render.
+          // Pop a row.
+          const next = renderState.tail;
+          renderState.rendering = next;
+          renderState.tail = next.sibling;
+          renderState.renderingStartTime = now();
+          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.
+
+          let suspenseContext = suspenseStackCursor.current;
+
+          if (didSuspendAlready) {
+            suspenseContext = setShallowSuspenseListContext(suspenseContext, ForceSuspenseFallback);
+          } else {
+            suspenseContext = setDefaultShallowSuspenseListContext(suspenseContext);
+          }
+
+          pushSuspenseListContext(workInProgress, suspenseContext); // Do a pass over the next row.
+          // Don't bubble properties in this case.
+
+          return next;
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
+
+    case ScopeComponent:
+      {
+
+        break;
+      }
+
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      {
+        popSuspenseHandler(workInProgress);
+        popHiddenContext();
+        const nextState = workInProgress.memoizedState;
+        const nextIsHidden = nextState !== null; // Schedule a Visibility effect if the visibility has changed
+
+        {
+          if (current !== null) {
+            const prevState = current.memoizedState;
+            const prevIsHidden = prevState !== null;
+
+            if (prevIsHidden !== nextIsHidden) {
+              workInProgress.flags |= Visibility;
+            }
+          } else {
+            // On initial mount, we only need a Visibility effect if the tree
+            // is hidden.
+            if (nextIsHidden) {
+              workInProgress.flags |= Visibility;
+            }
+          }
+        }
+
+        if (!nextIsHidden || (workInProgress.mode & ConcurrentMode) === NoMode) {
+          bubbleProperties(workInProgress);
+        } else {
+          // Don't bubble properties for hidden children unless we're rendering
+          // at offscreen priority.
+          if (includesSomeLane(renderLanes, OffscreenLane) && // Also don't bubble if the tree suspended
+          (workInProgress.flags & DidCapture) === NoLanes) {
+            bubbleProperties(workInProgress); // Check if there was an insertion or update in the hidden subtree.
+            // If so, we need to hide those nodes in the commit phase, so
+            // schedule a visibility effect.
+
+            if (workInProgress.subtreeFlags & (Placement | Update)) {
+              workInProgress.flags |= Visibility;
+            }
+          }
+        }
+
+        const offscreenQueue = workInProgress.updateQueue;
+
+        if (offscreenQueue !== null) {
+          const retryQueue = offscreenQueue.retryQueue;
+          scheduleRetryEffect(workInProgress, retryQueue);
+        }
+
+        {
+          let previousCache = null;
+
+          if (current !== null && current.memoizedState !== null && current.memoizedState.cachePool !== null) {
+            previousCache = current.memoizedState.cachePool.pool;
+          }
+
+          let cache = null;
+
+          if (workInProgress.memoizedState !== null && workInProgress.memoizedState.cachePool !== null) {
+            cache = workInProgress.memoizedState.cachePool.pool;
+          }
+
+          if (cache !== previousCache) {
+            // Run passive effects to retain/release the cache.
+            workInProgress.flags |= Passive$1;
+          }
+        }
+
+        popTransition(workInProgress, current);
+        return null;
+      }
+
+    case CacheComponent:
+      {
+        {
+          let previousCache = null;
+
+          if (current !== null) {
+            previousCache = current.memoizedState.cache;
+          }
+
+          const cache = workInProgress.memoizedState.cache;
+
+          if (cache !== previousCache) {
+            // Run passive effects to retain/release the cache.
+            workInProgress.flags |= Passive$1;
+          }
+
+          popCacheProvider();
+          bubbleProperties(workInProgress);
+        }
+
+        return null;
+      }
+
+    case TracingMarkerComponent:
+      {
+
+        return null;
+      }
+  }
+
+  throw Error(formatProdErrorMessage(156, workInProgress.tag));
+}
+
+function unwindWork(current, workInProgress, renderLanes) {
+  // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
+  popTreeContext(workInProgress);
+
+  switch (workInProgress.tag) {
+    case ClassComponent:
+      {
+        const Component = workInProgress.type;
+
+        if (isContextProvider(Component)) {
+          popContext();
+        }
+
+        const flags = workInProgress.flags;
+
+        if (flags & ShouldCapture) {
+          workInProgress.flags = flags & ~ShouldCapture | DidCapture;
+
+          return workInProgress;
+        }
+
+        return null;
+      }
+
+    case HostRoot:
+      {
+
+        {
+          popCacheProvider();
+        }
+        popHostContainer();
+        popTopLevelContextObject();
+        const flags = workInProgress.flags;
+
+        if ((flags & ShouldCapture) !== NoFlags$1 && (flags & DidCapture) === NoFlags$1) {
+          // There was an error during render that wasn't captured by a suspense
+          // boundary. Do a second pass on the root to unmount the children.
+          workInProgress.flags = flags & ~ShouldCapture | DidCapture;
+          return workInProgress;
+        } // We unwound to the root without completing it. Exit.
+
+
+        return null;
+      }
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      {
+        // TODO: popHydrationState
+        popHostContext(workInProgress);
+        return null;
+      }
+
+    case SuspenseComponent:
+      {
+        popSuspenseHandler(workInProgress);
+        const suspenseState = workInProgress.memoizedState;
+
+        if (suspenseState !== null && suspenseState.dehydrated !== null) {
+          if (workInProgress.alternate === null) {
+            throw Error(formatProdErrorMessage(340));
+          }
+
+          resetHydrationState();
+        }
+
+        const flags = workInProgress.flags;
+
+        if (flags & ShouldCapture) {
+          workInProgress.flags = flags & ~ShouldCapture | DidCapture; // Captured a suspense effect. Re-render the boundary.
+
+          return workInProgress;
+        }
+
+        return null;
+      }
+
+    case SuspenseListComponent:
+      {
+        popSuspenseListContext(); // SuspenseList doesn't actually catch anything. It should've been
+        // caught by a nested boundary. If not, it should bubble through.
+
+        return null;
+      }
+
+    case HostPortal:
+      popHostContainer();
+      return null;
+
+    case ContextProvider:
+      const context = workInProgress.type._context;
+      popProvider(context);
+      return null;
+
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      {
+        popSuspenseHandler(workInProgress);
+        popHiddenContext();
+        popTransition(workInProgress, current);
+        const flags = workInProgress.flags;
+
+        if (flags & ShouldCapture) {
+          workInProgress.flags = flags & ~ShouldCapture | DidCapture; // Captured a suspense effect. Re-render the boundary.
+
+          return workInProgress;
+        }
+
+        return null;
+      }
+
+    case CacheComponent:
+      {
+        popCacheProvider();
+      }
+
+      return null;
+
+    case TracingMarkerComponent:
+
+      return null;
+
+    default:
+      return null;
+  }
+}
+
+function unwindInterruptedWork(current, interruptedWork, renderLanes) {
+  // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
+  popTreeContext(interruptedWork);
+
+  switch (interruptedWork.tag) {
+    case ClassComponent:
+      {
+        const childContextTypes = interruptedWork.type.childContextTypes;
+
+        if (childContextTypes !== null && childContextTypes !== undefined) {
+          popContext();
+        }
+
+        break;
+      }
+
+    case HostRoot:
+      {
+
+        {
+          popCacheProvider();
+        }
+        popHostContainer();
+        popTopLevelContextObject();
+        break;
+      }
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      {
+        popHostContext(interruptedWork);
+        break;
+      }
+
+    case HostPortal:
+      popHostContainer();
+      break;
+
+    case SuspenseComponent:
+      popSuspenseHandler(interruptedWork);
+      break;
+
+    case SuspenseListComponent:
+      popSuspenseListContext();
+      break;
+
+    case ContextProvider:
+      const context = interruptedWork.type._context;
+      popProvider(context);
+      break;
+
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      popSuspenseHandler(interruptedWork);
+      popHiddenContext();
+      popTransition(interruptedWork, current);
+      break;
+
+    case CacheComponent:
+      {
+        popCacheProvider();
+      }
+
+      break;
+  }
+}
+
+function invokeGuardedCallbackImpl(name, func, context) {
+  {
+    // $FlowFixMe[method-unbinding]
+    const funcArgs = Array.prototype.slice.call(arguments, 3);
+
+    try {
+      // $FlowFixMe[incompatible-call] Flow doesn't understand the arguments splicing.
+      func.apply(context, funcArgs);
+    } catch (error) {
+      this.onError(error);
+    }
+  }
+}
+
+let hasError = false;
+let caughtError = null; // Used by event system to capture/rethrow the first error.
+
+let hasRethrowError = false;
+let rethrowError = null;
+const reporter = {
+  onError(error) {
+    hasError = true;
+    caughtError = error;
+  }
+
+};
+/**
+ * Call a function while guarding against errors that happens within it.
+ * Returns an error if it throws, otherwise null.
+ *
+ * In production, this is implemented using a try-catch. The reason we don't
+ * use a try-catch directly is so that we can swap out a different
+ * implementation in DEV mode.
+ *
+ * @param {String} name of the guard to use for logging or debugging
+ * @param {Function} func The function to invoke
+ * @param {*} context The context to use when calling the function
+ * @param {...*} args Arguments for function
+ */
+
+function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+  hasError = false;
+  caughtError = null;
+  invokeGuardedCallbackImpl.apply(reporter, arguments);
+}
+/**
+ * Same as invokeGuardedCallback, but instead of returning an error, it stores
+ * it in a global so it can be rethrown by `rethrowCaughtError` later.
+ * TODO: See if caughtError and rethrowError can be unified.
+ *
+ * @param {String} name of the guard to use for logging or debugging
+ * @param {Function} func The function to invoke
+ * @param {*} context The context to use when calling the function
+ * @param {...*} args Arguments for function
+ */
+
+function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
+  invokeGuardedCallback.apply(this, arguments);
+
+  if (hasError) {
+    const error = clearCaughtError();
+
+    if (!hasRethrowError) {
+      hasRethrowError = true;
+      rethrowError = error;
+    }
+  }
+}
+/**
+ * During execution of guarded functions we will capture the first error which
+ * we will rethrow to be handled by the top level error handler.
+ */
+
+function rethrowCaughtError() {
+  if (hasRethrowError) {
+    const error = rethrowError;
+    hasRethrowError = false;
+    rethrowError = null;
+    throw error;
+  }
+}
+function clearCaughtError() {
+  if (hasError) {
+    const error = caughtError;
+    hasError = false;
+    caughtError = null;
+    return error;
+  } else {
+    throw Error(formatProdErrorMessage(198));
+  }
+}
+
+// Allows us to avoid traversing the return path to find the nearest Offscreen ancestor.
+
+
+let offscreenSubtreeIsHidden = false;
+let offscreenSubtreeWasHidden = false;
+const PossiblyWeakSet = typeof WeakSet === 'function' ? WeakSet : Set;
+let nextEffect = null; // Used for Profiling builds to track updaters.
+
+function shouldProfile(current) {
+  return enableProfilerTimer   ;
+}
+
+function callComponentWillUnmountWithTimer(current, instance) {
+  instance.props = current.memoizedProps;
+  instance.state = current.memoizedState;
+
+  {
+    instance.componentWillUnmount();
+  }
+} // Capture errors so they don't interrupt unmounting.
+
+
+function safelyCallComponentWillUnmount(current, nearestMountedAncestor, instance) {
+  try {
+    callComponentWillUnmountWithTimer(current, instance);
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+} // Capture errors so they don't interrupt mounting.
+
+
+function safelyAttachRef(current, nearestMountedAncestor) {
+  try {
+    commitAttachRef(current);
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+}
+
+function safelyDetachRef(current, nearestMountedAncestor) {
+  const ref = current.ref;
+  const refCleanup = current.refCleanup;
+
+  if (ref !== null) {
+    if (typeof refCleanup === 'function') {
+      try {
+        if (shouldProfile(current)) ; else {
+          refCleanup();
+        }
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
+      } finally {
+        // `refCleanup` has been called. Nullify all references to it to prevent double invocation.
+        current.refCleanup = null;
+        const finishedWork = current.alternate;
+
+        if (finishedWork != null) {
+          finishedWork.refCleanup = null;
+        }
+      }
+    } else if (typeof ref === 'function') {
+      let retVal;
+
+      try {
+        if (shouldProfile(current)) ; else {
+          retVal = ref(null);
+        }
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
+      }
+    } else {
+      // $FlowFixMe[incompatible-use] unable to narrow type to RefObject
+      ref.current = null;
+    }
+  }
+}
+
+function safelyCallDestroy(current, nearestMountedAncestor, destroy) {
+  try {
+    destroy();
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+}
+let shouldFireAfterActiveInstanceBlur = false;
+function commitBeforeMutationEffects(root, firstChild) {
+  prepareForCommit();
+  nextEffect = firstChild;
+  commitBeforeMutationEffects_begin(); // We no longer need to track the active instance fiber
+
+  const shouldFire = shouldFireAfterActiveInstanceBlur;
+  shouldFireAfterActiveInstanceBlur = false;
+  return shouldFire;
+}
+
+function commitBeforeMutationEffects_begin() {
+  while (nextEffect !== null) {
+    const fiber = nextEffect; // This phase is only used for beforeActiveInstanceBlur.
+
+    const child = fiber.child;
+
+    if ((fiber.subtreeFlags & BeforeMutationMask) !== NoFlags$1 && child !== null) {
+      child.return = fiber;
+      nextEffect = child;
+    } else {
+      commitBeforeMutationEffects_complete();
+    }
+  }
+}
+
+function commitBeforeMutationEffects_complete() {
+  while (nextEffect !== null) {
+    const fiber = nextEffect;
+
+    try {
+      commitBeforeMutationEffectsOnFiber(fiber);
+    } catch (error) {
+      captureCommitPhaseError(fiber, fiber.return, error);
+    }
+    const sibling = fiber.sibling;
+
+    if (sibling !== null) {
+      sibling.return = fiber.return;
+      nextEffect = sibling;
+      return;
+    }
+
+    nextEffect = fiber.return;
+  }
+}
+
+function commitBeforeMutationEffectsOnFiber(finishedWork) {
+  const current = finishedWork.alternate;
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+      {
+        {
+          if ((flags & Update) !== NoFlags$1) {
+            commitUseEffectEventMount(finishedWork);
+          }
+        }
+
+        break;
+      }
+
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        break;
+      }
+
+    case ClassComponent:
+      {
+        if ((flags & Snapshot) !== NoFlags$1) {
+          if (current !== null) {
+            const prevProps = current.memoizedProps;
+            const prevState = current.memoizedState;
+            const instance = finishedWork.stateNode; // We could update instance props and state here,
+
+            const snapshot = instance.getSnapshotBeforeUpdate(finishedWork.elementType === finishedWork.type ? prevProps : resolveDefaultProps(finishedWork.type, prevProps), prevState);
+
+            instance.__reactInternalSnapshotBeforeUpdate = snapshot;
+          }
+        }
+
+        break;
+      }
+
+    case HostRoot:
+      {
+        if ((flags & Snapshot) !== NoFlags$1) {
+          {
+            const root = finishedWork.stateNode;
+            clearContainer(root.containerInfo);
+          }
+        }
+
+        break;
+      }
+
+    case HostComponent:
+    case HostHoistable:
+    case HostSingleton:
+    case HostText:
+    case HostPortal:
+    case IncompleteClassComponent:
+      // Nothing to do for these component types
+      break;
+
+    default:
+      {
+        if ((flags & Snapshot) !== NoFlags$1) {
+          throw Error(formatProdErrorMessage(163));
+        }
+      }
+  }
+}
+
+function commitHookEffectListUnmount(flags, finishedWork, nearestMountedAncestor) {
+  const updateQueue = finishedWork.updateQueue;
+  const lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
+
+  if (lastEffect !== null) {
+    const firstEffect = lastEffect.next;
+    let effect = firstEffect;
+
+    do {
+      if ((effect.tag & flags) === flags) {
+        // Unmount
+        const inst = effect.inst;
+        const destroy = inst.destroy;
+
+        if (destroy !== undefined) {
+          inst.destroy = undefined;
+
+          safelyCallDestroy(finishedWork, nearestMountedAncestor, destroy);
+        }
+      }
+
+      effect = effect.next;
+    } while (effect !== firstEffect);
+  }
+}
+
+function commitHookEffectListMount(flags, finishedWork) {
+  const updateQueue = finishedWork.updateQueue;
+  const lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
+
+  if (lastEffect !== null) {
+    const firstEffect = lastEffect.next;
+    let effect = firstEffect;
+
+    do {
+      if ((effect.tag & flags) === flags) {
+
+
+        const create = effect.create;
+
+        const inst = effect.inst;
+        const destroy = create();
+        inst.destroy = destroy;
+      }
+
+      effect = effect.next;
+    } while (effect !== firstEffect);
+  }
+}
+
+function commitUseEffectEventMount(finishedWork) {
+  const updateQueue = finishedWork.updateQueue;
+  const eventPayloads = updateQueue !== null ? updateQueue.events : null;
+
+  if (eventPayloads !== null) {
+    for (let ii = 0; ii < eventPayloads.length; ii++) {
+      const _eventPayloads$ii = eventPayloads[ii],
+            ref = _eventPayloads$ii.ref,
+            nextImpl = _eventPayloads$ii.nextImpl;
+      ref.impl = nextImpl;
+    }
+  }
+}
+
+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.
+  {
+    try {
+      commitHookEffectListMount(hookFlags, finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
+
+function commitClassLayoutLifecycles(finishedWork, current) {
+  const instance = finishedWork.stateNode;
+
+  if (current === null) {
+
+    {
+      try {
+        instance.componentDidMount();
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+  } else {
+    const prevProps = finishedWork.elementType === finishedWork.type ? current.memoizedProps : resolveDefaultProps(finishedWork.type, current.memoizedProps);
+    const prevState = current.memoizedState; // We could update instance props and state here,
+
+    {
+      try {
+        instance.componentDidUpdate(prevProps, prevState, instance.__reactInternalSnapshotBeforeUpdate);
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+  }
+}
+
+function commitClassCallbacks(finishedWork) {
+  // TODO: I think this is now always non-null by the time it reaches the
+  // commit phase. Consider removing the type check.
+  const updateQueue = finishedWork.updateQueue;
+
+  if (updateQueue !== null) {
+    const instance = finishedWork.stateNode;
+    // but instead we rely on them being set during last render.
+    // TODO: revisit this when we implement resuming.
+
+
+    try {
+      commitCallbacks(updateQueue, instance);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
+
+function commitHostComponentMount(finishedWork) {
+  const type = finishedWork.type;
+  const props = finishedWork.memoizedProps;
+  const instance = finishedWork.stateNode;
+
+  try {
+    commitMount(instance, type, props, finishedWork);
+  } catch (error) {
+    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+  }
+}
+
+function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork, committedLanes) {
+  // When updating this function, also update reappearLayoutEffects, which does
+  // most of the same things when an offscreen tree goes from hidden -> visible.
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+        if (flags & Update) {
+          commitHookLayoutEffects(finishedWork, Layout | HasEffect);
+        }
+
+        break;
+      }
+
+    case ClassComponent:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+        if (flags & Update) {
+          commitClassLayoutLifecycles(finishedWork, current);
+        }
+
+        if (flags & Callback) {
+          commitClassCallbacks(finishedWork);
+        }
+
+        if (flags & Ref) {
+          safelyAttachRef(finishedWork, finishedWork.return);
+        }
+
+        break;
+      }
+
+    case HostRoot:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+        if (flags & Callback) {
+          // TODO: I think this is now always non-null by the time it reaches the
+          // commit phase. Consider removing the type check.
+          const updateQueue = finishedWork.updateQueue;
+
+          if (updateQueue !== null) {
+            let instance = null;
+
+            if (finishedWork.child !== null) {
+              switch (finishedWork.child.tag) {
+                case HostSingleton:
+                case HostComponent:
+                  instance = getPublicInstance(finishedWork.child.stateNode);
+                  break;
+
+                case ClassComponent:
+                  instance = finishedWork.child.stateNode;
+                  break;
+              }
+            }
+
+            try {
+              commitCallbacks(updateQueue, instance);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+        }
+
+        break;
+      }
+
+    case HostHoistable:
+      {
+        {
+          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+          if (flags & Ref) {
+            safelyAttachRef(finishedWork, finishedWork.return);
+          }
+
+          break;
+        } // Fall through
+
+      }
+
+    case HostSingleton:
+    case HostComponent:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork); // Renderers may schedule work to be done after host components are mounted
+        // (eg DOM renderer may schedule auto-focus for inputs and form controls).
+        // These effects should only be committed when components are first mounted,
+        // aka when there is no current/alternate.
+
+        if (current === null && flags & Update) {
+          commitHostComponentMount(finishedWork);
+        }
+
+        if (flags & Ref) {
+          safelyAttachRef(finishedWork, finishedWork.return);
+        }
+
+        break;
+      }
+
+    case Profiler:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork); // TODO: Should this fire inside an offscreen tree? Or should it wait to
+
+        break;
+      }
+
+    case SuspenseComponent:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+        if (flags & Update) {
+          commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
+        }
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const isModernRoot = (finishedWork.mode & ConcurrentMode) !== NoMode;
+
+        if (isModernRoot) {
+          const isHidden = finishedWork.memoizedState !== null;
+          const newOffscreenSubtreeIsHidden = isHidden || offscreenSubtreeIsHidden;
+
+          if (newOffscreenSubtreeIsHidden) ; else {
+            // The Offscreen tree is visible.
+            const wasHidden = current !== null && current.memoizedState !== null;
+            const newOffscreenSubtreeWasHidden = wasHidden || offscreenSubtreeWasHidden;
+            const prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
+            const prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+            offscreenSubtreeIsHidden = newOffscreenSubtreeIsHidden;
+            offscreenSubtreeWasHidden = newOffscreenSubtreeWasHidden;
+
+            if (offscreenSubtreeWasHidden && !prevOffscreenSubtreeWasHidden) {
+              // This is the root of a reappearing boundary. As we continue
+              // traversing the layout effects, we must also re-mount layout
+              // effects that were unmounted when the Offscreen subtree was
+              // hidden. So this is a superset of the normal commitLayoutEffects.
+              const includeWorkInProgressEffects = (finishedWork.subtreeFlags & LayoutMask) !== NoFlags$1;
+              recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+            } else {
+              recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+            }
+
+            offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+            offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+          }
+        } else {
+          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        }
+
+        if (flags & Ref) {
+          const props = finishedWork.memoizedProps;
+
+          if (props.mode === 'manual') {
+            safelyAttachRef(finishedWork, finishedWork.return);
+          } else {
+            safelyDetachRef(finishedWork, finishedWork.return);
+          }
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        break;
+      }
+  }
+}
+
+function hideOrUnhideAllChildren(finishedWork, isHidden) {
+  // Only hide or unhide the top-most host nodes.
+  let hostSubtreeRoot = null;
+
+  {
+    // We only have the top Fiber that was inserted but we need to recurse down its
+    // children to find all the terminal nodes.
+    let node = finishedWork;
+
+    while (true) {
+      if (node.tag === HostComponent || (node.tag === HostHoistable ) || (node.tag === HostSingleton )) {
+        if (hostSubtreeRoot === null) {
+          hostSubtreeRoot = node;
+
+          try {
+            const instance = node.stateNode;
+
+            if (isHidden) {
+              hideInstance(instance);
+            } else {
+              unhideInstance(node.stateNode, node.memoizedProps);
+            }
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      } else if (node.tag === HostText) {
+        if (hostSubtreeRoot === null) {
+          try {
+            const instance = node.stateNode;
+
+            if (isHidden) {
+              hideTextInstance(instance);
+            } else {
+              unhideTextInstance(instance, node.memoizedProps);
+            }
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      } else if ((node.tag === OffscreenComponent || node.tag === LegacyHiddenComponent) && node.memoizedState !== null && node !== finishedWork) ; else if (node.child !== null) {
+        node.child.return = node;
+        node = node.child;
+        continue;
+      }
+
+      if (node === finishedWork) {
+        return;
+      }
+
+      while (node.sibling === null) {
+        if (node.return === null || node.return === finishedWork) {
+          return;
+        }
+
+        if (hostSubtreeRoot === node) {
+          hostSubtreeRoot = null;
+        }
+
+        node = node.return;
+      }
+
+      if (hostSubtreeRoot === node) {
+        hostSubtreeRoot = null;
+      }
+
+      node.sibling.return = node.return;
+      node = node.sibling;
+    }
+  }
+}
+
+function commitAttachRef(finishedWork) {
+  const ref = finishedWork.ref;
+
+  if (ref !== null) {
+    const instance = finishedWork.stateNode;
+    let instanceToUse;
+
+    switch (finishedWork.tag) {
+      case HostHoistable:
+      case HostSingleton:
+      case HostComponent:
+        instanceToUse = getPublicInstance(instance);
+        break;
+
+      default:
+        instanceToUse = instance;
+    } // Moved outside to ensure DCE works with this flag
+
+    if (typeof ref === 'function') {
+      {
+        finishedWork.refCleanup = ref(instanceToUse);
+      }
+    } else {
+
+
+      ref.current = instanceToUse;
+    }
+  }
+}
+
+function detachFiberMutation(fiber) {
+  // Cut off the return pointer to disconnect it from the tree.
+  // This enables us to detect and warn against state updates on an unmounted component.
+  // It also prevents events from bubbling from within disconnected components.
+  //
+  // Ideally, we should also clear the child pointer of the parent alternate to let this
+  // get GC:ed but we don't know which for sure which parent is the current
+  // one so we'll settle for GC:ing the subtree of this child.
+  // This child itself will be GC:ed when the parent updates the next time.
+  //
+  // Note that we can't clear child or sibling pointers yet.
+  // They're needed for passive effects and for findDOMNode.
+  // We defer those fields, and all other cleanup, to the passive phase (see detachFiberAfterEffects).
+  //
+  // Don't reset the alternate yet, either. We need that so we can detach the
+  // alternate's fields in the passive phase. Clearing the return pointer is
+  // sufficient for findDOMNode semantics.
+  const alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    alternate.return = null;
+  }
+
+  fiber.return = null;
+}
+
+function detachFiberAfterEffects(fiber) {
+  const alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    fiber.alternate = null;
+    detachFiberAfterEffects(alternate);
+  } // Clear cyclical Fiber fields. This level alone is designed to roughly
+  // approximate the planned Fiber refactor. In that world, `setState` will be
+  // bound to a special "instance" object instead of a Fiber. The Instance
+  // object will not have any of these fields. It will only be connected to
+  // the fiber tree via a single link at the root. So if this level alone is
+  // sufficient to fix memory issues, that bodes well for our plans.
+
+
+  fiber.child = null;
+  fiber.deletions = null;
+  fiber.sibling = null; // The `stateNode` is cyclical because on host nodes it points to the host
+  // tree, which has its own pointers to children, parents, and siblings.
+  // The other host nodes also point back to fibers, so we should detach that
+  // one, too.
+
+  if (fiber.tag === HostComponent) {
+    const hostInstance = fiber.stateNode;
+
+    if (hostInstance !== null) {
+      detachDeletedInstance(hostInstance);
+    }
+  }
+
+  fiber.stateNode = null;
+  // disconnected the fiber from the tree. So even if something leaks this
+  // particular fiber, it won't leak anything else.
+
+
+  fiber.return = null;
+  fiber.dependencies = null;
+  fiber.memoizedProps = null;
+  fiber.memoizedState = null;
+  fiber.pendingProps = null;
+  fiber.stateNode = null; // TODO: Move to `commitPassiveUnmountInsideDeletedTreeOnFiber` instead.
+
+  fiber.updateQueue = null;
+}
+
+function getHostParentFiber(fiber) {
+  let parent = fiber.return;
+
+  while (parent !== null) {
+    if (isHostParent(parent)) {
+      return parent;
+    }
+
+    parent = parent.return;
+  }
+
+  throw Error(formatProdErrorMessage(160));
+}
+
+function isHostParent(fiber) {
+  return fiber.tag === HostComponent || fiber.tag === HostRoot || (fiber.tag === HostHoistable ) || (fiber.tag === HostSingleton ) || fiber.tag === HostPortal;
+}
+
+function getHostSibling(fiber) {
+  // We're going to search forward into the tree until we find a sibling host
+  // node. Unfortunately, if multiple insertions are done in a row we have to
+  // search past them. This leads to exponential search for the next sibling.
+  // TODO: Find a more efficient way to do this.
+  let node = fiber;
+
+  siblings: while (true) {
+    // If we didn't find anything, let's try the next sibling.
+    while (node.sibling === null) {
+      if (node.return === null || isHostParent(node.return)) {
+        // If we pop out of the root or hit the parent the fiber we are the
+        // last sibling.
+        return null;
+      } // $FlowFixMe[incompatible-type] found when upgrading Flow
+
+
+      node = node.return;
+    }
+
+    node.sibling.return = node.return;
+    node = node.sibling;
+
+    while (node.tag !== HostComponent && node.tag !== HostText && (node.tag !== HostSingleton) && node.tag !== DehydratedFragment) {
+      // If it is not host node and, we might have a host node inside it.
+      // Try to search down until we find one.
+      if (node.flags & Placement) {
+        // If we don't have a child, try the siblings instead.
+        continue siblings;
+      } // If we don't have a child, try the siblings instead.
+      // We also skip portals because they are not part of this host tree.
+
+
+      if (node.child === null || node.tag === HostPortal) {
+        continue siblings;
+      } else {
+        node.child.return = node;
+        node = node.child;
+      }
+    } // Check if this host node is stable or about to be placed.
+
+
+    if (!(node.flags & Placement)) {
+      // Found it!
+      return node.stateNode;
+    }
+  }
+}
+
+function commitPlacement(finishedWork) {
+
+  {
+    if (finishedWork.tag === HostSingleton) {
+      // Singletons are already in the Host and don't need to be placed
+      // Since they operate somewhat like Portals though their children will
+      // have Placement and will get placed inside them
+      return;
+    }
+  } // Recursively insert all host nodes into the parent.
+
+
+  const parentFiber = getHostParentFiber(finishedWork);
+
+  switch (parentFiber.tag) {
+    case HostSingleton:
+      {
+        {
+          const parent = parentFiber.stateNode;
+          const before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
+          // children to find all the terminal nodes.
+
+          insertOrAppendPlacementNode(finishedWork, before, parent);
+          break;
+        } // Fall through
+
+      }
+
+    case HostComponent:
+      {
+        const parent = parentFiber.stateNode;
+
+        if (parentFiber.flags & ContentReset) {
+          // Reset the text content of the parent before doing any insertions
+          resetTextContent(parent); // Clear ContentReset from the effect tag
+
+          parentFiber.flags &= ~ContentReset;
+        }
+
+        const before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
+        // children to find all the terminal nodes.
+
+        insertOrAppendPlacementNode(finishedWork, before, parent);
+        break;
+      }
+
+    case HostRoot:
+    case HostPortal:
+      {
+        const parent = parentFiber.stateNode.containerInfo;
+        const before = getHostSibling(finishedWork);
+        insertOrAppendPlacementNodeIntoContainer(finishedWork, before, parent);
+        break;
+      }
+
+    default:
+      throw Error(formatProdErrorMessage(161));
+  }
+}
+
+function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
+  const tag = node.tag;
+  const isHost = tag === HostComponent || tag === HostText;
+
+  if (isHost) {
+    const stateNode = node.stateNode;
+
+    if (before) {
+      insertInContainerBefore(parent, stateNode, before);
+    } else {
+      appendChildToContainer(parent, stateNode);
+    }
+  } else if (tag === HostPortal || (tag === HostSingleton )) ; else {
+    const child = node.child;
+
+    if (child !== null) {
+      insertOrAppendPlacementNodeIntoContainer(child, before, parent);
+      let sibling = child.sibling;
+
+      while (sibling !== null) {
+        insertOrAppendPlacementNodeIntoContainer(sibling, before, parent);
+        sibling = sibling.sibling;
+      }
+    }
+  }
+}
+
+function insertOrAppendPlacementNode(node, before, parent) {
+  const tag = node.tag;
+  const isHost = tag === HostComponent || tag === HostText;
+
+  if (isHost) {
+    const stateNode = node.stateNode;
+
+    if (before) {
+      insertBefore(parent, stateNode, before);
+    } else {
+      appendChild(parent, stateNode);
+    }
+  } else if (tag === HostPortal || (tag === HostSingleton )) ; else {
+    const child = node.child;
+
+    if (child !== null) {
+      insertOrAppendPlacementNode(child, before, parent);
+      let sibling = child.sibling;
+
+      while (sibling !== null) {
+        insertOrAppendPlacementNode(sibling, before, parent);
+        sibling = sibling.sibling;
+      }
+    }
+  }
+} // These are tracked on the stack as we recursively traverse a
+// deleted subtree.
+// TODO: Update these during the whole mutation phase, not just during
+// a deletion.
+
+
+let hostParent = null;
+let hostParentIsContainer = false;
+
+function commitDeletionEffects(root, returnFiber, deletedFiber) {
+  {
+    // We only have the top Fiber that was deleted but we need to recurse down its
+    // children to find all the terminal nodes.
+    // Recursively delete all host nodes from the parent, detach refs, clean
+    // up mounted layout effects, and call componentWillUnmount.
+    // We only need to remove the topmost host child in each branch. But then we
+    // still need to keep traversing to unmount effects, refs, and cWU. TODO: We
+    // could split this into two separate traversals functions, where the second
+    // one doesn't include any removeChild logic. This is maybe the same
+    // function as "disappearLayoutEffects" (or whatever that turns into after
+    // the layout phase is refactored to use recursion).
+    // Before starting, find the nearest host parent on the stack so we know
+    // which instance/container to remove the children from.
+    // TODO: Instead of searching up the fiber return path on every deletion, we
+    // can track the nearest host component on the JS stack as we traverse the
+    // tree during the commit phase. This would make insertions faster, too.
+    let parent = returnFiber;
+
+    findParent: while (parent !== null) {
+      switch (parent.tag) {
+        case HostSingleton:
+        case HostComponent:
+          {
+            hostParent = parent.stateNode;
+            hostParentIsContainer = false;
+            break findParent;
+          }
+
+        case HostRoot:
+          {
+            hostParent = parent.stateNode.containerInfo;
+            hostParentIsContainer = true;
+            break findParent;
+          }
+
+        case HostPortal:
+          {
+            hostParent = parent.stateNode.containerInfo;
+            hostParentIsContainer = true;
+            break findParent;
+          }
+      }
+
+      parent = parent.return;
+    }
+
+    if (hostParent === null) {
+      throw Error(formatProdErrorMessage(160));
+    }
+
+    commitDeletionEffectsOnFiber(root, returnFiber, deletedFiber);
+    hostParent = null;
+    hostParentIsContainer = false;
+  }
+
+  detachFiberMutation(deletedFiber);
+}
+
+function recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, parent) {
+  // TODO: Use a static flag to skip trees that don't have unmount effects
+  let child = parent.child;
+
+  while (child !== null) {
+    commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, child);
+    child = child.sibling;
+  }
+}
+
+function commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, deletedFiber) {
+  onCommitUnmount(deletedFiber); // The cases in this outer switch modify the stack before they traverse
+  // into their subtree. There are simpler cases in the inner switch
+  // that don't modify the stack.
+
+  switch (deletedFiber.tag) {
+    case HostHoistable:
+      {
+        {
+          if (!offscreenSubtreeWasHidden) {
+            safelyDetachRef(deletedFiber, nearestMountedAncestor);
+          }
+
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+
+          if (deletedFiber.memoizedState) {
+            releaseResource(deletedFiber.memoizedState);
+          } else if (deletedFiber.stateNode) {
+            unmountHoistable(deletedFiber.stateNode);
+          }
+
+          return;
+        } // Fall through
+
+      }
+
+    case HostSingleton:
+      {
+        {
+          if (!offscreenSubtreeWasHidden) {
+            safelyDetachRef(deletedFiber, nearestMountedAncestor);
+          }
+
+          const prevHostParent = hostParent;
+          const prevHostParentIsContainer = hostParentIsContainer;
+          hostParent = deletedFiber.stateNode;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber); // Normally this is called in passive unmount effect phase however with
+          // HostSingleton we warn if you acquire one that is already associated to
+          // a different fiber. To increase our chances of avoiding this, specifically
+          // if you keyed a HostSingleton so there will be a delete followed by a Placement
+          // we treat detach eagerly here
+
+          releaseSingletonInstance(deletedFiber.stateNode);
+          hostParent = prevHostParent;
+          hostParentIsContainer = prevHostParentIsContainer;
+          return;
+        } // Fall through
+
+      }
+
+    case HostComponent:
+      {
+        if (!offscreenSubtreeWasHidden) {
+          safelyDetachRef(deletedFiber, nearestMountedAncestor);
+        } // Intentional fallthrough to next branch
+
+      }
+
+    case HostText:
+      {
+        // We only need to remove the nearest host child. Set the host parent
+        // to `null` on the stack to indicate that nested children don't
+        // need to be removed.
+        {
+          const prevHostParent = hostParent;
+          const prevHostParentIsContainer = hostParentIsContainer;
+          hostParent = null;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          hostParent = prevHostParent;
+          hostParentIsContainer = prevHostParentIsContainer;
+
+          if (hostParent !== null) {
+            // Now that all the child effects have unmounted, we can remove the
+            // node from the tree.
+            if (hostParentIsContainer) {
+              removeChildFromContainer(hostParent, deletedFiber.stateNode);
+            } else {
+              removeChild(hostParent, deletedFiber.stateNode);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case DehydratedFragment:
+      {
+        // Delete the dehydrated suspense boundary and all of its content.
+
+
+        {
+          if (hostParent !== null) {
+            if (hostParentIsContainer) {
+              clearSuspenseBoundaryFromContainer(hostParent, deletedFiber.stateNode);
+            } else {
+              clearSuspenseBoundary(hostParent, deletedFiber.stateNode);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case HostPortal:
+      {
+        {
+          // When we go into a portal, it becomes the parent to remove from.
+          const prevHostParent = hostParent;
+          const prevHostParentIsContainer = hostParentIsContainer;
+          hostParent = deletedFiber.stateNode.containerInfo;
+          hostParentIsContainer = true;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          hostParent = prevHostParent;
+          hostParentIsContainer = prevHostParentIsContainer;
+        }
+
+        return;
+      }
+
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent:
+      {
+        if (!offscreenSubtreeWasHidden) {
+          const updateQueue = deletedFiber.updateQueue;
+
+          if (updateQueue !== null) {
+            const lastEffect = updateQueue.lastEffect;
+
+            if (lastEffect !== null) {
+              const firstEffect = lastEffect.next;
+              let effect = firstEffect;
+
+              do {
+                const tag = effect.tag;
+                const inst = effect.inst;
+                const destroy = inst.destroy;
+
+                if (destroy !== undefined) {
+                  if ((tag & Insertion) !== NoFlags) {
+                    inst.destroy = undefined;
+                    safelyCallDestroy(deletedFiber, nearestMountedAncestor, destroy);
+                  } else if ((tag & Layout) !== NoFlags) {
+
+                    {
+                      inst.destroy = undefined;
+                      safelyCallDestroy(deletedFiber, nearestMountedAncestor, destroy);
+                    }
+                  }
+                }
+
+                effect = effect.next;
+              } while (effect !== firstEffect);
+            }
+          }
+        }
+
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        return;
+      }
+
+    case ClassComponent:
+      {
+        if (!offscreenSubtreeWasHidden) {
+          safelyDetachRef(deletedFiber, nearestMountedAncestor);
+          const instance = deletedFiber.stateNode;
+
+          if (typeof instance.componentWillUnmount === 'function') {
+            safelyCallComponentWillUnmount(deletedFiber, nearestMountedAncestor, instance);
+          }
+        }
+
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        return;
+      }
+
+    case ScopeComponent:
+      {
+
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        return;
+      }
+
+    case OffscreenComponent:
+      {
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+
+        if (deletedFiber.mode & ConcurrentMode) {
+          // If this offscreen component is hidden, we already unmounted it. Before
+          // deleting the children, track that it's already unmounted so that we
+          // don't attempt to unmount the effects again.
+          // TODO: If the tree is hidden, in most cases we should be able to skip
+          // over the nested children entirely. An exception is we haven't yet found
+          // the topmost host node to delete, which we already track on the stack.
+          // But the other case is portals, which need to be detached no matter how
+          // deeply they are nested. We should use a subtree flag to track whether a
+          // subtree includes a nested portal.
+          const prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || deletedFiber.memoizedState !== null;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+        } else {
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        return;
+      }
+  }
+}
+
+function commitSuspenseCallback(finishedWork) {
+}
+
+function commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {
+
+  const newState = finishedWork.memoizedState;
+
+  if (newState === null) {
+    const current = finishedWork.alternate;
+
+    if (current !== null) {
+      const prevState = current.memoizedState;
+
+      if (prevState !== null) {
+        const suspenseInstance = prevState.dehydrated;
+
+        if (suspenseInstance !== null) {
+          try {
+            commitHydratedSuspenseInstance(suspenseInstance);
+
+            if (enableSuspenseCallback) ;
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      }
+    }
+  }
+}
+
+function getRetryCache(finishedWork) {
+  // TODO: Unify the interface for the retry cache so we don't have to switch
+  // on the tag like this.
+  switch (finishedWork.tag) {
+    case SuspenseComponent:
+    case SuspenseListComponent:
+      {
+        let retryCache = finishedWork.stateNode;
+
+        if (retryCache === null) {
+          retryCache = finishedWork.stateNode = new PossiblyWeakSet();
+        }
+
+        return retryCache;
+      }
+
+    case OffscreenComponent:
+      {
+        const instance = finishedWork.stateNode;
+        let retryCache = instance._retryCache;
+
+        if (retryCache === null) {
+          retryCache = instance._retryCache = new PossiblyWeakSet();
+        }
+
+        return retryCache;
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(435, finishedWork.tag));
+      }
+  }
+}
+
+function detachOffscreenInstance(instance) {
+  const fiber = instance._current;
+
+  if (fiber === null) {
+    throw Error(formatProdErrorMessage(456));
+  }
+
+  if ((instance._pendingVisibility & OffscreenDetached) !== NoFlags$1) {
+    // The instance is already detached, this is a noop.
+    return;
+  } // TODO: There is an opportunity to optimise this by not entering commit phase
+  // and unmounting effects directly.
+
+
+  const root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+  if (root !== null) {
+    instance._pendingVisibility |= OffscreenDetached;
+    scheduleUpdateOnFiber(root, fiber, SyncLane);
+  }
+}
+function attachOffscreenInstance(instance) {
+  const fiber = instance._current;
+
+  if (fiber === null) {
+    throw Error(formatProdErrorMessage(456));
+  }
+
+  if ((instance._pendingVisibility & OffscreenDetached) === NoFlags$1) {
+    // The instance is already attached, this is a noop.
+    return;
+  }
+
+  const root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+  if (root !== null) {
+    instance._pendingVisibility &= ~OffscreenDetached;
+    scheduleUpdateOnFiber(root, fiber, SyncLane);
+  }
+}
+
+function attachSuspenseRetryListeners(finishedWork, wakeables) {
+  // If this boundary just timed out, then it will have a set of wakeables.
+  // For each wakeable, attach a listener so that when it resolves, React
+  // attempts to re-render the boundary in the primary (pre-timeout) state.
+  const retryCache = getRetryCache(finishedWork);
+  wakeables.forEach(wakeable => {
+    // Memoize using the boundary fiber to prevent redundant listeners.
+    const retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
+
+    if (!retryCache.has(wakeable)) {
+      retryCache.add(wakeable);
+
+      wakeable.then(retry, retry);
+    }
+  });
+} // This function detects when a Suspense boundary goes from visible to hidden.
+function commitMutationEffects(root, finishedWork, committedLanes) {
+  commitMutationEffectsOnFiber(finishedWork, root);
+}
+
+function recursivelyTraverseMutationEffects(root, parentFiber, lanes) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects hae fired.
+  const deletions = parentFiber.deletions;
+
+  if (deletions !== null) {
+    for (let i = 0; i < deletions.length; i++) {
+      const childToDelete = deletions[i];
+
+      try {
+        commitDeletionEffects(root, parentFiber, childToDelete);
+      } catch (error) {
+        captureCommitPhaseError(childToDelete, parentFiber, error);
+      }
+    }
+  }
+
+  if (parentFiber.subtreeFlags & MutationMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      commitMutationEffectsOnFiber(child, root);
+      child = child.sibling;
+    }
+  }
+}
+
+let currentHoistableRoot = null;
+
+function commitMutationEffectsOnFiber(finishedWork, root, lanes) {
+  const current = finishedWork.alternate;
+  const flags = finishedWork.flags; // The effect flag should be checked *after* we refine the type of fiber,
+  // because the fiber tag is more specific. An exception is any flag related
+  // to reconciliation, because those can be set on all fiber types.
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Update) {
+          try {
+            commitHookEffectListUnmount(Insertion | HasEffect, finishedWork, finishedWork.return);
+            commitHookEffectListMount(Insertion | HasEffect, finishedWork);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          } // Layout effects are destroyed during the mutation phase so that all
+          // destroy functions for all fibers are called before any create functions.
+          // This prevents sibling component effects from interfering with each other,
+          // e.g. a destroy function in one component should never override a ref set
+          // by a create function in another component during the same commit.
+
+
+          {
+            try {
+              commitHookEffectListUnmount(Layout | HasEffect, finishedWork, finishedWork.return);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case ClassComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Ref) {
+          if (current !== null) {
+            safelyDetachRef(current, current.return);
+          }
+        }
+
+        if (flags & Callback && offscreenSubtreeIsHidden) {
+          const updateQueue = finishedWork.updateQueue;
+
+          if (updateQueue !== null) {
+            deferHiddenCallbacks(updateQueue);
+          }
+        }
+
+        return;
+      }
+
+    case HostHoistable:
+      {
+        {
+          // We cast because we always set the root at the React root and so it cannot be
+          // null while we are processing mutation effects
+          const hoistableRoot = currentHoistableRoot;
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+
+          if (flags & Ref) {
+            if (current !== null) {
+              safelyDetachRef(current, current.return);
+            }
+          }
+
+          if (flags & Update) {
+            const currentResource = current !== null ? current.memoizedState : null;
+            const newResource = finishedWork.memoizedState;
+
+            if (current === null) {
+              // We are mounting a new HostHoistable Fiber. We fork the mount
+              // behavior based on whether this instance is a Hoistable Instance
+              // or a Hoistable Resource
+              if (newResource === null) {
+                if (finishedWork.stateNode === null) {
+                  finishedWork.stateNode = hydrateHoistable(hoistableRoot, finishedWork.type, finishedWork.memoizedProps, finishedWork);
+                } else {
+                  mountHoistable(hoistableRoot, finishedWork.type, finishedWork.stateNode);
+                }
+              } else {
+                finishedWork.stateNode = acquireResource(hoistableRoot, newResource, finishedWork.memoizedProps);
+              }
+            } else if (currentResource !== newResource) {
+              // We are moving to or from Hoistable Resource, or between different Hoistable Resources
+              if (currentResource === null) {
+                if (current.stateNode !== null) {
+                  unmountHoistable(current.stateNode);
+                }
+              } else {
+                releaseResource(currentResource);
+              }
+
+              if (newResource === null) {
+                mountHoistable(hoistableRoot, finishedWork.type, finishedWork.stateNode);
+              } else {
+                acquireResource(hoistableRoot, newResource, finishedWork.memoizedProps);
+              }
+            } else if (newResource === null && finishedWork.stateNode !== null) {
+              // We may have an update on a Hoistable element
+              const updatePayload = finishedWork.updateQueue;
+              finishedWork.updateQueue = null;
+
+              try {
+                commitUpdate(finishedWork.stateNode, updatePayload, finishedWork.type, current.memoizedProps, finishedWork.memoizedProps, finishedWork);
+              } catch (error) {
+                captureCommitPhaseError(finishedWork, finishedWork.return, error);
+              }
+            }
+          }
+
+          return;
+        } // Fall through
+
+      }
+
+    case HostSingleton:
+      {
+        {
+          if (flags & Update) {
+            const previousWork = finishedWork.alternate;
+
+            if (previousWork === null) {
+              const singleton = finishedWork.stateNode;
+              const props = finishedWork.memoizedProps; // This was a new mount, we need to clear and set initial properties
+
+              clearSingleton(singleton);
+              acquireSingletonInstance(finishedWork.type, props, singleton, finishedWork);
+            }
+          }
+        } // Fall through
+
+      }
+
+    case HostComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Ref) {
+          if (current !== null) {
+            safelyDetachRef(current, current.return);
+          }
+        }
+
+        {
+          // TODO: ContentReset gets cleared by the children during the commit
+          // phase. This is a refactor hazard because it means we must read
+          // flags the flags after `commitReconciliationEffects` has already run;
+          // the order matters. We should refactor so that ContentReset does not
+          // rely on mutating the flag during commit. Like by setting a flag
+          // during the render phase instead.
+          if (finishedWork.flags & ContentReset) {
+            const instance = finishedWork.stateNode;
+
+            try {
+              resetTextContent(instance);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+
+          if (flags & Update) {
+            const instance = finishedWork.stateNode;
+
+            if (instance != null) {
+              // Commit the work prepared earlier.
+              const newProps = finishedWork.memoizedProps; // For hydration we reuse the update path but we treat the oldProps
+              // as the newProps. The updatePayload will contain the real change in
+              // this case.
+
+              const oldProps = current !== null ? current.memoizedProps : newProps;
+              const type = finishedWork.type; // TODO: Type the updateQueue to be specific to host components.
+
+              const updatePayload = finishedWork.updateQueue;
+              finishedWork.updateQueue = null;
+
+              try {
+                commitUpdate(instance, updatePayload, type, oldProps, newProps, finishedWork);
+              } catch (error) {
+                captureCommitPhaseError(finishedWork, finishedWork.return, error);
+              }
+            }
+          }
+        }
+
+        return;
+      }
+
+    case HostText:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Update) {
+          {
+            if (finishedWork.stateNode === null) {
+              throw Error(formatProdErrorMessage(162));
+            }
+
+            const textInstance = finishedWork.stateNode;
+            const newText = finishedWork.memoizedProps; // For hydration we reuse the update path but we treat the oldProps
+            // as the newProps. The updatePayload will contain the real change in
+            // this case.
+
+            const oldText = current !== null ? current.memoizedProps : newText;
+
+            try {
+              commitTextUpdate(textInstance, oldText, newText);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case HostRoot:
+      {
+        {
+          prepareToCommitHoistables();
+          const previousHoistableRoot = currentHoistableRoot;
+          currentHoistableRoot = getHoistableRoot(root.containerInfo);
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          currentHoistableRoot = previousHoistableRoot;
+          commitReconciliationEffects(finishedWork);
+        }
+
+        if (flags & Update) {
+          {
+            if (current !== null) {
+              const prevRootState = current.memoizedState;
+
+              if (prevRootState.isDehydrated) {
+                try {
+                  commitHydratedContainer(root.containerInfo);
+                } catch (error) {
+                  captureCommitPhaseError(finishedWork, finishedWork.return, error);
+                }
+              }
+            }
+          }
+        }
+
+        return;
+      }
+
+    case HostPortal:
+      {
+        {
+          const previousHoistableRoot = currentHoistableRoot;
+          currentHoistableRoot = getHoistableRoot(finishedWork.stateNode.containerInfo);
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          currentHoistableRoot = previousHoistableRoot;
+        }
+
+        return;
+      }
+
+    case SuspenseComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork); // TODO: We should mark a flag on the Suspense fiber itself, rather than
+        // relying on the Offscreen fiber having a flag also being marked. The
+        // reason is that this offscreen fiber might not be part of the work-in-
+        // progress tree! It could have been reused from a previous render. This
+        // doesn't lead to incorrect behavior because we don't rely on the flag
+        // check alone; we also compare the states explicitly below. But for
+        // modeling purposes, we _should_ be able to rely on the flag check alone.
+        // So this is a bit fragile.
+        //
+        // Also, all this logic could/should move to the passive phase so it
+        // doesn't block paint.
+
+        const offscreenFiber = finishedWork.child;
+
+        if (offscreenFiber.flags & Visibility) {
+          // Throttle the appearance and disappearance of Suspense fallbacks.
+          const isShowingFallback = finishedWork.memoizedState !== null;
+          const wasShowingFallback = current !== null && current.memoizedState !== null;
+
+          {
+            if (isShowingFallback !== wasShowingFallback) {
+              // A fallback is either appearing or disappearing.
+              markCommitTimeOfFallback();
+            }
+          }
+        }
+
+        if (flags & Update) {
+          try {
+            commitSuspenseCallback(finishedWork);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+
+          const retryQueue = finishedWork.updateQueue;
+
+          if (retryQueue !== null) {
+            finishedWork.updateQueue = null;
+            attachSuspenseRetryListeners(finishedWork, retryQueue);
+          }
+        }
+
+        return;
+      }
+
+    case OffscreenComponent:
+      {
+        if (flags & Ref) {
+          if (current !== null) {
+            safelyDetachRef(current, current.return);
+          }
+        }
+
+        const newState = finishedWork.memoizedState;
+        const isHidden = newState !== null;
+        const wasHidden = current !== null && current.memoizedState !== null;
+
+        if (finishedWork.mode & ConcurrentMode) {
+          // Before committing the children, track on the stack whether this
+          // offscreen subtree was already hidden, so that we don't unmount the
+          // effects again.
+          const prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
+          const prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden || isHidden;
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || wasHidden;
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+        } else {
+          recursivelyTraverseMutationEffects(root, finishedWork);
+        }
+
+        commitReconciliationEffects(finishedWork);
+        const offscreenInstance = finishedWork.stateNode; // TODO: Add explicit effect flag to set _current.
+
+        offscreenInstance._current = finishedWork; // Offscreen stores pending changes to visibility in `_pendingVisibility`. This is
+        // to support batching of `attach` and `detach` calls.
+
+        offscreenInstance._visibility &= ~OffscreenDetached;
+        offscreenInstance._visibility |= offscreenInstance._pendingVisibility & OffscreenDetached;
+
+        if (flags & Visibility) {
+          // Track the current state on the Offscreen instance so we can
+          // read it during an event
+          if (isHidden) {
+            offscreenInstance._visibility &= ~OffscreenVisible;
+          } else {
+            offscreenInstance._visibility |= OffscreenVisible;
+          }
+
+          if (isHidden) {
+            const isUpdate = current !== null;
+            const wasHiddenByAncestorOffscreen = offscreenSubtreeIsHidden || offscreenSubtreeWasHidden; // Only trigger disapper layout effects if:
+            //   - This is an update, not first mount.
+            //   - This Offscreen was not hidden before.
+            //   - Ancestor Offscreen was not hidden in previous commit.
+
+            if (isUpdate && !wasHidden && !wasHiddenByAncestorOffscreen) {
+              if ((finishedWork.mode & ConcurrentMode) !== NoMode) {
+                // Disappear the layout effects of all the children
+                recursivelyTraverseDisappearLayoutEffects(finishedWork);
+              }
+            }
+          } // Offscreen with manual mode manages visibility manually.
+
+
+          if (!isOffscreenManual(finishedWork)) {
+            // TODO: This needs to run whenever there's an insertion or update
+            // inside a hidden Offscreen tree.
+            hideOrUnhideAllChildren(finishedWork, isHidden);
+          }
+        } // TODO: Move to passive phase
+
+
+        if (flags & Update) {
+          const offscreenQueue = finishedWork.updateQueue;
+
+          if (offscreenQueue !== null) {
+            const retryQueue = offscreenQueue.retryQueue;
+
+            if (retryQueue !== null) {
+              offscreenQueue.retryQueue = null;
+              attachSuspenseRetryListeners(finishedWork, retryQueue);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case SuspenseListComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Update) {
+          const retryQueue = finishedWork.updateQueue;
+
+          if (retryQueue !== null) {
+            finishedWork.updateQueue = null;
+            attachSuspenseRetryListeners(finishedWork, retryQueue);
+          }
+        }
+
+        return;
+      }
+
+    case ScopeComponent:
+      {
+
+        return;
+      }
+
+    default:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        return;
+      }
+  }
+}
+
+function commitReconciliationEffects(finishedWork) {
+  // Placement effects (insertions, reorders) can be scheduled on any fiber
+  // type. They needs to happen after the children effects have fired, but
+  // before the effects on this fiber have fired.
+  const flags = finishedWork.flags;
+
+  if (flags & Placement) {
+    try {
+      commitPlacement(finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    } // Clear the "placement" from effect tag so that we know that this is
+    // inserted, before any life-cycles like componentDidMount gets called.
+    // TODO: findDOMNode doesn't rely on this any more but isMounted does
+    // and isMounted is deprecated anyway so we should be able to kill this.
+
+
+    finishedWork.flags &= ~Placement;
+  }
+
+  if (flags & Hydrating) {
+    finishedWork.flags &= ~Hydrating;
+  }
+}
+
+function commitLayoutEffects(finishedWork, root, committedLanes) {
+  const current = finishedWork.alternate;
+  commitLayoutEffectOnFiber(root, current, finishedWork);
+}
+
+function recursivelyTraverseLayoutEffects(root, parentFiber, lanes) {
+
+  if (parentFiber.subtreeFlags & LayoutMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      const current = child.alternate;
+      commitLayoutEffectOnFiber(root, current, child);
+      child = child.sibling;
+    }
+  }
+}
+
+function disappearLayoutEffects(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent:
+      {
+        // TODO (Offscreen) Check: flags & LayoutStatic
+        {
+          commitHookEffectListUnmount(Layout, finishedWork, finishedWork.return);
+        }
+
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      }
+
+    case ClassComponent:
+      {
+        // TODO (Offscreen) Check: flags & RefStatic
+        safelyDetachRef(finishedWork, finishedWork.return);
+        const instance = finishedWork.stateNode;
+
+        if (typeof instance.componentWillUnmount === 'function') {
+          safelyCallComponentWillUnmount(finishedWork, finishedWork.return, instance);
+        }
+
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      }
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      {
+        // TODO (Offscreen) Check: flags & RefStatic
+        safelyDetachRef(finishedWork, finishedWork.return);
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        // TODO (Offscreen) Check: flags & RefStatic
+        safelyDetachRef(finishedWork, finishedWork.return);
+        const isHidden = finishedWork.memoizedState !== null;
+
+        if (isHidden) ; else {
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
+  // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+  let child = parentFiber.child;
+
+  while (child !== null) {
+    disappearLayoutEffects(child);
+    child = child.sibling;
+  }
+}
+
+function reappearLayoutEffects(finishedRoot, current, finishedWork, // This function visits both newly finished work and nodes that were re-used
+// from a previously committed tree. We cannot check non-static flags if the
+// node was reused.
+includeWorkInProgressEffects) {
+  // Turn on layout effects in a tree that previously disappeared.
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // TODO: Check flags & LayoutStatic
+
+        commitHookLayoutEffects(finishedWork, Layout);
+        break;
+      }
+
+    case ClassComponent:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // TODO: Check for LayoutStatic flag
+
+        const instance = finishedWork.stateNode;
+
+        if (typeof instance.componentDidMount === 'function') {
+          try {
+            instance.componentDidMount();
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        } // Commit any callbacks that would have fired while the component
+        // was hidden.
+
+
+        const updateQueue = finishedWork.updateQueue;
+
+        if (updateQueue !== null) {
+          commitHiddenCallbacks(updateQueue, instance);
+        } // If this is newly finished work, check for setState callbacks
+
+
+        if (includeWorkInProgressEffects && flags & Callback) {
+          commitClassCallbacks(finishedWork);
+        } // TODO: Check flags & RefStatic
+
+
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      }
+    // Unlike commitLayoutEffectsOnFiber, we don't need to handle HostRoot
+    // because this function only visits nodes that are inside an
+    // Offscreen fiber.
+    // case HostRoot: {
+    //  ...
+    // }
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // Renderers may schedule work to be done after host components are mounted
+        // (eg DOM renderer may schedule auto-focus for inputs and form controls).
+        // These effects should only be committed when components are first mounted,
+        // aka when there is no current/alternate.
+
+        if (includeWorkInProgressEffects && current === null && flags & Update) {
+          commitHostComponentMount(finishedWork);
+        } // TODO: Check flags & Ref
+
+
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      }
+
+    case Profiler:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // TODO: Figure out how Profiler updates should work with Offscreen
+
+        break;
+      }
+
+    case SuspenseComponent:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // TODO: Figure out how Suspense hydration callbacks should work
+        // with Offscreen.
+
+        if (includeWorkInProgressEffects && flags & Update) {
+          commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
+        }
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const offscreenState = finishedWork.memoizedState;
+        const isHidden = offscreenState !== null;
+
+        if (isHidden) ; else {
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+        } // TODO: Check flags & Ref
+
+
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseReappearLayoutEffects(finishedRoot, parentFiber, includeWorkInProgressEffects) {
+  // This function visits both newly finished work and nodes that were re-used
+  // from a previously committed tree. We cannot check non-static flags if the
+  // node was reused.
+  const childShouldIncludeWorkInProgressEffects = includeWorkInProgressEffects && (parentFiber.subtreeFlags & LayoutMask) !== NoFlags$1; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+  let child = parentFiber.child;
+
+  while (child !== null) {
+    const current = child.alternate;
+    reappearLayoutEffects(finishedRoot, current, child, childShouldIncludeWorkInProgressEffects);
+    child = child.sibling;
+  }
+}
+
+function commitHookPassiveMountEffects(finishedWork, hookFlags) {
+  {
+    try {
+      commitHookEffectListMount(hookFlags, finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
+
+function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
+  {
+    let previousCache = null;
+
+    if (current !== null && current.memoizedState !== null && current.memoizedState.cachePool !== null) {
+      previousCache = current.memoizedState.cachePool.pool;
+    }
+
+    let nextCache = null;
+
+    if (finishedWork.memoizedState !== null && finishedWork.memoizedState.cachePool !== null) {
+      nextCache = finishedWork.memoizedState.cachePool.pool;
+    } // Retain/release the cache used for pending (suspended) nodes.
+    // Note that this is only reached in the non-suspended/visible case:
+    // when the content is suspended/hidden, the retain/release occurs
+    // via the parent Suspense component (see case above).
+
+
+    if (nextCache !== previousCache) {
+      if (nextCache != null) {
+        retainCache(nextCache);
+      }
+
+      if (previousCache != null) {
+        releaseCache(previousCache);
+      }
+    }
+  }
+}
+
+function commitCachePassiveMountEffect(current, finishedWork) {
+  {
+    let previousCache = null;
+
+    if (finishedWork.alternate !== null) {
+      previousCache = finishedWork.alternate.memoizedState.cache;
+    }
+
+    const nextCache = finishedWork.memoizedState.cache; // Retain/release the cache. In theory the cache component
+    // could be "borrowing" a cache instance owned by some parent,
+    // in which case we could avoid retaining/releasing. But it
+    // is non-trivial to determine when that is the case, so we
+    // always retain/release.
+
+    if (nextCache !== previousCache) {
+      retainCache(nextCache);
+
+      if (previousCache != null) {
+        releaseCache(previousCache);
+      }
+    }
+  }
+}
+
+function commitPassiveMountEffects(root, finishedWork, committedLanes, committedTransitions) {
+  commitPassiveMountOnFiber(root, finishedWork, committedLanes, committedTransitions);
+}
+
+function recursivelyTraversePassiveMountEffects(root, parentFiber, committedLanes, committedTransitions) {
+
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      commitPassiveMountOnFiber(root, child, committedLanes, committedTransitions);
+      child = child.sibling;
+    }
+  }
+}
+
+function commitPassiveMountOnFiber(finishedRoot, finishedWork, committedLanes, committedTransitions) {
+  // When updating this function, also update reconnectPassiveEffects, which does
+  // most of the same things when an offscreen tree goes from hidden -> visible,
+  // or when toggling effects inside a hidden tree.
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+
+        if (flags & Passive$1) {
+          commitHookPassiveMountEffects(finishedWork, Passive | HasEffect);
+        }
+
+        break;
+      }
+
+    case HostRoot:
+      {
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+
+        if (flags & Passive$1) {
+          {
+            let previousCache = null;
+
+            if (finishedWork.alternate !== null) {
+              previousCache = finishedWork.alternate.memoizedState.cache;
+            }
+
+            const nextCache = finishedWork.memoizedState.cache; // Retain/release the root cache.
+            // Note that on initial mount, previousCache and nextCache will be the same
+            // and this retain won't occur. To counter this, we instead retain the HostRoot's
+            // initial cache when creating the root itself (see createFiberRoot() in
+            // ReactFiberRoot.js). Subsequent updates that change the cache are reflected
+            // here, such that previous/next caches are retained correctly.
+
+            if (nextCache !== previousCache) {
+              retainCache(nextCache);
+
+              if (previousCache != null) {
+                releaseCache(previousCache);
+              }
+            }
+          }
+        }
+
+        break;
+      }
+
+    case LegacyHiddenComponent:
+      {
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        // TODO: Pass `current` as argument to this function
+        const instance = finishedWork.stateNode;
+        const nextState = finishedWork.memoizedState;
+        const isHidden = nextState !== null;
+
+        if (isHidden) {
+          if (instance._visibility & OffscreenPassiveEffectsConnected) {
+            // The effects are currently connected. Update them.
+            recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          } else {
+            if (finishedWork.mode & ConcurrentMode) {
+              // The effects are currently disconnected. Since the tree is hidden,
+              // don't connect them. This also applies to the initial render.
+              {
+                // "Atomic" effects are ones that need to fire on every commit,
+                // even during pre-rendering. An example is updating the reference
+                // count on cache instances.
+                recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+              }
+            } else {
+              // Legacy Mode: Fire the effects even if the tree is hidden.
+              instance._visibility |= OffscreenPassiveEffectsConnected;
+              recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+            }
+          }
+        } else {
+          // Tree is visible
+          if (instance._visibility & OffscreenPassiveEffectsConnected) {
+            // The effects are currently connected. Update them.
+            recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          } else {
+            // The effects are currently disconnected. Reconnect them, while also
+            // firing effects inside newly mounted trees. This also applies to
+            // the initial render.
+            instance._visibility |= OffscreenPassiveEffectsConnected;
+            const includeWorkInProgressEffects = (finishedWork.subtreeFlags & PassiveMask) !== NoFlags$1;
+            recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+          }
+        }
+
+        if (flags & Passive$1) {
+          const current = finishedWork.alternate;
+          commitOffscreenPassiveMountEffects(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+
+        if (flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitCachePassiveMountEffect(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case TracingMarkerComponent:
+
+    default:
+      {
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseReconnectPassiveEffects(finishedRoot, parentFiber, committedLanes, committedTransitions, includeWorkInProgressEffects) {
+  // This function visits both newly finished work and nodes that were re-used
+  // from a previously committed tree. We cannot check non-static flags if the
+  // node was reused.
+  const childShouldIncludeWorkInProgressEffects = includeWorkInProgressEffects && (parentFiber.subtreeFlags & PassiveMask) !== NoFlags$1; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+  let child = parentFiber.child;
+
+  while (child !== null) {
+    reconnectPassiveEffects(finishedRoot, child, committedLanes, committedTransitions, childShouldIncludeWorkInProgressEffects);
+    child = child.sibling;
+  }
+}
+
+function reconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, // This function visits both newly finished work and nodes that were re-used
+// from a previously committed tree. We cannot check non-static flags if the
+// node was reused.
+includeWorkInProgressEffects) {
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects); // TODO: Check for PassiveStatic flag
+
+        commitHookPassiveMountEffects(finishedWork, Passive);
+        break;
+      }
+    // Unlike commitPassiveMountOnFiber, we don't need to handle HostRoot
+    // because this function only visits nodes that are inside an
+    // Offscreen fiber.
+    // case HostRoot: {
+    //  ...
+    // }
+
+    case LegacyHiddenComponent:
+      {
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const instance = finishedWork.stateNode;
+        const nextState = finishedWork.memoizedState;
+        const isHidden = nextState !== null;
+
+        if (isHidden) {
+          if (instance._visibility & OffscreenPassiveEffectsConnected) {
+            // The effects are currently connected. Update them.
+            recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+          } else {
+            if (finishedWork.mode & ConcurrentMode) {
+              // The effects are currently disconnected. Since the tree is hidden,
+              // don't connect them. This also applies to the initial render.
+              {
+                // "Atomic" effects are ones that need to fire on every commit,
+                // even during pre-rendering. An example is updating the reference
+                // count on cache instances.
+                recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+              }
+            } else {
+              // Legacy Mode: Fire the effects even if the tree is hidden.
+              instance._visibility |= OffscreenPassiveEffectsConnected;
+              recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+            }
+          }
+        } else {
+          // Tree is visible
+          // Since we're already inside a reconnecting tree, it doesn't matter
+          // whether the effects are currently connected. In either case, we'll
+          // continue traversing the tree and firing all the effects.
+          //
+          // We do need to set the "connected" flag on the instance, though.
+          instance._visibility |= OffscreenPassiveEffectsConnected;
+          recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+        }
+
+        if (includeWorkInProgressEffects && flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitOffscreenPassiveMountEffects(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+
+        if (includeWorkInProgressEffects && flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitCachePassiveMountEffect(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case TracingMarkerComponent:
+
+    default:
+      {
+        recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseAtomicPassiveEffects(finishedRoot, parentFiber, committedLanes, committedTransitions) {
+
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      commitAtomicPassiveEffects(finishedRoot, child);
+      child = child.sibling;
+    }
+  }
+}
+
+function commitAtomicPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions) {
+  // "Atomic" effects are ones that need to fire on every commit, even during
+  // pre-rendering. We call this function when traversing a hidden tree whose
+  // regular effects are currently disconnected.
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case OffscreenComponent:
+      {
+        recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+
+        if (flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitOffscreenPassiveMountEffects(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+
+        if (flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitCachePassiveMountEffect(current, finishedWork);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+        break;
+      }
+  }
+}
+
+function commitPassiveUnmountEffects(finishedWork) {
+  commitPassiveUnmountOnFiber(finishedWork);
+} // If we're inside a brand new tree, or a tree that was already visible, then we
+// should only suspend host components that have a ShouldSuspendCommit flag.
+// Components without it haven't changed since the last commit, so we can skip
+// over those.
+//
+// When we enter a tree that is being revealed (going from hidden -> visible),
+// we need to suspend _any_ component that _may_ suspend. Even if they're
+// already in the "current" tree. Because their visibility has changed, the
+// browser may not have prerendered them yet. So we check the MaySuspendCommit
+// flag instead.
+
+let suspenseyCommitFlag = ShouldSuspendCommit;
+function accumulateSuspenseyCommit(finishedWork) {
+  accumulateSuspenseyCommitOnFiber(finishedWork);
+}
+
+function recursivelyAccumulateSuspenseyCommit(parentFiber) {
+  if (parentFiber.subtreeFlags & suspenseyCommitFlag) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      accumulateSuspenseyCommitOnFiber(child);
+      child = child.sibling;
+    }
+  }
+}
+
+function accumulateSuspenseyCommitOnFiber(fiber) {
+  switch (fiber.tag) {
+    case HostHoistable:
+      {
+        recursivelyAccumulateSuspenseyCommit(fiber);
+
+        if (fiber.flags & suspenseyCommitFlag) {
+          if (fiber.memoizedState !== null) {
+            suspendResource( // This should always be set by visiting HostRoot first
+            currentHoistableRoot, fiber.memoizedState, fiber.memoizedProps);
+          }
+        }
+
+        break;
+      }
+
+    case HostComponent:
+      {
+        recursivelyAccumulateSuspenseyCommit(fiber);
+
+        break;
+      }
+
+    case HostRoot:
+    case HostPortal:
+      {
+        {
+          const previousHoistableRoot = currentHoistableRoot;
+          const container = fiber.stateNode.containerInfo;
+          currentHoistableRoot = getHoistableRoot(container);
+          recursivelyAccumulateSuspenseyCommit(fiber);
+          currentHoistableRoot = previousHoistableRoot;
+        }
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const isHidden = fiber.memoizedState !== null;
+
+        if (isHidden) ; else {
+          const current = fiber.alternate;
+          const wasHidden = current !== null && current.memoizedState !== null;
+
+          if (wasHidden) {
+            // This tree is being revealed. Visit all newly visible suspensey
+            // instances, even if they're in the current tree.
+            const prevFlags = suspenseyCommitFlag;
+            suspenseyCommitFlag = MaySuspendCommit;
+            recursivelyAccumulateSuspenseyCommit(fiber);
+            suspenseyCommitFlag = prevFlags;
+          } else {
+            recursivelyAccumulateSuspenseyCommit(fiber);
+          }
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyAccumulateSuspenseyCommit(fiber);
+      }
+  }
+}
+
+function detachAlternateSiblings(parentFiber) {
+  // A fiber was deleted from this parent fiber, but it's still part of the
+  // previous (alternate) parent fiber's list of children. Because children
+  // are a linked list, an earlier sibling that's still alive will be
+  // connected to the deleted fiber via its `alternate`:
+  //
+  //   live fiber --alternate--> previous live fiber --sibling--> deleted
+  //   fiber
+  //
+  // We can't disconnect `alternate` on nodes that haven't been deleted yet,
+  // but we can disconnect the `sibling` and `child` pointers.
+  const previousFiber = parentFiber.alternate;
+
+  if (previousFiber !== null) {
+    let detachedChild = previousFiber.child;
+
+    if (detachedChild !== null) {
+      previousFiber.child = null;
+
+      do {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        const detachedSibling = detachedChild.sibling; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+        detachedChild.sibling = null;
+        detachedChild = detachedSibling;
+      } while (detachedChild !== null);
+    }
+  }
+}
+
+function commitHookPassiveUnmountEffects(finishedWork, nearestMountedAncestor, hookFlags) {
+  {
+    commitHookEffectListUnmount(hookFlags, finishedWork, nearestMountedAncestor);
+  }
+}
+
+function recursivelyTraversePassiveUnmountEffects(parentFiber) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects have fired.
+  const deletions = parentFiber.deletions;
+
+  if ((parentFiber.flags & ChildDeletion) !== NoFlags$1) {
+    if (deletions !== null) {
+      for (let i = 0; i < deletions.length; i++) {
+        const childToDelete = deletions[i]; // TODO: Convert this to use recursion
+
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(childToDelete, parentFiber);
+      }
+    }
+
+    detachAlternateSiblings(parentFiber);
+  }
+
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      commitPassiveUnmountOnFiber(child);
+      child = child.sibling;
+    }
+  }
+}
+
+function commitPassiveUnmountOnFiber(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraversePassiveUnmountEffects(finishedWork);
+
+        if (finishedWork.flags & Passive$1) {
+          commitHookPassiveUnmountEffects(finishedWork, finishedWork.return, Passive | HasEffect);
+        }
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const instance = finishedWork.stateNode;
+        const nextState = finishedWork.memoizedState;
+        const isHidden = nextState !== null;
+
+        if (isHidden && instance._visibility & OffscreenPassiveEffectsConnected && ( // For backwards compatibility, don't unmount when a tree suspends. In
+        // the future we may change this to unmount after a delay.
+        finishedWork.return === null || finishedWork.return.tag !== SuspenseComponent)) {
+          // The effects are currently connected. Disconnect them.
+          // TODO: Add option or heuristic to delay before disconnecting the
+          // effects. Then if the tree reappears before the delay has elapsed, we
+          // can skip toggling the effects entirely.
+          instance._visibility &= ~OffscreenPassiveEffectsConnected;
+          recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+        } else {
+          recursivelyTraversePassiveUnmountEffects(finishedWork);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraversePassiveUnmountEffects(finishedWork);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects have fired.
+  const deletions = parentFiber.deletions;
+
+  if ((parentFiber.flags & ChildDeletion) !== NoFlags$1) {
+    if (deletions !== null) {
+      for (let i = 0; i < deletions.length; i++) {
+        const childToDelete = deletions[i]; // TODO: Convert this to use recursion
+
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(childToDelete, parentFiber);
+      }
+    }
+
+    detachAlternateSiblings(parentFiber);
+  }
+
+  let child = parentFiber.child;
+
+  while (child !== null) {
+    disconnectPassiveEffect(child);
+    child = child.sibling;
+  }
+}
+
+function disconnectPassiveEffect(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        // TODO: Check PassiveStatic flag
+        commitHookPassiveUnmountEffects(finishedWork, finishedWork.return, Passive); // When disconnecting passive effects, we fire the effects in the same
+        // order as during a deletiong: parent before child
+
+        recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const instance = finishedWork.stateNode;
+
+        if (instance._visibility & OffscreenPassiveEffectsConnected) {
+          instance._visibility &= ~OffscreenPassiveEffectsConnected;
+          recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+        break;
+      }
+  }
+}
+
+function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(deletedSubtreeRoot, nearestMountedAncestor) {
+  while (nextEffect !== null) {
+    const fiber = nextEffect; // Deletion effects fire in parent -> child order
+    commitPassiveUnmountInsideDeletedTreeOnFiber(fiber, nearestMountedAncestor);
+    const child = fiber.child; // TODO: Only traverse subtree if it has a PassiveStatic flag.
+
+    if (child !== null) {
+      child.return = fiber;
+      nextEffect = child;
+    } else {
+      commitPassiveUnmountEffectsInsideOfDeletedTree_complete(deletedSubtreeRoot);
+    }
+  }
+}
+
+function commitPassiveUnmountEffectsInsideOfDeletedTree_complete(deletedSubtreeRoot) {
+  while (nextEffect !== null) {
+    const fiber = nextEffect;
+    const sibling = fiber.sibling;
+    const returnFiber = fiber.return; // Recursively traverse the entire deleted tree and clean up fiber fields.
+    // This is more aggressive than ideal, and the long term goal is to only
+    // have to detach the deleted tree at the root.
+
+    detachFiberAfterEffects(fiber);
+
+    if (fiber === deletedSubtreeRoot) {
+      nextEffect = null;
+      return;
+    }
+
+    if (sibling !== null) {
+      sibling.return = returnFiber;
+      nextEffect = sibling;
+      return;
+    }
+
+    nextEffect = returnFiber;
+  }
+}
+
+function commitPassiveUnmountInsideDeletedTreeOnFiber(current, nearestMountedAncestor) {
+  switch (current.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        commitHookPassiveUnmountEffects(current, nearestMountedAncestor, Passive);
+        break;
+      }
+    // TODO: run passive unmount effects when unmounting a root.
+    // Because passive unmount effects are not currently run,
+    // the cache instance owned by the root will never be freed.
+    // When effects are run, the cache should be freed here:
+    // case HostRoot: {
+    //   if (enableCache) {
+    //     const cache = current.memoizedState.cache;
+    //     releaseCache(cache);
+    //   }
+    //   break;
+    // }
+
+    case LegacyHiddenComponent:
+    case OffscreenComponent:
+      {
+        {
+          if (current.memoizedState !== null && current.memoizedState.cachePool !== null) {
+            const cache = current.memoizedState.cachePool.pool; // Retain/release the cache used for pending (suspended) nodes.
+            // Note that this is only reached in the non-suspended/visible case:
+            // when the content is suspended/hidden, the retain/release occurs
+            // via the parent Suspense component (see case above).
+
+            if (cache != null) {
+              retainCache(cache);
+            }
+          }
+        }
+
+        break;
+      }
+
+    case SuspenseComponent:
+      {
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        {
+          const cache = current.memoizedState.cache;
+          releaseCache(cache);
+        }
+
+        break;
+      }
+  }
+}
+
+function getCacheSignal() {
+
+  const cache = readContext(CacheContext);
+  return cache.controller.signal;
+}
+
+function getCacheForType(resourceType) {
+
+  const cache = readContext(CacheContext);
+  let cacheForType = cache.data.get(resourceType);
+
+  if (cacheForType === undefined) {
+    cacheForType = resourceType();
+    cache.data.set(resourceType, cacheForType);
+  }
+
+  return cacheForType;
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal,
+  getCacheForType
+};
+
+let COMPONENT_TYPE = 0b000;
+let HAS_PSEUDO_CLASS_TYPE = 0b001;
+let ROLE_TYPE = 0b010;
+let TEST_NAME_TYPE = 0b011;
+let TEXT_TYPE = 0b100;
+
+if (typeof Symbol === 'function' && Symbol.for) {
+  const symbolFor = Symbol.for;
+  COMPONENT_TYPE = symbolFor('selector.component');
+  HAS_PSEUDO_CLASS_TYPE = symbolFor('selector.has_pseudo_class');
+  ROLE_TYPE = symbolFor('selector.role');
+  TEST_NAME_TYPE = symbolFor('selector.test_id');
+  TEXT_TYPE = symbolFor('selector.text');
+}
+
+function createComponentSelector(component) {
+  return {
+    $$typeof: COMPONENT_TYPE,
+    value: component
+  };
+}
+function createHasPseudoClassSelector(selectors) {
+  return {
+    $$typeof: HAS_PSEUDO_CLASS_TYPE,
+    value: selectors
+  };
+}
+function createRoleSelector(role) {
+  return {
+    $$typeof: ROLE_TYPE,
+    value: role
+  };
+}
+function createTextSelector(text) {
+  return {
+    $$typeof: TEXT_TYPE,
+    value: text
+  };
+}
+function createTestNameSelector(id) {
+  return {
+    $$typeof: TEST_NAME_TYPE,
+    value: id
+  };
+}
+
+function findFiberRootForHostRoot(hostRoot) {
+  const maybeFiber = getInstanceFromNode(hostRoot);
+
+  if (maybeFiber != null) {
+    if (typeof maybeFiber.memoizedProps['data-testname'] !== 'string') {
+      throw Error(formatProdErrorMessage(364));
+    }
+
+    return maybeFiber;
+  } else {
+    const fiberRoot = findFiberRoot(hostRoot);
+
+    if (fiberRoot === null) {
+      throw Error(formatProdErrorMessage(362));
+    } // The Flow type for FiberRoot is a little funky.
+    // createFiberRoot() cheats this by treating the root as :any and adding stateNode lazily.
+
+
+    return fiberRoot.stateNode.current;
+  }
+}
+
+function matchSelector(fiber, selector) {
+  const tag = fiber.tag;
+
+  switch (selector.$$typeof) {
+    case COMPONENT_TYPE:
+      if (fiber.type === selector.value) {
+        return true;
+      }
+
+      break;
+
+    case HAS_PSEUDO_CLASS_TYPE:
+      return hasMatchingPaths(fiber, selector.value);
+
+    case ROLE_TYPE:
+      if (tag === HostComponent || tag === HostHoistable || tag === HostSingleton) {
+        const node = fiber.stateNode;
+
+        if (matchAccessibilityRole(node, selector.value)) {
+          return true;
+        }
+      }
+
+      break;
+
+    case TEXT_TYPE:
+      if (tag === HostComponent || tag === HostText || tag === HostHoistable || tag === HostSingleton) {
+        const textContent = getTextContent(fiber);
+
+        if (textContent !== null && textContent.indexOf(selector.value) >= 0) {
+          return true;
+        }
+      }
+
+      break;
+
+    case TEST_NAME_TYPE:
+      if (tag === HostComponent || tag === HostHoistable || tag === HostSingleton) {
+        const dataTestID = fiber.memoizedProps['data-testname'];
+
+        if (typeof dataTestID === 'string' && dataTestID.toLowerCase() === selector.value.toLowerCase()) {
+          return true;
+        }
+      }
+
+      break;
+
+    default:
+      throw Error(formatProdErrorMessage(365));
+  }
+
+  return false;
+}
+
+function selectorToString(selector) {
+  switch (selector.$$typeof) {
+    case COMPONENT_TYPE:
+      const displayName = getComponentNameFromType(selector.value) || 'Unknown';
+      return "<" + displayName + ">";
+
+    case HAS_PSEUDO_CLASS_TYPE:
+      return ":has(" + (selectorToString(selector) || '') + ")";
+
+    case ROLE_TYPE:
+      return "[role=\"" + selector.value + "\"]";
+
+    case TEXT_TYPE:
+      return "\"" + selector.value + "\"";
+
+    case TEST_NAME_TYPE:
+      return "[data-testname=\"" + selector.value + "\"]";
+
+    default:
+      throw Error(formatProdErrorMessage(365));
+  }
+}
+
+function findPaths(root, selectors) {
+  const matchingFibers = [];
+  const stack = [root, 0];
+  let index = 0;
+
+  while (index < stack.length) {
+    const fiber = stack[index++];
+    const tag = fiber.tag;
+    let selectorIndex = stack[index++];
+    let selector = selectors[selectorIndex];
+
+    if ((tag === HostComponent || tag === HostHoistable || tag === HostSingleton) && isHiddenSubtree(fiber)) {
+      continue;
+    } else {
+      while (selector != null && matchSelector(fiber, selector)) {
+        selectorIndex++;
+        selector = selectors[selectorIndex];
+      }
+    }
+
+    if (selectorIndex === selectors.length) {
+      matchingFibers.push(fiber);
+    } else {
+      let child = fiber.child;
+
+      while (child !== null) {
+        stack.push(child, selectorIndex);
+        child = child.sibling;
+      }
+    }
+  }
+
+  return matchingFibers;
+} // Same as findPaths but with eager bailout on first match
+
+
+function hasMatchingPaths(root, selectors) {
+  const stack = [root, 0];
+  let index = 0;
+
+  while (index < stack.length) {
+    const fiber = stack[index++];
+    const tag = fiber.tag;
+    let selectorIndex = stack[index++];
+    let selector = selectors[selectorIndex];
+
+    if ((tag === HostComponent || tag === HostHoistable || tag === HostSingleton) && isHiddenSubtree(fiber)) {
+      continue;
+    } else {
+      while (selector != null && matchSelector(fiber, selector)) {
+        selectorIndex++;
+        selector = selectors[selectorIndex];
+      }
+    }
+
+    if (selectorIndex === selectors.length) {
+      return true;
+    } else {
+      let child = fiber.child;
+
+      while (child !== null) {
+        stack.push(child, selectorIndex);
+        child = child.sibling;
+      }
+    }
+  }
+
+  return false;
+}
+
+function findAllNodes(hostRoot, selectors) {
+
+  const root = findFiberRootForHostRoot(hostRoot);
+  const matchingFibers = findPaths(root, selectors);
+  const instanceRoots = [];
+  const stack = Array.from(matchingFibers);
+  let index = 0;
+
+  while (index < stack.length) {
+    const node = stack[index++];
+    const tag = node.tag;
+
+    if (tag === HostComponent || tag === HostHoistable || tag === HostSingleton) {
+      if (isHiddenSubtree(node)) {
+        continue;
+      }
+
+      instanceRoots.push(node.stateNode);
+    } else {
+      let child = node.child;
+
+      while (child !== null) {
+        stack.push(child);
+        child = child.sibling;
+      }
+    }
+  }
+
+  return instanceRoots;
+}
+function getFindAllNodesFailureDescription(hostRoot, selectors) {
+
+  const root = findFiberRootForHostRoot(hostRoot);
+  let maxSelectorIndex = 0;
+  const matchedNames = []; // The logic of this loop should be kept in sync with findPaths()
+
+  const stack = [root, 0];
+  let index = 0;
+
+  while (index < stack.length) {
+    const fiber = stack[index++];
+    const tag = fiber.tag;
+    let selectorIndex = stack[index++];
+    const selector = selectors[selectorIndex];
+
+    if ((tag === HostComponent || tag === HostHoistable || tag === HostSingleton) && isHiddenSubtree(fiber)) {
+      continue;
+    } else if (matchSelector(fiber, selector)) {
+      matchedNames.push(selectorToString(selector));
+      selectorIndex++;
+
+      if (selectorIndex > maxSelectorIndex) {
+        maxSelectorIndex = selectorIndex;
+      }
+    }
+
+    if (selectorIndex < selectors.length) {
+      let child = fiber.child;
+
+      while (child !== null) {
+        stack.push(child, selectorIndex);
+        child = child.sibling;
+      }
+    }
+  }
+
+  if (maxSelectorIndex < selectors.length) {
+    const unmatchedNames = [];
+
+    for (let i = maxSelectorIndex; i < selectors.length; i++) {
+      unmatchedNames.push(selectorToString(selectors[i]));
+    }
+
+    return 'findAllNodes was able to match part of the selector:\n' + ("  " + matchedNames.join(' > ') + "\n\n") + 'No matching component was found for:\n' + ("  " + unmatchedNames.join(' > '));
+  }
+
+  return null;
+}
+function findBoundingRects(hostRoot, selectors) {
+
+  const instanceRoots = findAllNodes(hostRoot, selectors);
+  const boundingRects = [];
+
+  for (let i = 0; i < instanceRoots.length; i++) {
+    boundingRects.push(getBoundingRect(instanceRoots[i]));
+  }
+
+  for (let i = boundingRects.length - 1; i > 0; i--) {
+    const targetRect = boundingRects[i];
+    const targetLeft = targetRect.x;
+    const targetRight = targetLeft + targetRect.width;
+    const targetTop = targetRect.y;
+    const targetBottom = targetTop + targetRect.height;
+
+    for (let j = i - 1; j >= 0; j--) {
+      if (i !== j) {
+        const otherRect = boundingRects[j];
+        const otherLeft = otherRect.x;
+        const otherRight = otherLeft + otherRect.width;
+        const otherTop = otherRect.y;
+        const otherBottom = otherTop + otherRect.height; // Merging all rects to the minimums set would be complicated,
+        // but we can handle the most common cases:
+        // 1. completely overlapping rects
+        // 2. adjacent rects that are the same width or height (e.g. items in a list)
+        //
+        // Even given the above constraints,
+        // we still won't end up with the fewest possible rects without doing multiple passes,
+        // but it's good enough for this purpose.
+
+        if (targetLeft >= otherLeft && targetTop >= otherTop && targetRight <= otherRight && targetBottom <= otherBottom) {
+          // Complete overlapping rects; remove the inner one.
+          boundingRects.splice(i, 1);
+          break;
+        } else if (targetLeft === otherLeft && targetRect.width === otherRect.width && !(otherBottom < targetTop) && !(otherTop > targetBottom)) {
+          // Adjacent vertical rects; merge them.
+          if (otherTop > targetTop) {
+            otherRect.height += otherTop - targetTop;
+            otherRect.y = targetTop;
+          }
+
+          if (otherBottom < targetBottom) {
+            otherRect.height = targetBottom - otherTop;
+          }
+
+          boundingRects.splice(i, 1);
+          break;
+        } else if (targetTop === otherTop && targetRect.height === otherRect.height && !(otherRight < targetLeft) && !(otherLeft > targetRight)) {
+          // Adjacent horizontal rects; merge them.
+          if (otherLeft > targetLeft) {
+            otherRect.width += otherLeft - targetLeft;
+            otherRect.x = targetLeft;
+          }
+
+          if (otherRight < targetRight) {
+            otherRect.width = targetRight - otherLeft;
+          }
+
+          boundingRects.splice(i, 1);
+          break;
+        }
+      }
+    }
+  }
+
+  return boundingRects;
+}
+function focusWithin(hostRoot, selectors) {
+
+  const root = findFiberRootForHostRoot(hostRoot);
+  const matchingFibers = findPaths(root, selectors);
+  const stack = Array.from(matchingFibers);
+  let index = 0;
+
+  while (index < stack.length) {
+    const fiber = stack[index++];
+    const tag = fiber.tag;
+
+    if (isHiddenSubtree(fiber)) {
+      continue;
+    }
+
+    if (tag === HostComponent || tag === HostHoistable || tag === HostSingleton) {
+      const node = fiber.stateNode;
+
+      if (setFocusIfFocusable(node)) {
+        return true;
+      }
+    }
+
+    let child = fiber.child;
+
+    while (child !== null) {
+      stack.push(child);
+      child = child.sibling;
+    }
+  }
+
+  return false;
+}
+function observeVisibleRects(hostRoot, selectors, callback, options) {
+
+  const instanceRoots = findAllNodes(hostRoot, selectors);
+
+  const _setupIntersectionObs = setupIntersectionObserver(instanceRoots, callback, options),
+        disconnect = _setupIntersectionObs.disconnect;
+ // When React mutates the host environment, we may need to change what we're listening to.
+  return {
+    disconnect: () => {
+
+
+      disconnect();
+    }
+  };
+}
+
+const PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
+      ReactCurrentCache = ReactSharedInternals.ReactCurrentCache,
+      ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner,
+      ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig,
+      ReactCurrentActQueue = ReactSharedInternals.ReactCurrentActQueue;
+const NoContext =
+/*             */
+0b000;
+const BatchedContext =
+/*               */
+0b001;
+const RenderContext =
+/*         */
+0b010;
+const CommitContext =
+/*         */
+0b100;
+const RootInProgress = 0;
+const RootFatalErrored = 1;
+const RootErrored = 2;
+const RootSuspended = 3;
+const RootSuspendedWithDelay = 4;
+const RootCompleted = 5;
+const RootDidNotComplete = 6; // Describes where we are in the React execution stack
+
+let executionContext = NoContext; // The root we're working on
+
+let workInProgressRoot = null; // The fiber we're working on
+
+let workInProgress = null; // The lanes we're rendering
+
+let workInProgressRootRenderLanes = NoLanes;
+const NotSuspended = 0;
+const SuspendedOnError = 1;
+const SuspendedOnData = 2;
+const SuspendedOnImmediate = 3;
+const SuspendedOnInstance = 4;
+const SuspendedOnInstanceAndReadyToContinue = 5;
+const SuspendedOnDeprecatedThrowPromise = 6;
+const SuspendedAndReadyToContinue = 7;
+const SuspendedOnHydration = 8; // When this is true, the work-in-progress fiber just suspended (or errored) and
+// we've yet to unwind the stack. In some cases, we may yield to the main thread
+// after this happens. If the fiber is pinged before we resume, we can retry
+// immediately instead of unwinding the stack.
+
+let workInProgressSuspendedReason = NotSuspended;
+let workInProgressThrownValue = null; // Whether a ping listener was attached during this render. This is slightly
+// different that whether something suspended, because we don't add multiple
+// listeners to a promise we've already seen (per root and lane).
+
+let workInProgressRootDidAttachPingListener = false; // A contextual version of workInProgressRootRenderLanes. It is a superset of
+// the lanes that we started working on at the root. When we enter a subtree
+// that is currently hidden, we add the lanes that would have committed if
+// the hidden tree hadn't been deferred. This is modified by the
+// HiddenContext module.
+//
+// Most things in the work loop should deal with workInProgressRootRenderLanes.
+// Most things in begin/complete phases should deal with entangledRenderLanes.
+
+let entangledRenderLanes = NoLanes; // Whether to root completed, errored, suspended, etc.
+
+let workInProgressRootExitStatus = RootInProgress; // A fatal error, if one is thrown
+
+let workInProgressRootFatalError = null; // The work left over by components that were visited during this render. Only
+// includes unprocessed updates, not work in bailed out children.
+
+let workInProgressRootSkippedLanes = NoLanes; // Lanes that were updated (in an interleaved event) during this render.
+
+let workInProgressRootInterleavedUpdatedLanes = NoLanes; // Lanes that were updated during the render phase (*not* an interleaved event).
+
+let workInProgressRootPingedLanes = NoLanes; // If this lane scheduled deferred work, this is the lane of the deferred task.
+
+let workInProgressDeferredLane = NoLane; // Errors that are thrown during the render phase.
+
+let workInProgressRootConcurrentErrors = null; // These are errors that we recovered from without surfacing them to the UI.
+// We will log them once the tree commits.
+
+let workInProgressRootRecoverableErrors = null; // The most recent time we either committed a fallback, or when a fallback was
+// filled in with the resolved UI. This lets us throttle the appearance of new
+// content as it streams in, to minimize jank.
+// TODO: Think of a better name for this variable?
+
+let globalMostRecentFallbackTime = 0;
+const FALLBACK_THROTTLE_MS = 300; // The absolute time for when we should start giving up on rendering
+// more and prefer CPU suspense heuristics instead.
+
+let workInProgressRootRenderTargetTime = Infinity; // How long a render is supposed to take before we start following CPU
+// suspense heuristics and opt out of rendering more content.
+
+const RENDER_TIMEOUT_MS = 500;
+let workInProgressTransitions = null;
+
+function resetRenderTimer() {
+  workInProgressRootRenderTargetTime = now() + RENDER_TIMEOUT_MS;
+}
+
+function getRenderTargetTime() {
+  return workInProgressRootRenderTargetTime;
+}
+let hasUncaughtError = false;
+let firstUncaughtError = null;
+let legacyErrorBoundariesThatAlreadyFailed = null; // Only used when enableProfilerNestedUpdateScheduledHook is true;
+let rootDoesHavePassiveEffects = false;
+let rootWithPendingPassiveEffects = null;
+let pendingPassiveEffectsLanes = NoLanes;
+let pendingPassiveEffectsRemainingLanes = NoLanes;
+let pendingPassiveTransitions = null; // Use these to prevent an infinite loop of nested updates
+
+const NESTED_UPDATE_LIMIT = 50;
+let nestedUpdateCount = 0;
+let rootWithNestedUpdates = null;
+function getWorkInProgressRoot() {
+  return workInProgressRoot;
+}
+function getWorkInProgressRootRenderLanes() {
+  return workInProgressRootRenderLanes;
+}
+function isWorkLoopSuspendedOnData() {
+  return workInProgressSuspendedReason === SuspendedOnData;
+}
+function requestUpdateLane(fiber) {
+  // Special cases
+  const mode = fiber.mode;
+
+  if ((mode & ConcurrentMode) === NoMode) {
+    return SyncLane;
+  } else if ((executionContext & RenderContext) !== NoContext && workInProgressRootRenderLanes !== NoLanes) {
+    // This is a render phase update. These are not officially supported. The
+    // old behavior is to give this the same "thread" (lanes) as
+    // whatever is currently rendering. So if you call `setState` on a component
+    // that happens later in the same render, it will flush. Ideally, we want to
+    // remove the special case and treat them as if they came from an
+    // interleaved event. Regardless, this pattern is not officially supported.
+    // This behavior is only a fallback. The flag only exists until we can roll
+    // out the setState warning, since existing code might accidentally rely on
+    // the current behavior.
+    return pickArbitraryLane(workInProgressRootRenderLanes);
+  }
+
+  const isTransition = requestCurrentTransition() !== NoTransition;
+
+  if (isTransition) {
+
+    const actionScopeLane = peekEntangledActionLane();
+    return actionScopeLane !== NoLane ? // We're inside an async action scope. Reuse the same lane.
+    actionScopeLane : // We may or may not be inside an async action scope. If we are, this
+    // is the first update in that scope. Either way, we need to get a
+    // fresh transition lane.
+    requestTransitionLane();
+  } // Updates originating inside certain React methods, like flushSync, have
+  // their priority set by tracking it with a context variable.
+  //
+  // The opaque type returned by the host config is internally a lane, so we can
+  // use that directly.
+  // TODO: Move this type conversion to the event priority module.
+
+
+  const updateLane = getCurrentUpdatePriority();
+
+  if (updateLane !== NoLane) {
+    return updateLane;
+  } // This update originated outside React. Ask the host environment for an
+  // appropriate priority, based on the type of event.
+  //
+  // The opaque type returned by the host config is internally a lane, so we can
+  // use that directly.
+  // TODO: Move this type conversion to the event priority module.
+
+
+  const eventLane = getCurrentEventPriority();
+  return eventLane;
+}
+
+function requestRetryLane(fiber) {
+  // This is a fork of `requestUpdateLane` designed specifically for Suspense
+  // "retries" — a special update that attempts to flip a Suspense boundary
+  // from its placeholder state to its primary/resolved state.
+  // Special cases
+  const mode = fiber.mode;
+
+  if ((mode & ConcurrentMode) === NoMode) {
+    return SyncLane;
+  }
+
+  return claimNextRetryLane();
+}
+
+function requestDeferredLane() {
+  if (workInProgressDeferredLane === NoLane) {
+    // If there are multiple useDeferredValue hooks in the same render, the
+    // tasks that they spawn should all be batched together, so they should all
+    // receive the same lane.
+    // Check the priority of the current render to decide the priority of the
+    // deferred task.
+    // OffscreenLane is used for prerendering, but we also use OffscreenLane
+    // for incremental hydration. It's given the lowest priority because the
+    // initial HTML is the same as the final UI. But useDeferredValue during
+    // hydration is an exception — we need to upgrade the UI to the final
+    // value. So if we're currently hydrating, we treat it like a transition.
+    const isPrerendering = includesSomeLane(workInProgressRootRenderLanes, OffscreenLane) && !getIsHydrating();
+
+    if (isPrerendering) {
+      // There's only one OffscreenLane, so if it contains deferred work, we
+      // should just reschedule using the same lane.
+      workInProgressDeferredLane = OffscreenLane;
+    } else {
+      // Everything else is spawned as a transition.
+      workInProgressDeferredLane = requestTransitionLane();
+    }
+  }
+
+  return workInProgressDeferredLane;
+}
+function scheduleUpdateOnFiber(root, fiber, lane) {
+  // finish loading.
+
+
+  if ( // Suspended render phase
+  root === workInProgressRoot && workInProgressSuspendedReason === SuspendedOnData || // Suspended commit phase
+  root.cancelPendingCommit !== null) {
+    // The incoming update might unblock the current render. Interrupt the
+    // current attempt and restart from the top.
+    prepareFreshStack(root, NoLanes);
+    markRootSuspended(root, workInProgressRootRenderLanes, workInProgressDeferredLane);
+  } // Mark that the root has a pending update.
+
+
+  markRootUpdated(root, lane);
+
+  if ((executionContext & RenderContext) !== NoLanes && root === workInProgressRoot) ; else {
+
+    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.
+      if ((executionContext & RenderContext) === NoContext) {
+        workInProgressRootInterleavedUpdatedLanes = mergeLanes(workInProgressRootInterleavedUpdatedLanes, lane);
+      }
+
+      if (workInProgressRootExitStatus === RootSuspendedWithDelay) {
+        // The root already suspended with a delay, which means this render
+        // definitely won't finish. Since we have a new update, let's mark it as
+        // suspended now, right before marking the incoming update. This has the
+        // effect of interrupting the current render and switching to the update.
+        // TODO: Make sure this doesn't override pings that happen while we've
+        // already started rendering.
+        markRootSuspended(root, workInProgressRootRenderLanes, workInProgressDeferredLane);
+      }
+    }
+
+    ensureRootIsScheduled(root);
+
+    if (lane === SyncLane && executionContext === NoContext && (fiber.mode & ConcurrentMode) === NoMode) {
+      {
+        // Flush the synchronous work now, unless we're already working or inside
+        // a batch. This is intentionally inside scheduleUpdateOnFiber instead of
+        // scheduleCallbackForFiber to preserve the ability to schedule a callback
+        // without immediately flushing it. We only do this for user-initiated
+        // updates, to preserve historical behavior of legacy mode.
+        resetRenderTimer();
+        flushSyncWorkOnLegacyRootsOnly();
+      }
+    }
+  }
+}
+function scheduleInitialHydrationOnRoot(root, lane) {
+  // This is a special fork of scheduleUpdateOnFiber that is only used to
+  // schedule the initial hydration of a root that has just been created. Most
+  // of the stuff in scheduleUpdateOnFiber can be skipped.
+  //
+  // The main reason for this separate path, though, is to distinguish the
+  // initial children from subsequent updates. In fully client-rendered roots
+  // (createRoot instead of hydrateRoot), all top-level renders are modeled as
+  // updates, but hydration roots are special because the initial render must
+  // match what was rendered on the server.
+  const current = root.current;
+  current.lanes = lane;
+  markRootUpdated(root, lane);
+  ensureRootIsScheduled(root);
+}
+function isUnsafeClassRenderPhaseUpdate(fiber) {
+  // Check if this is a render phase update. Only called by class components,
+  // which special (deprecated) behavior for UNSAFE_componentWillReceive props.
+  return (executionContext & RenderContext) !== NoContext;
+} // This is the entry point for every concurrent task, i.e. anything that
+// goes through Scheduler.
+
+function performConcurrentWorkOnRoot(root, didTimeout) {
+
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw Error(formatProdErrorMessage(327));
+  } // Flush any pending passive effects before deciding which lanes to work on,
+  // in case they schedule additional work.
+
+
+  const originalCallbackNode = root.callbackNode;
+  const didFlushPassiveEffects = flushPassiveEffects();
+
+  if (didFlushPassiveEffects) {
+    // Something in the passive effect phase may have canceled the current task.
+    // Check if the task node for this root was changed.
+    if (root.callbackNode !== originalCallbackNode) {
+      // The current task was canceled. Exit. We don't need to call
+      // `ensureRootIsScheduled` because the check above implies either that
+      // there's a new task, or that there's no remaining work on this root.
+      return null;
+    }
+  } // Determine the next lanes to work on, using the fields stored
+  // on the root.
+  // TODO: This was already computed in the caller. Pass it as an argument.
+
+
+  let lanes = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes);
+
+  if (lanes === NoLanes) {
+    // Defensive coding. This is never expected to happen.
+    return null;
+  } // We disable time-slicing in some cases: if the work has been CPU-bound
+  // for too long ("expired" work, to prevent starvation), or we're in
+  // sync-updates-by-default mode.
+  // TODO: We only check `didTimeout` defensively, to account for a Scheduler
+  // bug we're still investigating. Once the bug in Scheduler is fixed,
+  // we can remove this, since we track expiration ourselves.
+
+
+  const shouldTimeSlice = !includesBlockingLane(root, lanes) && !includesExpiredLane(root, lanes) && (!didTimeout);
+  let exitStatus = shouldTimeSlice ? renderRootConcurrent(root, lanes) : renderRootSync(root, lanes);
+
+  if (exitStatus !== RootInProgress) {
+    let renderWasConcurrent = shouldTimeSlice;
+
+    do {
+      if (exitStatus === RootDidNotComplete) {
+        // The render unwound without completing the tree. This happens in special
+        // cases where need to exit the current render without producing a
+        // consistent tree or committing.
+        markRootSuspended(root, lanes, NoLane);
+      } else {
+        // The render completed.
+        // Check if this render may have yielded to a concurrent event, and if so,
+        // confirm that any newly rendered stores are consistent.
+        // TODO: It's possible that even a concurrent render may never have yielded
+        // to the main thread, if it was fast enough, or if it expired. We could
+        // skip the consistency check in that case, too.
+        const finishedWork = root.current.alternate;
+
+        if (renderWasConcurrent && !isRenderConsistentWithExternalStores(finishedWork)) {
+          // A store was mutated in an interleaved event. Render again,
+          // synchronously, to block further mutations.
+          exitStatus = renderRootSync(root, lanes); // We assume the tree is now consistent because we didn't yield to any
+          // concurrent events.
+
+          renderWasConcurrent = false; // Need to check the exit status again.
+
+          continue;
+        } // Check if something threw
+
+
+        if (exitStatus === RootErrored) {
+          const originallyAttemptedLanes = lanes;
+          const errorRetryLanes = getLanesToRetrySynchronouslyOnError(root, originallyAttemptedLanes);
+
+          if (errorRetryLanes !== NoLanes) {
+            lanes = errorRetryLanes;
+            exitStatus = recoverFromConcurrentError(root, originallyAttemptedLanes, errorRetryLanes);
+            renderWasConcurrent = false;
+          }
+        }
+
+        if (exitStatus === RootFatalErrored) {
+          const fatalError = workInProgressRootFatalError;
+          prepareFreshStack(root, NoLanes);
+          markRootSuspended(root, lanes, NoLane);
+          ensureRootIsScheduled(root);
+          throw fatalError;
+        } // We now have a consistent tree. The next step is either to commit it,
+        // or, if something suspended, wait to commit it after a timeout.
+
+
+        root.finishedWork = finishedWork;
+        root.finishedLanes = lanes;
+        finishConcurrentRender(root, exitStatus, finishedWork, lanes);
+      }
+
+      break;
+    } while (true);
+  }
+
+  ensureRootIsScheduled(root);
+  return getContinuationForRoot(root, originalCallbackNode);
+}
+
+function recoverFromConcurrentError(root, originallyAttemptedLanes, errorRetryLanes) {
+  // If an error occurred during hydration, discard server response and fall
+  // back to client side render.
+  // Before rendering again, save the errors from the previous attempt.
+  const errorsFromFirstAttempt = workInProgressRootConcurrentErrors;
+  const wasRootDehydrated = isRootDehydrated(root);
+
+  if (wasRootDehydrated) {
+    // The shell failed to hydrate. Set a flag to force a client rendering
+    // during the next attempt. To do this, we call prepareFreshStack now
+    // to create the root work-in-progress fiber. This is a bit weird in terms
+    // of factoring, because it relies on renderRootSync not calling
+    // prepareFreshStack again in the call below, which happens because the
+    // root and lanes haven't changed.
+    //
+    // TODO: I think what we should do is set ForceClientRender inside
+    // throwException, like we do for nested Suspense boundaries. The reason
+    // it's here instead is so we can switch to the synchronous work loop, too.
+    // Something to consider for a future refactor.
+    const rootWorkInProgress = prepareFreshStack(root, errorRetryLanes);
+    rootWorkInProgress.flags |= ForceClientRender;
+  }
+
+  const exitStatus = renderRootSync(root, errorRetryLanes);
+
+  if (exitStatus !== RootErrored) {
+    // Successfully finished rendering on retry
+    if (workInProgressRootDidAttachPingListener && !wasRootDehydrated) {
+      // During the synchronous render, we attached additional ping listeners.
+      // This is highly suggestive of an uncached promise (though it's not the
+      // only reason this would happen). If it was an uncached promise, then
+      // it may have masked a downstream error from ocurring without actually
+      // fixing it. Example:
+      //
+      //    use(Promise.resolve('uncached'))
+      //    throw new Error('Oops!')
+      //
+      // When this happens, there's a conflict between blocking potential
+      // concurrent data races and unwrapping uncached promise values. We
+      // have to choose one or the other. Because the data race recovery is
+      // a last ditch effort, we'll disable it.
+      root.errorRecoveryDisabledLanes = mergeLanes(root.errorRecoveryDisabledLanes, originallyAttemptedLanes); // Mark the current render as suspended and force it to restart. Once
+      // these lanes finish successfully, we'll re-enable the error recovery
+      // mechanism for subsequent updates.
+
+      workInProgressRootInterleavedUpdatedLanes |= originallyAttemptedLanes;
+      return RootSuspendedWithDelay;
+    } // The errors from the failed first attempt have been recovered. Add
+    // them to the collection of recoverable errors. We'll log them in the
+    // commit phase.
+
+
+    const errorsFromSecondAttempt = workInProgressRootRecoverableErrors;
+    workInProgressRootRecoverableErrors = errorsFromFirstAttempt; // The errors from the second attempt should be queued after the errors
+    // from the first attempt, to preserve the causal sequence.
+
+    if (errorsFromSecondAttempt !== null) {
+      queueRecoverableErrors(errorsFromSecondAttempt);
+    }
+  }
+
+  return exitStatus;
+}
+
+function queueRecoverableErrors(errors) {
+  if (workInProgressRootRecoverableErrors === null) {
+    workInProgressRootRecoverableErrors = errors;
+  } else {
+    // $FlowFixMe[method-unbinding]
+    workInProgressRootRecoverableErrors.push.apply(workInProgressRootRecoverableErrors, errors);
+  }
+}
+
+function finishConcurrentRender(root, exitStatus, finishedWork, lanes) {
+  // TODO: The fact that most of these branches are identical suggests that some
+  // of the exit statuses are not best modeled as exit statuses and should be
+  // tracked orthogonally.
+  switch (exitStatus) {
+    case RootInProgress:
+    case RootFatalErrored:
+      {
+        throw Error(formatProdErrorMessage(345));
+      }
+
+    case RootSuspendedWithDelay:
+      {
+        if (includesOnlyTransitions(lanes)) {
+          // This is a transition, so we should exit without committing a
+          // placeholder and without scheduling a timeout. Delay indefinitely
+          // until we receive more data.
+          markRootSuspended(root, lanes, workInProgressDeferredLane);
+          return;
+        } // Commit the placeholder.
+
+
+        break;
+      }
+
+    case RootErrored:
+    case RootSuspended:
+    case RootCompleted:
+      {
+        break;
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(329));
+      }
+  }
+
+  {
+    if (includesOnlyRetries(lanes) && (alwaysThrottleRetries )) {
+      // This render only included retries, no updates. Throttle committing
+      // retries so that we don't show too many loading states too quickly.
+      const msUntilTimeout = globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now(); // Don't bother with a very short suspense time.
+
+      if (msUntilTimeout > 10) {
+        markRootSuspended(root, lanes, workInProgressDeferredLane);
+        const nextLanes = getNextLanes(root, NoLanes);
+
+        if (nextLanes !== NoLanes) {
+          // There's additional work we can do on this root. We might as well
+          // attempt to work on that while we're suspended.
+          return;
+        } // The render is suspended, it hasn't timed out, and there's no
+        // lower priority work to do. Instead of committing the fallback
+        // immediately, wait for more data to arrive.
+        // TODO: Combine retry throttling with Suspensey commits. Right now they
+        // run one after the other.
+
+
+        root.timeoutHandle = scheduleTimeout(commitRootWhenReady.bind(null, root, finishedWork, workInProgressRootRecoverableErrors, workInProgressTransitions, lanes, workInProgressDeferredLane), msUntilTimeout);
+        return;
+      }
+    }
+
+    commitRootWhenReady(root, finishedWork, workInProgressRootRecoverableErrors, workInProgressTransitions, lanes, workInProgressDeferredLane);
+  }
+}
+
+function commitRootWhenReady(root, finishedWork, recoverableErrors, transitions, lanes, spawnedLane) {
+  // TODO: Combine retry throttling with Suspensey commits. Right now they run
+  // one after the other.
+  if (includesOnlyNonUrgentLanes(lanes)) {
+    // Before committing, ask the renderer whether the host tree is ready.
+    // If it's not, we'll wait until it notifies us.
+    startSuspendingCommit(); // This will walk the completed fiber tree and attach listeners to all
+    // the suspensey resources. The renderer is responsible for accumulating
+    // all the load events. This all happens in a single synchronous
+    // transaction, so it track state in its own module scope.
+
+    accumulateSuspenseyCommit(finishedWork); // At the end, ask the renderer if it's ready to commit, or if we should
+    // suspend. If it's not ready, it will return a callback to subscribe to
+    // a ready event.
+
+    const schedulePendingCommit = waitForCommitToBeReady();
+
+    if (schedulePendingCommit !== null) {
+      // NOTE: waitForCommitToBeReady returns a subscribe function so that we
+      // only allocate a function if the commit isn't ready yet. The other
+      // pattern would be to always pass a callback to waitForCommitToBeReady.
+      // Not yet ready to commit. Delay the commit until the renderer notifies
+      // us that it's ready. This will be canceled if we start work on the
+      // root again.
+      root.cancelPendingCommit = schedulePendingCommit(commitRoot.bind(null, root, recoverableErrors, transitions));
+      markRootSuspended(root, lanes, spawnedLane);
+      return;
+    }
+  } // Otherwise, commit immediately.
+
+
+  commitRoot(root, recoverableErrors, transitions, spawnedLane);
+}
+
+function isRenderConsistentWithExternalStores(finishedWork) {
+  // Search the rendered tree for external store reads, and check whether the
+  // stores were mutated in a concurrent event. Intentionally using an iterative
+  // loop instead of recursion so we can exit early.
+  let node = finishedWork;
+
+  while (true) {
+    if (node.flags & StoreConsistency) {
+      const updateQueue = node.updateQueue;
+
+      if (updateQueue !== null) {
+        const checks = updateQueue.stores;
+
+        if (checks !== null) {
+          for (let i = 0; i < checks.length; i++) {
+            const check = checks[i];
+            const getSnapshot = check.getSnapshot;
+            const renderedValue = check.value;
+
+            try {
+              if (!objectIs(getSnapshot(), renderedValue)) {
+                // Found an inconsistent store.
+                return false;
+              }
+            } catch (error) {
+              // If `getSnapshot` throws, return `false`. This will schedule
+              // a re-render, and the error will be rethrown during render.
+              return false;
+            }
+          }
+        }
+      }
+    }
+
+    const child = node.child;
+
+    if (node.subtreeFlags & StoreConsistency && child !== null) {
+      child.return = node;
+      node = child;
+      continue;
+    }
+
+    if (node === finishedWork) {
+      return true;
+    }
+
+    while (node.sibling === null) {
+      if (node.return === null || node.return === finishedWork) {
+        return true;
+      }
+
+      node = node.return;
+    }
+
+    node.sibling.return = node.return;
+    node = node.sibling;
+  } // Flow doesn't know this is unreachable, but eslint does
+  // eslint-disable-next-line no-unreachable
+
+
+  return true;
+}
+
+function markRootSuspended(root, suspendedLanes, spawnedLane) {
+  // When suspending, we should always exclude lanes that were pinged or (more
+  // rarely, since we try to avoid it) updated during the render phase.
+  // TODO: Lol maybe there's a better way to factor this besides this
+  // obnoxiously named function :)
+  suspendedLanes = removeLanes(suspendedLanes, workInProgressRootPingedLanes);
+  suspendedLanes = removeLanes(suspendedLanes, workInProgressRootInterleavedUpdatedLanes);
+  markRootSuspended$1(root, suspendedLanes, spawnedLane);
+} // This is the entry point for synchronous tasks that don't go
+// through Scheduler
+
+
+function performSyncWorkOnRoot(root, lanes) {
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw Error(formatProdErrorMessage(327));
+  }
+
+  const didFlushPassiveEffects = flushPassiveEffects();
+
+  if (didFlushPassiveEffects) {
+    // If passive effects were flushed, exit to the outer work loop in the root
+    // scheduler, so we can recompute the priority.
+    // TODO: We don't actually need this `ensureRootIsScheduled` call because
+    // this path is only reachable if the root is already part of the schedule.
+    // I'm including it only for consistency with the other exit points from
+    // this function. Can address in a subsequent refactor.
+    ensureRootIsScheduled(root);
+    return null;
+  }
+
+  let exitStatus = renderRootSync(root, lanes);
+
+  if (root.tag !== LegacyRoot && exitStatus === RootErrored) {
+    // If something threw an error, try rendering one more time. We'll render
+    // synchronously to block concurrent data mutations, and we'll includes
+    // all pending updates are included. If it still fails after the second
+    // attempt, we'll give up and commit the resulting tree.
+    const originallyAttemptedLanes = lanes;
+    const errorRetryLanes = getLanesToRetrySynchronouslyOnError(root, originallyAttemptedLanes);
+
+    if (errorRetryLanes !== NoLanes) {
+      lanes = errorRetryLanes;
+      exitStatus = recoverFromConcurrentError(root, originallyAttemptedLanes, errorRetryLanes);
+    }
+  }
+
+  if (exitStatus === RootFatalErrored) {
+    const fatalError = workInProgressRootFatalError;
+    prepareFreshStack(root, NoLanes);
+    markRootSuspended(root, lanes, NoLane);
+    ensureRootIsScheduled(root);
+    throw fatalError;
+  }
+
+  if (exitStatus === RootDidNotComplete) {
+    // The render unwound without completing the tree. This happens in special
+    // cases where need to exit the current render without producing a
+    // consistent tree or committing.
+    markRootSuspended(root, lanes, NoLane);
+    ensureRootIsScheduled(root);
+    return null;
+  } // We now have a consistent tree. Because this is a sync render, we
+  // will commit it even if something suspended.
+
+
+  const finishedWork = root.current.alternate;
+  root.finishedWork = finishedWork;
+  root.finishedLanes = lanes;
+  commitRoot(root, workInProgressRootRecoverableErrors, workInProgressTransitions, workInProgressDeferredLane); // Before exiting, make sure there's a callback scheduled for the next
+  // pending level.
+
+  ensureRootIsScheduled(root);
+  return null;
+}
+function flushRoot(root, lanes) {
+  if (lanes !== NoLanes) {
+    upgradePendingLanesToSync(root, lanes);
+    ensureRootIsScheduled(root);
+
+    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
+      resetRenderTimer(); // TODO: For historical reasons this flushes all sync work across all
+      // roots. It shouldn't really matter either way, but we could change this
+      // to only flush the given root.
+
+      flushSyncWorkOnAllRoots();
+    }
+  }
+}
+function getExecutionContext() {
+  return executionContext;
+}
+function batchedUpdates$1(fn, a) {
+  const prevExecutionContext = executionContext;
+  executionContext |= BatchedContext;
+
+  try {
+    return fn(a);
+  } finally {
+    executionContext = prevExecutionContext; // If there were legacy sync updates, flush them at the end of the outer
+    // most batchedUpdates-like method.
+
+    if (executionContext === NoContext && // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.
+    !(false )) {
+      resetRenderTimer();
+      flushSyncWorkOnLegacyRootsOnly();
+    }
+  }
+}
+// Warning, this opts-out of checking the function body.
+// eslint-disable-next-line no-unused-vars
+// eslint-disable-next-line no-redeclare
+// eslint-disable-next-line no-redeclare
+
+function flushSync$1(fn) {
+  // In legacy mode, we flush pending passive effects at the beginning of the
+  // next event, not at the end of the previous one.
+  if (rootWithPendingPassiveEffects !== null && rootWithPendingPassiveEffects.tag === LegacyRoot && (executionContext & (RenderContext | CommitContext)) === NoContext) {
+    flushPassiveEffects();
+  }
+
+  const prevExecutionContext = executionContext;
+  executionContext |= BatchedContext;
+  const prevTransition = ReactCurrentBatchConfig$1.transition;
+  const previousPriority = getCurrentUpdatePriority();
+
+  try {
+    ReactCurrentBatchConfig$1.transition = null;
+    setCurrentUpdatePriority(DiscreteEventPriority);
+
+    if (fn) {
+      return fn();
+    } else {
+      return undefined;
+    }
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+    executionContext = prevExecutionContext; // Flush the immediate callbacks that were scheduled during this batch.
+    // Note that this will happen even if batchedUpdates is higher up
+    // the stack.
+
+    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
+      flushSyncWorkOnAllRoots();
+    }
+  }
+}
+function isInvalidExecutionContextForEventFunction() {
+  // Used to throw if certain APIs are called from the wrong context.
+  return (executionContext & RenderContext) !== NoContext;
+} // This is called by the HiddenContext module when we enter or leave a
+// hidden subtree. The stack logic is managed there because that's the only
+// place that ever modifies it. Which module it lives in doesn't matter for
+// performance because this function will get inlined regardless
+
+function setEntangledRenderLanes(newEntangledRenderLanes) {
+  entangledRenderLanes = newEntangledRenderLanes;
+}
+function getEntangledRenderLanes() {
+  return entangledRenderLanes;
+}
+
+function resetWorkInProgressStack() {
+  if (workInProgress === null) return;
+  let interruptedWork;
+
+  if (workInProgressSuspendedReason === NotSuspended) {
+    // Normal case. Work-in-progress hasn't started yet. Unwind all
+    // its parents.
+    interruptedWork = workInProgress.return;
+  } else {
+    // Work-in-progress is in suspended state. Reset the work loop and unwind
+    // both the suspended fiber and all its parents.
+    resetSuspendedWorkLoopOnUnwind(workInProgress);
+    interruptedWork = workInProgress;
+  }
+
+  while (interruptedWork !== null) {
+    const current = interruptedWork.alternate;
+    unwindInterruptedWork(current, interruptedWork);
+    interruptedWork = interruptedWork.return;
+  }
+
+  workInProgress = null;
+}
+
+function prepareFreshStack(root, lanes) {
+  root.finishedWork = null;
+  root.finishedLanes = NoLanes;
+  const timeoutHandle = root.timeoutHandle;
+
+  if (timeoutHandle !== noTimeout) {
+    // The root previous suspended and scheduled a timeout to commit a fallback
+    // state. Now that we have additional work, cancel the timeout.
+    root.timeoutHandle = noTimeout; // $FlowFixMe[incompatible-call] Complains noTimeout is not a TimeoutID, despite the check above
+
+    cancelTimeout(timeoutHandle);
+  }
+
+  const cancelPendingCommit = root.cancelPendingCommit;
+
+  if (cancelPendingCommit !== null) {
+    root.cancelPendingCommit = null;
+    cancelPendingCommit();
+  }
+
+  resetWorkInProgressStack();
+  workInProgressRoot = root;
+  const rootWorkInProgress = createWorkInProgress(root.current, null);
+  workInProgress = rootWorkInProgress;
+  workInProgressRootRenderLanes = lanes;
+  workInProgressSuspendedReason = NotSuspended;
+  workInProgressThrownValue = null;
+  workInProgressRootDidAttachPingListener = false;
+  workInProgressRootExitStatus = RootInProgress;
+  workInProgressRootFatalError = null;
+  workInProgressRootSkippedLanes = NoLanes;
+  workInProgressRootInterleavedUpdatedLanes = NoLanes;
+  workInProgressRootPingedLanes = NoLanes;
+  workInProgressDeferredLane = NoLane;
+  workInProgressRootConcurrentErrors = null;
+  workInProgressRootRecoverableErrors = null; // Get the lanes that are entangled with whatever we're about to render. We
+  // track these separately so we can distinguish the priority of the render
+  // task from the priority of the lanes it is entangled with. For example, a
+  // transition may not be allowed to finish unless it includes the Sync lane,
+  // which is currently suspended. We should be able to render the Transition
+  // and Sync lane in the same batch, but at Transition priority, because the
+  // Sync lane already suspended.
+
+  entangledRenderLanes = getEntangledLanes(root, lanes);
+  finishQueueingConcurrentUpdates();
+
+  return rootWorkInProgress;
+}
+
+function resetSuspendedWorkLoopOnUnwind(fiber) {
+  // Reset module-level state that was set during the render phase.
+  resetContextDependencies();
+  resetHooksOnUnwind(fiber);
+  resetChildReconcilerOnUnwind();
+}
+
+function handleThrow(root, thrownValue) {
+  // A component threw an exception. Usually this is because it suspended, but
+  // it also includes regular program errors.
+  //
+  // We're either going to unwind the stack to show a Suspense or error
+  // boundary, or we're going to replay the component again. Like after a
+  // promise resolves.
+  //
+  // Until we decide whether we're going to unwind or replay, we should preserve
+  // the current state of the work loop without resetting anything.
+  //
+  // If we do decide to unwind the stack, module-level variables will be reset
+  // in resetSuspendedWorkLoopOnUnwind.
+  // These should be reset immediately because they're only supposed to be set
+  // when React is executing user code.
+  resetHooksAfterThrow();
+  ReactCurrentOwner.current = null;
+
+  if (thrownValue === SuspenseException) {
+    // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown value
+    // to be a thenable, because before `use` existed that was the (unstable)
+    // API for suspending. This implementation detail can change later, once we
+    // deprecate the old API in favor of `use`.
+    thrownValue = getSuspendedThenable();
+    workInProgressSuspendedReason = shouldRemainOnPreviousScreen() && // Check if there are other pending updates that might possibly unblock this
+    // component from suspending. This mirrors the check in
+    // renderDidSuspendDelayIfPossible. We should attempt to unify them somehow.
+    // TODO: Consider unwinding immediately, using the
+    // SuspendedOnHydration mechanism.
+    !includesNonIdleWork(workInProgressRootSkippedLanes) && !includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes) ? // Suspend work loop until data resolves
+    SuspendedOnData : // Don't suspend work loop, except to check if the data has
+    // immediately resolved (i.e. in a microtask). Otherwise, trigger the
+    // nearest Suspense fallback.
+    SuspendedOnImmediate;
+  } else if (thrownValue === SuspenseyCommitException) {
+    thrownValue = getSuspendedThenable();
+    workInProgressSuspendedReason = SuspendedOnInstance;
+  } else if (thrownValue === SelectiveHydrationException) {
+    // An update flowed into a dehydrated boundary. Before we can apply the
+    // update, we need to finish hydrating. Interrupt the work-in-progress
+    // render so we can restart at the hydration lane.
+    //
+    // The ideal implementation would be able to switch contexts without
+    // unwinding the current stack.
+    //
+    // We could name this something more general but as of now it's the only
+    // case where we think this should happen.
+    workInProgressSuspendedReason = SuspendedOnHydration;
+  } else {
+    // This is a regular error.
+    const isWakeable = thrownValue !== null && typeof thrownValue === 'object' && typeof thrownValue.then === 'function';
+    workInProgressSuspendedReason = isWakeable ? // A wakeable object was thrown by a legacy Suspense implementation.
+    // This has slightly different behavior than suspending with `use`.
+    SuspendedOnDeprecatedThrowPromise : // This is a regular error. If something earlier in the component already
+    // suspended, we must clear the thenable state to unblock the work loop.
+    SuspendedOnError;
+  }
+
+  workInProgressThrownValue = thrownValue;
+  const erroredWork = workInProgress;
+
+  if (erroredWork === null) {
+    // This is a fatal error
+    workInProgressRootExitStatus = RootFatalErrored;
+    workInProgressRootFatalError = thrownValue;
+    return;
+  }
+}
+
+function shouldRemainOnPreviousScreen() {
+  // This is asking whether it's better to suspend the transition and remain
+  // on the previous screen, versus showing a fallback as soon as possible. It
+  // takes into account both the priority of render and also whether showing a
+  // fallback would produce a desirable user experience.
+  const handler = getSuspenseHandler();
+
+  if (handler === null) {
+    // There's no Suspense boundary that can provide a fallback. We have no
+    // choice but to remain on the previous screen.
+    // NOTE: We do this even for sync updates, for lack of any better option. In
+    // the future, we may change how we handle this, like by putting the whole
+    // root into a "detached" mode.
+    return true;
+  } // TODO: Once `use` has fully replaced the `throw promise` pattern, we should
+  // be able to remove the equivalent check in finishConcurrentRender, and rely
+  // just on this one.
+
+
+  if (includesOnlyTransitions(workInProgressRootRenderLanes)) {
+    if (getShellBoundary() === null) {
+      // We're rendering inside the "shell" of the app. Activating the nearest
+      // fallback would cause visible content to disappear. It's better to
+      // suspend the transition and remain on the previous screen.
+      return true;
+    } else {
+      // We're rendering content that wasn't part of the previous screen.
+      // Rather than block the transition, it's better to show a fallback as
+      // soon as possible. The appearance of any nested fallbacks will be
+      // throttled to avoid jank.
+      return false;
+    }
+  }
+
+  if (includesOnlyRetries(workInProgressRootRenderLanes) || // In this context, an OffscreenLane counts as a Retry
+  // TODO: It's become increasingly clear that Retries and Offscreen are
+  // deeply connected. They probably can be unified further.
+  includesSomeLane(workInProgressRootRenderLanes, OffscreenLane)) {
+    // During a retry, we can suspend rendering if the nearest Suspense boundary
+    // is the boundary of the "shell", because we're guaranteed not to block
+    // any new content from appearing.
+    //
+    // The reason we must check if this is a retry is because it guarantees
+    // that suspending the work loop won't block an actual update, because
+    // retries don't "update" anything; they fill in fallbacks that were left
+    // behind by a previous transition.
+    return handler === getShellBoundary();
+  } // For all other Lanes besides Transitions and Retries, we should not wait
+  // for the data to load.
+
+
+  return false;
+}
+
+function pushDispatcher(container) {
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = ContextOnlyDispatcher;
+
+  if (prevDispatcher === null) {
+    // The React isomorphic package does not include a default dispatcher.
+    // Instead the first renderer will lazily attach one, in order to give
+    // nicer error messages.
+    return ContextOnlyDispatcher;
+  } else {
+    return prevDispatcher;
+  }
+}
+
+function popDispatcher(prevDispatcher) {
+  ReactCurrentDispatcher.current = prevDispatcher;
+}
+
+function pushCacheDispatcher() {
+  {
+    const prevCacheDispatcher = ReactCurrentCache.current;
+    ReactCurrentCache.current = DefaultCacheDispatcher;
+    return prevCacheDispatcher;
+  }
+}
+
+function popCacheDispatcher(prevCacheDispatcher) {
+  {
+    ReactCurrentCache.current = prevCacheDispatcher;
+  }
+}
+
+function markCommitTimeOfFallback() {
+  globalMostRecentFallbackTime = now();
+}
+function markSkippedUpdateLanes(lane) {
+  workInProgressRootSkippedLanes = mergeLanes(lane, workInProgressRootSkippedLanes);
+}
+function renderDidSuspend() {
+  if (workInProgressRootExitStatus === RootInProgress) {
+    workInProgressRootExitStatus = RootSuspended;
+  }
+}
+function renderDidSuspendDelayIfPossible() {
+  workInProgressRootExitStatus = RootSuspendedWithDelay; // Check if there are updates that we skipped tree that might have unblocked
+  // this render.
+
+  if ((includesNonIdleWork(workInProgressRootSkippedLanes) || includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes)) && workInProgressRoot !== null) {
+    // Mark the current render as suspended so that we switch to working on
+    // the updates that were skipped. Usually we only suspend at the end of
+    // the render phase.
+    // TODO: We should probably always mark the root as suspended immediately
+    // (inside this function), since by suspending at the end of the render
+    // phase introduces a potential mistake where we suspend lanes that were
+    // pinged or updated while we were rendering.
+    // TODO: Consider unwinding immediately, using the
+    // SuspendedOnHydration mechanism.
+    markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes, workInProgressDeferredLane);
+  }
+}
+function renderDidError(error) {
+  if (workInProgressRootExitStatus !== RootSuspendedWithDelay) {
+    workInProgressRootExitStatus = RootErrored;
+  }
+
+  if (workInProgressRootConcurrentErrors === null) {
+    workInProgressRootConcurrentErrors = [error];
+  } else {
+    workInProgressRootConcurrentErrors.push(error);
+  }
+} // Called during render to determine if anything has suspended.
+// Returns false if we're not sure.
+
+function renderHasNotSuspendedYet() {
+  // If something errored or completed, we can't really be sure,
+  // so those are false.
+  return workInProgressRootExitStatus === RootInProgress;
+} // TODO: Over time, this function and renderRootConcurrent have become more
+// and more similar. Not sure it makes sense to maintain forked paths. Consider
+// unifying them again.
+
+function renderRootSync(root, lanes) {
+  const prevExecutionContext = executionContext;
+  executionContext |= RenderContext;
+  const prevDispatcher = pushDispatcher();
+  const prevCacheDispatcher = pushCacheDispatcher(); // If the root or lanes have changed, throw out the existing stack
+  // and prepare a fresh one. Otherwise we'll continue where we left off.
+
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
+
+    workInProgressTransitions = getTransitionsForLanes();
+    prepareFreshStack(root, lanes);
+  }
+
+  let didSuspendInShell = false;
+
+  outer: do {
+    try {
+      if (workInProgressSuspendedReason !== NotSuspended && workInProgress !== null) {
+        // The work loop is suspended. During a synchronous render, we don't
+        // yield to the main thread. Immediately unwind the stack. This will
+        // trigger either a fallback or an error boundary.
+        // TODO: For discrete and "default" updates (anything that's not
+        // flushSync), we want to wait for the microtasks the flush before
+        // unwinding. Will probably implement this using renderRootConcurrent,
+        // or merge renderRootSync and renderRootConcurrent into the same
+        // function and fork the behavior some other way.
+        const unitOfWork = workInProgress;
+        const thrownValue = workInProgressThrownValue;
+
+        switch (workInProgressSuspendedReason) {
+          case SuspendedOnHydration:
+            {
+              // Selective hydration. An update flowed into a dehydrated tree.
+              // Interrupt the current render so the work loop can switch to the
+              // hydration lane.
+              resetWorkInProgressStack();
+              workInProgressRootExitStatus = RootDidNotComplete;
+              break outer;
+            }
+
+          case SuspendedOnImmediate:
+          case SuspendedOnData:
+            {
+              if (!didSuspendInShell && getSuspenseHandler() === null) {
+                didSuspendInShell = true;
+              } // Intentional fallthrough
+
+            }
+
+          default:
+            {
+              // Unwind then continue with the normal work loop.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              break;
+            }
+        }
+      }
+
+      workLoopSync();
+      break;
+    } catch (thrownValue) {
+      handleThrow(root, thrownValue);
+    }
+  } while (true); // Check if something suspended in the shell. We use this to detect an
+  // infinite ping loop caused by an uncached promise.
+  //
+  // Only increment this counter once per synchronous render attempt across the
+  // whole tree. Even if there are many sibling components that suspend, this
+  // counter only gets incremented once.
+
+
+  if (didSuspendInShell) {
+    root.shellSuspendCounter++;
+  }
+
+  resetContextDependencies();
+  executionContext = prevExecutionContext;
+  popDispatcher(prevDispatcher);
+  popCacheDispatcher(prevCacheDispatcher);
+
+  if (workInProgress !== null) {
+    // This is a sync render, so we should have finished the whole tree.
+    throw Error(formatProdErrorMessage(261));
+  }
+
+
+  workInProgressRoot = null;
+  workInProgressRootRenderLanes = NoLanes; // It's safe to process the queue now that the render phase is complete.
+
+  finishQueueingConcurrentUpdates();
+  return workInProgressRootExitStatus;
+} // The work loop is an extremely hot path. Tell Closure not to inline it.
+
+/** @noinline */
+
+
+function workLoopSync() {
+  // Perform work without checking if we need to yield between fiber.
+  while (workInProgress !== null) {
+    performUnitOfWork(workInProgress);
+  }
+}
+
+function renderRootConcurrent(root, lanes) {
+  const prevExecutionContext = executionContext;
+  executionContext |= RenderContext;
+  const prevDispatcher = pushDispatcher();
+  const prevCacheDispatcher = pushCacheDispatcher(); // If the root or lanes have changed, throw out the existing stack
+  // and prepare a fresh one. Otherwise we'll continue where we left off.
+
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
+
+    workInProgressTransitions = getTransitionsForLanes();
+    resetRenderTimer();
+    prepareFreshStack(root, lanes);
+  }
+
+  outer: do {
+    try {
+      if (workInProgressSuspendedReason !== NotSuspended && workInProgress !== null) {
+        // The work loop is suspended. We need to either unwind the stack or
+        // replay the suspended component.
+        const unitOfWork = workInProgress;
+        const thrownValue = workInProgressThrownValue;
+
+        resumeOrUnwind: switch (workInProgressSuspendedReason) {
+          case SuspendedOnError:
+            {
+              // Unwind then continue with the normal work loop.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              break;
+            }
+
+          case SuspendedOnData:
+            {
+              const thenable = thrownValue;
+
+              if (isThenableResolved(thenable)) {
+                // The data resolved. Try rendering the component again.
+                workInProgressSuspendedReason = NotSuspended;
+                workInProgressThrownValue = null;
+                replaySuspendedUnitOfWork(unitOfWork);
+                break;
+              } // The work loop is suspended on data. We should wait for it to
+              // resolve before continuing to render.
+              // TODO: Handle the case where the promise resolves synchronously.
+              // Usually this is handled when we instrument the promise to add a
+              // `status` field, but if the promise already has a status, we won't
+              // have added a listener until right here.
+
+
+              const onResolution = () => {
+                // Check if the root is still suspended on this promise.
+                if (workInProgressSuspendedReason === SuspendedOnData && workInProgressRoot === root) {
+                  // Mark the root as ready to continue rendering.
+                  workInProgressSuspendedReason = SuspendedAndReadyToContinue;
+                } // Ensure the root is scheduled. We should do this even if we're
+                // currently working on a different root, so that we resume
+                // rendering later.
+
+
+                ensureRootIsScheduled(root);
+              };
+
+              thenable.then(onResolution, onResolution);
+              break outer;
+            }
+
+          case SuspendedOnImmediate:
+            {
+              // If this fiber just suspended, it's possible the data is already
+              // cached. Yield to the main thread to give it a chance to ping. If
+              // it does, we can retry immediately without unwinding the stack.
+              workInProgressSuspendedReason = SuspendedAndReadyToContinue;
+              break outer;
+            }
+
+          case SuspendedOnInstance:
+            {
+              workInProgressSuspendedReason = SuspendedOnInstanceAndReadyToContinue;
+              break outer;
+            }
+
+          case SuspendedAndReadyToContinue:
+            {
+              const thenable = thrownValue;
+
+              if (isThenableResolved(thenable)) {
+                // The data resolved. Try rendering the component again.
+                workInProgressSuspendedReason = NotSuspended;
+                workInProgressThrownValue = null;
+                replaySuspendedUnitOfWork(unitOfWork);
+              } else {
+                // Otherwise, unwind then continue with the normal work loop.
+                workInProgressSuspendedReason = NotSuspended;
+                workInProgressThrownValue = null;
+                throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              }
+
+              break;
+            }
+
+          case SuspendedOnInstanceAndReadyToContinue:
+            {
+              switch (workInProgress.tag) {
+                case HostComponent:
+                case HostHoistable:
+                case HostSingleton:
+                  {
+                    // Before unwinding the stack, check one more time if the
+                    // instance is ready. It may have loaded when React yielded to
+                    // the main thread.
+                    // Assigning this to a constant so Flow knows the binding won't
+                    // be mutated by `preloadInstance`.
+                    const hostFiber = workInProgress;
+                    const type = hostFiber.type;
+                    const props = hostFiber.pendingProps;
+                    const isReady = preloadInstance(type, props);
+
+                    if (isReady) {
+                      // The data resolved. Resume the work loop as if nothing
+                      // suspended. Unlike when a user component suspends, we don't
+                      // have to replay anything because the host fiber
+                      // already completed.
+                      workInProgressSuspendedReason = NotSuspended;
+                      workInProgressThrownValue = null;
+                      const sibling = hostFiber.sibling;
+
+                      if (sibling !== null) {
+                        workInProgress = sibling;
+                      } else {
+                        const returnFiber = hostFiber.return;
+
+                        if (returnFiber !== null) {
+                          workInProgress = returnFiber;
+                          completeUnitOfWork(returnFiber);
+                        } else {
+                          workInProgress = null;
+                        }
+                      }
+
+                      break resumeOrUnwind;
+                    }
+
+                    break;
+                  }
+
+                default:
+                  {
+                    // This will fail gracefully but it's not correct, so log a
+                    // warning in dev.
+                    if (false) ;
+
+                    break;
+                  }
+              } // Otherwise, unwind then continue with the normal work loop.
+
+
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              break;
+            }
+
+          case SuspendedOnDeprecatedThrowPromise:
+            {
+              // Suspended by an old implementation that uses the `throw promise`
+              // pattern. The newer replaying behavior can cause subtle issues
+              // like infinite ping loops. So we maintain the old behavior and
+              // always unwind.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              break;
+            }
+
+          case SuspendedOnHydration:
+            {
+              // Selective hydration. An update flowed into a dehydrated tree.
+              // Interrupt the current render so the work loop can switch to the
+              // hydration lane.
+              resetWorkInProgressStack();
+              workInProgressRootExitStatus = RootDidNotComplete;
+              break outer;
+            }
+
+          default:
+            {
+              throw Error(formatProdErrorMessage(462));
+            }
+        }
+      }
+
+      if (false && ReactCurrentActQueue.current !== null) ; else {
+        workLoopConcurrent();
+      }
+
+      break;
+    } catch (thrownValue) {
+      handleThrow(root, thrownValue);
+    }
+  } while (true);
+
+  resetContextDependencies();
+  popDispatcher(prevDispatcher);
+  popCacheDispatcher(prevCacheDispatcher);
+  executionContext = prevExecutionContext;
+
+
+  if (workInProgress !== null) {
+
+    return RootInProgress;
+  } else {
+
+
+    workInProgressRoot = null;
+    workInProgressRootRenderLanes = NoLanes; // It's safe to process the queue now that the render phase is complete.
+
+    finishQueueingConcurrentUpdates(); // Return the final exit status.
+
+    return workInProgressRootExitStatus;
+  }
+}
+/** @noinline */
+
+
+function workLoopConcurrent() {
+  // Perform work until Scheduler asks us to yield
+  while (workInProgress !== null && !shouldYield()) {
+    // $FlowFixMe[incompatible-call] found when upgrading Flow
+    performUnitOfWork(workInProgress);
+  }
+}
+
+function performUnitOfWork(unitOfWork) {
+  // The current, flushed, state of this fiber is the alternate. Ideally
+  // nothing should rely on this, but relying on it here means that we don't
+  // need an additional field on the work in progress.
+  const current = unitOfWork.alternate;
+  let next;
+
+  {
+    next = beginWork(current, unitOfWork, entangledRenderLanes);
+  }
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+
+  if (next === null) {
+    // If this doesn't spawn new work, complete the current work.
+    completeUnitOfWork(unitOfWork);
+  } else {
+    workInProgress = next;
+  }
+
+  ReactCurrentOwner.current = null;
+}
+
+function replaySuspendedUnitOfWork(unitOfWork) {
+  // This is a fork of performUnitOfWork specifcally for replaying a fiber that
+  // just suspended.
+  //
+  const current = unitOfWork.alternate;
+  let next;
+
+  switch (unitOfWork.tag) {
+    case IndeterminateComponent:
+      {
+        // Because it suspended with `use`, we can assume it's a
+        // function component.
+        unitOfWork.tag = FunctionComponent; // Fallthrough to the next branch.
+      }
+
+    case SimpleMemoComponent:
+    case FunctionComponent:
+      {
+        // Resolve `defaultProps`. This logic is copied from `beginWork`.
+        // TODO: Consider moving this switch statement into that module. Also,
+        // could maybe use this as an opportunity to say `use` doesn't work with
+        // `defaultProps` :)
+        const Component = unitOfWork.type;
+        const unresolvedProps = unitOfWork.pendingProps;
+        const resolvedProps = unitOfWork.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        let context;
+
+        {
+          const unmaskedContext = getUnmaskedContext(unitOfWork, Component, true);
+          context = getMaskedContext(unitOfWork, unmaskedContext);
+        }
+
+        next = replayFunctionComponent(current, unitOfWork, resolvedProps, Component, context, workInProgressRootRenderLanes);
+        break;
+      }
+
+    case ForwardRef:
+      {
+        // Resolve `defaultProps`. This logic is copied from `beginWork`.
+        // TODO: Consider moving this switch statement into that module. Also,
+        // could maybe use this as an opportunity to say `use` doesn't work with
+        // `defaultProps` :)
+        const Component = unitOfWork.type.render;
+        const unresolvedProps = unitOfWork.pendingProps;
+        const resolvedProps = unitOfWork.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        next = replayFunctionComponent(current, unitOfWork, resolvedProps, Component, unitOfWork.ref, workInProgressRootRenderLanes);
+        break;
+      }
+
+    case HostComponent:
+      {
+        // Some host components are stateful (that's how we implement form
+        // actions) but we don't bother to reuse the memoized state because it's
+        // not worth the extra code. The main reason to reuse the previous hooks
+        // is to reuse uncached promises, but we happen to know that the only
+        // promises that a host component might suspend on are definitely cached
+        // because they are controlled by us. So don't bother.
+        resetHooksOnUnwind(unitOfWork); // Fallthrough to the next branch.
+      }
+
+    default:
+      {
+        // Other types besides function components are reset completely before
+        // being replayed. Currently this only happens when a Usable type is
+        // reconciled — the reconciler will suspend.
+        //
+        // We reset the fiber back to its original state; however, this isn't
+        // a full "unwind" because we're going to reuse the promises that were
+        // reconciled previously. So it's intentional that we don't call
+        // resetSuspendedWorkLoopOnUnwind here.
+        unwindInterruptedWork(current, unitOfWork);
+        unitOfWork = workInProgress = resetWorkInProgress(unitOfWork, entangledRenderLanes);
+        next = beginWork(current, unitOfWork, entangledRenderLanes);
+        break;
+      }
+  }
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+
+  if (next === null) {
+    // If this doesn't spawn new work, complete the current work.
+    completeUnitOfWork(unitOfWork);
+  } else {
+    workInProgress = next;
+  }
+
+  ReactCurrentOwner.current = null;
+}
+
+function throwAndUnwindWorkLoop(unitOfWork, thrownValue) {
+  // This is a fork of performUnitOfWork specifcally for unwinding a fiber
+  // that threw an exception.
+  //
+  // Return to the normal work loop. This will unwind the stack, and potentially
+  // result in showing a fallback.
+  resetSuspendedWorkLoopOnUnwind(unitOfWork);
+  const returnFiber = unitOfWork.return;
+
+  if (returnFiber === null || workInProgressRoot === null) {
+    // Expected to be working on a non-root fiber. This is a fatal error
+    // because there's no ancestor that can handle it; the root is
+    // supposed to capture all errors that weren't caught by an error
+    // boundary.
+    workInProgressRootExitStatus = RootFatalErrored;
+    workInProgressRootFatalError = thrownValue; // Set `workInProgress` to null. This represents advancing to the next
+    // sibling, or the parent if there are no siblings. But since the root
+    // has no siblings nor a parent, we set it to null. Usually this is
+    // handled by `completeUnitOfWork` or `unwindWork`, but since we're
+    // intentionally not calling those, we need set it here.
+    // TODO: Consider calling `unwindWork` to pop the contexts.
+
+    workInProgress = null;
+    return;
+  }
+
+  try {
+    // Find and mark the nearest Suspense or error boundary that can handle
+    // this "exception".
+    throwException(workInProgressRoot, returnFiber, unitOfWork, thrownValue, workInProgressRootRenderLanes);
+  } catch (error) {
+    // We had trouble processing the error. An example of this happening is
+    // when accessing the `componentDidCatch` property of an error boundary
+    // throws an error. A weird edge case. There's a regression test for this.
+    // To prevent an infinite loop, bubble the error up to the next parent.
+    workInProgress = returnFiber;
+    throw error;
+  }
+
+  if (unitOfWork.flags & Incomplete) {
+    // Unwind the stack until we reach the nearest boundary.
+    unwindUnitOfWork(unitOfWork);
+  } else {
+    // Although the fiber suspended, we're intentionally going to commit it in
+    // an inconsistent state. We can do this safely in cases where we know the
+    // inconsistent tree will be hidden.
+    //
+    // This currently only applies to Legacy Suspense implementation, but we may
+    // port a version of this to concurrent roots, too, when performing a
+    // synchronous render. Because that will allow us to mutate the tree as we
+    // go instead of buffering mutations until the end. Though it's unclear if
+    // this particular path is how that would be implemented.
+    completeUnitOfWork(unitOfWork);
+  }
+}
+
+function completeUnitOfWork(unitOfWork) {
+  // Attempt to complete the current unit of work, then move to the next
+  // sibling. If there are no more siblings, return to the parent fiber.
+  let completedWork = unitOfWork;
+
+  do {
+    // nothing should rely on this, but relying on it here means that we don't
+    // need an additional field on the work in progress.
+
+
+    const current = completedWork.alternate;
+    const returnFiber = completedWork.return;
+    let next;
+
+    {
+      next = completeWork(current, completedWork, entangledRenderLanes);
+    }
+
+    if (next !== null) {
+      // Completing this fiber spawned new work. Work on that next.
+      workInProgress = next;
+      return;
+    }
+
+    const siblingFiber = completedWork.sibling;
+
+    if (siblingFiber !== null) {
+      // If there is more work to do in this returnFiber, do that next.
+      workInProgress = siblingFiber;
+      return;
+    } // Otherwise, return to the parent
+    // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+    completedWork = returnFiber; // Update the next thing we're working on in case something throws.
+
+    workInProgress = completedWork;
+  } while (completedWork !== null); // We've reached the root.
+
+
+  if (workInProgressRootExitStatus === RootInProgress) {
+    workInProgressRootExitStatus = RootCompleted;
+  }
+}
+
+function unwindUnitOfWork(unitOfWork) {
+  let incompleteWork = unitOfWork;
+
+  do {
+    // The current, flushed, state of this fiber is the alternate. Ideally
+    // nothing should rely on this, but relying on it here means that we don't
+    // need an additional field on the work in progress.
+    const current = incompleteWork.alternate; // This fiber did not complete because something threw. Pop values off
+    // the stack without entering the complete phase. If this is a boundary,
+    // capture values if possible.
+
+    const next = unwindWork(current, incompleteWork); // Because this fiber did not complete, don't reset its lanes.
+
+    if (next !== null) {
+      // Found a boundary that can handle this exception. Re-renter the
+      // begin phase. This branch will return us to the normal work loop.
+      //
+      // Since we're restarting, remove anything that is not a host effect
+      // from the effect tag.
+      next.flags &= HostEffectMask;
+      workInProgress = next;
+      return;
+    } // Keep unwinding until we reach either a boundary or the root.
+    // of the node being unwound, we should be able to reset node itself as we
+    // unwind the stack. Saves an additional null check.
+
+
+    const returnFiber = incompleteWork.return;
+
+    if (returnFiber !== null) {
+      // Mark the parent fiber as incomplete and clear its subtree flags.
+      // TODO: Once we stop prerendering siblings, we may be able to get rid of
+      // the Incomplete flag because unwinding to the nearest boundary will
+      // happen synchronously.
+      returnFiber.flags |= Incomplete;
+      returnFiber.subtreeFlags = NoFlags$1;
+      returnFiber.deletions = null;
+    } // NOTE: If we re-enable sibling prerendering in some cases, here we
+    // would switch to the normal completion path: check if a sibling
+    // exists, and if so, begin work on it.
+    // Otherwise, return to the parent
+    // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+    incompleteWork = returnFiber; // Update the next thing we're working on in case something throws.
+
+    workInProgress = incompleteWork;
+  } while (incompleteWork !== null); // We've unwound all the way to the root.
+
+
+  workInProgressRootExitStatus = RootDidNotComplete;
+  workInProgress = null;
+}
+
+function commitRoot(root, recoverableErrors, transitions, spawnedLane) {
+  // TODO: This no longer makes any sense. We already wrap the mutation and
+  // layout phases. Should be able to remove.
+  const previousUpdateLanePriority = getCurrentUpdatePriority();
+  const prevTransition = ReactCurrentBatchConfig$1.transition;
+
+  try {
+    ReactCurrentBatchConfig$1.transition = null;
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    commitRootImpl(root, recoverableErrors, transitions, previousUpdateLanePriority, spawnedLane);
+  } finally {
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+    setCurrentUpdatePriority(previousUpdateLanePriority);
+  }
+
+  return null;
+}
+
+function commitRootImpl(root, recoverableErrors, transitions, renderPriorityLevel, spawnedLane) {
+  do {
+    // `flushPassiveEffects` will call `flushSyncUpdateQueue` at the end, which
+    // means `flushPassiveEffects` will sometimes result in additional
+    // passive effects. So we need to keep flushing in a loop until there are
+    // no more pending effects.
+    // TODO: Might be better if `flushPassiveEffects` did not automatically
+    // flush synchronous work at the end, to avoid factoring hazards like this.
+    flushPassiveEffects();
+  } while (rootWithPendingPassiveEffects !== null);
+
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw Error(formatProdErrorMessage(327));
+  }
+
+  const finishedWork = root.finishedWork;
+  const lanes = root.finishedLanes;
+
+  if (finishedWork === null) {
+
+    return null;
+  }
+
+  root.finishedWork = null;
+  root.finishedLanes = NoLanes;
+
+  if (finishedWork === root.current) {
+    throw Error(formatProdErrorMessage(177));
+  } // commitRoot never returns a continuation; it always finishes synchronously.
+  // So we can clear these now to allow a new callback to be scheduled.
+
+
+  root.callbackNode = null;
+  root.callbackPriority = NoLane;
+  root.cancelPendingCommit = null; // Check which lanes no longer have any work scheduled on them, and mark
+  // those as finished.
+
+  let remainingLanes = mergeLanes(finishedWork.lanes, finishedWork.childLanes); // Make sure to account for lanes that were updated by a concurrent event
+  // during the render phase; don't mark them as finished.
+
+  const concurrentlyUpdatedLanes = getConcurrentlyUpdatedLanes();
+  remainingLanes = mergeLanes(remainingLanes, concurrentlyUpdatedLanes);
+  markRootFinished(root, remainingLanes, spawnedLane);
+
+  if (root === workInProgressRoot) {
+    // We can reset these now that they are finished.
+    workInProgressRoot = null;
+    workInProgress = null;
+    workInProgressRootRenderLanes = NoLanes;
+  } // If there are pending passive effects, schedule a callback to process them.
+  // Do this as early as possible, so it is queued before anything else that
+  // might get scheduled in the commit phase. (See #16714.)
+  // TODO: Delete all other places that schedule the passive effect callback
+  // They're redundant.
+
+
+  if ((finishedWork.subtreeFlags & PassiveMask) !== NoFlags$1 || (finishedWork.flags & PassiveMask) !== NoFlags$1) {
+    if (!rootDoesHavePassiveEffects) {
+      rootDoesHavePassiveEffects = true;
+      pendingPassiveEffectsRemainingLanes = remainingLanes; // workInProgressTransitions might be overwritten, so we want
+      // to store it in pendingPassiveTransitions until they get processed
+      // We need to pass this through as an argument to commitRoot
+      // because workInProgressTransitions might have changed between
+      // the previous render and commit if we throttle the commit
+      // with setTimeout
+
+      pendingPassiveTransitions = transitions;
+      scheduleCallback(NormalPriority$1, () => {
+        flushPassiveEffects(); // This render triggered passive effects: release the root cache pool
+        // *after* passive effects fire to avoid freeing a cache pool that may
+        // be referenced by a node in the tree (HostRoot, Cache boundary etc)
+
+        return null;
+      });
+    }
+  } // Check if there are any effects in the whole tree.
+  // TODO: This is left over from the effect list implementation, where we had
+  // to check for the existence of `firstEffect` to satisfy Flow. I think the
+  // only other reason this optimization exists is because it affects profiling.
+  // Reconsider whether this is necessary.
+
+
+  const subtreeHasEffects = (finishedWork.subtreeFlags & (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !== NoFlags$1;
+  const rootHasEffect = (finishedWork.flags & (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !== NoFlags$1;
+
+  if (subtreeHasEffects || rootHasEffect) {
+    const prevTransition = ReactCurrentBatchConfig$1.transition;
+    ReactCurrentBatchConfig$1.transition = null;
+    const previousPriority = getCurrentUpdatePriority();
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    const prevExecutionContext = executionContext;
+    executionContext |= CommitContext; // Reset this to null before calling lifecycles
+
+    ReactCurrentOwner.current = null; // The commit phase is broken into several sub-phases. We do a separate pass
+    // of the effect list for each phase: all mutation effects come before all
+    // layout effects, and so on.
+    // The first phase a "before mutation" phase. We use this phase to read the
+    // state of the host tree right before we mutate it. This is where
+    // getSnapshotBeforeUpdate is called.
+
+    commitBeforeMutationEffects(root, finishedWork);
+
+
+    commitMutationEffects(root, finishedWork);
+
+    resetAfterCommit(); // The work-in-progress tree is now the current tree. This must come after
+    // the mutation phase, so that the previous tree is still current during
+    // componentWillUnmount, but before the layout phase, so that the finished
+    // work is current during componentDidMount/Update.
+
+    root.current = finishedWork; // The next phase is the layout phase, where we call effects that read
+
+    commitLayoutEffects(finishedWork, root);
+    // opportunity to paint.
+
+
+    requestPaint();
+    executionContext = prevExecutionContext; // Reset the priority to the previous non-sync value.
+
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+  } else {
+    // No effects.
+    root.current = finishedWork; // Measure these anyway so the flamegraph explicitly shows that there were
+  }
+
+  if (rootDoesHavePassiveEffects) {
+    // This commit has passive effects. Stash a reference to them. But don't
+    // schedule a callback until after flushing layout work.
+    rootDoesHavePassiveEffects = false;
+    rootWithPendingPassiveEffects = root;
+    pendingPassiveEffectsLanes = lanes;
+  } else {
+    // There were no passive effects, so we can immediately release the cache
+    // pool for this render.
+    releaseRootPooledCache(root, remainingLanes);
+  } // Read this again, since an effect might have updated it
+
+
+  remainingLanes = root.pendingLanes; // Check if there's remaining work on this root
+  // TODO: This is part of the `componentDidCatch` implementation. Its purpose
+  // is to detect whether something might have called setState inside
+  // `componentDidCatch`. The mechanism is known to be flawed because `setState`
+  // inside `componentDidCatch` is itself flawed — that's why we recommend
+  // `getDerivedStateFromError` instead. However, it could be improved by
+  // checking if remainingLanes includes Sync work, instead of whether there's
+  // any work remaining at all (which would also include stuff like Suspense
+  // retries or transitions). It's been like this for a while, though, so fixing
+  // it probably isn't that urgent.
+
+  if (remainingLanes === NoLanes) {
+    // If there's no remaining work, we can clear the set of already failed
+    // error boundaries.
+    legacyErrorBoundariesThatAlreadyFailed = null;
+  }
+
+  onCommitRoot(finishedWork.stateNode, renderPriorityLevel);
+  // additional work on this root is scheduled.
+
+
+  ensureRootIsScheduled(root);
+
+  if (recoverableErrors !== null) {
+    // There were errors during this render, but recovered from them without
+    // needing to surface it to the UI. We log them here.
+    const onRecoverableError = root.onRecoverableError;
+
+    for (let i = 0; i < recoverableErrors.length; i++) {
+      const recoverableError = recoverableErrors[i];
+      const errorInfo = makeErrorInfo(recoverableError.digest, recoverableError.stack);
+      onRecoverableError(recoverableError.value, errorInfo);
+    }
+  }
+
+  if (hasUncaughtError) {
+    hasUncaughtError = false;
+    const error = firstUncaughtError;
+    firstUncaughtError = null;
+    throw error;
+  } // If the passive effects are the result of a discrete render, flush them
+  // synchronously at the end of the current task so that the result is
+  // immediately observable. Otherwise, we assume that they are not
+  // order-dependent and do not need to be observed by external systems, so we
+  // can wait until after paint.
+  // TODO: We can optimize this by not scheduling the callback earlier. Since we
+  // currently schedule the callback in multiple places, will wait until those
+  // are consolidated.
+
+
+  if (includesSyncLane(pendingPassiveEffectsLanes) && root.tag !== LegacyRoot) {
+    flushPassiveEffects();
+  } // Read this again, since a passive effect might have updated it
+
+
+  remainingLanes = root.pendingLanes; // Check if this render scheduled a cascading synchronous update. This is a
+  // heurstic to detect infinite update loops. We are intentionally excluding
+  // hydration lanes in this check, because render triggered by selective
+  // hydration is conceptually not an update.
+
+  if ( // Was the finished render the result of an update (not hydration)?
+  includesSomeLane(lanes, UpdateLanes) && // Did it schedule a sync update?
+  includesSomeLane(remainingLanes, SyncUpdateLanes)) {
+    // finishing. If there are too many, it indicates an infinite update loop.
+
+
+    if (root === rootWithNestedUpdates) {
+      nestedUpdateCount++;
+    } else {
+      nestedUpdateCount = 0;
+      rootWithNestedUpdates = root;
+    }
+  } else {
+    nestedUpdateCount = 0;
+  } // If layout work was scheduled, flush it now.
+
+
+  flushSyncWorkOnAllRoots();
+
+  return null;
+}
+
+function makeErrorInfo(digest, componentStack) {
+  {
+    return {
+      digest,
+      componentStack
+    };
+  }
+}
+
+function releaseRootPooledCache(root, remainingLanes) {
+  {
+    const pooledCacheLanes = root.pooledCacheLanes &= remainingLanes;
+
+    if (pooledCacheLanes === NoLanes) {
+      // None of the remaining work relies on the cache pool. Clear it so
+      // subsequent requests get a new cache
+      const pooledCache = root.pooledCache;
+
+      if (pooledCache != null) {
+        root.pooledCache = null;
+        releaseCache(pooledCache);
+      }
+    }
+  }
+}
+
+function flushPassiveEffects() {
+  // Returns whether passive effects were flushed.
+  // TODO: Combine this check with the one in flushPassiveEFfectsImpl. We should
+  // probably just combine the two functions. I believe they were only separate
+  // in the first place because we used to wrap it with
+  // `Scheduler.runWithPriority`, which accepts a function. But now we track the
+  // priority within React itself, so we can mutate the variable directly.
+  if (rootWithPendingPassiveEffects !== null) {
+    // Cache the root since rootWithPendingPassiveEffects is cleared in
+    // flushPassiveEffectsImpl
+    const root = rootWithPendingPassiveEffects; // Cache and clear the remaining lanes flag; it must be reset since this
+    // method can be called from various places, not always from commitRoot
+    // where the remaining lanes are known
+
+    const remainingLanes = pendingPassiveEffectsRemainingLanes;
+    pendingPassiveEffectsRemainingLanes = NoLanes;
+    const renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
+    const priority = lowerEventPriority(DefaultEventPriority, renderPriority);
+    const prevTransition = ReactCurrentBatchConfig$1.transition;
+    const previousPriority = getCurrentUpdatePriority();
+
+    try {
+      ReactCurrentBatchConfig$1.transition = null;
+      setCurrentUpdatePriority(priority);
+      return flushPassiveEffectsImpl();
+    } finally {
+      setCurrentUpdatePriority(previousPriority);
+      ReactCurrentBatchConfig$1.transition = prevTransition; // Once passive effects have run for the tree - giving components a
+      // chance to retain cache instances they use - release the pooled
+      // cache at the root (if there is one)
+
+      releaseRootPooledCache(root, remainingLanes);
+    }
+  }
+
+  return false;
+}
+
+function flushPassiveEffectsImpl() {
+  if (rootWithPendingPassiveEffects === null) {
+    return false;
+  } // Cache and clear the transitions flag
+
+
+  const transitions = pendingPassiveTransitions;
+  pendingPassiveTransitions = null;
+  const root = rootWithPendingPassiveEffects;
+  const lanes = pendingPassiveEffectsLanes;
+  rootWithPendingPassiveEffects = null; // TODO: This is sometimes out of sync with rootWithPendingPassiveEffects.
+  // Figure out why and fix it. It's not causing any known issues (probably
+  // because it's only used for profiling), but it's a refactor hazard.
+
+  pendingPassiveEffectsLanes = NoLanes;
+
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw Error(formatProdErrorMessage(331));
+  }
+
+  const prevExecutionContext = executionContext;
+  executionContext |= CommitContext;
+  commitPassiveUnmountEffects(root.current);
+  commitPassiveMountEffects(root, root.current, lanes, transitions); // TODO: Move to commitPassiveMountEffects
+
+  executionContext = prevExecutionContext;
+  flushSyncWorkOnAllRoots();
+
+
+  onPostCommitRoot(root);
+
+  return true;
+}
+
+function isAlreadyFailedLegacyErrorBoundary(instance) {
+  return legacyErrorBoundariesThatAlreadyFailed !== null && legacyErrorBoundariesThatAlreadyFailed.has(instance);
+}
+function markLegacyErrorBoundaryAsFailed(instance) {
+  if (legacyErrorBoundariesThatAlreadyFailed === null) {
+    legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);
+  } else {
+    legacyErrorBoundariesThatAlreadyFailed.add(instance);
+  }
+}
+
+function prepareToThrowUncaughtError(error) {
+  if (!hasUncaughtError) {
+    hasUncaughtError = true;
+    firstUncaughtError = error;
+  }
+}
+
+const onUncaughtError = prepareToThrowUncaughtError;
+
+function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
+  const errorInfo = createCapturedValueAtFiber(error, sourceFiber);
+  const update = createRootErrorUpdate(rootFiber, errorInfo, SyncLane);
+  const root = enqueueUpdate(rootFiber, update, SyncLane);
+
+  if (root !== null) {
+    markRootUpdated(root, SyncLane);
+    ensureRootIsScheduled(root);
+  }
+}
+
+function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
+
+  if (sourceFiber.tag === HostRoot) {
+    // Error was thrown at the root. There is no parent, so the root
+    // itself should capture it.
+    captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
+    return;
+  }
+
+  let fiber = nearestMountedAncestor;
+
+  while (fiber !== null) {
+    if (fiber.tag === HostRoot) {
+      captureCommitPhaseErrorOnRoot(fiber, sourceFiber, error);
+      return;
+    } else if (fiber.tag === ClassComponent) {
+      const ctor = fiber.type;
+      const instance = fiber.stateNode;
+
+      if (typeof ctor.getDerivedStateFromError === 'function' || typeof instance.componentDidCatch === 'function' && !isAlreadyFailedLegacyErrorBoundary(instance)) {
+        const errorInfo = createCapturedValueAtFiber(error, sourceFiber);
+        const update = createClassErrorUpdate(fiber, errorInfo, SyncLane);
+        const root = enqueueUpdate(fiber, update, SyncLane);
+
+        if (root !== null) {
+          markRootUpdated(root, SyncLane);
+          ensureRootIsScheduled(root);
+        }
+
+        return;
+      }
+    }
+
+    fiber = fiber.return;
+  }
+}
+function attachPingListener(root, wakeable, lanes) {
+  // Attach a ping listener
+  //
+  // The data might resolve before we have a chance to commit the fallback. Or,
+  // in the case of a refresh, we'll never commit a fallback. So we need to
+  // attach a listener now. When it resolves ("pings"), we can decide whether to
+  // try rendering the tree again.
+  //
+  // Only attach a listener if one does not already exist for the lanes
+  // we're currently rendering (which acts like a "thread ID" here).
+  //
+  // We only need to do this in concurrent mode. Legacy Suspense always
+  // commits fallbacks synchronously, so there are no pings.
+  let pingCache = root.pingCache;
+  let threadIDs;
+
+  if (pingCache === null) {
+    pingCache = root.pingCache = new PossiblyWeakMap();
+    threadIDs = new Set();
+    pingCache.set(wakeable, threadIDs);
+  } else {
+    threadIDs = pingCache.get(wakeable);
+
+    if (threadIDs === undefined) {
+      threadIDs = new Set();
+      pingCache.set(wakeable, threadIDs);
+    }
+  }
+
+  if (!threadIDs.has(lanes)) {
+    workInProgressRootDidAttachPingListener = true; // Memoize using the thread ID to prevent redundant listeners.
+
+    threadIDs.add(lanes);
+    const ping = pingSuspendedRoot.bind(null, root, wakeable, lanes);
+
+    wakeable.then(ping, ping);
+  }
+}
+
+function pingSuspendedRoot(root, wakeable, pingedLanes) {
+  const pingCache = root.pingCache;
+
+  if (pingCache !== null) {
+    // The wakeable resolved, so we no longer need to memoize, because it will
+    // never be thrown again.
+    pingCache.delete(wakeable);
+  }
+
+  markRootPinged(root, pingedLanes);
+
+  if (workInProgressRoot === root && isSubsetOfLanes(workInProgressRootRenderLanes, pingedLanes)) {
+    // Received a ping at the same priority level at which we're currently
+    // rendering. We might want to restart this render. This should mirror
+    // the logic of whether or not a root suspends once it completes.
+    // TODO: If we're rendering sync either due to Sync, Batched or expired,
+    // we should probably never restart.
+    // If we're suspended with delay, or if it's a retry, we'll always suspend
+    // so we can always restart.
+    if (workInProgressRootExitStatus === RootSuspendedWithDelay || workInProgressRootExitStatus === RootSuspended && includesOnlyRetries(workInProgressRootRenderLanes) && now() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS) {
+      // Force a restart from the root by unwinding the stack. Unless this is
+      // being called from the render phase, because that would cause a crash.
+      if ((executionContext & RenderContext) === NoContext) {
+        prepareFreshStack(root, NoLanes);
+      }
+    } else {
+      // Even though we can't restart right now, we might get an
+      // opportunity later. So we mark this render as having a ping.
+      workInProgressRootPingedLanes = mergeLanes(workInProgressRootPingedLanes, pingedLanes);
+    }
+  }
+
+  ensureRootIsScheduled(root);
+}
+
+function retryTimedOutBoundary(boundaryFiber, retryLane) {
+  // The boundary fiber (a Suspense component or SuspenseList component)
+  // previously was rendered in its fallback state. One of the promises that
+  // suspended it has resolved, which means at least part of the tree was
+  // likely unblocked. Try rendering again, at a new lanes.
+  if (retryLane === NoLane) {
+    // TODO: Assign this to `suspenseState.retryLane`? to avoid
+    // unnecessary entanglement?
+    retryLane = requestRetryLane(boundaryFiber);
+  } // TODO: Special case idle priority?
+
+
+  const root = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
+
+  if (root !== null) {
+    markRootUpdated(root, retryLane);
+    ensureRootIsScheduled(root);
+  }
+}
+
+function retryDehydratedSuspenseBoundary(boundaryFiber) {
+  const suspenseState = boundaryFiber.memoizedState;
+  let retryLane = NoLane;
+
+  if (suspenseState !== null) {
+    retryLane = suspenseState.retryLane;
+  }
+
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+}
+function resolveRetryWakeable(boundaryFiber, wakeable) {
+  let retryLane = NoLane; // Default
+
+  let retryCache;
+
+  switch (boundaryFiber.tag) {
+    case SuspenseComponent:
+      retryCache = boundaryFiber.stateNode;
+      const suspenseState = boundaryFiber.memoizedState;
+
+      if (suspenseState !== null) {
+        retryLane = suspenseState.retryLane;
+      }
+
+      break;
+
+    case SuspenseListComponent:
+      retryCache = boundaryFiber.stateNode;
+      break;
+
+    case OffscreenComponent:
+      {
+        const instance = boundaryFiber.stateNode;
+        retryCache = instance._retryCache;
+        break;
+      }
+
+    default:
+      throw Error(formatProdErrorMessage(314));
+  }
+
+  if (retryCache !== null) {
+    // The wakeable resolved, so we no longer need to memoize, because it will
+    // never be thrown again.
+    retryCache.delete(wakeable);
+  }
+
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+}
+function throwIfInfiniteUpdateLoopDetected() {
+  if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
+    nestedUpdateCount = 0;
+    rootWithNestedUpdates = null;
+    throw Error(formatProdErrorMessage(185));
+  }
+}
+let beginWork;
+
+{
+  beginWork = beginWork$1;
+}
+
+function scheduleCallback(priorityLevel, callback) {
+  {
+    // In production, always call Scheduler. This function will be stripped out.
+    return scheduleCallback$3(priorityLevel, callback);
+  }
+}
+
+function FiberNode(tag, pendingProps, key, mode) {
+  // Instance
+  this.tag = tag;
+  this.key = key;
+  this.elementType = null;
+  this.type = null;
+  this.stateNode = null; // Fiber
+
+  this.return = null;
+  this.child = null;
+  this.sibling = null;
+  this.index = 0;
+  this.ref = null;
+  this.refCleanup = null;
+  this.pendingProps = pendingProps;
+  this.memoizedProps = null;
+  this.updateQueue = null;
+  this.memoizedState = null;
+  this.dependencies = null;
+  this.mode = mode; // Effects
+
+  this.flags = NoFlags$1;
+  this.subtreeFlags = NoFlags$1;
+  this.deletions = null;
+  this.lanes = NoLanes;
+  this.childLanes = NoLanes;
+  this.alternate = null;
+} // This is a constructor function, rather than a POJO constructor, still
+// please ensure we do the following:
+// 1) Nobody should add any instance methods on this. Instance methods can be
+//    more difficult to predict when they get optimized and they are almost
+//    never inlined properly in static compilers.
+// 2) Nobody should rely on `instanceof Fiber` for type testing. We should
+//    always know when it is a fiber.
+// 3) We might want to experiment with using numeric keys since they are easier
+//    to optimize in a non-JIT environment.
+// 4) We can easily go from a constructor to a createFiber object literal if that
+//    is faster.
+// 5) It should be easy to port this to a C struct and keep a C implementation
+//    compatible.
+
+
+function createFiber(tag, pendingProps, key, mode) {
+  // $FlowFixMe[invalid-constructor]: the shapes are exact here but Flow doesn't like constructors
+  return new FiberNode(tag, pendingProps, key, mode);
+}
+
+function shouldConstruct(Component) {
+  const prototype = Component.prototype;
+  return !!(prototype && prototype.isReactComponent);
+}
+
+function isSimpleFunctionComponent(type) {
+  return typeof type === 'function' && !shouldConstruct(type) && type.defaultProps === undefined;
+}
+function resolveLazyComponentTag(Component) {
+  if (typeof Component === 'function') {
+    return shouldConstruct(Component) ? ClassComponent : FunctionComponent;
+  } else if (Component !== undefined && Component !== null) {
+    const $$typeof = Component.$$typeof;
+
+    if ($$typeof === REACT_FORWARD_REF_TYPE) {
+      return ForwardRef;
+    }
+
+    if ($$typeof === REACT_MEMO_TYPE) {
+      return MemoComponent;
+    }
+  }
+
+  return IndeterminateComponent;
+} // This is used to create an alternate fiber to do work on.
+
+function createWorkInProgress(current, pendingProps) {
+  let workInProgress = current.alternate;
+
+  if (workInProgress === null) {
+    // We use a double buffering pooling technique because we know that we'll
+    // only ever need at most two versions of a tree. We pool the "other" unused
+    // node that we're free to reuse. This is lazily created to avoid allocating
+    // extra objects for things that are never updated. It also allow us to
+    // reclaim the extra memory if needed.
+    workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode);
+    workInProgress.elementType = current.elementType;
+    workInProgress.type = current.type;
+    workInProgress.stateNode = current.stateNode;
+
+    workInProgress.alternate = current;
+    current.alternate = workInProgress;
+  } else {
+    workInProgress.pendingProps = pendingProps; // Needed because Blocks store data on type.
+
+    workInProgress.type = current.type; // We already have an alternate.
+    // Reset the effect tag.
+
+    workInProgress.flags = NoFlags$1; // The effects are no longer valid.
+
+    workInProgress.subtreeFlags = NoFlags$1;
+    workInProgress.deletions = null;
+  } // Reset all effects except static ones.
+  // Static effects are not specific to a render.
+
+
+  workInProgress.flags = current.flags & StaticMask;
+  workInProgress.childLanes = current.childLanes;
+  workInProgress.lanes = current.lanes;
+  workInProgress.child = current.child;
+  workInProgress.memoizedProps = current.memoizedProps;
+  workInProgress.memoizedState = current.memoizedState;
+  workInProgress.updateQueue = current.updateQueue; // Clone the dependencies object. This is mutated during the render phase, so
+  // it cannot be shared with the current fiber.
+
+  const currentDependencies = current.dependencies;
+  workInProgress.dependencies = currentDependencies === null ? null : {
+    lanes: currentDependencies.lanes,
+    firstContext: currentDependencies.firstContext
+  }; // These will be overridden during the parent's reconciliation
+
+  workInProgress.sibling = current.sibling;
+  workInProgress.index = current.index;
+  workInProgress.ref = current.ref;
+  workInProgress.refCleanup = current.refCleanup;
+
+  return workInProgress;
+} // Used to reuse a Fiber for a second pass.
+
+function resetWorkInProgress(workInProgress, renderLanes) {
+  // This resets the Fiber to what createFiber or createWorkInProgress would
+  // have set the values to before during the first pass. Ideally this wouldn't
+  // be necessary but unfortunately many code paths reads from the workInProgress
+  // when they should be reading from current and writing to workInProgress.
+  // We assume pendingProps, index, key, ref, return are still untouched to
+  // avoid doing another reconciliation.
+  // Reset the effect flags but keep any Placement tags, since that's something
+  // that child fiber is setting, not the reconciliation.
+  workInProgress.flags &= StaticMask | Placement; // The effects are no longer valid.
+
+  const current = workInProgress.alternate;
+
+  if (current === null) {
+    // Reset to createFiber's initial values.
+    workInProgress.childLanes = NoLanes;
+    workInProgress.lanes = renderLanes;
+    workInProgress.child = null;
+    workInProgress.subtreeFlags = NoFlags$1;
+    workInProgress.memoizedProps = null;
+    workInProgress.memoizedState = null;
+    workInProgress.updateQueue = null;
+    workInProgress.dependencies = null;
+    workInProgress.stateNode = null;
+  } else {
+    // Reset to the cloned values that createWorkInProgress would've.
+    workInProgress.childLanes = current.childLanes;
+    workInProgress.lanes = current.lanes;
+    workInProgress.child = current.child;
+    workInProgress.subtreeFlags = NoFlags$1;
+    workInProgress.deletions = null;
+    workInProgress.memoizedProps = current.memoizedProps;
+    workInProgress.memoizedState = current.memoizedState;
+    workInProgress.updateQueue = current.updateQueue; // Needed because Blocks store data on type.
+
+    workInProgress.type = current.type; // Clone the dependencies object. This is mutated during the render phase, so
+    // it cannot be shared with the current fiber.
+
+    const currentDependencies = current.dependencies;
+    workInProgress.dependencies = currentDependencies === null ? null : {
+      lanes: currentDependencies.lanes,
+      firstContext: currentDependencies.firstContext
+    };
+  }
+
+  return workInProgress;
+}
+function createHostRootFiber(tag, isStrictMode, concurrentUpdatesByDefaultOverride) {
+  let mode;
+
+  if (tag === ConcurrentRoot) {
+    mode = ConcurrentMode;
+
+    if (isStrictMode === true || createRootStrictEffectsByDefault) {
+      mode |= StrictLegacyMode | StrictEffectsMode;
+    }
+  } else {
+    mode = NoMode;
+  }
+
+  return createFiber(HostRoot, null, null, mode);
+}
+function createFiberFromTypeAndProps(type, // React$ElementType
+key, pendingProps, source, owner, mode, lanes) {
+  let fiberTag = IndeterminateComponent; // The resolved type is set if we know what the final type will be. I.e. it's not lazy.
+
+  let resolvedType = type;
+
+  if (typeof type === 'function') {
+    if (shouldConstruct(type)) {
+      fiberTag = ClassComponent;
+    }
+  } else if (typeof type === 'string') {
+    {
+      const hostContext = getHostContext();
+      fiberTag = isHostHoistableType(type, pendingProps, hostContext) ? HostHoistable : isHostSingletonType(type) ? HostSingleton : HostComponent;
+    }
+  } else {
+    getTag: switch (type) {
+      case REACT_FRAGMENT_TYPE:
+        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
+
+      case REACT_STRICT_MODE_TYPE:
+        fiberTag = Mode;
+        mode |= StrictLegacyMode;
+
+        if ((mode & ConcurrentMode) !== NoMode) {
+          // Strict effects should never run on legacy roots
+          mode |= StrictEffectsMode;
+        }
+
+        break;
+
+      case REACT_PROFILER_TYPE:
+        return createFiberFromProfiler(pendingProps, mode, lanes, key);
+
+      case REACT_SUSPENSE_TYPE:
+        return createFiberFromSuspense(pendingProps, mode, lanes, key);
+
+      case REACT_SUSPENSE_LIST_TYPE:
+        return createFiberFromSuspenseList(pendingProps, mode, lanes, key);
+
+      case REACT_OFFSCREEN_TYPE:
+        return createFiberFromOffscreen(pendingProps, mode, lanes, key);
+
+      case REACT_LEGACY_HIDDEN_TYPE:
+
+      // Fall through
+
+      case REACT_SCOPE_TYPE:
+
+      // Fall through
+
+      case REACT_CACHE_TYPE:
+        {
+          return createFiberFromCache(pendingProps, mode, lanes, key);
+        }
+
+      // Fall through
+
+      case REACT_TRACING_MARKER_TYPE:
+
+      // Fall through
+
+      case REACT_DEBUG_TRACING_MODE_TYPE:
+
+      // Fall through
+
+      default:
+        {
+          if (typeof type === 'object' && type !== null) {
+            switch (type.$$typeof) {
+              case REACT_PROVIDER_TYPE:
+                fiberTag = ContextProvider;
+                break getTag;
+
+              case REACT_CONTEXT_TYPE:
+                // This is a consumer
+                fiberTag = ContextConsumer;
+                break getTag;
+
+              case REACT_FORWARD_REF_TYPE:
+                fiberTag = ForwardRef;
+
+                break getTag;
+
+              case REACT_MEMO_TYPE:
+                fiberTag = MemoComponent;
+                break getTag;
+
+              case REACT_LAZY_TYPE:
+                fiberTag = LazyComponent;
+                resolvedType = null;
+                break getTag;
+            }
+          }
+
+          let info = '';
+
+          throw Error(formatProdErrorMessage(130, type == null ? type : typeof type, info));
+        }
+    }
+  }
+
+  const fiber = createFiber(fiberTag, pendingProps, key, mode);
+  fiber.elementType = type;
+  fiber.type = resolvedType;
+  fiber.lanes = lanes;
+
+  return fiber;
+}
+function createFiberFromElement(element, mode, lanes) {
+  let source = null;
+  let owner = null;
+
+  const type = element.type;
+  const key = element.key;
+  const pendingProps = element.props;
+  const fiber = createFiberFromTypeAndProps(type, key, pendingProps, source, owner, mode, lanes);
+
+  return fiber;
+}
+function createFiberFromFragment(elements, mode, lanes, key) {
+  const fiber = createFiber(Fragment, elements, key, mode);
+  fiber.lanes = lanes;
+  return fiber;
+}
+
+function createFiberFromProfiler(pendingProps, mode, lanes, key) {
+
+  const fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);
+  fiber.elementType = REACT_PROFILER_TYPE;
+  fiber.lanes = lanes;
+
+  return fiber;
+}
+
+function createFiberFromSuspense(pendingProps, mode, lanes, key) {
+  const fiber = createFiber(SuspenseComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_SUSPENSE_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromSuspenseList(pendingProps, mode, lanes, key) {
+  const fiber = createFiber(SuspenseListComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_SUSPENSE_LIST_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
+  const fiber = createFiber(OffscreenComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_OFFSCREEN_TYPE;
+  fiber.lanes = lanes;
+  const primaryChildInstance = {
+    _visibility: OffscreenVisible,
+    _pendingVisibility: OffscreenVisible,
+    _pendingMarkers: null,
+    _retryCache: null,
+    _transitions: null,
+    _current: null,
+    detach: () => detachOffscreenInstance(primaryChildInstance),
+    attach: () => attachOffscreenInstance(primaryChildInstance)
+  };
+  fiber.stateNode = primaryChildInstance;
+  return fiber;
+}
+function createFiberFromCache(pendingProps, mode, lanes, key) {
+  const fiber = createFiber(CacheComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_CACHE_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromText(content, mode, lanes) {
+  const fiber = createFiber(HostText, content, null, mode);
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromHostInstanceForDeletion() {
+  const fiber = createFiber(HostComponent, null, null, NoMode);
+  fiber.elementType = 'DELETED';
+  return fiber;
+}
+function createFiberFromDehydratedFragment(dehydratedNode) {
+  const fiber = createFiber(DehydratedFragment, null, null, NoMode);
+  fiber.stateNode = dehydratedNode;
+  return fiber;
+}
+function createFiberFromPortal(portal, mode, lanes) {
+  const pendingProps = portal.children !== null ? portal.children : [];
+  const fiber = createFiber(HostPortal, pendingProps, portal.key, mode);
+  fiber.lanes = lanes;
+  fiber.stateNode = {
+    containerInfo: portal.containerInfo,
+    pendingChildren: null,
+    // Used by persistent updates
+    implementation: portal.implementation
+  };
+  return fiber;
+} // Used for stashing WIP properties to replay failed work in DEV.
+
+function FiberRootNode(containerInfo, // $FlowFixMe[missing-local-annot]
+tag, hydrate, identifierPrefix, onRecoverableError, formState) {
+  this.tag = tag;
+  this.containerInfo = containerInfo;
+  this.pendingChildren = null;
+  this.current = null;
+  this.pingCache = null;
+  this.finishedWork = null;
+  this.timeoutHandle = noTimeout;
+  this.cancelPendingCommit = null;
+  this.context = null;
+  this.pendingContext = null;
+  this.next = null;
+  this.callbackNode = null;
+  this.callbackPriority = NoLane;
+  this.expirationTimes = createLaneMap(NoTimestamp);
+  this.pendingLanes = NoLanes;
+  this.suspendedLanes = NoLanes;
+  this.pingedLanes = NoLanes;
+  this.expiredLanes = NoLanes;
+  this.finishedLanes = NoLanes;
+  this.errorRecoveryDisabledLanes = NoLanes;
+  this.shellSuspendCounter = 0;
+  this.entangledLanes = NoLanes;
+  this.entanglements = createLaneMap(NoLanes);
+  this.hiddenUpdates = createLaneMap(null);
+  this.identifierPrefix = identifierPrefix;
+  this.onRecoverableError = onRecoverableError;
+
+  {
+    this.pooledCache = null;
+    this.pooledCacheLanes = NoLanes;
+  }
+
+  this.formState = formState;
+  this.incompleteTransitions = new Map();
+}
+
+function createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, // TODO: We have several of these arguments that are conceptually part of the
+// host config, but because they are passed in at runtime, we have to thread
+// them through the root constructor. Perhaps we should put them all into a
+// single type, like a DynamicHostConfig that is defined by the renderer.
+identifierPrefix, onRecoverableError, transitionCallbacks, formState) {
+  // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
+  const root = new FiberRootNode(containerInfo, tag, hydrate, identifierPrefix, onRecoverableError, formState);
+  // stateNode is any.
+
+
+  const uninitializedFiber = createHostRootFiber(tag, isStrictMode);
+  root.current = uninitializedFiber;
+  uninitializedFiber.stateNode = root;
+
+  {
+    const initialCache = createCache();
+    retainCache(initialCache); // The pooledCache is a fresh cache instance that is used temporarily
+    // for newly mounted boundaries during a render. In general, the
+    // pooledCache is always cleared from the root at the end of a render:
+    // it is either released when render commits, or moved to an Offscreen
+    // component if rendering suspends. Because the lifetime of the pooled
+    // cache is distinct from the main memoizedState.cache, it must be
+    // retained separately.
+
+    root.pooledCache = initialCache;
+    retainCache(initialCache);
+    const initialState = {
+      element: initialChildren,
+      isDehydrated: hydrate,
+      cache: initialCache
+    };
+    uninitializedFiber.memoizedState = initialState;
+  }
+
+  initializeUpdateQueue(uninitializedFiber);
+  return root;
+}
+
+var ReactVersion = '18.3.0-experimental-7508dcd5c-20231108';
+
+function createPortal$1(children, containerInfo, // TODO: figure out the API for cross-renderer implementation.
+implementation) {
+  let key = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+
+  return {
+    // This tag allow us to uniquely identify this as a React Portal
+    $$typeof: REACT_PORTAL_TYPE,
+    key: key == null ? null : '' + key,
+    children,
+    containerInfo,
+    implementation
+  };
+}
+
+function getContextForSubtree(parentComponent) {
+  if (!parentComponent) {
+    return emptyContextObject;
+  }
+
+  const fiber = get(parentComponent);
+  const parentContext = findCurrentUnmaskedContext(fiber);
+
+  if (fiber.tag === ClassComponent) {
+    const Component = fiber.type;
+
+    if (isContextProvider(Component)) {
+      return processChildContext(fiber, Component, parentContext);
+    }
+  }
+
+  return parentContext;
+}
+
+function findHostInstance(component) {
+  const fiber = get(component);
+
+  if (fiber === undefined) {
+    if (typeof component.render === 'function') {
+      throw Error(formatProdErrorMessage(188));
+    } else {
+      const keys = Object.keys(component).join(',');
+      throw Error(formatProdErrorMessage(268, keys));
+    }
+  }
+
+  const hostFiber = findCurrentHostFiber(fiber);
+
+  if (hostFiber === null) {
+    return null;
+  }
+
+  return getPublicInstance(hostFiber.stateNode);
+}
+
+function createContainer(containerInfo, tag, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks) {
+  const hydrate = false;
+  const initialChildren = null;
+  return createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks, null);
+}
+function createHydrationContainer(initialChildren, // TODO: Remove `callback` when we delete legacy mode.
+callback, containerInfo, tag, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks, formState) {
+  const hydrate = true;
+  const root = createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks, formState); // TODO: Move this to FiberRoot constructor
+
+  root.context = getContextForSubtree(null); // Schedule the initial render. In a hydration root, this is different from
+  // a regular update because the initial render must match was was rendered
+  // on the server.
+  // NOTE: This update intentionally doesn't have a payload. We're only using
+  // the update to schedule work on the root fiber (and, for legacy roots, to
+  // enqueue the callback if one is provided).
+
+  const current = root.current;
+  const lane = requestUpdateLane(current);
+  const update = createUpdate(lane);
+  update.callback = callback !== undefined && callback !== null ? callback : null;
+  enqueueUpdate(current, update, lane);
+  scheduleInitialHydrationOnRoot(root, lane);
+  return root;
+}
+function updateContainer(element, container, parentComponent, callback) {
+
+  const current = container.current;
+  const lane = requestUpdateLane(current);
+
+  const context = getContextForSubtree(parentComponent);
+
+  if (container.context === null) {
+    container.context = context;
+  } else {
+    container.pendingContext = context;
+  }
+
+  const update = createUpdate(lane); // Caution: React DevTools currently depends on this property
+  // being called "element".
+
+  update.payload = {
+    element
+  };
+  callback = callback === undefined ? null : callback;
+
+  if (callback !== null) {
+
+    update.callback = callback;
+  }
+
+  const root = enqueueUpdate(current, update, lane);
+
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, current, lane);
+    entangleTransitions(root, current, lane);
+  }
+
+  return lane;
+}
+function getPublicRootInstance(container) {
+  const containerFiber = container.current;
+
+  if (!containerFiber.child) {
+    return null;
+  }
+
+  switch (containerFiber.child.tag) {
+    case HostSingleton:
+    case HostComponent:
+      return getPublicInstance(containerFiber.child.stateNode);
+
+    default:
+      return containerFiber.child.stateNode;
+  }
+}
+function attemptSynchronousHydration(fiber) {
+  switch (fiber.tag) {
+    case HostRoot:
+      {
+        const root = fiber.stateNode;
+
+        if (isRootDehydrated(root)) {
+          // Flush the first scheduled "update".
+          const lanes = getHighestPriorityPendingLanes(root);
+          flushRoot(root, lanes);
+        }
+
+        break;
+      }
+
+    case SuspenseComponent:
+      {
+        flushSync$1(() => {
+          const root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+          if (root !== null) {
+            scheduleUpdateOnFiber(root, fiber, SyncLane);
+          }
+        }); // If we're still blocked after this, we need to increase
+        // the priority of any promises resolving within this
+        // boundary so that they next attempt also has higher pri.
+
+        const retryLane = SyncLane;
+        markRetryLaneIfNotHydrated(fiber, retryLane);
+        break;
+      }
+  }
+}
+
+function markRetryLaneImpl(fiber, retryLane) {
+  const suspenseState = fiber.memoizedState;
+
+  if (suspenseState !== null && suspenseState.dehydrated !== null) {
+    suspenseState.retryLane = higherPriorityLane(suspenseState.retryLane, retryLane);
+  }
+} // Increases the priority of thenables when they resolve within this boundary.
+
+
+function markRetryLaneIfNotHydrated(fiber, retryLane) {
+  markRetryLaneImpl(fiber, retryLane);
+  const alternate = fiber.alternate;
+
+  if (alternate) {
+    markRetryLaneImpl(alternate, retryLane);
+  }
+}
+
+function attemptContinuousHydration(fiber) {
+  if (fiber.tag !== SuspenseComponent) {
+    // We ignore HostRoots here because we can't increase
+    // their priority and they should not suspend on I/O,
+    // since you have to wrap anything that might suspend in
+    // Suspense.
+    return;
+  }
+
+  const lane = SelectiveHydrationLane;
+  const root = enqueueConcurrentRenderForLane(fiber, lane);
+
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, fiber, lane);
+  }
+
+  markRetryLaneIfNotHydrated(fiber, lane);
+}
+function attemptHydrationAtCurrentPriority(fiber) {
+  if (fiber.tag !== SuspenseComponent) {
+    // We ignore HostRoots here because we can't increase
+    // their priority other than synchronously flush it.
+    return;
+  }
+
+  const lane = requestUpdateLane(fiber);
+  const root = enqueueConcurrentRenderForLane(fiber, lane);
+
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, fiber, lane);
+  }
+
+  markRetryLaneIfNotHydrated(fiber, lane);
+}
+let overrideHookState = null;
+let overrideHookStateDeletePath = null;
+let overrideHookStateRenamePath = null;
+let overrideProps = null;
+let overridePropsDeletePath = null;
+let overridePropsRenamePath = null;
+let scheduleUpdate = null;
+let setErrorHandler = null;
+let setSuspenseHandler = null;
+
+function findHostInstanceByFiber(fiber) {
+  const hostFiber = findCurrentHostFiber(fiber);
+
+  if (hostFiber === null) {
+    return null;
+  }
+
+  return hostFiber.stateNode;
+}
+
+function emptyFindFiberByHostInstance(instance) {
+  return null;
+}
+
+function injectIntoDevTools(devToolsConfig) {
+  const findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
+  const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+  return injectInternals({
+    bundleType: devToolsConfig.bundleType,
+    version: devToolsConfig.version,
+    rendererPackageName: devToolsConfig.rendererPackageName,
+    rendererConfig: devToolsConfig.rendererConfig,
+    overrideHookState,
+    overrideHookStateDeletePath,
+    overrideHookStateRenamePath,
+    overrideProps,
+    overridePropsDeletePath,
+    overridePropsRenamePath,
+    setErrorHandler,
+    setSuspenseHandler,
+    scheduleUpdate,
+    currentDispatcherRef: ReactCurrentDispatcher,
+    findHostInstanceByFiber,
+    findFiberByHostInstance: findFiberByHostInstance || emptyFindFiberByHostInstance,
+    // React Refresh
+    findHostInstancesForRefresh: null,
+    scheduleRefresh: null,
+    scheduleRoot: null,
+    setRefreshHandler: null,
+    // Enables DevTools to append owner stacks to error messages in DEV mode.
+    getCurrentFiber: null,
+    // Enables DevTools to detect reconciler version rather than renderer version
+    // which may not match for third party renderers.
+    reconcilerVersion: ReactVersion
+  });
+}
+
+// the renderer. Such as when we're dispatching events or if third party
+// libraries need to call batchedUpdates. Eventually, this API will go away when
+// everything is batched by default. We'll then have a similar API to opt-out of
+// scheduled work and instead do synchronous work.
+
+let isInsideEventHandler = false;
+
+function finishEventHandler() {
+  // Here we wait until all updates have propagated, which is important
+  // when using controlled components within layers:
+  // https://github.com/facebook/react/issues/1698
+  // Then we restore state of any controlled component.
+  const controlledComponentsHavePendingUpdates = needsStateRestore();
+
+  if (controlledComponentsHavePendingUpdates) {
+    // If a controlled event was fired, we may need to restore the state of
+    // the DOM node back to the controlled value. This is necessary when React
+    // bails out of the update without touching the DOM.
+    // TODO: Restore state in the microtask, after the discrete updates flush,
+    // instead of early flushing them here.
+    flushSync$1();
+    restoreStateIfNeeded();
+  }
+}
+
+function batchedUpdates(fn, a, b) {
+  if (isInsideEventHandler) {
+    // If we are currently inside another batch, we need to wait until it
+    // fully completes before restoring state.
+    return fn(a, b);
+  }
+
+  isInsideEventHandler = true;
+
+  try {
+    return batchedUpdates$1(fn, a, b);
+  } finally {
+    isInsideEventHandler = false;
+    finishEventHandler();
+  }
+} // TODO: Replace with flushSync
+
+function isInteractive(tag) {
+  return tag === 'button' || tag === 'input' || tag === 'select' || tag === 'textarea';
+}
+
+function shouldPreventMouseEvent(name, type, props) {
+  switch (name) {
+    case 'onClick':
+    case 'onClickCapture':
+    case 'onDoubleClick':
+    case 'onDoubleClickCapture':
+    case 'onMouseDown':
+    case 'onMouseDownCapture':
+    case 'onMouseMove':
+    case 'onMouseMoveCapture':
+    case 'onMouseUp':
+    case 'onMouseUpCapture':
+    case 'onMouseEnter':
+      return !!(props.disabled && isInteractive(type));
+
+    default:
+      return false;
+  }
+}
+/**
+ * @param {object} inst The instance, which is the source of events.
+ * @param {string} registrationName Name of listener (e.g. `onClick`).
+ * @return {?function} The stored callback.
+ */
+
+
+function getListener(inst, registrationName) {
+  const stateNode = inst.stateNode;
+
+  if (stateNode === null) {
+    // Work in progress (ex: onload events in incremental mode).
+    return null;
+  }
+
+  const props = getFiberCurrentPropsFromNode(stateNode);
+
+  if (props === null) {
+    // Work in progress.
+    return null;
+  }
+
+  const listener = props[registrationName];
+
+  if (shouldPreventMouseEvent(registrationName, inst.type, props)) {
+    return null;
+  }
+
+  if (listener && typeof listener !== 'function') {
+    throw Error(formatProdErrorMessage(231, registrationName, typeof listener));
+  }
+
+  return listener;
+}
+
+let passiveBrowserEventsSupported = false; // Check if browser support events with passive listeners
+// https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support
+
+if (canUseDOM) {
+  try {
+    const options = {};
+    Object.defineProperty(options, 'passive', {
+      get: function () {
+        passiveBrowserEventsSupported = true;
+      }
+    });
+    window.addEventListener('test', options, options);
+    window.removeEventListener('test', options, options);
+  } catch (e) {
+    passiveBrowserEventsSupported = false;
+  }
+}
+
+/**
+ * `charCode` represents the actual "character code" and is safe to use with
+ * `String.fromCharCode`. As such, only keys that correspond to printable
+ * characters produce a valid `charCode`, the only exception to this is Enter.
+ * The Tab-key is considered non-printable and does not have a `charCode`,
+ * presumably because it does not produce a tab-character in browsers.
+ *
+ * @param {object} nativeEvent Native browser event.
+ * @return {number} Normalized `charCode` property.
+ */
+function getEventCharCode(nativeEvent) {
+  let charCode;
+  const keyCode = nativeEvent.keyCode;
+
+  if ('charCode' in nativeEvent) {
+    charCode = nativeEvent.charCode; // FF does not set `charCode` for the Enter-key, check against `keyCode`.
+
+    if (charCode === 0 && keyCode === 13) {
+      charCode = 13;
+    }
+  } else {
+    // IE8 does not implement `charCode`, but `keyCode` has the correct value.
+    charCode = keyCode;
+  } // IE and Edge (on Windows) and Chrome / Safari (on Windows and Linux)
+  // report Enter as charCode 10 when ctrl is pressed.
+
+
+  if (charCode === 10) {
+    charCode = 13;
+  } // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
+  // Must not discard the (non-)printable Enter-key.
+
+
+  if (charCode >= 32 || charCode === 13) {
+    return charCode;
+  }
+
+  return 0;
+}
+
+function functionThatReturnsTrue() {
+  return true;
+}
+
+function functionThatReturnsFalse() {
+  return false;
+} // This is intentionally a factory so that we have different returned constructors.
+// If we had a single constructor, it would be megamorphic and engines would deopt.
+
+
+function createSyntheticEvent(Interface) {
+  /**
+   * Synthetic events are dispatched by event plugins, typically in response to a
+   * top-level event delegation handler.
+   *
+   * These systems should generally use pooling to reduce the frequency of garbage
+   * collection. The system should check `isPersistent` to determine whether the
+   * event should be released into the pool after being dispatched. Users that
+   * need a persisted event should invoke `persist`.
+   *
+   * Synthetic events (and subclasses) implement the DOM Level 3 Events API by
+   * normalizing browser quirks. Subclasses do not necessarily have to implement a
+   * DOM interface; custom application-specific events can also subclass this.
+   */
+  // $FlowFixMe[missing-this-annot]
+  function SyntheticBaseEvent(reactName, reactEventType, targetInst, nativeEvent, nativeEventTarget) {
+    this._reactName = reactName;
+    this._targetInst = targetInst;
+    this.type = reactEventType;
+    this.nativeEvent = nativeEvent;
+    this.target = nativeEventTarget;
+    this.currentTarget = null;
+
+    for (const propName in Interface) {
+      if (!Interface.hasOwnProperty(propName)) {
+        continue;
+      }
+
+      const normalize = Interface[propName];
+
+      if (normalize) {
+        this[propName] = normalize(nativeEvent);
+      } else {
+        this[propName] = nativeEvent[propName];
+      }
+    }
+
+    const defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
+
+    if (defaultPrevented) {
+      this.isDefaultPrevented = functionThatReturnsTrue;
+    } else {
+      this.isDefaultPrevented = functionThatReturnsFalse;
+    }
+
+    this.isPropagationStopped = functionThatReturnsFalse;
+    return this;
+  } // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+  assign(SyntheticBaseEvent.prototype, {
+    // $FlowFixMe[missing-this-annot]
+    preventDefault: function () {
+      this.defaultPrevented = true;
+      const event = this.nativeEvent;
+
+      if (!event) {
+        return;
+      }
+
+      if (event.preventDefault) {
+        event.preventDefault(); // $FlowFixMe[illegal-typeof] - flow is not aware of `unknown` in IE
+      } else if (typeof event.returnValue !== 'unknown') {
+        event.returnValue = false;
+      }
+
+      this.isDefaultPrevented = functionThatReturnsTrue;
+    },
+    // $FlowFixMe[missing-this-annot]
+    stopPropagation: function () {
+      const event = this.nativeEvent;
+
+      if (!event) {
+        return;
+      }
+
+      if (event.stopPropagation) {
+        event.stopPropagation(); // $FlowFixMe[illegal-typeof] - flow is not aware of `unknown` in IE
+      } else if (typeof event.cancelBubble !== 'unknown') {
+        // The ChangeEventPlugin registers a "propertychange" event for
+        // IE. This event does not support bubbling or cancelling, and
+        // any references to cancelBubble throw "Member not found".  A
+        // typeof check of "unknown" circumvents this issue (and is also
+        // IE specific).
+        event.cancelBubble = true;
+      }
+
+      this.isPropagationStopped = functionThatReturnsTrue;
+    },
+
+    /**
+     * We release all dispatched `SyntheticEvent`s after each event loop, adding
+     * them back into the pool. This allows a way to hold onto a reference that
+     * won't be added back into the pool.
+     */
+    persist: function () {// Modern event system doesn't use pooling.
+    },
+
+    /**
+     * Checks if this event should be released back into the pool.
+     *
+     * @return {boolean} True if this should not be released, false otherwise.
+     */
+    isPersistent: functionThatReturnsTrue
+  });
+  return SyntheticBaseEvent;
+}
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+
+const EventInterface = {
+  eventPhase: 0,
+  bubbles: 0,
+  cancelable: 0,
+  timeStamp: function (event) {
+    return event.timeStamp || Date.now();
+  },
+  defaultPrevented: 0,
+  isTrusted: 0
+};
+const SyntheticEvent = createSyntheticEvent(EventInterface);
+
+const UIEventInterface = assign({}, EventInterface, {
+  view: 0,
+  detail: 0
+});
+
+const SyntheticUIEvent = createSyntheticEvent(UIEventInterface);
+let lastMovementX;
+let lastMovementY;
+let lastMouseEvent;
+
+function updateMouseMovementPolyfillState(event) {
+  if (event !== lastMouseEvent) {
+    if (lastMouseEvent && event.type === 'mousemove') {
+      // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+      lastMovementX = event.screenX - lastMouseEvent.screenX; // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+
+      lastMovementY = event.screenY - lastMouseEvent.screenY;
+    } else {
+      lastMovementX = 0;
+      lastMovementY = 0;
+    }
+
+    lastMouseEvent = event;
+  }
+}
+/**
+ * @interface MouseEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+
+const MouseEventInterface = assign({}, UIEventInterface, {
+  screenX: 0,
+  screenY: 0,
+  clientX: 0,
+  clientY: 0,
+  pageX: 0,
+  pageY: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  altKey: 0,
+  metaKey: 0,
+  getModifierState: getEventModifierState,
+  button: 0,
+  buttons: 0,
+  relatedTarget: function (event) {
+    if (event.relatedTarget === undefined) return event.fromElement === event.srcElement ? event.toElement : event.fromElement;
+    return event.relatedTarget;
+  },
+  movementX: function (event) {
+    if ('movementX' in event) {
+      return event.movementX;
+    }
+
+    updateMouseMovementPolyfillState(event);
+    return lastMovementX;
+  },
+  movementY: function (event) {
+    if ('movementY' in event) {
+      return event.movementY;
+    } // Don't need to call updateMouseMovementPolyfillState() here
+    // because it's guaranteed to have already run when movementX
+    // was copied.
+
+
+    return lastMovementY;
+  }
+});
+
+const SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface);
+/**
+ * @interface DragEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+const DragEventInterface = assign({}, MouseEventInterface, {
+  dataTransfer: 0
+});
+
+const SyntheticDragEvent = createSyntheticEvent(DragEventInterface);
+/**
+ * @interface FocusEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+const FocusEventInterface = assign({}, UIEventInterface, {
+  relatedTarget: 0
+});
+
+const SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent
+ */
+
+const AnimationEventInterface = assign({}, EventInterface, {
+  animationName: 0,
+  elapsedTime: 0,
+  pseudoElement: 0
+});
+
+const SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/clipboard-apis/
+ */
+
+const ClipboardEventInterface = assign({}, EventInterface, {
+  clipboardData: function (event) {
+    return 'clipboardData' in event ? event.clipboardData : window.clipboardData;
+  }
+});
+
+const SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents
+ */
+
+const CompositionEventInterface = assign({}, EventInterface, {
+  data: 0
+});
+
+const SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105
+ *      /#events-inputevents
+ */
+// Happens to share the same list for now.
+
+const SyntheticInputEvent = SyntheticCompositionEvent;
+/**
+ * Normalization of deprecated HTML5 `key` values
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
+ */
+
+const normalizeKey = {
+  Esc: 'Escape',
+  Spacebar: ' ',
+  Left: 'ArrowLeft',
+  Up: 'ArrowUp',
+  Right: 'ArrowRight',
+  Down: 'ArrowDown',
+  Del: 'Delete',
+  Win: 'OS',
+  Menu: 'ContextMenu',
+  Apps: 'ContextMenu',
+  Scroll: 'ScrollLock',
+  MozPrintableKey: 'Unidentified'
+};
+/**
+ * Translation from legacy `keyCode` to HTML5 `key`
+ * Only special keys supported, all others depend on keyboard layout or browser
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
+ */
+
+const translateToKey = {
+  '8': 'Backspace',
+  '9': 'Tab',
+  '12': 'Clear',
+  '13': 'Enter',
+  '16': 'Shift',
+  '17': 'Control',
+  '18': 'Alt',
+  '19': 'Pause',
+  '20': 'CapsLock',
+  '27': 'Escape',
+  '32': ' ',
+  '33': 'PageUp',
+  '34': 'PageDown',
+  '35': 'End',
+  '36': 'Home',
+  '37': 'ArrowLeft',
+  '38': 'ArrowUp',
+  '39': 'ArrowRight',
+  '40': 'ArrowDown',
+  '45': 'Insert',
+  '46': 'Delete',
+  '112': 'F1',
+  '113': 'F2',
+  '114': 'F3',
+  '115': 'F4',
+  '116': 'F5',
+  '117': 'F6',
+  '118': 'F7',
+  '119': 'F8',
+  '120': 'F9',
+  '121': 'F10',
+  '122': 'F11',
+  '123': 'F12',
+  '144': 'NumLock',
+  '145': 'ScrollLock',
+  '224': 'Meta'
+};
+/**
+ * @param {object} nativeEvent Native browser event.
+ * @return {string} Normalized `key` property.
+ */
+
+function getEventKey(nativeEvent) {
+  if (nativeEvent.key) {
+    // Normalize inconsistent values reported by browsers due to
+    // implementations of a working draft specification.
+    // FireFox implements `key` but returns `MozPrintableKey` for all
+    // printable characters (normalized to `Unidentified`), ignore it.
+    const key = // $FlowFixMe[invalid-computed-prop] unable to index with a `mixed` value
+    normalizeKey[nativeEvent.key] || nativeEvent.key;
+
+    if (key !== 'Unidentified') {
+      return key;
+    }
+  } // Browser does not implement `key`, polyfill as much of it as we can.
+
+
+  if (nativeEvent.type === 'keypress') {
+    const charCode = getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
+    nativeEvent); // The enter-key is technically both printable and non-printable and can
+    // thus be captured by `keypress`, no other non-printable key should.
+
+    return charCode === 13 ? 'Enter' : String.fromCharCode(charCode);
+  }
+
+  if (nativeEvent.type === 'keydown' || nativeEvent.type === 'keyup') {
+    // While user keyboard layout determines the actual meaning of each
+    // `keyCode` value, almost all function keys have a universal value.
+    // $FlowFixMe[invalid-computed-prop] unable to index with a `mixed` value
+    return translateToKey[nativeEvent.keyCode] || 'Unidentified';
+  }
+
+  return '';
+}
+/**
+ * Translation from modifier key to the associated property in the event.
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers
+ */
+
+
+const modifierKeyToProp = {
+  Alt: 'altKey',
+  Control: 'ctrlKey',
+  Meta: 'metaKey',
+  Shift: 'shiftKey'
+}; // Older browsers (Safari <= 10, iOS Safari <= 10.2) do not support
+// getModifierState. If getModifierState is not supported, we map it to a set of
+// modifier keys exposed by the event. In this case, Lock-keys are not supported.
+// $FlowFixMe[missing-local-annot]
+// $FlowFixMe[missing-this-annot]
+
+function modifierStateGetter(keyArg) {
+  const syntheticEvent = this;
+  const nativeEvent = syntheticEvent.nativeEvent;
+
+  if (nativeEvent.getModifierState) {
+    return nativeEvent.getModifierState(keyArg);
+  }
+
+  const keyProp = modifierKeyToProp[keyArg];
+  return keyProp ? !!nativeEvent[keyProp] : false;
+}
+
+function getEventModifierState(nativeEvent) {
+  return modifierStateGetter;
+}
+/**
+ * @interface KeyboardEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+
+const KeyboardEventInterface = assign({}, UIEventInterface, {
+  key: getEventKey,
+  code: 0,
+  location: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  altKey: 0,
+  metaKey: 0,
+  repeat: 0,
+  locale: 0,
+  getModifierState: getEventModifierState,
+  // Legacy Interface
+  charCode: function (event) {
+    // `charCode` is the result of a KeyPress event and represents the value of
+    // the actual printable character.
+    // KeyPress is deprecated, but its replacement is not yet final and not
+    // implemented in any major browser. Only KeyPress has charCode.
+    if (event.type === 'keypress') {
+      return getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
+      event);
+    }
+
+    return 0;
+  },
+  keyCode: function (event) {
+    // `keyCode` is the result of a KeyDown/Up event and represents the value of
+    // physical keyboard key.
+    // The actual meaning of the value depends on the users' keyboard layout
+    // which cannot be detected. Assuming that it is a US keyboard layout
+    // provides a surprisingly accurate mapping for US and European users.
+    // Due to this, it is left to the user to implement at this time.
+    if (event.type === 'keydown' || event.type === 'keyup') {
+      return event.keyCode;
+    }
+
+    return 0;
+  },
+  which: function (event) {
+    // `which` is an alias for either `keyCode` or `charCode` depending on the
+    // type of the event.
+    if (event.type === 'keypress') {
+      return getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
+      event);
+    }
+
+    if (event.type === 'keydown' || event.type === 'keyup') {
+      return event.keyCode;
+    }
+
+    return 0;
+  }
+});
+
+const SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface);
+/**
+ * @interface PointerEvent
+ * @see http://www.w3.org/TR/pointerevents/
+ */
+
+const PointerEventInterface = assign({}, MouseEventInterface, {
+  pointerId: 0,
+  width: 0,
+  height: 0,
+  pressure: 0,
+  tangentialPressure: 0,
+  tiltX: 0,
+  tiltY: 0,
+  twist: 0,
+  pointerType: 0,
+  isPrimary: 0
+});
+
+const SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface);
+/**
+ * @interface TouchEvent
+ * @see http://www.w3.org/TR/touch-events/
+ */
+
+const TouchEventInterface = assign({}, UIEventInterface, {
+  touches: 0,
+  targetTouches: 0,
+  changedTouches: 0,
+  altKey: 0,
+  metaKey: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  getModifierState: getEventModifierState
+});
+
+const SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent
+ */
+
+const TransitionEventInterface = assign({}, EventInterface, {
+  propertyName: 0,
+  elapsedTime: 0,
+  pseudoElement: 0
+});
+
+const SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface);
+/**
+ * @interface WheelEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+const WheelEventInterface = assign({}, MouseEventInterface, {
+  deltaX(event) {
+    return 'deltaX' in event ? event.deltaX : // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).
+    'wheelDeltaX' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+    -event.wheelDeltaX : 0;
+  },
+
+  deltaY(event) {
+    return 'deltaY' in event ? event.deltaY : // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
+    'wheelDeltaY' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+    -event.wheelDeltaY : // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
+    'wheelDelta' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+    -event.wheelDelta : 0;
+  },
+
+  deltaZ: 0,
+  // Browsers without "deltaMode" is reporting in raw wheel delta where one
+  // notch on the scroll is always +/- 120, roughly equivalent to pixels.
+  // A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or
+  // ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.
+  deltaMode: 0
+});
+
+const SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface);
+
+/**
+ * This plugin invokes action functions on forms, inputs and buttons if
+ * the form doesn't prevent default.
+ */
+
+function extractEvents$6(dispatchQueue, domEventName, maybeTargetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  if (domEventName !== 'submit') {
+    return;
+  }
+
+  if (!maybeTargetInst || maybeTargetInst.stateNode !== nativeEventTarget) {
+    // If we're inside a parent root that itself is a parent of this root, then
+    // its deepest target won't be the actual form that's being submitted.
+    return;
+  }
+
+  const formInst = maybeTargetInst;
+  const form = nativeEventTarget;
+  let action = getFiberCurrentPropsFromNode(form).action;
+  let submitter = nativeEvent.submitter;
+  let submitterAction;
+
+  if (submitter) {
+    const submitterProps = getFiberCurrentPropsFromNode(submitter);
+    submitterAction = submitterProps ? submitterProps.formAction : submitter.getAttribute('formAction');
+
+    if (submitterAction != null) {
+      // The submitter overrides the form action.
+      action = submitterAction; // If the action is a function, we don't want to pass its name
+      // value to the FormData since it's controlled by the server.
+
+      submitter = null;
+    }
+  }
+
+  if (typeof action !== 'function') {
+    return;
+  }
+
+  const event = new SyntheticEvent('action', 'action', null, nativeEvent, nativeEventTarget);
+
+  function submitForm() {
+    if (nativeEvent.defaultPrevented) {
+      // We let earlier events to prevent the action from submitting.
+      return;
+    } // Prevent native navigation.
+
+
+    event.preventDefault();
+    let formData;
+
+    if (submitter) {
+      // The submitter's value should be included in the FormData.
+      // It should be in the document order in the form.
+      // Since the FormData constructor invokes the formdata event it also
+      // needs to be available before that happens so after construction it's too
+      // late. We use a temporary fake node for the duration of this event.
+      // TODO: FormData takes a second argument that it's the submitter but this
+      // is fairly new so not all browsers support it yet. Switch to that technique
+      // when available.
+      const temp = submitter.ownerDocument.createElement('input');
+      temp.name = submitter.name;
+      temp.value = submitter.value;
+      submitter.parentNode.insertBefore(temp, submitter);
+      formData = new FormData(form);
+      temp.parentNode.removeChild(temp);
+    } else {
+      formData = new FormData(form);
+    }
+
+    const pendingState = {
+      pending: true,
+      data: formData,
+      method: form.method,
+      action: action
+    };
+
+    startHostTransition(formInst, pendingState, action, formData);
+  }
+
+  dispatchQueue.push({
+    event,
+    listeners: [{
+      instance: null,
+      listener: submitForm,
+      currentTarget: form
+    }]
+  });
+}
+function dispatchReplayedFormAction(formInst, form, action, formData) {
+  const pendingState = {
+    pending: true,
+    data: formData,
+    method: form.method,
+    action: action
+  };
+
+  startHostTransition(formInst, pendingState, action, formData);
+}
+
+// has this definition built-in.
+
+let hasScheduledReplayAttempt = false; // The last of each continuous event type. We only need to replay the last one
+// if the last target was dehydrated.
+
+let queuedFocus = null;
+let queuedDrag = null;
+let queuedMouse = null; // For pointer events there can be one latest event per pointerId.
+
+const queuedPointers = new Map();
+const queuedPointerCaptures = new Map(); // We could consider replaying selectionchange and touchmoves too.
+
+const queuedExplicitHydrationTargets = [];
+const discreteReplayableEvents = ['mousedown', 'mouseup', 'touchcancel', 'touchend', 'touchstart', 'auxclick', 'dblclick', 'pointercancel', 'pointerdown', 'pointerup', 'dragend', 'dragstart', 'drop', 'compositionend', 'compositionstart', 'keydown', 'keypress', 'keyup', 'input', 'textInput', // Intentionally camelCase
+'copy', 'cut', 'paste', 'click', 'change', 'contextmenu', 'reset' // 'submit', // stopPropagation blocks the replay mechanism
+];
+function isDiscreteEventThatRequiresHydration(eventType) {
+  return discreteReplayableEvents.indexOf(eventType) > -1;
+}
+
+function createQueuedReplayableEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+  return {
+    blockedOn,
+    domEventName,
+    eventSystemFlags,
+    nativeEvent,
+    targetContainers: [targetContainer]
+  };
+} // Resets the replaying for this type of continuous event to no event.
+
+
+function clearIfContinuousEvent(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case 'focusin':
+    case 'focusout':
+      queuedFocus = null;
+      break;
+
+    case 'dragenter':
+    case 'dragleave':
+      queuedDrag = null;
+      break;
+
+    case 'mouseover':
+    case 'mouseout':
+      queuedMouse = null;
+      break;
+
+    case 'pointerover':
+    case 'pointerout':
+      {
+        const pointerId = nativeEvent.pointerId;
+        queuedPointers.delete(pointerId);
+        break;
+      }
+
+    case 'gotpointercapture':
+    case 'lostpointercapture':
+      {
+        const pointerId = nativeEvent.pointerId;
+        queuedPointerCaptures.delete(pointerId);
+        break;
+      }
+  }
+}
+
+function accumulateOrCreateContinuousQueuedReplayableEvent(existingQueuedEvent, blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+  if (existingQueuedEvent === null || existingQueuedEvent.nativeEvent !== nativeEvent) {
+    const queuedEvent = createQueuedReplayableEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent);
+
+    if (blockedOn !== null) {
+      const fiber = getInstanceFromNode$1(blockedOn);
+
+      if (fiber !== null) {
+        // Attempt to increase the priority of this target.
+        attemptContinuousHydration(fiber);
+      }
+    }
+
+    return queuedEvent;
+  } // If we have already queued this exact event, then it's because
+  // the different event systems have different DOM event listeners.
+  // We can accumulate the flags, and the targetContainers, and
+  // store a single event to be replayed.
+
+
+  existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
+  const targetContainers = existingQueuedEvent.targetContainers;
+
+  if (targetContainer !== null && targetContainers.indexOf(targetContainer) === -1) {
+    targetContainers.push(targetContainer);
+  }
+
+  return existingQueuedEvent;
+}
+
+function queueIfContinuousEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+  // These set relatedTarget to null because the replayed event will be treated as if we
+  // moved from outside the window (no target) onto the target once it hydrates.
+  // Instead of mutating we could clone the event.
+  switch (domEventName) {
+    case 'focusin':
+      {
+        const focusEvent = nativeEvent;
+        queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(queuedFocus, blockedOn, domEventName, eventSystemFlags, targetContainer, focusEvent);
+        return true;
+      }
+
+    case 'dragenter':
+      {
+        const dragEvent = nativeEvent;
+        queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(queuedDrag, blockedOn, domEventName, eventSystemFlags, targetContainer, dragEvent);
+        return true;
+      }
+
+    case 'mouseover':
+      {
+        const mouseEvent = nativeEvent;
+        queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(queuedMouse, blockedOn, domEventName, eventSystemFlags, targetContainer, mouseEvent);
+        return true;
+      }
+
+    case 'pointerover':
+      {
+        const pointerEvent = nativeEvent;
+        const pointerId = pointerEvent.pointerId;
+        queuedPointers.set(pointerId, accumulateOrCreateContinuousQueuedReplayableEvent(queuedPointers.get(pointerId) || null, blockedOn, domEventName, eventSystemFlags, targetContainer, pointerEvent));
+        return true;
+      }
+
+    case 'gotpointercapture':
+      {
+        const pointerEvent = nativeEvent;
+        const pointerId = pointerEvent.pointerId;
+        queuedPointerCaptures.set(pointerId, accumulateOrCreateContinuousQueuedReplayableEvent(queuedPointerCaptures.get(pointerId) || null, blockedOn, domEventName, eventSystemFlags, targetContainer, pointerEvent));
+        return true;
+      }
+  }
+
+  return false;
+} // Check if this target is unblocked. Returns true if it's unblocked.
+
+function attemptExplicitHydrationTarget(queuedTarget) {
+  // TODO: This function shares a lot of logic with findInstanceBlockingEvent.
+  // Try to unify them. It's a bit tricky since it would require two return
+  // values.
+  const targetInst = getClosestInstanceFromNode(queuedTarget.target);
+
+  if (targetInst !== null) {
+    const nearestMounted = getNearestMountedFiber(targetInst);
+
+    if (nearestMounted !== null) {
+      const tag = nearestMounted.tag;
+
+      if (tag === SuspenseComponent) {
+        const instance = getSuspenseInstanceFromFiber(nearestMounted);
+
+        if (instance !== null) {
+          // We're blocked on hydrating this boundary.
+          // Increase its priority.
+          queuedTarget.blockedOn = instance;
+          runWithPriority(queuedTarget.priority, () => {
+            attemptHydrationAtCurrentPriority(nearestMounted);
+          });
+          return;
+        }
+      } else if (tag === HostRoot) {
+        const root = nearestMounted.stateNode;
+
+        if (isRootDehydrated(root)) {
+          queuedTarget.blockedOn = getContainerFromFiber(nearestMounted); // We don't currently have a way to increase the priority of
+          // a root other than sync.
+
+          return;
+        }
+      }
+    }
+  }
+
+  queuedTarget.blockedOn = null;
+}
+
+function queueExplicitHydrationTarget(target) {
+  // TODO: This will read the priority if it's dispatched by the React
+  // event system but not native events. Should read window.event.type, like
+  // we do for updates (getCurrentEventPriority).
+  const updatePriority = getCurrentUpdatePriority();
+  const queuedTarget = {
+    blockedOn: null,
+    target: target,
+    priority: updatePriority
+  };
+  let i = 0;
+
+  for (; i < queuedExplicitHydrationTargets.length; i++) {
+    // Stop once we hit the first target with lower priority than
+    if (!isHigherEventPriority(updatePriority, queuedExplicitHydrationTargets[i].priority)) {
+      break;
+    }
+  }
+
+  queuedExplicitHydrationTargets.splice(i, 0, queuedTarget);
+
+  if (i === 0) {
+    attemptExplicitHydrationTarget(queuedTarget);
+  }
+}
+
+function attemptReplayContinuousQueuedEvent(queuedEvent) {
+  if (queuedEvent.blockedOn !== null) {
+    return false;
+  }
+
+  const targetContainers = queuedEvent.targetContainers;
+
+  while (targetContainers.length > 0) {
+    const nextBlockedOn = findInstanceBlockingEvent(queuedEvent.nativeEvent);
+
+    if (nextBlockedOn === null) {
+      const nativeEvent = queuedEvent.nativeEvent;
+      const nativeEventClone = new nativeEvent.constructor(nativeEvent.type, nativeEvent);
+      setReplayingEvent(nativeEventClone);
+      nativeEvent.target.dispatchEvent(nativeEventClone);
+      resetReplayingEvent();
+    } else {
+      // We're still blocked. Try again later.
+      const fiber = getInstanceFromNode$1(nextBlockedOn);
+
+      if (fiber !== null) {
+        attemptContinuousHydration(fiber);
+      }
+
+      queuedEvent.blockedOn = nextBlockedOn;
+      return false;
+    } // This target container was successfully dispatched. Try the next.
+
+
+    targetContainers.shift();
+  }
+
+  return true;
+}
+
+function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
+  if (attemptReplayContinuousQueuedEvent(queuedEvent)) {
+    map.delete(key);
+  }
+}
+
+function replayUnblockedEvents() {
+  hasScheduledReplayAttempt = false; // Replay any continuous events.
+
+  if (queuedFocus !== null && attemptReplayContinuousQueuedEvent(queuedFocus)) {
+    queuedFocus = null;
+  }
+
+  if (queuedDrag !== null && attemptReplayContinuousQueuedEvent(queuedDrag)) {
+    queuedDrag = null;
+  }
+
+  if (queuedMouse !== null && attemptReplayContinuousQueuedEvent(queuedMouse)) {
+    queuedMouse = null;
+  }
+
+  queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
+  queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
+}
+
+function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
+  if (queuedEvent.blockedOn === unblocked) {
+    queuedEvent.blockedOn = null;
+
+    if (!hasScheduledReplayAttempt) {
+      hasScheduledReplayAttempt = true; // Schedule a callback to attempt replaying as many events as are
+      // now unblocked. This first might not actually be unblocked yet.
+      // We could check it early to avoid scheduling an unnecessary callback.
+
+      Scheduler.unstable_scheduleCallback(Scheduler.unstable_NormalPriority, replayUnblockedEvents);
+    }
+  }
+} // [form, submitter or action, formData...]
+
+
+let lastScheduledReplayQueue = null;
+
+function replayUnblockedFormActions(formReplayingQueue) {
+  if (lastScheduledReplayQueue === formReplayingQueue) {
+    lastScheduledReplayQueue = null;
+  }
+
+  for (let i = 0; i < formReplayingQueue.length; i += 3) {
+    const form = formReplayingQueue[i];
+    const submitterOrAction = formReplayingQueue[i + 1];
+    const formData = formReplayingQueue[i + 2];
+
+    if (typeof submitterOrAction !== 'function') {
+      // This action is not hydrated yet. This might be because it's blocked on
+      // a different React instance or higher up our tree.
+      const blockedOn = findInstanceBlockingTarget(submitterOrAction || form);
+
+      if (blockedOn === null) {
+        // We're not blocked but we don't have an action. This must mean that
+        // this is in another React instance. We'll just skip past it.
+        continue;
+      } else {
+        // We're blocked on something in this React instance. We'll retry later.
+        break;
+      }
+    }
+
+    const formInst = getInstanceFromNode$1(form);
+
+    if (formInst !== null) {
+      // This is part of our instance.
+      // We're ready to replay this. Let's delete it from the queue.
+      formReplayingQueue.splice(i, 3);
+      i -= 3;
+      dispatchReplayedFormAction(formInst, form, submitterOrAction, formData); // Continue without incrementing the index.
+
+      continue;
+    } // This form must've been part of a different React instance.
+    // If we want to preserve ordering between React instances on the same root
+    // we'd need some way for the other instance to ping us when it's done.
+    // We'll just skip this and let the other instance execute it.
+
+  }
+}
+
+function scheduleReplayQueueIfNeeded(formReplayingQueue) {
+  // Schedule a callback to execute any unblocked form actions in.
+  // We only keep track of the last queue which means that if multiple React oscillate
+  // commits, we could schedule more callbacks than necessary but it's not a big deal
+  // and we only really except one instance.
+  if (lastScheduledReplayQueue !== formReplayingQueue) {
+    lastScheduledReplayQueue = formReplayingQueue;
+    Scheduler.unstable_scheduleCallback(Scheduler.unstable_NormalPriority, () => replayUnblockedFormActions(formReplayingQueue));
+  }
+}
+
+function retryIfBlockedOn(unblocked) {
+  if (queuedFocus !== null) {
+    scheduleCallbackIfUnblocked(queuedFocus, unblocked);
+  }
+
+  if (queuedDrag !== null) {
+    scheduleCallbackIfUnblocked(queuedDrag, unblocked);
+  }
+
+  if (queuedMouse !== null) {
+    scheduleCallbackIfUnblocked(queuedMouse, unblocked);
+  }
+
+  const unblock = queuedEvent => scheduleCallbackIfUnblocked(queuedEvent, unblocked);
+
+  queuedPointers.forEach(unblock);
+  queuedPointerCaptures.forEach(unblock);
+
+  for (let i = 0; i < queuedExplicitHydrationTargets.length; i++) {
+    const queuedTarget = queuedExplicitHydrationTargets[i];
+
+    if (queuedTarget.blockedOn === unblocked) {
+      queuedTarget.blockedOn = null;
+    }
+  }
+
+  while (queuedExplicitHydrationTargets.length > 0) {
+    const nextExplicitTarget = queuedExplicitHydrationTargets[0];
+
+    if (nextExplicitTarget.blockedOn !== null) {
+      // We're still blocked.
+      break;
+    } else {
+      attemptExplicitHydrationTarget(nextExplicitTarget);
+
+      if (nextExplicitTarget.blockedOn === null) {
+        // We're unblocked.
+        queuedExplicitHydrationTargets.shift();
+      }
+    }
+  }
+
+  {
+    // Check the document if there are any queued form actions.
+    const root = unblocked.getRootNode();
+    const formReplayingQueue = root.$$reactFormReplay;
+
+    if (formReplayingQueue != null) {
+      for (let i = 0; i < formReplayingQueue.length; i += 3) {
+        const form = formReplayingQueue[i];
+        const submitterOrAction = formReplayingQueue[i + 1];
+        const formProps = getFiberCurrentPropsFromNode(form);
+
+        if (typeof submitterOrAction === 'function') {
+          // This action has already resolved. We're just waiting to dispatch it.
+          if (!formProps) {
+            // This was not part of this React instance. It might have been recently
+            // unblocking us from dispatching our events. So let's make sure we schedule
+            // a retry.
+            scheduleReplayQueueIfNeeded(formReplayingQueue);
+          }
+
+          continue;
+        }
+
+        let target = form;
+
+        if (formProps) {
+          // This form belongs to this React instance but the submitter might
+          // not be done yet.
+          let action = null;
+          const submitter = submitterOrAction;
+
+          if (submitter && submitter.hasAttribute('formAction')) {
+            // The submitter is the one that is responsible for the action.
+            target = submitter;
+            const submitterProps = getFiberCurrentPropsFromNode(submitter);
+
+            if (submitterProps) {
+              // The submitter is part of this instance.
+              action = submitterProps.formAction;
+            } else {
+              const blockedOn = findInstanceBlockingTarget(target);
+
+              if (blockedOn !== null) {
+                // The submitter is not hydrated yet. We'll wait for it.
+                continue;
+              } // The submitter must have been a part of a different React instance.
+              // Except the form isn't. We don't dispatch actions in this scenario.
+
+            }
+          } else {
+            action = formProps.action;
+          }
+
+          if (typeof action === 'function') {
+            formReplayingQueue[i + 1] = action;
+          } else {
+            // Something went wrong so let's just delete this action.
+            formReplayingQueue.splice(i, 3);
+            i -= 3;
+          } // Schedule a replay in case this unblocked something.
+
+
+          scheduleReplayQueueIfNeeded(formReplayingQueue);
+          continue;
+        } // Something above this target is still blocked so we can't continue yet.
+        // We're not sure if this target is actually part of this React instance
+        // yet. It could be a different React as a child but at least some parent is.
+        // We must continue for any further queued actions.
+
+      }
+    }
+  }
+}
+
+const ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig; // TODO: can we stop exporting these?
+
+let _enabled = true; // This is exported in FB builds for use by legacy FB layer infra.
+// We'd like to remove this but it's not clear if this is safe.
+
+function setEnabled(enabled) {
+  _enabled = !!enabled;
+}
+function isEnabled() {
+  return _enabled;
+}
+function createEventListenerWrapperWithPriority(targetContainer, domEventName, eventSystemFlags) {
+  const eventPriority = getEventPriority(domEventName);
+  let listenerWrapper;
+
+  switch (eventPriority) {
+    case DiscreteEventPriority:
+      listenerWrapper = dispatchDiscreteEvent;
+      break;
+
+    case ContinuousEventPriority:
+      listenerWrapper = dispatchContinuousEvent;
+      break;
+
+    case DefaultEventPriority:
+    default:
+      listenerWrapper = dispatchEvent;
+      break;
+  }
+
+  return listenerWrapper.bind(null, domEventName, eventSystemFlags, targetContainer);
+}
+
+function dispatchDiscreteEvent(domEventName, eventSystemFlags, container, nativeEvent) {
+  const previousPriority = getCurrentUpdatePriority();
+  const prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
+
+  try {
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig.transition = prevTransition;
+  }
+}
+
+function dispatchContinuousEvent(domEventName, eventSystemFlags, container, nativeEvent) {
+  const previousPriority = getCurrentUpdatePriority();
+  const prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
+
+  try {
+    setCurrentUpdatePriority(ContinuousEventPriority);
+    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig.transition = prevTransition;
+  }
+}
+
+function dispatchEvent(domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+  if (!_enabled) {
+    return;
+  }
+
+  let blockedOn = findInstanceBlockingEvent(nativeEvent);
+
+  if (blockedOn === null) {
+    dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, return_targetInst, targetContainer);
+    clearIfContinuousEvent(domEventName, nativeEvent);
+    return;
+  }
+
+  if (queueIfContinuousEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent)) {
+    nativeEvent.stopPropagation();
+    return;
+  } // We need to clear only if we didn't queue because
+  // queueing is accumulative.
+
+
+  clearIfContinuousEvent(domEventName, nativeEvent);
+
+  if (eventSystemFlags & IS_CAPTURE_PHASE && isDiscreteEventThatRequiresHydration(domEventName)) {
+    while (blockedOn !== null) {
+      const fiber = getInstanceFromNode$1(blockedOn);
+
+      if (fiber !== null) {
+        attemptSynchronousHydration(fiber);
+      }
+
+      const nextBlockedOn = findInstanceBlockingEvent(nativeEvent);
+
+      if (nextBlockedOn === null) {
+        dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, return_targetInst, targetContainer);
+      }
+
+      if (nextBlockedOn === blockedOn) {
+        break;
+      }
+
+      blockedOn = nextBlockedOn;
+    }
+
+    if (blockedOn !== null) {
+      nativeEvent.stopPropagation();
+    }
+
+    return;
+  } // 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 findInstanceBlockingEvent(nativeEvent) {
+  const nativeEventTarget = getEventTarget(nativeEvent);
+  return findInstanceBlockingTarget(nativeEventTarget);
+}
+let return_targetInst = null; // Returns a SuspenseInstance or Container if it's blocked.
+// The return_targetInst field above is conceptually part of the return value.
+
+function findInstanceBlockingTarget(targetNode) {
+  // TODO: Warn if _enabled is false.
+  return_targetInst = null;
+  let targetInst = getClosestInstanceFromNode(targetNode);
+
+  if (targetInst !== null) {
+    const nearestMounted = getNearestMountedFiber(targetInst);
+
+    if (nearestMounted === null) {
+      // This tree has been unmounted already. Dispatch without a target.
+      targetInst = null;
+    } else {
+      const tag = nearestMounted.tag;
+
+      if (tag === SuspenseComponent) {
+        const instance = getSuspenseInstanceFromFiber(nearestMounted);
+
+        if (instance !== null) {
+          // Queue the event to be replayed later. Abort dispatching since we
+          // don't want this event dispatched twice through the event system.
+          // TODO: If this is the first discrete event in the queue. Schedule an increased
+          // priority for this boundary.
+          return instance;
+        } // This shouldn't happen, something went wrong but to avoid blocking
+        // the whole system, dispatch the event without a target.
+        // TODO: Warn.
+
+
+        targetInst = null;
+      } else if (tag === HostRoot) {
+        const root = nearestMounted.stateNode;
+
+        if (isRootDehydrated(root)) {
+          // If this happens during a replay something went wrong and it might block
+          // the whole system.
+          return getContainerFromFiber(nearestMounted);
+        }
+
+        targetInst = null;
+      } else if (nearestMounted !== targetInst) {
+        // If we get an event (ex: img onload) before committing that
+        // component's mount, ignore it for now (that is, treat it as if it was an
+        // event on a non-React tree). We might also consider queueing events and
+        // dispatching them after the mount.
+        targetInst = null;
+      }
+    }
+  }
+
+  return_targetInst = targetInst; // We're not blocked on anything.
+
+  return null;
+}
+function getEventPriority(domEventName) {
+  switch (domEventName) {
+    // Used by SimpleEventPlugin:
+    case 'cancel':
+    case 'click':
+    case 'close':
+    case 'contextmenu':
+    case 'copy':
+    case 'cut':
+    case 'auxclick':
+    case 'dblclick':
+    case 'dragend':
+    case 'dragstart':
+    case 'drop':
+    case 'focusin':
+    case 'focusout':
+    case 'input':
+    case 'invalid':
+    case 'keydown':
+    case 'keypress':
+    case 'keyup':
+    case 'mousedown':
+    case 'mouseup':
+    case 'paste':
+    case 'pause':
+    case 'play':
+    case 'pointercancel':
+    case 'pointerdown':
+    case 'pointerup':
+    case 'ratechange':
+    case 'reset':
+    case 'resize':
+    case 'seeked':
+    case 'submit':
+    case 'touchcancel':
+    case 'touchend':
+    case 'touchstart':
+    case 'volumechange': // Used by polyfills: (fall through)
+
+    case 'change':
+    case 'selectionchange':
+    case 'textInput':
+    case 'compositionstart':
+    case 'compositionend':
+    case 'compositionupdate': // Only enableCreateEventHandleAPI: (fall through)
+
+    case 'beforeblur':
+    case 'afterblur': // Not used by React but could be by user code: (fall through)
+
+    case 'beforeinput':
+    case 'blur':
+    case 'fullscreenchange':
+    case 'focus':
+    case 'hashchange':
+    case 'popstate':
+    case 'select':
+    case 'selectstart':
+      return DiscreteEventPriority;
+
+    case 'drag':
+    case 'dragenter':
+    case 'dragexit':
+    case 'dragleave':
+    case 'dragover':
+    case 'mousemove':
+    case 'mouseout':
+    case 'mouseover':
+    case 'pointermove':
+    case 'pointerout':
+    case 'pointerover':
+    case 'scroll':
+    case 'toggle':
+    case 'touchmove':
+    case 'wheel': // Not used by React but could be by user code: (fall through)
+
+    case 'mouseenter':
+    case 'mouseleave':
+    case 'pointerenter':
+    case 'pointerleave':
+      return ContinuousEventPriority;
+
+    case 'message':
+      {
+        // We might be in the Scheduler callback.
+        // Eventually this mechanism will be replaced by a check
+        // of the current priority on the native scheduler.
+        const schedulerPriority = getCurrentPriorityLevel();
+
+        switch (schedulerPriority) {
+          case ImmediatePriority:
+            return DiscreteEventPriority;
+
+          case UserBlockingPriority:
+            return ContinuousEventPriority;
+
+          case NormalPriority$1:
+          case LowPriority:
+            // TODO: Handle LowSchedulerPriority, somehow. Maybe the same lane as hydration.
+            return DefaultEventPriority;
+
+          case IdlePriority:
+            return IdleEventPriority;
+
+          default:
+            return DefaultEventPriority;
+        }
+      }
+
+    default:
+      return DefaultEventPriority;
+  }
+}
+
+function addEventBubbleListener(target, eventType, listener) {
+  target.addEventListener(eventType, listener, false);
+  return listener;
+}
+function addEventCaptureListener(target, eventType, listener) {
+  target.addEventListener(eventType, listener, true);
+  return listener;
+}
+function addEventCaptureListenerWithPassiveFlag(target, eventType, listener, passive) {
+  target.addEventListener(eventType, listener, {
+    capture: true,
+    passive
+  });
+  return listener;
+}
+function addEventBubbleListenerWithPassiveFlag(target, eventType, listener, passive) {
+  target.addEventListener(eventType, listener, {
+    passive
+  });
+  return listener;
+}
+
+/**
+ * These variables store information about text content of a target node,
+ * allowing comparison of content before and after a given event.
+ *
+ * Identify the node where selection currently begins, then observe
+ * both its text content and its current position in the DOM. Since the
+ * browser may natively replace the target node during composition, we can
+ * use its position to find its replacement.
+ *
+ *
+ */
+let root = null;
+let startText = null;
+let fallbackText = null;
+function initialize(nativeEventTarget) {
+  root = nativeEventTarget;
+  startText = getText();
+  return true;
+}
+function reset() {
+  root = null;
+  startText = null;
+  fallbackText = null;
+}
+function getData() {
+  if (fallbackText) {
+    return fallbackText;
+  }
+
+  let start;
+  const startValue = startText;
+  const startLength = startValue.length;
+  let end;
+  const endValue = getText();
+  const endLength = endValue.length;
+
+  for (start = 0; start < startLength; start++) {
+    if (startValue[start] !== endValue[start]) {
+      break;
+    }
+  }
+
+  const minEnd = startLength - start;
+
+  for (end = 1; end <= minEnd; end++) {
+    if (startValue[startLength - end] !== endValue[endLength - end]) {
+      break;
+    }
+  }
+
+  const sliceTail = end > 1 ? 1 - end : undefined;
+  fallbackText = endValue.slice(start, sliceTail);
+  return fallbackText;
+}
+function getText() {
+  if ('value' in root) {
+    return root.value;
+  }
+
+  return root.textContent;
+}
+
+const END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space
+
+const START_KEYCODE = 229;
+const canUseCompositionEvent = canUseDOM && 'CompositionEvent' in window;
+let documentMode = null;
+
+if (canUseDOM && 'documentMode' in document) {
+  documentMode = document.documentMode;
+} // Webkit offers a very useful `textInput` event that can be used to
+// directly represent `beforeInput`. The IE `textinput` event is not as
+// useful, so we don't use it.
+
+
+const canUseTextInputEvent = canUseDOM && 'TextEvent' in window && !documentMode; // In IE9+, we have access to composition events, but the data supplied
+// by the native compositionend event may be incorrect. Japanese ideographic
+// spaces, for instance (\u3000) are not recorded correctly.
+
+const useFallbackCompositionData = canUseDOM && (!canUseCompositionEvent || documentMode && documentMode > 8 && documentMode <= 11);
+const SPACEBAR_CODE = 32;
+const SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);
+
+function registerEvents$3() {
+  registerTwoPhaseEvent('onBeforeInput', ['compositionend', 'keypress', 'textInput', 'paste']);
+  registerTwoPhaseEvent('onCompositionEnd', ['compositionend', 'focusout', 'keydown', 'keypress', 'keyup', 'mousedown']);
+  registerTwoPhaseEvent('onCompositionStart', ['compositionstart', 'focusout', 'keydown', 'keypress', 'keyup', 'mousedown']);
+  registerTwoPhaseEvent('onCompositionUpdate', ['compositionupdate', 'focusout', 'keydown', 'keypress', 'keyup', 'mousedown']);
+} // Track whether we've ever handled a keypress on the space key.
+
+
+let hasSpaceKeypress = false;
+/**
+ * Return whether a native keypress event is assumed to be a command.
+ * This is required because Firefox fires `keypress` events for key commands
+ * (cut, copy, select-all, etc.) even though no character is inserted.
+ */
+
+function isKeypressCommand(nativeEvent) {
+  return (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) && // ctrlKey && altKey is equivalent to AltGr, and is not a command.
+  !(nativeEvent.ctrlKey && nativeEvent.altKey);
+}
+/**
+ * Translate native top level events into event types.
+ */
+
+
+function getCompositionEventType(domEventName) {
+  switch (domEventName) {
+    case 'compositionstart':
+      return 'onCompositionStart';
+
+    case 'compositionend':
+      return 'onCompositionEnd';
+
+    case 'compositionupdate':
+      return 'onCompositionUpdate';
+  }
+}
+/**
+ * Does our fallback best-guess model think this event signifies that
+ * composition has begun?
+ */
+
+
+function isFallbackCompositionStart(domEventName, nativeEvent) {
+  return domEventName === 'keydown' && nativeEvent.keyCode === START_KEYCODE;
+}
+/**
+ * Does our fallback mode think that this event is the end of composition?
+ */
+
+
+function isFallbackCompositionEnd(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case 'keyup':
+      // Command keys insert or clear IME input.
+      return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1;
+
+    case 'keydown':
+      // Expect IME keyCode on each keydown. If we get any other
+      // code we must have exited earlier.
+      return nativeEvent.keyCode !== START_KEYCODE;
+
+    case 'keypress':
+    case 'mousedown':
+    case 'focusout':
+      // Events are not possible without cancelling IME.
+      return true;
+
+    default:
+      return false;
+  }
+}
+/**
+ * Google Input Tools provides composition data via a CustomEvent,
+ * with the `data` property populated in the `detail` object. If this
+ * is available on the event object, use it. If not, this is a plain
+ * composition event and we have nothing special to extract.
+ *
+ * @param {object} nativeEvent
+ * @return {?string}
+ */
+
+
+function getDataFromCustomEvent(nativeEvent) {
+  const detail = nativeEvent.detail;
+
+  if (typeof detail === 'object' && 'data' in detail) {
+    return detail.data;
+  }
+
+  return null;
+}
+/**
+ * Check if a composition event was triggered by Korean IME.
+ * Our fallback mode does not work well with IE's Korean IME,
+ * so just use native composition events when Korean IME is used.
+ * Although CompositionEvent.locale property is deprecated,
+ * it is available in IE, where our fallback mode is enabled.
+ *
+ * @param {object} nativeEvent
+ * @return {boolean}
+ */
+
+
+function isUsingKoreanIME(nativeEvent) {
+  return nativeEvent.locale === 'ko';
+} // Track the current IME composition status, if any.
+
+
+let isComposing = false;
+/**
+ * @return {?object} A SyntheticCompositionEvent.
+ */
+
+function extractCompositionEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget) {
+  let eventType;
+  let fallbackData;
+
+  if (canUseCompositionEvent) {
+    eventType = getCompositionEventType(domEventName);
+  } else if (!isComposing) {
+    if (isFallbackCompositionStart(domEventName, nativeEvent)) {
+      eventType = 'onCompositionStart';
+    }
+  } else if (isFallbackCompositionEnd(domEventName, nativeEvent)) {
+    eventType = 'onCompositionEnd';
+  }
+
+  if (!eventType) {
+    return null;
+  }
+
+  if (useFallbackCompositionData && !isUsingKoreanIME(nativeEvent)) {
+    // The current composition is stored statically and must not be
+    // overwritten while composition continues.
+    if (!isComposing && eventType === 'onCompositionStart') {
+      isComposing = initialize(nativeEventTarget);
+    } else if (eventType === 'onCompositionEnd') {
+      if (isComposing) {
+        fallbackData = getData();
+      }
+    }
+  }
+
+  const listeners = accumulateTwoPhaseListeners(targetInst, eventType);
+
+  if (listeners.length > 0) {
+    const event = new SyntheticCompositionEvent(eventType, domEventName, null, nativeEvent, nativeEventTarget);
+    dispatchQueue.push({
+      event,
+      listeners
+    });
+
+    if (fallbackData) {
+      // Inject data generated from fallback path into the synthetic event.
+      // This matches the property of native CompositionEventInterface.
+      // $FlowFixMe[incompatible-use]
+      event.data = fallbackData;
+    } else {
+      const customData = getDataFromCustomEvent(nativeEvent);
+
+      if (customData !== null) {
+        // $FlowFixMe[incompatible-use]
+        event.data = customData;
+      }
+    }
+  }
+}
+
+function getNativeBeforeInputChars(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case 'compositionend':
+      return getDataFromCustomEvent(nativeEvent);
+
+    case 'keypress':
+      /**
+       * If native `textInput` events are available, our goal is to make
+       * use of them. However, there is a special case: the spacebar key.
+       * In Webkit, preventing default on a spacebar `textInput` event
+       * cancels character insertion, but it *also* causes the browser
+       * to fall back to its default spacebar behavior of scrolling the
+       * page.
+       *
+       * Tracking at:
+       * https://code.google.com/p/chromium/issues/detail?id=355103
+       *
+       * To avoid this issue, use the keypress event as if no `textInput`
+       * event is available.
+       */
+      const which = nativeEvent.which;
+
+      if (which !== SPACEBAR_CODE) {
+        return null;
+      }
+
+      hasSpaceKeypress = true;
+      return SPACEBAR_CHAR;
+
+    case 'textInput':
+      // Record the characters to be added to the DOM.
+      const chars = nativeEvent.data; // If it's a spacebar character, assume that we have already handled
+      // it at the keypress level and bail immediately. Android Chrome
+      // doesn't give us keycodes, so we need to ignore it.
+
+      if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {
+        return null;
+      }
+
+      return chars;
+
+    default:
+      // For other native event types, do nothing.
+      return null;
+  }
+}
+/**
+ * For browsers that do not provide the `textInput` event, extract the
+ * appropriate string to use for SyntheticInputEvent.
+ */
+
+
+function getFallbackBeforeInputChars(domEventName, nativeEvent) {
+  // If we are currently composing (IME) and using a fallback to do so,
+  // try to extract the composed characters from the fallback object.
+  // If composition event is available, we extract a string only at
+  // compositionevent, otherwise extract it at fallback events.
+  if (isComposing) {
+    if (domEventName === 'compositionend' || !canUseCompositionEvent && isFallbackCompositionEnd(domEventName, nativeEvent)) {
+      const chars = getData();
+      reset();
+      isComposing = false;
+      return chars;
+    }
+
+    return null;
+  }
+
+  switch (domEventName) {
+    case 'paste':
+      // If a paste event occurs after a keypress, throw out the input
+      // chars. Paste events should not lead to BeforeInput events.
+      return null;
+
+    case 'keypress':
+      /**
+       * As of v27, Firefox may fire keypress events even when no character
+       * will be inserted. A few possibilities:
+       *
+       * - `which` is `0`. Arrow keys, Esc key, etc.
+       *
+       * - `which` is the pressed key code, but no char is available.
+       *   Ex: 'AltGr + d` in Polish. There is no modified character for
+       *   this key combination and no character is inserted into the
+       *   document, but FF fires the keypress for char code `100` anyway.
+       *   No `input` event will occur.
+       *
+       * - `which` is the pressed key code, but a command combination is
+       *   being used. Ex: `Cmd+C`. No character is inserted, and no
+       *   `input` event will occur.
+       */
+      if (!isKeypressCommand(nativeEvent)) {
+        // IE fires the `keypress` event when a user types an emoji via
+        // Touch keyboard of Windows.  In such a case, the `char` property
+        // holds an emoji character like `\uD83D\uDE0A`.  Because its length
+        // is 2, the property `which` does not represent an emoji correctly.
+        // In such a case, we directly return the `char` property instead of
+        // using `which`.
+        if (nativeEvent.char && nativeEvent.char.length > 1) {
+          return nativeEvent.char;
+        } else if (nativeEvent.which) {
+          return String.fromCharCode(nativeEvent.which);
+        }
+      }
+
+      return null;
+
+    case 'compositionend':
+      return useFallbackCompositionData && !isUsingKoreanIME(nativeEvent) ? null : nativeEvent.data;
+
+    default:
+      return null;
+  }
+}
+/**
+ * Extract a SyntheticInputEvent for `beforeInput`, based on either native
+ * `textInput` or fallback behavior.
+ *
+ * @return {?object} A SyntheticInputEvent.
+ */
+
+
+function extractBeforeInputEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget) {
+  let chars;
+
+  if (canUseTextInputEvent) {
+    chars = getNativeBeforeInputChars(domEventName, nativeEvent);
+  } else {
+    chars = getFallbackBeforeInputChars(domEventName, nativeEvent);
+  } // If no characters are being inserted, no BeforeInput event should
+  // be fired.
+
+
+  if (!chars) {
+    return null;
+  }
+
+  const listeners = accumulateTwoPhaseListeners(targetInst, 'onBeforeInput');
+
+  if (listeners.length > 0) {
+    const event = new SyntheticInputEvent('onBeforeInput', 'beforeinput', null, nativeEvent, nativeEventTarget);
+    dispatchQueue.push({
+      event,
+      listeners
+    }); // $FlowFixMe[incompatible-use]
+
+    event.data = chars;
+  }
+}
+/**
+ * Create an `onBeforeInput` event to match
+ * http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.
+ *
+ * This event plugin is based on the native `textInput` event
+ * available in Chrome, Safari, Opera, and IE. This event fires after
+ * `onKeyPress` and `onCompositionEnd`, but before `onInput`.
+ *
+ * `beforeInput` is spec'd but not implemented in any browsers, and
+ * the `input` event does not provide any useful information about what has
+ * actually been added, contrary to the spec. Thus, `textInput` is the best
+ * available event to identify the characters that have actually been inserted
+ * into the target node.
+ *
+ * This plugin is also responsible for emitting `composition` events, thus
+ * allowing us to share composition fallback code for both `beforeInput` and
+ * `composition` event types.
+ */
+
+
+function extractEvents$5(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  extractCompositionEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+  extractBeforeInputEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+}
+
+/**
+ * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary
+ */
+const supportedInputTypes = {
+  color: true,
+  date: true,
+  datetime: true,
+  'datetime-local': true,
+  email: true,
+  month: true,
+  number: true,
+  password: true,
+  range: true,
+  search: true,
+  tel: true,
+  text: true,
+  time: true,
+  url: true,
+  week: true
+};
+
+function isTextInputElement(elem) {
+  const nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+
+  if (nodeName === 'input') {
+    return !!supportedInputTypes[elem.type];
+  }
+
+  if (nodeName === 'textarea') {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Checks if an event is supported in the current execution environment.
+ *
+ * NOTE: This will not work correctly for non-generic events such as `change`,
+ * `reset`, `load`, `error`, and `select`.
+ *
+ * Borrows from Modernizr.
+ *
+ * @param {string} eventNameSuffix Event name, e.g. "click".
+ * @return {boolean} True if the event is supported.
+ * @internal
+ * @license Modernizr 3.0.0pre (Custom Build) | MIT
+ */
+
+function isEventSupported(eventNameSuffix) {
+  if (!canUseDOM) {
+    return false;
+  }
+
+  const eventName = 'on' + eventNameSuffix;
+  let isSupported = (eventName in document);
+
+  if (!isSupported) {
+    const element = document.createElement('div');
+    element.setAttribute(eventName, 'return;');
+    isSupported = typeof element[eventName] === 'function';
+  }
+
+  return isSupported;
+}
+
+function registerEvents$2() {
+  registerTwoPhaseEvent('onChange', ['change', 'click', 'focusin', 'focusout', 'input', 'keydown', 'keyup', 'selectionchange']);
+}
+
+function createAndAccumulateChangeEvent(dispatchQueue, inst, nativeEvent, target) {
+  // Flag this event loop as needing state restore.
+  enqueueStateRestore(target);
+  const listeners = accumulateTwoPhaseListeners(inst, 'onChange');
+
+  if (listeners.length > 0) {
+    const event = new SyntheticEvent('onChange', 'change', null, nativeEvent, target);
+    dispatchQueue.push({
+      event,
+      listeners
+    });
+  }
+}
+/**
+ * For IE shims
+ */
+
+
+let activeElement$1 = null;
+let activeElementInst$1 = null;
+/**
+ * SECTION: handle `change` event
+ */
+
+function shouldUseChangeEvent(elem) {
+  const nodeName = elem.nodeName && elem.nodeName.toLowerCase();
+  return nodeName === 'select' || nodeName === 'input' && elem.type === 'file';
+}
+
+function manualDispatchChangeEvent(nativeEvent) {
+  const dispatchQueue = [];
+  createAndAccumulateChangeEvent(dispatchQueue, activeElementInst$1, nativeEvent, getEventTarget(nativeEvent)); // If change and propertychange bubbled, we'd just bind to it like all the
+  // other events and have it go through ReactBrowserEventEmitter. Since it
+  // doesn't, we manually listen for the events and so we have to enqueue and
+  // process the abstract event manually.
+  //
+  // Batching is necessary here in order to ensure that all event handlers run
+  // before the next rerender (including event handlers attached to ancestor
+  // elements instead of directly on the input). Without this, controlled
+  // components don't work properly in conjunction with event bubbling because
+  // the component is rerendered and the value reverted before all the event
+  // handlers can run. See https://github.com/facebook/react/issues/708.
+
+  batchedUpdates(runEventInBatch, dispatchQueue);
+}
+
+function runEventInBatch(dispatchQueue) {
+  processDispatchQueue(dispatchQueue, 0);
+}
+
+function getInstIfValueChanged(targetInst) {
+  const targetNode = getNodeFromInstance(targetInst);
+
+  if (updateValueIfChanged(targetNode)) {
+    return targetInst;
+  }
+}
+
+function getTargetInstForChangeEvent(domEventName, targetInst) {
+  if (domEventName === 'change') {
+    return targetInst;
+  }
+}
+/**
+ * SECTION: handle `input` event
+ */
+
+
+let isInputEventSupported = false;
+
+if (canUseDOM) {
+  // IE9 claims to support the input event but fails to trigger it when
+  // deleting text, so we ignore its input events.
+  isInputEventSupported = isEventSupported('input') && (!document.documentMode || document.documentMode > 9);
+}
+/**
+ * (For IE <=9) Starts tracking propertychange events on the passed-in element
+ * and override the value property so that we can distinguish user events from
+ * value changes in JS.
+ */
+
+
+function startWatchingForValueChange(target, targetInst) {
+  activeElement$1 = target;
+  activeElementInst$1 = targetInst;
+  activeElement$1.attachEvent('onpropertychange', handlePropertyChange);
+}
+/**
+ * (For IE <=9) Removes the event listeners from the currently-tracked element,
+ * if any exists.
+ */
+
+
+function stopWatchingForValueChange() {
+  if (!activeElement$1) {
+    return;
+  }
+
+  activeElement$1.detachEvent('onpropertychange', handlePropertyChange);
+  activeElement$1 = null;
+  activeElementInst$1 = null;
+}
+/**
+ * (For IE <=9) Handles a propertychange event, sending a `change` event if
+ * the value of the active element has changed.
+ */
+// $FlowFixMe[missing-local-annot]
+
+
+function handlePropertyChange(nativeEvent) {
+  if (nativeEvent.propertyName !== 'value') {
+    return;
+  }
+
+  if (getInstIfValueChanged(activeElementInst$1)) {
+    manualDispatchChangeEvent(nativeEvent);
+  }
+}
+
+function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
+  if (domEventName === 'focusin') {
+    // In IE9, propertychange fires for most input events but is buggy and
+    // doesn't fire when text is deleted, but conveniently, selectionchange
+    // appears to fire in all of the remaining cases so we catch those and
+    // forward the event if the value has changed
+    // In either case, we don't want to call the event handler if the value
+    // is changed from JS so we redefine a setter for `.value` that updates
+    // our activeElementValue variable, allowing us to ignore those changes
+    //
+    // stopWatching() should be a noop here but we call it just in case we
+    // missed a blur event somehow.
+    stopWatchingForValueChange();
+    startWatchingForValueChange(target, targetInst);
+  } else if (domEventName === 'focusout') {
+    stopWatchingForValueChange();
+  }
+} // For IE8 and IE9.
+
+
+function getTargetInstForInputEventPolyfill(domEventName, targetInst) {
+  if (domEventName === 'selectionchange' || domEventName === 'keyup' || domEventName === 'keydown') {
+    // On the selectionchange event, the target is just document which isn't
+    // helpful for us so just check activeElement instead.
+    //
+    // 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire
+    // propertychange on the first input event after setting `value` from a
+    // script and fires only keydown, keypress, keyup. Catching keyup usually
+    // gets it and catching keydown lets us fire an event for the first
+    // keystroke if user does a key repeat (it'll be a little delayed: right
+    // before the second keystroke). Other input methods (e.g., paste) seem to
+    // fire selectionchange normally.
+    return getInstIfValueChanged(activeElementInst$1);
+  }
+}
+/**
+ * SECTION: handle `click` event
+ */
+
+
+function shouldUseClickEvent(elem) {
+  // Use the `click` event to detect changes to checkbox and radio inputs.
+  // This approach works across all browsers, whereas `change` does not fire
+  // until `blur` in IE8.
+  const nodeName = elem.nodeName;
+  return nodeName && nodeName.toLowerCase() === 'input' && (elem.type === 'checkbox' || elem.type === 'radio');
+}
+
+function getTargetInstForClickEvent(domEventName, targetInst) {
+  if (domEventName === 'click') {
+    return getInstIfValueChanged(targetInst);
+  }
+}
+
+function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
+  if (domEventName === 'input' || domEventName === 'change') {
+    return getInstIfValueChanged(targetInst);
+  }
+}
+
+function handleControlledInputBlur(node, props) {
+  if (node.type !== 'number') {
+    return;
+  }
+
+  {
+    const isControlled = props.value != null;
+
+    if (isControlled) {
+      // If controlled, assign the value attribute to the current value on blur
+      setDefaultValue(node, 'number', node.value);
+    }
+  }
+}
+/**
+ * This plugin creates an `onChange` event that normalizes change events
+ * across form elements. This event fires at a time when it's possible to
+ * change the element's value without seeing a flicker.
+ *
+ * Supported elements are:
+ * - input (see `isTextInputElement`)
+ * - textarea
+ * - select
+ */
+
+
+function extractEvents$4(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  const targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
+  let getTargetInstFunc, handleEventFunc;
+
+  if (shouldUseChangeEvent(targetNode)) {
+    getTargetInstFunc = getTargetInstForChangeEvent;
+  } else if (isTextInputElement(targetNode)) {
+    if (isInputEventSupported) {
+      getTargetInstFunc = getTargetInstForInputOrChangeEvent;
+    } else {
+      getTargetInstFunc = getTargetInstForInputEventPolyfill;
+      handleEventFunc = handleEventsForInputEventPolyfill;
+    }
+  } else if (shouldUseClickEvent(targetNode)) {
+    getTargetInstFunc = getTargetInstForClickEvent;
+  } else if (targetInst && isCustomElement(targetInst.elementType)) {
+    getTargetInstFunc = getTargetInstForChangeEvent;
+  }
+
+  if (getTargetInstFunc) {
+    const inst = getTargetInstFunc(domEventName, targetInst);
+
+    if (inst) {
+      createAndAccumulateChangeEvent(dispatchQueue, inst, nativeEvent, nativeEventTarget);
+      return;
+    }
+  }
+
+  if (handleEventFunc) {
+    handleEventFunc(domEventName, targetNode, targetInst);
+  } // When blurring, set the value attribute for number inputs
+
+
+  if (domEventName === 'focusout' && targetInst) {
+    // These props aren't necessarily the most current but we warn for changing
+    // between controlled and uncontrolled, so it doesn't matter and the previous
+    // code was also broken for changes.
+    const props = targetInst.memoizedProps;
+    handleControlledInputBlur(targetNode, props);
+  }
+}
+
+function registerEvents$1() {
+  registerDirectEvent('onMouseEnter', ['mouseout', 'mouseover']);
+  registerDirectEvent('onMouseLeave', ['mouseout', 'mouseover']);
+  registerDirectEvent('onPointerEnter', ['pointerout', 'pointerover']);
+  registerDirectEvent('onPointerLeave', ['pointerout', 'pointerover']);
+}
+/**
+ * For almost every interaction we care about, there will be both a top-level
+ * `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that
+ * we do not extract duplicate events. However, moving the mouse into the
+ * browser from outside will not fire a `mouseout` event. In this case, we use
+ * the `mouseover` top-level event.
+ */
+
+
+function extractEvents$3(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  const isOverEvent = domEventName === 'mouseover' || domEventName === 'pointerover';
+  const isOutEvent = domEventName === 'mouseout' || domEventName === 'pointerout';
+
+  if (isOverEvent && !isReplayingEvent(nativeEvent)) {
+    // If this is an over event with a target, we might have already dispatched
+    // the event in the out event of the other target. If this is replayed,
+    // then it's because we couldn't dispatch against this target previously
+    // so we have to do it now instead.
+    const related = nativeEvent.relatedTarget || nativeEvent.fromElement;
+
+    if (related) {
+      // If the related node is managed by React, we can assume that we have
+      // already dispatched the corresponding events during its mouseout.
+      if (getClosestInstanceFromNode(related) || isContainerMarkedAsRoot(related)) {
+        return;
+      }
+    }
+  }
+
+  if (!isOutEvent && !isOverEvent) {
+    // Must not be a mouse or pointer in or out - ignoring.
+    return;
+  }
+
+  let win; // TODO: why is this nullable in the types but we read from it?
+
+  if (nativeEventTarget.window === nativeEventTarget) {
+    // `nativeEventTarget` is probably a window object.
+    win = nativeEventTarget;
+  } else {
+    // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.
+    const doc = nativeEventTarget.ownerDocument;
+
+    if (doc) {
+      win = doc.defaultView || doc.parentWindow;
+    } else {
+      win = window;
+    }
+  }
+
+  let from;
+  let to;
+
+  if (isOutEvent) {
+    const related = nativeEvent.relatedTarget || nativeEvent.toElement;
+    from = targetInst;
+    to = related ? getClosestInstanceFromNode(related) : null;
+
+    if (to !== null) {
+      const nearestMounted = getNearestMountedFiber(to);
+      const tag = to.tag;
+
+      if (to !== nearestMounted || tag !== HostComponent && (tag !== HostSingleton) && tag !== HostText) {
+        to = null;
+      }
+    }
+  } else {
+    // Moving to a node from outside the window.
+    from = null;
+    to = targetInst;
+  }
+
+  if (from === to) {
+    // Nothing pertains to our managed components.
+    return;
+  }
+
+  let SyntheticEventCtor = SyntheticMouseEvent;
+  let leaveEventType = 'onMouseLeave';
+  let enterEventType = 'onMouseEnter';
+  let eventTypePrefix = 'mouse';
+
+  if (domEventName === 'pointerout' || domEventName === 'pointerover') {
+    SyntheticEventCtor = SyntheticPointerEvent;
+    leaveEventType = 'onPointerLeave';
+    enterEventType = 'onPointerEnter';
+    eventTypePrefix = 'pointer';
+  }
+
+  const fromNode = from == null ? win : getNodeFromInstance(from);
+  const toNode = to == null ? win : getNodeFromInstance(to);
+  const leave = new SyntheticEventCtor(leaveEventType, eventTypePrefix + 'leave', from, nativeEvent, nativeEventTarget);
+  leave.target = fromNode;
+  leave.relatedTarget = toNode;
+  let enter = null; // We should only process this nativeEvent if we are processing
+  // the first ancestor. Next time, we will ignore the event.
+
+  const nativeTargetInst = getClosestInstanceFromNode(nativeEventTarget);
+
+  if (nativeTargetInst === targetInst) {
+    const enterEvent = new SyntheticEventCtor(enterEventType, eventTypePrefix + 'enter', to, nativeEvent, nativeEventTarget);
+    enterEvent.target = toNode;
+    enterEvent.relatedTarget = fromNode;
+    enter = enterEvent;
+  }
+
+  accumulateEnterLeaveTwoPhaseListeners(dispatchQueue, leave, enter, from, to);
+}
+
+/**
+ * Given any node return the first leaf node without children.
+ *
+ * @param {DOMElement|DOMTextNode} node
+ * @return {DOMElement|DOMTextNode}
+ */
+
+function getLeafNode(node) {
+  while (node && node.firstChild) {
+    node = node.firstChild;
+  }
+
+  return node;
+}
+/**
+ * Get the next sibling within a container. This will walk up the
+ * DOM if a node's siblings have been exhausted.
+ *
+ * @param {DOMElement|DOMTextNode} node
+ * @return {?DOMElement|DOMTextNode}
+ */
+
+
+function getSiblingNode(node) {
+  while (node) {
+    if (node.nextSibling) {
+      return node.nextSibling;
+    }
+
+    node = node.parentNode;
+  }
+}
+/**
+ * Get object describing the nodes which contain characters at offset.
+ *
+ * @param {DOMElement|DOMTextNode} root
+ * @param {number} offset
+ * @return {?object}
+ */
+
+
+function getNodeForCharacterOffset(root, offset) {
+  let node = getLeafNode(root);
+  let nodeStart = 0;
+  let nodeEnd = 0;
+
+  while (node) {
+    if (node.nodeType === TEXT_NODE) {
+      nodeEnd = nodeStart + node.textContent.length;
+
+      if (nodeStart <= offset && nodeEnd >= offset) {
+        return {
+          node: node,
+          offset: offset - nodeStart
+        };
+      }
+
+      nodeStart = nodeEnd;
+    }
+
+    node = getLeafNode(getSiblingNode(node));
+  }
+}
+
+/**
+ * @param {DOMElement} outerNode
+ * @return {?object}
+ */
+
+function getOffsets(outerNode) {
+  const ownerDocument = outerNode.ownerDocument;
+  const win = ownerDocument && ownerDocument.defaultView || window;
+  const selection = win.getSelection && win.getSelection();
+
+  if (!selection || selection.rangeCount === 0) {
+    return null;
+  }
+
+  const anchorNode = selection.anchorNode,
+        anchorOffset = selection.anchorOffset,
+        focusNode = selection.focusNode,
+        focusOffset = selection.focusOffset; // In Firefox, anchorNode and focusNode can be "anonymous divs", e.g. the
+  // up/down buttons on an <input type="number">. Anonymous divs do not seem to
+  // expose properties, triggering a "Permission denied error" if any of its
+  // properties are accessed. The only seemingly possible way to avoid erroring
+  // is to access a property that typically works for non-anonymous divs and
+  // catch any error that may otherwise arise. See
+  // https://bugzilla.mozilla.org/show_bug.cgi?id=208427
+
+  try {
+    /* eslint-disable ft-flow/no-unused-expressions */
+    anchorNode.nodeType;
+    focusNode.nodeType;
+    /* eslint-enable ft-flow/no-unused-expressions */
+  } catch (e) {
+    return null;
+  }
+
+  return getModernOffsetsFromPoints(outerNode, anchorNode, anchorOffset, focusNode, focusOffset);
+}
+/**
+ * Returns {start, end} where `start` is the character/codepoint index of
+ * (anchorNode, anchorOffset) within the textContent of `outerNode`, and
+ * `end` is the index of (focusNode, focusOffset).
+ *
+ * Returns null if you pass in garbage input but we should probably just crash.
+ *
+ * Exported only for testing.
+ */
+
+function getModernOffsetsFromPoints(outerNode, anchorNode, anchorOffset, focusNode, focusOffset) {
+  let length = 0;
+  let start = -1;
+  let end = -1;
+  let indexWithinAnchor = 0;
+  let indexWithinFocus = 0;
+  let node = outerNode;
+  let parentNode = null;
+
+  outer: while (true) {
+    let next = null;
+
+    while (true) {
+      if (node === anchorNode && (anchorOffset === 0 || node.nodeType === TEXT_NODE)) {
+        start = length + anchorOffset;
+      }
+
+      if (node === focusNode && (focusOffset === 0 || node.nodeType === TEXT_NODE)) {
+        end = length + focusOffset;
+      }
+
+      if (node.nodeType === TEXT_NODE) {
+        length += node.nodeValue.length;
+      }
+
+      if ((next = node.firstChild) === null) {
+        break;
+      } // Moving from `node` to its first child `next`.
+
+
+      parentNode = node;
+      node = next;
+    }
+
+    while (true) {
+      if (node === outerNode) {
+        // If `outerNode` has children, this is always the second time visiting
+        // it. If it has no children, this is still the first loop, and the only
+        // valid selection is anchorNode and focusNode both equal to this node
+        // and both offsets 0, in which case we will have handled above.
+        break outer;
+      }
+
+      if (parentNode === anchorNode && ++indexWithinAnchor === anchorOffset) {
+        start = length;
+      }
+
+      if (parentNode === focusNode && ++indexWithinFocus === focusOffset) {
+        end = length;
+      }
+
+      if ((next = node.nextSibling) !== null) {
+        break;
+      }
+
+      node = parentNode;
+      parentNode = node.parentNode;
+    } // Moving from `node` to its next sibling `next`.
+
+
+    node = next;
+  }
+
+  if (start === -1 || end === -1) {
+    // This should never happen. (Would happen if the anchor/focus nodes aren't
+    // actually inside the passed-in node.)
+    return null;
+  }
+
+  return {
+    start: start,
+    end: end
+  };
+}
+/**
+ * In modern non-IE browsers, we can support both forward and backward
+ * selections.
+ *
+ * Note: IE10+ supports the Selection object, but it does not support
+ * the `extend` method, which means that even in modern IE, it's not possible
+ * to programmatically create a backward selection. Thus, for all IE
+ * versions, we use the old IE API to create our selections.
+ *
+ * @param {DOMElement|DOMTextNode} node
+ * @param {object} offsets
+ */
+
+function setOffsets(node, offsets) {
+  const doc = node.ownerDocument || document;
+  const win = doc && doc.defaultView || window; // Edge fails with "Object expected" in some scenarios.
+  // (For instance: TinyMCE editor used in a list component that supports pasting to add more,
+  // fails when pasting 100+ items)
+
+  if (!win.getSelection) {
+    return;
+  }
+
+  const selection = win.getSelection();
+  const length = node.textContent.length;
+  let start = Math.min(offsets.start, length);
+  let end = offsets.end === undefined ? start : Math.min(offsets.end, length); // IE 11 uses modern selection, but doesn't support the extend method.
+  // Flip backward selections, so we can set with a single range.
+
+  if (!selection.extend && start > end) {
+    const temp = end;
+    end = start;
+    start = temp;
+  }
+
+  const startMarker = getNodeForCharacterOffset(node, start);
+  const endMarker = getNodeForCharacterOffset(node, end);
+
+  if (startMarker && endMarker) {
+    if (selection.rangeCount === 1 && selection.anchorNode === startMarker.node && selection.anchorOffset === startMarker.offset && selection.focusNode === endMarker.node && selection.focusOffset === endMarker.offset) {
+      return;
+    }
+
+    const range = doc.createRange();
+    range.setStart(startMarker.node, startMarker.offset);
+    selection.removeAllRanges();
+
+    if (start > end) {
+      selection.addRange(range);
+      selection.extend(endMarker.node, endMarker.offset);
+    } else {
+      range.setEnd(endMarker.node, endMarker.offset);
+      selection.addRange(range);
+    }
+  }
+}
+
+function isTextNode(node) {
+  return node && node.nodeType === TEXT_NODE;
+}
+
+function containsNode(outerNode, innerNode) {
+  if (!outerNode || !innerNode) {
+    return false;
+  } else if (outerNode === innerNode) {
+    return true;
+  } else if (isTextNode(outerNode)) {
+    return false;
+  } else if (isTextNode(innerNode)) {
+    return containsNode(outerNode, innerNode.parentNode);
+  } else if ('contains' in outerNode) {
+    return outerNode.contains(innerNode);
+  } else if (outerNode.compareDocumentPosition) {
+    return !!(outerNode.compareDocumentPosition(innerNode) & 16);
+  } else {
+    return false;
+  }
+}
+
+function isInDocument(node) {
+  return node && node.ownerDocument && containsNode(node.ownerDocument.documentElement, node);
+}
+
+function isSameOriginFrame(iframe) {
+  try {
+    // Accessing the contentDocument of a HTMLIframeElement can cause the browser
+    // to throw, e.g. if it has a cross-origin src attribute.
+    // Safari will show an error in the console when the access results in "Blocked a frame with origin". e.g:
+    // iframe.contentDocument.defaultView;
+    // A safety way is to access one of the cross origin properties: Window or Location
+    // Which might result in "SecurityError" DOM Exception and it is compatible to Safari.
+    // https://html.spec.whatwg.org/multipage/browsers.html#integration-with-idl
+    return typeof iframe.contentWindow.location.href === 'string';
+  } catch (err) {
+    return false;
+  }
+}
+
+function getActiveElementDeep() {
+  let win = window;
+  let element = getActiveElement();
+
+  while (element instanceof win.HTMLIFrameElement) {
+    if (isSameOriginFrame(element)) {
+      win = element.contentWindow;
+    } else {
+      return element;
+    }
+
+    element = getActiveElement(win.document);
+  }
+
+  return element;
+}
+/**
+ * @ReactInputSelection: React input selection module. Based on Selection.js,
+ * but modified to be suitable for react and has a couple of bug fixes (doesn't
+ * assume buttons have range selections allowed).
+ * Input selection module for React.
+ */
+
+/**
+ * @hasSelectionCapabilities: we get the element types that support selection
+ * from https://html.spec.whatwg.org/#do-not-apply, looking at `selectionStart`
+ * and `selectionEnd` rows.
+ */
+
+
+function hasSelectionCapabilities(elem) {
+  const nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+  return nodeName && (nodeName === 'input' && (elem.type === 'text' || elem.type === 'search' || elem.type === 'tel' || elem.type === 'url' || elem.type === 'password') || nodeName === 'textarea' || elem.contentEditable === 'true');
+}
+function getSelectionInformation() {
+  const focusedElem = getActiveElementDeep();
+  return {
+    focusedElem: focusedElem,
+    selectionRange: hasSelectionCapabilities(focusedElem) ? getSelection$1(focusedElem) : null
+  };
+}
+/**
+ * @restoreSelection: If any selection information was potentially lost,
+ * restore it. This is useful when performing operations that could remove dom
+ * nodes and place them back in, resulting in focus being lost.
+ */
+
+function restoreSelection(priorSelectionInformation) {
+  const curFocusedElem = getActiveElementDeep();
+  const priorFocusedElem = priorSelectionInformation.focusedElem;
+  const priorSelectionRange = priorSelectionInformation.selectionRange;
+
+  if (curFocusedElem !== priorFocusedElem && isInDocument(priorFocusedElem)) {
+    if (priorSelectionRange !== null && hasSelectionCapabilities(priorFocusedElem)) {
+      setSelection(priorFocusedElem, priorSelectionRange);
+    } // Focusing a node can change the scroll position, which is undesirable
+
+
+    const ancestors = [];
+    let ancestor = priorFocusedElem;
+
+    while (ancestor = ancestor.parentNode) {
+      if (ancestor.nodeType === ELEMENT_NODE) {
+        ancestors.push({
+          element: ancestor,
+          left: ancestor.scrollLeft,
+          top: ancestor.scrollTop
+        });
+      }
+    }
+
+    if (typeof priorFocusedElem.focus === 'function') {
+      priorFocusedElem.focus();
+    }
+
+    for (let i = 0; i < ancestors.length; i++) {
+      const info = ancestors[i];
+      info.element.scrollLeft = info.left;
+      info.element.scrollTop = info.top;
+    }
+  }
+}
+/**
+ * @getSelection: Gets the selection bounds of a focused textarea, input or
+ * contentEditable node.
+ * -@input: Look up selection bounds of this input
+ * -@return {start: selectionStart, end: selectionEnd}
+ */
+
+function getSelection$1(input) {
+  let selection;
+
+  if ('selectionStart' in input) {
+    // Modern browser with input or textarea.
+    selection = {
+      start: input.selectionStart,
+      end: input.selectionEnd
+    };
+  } else {
+    // Content editable or old IE textarea.
+    selection = getOffsets(input);
+  }
+
+  return selection || {
+    start: 0,
+    end: 0
+  };
+}
+/**
+ * @setSelection: Sets the selection bounds of a textarea or input and focuses
+ * the input.
+ * -@input     Set selection bounds of this input or textarea
+ * -@offsets   Object of same form that is returned from get*
+ */
+
+function setSelection(input, offsets) {
+  const start = offsets.start;
+  let end = offsets.end;
+
+  if (end === undefined) {
+    end = start;
+  }
+
+  if ('selectionStart' in input) {
+    input.selectionStart = start;
+    input.selectionEnd = Math.min(end, input.value.length);
+  } else {
+    setOffsets(input, offsets);
+  }
+}
+
+const skipSelectionChangeEvent = canUseDOM && 'documentMode' in document && document.documentMode <= 11;
+
+function registerEvents() {
+  registerTwoPhaseEvent('onSelect', ['focusout', 'contextmenu', 'dragend', 'focusin', 'keydown', 'keyup', 'mousedown', 'mouseup', 'selectionchange']);
+}
+
+let activeElement = null;
+let activeElementInst = null;
+let lastSelection = null;
+let mouseDown = false;
+/**
+ * Get an object which is a unique representation of the current selection.
+ *
+ * The return value will not be consistent across nodes or browsers, but
+ * two identical selections on the same node will return identical objects.
+ */
+
+function getSelection(node) {
+  if ('selectionStart' in node && hasSelectionCapabilities(node)) {
+    return {
+      start: node.selectionStart,
+      end: node.selectionEnd
+    };
+  } else {
+    const win = node.ownerDocument && node.ownerDocument.defaultView || window;
+    const selection = win.getSelection();
+    return {
+      anchorNode: selection.anchorNode,
+      anchorOffset: selection.anchorOffset,
+      focusNode: selection.focusNode,
+      focusOffset: selection.focusOffset
+    };
+  }
+}
+/**
+ * Get document associated with the event target.
+ */
+
+
+function getEventTargetDocument(eventTarget) {
+  return eventTarget.window === eventTarget ? eventTarget.document : eventTarget.nodeType === DOCUMENT_NODE ? eventTarget : eventTarget.ownerDocument;
+}
+/**
+ * Poll selection to see whether it's changed.
+ *
+ * @param {object} nativeEvent
+ * @param {object} nativeEventTarget
+ * @return {?SyntheticEvent}
+ */
+
+
+function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
+  // Ensure we have the right element, and that the user is not dragging a
+  // selection (this matches native `select` event behavior). In HTML5, select
+  // fires only on input and textarea thus if there's no focused element we
+  // won't dispatch.
+  const doc = getEventTargetDocument(nativeEventTarget);
+
+  if (mouseDown || activeElement == null || activeElement !== getActiveElement(doc)) {
+    return;
+  } // Only fire when selection has actually changed.
+
+
+  const currentSelection = getSelection(activeElement);
+
+  if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {
+    lastSelection = currentSelection;
+    const listeners = accumulateTwoPhaseListeners(activeElementInst, 'onSelect');
+
+    if (listeners.length > 0) {
+      const event = new SyntheticEvent('onSelect', 'select', null, nativeEvent, nativeEventTarget);
+      dispatchQueue.push({
+        event,
+        listeners
+      });
+      event.target = activeElement;
+    }
+  }
+}
+/**
+ * This plugin creates an `onSelect` event that normalizes select events
+ * across form elements.
+ *
+ * Supported elements are:
+ * - input (see `isTextInputElement`)
+ * - textarea
+ * - contentEditable
+ *
+ * This differs from native browser implementations in the following ways:
+ * - Fires on contentEditable fields as well as inputs.
+ * - Fires for collapsed selection.
+ * - Fires after user input.
+ */
+
+
+function extractEvents$2(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  const targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
+
+  switch (domEventName) {
+    // Track the input node that has focus.
+    case 'focusin':
+      if (isTextInputElement(targetNode) || targetNode.contentEditable === 'true') {
+        activeElement = targetNode;
+        activeElementInst = targetInst;
+        lastSelection = null;
+      }
+
+      break;
+
+    case 'focusout':
+      activeElement = null;
+      activeElementInst = null;
+      lastSelection = null;
+      break;
+    // Don't fire the event while the user is dragging. This matches the
+    // semantics of the native select event.
+
+    case 'mousedown':
+      mouseDown = true;
+      break;
+
+    case 'contextmenu':
+    case 'mouseup':
+    case 'dragend':
+      mouseDown = false;
+      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+      break;
+    // Chrome and IE fire non-standard event when selection is changed (and
+    // sometimes when it hasn't). IE's event fires out of order with respect
+    // to key and input events on deletion, so we discard it.
+    //
+    // Firefox doesn't support selectionchange, so check selection status
+    // after each key entry. The selection changes after keydown and before
+    // keyup, but we check on keydown as well in the case of holding down a
+    // key, when multiple keydown events are fired but only one keyup is.
+    // This is also our approach for IE handling, for the reason above.
+
+    case 'selectionchange':
+      if (skipSelectionChangeEvent) {
+        break;
+      }
+
+    // falls through
+
+    case 'keydown':
+    case 'keyup':
+      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+  }
+}
+
+/**
+ * Generate a mapping of standard vendor prefixes using the defined style property and event name.
+ *
+ * @param {string} styleProp
+ * @param {string} eventName
+ * @returns {object}
+ */
+
+function makePrefixMap(styleProp, eventName) {
+  const prefixes = {};
+  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
+  prefixes['Webkit' + styleProp] = 'webkit' + eventName;
+  prefixes['Moz' + styleProp] = 'moz' + eventName;
+  return prefixes;
+}
+/**
+ * A list of event names to a configurable list of vendor prefixes.
+ */
+
+
+const vendorPrefixes = {
+  animationend: makePrefixMap('Animation', 'AnimationEnd'),
+  animationiteration: makePrefixMap('Animation', 'AnimationIteration'),
+  animationstart: makePrefixMap('Animation', 'AnimationStart'),
+  transitionend: makePrefixMap('Transition', 'TransitionEnd')
+};
+/**
+ * Event names that have already been detected and prefixed (if applicable).
+ */
+
+const prefixedEventNames = {};
+/**
+ * Element to check for prefixes on.
+ */
+
+let style = {};
+/**
+ * Bootstrap if a DOM exists.
+ */
+
+if (canUseDOM) {
+  style = document.createElement('div').style; // On some platforms, in particular some releases of Android 4.x,
+  // the un-prefixed "animation" and "transition" properties are defined on the
+  // style object but the events that fire will still be prefixed, so we need
+  // to check if the un-prefixed events are usable, and if not remove them from the map.
+
+  if (!('AnimationEvent' in window)) {
+    delete vendorPrefixes.animationend.animation;
+    delete vendorPrefixes.animationiteration.animation;
+    delete vendorPrefixes.animationstart.animation;
+  } // Same as above
+
+
+  if (!('TransitionEvent' in window)) {
+    delete vendorPrefixes.transitionend.transition;
+  }
+}
+/**
+ * Attempts to determine the correct vendor prefixed event name.
+ *
+ * @param {string} eventName
+ * @returns {string}
+ */
+
+
+function getVendorPrefixedEventName(eventName) {
+  if (prefixedEventNames[eventName]) {
+    return prefixedEventNames[eventName];
+  } else if (!vendorPrefixes[eventName]) {
+    return eventName;
+  }
+
+  const prefixMap = vendorPrefixes[eventName];
+
+  for (const styleProp in prefixMap) {
+    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {
+      return prefixedEventNames[eventName] = prefixMap[styleProp];
+    }
+  }
+
+  return eventName;
+}
+
+const ANIMATION_END = getVendorPrefixedEventName('animationend');
+const ANIMATION_ITERATION = getVendorPrefixedEventName('animationiteration');
+const ANIMATION_START = getVendorPrefixedEventName('animationstart');
+const TRANSITION_END = getVendorPrefixedEventName('transitionend');
+
+const topLevelEventsToReactNames = new Map(); // NOTE: Capitalization is important in this list!
+//
+// E.g. it needs "pointerDown", not "pointerdown".
+// This is because we derive both React name ("onPointerDown")
+// and DOM name ("pointerdown") from the same list.
+//
+// Exceptions that don't match this convention are listed separately.
+//
+// prettier-ignore
+
+const simpleEventPluginEvents = ['abort', 'auxClick', 'cancel', 'canPlay', 'canPlayThrough', 'click', 'close', 'contextMenu', 'copy', 'cut', 'drag', 'dragEnd', 'dragEnter', 'dragExit', 'dragLeave', 'dragOver', 'dragStart', 'drop', 'durationChange', 'emptied', 'encrypted', 'ended', 'error', 'gotPointerCapture', 'input', 'invalid', 'keyDown', 'keyPress', 'keyUp', 'load', 'loadedData', 'loadedMetadata', 'loadStart', 'lostPointerCapture', 'mouseDown', 'mouseMove', 'mouseOut', 'mouseOver', 'mouseUp', 'paste', 'pause', 'play', 'playing', 'pointerCancel', 'pointerDown', 'pointerMove', 'pointerOut', 'pointerOver', 'pointerUp', 'progress', 'rateChange', 'reset', 'resize', 'seeked', 'seeking', 'stalled', 'submit', 'suspend', 'timeUpdate', 'touchCancel', 'touchEnd', 'touchStart', 'volumeChange', 'scroll', 'scrollEnd', 'toggle', 'touchMove', 'waiting', 'wheel'];
+
+function registerSimpleEvent(domEventName, reactName) {
+  topLevelEventsToReactNames.set(domEventName, reactName);
+  registerTwoPhaseEvent(reactName, [domEventName]);
+}
+
+function registerSimpleEvents() {
+  for (let i = 0; i < simpleEventPluginEvents.length; i++) {
+    const eventName = simpleEventPluginEvents[i];
+    const domEventName = eventName.toLowerCase();
+    const capitalizedEvent = eventName[0].toUpperCase() + eventName.slice(1);
+    registerSimpleEvent(domEventName, 'on' + capitalizedEvent);
+  } // Special cases where event names don't match.
+
+
+  registerSimpleEvent(ANIMATION_END, 'onAnimationEnd');
+  registerSimpleEvent(ANIMATION_ITERATION, 'onAnimationIteration');
+  registerSimpleEvent(ANIMATION_START, 'onAnimationStart');
+  registerSimpleEvent('dblclick', 'onDoubleClick');
+  registerSimpleEvent('focusin', 'onFocus');
+  registerSimpleEvent('focusout', 'onBlur');
+  registerSimpleEvent(TRANSITION_END, 'onTransitionEnd');
+}
+
+function extractEvents$1(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  const reactName = topLevelEventsToReactNames.get(domEventName);
+
+  if (reactName === undefined) {
+    return;
+  }
+
+  let SyntheticEventCtor = SyntheticEvent;
+  let reactEventType = domEventName;
+
+  switch (domEventName) {
+    case 'keypress':
+      // Firefox creates a keypress event for function keys too. This removes
+      // the unwanted keypress events. Enter is however both printable and
+      // non-printable. One would expect Tab to be as well (but it isn't).
+      // TODO: Fixed in https://bugzilla.mozilla.org/show_bug.cgi?id=968056. Can
+      // probably remove.
+      if (getEventCharCode(nativeEvent) === 0) {
+        return;
+      }
+
+    /* falls through */
+
+    case 'keydown':
+    case 'keyup':
+      SyntheticEventCtor = SyntheticKeyboardEvent;
+      break;
+
+    case 'focusin':
+      reactEventType = 'focus';
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
+
+    case 'focusout':
+      reactEventType = 'blur';
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
+
+    case 'beforeblur':
+    case 'afterblur':
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
+
+    case 'click':
+      // Firefox creates a click event on right mouse clicks. This removes the
+      // unwanted click events.
+      // TODO: Fixed in https://phabricator.services.mozilla.com/D26793. Can
+      // probably remove.
+      if (nativeEvent.button === 2) {
+        return;
+      }
+
+    /* falls through */
+
+    case 'auxclick':
+    case 'dblclick':
+    case 'mousedown':
+    case 'mousemove':
+    case 'mouseup': // TODO: Disabled elements should not respond to mouse events
+
+    /* falls through */
+
+    case 'mouseout':
+    case 'mouseover':
+    case 'contextmenu':
+      SyntheticEventCtor = SyntheticMouseEvent;
+      break;
+
+    case 'drag':
+    case 'dragend':
+    case 'dragenter':
+    case 'dragexit':
+    case 'dragleave':
+    case 'dragover':
+    case 'dragstart':
+    case 'drop':
+      SyntheticEventCtor = SyntheticDragEvent;
+      break;
+
+    case 'touchcancel':
+    case 'touchend':
+    case 'touchmove':
+    case 'touchstart':
+      SyntheticEventCtor = SyntheticTouchEvent;
+      break;
+
+    case ANIMATION_END:
+    case ANIMATION_ITERATION:
+    case ANIMATION_START:
+      SyntheticEventCtor = SyntheticAnimationEvent;
+      break;
+
+    case TRANSITION_END:
+      SyntheticEventCtor = SyntheticTransitionEvent;
+      break;
+
+    case 'scroll':
+    case 'scrollend':
+      SyntheticEventCtor = SyntheticUIEvent;
+      break;
+
+    case 'wheel':
+      SyntheticEventCtor = SyntheticWheelEvent;
+      break;
+
+    case 'copy':
+    case 'cut':
+    case 'paste':
+      SyntheticEventCtor = SyntheticClipboardEvent;
+      break;
+
+    case 'gotpointercapture':
+    case 'lostpointercapture':
+    case 'pointercancel':
+    case 'pointerdown':
+    case 'pointermove':
+    case 'pointerout':
+    case 'pointerover':
+    case 'pointerup':
+      SyntheticEventCtor = SyntheticPointerEvent;
+      break;
+  }
+
+  const inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
+
+  {
+    // Some events don't bubble in the browser.
+    // In the past, React has always bubbled them, but this can be surprising.
+    // We're going to try aligning closer to the browser behavior by not bubbling
+    // them in React either. We'll start by not bubbling onScroll, and then expand.
+    const accumulateTargetOnly = !inCapturePhase && ( // TODO: ideally, we'd eventually add all events from
+    // nonDelegatedEvents list in DOMPluginEventSystem.
+    // Then we can remove this special list.
+    // This is a breaking change that can wait until React 18.
+    domEventName === 'scroll' || domEventName === 'scrollend');
+    const listeners = accumulateSinglePhaseListeners(targetInst, reactName, nativeEvent.type, inCapturePhase, accumulateTargetOnly);
+
+    if (listeners.length > 0) {
+      // Intentionally create event lazily.
+      const event = new SyntheticEventCtor(reactName, reactEventType, null, nativeEvent, nativeEventTarget);
+      dispatchQueue.push({
+        event,
+        listeners
+      });
+    }
+  }
+}
+
+registerSimpleEvents();
+registerEvents$1();
+registerEvents$2();
+registerEvents();
+registerEvents$3();
+
+function extractEvents(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  // TODO: we should remove the concept of a "SimpleEventPlugin".
+  // This is the basic functionality of the event system. All
+  // the other plugins are essentially polyfills. So the plugin
+  // should probably be inlined somewhere and have its logic
+  // be core the to event system. This would potentially allow
+  // us to ship builds of React without the polyfilled plugins below.
+  extractEvents$1(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags);
+  const shouldProcessPolyfillPlugins = (eventSystemFlags & SHOULD_NOT_PROCESS_POLYFILL_EVENT_PLUGINS) === 0; // We don't process these events unless we are in the
+  // event's native "bubble" phase, which means that we're
+  // not in the capture phase. That's because we emulate
+  // the capture phase here still. This is a trade-off,
+  // because in an ideal world we would not emulate and use
+  // the phases properly, like we do with the SimpleEvent
+  // plugin. However, the plugins below either expect
+  // emulation (EnterLeave) or use state localized to that
+  // plugin (BeforeInput, Change, Select). The state in
+  // these modules complicates things, as you'll essentially
+  // get the case where the capture phase event might change
+  // state, only for the following bubble event to come in
+  // later and not trigger anything as the state now
+  // invalidates the heuristics of the event plugin. We
+  // could alter all these plugins to work in such ways, but
+  // that might cause other unknown side-effects that we
+  // can't foresee right now.
+
+  if (shouldProcessPolyfillPlugins) {
+    extractEvents$3(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+    extractEvents$4(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+    extractEvents$2(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+    extractEvents$5(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+
+    {
+      extractEvents$6(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+    }
+  }
+} // List of events that need to be individually attached to media elements.
+
+
+const mediaEventTypes = ['abort', 'canplay', 'canplaythrough', 'durationchange', 'emptied', 'encrypted', 'ended', 'error', 'loadeddata', 'loadedmetadata', 'loadstart', 'pause', 'play', 'playing', 'progress', 'ratechange', 'resize', 'seeked', 'seeking', 'stalled', 'suspend', 'timeupdate', 'volumechange', 'waiting']; // We should not delegate these events to the container, but rather
+// set them on the actual target element itself. This is primarily
+// because these events do not consistently bubble in the DOM.
+
+const nonDelegatedEvents = new Set(['cancel', 'close', 'invalid', 'load', 'scroll', 'scrollend', 'toggle'].concat(mediaEventTypes));
+
+function executeDispatch(event, listener, currentTarget) {
+  const type = event.type || 'unknown-event';
+  event.currentTarget = currentTarget;
+  invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
+  event.currentTarget = null;
+}
+
+function processDispatchQueueItemsInOrder(event, dispatchListeners, inCapturePhase) {
+  let previousInstance;
+
+  if (inCapturePhase) {
+    for (let i = dispatchListeners.length - 1; i >= 0; i--) {
+      const _dispatchListeners$i = dispatchListeners[i],
+            instance = _dispatchListeners$i.instance,
+            currentTarget = _dispatchListeners$i.currentTarget,
+            listener = _dispatchListeners$i.listener;
+
+      if (instance !== previousInstance && event.isPropagationStopped()) {
+        return;
+      }
+
+      executeDispatch(event, listener, currentTarget);
+      previousInstance = instance;
+    }
+  } else {
+    for (let i = 0; i < dispatchListeners.length; i++) {
+      const _dispatchListeners$i2 = dispatchListeners[i],
+            instance = _dispatchListeners$i2.instance,
+            currentTarget = _dispatchListeners$i2.currentTarget,
+            listener = _dispatchListeners$i2.listener;
+
+      if (instance !== previousInstance && event.isPropagationStopped()) {
+        return;
+      }
+
+      executeDispatch(event, listener, currentTarget);
+      previousInstance = instance;
+    }
+  }
+}
+
+function processDispatchQueue(dispatchQueue, eventSystemFlags) {
+  const inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
+
+  for (let i = 0; i < dispatchQueue.length; i++) {
+    const _dispatchQueue$i = dispatchQueue[i],
+          event = _dispatchQueue$i.event,
+          listeners = _dispatchQueue$i.listeners;
+    processDispatchQueueItemsInOrder(event, listeners, inCapturePhase); //  event system doesn't use pooling.
+  } // This would be a good time to rethrow if any of the event handlers threw.
+
+
+  rethrowCaughtError();
+}
+
+function dispatchEventsForPlugins(domEventName, eventSystemFlags, nativeEvent, targetInst, targetContainer) {
+  const nativeEventTarget = getEventTarget(nativeEvent);
+  const dispatchQueue = [];
+  extractEvents(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags);
+  processDispatchQueue(dispatchQueue, eventSystemFlags);
+}
+
+function listenToNonDelegatedEvent(domEventName, targetElement) {
+
+  const isCapturePhaseListener = false;
+  const listenerSet = getEventListenerSet(targetElement);
+  const listenerSetKey = getListenerSetKey(domEventName, isCapturePhaseListener);
+
+  if (!listenerSet.has(listenerSetKey)) {
+    addTrappedEventListener(targetElement, domEventName, IS_NON_DELEGATED, isCapturePhaseListener);
+    listenerSet.add(listenerSetKey);
+  }
+}
+function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
+
+  let eventSystemFlags = 0;
+
+  if (isCapturePhaseListener) {
+    eventSystemFlags |= IS_CAPTURE_PHASE;
+  }
+
+  addTrappedEventListener(target, domEventName, eventSystemFlags, isCapturePhaseListener);
+} // This is only used by createEventHandle when the
+const listeningMarker = '_reactListening' + Math.random().toString(36).slice(2);
+function listenToAllSupportedEvents(rootContainerElement) {
+  if (!rootContainerElement[listeningMarker]) {
+    rootContainerElement[listeningMarker] = true;
+    allNativeEvents.forEach(domEventName => {
+      // We handle selectionchange separately because it
+      // doesn't bubble and needs to be on the document.
+      if (domEventName !== 'selectionchange') {
+        if (!nonDelegatedEvents.has(domEventName)) {
+          listenToNativeEvent(domEventName, false, rootContainerElement);
+        }
+
+        listenToNativeEvent(domEventName, true, rootContainerElement);
+      }
+    });
+    const ownerDocument = rootContainerElement.nodeType === DOCUMENT_NODE ? rootContainerElement : rootContainerElement.ownerDocument;
+
+    if (ownerDocument !== null) {
+      // The selectionchange event also needs deduplication
+      // but it is attached to the document.
+      if (!ownerDocument[listeningMarker]) {
+        ownerDocument[listeningMarker] = true;
+        listenToNativeEvent('selectionchange', false, ownerDocument);
+      }
+    }
+  }
+}
+
+function addTrappedEventListener(targetContainer, domEventName, eventSystemFlags, isCapturePhaseListener, isDeferredListenerForLegacyFBSupport) {
+  let listener = createEventListenerWrapperWithPriority(targetContainer, domEventName, eventSystemFlags); // If passive option is not supported, then the event will be
+  // active and not passive.
+
+  let isPassiveListener = undefined;
+
+  if (passiveBrowserEventsSupported) {
+    // Browsers introduced an intervention, making these events
+    // passive by default on document. React doesn't bind them
+    // to document anymore, but changing this now would undo
+    // the performance wins from the change. So we emulate
+    // the existing behavior manually on the roots now.
+    // https://github.com/facebook/react/issues/19651
+    if (domEventName === 'touchstart' || domEventName === 'touchmove' || domEventName === 'wheel') {
+      isPassiveListener = true;
+    }
+  }
+
+  targetContainer = targetContainer;
+
+
+  if (isCapturePhaseListener) {
+    if (isPassiveListener !== undefined) {
+      addEventCaptureListenerWithPassiveFlag(targetContainer, domEventName, listener, isPassiveListener);
+    } else {
+      addEventCaptureListener(targetContainer, domEventName, listener);
+    }
+  } else {
+    if (isPassiveListener !== undefined) {
+      addEventBubbleListenerWithPassiveFlag(targetContainer, domEventName, listener, isPassiveListener);
+    } else {
+      addEventBubbleListener(targetContainer, domEventName, listener);
+    }
+  }
+}
+
+function isMatchingRootContainer(grandContainer, targetContainer) {
+  return grandContainer === targetContainer || grandContainer.nodeType === COMMENT_NODE && grandContainer.parentNode === targetContainer;
+}
+
+function dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, targetInst, targetContainer) {
+  let ancestorInst = targetInst;
+
+  if ((eventSystemFlags & IS_EVENT_HANDLE_NON_MANAGED_NODE) === 0 && (eventSystemFlags & IS_NON_DELEGATED) === 0) {
+    const targetContainerNode = targetContainer; // If we are using the legacy FB support flag, we
+
+    if (targetInst !== null) {
+      // The below logic attempts to work out if we need to change
+      // the target fiber to a different ancestor. We had similar logic
+      // in the legacy event system, except the big difference between
+      // systems is that the modern event system now has an event listener
+      // attached to each React Root and React Portal Root. Together,
+      // the DOM nodes representing these roots are the "rootContainer".
+      // To figure out which ancestor instance we should use, we traverse
+      // up the fiber tree from the target instance and attempt to find
+      // root boundaries that match that of our current "rootContainer".
+      // If we find that "rootContainer", we find the parent fiber
+      // sub-tree for that root and make that our ancestor instance.
+      let node = targetInst;
+
+      mainLoop: while (true) {
+        if (node === null) {
+          return;
+        }
+
+        const nodeTag = node.tag;
+
+        if (nodeTag === HostRoot || nodeTag === HostPortal) {
+          let container = node.stateNode.containerInfo;
+
+          if (isMatchingRootContainer(container, targetContainerNode)) {
+            break;
+          }
+
+          if (nodeTag === HostPortal) {
+            // The target is a portal, but it's not the rootContainer we're looking for.
+            // Normally portals handle their own events all the way down to the root.
+            // So we should be able to stop now. However, we don't know if this portal
+            // was part of *our* root.
+            let grandNode = node.return;
+
+            while (grandNode !== null) {
+              const grandTag = grandNode.tag;
+
+              if (grandTag === HostRoot || grandTag === HostPortal) {
+                const grandContainer = grandNode.stateNode.containerInfo;
+
+                if (isMatchingRootContainer(grandContainer, targetContainerNode)) {
+                  // This is the rootContainer we're looking for and we found it as
+                  // a parent of the Portal. That means we can ignore it because the
+                  // Portal will bubble through to us.
+                  return;
+                }
+              }
+
+              grandNode = grandNode.return;
+            }
+          } // Now we need to find it's corresponding host fiber in the other
+          // tree. To do this we can use getClosestInstanceFromNode, but we
+          // need to validate that the fiber is a host instance, otherwise
+          // we need to traverse up through the DOM till we find the correct
+          // node that is from the other tree.
+
+
+          while (container !== null) {
+            const parentNode = getClosestInstanceFromNode(container);
+
+            if (parentNode === null) {
+              return;
+            }
+
+            const parentTag = parentNode.tag;
+
+            if (parentTag === HostComponent || parentTag === HostText || (parentTag === HostHoistable ) || (parentTag === HostSingleton )) {
+              node = ancestorInst = parentNode;
+              continue mainLoop;
+            }
+
+            container = container.parentNode;
+          }
+        }
+
+        node = node.return;
+      }
+    }
+  }
+
+  batchedUpdates(() => dispatchEventsForPlugins(domEventName, eventSystemFlags, nativeEvent, ancestorInst));
+}
+
+function createDispatchListener(instance, listener, currentTarget) {
+  return {
+    instance,
+    listener,
+    currentTarget
+  };
+}
+
+function accumulateSinglePhaseListeners(targetFiber, reactName, nativeEventType, inCapturePhase, accumulateTargetOnly, nativeEvent) {
+  const captureName = reactName !== null ? reactName + 'Capture' : null;
+  const reactEventName = inCapturePhase ? captureName : reactName;
+  let listeners = [];
+  let instance = targetFiber;
+  let lastHostComponent = null; // Accumulate all instances and listeners via the target -> root path.
+
+  while (instance !== null) {
+    const _instance = instance,
+          stateNode = _instance.stateNode,
+          tag = _instance.tag; // Handle listeners that are on HostComponents (i.e. <div>)
+
+    if ((tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton )) && stateNode !== null) {
+      lastHostComponent = stateNode; // createEventHandle listeners
+
+
+      if (reactEventName !== null) {
+        const listener = getListener(instance, reactEventName);
+
+        if (listener != null) {
+          listeners.push(createDispatchListener(instance, listener, lastHostComponent));
+        }
+      }
+    } // If we are only accumulating events for the target, then we don't
+    // continue to propagate through the React fiber tree to find other
+    // listeners.
+
+
+    if (accumulateTargetOnly) {
+      break;
+    } // If we are processing the onBeforeBlur event, then we need to take
+
+    instance = instance.return;
+  }
+
+  return listeners;
+} // We should only use this function for:
+// - BeforeInputEventPlugin
+// - ChangeEventPlugin
+// - SelectEventPlugin
+// This is because we only process these plugins
+// in the bubble phase, so we need to accumulate two
+// phase event listeners (via emulation).
+
+function accumulateTwoPhaseListeners(targetFiber, reactName) {
+  const captureName = reactName + 'Capture';
+  const listeners = [];
+  let instance = targetFiber; // Accumulate all instances and listeners via the target -> root path.
+
+  while (instance !== null) {
+    const _instance2 = instance,
+          stateNode = _instance2.stateNode,
+          tag = _instance2.tag; // Handle listeners that are on HostComponents (i.e. <div>)
+
+    if ((tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton )) && stateNode !== null) {
+      const currentTarget = stateNode;
+      const captureListener = getListener(instance, captureName);
+
+      if (captureListener != null) {
+        listeners.unshift(createDispatchListener(instance, captureListener, currentTarget));
+      }
+
+      const bubbleListener = getListener(instance, reactName);
+
+      if (bubbleListener != null) {
+        listeners.push(createDispatchListener(instance, bubbleListener, currentTarget));
+      }
+    }
+
+    instance = instance.return;
+  }
+
+  return listeners;
+}
+
+function getParent(inst) {
+  if (inst === null) {
+    return null;
+  }
+
+  do {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    inst = inst.return; // TODO: If this is a HostRoot we might want to bail out.
+    // That is depending on if we want nested subtrees (layers) to bubble
+    // events to their parent. We could also go through parentNode on the
+    // host node but that wouldn't work for React Native and doesn't let us
+    // do the portal feature.
+  } while (inst && inst.tag !== HostComponent && (inst.tag !== HostSingleton));
+
+  if (inst) {
+    return inst;
+  }
+
+  return null;
+}
+/**
+ * Return the lowest common ancestor of A and B, or null if they are in
+ * different trees.
+ */
+
+
+function getLowestCommonAncestor(instA, instB) {
+  let nodeA = instA;
+  let nodeB = instB;
+  let depthA = 0;
+
+  for (let tempA = nodeA; tempA; tempA = getParent(tempA)) {
+    depthA++;
+  }
+
+  let depthB = 0;
+
+  for (let tempB = nodeB; tempB; tempB = getParent(tempB)) {
+    depthB++;
+  } // If A is deeper, crawl up.
+
+
+  while (depthA - depthB > 0) {
+    nodeA = getParent(nodeA);
+    depthA--;
+  } // If B is deeper, crawl up.
+
+
+  while (depthB - depthA > 0) {
+    nodeB = getParent(nodeB);
+    depthB--;
+  } // Walk in lockstep until we find a match.
+
+
+  let depth = depthA;
+
+  while (depth--) {
+    if (nodeA === nodeB || nodeB !== null && nodeA === nodeB.alternate) {
+      return nodeA;
+    }
+
+    nodeA = getParent(nodeA);
+    nodeB = getParent(nodeB);
+  }
+
+  return null;
+}
+
+function accumulateEnterLeaveListenersForEvent(dispatchQueue, event, target, common, inCapturePhase) {
+  const registrationName = event._reactName;
+  const listeners = [];
+  let instance = target;
+
+  while (instance !== null) {
+    if (instance === common) {
+      break;
+    }
+
+    const _instance3 = instance,
+          alternate = _instance3.alternate,
+          stateNode = _instance3.stateNode,
+          tag = _instance3.tag;
+
+    if (alternate !== null && alternate === common) {
+      break;
+    }
+
+    if ((tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton )) && stateNode !== null) {
+      const currentTarget = stateNode;
+
+      if (inCapturePhase) {
+        const captureListener = getListener(instance, registrationName);
+
+        if (captureListener != null) {
+          listeners.unshift(createDispatchListener(instance, captureListener, currentTarget));
+        }
+      } else if (!inCapturePhase) {
+        const bubbleListener = getListener(instance, registrationName);
+
+        if (bubbleListener != null) {
+          listeners.push(createDispatchListener(instance, bubbleListener, currentTarget));
+        }
+      }
+    }
+
+    instance = instance.return;
+  }
+
+  if (listeners.length !== 0) {
+    dispatchQueue.push({
+      event,
+      listeners
+    });
+  }
+} // We should only use this function for:
+// - EnterLeaveEventPlugin
+// This is because we only process this plugin
+// in the bubble phase, so we need to accumulate two
+// phase event listeners.
+
+
+function accumulateEnterLeaveTwoPhaseListeners(dispatchQueue, leaveEvent, enterEvent, from, to) {
+  const common = from && to ? getLowestCommonAncestor(from, to) : null;
+
+  if (from !== null) {
+    accumulateEnterLeaveListenersForEvent(dispatchQueue, leaveEvent, from, common, false);
+  }
+
+  if (to !== null && enterEvent !== null) {
+    accumulateEnterLeaveListenersForEvent(dispatchQueue, enterEvent, to, common, true);
+  }
+}
+function getListenerSetKey(domEventName, capture) {
+  return domEventName + "__" + (capture ? 'capture' : 'bubble');
+}
+
+// It also can turn \u0000 into \uFFFD inside attributes.
+// https://www.w3.org/TR/html5/single-page.html#preprocessing-the-input-stream
+// If we have a mismatch, it might be caused by that.
+// We will still patch up in this case but not fire the warning.
+
+
+const NORMALIZE_NEWLINES_REGEX = /\r\n?/g;
+const NORMALIZE_NULL_AND_REPLACEMENT_REGEX = /\u0000|\uFFFD/g;
+
+function normalizeMarkupForTextOrAttribute(markup) {
+
+  const markupString = typeof markup === 'string' ? markup : '' + markup;
+  return markupString.replace(NORMALIZE_NEWLINES_REGEX, '\n').replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, '');
+}
+
+function checkForUnmatchedText(serverText, clientText, isConcurrentMode, shouldWarnDev) {
+  const normalizedClientText = normalizeMarkupForTextOrAttribute(clientText);
+  const normalizedServerText = normalizeMarkupForTextOrAttribute(serverText);
+
+  if (normalizedServerText === normalizedClientText) {
+    return;
+  }
+
+  if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {
+    // In concurrent roots, we throw when there's a text mismatch and revert to
+    // client rendering, up to the nearest Suspense boundary.
+    throw Error(formatProdErrorMessage(425));
+  }
+}
+
+function noop$1() {}
+
+function trapClickOnNonInteractiveElement(node) {
+  // Mobile Safari does not fire properly bubble click events on
+  // non-interactive elements, which means delegated click listeners do not
+  // fire. The workaround for this bug involves attaching an empty click
+  // listener on the target node.
+  // https://www.quirksmode.org/blog/archives/2010/09/click_event_del.html
+  // Just set it using the onclick property so that we don't have to manage any
+  // bookkeeping for it. Not sure if we need to clear it when the listener is
+  // removed.
+  // TODO: Only do this for the relevant Safaris maybe?
+  node.onclick = noop$1;
+}
+const xlinkNamespace = 'http://www.w3.org/1999/xlink';
+const xmlNamespace = 'http://www.w3.org/XML/1998/namespace';
+
+function setProp(domElement, tag, key, value, props, prevValue) {
+  switch (key) {
+    case 'children':
+      {
+        if (typeof value === 'string') {
+          // textContent on a <textarea> will cause the placeholder to not
+          // show within the <textarea> until it has been focused and blurred again.
+          // https://github.com/facebook/react/issues/6731#issuecomment-254874553
+
+
+          const canSetTextContent = (tag !== 'body') && (tag !== 'textarea' || value !== '');
+
+          if (canSetTextContent) {
+            setTextContent(domElement, value);
+          }
+        } else if (typeof value === 'number') {
+
+          const canSetTextContent = tag !== 'body';
+
+          if (canSetTextContent) {
+            setTextContent(domElement, '' + value);
+          }
+        }
+
+        break;
+      }
+    // These are very common props and therefore are in the beginning of the switch.
+    // TODO: aria-label is a very common prop but allows booleans so is not like the others
+    // but should ideally go in this list too.
+
+    case 'className':
+      setValueForKnownAttribute(domElement, 'class', value);
+      break;
+
+    case 'tabIndex':
+      // This has to be case sensitive in SVG.
+      setValueForKnownAttribute(domElement, 'tabindex', value);
+      break;
+
+    case 'dir':
+    case 'role':
+    case 'viewBox':
+    case 'width':
+    case 'height':
+      {
+        setValueForKnownAttribute(domElement, key, value);
+        break;
+      }
+
+    case 'style':
+      {
+        setValueForStyles(domElement, value, prevValue);
+        break;
+      }
+    // These attributes accept URLs. These must not allow javascript: URLS.
+
+    case 'src':
+    case 'href':
+      {
+        {
+          if (value === '') {
+
+            domElement.removeAttribute(key);
+            break;
+          }
+        }
+
+        if (value == null || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          domElement.removeAttribute(key);
+          break;
+        } // `setAttribute` with objects becomes only `[object]` in IE8/9,
+
+        const sanitizedValue = sanitizeURL('' + value);
+        domElement.setAttribute(key, sanitizedValue);
+        break;
+      }
+
+    case 'action':
+    case 'formAction':
+      {
+
+        {
+          if (typeof value === 'function') {
+            // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+            // because we'll preventDefault, but it can happen if a form is manually submitted or
+            // if someone calls stopPropagation before React gets the event.
+            // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+            // error message but the URL will be logged.
+            domElement.setAttribute(key, // eslint-disable-next-line no-script-url
+            "javascript:throw new Error('" + 'A React form was unexpectedly submitted. If you called form.submit() manually, ' + "consider using form.requestSubmit() instead. If you\\'re trying to use " + 'event.stopPropagation() in a submit event handler, consider also calling ' + 'event.preventDefault().' + "')");
+            break;
+          } else if (typeof prevValue === 'function') {
+            // When we're switching off a Server Action that was originally hydrated.
+            // The server control these fields during SSR that are now trailing.
+            // The regular diffing doesn't apply since we compare against the previous props.
+            // Instead, we need to force them to be set to whatever they should be now.
+            // This would be a lot cleaner if we did this whole fork in the per-tag approach.
+            if (key === 'formAction') {
+              if (tag !== 'input') {
+                // Setting the name here isn't completely safe for inputs if this is switching
+                // to become a radio button. In that case we let the tag based override take
+                // control.
+                setProp(domElement, tag, 'name', props.name, props, null);
+              }
+
+              setProp(domElement, tag, 'formEncType', props.formEncType, props, null);
+              setProp(domElement, tag, 'formMethod', props.formMethod, props, null);
+              setProp(domElement, tag, 'formTarget', props.formTarget, props, null);
+            } else {
+              setProp(domElement, tag, 'encType', props.encType, props, null);
+              setProp(domElement, tag, 'method', props.method, props, null);
+              setProp(domElement, tag, 'target', props.target, props, null);
+            }
+          }
+        }
+
+        if (value == null || !enableFormActions  || typeof value === 'symbol' || typeof value === 'boolean') {
+          domElement.removeAttribute(key);
+          break;
+        } // `setAttribute` with objects becomes only `[object]` in IE8/9,
+
+        const sanitizedValue = sanitizeURL('' + value);
+        domElement.setAttribute(key, sanitizedValue);
+        break;
+      }
+
+    case 'onClick':
+      {
+        // TODO: This cast may not be sound for SVG, MathML or custom elements.
+        if (value != null) {
+
+          trapClickOnNonInteractiveElement(domElement);
+        }
+
+        break;
+      }
+
+    case 'onScroll':
+      {
+        if (value != null) {
+
+          listenToNonDelegatedEvent('scroll', domElement);
+        }
+
+        break;
+      }
+
+    case 'onScrollEnd':
+      {
+        if (value != null) {
+
+          listenToNonDelegatedEvent('scrollend', domElement);
+        }
+
+        break;
+      }
+
+    case 'dangerouslySetInnerHTML':
+      {
+        if (value != null) {
+          if (typeof value !== 'object' || !('__html' in value)) {
+            throw Error(formatProdErrorMessage(61));
+          }
+
+          const nextHtml = value.__html;
+
+          if (nextHtml != null) {
+            if (props.children != null) {
+              throw Error(formatProdErrorMessage(60));
+            }
+
+            {
+              domElement.innerHTML = nextHtml;
+            }
+          }
+        }
+
+        break;
+      }
+    // Note: `option.selected` is not updated if `select.multiple` is
+    // disabled with `removeAttribute`. We have special logic for handling this.
+
+    case 'multiple':
+      {
+        domElement.multiple = value && typeof value !== 'function' && typeof value !== 'symbol';
+        break;
+      }
+
+    case 'muted':
+      {
+        domElement.muted = value && typeof value !== 'function' && typeof value !== 'symbol';
+        break;
+      }
+
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'defaultValue': // Reserved
+
+    case 'defaultChecked':
+    case 'innerHTML':
+      {
+        // Noop
+        break;
+      }
+
+    case 'autoFocus':
+      {
+        // We polyfill it separately on the client during commit.
+        // We could have excluded it in the property list instead of
+        // adding a special case here, but then it wouldn't be emitted
+        // on server rendering (but we *do* want to emit it in SSR).
+        break;
+      }
+
+    case 'xlinkHref':
+      {
+        if (value == null || typeof value === 'function' || typeof value === 'boolean' || typeof value === 'symbol') {
+          domElement.removeAttribute('xlink:href');
+          break;
+        } // `setAttribute` with objects becomes only `[object]` in IE8/9,
+
+        const sanitizedValue = sanitizeURL('' + value);
+        domElement.setAttributeNS(xlinkNamespace, 'xlink:href', sanitizedValue);
+        break;
+      }
+
+    case 'contentEditable':
+    case 'spellCheck':
+    case 'draggable':
+    case 'value':
+    case 'autoReverse':
+    case 'externalResourcesRequired':
+    case 'focusable':
+    case 'preserveAlpha':
+      {
+        // Booleanish String
+        // These are "enumerated" attributes that accept "true" and "false".
+        // In React, we let users pass `true` and `false` even though technically
+        // these aren't boolean attributes (they are coerced to strings).
+        // The SVG attributes are case-sensitive. Since the HTML attributes are
+        // insensitive they also work even though we canonically use lower case.
+        if (value != null && typeof value !== 'function' && typeof value !== 'symbol') {
+
+          domElement.setAttribute(key, '' + value);
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+    // Boolean
+
+    case 'allowFullScreen':
+    case 'async':
+    case 'autoPlay':
+    case 'controls':
+    case 'default':
+    case 'defer':
+    case 'disabled':
+    case 'disablePictureInPicture':
+    case 'disableRemotePlayback':
+    case 'formNoValidate':
+    case 'hidden':
+    case 'loop':
+    case 'noModule':
+    case 'noValidate':
+    case 'open':
+    case 'playsInline':
+    case 'readOnly':
+    case 'required':
+    case 'reversed':
+    case 'scoped':
+    case 'seamless':
+    case 'itemScope':
+      {
+        if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+          domElement.setAttribute(key, '');
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+    // Overloaded Boolean
+
+    case 'capture':
+    case 'download':
+      {
+        // An attribute that can be used as a flag as well as with a value.
+        // When true, it should be present (set either to an empty string or its name).
+        // When false, it should be omitted.
+        // For any other value, should be present with that value.
+        if (value === true) {
+          domElement.setAttribute(key, '');
+        } else if (value !== false && value != null && typeof value !== 'function' && typeof value !== 'symbol') {
+
+          domElement.setAttribute(key, value);
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+
+    case 'cols':
+    case 'rows':
+    case 'size':
+    case 'span':
+      {
+        // These are HTML attributes that must be positive numbers.
+        if (value != null && typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value) && value >= 1) {
+
+          domElement.setAttribute(key, value);
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+
+    case 'rowSpan':
+    case 'start':
+      {
+        // These are HTML attributes that must be numbers.
+        if (value != null && typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value)) {
+
+          domElement.setAttribute(key, value);
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+
+    case 'xlinkActuate':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:actuate', value);
+      break;
+
+    case 'xlinkArcrole':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:arcrole', value);
+      break;
+
+    case 'xlinkRole':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:role', value);
+      break;
+
+    case 'xlinkShow':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:show', value);
+      break;
+
+    case 'xlinkTitle':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:title', value);
+      break;
+
+    case 'xlinkType':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:type', value);
+      break;
+
+    case 'xmlBase':
+      setValueForNamespacedAttribute(domElement, xmlNamespace, 'xml:base', value);
+      break;
+
+    case 'xmlLang':
+      setValueForNamespacedAttribute(domElement, xmlNamespace, 'xml:lang', value);
+      break;
+
+    case 'xmlSpace':
+      setValueForNamespacedAttribute(domElement, xmlNamespace, 'xml:space', value);
+      break;
+    // Properties that should not be allowed on custom elements.
+
+    case 'is':
+      {
+        // passed it to createElement. We don't also need the attribute.
+        // However, our tests currently query for it so it's plausible someone
+        // else does too so it's break.
+
+
+        setValueForAttribute(domElement, 'is', value);
+        break;
+      }
+
+    case 'innerText':
+    case 'textContent':
+      {
+        break;
+      }
+
+    // Fall through
+
+    default:
+      {
+        if (key.length > 2 && (key[0] === 'o' || key[0] === 'O') && (key[1] === 'n' || key[1] === 'N')) ; else {
+          const attributeName = getAttributeAlias(key);
+          setValueForAttribute(domElement, attributeName, value);
+        }
+      }
+  }
+}
+
+function setPropOnCustomElement(domElement, tag, key, value, props, prevValue) {
+  switch (key) {
+    case 'style':
+      {
+        setValueForStyles(domElement, value, prevValue);
+        break;
+      }
+
+    case 'dangerouslySetInnerHTML':
+      {
+        if (value != null) {
+          if (typeof value !== 'object' || !('__html' in value)) {
+            throw Error(formatProdErrorMessage(61));
+          }
+
+          const nextHtml = value.__html;
+
+          if (nextHtml != null) {
+            if (props.children != null) {
+              throw Error(formatProdErrorMessage(60));
+            }
+
+            {
+              domElement.innerHTML = nextHtml;
+            }
+          }
+        }
+
+        break;
+      }
+
+    case 'children':
+      {
+        if (typeof value === 'string') {
+          setTextContent(domElement, value);
+        } else if (typeof value === 'number') {
+          setTextContent(domElement, '' + value);
+        }
+
+        break;
+      }
+
+    case 'onScroll':
+      {
+        if (value != null) {
+
+          listenToNonDelegatedEvent('scroll', domElement);
+        }
+
+        break;
+      }
+
+    case 'onScrollEnd':
+      {
+        if (value != null) {
+
+          listenToNonDelegatedEvent('scrollend', domElement);
+        }
+
+        break;
+      }
+
+    case 'onClick':
+      {
+        // TODO: This cast may not be sound for SVG, MathML or custom elements.
+        if (value != null) {
+
+          trapClickOnNonInteractiveElement(domElement);
+        }
+
+        break;
+      }
+
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'innerHTML':
+      {
+        // Noop
+        break;
+      }
+
+    case 'innerText': // Properties
+
+    case 'textContent':
+      {
+        break;
+      }
+
+    // Fall through
+
+    default:
+      {
+        if (registrationNameDependencies.hasOwnProperty(key)) ; else {
+          {
+            setValueForPropertyOnCustomComponent(domElement, key, value);
+          }
+        }
+      }
+  }
+}
+
+function setInitialProperties(domElement, tag, props) {
+
+
+  switch (tag) {
+    case 'div':
+    case 'span':
+    case 'svg':
+    case 'path':
+    case 'a':
+    case 'g':
+    case 'p':
+    case 'li':
+      {
+        // Fast track the most common tag types
+        break;
+      }
+
+    case 'input':
+      {
+        // listeners still fire for the invalid event.
+
+
+        listenToNonDelegatedEvent('invalid', domElement);
+        let name = null;
+        let type = null;
+        let value = null;
+        let defaultValue = null;
+        let checked = null;
+        let defaultChecked = null;
+
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'name':
+              {
+                name = propValue;
+                break;
+              }
+
+            case 'type':
+              {
+                type = propValue;
+                break;
+              }
+
+            case 'checked':
+              {
+                checked = propValue;
+                break;
+              }
+
+            case 'defaultChecked':
+              {
+                defaultChecked = propValue;
+                break;
+              }
+
+            case 'value':
+              {
+                value = propValue;
+                break;
+              }
+
+            case 'defaultValue':
+              {
+                defaultValue = propValue;
+                break;
+              }
+
+            case 'children':
+            case 'dangerouslySetInnerHTML':
+              {
+                if (propValue != null) {
+                  throw Error(formatProdErrorMessage(137, tag));
+                }
+
+                break;
+              }
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        } // TODO: Make sure we check if this is still unmounted or do any clean
+        initInput(domElement, value, defaultValue, checked, defaultChecked, type, name, false);
+        track(domElement);
+        return;
+      }
+
+    case 'select':
+      {
+        // listeners still fire for the invalid event.
+
+
+        listenToNonDelegatedEvent('invalid', domElement);
+        let value = null;
+        let defaultValue = null;
+        let multiple = null;
+
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'value':
+              {
+                value = propValue; // This is handled by initSelect below.
+
+                break;
+              }
+
+            case 'defaultValue':
+              {
+                defaultValue = propValue; // This is handled by initSelect below.
+
+                break;
+              }
+
+            case 'multiple':
+              {
+                multiple = propValue; // TODO: We don't actually have to fall through here because we set it
+                // in initSelect anyway. We can remove the special case in setProp.
+              }
+            // Fallthrough
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        }
+        initSelect(domElement, value, defaultValue, multiple);
+        return;
+      }
+
+    case 'textarea':
+      {
+        // listeners still fire for the invalid event.
+
+
+        listenToNonDelegatedEvent('invalid', domElement);
+        let value = null;
+        let defaultValue = null;
+        let children = null;
+
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'value':
+              {
+                value = propValue; // This is handled by initTextarea below.
+
+                break;
+              }
+
+            case 'defaultValue':
+              {
+                defaultValue = propValue;
+                break;
+              }
+
+            case 'children':
+              {
+                children = propValue; // Handled by initTextarea above.
+
+                break;
+              }
+
+            case 'dangerouslySetInnerHTML':
+              {
+                if (propValue != null) {
+                  // TODO: Do we really need a special error message for this. It's also pretty blunt.
+                  throw Error(formatProdErrorMessage(91));
+                }
+
+                break;
+              }
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        } // TODO: Make sure we check if this is still unmounted or do any clean
+        initTextarea(domElement, value, defaultValue, children);
+        track(domElement);
+        return;
+      }
+
+    case 'option':
+      {
+
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'selected':
+              {
+                // TODO: Remove support for selected on option.
+                domElement.selected = propValue && typeof propValue !== 'function' && typeof propValue !== 'symbol';
+                break;
+              }
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        }
+
+        return;
+      }
+
+    case 'dialog':
+      {
+        listenToNonDelegatedEvent('cancel', domElement);
+        listenToNonDelegatedEvent('close', domElement);
+        break;
+      }
+
+    case 'iframe':
+    case 'object':
+      {
+        // We listen to this event in case to ensure emulated bubble
+        // listeners still fire for the load event.
+        listenToNonDelegatedEvent('load', domElement);
+        break;
+      }
+
+    case 'video':
+    case 'audio':
+      {
+        // We listen to these events in case to ensure emulated bubble
+        // listeners still fire for all the media events.
+        for (let i = 0; i < mediaEventTypes.length; i++) {
+          listenToNonDelegatedEvent(mediaEventTypes[i], domElement);
+        }
+
+        break;
+      }
+
+    case 'image':
+      {
+        // We listen to these events in case to ensure emulated bubble
+        // listeners still fire for error and load events.
+        listenToNonDelegatedEvent('error', domElement);
+        listenToNonDelegatedEvent('load', domElement);
+        break;
+      }
+
+    case 'details':
+      {
+        // We listen to this event in case to ensure emulated bubble
+        // listeners still fire for the toggle event.
+        listenToNonDelegatedEvent('toggle', domElement);
+        break;
+      }
+
+    case 'embed':
+    case 'source':
+    case 'img':
+    case 'link':
+      {
+        // These are void elements that also need delegated events.
+        listenToNonDelegatedEvent('error', domElement);
+        listenToNonDelegatedEvent('load', domElement); // We fallthrough to the return of the void elements
+      }
+
+    case 'area':
+    case 'base':
+    case 'br':
+    case 'col':
+    case 'hr':
+    case 'keygen':
+    case 'meta':
+    case 'param':
+    case 'track':
+    case 'wbr':
+    case 'menuitem':
+      {
+        // Void elements
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'children':
+            case 'dangerouslySetInnerHTML':
+              {
+                // TODO: Can we make this a DEV warning to avoid this deny list?
+                throw Error(formatProdErrorMessage(137, tag));
+              }
+            // defaultChecked and defaultValue are ignored by setProp
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        }
+
+        return;
+      }
+
+    default:
+      {
+        if (isCustomElement(tag)) {
+          for (const propKey in props) {
+            if (!props.hasOwnProperty(propKey)) {
+              continue;
+            }
+
+            const propValue = props[propKey];
+
+            if (propValue == null) {
+              continue;
+            }
+
+            setPropOnCustomElement(domElement, tag, propKey, propValue, props, null);
+          }
+
+          return;
+        }
+      }
+  }
+
+  for (const propKey in props) {
+    if (!props.hasOwnProperty(propKey)) {
+      continue;
+    }
+
+    const propValue = props[propKey];
+
+    if (propValue == null) {
+      continue;
+    }
+
+    setProp(domElement, tag, propKey, propValue, props, null);
+  }
+}
+function updateProperties(domElement, tag, lastProps, nextProps) {
+
+  switch (tag) {
+    case 'div':
+    case 'span':
+    case 'svg':
+    case 'path':
+    case 'a':
+    case 'g':
+    case 'p':
+    case 'li':
+      {
+        // Fast track the most common tag types
+        break;
+      }
+
+    case 'input':
+      {
+        let name = null;
+        let type = null;
+        let value = null;
+        let defaultValue = null;
+        let lastDefaultValue = null;
+        let checked = null;
+        let defaultChecked = null;
+
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null) {
+            switch (propKey) {
+              case 'checked':
+                {
+                  break;
+                }
+
+              case 'value':
+                {
+                  // This is handled by updateWrapper below.
+                  break;
+                }
+
+              case 'defaultValue':
+                {
+                  lastDefaultValue = lastProp;
+                }
+              // defaultChecked and defaultValue are ignored by setProp
+              // Fallthrough
+
+              default:
+                {
+                  if (!nextProps.hasOwnProperty(propKey)) setProp(domElement, tag, propKey, null, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'type':
+                {
+                  type = nextProp;
+                  break;
+                }
+
+              case 'name':
+                {
+                  name = nextProp;
+                  break;
+                }
+
+              case 'checked':
+                {
+                  checked = nextProp;
+                  break;
+                }
+
+              case 'defaultChecked':
+                {
+                  defaultChecked = nextProp;
+                  break;
+                }
+
+              case 'value':
+                {
+                  value = nextProp;
+                  break;
+                }
+
+              case 'defaultValue':
+                {
+                  defaultValue = nextProp;
+                  break;
+                }
+
+              case 'children':
+              case 'dangerouslySetInnerHTML':
+                {
+                  if (nextProp != null) {
+                    throw Error(formatProdErrorMessage(137, tag));
+                  }
+
+                  break;
+                }
+
+              default:
+                {
+                  if (nextProp !== lastProp) setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        }
+        // happen after updating the rest of props. Otherwise HTML5 input validations
+        // raise warnings and prevent the new value from being assigned.
+
+
+        updateInput(domElement, value, defaultValue, lastDefaultValue, checked, defaultChecked, type, name);
+        return;
+      }
+
+    case 'select':
+      {
+        let value = null;
+        let defaultValue = null;
+        let multiple = null;
+        let wasMultiple = null;
+
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null) {
+            switch (propKey) {
+              case 'value':
+                {
+                  // This is handled by updateWrapper below.
+                  break;
+                }
+              // defaultValue are ignored by setProp
+
+              case 'multiple':
+                {
+                  wasMultiple = lastProp; // TODO: Move special case in here from setProp.
+                }
+              // Fallthrough
+
+              default:
+                {
+                  if (!nextProps.hasOwnProperty(propKey)) setProp(domElement, tag, propKey, null, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'value':
+                {
+                  value = nextProp; // This is handled by updateSelect below.
+
+                  break;
+                }
+
+              case 'defaultValue':
+                {
+                  defaultValue = nextProp;
+                  break;
+                }
+
+              case 'multiple':
+                {
+                  multiple = nextProp; // TODO: Just move the special case in here from setProp.
+                }
+              // Fallthrough
+
+              default:
+                {
+                  if (nextProp !== lastProp) setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        } // <select> value update needs to occur after <option> children
+        // reconciliation
+
+
+        updateSelect(domElement, value, defaultValue, multiple, wasMultiple);
+        return;
+      }
+
+    case 'textarea':
+      {
+        let value = null;
+        let defaultValue = null;
+
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+            switch (propKey) {
+              case 'value':
+                {
+                  // This is handled by updateTextarea below.
+                  break;
+                }
+
+              case 'children':
+                {
+                  // TODO: This doesn't actually do anything if it updates.
+                  break;
+                }
+              // defaultValue is ignored by setProp
+
+              default:
+                {
+                  setProp(domElement, tag, propKey, null, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'value':
+                {
+                  value = nextProp; // This is handled by updateTextarea below.
+
+                  break;
+                }
+
+              case 'defaultValue':
+                {
+                  defaultValue = nextProp;
+                  break;
+                }
+
+              case 'children':
+                {
+                  // TODO: This doesn't actually do anything if it updates.
+                  break;
+                }
+
+              case 'dangerouslySetInnerHTML':
+                {
+                  if (nextProp != null) {
+                    // TODO: Do we really need a special error message for this. It's also pretty blunt.
+                    throw Error(formatProdErrorMessage(91));
+                  }
+
+                  break;
+                }
+
+              default:
+                {
+                  if (nextProp !== lastProp) setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        updateTextarea(domElement, value, defaultValue);
+        return;
+      }
+
+    case 'option':
+      {
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+            switch (propKey) {
+              case 'selected':
+                {
+                  // TODO: Remove support for selected on option.
+                  domElement.selected = false;
+                  break;
+                }
+
+              default:
+                {
+                  setProp(domElement, tag, propKey, null, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && nextProp !== lastProp && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'selected':
+                {
+                  // TODO: Remove support for selected on option.
+                  domElement.selected = nextProp && typeof nextProp !== 'function' && typeof nextProp !== 'symbol';
+                  break;
+                }
+
+              default:
+                {
+                  setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        return;
+      }
+
+    case 'img':
+    case 'link':
+    case 'area':
+    case 'base':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'keygen':
+    case 'meta':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+    case 'menuitem':
+      {
+        // Void elements
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+            setProp(domElement, tag, propKey, null, nextProps, lastProp);
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && nextProp !== lastProp && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'children':
+              case 'dangerouslySetInnerHTML':
+                {
+                  if (nextProp != null) {
+                    // TODO: Can we make this a DEV warning to avoid this deny list?
+                    throw Error(formatProdErrorMessage(137, tag));
+                  }
+
+                  break;
+                }
+              // defaultChecked and defaultValue are ignored by setProp
+
+              default:
+                {
+                  setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        return;
+      }
+
+    default:
+      {
+        if (isCustomElement(tag)) {
+          for (const propKey in lastProps) {
+            const lastProp = lastProps[propKey];
+
+            if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+              setPropOnCustomElement(domElement, tag, propKey, null, nextProps, lastProp);
+            }
+          }
+
+          for (const propKey in nextProps) {
+            const nextProp = nextProps[propKey];
+            const lastProp = lastProps[propKey];
+
+            if (nextProps.hasOwnProperty(propKey) && nextProp !== lastProp && (nextProp != null || lastProp != null)) {
+              setPropOnCustomElement(domElement, tag, propKey, nextProp, nextProps, lastProp);
+            }
+          }
+
+          return;
+        }
+      }
+  }
+
+  for (const propKey in lastProps) {
+    const lastProp = lastProps[propKey];
+
+    if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+      setProp(domElement, tag, propKey, null, nextProps, lastProp);
+    }
+  }
+
+  for (const propKey in nextProps) {
+    const nextProp = nextProps[propKey];
+    const lastProp = lastProps[propKey];
+
+    if (nextProps.hasOwnProperty(propKey) && nextProp !== lastProp && (nextProp != null || lastProp != null)) {
+      setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+    }
+  }
+}
+
+function diffHydratedProperties(domElement, tag, props, isConcurrentMode, shouldWarnDev, hostContext) {
+
+
+  switch (tag) {
+    case 'dialog':
+      listenToNonDelegatedEvent('cancel', domElement);
+      listenToNonDelegatedEvent('close', domElement);
+      break;
+
+    case 'iframe':
+    case 'object':
+    case 'embed':
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the load event.
+      listenToNonDelegatedEvent('load', domElement);
+      break;
+
+    case 'video':
+    case 'audio':
+      // We listen to these events in case to ensure emulated bubble
+      // listeners still fire for all the media events.
+      for (let i = 0; i < mediaEventTypes.length; i++) {
+        listenToNonDelegatedEvent(mediaEventTypes[i], domElement);
+      }
+
+      break;
+
+    case 'source':
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the error event.
+      listenToNonDelegatedEvent('error', domElement);
+      break;
+
+    case 'img':
+    case 'image':
+    case 'link':
+      // We listen to these events in case to ensure emulated bubble
+      // listeners still fire for error and load events.
+      listenToNonDelegatedEvent('error', domElement);
+      listenToNonDelegatedEvent('load', domElement);
+      break;
+
+    case 'details':
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the toggle event.
+      listenToNonDelegatedEvent('toggle', domElement);
+      break;
+
+    case 'input':
+      // listeners still fire for the invalid event.
+
+
+      listenToNonDelegatedEvent('invalid', domElement); // TODO: Make sure we check if this is still unmounted or do any clean
+      // post mount to force it to diverge from attributes. However, for
+      // option and select we don't quite do the same thing and select
+      // is not resilient to the DOM state changing so we don't do that here.
+      // TODO: Consider not doing this for input and textarea.
+
+      initInput(domElement, props.value, props.defaultValue, props.checked, props.defaultChecked, props.type, props.name, true);
+      track(domElement);
+      break;
+
+    case 'option':
+      break;
+
+    case 'select':
+      // listeners still fire for the invalid event.
+
+
+      listenToNonDelegatedEvent('invalid', domElement);
+      break;
+
+    case 'textarea':
+      // listeners still fire for the invalid event.
+
+
+      listenToNonDelegatedEvent('invalid', domElement); // TODO: Make sure we check if this is still unmounted or do any clean
+      initTextarea(domElement, props.value, props.defaultValue, props.children);
+      track(domElement);
+      break;
+  }
+
+  const children = props.children; // For text content children we compare against textContent. This
+  // might match additional HTML that is hidden when we read it using
+  // textContent. E.g. "foo" will match "f<span>oo</span>" but that still
+  // satisfies our requirement. Our requirement is not to produce perfect
+  // HTML and attributes. Ideally we should preserve structure but it's
+  // ok not to if the visible content is still enough to indicate what
+  // even listeners these nodes might be wired up to.
+  // TODO: Warn if there is more than a single textNode as a child.
+  // TODO: Should we use domElement.firstChild.nodeValue to compare?
+
+  if (typeof children === 'string' || typeof children === 'number') {
+    if (domElement.textContent !== '' + children) {
+      if (props.suppressHydrationWarning !== true) {
+        checkForUnmatchedText(domElement.textContent, children, isConcurrentMode);
+      }
+
+      if (!isConcurrentMode || !enableClientRenderFallbackOnTextMismatch) {
+        // We really should be patching this in the commit phase but since
+        // this only affects legacy mode hydration which is deprecated anyway
+        // we can get away with it.
+        // Host singletons get their children appended and don't use the text
+        // content mechanism.
+        if (tag !== 'body') {
+          domElement.textContent = children;
+        }
+      }
+    }
+  }
+
+  if (props.onScroll != null) {
+    listenToNonDelegatedEvent('scroll', domElement);
+  }
+
+  if (props.onScrollEnd != null) {
+    listenToNonDelegatedEvent('scrollend', domElement);
+  }
+
+  if (props.onClick != null) {
+    // TODO: This cast may not be sound for SVG, MathML or custom elements.
+    trapClickOnNonInteractiveElement(domElement);
+  }
+}
+function diffHydratedText(textNode, text, isConcurrentMode) {
+  const isDifferent = textNode.nodeValue !== text;
+  return isDifferent;
+}
+function restoreControlledState(domElement, tag, props) {
+  switch (tag) {
+    case 'input':
+      restoreControlledInputState(domElement, props);
+      return;
+
+    case 'textarea':
+      restoreControlledTextareaState(domElement, props);
+      return;
+
+    case 'select':
+      restoreControlledSelectState(domElement, props);
+      return;
+  }
+}
+
+const SUPPRESS_HYDRATION_WARNING = 'suppressHydrationWarning';
+const SUSPENSE_START_DATA = '$';
+const SUSPENSE_END_DATA = '/$';
+const SUSPENSE_PENDING_START_DATA = '$?';
+const SUSPENSE_FALLBACK_START_DATA = '$!';
+const FORM_STATE_IS_MATCHING = 'F!';
+const FORM_STATE_IS_NOT_MATCHING = 'F';
+const STYLE = 'style';
+const HostContextNamespaceNone = 0;
+const HostContextNamespaceSvg = 1;
+const HostContextNamespaceMath = 2;
+let eventsEnabled = null;
+let selectionInformation = null;
+
+function getOwnerDocumentFromRootContainer(rootContainerElement) {
+  return rootContainerElement.nodeType === DOCUMENT_NODE ? rootContainerElement : rootContainerElement.ownerDocument;
+}
+
+function getRootHostContext(rootContainerInstance) {
+  let type;
+  let context;
+  const nodeType = rootContainerInstance.nodeType;
+
+  switch (nodeType) {
+    case DOCUMENT_NODE:
+    case DOCUMENT_FRAGMENT_NODE:
+      {
+        type = nodeType === DOCUMENT_NODE ? '#document' : '#fragment';
+        const root = rootContainerInstance.documentElement;
+
+        if (root) {
+          const namespaceURI = root.namespaceURI;
+          context = namespaceURI ? getOwnHostContext(namespaceURI) : HostContextNamespaceNone;
+        } else {
+          context = HostContextNamespaceNone;
+        }
+
+        break;
+      }
+
+    default:
+      {
+        const container = nodeType === COMMENT_NODE ? rootContainerInstance.parentNode : rootContainerInstance;
+        type = container.tagName;
+        const namespaceURI = container.namespaceURI;
+
+        if (!namespaceURI) {
+          switch (type) {
+            case 'svg':
+              context = HostContextNamespaceSvg;
+              break;
+
+            case 'math':
+              context = HostContextNamespaceMath;
+              break;
+
+            default:
+              context = HostContextNamespaceNone;
+              break;
+          }
+        } else {
+          const ownContext = getOwnHostContext(namespaceURI);
+          context = getChildHostContextProd(ownContext, type);
+        }
+
+        break;
+      }
+  }
+
+  return context;
+}
+
+function getOwnHostContext(namespaceURI) {
+  switch (namespaceURI) {
+    case SVG_NAMESPACE:
+      return HostContextNamespaceSvg;
+
+    case MATH_NAMESPACE:
+      return HostContextNamespaceMath;
+
+    default:
+      return HostContextNamespaceNone;
+  }
+}
+
+function getChildHostContextProd(parentNamespace, type) {
+  if (parentNamespace === HostContextNamespaceNone) {
+    // No (or default) parent namespace: potential entry point.
+    switch (type) {
+      case 'svg':
+        return HostContextNamespaceSvg;
+
+      case 'math':
+        return HostContextNamespaceMath;
+
+      default:
+        return HostContextNamespaceNone;
+    }
+  }
+
+  if (parentNamespace === HostContextNamespaceSvg && type === 'foreignObject') {
+    // We're leaving SVG.
+    return HostContextNamespaceNone;
+  } // By default, pass namespace below.
+
+
+  return parentNamespace;
+}
+
+function getChildHostContext(parentHostContext, type) {
+
+  const parentNamespace = parentHostContext;
+  return getChildHostContextProd(parentNamespace, type);
+}
+function getPublicInstance(instance) {
+  return instance;
+}
+function prepareForCommit(containerInfo) {
+  eventsEnabled = isEnabled();
+  selectionInformation = getSelectionInformation();
+  let activeInstance = null;
+
+  setEnabled(false);
+  return activeInstance;
+}
+function resetAfterCommit(containerInfo) {
+  restoreSelection(selectionInformation);
+  setEnabled(eventsEnabled);
+  eventsEnabled = null;
+  selectionInformation = null;
+}
+function createHoistableInstance(type, props, rootContainerInstance, internalInstanceHandle) {
+  const ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
+  const domElement = ownerDocument.createElement(type);
+  precacheFiberNode(internalInstanceHandle, domElement);
+  updateFiberProps(domElement, props);
+  setInitialProperties(domElement, type, props);
+  markNodeAsHoistable(domElement);
+  return domElement;
+}
+function createInstance(type, props, rootContainerInstance, hostContext, internalInstanceHandle) {
+  let hostContextProd;
+
+  {
+    hostContextProd = hostContext;
+  }
+
+  const ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
+  let domElement;
+
+  switch (hostContextProd) {
+    case HostContextNamespaceSvg:
+      domElement = ownerDocument.createElementNS(SVG_NAMESPACE, type);
+      break;
+
+    case HostContextNamespaceMath:
+      domElement = ownerDocument.createElementNS(MATH_NAMESPACE, type);
+      break;
+
+    default:
+      switch (type) {
+        case 'svg':
+          {
+            domElement = ownerDocument.createElementNS(SVG_NAMESPACE, type);
+            break;
+          }
+
+        case 'math':
+          {
+            domElement = ownerDocument.createElementNS(MATH_NAMESPACE, type);
+            break;
+          }
+
+        case 'script':
+          {
+            // Create the script via .innerHTML so its "parser-inserted" flag is
+            // set to true and it does not execute
+            const div = ownerDocument.createElement('div');
+
+            div.innerHTML = '<script><' + '/script>'; // eslint-disable-line
+            // This is guaranteed to yield a script element.
+
+            const firstChild = div.firstChild;
+            domElement = div.removeChild(firstChild);
+            break;
+          }
+
+        case 'select':
+          {
+            if (typeof props.is === 'string') {
+              domElement = ownerDocument.createElement('select', {
+                is: props.is
+              });
+            } else {
+              // Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.
+              // See discussion in https://github.com/facebook/react/pull/6896
+              // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
+              domElement = ownerDocument.createElement('select');
+            }
+
+            if (props.multiple) {
+              domElement.multiple = true;
+            } else if (props.size) {
+              // Setting a size greater than 1 causes a select to behave like `multiple=true`, where
+              // it is possible that no option is selected.
+              //
+              // This is only necessary when a select in "single selection mode".
+              domElement.size = props.size;
+            }
+
+            break;
+          }
+
+        default:
+          {
+            if (typeof props.is === 'string') {
+              domElement = ownerDocument.createElement(type, {
+                is: props.is
+              });
+            } else {
+              // Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.
+              // See discussion in https://github.com/facebook/react/pull/6896
+              // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
+              domElement = ownerDocument.createElement(type);
+            }
+          }
+      }
+
+  }
+
+  precacheFiberNode(internalInstanceHandle, domElement);
+  updateFiberProps(domElement, props);
+  return domElement;
+}
+function appendInitialChild(parentInstance, child) {
+  parentInstance.appendChild(child);
+}
+function finalizeInitialChildren(domElement, type, props, hostContext) {
+  setInitialProperties(domElement, type, props);
+
+  switch (type) {
+    case 'button':
+    case 'input':
+    case 'select':
+    case 'textarea':
+      return !!props.autoFocus;
+
+    case 'img':
+      return true;
+
+    default:
+      return false;
+  }
+}
+function shouldSetTextContent(type, props) {
+  return type === 'textarea' || type === 'noscript' || typeof props.children === 'string' || typeof props.children === 'number' || typeof props.dangerouslySetInnerHTML === 'object' && props.dangerouslySetInnerHTML !== null && props.dangerouslySetInnerHTML.__html != null;
+}
+function createTextInstance(text, rootContainerInstance, hostContext, internalInstanceHandle) {
+
+  const textNode = getOwnerDocumentFromRootContainer(rootContainerInstance).createTextNode(text);
+  precacheFiberNode(internalInstanceHandle, textNode);
+  return textNode;
+}
+function getCurrentEventPriority() {
+  const currentEvent = window.event;
+
+  if (currentEvent === undefined) {
+    return DefaultEventPriority;
+  }
+
+  return getEventPriority(currentEvent.type);
+}
+let currentPopstateTransitionEvent = null;
+function shouldAttemptEagerTransition() {
+  const event = window.event;
+
+  if (event && event.type === 'popstate') {
+    // This is a popstate event. Attempt to render any transition during this
+    // event synchronously. Unless we already attempted during this event.
+    if (event === currentPopstateTransitionEvent) {
+      // We already attempted to render this popstate transition synchronously.
+      // Any subsequent attempts must have happened as the result of a derived
+      // update, like startTransition inside useEffect, or useDV. Switch back to
+      // the default behavior for all remaining transitions during the current
+      // popstate event.
+      return false;
+    } else {
+      // Cache the current event in case a derived transition is scheduled.
+      // (Refer to previous branch.)
+      currentPopstateTransitionEvent = event;
+      return true;
+    }
+  } // We're not inside a popstate event.
+
+
+  currentPopstateTransitionEvent = null;
+  return false;
+}
+// if a component just imports ReactDOM (e.g. for findDOMNode).
+// Some environments might not have setTimeout or clearTimeout.
+
+const scheduleTimeout = typeof setTimeout === 'function' ? setTimeout : undefined;
+const cancelTimeout = typeof clearTimeout === 'function' ? clearTimeout : undefined;
+const noTimeout = -1;
+const localPromise = typeof Promise === 'function' ? Promise : undefined;
+function getInstanceFromNode(node) {
+  return getClosestInstanceFromNode(node) || null;
+}
+function preparePortalMount(portalInstance) {
+  listenToAllSupportedEvents(portalInstance);
+}
+const scheduleMicrotask = typeof queueMicrotask === 'function' ? queueMicrotask : typeof localPromise !== 'undefined' ? callback => localPromise.resolve(null).then(callback).catch(handleErrorInNextTick) : scheduleTimeout; // TODO: Determine the best fallback here.
+
+function handleErrorInNextTick(error) {
+  setTimeout(() => {
+    throw error;
+  });
+} // -------------------
+function commitMount(domElement, type, newProps, internalInstanceHandle) {
+  // Despite the naming that might imply otherwise, this method only
+  // fires if there is an `Update` effect scheduled during mounting.
+  // This happens if `finalizeInitialChildren` returns `true` (which it
+  // does to implement the `autoFocus` attribute on the client). But
+  // there are also other cases when this might happen (such as patching
+  // up text content during hydration mismatch). So we'll check this again.
+  switch (type) {
+    case 'button':
+    case 'input':
+    case 'select':
+    case 'textarea':
+      if (newProps.autoFocus) {
+        domElement.focus();
+      }
+
+      return;
+
+    case 'img':
+      {
+        if (newProps.src) {
+          domElement.src = newProps.src;
+        }
+
+        return;
+      }
+  }
+}
+function commitUpdate(domElement, updatePayload, type, oldProps, newProps, internalInstanceHandle) {
+  // Diff and update the properties.
+  updateProperties(domElement, type, oldProps, newProps); // Update the props handle so that we know which props are the ones with
+  // with current event handlers.
+
+  updateFiberProps(domElement, newProps);
+}
+function resetTextContent(domElement) {
+  setTextContent(domElement, '');
+}
+function commitTextUpdate(textInstance, oldText, newText) {
+  textInstance.nodeValue = newText;
+}
+function appendChild(parentInstance, child) {
+  parentInstance.appendChild(child);
+}
+function appendChildToContainer(container, child) {
+  let parentNode;
+
+  if (container.nodeType === COMMENT_NODE) {
+    parentNode = container.parentNode;
+    parentNode.insertBefore(child, container);
+  } else {
+    parentNode = container;
+    parentNode.appendChild(child);
+  } // This container might be used for a portal.
+  // If something inside a portal is clicked, that click should bubble
+  // through the React tree. However, on Mobile Safari the click would
+  // never bubble through the *DOM* tree unless an ancestor with onclick
+  // event exists. So we wouldn't see it and dispatch it.
+  // This is why we ensure that non React root containers have inline onclick
+  // defined.
+  // https://github.com/facebook/react/issues/11918
+
+
+  const reactRootContainer = container._reactRootContainer;
+
+  if ((reactRootContainer === null || reactRootContainer === undefined) && parentNode.onclick === null) {
+    // TODO: This cast may not be sound for SVG, MathML or custom elements.
+    trapClickOnNonInteractiveElement(parentNode);
+  }
+}
+function insertBefore(parentInstance, child, beforeChild) {
+  parentInstance.insertBefore(child, beforeChild);
+}
+function insertInContainerBefore(container, child, beforeChild) {
+  if (container.nodeType === COMMENT_NODE) {
+    container.parentNode.insertBefore(child, beforeChild);
+  } else {
+    container.insertBefore(child, beforeChild);
+  }
+}
+
+function removeChild(parentInstance, child) {
+  parentInstance.removeChild(child);
+}
+function removeChildFromContainer(container, child) {
+  if (container.nodeType === COMMENT_NODE) {
+    container.parentNode.removeChild(child);
+  } else {
+    container.removeChild(child);
+  }
+}
+function clearSuspenseBoundary(parentInstance, suspenseInstance) {
+  let node = suspenseInstance; // Delete all nodes within this suspense boundary.
+  // There might be nested nodes so we need to keep track of how
+  // deep we are and only break out when we're back on top.
+
+  let depth = 0;
+
+  do {
+    const nextNode = node.nextSibling;
+    parentInstance.removeChild(node);
+
+    if (nextNode && nextNode.nodeType === COMMENT_NODE) {
+      const data = nextNode.data;
+
+      if (data === SUSPENSE_END_DATA) {
+        if (depth === 0) {
+          parentInstance.removeChild(nextNode); // Retry if any event replaying was blocked on this.
+
+          retryIfBlockedOn(suspenseInstance);
+          return;
+        } else {
+          depth--;
+        }
+      } else if (data === SUSPENSE_START_DATA || data === SUSPENSE_PENDING_START_DATA || data === SUSPENSE_FALLBACK_START_DATA) {
+        depth++;
+      }
+    } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+    node = nextNode;
+  } while (node); // TODO: Warn, we didn't find the end comment boundary.
+  // Retry if any event replaying was blocked on this.
+
+
+  retryIfBlockedOn(suspenseInstance);
+}
+function clearSuspenseBoundaryFromContainer(container, suspenseInstance) {
+  if (container.nodeType === COMMENT_NODE) {
+    clearSuspenseBoundary(container.parentNode, suspenseInstance);
+  } else if (container.nodeType === ELEMENT_NODE) {
+    clearSuspenseBoundary(container, suspenseInstance);
+  } else ; // Retry if any event replaying was blocked on this.
+
+
+  retryIfBlockedOn(container);
+}
+function hideInstance(instance) {
+  // TODO: Does this work for all element types? What about MathML? Should we
+  // pass host context to this method?
+  instance = instance;
+  const style = instance.style; // $FlowFixMe[method-unbinding]
+
+  if (typeof style.setProperty === 'function') {
+    style.setProperty('display', 'none', 'important');
+  } else {
+    style.display = 'none';
+  }
+}
+function hideTextInstance(textInstance) {
+  textInstance.nodeValue = '';
+}
+function unhideInstance(instance, props) {
+  instance = instance;
+  const styleProp = props[STYLE];
+  const display = styleProp !== undefined && styleProp !== null && styleProp.hasOwnProperty('display') ? styleProp.display : null;
+  instance.style.display = display == null || typeof display === 'boolean' ? '' : // The value would've errored already if it wasn't safe.
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  ('' + display).trim();
+}
+function unhideTextInstance(textInstance, text) {
+  textInstance.nodeValue = text;
+}
+function clearContainer(container) {
+  {
+    const nodeType = container.nodeType;
+
+    if (nodeType === DOCUMENT_NODE) {
+      clearContainerSparingly(container);
+    } else if (nodeType === ELEMENT_NODE) {
+      switch (container.nodeName) {
+        case 'HEAD':
+        case 'HTML':
+        case 'BODY':
+          clearContainerSparingly(container);
+          return;
+
+        default:
+          {
+            container.textContent = '';
+          }
+      }
+    }
+  }
+}
+
+function clearContainerSparingly(container) {
+  let node;
+  let nextNode = container.firstChild;
+
+  if (nextNode && nextNode.nodeType === DOCUMENT_TYPE_NODE) {
+    nextNode = nextNode.nextSibling;
+  }
+
+  while (nextNode) {
+    node = nextNode;
+    nextNode = nextNode.nextSibling;
+
+    switch (node.nodeName) {
+      case 'HTML':
+      case 'HEAD':
+      case 'BODY':
+        {
+          const element = node;
+          clearContainerSparingly(element); // If these singleton instances had previously been rendered with React they
+          // may still hold on to references to the previous fiber tree. We detatch them
+          // prospectively to reset them to a baseline starting state since we cannot create
+          // new instances.
+
+          detachDeletedInstance(element);
+          continue;
+        }
+      // Script tags are retained to avoid an edge case bug. Normally scripts will execute if they
+      // are ever inserted into the DOM. However when streaming if a script tag is opened but not
+      // yet closed some browsers create and insert the script DOM Node but the script cannot execute
+      // yet until the closing tag is parsed. If something causes React to call clearContainer while
+      // this DOM node is in the document but not yet executable the DOM node will be removed from the
+      // document and when the script closing tag comes in the script will not end up running. This seems
+      // to happen in Chrome/Firefox but not Safari at the moment though this is not necessarily specified
+      // behavior so it could change in future versions of browsers. While leaving all scripts is broader
+      // than strictly necessary this is the least amount of additional code to avoid this breaking
+      // edge case.
+      //
+      // Style tags are retained because they may likely come from 3rd party scripts and extensions
+
+      case 'SCRIPT':
+      case 'STYLE':
+        {
+          continue;
+        }
+      // Stylesheet tags are retained because tehy may likely come from 3rd party scripts and extensions
+
+      case 'LINK':
+        {
+          if (node.rel.toLowerCase() === 'stylesheet') {
+            continue;
+          }
+        }
+    }
+
+    container.removeChild(node);
+  }
+
+  return;
+} // Making this so we can eventually move all of the instance caching to the commit phase.
+function isHydratableText(text) {
+  return text !== '';
+}
+function canHydrateInstance(instance, type, props, inRootOrSingleton) {
+  while (instance.nodeType === ELEMENT_NODE) {
+    const element = instance;
+    const anyProps = props;
+
+    if (element.nodeName.toLowerCase() !== type.toLowerCase()) {
+      if (!inRootOrSingleton || !enableHostSingletons) {
+        // Usually we error for mismatched tags.
+        if (element.nodeName === 'INPUT' && element.type === 'hidden') ; else {
+          return null;
+        }
+      } // In root or singleton parents we skip past mismatched instances.
+
+    } else if (!inRootOrSingleton || !enableHostSingletons) {
+      // Match
+      if (type === 'input' && element.type === 'hidden') {
+
+        const name = anyProps.name == null ? null : '' + anyProps.name;
+
+        if (anyProps.type !== 'hidden' || element.getAttribute('name') !== name) ; else {
+          return element;
+        }
+      } else {
+        return element;
+      }
+    } else if (isMarkedHoistable(element)) ; else {
+      // We have an Element with the right type.
+      // We are going to try to exclude it if we can definitely identify it as a hoisted Node or if
+      // we can guess that the node is likely hoisted or was inserted by a 3rd party script or browser extension
+      // using high entropy attributes for certain types. This technique will fail for strange insertions like
+      // extension prepending <div> in the <body> but that already breaks before and that is an edge case.
+      switch (type) {
+        // case 'title':
+        //We assume all titles are matchable. You should only have one in the Document, at least in a hoistable scope
+        // and if you are a HostComponent with type title we must either be in an <svg> context or this title must have an `itemProp` prop.
+        case 'meta':
+          {
+            // The only way to opt out of hoisting meta tags is to give it an itemprop attribute. We assume there will be
+            // not 3rd party meta tags that are prepended, accepting the cases where this isn't true because meta tags
+            // are usually only functional for SSR so even in a rare case where we did bind to an injected tag the runtime
+            // implications are minimal
+            if (!element.hasAttribute('itemprop')) {
+              // This is a Hoistable
+              break;
+            }
+
+            return element;
+          }
+
+        case 'link':
+          {
+            // Links come in many forms and we do expect 3rd parties to inject them into <head> / <body>. We exclude known resources
+            // and then use high-entroy attributes like href which are almost always used and almost always unique to filter out unlikely
+            // matches.
+            const rel = element.getAttribute('rel');
+
+            if (rel === 'stylesheet' && element.hasAttribute('data-precedence')) {
+              // This is a stylesheet resource
+              break;
+            } else if (rel !== anyProps.rel || element.getAttribute('href') !== (anyProps.href == null ? null : anyProps.href) || element.getAttribute('crossorigin') !== (anyProps.crossOrigin == null ? null : anyProps.crossOrigin) || element.getAttribute('title') !== (anyProps.title == null ? null : anyProps.title)) {
+              // rel + href should usually be enough to uniquely identify a link however crossOrigin can vary for rel preconnect
+              // and title could vary for rel alternate
+              break;
+            }
+
+            return element;
+          }
+
+        case 'style':
+          {
+            // Styles are hard to match correctly. We can exclude known resources but otherwise we accept the fact that a non-hoisted style tags
+            // in <head> or <body> are likely never going to be unmounted given their position in the document and the fact they likely hold global styles
+            if (element.hasAttribute('data-precedence')) {
+              // This is a style resource
+              break;
+            }
+
+            return element;
+          }
+
+        case 'script':
+          {
+            // Scripts are a little tricky, we exclude known resources and then similar to links try to use high-entropy attributes
+            // to reject poor matches. One challenge with scripts are inline scripts. We don't attempt to check text content which could
+            // in theory lead to a hydration error later if a 3rd party injected an inline script before the React rendered nodes.
+            // Falling back to client rendering if this happens should be seemless though so we will try this hueristic and revisit later
+            // if we learn it is problematic
+            const srcAttr = element.getAttribute('src');
+
+            if (srcAttr !== (anyProps.src == null ? null : anyProps.src) || element.getAttribute('type') !== (anyProps.type == null ? null : anyProps.type) || element.getAttribute('crossorigin') !== (anyProps.crossOrigin == null ? null : anyProps.crossOrigin)) {
+              // This script is for a different src/type/crossOrigin. It may be a script resource
+              // or it may just be a mistmatch
+              if (srcAttr && element.hasAttribute('async') && !element.hasAttribute('itemprop')) {
+                // This is an async script resource
+                break;
+              }
+            }
+
+            return element;
+          }
+
+        default:
+          {
+            // We have excluded the most likely cases of mismatch between hoistable tags, 3rd party script inserted tags,
+            // and browser extension inserted tags. While it is possible this is not the right match it is a decent hueristic
+            // that should work in the vast majority of cases.
+            return element;
+          }
+      }
+    }
+
+    const nextInstance = getNextHydratableSibling(element);
+
+    if (nextInstance === null) {
+      break;
+    }
+
+    instance = nextInstance;
+  } // This is a suspense boundary or Text node or we got the end.
+  // Suspense Boundaries are never expected to be injected by 3rd parties. If we see one it should be matched
+  // and this is a hydration error.
+  // Text Nodes are also not expected to be injected by 3rd parties. This is less of a guarantee for <body>
+  // but it seems reasonable and conservative to reject this as a hydration error as well
+
+
+  return null;
+}
+function canHydrateTextInstance(instance, text, inRootOrSingleton) {
+  // Empty strings are not parsed by HTML so there won't be a correct match here.
+  if (text === '') return null;
+
+  while (instance.nodeType !== TEXT_NODE) {
+    if (instance.nodeType === ELEMENT_NODE && instance.nodeName === 'INPUT' && instance.type === 'hidden') ; else if (!inRootOrSingleton || !enableHostSingletons) {
+      return null;
+    }
+
+    const nextInstance = getNextHydratableSibling(instance);
+
+    if (nextInstance === null) {
+      return null;
+    }
+
+    instance = nextInstance;
+  } // This has now been refined to a text node.
+
+
+  return instance;
+}
+function canHydrateSuspenseInstance(instance, inRootOrSingleton) {
+  while (instance.nodeType !== COMMENT_NODE) {
+    if (!inRootOrSingleton || !enableHostSingletons) {
+      return null;
+    }
+
+    const nextInstance = getNextHydratableSibling(instance);
+
+    if (nextInstance === null) {
+      return null;
+    }
+
+    instance = nextInstance;
+  } // This has now been refined to a suspense node.
+
+
+  return instance;
+}
+function isSuspenseInstancePending(instance) {
+  return instance.data === SUSPENSE_PENDING_START_DATA;
+}
+function isSuspenseInstanceFallback(instance) {
+  return instance.data === SUSPENSE_FALLBACK_START_DATA;
+}
+function getSuspenseInstanceFallbackErrorDetails(instance) {
+  const dataset = instance.nextSibling && instance.nextSibling.dataset;
+  let digest;
+
+  if (dataset) {
+    digest = dataset.dgst;
+  }
+
+  {
+    // Object gets DCE'd if constructed in tail position and matches callsite destructuring
+    return {
+      digest
+    };
+  }
+}
+function registerSuspenseInstanceRetry(instance, callback) {
+  instance._reactRetry = callback;
+}
+function canHydrateFormStateMarker(instance, inRootOrSingleton) {
+  while (instance.nodeType !== COMMENT_NODE) {
+    if (!inRootOrSingleton || !enableHostSingletons) {
+      return null;
+    }
+
+    const nextInstance = getNextHydratableSibling(instance);
+
+    if (nextInstance === null) {
+      return null;
+    }
+
+    instance = nextInstance;
+  }
+
+  const nodeData = instance.data;
+
+  if (nodeData === FORM_STATE_IS_MATCHING || nodeData === FORM_STATE_IS_NOT_MATCHING) {
+    const markerInstance = instance;
+    return markerInstance;
+  }
+
+  return null;
+}
+function isFormStateMarkerMatching(markerInstance) {
+  return markerInstance.data === FORM_STATE_IS_MATCHING;
+}
+
+function getNextHydratable(node) {
+  // Skip non-hydratable nodes.
+  for (; node != null; node = node.nextSibling) {
+    const nodeType = node.nodeType;
+
+    if (nodeType === ELEMENT_NODE || nodeType === TEXT_NODE) {
+      break;
+    }
+
+    if (nodeType === COMMENT_NODE) {
+      const nodeData = node.data;
+
+      if (nodeData === SUSPENSE_START_DATA || nodeData === SUSPENSE_FALLBACK_START_DATA || nodeData === SUSPENSE_PENDING_START_DATA || (nodeData === FORM_STATE_IS_MATCHING || nodeData === FORM_STATE_IS_NOT_MATCHING)) {
+        break;
+      }
+
+      if (nodeData === SUSPENSE_END_DATA) {
+        return null;
+      }
+    }
+  }
+
+  return node;
+}
+
+function getNextHydratableSibling(instance) {
+  return getNextHydratable(instance.nextSibling);
+}
+function getFirstHydratableChild(parentInstance) {
+  return getNextHydratable(parentInstance.firstChild);
+}
+function getFirstHydratableChildWithinContainer(parentContainer) {
+  return getNextHydratable(parentContainer.firstChild);
+}
+function getFirstHydratableChildWithinSuspenseInstance(parentInstance) {
+  return getNextHydratable(parentInstance.nextSibling);
+}
+function hydrateInstance(instance, type, props, hostContext, internalInstanceHandle, shouldWarnDev) {
+  precacheFiberNode(internalInstanceHandle, instance); // TODO: Possibly defer this until the commit phase where all the events
+  // get attached.
+
+  updateFiberProps(instance, props); // TODO: Temporary hack to check if we're in a concurrent root. We can delete
+  // when the legacy root API is removed.
+
+  const isConcurrentMode = (internalInstanceHandle.mode & ConcurrentMode) !== NoMode;
+  diffHydratedProperties(instance, type, props, isConcurrentMode);
+}
+function hydrateTextInstance(textInstance, text, internalInstanceHandle, shouldWarnDev) {
+  precacheFiberNode(internalInstanceHandle, textInstance); // TODO: Temporary hack to check if we're in a concurrent root. We can delete
+  return diffHydratedText(textInstance, text);
+}
+function hydrateSuspenseInstance(suspenseInstance, internalInstanceHandle) {
+  precacheFiberNode(internalInstanceHandle, suspenseInstance);
+}
+function getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance) {
+  let node = suspenseInstance.nextSibling; // Skip past all nodes within this suspense boundary.
+  // There might be nested nodes so we need to keep track of how
+  // deep we are and only break out when we're back on top.
+
+  let depth = 0;
+
+  while (node) {
+    if (node.nodeType === COMMENT_NODE) {
+      const data = node.data;
+
+      if (data === SUSPENSE_END_DATA) {
+        if (depth === 0) {
+          return getNextHydratableSibling(node);
+        } else {
+          depth--;
+        }
+      } else if (data === SUSPENSE_START_DATA || data === SUSPENSE_FALLBACK_START_DATA || data === SUSPENSE_PENDING_START_DATA) {
+        depth++;
+      }
+    }
+
+    node = node.nextSibling;
+  } // TODO: Warn, we didn't find the end comment boundary.
+
+
+  return null;
+} // Returns the SuspenseInstance if this node is a direct child of a
+// SuspenseInstance. I.e. if its previous sibling is a Comment with
+// SUSPENSE_x_START_DATA. Otherwise, null.
+
+function getParentSuspenseInstance(targetInstance) {
+  let node = targetInstance.previousSibling; // Skip past all nodes within this suspense boundary.
+  // There might be nested nodes so we need to keep track of how
+  // deep we are and only break out when we're back on top.
+
+  let depth = 0;
+
+  while (node) {
+    if (node.nodeType === COMMENT_NODE) {
+      const data = node.data;
+
+      if (data === SUSPENSE_START_DATA || data === SUSPENSE_FALLBACK_START_DATA || data === SUSPENSE_PENDING_START_DATA) {
+        if (depth === 0) {
+          return node;
+        } else {
+          depth--;
+        }
+      } else if (data === SUSPENSE_END_DATA) {
+        depth++;
+      }
+    }
+
+    node = node.previousSibling;
+  }
+
+  return null;
+}
+function commitHydratedContainer(container) {
+  // Retry if any event replaying was blocked on this.
+  retryIfBlockedOn(container);
+}
+function commitHydratedSuspenseInstance(suspenseInstance) {
+  // Retry if any event replaying was blocked on this.
+  retryIfBlockedOn(suspenseInstance);
+}
+function shouldDeleteUnhydratedTailInstances(parentType) {
+  return (parentType !== 'form' && parentType !== 'button');
+}
+function didNotMatchHydratedContainerTextInstance(parentContainer, textInstance, text, isConcurrentMode, shouldWarnDev) {
+  checkForUnmatchedText(textInstance.nodeValue, text, isConcurrentMode);
+}
+function didNotMatchHydratedTextInstance(parentType, parentProps, parentInstance, textInstance, text, isConcurrentMode, shouldWarnDev) {
+  if (parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
+    checkForUnmatchedText(textInstance.nodeValue, text, isConcurrentMode);
+  }
+}
+function findFiberRoot(node) {
+  const stack = [node];
+  let index = 0;
+
+  while (index < stack.length) {
+    const current = stack[index++];
+
+    if (isContainerMarkedAsRoot(current)) {
+      return getInstanceFromNode$1(current);
+    }
+
+    stack.push.apply(stack, current.children);
+  }
+
+  return null;
+}
+function getBoundingRect(node) {
+  const rect = node.getBoundingClientRect();
+  return {
+    x: rect.left,
+    y: rect.top,
+    width: rect.width,
+    height: rect.height
+  };
+}
+function matchAccessibilityRole(node, role) {
+  if (hasRole(node, role)) {
+    return true;
+  }
+
+  return false;
+}
+function getTextContent(fiber) {
+  switch (fiber.tag) {
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      let textContent = '';
+      const childNodes = fiber.stateNode.childNodes;
+
+      for (let i = 0; i < childNodes.length; i++) {
+        const childNode = childNodes[i];
+
+        if (childNode.nodeType === Node.TEXT_NODE) {
+          textContent += childNode.textContent;
+        }
+      }
+
+      return textContent;
+
+    case HostText:
+      return fiber.stateNode.textContent;
+  }
+
+  return null;
+}
+function isHiddenSubtree(fiber) {
+  return fiber.tag === HostComponent && fiber.memoizedProps.hidden === true;
+}
+function setFocusIfFocusable(node) {
+  // The logic for determining if an element is focusable is kind of complex,
+  // and since we want to actually change focus anyway- we can just skip it.
+  // Instead we'll just listen for a "focus" event to verify that focus was set.
+  //
+  // We could compare the node to document.activeElement after focus,
+  // but this would not handle the case where application code managed focus to automatically blur.
+  let didFocus = false;
+
+  const handleFocus = () => {
+    didFocus = true;
+  };
+
+  const element = node;
+
+  try {
+    element.addEventListener('focus', handleFocus); // $FlowFixMe[method-unbinding]
+
+    (element.focus || HTMLElement.prototype.focus).call(element);
+  } finally {
+    element.removeEventListener('focus', handleFocus);
+  }
+
+  return didFocus;
+}
+function setupIntersectionObserver(targets, callback, options) {
+  const rectRatioCache = new Map();
+  targets.forEach(target => {
+    rectRatioCache.set(target, {
+      rect: getBoundingRect(target),
+      ratio: 0
+    });
+  });
+
+  const handleIntersection = entries => {
+    entries.forEach(entry => {
+      const boundingClientRect = entry.boundingClientRect,
+            intersectionRatio = entry.intersectionRatio,
+            target = entry.target;
+      rectRatioCache.set(target, {
+        rect: {
+          x: boundingClientRect.left,
+          y: boundingClientRect.top,
+          width: boundingClientRect.width,
+          height: boundingClientRect.height
+        },
+        ratio: intersectionRatio
+      });
+    });
+    callback(Array.from(rectRatioCache.values()));
+  };
+
+  const observer = new IntersectionObserver(handleIntersection, options);
+  targets.forEach(target => {
+    observer.observe(target);
+  });
+  return {
+    disconnect: () => observer.disconnect(),
+    observe: target => {
+      rectRatioCache.set(target, {
+        rect: getBoundingRect(target),
+        ratio: 0
+      });
+      observer.observe(target);
+    },
+    unobserve: target => {
+      rectRatioCache.delete(target);
+      observer.unobserve(target);
+    }
+  };
+}
+function isHostSingletonType(type) {
+  return type === 'html' || type === 'head' || type === 'body';
+}
+function resolveSingletonInstance(type, props, rootContainerInstance, hostContext, validateDOMNestingDev) {
+
+  const ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
+
+  switch (type) {
+    case 'html':
+      {
+        const documentElement = ownerDocument.documentElement;
+
+        if (!documentElement) {
+          throw Error(formatProdErrorMessage(452));
+        }
+
+        return documentElement;
+      }
+
+    case 'head':
+      {
+        const head = ownerDocument.head;
+
+        if (!head) {
+          throw Error(formatProdErrorMessage(453));
+        }
+
+        return head;
+      }
+
+    case 'body':
+      {
+        const body = ownerDocument.body;
+
+        if (!body) {
+          throw Error(formatProdErrorMessage(454));
+        }
+
+        return body;
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(451));
+      }
+  }
+}
+function acquireSingletonInstance(type, props, instance, internalInstanceHandle) {
+
+  const attributes = instance.attributes;
+
+  while (attributes.length) {
+    instance.removeAttributeNode(attributes[0]);
+  }
+
+  setInitialProperties(instance, type, props);
+  precacheFiberNode(internalInstanceHandle, instance);
+  updateFiberProps(instance, props);
+}
+function releaseSingletonInstance(instance) {
+  const attributes = instance.attributes;
+
+  while (attributes.length) {
+    instance.removeAttributeNode(attributes[0]);
+  }
+
+  detachDeletedInstance(instance);
+}
+function clearSingleton(instance) {
+  const element = instance;
+  let node = element.firstChild;
+
+  while (node) {
+    const nextNode = node.nextSibling;
+    const nodeName = node.nodeName;
+
+    if (isMarkedHoistable(node) || nodeName === 'HEAD' || nodeName === 'BODY' || nodeName === 'SCRIPT' || nodeName === 'STYLE' || nodeName === 'LINK' && node.rel.toLowerCase() === 'stylesheet') ; else {
+      element.removeChild(node);
+    }
+
+    node = nextNode;
+  }
+
+  return;
+} // -------------------
+const NotLoaded =
+/*       */
+0b000;
+const Loaded =
+/*          */
+0b001;
+const Errored =
+/*         */
+0b010;
+const Settled =
+/*         */
+0b011;
+const Inserted =
+/*        */
+0b100;
+function prepareToCommitHoistables() {
+  tagCaches = null;
+} // global collections of Resources
+
+const preloadPropsMap = new Map();
+const preconnectsSet = new Set(); // getRootNode is missing from IE and old jsdom versions
+
+function getHoistableRoot(container) {
+  // $FlowFixMe[method-unbinding]
+  return typeof container.getRootNode === 'function' ?
+  /* $FlowFixMe[incompatible-return] Flow types this as returning a `Node`,
+   * but it's either a `Document` or `ShadowRoot`. */
+  container.getRootNode() : container.ownerDocument;
+}
+
+function getCurrentResourceRoot() {
+  const currentContainer = getCurrentRootHostContainer();
+  return currentContainer ? getHoistableRoot(currentContainer) : null;
+}
+
+function getDocumentFromRoot(root) {
+  return root.ownerDocument || root;
+} // We want this to be the default dispatcher on ReactDOMSharedInternals but we don't want to mutate
+// internals in Module scope. Instead we export it and Internals will import it. There is already a cycle
+// from Internals -> ReactDOM -> HostConfig -> Internals so this doesn't introduce a new one.
+
+
+const ReactDOMClientDispatcher = {
+  prefetchDNS: prefetchDNS$1,
+  preconnect: preconnect$1,
+  preload: preload$1,
+  preloadModule: preloadModule$1,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+}; // We expect this to get inlined. It is a function mostly to communicate the special nature of
+// how we resolve the HoistableRoot for ReactDOM.pre*() methods. Because we support calling
+// these methods outside of render there is no way to know which Document or ShadowRoot is 'scoped'
+// and so we have to fall back to something universal. Currently we just refer to the global document.
+// This is notable because nowhere else in ReactDOM do we actually reference the global document or window
+// because we may be rendering inside an iframe.
+
+function getDocumentForImperativeFloatMethods() {
+  return document;
+}
+
+function preconnectAs(rel, href, crossOrigin) {
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (typeof href === 'string' && href) {
+    const limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+    let key = "link[rel=\"" + rel + "\"][href=\"" + limitedEscapedHref + "\"]";
+
+    if (typeof crossOrigin === 'string') {
+      key += "[crossorigin=\"" + crossOrigin + "\"]";
+    }
+
+    if (!preconnectsSet.has(key)) {
+      preconnectsSet.add(key);
+      const preconnectProps = {
+        rel,
+        crossOrigin,
+        href
+      };
+
+      if (null === ownerDocument.querySelector(key)) {
+        const instance = ownerDocument.createElement('link');
+        setInitialProperties(instance, 'link', preconnectProps);
+        markNodeAsHoistable(instance);
+        ownerDocument.head.appendChild(instance);
+      }
+    }
+  }
+}
+
+function prefetchDNS$1(href) {
+
+  preconnectAs('dns-prefetch', href, null);
+}
+
+function preconnect$1(href, crossOrigin) {
+
+  preconnectAs('preconnect', href, crossOrigin);
+}
+
+function preload$1(href, as, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (href && as && ownerDocument) {
+    let preloadSelector = "link[rel=\"preload\"][as=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(as) + "\"]";
+
+    if (as === 'image') {
+      if (options && options.imageSrcSet) {
+        preloadSelector += "[imagesrcset=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(options.imageSrcSet) + "\"]";
+
+        if (typeof options.imageSizes === 'string') {
+          preloadSelector += "[imagesizes=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(options.imageSizes) + "\"]";
+        }
+      } else {
+        preloadSelector += "[href=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(href) + "\"]";
+      }
+    } else {
+      preloadSelector += "[href=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(href) + "\"]";
+    } // Some preloads are keyed under their selector. This happens when the preload is for
+    // an arbitrary type. Other preloads are keyed under the resource key they represent a preload for.
+    // Here we figure out which key to use to determine if we have a preload already.
+
+
+    let key = preloadSelector;
+
+    switch (as) {
+      case 'style':
+        key = getStyleKey(href);
+        break;
+
+      case 'script':
+        key = getScriptKey(href);
+        break;
+    }
+
+    if (!preloadPropsMap.has(key)) {
+      const preloadProps = assign({
+        rel: 'preload',
+        // There is a bug in Safari where imageSrcSet is not respected on preload links
+        // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+        // This harms older browers that do not support imageSrcSet by making their preloads not work
+        // but this population is shrinking fast and is already small so we accept this tradeoff.
+        href: as === 'image' && options && options.imageSrcSet ? undefined : href,
+        as
+      }, options);
+
+      preloadPropsMap.set(key, preloadProps);
+
+      if (null === ownerDocument.querySelector(preloadSelector)) {
+        if (as === 'style' && ownerDocument.querySelector(getStylesheetSelectorFromKey(key))) {
+          // We already have a stylesheet for this key. We don't need to preload it.
+          return;
+        } else if (as === 'script' && ownerDocument.querySelector(getScriptSelectorFromKey(key))) {
+          // We already have a stylesheet for this key. We don't need to preload it.
+          return;
+        }
+
+        const instance = ownerDocument.createElement('link');
+        setInitialProperties(instance, 'link', preloadProps);
+        markNodeAsHoistable(instance);
+        ownerDocument.head.appendChild(instance);
+      }
+    }
+  }
+}
+
+function preloadModule$1(href, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (href) {
+    const as = options && typeof options.as === 'string' ? options.as : 'script';
+    const preloadSelector = "link[rel=\"modulepreload\"][as=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(as) + "\"][href=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(href) + "\"]"; // Some preloads are keyed under their selector. This happens when the preload is for
+    // an arbitrary type. Other preloads are keyed under the resource key they represent a preload for.
+    // Here we figure out which key to use to determine if we have a preload already.
+
+    let key = preloadSelector;
+
+    switch (as) {
+      case 'audioworklet':
+      case 'paintworklet':
+      case 'serviceworker':
+      case 'sharedworker':
+      case 'worker':
+      case 'script':
+        {
+          key = getScriptKey(href);
+          break;
+        }
+    }
+
+    if (!preloadPropsMap.has(key)) {
+      const props = assign({
+        rel: 'modulepreload',
+        href
+      }, options);
+
+      preloadPropsMap.set(key, props);
+
+      if (null === ownerDocument.querySelector(preloadSelector)) {
+        switch (as) {
+          case 'audioworklet':
+          case 'paintworklet':
+          case 'serviceworker':
+          case 'sharedworker':
+          case 'worker':
+          case 'script':
+            {
+              if (ownerDocument.querySelector(getScriptSelectorFromKey(key))) {
+                return;
+              }
+            }
+        }
+
+        const instance = ownerDocument.createElement('link');
+        setInitialProperties(instance, 'link', props);
+        markNodeAsHoistable(instance);
+        ownerDocument.head.appendChild(instance);
+      }
+    }
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (href) {
+    const styles = getResourcesFromRoot(ownerDocument).hoistableStyles;
+    const key = getStyleKey(href);
+    precedence = precedence || 'default'; // Check if this resource already exists
+
+    let resource = styles.get(key);
+
+    if (resource) {
+      // We can early return. The resource exists and there is nothing
+      // more to do
+      return;
+    }
+
+    const state = {
+      loading: NotLoaded,
+      preload: null
+    }; // Attempt to hydrate instance from DOM
+
+    let instance = ownerDocument.querySelector(getStylesheetSelectorFromKey(key));
+
+    if (instance) {
+      state.loading = Loaded | Inserted;
+    } else {
+      // Construct a new instance and insert it
+      const stylesheetProps = assign({
+        rel: 'stylesheet',
+        href,
+        'data-precedence': precedence
+      }, options);
+
+      const preloadProps = preloadPropsMap.get(key);
+
+      if (preloadProps) {
+        adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps);
+      }
+
+      const link = instance = ownerDocument.createElement('link');
+      markNodeAsHoistable(link);
+      setInitialProperties(link, 'link', stylesheetProps);
+      link._p = new Promise((resolve, reject) => {
+        link.onload = resolve;
+        link.onerror = reject;
+      });
+      link.addEventListener('load', () => {
+        state.loading |= Loaded;
+      });
+      link.addEventListener('error', () => {
+        state.loading |= Errored;
+      });
+      state.loading |= Inserted;
+      insertStylesheet(instance, precedence, ownerDocument);
+    } // Construct a Resource and cache it
+
+
+    resource = {
+      type: 'stylesheet',
+      instance,
+      count: 1,
+      state
+    };
+    styles.set(key, resource);
+    return;
+  }
+}
+
+function preinitScript(src, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (src) {
+    const scripts = getResourcesFromRoot(ownerDocument).hoistableScripts;
+    const key = getScriptKey(src); // Check if this resource already exists
+
+    let resource = scripts.get(key);
+
+    if (resource) {
+      // We can early return. The resource exists and there is nothing
+      // more to do
+      return;
+    } // Attempt to hydrate instance from DOM
+
+
+    let instance = ownerDocument.querySelector(getScriptSelectorFromKey(key));
+
+    if (!instance) {
+      // Construct a new instance and insert it
+      const scriptProps = assign({
+        src,
+        async: true
+      }, options); // Adopt certain preload props
+
+
+      const preloadProps = preloadPropsMap.get(key);
+
+      if (preloadProps) {
+        adoptPreloadPropsForScript(scriptProps, preloadProps);
+      }
+
+      instance = ownerDocument.createElement('script');
+      markNodeAsHoistable(instance);
+      setInitialProperties(instance, 'link', scriptProps);
+      ownerDocument.head.appendChild(instance);
+    } // Construct a Resource and cache it
+
+
+    resource = {
+      type: 'script',
+      instance,
+      count: 1,
+      state: null
+    };
+    scripts.set(key, resource);
+    return;
+  }
+}
+
+function preinitModuleScript(src, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (src) {
+    const scripts = getResourcesFromRoot(ownerDocument).hoistableScripts;
+    const key = getScriptKey(src); // Check if this resource already exists
+
+    let resource = scripts.get(key);
+
+    if (resource) {
+      // We can early return. The resource exists and there is nothing
+      // more to do
+      return;
+    } // Attempt to hydrate instance from DOM
+
+
+    let instance = ownerDocument.querySelector(getScriptSelectorFromKey(key));
+
+    if (!instance) {
+      // Construct a new instance and insert it
+      const scriptProps = assign({
+        src,
+        async: true,
+        type: 'module'
+      }, options); // Adopt certain preload props
+
+
+      const preloadProps = preloadPropsMap.get(key);
+
+      if (preloadProps) {
+        adoptPreloadPropsForScript(scriptProps, preloadProps);
+      }
+
+      instance = ownerDocument.createElement('script');
+      markNodeAsHoistable(instance);
+      setInitialProperties(instance, 'link', scriptProps);
+      ownerDocument.head.appendChild(instance);
+    } // Construct a Resource and cache it
+
+
+    resource = {
+      type: 'script',
+      instance,
+      count: 1,
+      state: null
+    };
+    scripts.set(key, resource);
+    return;
+  }
+} // This function is called in begin work and we should always have a currentDocument set
+
+
+function getResource(type, currentProps, pendingProps) {
+  const resourceRoot = getCurrentResourceRoot();
+
+  if (!resourceRoot) {
+    throw Error(formatProdErrorMessage(446));
+  }
+
+  switch (type) {
+    case 'meta':
+    case 'title':
+      {
+        return null;
+      }
+
+    case 'style':
+      {
+        if (typeof pendingProps.precedence === 'string' && typeof pendingProps.href === 'string') {
+          const key = getStyleKey(pendingProps.href);
+          const styles = getResourcesFromRoot(resourceRoot).hoistableStyles;
+          let resource = styles.get(key);
+
+          if (!resource) {
+            resource = {
+              type: 'style',
+              instance: null,
+              count: 0,
+              state: null
+            };
+            styles.set(key, resource);
+          }
+
+          return resource;
+        }
+
+        return {
+          type: 'void',
+          instance: null,
+          count: 0,
+          state: null
+        };
+      }
+
+    case 'link':
+      {
+        if (pendingProps.rel === 'stylesheet' && typeof pendingProps.href === 'string' && typeof pendingProps.precedence === 'string') {
+          const qualifiedProps = pendingProps;
+          const key = getStyleKey(qualifiedProps.href);
+          const styles = getResourcesFromRoot(resourceRoot).hoistableStyles;
+          let resource = styles.get(key);
+
+          if (!resource) {
+            // We asserted this above but Flow can't figure out that the type satisfies
+            const ownerDocument = getDocumentFromRoot(resourceRoot);
+            resource = {
+              type: 'stylesheet',
+              instance: null,
+              count: 0,
+              state: {
+                loading: NotLoaded,
+                preload: null
+              }
+            };
+            styles.set(key, resource);
+
+            if (!preloadPropsMap.has(key)) {
+              preloadStylesheet(ownerDocument, key, preloadPropsFromStylesheet(qualifiedProps), resource.state);
+            }
+          }
+
+          return resource;
+        }
+
+        return null;
+      }
+
+    case 'script':
+      {
+        if (typeof pendingProps.src === 'string' && pendingProps.async === true) {
+          const scriptProps = pendingProps;
+          const key = getScriptKey(scriptProps.src);
+          const scripts = getResourcesFromRoot(resourceRoot).hoistableScripts;
+          let resource = scripts.get(key);
+
+          if (!resource) {
+            resource = {
+              type: 'script',
+              instance: null,
+              count: 0,
+              state: null
+            };
+            scripts.set(key, resource);
+          }
+
+          return resource;
+        }
+
+        return {
+          type: 'void',
+          instance: null,
+          count: 0,
+          state: null
+        };
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(444, type));
+      }
+  }
+}
+
+function styleTagPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    'data-href': rawProps.href,
+    'data-precedence': rawProps.precedence,
+    href: null,
+    precedence: null
+  });
+}
+
+function getStyleKey(href) {
+  const limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+  return "href=\"" + limitedEscapedHref + "\"";
+}
+
+function getStyleTagSelector(href) {
+  const limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+  return "style[data-href~=\"" + limitedEscapedHref + "\"]";
+}
+
+function getStylesheetSelectorFromKey(key) {
+  return "link[rel=\"stylesheet\"][" + key + "]";
+}
+
+function getPreloadStylesheetSelectorFromKey(key) {
+  return "link[rel=\"preload\"][as=\"style\"][" + key + "]";
+}
+
+function stylesheetPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    'data-precedence': rawProps.precedence,
+    precedence: null
+  });
+}
+
+function preloadStylesheet(ownerDocument, key, preloadProps, state) {
+  preloadPropsMap.set(key, preloadProps);
+
+  if (!ownerDocument.querySelector(getStylesheetSelectorFromKey(key))) {
+    // There is no matching stylesheet instance in the Document.
+    // We will insert a preload now to kick off loading because
+    // we expect this stylesheet to commit
+    const preloadEl = ownerDocument.querySelector(getPreloadStylesheetSelectorFromKey(key));
+
+    if (preloadEl) {
+      // If we find a preload already it was SSR'd and we won't have an actual
+      // loading state to track. For now we will just assume it is loaded
+      state.loading = Loaded;
+    } else {
+      const instance = ownerDocument.createElement('link');
+      state.preload = instance;
+      instance.addEventListener('load', () => state.loading |= Loaded);
+      instance.addEventListener('error', () => state.loading |= Errored);
+      setInitialProperties(instance, 'link', preloadProps);
+      markNodeAsHoistable(instance);
+      ownerDocument.head.appendChild(instance);
+    }
+  }
+}
+
+function preloadPropsFromStylesheet(props) {
+  return {
+    rel: 'preload',
+    as: 'style',
+    href: props.href,
+    crossOrigin: props.crossOrigin,
+    integrity: props.integrity,
+    media: props.media,
+    hrefLang: props.hrefLang,
+    referrerPolicy: props.referrerPolicy
+  };
+}
+
+function getScriptKey(src) {
+  const limitedEscapedSrc = escapeSelectorAttributeValueInsideDoubleQuotes(src);
+  return "[src=\"" + limitedEscapedSrc + "\"]";
+}
+
+function getScriptSelectorFromKey(key) {
+  return 'script[async]' + key;
+}
+
+function acquireResource(hoistableRoot, resource, props) {
+  resource.count++;
+
+  if (resource.instance === null) {
+    switch (resource.type) {
+      case 'style':
+        {
+          const qualifiedProps = props; // Attempt to hydrate instance from DOM
+
+          let instance = hoistableRoot.querySelector(getStyleTagSelector(qualifiedProps.href));
+
+          if (instance) {
+            resource.instance = instance;
+            markNodeAsHoistable(instance);
+            return instance;
+          }
+
+          const styleProps = styleTagPropsFromRawProps(props);
+          const ownerDocument = getDocumentFromRoot(hoistableRoot);
+          instance = ownerDocument.createElement('style');
+          markNodeAsHoistable(instance);
+          setInitialProperties(instance, 'style', styleProps); // TODO: `style` does not have loading state for tracking insertions. I
+          // guess because these aren't suspensey? Not sure whether this is a
+          // factoring smell.
+          // resource.state.loading |= Inserted;
+
+          insertStylesheet(instance, qualifiedProps.precedence, hoistableRoot);
+          resource.instance = instance;
+          return instance;
+        }
+
+      case 'stylesheet':
+        {
+          // This typing is enforce by `getResource`. If we change the logic
+          // there for what qualifies as a stylesheet resource we need to ensure
+          // this cast still makes sense;
+          const qualifiedProps = props;
+          const key = getStyleKey(qualifiedProps.href); // Attempt to hydrate instance from DOM
+
+          let instance = hoistableRoot.querySelector(getStylesheetSelectorFromKey(key));
+
+          if (instance) {
+            resource.state.loading |= Inserted;
+            resource.instance = instance;
+            markNodeAsHoistable(instance);
+            return instance;
+          }
+
+          const stylesheetProps = stylesheetPropsFromRawProps(props);
+          const preloadProps = preloadPropsMap.get(key);
+
+          if (preloadProps) {
+            adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps);
+          } // Construct and insert a new instance
+
+
+          const ownerDocument = getDocumentFromRoot(hoistableRoot);
+          instance = ownerDocument.createElement('link');
+          markNodeAsHoistable(instance);
+          const linkInstance = instance;
+          linkInstance._p = new Promise((resolve, reject) => {
+            linkInstance.onload = resolve;
+            linkInstance.onerror = reject;
+          });
+          setInitialProperties(instance, 'link', stylesheetProps);
+          resource.state.loading |= Inserted;
+          insertStylesheet(instance, qualifiedProps.precedence, hoistableRoot);
+          resource.instance = instance;
+          return instance;
+        }
+
+      case 'script':
+        {
+          // This typing is enforce by `getResource`. If we change the logic
+          // there for what qualifies as a stylesheet resource we need to ensure
+          // this cast still makes sense;
+          const borrowedScriptProps = props;
+          const key = getScriptKey(borrowedScriptProps.src); // Attempt to hydrate instance from DOM
+
+          let instance = hoistableRoot.querySelector(getScriptSelectorFromKey(key));
+
+          if (instance) {
+            resource.instance = instance;
+            markNodeAsHoistable(instance);
+            return instance;
+          }
+
+          let scriptProps = borrowedScriptProps;
+          const preloadProps = preloadPropsMap.get(key);
+
+          if (preloadProps) {
+            scriptProps = assign({}, borrowedScriptProps);
+            adoptPreloadPropsForScript(scriptProps, preloadProps);
+          } // Construct and insert a new instance
+
+
+          const ownerDocument = getDocumentFromRoot(hoistableRoot);
+          instance = ownerDocument.createElement('script');
+          markNodeAsHoistable(instance);
+          setInitialProperties(instance, 'link', scriptProps);
+          ownerDocument.head.appendChild(instance);
+          resource.instance = instance;
+          return instance;
+        }
+
+      case 'void':
+        {
+          return null;
+        }
+
+      default:
+        {
+          throw Error(formatProdErrorMessage(443, resource.type));
+        }
+    }
+  } else {
+    // In the case of stylesheets, they might have already been assigned an
+    // instance during `suspendResource`. But that doesn't mean they were
+    // inserted, because the commit might have been interrupted. So we need to
+    // check now.
+    //
+    // The other resource types are unaffected because they are not
+    // yet suspensey.
+    //
+    // TODO: This is a bit of a code smell. Consider refactoring how
+    // `suspendResource` and `acquireResource` work together. The idea is that
+    // `suspendResource` does all the same stuff as `acquireResource` except
+    // for the insertion.
+    if (resource.type === 'stylesheet' && (resource.state.loading & Inserted) === NotLoaded) {
+      const qualifiedProps = props;
+      const instance = resource.instance;
+      resource.state.loading |= Inserted;
+      insertStylesheet(instance, qualifiedProps.precedence, hoistableRoot);
+    }
+  }
+
+  return resource.instance;
+}
+function releaseResource(resource) {
+  resource.count--;
+}
+
+function insertStylesheet(instance, precedence, root) {
+  const nodes = root.querySelectorAll('link[rel="stylesheet"][data-precedence],style[data-precedence]');
+  const last = nodes.length ? nodes[nodes.length - 1] : null;
+  let prior = last;
+
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const nodePrecedence = node.dataset.precedence;
+
+    if (nodePrecedence === precedence) {
+      prior = node;
+    } else if (prior !== last) {
+      break;
+    }
+  }
+
+  if (prior) {
+    // We get the prior from the document so we know it is in the tree.
+    // We also know that links can't be the topmost Node so the parentNode
+    // must exist.
+    prior.parentNode.insertBefore(instance, prior.nextSibling);
+  } else {
+    const parent = root.nodeType === DOCUMENT_NODE ? root.head : root;
+    parent.insertBefore(instance, parent.firstChild);
+  }
+}
+
+function adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps) {
+  if (stylesheetProps.crossOrigin == null) stylesheetProps.crossOrigin = preloadProps.crossOrigin;
+  if (stylesheetProps.referrerPolicy == null) stylesheetProps.referrerPolicy = preloadProps.referrerPolicy;
+  if (stylesheetProps.title == null) stylesheetProps.title = preloadProps.title;
+}
+
+function adoptPreloadPropsForScript(scriptProps, preloadProps) {
+  if (scriptProps.crossOrigin == null) scriptProps.crossOrigin = preloadProps.crossOrigin;
+  if (scriptProps.referrerPolicy == null) scriptProps.referrerPolicy = preloadProps.referrerPolicy;
+  if (scriptProps.integrity == null) scriptProps.integrity = preloadProps.integrity;
+}
+
+let tagCaches = null;
+function hydrateHoistable(hoistableRoot, type, props, internalInstanceHandle) {
+  const ownerDocument = getDocumentFromRoot(hoistableRoot);
+  let instance = null;
+
+  getInstance: switch (type) {
+    case 'title':
+      {
+        instance = ownerDocument.getElementsByTagName('title')[0];
+
+        if (!instance || isOwnedInstance(instance) || instance.namespaceURI === SVG_NAMESPACE || instance.hasAttribute('itemprop')) {
+          instance = ownerDocument.createElement(type);
+          ownerDocument.head.insertBefore(instance, ownerDocument.querySelector('head > title'));
+        }
+
+        setInitialProperties(instance, type, props);
+        precacheFiberNode(internalInstanceHandle, instance);
+        markNodeAsHoistable(instance);
+        return instance;
+      }
+
+    case 'link':
+      {
+        const cache = getHydratableHoistableCache('link', 'href', ownerDocument);
+        const key = type + (props.href || '');
+        const maybeNodes = cache.get(key);
+
+        if (maybeNodes) {
+          const nodes = maybeNodes;
+
+          for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i];
+
+            if (node.getAttribute('href') !== (props.href == null ? null : props.href) || node.getAttribute('rel') !== (props.rel == null ? null : props.rel) || node.getAttribute('title') !== (props.title == null ? null : props.title) || node.getAttribute('crossorigin') !== (props.crossOrigin == null ? null : props.crossOrigin)) {
+              // mismatch, try the next node;
+              continue;
+            }
+
+            instance = node;
+            nodes.splice(i, 1);
+            break getInstance;
+          }
+        }
+
+        instance = ownerDocument.createElement(type);
+        setInitialProperties(instance, type, props);
+        ownerDocument.head.appendChild(instance);
+        break;
+      }
+
+    case 'meta':
+      {
+        const cache = getHydratableHoistableCache('meta', 'content', ownerDocument);
+        const key = type + (props.content || '');
+        const maybeNodes = cache.get(key);
+
+        if (maybeNodes) {
+          const nodes = maybeNodes;
+
+          for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i]; // We coerce content to string because it is the most likely one to
+
+            if (node.getAttribute('content') !== (props.content == null ? null : '' + props.content) || node.getAttribute('name') !== (props.name == null ? null : props.name) || node.getAttribute('property') !== (props.property == null ? null : props.property) || node.getAttribute('http-equiv') !== (props.httpEquiv == null ? null : props.httpEquiv) || node.getAttribute('charset') !== (props.charSet == null ? null : props.charSet)) {
+              // mismatch, try the next node;
+              continue;
+            }
+
+            instance = node;
+            nodes.splice(i, 1);
+            break getInstance;
+          }
+        }
+
+        instance = ownerDocument.createElement(type);
+        setInitialProperties(instance, type, props);
+        ownerDocument.head.appendChild(instance);
+        break;
+      }
+
+    default:
+      throw Error(formatProdErrorMessage(468, type));
+  } // This node is a match
+
+
+  precacheFiberNode(internalInstanceHandle, instance);
+  markNodeAsHoistable(instance);
+  return instance;
+}
+
+function getHydratableHoistableCache(type, keyAttribute, ownerDocument) {
+  let cache;
+  let caches;
+
+  if (tagCaches === null) {
+    cache = new Map();
+    caches = tagCaches = new Map();
+    caches.set(ownerDocument, cache);
+  } else {
+    caches = tagCaches;
+    const maybeCache = caches.get(ownerDocument);
+
+    if (!maybeCache) {
+      cache = new Map();
+      caches.set(ownerDocument, cache);
+    } else {
+      cache = maybeCache;
+    }
+  }
+
+  if (cache.has(type)) {
+    // We use type as a special key that signals that this cache has been seeded for this type
+    return cache;
+  } // Mark this cache as seeded for this type
+
+
+  cache.set(type, null);
+  const nodes = ownerDocument.getElementsByTagName(type);
+
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+
+    if (!isOwnedInstance(node) && (type !== 'link' || node.getAttribute('rel') !== 'stylesheet') && node.namespaceURI !== SVG_NAMESPACE) {
+      const nodeKey = node.getAttribute(keyAttribute) || '';
+      const key = type + nodeKey;
+      const existing = cache.get(key);
+
+      if (existing) {
+        existing.push(node);
+      } else {
+        cache.set(key, [node]);
+      }
+    }
+  }
+
+  return cache;
+}
+
+function mountHoistable(hoistableRoot, type, instance) {
+  const ownerDocument = getDocumentFromRoot(hoistableRoot);
+  ownerDocument.head.insertBefore(instance, type === 'title' ? ownerDocument.querySelector('head > title') : null);
+}
+function unmountHoistable(instance) {
+  instance.parentNode.removeChild(instance);
+}
+function isHostHoistableType(type, props, hostContext) {
+  let hostContextProd;
+
+  {
+    hostContextProd = hostContext;
+  } // Global opt out of hoisting for anything in SVG Namespace or anything with an itemProp inside an itemScope
+
+
+  if (hostContextProd === HostContextNamespaceSvg || props.itemProp != null) {
+
+    return false;
+  }
+
+  switch (type) {
+    case 'meta':
+    case 'title':
+      {
+        return true;
+      }
+
+    case 'style':
+      {
+        if (typeof props.precedence !== 'string' || typeof props.href !== 'string' || props.href === '') {
+
+          return false;
+        }
+
+        return true;
+      }
+
+    case 'link':
+      {
+        if (typeof props.rel !== 'string' || typeof props.href !== 'string' || props.href === '' || props.onLoad || props.onError) {
+
+          return false;
+        }
+
+        switch (props.rel) {
+          case 'stylesheet':
+            {
+              const precedence = props.precedence,
+                    disabled = props.disabled;
+
+              return typeof precedence === 'string' && disabled == null;
+            }
+
+          default:
+            {
+              return true;
+            }
+        }
+      }
+
+    case 'script':
+      {
+        if (props.async !== true || props.onLoad || props.onError || typeof props.src !== 'string' || !props.src) {
+
+          return false;
+        }
+
+        return true;
+      }
+
+    case 'noscript':
+    case 'template':
+      {
+
+        return false;
+      }
+  }
+
+  return false;
+}
+function mayResourceSuspendCommit(resource) {
+  return resource.type === 'stylesheet' && (resource.state.loading & Inserted) === NotLoaded;
+}
+function preloadInstance(type, props) {
+  // Return true to indicate it's already loaded
+  return true;
+}
+function preloadResource(resource) {
+  if (resource.type === 'stylesheet' && (resource.state.loading & Settled) === NotLoaded) {
+    // we have not finished loading the underlying stylesheet yet.
+    return false;
+  } // Return true to indicate it's already loaded
+
+
+  return true;
+}
+let suspendedState = null; // We use a noop function when we begin suspending because if possible we want the
+// waitfor step to finish synchronously. If it doesn't we'll return a function to
+// provide the actual unsuspend function and that will get completed when the count
+// hits zero or it will get cancelled if the root starts new work.
+
+function noop() {}
+
+function startSuspendingCommit() {
+  suspendedState = {
+    stylesheets: null,
+    count: 0,
+    unsuspend: noop
+  };
+}
+function suspendResource(hoistableRoot, resource, props) {
+  if (suspendedState === null) {
+    throw Error(formatProdErrorMessage(475));
+  }
+
+  const state = suspendedState;
+
+  if (resource.type === 'stylesheet') {
+    if (typeof props.media === 'string') {
+      // If we don't currently match media we avoid suspending on this resource
+      // and let it insert on the mutation path
+      if (matchMedia(props.media).matches === false) {
+        return;
+      }
+    }
+
+    if ((resource.state.loading & Inserted) === NotLoaded) {
+      if (resource.instance === null) {
+        const qualifiedProps = props;
+        const key = getStyleKey(qualifiedProps.href); // Attempt to hydrate instance from DOM
+
+        let instance = hoistableRoot.querySelector(getStylesheetSelectorFromKey(key));
+
+        if (instance) {
+          // If this instance has a loading state it came from the Fizz runtime.
+          // If there is not loading state it is assumed to have been server rendered
+          // as part of the preamble and therefore synchronously loaded. It could have
+          // errored however which we still do not yet have a means to detect. For now
+          // we assume it is loaded.
+          const maybeLoadingState = instance._p;
+
+          if (maybeLoadingState !== null && typeof maybeLoadingState === 'object' && // $FlowFixMe[method-unbinding]
+          typeof maybeLoadingState.then === 'function') {
+            const loadingState = maybeLoadingState;
+            state.count++;
+            const ping = onUnsuspend.bind(state);
+            loadingState.then(ping, ping);
+          }
+
+          resource.state.loading |= Inserted;
+          resource.instance = instance;
+          markNodeAsHoistable(instance);
+          return;
+        }
+
+        const ownerDocument = getDocumentFromRoot(hoistableRoot);
+        const stylesheetProps = stylesheetPropsFromRawProps(props);
+        const preloadProps = preloadPropsMap.get(key);
+
+        if (preloadProps) {
+          adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps);
+        } // Construct and insert a new instance
+
+
+        instance = ownerDocument.createElement('link');
+        markNodeAsHoistable(instance);
+        const linkInstance = instance; // This Promise is a loading state used by the Fizz runtime. We need this incase there is a race
+        // between this resource being rendered on the client and being rendered with a late completed boundary.
+
+        linkInstance._p = new Promise((resolve, reject) => {
+          linkInstance.onload = resolve;
+          linkInstance.onerror = reject;
+        });
+        setInitialProperties(instance, 'link', stylesheetProps);
+        resource.instance = instance;
+      }
+
+      if (state.stylesheets === null) {
+        state.stylesheets = new Map();
+      }
+
+      state.stylesheets.set(resource, hoistableRoot);
+      const preloadEl = resource.state.preload;
+
+      if (preloadEl && (resource.state.loading & Settled) === NotLoaded) {
+        state.count++;
+        const ping = onUnsuspend.bind(state);
+        preloadEl.addEventListener('load', ping);
+        preloadEl.addEventListener('error', ping);
+      }
+    }
+  }
+}
+function waitForCommitToBeReady() {
+  if (suspendedState === null) {
+    throw Error(formatProdErrorMessage(475));
+  }
+
+  const state = suspendedState;
+
+  if (state.stylesheets && state.count === 0) {
+    // We are not currently blocked but we have not inserted all stylesheets.
+    // If this insertion happens and loads or errors synchronously then we can
+    // avoid suspending the commit. To do this we check the count again immediately after
+    insertSuspendedStylesheets(state, state.stylesheets);
+  } // We need to check the count again because the inserted stylesheets may have led to new
+  // tasks to wait on.
+
+
+  if (state.count > 0) {
+    return commit => {
+      // We almost never want to show content before its styles have loaded. But
+      // eventually we will give up and allow unstyled content. So this number is
+      // somewhat arbitrary — big enough that you'd only reach it under
+      // extreme circumstances.
+      // TODO: Figure out what the browser engines do during initial page load and
+      // consider aligning our behavior with that.
+      const stylesheetTimer = setTimeout(() => {
+        if (state.stylesheets) {
+          insertSuspendedStylesheets(state, state.stylesheets);
+        }
+
+        if (state.unsuspend) {
+          const unsuspend = state.unsuspend;
+          state.unsuspend = null;
+          unsuspend();
+        }
+      }, 60000); // one minute
+
+      state.unsuspend = commit;
+      return () => {
+        state.unsuspend = null;
+        clearTimeout(stylesheetTimer);
+      };
+    };
+  }
+
+  return null;
+}
+
+function onUnsuspend() {
+  this.count--;
+
+  if (this.count === 0) {
+    if (this.stylesheets) {
+      // If we haven't actually inserted the stylesheets yet we need to do so now before starting the commit.
+      // The reason we do this after everything else has finished is because we want to have all the stylesheets
+      // load synchronously right before mutating. Ideally the new styles will cause a single recalc only on the
+      // new tree. When we filled up stylesheets we only inlcuded stylesheets with matching media attributes so we
+      // wait for them to load before actually continuing. We expect this to increase the count above zero
+      insertSuspendedStylesheets(this, this.stylesheets);
+    } else if (this.unsuspend) {
+      const unsuspend = this.unsuspend;
+      this.unsuspend = null;
+      unsuspend();
+    }
+  }
+} // This is typecast to non-null because it will always be set before read.
+// it is important that this not be used except when the stack guarantees it exists.
+// Currentlyt his is only during insertSuspendedStylesheet.
+
+
+let precedencesByRoot = null;
+
+function insertSuspendedStylesheets(state, resources) {
+  // We need to clear this out so we don't try to reinsert after the stylesheets have loaded
+  state.stylesheets = null;
+
+  if (state.unsuspend === null) {
+    // The suspended commit was cancelled. We don't need to insert any stylesheets.
+    return;
+  } // Temporarily increment count. we don't want any synchronously loaded stylesheets to try to unsuspend
+  // before we finish inserting all stylesheets.
+
+
+  state.count++;
+  precedencesByRoot = new Map();
+  resources.forEach(insertStylesheetIntoRoot, state);
+  precedencesByRoot = null; // We can remove our temporary count and if we're still at zero we can unsuspend.
+  // If we are in the synchronous phase before deciding if the commit should suspend and this
+  // ends up hitting the unsuspend path it will just invoke the noop unsuspend.
+
+  onUnsuspend.call(state);
+}
+
+function insertStylesheetIntoRoot(root, resource, map) {
+  if (resource.state.loading & Inserted) {
+    // This resource was inserted by another root committing. we don't need to insert it again
+    return;
+  }
+
+  let last;
+  let precedences = precedencesByRoot.get(root);
+
+  if (!precedences) {
+    precedences = new Map();
+    precedencesByRoot.set(root, precedences);
+    const nodes = root.querySelectorAll('link[data-precedence],style[data-precedence]');
+
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+
+      if (node.nodeName === 'link' || // We omit style tags with media="not all" because they are not in the right position
+      // and will be hoisted by the Fizz runtime imminently.
+      node.getAttribute('media') !== 'not all') {
+        precedences.set('p' + node.dataset.precedence, node);
+        last = node;
+      }
+    }
+
+    if (last) {
+      precedences.set('last', last);
+    }
+  } else {
+    last = precedences.get('last');
+  } // We only call this after we have constructed an instance so we assume it here
+
+
+  const instance = resource.instance; // We will always have a precedence for stylesheet instances
+
+  const precedence = instance.getAttribute('data-precedence');
+  const prior = precedences.get('p' + precedence) || last;
+
+  if (prior === last) {
+    precedences.set('last', instance);
+  }
+
+  precedences.set(precedence, instance);
+  this.count++;
+  const onComplete = onUnsuspend.bind(this);
+  instance.addEventListener('load', onComplete);
+  instance.addEventListener('error', onComplete);
+
+  if (prior) {
+    prior.parentNode.insertBefore(instance, prior.nextSibling);
+  } else {
+    const parent = root.nodeType === DOCUMENT_NODE ? root.head : root;
+    parent.insertBefore(instance, parent.firstChild);
+  }
+
+  resource.state.loading |= Inserted;
+}
+
+const NotPendingTransition = NotPending;
+
+const Dispatcher$1 = Internals.Dispatcher;
+
+if (typeof document !== 'undefined') {
+  // Set the default dispatcher to the client dispatcher
+  Dispatcher$1.current = ReactDOMClientDispatcher;
+}
+/* global reportError */
+
+const defaultOnRecoverableError = typeof reportError === 'function' ? // In modern browsers, reportError will dispatch an error event,
+// emulating an uncaught JavaScript error.
+reportError : error => {
+  // In older browsers and test environments, fallback to console.error.
+  // eslint-disable-next-line react-internal/no-production-logging
+  console['error'](error);
+}; // $FlowFixMe[missing-this-annot]
+
+function ReactDOMRoot(internalRoot) {
+  this._internalRoot = internalRoot;
+} // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+ReactDOMHydrationRoot.prototype.render = ReactDOMRoot.prototype.render = // $FlowFixMe[missing-this-annot]
+function (children) {
+  const root = this._internalRoot;
+
+  if (root === null) {
+    throw Error(formatProdErrorMessage(409));
+  }
+
+  updateContainer(children, root, null, null);
+}; // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+ReactDOMHydrationRoot.prototype.unmount = ReactDOMRoot.prototype.unmount = // $FlowFixMe[missing-this-annot]
+function () {
+
+  const root = this._internalRoot;
+
+  if (root !== null) {
+    this._internalRoot = null;
+    const container = root.containerInfo;
+
+    flushSync$1(() => {
+      updateContainer(null, root, null, null);
+    });
+    unmarkContainerAsRoot(container);
+  }
+};
+
+function createRoot$1(container, options) {
+  if (!isValidContainer(container)) {
+    throw Error(formatProdErrorMessage(299));
+  }
+  let isStrictMode = false;
+  let concurrentUpdatesByDefaultOverride = false;
+  let identifierPrefix = '';
+  let onRecoverableError = defaultOnRecoverableError;
+  let transitionCallbacks = null;
+
+  if (options !== null && options !== undefined) {
+
+    if (options.unstable_strictMode === true) {
+      isStrictMode = true;
+    }
+
+    if (options.identifierPrefix !== undefined) {
+      identifierPrefix = options.identifierPrefix;
+    }
+
+    if (options.onRecoverableError !== undefined) {
+      onRecoverableError = options.onRecoverableError;
+    }
+
+    if (options.unstable_transitionCallbacks !== undefined) {
+      transitionCallbacks = options.unstable_transitionCallbacks;
+    }
+  }
+
+  const root = createContainer(container, ConcurrentRoot, null, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks);
+  markContainerAsRoot(root.current, container);
+  Dispatcher$1.current = ReactDOMClientDispatcher;
+  const rootContainerElement = container.nodeType === COMMENT_NODE ? container.parentNode : container;
+  listenToAllSupportedEvents(rootContainerElement); // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
+
+  return new ReactDOMRoot(root);
+} // $FlowFixMe[missing-this-annot]
+
+function ReactDOMHydrationRoot(internalRoot) {
+  this._internalRoot = internalRoot;
+}
+
+function scheduleHydration(target) {
+  if (target) {
+    queueExplicitHydrationTarget(target);
+  }
+} // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+ReactDOMHydrationRoot.prototype.unstable_scheduleHydration = scheduleHydration;
+function hydrateRoot$1(container, initialChildren, options) {
+  if (!isValidContainer(container)) {
+    throw Error(formatProdErrorMessage(405));
+  }
+  // the hydration callbacks.
+
+
+  const hydrationCallbacks = options != null ? options : null;
+  let isStrictMode = false;
+  let concurrentUpdatesByDefaultOverride = false;
+  let identifierPrefix = '';
+  let onRecoverableError = defaultOnRecoverableError;
+  let transitionCallbacks = null;
+  let formState = null;
+
+  if (options !== null && options !== undefined) {
+    if (options.unstable_strictMode === true) {
+      isStrictMode = true;
+    }
+
+    if (options.identifierPrefix !== undefined) {
+      identifierPrefix = options.identifierPrefix;
+    }
+
+    if (options.onRecoverableError !== undefined) {
+      onRecoverableError = options.onRecoverableError;
+    }
+
+    if (options.unstable_transitionCallbacks !== undefined) {
+      transitionCallbacks = options.unstable_transitionCallbacks;
+    }
+
+    {
+      if (options.formState !== undefined) {
+        formState = options.formState;
+      }
+    }
+  }
+
+  const root = createHydrationContainer(initialChildren, null, container, ConcurrentRoot, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks, formState);
+  markContainerAsRoot(root.current, container);
+  Dispatcher$1.current = ReactDOMClientDispatcher; // This can't be a comment node since hydration doesn't work on comment nodes anyway.
+
+  listenToAllSupportedEvents(container); // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
+
+  return new ReactDOMHydrationRoot(root);
+}
+function isValidContainer(node) {
+  return !!(node && (node.nodeType === ELEMENT_NODE || node.nodeType === DOCUMENT_NODE || node.nodeType === DOCUMENT_FRAGMENT_NODE || !disableCommentsAsDOMContainers  ));
+} // TODO: Remove this function which also includes comment nodes.
+// We only use it in places that are currently more relaxed.
+
+function isValidContainerLegacy(node) {
+  return !!(node && (node.nodeType === ELEMENT_NODE || node.nodeType === DOCUMENT_NODE || node.nodeType === DOCUMENT_FRAGMENT_NODE || node.nodeType === COMMENT_NODE && node.nodeValue === ' react-mount-point-unstable '));
+}
+
+function noopOnRecoverableError() {// This isn't reachable because onRecoverableError isn't called in the
+  // legacy API.
+}
+
+function legacyCreateRootFromDOMContainer(container, initialChildren, parentComponent, callback, isHydrationContainer) {
+  if (isHydrationContainer) {
+    if (typeof callback === 'function') {
+      const originalCallback = callback;
+
+      callback = function () {
+        const instance = getPublicRootInstance(root);
+        originalCallback.call(instance);
+      };
+    }
+
+    const root = createHydrationContainer(initialChildren, callback, container, LegacyRoot, null, // hydrationCallbacks
+    false, // isStrictMode
+    false, // concurrentUpdatesByDefaultOverride,
+    '', // identifierPrefix
+    noopOnRecoverableError, // TODO(luna) Support hydration later
+    null, null);
+    container._reactRootContainer = root;
+    markContainerAsRoot(root.current, container);
+    const rootContainerElement = container.nodeType === COMMENT_NODE ? container.parentNode : container; // $FlowFixMe[incompatible-call]
+
+    listenToAllSupportedEvents(rootContainerElement);
+    flushSync$1();
+    return root;
+  } else {
+    // First clear any existing content.
+    clearContainer(container);
+
+    if (typeof callback === 'function') {
+      const originalCallback = callback;
+
+      callback = function () {
+        const instance = getPublicRootInstance(root);
+        originalCallback.call(instance);
+      };
+    }
+
+    const root = createContainer(container, LegacyRoot, null, // hydrationCallbacks
+    false, // isStrictMode
+    false, // concurrentUpdatesByDefaultOverride,
+    '', // identifierPrefix
+    noopOnRecoverableError, // onRecoverableError
+    null // transitionCallbacks
+    );
+    container._reactRootContainer = root;
+    markContainerAsRoot(root.current, container);
+    const rootContainerElement = container.nodeType === COMMENT_NODE ? container.parentNode : container; // $FlowFixMe[incompatible-call]
+
+    listenToAllSupportedEvents(rootContainerElement); // Initial mount should not be batched.
+
+    flushSync$1(() => {
+      updateContainer(initialChildren, root, parentComponent, callback);
+    });
+    return root;
+  }
+}
+
+function legacyRenderSubtreeIntoContainer(parentComponent, children, container, forceHydrate, callback) {
+
+  const maybeRoot = container._reactRootContainer;
+  let root;
+
+  if (!maybeRoot) {
+    // Initial mount
+    root = legacyCreateRootFromDOMContainer(container, children, parentComponent, callback, forceHydrate);
+  } else {
+    root = maybeRoot;
+
+    if (typeof callback === 'function') {
+      const originalCallback = callback;
+
+      callback = function () {
+        const instance = getPublicRootInstance(root);
+        originalCallback.call(instance);
+      };
+    } // Update
+
+
+    updateContainer(children, root, parentComponent, callback);
+  }
+
+  return getPublicRootInstance(root);
+}
+
+function findDOMNode(componentOrElement) {
+
+  if (componentOrElement == null) {
+    return null;
+  }
+
+  if (componentOrElement.nodeType === ELEMENT_NODE) {
+    return componentOrElement;
+  }
+
+  return findHostInstance(componentOrElement);
+}
+function hydrate(element, container, callback) {
+
+  if (!isValidContainerLegacy(container)) {
+    throw Error(formatProdErrorMessage(200));
+  }
+
+
+  return legacyRenderSubtreeIntoContainer(null, element, container, true, callback);
+}
+function render(element, container, callback) {
+
+  if (!isValidContainerLegacy(container)) {
+    throw Error(formatProdErrorMessage(200));
+  }
+
+  return legacyRenderSubtreeIntoContainer(null, element, container, false, callback);
+}
+function unstable_renderSubtreeIntoContainer(parentComponent, element, containerNode, callback) {
+
+  if (!isValidContainerLegacy(containerNode)) {
+    throw Error(formatProdErrorMessage(200));
+  }
+
+  if (parentComponent == null || !has(parentComponent)) {
+    throw Error(formatProdErrorMessage(38));
+  }
+
+  return legacyRenderSubtreeIntoContainer(parentComponent, element, containerNode, false, callback);
+}
+function unmountComponentAtNode(container) {
+  if (!isValidContainerLegacy(container)) {
+    throw Error(formatProdErrorMessage(40));
+  }
+
+  if (container._reactRootContainer) {
+
+
+    flushSync$1(() => {
+      legacyRenderSubtreeIntoContainer(null, null, container, false, () => {
+        // $FlowFixMe[incompatible-type] This should probably use `delete container._reactRootContainer`
+        container._reactRootContainer = null;
+        unmarkContainerAsRoot(container);
+      });
+    }); // If you call unmountComponentAtNode twice in quick succession, you'll
+    // get `true` twice. That's probably fine?
+
+    return true;
+  } else {
+
+    return false;
+  }
+}
+
+const ReactDOMSharedInternals = Internals;
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+function getCrossOriginStringAs(as, input) {
+  if (as === 'font') {
+    return '';
+  }
+
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+const Dispatcher = ReactDOMSharedInternals.Dispatcher;
+function prefetchDNS(href) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    dispatcher.prefetchDNS(href);
+  } // We don't error because preconnect needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preconnect(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    const crossOrigin = options ? getCrossOriginString(options.crossOrigin) : null;
+    dispatcher.preconnect(href, crossOrigin);
+  } // We don't error because preconnect needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preload(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string' && // We check existence because we cannot enforce this function is actually called with the stated type
+  typeof options === 'object' && options !== null && typeof options.as === 'string') {
+    const as = options.as;
+    const crossOrigin = getCrossOriginStringAs(as, options.crossOrigin);
+    dispatcher.preload(href, as, {
+      crossOrigin,
+      integrity: typeof options.integrity === 'string' ? options.integrity : undefined,
+      nonce: typeof options.nonce === 'string' ? options.nonce : undefined,
+      type: typeof options.type === 'string' ? options.type : undefined,
+      fetchPriority: typeof options.fetchPriority === 'string' ? options.fetchPriority : undefined,
+      referrerPolicy: typeof options.referrerPolicy === 'string' ? options.referrerPolicy : undefined,
+      imageSrcSet: typeof options.imageSrcSet === 'string' ? options.imageSrcSet : undefined,
+      imageSizes: typeof options.imageSizes === 'string' ? options.imageSizes : undefined
+    });
+  } // We don't error because preload needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preloadModule(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    if (options) {
+      const crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);
+      dispatcher.preloadModule(href, {
+        as: typeof options.as === 'string' && options.as !== 'script' ? options.as : undefined,
+        crossOrigin,
+        integrity: typeof options.integrity === 'string' ? options.integrity : undefined
+      });
+    } else {
+      dispatcher.preloadModule(href);
+    }
+  } // We don't error because preload needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preinit(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string' && options && typeof options.as === 'string') {
+    const as = options.as;
+    const crossOrigin = getCrossOriginStringAs(as, options.crossOrigin);
+    const integrity = typeof options.integrity === 'string' ? options.integrity : undefined;
+    const fetchPriority = typeof options.fetchPriority === 'string' ? options.fetchPriority : undefined;
+
+    if (as === 'style') {
+      dispatcher.preinitStyle(href, typeof options.precedence === 'string' ? options.precedence : undefined, {
+        crossOrigin,
+        integrity,
+        fetchPriority
+      });
+    } else if (as === 'script') {
+      dispatcher.preinitScript(href, {
+        crossOrigin,
+        integrity,
+        fetchPriority,
+        nonce: typeof options.nonce === 'string' ? options.nonce : undefined
+      });
+    }
+  } // We don't error because preinit needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preinitModule(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    if (typeof options === 'object' && options !== null) {
+      if (options.as == null || options.as === 'script') {
+        const crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);
+        dispatcher.preinitModuleScript(href, {
+          crossOrigin,
+          integrity: typeof options.integrity === 'string' ? options.integrity : undefined,
+          nonce: typeof options.nonce === 'string' ? options.nonce : undefined
+        });
+      }
+    } else if (options == null) {
+      dispatcher.preinitModuleScript(href);
+    }
+  } // We don't error because preinit needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+
+function createPortal(children, container) {
+  let key = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+
+  if (!isValidContainer(container)) {
+    throw Error(formatProdErrorMessage(200));
+  } // TODO: pass ReactDOM portal implementation as third argument
+  // $FlowFixMe[incompatible-return] The Flow type is opaque but there's no way to actually create it.
+
+
+  return createPortal$1(children, container, null, key);
+}
+
+function renderSubtreeIntoContainer(parentComponent, element, containerNode, callback) {
+  return unstable_renderSubtreeIntoContainer(parentComponent, element, containerNode, callback);
+}
+
+function createRoot(container, options) {
+
+  return createRoot$1(container, options);
+}
+
+function hydrateRoot(container, initialChildren, options) {
+
+  return hydrateRoot$1(container, initialChildren, options);
+} // Overload the definition to the two valid signatures.
+// Warning, this opts-out of checking the function body.
+// eslint-disable-next-line no-redeclare
+// eslint-disable-next-line no-redeclare
+
+
+function flushSync(fn) {
+
+  return flushSync$1(fn);
+}
+// This is an array for better minification.
+
+Internals.Events = [getInstanceFromNode$1, getNodeFromInstance, getFiberCurrentPropsFromNode, enqueueStateRestore, restoreStateIfNeeded, batchedUpdates$1];
+injectIntoDevTools({
+  findFiberByHostInstance: getClosestInstanceFromNode,
+  bundleType: 0,
+  version: ReactVersion,
+  rendererPackageName: 'react-dom'
+});
+
+function experimental_useFormStatus() {
+
+  return useFormStatus();
+}
+function experimental_useFormState(action, initialState, permalink) {
+
+  return useFormState(action, initialState, permalink);
+}
+
+exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = Internals;
+exports.createComponentSelector = createComponentSelector;
+exports.createHasPseudoClassSelector = createHasPseudoClassSelector;
+exports.createPortal = createPortal;
+exports.createRoleSelector = createRoleSelector;
+exports.createRoot = createRoot;
+exports.createTestNameSelector = createTestNameSelector;
+exports.createTextSelector = createTextSelector;
+exports.experimental_useFormState = experimental_useFormState;
+exports.experimental_useFormStatus = experimental_useFormStatus;
+exports.findAllNodes = findAllNodes;
+exports.findBoundingRects = findBoundingRects;
+exports.findDOMNode = findDOMNode;
+exports.flushSync = flushSync;
+exports.focusWithin = focusWithin;
+exports.getFindAllNodesFailureDescription = getFindAllNodesFailureDescription;
+exports.hydrate = hydrate;
+exports.hydrateRoot = hydrateRoot;
+exports.observeVisibleRects = observeVisibleRects;
+exports.preconnect = preconnect;
+exports.prefetchDNS = prefetchDNS;
+exports.preinit = preinit;
+exports.preinitModule = preinitModule;
+exports.preload = preload;
+exports.preloadModule = preloadModule;
+exports.render = render;
+exports.unmountComponentAtNode = unmountComponentAtNode;
+exports.unstable_batchedUpdates = batchedUpdates$1;
+exports.unstable_renderSubtreeIntoContainer = renderSubtreeIntoContainer;
+exports.unstable_runWithPriority = runWithPriority;
+exports.useFormState = useFormState;
+exports.useFormStatus = useFormStatus;
+exports.version = ReactVersion;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-unstable_testing.production.min.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-unstable_testing.production.min.js
index 748febcccc0d1..bab9fd1a8386c 100644
--- a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-unstable_testing.production.min.js
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-unstable_testing.production.min.js
@@ -1,13 +1,11 @@
-/**
- * @license React
- * react-dom-unstable_testing.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
 /*
+ React
+ react-dom-unstable_testing.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
  Modernizr 3.0.0pre (Custom Build) | MIT
 */
 'use strict';var aa=require("next/dist/compiled/react-experimental"),ba=require("next/dist/compiled/scheduler-experimental"),ca={usingClientEntryPoint:!1,Events:null,Dispatcher:{current:null}};function t(a){for(var b="https://reactjs.org/docs/error-decoder.html?invariant="+a,c=1;c<arguments.length;c++)b+="&args[]="+encodeURIComponent(arguments[c]);return"Minified React error #"+a+"; visit "+b+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}
@@ -35,8 +33,9 @@ var Zb=!("undefined"===typeof window||"undefined"===typeof window.document||"und
 {},bc={};function cc(a){if(Ab.call(bc,a))return!0;if(Ab.call(ac,a))return!1;if($b.test(a))return bc[a]=!0;ac[a]=!0;return!1}function dc(a,b,c){if(cc(b))if(null===c)a.removeAttribute(b);else{switch(typeof c){case "undefined":case "function":case "symbol":a.removeAttribute(b);return;case "boolean":var d=b.toLowerCase().slice(0,5);if("data-"!==d&&"aria-"!==d){a.removeAttribute(b);return}}a.setAttribute(b,""+c)}}
 function ec(a,b,c){if(null===c)a.removeAttribute(b);else{switch(typeof c){case "undefined":case "function":case "symbol":case "boolean":a.removeAttribute(b);return}a.setAttribute(b,""+c)}}function fc(a,b,c,d){if(null===d)a.removeAttribute(c);else{switch(typeof d){case "undefined":case "function":case "symbol":case "boolean":a.removeAttribute(c);return}a.setAttributeNS(b,c,""+d)}}var gc;
 function hc(a){if(void 0===gc)try{throw Error();}catch(c){var b=c.stack.trim().match(/\n( *(at )?)/);gc=b&&b[1]||""}return"\n"+gc+a}var ic=!1;
-function jc(a,b){if(!a||ic)return"";ic=!0;var c=Error.prepareStackTrace;Error.prepareStackTrace=void 0;try{if(b)if(b=function(){throw Error();},Object.defineProperty(b.prototype,"props",{set:function(){throw Error();}}),"object"===typeof Reflect&&Reflect.construct){try{Reflect.construct(b,[])}catch(q){var d=q}Reflect.construct(a,[],b)}else{try{b.call()}catch(q){d=q}a.call(b.prototype)}else{try{throw Error();}catch(q){d=q}var e=a();e&&"function"===typeof e.catch&&e.catch(function(){})}}catch(q){if(q&&
-d&&"string"===typeof q.stack){for(var f=q.stack.split("\n"),g=d.stack.split("\n"),h=f.length-1,k=g.length-1;1<=h&&0<=k&&f[h]!==g[k];)k--;for(;1<=h&&0<=k;h--,k--)if(f[h]!==g[k]){if(1!==h||1!==k){do if(h--,k--,0>k||f[h]!==g[k]){var n="\n"+f[h].replace(" at new "," at ");a.displayName&&n.includes("<anonymous>")&&(n=n.replace("<anonymous>",a.displayName));return n}while(1<=h&&0<=k)}break}}}finally{ic=!1,Error.prepareStackTrace=c}return(a=a?a.displayName||a.name:"")?hc(a):""}
+function jc(a,b){if(!a||ic)return"";ic=!0;var c=Error.prepareStackTrace;Error.prepareStackTrace=void 0;var d={DetermineComponentFrameRoot:function(){try{if(b){var w=function(){throw Error();};Object.defineProperty(w.prototype,"props",{set:function(){throw Error();}});if("object"===typeof Reflect&&Reflect.construct){try{Reflect.construct(w,[])}catch(u){var r=u}Reflect.construct(a,[],w)}else{try{w.call()}catch(u){r=u}a.call(w.prototype)}}else{try{throw Error();}catch(u){r=u}(w=a())&&"function"===typeof w.catch&&
+w.catch(function(){})}}catch(u){if(u&&r&&"string"===typeof u.stack)return[u.stack,r.stack]}return[null,null]}};d.DetermineComponentFrameRoot.displayName="DetermineComponentFrameRoot";var e=Object.getOwnPropertyDescriptor(d.DetermineComponentFrameRoot,"name");e&&e.configurable&&Object.defineProperty(d.DetermineComponentFrameRoot,"name",{value:"DetermineComponentFrameRoot"});try{var f=d.DetermineComponentFrameRoot(),g=f[0],h=f[1];if(g&&h){var k=g.split("\n"),n=h.split("\n");for(e=d=0;d<k.length&&!k[d].includes("DetermineComponentFrameRoot");)d++;
+for(;e<n.length&&!n[e].includes("DetermineComponentFrameRoot");)e++;if(d===k.length||e===n.length)for(d=k.length-1,e=n.length-1;1<=d&&0<=e&&k[d]!==n[e];)e--;for(;1<=d&&0<=e;d--,e--)if(k[d]!==n[e]){if(1!==d||1!==e){do if(d--,e--,0>e||k[d]!==n[e]){var q="\n"+k[d].replace(" at new "," at ");a.displayName&&q.includes("<anonymous>")&&(q=q.replace("<anonymous>",a.displayName));return q}while(1<=d&&0<=e)}break}}}finally{ic=!1,Error.prepareStackTrace=c}return(c=a?a.displayName||a.name:"")?hc(c):""}
 function kc(a){switch(a.tag){case 26:case 27:case 5:return hc(a.type);case 16:return hc("Lazy");case 13:return hc("Suspense");case 19:return hc("SuspenseList");case 0:case 2:case 15:return a=jc(a.type,!1),a;case 11:return a=jc(a.type.render,!1),a;case 1:return a=jc(a.type,!0),a;default:return""}}
 function lc(a){if(null==a)return null;if("function"===typeof a)return a.displayName||a.name||null;if("string"===typeof a)return a;switch(a){case pa:return"Fragment";case oa:return"Portal";case ra:return"Profiler";case qa:return"StrictMode";case wa:return"Suspense";case xa:return"SuspenseList";case Da:return"Cache"}if("object"===typeof a)switch(a.$$typeof){case ta:return(a.displayName||"Context")+".Consumer";case sa:return(a._context.displayName||"Context")+".Provider";case va:var b=a.render;a=a.displayName;
 a||(a=b.displayName||b.name||"",a=""!==a?"ForwardRef("+a+")":"ForwardRef");return a;case ya:return b=a.displayName||null,null!==b?b:lc(a.type)||"Memo";case za:b=a._payload;a=a._init;try{return lc(a(b))}catch(c){break}case ua:return(a.displayName||a._globalName)+".Provider"}return null}
@@ -428,9 +427,9 @@ d);f?f.parentNode.insertBefore(e,f.nextSibling):(a=9===a.nodeType?a.head:a,a.ins
 bp.prototype.unmount=ap.prototype.unmount=function(){var a=this._internalRoot;if(null!==a){this._internalRoot=null;var b=a.containerInfo;Xk(function(){zl(null,a,null,null)});b[Eb]=null}};function bp(a){this._internalRoot=a}bp.prototype.unstable_scheduleHydration=function(a){if(a){var b=F;a={blockedOn:null,target:a,priority:b};for(var c=0;c<Dm.length&&0!==b&&b<Dm[c].priority;c++);Dm.splice(c,0,a);0===c&&Im(a)}};function cp(a){return!(!a||1!==a.nodeType&&9!==a.nodeType&&11!==a.nodeType)}
 function dp(a){return!(!a||1!==a.nodeType&&9!==a.nodeType&&11!==a.nodeType&&(8!==a.nodeType||" react-mount-point-unstable "!==a.nodeValue))}function ep(){}
 function fp(a,b,c,d,e){if(e){if("function"===typeof d){var f=d;d=function(){var n=Al(g);f.call(n)}}var g=yl(b,d,a,0,null,!1,!1,"",ep,null,null);a._reactRootContainer=g;a[Eb]=g.current;Li(8===a.nodeType?a.parentNode:a);Xk();return g}lj(a);if("function"===typeof d){var h=d;d=function(){var n=Al(k);h.call(n)}}var k=vl(a,0,!1,null,null,!1,!1,"",ep,null,null);a._reactRootContainer=k;a[Eb]=k.current;Li(8===a.nodeType?a.parentNode:a);Xk(function(){zl(b,k,c,d)});return k}
-function gp(a,b,c,d,e){var f=c._reactRootContainer;if(f){var g=f;if("function"===typeof e){var h=e;e=function(){var k=Al(g);h.call(k)}}zl(b,g,a,e)}else g=fp(c,b,a,e,d);return Al(g)}function hp(a,b){if("font"===a)return"";if("string"===typeof b)return"use-credentials"===b?b:""}var ip=ca.Dispatcher;ca.Events=[Ob,Pb,Qb,Nc,Oc,Wk];var jp={findFiberByHostInstance:Mb,bundleType:0,version:"18.3.0-experimental-2983249dd-20231107",rendererPackageName:"react-dom"};
+function gp(a,b,c,d,e){var f=c._reactRootContainer;if(f){var g=f;if("function"===typeof e){var h=e;e=function(){var k=Al(g);h.call(k)}}zl(b,g,a,e)}else g=fp(c,b,a,e,d);return Al(g)}function hp(a,b){if("font"===a)return"";if("string"===typeof b)return"use-credentials"===b?b:""}var ip=ca.Dispatcher;ca.Events=[Ob,Pb,Qb,Nc,Oc,Wk];var jp={findFiberByHostInstance:Mb,bundleType:0,version:"18.3.0-experimental-7508dcd5c-20231108",rendererPackageName:"react-dom"};
 var kp={bundleType:jp.bundleType,version:jp.version,rendererPackageName:jp.rendererPackageName,rendererConfig:jp.rendererConfig,overrideHookState:null,overrideHookStateDeletePath:null,overrideHookStateRenamePath:null,overrideProps:null,overridePropsDeletePath:null,overridePropsRenamePath:null,setErrorHandler:null,setSuspenseHandler:null,scheduleUpdate:null,currentDispatcherRef:da.ReactCurrentDispatcher,findHostInstanceByFiber:function(a){a=Tc(a);return null===a?null:a.stateNode},findFiberByHostInstance:jp.findFiberByHostInstance||
-Fl,findHostInstancesForRefresh:null,scheduleRefresh:null,scheduleRoot:null,setRefreshHandler:null,getCurrentFiber:null,reconcilerVersion:"18.3.0-experimental-2983249dd-20231107"};if("undefined"!==typeof __REACT_DEVTOOLS_GLOBAL_HOOK__){var lp=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(!lp.isDisabled&&lp.supportsFiber)try{eb=lp.inject(kp),fb=lp}catch(a){}}exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=ca;exports.createComponentSelector=function(a){return{$$typeof:nk,value:a}};
+Fl,findHostInstancesForRefresh:null,scheduleRefresh:null,scheduleRoot:null,setRefreshHandler:null,getCurrentFiber:null,reconcilerVersion:"18.3.0-experimental-7508dcd5c-20231108"};if("undefined"!==typeof __REACT_DEVTOOLS_GLOBAL_HOOK__){var lp=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(!lp.isDisabled&&lp.supportsFiber)try{eb=lp.inject(kp),fb=lp}catch(a){}}exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=ca;exports.createComponentSelector=function(a){return{$$typeof:nk,value:a}};
 exports.createHasPseudoClassSelector=function(a){return{$$typeof:ok,value:a}};exports.createPortal=function(a,b){var c=2<arguments.length&&void 0!==arguments[2]?arguments[2]:null;if(!cp(b))throw Error(t(200));return wl(a,b,null,c)};exports.createRoleSelector=function(a){return{$$typeof:pk,value:a}};
 exports.createRoot=function(a,b){if(!cp(a))throw Error(t(299));var c=!1,d="",e=$o,f=null;null!==b&&void 0!==b&&(!0===b.unstable_strictMode&&(c=!0),void 0!==b.identifierPrefix&&(d=b.identifierPrefix),void 0!==b.onRecoverableError&&(e=b.onRecoverableError),void 0!==b.unstable_transitionCallbacks&&(f=b.unstable_transitionCallbacks));b=vl(a,1,!1,null,null,c,!1,d,e,f,null);a[Eb]=b.current;Zo.current=Ko;Li(8===a.nodeType?a.parentNode:a);return new ap(b)};
 exports.createTestNameSelector=function(a){return{$$typeof:qk,value:a}};exports.createTextSelector=function(a){return{$$typeof:rk,value:a}};exports.experimental_useFormState=function(a,b,c){return ja(a,b,c)};exports.experimental_useFormStatus=function(){return ia()};exports.findAllNodes=yk;
@@ -446,4 +445,6 @@ exports.preinitModule=function(a,b){var c=ip.current;if(c&&"string"===typeof a)i
 exports.preload=function(a,b){var c=ip.current;if(c&&"string"===typeof a&&"object"===typeof b&&null!==b&&"string"===typeof b.as){var d=b.as,e=hp(d,b.crossOrigin);c.preload(a,d,{crossOrigin:e,integrity:"string"===typeof b.integrity?b.integrity:void 0,nonce:"string"===typeof b.nonce?b.nonce:void 0,type:"string"===typeof b.type?b.type:void 0,fetchPriority:"string"===typeof b.fetchPriority?b.fetchPriority:void 0,referrerPolicy:"string"===typeof b.referrerPolicy?b.referrerPolicy:void 0,imageSrcSet:"string"===
 typeof b.imageSrcSet?b.imageSrcSet:void 0,imageSizes:"string"===typeof b.imageSizes?b.imageSizes:void 0})}};exports.preloadModule=function(a,b){var c=ip.current;if(c&&"string"===typeof a)if(b){var d=hp(b.as,b.crossOrigin);c.preloadModule(a,{as:"string"===typeof b.as&&"script"!==b.as?b.as:void 0,crossOrigin:d,integrity:"string"===typeof b.integrity?b.integrity:void 0})}else c.preloadModule(a)};exports.render=function(a,b,c){if(!dp(b))throw Error(t(200));return gp(null,a,b,!1,c)};
 exports.unmountComponentAtNode=function(a){if(!dp(a))throw Error(t(40));return a._reactRootContainer?(Xk(function(){gp(null,null,a,!1,function(){a._reactRootContainer=null;a[Eb]=null})}),!0):!1};exports.unstable_batchedUpdates=Wk;exports.unstable_renderSubtreeIntoContainer=function(a,b,c,d){if(!dp(c))throw Error(t(200));if(null==a||void 0===a._reactInternals)throw Error(t(38));return gp(a,b,c,!1,d)};exports.unstable_runWithPriority=yb;exports.useFormState=ja;exports.useFormStatus=ia;
-exports.version="18.3.0-experimental-2983249dd-20231107";
+exports.version="18.3.0-experimental-7508dcd5c-20231108";
+
+//# sourceMappingURL=react-dom-unstable_testing.production.min.js.map
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.development.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.development.js
index 0b3a2a7314653..9d48fa1d9b21c 100644
--- a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.development.js
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.development.js
@@ -2688,6 +2688,18 @@ var componentFrameCache;
   var PossiblyWeakMap$1 = typeof WeakMap === 'function' ? WeakMap : Map;
   componentFrameCache = new PossiblyWeakMap$1();
 }
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
@@ -2703,7 +2715,6 @@ function describeNativeComponentFrame(fn, construct) {
     }
   }
 
-  var control;
   reentry = true;
   var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
 
@@ -2717,81 +2728,140 @@ function describeNativeComponentFrame(fn, construct) {
     ReactCurrentDispatcher$2.current = null;
     disableLogs();
   }
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
 
-  try {
-    // This should throw.
-    if (construct) {
-      // Something should be setting the props in the constructor.
-      var Fake = function () {
-        throw Error();
-      }; // $FlowFixMe[prop-missing]
 
+  var RunInRootFrame = {
+    DetermineComponentFrameRoot: function () {
+      var control;
 
-      Object.defineProperty(Fake.prototype, 'props', {
-        set: function () {
-          // We use a throwing setter instead of frozen or non-writable props
-          // because that won't throw in a non-strict mode function.
-          throw Error();
-        }
-      });
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          var Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
 
-      if (typeof Reflect === 'object' && Reflect.construct) {
-        // We construct a different control for this case to include any extra
-        // frames added by the construct call.
-        try {
-          Reflect.construct(Fake, []);
-        } catch (x) {
-          control = x;
-        }
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
 
-        Reflect.construct(fn, [], Fake);
-      } else {
-        try {
-          Fake.call();
-        } catch (x) {
-          control = x;
-        } // $FlowFixMe[prop-missing] found when upgrading Flow
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
 
 
-        fn.call(Fake.prototype);
-      }
-    } else {
-      try {
-        throw Error();
-      } catch (x) {
-        control = x;
-      } // TODO(luna): This will currently only throw if the function component
-      // tries to access React/ReactDOM/props. We should probably make this throw
-      // in simple components too
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
 
 
-      var maybePromise = fn(); // If the function component returns a promise, it's likely an async
-      // component, which we don't yet support. Attach a noop catch handler to
-      // silence the error.
-      // TODO: Implement component stacks for async client components?
+          var maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
 
-      if (maybePromise && typeof maybePromise.catch === 'function') {
-        maybePromise.catch(function () {});
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(function () {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
       }
+
+      return [null, null];
     }
-  } catch (sample) {
-    // This is inlined manually because closure doesn't do it for us.
-    if (sample && control && typeof sample.stack === 'string') {
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
+
+  try {
+    var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
+
+    if (sampleStack && controlStack) {
       // This extracts the first frame from the sample that isn't also in the control.
       // Skipping one frame that we assume is the frame that calls the two.
-      var sampleLines = sample.stack.split('\n');
-      var controlLines = control.stack.split('\n');
-      var s = sampleLines.length - 1;
-      var c = controlLines.length - 1;
+      var sampleLines = sampleStack.split('\n');
+      var controlLines = controlStack.split('\n');
+      var s = 0;
+      var c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
 
-      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
-        // We expect at least one stack frame to be shared.
-        // Typically this will be the root most one. However, stack frames may be
-        // cut off due to maximum stack limits. In this case, one maybe cut off
-        // earlier than the other. We assume that the sample is longer or the same
-        // and there for cut off earlier. So we should find the root most frame in
-        // the sample somewhere in the control.
-        c--;
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
       }
 
       for (; s >= 1 && c >= 0; s--, c--) {
@@ -2820,7 +2890,7 @@ function describeNativeComponentFrame(fn, construct) {
                   _frame = _frame.replace('<anonymous>', fn.displayName);
                 }
 
-                {
+                if (true) {
                   if (typeof fn === 'function') {
                     componentFrameCache.set(fn, _frame);
                   }
@@ -28277,7 +28347,7 @@ identifierPrefix, onRecoverableError, transitionCallbacks, formState) {
   return root;
 }
 
-var ReactVersion = '18.3.0-experimental-2983249dd-20231107';
+var ReactVersion = '18.3.0-experimental-7508dcd5c-20231108';
 
 function createPortal$1(children, containerInfo, // TODO: figure out the API for cross-renderer implementation.
 implementation) {
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.production.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.production.js
new file mode 100644
index 0000000000000..7eeb627e1eea1
--- /dev/null
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.production.js
@@ -0,0 +1,27812 @@
+/**
+ * @license React
+ * react-dom.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require("next/dist/compiled/react-experimental");
+var Scheduler = require("next/dist/compiled/scheduler-experimental");
+
+const Internals = {
+  usingClientEntryPoint: false,
+  Events: null,
+  Dispatcher: {
+    current: null
+  }
+};
+
+// Do not require this module directly! Use normal `invariant` calls with
+// template literal strings. The messages will be replaced with error codes
+// during build.
+function formatProdErrorMessage(code) {
+  let url = 'https://reactjs.org/docs/error-decoder.html?invariant=' + code;
+
+  for (let i = 1; i < arguments.length; i++) {
+    url += '&args[]=' + encodeURIComponent(arguments[i]);
+  }
+
+  return "Minified React error #" + code + "; visit " + url + " for the full message or " + 'use the non-minified dev environment for full errors and additional ' + 'helpful warnings.';
+}
+
+const assign = Object.assign;
+
+// -----------------------------------------------------------------------------
+// Killswitch
+//
+// Flags that exist solely to turn off a change in case it causes a regression
+// when it rolls out to prod. We should remove these as soon as possible.
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+// Land or remove (moderate effort)
+//
+// Flags that can be probably deleted or landed, but might require extra effort
+// like migrating internal callers or performance testing.
+// -----------------------------------------------------------------------------
+// TODO: Finish rolling out in www
+
+const enableClientRenderFallbackOnTextMismatch = true;
+const enableFormActions = true;
+const enableAsyncActions = true; // Not sure if www still uses this. We don't have a replacement but whatever we
+// Slated for removal in the future (significant effort)
+//
+// These are experiments that didn't work out, and never shipped, but we can't
+// delete from the codebase until we migrate internal callers.
+// -----------------------------------------------------------------------------
+// Add a callback property to suspense to notify which promises are currently
+// in the update queue. This allows reporting and tracing of what is causing
+// the user to see a loading state.
+//
+// Also allows hydration callbacks to fire when a dehydrated boundary gets
+// hydrated or deleted.
+//
+// This will eventually be replaced by the Transition Tracing proposal.
+
+const enableSuspenseCallback = false; // Experimental Scope support.
+
+const enableLazyContextPropagation = false; // FB-only usage. The new API has different semantics.
+
+const enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber
+const enableHostSingletons = true;
+const alwaysThrottleRetries = true;
+// Chopping Block
+//
+// Planned feature deprecations and breaking changes. Sorted roughly in order of
+// when we plan to enable them.
+// -----------------------------------------------------------------------------
+// This flag enables Strict Effects by default. We're not turning this on until
+// after 18 because it requires migration work. Recommendation is to use
+// <StrictMode /> to gradually upgrade components.
+// If TRUE, trees rendered with createRoot will be StrictEffectsMode.
+// If FALSE, these trees will be StrictLegacyMode.
+
+const createRootStrictEffectsByDefault = false;
+// React DOM Chopping Block
+//
+// Similar to main Chopping Block but only flags related to React DOM. These are
+// grouped because we will likely batch all of them into a single major release.
+// -----------------------------------------------------------------------------
+// Disable support for comment nodes as React DOM containers. Already disabled
+// in open source, but www codebase still relies on it. Need to remove.
+
+const disableCommentsAsDOMContainers = true; // Disable javascript: URL strings in href for XSS protection.
+// Debugging and DevTools
+// -----------------------------------------------------------------------------
+// Adds user timing marks for e.g. state updates, suspense, and work loop stuff,
+// for an experimental timeline tool.
+
+const enableSchedulingProfiler = false; // Helps identify side effects in render-phase lifecycle hooks and setState
+
+const enableProfilerTimer = false; // Record durations for commit and passive effects phases.
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactCurrentDispatcher$2 = ReactSharedInternals.ReactCurrentDispatcher; // Since the "not pending" value is always the same, we can reuse the
+// same object across all transitions.
+
+const sharedNotPendingObject = {
+  pending: false,
+  data: null,
+  method: null,
+  action: null
+};
+const NotPending = sharedNotPendingObject;
+
+function resolveDispatcher() {
+  // Copied from react/src/ReactHooks.js. It's the same thing but in a
+  // different package.
+  const dispatcher = ReactCurrentDispatcher$2.current;
+  // intentionally don't throw our own error because this is in a hot path.
+  // Also helps ensure this is inlined.
+
+
+  return dispatcher;
+}
+
+function useFormStatus() {
+  {
+    const dispatcher = resolveDispatcher(); // $FlowFixMe[not-a-function] We know this exists because of the feature check above.
+
+    return dispatcher.useHostTransitionStatus();
+  }
+}
+function useFormState(action, initialState, permalink) {
+  {
+    const dispatcher = resolveDispatcher(); // $FlowFixMe[not-a-function] This is unstable, thus optional
+
+    return dispatcher.useFormState(action, initialState, permalink);
+  }
+}
+
+const valueStack = [];
+
+let index = -1;
+
+function createCursor(defaultValue) {
+  return {
+    current: defaultValue
+  };
+}
+
+function pop(cursor, fiber) {
+  if (index < 0) {
+
+    return;
+  }
+
+  cursor.current = valueStack[index];
+  valueStack[index] = null;
+
+  index--;
+}
+
+function push(cursor, value, fiber) {
+  index++;
+  valueStack[index] = cursor.current;
+
+  cursor.current = value;
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+const REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_CONTEXT_TYPE = Symbol.for('react.context');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SCOPE_TYPE = Symbol.for('react.scope');
+const REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');
+const REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+const REACT_LEGACY_HIDDEN_TYPE = Symbol.for('react.legacy_hidden');
+const REACT_CACHE_TYPE = Symbol.for('react.cache');
+const REACT_TRACING_MARKER_TYPE = Symbol.for('react.tracing_marker');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+const contextStackCursor$1 = createCursor(null);
+const contextFiberStackCursor = createCursor(null);
+const rootInstanceStackCursor = createCursor(null); // Represents the nearest host transition provider (in React DOM, a <form />)
+// NOTE: Since forms cannot be nested, and this feature is only implemented by
+// React DOM, we don't technically need this to be a stack. It could be a single
+// module variable instead.
+
+const hostTransitionProviderCursor = createCursor(null); // TODO: This should initialize to NotPendingTransition, a constant
+// imported from the fiber config. However, because of a cycle in the module
+// graph, that value isn't defined during this module's initialization. I can't
+// think of a way to work around this without moving that value out of the
+// fiber config. For now, the "no provider" case is handled when reading,
+// inside useHostTransitionStatus.
+
+const HostTransitionContext = {
+  $$typeof: REACT_CONTEXT_TYPE,
+  _currentValue: null,
+  _currentValue2: null,
+  _threadCount: 0,
+  Provider: null,
+  Consumer: null,
+  _defaultValue: null,
+  _globalName: null
+};
+
+function requiredContext(c) {
+
+  return c;
+}
+
+function getCurrentRootHostContainer() {
+  return rootInstanceStackCursor.current;
+}
+
+function getRootHostContainer() {
+  const rootInstance = requiredContext(rootInstanceStackCursor.current);
+  return rootInstance;
+}
+
+function pushHostContainer(fiber, nextRootInstance) {
+  // Push current root instance onto the stack;
+  // This allows us to reset root when portals are popped.
+  push(rootInstanceStackCursor, nextRootInstance); // Track the context and the Fiber that provided it.
+  // This enables us to pop only Fibers that provide unique contexts.
+
+  push(contextFiberStackCursor, fiber); // Finally, we need to push the host context to the stack.
+  // However, we can't just call getRootHostContext() and push it because
+  // we'd have a different number of entries on the stack depending on
+  // whether getRootHostContext() throws somewhere in renderer code or not.
+  // So we push an empty value first. This lets us safely unwind on errors.
+
+  push(contextStackCursor$1, null);
+  const nextRootContext = getRootHostContext(nextRootInstance); // Now that we know this function doesn't throw, replace it.
+
+  pop(contextStackCursor$1);
+  push(contextStackCursor$1, nextRootContext);
+}
+
+function popHostContainer(fiber) {
+  pop(contextStackCursor$1);
+  pop(contextFiberStackCursor);
+  pop(rootInstanceStackCursor);
+}
+
+function getHostContext() {
+  const context = requiredContext(contextStackCursor$1.current);
+  return context;
+}
+
+function pushHostContext(fiber) {
+  {
+    const stateHook = fiber.memoizedState;
+
+    if (stateHook !== null) {
+      // Only provide context if this fiber has been upgraded by a host
+      // transition. We use the same optimization for regular host context below.
+      push(hostTransitionProviderCursor, fiber);
+    }
+  }
+
+  const context = requiredContext(contextStackCursor$1.current);
+  const nextContext = getChildHostContext(context, fiber.type); // Don't push this Fiber's context unless it's unique.
+
+  if (context !== nextContext) {
+    // Track the context and the Fiber that provided it.
+    // This enables us to pop only Fibers that provide unique contexts.
+    push(contextFiberStackCursor, fiber);
+    push(contextStackCursor$1, nextContext);
+  }
+}
+
+function popHostContext(fiber) {
+  if (contextFiberStackCursor.current === fiber) {
+    // Do not pop unless this Fiber provided the current context.
+    // pushHostContext() only pushes Fibers that provide unique contexts.
+    pop(contextStackCursor$1);
+    pop(contextFiberStackCursor);
+  }
+
+  {
+    if (hostTransitionProviderCursor.current === fiber) {
+      // Do not pop unless this Fiber provided the current context. This is mostly
+      // a performance optimization, but conveniently it also prevents a potential
+      // data race where a host provider is upgraded (i.e. memoizedState becomes
+      // non-null) during a concurrent event. This is a bit of a flaw in the way
+      // we upgrade host components, but because we're accounting for it here, it
+      // should be fine.
+      pop(hostTransitionProviderCursor); // When popping the transition provider, we reset the context value back
+      // to `null`. We can do this because you're not allowd to nest forms. If
+      // we allowed for multiple nested host transition providers, then we'd
+      // need to reset this to the parent provider's status.
+
+      {
+        HostTransitionContext._currentValue = null;
+      }
+    }
+  }
+}
+
+const NoFlags$1 =
+/*                      */
+0b0000000000000000000000000000;
+const PerformedWork =
+/*                */
+0b0000000000000000000000000001;
+const Placement =
+/*                    */
+0b0000000000000000000000000010;
+const DidCapture =
+/*                   */
+0b0000000000000000000010000000;
+const Hydrating =
+/*                    */
+0b0000000000000001000000000000; // You can change the rest (and add more).
+
+const Update =
+/*                       */
+0b0000000000000000000000000100;
+/* Skipped value:                                 0b0000000000000000000000001000; */
+
+const ChildDeletion =
+/*                */
+0b0000000000000000000000010000;
+const ContentReset =
+/*                 */
+0b0000000000000000000000100000;
+const Callback =
+/*                     */
+0b0000000000000000000001000000;
+/* Used by DidCapture:                            0b0000000000000000000010000000; */
+
+const ForceClientRender =
+/*            */
+0b0000000000000000000100000000;
+const Ref =
+/*                          */
+0b0000000000000000001000000000;
+const Snapshot =
+/*                     */
+0b0000000000000000010000000000;
+const Passive$1 =
+/*                      */
+0b0000000000000000100000000000;
+/* Used by Hydrating:                             0b0000000000000001000000000000; */
+
+const Visibility =
+/*                   */
+0b0000000000000010000000000000;
+const StoreConsistency =
+/*             */
+0b0000000000000100000000000000; // It's OK to reuse these bits because these flags are mutually exclusive for
+// different fiber types. We should really be doing this for as many flags as
+// possible, because we're about to run out of bits.
+
+const ScheduleRetry = StoreConsistency;
+const ShouldSuspendCommit = Visibility;
+const LifecycleEffectMask = Passive$1 | Update | Callback | Ref | Snapshot | StoreConsistency; // Union of all commit flags (flags with the lifetime of a particular commit)
+
+const HostEffectMask =
+/*               */
+0b0000000000000111111111111111; // These are not really side effects, but we still reuse this field.
+
+const Incomplete =
+/*                   */
+0b0000000000001000000000000000;
+const ShouldCapture =
+/*                */
+0b0000000000010000000000000000;
+const ForceUpdateForLegacySuspense =
+/* */
+0b0000000000100000000000000000;
+const Forked =
+/*                       */
+0b0000000100000000000000000000; // Static tags describe aspects of a fiber that are not specific to a render,
+// e.g. a fiber uses a passive effect (even if there are no updates on this particular render).
+// This enables us to defer more work in the unmount case,
+// since we can defer traversing the tree during layout to look for Passive effects,
+// and instead rely on the static flag as a signal that there may be cleanup work.
+
+const RefStatic =
+/*                    */
+0b0000001000000000000000000000;
+const LayoutStatic =
+/*                 */
+0b0000010000000000000000000000;
+const PassiveStatic =
+/*                */
+0b0000100000000000000000000000;
+const MaySuspendCommit =
+/*             */
+0b0001000000000000000000000000; // Flag used to identify newly inserted fibers. It isn't reset after commit unlike `Placement`.
+
+const PlacementDEV =
+/*                 */
+0b0010000000000000000000000000;
+// don't contain effects, by checking subtreeFlags.
+
+const BeforeMutationMask = // TODO: Remove Update flag from before mutation phase by re-landing Visibility
+// flag logic (see #20043)
+Update | Snapshot | (0);
+const MutationMask = Placement | Update | ChildDeletion | ContentReset | Ref | Hydrating | Visibility;
+const LayoutMask = Update | Callback | Ref | Visibility; // TODO: Split into PassiveMountMask and PassiveUnmountMask
+
+const PassiveMask = Passive$1 | Visibility | ChildDeletion; // Union of tags that don't get reset on clones.
+// This allows certain concepts to persist without recalculating them,
+// e.g. whether a subtree contains passive effects or portals.
+
+const StaticMask = LayoutStatic | PassiveStatic | RefStatic | MaySuspendCommit;
+
+// This module only exists as an ESM wrapper around the external CommonJS
+const scheduleCallback$3 = Scheduler.unstable_scheduleCallback;
+const cancelCallback$1 = Scheduler.unstable_cancelCallback;
+const shouldYield = Scheduler.unstable_shouldYield;
+const requestPaint = Scheduler.unstable_requestPaint;
+const now = Scheduler.unstable_now;
+const getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel;
+const ImmediatePriority = Scheduler.unstable_ImmediatePriority;
+const UserBlockingPriority = Scheduler.unstable_UserBlockingPriority;
+const NormalPriority$1 = Scheduler.unstable_NormalPriority;
+const LowPriority = Scheduler.unstable_LowPriority;
+const IdlePriority = Scheduler.unstable_IdlePriority; // this doesn't actually exist on the scheduler, but it *does*
+
+let rendererID = null;
+let injectedHook = null;
+function injectInternals(internals) {
+  if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {
+    // No DevTools
+    return false;
+  }
+
+  const hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+
+  if (hook.isDisabled) {
+    // This isn't a real property on the hook, but it can be set to opt out
+    // of DevTools integration and associated warnings and logs.
+    // https://github.com/facebook/react/issues/3877
+    return true;
+  }
+
+  if (!hook.supportsFiber) {
+
+
+    return true;
+  }
+
+  try {
+    if (enableSchedulingProfiler) ;
+
+    rendererID = hook.inject(internals); // We have successfully injected, so now it is safe to set up hooks.
+
+    injectedHook = hook;
+  } catch (err) {
+  }
+
+  if (hook.checkDCE) {
+    // This is the real DevTools.
+    return true;
+  } else {
+    // This is likely a hook installed by Fast Refresh runtime.
+    return false;
+  }
+}
+function onCommitRoot(root, eventPriority) {
+  if (injectedHook && typeof injectedHook.onCommitFiberRoot === 'function') {
+    try {
+      const didError = (root.current.flags & DidCapture) === DidCapture;
+
+      if (enableProfilerTimer) ; else {
+        injectedHook.onCommitFiberRoot(rendererID, root, undefined, didError);
+      }
+    } catch (err) {
+    }
+  }
+}
+function onPostCommitRoot(root) {
+  if (injectedHook && typeof injectedHook.onPostCommitFiberRoot === 'function') {
+    try {
+      injectedHook.onPostCommitFiberRoot(rendererID, root);
+    } catch (err) {
+    }
+  }
+}
+function onCommitUnmount(fiber) {
+  if (injectedHook && typeof injectedHook.onCommitFiberUnmount === 'function') {
+    try {
+      injectedHook.onCommitFiberUnmount(rendererID, fiber);
+    } catch (err) {
+    }
+  }
+}
+
+function injectProfilingHooks(profilingHooks) {
+}
+
+function getLaneLabelMap() {
+  {
+    return null;
+  }
+}
+
+const NoMode =
+/*                         */
+0b0000000; // TODO: Remove ConcurrentMode by reading from the root tag instead
+
+const ConcurrentMode =
+/*                 */
+0b0000001;
+const ProfileMode =
+/*                    */
+0b0000010;
+const StrictLegacyMode =
+/*               */
+0b0001000;
+const StrictEffectsMode =
+/*              */
+0b0010000;
+
+// TODO: This is pretty well supported by browsers. Maybe we can drop it.
+const 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
+
+const log = Math.log;
+const LN2 = Math.LN2;
+
+function clz32Fallback(x) {
+  const asUint = x >>> 0;
+
+  if (asUint === 0) {
+    return 32;
+  }
+
+  return 31 - (log(asUint) / LN2 | 0) | 0;
+}
+
+// TODO: Ideally these types would be opaque but that doesn't work well with
+// If those values are changed that package should be rebuilt and redeployed.
+
+const TotalLanes = 31;
+const NoLanes =
+/*                        */
+0b0000000000000000000000000000000;
+const NoLane =
+/*                          */
+0b0000000000000000000000000000000;
+const SyncHydrationLane =
+/*               */
+0b0000000000000000000000000000001;
+const SyncLane =
+/*                        */
+0b0000000000000000000000000000010;
+const SyncLaneIndex = 1;
+const InputContinuousHydrationLane =
+/*    */
+0b0000000000000000000000000000100;
+const InputContinuousLane =
+/*             */
+0b0000000000000000000000000001000;
+const DefaultHydrationLane =
+/*            */
+0b0000000000000000000000000010000;
+const DefaultLane =
+/*                     */
+0b0000000000000000000000000100000;
+const SyncUpdateLanes = SyncLane | InputContinuousLane | DefaultLane ;
+const TransitionHydrationLane =
+/*                */
+0b0000000000000000000000001000000;
+const TransitionLanes =
+/*                       */
+0b0000000001111111111111110000000;
+const TransitionLane1 =
+/*                        */
+0b0000000000000000000000010000000;
+const TransitionLane2 =
+/*                        */
+0b0000000000000000000000100000000;
+const TransitionLane3 =
+/*                        */
+0b0000000000000000000001000000000;
+const TransitionLane4 =
+/*                        */
+0b0000000000000000000010000000000;
+const TransitionLane5 =
+/*                        */
+0b0000000000000000000100000000000;
+const TransitionLane6 =
+/*                        */
+0b0000000000000000001000000000000;
+const TransitionLane7 =
+/*                        */
+0b0000000000000000010000000000000;
+const TransitionLane8 =
+/*                        */
+0b0000000000000000100000000000000;
+const TransitionLane9 =
+/*                        */
+0b0000000000000001000000000000000;
+const TransitionLane10 =
+/*                       */
+0b0000000000000010000000000000000;
+const TransitionLane11 =
+/*                       */
+0b0000000000000100000000000000000;
+const TransitionLane12 =
+/*                       */
+0b0000000000001000000000000000000;
+const TransitionLane13 =
+/*                       */
+0b0000000000010000000000000000000;
+const TransitionLane14 =
+/*                       */
+0b0000000000100000000000000000000;
+const TransitionLane15 =
+/*                       */
+0b0000000001000000000000000000000;
+const RetryLanes =
+/*                            */
+0b0000011110000000000000000000000;
+const RetryLane1 =
+/*                             */
+0b0000000010000000000000000000000;
+const RetryLane2 =
+/*                             */
+0b0000000100000000000000000000000;
+const RetryLane3 =
+/*                             */
+0b0000001000000000000000000000000;
+const RetryLane4 =
+/*                             */
+0b0000010000000000000000000000000;
+const SomeRetryLane = RetryLane1;
+const SelectiveHydrationLane =
+/*          */
+0b0000100000000000000000000000000;
+const NonIdleLanes =
+/*                          */
+0b0000111111111111111111111111111;
+const IdleHydrationLane =
+/*               */
+0b0001000000000000000000000000000;
+const IdleLane =
+/*                        */
+0b0010000000000000000000000000000;
+const OffscreenLane =
+/*                   */
+0b0100000000000000000000000000000;
+const DeferredLane =
+/*                    */
+0b1000000000000000000000000000000; // Any lane that might schedule an update. This is used to detect infinite
+// update loops, so it doesn't include hydration lanes or retries.
+
+const UpdateLanes = SyncLane | InputContinuousLane | DefaultLane | TransitionLanes; // This function is used for the experimental timeline (react-devtools-timeline)
+const NoTimestamp = -1;
+let nextTransitionLane = TransitionLane1;
+let nextRetryLane = RetryLane1;
+
+function getHighestPriorityLanes(lanes) {
+  {
+    const pendingSyncLanes = lanes & SyncUpdateLanes;
+
+    if (pendingSyncLanes !== 0) {
+      return pendingSyncLanes;
+    }
+  }
+
+  switch (getHighestPriorityLane(lanes)) {
+    case SyncHydrationLane:
+      return SyncHydrationLane;
+
+    case SyncLane:
+      return SyncLane;
+
+    case InputContinuousHydrationLane:
+      return InputContinuousHydrationLane;
+
+    case InputContinuousLane:
+      return InputContinuousLane;
+
+    case DefaultHydrationLane:
+      return DefaultHydrationLane;
+
+    case DefaultLane:
+      return DefaultLane;
+
+    case TransitionHydrationLane:
+      return TransitionHydrationLane;
+
+    case TransitionLane1:
+    case TransitionLane2:
+    case TransitionLane3:
+    case TransitionLane4:
+    case TransitionLane5:
+    case TransitionLane6:
+    case TransitionLane7:
+    case TransitionLane8:
+    case TransitionLane9:
+    case TransitionLane10:
+    case TransitionLane11:
+    case TransitionLane12:
+    case TransitionLane13:
+    case TransitionLane14:
+    case TransitionLane15:
+      return lanes & TransitionLanes;
+
+    case RetryLane1:
+    case RetryLane2:
+    case RetryLane3:
+    case RetryLane4:
+      return lanes & RetryLanes;
+
+    case SelectiveHydrationLane:
+      return SelectiveHydrationLane;
+
+    case IdleHydrationLane:
+      return IdleHydrationLane;
+
+    case IdleLane:
+      return IdleLane;
+
+    case OffscreenLane:
+      return OffscreenLane;
+
+    case DeferredLane:
+      // This shouldn't be reachable because deferred work is always entangled
+      // with something else.
+      return NoLanes;
+
+    default:
+
+
+      return lanes;
+  }
+}
+
+function getNextLanes(root, wipLanes) {
+  // Early bailout if there's no pending work left.
+  const pendingLanes = root.pendingLanes;
+
+  if (pendingLanes === NoLanes) {
+    return NoLanes;
+  }
+
+  let nextLanes = NoLanes;
+  const suspendedLanes = root.suspendedLanes;
+  const pingedLanes = root.pingedLanes; // Do not work on any idle work until all the non-idle work has finished,
+  // even if the work is suspended.
+
+  const nonIdlePendingLanes = pendingLanes & NonIdleLanes;
+
+  if (nonIdlePendingLanes !== NoLanes) {
+    const nonIdleUnblockedLanes = nonIdlePendingLanes & ~suspendedLanes;
+
+    if (nonIdleUnblockedLanes !== NoLanes) {
+      nextLanes = getHighestPriorityLanes(nonIdleUnblockedLanes);
+    } else {
+      const nonIdlePingedLanes = nonIdlePendingLanes & pingedLanes;
+
+      if (nonIdlePingedLanes !== NoLanes) {
+        nextLanes = getHighestPriorityLanes(nonIdlePingedLanes);
+      }
+    }
+  } else {
+    // The only remaining work is Idle.
+    const unblockedLanes = pendingLanes & ~suspendedLanes;
+
+    if (unblockedLanes !== NoLanes) {
+      nextLanes = getHighestPriorityLanes(unblockedLanes);
+    } else {
+      if (pingedLanes !== NoLanes) {
+        nextLanes = getHighestPriorityLanes(pingedLanes);
+      }
+    }
+  }
+
+  if (nextLanes === NoLanes) {
+    // This should only be reachable if we're suspended
+    // TODO: Consider warning in this path if a fallback timer is not scheduled.
+    return NoLanes;
+  } // If we're already in the middle of a render, switching lanes will interrupt
+  // it and we'll lose our progress. We should only do this if the new lanes are
+  // higher priority.
+
+
+  if (wipLanes !== NoLanes && wipLanes !== nextLanes && // If we already suspended with a delay, then interrupting is fine. Don't
+  // bother waiting until the root is complete.
+  (wipLanes & suspendedLanes) === NoLanes) {
+    const nextLane = getHighestPriorityLane(nextLanes);
+    const wipLane = getHighestPriorityLane(wipLanes);
+
+    if ( // Tests whether the next lane is equal or lower priority than the wip
+    // one. This works because the bits decrease in priority as you go left.
+    nextLane >= wipLane || // Default priority updates should not interrupt transition updates. The
+    // only difference between default updates and transition updates is that
+    // default updates do not support refresh transitions.
+    nextLane === DefaultLane && (wipLane & TransitionLanes) !== NoLanes) {
+      // Keep working on the existing in-progress tree. Do not interrupt.
+      return wipLanes;
+    }
+  }
+
+  return nextLanes;
+}
+function getEntangledLanes(root, renderLanes) {
+  let entangledLanes = renderLanes;
+
+  if ((entangledLanes & InputContinuousLane) !== NoLanes) {
+    // When updates are sync by default, we entangle continuous priority updates
+    // and default updates, so they render in the same batch. The only reason
+    // they use separate lanes is because continuous updates should interrupt
+    // transitions, but default updates should not.
+    entangledLanes |= entangledLanes & DefaultLane;
+  } // Check for entangled lanes and add them to the batch.
+  //
+  // A lane is said to be entangled with another when it's not allowed to render
+  // in a batch that does not also include the other lane. Typically we do this
+  // when multiple updates have the same source, and we only want to respond to
+  // the most recent event from that source.
+  //
+  // Note that we apply entanglements *after* checking for partial work above.
+  // This means that if a lane is entangled during an interleaved event while
+  // it's already rendering, we won't interrupt it. This is intentional, since
+  // entanglement is usually "best effort": we'll try our best to render the
+  // lanes in the same batch, but it's not worth throwing out partially
+  // completed work in order to do it.
+  // TODO: Reconsider this. The counter-argument is that the partial work
+  // represents an intermediate state, which we don't want to show to the user.
+  // And by spending extra time finishing it, we're increasing the amount of
+  // time it takes to show the final state, which is what they are actually
+  // waiting for.
+  //
+  // For those exceptions where entanglement is semantically important,
+  // we should ensure that there is no partial work at the
+  // time we apply the entanglement.
+
+
+  const allEntangledLanes = root.entangledLanes;
+
+  if (allEntangledLanes !== NoLanes) {
+    const entanglements = root.entanglements;
+    let lanes = entangledLanes & allEntangledLanes;
+
+    while (lanes > 0) {
+      const index = pickArbitraryLaneIndex(lanes);
+      const lane = 1 << index;
+      entangledLanes |= entanglements[index];
+      lanes &= ~lane;
+    }
+  }
+
+  return entangledLanes;
+}
+
+function computeExpirationTime(lane, currentTime) {
+  switch (lane) {
+    case SyncHydrationLane:
+    case SyncLane:
+    case InputContinuousHydrationLane:
+    case InputContinuousLane:
+      // User interactions should expire slightly more quickly.
+      //
+      // NOTE: This is set to the corresponding constant as in Scheduler.js.
+      // When we made it larger, a product metric in www regressed, suggesting
+      // there's a user interaction that's being starved by a series of
+      // synchronous updates. If that theory is correct, the proper solution is
+      // to fix the starvation. However, this scenario supports the idea that
+      // expiration times are an important safeguard when starvation
+      // does happen.
+      return currentTime + 250;
+
+    case DefaultHydrationLane:
+    case DefaultLane:
+    case TransitionHydrationLane:
+    case TransitionLane1:
+    case TransitionLane2:
+    case TransitionLane3:
+    case TransitionLane4:
+    case TransitionLane5:
+    case TransitionLane6:
+    case TransitionLane7:
+    case TransitionLane8:
+    case TransitionLane9:
+    case TransitionLane10:
+    case TransitionLane11:
+    case TransitionLane12:
+    case TransitionLane13:
+    case TransitionLane14:
+    case TransitionLane15:
+      return currentTime + 5000;
+
+    case RetryLane1:
+    case RetryLane2:
+    case RetryLane3:
+    case RetryLane4:
+      // TODO: Retries should be allowed to expire if they are CPU bound for
+      // too long, but when I made this change it caused a spike in browser
+      // crashes. There must be some other underlying bug; not super urgent but
+      // ideally should figure out why and fix it. Unfortunately we don't have
+      // a repro for the crashes, only detected via production metrics.
+      return NoTimestamp;
+
+    case SelectiveHydrationLane:
+    case IdleHydrationLane:
+    case IdleLane:
+    case OffscreenLane:
+    case DeferredLane:
+      // Anything idle priority or lower should never expire.
+      return NoTimestamp;
+
+    default:
+
+      return NoTimestamp;
+  }
+}
+
+function markStarvedLanesAsExpired(root, currentTime) {
+  // TODO: This gets called every time we yield. We can optimize by storing
+  // the earliest expiration time on the root. Then use that to quickly bail out
+  // of this function.
+  const pendingLanes = root.pendingLanes;
+  const suspendedLanes = root.suspendedLanes;
+  const pingedLanes = root.pingedLanes;
+  const expirationTimes = root.expirationTimes; // Iterate through the pending lanes and check if we've reached their
+  // expiration time. If so, we'll assume the update is being starved and mark
+  // it as expired to force it to finish.
+  // TODO: We should be able to replace this with upgradePendingLanesToSync
+  //
+  // We exclude retry lanes because those must always be time sliced, in order
+  // to unwrap uncached promises.
+  // TODO: Write a test for this
+
+  let lanes = pendingLanes & ~RetryLanes;
+
+  while (lanes > 0) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+    const expirationTime = expirationTimes[index];
+
+    if (expirationTime === NoTimestamp) {
+      // Found a pending lane with no expiration time. If it's not suspended, or
+      // if it's pinged, assume it's CPU-bound. Compute a new expiration time
+      // using the current time.
+      if ((lane & suspendedLanes) === NoLanes || (lane & pingedLanes) !== NoLanes) {
+        // Assumes timestamps are monotonically increasing.
+        expirationTimes[index] = computeExpirationTime(lane, currentTime);
+      }
+    } else if (expirationTime <= currentTime) {
+      // This lane expired
+      root.expiredLanes |= lane;
+    }
+
+    lanes &= ~lane;
+  }
+} // This returns the highest priority pending lanes regardless of whether they
+// are suspended.
+
+function getHighestPriorityPendingLanes(root) {
+  return getHighestPriorityLanes(root.pendingLanes);
+}
+function getLanesToRetrySynchronouslyOnError(root, originallyAttemptedLanes) {
+  if (root.errorRecoveryDisabledLanes & originallyAttemptedLanes) {
+    // The error recovery mechanism is disabled until these lanes are cleared.
+    return NoLanes;
+  }
+
+  const everythingButOffscreen = root.pendingLanes & ~OffscreenLane;
+
+  if (everythingButOffscreen !== NoLanes) {
+    return everythingButOffscreen;
+  }
+
+  if (everythingButOffscreen & OffscreenLane) {
+    return OffscreenLane;
+  }
+
+  return NoLanes;
+}
+function includesSyncLane(lanes) {
+  return (lanes & (SyncLane | SyncHydrationLane)) !== NoLanes;
+}
+function includesNonIdleWork(lanes) {
+  return (lanes & NonIdleLanes) !== NoLanes;
+}
+function includesOnlyRetries(lanes) {
+  return (lanes & RetryLanes) === lanes;
+}
+function includesOnlyNonUrgentLanes(lanes) {
+  // TODO: Should hydration lanes be included here? This function is only
+  // used in `updateDeferredValueImpl`.
+  const UrgentLanes = SyncLane | InputContinuousLane | DefaultLane;
+  return (lanes & UrgentLanes) === NoLanes;
+}
+function includesOnlyTransitions(lanes) {
+  return (lanes & TransitionLanes) === lanes;
+}
+function includesBlockingLane(root, lanes) {
+
+  const SyncDefaultLanes = InputContinuousHydrationLane | InputContinuousLane | DefaultHydrationLane | DefaultLane;
+  return (lanes & SyncDefaultLanes) !== NoLanes;
+}
+function includesExpiredLane(root, lanes) {
+  // This is a separate check from includesBlockingLane because a lane can
+  // expire after a render has already started.
+  return (lanes & root.expiredLanes) !== NoLanes;
+}
+function isTransitionLane(lane) {
+  return (lane & TransitionLanes) !== NoLanes;
+}
+function claimNextTransitionLane() {
+  // Cycle through the lanes, assigning each new transition to the next lane.
+  // In most cases, this means every transition gets its own lane, until we
+  // run out of lanes and cycle back to the beginning.
+  const lane = nextTransitionLane;
+  nextTransitionLane <<= 1;
+
+  if ((nextTransitionLane & TransitionLanes) === NoLanes) {
+    nextTransitionLane = TransitionLane1;
+  }
+
+  return lane;
+}
+function claimNextRetryLane() {
+  const lane = nextRetryLane;
+  nextRetryLane <<= 1;
+
+  if ((nextRetryLane & RetryLanes) === NoLanes) {
+    nextRetryLane = RetryLane1;
+  }
+
+  return lane;
+}
+function getHighestPriorityLane(lanes) {
+  return lanes & -lanes;
+}
+function pickArbitraryLane(lanes) {
+  // This wrapper function gets inlined. Only exists so to communicate that it
+  // doesn't matter which bit is selected; you can pick any bit without
+  // affecting the algorithms where its used. Here I'm using
+  // getHighestPriorityLane because it requires the fewest operations.
+  return getHighestPriorityLane(lanes);
+}
+
+function pickArbitraryLaneIndex(lanes) {
+  return 31 - clz32(lanes);
+}
+
+function laneToIndex(lane) {
+  return pickArbitraryLaneIndex(lane);
+}
+
+function includesSomeLane(a, b) {
+  return (a & b) !== NoLanes;
+}
+function isSubsetOfLanes(set, subset) {
+  return (set & subset) === subset;
+}
+function mergeLanes(a, b) {
+  return a | b;
+}
+function removeLanes(set, subset) {
+  return set & ~subset;
+}
+function intersectLanes(a, b) {
+  return a & b;
+} // Seems redundant, but it changes the type from a single lane (used for
+// updates) to a group of lanes (used for flushing work).
+
+function laneToLanes(lane) {
+  return lane;
+}
+function higherPriorityLane(a, b) {
+  // This works because the bit ranges decrease in priority as you go left.
+  return a !== NoLane && a < b ? a : b;
+}
+function createLaneMap(initial) {
+  // Intentionally pushing one by one.
+  // https://v8.dev/blog/elements-kinds#avoid-creating-holes
+  const laneMap = [];
+
+  for (let i = 0; i < TotalLanes; i++) {
+    laneMap.push(initial);
+  }
+
+  return laneMap;
+}
+function markRootUpdated(root, updateLane) {
+  root.pendingLanes |= updateLane; // If there are any suspended transitions, it's possible this new update
+  // could unblock them. Clear the suspended lanes so that we can try rendering
+  // them again.
+  //
+  // TODO: We really only need to unsuspend only lanes that are in the
+  // `subtreeLanes` of the updated fiber, or the update lanes of the return
+  // path. This would exclude suspended updates in an unrelated sibling tree,
+  // since there's no way for this update to unblock it.
+  //
+  // We don't do this if the incoming update is idle, because we never process
+  // idle updates until after all the regular updates have finished; there's no
+  // way it could unblock a transition.
+
+  if (updateLane !== IdleLane) {
+    root.suspendedLanes = NoLanes;
+    root.pingedLanes = NoLanes;
+  }
+}
+function markRootSuspended$1(root, suspendedLanes, spawnedLane) {
+  root.suspendedLanes |= suspendedLanes;
+  root.pingedLanes &= ~suspendedLanes; // The suspended lanes are no longer CPU-bound. Clear their expiration times.
+
+  const expirationTimes = root.expirationTimes;
+  let lanes = suspendedLanes;
+
+  while (lanes > 0) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+    expirationTimes[index] = NoTimestamp;
+    lanes &= ~lane;
+  }
+
+  if (spawnedLane !== NoLane) {
+    markSpawnedDeferredLane(root, spawnedLane, suspendedLanes);
+  }
+}
+function markRootPinged(root, pingedLanes) {
+  root.pingedLanes |= root.suspendedLanes & pingedLanes;
+}
+function markRootFinished(root, remainingLanes, spawnedLane) {
+  const noLongerPendingLanes = root.pendingLanes & ~remainingLanes;
+  root.pendingLanes = remainingLanes; // Let's try everything again
+
+  root.suspendedLanes = NoLanes;
+  root.pingedLanes = NoLanes;
+  root.expiredLanes &= remainingLanes;
+  root.entangledLanes &= remainingLanes;
+  root.errorRecoveryDisabledLanes &= remainingLanes;
+  root.shellSuspendCounter = 0;
+  const entanglements = root.entanglements;
+  const expirationTimes = root.expirationTimes;
+  const hiddenUpdates = root.hiddenUpdates; // Clear the lanes that no longer have pending work
+
+  let lanes = noLongerPendingLanes;
+
+  while (lanes > 0) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+    entanglements[index] = NoLanes;
+    expirationTimes[index] = NoTimestamp;
+    const hiddenUpdatesForLane = hiddenUpdates[index];
+
+    if (hiddenUpdatesForLane !== null) {
+      hiddenUpdates[index] = null; // "Hidden" updates are updates that were made to a hidden component. They
+      // have special logic associated with them because they may be entangled
+      // with updates that occur outside that tree. But once the outer tree
+      // commits, they behave like regular updates.
+
+      for (let i = 0; i < hiddenUpdatesForLane.length; i++) {
+        const update = hiddenUpdatesForLane[i];
+
+        if (update !== null) {
+          update.lane &= ~OffscreenLane;
+        }
+      }
+    }
+
+    lanes &= ~lane;
+  }
+
+  if (spawnedLane !== NoLane) {
+    markSpawnedDeferredLane(root, spawnedLane, // This render finished successfully without suspending, so we don't need
+    // to entangle the spawned task with the parent task.
+    NoLanes);
+  }
+}
+
+function markSpawnedDeferredLane(root, spawnedLane, entangledLanes) {
+  // This render spawned a deferred task. Mark it as pending.
+  root.pendingLanes |= spawnedLane;
+  root.suspendedLanes &= ~spawnedLane; // Entangle the spawned lane with the DeferredLane bit so that we know it
+  // was the result of another render. This lets us avoid a useDeferredValue
+  // waterfall — only the first level will defer.
+
+  const spawnedLaneIndex = laneToIndex(spawnedLane);
+  root.entangledLanes |= spawnedLane;
+  root.entanglements[spawnedLaneIndex] |= DeferredLane | // If the parent render task suspended, we must also entangle those lanes
+  // with the spawned task, so that the deferred task includes all the same
+  // updates that the parent task did. We can exclude any lane that is not
+  // used for updates (e.g. Offscreen).
+  entangledLanes & UpdateLanes;
+}
+
+function markRootEntangled(root, entangledLanes) {
+  // In addition to entangling each of the given lanes with each other, we also
+  // have to consider _transitive_ entanglements. For each lane that is already
+  // entangled with *any* of the given lanes, that lane is now transitively
+  // entangled with *all* the given lanes.
+  //
+  // Translated: If C is entangled with A, then entangling A with B also
+  // entangles C with B.
+  //
+  // If this is hard to grasp, it might help to intentionally break this
+  // function and look at the tests that fail in ReactTransition-test.js. Try
+  // commenting out one of the conditions below.
+  const rootEntangledLanes = root.entangledLanes |= entangledLanes;
+  const entanglements = root.entanglements;
+  let lanes = rootEntangledLanes;
+
+  while (lanes) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+
+    if ( // Is this one of the newly entangled lanes?
+    lane & entangledLanes | // Is this lane transitively entangled with the newly entangled lanes?
+    entanglements[index] & entangledLanes) {
+      entanglements[index] |= entangledLanes;
+    }
+
+    lanes &= ~lane;
+  }
+}
+function upgradePendingLaneToSync(root, lane) {
+  // Since we're upgrading the priority of the given lane, there is now pending
+  // sync work.
+  root.pendingLanes |= SyncLane; // Entangle the sync lane with the lane we're upgrading. This means SyncLane
+  // will not be allowed to finish without also finishing the given lane.
+
+  root.entangledLanes |= SyncLane;
+  root.entanglements[SyncLaneIndex] |= lane;
+}
+function upgradePendingLanesToSync(root, lanesToUpgrade) {
+  // Same as upgradePendingLaneToSync but accepts multiple lanes, so it's a
+  // bit slower.
+  root.pendingLanes |= SyncLane;
+  root.entangledLanes |= SyncLane;
+  let lanes = lanesToUpgrade;
+
+  while (lanes) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+    root.entanglements[SyncLaneIndex] |= lane;
+    lanes &= ~lane;
+  }
+}
+function markHiddenUpdate(root, update, lane) {
+  const index = laneToIndex(lane);
+  const hiddenUpdates = root.hiddenUpdates;
+  const hiddenUpdatesForLane = hiddenUpdates[index];
+
+  if (hiddenUpdatesForLane === null) {
+    hiddenUpdates[index] = [update];
+  } else {
+    hiddenUpdatesForLane.push(update);
+  }
+
+  update.lane = lane | OffscreenLane;
+}
+function getBumpedLaneForHydration(root, renderLanes) {
+  const renderLane = getHighestPriorityLane(renderLanes);
+  let lane;
+
+  if ((renderLane & SyncUpdateLanes) !== NoLane) {
+    lane = SyncHydrationLane;
+  } else {
+    switch (renderLane) {
+      case SyncLane:
+        lane = SyncHydrationLane;
+        break;
+
+      case InputContinuousLane:
+        lane = InputContinuousHydrationLane;
+        break;
+
+      case DefaultLane:
+        lane = DefaultHydrationLane;
+        break;
+
+      case TransitionLane1:
+      case TransitionLane2:
+      case TransitionLane3:
+      case TransitionLane4:
+      case TransitionLane5:
+      case TransitionLane6:
+      case TransitionLane7:
+      case TransitionLane8:
+      case TransitionLane9:
+      case TransitionLane10:
+      case TransitionLane11:
+      case TransitionLane12:
+      case TransitionLane13:
+      case TransitionLane14:
+      case TransitionLane15:
+      case RetryLane1:
+      case RetryLane2:
+      case RetryLane3:
+      case RetryLane4:
+        lane = TransitionHydrationLane;
+        break;
+
+      case IdleLane:
+        lane = IdleHydrationLane;
+        break;
+
+      default:
+        // Everything else is already either a hydration lane, or shouldn't
+        // be retried at a hydration lane.
+        lane = NoLane;
+        break;
+    }
+  } // Check if the lane we chose is suspended. If so, that indicates that we
+  // already attempted and failed to hydrate at that level. Also check if we're
+  // already rendering that lane, which is rare but could happen.
+
+
+  if ((lane & (root.suspendedLanes | renderLanes)) !== NoLane) {
+    // Give up trying to hydrate and fall back to client render.
+    return NoLane;
+  }
+
+  return lane;
+}
+function getTransitionsForLanes(root, lanes) {
+  {
+    return null;
+  }
+}
+
+const DiscreteEventPriority = SyncLane;
+const ContinuousEventPriority = InputContinuousLane;
+const DefaultEventPriority = DefaultLane;
+const IdleEventPriority = IdleLane;
+let currentUpdatePriority = NoLane;
+function getCurrentUpdatePriority() {
+  return currentUpdatePriority;
+}
+function setCurrentUpdatePriority(newPriority) {
+  currentUpdatePriority = newPriority;
+}
+function runWithPriority(priority, fn) {
+  const previousPriority = currentUpdatePriority;
+
+  try {
+    currentUpdatePriority = priority;
+    return fn();
+  } finally {
+    currentUpdatePriority = previousPriority;
+  }
+}
+function higherEventPriority(a, b) {
+  return a !== 0 && a < b ? a : b;
+}
+function lowerEventPriority(a, b) {
+  return a === 0 || a > b ? a : b;
+}
+function isHigherEventPriority(a, b) {
+  return a !== 0 && a < b;
+}
+function lanesToEventPriority(lanes) {
+  const lane = getHighestPriorityLane(lanes);
+
+  if (!isHigherEventPriority(DiscreteEventPriority, lane)) {
+    return DiscreteEventPriority;
+  }
+
+  if (!isHigherEventPriority(ContinuousEventPriority, lane)) {
+    return ContinuousEventPriority;
+  }
+
+  if (includesNonIdleWork(lane)) {
+    return DefaultEventPriority;
+  }
+
+  return IdleEventPriority;
+}
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+const FunctionComponent = 0;
+const ClassComponent = 1;
+const IndeterminateComponent = 2; // Before we know whether it is function or class
+
+const HostRoot = 3; // Root of a host tree. Could be nested inside another node.
+
+const HostPortal = 4; // A subtree. Could be an entry point to a different renderer.
+
+const HostComponent = 5;
+const HostText = 6;
+const Fragment = 7;
+const Mode = 8;
+const ContextConsumer = 9;
+const ContextProvider = 10;
+const ForwardRef = 11;
+const Profiler = 12;
+const SuspenseComponent = 13;
+const MemoComponent = 14;
+const SimpleMemoComponent = 15;
+const LazyComponent = 16;
+const IncompleteClassComponent = 17;
+const DehydratedFragment = 18;
+const SuspenseListComponent = 19;
+const ScopeComponent = 21;
+const OffscreenComponent = 22;
+const LegacyHiddenComponent = 23;
+const CacheComponent = 24;
+const TracingMarkerComponent = 25;
+const HostHoistable = 26;
+const HostSingleton = 27;
+
+const randomKey = Math.random().toString(36).slice(2);
+const internalInstanceKey = '__reactFiber$' + randomKey;
+const internalPropsKey = '__reactProps$' + randomKey;
+const internalContainerInstanceKey = '__reactContainer$' + randomKey;
+const internalEventHandlersKey = '__reactEvents$' + randomKey;
+const internalEventHandlerListenersKey = '__reactListeners$' + randomKey;
+const internalEventHandlesSetKey = '__reactHandles$' + randomKey;
+const internalRootNodeResourcesKey = '__reactResources$' + randomKey;
+const internalHoistableMarker = '__reactMarker$' + randomKey;
+function detachDeletedInstance(node) {
+  // TODO: This function is only called on host components. I don't think all of
+  // these fields are relevant.
+  delete node[internalInstanceKey];
+  delete node[internalPropsKey];
+  delete node[internalEventHandlersKey];
+  delete node[internalEventHandlerListenersKey];
+  delete node[internalEventHandlesSetKey];
+}
+function precacheFiberNode(hostInst, node) {
+  node[internalInstanceKey] = hostInst;
+}
+function markContainerAsRoot(hostRoot, node) {
+  // $FlowFixMe[prop-missing]
+  node[internalContainerInstanceKey] = hostRoot;
+}
+function unmarkContainerAsRoot(node) {
+  // $FlowFixMe[prop-missing]
+  node[internalContainerInstanceKey] = null;
+}
+function isContainerMarkedAsRoot(node) {
+  // $FlowFixMe[prop-missing]
+  return !!node[internalContainerInstanceKey];
+} // Given a DOM node, return the closest HostComponent or HostText fiber ancestor.
+// If the target node is part of a hydrated or not yet rendered subtree, then
+// this may also return a SuspenseComponent or HostRoot to indicate that.
+// Conceptually the HostRoot fiber is a child of the Container node. So if you
+// pass the Container node as the targetNode, you will not actually get the
+// HostRoot back. To get to the HostRoot, you need to pass a child of it.
+// The same thing applies to Suspense boundaries.
+
+function getClosestInstanceFromNode(targetNode) {
+  let targetInst = targetNode[internalInstanceKey];
+
+  if (targetInst) {
+    // Don't return HostRoot or SuspenseComponent here.
+    return targetInst;
+  } // If the direct event target isn't a React owned DOM node, we need to look
+  // to see if one of its parents is a React owned DOM node.
+
+
+  let parentNode = targetNode.parentNode;
+
+  while (parentNode) {
+    // We'll check if this is a container root that could include
+    // React nodes in the future. We need to check this first because
+    // if we're a child of a dehydrated container, we need to first
+    // find that inner container before moving on to finding the parent
+    // instance. Note that we don't check this field on  the targetNode
+    // itself because the fibers are conceptually between the container
+    // node and the first child. It isn't surrounding the container node.
+    // If it's not a container, we check if it's an instance.
+    targetInst = parentNode[internalContainerInstanceKey] || parentNode[internalInstanceKey];
+
+    if (targetInst) {
+      // Since this wasn't the direct target of the event, we might have
+      // stepped past dehydrated DOM nodes to get here. However they could
+      // also have been non-React nodes. We need to answer which one.
+      // If we the instance doesn't have any children, then there can't be
+      // a nested suspense boundary within it. So we can use this as a fast
+      // bailout. Most of the time, when people add non-React children to
+      // the tree, it is using a ref to a child-less DOM node.
+      // Normally we'd only need to check one of the fibers because if it
+      // has ever gone from having children to deleting them or vice versa
+      // it would have deleted the dehydrated boundary nested inside already.
+      // However, since the HostRoot starts out with an alternate it might
+      // have one on the alternate so we need to check in case this was a
+      // root.
+      const alternate = targetInst.alternate;
+
+      if (targetInst.child !== null || alternate !== null && alternate.child !== null) {
+        // Next we need to figure out if the node that skipped past is
+        // nested within a dehydrated boundary and if so, which one.
+        let suspenseInstance = getParentSuspenseInstance(targetNode);
+
+        while (suspenseInstance !== null) {
+          // We found a suspense instance. That means that we haven't
+          // hydrated it yet. Even though we leave the comments in the
+          // DOM after hydrating, and there are boundaries in the DOM
+          // that could already be hydrated, we wouldn't have found them
+          // through this pass since if the target is hydrated it would
+          // have had an internalInstanceKey on it.
+          // Let's get the fiber associated with the SuspenseComponent
+          // as the deepest instance.
+          // $FlowFixMe[prop-missing]
+          const targetSuspenseInst = suspenseInstance[internalInstanceKey];
+
+          if (targetSuspenseInst) {
+            return targetSuspenseInst;
+          } // If we don't find a Fiber on the comment, it might be because
+          // we haven't gotten to hydrate it yet. There might still be a
+          // parent boundary that hasn't above this one so we need to find
+          // the outer most that is known.
+
+
+          suspenseInstance = getParentSuspenseInstance(suspenseInstance); // If we don't find one, then that should mean that the parent
+          // host component also hasn't hydrated yet. We can return it
+          // below since it will bail out on the isMounted check later.
+        }
+      }
+
+      return targetInst;
+    }
+
+    targetNode = parentNode;
+    parentNode = targetNode.parentNode;
+  }
+
+  return null;
+}
+/**
+ * Given a DOM node, return the ReactDOMComponent or ReactDOMTextComponent
+ * instance, or null if the node was not rendered by this React.
+ */
+
+function getInstanceFromNode(node) {
+  const inst = node[internalInstanceKey] || node[internalContainerInstanceKey];
+
+  if (inst) {
+    const tag = inst.tag;
+
+    if (tag === HostComponent || tag === HostText || tag === SuspenseComponent || (tag === HostHoistable ) || (tag === HostSingleton ) || tag === HostRoot) {
+      return inst;
+    } else {
+      return null;
+    }
+  }
+
+  return null;
+}
+/**
+ * Given a ReactDOMComponent or ReactDOMTextComponent, return the corresponding
+ * DOM node.
+ */
+
+function getNodeFromInstance(inst) {
+  const tag = inst.tag;
+
+  if (tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton ) || tag === HostText) {
+    // In Fiber this, is just the state node right now. We assume it will be
+    // a host component or host text.
+    return inst.stateNode;
+  } // Without this first invariant, passing a non-DOM-component triggers the next
+  // invariant for a missing parent, which is super confusing.
+
+
+  throw Error(formatProdErrorMessage(33));
+}
+function getFiberCurrentPropsFromNode(node) {
+  return node[internalPropsKey] || null;
+}
+function updateFiberProps(node, props) {
+  node[internalPropsKey] = props;
+}
+function getEventListenerSet(node) {
+  let elementListenerSet = node[internalEventHandlersKey];
+
+  if (elementListenerSet === undefined) {
+    elementListenerSet = node[internalEventHandlersKey] = new Set();
+  }
+
+  return elementListenerSet;
+}
+function getResourcesFromRoot(root) {
+  let resources = root[internalRootNodeResourcesKey];
+
+  if (!resources) {
+    resources = root[internalRootNodeResourcesKey] = {
+      hoistableStyles: new Map(),
+      hoistableScripts: new Map()
+    };
+  }
+
+  return resources;
+}
+function isMarkedHoistable(node) {
+  return !!node[internalHoistableMarker];
+}
+function markNodeAsHoistable(node) {
+  node[internalHoistableMarker] = true;
+}
+function isOwnedInstance(node) {
+  return !!(node[internalHoistableMarker] || node[internalInstanceKey]);
+}
+
+const allNativeEvents = new Set();
+/**
+ * Mapping from registration name to event name
+ */
+
+
+const registrationNameDependencies = {};
+
+function registerTwoPhaseEvent(registrationName, dependencies) {
+  registerDirectEvent(registrationName, dependencies);
+  registerDirectEvent(registrationName + 'Capture', dependencies);
+}
+function registerDirectEvent(registrationName, dependencies) {
+
+  registrationNameDependencies[registrationName] = dependencies;
+
+  for (let i = 0; i < dependencies.length; i++) {
+    allNativeEvents.add(dependencies[i]);
+  }
+}
+
+const canUseDOM = !!(typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined');
+
+/* eslint-disable max-len */
+
+const ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
+/* eslint-enable max-len */
+
+const ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
+const VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+const illegalAttributeNameCache = {};
+const validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+  if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+    return true;
+  }
+
+  if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+    return false;
+  }
+
+  if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+    validatedAttributeNameCache[attributeName] = true;
+    return true;
+  }
+
+  illegalAttributeNameCache[attributeName] = true;
+
+  return false;
+}
+
+function setValueForAttribute(node, name, value) {
+  if (isAttributeNameSafe(name)) {
+    // If the prop isn't in the special list, treat it as a simple attribute.
+    // shouldRemoveAttribute
+    if (value === null) {
+      node.removeAttribute(name);
+      return;
+    }
+
+    switch (typeof value) {
+      case 'undefined':
+      case 'function':
+      case 'symbol':
+        // eslint-disable-line
+        node.removeAttribute(name);
+        return;
+
+      case 'boolean':
+        {
+          const prefix = name.toLowerCase().slice(0, 5);
+
+          if (prefix !== 'data-' && prefix !== 'aria-') {
+            node.removeAttribute(name);
+            return;
+          }
+        }
+    }
+
+    node.setAttribute(name, '' + value);
+  }
+}
+function setValueForKnownAttribute(node, name, value) {
+  if (value === null) {
+    node.removeAttribute(name);
+    return;
+  }
+
+  switch (typeof value) {
+    case 'undefined':
+    case 'function':
+    case 'symbol':
+    case 'boolean':
+      {
+        node.removeAttribute(name);
+        return;
+      }
+  }
+
+  node.setAttribute(name, '' + value);
+}
+function setValueForNamespacedAttribute(node, namespace, name, value) {
+  if (value === null) {
+    node.removeAttribute(name);
+    return;
+  }
+
+  switch (typeof value) {
+    case 'undefined':
+    case 'function':
+    case 'symbol':
+    case 'boolean':
+      {
+        node.removeAttribute(name);
+        return;
+      }
+  }
+
+  node.setAttributeNS(namespace, name, '' + value);
+}
+function setValueForPropertyOnCustomComponent(node, name, value) {
+  if (name[0] === 'o' && name[1] === 'n') {
+    const useCapture = name.endsWith('Capture');
+    const eventName = name.slice(2, useCapture ? name.length - 7 : undefined);
+    const prevProps = getFiberCurrentPropsFromNode(node);
+    const 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[incompatible-cast] value can't be casted to EventListener.
+
+
+      node.addEventListener(eventName, value, useCapture);
+      return;
+    }
+  }
+
+  if (name in node) {
+    node[name] = value;
+    return;
+  }
+
+  if (value === true) {
+    node.setAttribute(name, '');
+    return;
+  } // From here, it's the same as any attribute
+
+
+  setValueForAttribute(node, name, value);
+}
+
+let prefix;
+function describeBuiltInComponentFrame(name, source, ownerFn) {
+  {
+    if (prefix === undefined) {
+      // Extract the VM specific prefix used by each line.
+      try {
+        throw Error();
+      } catch (x) {
+        const match = x.stack.trim().match(/\n( *(at )?)/);
+        prefix = match && match[1] || '';
+      }
+    } // We use the prefix to ensure our stacks line up with native stack frames.
+
+
+    return '\n' + prefix + name;
+  }
+}
+let reentry = false;
+let componentFrameCache;
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
+
+function describeNativeComponentFrame(fn, construct) {
+  // If something asked for a stack inside a fake render, it should get ignored.
+  if (!fn || reentry) {
+    return '';
+  }
+
+  reentry = true;
+  const previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
+
+  Error.prepareStackTrace = undefined;
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
+
+
+  const RunInRootFrame = {
+    DetermineComponentFrameRoot() {
+      let control;
+
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          const Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
+
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
+
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
+
+
+          const maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
+
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(() => {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
+      }
+
+      return [null, null];
+    }
+
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  const namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
+
+  try {
+    const _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+          sampleStack = _RunInRootFrame$Deter[0],
+          controlStack = _RunInRootFrame$Deter[1];
+
+    if (sampleStack && controlStack) {
+      // This extracts the first frame from the sample that isn't also in the control.
+      // Skipping one frame that we assume is the frame that calls the two.
+      const sampleLines = sampleStack.split('\n');
+      const controlLines = controlStack.split('\n');
+      let s = 0;
+      let c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
+      }
+
+      for (; s >= 1 && c >= 0; s--, c--) {
+        // Next we find the first one that isn't the same which should be the
+        // frame that called our sample function and the control.
+        if (sampleLines[s] !== controlLines[c]) {
+          // In V8, the first line is describing the message but other VMs don't.
+          // If we're about to return the first line, and the control is also on the same
+          // line, that's a pretty good indicator that our sample threw at same line as
+          // the control. I.e. before we entered the sample frame. So we ignore this result.
+          // This can happen if you passed a class to function component, or non-function.
+          if (s !== 1 || c !== 1) {
+            do {
+              s--;
+              c--; // We may still have similar intermediate frames from the construct call.
+              // The next one that isn't the same should be our match though.
+
+              if (c < 0 || sampleLines[s] !== controlLines[c]) {
+                // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
+                let frame = '\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled "<anonymous>"
+                // but we have a user-provided "displayName"
+                // splice it in to make the stack more readable.
+
+                if (fn.displayName && frame.includes('<anonymous>')) {
+                  frame = frame.replace('<anonymous>', fn.displayName);
+                }
+
+                if (false) ; // Return the line we found.
+
+
+                return frame;
+              }
+            } while (s >= 1 && c >= 0);
+          }
+
+          break;
+        }
+      }
+    }
+  } finally {
+    reentry = false;
+
+    Error.prepareStackTrace = previousPrepareStackTrace;
+  } // Fallback to just using the name if we couldn't make it throw.
+
+
+  const name = fn ? fn.displayName || fn.name : '';
+  const syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';
+
+  return syntheticFrame;
+}
+
+function describeClassComponentFrame(ctor, source, ownerFn) {
+  {
+    return describeNativeComponentFrame(ctor, true);
+  }
+}
+function describeFunctionComponentFrame(fn, source, ownerFn) {
+  {
+    return describeNativeComponentFrame(fn, false);
+  }
+}
+
+function describeFiber(fiber) {
+
+  switch (fiber.tag) {
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      return describeBuiltInComponentFrame(fiber.type);
+
+    case LazyComponent:
+      return describeBuiltInComponentFrame('Lazy');
+
+    case SuspenseComponent:
+      return describeBuiltInComponentFrame('Suspense');
+
+    case SuspenseListComponent:
+      return describeBuiltInComponentFrame('SuspenseList');
+
+    case FunctionComponent:
+    case IndeterminateComponent:
+    case SimpleMemoComponent:
+      return describeFunctionComponentFrame(fiber.type);
+
+    case ForwardRef:
+      return describeFunctionComponentFrame(fiber.type.render);
+
+    case ClassComponent:
+      return describeClassComponentFrame(fiber.type);
+
+    default:
+      return '';
+  }
+}
+
+function getStackByFiberInDevAndProd(workInProgress) {
+  try {
+    let info = '';
+    let node = workInProgress;
+
+    do {
+      info += describeFiber(node); // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+      node = node.return;
+    } while (node);
+
+    return info;
+  } catch (x) {
+    return '\nError generating stack: ' + x.message + '\n' + x.stack;
+  }
+}
+
+function getWrappedName$1(outerType, innerType, wrapperName) {
+  const displayName = outerType.displayName;
+
+  if (displayName) {
+    return displayName;
+  }
+
+  const functionName = innerType.displayName || innerType.name || '';
+  return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
+} // Keep in sync with react-reconciler/getComponentNameFromFiber
+
+
+function getContextName$1(type) {
+  return type.displayName || 'Context';
+} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+
+function getComponentNameFromType(type) {
+  if (type == null) {
+    // Host root, text node or just invalid type.
+    return null;
+  }
+
+  if (typeof type === 'function') {
+    return type.displayName || type.name || null;
+  }
+
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_FRAGMENT_TYPE:
+      return 'Fragment';
+
+    case REACT_PORTAL_TYPE:
+      return 'Portal';
+
+    case REACT_PROFILER_TYPE:
+      return 'Profiler';
+
+    case REACT_STRICT_MODE_TYPE:
+      return 'StrictMode';
+
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+
+    case REACT_CACHE_TYPE:
+      {
+        return 'Cache';
+      }
+
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        const context = type;
+        return getContextName$1(context) + '.Consumer';
+
+      case REACT_PROVIDER_TYPE:
+        const provider = type;
+        return getContextName$1(provider._context) + '.Provider';
+
+      case REACT_FORWARD_REF_TYPE:
+        return getWrappedName$1(type, type.render, 'ForwardRef');
+
+      case REACT_MEMO_TYPE:
+        const outerName = type.displayName || null;
+
+        if (outerName !== null) {
+          return outerName;
+        }
+
+        return getComponentNameFromType(type.type) || 'Memo';
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            return getComponentNameFromType(init(payload));
+          } catch (x) {
+            return null;
+          }
+        }
+
+      case REACT_SERVER_CONTEXT_TYPE:
+        {
+          const context2 = type;
+          return (context2.displayName || context2._globalName) + '.Provider';
+        }
+
+    }
+  }
+
+  return null;
+}
+
+function getWrappedName(outerType, innerType, wrapperName) {
+  const functionName = innerType.displayName || innerType.name || '';
+  return outerType.displayName || (functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName);
+} // Keep in sync with shared/getComponentNameFromType
+
+
+function getContextName(type) {
+  return type.displayName || 'Context';
+}
+
+function getComponentNameFromFiber(fiber) {
+  const tag = fiber.tag,
+        type = fiber.type;
+
+  switch (tag) {
+    case CacheComponent:
+      return 'Cache';
+
+    case ContextConsumer:
+      const context = type;
+      return getContextName(context) + '.Consumer';
+
+    case ContextProvider:
+      const provider = type;
+      return getContextName(provider._context) + '.Provider';
+
+    case DehydratedFragment:
+      return 'DehydratedFragment';
+
+    case ForwardRef:
+      return getWrappedName(type, type.render, 'ForwardRef');
+
+    case Fragment:
+      return 'Fragment';
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      // Host component type is the display name (e.g. "div", "View")
+      return type;
+
+    case HostPortal:
+      return 'Portal';
+
+    case HostRoot:
+      return 'Root';
+
+    case HostText:
+      return 'Text';
+
+    case LazyComponent:
+      // Name comes from the type in this case; we don't have a tag.
+      return getComponentNameFromType(type);
+
+    case Mode:
+      if (type === REACT_STRICT_MODE_TYPE) {
+        // Don't be less specific than shared/getComponentNameFromType
+        return 'StrictMode';
+      }
+
+      return 'Mode';
+
+    case OffscreenComponent:
+      return 'Offscreen';
+
+    case Profiler:
+      return 'Profiler';
+
+    case ScopeComponent:
+      return 'Scope';
+
+    case SuspenseComponent:
+      return 'Suspense';
+
+    case SuspenseListComponent:
+      return 'SuspenseList';
+
+    case TracingMarkerComponent:
+      return 'TracingMarker';
+    // The display name for this tags come from the user-provided type:
+
+    case ClassComponent:
+    case FunctionComponent:
+    case IncompleteClassComponent:
+    case IndeterminateComponent:
+    case MemoComponent:
+    case SimpleMemoComponent:
+      if (typeof type === 'function') {
+        return type.displayName || type.name || null;
+      }
+
+      if (typeof type === 'string') {
+        return type;
+      }
+
+      break;
+
+  }
+
+  return null;
+}
+
+// around this limitation, we use an opaque type that can only be obtained by
+// passing the value through getToStringValue first.
+
+function toString(value) {
+  // The coercion safety check is performed in getToStringValue().
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  return '' + value;
+}
+function getToStringValue(value) {
+  switch (typeof value) {
+    case 'boolean':
+    case 'number':
+    case 'string':
+    case 'undefined':
+      return value;
+
+    case 'object':
+
+      return value;
+
+    default:
+      // function, symbol are assigned as empty strings
+      return '';
+  }
+}
+
+function isCheckable(elem) {
+  const type = elem.type;
+  const nodeName = elem.nodeName;
+  return nodeName && nodeName.toLowerCase() === 'input' && (type === 'checkbox' || type === 'radio');
+}
+
+function getTracker(node) {
+  return node._valueTracker;
+}
+
+function detachTracker(node) {
+  node._valueTracker = null;
+}
+
+function getValueFromNode(node) {
+  let value = '';
+
+  if (!node) {
+    return value;
+  }
+
+  if (isCheckable(node)) {
+    value = node.checked ? 'true' : 'false';
+  } else {
+    value = node.value;
+  }
+
+  return value;
+}
+
+function trackValueOnNode(node) {
+  const valueField = isCheckable(node) ? 'checked' : 'value';
+  const descriptor = Object.getOwnPropertyDescriptor(node.constructor.prototype, valueField);
+
+  let currentValue = '' + node[valueField]; // if someone has already defined a value or Safari, then bail
+  // and don't track value will cause over reporting of changes,
+  // but it's better then a hard failure
+  // (needed for certain tests that spyOn input values and Safari)
+
+  if (node.hasOwnProperty(valueField) || typeof descriptor === 'undefined' || typeof descriptor.get !== 'function' || typeof descriptor.set !== 'function') {
+    return;
+  }
+
+  const get = descriptor.get,
+        set = descriptor.set;
+  Object.defineProperty(node, valueField, {
+    configurable: true,
+    // $FlowFixMe[missing-this-annot]
+    get: function () {
+      return get.call(this);
+    },
+    // $FlowFixMe[missing-local-annot]
+    // $FlowFixMe[missing-this-annot]
+    set: function (value) {
+
+      currentValue = '' + value;
+      set.call(this, value);
+    }
+  }); // We could've passed this the first time
+  // but it triggers a bug in IE11 and Edge 14/15.
+  // Calling defineProperty() again should be equivalent.
+  // https://github.com/facebook/react/issues/11768
+
+  Object.defineProperty(node, valueField, {
+    enumerable: descriptor.enumerable
+  });
+  const tracker = {
+    getValue() {
+      return currentValue;
+    },
+
+    setValue(value) {
+
+      currentValue = '' + value;
+    },
+
+    stopTracking() {
+      detachTracker(node);
+      delete node[valueField];
+    }
+
+  };
+  return tracker;
+}
+
+function track(node) {
+  if (getTracker(node)) {
+    return;
+  }
+
+  node._valueTracker = trackValueOnNode(node);
+}
+function updateValueIfChanged(node) {
+  if (!node) {
+    return false;
+  }
+
+  const tracker = getTracker(node); // if there is no tracker at this point it's unlikely
+  // that trying again will succeed
+
+  if (!tracker) {
+    return true;
+  }
+
+  const lastValue = tracker.getValue();
+  const nextValue = getValueFromNode(node);
+
+  if (nextValue !== lastValue) {
+    tracker.setValue(nextValue);
+    return true;
+  }
+
+  return false;
+}
+
+function getActiveElement(doc) {
+  doc = doc || (typeof document !== 'undefined' ? document : undefined);
+
+  if (typeof doc === 'undefined') {
+    return null;
+  }
+
+  try {
+    return doc.activeElement || doc.body;
+  } catch (e) {
+    return doc.body;
+  }
+}
+
+// When passing user input into querySelector(All) the embedded string must not alter
+// the semantics of the query. This escape function is safe to use when we know the
+// provided value is going to be wrapped in double quotes as part of an attribute selector
+// Do not use it anywhere else
+// we escape double quotes and backslashes
+const escapeSelectorAttributeValueInsideDoubleQuotesRegex = /[\n\"\\]/g;
+function escapeSelectorAttributeValueInsideDoubleQuotes(value) {
+  return value.replace(escapeSelectorAttributeValueInsideDoubleQuotesRegex, ch => '\\' + ch.charCodeAt(0).toString(16) + ' ');
+}
+
+function updateInput(element, value, defaultValue, lastDefaultValue, checked, defaultChecked, type, name) {
+  const node = element; // Temporarily disconnect the input from any radio buttons.
+  // Changing the type or name as the same time as changing the checked value
+  // needs to be atomically applied. We can only ensure that by disconnecting
+  // the name while do the mutations and then reapply the name after that's done.
+
+  node.name = '';
+
+  if (type != null && typeof type !== 'function' && typeof type !== 'symbol' && typeof type !== 'boolean') {
+
+    node.type = type;
+  } else {
+    node.removeAttribute('type');
+  }
+
+  if (value != null) {
+    if (type === 'number') {
+      if ( // $FlowFixMe[incompatible-type]
+      value === 0 && node.value === '' || // We explicitly want to coerce to number here if possible.
+      // eslint-disable-next-line
+      node.value != value) {
+        node.value = toString(getToStringValue(value));
+      }
+    } else if (node.value !== toString(getToStringValue(value))) {
+      node.value = toString(getToStringValue(value));
+    }
+  } else if (type === 'submit' || type === 'reset') {
+    // Submit/reset inputs need the attribute removed completely to avoid
+    // blank-text buttons.
+    node.removeAttribute('value');
+  }
+
+  {
+    // When syncing the value attribute, the value comes from a cascade of
+    // properties:
+    //  1. The value React property
+    //  2. The defaultValue React property
+    //  3. Otherwise there should be no change
+    if (value != null) {
+      setDefaultValue(node, type, getToStringValue(value));
+    } else if (defaultValue != null) {
+      setDefaultValue(node, type, getToStringValue(defaultValue));
+    } else if (lastDefaultValue != null) {
+      node.removeAttribute('value');
+    }
+  }
+
+  {
+    // 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 (checked == null && defaultChecked != null) {
+      node.defaultChecked = !!defaultChecked;
+    }
+  }
+
+  if (checked != null) {
+    // Important to set this even if it's not a change in order to update input
+    // value tracking with radio buttons
+    // TODO: Should really update input value tracking for the whole radio
+    // button group in an effect or something (similar to #27024)
+    node.checked = checked && typeof checked !== 'function' && typeof checked !== 'symbol';
+  }
+
+  if (name != null && typeof name !== 'function' && typeof name !== 'symbol' && typeof name !== 'boolean') {
+
+    node.name = toString(getToStringValue(name));
+  } else {
+    node.removeAttribute('name');
+  }
+}
+function initInput(element, value, defaultValue, checked, defaultChecked, type, name, isHydrating) {
+  const node = element;
+
+  if (type != null && typeof type !== 'function' && typeof type !== 'symbol' && typeof type !== 'boolean') {
+
+    node.type = type;
+  }
+
+  if (value != null || defaultValue != null) {
+    const isButton = type === 'submit' || type === 'reset'; // Avoid setting value attribute on submit/reset inputs as it overrides the
+    // default value provided by the browser. See: #12872
+
+    if (isButton && (value === undefined || value === null)) {
+      return;
+    }
+
+    const defaultValueStr = defaultValue != null ? toString(getToStringValue(defaultValue)) : '';
+    const initialValue = value != null ? toString(getToStringValue(value)) : defaultValueStr; // Do not assign value if it is already set. This prevents user text input
+    // from being lost during SSR hydration.
+
+    if (!isHydrating) {
+      {
+        // When syncing the value attribute, the value property should use
+        // the wrapperState._initialValue property. This uses:
+        //
+        //   1. The value React property when present
+        //   2. The defaultValue React property when present
+        //   3. An empty string
+        if (initialValue !== node.value) {
+          node.value = initialValue;
+        }
+      }
+    }
+
+    {
+      // Otherwise, the value attribute is synchronized to the property,
+      // so we assign defaultValue to the same thing as the value property
+      // assignment step above.
+      node.defaultValue = initialValue;
+    }
+  } // Normally, we'd just do `node.checked = node.checked` upon initial mount, less this bug
+  // this is needed to work around a chrome bug where setting defaultChecked
+  // will sometimes influence the value of checked (even after detachment).
+  // Reference: https://bugs.chromium.org/p/chromium/issues/detail?id=608416
+  // We need to temporarily unset name to avoid disrupting radio button groups.
+
+
+  const checkedOrDefault = checked != null ? checked : defaultChecked; // TODO: This 'function' or 'symbol' check isn't replicated in other places
+  // so this semantic is inconsistent.
+
+  const initialChecked = typeof checkedOrDefault !== 'function' && typeof checkedOrDefault !== 'symbol' && !!checkedOrDefault;
+
+  if (isHydrating) {
+    // Detach .checked from .defaultChecked but leave user input alone
+    node.checked = node.checked;
+  } else {
+    node.checked = !!initialChecked;
+  }
+
+  {
+    // When syncing the checked attribute, both the checked property and
+    // attribute are assigned at the same time using defaultChecked. This uses:
+    //
+    //   1. The checked React property when present
+    //   2. The defaultChecked React property when present
+    //   3. Otherwise, false
+    node.defaultChecked = !node.defaultChecked;
+    node.defaultChecked = !!initialChecked;
+  } // Name needs to be set at the end so that it applies atomically to connected radio buttons.
+
+
+  if (name != null && typeof name !== 'function' && typeof name !== 'symbol' && typeof name !== 'boolean') {
+
+    node.name = name;
+  }
+}
+function restoreControlledInputState(element, props) {
+  const rootNode = element;
+  updateInput(rootNode, props.value, props.defaultValue, props.defaultValue, props.checked, props.defaultChecked, props.type, props.name);
+  const name = props.name;
+
+  if (props.type === 'radio' && name != null) {
+    let queryRoot = rootNode;
+
+    while (queryRoot.parentNode) {
+      queryRoot = queryRoot.parentNode;
+    } // If `rootNode.form` was non-null, then we could try `form.elements`,
+
+    const group = queryRoot.querySelectorAll('input[name="' + escapeSelectorAttributeValueInsideDoubleQuotes('' + name) + '"][type="radio"]');
+
+    for (let i = 0; i < group.length; i++) {
+      const otherNode = group[i];
+
+      if (otherNode === rootNode || otherNode.form !== rootNode.form) {
+        continue;
+      } // This will throw if radio buttons rendered by different copies of React
+      // and the same name are rendered into the same form (same as #1939).
+      // That's probably okay; we don't support it just as we don't support
+      // mixing React radio buttons with non-React ones.
+
+
+      const otherProps = getFiberCurrentPropsFromNode(otherNode);
+
+      if (!otherProps) {
+        throw Error(formatProdErrorMessage(90));
+      } // If this is a controlled radio button group, forcing the input that
+      // was previously checked to update will cause it to be come re-checked
+      // as appropriate.
+
+
+      updateInput(otherNode, otherProps.value, otherProps.defaultValue, otherProps.defaultValue, otherProps.checked, otherProps.defaultChecked, otherProps.type, otherProps.name);
+    } // If any updateInput() call set .checked to true, an input in this group
+    // (often, `rootNode` itself) may have become unchecked
+
+
+    for (let i = 0; i < group.length; i++) {
+      const otherNode = group[i];
+
+      if (otherNode.form !== rootNode.form) {
+        continue;
+      }
+
+      updateValueIfChanged(otherNode);
+    }
+  }
+} // In Chrome, assigning defaultValue to certain input types triggers input validation.
+// For number inputs, the display value loses trailing decimal points. For email inputs,
+// Chrome raises "The specified value <x> is not a valid email address".
+//
+// Here we check to see if the defaultValue has actually changed, avoiding these problems
+// when the user is inputting text
+//
+// https://github.com/facebook/react/issues/7253
+
+function setDefaultValue(node, type, value) {
+  if ( // Focused number inputs synchronize on blur. See ChangeEventPlugin.js
+  type !== 'number' || getActiveElement(node.ownerDocument) !== node) {
+    if (node.defaultValue !== toString(value)) {
+      node.defaultValue = toString(value);
+    }
+  }
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+// TODO: direct imports like some-package/src/* are bad. Fix me.
+
+function updateOptions(node, multiple, propValue, setDefaultSelected) {
+  const options = node.options;
+
+  if (multiple) {
+    const selectedValues = propValue;
+    const selectedValue = {};
+
+    for (let i = 0; i < selectedValues.length; i++) {
+      // Prefix to avoid chaos with special keys.
+      selectedValue['$' + selectedValues[i]] = true;
+    }
+
+    for (let i = 0; i < options.length; i++) {
+      const selected = selectedValue.hasOwnProperty('$' + options[i].value);
+
+      if (options[i].selected !== selected) {
+        options[i].selected = selected;
+      }
+
+      if (selected && setDefaultSelected) {
+        options[i].defaultSelected = true;
+      }
+    }
+  } else {
+    // Do not set `select.value` as exact behavior isn't consistent across all
+    // browsers for all cases.
+    const selectedValue = toString(getToStringValue(propValue));
+    let defaultSelected = null;
+
+    for (let i = 0; i < options.length; i++) {
+      if (options[i].value === selectedValue) {
+        options[i].selected = true;
+
+        if (setDefaultSelected) {
+          options[i].defaultSelected = true;
+        }
+
+        return;
+      }
+
+      if (defaultSelected === null && !options[i].disabled) {
+        defaultSelected = options[i];
+      }
+    }
+
+    if (defaultSelected !== null) {
+      defaultSelected.selected = true;
+    }
+  }
+}
+function initSelect(element, value, defaultValue, multiple) {
+  const node = element;
+  node.multiple = !!multiple;
+
+  if (value != null) {
+    updateOptions(node, !!multiple, value, false);
+  } else if (defaultValue != null) {
+    updateOptions(node, !!multiple, defaultValue, true);
+  }
+}
+function updateSelect(element, value, defaultValue, multiple, wasMultiple) {
+  const node = element;
+
+  if (value != null) {
+    updateOptions(node, !!multiple, value, false);
+  } else if (!!wasMultiple !== !!multiple) {
+    // For simplicity, reapply `defaultValue` if `multiple` is toggled.
+    if (defaultValue != null) {
+      updateOptions(node, !!multiple, defaultValue, true);
+    } else {
+      // Revert the select back to its default unselected state.
+      updateOptions(node, !!multiple, multiple ? [] : '', false);
+    }
+  }
+}
+function restoreControlledSelectState(element, props) {
+  const node = element;
+  const value = props.value;
+
+  if (value != null) {
+    updateOptions(node, !!props.multiple, value, false);
+  }
+}
+
+function updateTextarea(element, value, defaultValue) {
+  const node = element;
+
+  if (value != null) {
+    // Cast `value` to a string to ensure the value is set correctly. While
+    // browsers typically do this as necessary, jsdom doesn't.
+    const newValue = toString(getToStringValue(value)); // To avoid side effects (such as losing text selection), only set value if changed
+
+    if (newValue !== node.value) {
+      node.value = newValue;
+    } // TOOO: This should respect disableInputAttributeSyncing flag.
+
+
+    if (defaultValue == null) {
+      if (node.defaultValue !== newValue) {
+        node.defaultValue = newValue;
+      }
+
+      return;
+    }
+  }
+
+  if (defaultValue != null) {
+    node.defaultValue = toString(getToStringValue(defaultValue));
+  } else {
+    node.defaultValue = '';
+  }
+}
+function initTextarea(element, value, defaultValue, children) {
+  const node = element;
+  let initialValue = value; // Only bother fetching default value if we're going to use it
+
+  if (initialValue == null) {
+    if (children != null) {
+      {
+        if (defaultValue != null) {
+          throw Error(formatProdErrorMessage(92));
+        }
+
+        if (isArray(children)) {
+          if (children.length > 1) {
+            throw Error(formatProdErrorMessage(93));
+          }
+
+          children = children[0];
+        }
+
+        defaultValue = children;
+      }
+    }
+
+    if (defaultValue == null) {
+      defaultValue = '';
+    }
+
+    initialValue = defaultValue;
+  }
+
+  const stringValue = getToStringValue(initialValue);
+  node.defaultValue = stringValue; // This will be toString:ed.
+  // This is in postMount because we need access to the DOM node, which is not
+  // available until after the component has mounted.
+
+  const textContent = node.textContent; // Only set node.value if textContent is equal to the expected
+  // initial value. In IE10/IE11 there is a bug where the placeholder attribute
+  // will populate textContent as well.
+  // https://developer.microsoft.com/microsoft-edge/platform/issues/101525/
+
+  if (textContent === stringValue) {
+    if (textContent !== '' && textContent !== null) {
+      node.value = textContent;
+    }
+  }
+}
+function restoreControlledTextareaState(element, props) {
+  // DOM component is still mounted; update
+  updateTextarea(element, props.value, props.defaultValue);
+}
+
+const MATH_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
+const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
+
+/* globals MSApp */
+
+if (typeof MSApp !== 'undefined' && MSApp.execUnsafeLocalFunction) ;
+
+/**
+ * HTML nodeType values that represent the type of the node
+ */
+const ELEMENT_NODE = 1;
+const TEXT_NODE = 3;
+const COMMENT_NODE = 8;
+const DOCUMENT_NODE = 9;
+const DOCUMENT_TYPE_NODE = 10;
+const DOCUMENT_FRAGMENT_NODE = 11;
+
+/**
+ * Set the textContent property of a node. For text updates, it's faster
+ * to set the `nodeValue` of the Text node directly instead of using
+ * `.textContent` which will remove the existing node and create a new one.
+ *
+ * @param {DOMElement} node
+ * @param {string} text
+ * @internal
+ */
+
+function setTextContent(node, text) {
+  if (text) {
+    const firstChild = node.firstChild;
+
+    if (firstChild && firstChild === node.lastChild && firstChild.nodeType === TEXT_NODE) {
+      firstChild.nodeValue = text;
+      return;
+    }
+  }
+
+  node.textContent = text;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+const unitlessNumbers = new Set(['animationIterationCount', 'aspectRatio', 'borderImageOutset', 'borderImageSlice', 'borderImageWidth', 'boxFlex', 'boxFlexGroup', 'boxOrdinalGroup', 'columnCount', 'columns', 'flex', 'flexGrow', 'flexPositive', 'flexShrink', 'flexNegative', 'flexOrder', 'gridArea', 'gridRow', 'gridRowEnd', 'gridRowSpan', 'gridRowStart', 'gridColumn', 'gridColumnEnd', 'gridColumnSpan', 'gridColumnStart', 'fontWeight', 'lineClamp', 'lineHeight', 'opacity', 'order', 'orphans', 'scale', 'tabSize', 'widows', 'zIndex', 'zoom', 'fillOpacity', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'MozBoxFlexGroup', 'MozLineClamp', 'msAnimationIterationCount', 'msFlex', 'msZoom', 'msFlexGrow', 'msFlexNegative', 'msFlexOrder', 'msFlexPositive', 'msFlexShrink', 'msGridColumn', 'msGridColumnSpan', 'msGridRow', 'msGridRowSpan', 'WebkitAnimationIterationCount', 'WebkitBoxFlex', 'WebKitBoxFlexGroup', 'WebkitBoxOrdinalGroup', 'WebkitColumnCount', 'WebkitColumns', 'WebkitFlex', 'WebkitFlexGrow', 'WebkitFlexPositive', 'WebkitFlexShrink', 'WebkitLineClamp']);
+function isUnitlessNumber (name) {
+  return unitlessNumbers.has(name);
+}
+
+function setValueForStyle(style, styleName, value) {
+  const isCustomProperty = styleName.indexOf('--') === 0;
+
+  if (value == null || typeof value === 'boolean' || value === '') {
+    if (isCustomProperty) {
+      style.setProperty(styleName, '');
+    } else if (styleName === 'float') {
+      style.cssFloat = '';
+    } else {
+      style[styleName] = '';
+    }
+  } else if (isCustomProperty) {
+    style.setProperty(styleName, value);
+  } else if (typeof value === 'number' && value !== 0 && !isUnitlessNumber(styleName)) {
+    style[styleName] = value + 'px'; // Presumes implicit 'px' suffix for unitless numbers
+  } else {
+    if (styleName === 'float') {
+      style.cssFloat = value;
+    } else {
+
+      style[styleName] = ('' + value).trim();
+    }
+  }
+}
+/**
+ * Sets the value for multiple styles on a node.  If a value is specified as
+ * '' (empty string), the corresponding style property will be unset.
+ *
+ * @param {DOMElement} node
+ * @param {object} styles
+ */
+
+
+function setValueForStyles(node, styles, prevStyles) {
+  if (styles != null && typeof styles !== 'object') {
+    throw Error(formatProdErrorMessage(62));
+  }
+
+  const style = node.style;
+
+  if (prevStyles != null) {
+
+    for (const styleName in prevStyles) {
+      if (prevStyles.hasOwnProperty(styleName) && (styles == null || !styles.hasOwnProperty(styleName))) {
+        // Clear style
+        const isCustomProperty = styleName.indexOf('--') === 0;
+
+        if (isCustomProperty) {
+          style.setProperty(styleName, '');
+        } else if (styleName === 'float') {
+          style.cssFloat = '';
+        } else {
+          style[styleName] = '';
+        }
+      }
+    }
+
+    for (const styleName in styles) {
+      const value = styles[styleName];
+
+      if (styles.hasOwnProperty(styleName) && prevStyles[styleName] !== value) {
+        setValueForStyle(style, styleName, value);
+      }
+    }
+  } else {
+    for (const styleName in styles) {
+      if (styles.hasOwnProperty(styleName)) {
+        const value = styles[styleName];
+        setValueForStyle(style, styleName, value);
+      }
+    }
+  }
+}
+
+function isCustomElement(tagName, props) {
+  if (tagName.indexOf('-') === -1) {
+    return false;
+  }
+
+  switch (tagName) {
+    // These are reserved SVG and MathML elements.
+    // We don't mind this list too much because we expect it to never grow.
+    // The alternative is to track the namespace in a few places which is convoluted.
+    // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+    case 'annotation-xml':
+    case 'color-profile':
+    case 'font-face':
+    case 'font-face-src':
+    case 'font-face-uri':
+    case 'font-face-format':
+    case 'font-face-name':
+    case 'missing-glyph':
+      return false;
+
+    default:
+      return true;
+  }
+}
+
+const aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+  return aliases.get(name) || name;
+}
+
+function sanitizeURL(url) {
+
+  return url;
+}
+
+const IS_EVENT_HANDLE_NON_MANAGED_NODE = 1;
+const IS_NON_DELEGATED = 1 << 1;
+const IS_CAPTURE_PHASE = 1 << 2;
+// 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.
+// We also don't want to defer during event replaying.
+
+const SHOULD_NOT_PROCESS_POLYFILL_EVENT_PLUGINS = IS_EVENT_HANDLE_NON_MANAGED_NODE | IS_NON_DELEGATED | IS_CAPTURE_PHASE;
+
+// This exists to avoid circular dependency between ReactDOMEventReplaying
+// and DOMPluginEventSystem.
+let currentReplayingEvent = null;
+function setReplayingEvent(event) {
+
+  currentReplayingEvent = event;
+}
+function resetReplayingEvent() {
+
+  currentReplayingEvent = null;
+}
+function isReplayingEvent(event) {
+  return event === currentReplayingEvent;
+}
+
+/**
+ * Gets the target node from a native browser event by accounting for
+ * inconsistencies in browser DOM APIs.
+ *
+ * @param {object} nativeEvent Native browser event.
+ * @return {DOMEventTarget} Target node.
+ */
+
+function getEventTarget(nativeEvent) {
+  // Fallback to nativeEvent.srcElement for IE9
+  // https://github.com/facebook/react/issues/12506
+  let target = nativeEvent.target || nativeEvent.srcElement || window; // Normalize SVG <use> element events #4963
+
+  if (target.correspondingUseElement) {
+    target = target.correspondingUseElement;
+  } // Safari may fire events on text nodes (Node.TEXT_NODE is 3).
+  // @see http://www.quirksmode.org/js/events_properties.html
+
+
+  return target.nodeType === TEXT_NODE ? target.parentNode : target;
+}
+
+let restoreTarget = null;
+let restoreQueue = null;
+
+function restoreStateOfTarget(target) {
+  // We perform this translation at the end of the event loop so that we
+  // always receive the correct fiber here
+  const internalInstance = getInstanceFromNode(target);
+
+  if (!internalInstance) {
+    // Unmounted
+    return;
+  }
+
+  const stateNode = internalInstance.stateNode; // Guard against Fiber being unmounted.
+
+  if (stateNode) {
+    const props = getFiberCurrentPropsFromNode(stateNode);
+    restoreControlledState(internalInstance.stateNode, internalInstance.type, props);
+  }
+}
+
+function enqueueStateRestore(target) {
+  if (restoreTarget) {
+    if (restoreQueue) {
+      restoreQueue.push(target);
+    } else {
+      restoreQueue = [target];
+    }
+  } else {
+    restoreTarget = target;
+  }
+}
+function needsStateRestore() {
+  return restoreTarget !== null || restoreQueue !== null;
+}
+function restoreStateIfNeeded() {
+  if (!restoreTarget) {
+    return;
+  }
+
+  const target = restoreTarget;
+  const queuedTargets = restoreQueue;
+  restoreTarget = null;
+  restoreQueue = null;
+  restoreStateOfTarget(target);
+
+  if (queuedTargets) {
+    for (let i = 0; i < queuedTargets.length; i++) {
+      restoreStateOfTarget(queuedTargets[i]);
+    }
+  }
+}
+
+/**
+ * `ReactInstanceMap` maintains a mapping from a public facing stateful
+ * instance (key) and the internal representation (value). This allows public
+ * methods to accept the user facing instance as an argument and map them back
+ * to internal methods.
+ *
+ * Note that this module is currently shared and assumed to be stateless.
+ * If this becomes an actual Map, that will break.
+ */
+function get(key) {
+  return key._reactInternals;
+}
+function has(key) {
+  return key._reactInternals !== undefined;
+}
+function set(key, value) {
+  key._reactInternals = value;
+}
+
+function getNearestMountedFiber(fiber) {
+  let node = fiber;
+  let nearestMounted = fiber;
+
+  if (!fiber.alternate) {
+    // If there is no alternate, this might be a new tree that isn't inserted
+    // yet. If it is, then it will have a pending insertion effect on it.
+    let nextNode = node;
+
+    do {
+      node = nextNode;
+
+      if ((node.flags & (Placement | Hydrating)) !== NoFlags$1) {
+        // This is an insertion or in-progress hydration. The nearest possible
+        // mounted fiber is the parent but we need to continue to figure out
+        // if that one is still mounted.
+        nearestMounted = node.return;
+      } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+      nextNode = node.return;
+    } while (nextNode);
+  } else {
+    while (node.return) {
+      node = node.return;
+    }
+  }
+
+  if (node.tag === HostRoot) {
+    // TODO: Check if this was a nested HostRoot when used with
+    // renderContainerIntoSubtree.
+    return nearestMounted;
+  } // If we didn't hit the root, that means that we're in an disconnected tree
+  // that has been unmounted.
+
+
+  return null;
+}
+function getSuspenseInstanceFromFiber(fiber) {
+  if (fiber.tag === SuspenseComponent) {
+    let suspenseState = fiber.memoizedState;
+
+    if (suspenseState === null) {
+      const current = fiber.alternate;
+
+      if (current !== null) {
+        suspenseState = current.memoizedState;
+      }
+    }
+
+    if (suspenseState !== null) {
+      return suspenseState.dehydrated;
+    }
+  }
+
+  return null;
+}
+function getContainerFromFiber(fiber) {
+  return fiber.tag === HostRoot ? fiber.stateNode.containerInfo : null;
+}
+function isFiberMounted(fiber) {
+  return getNearestMountedFiber(fiber) === fiber;
+}
+function isMounted(component) {
+
+  const fiber = get(component);
+
+  if (!fiber) {
+    return false;
+  }
+
+  return getNearestMountedFiber(fiber) === fiber;
+}
+
+function assertIsMounted(fiber) {
+  if (getNearestMountedFiber(fiber) !== fiber) {
+    throw Error(formatProdErrorMessage(188));
+  }
+}
+
+function findCurrentFiberUsingSlowPath(fiber) {
+  const alternate = fiber.alternate;
+
+  if (!alternate) {
+    // If there is no alternate, then we only need to check if it is mounted.
+    const nearestMounted = getNearestMountedFiber(fiber);
+
+    if (nearestMounted === null) {
+      throw Error(formatProdErrorMessage(188));
+    }
+
+    if (nearestMounted !== fiber) {
+      return null;
+    }
+
+    return fiber;
+  } // If we have two possible branches, we'll walk backwards up to the root
+  // to see what path the root points to. On the way we may hit one of the
+  // special cases and we'll deal with them.
+
+
+  let a = fiber;
+  let b = alternate;
+
+  while (true) {
+    const parentA = a.return;
+
+    if (parentA === null) {
+      // We're at the root.
+      break;
+    }
+
+    const parentB = parentA.alternate;
+
+    if (parentB === null) {
+      // There is no alternate. This is an unusual case. Currently, it only
+      // happens when a Suspense component is hidden. An extra fragment fiber
+      // is inserted in between the Suspense fiber and its children. Skip
+      // over this extra fragment fiber and proceed to the next parent.
+      const nextParent = parentA.return;
+
+      if (nextParent !== null) {
+        a = b = nextParent;
+        continue;
+      } // If there's no parent, we're at the root.
+
+
+      break;
+    } // If both copies of the parent fiber point to the same child, we can
+    // assume that the child is current. This happens when we bailout on low
+    // priority: the bailed out fiber's child reuses the current child.
+
+
+    if (parentA.child === parentB.child) {
+      let child = parentA.child;
+
+      while (child) {
+        if (child === a) {
+          // We've determined that A is the current branch.
+          assertIsMounted(parentA);
+          return fiber;
+        }
+
+        if (child === b) {
+          // We've determined that B is the current branch.
+          assertIsMounted(parentA);
+          return alternate;
+        }
+
+        child = child.sibling;
+      } // We should never have an alternate for any mounting node. So the only
+      // way this could possibly happen is if this was unmounted, if at all.
+
+
+      throw Error(formatProdErrorMessage(188));
+    }
+
+    if (a.return !== b.return) {
+      // The return pointer of A and the return pointer of B point to different
+      // fibers. We assume that return pointers never criss-cross, so A must
+      // belong to the child set of A.return, and B must belong to the child
+      // set of B.return.
+      a = parentA;
+      b = parentB;
+    } else {
+      // The return pointers point to the same fiber. We'll have to use the
+      // default, slow path: scan the child sets of each parent alternate to see
+      // which child belongs to which set.
+      //
+      // Search parent A's child set
+      let didFindChild = false;
+      let child = parentA.child;
+
+      while (child) {
+        if (child === a) {
+          didFindChild = true;
+          a = parentA;
+          b = parentB;
+          break;
+        }
+
+        if (child === b) {
+          didFindChild = true;
+          b = parentA;
+          a = parentB;
+          break;
+        }
+
+        child = child.sibling;
+      }
+
+      if (!didFindChild) {
+        // Search parent B's child set
+        child = parentB.child;
+
+        while (child) {
+          if (child === a) {
+            didFindChild = true;
+            a = parentB;
+            b = parentA;
+            break;
+          }
+
+          if (child === b) {
+            didFindChild = true;
+            b = parentB;
+            a = parentA;
+            break;
+          }
+
+          child = child.sibling;
+        }
+
+        if (!didFindChild) {
+          throw Error(formatProdErrorMessage(189));
+        }
+      }
+    }
+
+    if (a.alternate !== b) {
+      throw Error(formatProdErrorMessage(190));
+    }
+  } // If the root is not a host container, we're in a disconnected tree. I.e.
+  // unmounted.
+
+
+  if (a.tag !== HostRoot) {
+    throw Error(formatProdErrorMessage(188));
+  }
+
+  if (a.stateNode.current === a) {
+    // We've determined that A is the current branch.
+    return fiber;
+  } // Otherwise B has to be current branch.
+
+
+  return alternate;
+}
+function findCurrentHostFiber(parent) {
+  const currentParent = findCurrentFiberUsingSlowPath(parent);
+  return currentParent !== null ? findCurrentHostFiberImpl(currentParent) : null;
+}
+
+function findCurrentHostFiberImpl(node) {
+  // Next we'll drill down this component to find the first HostComponent/Text.
+  const tag = node.tag;
+
+  if (tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton ) || tag === HostText) {
+    return node;
+  }
+
+  let child = node.child;
+
+  while (child !== null) {
+    const match = findCurrentHostFiberImpl(child);
+
+    if (match !== null) {
+      return match;
+    }
+
+    child = child.sibling;
+  }
+
+  return null;
+}
+
+const emptyContextObject = {};
+
+
+const contextStackCursor = createCursor(emptyContextObject); // A cursor to a boolean indicating whether the context has changed.
+
+const didPerformWorkStackCursor = createCursor(false); // Keep track of the previous context object that was on the stack.
+// We use this to get access to the parent context after we have already
+// pushed the next context provider, and now need to merge their contexts.
+
+let previousContext = emptyContextObject;
+
+function getUnmaskedContext(workInProgress, Component, didPushOwnContextIfProvider) {
+  {
+    if (didPushOwnContextIfProvider && isContextProvider(Component)) {
+      // If the fiber is a context provider itself, when we read its context
+      // we may have already pushed its own child context on the stack. A context
+      // provider should not "see" its own child context. Therefore we read the
+      // previous (parent) context instead for a context provider.
+      return previousContext;
+    }
+
+    return contextStackCursor.current;
+  }
+}
+
+function cacheContext(workInProgress, unmaskedContext, maskedContext) {
+  {
+    const instance = workInProgress.stateNode;
+    instance.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext;
+    instance.__reactInternalMemoizedMaskedChildContext = maskedContext;
+  }
+}
+
+function getMaskedContext(workInProgress, unmaskedContext) {
+  {
+    const type = workInProgress.type;
+    const contextTypes = type.contextTypes;
+
+    if (!contextTypes) {
+      return emptyContextObject;
+    } // Avoid recreating masked context unless unmasked context has changed.
+    // Failing to do this will result in unnecessary calls to componentWillReceiveProps.
+    // This may trigger infinite loops if componentWillReceiveProps calls setState.
+
+
+    const instance = workInProgress.stateNode;
+
+    if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) {
+      return instance.__reactInternalMemoizedMaskedChildContext;
+    }
+
+    const context = {};
+
+    for (const key in contextTypes) {
+      context[key] = unmaskedContext[key];
+    }
+    // Context is created before the class component is instantiated so check for instance.
+
+
+    if (instance) {
+      cacheContext(workInProgress, unmaskedContext, context);
+    }
+
+    return context;
+  }
+}
+
+function hasContextChanged() {
+  {
+    return didPerformWorkStackCursor.current;
+  }
+}
+
+function isContextProvider(type) {
+  {
+    const childContextTypes = type.childContextTypes;
+    return childContextTypes !== null && childContextTypes !== undefined;
+  }
+}
+
+function popContext(fiber) {
+  {
+    pop(didPerformWorkStackCursor);
+    pop(contextStackCursor);
+  }
+}
+
+function popTopLevelContextObject(fiber) {
+  {
+    pop(didPerformWorkStackCursor);
+    pop(contextStackCursor);
+  }
+}
+
+function pushTopLevelContextObject(fiber, context, didChange) {
+  {
+    if (contextStackCursor.current !== emptyContextObject) {
+      throw Error(formatProdErrorMessage(168));
+    }
+
+    push(contextStackCursor, context);
+    push(didPerformWorkStackCursor, didChange);
+  }
+}
+
+function processChildContext(fiber, type, parentContext) {
+  {
+    const instance = fiber.stateNode;
+    const childContextTypes = type.childContextTypes; // TODO (bvaughn) Replace this behavior with an invariant() in the future.
+    // It has only been added in Fiber to match the (unintentional) behavior in Stack.
+
+    if (typeof instance.getChildContext !== 'function') {
+
+      return parentContext;
+    }
+
+    const childContext = instance.getChildContext();
+
+    for (const contextKey in childContext) {
+      if (!(contextKey in childContextTypes)) {
+        throw Error(formatProdErrorMessage(108, getComponentNameFromFiber(fiber) || 'Unknown', contextKey));
+      }
+    }
+
+    return assign({}, parentContext, childContext);
+  }
+}
+
+function pushContextProvider(workInProgress) {
+  {
+    const instance = workInProgress.stateNode; // We push the context as early as possible to ensure stack integrity.
+    // If the instance does not exist yet, we will push null at first,
+    // and replace it on the stack later when invalidating the context.
+
+    const memoizedMergedChildContext = instance && instance.__reactInternalMemoizedMergedChildContext || emptyContextObject; // Remember the parent context so we can merge with it later.
+    // Inherit the parent's did-perform-work value to avoid inadvertently blocking updates.
+
+    previousContext = contextStackCursor.current;
+    push(contextStackCursor, memoizedMergedChildContext);
+    push(didPerformWorkStackCursor, didPerformWorkStackCursor.current);
+    return true;
+  }
+}
+
+function invalidateContextProvider(workInProgress, type, didChange) {
+  {
+    const instance = workInProgress.stateNode;
+
+    if (!instance) {
+      throw Error(formatProdErrorMessage(169));
+    }
+
+    if (didChange) {
+      // Merge parent and own context.
+      // Skip this if we're not updating due to sCU.
+      // This avoids unnecessarily recomputing memoized values.
+      const mergedContext = processChildContext(workInProgress, type, previousContext);
+      instance.__reactInternalMemoizedMergedChildContext = mergedContext; // Replace the old (or empty) context with the new one.
+      // It is important to unwind the context in the reverse order.
+
+      pop(didPerformWorkStackCursor);
+      pop(contextStackCursor); // Now push the new context and mark that it has changed.
+
+      push(contextStackCursor, mergedContext);
+      push(didPerformWorkStackCursor, didChange);
+    } else {
+      pop(didPerformWorkStackCursor);
+      push(didPerformWorkStackCursor, didChange);
+    }
+  }
+}
+
+function findCurrentUnmaskedContext(fiber) {
+  {
+    // Currently this is only used with renderSubtreeIntoContainer; not sure if it
+    // makes sense elsewhere
+    if (!isFiberMounted(fiber) || fiber.tag !== ClassComponent) {
+      throw Error(formatProdErrorMessage(170));
+    }
+
+    let node = fiber;
+
+    do {
+      switch (node.tag) {
+        case HostRoot:
+          return node.stateNode.context;
+
+        case ClassComponent:
+          {
+            const Component = node.type;
+
+            if (isContextProvider(Component)) {
+              return node.stateNode.__reactInternalMemoizedMergedChildContext;
+            }
+
+            break;
+          }
+      } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+      node = node.return;
+    } while (node !== null);
+
+    throw Error(formatProdErrorMessage(171));
+  }
+}
+
+const LegacyRoot = 0;
+const ConcurrentRoot = 1;
+
+// We use the existence of the state object as an indicator that the component
+// is hidden.
+const OffscreenVisible =
+/*                     */
+0b001;
+const OffscreenDetached =
+/*                    */
+0b010;
+const OffscreenPassiveEffectsConnected =
+/*     */
+0b100;
+function isOffscreenManual(offscreenFiber) {
+  return offscreenFiber.memoizedProps !== null && offscreenFiber.memoizedProps.mode === 'manual';
+}
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+
+const objectIs = // $FlowFixMe[method-unbinding]
+typeof Object.is === 'function' ? Object.is : is;
+
+// This is imported by the event replaying implementation in React DOM. It's
+// in a separate file to break a circular dependency between the renderer and
+// the reconciler.
+function isRootDehydrated(root) {
+  const currentState = root.current.memoizedState;
+  return currentState.isDehydrated;
+}
+
+// Ids are base 32 strings whose binary representation corresponds to the
+// 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.
+
+const forkStack = [];
+let forkStackIndex = 0;
+let treeForkProvider = null;
+let treeForkCount = 0;
+const idStack = [];
+let idStackIndex = 0;
+let treeContextProvider = null;
+let treeContextId = 1;
+let treeContextOverflow = '';
+function isForkedChild(workInProgress) {
+  return (workInProgress.flags & Forked) !== NoFlags$1;
+}
+function getForksAtLevel(workInProgress) {
+  return treeForkCount;
+}
+function getTreeId() {
+  const overflow = treeContextOverflow;
+  const idWithLeadingBit = treeContextId;
+  const id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
+  return id.toString(32) + overflow;
+}
+function pushTreeFork(workInProgress, totalChildren) {
+  forkStack[forkStackIndex++] = treeForkCount;
+  forkStack[forkStackIndex++] = treeForkProvider;
+  treeForkProvider = workInProgress;
+  treeForkCount = totalChildren;
+}
+function pushTreeId(workInProgress, totalChildren, index) {
+  idStack[idStackIndex++] = treeContextId;
+  idStack[idStackIndex++] = treeContextOverflow;
+  idStack[idStackIndex++] = treeContextProvider;
+  treeContextProvider = workInProgress;
+  const baseIdWithLeadingBit = treeContextId;
+  const baseOverflow = treeContextOverflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
+  // of the id; we use it to account for leading 0s.
+
+  const baseLength = getBitLength(baseIdWithLeadingBit) - 1;
+  const baseId = baseIdWithLeadingBit & ~(1 << baseLength);
+  const slot = index + 1;
+  const length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
+  // consideration the leading 1 we use to mark the end of the sequence.
+
+  if (length > 30) {
+    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
+    // This branch assumes the length of the base id is greater than 5; it won't
+    // work for smaller ids, because you need 5 bits per character.
+    //
+    // We encode the id in multiple steps: first the base id, then the
+    // remaining digits.
+    //
+    // Each 5 bit sequence corresponds to a single base 32 character. So for
+    // example, if the current id is 23 bits long, we can convert 20 of those
+    // bits into a string of 4 characters, with 3 bits left over.
+    //
+    // First calculate how many bits in the base id represent a complete
+    // sequence of characters.
+    const numberOfOverflowBits = baseLength - baseLength % 5; // Then create a bitmask that selects only those bits.
+
+    const newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
+
+    const newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
+
+    const restOfBaseId = baseId >> numberOfOverflowBits;
+    const restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
+    // we made more room, this time it won't overflow.
+
+    const restOfLength = getBitLength(totalChildren) + restOfBaseLength;
+    const restOfNewBits = slot << restOfBaseLength;
+    const id = restOfNewBits | restOfBaseId;
+    const overflow = newOverflow + baseOverflow;
+    treeContextId = 1 << restOfLength | id;
+    treeContextOverflow = overflow;
+  } else {
+    // Normal path
+    const newBits = slot << baseLength;
+    const id = newBits | baseId;
+    const overflow = baseOverflow;
+    treeContextId = 1 << length | id;
+    treeContextOverflow = overflow;
+  }
+}
+function pushMaterializedTreeId(workInProgress) {
+  // in its children.
+
+  const returnFiber = workInProgress.return;
+
+  if (returnFiber !== null) {
+    const numberOfForks = 1;
+    const slotIndex = 0;
+    pushTreeFork(workInProgress, numberOfForks);
+    pushTreeId(workInProgress, numberOfForks, slotIndex);
+  }
+}
+
+function getBitLength(number) {
+  return 32 - clz32(number);
+}
+
+function getLeadingBit(id) {
+  return 1 << getBitLength(id) - 1;
+}
+
+function popTreeContext(workInProgress) {
+  // Restore the previous values.
+  // This is a bit more complicated than other context-like modules in Fiber
+  // because the same Fiber may appear on the stack multiple times and for
+  // different reasons. We have to keep popping until the work-in-progress is
+  // no longer at the top of the stack.
+  while (workInProgress === treeForkProvider) {
+    treeForkProvider = forkStack[--forkStackIndex];
+    forkStack[forkStackIndex] = null;
+    treeForkCount = forkStack[--forkStackIndex];
+    forkStack[forkStackIndex] = null;
+  }
+
+  while (workInProgress === treeContextProvider) {
+    treeContextProvider = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+    treeContextOverflow = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+    treeContextId = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+  }
+}
+function getSuspendedTreeContext() {
+
+  if (treeContextProvider !== null) {
+    return {
+      id: treeContextId,
+      overflow: treeContextOverflow
+    };
+  } else {
+    return null;
+  }
+}
+function restoreSuspendedTreeContext(workInProgress, suspendedContext) {
+  idStack[idStackIndex++] = treeContextId;
+  idStack[idStackIndex++] = treeContextOverflow;
+  idStack[idStackIndex++] = treeContextProvider;
+  treeContextId = suspendedContext.id;
+  treeContextOverflow = suspendedContext.overflow;
+  treeContextProvider = workInProgress;
+}
+
+// This may have been an insertion or a hydration.
+
+let hydrationParentFiber = null;
+let nextHydratableInstance = null;
+let isHydrating = false; // This flag allows for warning supression when we expect there to be mismatches
+
+let hydrationErrors = null;
+let rootOrSingletonContext = false;
+
+function enterHydrationState(fiber) {
+
+  const parentInstance = fiber.stateNode.containerInfo;
+  nextHydratableInstance = getFirstHydratableChildWithinContainer(parentInstance);
+  hydrationParentFiber = fiber;
+  isHydrating = true;
+  hydrationErrors = null;
+  rootOrSingletonContext = true;
+  return true;
+}
+
+function reenterHydrationStateFromDehydratedSuspenseInstance(fiber, suspenseInstance, treeContext) {
+
+  nextHydratableInstance = getFirstHydratableChildWithinSuspenseInstance(suspenseInstance);
+  hydrationParentFiber = fiber;
+  isHydrating = true;
+  hydrationErrors = null;
+  rootOrSingletonContext = false;
+
+  if (treeContext !== null) {
+    restoreSuspendedTreeContext(fiber, treeContext);
+  }
+
+  return true;
+}
+
+function deleteHydratableInstance(returnFiber, instance) {
+  const childToDelete = createFiberFromHostInstanceForDeletion();
+  childToDelete.stateNode = instance;
+  childToDelete.return = returnFiber;
+  const deletions = returnFiber.deletions;
+
+  if (deletions === null) {
+    returnFiber.deletions = [childToDelete];
+    returnFiber.flags |= ChildDeletion;
+  } else {
+    deletions.push(childToDelete);
+  }
+}
+
+function insertNonHydratedInstance(returnFiber, fiber) {
+  fiber.flags = fiber.flags & ~Hydrating | Placement;
+}
+
+function tryHydrateInstance(fiber, nextInstance) {
+  // fiber is a HostComponent Fiber
+  const instance = canHydrateInstance(nextInstance, fiber.type, fiber.pendingProps, rootOrSingletonContext);
+
+  if (instance !== null) {
+    fiber.stateNode = instance;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = getFirstHydratableChild(instance);
+    rootOrSingletonContext = false;
+    return true;
+  }
+
+  return false;
+}
+
+function tryHydrateText(fiber, nextInstance) {
+  // fiber is a HostText Fiber
+  const text = fiber.pendingProps;
+  const textInstance = canHydrateTextInstance(nextInstance, text, rootOrSingletonContext);
+
+  if (textInstance !== null) {
+    fiber.stateNode = textInstance;
+    hydrationParentFiber = fiber; // Text Instances don't have children so there's nothing to hydrate.
+
+    nextHydratableInstance = null;
+    return true;
+  }
+
+  return false;
+}
+
+function tryHydrateSuspense(fiber, nextInstance) {
+  // fiber is a SuspenseComponent Fiber
+  const suspenseInstance = canHydrateSuspenseInstance(nextInstance, rootOrSingletonContext);
+
+  if (suspenseInstance !== null) {
+    const suspenseState = {
+      dehydrated: suspenseInstance,
+      treeContext: getSuspendedTreeContext(),
+      retryLane: OffscreenLane
+    };
+    fiber.memoizedState = suspenseState; // Store the dehydrated fragment as a child fiber.
+    // This simplifies the code for getHostSibling and deleting nodes,
+    // since it doesn't have to consider all Suspense boundaries and
+    // check if they're dehydrated ones or not.
+
+    const dehydratedFragment = createFiberFromDehydratedFragment(suspenseInstance);
+    dehydratedFragment.return = fiber;
+    fiber.child = dehydratedFragment;
+    hydrationParentFiber = fiber; // While a Suspense Instance does have children, we won't step into
+    // it during the first pass. Instead, we'll reenter it later.
+
+    nextHydratableInstance = null;
+    return true;
+  }
+
+  return false;
+}
+
+function shouldClientRenderOnMismatch(fiber) {
+  return (fiber.mode & ConcurrentMode) !== NoMode && (fiber.flags & DidCapture) === NoFlags$1;
+}
+
+function throwOnHydrationMismatch(fiber) {
+  throw Error(formatProdErrorMessage(418));
+}
+
+function claimHydratableSingleton(fiber) {
+  {
+    if (!isHydrating) {
+      return;
+    }
+
+    const currentRootContainer = getRootHostContainer();
+    const instance = fiber.stateNode = resolveSingletonInstance(fiber.type, fiber.pendingProps, currentRootContainer);
+    hydrationParentFiber = fiber;
+    rootOrSingletonContext = true;
+    nextHydratableInstance = getFirstHydratableChild(instance);
+  }
+}
+
+function tryToClaimNextHydratableInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
+
+  const initialInstance = nextHydratableInstance;
+  const nextInstance = nextHydratableInstance;
+
+  if (!nextInstance) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
+
+
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
+    return;
+  }
+
+  const firstAttemptedInstance = nextInstance;
+
+  if (!tryHydrateInstance(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
+
+
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    const prevHydrationParentFiber = hydrationParentFiber;
+
+    if (!nextHydratableInstance || !tryHydrateInstance(fiber, nextHydratableInstance)) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
+
+
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+  }
+}
+
+function tryToClaimNextHydratableTextInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
+
+  const text = fiber.pendingProps;
+  const isHydratable = isHydratableText(text);
+  const initialInstance = nextHydratableInstance;
+  const nextInstance = nextHydratableInstance;
+
+  if (!nextInstance || !isHydratable) {
+    // We exclude non hydrabable text because we know there are no matching hydratables.
+    // We either throw or insert depending on the render mode.
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
+
+
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
+    return;
+  }
+
+  const firstAttemptedInstance = nextInstance;
+
+  if (!tryHydrateText(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
+
+
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    const prevHydrationParentFiber = hydrationParentFiber;
+
+    if (!nextHydratableInstance || !tryHydrateText(fiber, nextHydratableInstance)) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
+
+
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+  }
+}
+
+function tryToClaimNextHydratableSuspenseInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
+
+  const initialInstance = nextHydratableInstance;
+  const nextInstance = nextHydratableInstance;
+
+  if (!nextInstance) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
+
+
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
+    return;
+  }
+
+  const firstAttemptedInstance = nextInstance;
+
+  if (!tryHydrateSuspense(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
+
+
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    const prevHydrationParentFiber = hydrationParentFiber;
+
+    if (!nextHydratableInstance || !tryHydrateSuspense(fiber, nextHydratableInstance)) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
+
+
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+  }
+}
+
+function tryToClaimNextHydratableFormMarkerInstance(fiber) {
+  if (!isHydrating) {
+    return false;
+  }
+
+  if (nextHydratableInstance) {
+    const markerInstance = canHydrateFormStateMarker(nextHydratableInstance, rootOrSingletonContext);
+
+    if (markerInstance) {
+      // Found the marker instance.
+      nextHydratableInstance = getNextHydratableSibling(markerInstance); // Return true if this marker instance should use the state passed
+      // to hydrateRoot.
+      // TODO: As an optimization, Fizz should only emit these markers if form
+      // state is passed at the root.
+
+      return isFormStateMarkerMatching(markerInstance);
+    }
+  } // Should have found a marker instance. Throw an error to trigger client
+  // rendering. We don't bother to check if we're in a concurrent root because
+  // useFormState is a new API, so backwards compat is not an issue.
+
+
+  throwOnHydrationMismatch();
+  return false;
+}
+
+function prepareToHydrateHostInstance(fiber, hostContext) {
+
+  const instance = fiber.stateNode;
+  hydrateInstance(instance, fiber.type, fiber.memoizedProps, hostContext, fiber);
+}
+
+function prepareToHydrateHostTextInstance(fiber) {
+
+  const textInstance = fiber.stateNode;
+  const textContent = fiber.memoizedProps;
+  const shouldUpdate = hydrateTextInstance(textInstance, textContent, fiber);
+
+  if (shouldUpdate) {
+    // We assume that prepareToHydrateHostTextInstance is called in a context where the
+    // hydration parent is the parent host component of this host text.
+    const returnFiber = hydrationParentFiber;
+
+    if (returnFiber !== null) {
+      switch (returnFiber.tag) {
+        case HostRoot:
+          {
+            const parentContainer = returnFiber.stateNode.containerInfo;
+            const isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
+            didNotMatchHydratedContainerTextInstance(parentContainer, textInstance, textContent, // TODO: Delete this argument when we remove the legacy root API.
+            isConcurrentMode);
+
+            if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {
+              // In concurrent mode we never update the mismatched text,
+              // even if the error was ignored.
+              return false;
+            }
+
+            break;
+          }
+
+        case HostSingleton:
+        case HostComponent:
+          {
+            const parentType = returnFiber.type;
+            const parentProps = returnFiber.memoizedProps;
+            const parentInstance = returnFiber.stateNode;
+            const isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
+            didNotMatchHydratedTextInstance(parentType, parentProps, parentInstance, textInstance, textContent, // TODO: Delete this argument when we remove the legacy root API.
+            isConcurrentMode);
+
+            if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {
+              // In concurrent mode we never update the mismatched text,
+              // even if the error was ignored.
+              return false;
+            }
+
+            break;
+          }
+      }
+    }
+  }
+
+  return shouldUpdate;
+}
+
+function prepareToHydrateHostSuspenseInstance(fiber) {
+
+  const suspenseState = fiber.memoizedState;
+  const suspenseInstance = suspenseState !== null ? suspenseState.dehydrated : null;
+
+  if (!suspenseInstance) {
+    throw Error(formatProdErrorMessage(317));
+  }
+
+  hydrateSuspenseInstance(suspenseInstance, fiber);
+}
+
+function skipPastDehydratedSuspenseInstance(fiber) {
+
+  const suspenseState = fiber.memoizedState;
+  const suspenseInstance = suspenseState !== null ? suspenseState.dehydrated : null;
+
+  if (!suspenseInstance) {
+    throw Error(formatProdErrorMessage(317));
+  }
+
+  return getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance);
+}
+
+function popToNextHostParent(fiber) {
+  hydrationParentFiber = fiber.return;
+
+  while (hydrationParentFiber) {
+    switch (hydrationParentFiber.tag) {
+      case HostRoot:
+      case HostSingleton:
+        rootOrSingletonContext = true;
+        return;
+
+      case HostComponent:
+      case SuspenseComponent:
+        rootOrSingletonContext = false;
+        return;
+
+      default:
+        hydrationParentFiber = hydrationParentFiber.return;
+    }
+  }
+}
+
+function popHydrationState(fiber) {
+
+  if (fiber !== hydrationParentFiber) {
+    // We're deeper than the current hydration context, inside an inserted
+    // tree.
+    return false;
+  }
+
+  if (!isHydrating) {
+    // If we're not currently hydrating but we're in a hydration context, then
+    // we were an insertion and now need to pop up reenter hydration of our
+    // siblings.
+    popToNextHostParent(fiber);
+    isHydrating = true;
+    return false;
+  }
+
+  let shouldClear = false;
+
+  {
+    // With float we never clear the Root, or Singleton instances. We also do not clear Instances
+    // that have singleton text content
+    if (fiber.tag !== HostRoot && fiber.tag !== HostSingleton && !(fiber.tag === HostComponent && (!shouldDeleteUnhydratedTailInstances(fiber.type) || shouldSetTextContent(fiber.type, fiber.memoizedProps)))) {
+      shouldClear = true;
+    }
+  }
+
+  if (shouldClear) {
+    let nextInstance = nextHydratableInstance;
+
+    if (nextInstance) {
+      if (shouldClientRenderOnMismatch(fiber)) {
+        warnIfUnhydratedTailNodes();
+        throwOnHydrationMismatch();
+      } else {
+        while (nextInstance) {
+          deleteHydratableInstance(fiber, nextInstance);
+          nextInstance = getNextHydratableSibling(nextInstance);
+        }
+      }
+    }
+  }
+
+  popToNextHostParent(fiber);
+
+  if (fiber.tag === SuspenseComponent) {
+    nextHydratableInstance = skipPastDehydratedSuspenseInstance(fiber);
+  } else {
+    nextHydratableInstance = hydrationParentFiber ? getNextHydratableSibling(fiber.stateNode) : null;
+  }
+
+  return true;
+}
+
+function hasUnhydratedTailNodes() {
+  return isHydrating && nextHydratableInstance !== null;
+}
+
+function warnIfUnhydratedTailNodes(fiber) {
+  let nextInstance = nextHydratableInstance;
+
+  while (nextInstance) {
+    nextInstance = getNextHydratableSibling(nextInstance);
+  }
+}
+
+function resetHydrationState() {
+
+  hydrationParentFiber = null;
+  nextHydratableInstance = null;
+  isHydrating = false;
+}
+
+function upgradeHydrationErrorsToRecoverable() {
+  if (hydrationErrors !== null) {
+    // Successfully completed a forced client render. The errors that occurred
+    // during the hydration attempt are now recovered. We will log them in
+    // commit phase, once the entire tree has finished.
+    queueRecoverableErrors(hydrationErrors);
+    hydrationErrors = null;
+  }
+}
+
+function getIsHydrating() {
+  return isHydrating;
+}
+
+function queueHydrationError(error) {
+  if (hydrationErrors === null) {
+    hydrationErrors = [error];
+  } else {
+    hydrationErrors.push(error);
+  }
+}
+
+// we wait until the current render is over (either finished or interrupted)
+// before adding it to the fiber/hook queue. Push to this array so we can
+// access the queue, fiber, update, et al later.
+
+const concurrentQueues = [];
+let concurrentQueuesIndex = 0;
+let concurrentlyUpdatedLanes = NoLanes;
+function finishQueueingConcurrentUpdates() {
+  const endIndex = concurrentQueuesIndex;
+  concurrentQueuesIndex = 0;
+  concurrentlyUpdatedLanes = NoLanes;
+  let i = 0;
+
+  while (i < endIndex) {
+    const fiber = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    const queue = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    const update = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    const lane = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+
+    if (queue !== null && update !== null) {
+      const pending = queue.pending;
+
+      if (pending === null) {
+        // This is the first update. Create a circular list.
+        update.next = update;
+      } else {
+        update.next = pending.next;
+        pending.next = update;
+      }
+
+      queue.pending = update;
+    }
+
+    if (lane !== NoLane) {
+      markUpdateLaneFromFiberToRoot(fiber, update, lane);
+    }
+  }
+}
+function getConcurrentlyUpdatedLanes() {
+  return concurrentlyUpdatedLanes;
+}
+
+function enqueueUpdate$1(fiber, queue, update, lane) {
+  // Don't update the `childLanes` on the return path yet. If we already in
+  // the middle of rendering, wait until after it has completed.
+  concurrentQueues[concurrentQueuesIndex++] = fiber;
+  concurrentQueues[concurrentQueuesIndex++] = queue;
+  concurrentQueues[concurrentQueuesIndex++] = update;
+  concurrentQueues[concurrentQueuesIndex++] = lane;
+  concurrentlyUpdatedLanes = mergeLanes(concurrentlyUpdatedLanes, lane); // The fiber's `lane` field is used in some places to check if any work is
+  // scheduled, to perform an eager bailout, so we need to update it immediately.
+  // TODO: We should probably move this to the "shared" queue instead.
+
+  fiber.lanes = mergeLanes(fiber.lanes, lane);
+  const alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, lane);
+  }
+}
+
+function enqueueConcurrentHookUpdate(fiber, queue, update, lane) {
+  const concurrentQueue = queue;
+  const concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane);
+  return getRootForUpdatedFiber(fiber);
+}
+function enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update) {
+  // This function is used to queue an update that doesn't need a rerender. The
+  // only reason we queue it is in case there's a subsequent higher priority
+  // update that causes it to be rebased.
+  const lane = NoLane;
+  const concurrentQueue = queue;
+  const concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane); // Usually we can rely on the upcoming render phase to process the concurrent
+  // queue. However, since this is a bail out, we're not scheduling any work
+  // here. So the update we just queued will leak until something else happens
+  // to schedule work (if ever).
+  //
+  // Check if we're currently in the middle of rendering a tree, and if not,
+  // process the queue immediately to prevent a leak.
+
+  const isConcurrentlyRendering = getWorkInProgressRoot() !== null;
+
+  if (!isConcurrentlyRendering) {
+    finishQueueingConcurrentUpdates();
+  }
+}
+function enqueueConcurrentClassUpdate(fiber, queue, update, lane) {
+  const concurrentQueue = queue;
+  const concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane);
+  return getRootForUpdatedFiber(fiber);
+}
+function enqueueConcurrentRenderForLane(fiber, lane) {
+  enqueueUpdate$1(fiber, null, null, lane);
+  return getRootForUpdatedFiber(fiber);
+} // Calling this function outside this module should only be done for backwards
+// compatibility and should always be accompanied by a warning.
+
+function unsafe_markUpdateLaneFromFiberToRoot(sourceFiber, lane) {
+  // NOTE: For Hyrum's Law reasons, if an infinite update loop is detected, it
+  // should throw before `markUpdateLaneFromFiberToRoot` is called. But this is
+  // undefined behavior and we can change it if we need to; it just so happens
+  // that, at the time of this writing, there's an internal product test that
+  // happens to rely on this.
+  const root = getRootForUpdatedFiber(sourceFiber);
+  markUpdateLaneFromFiberToRoot(sourceFiber, null, lane);
+  return root;
+}
+
+function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
+  // Update the source fiber's lanes
+  sourceFiber.lanes = mergeLanes(sourceFiber.lanes, lane);
+  let alternate = sourceFiber.alternate;
+
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, lane);
+  } // Walk the parent path to the root and update the child lanes.
+
+
+  let isHidden = false;
+  let parent = sourceFiber.return;
+  let node = sourceFiber;
+
+  while (parent !== null) {
+    parent.childLanes = mergeLanes(parent.childLanes, lane);
+    alternate = parent.alternate;
+
+    if (alternate !== null) {
+      alternate.childLanes = mergeLanes(alternate.childLanes, lane);
+    }
+
+    if (parent.tag === OffscreenComponent) {
+      // Check if this offscreen boundary is currently hidden.
+      //
+      // The instance may be null if the Offscreen parent was unmounted. Usually
+      // the parent wouldn't be reachable in that case because we disconnect
+      // fibers from the tree when they are deleted. However, there's a weird
+      // edge case where setState is called on a fiber that was interrupted
+      // before it ever mounted. Because it never mounts, it also never gets
+      // deleted. Because it never gets deleted, its return pointer never gets
+      // disconnected. Which means it may be attached to a deleted Offscreen
+      // parent node. (This discovery suggests it may be better for memory usage
+      // if we don't attach the `return` pointer until the commit phase, though
+      // in order to do that we'd need some other way to track the return
+      // pointer during the initial render, like on the stack.)
+      //
+      // This case is always accompanied by a warning, but we still need to
+      // account for it. (There may be other cases that we haven't discovered,
+      // too.)
+      const offscreenInstance = parent.stateNode;
+
+      if (offscreenInstance !== null && !(offscreenInstance._visibility & OffscreenVisible)) {
+        isHidden = true;
+      }
+    }
+
+    node = parent;
+    parent = parent.return;
+  }
+
+  if (isHidden && update !== null && node.tag === HostRoot) {
+    const root = node.stateNode;
+    markHiddenUpdate(root, update, lane);
+  }
+}
+
+function getRootForUpdatedFiber(sourceFiber) {
+  // TODO: We will detect and infinite update loop and throw even if this fiber
+  // has already unmounted. This isn't really necessary but it happens to be the
+  // current behavior we've used for several release cycles. Consider not
+  // performing this check if the updated fiber already unmounted, since it's
+  // not possible for that to cause an infinite update loop.
+  throwIfInfiniteUpdateLoopDetected(); // When a setState happens, we must ensure the root is scheduled. Because
+  let node = sourceFiber;
+  let parent = node.return;
+
+  while (parent !== null) {
+    node = parent;
+    parent = node.return;
+  }
+
+  return node.tag === HostRoot ? node.stateNode : null;
+}
+
+const UpdateState = 0;
+const ReplaceState = 1;
+const ForceUpdate = 2;
+const CaptureUpdate = 3; // Global state that is reset at the beginning of calling `processUpdateQueue`.
+// It should only be read right after calling `processUpdateQueue`, via
+// `checkHasForceUpdateAfterProcessing`.
+
+let hasForceUpdate = false;
+
+function initializeUpdateQueue(fiber) {
+  const queue = {
+    baseState: fiber.memoizedState,
+    firstBaseUpdate: null,
+    lastBaseUpdate: null,
+    shared: {
+      pending: null,
+      lanes: NoLanes,
+      hiddenCallbacks: null
+    },
+    callbacks: null
+  };
+  fiber.updateQueue = queue;
+}
+function cloneUpdateQueue(current, workInProgress) {
+  // Clone the update queue from current. Unless it's already a clone.
+  const queue = workInProgress.updateQueue;
+  const currentQueue = current.updateQueue;
+
+  if (queue === currentQueue) {
+    const clone = {
+      baseState: currentQueue.baseState,
+      firstBaseUpdate: currentQueue.firstBaseUpdate,
+      lastBaseUpdate: currentQueue.lastBaseUpdate,
+      shared: currentQueue.shared,
+      callbacks: null
+    };
+    workInProgress.updateQueue = clone;
+  }
+}
+function createUpdate(lane) {
+  const update = {
+    lane,
+    tag: UpdateState,
+    payload: null,
+    callback: null,
+    next: null
+  };
+  return update;
+}
+function enqueueUpdate(fiber, update, lane) {
+  const updateQueue = fiber.updateQueue;
+
+  if (updateQueue === null) {
+    // Only occurs if the fiber has been unmounted.
+    return null;
+  }
+
+  const sharedQueue = updateQueue.shared;
+
+  if (isUnsafeClassRenderPhaseUpdate()) {
+    // This is an unsafe render phase update. Add directly to the update
+    // queue so we can process it immediately during the current render.
+    const pending = sharedQueue.pending;
+
+    if (pending === null) {
+      // This is the first update. Create a circular list.
+      update.next = update;
+    } else {
+      update.next = pending.next;
+      pending.next = update;
+    }
+
+    sharedQueue.pending = update; // Update the childLanes even though we're most likely already rendering
+    // this fiber. This is for backwards compatibility in the case where you
+    // update a different component during render phase than the one that is
+    // currently renderings (a pattern that is accompanied by a warning).
+
+    return unsafe_markUpdateLaneFromFiberToRoot(fiber, lane);
+  } else {
+    return enqueueConcurrentClassUpdate(fiber, sharedQueue, update, lane);
+  }
+}
+function entangleTransitions(root, fiber, lane) {
+  const updateQueue = fiber.updateQueue;
+
+  if (updateQueue === null) {
+    // Only occurs if the fiber has been unmounted.
+    return;
+  }
+
+  const sharedQueue = updateQueue.shared;
+
+  if (isTransitionLane(lane)) {
+    let queueLanes = sharedQueue.lanes; // If any entangled lanes are no longer pending on the root, then they must
+    // have finished. We can remove them from the shared queue, which represents
+    // a superset of the actually pending lanes. In some cases we may entangle
+    // more than we need to, but that's OK. In fact it's worse if we *don't*
+    // entangle when we should.
+
+    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.
+
+    const newQueueLanes = mergeLanes(queueLanes, lane);
+    sharedQueue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if
+    // the lane finished since the last time we entangled it. So we need to
+    // entangle it again, just to be sure.
+
+    markRootEntangled(root, newQueueLanes);
+  }
+}
+function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
+  // Captured updates are updates that are thrown by a child during the render
+  // phase. They should be discarded if the render is aborted. Therefore,
+  // we should only put them on the work-in-progress queue, not the current one.
+  let queue = workInProgress.updateQueue; // Check if the work-in-progress queue is a clone.
+
+  const current = workInProgress.alternate;
+
+  if (current !== null) {
+    const currentQueue = current.updateQueue;
+
+    if (queue === currentQueue) {
+      // The work-in-progress queue is the same as current. This happens when
+      // we bail out on a parent fiber that then captures an error thrown by
+      // a child. Since we want to append the update only to the work-in
+      // -progress queue, we need to clone the updates. We usually clone during
+      // processUpdateQueue, but that didn't happen in this case because we
+      // skipped over the parent when we bailed out.
+      let newFirst = null;
+      let newLast = null;
+      const firstBaseUpdate = queue.firstBaseUpdate;
+
+      if (firstBaseUpdate !== null) {
+        // Loop through the updates and clone them.
+        let update = firstBaseUpdate;
+
+        do {
+          const clone = {
+            lane: update.lane,
+            tag: update.tag,
+            payload: update.payload,
+            // When this update is rebased, we should not fire its
+            // callback again.
+            callback: null,
+            next: null
+          };
+
+          if (newLast === null) {
+            newFirst = newLast = clone;
+          } else {
+            newLast.next = clone;
+            newLast = clone;
+          } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+          update = update.next;
+        } while (update !== null); // Append the captured update the end of the cloned list.
+
+
+        if (newLast === null) {
+          newFirst = newLast = capturedUpdate;
+        } else {
+          newLast.next = capturedUpdate;
+          newLast = capturedUpdate;
+        }
+      } else {
+        // There are no base updates.
+        newFirst = newLast = capturedUpdate;
+      }
+
+      queue = {
+        baseState: currentQueue.baseState,
+        firstBaseUpdate: newFirst,
+        lastBaseUpdate: newLast,
+        shared: currentQueue.shared,
+        callbacks: currentQueue.callbacks
+      };
+      workInProgress.updateQueue = queue;
+      return;
+    }
+  } // Append the update to the end of the list.
+
+
+  const lastBaseUpdate = queue.lastBaseUpdate;
+
+  if (lastBaseUpdate === null) {
+    queue.firstBaseUpdate = capturedUpdate;
+  } else {
+    lastBaseUpdate.next = capturedUpdate;
+  }
+
+  queue.lastBaseUpdate = capturedUpdate;
+}
+
+function getStateFromUpdate(workInProgress, queue, update, prevState, nextProps, instance) {
+  switch (update.tag) {
+    case ReplaceState:
+      {
+        const payload = update.payload;
+
+        if (typeof payload === 'function') {
+
+          const nextState = payload.call(instance, prevState, nextProps);
+
+          return nextState;
+        } // State object
+
+
+        return payload;
+      }
+
+    case CaptureUpdate:
+      {
+        workInProgress.flags = workInProgress.flags & ~ShouldCapture | DidCapture;
+      }
+    // Intentional fallthrough
+
+    case UpdateState:
+      {
+        const payload = update.payload;
+        let partialState;
+
+        if (typeof payload === 'function') {
+
+          partialState = payload.call(instance, prevState, nextProps);
+        } else {
+          // Partial state object
+          partialState = payload;
+        }
+
+        if (partialState === null || partialState === undefined) {
+          // Null and undefined are treated as no-ops.
+          return prevState;
+        } // Merge the partial state and the previous state.
+
+
+        return assign({}, prevState, partialState);
+      }
+
+    case ForceUpdate:
+      {
+        hasForceUpdate = true;
+        return prevState;
+      }
+  }
+
+  return prevState;
+}
+
+function processUpdateQueue(workInProgress, props, instance, renderLanes) {
+  // This is always non-null on a ClassComponent or HostRoot
+  const queue = workInProgress.updateQueue;
+  hasForceUpdate = false;
+
+  let firstBaseUpdate = queue.firstBaseUpdate;
+  let lastBaseUpdate = queue.lastBaseUpdate; // Check if there are pending updates. If so, transfer them to the base queue.
+
+  let pendingQueue = queue.shared.pending;
+
+  if (pendingQueue !== null) {
+    queue.shared.pending = null; // The pending queue is circular. Disconnect the pointer between first
+    // and last so that it's non-circular.
+
+    const lastPendingUpdate = pendingQueue;
+    const firstPendingUpdate = lastPendingUpdate.next;
+    lastPendingUpdate.next = null; // Append pending updates to base queue
+
+    if (lastBaseUpdate === null) {
+      firstBaseUpdate = firstPendingUpdate;
+    } else {
+      lastBaseUpdate.next = firstPendingUpdate;
+    }
+
+    lastBaseUpdate = lastPendingUpdate; // If there's a current queue, and it's different from the base queue, then
+    // we need to transfer the updates to that queue, too. Because the base
+    // queue is a singly-linked list with no cycles, we can append to both
+    // lists and take advantage of structural sharing.
+    // TODO: Pass `current` as argument
+
+    const current = workInProgress.alternate;
+
+    if (current !== null) {
+      // This is always non-null on a ClassComponent or HostRoot
+      const currentQueue = current.updateQueue;
+      const currentLastBaseUpdate = currentQueue.lastBaseUpdate;
+
+      if (currentLastBaseUpdate !== lastBaseUpdate) {
+        if (currentLastBaseUpdate === null) {
+          currentQueue.firstBaseUpdate = firstPendingUpdate;
+        } else {
+          currentLastBaseUpdate.next = firstPendingUpdate;
+        }
+
+        currentQueue.lastBaseUpdate = lastPendingUpdate;
+      }
+    }
+  } // These values may change as we process the queue.
+
+
+  if (firstBaseUpdate !== null) {
+    // Iterate through the list of updates to compute the result.
+    let newState = queue.baseState; // TODO: Don't need to accumulate this. Instead, we can remove renderLanes
+    // from the original lanes.
+
+    let newLanes = NoLanes;
+    let newBaseState = null;
+    let newFirstBaseUpdate = null;
+    let newLastBaseUpdate = null;
+    let update = firstBaseUpdate;
+
+    do {
+      // An extra OffscreenLane bit is added to updates that were made to
+      // a hidden tree, so that we can distinguish them from updates that were
+      // already there when the tree was hidden.
+      const updateLane = removeLanes(update.lane, OffscreenLane);
+      const isHiddenUpdate = updateLane !== update.lane; // Check if this update was made while the tree was hidden. If so, then
+      // it's not a "base" update and we should disregard the extra base lanes
+      // that were added to renderLanes when we entered the Offscreen tree.
+
+      const shouldSkipUpdate = isHiddenUpdate ? !isSubsetOfLanes(getWorkInProgressRootRenderLanes(), updateLane) : !isSubsetOfLanes(renderLanes, updateLane);
+
+      if (shouldSkipUpdate) {
+        // Priority is insufficient. Skip this update. If this is the first
+        // skipped update, the previous update/state is the new base
+        // update/state.
+        const clone = {
+          lane: updateLane,
+          tag: update.tag,
+          payload: update.payload,
+          callback: update.callback,
+          next: null
+        };
+
+        if (newLastBaseUpdate === null) {
+          newFirstBaseUpdate = newLastBaseUpdate = clone;
+          newBaseState = newState;
+        } else {
+          newLastBaseUpdate = newLastBaseUpdate.next = clone;
+        } // Update the remaining priority in the queue.
+
+
+        newLanes = mergeLanes(newLanes, updateLane);
+      } else {
+        // This update does have sufficient priority.
+        if (newLastBaseUpdate !== null) {
+          const clone = {
+            // This update is going to be committed so we never want uncommit
+            // it. Using NoLane works because 0 is a subset of all bitmasks, so
+            // this will never be skipped by the check above.
+            lane: NoLane,
+            tag: update.tag,
+            payload: update.payload,
+            // When this update is rebased, we should not fire its
+            // callback again.
+            callback: null,
+            next: null
+          };
+          newLastBaseUpdate = newLastBaseUpdate.next = clone;
+        } // Process this update.
+
+
+        newState = getStateFromUpdate(workInProgress, queue, update, newState, props, instance);
+        const callback = update.callback;
+
+        if (callback !== null) {
+          workInProgress.flags |= Callback;
+
+          if (isHiddenUpdate) {
+            workInProgress.flags |= Visibility;
+          }
+
+          const callbacks = queue.callbacks;
+
+          if (callbacks === null) {
+            queue.callbacks = [callback];
+          } else {
+            callbacks.push(callback);
+          }
+        }
+      } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+      update = update.next;
+
+      if (update === null) {
+        pendingQueue = queue.shared.pending;
+
+        if (pendingQueue === null) {
+          break;
+        } else {
+          // An update was scheduled from inside a reducer. Add the new
+          // pending updates to the end of the list and keep processing.
+          const lastPendingUpdate = pendingQueue; // Intentionally unsound. Pending updates form a circular list, but we
+          // unravel them when transferring them to the base queue.
+
+          const firstPendingUpdate = lastPendingUpdate.next;
+          lastPendingUpdate.next = null;
+          update = firstPendingUpdate;
+          queue.lastBaseUpdate = lastPendingUpdate;
+          queue.shared.pending = null;
+        }
+      }
+    } while (true);
+
+    if (newLastBaseUpdate === null) {
+      newBaseState = newState;
+    }
+
+    queue.baseState = newBaseState;
+    queue.firstBaseUpdate = newFirstBaseUpdate;
+    queue.lastBaseUpdate = newLastBaseUpdate;
+
+    if (firstBaseUpdate === null) {
+      // `queue.lanes` is used for entangling transitions. We can set it back to
+      // zero once the queue is empty.
+      queue.shared.lanes = NoLanes;
+    } // Set the remaining expiration time to be whatever is remaining in the queue.
+    // This should be fine because the only two other things that contribute to
+    // expiration time are props and context. We're already in the middle of the
+    // begin phase by the time we start processing the queue, so we've already
+    // dealt with the props. Context in components that specify
+    // shouldComponentUpdate is tricky; but we'll have to account for
+    // that regardless.
+
+
+    markSkippedUpdateLanes(newLanes);
+    workInProgress.lanes = newLanes;
+    workInProgress.memoizedState = newState;
+  }
+}
+
+function callCallback(callback, context) {
+  if (typeof callback !== 'function') {
+    throw Error(formatProdErrorMessage(191, callback));
+  }
+
+  callback.call(context);
+}
+
+function resetHasForceUpdateBeforeProcessing() {
+  hasForceUpdate = false;
+}
+function checkHasForceUpdateAfterProcessing() {
+  return hasForceUpdate;
+}
+function deferHiddenCallbacks(updateQueue) {
+  // When an update finishes on a hidden component, its callback should not
+  // be fired until/unless the component is made visible again. Stash the
+  // callback on the shared queue object so it can be fired later.
+  const newHiddenCallbacks = updateQueue.callbacks;
+
+  if (newHiddenCallbacks !== null) {
+    const existingHiddenCallbacks = updateQueue.shared.hiddenCallbacks;
+
+    if (existingHiddenCallbacks === null) {
+      updateQueue.shared.hiddenCallbacks = newHiddenCallbacks;
+    } else {
+      updateQueue.shared.hiddenCallbacks = existingHiddenCallbacks.concat(newHiddenCallbacks);
+    }
+  }
+}
+function commitHiddenCallbacks(updateQueue, context) {
+  // This component is switching from hidden -> visible. Commit any callbacks
+  // that were previously deferred.
+  const hiddenCallbacks = updateQueue.shared.hiddenCallbacks;
+
+  if (hiddenCallbacks !== null) {
+    updateQueue.shared.hiddenCallbacks = null;
+
+    for (let i = 0; i < hiddenCallbacks.length; i++) {
+      const callback = hiddenCallbacks[i];
+      callCallback(callback, context);
+    }
+  }
+}
+function commitCallbacks(updateQueue, context) {
+  const callbacks = updateQueue.callbacks;
+
+  if (callbacks !== null) {
+    updateQueue.callbacks = null;
+
+    for (let i = 0; i < callbacks.length; i++) {
+      const callback = callbacks[i];
+      callCallback(callback, context);
+    }
+  }
+}
+
+/**
+ * Performs equality by iterating through keys on an object and returning false
+ * when any key has values which are not strictly equal between the arguments.
+ * Returns true when the values of all keys are strictly equal.
+ */
+
+function shallowEqual(objA, objB) {
+  if (objectIs(objA, objB)) {
+    return true;
+  }
+
+  if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
+    return false;
+  }
+
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+
+  if (keysA.length !== keysB.length) {
+    return false;
+  } // Test for A's keys different from B.
+
+
+  for (let i = 0; i < keysA.length; i++) {
+    const currentKey = keysA[i];
+
+    if (!hasOwnProperty.call(objB, currentKey) || // $FlowFixMe[incompatible-use] lost refinement of `objB`
+    !objectIs(objA[currentKey], objB[currentKey])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+// detect this is caught by userspace, we'll log a warning in development.
+
+const SuspenseException = Error(formatProdErrorMessage(460));
+const SuspenseyCommitException = Error(formatProdErrorMessage(474)); // This is a noop thenable that we use to trigger a fallback in throwException.
+// TODO: It would be better to refactor throwException into multiple functions
+// so we can trigger a fallback directly without having to check the type. But
+// for now this will do.
+
+const noopSuspenseyCommitThenable = {
+  then() {
+  }
+
+};
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+function isThenableResolved(thenable) {
+  const status = thenable.status;
+  return status === 'fulfilled' || status === 'rejected';
+}
+
+function noop$2() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop$2, noop$2);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        checkIfUseWrappedInAsyncCatch(rejectedError);
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          // Attach a dummy listener, to ensure that any lazy initialization can
+          // happen. Flight lazily parses JSON when the value is actually awaited.
+          thenable.then(noop$2, noop$2);
+        } else {
+          // This is an uncached thenable that we haven't seen before.
+          // Detect infinite ping loops caused by uncached promises.
+          const root = getWorkInProgressRoot();
+
+          if (root !== null && root.shellSuspendCounter > 100) {
+            // This root has suspended repeatedly in the shell without making any
+            // progress (i.e. committing something). This is highly suggestive of
+            // an infinite ping loop, often caused by an accidental Async Client
+            // Component.
+            //
+            // During a transition, we can suspend the work loop until the promise
+            // to resolve, but this is a sync render, so that's not an option. We
+            // also can't show a fallback, because none was provided. So our last
+            // resort is to throw an error.
+            //
+            // TODO: Remove this error in a future release. Other ways of handling
+            // this case include forcing a concurrent render, or putting the whole
+            // root into offscreen mode.
+            throw Error(formatProdErrorMessage(482));
+          }
+
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously.
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                const rejectedError = rejectedThenable.reason;
+                checkIfUseWrappedInAsyncCatch(rejectedError);
+                throw rejectedError;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+
+        throw SuspenseException;
+      }
+  }
+}
+function suspendCommit() {
+  // This extra indirection only exists so it can handle passing
+  // noopSuspenseyCommitThenable through to throwException.
+  // TODO: Factor the thenable check out of throwException
+  suspendedThenable = noopSuspenseyCommitThenable;
+  throw SuspenseyCommitException;
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw Error(formatProdErrorMessage(459));
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+
+  return thenable;
+}
+function checkIfUseWrappedInAsyncCatch(rejectedReason) {
+  // This check runs in prod, too, because it prevents a more confusing
+  // downstream error, where SuspenseException is caught by a promise and
+  // thrown asynchronously.
+  // TODO: Another way to prevent SuspenseException from leaking into an async
+  // execution context is to check the dispatcher every time `use` is called,
+  // or some equivalent. That might be preferable for other reasons, too, since
+  // it matches how we prevent similar mistakes for other hooks.
+  if (rejectedReason === SuspenseException) {
+    throw Error(formatProdErrorMessage(483));
+  }
+}
+
+let thenableState$1 = null;
+let thenableIndexCounter$1 = 0;
+
+function unwrapThenable(thenable) {
+  const index = thenableIndexCounter$1;
+  thenableIndexCounter$1 += 1;
+
+  if (thenableState$1 === null) {
+    thenableState$1 = createThenableState();
+  }
+
+  return trackUsedThenable(thenableState$1, thenable, index);
+}
+
+function coerceRef(returnFiber, current, element) {
+  const mixedRef = element.ref;
+
+  if (mixedRef !== null && typeof mixedRef !== 'function' && typeof mixedRef !== 'object') {
+
+    if (element._owner) {
+      const owner = element._owner;
+      let inst;
+
+      if (owner) {
+        const ownerFiber = owner;
+
+        if (ownerFiber.tag !== ClassComponent) {
+          throw Error(formatProdErrorMessage(309));
+        }
+
+        inst = ownerFiber.stateNode;
+      }
+
+      if (!inst) {
+        throw Error(formatProdErrorMessage(147, mixedRef));
+      } // Assigning this to a const so Flow knows it won't change in the closure
+
+
+      const resolvedInst = inst;
+
+      const stringRef = '' + mixedRef; // Check if previous string ref matches new string ref
+
+      if (current !== null && current.ref !== null && typeof current.ref === 'function' && current.ref._stringRef === stringRef) {
+        return current.ref;
+      }
+
+      const ref = function (value) {
+        const refs = resolvedInst.refs;
+
+        if (value === null) {
+          delete refs[stringRef];
+        } else {
+          refs[stringRef] = value;
+        }
+      };
+
+      ref._stringRef = stringRef;
+      return ref;
+    } else {
+      if (typeof mixedRef !== 'string') {
+        throw Error(formatProdErrorMessage(284));
+      }
+
+      if (!element._owner) {
+        throw Error(formatProdErrorMessage(290, mixedRef));
+      }
+    }
+  }
+
+  return mixedRef;
+}
+
+function throwOnInvalidObjectType(returnFiber, newChild) {
+  // $FlowFixMe[method-unbinding]
+  const childString = Object.prototype.toString.call(newChild);
+  throw Error(formatProdErrorMessage(31, childString === '[object Object]' ? 'object with keys {' + Object.keys(newChild).join(', ') + '}' : childString));
+}
+
+function resolveLazy(lazyType) {
+  const payload = lazyType._payload;
+  const init = lazyType._init;
+  return init(payload);
+} // This wrapper function exists because I expect to clone the code in each path
+// to be able to optimize each path individually by branching early. This needs
+// a compiler or we can do it manually. Helpers that don't need this branching
+// live outside of this function.
+
+
+function createChildReconciler(shouldTrackSideEffects) {
+  function deleteChild(returnFiber, childToDelete) {
+    if (!shouldTrackSideEffects) {
+      // Noop.
+      return;
+    }
+
+    const deletions = returnFiber.deletions;
+
+    if (deletions === null) {
+      returnFiber.deletions = [childToDelete];
+      returnFiber.flags |= ChildDeletion;
+    } else {
+      deletions.push(childToDelete);
+    }
+  }
+
+  function deleteRemainingChildren(returnFiber, currentFirstChild) {
+    if (!shouldTrackSideEffects) {
+      // Noop.
+      return null;
+    } // TODO: For the shouldClone case, this could be micro-optimized a bit by
+    // assuming that after the first child we've already added everything.
+
+
+    let childToDelete = currentFirstChild;
+
+    while (childToDelete !== null) {
+      deleteChild(returnFiber, childToDelete);
+      childToDelete = childToDelete.sibling;
+    }
+
+    return null;
+  }
+
+  function mapRemainingChildren(returnFiber, currentFirstChild) {
+    // Add the remaining children to a temporary map so that we can find them by
+    // keys quickly. Implicit (null) keys get added to this set with their index
+    // instead.
+    const existingChildren = new Map();
+    let existingChild = currentFirstChild;
+
+    while (existingChild !== null) {
+      if (existingChild.key !== null) {
+        existingChildren.set(existingChild.key, existingChild);
+      } else {
+        existingChildren.set(existingChild.index, existingChild);
+      }
+
+      existingChild = existingChild.sibling;
+    }
+
+    return existingChildren;
+  }
+
+  function useFiber(fiber, pendingProps) {
+    // We currently set sibling to null and index to 0 here because it is easy
+    // to forget to do before returning it. E.g. for the single child case.
+    const clone = createWorkInProgress(fiber, pendingProps);
+    clone.index = 0;
+    clone.sibling = null;
+    return clone;
+  }
+
+  function placeChild(newFiber, lastPlacedIndex, newIndex) {
+    newFiber.index = newIndex;
+
+    if (!shouldTrackSideEffects) {
+      // During hydration, the useId algorithm needs to know which fibers are
+      // part of a list of children (arrays, iterators).
+      newFiber.flags |= Forked;
+      return lastPlacedIndex;
+    }
+
+    const current = newFiber.alternate;
+
+    if (current !== null) {
+      const oldIndex = current.index;
+
+      if (oldIndex < lastPlacedIndex) {
+        // This is a move.
+        newFiber.flags |= Placement | PlacementDEV;
+        return lastPlacedIndex;
+      } else {
+        // This item can stay in place.
+        return oldIndex;
+      }
+    } else {
+      // This is an insertion.
+      newFiber.flags |= Placement | PlacementDEV;
+      return lastPlacedIndex;
+    }
+  }
+
+  function placeSingleChild(newFiber) {
+    // This is simpler for the single child case. We only need to do a
+    // placement for inserting new children.
+    if (shouldTrackSideEffects && newFiber.alternate === null) {
+      newFiber.flags |= Placement | PlacementDEV;
+    }
+
+    return newFiber;
+  }
+
+  function updateTextNode(returnFiber, current, textContent, lanes) {
+    if (current === null || current.tag !== HostText) {
+      // Insert
+      const created = createFiberFromText(textContent, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      const existing = useFiber(current, textContent);
+      existing.return = returnFiber;
+      return existing;
+    }
+  }
+
+  function updateElement(returnFiber, current, element, lanes) {
+    const elementType = element.type;
+
+    if (elementType === REACT_FRAGMENT_TYPE) {
+      return updateFragment(returnFiber, current, element.props.children, lanes, element.key);
+    }
+
+    if (current !== null) {
+      if (current.elementType === elementType || ( // Keep this check inline so it only runs on the false path:
+      false) || // Lazy types should reconcile their resolved type.
+      // We need to do this after the Hot Reloading check above,
+      // because hot reloading has different semantics than prod because
+      // it doesn't resuspend. So we can't let the call below suspend.
+      typeof elementType === 'object' && elementType !== null && elementType.$$typeof === REACT_LAZY_TYPE && resolveLazy(elementType) === current.type) {
+        // Move based on index
+        const existing = useFiber(current, element.props);
+        existing.ref = coerceRef(returnFiber, current, element);
+        existing.return = returnFiber;
+
+        return existing;
+      }
+    } // Insert
+
+
+    const created = createFiberFromElement(element, returnFiber.mode, lanes);
+    created.ref = coerceRef(returnFiber, current, element);
+    created.return = returnFiber;
+    return created;
+  }
+
+  function updatePortal(returnFiber, current, portal, lanes) {
+    if (current === null || current.tag !== HostPortal || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation) {
+      // Insert
+      const created = createFiberFromPortal(portal, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      const existing = useFiber(current, portal.children || []);
+      existing.return = returnFiber;
+      return existing;
+    }
+  }
+
+  function updateFragment(returnFiber, current, fragment, lanes, key) {
+    if (current === null || current.tag !== Fragment) {
+      // Insert
+      const created = createFiberFromFragment(fragment, returnFiber.mode, lanes, key);
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      const existing = useFiber(current, fragment);
+      existing.return = returnFiber;
+      return existing;
+    }
+  }
+
+  function createChild(returnFiber, newChild, lanes) {
+    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {
+      // Text nodes don't have keys. If the previous node is implicitly keyed
+      // we can continue to replace it without aborting even if it is not a text
+      // node.
+      const created = createFiberFromText('' + newChild, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    }
+
+    if (typeof newChild === 'object' && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const created = createFiberFromElement(newChild, returnFiber.mode, lanes);
+            created.ref = coerceRef(returnFiber, null, newChild);
+            created.return = returnFiber;
+            return created;
+          }
+
+        case REACT_PORTAL_TYPE:
+          {
+            const created = createFiberFromPortal(newChild, returnFiber.mode, lanes);
+            created.return = returnFiber;
+            return created;
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = newChild._payload;
+            const init = newChild._init;
+            return createChild(returnFiber, init(payload), lanes);
+          }
+      }
+
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        const created = createFiberFromFragment(newChild, returnFiber.mode, lanes, null);
+        created.return = returnFiber;
+        return created;
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
+
+
+      if (typeof newChild.then === 'function') {
+        const thenable = newChild;
+        return createChild(returnFiber, unwrapThenable(thenable), lanes);
+      }
+
+      if (newChild.$$typeof === REACT_CONTEXT_TYPE || newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+        const context = newChild;
+        return createChild(returnFiber, readContextDuringReconcilation(returnFiber, context, lanes), lanes);
+      }
+
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+
+    return null;
+  }
+
+  function updateSlot(returnFiber, oldFiber, newChild, lanes) {
+    // Update the fiber if the keys match, otherwise return null.
+    const key = oldFiber !== null ? oldFiber.key : null;
+
+    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {
+      // Text nodes don't have keys. If the previous node is implicitly keyed
+      // we can continue to replace it without aborting even if it is not a text
+      // node.
+      if (key !== null) {
+        return null;
+      }
+
+      return updateTextNode(returnFiber, oldFiber, '' + newChild, lanes);
+    }
+
+    if (typeof newChild === 'object' && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            if (newChild.key === key) {
+              return updateElement(returnFiber, oldFiber, newChild, lanes);
+            } else {
+              return null;
+            }
+          }
+
+        case REACT_PORTAL_TYPE:
+          {
+            if (newChild.key === key) {
+              return updatePortal(returnFiber, oldFiber, newChild, lanes);
+            } else {
+              return null;
+            }
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = newChild._payload;
+            const init = newChild._init;
+            return updateSlot(returnFiber, oldFiber, init(payload), lanes);
+          }
+      }
+
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        if (key !== null) {
+          return null;
+        }
+
+        return updateFragment(returnFiber, oldFiber, newChild, lanes, null);
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
+
+
+      if (typeof newChild.then === 'function') {
+        const thenable = newChild;
+        return updateSlot(returnFiber, oldFiber, unwrapThenable(thenable), lanes);
+      }
+
+      if (newChild.$$typeof === REACT_CONTEXT_TYPE || newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+        const context = newChild;
+        return updateSlot(returnFiber, oldFiber, readContextDuringReconcilation(returnFiber, context, lanes), lanes);
+      }
+
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+
+    return null;
+  }
+
+  function updateFromMap(existingChildren, returnFiber, newIdx, newChild, lanes) {
+    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {
+      // Text nodes don't have keys, so we neither have to check the old nor
+      // new node for the key. If both are text nodes, they match.
+      const matchedFiber = existingChildren.get(newIdx) || null;
+      return updateTextNode(returnFiber, matchedFiber, '' + newChild, lanes);
+    }
+
+    if (typeof newChild === 'object' && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const matchedFiber = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;
+            return updateElement(returnFiber, matchedFiber, newChild, lanes);
+          }
+
+        case REACT_PORTAL_TYPE:
+          {
+            const matchedFiber = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;
+            return updatePortal(returnFiber, matchedFiber, newChild, lanes);
+          }
+
+        case REACT_LAZY_TYPE:
+          const payload = newChild._payload;
+          const init = newChild._init;
+          return updateFromMap(existingChildren, returnFiber, newIdx, init(payload), lanes);
+      }
+
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        const matchedFiber = existingChildren.get(newIdx) || null;
+        return updateFragment(returnFiber, matchedFiber, newChild, lanes, null);
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
+
+
+      if (typeof newChild.then === 'function') {
+        const thenable = newChild;
+        return updateFromMap(existingChildren, returnFiber, newIdx, unwrapThenable(thenable), lanes);
+      }
+
+      if (newChild.$$typeof === REACT_CONTEXT_TYPE || newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+        const context = newChild;
+        return updateFromMap(existingChildren, returnFiber, newIdx, readContextDuringReconcilation(returnFiber, context, lanes), lanes);
+      }
+
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+
+    return null;
+  }
+
+  function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, lanes) {
+
+    let resultingFirstChild = null;
+    let previousNewFiber = null;
+    let oldFiber = currentFirstChild;
+    let lastPlacedIndex = 0;
+    let newIdx = 0;
+    let nextOldFiber = null;
+
+    for (; oldFiber !== null && newIdx < newChildren.length; newIdx++) {
+      if (oldFiber.index > newIdx) {
+        nextOldFiber = oldFiber;
+        oldFiber = null;
+      } else {
+        nextOldFiber = oldFiber.sibling;
+      }
+
+      const newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], lanes);
+
+      if (newFiber === null) {
+        // TODO: This breaks on empty slots like null children. That's
+        // unfortunate because it triggers the slow path all the time. We need
+        // a better way to communicate whether this was a miss or null,
+        // boolean, undefined, etc.
+        if (oldFiber === null) {
+          oldFiber = nextOldFiber;
+        }
+
+        break;
+      }
+
+      if (shouldTrackSideEffects) {
+        if (oldFiber && newFiber.alternate === null) {
+          // We matched the slot, but we didn't reuse the existing fiber, so we
+          // need to delete the existing child.
+          deleteChild(returnFiber, oldFiber);
+        }
+      }
+
+      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+      if (previousNewFiber === null) {
+        // TODO: Move out of the loop. This only happens for the first run.
+        resultingFirstChild = newFiber;
+      } else {
+        // TODO: Defer siblings if we're not at the right index for this slot.
+        // I.e. if we had null values before, then we want to defer this
+        // for each null value. However, we also don't want to call updateSlot
+        // with the previous one.
+        previousNewFiber.sibling = newFiber;
+      }
+
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
+    }
+
+    if (newIdx === newChildren.length) {
+      // We've reached the end of the new children. We can delete the rest.
+      deleteRemainingChildren(returnFiber, oldFiber);
+
+      if (getIsHydrating()) {
+        const numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
+
+      return resultingFirstChild;
+    }
+
+    if (oldFiber === null) {
+      // If we don't have any more existing children we can choose a fast path
+      // since the rest will all be insertions.
+      for (; newIdx < newChildren.length; newIdx++) {
+        const newFiber = createChild(returnFiber, newChildren[newIdx], lanes);
+
+        if (newFiber === null) {
+          continue;
+        }
+
+        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          // TODO: Move out of the loop. This only happens for the first run.
+          resultingFirstChild = newFiber;
+        } else {
+          previousNewFiber.sibling = newFiber;
+        }
+
+        previousNewFiber = newFiber;
+      }
+
+      if (getIsHydrating()) {
+        const numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
+
+      return resultingFirstChild;
+    } // Add all children to a key map for quick lookups.
+
+
+    const existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
+
+    for (; newIdx < newChildren.length; newIdx++) {
+      const newFiber = updateFromMap(existingChildren, returnFiber, newIdx, newChildren[newIdx], lanes);
+
+      if (newFiber !== null) {
+        if (shouldTrackSideEffects) {
+          if (newFiber.alternate !== null) {
+            // The new fiber is a work in progress, but if there exists a
+            // current, that means that we reused the fiber. We need to delete
+            // it from the child list so that we don't add it to the deletion
+            // list.
+            existingChildren.delete(newFiber.key === null ? newIdx : newFiber.key);
+          }
+        }
+
+        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          resultingFirstChild = newFiber;
+        } else {
+          previousNewFiber.sibling = newFiber;
+        }
+
+        previousNewFiber = newFiber;
+      }
+    }
+
+    if (shouldTrackSideEffects) {
+      // Any existing children that weren't consumed above were deleted. We need
+      // to add them to the deletion list.
+      existingChildren.forEach(child => deleteChild(returnFiber, child));
+    }
+
+    if (getIsHydrating()) {
+      const numberOfForks = newIdx;
+      pushTreeFork(returnFiber, numberOfForks);
+    }
+
+    return resultingFirstChild;
+  }
+
+  function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildrenIterable, lanes) {
+    // This is the same implementation as reconcileChildrenArray(),
+    // but using the iterator instead.
+    const iteratorFn = getIteratorFn(newChildrenIterable);
+
+    if (typeof iteratorFn !== 'function') {
+      throw Error(formatProdErrorMessage(150));
+    }
+
+    const newChildren = iteratorFn.call(newChildrenIterable);
+
+    if (newChildren == null) {
+      throw Error(formatProdErrorMessage(151));
+    }
+
+    let resultingFirstChild = null;
+    let previousNewFiber = null;
+    let oldFiber = currentFirstChild;
+    let lastPlacedIndex = 0;
+    let newIdx = 0;
+    let nextOldFiber = null;
+    let step = newChildren.next();
+
+    for (; oldFiber !== null && !step.done; newIdx++, step = newChildren.next()) {
+      if (oldFiber.index > newIdx) {
+        nextOldFiber = oldFiber;
+        oldFiber = null;
+      } else {
+        nextOldFiber = oldFiber.sibling;
+      }
+
+      const newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
+
+      if (newFiber === null) {
+        // TODO: This breaks on empty slots like null children. That's
+        // unfortunate because it triggers the slow path all the time. We need
+        // a better way to communicate whether this was a miss or null,
+        // boolean, undefined, etc.
+        if (oldFiber === null) {
+          oldFiber = nextOldFiber;
+        }
+
+        break;
+      }
+
+      if (shouldTrackSideEffects) {
+        if (oldFiber && newFiber.alternate === null) {
+          // We matched the slot, but we didn't reuse the existing fiber, so we
+          // need to delete the existing child.
+          deleteChild(returnFiber, oldFiber);
+        }
+      }
+
+      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+      if (previousNewFiber === null) {
+        // TODO: Move out of the loop. This only happens for the first run.
+        resultingFirstChild = newFiber;
+      } else {
+        // TODO: Defer siblings if we're not at the right index for this slot.
+        // I.e. if we had null values before, then we want to defer this
+        // for each null value. However, we also don't want to call updateSlot
+        // with the previous one.
+        previousNewFiber.sibling = newFiber;
+      }
+
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
+    }
+
+    if (step.done) {
+      // We've reached the end of the new children. We can delete the rest.
+      deleteRemainingChildren(returnFiber, oldFiber);
+
+      if (getIsHydrating()) {
+        const numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
+
+      return resultingFirstChild;
+    }
+
+    if (oldFiber === null) {
+      // If we don't have any more existing children we can choose a fast path
+      // since the rest will all be insertions.
+      for (; !step.done; newIdx++, step = newChildren.next()) {
+        const newFiber = createChild(returnFiber, step.value, lanes);
+
+        if (newFiber === null) {
+          continue;
+        }
+
+        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          // TODO: Move out of the loop. This only happens for the first run.
+          resultingFirstChild = newFiber;
+        } else {
+          previousNewFiber.sibling = newFiber;
+        }
+
+        previousNewFiber = newFiber;
+      }
+
+      if (getIsHydrating()) {
+        const numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
+
+      return resultingFirstChild;
+    } // Add all children to a key map for quick lookups.
+
+
+    const existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
+
+    for (; !step.done; newIdx++, step = newChildren.next()) {
+      const newFiber = updateFromMap(existingChildren, returnFiber, newIdx, step.value, lanes);
+
+      if (newFiber !== null) {
+        if (shouldTrackSideEffects) {
+          if (newFiber.alternate !== null) {
+            // The new fiber is a work in progress, but if there exists a
+            // current, that means that we reused the fiber. We need to delete
+            // it from the child list so that we don't add it to the deletion
+            // list.
+            existingChildren.delete(newFiber.key === null ? newIdx : newFiber.key);
+          }
+        }
+
+        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          resultingFirstChild = newFiber;
+        } else {
+          previousNewFiber.sibling = newFiber;
+        }
+
+        previousNewFiber = newFiber;
+      }
+    }
+
+    if (shouldTrackSideEffects) {
+      // Any existing children that weren't consumed above were deleted. We need
+      // to add them to the deletion list.
+      existingChildren.forEach(child => deleteChild(returnFiber, child));
+    }
+
+    if (getIsHydrating()) {
+      const numberOfForks = newIdx;
+      pushTreeFork(returnFiber, numberOfForks);
+    }
+
+    return resultingFirstChild;
+  }
+
+  function reconcileSingleTextNode(returnFiber, currentFirstChild, textContent, lanes) {
+    // There's no need to check for keys on text nodes since we don't have a
+    // way to define them.
+    if (currentFirstChild !== null && currentFirstChild.tag === HostText) {
+      // We already have an existing node so let's just update it and delete
+      // the rest.
+      deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+      const existing = useFiber(currentFirstChild, textContent);
+      existing.return = returnFiber;
+      return existing;
+    } // The existing first child is not a text node so we need to create one
+    // and delete the existing ones.
+
+
+    deleteRemainingChildren(returnFiber, currentFirstChild);
+    const created = createFiberFromText(textContent, returnFiber.mode, lanes);
+    created.return = returnFiber;
+    return created;
+  }
+
+  function reconcileSingleElement(returnFiber, currentFirstChild, element, lanes) {
+    const key = element.key;
+    let child = currentFirstChild;
+
+    while (child !== null) {
+      // TODO: If key === null and child.key === null, then this only applies to
+      // the first item in the list.
+      if (child.key === key) {
+        const elementType = element.type;
+
+        if (elementType === REACT_FRAGMENT_TYPE) {
+          if (child.tag === Fragment) {
+            deleteRemainingChildren(returnFiber, child.sibling);
+            const existing = useFiber(child, element.props.children);
+            existing.return = returnFiber;
+
+            return existing;
+          }
+        } else {
+          if (child.elementType === elementType || ( // Keep this check inline so it only runs on the false path:
+          false) || // Lazy types should reconcile their resolved type.
+          // We need to do this after the Hot Reloading check above,
+          // because hot reloading has different semantics than prod because
+          // it doesn't resuspend. So we can't let the call below suspend.
+          typeof elementType === 'object' && elementType !== null && elementType.$$typeof === REACT_LAZY_TYPE && resolveLazy(elementType) === child.type) {
+            deleteRemainingChildren(returnFiber, child.sibling);
+            const existing = useFiber(child, element.props);
+            existing.ref = coerceRef(returnFiber, child, element);
+            existing.return = returnFiber;
+
+            return existing;
+          }
+        } // Didn't match.
+
+
+        deleteRemainingChildren(returnFiber, child);
+        break;
+      } else {
+        deleteChild(returnFiber, child);
+      }
+
+      child = child.sibling;
+    }
+
+    if (element.type === REACT_FRAGMENT_TYPE) {
+      const created = createFiberFromFragment(element.props.children, returnFiber.mode, lanes, element.key);
+      created.return = returnFiber;
+      return created;
+    } else {
+      const created = createFiberFromElement(element, returnFiber.mode, lanes);
+      created.ref = coerceRef(returnFiber, currentFirstChild, element);
+      created.return = returnFiber;
+      return created;
+    }
+  }
+
+  function reconcileSinglePortal(returnFiber, currentFirstChild, portal, lanes) {
+    const key = portal.key;
+    let child = currentFirstChild;
+
+    while (child !== null) {
+      // TODO: If key === null and child.key === null, then this only applies to
+      // the first item in the list.
+      if (child.key === key) {
+        if (child.tag === HostPortal && child.stateNode.containerInfo === portal.containerInfo && child.stateNode.implementation === portal.implementation) {
+          deleteRemainingChildren(returnFiber, child.sibling);
+          const existing = useFiber(child, portal.children || []);
+          existing.return = returnFiber;
+          return existing;
+        } else {
+          deleteRemainingChildren(returnFiber, child);
+          break;
+        }
+      } else {
+        deleteChild(returnFiber, child);
+      }
+
+      child = child.sibling;
+    }
+
+    const created = createFiberFromPortal(portal, returnFiber.mode, lanes);
+    created.return = returnFiber;
+    return created;
+  } // This API will tag the children with the side-effect of the reconciliation
+  // itself. They will be added to the side-effect list as we pass through the
+  // children and the parent.
+
+
+  function reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes) {
+    // This function is not recursive.
+    // If the top level item is an array, we treat it as a set of children,
+    // not as a fragment. Nested arrays on the other hand will be treated as
+    // fragment nodes. Recursion happens at the normal flow.
+    // Handle top level unkeyed fragments as if they were arrays.
+    // This leads to an ambiguity between <>{[...]}</> and <>...</>.
+    // We treat the ambiguous cases above the same.
+    // TODO: Let's use recursion like we do for Usable nodes?
+    const isUnkeyedTopLevelFragment = typeof newChild === 'object' && newChild !== null && newChild.type === REACT_FRAGMENT_TYPE && newChild.key === null;
+
+    if (isUnkeyedTopLevelFragment) {
+      newChild = newChild.props.children;
+    } // Handle object types
+
+
+    if (typeof newChild === 'object' && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          return placeSingleChild(reconcileSingleElement(returnFiber, currentFirstChild, newChild, lanes));
+
+        case REACT_PORTAL_TYPE:
+          return placeSingleChild(reconcileSinglePortal(returnFiber, currentFirstChild, newChild, lanes));
+
+        case REACT_LAZY_TYPE:
+          const payload = newChild._payload;
+          const init = newChild._init; // TODO: This function is supposed to be non-recursive.
+
+          return reconcileChildFibers(returnFiber, currentFirstChild, init(payload), lanes);
+      }
+
+      if (isArray(newChild)) {
+        return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, lanes);
+      }
+
+      if (getIteratorFn(newChild)) {
+        return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, lanes);
+      } // Usables are a valid React node type. When React encounters a Usable in
+      // a child position, it unwraps it using the same algorithm as `use`. For
+      // example, for promises, React will throw an exception to unwind the
+      // stack, then replay the component once the promise resolves.
+      //
+      // A difference from `use` is that React will keep unwrapping the value
+      // until it reaches a non-Usable type.
+      //
+      // e.g. Usable<Usable<Usable<T>>> should resolve to T
+      //
+      // The structure is a bit unfortunate. Ideally, we shouldn't need to
+      // replay the entire begin phase of the parent fiber in order to reconcile
+      // the children again. This would require a somewhat significant refactor,
+      // because reconcilation happens deep within the begin phase, and
+      // depending on the type of work, not always at the end. We should
+      // consider as an future improvement.
+
+
+      if (typeof newChild.then === 'function') {
+        const thenable = newChild;
+        return reconcileChildFibersImpl(returnFiber, currentFirstChild, unwrapThenable(thenable), lanes);
+      }
+
+      if (newChild.$$typeof === REACT_CONTEXT_TYPE || newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+        const context = newChild;
+        return reconcileChildFibersImpl(returnFiber, currentFirstChild, readContextDuringReconcilation(returnFiber, context, lanes), lanes);
+      }
+
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+
+    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {
+      return placeSingleChild(reconcileSingleTextNode(returnFiber, currentFirstChild, '' + newChild, lanes));
+    }
+
+
+    return deleteRemainingChildren(returnFiber, currentFirstChild);
+  }
+
+  function reconcileChildFibers(returnFiber, currentFirstChild, newChild, lanes) {
+    // This indirection only exists so we can reset `thenableState` at the end.
+    // It should get inlined by Closure.
+    thenableIndexCounter$1 = 0;
+    const firstChildFiber = reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes);
+    thenableState$1 = null; // Don't bother to reset `thenableIndexCounter` to 0 because it always gets
+    // set at the beginning.
+
+    return firstChildFiber;
+  }
+
+  return reconcileChildFibers;
+}
+
+const reconcileChildFibers = createChildReconciler(true);
+const mountChildFibers = createChildReconciler(false);
+function resetChildReconcilerOnUnwind() {
+  // On unwind, clear any pending thenables that were used.
+  thenableState$1 = null;
+  thenableIndexCounter$1 = 0;
+}
+function cloneChildFibers(current, workInProgress) {
+  if (current !== null && workInProgress.child !== current.child) {
+    throw Error(formatProdErrorMessage(153));
+  }
+
+  if (workInProgress.child === null) {
+    return;
+  }
+
+  let currentChild = workInProgress.child;
+  let newChild = createWorkInProgress(currentChild, currentChild.pendingProps);
+  workInProgress.child = newChild;
+  newChild.return = workInProgress;
+
+  while (currentChild.sibling !== null) {
+    currentChild = currentChild.sibling;
+    newChild = newChild.sibling = createWorkInProgress(currentChild, currentChild.pendingProps);
+    newChild.return = workInProgress;
+  }
+
+  newChild.sibling = null;
+} // Reset a workInProgress child set to prepare it for a second pass.
+
+function resetChildFibers(workInProgress, lanes) {
+  let child = workInProgress.child;
+
+  while (child !== null) {
+    resetWorkInProgress(child, lanes);
+    child = child.sibling;
+  }
+}
+
+// TODO: This isn't being used yet, but it's intended to replace the
+// InvisibleParentContext that is currently managed by SuspenseContext.
+
+const currentTreeHiddenStackCursor = createCursor(null);
+const prevEntangledRenderLanesCursor = createCursor(NoLanes);
+function pushHiddenContext(fiber, context) {
+  const prevEntangledRenderLanes = getEntangledRenderLanes();
+  push(prevEntangledRenderLanesCursor, prevEntangledRenderLanes);
+  push(currentTreeHiddenStackCursor, context); // When rendering a subtree that's currently hidden, we must include all
+  // lanes that would have rendered if the hidden subtree hadn't been deferred.
+  // That is, in order to reveal content from hidden -> visible, we must commit
+  // all the updates that we skipped when we originally hid the tree.
+
+  setEntangledRenderLanes(mergeLanes(prevEntangledRenderLanes, context.baseLanes));
+}
+function reuseHiddenContextOnStack(fiber) {
+  // This subtree is not currently hidden, so we don't need to add any lanes
+  // to the render lanes. But we still need to push something to avoid a
+  // context mismatch. Reuse the existing context on the stack.
+  push(prevEntangledRenderLanesCursor, getEntangledRenderLanes());
+  push(currentTreeHiddenStackCursor, currentTreeHiddenStackCursor.current);
+}
+function popHiddenContext(fiber) {
+  // Restore the previous render lanes from the stack
+  setEntangledRenderLanes(prevEntangledRenderLanesCursor.current);
+  pop(currentTreeHiddenStackCursor);
+  pop(prevEntangledRenderLanesCursor);
+}
+function isCurrentTreeHidden() {
+  return currentTreeHiddenStackCursor.current !== null;
+}
+
+// suspends, i.e. it's the nearest `catch` block on the stack.
+
+const suspenseHandlerStackCursor = createCursor(null); // Represents the outermost boundary that is not visible in the current tree.
+// Everything above this is the "shell". When this is null, it means we're
+// rendering in the shell of the app. If it's non-null, it means we're rendering
+// deeper than the shell, inside a new tree that wasn't already visible.
+//
+// The main way we use this concept is to determine whether showing a fallback
+// would result in a desirable or undesirable loading state. Activing a fallback
+// in the shell is considered an undersirable loading state, because it would
+// mean hiding visible (albeit stale) content in the current tree — we prefer to
+// show the stale content, rather than switch to a fallback. But showing a
+// fallback in a new tree is fine, because there's no stale content to
+// prefer instead.
+
+let shellBoundary = null;
+function getShellBoundary() {
+  return shellBoundary;
+}
+function pushPrimaryTreeSuspenseHandler(handler) {
+  // TODO: Pass as argument
+  const current = handler.alternate;
+  // propagated a single level. For example, when ForceSuspenseFallback is set,
+  // it should only force the nearest Suspense boundary into fallback mode.
+
+  pushSuspenseListContext(handler, setDefaultShallowSuspenseListContext(suspenseStackCursor.current)); // Experimental feature: Some Suspense boundaries are marked as having an
+  // to push a nested Suspense handler, because it will get replaced by the
+  // outer fallback, anyway. Consider this as a future optimization.
+
+
+  push(suspenseHandlerStackCursor, handler);
+
+  if (shellBoundary === null) {
+    if (current === null || isCurrentTreeHidden()) {
+      // This boundary is not visible in the current UI.
+      shellBoundary = handler;
+    } else {
+      const prevState = current.memoizedState;
+
+      if (prevState !== null) {
+        // This boundary is showing a fallback in the current UI.
+        shellBoundary = handler;
+      }
+    }
+  }
+}
+function pushFallbackTreeSuspenseHandler(fiber) {
+  // We're about to render the fallback. If something in the fallback suspends,
+  // it's akin to throwing inside of a `catch` block. This boundary should not
+  // capture. Reuse the existing handler on the stack.
+  reuseSuspenseHandlerOnStack(fiber);
+}
+function pushOffscreenSuspenseHandler(fiber) {
+  if (fiber.tag === OffscreenComponent) {
+    // A SuspenseList context is only pushed here to avoid a push/pop mismatch.
+    // Reuse the current value on the stack.
+    // TODO: We can avoid needing to push here by by forking popSuspenseHandler
+    // into separate functions for Suspense and Offscreen.
+    pushSuspenseListContext(fiber, suspenseStackCursor.current);
+    push(suspenseHandlerStackCursor, fiber);
+
+    if (shellBoundary !== null) ; else {
+      const current = fiber.alternate;
+
+      if (current !== null) {
+        const prevState = current.memoizedState;
+
+        if (prevState !== null) {
+          // This is the first boundary in the stack that's already showing
+          // a fallback. So everything outside is considered the shell.
+          shellBoundary = fiber;
+        }
+      }
+    }
+  } else {
+    // This is a LegacyHidden component.
+    reuseSuspenseHandlerOnStack(fiber);
+  }
+}
+function reuseSuspenseHandlerOnStack(fiber) {
+  pushSuspenseListContext(fiber, suspenseStackCursor.current);
+  push(suspenseHandlerStackCursor, getSuspenseHandler());
+}
+function getSuspenseHandler() {
+  return suspenseHandlerStackCursor.current;
+}
+function popSuspenseHandler(fiber) {
+  pop(suspenseHandlerStackCursor);
+
+  if (shellBoundary === fiber) {
+    // Popping back into the shell.
+    shellBoundary = null;
+  }
+
+  popSuspenseListContext();
+} // SuspenseList context
+// TODO: Move to a separate module? We may change the SuspenseList
+// implementation to hide/show in the commit phase, anyway.
+
+const DefaultSuspenseContext = 0b00;
+const SubtreeSuspenseContextMask = 0b01; // ForceSuspenseFallback can be used by SuspenseList to force newly added
+// items into their fallback state during one of the render passes.
+
+const ForceSuspenseFallback = 0b10;
+const suspenseStackCursor = createCursor(DefaultSuspenseContext);
+function hasSuspenseListContext(parentContext, flag) {
+  return (parentContext & flag) !== 0;
+}
+function setDefaultShallowSuspenseListContext(parentContext) {
+  return parentContext & SubtreeSuspenseContextMask;
+}
+function setShallowSuspenseListContext(parentContext, shallowContext) {
+  return parentContext & SubtreeSuspenseContextMask | shallowContext;
+}
+function pushSuspenseListContext(fiber, newContext) {
+  push(suspenseStackCursor, newContext);
+}
+function popSuspenseListContext(fiber) {
+  pop(suspenseStackCursor);
+}
+
+// A non-null SuspenseState means that it is blocked for one reason or another.
+// - A non-null dehydrated field means it's blocked pending hydration.
+//   - A non-null dehydrated field can use isSuspenseInstancePending or
+//     isSuspenseInstanceFallback to query the reason for being dehydrated.
+// - A null dehydrated field means it's blocked by something suspending and
+//   we're currently showing a fallback instead.
+
+function findFirstSuspended(row) {
+  let node = row;
+
+  while (node !== null) {
+    if (node.tag === SuspenseComponent) {
+      const state = node.memoizedState;
+
+      if (state !== null) {
+        const dehydrated = state.dehydrated;
+
+        if (dehydrated === null || isSuspenseInstancePending(dehydrated) || isSuspenseInstanceFallback(dehydrated)) {
+          return node;
+        }
+      }
+    } else if (node.tag === SuspenseListComponent && // revealOrder undefined can't be trusted because it don't
+    // keep track of whether it suspended or not.
+    node.memoizedProps.revealOrder !== undefined) {
+      const didSuspend = (node.flags & DidCapture) !== NoFlags$1;
+
+      if (didSuspend) {
+        return node;
+      }
+    } else if (node.child !== null) {
+      node.child.return = node;
+      node = node.child;
+      continue;
+    }
+
+    if (node === row) {
+      return null;
+    }
+
+    while (node.sibling === null) {
+      if (node.return === null || node.return === row) {
+        return null;
+      }
+
+      node = node.return;
+    }
+
+    node.sibling.return = node.return;
+    node = node.sibling;
+  }
+
+  return null;
+}
+
+const NoFlags =
+/*   */
+0b0000; // Represents whether effect should fire.
+
+const HasEffect =
+/* */
+0b0001; // Represents the phase in which the effect (not the clean-up) fires.
+
+const Insertion =
+/* */
+0b0010;
+const Layout =
+/*    */
+0b0100;
+const Passive =
+/*   */
+0b1000;
+
+// there's only a single root, but we do support multi root apps, hence this
+// extra complexity. But this module is optimized for the single root case.
+
+let firstScheduledRoot = null;
+let lastScheduledRoot = null; // Used to prevent redundant mircotasks from being scheduled.
+
+let didScheduleMicrotask = false; // `act` "microtasks" are scheduled on the `act` queue instead of an actual
+
+let mightHavePendingSyncWork = false;
+let isFlushingWork = false;
+let currentEventTransitionLane = NoLane;
+function ensureRootIsScheduled(root) {
+  // This function is called whenever a root receives an update. It does two
+  // things 1) it ensures the root is in the root schedule, and 2) it ensures
+  // there's a pending microtask to process the root schedule.
+  //
+  // Most of the actual scheduling logic does not happen until
+  // `scheduleTaskForRootDuringMicrotask` runs.
+  // Add the root to the schedule
+  if (root === lastScheduledRoot || root.next !== null) ; else {
+    if (lastScheduledRoot === null) {
+      firstScheduledRoot = lastScheduledRoot = root;
+    } else {
+      lastScheduledRoot.next = root;
+      lastScheduledRoot = root;
+    }
+  } // Any time a root received an update, we set this to true until the next time
+  // we process the schedule. If it's false, then we can quickly exit flushSync
+  // without consulting the schedule.
+
+
+  mightHavePendingSyncWork = true; // At the end of the current event, go through each of the roots and ensure
+  // there's a task scheduled for each one at the correct priority.
+
+  {
+    if (!didScheduleMicrotask) {
+      didScheduleMicrotask = true;
+      scheduleImmediateTask(processRootScheduleInMicrotask);
+    }
+  }
+}
+function flushSyncWorkOnAllRoots() {
+  // This is allowed to be called synchronously, but the caller should check
+  // the execution context first.
+  flushSyncWorkAcrossRoots_impl(false);
+}
+function flushSyncWorkOnLegacyRootsOnly() {
+  // This is allowed to be called synchronously, but the caller should check
+  // the execution context first.
+  flushSyncWorkAcrossRoots_impl(true);
+}
+
+function flushSyncWorkAcrossRoots_impl(onlyLegacy) {
+  if (isFlushingWork) {
+    // Prevent reentrancy.
+    // TODO: Is this overly defensive? The callers must check the execution
+    // context first regardless.
+    return;
+  }
+
+  if (!mightHavePendingSyncWork) {
+    // Fast path. There's no sync work to do.
+    return;
+  } // There may or may not be synchronous work scheduled. Let's check.
+
+
+  let didPerformSomeWork;
+  let errors = null;
+  isFlushingWork = true;
+
+  do {
+    didPerformSomeWork = false;
+    let root = firstScheduledRoot;
+
+    while (root !== null) {
+      if (onlyLegacy && root.tag !== LegacyRoot) ; else {
+        const workInProgressRoot = getWorkInProgressRoot();
+        const workInProgressRootRenderLanes = getWorkInProgressRootRenderLanes();
+        const nextLanes = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes);
+
+        if (includesSyncLane(nextLanes)) {
+          // This root has pending sync work. Flush it now.
+          try {
+            didPerformSomeWork = true;
+            performSyncWorkOnRoot(root, nextLanes);
+          } catch (error) {
+            // Collect errors so we can rethrow them at the end
+            if (errors === null) {
+              errors = [error];
+            } else {
+              errors.push(error);
+            }
+          }
+        }
+      }
+
+      root = root.next;
+    }
+  } while (didPerformSomeWork);
+
+  isFlushingWork = false; // If any errors were thrown, rethrow them right before exiting.
+  // TODO: Consider returning these to the caller, to allow them to decide
+  // how/when to rethrow.
+
+  if (errors !== null) {
+    if (errors.length > 1) {
+      if (typeof AggregateError === 'function') {
+        // eslint-disable-next-line no-undef
+        throw new AggregateError(errors);
+      } else {
+        for (let i = 1; i < errors.length; i++) {
+          scheduleImmediateTask(throwError.bind(null, errors[i]));
+        }
+
+        const firstError = errors[0];
+        throw firstError;
+      }
+    } else {
+      const error = errors[0];
+      throw error;
+    }
+  }
+}
+
+function throwError(error) {
+  throw error;
+}
+
+function processRootScheduleInMicrotask() {
+  // This function is always called inside a microtask. It should never be
+  // called synchronously.
+  didScheduleMicrotask = false;
+
+
+  mightHavePendingSyncWork = false;
+  const currentTime = now();
+  let prev = null;
+  let root = firstScheduledRoot;
+
+  while (root !== null) {
+    const next = root.next;
+
+    if (currentEventTransitionLane !== NoLane && shouldAttemptEagerTransition()) {
+      // A transition was scheduled during an event, but we're going to try to
+      // render it synchronously anyway. We do this during a popstate event to
+      // preserve the scroll position of the previous page.
+      upgradePendingLaneToSync(root, currentEventTransitionLane);
+    }
+
+    const nextLanes = scheduleTaskForRootDuringMicrotask(root, currentTime);
+
+    if (nextLanes === NoLane) {
+      // This root has no more pending work. Remove it from the schedule. To
+      // guard against subtle reentrancy bugs, this microtask is the only place
+      // we do this — you can add roots to the schedule whenever, but you can
+      // only remove them here.
+      // Null this out so we know it's been removed from the schedule.
+      root.next = null;
+
+      if (prev === null) {
+        // This is the new head of the list
+        firstScheduledRoot = next;
+      } else {
+        prev.next = next;
+      }
+
+      if (next === null) {
+        // This is the new tail of the list
+        lastScheduledRoot = prev;
+      }
+    } else {
+      // This root still has work. Keep it in the list.
+      prev = root;
+
+      if (includesSyncLane(nextLanes)) {
+        mightHavePendingSyncWork = true;
+      }
+    }
+
+    root = next;
+  }
+
+  currentEventTransitionLane = NoLane; // At the end of the microtask, flush any pending synchronous work. This has
+  // to come at the end, because it does actual rendering work that might throw.
+
+  flushSyncWorkOnAllRoots();
+}
+
+function scheduleTaskForRootDuringMicrotask(root, currentTime) {
+  // This function is always called inside a microtask, or at the very end of a
+  // rendering task right before we yield to the main thread. It should never be
+  // called synchronously.
+  //
+  // TODO: Unless enableDeferRootSchedulingToMicrotask is off. We need to land
+  // that ASAP to unblock additional features we have planned.
+  //
+  // This function also never performs React work synchronously; it should
+  // only schedule work to be performed later, in a separate task or microtask.
+  // Check if any lanes are being starved by other work. If so, mark them as
+  // expired so we know to work on those next.
+  markStarvedLanesAsExpired(root, currentTime); // Determine the next lanes to work on, and their priority.
+
+  const workInProgressRoot = getWorkInProgressRoot();
+  const workInProgressRootRenderLanes = getWorkInProgressRootRenderLanes();
+  const nextLanes = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes);
+  const existingCallbackNode = root.callbackNode;
+
+  if ( // Check if there's nothing to work on
+  nextLanes === NoLanes || // If this root is currently suspended and waiting for data to resolve, don't
+  // schedule a task to render it. We'll either wait for a ping, or wait to
+  // receive an update.
+  //
+  // Suspended render phase
+  root === workInProgressRoot && isWorkLoopSuspendedOnData() || // Suspended commit phase
+  root.cancelPendingCommit !== null) {
+    // Fast path: There's nothing to work on.
+    if (existingCallbackNode !== null) {
+      cancelCallback(existingCallbackNode);
+    }
+
+    root.callbackNode = null;
+    root.callbackPriority = NoLane;
+    return NoLane;
+  } // Schedule a new callback in the host environment.
+
+
+  if (includesSyncLane(nextLanes)) {
+    // Synchronous work is always flushed at the end of the microtask, so we
+    // don't need to schedule an additional task.
+    if (existingCallbackNode !== null) {
+      cancelCallback(existingCallbackNode);
+    }
+
+    root.callbackPriority = SyncLane;
+    root.callbackNode = null;
+    return SyncLane;
+  } else {
+    // We use the highest priority lane to represent the priority of the callback.
+    const existingCallbackPriority = root.callbackPriority;
+    const newCallbackPriority = getHighestPriorityLane(nextLanes);
+
+    if (newCallbackPriority === existingCallbackPriority && // Special case related to `act`. If the currently scheduled task is a
+    // Scheduler task, rather than an `act` task, cancel it and re-schedule
+    // on the `act` queue.
+    !(false  )) {
+      // The priority hasn't changed. We can reuse the existing task.
+      return newCallbackPriority;
+    } else {
+      // Cancel the existing callback. We'll schedule a new one below.
+      cancelCallback(existingCallbackNode);
+    }
+
+    let schedulerPriorityLevel;
+
+    switch (lanesToEventPriority(nextLanes)) {
+      case DiscreteEventPriority:
+        schedulerPriorityLevel = ImmediatePriority;
+        break;
+
+      case ContinuousEventPriority:
+        schedulerPriorityLevel = UserBlockingPriority;
+        break;
+
+      case DefaultEventPriority:
+        schedulerPriorityLevel = NormalPriority$1;
+        break;
+
+      case IdleEventPriority:
+        schedulerPriorityLevel = IdlePriority;
+        break;
+
+      default:
+        schedulerPriorityLevel = NormalPriority$1;
+        break;
+    }
+
+    const newCallbackNode = scheduleCallback$2(schedulerPriorityLevel, performConcurrentWorkOnRoot.bind(null, root));
+    root.callbackPriority = newCallbackPriority;
+    root.callbackNode = newCallbackNode;
+    return newCallbackPriority;
+  }
+}
+
+function getContinuationForRoot(root, originalCallbackNode) {
+  // This is called at the end of `performConcurrentWorkOnRoot` to determine
+  // if we need to schedule a continuation task.
+  //
+  // Usually `scheduleTaskForRootDuringMicrotask` only runs inside a microtask;
+  // however, since most of the logic for determining if we need a continuation
+  // versus a new task is the same, we cheat a bit and call it here. This is
+  // only safe to do because we know we're at the end of the browser task.
+  // So although it's not an actual microtask, it might as well be.
+  scheduleTaskForRootDuringMicrotask(root, now());
+
+  if (root.callbackNode === originalCallbackNode) {
+    // The task node scheduled for this root is the same one that's
+    // currently executed. Need to return a continuation.
+    return performConcurrentWorkOnRoot.bind(null, root);
+  }
+
+  return null;
+}
+
+function scheduleCallback$2(priorityLevel, callback) {
+  {
+    return scheduleCallback$3(priorityLevel, callback);
+  }
+}
+
+function cancelCallback(callbackNode) {
+  if (callbackNode !== null) {
+    cancelCallback$1(callbackNode);
+  }
+}
+
+function scheduleImmediateTask(cb) {
+  // Alternatively, can we move this check to the host config?
+
+
+  {
+    scheduleMicrotask(() => {
+      // In Safari, appending an iframe forces microtasks to run.
+      // https://github.com/facebook/react/issues/22459
+      // We don't support running callbacks in the middle of render
+      // or commit so we need to check against that.
+      const executionContext = getExecutionContext();
+
+      if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+        // Note that this would still prematurely flush the callbacks
+        // if this happens outside render or commit phase (e.g. in an event).
+        // Intentionally using a macrotask instead of a microtask here. This is
+        // wrong semantically but it prevents an infinite loop. The bug is
+        // Safari's, not ours, so we just do our best to not crash even though
+        // the behavior isn't completely correct.
+        scheduleCallback$3(ImmediatePriority, cb);
+        return;
+      }
+
+      cb();
+    });
+  }
+}
+
+function requestTransitionLane() {
+  // The algorithm for assigning an update to a lane should be stable for all
+  // updates at the same priority within the same event. To do this, the
+  // inputs to the algorithm must be the same.
+  //
+  // The trick we use is to cache the first of each of these inputs within an
+  // event. Then reset the cached values once we can be sure the event is
+  // over. Our heuristic for that is whenever we enter a concurrent work loop.
+  if (currentEventTransitionLane === NoLane) {
+    // All transitions within the same event are assigned the same lane.
+    currentEventTransitionLane = claimNextTransitionLane();
+  }
+
+  return currentEventTransitionLane;
+}
+
+// transition updates that occur while the async action is still in progress
+// are treated as part of the action.
+//
+// The ideal behavior would be to treat each async function as an independent
+// action. However, without a mechanism like AsyncContext, we can't tell which
+// action an update corresponds to. So instead, we entangle them all into one.
+// The listeners to notify once the entangled scope completes.
+
+let currentEntangledListeners = null; // The number of pending async actions in the entangled scope.
+
+let currentEntangledPendingCount = 0; // The transition lane shared by all updates in the entangled scope.
+
+let currentEntangledLane = NoLane;
+function requestAsyncActionContext(actionReturnValue, // If this is provided, this resulting thenable resolves to this value instead
+// of the return value of the action. This is a perf trick to avoid composing
+// an extra async function.
+overrideReturnValue) {
+  // This is an async action.
+  //
+  // Return a thenable that resolves once the action scope (i.e. the async
+  // function passed to startTransition) has finished running.
+  const thenable = actionReturnValue;
+  let entangledListeners;
+
+  if (currentEntangledListeners === null) {
+    // There's no outer async action scope. Create a new one.
+    entangledListeners = currentEntangledListeners = [];
+    currentEntangledPendingCount = 0;
+    currentEntangledLane = requestTransitionLane();
+  } else {
+    entangledListeners = currentEntangledListeners;
+  }
+
+  currentEntangledPendingCount++; // Create a thenable that represents the result of this action, but doesn't
+  // resolve until the entire entangled scope has finished.
+  //
+  // Expressed using promises:
+  //   const [thisResult] = await Promise.all([thisAction, entangledAction]);
+  //   return thisResult;
+
+  const resultThenable = createResultThenable(entangledListeners);
+  let resultStatus = 'pending';
+  let resultValue;
+  let rejectedReason;
+  thenable.then(value => {
+    resultStatus = 'fulfilled';
+    resultValue = overrideReturnValue !== null ? overrideReturnValue : value;
+    pingEngtangledActionScope();
+  }, error => {
+    resultStatus = 'rejected';
+    rejectedReason = error;
+    pingEngtangledActionScope();
+  }); // Attach a listener to fill in the result.
+
+  entangledListeners.push(() => {
+    switch (resultStatus) {
+      case 'fulfilled':
+        {
+          const fulfilledThenable = resultThenable;
+          fulfilledThenable.status = 'fulfilled';
+          fulfilledThenable.value = resultValue;
+          break;
+        }
+
+      case 'rejected':
+        {
+          const rejectedThenable = resultThenable;
+          rejectedThenable.status = 'rejected';
+          rejectedThenable.reason = rejectedReason;
+          break;
+        }
+
+      case 'pending':
+      default:
+        {
+          // The listener above should have been called first, so `resultStatus`
+          // should already be set to the correct value.
+          throw Error(formatProdErrorMessage(478));
+        }
+    }
+  });
+  return resultThenable;
+}
+function requestSyncActionContext(actionReturnValue, // If this is provided, this resulting thenable resolves to this value instead
+// of the return value of the action. This is a perf trick to avoid composing
+// an extra async function.
+overrideReturnValue) {
+  const resultValue = overrideReturnValue !== null ? overrideReturnValue : actionReturnValue; // This is not an async action, but it may be part of an outer async action.
+
+  if (currentEntangledListeners === null) {
+    return resultValue;
+  } else {
+    // Return a thenable that does not resolve until the entangled actions
+    // have finished.
+    const entangledListeners = currentEntangledListeners;
+    const resultThenable = createResultThenable(entangledListeners);
+    entangledListeners.push(() => {
+      const fulfilledThenable = resultThenable;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = resultValue;
+    });
+    return resultThenable;
+  }
+}
+
+function pingEngtangledActionScope() {
+  if (currentEntangledListeners !== null && --currentEntangledPendingCount === 0) {
+    // All the actions have finished. Close the entangled async action scope
+    // and notify all the listeners.
+    const listeners = currentEntangledListeners;
+    currentEntangledListeners = null;
+    currentEntangledLane = NoLane;
+
+    for (let i = 0; i < listeners.length; i++) {
+      const listener = listeners[i];
+      listener();
+    }
+  }
+}
+
+function createResultThenable(entangledListeners) {
+  // Waits for the entangled async action to complete, then resolves to the
+  // result of an individual action.
+  const resultThenable = {
+    status: 'pending',
+    value: null,
+    reason: null,
+
+    then(resolve) {
+      // This is a bit of a cheat. `resolve` expects a value of type `S` to be
+      // passed, but because we're instrumenting the `status` field ourselves,
+      // and we know this thenable will only be used by React, we also know
+      // the value isn't actually needed. So we add the resolve function
+      // directly to the entangled listeners.
+      //
+      // This is also why we don't need to check if the thenable is still
+      // pending; the Suspense implementation already performs that check.
+      const ping = resolve;
+      entangledListeners.push(ping);
+    }
+
+  };
+  return resultThenable;
+}
+
+function peekEntangledActionLane() {
+  return currentEntangledLane;
+}
+
+const ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
+      ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig;
+// lifetime of an effect. In Rust terms, a RefCell. We use it to store the
+// "destroy" function that is returned from an effect, because that is stateful.
+// The field is `undefined` if the effect is unmounted, or if the effect ran
+// but is not stateful. We don't explicitly track whether the effect is mounted
+// or unmounted because that can be inferred by the hiddenness of the fiber in
+// the tree, i.e. whether there is a hidden Offscreen fiber above it.
+//
+// It's unfortunate that this is stored on a separate object, because it adds
+// more memory per effect instance, but it's conceptually sound. I think there's
+// likely a better data structure we could use for effects; perhaps just one
+// array of effect instances per fiber. But I think this is OK for now despite
+// the additional memory and we can follow up with performance
+// optimizations later.
+// These are set right before calling the component.
+
+
+let renderLanes = NoLanes; // The work-in-progress fiber. I've named it differently to distinguish it from
+// the work-in-progress hook.
+
+let currentlyRenderingFiber$1 = null; // Hooks are stored as a linked list on the fiber's memoizedState field. The
+// current hook list is the list that belongs to the current fiber. The
+// work-in-progress hook list is a new list that will be added to the
+// work-in-progress fiber.
+
+let currentHook = null;
+let workInProgressHook = null; // Whether an update was scheduled at any point during the render phase. This
+// does not get reset if we do another render pass; only when we're completely
+// finished evaluating this component. This is an optimization so we know
+// whether we need to clear render phase updates after a throw.
+
+let didScheduleRenderPhaseUpdate = false; // Where an update was scheduled only during the current render pass. This
+// gets reset after each attempt.
+// TODO: Maybe there's some way to consolidate this with
+// `didScheduleRenderPhaseUpdate`. Or with `numberOfReRenders`.
+
+let didScheduleRenderPhaseUpdateDuringThisPass = false;
+let shouldDoubleInvokeUserFnsInHooksDEV = false; // Counts the number of useId hooks in this component.
+
+let localIdCounter = 0; // Counts number of `use`-d thenables
+
+let thenableIndexCounter = 0;
+let thenableState = null; // Used for ids that are generated completely client-side (i.e. not during
+// hydration). This counter is global, so client ids are not stable across
+// render attempts.
+
+let globalClientIdCounter = 0;
+const RE_RENDER_LIMIT = 25; // In DEV, this is the name of the currently executing primitive hook
+
+function throwInvalidHookError() {
+  throw Error(formatProdErrorMessage(321));
+}
+
+function areHookInputsEqual(nextDeps, prevDeps) {
+
+  if (prevDeps === null) {
+
+    return false;
+  }
+
+
+  for (let i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    if (objectIs(nextDeps[i], prevDeps[i])) {
+      continue;
+    }
+
+    return false;
+  }
+
+  return true;
+}
+
+function renderWithHooks(current, workInProgress, Component, props, secondArg, nextRenderLanes) {
+  renderLanes = nextRenderLanes;
+  currentlyRenderingFiber$1 = workInProgress;
+
+  workInProgress.memoizedState = null;
+  workInProgress.updateQueue = null;
+  workInProgress.lanes = NoLanes; // The following should have already been reset
+  // currentHook = null;
+  // workInProgressHook = null;
+  // didScheduleRenderPhaseUpdate = false;
+  // localIdCounter = 0;
+  // thenableIndexCounter = 0;
+  // thenableState = null;
+  // TODO Warn if no hooks are used at all during mount, then some are used during update.
+  // Currently we will identify the update render as a mount because memoizedState === null.
+  // This is tricky because it's valid for certain types of components (e.g. React.lazy)
+  // Using memoizedState to differentiate between mount/update only works if at least one stateful hook is used.
+  // Non-stateful hooks (e.g. context) don't get added to memoizedState,
+  // so memoizedState would be null during updates and mounts.
+
+  {
+    ReactCurrentDispatcher$1.current = current === null || current.memoizedState === null ? HooksDispatcherOnMount : HooksDispatcherOnUpdate;
+  } // In Strict Mode, during development, user functions are double invoked to
+  // help detect side effects. The logic for how this is implemented for in
+  // hook components is a bit complex so let's break it down.
+  //
+  // We will invoke the entire component function twice. However, during the
+  // second invocation of the component, the hook state from the first
+  // invocation will be reused. That means things like `useMemo` functions won't
+  // run again, because the deps will match and the memoized result will
+  // be reused.
+  //
+  // We want memoized functions to run twice, too, so account for this, user
+  // functions are double invoked during the *first* invocation of the component
+  // function, and are *not* double invoked during the second incovation:
+  //
+  // - First execution of component function: user functions are double invoked
+  // - Second execution of component function (in Strict Mode, during
+  //   development): user functions are not double invoked.
+  //
+  // This is intentional for a few reasons; most importantly, it's because of
+  // how `use` works when something suspends: it reuses the promise that was
+  // passed during the first attempt. This is itself a form of memoization.
+  // We need to be able to memoize the reactive inputs to the `use` call using
+  // a hook (i.e. `useMemo`), which means, the reactive inputs to `use` must
+  // come from the same component invocation as the output.
+  //
+  // There are plenty of tests to ensure this behavior is correct.
+
+
+  const shouldDoubleRenderDEV = false  ;
+  shouldDoubleInvokeUserFnsInHooksDEV = shouldDoubleRenderDEV;
+  let children = Component(props, secondArg);
+  shouldDoubleInvokeUserFnsInHooksDEV = false; // Check if there was a render phase update
+
+  if (didScheduleRenderPhaseUpdateDuringThisPass) {
+    // Keep rendering until the component stabilizes (there are no more render
+    // phase updates).
+    children = renderWithHooksAgain(workInProgress, Component, props, secondArg);
+  }
+
+  finishRenderingHooks();
+  return children;
+}
+
+function finishRenderingHooks(current, workInProgress, Component) {
+  // at the beginning of the render phase and there's no re-entrance.
+
+
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher; // This check uses currentHook so that it works the same in DEV and prod bundles.
+  // hookTypesDev could catch more cases (e.g. context) but only in DEV bundles.
+
+  const didRenderTooFewHooks = currentHook !== null && currentHook.next !== null;
+  renderLanes = NoLanes;
+  currentlyRenderingFiber$1 = null;
+  currentHook = null;
+  workInProgressHook = null;
+
+  didScheduleRenderPhaseUpdate = false; // This is reset by checkDidRenderIdHook
+  // localIdCounter = 0;
+
+  thenableIndexCounter = 0;
+  thenableState = null;
+
+  if (didRenderTooFewHooks) {
+    throw Error(formatProdErrorMessage(300));
+  }
+}
+
+function replaySuspendedComponentWithHooks(current, workInProgress, Component, props, secondArg) {
+
+  const children = renderWithHooksAgain(workInProgress, Component, props, secondArg);
+  finishRenderingHooks();
+  return children;
+}
+
+function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
+  // This is used to perform another render pass. It's used when setState is
+  // called during render, and for double invoking components in Strict Mode
+  // during development.
+  //
+  // The state from the previous pass is reused whenever possible. So, state
+  // updates that were already processed are not processed again, and memoized
+  // functions (`useMemo`) are not invoked again.
+  //
+  // Keep rendering in a loop for as long as render phase updates continue to
+  // be scheduled. Use a counter to prevent infinite loops.
+  currentlyRenderingFiber$1 = workInProgress;
+  let numberOfReRenders = 0;
+  let children;
+
+  do {
+    if (didScheduleRenderPhaseUpdateDuringThisPass) {
+      // It's possible that a use() value depended on a state that was updated in
+      // this rerender, so we need to watch for different thenables this time.
+      thenableState = null;
+    }
+
+    thenableIndexCounter = 0;
+    didScheduleRenderPhaseUpdateDuringThisPass = false;
+
+    if (numberOfReRenders >= RE_RENDER_LIMIT) {
+      throw Error(formatProdErrorMessage(301));
+    }
+
+    numberOfReRenders += 1;
+
+
+    currentHook = null;
+    workInProgressHook = null;
+    workInProgress.updateQueue = null;
+
+    ReactCurrentDispatcher$1.current = HooksDispatcherOnRerender;
+    children = Component(props, secondArg);
+  } while (didScheduleRenderPhaseUpdateDuringThisPass);
+
+  return children;
+}
+
+function renderTransitionAwareHostComponentWithHooks(current, workInProgress, lanes) {
+
+  return renderWithHooks(current, workInProgress, TransitionAwareHostComponent, null, null, lanes);
+}
+function TransitionAwareHostComponent() {
+
+  const dispatcher = ReactCurrentDispatcher$1.current;
+
+  const _dispatcher$useState = dispatcher.useState(),
+        maybeThenable = _dispatcher$useState[0];
+
+  if (typeof maybeThenable.then === 'function') {
+    const thenable = maybeThenable;
+    return useThenable(thenable);
+  } else {
+    const status = maybeThenable;
+    return status;
+  }
+}
+function checkDidRenderIdHook() {
+  // This should be called immediately after every renderWithHooks call.
+  // Conceptually, it's part of the return value of renderWithHooks; it's only a
+  // separate function to avoid using an array tuple.
+  const didRenderIdHook = localIdCounter !== 0;
+  localIdCounter = 0;
+  return didRenderIdHook;
+}
+function bailoutHooks(current, workInProgress, lanes) {
+  workInProgress.updateQueue = current.updateQueue; // TODO: Don't need to reset the flags here, because they're reset in the
+  // complete phase (bubbleProperties).
+
+  {
+    workInProgress.flags &= ~(Passive$1 | Update);
+  }
+
+  current.lanes = removeLanes(current.lanes, lanes);
+}
+function resetHooksAfterThrow() {
+  // This is called immediaetly after a throw. It shouldn't reset the entire
+  // module state, because the work loop might decide to replay the component
+  // again without rewinding.
+  //
+  // It should only reset things like the current dispatcher, to prevent hooks
+  // from being called outside of a component.
+  currentlyRenderingFiber$1 = null; // We can assume the previous dispatcher is always this one, since we set it
+  // at the beginning of the render phase and there's no re-entrance.
+
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+}
+function resetHooksOnUnwind(workInProgress) {
+  if (didScheduleRenderPhaseUpdate) {
+    // There were render phase updates. These are only valid for this render
+    // phase, which we are now aborting. Remove the updates from the queues so
+    // they do not persist to the next render. Do not remove updates from hooks
+    // that weren't processed.
+    //
+    // Only reset the updates from the queue if it has a clone. If it does
+    // not have a clone, that means it wasn't processed, and the updates were
+    // scheduled before we entered the render phase.
+    let hook = workInProgress.memoizedState;
+
+    while (hook !== null) {
+      const queue = hook.queue;
+
+      if (queue !== null) {
+        queue.pending = null;
+      }
+
+      hook = hook.next;
+    }
+
+    didScheduleRenderPhaseUpdate = false;
+  }
+
+  renderLanes = NoLanes;
+  currentlyRenderingFiber$1 = null;
+  currentHook = null;
+  workInProgressHook = null;
+
+  didScheduleRenderPhaseUpdateDuringThisPass = false;
+  localIdCounter = 0;
+  thenableIndexCounter = 0;
+  thenableState = null;
+}
+
+function mountWorkInProgressHook() {
+  const hook = {
+    memoizedState: null,
+    baseState: null,
+    baseQueue: null,
+    queue: null,
+    next: null
+  };
+
+  if (workInProgressHook === null) {
+    // This is the first hook in the list
+    currentlyRenderingFiber$1.memoizedState = workInProgressHook = hook;
+  } else {
+    // Append to the end of the list
+    workInProgressHook = workInProgressHook.next = hook;
+  }
+
+  return workInProgressHook;
+}
+
+function updateWorkInProgressHook() {
+  // This function is used both for updates and for re-renders triggered by a
+  // render phase update. It assumes there is either a current hook we can
+  // clone, or a work-in-progress hook from a previous render pass that we can
+  // use as a base.
+  let nextCurrentHook;
+
+  if (currentHook === null) {
+    const current = currentlyRenderingFiber$1.alternate;
+
+    if (current !== null) {
+      nextCurrentHook = current.memoizedState;
+    } else {
+      nextCurrentHook = null;
+    }
+  } else {
+    nextCurrentHook = currentHook.next;
+  }
+
+  let nextWorkInProgressHook;
+
+  if (workInProgressHook === null) {
+    nextWorkInProgressHook = currentlyRenderingFiber$1.memoizedState;
+  } else {
+    nextWorkInProgressHook = workInProgressHook.next;
+  }
+
+  if (nextWorkInProgressHook !== null) {
+    // There's already a work-in-progress. Reuse it.
+    workInProgressHook = nextWorkInProgressHook;
+    nextWorkInProgressHook = workInProgressHook.next;
+    currentHook = nextCurrentHook;
+  } else {
+    // Clone from the current hook.
+    if (nextCurrentHook === null) {
+      const currentFiber = currentlyRenderingFiber$1.alternate;
+
+      if (currentFiber === null) {
+        // This is the initial render. This branch is reached when the component
+        // suspends, resumes, then renders an additional hook.
+        // Should never be reached because we should switch to the mount dispatcher first.
+        throw Error(formatProdErrorMessage(467));
+      } else {
+        // This is an update. We should always have a current hook.
+        throw Error(formatProdErrorMessage(310));
+      }
+    }
+
+    currentHook = nextCurrentHook;
+    const newHook = {
+      memoizedState: currentHook.memoizedState,
+      baseState: currentHook.baseState,
+      baseQueue: currentHook.baseQueue,
+      queue: currentHook.queue,
+      next: null
+    };
+
+    if (workInProgressHook === null) {
+      // This is the first hook in the list.
+      currentlyRenderingFiber$1.memoizedState = workInProgressHook = newHook;
+    } else {
+      // Append to the end of the list.
+      workInProgressHook = workInProgressHook.next = newHook;
+    }
+  }
+
+  return workInProgressHook;
+} // NOTE: defining two versions of this function to avoid size impact when this feature is disabled.
+// Previously this function was inlined, the additional `memoCache` property makes it not inlined.
+
+
+let createFunctionComponentUpdateQueue;
+
+{
+  createFunctionComponentUpdateQueue = () => {
+    return {
+      lastEffect: null,
+      events: null,
+      stores: null,
+      memoCache: null
+    };
+  };
+}
+
+function useThenable(thenable) {
+  // Track the position of the thenable within this fiber.
+  const index = thenableIndexCounter;
+  thenableIndexCounter += 1;
+
+  if (thenableState === null) {
+    thenableState = createThenableState();
+  }
+
+  const result = trackUsedThenable(thenableState, thenable, index);
+
+  if (currentlyRenderingFiber$1.alternate === null && (workInProgressHook === null ? currentlyRenderingFiber$1.memoizedState === null : workInProgressHook.next === null)) {
+    // Initial render, and either this is the first time the component is
+    // called, or there were no Hooks called after this use() the previous
+    // time (perhaps because it threw). Subsequent Hook calls should use the
+    // mount dispatcher.
+    {
+      ReactCurrentDispatcher$1.current = HooksDispatcherOnMount;
+    }
+  }
+
+  return result;
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable;
+      return useThenable(thenable);
+    } else if (usable.$$typeof === REACT_CONTEXT_TYPE || usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+  throw Error(formatProdErrorMessage(438, String(usable)));
+}
+
+function useMemoCache(size) {
+  let memoCache = null; // Fast-path, load memo cache from wip fiber if already prepared
+
+  let updateQueue = currentlyRenderingFiber$1.updateQueue;
+
+  if (updateQueue !== null) {
+    memoCache = updateQueue.memoCache;
+  } // Otherwise clone from the current fiber
+
+
+  if (memoCache == null) {
+    const current = currentlyRenderingFiber$1.alternate;
+
+    if (current !== null) {
+      const currentUpdateQueue = current.updateQueue;
+
+      if (currentUpdateQueue !== null) {
+        const currentMemoCache = currentUpdateQueue.memoCache;
+
+        if (currentMemoCache != null) {
+          memoCache = {
+            data: currentMemoCache.data.map(array => 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;
+  let data = memoCache.data[memoCache.index];
+
+  if (data === undefined) {
+    data = memoCache.data[memoCache.index] = new Array(size);
+
+    for (let i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL;
+    }
+  }
+
+  memoCache.index++;
+  return data;
+}
+
+function basicStateReducer(state, action) {
+  // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
+  return typeof action === 'function' ? action(state) : action;
+}
+
+function mountReducer(reducer, initialArg, init) {
+  const hook = mountWorkInProgressHook();
+  let initialState;
+
+  if (init !== undefined) {
+    initialState = init(initialArg);
+  } else {
+    initialState = initialArg;
+  }
+
+  hook.memoizedState = hook.baseState = initialState;
+  const queue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    lastRenderedReducer: reducer,
+    lastRenderedState: initialState
+  };
+  hook.queue = queue;
+  const dispatch = queue.dispatch = dispatchReducerAction.bind(null, currentlyRenderingFiber$1, queue);
+  return [hook.memoizedState, dispatch];
+}
+
+function updateReducer(reducer, initialArg, init) {
+  const hook = updateWorkInProgressHook();
+  return updateReducerImpl(hook, currentHook, reducer);
+}
+
+function updateReducerImpl(hook, current, reducer) {
+  const queue = hook.queue;
+
+  if (queue === null) {
+    throw Error(formatProdErrorMessage(311));
+  }
+
+  queue.lastRenderedReducer = reducer; // The last rebase update that is NOT part of the base state.
+
+  let baseQueue = hook.baseQueue; // The last pending update that hasn't been processed yet.
+
+  const pendingQueue = queue.pending;
+
+  if (pendingQueue !== null) {
+    // We have new updates that haven't been processed yet.
+    // We'll add them to the base queue.
+    if (baseQueue !== null) {
+      // Merge the pending queue and the base queue.
+      const baseFirst = baseQueue.next;
+      const pendingFirst = pendingQueue.next;
+      baseQueue.next = pendingFirst;
+      pendingQueue.next = baseFirst;
+    }
+
+    current.baseQueue = baseQueue = pendingQueue;
+    queue.pending = null;
+  }
+
+  if (baseQueue !== null) {
+    // We have a queue to process.
+    const first = baseQueue.next;
+    let newState = hook.baseState;
+    let newBaseState = null;
+    let newBaseQueueFirst = null;
+    let newBaseQueueLast = null;
+    let update = first;
+
+    do {
+      // An extra OffscreenLane bit is added to updates that were made to
+      // a hidden tree, so that we can distinguish them from updates that were
+      // already there when the tree was hidden.
+      const updateLane = removeLanes(update.lane, OffscreenLane);
+      const isHiddenUpdate = updateLane !== update.lane; // Check if this update was made while the tree was hidden. If so, then
+      // it's not a "base" update and we should disregard the extra base lanes
+      // that were added to renderLanes when we entered the Offscreen tree.
+
+      const shouldSkipUpdate = isHiddenUpdate ? !isSubsetOfLanes(getWorkInProgressRootRenderLanes(), updateLane) : !isSubsetOfLanes(renderLanes, updateLane);
+
+      if (shouldSkipUpdate) {
+        // Priority is insufficient. Skip this update. If this is the first
+        // skipped update, the previous update/state is the new base
+        // update/state.
+        const clone = {
+          lane: updateLane,
+          revertLane: update.revertLane,
+          action: update.action,
+          hasEagerState: update.hasEagerState,
+          eagerState: update.eagerState,
+          next: null
+        };
+
+        if (newBaseQueueLast === null) {
+          newBaseQueueFirst = newBaseQueueLast = clone;
+          newBaseState = newState;
+        } else {
+          newBaseQueueLast = newBaseQueueLast.next = clone;
+        } // Update the remaining priority in the queue.
+        // TODO: Don't need to accumulate this. Instead, we can remove
+        // renderLanes from the original lanes.
+
+
+        currentlyRenderingFiber$1.lanes = mergeLanes(currentlyRenderingFiber$1.lanes, updateLane);
+        markSkippedUpdateLanes(updateLane);
+      } else {
+        // This update does have sufficient priority.
+        // Check if this is an optimistic update.
+        const revertLane = update.revertLane;
+
+        if (revertLane === NoLane) {
+          // This is not an optimistic update, and we're going to apply it now.
+          // But, if there were earlier updates that were skipped, we need to
+          // leave this update in the queue so it can be rebased later.
+          if (newBaseQueueLast !== null) {
+            const clone = {
+              // This update is going to be committed so we never want uncommit
+              // it. Using NoLane works because 0 is a subset of all bitmasks, so
+              // this will never be skipped by the check above.
+              lane: NoLane,
+              revertLane: NoLane,
+              action: update.action,
+              hasEagerState: update.hasEagerState,
+              eagerState: update.eagerState,
+              next: null
+            };
+            newBaseQueueLast = newBaseQueueLast.next = clone;
+          }
+        } else {
+          // This is an optimistic update. If the "revert" priority is
+          // sufficient, don't apply the update. Otherwise, apply the update,
+          // but leave it in the queue so it can be either reverted or
+          // rebased in a subsequent render.
+          if (isSubsetOfLanes(renderLanes, revertLane)) {
+            // The transition that this optimistic update is associated with
+            // has finished. Pretend the update doesn't exist by skipping
+            // over it.
+            update = update.next;
+            continue;
+          } else {
+            const clone = {
+              // Once we commit an optimistic update, we shouldn't uncommit it
+              // until the transition it is associated with has finished
+              // (represented by revertLane). Using NoLane here works because 0
+              // is a subset of all bitmasks, so this will never be skipped by
+              // the check above.
+              lane: NoLane,
+              // Reuse the same revertLane so we know when the transition
+              // has finished.
+              revertLane: update.revertLane,
+              action: update.action,
+              hasEagerState: update.hasEagerState,
+              eagerState: update.eagerState,
+              next: null
+            };
+
+            if (newBaseQueueLast === null) {
+              newBaseQueueFirst = newBaseQueueLast = clone;
+              newBaseState = newState;
+            } else {
+              newBaseQueueLast = newBaseQueueLast.next = clone;
+            } // Update the remaining priority in the queue.
+            // TODO: Don't need to accumulate this. Instead, we can remove
+            // renderLanes from the original lanes.
+
+
+            currentlyRenderingFiber$1.lanes = mergeLanes(currentlyRenderingFiber$1.lanes, revertLane);
+            markSkippedUpdateLanes(revertLane);
+          }
+        } // Process this update.
+
+
+        const action = update.action;
+
+        if (shouldDoubleInvokeUserFnsInHooksDEV) {
+          reducer(newState, action);
+        }
+
+        if (update.hasEagerState) {
+          // If this update is a state update (not a reducer) and was processed eagerly,
+          // we can use the eagerly computed state
+          newState = update.eagerState;
+        } else {
+          newState = reducer(newState, action);
+        }
+      }
+
+      update = update.next;
+    } while (update !== null && update !== first);
+
+    if (newBaseQueueLast === null) {
+      newBaseState = newState;
+    } else {
+      newBaseQueueLast.next = newBaseQueueFirst;
+    } // Mark that the fiber performed work, but only if the new state is
+    // different from the current state.
+
+
+    if (!objectIs(newState, hook.memoizedState)) {
+      markWorkInProgressReceivedUpdate();
+    }
+
+    hook.memoizedState = newState;
+    hook.baseState = newBaseState;
+    hook.baseQueue = newBaseQueueLast;
+    queue.lastRenderedState = newState;
+  }
+
+  if (baseQueue === null) {
+    // `queue.lanes` is used for entangling transitions. We can set it back to
+    // zero once the queue is empty.
+    queue.lanes = NoLanes;
+  }
+
+  const dispatch = queue.dispatch;
+  return [hook.memoizedState, dispatch];
+}
+
+function rerenderReducer(reducer, initialArg, init) {
+  const hook = updateWorkInProgressHook();
+  const queue = hook.queue;
+
+  if (queue === null) {
+    throw Error(formatProdErrorMessage(311));
+  }
+
+  queue.lastRenderedReducer = reducer; // This is a re-render. Apply the new render phase updates to the previous
+  // work-in-progress hook.
+
+  const dispatch = queue.dispatch;
+  const lastRenderPhaseUpdate = queue.pending;
+  let newState = hook.memoizedState;
+
+  if (lastRenderPhaseUpdate !== null) {
+    // The queue doesn't persist past this render pass.
+    queue.pending = null;
+    const firstRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+    let update = firstRenderPhaseUpdate;
+
+    do {
+      // Process this render phase update. We don't have to check the
+      // priority because it will always be the same as the current
+      // render's.
+      const action = update.action;
+      newState = reducer(newState, action);
+      update = update.next;
+    } while (update !== firstRenderPhaseUpdate); // Mark that the fiber performed work, but only if the new state is
+    // different from the current state.
+
+
+    if (!objectIs(newState, hook.memoizedState)) {
+      markWorkInProgressReceivedUpdate();
+    }
+
+    hook.memoizedState = newState; // Don't persist the state accumulated from the render phase updates to
+    // the base state unless the queue is empty.
+    // TODO: Not sure if this is the desired semantics, but it's what we
+    // do for gDSFP. I can't remember why.
+
+    if (hook.baseQueue === null) {
+      hook.baseState = newState;
+    }
+
+    queue.lastRenderedState = newState;
+  }
+
+  return [newState, dispatch];
+}
+
+function mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  const fiber = currentlyRenderingFiber$1;
+  const hook = mountWorkInProgressHook();
+  let nextSnapshot;
+  const isHydrating = getIsHydrating();
+
+  if (isHydrating) {
+    if (getServerSnapshot === undefined) {
+      throw Error(formatProdErrorMessage(407));
+    }
+
+    nextSnapshot = getServerSnapshot();
+  } else {
+    nextSnapshot = getSnapshot();
+    // Right before committing, we will walk the tree and check if any of the
+    // stores were mutated.
+    //
+    // We won't do this if we're hydrating server-rendered content, because if
+    // the content is stale, it's already visible anyway. Instead we'll patch
+    // it up in a passive effect.
+
+
+    const root = getWorkInProgressRoot();
+
+    if (root === null) {
+      throw Error(formatProdErrorMessage(349));
+    }
+
+    const rootRenderLanes = getWorkInProgressRootRenderLanes();
+
+    if (!includesBlockingLane(root, rootRenderLanes)) {
+      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+    }
+  } // Read the current snapshot from the store on every render. This breaks the
+  // normal rules of React, and only works because store updates are
+  // always synchronous.
+
+
+  hook.memoizedState = nextSnapshot;
+  const inst = {
+    value: nextSnapshot,
+    getSnapshot
+  };
+  hook.queue = inst; // Schedule an effect to subscribe to the store.
+
+  mountEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [subscribe]); // Schedule an effect to update the mutable instance fields. We will update
+  // this whenever subscribe, getSnapshot, or value changes. Because there's no
+  // clean-up function, and we track the deps correctly, we can call pushEffect
+  // directly, without storing any additional state. For the same reason, we
+  // don't need to set a static flag, either.
+
+  fiber.flags |= Passive$1;
+  pushEffect(HasEffect | Passive, updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot), createEffectInstance(), null);
+  return nextSnapshot;
+}
+
+function updateSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  const fiber = currentlyRenderingFiber$1;
+  const hook = updateWorkInProgressHook(); // Read the current snapshot from the store on every render. This breaks the
+  // normal rules of React, and only works because store updates are
+  // always synchronous.
+
+  let nextSnapshot;
+  const isHydrating = getIsHydrating();
+
+  if (isHydrating) {
+    // Needed for strict mode double render
+    if (getServerSnapshot === undefined) {
+      throw Error(formatProdErrorMessage(407));
+    }
+
+    nextSnapshot = getServerSnapshot();
+  } else {
+    nextSnapshot = getSnapshot();
+  }
+
+  const prevSnapshot = (currentHook || hook).memoizedState;
+  const snapshotChanged = !objectIs(prevSnapshot, nextSnapshot);
+
+  if (snapshotChanged) {
+    hook.memoizedState = nextSnapshot;
+    markWorkInProgressReceivedUpdate();
+  }
+
+  const inst = hook.queue;
+  updateEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [subscribe]); // Whenever getSnapshot or subscribe changes, we need to check in the
+  // commit phase if there was an interleaved mutation. In concurrent mode
+  // this can happen all the time, but even in synchronous mode, an earlier
+  // effect may have mutated the store.
+
+  if (inst.getSnapshot !== getSnapshot || snapshotChanged || // Check if the subscribe function changed. We can save some memory by
+  // checking whether we scheduled a subscription effect above.
+  workInProgressHook !== null && workInProgressHook.memoizedState.tag & HasEffect) {
+    fiber.flags |= Passive$1;
+    pushEffect(HasEffect | Passive, updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot), createEffectInstance(), null); // Unless we're rendering a blocking lane, schedule a consistency check.
+    // Right before committing, we will walk the tree and check if any of the
+    // stores were mutated.
+
+    const root = getWorkInProgressRoot();
+
+    if (root === null) {
+      throw Error(formatProdErrorMessage(349));
+    }
+
+    if (!isHydrating && !includesBlockingLane(root, renderLanes)) {
+      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+    }
+  }
+
+  return nextSnapshot;
+}
+
+function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
+  fiber.flags |= StoreConsistency;
+  const check = {
+    getSnapshot,
+    value: renderedSnapshot
+  };
+  let componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.stores = [check];
+  } else {
+    const stores = componentUpdateQueue.stores;
+
+    if (stores === null) {
+      componentUpdateQueue.stores = [check];
+    } else {
+      stores.push(check);
+    }
+  }
+}
+
+function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
+  // These are updated in the passive phase
+  inst.value = nextSnapshot;
+  inst.getSnapshot = getSnapshot; // Something may have been mutated in between render and commit. This could
+  // have been in an event that fired before the passive effects, or it could
+  // have been in a layout effect. In that case, we would have used the old
+  // snapsho and getSnapshot values to bail out. We need to check one more time.
+
+  if (checkIfSnapshotChanged(inst)) {
+    // Force a re-render.
+    forceStoreRerender(fiber);
+  }
+}
+
+function subscribeToStore(fiber, inst, subscribe) {
+  const handleStoreChange = () => {
+    // The store changed. Check if the snapshot changed since the last time we
+    // read from the store.
+    if (checkIfSnapshotChanged(inst)) {
+      // Force a re-render.
+      forceStoreRerender(fiber);
+    }
+  }; // Subscribe to the store and return a clean-up function.
+
+
+  return subscribe(handleStoreChange);
+}
+
+function checkIfSnapshotChanged(inst) {
+  const latestGetSnapshot = inst.getSnapshot;
+  const prevValue = inst.value;
+
+  try {
+    const nextValue = latestGetSnapshot();
+    return !objectIs(prevValue, nextValue);
+  } catch (error) {
+    return true;
+  }
+}
+
+function forceStoreRerender(fiber) {
+  const root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, fiber, SyncLane);
+  }
+}
+
+function mountStateImpl(initialState) {
+  const hook = mountWorkInProgressHook();
+
+  if (typeof initialState === 'function') {
+    // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
+    initialState = initialState();
+  }
+
+  hook.memoizedState = hook.baseState = initialState;
+  const queue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    lastRenderedReducer: basicStateReducer,
+    lastRenderedState: initialState
+  };
+  hook.queue = queue;
+  return hook;
+}
+
+function mountState(initialState) {
+  const hook = mountStateImpl(initialState);
+  const queue = hook.queue;
+  const dispatch = dispatchSetState.bind(null, currentlyRenderingFiber$1, queue);
+  queue.dispatch = dispatch;
+  return [hook.memoizedState, dispatch];
+}
+
+function updateState(initialState) {
+  return updateReducer(basicStateReducer);
+}
+
+function rerenderState(initialState) {
+  return rerenderReducer(basicStateReducer);
+}
+
+function mountOptimistic(passthrough, reducer) {
+  const hook = mountWorkInProgressHook();
+  hook.memoizedState = hook.baseState = passthrough;
+  const queue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    // Optimistic state does not use the eager update optimization.
+    lastRenderedReducer: null,
+    lastRenderedState: null
+  };
+  hook.queue = queue; // This is different than the normal setState function.
+
+  const dispatch = dispatchOptimisticSetState.bind(null, currentlyRenderingFiber$1, true, queue);
+  queue.dispatch = dispatch;
+  return [passthrough, dispatch];
+}
+
+function updateOptimistic(passthrough, reducer) {
+  const hook = updateWorkInProgressHook();
+  return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
+}
+
+function updateOptimisticImpl(hook, current, passthrough, reducer) {
+  // Optimistic updates are always rebased on top of the latest value passed in
+  // as an argument. It's called a passthrough because if there are no pending
+  // updates, it will be returned as-is.
+  //
+  // Reset the base state to the passthrough. Future updates will be applied
+  // on top of this.
+  hook.baseState = passthrough; // If a reducer is not provided, default to the same one used by useState.
+
+  const resolvedReducer = typeof reducer === 'function' ? reducer : basicStateReducer;
+  return updateReducerImpl(hook, currentHook, resolvedReducer);
+}
+
+function rerenderOptimistic(passthrough, reducer) {
+  // Unlike useState, useOptimistic doesn't support render phase updates.
+  // Also unlike useState, we need to replay all pending updates again in case
+  // the passthrough value changed.
+  //
+  // So instead of a forked re-render implementation that knows how to handle
+  // render phase udpates, we can use the same implementation as during a
+  // regular mount or update.
+  const hook = updateWorkInProgressHook();
+
+  if (currentHook !== null) {
+    // This is an update. Process the update queue.
+    return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
+  } // This is a mount. No updates to process.
+  // Reset the base state to the passthrough. Future updates will be applied
+  // on top of this.
+
+
+  hook.baseState = passthrough;
+  const dispatch = hook.queue.dispatch;
+  return [passthrough, dispatch];
+} // useFormState actions run sequentially, because each action receives the
+// previous state as an argument. We store pending actions on a queue.
+
+
+function dispatchFormState(fiber, actionQueue, setState, payload) {
+  if (isRenderPhaseUpdate(fiber)) {
+    throw Error(formatProdErrorMessage(485));
+  }
+
+  const last = actionQueue.pending;
+
+  if (last === null) {
+    // There are no pending actions; this is the first one. We can run
+    // it immediately.
+    const newLast = {
+      payload,
+      next: null // circular
+
+    };
+    newLast.next = actionQueue.pending = newLast;
+    runFormStateAction(actionQueue, setState, payload);
+  } else {
+    // There's already an action running. Add to the queue.
+    const first = last.next;
+    const newLast = {
+      payload,
+      next: first
+    };
+    actionQueue.pending = last.next = newLast;
+  }
+}
+
+function runFormStateAction(actionQueue, setState, payload) {
+  const action = actionQueue.action;
+  const prevState = actionQueue.state; // This is a fork of startTransition
+
+  const prevTransition = ReactCurrentBatchConfig$3.transition;
+  ReactCurrentBatchConfig$3.transition = {};
+
+  try {
+    const returnValue = action(prevState, payload);
+
+    if (returnValue !== null && typeof returnValue === 'object' && // $FlowFixMe[method-unbinding]
+    typeof returnValue.then === 'function') {
+      const thenable = returnValue; // Attach a listener to read the return state of the action. As soon as
+      // this resolves, we can run the next action in the sequence.
+
+      thenable.then(nextState => {
+        actionQueue.state = nextState;
+        finishRunningFormStateAction(actionQueue, setState);
+      }, () => finishRunningFormStateAction(actionQueue, setState));
+      const entangledResult = requestAsyncActionContext(thenable, null);
+      setState(entangledResult);
+    } else {
+      // This is either `returnValue` or a thenable that resolves to
+      // `returnValue`, depending on whether we're inside an async action scope.
+      const entangledResult = requestSyncActionContext(returnValue, null);
+      setState(entangledResult);
+      const nextState = returnValue;
+      actionQueue.state = nextState;
+      finishRunningFormStateAction(actionQueue, setState);
+    }
+  } catch (error) {
+    // This is a trick to get the `useFormState` hook to rethrow the error.
+    // When it unwraps the thenable with the `use` algorithm, the error
+    // will be thrown.
+    const rejectedThenable = {
+      then() {},
+
+      status: 'rejected',
+      reason: error // $FlowFixMe: Not sure why this doesn't work
+
+    };
+    setState(rejectedThenable);
+    finishRunningFormStateAction(actionQueue, setState);
+  } finally {
+    ReactCurrentBatchConfig$3.transition = prevTransition;
+  }
+}
+
+function finishRunningFormStateAction(actionQueue, setState) {
+  // The action finished running. Pop it from the queue and run the next pending
+  // action, if there are any.
+  const last = actionQueue.pending;
+
+  if (last !== null) {
+    const first = last.next;
+
+    if (first === last) {
+      // This was the last action in the queue.
+      actionQueue.pending = null;
+    } else {
+      // Remove the first node from the circular queue.
+      const next = first.next;
+      last.next = next; // Run the next action.
+
+      runFormStateAction(actionQueue, setState, next.payload);
+    }
+  }
+}
+
+function formStateReducer(oldState, newState) {
+  return newState;
+}
+
+function mountFormState(action, initialStateProp, permalink) {
+  let initialState = initialStateProp;
+
+  if (getIsHydrating()) {
+    const root = getWorkInProgressRoot();
+    const ssrFormState = root.formState; // If a formState option was passed to the root, there are form state
+    // markers that we need to hydrate. These indicate whether the form state
+    // matches this hook instance.
+
+    if (ssrFormState !== null) {
+      const isMatching = tryToClaimNextHydratableFormMarkerInstance();
+
+      if (isMatching) {
+        initialState = ssrFormState[0];
+      }
+    }
+  } // State hook. The state is stored in a thenable which is then unwrapped by
+  // the `use` algorithm during render.
+
+
+  const stateHook = mountWorkInProgressHook();
+  stateHook.memoizedState = stateHook.baseState = initialState; // TODO: Typing this "correctly" results in recursion limit errors
+  // const stateQueue: UpdateQueue<S | Awaited<S>, S | Awaited<S>> = {
+
+  const stateQueue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    lastRenderedReducer: formStateReducer,
+    lastRenderedState: initialState
+  };
+  stateHook.queue = stateQueue;
+  const setState = dispatchSetState.bind(null, currentlyRenderingFiber$1, stateQueue);
+  stateQueue.dispatch = setState; // Action queue hook. This is used to queue pending actions. The queue is
+  // shared between all instances of the hook. Similar to a regular state queue,
+  // but different because the actions are run sequentially, and they run in
+  // an event instead of during render.
+
+  const actionQueueHook = mountWorkInProgressHook();
+  const actionQueue = {
+    state: initialState,
+    dispatch: null,
+    // circular
+    action,
+    pending: null
+  };
+  actionQueueHook.queue = actionQueue;
+  const dispatch = dispatchFormState.bind(null, currentlyRenderingFiber$1, actionQueue, setState);
+  actionQueue.dispatch = dispatch; // Stash the action function on the memoized state of the hook. We'll use this
+  // to detect when the action function changes so we can update it in
+  // an effect.
+
+  actionQueueHook.memoizedState = action;
+  return [initialState, dispatch];
+}
+
+function updateFormState(action, initialState, permalink) {
+  const stateHook = updateWorkInProgressHook();
+  const currentStateHook = currentHook;
+  return updateFormStateImpl(stateHook, currentStateHook, action);
+}
+
+function updateFormStateImpl(stateHook, currentStateHook, action, initialState, permalink) {
+  const _updateReducerImpl = updateReducerImpl(stateHook, currentStateHook, formStateReducer),
+        actionResult = _updateReducerImpl[0]; // This will suspend until the action finishes.
+
+
+  const state = typeof actionResult === 'object' && actionResult !== null && // $FlowFixMe[method-unbinding]
+  typeof actionResult.then === 'function' ? useThenable(actionResult) : actionResult;
+  const actionQueueHook = updateWorkInProgressHook();
+  const actionQueue = actionQueueHook.queue;
+  const dispatch = actionQueue.dispatch; // Check if a new action was passed. If so, update it in an effect.
+
+  const prevAction = actionQueueHook.memoizedState;
+
+  if (action !== prevAction) {
+    currentlyRenderingFiber$1.flags |= Passive$1;
+    pushEffect(HasEffect | Passive, formStateActionEffect.bind(null, actionQueue, action), createEffectInstance(), null);
+  }
+
+  return [state, dispatch];
+}
+
+function formStateActionEffect(actionQueue, action) {
+  actionQueue.action = action;
+}
+
+function rerenderFormState(action, initialState, permalink) {
+  // Unlike useState, useFormState doesn't support render phase updates.
+  // Also unlike useState, we need to replay all pending updates again in case
+  // the passthrough value changed.
+  //
+  // So instead of a forked re-render implementation that knows how to handle
+  // render phase udpates, we can use the same implementation as during a
+  // regular mount or update.
+  const stateHook = updateWorkInProgressHook();
+  const currentStateHook = currentHook;
+
+  if (currentStateHook !== null) {
+    // This is an update. Process the update queue.
+    return updateFormStateImpl(stateHook, currentStateHook, action);
+  } // This is a mount. No updates to process.
+
+
+  const state = stateHook.memoizedState;
+  const actionQueueHook = updateWorkInProgressHook();
+  const actionQueue = actionQueueHook.queue;
+  const dispatch = actionQueue.dispatch; // This may have changed during the rerender.
+
+  actionQueueHook.memoizedState = action;
+  return [state, dispatch];
+}
+
+function pushEffect(tag, create, inst, deps) {
+  const effect = {
+    tag,
+    create,
+    inst,
+    deps,
+    // Circular
+    next: null
+  };
+  let componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.lastEffect = effect.next = effect;
+  } else {
+    const lastEffect = componentUpdateQueue.lastEffect;
+
+    if (lastEffect === null) {
+      componentUpdateQueue.lastEffect = effect.next = effect;
+    } else {
+      const firstEffect = lastEffect.next;
+      lastEffect.next = effect;
+      effect.next = firstEffect;
+      componentUpdateQueue.lastEffect = effect;
+    }
+  }
+
+  return effect;
+}
+
+function createEffectInstance() {
+  return {
+    destroy: undefined
+  };
+}
+
+function mountRef(initialValue) {
+  const hook = mountWorkInProgressHook();
+
+  {
+    const ref = {
+      current: initialValue
+    };
+    hook.memoizedState = ref;
+    return ref;
+  }
+}
+
+function updateRef(initialValue) {
+  const hook = updateWorkInProgressHook();
+  return hook.memoizedState;
+}
+
+function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
+  const hook = mountWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(HasEffect | hookFlags, create, createEffectInstance(), nextDeps);
+}
+
+function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
+  const hook = updateWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  const effect = hook.memoizedState;
+  const inst = effect.inst; // currentHook is null on initial mount when rerendering after a render phase
+  // state update or for strict mode.
+
+  if (currentHook !== null) {
+    if (nextDeps !== null) {
+      const prevEffect = currentHook.memoizedState;
+      const prevDeps = prevEffect.deps;
+
+      if (areHookInputsEqual(nextDeps, prevDeps)) {
+        hook.memoizedState = pushEffect(hookFlags, create, inst, nextDeps);
+        return;
+      }
+    }
+  }
+
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(HasEffect | hookFlags, create, inst, nextDeps);
+}
+
+function mountEffect(create, deps) {
+  {
+    mountEffectImpl(Passive$1 | PassiveStatic, Passive, create, deps);
+  }
+}
+
+function updateEffect(create, deps) {
+  updateEffectImpl(Passive$1, Passive, create, deps);
+}
+
+function useEffectEventImpl(payload) {
+  currentlyRenderingFiber$1.flags |= Update;
+  let componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.events = [payload];
+  } else {
+    const events = componentUpdateQueue.events;
+
+    if (events === null) {
+      componentUpdateQueue.events = [payload];
+    } else {
+      events.push(payload);
+    }
+  }
+}
+
+function mountEvent(callback) {
+  const hook = mountWorkInProgressHook();
+  const ref = {
+    impl: callback
+  };
+  hook.memoizedState = ref; // $FlowIgnore[incompatible-return]
+
+  return function eventFn() {
+    if (isInvalidExecutionContextForEventFunction()) {
+      throw Error(formatProdErrorMessage(440));
+    }
+
+    return ref.impl.apply(undefined, arguments);
+  };
+}
+
+function updateEvent(callback) {
+  const hook = updateWorkInProgressHook();
+  const ref = hook.memoizedState;
+  useEffectEventImpl({
+    ref,
+    nextImpl: callback
+  }); // $FlowIgnore[incompatible-return]
+
+  return function eventFn() {
+    if (isInvalidExecutionContextForEventFunction()) {
+      throw Error(formatProdErrorMessage(440));
+    }
+
+    return ref.impl.apply(undefined, arguments);
+  };
+}
+
+function mountInsertionEffect(create, deps) {
+  mountEffectImpl(Update, Insertion, create, deps);
+}
+
+function updateInsertionEffect(create, deps) {
+  return updateEffectImpl(Update, Insertion, create, deps);
+}
+
+function mountLayoutEffect(create, deps) {
+  let fiberFlags = Update | LayoutStatic;
+
+  return mountEffectImpl(fiberFlags, Layout, create, deps);
+}
+
+function updateLayoutEffect(create, deps) {
+  return updateEffectImpl(Update, Layout, create, deps);
+}
+
+function imperativeHandleEffect(create, ref) {
+  if (typeof ref === 'function') {
+    const refCallback = ref;
+    const inst = create();
+    refCallback(inst);
+    return () => {
+      refCallback(null);
+    };
+  } else if (ref !== null && ref !== undefined) {
+    const refObject = ref;
+
+    const inst = create();
+    refObject.current = inst;
+    return () => {
+      refObject.current = null;
+    };
+  }
+}
+
+function mountImperativeHandle(ref, create, deps) {
+
+
+  const effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+  let fiberFlags = Update | LayoutStatic;
+
+  mountEffectImpl(fiberFlags, Layout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
+}
+
+function updateImperativeHandle(ref, create, deps) {
+
+
+  const effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+  updateEffectImpl(Update, Layout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
+}
+
+function mountDebugValue(value, formatterFn) {// This hook is normally a no-op.
+  // The react-debug-hooks package injects its own implementation
+  // so that e.g. DevTools can display custom hook values.
+}
+
+const updateDebugValue = mountDebugValue;
+
+function mountCallback(callback, deps) {
+  const hook = mountWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  hook.memoizedState = [callback, nextDeps];
+  return callback;
+}
+
+function updateCallback(callback, deps) {
+  const hook = updateWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  const prevState = hook.memoizedState;
+
+  if (nextDeps !== null) {
+    const prevDeps = prevState[1];
+
+    if (areHookInputsEqual(nextDeps, prevDeps)) {
+      return prevState[0];
+    }
+  }
+
+  hook.memoizedState = [callback, nextDeps];
+  return callback;
+}
+
+function mountMemo(nextCreate, deps) {
+  const hook = mountWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+
+  if (shouldDoubleInvokeUserFnsInHooksDEV) {
+    nextCreate();
+  }
+
+  const nextValue = nextCreate();
+  hook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
+
+function updateMemo(nextCreate, deps) {
+  const hook = updateWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  const prevState = hook.memoizedState; // Assume these are defined. If they're not, areHookInputsEqual will warn.
+
+  if (nextDeps !== null) {
+    const prevDeps = prevState[1];
+
+    if (areHookInputsEqual(nextDeps, prevDeps)) {
+      return prevState[0];
+    }
+  }
+
+  if (shouldDoubleInvokeUserFnsInHooksDEV) {
+    nextCreate();
+  }
+
+  const nextValue = nextCreate();
+  hook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
+
+function mountDeferredValue(value, initialValue) {
+  const hook = mountWorkInProgressHook();
+  return mountDeferredValueImpl(hook, value, initialValue);
+}
+
+function updateDeferredValue(value, initialValue) {
+  const hook = updateWorkInProgressHook();
+  const resolvedCurrentHook = currentHook;
+  const prevValue = resolvedCurrentHook.memoizedState;
+  return updateDeferredValueImpl(hook, prevValue, value, initialValue);
+}
+
+function rerenderDeferredValue(value, initialValue) {
+  const hook = updateWorkInProgressHook();
+
+  if (currentHook === null) {
+    // This is a rerender during a mount.
+    return mountDeferredValueImpl(hook, value, initialValue);
+  } else {
+    // This is a rerender during an update.
+    const prevValue = currentHook.memoizedState;
+    return updateDeferredValueImpl(hook, prevValue, value, initialValue);
+  }
+}
+
+function mountDeferredValueImpl(hook, value, initialValue) {
+  if (// When `initialValue` is provided, we defer the initial render even if the
+  // current render is not synchronous.
+  initialValue !== undefined && // However, to avoid waterfalls, we do not defer if this render
+  // was itself spawned by an earlier useDeferredValue. Check if DeferredLane
+  // is part of the render lanes.
+  !includesSomeLane(renderLanes, DeferredLane)) {
+    // Render with the initial value
+    hook.memoizedState = initialValue; // Schedule a deferred render to switch to the final value.
+
+    const deferredLane = requestDeferredLane();
+    currentlyRenderingFiber$1.lanes = mergeLanes(currentlyRenderingFiber$1.lanes, deferredLane);
+    markSkippedUpdateLanes(deferredLane);
+    return initialValue;
+  } else {
+    hook.memoizedState = value;
+    return value;
+  }
+}
+
+function updateDeferredValueImpl(hook, prevValue, value, initialValue) {
+  if (objectIs(value, prevValue)) {
+    // The incoming value is referentially identical to the currently rendered
+    // value, so we can bail out quickly.
+    return value;
+  } else {
+    // Received a new value that's different from the current value.
+    // Check if we're inside a hidden tree
+    if (isCurrentTreeHidden()) {
+      // Revealing a prerendered tree is considered the same as mounting new
+      // one, so we reuse the "mount" path in this case.
+      const resultValue = mountDeferredValueImpl(hook, value, initialValue); // Unlike during an actual mount, we need to mark this as an update if
+      // the value changed.
+
+      if (!objectIs(resultValue, prevValue)) {
+        markWorkInProgressReceivedUpdate();
+      }
+
+      return resultValue;
+    }
+
+    const shouldDeferValue = !includesOnlyNonUrgentLanes(renderLanes);
+
+    if (shouldDeferValue) {
+      // This is an urgent update. Since the value has changed, keep using the
+      // previous value and spawn a deferred render to update it later.
+      // Schedule a deferred render
+      const deferredLane = requestDeferredLane();
+      currentlyRenderingFiber$1.lanes = mergeLanes(currentlyRenderingFiber$1.lanes, deferredLane);
+      markSkippedUpdateLanes(deferredLane); // Reuse the previous value. We do not need to mark this as an update,
+      // because we did not render a new value.
+
+      return prevValue;
+    } else {
+      // This is not an urgent update, so we can use the latest value regardless
+      // of what it is. No need to defer it.
+      // Mark this as an update to prevent the fiber from bailing out.
+      markWorkInProgressReceivedUpdate();
+      hook.memoizedState = value;
+      return value;
+    }
+  }
+}
+
+function startTransition(fiber, queue, pendingState, finishedState, callback, options) {
+  const previousPriority = getCurrentUpdatePriority();
+  setCurrentUpdatePriority(higherEventPriority(previousPriority, ContinuousEventPriority));
+  const prevTransition = ReactCurrentBatchConfig$3.transition;
+  const currentTransition = {};
+
+  {
+    // We don't really need to use an optimistic update here, because we
+    // schedule a second "revert" update below (which we use to suspend the
+    // transition until the async action scope has finished). But we'll use an
+    // optimistic update anyway to make it less likely the behavior accidentally
+    // diverges; for example, both an optimistic update and this one should
+    // share the same lane.
+    ReactCurrentBatchConfig$3.transition = currentTransition;
+    dispatchOptimisticSetState(fiber, false, queue, pendingState);
+  }
+
+  try {
+    if (enableAsyncActions) {
+      const returnValue = callback(); // Check if we're inside an async action scope. If so, we'll entangle
+      // this new action with the existing scope.
+      //
+      // If we're not already inside an async action scope, and this action is
+      // async, then we'll create a new async scope.
+      //
+      // In the async case, the resulting render will suspend until the async
+      // action scope has finished.
+
+      if (returnValue !== null && typeof returnValue === 'object' && typeof returnValue.then === 'function') {
+        const thenable = returnValue; // This is a thenable that resolves to `finishedState` once the async
+        // action scope has finished.
+
+        const entangledResult = requestAsyncActionContext(thenable, finishedState);
+        dispatchSetState(fiber, queue, entangledResult);
+      } else {
+        // This is either `finishedState` or a thenable that resolves to
+        // `finishedState`, depending on whether we're inside an async
+        // action scope.
+        const entangledResult = requestSyncActionContext(returnValue, finishedState);
+        dispatchSetState(fiber, queue, entangledResult);
+      }
+    }
+  } catch (error) {
+    {
+      // This is a trick to get the `useTransition` hook to rethrow the error.
+      // When it unwraps the thenable with the `use` algorithm, the error
+      // will be thrown.
+      const rejectedThenable = {
+        then() {},
+
+        status: 'rejected',
+        reason: error
+      };
+      dispatchSetState(fiber, queue, rejectedThenable);
+    }
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$3.transition = prevTransition;
+  }
+}
+
+function startHostTransition(formFiber, pendingState, callback, formData) {
+
+  if (formFiber.tag !== HostComponent) {
+    throw Error(formatProdErrorMessage(476));
+  }
+
+  let queue;
+
+  if (formFiber.memoizedState === null) {
+    // Upgrade this host component fiber to be stateful. We're going to pretend
+    // it was stateful all along so we can reuse most of the implementation
+    // for function components and useTransition.
+    //
+    // Create the state hook used by TransitionAwareHostComponent. This is
+    // essentially an inlined version of mountState.
+    const newQueue = {
+      pending: null,
+      lanes: NoLanes,
+      // We're going to cheat and intentionally not create a bound dispatch
+      // method, because we can call it directly in startTransition.
+      dispatch: null,
+      lastRenderedReducer: basicStateReducer,
+      lastRenderedState: NotPendingTransition
+    };
+    queue = newQueue;
+    const stateHook = {
+      memoizedState: NotPendingTransition,
+      baseState: NotPendingTransition,
+      baseQueue: null,
+      queue: newQueue,
+      next: null
+    }; // Add the state hook to both fiber alternates. The idea is that the fiber
+    // had this hook all along.
+
+    formFiber.memoizedState = stateHook;
+    const alternate = formFiber.alternate;
+
+    if (alternate !== null) {
+      alternate.memoizedState = stateHook;
+    }
+  } else {
+    // This fiber was already upgraded to be stateful.
+    const stateHook = formFiber.memoizedState;
+    queue = stateHook.queue;
+  }
+
+  startTransition(formFiber, queue, pendingState, NotPendingTransition, // TODO: We can avoid this extra wrapper, somehow. Figure out layering
+  // once more of this function is implemented.
+  () => callback(formData));
+}
+
+function mountTransition() {
+  const stateHook = mountStateImpl(false); // The `start` method never changes.
+
+  const start = startTransition.bind(null, currentlyRenderingFiber$1, stateHook.queue, true, false);
+  const hook = mountWorkInProgressHook();
+  hook.memoizedState = start;
+  return [false, start];
+}
+
+function updateTransition() {
+  const _updateState = updateState(),
+        booleanOrThenable = _updateState[0];
+
+  const hook = updateWorkInProgressHook();
+  const start = hook.memoizedState;
+  const isPending = typeof booleanOrThenable === 'boolean' ? booleanOrThenable : // This will suspend until the async action scope has finished.
+  useThenable(booleanOrThenable);
+  return [isPending, start];
+}
+
+function rerenderTransition() {
+  const _rerenderState = rerenderState(),
+        booleanOrThenable = _rerenderState[0];
+
+  const hook = updateWorkInProgressHook();
+  const start = hook.memoizedState;
+  const isPending = typeof booleanOrThenable === 'boolean' ? booleanOrThenable : // This will suspend until the async action scope has finished.
+  useThenable(booleanOrThenable);
+  return [isPending, start];
+}
+
+function useHostTransitionStatus() {
+
+  const status = readContext(HostTransitionContext);
+  return status !== null ? status : NotPendingTransition;
+}
+
+function mountId() {
+  const hook = mountWorkInProgressHook();
+  const root = getWorkInProgressRoot(); // TODO: In Fizz, id generation is specific to each server config. Maybe we
+  // should do this in Fiber, too? Deferring this decision for now because
+  // there's no other place to store the prefix except for an internal field on
+  // the public createRoot object, which the fiber tree does not currently have
+  // a reference to.
+
+  const identifierPrefix = root.identifierPrefix;
+  let id;
+
+  if (getIsHydrating()) {
+    const treeId = getTreeId(); // Use a captial R prefix for server-generated ids.
+
+    id = ':' + identifierPrefix + 'R' + treeId; // Unless this is the first id at this level, append a number at the end
+    // that represents the position of this useId hook among all the useId
+    // hooks for this fiber.
+
+    const localId = localIdCounter++;
+
+    if (localId > 0) {
+      id += 'H' + localId.toString(32);
+    }
+
+    id += ':';
+  } else {
+    // Use a lowercase r prefix for client-generated ids.
+    const globalClientId = globalClientIdCounter++;
+    id = ':' + identifierPrefix + 'r' + globalClientId.toString(32) + ':';
+  }
+
+  hook.memoizedState = id;
+  return id;
+}
+
+function updateId() {
+  const hook = updateWorkInProgressHook();
+  const id = hook.memoizedState;
+  return id;
+}
+
+function mountRefresh() {
+  const hook = mountWorkInProgressHook();
+  const refresh = hook.memoizedState = refreshCache.bind(null, currentlyRenderingFiber$1);
+  return refresh;
+}
+
+function updateRefresh() {
+  const hook = updateWorkInProgressHook();
+  return hook.memoizedState;
+}
+
+function refreshCache(fiber, seedKey, seedValue) {
+  // TODO: Consider warning if the refresh is at discrete priority, or if we
+  // otherwise suspect that it wasn't batched properly.
+
+
+  let provider = fiber.return;
+
+  while (provider !== null) {
+    switch (provider.tag) {
+      case CacheComponent:
+      case HostRoot:
+        {
+          // Schedule an update on the cache boundary to trigger a refresh.
+          const lane = requestUpdateLane(provider);
+          const refreshUpdate = createUpdate(lane);
+          const root = enqueueUpdate(provider, refreshUpdate, lane);
+
+          if (root !== null) {
+            scheduleUpdateOnFiber(root, provider, lane);
+            entangleTransitions(root, provider, lane);
+          } // TODO: If a refresh never commits, the new cache created here must be
+          // released. A simple case is start refreshing a cache boundary, but then
+          // unmount that boundary before the refresh completes.
+
+
+          const seededCache = createCache();
+
+          if (seedKey !== null && seedKey !== undefined && root !== null) {
+            {
+              // Seed the cache with the value passed by the caller. This could be
+              // from a server mutation, or it could be a streaming response.
+              seededCache.data.set(seedKey, seedValue);
+            }
+          }
+
+          const payload = {
+            cache: seededCache
+          };
+          refreshUpdate.payload = payload;
+          return;
+        }
+    }
+
+    provider = provider.return;
+  } // TODO: Warn if unmounted?
+
+}
+
+function dispatchReducerAction(fiber, queue, action) {
+
+  const lane = requestUpdateLane(fiber);
+  const update = {
+    lane,
+    revertLane: NoLane,
+    action,
+    hasEagerState: false,
+    eagerState: null,
+    next: null
+  };
+
+  if (isRenderPhaseUpdate(fiber)) {
+    enqueueRenderPhaseUpdate(queue, update);
+  } else {
+    const root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitionUpdate(root, queue, lane);
+    }
+  }
+}
+
+function dispatchSetState(fiber, queue, action) {
+
+  const lane = requestUpdateLane(fiber);
+  const update = {
+    lane,
+    revertLane: NoLane,
+    action,
+    hasEagerState: false,
+    eagerState: null,
+    next: null
+  };
+
+  if (isRenderPhaseUpdate(fiber)) {
+    enqueueRenderPhaseUpdate(queue, update);
+  } else {
+    const alternate = fiber.alternate;
+
+    if (fiber.lanes === NoLanes && (alternate === null || alternate.lanes === NoLanes)) {
+      // The queue is currently empty, which means we can eagerly compute the
+      // next state before entering the render phase. If the new state is the
+      // same as the current state, we may be able to bail out entirely.
+      const lastRenderedReducer = queue.lastRenderedReducer;
+
+      if (lastRenderedReducer !== null) {
+
+        try {
+          const currentState = queue.lastRenderedState;
+          const eagerState = lastRenderedReducer(currentState, action); // Stash the eagerly computed state, and the reducer used to compute
+          // it, on the update object. If the reducer hasn't changed by the
+          // time we enter the render phase, then the eager state can be used
+          // without calling the reducer again.
+
+          update.hasEagerState = true;
+          update.eagerState = eagerState;
+
+          if (objectIs(eagerState, currentState)) {
+            // Fast path. We can bail out without scheduling React to re-render.
+            // It's still possible that we'll need to rebase this update later,
+            // if the component re-renders for a different reason and by that
+            // time the reducer has changed.
+            // TODO: Do we still need to entangle transitions in this case?
+            enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update);
+            return;
+          }
+        } catch (error) {// Suppress the error. It will throw again in the render phase.
+        } finally {
+        }
+      }
+    }
+
+    const root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitionUpdate(root, queue, lane);
+    }
+  }
+}
+
+function dispatchOptimisticSetState(fiber, throwIfDuringRender, queue, action) {
+
+  const update = {
+    // An optimistic update commits synchronously.
+    lane: SyncLane,
+    // After committing, the optimistic update is "reverted" using the same
+    // lane as the transition it's associated with.
+    revertLane: requestTransitionLane(),
+    action,
+    hasEagerState: false,
+    eagerState: null,
+    next: null
+  };
+
+  if (isRenderPhaseUpdate(fiber)) {
+    // When calling startTransition during render, this warns instead of
+    // throwing because throwing would be a breaking change. setOptimisticState
+    // is a new API so it's OK to throw.
+    if (throwIfDuringRender) {
+      throw Error(formatProdErrorMessage(479));
+    }
+  } else {
+    const root = enqueueConcurrentHookUpdate(fiber, queue, update, SyncLane);
+
+    if (root !== null) {
+      // NOTE: The optimistic update implementation assumes that the transition
+      // will never be attempted before the optimistic update. This currently
+      // holds because the optimistic update is always synchronous. If we ever
+      // change that, we'll need to account for this.
+      scheduleUpdateOnFiber(root, fiber, SyncLane); // Optimistic updates are always synchronous, so we don't need to call
+      // entangleTransitionUpdate here.
+    }
+  }
+}
+
+function isRenderPhaseUpdate(fiber) {
+  const alternate = fiber.alternate;
+  return fiber === currentlyRenderingFiber$1 || alternate !== null && alternate === currentlyRenderingFiber$1;
+}
+
+function enqueueRenderPhaseUpdate(queue, update) {
+  // This is a render phase update. Stash it in a lazily-created map of
+  // queue -> linked list of updates. After this render pass, we'll restart
+  // and apply the stashed updates on top of the work-in-progress hook.
+  didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate = true;
+  const pending = queue.pending;
+
+  if (pending === null) {
+    // This is the first update. Create a circular list.
+    update.next = update;
+  } else {
+    update.next = pending.next;
+    pending.next = update;
+  }
+
+  queue.pending = update;
+} // TODO: Move to ReactFiberConcurrentUpdates?
+
+
+function entangleTransitionUpdate(root, queue, lane) {
+  if (isTransitionLane(lane)) {
+    let queueLanes = queue.lanes; // If any entangled lanes are no longer pending on the root, then they
+    // must have finished. We can remove them from the shared queue, which
+    // represents a superset of the actually pending lanes. In some cases we
+    // may entangle more than we need to, but that's OK. In fact it's worse if
+    // we *don't* entangle when we should.
+
+    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.
+
+    const newQueueLanes = mergeLanes(queueLanes, lane);
+    queue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if
+    // the lane finished since the last time we entangled it. So we need to
+    // entangle it again, just to be sure.
+
+    markRootEntangled(root, newQueueLanes);
+  }
+}
+
+const ContextOnlyDispatcher = {
+  readContext,
+  use,
+  useCallback: throwInvalidHookError,
+  useContext: throwInvalidHookError,
+  useEffect: throwInvalidHookError,
+  useImperativeHandle: throwInvalidHookError,
+  useInsertionEffect: throwInvalidHookError,
+  useLayoutEffect: throwInvalidHookError,
+  useMemo: throwInvalidHookError,
+  useReducer: throwInvalidHookError,
+  useRef: throwInvalidHookError,
+  useState: throwInvalidHookError,
+  useDebugValue: throwInvalidHookError,
+  useDeferredValue: throwInvalidHookError,
+  useTransition: throwInvalidHookError,
+  useSyncExternalStore: throwInvalidHookError,
+  useId: throwInvalidHookError
+};
+
+{
+  ContextOnlyDispatcher.useCacheRefresh = throwInvalidHookError;
+}
+
+{
+  ContextOnlyDispatcher.useMemoCache = throwInvalidHookError;
+}
+
+{
+  ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
+}
+
+{
+  ContextOnlyDispatcher.useHostTransitionStatus = throwInvalidHookError;
+  ContextOnlyDispatcher.useFormState = throwInvalidHookError;
+}
+
+{
+  ContextOnlyDispatcher.useOptimistic = throwInvalidHookError;
+}
+
+const HooksDispatcherOnMount = {
+  readContext,
+  use,
+  useCallback: mountCallback,
+  useContext: readContext,
+  useEffect: mountEffect,
+  useImperativeHandle: mountImperativeHandle,
+  useLayoutEffect: mountLayoutEffect,
+  useInsertionEffect: mountInsertionEffect,
+  useMemo: mountMemo,
+  useReducer: mountReducer,
+  useRef: mountRef,
+  useState: mountState,
+  useDebugValue: mountDebugValue,
+  useDeferredValue: mountDeferredValue,
+  useTransition: mountTransition,
+  useSyncExternalStore: mountSyncExternalStore,
+  useId: mountId
+};
+
+{
+  HooksDispatcherOnMount.useCacheRefresh = mountRefresh;
+}
+
+{
+  HooksDispatcherOnMount.useMemoCache = useMemoCache;
+}
+
+{
+  HooksDispatcherOnMount.useEffectEvent = mountEvent;
+}
+
+{
+  HooksDispatcherOnMount.useHostTransitionStatus = useHostTransitionStatus;
+  HooksDispatcherOnMount.useFormState = mountFormState;
+}
+
+{
+  HooksDispatcherOnMount.useOptimistic = mountOptimistic;
+}
+
+const HooksDispatcherOnUpdate = {
+  readContext,
+  use,
+  useCallback: updateCallback,
+  useContext: readContext,
+  useEffect: updateEffect,
+  useImperativeHandle: updateImperativeHandle,
+  useInsertionEffect: updateInsertionEffect,
+  useLayoutEffect: updateLayoutEffect,
+  useMemo: updateMemo,
+  useReducer: updateReducer,
+  useRef: updateRef,
+  useState: updateState,
+  useDebugValue: updateDebugValue,
+  useDeferredValue: updateDeferredValue,
+  useTransition: updateTransition,
+  useSyncExternalStore: updateSyncExternalStore,
+  useId: updateId
+};
+
+{
+  HooksDispatcherOnUpdate.useCacheRefresh = updateRefresh;
+}
+
+{
+  HooksDispatcherOnUpdate.useMemoCache = useMemoCache;
+}
+
+{
+  HooksDispatcherOnUpdate.useEffectEvent = updateEvent;
+}
+
+{
+  HooksDispatcherOnUpdate.useHostTransitionStatus = useHostTransitionStatus;
+  HooksDispatcherOnUpdate.useFormState = updateFormState;
+}
+
+{
+  HooksDispatcherOnUpdate.useOptimistic = updateOptimistic;
+}
+
+const HooksDispatcherOnRerender = {
+  readContext,
+  use,
+  useCallback: updateCallback,
+  useContext: readContext,
+  useEffect: updateEffect,
+  useImperativeHandle: updateImperativeHandle,
+  useInsertionEffect: updateInsertionEffect,
+  useLayoutEffect: updateLayoutEffect,
+  useMemo: updateMemo,
+  useReducer: rerenderReducer,
+  useRef: updateRef,
+  useState: rerenderState,
+  useDebugValue: updateDebugValue,
+  useDeferredValue: rerenderDeferredValue,
+  useTransition: rerenderTransition,
+  useSyncExternalStore: updateSyncExternalStore,
+  useId: updateId
+};
+
+{
+  HooksDispatcherOnRerender.useCacheRefresh = updateRefresh;
+}
+
+{
+  HooksDispatcherOnRerender.useMemoCache = useMemoCache;
+}
+
+{
+  HooksDispatcherOnRerender.useEffectEvent = updateEvent;
+}
+
+{
+  HooksDispatcherOnRerender.useHostTransitionStatus = useHostTransitionStatus;
+  HooksDispatcherOnRerender.useFormState = rerenderFormState;
+}
+
+{
+  HooksDispatcherOnRerender.useOptimistic = rerenderOptimistic;
+}
+
+function recordLayoutEffectDuration(fiber) {
+  {
+    return;
+  }
+}
+
+function startLayoutEffectTimer() {
+  {
+    return;
+  }
+}
+
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    // Resolve default props. Taken from ReactElement
+    const props = assign({}, baseProps);
+    const defaultProps = Component.defaultProps;
+
+    for (const propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+
+    return props;
+  }
+
+  return baseProps;
+}
+
+function applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, nextProps) {
+  const prevState = workInProgress.memoizedState;
+  let partialState = getDerivedStateFromProps(nextProps, prevState);
+
+
+  const memoizedState = partialState === null || partialState === undefined ? prevState : assign({}, prevState, partialState);
+  workInProgress.memoizedState = memoizedState; // Once the update queue is empty, persist the derived state onto the
+  // base state.
+
+  if (workInProgress.lanes === NoLanes) {
+    // Queue is always non-null for classes
+    const updateQueue = workInProgress.updateQueue;
+    updateQueue.baseState = memoizedState;
+  }
+}
+
+const classComponentUpdater = {
+  isMounted,
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueSetState(inst, payload, callback) {
+    const fiber = get(inst);
+    const lane = requestUpdateLane(fiber);
+    const update = createUpdate(lane);
+    update.payload = payload;
+
+    if (callback !== undefined && callback !== null) {
+
+      update.callback = callback;
+    }
+
+    const root = enqueueUpdate(fiber, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitions(root, fiber, lane);
+    }
+  },
+
+  enqueueReplaceState(inst, payload, callback) {
+    const fiber = get(inst);
+    const lane = requestUpdateLane(fiber);
+    const update = createUpdate(lane);
+    update.tag = ReplaceState;
+    update.payload = payload;
+
+    if (callback !== undefined && callback !== null) {
+
+      update.callback = callback;
+    }
+
+    const root = enqueueUpdate(fiber, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitions(root, fiber, lane);
+    }
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueForceUpdate(inst, callback) {
+    const fiber = get(inst);
+    const lane = requestUpdateLane(fiber);
+    const update = createUpdate(lane);
+    update.tag = ForceUpdate;
+
+    if (callback !== undefined && callback !== null) {
+
+      update.callback = callback;
+    }
+
+    const root = enqueueUpdate(fiber, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitions(root, fiber, lane);
+    }
+  }
+
+};
+
+function checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {
+  const instance = workInProgress.stateNode;
+
+  if (typeof instance.shouldComponentUpdate === 'function') {
+    let shouldUpdate = instance.shouldComponentUpdate(newProps, newState, nextContext);
+
+    return shouldUpdate;
+  }
+
+  if (ctor.prototype && ctor.prototype.isPureReactComponent) {
+    return !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState);
+  }
+
+  return true;
+}
+
+function adoptClassInstance(workInProgress, instance) {
+  instance.updater = classComponentUpdater;
+  workInProgress.stateNode = instance; // The instance needs access to the fiber so that it can schedule updates
+
+  set(instance, workInProgress);
+}
+
+function constructClassInstance(workInProgress, ctor, props) {
+  let isLegacyContextConsumer = false;
+  let unmaskedContext = emptyContextObject;
+  let context = emptyContextObject;
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    context = readContext(contextType);
+  } else {
+    unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    const contextTypes = ctor.contextTypes;
+    isLegacyContextConsumer = contextTypes !== null && contextTypes !== undefined;
+    context = isLegacyContextConsumer ? getMaskedContext(workInProgress, unmaskedContext) : emptyContextObject;
+  }
+
+  let instance = new ctor(props, context); // Instantiate twice to help detect side-effects.
+
+  workInProgress.memoizedState = instance.state !== null && instance.state !== undefined ? instance.state : null;
+  adoptClassInstance(workInProgress, instance);
+  // ReactFiberContext usually updates this cache but can't for newly-created instances.
+
+
+  if (isLegacyContextConsumer) {
+    cacheContext(workInProgress, unmaskedContext, context);
+  }
+
+  return instance;
+}
+
+function callComponentWillMount(workInProgress, instance) {
+  const oldState = instance.state;
+
+  if (typeof instance.componentWillMount === 'function') {
+    instance.componentWillMount();
+  }
+
+  if (typeof instance.UNSAFE_componentWillMount === 'function') {
+    instance.UNSAFE_componentWillMount();
+  }
+
+  if (oldState !== instance.state) {
+
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+}
+
+function callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {
+  const oldState = instance.state;
+
+  if (typeof instance.componentWillReceiveProps === 'function') {
+    instance.componentWillReceiveProps(newProps, nextContext);
+  }
+
+  if (typeof instance.UNSAFE_componentWillReceiveProps === 'function') {
+    instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+  }
+
+  if (instance.state !== oldState) {
+
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+} // Invokes the mount life-cycles on a previously never rendered instance.
+
+
+function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+
+  const instance = workInProgress.stateNode;
+  instance.props = newProps;
+  instance.state = workInProgress.memoizedState;
+  instance.refs = {};
+  initializeUpdateQueue(workInProgress);
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    instance.context = readContext(contextType);
+  } else {
+    const unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    instance.context = getMaskedContext(workInProgress, unmaskedContext);
+  }
+
+  instance.state = workInProgress.memoizedState;
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+    instance.state = workInProgress.memoizedState;
+  } // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+
+  if (typeof ctor.getDerivedStateFromProps !== 'function' && typeof instance.getSnapshotBeforeUpdate !== 'function' && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
+    callComponentWillMount(workInProgress, instance); // If we had additional state updates during this life-cycle, let's
+    // process them now.
+
+    processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+    instance.state = workInProgress.memoizedState;
+  }
+
+  if (typeof instance.componentDidMount === 'function') {
+    workInProgress.flags |= Update | LayoutStatic;
+  }
+}
+
+function resumeMountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+  const instance = workInProgress.stateNode;
+  const oldProps = workInProgress.memoizedProps;
+  instance.props = oldProps;
+  const oldContext = instance.context;
+  const contextType = ctor.contextType;
+  let nextContext = emptyContextObject;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    nextContext = readContext(contextType);
+  } else {
+    const nextLegacyUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    nextContext = getMaskedContext(workInProgress, nextLegacyUnmaskedContext);
+  }
+
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+  const hasNewLifecycles = typeof getDerivedStateFromProps === 'function' || typeof instance.getSnapshotBeforeUpdate === 'function'; // Note: During these life-cycles, instance.props/instance.state are what
+  // ever the previously attempted to render - not the "current". However,
+  // during componentDidUpdate we pass the "current" props.
+  // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+  if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === 'function' || typeof instance.componentWillReceiveProps === 'function')) {
+    if (oldProps !== newProps || oldContext !== nextContext) {
+      callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
+    }
+  }
+
+  resetHasForceUpdateBeforeProcessing();
+  const oldState = workInProgress.memoizedState;
+  let newState = instance.state = oldState;
+  processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+  newState = workInProgress.memoizedState;
+
+  if (oldProps === newProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing()) {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidMount === 'function') {
+      workInProgress.flags |= Update | LayoutStatic;
+    }
+
+    return false;
+  }
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+    newState = workInProgress.memoizedState;
+  }
+
+  const shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext);
+
+  if (shouldUpdate) {
+    // In order to support react-lifecycles-compat polyfilled components,
+    // Unsafe lifecycles should not be invoked for components using the new APIs.
+    if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
+      if (typeof instance.componentWillMount === 'function') {
+        instance.componentWillMount();
+      }
+
+      if (typeof instance.UNSAFE_componentWillMount === 'function') {
+        instance.UNSAFE_componentWillMount();
+      }
+    }
+
+    if (typeof instance.componentDidMount === 'function') {
+      workInProgress.flags |= Update | LayoutStatic;
+    }
+  } else {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidMount === 'function') {
+      workInProgress.flags |= Update | LayoutStatic;
+    }
+    // memoized state to indicate that this work can be reused.
+
+
+    workInProgress.memoizedProps = newProps;
+    workInProgress.memoizedState = newState;
+  } // Update the existing instance's state, props, and context pointers even
+  // if shouldComponentUpdate returns false.
+
+
+  instance.props = newProps;
+  instance.state = newState;
+  instance.context = nextContext;
+  return shouldUpdate;
+} // Invokes the update life-cycles and returns false if it shouldn't rerender.
+
+
+function updateClassInstance(current, workInProgress, ctor, newProps, renderLanes) {
+  const instance = workInProgress.stateNode;
+  cloneUpdateQueue(current, workInProgress);
+  const unresolvedOldProps = workInProgress.memoizedProps;
+  const oldProps = workInProgress.type === workInProgress.elementType ? unresolvedOldProps : resolveDefaultProps(workInProgress.type, unresolvedOldProps);
+  instance.props = oldProps;
+  const unresolvedNewProps = workInProgress.pendingProps;
+  const oldContext = instance.context;
+  const contextType = ctor.contextType;
+  let nextContext = emptyContextObject;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    nextContext = readContext(contextType);
+  } else {
+    const nextUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    nextContext = getMaskedContext(workInProgress, nextUnmaskedContext);
+  }
+
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+  const hasNewLifecycles = typeof getDerivedStateFromProps === 'function' || typeof instance.getSnapshotBeforeUpdate === 'function'; // Note: During these life-cycles, instance.props/instance.state are what
+  // ever the previously attempted to render - not the "current". However,
+  // during componentDidUpdate we pass the "current" props.
+  // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+  if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === 'function' || typeof instance.componentWillReceiveProps === 'function')) {
+    if (unresolvedOldProps !== unresolvedNewProps || oldContext !== nextContext) {
+      callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
+    }
+  }
+
+  resetHasForceUpdateBeforeProcessing();
+  const oldState = workInProgress.memoizedState;
+  let newState = instance.state = oldState;
+  processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+  newState = workInProgress.memoizedState;
+
+  if (unresolvedOldProps === unresolvedNewProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing() && !(enableLazyContextPropagation   )) {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidUpdate === 'function') {
+      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+        workInProgress.flags |= Update;
+      }
+    }
+
+    if (typeof instance.getSnapshotBeforeUpdate === 'function') {
+      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+        workInProgress.flags |= Snapshot;
+      }
+    }
+
+    return false;
+  }
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+    newState = workInProgress.memoizedState;
+  }
+
+  const shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) || // TODO: In some cases, we'll end up checking if context has changed twice,
+  // both before and after `shouldComponentUpdate` has been called. Not ideal,
+  // but I'm loath to refactor this function. This only happens for memoized
+  // components so it's not that common.
+  enableLazyContextPropagation   ;
+
+  if (shouldUpdate) {
+    // In order to support react-lifecycles-compat polyfilled components,
+    // Unsafe lifecycles should not be invoked for components using the new APIs.
+    if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillUpdate === 'function' || typeof instance.componentWillUpdate === 'function')) {
+      if (typeof instance.componentWillUpdate === 'function') {
+        instance.componentWillUpdate(newProps, newState, nextContext);
+      }
+
+      if (typeof instance.UNSAFE_componentWillUpdate === 'function') {
+        instance.UNSAFE_componentWillUpdate(newProps, newState, nextContext);
+      }
+    }
+
+    if (typeof instance.componentDidUpdate === 'function') {
+      workInProgress.flags |= Update;
+    }
+
+    if (typeof instance.getSnapshotBeforeUpdate === 'function') {
+      workInProgress.flags |= Snapshot;
+    }
+  } else {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidUpdate === 'function') {
+      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+        workInProgress.flags |= Update;
+      }
+    }
+
+    if (typeof instance.getSnapshotBeforeUpdate === 'function') {
+      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+        workInProgress.flags |= Snapshot;
+      }
+    } // If shouldComponentUpdate returned false, we should still update the
+    // memoized props/state to indicate that this work can be reused.
+
+
+    workInProgress.memoizedProps = newProps;
+    workInProgress.memoizedState = newState;
+  } // Update the existing instance's state, props, and context pointers even
+  // if shouldComponentUpdate returns false.
+
+
+  instance.props = newProps;
+  instance.state = newState;
+  instance.context = nextContext;
+  return shouldUpdate;
+}
+
+function createCapturedValueAtFiber(value, source) {
+  // If the value is an error, call this function immediately after it is thrown
+  // so the stack is accurate.
+  return {
+    value,
+    source,
+    stack: getStackByFiberInDevAndProd(source),
+    digest: null
+  };
+}
+function createCapturedValue(value, digest, stack) {
+  return {
+    value,
+    source: null,
+    stack: stack != null ? stack : null,
+    digest: digest != null ? digest : null
+  };
+}
+
+// This module is forked in different environments.
+// By default, return `true` to log errors to the console.
+// Forks can return `false` if this isn't desirable.
+function showErrorDialog(boundary, errorInfo) {
+  return true;
+}
+
+function logCapturedError(boundary, errorInfo) {
+  try {
+    const logError = showErrorDialog(boundary, errorInfo); // Allow injected showErrorDialog() to prevent default console.error logging.
+    // This enables renderers like ReactNative to better manage redbox behavior.
+
+    if (logError === false) ;
+
+    const error = errorInfo.value;
+
+    if (false) ; else {
+      // In production, we print the error directly.
+      // This will include the message, the JS stack, and anything the browser wants to show.
+      // We pass the error object instead of custom message so that the browser displays the error natively.
+      console['error'](error); // Don't transform to our wrapper
+    }
+  } catch (e) {
+    // This method must not throw, or React internal state will get messed up.
+    // If console.error is overridden, or logCapturedError() shows a dialog that throws,
+    // we want to report this error outside of the normal stack as a last resort.
+    // https://github.com/facebook/react/issues/13188
+    setTimeout(() => {
+      throw e;
+    });
+  }
+}
+
+function createRootErrorUpdate(fiber, errorInfo, lane) {
+  const update = createUpdate(lane); // Unmount the root by rendering null.
+
+  update.tag = CaptureUpdate; // Caution: React DevTools currently depends on this property
+  // being called "element".
+
+  update.payload = {
+    element: null
+  };
+  const error = errorInfo.value;
+
+  update.callback = () => {
+    onUncaughtError(error);
+    logCapturedError(fiber, errorInfo);
+  };
+
+  return update;
+}
+
+function createClassErrorUpdate(fiber, errorInfo, lane) {
+  const update = createUpdate(lane);
+  update.tag = CaptureUpdate;
+  const getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+
+  if (typeof getDerivedStateFromError === 'function') {
+    const error = errorInfo.value;
+
+    update.payload = () => {
+      return getDerivedStateFromError(error);
+    };
+
+    update.callback = () => {
+
+      logCapturedError(fiber, errorInfo);
+    };
+  }
+
+  const inst = fiber.stateNode;
+
+  if (inst !== null && typeof inst.componentDidCatch === 'function') {
+    // $FlowFixMe[missing-this-annot]
+    update.callback = function callback() {
+
+      logCapturedError(fiber, errorInfo);
+
+      if (typeof getDerivedStateFromError !== 'function') {
+        // To preserve the preexisting retry behavior of error boundaries,
+        // we keep track of which ones already failed during this batch.
+        // This gets reset before we yield back to the browser.
+        // TODO: Warn in strict mode if getDerivedStateFromError is
+        // not defined.
+        markLegacyErrorBoundaryAsFailed(this);
+      }
+
+      const error = errorInfo.value;
+      const stack = errorInfo.stack;
+      this.componentDidCatch(error, {
+        componentStack: stack !== null ? stack : ''
+      });
+    };
+  }
+
+  return update;
+}
+
+function resetSuspendedComponent(sourceFiber, rootRenderLanes) {
+  // A legacy mode Suspense quirk, only relevant to hook components.
+
+
+  const tag = sourceFiber.tag;
+
+  if ((sourceFiber.mode & ConcurrentMode) === NoMode && (tag === FunctionComponent || tag === ForwardRef || tag === SimpleMemoComponent)) {
+    const currentSource = sourceFiber.alternate;
+
+    if (currentSource) {
+      sourceFiber.updateQueue = currentSource.updateQueue;
+      sourceFiber.memoizedState = currentSource.memoizedState;
+      sourceFiber.lanes = currentSource.lanes;
+    } else {
+      sourceFiber.updateQueue = null;
+      sourceFiber.memoizedState = null;
+    }
+  }
+}
+
+function markSuspenseBoundaryShouldCapture(suspenseBoundary, returnFiber, sourceFiber, root, rootRenderLanes) {
+  // This marks a Suspense boundary so that when we're unwinding the stack,
+  // it captures the suspended "exception" and does a second (fallback) pass.
+  if ((suspenseBoundary.mode & ConcurrentMode) === NoMode) {
+    // Legacy Mode Suspense
+    //
+    // If the boundary is in legacy mode, we should *not*
+    // suspend the commit. Pretend as if the suspended component rendered
+    // null and keep rendering. When the Suspense boundary completes,
+    // we'll do a second pass to render the fallback.
+    if (suspenseBoundary === returnFiber) {
+      // Special case where we suspended while reconciling the children of
+      // a Suspense boundary's inner Offscreen wrapper fiber. This happens
+      // when a React.lazy component is a direct child of a
+      // Suspense boundary.
+      //
+      // Suspense boundaries are implemented as multiple fibers, but they
+      // are a single conceptual unit. The legacy mode behavior where we
+      // pretend the suspended fiber committed as `null` won't work,
+      // because in this case the "suspended" fiber is the inner
+      // Offscreen wrapper.
+      //
+      // Because the contents of the boundary haven't started rendering
+      // yet (i.e. nothing in the tree has partially rendered) we can
+      // switch to the regular, concurrent mode behavior: mark the
+      // boundary with ShouldCapture and enter the unwind phase.
+      suspenseBoundary.flags |= ShouldCapture;
+    } else {
+      suspenseBoundary.flags |= DidCapture;
+      sourceFiber.flags |= ForceUpdateForLegacySuspense; // We're going to commit this fiber even though it didn't complete.
+      // But we shouldn't call any lifecycle methods or callbacks. Remove
+      // all lifecycle effect tags.
+
+      sourceFiber.flags &= ~(LifecycleEffectMask | Incomplete);
+
+      if (sourceFiber.tag === ClassComponent) {
+        const currentSourceFiber = sourceFiber.alternate;
+
+        if (currentSourceFiber === null) {
+          // This is a new mount. Change the tag so it's not mistaken for a
+          // completed class component. For example, we should not call
+          // componentWillUnmount if it is deleted.
+          sourceFiber.tag = IncompleteClassComponent;
+        } else {
+          // When we try rendering again, we should not reuse the current fiber,
+          // since it's known to be in an inconsistent state. Use a force update to
+          // prevent a bail out.
+          const update = createUpdate(SyncLane);
+          update.tag = ForceUpdate;
+          enqueueUpdate(sourceFiber, update, SyncLane);
+        }
+      } // The source fiber did not complete. Mark it with Sync priority to
+      // indicate that it still has pending work.
+
+
+      sourceFiber.lanes = mergeLanes(sourceFiber.lanes, SyncLane);
+    }
+
+    return suspenseBoundary;
+  } // Confirmed that the boundary is in a concurrent mode tree. Continue
+  // with the normal suspend path.
+  //
+  // After this we'll use a set of heuristics to determine whether this
+  // render pass will run to completion or restart or "suspend" the commit.
+  // The actual logic for this is spread out in different places.
+  //
+  // This first principle is that if we're going to suspend when we complete
+  // a root, then we should also restart if we get an update or ping that
+  // might unsuspend it, and vice versa. The only reason to suspend is
+  // because you think you might want to restart before committing. However,
+  // it doesn't make sense to restart only while in the period we're suspended.
+  //
+  // Restarting too aggressively is also not good because it starves out any
+  // intermediate loading state. So we use heuristics to determine when.
+  // Suspense Heuristics
+  //
+  // If nothing threw a Promise or all the same fallbacks are already showing,
+  // then don't suspend/restart.
+  //
+  // If this is an initial render of a new tree of Suspense boundaries and
+  // those trigger a fallback, then don't suspend/restart. We want to ensure
+  // that we can show the initial loading state as quickly as possible.
+  //
+  // If we hit a "Delayed" case, such as when we'd switch from content back into
+  // a fallback, then we should always suspend/restart. Transitions apply
+  // to this case. If none is defined, JND is used instead.
+  //
+  // If we're already showing a fallback and it gets "retried", allowing us to show
+  // another level, but there's still an inner boundary that would show a fallback,
+  // then we suspend/restart for 500ms since the last time we showed a fallback
+  // anywhere in the tree. This effectively throttles progressive loading into a
+  // consistent train of commits. This also gives us an opportunity to restart to
+  // get to the completed state slightly earlier.
+  //
+  // If there's ambiguity due to batching it's resolved in preference of:
+  // 1) "delayed", 2) "initial render", 3) "retry".
+  //
+  // We want to ensure that a "busy" state doesn't get force committed. We want to
+  // ensure that new initial loading states can commit as soon as possible.
+
+
+  suspenseBoundary.flags |= ShouldCapture; // TODO: I think we can remove this, since we now use `DidCapture` in
+  // the begin phase to prevent an early bailout.
+
+  suspenseBoundary.lanes = rootRenderLanes;
+  return suspenseBoundary;
+}
+
+function throwException(root, returnFiber, sourceFiber, value, rootRenderLanes) {
+  // The source fiber did not complete.
+  sourceFiber.flags |= Incomplete;
+
+  if (value !== null && typeof value === 'object') {
+    if (value.$$typeof === REACT_POSTPONE_TYPE) {
+      // Act as if this is an infinitely suspending promise.
+      value = {
+        then: function () {}
+      };
+    }
+
+    if (typeof value.then === 'function') {
+      // This is a wakeable. The component suspended.
+      const wakeable = value;
+      resetSuspendedComponent(sourceFiber);
+
+
+      const suspenseBoundary = getSuspenseHandler();
+
+      if (suspenseBoundary !== null) {
+        switch (suspenseBoundary.tag) {
+          case SuspenseComponent:
+            {
+              // If this suspense boundary is not already showing a fallback, mark
+              // the in-progress render as suspended. We try to perform this logic
+              // as soon as soon as possible during the render phase, so the work
+              // loop can know things like whether it's OK to switch to other tasks,
+              // or whether it can wait for data to resolve before continuing.
+              // TODO: Most of these checks are already performed when entering a
+              // Suspense boundary. We should track the information on the stack so
+              // we don't have to recompute it on demand. This would also allow us
+              // to unify with `use` which needs to perform this logic even sooner,
+              // before `throwException` is called.
+              if (sourceFiber.mode & ConcurrentMode) {
+                if (getShellBoundary() === null) {
+                  // Suspended in the "shell" of the app. This is an undesirable
+                  // loading state. We should avoid committing this tree.
+                  renderDidSuspendDelayIfPossible();
+                } else {
+                  // If we suspended deeper than the shell, we don't need to delay
+                  // the commmit. However, we still call renderDidSuspend if this is
+                  // a new boundary, to tell the work loop that a new fallback has
+                  // appeared during this render.
+                  // TODO: Theoretically we should be able to delete this branch.
+                  // It's currently used for two things: 1) to throttle the
+                  // appearance of successive loading states, and 2) in
+                  // SuspenseList, to determine whether the children include any
+                  // pending fallbacks. For 1, we should apply throttling to all
+                  // retries, not just ones that render an additional fallback. For
+                  // 2, we should check subtreeFlags instead. Then we can delete
+                  // this branch.
+                  const current = suspenseBoundary.alternate;
+
+                  if (current === null) {
+                    renderDidSuspend();
+                  }
+                }
+              }
+
+              suspenseBoundary.flags &= ~ForceClientRender;
+              markSuspenseBoundaryShouldCapture(suspenseBoundary, returnFiber, sourceFiber, root, rootRenderLanes); // Retry listener
+              //
+              // If the fallback does commit, we need to attach a different type of
+              // listener. This one schedules an update on the Suspense boundary to
+              // turn the fallback state off.
+              //
+              // Stash the wakeable on the boundary fiber so we can access it in the
+              // commit phase.
+              //
+              // When the wakeable resolves, we'll attempt to render the boundary
+              // again ("retry").
+              // Check if this is a Suspensey resource. We do not attach retry
+              // listeners to these, because we don't actually need them for
+              // rendering. Only for committing. Instead, if a fallback commits
+              // and the only thing that suspended was a Suspensey resource, we
+              // retry immediately.
+              // TODO: Refactor throwException so that we don't have to do this type
+              // check. The caller already knows what the cause was.
+
+              const isSuspenseyResource = wakeable === noopSuspenseyCommitThenable;
+
+              if (isSuspenseyResource) {
+                suspenseBoundary.flags |= ScheduleRetry;
+              } else {
+                const retryQueue = suspenseBoundary.updateQueue;
+
+                if (retryQueue === null) {
+                  suspenseBoundary.updateQueue = new Set([wakeable]);
+                } else {
+                  retryQueue.add(wakeable);
+                } // We only attach ping listeners in concurrent mode. Legacy
+                // Suspense always commits fallbacks synchronously, so there are
+                // no pings.
+
+
+                if (suspenseBoundary.mode & ConcurrentMode) {
+                  attachPingListener(root, wakeable, rootRenderLanes);
+                }
+              }
+
+              return;
+            }
+
+          case OffscreenComponent:
+            {
+              if (suspenseBoundary.mode & ConcurrentMode) {
+                suspenseBoundary.flags |= ShouldCapture;
+                const isSuspenseyResource = wakeable === noopSuspenseyCommitThenable;
+
+                if (isSuspenseyResource) {
+                  suspenseBoundary.flags |= ScheduleRetry;
+                } else {
+                  const offscreenQueue = suspenseBoundary.updateQueue;
+
+                  if (offscreenQueue === null) {
+                    const newOffscreenQueue = {
+                      transitions: null,
+                      markerInstances: null,
+                      retryQueue: new Set([wakeable])
+                    };
+                    suspenseBoundary.updateQueue = newOffscreenQueue;
+                  } else {
+                    const retryQueue = offscreenQueue.retryQueue;
+
+                    if (retryQueue === null) {
+                      offscreenQueue.retryQueue = new Set([wakeable]);
+                    } else {
+                      retryQueue.add(wakeable);
+                    }
+                  }
+
+                  attachPingListener(root, wakeable, rootRenderLanes);
+                }
+
+                return;
+              }
+            }
+        }
+
+        throw Error(formatProdErrorMessage(435, suspenseBoundary.tag));
+      } else {
+        // No boundary was found. Unless this is a sync update, this is OK.
+        // We can suspend and wait for more data to arrive.
+        if (root.tag === ConcurrentRoot) {
+          // In a concurrent root, suspending without a Suspense boundary is
+          // allowed. It will suspend indefinitely without committing.
+          //
+          // TODO: Should we have different behavior for discrete updates? What
+          // about flushSync? Maybe it should put the tree into an inert state,
+          // and potentially log a warning. Revisit this for a future release.
+          attachPingListener(root, wakeable, rootRenderLanes);
+          renderDidSuspendDelayIfPossible();
+          return;
+        } else {
+          // In a legacy root, suspending without a boundary is always an error.
+          const uncaughtSuspenseError = Error(formatProdErrorMessage(426));
+          value = uncaughtSuspenseError;
+        }
+      }
+    }
+  } // This is a regular error, not a Suspense wakeable.
+
+
+  if (getIsHydrating() && sourceFiber.mode & ConcurrentMode) {
+    const suspenseBoundary = getSuspenseHandler(); // If the error was thrown during hydration, we may be able to recover by
+    // discarding the dehydrated content and switching to a client render.
+    // Instead of surfacing the error, find the nearest Suspense boundary
+    // and render it again without hydration.
+
+    if (suspenseBoundary !== null) {
+      if ((suspenseBoundary.flags & ShouldCapture) === NoFlags$1) {
+        // Set a flag to indicate that we should try rendering the normal
+        // children again, not the fallback.
+        suspenseBoundary.flags |= ForceClientRender;
+      }
+
+      markSuspenseBoundaryShouldCapture(suspenseBoundary, returnFiber, sourceFiber, root, rootRenderLanes); // Even though the user may not be affected by this error, we should
+      // still log it so it can be fixed.
+
+      queueHydrationError(createCapturedValueAtFiber(value, sourceFiber));
+      return;
+    }
+  }
+
+  value = createCapturedValueAtFiber(value, sourceFiber);
+  renderDidError(value); // We didn't find a boundary that could handle this type of exception. Start
+  // over and traverse parent path again, this time treating the exception
+  // as an error.
+
+  let workInProgress = returnFiber;
+
+  do {
+    switch (workInProgress.tag) {
+      case HostRoot:
+        {
+          const errorInfo = value;
+          workInProgress.flags |= ShouldCapture;
+          const lane = pickArbitraryLane(rootRenderLanes);
+          workInProgress.lanes = mergeLanes(workInProgress.lanes, lane);
+          const update = createRootErrorUpdate(workInProgress, errorInfo, lane);
+          enqueueCapturedUpdate(workInProgress, update);
+          return;
+        }
+
+      case ClassComponent:
+        // Capture and retry
+        const errorInfo = value;
+        const ctor = workInProgress.type;
+        const instance = workInProgress.stateNode;
+
+        if ((workInProgress.flags & DidCapture) === NoFlags$1 && (typeof ctor.getDerivedStateFromError === 'function' || instance !== null && typeof instance.componentDidCatch === 'function' && !isAlreadyFailedLegacyErrorBoundary(instance))) {
+          workInProgress.flags |= ShouldCapture;
+          const lane = pickArbitraryLane(rootRenderLanes);
+          workInProgress.lanes = mergeLanes(workInProgress.lanes, lane); // Schedule the error boundary to re-render using updated state
+
+          const update = createClassErrorUpdate(workInProgress, errorInfo, lane);
+          enqueueCapturedUpdate(workInProgress, update);
+          return;
+        }
+
+        break;
+    } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+    workInProgress = workInProgress.return;
+  } while (workInProgress !== null);
+}
+
+const ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner; // A special exception that's used to unwind the stack when an update flows
+// into a dehydrated boundary.
+
+const SelectiveHydrationException = Error(formatProdErrorMessage(461));
+let didReceiveUpdate = false;
+
+function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
+  if (current === null) {
+    // If this is a fresh new component that hasn't been rendered yet, we
+    // won't update its child set by applying minimal side-effects. Instead,
+    // we will add them all to the child before it gets rendered. That means
+    // we can optimize this reconciliation pass by not tracking side-effects.
+    workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderLanes);
+  } else {
+    // If the current child is the same as the work in progress, it means that
+    // we haven't yet started any work on these children. Therefore, we use
+    // the clone algorithm to create a copy of all the current children.
+    // If we had any progressed work already, that is invalid at this point so
+    // let's throw it out.
+    workInProgress.child = reconcileChildFibers(workInProgress, current.child, nextChildren, renderLanes);
+  }
+}
+
+function forceUnmountCurrentAndReconcile(current, workInProgress, nextChildren, renderLanes) {
+  // This function is fork of reconcileChildren. It's used in cases where we
+  // want to reconcile without matching against the existing set. This has the
+  // effect of all current children being unmounted; even if the type and key
+  // are the same, the old child is unmounted and a new child is created.
+  //
+  // To do this, we're going to go through the reconcile algorithm twice. In
+  // the first pass, we schedule a deletion for all the current children by
+  // passing null.
+  workInProgress.child = reconcileChildFibers(workInProgress, current.child, null, renderLanes); // In the second pass, we mount the new children. The trick here is that we
+  // pass null in place of where we usually pass the current child set. This has
+  // the effect of remounting all children regardless of whether their
+  // identities match.
+
+  workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderLanes);
+}
+
+function updateForwardRef(current, workInProgress, Component, nextProps, renderLanes) {
+
+  const render = Component.render;
+  const ref = workInProgress.ref; // The rest is a fork of updateFunctionComponent
+
+  let nextChildren;
+  let hasId;
+  prepareToReadContext(workInProgress, renderLanes);
+
+  {
+    nextChildren = renderWithHooks(current, workInProgress, render, nextProps, ref, renderLanes);
+    hasId = checkDidRenderIdHook();
+  }
+
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateMemoComponent(current, workInProgress, Component, nextProps, renderLanes) {
+  if (current === null) {
+    const type = Component.type;
+
+    if (isSimpleFunctionComponent(type) && Component.compare === null && // SimpleMemoComponent codepath doesn't resolve outer props either.
+    Component.defaultProps === undefined) {
+      let resolvedType = type;
+      // and with only the default shallow comparison, we upgrade it
+      // to a SimpleMemoComponent to allow fast path updates.
+
+
+      workInProgress.tag = SimpleMemoComponent;
+      workInProgress.type = resolvedType;
+
+      return updateSimpleMemoComponent(current, workInProgress, resolvedType, nextProps, renderLanes);
+    }
+
+    const child = createFiberFromTypeAndProps(Component.type, null, nextProps, null, workInProgress, workInProgress.mode, renderLanes);
+    child.ref = workInProgress.ref;
+    child.return = workInProgress;
+    workInProgress.child = child;
+    return child;
+  }
+
+  const currentChild = current.child; // This is always exactly one child
+
+  const hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(current, renderLanes);
+
+  if (!hasScheduledUpdateOrContext) {
+    // This will be the props with resolved defaultProps,
+    // unlike current.memoizedProps which will be the unresolved ones.
+    const prevProps = currentChild.memoizedProps; // Default to shallow comparison
+
+    let compare = Component.compare;
+    compare = compare !== null ? compare : shallowEqual;
+
+    if (compare(prevProps, nextProps) && current.ref === workInProgress.ref) {
+      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    }
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+  const newChild = createWorkInProgress(currentChild, nextProps);
+  newChild.ref = workInProgress.ref;
+  newChild.return = workInProgress;
+  workInProgress.child = newChild;
+  return newChild;
+}
+
+function updateSimpleMemoComponent(current, workInProgress, Component, nextProps, renderLanes) {
+
+  if (current !== null) {
+    const prevProps = current.memoizedProps;
+
+    if (shallowEqual(prevProps, nextProps) && current.ref === workInProgress.ref && ( // Prevent bailout if the implementation changed due to hot reload.
+    true)) {
+      didReceiveUpdate = false; // The props are shallowly equal. Reuse the previous props object, like we
+      // would during a normal fiber bailout.
+      //
+      // We don't have strong guarantees that the props object is referentially
+      // equal during updates where we can't bail out anyway — like if the props
+      // are shallowly equal, but there's a local state or context update in the
+      // same batch.
+      //
+      // However, as a principle, we should aim to make the behavior consistent
+      // across different ways of memoizing a component. For example, React.memo
+      // has a different internal Fiber layout if you pass a normal function
+      // component (SimpleMemoComponent) versus if you pass a different type
+      // like forwardRef (MemoComponent). But this is an implementation detail.
+      // Wrapping a component in forwardRef (or React.lazy, etc) shouldn't
+      // affect whether the props object is reused during a bailout.
+
+      workInProgress.pendingProps = nextProps = prevProps;
+
+      if (!checkScheduledUpdateOrContext(current, renderLanes)) {
+        // The pending lanes were cleared at the beginning of beginWork. We're
+        // about to bail out, but there might be other lanes that weren't
+        // included in the current render. Usually, the priority level of the
+        // remaining updates is accumulated during the evaluation of the
+        // component (i.e. when processing the update queue). But since since
+        // we're bailing out early *without* evaluating the component, we need
+        // to account for it here, too. Reset to the value of the current fiber.
+        // NOTE: This only applies to SimpleMemoComponent, not MemoComponent,
+        // because a MemoComponent fiber does not have hooks or an update queue;
+        // rather, it wraps around an inner component, which may or may not
+        // contains hooks.
+        // TODO: Move the reset at in beginWork out of the common path so that
+        // this is no longer necessary.
+        workInProgress.lanes = current.lanes;
+        return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+      } else if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags$1) {
+        // This is a special case that only exists for legacy mode.
+        // See https://github.com/facebook/react/pull/19216.
+        didReceiveUpdate = true;
+      }
+    }
+  }
+
+  return updateFunctionComponent(current, workInProgress, Component, nextProps, renderLanes);
+}
+
+function updateOffscreenComponent(current, workInProgress, renderLanes) {
+  const nextProps = workInProgress.pendingProps;
+  const nextChildren = nextProps.children;
+  const nextIsDetached = (workInProgress.stateNode._pendingVisibility & OffscreenDetached) !== 0;
+  const prevState = current !== null ? current.memoizedState : null;
+  markRef$1(current, workInProgress);
+
+  if (nextProps.mode === 'hidden' || enableLegacyHidden  || nextIsDetached) {
+    // Rendering a hidden tree.
+    const didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
+
+    if (didSuspend) {
+      // Something suspended inside a hidden tree
+      // Include the base lanes from the last render
+      const nextBaseLanes = prevState !== null ? mergeLanes(prevState.baseLanes, renderLanes) : renderLanes;
+
+      if (current !== null) {
+        // Reset to the current children
+        let currentChild = workInProgress.child = current.child; // The current render suspended, but there may be other lanes with
+        // pending work. We can't read `childLanes` from the current Offscreen
+        // fiber because we reset it when it was deferred; however, we can read
+        // the pending lanes from the child fibers.
+
+        let currentChildLanes = NoLanes;
+
+        while (currentChild !== null) {
+          currentChildLanes = mergeLanes(mergeLanes(currentChildLanes, currentChild.lanes), currentChild.childLanes);
+          currentChild = currentChild.sibling;
+        }
+
+        const lanesWeJustAttempted = nextBaseLanes;
+        const remainingChildLanes = removeLanes(currentChildLanes, lanesWeJustAttempted);
+        workInProgress.childLanes = remainingChildLanes;
+      } else {
+        workInProgress.childLanes = NoLanes;
+        workInProgress.child = null;
+      }
+
+      return deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes);
+    }
+
+    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+      // In legacy sync mode, don't defer the subtree. Render it now.
+      // TODO: Consider how Offscreen should work with transitions in the future
+      const nextState = {
+        baseLanes: NoLanes,
+        cachePool: null
+      };
+      workInProgress.memoizedState = nextState;
+
+      {
+        // push the cache pool even though we're going to bail out
+        // because otherwise there'd be a context mismatch
+        if (current !== null) {
+          pushTransition(workInProgress, null);
+        }
+      }
+
+      reuseHiddenContextOnStack();
+      pushOffscreenSuspenseHandler(workInProgress);
+    } else if (!includesSomeLane(renderLanes, OffscreenLane)) {
+      // We're hidden, and we're not rendering at Offscreen. We will bail out
+      // and resume this tree later.
+      // Schedule this fiber to re-render at Offscreen priority
+      workInProgress.lanes = workInProgress.childLanes = laneToLanes(OffscreenLane); // Include the base lanes from the last render
+
+      const nextBaseLanes = prevState !== null ? mergeLanes(prevState.baseLanes, renderLanes) : renderLanes;
+      return deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes);
+    } else {
+      // This is the second render. The surrounding visible content has already
+      // committed. Now we resume rendering the hidden tree.
+      // Rendering at offscreen, so we can clear the base lanes.
+      const nextState = {
+        baseLanes: NoLanes,
+        cachePool: null
+      };
+      workInProgress.memoizedState = nextState;
+
+      if (current !== null) {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        const 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);
+      } // Push the lanes that were skipped when we bailed out.
+
+
+      if (prevState !== null) {
+        pushHiddenContext(workInProgress, prevState);
+      } else {
+        reuseHiddenContextOnStack();
+      }
+
+      pushOffscreenSuspenseHandler(workInProgress);
+    }
+  } else {
+    // Rendering a visible tree.
+    if (prevState !== null) {
+      // We're going from hidden -> visible.
+      let prevCachePool = null;
+
+      {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        prevCachePool = prevState.cachePool;
+      }
+
+      pushTransition(workInProgress, prevCachePool); // Push the lanes that were skipped when we bailed out.
+
+      pushHiddenContext(workInProgress, prevState);
+      reuseSuspenseHandlerOnStack(workInProgress); // Since we're not hidden anymore, reset the state
+
+      workInProgress.memoizedState = null;
+    } else {
+      // We weren't previously hidden, and we still aren't, so there's nothing
+      // special to do. Need to push to the stack regardless, though, to avoid
+      // a push/pop misalignment.
+      {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        if (current !== null) {
+          pushTransition(workInProgress, null);
+        }
+      } // We're about to bail out, but we need to push this to the stack anyway
+      // to avoid a push/pop misalignment.
+
+
+      reuseHiddenContextOnStack();
+      reuseSuspenseHandlerOnStack(workInProgress);
+    }
+  }
+
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes, renderLanes) {
+  const nextState = {
+    baseLanes: nextBaseLanes,
+    // Save the cache pool so we can resume later.
+    cachePool: getOffscreenDeferredCache() 
+  };
+  workInProgress.memoizedState = nextState;
+
+  {
+    // push the cache pool even though we're going to bail out
+    // because otherwise there'd be a context mismatch
+    if (current !== null) {
+      pushTransition(workInProgress, null);
+    }
+  } // We're about to bail out, but we need to push this to the stack anyway
+  // to avoid a push/pop misalignment.
+
+
+  reuseHiddenContextOnStack();
+  pushOffscreenSuspenseHandler(workInProgress);
+
+  return null;
+} // Note: These happen to have identical begin phases, for now. We shouldn't hold
+
+function updateCacheComponent(current, workInProgress, renderLanes) {
+
+  prepareToReadContext(workInProgress, renderLanes);
+  const parentCache = readContext(CacheContext);
+
+  if (current === null) {
+    // Initial mount. Request a fresh cache from the pool.
+    const freshCache = requestCacheFromPool(renderLanes);
+    const initialState = {
+      parent: parentCache,
+      cache: freshCache
+    };
+    workInProgress.memoizedState = initialState;
+    initializeUpdateQueue(workInProgress);
+    pushCacheProvider(workInProgress, freshCache);
+  } else {
+    // Check for updates
+    if (includesSomeLane(current.lanes, renderLanes)) {
+      cloneUpdateQueue(current, workInProgress);
+      processUpdateQueue(workInProgress, null, null, renderLanes);
+    }
+
+    const prevState = current.memoizedState;
+    const nextState = workInProgress.memoizedState; // Compare the new parent cache to the previous to see detect there was
+    // a refresh.
+
+    if (prevState.parent !== parentCache) {
+      // Refresh in parent. Update the parent.
+      const derivedState = {
+        parent: parentCache,
+        cache: parentCache
+      }; // Copied from getDerivedStateFromProps implementation. Once the update
+      // queue is empty, persist the derived state onto the base state.
+
+      workInProgress.memoizedState = derivedState;
+
+      if (workInProgress.lanes === NoLanes) {
+        const updateQueue = workInProgress.updateQueue;
+        workInProgress.memoizedState = updateQueue.baseState = derivedState;
+      }
+
+      pushCacheProvider(workInProgress, parentCache); // No need to propagate a context change because the refreshed parent
+      // already did.
+    } else {
+      // The parent didn't refresh. Now check if this cache did.
+      const nextCache = nextState.cache;
+      pushCacheProvider(workInProgress, nextCache);
+
+      if (nextCache !== prevState.cache) {
+        // This cache refreshed. Propagate a context change.
+        propagateContextChange(workInProgress, CacheContext, renderLanes);
+      }
+    }
+  }
+
+  const nextChildren = workInProgress.pendingProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+} // This should only be called if the name changes
+
+function updateFragment(current, workInProgress, renderLanes) {
+  const nextChildren = workInProgress.pendingProps;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateMode(current, workInProgress, renderLanes) {
+  const nextChildren = workInProgress.pendingProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateProfiler(current, workInProgress, renderLanes) {
+
+  const nextProps = workInProgress.pendingProps;
+  const nextChildren = nextProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function markRef$1(current, workInProgress) {
+  const ref = workInProgress.ref;
+
+  if (current === null && ref !== null || current !== null && current.ref !== ref) {
+    // Schedule a Ref effect
+    workInProgress.flags |= Ref;
+    workInProgress.flags |= RefStatic;
+  }
+}
+
+function updateFunctionComponent(current, workInProgress, Component, nextProps, renderLanes) {
+
+  let context;
+
+  {
+    const unmaskedContext = getUnmaskedContext(workInProgress, Component, true);
+    context = getMaskedContext(workInProgress, unmaskedContext);
+  }
+
+  let nextChildren;
+  let hasId;
+  prepareToReadContext(workInProgress, renderLanes);
+
+  {
+    nextChildren = renderWithHooks(current, workInProgress, Component, nextProps, context, renderLanes);
+    hasId = checkDidRenderIdHook();
+  }
+
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function replayFunctionComponent(current, workInProgress, nextProps, Component, secondArg, renderLanes) {
+  // This function is used to replay a component that previously suspended,
+  // after its data resolves. It's a simplified version of
+  // updateFunctionComponent that reuses the hooks from the previous attempt.
+  prepareToReadContext(workInProgress, renderLanes);
+
+  const nextChildren = replaySuspendedComponentWithHooks(current, workInProgress, Component, nextProps, secondArg);
+  const hasId = checkDidRenderIdHook();
+
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateClassComponent(current, workInProgress, Component, nextProps, renderLanes) {
+  // During mounting we don't know the child context yet as the instance doesn't exist.
+  // We will invalidate the child context in finishClassComponent() right after rendering.
+
+
+  let hasContext;
+
+  if (isContextProvider(Component)) {
+    hasContext = true;
+    pushContextProvider(workInProgress);
+  } else {
+    hasContext = false;
+  }
+
+  prepareToReadContext(workInProgress, renderLanes);
+  const instance = workInProgress.stateNode;
+  let shouldUpdate;
+
+  if (instance === null) {
+    resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress); // In the initial pass we might need to construct the instance.
+
+    constructClassInstance(workInProgress, Component, nextProps);
+    mountClassInstance(workInProgress, Component, nextProps, renderLanes);
+    shouldUpdate = true;
+  } else if (current === null) {
+    // In a resume, we'll already have an instance we can reuse.
+    shouldUpdate = resumeMountClassInstance(workInProgress, Component, nextProps, renderLanes);
+  } else {
+    shouldUpdate = updateClassInstance(current, workInProgress, Component, nextProps, renderLanes);
+  }
+
+  const nextUnitOfWork = finishClassComponent(current, workInProgress, Component, shouldUpdate, hasContext, renderLanes);
+
+  return nextUnitOfWork;
+}
+
+function finishClassComponent(current, workInProgress, Component, shouldUpdate, hasContext, renderLanes) {
+  // Refs should update even if shouldComponentUpdate returns false
+  markRef$1(current, workInProgress);
+  const didCaptureError = (workInProgress.flags & DidCapture) !== NoFlags$1;
+
+  if (!shouldUpdate && !didCaptureError) {
+    // Context providers should defer to sCU for rendering
+    if (hasContext) {
+      invalidateContextProvider(workInProgress, Component, false);
+    }
+
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+
+  const instance = workInProgress.stateNode; // Rerender
+
+  ReactCurrentOwner$1.current = workInProgress;
+  let nextChildren;
+
+  if (didCaptureError && typeof Component.getDerivedStateFromError !== 'function') {
+    // If we captured an error, but getDerivedStateFromError is not defined,
+    // unmount all the children. componentDidCatch will schedule an update to
+    // re-render a fallback. This is temporary until we migrate everyone to
+    // the new API.
+    // TODO: Warn in a future release.
+    nextChildren = null;
+  } else {
+
+    {
+      nextChildren = instance.render();
+    }
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+
+  if (current !== null && didCaptureError) {
+    // If we're recovering from an error, reconcile without reusing any of
+    // the existing children. Conceptually, the normal children and the children
+    // that are shown on error are two different sets, so we shouldn't reuse
+    // normal children even if their identities match.
+    forceUnmountCurrentAndReconcile(current, workInProgress, nextChildren, renderLanes);
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  } // Memoize state using the values we just used to render.
+  // TODO: Restructure so we never read values from the instance.
+
+
+  workInProgress.memoizedState = instance.state; // The context might have changed so we need to recalculate it.
+
+  if (hasContext) {
+    invalidateContextProvider(workInProgress, Component, true);
+  }
+
+  return workInProgress.child;
+}
+
+function pushHostRootContext(workInProgress) {
+  const root = workInProgress.stateNode;
+
+  if (root.pendingContext) {
+    pushTopLevelContextObject(workInProgress, root.pendingContext, root.pendingContext !== root.context);
+  } else if (root.context) {
+    // Should always be set
+    pushTopLevelContextObject(workInProgress, root.context, false);
+  }
+
+  pushHostContainer(workInProgress, root.containerInfo);
+}
+
+function updateHostRoot(current, workInProgress, renderLanes) {
+  pushHostRootContext(workInProgress);
+
+  if (current === null) {
+    throw Error(formatProdErrorMessage(387));
+  }
+
+  const nextProps = workInProgress.pendingProps;
+  const prevState = workInProgress.memoizedState;
+  const prevChildren = prevState.element;
+  cloneUpdateQueue(current, workInProgress);
+  processUpdateQueue(workInProgress, nextProps, null, renderLanes);
+  const nextState = workInProgress.memoizedState;
+
+  {
+    const nextCache = nextState.cache;
+    pushCacheProvider(workInProgress, nextCache);
+
+    if (nextCache !== prevState.cache) {
+      // The root cache refreshed.
+      propagateContextChange(workInProgress, CacheContext, renderLanes);
+    }
+  } // Caution: React DevTools currently depends on this property
+  // being called "element".
+
+
+  const nextChildren = nextState.element;
+
+  if (prevState.isDehydrated) {
+    // This is a hydration root whose shell has not yet hydrated. We should
+    // attempt to hydrate.
+    // Flip isDehydrated to false to indicate that when this render
+    // finishes, the root will no longer be dehydrated.
+    const overrideState = {
+      element: nextChildren,
+      isDehydrated: false,
+      cache: nextState.cache
+    };
+    const updateQueue = workInProgress.updateQueue; // `baseState` can always be the last state because the root doesn't
+    // have reducer functions so it doesn't need rebasing.
+
+    updateQueue.baseState = overrideState;
+    workInProgress.memoizedState = overrideState;
+
+    if (workInProgress.flags & ForceClientRender) {
+      // Something errored during a previous attempt to hydrate the shell, so we
+      // forced a client render.
+      const recoverableError = createCapturedValueAtFiber(Error(formatProdErrorMessage(423)), workInProgress);
+      return mountHostRootWithoutHydrating(current, workInProgress, nextChildren, renderLanes, recoverableError);
+    } else if (nextChildren !== prevChildren) {
+      const recoverableError = createCapturedValueAtFiber(Error(formatProdErrorMessage(424)), workInProgress);
+      return mountHostRootWithoutHydrating(current, workInProgress, nextChildren, renderLanes, recoverableError);
+    } else {
+      // The outermost shell has not hydrated yet. Start hydrating.
+      enterHydrationState(workInProgress);
+      const child = mountChildFibers(workInProgress, null, nextChildren, renderLanes);
+      workInProgress.child = child;
+      let node = child;
+
+      while (node) {
+        // Mark each child as hydrating. This is a fast path to know whether this
+        // tree is part of a hydrating tree. This is used to determine if a child
+        // node has fully mounted yet, and for scheduling event replaying.
+        // Conceptually this is similar to Placement in that a new subtree is
+        // inserted into the React tree here. It just happens to not need DOM
+        // mutations because it already exists.
+        node.flags = node.flags & ~Placement | Hydrating;
+        node = node.sibling;
+      }
+    }
+  } else {
+    // Root is not dehydrated. Either this is a client-only root, or it
+    // already hydrated.
+    resetHydrationState();
+
+    if (nextChildren === prevChildren) {
+      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    }
+
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  }
+
+  return workInProgress.child;
+}
+
+function mountHostRootWithoutHydrating(current, workInProgress, nextChildren, renderLanes, recoverableError) {
+  // Revert to client rendering.
+  resetHydrationState();
+  queueHydrationError(recoverableError);
+  workInProgress.flags |= ForceClientRender;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateHostComponent$1(current, workInProgress, renderLanes) {
+  pushHostContext(workInProgress);
+
+  if (current === null) {
+    tryToClaimNextHydratableInstance(workInProgress);
+  }
+
+  const type = workInProgress.type;
+  const nextProps = workInProgress.pendingProps;
+  const prevProps = current !== null ? current.memoizedProps : null;
+  let nextChildren = nextProps.children;
+  const isDirectTextChild = shouldSetTextContent(type, nextProps);
+
+  if (isDirectTextChild) {
+    // We special case a direct text child of a host node. This is a common
+    // case. We won't handle it as a reified child. We will instead handle
+    // this in the host environment that also has access to this prop. That
+    // avoids allocating another HostText fiber and traversing it.
+    nextChildren = null;
+  } else if (prevProps !== null && shouldSetTextContent(type, prevProps)) {
+    // If we're switching from a direct text child to a normal child, or to
+    // empty, we need to schedule the text content to be reset.
+    workInProgress.flags |= ContentReset;
+  }
+
+  {
+    const memoizedState = workInProgress.memoizedState;
+
+    if (memoizedState !== null) {
+      // This fiber has been upgraded to a stateful component. The only way
+      // happens currently is for form actions. We use hooks to track the
+      // pending and error state of the form.
+      //
+      // Once a fiber is upgraded to be stateful, it remains stateful for the
+      // rest of its lifetime.
+      const newState = renderTransitionAwareHostComponentWithHooks(current, workInProgress, renderLanes); // If the transition state changed, propagate the change to all the
+      // descendents. We use Context as an implementation detail for this.
+      //
+      // This is intentionally set here instead of pushHostContext because
+      // pushHostContext gets called before we process the state hook, to avoid
+      // a state mismatch in the event that something suspends.
+      //
+      // NOTE: This assumes that there cannot be nested transition providers,
+      // because the only renderer that implements this feature is React DOM,
+      // and forms cannot be nested. If we did support nested providers, then
+      // we would need to push a context value even for host fibers that
+      // haven't been upgraded yet.
+
+      {
+        HostTransitionContext._currentValue = newState;
+      }
+
+      {
+        if (didReceiveUpdate) {
+          if (current !== null) {
+            const oldStateHook = current.memoizedState;
+            const oldState = oldStateHook.memoizedState; // This uses regular equality instead of Object.is because we assume
+            // that host transition state doesn't include NaN as a valid type.
+
+            if (oldState !== newState) {
+              propagateContextChange(workInProgress, HostTransitionContext, renderLanes);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  markRef$1(current, workInProgress);
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateHostHoistable(current, workInProgress, renderLanes) {
+  markRef$1(current, workInProgress);
+  const currentProps = current === null ? null : current.memoizedProps;
+  const resource = workInProgress.memoizedState = getResource(workInProgress.type, currentProps, workInProgress.pendingProps);
+
+  if (current === null) {
+    if (!getIsHydrating() && resource === null) {
+      // This is not a Resource Hoistable and we aren't hydrating so we construct the instance.
+      workInProgress.stateNode = createHoistableInstance(workInProgress.type, workInProgress.pendingProps, getRootHostContainer(), workInProgress);
+    }
+  } // Resources never have reconciler managed children. It is possible for
+  // the host implementation of getResource to consider children in the
+  // resource construction but they will otherwise be discarded. In practice
+  // this precludes all but the simplest children and Host specific warnings
+  // should be implemented to warn when children are passsed when otherwise not
+  // expected
+
+
+  return null;
+}
+
+function updateHostSingleton(current, workInProgress, renderLanes) {
+  pushHostContext(workInProgress);
+
+  if (current === null) {
+    claimHydratableSingleton(workInProgress);
+  }
+
+  const nextChildren = workInProgress.pendingProps.children;
+
+  if (current === null && !getIsHydrating()) {
+    // Similar to Portals we append Singleton children in the commit phase. So we
+    // Track insertions even on mount.
+    // TODO: Consider unifying this with how the root works.
+    workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderLanes);
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  }
+
+  markRef$1(current, workInProgress);
+  return workInProgress.child;
+}
+
+function updateHostText$1(current, workInProgress) {
+  if (current === null) {
+    tryToClaimNextHydratableTextInstance(workInProgress);
+  } // Nothing to do here. This is terminal. We'll do the completion step
+  // immediately after.
+
+
+  return null;
+}
+
+function mountLazyComponent(_current, workInProgress, elementType, renderLanes) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);
+  const props = workInProgress.pendingProps;
+  const lazyComponent = elementType;
+  const payload = lazyComponent._payload;
+  const init = lazyComponent._init;
+  let Component = init(payload); // Store the unwrapped component in the type.
+
+  workInProgress.type = Component;
+  const resolvedTag = workInProgress.tag = resolveLazyComponentTag(Component);
+  const resolvedProps = resolveDefaultProps(Component, props);
+  let child;
+
+  switch (resolvedTag) {
+    case FunctionComponent:
+      {
+
+        child = updateFunctionComponent(null, workInProgress, Component, resolvedProps, renderLanes);
+        return child;
+      }
+
+    case ClassComponent:
+      {
+
+        child = updateClassComponent(null, workInProgress, Component, resolvedProps, renderLanes);
+        return child;
+      }
+
+    case ForwardRef:
+      {
+
+        child = updateForwardRef(null, workInProgress, Component, resolvedProps, renderLanes);
+        return child;
+      }
+
+    case MemoComponent:
+      {
+
+        child = updateMemoComponent(null, workInProgress, Component, resolveDefaultProps(Component.type, resolvedProps), // The inner type can have defaults too
+        renderLanes);
+        return child;
+      }
+  }
+
+  let hint = '';
+  // because the fact that it's a separate type of work is an
+  // implementation detail.
+
+
+  throw Error(formatProdErrorMessage(306, Component, hint));
+}
+
+function mountIncompleteClassComponent(_current, workInProgress, Component, nextProps, renderLanes) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress); // Promote the fiber to a class and try rendering again.
+
+  workInProgress.tag = ClassComponent; // The rest of this function is a fork of `updateClassComponent`
+  // Push context providers early to prevent context stack mismatches.
+  // During mounting we don't know the child context yet as the instance doesn't exist.
+  // We will invalidate the child context in finishClassComponent() right after rendering.
+
+  let hasContext;
+
+  if (isContextProvider(Component)) {
+    hasContext = true;
+    pushContextProvider(workInProgress);
+  } else {
+    hasContext = false;
+  }
+
+  prepareToReadContext(workInProgress, renderLanes);
+  constructClassInstance(workInProgress, Component, nextProps);
+  mountClassInstance(workInProgress, Component, nextProps, renderLanes);
+  return finishClassComponent(null, workInProgress, Component, true, hasContext, renderLanes);
+}
+
+function mountIndeterminateComponent(_current, workInProgress, Component, renderLanes) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);
+  const props = workInProgress.pendingProps;
+  let context;
+
+  {
+    const unmaskedContext = getUnmaskedContext(workInProgress, Component, false);
+    context = getMaskedContext(workInProgress, unmaskedContext);
+  }
+
+  prepareToReadContext(workInProgress, renderLanes);
+  let value;
+  let hasId;
+
+  {
+    value = renderWithHooks(null, workInProgress, Component, props, context, renderLanes);
+    hasId = checkDidRenderIdHook();
+  }
+
+
+  workInProgress.flags |= PerformedWork;
+
+  if ( // Run these checks in production only if the flag is off.
+  // Eventually we'll delete this branch altogether.
+  typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) {
+
+
+    workInProgress.tag = ClassComponent; // Throw out any hooks that were used.
+
+    workInProgress.memoizedState = null;
+    workInProgress.updateQueue = null; // Push context providers early to prevent context stack mismatches.
+    // During mounting we don't know the child context yet as the instance doesn't exist.
+    // We will invalidate the child context in finishClassComponent() right after rendering.
+
+    let hasContext = false;
+
+    if (isContextProvider(Component)) {
+      hasContext = true;
+      pushContextProvider(workInProgress);
+    } else {
+      hasContext = false;
+    }
+
+    workInProgress.memoizedState = value.state !== null && value.state !== undefined ? value.state : null;
+    initializeUpdateQueue(workInProgress);
+    adoptClassInstance(workInProgress, value);
+    mountClassInstance(workInProgress, Component, props, renderLanes);
+    return finishClassComponent(null, workInProgress, Component, true, hasContext, renderLanes);
+  } else {
+    // Proceed under the assumption that this is a function component
+    workInProgress.tag = FunctionComponent;
+
+    if (getIsHydrating() && hasId) {
+      pushMaterializedTreeId(workInProgress);
+    }
+
+    reconcileChildren(null, workInProgress, value, renderLanes);
+
+    return workInProgress.child;
+  }
+}
+
+const SUSPENDED_MARKER = {
+  dehydrated: null,
+  treeContext: null,
+  retryLane: NoLane
+};
+
+function mountSuspenseOffscreenState(renderLanes) {
+  return {
+    baseLanes: renderLanes,
+    cachePool: getSuspendedCache()
+  };
+}
+
+function updateSuspenseOffscreenState(prevOffscreenState, renderLanes) {
+  let cachePool = null;
+
+  {
+    const prevCachePool = prevOffscreenState.cachePool;
+
+    if (prevCachePool !== null) {
+      const parentCache = CacheContext._currentValue ;
+
+      if (prevCachePool.parent !== parentCache) {
+        // Detected a refresh in the parent. This overrides any previously
+        // suspended cache.
+        cachePool = {
+          parent: parentCache,
+          pool: parentCache
+        };
+      } else {
+        // We can reuse the cache from last time. The only thing that would have
+        // overridden it is a parent refresh, which we checked for above.
+        cachePool = prevCachePool;
+      }
+    } else {
+      // If there's no previous cache pool, grab the current one.
+      cachePool = getSuspendedCache();
+    }
+  }
+
+  return {
+    baseLanes: mergeLanes(prevOffscreenState.baseLanes, renderLanes),
+    cachePool
+  };
+} // TODO: Probably should inline this back
+
+
+function shouldRemainOnFallback(current, workInProgress, renderLanes) {
+  // If we're already showing a fallback, there are cases where we need to
+  // remain on that fallback regardless of whether the content has resolved.
+  // For example, SuspenseList coordinates when nested content appears.
+  // TODO: For compatibility with offscreen prerendering, this should also check
+  // whether the current fiber (if it exists) was visible in the previous tree.
+  if (current !== null) {
+    const suspenseState = current.memoizedState;
+
+    if (suspenseState === null) {
+      // Currently showing content. Don't hide it, even if ForceSuspenseFallback
+      // is true. More precise name might be "ForceRemainSuspenseFallback".
+      // Note: This is a factoring smell. Can't remain on a fallback if there's
+      // no fallback to remain on.
+      return false;
+    }
+  } // Not currently showing content. Consult the Suspense context.
+
+
+  const suspenseContext = suspenseStackCursor.current;
+  return hasSuspenseListContext(suspenseContext, ForceSuspenseFallback);
+}
+
+function getRemainingWorkInPrimaryTree(current, renderLanes) {
+  // TODO: Should not remove render lanes that were pinged during this render
+  return removeLanes(current.childLanes, renderLanes);
+}
+
+function updateSuspenseComponent(current, workInProgress, renderLanes) {
+  const nextProps = workInProgress.pendingProps; // This is used by DevTools to force a boundary to suspend.
+
+  let showFallback = false;
+  const didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
+
+  if (didSuspend || shouldRemainOnFallback(current)) {
+    // Something in this boundary's subtree already suspended. Switch to
+    // rendering the fallback children.
+    showFallback = true;
+    workInProgress.flags &= ~DidCapture;
+  } // OK, the next part is confusing. We're about to reconcile the Suspense
+  // boundary's children. This involves some custom reconciliation logic. Two
+  // main reasons this is so complicated.
+  //
+  // First, Legacy Mode has different semantics for backwards compatibility. The
+  // primary tree will commit in an inconsistent state, so when we do the
+  // second pass to render the fallback, we do some exceedingly, uh, clever
+  // hacks to make that not totally break. Like transferring effects and
+  // deletions from hidden tree. In Concurrent Mode, it's much simpler,
+  // because we bailout on the primary tree completely and leave it in its old
+  // state, no effects. Same as what we do for Offscreen (except that
+  // Offscreen doesn't have the first render pass).
+  //
+  // Second is hydration. During hydration, the Suspense fiber has a slightly
+  // different layout, where the child points to a dehydrated fragment, which
+  // contains the DOM rendered by the server.
+  //
+  // Third, even if you set all that aside, Suspense is like error boundaries in
+  // that we first we try to render one tree, and if that fails, we render again
+  // and switch to a different tree. Like a try/catch block. So we have to track
+  // which branch we're currently rendering. Ideally we would model this using
+  // a stack.
+
+
+  if (current === null) {
+    // Initial mount
+    // Special path for hydration
+    // If we're currently hydrating, try to hydrate this boundary.
+    if (getIsHydrating()) {
+      // We must push the suspense handler context *before* attempting to
+      // hydrate, to avoid a mismatch in case it errors.
+      if (showFallback) {
+        pushPrimaryTreeSuspenseHandler(workInProgress);
+      } else {
+        pushFallbackTreeSuspenseHandler(workInProgress);
+      }
+
+      tryToClaimNextHydratableSuspenseInstance(workInProgress); // This could've been a dehydrated suspense component.
+
+      const suspenseState = workInProgress.memoizedState;
+
+      if (suspenseState !== null) {
+        const dehydrated = suspenseState.dehydrated;
+
+        if (dehydrated !== null) {
+          return mountDehydratedSuspenseComponent(workInProgress, dehydrated);
+        }
+      } // If hydration didn't succeed, fall through to the normal Suspense path.
+      // To avoid a stack mismatch we need to pop the Suspense handler that we
+      // pushed above. This will become less awkward when move the hydration
+      // logic to its own fiber.
+
+
+      popSuspenseHandler(workInProgress);
+    }
+
+    const nextPrimaryChildren = nextProps.children;
+    const nextFallbackChildren = nextProps.fallback;
+
+    if (showFallback) {
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      const fallbackFragment = mountSuspenseFallbackChildren(workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);
+      const primaryChildFragment = workInProgress.child;
+      primaryChildFragment.memoizedState = mountSuspenseOffscreenState(renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+
+      return fallbackFragment;
+    } else if (typeof nextProps.unstable_expectedLoadTime === 'number') {
+      // This is a CPU-bound tree. Skip this tree and show a placeholder to
+      // unblock the surrounding content. Then immediately retry after the
+      // initial commit.
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      const fallbackFragment = mountSuspenseFallbackChildren(workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);
+      const primaryChildFragment = workInProgress.child;
+      primaryChildFragment.memoizedState = mountSuspenseOffscreenState(renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER; // TODO: Transition Tracing is not yet implemented for CPU Suspense.
+      // Since nothing actually suspended, there will nothing to ping this to
+      // get it started back up to attempt the next item. While in terms of
+      // priority this work has the same priority as this current render, it's
+      // not part of the same transition once the transition has committed. If
+      // it's sync, we still want to yield so that it can be painted.
+      // Conceptually, this is really the same as pinging. We can use any
+      // RetryLane even if it's the one currently rendering since we're leaving
+      // it behind on this node.
+
+      workInProgress.lanes = SomeRetryLane;
+      return fallbackFragment;
+    } else {
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      return mountSuspensePrimaryChildren(workInProgress, nextPrimaryChildren);
+    }
+  } else {
+    // This is an update.
+    // Special path for hydration
+    const prevState = current.memoizedState;
+
+    if (prevState !== null) {
+      const dehydrated = prevState.dehydrated;
+
+      if (dehydrated !== null) {
+        return updateDehydratedSuspenseComponent(current, workInProgress, didSuspend, nextProps, dehydrated, prevState, renderLanes);
+      }
+    }
+
+    if (showFallback) {
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      const nextFallbackChildren = nextProps.fallback;
+      const nextPrimaryChildren = nextProps.children;
+      const fallbackChildFragment = updateSuspenseFallbackChildren(current, workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);
+      const primaryChildFragment = workInProgress.child;
+      const prevOffscreenState = current.child.memoizedState;
+      primaryChildFragment.memoizedState = prevOffscreenState === null ? mountSuspenseOffscreenState(renderLanes) : updateSuspenseOffscreenState(prevOffscreenState, renderLanes);
+
+      primaryChildFragment.childLanes = getRemainingWorkInPrimaryTree(current, renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+      return fallbackChildFragment;
+    } else {
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      const nextPrimaryChildren = nextProps.children;
+      const primaryChildFragment = updateSuspensePrimaryChildren(current, workInProgress, nextPrimaryChildren, renderLanes);
+      workInProgress.memoizedState = null;
+      return primaryChildFragment;
+    }
+  }
+}
+
+function mountSuspensePrimaryChildren(workInProgress, primaryChildren, renderLanes) {
+  const mode = workInProgress.mode;
+  const primaryChildProps = {
+    mode: 'visible',
+    children: primaryChildren
+  };
+  const primaryChildFragment = mountWorkInProgressOffscreenFiber(primaryChildProps, mode);
+  primaryChildFragment.return = workInProgress;
+  workInProgress.child = primaryChildFragment;
+  return primaryChildFragment;
+}
+
+function mountSuspenseFallbackChildren(workInProgress, primaryChildren, fallbackChildren, renderLanes) {
+  const mode = workInProgress.mode;
+  const progressedPrimaryFragment = workInProgress.child;
+  const primaryChildProps = {
+    mode: 'hidden',
+    children: primaryChildren
+  };
+  let primaryChildFragment;
+  let fallbackChildFragment;
+
+  if ((mode & ConcurrentMode) === NoMode && progressedPrimaryFragment !== null) {
+    // In legacy mode, we commit the primary tree as if it successfully
+    // completed, even though it's in an inconsistent state.
+    primaryChildFragment = progressedPrimaryFragment;
+    primaryChildFragment.childLanes = NoLanes;
+    primaryChildFragment.pendingProps = primaryChildProps;
+
+    fallbackChildFragment = createFiberFromFragment(fallbackChildren, mode, renderLanes, null);
+  } else {
+    primaryChildFragment = mountWorkInProgressOffscreenFiber(primaryChildProps, mode);
+    fallbackChildFragment = createFiberFromFragment(fallbackChildren, mode, renderLanes, null);
+  }
+
+  primaryChildFragment.return = workInProgress;
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
+  return fallbackChildFragment;
+}
+
+function mountWorkInProgressOffscreenFiber(offscreenProps, mode, renderLanes) {
+  // The props argument to `createFiberFromOffscreen` is `any` typed, so we use
+  // this wrapper function to constrain it.
+  return createFiberFromOffscreen(offscreenProps, mode, NoLanes, null);
+}
+
+function updateWorkInProgressOffscreenFiber(current, offscreenProps) {
+  // The props argument to `createWorkInProgress` is `any` typed, so we use this
+  // wrapper function to constrain it.
+  return createWorkInProgress(current, offscreenProps);
+}
+
+function updateSuspensePrimaryChildren(current, workInProgress, primaryChildren, renderLanes) {
+  const currentPrimaryChildFragment = current.child;
+  const currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
+  const primaryChildFragment = updateWorkInProgressOffscreenFiber(currentPrimaryChildFragment, {
+    mode: 'visible',
+    children: primaryChildren
+  });
+
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    primaryChildFragment.lanes = renderLanes;
+  }
+
+  primaryChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = null;
+
+  if (currentFallbackChildFragment !== null) {
+    // Delete the fallback child fragment
+    const deletions = workInProgress.deletions;
+
+    if (deletions === null) {
+      workInProgress.deletions = [currentFallbackChildFragment];
+      workInProgress.flags |= ChildDeletion;
+    } else {
+      deletions.push(currentFallbackChildFragment);
+    }
+  }
+
+  workInProgress.child = primaryChildFragment;
+  return primaryChildFragment;
+}
+
+function updateSuspenseFallbackChildren(current, workInProgress, primaryChildren, fallbackChildren, renderLanes) {
+  const mode = workInProgress.mode;
+  const currentPrimaryChildFragment = current.child;
+  const currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
+  const primaryChildProps = {
+    mode: 'hidden',
+    children: primaryChildren
+  };
+  let primaryChildFragment;
+
+  if ( // In legacy mode, we commit the primary tree as if it successfully
+  // completed, even though it's in an inconsistent state.
+  (mode & ConcurrentMode) === NoMode && // Make sure we're on the second pass, i.e. the primary child fragment was
+  // already cloned. In legacy mode, the only case where this isn't true is
+  // when DevTools forces us to display a fallback; we skip the first render
+  // pass entirely and go straight to rendering the fallback. (In Concurrent
+  // Mode, SuspenseList can also trigger this scenario, but this is a legacy-
+  // only codepath.)
+  workInProgress.child !== currentPrimaryChildFragment) {
+    const progressedPrimaryFragment = workInProgress.child;
+    primaryChildFragment = progressedPrimaryFragment;
+    primaryChildFragment.childLanes = NoLanes;
+    primaryChildFragment.pendingProps = primaryChildProps;
+    // However, since we're going to remain on the fallback, we no longer want
+    // to delete it.
+
+
+    workInProgress.deletions = null;
+  } else {
+    primaryChildFragment = updateWorkInProgressOffscreenFiber(currentPrimaryChildFragment, primaryChildProps); // Since we're reusing a current tree, we need to reuse the flags, too.
+    // (We don't do this in legacy mode, because in legacy mode we don't re-use
+    // the current tree; see previous branch.)
+
+    primaryChildFragment.subtreeFlags = currentPrimaryChildFragment.subtreeFlags & StaticMask;
+  }
+
+  let fallbackChildFragment;
+
+  if (currentFallbackChildFragment !== null) {
+    fallbackChildFragment = createWorkInProgress(currentFallbackChildFragment, fallbackChildren);
+  } else {
+    fallbackChildFragment = createFiberFromFragment(fallbackChildren, mode, renderLanes, null); // Needs a placement effect because the parent (the Suspense boundary) already
+    // mounted but this is a new fiber.
+
+    fallbackChildFragment.flags |= Placement;
+  }
+
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
+  return fallbackChildFragment;
+}
+
+function retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, recoverableError) {
+  // Falling back to client rendering. Because this has performance
+  // implications, it's considered a recoverable error, even though the user
+  // likely won't observe anything wrong with the UI.
+  //
+  // The error is passed in as an argument to enforce that every caller provide
+  // a custom message, or explicitly opt out (currently the only path that opts
+  // out is legacy mode; every concurrent path provides an error).
+  if (recoverableError !== null) {
+    queueHydrationError(recoverableError);
+  } // This will add the old fiber to the deletion list
+
+
+  reconcileChildFibers(workInProgress, current.child, null, renderLanes); // We're now not suspended nor dehydrated.
+
+  const nextProps = workInProgress.pendingProps;
+  const primaryChildren = nextProps.children;
+  const primaryChildFragment = mountSuspensePrimaryChildren(workInProgress, primaryChildren); // Needs a placement effect because the parent (the Suspense boundary) already
+  // mounted but this is a new fiber.
+
+  primaryChildFragment.flags |= Placement;
+  workInProgress.memoizedState = null;
+  return primaryChildFragment;
+}
+
+function mountSuspenseFallbackAfterRetryWithoutHydrating(current, workInProgress, primaryChildren, fallbackChildren, renderLanes) {
+  const fiberMode = workInProgress.mode;
+  const primaryChildProps = {
+    mode: 'visible',
+    children: primaryChildren
+  };
+  const primaryChildFragment = mountWorkInProgressOffscreenFiber(primaryChildProps, fiberMode);
+  const fallbackChildFragment = createFiberFromFragment(fallbackChildren, fiberMode, renderLanes, null); // Needs a placement effect because the parent (the Suspense
+  // boundary) already mounted but this is a new fiber.
+
+  fallbackChildFragment.flags |= Placement;
+  primaryChildFragment.return = workInProgress;
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
+
+  if ((workInProgress.mode & ConcurrentMode) !== NoMode) {
+    // We will have dropped the effect list which contains the
+    // deletion. We need to reconcile to delete the current child.
+    reconcileChildFibers(workInProgress, current.child, null, renderLanes);
+  }
+
+  return fallbackChildFragment;
+}
+
+function mountDehydratedSuspenseComponent(workInProgress, suspenseInstance, renderLanes) {
+  // During the first pass, we'll bail out and not drill into the children.
+  // Instead, we'll leave the content in place and try to hydrate it later.
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+
+    workInProgress.lanes = laneToLanes(SyncLane);
+  } else if (isSuspenseInstanceFallback(suspenseInstance)) {
+    // This is a client-only boundary. Since we won't get any content from the server
+    // for this, we need to schedule that at a higher priority based on when it would
+    // have timed out. In theory we could render it in this pass but it would have the
+    // wrong priority associated with it and will prevent hydration of parent path.
+    // Instead, we'll leave work left on it to render it in a separate commit.
+    // TODO This time should be the time at which the server rendered response that is
+    // a parent to this boundary was displayed. However, since we currently don't have
+    // a protocol to transfer that time, we'll just estimate it by using the current
+    // time. This will mean that Suspense timeouts are slightly shifted to later than
+    // they should be.
+    // Schedule a normal pri update to render this content.
+    workInProgress.lanes = laneToLanes(DefaultHydrationLane);
+  } else {
+    // We'll continue hydrating the rest at offscreen priority since we'll already
+    // be showing the right content coming from the server, it is no rush.
+    workInProgress.lanes = laneToLanes(OffscreenLane);
+  }
+
+  return null;
+}
+
+function updateDehydratedSuspenseComponent(current, workInProgress, didSuspend, nextProps, suspenseInstance, suspenseState, renderLanes) {
+  if (!didSuspend) {
+    // This is the first render pass. Attempt to hydrate.
+    pushPrimaryTreeSuspenseHandler(workInProgress); // We should never be hydrating at this point because it is the first pass,
+
+    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, null);
+    }
+
+    if (isSuspenseInstanceFallback(suspenseInstance)) {
+      // This boundary is in a permanent fallback state. In this case, we'll never
+      // get an update and we'll never be able to hydrate the final content. Let's just try the
+      // client side render instead.
+      let digest;
+      let stack;
+
+      {
+        var _getSuspenseInstanceF2 = getSuspenseInstanceFallbackErrorDetails(suspenseInstance);
+
+        digest = _getSuspenseInstanceF2.digest;
+      }
+
+      let capturedValue = null; // TODO: Figure out a better signal than encoding a magic digest value.
+
+      if (digest !== 'POSTPONE') {
+        let error;
+
+        {
+          error = Error(formatProdErrorMessage(419));
+        }
+
+        error.digest = digest;
+        capturedValue = createCapturedValue(error, digest, stack);
+      }
+
+      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, capturedValue);
+    }
+    // any context has changed, we need to treat is as if the input might have changed.
+
+
+    const hasContextChanged = includesSomeLane(renderLanes, current.childLanes);
+
+    if (didReceiveUpdate || hasContextChanged) {
+      // This boundary has changed since the first render. This means that we are now unable to
+      // hydrate it. We might still be able to hydrate it using a higher priority lane.
+      const root = getWorkInProgressRoot();
+
+      if (root !== null) {
+        const attemptHydrationAtLane = getBumpedLaneForHydration(root, renderLanes);
+
+        if (attemptHydrationAtLane !== NoLane && attemptHydrationAtLane !== suspenseState.retryLane) {
+          // Intentionally mutating since this render will get interrupted. This
+          // is one of the very rare times where we mutate the current tree
+          // during the render phase.
+          suspenseState.retryLane = attemptHydrationAtLane;
+          enqueueConcurrentRenderForLane(current, attemptHydrationAtLane);
+          scheduleUpdateOnFiber(root, current, attemptHydrationAtLane); // Throw a special object that signals to the work loop that it should
+          // interrupt the current render.
+          //
+          // Because we're inside a React-only execution stack, we don't
+          // strictly need to throw here — we could instead modify some internal
+          // work loop state. But using an exception means we don't need to
+          // check for this case on every iteration of the work loop. So doing
+          // it this way moves the check out of the fast path.
+
+          throw SelectiveHydrationException;
+        }
+      } // If we did not selectively hydrate, we'll continue rendering without
+      // hydrating. Mark this tree as suspended to prevent it from committing
+      // outside a transition.
+      //
+      // This path should only happen if the hydration lane already suspended.
+      // Currently, it also happens during sync updates because there is no
+      // hydration lane for sync updates.
+      // TODO: We should ideally have a sync hydration lane that we can apply to do
+      // a pass where we hydrate this subtree in place using the previous Context and then
+      // reapply the update afterwards.
+
+
+      if (isSuspenseInstancePending(suspenseInstance)) ; else {
+        renderDidSuspendDelayIfPossible();
+      }
+
+      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, null);
+    } else if (isSuspenseInstancePending(suspenseInstance)) {
+      // This component is still pending more data from the server, so we can't hydrate its
+      // content. We treat it as if this component suspended itself. It might seem as if
+      // we could just try to render it client-side instead. However, this will perform a
+      // lot of unnecessary work and is unlikely to complete since it often will suspend
+      // on missing data anyway. Additionally, the server might be able to render more
+      // than we can on the client yet. In that case we'd end up with more fallback states
+      // on the client than if we just leave it alone. If the server times out or errors
+      // these should update this boundary to the permanent Fallback state instead.
+      // Mark it as having captured (i.e. suspended).
+      workInProgress.flags |= DidCapture; // Leave the child in place. I.e. the dehydrated fragment.
+
+      workInProgress.child = current.child; // Register a callback to retry this boundary once the server has sent the result.
+
+      const retry = retryDehydratedSuspenseBoundary.bind(null, current);
+      registerSuspenseInstanceRetry(suspenseInstance, retry);
+      return null;
+    } else {
+      // This is the first attempt.
+      reenterHydrationStateFromDehydratedSuspenseInstance(workInProgress, suspenseInstance, suspenseState.treeContext);
+      const primaryChildren = nextProps.children;
+      const primaryChildFragment = mountSuspensePrimaryChildren(workInProgress, primaryChildren); // Mark the children as hydrating. This is a fast path to know whether this
+      // tree is part of a hydrating tree. This is used to determine if a child
+      // node has fully mounted yet, and for scheduling event replaying.
+      // Conceptually this is similar to Placement in that a new subtree is
+      // inserted into the React tree here. It just happens to not need DOM
+      // mutations because it already exists.
+
+      primaryChildFragment.flags |= Hydrating;
+      return primaryChildFragment;
+    }
+  } else {
+    // This is the second render pass. We already attempted to hydrated, but
+    // something either suspended or errored.
+    if (workInProgress.flags & ForceClientRender) {
+      // Something errored during hydration. Try again without hydrating.
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      workInProgress.flags &= ~ForceClientRender;
+      const capturedValue = createCapturedValue(Error(formatProdErrorMessage(422)));
+      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, capturedValue);
+    } else if (workInProgress.memoizedState !== null) {
+      // Something suspended and we should still be in dehydrated mode.
+      // Leave the existing child in place.
+      // Push to avoid a mismatch
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      workInProgress.child = current.child; // The dehydrated completion pass expects this flag to be there
+      // but the normal suspense pass doesn't.
+
+      workInProgress.flags |= DidCapture;
+      return null;
+    } else {
+      // Suspended but we should no longer be in dehydrated mode.
+      // Therefore we now have to render the fallback.
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      const nextPrimaryChildren = nextProps.children;
+      const nextFallbackChildren = nextProps.fallback;
+      const fallbackChildFragment = mountSuspenseFallbackAfterRetryWithoutHydrating(current, workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);
+      const primaryChildFragment = workInProgress.child;
+      primaryChildFragment.memoizedState = mountSuspenseOffscreenState(renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+      return fallbackChildFragment;
+    }
+  }
+}
+
+function scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {
+  fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
+  const alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+  }
+
+  scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);
+}
+
+function propagateSuspenseContextChange(workInProgress, firstChild, renderLanes) {
+  // Mark any Suspense boundaries with fallbacks as having work to do.
+  // If they were previously forced into fallbacks, they may now be able
+  // to unblock.
+  let node = firstChild;
+
+  while (node !== null) {
+    if (node.tag === SuspenseComponent) {
+      const state = node.memoizedState;
+
+      if (state !== null) {
+        scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);
+      }
+    } else if (node.tag === SuspenseListComponent) {
+      // If the tail is hidden there might not be an Suspense boundaries
+      // to schedule work on. In this case we have to schedule it on the
+      // list itself.
+      // We don't have to traverse to the children of the list since
+      // the list will propagate the change when it rerenders.
+      scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);
+    } else if (node.child !== null) {
+      node.child.return = node;
+      node = node.child;
+      continue;
+    }
+
+    if (node === workInProgress) {
+      return;
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    while (node.sibling === null) {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      if (node.return === null || node.return === workInProgress) {
+        return;
+      }
+
+      node = node.return;
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    node.sibling.return = node.return;
+    node = node.sibling;
+  }
+}
+
+function findLastContentRow(firstChild) {
+  // This is going to find the last row among these children that is already
+  // showing content on the screen, as opposed to being in fallback state or
+  // new. If a row has multiple Suspense boundaries, any of them being in the
+  // fallback state, counts as the whole row being in a fallback state.
+  // Note that the "rows" will be workInProgress, but any nested children
+  // will still be current since we haven't rendered them yet. The mounted
+  // order may not be the same as the new order. We use the new order.
+  let row = firstChild;
+  let lastContentRow = null;
+
+  while (row !== null) {
+    const currentRow = row.alternate; // New rows can't be content rows.
+
+    if (currentRow !== null && findFirstSuspended(currentRow) === null) {
+      lastContentRow = row;
+    }
+
+    row = row.sibling;
+  }
+
+  return lastContentRow;
+}
+
+function initSuspenseListRenderState(workInProgress, isBackwards, tail, lastContentRow, tailMode) {
+  const renderState = workInProgress.memoizedState;
+
+  if (renderState === null) {
+    workInProgress.memoizedState = {
+      isBackwards: isBackwards,
+      rendering: null,
+      renderingStartTime: 0,
+      last: lastContentRow,
+      tail: tail,
+      tailMode: tailMode
+    };
+  } else {
+    // We can reuse the existing object from previous renders.
+    renderState.isBackwards = isBackwards;
+    renderState.rendering = null;
+    renderState.renderingStartTime = 0;
+    renderState.last = lastContentRow;
+    renderState.tail = tail;
+    renderState.tailMode = tailMode;
+  }
+} // This can end up rendering this component multiple passes.
+// The first pass splits the children fibers into two sets. A head and tail.
+// We first render the head. If anything is in fallback state, we do another
+// pass through beginWork to rerender all children (including the tail) with
+// the force suspend context. If the first render didn't have anything in
+// in fallback state. Then we render each row in the tail one-by-one.
+// That happens in the completeWork phase without going back to beginWork.
+
+
+function updateSuspenseListComponent(current, workInProgress, renderLanes) {
+  const nextProps = workInProgress.pendingProps;
+  const revealOrder = nextProps.revealOrder;
+  const tailMode = nextProps.tail;
+  const newChildren = nextProps.children;
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  let suspenseContext = suspenseStackCursor.current;
+  const shouldForceFallback = hasSuspenseListContext(suspenseContext, ForceSuspenseFallback);
+
+  if (shouldForceFallback) {
+    suspenseContext = setShallowSuspenseListContext(suspenseContext, ForceSuspenseFallback);
+    workInProgress.flags |= DidCapture;
+  } else {
+    const didSuspendBefore = current !== null && (current.flags & DidCapture) !== NoFlags$1;
+
+    if (didSuspendBefore) {
+      // If we previously forced a fallback, we need to schedule work
+      // on any nested boundaries to let them know to try to render
+      // again. This is the same as context updating.
+      propagateSuspenseContextChange(workInProgress, workInProgress.child, renderLanes);
+    }
+
+    suspenseContext = setDefaultShallowSuspenseListContext(suspenseContext);
+  }
+
+  pushSuspenseListContext(workInProgress, suspenseContext);
+
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    // In legacy mode, SuspenseList doesn't work so we just
+    // use make it a noop by treating it as the default revealOrder.
+    workInProgress.memoizedState = null;
+  } else {
+    switch (revealOrder) {
+      case 'forwards':
+        {
+          const lastContentRow = findLastContentRow(workInProgress.child);
+          let tail;
+
+          if (lastContentRow === null) {
+            // The whole list is part of the tail.
+            // TODO: We could fast path by just rendering the tail now.
+            tail = workInProgress.child;
+            workInProgress.child = null;
+          } else {
+            // Disconnect the tail rows after the content row.
+            // We're going to render them separately later.
+            tail = lastContentRow.sibling;
+            lastContentRow.sibling = null;
+          }
+
+          initSuspenseListRenderState(workInProgress, false, // isBackwards
+          tail, lastContentRow, tailMode);
+          break;
+        }
+
+      case 'backwards':
+        {
+          // We're going to find the first row that has existing content.
+          // At the same time we're going to reverse the list of everything
+          // we pass in the meantime. That's going to be our tail in reverse
+          // order.
+          let tail = null;
+          let row = workInProgress.child;
+          workInProgress.child = null;
+
+          while (row !== null) {
+            const currentRow = row.alternate; // New rows can't be content rows.
+
+            if (currentRow !== null && findFirstSuspended(currentRow) === null) {
+              // This is the beginning of the main content.
+              workInProgress.child = row;
+              break;
+            }
+
+            const nextRow = row.sibling;
+            row.sibling = tail;
+            tail = row;
+            row = nextRow;
+          } // TODO: If workInProgress.child is null, we can continue on the tail immediately.
+
+
+          initSuspenseListRenderState(workInProgress, true, // isBackwards
+          tail, null, // last
+          tailMode);
+          break;
+        }
+
+      case 'together':
+        {
+          initSuspenseListRenderState(workInProgress, false, // isBackwards
+          null, // tail
+          null, // last
+          undefined);
+          break;
+        }
+
+      default:
+        {
+          // The default reveal order is the same as not having
+          // a boundary.
+          workInProgress.memoizedState = null;
+        }
+    }
+  }
+
+  return workInProgress.child;
+}
+
+function updatePortalComponent(current, workInProgress, renderLanes) {
+  pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+  const nextChildren = workInProgress.pendingProps;
+
+  if (current === null) {
+    // Portals are special because we don't append the children during mount
+    // but at commit. Therefore we need to track insertions which the normal
+    // flow doesn't do during mount. This doesn't happen at the root because
+    // the root always starts with a "current" with a null child.
+    // TODO: Consider unifying this with how the root works.
+    workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderLanes);
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  }
+
+  return workInProgress.child;
+}
+
+function updateContextProvider(current, workInProgress, renderLanes) {
+  const providerType = workInProgress.type;
+  const context = providerType._context;
+  const newProps = workInProgress.pendingProps;
+  const oldProps = workInProgress.memoizedProps;
+  const newValue = newProps.value;
+
+  pushProvider(workInProgress, context, newValue);
+
+  {
+    if (oldProps !== null) {
+      const oldValue = oldProps.value;
+
+      if (objectIs(oldValue, newValue)) {
+        // No change. Bailout early if children are the same.
+        if (oldProps.children === newProps.children && !hasContextChanged()) {
+          return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+        }
+      } else {
+        // The context value changed. Search for matching consumers and schedule
+        // them to update.
+        propagateContextChange(workInProgress, context, renderLanes);
+      }
+    }
+  }
+
+  const newChildren = newProps.children;
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateContextConsumer(current, workInProgress, renderLanes) {
+  let context = workInProgress.type; // The logic below for Context differs depending on PROD or DEV mode. In
+
+  const newProps = workInProgress.pendingProps;
+  const render = newProps.children;
+
+  prepareToReadContext(workInProgress, renderLanes);
+  const newValue = readContext(context);
+
+  let newChildren;
+
+  {
+    newChildren = render(newValue);
+  }
+
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function markWorkInProgressReceivedUpdate() {
+  didReceiveUpdate = true;
+}
+
+function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    if (current !== null) {
+      // A lazy component only mounts if it suspended inside a non-
+      // concurrent tree, in an inconsistent state. We want to treat it like
+      // a new mount, even though an empty version of it already committed.
+      // Disconnect the alternate pointers.
+      current.alternate = null;
+      workInProgress.alternate = null; // Since this is conceptually a new fiber, schedule a Placement effect
+
+      workInProgress.flags |= Placement;
+    }
+  }
+}
+
+function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
+  if (current !== null) {
+    // Reuse previous dependencies
+    workInProgress.dependencies = current.dependencies;
+  }
+
+  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.
+    {
+      return null;
+    }
+  } // This fiber doesn't have work, but its subtree does. Clone the child
+  // fibers and continue.
+
+
+  cloneChildFibers(current, workInProgress);
+  return workInProgress.child;
+}
+
+function checkScheduledUpdateOrContext(current, renderLanes) {
+  // Before performing an early bailout, we must check if there are pending
+  // updates or context.
+  const updateLanes = current.lanes;
+
+  if (includesSomeLane(updateLanes, renderLanes)) {
+    return true;
+  } // No pending update, but because context is propagated lazily, we need
+
+  return false;
+}
+
+function attemptEarlyBailoutIfNoScheduledUpdate(current, workInProgress, renderLanes) {
+  // This fiber does not have any pending work. Bailout without entering
+  // the begin phase. There's still some bookkeeping we that needs to be done
+  // in this optimized path, mostly pushing stuff onto the stack.
+  switch (workInProgress.tag) {
+    case HostRoot:
+      pushHostRootContext(workInProgress);
+
+      {
+        const cache = current.memoizedState.cache;
+        pushCacheProvider(workInProgress, cache);
+      }
+
+      resetHydrationState();
+      break;
+
+    case HostSingleton:
+    case HostComponent:
+      pushHostContext(workInProgress);
+      break;
+
+    case ClassComponent:
+      {
+        const Component = workInProgress.type;
+
+        if (isContextProvider(Component)) {
+          pushContextProvider(workInProgress);
+        }
+
+        break;
+      }
+
+    case HostPortal:
+      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+      break;
+
+    case ContextProvider:
+      {
+        const newValue = workInProgress.memoizedProps.value;
+        const context = workInProgress.type._context;
+        pushProvider(workInProgress, context, newValue);
+        break;
+      }
+
+    case Profiler:
+
+      break;
+
+    case SuspenseComponent:
+      {
+        const state = workInProgress.memoizedState;
+
+        if (state !== null) {
+          if (state.dehydrated !== null) {
+            // We're not going to render the children, so this is just to maintain
+            // push/pop symmetry
+            pushPrimaryTreeSuspenseHandler(workInProgress); // We know that this component will suspend again because if it has
+            // been unsuspended it has committed as a resolved Suspense component.
+            // If it needs to be retried, it should have work scheduled on it.
+
+            workInProgress.flags |= DidCapture; // We should never render the children of a dehydrated boundary until we
+            // upgrade it. We return null instead of bailoutOnAlreadyFinishedWork.
+
+            return null;
+          } // If this boundary is currently timed out, we need to decide
+          // whether to retry the primary children, or to skip over it and
+          // go straight to the fallback. Check the priority of the primary
+          // child fragment.
+
+
+          const primaryChildFragment = workInProgress.child;
+          const primaryChildLanes = primaryChildFragment.childLanes;
+
+          if (includesSomeLane(renderLanes, primaryChildLanes)) {
+            // The primary children have pending work. Use the normal path
+            // to attempt to render the primary children again.
+            return updateSuspenseComponent(current, workInProgress, renderLanes);
+          } else {
+            // The primary child fragment does not have pending work marked
+            // on it
+            pushPrimaryTreeSuspenseHandler(workInProgress); // The primary children do not have pending work with sufficient
+            // priority. Bailout.
+
+            const child = bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+
+            if (child !== null) {
+              // The fallback children have pending work. Skip over the
+              // primary children and work on the fallback.
+              return child.sibling;
+            } else {
+              // Note: We can return `null` here because we already checked
+              // whether there were nested context consumers, via the call to
+              // `bailoutOnAlreadyFinishedWork` above.
+              return null;
+            }
+          }
+        } else {
+          pushPrimaryTreeSuspenseHandler(workInProgress);
+        }
+
+        break;
+      }
+
+    case SuspenseListComponent:
+      {
+        const didSuspendBefore = (current.flags & DidCapture) !== NoFlags$1;
+        let hasChildWork = includesSomeLane(renderLanes, workInProgress.childLanes);
+
+        if (didSuspendBefore) {
+          if (hasChildWork) {
+            // If something was in fallback state last time, and we have all the
+            // same children then we're still in progressive loading state.
+            // Something might get unblocked by state updates or retries in the
+            // tree which will affect the tail. So we need to use the normal
+            // path to compute the correct tail.
+            return updateSuspenseListComponent(current, workInProgress, renderLanes);
+          } // If none of the children had any work, that means that none of
+          // them got retried so they'll still be blocked in the same way
+          // as before. We can fast bail out.
+
+
+          workInProgress.flags |= DidCapture;
+        } // If nothing suspended before and we're rendering the same children,
+        // then the tail doesn't matter. Anything new that suspends will work
+        // in the "together" mode, so we can continue from the state we had.
+
+
+        const renderState = workInProgress.memoizedState;
+
+        if (renderState !== null) {
+          // Reset to the "together" mode in case we've started a different
+          // update in the past but didn't complete it.
+          renderState.rendering = null;
+          renderState.tail = null;
+          renderState.lastEffect = null;
+        }
+
+        pushSuspenseListContext(workInProgress, suspenseStackCursor.current);
+
+        if (hasChildWork) {
+          break;
+        } else {
+          // If none of the children had any work, that means that none of
+          // them got retried so they'll still be blocked in the same way
+          // as before. We can fast bail out.
+          return null;
+        }
+      }
+
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      {
+        // Need to check if the tree still needs to be deferred. This is
+        // almost identical to the logic used in the normal update path,
+        // so we'll just enter that. The only difference is we'll bail out
+        // at the next level instead of this one, because the child props
+        // have not changed. Which is fine.
+        // TODO: Probably should refactor `beginWork` to split the bailout
+        // path from the normal path. I'm tempted to do a labeled break here
+        // but I won't :)
+        workInProgress.lanes = NoLanes;
+        return updateOffscreenComponent(current, workInProgress, renderLanes);
+      }
+
+    case CacheComponent:
+      {
+        {
+          const cache = current.memoizedState.cache;
+          pushCacheProvider(workInProgress, cache);
+        }
+
+        break;
+      }
+  }
+
+  return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+}
+
+function beginWork$1(current, workInProgress, renderLanes) {
+
+  if (current !== null) {
+    const oldProps = current.memoizedProps;
+    const newProps = workInProgress.pendingProps;
+
+    if (oldProps !== newProps || hasContextChanged() || ( // Force a re-render if the implementation changed due to hot reload:
+    false)) {
+      // If props or context changed, mark the fiber as having performed work.
+      // This may be unset if the props are determined to be equal later (memo).
+      didReceiveUpdate = true;
+    } else {
+      // Neither props nor legacy context changes. Check if there's a pending
+      // update or context change.
+      const hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(current, renderLanes);
+
+      if (!hasScheduledUpdateOrContext && // If this is the second pass of an error or suspense boundary, there
+      // may not be work scheduled on `current`, so we check for this flag.
+      (workInProgress.flags & DidCapture) === NoFlags$1) {
+        // No pending updates or context. Bail out now.
+        didReceiveUpdate = false;
+        return attemptEarlyBailoutIfNoScheduledUpdate(current, workInProgress, renderLanes);
+      }
+
+      if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags$1) {
+        // This is a special case that only exists for legacy mode.
+        // See https://github.com/facebook/react/pull/19216.
+        didReceiveUpdate = true;
+      } else {
+        // An update was scheduled on this fiber, but there are no new props
+        // nor legacy context. Set this to false. If an update queue or context
+        // consumer produces a changed value, it will set this to true. Otherwise,
+        // the component will assume the children have not changed and bail out.
+        didReceiveUpdate = false;
+      }
+    }
+  } else {
+    didReceiveUpdate = false;
+
+    if (getIsHydrating() && isForkedChild(workInProgress)) {
+      // Check if this child belongs to a list of muliple children in
+      // its parent.
+      //
+      // In a true multi-threaded implementation, we would render children on
+      // parallel threads. This would represent the beginning of a new render
+      // thread for this subtree.
+      //
+      // We only use this for id generation during hydration, which is why the
+      // logic is located in this special branch.
+      const slotIndex = workInProgress.index;
+      const numberOfForks = getForksAtLevel();
+      pushTreeId(workInProgress, numberOfForks, slotIndex);
+    }
+  } // Before entering the begin phase, clear pending update priority.
+  // TODO: This assumes that we're about to evaluate the component and process
+  // the update queue. However, there's an exception: SimpleMemoComponent
+  // sometimes bails out later in the begin phase. This indicates that we should
+  // move this assignment out of the common path and into each branch.
+
+
+  workInProgress.lanes = NoLanes;
+
+  switch (workInProgress.tag) {
+    case IndeterminateComponent:
+      {
+        return mountIndeterminateComponent(current, workInProgress, workInProgress.type, renderLanes);
+      }
+
+    case LazyComponent:
+      {
+        const elementType = workInProgress.elementType;
+        return mountLazyComponent(current, workInProgress, elementType, renderLanes);
+      }
+
+    case FunctionComponent:
+      {
+        const Component = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps;
+        const resolvedProps = workInProgress.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        return updateFunctionComponent(current, workInProgress, Component, resolvedProps, renderLanes);
+      }
+
+    case ClassComponent:
+      {
+        const Component = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps;
+        const resolvedProps = workInProgress.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        return updateClassComponent(current, workInProgress, Component, resolvedProps, renderLanes);
+      }
+
+    case HostRoot:
+      return updateHostRoot(current, workInProgress, renderLanes);
+
+    case HostHoistable:
+      {
+        return updateHostHoistable(current, workInProgress);
+      }
+
+    // Fall through
+
+    case HostSingleton:
+      {
+        return updateHostSingleton(current, workInProgress, renderLanes);
+      }
+
+    // Fall through
+
+    case HostComponent:
+      return updateHostComponent$1(current, workInProgress, renderLanes);
+
+    case HostText:
+      return updateHostText$1(current, workInProgress);
+
+    case SuspenseComponent:
+      return updateSuspenseComponent(current, workInProgress, renderLanes);
+
+    case HostPortal:
+      return updatePortalComponent(current, workInProgress, renderLanes);
+
+    case ForwardRef:
+      {
+        const type = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps;
+        const resolvedProps = workInProgress.elementType === type ? unresolvedProps : resolveDefaultProps(type, unresolvedProps);
+        return updateForwardRef(current, workInProgress, type, resolvedProps, renderLanes);
+      }
+
+    case Fragment:
+      return updateFragment(current, workInProgress, renderLanes);
+
+    case Mode:
+      return updateMode(current, workInProgress, renderLanes);
+
+    case Profiler:
+      return updateProfiler(current, workInProgress, renderLanes);
+
+    case ContextProvider:
+      return updateContextProvider(current, workInProgress, renderLanes);
+
+    case ContextConsumer:
+      return updateContextConsumer(current, workInProgress, renderLanes);
+
+    case MemoComponent:
+      {
+        const type = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps; // Resolve outer props first, then resolve inner props.
+
+        let resolvedProps = resolveDefaultProps(type, unresolvedProps);
+
+        resolvedProps = resolveDefaultProps(type.type, resolvedProps);
+        return updateMemoComponent(current, workInProgress, type, resolvedProps, renderLanes);
+      }
+
+    case SimpleMemoComponent:
+      {
+        return updateSimpleMemoComponent(current, workInProgress, workInProgress.type, workInProgress.pendingProps, renderLanes);
+      }
+
+    case IncompleteClassComponent:
+      {
+        const Component = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps;
+        const resolvedProps = workInProgress.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        return mountIncompleteClassComponent(current, workInProgress, Component, resolvedProps, renderLanes);
+      }
+
+    case SuspenseListComponent:
+      {
+        return updateSuspenseListComponent(current, workInProgress, renderLanes);
+      }
+
+    case ScopeComponent:
+      {
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        return updateOffscreenComponent(current, workInProgress, renderLanes);
+      }
+
+    case LegacyHiddenComponent:
+      {
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        {
+          return updateCacheComponent(current, workInProgress, renderLanes);
+        }
+      }
+  }
+
+  throw Error(formatProdErrorMessage(156, workInProgress.tag));
+}
+
+const valueCursor = createCursor(null);
+
+let currentlyRenderingFiber = null;
+let lastContextDependency = null;
+let lastFullyObservedContext = null;
+function resetContextDependencies() {
+  // This is called right before React yields execution, to ensure `readContext`
+  // cannot be called outside the render phase.
+  currentlyRenderingFiber = null;
+  lastContextDependency = null;
+  lastFullyObservedContext = null;
+}
+function pushProvider(providerFiber, context, nextValue) {
+  {
+    push(valueCursor, context._currentValue);
+    context._currentValue = nextValue;
+  }
+}
+function popProvider(context, providerFiber) {
+  const currentValue = valueCursor.current;
+
+  {
+    if (currentValue === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      context._currentValue = context._defaultValue;
+    } else {
+      context._currentValue = currentValue;
+    }
+  }
+
+  pop(valueCursor);
+}
+function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
+  // Update the child lanes of all the ancestors, including the alternates.
+  let node = parent;
+
+  while (node !== null) {
+    const alternate = node.alternate;
+
+    if (!isSubsetOfLanes(node.childLanes, renderLanes)) {
+      node.childLanes = mergeLanes(node.childLanes, renderLanes);
+
+      if (alternate !== null) {
+        alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
+      }
+    } else if (alternate !== null && !isSubsetOfLanes(alternate.childLanes, renderLanes)) {
+      alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
+    } else ;
+
+    if (node === propagationRoot) {
+      break;
+    }
+
+    node = node.return;
+  }
+}
+function propagateContextChange(workInProgress, context, renderLanes) {
+  {
+    propagateContextChange_eager(workInProgress, context, renderLanes);
+  }
+}
+
+function propagateContextChange_eager(workInProgress, context, renderLanes) {
+
+  let 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) {
+    let nextFiber; // Visit this fiber.
+
+    const list = fiber.dependencies;
+
+    if (list !== null) {
+      nextFiber = fiber.child;
+      let dependency = list.firstContext;
+
+      while (dependency !== null) {
+        // Check if the context matches.
+        if (dependency.context === context) {
+          // Match! Schedule an update on this fiber.
+          if (fiber.tag === ClassComponent) {
+            // Schedule a force update on the work-in-progress.
+            const lane = pickArbitraryLane(renderLanes);
+            const update = createUpdate(lane);
+            update.tag = ForceUpdate; // TODO: Because we don't have a work-in-progress, this will add the
+            // update to the current fiber, too, which means it will persist even if
+            // this render is thrown away. Since it's a race condition, not sure it's
+            // worth fixing.
+            // Inlined `enqueueUpdate` to remove interleaved update check
+
+            const updateQueue = fiber.updateQueue;
+
+            if (updateQueue === null) ; else {
+              const sharedQueue = updateQueue.shared;
+              const pending = sharedQueue.pending;
+
+              if (pending === null) {
+                // This is the first update. Create a circular list.
+                update.next = update;
+              } else {
+                update.next = pending.next;
+                pending.next = update;
+              }
+
+              sharedQueue.pending = update;
+            }
+          }
+
+          fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
+          const alternate = fiber.alternate;
+
+          if (alternate !== null) {
+            alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+          }
+
+          scheduleContextWorkOnParentPath(fiber.return, renderLanes, workInProgress); // Mark the updated lanes on the list, too.
+
+          list.lanes = mergeLanes(list.lanes, renderLanes); // Since we already found a match, we can stop traversing the
+          // dependency list.
+
+          break;
+        }
+
+        dependency = dependency.next;
+      }
+    } else if (fiber.tag === ContextProvider) {
+      // Don't scan deeper if this is a matching provider
+      nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
+    } else if (fiber.tag === DehydratedFragment) {
+      // If a dehydrated suspense boundary is in this subtree, we don't know
+      // if it will have any context consumers in it. The best we can do is
+      // mark it as having updates.
+      const parentSuspense = fiber.return;
+
+      if (parentSuspense === null) {
+        throw Error(formatProdErrorMessage(341));
+      }
+
+      parentSuspense.lanes = mergeLanes(parentSuspense.lanes, renderLanes);
+      const alternate = parentSuspense.alternate;
+
+      if (alternate !== null) {
+        alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+      } // This is intentionally passing this fiber as the parent
+      // because we want to schedule this fiber as having work
+      // on its children. We'll use the childLanes on
+      // this fiber to indicate that a context has changed.
+
+
+      scheduleContextWorkOnParentPath(parentSuspense, renderLanes, workInProgress);
+      nextFiber = fiber.sibling;
+    } else {
+      // Traverse down.
+      nextFiber = fiber.child;
+    }
+
+    if (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;
+        }
+
+        const 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 prepareToReadContext(workInProgress, renderLanes) {
+  currentlyRenderingFiber = workInProgress;
+  lastContextDependency = null;
+  lastFullyObservedContext = null;
+  const dependencies = workInProgress.dependencies;
+
+  if (dependencies !== null) {
+    {
+      const firstContext = dependencies.firstContext;
+
+      if (firstContext !== null) {
+        if (includesSomeLane(dependencies.lanes, renderLanes)) {
+          // Context list has a pending update. Mark that this fiber performed work.
+          markWorkInProgressReceivedUpdate();
+        } // Reset the work-in-progress list
+
+
+        dependencies.firstContext = null;
+      }
+    }
+  }
+}
+function readContext(context) {
+
+  return readContextForConsumer(currentlyRenderingFiber, context);
+}
+function readContextDuringReconcilation(consumer, context, renderLanes) {
+  if (currentlyRenderingFiber === null) {
+    prepareToReadContext(consumer, renderLanes);
+  }
+
+  return readContextForConsumer(consumer, context);
+}
+
+function readContextForConsumer(consumer, context) {
+  const value = context._currentValue ;
+
+  if (lastFullyObservedContext === context) ; else {
+    const contextItem = {
+      context: context,
+      memoizedValue: value,
+      next: null
+    };
+
+    if (lastContextDependency === null) {
+      if (consumer === null) {
+        throw Error(formatProdErrorMessage(308));
+      } // This is the first dependency for this component. Create a new list.
+
+
+      lastContextDependency = contextItem;
+      consumer.dependencies = {
+        lanes: NoLanes,
+        firstContext: contextItem
+      };
+    } else {
+      // Append a new context item.
+      lastContextDependency = lastContextDependency.next = contextItem;
+    }
+  }
+
+  return value;
+}
+
+// replace it with a lightweight shim that only has the features we use.
+
+const AbortControllerLocal = typeof AbortController !== 'undefined' ? AbortController : // $FlowFixMe[missing-this-annot]
+// $FlowFixMe[prop-missing]
+function AbortControllerShim() {
+  const listeners = [];
+  const signal = this.signal = {
+    aborted: false,
+    addEventListener: (type, listener) => {
+      listeners.push(listener);
+    }
+  };
+
+  this.abort = () => {
+    signal.aborted = true;
+    listeners.forEach(listener => listener());
+  };
+} ; // Intentionally not named imports because Rollup would
+// use dynamic dispatch for CommonJS interop named imports.
+
+const scheduleCallback$1 = Scheduler.unstable_scheduleCallback,
+      NormalPriority = Scheduler.unstable_NormalPriority;
+const CacheContext = {
+  $$typeof: REACT_CONTEXT_TYPE,
+  // We don't use Consumer/Provider for Cache components. So we'll cheat.
+  Consumer: null,
+  Provider: null,
+  // We'll initialize these at the root.
+  _currentValue: null,
+  _currentValue2: null,
+  _threadCount: 0,
+  _defaultValue: null,
+  _globalName: null
+} ;
+// for retaining the cache once it is in use (retainCache), and releasing the cache
+// once it is no longer needed (releaseCache).
+
+
+function createCache() {
+
+  const cache = {
+    controller: new AbortControllerLocal(),
+    data: new Map(),
+    refCount: 0
+  };
+  return cache;
+}
+function retainCache(cache) {
+
+  cache.refCount++;
+} // Cleanup a cache instance, potentially freeing it if there are no more references
+
+function releaseCache(cache) {
+
+  cache.refCount--;
+
+  if (cache.refCount === 0) {
+    scheduleCallback$1(NormalPriority, () => {
+      cache.controller.abort();
+    });
+  }
+}
+function pushCacheProvider(workInProgress, cache) {
+
+  pushProvider(workInProgress, CacheContext, cache);
+}
+function popCacheProvider(workInProgress, cache) {
+
+  popProvider(CacheContext);
+}
+
+const ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig;
+const NoTransition = null;
+function requestCurrentTransition() {
+  return ReactCurrentBatchConfig$2.transition;
+} // When retrying a Suspense/Offscreen boundary, we restore the cache that was
+// used during the previous render by placing it here, on the stack.
+
+const resumedCache = createCursor(null); // During the render/synchronous commit phase, we don't actually process the
+
+function peekCacheFromPool() {
+  // If we're rendering inside a Suspense boundary that is currently hidden,
+  // we should use the same cache that we used during the previous render, if
+  // one exists.
+
+
+  const cacheResumedFromPreviousRender = resumedCache.current;
+
+  if (cacheResumedFromPreviousRender !== null) {
+    return cacheResumedFromPreviousRender;
+  } // Otherwise, check the root's cache pool.
+
+
+  const root = getWorkInProgressRoot();
+  const cacheFromRootCachePool = root.pooledCache;
+  return cacheFromRootCachePool;
+}
+
+function requestCacheFromPool(renderLanes) {
+  // Similar to previous function, except if there's not already a cache in the
+  // pool, we allocate a new one.
+  const cacheFromPool = peekCacheFromPool();
+
+  if (cacheFromPool !== null) {
+    return cacheFromPool;
+  } // Create a fresh cache and add it to the root cache pool. A cache can have
+  // multiple owners:
+  // - A cache pool that lives on the FiberRoot. This is where all fresh caches
+  //   are originally created (TODO: except during refreshes, until we implement
+  //   this correctly). The root takes ownership immediately when the cache is
+  //   created. Conceptually, root.pooledCache is an Option<Arc<Cache>> (owned),
+  //   and the return value of this function is a &Arc<Cache> (borrowed).
+  // - One of several fiber types: host root, cache boundary, suspense
+  //   component. These retain and release in the commit phase.
+
+
+  const root = getWorkInProgressRoot();
+  const freshCache = createCache();
+  root.pooledCache = freshCache;
+  retainCache(freshCache);
+
+  if (freshCache !== null) {
+    root.pooledCacheLanes |= renderLanes;
+  }
+
+  return freshCache;
+}
+function pushTransition(offscreenWorkInProgress, prevCachePool, newTransitions) {
+  {
+    if (prevCachePool === null) {
+      push(resumedCache, resumedCache.current);
+    } else {
+      push(resumedCache, prevCachePool.pool);
+    }
+  }
+}
+function popTransition(workInProgress, current) {
+  if (current !== null) {
+
+    {
+      pop(resumedCache);
+    }
+  }
+}
+function getSuspendedCache() {
+  // cache that would have been used to render fresh data during this render,
+  // if there was any, so that we can resume rendering with the same cache when
+  // we receive more data.
+
+
+  const cacheFromPool = peekCacheFromPool();
+
+  if (cacheFromPool === null) {
+    return null;
+  }
+
+  return {
+    // We must also save the parent, so that when we resume we can detect
+    // a refresh.
+    parent: CacheContext._currentValue ,
+    pool: cacheFromPool
+  };
+}
+function getOffscreenDeferredCache() {
+
+  const cacheFromPool = peekCacheFromPool();
+
+  if (cacheFromPool === null) {
+    return null;
+  }
+
+  return {
+    // We must also store the parent, so that when we resume we can detect
+    // a refresh.
+    parent: CacheContext._currentValue ,
+    pool: cacheFromPool
+  };
+}
+
+function markUpdate(workInProgress) {
+  // Tag the fiber with an update effect. This turns a Placement into
+  // a PlacementAndUpdate.
+  workInProgress.flags |= Update;
+}
+
+function markRef(workInProgress) {
+  workInProgress.flags |= Ref | RefStatic;
+}
+
+function appendAllChildren(parent, workInProgress, needsVisibilityToggle, isHidden) {
+  {
+    // We only have the top Fiber that was created but we need recurse down its
+    // children to find all the terminal nodes.
+    let node = workInProgress.child;
+
+    while (node !== null) {
+      if (node.tag === HostComponent || node.tag === HostText) {
+        appendInitialChild(parent, node.stateNode);
+      } else if (node.tag === HostPortal || (node.tag === HostSingleton )) ; else if (node.child !== null) {
+        node.child.return = node;
+        node = node.child;
+        continue;
+      }
+
+      if (node === workInProgress) {
+        return;
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+      while (node.sibling === null) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        if (node.return === null || node.return === workInProgress) {
+          return;
+        }
+
+        node = node.return;
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+      node.sibling.return = node.return;
+      node = node.sibling;
+    }
+  }
+} // An unfortunate fork of appendAllChildren because we have two different parent types.
+
+function updateHostComponent(current, workInProgress, type, newProps, renderLanes) {
+  {
+    // If we have an alternate, that means this is an update and we need to
+    // schedule a side-effect to do the updates.
+    const oldProps = current.memoizedProps;
+
+    if (oldProps === newProps) {
+      // In mutation mode, this is sufficient for a bailout because
+      // we won't touch this node even if children changed.
+      return;
+    }
+
+    markUpdate(workInProgress);
+  }
+} // This function must be called at the very end of the complete phase, because
+// it might throw to suspend, and if the resource immediately loads, the work
+// loop will resume rendering as if the work-in-progress completed. So it must
+// fully complete.
+// TODO: This should ideally move to begin phase, but currently the instance is
+// not created until the complete phase. For our existing use cases, host nodes
+// that suspend don't have children, so it doesn't matter. But that might not
+// always be true in the future.
+
+
+function preloadInstanceAndSuspendIfNeeded(workInProgress, type, props, renderLanes) {
+  {
+    // If this flag was set previously, we can remove it. The flag
+    // represents whether this particular set of props might ever need to
+    // suspend. The safest thing to do is for maySuspendCommit to always
+    // return true, but if the renderer is reasonably confident that the
+    // underlying resource won't be evicted, it can return false as a
+    // performance optimization.
+    workInProgress.flags &= ~MaySuspendCommit;
+    return;
+  } // Mark this fiber with a flag. This gets set on all host instances
+}
+
+function preloadResourceAndSuspendIfNeeded(workInProgress, resource, type, props, renderLanes) {
+  // This is a fork of preloadInstanceAndSuspendIfNeeded, but for resources.
+  if (!mayResourceSuspendCommit(resource)) {
+    workInProgress.flags &= ~MaySuspendCommit;
+    return;
+  }
+
+  workInProgress.flags |= MaySuspendCommit;
+  const rootRenderLanes = getWorkInProgressRootRenderLanes();
+
+  if (!includesOnlyNonUrgentLanes(rootRenderLanes)) ; else {
+    const isReady = preloadResource(resource);
+
+    if (!isReady) {
+      if (shouldRemainOnPreviousScreen()) {
+        workInProgress.flags |= ShouldSuspendCommit;
+      } else {
+        suspendCommit();
+      }
+    }
+  }
+}
+
+function scheduleRetryEffect(workInProgress, retryQueue) {
+  const wakeables = retryQueue;
+
+  if (wakeables !== null) {
+    // Schedule an effect to attach a retry listener to the promise.
+    // TODO: Move to passive phase
+    workInProgress.flags |= Update;
+  } else {
+    // This boundary suspended, but no wakeables were added to the retry
+    // queue. Check if the renderer suspended commit. If so, this means
+    // that once the fallback is committed, we can immediately retry
+    // rendering again, because rendering wasn't actually blocked. Only
+    // the commit phase.
+    // TODO: Consider a model where we always schedule an immediate retry, even
+    // for normal Suspense. That way the retry can partially render up to the
+    // first thing that suspends.
+    if (workInProgress.flags & ScheduleRetry) {
+      const retryLane = // TODO: This check should probably be moved into claimNextRetryLane
+      // I also suspect that we need some further consolidation of offscreen
+      // and retry lanes.
+      workInProgress.tag !== OffscreenComponent ? claimNextRetryLane() : OffscreenLane;
+      workInProgress.lanes = mergeLanes(workInProgress.lanes, retryLane);
+    }
+  }
+}
+
+function updateHostText(current, workInProgress, oldText, newText) {
+  {
+    // If the text differs, mark it as an update. All the work in done in commitWork.
+    if (oldText !== newText) {
+      markUpdate(workInProgress);
+    }
+  }
+}
+
+function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
+  if (getIsHydrating()) {
+    // If we're hydrating, we should consume as many items as we can
+    // so we don't leave any behind.
+    return;
+  }
+
+  switch (renderState.tailMode) {
+    case 'hidden':
+      {
+        // Any insertions at the end of the tail list after this point
+        // should be invisible. If there are already mounted boundaries
+        // anything before them are not considered for collapsing.
+        // Therefore we need to go through the whole tail to find if
+        // there are any.
+        let tailNode = renderState.tail;
+        let lastTailNode = null;
+
+        while (tailNode !== null) {
+          if (tailNode.alternate !== null) {
+            lastTailNode = tailNode;
+          }
+
+          tailNode = tailNode.sibling;
+        } // Next we're simply going to delete all insertions after the
+        // last rendered item.
+
+
+        if (lastTailNode === null) {
+          // All remaining items in the tail are insertions.
+          renderState.tail = null;
+        } else {
+          // Detach the insertion after the last node that was already
+          // inserted.
+          lastTailNode.sibling = null;
+        }
+
+        break;
+      }
+
+    case 'collapsed':
+      {
+        // Any insertions at the end of the tail list after this point
+        // should be invisible. If there are already mounted boundaries
+        // anything before them are not considered for collapsing.
+        // Therefore we need to go through the whole tail to find if
+        // there are any.
+        let tailNode = renderState.tail;
+        let lastTailNode = null;
+
+        while (tailNode !== null) {
+          if (tailNode.alternate !== null) {
+            lastTailNode = tailNode;
+          }
+
+          tailNode = tailNode.sibling;
+        } // Next we're simply going to delete all insertions after the
+        // last rendered item.
+
+
+        if (lastTailNode === null) {
+          // All remaining items in the tail are insertions.
+          if (!hasRenderedATailFallback && renderState.tail !== null) {
+            // We suspended during the head. We want to show at least one
+            // row at the tail. So we'll keep on and cut off the rest.
+            renderState.tail.sibling = null;
+          } else {
+            renderState.tail = null;
+          }
+        } else {
+          // Detach the insertion after the last node that was already
+          // inserted.
+          lastTailNode.sibling = null;
+        }
+
+        break;
+      }
+  }
+}
+
+function bubbleProperties(completedWork) {
+  const didBailout = completedWork.alternate !== null && completedWork.alternate.child === completedWork.child;
+  let newChildLanes = NoLanes;
+  let subtreeFlags = NoFlags$1;
+
+  if (!didBailout) {
+    // Bubble up the earliest expiration time.
+    {
+      let child = completedWork.child;
+
+      while (child !== null) {
+        newChildLanes = mergeLanes(newChildLanes, mergeLanes(child.lanes, child.childLanes));
+        subtreeFlags |= child.subtreeFlags;
+        subtreeFlags |= child.flags; // Update the return pointer so the tree is consistent. This is a code
+        // smell because it assumes the commit phase is never concurrent with
+        // the render phase. Will address during refactor to alternate model.
+
+        child.return = completedWork;
+        child = child.sibling;
+      }
+    }
+
+    completedWork.subtreeFlags |= subtreeFlags;
+  } else {
+    // Bubble up the earliest expiration time.
+    {
+      let child = completedWork.child;
+
+      while (child !== null) {
+        newChildLanes = mergeLanes(newChildLanes, mergeLanes(child.lanes, child.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 |= child.subtreeFlags & StaticMask;
+        subtreeFlags |= child.flags & StaticMask; // Update the return pointer so the tree is consistent. This is a code
+        // smell because it assumes the commit phase is never concurrent with
+        // the render phase. Will address during refactor to alternate model.
+
+        child.return = completedWork;
+        child = child.sibling;
+      }
+    }
+
+    completedWork.subtreeFlags |= subtreeFlags;
+  }
+
+  completedWork.childLanes = newChildLanes;
+  return didBailout;
+}
+
+function completeDehydratedSuspenseBoundary(current, workInProgress, nextState) {
+  if (hasUnhydratedTailNodes() && (workInProgress.mode & ConcurrentMode) !== NoMode && (workInProgress.flags & DidCapture) === NoFlags$1) {
+    warnIfUnhydratedTailNodes();
+    resetHydrationState();
+    workInProgress.flags |= ForceClientRender | DidCapture;
+    return false;
+  }
+
+  const wasHydrated = popHydrationState(workInProgress);
+
+  if (nextState !== null && nextState.dehydrated !== null) {
+    // We might be inside a hydration state the first time we're picking up this
+    // Suspense boundary, and also after we've reentered it for further hydration.
+    if (current === null) {
+      if (!wasHydrated) {
+        throw Error(formatProdErrorMessage(318));
+      }
+
+      prepareToHydrateHostSuspenseInstance(workInProgress);
+      bubbleProperties(workInProgress);
+
+      return false;
+    } else {
+      // We might have reentered this boundary to hydrate it. If so, we need to reset the hydration
+      // state since we're now exiting out of it. popHydrationState doesn't do that for us.
+      resetHydrationState();
+
+      if ((workInProgress.flags & DidCapture) === NoFlags$1) {
+        // This boundary did not suspend so it's now hydrated and unsuspended.
+        workInProgress.memoizedState = null;
+      } // If nothing suspended, we need to schedule an effect to mark this boundary
+      // as having hydrated so events know that they're free to be invoked.
+      // It's also a signal to replay events and the suspense callback.
+      // If something suspended, schedule an effect to attach retry listeners.
+      // So we might as well always mark this.
+
+
+      workInProgress.flags |= Update;
+      bubbleProperties(workInProgress);
+
+      return false;
+    }
+  } else {
+    // Successfully completed this tree. If this was a forced client render,
+    // there may have been recoverable errors during first hydration
+    // attempt. If so, add them to a queue so we can log them in the
+    // commit phase.
+    upgradeHydrationErrorsToRecoverable(); // Fall through to normal Suspense path
+
+    return true;
+  }
+}
+
+function completeWork(current, workInProgress, renderLanes) {
+  const newProps = workInProgress.pendingProps; // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
+
+  popTreeContext(workInProgress);
+
+  switch (workInProgress.tag) {
+    case IndeterminateComponent:
+    case LazyComponent:
+    case SimpleMemoComponent:
+    case FunctionComponent:
+    case ForwardRef:
+    case Fragment:
+    case Mode:
+    case Profiler:
+    case ContextConsumer:
+    case MemoComponent:
+      bubbleProperties(workInProgress);
+      return null;
+
+    case ClassComponent:
+      {
+        const Component = workInProgress.type;
+
+        if (isContextProvider(Component)) {
+          popContext();
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
+
+    case HostRoot:
+      {
+        const fiberRoot = workInProgress.stateNode;
+
+        {
+          let previousCache = null;
+
+          if (current !== null) {
+            previousCache = current.memoizedState.cache;
+          }
+
+          const cache = workInProgress.memoizedState.cache;
+
+          if (cache !== previousCache) {
+            // Run passive effects to retain/release the cache.
+            workInProgress.flags |= Passive$1;
+          }
+
+          popCacheProvider();
+        }
+        popHostContainer();
+        popTopLevelContextObject();
+
+        if (fiberRoot.pendingContext) {
+          fiberRoot.context = fiberRoot.pendingContext;
+          fiberRoot.pendingContext = null;
+        }
+
+        if (current === null || current.child === null) {
+          // If we hydrated, pop so that we can delete any remaining children
+          // that weren't hydrated.
+          const wasHydrated = popHydrationState(workInProgress);
+
+          if (wasHydrated) {
+            // If we hydrated, then we'll need to schedule an update for
+            // the commit side-effects on the root.
+            markUpdate(workInProgress);
+          } else {
+            if (current !== null) {
+              const prevState = current.memoizedState;
+
+              if ( // Check if this is a client root
+              !prevState.isDehydrated || // Check if we reverted to client rendering (e.g. due to an error)
+              (workInProgress.flags & ForceClientRender) !== NoFlags$1) {
+                // Schedule an effect to clear this container at the start of the
+                // next commit. This handles the case of React rendering into a
+                // container with previous children. It's also safe to do for
+                // updates too, because current.child would only be null if the
+                // previous render was null (so the container would already
+                // be empty).
+                workInProgress.flags |= Snapshot; // If this was a forced client render, there may have been
+                // recoverable errors during first hydration attempt. If so, add
+                // them to a queue so we can log them in the commit phase.
+
+                upgradeHydrationErrorsToRecoverable();
+              }
+            }
+          }
+        }
+        bubbleProperties(workInProgress);
+
+        return null;
+      }
+
+    case HostHoistable:
+      {
+        {
+          const nextResource = workInProgress.memoizedState;
+
+          if (current === null) {
+            // We are mounting and must Update this Hoistable in this commit
+            // @TODO refactor this block to create the instance here in complete
+            // phase if we are not hydrating.
+            markUpdate(workInProgress);
+
+            if (workInProgress.ref !== null) {
+              markRef(workInProgress);
+            }
+
+            if (nextResource !== null) {
+              // This is a Hoistable Resource
+              // This must come at the very end of the complete phase.
+              bubbleProperties(workInProgress);
+              preloadResourceAndSuspendIfNeeded(workInProgress, nextResource);
+              return null;
+            } else {
+              // This is a Hoistable Instance
+              // This must come at the very end of the complete phase.
+              bubbleProperties(workInProgress);
+              preloadInstanceAndSuspendIfNeeded(workInProgress);
+              return null;
+            }
+          } else {
+            // We are updating.
+            const currentResource = current.memoizedState;
+
+            if (nextResource !== currentResource) {
+              // We are transitioning to, from, or between Hoistable Resources
+              // and require an update
+              markUpdate(workInProgress);
+            }
+
+            if (current.ref !== workInProgress.ref) {
+              markRef(workInProgress);
+            }
+
+            if (nextResource !== null) {
+              // This is a Hoistable Resource
+              // This must come at the very end of the complete phase.
+              bubbleProperties(workInProgress);
+
+              if (nextResource === currentResource) {
+                workInProgress.flags &= ~MaySuspendCommit;
+              } else {
+                preloadResourceAndSuspendIfNeeded(workInProgress, nextResource);
+              }
+
+              return null;
+            } else {
+              // This is a Hoistable Instance
+              // We may have props to update on the Hoistable instance.
+              {
+                const oldProps = current.memoizedProps;
+
+                if (oldProps !== newProps) {
+                  markUpdate(workInProgress);
+                }
+              } // This must come at the very end of the complete phase.
+
+
+              bubbleProperties(workInProgress);
+              preloadInstanceAndSuspendIfNeeded(workInProgress);
+              return null;
+            }
+          }
+        } // Fall through
+
+      }
+
+    case HostSingleton:
+      {
+        {
+          popHostContext(workInProgress);
+          const rootContainerInstance = getRootHostContainer();
+          const type = workInProgress.type;
+
+          if (current !== null && workInProgress.stateNode != null) {
+            {
+              const oldProps = current.memoizedProps;
+
+              if (oldProps !== newProps) {
+                markUpdate(workInProgress);
+              }
+            }
+
+            if (current.ref !== workInProgress.ref) {
+              markRef(workInProgress);
+            }
+          } else {
+            if (!newProps) {
+              if (workInProgress.stateNode === null) {
+                throw Error(formatProdErrorMessage(166));
+              } // This can happen when we abort work.
+
+
+              bubbleProperties(workInProgress);
+              return null;
+            }
+
+            const currentHostContext = getHostContext();
+            const wasHydrated = popHydrationState(workInProgress);
+            let instance;
+
+            if (wasHydrated) {
+              // We ignore the boolean indicating there is an updateQueue because
+              // it is used only to set text children and HostSingletons do not
+              // use them.
+              prepareToHydrateHostInstance(workInProgress, currentHostContext);
+              instance = workInProgress.stateNode;
+            } else {
+              instance = resolveSingletonInstance(type, newProps, rootContainerInstance);
+              workInProgress.stateNode = instance;
+              markUpdate(workInProgress);
+            }
+
+            if (workInProgress.ref !== null) {
+              // If there is a ref on a host node we need to schedule a callback
+              markRef(workInProgress);
+            }
+          }
+
+          bubbleProperties(workInProgress);
+          return null;
+        } // Fall through
+
+      }
+
+    case HostComponent:
+      {
+        popHostContext(workInProgress);
+        const type = workInProgress.type;
+
+        if (current !== null && workInProgress.stateNode != null) {
+          updateHostComponent(current, workInProgress, type, newProps);
+
+          if (current.ref !== workInProgress.ref) {
+            markRef(workInProgress);
+          }
+        } else {
+          if (!newProps) {
+            if (workInProgress.stateNode === null) {
+              throw Error(formatProdErrorMessage(166));
+            } // This can happen when we abort work.
+
+
+            bubbleProperties(workInProgress);
+            return null;
+          }
+
+          const currentHostContext = getHostContext(); // TODO: Move createInstance to beginWork and keep it on a context
+          // "stack" as the parent. Then append children as we go in beginWork
+          // or completeWork depending on whether we want to add them top->down or
+          // bottom->up. Top->down is faster in IE11.
+
+          const wasHydrated = popHydrationState(workInProgress);
+
+          if (wasHydrated) {
+            // TODO: Move this and createInstance step into the beginPhase
+            // to consolidate.
+            prepareToHydrateHostInstance(workInProgress, currentHostContext);
+          } else {
+            const rootContainerInstance = getRootHostContainer();
+            const instance = createInstance(type, newProps, rootContainerInstance, currentHostContext, workInProgress); // TODO: For persistent renderers, we should pass children as part
+            // of the initial instance creation
+
+            appendAllChildren(instance, workInProgress);
+            workInProgress.stateNode = instance; // Certain renderers require commit-time effects for initial mount.
+            // (eg DOM renderer supports auto-focus for certain elements).
+            // Make sure such renderers get scheduled for later work.
+
+            if (finalizeInitialChildren(instance, type, newProps)) {
+              markUpdate(workInProgress);
+            }
+          }
+
+          if (workInProgress.ref !== null) {
+            // If there is a ref on a host node we need to schedule a callback
+            markRef(workInProgress);
+          }
+        }
+
+        bubbleProperties(workInProgress); // This must come at the very end of the complete phase, because it might
+        // throw to suspend, and if the resource immediately loads, the work loop
+        // will resume rendering as if the work-in-progress completed. So it must
+        // fully complete.
+
+        preloadInstanceAndSuspendIfNeeded(workInProgress);
+        return null;
+      }
+
+    case HostText:
+      {
+        const newText = newProps;
+
+        if (current && workInProgress.stateNode != null) {
+          const oldText = current.memoizedProps; // If we have an alternate, that means this is an update and we need
+          // to schedule a side-effect to do the updates.
+
+          updateHostText(current, workInProgress, oldText, newText);
+        } else {
+          if (typeof newText !== 'string') {
+            if (workInProgress.stateNode === null) {
+              throw Error(formatProdErrorMessage(166));
+            } // This can happen when we abort work.
+
+          }
+
+          const rootContainerInstance = getRootHostContainer();
+          const currentHostContext = getHostContext();
+          const wasHydrated = popHydrationState(workInProgress);
+
+          if (wasHydrated) {
+            if (prepareToHydrateHostTextInstance(workInProgress)) {
+              markUpdate(workInProgress);
+            }
+          } else {
+            workInProgress.stateNode = createTextInstance(newText, rootContainerInstance, currentHostContext, workInProgress);
+          }
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
+
+    case SuspenseComponent:
+      {
+        popSuspenseHandler(workInProgress);
+        const nextState = workInProgress.memoizedState; // Special path for dehydrated boundaries. We may eventually move this
+        // to its own fiber type so that we can add other kinds of hydration
+        // boundaries that aren't associated with a Suspense tree. In anticipation
+        // of such a refactor, all the hydration logic is contained in
+        // this branch.
+
+        if (current === null || current.memoizedState !== null && current.memoizedState.dehydrated !== null) {
+          const fallthroughToNormalSuspensePath = completeDehydratedSuspenseBoundary(current, workInProgress, nextState);
+
+          if (!fallthroughToNormalSuspensePath) {
+            if (workInProgress.flags & ForceClientRender) {
+              // Special case. There were remaining unhydrated nodes. We treat
+              // this as a mismatch. Revert to client rendering.
+              return workInProgress;
+            } else {
+              // Did not finish hydrating, either because this is the initial
+              // render or because something suspended.
+              return null;
+            }
+          } // Continue with the normal Suspense path.
+
+        }
+
+        if ((workInProgress.flags & DidCapture) !== NoFlags$1) {
+          // Something suspended. Re-render with the fallback children.
+          workInProgress.lanes = renderLanes; // Do not reset the effect list.
+
+
+          return workInProgress;
+        }
+
+        const nextDidTimeout = nextState !== null;
+        const prevDidTimeout = current !== null && current.memoizedState !== null;
+
+        if (nextDidTimeout) {
+          const offscreenFiber = workInProgress.child;
+          let previousCache = null;
+
+          if (offscreenFiber.alternate !== null && offscreenFiber.alternate.memoizedState !== null && offscreenFiber.alternate.memoizedState.cachePool !== null) {
+            previousCache = offscreenFiber.alternate.memoizedState.cachePool.pool;
+          }
+
+          let cache = null;
+
+          if (offscreenFiber.memoizedState !== null && offscreenFiber.memoizedState.cachePool !== null) {
+            cache = offscreenFiber.memoizedState.cachePool.pool;
+          }
+
+          if (cache !== previousCache) {
+            // Run passive effects to retain/release the cache.
+            offscreenFiber.flags |= Passive$1;
+          }
+        } // If the suspended state of the boundary changes, we need to schedule
+        // a passive effect, which is when we process the transitions
+
+
+        if (nextDidTimeout !== prevDidTimeout) {
+          // an effect to toggle the subtree's visibility. When we switch from
+          // fallback -> primary, the inner Offscreen fiber schedules this effect
+          // as part of its normal complete phase. But when we switch from
+          // primary -> fallback, the inner Offscreen fiber does not have a complete
+          // phase. So we need to schedule its effect here.
+          //
+          // We also use this flag to connect/disconnect the effects, but the same
+          // logic applies: when re-connecting, the Offscreen fiber's complete
+          // phase will handle scheduling the effect. It's only when the fallback
+          // is active that we have to do anything special.
+
+
+          if (nextDidTimeout) {
+            const offscreenFiber = workInProgress.child;
+            offscreenFiber.flags |= Visibility;
+          }
+        }
+
+        const retryQueue = workInProgress.updateQueue;
+        scheduleRetryEffect(workInProgress, retryQueue);
+
+        bubbleProperties(workInProgress);
+
+        return null;
+      }
+
+    case HostPortal:
+      popHostContainer();
+
+      if (current === null) {
+        preparePortalMount(workInProgress.stateNode.containerInfo);
+      }
+
+      bubbleProperties(workInProgress);
+      return null;
+
+    case ContextProvider:
+      // Pop provider fiber
+      const context = workInProgress.type._context;
+      popProvider(context);
+      bubbleProperties(workInProgress);
+      return null;
+
+    case IncompleteClassComponent:
+      {
+        // Same as class component case. I put it down here so that the tags are
+        // sequential to ensure this switch is compiled to a jump table.
+        const Component = workInProgress.type;
+
+        if (isContextProvider(Component)) {
+          popContext();
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
+
+    case SuspenseListComponent:
+      {
+        popSuspenseListContext();
+        const renderState = workInProgress.memoizedState;
+
+        if (renderState === null) {
+          // We're running in the default, "independent" mode.
+          // We don't do anything in this mode.
+          bubbleProperties(workInProgress);
+          return null;
+        }
+
+        let didSuspendAlready = (workInProgress.flags & DidCapture) !== NoFlags$1;
+        const renderedTail = renderState.rendering;
+
+        if (renderedTail === null) {
+          // We just rendered the head.
+          if (!didSuspendAlready) {
+            // This is the first pass. We need to figure out if anything is still
+            // suspended in the rendered set.
+            // If new content unsuspended, but there's still some content that
+            // didn't. Then we need to do a second pass that forces everything
+            // to keep showing their fallbacks.
+            // We might be suspended if something in this render pass suspended, or
+            // something in the previous committed pass suspended. Otherwise,
+            // there's no chance so we can skip the expensive call to
+            // findFirstSuspended.
+            const cannotBeSuspended = renderHasNotSuspendedYet() && (current === null || (current.flags & DidCapture) === NoFlags$1);
+
+            if (!cannotBeSuspended) {
+              let row = workInProgress.child;
+
+              while (row !== null) {
+                const suspended = findFirstSuspended(row);
+
+                if (suspended !== null) {
+                  didSuspendAlready = true;
+                  workInProgress.flags |= DidCapture;
+                  cutOffTailIfNeeded(renderState, false); // If this is a newly suspended tree, it might not get committed as
+                  // part of the second pass. In that case nothing will subscribe to
+                  // its thenables. Instead, we'll transfer its thenables to the
+                  // SuspenseList so that it can retry if they resolve.
+                  // There might be multiple of these in the list but since we're
+                  // going to wait for all of them anyway, it doesn't really matter
+                  // which ones gets to ping. In theory we could get clever and keep
+                  // track of how many dependencies remain but it gets tricky because
+                  // in the meantime, we can add/remove/change items and dependencies.
+                  // We might bail out of the loop before finding any but that
+                  // doesn't matter since that means that the other boundaries that
+                  // we did find already has their listeners attached.
+
+                  const retryQueue = suspended.updateQueue;
+                  workInProgress.updateQueue = retryQueue;
+                  scheduleRetryEffect(workInProgress, retryQueue); // Rerender the whole list, but this time, we'll force fallbacks
+                  // to stay in place.
+                  // Reset the effect flags before doing the second pass since that's now invalid.
+                  // Reset the child fibers to their original state.
+
+                  workInProgress.subtreeFlags = NoFlags$1;
+                  resetChildFibers(workInProgress, renderLanes); // Set up the Suspense List Context to force suspense and
+                  // immediately rerender the children.
+
+                  pushSuspenseListContext(workInProgress, setShallowSuspenseListContext(suspenseStackCursor.current, ForceSuspenseFallback)); // Don't bubble properties in this case.
+
+                  return workInProgress.child;
+                }
+
+                row = row.sibling;
+              }
+            }
+
+            if (renderState.tail !== null && now() > getRenderTargetTime()) {
+              // We have already passed our CPU deadline but we still have rows
+              // left in the tail. We'll just give up further attempts to render
+              // the main content and only render fallbacks.
+              workInProgress.flags |= DidCapture;
+              didSuspendAlready = true;
+              cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
+              // to get it started back up to attempt the next item. While in terms
+              // of priority this work has the same priority as this current render,
+              // it's not part of the same transition once the transition has
+              // committed. If it's sync, we still want to yield so that it can be
+              // painted. Conceptually, this is really the same as pinging.
+              // We can use any RetryLane even if it's the one currently rendering
+              // since we're leaving it behind on this node.
+
+              workInProgress.lanes = SomeRetryLane;
+            }
+          } else {
+            cutOffTailIfNeeded(renderState, false);
+          } // Next we're going to render the tail.
+
+        } else {
+          // Append the rendered row to the child list.
+          if (!didSuspendAlready) {
+            const suspended = findFirstSuspended(renderedTail);
+
+            if (suspended !== null) {
+              workInProgress.flags |= DidCapture;
+              didSuspendAlready = true; // Ensure we transfer the update queue to the parent so that it doesn't
+              // get lost if this row ends up dropped during a second pass.
+
+              const retryQueue = suspended.updateQueue;
+              workInProgress.updateQueue = retryQueue;
+              scheduleRetryEffect(workInProgress, retryQueue);
+              cutOffTailIfNeeded(renderState, true); // This might have been modified.
+
+              if (renderState.tail === null && renderState.tailMode === 'hidden' && !renderedTail.alternate && !getIsHydrating() // We don't cut it if we're hydrating.
+              ) {
+                  // We're done.
+                  bubbleProperties(workInProgress);
+                  return null;
+                }
+            } else if ( // The time it took to render last row is greater than the remaining
+            // time we have to render. So rendering one more row would likely
+            // exceed it.
+            now() * 2 - renderState.renderingStartTime > getRenderTargetTime() && renderLanes !== OffscreenLane) {
+              // We have now passed our CPU deadline and we'll just give up further
+              // attempts to render the main content and only render fallbacks.
+              // The assumption is that this is usually faster.
+              workInProgress.flags |= DidCapture;
+              didSuspendAlready = true;
+              cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
+              // to get it started back up to attempt the next item. While in terms
+              // of priority this work has the same priority as this current render,
+              // it's not part of the same transition once the transition has
+              // committed. If it's sync, we still want to yield so that it can be
+              // painted. Conceptually, this is really the same as pinging.
+              // We can use any RetryLane even if it's the one currently rendering
+              // since we're leaving it behind on this node.
+
+              workInProgress.lanes = SomeRetryLane;
+            }
+          }
+
+          if (renderState.isBackwards) {
+            // The effect list of the backwards tail will have been added
+            // to the end. This breaks the guarantee that life-cycles fire in
+            // sibling order but that isn't a strong guarantee promised by React.
+            // Especially since these might also just pop in during future commits.
+            // Append to the beginning of the list.
+            renderedTail.sibling = workInProgress.child;
+            workInProgress.child = renderedTail;
+          } else {
+            const previousSibling = renderState.last;
+
+            if (previousSibling !== null) {
+              previousSibling.sibling = renderedTail;
+            } else {
+              workInProgress.child = renderedTail;
+            }
+
+            renderState.last = renderedTail;
+          }
+        }
+
+        if (renderState.tail !== null) {
+          // We still have tail rows to render.
+          // Pop a row.
+          const next = renderState.tail;
+          renderState.rendering = next;
+          renderState.tail = next.sibling;
+          renderState.renderingStartTime = now();
+          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.
+
+          let suspenseContext = suspenseStackCursor.current;
+
+          if (didSuspendAlready) {
+            suspenseContext = setShallowSuspenseListContext(suspenseContext, ForceSuspenseFallback);
+          } else {
+            suspenseContext = setDefaultShallowSuspenseListContext(suspenseContext);
+          }
+
+          pushSuspenseListContext(workInProgress, suspenseContext); // Do a pass over the next row.
+          // Don't bubble properties in this case.
+
+          return next;
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
+
+    case ScopeComponent:
+      {
+
+        break;
+      }
+
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      {
+        popSuspenseHandler(workInProgress);
+        popHiddenContext();
+        const nextState = workInProgress.memoizedState;
+        const nextIsHidden = nextState !== null; // Schedule a Visibility effect if the visibility has changed
+
+        {
+          if (current !== null) {
+            const prevState = current.memoizedState;
+            const prevIsHidden = prevState !== null;
+
+            if (prevIsHidden !== nextIsHidden) {
+              workInProgress.flags |= Visibility;
+            }
+          } else {
+            // On initial mount, we only need a Visibility effect if the tree
+            // is hidden.
+            if (nextIsHidden) {
+              workInProgress.flags |= Visibility;
+            }
+          }
+        }
+
+        if (!nextIsHidden || (workInProgress.mode & ConcurrentMode) === NoMode) {
+          bubbleProperties(workInProgress);
+        } else {
+          // Don't bubble properties for hidden children unless we're rendering
+          // at offscreen priority.
+          if (includesSomeLane(renderLanes, OffscreenLane) && // Also don't bubble if the tree suspended
+          (workInProgress.flags & DidCapture) === NoLanes) {
+            bubbleProperties(workInProgress); // Check if there was an insertion or update in the hidden subtree.
+            // If so, we need to hide those nodes in the commit phase, so
+            // schedule a visibility effect.
+
+            if (workInProgress.subtreeFlags & (Placement | Update)) {
+              workInProgress.flags |= Visibility;
+            }
+          }
+        }
+
+        const offscreenQueue = workInProgress.updateQueue;
+
+        if (offscreenQueue !== null) {
+          const retryQueue = offscreenQueue.retryQueue;
+          scheduleRetryEffect(workInProgress, retryQueue);
+        }
+
+        {
+          let previousCache = null;
+
+          if (current !== null && current.memoizedState !== null && current.memoizedState.cachePool !== null) {
+            previousCache = current.memoizedState.cachePool.pool;
+          }
+
+          let cache = null;
+
+          if (workInProgress.memoizedState !== null && workInProgress.memoizedState.cachePool !== null) {
+            cache = workInProgress.memoizedState.cachePool.pool;
+          }
+
+          if (cache !== previousCache) {
+            // Run passive effects to retain/release the cache.
+            workInProgress.flags |= Passive$1;
+          }
+        }
+
+        popTransition(workInProgress, current);
+        return null;
+      }
+
+    case CacheComponent:
+      {
+        {
+          let previousCache = null;
+
+          if (current !== null) {
+            previousCache = current.memoizedState.cache;
+          }
+
+          const cache = workInProgress.memoizedState.cache;
+
+          if (cache !== previousCache) {
+            // Run passive effects to retain/release the cache.
+            workInProgress.flags |= Passive$1;
+          }
+
+          popCacheProvider();
+          bubbleProperties(workInProgress);
+        }
+
+        return null;
+      }
+
+    case TracingMarkerComponent:
+      {
+
+        return null;
+      }
+  }
+
+  throw Error(formatProdErrorMessage(156, workInProgress.tag));
+}
+
+function unwindWork(current, workInProgress, renderLanes) {
+  // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
+  popTreeContext(workInProgress);
+
+  switch (workInProgress.tag) {
+    case ClassComponent:
+      {
+        const Component = workInProgress.type;
+
+        if (isContextProvider(Component)) {
+          popContext();
+        }
+
+        const flags = workInProgress.flags;
+
+        if (flags & ShouldCapture) {
+          workInProgress.flags = flags & ~ShouldCapture | DidCapture;
+
+          return workInProgress;
+        }
+
+        return null;
+      }
+
+    case HostRoot:
+      {
+
+        {
+          popCacheProvider();
+        }
+        popHostContainer();
+        popTopLevelContextObject();
+        const flags = workInProgress.flags;
+
+        if ((flags & ShouldCapture) !== NoFlags$1 && (flags & DidCapture) === NoFlags$1) {
+          // There was an error during render that wasn't captured by a suspense
+          // boundary. Do a second pass on the root to unmount the children.
+          workInProgress.flags = flags & ~ShouldCapture | DidCapture;
+          return workInProgress;
+        } // We unwound to the root without completing it. Exit.
+
+
+        return null;
+      }
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      {
+        // TODO: popHydrationState
+        popHostContext(workInProgress);
+        return null;
+      }
+
+    case SuspenseComponent:
+      {
+        popSuspenseHandler(workInProgress);
+        const suspenseState = workInProgress.memoizedState;
+
+        if (suspenseState !== null && suspenseState.dehydrated !== null) {
+          if (workInProgress.alternate === null) {
+            throw Error(formatProdErrorMessage(340));
+          }
+
+          resetHydrationState();
+        }
+
+        const flags = workInProgress.flags;
+
+        if (flags & ShouldCapture) {
+          workInProgress.flags = flags & ~ShouldCapture | DidCapture; // Captured a suspense effect. Re-render the boundary.
+
+          return workInProgress;
+        }
+
+        return null;
+      }
+
+    case SuspenseListComponent:
+      {
+        popSuspenseListContext(); // SuspenseList doesn't actually catch anything. It should've been
+        // caught by a nested boundary. If not, it should bubble through.
+
+        return null;
+      }
+
+    case HostPortal:
+      popHostContainer();
+      return null;
+
+    case ContextProvider:
+      const context = workInProgress.type._context;
+      popProvider(context);
+      return null;
+
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      {
+        popSuspenseHandler(workInProgress);
+        popHiddenContext();
+        popTransition(workInProgress, current);
+        const flags = workInProgress.flags;
+
+        if (flags & ShouldCapture) {
+          workInProgress.flags = flags & ~ShouldCapture | DidCapture; // Captured a suspense effect. Re-render the boundary.
+
+          return workInProgress;
+        }
+
+        return null;
+      }
+
+    case CacheComponent:
+      {
+        popCacheProvider();
+      }
+
+      return null;
+
+    case TracingMarkerComponent:
+
+      return null;
+
+    default:
+      return null;
+  }
+}
+
+function unwindInterruptedWork(current, interruptedWork, renderLanes) {
+  // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
+  popTreeContext(interruptedWork);
+
+  switch (interruptedWork.tag) {
+    case ClassComponent:
+      {
+        const childContextTypes = interruptedWork.type.childContextTypes;
+
+        if (childContextTypes !== null && childContextTypes !== undefined) {
+          popContext();
+        }
+
+        break;
+      }
+
+    case HostRoot:
+      {
+
+        {
+          popCacheProvider();
+        }
+        popHostContainer();
+        popTopLevelContextObject();
+        break;
+      }
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      {
+        popHostContext(interruptedWork);
+        break;
+      }
+
+    case HostPortal:
+      popHostContainer();
+      break;
+
+    case SuspenseComponent:
+      popSuspenseHandler(interruptedWork);
+      break;
+
+    case SuspenseListComponent:
+      popSuspenseListContext();
+      break;
+
+    case ContextProvider:
+      const context = interruptedWork.type._context;
+      popProvider(context);
+      break;
+
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      popSuspenseHandler(interruptedWork);
+      popHiddenContext();
+      popTransition(interruptedWork, current);
+      break;
+
+    case CacheComponent:
+      {
+        popCacheProvider();
+      }
+
+      break;
+  }
+}
+
+function invokeGuardedCallbackImpl(name, func, context) {
+  {
+    // $FlowFixMe[method-unbinding]
+    const funcArgs = Array.prototype.slice.call(arguments, 3);
+
+    try {
+      // $FlowFixMe[incompatible-call] Flow doesn't understand the arguments splicing.
+      func.apply(context, funcArgs);
+    } catch (error) {
+      this.onError(error);
+    }
+  }
+}
+
+let hasError = false;
+let caughtError = null; // Used by event system to capture/rethrow the first error.
+
+let hasRethrowError = false;
+let rethrowError = null;
+const reporter = {
+  onError(error) {
+    hasError = true;
+    caughtError = error;
+  }
+
+};
+/**
+ * Call a function while guarding against errors that happens within it.
+ * Returns an error if it throws, otherwise null.
+ *
+ * In production, this is implemented using a try-catch. The reason we don't
+ * use a try-catch directly is so that we can swap out a different
+ * implementation in DEV mode.
+ *
+ * @param {String} name of the guard to use for logging or debugging
+ * @param {Function} func The function to invoke
+ * @param {*} context The context to use when calling the function
+ * @param {...*} args Arguments for function
+ */
+
+function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+  hasError = false;
+  caughtError = null;
+  invokeGuardedCallbackImpl.apply(reporter, arguments);
+}
+/**
+ * Same as invokeGuardedCallback, but instead of returning an error, it stores
+ * it in a global so it can be rethrown by `rethrowCaughtError` later.
+ * TODO: See if caughtError and rethrowError can be unified.
+ *
+ * @param {String} name of the guard to use for logging or debugging
+ * @param {Function} func The function to invoke
+ * @param {*} context The context to use when calling the function
+ * @param {...*} args Arguments for function
+ */
+
+function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
+  invokeGuardedCallback.apply(this, arguments);
+
+  if (hasError) {
+    const error = clearCaughtError();
+
+    if (!hasRethrowError) {
+      hasRethrowError = true;
+      rethrowError = error;
+    }
+  }
+}
+/**
+ * During execution of guarded functions we will capture the first error which
+ * we will rethrow to be handled by the top level error handler.
+ */
+
+function rethrowCaughtError() {
+  if (hasRethrowError) {
+    const error = rethrowError;
+    hasRethrowError = false;
+    rethrowError = null;
+    throw error;
+  }
+}
+function clearCaughtError() {
+  if (hasError) {
+    const error = caughtError;
+    hasError = false;
+    caughtError = null;
+    return error;
+  } else {
+    throw Error(formatProdErrorMessage(198));
+  }
+}
+
+// Allows us to avoid traversing the return path to find the nearest Offscreen ancestor.
+
+
+let offscreenSubtreeIsHidden = false;
+let offscreenSubtreeWasHidden = false;
+const PossiblyWeakSet = typeof WeakSet === 'function' ? WeakSet : Set;
+let nextEffect = null; // Used for Profiling builds to track updaters.
+
+function shouldProfile(current) {
+  return enableProfilerTimer   ;
+}
+
+function callComponentWillUnmountWithTimer(current, instance) {
+  instance.props = current.memoizedProps;
+  instance.state = current.memoizedState;
+
+  {
+    instance.componentWillUnmount();
+  }
+} // Capture errors so they don't interrupt unmounting.
+
+
+function safelyCallComponentWillUnmount(current, nearestMountedAncestor, instance) {
+  try {
+    callComponentWillUnmountWithTimer(current, instance);
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+} // Capture errors so they don't interrupt mounting.
+
+
+function safelyAttachRef(current, nearestMountedAncestor) {
+  try {
+    commitAttachRef(current);
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+}
+
+function safelyDetachRef(current, nearestMountedAncestor) {
+  const ref = current.ref;
+  const refCleanup = current.refCleanup;
+
+  if (ref !== null) {
+    if (typeof refCleanup === 'function') {
+      try {
+        if (shouldProfile(current)) ; else {
+          refCleanup();
+        }
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
+      } finally {
+        // `refCleanup` has been called. Nullify all references to it to prevent double invocation.
+        current.refCleanup = null;
+        const finishedWork = current.alternate;
+
+        if (finishedWork != null) {
+          finishedWork.refCleanup = null;
+        }
+      }
+    } else if (typeof ref === 'function') {
+      let retVal;
+
+      try {
+        if (shouldProfile(current)) ; else {
+          retVal = ref(null);
+        }
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
+      }
+    } else {
+      // $FlowFixMe[incompatible-use] unable to narrow type to RefObject
+      ref.current = null;
+    }
+  }
+}
+
+function safelyCallDestroy(current, nearestMountedAncestor, destroy) {
+  try {
+    destroy();
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+}
+let shouldFireAfterActiveInstanceBlur = false;
+function commitBeforeMutationEffects(root, firstChild) {
+  prepareForCommit();
+  nextEffect = firstChild;
+  commitBeforeMutationEffects_begin(); // We no longer need to track the active instance fiber
+
+  const shouldFire = shouldFireAfterActiveInstanceBlur;
+  shouldFireAfterActiveInstanceBlur = false;
+  return shouldFire;
+}
+
+function commitBeforeMutationEffects_begin() {
+  while (nextEffect !== null) {
+    const fiber = nextEffect; // This phase is only used for beforeActiveInstanceBlur.
+
+    const child = fiber.child;
+
+    if ((fiber.subtreeFlags & BeforeMutationMask) !== NoFlags$1 && child !== null) {
+      child.return = fiber;
+      nextEffect = child;
+    } else {
+      commitBeforeMutationEffects_complete();
+    }
+  }
+}
+
+function commitBeforeMutationEffects_complete() {
+  while (nextEffect !== null) {
+    const fiber = nextEffect;
+
+    try {
+      commitBeforeMutationEffectsOnFiber(fiber);
+    } catch (error) {
+      captureCommitPhaseError(fiber, fiber.return, error);
+    }
+    const sibling = fiber.sibling;
+
+    if (sibling !== null) {
+      sibling.return = fiber.return;
+      nextEffect = sibling;
+      return;
+    }
+
+    nextEffect = fiber.return;
+  }
+}
+
+function commitBeforeMutationEffectsOnFiber(finishedWork) {
+  const current = finishedWork.alternate;
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+      {
+        {
+          if ((flags & Update) !== NoFlags$1) {
+            commitUseEffectEventMount(finishedWork);
+          }
+        }
+
+        break;
+      }
+
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        break;
+      }
+
+    case ClassComponent:
+      {
+        if ((flags & Snapshot) !== NoFlags$1) {
+          if (current !== null) {
+            const prevProps = current.memoizedProps;
+            const prevState = current.memoizedState;
+            const instance = finishedWork.stateNode; // We could update instance props and state here,
+
+            const snapshot = instance.getSnapshotBeforeUpdate(finishedWork.elementType === finishedWork.type ? prevProps : resolveDefaultProps(finishedWork.type, prevProps), prevState);
+
+            instance.__reactInternalSnapshotBeforeUpdate = snapshot;
+          }
+        }
+
+        break;
+      }
+
+    case HostRoot:
+      {
+        if ((flags & Snapshot) !== NoFlags$1) {
+          {
+            const root = finishedWork.stateNode;
+            clearContainer(root.containerInfo);
+          }
+        }
+
+        break;
+      }
+
+    case HostComponent:
+    case HostHoistable:
+    case HostSingleton:
+    case HostText:
+    case HostPortal:
+    case IncompleteClassComponent:
+      // Nothing to do for these component types
+      break;
+
+    default:
+      {
+        if ((flags & Snapshot) !== NoFlags$1) {
+          throw Error(formatProdErrorMessage(163));
+        }
+      }
+  }
+}
+
+function commitHookEffectListUnmount(flags, finishedWork, nearestMountedAncestor) {
+  const updateQueue = finishedWork.updateQueue;
+  const lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
+
+  if (lastEffect !== null) {
+    const firstEffect = lastEffect.next;
+    let effect = firstEffect;
+
+    do {
+      if ((effect.tag & flags) === flags) {
+        // Unmount
+        const inst = effect.inst;
+        const destroy = inst.destroy;
+
+        if (destroy !== undefined) {
+          inst.destroy = undefined;
+
+          safelyCallDestroy(finishedWork, nearestMountedAncestor, destroy);
+        }
+      }
+
+      effect = effect.next;
+    } while (effect !== firstEffect);
+  }
+}
+
+function commitHookEffectListMount(flags, finishedWork) {
+  const updateQueue = finishedWork.updateQueue;
+  const lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
+
+  if (lastEffect !== null) {
+    const firstEffect = lastEffect.next;
+    let effect = firstEffect;
+
+    do {
+      if ((effect.tag & flags) === flags) {
+
+
+        const create = effect.create;
+
+        const inst = effect.inst;
+        const destroy = create();
+        inst.destroy = destroy;
+      }
+
+      effect = effect.next;
+    } while (effect !== firstEffect);
+  }
+}
+
+function commitUseEffectEventMount(finishedWork) {
+  const updateQueue = finishedWork.updateQueue;
+  const eventPayloads = updateQueue !== null ? updateQueue.events : null;
+
+  if (eventPayloads !== null) {
+    for (let ii = 0; ii < eventPayloads.length; ii++) {
+      const _eventPayloads$ii = eventPayloads[ii],
+            ref = _eventPayloads$ii.ref,
+            nextImpl = _eventPayloads$ii.nextImpl;
+      ref.impl = nextImpl;
+    }
+  }
+}
+
+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.
+  {
+    try {
+      commitHookEffectListMount(hookFlags, finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
+
+function commitClassLayoutLifecycles(finishedWork, current) {
+  const instance = finishedWork.stateNode;
+
+  if (current === null) {
+
+    {
+      try {
+        instance.componentDidMount();
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+  } else {
+    const prevProps = finishedWork.elementType === finishedWork.type ? current.memoizedProps : resolveDefaultProps(finishedWork.type, current.memoizedProps);
+    const prevState = current.memoizedState; // We could update instance props and state here,
+
+    {
+      try {
+        instance.componentDidUpdate(prevProps, prevState, instance.__reactInternalSnapshotBeforeUpdate);
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+  }
+}
+
+function commitClassCallbacks(finishedWork) {
+  // TODO: I think this is now always non-null by the time it reaches the
+  // commit phase. Consider removing the type check.
+  const updateQueue = finishedWork.updateQueue;
+
+  if (updateQueue !== null) {
+    const instance = finishedWork.stateNode;
+    // but instead we rely on them being set during last render.
+    // TODO: revisit this when we implement resuming.
+
+
+    try {
+      commitCallbacks(updateQueue, instance);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
+
+function commitHostComponentMount(finishedWork) {
+  const type = finishedWork.type;
+  const props = finishedWork.memoizedProps;
+  const instance = finishedWork.stateNode;
+
+  try {
+    commitMount(instance, type, props, finishedWork);
+  } catch (error) {
+    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+  }
+}
+
+function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork, committedLanes) {
+  // When updating this function, also update reappearLayoutEffects, which does
+  // most of the same things when an offscreen tree goes from hidden -> visible.
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+        if (flags & Update) {
+          commitHookLayoutEffects(finishedWork, Layout | HasEffect);
+        }
+
+        break;
+      }
+
+    case ClassComponent:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+        if (flags & Update) {
+          commitClassLayoutLifecycles(finishedWork, current);
+        }
+
+        if (flags & Callback) {
+          commitClassCallbacks(finishedWork);
+        }
+
+        if (flags & Ref) {
+          safelyAttachRef(finishedWork, finishedWork.return);
+        }
+
+        break;
+      }
+
+    case HostRoot:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+        if (flags & Callback) {
+          // TODO: I think this is now always non-null by the time it reaches the
+          // commit phase. Consider removing the type check.
+          const updateQueue = finishedWork.updateQueue;
+
+          if (updateQueue !== null) {
+            let instance = null;
+
+            if (finishedWork.child !== null) {
+              switch (finishedWork.child.tag) {
+                case HostSingleton:
+                case HostComponent:
+                  instance = getPublicInstance(finishedWork.child.stateNode);
+                  break;
+
+                case ClassComponent:
+                  instance = finishedWork.child.stateNode;
+                  break;
+              }
+            }
+
+            try {
+              commitCallbacks(updateQueue, instance);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+        }
+
+        break;
+      }
+
+    case HostHoistable:
+      {
+        {
+          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+          if (flags & Ref) {
+            safelyAttachRef(finishedWork, finishedWork.return);
+          }
+
+          break;
+        } // Fall through
+
+      }
+
+    case HostSingleton:
+    case HostComponent:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork); // Renderers may schedule work to be done after host components are mounted
+        // (eg DOM renderer may schedule auto-focus for inputs and form controls).
+        // These effects should only be committed when components are first mounted,
+        // aka when there is no current/alternate.
+
+        if (current === null && flags & Update) {
+          commitHostComponentMount(finishedWork);
+        }
+
+        if (flags & Ref) {
+          safelyAttachRef(finishedWork, finishedWork.return);
+        }
+
+        break;
+      }
+
+    case Profiler:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork); // TODO: Should this fire inside an offscreen tree? Or should it wait to
+
+        break;
+      }
+
+    case SuspenseComponent:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+        if (flags & Update) {
+          commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
+        }
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const isModernRoot = (finishedWork.mode & ConcurrentMode) !== NoMode;
+
+        if (isModernRoot) {
+          const isHidden = finishedWork.memoizedState !== null;
+          const newOffscreenSubtreeIsHidden = isHidden || offscreenSubtreeIsHidden;
+
+          if (newOffscreenSubtreeIsHidden) ; else {
+            // The Offscreen tree is visible.
+            const wasHidden = current !== null && current.memoizedState !== null;
+            const newOffscreenSubtreeWasHidden = wasHidden || offscreenSubtreeWasHidden;
+            const prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
+            const prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+            offscreenSubtreeIsHidden = newOffscreenSubtreeIsHidden;
+            offscreenSubtreeWasHidden = newOffscreenSubtreeWasHidden;
+
+            if (offscreenSubtreeWasHidden && !prevOffscreenSubtreeWasHidden) {
+              // This is the root of a reappearing boundary. As we continue
+              // traversing the layout effects, we must also re-mount layout
+              // effects that were unmounted when the Offscreen subtree was
+              // hidden. So this is a superset of the normal commitLayoutEffects.
+              const includeWorkInProgressEffects = (finishedWork.subtreeFlags & LayoutMask) !== NoFlags$1;
+              recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+            } else {
+              recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+            }
+
+            offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+            offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+          }
+        } else {
+          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        }
+
+        if (flags & Ref) {
+          const props = finishedWork.memoizedProps;
+
+          if (props.mode === 'manual') {
+            safelyAttachRef(finishedWork, finishedWork.return);
+          } else {
+            safelyDetachRef(finishedWork, finishedWork.return);
+          }
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        break;
+      }
+  }
+}
+
+function hideOrUnhideAllChildren(finishedWork, isHidden) {
+  // Only hide or unhide the top-most host nodes.
+  let hostSubtreeRoot = null;
+
+  {
+    // We only have the top Fiber that was inserted but we need to recurse down its
+    // children to find all the terminal nodes.
+    let node = finishedWork;
+
+    while (true) {
+      if (node.tag === HostComponent || (node.tag === HostHoistable ) || (node.tag === HostSingleton )) {
+        if (hostSubtreeRoot === null) {
+          hostSubtreeRoot = node;
+
+          try {
+            const instance = node.stateNode;
+
+            if (isHidden) {
+              hideInstance(instance);
+            } else {
+              unhideInstance(node.stateNode, node.memoizedProps);
+            }
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      } else if (node.tag === HostText) {
+        if (hostSubtreeRoot === null) {
+          try {
+            const instance = node.stateNode;
+
+            if (isHidden) {
+              hideTextInstance(instance);
+            } else {
+              unhideTextInstance(instance, node.memoizedProps);
+            }
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      } else if ((node.tag === OffscreenComponent || node.tag === LegacyHiddenComponent) && node.memoizedState !== null && node !== finishedWork) ; else if (node.child !== null) {
+        node.child.return = node;
+        node = node.child;
+        continue;
+      }
+
+      if (node === finishedWork) {
+        return;
+      }
+
+      while (node.sibling === null) {
+        if (node.return === null || node.return === finishedWork) {
+          return;
+        }
+
+        if (hostSubtreeRoot === node) {
+          hostSubtreeRoot = null;
+        }
+
+        node = node.return;
+      }
+
+      if (hostSubtreeRoot === node) {
+        hostSubtreeRoot = null;
+      }
+
+      node.sibling.return = node.return;
+      node = node.sibling;
+    }
+  }
+}
+
+function commitAttachRef(finishedWork) {
+  const ref = finishedWork.ref;
+
+  if (ref !== null) {
+    const instance = finishedWork.stateNode;
+    let instanceToUse;
+
+    switch (finishedWork.tag) {
+      case HostHoistable:
+      case HostSingleton:
+      case HostComponent:
+        instanceToUse = getPublicInstance(instance);
+        break;
+
+      default:
+        instanceToUse = instance;
+    } // Moved outside to ensure DCE works with this flag
+
+    if (typeof ref === 'function') {
+      {
+        finishedWork.refCleanup = ref(instanceToUse);
+      }
+    } else {
+
+
+      ref.current = instanceToUse;
+    }
+  }
+}
+
+function detachFiberMutation(fiber) {
+  // Cut off the return pointer to disconnect it from the tree.
+  // This enables us to detect and warn against state updates on an unmounted component.
+  // It also prevents events from bubbling from within disconnected components.
+  //
+  // Ideally, we should also clear the child pointer of the parent alternate to let this
+  // get GC:ed but we don't know which for sure which parent is the current
+  // one so we'll settle for GC:ing the subtree of this child.
+  // This child itself will be GC:ed when the parent updates the next time.
+  //
+  // Note that we can't clear child or sibling pointers yet.
+  // They're needed for passive effects and for findDOMNode.
+  // We defer those fields, and all other cleanup, to the passive phase (see detachFiberAfterEffects).
+  //
+  // Don't reset the alternate yet, either. We need that so we can detach the
+  // alternate's fields in the passive phase. Clearing the return pointer is
+  // sufficient for findDOMNode semantics.
+  const alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    alternate.return = null;
+  }
+
+  fiber.return = null;
+}
+
+function detachFiberAfterEffects(fiber) {
+  const alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    fiber.alternate = null;
+    detachFiberAfterEffects(alternate);
+  } // Clear cyclical Fiber fields. This level alone is designed to roughly
+  // approximate the planned Fiber refactor. In that world, `setState` will be
+  // bound to a special "instance" object instead of a Fiber. The Instance
+  // object will not have any of these fields. It will only be connected to
+  // the fiber tree via a single link at the root. So if this level alone is
+  // sufficient to fix memory issues, that bodes well for our plans.
+
+
+  fiber.child = null;
+  fiber.deletions = null;
+  fiber.sibling = null; // The `stateNode` is cyclical because on host nodes it points to the host
+  // tree, which has its own pointers to children, parents, and siblings.
+  // The other host nodes also point back to fibers, so we should detach that
+  // one, too.
+
+  if (fiber.tag === HostComponent) {
+    const hostInstance = fiber.stateNode;
+
+    if (hostInstance !== null) {
+      detachDeletedInstance(hostInstance);
+    }
+  }
+
+  fiber.stateNode = null;
+  // disconnected the fiber from the tree. So even if something leaks this
+  // particular fiber, it won't leak anything else.
+
+
+  fiber.return = null;
+  fiber.dependencies = null;
+  fiber.memoizedProps = null;
+  fiber.memoizedState = null;
+  fiber.pendingProps = null;
+  fiber.stateNode = null; // TODO: Move to `commitPassiveUnmountInsideDeletedTreeOnFiber` instead.
+
+  fiber.updateQueue = null;
+}
+
+function getHostParentFiber(fiber) {
+  let parent = fiber.return;
+
+  while (parent !== null) {
+    if (isHostParent(parent)) {
+      return parent;
+    }
+
+    parent = parent.return;
+  }
+
+  throw Error(formatProdErrorMessage(160));
+}
+
+function isHostParent(fiber) {
+  return fiber.tag === HostComponent || fiber.tag === HostRoot || (fiber.tag === HostHoistable ) || (fiber.tag === HostSingleton ) || fiber.tag === HostPortal;
+}
+
+function getHostSibling(fiber) {
+  // We're going to search forward into the tree until we find a sibling host
+  // node. Unfortunately, if multiple insertions are done in a row we have to
+  // search past them. This leads to exponential search for the next sibling.
+  // TODO: Find a more efficient way to do this.
+  let node = fiber;
+
+  siblings: while (true) {
+    // If we didn't find anything, let's try the next sibling.
+    while (node.sibling === null) {
+      if (node.return === null || isHostParent(node.return)) {
+        // If we pop out of the root or hit the parent the fiber we are the
+        // last sibling.
+        return null;
+      } // $FlowFixMe[incompatible-type] found when upgrading Flow
+
+
+      node = node.return;
+    }
+
+    node.sibling.return = node.return;
+    node = node.sibling;
+
+    while (node.tag !== HostComponent && node.tag !== HostText && (node.tag !== HostSingleton) && node.tag !== DehydratedFragment) {
+      // If it is not host node and, we might have a host node inside it.
+      // Try to search down until we find one.
+      if (node.flags & Placement) {
+        // If we don't have a child, try the siblings instead.
+        continue siblings;
+      } // If we don't have a child, try the siblings instead.
+      // We also skip portals because they are not part of this host tree.
+
+
+      if (node.child === null || node.tag === HostPortal) {
+        continue siblings;
+      } else {
+        node.child.return = node;
+        node = node.child;
+      }
+    } // Check if this host node is stable or about to be placed.
+
+
+    if (!(node.flags & Placement)) {
+      // Found it!
+      return node.stateNode;
+    }
+  }
+}
+
+function commitPlacement(finishedWork) {
+
+  {
+    if (finishedWork.tag === HostSingleton) {
+      // Singletons are already in the Host and don't need to be placed
+      // Since they operate somewhat like Portals though their children will
+      // have Placement and will get placed inside them
+      return;
+    }
+  } // Recursively insert all host nodes into the parent.
+
+
+  const parentFiber = getHostParentFiber(finishedWork);
+
+  switch (parentFiber.tag) {
+    case HostSingleton:
+      {
+        {
+          const parent = parentFiber.stateNode;
+          const before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
+          // children to find all the terminal nodes.
+
+          insertOrAppendPlacementNode(finishedWork, before, parent);
+          break;
+        } // Fall through
+
+      }
+
+    case HostComponent:
+      {
+        const parent = parentFiber.stateNode;
+
+        if (parentFiber.flags & ContentReset) {
+          // Reset the text content of the parent before doing any insertions
+          resetTextContent(parent); // Clear ContentReset from the effect tag
+
+          parentFiber.flags &= ~ContentReset;
+        }
+
+        const before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
+        // children to find all the terminal nodes.
+
+        insertOrAppendPlacementNode(finishedWork, before, parent);
+        break;
+      }
+
+    case HostRoot:
+    case HostPortal:
+      {
+        const parent = parentFiber.stateNode.containerInfo;
+        const before = getHostSibling(finishedWork);
+        insertOrAppendPlacementNodeIntoContainer(finishedWork, before, parent);
+        break;
+      }
+
+    default:
+      throw Error(formatProdErrorMessage(161));
+  }
+}
+
+function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
+  const tag = node.tag;
+  const isHost = tag === HostComponent || tag === HostText;
+
+  if (isHost) {
+    const stateNode = node.stateNode;
+
+    if (before) {
+      insertInContainerBefore(parent, stateNode, before);
+    } else {
+      appendChildToContainer(parent, stateNode);
+    }
+  } else if (tag === HostPortal || (tag === HostSingleton )) ; else {
+    const child = node.child;
+
+    if (child !== null) {
+      insertOrAppendPlacementNodeIntoContainer(child, before, parent);
+      let sibling = child.sibling;
+
+      while (sibling !== null) {
+        insertOrAppendPlacementNodeIntoContainer(sibling, before, parent);
+        sibling = sibling.sibling;
+      }
+    }
+  }
+}
+
+function insertOrAppendPlacementNode(node, before, parent) {
+  const tag = node.tag;
+  const isHost = tag === HostComponent || tag === HostText;
+
+  if (isHost) {
+    const stateNode = node.stateNode;
+
+    if (before) {
+      insertBefore(parent, stateNode, before);
+    } else {
+      appendChild(parent, stateNode);
+    }
+  } else if (tag === HostPortal || (tag === HostSingleton )) ; else {
+    const child = node.child;
+
+    if (child !== null) {
+      insertOrAppendPlacementNode(child, before, parent);
+      let sibling = child.sibling;
+
+      while (sibling !== null) {
+        insertOrAppendPlacementNode(sibling, before, parent);
+        sibling = sibling.sibling;
+      }
+    }
+  }
+} // These are tracked on the stack as we recursively traverse a
+// deleted subtree.
+// TODO: Update these during the whole mutation phase, not just during
+// a deletion.
+
+
+let hostParent = null;
+let hostParentIsContainer = false;
+
+function commitDeletionEffects(root, returnFiber, deletedFiber) {
+  {
+    // We only have the top Fiber that was deleted but we need to recurse down its
+    // children to find all the terminal nodes.
+    // Recursively delete all host nodes from the parent, detach refs, clean
+    // up mounted layout effects, and call componentWillUnmount.
+    // We only need to remove the topmost host child in each branch. But then we
+    // still need to keep traversing to unmount effects, refs, and cWU. TODO: We
+    // could split this into two separate traversals functions, where the second
+    // one doesn't include any removeChild logic. This is maybe the same
+    // function as "disappearLayoutEffects" (or whatever that turns into after
+    // the layout phase is refactored to use recursion).
+    // Before starting, find the nearest host parent on the stack so we know
+    // which instance/container to remove the children from.
+    // TODO: Instead of searching up the fiber return path on every deletion, we
+    // can track the nearest host component on the JS stack as we traverse the
+    // tree during the commit phase. This would make insertions faster, too.
+    let parent = returnFiber;
+
+    findParent: while (parent !== null) {
+      switch (parent.tag) {
+        case HostSingleton:
+        case HostComponent:
+          {
+            hostParent = parent.stateNode;
+            hostParentIsContainer = false;
+            break findParent;
+          }
+
+        case HostRoot:
+          {
+            hostParent = parent.stateNode.containerInfo;
+            hostParentIsContainer = true;
+            break findParent;
+          }
+
+        case HostPortal:
+          {
+            hostParent = parent.stateNode.containerInfo;
+            hostParentIsContainer = true;
+            break findParent;
+          }
+      }
+
+      parent = parent.return;
+    }
+
+    if (hostParent === null) {
+      throw Error(formatProdErrorMessage(160));
+    }
+
+    commitDeletionEffectsOnFiber(root, returnFiber, deletedFiber);
+    hostParent = null;
+    hostParentIsContainer = false;
+  }
+
+  detachFiberMutation(deletedFiber);
+}
+
+function recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, parent) {
+  // TODO: Use a static flag to skip trees that don't have unmount effects
+  let child = parent.child;
+
+  while (child !== null) {
+    commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, child);
+    child = child.sibling;
+  }
+}
+
+function commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, deletedFiber) {
+  onCommitUnmount(deletedFiber); // The cases in this outer switch modify the stack before they traverse
+  // into their subtree. There are simpler cases in the inner switch
+  // that don't modify the stack.
+
+  switch (deletedFiber.tag) {
+    case HostHoistable:
+      {
+        {
+          if (!offscreenSubtreeWasHidden) {
+            safelyDetachRef(deletedFiber, nearestMountedAncestor);
+          }
+
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+
+          if (deletedFiber.memoizedState) {
+            releaseResource(deletedFiber.memoizedState);
+          } else if (deletedFiber.stateNode) {
+            unmountHoistable(deletedFiber.stateNode);
+          }
+
+          return;
+        } // Fall through
+
+      }
+
+    case HostSingleton:
+      {
+        {
+          if (!offscreenSubtreeWasHidden) {
+            safelyDetachRef(deletedFiber, nearestMountedAncestor);
+          }
+
+          const prevHostParent = hostParent;
+          const prevHostParentIsContainer = hostParentIsContainer;
+          hostParent = deletedFiber.stateNode;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber); // Normally this is called in passive unmount effect phase however with
+          // HostSingleton we warn if you acquire one that is already associated to
+          // a different fiber. To increase our chances of avoiding this, specifically
+          // if you keyed a HostSingleton so there will be a delete followed by a Placement
+          // we treat detach eagerly here
+
+          releaseSingletonInstance(deletedFiber.stateNode);
+          hostParent = prevHostParent;
+          hostParentIsContainer = prevHostParentIsContainer;
+          return;
+        } // Fall through
+
+      }
+
+    case HostComponent:
+      {
+        if (!offscreenSubtreeWasHidden) {
+          safelyDetachRef(deletedFiber, nearestMountedAncestor);
+        } // Intentional fallthrough to next branch
+
+      }
+
+    case HostText:
+      {
+        // We only need to remove the nearest host child. Set the host parent
+        // to `null` on the stack to indicate that nested children don't
+        // need to be removed.
+        {
+          const prevHostParent = hostParent;
+          const prevHostParentIsContainer = hostParentIsContainer;
+          hostParent = null;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          hostParent = prevHostParent;
+          hostParentIsContainer = prevHostParentIsContainer;
+
+          if (hostParent !== null) {
+            // Now that all the child effects have unmounted, we can remove the
+            // node from the tree.
+            if (hostParentIsContainer) {
+              removeChildFromContainer(hostParent, deletedFiber.stateNode);
+            } else {
+              removeChild(hostParent, deletedFiber.stateNode);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case DehydratedFragment:
+      {
+        // Delete the dehydrated suspense boundary and all of its content.
+
+
+        {
+          if (hostParent !== null) {
+            if (hostParentIsContainer) {
+              clearSuspenseBoundaryFromContainer(hostParent, deletedFiber.stateNode);
+            } else {
+              clearSuspenseBoundary(hostParent, deletedFiber.stateNode);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case HostPortal:
+      {
+        {
+          // When we go into a portal, it becomes the parent to remove from.
+          const prevHostParent = hostParent;
+          const prevHostParentIsContainer = hostParentIsContainer;
+          hostParent = deletedFiber.stateNode.containerInfo;
+          hostParentIsContainer = true;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          hostParent = prevHostParent;
+          hostParentIsContainer = prevHostParentIsContainer;
+        }
+
+        return;
+      }
+
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent:
+      {
+        if (!offscreenSubtreeWasHidden) {
+          const updateQueue = deletedFiber.updateQueue;
+
+          if (updateQueue !== null) {
+            const lastEffect = updateQueue.lastEffect;
+
+            if (lastEffect !== null) {
+              const firstEffect = lastEffect.next;
+              let effect = firstEffect;
+
+              do {
+                const tag = effect.tag;
+                const inst = effect.inst;
+                const destroy = inst.destroy;
+
+                if (destroy !== undefined) {
+                  if ((tag & Insertion) !== NoFlags) {
+                    inst.destroy = undefined;
+                    safelyCallDestroy(deletedFiber, nearestMountedAncestor, destroy);
+                  } else if ((tag & Layout) !== NoFlags) {
+
+                    {
+                      inst.destroy = undefined;
+                      safelyCallDestroy(deletedFiber, nearestMountedAncestor, destroy);
+                    }
+                  }
+                }
+
+                effect = effect.next;
+              } while (effect !== firstEffect);
+            }
+          }
+        }
+
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        return;
+      }
+
+    case ClassComponent:
+      {
+        if (!offscreenSubtreeWasHidden) {
+          safelyDetachRef(deletedFiber, nearestMountedAncestor);
+          const instance = deletedFiber.stateNode;
+
+          if (typeof instance.componentWillUnmount === 'function') {
+            safelyCallComponentWillUnmount(deletedFiber, nearestMountedAncestor, instance);
+          }
+        }
+
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        return;
+      }
+
+    case ScopeComponent:
+      {
+
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        return;
+      }
+
+    case OffscreenComponent:
+      {
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+
+        if (deletedFiber.mode & ConcurrentMode) {
+          // If this offscreen component is hidden, we already unmounted it. Before
+          // deleting the children, track that it's already unmounted so that we
+          // don't attempt to unmount the effects again.
+          // TODO: If the tree is hidden, in most cases we should be able to skip
+          // over the nested children entirely. An exception is we haven't yet found
+          // the topmost host node to delete, which we already track on the stack.
+          // But the other case is portals, which need to be detached no matter how
+          // deeply they are nested. We should use a subtree flag to track whether a
+          // subtree includes a nested portal.
+          const prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || deletedFiber.memoizedState !== null;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+        } else {
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        return;
+      }
+  }
+}
+
+function commitSuspenseCallback(finishedWork) {
+}
+
+function commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {
+
+  const newState = finishedWork.memoizedState;
+
+  if (newState === null) {
+    const current = finishedWork.alternate;
+
+    if (current !== null) {
+      const prevState = current.memoizedState;
+
+      if (prevState !== null) {
+        const suspenseInstance = prevState.dehydrated;
+
+        if (suspenseInstance !== null) {
+          try {
+            commitHydratedSuspenseInstance(suspenseInstance);
+
+            if (enableSuspenseCallback) ;
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      }
+    }
+  }
+}
+
+function getRetryCache(finishedWork) {
+  // TODO: Unify the interface for the retry cache so we don't have to switch
+  // on the tag like this.
+  switch (finishedWork.tag) {
+    case SuspenseComponent:
+    case SuspenseListComponent:
+      {
+        let retryCache = finishedWork.stateNode;
+
+        if (retryCache === null) {
+          retryCache = finishedWork.stateNode = new PossiblyWeakSet();
+        }
+
+        return retryCache;
+      }
+
+    case OffscreenComponent:
+      {
+        const instance = finishedWork.stateNode;
+        let retryCache = instance._retryCache;
+
+        if (retryCache === null) {
+          retryCache = instance._retryCache = new PossiblyWeakSet();
+        }
+
+        return retryCache;
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(435, finishedWork.tag));
+      }
+  }
+}
+
+function detachOffscreenInstance(instance) {
+  const fiber = instance._current;
+
+  if (fiber === null) {
+    throw Error(formatProdErrorMessage(456));
+  }
+
+  if ((instance._pendingVisibility & OffscreenDetached) !== NoFlags$1) {
+    // The instance is already detached, this is a noop.
+    return;
+  } // TODO: There is an opportunity to optimise this by not entering commit phase
+  // and unmounting effects directly.
+
+
+  const root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+  if (root !== null) {
+    instance._pendingVisibility |= OffscreenDetached;
+    scheduleUpdateOnFiber(root, fiber, SyncLane);
+  }
+}
+function attachOffscreenInstance(instance) {
+  const fiber = instance._current;
+
+  if (fiber === null) {
+    throw Error(formatProdErrorMessage(456));
+  }
+
+  if ((instance._pendingVisibility & OffscreenDetached) === NoFlags$1) {
+    // The instance is already attached, this is a noop.
+    return;
+  }
+
+  const root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+  if (root !== null) {
+    instance._pendingVisibility &= ~OffscreenDetached;
+    scheduleUpdateOnFiber(root, fiber, SyncLane);
+  }
+}
+
+function attachSuspenseRetryListeners(finishedWork, wakeables) {
+  // If this boundary just timed out, then it will have a set of wakeables.
+  // For each wakeable, attach a listener so that when it resolves, React
+  // attempts to re-render the boundary in the primary (pre-timeout) state.
+  const retryCache = getRetryCache(finishedWork);
+  wakeables.forEach(wakeable => {
+    // Memoize using the boundary fiber to prevent redundant listeners.
+    const retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
+
+    if (!retryCache.has(wakeable)) {
+      retryCache.add(wakeable);
+
+      wakeable.then(retry, retry);
+    }
+  });
+} // This function detects when a Suspense boundary goes from visible to hidden.
+function commitMutationEffects(root, finishedWork, committedLanes) {
+  commitMutationEffectsOnFiber(finishedWork, root);
+}
+
+function recursivelyTraverseMutationEffects(root, parentFiber, lanes) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects hae fired.
+  const deletions = parentFiber.deletions;
+
+  if (deletions !== null) {
+    for (let i = 0; i < deletions.length; i++) {
+      const childToDelete = deletions[i];
+
+      try {
+        commitDeletionEffects(root, parentFiber, childToDelete);
+      } catch (error) {
+        captureCommitPhaseError(childToDelete, parentFiber, error);
+      }
+    }
+  }
+
+  if (parentFiber.subtreeFlags & MutationMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      commitMutationEffectsOnFiber(child, root);
+      child = child.sibling;
+    }
+  }
+}
+
+let currentHoistableRoot = null;
+
+function commitMutationEffectsOnFiber(finishedWork, root, lanes) {
+  const current = finishedWork.alternate;
+  const flags = finishedWork.flags; // The effect flag should be checked *after* we refine the type of fiber,
+  // because the fiber tag is more specific. An exception is any flag related
+  // to reconciliation, because those can be set on all fiber types.
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Update) {
+          try {
+            commitHookEffectListUnmount(Insertion | HasEffect, finishedWork, finishedWork.return);
+            commitHookEffectListMount(Insertion | HasEffect, finishedWork);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          } // Layout effects are destroyed during the mutation phase so that all
+          // destroy functions for all fibers are called before any create functions.
+          // This prevents sibling component effects from interfering with each other,
+          // e.g. a destroy function in one component should never override a ref set
+          // by a create function in another component during the same commit.
+
+
+          {
+            try {
+              commitHookEffectListUnmount(Layout | HasEffect, finishedWork, finishedWork.return);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case ClassComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Ref) {
+          if (current !== null) {
+            safelyDetachRef(current, current.return);
+          }
+        }
+
+        if (flags & Callback && offscreenSubtreeIsHidden) {
+          const updateQueue = finishedWork.updateQueue;
+
+          if (updateQueue !== null) {
+            deferHiddenCallbacks(updateQueue);
+          }
+        }
+
+        return;
+      }
+
+    case HostHoistable:
+      {
+        {
+          // We cast because we always set the root at the React root and so it cannot be
+          // null while we are processing mutation effects
+          const hoistableRoot = currentHoistableRoot;
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+
+          if (flags & Ref) {
+            if (current !== null) {
+              safelyDetachRef(current, current.return);
+            }
+          }
+
+          if (flags & Update) {
+            const currentResource = current !== null ? current.memoizedState : null;
+            const newResource = finishedWork.memoizedState;
+
+            if (current === null) {
+              // We are mounting a new HostHoistable Fiber. We fork the mount
+              // behavior based on whether this instance is a Hoistable Instance
+              // or a Hoistable Resource
+              if (newResource === null) {
+                if (finishedWork.stateNode === null) {
+                  finishedWork.stateNode = hydrateHoistable(hoistableRoot, finishedWork.type, finishedWork.memoizedProps, finishedWork);
+                } else {
+                  mountHoistable(hoistableRoot, finishedWork.type, finishedWork.stateNode);
+                }
+              } else {
+                finishedWork.stateNode = acquireResource(hoistableRoot, newResource, finishedWork.memoizedProps);
+              }
+            } else if (currentResource !== newResource) {
+              // We are moving to or from Hoistable Resource, or between different Hoistable Resources
+              if (currentResource === null) {
+                if (current.stateNode !== null) {
+                  unmountHoistable(current.stateNode);
+                }
+              } else {
+                releaseResource(currentResource);
+              }
+
+              if (newResource === null) {
+                mountHoistable(hoistableRoot, finishedWork.type, finishedWork.stateNode);
+              } else {
+                acquireResource(hoistableRoot, newResource, finishedWork.memoizedProps);
+              }
+            } else if (newResource === null && finishedWork.stateNode !== null) {
+              // We may have an update on a Hoistable element
+              const updatePayload = finishedWork.updateQueue;
+              finishedWork.updateQueue = null;
+
+              try {
+                commitUpdate(finishedWork.stateNode, updatePayload, finishedWork.type, current.memoizedProps, finishedWork.memoizedProps, finishedWork);
+              } catch (error) {
+                captureCommitPhaseError(finishedWork, finishedWork.return, error);
+              }
+            }
+          }
+
+          return;
+        } // Fall through
+
+      }
+
+    case HostSingleton:
+      {
+        {
+          if (flags & Update) {
+            const previousWork = finishedWork.alternate;
+
+            if (previousWork === null) {
+              const singleton = finishedWork.stateNode;
+              const props = finishedWork.memoizedProps; // This was a new mount, we need to clear and set initial properties
+
+              clearSingleton(singleton);
+              acquireSingletonInstance(finishedWork.type, props, singleton, finishedWork);
+            }
+          }
+        } // Fall through
+
+      }
+
+    case HostComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Ref) {
+          if (current !== null) {
+            safelyDetachRef(current, current.return);
+          }
+        }
+
+        {
+          // TODO: ContentReset gets cleared by the children during the commit
+          // phase. This is a refactor hazard because it means we must read
+          // flags the flags after `commitReconciliationEffects` has already run;
+          // the order matters. We should refactor so that ContentReset does not
+          // rely on mutating the flag during commit. Like by setting a flag
+          // during the render phase instead.
+          if (finishedWork.flags & ContentReset) {
+            const instance = finishedWork.stateNode;
+
+            try {
+              resetTextContent(instance);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+
+          if (flags & Update) {
+            const instance = finishedWork.stateNode;
+
+            if (instance != null) {
+              // Commit the work prepared earlier.
+              const newProps = finishedWork.memoizedProps; // For hydration we reuse the update path but we treat the oldProps
+              // as the newProps. The updatePayload will contain the real change in
+              // this case.
+
+              const oldProps = current !== null ? current.memoizedProps : newProps;
+              const type = finishedWork.type; // TODO: Type the updateQueue to be specific to host components.
+
+              const updatePayload = finishedWork.updateQueue;
+              finishedWork.updateQueue = null;
+
+              try {
+                commitUpdate(instance, updatePayload, type, oldProps, newProps, finishedWork);
+              } catch (error) {
+                captureCommitPhaseError(finishedWork, finishedWork.return, error);
+              }
+            }
+          }
+        }
+
+        return;
+      }
+
+    case HostText:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Update) {
+          {
+            if (finishedWork.stateNode === null) {
+              throw Error(formatProdErrorMessage(162));
+            }
+
+            const textInstance = finishedWork.stateNode;
+            const newText = finishedWork.memoizedProps; // For hydration we reuse the update path but we treat the oldProps
+            // as the newProps. The updatePayload will contain the real change in
+            // this case.
+
+            const oldText = current !== null ? current.memoizedProps : newText;
+
+            try {
+              commitTextUpdate(textInstance, oldText, newText);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case HostRoot:
+      {
+        {
+          prepareToCommitHoistables();
+          const previousHoistableRoot = currentHoistableRoot;
+          currentHoistableRoot = getHoistableRoot(root.containerInfo);
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          currentHoistableRoot = previousHoistableRoot;
+          commitReconciliationEffects(finishedWork);
+        }
+
+        if (flags & Update) {
+          {
+            if (current !== null) {
+              const prevRootState = current.memoizedState;
+
+              if (prevRootState.isDehydrated) {
+                try {
+                  commitHydratedContainer(root.containerInfo);
+                } catch (error) {
+                  captureCommitPhaseError(finishedWork, finishedWork.return, error);
+                }
+              }
+            }
+          }
+        }
+
+        return;
+      }
+
+    case HostPortal:
+      {
+        {
+          const previousHoistableRoot = currentHoistableRoot;
+          currentHoistableRoot = getHoistableRoot(finishedWork.stateNode.containerInfo);
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          currentHoistableRoot = previousHoistableRoot;
+        }
+
+        return;
+      }
+
+    case SuspenseComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork); // TODO: We should mark a flag on the Suspense fiber itself, rather than
+        // relying on the Offscreen fiber having a flag also being marked. The
+        // reason is that this offscreen fiber might not be part of the work-in-
+        // progress tree! It could have been reused from a previous render. This
+        // doesn't lead to incorrect behavior because we don't rely on the flag
+        // check alone; we also compare the states explicitly below. But for
+        // modeling purposes, we _should_ be able to rely on the flag check alone.
+        // So this is a bit fragile.
+        //
+        // Also, all this logic could/should move to the passive phase so it
+        // doesn't block paint.
+
+        const offscreenFiber = finishedWork.child;
+
+        if (offscreenFiber.flags & Visibility) {
+          // Throttle the appearance and disappearance of Suspense fallbacks.
+          const isShowingFallback = finishedWork.memoizedState !== null;
+          const wasShowingFallback = current !== null && current.memoizedState !== null;
+
+          {
+            if (isShowingFallback !== wasShowingFallback) {
+              // A fallback is either appearing or disappearing.
+              markCommitTimeOfFallback();
+            }
+          }
+        }
+
+        if (flags & Update) {
+          try {
+            commitSuspenseCallback(finishedWork);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+
+          const retryQueue = finishedWork.updateQueue;
+
+          if (retryQueue !== null) {
+            finishedWork.updateQueue = null;
+            attachSuspenseRetryListeners(finishedWork, retryQueue);
+          }
+        }
+
+        return;
+      }
+
+    case OffscreenComponent:
+      {
+        if (flags & Ref) {
+          if (current !== null) {
+            safelyDetachRef(current, current.return);
+          }
+        }
+
+        const newState = finishedWork.memoizedState;
+        const isHidden = newState !== null;
+        const wasHidden = current !== null && current.memoizedState !== null;
+
+        if (finishedWork.mode & ConcurrentMode) {
+          // Before committing the children, track on the stack whether this
+          // offscreen subtree was already hidden, so that we don't unmount the
+          // effects again.
+          const prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
+          const prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden || isHidden;
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || wasHidden;
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+        } else {
+          recursivelyTraverseMutationEffects(root, finishedWork);
+        }
+
+        commitReconciliationEffects(finishedWork);
+        const offscreenInstance = finishedWork.stateNode; // TODO: Add explicit effect flag to set _current.
+
+        offscreenInstance._current = finishedWork; // Offscreen stores pending changes to visibility in `_pendingVisibility`. This is
+        // to support batching of `attach` and `detach` calls.
+
+        offscreenInstance._visibility &= ~OffscreenDetached;
+        offscreenInstance._visibility |= offscreenInstance._pendingVisibility & OffscreenDetached;
+
+        if (flags & Visibility) {
+          // Track the current state on the Offscreen instance so we can
+          // read it during an event
+          if (isHidden) {
+            offscreenInstance._visibility &= ~OffscreenVisible;
+          } else {
+            offscreenInstance._visibility |= OffscreenVisible;
+          }
+
+          if (isHidden) {
+            const isUpdate = current !== null;
+            const wasHiddenByAncestorOffscreen = offscreenSubtreeIsHidden || offscreenSubtreeWasHidden; // Only trigger disapper layout effects if:
+            //   - This is an update, not first mount.
+            //   - This Offscreen was not hidden before.
+            //   - Ancestor Offscreen was not hidden in previous commit.
+
+            if (isUpdate && !wasHidden && !wasHiddenByAncestorOffscreen) {
+              if ((finishedWork.mode & ConcurrentMode) !== NoMode) {
+                // Disappear the layout effects of all the children
+                recursivelyTraverseDisappearLayoutEffects(finishedWork);
+              }
+            }
+          } // Offscreen with manual mode manages visibility manually.
+
+
+          if (!isOffscreenManual(finishedWork)) {
+            // TODO: This needs to run whenever there's an insertion or update
+            // inside a hidden Offscreen tree.
+            hideOrUnhideAllChildren(finishedWork, isHidden);
+          }
+        } // TODO: Move to passive phase
+
+
+        if (flags & Update) {
+          const offscreenQueue = finishedWork.updateQueue;
+
+          if (offscreenQueue !== null) {
+            const retryQueue = offscreenQueue.retryQueue;
+
+            if (retryQueue !== null) {
+              offscreenQueue.retryQueue = null;
+              attachSuspenseRetryListeners(finishedWork, retryQueue);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case SuspenseListComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Update) {
+          const retryQueue = finishedWork.updateQueue;
+
+          if (retryQueue !== null) {
+            finishedWork.updateQueue = null;
+            attachSuspenseRetryListeners(finishedWork, retryQueue);
+          }
+        }
+
+        return;
+      }
+
+    case ScopeComponent:
+      {
+
+        return;
+      }
+
+    default:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        return;
+      }
+  }
+}
+
+function commitReconciliationEffects(finishedWork) {
+  // Placement effects (insertions, reorders) can be scheduled on any fiber
+  // type. They needs to happen after the children effects have fired, but
+  // before the effects on this fiber have fired.
+  const flags = finishedWork.flags;
+
+  if (flags & Placement) {
+    try {
+      commitPlacement(finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    } // Clear the "placement" from effect tag so that we know that this is
+    // inserted, before any life-cycles like componentDidMount gets called.
+    // TODO: findDOMNode doesn't rely on this any more but isMounted does
+    // and isMounted is deprecated anyway so we should be able to kill this.
+
+
+    finishedWork.flags &= ~Placement;
+  }
+
+  if (flags & Hydrating) {
+    finishedWork.flags &= ~Hydrating;
+  }
+}
+
+function commitLayoutEffects(finishedWork, root, committedLanes) {
+  const current = finishedWork.alternate;
+  commitLayoutEffectOnFiber(root, current, finishedWork);
+}
+
+function recursivelyTraverseLayoutEffects(root, parentFiber, lanes) {
+
+  if (parentFiber.subtreeFlags & LayoutMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      const current = child.alternate;
+      commitLayoutEffectOnFiber(root, current, child);
+      child = child.sibling;
+    }
+  }
+}
+
+function disappearLayoutEffects(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent:
+      {
+        // TODO (Offscreen) Check: flags & LayoutStatic
+        {
+          commitHookEffectListUnmount(Layout, finishedWork, finishedWork.return);
+        }
+
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      }
+
+    case ClassComponent:
+      {
+        // TODO (Offscreen) Check: flags & RefStatic
+        safelyDetachRef(finishedWork, finishedWork.return);
+        const instance = finishedWork.stateNode;
+
+        if (typeof instance.componentWillUnmount === 'function') {
+          safelyCallComponentWillUnmount(finishedWork, finishedWork.return, instance);
+        }
+
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      }
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      {
+        // TODO (Offscreen) Check: flags & RefStatic
+        safelyDetachRef(finishedWork, finishedWork.return);
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        // TODO (Offscreen) Check: flags & RefStatic
+        safelyDetachRef(finishedWork, finishedWork.return);
+        const isHidden = finishedWork.memoizedState !== null;
+
+        if (isHidden) ; else {
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
+  // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+  let child = parentFiber.child;
+
+  while (child !== null) {
+    disappearLayoutEffects(child);
+    child = child.sibling;
+  }
+}
+
+function reappearLayoutEffects(finishedRoot, current, finishedWork, // This function visits both newly finished work and nodes that were re-used
+// from a previously committed tree. We cannot check non-static flags if the
+// node was reused.
+includeWorkInProgressEffects) {
+  // Turn on layout effects in a tree that previously disappeared.
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // TODO: Check flags & LayoutStatic
+
+        commitHookLayoutEffects(finishedWork, Layout);
+        break;
+      }
+
+    case ClassComponent:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // TODO: Check for LayoutStatic flag
+
+        const instance = finishedWork.stateNode;
+
+        if (typeof instance.componentDidMount === 'function') {
+          try {
+            instance.componentDidMount();
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        } // Commit any callbacks that would have fired while the component
+        // was hidden.
+
+
+        const updateQueue = finishedWork.updateQueue;
+
+        if (updateQueue !== null) {
+          commitHiddenCallbacks(updateQueue, instance);
+        } // If this is newly finished work, check for setState callbacks
+
+
+        if (includeWorkInProgressEffects && flags & Callback) {
+          commitClassCallbacks(finishedWork);
+        } // TODO: Check flags & RefStatic
+
+
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      }
+    // Unlike commitLayoutEffectsOnFiber, we don't need to handle HostRoot
+    // because this function only visits nodes that are inside an
+    // Offscreen fiber.
+    // case HostRoot: {
+    //  ...
+    // }
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // Renderers may schedule work to be done after host components are mounted
+        // (eg DOM renderer may schedule auto-focus for inputs and form controls).
+        // These effects should only be committed when components are first mounted,
+        // aka when there is no current/alternate.
+
+        if (includeWorkInProgressEffects && current === null && flags & Update) {
+          commitHostComponentMount(finishedWork);
+        } // TODO: Check flags & Ref
+
+
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      }
+
+    case Profiler:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // TODO: Figure out how Profiler updates should work with Offscreen
+
+        break;
+      }
+
+    case SuspenseComponent:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // TODO: Figure out how Suspense hydration callbacks should work
+        // with Offscreen.
+
+        if (includeWorkInProgressEffects && flags & Update) {
+          commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
+        }
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const offscreenState = finishedWork.memoizedState;
+        const isHidden = offscreenState !== null;
+
+        if (isHidden) ; else {
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+        } // TODO: Check flags & Ref
+
+
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseReappearLayoutEffects(finishedRoot, parentFiber, includeWorkInProgressEffects) {
+  // This function visits both newly finished work and nodes that were re-used
+  // from a previously committed tree. We cannot check non-static flags if the
+  // node was reused.
+  const childShouldIncludeWorkInProgressEffects = includeWorkInProgressEffects && (parentFiber.subtreeFlags & LayoutMask) !== NoFlags$1; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+  let child = parentFiber.child;
+
+  while (child !== null) {
+    const current = child.alternate;
+    reappearLayoutEffects(finishedRoot, current, child, childShouldIncludeWorkInProgressEffects);
+    child = child.sibling;
+  }
+}
+
+function commitHookPassiveMountEffects(finishedWork, hookFlags) {
+  {
+    try {
+      commitHookEffectListMount(hookFlags, finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
+
+function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
+  {
+    let previousCache = null;
+
+    if (current !== null && current.memoizedState !== null && current.memoizedState.cachePool !== null) {
+      previousCache = current.memoizedState.cachePool.pool;
+    }
+
+    let nextCache = null;
+
+    if (finishedWork.memoizedState !== null && finishedWork.memoizedState.cachePool !== null) {
+      nextCache = finishedWork.memoizedState.cachePool.pool;
+    } // Retain/release the cache used for pending (suspended) nodes.
+    // Note that this is only reached in the non-suspended/visible case:
+    // when the content is suspended/hidden, the retain/release occurs
+    // via the parent Suspense component (see case above).
+
+
+    if (nextCache !== previousCache) {
+      if (nextCache != null) {
+        retainCache(nextCache);
+      }
+
+      if (previousCache != null) {
+        releaseCache(previousCache);
+      }
+    }
+  }
+}
+
+function commitCachePassiveMountEffect(current, finishedWork) {
+  {
+    let previousCache = null;
+
+    if (finishedWork.alternate !== null) {
+      previousCache = finishedWork.alternate.memoizedState.cache;
+    }
+
+    const nextCache = finishedWork.memoizedState.cache; // Retain/release the cache. In theory the cache component
+    // could be "borrowing" a cache instance owned by some parent,
+    // in which case we could avoid retaining/releasing. But it
+    // is non-trivial to determine when that is the case, so we
+    // always retain/release.
+
+    if (nextCache !== previousCache) {
+      retainCache(nextCache);
+
+      if (previousCache != null) {
+        releaseCache(previousCache);
+      }
+    }
+  }
+}
+
+function commitPassiveMountEffects(root, finishedWork, committedLanes, committedTransitions) {
+  commitPassiveMountOnFiber(root, finishedWork, committedLanes, committedTransitions);
+}
+
+function recursivelyTraversePassiveMountEffects(root, parentFiber, committedLanes, committedTransitions) {
+
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      commitPassiveMountOnFiber(root, child, committedLanes, committedTransitions);
+      child = child.sibling;
+    }
+  }
+}
+
+function commitPassiveMountOnFiber(finishedRoot, finishedWork, committedLanes, committedTransitions) {
+  // When updating this function, also update reconnectPassiveEffects, which does
+  // most of the same things when an offscreen tree goes from hidden -> visible,
+  // or when toggling effects inside a hidden tree.
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+
+        if (flags & Passive$1) {
+          commitHookPassiveMountEffects(finishedWork, Passive | HasEffect);
+        }
+
+        break;
+      }
+
+    case HostRoot:
+      {
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+
+        if (flags & Passive$1) {
+          {
+            let previousCache = null;
+
+            if (finishedWork.alternate !== null) {
+              previousCache = finishedWork.alternate.memoizedState.cache;
+            }
+
+            const nextCache = finishedWork.memoizedState.cache; // Retain/release the root cache.
+            // Note that on initial mount, previousCache and nextCache will be the same
+            // and this retain won't occur. To counter this, we instead retain the HostRoot's
+            // initial cache when creating the root itself (see createFiberRoot() in
+            // ReactFiberRoot.js). Subsequent updates that change the cache are reflected
+            // here, such that previous/next caches are retained correctly.
+
+            if (nextCache !== previousCache) {
+              retainCache(nextCache);
+
+              if (previousCache != null) {
+                releaseCache(previousCache);
+              }
+            }
+          }
+        }
+
+        break;
+      }
+
+    case LegacyHiddenComponent:
+      {
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        // TODO: Pass `current` as argument to this function
+        const instance = finishedWork.stateNode;
+        const nextState = finishedWork.memoizedState;
+        const isHidden = nextState !== null;
+
+        if (isHidden) {
+          if (instance._visibility & OffscreenPassiveEffectsConnected) {
+            // The effects are currently connected. Update them.
+            recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          } else {
+            if (finishedWork.mode & ConcurrentMode) {
+              // The effects are currently disconnected. Since the tree is hidden,
+              // don't connect them. This also applies to the initial render.
+              {
+                // "Atomic" effects are ones that need to fire on every commit,
+                // even during pre-rendering. An example is updating the reference
+                // count on cache instances.
+                recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+              }
+            } else {
+              // Legacy Mode: Fire the effects even if the tree is hidden.
+              instance._visibility |= OffscreenPassiveEffectsConnected;
+              recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+            }
+          }
+        } else {
+          // Tree is visible
+          if (instance._visibility & OffscreenPassiveEffectsConnected) {
+            // The effects are currently connected. Update them.
+            recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          } else {
+            // The effects are currently disconnected. Reconnect them, while also
+            // firing effects inside newly mounted trees. This also applies to
+            // the initial render.
+            instance._visibility |= OffscreenPassiveEffectsConnected;
+            const includeWorkInProgressEffects = (finishedWork.subtreeFlags & PassiveMask) !== NoFlags$1;
+            recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+          }
+        }
+
+        if (flags & Passive$1) {
+          const current = finishedWork.alternate;
+          commitOffscreenPassiveMountEffects(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+
+        if (flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitCachePassiveMountEffect(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case TracingMarkerComponent:
+
+    default:
+      {
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseReconnectPassiveEffects(finishedRoot, parentFiber, committedLanes, committedTransitions, includeWorkInProgressEffects) {
+  // This function visits both newly finished work and nodes that were re-used
+  // from a previously committed tree. We cannot check non-static flags if the
+  // node was reused.
+  const childShouldIncludeWorkInProgressEffects = includeWorkInProgressEffects && (parentFiber.subtreeFlags & PassiveMask) !== NoFlags$1; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+  let child = parentFiber.child;
+
+  while (child !== null) {
+    reconnectPassiveEffects(finishedRoot, child, committedLanes, committedTransitions, childShouldIncludeWorkInProgressEffects);
+    child = child.sibling;
+  }
+}
+
+function reconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, // This function visits both newly finished work and nodes that were re-used
+// from a previously committed tree. We cannot check non-static flags if the
+// node was reused.
+includeWorkInProgressEffects) {
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects); // TODO: Check for PassiveStatic flag
+
+        commitHookPassiveMountEffects(finishedWork, Passive);
+        break;
+      }
+    // Unlike commitPassiveMountOnFiber, we don't need to handle HostRoot
+    // because this function only visits nodes that are inside an
+    // Offscreen fiber.
+    // case HostRoot: {
+    //  ...
+    // }
+
+    case LegacyHiddenComponent:
+      {
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const instance = finishedWork.stateNode;
+        const nextState = finishedWork.memoizedState;
+        const isHidden = nextState !== null;
+
+        if (isHidden) {
+          if (instance._visibility & OffscreenPassiveEffectsConnected) {
+            // The effects are currently connected. Update them.
+            recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+          } else {
+            if (finishedWork.mode & ConcurrentMode) {
+              // The effects are currently disconnected. Since the tree is hidden,
+              // don't connect them. This also applies to the initial render.
+              {
+                // "Atomic" effects are ones that need to fire on every commit,
+                // even during pre-rendering. An example is updating the reference
+                // count on cache instances.
+                recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+              }
+            } else {
+              // Legacy Mode: Fire the effects even if the tree is hidden.
+              instance._visibility |= OffscreenPassiveEffectsConnected;
+              recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+            }
+          }
+        } else {
+          // Tree is visible
+          // Since we're already inside a reconnecting tree, it doesn't matter
+          // whether the effects are currently connected. In either case, we'll
+          // continue traversing the tree and firing all the effects.
+          //
+          // We do need to set the "connected" flag on the instance, though.
+          instance._visibility |= OffscreenPassiveEffectsConnected;
+          recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+        }
+
+        if (includeWorkInProgressEffects && flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitOffscreenPassiveMountEffects(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+
+        if (includeWorkInProgressEffects && flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitCachePassiveMountEffect(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case TracingMarkerComponent:
+
+    default:
+      {
+        recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseAtomicPassiveEffects(finishedRoot, parentFiber, committedLanes, committedTransitions) {
+
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      commitAtomicPassiveEffects(finishedRoot, child);
+      child = child.sibling;
+    }
+  }
+}
+
+function commitAtomicPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions) {
+  // "Atomic" effects are ones that need to fire on every commit, even during
+  // pre-rendering. We call this function when traversing a hidden tree whose
+  // regular effects are currently disconnected.
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case OffscreenComponent:
+      {
+        recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+
+        if (flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitOffscreenPassiveMountEffects(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+
+        if (flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitCachePassiveMountEffect(current, finishedWork);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+        break;
+      }
+  }
+}
+
+function commitPassiveUnmountEffects(finishedWork) {
+  commitPassiveUnmountOnFiber(finishedWork);
+} // If we're inside a brand new tree, or a tree that was already visible, then we
+// should only suspend host components that have a ShouldSuspendCommit flag.
+// Components without it haven't changed since the last commit, so we can skip
+// over those.
+//
+// When we enter a tree that is being revealed (going from hidden -> visible),
+// we need to suspend _any_ component that _may_ suspend. Even if they're
+// already in the "current" tree. Because their visibility has changed, the
+// browser may not have prerendered them yet. So we check the MaySuspendCommit
+// flag instead.
+
+let suspenseyCommitFlag = ShouldSuspendCommit;
+function accumulateSuspenseyCommit(finishedWork) {
+  accumulateSuspenseyCommitOnFiber(finishedWork);
+}
+
+function recursivelyAccumulateSuspenseyCommit(parentFiber) {
+  if (parentFiber.subtreeFlags & suspenseyCommitFlag) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      accumulateSuspenseyCommitOnFiber(child);
+      child = child.sibling;
+    }
+  }
+}
+
+function accumulateSuspenseyCommitOnFiber(fiber) {
+  switch (fiber.tag) {
+    case HostHoistable:
+      {
+        recursivelyAccumulateSuspenseyCommit(fiber);
+
+        if (fiber.flags & suspenseyCommitFlag) {
+          if (fiber.memoizedState !== null) {
+            suspendResource( // This should always be set by visiting HostRoot first
+            currentHoistableRoot, fiber.memoizedState, fiber.memoizedProps);
+          }
+        }
+
+        break;
+      }
+
+    case HostComponent:
+      {
+        recursivelyAccumulateSuspenseyCommit(fiber);
+
+        break;
+      }
+
+    case HostRoot:
+    case HostPortal:
+      {
+        {
+          const previousHoistableRoot = currentHoistableRoot;
+          const container = fiber.stateNode.containerInfo;
+          currentHoistableRoot = getHoistableRoot(container);
+          recursivelyAccumulateSuspenseyCommit(fiber);
+          currentHoistableRoot = previousHoistableRoot;
+        }
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const isHidden = fiber.memoizedState !== null;
+
+        if (isHidden) ; else {
+          const current = fiber.alternate;
+          const wasHidden = current !== null && current.memoizedState !== null;
+
+          if (wasHidden) {
+            // This tree is being revealed. Visit all newly visible suspensey
+            // instances, even if they're in the current tree.
+            const prevFlags = suspenseyCommitFlag;
+            suspenseyCommitFlag = MaySuspendCommit;
+            recursivelyAccumulateSuspenseyCommit(fiber);
+            suspenseyCommitFlag = prevFlags;
+          } else {
+            recursivelyAccumulateSuspenseyCommit(fiber);
+          }
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyAccumulateSuspenseyCommit(fiber);
+      }
+  }
+}
+
+function detachAlternateSiblings(parentFiber) {
+  // A fiber was deleted from this parent fiber, but it's still part of the
+  // previous (alternate) parent fiber's list of children. Because children
+  // are a linked list, an earlier sibling that's still alive will be
+  // connected to the deleted fiber via its `alternate`:
+  //
+  //   live fiber --alternate--> previous live fiber --sibling--> deleted
+  //   fiber
+  //
+  // We can't disconnect `alternate` on nodes that haven't been deleted yet,
+  // but we can disconnect the `sibling` and `child` pointers.
+  const previousFiber = parentFiber.alternate;
+
+  if (previousFiber !== null) {
+    let detachedChild = previousFiber.child;
+
+    if (detachedChild !== null) {
+      previousFiber.child = null;
+
+      do {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        const detachedSibling = detachedChild.sibling; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+        detachedChild.sibling = null;
+        detachedChild = detachedSibling;
+      } while (detachedChild !== null);
+    }
+  }
+}
+
+function commitHookPassiveUnmountEffects(finishedWork, nearestMountedAncestor, hookFlags) {
+  {
+    commitHookEffectListUnmount(hookFlags, finishedWork, nearestMountedAncestor);
+  }
+}
+
+function recursivelyTraversePassiveUnmountEffects(parentFiber) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects have fired.
+  const deletions = parentFiber.deletions;
+
+  if ((parentFiber.flags & ChildDeletion) !== NoFlags$1) {
+    if (deletions !== null) {
+      for (let i = 0; i < deletions.length; i++) {
+        const childToDelete = deletions[i]; // TODO: Convert this to use recursion
+
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(childToDelete, parentFiber);
+      }
+    }
+
+    detachAlternateSiblings(parentFiber);
+  }
+
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      commitPassiveUnmountOnFiber(child);
+      child = child.sibling;
+    }
+  }
+}
+
+function commitPassiveUnmountOnFiber(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraversePassiveUnmountEffects(finishedWork);
+
+        if (finishedWork.flags & Passive$1) {
+          commitHookPassiveUnmountEffects(finishedWork, finishedWork.return, Passive | HasEffect);
+        }
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const instance = finishedWork.stateNode;
+        const nextState = finishedWork.memoizedState;
+        const isHidden = nextState !== null;
+
+        if (isHidden && instance._visibility & OffscreenPassiveEffectsConnected && ( // For backwards compatibility, don't unmount when a tree suspends. In
+        // the future we may change this to unmount after a delay.
+        finishedWork.return === null || finishedWork.return.tag !== SuspenseComponent)) {
+          // The effects are currently connected. Disconnect them.
+          // TODO: Add option or heuristic to delay before disconnecting the
+          // effects. Then if the tree reappears before the delay has elapsed, we
+          // can skip toggling the effects entirely.
+          instance._visibility &= ~OffscreenPassiveEffectsConnected;
+          recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+        } else {
+          recursivelyTraversePassiveUnmountEffects(finishedWork);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraversePassiveUnmountEffects(finishedWork);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects have fired.
+  const deletions = parentFiber.deletions;
+
+  if ((parentFiber.flags & ChildDeletion) !== NoFlags$1) {
+    if (deletions !== null) {
+      for (let i = 0; i < deletions.length; i++) {
+        const childToDelete = deletions[i]; // TODO: Convert this to use recursion
+
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(childToDelete, parentFiber);
+      }
+    }
+
+    detachAlternateSiblings(parentFiber);
+  }
+
+  let child = parentFiber.child;
+
+  while (child !== null) {
+    disconnectPassiveEffect(child);
+    child = child.sibling;
+  }
+}
+
+function disconnectPassiveEffect(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        // TODO: Check PassiveStatic flag
+        commitHookPassiveUnmountEffects(finishedWork, finishedWork.return, Passive); // When disconnecting passive effects, we fire the effects in the same
+        // order as during a deletiong: parent before child
+
+        recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const instance = finishedWork.stateNode;
+
+        if (instance._visibility & OffscreenPassiveEffectsConnected) {
+          instance._visibility &= ~OffscreenPassiveEffectsConnected;
+          recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+        break;
+      }
+  }
+}
+
+function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(deletedSubtreeRoot, nearestMountedAncestor) {
+  while (nextEffect !== null) {
+    const fiber = nextEffect; // Deletion effects fire in parent -> child order
+    commitPassiveUnmountInsideDeletedTreeOnFiber(fiber, nearestMountedAncestor);
+    const child = fiber.child; // TODO: Only traverse subtree if it has a PassiveStatic flag.
+
+    if (child !== null) {
+      child.return = fiber;
+      nextEffect = child;
+    } else {
+      commitPassiveUnmountEffectsInsideOfDeletedTree_complete(deletedSubtreeRoot);
+    }
+  }
+}
+
+function commitPassiveUnmountEffectsInsideOfDeletedTree_complete(deletedSubtreeRoot) {
+  while (nextEffect !== null) {
+    const fiber = nextEffect;
+    const sibling = fiber.sibling;
+    const returnFiber = fiber.return; // Recursively traverse the entire deleted tree and clean up fiber fields.
+    // This is more aggressive than ideal, and the long term goal is to only
+    // have to detach the deleted tree at the root.
+
+    detachFiberAfterEffects(fiber);
+
+    if (fiber === deletedSubtreeRoot) {
+      nextEffect = null;
+      return;
+    }
+
+    if (sibling !== null) {
+      sibling.return = returnFiber;
+      nextEffect = sibling;
+      return;
+    }
+
+    nextEffect = returnFiber;
+  }
+}
+
+function commitPassiveUnmountInsideDeletedTreeOnFiber(current, nearestMountedAncestor) {
+  switch (current.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        commitHookPassiveUnmountEffects(current, nearestMountedAncestor, Passive);
+        break;
+      }
+    // TODO: run passive unmount effects when unmounting a root.
+    // Because passive unmount effects are not currently run,
+    // the cache instance owned by the root will never be freed.
+    // When effects are run, the cache should be freed here:
+    // case HostRoot: {
+    //   if (enableCache) {
+    //     const cache = current.memoizedState.cache;
+    //     releaseCache(cache);
+    //   }
+    //   break;
+    // }
+
+    case LegacyHiddenComponent:
+    case OffscreenComponent:
+      {
+        {
+          if (current.memoizedState !== null && current.memoizedState.cachePool !== null) {
+            const cache = current.memoizedState.cachePool.pool; // Retain/release the cache used for pending (suspended) nodes.
+            // Note that this is only reached in the non-suspended/visible case:
+            // when the content is suspended/hidden, the retain/release occurs
+            // via the parent Suspense component (see case above).
+
+            if (cache != null) {
+              retainCache(cache);
+            }
+          }
+        }
+
+        break;
+      }
+
+    case SuspenseComponent:
+      {
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        {
+          const cache = current.memoizedState.cache;
+          releaseCache(cache);
+        }
+
+        break;
+      }
+  }
+}
+
+function getCacheSignal() {
+
+  const cache = readContext(CacheContext);
+  return cache.controller.signal;
+}
+
+function getCacheForType(resourceType) {
+
+  const cache = readContext(CacheContext);
+  let cacheForType = cache.data.get(resourceType);
+
+  if (cacheForType === undefined) {
+    cacheForType = resourceType();
+    cache.data.set(resourceType, cacheForType);
+  }
+
+  return cacheForType;
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal,
+  getCacheForType
+};
+
+const PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
+      ReactCurrentCache = ReactSharedInternals.ReactCurrentCache,
+      ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner,
+      ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig,
+      ReactCurrentActQueue = ReactSharedInternals.ReactCurrentActQueue;
+const NoContext =
+/*             */
+0b000;
+const BatchedContext =
+/*               */
+0b001;
+const RenderContext =
+/*         */
+0b010;
+const CommitContext =
+/*         */
+0b100;
+const RootInProgress = 0;
+const RootFatalErrored = 1;
+const RootErrored = 2;
+const RootSuspended = 3;
+const RootSuspendedWithDelay = 4;
+const RootCompleted = 5;
+const RootDidNotComplete = 6; // Describes where we are in the React execution stack
+
+let executionContext = NoContext; // The root we're working on
+
+let workInProgressRoot = null; // The fiber we're working on
+
+let workInProgress = null; // The lanes we're rendering
+
+let workInProgressRootRenderLanes = NoLanes;
+const NotSuspended = 0;
+const SuspendedOnError = 1;
+const SuspendedOnData = 2;
+const SuspendedOnImmediate = 3;
+const SuspendedOnInstance = 4;
+const SuspendedOnInstanceAndReadyToContinue = 5;
+const SuspendedOnDeprecatedThrowPromise = 6;
+const SuspendedAndReadyToContinue = 7;
+const SuspendedOnHydration = 8; // When this is true, the work-in-progress fiber just suspended (or errored) and
+// we've yet to unwind the stack. In some cases, we may yield to the main thread
+// after this happens. If the fiber is pinged before we resume, we can retry
+// immediately instead of unwinding the stack.
+
+let workInProgressSuspendedReason = NotSuspended;
+let workInProgressThrownValue = null; // Whether a ping listener was attached during this render. This is slightly
+// different that whether something suspended, because we don't add multiple
+// listeners to a promise we've already seen (per root and lane).
+
+let workInProgressRootDidAttachPingListener = false; // A contextual version of workInProgressRootRenderLanes. It is a superset of
+// the lanes that we started working on at the root. When we enter a subtree
+// that is currently hidden, we add the lanes that would have committed if
+// the hidden tree hadn't been deferred. This is modified by the
+// HiddenContext module.
+//
+// Most things in the work loop should deal with workInProgressRootRenderLanes.
+// Most things in begin/complete phases should deal with entangledRenderLanes.
+
+let entangledRenderLanes = NoLanes; // Whether to root completed, errored, suspended, etc.
+
+let workInProgressRootExitStatus = RootInProgress; // A fatal error, if one is thrown
+
+let workInProgressRootFatalError = null; // The work left over by components that were visited during this render. Only
+// includes unprocessed updates, not work in bailed out children.
+
+let workInProgressRootSkippedLanes = NoLanes; // Lanes that were updated (in an interleaved event) during this render.
+
+let workInProgressRootInterleavedUpdatedLanes = NoLanes; // Lanes that were updated during the render phase (*not* an interleaved event).
+
+let workInProgressRootPingedLanes = NoLanes; // If this lane scheduled deferred work, this is the lane of the deferred task.
+
+let workInProgressDeferredLane = NoLane; // Errors that are thrown during the render phase.
+
+let workInProgressRootConcurrentErrors = null; // These are errors that we recovered from without surfacing them to the UI.
+// We will log them once the tree commits.
+
+let workInProgressRootRecoverableErrors = null; // The most recent time we either committed a fallback, or when a fallback was
+// filled in with the resolved UI. This lets us throttle the appearance of new
+// content as it streams in, to minimize jank.
+// TODO: Think of a better name for this variable?
+
+let globalMostRecentFallbackTime = 0;
+const FALLBACK_THROTTLE_MS = 300; // The absolute time for when we should start giving up on rendering
+// more and prefer CPU suspense heuristics instead.
+
+let workInProgressRootRenderTargetTime = Infinity; // How long a render is supposed to take before we start following CPU
+// suspense heuristics and opt out of rendering more content.
+
+const RENDER_TIMEOUT_MS = 500;
+let workInProgressTransitions = null;
+
+function resetRenderTimer() {
+  workInProgressRootRenderTargetTime = now() + RENDER_TIMEOUT_MS;
+}
+
+function getRenderTargetTime() {
+  return workInProgressRootRenderTargetTime;
+}
+let hasUncaughtError = false;
+let firstUncaughtError = null;
+let legacyErrorBoundariesThatAlreadyFailed = null; // Only used when enableProfilerNestedUpdateScheduledHook is true;
+let rootDoesHavePassiveEffects = false;
+let rootWithPendingPassiveEffects = null;
+let pendingPassiveEffectsLanes = NoLanes;
+let pendingPassiveEffectsRemainingLanes = NoLanes;
+let pendingPassiveTransitions = null; // Use these to prevent an infinite loop of nested updates
+
+const NESTED_UPDATE_LIMIT = 50;
+let nestedUpdateCount = 0;
+let rootWithNestedUpdates = null;
+function getWorkInProgressRoot() {
+  return workInProgressRoot;
+}
+function getWorkInProgressRootRenderLanes() {
+  return workInProgressRootRenderLanes;
+}
+function isWorkLoopSuspendedOnData() {
+  return workInProgressSuspendedReason === SuspendedOnData;
+}
+function requestUpdateLane(fiber) {
+  // Special cases
+  const mode = fiber.mode;
+
+  if ((mode & ConcurrentMode) === NoMode) {
+    return SyncLane;
+  } else if ((executionContext & RenderContext) !== NoContext && workInProgressRootRenderLanes !== NoLanes) {
+    // This is a render phase update. These are not officially supported. The
+    // old behavior is to give this the same "thread" (lanes) as
+    // whatever is currently rendering. So if you call `setState` on a component
+    // that happens later in the same render, it will flush. Ideally, we want to
+    // remove the special case and treat them as if they came from an
+    // interleaved event. Regardless, this pattern is not officially supported.
+    // This behavior is only a fallback. The flag only exists until we can roll
+    // out the setState warning, since existing code might accidentally rely on
+    // the current behavior.
+    return pickArbitraryLane(workInProgressRootRenderLanes);
+  }
+
+  const isTransition = requestCurrentTransition() !== NoTransition;
+
+  if (isTransition) {
+
+    const actionScopeLane = peekEntangledActionLane();
+    return actionScopeLane !== NoLane ? // We're inside an async action scope. Reuse the same lane.
+    actionScopeLane : // We may or may not be inside an async action scope. If we are, this
+    // is the first update in that scope. Either way, we need to get a
+    // fresh transition lane.
+    requestTransitionLane();
+  } // Updates originating inside certain React methods, like flushSync, have
+  // their priority set by tracking it with a context variable.
+  //
+  // The opaque type returned by the host config is internally a lane, so we can
+  // use that directly.
+  // TODO: Move this type conversion to the event priority module.
+
+
+  const updateLane = getCurrentUpdatePriority();
+
+  if (updateLane !== NoLane) {
+    return updateLane;
+  } // This update originated outside React. Ask the host environment for an
+  // appropriate priority, based on the type of event.
+  //
+  // The opaque type returned by the host config is internally a lane, so we can
+  // use that directly.
+  // TODO: Move this type conversion to the event priority module.
+
+
+  const eventLane = getCurrentEventPriority();
+  return eventLane;
+}
+
+function requestRetryLane(fiber) {
+  // This is a fork of `requestUpdateLane` designed specifically for Suspense
+  // "retries" — a special update that attempts to flip a Suspense boundary
+  // from its placeholder state to its primary/resolved state.
+  // Special cases
+  const mode = fiber.mode;
+
+  if ((mode & ConcurrentMode) === NoMode) {
+    return SyncLane;
+  }
+
+  return claimNextRetryLane();
+}
+
+function requestDeferredLane() {
+  if (workInProgressDeferredLane === NoLane) {
+    // If there are multiple useDeferredValue hooks in the same render, the
+    // tasks that they spawn should all be batched together, so they should all
+    // receive the same lane.
+    // Check the priority of the current render to decide the priority of the
+    // deferred task.
+    // OffscreenLane is used for prerendering, but we also use OffscreenLane
+    // for incremental hydration. It's given the lowest priority because the
+    // initial HTML is the same as the final UI. But useDeferredValue during
+    // hydration is an exception — we need to upgrade the UI to the final
+    // value. So if we're currently hydrating, we treat it like a transition.
+    const isPrerendering = includesSomeLane(workInProgressRootRenderLanes, OffscreenLane) && !getIsHydrating();
+
+    if (isPrerendering) {
+      // There's only one OffscreenLane, so if it contains deferred work, we
+      // should just reschedule using the same lane.
+      workInProgressDeferredLane = OffscreenLane;
+    } else {
+      // Everything else is spawned as a transition.
+      workInProgressDeferredLane = requestTransitionLane();
+    }
+  }
+
+  return workInProgressDeferredLane;
+}
+function scheduleUpdateOnFiber(root, fiber, lane) {
+  // finish loading.
+
+
+  if ( // Suspended render phase
+  root === workInProgressRoot && workInProgressSuspendedReason === SuspendedOnData || // Suspended commit phase
+  root.cancelPendingCommit !== null) {
+    // The incoming update might unblock the current render. Interrupt the
+    // current attempt and restart from the top.
+    prepareFreshStack(root, NoLanes);
+    markRootSuspended(root, workInProgressRootRenderLanes, workInProgressDeferredLane);
+  } // Mark that the root has a pending update.
+
+
+  markRootUpdated(root, lane);
+
+  if ((executionContext & RenderContext) !== NoLanes && root === workInProgressRoot) ; else {
+
+    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.
+      if ((executionContext & RenderContext) === NoContext) {
+        workInProgressRootInterleavedUpdatedLanes = mergeLanes(workInProgressRootInterleavedUpdatedLanes, lane);
+      }
+
+      if (workInProgressRootExitStatus === RootSuspendedWithDelay) {
+        // The root already suspended with a delay, which means this render
+        // definitely won't finish. Since we have a new update, let's mark it as
+        // suspended now, right before marking the incoming update. This has the
+        // effect of interrupting the current render and switching to the update.
+        // TODO: Make sure this doesn't override pings that happen while we've
+        // already started rendering.
+        markRootSuspended(root, workInProgressRootRenderLanes, workInProgressDeferredLane);
+      }
+    }
+
+    ensureRootIsScheduled(root);
+
+    if (lane === SyncLane && executionContext === NoContext && (fiber.mode & ConcurrentMode) === NoMode) {
+      {
+        // Flush the synchronous work now, unless we're already working or inside
+        // a batch. This is intentionally inside scheduleUpdateOnFiber instead of
+        // scheduleCallbackForFiber to preserve the ability to schedule a callback
+        // without immediately flushing it. We only do this for user-initiated
+        // updates, to preserve historical behavior of legacy mode.
+        resetRenderTimer();
+        flushSyncWorkOnLegacyRootsOnly();
+      }
+    }
+  }
+}
+function scheduleInitialHydrationOnRoot(root, lane) {
+  // This is a special fork of scheduleUpdateOnFiber that is only used to
+  // schedule the initial hydration of a root that has just been created. Most
+  // of the stuff in scheduleUpdateOnFiber can be skipped.
+  //
+  // The main reason for this separate path, though, is to distinguish the
+  // initial children from subsequent updates. In fully client-rendered roots
+  // (createRoot instead of hydrateRoot), all top-level renders are modeled as
+  // updates, but hydration roots are special because the initial render must
+  // match what was rendered on the server.
+  const current = root.current;
+  current.lanes = lane;
+  markRootUpdated(root, lane);
+  ensureRootIsScheduled(root);
+}
+function isUnsafeClassRenderPhaseUpdate(fiber) {
+  // Check if this is a render phase update. Only called by class components,
+  // which special (deprecated) behavior for UNSAFE_componentWillReceive props.
+  return (executionContext & RenderContext) !== NoContext;
+} // This is the entry point for every concurrent task, i.e. anything that
+// goes through Scheduler.
+
+function performConcurrentWorkOnRoot(root, didTimeout) {
+
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw Error(formatProdErrorMessage(327));
+  } // Flush any pending passive effects before deciding which lanes to work on,
+  // in case they schedule additional work.
+
+
+  const originalCallbackNode = root.callbackNode;
+  const didFlushPassiveEffects = flushPassiveEffects();
+
+  if (didFlushPassiveEffects) {
+    // Something in the passive effect phase may have canceled the current task.
+    // Check if the task node for this root was changed.
+    if (root.callbackNode !== originalCallbackNode) {
+      // The current task was canceled. Exit. We don't need to call
+      // `ensureRootIsScheduled` because the check above implies either that
+      // there's a new task, or that there's no remaining work on this root.
+      return null;
+    }
+  } // Determine the next lanes to work on, using the fields stored
+  // on the root.
+  // TODO: This was already computed in the caller. Pass it as an argument.
+
+
+  let lanes = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes);
+
+  if (lanes === NoLanes) {
+    // Defensive coding. This is never expected to happen.
+    return null;
+  } // We disable time-slicing in some cases: if the work has been CPU-bound
+  // for too long ("expired" work, to prevent starvation), or we're in
+  // sync-updates-by-default mode.
+  // TODO: We only check `didTimeout` defensively, to account for a Scheduler
+  // bug we're still investigating. Once the bug in Scheduler is fixed,
+  // we can remove this, since we track expiration ourselves.
+
+
+  const shouldTimeSlice = !includesBlockingLane(root, lanes) && !includesExpiredLane(root, lanes) && (!didTimeout);
+  let exitStatus = shouldTimeSlice ? renderRootConcurrent(root, lanes) : renderRootSync(root, lanes);
+
+  if (exitStatus !== RootInProgress) {
+    let renderWasConcurrent = shouldTimeSlice;
+
+    do {
+      if (exitStatus === RootDidNotComplete) {
+        // The render unwound without completing the tree. This happens in special
+        // cases where need to exit the current render without producing a
+        // consistent tree or committing.
+        markRootSuspended(root, lanes, NoLane);
+      } else {
+        // The render completed.
+        // Check if this render may have yielded to a concurrent event, and if so,
+        // confirm that any newly rendered stores are consistent.
+        // TODO: It's possible that even a concurrent render may never have yielded
+        // to the main thread, if it was fast enough, or if it expired. We could
+        // skip the consistency check in that case, too.
+        const finishedWork = root.current.alternate;
+
+        if (renderWasConcurrent && !isRenderConsistentWithExternalStores(finishedWork)) {
+          // A store was mutated in an interleaved event. Render again,
+          // synchronously, to block further mutations.
+          exitStatus = renderRootSync(root, lanes); // We assume the tree is now consistent because we didn't yield to any
+          // concurrent events.
+
+          renderWasConcurrent = false; // Need to check the exit status again.
+
+          continue;
+        } // Check if something threw
+
+
+        if (exitStatus === RootErrored) {
+          const originallyAttemptedLanes = lanes;
+          const errorRetryLanes = getLanesToRetrySynchronouslyOnError(root, originallyAttemptedLanes);
+
+          if (errorRetryLanes !== NoLanes) {
+            lanes = errorRetryLanes;
+            exitStatus = recoverFromConcurrentError(root, originallyAttemptedLanes, errorRetryLanes);
+            renderWasConcurrent = false;
+          }
+        }
+
+        if (exitStatus === RootFatalErrored) {
+          const fatalError = workInProgressRootFatalError;
+          prepareFreshStack(root, NoLanes);
+          markRootSuspended(root, lanes, NoLane);
+          ensureRootIsScheduled(root);
+          throw fatalError;
+        } // We now have a consistent tree. The next step is either to commit it,
+        // or, if something suspended, wait to commit it after a timeout.
+
+
+        root.finishedWork = finishedWork;
+        root.finishedLanes = lanes;
+        finishConcurrentRender(root, exitStatus, finishedWork, lanes);
+      }
+
+      break;
+    } while (true);
+  }
+
+  ensureRootIsScheduled(root);
+  return getContinuationForRoot(root, originalCallbackNode);
+}
+
+function recoverFromConcurrentError(root, originallyAttemptedLanes, errorRetryLanes) {
+  // If an error occurred during hydration, discard server response and fall
+  // back to client side render.
+  // Before rendering again, save the errors from the previous attempt.
+  const errorsFromFirstAttempt = workInProgressRootConcurrentErrors;
+  const wasRootDehydrated = isRootDehydrated(root);
+
+  if (wasRootDehydrated) {
+    // The shell failed to hydrate. Set a flag to force a client rendering
+    // during the next attempt. To do this, we call prepareFreshStack now
+    // to create the root work-in-progress fiber. This is a bit weird in terms
+    // of factoring, because it relies on renderRootSync not calling
+    // prepareFreshStack again in the call below, which happens because the
+    // root and lanes haven't changed.
+    //
+    // TODO: I think what we should do is set ForceClientRender inside
+    // throwException, like we do for nested Suspense boundaries. The reason
+    // it's here instead is so we can switch to the synchronous work loop, too.
+    // Something to consider for a future refactor.
+    const rootWorkInProgress = prepareFreshStack(root, errorRetryLanes);
+    rootWorkInProgress.flags |= ForceClientRender;
+  }
+
+  const exitStatus = renderRootSync(root, errorRetryLanes);
+
+  if (exitStatus !== RootErrored) {
+    // Successfully finished rendering on retry
+    if (workInProgressRootDidAttachPingListener && !wasRootDehydrated) {
+      // During the synchronous render, we attached additional ping listeners.
+      // This is highly suggestive of an uncached promise (though it's not the
+      // only reason this would happen). If it was an uncached promise, then
+      // it may have masked a downstream error from ocurring without actually
+      // fixing it. Example:
+      //
+      //    use(Promise.resolve('uncached'))
+      //    throw new Error('Oops!')
+      //
+      // When this happens, there's a conflict between blocking potential
+      // concurrent data races and unwrapping uncached promise values. We
+      // have to choose one or the other. Because the data race recovery is
+      // a last ditch effort, we'll disable it.
+      root.errorRecoveryDisabledLanes = mergeLanes(root.errorRecoveryDisabledLanes, originallyAttemptedLanes); // Mark the current render as suspended and force it to restart. Once
+      // these lanes finish successfully, we'll re-enable the error recovery
+      // mechanism for subsequent updates.
+
+      workInProgressRootInterleavedUpdatedLanes |= originallyAttemptedLanes;
+      return RootSuspendedWithDelay;
+    } // The errors from the failed first attempt have been recovered. Add
+    // them to the collection of recoverable errors. We'll log them in the
+    // commit phase.
+
+
+    const errorsFromSecondAttempt = workInProgressRootRecoverableErrors;
+    workInProgressRootRecoverableErrors = errorsFromFirstAttempt; // The errors from the second attempt should be queued after the errors
+    // from the first attempt, to preserve the causal sequence.
+
+    if (errorsFromSecondAttempt !== null) {
+      queueRecoverableErrors(errorsFromSecondAttempt);
+    }
+  }
+
+  return exitStatus;
+}
+
+function queueRecoverableErrors(errors) {
+  if (workInProgressRootRecoverableErrors === null) {
+    workInProgressRootRecoverableErrors = errors;
+  } else {
+    // $FlowFixMe[method-unbinding]
+    workInProgressRootRecoverableErrors.push.apply(workInProgressRootRecoverableErrors, errors);
+  }
+}
+
+function finishConcurrentRender(root, exitStatus, finishedWork, lanes) {
+  // TODO: The fact that most of these branches are identical suggests that some
+  // of the exit statuses are not best modeled as exit statuses and should be
+  // tracked orthogonally.
+  switch (exitStatus) {
+    case RootInProgress:
+    case RootFatalErrored:
+      {
+        throw Error(formatProdErrorMessage(345));
+      }
+
+    case RootSuspendedWithDelay:
+      {
+        if (includesOnlyTransitions(lanes)) {
+          // This is a transition, so we should exit without committing a
+          // placeholder and without scheduling a timeout. Delay indefinitely
+          // until we receive more data.
+          markRootSuspended(root, lanes, workInProgressDeferredLane);
+          return;
+        } // Commit the placeholder.
+
+
+        break;
+      }
+
+    case RootErrored:
+    case RootSuspended:
+    case RootCompleted:
+      {
+        break;
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(329));
+      }
+  }
+
+  {
+    if (includesOnlyRetries(lanes) && (alwaysThrottleRetries )) {
+      // This render only included retries, no updates. Throttle committing
+      // retries so that we don't show too many loading states too quickly.
+      const msUntilTimeout = globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now(); // Don't bother with a very short suspense time.
+
+      if (msUntilTimeout > 10) {
+        markRootSuspended(root, lanes, workInProgressDeferredLane);
+        const nextLanes = getNextLanes(root, NoLanes);
+
+        if (nextLanes !== NoLanes) {
+          // There's additional work we can do on this root. We might as well
+          // attempt to work on that while we're suspended.
+          return;
+        } // The render is suspended, it hasn't timed out, and there's no
+        // lower priority work to do. Instead of committing the fallback
+        // immediately, wait for more data to arrive.
+        // TODO: Combine retry throttling with Suspensey commits. Right now they
+        // run one after the other.
+
+
+        root.timeoutHandle = scheduleTimeout(commitRootWhenReady.bind(null, root, finishedWork, workInProgressRootRecoverableErrors, workInProgressTransitions, lanes, workInProgressDeferredLane), msUntilTimeout);
+        return;
+      }
+    }
+
+    commitRootWhenReady(root, finishedWork, workInProgressRootRecoverableErrors, workInProgressTransitions, lanes, workInProgressDeferredLane);
+  }
+}
+
+function commitRootWhenReady(root, finishedWork, recoverableErrors, transitions, lanes, spawnedLane) {
+  // TODO: Combine retry throttling with Suspensey commits. Right now they run
+  // one after the other.
+  if (includesOnlyNonUrgentLanes(lanes)) {
+    // Before committing, ask the renderer whether the host tree is ready.
+    // If it's not, we'll wait until it notifies us.
+    startSuspendingCommit(); // This will walk the completed fiber tree and attach listeners to all
+    // the suspensey resources. The renderer is responsible for accumulating
+    // all the load events. This all happens in a single synchronous
+    // transaction, so it track state in its own module scope.
+
+    accumulateSuspenseyCommit(finishedWork); // At the end, ask the renderer if it's ready to commit, or if we should
+    // suspend. If it's not ready, it will return a callback to subscribe to
+    // a ready event.
+
+    const schedulePendingCommit = waitForCommitToBeReady();
+
+    if (schedulePendingCommit !== null) {
+      // NOTE: waitForCommitToBeReady returns a subscribe function so that we
+      // only allocate a function if the commit isn't ready yet. The other
+      // pattern would be to always pass a callback to waitForCommitToBeReady.
+      // Not yet ready to commit. Delay the commit until the renderer notifies
+      // us that it's ready. This will be canceled if we start work on the
+      // root again.
+      root.cancelPendingCommit = schedulePendingCommit(commitRoot.bind(null, root, recoverableErrors, transitions));
+      markRootSuspended(root, lanes, spawnedLane);
+      return;
+    }
+  } // Otherwise, commit immediately.
+
+
+  commitRoot(root, recoverableErrors, transitions, spawnedLane);
+}
+
+function isRenderConsistentWithExternalStores(finishedWork) {
+  // Search the rendered tree for external store reads, and check whether the
+  // stores were mutated in a concurrent event. Intentionally using an iterative
+  // loop instead of recursion so we can exit early.
+  let node = finishedWork;
+
+  while (true) {
+    if (node.flags & StoreConsistency) {
+      const updateQueue = node.updateQueue;
+
+      if (updateQueue !== null) {
+        const checks = updateQueue.stores;
+
+        if (checks !== null) {
+          for (let i = 0; i < checks.length; i++) {
+            const check = checks[i];
+            const getSnapshot = check.getSnapshot;
+            const renderedValue = check.value;
+
+            try {
+              if (!objectIs(getSnapshot(), renderedValue)) {
+                // Found an inconsistent store.
+                return false;
+              }
+            } catch (error) {
+              // If `getSnapshot` throws, return `false`. This will schedule
+              // a re-render, and the error will be rethrown during render.
+              return false;
+            }
+          }
+        }
+      }
+    }
+
+    const child = node.child;
+
+    if (node.subtreeFlags & StoreConsistency && child !== null) {
+      child.return = node;
+      node = child;
+      continue;
+    }
+
+    if (node === finishedWork) {
+      return true;
+    }
+
+    while (node.sibling === null) {
+      if (node.return === null || node.return === finishedWork) {
+        return true;
+      }
+
+      node = node.return;
+    }
+
+    node.sibling.return = node.return;
+    node = node.sibling;
+  } // Flow doesn't know this is unreachable, but eslint does
+  // eslint-disable-next-line no-unreachable
+
+
+  return true;
+}
+
+function markRootSuspended(root, suspendedLanes, spawnedLane) {
+  // When suspending, we should always exclude lanes that were pinged or (more
+  // rarely, since we try to avoid it) updated during the render phase.
+  // TODO: Lol maybe there's a better way to factor this besides this
+  // obnoxiously named function :)
+  suspendedLanes = removeLanes(suspendedLanes, workInProgressRootPingedLanes);
+  suspendedLanes = removeLanes(suspendedLanes, workInProgressRootInterleavedUpdatedLanes);
+  markRootSuspended$1(root, suspendedLanes, spawnedLane);
+} // This is the entry point for synchronous tasks that don't go
+// through Scheduler
+
+
+function performSyncWorkOnRoot(root, lanes) {
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw Error(formatProdErrorMessage(327));
+  }
+
+  const didFlushPassiveEffects = flushPassiveEffects();
+
+  if (didFlushPassiveEffects) {
+    // If passive effects were flushed, exit to the outer work loop in the root
+    // scheduler, so we can recompute the priority.
+    // TODO: We don't actually need this `ensureRootIsScheduled` call because
+    // this path is only reachable if the root is already part of the schedule.
+    // I'm including it only for consistency with the other exit points from
+    // this function. Can address in a subsequent refactor.
+    ensureRootIsScheduled(root);
+    return null;
+  }
+
+  let exitStatus = renderRootSync(root, lanes);
+
+  if (root.tag !== LegacyRoot && exitStatus === RootErrored) {
+    // If something threw an error, try rendering one more time. We'll render
+    // synchronously to block concurrent data mutations, and we'll includes
+    // all pending updates are included. If it still fails after the second
+    // attempt, we'll give up and commit the resulting tree.
+    const originallyAttemptedLanes = lanes;
+    const errorRetryLanes = getLanesToRetrySynchronouslyOnError(root, originallyAttemptedLanes);
+
+    if (errorRetryLanes !== NoLanes) {
+      lanes = errorRetryLanes;
+      exitStatus = recoverFromConcurrentError(root, originallyAttemptedLanes, errorRetryLanes);
+    }
+  }
+
+  if (exitStatus === RootFatalErrored) {
+    const fatalError = workInProgressRootFatalError;
+    prepareFreshStack(root, NoLanes);
+    markRootSuspended(root, lanes, NoLane);
+    ensureRootIsScheduled(root);
+    throw fatalError;
+  }
+
+  if (exitStatus === RootDidNotComplete) {
+    // The render unwound without completing the tree. This happens in special
+    // cases where need to exit the current render without producing a
+    // consistent tree or committing.
+    markRootSuspended(root, lanes, NoLane);
+    ensureRootIsScheduled(root);
+    return null;
+  } // We now have a consistent tree. Because this is a sync render, we
+  // will commit it even if something suspended.
+
+
+  const finishedWork = root.current.alternate;
+  root.finishedWork = finishedWork;
+  root.finishedLanes = lanes;
+  commitRoot(root, workInProgressRootRecoverableErrors, workInProgressTransitions, workInProgressDeferredLane); // Before exiting, make sure there's a callback scheduled for the next
+  // pending level.
+
+  ensureRootIsScheduled(root);
+  return null;
+}
+function flushRoot(root, lanes) {
+  if (lanes !== NoLanes) {
+    upgradePendingLanesToSync(root, lanes);
+    ensureRootIsScheduled(root);
+
+    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
+      resetRenderTimer(); // TODO: For historical reasons this flushes all sync work across all
+      // roots. It shouldn't really matter either way, but we could change this
+      // to only flush the given root.
+
+      flushSyncWorkOnAllRoots();
+    }
+  }
+}
+function getExecutionContext() {
+  return executionContext;
+}
+function batchedUpdates$1(fn, a) {
+  const prevExecutionContext = executionContext;
+  executionContext |= BatchedContext;
+
+  try {
+    return fn(a);
+  } finally {
+    executionContext = prevExecutionContext; // If there were legacy sync updates, flush them at the end of the outer
+    // most batchedUpdates-like method.
+
+    if (executionContext === NoContext && // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.
+    !(false )) {
+      resetRenderTimer();
+      flushSyncWorkOnLegacyRootsOnly();
+    }
+  }
+}
+// Warning, this opts-out of checking the function body.
+// eslint-disable-next-line no-unused-vars
+// eslint-disable-next-line no-redeclare
+// eslint-disable-next-line no-redeclare
+
+function flushSync$1(fn) {
+  // In legacy mode, we flush pending passive effects at the beginning of the
+  // next event, not at the end of the previous one.
+  if (rootWithPendingPassiveEffects !== null && rootWithPendingPassiveEffects.tag === LegacyRoot && (executionContext & (RenderContext | CommitContext)) === NoContext) {
+    flushPassiveEffects();
+  }
+
+  const prevExecutionContext = executionContext;
+  executionContext |= BatchedContext;
+  const prevTransition = ReactCurrentBatchConfig$1.transition;
+  const previousPriority = getCurrentUpdatePriority();
+
+  try {
+    ReactCurrentBatchConfig$1.transition = null;
+    setCurrentUpdatePriority(DiscreteEventPriority);
+
+    if (fn) {
+      return fn();
+    } else {
+      return undefined;
+    }
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+    executionContext = prevExecutionContext; // Flush the immediate callbacks that were scheduled during this batch.
+    // Note that this will happen even if batchedUpdates is higher up
+    // the stack.
+
+    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
+      flushSyncWorkOnAllRoots();
+    }
+  }
+}
+function isInvalidExecutionContextForEventFunction() {
+  // Used to throw if certain APIs are called from the wrong context.
+  return (executionContext & RenderContext) !== NoContext;
+} // This is called by the HiddenContext module when we enter or leave a
+// hidden subtree. The stack logic is managed there because that's the only
+// place that ever modifies it. Which module it lives in doesn't matter for
+// performance because this function will get inlined regardless
+
+function setEntangledRenderLanes(newEntangledRenderLanes) {
+  entangledRenderLanes = newEntangledRenderLanes;
+}
+function getEntangledRenderLanes() {
+  return entangledRenderLanes;
+}
+
+function resetWorkInProgressStack() {
+  if (workInProgress === null) return;
+  let interruptedWork;
+
+  if (workInProgressSuspendedReason === NotSuspended) {
+    // Normal case. Work-in-progress hasn't started yet. Unwind all
+    // its parents.
+    interruptedWork = workInProgress.return;
+  } else {
+    // Work-in-progress is in suspended state. Reset the work loop and unwind
+    // both the suspended fiber and all its parents.
+    resetSuspendedWorkLoopOnUnwind(workInProgress);
+    interruptedWork = workInProgress;
+  }
+
+  while (interruptedWork !== null) {
+    const current = interruptedWork.alternate;
+    unwindInterruptedWork(current, interruptedWork);
+    interruptedWork = interruptedWork.return;
+  }
+
+  workInProgress = null;
+}
+
+function prepareFreshStack(root, lanes) {
+  root.finishedWork = null;
+  root.finishedLanes = NoLanes;
+  const timeoutHandle = root.timeoutHandle;
+
+  if (timeoutHandle !== noTimeout) {
+    // The root previous suspended and scheduled a timeout to commit a fallback
+    // state. Now that we have additional work, cancel the timeout.
+    root.timeoutHandle = noTimeout; // $FlowFixMe[incompatible-call] Complains noTimeout is not a TimeoutID, despite the check above
+
+    cancelTimeout(timeoutHandle);
+  }
+
+  const cancelPendingCommit = root.cancelPendingCommit;
+
+  if (cancelPendingCommit !== null) {
+    root.cancelPendingCommit = null;
+    cancelPendingCommit();
+  }
+
+  resetWorkInProgressStack();
+  workInProgressRoot = root;
+  const rootWorkInProgress = createWorkInProgress(root.current, null);
+  workInProgress = rootWorkInProgress;
+  workInProgressRootRenderLanes = lanes;
+  workInProgressSuspendedReason = NotSuspended;
+  workInProgressThrownValue = null;
+  workInProgressRootDidAttachPingListener = false;
+  workInProgressRootExitStatus = RootInProgress;
+  workInProgressRootFatalError = null;
+  workInProgressRootSkippedLanes = NoLanes;
+  workInProgressRootInterleavedUpdatedLanes = NoLanes;
+  workInProgressRootPingedLanes = NoLanes;
+  workInProgressDeferredLane = NoLane;
+  workInProgressRootConcurrentErrors = null;
+  workInProgressRootRecoverableErrors = null; // Get the lanes that are entangled with whatever we're about to render. We
+  // track these separately so we can distinguish the priority of the render
+  // task from the priority of the lanes it is entangled with. For example, a
+  // transition may not be allowed to finish unless it includes the Sync lane,
+  // which is currently suspended. We should be able to render the Transition
+  // and Sync lane in the same batch, but at Transition priority, because the
+  // Sync lane already suspended.
+
+  entangledRenderLanes = getEntangledLanes(root, lanes);
+  finishQueueingConcurrentUpdates();
+
+  return rootWorkInProgress;
+}
+
+function resetSuspendedWorkLoopOnUnwind(fiber) {
+  // Reset module-level state that was set during the render phase.
+  resetContextDependencies();
+  resetHooksOnUnwind(fiber);
+  resetChildReconcilerOnUnwind();
+}
+
+function handleThrow(root, thrownValue) {
+  // A component threw an exception. Usually this is because it suspended, but
+  // it also includes regular program errors.
+  //
+  // We're either going to unwind the stack to show a Suspense or error
+  // boundary, or we're going to replay the component again. Like after a
+  // promise resolves.
+  //
+  // Until we decide whether we're going to unwind or replay, we should preserve
+  // the current state of the work loop without resetting anything.
+  //
+  // If we do decide to unwind the stack, module-level variables will be reset
+  // in resetSuspendedWorkLoopOnUnwind.
+  // These should be reset immediately because they're only supposed to be set
+  // when React is executing user code.
+  resetHooksAfterThrow();
+  ReactCurrentOwner.current = null;
+
+  if (thrownValue === SuspenseException) {
+    // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown value
+    // to be a thenable, because before `use` existed that was the (unstable)
+    // API for suspending. This implementation detail can change later, once we
+    // deprecate the old API in favor of `use`.
+    thrownValue = getSuspendedThenable();
+    workInProgressSuspendedReason = shouldRemainOnPreviousScreen() && // Check if there are other pending updates that might possibly unblock this
+    // component from suspending. This mirrors the check in
+    // renderDidSuspendDelayIfPossible. We should attempt to unify them somehow.
+    // TODO: Consider unwinding immediately, using the
+    // SuspendedOnHydration mechanism.
+    !includesNonIdleWork(workInProgressRootSkippedLanes) && !includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes) ? // Suspend work loop until data resolves
+    SuspendedOnData : // Don't suspend work loop, except to check if the data has
+    // immediately resolved (i.e. in a microtask). Otherwise, trigger the
+    // nearest Suspense fallback.
+    SuspendedOnImmediate;
+  } else if (thrownValue === SuspenseyCommitException) {
+    thrownValue = getSuspendedThenable();
+    workInProgressSuspendedReason = SuspendedOnInstance;
+  } else if (thrownValue === SelectiveHydrationException) {
+    // An update flowed into a dehydrated boundary. Before we can apply the
+    // update, we need to finish hydrating. Interrupt the work-in-progress
+    // render so we can restart at the hydration lane.
+    //
+    // The ideal implementation would be able to switch contexts without
+    // unwinding the current stack.
+    //
+    // We could name this something more general but as of now it's the only
+    // case where we think this should happen.
+    workInProgressSuspendedReason = SuspendedOnHydration;
+  } else {
+    // This is a regular error.
+    const isWakeable = thrownValue !== null && typeof thrownValue === 'object' && typeof thrownValue.then === 'function';
+    workInProgressSuspendedReason = isWakeable ? // A wakeable object was thrown by a legacy Suspense implementation.
+    // This has slightly different behavior than suspending with `use`.
+    SuspendedOnDeprecatedThrowPromise : // This is a regular error. If something earlier in the component already
+    // suspended, we must clear the thenable state to unblock the work loop.
+    SuspendedOnError;
+  }
+
+  workInProgressThrownValue = thrownValue;
+  const erroredWork = workInProgress;
+
+  if (erroredWork === null) {
+    // This is a fatal error
+    workInProgressRootExitStatus = RootFatalErrored;
+    workInProgressRootFatalError = thrownValue;
+    return;
+  }
+}
+
+function shouldRemainOnPreviousScreen() {
+  // This is asking whether it's better to suspend the transition and remain
+  // on the previous screen, versus showing a fallback as soon as possible. It
+  // takes into account both the priority of render and also whether showing a
+  // fallback would produce a desirable user experience.
+  const handler = getSuspenseHandler();
+
+  if (handler === null) {
+    // There's no Suspense boundary that can provide a fallback. We have no
+    // choice but to remain on the previous screen.
+    // NOTE: We do this even for sync updates, for lack of any better option. In
+    // the future, we may change how we handle this, like by putting the whole
+    // root into a "detached" mode.
+    return true;
+  } // TODO: Once `use` has fully replaced the `throw promise` pattern, we should
+  // be able to remove the equivalent check in finishConcurrentRender, and rely
+  // just on this one.
+
+
+  if (includesOnlyTransitions(workInProgressRootRenderLanes)) {
+    if (getShellBoundary() === null) {
+      // We're rendering inside the "shell" of the app. Activating the nearest
+      // fallback would cause visible content to disappear. It's better to
+      // suspend the transition and remain on the previous screen.
+      return true;
+    } else {
+      // We're rendering content that wasn't part of the previous screen.
+      // Rather than block the transition, it's better to show a fallback as
+      // soon as possible. The appearance of any nested fallbacks will be
+      // throttled to avoid jank.
+      return false;
+    }
+  }
+
+  if (includesOnlyRetries(workInProgressRootRenderLanes) || // In this context, an OffscreenLane counts as a Retry
+  // TODO: It's become increasingly clear that Retries and Offscreen are
+  // deeply connected. They probably can be unified further.
+  includesSomeLane(workInProgressRootRenderLanes, OffscreenLane)) {
+    // During a retry, we can suspend rendering if the nearest Suspense boundary
+    // is the boundary of the "shell", because we're guaranteed not to block
+    // any new content from appearing.
+    //
+    // The reason we must check if this is a retry is because it guarantees
+    // that suspending the work loop won't block an actual update, because
+    // retries don't "update" anything; they fill in fallbacks that were left
+    // behind by a previous transition.
+    return handler === getShellBoundary();
+  } // For all other Lanes besides Transitions and Retries, we should not wait
+  // for the data to load.
+
+
+  return false;
+}
+
+function pushDispatcher(container) {
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = ContextOnlyDispatcher;
+
+  if (prevDispatcher === null) {
+    // The React isomorphic package does not include a default dispatcher.
+    // Instead the first renderer will lazily attach one, in order to give
+    // nicer error messages.
+    return ContextOnlyDispatcher;
+  } else {
+    return prevDispatcher;
+  }
+}
+
+function popDispatcher(prevDispatcher) {
+  ReactCurrentDispatcher.current = prevDispatcher;
+}
+
+function pushCacheDispatcher() {
+  {
+    const prevCacheDispatcher = ReactCurrentCache.current;
+    ReactCurrentCache.current = DefaultCacheDispatcher;
+    return prevCacheDispatcher;
+  }
+}
+
+function popCacheDispatcher(prevCacheDispatcher) {
+  {
+    ReactCurrentCache.current = prevCacheDispatcher;
+  }
+}
+
+function markCommitTimeOfFallback() {
+  globalMostRecentFallbackTime = now();
+}
+function markSkippedUpdateLanes(lane) {
+  workInProgressRootSkippedLanes = mergeLanes(lane, workInProgressRootSkippedLanes);
+}
+function renderDidSuspend() {
+  if (workInProgressRootExitStatus === RootInProgress) {
+    workInProgressRootExitStatus = RootSuspended;
+  }
+}
+function renderDidSuspendDelayIfPossible() {
+  workInProgressRootExitStatus = RootSuspendedWithDelay; // Check if there are updates that we skipped tree that might have unblocked
+  // this render.
+
+  if ((includesNonIdleWork(workInProgressRootSkippedLanes) || includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes)) && workInProgressRoot !== null) {
+    // Mark the current render as suspended so that we switch to working on
+    // the updates that were skipped. Usually we only suspend at the end of
+    // the render phase.
+    // TODO: We should probably always mark the root as suspended immediately
+    // (inside this function), since by suspending at the end of the render
+    // phase introduces a potential mistake where we suspend lanes that were
+    // pinged or updated while we were rendering.
+    // TODO: Consider unwinding immediately, using the
+    // SuspendedOnHydration mechanism.
+    markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes, workInProgressDeferredLane);
+  }
+}
+function renderDidError(error) {
+  if (workInProgressRootExitStatus !== RootSuspendedWithDelay) {
+    workInProgressRootExitStatus = RootErrored;
+  }
+
+  if (workInProgressRootConcurrentErrors === null) {
+    workInProgressRootConcurrentErrors = [error];
+  } else {
+    workInProgressRootConcurrentErrors.push(error);
+  }
+} // Called during render to determine if anything has suspended.
+// Returns false if we're not sure.
+
+function renderHasNotSuspendedYet() {
+  // If something errored or completed, we can't really be sure,
+  // so those are false.
+  return workInProgressRootExitStatus === RootInProgress;
+} // TODO: Over time, this function and renderRootConcurrent have become more
+// and more similar. Not sure it makes sense to maintain forked paths. Consider
+// unifying them again.
+
+function renderRootSync(root, lanes) {
+  const prevExecutionContext = executionContext;
+  executionContext |= RenderContext;
+  const prevDispatcher = pushDispatcher();
+  const prevCacheDispatcher = pushCacheDispatcher(); // If the root or lanes have changed, throw out the existing stack
+  // and prepare a fresh one. Otherwise we'll continue where we left off.
+
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
+
+    workInProgressTransitions = getTransitionsForLanes();
+    prepareFreshStack(root, lanes);
+  }
+
+  let didSuspendInShell = false;
+
+  outer: do {
+    try {
+      if (workInProgressSuspendedReason !== NotSuspended && workInProgress !== null) {
+        // The work loop is suspended. During a synchronous render, we don't
+        // yield to the main thread. Immediately unwind the stack. This will
+        // trigger either a fallback or an error boundary.
+        // TODO: For discrete and "default" updates (anything that's not
+        // flushSync), we want to wait for the microtasks the flush before
+        // unwinding. Will probably implement this using renderRootConcurrent,
+        // or merge renderRootSync and renderRootConcurrent into the same
+        // function and fork the behavior some other way.
+        const unitOfWork = workInProgress;
+        const thrownValue = workInProgressThrownValue;
+
+        switch (workInProgressSuspendedReason) {
+          case SuspendedOnHydration:
+            {
+              // Selective hydration. An update flowed into a dehydrated tree.
+              // Interrupt the current render so the work loop can switch to the
+              // hydration lane.
+              resetWorkInProgressStack();
+              workInProgressRootExitStatus = RootDidNotComplete;
+              break outer;
+            }
+
+          case SuspendedOnImmediate:
+          case SuspendedOnData:
+            {
+              if (!didSuspendInShell && getSuspenseHandler() === null) {
+                didSuspendInShell = true;
+              } // Intentional fallthrough
+
+            }
+
+          default:
+            {
+              // Unwind then continue with the normal work loop.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              break;
+            }
+        }
+      }
+
+      workLoopSync();
+      break;
+    } catch (thrownValue) {
+      handleThrow(root, thrownValue);
+    }
+  } while (true); // Check if something suspended in the shell. We use this to detect an
+  // infinite ping loop caused by an uncached promise.
+  //
+  // Only increment this counter once per synchronous render attempt across the
+  // whole tree. Even if there are many sibling components that suspend, this
+  // counter only gets incremented once.
+
+
+  if (didSuspendInShell) {
+    root.shellSuspendCounter++;
+  }
+
+  resetContextDependencies();
+  executionContext = prevExecutionContext;
+  popDispatcher(prevDispatcher);
+  popCacheDispatcher(prevCacheDispatcher);
+
+  if (workInProgress !== null) {
+    // This is a sync render, so we should have finished the whole tree.
+    throw Error(formatProdErrorMessage(261));
+  }
+
+
+  workInProgressRoot = null;
+  workInProgressRootRenderLanes = NoLanes; // It's safe to process the queue now that the render phase is complete.
+
+  finishQueueingConcurrentUpdates();
+  return workInProgressRootExitStatus;
+} // The work loop is an extremely hot path. Tell Closure not to inline it.
+
+/** @noinline */
+
+
+function workLoopSync() {
+  // Perform work without checking if we need to yield between fiber.
+  while (workInProgress !== null) {
+    performUnitOfWork(workInProgress);
+  }
+}
+
+function renderRootConcurrent(root, lanes) {
+  const prevExecutionContext = executionContext;
+  executionContext |= RenderContext;
+  const prevDispatcher = pushDispatcher();
+  const prevCacheDispatcher = pushCacheDispatcher(); // If the root or lanes have changed, throw out the existing stack
+  // and prepare a fresh one. Otherwise we'll continue where we left off.
+
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
+
+    workInProgressTransitions = getTransitionsForLanes();
+    resetRenderTimer();
+    prepareFreshStack(root, lanes);
+  }
+
+  outer: do {
+    try {
+      if (workInProgressSuspendedReason !== NotSuspended && workInProgress !== null) {
+        // The work loop is suspended. We need to either unwind the stack or
+        // replay the suspended component.
+        const unitOfWork = workInProgress;
+        const thrownValue = workInProgressThrownValue;
+
+        resumeOrUnwind: switch (workInProgressSuspendedReason) {
+          case SuspendedOnError:
+            {
+              // Unwind then continue with the normal work loop.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              break;
+            }
+
+          case SuspendedOnData:
+            {
+              const thenable = thrownValue;
+
+              if (isThenableResolved(thenable)) {
+                // The data resolved. Try rendering the component again.
+                workInProgressSuspendedReason = NotSuspended;
+                workInProgressThrownValue = null;
+                replaySuspendedUnitOfWork(unitOfWork);
+                break;
+              } // The work loop is suspended on data. We should wait for it to
+              // resolve before continuing to render.
+              // TODO: Handle the case where the promise resolves synchronously.
+              // Usually this is handled when we instrument the promise to add a
+              // `status` field, but if the promise already has a status, we won't
+              // have added a listener until right here.
+
+
+              const onResolution = () => {
+                // Check if the root is still suspended on this promise.
+                if (workInProgressSuspendedReason === SuspendedOnData && workInProgressRoot === root) {
+                  // Mark the root as ready to continue rendering.
+                  workInProgressSuspendedReason = SuspendedAndReadyToContinue;
+                } // Ensure the root is scheduled. We should do this even if we're
+                // currently working on a different root, so that we resume
+                // rendering later.
+
+
+                ensureRootIsScheduled(root);
+              };
+
+              thenable.then(onResolution, onResolution);
+              break outer;
+            }
+
+          case SuspendedOnImmediate:
+            {
+              // If this fiber just suspended, it's possible the data is already
+              // cached. Yield to the main thread to give it a chance to ping. If
+              // it does, we can retry immediately without unwinding the stack.
+              workInProgressSuspendedReason = SuspendedAndReadyToContinue;
+              break outer;
+            }
+
+          case SuspendedOnInstance:
+            {
+              workInProgressSuspendedReason = SuspendedOnInstanceAndReadyToContinue;
+              break outer;
+            }
+
+          case SuspendedAndReadyToContinue:
+            {
+              const thenable = thrownValue;
+
+              if (isThenableResolved(thenable)) {
+                // The data resolved. Try rendering the component again.
+                workInProgressSuspendedReason = NotSuspended;
+                workInProgressThrownValue = null;
+                replaySuspendedUnitOfWork(unitOfWork);
+              } else {
+                // Otherwise, unwind then continue with the normal work loop.
+                workInProgressSuspendedReason = NotSuspended;
+                workInProgressThrownValue = null;
+                throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              }
+
+              break;
+            }
+
+          case SuspendedOnInstanceAndReadyToContinue:
+            {
+              switch (workInProgress.tag) {
+                case HostComponent:
+                case HostHoistable:
+                case HostSingleton:
+                  {
+                    // Before unwinding the stack, check one more time if the
+                    // instance is ready. It may have loaded when React yielded to
+                    // the main thread.
+                    // Assigning this to a constant so Flow knows the binding won't
+                    // be mutated by `preloadInstance`.
+                    const hostFiber = workInProgress;
+                    const type = hostFiber.type;
+                    const props = hostFiber.pendingProps;
+                    const isReady = preloadInstance(type, props);
+
+                    if (isReady) {
+                      // The data resolved. Resume the work loop as if nothing
+                      // suspended. Unlike when a user component suspends, we don't
+                      // have to replay anything because the host fiber
+                      // already completed.
+                      workInProgressSuspendedReason = NotSuspended;
+                      workInProgressThrownValue = null;
+                      const sibling = hostFiber.sibling;
+
+                      if (sibling !== null) {
+                        workInProgress = sibling;
+                      } else {
+                        const returnFiber = hostFiber.return;
+
+                        if (returnFiber !== null) {
+                          workInProgress = returnFiber;
+                          completeUnitOfWork(returnFiber);
+                        } else {
+                          workInProgress = null;
+                        }
+                      }
+
+                      break resumeOrUnwind;
+                    }
+
+                    break;
+                  }
+
+                default:
+                  {
+                    // This will fail gracefully but it's not correct, so log a
+                    // warning in dev.
+                    if (false) ;
+
+                    break;
+                  }
+              } // Otherwise, unwind then continue with the normal work loop.
+
+
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              break;
+            }
+
+          case SuspendedOnDeprecatedThrowPromise:
+            {
+              // Suspended by an old implementation that uses the `throw promise`
+              // pattern. The newer replaying behavior can cause subtle issues
+              // like infinite ping loops. So we maintain the old behavior and
+              // always unwind.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              break;
+            }
+
+          case SuspendedOnHydration:
+            {
+              // Selective hydration. An update flowed into a dehydrated tree.
+              // Interrupt the current render so the work loop can switch to the
+              // hydration lane.
+              resetWorkInProgressStack();
+              workInProgressRootExitStatus = RootDidNotComplete;
+              break outer;
+            }
+
+          default:
+            {
+              throw Error(formatProdErrorMessage(462));
+            }
+        }
+      }
+
+      if (false && ReactCurrentActQueue.current !== null) ; else {
+        workLoopConcurrent();
+      }
+
+      break;
+    } catch (thrownValue) {
+      handleThrow(root, thrownValue);
+    }
+  } while (true);
+
+  resetContextDependencies();
+  popDispatcher(prevDispatcher);
+  popCacheDispatcher(prevCacheDispatcher);
+  executionContext = prevExecutionContext;
+
+
+  if (workInProgress !== null) {
+
+    return RootInProgress;
+  } else {
+
+
+    workInProgressRoot = null;
+    workInProgressRootRenderLanes = NoLanes; // It's safe to process the queue now that the render phase is complete.
+
+    finishQueueingConcurrentUpdates(); // Return the final exit status.
+
+    return workInProgressRootExitStatus;
+  }
+}
+/** @noinline */
+
+
+function workLoopConcurrent() {
+  // Perform work until Scheduler asks us to yield
+  while (workInProgress !== null && !shouldYield()) {
+    // $FlowFixMe[incompatible-call] found when upgrading Flow
+    performUnitOfWork(workInProgress);
+  }
+}
+
+function performUnitOfWork(unitOfWork) {
+  // The current, flushed, state of this fiber is the alternate. Ideally
+  // nothing should rely on this, but relying on it here means that we don't
+  // need an additional field on the work in progress.
+  const current = unitOfWork.alternate;
+  let next;
+
+  {
+    next = beginWork(current, unitOfWork, entangledRenderLanes);
+  }
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+
+  if (next === null) {
+    // If this doesn't spawn new work, complete the current work.
+    completeUnitOfWork(unitOfWork);
+  } else {
+    workInProgress = next;
+  }
+
+  ReactCurrentOwner.current = null;
+}
+
+function replaySuspendedUnitOfWork(unitOfWork) {
+  // This is a fork of performUnitOfWork specifcally for replaying a fiber that
+  // just suspended.
+  //
+  const current = unitOfWork.alternate;
+  let next;
+
+  switch (unitOfWork.tag) {
+    case IndeterminateComponent:
+      {
+        // Because it suspended with `use`, we can assume it's a
+        // function component.
+        unitOfWork.tag = FunctionComponent; // Fallthrough to the next branch.
+      }
+
+    case SimpleMemoComponent:
+    case FunctionComponent:
+      {
+        // Resolve `defaultProps`. This logic is copied from `beginWork`.
+        // TODO: Consider moving this switch statement into that module. Also,
+        // could maybe use this as an opportunity to say `use` doesn't work with
+        // `defaultProps` :)
+        const Component = unitOfWork.type;
+        const unresolvedProps = unitOfWork.pendingProps;
+        const resolvedProps = unitOfWork.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        let context;
+
+        {
+          const unmaskedContext = getUnmaskedContext(unitOfWork, Component, true);
+          context = getMaskedContext(unitOfWork, unmaskedContext);
+        }
+
+        next = replayFunctionComponent(current, unitOfWork, resolvedProps, Component, context, workInProgressRootRenderLanes);
+        break;
+      }
+
+    case ForwardRef:
+      {
+        // Resolve `defaultProps`. This logic is copied from `beginWork`.
+        // TODO: Consider moving this switch statement into that module. Also,
+        // could maybe use this as an opportunity to say `use` doesn't work with
+        // `defaultProps` :)
+        const Component = unitOfWork.type.render;
+        const unresolvedProps = unitOfWork.pendingProps;
+        const resolvedProps = unitOfWork.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        next = replayFunctionComponent(current, unitOfWork, resolvedProps, Component, unitOfWork.ref, workInProgressRootRenderLanes);
+        break;
+      }
+
+    case HostComponent:
+      {
+        // Some host components are stateful (that's how we implement form
+        // actions) but we don't bother to reuse the memoized state because it's
+        // not worth the extra code. The main reason to reuse the previous hooks
+        // is to reuse uncached promises, but we happen to know that the only
+        // promises that a host component might suspend on are definitely cached
+        // because they are controlled by us. So don't bother.
+        resetHooksOnUnwind(unitOfWork); // Fallthrough to the next branch.
+      }
+
+    default:
+      {
+        // Other types besides function components are reset completely before
+        // being replayed. Currently this only happens when a Usable type is
+        // reconciled — the reconciler will suspend.
+        //
+        // We reset the fiber back to its original state; however, this isn't
+        // a full "unwind" because we're going to reuse the promises that were
+        // reconciled previously. So it's intentional that we don't call
+        // resetSuspendedWorkLoopOnUnwind here.
+        unwindInterruptedWork(current, unitOfWork);
+        unitOfWork = workInProgress = resetWorkInProgress(unitOfWork, entangledRenderLanes);
+        next = beginWork(current, unitOfWork, entangledRenderLanes);
+        break;
+      }
+  }
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+
+  if (next === null) {
+    // If this doesn't spawn new work, complete the current work.
+    completeUnitOfWork(unitOfWork);
+  } else {
+    workInProgress = next;
+  }
+
+  ReactCurrentOwner.current = null;
+}
+
+function throwAndUnwindWorkLoop(unitOfWork, thrownValue) {
+  // This is a fork of performUnitOfWork specifcally for unwinding a fiber
+  // that threw an exception.
+  //
+  // Return to the normal work loop. This will unwind the stack, and potentially
+  // result in showing a fallback.
+  resetSuspendedWorkLoopOnUnwind(unitOfWork);
+  const returnFiber = unitOfWork.return;
+
+  if (returnFiber === null || workInProgressRoot === null) {
+    // Expected to be working on a non-root fiber. This is a fatal error
+    // because there's no ancestor that can handle it; the root is
+    // supposed to capture all errors that weren't caught by an error
+    // boundary.
+    workInProgressRootExitStatus = RootFatalErrored;
+    workInProgressRootFatalError = thrownValue; // Set `workInProgress` to null. This represents advancing to the next
+    // sibling, or the parent if there are no siblings. But since the root
+    // has no siblings nor a parent, we set it to null. Usually this is
+    // handled by `completeUnitOfWork` or `unwindWork`, but since we're
+    // intentionally not calling those, we need set it here.
+    // TODO: Consider calling `unwindWork` to pop the contexts.
+
+    workInProgress = null;
+    return;
+  }
+
+  try {
+    // Find and mark the nearest Suspense or error boundary that can handle
+    // this "exception".
+    throwException(workInProgressRoot, returnFiber, unitOfWork, thrownValue, workInProgressRootRenderLanes);
+  } catch (error) {
+    // We had trouble processing the error. An example of this happening is
+    // when accessing the `componentDidCatch` property of an error boundary
+    // throws an error. A weird edge case. There's a regression test for this.
+    // To prevent an infinite loop, bubble the error up to the next parent.
+    workInProgress = returnFiber;
+    throw error;
+  }
+
+  if (unitOfWork.flags & Incomplete) {
+    // Unwind the stack until we reach the nearest boundary.
+    unwindUnitOfWork(unitOfWork);
+  } else {
+    // Although the fiber suspended, we're intentionally going to commit it in
+    // an inconsistent state. We can do this safely in cases where we know the
+    // inconsistent tree will be hidden.
+    //
+    // This currently only applies to Legacy Suspense implementation, but we may
+    // port a version of this to concurrent roots, too, when performing a
+    // synchronous render. Because that will allow us to mutate the tree as we
+    // go instead of buffering mutations until the end. Though it's unclear if
+    // this particular path is how that would be implemented.
+    completeUnitOfWork(unitOfWork);
+  }
+}
+
+function completeUnitOfWork(unitOfWork) {
+  // Attempt to complete the current unit of work, then move to the next
+  // sibling. If there are no more siblings, return to the parent fiber.
+  let completedWork = unitOfWork;
+
+  do {
+    // nothing should rely on this, but relying on it here means that we don't
+    // need an additional field on the work in progress.
+
+
+    const current = completedWork.alternate;
+    const returnFiber = completedWork.return;
+    let next;
+
+    {
+      next = completeWork(current, completedWork, entangledRenderLanes);
+    }
+
+    if (next !== null) {
+      // Completing this fiber spawned new work. Work on that next.
+      workInProgress = next;
+      return;
+    }
+
+    const siblingFiber = completedWork.sibling;
+
+    if (siblingFiber !== null) {
+      // If there is more work to do in this returnFiber, do that next.
+      workInProgress = siblingFiber;
+      return;
+    } // Otherwise, return to the parent
+    // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+    completedWork = returnFiber; // Update the next thing we're working on in case something throws.
+
+    workInProgress = completedWork;
+  } while (completedWork !== null); // We've reached the root.
+
+
+  if (workInProgressRootExitStatus === RootInProgress) {
+    workInProgressRootExitStatus = RootCompleted;
+  }
+}
+
+function unwindUnitOfWork(unitOfWork) {
+  let incompleteWork = unitOfWork;
+
+  do {
+    // The current, flushed, state of this fiber is the alternate. Ideally
+    // nothing should rely on this, but relying on it here means that we don't
+    // need an additional field on the work in progress.
+    const current = incompleteWork.alternate; // This fiber did not complete because something threw. Pop values off
+    // the stack without entering the complete phase. If this is a boundary,
+    // capture values if possible.
+
+    const next = unwindWork(current, incompleteWork); // Because this fiber did not complete, don't reset its lanes.
+
+    if (next !== null) {
+      // Found a boundary that can handle this exception. Re-renter the
+      // begin phase. This branch will return us to the normal work loop.
+      //
+      // Since we're restarting, remove anything that is not a host effect
+      // from the effect tag.
+      next.flags &= HostEffectMask;
+      workInProgress = next;
+      return;
+    } // Keep unwinding until we reach either a boundary or the root.
+    // of the node being unwound, we should be able to reset node itself as we
+    // unwind the stack. Saves an additional null check.
+
+
+    const returnFiber = incompleteWork.return;
+
+    if (returnFiber !== null) {
+      // Mark the parent fiber as incomplete and clear its subtree flags.
+      // TODO: Once we stop prerendering siblings, we may be able to get rid of
+      // the Incomplete flag because unwinding to the nearest boundary will
+      // happen synchronously.
+      returnFiber.flags |= Incomplete;
+      returnFiber.subtreeFlags = NoFlags$1;
+      returnFiber.deletions = null;
+    } // NOTE: If we re-enable sibling prerendering in some cases, here we
+    // would switch to the normal completion path: check if a sibling
+    // exists, and if so, begin work on it.
+    // Otherwise, return to the parent
+    // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+    incompleteWork = returnFiber; // Update the next thing we're working on in case something throws.
+
+    workInProgress = incompleteWork;
+  } while (incompleteWork !== null); // We've unwound all the way to the root.
+
+
+  workInProgressRootExitStatus = RootDidNotComplete;
+  workInProgress = null;
+}
+
+function commitRoot(root, recoverableErrors, transitions, spawnedLane) {
+  // TODO: This no longer makes any sense. We already wrap the mutation and
+  // layout phases. Should be able to remove.
+  const previousUpdateLanePriority = getCurrentUpdatePriority();
+  const prevTransition = ReactCurrentBatchConfig$1.transition;
+
+  try {
+    ReactCurrentBatchConfig$1.transition = null;
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    commitRootImpl(root, recoverableErrors, transitions, previousUpdateLanePriority, spawnedLane);
+  } finally {
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+    setCurrentUpdatePriority(previousUpdateLanePriority);
+  }
+
+  return null;
+}
+
+function commitRootImpl(root, recoverableErrors, transitions, renderPriorityLevel, spawnedLane) {
+  do {
+    // `flushPassiveEffects` will call `flushSyncUpdateQueue` at the end, which
+    // means `flushPassiveEffects` will sometimes result in additional
+    // passive effects. So we need to keep flushing in a loop until there are
+    // no more pending effects.
+    // TODO: Might be better if `flushPassiveEffects` did not automatically
+    // flush synchronous work at the end, to avoid factoring hazards like this.
+    flushPassiveEffects();
+  } while (rootWithPendingPassiveEffects !== null);
+
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw Error(formatProdErrorMessage(327));
+  }
+
+  const finishedWork = root.finishedWork;
+  const lanes = root.finishedLanes;
+
+  if (finishedWork === null) {
+
+    return null;
+  }
+
+  root.finishedWork = null;
+  root.finishedLanes = NoLanes;
+
+  if (finishedWork === root.current) {
+    throw Error(formatProdErrorMessage(177));
+  } // commitRoot never returns a continuation; it always finishes synchronously.
+  // So we can clear these now to allow a new callback to be scheduled.
+
+
+  root.callbackNode = null;
+  root.callbackPriority = NoLane;
+  root.cancelPendingCommit = null; // Check which lanes no longer have any work scheduled on them, and mark
+  // those as finished.
+
+  let remainingLanes = mergeLanes(finishedWork.lanes, finishedWork.childLanes); // Make sure to account for lanes that were updated by a concurrent event
+  // during the render phase; don't mark them as finished.
+
+  const concurrentlyUpdatedLanes = getConcurrentlyUpdatedLanes();
+  remainingLanes = mergeLanes(remainingLanes, concurrentlyUpdatedLanes);
+  markRootFinished(root, remainingLanes, spawnedLane);
+
+  if (root === workInProgressRoot) {
+    // We can reset these now that they are finished.
+    workInProgressRoot = null;
+    workInProgress = null;
+    workInProgressRootRenderLanes = NoLanes;
+  } // If there are pending passive effects, schedule a callback to process them.
+  // Do this as early as possible, so it is queued before anything else that
+  // might get scheduled in the commit phase. (See #16714.)
+  // TODO: Delete all other places that schedule the passive effect callback
+  // They're redundant.
+
+
+  if ((finishedWork.subtreeFlags & PassiveMask) !== NoFlags$1 || (finishedWork.flags & PassiveMask) !== NoFlags$1) {
+    if (!rootDoesHavePassiveEffects) {
+      rootDoesHavePassiveEffects = true;
+      pendingPassiveEffectsRemainingLanes = remainingLanes; // workInProgressTransitions might be overwritten, so we want
+      // to store it in pendingPassiveTransitions until they get processed
+      // We need to pass this through as an argument to commitRoot
+      // because workInProgressTransitions might have changed between
+      // the previous render and commit if we throttle the commit
+      // with setTimeout
+
+      pendingPassiveTransitions = transitions;
+      scheduleCallback(NormalPriority$1, () => {
+        flushPassiveEffects(); // This render triggered passive effects: release the root cache pool
+        // *after* passive effects fire to avoid freeing a cache pool that may
+        // be referenced by a node in the tree (HostRoot, Cache boundary etc)
+
+        return null;
+      });
+    }
+  } // Check if there are any effects in the whole tree.
+  // TODO: This is left over from the effect list implementation, where we had
+  // to check for the existence of `firstEffect` to satisfy Flow. I think the
+  // only other reason this optimization exists is because it affects profiling.
+  // Reconsider whether this is necessary.
+
+
+  const subtreeHasEffects = (finishedWork.subtreeFlags & (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !== NoFlags$1;
+  const rootHasEffect = (finishedWork.flags & (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !== NoFlags$1;
+
+  if (subtreeHasEffects || rootHasEffect) {
+    const prevTransition = ReactCurrentBatchConfig$1.transition;
+    ReactCurrentBatchConfig$1.transition = null;
+    const previousPriority = getCurrentUpdatePriority();
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    const prevExecutionContext = executionContext;
+    executionContext |= CommitContext; // Reset this to null before calling lifecycles
+
+    ReactCurrentOwner.current = null; // The commit phase is broken into several sub-phases. We do a separate pass
+    // of the effect list for each phase: all mutation effects come before all
+    // layout effects, and so on.
+    // The first phase a "before mutation" phase. We use this phase to read the
+    // state of the host tree right before we mutate it. This is where
+    // getSnapshotBeforeUpdate is called.
+
+    commitBeforeMutationEffects(root, finishedWork);
+
+
+    commitMutationEffects(root, finishedWork);
+
+    resetAfterCommit(); // The work-in-progress tree is now the current tree. This must come after
+    // the mutation phase, so that the previous tree is still current during
+    // componentWillUnmount, but before the layout phase, so that the finished
+    // work is current during componentDidMount/Update.
+
+    root.current = finishedWork; // The next phase is the layout phase, where we call effects that read
+
+    commitLayoutEffects(finishedWork, root);
+    // opportunity to paint.
+
+
+    requestPaint();
+    executionContext = prevExecutionContext; // Reset the priority to the previous non-sync value.
+
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+  } else {
+    // No effects.
+    root.current = finishedWork; // Measure these anyway so the flamegraph explicitly shows that there were
+  }
+
+  if (rootDoesHavePassiveEffects) {
+    // This commit has passive effects. Stash a reference to them. But don't
+    // schedule a callback until after flushing layout work.
+    rootDoesHavePassiveEffects = false;
+    rootWithPendingPassiveEffects = root;
+    pendingPassiveEffectsLanes = lanes;
+  } else {
+    // There were no passive effects, so we can immediately release the cache
+    // pool for this render.
+    releaseRootPooledCache(root, remainingLanes);
+  } // Read this again, since an effect might have updated it
+
+
+  remainingLanes = root.pendingLanes; // Check if there's remaining work on this root
+  // TODO: This is part of the `componentDidCatch` implementation. Its purpose
+  // is to detect whether something might have called setState inside
+  // `componentDidCatch`. The mechanism is known to be flawed because `setState`
+  // inside `componentDidCatch` is itself flawed — that's why we recommend
+  // `getDerivedStateFromError` instead. However, it could be improved by
+  // checking if remainingLanes includes Sync work, instead of whether there's
+  // any work remaining at all (which would also include stuff like Suspense
+  // retries or transitions). It's been like this for a while, though, so fixing
+  // it probably isn't that urgent.
+
+  if (remainingLanes === NoLanes) {
+    // If there's no remaining work, we can clear the set of already failed
+    // error boundaries.
+    legacyErrorBoundariesThatAlreadyFailed = null;
+  }
+
+  onCommitRoot(finishedWork.stateNode, renderPriorityLevel);
+  // additional work on this root is scheduled.
+
+
+  ensureRootIsScheduled(root);
+
+  if (recoverableErrors !== null) {
+    // There were errors during this render, but recovered from them without
+    // needing to surface it to the UI. We log them here.
+    const onRecoverableError = root.onRecoverableError;
+
+    for (let i = 0; i < recoverableErrors.length; i++) {
+      const recoverableError = recoverableErrors[i];
+      const errorInfo = makeErrorInfo(recoverableError.digest, recoverableError.stack);
+      onRecoverableError(recoverableError.value, errorInfo);
+    }
+  }
+
+  if (hasUncaughtError) {
+    hasUncaughtError = false;
+    const error = firstUncaughtError;
+    firstUncaughtError = null;
+    throw error;
+  } // If the passive effects are the result of a discrete render, flush them
+  // synchronously at the end of the current task so that the result is
+  // immediately observable. Otherwise, we assume that they are not
+  // order-dependent and do not need to be observed by external systems, so we
+  // can wait until after paint.
+  // TODO: We can optimize this by not scheduling the callback earlier. Since we
+  // currently schedule the callback in multiple places, will wait until those
+  // are consolidated.
+
+
+  if (includesSyncLane(pendingPassiveEffectsLanes) && root.tag !== LegacyRoot) {
+    flushPassiveEffects();
+  } // Read this again, since a passive effect might have updated it
+
+
+  remainingLanes = root.pendingLanes; // Check if this render scheduled a cascading synchronous update. This is a
+  // heurstic to detect infinite update loops. We are intentionally excluding
+  // hydration lanes in this check, because render triggered by selective
+  // hydration is conceptually not an update.
+
+  if ( // Was the finished render the result of an update (not hydration)?
+  includesSomeLane(lanes, UpdateLanes) && // Did it schedule a sync update?
+  includesSomeLane(remainingLanes, SyncUpdateLanes)) {
+    // finishing. If there are too many, it indicates an infinite update loop.
+
+
+    if (root === rootWithNestedUpdates) {
+      nestedUpdateCount++;
+    } else {
+      nestedUpdateCount = 0;
+      rootWithNestedUpdates = root;
+    }
+  } else {
+    nestedUpdateCount = 0;
+  } // If layout work was scheduled, flush it now.
+
+
+  flushSyncWorkOnAllRoots();
+
+  return null;
+}
+
+function makeErrorInfo(digest, componentStack) {
+  {
+    return {
+      digest,
+      componentStack
+    };
+  }
+}
+
+function releaseRootPooledCache(root, remainingLanes) {
+  {
+    const pooledCacheLanes = root.pooledCacheLanes &= remainingLanes;
+
+    if (pooledCacheLanes === NoLanes) {
+      // None of the remaining work relies on the cache pool. Clear it so
+      // subsequent requests get a new cache
+      const pooledCache = root.pooledCache;
+
+      if (pooledCache != null) {
+        root.pooledCache = null;
+        releaseCache(pooledCache);
+      }
+    }
+  }
+}
+
+function flushPassiveEffects() {
+  // Returns whether passive effects were flushed.
+  // TODO: Combine this check with the one in flushPassiveEFfectsImpl. We should
+  // probably just combine the two functions. I believe they were only separate
+  // in the first place because we used to wrap it with
+  // `Scheduler.runWithPriority`, which accepts a function. But now we track the
+  // priority within React itself, so we can mutate the variable directly.
+  if (rootWithPendingPassiveEffects !== null) {
+    // Cache the root since rootWithPendingPassiveEffects is cleared in
+    // flushPassiveEffectsImpl
+    const root = rootWithPendingPassiveEffects; // Cache and clear the remaining lanes flag; it must be reset since this
+    // method can be called from various places, not always from commitRoot
+    // where the remaining lanes are known
+
+    const remainingLanes = pendingPassiveEffectsRemainingLanes;
+    pendingPassiveEffectsRemainingLanes = NoLanes;
+    const renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
+    const priority = lowerEventPriority(DefaultEventPriority, renderPriority);
+    const prevTransition = ReactCurrentBatchConfig$1.transition;
+    const previousPriority = getCurrentUpdatePriority();
+
+    try {
+      ReactCurrentBatchConfig$1.transition = null;
+      setCurrentUpdatePriority(priority);
+      return flushPassiveEffectsImpl();
+    } finally {
+      setCurrentUpdatePriority(previousPriority);
+      ReactCurrentBatchConfig$1.transition = prevTransition; // Once passive effects have run for the tree - giving components a
+      // chance to retain cache instances they use - release the pooled
+      // cache at the root (if there is one)
+
+      releaseRootPooledCache(root, remainingLanes);
+    }
+  }
+
+  return false;
+}
+
+function flushPassiveEffectsImpl() {
+  if (rootWithPendingPassiveEffects === null) {
+    return false;
+  } // Cache and clear the transitions flag
+
+
+  const transitions = pendingPassiveTransitions;
+  pendingPassiveTransitions = null;
+  const root = rootWithPendingPassiveEffects;
+  const lanes = pendingPassiveEffectsLanes;
+  rootWithPendingPassiveEffects = null; // TODO: This is sometimes out of sync with rootWithPendingPassiveEffects.
+  // Figure out why and fix it. It's not causing any known issues (probably
+  // because it's only used for profiling), but it's a refactor hazard.
+
+  pendingPassiveEffectsLanes = NoLanes;
+
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw Error(formatProdErrorMessage(331));
+  }
+
+  const prevExecutionContext = executionContext;
+  executionContext |= CommitContext;
+  commitPassiveUnmountEffects(root.current);
+  commitPassiveMountEffects(root, root.current, lanes, transitions); // TODO: Move to commitPassiveMountEffects
+
+  executionContext = prevExecutionContext;
+  flushSyncWorkOnAllRoots();
+
+
+  onPostCommitRoot(root);
+
+  return true;
+}
+
+function isAlreadyFailedLegacyErrorBoundary(instance) {
+  return legacyErrorBoundariesThatAlreadyFailed !== null && legacyErrorBoundariesThatAlreadyFailed.has(instance);
+}
+function markLegacyErrorBoundaryAsFailed(instance) {
+  if (legacyErrorBoundariesThatAlreadyFailed === null) {
+    legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);
+  } else {
+    legacyErrorBoundariesThatAlreadyFailed.add(instance);
+  }
+}
+
+function prepareToThrowUncaughtError(error) {
+  if (!hasUncaughtError) {
+    hasUncaughtError = true;
+    firstUncaughtError = error;
+  }
+}
+
+const onUncaughtError = prepareToThrowUncaughtError;
+
+function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
+  const errorInfo = createCapturedValueAtFiber(error, sourceFiber);
+  const update = createRootErrorUpdate(rootFiber, errorInfo, SyncLane);
+  const root = enqueueUpdate(rootFiber, update, SyncLane);
+
+  if (root !== null) {
+    markRootUpdated(root, SyncLane);
+    ensureRootIsScheduled(root);
+  }
+}
+
+function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
+
+  if (sourceFiber.tag === HostRoot) {
+    // Error was thrown at the root. There is no parent, so the root
+    // itself should capture it.
+    captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
+    return;
+  }
+
+  let fiber = nearestMountedAncestor;
+
+  while (fiber !== null) {
+    if (fiber.tag === HostRoot) {
+      captureCommitPhaseErrorOnRoot(fiber, sourceFiber, error);
+      return;
+    } else if (fiber.tag === ClassComponent) {
+      const ctor = fiber.type;
+      const instance = fiber.stateNode;
+
+      if (typeof ctor.getDerivedStateFromError === 'function' || typeof instance.componentDidCatch === 'function' && !isAlreadyFailedLegacyErrorBoundary(instance)) {
+        const errorInfo = createCapturedValueAtFiber(error, sourceFiber);
+        const update = createClassErrorUpdate(fiber, errorInfo, SyncLane);
+        const root = enqueueUpdate(fiber, update, SyncLane);
+
+        if (root !== null) {
+          markRootUpdated(root, SyncLane);
+          ensureRootIsScheduled(root);
+        }
+
+        return;
+      }
+    }
+
+    fiber = fiber.return;
+  }
+}
+function attachPingListener(root, wakeable, lanes) {
+  // Attach a ping listener
+  //
+  // The data might resolve before we have a chance to commit the fallback. Or,
+  // in the case of a refresh, we'll never commit a fallback. So we need to
+  // attach a listener now. When it resolves ("pings"), we can decide whether to
+  // try rendering the tree again.
+  //
+  // Only attach a listener if one does not already exist for the lanes
+  // we're currently rendering (which acts like a "thread ID" here).
+  //
+  // We only need to do this in concurrent mode. Legacy Suspense always
+  // commits fallbacks synchronously, so there are no pings.
+  let pingCache = root.pingCache;
+  let threadIDs;
+
+  if (pingCache === null) {
+    pingCache = root.pingCache = new PossiblyWeakMap();
+    threadIDs = new Set();
+    pingCache.set(wakeable, threadIDs);
+  } else {
+    threadIDs = pingCache.get(wakeable);
+
+    if (threadIDs === undefined) {
+      threadIDs = new Set();
+      pingCache.set(wakeable, threadIDs);
+    }
+  }
+
+  if (!threadIDs.has(lanes)) {
+    workInProgressRootDidAttachPingListener = true; // Memoize using the thread ID to prevent redundant listeners.
+
+    threadIDs.add(lanes);
+    const ping = pingSuspendedRoot.bind(null, root, wakeable, lanes);
+
+    wakeable.then(ping, ping);
+  }
+}
+
+function pingSuspendedRoot(root, wakeable, pingedLanes) {
+  const pingCache = root.pingCache;
+
+  if (pingCache !== null) {
+    // The wakeable resolved, so we no longer need to memoize, because it will
+    // never be thrown again.
+    pingCache.delete(wakeable);
+  }
+
+  markRootPinged(root, pingedLanes);
+
+  if (workInProgressRoot === root && isSubsetOfLanes(workInProgressRootRenderLanes, pingedLanes)) {
+    // Received a ping at the same priority level at which we're currently
+    // rendering. We might want to restart this render. This should mirror
+    // the logic of whether or not a root suspends once it completes.
+    // TODO: If we're rendering sync either due to Sync, Batched or expired,
+    // we should probably never restart.
+    // If we're suspended with delay, or if it's a retry, we'll always suspend
+    // so we can always restart.
+    if (workInProgressRootExitStatus === RootSuspendedWithDelay || workInProgressRootExitStatus === RootSuspended && includesOnlyRetries(workInProgressRootRenderLanes) && now() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS) {
+      // Force a restart from the root by unwinding the stack. Unless this is
+      // being called from the render phase, because that would cause a crash.
+      if ((executionContext & RenderContext) === NoContext) {
+        prepareFreshStack(root, NoLanes);
+      }
+    } else {
+      // Even though we can't restart right now, we might get an
+      // opportunity later. So we mark this render as having a ping.
+      workInProgressRootPingedLanes = mergeLanes(workInProgressRootPingedLanes, pingedLanes);
+    }
+  }
+
+  ensureRootIsScheduled(root);
+}
+
+function retryTimedOutBoundary(boundaryFiber, retryLane) {
+  // The boundary fiber (a Suspense component or SuspenseList component)
+  // previously was rendered in its fallback state. One of the promises that
+  // suspended it has resolved, which means at least part of the tree was
+  // likely unblocked. Try rendering again, at a new lanes.
+  if (retryLane === NoLane) {
+    // TODO: Assign this to `suspenseState.retryLane`? to avoid
+    // unnecessary entanglement?
+    retryLane = requestRetryLane(boundaryFiber);
+  } // TODO: Special case idle priority?
+
+
+  const root = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
+
+  if (root !== null) {
+    markRootUpdated(root, retryLane);
+    ensureRootIsScheduled(root);
+  }
+}
+
+function retryDehydratedSuspenseBoundary(boundaryFiber) {
+  const suspenseState = boundaryFiber.memoizedState;
+  let retryLane = NoLane;
+
+  if (suspenseState !== null) {
+    retryLane = suspenseState.retryLane;
+  }
+
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+}
+function resolveRetryWakeable(boundaryFiber, wakeable) {
+  let retryLane = NoLane; // Default
+
+  let retryCache;
+
+  switch (boundaryFiber.tag) {
+    case SuspenseComponent:
+      retryCache = boundaryFiber.stateNode;
+      const suspenseState = boundaryFiber.memoizedState;
+
+      if (suspenseState !== null) {
+        retryLane = suspenseState.retryLane;
+      }
+
+      break;
+
+    case SuspenseListComponent:
+      retryCache = boundaryFiber.stateNode;
+      break;
+
+    case OffscreenComponent:
+      {
+        const instance = boundaryFiber.stateNode;
+        retryCache = instance._retryCache;
+        break;
+      }
+
+    default:
+      throw Error(formatProdErrorMessage(314));
+  }
+
+  if (retryCache !== null) {
+    // The wakeable resolved, so we no longer need to memoize, because it will
+    // never be thrown again.
+    retryCache.delete(wakeable);
+  }
+
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+}
+function throwIfInfiniteUpdateLoopDetected() {
+  if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
+    nestedUpdateCount = 0;
+    rootWithNestedUpdates = null;
+    throw Error(formatProdErrorMessage(185));
+  }
+}
+let beginWork;
+
+{
+  beginWork = beginWork$1;
+}
+
+function scheduleCallback(priorityLevel, callback) {
+  {
+    // In production, always call Scheduler. This function will be stripped out.
+    return scheduleCallback$3(priorityLevel, callback);
+  }
+}
+
+function FiberNode(tag, pendingProps, key, mode) {
+  // Instance
+  this.tag = tag;
+  this.key = key;
+  this.elementType = null;
+  this.type = null;
+  this.stateNode = null; // Fiber
+
+  this.return = null;
+  this.child = null;
+  this.sibling = null;
+  this.index = 0;
+  this.ref = null;
+  this.refCleanup = null;
+  this.pendingProps = pendingProps;
+  this.memoizedProps = null;
+  this.updateQueue = null;
+  this.memoizedState = null;
+  this.dependencies = null;
+  this.mode = mode; // Effects
+
+  this.flags = NoFlags$1;
+  this.subtreeFlags = NoFlags$1;
+  this.deletions = null;
+  this.lanes = NoLanes;
+  this.childLanes = NoLanes;
+  this.alternate = null;
+} // This is a constructor function, rather than a POJO constructor, still
+// please ensure we do the following:
+// 1) Nobody should add any instance methods on this. Instance methods can be
+//    more difficult to predict when they get optimized and they are almost
+//    never inlined properly in static compilers.
+// 2) Nobody should rely on `instanceof Fiber` for type testing. We should
+//    always know when it is a fiber.
+// 3) We might want to experiment with using numeric keys since they are easier
+//    to optimize in a non-JIT environment.
+// 4) We can easily go from a constructor to a createFiber object literal if that
+//    is faster.
+// 5) It should be easy to port this to a C struct and keep a C implementation
+//    compatible.
+
+
+function createFiber(tag, pendingProps, key, mode) {
+  // $FlowFixMe[invalid-constructor]: the shapes are exact here but Flow doesn't like constructors
+  return new FiberNode(tag, pendingProps, key, mode);
+}
+
+function shouldConstruct(Component) {
+  const prototype = Component.prototype;
+  return !!(prototype && prototype.isReactComponent);
+}
+
+function isSimpleFunctionComponent(type) {
+  return typeof type === 'function' && !shouldConstruct(type) && type.defaultProps === undefined;
+}
+function resolveLazyComponentTag(Component) {
+  if (typeof Component === 'function') {
+    return shouldConstruct(Component) ? ClassComponent : FunctionComponent;
+  } else if (Component !== undefined && Component !== null) {
+    const $$typeof = Component.$$typeof;
+
+    if ($$typeof === REACT_FORWARD_REF_TYPE) {
+      return ForwardRef;
+    }
+
+    if ($$typeof === REACT_MEMO_TYPE) {
+      return MemoComponent;
+    }
+  }
+
+  return IndeterminateComponent;
+} // This is used to create an alternate fiber to do work on.
+
+function createWorkInProgress(current, pendingProps) {
+  let workInProgress = current.alternate;
+
+  if (workInProgress === null) {
+    // We use a double buffering pooling technique because we know that we'll
+    // only ever need at most two versions of a tree. We pool the "other" unused
+    // node that we're free to reuse. This is lazily created to avoid allocating
+    // extra objects for things that are never updated. It also allow us to
+    // reclaim the extra memory if needed.
+    workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode);
+    workInProgress.elementType = current.elementType;
+    workInProgress.type = current.type;
+    workInProgress.stateNode = current.stateNode;
+
+    workInProgress.alternate = current;
+    current.alternate = workInProgress;
+  } else {
+    workInProgress.pendingProps = pendingProps; // Needed because Blocks store data on type.
+
+    workInProgress.type = current.type; // We already have an alternate.
+    // Reset the effect tag.
+
+    workInProgress.flags = NoFlags$1; // The effects are no longer valid.
+
+    workInProgress.subtreeFlags = NoFlags$1;
+    workInProgress.deletions = null;
+  } // Reset all effects except static ones.
+  // Static effects are not specific to a render.
+
+
+  workInProgress.flags = current.flags & StaticMask;
+  workInProgress.childLanes = current.childLanes;
+  workInProgress.lanes = current.lanes;
+  workInProgress.child = current.child;
+  workInProgress.memoizedProps = current.memoizedProps;
+  workInProgress.memoizedState = current.memoizedState;
+  workInProgress.updateQueue = current.updateQueue; // Clone the dependencies object. This is mutated during the render phase, so
+  // it cannot be shared with the current fiber.
+
+  const currentDependencies = current.dependencies;
+  workInProgress.dependencies = currentDependencies === null ? null : {
+    lanes: currentDependencies.lanes,
+    firstContext: currentDependencies.firstContext
+  }; // These will be overridden during the parent's reconciliation
+
+  workInProgress.sibling = current.sibling;
+  workInProgress.index = current.index;
+  workInProgress.ref = current.ref;
+  workInProgress.refCleanup = current.refCleanup;
+
+  return workInProgress;
+} // Used to reuse a Fiber for a second pass.
+
+function resetWorkInProgress(workInProgress, renderLanes) {
+  // This resets the Fiber to what createFiber or createWorkInProgress would
+  // have set the values to before during the first pass. Ideally this wouldn't
+  // be necessary but unfortunately many code paths reads from the workInProgress
+  // when they should be reading from current and writing to workInProgress.
+  // We assume pendingProps, index, key, ref, return are still untouched to
+  // avoid doing another reconciliation.
+  // Reset the effect flags but keep any Placement tags, since that's something
+  // that child fiber is setting, not the reconciliation.
+  workInProgress.flags &= StaticMask | Placement; // The effects are no longer valid.
+
+  const current = workInProgress.alternate;
+
+  if (current === null) {
+    // Reset to createFiber's initial values.
+    workInProgress.childLanes = NoLanes;
+    workInProgress.lanes = renderLanes;
+    workInProgress.child = null;
+    workInProgress.subtreeFlags = NoFlags$1;
+    workInProgress.memoizedProps = null;
+    workInProgress.memoizedState = null;
+    workInProgress.updateQueue = null;
+    workInProgress.dependencies = null;
+    workInProgress.stateNode = null;
+  } else {
+    // Reset to the cloned values that createWorkInProgress would've.
+    workInProgress.childLanes = current.childLanes;
+    workInProgress.lanes = current.lanes;
+    workInProgress.child = current.child;
+    workInProgress.subtreeFlags = NoFlags$1;
+    workInProgress.deletions = null;
+    workInProgress.memoizedProps = current.memoizedProps;
+    workInProgress.memoizedState = current.memoizedState;
+    workInProgress.updateQueue = current.updateQueue; // Needed because Blocks store data on type.
+
+    workInProgress.type = current.type; // Clone the dependencies object. This is mutated during the render phase, so
+    // it cannot be shared with the current fiber.
+
+    const currentDependencies = current.dependencies;
+    workInProgress.dependencies = currentDependencies === null ? null : {
+      lanes: currentDependencies.lanes,
+      firstContext: currentDependencies.firstContext
+    };
+  }
+
+  return workInProgress;
+}
+function createHostRootFiber(tag, isStrictMode, concurrentUpdatesByDefaultOverride) {
+  let mode;
+
+  if (tag === ConcurrentRoot) {
+    mode = ConcurrentMode;
+
+    if (isStrictMode === true || createRootStrictEffectsByDefault) {
+      mode |= StrictLegacyMode | StrictEffectsMode;
+    }
+  } else {
+    mode = NoMode;
+  }
+
+  return createFiber(HostRoot, null, null, mode);
+}
+function createFiberFromTypeAndProps(type, // React$ElementType
+key, pendingProps, source, owner, mode, lanes) {
+  let fiberTag = IndeterminateComponent; // The resolved type is set if we know what the final type will be. I.e. it's not lazy.
+
+  let resolvedType = type;
+
+  if (typeof type === 'function') {
+    if (shouldConstruct(type)) {
+      fiberTag = ClassComponent;
+    }
+  } else if (typeof type === 'string') {
+    {
+      const hostContext = getHostContext();
+      fiberTag = isHostHoistableType(type, pendingProps, hostContext) ? HostHoistable : isHostSingletonType(type) ? HostSingleton : HostComponent;
+    }
+  } else {
+    getTag: switch (type) {
+      case REACT_FRAGMENT_TYPE:
+        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
+
+      case REACT_STRICT_MODE_TYPE:
+        fiberTag = Mode;
+        mode |= StrictLegacyMode;
+
+        if ((mode & ConcurrentMode) !== NoMode) {
+          // Strict effects should never run on legacy roots
+          mode |= StrictEffectsMode;
+        }
+
+        break;
+
+      case REACT_PROFILER_TYPE:
+        return createFiberFromProfiler(pendingProps, mode, lanes, key);
+
+      case REACT_SUSPENSE_TYPE:
+        return createFiberFromSuspense(pendingProps, mode, lanes, key);
+
+      case REACT_SUSPENSE_LIST_TYPE:
+        return createFiberFromSuspenseList(pendingProps, mode, lanes, key);
+
+      case REACT_OFFSCREEN_TYPE:
+        return createFiberFromOffscreen(pendingProps, mode, lanes, key);
+
+      case REACT_LEGACY_HIDDEN_TYPE:
+
+      // Fall through
+
+      case REACT_SCOPE_TYPE:
+
+      // Fall through
+
+      case REACT_CACHE_TYPE:
+        {
+          return createFiberFromCache(pendingProps, mode, lanes, key);
+        }
+
+      // Fall through
+
+      case REACT_TRACING_MARKER_TYPE:
+
+      // Fall through
+
+      case REACT_DEBUG_TRACING_MODE_TYPE:
+
+      // Fall through
+
+      default:
+        {
+          if (typeof type === 'object' && type !== null) {
+            switch (type.$$typeof) {
+              case REACT_PROVIDER_TYPE:
+                fiberTag = ContextProvider;
+                break getTag;
+
+              case REACT_CONTEXT_TYPE:
+                // This is a consumer
+                fiberTag = ContextConsumer;
+                break getTag;
+
+              case REACT_FORWARD_REF_TYPE:
+                fiberTag = ForwardRef;
+
+                break getTag;
+
+              case REACT_MEMO_TYPE:
+                fiberTag = MemoComponent;
+                break getTag;
+
+              case REACT_LAZY_TYPE:
+                fiberTag = LazyComponent;
+                resolvedType = null;
+                break getTag;
+            }
+          }
+
+          let info = '';
+
+          throw Error(formatProdErrorMessage(130, type == null ? type : typeof type, info));
+        }
+    }
+  }
+
+  const fiber = createFiber(fiberTag, pendingProps, key, mode);
+  fiber.elementType = type;
+  fiber.type = resolvedType;
+  fiber.lanes = lanes;
+
+  return fiber;
+}
+function createFiberFromElement(element, mode, lanes) {
+  let source = null;
+  let owner = null;
+
+  const type = element.type;
+  const key = element.key;
+  const pendingProps = element.props;
+  const fiber = createFiberFromTypeAndProps(type, key, pendingProps, source, owner, mode, lanes);
+
+  return fiber;
+}
+function createFiberFromFragment(elements, mode, lanes, key) {
+  const fiber = createFiber(Fragment, elements, key, mode);
+  fiber.lanes = lanes;
+  return fiber;
+}
+
+function createFiberFromProfiler(pendingProps, mode, lanes, key) {
+
+  const fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);
+  fiber.elementType = REACT_PROFILER_TYPE;
+  fiber.lanes = lanes;
+
+  return fiber;
+}
+
+function createFiberFromSuspense(pendingProps, mode, lanes, key) {
+  const fiber = createFiber(SuspenseComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_SUSPENSE_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromSuspenseList(pendingProps, mode, lanes, key) {
+  const fiber = createFiber(SuspenseListComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_SUSPENSE_LIST_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
+  const fiber = createFiber(OffscreenComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_OFFSCREEN_TYPE;
+  fiber.lanes = lanes;
+  const primaryChildInstance = {
+    _visibility: OffscreenVisible,
+    _pendingVisibility: OffscreenVisible,
+    _pendingMarkers: null,
+    _retryCache: null,
+    _transitions: null,
+    _current: null,
+    detach: () => detachOffscreenInstance(primaryChildInstance),
+    attach: () => attachOffscreenInstance(primaryChildInstance)
+  };
+  fiber.stateNode = primaryChildInstance;
+  return fiber;
+}
+function createFiberFromCache(pendingProps, mode, lanes, key) {
+  const fiber = createFiber(CacheComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_CACHE_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromText(content, mode, lanes) {
+  const fiber = createFiber(HostText, content, null, mode);
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromHostInstanceForDeletion() {
+  const fiber = createFiber(HostComponent, null, null, NoMode);
+  fiber.elementType = 'DELETED';
+  return fiber;
+}
+function createFiberFromDehydratedFragment(dehydratedNode) {
+  const fiber = createFiber(DehydratedFragment, null, null, NoMode);
+  fiber.stateNode = dehydratedNode;
+  return fiber;
+}
+function createFiberFromPortal(portal, mode, lanes) {
+  const pendingProps = portal.children !== null ? portal.children : [];
+  const fiber = createFiber(HostPortal, pendingProps, portal.key, mode);
+  fiber.lanes = lanes;
+  fiber.stateNode = {
+    containerInfo: portal.containerInfo,
+    pendingChildren: null,
+    // Used by persistent updates
+    implementation: portal.implementation
+  };
+  return fiber;
+} // Used for stashing WIP properties to replay failed work in DEV.
+
+function FiberRootNode(containerInfo, // $FlowFixMe[missing-local-annot]
+tag, hydrate, identifierPrefix, onRecoverableError, formState) {
+  this.tag = tag;
+  this.containerInfo = containerInfo;
+  this.pendingChildren = null;
+  this.current = null;
+  this.pingCache = null;
+  this.finishedWork = null;
+  this.timeoutHandle = noTimeout;
+  this.cancelPendingCommit = null;
+  this.context = null;
+  this.pendingContext = null;
+  this.next = null;
+  this.callbackNode = null;
+  this.callbackPriority = NoLane;
+  this.expirationTimes = createLaneMap(NoTimestamp);
+  this.pendingLanes = NoLanes;
+  this.suspendedLanes = NoLanes;
+  this.pingedLanes = NoLanes;
+  this.expiredLanes = NoLanes;
+  this.finishedLanes = NoLanes;
+  this.errorRecoveryDisabledLanes = NoLanes;
+  this.shellSuspendCounter = 0;
+  this.entangledLanes = NoLanes;
+  this.entanglements = createLaneMap(NoLanes);
+  this.hiddenUpdates = createLaneMap(null);
+  this.identifierPrefix = identifierPrefix;
+  this.onRecoverableError = onRecoverableError;
+
+  {
+    this.pooledCache = null;
+    this.pooledCacheLanes = NoLanes;
+  }
+
+  this.formState = formState;
+  this.incompleteTransitions = new Map();
+}
+
+function createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, // TODO: We have several of these arguments that are conceptually part of the
+// host config, but because they are passed in at runtime, we have to thread
+// them through the root constructor. Perhaps we should put them all into a
+// single type, like a DynamicHostConfig that is defined by the renderer.
+identifierPrefix, onRecoverableError, transitionCallbacks, formState) {
+  // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
+  const root = new FiberRootNode(containerInfo, tag, hydrate, identifierPrefix, onRecoverableError, formState);
+  // stateNode is any.
+
+
+  const uninitializedFiber = createHostRootFiber(tag, isStrictMode);
+  root.current = uninitializedFiber;
+  uninitializedFiber.stateNode = root;
+
+  {
+    const initialCache = createCache();
+    retainCache(initialCache); // The pooledCache is a fresh cache instance that is used temporarily
+    // for newly mounted boundaries during a render. In general, the
+    // pooledCache is always cleared from the root at the end of a render:
+    // it is either released when render commits, or moved to an Offscreen
+    // component if rendering suspends. Because the lifetime of the pooled
+    // cache is distinct from the main memoizedState.cache, it must be
+    // retained separately.
+
+    root.pooledCache = initialCache;
+    retainCache(initialCache);
+    const initialState = {
+      element: initialChildren,
+      isDehydrated: hydrate,
+      cache: initialCache
+    };
+    uninitializedFiber.memoizedState = initialState;
+  }
+
+  initializeUpdateQueue(uninitializedFiber);
+  return root;
+}
+
+var ReactVersion = '18.3.0-experimental-7508dcd5c-20231108';
+
+function createPortal$1(children, containerInfo, // TODO: figure out the API for cross-renderer implementation.
+implementation) {
+  let key = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+
+  return {
+    // This tag allow us to uniquely identify this as a React Portal
+    $$typeof: REACT_PORTAL_TYPE,
+    key: key == null ? null : '' + key,
+    children,
+    containerInfo,
+    implementation
+  };
+}
+
+function getContextForSubtree(parentComponent) {
+  if (!parentComponent) {
+    return emptyContextObject;
+  }
+
+  const fiber = get(parentComponent);
+  const parentContext = findCurrentUnmaskedContext(fiber);
+
+  if (fiber.tag === ClassComponent) {
+    const Component = fiber.type;
+
+    if (isContextProvider(Component)) {
+      return processChildContext(fiber, Component, parentContext);
+    }
+  }
+
+  return parentContext;
+}
+
+function findHostInstance(component) {
+  const fiber = get(component);
+
+  if (fiber === undefined) {
+    if (typeof component.render === 'function') {
+      throw Error(formatProdErrorMessage(188));
+    } else {
+      const keys = Object.keys(component).join(',');
+      throw Error(formatProdErrorMessage(268, keys));
+    }
+  }
+
+  const hostFiber = findCurrentHostFiber(fiber);
+
+  if (hostFiber === null) {
+    return null;
+  }
+
+  return getPublicInstance(hostFiber.stateNode);
+}
+
+function createContainer(containerInfo, tag, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks) {
+  const hydrate = false;
+  const initialChildren = null;
+  return createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks, null);
+}
+function createHydrationContainer(initialChildren, // TODO: Remove `callback` when we delete legacy mode.
+callback, containerInfo, tag, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks, formState) {
+  const hydrate = true;
+  const root = createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks, formState); // TODO: Move this to FiberRoot constructor
+
+  root.context = getContextForSubtree(null); // Schedule the initial render. In a hydration root, this is different from
+  // a regular update because the initial render must match was was rendered
+  // on the server.
+  // NOTE: This update intentionally doesn't have a payload. We're only using
+  // the update to schedule work on the root fiber (and, for legacy roots, to
+  // enqueue the callback if one is provided).
+
+  const current = root.current;
+  const lane = requestUpdateLane(current);
+  const update = createUpdate(lane);
+  update.callback = callback !== undefined && callback !== null ? callback : null;
+  enqueueUpdate(current, update, lane);
+  scheduleInitialHydrationOnRoot(root, lane);
+  return root;
+}
+function updateContainer(element, container, parentComponent, callback) {
+
+  const current = container.current;
+  const lane = requestUpdateLane(current);
+
+  const context = getContextForSubtree(parentComponent);
+
+  if (container.context === null) {
+    container.context = context;
+  } else {
+    container.pendingContext = context;
+  }
+
+  const update = createUpdate(lane); // Caution: React DevTools currently depends on this property
+  // being called "element".
+
+  update.payload = {
+    element
+  };
+  callback = callback === undefined ? null : callback;
+
+  if (callback !== null) {
+
+    update.callback = callback;
+  }
+
+  const root = enqueueUpdate(current, update, lane);
+
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, current, lane);
+    entangleTransitions(root, current, lane);
+  }
+
+  return lane;
+}
+function getPublicRootInstance(container) {
+  const containerFiber = container.current;
+
+  if (!containerFiber.child) {
+    return null;
+  }
+
+  switch (containerFiber.child.tag) {
+    case HostSingleton:
+    case HostComponent:
+      return getPublicInstance(containerFiber.child.stateNode);
+
+    default:
+      return containerFiber.child.stateNode;
+  }
+}
+function attemptSynchronousHydration(fiber) {
+  switch (fiber.tag) {
+    case HostRoot:
+      {
+        const root = fiber.stateNode;
+
+        if (isRootDehydrated(root)) {
+          // Flush the first scheduled "update".
+          const lanes = getHighestPriorityPendingLanes(root);
+          flushRoot(root, lanes);
+        }
+
+        break;
+      }
+
+    case SuspenseComponent:
+      {
+        flushSync$1(() => {
+          const root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+          if (root !== null) {
+            scheduleUpdateOnFiber(root, fiber, SyncLane);
+          }
+        }); // If we're still blocked after this, we need to increase
+        // the priority of any promises resolving within this
+        // boundary so that they next attempt also has higher pri.
+
+        const retryLane = SyncLane;
+        markRetryLaneIfNotHydrated(fiber, retryLane);
+        break;
+      }
+  }
+}
+
+function markRetryLaneImpl(fiber, retryLane) {
+  const suspenseState = fiber.memoizedState;
+
+  if (suspenseState !== null && suspenseState.dehydrated !== null) {
+    suspenseState.retryLane = higherPriorityLane(suspenseState.retryLane, retryLane);
+  }
+} // Increases the priority of thenables when they resolve within this boundary.
+
+
+function markRetryLaneIfNotHydrated(fiber, retryLane) {
+  markRetryLaneImpl(fiber, retryLane);
+  const alternate = fiber.alternate;
+
+  if (alternate) {
+    markRetryLaneImpl(alternate, retryLane);
+  }
+}
+
+function attemptContinuousHydration(fiber) {
+  if (fiber.tag !== SuspenseComponent) {
+    // We ignore HostRoots here because we can't increase
+    // their priority and they should not suspend on I/O,
+    // since you have to wrap anything that might suspend in
+    // Suspense.
+    return;
+  }
+
+  const lane = SelectiveHydrationLane;
+  const root = enqueueConcurrentRenderForLane(fiber, lane);
+
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, fiber, lane);
+  }
+
+  markRetryLaneIfNotHydrated(fiber, lane);
+}
+function attemptHydrationAtCurrentPriority(fiber) {
+  if (fiber.tag !== SuspenseComponent) {
+    // We ignore HostRoots here because we can't increase
+    // their priority other than synchronously flush it.
+    return;
+  }
+
+  const lane = requestUpdateLane(fiber);
+  const root = enqueueConcurrentRenderForLane(fiber, lane);
+
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, fiber, lane);
+  }
+
+  markRetryLaneIfNotHydrated(fiber, lane);
+}
+let overrideHookState = null;
+let overrideHookStateDeletePath = null;
+let overrideHookStateRenamePath = null;
+let overrideProps = null;
+let overridePropsDeletePath = null;
+let overridePropsRenamePath = null;
+let scheduleUpdate = null;
+let setErrorHandler = null;
+let setSuspenseHandler = null;
+
+function findHostInstanceByFiber(fiber) {
+  const hostFiber = findCurrentHostFiber(fiber);
+
+  if (hostFiber === null) {
+    return null;
+  }
+
+  return hostFiber.stateNode;
+}
+
+function emptyFindFiberByHostInstance(instance) {
+  return null;
+}
+
+function injectIntoDevTools(devToolsConfig) {
+  const findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
+  const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+  return injectInternals({
+    bundleType: devToolsConfig.bundleType,
+    version: devToolsConfig.version,
+    rendererPackageName: devToolsConfig.rendererPackageName,
+    rendererConfig: devToolsConfig.rendererConfig,
+    overrideHookState,
+    overrideHookStateDeletePath,
+    overrideHookStateRenamePath,
+    overrideProps,
+    overridePropsDeletePath,
+    overridePropsRenamePath,
+    setErrorHandler,
+    setSuspenseHandler,
+    scheduleUpdate,
+    currentDispatcherRef: ReactCurrentDispatcher,
+    findHostInstanceByFiber,
+    findFiberByHostInstance: findFiberByHostInstance || emptyFindFiberByHostInstance,
+    // React Refresh
+    findHostInstancesForRefresh: null,
+    scheduleRefresh: null,
+    scheduleRoot: null,
+    setRefreshHandler: null,
+    // Enables DevTools to append owner stacks to error messages in DEV mode.
+    getCurrentFiber: null,
+    // Enables DevTools to detect reconciler version rather than renderer version
+    // which may not match for third party renderers.
+    reconcilerVersion: ReactVersion
+  });
+}
+
+// the renderer. Such as when we're dispatching events or if third party
+// libraries need to call batchedUpdates. Eventually, this API will go away when
+// everything is batched by default. We'll then have a similar API to opt-out of
+// scheduled work and instead do synchronous work.
+
+let isInsideEventHandler = false;
+
+function finishEventHandler() {
+  // Here we wait until all updates have propagated, which is important
+  // when using controlled components within layers:
+  // https://github.com/facebook/react/issues/1698
+  // Then we restore state of any controlled component.
+  const controlledComponentsHavePendingUpdates = needsStateRestore();
+
+  if (controlledComponentsHavePendingUpdates) {
+    // If a controlled event was fired, we may need to restore the state of
+    // the DOM node back to the controlled value. This is necessary when React
+    // bails out of the update without touching the DOM.
+    // TODO: Restore state in the microtask, after the discrete updates flush,
+    // instead of early flushing them here.
+    flushSync$1();
+    restoreStateIfNeeded();
+  }
+}
+
+function batchedUpdates(fn, a, b) {
+  if (isInsideEventHandler) {
+    // If we are currently inside another batch, we need to wait until it
+    // fully completes before restoring state.
+    return fn(a, b);
+  }
+
+  isInsideEventHandler = true;
+
+  try {
+    return batchedUpdates$1(fn, a, b);
+  } finally {
+    isInsideEventHandler = false;
+    finishEventHandler();
+  }
+} // TODO: Replace with flushSync
+
+function isInteractive(tag) {
+  return tag === 'button' || tag === 'input' || tag === 'select' || tag === 'textarea';
+}
+
+function shouldPreventMouseEvent(name, type, props) {
+  switch (name) {
+    case 'onClick':
+    case 'onClickCapture':
+    case 'onDoubleClick':
+    case 'onDoubleClickCapture':
+    case 'onMouseDown':
+    case 'onMouseDownCapture':
+    case 'onMouseMove':
+    case 'onMouseMoveCapture':
+    case 'onMouseUp':
+    case 'onMouseUpCapture':
+    case 'onMouseEnter':
+      return !!(props.disabled && isInteractive(type));
+
+    default:
+      return false;
+  }
+}
+/**
+ * @param {object} inst The instance, which is the source of events.
+ * @param {string} registrationName Name of listener (e.g. `onClick`).
+ * @return {?function} The stored callback.
+ */
+
+
+function getListener(inst, registrationName) {
+  const stateNode = inst.stateNode;
+
+  if (stateNode === null) {
+    // Work in progress (ex: onload events in incremental mode).
+    return null;
+  }
+
+  const props = getFiberCurrentPropsFromNode(stateNode);
+
+  if (props === null) {
+    // Work in progress.
+    return null;
+  }
+
+  const listener = props[registrationName];
+
+  if (shouldPreventMouseEvent(registrationName, inst.type, props)) {
+    return null;
+  }
+
+  if (listener && typeof listener !== 'function') {
+    throw Error(formatProdErrorMessage(231, registrationName, typeof listener));
+  }
+
+  return listener;
+}
+
+let passiveBrowserEventsSupported = false; // Check if browser support events with passive listeners
+// https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support
+
+if (canUseDOM) {
+  try {
+    const options = {};
+    Object.defineProperty(options, 'passive', {
+      get: function () {
+        passiveBrowserEventsSupported = true;
+      }
+    });
+    window.addEventListener('test', options, options);
+    window.removeEventListener('test', options, options);
+  } catch (e) {
+    passiveBrowserEventsSupported = false;
+  }
+}
+
+/**
+ * `charCode` represents the actual "character code" and is safe to use with
+ * `String.fromCharCode`. As such, only keys that correspond to printable
+ * characters produce a valid `charCode`, the only exception to this is Enter.
+ * The Tab-key is considered non-printable and does not have a `charCode`,
+ * presumably because it does not produce a tab-character in browsers.
+ *
+ * @param {object} nativeEvent Native browser event.
+ * @return {number} Normalized `charCode` property.
+ */
+function getEventCharCode(nativeEvent) {
+  let charCode;
+  const keyCode = nativeEvent.keyCode;
+
+  if ('charCode' in nativeEvent) {
+    charCode = nativeEvent.charCode; // FF does not set `charCode` for the Enter-key, check against `keyCode`.
+
+    if (charCode === 0 && keyCode === 13) {
+      charCode = 13;
+    }
+  } else {
+    // IE8 does not implement `charCode`, but `keyCode` has the correct value.
+    charCode = keyCode;
+  } // IE and Edge (on Windows) and Chrome / Safari (on Windows and Linux)
+  // report Enter as charCode 10 when ctrl is pressed.
+
+
+  if (charCode === 10) {
+    charCode = 13;
+  } // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
+  // Must not discard the (non-)printable Enter-key.
+
+
+  if (charCode >= 32 || charCode === 13) {
+    return charCode;
+  }
+
+  return 0;
+}
+
+function functionThatReturnsTrue() {
+  return true;
+}
+
+function functionThatReturnsFalse() {
+  return false;
+} // This is intentionally a factory so that we have different returned constructors.
+// If we had a single constructor, it would be megamorphic and engines would deopt.
+
+
+function createSyntheticEvent(Interface) {
+  /**
+   * Synthetic events are dispatched by event plugins, typically in response to a
+   * top-level event delegation handler.
+   *
+   * These systems should generally use pooling to reduce the frequency of garbage
+   * collection. The system should check `isPersistent` to determine whether the
+   * event should be released into the pool after being dispatched. Users that
+   * need a persisted event should invoke `persist`.
+   *
+   * Synthetic events (and subclasses) implement the DOM Level 3 Events API by
+   * normalizing browser quirks. Subclasses do not necessarily have to implement a
+   * DOM interface; custom application-specific events can also subclass this.
+   */
+  // $FlowFixMe[missing-this-annot]
+  function SyntheticBaseEvent(reactName, reactEventType, targetInst, nativeEvent, nativeEventTarget) {
+    this._reactName = reactName;
+    this._targetInst = targetInst;
+    this.type = reactEventType;
+    this.nativeEvent = nativeEvent;
+    this.target = nativeEventTarget;
+    this.currentTarget = null;
+
+    for (const propName in Interface) {
+      if (!Interface.hasOwnProperty(propName)) {
+        continue;
+      }
+
+      const normalize = Interface[propName];
+
+      if (normalize) {
+        this[propName] = normalize(nativeEvent);
+      } else {
+        this[propName] = nativeEvent[propName];
+      }
+    }
+
+    const defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
+
+    if (defaultPrevented) {
+      this.isDefaultPrevented = functionThatReturnsTrue;
+    } else {
+      this.isDefaultPrevented = functionThatReturnsFalse;
+    }
+
+    this.isPropagationStopped = functionThatReturnsFalse;
+    return this;
+  } // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+  assign(SyntheticBaseEvent.prototype, {
+    // $FlowFixMe[missing-this-annot]
+    preventDefault: function () {
+      this.defaultPrevented = true;
+      const event = this.nativeEvent;
+
+      if (!event) {
+        return;
+      }
+
+      if (event.preventDefault) {
+        event.preventDefault(); // $FlowFixMe[illegal-typeof] - flow is not aware of `unknown` in IE
+      } else if (typeof event.returnValue !== 'unknown') {
+        event.returnValue = false;
+      }
+
+      this.isDefaultPrevented = functionThatReturnsTrue;
+    },
+    // $FlowFixMe[missing-this-annot]
+    stopPropagation: function () {
+      const event = this.nativeEvent;
+
+      if (!event) {
+        return;
+      }
+
+      if (event.stopPropagation) {
+        event.stopPropagation(); // $FlowFixMe[illegal-typeof] - flow is not aware of `unknown` in IE
+      } else if (typeof event.cancelBubble !== 'unknown') {
+        // The ChangeEventPlugin registers a "propertychange" event for
+        // IE. This event does not support bubbling or cancelling, and
+        // any references to cancelBubble throw "Member not found".  A
+        // typeof check of "unknown" circumvents this issue (and is also
+        // IE specific).
+        event.cancelBubble = true;
+      }
+
+      this.isPropagationStopped = functionThatReturnsTrue;
+    },
+
+    /**
+     * We release all dispatched `SyntheticEvent`s after each event loop, adding
+     * them back into the pool. This allows a way to hold onto a reference that
+     * won't be added back into the pool.
+     */
+    persist: function () {// Modern event system doesn't use pooling.
+    },
+
+    /**
+     * Checks if this event should be released back into the pool.
+     *
+     * @return {boolean} True if this should not be released, false otherwise.
+     */
+    isPersistent: functionThatReturnsTrue
+  });
+  return SyntheticBaseEvent;
+}
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+
+const EventInterface = {
+  eventPhase: 0,
+  bubbles: 0,
+  cancelable: 0,
+  timeStamp: function (event) {
+    return event.timeStamp || Date.now();
+  },
+  defaultPrevented: 0,
+  isTrusted: 0
+};
+const SyntheticEvent = createSyntheticEvent(EventInterface);
+
+const UIEventInterface = assign({}, EventInterface, {
+  view: 0,
+  detail: 0
+});
+
+const SyntheticUIEvent = createSyntheticEvent(UIEventInterface);
+let lastMovementX;
+let lastMovementY;
+let lastMouseEvent;
+
+function updateMouseMovementPolyfillState(event) {
+  if (event !== lastMouseEvent) {
+    if (lastMouseEvent && event.type === 'mousemove') {
+      // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+      lastMovementX = event.screenX - lastMouseEvent.screenX; // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+
+      lastMovementY = event.screenY - lastMouseEvent.screenY;
+    } else {
+      lastMovementX = 0;
+      lastMovementY = 0;
+    }
+
+    lastMouseEvent = event;
+  }
+}
+/**
+ * @interface MouseEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+
+const MouseEventInterface = assign({}, UIEventInterface, {
+  screenX: 0,
+  screenY: 0,
+  clientX: 0,
+  clientY: 0,
+  pageX: 0,
+  pageY: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  altKey: 0,
+  metaKey: 0,
+  getModifierState: getEventModifierState,
+  button: 0,
+  buttons: 0,
+  relatedTarget: function (event) {
+    if (event.relatedTarget === undefined) return event.fromElement === event.srcElement ? event.toElement : event.fromElement;
+    return event.relatedTarget;
+  },
+  movementX: function (event) {
+    if ('movementX' in event) {
+      return event.movementX;
+    }
+
+    updateMouseMovementPolyfillState(event);
+    return lastMovementX;
+  },
+  movementY: function (event) {
+    if ('movementY' in event) {
+      return event.movementY;
+    } // Don't need to call updateMouseMovementPolyfillState() here
+    // because it's guaranteed to have already run when movementX
+    // was copied.
+
+
+    return lastMovementY;
+  }
+});
+
+const SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface);
+/**
+ * @interface DragEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+const DragEventInterface = assign({}, MouseEventInterface, {
+  dataTransfer: 0
+});
+
+const SyntheticDragEvent = createSyntheticEvent(DragEventInterface);
+/**
+ * @interface FocusEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+const FocusEventInterface = assign({}, UIEventInterface, {
+  relatedTarget: 0
+});
+
+const SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent
+ */
+
+const AnimationEventInterface = assign({}, EventInterface, {
+  animationName: 0,
+  elapsedTime: 0,
+  pseudoElement: 0
+});
+
+const SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/clipboard-apis/
+ */
+
+const ClipboardEventInterface = assign({}, EventInterface, {
+  clipboardData: function (event) {
+    return 'clipboardData' in event ? event.clipboardData : window.clipboardData;
+  }
+});
+
+const SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents
+ */
+
+const CompositionEventInterface = assign({}, EventInterface, {
+  data: 0
+});
+
+const SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105
+ *      /#events-inputevents
+ */
+// Happens to share the same list for now.
+
+const SyntheticInputEvent = SyntheticCompositionEvent;
+/**
+ * Normalization of deprecated HTML5 `key` values
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
+ */
+
+const normalizeKey = {
+  Esc: 'Escape',
+  Spacebar: ' ',
+  Left: 'ArrowLeft',
+  Up: 'ArrowUp',
+  Right: 'ArrowRight',
+  Down: 'ArrowDown',
+  Del: 'Delete',
+  Win: 'OS',
+  Menu: 'ContextMenu',
+  Apps: 'ContextMenu',
+  Scroll: 'ScrollLock',
+  MozPrintableKey: 'Unidentified'
+};
+/**
+ * Translation from legacy `keyCode` to HTML5 `key`
+ * Only special keys supported, all others depend on keyboard layout or browser
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
+ */
+
+const translateToKey = {
+  '8': 'Backspace',
+  '9': 'Tab',
+  '12': 'Clear',
+  '13': 'Enter',
+  '16': 'Shift',
+  '17': 'Control',
+  '18': 'Alt',
+  '19': 'Pause',
+  '20': 'CapsLock',
+  '27': 'Escape',
+  '32': ' ',
+  '33': 'PageUp',
+  '34': 'PageDown',
+  '35': 'End',
+  '36': 'Home',
+  '37': 'ArrowLeft',
+  '38': 'ArrowUp',
+  '39': 'ArrowRight',
+  '40': 'ArrowDown',
+  '45': 'Insert',
+  '46': 'Delete',
+  '112': 'F1',
+  '113': 'F2',
+  '114': 'F3',
+  '115': 'F4',
+  '116': 'F5',
+  '117': 'F6',
+  '118': 'F7',
+  '119': 'F8',
+  '120': 'F9',
+  '121': 'F10',
+  '122': 'F11',
+  '123': 'F12',
+  '144': 'NumLock',
+  '145': 'ScrollLock',
+  '224': 'Meta'
+};
+/**
+ * @param {object} nativeEvent Native browser event.
+ * @return {string} Normalized `key` property.
+ */
+
+function getEventKey(nativeEvent) {
+  if (nativeEvent.key) {
+    // Normalize inconsistent values reported by browsers due to
+    // implementations of a working draft specification.
+    // FireFox implements `key` but returns `MozPrintableKey` for all
+    // printable characters (normalized to `Unidentified`), ignore it.
+    const key = // $FlowFixMe[invalid-computed-prop] unable to index with a `mixed` value
+    normalizeKey[nativeEvent.key] || nativeEvent.key;
+
+    if (key !== 'Unidentified') {
+      return key;
+    }
+  } // Browser does not implement `key`, polyfill as much of it as we can.
+
+
+  if (nativeEvent.type === 'keypress') {
+    const charCode = getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
+    nativeEvent); // The enter-key is technically both printable and non-printable and can
+    // thus be captured by `keypress`, no other non-printable key should.
+
+    return charCode === 13 ? 'Enter' : String.fromCharCode(charCode);
+  }
+
+  if (nativeEvent.type === 'keydown' || nativeEvent.type === 'keyup') {
+    // While user keyboard layout determines the actual meaning of each
+    // `keyCode` value, almost all function keys have a universal value.
+    // $FlowFixMe[invalid-computed-prop] unable to index with a `mixed` value
+    return translateToKey[nativeEvent.keyCode] || 'Unidentified';
+  }
+
+  return '';
+}
+/**
+ * Translation from modifier key to the associated property in the event.
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers
+ */
+
+
+const modifierKeyToProp = {
+  Alt: 'altKey',
+  Control: 'ctrlKey',
+  Meta: 'metaKey',
+  Shift: 'shiftKey'
+}; // Older browsers (Safari <= 10, iOS Safari <= 10.2) do not support
+// getModifierState. If getModifierState is not supported, we map it to a set of
+// modifier keys exposed by the event. In this case, Lock-keys are not supported.
+// $FlowFixMe[missing-local-annot]
+// $FlowFixMe[missing-this-annot]
+
+function modifierStateGetter(keyArg) {
+  const syntheticEvent = this;
+  const nativeEvent = syntheticEvent.nativeEvent;
+
+  if (nativeEvent.getModifierState) {
+    return nativeEvent.getModifierState(keyArg);
+  }
+
+  const keyProp = modifierKeyToProp[keyArg];
+  return keyProp ? !!nativeEvent[keyProp] : false;
+}
+
+function getEventModifierState(nativeEvent) {
+  return modifierStateGetter;
+}
+/**
+ * @interface KeyboardEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+
+const KeyboardEventInterface = assign({}, UIEventInterface, {
+  key: getEventKey,
+  code: 0,
+  location: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  altKey: 0,
+  metaKey: 0,
+  repeat: 0,
+  locale: 0,
+  getModifierState: getEventModifierState,
+  // Legacy Interface
+  charCode: function (event) {
+    // `charCode` is the result of a KeyPress event and represents the value of
+    // the actual printable character.
+    // KeyPress is deprecated, but its replacement is not yet final and not
+    // implemented in any major browser. Only KeyPress has charCode.
+    if (event.type === 'keypress') {
+      return getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
+      event);
+    }
+
+    return 0;
+  },
+  keyCode: function (event) {
+    // `keyCode` is the result of a KeyDown/Up event and represents the value of
+    // physical keyboard key.
+    // The actual meaning of the value depends on the users' keyboard layout
+    // which cannot be detected. Assuming that it is a US keyboard layout
+    // provides a surprisingly accurate mapping for US and European users.
+    // Due to this, it is left to the user to implement at this time.
+    if (event.type === 'keydown' || event.type === 'keyup') {
+      return event.keyCode;
+    }
+
+    return 0;
+  },
+  which: function (event) {
+    // `which` is an alias for either `keyCode` or `charCode` depending on the
+    // type of the event.
+    if (event.type === 'keypress') {
+      return getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
+      event);
+    }
+
+    if (event.type === 'keydown' || event.type === 'keyup') {
+      return event.keyCode;
+    }
+
+    return 0;
+  }
+});
+
+const SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface);
+/**
+ * @interface PointerEvent
+ * @see http://www.w3.org/TR/pointerevents/
+ */
+
+const PointerEventInterface = assign({}, MouseEventInterface, {
+  pointerId: 0,
+  width: 0,
+  height: 0,
+  pressure: 0,
+  tangentialPressure: 0,
+  tiltX: 0,
+  tiltY: 0,
+  twist: 0,
+  pointerType: 0,
+  isPrimary: 0
+});
+
+const SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface);
+/**
+ * @interface TouchEvent
+ * @see http://www.w3.org/TR/touch-events/
+ */
+
+const TouchEventInterface = assign({}, UIEventInterface, {
+  touches: 0,
+  targetTouches: 0,
+  changedTouches: 0,
+  altKey: 0,
+  metaKey: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  getModifierState: getEventModifierState
+});
+
+const SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent
+ */
+
+const TransitionEventInterface = assign({}, EventInterface, {
+  propertyName: 0,
+  elapsedTime: 0,
+  pseudoElement: 0
+});
+
+const SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface);
+/**
+ * @interface WheelEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+const WheelEventInterface = assign({}, MouseEventInterface, {
+  deltaX(event) {
+    return 'deltaX' in event ? event.deltaX : // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).
+    'wheelDeltaX' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+    -event.wheelDeltaX : 0;
+  },
+
+  deltaY(event) {
+    return 'deltaY' in event ? event.deltaY : // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
+    'wheelDeltaY' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+    -event.wheelDeltaY : // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
+    'wheelDelta' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+    -event.wheelDelta : 0;
+  },
+
+  deltaZ: 0,
+  // Browsers without "deltaMode" is reporting in raw wheel delta where one
+  // notch on the scroll is always +/- 120, roughly equivalent to pixels.
+  // A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or
+  // ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.
+  deltaMode: 0
+});
+
+const SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface);
+
+/**
+ * This plugin invokes action functions on forms, inputs and buttons if
+ * the form doesn't prevent default.
+ */
+
+function extractEvents$6(dispatchQueue, domEventName, maybeTargetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  if (domEventName !== 'submit') {
+    return;
+  }
+
+  if (!maybeTargetInst || maybeTargetInst.stateNode !== nativeEventTarget) {
+    // If we're inside a parent root that itself is a parent of this root, then
+    // its deepest target won't be the actual form that's being submitted.
+    return;
+  }
+
+  const formInst = maybeTargetInst;
+  const form = nativeEventTarget;
+  let action = getFiberCurrentPropsFromNode(form).action;
+  let submitter = nativeEvent.submitter;
+  let submitterAction;
+
+  if (submitter) {
+    const submitterProps = getFiberCurrentPropsFromNode(submitter);
+    submitterAction = submitterProps ? submitterProps.formAction : submitter.getAttribute('formAction');
+
+    if (submitterAction != null) {
+      // The submitter overrides the form action.
+      action = submitterAction; // If the action is a function, we don't want to pass its name
+      // value to the FormData since it's controlled by the server.
+
+      submitter = null;
+    }
+  }
+
+  if (typeof action !== 'function') {
+    return;
+  }
+
+  const event = new SyntheticEvent('action', 'action', null, nativeEvent, nativeEventTarget);
+
+  function submitForm() {
+    if (nativeEvent.defaultPrevented) {
+      // We let earlier events to prevent the action from submitting.
+      return;
+    } // Prevent native navigation.
+
+
+    event.preventDefault();
+    let formData;
+
+    if (submitter) {
+      // The submitter's value should be included in the FormData.
+      // It should be in the document order in the form.
+      // Since the FormData constructor invokes the formdata event it also
+      // needs to be available before that happens so after construction it's too
+      // late. We use a temporary fake node for the duration of this event.
+      // TODO: FormData takes a second argument that it's the submitter but this
+      // is fairly new so not all browsers support it yet. Switch to that technique
+      // when available.
+      const temp = submitter.ownerDocument.createElement('input');
+      temp.name = submitter.name;
+      temp.value = submitter.value;
+      submitter.parentNode.insertBefore(temp, submitter);
+      formData = new FormData(form);
+      temp.parentNode.removeChild(temp);
+    } else {
+      formData = new FormData(form);
+    }
+
+    const pendingState = {
+      pending: true,
+      data: formData,
+      method: form.method,
+      action: action
+    };
+
+    startHostTransition(formInst, pendingState, action, formData);
+  }
+
+  dispatchQueue.push({
+    event,
+    listeners: [{
+      instance: null,
+      listener: submitForm,
+      currentTarget: form
+    }]
+  });
+}
+function dispatchReplayedFormAction(formInst, form, action, formData) {
+  const pendingState = {
+    pending: true,
+    data: formData,
+    method: form.method,
+    action: action
+  };
+
+  startHostTransition(formInst, pendingState, action, formData);
+}
+
+// has this definition built-in.
+
+let hasScheduledReplayAttempt = false; // The last of each continuous event type. We only need to replay the last one
+// if the last target was dehydrated.
+
+let queuedFocus = null;
+let queuedDrag = null;
+let queuedMouse = null; // For pointer events there can be one latest event per pointerId.
+
+const queuedPointers = new Map();
+const queuedPointerCaptures = new Map(); // We could consider replaying selectionchange and touchmoves too.
+
+const queuedExplicitHydrationTargets = [];
+const discreteReplayableEvents = ['mousedown', 'mouseup', 'touchcancel', 'touchend', 'touchstart', 'auxclick', 'dblclick', 'pointercancel', 'pointerdown', 'pointerup', 'dragend', 'dragstart', 'drop', 'compositionend', 'compositionstart', 'keydown', 'keypress', 'keyup', 'input', 'textInput', // Intentionally camelCase
+'copy', 'cut', 'paste', 'click', 'change', 'contextmenu', 'reset' // 'submit', // stopPropagation blocks the replay mechanism
+];
+function isDiscreteEventThatRequiresHydration(eventType) {
+  return discreteReplayableEvents.indexOf(eventType) > -1;
+}
+
+function createQueuedReplayableEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+  return {
+    blockedOn,
+    domEventName,
+    eventSystemFlags,
+    nativeEvent,
+    targetContainers: [targetContainer]
+  };
+} // Resets the replaying for this type of continuous event to no event.
+
+
+function clearIfContinuousEvent(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case 'focusin':
+    case 'focusout':
+      queuedFocus = null;
+      break;
+
+    case 'dragenter':
+    case 'dragleave':
+      queuedDrag = null;
+      break;
+
+    case 'mouseover':
+    case 'mouseout':
+      queuedMouse = null;
+      break;
+
+    case 'pointerover':
+    case 'pointerout':
+      {
+        const pointerId = nativeEvent.pointerId;
+        queuedPointers.delete(pointerId);
+        break;
+      }
+
+    case 'gotpointercapture':
+    case 'lostpointercapture':
+      {
+        const pointerId = nativeEvent.pointerId;
+        queuedPointerCaptures.delete(pointerId);
+        break;
+      }
+  }
+}
+
+function accumulateOrCreateContinuousQueuedReplayableEvent(existingQueuedEvent, blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+  if (existingQueuedEvent === null || existingQueuedEvent.nativeEvent !== nativeEvent) {
+    const queuedEvent = createQueuedReplayableEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent);
+
+    if (blockedOn !== null) {
+      const fiber = getInstanceFromNode(blockedOn);
+
+      if (fiber !== null) {
+        // Attempt to increase the priority of this target.
+        attemptContinuousHydration(fiber);
+      }
+    }
+
+    return queuedEvent;
+  } // If we have already queued this exact event, then it's because
+  // the different event systems have different DOM event listeners.
+  // We can accumulate the flags, and the targetContainers, and
+  // store a single event to be replayed.
+
+
+  existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
+  const targetContainers = existingQueuedEvent.targetContainers;
+
+  if (targetContainer !== null && targetContainers.indexOf(targetContainer) === -1) {
+    targetContainers.push(targetContainer);
+  }
+
+  return existingQueuedEvent;
+}
+
+function queueIfContinuousEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+  // These set relatedTarget to null because the replayed event will be treated as if we
+  // moved from outside the window (no target) onto the target once it hydrates.
+  // Instead of mutating we could clone the event.
+  switch (domEventName) {
+    case 'focusin':
+      {
+        const focusEvent = nativeEvent;
+        queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(queuedFocus, blockedOn, domEventName, eventSystemFlags, targetContainer, focusEvent);
+        return true;
+      }
+
+    case 'dragenter':
+      {
+        const dragEvent = nativeEvent;
+        queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(queuedDrag, blockedOn, domEventName, eventSystemFlags, targetContainer, dragEvent);
+        return true;
+      }
+
+    case 'mouseover':
+      {
+        const mouseEvent = nativeEvent;
+        queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(queuedMouse, blockedOn, domEventName, eventSystemFlags, targetContainer, mouseEvent);
+        return true;
+      }
+
+    case 'pointerover':
+      {
+        const pointerEvent = nativeEvent;
+        const pointerId = pointerEvent.pointerId;
+        queuedPointers.set(pointerId, accumulateOrCreateContinuousQueuedReplayableEvent(queuedPointers.get(pointerId) || null, blockedOn, domEventName, eventSystemFlags, targetContainer, pointerEvent));
+        return true;
+      }
+
+    case 'gotpointercapture':
+      {
+        const pointerEvent = nativeEvent;
+        const pointerId = pointerEvent.pointerId;
+        queuedPointerCaptures.set(pointerId, accumulateOrCreateContinuousQueuedReplayableEvent(queuedPointerCaptures.get(pointerId) || null, blockedOn, domEventName, eventSystemFlags, targetContainer, pointerEvent));
+        return true;
+      }
+  }
+
+  return false;
+} // Check if this target is unblocked. Returns true if it's unblocked.
+
+function attemptExplicitHydrationTarget(queuedTarget) {
+  // TODO: This function shares a lot of logic with findInstanceBlockingEvent.
+  // Try to unify them. It's a bit tricky since it would require two return
+  // values.
+  const targetInst = getClosestInstanceFromNode(queuedTarget.target);
+
+  if (targetInst !== null) {
+    const nearestMounted = getNearestMountedFiber(targetInst);
+
+    if (nearestMounted !== null) {
+      const tag = nearestMounted.tag;
+
+      if (tag === SuspenseComponent) {
+        const instance = getSuspenseInstanceFromFiber(nearestMounted);
+
+        if (instance !== null) {
+          // We're blocked on hydrating this boundary.
+          // Increase its priority.
+          queuedTarget.blockedOn = instance;
+          runWithPriority(queuedTarget.priority, () => {
+            attemptHydrationAtCurrentPriority(nearestMounted);
+          });
+          return;
+        }
+      } else if (tag === HostRoot) {
+        const root = nearestMounted.stateNode;
+
+        if (isRootDehydrated(root)) {
+          queuedTarget.blockedOn = getContainerFromFiber(nearestMounted); // We don't currently have a way to increase the priority of
+          // a root other than sync.
+
+          return;
+        }
+      }
+    }
+  }
+
+  queuedTarget.blockedOn = null;
+}
+
+function queueExplicitHydrationTarget(target) {
+  // TODO: This will read the priority if it's dispatched by the React
+  // event system but not native events. Should read window.event.type, like
+  // we do for updates (getCurrentEventPriority).
+  const updatePriority = getCurrentUpdatePriority();
+  const queuedTarget = {
+    blockedOn: null,
+    target: target,
+    priority: updatePriority
+  };
+  let i = 0;
+
+  for (; i < queuedExplicitHydrationTargets.length; i++) {
+    // Stop once we hit the first target with lower priority than
+    if (!isHigherEventPriority(updatePriority, queuedExplicitHydrationTargets[i].priority)) {
+      break;
+    }
+  }
+
+  queuedExplicitHydrationTargets.splice(i, 0, queuedTarget);
+
+  if (i === 0) {
+    attemptExplicitHydrationTarget(queuedTarget);
+  }
+}
+
+function attemptReplayContinuousQueuedEvent(queuedEvent) {
+  if (queuedEvent.blockedOn !== null) {
+    return false;
+  }
+
+  const targetContainers = queuedEvent.targetContainers;
+
+  while (targetContainers.length > 0) {
+    const nextBlockedOn = findInstanceBlockingEvent(queuedEvent.nativeEvent);
+
+    if (nextBlockedOn === null) {
+      const nativeEvent = queuedEvent.nativeEvent;
+      const nativeEventClone = new nativeEvent.constructor(nativeEvent.type, nativeEvent);
+      setReplayingEvent(nativeEventClone);
+      nativeEvent.target.dispatchEvent(nativeEventClone);
+      resetReplayingEvent();
+    } else {
+      // We're still blocked. Try again later.
+      const fiber = getInstanceFromNode(nextBlockedOn);
+
+      if (fiber !== null) {
+        attemptContinuousHydration(fiber);
+      }
+
+      queuedEvent.blockedOn = nextBlockedOn;
+      return false;
+    } // This target container was successfully dispatched. Try the next.
+
+
+    targetContainers.shift();
+  }
+
+  return true;
+}
+
+function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
+  if (attemptReplayContinuousQueuedEvent(queuedEvent)) {
+    map.delete(key);
+  }
+}
+
+function replayUnblockedEvents() {
+  hasScheduledReplayAttempt = false; // Replay any continuous events.
+
+  if (queuedFocus !== null && attemptReplayContinuousQueuedEvent(queuedFocus)) {
+    queuedFocus = null;
+  }
+
+  if (queuedDrag !== null && attemptReplayContinuousQueuedEvent(queuedDrag)) {
+    queuedDrag = null;
+  }
+
+  if (queuedMouse !== null && attemptReplayContinuousQueuedEvent(queuedMouse)) {
+    queuedMouse = null;
+  }
+
+  queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
+  queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
+}
+
+function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
+  if (queuedEvent.blockedOn === unblocked) {
+    queuedEvent.blockedOn = null;
+
+    if (!hasScheduledReplayAttempt) {
+      hasScheduledReplayAttempt = true; // Schedule a callback to attempt replaying as many events as are
+      // now unblocked. This first might not actually be unblocked yet.
+      // We could check it early to avoid scheduling an unnecessary callback.
+
+      Scheduler.unstable_scheduleCallback(Scheduler.unstable_NormalPriority, replayUnblockedEvents);
+    }
+  }
+} // [form, submitter or action, formData...]
+
+
+let lastScheduledReplayQueue = null;
+
+function replayUnblockedFormActions(formReplayingQueue) {
+  if (lastScheduledReplayQueue === formReplayingQueue) {
+    lastScheduledReplayQueue = null;
+  }
+
+  for (let i = 0; i < formReplayingQueue.length; i += 3) {
+    const form = formReplayingQueue[i];
+    const submitterOrAction = formReplayingQueue[i + 1];
+    const formData = formReplayingQueue[i + 2];
+
+    if (typeof submitterOrAction !== 'function') {
+      // This action is not hydrated yet. This might be because it's blocked on
+      // a different React instance or higher up our tree.
+      const blockedOn = findInstanceBlockingTarget(submitterOrAction || form);
+
+      if (blockedOn === null) {
+        // We're not blocked but we don't have an action. This must mean that
+        // this is in another React instance. We'll just skip past it.
+        continue;
+      } else {
+        // We're blocked on something in this React instance. We'll retry later.
+        break;
+      }
+    }
+
+    const formInst = getInstanceFromNode(form);
+
+    if (formInst !== null) {
+      // This is part of our instance.
+      // We're ready to replay this. Let's delete it from the queue.
+      formReplayingQueue.splice(i, 3);
+      i -= 3;
+      dispatchReplayedFormAction(formInst, form, submitterOrAction, formData); // Continue without incrementing the index.
+
+      continue;
+    } // This form must've been part of a different React instance.
+    // If we want to preserve ordering between React instances on the same root
+    // we'd need some way for the other instance to ping us when it's done.
+    // We'll just skip this and let the other instance execute it.
+
+  }
+}
+
+function scheduleReplayQueueIfNeeded(formReplayingQueue) {
+  // Schedule a callback to execute any unblocked form actions in.
+  // We only keep track of the last queue which means that if multiple React oscillate
+  // commits, we could schedule more callbacks than necessary but it's not a big deal
+  // and we only really except one instance.
+  if (lastScheduledReplayQueue !== formReplayingQueue) {
+    lastScheduledReplayQueue = formReplayingQueue;
+    Scheduler.unstable_scheduleCallback(Scheduler.unstable_NormalPriority, () => replayUnblockedFormActions(formReplayingQueue));
+  }
+}
+
+function retryIfBlockedOn(unblocked) {
+  if (queuedFocus !== null) {
+    scheduleCallbackIfUnblocked(queuedFocus, unblocked);
+  }
+
+  if (queuedDrag !== null) {
+    scheduleCallbackIfUnblocked(queuedDrag, unblocked);
+  }
+
+  if (queuedMouse !== null) {
+    scheduleCallbackIfUnblocked(queuedMouse, unblocked);
+  }
+
+  const unblock = queuedEvent => scheduleCallbackIfUnblocked(queuedEvent, unblocked);
+
+  queuedPointers.forEach(unblock);
+  queuedPointerCaptures.forEach(unblock);
+
+  for (let i = 0; i < queuedExplicitHydrationTargets.length; i++) {
+    const queuedTarget = queuedExplicitHydrationTargets[i];
+
+    if (queuedTarget.blockedOn === unblocked) {
+      queuedTarget.blockedOn = null;
+    }
+  }
+
+  while (queuedExplicitHydrationTargets.length > 0) {
+    const nextExplicitTarget = queuedExplicitHydrationTargets[0];
+
+    if (nextExplicitTarget.blockedOn !== null) {
+      // We're still blocked.
+      break;
+    } else {
+      attemptExplicitHydrationTarget(nextExplicitTarget);
+
+      if (nextExplicitTarget.blockedOn === null) {
+        // We're unblocked.
+        queuedExplicitHydrationTargets.shift();
+      }
+    }
+  }
+
+  {
+    // Check the document if there are any queued form actions.
+    const root = unblocked.getRootNode();
+    const formReplayingQueue = root.$$reactFormReplay;
+
+    if (formReplayingQueue != null) {
+      for (let i = 0; i < formReplayingQueue.length; i += 3) {
+        const form = formReplayingQueue[i];
+        const submitterOrAction = formReplayingQueue[i + 1];
+        const formProps = getFiberCurrentPropsFromNode(form);
+
+        if (typeof submitterOrAction === 'function') {
+          // This action has already resolved. We're just waiting to dispatch it.
+          if (!formProps) {
+            // This was not part of this React instance. It might have been recently
+            // unblocking us from dispatching our events. So let's make sure we schedule
+            // a retry.
+            scheduleReplayQueueIfNeeded(formReplayingQueue);
+          }
+
+          continue;
+        }
+
+        let target = form;
+
+        if (formProps) {
+          // This form belongs to this React instance but the submitter might
+          // not be done yet.
+          let action = null;
+          const submitter = submitterOrAction;
+
+          if (submitter && submitter.hasAttribute('formAction')) {
+            // The submitter is the one that is responsible for the action.
+            target = submitter;
+            const submitterProps = getFiberCurrentPropsFromNode(submitter);
+
+            if (submitterProps) {
+              // The submitter is part of this instance.
+              action = submitterProps.formAction;
+            } else {
+              const blockedOn = findInstanceBlockingTarget(target);
+
+              if (blockedOn !== null) {
+                // The submitter is not hydrated yet. We'll wait for it.
+                continue;
+              } // The submitter must have been a part of a different React instance.
+              // Except the form isn't. We don't dispatch actions in this scenario.
+
+            }
+          } else {
+            action = formProps.action;
+          }
+
+          if (typeof action === 'function') {
+            formReplayingQueue[i + 1] = action;
+          } else {
+            // Something went wrong so let's just delete this action.
+            formReplayingQueue.splice(i, 3);
+            i -= 3;
+          } // Schedule a replay in case this unblocked something.
+
+
+          scheduleReplayQueueIfNeeded(formReplayingQueue);
+          continue;
+        } // Something above this target is still blocked so we can't continue yet.
+        // We're not sure if this target is actually part of this React instance
+        // yet. It could be a different React as a child but at least some parent is.
+        // We must continue for any further queued actions.
+
+      }
+    }
+  }
+}
+
+const ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig; // TODO: can we stop exporting these?
+
+let _enabled = true; // This is exported in FB builds for use by legacy FB layer infra.
+// We'd like to remove this but it's not clear if this is safe.
+
+function setEnabled(enabled) {
+  _enabled = !!enabled;
+}
+function isEnabled() {
+  return _enabled;
+}
+function createEventListenerWrapperWithPriority(targetContainer, domEventName, eventSystemFlags) {
+  const eventPriority = getEventPriority(domEventName);
+  let listenerWrapper;
+
+  switch (eventPriority) {
+    case DiscreteEventPriority:
+      listenerWrapper = dispatchDiscreteEvent;
+      break;
+
+    case ContinuousEventPriority:
+      listenerWrapper = dispatchContinuousEvent;
+      break;
+
+    case DefaultEventPriority:
+    default:
+      listenerWrapper = dispatchEvent;
+      break;
+  }
+
+  return listenerWrapper.bind(null, domEventName, eventSystemFlags, targetContainer);
+}
+
+function dispatchDiscreteEvent(domEventName, eventSystemFlags, container, nativeEvent) {
+  const previousPriority = getCurrentUpdatePriority();
+  const prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
+
+  try {
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig.transition = prevTransition;
+  }
+}
+
+function dispatchContinuousEvent(domEventName, eventSystemFlags, container, nativeEvent) {
+  const previousPriority = getCurrentUpdatePriority();
+  const prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
+
+  try {
+    setCurrentUpdatePriority(ContinuousEventPriority);
+    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig.transition = prevTransition;
+  }
+}
+
+function dispatchEvent(domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+  if (!_enabled) {
+    return;
+  }
+
+  let blockedOn = findInstanceBlockingEvent(nativeEvent);
+
+  if (blockedOn === null) {
+    dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, return_targetInst, targetContainer);
+    clearIfContinuousEvent(domEventName, nativeEvent);
+    return;
+  }
+
+  if (queueIfContinuousEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent)) {
+    nativeEvent.stopPropagation();
+    return;
+  } // We need to clear only if we didn't queue because
+  // queueing is accumulative.
+
+
+  clearIfContinuousEvent(domEventName, nativeEvent);
+
+  if (eventSystemFlags & IS_CAPTURE_PHASE && isDiscreteEventThatRequiresHydration(domEventName)) {
+    while (blockedOn !== null) {
+      const fiber = getInstanceFromNode(blockedOn);
+
+      if (fiber !== null) {
+        attemptSynchronousHydration(fiber);
+      }
+
+      const nextBlockedOn = findInstanceBlockingEvent(nativeEvent);
+
+      if (nextBlockedOn === null) {
+        dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, return_targetInst, targetContainer);
+      }
+
+      if (nextBlockedOn === blockedOn) {
+        break;
+      }
+
+      blockedOn = nextBlockedOn;
+    }
+
+    if (blockedOn !== null) {
+      nativeEvent.stopPropagation();
+    }
+
+    return;
+  } // 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 findInstanceBlockingEvent(nativeEvent) {
+  const nativeEventTarget = getEventTarget(nativeEvent);
+  return findInstanceBlockingTarget(nativeEventTarget);
+}
+let return_targetInst = null; // Returns a SuspenseInstance or Container if it's blocked.
+// The return_targetInst field above is conceptually part of the return value.
+
+function findInstanceBlockingTarget(targetNode) {
+  // TODO: Warn if _enabled is false.
+  return_targetInst = null;
+  let targetInst = getClosestInstanceFromNode(targetNode);
+
+  if (targetInst !== null) {
+    const nearestMounted = getNearestMountedFiber(targetInst);
+
+    if (nearestMounted === null) {
+      // This tree has been unmounted already. Dispatch without a target.
+      targetInst = null;
+    } else {
+      const tag = nearestMounted.tag;
+
+      if (tag === SuspenseComponent) {
+        const instance = getSuspenseInstanceFromFiber(nearestMounted);
+
+        if (instance !== null) {
+          // Queue the event to be replayed later. Abort dispatching since we
+          // don't want this event dispatched twice through the event system.
+          // TODO: If this is the first discrete event in the queue. Schedule an increased
+          // priority for this boundary.
+          return instance;
+        } // This shouldn't happen, something went wrong but to avoid blocking
+        // the whole system, dispatch the event without a target.
+        // TODO: Warn.
+
+
+        targetInst = null;
+      } else if (tag === HostRoot) {
+        const root = nearestMounted.stateNode;
+
+        if (isRootDehydrated(root)) {
+          // If this happens during a replay something went wrong and it might block
+          // the whole system.
+          return getContainerFromFiber(nearestMounted);
+        }
+
+        targetInst = null;
+      } else if (nearestMounted !== targetInst) {
+        // If we get an event (ex: img onload) before committing that
+        // component's mount, ignore it for now (that is, treat it as if it was an
+        // event on a non-React tree). We might also consider queueing events and
+        // dispatching them after the mount.
+        targetInst = null;
+      }
+    }
+  }
+
+  return_targetInst = targetInst; // We're not blocked on anything.
+
+  return null;
+}
+function getEventPriority(domEventName) {
+  switch (domEventName) {
+    // Used by SimpleEventPlugin:
+    case 'cancel':
+    case 'click':
+    case 'close':
+    case 'contextmenu':
+    case 'copy':
+    case 'cut':
+    case 'auxclick':
+    case 'dblclick':
+    case 'dragend':
+    case 'dragstart':
+    case 'drop':
+    case 'focusin':
+    case 'focusout':
+    case 'input':
+    case 'invalid':
+    case 'keydown':
+    case 'keypress':
+    case 'keyup':
+    case 'mousedown':
+    case 'mouseup':
+    case 'paste':
+    case 'pause':
+    case 'play':
+    case 'pointercancel':
+    case 'pointerdown':
+    case 'pointerup':
+    case 'ratechange':
+    case 'reset':
+    case 'resize':
+    case 'seeked':
+    case 'submit':
+    case 'touchcancel':
+    case 'touchend':
+    case 'touchstart':
+    case 'volumechange': // Used by polyfills: (fall through)
+
+    case 'change':
+    case 'selectionchange':
+    case 'textInput':
+    case 'compositionstart':
+    case 'compositionend':
+    case 'compositionupdate': // Only enableCreateEventHandleAPI: (fall through)
+
+    case 'beforeblur':
+    case 'afterblur': // Not used by React but could be by user code: (fall through)
+
+    case 'beforeinput':
+    case 'blur':
+    case 'fullscreenchange':
+    case 'focus':
+    case 'hashchange':
+    case 'popstate':
+    case 'select':
+    case 'selectstart':
+      return DiscreteEventPriority;
+
+    case 'drag':
+    case 'dragenter':
+    case 'dragexit':
+    case 'dragleave':
+    case 'dragover':
+    case 'mousemove':
+    case 'mouseout':
+    case 'mouseover':
+    case 'pointermove':
+    case 'pointerout':
+    case 'pointerover':
+    case 'scroll':
+    case 'toggle':
+    case 'touchmove':
+    case 'wheel': // Not used by React but could be by user code: (fall through)
+
+    case 'mouseenter':
+    case 'mouseleave':
+    case 'pointerenter':
+    case 'pointerleave':
+      return ContinuousEventPriority;
+
+    case 'message':
+      {
+        // We might be in the Scheduler callback.
+        // Eventually this mechanism will be replaced by a check
+        // of the current priority on the native scheduler.
+        const schedulerPriority = getCurrentPriorityLevel();
+
+        switch (schedulerPriority) {
+          case ImmediatePriority:
+            return DiscreteEventPriority;
+
+          case UserBlockingPriority:
+            return ContinuousEventPriority;
+
+          case NormalPriority$1:
+          case LowPriority:
+            // TODO: Handle LowSchedulerPriority, somehow. Maybe the same lane as hydration.
+            return DefaultEventPriority;
+
+          case IdlePriority:
+            return IdleEventPriority;
+
+          default:
+            return DefaultEventPriority;
+        }
+      }
+
+    default:
+      return DefaultEventPriority;
+  }
+}
+
+function addEventBubbleListener(target, eventType, listener) {
+  target.addEventListener(eventType, listener, false);
+  return listener;
+}
+function addEventCaptureListener(target, eventType, listener) {
+  target.addEventListener(eventType, listener, true);
+  return listener;
+}
+function addEventCaptureListenerWithPassiveFlag(target, eventType, listener, passive) {
+  target.addEventListener(eventType, listener, {
+    capture: true,
+    passive
+  });
+  return listener;
+}
+function addEventBubbleListenerWithPassiveFlag(target, eventType, listener, passive) {
+  target.addEventListener(eventType, listener, {
+    passive
+  });
+  return listener;
+}
+
+/**
+ * These variables store information about text content of a target node,
+ * allowing comparison of content before and after a given event.
+ *
+ * Identify the node where selection currently begins, then observe
+ * both its text content and its current position in the DOM. Since the
+ * browser may natively replace the target node during composition, we can
+ * use its position to find its replacement.
+ *
+ *
+ */
+let root = null;
+let startText = null;
+let fallbackText = null;
+function initialize(nativeEventTarget) {
+  root = nativeEventTarget;
+  startText = getText();
+  return true;
+}
+function reset() {
+  root = null;
+  startText = null;
+  fallbackText = null;
+}
+function getData() {
+  if (fallbackText) {
+    return fallbackText;
+  }
+
+  let start;
+  const startValue = startText;
+  const startLength = startValue.length;
+  let end;
+  const endValue = getText();
+  const endLength = endValue.length;
+
+  for (start = 0; start < startLength; start++) {
+    if (startValue[start] !== endValue[start]) {
+      break;
+    }
+  }
+
+  const minEnd = startLength - start;
+
+  for (end = 1; end <= minEnd; end++) {
+    if (startValue[startLength - end] !== endValue[endLength - end]) {
+      break;
+    }
+  }
+
+  const sliceTail = end > 1 ? 1 - end : undefined;
+  fallbackText = endValue.slice(start, sliceTail);
+  return fallbackText;
+}
+function getText() {
+  if ('value' in root) {
+    return root.value;
+  }
+
+  return root.textContent;
+}
+
+const END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space
+
+const START_KEYCODE = 229;
+const canUseCompositionEvent = canUseDOM && 'CompositionEvent' in window;
+let documentMode = null;
+
+if (canUseDOM && 'documentMode' in document) {
+  documentMode = document.documentMode;
+} // Webkit offers a very useful `textInput` event that can be used to
+// directly represent `beforeInput`. The IE `textinput` event is not as
+// useful, so we don't use it.
+
+
+const canUseTextInputEvent = canUseDOM && 'TextEvent' in window && !documentMode; // In IE9+, we have access to composition events, but the data supplied
+// by the native compositionend event may be incorrect. Japanese ideographic
+// spaces, for instance (\u3000) are not recorded correctly.
+
+const useFallbackCompositionData = canUseDOM && (!canUseCompositionEvent || documentMode && documentMode > 8 && documentMode <= 11);
+const SPACEBAR_CODE = 32;
+const SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);
+
+function registerEvents$3() {
+  registerTwoPhaseEvent('onBeforeInput', ['compositionend', 'keypress', 'textInput', 'paste']);
+  registerTwoPhaseEvent('onCompositionEnd', ['compositionend', 'focusout', 'keydown', 'keypress', 'keyup', 'mousedown']);
+  registerTwoPhaseEvent('onCompositionStart', ['compositionstart', 'focusout', 'keydown', 'keypress', 'keyup', 'mousedown']);
+  registerTwoPhaseEvent('onCompositionUpdate', ['compositionupdate', 'focusout', 'keydown', 'keypress', 'keyup', 'mousedown']);
+} // Track whether we've ever handled a keypress on the space key.
+
+
+let hasSpaceKeypress = false;
+/**
+ * Return whether a native keypress event is assumed to be a command.
+ * This is required because Firefox fires `keypress` events for key commands
+ * (cut, copy, select-all, etc.) even though no character is inserted.
+ */
+
+function isKeypressCommand(nativeEvent) {
+  return (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) && // ctrlKey && altKey is equivalent to AltGr, and is not a command.
+  !(nativeEvent.ctrlKey && nativeEvent.altKey);
+}
+/**
+ * Translate native top level events into event types.
+ */
+
+
+function getCompositionEventType(domEventName) {
+  switch (domEventName) {
+    case 'compositionstart':
+      return 'onCompositionStart';
+
+    case 'compositionend':
+      return 'onCompositionEnd';
+
+    case 'compositionupdate':
+      return 'onCompositionUpdate';
+  }
+}
+/**
+ * Does our fallback best-guess model think this event signifies that
+ * composition has begun?
+ */
+
+
+function isFallbackCompositionStart(domEventName, nativeEvent) {
+  return domEventName === 'keydown' && nativeEvent.keyCode === START_KEYCODE;
+}
+/**
+ * Does our fallback mode think that this event is the end of composition?
+ */
+
+
+function isFallbackCompositionEnd(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case 'keyup':
+      // Command keys insert or clear IME input.
+      return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1;
+
+    case 'keydown':
+      // Expect IME keyCode on each keydown. If we get any other
+      // code we must have exited earlier.
+      return nativeEvent.keyCode !== START_KEYCODE;
+
+    case 'keypress':
+    case 'mousedown':
+    case 'focusout':
+      // Events are not possible without cancelling IME.
+      return true;
+
+    default:
+      return false;
+  }
+}
+/**
+ * Google Input Tools provides composition data via a CustomEvent,
+ * with the `data` property populated in the `detail` object. If this
+ * is available on the event object, use it. If not, this is a plain
+ * composition event and we have nothing special to extract.
+ *
+ * @param {object} nativeEvent
+ * @return {?string}
+ */
+
+
+function getDataFromCustomEvent(nativeEvent) {
+  const detail = nativeEvent.detail;
+
+  if (typeof detail === 'object' && 'data' in detail) {
+    return detail.data;
+  }
+
+  return null;
+}
+/**
+ * Check if a composition event was triggered by Korean IME.
+ * Our fallback mode does not work well with IE's Korean IME,
+ * so just use native composition events when Korean IME is used.
+ * Although CompositionEvent.locale property is deprecated,
+ * it is available in IE, where our fallback mode is enabled.
+ *
+ * @param {object} nativeEvent
+ * @return {boolean}
+ */
+
+
+function isUsingKoreanIME(nativeEvent) {
+  return nativeEvent.locale === 'ko';
+} // Track the current IME composition status, if any.
+
+
+let isComposing = false;
+/**
+ * @return {?object} A SyntheticCompositionEvent.
+ */
+
+function extractCompositionEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget) {
+  let eventType;
+  let fallbackData;
+
+  if (canUseCompositionEvent) {
+    eventType = getCompositionEventType(domEventName);
+  } else if (!isComposing) {
+    if (isFallbackCompositionStart(domEventName, nativeEvent)) {
+      eventType = 'onCompositionStart';
+    }
+  } else if (isFallbackCompositionEnd(domEventName, nativeEvent)) {
+    eventType = 'onCompositionEnd';
+  }
+
+  if (!eventType) {
+    return null;
+  }
+
+  if (useFallbackCompositionData && !isUsingKoreanIME(nativeEvent)) {
+    // The current composition is stored statically and must not be
+    // overwritten while composition continues.
+    if (!isComposing && eventType === 'onCompositionStart') {
+      isComposing = initialize(nativeEventTarget);
+    } else if (eventType === 'onCompositionEnd') {
+      if (isComposing) {
+        fallbackData = getData();
+      }
+    }
+  }
+
+  const listeners = accumulateTwoPhaseListeners(targetInst, eventType);
+
+  if (listeners.length > 0) {
+    const event = new SyntheticCompositionEvent(eventType, domEventName, null, nativeEvent, nativeEventTarget);
+    dispatchQueue.push({
+      event,
+      listeners
+    });
+
+    if (fallbackData) {
+      // Inject data generated from fallback path into the synthetic event.
+      // This matches the property of native CompositionEventInterface.
+      // $FlowFixMe[incompatible-use]
+      event.data = fallbackData;
+    } else {
+      const customData = getDataFromCustomEvent(nativeEvent);
+
+      if (customData !== null) {
+        // $FlowFixMe[incompatible-use]
+        event.data = customData;
+      }
+    }
+  }
+}
+
+function getNativeBeforeInputChars(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case 'compositionend':
+      return getDataFromCustomEvent(nativeEvent);
+
+    case 'keypress':
+      /**
+       * If native `textInput` events are available, our goal is to make
+       * use of them. However, there is a special case: the spacebar key.
+       * In Webkit, preventing default on a spacebar `textInput` event
+       * cancels character insertion, but it *also* causes the browser
+       * to fall back to its default spacebar behavior of scrolling the
+       * page.
+       *
+       * Tracking at:
+       * https://code.google.com/p/chromium/issues/detail?id=355103
+       *
+       * To avoid this issue, use the keypress event as if no `textInput`
+       * event is available.
+       */
+      const which = nativeEvent.which;
+
+      if (which !== SPACEBAR_CODE) {
+        return null;
+      }
+
+      hasSpaceKeypress = true;
+      return SPACEBAR_CHAR;
+
+    case 'textInput':
+      // Record the characters to be added to the DOM.
+      const chars = nativeEvent.data; // If it's a spacebar character, assume that we have already handled
+      // it at the keypress level and bail immediately. Android Chrome
+      // doesn't give us keycodes, so we need to ignore it.
+
+      if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {
+        return null;
+      }
+
+      return chars;
+
+    default:
+      // For other native event types, do nothing.
+      return null;
+  }
+}
+/**
+ * For browsers that do not provide the `textInput` event, extract the
+ * appropriate string to use for SyntheticInputEvent.
+ */
+
+
+function getFallbackBeforeInputChars(domEventName, nativeEvent) {
+  // If we are currently composing (IME) and using a fallback to do so,
+  // try to extract the composed characters from the fallback object.
+  // If composition event is available, we extract a string only at
+  // compositionevent, otherwise extract it at fallback events.
+  if (isComposing) {
+    if (domEventName === 'compositionend' || !canUseCompositionEvent && isFallbackCompositionEnd(domEventName, nativeEvent)) {
+      const chars = getData();
+      reset();
+      isComposing = false;
+      return chars;
+    }
+
+    return null;
+  }
+
+  switch (domEventName) {
+    case 'paste':
+      // If a paste event occurs after a keypress, throw out the input
+      // chars. Paste events should not lead to BeforeInput events.
+      return null;
+
+    case 'keypress':
+      /**
+       * As of v27, Firefox may fire keypress events even when no character
+       * will be inserted. A few possibilities:
+       *
+       * - `which` is `0`. Arrow keys, Esc key, etc.
+       *
+       * - `which` is the pressed key code, but no char is available.
+       *   Ex: 'AltGr + d` in Polish. There is no modified character for
+       *   this key combination and no character is inserted into the
+       *   document, but FF fires the keypress for char code `100` anyway.
+       *   No `input` event will occur.
+       *
+       * - `which` is the pressed key code, but a command combination is
+       *   being used. Ex: `Cmd+C`. No character is inserted, and no
+       *   `input` event will occur.
+       */
+      if (!isKeypressCommand(nativeEvent)) {
+        // IE fires the `keypress` event when a user types an emoji via
+        // Touch keyboard of Windows.  In such a case, the `char` property
+        // holds an emoji character like `\uD83D\uDE0A`.  Because its length
+        // is 2, the property `which` does not represent an emoji correctly.
+        // In such a case, we directly return the `char` property instead of
+        // using `which`.
+        if (nativeEvent.char && nativeEvent.char.length > 1) {
+          return nativeEvent.char;
+        } else if (nativeEvent.which) {
+          return String.fromCharCode(nativeEvent.which);
+        }
+      }
+
+      return null;
+
+    case 'compositionend':
+      return useFallbackCompositionData && !isUsingKoreanIME(nativeEvent) ? null : nativeEvent.data;
+
+    default:
+      return null;
+  }
+}
+/**
+ * Extract a SyntheticInputEvent for `beforeInput`, based on either native
+ * `textInput` or fallback behavior.
+ *
+ * @return {?object} A SyntheticInputEvent.
+ */
+
+
+function extractBeforeInputEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget) {
+  let chars;
+
+  if (canUseTextInputEvent) {
+    chars = getNativeBeforeInputChars(domEventName, nativeEvent);
+  } else {
+    chars = getFallbackBeforeInputChars(domEventName, nativeEvent);
+  } // If no characters are being inserted, no BeforeInput event should
+  // be fired.
+
+
+  if (!chars) {
+    return null;
+  }
+
+  const listeners = accumulateTwoPhaseListeners(targetInst, 'onBeforeInput');
+
+  if (listeners.length > 0) {
+    const event = new SyntheticInputEvent('onBeforeInput', 'beforeinput', null, nativeEvent, nativeEventTarget);
+    dispatchQueue.push({
+      event,
+      listeners
+    }); // $FlowFixMe[incompatible-use]
+
+    event.data = chars;
+  }
+}
+/**
+ * Create an `onBeforeInput` event to match
+ * http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.
+ *
+ * This event plugin is based on the native `textInput` event
+ * available in Chrome, Safari, Opera, and IE. This event fires after
+ * `onKeyPress` and `onCompositionEnd`, but before `onInput`.
+ *
+ * `beforeInput` is spec'd but not implemented in any browsers, and
+ * the `input` event does not provide any useful information about what has
+ * actually been added, contrary to the spec. Thus, `textInput` is the best
+ * available event to identify the characters that have actually been inserted
+ * into the target node.
+ *
+ * This plugin is also responsible for emitting `composition` events, thus
+ * allowing us to share composition fallback code for both `beforeInput` and
+ * `composition` event types.
+ */
+
+
+function extractEvents$5(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  extractCompositionEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+  extractBeforeInputEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+}
+
+/**
+ * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary
+ */
+const supportedInputTypes = {
+  color: true,
+  date: true,
+  datetime: true,
+  'datetime-local': true,
+  email: true,
+  month: true,
+  number: true,
+  password: true,
+  range: true,
+  search: true,
+  tel: true,
+  text: true,
+  time: true,
+  url: true,
+  week: true
+};
+
+function isTextInputElement(elem) {
+  const nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+
+  if (nodeName === 'input') {
+    return !!supportedInputTypes[elem.type];
+  }
+
+  if (nodeName === 'textarea') {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Checks if an event is supported in the current execution environment.
+ *
+ * NOTE: This will not work correctly for non-generic events such as `change`,
+ * `reset`, `load`, `error`, and `select`.
+ *
+ * Borrows from Modernizr.
+ *
+ * @param {string} eventNameSuffix Event name, e.g. "click".
+ * @return {boolean} True if the event is supported.
+ * @internal
+ * @license Modernizr 3.0.0pre (Custom Build) | MIT
+ */
+
+function isEventSupported(eventNameSuffix) {
+  if (!canUseDOM) {
+    return false;
+  }
+
+  const eventName = 'on' + eventNameSuffix;
+  let isSupported = (eventName in document);
+
+  if (!isSupported) {
+    const element = document.createElement('div');
+    element.setAttribute(eventName, 'return;');
+    isSupported = typeof element[eventName] === 'function';
+  }
+
+  return isSupported;
+}
+
+function registerEvents$2() {
+  registerTwoPhaseEvent('onChange', ['change', 'click', 'focusin', 'focusout', 'input', 'keydown', 'keyup', 'selectionchange']);
+}
+
+function createAndAccumulateChangeEvent(dispatchQueue, inst, nativeEvent, target) {
+  // Flag this event loop as needing state restore.
+  enqueueStateRestore(target);
+  const listeners = accumulateTwoPhaseListeners(inst, 'onChange');
+
+  if (listeners.length > 0) {
+    const event = new SyntheticEvent('onChange', 'change', null, nativeEvent, target);
+    dispatchQueue.push({
+      event,
+      listeners
+    });
+  }
+}
+/**
+ * For IE shims
+ */
+
+
+let activeElement$1 = null;
+let activeElementInst$1 = null;
+/**
+ * SECTION: handle `change` event
+ */
+
+function shouldUseChangeEvent(elem) {
+  const nodeName = elem.nodeName && elem.nodeName.toLowerCase();
+  return nodeName === 'select' || nodeName === 'input' && elem.type === 'file';
+}
+
+function manualDispatchChangeEvent(nativeEvent) {
+  const dispatchQueue = [];
+  createAndAccumulateChangeEvent(dispatchQueue, activeElementInst$1, nativeEvent, getEventTarget(nativeEvent)); // If change and propertychange bubbled, we'd just bind to it like all the
+  // other events and have it go through ReactBrowserEventEmitter. Since it
+  // doesn't, we manually listen for the events and so we have to enqueue and
+  // process the abstract event manually.
+  //
+  // Batching is necessary here in order to ensure that all event handlers run
+  // before the next rerender (including event handlers attached to ancestor
+  // elements instead of directly on the input). Without this, controlled
+  // components don't work properly in conjunction with event bubbling because
+  // the component is rerendered and the value reverted before all the event
+  // handlers can run. See https://github.com/facebook/react/issues/708.
+
+  batchedUpdates(runEventInBatch, dispatchQueue);
+}
+
+function runEventInBatch(dispatchQueue) {
+  processDispatchQueue(dispatchQueue, 0);
+}
+
+function getInstIfValueChanged(targetInst) {
+  const targetNode = getNodeFromInstance(targetInst);
+
+  if (updateValueIfChanged(targetNode)) {
+    return targetInst;
+  }
+}
+
+function getTargetInstForChangeEvent(domEventName, targetInst) {
+  if (domEventName === 'change') {
+    return targetInst;
+  }
+}
+/**
+ * SECTION: handle `input` event
+ */
+
+
+let isInputEventSupported = false;
+
+if (canUseDOM) {
+  // IE9 claims to support the input event but fails to trigger it when
+  // deleting text, so we ignore its input events.
+  isInputEventSupported = isEventSupported('input') && (!document.documentMode || document.documentMode > 9);
+}
+/**
+ * (For IE <=9) Starts tracking propertychange events on the passed-in element
+ * and override the value property so that we can distinguish user events from
+ * value changes in JS.
+ */
+
+
+function startWatchingForValueChange(target, targetInst) {
+  activeElement$1 = target;
+  activeElementInst$1 = targetInst;
+  activeElement$1.attachEvent('onpropertychange', handlePropertyChange);
+}
+/**
+ * (For IE <=9) Removes the event listeners from the currently-tracked element,
+ * if any exists.
+ */
+
+
+function stopWatchingForValueChange() {
+  if (!activeElement$1) {
+    return;
+  }
+
+  activeElement$1.detachEvent('onpropertychange', handlePropertyChange);
+  activeElement$1 = null;
+  activeElementInst$1 = null;
+}
+/**
+ * (For IE <=9) Handles a propertychange event, sending a `change` event if
+ * the value of the active element has changed.
+ */
+// $FlowFixMe[missing-local-annot]
+
+
+function handlePropertyChange(nativeEvent) {
+  if (nativeEvent.propertyName !== 'value') {
+    return;
+  }
+
+  if (getInstIfValueChanged(activeElementInst$1)) {
+    manualDispatchChangeEvent(nativeEvent);
+  }
+}
+
+function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
+  if (domEventName === 'focusin') {
+    // In IE9, propertychange fires for most input events but is buggy and
+    // doesn't fire when text is deleted, but conveniently, selectionchange
+    // appears to fire in all of the remaining cases so we catch those and
+    // forward the event if the value has changed
+    // In either case, we don't want to call the event handler if the value
+    // is changed from JS so we redefine a setter for `.value` that updates
+    // our activeElementValue variable, allowing us to ignore those changes
+    //
+    // stopWatching() should be a noop here but we call it just in case we
+    // missed a blur event somehow.
+    stopWatchingForValueChange();
+    startWatchingForValueChange(target, targetInst);
+  } else if (domEventName === 'focusout') {
+    stopWatchingForValueChange();
+  }
+} // For IE8 and IE9.
+
+
+function getTargetInstForInputEventPolyfill(domEventName, targetInst) {
+  if (domEventName === 'selectionchange' || domEventName === 'keyup' || domEventName === 'keydown') {
+    // On the selectionchange event, the target is just document which isn't
+    // helpful for us so just check activeElement instead.
+    //
+    // 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire
+    // propertychange on the first input event after setting `value` from a
+    // script and fires only keydown, keypress, keyup. Catching keyup usually
+    // gets it and catching keydown lets us fire an event for the first
+    // keystroke if user does a key repeat (it'll be a little delayed: right
+    // before the second keystroke). Other input methods (e.g., paste) seem to
+    // fire selectionchange normally.
+    return getInstIfValueChanged(activeElementInst$1);
+  }
+}
+/**
+ * SECTION: handle `click` event
+ */
+
+
+function shouldUseClickEvent(elem) {
+  // Use the `click` event to detect changes to checkbox and radio inputs.
+  // This approach works across all browsers, whereas `change` does not fire
+  // until `blur` in IE8.
+  const nodeName = elem.nodeName;
+  return nodeName && nodeName.toLowerCase() === 'input' && (elem.type === 'checkbox' || elem.type === 'radio');
+}
+
+function getTargetInstForClickEvent(domEventName, targetInst) {
+  if (domEventName === 'click') {
+    return getInstIfValueChanged(targetInst);
+  }
+}
+
+function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
+  if (domEventName === 'input' || domEventName === 'change') {
+    return getInstIfValueChanged(targetInst);
+  }
+}
+
+function handleControlledInputBlur(node, props) {
+  if (node.type !== 'number') {
+    return;
+  }
+
+  {
+    const isControlled = props.value != null;
+
+    if (isControlled) {
+      // If controlled, assign the value attribute to the current value on blur
+      setDefaultValue(node, 'number', node.value);
+    }
+  }
+}
+/**
+ * This plugin creates an `onChange` event that normalizes change events
+ * across form elements. This event fires at a time when it's possible to
+ * change the element's value without seeing a flicker.
+ *
+ * Supported elements are:
+ * - input (see `isTextInputElement`)
+ * - textarea
+ * - select
+ */
+
+
+function extractEvents$4(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  const targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
+  let getTargetInstFunc, handleEventFunc;
+
+  if (shouldUseChangeEvent(targetNode)) {
+    getTargetInstFunc = getTargetInstForChangeEvent;
+  } else if (isTextInputElement(targetNode)) {
+    if (isInputEventSupported) {
+      getTargetInstFunc = getTargetInstForInputOrChangeEvent;
+    } else {
+      getTargetInstFunc = getTargetInstForInputEventPolyfill;
+      handleEventFunc = handleEventsForInputEventPolyfill;
+    }
+  } else if (shouldUseClickEvent(targetNode)) {
+    getTargetInstFunc = getTargetInstForClickEvent;
+  } else if (targetInst && isCustomElement(targetInst.elementType)) {
+    getTargetInstFunc = getTargetInstForChangeEvent;
+  }
+
+  if (getTargetInstFunc) {
+    const inst = getTargetInstFunc(domEventName, targetInst);
+
+    if (inst) {
+      createAndAccumulateChangeEvent(dispatchQueue, inst, nativeEvent, nativeEventTarget);
+      return;
+    }
+  }
+
+  if (handleEventFunc) {
+    handleEventFunc(domEventName, targetNode, targetInst);
+  } // When blurring, set the value attribute for number inputs
+
+
+  if (domEventName === 'focusout' && targetInst) {
+    // These props aren't necessarily the most current but we warn for changing
+    // between controlled and uncontrolled, so it doesn't matter and the previous
+    // code was also broken for changes.
+    const props = targetInst.memoizedProps;
+    handleControlledInputBlur(targetNode, props);
+  }
+}
+
+function registerEvents$1() {
+  registerDirectEvent('onMouseEnter', ['mouseout', 'mouseover']);
+  registerDirectEvent('onMouseLeave', ['mouseout', 'mouseover']);
+  registerDirectEvent('onPointerEnter', ['pointerout', 'pointerover']);
+  registerDirectEvent('onPointerLeave', ['pointerout', 'pointerover']);
+}
+/**
+ * For almost every interaction we care about, there will be both a top-level
+ * `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that
+ * we do not extract duplicate events. However, moving the mouse into the
+ * browser from outside will not fire a `mouseout` event. In this case, we use
+ * the `mouseover` top-level event.
+ */
+
+
+function extractEvents$3(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  const isOverEvent = domEventName === 'mouseover' || domEventName === 'pointerover';
+  const isOutEvent = domEventName === 'mouseout' || domEventName === 'pointerout';
+
+  if (isOverEvent && !isReplayingEvent(nativeEvent)) {
+    // If this is an over event with a target, we might have already dispatched
+    // the event in the out event of the other target. If this is replayed,
+    // then it's because we couldn't dispatch against this target previously
+    // so we have to do it now instead.
+    const related = nativeEvent.relatedTarget || nativeEvent.fromElement;
+
+    if (related) {
+      // If the related node is managed by React, we can assume that we have
+      // already dispatched the corresponding events during its mouseout.
+      if (getClosestInstanceFromNode(related) || isContainerMarkedAsRoot(related)) {
+        return;
+      }
+    }
+  }
+
+  if (!isOutEvent && !isOverEvent) {
+    // Must not be a mouse or pointer in or out - ignoring.
+    return;
+  }
+
+  let win; // TODO: why is this nullable in the types but we read from it?
+
+  if (nativeEventTarget.window === nativeEventTarget) {
+    // `nativeEventTarget` is probably a window object.
+    win = nativeEventTarget;
+  } else {
+    // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.
+    const doc = nativeEventTarget.ownerDocument;
+
+    if (doc) {
+      win = doc.defaultView || doc.parentWindow;
+    } else {
+      win = window;
+    }
+  }
+
+  let from;
+  let to;
+
+  if (isOutEvent) {
+    const related = nativeEvent.relatedTarget || nativeEvent.toElement;
+    from = targetInst;
+    to = related ? getClosestInstanceFromNode(related) : null;
+
+    if (to !== null) {
+      const nearestMounted = getNearestMountedFiber(to);
+      const tag = to.tag;
+
+      if (to !== nearestMounted || tag !== HostComponent && (tag !== HostSingleton) && tag !== HostText) {
+        to = null;
+      }
+    }
+  } else {
+    // Moving to a node from outside the window.
+    from = null;
+    to = targetInst;
+  }
+
+  if (from === to) {
+    // Nothing pertains to our managed components.
+    return;
+  }
+
+  let SyntheticEventCtor = SyntheticMouseEvent;
+  let leaveEventType = 'onMouseLeave';
+  let enterEventType = 'onMouseEnter';
+  let eventTypePrefix = 'mouse';
+
+  if (domEventName === 'pointerout' || domEventName === 'pointerover') {
+    SyntheticEventCtor = SyntheticPointerEvent;
+    leaveEventType = 'onPointerLeave';
+    enterEventType = 'onPointerEnter';
+    eventTypePrefix = 'pointer';
+  }
+
+  const fromNode = from == null ? win : getNodeFromInstance(from);
+  const toNode = to == null ? win : getNodeFromInstance(to);
+  const leave = new SyntheticEventCtor(leaveEventType, eventTypePrefix + 'leave', from, nativeEvent, nativeEventTarget);
+  leave.target = fromNode;
+  leave.relatedTarget = toNode;
+  let enter = null; // We should only process this nativeEvent if we are processing
+  // the first ancestor. Next time, we will ignore the event.
+
+  const nativeTargetInst = getClosestInstanceFromNode(nativeEventTarget);
+
+  if (nativeTargetInst === targetInst) {
+    const enterEvent = new SyntheticEventCtor(enterEventType, eventTypePrefix + 'enter', to, nativeEvent, nativeEventTarget);
+    enterEvent.target = toNode;
+    enterEvent.relatedTarget = fromNode;
+    enter = enterEvent;
+  }
+
+  accumulateEnterLeaveTwoPhaseListeners(dispatchQueue, leave, enter, from, to);
+}
+
+/**
+ * Given any node return the first leaf node without children.
+ *
+ * @param {DOMElement|DOMTextNode} node
+ * @return {DOMElement|DOMTextNode}
+ */
+
+function getLeafNode(node) {
+  while (node && node.firstChild) {
+    node = node.firstChild;
+  }
+
+  return node;
+}
+/**
+ * Get the next sibling within a container. This will walk up the
+ * DOM if a node's siblings have been exhausted.
+ *
+ * @param {DOMElement|DOMTextNode} node
+ * @return {?DOMElement|DOMTextNode}
+ */
+
+
+function getSiblingNode(node) {
+  while (node) {
+    if (node.nextSibling) {
+      return node.nextSibling;
+    }
+
+    node = node.parentNode;
+  }
+}
+/**
+ * Get object describing the nodes which contain characters at offset.
+ *
+ * @param {DOMElement|DOMTextNode} root
+ * @param {number} offset
+ * @return {?object}
+ */
+
+
+function getNodeForCharacterOffset(root, offset) {
+  let node = getLeafNode(root);
+  let nodeStart = 0;
+  let nodeEnd = 0;
+
+  while (node) {
+    if (node.nodeType === TEXT_NODE) {
+      nodeEnd = nodeStart + node.textContent.length;
+
+      if (nodeStart <= offset && nodeEnd >= offset) {
+        return {
+          node: node,
+          offset: offset - nodeStart
+        };
+      }
+
+      nodeStart = nodeEnd;
+    }
+
+    node = getLeafNode(getSiblingNode(node));
+  }
+}
+
+/**
+ * @param {DOMElement} outerNode
+ * @return {?object}
+ */
+
+function getOffsets(outerNode) {
+  const ownerDocument = outerNode.ownerDocument;
+  const win = ownerDocument && ownerDocument.defaultView || window;
+  const selection = win.getSelection && win.getSelection();
+
+  if (!selection || selection.rangeCount === 0) {
+    return null;
+  }
+
+  const anchorNode = selection.anchorNode,
+        anchorOffset = selection.anchorOffset,
+        focusNode = selection.focusNode,
+        focusOffset = selection.focusOffset; // In Firefox, anchorNode and focusNode can be "anonymous divs", e.g. the
+  // up/down buttons on an <input type="number">. Anonymous divs do not seem to
+  // expose properties, triggering a "Permission denied error" if any of its
+  // properties are accessed. The only seemingly possible way to avoid erroring
+  // is to access a property that typically works for non-anonymous divs and
+  // catch any error that may otherwise arise. See
+  // https://bugzilla.mozilla.org/show_bug.cgi?id=208427
+
+  try {
+    /* eslint-disable ft-flow/no-unused-expressions */
+    anchorNode.nodeType;
+    focusNode.nodeType;
+    /* eslint-enable ft-flow/no-unused-expressions */
+  } catch (e) {
+    return null;
+  }
+
+  return getModernOffsetsFromPoints(outerNode, anchorNode, anchorOffset, focusNode, focusOffset);
+}
+/**
+ * Returns {start, end} where `start` is the character/codepoint index of
+ * (anchorNode, anchorOffset) within the textContent of `outerNode`, and
+ * `end` is the index of (focusNode, focusOffset).
+ *
+ * Returns null if you pass in garbage input but we should probably just crash.
+ *
+ * Exported only for testing.
+ */
+
+function getModernOffsetsFromPoints(outerNode, anchorNode, anchorOffset, focusNode, focusOffset) {
+  let length = 0;
+  let start = -1;
+  let end = -1;
+  let indexWithinAnchor = 0;
+  let indexWithinFocus = 0;
+  let node = outerNode;
+  let parentNode = null;
+
+  outer: while (true) {
+    let next = null;
+
+    while (true) {
+      if (node === anchorNode && (anchorOffset === 0 || node.nodeType === TEXT_NODE)) {
+        start = length + anchorOffset;
+      }
+
+      if (node === focusNode && (focusOffset === 0 || node.nodeType === TEXT_NODE)) {
+        end = length + focusOffset;
+      }
+
+      if (node.nodeType === TEXT_NODE) {
+        length += node.nodeValue.length;
+      }
+
+      if ((next = node.firstChild) === null) {
+        break;
+      } // Moving from `node` to its first child `next`.
+
+
+      parentNode = node;
+      node = next;
+    }
+
+    while (true) {
+      if (node === outerNode) {
+        // If `outerNode` has children, this is always the second time visiting
+        // it. If it has no children, this is still the first loop, and the only
+        // valid selection is anchorNode and focusNode both equal to this node
+        // and both offsets 0, in which case we will have handled above.
+        break outer;
+      }
+
+      if (parentNode === anchorNode && ++indexWithinAnchor === anchorOffset) {
+        start = length;
+      }
+
+      if (parentNode === focusNode && ++indexWithinFocus === focusOffset) {
+        end = length;
+      }
+
+      if ((next = node.nextSibling) !== null) {
+        break;
+      }
+
+      node = parentNode;
+      parentNode = node.parentNode;
+    } // Moving from `node` to its next sibling `next`.
+
+
+    node = next;
+  }
+
+  if (start === -1 || end === -1) {
+    // This should never happen. (Would happen if the anchor/focus nodes aren't
+    // actually inside the passed-in node.)
+    return null;
+  }
+
+  return {
+    start: start,
+    end: end
+  };
+}
+/**
+ * In modern non-IE browsers, we can support both forward and backward
+ * selections.
+ *
+ * Note: IE10+ supports the Selection object, but it does not support
+ * the `extend` method, which means that even in modern IE, it's not possible
+ * to programmatically create a backward selection. Thus, for all IE
+ * versions, we use the old IE API to create our selections.
+ *
+ * @param {DOMElement|DOMTextNode} node
+ * @param {object} offsets
+ */
+
+function setOffsets(node, offsets) {
+  const doc = node.ownerDocument || document;
+  const win = doc && doc.defaultView || window; // Edge fails with "Object expected" in some scenarios.
+  // (For instance: TinyMCE editor used in a list component that supports pasting to add more,
+  // fails when pasting 100+ items)
+
+  if (!win.getSelection) {
+    return;
+  }
+
+  const selection = win.getSelection();
+  const length = node.textContent.length;
+  let start = Math.min(offsets.start, length);
+  let end = offsets.end === undefined ? start : Math.min(offsets.end, length); // IE 11 uses modern selection, but doesn't support the extend method.
+  // Flip backward selections, so we can set with a single range.
+
+  if (!selection.extend && start > end) {
+    const temp = end;
+    end = start;
+    start = temp;
+  }
+
+  const startMarker = getNodeForCharacterOffset(node, start);
+  const endMarker = getNodeForCharacterOffset(node, end);
+
+  if (startMarker && endMarker) {
+    if (selection.rangeCount === 1 && selection.anchorNode === startMarker.node && selection.anchorOffset === startMarker.offset && selection.focusNode === endMarker.node && selection.focusOffset === endMarker.offset) {
+      return;
+    }
+
+    const range = doc.createRange();
+    range.setStart(startMarker.node, startMarker.offset);
+    selection.removeAllRanges();
+
+    if (start > end) {
+      selection.addRange(range);
+      selection.extend(endMarker.node, endMarker.offset);
+    } else {
+      range.setEnd(endMarker.node, endMarker.offset);
+      selection.addRange(range);
+    }
+  }
+}
+
+function isTextNode(node) {
+  return node && node.nodeType === TEXT_NODE;
+}
+
+function containsNode(outerNode, innerNode) {
+  if (!outerNode || !innerNode) {
+    return false;
+  } else if (outerNode === innerNode) {
+    return true;
+  } else if (isTextNode(outerNode)) {
+    return false;
+  } else if (isTextNode(innerNode)) {
+    return containsNode(outerNode, innerNode.parentNode);
+  } else if ('contains' in outerNode) {
+    return outerNode.contains(innerNode);
+  } else if (outerNode.compareDocumentPosition) {
+    return !!(outerNode.compareDocumentPosition(innerNode) & 16);
+  } else {
+    return false;
+  }
+}
+
+function isInDocument(node) {
+  return node && node.ownerDocument && containsNode(node.ownerDocument.documentElement, node);
+}
+
+function isSameOriginFrame(iframe) {
+  try {
+    // Accessing the contentDocument of a HTMLIframeElement can cause the browser
+    // to throw, e.g. if it has a cross-origin src attribute.
+    // Safari will show an error in the console when the access results in "Blocked a frame with origin". e.g:
+    // iframe.contentDocument.defaultView;
+    // A safety way is to access one of the cross origin properties: Window or Location
+    // Which might result in "SecurityError" DOM Exception and it is compatible to Safari.
+    // https://html.spec.whatwg.org/multipage/browsers.html#integration-with-idl
+    return typeof iframe.contentWindow.location.href === 'string';
+  } catch (err) {
+    return false;
+  }
+}
+
+function getActiveElementDeep() {
+  let win = window;
+  let element = getActiveElement();
+
+  while (element instanceof win.HTMLIFrameElement) {
+    if (isSameOriginFrame(element)) {
+      win = element.contentWindow;
+    } else {
+      return element;
+    }
+
+    element = getActiveElement(win.document);
+  }
+
+  return element;
+}
+/**
+ * @ReactInputSelection: React input selection module. Based on Selection.js,
+ * but modified to be suitable for react and has a couple of bug fixes (doesn't
+ * assume buttons have range selections allowed).
+ * Input selection module for React.
+ */
+
+/**
+ * @hasSelectionCapabilities: we get the element types that support selection
+ * from https://html.spec.whatwg.org/#do-not-apply, looking at `selectionStart`
+ * and `selectionEnd` rows.
+ */
+
+
+function hasSelectionCapabilities(elem) {
+  const nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+  return nodeName && (nodeName === 'input' && (elem.type === 'text' || elem.type === 'search' || elem.type === 'tel' || elem.type === 'url' || elem.type === 'password') || nodeName === 'textarea' || elem.contentEditable === 'true');
+}
+function getSelectionInformation() {
+  const focusedElem = getActiveElementDeep();
+  return {
+    focusedElem: focusedElem,
+    selectionRange: hasSelectionCapabilities(focusedElem) ? getSelection$1(focusedElem) : null
+  };
+}
+/**
+ * @restoreSelection: If any selection information was potentially lost,
+ * restore it. This is useful when performing operations that could remove dom
+ * nodes and place them back in, resulting in focus being lost.
+ */
+
+function restoreSelection(priorSelectionInformation) {
+  const curFocusedElem = getActiveElementDeep();
+  const priorFocusedElem = priorSelectionInformation.focusedElem;
+  const priorSelectionRange = priorSelectionInformation.selectionRange;
+
+  if (curFocusedElem !== priorFocusedElem && isInDocument(priorFocusedElem)) {
+    if (priorSelectionRange !== null && hasSelectionCapabilities(priorFocusedElem)) {
+      setSelection(priorFocusedElem, priorSelectionRange);
+    } // Focusing a node can change the scroll position, which is undesirable
+
+
+    const ancestors = [];
+    let ancestor = priorFocusedElem;
+
+    while (ancestor = ancestor.parentNode) {
+      if (ancestor.nodeType === ELEMENT_NODE) {
+        ancestors.push({
+          element: ancestor,
+          left: ancestor.scrollLeft,
+          top: ancestor.scrollTop
+        });
+      }
+    }
+
+    if (typeof priorFocusedElem.focus === 'function') {
+      priorFocusedElem.focus();
+    }
+
+    for (let i = 0; i < ancestors.length; i++) {
+      const info = ancestors[i];
+      info.element.scrollLeft = info.left;
+      info.element.scrollTop = info.top;
+    }
+  }
+}
+/**
+ * @getSelection: Gets the selection bounds of a focused textarea, input or
+ * contentEditable node.
+ * -@input: Look up selection bounds of this input
+ * -@return {start: selectionStart, end: selectionEnd}
+ */
+
+function getSelection$1(input) {
+  let selection;
+
+  if ('selectionStart' in input) {
+    // Modern browser with input or textarea.
+    selection = {
+      start: input.selectionStart,
+      end: input.selectionEnd
+    };
+  } else {
+    // Content editable or old IE textarea.
+    selection = getOffsets(input);
+  }
+
+  return selection || {
+    start: 0,
+    end: 0
+  };
+}
+/**
+ * @setSelection: Sets the selection bounds of a textarea or input and focuses
+ * the input.
+ * -@input     Set selection bounds of this input or textarea
+ * -@offsets   Object of same form that is returned from get*
+ */
+
+function setSelection(input, offsets) {
+  const start = offsets.start;
+  let end = offsets.end;
+
+  if (end === undefined) {
+    end = start;
+  }
+
+  if ('selectionStart' in input) {
+    input.selectionStart = start;
+    input.selectionEnd = Math.min(end, input.value.length);
+  } else {
+    setOffsets(input, offsets);
+  }
+}
+
+const skipSelectionChangeEvent = canUseDOM && 'documentMode' in document && document.documentMode <= 11;
+
+function registerEvents() {
+  registerTwoPhaseEvent('onSelect', ['focusout', 'contextmenu', 'dragend', 'focusin', 'keydown', 'keyup', 'mousedown', 'mouseup', 'selectionchange']);
+}
+
+let activeElement = null;
+let activeElementInst = null;
+let lastSelection = null;
+let mouseDown = false;
+/**
+ * Get an object which is a unique representation of the current selection.
+ *
+ * The return value will not be consistent across nodes or browsers, but
+ * two identical selections on the same node will return identical objects.
+ */
+
+function getSelection(node) {
+  if ('selectionStart' in node && hasSelectionCapabilities(node)) {
+    return {
+      start: node.selectionStart,
+      end: node.selectionEnd
+    };
+  } else {
+    const win = node.ownerDocument && node.ownerDocument.defaultView || window;
+    const selection = win.getSelection();
+    return {
+      anchorNode: selection.anchorNode,
+      anchorOffset: selection.anchorOffset,
+      focusNode: selection.focusNode,
+      focusOffset: selection.focusOffset
+    };
+  }
+}
+/**
+ * Get document associated with the event target.
+ */
+
+
+function getEventTargetDocument(eventTarget) {
+  return eventTarget.window === eventTarget ? eventTarget.document : eventTarget.nodeType === DOCUMENT_NODE ? eventTarget : eventTarget.ownerDocument;
+}
+/**
+ * Poll selection to see whether it's changed.
+ *
+ * @param {object} nativeEvent
+ * @param {object} nativeEventTarget
+ * @return {?SyntheticEvent}
+ */
+
+
+function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
+  // Ensure we have the right element, and that the user is not dragging a
+  // selection (this matches native `select` event behavior). In HTML5, select
+  // fires only on input and textarea thus if there's no focused element we
+  // won't dispatch.
+  const doc = getEventTargetDocument(nativeEventTarget);
+
+  if (mouseDown || activeElement == null || activeElement !== getActiveElement(doc)) {
+    return;
+  } // Only fire when selection has actually changed.
+
+
+  const currentSelection = getSelection(activeElement);
+
+  if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {
+    lastSelection = currentSelection;
+    const listeners = accumulateTwoPhaseListeners(activeElementInst, 'onSelect');
+
+    if (listeners.length > 0) {
+      const event = new SyntheticEvent('onSelect', 'select', null, nativeEvent, nativeEventTarget);
+      dispatchQueue.push({
+        event,
+        listeners
+      });
+      event.target = activeElement;
+    }
+  }
+}
+/**
+ * This plugin creates an `onSelect` event that normalizes select events
+ * across form elements.
+ *
+ * Supported elements are:
+ * - input (see `isTextInputElement`)
+ * - textarea
+ * - contentEditable
+ *
+ * This differs from native browser implementations in the following ways:
+ * - Fires on contentEditable fields as well as inputs.
+ * - Fires for collapsed selection.
+ * - Fires after user input.
+ */
+
+
+function extractEvents$2(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  const targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
+
+  switch (domEventName) {
+    // Track the input node that has focus.
+    case 'focusin':
+      if (isTextInputElement(targetNode) || targetNode.contentEditable === 'true') {
+        activeElement = targetNode;
+        activeElementInst = targetInst;
+        lastSelection = null;
+      }
+
+      break;
+
+    case 'focusout':
+      activeElement = null;
+      activeElementInst = null;
+      lastSelection = null;
+      break;
+    // Don't fire the event while the user is dragging. This matches the
+    // semantics of the native select event.
+
+    case 'mousedown':
+      mouseDown = true;
+      break;
+
+    case 'contextmenu':
+    case 'mouseup':
+    case 'dragend':
+      mouseDown = false;
+      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+      break;
+    // Chrome and IE fire non-standard event when selection is changed (and
+    // sometimes when it hasn't). IE's event fires out of order with respect
+    // to key and input events on deletion, so we discard it.
+    //
+    // Firefox doesn't support selectionchange, so check selection status
+    // after each key entry. The selection changes after keydown and before
+    // keyup, but we check on keydown as well in the case of holding down a
+    // key, when multiple keydown events are fired but only one keyup is.
+    // This is also our approach for IE handling, for the reason above.
+
+    case 'selectionchange':
+      if (skipSelectionChangeEvent) {
+        break;
+      }
+
+    // falls through
+
+    case 'keydown':
+    case 'keyup':
+      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+  }
+}
+
+/**
+ * Generate a mapping of standard vendor prefixes using the defined style property and event name.
+ *
+ * @param {string} styleProp
+ * @param {string} eventName
+ * @returns {object}
+ */
+
+function makePrefixMap(styleProp, eventName) {
+  const prefixes = {};
+  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
+  prefixes['Webkit' + styleProp] = 'webkit' + eventName;
+  prefixes['Moz' + styleProp] = 'moz' + eventName;
+  return prefixes;
+}
+/**
+ * A list of event names to a configurable list of vendor prefixes.
+ */
+
+
+const vendorPrefixes = {
+  animationend: makePrefixMap('Animation', 'AnimationEnd'),
+  animationiteration: makePrefixMap('Animation', 'AnimationIteration'),
+  animationstart: makePrefixMap('Animation', 'AnimationStart'),
+  transitionend: makePrefixMap('Transition', 'TransitionEnd')
+};
+/**
+ * Event names that have already been detected and prefixed (if applicable).
+ */
+
+const prefixedEventNames = {};
+/**
+ * Element to check for prefixes on.
+ */
+
+let style = {};
+/**
+ * Bootstrap if a DOM exists.
+ */
+
+if (canUseDOM) {
+  style = document.createElement('div').style; // On some platforms, in particular some releases of Android 4.x,
+  // the un-prefixed "animation" and "transition" properties are defined on the
+  // style object but the events that fire will still be prefixed, so we need
+  // to check if the un-prefixed events are usable, and if not remove them from the map.
+
+  if (!('AnimationEvent' in window)) {
+    delete vendorPrefixes.animationend.animation;
+    delete vendorPrefixes.animationiteration.animation;
+    delete vendorPrefixes.animationstart.animation;
+  } // Same as above
+
+
+  if (!('TransitionEvent' in window)) {
+    delete vendorPrefixes.transitionend.transition;
+  }
+}
+/**
+ * Attempts to determine the correct vendor prefixed event name.
+ *
+ * @param {string} eventName
+ * @returns {string}
+ */
+
+
+function getVendorPrefixedEventName(eventName) {
+  if (prefixedEventNames[eventName]) {
+    return prefixedEventNames[eventName];
+  } else if (!vendorPrefixes[eventName]) {
+    return eventName;
+  }
+
+  const prefixMap = vendorPrefixes[eventName];
+
+  for (const styleProp in prefixMap) {
+    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {
+      return prefixedEventNames[eventName] = prefixMap[styleProp];
+    }
+  }
+
+  return eventName;
+}
+
+const ANIMATION_END = getVendorPrefixedEventName('animationend');
+const ANIMATION_ITERATION = getVendorPrefixedEventName('animationiteration');
+const ANIMATION_START = getVendorPrefixedEventName('animationstart');
+const TRANSITION_END = getVendorPrefixedEventName('transitionend');
+
+const topLevelEventsToReactNames = new Map(); // NOTE: Capitalization is important in this list!
+//
+// E.g. it needs "pointerDown", not "pointerdown".
+// This is because we derive both React name ("onPointerDown")
+// and DOM name ("pointerdown") from the same list.
+//
+// Exceptions that don't match this convention are listed separately.
+//
+// prettier-ignore
+
+const simpleEventPluginEvents = ['abort', 'auxClick', 'cancel', 'canPlay', 'canPlayThrough', 'click', 'close', 'contextMenu', 'copy', 'cut', 'drag', 'dragEnd', 'dragEnter', 'dragExit', 'dragLeave', 'dragOver', 'dragStart', 'drop', 'durationChange', 'emptied', 'encrypted', 'ended', 'error', 'gotPointerCapture', 'input', 'invalid', 'keyDown', 'keyPress', 'keyUp', 'load', 'loadedData', 'loadedMetadata', 'loadStart', 'lostPointerCapture', 'mouseDown', 'mouseMove', 'mouseOut', 'mouseOver', 'mouseUp', 'paste', 'pause', 'play', 'playing', 'pointerCancel', 'pointerDown', 'pointerMove', 'pointerOut', 'pointerOver', 'pointerUp', 'progress', 'rateChange', 'reset', 'resize', 'seeked', 'seeking', 'stalled', 'submit', 'suspend', 'timeUpdate', 'touchCancel', 'touchEnd', 'touchStart', 'volumeChange', 'scroll', 'scrollEnd', 'toggle', 'touchMove', 'waiting', 'wheel'];
+
+function registerSimpleEvent(domEventName, reactName) {
+  topLevelEventsToReactNames.set(domEventName, reactName);
+  registerTwoPhaseEvent(reactName, [domEventName]);
+}
+
+function registerSimpleEvents() {
+  for (let i = 0; i < simpleEventPluginEvents.length; i++) {
+    const eventName = simpleEventPluginEvents[i];
+    const domEventName = eventName.toLowerCase();
+    const capitalizedEvent = eventName[0].toUpperCase() + eventName.slice(1);
+    registerSimpleEvent(domEventName, 'on' + capitalizedEvent);
+  } // Special cases where event names don't match.
+
+
+  registerSimpleEvent(ANIMATION_END, 'onAnimationEnd');
+  registerSimpleEvent(ANIMATION_ITERATION, 'onAnimationIteration');
+  registerSimpleEvent(ANIMATION_START, 'onAnimationStart');
+  registerSimpleEvent('dblclick', 'onDoubleClick');
+  registerSimpleEvent('focusin', 'onFocus');
+  registerSimpleEvent('focusout', 'onBlur');
+  registerSimpleEvent(TRANSITION_END, 'onTransitionEnd');
+}
+
+function extractEvents$1(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  const reactName = topLevelEventsToReactNames.get(domEventName);
+
+  if (reactName === undefined) {
+    return;
+  }
+
+  let SyntheticEventCtor = SyntheticEvent;
+  let reactEventType = domEventName;
+
+  switch (domEventName) {
+    case 'keypress':
+      // Firefox creates a keypress event for function keys too. This removes
+      // the unwanted keypress events. Enter is however both printable and
+      // non-printable. One would expect Tab to be as well (but it isn't).
+      // TODO: Fixed in https://bugzilla.mozilla.org/show_bug.cgi?id=968056. Can
+      // probably remove.
+      if (getEventCharCode(nativeEvent) === 0) {
+        return;
+      }
+
+    /* falls through */
+
+    case 'keydown':
+    case 'keyup':
+      SyntheticEventCtor = SyntheticKeyboardEvent;
+      break;
+
+    case 'focusin':
+      reactEventType = 'focus';
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
+
+    case 'focusout':
+      reactEventType = 'blur';
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
+
+    case 'beforeblur':
+    case 'afterblur':
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
+
+    case 'click':
+      // Firefox creates a click event on right mouse clicks. This removes the
+      // unwanted click events.
+      // TODO: Fixed in https://phabricator.services.mozilla.com/D26793. Can
+      // probably remove.
+      if (nativeEvent.button === 2) {
+        return;
+      }
+
+    /* falls through */
+
+    case 'auxclick':
+    case 'dblclick':
+    case 'mousedown':
+    case 'mousemove':
+    case 'mouseup': // TODO: Disabled elements should not respond to mouse events
+
+    /* falls through */
+
+    case 'mouseout':
+    case 'mouseover':
+    case 'contextmenu':
+      SyntheticEventCtor = SyntheticMouseEvent;
+      break;
+
+    case 'drag':
+    case 'dragend':
+    case 'dragenter':
+    case 'dragexit':
+    case 'dragleave':
+    case 'dragover':
+    case 'dragstart':
+    case 'drop':
+      SyntheticEventCtor = SyntheticDragEvent;
+      break;
+
+    case 'touchcancel':
+    case 'touchend':
+    case 'touchmove':
+    case 'touchstart':
+      SyntheticEventCtor = SyntheticTouchEvent;
+      break;
+
+    case ANIMATION_END:
+    case ANIMATION_ITERATION:
+    case ANIMATION_START:
+      SyntheticEventCtor = SyntheticAnimationEvent;
+      break;
+
+    case TRANSITION_END:
+      SyntheticEventCtor = SyntheticTransitionEvent;
+      break;
+
+    case 'scroll':
+    case 'scrollend':
+      SyntheticEventCtor = SyntheticUIEvent;
+      break;
+
+    case 'wheel':
+      SyntheticEventCtor = SyntheticWheelEvent;
+      break;
+
+    case 'copy':
+    case 'cut':
+    case 'paste':
+      SyntheticEventCtor = SyntheticClipboardEvent;
+      break;
+
+    case 'gotpointercapture':
+    case 'lostpointercapture':
+    case 'pointercancel':
+    case 'pointerdown':
+    case 'pointermove':
+    case 'pointerout':
+    case 'pointerover':
+    case 'pointerup':
+      SyntheticEventCtor = SyntheticPointerEvent;
+      break;
+  }
+
+  const inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
+
+  {
+    // Some events don't bubble in the browser.
+    // In the past, React has always bubbled them, but this can be surprising.
+    // We're going to try aligning closer to the browser behavior by not bubbling
+    // them in React either. We'll start by not bubbling onScroll, and then expand.
+    const accumulateTargetOnly = !inCapturePhase && ( // TODO: ideally, we'd eventually add all events from
+    // nonDelegatedEvents list in DOMPluginEventSystem.
+    // Then we can remove this special list.
+    // This is a breaking change that can wait until React 18.
+    domEventName === 'scroll' || domEventName === 'scrollend');
+    const listeners = accumulateSinglePhaseListeners(targetInst, reactName, nativeEvent.type, inCapturePhase, accumulateTargetOnly);
+
+    if (listeners.length > 0) {
+      // Intentionally create event lazily.
+      const event = new SyntheticEventCtor(reactName, reactEventType, null, nativeEvent, nativeEventTarget);
+      dispatchQueue.push({
+        event,
+        listeners
+      });
+    }
+  }
+}
+
+registerSimpleEvents();
+registerEvents$1();
+registerEvents$2();
+registerEvents();
+registerEvents$3();
+
+function extractEvents(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  // TODO: we should remove the concept of a "SimpleEventPlugin".
+  // This is the basic functionality of the event system. All
+  // the other plugins are essentially polyfills. So the plugin
+  // should probably be inlined somewhere and have its logic
+  // be core the to event system. This would potentially allow
+  // us to ship builds of React without the polyfilled plugins below.
+  extractEvents$1(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags);
+  const shouldProcessPolyfillPlugins = (eventSystemFlags & SHOULD_NOT_PROCESS_POLYFILL_EVENT_PLUGINS) === 0; // We don't process these events unless we are in the
+  // event's native "bubble" phase, which means that we're
+  // not in the capture phase. That's because we emulate
+  // the capture phase here still. This is a trade-off,
+  // because in an ideal world we would not emulate and use
+  // the phases properly, like we do with the SimpleEvent
+  // plugin. However, the plugins below either expect
+  // emulation (EnterLeave) or use state localized to that
+  // plugin (BeforeInput, Change, Select). The state in
+  // these modules complicates things, as you'll essentially
+  // get the case where the capture phase event might change
+  // state, only for the following bubble event to come in
+  // later and not trigger anything as the state now
+  // invalidates the heuristics of the event plugin. We
+  // could alter all these plugins to work in such ways, but
+  // that might cause other unknown side-effects that we
+  // can't foresee right now.
+
+  if (shouldProcessPolyfillPlugins) {
+    extractEvents$3(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+    extractEvents$4(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+    extractEvents$2(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+    extractEvents$5(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+
+    {
+      extractEvents$6(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+    }
+  }
+} // List of events that need to be individually attached to media elements.
+
+
+const mediaEventTypes = ['abort', 'canplay', 'canplaythrough', 'durationchange', 'emptied', 'encrypted', 'ended', 'error', 'loadeddata', 'loadedmetadata', 'loadstart', 'pause', 'play', 'playing', 'progress', 'ratechange', 'resize', 'seeked', 'seeking', 'stalled', 'suspend', 'timeupdate', 'volumechange', 'waiting']; // We should not delegate these events to the container, but rather
+// set them on the actual target element itself. This is primarily
+// because these events do not consistently bubble in the DOM.
+
+const nonDelegatedEvents = new Set(['cancel', 'close', 'invalid', 'load', 'scroll', 'scrollend', 'toggle'].concat(mediaEventTypes));
+
+function executeDispatch(event, listener, currentTarget) {
+  const type = event.type || 'unknown-event';
+  event.currentTarget = currentTarget;
+  invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
+  event.currentTarget = null;
+}
+
+function processDispatchQueueItemsInOrder(event, dispatchListeners, inCapturePhase) {
+  let previousInstance;
+
+  if (inCapturePhase) {
+    for (let i = dispatchListeners.length - 1; i >= 0; i--) {
+      const _dispatchListeners$i = dispatchListeners[i],
+            instance = _dispatchListeners$i.instance,
+            currentTarget = _dispatchListeners$i.currentTarget,
+            listener = _dispatchListeners$i.listener;
+
+      if (instance !== previousInstance && event.isPropagationStopped()) {
+        return;
+      }
+
+      executeDispatch(event, listener, currentTarget);
+      previousInstance = instance;
+    }
+  } else {
+    for (let i = 0; i < dispatchListeners.length; i++) {
+      const _dispatchListeners$i2 = dispatchListeners[i],
+            instance = _dispatchListeners$i2.instance,
+            currentTarget = _dispatchListeners$i2.currentTarget,
+            listener = _dispatchListeners$i2.listener;
+
+      if (instance !== previousInstance && event.isPropagationStopped()) {
+        return;
+      }
+
+      executeDispatch(event, listener, currentTarget);
+      previousInstance = instance;
+    }
+  }
+}
+
+function processDispatchQueue(dispatchQueue, eventSystemFlags) {
+  const inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
+
+  for (let i = 0; i < dispatchQueue.length; i++) {
+    const _dispatchQueue$i = dispatchQueue[i],
+          event = _dispatchQueue$i.event,
+          listeners = _dispatchQueue$i.listeners;
+    processDispatchQueueItemsInOrder(event, listeners, inCapturePhase); //  event system doesn't use pooling.
+  } // This would be a good time to rethrow if any of the event handlers threw.
+
+
+  rethrowCaughtError();
+}
+
+function dispatchEventsForPlugins(domEventName, eventSystemFlags, nativeEvent, targetInst, targetContainer) {
+  const nativeEventTarget = getEventTarget(nativeEvent);
+  const dispatchQueue = [];
+  extractEvents(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags);
+  processDispatchQueue(dispatchQueue, eventSystemFlags);
+}
+
+function listenToNonDelegatedEvent(domEventName, targetElement) {
+
+  const isCapturePhaseListener = false;
+  const listenerSet = getEventListenerSet(targetElement);
+  const listenerSetKey = getListenerSetKey(domEventName, isCapturePhaseListener);
+
+  if (!listenerSet.has(listenerSetKey)) {
+    addTrappedEventListener(targetElement, domEventName, IS_NON_DELEGATED, isCapturePhaseListener);
+    listenerSet.add(listenerSetKey);
+  }
+}
+function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
+
+  let eventSystemFlags = 0;
+
+  if (isCapturePhaseListener) {
+    eventSystemFlags |= IS_CAPTURE_PHASE;
+  }
+
+  addTrappedEventListener(target, domEventName, eventSystemFlags, isCapturePhaseListener);
+} // This is only used by createEventHandle when the
+const listeningMarker = '_reactListening' + Math.random().toString(36).slice(2);
+function listenToAllSupportedEvents(rootContainerElement) {
+  if (!rootContainerElement[listeningMarker]) {
+    rootContainerElement[listeningMarker] = true;
+    allNativeEvents.forEach(domEventName => {
+      // We handle selectionchange separately because it
+      // doesn't bubble and needs to be on the document.
+      if (domEventName !== 'selectionchange') {
+        if (!nonDelegatedEvents.has(domEventName)) {
+          listenToNativeEvent(domEventName, false, rootContainerElement);
+        }
+
+        listenToNativeEvent(domEventName, true, rootContainerElement);
+      }
+    });
+    const ownerDocument = rootContainerElement.nodeType === DOCUMENT_NODE ? rootContainerElement : rootContainerElement.ownerDocument;
+
+    if (ownerDocument !== null) {
+      // The selectionchange event also needs deduplication
+      // but it is attached to the document.
+      if (!ownerDocument[listeningMarker]) {
+        ownerDocument[listeningMarker] = true;
+        listenToNativeEvent('selectionchange', false, ownerDocument);
+      }
+    }
+  }
+}
+
+function addTrappedEventListener(targetContainer, domEventName, eventSystemFlags, isCapturePhaseListener, isDeferredListenerForLegacyFBSupport) {
+  let listener = createEventListenerWrapperWithPriority(targetContainer, domEventName, eventSystemFlags); // If passive option is not supported, then the event will be
+  // active and not passive.
+
+  let isPassiveListener = undefined;
+
+  if (passiveBrowserEventsSupported) {
+    // Browsers introduced an intervention, making these events
+    // passive by default on document. React doesn't bind them
+    // to document anymore, but changing this now would undo
+    // the performance wins from the change. So we emulate
+    // the existing behavior manually on the roots now.
+    // https://github.com/facebook/react/issues/19651
+    if (domEventName === 'touchstart' || domEventName === 'touchmove' || domEventName === 'wheel') {
+      isPassiveListener = true;
+    }
+  }
+
+  targetContainer = targetContainer;
+
+
+  if (isCapturePhaseListener) {
+    if (isPassiveListener !== undefined) {
+      addEventCaptureListenerWithPassiveFlag(targetContainer, domEventName, listener, isPassiveListener);
+    } else {
+      addEventCaptureListener(targetContainer, domEventName, listener);
+    }
+  } else {
+    if (isPassiveListener !== undefined) {
+      addEventBubbleListenerWithPassiveFlag(targetContainer, domEventName, listener, isPassiveListener);
+    } else {
+      addEventBubbleListener(targetContainer, domEventName, listener);
+    }
+  }
+}
+
+function isMatchingRootContainer(grandContainer, targetContainer) {
+  return grandContainer === targetContainer || grandContainer.nodeType === COMMENT_NODE && grandContainer.parentNode === targetContainer;
+}
+
+function dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, targetInst, targetContainer) {
+  let ancestorInst = targetInst;
+
+  if ((eventSystemFlags & IS_EVENT_HANDLE_NON_MANAGED_NODE) === 0 && (eventSystemFlags & IS_NON_DELEGATED) === 0) {
+    const targetContainerNode = targetContainer; // If we are using the legacy FB support flag, we
+
+    if (targetInst !== null) {
+      // The below logic attempts to work out if we need to change
+      // the target fiber to a different ancestor. We had similar logic
+      // in the legacy event system, except the big difference between
+      // systems is that the modern event system now has an event listener
+      // attached to each React Root and React Portal Root. Together,
+      // the DOM nodes representing these roots are the "rootContainer".
+      // To figure out which ancestor instance we should use, we traverse
+      // up the fiber tree from the target instance and attempt to find
+      // root boundaries that match that of our current "rootContainer".
+      // If we find that "rootContainer", we find the parent fiber
+      // sub-tree for that root and make that our ancestor instance.
+      let node = targetInst;
+
+      mainLoop: while (true) {
+        if (node === null) {
+          return;
+        }
+
+        const nodeTag = node.tag;
+
+        if (nodeTag === HostRoot || nodeTag === HostPortal) {
+          let container = node.stateNode.containerInfo;
+
+          if (isMatchingRootContainer(container, targetContainerNode)) {
+            break;
+          }
+
+          if (nodeTag === HostPortal) {
+            // The target is a portal, but it's not the rootContainer we're looking for.
+            // Normally portals handle their own events all the way down to the root.
+            // So we should be able to stop now. However, we don't know if this portal
+            // was part of *our* root.
+            let grandNode = node.return;
+
+            while (grandNode !== null) {
+              const grandTag = grandNode.tag;
+
+              if (grandTag === HostRoot || grandTag === HostPortal) {
+                const grandContainer = grandNode.stateNode.containerInfo;
+
+                if (isMatchingRootContainer(grandContainer, targetContainerNode)) {
+                  // This is the rootContainer we're looking for and we found it as
+                  // a parent of the Portal. That means we can ignore it because the
+                  // Portal will bubble through to us.
+                  return;
+                }
+              }
+
+              grandNode = grandNode.return;
+            }
+          } // Now we need to find it's corresponding host fiber in the other
+          // tree. To do this we can use getClosestInstanceFromNode, but we
+          // need to validate that the fiber is a host instance, otherwise
+          // we need to traverse up through the DOM till we find the correct
+          // node that is from the other tree.
+
+
+          while (container !== null) {
+            const parentNode = getClosestInstanceFromNode(container);
+
+            if (parentNode === null) {
+              return;
+            }
+
+            const parentTag = parentNode.tag;
+
+            if (parentTag === HostComponent || parentTag === HostText || (parentTag === HostHoistable ) || (parentTag === HostSingleton )) {
+              node = ancestorInst = parentNode;
+              continue mainLoop;
+            }
+
+            container = container.parentNode;
+          }
+        }
+
+        node = node.return;
+      }
+    }
+  }
+
+  batchedUpdates(() => dispatchEventsForPlugins(domEventName, eventSystemFlags, nativeEvent, ancestorInst));
+}
+
+function createDispatchListener(instance, listener, currentTarget) {
+  return {
+    instance,
+    listener,
+    currentTarget
+  };
+}
+
+function accumulateSinglePhaseListeners(targetFiber, reactName, nativeEventType, inCapturePhase, accumulateTargetOnly, nativeEvent) {
+  const captureName = reactName !== null ? reactName + 'Capture' : null;
+  const reactEventName = inCapturePhase ? captureName : reactName;
+  let listeners = [];
+  let instance = targetFiber;
+  let lastHostComponent = null; // Accumulate all instances and listeners via the target -> root path.
+
+  while (instance !== null) {
+    const _instance = instance,
+          stateNode = _instance.stateNode,
+          tag = _instance.tag; // Handle listeners that are on HostComponents (i.e. <div>)
+
+    if ((tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton )) && stateNode !== null) {
+      lastHostComponent = stateNode; // createEventHandle listeners
+
+
+      if (reactEventName !== null) {
+        const listener = getListener(instance, reactEventName);
+
+        if (listener != null) {
+          listeners.push(createDispatchListener(instance, listener, lastHostComponent));
+        }
+      }
+    } // If we are only accumulating events for the target, then we don't
+    // continue to propagate through the React fiber tree to find other
+    // listeners.
+
+
+    if (accumulateTargetOnly) {
+      break;
+    } // If we are processing the onBeforeBlur event, then we need to take
+
+    instance = instance.return;
+  }
+
+  return listeners;
+} // We should only use this function for:
+// - BeforeInputEventPlugin
+// - ChangeEventPlugin
+// - SelectEventPlugin
+// This is because we only process these plugins
+// in the bubble phase, so we need to accumulate two
+// phase event listeners (via emulation).
+
+function accumulateTwoPhaseListeners(targetFiber, reactName) {
+  const captureName = reactName + 'Capture';
+  const listeners = [];
+  let instance = targetFiber; // Accumulate all instances and listeners via the target -> root path.
+
+  while (instance !== null) {
+    const _instance2 = instance,
+          stateNode = _instance2.stateNode,
+          tag = _instance2.tag; // Handle listeners that are on HostComponents (i.e. <div>)
+
+    if ((tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton )) && stateNode !== null) {
+      const currentTarget = stateNode;
+      const captureListener = getListener(instance, captureName);
+
+      if (captureListener != null) {
+        listeners.unshift(createDispatchListener(instance, captureListener, currentTarget));
+      }
+
+      const bubbleListener = getListener(instance, reactName);
+
+      if (bubbleListener != null) {
+        listeners.push(createDispatchListener(instance, bubbleListener, currentTarget));
+      }
+    }
+
+    instance = instance.return;
+  }
+
+  return listeners;
+}
+
+function getParent(inst) {
+  if (inst === null) {
+    return null;
+  }
+
+  do {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    inst = inst.return; // TODO: If this is a HostRoot we might want to bail out.
+    // That is depending on if we want nested subtrees (layers) to bubble
+    // events to their parent. We could also go through parentNode on the
+    // host node but that wouldn't work for React Native and doesn't let us
+    // do the portal feature.
+  } while (inst && inst.tag !== HostComponent && (inst.tag !== HostSingleton));
+
+  if (inst) {
+    return inst;
+  }
+
+  return null;
+}
+/**
+ * Return the lowest common ancestor of A and B, or null if they are in
+ * different trees.
+ */
+
+
+function getLowestCommonAncestor(instA, instB) {
+  let nodeA = instA;
+  let nodeB = instB;
+  let depthA = 0;
+
+  for (let tempA = nodeA; tempA; tempA = getParent(tempA)) {
+    depthA++;
+  }
+
+  let depthB = 0;
+
+  for (let tempB = nodeB; tempB; tempB = getParent(tempB)) {
+    depthB++;
+  } // If A is deeper, crawl up.
+
+
+  while (depthA - depthB > 0) {
+    nodeA = getParent(nodeA);
+    depthA--;
+  } // If B is deeper, crawl up.
+
+
+  while (depthB - depthA > 0) {
+    nodeB = getParent(nodeB);
+    depthB--;
+  } // Walk in lockstep until we find a match.
+
+
+  let depth = depthA;
+
+  while (depth--) {
+    if (nodeA === nodeB || nodeB !== null && nodeA === nodeB.alternate) {
+      return nodeA;
+    }
+
+    nodeA = getParent(nodeA);
+    nodeB = getParent(nodeB);
+  }
+
+  return null;
+}
+
+function accumulateEnterLeaveListenersForEvent(dispatchQueue, event, target, common, inCapturePhase) {
+  const registrationName = event._reactName;
+  const listeners = [];
+  let instance = target;
+
+  while (instance !== null) {
+    if (instance === common) {
+      break;
+    }
+
+    const _instance3 = instance,
+          alternate = _instance3.alternate,
+          stateNode = _instance3.stateNode,
+          tag = _instance3.tag;
+
+    if (alternate !== null && alternate === common) {
+      break;
+    }
+
+    if ((tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton )) && stateNode !== null) {
+      const currentTarget = stateNode;
+
+      if (inCapturePhase) {
+        const captureListener = getListener(instance, registrationName);
+
+        if (captureListener != null) {
+          listeners.unshift(createDispatchListener(instance, captureListener, currentTarget));
+        }
+      } else if (!inCapturePhase) {
+        const bubbleListener = getListener(instance, registrationName);
+
+        if (bubbleListener != null) {
+          listeners.push(createDispatchListener(instance, bubbleListener, currentTarget));
+        }
+      }
+    }
+
+    instance = instance.return;
+  }
+
+  if (listeners.length !== 0) {
+    dispatchQueue.push({
+      event,
+      listeners
+    });
+  }
+} // We should only use this function for:
+// - EnterLeaveEventPlugin
+// This is because we only process this plugin
+// in the bubble phase, so we need to accumulate two
+// phase event listeners.
+
+
+function accumulateEnterLeaveTwoPhaseListeners(dispatchQueue, leaveEvent, enterEvent, from, to) {
+  const common = from && to ? getLowestCommonAncestor(from, to) : null;
+
+  if (from !== null) {
+    accumulateEnterLeaveListenersForEvent(dispatchQueue, leaveEvent, from, common, false);
+  }
+
+  if (to !== null && enterEvent !== null) {
+    accumulateEnterLeaveListenersForEvent(dispatchQueue, enterEvent, to, common, true);
+  }
+}
+function getListenerSetKey(domEventName, capture) {
+  return domEventName + "__" + (capture ? 'capture' : 'bubble');
+}
+
+// It also can turn \u0000 into \uFFFD inside attributes.
+// https://www.w3.org/TR/html5/single-page.html#preprocessing-the-input-stream
+// If we have a mismatch, it might be caused by that.
+// We will still patch up in this case but not fire the warning.
+
+
+const NORMALIZE_NEWLINES_REGEX = /\r\n?/g;
+const NORMALIZE_NULL_AND_REPLACEMENT_REGEX = /\u0000|\uFFFD/g;
+
+function normalizeMarkupForTextOrAttribute(markup) {
+
+  const markupString = typeof markup === 'string' ? markup : '' + markup;
+  return markupString.replace(NORMALIZE_NEWLINES_REGEX, '\n').replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, '');
+}
+
+function checkForUnmatchedText(serverText, clientText, isConcurrentMode, shouldWarnDev) {
+  const normalizedClientText = normalizeMarkupForTextOrAttribute(clientText);
+  const normalizedServerText = normalizeMarkupForTextOrAttribute(serverText);
+
+  if (normalizedServerText === normalizedClientText) {
+    return;
+  }
+
+  if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {
+    // In concurrent roots, we throw when there's a text mismatch and revert to
+    // client rendering, up to the nearest Suspense boundary.
+    throw Error(formatProdErrorMessage(425));
+  }
+}
+
+function noop$1() {}
+
+function trapClickOnNonInteractiveElement(node) {
+  // Mobile Safari does not fire properly bubble click events on
+  // non-interactive elements, which means delegated click listeners do not
+  // fire. The workaround for this bug involves attaching an empty click
+  // listener on the target node.
+  // https://www.quirksmode.org/blog/archives/2010/09/click_event_del.html
+  // Just set it using the onclick property so that we don't have to manage any
+  // bookkeeping for it. Not sure if we need to clear it when the listener is
+  // removed.
+  // TODO: Only do this for the relevant Safaris maybe?
+  node.onclick = noop$1;
+}
+const xlinkNamespace = 'http://www.w3.org/1999/xlink';
+const xmlNamespace = 'http://www.w3.org/XML/1998/namespace';
+
+function setProp(domElement, tag, key, value, props, prevValue) {
+  switch (key) {
+    case 'children':
+      {
+        if (typeof value === 'string') {
+          // textContent on a <textarea> will cause the placeholder to not
+          // show within the <textarea> until it has been focused and blurred again.
+          // https://github.com/facebook/react/issues/6731#issuecomment-254874553
+
+
+          const canSetTextContent = (tag !== 'body') && (tag !== 'textarea' || value !== '');
+
+          if (canSetTextContent) {
+            setTextContent(domElement, value);
+          }
+        } else if (typeof value === 'number') {
+
+          const canSetTextContent = tag !== 'body';
+
+          if (canSetTextContent) {
+            setTextContent(domElement, '' + value);
+          }
+        }
+
+        break;
+      }
+    // These are very common props and therefore are in the beginning of the switch.
+    // TODO: aria-label is a very common prop but allows booleans so is not like the others
+    // but should ideally go in this list too.
+
+    case 'className':
+      setValueForKnownAttribute(domElement, 'class', value);
+      break;
+
+    case 'tabIndex':
+      // This has to be case sensitive in SVG.
+      setValueForKnownAttribute(domElement, 'tabindex', value);
+      break;
+
+    case 'dir':
+    case 'role':
+    case 'viewBox':
+    case 'width':
+    case 'height':
+      {
+        setValueForKnownAttribute(domElement, key, value);
+        break;
+      }
+
+    case 'style':
+      {
+        setValueForStyles(domElement, value, prevValue);
+        break;
+      }
+    // These attributes accept URLs. These must not allow javascript: URLS.
+
+    case 'src':
+    case 'href':
+      {
+        {
+          if (value === '') {
+
+            domElement.removeAttribute(key);
+            break;
+          }
+        }
+
+        if (value == null || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          domElement.removeAttribute(key);
+          break;
+        } // `setAttribute` with objects becomes only `[object]` in IE8/9,
+
+        const sanitizedValue = sanitizeURL('' + value);
+        domElement.setAttribute(key, sanitizedValue);
+        break;
+      }
+
+    case 'action':
+    case 'formAction':
+      {
+
+        {
+          if (typeof value === 'function') {
+            // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+            // because we'll preventDefault, but it can happen if a form is manually submitted or
+            // if someone calls stopPropagation before React gets the event.
+            // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+            // error message but the URL will be logged.
+            domElement.setAttribute(key, // eslint-disable-next-line no-script-url
+            "javascript:throw new Error('" + 'A React form was unexpectedly submitted. If you called form.submit() manually, ' + "consider using form.requestSubmit() instead. If you\\'re trying to use " + 'event.stopPropagation() in a submit event handler, consider also calling ' + 'event.preventDefault().' + "')");
+            break;
+          } else if (typeof prevValue === 'function') {
+            // When we're switching off a Server Action that was originally hydrated.
+            // The server control these fields during SSR that are now trailing.
+            // The regular diffing doesn't apply since we compare against the previous props.
+            // Instead, we need to force them to be set to whatever they should be now.
+            // This would be a lot cleaner if we did this whole fork in the per-tag approach.
+            if (key === 'formAction') {
+              if (tag !== 'input') {
+                // Setting the name here isn't completely safe for inputs if this is switching
+                // to become a radio button. In that case we let the tag based override take
+                // control.
+                setProp(domElement, tag, 'name', props.name, props, null);
+              }
+
+              setProp(domElement, tag, 'formEncType', props.formEncType, props, null);
+              setProp(domElement, tag, 'formMethod', props.formMethod, props, null);
+              setProp(domElement, tag, 'formTarget', props.formTarget, props, null);
+            } else {
+              setProp(domElement, tag, 'encType', props.encType, props, null);
+              setProp(domElement, tag, 'method', props.method, props, null);
+              setProp(domElement, tag, 'target', props.target, props, null);
+            }
+          }
+        }
+
+        if (value == null || !enableFormActions  || typeof value === 'symbol' || typeof value === 'boolean') {
+          domElement.removeAttribute(key);
+          break;
+        } // `setAttribute` with objects becomes only `[object]` in IE8/9,
+
+        const sanitizedValue = sanitizeURL('' + value);
+        domElement.setAttribute(key, sanitizedValue);
+        break;
+      }
+
+    case 'onClick':
+      {
+        // TODO: This cast may not be sound for SVG, MathML or custom elements.
+        if (value != null) {
+
+          trapClickOnNonInteractiveElement(domElement);
+        }
+
+        break;
+      }
+
+    case 'onScroll':
+      {
+        if (value != null) {
+
+          listenToNonDelegatedEvent('scroll', domElement);
+        }
+
+        break;
+      }
+
+    case 'onScrollEnd':
+      {
+        if (value != null) {
+
+          listenToNonDelegatedEvent('scrollend', domElement);
+        }
+
+        break;
+      }
+
+    case 'dangerouslySetInnerHTML':
+      {
+        if (value != null) {
+          if (typeof value !== 'object' || !('__html' in value)) {
+            throw Error(formatProdErrorMessage(61));
+          }
+
+          const nextHtml = value.__html;
+
+          if (nextHtml != null) {
+            if (props.children != null) {
+              throw Error(formatProdErrorMessage(60));
+            }
+
+            {
+              domElement.innerHTML = nextHtml;
+            }
+          }
+        }
+
+        break;
+      }
+    // Note: `option.selected` is not updated if `select.multiple` is
+    // disabled with `removeAttribute`. We have special logic for handling this.
+
+    case 'multiple':
+      {
+        domElement.multiple = value && typeof value !== 'function' && typeof value !== 'symbol';
+        break;
+      }
+
+    case 'muted':
+      {
+        domElement.muted = value && typeof value !== 'function' && typeof value !== 'symbol';
+        break;
+      }
+
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'defaultValue': // Reserved
+
+    case 'defaultChecked':
+    case 'innerHTML':
+      {
+        // Noop
+        break;
+      }
+
+    case 'autoFocus':
+      {
+        // We polyfill it separately on the client during commit.
+        // We could have excluded it in the property list instead of
+        // adding a special case here, but then it wouldn't be emitted
+        // on server rendering (but we *do* want to emit it in SSR).
+        break;
+      }
+
+    case 'xlinkHref':
+      {
+        if (value == null || typeof value === 'function' || typeof value === 'boolean' || typeof value === 'symbol') {
+          domElement.removeAttribute('xlink:href');
+          break;
+        } // `setAttribute` with objects becomes only `[object]` in IE8/9,
+
+        const sanitizedValue = sanitizeURL('' + value);
+        domElement.setAttributeNS(xlinkNamespace, 'xlink:href', sanitizedValue);
+        break;
+      }
+
+    case 'contentEditable':
+    case 'spellCheck':
+    case 'draggable':
+    case 'value':
+    case 'autoReverse':
+    case 'externalResourcesRequired':
+    case 'focusable':
+    case 'preserveAlpha':
+      {
+        // Booleanish String
+        // These are "enumerated" attributes that accept "true" and "false".
+        // In React, we let users pass `true` and `false` even though technically
+        // these aren't boolean attributes (they are coerced to strings).
+        // The SVG attributes are case-sensitive. Since the HTML attributes are
+        // insensitive they also work even though we canonically use lower case.
+        if (value != null && typeof value !== 'function' && typeof value !== 'symbol') {
+
+          domElement.setAttribute(key, '' + value);
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+    // Boolean
+
+    case 'allowFullScreen':
+    case 'async':
+    case 'autoPlay':
+    case 'controls':
+    case 'default':
+    case 'defer':
+    case 'disabled':
+    case 'disablePictureInPicture':
+    case 'disableRemotePlayback':
+    case 'formNoValidate':
+    case 'hidden':
+    case 'loop':
+    case 'noModule':
+    case 'noValidate':
+    case 'open':
+    case 'playsInline':
+    case 'readOnly':
+    case 'required':
+    case 'reversed':
+    case 'scoped':
+    case 'seamless':
+    case 'itemScope':
+      {
+        if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+          domElement.setAttribute(key, '');
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+    // Overloaded Boolean
+
+    case 'capture':
+    case 'download':
+      {
+        // An attribute that can be used as a flag as well as with a value.
+        // When true, it should be present (set either to an empty string or its name).
+        // When false, it should be omitted.
+        // For any other value, should be present with that value.
+        if (value === true) {
+          domElement.setAttribute(key, '');
+        } else if (value !== false && value != null && typeof value !== 'function' && typeof value !== 'symbol') {
+
+          domElement.setAttribute(key, value);
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+
+    case 'cols':
+    case 'rows':
+    case 'size':
+    case 'span':
+      {
+        // These are HTML attributes that must be positive numbers.
+        if (value != null && typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value) && value >= 1) {
+
+          domElement.setAttribute(key, value);
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+
+    case 'rowSpan':
+    case 'start':
+      {
+        // These are HTML attributes that must be numbers.
+        if (value != null && typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value)) {
+
+          domElement.setAttribute(key, value);
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+
+    case 'xlinkActuate':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:actuate', value);
+      break;
+
+    case 'xlinkArcrole':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:arcrole', value);
+      break;
+
+    case 'xlinkRole':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:role', value);
+      break;
+
+    case 'xlinkShow':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:show', value);
+      break;
+
+    case 'xlinkTitle':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:title', value);
+      break;
+
+    case 'xlinkType':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:type', value);
+      break;
+
+    case 'xmlBase':
+      setValueForNamespacedAttribute(domElement, xmlNamespace, 'xml:base', value);
+      break;
+
+    case 'xmlLang':
+      setValueForNamespacedAttribute(domElement, xmlNamespace, 'xml:lang', value);
+      break;
+
+    case 'xmlSpace':
+      setValueForNamespacedAttribute(domElement, xmlNamespace, 'xml:space', value);
+      break;
+    // Properties that should not be allowed on custom elements.
+
+    case 'is':
+      {
+        // passed it to createElement. We don't also need the attribute.
+        // However, our tests currently query for it so it's plausible someone
+        // else does too so it's break.
+
+
+        setValueForAttribute(domElement, 'is', value);
+        break;
+      }
+
+    case 'innerText':
+    case 'textContent':
+      {
+        break;
+      }
+
+    // Fall through
+
+    default:
+      {
+        if (key.length > 2 && (key[0] === 'o' || key[0] === 'O') && (key[1] === 'n' || key[1] === 'N')) ; else {
+          const attributeName = getAttributeAlias(key);
+          setValueForAttribute(domElement, attributeName, value);
+        }
+      }
+  }
+}
+
+function setPropOnCustomElement(domElement, tag, key, value, props, prevValue) {
+  switch (key) {
+    case 'style':
+      {
+        setValueForStyles(domElement, value, prevValue);
+        break;
+      }
+
+    case 'dangerouslySetInnerHTML':
+      {
+        if (value != null) {
+          if (typeof value !== 'object' || !('__html' in value)) {
+            throw Error(formatProdErrorMessage(61));
+          }
+
+          const nextHtml = value.__html;
+
+          if (nextHtml != null) {
+            if (props.children != null) {
+              throw Error(formatProdErrorMessage(60));
+            }
+
+            {
+              domElement.innerHTML = nextHtml;
+            }
+          }
+        }
+
+        break;
+      }
+
+    case 'children':
+      {
+        if (typeof value === 'string') {
+          setTextContent(domElement, value);
+        } else if (typeof value === 'number') {
+          setTextContent(domElement, '' + value);
+        }
+
+        break;
+      }
+
+    case 'onScroll':
+      {
+        if (value != null) {
+
+          listenToNonDelegatedEvent('scroll', domElement);
+        }
+
+        break;
+      }
+
+    case 'onScrollEnd':
+      {
+        if (value != null) {
+
+          listenToNonDelegatedEvent('scrollend', domElement);
+        }
+
+        break;
+      }
+
+    case 'onClick':
+      {
+        // TODO: This cast may not be sound for SVG, MathML or custom elements.
+        if (value != null) {
+
+          trapClickOnNonInteractiveElement(domElement);
+        }
+
+        break;
+      }
+
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'innerHTML':
+      {
+        // Noop
+        break;
+      }
+
+    case 'innerText': // Properties
+
+    case 'textContent':
+      {
+        break;
+      }
+
+    // Fall through
+
+    default:
+      {
+        if (registrationNameDependencies.hasOwnProperty(key)) ; else {
+          {
+            setValueForPropertyOnCustomComponent(domElement, key, value);
+          }
+        }
+      }
+  }
+}
+
+function setInitialProperties(domElement, tag, props) {
+
+
+  switch (tag) {
+    case 'div':
+    case 'span':
+    case 'svg':
+    case 'path':
+    case 'a':
+    case 'g':
+    case 'p':
+    case 'li':
+      {
+        // Fast track the most common tag types
+        break;
+      }
+
+    case 'input':
+      {
+        // listeners still fire for the invalid event.
+
+
+        listenToNonDelegatedEvent('invalid', domElement);
+        let name = null;
+        let type = null;
+        let value = null;
+        let defaultValue = null;
+        let checked = null;
+        let defaultChecked = null;
+
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'name':
+              {
+                name = propValue;
+                break;
+              }
+
+            case 'type':
+              {
+                type = propValue;
+                break;
+              }
+
+            case 'checked':
+              {
+                checked = propValue;
+                break;
+              }
+
+            case 'defaultChecked':
+              {
+                defaultChecked = propValue;
+                break;
+              }
+
+            case 'value':
+              {
+                value = propValue;
+                break;
+              }
+
+            case 'defaultValue':
+              {
+                defaultValue = propValue;
+                break;
+              }
+
+            case 'children':
+            case 'dangerouslySetInnerHTML':
+              {
+                if (propValue != null) {
+                  throw Error(formatProdErrorMessage(137, tag));
+                }
+
+                break;
+              }
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        } // TODO: Make sure we check if this is still unmounted or do any clean
+        initInput(domElement, value, defaultValue, checked, defaultChecked, type, name, false);
+        track(domElement);
+        return;
+      }
+
+    case 'select':
+      {
+        // listeners still fire for the invalid event.
+
+
+        listenToNonDelegatedEvent('invalid', domElement);
+        let value = null;
+        let defaultValue = null;
+        let multiple = null;
+
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'value':
+              {
+                value = propValue; // This is handled by initSelect below.
+
+                break;
+              }
+
+            case 'defaultValue':
+              {
+                defaultValue = propValue; // This is handled by initSelect below.
+
+                break;
+              }
+
+            case 'multiple':
+              {
+                multiple = propValue; // TODO: We don't actually have to fall through here because we set it
+                // in initSelect anyway. We can remove the special case in setProp.
+              }
+            // Fallthrough
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        }
+        initSelect(domElement, value, defaultValue, multiple);
+        return;
+      }
+
+    case 'textarea':
+      {
+        // listeners still fire for the invalid event.
+
+
+        listenToNonDelegatedEvent('invalid', domElement);
+        let value = null;
+        let defaultValue = null;
+        let children = null;
+
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'value':
+              {
+                value = propValue; // This is handled by initTextarea below.
+
+                break;
+              }
+
+            case 'defaultValue':
+              {
+                defaultValue = propValue;
+                break;
+              }
+
+            case 'children':
+              {
+                children = propValue; // Handled by initTextarea above.
+
+                break;
+              }
+
+            case 'dangerouslySetInnerHTML':
+              {
+                if (propValue != null) {
+                  // TODO: Do we really need a special error message for this. It's also pretty blunt.
+                  throw Error(formatProdErrorMessage(91));
+                }
+
+                break;
+              }
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        } // TODO: Make sure we check if this is still unmounted or do any clean
+        initTextarea(domElement, value, defaultValue, children);
+        track(domElement);
+        return;
+      }
+
+    case 'option':
+      {
+
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'selected':
+              {
+                // TODO: Remove support for selected on option.
+                domElement.selected = propValue && typeof propValue !== 'function' && typeof propValue !== 'symbol';
+                break;
+              }
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        }
+
+        return;
+      }
+
+    case 'dialog':
+      {
+        listenToNonDelegatedEvent('cancel', domElement);
+        listenToNonDelegatedEvent('close', domElement);
+        break;
+      }
+
+    case 'iframe':
+    case 'object':
+      {
+        // We listen to this event in case to ensure emulated bubble
+        // listeners still fire for the load event.
+        listenToNonDelegatedEvent('load', domElement);
+        break;
+      }
+
+    case 'video':
+    case 'audio':
+      {
+        // We listen to these events in case to ensure emulated bubble
+        // listeners still fire for all the media events.
+        for (let i = 0; i < mediaEventTypes.length; i++) {
+          listenToNonDelegatedEvent(mediaEventTypes[i], domElement);
+        }
+
+        break;
+      }
+
+    case 'image':
+      {
+        // We listen to these events in case to ensure emulated bubble
+        // listeners still fire for error and load events.
+        listenToNonDelegatedEvent('error', domElement);
+        listenToNonDelegatedEvent('load', domElement);
+        break;
+      }
+
+    case 'details':
+      {
+        // We listen to this event in case to ensure emulated bubble
+        // listeners still fire for the toggle event.
+        listenToNonDelegatedEvent('toggle', domElement);
+        break;
+      }
+
+    case 'embed':
+    case 'source':
+    case 'img':
+    case 'link':
+      {
+        // These are void elements that also need delegated events.
+        listenToNonDelegatedEvent('error', domElement);
+        listenToNonDelegatedEvent('load', domElement); // We fallthrough to the return of the void elements
+      }
+
+    case 'area':
+    case 'base':
+    case 'br':
+    case 'col':
+    case 'hr':
+    case 'keygen':
+    case 'meta':
+    case 'param':
+    case 'track':
+    case 'wbr':
+    case 'menuitem':
+      {
+        // Void elements
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'children':
+            case 'dangerouslySetInnerHTML':
+              {
+                // TODO: Can we make this a DEV warning to avoid this deny list?
+                throw Error(formatProdErrorMessage(137, tag));
+              }
+            // defaultChecked and defaultValue are ignored by setProp
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        }
+
+        return;
+      }
+
+    default:
+      {
+        if (isCustomElement(tag)) {
+          for (const propKey in props) {
+            if (!props.hasOwnProperty(propKey)) {
+              continue;
+            }
+
+            const propValue = props[propKey];
+
+            if (propValue == null) {
+              continue;
+            }
+
+            setPropOnCustomElement(domElement, tag, propKey, propValue, props, null);
+          }
+
+          return;
+        }
+      }
+  }
+
+  for (const propKey in props) {
+    if (!props.hasOwnProperty(propKey)) {
+      continue;
+    }
+
+    const propValue = props[propKey];
+
+    if (propValue == null) {
+      continue;
+    }
+
+    setProp(domElement, tag, propKey, propValue, props, null);
+  }
+}
+function updateProperties(domElement, tag, lastProps, nextProps) {
+
+  switch (tag) {
+    case 'div':
+    case 'span':
+    case 'svg':
+    case 'path':
+    case 'a':
+    case 'g':
+    case 'p':
+    case 'li':
+      {
+        // Fast track the most common tag types
+        break;
+      }
+
+    case 'input':
+      {
+        let name = null;
+        let type = null;
+        let value = null;
+        let defaultValue = null;
+        let lastDefaultValue = null;
+        let checked = null;
+        let defaultChecked = null;
+
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null) {
+            switch (propKey) {
+              case 'checked':
+                {
+                  break;
+                }
+
+              case 'value':
+                {
+                  // This is handled by updateWrapper below.
+                  break;
+                }
+
+              case 'defaultValue':
+                {
+                  lastDefaultValue = lastProp;
+                }
+              // defaultChecked and defaultValue are ignored by setProp
+              // Fallthrough
+
+              default:
+                {
+                  if (!nextProps.hasOwnProperty(propKey)) setProp(domElement, tag, propKey, null, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'type':
+                {
+                  type = nextProp;
+                  break;
+                }
+
+              case 'name':
+                {
+                  name = nextProp;
+                  break;
+                }
+
+              case 'checked':
+                {
+                  checked = nextProp;
+                  break;
+                }
+
+              case 'defaultChecked':
+                {
+                  defaultChecked = nextProp;
+                  break;
+                }
+
+              case 'value':
+                {
+                  value = nextProp;
+                  break;
+                }
+
+              case 'defaultValue':
+                {
+                  defaultValue = nextProp;
+                  break;
+                }
+
+              case 'children':
+              case 'dangerouslySetInnerHTML':
+                {
+                  if (nextProp != null) {
+                    throw Error(formatProdErrorMessage(137, tag));
+                  }
+
+                  break;
+                }
+
+              default:
+                {
+                  if (nextProp !== lastProp) setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        }
+        // happen after updating the rest of props. Otherwise HTML5 input validations
+        // raise warnings and prevent the new value from being assigned.
+
+
+        updateInput(domElement, value, defaultValue, lastDefaultValue, checked, defaultChecked, type, name);
+        return;
+      }
+
+    case 'select':
+      {
+        let value = null;
+        let defaultValue = null;
+        let multiple = null;
+        let wasMultiple = null;
+
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null) {
+            switch (propKey) {
+              case 'value':
+                {
+                  // This is handled by updateWrapper below.
+                  break;
+                }
+              // defaultValue are ignored by setProp
+
+              case 'multiple':
+                {
+                  wasMultiple = lastProp; // TODO: Move special case in here from setProp.
+                }
+              // Fallthrough
+
+              default:
+                {
+                  if (!nextProps.hasOwnProperty(propKey)) setProp(domElement, tag, propKey, null, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'value':
+                {
+                  value = nextProp; // This is handled by updateSelect below.
+
+                  break;
+                }
+
+              case 'defaultValue':
+                {
+                  defaultValue = nextProp;
+                  break;
+                }
+
+              case 'multiple':
+                {
+                  multiple = nextProp; // TODO: Just move the special case in here from setProp.
+                }
+              // Fallthrough
+
+              default:
+                {
+                  if (nextProp !== lastProp) setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        } // <select> value update needs to occur after <option> children
+        // reconciliation
+
+
+        updateSelect(domElement, value, defaultValue, multiple, wasMultiple);
+        return;
+      }
+
+    case 'textarea':
+      {
+        let value = null;
+        let defaultValue = null;
+
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+            switch (propKey) {
+              case 'value':
+                {
+                  // This is handled by updateTextarea below.
+                  break;
+                }
+
+              case 'children':
+                {
+                  // TODO: This doesn't actually do anything if it updates.
+                  break;
+                }
+              // defaultValue is ignored by setProp
+
+              default:
+                {
+                  setProp(domElement, tag, propKey, null, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'value':
+                {
+                  value = nextProp; // This is handled by updateTextarea below.
+
+                  break;
+                }
+
+              case 'defaultValue':
+                {
+                  defaultValue = nextProp;
+                  break;
+                }
+
+              case 'children':
+                {
+                  // TODO: This doesn't actually do anything if it updates.
+                  break;
+                }
+
+              case 'dangerouslySetInnerHTML':
+                {
+                  if (nextProp != null) {
+                    // TODO: Do we really need a special error message for this. It's also pretty blunt.
+                    throw Error(formatProdErrorMessage(91));
+                  }
+
+                  break;
+                }
+
+              default:
+                {
+                  if (nextProp !== lastProp) setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        updateTextarea(domElement, value, defaultValue);
+        return;
+      }
+
+    case 'option':
+      {
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+            switch (propKey) {
+              case 'selected':
+                {
+                  // TODO: Remove support for selected on option.
+                  domElement.selected = false;
+                  break;
+                }
+
+              default:
+                {
+                  setProp(domElement, tag, propKey, null, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && nextProp !== lastProp && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'selected':
+                {
+                  // TODO: Remove support for selected on option.
+                  domElement.selected = nextProp && typeof nextProp !== 'function' && typeof nextProp !== 'symbol';
+                  break;
+                }
+
+              default:
+                {
+                  setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        return;
+      }
+
+    case 'img':
+    case 'link':
+    case 'area':
+    case 'base':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'keygen':
+    case 'meta':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+    case 'menuitem':
+      {
+        // Void elements
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+            setProp(domElement, tag, propKey, null, nextProps, lastProp);
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && nextProp !== lastProp && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'children':
+              case 'dangerouslySetInnerHTML':
+                {
+                  if (nextProp != null) {
+                    // TODO: Can we make this a DEV warning to avoid this deny list?
+                    throw Error(formatProdErrorMessage(137, tag));
+                  }
+
+                  break;
+                }
+              // defaultChecked and defaultValue are ignored by setProp
+
+              default:
+                {
+                  setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        return;
+      }
+
+    default:
+      {
+        if (isCustomElement(tag)) {
+          for (const propKey in lastProps) {
+            const lastProp = lastProps[propKey];
+
+            if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+              setPropOnCustomElement(domElement, tag, propKey, null, nextProps, lastProp);
+            }
+          }
+
+          for (const propKey in nextProps) {
+            const nextProp = nextProps[propKey];
+            const lastProp = lastProps[propKey];
+
+            if (nextProps.hasOwnProperty(propKey) && nextProp !== lastProp && (nextProp != null || lastProp != null)) {
+              setPropOnCustomElement(domElement, tag, propKey, nextProp, nextProps, lastProp);
+            }
+          }
+
+          return;
+        }
+      }
+  }
+
+  for (const propKey in lastProps) {
+    const lastProp = lastProps[propKey];
+
+    if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+      setProp(domElement, tag, propKey, null, nextProps, lastProp);
+    }
+  }
+
+  for (const propKey in nextProps) {
+    const nextProp = nextProps[propKey];
+    const lastProp = lastProps[propKey];
+
+    if (nextProps.hasOwnProperty(propKey) && nextProp !== lastProp && (nextProp != null || lastProp != null)) {
+      setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+    }
+  }
+}
+
+function diffHydratedProperties(domElement, tag, props, isConcurrentMode, shouldWarnDev, hostContext) {
+
+
+  switch (tag) {
+    case 'dialog':
+      listenToNonDelegatedEvent('cancel', domElement);
+      listenToNonDelegatedEvent('close', domElement);
+      break;
+
+    case 'iframe':
+    case 'object':
+    case 'embed':
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the load event.
+      listenToNonDelegatedEvent('load', domElement);
+      break;
+
+    case 'video':
+    case 'audio':
+      // We listen to these events in case to ensure emulated bubble
+      // listeners still fire for all the media events.
+      for (let i = 0; i < mediaEventTypes.length; i++) {
+        listenToNonDelegatedEvent(mediaEventTypes[i], domElement);
+      }
+
+      break;
+
+    case 'source':
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the error event.
+      listenToNonDelegatedEvent('error', domElement);
+      break;
+
+    case 'img':
+    case 'image':
+    case 'link':
+      // We listen to these events in case to ensure emulated bubble
+      // listeners still fire for error and load events.
+      listenToNonDelegatedEvent('error', domElement);
+      listenToNonDelegatedEvent('load', domElement);
+      break;
+
+    case 'details':
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the toggle event.
+      listenToNonDelegatedEvent('toggle', domElement);
+      break;
+
+    case 'input':
+      // listeners still fire for the invalid event.
+
+
+      listenToNonDelegatedEvent('invalid', domElement); // TODO: Make sure we check if this is still unmounted or do any clean
+      // post mount to force it to diverge from attributes. However, for
+      // option and select we don't quite do the same thing and select
+      // is not resilient to the DOM state changing so we don't do that here.
+      // TODO: Consider not doing this for input and textarea.
+
+      initInput(domElement, props.value, props.defaultValue, props.checked, props.defaultChecked, props.type, props.name, true);
+      track(domElement);
+      break;
+
+    case 'option':
+      break;
+
+    case 'select':
+      // listeners still fire for the invalid event.
+
+
+      listenToNonDelegatedEvent('invalid', domElement);
+      break;
+
+    case 'textarea':
+      // listeners still fire for the invalid event.
+
+
+      listenToNonDelegatedEvent('invalid', domElement); // TODO: Make sure we check if this is still unmounted or do any clean
+      initTextarea(domElement, props.value, props.defaultValue, props.children);
+      track(domElement);
+      break;
+  }
+
+  const children = props.children; // For text content children we compare against textContent. This
+  // might match additional HTML that is hidden when we read it using
+  // textContent. E.g. "foo" will match "f<span>oo</span>" but that still
+  // satisfies our requirement. Our requirement is not to produce perfect
+  // HTML and attributes. Ideally we should preserve structure but it's
+  // ok not to if the visible content is still enough to indicate what
+  // even listeners these nodes might be wired up to.
+  // TODO: Warn if there is more than a single textNode as a child.
+  // TODO: Should we use domElement.firstChild.nodeValue to compare?
+
+  if (typeof children === 'string' || typeof children === 'number') {
+    if (domElement.textContent !== '' + children) {
+      if (props.suppressHydrationWarning !== true) {
+        checkForUnmatchedText(domElement.textContent, children, isConcurrentMode);
+      }
+
+      if (!isConcurrentMode || !enableClientRenderFallbackOnTextMismatch) {
+        // We really should be patching this in the commit phase but since
+        // this only affects legacy mode hydration which is deprecated anyway
+        // we can get away with it.
+        // Host singletons get their children appended and don't use the text
+        // content mechanism.
+        if (tag !== 'body') {
+          domElement.textContent = children;
+        }
+      }
+    }
+  }
+
+  if (props.onScroll != null) {
+    listenToNonDelegatedEvent('scroll', domElement);
+  }
+
+  if (props.onScrollEnd != null) {
+    listenToNonDelegatedEvent('scrollend', domElement);
+  }
+
+  if (props.onClick != null) {
+    // TODO: This cast may not be sound for SVG, MathML or custom elements.
+    trapClickOnNonInteractiveElement(domElement);
+  }
+}
+function diffHydratedText(textNode, text, isConcurrentMode) {
+  const isDifferent = textNode.nodeValue !== text;
+  return isDifferent;
+}
+function restoreControlledState(domElement, tag, props) {
+  switch (tag) {
+    case 'input':
+      restoreControlledInputState(domElement, props);
+      return;
+
+    case 'textarea':
+      restoreControlledTextareaState(domElement, props);
+      return;
+
+    case 'select':
+      restoreControlledSelectState(domElement, props);
+      return;
+  }
+}
+
+const SUPPRESS_HYDRATION_WARNING = 'suppressHydrationWarning';
+const SUSPENSE_START_DATA = '$';
+const SUSPENSE_END_DATA = '/$';
+const SUSPENSE_PENDING_START_DATA = '$?';
+const SUSPENSE_FALLBACK_START_DATA = '$!';
+const FORM_STATE_IS_MATCHING = 'F!';
+const FORM_STATE_IS_NOT_MATCHING = 'F';
+const STYLE = 'style';
+const HostContextNamespaceNone = 0;
+const HostContextNamespaceSvg = 1;
+const HostContextNamespaceMath = 2;
+let eventsEnabled = null;
+let selectionInformation = null;
+
+function getOwnerDocumentFromRootContainer(rootContainerElement) {
+  return rootContainerElement.nodeType === DOCUMENT_NODE ? rootContainerElement : rootContainerElement.ownerDocument;
+}
+
+function getRootHostContext(rootContainerInstance) {
+  let type;
+  let context;
+  const nodeType = rootContainerInstance.nodeType;
+
+  switch (nodeType) {
+    case DOCUMENT_NODE:
+    case DOCUMENT_FRAGMENT_NODE:
+      {
+        type = nodeType === DOCUMENT_NODE ? '#document' : '#fragment';
+        const root = rootContainerInstance.documentElement;
+
+        if (root) {
+          const namespaceURI = root.namespaceURI;
+          context = namespaceURI ? getOwnHostContext(namespaceURI) : HostContextNamespaceNone;
+        } else {
+          context = HostContextNamespaceNone;
+        }
+
+        break;
+      }
+
+    default:
+      {
+        const container = nodeType === COMMENT_NODE ? rootContainerInstance.parentNode : rootContainerInstance;
+        type = container.tagName;
+        const namespaceURI = container.namespaceURI;
+
+        if (!namespaceURI) {
+          switch (type) {
+            case 'svg':
+              context = HostContextNamespaceSvg;
+              break;
+
+            case 'math':
+              context = HostContextNamespaceMath;
+              break;
+
+            default:
+              context = HostContextNamespaceNone;
+              break;
+          }
+        } else {
+          const ownContext = getOwnHostContext(namespaceURI);
+          context = getChildHostContextProd(ownContext, type);
+        }
+
+        break;
+      }
+  }
+
+  return context;
+}
+
+function getOwnHostContext(namespaceURI) {
+  switch (namespaceURI) {
+    case SVG_NAMESPACE:
+      return HostContextNamespaceSvg;
+
+    case MATH_NAMESPACE:
+      return HostContextNamespaceMath;
+
+    default:
+      return HostContextNamespaceNone;
+  }
+}
+
+function getChildHostContextProd(parentNamespace, type) {
+  if (parentNamespace === HostContextNamespaceNone) {
+    // No (or default) parent namespace: potential entry point.
+    switch (type) {
+      case 'svg':
+        return HostContextNamespaceSvg;
+
+      case 'math':
+        return HostContextNamespaceMath;
+
+      default:
+        return HostContextNamespaceNone;
+    }
+  }
+
+  if (parentNamespace === HostContextNamespaceSvg && type === 'foreignObject') {
+    // We're leaving SVG.
+    return HostContextNamespaceNone;
+  } // By default, pass namespace below.
+
+
+  return parentNamespace;
+}
+
+function getChildHostContext(parentHostContext, type) {
+
+  const parentNamespace = parentHostContext;
+  return getChildHostContextProd(parentNamespace, type);
+}
+function getPublicInstance(instance) {
+  return instance;
+}
+function prepareForCommit(containerInfo) {
+  eventsEnabled = isEnabled();
+  selectionInformation = getSelectionInformation();
+  let activeInstance = null;
+
+  setEnabled(false);
+  return activeInstance;
+}
+function resetAfterCommit(containerInfo) {
+  restoreSelection(selectionInformation);
+  setEnabled(eventsEnabled);
+  eventsEnabled = null;
+  selectionInformation = null;
+}
+function createHoistableInstance(type, props, rootContainerInstance, internalInstanceHandle) {
+  const ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
+  const domElement = ownerDocument.createElement(type);
+  precacheFiberNode(internalInstanceHandle, domElement);
+  updateFiberProps(domElement, props);
+  setInitialProperties(domElement, type, props);
+  markNodeAsHoistable(domElement);
+  return domElement;
+}
+function createInstance(type, props, rootContainerInstance, hostContext, internalInstanceHandle) {
+  let hostContextProd;
+
+  {
+    hostContextProd = hostContext;
+  }
+
+  const ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
+  let domElement;
+
+  switch (hostContextProd) {
+    case HostContextNamespaceSvg:
+      domElement = ownerDocument.createElementNS(SVG_NAMESPACE, type);
+      break;
+
+    case HostContextNamespaceMath:
+      domElement = ownerDocument.createElementNS(MATH_NAMESPACE, type);
+      break;
+
+    default:
+      switch (type) {
+        case 'svg':
+          {
+            domElement = ownerDocument.createElementNS(SVG_NAMESPACE, type);
+            break;
+          }
+
+        case 'math':
+          {
+            domElement = ownerDocument.createElementNS(MATH_NAMESPACE, type);
+            break;
+          }
+
+        case 'script':
+          {
+            // Create the script via .innerHTML so its "parser-inserted" flag is
+            // set to true and it does not execute
+            const div = ownerDocument.createElement('div');
+
+            div.innerHTML = '<script><' + '/script>'; // eslint-disable-line
+            // This is guaranteed to yield a script element.
+
+            const firstChild = div.firstChild;
+            domElement = div.removeChild(firstChild);
+            break;
+          }
+
+        case 'select':
+          {
+            if (typeof props.is === 'string') {
+              domElement = ownerDocument.createElement('select', {
+                is: props.is
+              });
+            } else {
+              // Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.
+              // See discussion in https://github.com/facebook/react/pull/6896
+              // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
+              domElement = ownerDocument.createElement('select');
+            }
+
+            if (props.multiple) {
+              domElement.multiple = true;
+            } else if (props.size) {
+              // Setting a size greater than 1 causes a select to behave like `multiple=true`, where
+              // it is possible that no option is selected.
+              //
+              // This is only necessary when a select in "single selection mode".
+              domElement.size = props.size;
+            }
+
+            break;
+          }
+
+        default:
+          {
+            if (typeof props.is === 'string') {
+              domElement = ownerDocument.createElement(type, {
+                is: props.is
+              });
+            } else {
+              // Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.
+              // See discussion in https://github.com/facebook/react/pull/6896
+              // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
+              domElement = ownerDocument.createElement(type);
+            }
+          }
+      }
+
+  }
+
+  precacheFiberNode(internalInstanceHandle, domElement);
+  updateFiberProps(domElement, props);
+  return domElement;
+}
+function appendInitialChild(parentInstance, child) {
+  parentInstance.appendChild(child);
+}
+function finalizeInitialChildren(domElement, type, props, hostContext) {
+  setInitialProperties(domElement, type, props);
+
+  switch (type) {
+    case 'button':
+    case 'input':
+    case 'select':
+    case 'textarea':
+      return !!props.autoFocus;
+
+    case 'img':
+      return true;
+
+    default:
+      return false;
+  }
+}
+function shouldSetTextContent(type, props) {
+  return type === 'textarea' || type === 'noscript' || typeof props.children === 'string' || typeof props.children === 'number' || typeof props.dangerouslySetInnerHTML === 'object' && props.dangerouslySetInnerHTML !== null && props.dangerouslySetInnerHTML.__html != null;
+}
+function createTextInstance(text, rootContainerInstance, hostContext, internalInstanceHandle) {
+
+  const textNode = getOwnerDocumentFromRootContainer(rootContainerInstance).createTextNode(text);
+  precacheFiberNode(internalInstanceHandle, textNode);
+  return textNode;
+}
+function getCurrentEventPriority() {
+  const currentEvent = window.event;
+
+  if (currentEvent === undefined) {
+    return DefaultEventPriority;
+  }
+
+  return getEventPriority(currentEvent.type);
+}
+let currentPopstateTransitionEvent = null;
+function shouldAttemptEagerTransition() {
+  const event = window.event;
+
+  if (event && event.type === 'popstate') {
+    // This is a popstate event. Attempt to render any transition during this
+    // event synchronously. Unless we already attempted during this event.
+    if (event === currentPopstateTransitionEvent) {
+      // We already attempted to render this popstate transition synchronously.
+      // Any subsequent attempts must have happened as the result of a derived
+      // update, like startTransition inside useEffect, or useDV. Switch back to
+      // the default behavior for all remaining transitions during the current
+      // popstate event.
+      return false;
+    } else {
+      // Cache the current event in case a derived transition is scheduled.
+      // (Refer to previous branch.)
+      currentPopstateTransitionEvent = event;
+      return true;
+    }
+  } // We're not inside a popstate event.
+
+
+  currentPopstateTransitionEvent = null;
+  return false;
+}
+// if a component just imports ReactDOM (e.g. for findDOMNode).
+// Some environments might not have setTimeout or clearTimeout.
+
+const scheduleTimeout = typeof setTimeout === 'function' ? setTimeout : undefined;
+const cancelTimeout = typeof clearTimeout === 'function' ? clearTimeout : undefined;
+const noTimeout = -1;
+const localPromise = typeof Promise === 'function' ? Promise : undefined;
+function preparePortalMount(portalInstance) {
+  listenToAllSupportedEvents(portalInstance);
+}
+const scheduleMicrotask = typeof queueMicrotask === 'function' ? queueMicrotask : typeof localPromise !== 'undefined' ? callback => localPromise.resolve(null).then(callback).catch(handleErrorInNextTick) : scheduleTimeout; // TODO: Determine the best fallback here.
+
+function handleErrorInNextTick(error) {
+  setTimeout(() => {
+    throw error;
+  });
+} // -------------------
+function commitMount(domElement, type, newProps, internalInstanceHandle) {
+  // Despite the naming that might imply otherwise, this method only
+  // fires if there is an `Update` effect scheduled during mounting.
+  // This happens if `finalizeInitialChildren` returns `true` (which it
+  // does to implement the `autoFocus` attribute on the client). But
+  // there are also other cases when this might happen (such as patching
+  // up text content during hydration mismatch). So we'll check this again.
+  switch (type) {
+    case 'button':
+    case 'input':
+    case 'select':
+    case 'textarea':
+      if (newProps.autoFocus) {
+        domElement.focus();
+      }
+
+      return;
+
+    case 'img':
+      {
+        if (newProps.src) {
+          domElement.src = newProps.src;
+        }
+
+        return;
+      }
+  }
+}
+function commitUpdate(domElement, updatePayload, type, oldProps, newProps, internalInstanceHandle) {
+  // Diff and update the properties.
+  updateProperties(domElement, type, oldProps, newProps); // Update the props handle so that we know which props are the ones with
+  // with current event handlers.
+
+  updateFiberProps(domElement, newProps);
+}
+function resetTextContent(domElement) {
+  setTextContent(domElement, '');
+}
+function commitTextUpdate(textInstance, oldText, newText) {
+  textInstance.nodeValue = newText;
+}
+function appendChild(parentInstance, child) {
+  parentInstance.appendChild(child);
+}
+function appendChildToContainer(container, child) {
+  let parentNode;
+
+  if (container.nodeType === COMMENT_NODE) {
+    parentNode = container.parentNode;
+    parentNode.insertBefore(child, container);
+  } else {
+    parentNode = container;
+    parentNode.appendChild(child);
+  } // This container might be used for a portal.
+  // If something inside a portal is clicked, that click should bubble
+  // through the React tree. However, on Mobile Safari the click would
+  // never bubble through the *DOM* tree unless an ancestor with onclick
+  // event exists. So we wouldn't see it and dispatch it.
+  // This is why we ensure that non React root containers have inline onclick
+  // defined.
+  // https://github.com/facebook/react/issues/11918
+
+
+  const reactRootContainer = container._reactRootContainer;
+
+  if ((reactRootContainer === null || reactRootContainer === undefined) && parentNode.onclick === null) {
+    // TODO: This cast may not be sound for SVG, MathML or custom elements.
+    trapClickOnNonInteractiveElement(parentNode);
+  }
+}
+function insertBefore(parentInstance, child, beforeChild) {
+  parentInstance.insertBefore(child, beforeChild);
+}
+function insertInContainerBefore(container, child, beforeChild) {
+  if (container.nodeType === COMMENT_NODE) {
+    container.parentNode.insertBefore(child, beforeChild);
+  } else {
+    container.insertBefore(child, beforeChild);
+  }
+}
+
+function removeChild(parentInstance, child) {
+  parentInstance.removeChild(child);
+}
+function removeChildFromContainer(container, child) {
+  if (container.nodeType === COMMENT_NODE) {
+    container.parentNode.removeChild(child);
+  } else {
+    container.removeChild(child);
+  }
+}
+function clearSuspenseBoundary(parentInstance, suspenseInstance) {
+  let node = suspenseInstance; // Delete all nodes within this suspense boundary.
+  // There might be nested nodes so we need to keep track of how
+  // deep we are and only break out when we're back on top.
+
+  let depth = 0;
+
+  do {
+    const nextNode = node.nextSibling;
+    parentInstance.removeChild(node);
+
+    if (nextNode && nextNode.nodeType === COMMENT_NODE) {
+      const data = nextNode.data;
+
+      if (data === SUSPENSE_END_DATA) {
+        if (depth === 0) {
+          parentInstance.removeChild(nextNode); // Retry if any event replaying was blocked on this.
+
+          retryIfBlockedOn(suspenseInstance);
+          return;
+        } else {
+          depth--;
+        }
+      } else if (data === SUSPENSE_START_DATA || data === SUSPENSE_PENDING_START_DATA || data === SUSPENSE_FALLBACK_START_DATA) {
+        depth++;
+      }
+    } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+    node = nextNode;
+  } while (node); // TODO: Warn, we didn't find the end comment boundary.
+  // Retry if any event replaying was blocked on this.
+
+
+  retryIfBlockedOn(suspenseInstance);
+}
+function clearSuspenseBoundaryFromContainer(container, suspenseInstance) {
+  if (container.nodeType === COMMENT_NODE) {
+    clearSuspenseBoundary(container.parentNode, suspenseInstance);
+  } else if (container.nodeType === ELEMENT_NODE) {
+    clearSuspenseBoundary(container, suspenseInstance);
+  } else ; // Retry if any event replaying was blocked on this.
+
+
+  retryIfBlockedOn(container);
+}
+function hideInstance(instance) {
+  // TODO: Does this work for all element types? What about MathML? Should we
+  // pass host context to this method?
+  instance = instance;
+  const style = instance.style; // $FlowFixMe[method-unbinding]
+
+  if (typeof style.setProperty === 'function') {
+    style.setProperty('display', 'none', 'important');
+  } else {
+    style.display = 'none';
+  }
+}
+function hideTextInstance(textInstance) {
+  textInstance.nodeValue = '';
+}
+function unhideInstance(instance, props) {
+  instance = instance;
+  const styleProp = props[STYLE];
+  const display = styleProp !== undefined && styleProp !== null && styleProp.hasOwnProperty('display') ? styleProp.display : null;
+  instance.style.display = display == null || typeof display === 'boolean' ? '' : // The value would've errored already if it wasn't safe.
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  ('' + display).trim();
+}
+function unhideTextInstance(textInstance, text) {
+  textInstance.nodeValue = text;
+}
+function clearContainer(container) {
+  {
+    const nodeType = container.nodeType;
+
+    if (nodeType === DOCUMENT_NODE) {
+      clearContainerSparingly(container);
+    } else if (nodeType === ELEMENT_NODE) {
+      switch (container.nodeName) {
+        case 'HEAD':
+        case 'HTML':
+        case 'BODY':
+          clearContainerSparingly(container);
+          return;
+
+        default:
+          {
+            container.textContent = '';
+          }
+      }
+    }
+  }
+}
+
+function clearContainerSparingly(container) {
+  let node;
+  let nextNode = container.firstChild;
+
+  if (nextNode && nextNode.nodeType === DOCUMENT_TYPE_NODE) {
+    nextNode = nextNode.nextSibling;
+  }
+
+  while (nextNode) {
+    node = nextNode;
+    nextNode = nextNode.nextSibling;
+
+    switch (node.nodeName) {
+      case 'HTML':
+      case 'HEAD':
+      case 'BODY':
+        {
+          const element = node;
+          clearContainerSparingly(element); // If these singleton instances had previously been rendered with React they
+          // may still hold on to references to the previous fiber tree. We detatch them
+          // prospectively to reset them to a baseline starting state since we cannot create
+          // new instances.
+
+          detachDeletedInstance(element);
+          continue;
+        }
+      // Script tags are retained to avoid an edge case bug. Normally scripts will execute if they
+      // are ever inserted into the DOM. However when streaming if a script tag is opened but not
+      // yet closed some browsers create and insert the script DOM Node but the script cannot execute
+      // yet until the closing tag is parsed. If something causes React to call clearContainer while
+      // this DOM node is in the document but not yet executable the DOM node will be removed from the
+      // document and when the script closing tag comes in the script will not end up running. This seems
+      // to happen in Chrome/Firefox but not Safari at the moment though this is not necessarily specified
+      // behavior so it could change in future versions of browsers. While leaving all scripts is broader
+      // than strictly necessary this is the least amount of additional code to avoid this breaking
+      // edge case.
+      //
+      // Style tags are retained because they may likely come from 3rd party scripts and extensions
+
+      case 'SCRIPT':
+      case 'STYLE':
+        {
+          continue;
+        }
+      // Stylesheet tags are retained because tehy may likely come from 3rd party scripts and extensions
+
+      case 'LINK':
+        {
+          if (node.rel.toLowerCase() === 'stylesheet') {
+            continue;
+          }
+        }
+    }
+
+    container.removeChild(node);
+  }
+
+  return;
+} // Making this so we can eventually move all of the instance caching to the commit phase.
+function isHydratableText(text) {
+  return text !== '';
+}
+function canHydrateInstance(instance, type, props, inRootOrSingleton) {
+  while (instance.nodeType === ELEMENT_NODE) {
+    const element = instance;
+    const anyProps = props;
+
+    if (element.nodeName.toLowerCase() !== type.toLowerCase()) {
+      if (!inRootOrSingleton || !enableHostSingletons) {
+        // Usually we error for mismatched tags.
+        if (element.nodeName === 'INPUT' && element.type === 'hidden') ; else {
+          return null;
+        }
+      } // In root or singleton parents we skip past mismatched instances.
+
+    } else if (!inRootOrSingleton || !enableHostSingletons) {
+      // Match
+      if (type === 'input' && element.type === 'hidden') {
+
+        const name = anyProps.name == null ? null : '' + anyProps.name;
+
+        if (anyProps.type !== 'hidden' || element.getAttribute('name') !== name) ; else {
+          return element;
+        }
+      } else {
+        return element;
+      }
+    } else if (isMarkedHoistable(element)) ; else {
+      // We have an Element with the right type.
+      // We are going to try to exclude it if we can definitely identify it as a hoisted Node or if
+      // we can guess that the node is likely hoisted or was inserted by a 3rd party script or browser extension
+      // using high entropy attributes for certain types. This technique will fail for strange insertions like
+      // extension prepending <div> in the <body> but that already breaks before and that is an edge case.
+      switch (type) {
+        // case 'title':
+        //We assume all titles are matchable. You should only have one in the Document, at least in a hoistable scope
+        // and if you are a HostComponent with type title we must either be in an <svg> context or this title must have an `itemProp` prop.
+        case 'meta':
+          {
+            // The only way to opt out of hoisting meta tags is to give it an itemprop attribute. We assume there will be
+            // not 3rd party meta tags that are prepended, accepting the cases where this isn't true because meta tags
+            // are usually only functional for SSR so even in a rare case where we did bind to an injected tag the runtime
+            // implications are minimal
+            if (!element.hasAttribute('itemprop')) {
+              // This is a Hoistable
+              break;
+            }
+
+            return element;
+          }
+
+        case 'link':
+          {
+            // Links come in many forms and we do expect 3rd parties to inject them into <head> / <body>. We exclude known resources
+            // and then use high-entroy attributes like href which are almost always used and almost always unique to filter out unlikely
+            // matches.
+            const rel = element.getAttribute('rel');
+
+            if (rel === 'stylesheet' && element.hasAttribute('data-precedence')) {
+              // This is a stylesheet resource
+              break;
+            } else if (rel !== anyProps.rel || element.getAttribute('href') !== (anyProps.href == null ? null : anyProps.href) || element.getAttribute('crossorigin') !== (anyProps.crossOrigin == null ? null : anyProps.crossOrigin) || element.getAttribute('title') !== (anyProps.title == null ? null : anyProps.title)) {
+              // rel + href should usually be enough to uniquely identify a link however crossOrigin can vary for rel preconnect
+              // and title could vary for rel alternate
+              break;
+            }
+
+            return element;
+          }
+
+        case 'style':
+          {
+            // Styles are hard to match correctly. We can exclude known resources but otherwise we accept the fact that a non-hoisted style tags
+            // in <head> or <body> are likely never going to be unmounted given their position in the document and the fact they likely hold global styles
+            if (element.hasAttribute('data-precedence')) {
+              // This is a style resource
+              break;
+            }
+
+            return element;
+          }
+
+        case 'script':
+          {
+            // Scripts are a little tricky, we exclude known resources and then similar to links try to use high-entropy attributes
+            // to reject poor matches. One challenge with scripts are inline scripts. We don't attempt to check text content which could
+            // in theory lead to a hydration error later if a 3rd party injected an inline script before the React rendered nodes.
+            // Falling back to client rendering if this happens should be seemless though so we will try this hueristic and revisit later
+            // if we learn it is problematic
+            const srcAttr = element.getAttribute('src');
+
+            if (srcAttr !== (anyProps.src == null ? null : anyProps.src) || element.getAttribute('type') !== (anyProps.type == null ? null : anyProps.type) || element.getAttribute('crossorigin') !== (anyProps.crossOrigin == null ? null : anyProps.crossOrigin)) {
+              // This script is for a different src/type/crossOrigin. It may be a script resource
+              // or it may just be a mistmatch
+              if (srcAttr && element.hasAttribute('async') && !element.hasAttribute('itemprop')) {
+                // This is an async script resource
+                break;
+              }
+            }
+
+            return element;
+          }
+
+        default:
+          {
+            // We have excluded the most likely cases of mismatch between hoistable tags, 3rd party script inserted tags,
+            // and browser extension inserted tags. While it is possible this is not the right match it is a decent hueristic
+            // that should work in the vast majority of cases.
+            return element;
+          }
+      }
+    }
+
+    const nextInstance = getNextHydratableSibling(element);
+
+    if (nextInstance === null) {
+      break;
+    }
+
+    instance = nextInstance;
+  } // This is a suspense boundary or Text node or we got the end.
+  // Suspense Boundaries are never expected to be injected by 3rd parties. If we see one it should be matched
+  // and this is a hydration error.
+  // Text Nodes are also not expected to be injected by 3rd parties. This is less of a guarantee for <body>
+  // but it seems reasonable and conservative to reject this as a hydration error as well
+
+
+  return null;
+}
+function canHydrateTextInstance(instance, text, inRootOrSingleton) {
+  // Empty strings are not parsed by HTML so there won't be a correct match here.
+  if (text === '') return null;
+
+  while (instance.nodeType !== TEXT_NODE) {
+    if (instance.nodeType === ELEMENT_NODE && instance.nodeName === 'INPUT' && instance.type === 'hidden') ; else if (!inRootOrSingleton || !enableHostSingletons) {
+      return null;
+    }
+
+    const nextInstance = getNextHydratableSibling(instance);
+
+    if (nextInstance === null) {
+      return null;
+    }
+
+    instance = nextInstance;
+  } // This has now been refined to a text node.
+
+
+  return instance;
+}
+function canHydrateSuspenseInstance(instance, inRootOrSingleton) {
+  while (instance.nodeType !== COMMENT_NODE) {
+    if (!inRootOrSingleton || !enableHostSingletons) {
+      return null;
+    }
+
+    const nextInstance = getNextHydratableSibling(instance);
+
+    if (nextInstance === null) {
+      return null;
+    }
+
+    instance = nextInstance;
+  } // This has now been refined to a suspense node.
+
+
+  return instance;
+}
+function isSuspenseInstancePending(instance) {
+  return instance.data === SUSPENSE_PENDING_START_DATA;
+}
+function isSuspenseInstanceFallback(instance) {
+  return instance.data === SUSPENSE_FALLBACK_START_DATA;
+}
+function getSuspenseInstanceFallbackErrorDetails(instance) {
+  const dataset = instance.nextSibling && instance.nextSibling.dataset;
+  let digest;
+
+  if (dataset) {
+    digest = dataset.dgst;
+  }
+
+  {
+    // Object gets DCE'd if constructed in tail position and matches callsite destructuring
+    return {
+      digest
+    };
+  }
+}
+function registerSuspenseInstanceRetry(instance, callback) {
+  instance._reactRetry = callback;
+}
+function canHydrateFormStateMarker(instance, inRootOrSingleton) {
+  while (instance.nodeType !== COMMENT_NODE) {
+    if (!inRootOrSingleton || !enableHostSingletons) {
+      return null;
+    }
+
+    const nextInstance = getNextHydratableSibling(instance);
+
+    if (nextInstance === null) {
+      return null;
+    }
+
+    instance = nextInstance;
+  }
+
+  const nodeData = instance.data;
+
+  if (nodeData === FORM_STATE_IS_MATCHING || nodeData === FORM_STATE_IS_NOT_MATCHING) {
+    const markerInstance = instance;
+    return markerInstance;
+  }
+
+  return null;
+}
+function isFormStateMarkerMatching(markerInstance) {
+  return markerInstance.data === FORM_STATE_IS_MATCHING;
+}
+
+function getNextHydratable(node) {
+  // Skip non-hydratable nodes.
+  for (; node != null; node = node.nextSibling) {
+    const nodeType = node.nodeType;
+
+    if (nodeType === ELEMENT_NODE || nodeType === TEXT_NODE) {
+      break;
+    }
+
+    if (nodeType === COMMENT_NODE) {
+      const nodeData = node.data;
+
+      if (nodeData === SUSPENSE_START_DATA || nodeData === SUSPENSE_FALLBACK_START_DATA || nodeData === SUSPENSE_PENDING_START_DATA || (nodeData === FORM_STATE_IS_MATCHING || nodeData === FORM_STATE_IS_NOT_MATCHING)) {
+        break;
+      }
+
+      if (nodeData === SUSPENSE_END_DATA) {
+        return null;
+      }
+    }
+  }
+
+  return node;
+}
+
+function getNextHydratableSibling(instance) {
+  return getNextHydratable(instance.nextSibling);
+}
+function getFirstHydratableChild(parentInstance) {
+  return getNextHydratable(parentInstance.firstChild);
+}
+function getFirstHydratableChildWithinContainer(parentContainer) {
+  return getNextHydratable(parentContainer.firstChild);
+}
+function getFirstHydratableChildWithinSuspenseInstance(parentInstance) {
+  return getNextHydratable(parentInstance.nextSibling);
+}
+function hydrateInstance(instance, type, props, hostContext, internalInstanceHandle, shouldWarnDev) {
+  precacheFiberNode(internalInstanceHandle, instance); // TODO: Possibly defer this until the commit phase where all the events
+  // get attached.
+
+  updateFiberProps(instance, props); // TODO: Temporary hack to check if we're in a concurrent root. We can delete
+  // when the legacy root API is removed.
+
+  const isConcurrentMode = (internalInstanceHandle.mode & ConcurrentMode) !== NoMode;
+  diffHydratedProperties(instance, type, props, isConcurrentMode);
+}
+function hydrateTextInstance(textInstance, text, internalInstanceHandle, shouldWarnDev) {
+  precacheFiberNode(internalInstanceHandle, textInstance); // TODO: Temporary hack to check if we're in a concurrent root. We can delete
+  return diffHydratedText(textInstance, text);
+}
+function hydrateSuspenseInstance(suspenseInstance, internalInstanceHandle) {
+  precacheFiberNode(internalInstanceHandle, suspenseInstance);
+}
+function getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance) {
+  let node = suspenseInstance.nextSibling; // Skip past all nodes within this suspense boundary.
+  // There might be nested nodes so we need to keep track of how
+  // deep we are and only break out when we're back on top.
+
+  let depth = 0;
+
+  while (node) {
+    if (node.nodeType === COMMENT_NODE) {
+      const data = node.data;
+
+      if (data === SUSPENSE_END_DATA) {
+        if (depth === 0) {
+          return getNextHydratableSibling(node);
+        } else {
+          depth--;
+        }
+      } else if (data === SUSPENSE_START_DATA || data === SUSPENSE_FALLBACK_START_DATA || data === SUSPENSE_PENDING_START_DATA) {
+        depth++;
+      }
+    }
+
+    node = node.nextSibling;
+  } // TODO: Warn, we didn't find the end comment boundary.
+
+
+  return null;
+} // Returns the SuspenseInstance if this node is a direct child of a
+// SuspenseInstance. I.e. if its previous sibling is a Comment with
+// SUSPENSE_x_START_DATA. Otherwise, null.
+
+function getParentSuspenseInstance(targetInstance) {
+  let node = targetInstance.previousSibling; // Skip past all nodes within this suspense boundary.
+  // There might be nested nodes so we need to keep track of how
+  // deep we are and only break out when we're back on top.
+
+  let depth = 0;
+
+  while (node) {
+    if (node.nodeType === COMMENT_NODE) {
+      const data = node.data;
+
+      if (data === SUSPENSE_START_DATA || data === SUSPENSE_FALLBACK_START_DATA || data === SUSPENSE_PENDING_START_DATA) {
+        if (depth === 0) {
+          return node;
+        } else {
+          depth--;
+        }
+      } else if (data === SUSPENSE_END_DATA) {
+        depth++;
+      }
+    }
+
+    node = node.previousSibling;
+  }
+
+  return null;
+}
+function commitHydratedContainer(container) {
+  // Retry if any event replaying was blocked on this.
+  retryIfBlockedOn(container);
+}
+function commitHydratedSuspenseInstance(suspenseInstance) {
+  // Retry if any event replaying was blocked on this.
+  retryIfBlockedOn(suspenseInstance);
+}
+function shouldDeleteUnhydratedTailInstances(parentType) {
+  return (parentType !== 'form' && parentType !== 'button');
+}
+function didNotMatchHydratedContainerTextInstance(parentContainer, textInstance, text, isConcurrentMode, shouldWarnDev) {
+  checkForUnmatchedText(textInstance.nodeValue, text, isConcurrentMode);
+}
+function didNotMatchHydratedTextInstance(parentType, parentProps, parentInstance, textInstance, text, isConcurrentMode, shouldWarnDev) {
+  if (parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
+    checkForUnmatchedText(textInstance.nodeValue, text, isConcurrentMode);
+  }
+}
+function isHostSingletonType(type) {
+  return type === 'html' || type === 'head' || type === 'body';
+}
+function resolveSingletonInstance(type, props, rootContainerInstance, hostContext, validateDOMNestingDev) {
+
+  const ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
+
+  switch (type) {
+    case 'html':
+      {
+        const documentElement = ownerDocument.documentElement;
+
+        if (!documentElement) {
+          throw Error(formatProdErrorMessage(452));
+        }
+
+        return documentElement;
+      }
+
+    case 'head':
+      {
+        const head = ownerDocument.head;
+
+        if (!head) {
+          throw Error(formatProdErrorMessage(453));
+        }
+
+        return head;
+      }
+
+    case 'body':
+      {
+        const body = ownerDocument.body;
+
+        if (!body) {
+          throw Error(formatProdErrorMessage(454));
+        }
+
+        return body;
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(451));
+      }
+  }
+}
+function acquireSingletonInstance(type, props, instance, internalInstanceHandle) {
+
+  const attributes = instance.attributes;
+
+  while (attributes.length) {
+    instance.removeAttributeNode(attributes[0]);
+  }
+
+  setInitialProperties(instance, type, props);
+  precacheFiberNode(internalInstanceHandle, instance);
+  updateFiberProps(instance, props);
+}
+function releaseSingletonInstance(instance) {
+  const attributes = instance.attributes;
+
+  while (attributes.length) {
+    instance.removeAttributeNode(attributes[0]);
+  }
+
+  detachDeletedInstance(instance);
+}
+function clearSingleton(instance) {
+  const element = instance;
+  let node = element.firstChild;
+
+  while (node) {
+    const nextNode = node.nextSibling;
+    const nodeName = node.nodeName;
+
+    if (isMarkedHoistable(node) || nodeName === 'HEAD' || nodeName === 'BODY' || nodeName === 'SCRIPT' || nodeName === 'STYLE' || nodeName === 'LINK' && node.rel.toLowerCase() === 'stylesheet') ; else {
+      element.removeChild(node);
+    }
+
+    node = nextNode;
+  }
+
+  return;
+} // -------------------
+const NotLoaded =
+/*       */
+0b000;
+const Loaded =
+/*          */
+0b001;
+const Errored =
+/*         */
+0b010;
+const Settled =
+/*         */
+0b011;
+const Inserted =
+/*        */
+0b100;
+function prepareToCommitHoistables() {
+  tagCaches = null;
+} // global collections of Resources
+
+const preloadPropsMap = new Map();
+const preconnectsSet = new Set(); // getRootNode is missing from IE and old jsdom versions
+
+function getHoistableRoot(container) {
+  // $FlowFixMe[method-unbinding]
+  return typeof container.getRootNode === 'function' ?
+  /* $FlowFixMe[incompatible-return] Flow types this as returning a `Node`,
+   * but it's either a `Document` or `ShadowRoot`. */
+  container.getRootNode() : container.ownerDocument;
+}
+
+function getCurrentResourceRoot() {
+  const currentContainer = getCurrentRootHostContainer();
+  return currentContainer ? getHoistableRoot(currentContainer) : null;
+}
+
+function getDocumentFromRoot(root) {
+  return root.ownerDocument || root;
+} // We want this to be the default dispatcher on ReactDOMSharedInternals but we don't want to mutate
+// internals in Module scope. Instead we export it and Internals will import it. There is already a cycle
+// from Internals -> ReactDOM -> HostConfig -> Internals so this doesn't introduce a new one.
+
+
+const ReactDOMClientDispatcher = {
+  prefetchDNS: prefetchDNS$1,
+  preconnect: preconnect$1,
+  preload: preload$1,
+  preloadModule: preloadModule$1,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+}; // We expect this to get inlined. It is a function mostly to communicate the special nature of
+// how we resolve the HoistableRoot for ReactDOM.pre*() methods. Because we support calling
+// these methods outside of render there is no way to know which Document or ShadowRoot is 'scoped'
+// and so we have to fall back to something universal. Currently we just refer to the global document.
+// This is notable because nowhere else in ReactDOM do we actually reference the global document or window
+// because we may be rendering inside an iframe.
+
+function getDocumentForImperativeFloatMethods() {
+  return document;
+}
+
+function preconnectAs(rel, href, crossOrigin) {
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (typeof href === 'string' && href) {
+    const limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+    let key = "link[rel=\"" + rel + "\"][href=\"" + limitedEscapedHref + "\"]";
+
+    if (typeof crossOrigin === 'string') {
+      key += "[crossorigin=\"" + crossOrigin + "\"]";
+    }
+
+    if (!preconnectsSet.has(key)) {
+      preconnectsSet.add(key);
+      const preconnectProps = {
+        rel,
+        crossOrigin,
+        href
+      };
+
+      if (null === ownerDocument.querySelector(key)) {
+        const instance = ownerDocument.createElement('link');
+        setInitialProperties(instance, 'link', preconnectProps);
+        markNodeAsHoistable(instance);
+        ownerDocument.head.appendChild(instance);
+      }
+    }
+  }
+}
+
+function prefetchDNS$1(href) {
+
+  preconnectAs('dns-prefetch', href, null);
+}
+
+function preconnect$1(href, crossOrigin) {
+
+  preconnectAs('preconnect', href, crossOrigin);
+}
+
+function preload$1(href, as, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (href && as && ownerDocument) {
+    let preloadSelector = "link[rel=\"preload\"][as=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(as) + "\"]";
+
+    if (as === 'image') {
+      if (options && options.imageSrcSet) {
+        preloadSelector += "[imagesrcset=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(options.imageSrcSet) + "\"]";
+
+        if (typeof options.imageSizes === 'string') {
+          preloadSelector += "[imagesizes=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(options.imageSizes) + "\"]";
+        }
+      } else {
+        preloadSelector += "[href=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(href) + "\"]";
+      }
+    } else {
+      preloadSelector += "[href=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(href) + "\"]";
+    } // Some preloads are keyed under their selector. This happens when the preload is for
+    // an arbitrary type. Other preloads are keyed under the resource key they represent a preload for.
+    // Here we figure out which key to use to determine if we have a preload already.
+
+
+    let key = preloadSelector;
+
+    switch (as) {
+      case 'style':
+        key = getStyleKey(href);
+        break;
+
+      case 'script':
+        key = getScriptKey(href);
+        break;
+    }
+
+    if (!preloadPropsMap.has(key)) {
+      const preloadProps = assign({
+        rel: 'preload',
+        // There is a bug in Safari where imageSrcSet is not respected on preload links
+        // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+        // This harms older browers that do not support imageSrcSet by making their preloads not work
+        // but this population is shrinking fast and is already small so we accept this tradeoff.
+        href: as === 'image' && options && options.imageSrcSet ? undefined : href,
+        as
+      }, options);
+
+      preloadPropsMap.set(key, preloadProps);
+
+      if (null === ownerDocument.querySelector(preloadSelector)) {
+        if (as === 'style' && ownerDocument.querySelector(getStylesheetSelectorFromKey(key))) {
+          // We already have a stylesheet for this key. We don't need to preload it.
+          return;
+        } else if (as === 'script' && ownerDocument.querySelector(getScriptSelectorFromKey(key))) {
+          // We already have a stylesheet for this key. We don't need to preload it.
+          return;
+        }
+
+        const instance = ownerDocument.createElement('link');
+        setInitialProperties(instance, 'link', preloadProps);
+        markNodeAsHoistable(instance);
+        ownerDocument.head.appendChild(instance);
+      }
+    }
+  }
+}
+
+function preloadModule$1(href, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (href) {
+    const as = options && typeof options.as === 'string' ? options.as : 'script';
+    const preloadSelector = "link[rel=\"modulepreload\"][as=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(as) + "\"][href=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(href) + "\"]"; // Some preloads are keyed under their selector. This happens when the preload is for
+    // an arbitrary type. Other preloads are keyed under the resource key they represent a preload for.
+    // Here we figure out which key to use to determine if we have a preload already.
+
+    let key = preloadSelector;
+
+    switch (as) {
+      case 'audioworklet':
+      case 'paintworklet':
+      case 'serviceworker':
+      case 'sharedworker':
+      case 'worker':
+      case 'script':
+        {
+          key = getScriptKey(href);
+          break;
+        }
+    }
+
+    if (!preloadPropsMap.has(key)) {
+      const props = assign({
+        rel: 'modulepreload',
+        href
+      }, options);
+
+      preloadPropsMap.set(key, props);
+
+      if (null === ownerDocument.querySelector(preloadSelector)) {
+        switch (as) {
+          case 'audioworklet':
+          case 'paintworklet':
+          case 'serviceworker':
+          case 'sharedworker':
+          case 'worker':
+          case 'script':
+            {
+              if (ownerDocument.querySelector(getScriptSelectorFromKey(key))) {
+                return;
+              }
+            }
+        }
+
+        const instance = ownerDocument.createElement('link');
+        setInitialProperties(instance, 'link', props);
+        markNodeAsHoistable(instance);
+        ownerDocument.head.appendChild(instance);
+      }
+    }
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (href) {
+    const styles = getResourcesFromRoot(ownerDocument).hoistableStyles;
+    const key = getStyleKey(href);
+    precedence = precedence || 'default'; // Check if this resource already exists
+
+    let resource = styles.get(key);
+
+    if (resource) {
+      // We can early return. The resource exists and there is nothing
+      // more to do
+      return;
+    }
+
+    const state = {
+      loading: NotLoaded,
+      preload: null
+    }; // Attempt to hydrate instance from DOM
+
+    let instance = ownerDocument.querySelector(getStylesheetSelectorFromKey(key));
+
+    if (instance) {
+      state.loading = Loaded | Inserted;
+    } else {
+      // Construct a new instance and insert it
+      const stylesheetProps = assign({
+        rel: 'stylesheet',
+        href,
+        'data-precedence': precedence
+      }, options);
+
+      const preloadProps = preloadPropsMap.get(key);
+
+      if (preloadProps) {
+        adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps);
+      }
+
+      const link = instance = ownerDocument.createElement('link');
+      markNodeAsHoistable(link);
+      setInitialProperties(link, 'link', stylesheetProps);
+      link._p = new Promise((resolve, reject) => {
+        link.onload = resolve;
+        link.onerror = reject;
+      });
+      link.addEventListener('load', () => {
+        state.loading |= Loaded;
+      });
+      link.addEventListener('error', () => {
+        state.loading |= Errored;
+      });
+      state.loading |= Inserted;
+      insertStylesheet(instance, precedence, ownerDocument);
+    } // Construct a Resource and cache it
+
+
+    resource = {
+      type: 'stylesheet',
+      instance,
+      count: 1,
+      state
+    };
+    styles.set(key, resource);
+    return;
+  }
+}
+
+function preinitScript(src, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (src) {
+    const scripts = getResourcesFromRoot(ownerDocument).hoistableScripts;
+    const key = getScriptKey(src); // Check if this resource already exists
+
+    let resource = scripts.get(key);
+
+    if (resource) {
+      // We can early return. The resource exists and there is nothing
+      // more to do
+      return;
+    } // Attempt to hydrate instance from DOM
+
+
+    let instance = ownerDocument.querySelector(getScriptSelectorFromKey(key));
+
+    if (!instance) {
+      // Construct a new instance and insert it
+      const scriptProps = assign({
+        src,
+        async: true
+      }, options); // Adopt certain preload props
+
+
+      const preloadProps = preloadPropsMap.get(key);
+
+      if (preloadProps) {
+        adoptPreloadPropsForScript(scriptProps, preloadProps);
+      }
+
+      instance = ownerDocument.createElement('script');
+      markNodeAsHoistable(instance);
+      setInitialProperties(instance, 'link', scriptProps);
+      ownerDocument.head.appendChild(instance);
+    } // Construct a Resource and cache it
+
+
+    resource = {
+      type: 'script',
+      instance,
+      count: 1,
+      state: null
+    };
+    scripts.set(key, resource);
+    return;
+  }
+}
+
+function preinitModuleScript(src, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (src) {
+    const scripts = getResourcesFromRoot(ownerDocument).hoistableScripts;
+    const key = getScriptKey(src); // Check if this resource already exists
+
+    let resource = scripts.get(key);
+
+    if (resource) {
+      // We can early return. The resource exists and there is nothing
+      // more to do
+      return;
+    } // Attempt to hydrate instance from DOM
+
+
+    let instance = ownerDocument.querySelector(getScriptSelectorFromKey(key));
+
+    if (!instance) {
+      // Construct a new instance and insert it
+      const scriptProps = assign({
+        src,
+        async: true,
+        type: 'module'
+      }, options); // Adopt certain preload props
+
+
+      const preloadProps = preloadPropsMap.get(key);
+
+      if (preloadProps) {
+        adoptPreloadPropsForScript(scriptProps, preloadProps);
+      }
+
+      instance = ownerDocument.createElement('script');
+      markNodeAsHoistable(instance);
+      setInitialProperties(instance, 'link', scriptProps);
+      ownerDocument.head.appendChild(instance);
+    } // Construct a Resource and cache it
+
+
+    resource = {
+      type: 'script',
+      instance,
+      count: 1,
+      state: null
+    };
+    scripts.set(key, resource);
+    return;
+  }
+} // This function is called in begin work and we should always have a currentDocument set
+
+
+function getResource(type, currentProps, pendingProps) {
+  const resourceRoot = getCurrentResourceRoot();
+
+  if (!resourceRoot) {
+    throw Error(formatProdErrorMessage(446));
+  }
+
+  switch (type) {
+    case 'meta':
+    case 'title':
+      {
+        return null;
+      }
+
+    case 'style':
+      {
+        if (typeof pendingProps.precedence === 'string' && typeof pendingProps.href === 'string') {
+          const key = getStyleKey(pendingProps.href);
+          const styles = getResourcesFromRoot(resourceRoot).hoistableStyles;
+          let resource = styles.get(key);
+
+          if (!resource) {
+            resource = {
+              type: 'style',
+              instance: null,
+              count: 0,
+              state: null
+            };
+            styles.set(key, resource);
+          }
+
+          return resource;
+        }
+
+        return {
+          type: 'void',
+          instance: null,
+          count: 0,
+          state: null
+        };
+      }
+
+    case 'link':
+      {
+        if (pendingProps.rel === 'stylesheet' && typeof pendingProps.href === 'string' && typeof pendingProps.precedence === 'string') {
+          const qualifiedProps = pendingProps;
+          const key = getStyleKey(qualifiedProps.href);
+          const styles = getResourcesFromRoot(resourceRoot).hoistableStyles;
+          let resource = styles.get(key);
+
+          if (!resource) {
+            // We asserted this above but Flow can't figure out that the type satisfies
+            const ownerDocument = getDocumentFromRoot(resourceRoot);
+            resource = {
+              type: 'stylesheet',
+              instance: null,
+              count: 0,
+              state: {
+                loading: NotLoaded,
+                preload: null
+              }
+            };
+            styles.set(key, resource);
+
+            if (!preloadPropsMap.has(key)) {
+              preloadStylesheet(ownerDocument, key, preloadPropsFromStylesheet(qualifiedProps), resource.state);
+            }
+          }
+
+          return resource;
+        }
+
+        return null;
+      }
+
+    case 'script':
+      {
+        if (typeof pendingProps.src === 'string' && pendingProps.async === true) {
+          const scriptProps = pendingProps;
+          const key = getScriptKey(scriptProps.src);
+          const scripts = getResourcesFromRoot(resourceRoot).hoistableScripts;
+          let resource = scripts.get(key);
+
+          if (!resource) {
+            resource = {
+              type: 'script',
+              instance: null,
+              count: 0,
+              state: null
+            };
+            scripts.set(key, resource);
+          }
+
+          return resource;
+        }
+
+        return {
+          type: 'void',
+          instance: null,
+          count: 0,
+          state: null
+        };
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(444, type));
+      }
+  }
+}
+
+function styleTagPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    'data-href': rawProps.href,
+    'data-precedence': rawProps.precedence,
+    href: null,
+    precedence: null
+  });
+}
+
+function getStyleKey(href) {
+  const limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+  return "href=\"" + limitedEscapedHref + "\"";
+}
+
+function getStyleTagSelector(href) {
+  const limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+  return "style[data-href~=\"" + limitedEscapedHref + "\"]";
+}
+
+function getStylesheetSelectorFromKey(key) {
+  return "link[rel=\"stylesheet\"][" + key + "]";
+}
+
+function getPreloadStylesheetSelectorFromKey(key) {
+  return "link[rel=\"preload\"][as=\"style\"][" + key + "]";
+}
+
+function stylesheetPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    'data-precedence': rawProps.precedence,
+    precedence: null
+  });
+}
+
+function preloadStylesheet(ownerDocument, key, preloadProps, state) {
+  preloadPropsMap.set(key, preloadProps);
+
+  if (!ownerDocument.querySelector(getStylesheetSelectorFromKey(key))) {
+    // There is no matching stylesheet instance in the Document.
+    // We will insert a preload now to kick off loading because
+    // we expect this stylesheet to commit
+    const preloadEl = ownerDocument.querySelector(getPreloadStylesheetSelectorFromKey(key));
+
+    if (preloadEl) {
+      // If we find a preload already it was SSR'd and we won't have an actual
+      // loading state to track. For now we will just assume it is loaded
+      state.loading = Loaded;
+    } else {
+      const instance = ownerDocument.createElement('link');
+      state.preload = instance;
+      instance.addEventListener('load', () => state.loading |= Loaded);
+      instance.addEventListener('error', () => state.loading |= Errored);
+      setInitialProperties(instance, 'link', preloadProps);
+      markNodeAsHoistable(instance);
+      ownerDocument.head.appendChild(instance);
+    }
+  }
+}
+
+function preloadPropsFromStylesheet(props) {
+  return {
+    rel: 'preload',
+    as: 'style',
+    href: props.href,
+    crossOrigin: props.crossOrigin,
+    integrity: props.integrity,
+    media: props.media,
+    hrefLang: props.hrefLang,
+    referrerPolicy: props.referrerPolicy
+  };
+}
+
+function getScriptKey(src) {
+  const limitedEscapedSrc = escapeSelectorAttributeValueInsideDoubleQuotes(src);
+  return "[src=\"" + limitedEscapedSrc + "\"]";
+}
+
+function getScriptSelectorFromKey(key) {
+  return 'script[async]' + key;
+}
+
+function acquireResource(hoistableRoot, resource, props) {
+  resource.count++;
+
+  if (resource.instance === null) {
+    switch (resource.type) {
+      case 'style':
+        {
+          const qualifiedProps = props; // Attempt to hydrate instance from DOM
+
+          let instance = hoistableRoot.querySelector(getStyleTagSelector(qualifiedProps.href));
+
+          if (instance) {
+            resource.instance = instance;
+            markNodeAsHoistable(instance);
+            return instance;
+          }
+
+          const styleProps = styleTagPropsFromRawProps(props);
+          const ownerDocument = getDocumentFromRoot(hoistableRoot);
+          instance = ownerDocument.createElement('style');
+          markNodeAsHoistable(instance);
+          setInitialProperties(instance, 'style', styleProps); // TODO: `style` does not have loading state for tracking insertions. I
+          // guess because these aren't suspensey? Not sure whether this is a
+          // factoring smell.
+          // resource.state.loading |= Inserted;
+
+          insertStylesheet(instance, qualifiedProps.precedence, hoistableRoot);
+          resource.instance = instance;
+          return instance;
+        }
+
+      case 'stylesheet':
+        {
+          // This typing is enforce by `getResource`. If we change the logic
+          // there for what qualifies as a stylesheet resource we need to ensure
+          // this cast still makes sense;
+          const qualifiedProps = props;
+          const key = getStyleKey(qualifiedProps.href); // Attempt to hydrate instance from DOM
+
+          let instance = hoistableRoot.querySelector(getStylesheetSelectorFromKey(key));
+
+          if (instance) {
+            resource.state.loading |= Inserted;
+            resource.instance = instance;
+            markNodeAsHoistable(instance);
+            return instance;
+          }
+
+          const stylesheetProps = stylesheetPropsFromRawProps(props);
+          const preloadProps = preloadPropsMap.get(key);
+
+          if (preloadProps) {
+            adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps);
+          } // Construct and insert a new instance
+
+
+          const ownerDocument = getDocumentFromRoot(hoistableRoot);
+          instance = ownerDocument.createElement('link');
+          markNodeAsHoistable(instance);
+          const linkInstance = instance;
+          linkInstance._p = new Promise((resolve, reject) => {
+            linkInstance.onload = resolve;
+            linkInstance.onerror = reject;
+          });
+          setInitialProperties(instance, 'link', stylesheetProps);
+          resource.state.loading |= Inserted;
+          insertStylesheet(instance, qualifiedProps.precedence, hoistableRoot);
+          resource.instance = instance;
+          return instance;
+        }
+
+      case 'script':
+        {
+          // This typing is enforce by `getResource`. If we change the logic
+          // there for what qualifies as a stylesheet resource we need to ensure
+          // this cast still makes sense;
+          const borrowedScriptProps = props;
+          const key = getScriptKey(borrowedScriptProps.src); // Attempt to hydrate instance from DOM
+
+          let instance = hoistableRoot.querySelector(getScriptSelectorFromKey(key));
+
+          if (instance) {
+            resource.instance = instance;
+            markNodeAsHoistable(instance);
+            return instance;
+          }
+
+          let scriptProps = borrowedScriptProps;
+          const preloadProps = preloadPropsMap.get(key);
+
+          if (preloadProps) {
+            scriptProps = assign({}, borrowedScriptProps);
+            adoptPreloadPropsForScript(scriptProps, preloadProps);
+          } // Construct and insert a new instance
+
+
+          const ownerDocument = getDocumentFromRoot(hoistableRoot);
+          instance = ownerDocument.createElement('script');
+          markNodeAsHoistable(instance);
+          setInitialProperties(instance, 'link', scriptProps);
+          ownerDocument.head.appendChild(instance);
+          resource.instance = instance;
+          return instance;
+        }
+
+      case 'void':
+        {
+          return null;
+        }
+
+      default:
+        {
+          throw Error(formatProdErrorMessage(443, resource.type));
+        }
+    }
+  } else {
+    // In the case of stylesheets, they might have already been assigned an
+    // instance during `suspendResource`. But that doesn't mean they were
+    // inserted, because the commit might have been interrupted. So we need to
+    // check now.
+    //
+    // The other resource types are unaffected because they are not
+    // yet suspensey.
+    //
+    // TODO: This is a bit of a code smell. Consider refactoring how
+    // `suspendResource` and `acquireResource` work together. The idea is that
+    // `suspendResource` does all the same stuff as `acquireResource` except
+    // for the insertion.
+    if (resource.type === 'stylesheet' && (resource.state.loading & Inserted) === NotLoaded) {
+      const qualifiedProps = props;
+      const instance = resource.instance;
+      resource.state.loading |= Inserted;
+      insertStylesheet(instance, qualifiedProps.precedence, hoistableRoot);
+    }
+  }
+
+  return resource.instance;
+}
+function releaseResource(resource) {
+  resource.count--;
+}
+
+function insertStylesheet(instance, precedence, root) {
+  const nodes = root.querySelectorAll('link[rel="stylesheet"][data-precedence],style[data-precedence]');
+  const last = nodes.length ? nodes[nodes.length - 1] : null;
+  let prior = last;
+
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const nodePrecedence = node.dataset.precedence;
+
+    if (nodePrecedence === precedence) {
+      prior = node;
+    } else if (prior !== last) {
+      break;
+    }
+  }
+
+  if (prior) {
+    // We get the prior from the document so we know it is in the tree.
+    // We also know that links can't be the topmost Node so the parentNode
+    // must exist.
+    prior.parentNode.insertBefore(instance, prior.nextSibling);
+  } else {
+    const parent = root.nodeType === DOCUMENT_NODE ? root.head : root;
+    parent.insertBefore(instance, parent.firstChild);
+  }
+}
+
+function adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps) {
+  if (stylesheetProps.crossOrigin == null) stylesheetProps.crossOrigin = preloadProps.crossOrigin;
+  if (stylesheetProps.referrerPolicy == null) stylesheetProps.referrerPolicy = preloadProps.referrerPolicy;
+  if (stylesheetProps.title == null) stylesheetProps.title = preloadProps.title;
+}
+
+function adoptPreloadPropsForScript(scriptProps, preloadProps) {
+  if (scriptProps.crossOrigin == null) scriptProps.crossOrigin = preloadProps.crossOrigin;
+  if (scriptProps.referrerPolicy == null) scriptProps.referrerPolicy = preloadProps.referrerPolicy;
+  if (scriptProps.integrity == null) scriptProps.integrity = preloadProps.integrity;
+}
+
+let tagCaches = null;
+function hydrateHoistable(hoistableRoot, type, props, internalInstanceHandle) {
+  const ownerDocument = getDocumentFromRoot(hoistableRoot);
+  let instance = null;
+
+  getInstance: switch (type) {
+    case 'title':
+      {
+        instance = ownerDocument.getElementsByTagName('title')[0];
+
+        if (!instance || isOwnedInstance(instance) || instance.namespaceURI === SVG_NAMESPACE || instance.hasAttribute('itemprop')) {
+          instance = ownerDocument.createElement(type);
+          ownerDocument.head.insertBefore(instance, ownerDocument.querySelector('head > title'));
+        }
+
+        setInitialProperties(instance, type, props);
+        precacheFiberNode(internalInstanceHandle, instance);
+        markNodeAsHoistable(instance);
+        return instance;
+      }
+
+    case 'link':
+      {
+        const cache = getHydratableHoistableCache('link', 'href', ownerDocument);
+        const key = type + (props.href || '');
+        const maybeNodes = cache.get(key);
+
+        if (maybeNodes) {
+          const nodes = maybeNodes;
+
+          for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i];
+
+            if (node.getAttribute('href') !== (props.href == null ? null : props.href) || node.getAttribute('rel') !== (props.rel == null ? null : props.rel) || node.getAttribute('title') !== (props.title == null ? null : props.title) || node.getAttribute('crossorigin') !== (props.crossOrigin == null ? null : props.crossOrigin)) {
+              // mismatch, try the next node;
+              continue;
+            }
+
+            instance = node;
+            nodes.splice(i, 1);
+            break getInstance;
+          }
+        }
+
+        instance = ownerDocument.createElement(type);
+        setInitialProperties(instance, type, props);
+        ownerDocument.head.appendChild(instance);
+        break;
+      }
+
+    case 'meta':
+      {
+        const cache = getHydratableHoistableCache('meta', 'content', ownerDocument);
+        const key = type + (props.content || '');
+        const maybeNodes = cache.get(key);
+
+        if (maybeNodes) {
+          const nodes = maybeNodes;
+
+          for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i]; // We coerce content to string because it is the most likely one to
+
+            if (node.getAttribute('content') !== (props.content == null ? null : '' + props.content) || node.getAttribute('name') !== (props.name == null ? null : props.name) || node.getAttribute('property') !== (props.property == null ? null : props.property) || node.getAttribute('http-equiv') !== (props.httpEquiv == null ? null : props.httpEquiv) || node.getAttribute('charset') !== (props.charSet == null ? null : props.charSet)) {
+              // mismatch, try the next node;
+              continue;
+            }
+
+            instance = node;
+            nodes.splice(i, 1);
+            break getInstance;
+          }
+        }
+
+        instance = ownerDocument.createElement(type);
+        setInitialProperties(instance, type, props);
+        ownerDocument.head.appendChild(instance);
+        break;
+      }
+
+    default:
+      throw Error(formatProdErrorMessage(468, type));
+  } // This node is a match
+
+
+  precacheFiberNode(internalInstanceHandle, instance);
+  markNodeAsHoistable(instance);
+  return instance;
+}
+
+function getHydratableHoistableCache(type, keyAttribute, ownerDocument) {
+  let cache;
+  let caches;
+
+  if (tagCaches === null) {
+    cache = new Map();
+    caches = tagCaches = new Map();
+    caches.set(ownerDocument, cache);
+  } else {
+    caches = tagCaches;
+    const maybeCache = caches.get(ownerDocument);
+
+    if (!maybeCache) {
+      cache = new Map();
+      caches.set(ownerDocument, cache);
+    } else {
+      cache = maybeCache;
+    }
+  }
+
+  if (cache.has(type)) {
+    // We use type as a special key that signals that this cache has been seeded for this type
+    return cache;
+  } // Mark this cache as seeded for this type
+
+
+  cache.set(type, null);
+  const nodes = ownerDocument.getElementsByTagName(type);
+
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+
+    if (!isOwnedInstance(node) && (type !== 'link' || node.getAttribute('rel') !== 'stylesheet') && node.namespaceURI !== SVG_NAMESPACE) {
+      const nodeKey = node.getAttribute(keyAttribute) || '';
+      const key = type + nodeKey;
+      const existing = cache.get(key);
+
+      if (existing) {
+        existing.push(node);
+      } else {
+        cache.set(key, [node]);
+      }
+    }
+  }
+
+  return cache;
+}
+
+function mountHoistable(hoistableRoot, type, instance) {
+  const ownerDocument = getDocumentFromRoot(hoistableRoot);
+  ownerDocument.head.insertBefore(instance, type === 'title' ? ownerDocument.querySelector('head > title') : null);
+}
+function unmountHoistable(instance) {
+  instance.parentNode.removeChild(instance);
+}
+function isHostHoistableType(type, props, hostContext) {
+  let hostContextProd;
+
+  {
+    hostContextProd = hostContext;
+  } // Global opt out of hoisting for anything in SVG Namespace or anything with an itemProp inside an itemScope
+
+
+  if (hostContextProd === HostContextNamespaceSvg || props.itemProp != null) {
+
+    return false;
+  }
+
+  switch (type) {
+    case 'meta':
+    case 'title':
+      {
+        return true;
+      }
+
+    case 'style':
+      {
+        if (typeof props.precedence !== 'string' || typeof props.href !== 'string' || props.href === '') {
+
+          return false;
+        }
+
+        return true;
+      }
+
+    case 'link':
+      {
+        if (typeof props.rel !== 'string' || typeof props.href !== 'string' || props.href === '' || props.onLoad || props.onError) {
+
+          return false;
+        }
+
+        switch (props.rel) {
+          case 'stylesheet':
+            {
+              const precedence = props.precedence,
+                    disabled = props.disabled;
+
+              return typeof precedence === 'string' && disabled == null;
+            }
+
+          default:
+            {
+              return true;
+            }
+        }
+      }
+
+    case 'script':
+      {
+        if (props.async !== true || props.onLoad || props.onError || typeof props.src !== 'string' || !props.src) {
+
+          return false;
+        }
+
+        return true;
+      }
+
+    case 'noscript':
+    case 'template':
+      {
+
+        return false;
+      }
+  }
+
+  return false;
+}
+function mayResourceSuspendCommit(resource) {
+  return resource.type === 'stylesheet' && (resource.state.loading & Inserted) === NotLoaded;
+}
+function preloadInstance(type, props) {
+  // Return true to indicate it's already loaded
+  return true;
+}
+function preloadResource(resource) {
+  if (resource.type === 'stylesheet' && (resource.state.loading & Settled) === NotLoaded) {
+    // we have not finished loading the underlying stylesheet yet.
+    return false;
+  } // Return true to indicate it's already loaded
+
+
+  return true;
+}
+let suspendedState = null; // We use a noop function when we begin suspending because if possible we want the
+// waitfor step to finish synchronously. If it doesn't we'll return a function to
+// provide the actual unsuspend function and that will get completed when the count
+// hits zero or it will get cancelled if the root starts new work.
+
+function noop() {}
+
+function startSuspendingCommit() {
+  suspendedState = {
+    stylesheets: null,
+    count: 0,
+    unsuspend: noop
+  };
+}
+function suspendResource(hoistableRoot, resource, props) {
+  if (suspendedState === null) {
+    throw Error(formatProdErrorMessage(475));
+  }
+
+  const state = suspendedState;
+
+  if (resource.type === 'stylesheet') {
+    if (typeof props.media === 'string') {
+      // If we don't currently match media we avoid suspending on this resource
+      // and let it insert on the mutation path
+      if (matchMedia(props.media).matches === false) {
+        return;
+      }
+    }
+
+    if ((resource.state.loading & Inserted) === NotLoaded) {
+      if (resource.instance === null) {
+        const qualifiedProps = props;
+        const key = getStyleKey(qualifiedProps.href); // Attempt to hydrate instance from DOM
+
+        let instance = hoistableRoot.querySelector(getStylesheetSelectorFromKey(key));
+
+        if (instance) {
+          // If this instance has a loading state it came from the Fizz runtime.
+          // If there is not loading state it is assumed to have been server rendered
+          // as part of the preamble and therefore synchronously loaded. It could have
+          // errored however which we still do not yet have a means to detect. For now
+          // we assume it is loaded.
+          const maybeLoadingState = instance._p;
+
+          if (maybeLoadingState !== null && typeof maybeLoadingState === 'object' && // $FlowFixMe[method-unbinding]
+          typeof maybeLoadingState.then === 'function') {
+            const loadingState = maybeLoadingState;
+            state.count++;
+            const ping = onUnsuspend.bind(state);
+            loadingState.then(ping, ping);
+          }
+
+          resource.state.loading |= Inserted;
+          resource.instance = instance;
+          markNodeAsHoistable(instance);
+          return;
+        }
+
+        const ownerDocument = getDocumentFromRoot(hoistableRoot);
+        const stylesheetProps = stylesheetPropsFromRawProps(props);
+        const preloadProps = preloadPropsMap.get(key);
+
+        if (preloadProps) {
+          adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps);
+        } // Construct and insert a new instance
+
+
+        instance = ownerDocument.createElement('link');
+        markNodeAsHoistable(instance);
+        const linkInstance = instance; // This Promise is a loading state used by the Fizz runtime. We need this incase there is a race
+        // between this resource being rendered on the client and being rendered with a late completed boundary.
+
+        linkInstance._p = new Promise((resolve, reject) => {
+          linkInstance.onload = resolve;
+          linkInstance.onerror = reject;
+        });
+        setInitialProperties(instance, 'link', stylesheetProps);
+        resource.instance = instance;
+      }
+
+      if (state.stylesheets === null) {
+        state.stylesheets = new Map();
+      }
+
+      state.stylesheets.set(resource, hoistableRoot);
+      const preloadEl = resource.state.preload;
+
+      if (preloadEl && (resource.state.loading & Settled) === NotLoaded) {
+        state.count++;
+        const ping = onUnsuspend.bind(state);
+        preloadEl.addEventListener('load', ping);
+        preloadEl.addEventListener('error', ping);
+      }
+    }
+  }
+}
+function waitForCommitToBeReady() {
+  if (suspendedState === null) {
+    throw Error(formatProdErrorMessage(475));
+  }
+
+  const state = suspendedState;
+
+  if (state.stylesheets && state.count === 0) {
+    // We are not currently blocked but we have not inserted all stylesheets.
+    // If this insertion happens and loads or errors synchronously then we can
+    // avoid suspending the commit. To do this we check the count again immediately after
+    insertSuspendedStylesheets(state, state.stylesheets);
+  } // We need to check the count again because the inserted stylesheets may have led to new
+  // tasks to wait on.
+
+
+  if (state.count > 0) {
+    return commit => {
+      // We almost never want to show content before its styles have loaded. But
+      // eventually we will give up and allow unstyled content. So this number is
+      // somewhat arbitrary — big enough that you'd only reach it under
+      // extreme circumstances.
+      // TODO: Figure out what the browser engines do during initial page load and
+      // consider aligning our behavior with that.
+      const stylesheetTimer = setTimeout(() => {
+        if (state.stylesheets) {
+          insertSuspendedStylesheets(state, state.stylesheets);
+        }
+
+        if (state.unsuspend) {
+          const unsuspend = state.unsuspend;
+          state.unsuspend = null;
+          unsuspend();
+        }
+      }, 60000); // one minute
+
+      state.unsuspend = commit;
+      return () => {
+        state.unsuspend = null;
+        clearTimeout(stylesheetTimer);
+      };
+    };
+  }
+
+  return null;
+}
+
+function onUnsuspend() {
+  this.count--;
+
+  if (this.count === 0) {
+    if (this.stylesheets) {
+      // If we haven't actually inserted the stylesheets yet we need to do so now before starting the commit.
+      // The reason we do this after everything else has finished is because we want to have all the stylesheets
+      // load synchronously right before mutating. Ideally the new styles will cause a single recalc only on the
+      // new tree. When we filled up stylesheets we only inlcuded stylesheets with matching media attributes so we
+      // wait for them to load before actually continuing. We expect this to increase the count above zero
+      insertSuspendedStylesheets(this, this.stylesheets);
+    } else if (this.unsuspend) {
+      const unsuspend = this.unsuspend;
+      this.unsuspend = null;
+      unsuspend();
+    }
+  }
+} // This is typecast to non-null because it will always be set before read.
+// it is important that this not be used except when the stack guarantees it exists.
+// Currentlyt his is only during insertSuspendedStylesheet.
+
+
+let precedencesByRoot = null;
+
+function insertSuspendedStylesheets(state, resources) {
+  // We need to clear this out so we don't try to reinsert after the stylesheets have loaded
+  state.stylesheets = null;
+
+  if (state.unsuspend === null) {
+    // The suspended commit was cancelled. We don't need to insert any stylesheets.
+    return;
+  } // Temporarily increment count. we don't want any synchronously loaded stylesheets to try to unsuspend
+  // before we finish inserting all stylesheets.
+
+
+  state.count++;
+  precedencesByRoot = new Map();
+  resources.forEach(insertStylesheetIntoRoot, state);
+  precedencesByRoot = null; // We can remove our temporary count and if we're still at zero we can unsuspend.
+  // If we are in the synchronous phase before deciding if the commit should suspend and this
+  // ends up hitting the unsuspend path it will just invoke the noop unsuspend.
+
+  onUnsuspend.call(state);
+}
+
+function insertStylesheetIntoRoot(root, resource, map) {
+  if (resource.state.loading & Inserted) {
+    // This resource was inserted by another root committing. we don't need to insert it again
+    return;
+  }
+
+  let last;
+  let precedences = precedencesByRoot.get(root);
+
+  if (!precedences) {
+    precedences = new Map();
+    precedencesByRoot.set(root, precedences);
+    const nodes = root.querySelectorAll('link[data-precedence],style[data-precedence]');
+
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+
+      if (node.nodeName === 'link' || // We omit style tags with media="not all" because they are not in the right position
+      // and will be hoisted by the Fizz runtime imminently.
+      node.getAttribute('media') !== 'not all') {
+        precedences.set('p' + node.dataset.precedence, node);
+        last = node;
+      }
+    }
+
+    if (last) {
+      precedences.set('last', last);
+    }
+  } else {
+    last = precedences.get('last');
+  } // We only call this after we have constructed an instance so we assume it here
+
+
+  const instance = resource.instance; // We will always have a precedence for stylesheet instances
+
+  const precedence = instance.getAttribute('data-precedence');
+  const prior = precedences.get('p' + precedence) || last;
+
+  if (prior === last) {
+    precedences.set('last', instance);
+  }
+
+  precedences.set(precedence, instance);
+  this.count++;
+  const onComplete = onUnsuspend.bind(this);
+  instance.addEventListener('load', onComplete);
+  instance.addEventListener('error', onComplete);
+
+  if (prior) {
+    prior.parentNode.insertBefore(instance, prior.nextSibling);
+  } else {
+    const parent = root.nodeType === DOCUMENT_NODE ? root.head : root;
+    parent.insertBefore(instance, parent.firstChild);
+  }
+
+  resource.state.loading |= Inserted;
+}
+
+const NotPendingTransition = NotPending;
+
+const Dispatcher$1 = Internals.Dispatcher;
+
+if (typeof document !== 'undefined') {
+  // Set the default dispatcher to the client dispatcher
+  Dispatcher$1.current = ReactDOMClientDispatcher;
+}
+/* global reportError */
+
+const defaultOnRecoverableError = typeof reportError === 'function' ? // In modern browsers, reportError will dispatch an error event,
+// emulating an uncaught JavaScript error.
+reportError : error => {
+  // In older browsers and test environments, fallback to console.error.
+  // eslint-disable-next-line react-internal/no-production-logging
+  console['error'](error);
+}; // $FlowFixMe[missing-this-annot]
+
+function ReactDOMRoot(internalRoot) {
+  this._internalRoot = internalRoot;
+} // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+ReactDOMHydrationRoot.prototype.render = ReactDOMRoot.prototype.render = // $FlowFixMe[missing-this-annot]
+function (children) {
+  const root = this._internalRoot;
+
+  if (root === null) {
+    throw Error(formatProdErrorMessage(409));
+  }
+
+  updateContainer(children, root, null, null);
+}; // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+ReactDOMHydrationRoot.prototype.unmount = ReactDOMRoot.prototype.unmount = // $FlowFixMe[missing-this-annot]
+function () {
+
+  const root = this._internalRoot;
+
+  if (root !== null) {
+    this._internalRoot = null;
+    const container = root.containerInfo;
+
+    flushSync$1(() => {
+      updateContainer(null, root, null, null);
+    });
+    unmarkContainerAsRoot(container);
+  }
+};
+
+function createRoot$1(container, options) {
+  if (!isValidContainer(container)) {
+    throw Error(formatProdErrorMessage(299));
+  }
+  let isStrictMode = false;
+  let concurrentUpdatesByDefaultOverride = false;
+  let identifierPrefix = '';
+  let onRecoverableError = defaultOnRecoverableError;
+  let transitionCallbacks = null;
+
+  if (options !== null && options !== undefined) {
+
+    if (options.unstable_strictMode === true) {
+      isStrictMode = true;
+    }
+
+    if (options.identifierPrefix !== undefined) {
+      identifierPrefix = options.identifierPrefix;
+    }
+
+    if (options.onRecoverableError !== undefined) {
+      onRecoverableError = options.onRecoverableError;
+    }
+
+    if (options.unstable_transitionCallbacks !== undefined) {
+      transitionCallbacks = options.unstable_transitionCallbacks;
+    }
+  }
+
+  const root = createContainer(container, ConcurrentRoot, null, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks);
+  markContainerAsRoot(root.current, container);
+  Dispatcher$1.current = ReactDOMClientDispatcher;
+  const rootContainerElement = container.nodeType === COMMENT_NODE ? container.parentNode : container;
+  listenToAllSupportedEvents(rootContainerElement); // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
+
+  return new ReactDOMRoot(root);
+} // $FlowFixMe[missing-this-annot]
+
+function ReactDOMHydrationRoot(internalRoot) {
+  this._internalRoot = internalRoot;
+}
+
+function scheduleHydration(target) {
+  if (target) {
+    queueExplicitHydrationTarget(target);
+  }
+} // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+ReactDOMHydrationRoot.prototype.unstable_scheduleHydration = scheduleHydration;
+function hydrateRoot$1(container, initialChildren, options) {
+  if (!isValidContainer(container)) {
+    throw Error(formatProdErrorMessage(405));
+  }
+  // the hydration callbacks.
+
+
+  const hydrationCallbacks = options != null ? options : null;
+  let isStrictMode = false;
+  let concurrentUpdatesByDefaultOverride = false;
+  let identifierPrefix = '';
+  let onRecoverableError = defaultOnRecoverableError;
+  let transitionCallbacks = null;
+  let formState = null;
+
+  if (options !== null && options !== undefined) {
+    if (options.unstable_strictMode === true) {
+      isStrictMode = true;
+    }
+
+    if (options.identifierPrefix !== undefined) {
+      identifierPrefix = options.identifierPrefix;
+    }
+
+    if (options.onRecoverableError !== undefined) {
+      onRecoverableError = options.onRecoverableError;
+    }
+
+    if (options.unstable_transitionCallbacks !== undefined) {
+      transitionCallbacks = options.unstable_transitionCallbacks;
+    }
+
+    {
+      if (options.formState !== undefined) {
+        formState = options.formState;
+      }
+    }
+  }
+
+  const root = createHydrationContainer(initialChildren, null, container, ConcurrentRoot, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks, formState);
+  markContainerAsRoot(root.current, container);
+  Dispatcher$1.current = ReactDOMClientDispatcher; // This can't be a comment node since hydration doesn't work on comment nodes anyway.
+
+  listenToAllSupportedEvents(container); // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
+
+  return new ReactDOMHydrationRoot(root);
+}
+function isValidContainer(node) {
+  return !!(node && (node.nodeType === ELEMENT_NODE || node.nodeType === DOCUMENT_NODE || node.nodeType === DOCUMENT_FRAGMENT_NODE || !disableCommentsAsDOMContainers  ));
+} // TODO: Remove this function which also includes comment nodes.
+// We only use it in places that are currently more relaxed.
+
+function isValidContainerLegacy(node) {
+  return !!(node && (node.nodeType === ELEMENT_NODE || node.nodeType === DOCUMENT_NODE || node.nodeType === DOCUMENT_FRAGMENT_NODE || node.nodeType === COMMENT_NODE && node.nodeValue === ' react-mount-point-unstable '));
+}
+
+function noopOnRecoverableError() {// This isn't reachable because onRecoverableError isn't called in the
+  // legacy API.
+}
+
+function legacyCreateRootFromDOMContainer(container, initialChildren, parentComponent, callback, isHydrationContainer) {
+  if (isHydrationContainer) {
+    if (typeof callback === 'function') {
+      const originalCallback = callback;
+
+      callback = function () {
+        const instance = getPublicRootInstance(root);
+        originalCallback.call(instance);
+      };
+    }
+
+    const root = createHydrationContainer(initialChildren, callback, container, LegacyRoot, null, // hydrationCallbacks
+    false, // isStrictMode
+    false, // concurrentUpdatesByDefaultOverride,
+    '', // identifierPrefix
+    noopOnRecoverableError, // TODO(luna) Support hydration later
+    null, null);
+    container._reactRootContainer = root;
+    markContainerAsRoot(root.current, container);
+    const rootContainerElement = container.nodeType === COMMENT_NODE ? container.parentNode : container; // $FlowFixMe[incompatible-call]
+
+    listenToAllSupportedEvents(rootContainerElement);
+    flushSync$1();
+    return root;
+  } else {
+    // First clear any existing content.
+    clearContainer(container);
+
+    if (typeof callback === 'function') {
+      const originalCallback = callback;
+
+      callback = function () {
+        const instance = getPublicRootInstance(root);
+        originalCallback.call(instance);
+      };
+    }
+
+    const root = createContainer(container, LegacyRoot, null, // hydrationCallbacks
+    false, // isStrictMode
+    false, // concurrentUpdatesByDefaultOverride,
+    '', // identifierPrefix
+    noopOnRecoverableError, // onRecoverableError
+    null // transitionCallbacks
+    );
+    container._reactRootContainer = root;
+    markContainerAsRoot(root.current, container);
+    const rootContainerElement = container.nodeType === COMMENT_NODE ? container.parentNode : container; // $FlowFixMe[incompatible-call]
+
+    listenToAllSupportedEvents(rootContainerElement); // Initial mount should not be batched.
+
+    flushSync$1(() => {
+      updateContainer(initialChildren, root, parentComponent, callback);
+    });
+    return root;
+  }
+}
+
+function legacyRenderSubtreeIntoContainer(parentComponent, children, container, forceHydrate, callback) {
+
+  const maybeRoot = container._reactRootContainer;
+  let root;
+
+  if (!maybeRoot) {
+    // Initial mount
+    root = legacyCreateRootFromDOMContainer(container, children, parentComponent, callback, forceHydrate);
+  } else {
+    root = maybeRoot;
+
+    if (typeof callback === 'function') {
+      const originalCallback = callback;
+
+      callback = function () {
+        const instance = getPublicRootInstance(root);
+        originalCallback.call(instance);
+      };
+    } // Update
+
+
+    updateContainer(children, root, parentComponent, callback);
+  }
+
+  return getPublicRootInstance(root);
+}
+
+function findDOMNode(componentOrElement) {
+
+  if (componentOrElement == null) {
+    return null;
+  }
+
+  if (componentOrElement.nodeType === ELEMENT_NODE) {
+    return componentOrElement;
+  }
+
+  return findHostInstance(componentOrElement);
+}
+function hydrate(element, container, callback) {
+
+  if (!isValidContainerLegacy(container)) {
+    throw Error(formatProdErrorMessage(200));
+  }
+
+
+  return legacyRenderSubtreeIntoContainer(null, element, container, true, callback);
+}
+function render(element, container, callback) {
+
+  if (!isValidContainerLegacy(container)) {
+    throw Error(formatProdErrorMessage(200));
+  }
+
+  return legacyRenderSubtreeIntoContainer(null, element, container, false, callback);
+}
+function unstable_renderSubtreeIntoContainer(parentComponent, element, containerNode, callback) {
+
+  if (!isValidContainerLegacy(containerNode)) {
+    throw Error(formatProdErrorMessage(200));
+  }
+
+  if (parentComponent == null || !has(parentComponent)) {
+    throw Error(formatProdErrorMessage(38));
+  }
+
+  return legacyRenderSubtreeIntoContainer(parentComponent, element, containerNode, false, callback);
+}
+function unmountComponentAtNode(container) {
+  if (!isValidContainerLegacy(container)) {
+    throw Error(formatProdErrorMessage(40));
+  }
+
+  if (container._reactRootContainer) {
+
+
+    flushSync$1(() => {
+      legacyRenderSubtreeIntoContainer(null, null, container, false, () => {
+        // $FlowFixMe[incompatible-type] This should probably use `delete container._reactRootContainer`
+        container._reactRootContainer = null;
+        unmarkContainerAsRoot(container);
+      });
+    }); // If you call unmountComponentAtNode twice in quick succession, you'll
+    // get `true` twice. That's probably fine?
+
+    return true;
+  } else {
+
+    return false;
+  }
+}
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+function getCrossOriginStringAs(as, input) {
+  if (as === 'font') {
+    return '';
+  }
+
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+const Dispatcher = Internals.Dispatcher;
+function prefetchDNS(href) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    dispatcher.prefetchDNS(href);
+  } // We don't error because preconnect needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preconnect(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    const crossOrigin = options ? getCrossOriginString(options.crossOrigin) : null;
+    dispatcher.preconnect(href, crossOrigin);
+  } // We don't error because preconnect needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preload(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string' && // We check existence because we cannot enforce this function is actually called with the stated type
+  typeof options === 'object' && options !== null && typeof options.as === 'string') {
+    const as = options.as;
+    const crossOrigin = getCrossOriginStringAs(as, options.crossOrigin);
+    dispatcher.preload(href, as, {
+      crossOrigin,
+      integrity: typeof options.integrity === 'string' ? options.integrity : undefined,
+      nonce: typeof options.nonce === 'string' ? options.nonce : undefined,
+      type: typeof options.type === 'string' ? options.type : undefined,
+      fetchPriority: typeof options.fetchPriority === 'string' ? options.fetchPriority : undefined,
+      referrerPolicy: typeof options.referrerPolicy === 'string' ? options.referrerPolicy : undefined,
+      imageSrcSet: typeof options.imageSrcSet === 'string' ? options.imageSrcSet : undefined,
+      imageSizes: typeof options.imageSizes === 'string' ? options.imageSizes : undefined
+    });
+  } // We don't error because preload needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preloadModule(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    if (options) {
+      const crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);
+      dispatcher.preloadModule(href, {
+        as: typeof options.as === 'string' && options.as !== 'script' ? options.as : undefined,
+        crossOrigin,
+        integrity: typeof options.integrity === 'string' ? options.integrity : undefined
+      });
+    } else {
+      dispatcher.preloadModule(href);
+    }
+  } // We don't error because preload needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preinit(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string' && options && typeof options.as === 'string') {
+    const as = options.as;
+    const crossOrigin = getCrossOriginStringAs(as, options.crossOrigin);
+    const integrity = typeof options.integrity === 'string' ? options.integrity : undefined;
+    const fetchPriority = typeof options.fetchPriority === 'string' ? options.fetchPriority : undefined;
+
+    if (as === 'style') {
+      dispatcher.preinitStyle(href, typeof options.precedence === 'string' ? options.precedence : undefined, {
+        crossOrigin,
+        integrity,
+        fetchPriority
+      });
+    } else if (as === 'script') {
+      dispatcher.preinitScript(href, {
+        crossOrigin,
+        integrity,
+        fetchPriority,
+        nonce: typeof options.nonce === 'string' ? options.nonce : undefined
+      });
+    }
+  } // We don't error because preinit needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preinitModule(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    if (typeof options === 'object' && options !== null) {
+      if (options.as == null || options.as === 'script') {
+        const crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);
+        dispatcher.preinitModuleScript(href, {
+          crossOrigin,
+          integrity: typeof options.integrity === 'string' ? options.integrity : undefined,
+          nonce: typeof options.nonce === 'string' ? options.nonce : undefined
+        });
+      }
+    } else if (options == null) {
+      dispatcher.preinitModuleScript(href);
+    }
+  } // We don't error because preinit needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+
+function createPortal(children, container) {
+  let key = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+
+  if (!isValidContainer(container)) {
+    throw Error(formatProdErrorMessage(200));
+  } // TODO: pass ReactDOM portal implementation as third argument
+  // $FlowFixMe[incompatible-return] The Flow type is opaque but there's no way to actually create it.
+
+
+  return createPortal$1(children, container, null, key);
+}
+
+function renderSubtreeIntoContainer(parentComponent, element, containerNode, callback) {
+  return unstable_renderSubtreeIntoContainer(parentComponent, element, containerNode, callback);
+}
+
+function createRoot(container, options) {
+
+  return createRoot$1(container, options);
+}
+
+function hydrateRoot(container, initialChildren, options) {
+
+  return hydrateRoot$1(container, initialChildren, options);
+} // Overload the definition to the two valid signatures.
+// Warning, this opts-out of checking the function body.
+// eslint-disable-next-line no-redeclare
+// eslint-disable-next-line no-redeclare
+
+
+function flushSync(fn) {
+
+  return flushSync$1(fn);
+}
+// This is an array for better minification.
+
+Internals.Events = [getInstanceFromNode, getNodeFromInstance, getFiberCurrentPropsFromNode, enqueueStateRestore, restoreStateIfNeeded, batchedUpdates$1];
+injectIntoDevTools({
+  findFiberByHostInstance: getClosestInstanceFromNode,
+  bundleType: 0,
+  version: ReactVersion,
+  rendererPackageName: 'react-dom'
+});
+
+function experimental_useFormStatus() {
+
+  return useFormStatus();
+}
+function experimental_useFormState(action, initialState, permalink) {
+
+  return useFormState(action, initialState, permalink);
+}
+
+exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = Internals;
+exports.createPortal = createPortal;
+exports.createRoot = createRoot;
+exports.experimental_useFormState = experimental_useFormState;
+exports.experimental_useFormStatus = experimental_useFormStatus;
+exports.findDOMNode = findDOMNode;
+exports.flushSync = flushSync;
+exports.hydrate = hydrate;
+exports.hydrateRoot = hydrateRoot;
+exports.preconnect = preconnect;
+exports.prefetchDNS = prefetchDNS;
+exports.preinit = preinit;
+exports.preinitModule = preinitModule;
+exports.preload = preload;
+exports.preloadModule = preloadModule;
+exports.render = render;
+exports.unmountComponentAtNode = unmountComponentAtNode;
+exports.unstable_batchedUpdates = batchedUpdates$1;
+exports.unstable_renderSubtreeIntoContainer = renderSubtreeIntoContainer;
+exports.unstable_runWithPriority = runWithPriority;
+exports.useFormState = useFormState;
+exports.useFormStatus = useFormStatus;
+exports.version = ReactVersion;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.production.min.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.production.min.js
index ea65b539c661d..f5acde475a485 100644
--- a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.production.min.js
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.production.min.js
@@ -1,16 +1,14 @@
-/**
- * @license React
- * react-dom.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
 /*
+ React
+ react-dom.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
  Modernizr 3.0.0pre (Custom Build) | MIT
 */
-'use strict';var aa=require("next/dist/compiled/react-experimental"),ba=require("next/dist/compiled/scheduler-experimental"),ca={usingClientEntryPoint:!1,Events:null,Dispatcher:{current:null}};function t(a){for(var b="https://reactjs.org/docs/error-decoder.html?invariant="+a,c=1;c<arguments.length;c++)b+="&args[]="+encodeURIComponent(arguments[c]);return"Minified React error #"+a+"; visit "+b+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}
+'use strict';var aa=require("next/dist/compiled/react-experimental"),ba=require("next/dist/compiled/scheduler-experimental"),ca={usingClientEntryPoint:!1,Events:null,Dispatcher:{current:null}};function u(a){for(var b="https://reactjs.org/docs/error-decoder.html?invariant="+a,c=1;c<arguments.length;c++)b+="&args[]="+encodeURIComponent(arguments[c]);return"Minified React error #"+a+"; visit "+b+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}
 var B=Object.assign,da=aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,ea=da.ReactCurrentDispatcher,fa={pending:!1,data:null,method:null,action:null};function ia(){return ea.current.useHostTransitionStatus()}function ja(a,b,c){return ea.current.useFormState(a,b,c)}var ka=[],la=-1;function ma(a){return{current:a}}function D(a){0>la||(a.current=ka[la],ka[la]=null,la--)}function E(a,b){la++;ka[la]=a.current;a.current=b}
 var na=Symbol.for("react.element"),oa=Symbol.for("react.portal"),pa=Symbol.for("react.fragment"),qa=Symbol.for("react.strict_mode"),ra=Symbol.for("react.profiler"),sa=Symbol.for("react.provider"),ta=Symbol.for("react.context"),ua=Symbol.for("react.server_context"),va=Symbol.for("react.forward_ref"),wa=Symbol.for("react.suspense"),xa=Symbol.for("react.suspense_list"),ya=Symbol.for("react.memo"),za=Symbol.for("react.lazy"),Aa=Symbol.for("react.scope");Symbol.for("react.debug_trace_mode");
 var Ba=Symbol.for("react.offscreen"),Ca=Symbol.for("react.legacy_hidden"),Da=Symbol.for("react.cache");Symbol.for("react.tracing_marker");var Ea=Symbol.for("react.default_value"),Fa=Symbol.for("react.memo_cache_sentinel"),Ga=Symbol.for("react.postpone"),Ha=Symbol.iterator;function Ia(a){if(null===a||"object"!==typeof a)return null;a=Ha&&a[Ha]||a["@@iterator"];return"function"===typeof a?a:null}
@@ -25,14 +23,15 @@ function qb(a,b){if(a.errorRecoveryDisabledLanes&b)return 0;a=a.pendingLanes&-53
 function ub(a,b,c){var d=a.pendingLanes&~b;a.pendingLanes=b;a.suspendedLanes=0;a.pingedLanes=0;a.expiredLanes&=b;a.entangledLanes&=b;a.errorRecoveryDisabledLanes&=b;a.shellSuspendCounter=0;b=a.entanglements;for(var e=a.expirationTimes,f=a.hiddenUpdates;0<d;){var g=31-ib(d),h=1<<g;b[g]=0;e[g]=-1;var l=f[g];if(null!==l)for(f[g]=null,g=0;g<l.length;g++){var p=l[g];null!==p&&(p.lane&=-536870913)}d&=~h}0!==c&&vb(a,c,0)}
 function vb(a,b,c){a.pendingLanes|=b;a.suspendedLanes&=~b;var d=31-ib(b);a.entangledLanes|=b;a.entanglements[d]=a.entanglements[d]|1073741824|c&4194218}function wb(a,b){var c=a.entangledLanes|=b;for(a=a.entanglements;c;){var d=31-ib(c),e=1<<d;e&b|a[d]&b&&(a[d]|=b);c&=~e}}function xb(a,b){a.pendingLanes|=2;for(a.entangledLanes|=2;b;){var c=1<<31-ib(b);a.entanglements[1]|=c;b&=~c}}var F=0;function yb(a,b){var c=F;try{return F=a,b()}finally{F=c}}
 function zb(a){a&=-a;return 2<a?8<a?0!==(a&134217727)?32:268435456:8:2}var Ab=Object.prototype.hasOwnProperty,Bb=Math.random().toString(36).slice(2),Cb="__reactFiber$"+Bb,Db="__reactProps$"+Bb,Eb="__reactContainer$"+Bb,Fb="__reactEvents$"+Bb,Hb="__reactListeners$"+Bb,Ib="__reactHandles$"+Bb,Jb="__reactResources$"+Bb,Kb="__reactMarker$"+Bb;function Lb(a){delete a[Cb];delete a[Db];delete a[Fb];delete a[Hb];delete a[Ib]}
-function Mb(a){var b=a[Cb];if(b)return b;for(var c=a.parentNode;c;){if(b=c[Eb]||c[Cb]){c=b.alternate;if(null!==b.child||null!==c&&null!==c.child)for(a=Nb(a);null!==a;){if(c=a[Cb])return c;a=Nb(a)}return b}a=c;c=a.parentNode}return null}function Ob(a){if(a=a[Cb]||a[Eb]){var b=a.tag;if(5===b||6===b||13===b||26===b||27===b||3===b)return a}return null}function Pb(a){var b=a.tag;if(5===b||26===b||27===b||6===b)return a.stateNode;throw Error(t(33));}function Qb(a){return a[Db]||null}
+function Mb(a){var b=a[Cb];if(b)return b;for(var c=a.parentNode;c;){if(b=c[Eb]||c[Cb]){c=b.alternate;if(null!==b.child||null!==c&&null!==c.child)for(a=Nb(a);null!==a;){if(c=a[Cb])return c;a=Nb(a)}return b}a=c;c=a.parentNode}return null}function Ob(a){if(a=a[Cb]||a[Eb]){var b=a.tag;if(5===b||6===b||13===b||26===b||27===b||3===b)return a}return null}function Pb(a){var b=a.tag;if(5===b||26===b||27===b||6===b)return a.stateNode;throw Error(u(33));}function Qb(a){return a[Db]||null}
 function Rb(a){var b=a[Jb];b||(b=a[Jb]={hoistableStyles:new Map,hoistableScripts:new Map});return b}function Sb(a){a[Kb]=!0}var Tb=new Set,Ub={};function Vb(a,b){Wb(a,b);Wb(a+"Capture",b)}function Wb(a,b){Ub[a]=b;for(a=0;a<b.length;a++)Tb.add(b[a])}
 var Xb=!("undefined"===typeof window||"undefined"===typeof window.document||"undefined"===typeof window.document.createElement),Yb=RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"),Zb=
 {},$b={};function ac(a){if(Ab.call($b,a))return!0;if(Ab.call(Zb,a))return!1;if(Yb.test(a))return $b[a]=!0;Zb[a]=!0;return!1}function bc(a,b,c){if(ac(b))if(null===c)a.removeAttribute(b);else{switch(typeof c){case "undefined":case "function":case "symbol":a.removeAttribute(b);return;case "boolean":var d=b.toLowerCase().slice(0,5);if("data-"!==d&&"aria-"!==d){a.removeAttribute(b);return}}a.setAttribute(b,""+c)}}
 function cc(a,b,c){if(null===c)a.removeAttribute(b);else{switch(typeof c){case "undefined":case "function":case "symbol":case "boolean":a.removeAttribute(b);return}a.setAttribute(b,""+c)}}function dc(a,b,c,d){if(null===d)a.removeAttribute(c);else{switch(typeof d){case "undefined":case "function":case "symbol":case "boolean":a.removeAttribute(c);return}a.setAttributeNS(b,c,""+d)}}var ec;
 function fc(a){if(void 0===ec)try{throw Error();}catch(c){var b=c.stack.trim().match(/\n( *(at )?)/);ec=b&&b[1]||""}return"\n"+ec+a}var gc=!1;
-function hc(a,b){if(!a||gc)return"";gc=!0;var c=Error.prepareStackTrace;Error.prepareStackTrace=void 0;try{if(b)if(b=function(){throw Error();},Object.defineProperty(b.prototype,"props",{set:function(){throw Error();}}),"object"===typeof Reflect&&Reflect.construct){try{Reflect.construct(b,[])}catch(q){var d=q}Reflect.construct(a,[],b)}else{try{b.call()}catch(q){d=q}a.call(b.prototype)}else{try{throw Error();}catch(q){d=q}var e=a();e&&"function"===typeof e.catch&&e.catch(function(){})}}catch(q){if(q&&
-d&&"string"===typeof q.stack){for(var f=q.stack.split("\n"),g=d.stack.split("\n"),h=f.length-1,l=g.length-1;1<=h&&0<=l&&f[h]!==g[l];)l--;for(;1<=h&&0<=l;h--,l--)if(f[h]!==g[l]){if(1!==h||1!==l){do if(h--,l--,0>l||f[h]!==g[l]){var p="\n"+f[h].replace(" at new "," at ");a.displayName&&p.includes("<anonymous>")&&(p=p.replace("<anonymous>",a.displayName));return p}while(1<=h&&0<=l)}break}}}finally{gc=!1,Error.prepareStackTrace=c}return(a=a?a.displayName||a.name:"")?fc(a):""}
+function hc(a,b){if(!a||gc)return"";gc=!0;var c=Error.prepareStackTrace;Error.prepareStackTrace=void 0;var d={DetermineComponentFrameRoot:function(){try{if(b){var w=function(){throw Error();};Object.defineProperty(w.prototype,"props",{set:function(){throw Error();}});if("object"===typeof Reflect&&Reflect.construct){try{Reflect.construct(w,[])}catch(t){var r=t}Reflect.construct(a,[],w)}else{try{w.call()}catch(t){r=t}a.call(w.prototype)}}else{try{throw Error();}catch(t){r=t}(w=a())&&"function"===typeof w.catch&&
+w.catch(function(){})}}catch(t){if(t&&r&&"string"===typeof t.stack)return[t.stack,r.stack]}return[null,null]}};d.DetermineComponentFrameRoot.displayName="DetermineComponentFrameRoot";var e=Object.getOwnPropertyDescriptor(d.DetermineComponentFrameRoot,"name");e&&e.configurable&&Object.defineProperty(d.DetermineComponentFrameRoot,"name",{value:"DetermineComponentFrameRoot"});try{var f=d.DetermineComponentFrameRoot(),g=f[0],h=f[1];if(g&&h){var l=g.split("\n"),p=h.split("\n");for(e=d=0;d<l.length&&!l[d].includes("DetermineComponentFrameRoot");)d++;
+for(;e<p.length&&!p[e].includes("DetermineComponentFrameRoot");)e++;if(d===l.length||e===p.length)for(d=l.length-1,e=p.length-1;1<=d&&0<=e&&l[d]!==p[e];)e--;for(;1<=d&&0<=e;d--,e--)if(l[d]!==p[e]){if(1!==d||1!==e){do if(d--,e--,0>e||l[d]!==p[e]){var q="\n"+l[d].replace(" at new "," at ");a.displayName&&q.includes("<anonymous>")&&(q=q.replace("<anonymous>",a.displayName));return q}while(1<=d&&0<=e)}break}}}finally{gc=!1,Error.prepareStackTrace=c}return(c=a?a.displayName||a.name:"")?fc(c):""}
 function ic(a){switch(a.tag){case 26:case 27:case 5:return fc(a.type);case 16:return fc("Lazy");case 13:return fc("Suspense");case 19:return fc("SuspenseList");case 0:case 2:case 15:return a=hc(a.type,!1),a;case 11:return a=hc(a.type.render,!1),a;case 1:return a=hc(a.type,!0),a;default:return""}}
 function jc(a){if(null==a)return null;if("function"===typeof a)return a.displayName||a.name||null;if("string"===typeof a)return a;switch(a){case pa:return"Fragment";case oa:return"Portal";case ra:return"Profiler";case qa:return"StrictMode";case wa:return"Suspense";case xa:return"SuspenseList";case Da:return"Cache"}if("object"===typeof a)switch(a.$$typeof){case ta:return(a.displayName||"Context")+".Consumer";case sa:return(a._context.displayName||"Context")+".Provider";case va:var b=a.render;a=a.displayName;
 a||(a=b.displayName||b.name||"",a=""!==a?"ForwardRef("+a+")":"ForwardRef");return a;case ya:return b=a.displayName||null,null!==b?b:jc(a.type)||"Memo";case za:b=a._payload;a=a._init;try{return jc(a(b))}catch(c){break}case ua:return(a.displayName||a._globalName)+".Provider"}return null}
@@ -47,10 +46,10 @@ typeof e);null!=h&&"function"!==typeof h&&"symbol"!==typeof h&&"boolean"!==typeo
 function vc(a,b,c,d,e,f,g,h){null!=f&&"function"!==typeof f&&"symbol"!==typeof f&&"boolean"!==typeof f&&(a.type=f);if(null!=b||null!=c){if(!("submit"!==f&&"reset"!==f||void 0!==b&&null!==b))return;c=null!=c?""+lc(c):"";b=null!=b?""+lc(b):c;h||b===a.value||(a.value=b);a.defaultValue=b}d=null!=d?d:e;d="function"!==typeof d&&"symbol"!==typeof d&&!!d;a.checked=h?a.checked:!!d;a.defaultChecked=!!d;null!=g&&"function"!==typeof g&&"symbol"!==typeof g&&"boolean"!==typeof g&&(a.name=g)}
 function uc(a,b,c){"number"===b&&qc(a.ownerDocument)===a||a.defaultValue===""+c||(a.defaultValue=""+c)}var wc=Array.isArray;
 function xc(a,b,c,d){a=a.options;if(b){b={};for(var e=0;e<c.length;e++)b["$"+c[e]]=!0;for(c=0;c<a.length;c++)e=b.hasOwnProperty("$"+a[c].value),a[c].selected!==e&&(a[c].selected=e),e&&d&&(a[c].defaultSelected=!0)}else{c=""+lc(c);b=null;for(e=0;e<a.length;e++){if(a[e].value===c){a[e].selected=!0;d&&(a[e].defaultSelected=!0);return}null!==b||a[e].disabled||(b=a[e])}null!==b&&(b.selected=!0)}}
-function yc(a,b,c){if(null!=b&&(b=""+lc(b),b!==a.value&&(a.value=b),null==c)){a.defaultValue!==b&&(a.defaultValue=b);return}a.defaultValue=null!=c?""+lc(c):""}function zc(a,b,c,d){if(null==b){if(null!=d){if(null!=c)throw Error(t(92));if(wc(d)){if(1<d.length)throw Error(t(93));d=d[0]}c=d}null==c&&(c="");b=c}c=lc(b);a.defaultValue=c;d=a.textContent;d===c&&""!==d&&null!==d&&(a.value=d)}
+function yc(a,b,c){if(null!=b&&(b=""+lc(b),b!==a.value&&(a.value=b),null==c)){a.defaultValue!==b&&(a.defaultValue=b);return}a.defaultValue=null!=c?""+lc(c):""}function zc(a,b,c,d){if(null==b){if(null!=d){if(null!=c)throw Error(u(92));if(wc(d)){if(1<d.length)throw Error(u(93));d=d[0]}c=d}null==c&&(c="");b=c}c=lc(b);a.defaultValue=c;d=a.textContent;d===c&&""!==d&&null!==d&&(a.value=d)}
 function Ac(a,b){if(b){var c=a.firstChild;if(c&&c===a.lastChild&&3===c.nodeType){c.nodeValue=b;return}}a.textContent=b}var Bc=new Set("animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp".split(" "));
 function Cc(a,b,c){var d=0===b.indexOf("--");null==c||"boolean"===typeof c||""===c?d?a.setProperty(b,""):"float"===b?a.cssFloat="":a[b]="":d?a.setProperty(b,c):"number"!==typeof c||0===c||Bc.has(b)?"float"===b?a.cssFloat=c:a[b]=(""+c).trim():a[b]=c+"px"}
-function Dc(a,b,c){if(null!=b&&"object"!==typeof b)throw Error(t(62));a=a.style;if(null!=c){for(var d in c)!c.hasOwnProperty(d)||null!=b&&b.hasOwnProperty(d)||(0===d.indexOf("--")?a.setProperty(d,""):"float"===d?a.cssFloat="":a[d]="");for(var e in b)d=b[e],b.hasOwnProperty(e)&&c[e]!==d&&Cc(a,e,d)}else for(var f in b)b.hasOwnProperty(f)&&Cc(a,f,b[f])}
+function Dc(a,b,c){if(null!=b&&"object"!==typeof b)throw Error(u(62));a=a.style;if(null!=c){for(var d in c)!c.hasOwnProperty(d)||null!=b&&b.hasOwnProperty(d)||(0===d.indexOf("--")?a.setProperty(d,""):"float"===d?a.cssFloat="":a[d]="");for(var e in b)d=b[e],b.hasOwnProperty(e)&&c[e]!==d&&Cc(a,e,d)}else for(var f in b)b.hasOwnProperty(f)&&Cc(a,f,b[f])}
 function Ec(a){if(-1===a.indexOf("-"))return!1;switch(a){case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph":return!1;default:return!0}}
 var Fc=new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv","http-equiv"],["crossOrigin","crossorigin"],["accentHeight","accent-height"],["alignmentBaseline","alignment-baseline"],["arabicForm","arabic-form"],["baselineShift","baseline-shift"],["capHeight","cap-height"],["clipPath","clip-path"],["clipRule","clip-rule"],["colorInterpolation","color-interpolation"],["colorInterpolationFilters","color-interpolation-filters"],["colorProfile","color-profile"],["colorRendering","color-rendering"],
 ["dominantBaseline","dominant-baseline"],["enableBackground","enable-background"],["fillOpacity","fill-opacity"],["fillRule","fill-rule"],["floodColor","flood-color"],["floodOpacity","flood-opacity"],["fontFamily","font-family"],["fontSize","font-size"],["fontSizeAdjust","font-size-adjust"],["fontStretch","font-stretch"],["fontStyle","font-style"],["fontVariant","font-variant"],["fontWeight","font-weight"],["glyphName","glyph-name"],["glyphOrientationHorizontal","glyph-orientation-horizontal"],["glyphOrientationVertical",
@@ -58,81 +57,81 @@ var Fc=new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv
 "shape-rendering"],["stopColor","stop-color"],["stopOpacity","stop-opacity"],["strikethroughPosition","strikethrough-position"],["strikethroughThickness","strikethrough-thickness"],["strokeDasharray","stroke-dasharray"],["strokeDashoffset","stroke-dashoffset"],["strokeLinecap","stroke-linecap"],["strokeLinejoin","stroke-linejoin"],["strokeMiterlimit","stroke-miterlimit"],["strokeOpacity","stroke-opacity"],["strokeWidth","stroke-width"],["textAnchor","text-anchor"],["textDecoration","text-decoration"],
 ["textRendering","text-rendering"],["transformOrigin","transform-origin"],["underlinePosition","underline-position"],["underlineThickness","underline-thickness"],["unicodeBidi","unicode-bidi"],["unicodeRange","unicode-range"],["unitsPerEm","units-per-em"],["vAlphabetic","v-alphabetic"],["vHanging","v-hanging"],["vIdeographic","v-ideographic"],["vMathematical","v-mathematical"],["vectorEffect","vector-effect"],["vertAdvY","vert-adv-y"],["vertOriginX","vert-origin-x"],["vertOriginY","vert-origin-y"],
 ["wordSpacing","word-spacing"],["writingMode","writing-mode"],["xmlnsXlink","xmlns:xlink"],["xHeight","x-height"]]),Gc=null;function Hc(a){a=a.target||a.srcElement||window;a.correspondingUseElement&&(a=a.correspondingUseElement);return 3===a.nodeType?a.parentNode:a}var Ic=null,Jc=null;
-function Kc(a){var b=Ob(a);if(b&&(a=b.stateNode)){var c=Qb(a);a:switch(a=b.stateNode,b.type){case "input":tc(a,c.value,c.defaultValue,c.defaultValue,c.checked,c.defaultChecked,c.type,c.name);b=c.name;if("radio"===c.type&&null!=b){for(c=a;c.parentNode;)c=c.parentNode;c=c.querySelectorAll('input[name="'+sc(""+b)+'"][type="radio"]');for(b=0;b<c.length;b++){var d=c[b];if(d!==a&&d.form===a.form){var e=Qb(d);if(!e)throw Error(t(90));tc(d,e.value,e.defaultValue,e.defaultValue,e.checked,e.defaultChecked,
+function Kc(a){var b=Ob(a);if(b&&(a=b.stateNode)){var c=Qb(a);a:switch(a=b.stateNode,b.type){case "input":tc(a,c.value,c.defaultValue,c.defaultValue,c.checked,c.defaultChecked,c.type,c.name);b=c.name;if("radio"===c.type&&null!=b){for(c=a;c.parentNode;)c=c.parentNode;c=c.querySelectorAll('input[name="'+sc(""+b)+'"][type="radio"]');for(b=0;b<c.length;b++){var d=c[b];if(d!==a&&d.form===a.form){var e=Qb(d);if(!e)throw Error(u(90));tc(d,e.value,e.defaultValue,e.defaultValue,e.checked,e.defaultChecked,
 e.type,e.name)}}for(b=0;b<c.length;b++)d=c[b],d.form===a.form&&pc(d)}break a;case "textarea":yc(a,c.value,c.defaultValue);break a;case "select":b=c.value,null!=b&&xc(a,!!c.multiple,b,!1)}}}function Lc(a){Ic?Jc?Jc.push(a):Jc=[a]:Ic=a}function Mc(){if(Ic){var a=Ic,b=Jc;Jc=Ic=null;Kc(a);if(b)for(a=0;a<b.length;a++)Kc(b[a])}}function Nc(a){var b=a,c=a;if(a.alternate)for(;b.return;)b=b.return;else{a=b;do b=a,0!==(b.flags&4098)&&(c=b.return),a=b.return;while(a)}return 3===b.tag?c:null}
-function Oc(a){if(13===a.tag){var b=a.memoizedState;null===b&&(a=a.alternate,null!==a&&(b=a.memoizedState));if(null!==b)return b.dehydrated}return null}function Pc(a){if(Nc(a)!==a)throw Error(t(188));}
-function Qc(a){var b=a.alternate;if(!b){b=Nc(a);if(null===b)throw Error(t(188));return b!==a?null:a}for(var c=a,d=b;;){var e=c.return;if(null===e)break;var f=e.alternate;if(null===f){d=e.return;if(null!==d){c=d;continue}break}if(e.child===f.child){for(f=e.child;f;){if(f===c)return Pc(e),a;if(f===d)return Pc(e),b;f=f.sibling}throw Error(t(188));}if(c.return!==d.return)c=e,d=f;else{for(var g=!1,h=e.child;h;){if(h===c){g=!0;c=e;d=f;break}if(h===d){g=!0;d=e;c=f;break}h=h.sibling}if(!g){for(h=f.child;h;){if(h===
-c){g=!0;c=f;d=e;break}if(h===d){g=!0;d=f;c=e;break}h=h.sibling}if(!g)throw Error(t(189));}}if(c.alternate!==d)throw Error(t(190));}if(3!==c.tag)throw Error(t(188));return c.stateNode.current===c?a:b}function Rc(a){a=Qc(a);return null!==a?Sc(a):null}function Sc(a){var b=a.tag;if(5===b||26===b||27===b||6===b)return a;for(a=a.child;null!==a;){b=Sc(a);if(null!==b)return b;a=a.sibling}return null}var Tc={},Uc=ma(Tc),Vc=ma(!1),Wc=Tc;
+function Oc(a){if(13===a.tag){var b=a.memoizedState;null===b&&(a=a.alternate,null!==a&&(b=a.memoizedState));if(null!==b)return b.dehydrated}return null}function Pc(a){if(Nc(a)!==a)throw Error(u(188));}
+function Qc(a){var b=a.alternate;if(!b){b=Nc(a);if(null===b)throw Error(u(188));return b!==a?null:a}for(var c=a,d=b;;){var e=c.return;if(null===e)break;var f=e.alternate;if(null===f){d=e.return;if(null!==d){c=d;continue}break}if(e.child===f.child){for(f=e.child;f;){if(f===c)return Pc(e),a;if(f===d)return Pc(e),b;f=f.sibling}throw Error(u(188));}if(c.return!==d.return)c=e,d=f;else{for(var g=!1,h=e.child;h;){if(h===c){g=!0;c=e;d=f;break}if(h===d){g=!0;d=e;c=f;break}h=h.sibling}if(!g){for(h=f.child;h;){if(h===
+c){g=!0;c=f;d=e;break}if(h===d){g=!0;d=f;c=e;break}h=h.sibling}if(!g)throw Error(u(189));}}if(c.alternate!==d)throw Error(u(190));}if(3!==c.tag)throw Error(u(188));return c.stateNode.current===c?a:b}function Rc(a){a=Qc(a);return null!==a?Sc(a):null}function Sc(a){var b=a.tag;if(5===b||26===b||27===b||6===b)return a;for(a=a.child;null!==a;){b=Sc(a);if(null!==b)return b;a=a.sibling}return null}var Tc={},Uc=ma(Tc),Vc=ma(!1),Wc=Tc;
 function Xc(a,b){var c=a.type.contextTypes;if(!c)return Tc;var d=a.stateNode;if(d&&d.__reactInternalMemoizedUnmaskedChildContext===b)return d.__reactInternalMemoizedMaskedChildContext;var e={},f;for(f in c)e[f]=b[f];d&&(a=a.stateNode,a.__reactInternalMemoizedUnmaskedChildContext=b,a.__reactInternalMemoizedMaskedChildContext=e);return e}function Yc(a){a=a.childContextTypes;return null!==a&&void 0!==a}function Zc(){D(Vc);D(Uc)}
-function $c(a,b,c){if(Uc.current!==Tc)throw Error(t(168));E(Uc,b);E(Vc,c)}function ad(a,b,c){var d=a.stateNode;b=b.childContextTypes;if("function"!==typeof d.getChildContext)return c;d=d.getChildContext();for(var e in d)if(!(e in b))throw Error(t(108,kc(a)||"Unknown",e));return B({},c,d)}function bd(a){a=(a=a.stateNode)&&a.__reactInternalMemoizedMergedChildContext||Tc;Wc=Uc.current;E(Uc,a);E(Vc,Vc.current);return!0}
-function cd(a,b,c){var d=a.stateNode;if(!d)throw Error(t(169));c?(a=ad(a,b,Wc),d.__reactInternalMemoizedMergedChildContext=a,D(Vc),D(Uc),E(Uc,a)):D(Vc);E(Vc,c)}function dd(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var ed="function"===typeof Object.is?Object.is:dd,fd=[],gd=0,hd=null,id=0,jd=[],kd=0,ld=null,md=1,nd="";function od(a,b){fd[gd++]=id;fd[gd++]=hd;hd=a;id=b}
+function $c(a,b,c){if(Uc.current!==Tc)throw Error(u(168));E(Uc,b);E(Vc,c)}function ad(a,b,c){var d=a.stateNode;b=b.childContextTypes;if("function"!==typeof d.getChildContext)return c;d=d.getChildContext();for(var e in d)if(!(e in b))throw Error(u(108,kc(a)||"Unknown",e));return B({},c,d)}function bd(a){a=(a=a.stateNode)&&a.__reactInternalMemoizedMergedChildContext||Tc;Wc=Uc.current;E(Uc,a);E(Vc,Vc.current);return!0}
+function cd(a,b,c){var d=a.stateNode;if(!d)throw Error(u(169));c?(a=ad(a,b,Wc),d.__reactInternalMemoizedMergedChildContext=a,D(Vc),D(Uc),E(Uc,a)):D(Vc);E(Vc,c)}function dd(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var ed="function"===typeof Object.is?Object.is:dd,fd=[],gd=0,hd=null,id=0,jd=[],kd=0,ld=null,md=1,nd="";function od(a,b){fd[gd++]=id;fd[gd++]=hd;hd=a;id=b}
 function pd(a,b,c){jd[kd++]=md;jd[kd++]=nd;jd[kd++]=ld;ld=a;var d=md;a=nd;var e=32-ib(d)-1;d&=~(1<<e);c+=1;var f=32-ib(b)+e;if(30<f){var g=e-e%5;f=(d&(1<<g)-1).toString(32);d>>=g;e-=g;md=1<<32-ib(b)+e|c<<e|d;nd=f+a}else md=1<<f|c<<e|d,nd=a}function qd(a){null!==a.return&&(od(a,1),pd(a,1,0))}function rd(a){for(;a===hd;)hd=fd[--gd],fd[gd]=null,id=fd[--gd],fd[gd]=null;for(;a===ld;)ld=jd[--kd],jd[kd]=null,nd=jd[--kd],jd[kd]=null,md=jd[--kd],jd[kd]=null}var G=null,J=null,K=!1,sd=null,td=!1;
 function ud(a,b){var c=vd(5,null,null,0);c.elementType="DELETED";c.stateNode=b;c.return=a;b=a.deletions;null===b?(a.deletions=[c],a.flags|=16):b.push(c)}function wd(a,b){b.flags=b.flags&-4097|2}function xd(a,b){b=yd(b,a.type,a.pendingProps,td);return null!==b?(a.stateNode=b,G=a,J=zd(b.firstChild),td=!1,!0):!1}function Ad(a,b){b=Bd(b,a.pendingProps,td);return null!==b?(a.stateNode=b,G=a,J=null,!0):!1}
-function Cd(a,b){a:{var c=b;for(b=td;8!==c.nodeType;){if(!b){b=null;break a}c=Dd(c);if(null===c){b=null;break a}}b=c}return null!==b?(c=null!==ld?{id:md,overflow:nd}:null,a.memoizedState={dehydrated:b,treeContext:c,retryLane:536870912},c=vd(18,null,null,0),c.stateNode=b,c.return=a,a.child=c,G=a,J=null,!0):!1}function Ed(a){return 0!==(a.mode&1)&&0===(a.flags&128)}function Fd(){throw Error(t(418));}
+function Cd(a,b){a:{var c=b;for(b=td;8!==c.nodeType;){if(!b){b=null;break a}c=Dd(c);if(null===c){b=null;break a}}b=c}return null!==b?(c=null!==ld?{id:md,overflow:nd}:null,a.memoizedState={dehydrated:b,treeContext:c,retryLane:536870912},c=vd(18,null,null,0),c.stateNode=b,c.return=a,a.child=c,G=a,J=null,!0):!1}function Ed(a){return 0!==(a.mode&1)&&0===(a.flags&128)}function Fd(){throw Error(u(418));}
 function Gd(a){for(G=a.return;G;)switch(G.tag){case 3:case 27:td=!0;return;case 5:case 13:td=!1;return;default:G=G.return}}
-function Hd(a){if(a!==G)return!1;if(!K)return Gd(a),K=!0,!1;var b=!1,c;if(c=3!==a.tag&&27!==a.tag){if(c=5===a.tag)c=a.type,c=!("form"!==c&&"button"!==c)||Id(a.type,a.memoizedProps);c=!c}c&&(b=!0);if(b&&(b=J))if(Ed(a))Jd(),Fd();else for(;b;)ud(a,b),b=Dd(b);Gd(a);if(13===a.tag){a=a.memoizedState;a=null!==a?a.dehydrated:null;if(!a)throw Error(t(317));a:{a=a.nextSibling;for(b=0;a;){if(8===a.nodeType)if(c=a.data,"/$"===c){if(0===b){J=Dd(a);break a}b--}else"$"!==c&&"$!"!==c&&"$?"!==c||b++;a=a.nextSibling}J=
+function Hd(a){if(a!==G)return!1;if(!K)return Gd(a),K=!0,!1;var b=!1,c;if(c=3!==a.tag&&27!==a.tag){if(c=5===a.tag)c=a.type,c=!("form"!==c&&"button"!==c)||Id(a.type,a.memoizedProps);c=!c}c&&(b=!0);if(b&&(b=J))if(Ed(a))Jd(),Fd();else for(;b;)ud(a,b),b=Dd(b);Gd(a);if(13===a.tag){a=a.memoizedState;a=null!==a?a.dehydrated:null;if(!a)throw Error(u(317));a:{a=a.nextSibling;for(b=0;a;){if(8===a.nodeType)if(c=a.data,"/$"===c){if(0===b){J=Dd(a);break a}b--}else"$"!==c&&"$!"!==c&&"$?"!==c||b++;a=a.nextSibling}J=
 null}}else J=G?Dd(a.stateNode):null;return!0}function Jd(){for(var a=J;a;)a=Dd(a)}function Kd(){J=G=null;K=!1}function Ld(a){null===sd?sd=[a]:sd.push(a)}var Md=[],Nd=0,Od=0;function Pd(){for(var a=Nd,b=Od=Nd=0;b<a;){var c=Md[b];Md[b++]=null;var d=Md[b];Md[b++]=null;var e=Md[b];Md[b++]=null;var f=Md[b];Md[b++]=null;if(null!==d&&null!==e){var g=d.pending;null===g?e.next=e:(e.next=g.next,g.next=e);d.pending=e}0!==f&&Qd(c,e,f)}}
 function Rd(a,b,c,d){Md[Nd++]=a;Md[Nd++]=b;Md[Nd++]=c;Md[Nd++]=d;Od|=d;a.lanes|=d;a=a.alternate;null!==a&&(a.lanes|=d)}function Sd(a,b,c,d){Rd(a,b,c,d);return Td(a)}function Ud(a,b){Rd(a,null,null,b);return Td(a)}
-function Qd(a,b,c){a.lanes|=c;var d=a.alternate;null!==d&&(d.lanes|=c);for(var e=!1,f=a.return;null!==f;)f.childLanes|=c,d=f.alternate,null!==d&&(d.childLanes|=c),22===f.tag&&(a=f.stateNode,null===a||a._visibility&1||(e=!0)),a=f,f=f.return;e&&null!==b&&3===a.tag&&(f=a.stateNode,e=31-ib(c),f=f.hiddenUpdates,a=f[e],null===a?f[e]=[b]:a.push(b),b.lane=c|536870912)}function Td(a){if(50<Vd)throw Vd=0,Wd=null,Error(t(185));for(var b=a.return;null!==b;)a=b,b=a.return;return 3===a.tag?a.stateNode:null}
+function Qd(a,b,c){a.lanes|=c;var d=a.alternate;null!==d&&(d.lanes|=c);for(var e=!1,f=a.return;null!==f;)f.childLanes|=c,d=f.alternate,null!==d&&(d.childLanes|=c),22===f.tag&&(a=f.stateNode,null===a||a._visibility&1||(e=!0)),a=f,f=f.return;e&&null!==b&&3===a.tag&&(f=a.stateNode,e=31-ib(c),f=f.hiddenUpdates,a=f[e],null===a?f[e]=[b]:a.push(b),b.lane=c|536870912)}function Td(a){if(50<Vd)throw Vd=0,Wd=null,Error(u(185));for(var b=a.return;null!==b;)a=b,b=a.return;return 3===a.tag?a.stateNode:null}
 var Xd=!1;function Yd(a){a.updateQueue={baseState:a.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,lanes:0,hiddenCallbacks:null},callbacks:null}}function Zd(a,b){a=a.updateQueue;b.updateQueue===a&&(b.updateQueue={baseState:a.baseState,firstBaseUpdate:a.firstBaseUpdate,lastBaseUpdate:a.lastBaseUpdate,shared:a.shared,callbacks:null})}function $d(a){return{lane:a,tag:0,payload:null,callback:null,next:null}}
 function ae(a,b,c){var d=a.updateQueue;if(null===d)return null;d=d.shared;if(0!==(L&2)){var e=d.pending;null===e?b.next=b:(b.next=e.next,e.next=b);d.pending=b;b=Td(a);Qd(a,null,c);return b}Rd(a,d,b,c);return Td(a)}function be(a,b,c){b=b.updateQueue;if(null!==b&&(b=b.shared,0!==(c&4194176))){var d=b.lanes;d&=a.pendingLanes;c|=d;b.lanes=c;wb(a,c)}}
 function ce(a,b){var c=a.updateQueue,d=a.alternate;if(null!==d&&(d=d.updateQueue,c===d)){var e=null,f=null;c=c.firstBaseUpdate;if(null!==c){do{var g={lane:c.lane,tag:c.tag,payload:c.payload,callback:null,next:null};null===f?e=f=g:f=f.next=g;c=c.next}while(null!==c);null===f?e=f=b:f=f.next=b}else e=f=b;c={baseState:d.baseState,firstBaseUpdate:e,lastBaseUpdate:f,shared:d.shared,callbacks:d.callbacks};a.updateQueue=c;return}a=c.lastBaseUpdate;null===a?c.firstBaseUpdate=b:a.next=b;c.lastBaseUpdate=b}
-function de(a,b,c,d){var e=a.updateQueue;Xd=!1;var f=e.firstBaseUpdate,g=e.lastBaseUpdate,h=e.shared.pending;if(null!==h){e.shared.pending=null;var l=h,p=l.next;l.next=null;null===g?f=p:g.next=p;g=l;var q=a.alternate;null!==q&&(q=q.updateQueue,h=q.lastBaseUpdate,h!==g&&(null===h?q.firstBaseUpdate=p:h.next=p,q.lastBaseUpdate=l))}if(null!==f){var w=e.baseState;g=0;q=p=l=null;h=f;do{var r=h.lane&-536870913,u=r!==h.lane;if(u?(M&r)===r:(d&r)===r){null!==q&&(q=q.next={lane:0,tag:h.tag,payload:h.payload,
-callback:null,next:null});a:{var z=a,C=h;r=b;var V=c;switch(C.tag){case 1:z=C.payload;if("function"===typeof z){w=z.call(V,w,r);break a}w=z;break a;case 3:z.flags=z.flags&-65537|128;case 0:z=C.payload;r="function"===typeof z?z.call(V,w,r):z;if(null===r||void 0===r)break a;w=B({},w,r);break a;case 2:Xd=!0}}r=h.callback;null!==r&&(a.flags|=64,u&&(a.flags|=8192),u=e.callbacks,null===u?e.callbacks=[r]:u.push(r))}else u={lane:r,tag:h.tag,payload:h.payload,callback:h.callback,next:null},null===q?(p=q=u,
-l=w):q=q.next=u,g|=r;h=h.next;if(null===h)if(h=e.shared.pending,null===h)break;else u=h,h=u.next,u.next=null,e.lastBaseUpdate=u,e.shared.pending=null}while(1);null===q&&(l=w);e.baseState=l;e.firstBaseUpdate=p;e.lastBaseUpdate=q;null===f&&(e.shared.lanes=0);ee|=g;a.lanes=g;a.memoizedState=w}}function fe(a,b){if("function"!==typeof a)throw Error(t(191,a));a.call(b)}function ge(a,b){var c=a.callbacks;if(null!==c)for(a.callbacks=null,a=0;a<c.length;a++)fe(c[a],b)}
-function he(a,b){if(ed(a,b))return!0;if("object"!==typeof a||null===a||"object"!==typeof b||null===b)return!1;var c=Object.keys(a),d=Object.keys(b);if(c.length!==d.length)return!1;for(d=0;d<c.length;d++){var e=c[d];if(!Ab.call(b,e)||!ed(a[e],b[e]))return!1}return!0}var ie=Error(t(460)),je=Error(t(474)),ke={then:function(){}};function le(a){a=a.status;return"fulfilled"===a||"rejected"===a}function me(){}
-function ne(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(me,me),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":a=b.reason;if(a===ie)throw Error(t(483));throw a;default:if("string"===typeof b.status)b.then(me,me);else{a=N;if(null!==a&&100<a.shellSuspendCounter)throw Error(t(482));a=b;a.status="pending";a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}});switch(b.status){case "fulfilled":return b.value;
-case "rejected":a=b.reason;if(a===ie)throw Error(t(483));throw a;}}oe=b;throw ie;}}var oe=null;function pe(){if(null===oe)throw Error(t(459));var a=oe;oe=null;return a}var qe=null,re=0;function se(a){var b=re;re+=1;null===qe&&(qe=[]);return ne(qe,a,b)}
-function te(a,b,c){a=c.ref;if(null!==a&&"function"!==typeof a&&"object"!==typeof a){if(c._owner){c=c._owner;if(c){if(1!==c.tag)throw Error(t(309));var d=c.stateNode}if(!d)throw Error(t(147,a));var e=d,f=""+a;if(null!==b&&null!==b.ref&&"function"===typeof b.ref&&b.ref._stringRef===f)return b.ref;b=function(g){var h=e.refs;null===g?delete h[f]:h[f]=g};b._stringRef=f;return b}if("string"!==typeof a)throw Error(t(284));if(!c._owner)throw Error(t(290,a));}return a}
-function ue(a,b){a=Object.prototype.toString.call(b);throw Error(t(31,"[object Object]"===a?"object with keys {"+Object.keys(b).join(", ")+"}":a));}function ve(a){var b=a._init;return b(a._payload)}
+function de(a,b,c,d){var e=a.updateQueue;Xd=!1;var f=e.firstBaseUpdate,g=e.lastBaseUpdate,h=e.shared.pending;if(null!==h){e.shared.pending=null;var l=h,p=l.next;l.next=null;null===g?f=p:g.next=p;g=l;var q=a.alternate;null!==q&&(q=q.updateQueue,h=q.lastBaseUpdate,h!==g&&(null===h?q.firstBaseUpdate=p:h.next=p,q.lastBaseUpdate=l))}if(null!==f){var w=e.baseState;g=0;q=p=l=null;h=f;do{var r=h.lane&-536870913,t=r!==h.lane;if(t?(M&r)===r:(d&r)===r){null!==q&&(q=q.next={lane:0,tag:h.tag,payload:h.payload,
+callback:null,next:null});a:{var z=a,C=h;r=b;var V=c;switch(C.tag){case 1:z=C.payload;if("function"===typeof z){w=z.call(V,w,r);break a}w=z;break a;case 3:z.flags=z.flags&-65537|128;case 0:z=C.payload;r="function"===typeof z?z.call(V,w,r):z;if(null===r||void 0===r)break a;w=B({},w,r);break a;case 2:Xd=!0}}r=h.callback;null!==r&&(a.flags|=64,t&&(a.flags|=8192),t=e.callbacks,null===t?e.callbacks=[r]:t.push(r))}else t={lane:r,tag:h.tag,payload:h.payload,callback:h.callback,next:null},null===q?(p=q=t,
+l=w):q=q.next=t,g|=r;h=h.next;if(null===h)if(h=e.shared.pending,null===h)break;else t=h,h=t.next,t.next=null,e.lastBaseUpdate=t,e.shared.pending=null}while(1);null===q&&(l=w);e.baseState=l;e.firstBaseUpdate=p;e.lastBaseUpdate=q;null===f&&(e.shared.lanes=0);ee|=g;a.lanes=g;a.memoizedState=w}}function fe(a,b){if("function"!==typeof a)throw Error(u(191,a));a.call(b)}function ge(a,b){var c=a.callbacks;if(null!==c)for(a.callbacks=null,a=0;a<c.length;a++)fe(c[a],b)}
+function he(a,b){if(ed(a,b))return!0;if("object"!==typeof a||null===a||"object"!==typeof b||null===b)return!1;var c=Object.keys(a),d=Object.keys(b);if(c.length!==d.length)return!1;for(d=0;d<c.length;d++){var e=c[d];if(!Ab.call(b,e)||!ed(a[e],b[e]))return!1}return!0}var ie=Error(u(460)),je=Error(u(474)),ke={then:function(){}};function le(a){a=a.status;return"fulfilled"===a||"rejected"===a}function me(){}
+function ne(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(me,me),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":a=b.reason;if(a===ie)throw Error(u(483));throw a;default:if("string"===typeof b.status)b.then(me,me);else{a=N;if(null!==a&&100<a.shellSuspendCounter)throw Error(u(482));a=b;a.status="pending";a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}});switch(b.status){case "fulfilled":return b.value;
+case "rejected":a=b.reason;if(a===ie)throw Error(u(483));throw a;}}oe=b;throw ie;}}var oe=null;function pe(){if(null===oe)throw Error(u(459));var a=oe;oe=null;return a}var qe=null,re=0;function se(a){var b=re;re+=1;null===qe&&(qe=[]);return ne(qe,a,b)}
+function te(a,b,c){a=c.ref;if(null!==a&&"function"!==typeof a&&"object"!==typeof a){if(c._owner){c=c._owner;if(c){if(1!==c.tag)throw Error(u(309));var d=c.stateNode}if(!d)throw Error(u(147,a));var e=d,f=""+a;if(null!==b&&null!==b.ref&&"function"===typeof b.ref&&b.ref._stringRef===f)return b.ref;b=function(g){var h=e.refs;null===g?delete h[f]:h[f]=g};b._stringRef=f;return b}if("string"!==typeof a)throw Error(u(284));if(!c._owner)throw Error(u(290,a));}return a}
+function ue(a,b){a=Object.prototype.toString.call(b);throw Error(u(31,"[object Object]"===a?"object with keys {"+Object.keys(b).join(", ")+"}":a));}function ve(a){var b=a._init;return b(a._payload)}
 function we(a){function b(m,k){if(a){var n=m.deletions;null===n?(m.deletions=[k],m.flags|=16):n.push(k)}}function c(m,k){if(!a)return null;for(;null!==k;)b(m,k),k=k.sibling;return null}function d(m,k){for(m=new Map;null!==k;)null!==k.key?m.set(k.key,k):m.set(k.index,k),k=k.sibling;return m}function e(m,k){m=xe(m,k);m.index=0;m.sibling=null;return m}function f(m,k,n){m.index=n;if(!a)return m.flags|=1048576,k;n=m.alternate;if(null!==n)return n=n.index,n<k?(m.flags|=33554434,k):n;m.flags|=33554434;return k}
 function g(m){a&&null===m.alternate&&(m.flags|=33554434);return m}function h(m,k,n,v){if(null===k||6!==k.tag)return k=ye(n,m.mode,v),k.return=m,k;k=e(k,n);k.return=m;return k}function l(m,k,n,v){var x=n.type;if(x===pa)return q(m,k,n.props.children,v,n.key);if(null!==k&&(k.elementType===x||"object"===typeof x&&null!==x&&x.$$typeof===za&&ve(x)===k.type))return v=e(k,n.props),v.ref=te(m,k,n),v.return=m,v;v=ze(n.type,n.key,n.props,null,null,m.mode,v);v.ref=te(m,k,n);v.return=m;return v}function p(m,k,
 n,v){if(null===k||4!==k.tag||k.stateNode.containerInfo!==n.containerInfo||k.stateNode.implementation!==n.implementation)return k=Ae(n,m.mode,v),k.return=m,k;k=e(k,n.children||[]);k.return=m;return k}function q(m,k,n,v,x){if(null===k||7!==k.tag)return k=Be(n,m.mode,v,x),k.return=m,k;k=e(k,n);k.return=m;return k}function w(m,k,n){if("string"===typeof k&&""!==k||"number"===typeof k)return k=ye(""+k,m.mode,n),k.return=m,k;if("object"===typeof k&&null!==k){switch(k.$$typeof){case na:return n=ze(k.type,
 k.key,k.props,null,null,m.mode,n),n.ref=te(m,null,k),n.return=m,n;case oa:return k=Ae(k,m.mode,n),k.return=m,k;case za:var v=k._init;return w(m,v(k._payload),n)}if(wc(k)||Ia(k))return k=Be(k,m.mode,n,null),k.return=m,k;if("function"===typeof k.then)return w(m,se(k),n);if(k.$$typeof===ta||k.$$typeof===ua)return w(m,Ce(m,k,n),n);ue(m,k)}return null}function r(m,k,n,v){var x=null!==k?k.key:null;if("string"===typeof n&&""!==n||"number"===typeof n)return null!==x?null:h(m,k,""+n,v);if("object"===typeof n&&
-null!==n){switch(n.$$typeof){case na:return n.key===x?l(m,k,n,v):null;case oa:return n.key===x?p(m,k,n,v):null;case za:return x=n._init,r(m,k,x(n._payload),v)}if(wc(n)||Ia(n))return null!==x?null:q(m,k,n,v,null);if("function"===typeof n.then)return r(m,k,se(n),v);if(n.$$typeof===ta||n.$$typeof===ua)return r(m,k,Ce(m,n,v),v);ue(m,n)}return null}function u(m,k,n,v,x){if("string"===typeof v&&""!==v||"number"===typeof v)return m=m.get(n)||null,h(k,m,""+v,x);if("object"===typeof v&&null!==v){switch(v.$$typeof){case na:return m=
-m.get(null===v.key?n:v.key)||null,l(k,m,v,x);case oa:return m=m.get(null===v.key?n:v.key)||null,p(k,m,v,x);case za:var A=v._init;return u(m,k,n,A(v._payload),x)}if(wc(v)||Ia(v))return m=m.get(n)||null,q(k,m,v,x,null);if("function"===typeof v.then)return u(m,k,n,se(v),x);if(v.$$typeof===ta||v.$$typeof===ua)return u(m,k,n,Ce(k,v,x),x);ue(k,v)}return null}function z(m,k,n,v){for(var x=null,A=null,y=k,H=k=0,ha=null;null!==y&&H<n.length;H++){y.index>H?(ha=y,y=null):ha=y.sibling;var I=r(m,y,n[H],v);if(null===
-I){null===y&&(y=ha);break}a&&y&&null===I.alternate&&b(m,y);k=f(I,k,H);null===A?x=I:A.sibling=I;A=I;y=ha}if(H===n.length)return c(m,y),K&&od(m,H),x;if(null===y){for(;H<n.length;H++)y=w(m,n[H],v),null!==y&&(k=f(y,k,H),null===A?x=y:A.sibling=y,A=y);K&&od(m,H);return x}for(y=d(m,y);H<n.length;H++)ha=u(y,m,H,n[H],v),null!==ha&&(a&&null!==ha.alternate&&y.delete(null===ha.key?H:ha.key),k=f(ha,k,H),null===A?x=ha:A.sibling=ha,A=ha);a&&y.forEach(function(Gb){return b(m,Gb)});K&&od(m,H);return x}function C(m,
-k,n,v){var x=Ia(n);if("function"!==typeof x)throw Error(t(150));n=x.call(n);if(null==n)throw Error(t(151));for(var A=x=null,y=k,H=k=0,ha=null,I=n.next();null!==y&&!I.done;H++,I=n.next()){y.index>H?(ha=y,y=null):ha=y.sibling;var Gb=r(m,y,I.value,v);if(null===Gb){null===y&&(y=ha);break}a&&y&&null===Gb.alternate&&b(m,y);k=f(Gb,k,H);null===A?x=Gb:A.sibling=Gb;A=Gb;y=ha}if(I.done)return c(m,y),K&&od(m,H),x;if(null===y){for(;!I.done;H++,I=n.next())I=w(m,I.value,v),null!==I&&(k=f(I,k,H),null===A?x=I:A.sibling=
-I,A=I);K&&od(m,H);return x}for(y=d(m,y);!I.done;H++,I=n.next())I=u(y,m,H,I.value,v),null!==I&&(a&&null!==I.alternate&&y.delete(null===I.key?H:I.key),k=f(I,k,H),null===A?x=I:A.sibling=I,A=I);a&&y.forEach(function(Qm){return b(m,Qm)});K&&od(m,H);return x}function V(m,k,n,v){"object"===typeof n&&null!==n&&n.type===pa&&null===n.key&&(n=n.props.children);if("object"===typeof n&&null!==n){switch(n.$$typeof){case na:a:{for(var x=n.key,A=k;null!==A;){if(A.key===x){x=n.type;if(x===pa){if(7===A.tag){c(m,A.sibling);
+null!==n){switch(n.$$typeof){case na:return n.key===x?l(m,k,n,v):null;case oa:return n.key===x?p(m,k,n,v):null;case za:return x=n._init,r(m,k,x(n._payload),v)}if(wc(n)||Ia(n))return null!==x?null:q(m,k,n,v,null);if("function"===typeof n.then)return r(m,k,se(n),v);if(n.$$typeof===ta||n.$$typeof===ua)return r(m,k,Ce(m,n,v),v);ue(m,n)}return null}function t(m,k,n,v,x){if("string"===typeof v&&""!==v||"number"===typeof v)return m=m.get(n)||null,h(k,m,""+v,x);if("object"===typeof v&&null!==v){switch(v.$$typeof){case na:return m=
+m.get(null===v.key?n:v.key)||null,l(k,m,v,x);case oa:return m=m.get(null===v.key?n:v.key)||null,p(k,m,v,x);case za:var A=v._init;return t(m,k,n,A(v._payload),x)}if(wc(v)||Ia(v))return m=m.get(n)||null,q(k,m,v,x,null);if("function"===typeof v.then)return t(m,k,n,se(v),x);if(v.$$typeof===ta||v.$$typeof===ua)return t(m,k,n,Ce(k,v,x),x);ue(k,v)}return null}function z(m,k,n,v){for(var x=null,A=null,y=k,H=k=0,ha=null;null!==y&&H<n.length;H++){y.index>H?(ha=y,y=null):ha=y.sibling;var I=r(m,y,n[H],v);if(null===
+I){null===y&&(y=ha);break}a&&y&&null===I.alternate&&b(m,y);k=f(I,k,H);null===A?x=I:A.sibling=I;A=I;y=ha}if(H===n.length)return c(m,y),K&&od(m,H),x;if(null===y){for(;H<n.length;H++)y=w(m,n[H],v),null!==y&&(k=f(y,k,H),null===A?x=y:A.sibling=y,A=y);K&&od(m,H);return x}for(y=d(m,y);H<n.length;H++)ha=t(y,m,H,n[H],v),null!==ha&&(a&&null!==ha.alternate&&y.delete(null===ha.key?H:ha.key),k=f(ha,k,H),null===A?x=ha:A.sibling=ha,A=ha);a&&y.forEach(function(Gb){return b(m,Gb)});K&&od(m,H);return x}function C(m,
+k,n,v){var x=Ia(n);if("function"!==typeof x)throw Error(u(150));n=x.call(n);if(null==n)throw Error(u(151));for(var A=x=null,y=k,H=k=0,ha=null,I=n.next();null!==y&&!I.done;H++,I=n.next()){y.index>H?(ha=y,y=null):ha=y.sibling;var Gb=r(m,y,I.value,v);if(null===Gb){null===y&&(y=ha);break}a&&y&&null===Gb.alternate&&b(m,y);k=f(Gb,k,H);null===A?x=Gb:A.sibling=Gb;A=Gb;y=ha}if(I.done)return c(m,y),K&&od(m,H),x;if(null===y){for(;!I.done;H++,I=n.next())I=w(m,I.value,v),null!==I&&(k=f(I,k,H),null===A?x=I:A.sibling=
+I,A=I);K&&od(m,H);return x}for(y=d(m,y);!I.done;H++,I=n.next())I=t(y,m,H,I.value,v),null!==I&&(a&&null!==I.alternate&&y.delete(null===I.key?H:I.key),k=f(I,k,H),null===A?x=I:A.sibling=I,A=I);a&&y.forEach(function(Qm){return b(m,Qm)});K&&od(m,H);return x}function V(m,k,n,v){"object"===typeof n&&null!==n&&n.type===pa&&null===n.key&&(n=n.props.children);if("object"===typeof n&&null!==n){switch(n.$$typeof){case na:a:{for(var x=n.key,A=k;null!==A;){if(A.key===x){x=n.type;if(x===pa){if(7===A.tag){c(m,A.sibling);
 k=e(A,n.props.children);k.return=m;m=k;break a}}else if(A.elementType===x||"object"===typeof x&&null!==x&&x.$$typeof===za&&ve(x)===A.type){c(m,A.sibling);k=e(A,n.props);k.ref=te(m,A,n);k.return=m;m=k;break a}c(m,A);break}else b(m,A);A=A.sibling}n.type===pa?(k=Be(n.props.children,m.mode,v,n.key),k.return=m,m=k):(v=ze(n.type,n.key,n.props,null,null,m.mode,v),v.ref=te(m,k,n),v.return=m,m=v)}return g(m);case oa:a:{for(A=n.key;null!==k;){if(k.key===A)if(4===k.tag&&k.stateNode.containerInfo===n.containerInfo&&
 k.stateNode.implementation===n.implementation){c(m,k.sibling);k=e(k,n.children||[]);k.return=m;m=k;break a}else{c(m,k);break}else b(m,k);k=k.sibling}k=Ae(n,m.mode,v);k.return=m;m=k}return g(m);case za:return A=n._init,R(m,k,A(n._payload),v)}if(wc(n))return z(m,k,n,v);if(Ia(n))return C(m,k,n,v);if("function"===typeof n.then)return V(m,k,se(n),v);if(n.$$typeof===ta||n.$$typeof===ua)return V(m,k,Ce(m,n,v),v);ue(m,n)}return"string"===typeof n&&""!==n||"number"===typeof n?(n=""+n,null!==k&&6===k.tag?(c(m,
 k.sibling),k=e(k,n),k.return=m,m=k):(c(m,k),k=ye(n,m.mode,v),k.return=m,m=k),g(m)):c(m,k)}function R(m,k,n,v){re=0;m=V(m,k,n,v);qe=null;return m}return R}var De=we(!0),Ee=we(!1),Fe=ma(null),Ge=ma(0);function He(a,b){a=Ie;E(Ge,a);E(Fe,b);Ie=a|b.baseLanes}function Je(){E(Ge,Ie);E(Fe,Fe.current)}function Ke(){Ie=Ge.current;D(Fe);D(Ge)}var Le=ma(null),Me=null;function Ne(a){var b=a.alternate;E(Oe,Oe.current&1);E(Le,a);null===Me&&(null===b||null!==Fe.current?Me=a:null!==b.memoizedState&&(Me=a))}
 function Pe(a){if(22===a.tag){if(E(Oe,Oe.current),E(Le,a),null===Me){var b=a.alternate;null!==b&&null!==b.memoizedState&&(Me=a)}}else Qe(a)}function Qe(){E(Oe,Oe.current);E(Le,Le.current)}function Re(a){D(Le);Me===a&&(Me=null);D(Oe)}var Oe=ma(0);
 function Se(a){for(var b=a;null!==b;){if(13===b.tag){var c=b.memoizedState;if(null!==c&&(c=c.dehydrated,null===c||"$?"===c.data||"$!"===c.data))return b}else if(19===b.tag&&void 0!==b.memoizedProps.revealOrder){if(0!==(b.flags&128))return b}else if(null!==b.child){b.child.return=b;b=b.child;continue}if(b===a)break;for(;null===b.sibling;){if(null===b.return||b.return===a)return null;b=b.return}b.sibling.return=b.return;b=b.sibling}return null}var Te=null,Ue=null,Ve=!1,We=!1,Xe=!1,Ye=0;
 function Ze(a){a!==Ue&&null===a.next&&(null===Ue?Te=Ue=a:Ue=Ue.next=a);We=!0;Ve||(Ve=!0,$e(af))}
-function bf(a){if(!Xe&&We){var b=null;Xe=!0;do{var c=!1;for(var d=Te;null!==d;){if(!a||0===d.tag){var e=M,f=ob(d,d===N?e:0);if(0!==(f&3))try{c=!0;e=d;if(0!==(L&6))throw Error(t(327));if(!cf()){var g=df(e,f);if(0!==e.tag&&2===g){var h=f,l=qb(e,h);0!==l&&(f=l,g=ef(e,h,l))}if(1===g)throw h=ff,gf(e,0),hf(e,f,0),Ze(e),h;6===g?hf(e,f,0):(e.finishedWork=e.current.alternate,e.finishedLanes=f,jf(e,kf,lf,mf))}Ze(e)}catch(p){null===b?b=[p]:b.push(p)}}d=d.next}}while(c);Xe=!1;if(null!==b){if(1<b.length){if("function"===
+function bf(a){if(!Xe&&We){var b=null;Xe=!0;do{var c=!1;for(var d=Te;null!==d;){if(!a||0===d.tag){var e=M,f=ob(d,d===N?e:0);if(0!==(f&3))try{c=!0;e=d;if(0!==(L&6))throw Error(u(327));if(!cf()){var g=df(e,f);if(0!==e.tag&&2===g){var h=f,l=qb(e,h);0!==l&&(f=l,g=ef(e,h,l))}if(1===g)throw h=ff,gf(e,0),hf(e,f,0),Ze(e),h;6===g?hf(e,f,0):(e.finishedWork=e.current.alternate,e.finishedLanes=f,jf(e,kf,lf,mf))}Ze(e)}catch(p){null===b?b=[p]:b.push(p)}}d=d.next}}while(c);Xe=!1;if(null!==b){if(1<b.length){if("function"===
 typeof AggregateError)throw new AggregateError(b);for(a=1;a<b.length;a++)$e(nf.bind(null,b[a]))}throw b[0];}}}function nf(a){throw a;}function af(){We=Ve=!1;for(var a=Ya(),b=null,c=Te;null!==c;){var d=c.next;if(0!==Ye&&of()){var e=c,f=Ye;e.pendingLanes|=2;e.entangledLanes|=2;e.entanglements[1]|=f}e=pf(c,a);0===e?(c.next=null,null===b?Te=d:b.next=d,null===d&&(Ue=b)):(b=c,0!==(e&3)&&(We=!0));c=d}Ye=0;bf(!1)}
 function pf(a,b){for(var c=a.suspendedLanes,d=a.pingedLanes,e=a.expirationTimes,f=a.pendingLanes&-62914561;0<f;){var g=31-ib(f),h=1<<g,l=e[g];if(-1===l){if(0===(h&c)||0!==(h&d))e[g]=pb(h,b)}else l<=b&&(a.expiredLanes|=h);f&=~h}b=N;c=M;c=ob(a,a===b?c:0);d=a.callbackNode;if(0===c||a===b&&2===O||null!==a.cancelPendingCommit)return null!==d&&null!==d&&Va(d),a.callbackNode=null,a.callbackPriority=0;if(0!==(c&3))return null!==d&&null!==d&&Va(d),a.callbackPriority=2,a.callbackNode=null,2;b=c&-c;if(b===a.callbackPriority)return b;
 null!==d&&Va(d);switch(zb(c)){case 2:c=$a;break;case 8:c=ab;break;case 32:c=bb;break;case 268435456:c=db;break;default:c=bb}d=qf.bind(null,a);c=Ua(c,d);a.callbackPriority=b;a.callbackNode=c;return b}function $e(a){rf(function(){0!==(L&6)?Ua($a,a):a()})}function sf(){if(0===Ye){var a=lb;lb<<=1;0===(lb&4194176)&&(lb=128);Ye=a}return Ye}var tf=null,uf=0,vf=0;
-function wf(a,b){if(null===tf){var c=tf=[];uf=0;vf=sf()}else c=tf;uf++;var d=xf(c),e="pending",f,g;a.then(function(h){e="fulfilled";f=null!==b?b:h;yf()},function(h){e="rejected";g=h;yf()});c.push(function(){switch(e){case "fulfilled":d.status="fulfilled";d.value=f;break;case "rejected":d.status="rejected";d.reason=g;break;default:throw Error(t(478));}});return d}function zf(a,b){var c=null!==b?b:a;if(null===tf)return c;a=tf;var d=xf(a);a.push(function(){d.status="fulfilled";d.value=c});return d}
-function yf(){if(null!==tf&&0===--uf){var a=tf;tf=null;for(var b=vf=0;b<a.length;b++)(0,a[b])()}}function xf(a){return{status:"pending",value:null,reason:null,then:function(b){a.push(b)}}}var Af=da.ReactCurrentDispatcher,Bf=da.ReactCurrentBatchConfig,Cf=0,P=null,Q=null,S=null,Df=!1,Ef=!1,Ff=!1,Gf=0,Hf=0,If=null,Jf=0;function T(){throw Error(t(321));}function Kf(a,b){if(null===b)return!1;for(var c=0;c<b.length&&c<a.length;c++)if(!ed(a[c],b[c]))return!1;return!0}
-function Lf(a,b,c,d,e,f){Cf=f;P=b;b.memoizedState=null;b.updateQueue=null;b.lanes=0;Af.current=null===a||null===a.memoizedState?Mf:Nf;Ff=!1;a=c(d,e);Ff=!1;Ef&&(a=Of(b,c,d,e));Pf();return a}function Pf(){Af.current=Qf;var a=null!==Q&&null!==Q.next;Cf=0;S=Q=P=null;Df=!1;Hf=0;If=null;if(a)throw Error(t(300));}function Of(a,b,c,d){P=a;var e=0;do{Ef&&(If=null);Hf=0;Ef=!1;if(25<=e)throw Error(t(301));e+=1;S=Q=null;a.updateQueue=null;Af.current=Rf;var f=b(c,d)}while(Ef);return f}
+function wf(a,b){if(null===tf){var c=tf=[];uf=0;vf=sf()}else c=tf;uf++;var d=xf(c),e="pending",f,g;a.then(function(h){e="fulfilled";f=null!==b?b:h;yf()},function(h){e="rejected";g=h;yf()});c.push(function(){switch(e){case "fulfilled":d.status="fulfilled";d.value=f;break;case "rejected":d.status="rejected";d.reason=g;break;default:throw Error(u(478));}});return d}function zf(a,b){var c=null!==b?b:a;if(null===tf)return c;a=tf;var d=xf(a);a.push(function(){d.status="fulfilled";d.value=c});return d}
+function yf(){if(null!==tf&&0===--uf){var a=tf;tf=null;for(var b=vf=0;b<a.length;b++)(0,a[b])()}}function xf(a){return{status:"pending",value:null,reason:null,then:function(b){a.push(b)}}}var Af=da.ReactCurrentDispatcher,Bf=da.ReactCurrentBatchConfig,Cf=0,P=null,Q=null,S=null,Df=!1,Ef=!1,Ff=!1,Gf=0,Hf=0,If=null,Jf=0;function T(){throw Error(u(321));}function Kf(a,b){if(null===b)return!1;for(var c=0;c<b.length&&c<a.length;c++)if(!ed(a[c],b[c]))return!1;return!0}
+function Lf(a,b,c,d,e,f){Cf=f;P=b;b.memoizedState=null;b.updateQueue=null;b.lanes=0;Af.current=null===a||null===a.memoizedState?Mf:Nf;Ff=!1;a=c(d,e);Ff=!1;Ef&&(a=Of(b,c,d,e));Pf();return a}function Pf(){Af.current=Qf;var a=null!==Q&&null!==Q.next;Cf=0;S=Q=P=null;Df=!1;Hf=0;If=null;if(a)throw Error(u(300));}function Of(a,b,c,d){P=a;var e=0;do{Ef&&(If=null);Hf=0;Ef=!1;if(25<=e)throw Error(u(301));e+=1;S=Q=null;a.updateQueue=null;Af.current=Rf;var f=b(c,d)}while(Ef);return f}
 function Sf(){var a=Af.current.useState()[0];return"function"===typeof a.then?Tf(a):a}function Uf(){var a=0!==Gf;Gf=0;return a}function Vf(a,b,c){b.updateQueue=a.updateQueue;b.flags&=-2053;a.lanes&=~c}function Wf(a){if(Df){for(a=a.memoizedState;null!==a;){var b=a.queue;null!==b&&(b.pending=null);a=a.next}Df=!1}Cf=0;S=Q=P=null;Ef=!1;Hf=Gf=0;If=null}function Xf(){var a={memoizedState:null,baseState:null,baseQueue:null,queue:null,next:null};null===S?P.memoizedState=S=a:S=S.next=a;return S}
-function Yf(){if(null===Q){var a=P.alternate;a=null!==a?a.memoizedState:null}else a=Q.next;var b=null===S?P.memoizedState:S.next;if(null!==b)S=b,Q=a;else{if(null===a){if(null===P.alternate)throw Error(t(467));throw Error(t(310));}Q=a;a={memoizedState:Q.memoizedState,baseState:Q.baseState,baseQueue:Q.baseQueue,queue:Q.queue,next:null};null===S?P.memoizedState=S=a:S=S.next=a}return S}var Zf;Zf=function(){return{lastEffect:null,events:null,stores:null,memoCache:null}};
-function Tf(a){var b=Hf;Hf+=1;null===If&&(If=[]);a=ne(If,a,b);null===P.alternate&&(null===S?null===P.memoizedState:null===S.next)&&(Af.current=Mf);return a}function $f(a){if(null!==a&&"object"===typeof a){if("function"===typeof a.then)return Tf(a);if(a.$$typeof===ta||a.$$typeof===ua)return ag(a)}throw Error(t(438,String(a)));}
+function Yf(){if(null===Q){var a=P.alternate;a=null!==a?a.memoizedState:null}else a=Q.next;var b=null===S?P.memoizedState:S.next;if(null!==b)S=b,Q=a;else{if(null===a){if(null===P.alternate)throw Error(u(467));throw Error(u(310));}Q=a;a={memoizedState:Q.memoizedState,baseState:Q.baseState,baseQueue:Q.baseQueue,queue:Q.queue,next:null};null===S?P.memoizedState=S=a:S=S.next=a}return S}var Zf;Zf=function(){return{lastEffect:null,events:null,stores:null,memoCache:null}};
+function Tf(a){var b=Hf;Hf+=1;null===If&&(If=[]);a=ne(If,a,b);null===P.alternate&&(null===S?null===P.memoizedState:null===S.next)&&(Af.current=Mf);return a}function $f(a){if(null!==a&&"object"===typeof a){if("function"===typeof a.then)return Tf(a);if(a.$$typeof===ta||a.$$typeof===ua)return ag(a)}throw Error(u(438,String(a)));}
 function bg(a){var b=null,c=P.updateQueue;null!==c&&(b=c.memoCache);if(null==b){var d=P.alternate;null!==d&&(d=d.updateQueue,null!==d&&(d=d.memoCache,null!=d&&(b={data:d.data.map(function(e){return e.slice()}),index:0})))}null==b&&(b={data:[],index:0});null===c&&(c=Zf(),P.updateQueue=c);c.memoCache=b;c=b.data[b.index];if(void 0===c)for(c=b.data[b.index]=Array(a),d=0;d<a;d++)c[d]=Fa;b.index++;return c}function cg(a,b){return"function"===typeof b?b(a):b}function dg(a){var b=Yf();return eg(b,Q,a)}
-function eg(a,b,c){var d=a.queue;if(null===d)throw Error(t(311));d.lastRenderedReducer=c;var e=a.baseQueue,f=d.pending;if(null!==f){if(null!==e){var g=e.next;e.next=f.next;f.next=g}b.baseQueue=e=f;d.pending=null}if(null!==e){b=e.next;f=a.baseState;var h=g=null,l=null,p=b;do{var q=p.lane&-536870913;if(q!==p.lane?(M&q)===q:(Cf&q)===q){q=p.revertLane;if(0===q)null!==l&&(l=l.next={lane:0,revertLane:0,action:p.action,hasEagerState:p.hasEagerState,eagerState:p.eagerState,next:null});else if((Cf&q)===q){p=
+function eg(a,b,c){var d=a.queue;if(null===d)throw Error(u(311));d.lastRenderedReducer=c;var e=a.baseQueue,f=d.pending;if(null!==f){if(null!==e){var g=e.next;e.next=f.next;f.next=g}b.baseQueue=e=f;d.pending=null}if(null!==e){b=e.next;f=a.baseState;var h=g=null,l=null,p=b;do{var q=p.lane&-536870913;if(q!==p.lane?(M&q)===q:(Cf&q)===q){q=p.revertLane;if(0===q)null!==l&&(l=l.next={lane:0,revertLane:0,action:p.action,hasEagerState:p.hasEagerState,eagerState:p.eagerState,next:null});else if((Cf&q)===q){p=
 p.next;continue}else{var w={lane:0,revertLane:p.revertLane,action:p.action,hasEagerState:p.hasEagerState,eagerState:p.eagerState,next:null};null===l?(h=l=w,g=f):l=l.next=w;P.lanes|=q;ee|=q}q=p.action;Ff&&c(f,q);f=p.hasEagerState?p.eagerState:c(f,q)}else w={lane:q,revertLane:p.revertLane,action:p.action,hasEagerState:p.hasEagerState,eagerState:p.eagerState,next:null},null===l?(h=l=w,g=f):l=l.next=w,P.lanes|=q,ee|=q;p=p.next}while(null!==p&&p!==b);null===l?g=f:l.next=h;ed(f,a.memoizedState)||(fg=!0);
-a.memoizedState=f;a.baseState=g;a.baseQueue=l;d.lastRenderedState=f}null===e&&(d.lanes=0);return[a.memoizedState,d.dispatch]}function gg(a){var b=Yf(),c=b.queue;if(null===c)throw Error(t(311));c.lastRenderedReducer=a;var d=c.dispatch,e=c.pending,f=b.memoizedState;if(null!==e){c.pending=null;var g=e=e.next;do f=a(f,g.action),g=g.next;while(g!==e);ed(f,b.memoizedState)||(fg=!0);b.memoizedState=f;null===b.baseQueue&&(b.baseState=f);c.lastRenderedState=f}return[f,d]}
-function hg(a,b,c){var d=P,e=Yf(),f=K;if(f){if(void 0===c)throw Error(t(407));c=c()}else c=b();var g=!ed((Q||e).memoizedState,c);g&&(e.memoizedState=c,fg=!0);e=e.queue;ig(jg.bind(null,d,e,a),[a]);if(e.getSnapshot!==b||g||null!==S&&S.memoizedState.tag&1){d.flags|=2048;kg(9,lg.bind(null,d,e,c,b),{destroy:void 0},null);if(null===N)throw Error(t(349));f||0!==(Cf&60)||mg(d,b,c)}return c}
+a.memoizedState=f;a.baseState=g;a.baseQueue=l;d.lastRenderedState=f}null===e&&(d.lanes=0);return[a.memoizedState,d.dispatch]}function gg(a){var b=Yf(),c=b.queue;if(null===c)throw Error(u(311));c.lastRenderedReducer=a;var d=c.dispatch,e=c.pending,f=b.memoizedState;if(null!==e){c.pending=null;var g=e=e.next;do f=a(f,g.action),g=g.next;while(g!==e);ed(f,b.memoizedState)||(fg=!0);b.memoizedState=f;null===b.baseQueue&&(b.baseState=f);c.lastRenderedState=f}return[f,d]}
+function hg(a,b,c){var d=P,e=Yf(),f=K;if(f){if(void 0===c)throw Error(u(407));c=c()}else c=b();var g=!ed((Q||e).memoizedState,c);g&&(e.memoizedState=c,fg=!0);e=e.queue;ig(jg.bind(null,d,e,a),[a]);if(e.getSnapshot!==b||g||null!==S&&S.memoizedState.tag&1){d.flags|=2048;kg(9,lg.bind(null,d,e,c,b),{destroy:void 0},null);if(null===N)throw Error(u(349));f||0!==(Cf&60)||mg(d,b,c)}return c}
 function mg(a,b,c){a.flags|=16384;a={getSnapshot:b,value:c};b=P.updateQueue;null===b?(b=Zf(),P.updateQueue=b,b.stores=[a]):(c=b.stores,null===c?b.stores=[a]:c.push(a))}function lg(a,b,c,d){b.value=c;b.getSnapshot=d;ng(b)&&og(a)}function jg(a,b,c){return c(function(){ng(b)&&og(a)})}function ng(a){var b=a.getSnapshot;a=a.value;try{var c=b();return!ed(a,c)}catch(d){return!0}}function og(a){var b=Ud(a,2);null!==b&&pg(b,a,2)}
-function qg(a){var b=Xf();"function"===typeof a&&(a=a());b.memoizedState=b.baseState=a;b.queue={pending:null,lanes:0,dispatch:null,lastRenderedReducer:cg,lastRenderedState:a};return b}function rg(a,b,c,d){a.baseState=c;return eg(a,Q,"function"===typeof d?d:cg)}function sg(a,b,c,d){if(tg(a))throw Error(t(485));a=b.pending;null===a?(a={payload:d,next:null},a.next=b.pending=a,ug(b,c,d)):b.pending=a.next={payload:d,next:a.next}}
+function qg(a){var b=Xf();"function"===typeof a&&(a=a());b.memoizedState=b.baseState=a;b.queue={pending:null,lanes:0,dispatch:null,lastRenderedReducer:cg,lastRenderedState:a};return b}function rg(a,b,c,d){a.baseState=c;return eg(a,Q,"function"===typeof d?d:cg)}function sg(a,b,c,d){if(tg(a))throw Error(u(485));a=b.pending;null===a?(a={payload:d,next:null},a.next=b.pending=a,ug(b,c,d)):b.pending=a.next={payload:d,next:a.next}}
 function ug(a,b,c){var d=a.action,e=a.state,f=Bf.transition;Bf.transition={};try{var g=d(e,c);if(null!==g&&"object"===typeof g&&"function"===typeof g.then){g.then(function(p){a.state=p;vg(a,b)},function(){return vg(a,b)});var h=wf(g,null);b(h)}else{var l=zf(g,null);b(l);a.state=g;vg(a,b)}}catch(p){b({then:function(){},status:"rejected",reason:p}),vg(a,b)}finally{Bf.transition=f}}
 function vg(a,b){var c=a.pending;if(null!==c){var d=c.next;d===c?a.pending=null:(d=d.next,c.next=d,ug(a,b,d.payload))}}function wg(a,b){return b}function xg(a,b,c){a=eg(a,b,wg)[0];a="object"===typeof a&&null!==a&&"function"===typeof a.then?Tf(a):a;b=Yf();var d=b.queue,e=d.dispatch;c!==b.memoizedState&&(P.flags|=2048,kg(9,yg.bind(null,d,c),{destroy:void 0},null));return[a,e]}function yg(a,b){a.action=b}
 function kg(a,b,c,d){a={tag:a,create:b,inst:c,deps:d,next:null};b=P.updateQueue;null===b?(b=Zf(),P.updateQueue=b,b.lastEffect=a.next=a):(c=b.lastEffect,null===c?b.lastEffect=a.next=a:(d=c.next,c.next=a,a.next=d,b.lastEffect=a));return a}function zg(){return Yf().memoizedState}function Ag(a,b,c,d){var e=Xf();P.flags|=a;e.memoizedState=kg(1|b,c,{destroy:void 0},void 0===d?null:d)}
 function Bg(a,b,c,d){var e=Yf();d=void 0===d?null:d;var f=e.memoizedState.inst;null!==Q&&null!==d&&Kf(d,Q.memoizedState.deps)?e.memoizedState=kg(b,c,f,d):(P.flags|=a,e.memoizedState=kg(1|b,c,f,d))}function Cg(a,b){Ag(8390656,8,a,b)}function ig(a,b){Bg(2048,8,a,b)}function Dg(a){P.flags|=4;var b=P.updateQueue;if(null===b)b=Zf(),P.updateQueue=b,b.events=[a];else{var c=b.events;null===c?b.events=[a]:c.push(a)}}
-function Eg(a){var b=Yf().memoizedState;Dg({ref:b,nextImpl:a});return function(){if(0!==(L&2))throw Error(t(440));return b.impl.apply(void 0,arguments)}}function Fg(a,b){return Bg(4,2,a,b)}function Gg(a,b){return Bg(4,4,a,b)}function Hg(a,b){if("function"===typeof b)return a=a(),b(a),function(){b(null)};if(null!==b&&void 0!==b)return a=a(),b.current=a,function(){b.current=null}}function Ig(a,b,c){c=null!==c&&void 0!==c?c.concat([a]):null;Bg(4,4,Hg.bind(null,b,a),c)}function Jg(){}
+function Eg(a){var b=Yf().memoizedState;Dg({ref:b,nextImpl:a});return function(){if(0!==(L&2))throw Error(u(440));return b.impl.apply(void 0,arguments)}}function Fg(a,b){return Bg(4,2,a,b)}function Gg(a,b){return Bg(4,4,a,b)}function Hg(a,b){if("function"===typeof b)return a=a(),b(a),function(){b(null)};if(null!==b&&void 0!==b)return a=a(),b.current=a,function(){b.current=null}}function Ig(a,b,c){c=null!==c&&void 0!==c?c.concat([a]):null;Bg(4,4,Hg.bind(null,b,a),c)}function Jg(){}
 function Kg(a,b){var c=Yf();b=void 0===b?null:b;var d=c.memoizedState;if(null!==b&&Kf(b,d[1]))return d[0];c.memoizedState=[a,b];return a}function Lg(a,b){var c=Yf();b=void 0===b?null:b;var d=c.memoizedState;if(null!==b&&Kf(b,d[1]))return d[0];Ff&&a();a=a();c.memoizedState=[a,b];return a}function Mg(a,b,c){if(void 0===c||0!==(Cf&1073741824))return a.memoizedState=b;a.memoizedState=c;a=Ng();P.lanes|=a;ee|=a;return c}
 function Og(a,b,c,d){if(ed(c,b))return c;if(null!==Fe.current)return a=Mg(a,c,d),ed(a,b)||(fg=!0),a;if(0===(Cf&42))return fg=!0,a.memoizedState=c;a=Ng();P.lanes|=a;ee|=a;return b}function Pg(a,b,c,d,e){var f=F;F=0!==f&&8>f?f:8;var g=Bf.transition;Bf.transition={};Qg(a,!1,b,c);try{var h=e();if(null!==h&&"object"===typeof h&&"function"===typeof h.then){var l=wf(h,d);Rg(a,b,l)}else{var p=zf(h,d);Rg(a,b,p)}}catch(q){Rg(a,b,{then:function(){},status:"rejected",reason:q})}finally{F=f,Bf.transition=g}}
-function Sg(a,b,c,d){if(5!==a.tag)throw Error(t(476));if(null===a.memoizedState){var e={pending:null,lanes:0,dispatch:null,lastRenderedReducer:cg,lastRenderedState:fa};var f=e;e={memoizedState:fa,baseState:fa,baseQueue:null,queue:e,next:null};a.memoizedState=e;var g=a.alternate;null!==g&&(g.memoizedState=e)}else f=a.memoizedState.queue;Pg(a,f,b,fa,function(){return c(d)})}function Tg(){var a=ag(Na);return null!==a?a:fa}function Ug(){return Yf().memoizedState}
+function Sg(a,b,c,d){if(5!==a.tag)throw Error(u(476));if(null===a.memoizedState){var e={pending:null,lanes:0,dispatch:null,lastRenderedReducer:cg,lastRenderedState:fa};var f=e;e={memoizedState:fa,baseState:fa,baseQueue:null,queue:e,next:null};a.memoizedState=e;var g=a.alternate;null!==g&&(g.memoizedState=e)}else f=a.memoizedState.queue;Pg(a,f,b,fa,function(){return c(d)})}function Tg(){var a=ag(Na);return null!==a?a:fa}function Ug(){return Yf().memoizedState}
 function Vg(){return Yf().memoizedState}function Wg(a,b,c){for(var d=a.return;null!==d;){switch(d.tag){case 24:case 3:var e=Xg(d);a=$d(e);var f=ae(d,a,e);null!==f&&(pg(f,d,e),be(f,d,e));d=Yg();null!==b&&void 0!==b&&null!==f&&d.data.set(b,c);a.payload={cache:d};return}d=d.return}}function Zg(a,b,c){var d=Xg(a);c={lane:d,revertLane:0,action:c,hasEagerState:!1,eagerState:null,next:null};tg(a)?$g(b,c):(c=Sd(a,b,c,d),null!==c&&(pg(c,a,d),ah(c,b,d)))}
 function Rg(a,b,c){var d=Xg(a),e={lane:d,revertLane:0,action:c,hasEagerState:!1,eagerState:null,next:null};if(tg(a))$g(b,e);else{var f=a.alternate;if(0===a.lanes&&(null===f||0===f.lanes)&&(f=b.lastRenderedReducer,null!==f))try{var g=b.lastRenderedState,h=f(g,c);e.hasEagerState=!0;e.eagerState=h;if(ed(h,g)){Rd(a,b,e,0);null===N&&Pd();return}}catch(l){}finally{}c=Sd(a,b,e,d);null!==c&&(pg(c,a,d),ah(c,b,d))}}
-function Qg(a,b,c,d){d={lane:2,revertLane:sf(),action:d,hasEagerState:!1,eagerState:null,next:null};if(tg(a)){if(b)throw Error(t(479));}else b=Sd(a,c,d,2),null!==b&&pg(b,a,2)}function tg(a){var b=a.alternate;return a===P||null!==b&&b===P}function $g(a,b){Ef=Df=!0;var c=a.pending;null===c?b.next=b:(b.next=c.next,c.next=b);a.pending=b}function ah(a,b,c){if(0!==(c&4194176)){var d=b.lanes;d&=a.pendingLanes;c|=d;b.lanes=c;wb(a,c)}}
+function Qg(a,b,c,d){d={lane:2,revertLane:sf(),action:d,hasEagerState:!1,eagerState:null,next:null};if(tg(a)){if(b)throw Error(u(479));}else b=Sd(a,c,d,2),null!==b&&pg(b,a,2)}function tg(a){var b=a.alternate;return a===P||null!==b&&b===P}function $g(a,b){Ef=Df=!0;var c=a.pending;null===c?b.next=b:(b.next=c.next,c.next=b);a.pending=b}function ah(a,b,c){if(0!==(c&4194176)){var d=b.lanes;d&=a.pendingLanes;c|=d;b.lanes=c;wb(a,c)}}
 var Qf={readContext:ag,use:$f,useCallback:T,useContext:T,useEffect:T,useImperativeHandle:T,useInsertionEffect:T,useLayoutEffect:T,useMemo:T,useReducer:T,useRef:T,useState:T,useDebugValue:T,useDeferredValue:T,useTransition:T,useSyncExternalStore:T,useId:T};Qf.useCacheRefresh=T;Qf.useMemoCache=T;Qf.useEffectEvent=T;Qf.useHostTransitionStatus=T;Qf.useFormState=T;Qf.useOptimistic=T;
 var Mf={readContext:ag,use:$f,useCallback:function(a,b){Xf().memoizedState=[a,void 0===b?null:b];return a},useContext:ag,useEffect:Cg,useImperativeHandle:function(a,b,c){c=null!==c&&void 0!==c?c.concat([a]):null;Ag(4194308,4,Hg.bind(null,b,a),c)},useLayoutEffect:function(a,b){return Ag(4194308,4,a,b)},useInsertionEffect:function(a,b){Ag(4,2,a,b)},useMemo:function(a,b){var c=Xf();b=void 0===b?null:b;Ff&&a();a=a();c.memoizedState=[a,b];return a},useReducer:function(a,b,c){var d=Xf();b=void 0!==c?c(b):
 b;d.memoizedState=d.baseState=b;a={pending:null,lanes:0,dispatch:null,lastRenderedReducer:a,lastRenderedState:b};d.queue=a;a=a.dispatch=Zg.bind(null,P,a);return[d.memoizedState,a]},useRef:function(a){var b=Xf();a={current:a};return b.memoizedState=a},useState:function(a){a=qg(a);var b=a.queue,c=Rg.bind(null,P,b);b.dispatch=c;return[a.memoizedState,c]},useDebugValue:Jg,useDeferredValue:function(a,b){var c=Xf();return Mg(c,a,b)},useTransition:function(){var a=qg(!1);a=Pg.bind(null,P,a.queue,!0,!1);
-Xf().memoizedState=a;return[!1,a]},useSyncExternalStore:function(a,b,c){var d=P,e=Xf();if(K){if(void 0===c)throw Error(t(407));c=c()}else{c=b();if(null===N)throw Error(t(349));0!==(M&60)||mg(d,b,c)}e.memoizedState=c;var f={value:c,getSnapshot:b};e.queue=f;Cg(jg.bind(null,d,f,a),[a]);d.flags|=2048;kg(9,lg.bind(null,d,f,c,b),{destroy:void 0},null);return c},useId:function(){var a=Xf(),b=N.identifierPrefix;if(K){var c=nd;var d=md;c=(d&~(1<<32-ib(d)-1)).toString(32)+c;b=":"+b+"R"+c;c=Gf++;0<c&&(b+="H"+
-c.toString(32));b+=":"}else c=Jf++,b=":"+b+"r"+c.toString(32)+":";return a.memoizedState=b},useCacheRefresh:function(){return Xf().memoizedState=Wg.bind(null,P)}};Mf.useMemoCache=bg;Mf.useEffectEvent=function(a){var b=Xf(),c={impl:a};b.memoizedState=c;return function(){if(0!==(L&2))throw Error(t(440));return c.impl.apply(void 0,arguments)}};Mf.useHostTransitionStatus=Tg;
+Xf().memoizedState=a;return[!1,a]},useSyncExternalStore:function(a,b,c){var d=P,e=Xf();if(K){if(void 0===c)throw Error(u(407));c=c()}else{c=b();if(null===N)throw Error(u(349));0!==(M&60)||mg(d,b,c)}e.memoizedState=c;var f={value:c,getSnapshot:b};e.queue=f;Cg(jg.bind(null,d,f,a),[a]);d.flags|=2048;kg(9,lg.bind(null,d,f,c,b),{destroy:void 0},null);return c},useId:function(){var a=Xf(),b=N.identifierPrefix;if(K){var c=nd;var d=md;c=(d&~(1<<32-ib(d)-1)).toString(32)+c;b=":"+b+"R"+c;c=Gf++;0<c&&(b+="H"+
+c.toString(32));b+=":"}else c=Jf++,b=":"+b+"r"+c.toString(32)+":";return a.memoizedState=b},useCacheRefresh:function(){return Xf().memoizedState=Wg.bind(null,P)}};Mf.useMemoCache=bg;Mf.useEffectEvent=function(a){var b=Xf(),c={impl:a};b.memoizedState=c;return function(){if(0!==(L&2))throw Error(u(440));return c.impl.apply(void 0,arguments)}};Mf.useHostTransitionStatus=Tg;
 Mf.useFormState=function(a,b){if(K){var c=N.formState;if(null!==c){a:{if(K){if(J){b:{var d=J;for(var e=td;8!==d.nodeType;){if(!e){d=null;break b}d=Dd(d);if(null===d){d=null;break b}}e=d.data;d="F!"===e||"F"===e?d:null}if(d){J=Dd(d);d="F!"===d.data;break a}}Fd()}d=!1}d&&(b=c[0])}}c=Xf();c.memoizedState=c.baseState=b;d={pending:null,lanes:0,dispatch:null,lastRenderedReducer:wg,lastRenderedState:b};c.queue=d;c=Rg.bind(null,P,d);d.dispatch=c;d=Xf();e={state:b,dispatch:null,action:a,pending:null};d.queue=
 e;c=sg.bind(null,P,e,c);e.dispatch=c;d.memoizedState=a;return[b,c]};Mf.useOptimistic=function(a){var b=Xf();b.memoizedState=b.baseState=a;var c={pending:null,lanes:0,dispatch:null,lastRenderedReducer:null,lastRenderedState:null};b.queue=c;b=Qg.bind(null,P,!0,c);c.dispatch=b;return[a,b]};
 var Nf={readContext:ag,use:$f,useCallback:Kg,useContext:ag,useEffect:ig,useImperativeHandle:Ig,useInsertionEffect:Fg,useLayoutEffect:Gg,useMemo:Lg,useReducer:dg,useRef:zg,useState:function(){return dg(cg)},useDebugValue:Jg,useDeferredValue:function(a,b){var c=Yf();return Og(c,Q.memoizedState,a,b)},useTransition:function(){var a=dg(cg)[0],b=Yf().memoizedState;return["boolean"===typeof a?a:Tf(a),b]},useSyncExternalStore:hg,useId:Ug};Nf.useCacheRefresh=Vg;Nf.useMemoCache=bg;Nf.useEffectEvent=Eg;
@@ -150,8 +149,8 @@ function jh(a,b,c){return{value:a,source:null,stack:null!=c?c:null,digest:null!=
 function oh(a,b,c){c=$d(c);c.tag=3;var d=a.type.getDerivedStateFromError;if("function"===typeof d){var e=b.value;c.payload=function(){return d(e)};c.callback=function(){kh(a,b)}}var f=a.stateNode;null!==f&&"function"===typeof f.componentDidCatch&&(c.callback=function(){kh(a,b);"function"!==typeof d&&(null===ph?ph=new Set([this]):ph.add(this));var g=b.stack;this.componentDidCatch(b.value,{componentStack:null!==g?g:""})});return c}
 function qh(a){var b=a.tag;0!==(a.mode&1)||0!==b&&11!==b&&15!==b||((b=a.alternate)?(a.updateQueue=b.updateQueue,a.memoizedState=b.memoizedState,a.lanes=b.lanes):(a.updateQueue=null,a.memoizedState=null))}function rh(a,b,c,d,e){if(0===(a.mode&1))return a===b?a.flags|=65536:(a.flags|=128,c.flags|=131072,c.flags&=-52805,1===c.tag&&(null===c.alternate?c.tag=17:(b=$d(2),b.tag=2,ae(c,b,2))),c.lanes|=2),a;a.flags|=65536;a.lanes=e;return a}
 function sh(a,b,c,d,e){c.flags|=32768;if(null!==d&&"object"===typeof d&&(d.$$typeof===Ga&&(d={then:function(){}}),"function"===typeof d.then)){qh(c);var f=Le.current;if(null!==f){switch(f.tag){case 13:c.mode&1&&(null===Me?th():null===f.alternate&&0===uh&&(uh=3));f.flags&=-257;rh(f,b,c,a,e);d===ke?f.flags|=16384:(b=f.updateQueue,null===b?f.updateQueue=new Set([d]):b.add(d),f.mode&1&&vh(a,d,e));return;case 22:if(f.mode&1){f.flags|=65536;d===ke?f.flags|=16384:(b=f.updateQueue,null===b?(b={transitions:null,
-markerInstances:null,retryQueue:new Set([d])},f.updateQueue=b):(f=b.retryQueue,null===f?b.retryQueue=new Set([d]):f.add(d)),vh(a,d,e));return}}throw Error(t(435,f.tag));}if(1===a.tag){vh(a,d,e);th();return}d=Error(t(426))}if(K&&c.mode&1&&(f=Le.current,null!==f)){0===(f.flags&65536)&&(f.flags|=256);rh(f,b,c,a,e);Ld(ih(d,c));return}d=ih(d,c);wh(d);a=b;do{switch(a.tag){case 3:a.flags|=65536;e&=-e;a.lanes|=e;e=lh(a,d,e);ce(a,e);return;case 1:if(f=d,b=a.type,c=a.stateNode,0===(a.flags&128)&&("function"===
-typeof b.getDerivedStateFromError||null!==c&&"function"===typeof c.componentDidCatch&&(null===ph||!ph.has(c)))){a.flags|=65536;e&=-e;a.lanes|=e;e=oh(a,f,e);ce(a,e);return}}a=a.return}while(null!==a)}var xh=da.ReactCurrentOwner,yh=Error(t(461)),fg=!1;function zh(a,b,c,d){b.child=null===a?Ee(b,null,c,d):De(b,a.child,c,d)}function Ah(a,b,c,d,e){c=c.render;var f=b.ref;Bh(b,e);d=Lf(a,b,c,d,f,e);c=Uf();if(null!==a&&!fg)return Vf(a,b,e),Ch(a,b,e);K&&c&&qd(b);b.flags|=1;zh(a,b,d,e);return b.child}
+markerInstances:null,retryQueue:new Set([d])},f.updateQueue=b):(f=b.retryQueue,null===f?b.retryQueue=new Set([d]):f.add(d)),vh(a,d,e));return}}throw Error(u(435,f.tag));}if(1===a.tag){vh(a,d,e);th();return}d=Error(u(426))}if(K&&c.mode&1&&(f=Le.current,null!==f)){0===(f.flags&65536)&&(f.flags|=256);rh(f,b,c,a,e);Ld(ih(d,c));return}d=ih(d,c);wh(d);a=b;do{switch(a.tag){case 3:a.flags|=65536;e&=-e;a.lanes|=e;e=lh(a,d,e);ce(a,e);return;case 1:if(f=d,b=a.type,c=a.stateNode,0===(a.flags&128)&&("function"===
+typeof b.getDerivedStateFromError||null!==c&&"function"===typeof c.componentDidCatch&&(null===ph||!ph.has(c)))){a.flags|=65536;e&=-e;a.lanes|=e;e=oh(a,f,e);ce(a,e);return}}a=a.return}while(null!==a)}var xh=da.ReactCurrentOwner,yh=Error(u(461)),fg=!1;function zh(a,b,c,d){b.child=null===a?Ee(b,null,c,d):De(b,a.child,c,d)}function Ah(a,b,c,d,e){c=c.render;var f=b.ref;Bh(b,e);d=Lf(a,b,c,d,f,e);c=Uf();if(null!==a&&!fg)return Vf(a,b,e),Ch(a,b,e);K&&c&&qd(b);b.flags|=1;zh(a,b,d,e);return b.child}
 function Dh(a,b,c,d,e){if(null===a){var f=c.type;if("function"===typeof f&&!Eh(f)&&void 0===f.defaultProps&&null===c.compare&&void 0===c.defaultProps)return b.tag=15,b.type=f,Fh(a,b,f,d,e);a=ze(c.type,null,d,null,b,b.mode,e);a.ref=b.ref;a.return=b;return b.child=a}f=a.child;if(0===(a.lanes&e)){var g=f.memoizedProps;c=c.compare;c=null!==c?c:he;if(c(g,d)&&a.ref===b.ref)return Ch(a,b,e)}b.flags|=1;a=xe(f,d);a.ref=b.ref;a.return=b;return b.child=a}
 function Fh(a,b,c,d,e){if(null!==a){var f=a.memoizedProps;if(he(f,d)&&a.ref===b.ref)if(fg=!1,b.pendingProps=d=f,0!==(a.lanes&e))0!==(a.flags&131072)&&(fg=!0);else return b.lanes=a.lanes,Ch(a,b,e)}return Gh(a,b,c,d,e)}
 function Hh(a,b,c){var d=b.pendingProps,e=d.children,f=0!==(b.stateNode._pendingVisibility&2),g=null!==a?a.memoizedState:null;Ih(a,b);if("hidden"===d.mode||f){if(0!==(b.flags&128)){c=null!==g?g.baseLanes|c:c;if(null!==a){d=b.child=a.child;for(e=0;null!==d;)e=e|d.lanes|d.childLanes,d=d.sibling;b.childLanes=e&~c}else b.childLanes=0,b.child=null;return Jh(a,b,c)}if(0===(b.mode&1))b.memoizedState={baseLanes:0,cachePool:null},null!==a&&Kh(b,null),Je(),Pe(b);else if(0!==(c&536870912))b.memoizedState={baseLanes:0,
@@ -159,8 +158,8 @@ cachePool:null},null!==a&&Kh(b,null!==g?g.cachePool:null),null!==g?He(b,g):Je(),
 function Ih(a,b){var c=b.ref;if(null===a&&null!==c||null!==a&&a.ref!==c)b.flags|=512,b.flags|=2097152}function Gh(a,b,c,d,e){var f=Yc(c)?Wc:Uc.current;f=Xc(b,f);Bh(b,e);c=Lf(a,b,c,d,f,e);d=Uf();if(null!==a&&!fg)return Vf(a,b,e),Ch(a,b,e);K&&d&&qd(b);b.flags|=1;zh(a,b,c,e);return b.child}function Nh(a,b,c,d,e,f){Bh(b,f);c=Of(b,d,c,e);Pf();d=Uf();if(null!==a&&!fg)return Vf(a,b,f),Ch(a,b,f);K&&d&&qd(b);b.flags|=1;zh(a,b,c,f);return b.child}
 function Oh(a,b,c,d,e){if(Yc(c)){var f=!0;bd(b)}else f=!1;Bh(b,e);if(null===b.stateNode)Ph(a,b),fh(b,c,d),hh(b,c,d,e),d=!0;else if(null===a){var g=b.stateNode,h=b.memoizedProps;g.props=h;var l=g.context,p=c.contextType;"object"===typeof p&&null!==p?p=ag(p):(p=Yc(c)?Wc:Uc.current,p=Xc(b,p));var q=c.getDerivedStateFromProps,w="function"===typeof q||"function"===typeof g.getSnapshotBeforeUpdate;w||"function"!==typeof g.UNSAFE_componentWillReceiveProps&&"function"!==typeof g.componentWillReceiveProps||
 (h!==d||l!==p)&&gh(b,g,d,p);Xd=!1;var r=b.memoizedState;g.state=r;de(b,d,g,e);l=b.memoizedState;h!==d||r!==l||Vc.current||Xd?("function"===typeof q&&(ch(b,c,q,d),l=b.memoizedState),(h=Xd||eh(b,c,h,d,r,l,p))?(w||"function"!==typeof g.UNSAFE_componentWillMount&&"function"!==typeof g.componentWillMount||("function"===typeof g.componentWillMount&&g.componentWillMount(),"function"===typeof g.UNSAFE_componentWillMount&&g.UNSAFE_componentWillMount()),"function"===typeof g.componentDidMount&&(b.flags|=4194308)):
-("function"===typeof g.componentDidMount&&(b.flags|=4194308),b.memoizedProps=d,b.memoizedState=l),g.props=d,g.state=l,g.context=p,d=h):("function"===typeof g.componentDidMount&&(b.flags|=4194308),d=!1)}else{g=b.stateNode;Zd(a,b);h=b.memoizedProps;p=b.type===b.elementType?h:bh(b.type,h);g.props=p;w=b.pendingProps;r=g.context;l=c.contextType;"object"===typeof l&&null!==l?l=ag(l):(l=Yc(c)?Wc:Uc.current,l=Xc(b,l));var u=c.getDerivedStateFromProps;(q="function"===typeof u||"function"===typeof g.getSnapshotBeforeUpdate)||
-"function"!==typeof g.UNSAFE_componentWillReceiveProps&&"function"!==typeof g.componentWillReceiveProps||(h!==w||r!==l)&&gh(b,g,d,l);Xd=!1;r=b.memoizedState;g.state=r;de(b,d,g,e);var z=b.memoizedState;h!==w||r!==z||Vc.current||Xd?("function"===typeof u&&(ch(b,c,u,d),z=b.memoizedState),(p=Xd||eh(b,c,p,d,r,z,l)||!1)?(q||"function"!==typeof g.UNSAFE_componentWillUpdate&&"function"!==typeof g.componentWillUpdate||("function"===typeof g.componentWillUpdate&&g.componentWillUpdate(d,z,l),"function"===typeof g.UNSAFE_componentWillUpdate&&
+("function"===typeof g.componentDidMount&&(b.flags|=4194308),b.memoizedProps=d,b.memoizedState=l),g.props=d,g.state=l,g.context=p,d=h):("function"===typeof g.componentDidMount&&(b.flags|=4194308),d=!1)}else{g=b.stateNode;Zd(a,b);h=b.memoizedProps;p=b.type===b.elementType?h:bh(b.type,h);g.props=p;w=b.pendingProps;r=g.context;l=c.contextType;"object"===typeof l&&null!==l?l=ag(l):(l=Yc(c)?Wc:Uc.current,l=Xc(b,l));var t=c.getDerivedStateFromProps;(q="function"===typeof t||"function"===typeof g.getSnapshotBeforeUpdate)||
+"function"!==typeof g.UNSAFE_componentWillReceiveProps&&"function"!==typeof g.componentWillReceiveProps||(h!==w||r!==l)&&gh(b,g,d,l);Xd=!1;r=b.memoizedState;g.state=r;de(b,d,g,e);var z=b.memoizedState;h!==w||r!==z||Vc.current||Xd?("function"===typeof t&&(ch(b,c,t,d),z=b.memoizedState),(p=Xd||eh(b,c,p,d,r,z,l)||!1)?(q||"function"!==typeof g.UNSAFE_componentWillUpdate&&"function"!==typeof g.componentWillUpdate||("function"===typeof g.componentWillUpdate&&g.componentWillUpdate(d,z,l),"function"===typeof g.UNSAFE_componentWillUpdate&&
 g.UNSAFE_componentWillUpdate(d,z,l)),"function"===typeof g.componentDidUpdate&&(b.flags|=4),"function"===typeof g.getSnapshotBeforeUpdate&&(b.flags|=1024)):("function"!==typeof g.componentDidUpdate||h===a.memoizedProps&&r===a.memoizedState||(b.flags|=4),"function"!==typeof g.getSnapshotBeforeUpdate||h===a.memoizedProps&&r===a.memoizedState||(b.flags|=1024),b.memoizedProps=d,b.memoizedState=z),g.props=d,g.state=z,g.context=l,d=p):("function"!==typeof g.componentDidUpdate||h===a.memoizedProps&&r===
 a.memoizedState||(b.flags|=4),"function"!==typeof g.getSnapshotBeforeUpdate||h===a.memoizedProps&&r===a.memoizedState||(b.flags|=1024),d=!1)}return Qh(a,b,c,d,f,e)}
 function Qh(a,b,c,d,e,f){Ih(a,b);var g=0!==(b.flags&128);if(!d&&!g)return e&&cd(b,c,!1),Ch(a,b,f);d=b.stateNode;xh.current=b;var h=g&&"function"!==typeof c.getDerivedStateFromError?null:d.render();b.flags|=1;null!==a&&g?(b.child=De(b,a.child,null,f),b.child=De(b,null,h,f)):zh(a,b,h,f);b.memoizedState=d.state;e&&cd(b,c,!0);return b.child}function Rh(a){var b=a.stateNode;b.pendingContext?$c(a,b.pendingContext,b.pendingContext!==b.context):b.context&&$c(a,b.context,!1);Oa(a,b.containerInfo)}
@@ -170,45 +169,45 @@ a=Xh(b,a,f,c),b.child.memoizedState=Uh(c),b.memoizedState=Th,a;if("number"===typ
 l),d.subtreeFlags=g.subtreeFlags&31457280);null!==h?e=xe(h,e):(e=Be(e,f,c,null),e.flags|=2);e.return=b;d.return=b;d.sibling=e;b.child=d;d=e;e=b.child;f=a.child.memoizedState;null===f?f=Uh(c):(g=f.cachePool,null!==g?(h=Mh._currentValue,g=g.parent!==h?{parent:h,pool:h}:g):g=Vh(),f={baseLanes:f.baseLanes|c,cachePool:g});e.memoizedState=f;e.childLanes=a.childLanes&~c;b.memoizedState=Th;return d}Ne(b);e=a.child;a=e.sibling;d=xe(e,{mode:"visible",children:d.children});0===(b.mode&1)&&(d.lanes=c);d.return=
 b;d.sibling=null;null!==a&&(c=b.deletions,null===c?(b.deletions=[a],b.flags|=16):c.push(a));b.child=d;b.memoizedState=null;return d}function Yh(a,b){b=$h({mode:"visible",children:b},a.mode,0,null);b.return=a;return a.child=b}function Xh(a,b,c,d){var e=a.mode,f=a.child;b={mode:"hidden",children:b};0===(e&1)&&null!==f?(f.childLanes=0,f.pendingProps=b):f=$h(b,e,0,null);c=Be(c,e,d,null);f.return=a;c.return=a;f.sibling=c;a.child=f;return c}
 function ai(a,b,c,d){null!==d&&Ld(d);De(b,a.child,null,c);a=Yh(b,b.pendingProps.children);a.flags|=2;b.memoizedState=null;return a}
-function Zh(a,b,c,d,e,f,g){if(c){if(b.flags&256)return Ne(b),b.flags&=-257,e=jh(Error(t(422))),ai(a,b,g,e);if(null!==b.memoizedState)return Qe(b),b.child=a.child,b.flags|=128,null;Qe(b);e=d.fallback;f=b.mode;d=$h({mode:"visible",children:d.children},f,0,null);e=Be(e,f,g,null);e.flags|=2;d.return=b;e.return=b;d.sibling=e;b.child=d;0!==(b.mode&1)&&De(b,a.child,null,g);b.child.memoizedState=Uh(g);b.memoizedState=Th;return e}Ne(b);if(0===(b.mode&1))return ai(a,b,g,null);if("$!"===e.data){e=e.nextSibling&&
-e.nextSibling.dataset;if(e)var h=e.dgst;e=h;f=null;"POSTPONE"!==e&&(f=Error(t(419)),f.digest=e,f=jh(f,e,void 0));return ai(a,b,g,f)}h=0!==(g&a.childLanes);if(fg||h){d=N;if(null!==d){h=g&-g;if(0!==(h&42))h=1;else switch(h){case 2:h=1;break;case 8:h=4;break;case 32:h=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:h=64;break;
+function Zh(a,b,c,d,e,f,g){if(c){if(b.flags&256)return Ne(b),b.flags&=-257,e=jh(Error(u(422))),ai(a,b,g,e);if(null!==b.memoizedState)return Qe(b),b.child=a.child,b.flags|=128,null;Qe(b);e=d.fallback;f=b.mode;d=$h({mode:"visible",children:d.children},f,0,null);e=Be(e,f,g,null);e.flags|=2;d.return=b;e.return=b;d.sibling=e;b.child=d;0!==(b.mode&1)&&De(b,a.child,null,g);b.child.memoizedState=Uh(g);b.memoizedState=Th;return e}Ne(b);if(0===(b.mode&1))return ai(a,b,g,null);if("$!"===e.data){e=e.nextSibling&&
+e.nextSibling.dataset;if(e)var h=e.dgst;e=h;f=null;"POSTPONE"!==e&&(f=Error(u(419)),f.digest=e,f=jh(f,e,void 0));return ai(a,b,g,f)}h=0!==(g&a.childLanes);if(fg||h){d=N;if(null!==d){h=g&-g;if(0!==(h&42))h=1;else switch(h){case 2:h=1;break;case 8:h=4;break;case 32:h=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:h=64;break;
 case 268435456:h=134217728;break;default:h=0}h=0!==(h&(d.suspendedLanes|g))?0:h;if(0!==h&&h!==f.retryLane)throw f.retryLane=h,Ud(a,h),pg(d,a,h),yh;}"$?"!==e.data&&th();return ai(a,b,g,null)}if("$?"===e.data)return b.flags|=128,b.child=a.child,b=bi.bind(null,a),e._reactRetry=b,null;a=f.treeContext;J=zd(e.nextSibling);G=b;K=!0;sd=null;td=!1;null!==a&&(jd[kd++]=md,jd[kd++]=nd,jd[kd++]=ld,md=a.id,nd=a.overflow,ld=b);b=Yh(b,d.children);b.flags|=4096;return b}
 function ci(a,b,c){a.lanes|=b;var d=a.alternate;null!==d&&(d.lanes|=b);di(a.return,b,c)}function ei(a,b,c,d,e){var f=a.memoizedState;null===f?a.memoizedState={isBackwards:b,rendering:null,renderingStartTime:0,last:d,tail:c,tailMode:e}:(f.isBackwards=b,f.rendering=null,f.renderingStartTime=0,f.last=d,f.tail=c,f.tailMode=e)}
 function fi(a,b,c){var d=b.pendingProps,e=d.revealOrder,f=d.tail;zh(a,b,d.children,c);d=Oe.current;if(0!==(d&2))d=d&1|2,b.flags|=128;else{if(null!==a&&0!==(a.flags&128))a:for(a=b.child;null!==a;){if(13===a.tag)null!==a.memoizedState&&ci(a,c,b);else if(19===a.tag)ci(a,c,b);else if(null!==a.child){a.child.return=a;a=a.child;continue}if(a===b)break a;for(;null===a.sibling;){if(null===a.return||a.return===b)break a;a=a.return}a.sibling.return=a.return;a=a.sibling}d&=1}E(Oe,d);if(0===(b.mode&1))b.memoizedState=
 null;else switch(e){case "forwards":c=b.child;for(e=null;null!==c;)a=c.alternate,null!==a&&null===Se(a)&&(e=c),c=c.sibling;c=e;null===c?(e=b.child,b.child=null):(e=c.sibling,c.sibling=null);ei(b,!1,e,c,f);break;case "backwards":c=null;e=b.child;for(b.child=null;null!==e;){a=e.alternate;if(null!==a&&null===Se(a)){b.child=e;break}a=e.sibling;e.sibling=c;c=e;e=a}ei(b,!0,c,null,f);break;case "together":ei(b,!1,null,null,void 0);break;default:b.memoizedState=null}return b.child}
-function Ph(a,b){0===(b.mode&1)&&null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2)}function Ch(a,b,c){null!==a&&(b.dependencies=a.dependencies);ee|=b.lanes;if(0===(c&b.childLanes))return null;if(null!==a&&b.child!==a.child)throw Error(t(153));if(null!==b.child){a=b.child;c=xe(a,a.pendingProps);b.child=c;for(c.return=b;null!==a.sibling;)a=a.sibling,c=c.sibling=xe(a,a.pendingProps),c.return=b;c.sibling=null}return b.child}
+function Ph(a,b){0===(b.mode&1)&&null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2)}function Ch(a,b,c){null!==a&&(b.dependencies=a.dependencies);ee|=b.lanes;if(0===(c&b.childLanes))return null;if(null!==a&&b.child!==a.child)throw Error(u(153));if(null!==b.child){a=b.child;c=xe(a,a.pendingProps);b.child=c;for(c.return=b;null!==a.sibling;)a=a.sibling,c=c.sibling=xe(a,a.pendingProps),c.return=b;c.sibling=null}return b.child}
 function gi(a,b,c){switch(b.tag){case 3:Rh(b);hi(b,Mh,a.memoizedState.cache);Kd();break;case 27:case 5:Sa(b);break;case 1:Yc(b.type)&&bd(b);break;case 4:Oa(b,b.stateNode.containerInfo);break;case 10:hi(b,b.type._context,b.memoizedProps.value);break;case 13:var d=b.memoizedState;if(null!==d){if(null!==d.dehydrated)return Ne(b),b.flags|=128,null;if(0!==(c&b.child.childLanes))return Wh(a,b,c);Ne(b);a=Ch(a,b,c);return null!==a?a.sibling:null}Ne(b);break;case 19:d=0!==(c&b.childLanes);if(0!==(a.flags&
 128)){if(d)return fi(a,b,c);b.flags|=128}var e=b.memoizedState;null!==e&&(e.rendering=null,e.tail=null,e.lastEffect=null);E(Oe,Oe.current);if(d)break;else return null;case 22:case 23:return b.lanes=0,Hh(a,b,c);case 24:hi(b,Mh,a.memoizedState.cache)}return Ch(a,b,c)}var ii=ma(null),ji=null,ki=null,li=null;function mi(){li=ki=ji=null}function hi(a,b,c){E(ii,b._currentValue);b._currentValue=c}function ni(a){var b=ii.current;a._currentValue=b===Ea?a._defaultValue:b;D(ii)}
 function di(a,b,c){for(;null!==a;){var d=a.alternate;(a.childLanes&b)!==b?(a.childLanes|=b,null!==d&&(d.childLanes|=b)):null!==d&&(d.childLanes&b)!==b&&(d.childLanes|=b);if(a===c)break;a=a.return}}
 function oi(a,b,c){var d=a.child;null!==d&&(d.return=a);for(;null!==d;){var e=d.dependencies;if(null!==e){var f=d.child;for(var g=e.firstContext;null!==g;){if(g.context===b){if(1===d.tag){g=$d(c&-c);g.tag=2;var h=d.updateQueue;if(null!==h){h=h.shared;var l=h.pending;null===l?g.next=g:(g.next=l.next,l.next=g);h.pending=g}}d.lanes|=c;g=d.alternate;null!==g&&(g.lanes|=c);di(d.return,c,a);e.lanes|=c;break}g=g.next}}else if(10===d.tag)f=d.type===a.type?null:d.child;else if(18===d.tag){f=d.return;if(null===
-f)throw Error(t(341));f.lanes|=c;e=f.alternate;null!==e&&(e.lanes|=c);di(f,c,a);f=d.sibling}else f=d.child;if(null!==f)f.return=d;else for(f=d;null!==f;){if(f===a){f=null;break}d=f.sibling;if(null!==d){d.return=f.return;f=d;break}f=f.return}d=f}}function Bh(a,b){ji=a;li=ki=null;a=a.dependencies;null!==a&&null!==a.firstContext&&(0!==(a.lanes&b)&&(fg=!0),a.firstContext=null)}function ag(a){return pi(ji,a)}function Ce(a,b,c){null===ji&&Bh(a,c);return pi(a,b)}
-function pi(a,b){var c=b._currentValue;if(li!==b)if(b={context:b,memoizedValue:c,next:null},null===ki){if(null===a)throw Error(t(308));ki=b;a.dependencies={lanes:0,firstContext:b}}else ki=ki.next=b;return c}
+f)throw Error(u(341));f.lanes|=c;e=f.alternate;null!==e&&(e.lanes|=c);di(f,c,a);f=d.sibling}else f=d.child;if(null!==f)f.return=d;else for(f=d;null!==f;){if(f===a){f=null;break}d=f.sibling;if(null!==d){d.return=f.return;f=d;break}f=f.return}d=f}}function Bh(a,b){ji=a;li=ki=null;a=a.dependencies;null!==a&&null!==a.firstContext&&(0!==(a.lanes&b)&&(fg=!0),a.firstContext=null)}function ag(a){return pi(ji,a)}function Ce(a,b,c){null===ji&&Bh(a,c);return pi(a,b)}
+function pi(a,b){var c=b._currentValue;if(li!==b)if(b={context:b,memoizedValue:c,next:null},null===ki){if(null===a)throw Error(u(308));ki=b;a.dependencies={lanes:0,firstContext:b}}else ki=ki.next=b;return c}
 var qi="undefined"!==typeof AbortController?AbortController:function(){var a=[],b=this.signal={aborted:!1,addEventListener:function(c,d){a.push(d)}};this.abort=function(){b.aborted=!0;a.forEach(function(c){return c()})}},ri=ba.unstable_scheduleCallback,si=ba.unstable_NormalPriority,Mh={$$typeof:ta,Consumer:null,Provider:null,_currentValue:null,_currentValue2:null,_threadCount:0,_defaultValue:null,_globalName:null};function Yg(){return{controller:new qi,data:new Map,refCount:0}}
 function ti(a){a.refCount--;0===a.refCount&&ri(si,function(){a.controller.abort()})}var ui=da.ReactCurrentBatchConfig,vi=ma(null);function Lh(){var a=vi.current;return null!==a?a:N.pooledCache}function Kh(a,b){null===b?E(vi,vi.current):E(vi,b.pool)}function Vh(){var a=Lh();return null===a?null:{parent:Mh._currentValue,pool:a}}function wi(a){a.flags|=4}function xi(a){a.flags|=2097664}
 function yi(a,b){if("stylesheet"!==b.type||0!==(b.state.loading&4))a.flags&=-16777217;else if(a.flags|=16777216,0===(M&42)&&(b="stylesheet"===b.type&&0===(b.state.loading&3)?!1:!0,!b))if(zi())a.flags|=8192;else throw oe=ke,je;}function Ai(a,b){null!==b?a.flags|=4:a.flags&16384&&(b=22!==a.tag?rb():536870912,a.lanes|=b)}
 function Bi(a,b){if(!K)switch(a.tailMode){case "hidden":b=a.tail;for(var c=null;null!==b;)null!==b.alternate&&(c=b),b=b.sibling;null===c?a.tail=null:c.sibling=null;break;case "collapsed":c=a.tail;for(var d=null;null!==c;)null!==c.alternate&&(d=c),c=c.sibling;null===d?b||null===a.tail?a.tail=null:a.tail.sibling=null:d.sibling=null}}
 function U(a){var b=null!==a.alternate&&a.alternate.child===a.child,c=0,d=0;if(b)for(var e=a.child;null!==e;)c|=e.lanes|e.childLanes,d|=e.subtreeFlags&31457280,d|=e.flags&31457280,e.return=a,e=e.sibling;else for(e=a.child;null!==e;)c|=e.lanes|e.childLanes,d|=e.subtreeFlags,d|=e.flags,e.return=a,e=e.sibling;a.subtreeFlags|=d;a.childLanes=c;return b}
 function Ci(a,b,c){var d=b.pendingProps;rd(b);switch(b.tag){case 2:case 16:case 15:case 0:case 11:case 7:case 8:case 12:case 9:case 14:return U(b),null;case 1:return Yc(b.type)&&Zc(),U(b),null;case 3:c=b.stateNode;d=null;null!==a&&(d=a.memoizedState.cache);b.memoizedState.cache!==d&&(b.flags|=2048);ni(Mh);Ra();D(Vc);D(Uc);c.pendingContext&&(c.context=c.pendingContext,c.pendingContext=null);if(null===a||null===a.child)Hd(b)?wi(b):null===a||a.memoizedState.isDehydrated&&0===(b.flags&256)||(b.flags|=
-1024,null!==sd&&(Di(sd),sd=null));U(b);return null;case 26:c=b.memoizedState;if(null===a)wi(b),null!==b.ref&&xi(b),null!==c?(U(b),yi(b,c)):(U(b),b.flags&=-16777217);else{var e=a.memoizedState;c!==e&&wi(b);a.ref!==b.ref&&xi(b);null!==c?(U(b),c===e?b.flags&=-16777217:yi(b,c)):(a.memoizedProps!==d&&wi(b),U(b),b.flags&=-16777217)}return null;case 27:Ta(b);c=La.current;e=b.type;if(null!==a&&null!=b.stateNode)a.memoizedProps!==d&&wi(b),a.ref!==b.ref&&xi(b);else{if(!d){if(null===b.stateNode)throw Error(t(166));
-U(b);return null}a=Ja.current;Hd(b)?Ei(b.stateNode,b.type,b.memoizedProps,a,b):(a=Fi(e,d,c),b.stateNode=a,wi(b));null!==b.ref&&xi(b)}U(b);return null;case 5:Ta(b);c=b.type;if(null!==a&&null!=b.stateNode)a.memoizedProps!==d&&wi(b),a.ref!==b.ref&&xi(b);else{if(!d){if(null===b.stateNode)throw Error(t(166));U(b);return null}a=Ja.current;if(Hd(b))Ei(b.stateNode,b.type,b.memoizedProps,a,b);else{e=Gi(La.current);switch(a){case 1:a=e.createElementNS("http://www.w3.org/2000/svg",c);break;case 2:a=e.createElementNS("http://www.w3.org/1998/Math/MathML",
+1024,null!==sd&&(Di(sd),sd=null));U(b);return null;case 26:c=b.memoizedState;if(null===a)wi(b),null!==b.ref&&xi(b),null!==c?(U(b),yi(b,c)):(U(b),b.flags&=-16777217);else{var e=a.memoizedState;c!==e&&wi(b);a.ref!==b.ref&&xi(b);null!==c?(U(b),c===e?b.flags&=-16777217:yi(b,c)):(a.memoizedProps!==d&&wi(b),U(b),b.flags&=-16777217)}return null;case 27:Ta(b);c=La.current;e=b.type;if(null!==a&&null!=b.stateNode)a.memoizedProps!==d&&wi(b),a.ref!==b.ref&&xi(b);else{if(!d){if(null===b.stateNode)throw Error(u(166));
+U(b);return null}a=Ja.current;Hd(b)?Ei(b.stateNode,b.type,b.memoizedProps,a,b):(a=Fi(e,d,c),b.stateNode=a,wi(b));null!==b.ref&&xi(b)}U(b);return null;case 5:Ta(b);c=b.type;if(null!==a&&null!=b.stateNode)a.memoizedProps!==d&&wi(b),a.ref!==b.ref&&xi(b);else{if(!d){if(null===b.stateNode)throw Error(u(166));U(b);return null}a=Ja.current;if(Hd(b))Ei(b.stateNode,b.type,b.memoizedProps,a,b);else{e=Gi(La.current);switch(a){case 1:a=e.createElementNS("http://www.w3.org/2000/svg",c);break;case 2:a=e.createElementNS("http://www.w3.org/1998/Math/MathML",
 c);break;default:switch(c){case "svg":a=e.createElementNS("http://www.w3.org/2000/svg",c);break;case "math":a=e.createElementNS("http://www.w3.org/1998/Math/MathML",c);break;case "script":a=e.createElement("div");a.innerHTML="<script>\x3c/script>";a=a.removeChild(a.firstChild);break;case "select":a="string"===typeof d.is?e.createElement("select",{is:d.is}):e.createElement("select");d.multiple?a.multiple=!0:d.size&&(a.size=d.size);break;default:a="string"===typeof d.is?e.createElement(c,{is:d.is}):
 e.createElement(c)}}a[Cb]=b;a[Db]=d;a:for(e=b.child;null!==e;){if(5===e.tag||6===e.tag)a.appendChild(e.stateNode);else if(4!==e.tag&&27!==e.tag&&null!==e.child){e.child.return=e;e=e.child;continue}if(e===b)break a;for(;null===e.sibling;){if(null===e.return||e.return===b)break a;e=e.return}e.sibling.return=e.return;e=e.sibling}b.stateNode=a;a:switch(Hi(a,c,d),c){case "button":case "input":case "select":case "textarea":a=!!d.autoFocus;break a;case "img":a=!0;break a;default:a=!1}a&&wi(b)}null!==b.ref&&
-xi(b)}U(b);b.flags&=-16777217;return null;case 6:if(a&&null!=b.stateNode)a.memoizedProps!==d&&wi(b);else{if("string"!==typeof d&&null===b.stateNode)throw Error(t(166));a=La.current;if(Hd(b)){a:{a=b.stateNode;c=b.memoizedProps;a[Cb]=b;if(d=a.nodeValue!==c)if(e=G,null!==e)switch(e.tag){case 3:e=0!==(e.mode&1);Ii(a.nodeValue,c,e);if(e){a=!1;break a}break;case 27:case 5:var f=0!==(e.mode&1);!0!==e.memoizedProps.suppressHydrationWarning&&Ii(a.nodeValue,c,f);if(f){a=!1;break a}}a=d}a&&wi(b)}else a=Gi(a).createTextNode(d),
-a[Cb]=b,b.stateNode=a}U(b);return null;case 13:Re(b);d=b.memoizedState;if(null===a||null!==a.memoizedState&&null!==a.memoizedState.dehydrated){if(K&&null!==J&&0!==(b.mode&1)&&0===(b.flags&128))Jd(),Kd(),b.flags|=384,e=!1;else if(e=Hd(b),null!==d&&null!==d.dehydrated){if(null===a){if(!e)throw Error(t(318));e=b.memoizedState;e=null!==e?e.dehydrated:null;if(!e)throw Error(t(317));e[Cb]=b}else Kd(),0===(b.flags&128)&&(b.memoizedState=null),b.flags|=4;U(b);e=!1}else null!==sd&&(Di(sd),sd=null),e=!0;if(!e)return b.flags&
+xi(b)}U(b);b.flags&=-16777217;return null;case 6:if(a&&null!=b.stateNode)a.memoizedProps!==d&&wi(b);else{if("string"!==typeof d&&null===b.stateNode)throw Error(u(166));a=La.current;if(Hd(b)){a:{a=b.stateNode;c=b.memoizedProps;a[Cb]=b;if(d=a.nodeValue!==c)if(e=G,null!==e)switch(e.tag){case 3:e=0!==(e.mode&1);Ii(a.nodeValue,c,e);if(e){a=!1;break a}break;case 27:case 5:var f=0!==(e.mode&1);!0!==e.memoizedProps.suppressHydrationWarning&&Ii(a.nodeValue,c,f);if(f){a=!1;break a}}a=d}a&&wi(b)}else a=Gi(a).createTextNode(d),
+a[Cb]=b,b.stateNode=a}U(b);return null;case 13:Re(b);d=b.memoizedState;if(null===a||null!==a.memoizedState&&null!==a.memoizedState.dehydrated){if(K&&null!==J&&0!==(b.mode&1)&&0===(b.flags&128))Jd(),Kd(),b.flags|=384,e=!1;else if(e=Hd(b),null!==d&&null!==d.dehydrated){if(null===a){if(!e)throw Error(u(318));e=b.memoizedState;e=null!==e?e.dehydrated:null;if(!e)throw Error(u(317));e[Cb]=b}else Kd(),0===(b.flags&128)&&(b.memoizedState=null),b.flags|=4;U(b);e=!1}else null!==sd&&(Di(sd),sd=null),e=!0;if(!e)return b.flags&
 256?b:null}if(0!==(b.flags&128))return b.lanes=c,b;c=null!==d;a=null!==a&&null!==a.memoizedState;c&&(d=b.child,e=null,null!==d.alternate&&null!==d.alternate.memoizedState&&null!==d.alternate.memoizedState.cachePool&&(e=d.alternate.memoizedState.cachePool.pool),f=null,null!==d.memoizedState&&null!==d.memoizedState.cachePool&&(f=d.memoizedState.cachePool.pool),f!==e&&(d.flags|=2048));c!==a&&c&&(b.child.flags|=8192);Ai(b,b.updateQueue);U(b);return null;case 4:return Ra(),null===a&&Ji(b.stateNode.containerInfo),
 U(b),null;case 10:return ni(b.type._context),U(b),null;case 17:return Yc(b.type)&&Zc(),U(b),null;case 19:D(Oe);e=b.memoizedState;if(null===e)return U(b),null;d=0!==(b.flags&128);f=e.rendering;if(null===f)if(d)Bi(e,!1);else{if(0!==uh||null!==a&&0!==(a.flags&128))for(a=b.child;null!==a;){f=Se(a);if(null!==f){b.flags|=128;Bi(e,!1);a=f.updateQueue;b.updateQueue=a;Ai(b,a);b.subtreeFlags=0;a=c;for(c=b.child;null!==c;)Ki(c,a),c=c.sibling;E(Oe,Oe.current&1|2);return b.child}a=a.sibling}null!==e.tail&&Ya()>
 Li&&(b.flags|=128,d=!0,Bi(e,!1),b.lanes=4194304)}else{if(!d)if(a=Se(f),null!==a){if(b.flags|=128,d=!0,a=a.updateQueue,b.updateQueue=a,Ai(b,a),Bi(e,!0),null===e.tail&&"hidden"===e.tailMode&&!f.alternate&&!K)return U(b),null}else 2*Ya()-e.renderingStartTime>Li&&536870912!==c&&(b.flags|=128,d=!0,Bi(e,!1),b.lanes=4194304);e.isBackwards?(f.sibling=b.child,b.child=f):(a=e.last,null!==a?a.sibling=f:b.child=f,e.last=f)}if(null!==e.tail)return b=e.tail,e.rendering=b,e.tail=b.sibling,e.renderingStartTime=Ya(),
 b.sibling=null,a=Oe.current,E(Oe,d?a&1|2:a&1),b;U(b);return null;case 22:case 23:return Re(b),Ke(),d=null!==b.memoizedState,null!==a?null!==a.memoizedState!==d&&(b.flags|=8192):d&&(b.flags|=8192),d&&0!==(b.mode&1)?0!==(c&536870912)&&0===(b.flags&128)&&(U(b),b.subtreeFlags&6&&(b.flags|=8192)):U(b),c=b.updateQueue,null!==c&&Ai(b,c.retryQueue),c=null,null!==a&&null!==a.memoizedState&&null!==a.memoizedState.cachePool&&(c=a.memoizedState.cachePool.pool),d=null,null!==b.memoizedState&&null!==b.memoizedState.cachePool&&
-(d=b.memoizedState.cachePool.pool),d!==c&&(b.flags|=2048),null!==a&&D(vi),null;case 24:return c=null,null!==a&&(c=a.memoizedState.cache),b.memoizedState.cache!==c&&(b.flags|=2048),ni(Mh),U(b),null;case 25:return null}throw Error(t(156,b.tag));}
-function Mi(a,b){rd(b);switch(b.tag){case 1:return Yc(b.type)&&Zc(),a=b.flags,a&65536?(b.flags=a&-65537|128,b):null;case 3:return ni(Mh),Ra(),D(Vc),D(Uc),a=b.flags,0!==(a&65536)&&0===(a&128)?(b.flags=a&-65537|128,b):null;case 26:case 27:case 5:return Ta(b),null;case 13:Re(b);a=b.memoizedState;if(null!==a&&null!==a.dehydrated){if(null===b.alternate)throw Error(t(340));Kd()}a=b.flags;return a&65536?(b.flags=a&-65537|128,b):null;case 19:return D(Oe),null;case 4:return Ra(),null;case 10:return ni(b.type._context),
+(d=b.memoizedState.cachePool.pool),d!==c&&(b.flags|=2048),null!==a&&D(vi),null;case 24:return c=null,null!==a&&(c=a.memoizedState.cache),b.memoizedState.cache!==c&&(b.flags|=2048),ni(Mh),U(b),null;case 25:return null}throw Error(u(156,b.tag));}
+function Mi(a,b){rd(b);switch(b.tag){case 1:return Yc(b.type)&&Zc(),a=b.flags,a&65536?(b.flags=a&-65537|128,b):null;case 3:return ni(Mh),Ra(),D(Vc),D(Uc),a=b.flags,0!==(a&65536)&&0===(a&128)?(b.flags=a&-65537|128,b):null;case 26:case 27:case 5:return Ta(b),null;case 13:Re(b);a=b.memoizedState;if(null!==a&&null!==a.dehydrated){if(null===b.alternate)throw Error(u(340));Kd()}a=b.flags;return a&65536?(b.flags=a&-65537|128,b):null;case 19:return D(Oe),null;case 4:return Ra(),null;case 10:return ni(b.type._context),
 null;case 22:case 23:return Re(b),Ke(),null!==a&&D(vi),a=b.flags,a&65536?(b.flags=a&-65537|128,b):null;case 24:return ni(Mh),null;case 25:return null;default:return null}}
 function Ni(a,b){rd(b);switch(b.tag){case 1:a=b.type.childContextTypes;null!==a&&void 0!==a&&Zc();break;case 3:ni(Mh);Ra();D(Vc);D(Uc);break;case 26:case 27:case 5:Ta(b);break;case 4:Ra();break;case 13:Re(b);break;case 19:D(Oe);break;case 10:ni(b.type._context);break;case 22:case 23:Re(b);Ke();null!==a&&D(vi);break;case 24:ni(Mh)}}function Oi(a,b,c){var d=Array.prototype.slice.call(arguments,3);try{b.apply(c,d)}catch(e){this.onError(e)}}
-var Pi=!1,Qi=null,Ri=!1,Si=null,Ti={onError:function(a){Pi=!0;Qi=a}};function Ui(a,b,c,d,e,f,g,h,l){Pi=!1;Qi=null;Oi.apply(Ti,arguments)}function Vi(a,b,c,d,e,f,g,h,l){Ui.apply(this,arguments);if(Pi){if(Pi){var p=Qi;Pi=!1;Qi=null}else throw Error(t(198));Ri||(Ri=!0,Si=p)}}var Wi=!1,Xi=!1,Yi="function"===typeof WeakSet?WeakSet:Set,Zi=null;
+var Pi=!1,Qi=null,Ri=!1,Si=null,Ti={onError:function(a){Pi=!0;Qi=a}};function Ui(a,b,c,d,e,f,g,h,l){Pi=!1;Qi=null;Oi.apply(Ti,arguments)}function Vi(a,b,c,d,e,f,g,h,l){Ui.apply(this,arguments);if(Pi){if(Pi){var p=Qi;Pi=!1;Qi=null}else throw Error(u(198));Ri||(Ri=!0,Si=p)}}var Wi=!1,Xi=!1,Yi="function"===typeof WeakSet?WeakSet:Set,Zi=null;
 function $i(a,b){try{var c=a.ref;if(null!==c){var d=a.stateNode;switch(a.tag){case 26:case 27:case 5:var e=d;break;default:e=d}"function"===typeof c?a.refCleanup=c(e):c.current=e}}catch(f){W(a,b,f)}}function aj(a,b){var c=a.ref,d=a.refCleanup;if(null!==c)if("function"===typeof d)try{d()}catch(e){W(a,b,e)}finally{a.refCleanup=null,a=a.alternate,null!=a&&(a.refCleanup=null)}else if("function"===typeof c)try{c(null)}catch(e){W(a,b,e)}else c.current=null}
 function bj(a,b,c){try{c()}catch(d){W(a,b,d)}}var cj=!1;
-function dj(a,b){ej=fj;a=gj();if(hj(a)){if("selectionStart"in a)var c={start:a.selectionStart,end:a.selectionEnd};else a:{c=(c=a.ownerDocument)&&c.defaultView||window;var d=c.getSelection&&c.getSelection();if(d&&0!==d.rangeCount){c=d.anchorNode;var e=d.anchorOffset,f=d.focusNode;d=d.focusOffset;try{c.nodeType,f.nodeType}catch(A){c=null;break a}var g=0,h=-1,l=-1,p=0,q=0,w=a,r=null;b:for(;;){for(var u;;){w!==c||0!==e&&3!==w.nodeType||(h=g+e);w!==f||0!==d&&3!==w.nodeType||(l=g+d);3===w.nodeType&&(g+=
-w.nodeValue.length);if(null===(u=w.firstChild))break;r=w;w=u}for(;;){if(w===a)break b;r===c&&++p===e&&(h=g);r===f&&++q===d&&(l=g);if(null!==(u=w.nextSibling))break;w=r;r=w.parentNode}w=u}c=-1===h||-1===l?null:{start:h,end:l}}else c=null}c=c||{start:0,end:0}}else c=null;ij={focusedElem:a,selectionRange:c};fj=!1;for(Zi=b;null!==Zi;)if(b=Zi,a=b.child,0!==(b.subtreeFlags&1028)&&null!==a)a.return=b,Zi=a;else for(;null!==Zi;){b=Zi;try{var z=b.alternate,C=b.flags;switch(b.tag){case 0:if(0!==(C&4)){var V=
-b.updateQueue,R=null!==V?V.events:null;if(null!==R)for(a=0;a<R.length;a++){var m=R[a];m.ref.impl=m.nextImpl}}break;case 11:case 15:break;case 1:if(0!==(C&1024)&&null!==z){var k=z.memoizedProps,n=z.memoizedState,v=b.stateNode,x=v.getSnapshotBeforeUpdate(b.elementType===b.type?k:bh(b.type,k),n);v.__reactInternalSnapshotBeforeUpdate=x}break;case 3:0!==(C&1024)&&jj(b.stateNode.containerInfo);break;case 5:case 26:case 27:case 6:case 4:case 17:break;default:if(0!==(C&1024))throw Error(t(163));}}catch(A){W(b,
+function dj(a,b){ej=fj;a=gj();if(hj(a)){if("selectionStart"in a)var c={start:a.selectionStart,end:a.selectionEnd};else a:{c=(c=a.ownerDocument)&&c.defaultView||window;var d=c.getSelection&&c.getSelection();if(d&&0!==d.rangeCount){c=d.anchorNode;var e=d.anchorOffset,f=d.focusNode;d=d.focusOffset;try{c.nodeType,f.nodeType}catch(A){c=null;break a}var g=0,h=-1,l=-1,p=0,q=0,w=a,r=null;b:for(;;){for(var t;;){w!==c||0!==e&&3!==w.nodeType||(h=g+e);w!==f||0!==d&&3!==w.nodeType||(l=g+d);3===w.nodeType&&(g+=
+w.nodeValue.length);if(null===(t=w.firstChild))break;r=w;w=t}for(;;){if(w===a)break b;r===c&&++p===e&&(h=g);r===f&&++q===d&&(l=g);if(null!==(t=w.nextSibling))break;w=r;r=w.parentNode}w=t}c=-1===h||-1===l?null:{start:h,end:l}}else c=null}c=c||{start:0,end:0}}else c=null;ij={focusedElem:a,selectionRange:c};fj=!1;for(Zi=b;null!==Zi;)if(b=Zi,a=b.child,0!==(b.subtreeFlags&1028)&&null!==a)a.return=b,Zi=a;else for(;null!==Zi;){b=Zi;try{var z=b.alternate,C=b.flags;switch(b.tag){case 0:if(0!==(C&4)){var V=
+b.updateQueue,R=null!==V?V.events:null;if(null!==R)for(a=0;a<R.length;a++){var m=R[a];m.ref.impl=m.nextImpl}}break;case 11:case 15:break;case 1:if(0!==(C&1024)&&null!==z){var k=z.memoizedProps,n=z.memoizedState,v=b.stateNode,x=v.getSnapshotBeforeUpdate(b.elementType===b.type?k:bh(b.type,k),n);v.__reactInternalSnapshotBeforeUpdate=x}break;case 3:0!==(C&1024)&&jj(b.stateNode.containerInfo);break;case 5:case 26:case 27:case 6:case 4:case 17:break;default:if(0!==(C&1024))throw Error(u(163));}}catch(A){W(b,
 b.return,A)}a=b.sibling;if(null!==a){a.return=b.return;Zi=a;break}Zi=b.return}z=cj;cj=!1;return z}function kj(a,b,c){var d=b.updateQueue;d=null!==d?d.lastEffect:null;if(null!==d){var e=d=d.next;do{if((e.tag&a)===a){var f=e.inst,g=f.destroy;void 0!==g&&(f.destroy=void 0,bj(b,c,g))}e=e.next}while(e!==d)}}function lj(a,b){b=b.updateQueue;b=null!==b?b.lastEffect:null;if(null!==b){var c=b=b.next;do{if((c.tag&a)===a){var d=c.create,e=c.inst;d=d();e.destroy=d}c=c.next}while(c!==b)}}
 function mj(a,b){try{lj(b,a)}catch(c){W(a,a.return,c)}}function nj(a){var b=a.updateQueue;if(null!==b){var c=a.stateNode;try{ge(b,c)}catch(d){W(a,a.return,d)}}}function oj(a){var b=a.type,c=a.memoizedProps,d=a.stateNode;try{a:switch(b){case "button":case "input":case "select":case "textarea":c.autoFocus&&d.focus();break a;case "img":c.src&&(d.src=c.src)}}catch(e){W(a,a.return,e)}}
 function pj(a,b,c){var d=c.flags;switch(c.tag){case 0:case 11:case 15:qj(a,c);d&4&&mj(c,5);break;case 1:qj(a,c);if(d&4)if(a=c.stateNode,null===b)try{a.componentDidMount()}catch(h){W(c,c.return,h)}else{var e=c.elementType===c.type?b.memoizedProps:bh(c.type,b.memoizedProps);b=b.memoizedState;try{a.componentDidUpdate(e,b,a.__reactInternalSnapshotBeforeUpdate)}catch(h){W(c,c.return,h)}}d&64&&nj(c);d&512&&$i(c,c.return);break;case 3:qj(a,c);if(d&64&&(d=c.updateQueue,null!==d)){a=null;if(null!==c.child)switch(c.child.tag){case 27:case 5:a=
@@ -220,20 +219,20 @@ function yj(a,b,c){var d=a.tag;if(5===d||6===d)a=a.stateNode,b?c.insertBefore(a,
 function Cj(a,b,c){if(fb&&"function"===typeof fb.onCommitFiberUnmount)try{fb.onCommitFiberUnmount(eb,c)}catch(l){}switch(c.tag){case 26:Xi||aj(c,b);Bj(a,b,c);c.memoizedState?c.memoizedState.count--:c.stateNode&&(c=c.stateNode,c.parentNode.removeChild(c));break;case 27:Xi||aj(c,b);var d=zj,e=Aj;zj=c.stateNode;Bj(a,b,c);c=c.stateNode;for(a=c.attributes;a.length;)c.removeAttributeNode(a[0]);Lb(c);zj=d;Aj=e;break;case 5:Xi||aj(c,b);case 6:d=zj;e=Aj;zj=null;Bj(a,b,c);zj=d;Aj=e;null!==zj&&(Aj?(a=zj,c=c.stateNode,
 8===a.nodeType?a.parentNode.removeChild(c):a.removeChild(c)):zj.removeChild(c.stateNode));break;case 18:null!==zj&&(Aj?(a=zj,c=c.stateNode,8===a.nodeType?Dj(a.parentNode,c):1===a.nodeType&&Dj(a,c),Ej(a)):Dj(zj,c.stateNode));break;case 4:d=zj;e=Aj;zj=c.stateNode.containerInfo;Aj=!0;Bj(a,b,c);zj=d;Aj=e;break;case 0:case 11:case 14:case 15:if(!Xi&&(d=c.updateQueue,null!==d&&(d=d.lastEffect,null!==d))){e=d=d.next;do{var f=e.tag,g=e.inst,h=g.destroy;void 0!==h&&(0!==(f&2)?(g.destroy=void 0,bj(c,b,h)):
 0!==(f&4)&&(g.destroy=void 0,bj(c,b,h)));e=e.next}while(e!==d)}Bj(a,b,c);break;case 1:if(!Xi&&(aj(c,b),d=c.stateNode,"function"===typeof d.componentWillUnmount))try{d.props=c.memoizedProps,d.state=c.memoizedState,d.componentWillUnmount()}catch(l){W(c,b,l)}Bj(a,b,c);break;case 21:Bj(a,b,c);break;case 22:aj(c,b);c.mode&1?(Xi=(d=Xi)||null!==c.memoizedState,Bj(a,b,c),Xi=d):Bj(a,b,c);break;default:Bj(a,b,c)}}
-function rj(a,b){if(null===b.memoizedState&&(a=b.alternate,null!==a&&(a=a.memoizedState,null!==a&&(a=a.dehydrated,null!==a))))try{Ej(a)}catch(c){W(b,b.return,c)}}function Fj(a){switch(a.tag){case 13:case 19:var b=a.stateNode;null===b&&(b=a.stateNode=new Yi);return b;case 22:return a=a.stateNode,b=a._retryCache,null===b&&(b=a._retryCache=new Yi),b;default:throw Error(t(435,a.tag));}}function Gj(a,b){var c=Fj(a);b.forEach(function(d){var e=Hj.bind(null,a,d);c.has(d)||(c.add(d),d.then(e,e))})}
-function Ij(a,b){var c=b.deletions;if(null!==c)for(var d=0;d<c.length;d++){var e=c[d];try{var f=a,g=b,h=g;a:for(;null!==h;){switch(h.tag){case 27:case 5:zj=h.stateNode;Aj=!1;break a;case 3:zj=h.stateNode.containerInfo;Aj=!0;break a;case 4:zj=h.stateNode.containerInfo;Aj=!0;break a}h=h.return}if(null===zj)throw Error(t(160));Cj(f,g,e);zj=null;Aj=!1;var l=e.alternate;null!==l&&(l.return=null);e.return=null}catch(p){W(e,b,p)}}if(b.subtreeFlags&12854)for(b=b.child;null!==b;)Jj(b,a),b=b.sibling}
+function rj(a,b){if(null===b.memoizedState&&(a=b.alternate,null!==a&&(a=a.memoizedState,null!==a&&(a=a.dehydrated,null!==a))))try{Ej(a)}catch(c){W(b,b.return,c)}}function Fj(a){switch(a.tag){case 13:case 19:var b=a.stateNode;null===b&&(b=a.stateNode=new Yi);return b;case 22:return a=a.stateNode,b=a._retryCache,null===b&&(b=a._retryCache=new Yi),b;default:throw Error(u(435,a.tag));}}function Gj(a,b){var c=Fj(a);b.forEach(function(d){var e=Hj.bind(null,a,d);c.has(d)||(c.add(d),d.then(e,e))})}
+function Ij(a,b){var c=b.deletions;if(null!==c)for(var d=0;d<c.length;d++){var e=c[d];try{var f=a,g=b,h=g;a:for(;null!==h;){switch(h.tag){case 27:case 5:zj=h.stateNode;Aj=!1;break a;case 3:zj=h.stateNode.containerInfo;Aj=!0;break a;case 4:zj=h.stateNode.containerInfo;Aj=!0;break a}h=h.return}if(null===zj)throw Error(u(160));Cj(f,g,e);zj=null;Aj=!1;var l=e.alternate;null!==l&&(l.return=null);e.return=null}catch(p){W(e,b,p)}}if(b.subtreeFlags&12854)for(b=b.child;null!==b;)Jj(b,a),b=b.sibling}
 var Kj=null;
-function Jj(a,b){var c=a.alternate,d=a.flags;switch(a.tag){case 0:case 11:case 14:case 15:Ij(b,a);Lj(a);if(d&4){try{kj(3,a,a.return),lj(3,a)}catch(u){W(a,a.return,u)}try{kj(5,a,a.return)}catch(u){W(a,a.return,u)}}break;case 1:Ij(b,a);Lj(a);d&512&&null!==c&&aj(c,c.return);d&64&&Wi&&(a=a.updateQueue,null!==a&&(c=a.callbacks,null!==c&&(d=a.shared.hiddenCallbacks,a.shared.hiddenCallbacks=null===d?c:d.concat(c))));break;case 26:var e=Kj;Ij(b,a);Lj(a);d&512&&null!==c&&aj(c,c.return);if(d&4)if(b=null!==
+function Jj(a,b){var c=a.alternate,d=a.flags;switch(a.tag){case 0:case 11:case 14:case 15:Ij(b,a);Lj(a);if(d&4){try{kj(3,a,a.return),lj(3,a)}catch(t){W(a,a.return,t)}try{kj(5,a,a.return)}catch(t){W(a,a.return,t)}}break;case 1:Ij(b,a);Lj(a);d&512&&null!==c&&aj(c,c.return);d&64&&Wi&&(a=a.updateQueue,null!==a&&(c=a.callbacks,null!==c&&(d=a.shared.hiddenCallbacks,a.shared.hiddenCallbacks=null===d?c:d.concat(c))));break;case 26:var e=Kj;Ij(b,a);Lj(a);d&512&&null!==c&&aj(c,c.return);if(d&4)if(b=null!==
 c?c.memoizedState:null,d=a.memoizedState,null===c)if(null===d)if(null===a.stateNode){a:{c=a.type;d=a.memoizedProps;b=e.ownerDocument||e;b:switch(c){case "title":e=b.getElementsByTagName("title")[0];if(!e||e[Kb]||e[Cb]||"http://www.w3.org/2000/svg"===e.namespaceURI||e.hasAttribute("itemprop"))e=b.createElement(c),b.head.insertBefore(e,b.querySelector("head > title"));Hi(e,c,d);e[Cb]=a;Sb(e);c=e;break a;case "link":var f=Mj("link","href",b).get(c+(d.href||""));if(f)for(var g=0;g<f.length;g++)if(e=f[g],
 e.getAttribute("href")===(null==d.href?null:d.href)&&e.getAttribute("rel")===(null==d.rel?null:d.rel)&&e.getAttribute("title")===(null==d.title?null:d.title)&&e.getAttribute("crossorigin")===(null==d.crossOrigin?null:d.crossOrigin)){f.splice(g,1);break b}e=b.createElement(c);Hi(e,c,d);b.head.appendChild(e);break;case "meta":if(f=Mj("meta","content",b).get(c+(d.content||"")))for(g=0;g<f.length;g++)if(e=f[g],e.getAttribute("content")===(null==d.content?null:""+d.content)&&e.getAttribute("name")===(null==
-d.name?null:d.name)&&e.getAttribute("property")===(null==d.property?null:d.property)&&e.getAttribute("http-equiv")===(null==d.httpEquiv?null:d.httpEquiv)&&e.getAttribute("charset")===(null==d.charSet?null:d.charSet)){f.splice(g,1);break b}e=b.createElement(c);Hi(e,c,d);b.head.appendChild(e);break;default:throw Error(t(468,c));}e[Cb]=a;Sb(e);c=e}a.stateNode=c}else Nj(e,a.type,a.stateNode);else a.stateNode=Oj(e,d,a.memoizedProps);else if(b!==d)null===b?null!==c.stateNode&&(c=c.stateNode,c.parentNode.removeChild(c)):
-b.count--,null===d?Nj(e,a.type,a.stateNode):Oj(e,d,a.memoizedProps);else if(null===d&&null!==a.stateNode){a.updateQueue=null;try{var h=a.stateNode,l=a.memoizedProps;Pj(h,a.type,c.memoizedProps,l);h[Db]=l}catch(u){W(a,a.return,u)}}break;case 27:if(d&4&&null===a.alternate){e=a.stateNode;f=a.memoizedProps;for(g=e.firstChild;g;){var p=g.nextSibling,q=g.nodeName;g[Kb]||"HEAD"===q||"BODY"===q||"SCRIPT"===q||"STYLE"===q||"LINK"===q&&"stylesheet"===g.rel.toLowerCase()||e.removeChild(g);g=p}g=a.type;for(p=
-e.attributes;p.length;)e.removeAttributeNode(p[0]);Hi(e,g,f);e[Cb]=a;e[Db]=f}case 5:Ij(b,a);Lj(a);d&512&&null!==c&&aj(c,c.return);if(a.flags&32){b=a.stateNode;try{Ac(b,"")}catch(u){W(a,a.return,u)}}if(d&4&&(d=a.stateNode,null!=d)){b=a.memoizedProps;c=null!==c?c.memoizedProps:b;e=a.type;a.updateQueue=null;try{Pj(d,e,c,b),d[Db]=b}catch(u){W(a,a.return,u)}}break;case 6:Ij(b,a);Lj(a);if(d&4){if(null===a.stateNode)throw Error(t(162));c=a.stateNode;d=a.memoizedProps;try{c.nodeValue=d}catch(u){W(a,a.return,
-u)}}break;case 3:Qj=null;e=Kj;Kj=Rj(b.containerInfo);Ij(b,a);Kj=e;Lj(a);if(d&4&&null!==c&&c.memoizedState.isDehydrated)try{Ej(b.containerInfo)}catch(u){W(a,a.return,u)}break;case 4:c=Kj;Kj=Rj(a.stateNode.containerInfo);Ij(b,a);Lj(a);Kj=c;break;case 13:Ij(b,a);Lj(a);a.child.flags&8192&&null!==a.memoizedState!==(null!==c&&null!==c.memoizedState)&&(Sj=Ya());d&4&&(c=a.updateQueue,null!==c&&(a.updateQueue=null,Gj(a,c)));break;case 22:d&512&&null!==c&&aj(c,c.return);h=null!==a.memoizedState;l=null!==c&&
+d.name?null:d.name)&&e.getAttribute("property")===(null==d.property?null:d.property)&&e.getAttribute("http-equiv")===(null==d.httpEquiv?null:d.httpEquiv)&&e.getAttribute("charset")===(null==d.charSet?null:d.charSet)){f.splice(g,1);break b}e=b.createElement(c);Hi(e,c,d);b.head.appendChild(e);break;default:throw Error(u(468,c));}e[Cb]=a;Sb(e);c=e}a.stateNode=c}else Nj(e,a.type,a.stateNode);else a.stateNode=Oj(e,d,a.memoizedProps);else if(b!==d)null===b?null!==c.stateNode&&(c=c.stateNode,c.parentNode.removeChild(c)):
+b.count--,null===d?Nj(e,a.type,a.stateNode):Oj(e,d,a.memoizedProps);else if(null===d&&null!==a.stateNode){a.updateQueue=null;try{var h=a.stateNode,l=a.memoizedProps;Pj(h,a.type,c.memoizedProps,l);h[Db]=l}catch(t){W(a,a.return,t)}}break;case 27:if(d&4&&null===a.alternate){e=a.stateNode;f=a.memoizedProps;for(g=e.firstChild;g;){var p=g.nextSibling,q=g.nodeName;g[Kb]||"HEAD"===q||"BODY"===q||"SCRIPT"===q||"STYLE"===q||"LINK"===q&&"stylesheet"===g.rel.toLowerCase()||e.removeChild(g);g=p}g=a.type;for(p=
+e.attributes;p.length;)e.removeAttributeNode(p[0]);Hi(e,g,f);e[Cb]=a;e[Db]=f}case 5:Ij(b,a);Lj(a);d&512&&null!==c&&aj(c,c.return);if(a.flags&32){b=a.stateNode;try{Ac(b,"")}catch(t){W(a,a.return,t)}}if(d&4&&(d=a.stateNode,null!=d)){b=a.memoizedProps;c=null!==c?c.memoizedProps:b;e=a.type;a.updateQueue=null;try{Pj(d,e,c,b),d[Db]=b}catch(t){W(a,a.return,t)}}break;case 6:Ij(b,a);Lj(a);if(d&4){if(null===a.stateNode)throw Error(u(162));c=a.stateNode;d=a.memoizedProps;try{c.nodeValue=d}catch(t){W(a,a.return,
+t)}}break;case 3:Qj=null;e=Kj;Kj=Rj(b.containerInfo);Ij(b,a);Kj=e;Lj(a);if(d&4&&null!==c&&c.memoizedState.isDehydrated)try{Ej(b.containerInfo)}catch(t){W(a,a.return,t)}break;case 4:c=Kj;Kj=Rj(a.stateNode.containerInfo);Ij(b,a);Lj(a);Kj=c;break;case 13:Ij(b,a);Lj(a);a.child.flags&8192&&null!==a.memoizedState!==(null!==c&&null!==c.memoizedState)&&(Sj=Ya());d&4&&(c=a.updateQueue,null!==c&&(a.updateQueue=null,Gj(a,c)));break;case 22:d&512&&null!==c&&aj(c,c.return);h=null!==a.memoizedState;l=null!==c&&
 null!==c.memoizedState;if(a.mode&1){var w=Wi,r=Xi;Wi=w||h;Xi=r||l;Ij(b,a);Xi=r;Wi=w}else Ij(b,a);Lj(a);b=a.stateNode;b._current=a;b._visibility&=-3;b._visibility|=b._pendingVisibility&2;if(d&8192&&(b._visibility=h?b._visibility&-2:b._visibility|1,h&&(b=Wi||Xi,null===c||l||b||0!==(a.mode&1)&&Tj(a)),null===a.memoizedProps||"manual"!==a.memoizedProps.mode))a:for(c=null,b=a;;){if(5===b.tag||26===b.tag||27===b.tag){if(null===c){c=b;try{e=b.stateNode,h?(f=e.style,"function"===typeof f.setProperty?f.setProperty("display",
-"none","important"):f.display="none"):(g=b.stateNode,p=b.memoizedProps.style,q=void 0!==p&&null!==p&&p.hasOwnProperty("display")?p.display:null,g.style.display=null==q||"boolean"===typeof q?"":(""+q).trim())}catch(u){W(a,a.return,u)}}}else if(6===b.tag){if(null===c)try{b.stateNode.nodeValue=h?"":b.memoizedProps}catch(u){W(a,a.return,u)}}else if((22!==b.tag&&23!==b.tag||null===b.memoizedState||b===a)&&null!==b.child){b.child.return=b;b=b.child;continue}if(b===a)break a;for(;null===b.sibling;){if(null===
+"none","important"):f.display="none"):(g=b.stateNode,p=b.memoizedProps.style,q=void 0!==p&&null!==p&&p.hasOwnProperty("display")?p.display:null,g.style.display=null==q||"boolean"===typeof q?"":(""+q).trim())}catch(t){W(a,a.return,t)}}}else if(6===b.tag){if(null===c)try{b.stateNode.nodeValue=h?"":b.memoizedProps}catch(t){W(a,a.return,t)}}else if((22!==b.tag&&23!==b.tag||null===b.memoizedState||b===a)&&null!==b.child){b.child.return=b;b=b.child;continue}if(b===a)break a;for(;null===b.sibling;){if(null===
 b.return||b.return===a)break a;c===b&&(c=null);b=b.return}c===b&&(c=null);b.sibling.return=b.return;b=b.sibling}d&4&&(c=a.updateQueue,null!==c&&(d=c.retryQueue,null!==d&&(c.retryQueue=null,Gj(a,d))));break;case 19:Ij(b,a);Lj(a);d&4&&(c=a.updateQueue,null!==c&&(a.updateQueue=null,Gj(a,c)));break;case 21:break;default:Ij(b,a),Lj(a)}}
-function Lj(a){var b=a.flags;if(b&2){try{if(27!==a.tag){b:{for(var c=a.return;null!==c;){if(uj(c)){var d=c;break b}c=c.return}throw Error(t(160));}switch(d.tag){case 27:var e=d.stateNode,f=vj(a);yj(a,f,e);break;case 5:var g=d.stateNode;d.flags&32&&(Ac(g,""),d.flags&=-33);var h=vj(a);yj(a,h,g);break;case 3:case 4:var l=d.stateNode.containerInfo,p=vj(a);wj(a,p,l);break;default:throw Error(t(161));}}}catch(q){W(a,a.return,q)}a.flags&=-3}b&4096&&(a.flags&=-4097)}
+function Lj(a){var b=a.flags;if(b&2){try{if(27!==a.tag){b:{for(var c=a.return;null!==c;){if(uj(c)){var d=c;break b}c=c.return}throw Error(u(160));}switch(d.tag){case 27:var e=d.stateNode,f=vj(a);yj(a,f,e);break;case 5:var g=d.stateNode;d.flags&32&&(Ac(g,""),d.flags&=-33);var h=vj(a);yj(a,h,g);break;case 3:case 4:var l=d.stateNode.containerInfo,p=vj(a);wj(a,p,l);break;default:throw Error(u(161));}}}catch(q){W(a,a.return,q)}a.flags&=-3}b&4096&&(a.flags&=-4097)}
 function qj(a,b){if(b.subtreeFlags&8772)for(b=b.child;null!==b;)pj(a,b.alternate,b),b=b.sibling}
 function Tj(a){for(a=a.child;null!==a;){var b=a;switch(b.tag){case 0:case 11:case 14:case 15:kj(4,b,b.return);Tj(b);break;case 1:aj(b,b.return);var c=b.stateNode;if("function"===typeof c.componentWillUnmount){var d=b,e=b.return;try{var f=d;c.props=f.memoizedProps;c.state=f.memoizedState;c.componentWillUnmount()}catch(g){W(d,e,g)}}Tj(b);break;case 26:case 27:case 5:aj(b,b.return);Tj(b);break;case 22:aj(b,b.return);null===b.memoizedState&&Tj(b);break;default:Tj(b)}a=a.sibling}}
 function sj(a,b,c){c=c&&0!==(b.subtreeFlags&8772);for(b=b.child;null!==b;){var d=b.alternate,e=a,f=b,g=f.flags;switch(f.tag){case 0:case 11:case 15:sj(e,f,c);mj(f,4);break;case 1:sj(e,f,c);e=f.stateNode;if("function"===typeof e.componentDidMount)try{e.componentDidMount()}catch(l){W(f,f.return,l)}d=f.updateQueue;if(null!==d){var h=d.shared.hiddenCallbacks;if(null!==h)for(d.shared.hiddenCallbacks=null,d=0;d<h.length;d++)fe(h[d],e)}c&&g&64&&nj(f);$i(f,f.return);break;case 26:case 27:case 5:sj(e,f,c);
@@ -250,8 +249,8 @@ function jk(a){var b=a.deletions;if(0!==(a.flags&16)){if(null!==b)for(var c=0;c<
 function hk(a,b){for(;null!==Zi;){var c=Zi;switch(c.tag){case 0:case 11:case 15:kj(8,c,b);break;case 23:case 22:if(null!==c.memoizedState&&null!==c.memoizedState.cachePool){var d=c.memoizedState.cachePool.pool;null!=d&&d.refCount++}break;case 24:ti(c.memoizedState.cache)}d=c.child;if(null!==d)d.return=c,Zi=d;else a:for(c=a;null!==Zi;){d=Zi;var e=d.sibling,f=d.return;tj(d);if(d===c){Zi=null;break a}if(null!==e){e.return=f;Zi=e;break a}Zi=f}}}
 var kk={getCacheSignal:function(){return ag(Mh).controller.signal},getCacheForType:function(a){var b=ag(Mh),c=b.data.get(a);void 0===c&&(c=a(),b.data.set(a,c));return c}},lk="function"===typeof WeakMap?WeakMap:Map,mk=da.ReactCurrentDispatcher,nk=da.ReactCurrentCache,ok=da.ReactCurrentOwner,pk=da.ReactCurrentBatchConfig,L=0,N=null,X=null,M=0,O=0,qk=null,rk=!1,Ie=0,uh=0,ff=null,ee=0,sk=0,tk=0,mf=0,uk=null,kf=null,Sj=0,Li=Infinity,lf=null,mh=!1,nh=null,ph=null,vk=!1,wk=null,xk=0,yk=0,zk=null,Vd=0,Wd=
 null;function Xg(a){if(0===(a.mode&1))return 2;if(0!==(L&2)&&0!==M)return M&-M;if(null!==ui.transition)return a=vf,0!==a?a:sf();a=F;if(0!==a)return a;a=window.event;a=void 0===a?32:Ak(a.type);return a}function Ng(){0===mf&&(mf=0===(M&536870912)||K?sf():536870912);return mf}function pg(a,b,c){if(a===N&&2===O||null!==a.cancelPendingCommit)gf(a,0),hf(a,M,mf);tb(a,c);if(0===(L&2)||a!==N)a===N&&(0===(L&2)&&(sk|=c),4===uh&&hf(a,M,mf)),Ze(a),2===c&&0===L&&0===(b.mode&1)&&(Li=Ya()+500,bf(!0))}
-function qf(a,b){if(0!==(L&6))throw Error(t(327));var c=a.callbackNode;if(cf()&&a.callbackNode!==c)return null;var d=ob(a,a===N?M:0);if(0===d)return null;var e=0===(d&60)&&0===(d&a.expiredLanes)&&!b;b=e?Bk(a,d):df(a,d);if(0!==b){var f=e;do{if(6===b)hf(a,d,0);else{e=a.current.alternate;if(f&&!Ck(e)){b=df(a,d);f=!1;continue}if(2===b){f=d;var g=qb(a,f);0!==g&&(d=g,b=ef(a,f,g))}if(1===b)throw c=ff,gf(a,0),hf(a,d,0),Ze(a),c;a.finishedWork=e;a.finishedLanes=d;a:{f=a;switch(b){case 0:case 1:throw Error(t(345));
-case 4:if((d&4194176)===d){hf(f,d,mf);break a}break;case 2:case 3:case 5:break;default:throw Error(t(329));}if((d&62914560)===d&&(b=Sj+300-Ya(),10<b)){hf(f,d,mf);if(0!==ob(f,0))break a;f.timeoutHandle=Dk(Ek.bind(null,f,e,kf,lf,d,mf),b);break a}Ek(f,e,kf,lf,d,mf)}}break}while(1)}Ze(a);pf(a,Ya());a=a.callbackNode===c?qf.bind(null,a):null;return a}
+function qf(a,b){if(0!==(L&6))throw Error(u(327));var c=a.callbackNode;if(cf()&&a.callbackNode!==c)return null;var d=ob(a,a===N?M:0);if(0===d)return null;var e=0===(d&60)&&0===(d&a.expiredLanes)&&!b;b=e?Bk(a,d):df(a,d);if(0!==b){var f=e;do{if(6===b)hf(a,d,0);else{e=a.current.alternate;if(f&&!Ck(e)){b=df(a,d);f=!1;continue}if(2===b){f=d;var g=qb(a,f);0!==g&&(d=g,b=ef(a,f,g))}if(1===b)throw c=ff,gf(a,0),hf(a,d,0),Ze(a),c;a.finishedWork=e;a.finishedLanes=d;a:{f=a;switch(b){case 0:case 1:throw Error(u(345));
+case 4:if((d&4194176)===d){hf(f,d,mf);break a}break;case 2:case 3:case 5:break;default:throw Error(u(329));}if((d&62914560)===d&&(b=Sj+300-Ya(),10<b)){hf(f,d,mf);if(0!==ob(f,0))break a;f.timeoutHandle=Dk(Ek.bind(null,f,e,kf,lf,d,mf),b);break a}Ek(f,e,kf,lf,d,mf)}}break}while(1)}Ze(a);pf(a,Ya());a=a.callbackNode===c?qf.bind(null,a):null;return a}
 function ef(a,b,c){var d=uk,e=a.current.memoizedState.isDehydrated;e&&(gf(a,c).flags|=256);c=df(a,c);if(2!==c){if(rk&&!e)return a.errorRecoveryDisabledLanes|=b,sk|=b,4;a=kf;kf=d;null!==a&&Di(a)}return c}function Di(a){null===kf?kf=a:kf.push.apply(kf,a)}function Ek(a,b,c,d,e,f){if(0===(e&42)&&(Fk={stylesheets:null,count:0,unsuspend:Gk},dk(b),b=Hk(),null!==b)){a.cancelPendingCommit=b(jf.bind(null,a,c,d));hf(a,e,f);return}jf(a,c,d,f)}
 function Ck(a){for(var b=a;;){if(b.flags&16384){var c=b.updateQueue;if(null!==c&&(c=c.stores,null!==c))for(var d=0;d<c.length;d++){var e=c[d],f=e.getSnapshot;e=e.value;try{if(!ed(f(),e))return!1}catch(g){return!1}}}c=b.child;if(b.subtreeFlags&16384&&null!==c)c.return=b,b=c;else{if(b===a)break;for(;null===b.sibling;){if(null===b.return||b.return===a)return!0;b=b.return}b.sibling.return=b.return;b=b.sibling}}return!0}
 function hf(a,b,c){b&=~tk;b&=~sk;a.suspendedLanes|=b;a.pingedLanes&=~b;for(var d=a.expirationTimes,e=b;0<e;){var f=31-ib(e),g=1<<f;d[f]=-1;e&=~g}0!==c&&vb(a,c,b)}function Ik(a,b){var c=L;L|=1;try{return a(b)}finally{L=c,0===L&&(Li=Ya()+500,bf(!0))}}function Jk(a){null!==wk&&0===wk.tag&&0===(L&6)&&cf();var b=L;L|=1;var c=pk.transition,d=F;try{if(pk.transition=null,F=2,a)return a()}finally{F=d,pk.transition=c,L=b,0===(L&6)&&bf(!1)}}
@@ -259,28 +258,28 @@ function Kk(){if(null!==X){if(0===O)var a=X.return;else a=X,mi(),Wf(a),qe=null,r
 function gf(a,b){a.finishedWork=null;a.finishedLanes=0;var c=a.timeoutHandle;-1!==c&&(a.timeoutHandle=-1,Lk(c));c=a.cancelPendingCommit;null!==c&&(a.cancelPendingCommit=null,c());Kk();N=a;X=c=xe(a.current,null);M=b;O=0;qk=null;rk=!1;uh=0;ff=null;mf=tk=sk=ee=0;kf=uk=null;0!==(b&8)&&(b|=b&32);var d=a.entangledLanes;if(0!==d)for(a=a.entanglements,d&=b;0<d;){var e=31-ib(d),f=1<<e;b|=a[e];d&=~f}Ie=b;Pd();return c}
 function Mk(a,b){P=null;Af.current=Qf;ok.current=null;b===ie?(b=pe(),O=zi()&&0===(ee&134217727)&&0===(sk&134217727)?2:3):b===je?(b=pe(),O=4):O=b===yh?8:null!==b&&"object"===typeof b&&"function"===typeof b.then?6:1;qk=b;null===X&&(uh=1,ff=b)}function zi(){var a=Le.current;return null===a?!0:(M&4194176)===M?null===Me?!0:!1:(M&62914560)===M||0!==(M&536870912)?a===Me:!1}function Nk(){var a=mk.current;mk.current=Qf;return null===a?Qf:a}function Ok(){var a=nk.current;nk.current=kk;return a}
 function th(){uh=4;0===(ee&134217727)&&0===(sk&134217727)||null===N||hf(N,M,mf)}function wh(a){4!==uh&&(uh=2);null===uk?uk=[a]:uk.push(a)}
-function df(a,b){var c=L;L|=2;var d=Nk(),e=Ok();if(N!==a||M!==b)lf=null,gf(a,b);b=!1;a:do try{if(0!==O&&null!==X){var f=X,g=qk;switch(O){case 8:Kk();uh=6;break a;case 3:case 2:b||null!==Le.current||(b=!0);default:O=0,qk=null,Pk(f,g)}}Qk();break}catch(h){Mk(a,h)}while(1);b&&a.shellSuspendCounter++;mi();L=c;mk.current=d;nk.current=e;if(null!==X)throw Error(t(261));N=null;M=0;Pd();return uh}function Qk(){for(;null!==X;)Rk(X)}
+function df(a,b){var c=L;L|=2;var d=Nk(),e=Ok();if(N!==a||M!==b)lf=null,gf(a,b);b=!1;a:do try{if(0!==O&&null!==X){var f=X,g=qk;switch(O){case 8:Kk();uh=6;break a;case 3:case 2:b||null!==Le.current||(b=!0);default:O=0,qk=null,Pk(f,g)}}Qk();break}catch(h){Mk(a,h)}while(1);b&&a.shellSuspendCounter++;mi();L=c;mk.current=d;nk.current=e;if(null!==X)throw Error(u(261));N=null;M=0;Pd();return uh}function Qk(){for(;null!==X;)Rk(X)}
 function Bk(a,b){var c=L;L|=2;var d=Nk(),e=Ok();if(N!==a||M!==b)lf=null,Li=Ya()+500,gf(a,b);a:do try{if(0!==O&&null!==X){b=X;var f=qk;b:switch(O){case 1:O=0;qk=null;Pk(b,f);break;case 2:if(le(f)){O=0;qk=null;Sk(b);break}b=function(){2===O&&N===a&&(O=7);Ze(a)};f.then(b,b);break a;case 3:O=7;break a;case 4:O=5;break a;case 7:le(f)?(O=0,qk=null,Sk(b)):(O=0,qk=null,Pk(b,f));break;case 5:switch(X.tag){case 5:case 26:case 27:b=X;O=0;qk=null;var g=b.sibling;if(null!==g)X=g;else{var h=b.return;null!==h?(X=
-h,Tk(h)):X=null}break b}O=0;qk=null;Pk(b,f);break;case 6:O=0;qk=null;Pk(b,f);break;case 8:Kk();uh=6;break a;default:throw Error(t(462));}}Uk();break}catch(l){Mk(a,l)}while(1);mi();mk.current=d;nk.current=e;L=c;if(null!==X)return 0;N=null;M=0;Pd();return uh}function Uk(){for(;null!==X&&!Wa();)Rk(X)}function Rk(a){var b=Vk(a.alternate,a,Ie);a.memoizedProps=a.pendingProps;null===b?Tk(a):X=b;ok.current=null}
+h,Tk(h)):X=null}break b}O=0;qk=null;Pk(b,f);break;case 6:O=0;qk=null;Pk(b,f);break;case 8:Kk();uh=6;break a;default:throw Error(u(462));}}Uk();break}catch(l){Mk(a,l)}while(1);mi();mk.current=d;nk.current=e;L=c;if(null!==X)return 0;N=null;M=0;Pd();return uh}function Uk(){for(;null!==X&&!Wa();)Rk(X)}function Rk(a){var b=Vk(a.alternate,a,Ie);a.memoizedProps=a.pendingProps;null===b?Tk(a):X=b;ok.current=null}
 function Sk(a){var b=a.alternate;switch(a.tag){case 2:a.tag=0;case 15:case 0:var c=a.type,d=a.pendingProps;d=a.elementType===c?d:bh(c,d);var e=Yc(c)?Wc:Uc.current;e=Xc(a,e);b=Nh(b,a,d,c,e,M);break;case 11:c=a.type.render;d=a.pendingProps;d=a.elementType===c?d:bh(c,d);b=Nh(b,a,d,c,a.ref,M);break;case 5:Wf(a);default:Ni(b,a),a=X=Ki(a,Ie),b=Vk(b,a,Ie)}a.memoizedProps=a.pendingProps;null===b?Tk(a):X=b;ok.current=null}
 function Pk(a,b){mi();Wf(a);qe=null;re=0;var c=a.return;if(null===c||null===N)uh=1,ff=b,X=null;else{try{sh(N,c,a,b,M)}catch(d){throw X=c,d;}if(a.flags&32768)a:{do{b=Mi(a.alternate,a);if(null!==b){b.flags&=32767;X=b;break a}a=a.return;null!==a&&(a.flags|=32768,a.subtreeFlags=0,a.deletions=null);X=a}while(null!==a);uh=6;X=null}else Tk(a)}}function Tk(a){var b=a;do{a=b.return;var c=Ci(b.alternate,b,Ie);if(null!==c){X=c;return}b=b.sibling;if(null!==b){X=b;return}X=b=a}while(null!==b);0===uh&&(uh=5)}
 function jf(a,b,c,d){var e=F,f=pk.transition;try{pk.transition=null,F=2,Wk(a,b,c,e,d)}finally{pk.transition=f,F=e}return null}
-function Wk(a,b,c,d,e){do cf();while(null!==wk);if(0!==(L&6))throw Error(t(327));var f=a.finishedWork,g=a.finishedLanes;if(null===f)return null;a.finishedWork=null;a.finishedLanes=0;if(f===a.current)throw Error(t(177));a.callbackNode=null;a.callbackPriority=0;a.cancelPendingCommit=null;var h=f.lanes|f.childLanes;h|=Od;ub(a,h,e);a===N&&(X=N=null,M=0);0===(f.subtreeFlags&10256)&&0===(f.flags&10256)||vk||(vk=!0,yk=h,zk=c,Xk(bb,function(){cf();return null}));c=0!==(f.flags&15990);if(0!==(f.subtreeFlags&
+function Wk(a,b,c,d,e){do cf();while(null!==wk);if(0!==(L&6))throw Error(u(327));var f=a.finishedWork,g=a.finishedLanes;if(null===f)return null;a.finishedWork=null;a.finishedLanes=0;if(f===a.current)throw Error(u(177));a.callbackNode=null;a.callbackPriority=0;a.cancelPendingCommit=null;var h=f.lanes|f.childLanes;h|=Od;ub(a,h,e);a===N&&(X=N=null,M=0);0===(f.subtreeFlags&10256)&&0===(f.flags&10256)||vk||(vk=!0,yk=h,zk=c,Xk(bb,function(){cf();return null}));c=0!==(f.flags&15990);if(0!==(f.subtreeFlags&
 15990)||c){c=pk.transition;pk.transition=null;e=F;F=2;var l=L;L|=4;ok.current=null;dj(a,f);Jj(f,a);Yk(ij);fj=!!ej;ij=ej=null;a.current=f;pj(a,f.alternate,f);Xa();L=l;F=e;pk.transition=c}else a.current=f;vk?(vk=!1,wk=a,xk=g):Zk(a,h);h=a.pendingLanes;0===h&&(ph=null);gb(f.stateNode,d);Ze(a);if(null!==b)for(d=a.onRecoverableError,f=0;f<b.length;f++)h=b[f],c={digest:h.digest,componentStack:h.stack},d(h.value,c);if(mh)throw mh=!1,a=nh,nh=null,a;0!==(xk&3)&&0!==a.tag&&cf();h=a.pendingLanes;0!==(g&4194218)&&
 0!==(h&42)?a===Wd?Vd++:(Vd=0,Wd=a):Vd=0;bf(!1);return null}function Zk(a,b){0===(a.pooledCacheLanes&=b)&&(b=a.pooledCache,null!=b&&(a.pooledCache=null,ti(b)))}
-function cf(){if(null!==wk){var a=wk,b=yk;yk=0;var c=zb(xk),d=32>c?32:c;c=pk.transition;var e=F;try{pk.transition=null;F=d;if(null===wk)var f=!1;else{d=zk;zk=null;var g=wk,h=xk;wk=null;xk=0;if(0!==(L&6))throw Error(t(331));var l=L;L|=4;ik(g.current);Yj(g,g.current,h,d);L=l;bf(!1);if(fb&&"function"===typeof fb.onPostCommitFiberRoot)try{fb.onPostCommitFiberRoot(eb,g)}catch(p){}f=!0}return f}finally{F=e,pk.transition=c,Zk(a,b)}}return!1}
+function cf(){if(null!==wk){var a=wk,b=yk;yk=0;var c=zb(xk),d=32>c?32:c;c=pk.transition;var e=F;try{pk.transition=null;F=d;if(null===wk)var f=!1;else{d=zk;zk=null;var g=wk,h=xk;wk=null;xk=0;if(0!==(L&6))throw Error(u(331));var l=L;L|=4;ik(g.current);Yj(g,g.current,h,d);L=l;bf(!1);if(fb&&"function"===typeof fb.onPostCommitFiberRoot)try{fb.onPostCommitFiberRoot(eb,g)}catch(p){}f=!0}return f}finally{F=e,pk.transition=c,Zk(a,b)}}return!1}
 function $k(a,b,c){b=ih(c,b);b=lh(a,b,2);a=ae(a,b,2);null!==a&&(tb(a,2),Ze(a))}function W(a,b,c){if(3===a.tag)$k(a,a,c);else for(;null!==b;){if(3===b.tag){$k(b,a,c);break}else if(1===b.tag){var d=b.stateNode;if("function"===typeof b.type.getDerivedStateFromError||"function"===typeof d.componentDidCatch&&(null===ph||!ph.has(d))){a=ih(c,a);a=oh(b,a,2);b=ae(b,a,2);null!==b&&(tb(b,2),Ze(b));break}}b=b.return}}
 function vh(a,b,c){var d=a.pingCache;if(null===d){d=a.pingCache=new lk;var e=new Set;d.set(b,e)}else e=d.get(b),void 0===e&&(e=new Set,d.set(b,e));e.has(c)||(rk=!0,e.add(c),a=al.bind(null,a,b,c),b.then(a,a))}function al(a,b,c){var d=a.pingCache;null!==d&&d.delete(b);a.pingedLanes|=a.suspendedLanes&c;N===a&&(M&c)===c&&(4===uh||3===uh&&(M&62914560)===M&&300>Ya()-Sj?0===(L&2)&&gf(a,0):tk|=c);Ze(a)}function bl(a,b){0===b&&(b=0===(a.mode&1)?2:rb());a=Ud(a,b);null!==a&&(tb(a,b),Ze(a))}
-function bi(a){var b=a.memoizedState,c=0;null!==b&&(c=b.retryLane);bl(a,c)}function Hj(a,b){var c=0;switch(a.tag){case 13:var d=a.stateNode;var e=a.memoizedState;null!==e&&(c=e.retryLane);break;case 19:d=a.stateNode;break;case 22:d=a.stateNode._retryCache;break;default:throw Error(t(314));}null!==d&&d.delete(b);bl(a,c)}var Vk;
+function bi(a){var b=a.memoizedState,c=0;null!==b&&(c=b.retryLane);bl(a,c)}function Hj(a,b){var c=0;switch(a.tag){case 13:var d=a.stateNode;var e=a.memoizedState;null!==e&&(c=e.retryLane);break;case 19:d=a.stateNode;break;case 22:d=a.stateNode._retryCache;break;default:throw Error(u(314));}null!==d&&d.delete(b);bl(a,c)}var Vk;
 Vk=function(a,b,c){if(null!==a)if(a.memoizedProps!==b.pendingProps||Vc.current)fg=!0;else{if(0===(a.lanes&c)&&0===(b.flags&128))return fg=!1,gi(a,b,c);fg=0!==(a.flags&131072)?!0:!1}else fg=!1,K&&0!==(b.flags&1048576)&&pd(b,id,b.index);b.lanes=0;switch(b.tag){case 2:var d=b.type;Ph(a,b);a=b.pendingProps;var e=Xc(b,Uc.current);Bh(b,c);e=Lf(null,b,d,a,e,c);var f=Uf();b.flags|=1;"object"===typeof e&&null!==e&&"function"===typeof e.render&&void 0===e.$$typeof?(b.tag=1,b.memoizedState=null,b.updateQueue=
-null,Yc(d)?(f=!0,bd(b)):f=!1,b.memoizedState=null!==e.state&&void 0!==e.state?e.state:null,Yd(b),e.updater=dh,b.stateNode=e,e._reactInternals=b,hh(b,d,a,c),b=Qh(null,b,d,!0,f,c)):(b.tag=0,K&&f&&qd(b),zh(null,b,e,c),b=b.child);return b;case 16:d=b.elementType;a:{Ph(a,b);a=b.pendingProps;e=d._init;d=e(d._payload);b.type=d;e=b.tag=cl(d);a=bh(d,a);switch(e){case 0:b=Gh(null,b,d,a,c);break a;case 1:b=Oh(null,b,d,a,c);break a;case 11:b=Ah(null,b,d,a,c);break a;case 14:b=Dh(null,b,d,bh(d.type,a),c);break a}throw Error(t(306,
-d,""));}return b;case 0:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:bh(d,e),Gh(a,b,d,e,c);case 1:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:bh(d,e),Oh(a,b,d,e,c);case 3:a:{Rh(b);if(null===a)throw Error(t(387));e=b.pendingProps;f=b.memoizedState;d=f.element;Zd(a,b);de(b,e,null,c);var g=b.memoizedState;e=g.cache;hi(b,Mh,e);e!==f.cache&&oi(b,Mh,c);e=g.element;if(f.isDehydrated)if(f={element:e,isDehydrated:!1,cache:g.cache},b.updateQueue.baseState=f,b.memoizedState=f,b.flags&256){d=
-ih(Error(t(423)),b);b=Sh(a,b,e,c,d);break a}else if(e!==d){d=ih(Error(t(424)),b);b=Sh(a,b,e,c,d);break a}else for(J=zd(b.stateNode.containerInfo.firstChild),G=b,K=!0,sd=null,td=!0,c=Ee(b,null,e,c),b.child=c;c;)c.flags=c.flags&-3|4096,c=c.sibling;else{Kd();if(e===d){b=Ch(a,b,c);break a}zh(a,b,e,c)}b=b.child}return b;case 26:return Ih(a,b),c=b.memoizedState=dl(b.type,null===a?null:a.memoizedProps,b.pendingProps),null!==a||K||null!==c||(c=b.type,a=b.pendingProps,d=Gi(La.current).createElement(c),d[Cb]=
+null,Yc(d)?(f=!0,bd(b)):f=!1,b.memoizedState=null!==e.state&&void 0!==e.state?e.state:null,Yd(b),e.updater=dh,b.stateNode=e,e._reactInternals=b,hh(b,d,a,c),b=Qh(null,b,d,!0,f,c)):(b.tag=0,K&&f&&qd(b),zh(null,b,e,c),b=b.child);return b;case 16:d=b.elementType;a:{Ph(a,b);a=b.pendingProps;e=d._init;d=e(d._payload);b.type=d;e=b.tag=cl(d);a=bh(d,a);switch(e){case 0:b=Gh(null,b,d,a,c);break a;case 1:b=Oh(null,b,d,a,c);break a;case 11:b=Ah(null,b,d,a,c);break a;case 14:b=Dh(null,b,d,bh(d.type,a),c);break a}throw Error(u(306,
+d,""));}return b;case 0:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:bh(d,e),Gh(a,b,d,e,c);case 1:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:bh(d,e),Oh(a,b,d,e,c);case 3:a:{Rh(b);if(null===a)throw Error(u(387));e=b.pendingProps;f=b.memoizedState;d=f.element;Zd(a,b);de(b,e,null,c);var g=b.memoizedState;e=g.cache;hi(b,Mh,e);e!==f.cache&&oi(b,Mh,c);e=g.element;if(f.isDehydrated)if(f={element:e,isDehydrated:!1,cache:g.cache},b.updateQueue.baseState=f,b.memoizedState=f,b.flags&256){d=
+ih(Error(u(423)),b);b=Sh(a,b,e,c,d);break a}else if(e!==d){d=ih(Error(u(424)),b);b=Sh(a,b,e,c,d);break a}else for(J=zd(b.stateNode.containerInfo.firstChild),G=b,K=!0,sd=null,td=!0,c=Ee(b,null,e,c),b.child=c;c;)c.flags=c.flags&-3|4096,c=c.sibling;else{Kd();if(e===d){b=Ch(a,b,c);break a}zh(a,b,e,c)}b=b.child}return b;case 26:return Ih(a,b),c=b.memoizedState=dl(b.type,null===a?null:a.memoizedProps,b.pendingProps),null!==a||K||null!==c||(c=b.type,a=b.pendingProps,d=Gi(La.current).createElement(c),d[Cb]=
 b,d[Db]=a,Hi(d,c,a),Sb(d),b.stateNode=d),null;case 27:return Sa(b),null===a&&K&&(d=b.stateNode=Fi(b.type,b.pendingProps,La.current),G=b,td=!0,J=zd(d.firstChild)),d=b.pendingProps.children,null!==a||K?zh(a,b,d,c):b.child=De(b,null,d,c),Ih(a,b),b.child;case 5:return Sa(b),null===a&&K&&((e=d=J,e)?xd(b,e)||(Ed(b)&&Fd(),J=Dd(e),f=G,J&&xd(b,J)?ud(f,e):(wd(G,b),K=!1,G=b,J=d)):(Ed(b)&&Fd(),wd(G,b),K=!1,G=b,J=d)),e=b.type,f=b.pendingProps,g=null!==a?a.memoizedProps:null,d=f.children,Id(e,f)?d=null:null!==
 g&&Id(e,g)&&(b.flags|=32),null!==b.memoizedState&&(e=Lf(a,b,Sf,null,null,c),Na._currentValue=e,fg&&null!==a&&a.memoizedState.memoizedState!==e&&oi(b,Na,c)),Ih(a,b),zh(a,b,d,c),b.child;case 6:return null===a&&K&&((d=""!==b.pendingProps,a=c=J,a&&d)?Ad(b,a)||(Ed(b)&&Fd(),J=Dd(a),d=G,J&&Ad(b,J)?ud(d,a):(wd(G,b),K=!1,G=b,J=c)):(Ed(b)&&Fd(),wd(G,b),K=!1,G=b,J=c)),null;case 13:return Wh(a,b,c);case 4:return Oa(b,b.stateNode.containerInfo),d=b.pendingProps,null===a?b.child=De(b,null,d,c):zh(a,b,d,c),b.child;
 case 11:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:bh(d,e),Ah(a,b,d,e,c);case 7:return zh(a,b,b.pendingProps,c),b.child;case 8:return zh(a,b,b.pendingProps.children,c),b.child;case 12:return zh(a,b,b.pendingProps.children,c),b.child;case 10:a:{d=b.type._context;e=b.pendingProps;f=b.memoizedProps;g=e.value;hi(b,d,g);if(null!==f)if(ed(f.value,g)){if(f.children===e.children&&!Vc.current){b=Ch(a,b,c);break a}}else oi(b,d,c);zh(a,b,e.children,c);b=b.child}return b;case 9:return e=b.type,d=
 b.pendingProps.children,Bh(b,c),e=ag(e),d=d(e),b.flags|=1,zh(a,b,d,c),b.child;case 14:return d=b.type,e=bh(d,b.pendingProps),e=bh(d.type,e),Dh(a,b,d,e,c);case 15:return Fh(a,b,b.type,b.pendingProps,c);case 17:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:bh(d,e),Ph(a,b),b.tag=1,Yc(d)?(a=!0,bd(b)):a=!1,Bh(b,c),fh(b,d,e),hh(b,d,e,c),Qh(null,b,d,!0,a,c);case 19:return fi(a,b,c);case 22:return Hh(a,b,c);case 24:return Bh(b,c),d=ag(Mh),null===a?(e=Lh(),null===e&&(e=N,f=Yg(),e.pooledCache=f,f.refCount++,
-null!==f&&(e.pooledCacheLanes|=c),e=f),b.memoizedState={parent:d,cache:e},Yd(b),hi(b,Mh,e)):(0!==(a.lanes&c)&&(Zd(a,b),de(b,null,null,c)),e=a.memoizedState,f=b.memoizedState,e.parent!==d?(e={parent:d,cache:d},b.memoizedState=e,0===b.lanes&&(b.memoizedState=b.updateQueue.baseState=e),hi(b,Mh,d)):(d=f.cache,hi(b,Mh,d),d!==e.cache&&oi(b,Mh,c))),zh(a,b,b.pendingProps.children,c),b.child}throw Error(t(156,b.tag));};function Xk(a,b){return Ua(a,b)}
+null!==f&&(e.pooledCacheLanes|=c),e=f),b.memoizedState={parent:d,cache:e},Yd(b),hi(b,Mh,e)):(0!==(a.lanes&c)&&(Zd(a,b),de(b,null,null,c)),e=a.memoizedState,f=b.memoizedState,e.parent!==d?(e={parent:d,cache:d},b.memoizedState=e,0===b.lanes&&(b.memoizedState=b.updateQueue.baseState=e),hi(b,Mh,d)):(d=f.cache,hi(b,Mh,d),d!==e.cache&&oi(b,Mh,c))),zh(a,b,b.pendingProps.children,c),b.child}throw Error(u(156,b.tag));};function Xk(a,b){return Ua(a,b)}
 function el(a,b,c,d){this.tag=a;this.key=c;this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null;this.index=0;this.refCleanup=this.ref=null;this.pendingProps=b;this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null;this.mode=d;this.subtreeFlags=this.flags=0;this.deletions=null;this.childLanes=this.lanes=0;this.alternate=null}function vd(a,b,c,d){return new el(a,b,c,d)}function Eh(a){a=a.prototype;return!(!a||!a.isReactComponent)}
 function cl(a){if("function"===typeof a)return Eh(a)?1:0;if(void 0!==a&&null!==a){a=a.$$typeof;if(a===va)return 11;if(a===ya)return 14}return 2}
 function xe(a,b){var c=a.alternate;null===c?(c=vd(a.tag,b,a.key,a.mode),c.elementType=a.elementType,c.type=a.type,c.stateNode=a.stateNode,c.alternate=a,a.alternate=c):(c.pendingProps=b,c.type=a.type,c.flags=0,c.subtreeFlags=0,c.deletions=null);c.flags=a.flags&31457280;c.childLanes=a.childLanes;c.lanes=a.lanes;c.child=a.child;c.memoizedProps=a.memoizedProps;c.memoizedState=a.memoizedState;c.updateQueue=a.updateQueue;b=a.dependencies;c.dependencies=null===b?null:{lanes:b.lanes,firstContext:b.firstContext};
@@ -288,18 +287,18 @@ c.sibling=a.sibling;c.index=a.index;c.ref=a.ref;c.refCleanup=a.refCleanup;return
 function Ki(a,b){a.flags&=31457282;var c=a.alternate;null===c?(a.childLanes=0,a.lanes=b,a.child=null,a.subtreeFlags=0,a.memoizedProps=null,a.memoizedState=null,a.updateQueue=null,a.dependencies=null,a.stateNode=null):(a.childLanes=c.childLanes,a.lanes=c.lanes,a.child=c.child,a.subtreeFlags=0,a.deletions=null,a.memoizedProps=c.memoizedProps,a.memoizedState=c.memoizedState,a.updateQueue=c.updateQueue,a.type=c.type,b=c.dependencies,a.dependencies=null===b?null:{lanes:b.lanes,firstContext:b.firstContext});
 return a}
 function ze(a,b,c,d,e,f,g){e=2;d=a;if("function"===typeof a)Eh(a)&&(e=1);else if("string"===typeof a)e=fl(a,c,Ja.current)?26:"html"===a||"head"===a||"body"===a?27:5;else a:switch(a){case pa:return Be(c.children,f,g,b);case qa:e=8;f|=8;0!==(f&1)&&(f|=16);break;case ra:return a=vd(12,c,b,f|2),a.elementType=ra,a.lanes=g,a;case wa:return a=vd(13,c,b,f),a.elementType=wa,a.lanes=g,a;case xa:return a=vd(19,c,b,f),a.elementType=xa,a.lanes=g,a;case Ba:return $h(c,f,g,b);case Ca:case Aa:case Da:return a=vd(24,
-c,b,f),a.elementType=Da,a.lanes=g,a;default:if("object"===typeof a&&null!==a)switch(a.$$typeof){case sa:e=10;break a;case ta:e=9;break a;case va:e=11;break a;case ya:e=14;break a;case za:e=16;d=null;break a}throw Error(t(130,null==a?a:typeof a,""));}b=vd(e,c,b,f);b.elementType=a;b.type=d;b.lanes=g;return b}function Be(a,b,c,d){a=vd(7,a,d,b);a.lanes=c;return a}
-function $h(a,b,c,d){a=vd(22,a,d,b);a.elementType=Ba;a.lanes=c;var e={_visibility:1,_pendingVisibility:1,_pendingMarkers:null,_retryCache:null,_transitions:null,_current:null,detach:function(){var f=e._current;if(null===f)throw Error(t(456));if(0===(e._pendingVisibility&2)){var g=Ud(f,2);null!==g&&(e._pendingVisibility|=2,pg(g,f,2))}},attach:function(){var f=e._current;if(null===f)throw Error(t(456));if(0!==(e._pendingVisibility&2)){var g=Ud(f,2);null!==g&&(e._pendingVisibility&=-3,pg(g,f,2))}}};
+c,b,f),a.elementType=Da,a.lanes=g,a;default:if("object"===typeof a&&null!==a)switch(a.$$typeof){case sa:e=10;break a;case ta:e=9;break a;case va:e=11;break a;case ya:e=14;break a;case za:e=16;d=null;break a}throw Error(u(130,null==a?a:typeof a,""));}b=vd(e,c,b,f);b.elementType=a;b.type=d;b.lanes=g;return b}function Be(a,b,c,d){a=vd(7,a,d,b);a.lanes=c;return a}
+function $h(a,b,c,d){a=vd(22,a,d,b);a.elementType=Ba;a.lanes=c;var e={_visibility:1,_pendingVisibility:1,_pendingMarkers:null,_retryCache:null,_transitions:null,_current:null,detach:function(){var f=e._current;if(null===f)throw Error(u(456));if(0===(e._pendingVisibility&2)){var g=Ud(f,2);null!==g&&(e._pendingVisibility|=2,pg(g,f,2))}},attach:function(){var f=e._current;if(null===f)throw Error(u(456));if(0!==(e._pendingVisibility&2)){var g=Ud(f,2);null!==g&&(e._pendingVisibility&=-3,pg(g,f,2))}}};
 a.stateNode=e;return a}function ye(a,b,c){a=vd(6,a,null,b);a.lanes=c;return a}function Ae(a,b,c){b=vd(4,null!==a.children?a.children:[],a.key,b);b.lanes=c;b.stateNode={containerInfo:a.containerInfo,pendingChildren:null,implementation:a.implementation};return b}
 function gl(a,b,c,d,e,f){this.tag=b;this.containerInfo=a;this.finishedWork=this.pingCache=this.current=this.pendingChildren=null;this.timeoutHandle=-1;this.callbackNode=this.next=this.pendingContext=this.context=this.cancelPendingCommit=null;this.callbackPriority=0;this.expirationTimes=sb(-1);this.entangledLanes=this.shellSuspendCounter=this.errorRecoveryDisabledLanes=this.finishedLanes=this.expiredLanes=this.pingedLanes=this.suspendedLanes=this.pendingLanes=0;this.entanglements=sb(0);this.hiddenUpdates=
 sb(null);this.identifierPrefix=d;this.onRecoverableError=e;this.pooledCache=null;this.pooledCacheLanes=0;this.formState=f;this.incompleteTransitions=new Map}function hl(a,b,c,d,e,f,g,h,l,p,q){a=new gl(a,b,c,h,l,q);1===b?(b=1,!0===f&&(b|=24)):b=0;f=vd(3,null,null,b);a.current=f;f.stateNode=a;b=Yg();b.refCount++;a.pooledCache=b;b.refCount++;f.memoizedState={element:d,isDehydrated:c,cache:b};Yd(f);return a}
 function il(a,b,c){var d=3<arguments.length&&void 0!==arguments[3]?arguments[3]:null;return{$$typeof:oa,key:null==d?null:""+d,children:a,containerInfo:b,implementation:c}}
-function jl(a){if(!a)return Tc;a=a._reactInternals;a:{if(Nc(a)!==a||1!==a.tag)throw Error(t(170));var b=a;do{switch(b.tag){case 3:b=b.stateNode.context;break a;case 1:if(Yc(b.type)){b=b.stateNode.__reactInternalMemoizedMergedChildContext;break a}}b=b.return}while(null!==b);throw Error(t(171));}if(1===a.tag){var c=a.type;if(Yc(c))return ad(a,c,b)}return b}
+function jl(a){if(!a)return Tc;a=a._reactInternals;a:{if(Nc(a)!==a||1!==a.tag)throw Error(u(170));var b=a;do{switch(b.tag){case 3:b=b.stateNode.context;break a;case 1:if(Yc(b.type)){b=b.stateNode.__reactInternalMemoizedMergedChildContext;break a}}b=b.return}while(null!==b);throw Error(u(171));}if(1===a.tag){var c=a.type;if(Yc(c))return ad(a,c,b)}return b}
 function kl(a,b,c,d,e,f,g,h,l,p,q){a=hl(c,d,!0,a,e,f,g,h,l,p,q);a.context=jl(null);c=a.current;d=Xg(c);e=$d(d);e.callback=void 0!==b&&null!==b?b:null;ae(c,e,d);a.current.lanes=d;tb(a,d);Ze(a);return a}function ll(a,b,c,d){var e=b.current,f=Xg(e);c=jl(c);null===b.context?b.context=c:b.pendingContext=c;b=$d(f);b.payload={element:a};d=void 0===d?null:d;null!==d&&(b.callback=d);a=ae(e,b,f);null!==a&&(pg(a,e,f),be(a,e,f));return f}
 function ml(a){a=a.current;if(!a.child)return null;switch(a.child.tag){case 27:case 5:return a.child.stateNode;default:return a.child.stateNode}}function nl(a){switch(a.tag){case 3:var b=a.stateNode;if(b.current.memoizedState.isDehydrated){var c=nb(b.pendingLanes);0!==c&&(xb(b,c),Ze(b),0===(L&6)&&(Li=Ya()+500,bf(!1)))}break;case 13:Jk(function(){var d=Ud(a,2);null!==d&&pg(d,a,2)}),ol(a,2)}}
 function pl(a,b){a=a.memoizedState;if(null!==a&&null!==a.dehydrated){var c=a.retryLane;a.retryLane=0!==c&&c<b?c:b}}function ol(a,b){pl(a,b);(a=a.alternate)&&pl(a,b)}function ql(a){if(13===a.tag){var b=Ud(a,67108864);null!==b&&pg(b,a,67108864);ol(a,67108864)}}function rl(){return null}var sl=!1;function tl(a,b,c){if(sl)return a(b,c);sl=!0;try{return Ik(a,b,c)}finally{if(sl=!1,null!==Ic||null!==Jc)Jk(),Mc()}}
 function ul(a,b){var c=a.stateNode;if(null===c)return null;var d=Qb(c);if(null===d)return null;c=d[b];a:switch(b){case "onClick":case "onClickCapture":case "onDoubleClick":case "onDoubleClickCapture":case "onMouseDown":case "onMouseDownCapture":case "onMouseMove":case "onMouseMoveCapture":case "onMouseUp":case "onMouseUpCapture":case "onMouseEnter":(d=!d.disabled)||(a=a.type,d=!("button"===a||"input"===a||"select"===a||"textarea"===a));a=!d;break a;default:a=!1}if(a)return null;if(c&&"function"!==
-typeof c)throw Error(t(231,b,typeof c));return c}var vl=!1;if(Xb)try{var wl={};Object.defineProperty(wl,"passive",{get:function(){vl=!0}});window.addEventListener("test",wl,wl);window.removeEventListener("test",wl,wl)}catch(a){vl=!1}function xl(a){var b=a.keyCode;"charCode"in a?(a=a.charCode,0===a&&13===b&&(a=13)):a=b;10===a&&(a=13);return 32<=a||13===a?a:0}function yl(){return!0}function zl(){return!1}
+typeof c)throw Error(u(231,b,typeof c));return c}var vl=!1;if(Xb)try{var wl={};Object.defineProperty(wl,"passive",{get:function(){vl=!0}});window.addEventListener("test",wl,wl);window.removeEventListener("test",wl,wl)}catch(a){vl=!1}function xl(a){var b=a.keyCode;"charCode"in a?(a=a.charCode,0===a&&13===b&&(a=13)):a=b;10===a&&(a=13);return 32<=a||13===a?a:0}function yl(){return!0}function zl(){return!1}
 function Al(a){function b(c,d,e,f,g){this._reactName=c;this._targetInst=e;this.type=d;this.nativeEvent=f;this.target=g;this.currentTarget=null;for(var h in a)a.hasOwnProperty(h)&&(c=a[h],this[h]=c?c(f):f[h]);this.isDefaultPrevented=(null!=f.defaultPrevented?f.defaultPrevented:!1===f.returnValue)?yl:zl;this.isPropagationStopped=zl;return this}B(b.prototype,{preventDefault:function(){this.defaultPrevented=!0;var c=this.nativeEvent;c&&(c.preventDefault?c.preventDefault():"unknown"!==typeof c.returnValue&&
 (c.returnValue=!1),this.isDefaultPrevented=yl)},stopPropagation:function(){var c=this.nativeEvent;c&&(c.stopPropagation?c.stopPropagation():"unknown"!==typeof c.cancelBubble&&(c.cancelBubble=!0),this.isPropagationStopped=yl)},persist:function(){},isPersistent:yl});return b}
 var Bl={eventPhase:0,bubbles:0,cancelable:0,timeStamp:function(a){return a.timeStamp||Date.now()},defaultPrevented:0,isTrusted:0},Cl=Al(Bl),Dl=B({},Bl,{view:0,detail:0}),El=Al(Dl),Fl,Gl,Hl,Jl=B({},Dl,{screenX:0,screenY:0,clientX:0,clientY:0,pageX:0,pageY:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,getModifierState:Il,button:0,buttons:0,relatedTarget:function(a){return void 0===a.relatedTarget?a.fromElement===a.srcElement?a.toElement:a.fromElement:a.relatedTarget},movementX:function(a){if("movementX"in
@@ -345,37 +344,37 @@ function gn(a,b){b=0!==(b&4);for(var c=0;c<a.length;c++){var d=a[c],e=d.event;d=
 function Y(a,b){var c=b[Fb];void 0===c&&(c=b[Fb]=new Set);var d=a+"__bubble";c.has(d)||(Wn(b,a,2,!1),c.add(d))}function Xn(a,b,c){var d=0;b&&(d|=4);Wn(c,a,d,b)}var Yn="_reactListening"+Math.random().toString(36).slice(2);function Ji(a){if(!a[Yn]){a[Yn]=!0;Tb.forEach(function(c){"selectionchange"!==c&&(Un.has(c)||Xn(c,!1,a),Xn(c,!0,a))});var b=9===a.nodeType?a:a.ownerDocument;null===b||b[Yn]||(b[Yn]=!0,Xn("selectionchange",!1,b))}}
 function Wn(a,b,c,d){switch(Ak(b)){case 2:var e=Em;break;case 8:e=Gm;break;default:e=Fm}c=e.bind(null,b,c,a);e=void 0;!vl||"touchstart"!==b&&"touchmove"!==b&&"wheel"!==b||(e=!0);d?void 0!==e?a.addEventListener(b,c,{capture:!0,passive:e}):a.addEventListener(b,c,!0):void 0!==e?a.addEventListener(b,c,{passive:e}):a.addEventListener(b,c,!1)}
 function Hm(a,b,c,d,e){var f=d;if(0===(b&1)&&0===(b&2)&&null!==d)a:for(;;){if(null===d)return;var g=d.tag;if(3===g||4===g){var h=d.stateNode.containerInfo;if(h===e||8===h.nodeType&&h.parentNode===e)break;if(4===g)for(g=d.return;null!==g;){var l=g.tag;if(3===l||4===l)if(l=g.stateNode.containerInfo,l===e||8===l.nodeType&&l.parentNode===e)return;g=g.return}for(;null!==h;){g=Mb(h);if(null===g)return;l=g.tag;if(5===l||6===l||26===l||27===l){d=f=g;continue a}h=h.parentNode}}d=d.return}tl(function(){var p=
-f,q=Hc(c),w=[];a:{var r=Mn.get(a);if(void 0!==r){var u=Cl,z=a;switch(a){case "keypress":if(0===xl(c))break a;case "keydown":case "keyup":u=$l;break;case "focusin":z="focus";u=Ol;break;case "focusout":z="blur";u=Ol;break;case "beforeblur":case "afterblur":u=Ol;break;case "click":if(2===c.button)break a;case "auxclick":case "dblclick":case "mousedown":case "mousemove":case "mouseup":case "mouseout":case "mouseover":case "contextmenu":u=Kl;break;case "drag":case "dragend":case "dragenter":case "dragexit":case "dragleave":case "dragover":case "dragstart":case "drop":u=
-Ml;break;case "touchcancel":case "touchend":case "touchmove":case "touchstart":u=dm;break;case In:case Jn:case Kn:u=Ql;break;case Ln:u=fm;break;case "scroll":case "scrollend":u=El;break;case "wheel":u=hm;break;case "copy":case "cut":case "paste":u=Sl;break;case "gotpointercapture":case "lostpointercapture":case "pointercancel":case "pointerdown":case "pointermove":case "pointerout":case "pointerover":case "pointerup":u=bm}var C=0!==(b&4),V=!C&&("scroll"===a||"scrollend"===a),R=C?null!==r?r+"Capture":
-null:r;C=[];for(var m=p,k;null!==m;){var n=m;k=n.stateNode;n=n.tag;5!==n&&26!==n&&27!==n||null===k||null===R||(n=ul(m,R),null!=n&&C.push(Zn(m,n,k)));if(V)break;m=m.return}0<C.length&&(r=new u(r,z,null,c,q),w.push({event:r,listeners:C}))}}if(0===(b&7)){a:{r="mouseover"===a||"pointerover"===a;u="mouseout"===a||"pointerout"===a;if(r&&c!==Gc&&(z=c.relatedTarget||c.fromElement)&&(Mb(z)||z[Eb]))break a;if(u||r){r=q.window===q?q:(r=q.ownerDocument)?r.defaultView||r.parentWindow:window;if(u){if(z=c.relatedTarget||
-c.toElement,u=p,z=z?Mb(z):null,null!==z&&(V=Nc(z),C=z.tag,z!==V||5!==C&&27!==C&&6!==C))z=null}else u=null,z=p;if(u!==z){C=Kl;n="onMouseLeave";R="onMouseEnter";m="mouse";if("pointerout"===a||"pointerover"===a)C=bm,n="onPointerLeave",R="onPointerEnter",m="pointer";V=null==u?r:Pb(u);k=null==z?r:Pb(z);r=new C(n,m+"leave",u,c,q);r.target=V;r.relatedTarget=k;n=null;Mb(q)===p&&(C=new C(R,m+"enter",z,c,q),C.target=k,C.relatedTarget=V,n=C);V=n;if(u&&z)b:{C=u;R=z;m=0;for(k=C;k;k=$n(k))m++;k=0;for(n=R;n;n=$n(n))k++;
-for(;0<m-k;)C=$n(C),m--;for(;0<k-m;)R=$n(R),k--;for(;m--;){if(C===R||null!==R&&C===R.alternate)break b;C=$n(C);R=$n(R)}C=null}else C=null;null!==u&&ao(w,r,u,C,!1);null!==z&&null!==V&&ao(w,V,z,C,!0)}}}a:{r=p?Pb(p):window;u=r.nodeName&&r.nodeName.toLowerCase();if("select"===u||"input"===u&&"file"===r.type)var v=jn;else if(an(r))if(kn)v=tn;else{v=rn;var x=qn}else u=r.nodeName,!u||"input"!==u.toLowerCase()||"checkbox"!==r.type&&"radio"!==r.type?p&&Ec(p.elementType)&&(v=jn):v=sn;if(v&&(v=v(a,p))){bn(w,
+f,q=Hc(c),w=[];a:{var r=Mn.get(a);if(void 0!==r){var t=Cl,z=a;switch(a){case "keypress":if(0===xl(c))break a;case "keydown":case "keyup":t=$l;break;case "focusin":z="focus";t=Ol;break;case "focusout":z="blur";t=Ol;break;case "beforeblur":case "afterblur":t=Ol;break;case "click":if(2===c.button)break a;case "auxclick":case "dblclick":case "mousedown":case "mousemove":case "mouseup":case "mouseout":case "mouseover":case "contextmenu":t=Kl;break;case "drag":case "dragend":case "dragenter":case "dragexit":case "dragleave":case "dragover":case "dragstart":case "drop":t=
+Ml;break;case "touchcancel":case "touchend":case "touchmove":case "touchstart":t=dm;break;case In:case Jn:case Kn:t=Ql;break;case Ln:t=fm;break;case "scroll":case "scrollend":t=El;break;case "wheel":t=hm;break;case "copy":case "cut":case "paste":t=Sl;break;case "gotpointercapture":case "lostpointercapture":case "pointercancel":case "pointerdown":case "pointermove":case "pointerout":case "pointerover":case "pointerup":t=bm}var C=0!==(b&4),V=!C&&("scroll"===a||"scrollend"===a),R=C?null!==r?r+"Capture":
+null:r;C=[];for(var m=p,k;null!==m;){var n=m;k=n.stateNode;n=n.tag;5!==n&&26!==n&&27!==n||null===k||null===R||(n=ul(m,R),null!=n&&C.push(Zn(m,n,k)));if(V)break;m=m.return}0<C.length&&(r=new t(r,z,null,c,q),w.push({event:r,listeners:C}))}}if(0===(b&7)){a:{r="mouseover"===a||"pointerover"===a;t="mouseout"===a||"pointerout"===a;if(r&&c!==Gc&&(z=c.relatedTarget||c.fromElement)&&(Mb(z)||z[Eb]))break a;if(t||r){r=q.window===q?q:(r=q.ownerDocument)?r.defaultView||r.parentWindow:window;if(t){if(z=c.relatedTarget||
+c.toElement,t=p,z=z?Mb(z):null,null!==z&&(V=Nc(z),C=z.tag,z!==V||5!==C&&27!==C&&6!==C))z=null}else t=null,z=p;if(t!==z){C=Kl;n="onMouseLeave";R="onMouseEnter";m="mouse";if("pointerout"===a||"pointerover"===a)C=bm,n="onPointerLeave",R="onPointerEnter",m="pointer";V=null==t?r:Pb(t);k=null==z?r:Pb(z);r=new C(n,m+"leave",t,c,q);r.target=V;r.relatedTarget=k;n=null;Mb(q)===p&&(C=new C(R,m+"enter",z,c,q),C.target=k,C.relatedTarget=V,n=C);V=n;if(t&&z)b:{C=t;R=z;m=0;for(k=C;k;k=$n(k))m++;k=0;for(n=R;n;n=$n(n))k++;
+for(;0<m-k;)C=$n(C),m--;for(;0<k-m;)R=$n(R),k--;for(;m--;){if(C===R||null!==R&&C===R.alternate)break b;C=$n(C);R=$n(R)}C=null}else C=null;null!==t&&ao(w,r,t,C,!1);null!==z&&null!==V&&ao(w,V,z,C,!0)}}}a:{r=p?Pb(p):window;t=r.nodeName&&r.nodeName.toLowerCase();if("select"===t||"input"===t&&"file"===r.type)var v=jn;else if(an(r))if(kn)v=tn;else{v=rn;var x=qn}else t=r.nodeName,!t||"input"!==t.toLowerCase()||"checkbox"!==r.type&&"radio"!==r.type?p&&Ec(p.elementType)&&(v=jn):v=sn;if(v&&(v=v(a,p))){bn(w,
 v,c,q);break a}x&&x(a,r,p);"focusout"===a&&p&&"number"===r.type&&null!=p.memoizedProps.value&&uc(r,"number",r.value)}x=p?Pb(p):window;switch(a){case "focusin":if(an(x)||"true"===x.contentEditable)yn=x,zn=p,An=null;break;case "focusout":An=zn=yn=null;break;case "mousedown":Bn=!0;break;case "contextmenu":case "mouseup":case "dragend":Bn=!1;Cn(w,c,q);break;case "selectionchange":if(xn)break;case "keydown":case "keyup":Cn(w,c,q)}var A;if(Om)b:{switch(a){case "compositionstart":var y="onCompositionStart";
 break b;case "compositionend":y="onCompositionEnd";break b;case "compositionupdate":y="onCompositionUpdate";break b}y=void 0}else Xm?Vm(a,c)&&(y="onCompositionEnd"):"keydown"===a&&229===c.keyCode&&(y="onCompositionStart");y&&(Sm&&"ko"!==c.locale&&(Xm||"onCompositionStart"!==y?"onCompositionEnd"===y&&Xm&&(A=Mm()):(Jm=q,Km="value"in Jm?Jm.value:Jm.textContent,Xm=!0)),x=cn(p,y),0<x.length&&(y=new Ul(y,a,null,c,q),w.push({event:y,listeners:x}),A?y.data=A:(A=Wm(c),null!==A&&(y.data=A))));if(A=Rm?Ym(a,
 c):Zm(a,c))y=cn(p,"onBeforeInput"),0<y.length&&(x=new Ul("onBeforeInput","beforeinput",null,c,q),w.push({event:x,listeners:y}),x.data=A);im(w,a,p,c,q)}gn(w,b)})}function Zn(a,b,c){return{instance:a,listener:b,currentTarget:c}}function cn(a,b){for(var c=b+"Capture",d=[];null!==a;){var e=a,f=e.stateNode;e=e.tag;5!==e&&26!==e&&27!==e||null===f||(e=ul(a,c),null!=e&&d.unshift(Zn(a,e,f)),e=ul(a,b),null!=e&&d.push(Zn(a,e,f)));a=a.return}return d}
 function $n(a){if(null===a)return null;do a=a.return;while(a&&5!==a.tag&&27!==a.tag);return a?a:null}function ao(a,b,c,d,e){for(var f=b._reactName,g=[];null!==c&&c!==d;){var h=c,l=h.alternate,p=h.stateNode;h=h.tag;if(null!==l&&l===d)break;5!==h&&26!==h&&27!==h||null===p||(l=p,e?(p=ul(c,f),null!=p&&g.unshift(Zn(c,p,l))):e||(p=ul(c,f),null!=p&&g.push(Zn(c,p,l))));c=c.return}0!==g.length&&a.push({event:b,listeners:g})}var bo=/\r\n?/g,co=/\u0000|\uFFFD/g;
-function eo(a){return("string"===typeof a?a:""+a).replace(bo,"\n").replace(co,"")}function Ii(a,b,c){b=eo(b);if(eo(a)!==b&&c)throw Error(t(425));}function xj(){}
+function eo(a){return("string"===typeof a?a:""+a).replace(bo,"\n").replace(co,"")}function Ii(a,b,c){b=eo(b);if(eo(a)!==b&&c)throw Error(u(425));}function xj(){}
 function Z(a,b,c,d,e,f){switch(c){case "children":"string"===typeof d?"body"===b||"textarea"===b&&""===d||Ac(a,d):"number"===typeof d&&"body"!==b&&Ac(a,""+d);break;case "className":cc(a,"class",d);break;case "tabIndex":cc(a,"tabindex",d);break;case "dir":case "role":case "viewBox":case "width":case "height":cc(a,c,d);break;case "style":Dc(a,d,f);break;case "src":case "href":if(""===d){a.removeAttribute(c);break}if(null==d||"function"===typeof d||"symbol"===typeof d||"boolean"===typeof d){a.removeAttribute(c);
 break}a.setAttribute(c,""+d);break;case "action":case "formAction":if("function"===typeof d){a.setAttribute(c,"javascript:throw new Error('A React form was unexpectedly submitted. If you called form.submit() manually, consider using form.requestSubmit() instead. If you\\'re trying to use event.stopPropagation() in a submit event handler, consider also calling event.preventDefault().')");break}else"function"===typeof f&&("formAction"===c?("input"!==b&&Z(a,b,"name",e.name,e,null),Z(a,b,"formEncType",
 e.formEncType,e,null),Z(a,b,"formMethod",e.formMethod,e,null),Z(a,b,"formTarget",e.formTarget,e,null)):(Z(a,b,"encType",e.encType,e,null),Z(a,b,"method",e.method,e,null),Z(a,b,"target",e.target,e,null)));if(null==d||"symbol"===typeof d||"boolean"===typeof d){a.removeAttribute(c);break}a.setAttribute(c,""+d);break;case "onClick":null!=d&&(a.onclick=xj);break;case "onScroll":null!=d&&Y("scroll",a);break;case "onScrollEnd":null!=d&&Y("scrollend",a);break;case "dangerouslySetInnerHTML":if(null!=d){if("object"!==
-typeof d||!("__html"in d))throw Error(t(61));d=d.__html;if(null!=d){if(null!=e.children)throw Error(t(60));a.innerHTML=d}}break;case "multiple":a.multiple=d&&"function"!==typeof d&&"symbol"!==typeof d;break;case "muted":a.muted=d&&"function"!==typeof d&&"symbol"!==typeof d;break;case "suppressContentEditableWarning":case "suppressHydrationWarning":case "defaultValue":case "defaultChecked":case "innerHTML":break;case "autoFocus":break;case "xlinkHref":if(null==d||"function"===typeof d||"boolean"===
+typeof d||!("__html"in d))throw Error(u(61));d=d.__html;if(null!=d){if(null!=e.children)throw Error(u(60));a.innerHTML=d}}break;case "multiple":a.multiple=d&&"function"!==typeof d&&"symbol"!==typeof d;break;case "muted":a.muted=d&&"function"!==typeof d&&"symbol"!==typeof d;break;case "suppressContentEditableWarning":case "suppressHydrationWarning":case "defaultValue":case "defaultChecked":case "innerHTML":break;case "autoFocus":break;case "xlinkHref":if(null==d||"function"===typeof d||"boolean"===
 typeof d||"symbol"===typeof d){a.removeAttribute("xlink:href");break}a.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",""+d);break;case "contentEditable":case "spellCheck":case "draggable":case "value":case "autoReverse":case "externalResourcesRequired":case "focusable":case "preserveAlpha":null!=d&&"function"!==typeof d&&"symbol"!==typeof d?a.setAttribute(c,""+d):a.removeAttribute(c);break;case "allowFullScreen":case "async":case "autoPlay":case "controls":case "default":case "defer":case "disabled":case "disablePictureInPicture":case "disableRemotePlayback":case "formNoValidate":case "hidden":case "loop":case "noModule":case "noValidate":case "open":case "playsInline":case "readOnly":case "required":case "reversed":case "scoped":case "seamless":case "itemScope":d&&
 "function"!==typeof d&&"symbol"!==typeof d?a.setAttribute(c,""):a.removeAttribute(c);break;case "capture":case "download":!0===d?a.setAttribute(c,""):!1!==d&&null!=d&&"function"!==typeof d&&"symbol"!==typeof d?a.setAttribute(c,d):a.removeAttribute(c);break;case "cols":case "rows":case "size":case "span":null!=d&&"function"!==typeof d&&"symbol"!==typeof d&&!isNaN(d)&&1<=d?a.setAttribute(c,d):a.removeAttribute(c);break;case "rowSpan":case "start":null==d||"function"===typeof d||"symbol"===typeof d||
 isNaN(d)?a.removeAttribute(c):a.setAttribute(c,d);break;case "xlinkActuate":dc(a,"http://www.w3.org/1999/xlink","xlink:actuate",d);break;case "xlinkArcrole":dc(a,"http://www.w3.org/1999/xlink","xlink:arcrole",d);break;case "xlinkRole":dc(a,"http://www.w3.org/1999/xlink","xlink:role",d);break;case "xlinkShow":dc(a,"http://www.w3.org/1999/xlink","xlink:show",d);break;case "xlinkTitle":dc(a,"http://www.w3.org/1999/xlink","xlink:title",d);break;case "xlinkType":dc(a,"http://www.w3.org/1999/xlink","xlink:type",
 d);break;case "xmlBase":dc(a,"http://www.w3.org/XML/1998/namespace","xml:base",d);break;case "xmlLang":dc(a,"http://www.w3.org/XML/1998/namespace","xml:lang",d);break;case "xmlSpace":dc(a,"http://www.w3.org/XML/1998/namespace","xml:space",d);break;case "is":bc(a,"is",d);break;case "innerText":case "textContent":break;default:if(!(2<c.length)||"o"!==c[0]&&"O"!==c[0]||"n"!==c[1]&&"N"!==c[1])e=Fc.get(c)||c,bc(a,e,d)}}
-function fo(a,b,c,d,e,f){switch(c){case "style":Dc(a,d,f);break;case "dangerouslySetInnerHTML":if(null!=d){if("object"!==typeof d||!("__html"in d))throw Error(t(61));c=d.__html;if(null!=c){if(null!=e.children)throw Error(t(60));a.innerHTML=c}}break;case "children":"string"===typeof d?Ac(a,d):"number"===typeof d&&Ac(a,""+d);break;case "onScroll":null!=d&&Y("scroll",a);break;case "onScrollEnd":null!=d&&Y("scrollend",a);break;case "onClick":null!=d&&(a.onclick=xj);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":case "innerHTML":break;
+function fo(a,b,c,d,e,f){switch(c){case "style":Dc(a,d,f);break;case "dangerouslySetInnerHTML":if(null!=d){if("object"!==typeof d||!("__html"in d))throw Error(u(61));c=d.__html;if(null!=c){if(null!=e.children)throw Error(u(60));a.innerHTML=c}}break;case "children":"string"===typeof d?Ac(a,d):"number"===typeof d&&Ac(a,""+d);break;case "onScroll":null!=d&&Y("scroll",a);break;case "onScrollEnd":null!=d&&Y("scrollend",a);break;case "onClick":null!=d&&(a.onclick=xj);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":case "innerHTML":break;
 case "innerText":case "textContent":break;default:if(!Ub.hasOwnProperty(c))a:{if("o"===c[0]&&"n"===c[1]&&(e=c.endsWith("Capture"),b=c.slice(2,e?c.length-7:void 0),f=Qb(a),f=null!=f?f[c]:null,"function"===typeof f&&a.removeEventListener(b,f,e),"function"===typeof d)){"function"!==typeof f&&null!==f&&(c in a?a[c]=null:a.hasAttribute(c)&&a.removeAttribute(c));a.addEventListener(b,d,e);break a}c in a?a[c]=d:!0===d?a.setAttribute(c,""):bc(a,c,d)}}}
-function Hi(a,b,c){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "input":Y("invalid",a);var d=null,e=null,f=null,g=null,h=null,l=null;for(q in c)if(c.hasOwnProperty(q)){var p=c[q];if(null!=p)switch(q){case "name":d=p;break;case "type":e=p;break;case "checked":h=p;break;case "defaultChecked":l=p;break;case "value":f=p;break;case "defaultValue":g=p;break;case "children":case "dangerouslySetInnerHTML":if(null!=p)throw Error(t(137,b));break;default:Z(a,
+function Hi(a,b,c){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "input":Y("invalid",a);var d=null,e=null,f=null,g=null,h=null,l=null;for(q in c)if(c.hasOwnProperty(q)){var p=c[q];if(null!=p)switch(q){case "name":d=p;break;case "type":e=p;break;case "checked":h=p;break;case "defaultChecked":l=p;break;case "value":f=p;break;case "defaultValue":g=p;break;case "children":case "dangerouslySetInnerHTML":if(null!=p)throw Error(u(137,b));break;default:Z(a,
 b,q,p,c,null)}}vc(a,f,g,h,l,e,d,!1);oc(a);return;case "select":Y("invalid",a);var q=e=f=null;for(d in c)if(c.hasOwnProperty(d)&&(g=c[d],null!=g))switch(d){case "value":f=g;break;case "defaultValue":e=g;break;case "multiple":q=g;default:Z(a,b,d,g,c,null)}b=f;c=e;a.multiple=!!q;null!=b?xc(a,!!q,b,!1):null!=c&&xc(a,!!q,c,!0);return;case "textarea":Y("invalid",a);f=d=q=null;for(e in c)if(c.hasOwnProperty(e)&&(g=c[e],null!=g))switch(e){case "value":q=g;break;case "defaultValue":d=g;break;case "children":f=
-g;break;case "dangerouslySetInnerHTML":if(null!=g)throw Error(t(91));break;default:Z(a,b,e,g,c,null)}zc(a,q,d,f);oc(a);return;case "option":for(g in c)if(c.hasOwnProperty(g)&&(q=c[g],null!=q))switch(g){case "selected":a.selected=q&&"function"!==typeof q&&"symbol"!==typeof q;break;default:Z(a,b,g,q,c,null)}return;case "dialog":Y("cancel",a);Y("close",a);break;case "iframe":case "object":Y("load",a);break;case "video":case "audio":for(q=0;q<Tn.length;q++)Y(Tn[q],a);break;case "image":Y("error",a);Y("load",
-a);break;case "details":Y("toggle",a);break;case "embed":case "source":case "img":case "link":Y("error",a),Y("load",a);case "area":case "base":case "br":case "col":case "hr":case "keygen":case "meta":case "param":case "track":case "wbr":case "menuitem":for(h in c)if(c.hasOwnProperty(h)&&(q=c[h],null!=q))switch(h){case "children":case "dangerouslySetInnerHTML":throw Error(t(137,b));default:Z(a,b,h,q,c,null)}return;default:if(Ec(b)){for(l in c)c.hasOwnProperty(l)&&(q=c[l],null!=q&&fo(a,b,l,q,c,null));
+g;break;case "dangerouslySetInnerHTML":if(null!=g)throw Error(u(91));break;default:Z(a,b,e,g,c,null)}zc(a,q,d,f);oc(a);return;case "option":for(g in c)if(c.hasOwnProperty(g)&&(q=c[g],null!=q))switch(g){case "selected":a.selected=q&&"function"!==typeof q&&"symbol"!==typeof q;break;default:Z(a,b,g,q,c,null)}return;case "dialog":Y("cancel",a);Y("close",a);break;case "iframe":case "object":Y("load",a);break;case "video":case "audio":for(q=0;q<Tn.length;q++)Y(Tn[q],a);break;case "image":Y("error",a);Y("load",
+a);break;case "details":Y("toggle",a);break;case "embed":case "source":case "img":case "link":Y("error",a),Y("load",a);case "area":case "base":case "br":case "col":case "hr":case "keygen":case "meta":case "param":case "track":case "wbr":case "menuitem":for(h in c)if(c.hasOwnProperty(h)&&(q=c[h],null!=q))switch(h){case "children":case "dangerouslySetInnerHTML":throw Error(u(137,b));default:Z(a,b,h,q,c,null)}return;default:if(Ec(b)){for(l in c)c.hasOwnProperty(l)&&(q=c[l],null!=q&&fo(a,b,l,q,c,null));
 return}}for(f in c)c.hasOwnProperty(f)&&(q=c[f],null!=q&&Z(a,b,f,q,c,null))}
-function Pj(a,b,c,d){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "input":var e=null,f=null,g=null,h=null,l=null,p=null,q=null;for(u in c){var w=c[u];if(c.hasOwnProperty(u)&&null!=w)switch(u){case "checked":break;case "value":break;case "defaultValue":l=w;default:d.hasOwnProperty(u)||Z(a,b,u,null,d,w)}}for(var r in d){var u=d[r];w=c[r];if(d.hasOwnProperty(r)&&(null!=u||null!=w))switch(r){case "type":f=u;break;case "name":e=u;break;case "checked":p=
-u;break;case "defaultChecked":q=u;break;case "value":g=u;break;case "defaultValue":h=u;break;case "children":case "dangerouslySetInnerHTML":if(null!=u)throw Error(t(137,b));break;default:u!==w&&Z(a,b,r,u,d,w)}}tc(a,g,h,l,p,q,f,e);return;case "select":u=g=h=r=null;for(f in c)if(l=c[f],c.hasOwnProperty(f)&&null!=l)switch(f){case "value":break;case "multiple":u=l;default:d.hasOwnProperty(f)||Z(a,b,f,null,d,l)}for(e in d)if(f=d[e],l=c[e],d.hasOwnProperty(e)&&(null!=f||null!=l))switch(e){case "value":r=
-f;break;case "defaultValue":h=f;break;case "multiple":g=f;default:f!==l&&Z(a,b,e,f,d,l)}b=h;c=g;d=u;null!=r?xc(a,!!c,r,!1):!!d!==!!c&&(null!=b?xc(a,!!c,b,!0):xc(a,!!c,c?[]:"",!1));return;case "textarea":u=r=null;for(h in c)if(e=c[h],c.hasOwnProperty(h)&&null!=e&&!d.hasOwnProperty(h))switch(h){case "value":break;case "children":break;default:Z(a,b,h,null,d,e)}for(g in d)if(e=d[g],f=c[g],d.hasOwnProperty(g)&&(null!=e||null!=f))switch(g){case "value":r=e;break;case "defaultValue":u=e;break;case "children":break;
-case "dangerouslySetInnerHTML":if(null!=e)throw Error(t(91));break;default:e!==f&&Z(a,b,g,e,d,f)}yc(a,r,u);return;case "option":for(var z in c)if(r=c[z],c.hasOwnProperty(z)&&null!=r&&!d.hasOwnProperty(z))switch(z){case "selected":a.selected=!1;break;default:Z(a,b,z,null,d,r)}for(l in d)if(r=d[l],u=c[l],d.hasOwnProperty(l)&&r!==u&&(null!=r||null!=u))switch(l){case "selected":a.selected=r&&"function"!==typeof r&&"symbol"!==typeof r;break;default:Z(a,b,l,r,d,u)}return;case "img":case "link":case "area":case "base":case "br":case "col":case "embed":case "hr":case "keygen":case "meta":case "param":case "source":case "track":case "wbr":case "menuitem":for(var C in c)r=
-c[C],c.hasOwnProperty(C)&&null!=r&&!d.hasOwnProperty(C)&&Z(a,b,C,null,d,r);for(p in d)if(r=d[p],u=c[p],d.hasOwnProperty(p)&&r!==u&&(null!=r||null!=u))switch(p){case "children":case "dangerouslySetInnerHTML":if(null!=r)throw Error(t(137,b));break;default:Z(a,b,p,r,d,u)}return;default:if(Ec(b)){for(var V in c)r=c[V],c.hasOwnProperty(V)&&null!=r&&!d.hasOwnProperty(V)&&fo(a,b,V,null,d,r);for(q in d)r=d[q],u=c[q],!d.hasOwnProperty(q)||r===u||null==r&&null==u||fo(a,b,q,r,d,u);return}}for(var R in c)r=c[R],
-c.hasOwnProperty(R)&&null!=r&&!d.hasOwnProperty(R)&&Z(a,b,R,null,d,r);for(w in d)r=d[w],u=c[w],!d.hasOwnProperty(w)||r===u||null==r&&null==u||Z(a,b,w,r,d,u)}var ej=null,ij=null;function Gi(a){return 9===a.nodeType?a:a.ownerDocument}function Pa(a){switch(a){case "http://www.w3.org/2000/svg":return 1;case "http://www.w3.org/1998/Math/MathML":return 2;default:return 0}}
+function Pj(a,b,c,d){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "input":var e=null,f=null,g=null,h=null,l=null,p=null,q=null;for(t in c){var w=c[t];if(c.hasOwnProperty(t)&&null!=w)switch(t){case "checked":break;case "value":break;case "defaultValue":l=w;default:d.hasOwnProperty(t)||Z(a,b,t,null,d,w)}}for(var r in d){var t=d[r];w=c[r];if(d.hasOwnProperty(r)&&(null!=t||null!=w))switch(r){case "type":f=t;break;case "name":e=t;break;case "checked":p=
+t;break;case "defaultChecked":q=t;break;case "value":g=t;break;case "defaultValue":h=t;break;case "children":case "dangerouslySetInnerHTML":if(null!=t)throw Error(u(137,b));break;default:t!==w&&Z(a,b,r,t,d,w)}}tc(a,g,h,l,p,q,f,e);return;case "select":t=g=h=r=null;for(f in c)if(l=c[f],c.hasOwnProperty(f)&&null!=l)switch(f){case "value":break;case "multiple":t=l;default:d.hasOwnProperty(f)||Z(a,b,f,null,d,l)}for(e in d)if(f=d[e],l=c[e],d.hasOwnProperty(e)&&(null!=f||null!=l))switch(e){case "value":r=
+f;break;case "defaultValue":h=f;break;case "multiple":g=f;default:f!==l&&Z(a,b,e,f,d,l)}b=h;c=g;d=t;null!=r?xc(a,!!c,r,!1):!!d!==!!c&&(null!=b?xc(a,!!c,b,!0):xc(a,!!c,c?[]:"",!1));return;case "textarea":t=r=null;for(h in c)if(e=c[h],c.hasOwnProperty(h)&&null!=e&&!d.hasOwnProperty(h))switch(h){case "value":break;case "children":break;default:Z(a,b,h,null,d,e)}for(g in d)if(e=d[g],f=c[g],d.hasOwnProperty(g)&&(null!=e||null!=f))switch(g){case "value":r=e;break;case "defaultValue":t=e;break;case "children":break;
+case "dangerouslySetInnerHTML":if(null!=e)throw Error(u(91));break;default:e!==f&&Z(a,b,g,e,d,f)}yc(a,r,t);return;case "option":for(var z in c)if(r=c[z],c.hasOwnProperty(z)&&null!=r&&!d.hasOwnProperty(z))switch(z){case "selected":a.selected=!1;break;default:Z(a,b,z,null,d,r)}for(l in d)if(r=d[l],t=c[l],d.hasOwnProperty(l)&&r!==t&&(null!=r||null!=t))switch(l){case "selected":a.selected=r&&"function"!==typeof r&&"symbol"!==typeof r;break;default:Z(a,b,l,r,d,t)}return;case "img":case "link":case "area":case "base":case "br":case "col":case "embed":case "hr":case "keygen":case "meta":case "param":case "source":case "track":case "wbr":case "menuitem":for(var C in c)r=
+c[C],c.hasOwnProperty(C)&&null!=r&&!d.hasOwnProperty(C)&&Z(a,b,C,null,d,r);for(p in d)if(r=d[p],t=c[p],d.hasOwnProperty(p)&&r!==t&&(null!=r||null!=t))switch(p){case "children":case "dangerouslySetInnerHTML":if(null!=r)throw Error(u(137,b));break;default:Z(a,b,p,r,d,t)}return;default:if(Ec(b)){for(var V in c)r=c[V],c.hasOwnProperty(V)&&null!=r&&!d.hasOwnProperty(V)&&fo(a,b,V,null,d,r);for(q in d)r=d[q],t=c[q],!d.hasOwnProperty(q)||r===t||null==r&&null==t||fo(a,b,q,r,d,t);return}}for(var R in c)r=c[R],
+c.hasOwnProperty(R)&&null!=r&&!d.hasOwnProperty(R)&&Z(a,b,R,null,d,r);for(w in d)r=d[w],t=c[w],!d.hasOwnProperty(w)||r===t||null==r&&null==t||Z(a,b,w,r,d,t)}var ej=null,ij=null;function Gi(a){return 9===a.nodeType?a:a.ownerDocument}function Pa(a){switch(a){case "http://www.w3.org/2000/svg":return 1;case "http://www.w3.org/1998/Math/MathML":return 2;default:return 0}}
 function Qa(a,b){if(0===a)switch(b){case "svg":return 1;case "math":return 2;default:return 0}return 1===a&&"foreignObject"===b?0:a}function Id(a,b){return"textarea"===a||"noscript"===a||"string"===typeof b.children||"number"===typeof b.children||"object"===typeof b.dangerouslySetInnerHTML&&null!==b.dangerouslySetInnerHTML&&null!=b.dangerouslySetInnerHTML.__html}var go=null;function of(){var a=window.event;if(a&&"popstate"===a.type){if(a===go)return!1;go=a;return!0}go=null;return!1}
 var Dk="function"===typeof setTimeout?setTimeout:void 0,Lk="function"===typeof clearTimeout?clearTimeout:void 0,ho="function"===typeof Promise?Promise:void 0,rf="function"===typeof queueMicrotask?queueMicrotask:"undefined"!==typeof ho?function(a){return ho.resolve(null).then(a).catch(io)}:Dk;function io(a){setTimeout(function(){throw a;})}
 function Dj(a,b){var c=b,d=0;do{var e=c.nextSibling;a.removeChild(c);if(e&&8===e.nodeType)if(c=e.data,"/$"===c){if(0===d){a.removeChild(e);Ej(b);return}d--}else"$"!==c&&"$?"!==c&&"$!"!==c||d++;c=e}while(c);Ej(b)}function jj(a){var b=a.nodeType;if(9===b)jo(a);else if(1===b)switch(a.nodeName){case "HEAD":case "HTML":case "BODY":jo(a);break;default:a.textContent=""}}
@@ -385,7 +384,7 @@ a.getAttribute("href")!==(null==e.href?null:e.href)||a.getAttribute("crossorigin
 return a;default:return a}a=Dd(a);if(null===a)break}return null}function Bd(a,b,c){if(""===b)return null;for(;3!==a.nodeType;){if((1!==a.nodeType||"INPUT"!==a.nodeName||"hidden"!==a.type)&&!c)return null;a=Dd(a);if(null===a)return null}return a}function zd(a){for(;null!=a;a=a.nextSibling){var b=a.nodeType;if(1===b||3===b)break;if(8===b){b=a.data;if("$"===b||"$!"===b||"$?"===b||"F!"===b||"F"===b)break;if("/$"===b)return null}}return a}function Dd(a){return zd(a.nextSibling)}
 function Ei(a,b,c,d,e){a[Cb]=e;a[Db]=c;d=0!==(e.mode&1);switch(b){case "dialog":Y("cancel",a);Y("close",a);break;case "iframe":case "object":case "embed":Y("load",a);break;case "video":case "audio":for(e=0;e<Tn.length;e++)Y(Tn[e],a);break;case "source":Y("error",a);break;case "img":case "image":case "link":Y("error",a);Y("load",a);break;case "details":Y("toggle",a);break;case "input":Y("invalid",a);vc(a,c.value,c.defaultValue,c.checked,c.defaultChecked,c.type,c.name,!0);oc(a);break;case "select":Y("invalid",
 a);break;case "textarea":Y("invalid",a),zc(a,c.value,c.defaultValue,c.children),oc(a)}e=c.children;"string"!==typeof e&&"number"!==typeof e||a.textContent===""+e||(!0!==c.suppressHydrationWarning&&Ii(a.textContent,e,d),d||"body"===b||(a.textContent=e));null!=c.onScroll&&Y("scroll",a);null!=c.onScrollEnd&&Y("scrollend",a);null!=c.onClick&&(a.onclick=xj)}
-function Nb(a){a=a.previousSibling;for(var b=0;a;){if(8===a.nodeType){var c=a.data;if("$"===c||"$!"===c||"$?"===c){if(0===b)return a;b--}else"/$"===c&&b++}a=a.previousSibling}return null}function Fi(a,b,c){b=Gi(c);switch(a){case "html":a=b.documentElement;if(!a)throw Error(t(452));return a;case "head":a=b.head;if(!a)throw Error(t(453));return a;case "body":a=b.body;if(!a)throw Error(t(454));return a;default:throw Error(t(451));}}var ko=new Map,lo=new Set;
+function Nb(a){a=a.previousSibling;for(var b=0;a;){if(8===a.nodeType){var c=a.data;if("$"===c||"$!"===c||"$?"===c){if(0===b)return a;b--}else"/$"===c&&b++}a=a.previousSibling}return null}function Fi(a,b,c){b=Gi(c);switch(a){case "html":a=b.documentElement;if(!a)throw Error(u(452));return a;case "head":a=b.head;if(!a)throw Error(u(453));return a;case "body":a=b.body;if(!a)throw Error(u(454));return a;default:throw Error(u(451));}}var ko=new Map,lo=new Set;
 function Rj(a){return"function"===typeof a.getRootNode?a.getRootNode():a.ownerDocument}var to={prefetchDNS:mo,preconnect:no,preload:oo,preloadModule:po,preinitStyle:qo,preinitScript:ro,preinitModuleScript:so};
 function uo(a,b,c){var d=document;if("string"===typeof b&&b){var e=sc(b);e='link[rel="'+a+'"][href="'+e+'"]';"string"===typeof c&&(e+='[crossorigin="'+c+'"]');lo.has(e)||(lo.add(e),a={rel:a,crossOrigin:c,href:b},null===d.querySelector(e)&&(b=d.createElement("link"),Hi(b,"link",a),Sb(b),d.head.appendChild(b)))}}function mo(a){uo("dns-prefetch",a,null)}function no(a,b){uo("preconnect",a,b)}
 function oo(a,b,c){var d=document;if(a&&b&&d){var e='link[rel="preload"][as="'+sc(b)+'"]';"image"===b?c&&c.imageSrcSet?(e+='[imagesrcset="'+sc(c.imageSrcSet)+'"]',"string"===typeof c.imageSizes&&(e+='[imagesizes="'+sc(c.imageSizes)+'"]')):e+='[href="'+sc(a)+'"]':e+='[href="'+sc(a)+'"]';var f=e;switch(b){case "style":f=vo(a);break;case "script":f=wo(a)}ko.has(f)||(a=B({rel:"preload",href:"image"===b&&c&&c.imageSrcSet?void 0:a,as:b},c),ko.set(f,a),null!==d.querySelector(e)||"style"===b&&d.querySelector(xo(f))||
@@ -395,39 +394,41 @@ Hi(d,"link",a);Sb(d);c.head.appendChild(d)}}}
 function qo(a,b,c){var d=document;if(a){var e=Rb(d).hoistableStyles,f=vo(a);b=b||"default";var g=e.get(f);if(!g){var h={loading:0,preload:null};if(g=d.querySelector(xo(f)))h.loading=5;else{a=B({rel:"stylesheet",href:a,"data-precedence":b},c);(c=ko.get(f))&&zo(a,c);var l=g=d.createElement("link");Sb(l);Hi(l,"link",a);l._p=new Promise(function(p,q){l.onload=p;l.onerror=q});l.addEventListener("load",function(){h.loading|=1});l.addEventListener("error",function(){h.loading|=2});h.loading|=4;Ao(g,b,d)}g=
 {type:"stylesheet",instance:g,count:1,state:h};e.set(f,g)}}}function ro(a,b){var c=document;if(a){var d=Rb(c).hoistableScripts,e=wo(a),f=d.get(e);f||(f=c.querySelector(yo(e)),f||(a=B({src:a,async:!0},b),(b=ko.get(e))&&Bo(a,b),f=c.createElement("script"),Sb(f),Hi(f,"link",a),c.head.appendChild(f)),f={type:"script",instance:f,count:1,state:null},d.set(e,f))}}
 function so(a,b){var c=document;if(a){var d=Rb(c).hoistableScripts,e=wo(a),f=d.get(e);f||(f=c.querySelector(yo(e)),f||(a=B({src:a,async:!0,type:"module"},b),(b=ko.get(e))&&Bo(a,b),f=c.createElement("script"),Sb(f),Hi(f,"link",a),c.head.appendChild(f)),f={type:"script",instance:f,count:1,state:null},d.set(e,f))}}
-function dl(a,b,c){b=(b=La.current)?Rj(b):null;if(!b)throw Error(t(446));switch(a){case "meta":case "title":return null;case "style":return"string"===typeof c.precedence&&"string"===typeof c.href?(c=vo(c.href),b=Rb(b).hoistableStyles,a=b.get(c),a||(a={type:"style",instance:null,count:0,state:null},b.set(c,a)),a):{type:"void",instance:null,count:0,state:null};case "link":if("stylesheet"===c.rel&&"string"===typeof c.href&&"string"===typeof c.precedence){a=vo(c.href);var d=Rb(b).hoistableStyles,e=d.get(a);
+function dl(a,b,c){b=(b=La.current)?Rj(b):null;if(!b)throw Error(u(446));switch(a){case "meta":case "title":return null;case "style":return"string"===typeof c.precedence&&"string"===typeof c.href?(c=vo(c.href),b=Rb(b).hoistableStyles,a=b.get(c),a||(a={type:"style",instance:null,count:0,state:null},b.set(c,a)),a):{type:"void",instance:null,count:0,state:null};case "link":if("stylesheet"===c.rel&&"string"===typeof c.href&&"string"===typeof c.precedence){a=vo(c.href);var d=Rb(b).hoistableStyles,e=d.get(a);
 e||(b=b.ownerDocument||b,e={type:"stylesheet",instance:null,count:0,state:{loading:0,preload:null}},d.set(a,e),ko.has(a)||Co(b,a,{rel:"preload",as:"style",href:c.href,crossOrigin:c.crossOrigin,integrity:c.integrity,media:c.media,hrefLang:c.hrefLang,referrerPolicy:c.referrerPolicy},e.state));return e}return null;case "script":return"string"===typeof c.src&&!0===c.async?(c=wo(c.src),b=Rb(b).hoistableScripts,a=b.get(c),a||(a={type:"script",instance:null,count:0,state:null},b.set(c,a)),a):{type:"void",
-instance:null,count:0,state:null};default:throw Error(t(444,a));}}function vo(a){return'href="'+sc(a)+'"'}function xo(a){return'link[rel="stylesheet"]['+a+"]"}function Do(a){return B({},a,{"data-precedence":a.precedence,precedence:null})}
+instance:null,count:0,state:null};default:throw Error(u(444,a));}}function vo(a){return'href="'+sc(a)+'"'}function xo(a){return'link[rel="stylesheet"]['+a+"]"}function Do(a){return B({},a,{"data-precedence":a.precedence,precedence:null})}
 function Co(a,b,c,d){ko.set(b,c);a.querySelector(xo(b))||(a.querySelector('link[rel="preload"][as="style"]['+b+"]")?d.loading=1:(b=a.createElement("link"),d.preload=b,b.addEventListener("load",function(){return d.loading|=1}),b.addEventListener("error",function(){return d.loading|=2}),Hi(b,"link",c),Sb(b),a.head.appendChild(b)))}function wo(a){return'[src="'+sc(a)+'"]'}function yo(a){return"script[async]"+a}
 function Oj(a,b,c){b.count++;if(null===b.instance)switch(b.type){case "style":var d=a.querySelector('style[data-href~="'+sc(c.href)+'"]');if(d)return b.instance=d,Sb(d),d;var e=B({},c,{"data-href":c.href,"data-precedence":c.precedence,href:null,precedence:null});d=(a.ownerDocument||a).createElement("style");Sb(d);Hi(d,"style",e);Ao(d,c.precedence,a);return b.instance=d;case "stylesheet":e=vo(c.href);var f=a.querySelector(xo(e));if(f)return b.state.loading|=4,b.instance=f,Sb(f),f;d=Do(c);(e=ko.get(e))&&
-zo(d,e);f=(a.ownerDocument||a).createElement("link");Sb(f);var g=f;g._p=new Promise(function(h,l){g.onload=h;g.onerror=l});Hi(f,"link",d);b.state.loading|=4;Ao(f,c.precedence,a);return b.instance=f;case "script":f=wo(c.src);if(e=a.querySelector(yo(f)))return b.instance=e,Sb(e),e;d=c;if(e=ko.get(f))d=B({},c),Bo(d,e);a=a.ownerDocument||a;e=a.createElement("script");Sb(e);Hi(e,"link",d);a.head.appendChild(e);return b.instance=e;case "void":return null;default:throw Error(t(443,b.type));}else"stylesheet"===
+zo(d,e);f=(a.ownerDocument||a).createElement("link");Sb(f);var g=f;g._p=new Promise(function(h,l){g.onload=h;g.onerror=l});Hi(f,"link",d);b.state.loading|=4;Ao(f,c.precedence,a);return b.instance=f;case "script":f=wo(c.src);if(e=a.querySelector(yo(f)))return b.instance=e,Sb(e),e;d=c;if(e=ko.get(f))d=B({},c),Bo(d,e);a=a.ownerDocument||a;e=a.createElement("script");Sb(e);Hi(e,"link",d);a.head.appendChild(e);return b.instance=e;case "void":return null;default:throw Error(u(443,b.type));}else"stylesheet"===
 b.type&&0===(b.state.loading&4)&&(d=b.instance,b.state.loading|=4,Ao(d,c.precedence,a));return b.instance}function Ao(a,b,c){for(var d=c.querySelectorAll('link[rel="stylesheet"][data-precedence],style[data-precedence]'),e=d.length?d[d.length-1]:null,f=e,g=0;g<d.length;g++){var h=d[g];if(h.dataset.precedence===b)f=h;else if(f!==e)break}f?f.parentNode.insertBefore(a,f.nextSibling):(b=9===c.nodeType?c.head:c,b.insertBefore(a,b.firstChild))}
 function zo(a,b){null==a.crossOrigin&&(a.crossOrigin=b.crossOrigin);null==a.referrerPolicy&&(a.referrerPolicy=b.referrerPolicy);null==a.title&&(a.title=b.title)}function Bo(a,b){null==a.crossOrigin&&(a.crossOrigin=b.crossOrigin);null==a.referrerPolicy&&(a.referrerPolicy=b.referrerPolicy);null==a.integrity&&(a.integrity=b.integrity)}var Qj=null;
 function Mj(a,b,c){if(null===Qj){var d=new Map;var e=Qj=new Map;e.set(c,d)}else e=Qj,d=e.get(c),d||(d=new Map,e.set(c,d));if(d.has(a))return d;d.set(a,null);c=c.getElementsByTagName(a);for(e=0;e<c.length;e++){var f=c[e];if(!(f[Kb]||f[Cb]||"link"===a&&"stylesheet"===f.getAttribute("rel"))&&"http://www.w3.org/2000/svg"!==f.namespaceURI){var g=f.getAttribute(b)||"";g=a+g;var h=d.get(g);h?h.push(f):d.set(g,[f])}}return d}
 function Nj(a,b,c){a=a.ownerDocument||a;a.head.insertBefore(c,"title"===b?a.querySelector("head > title"):null)}
 function fl(a,b,c){if(1===c||null!=b.itemProp)return!1;switch(a){case "meta":case "title":return!0;case "style":if("string"!==typeof b.precedence||"string"!==typeof b.href||""===b.href)break;return!0;case "link":if("string"!==typeof b.rel||"string"!==typeof b.href||""===b.href||b.onLoad||b.onError)break;switch(b.rel){case "stylesheet":return a=b.disabled,"string"===typeof b.precedence&&null==a;default:return!0}case "script":if(!0===b.async&&!b.onLoad&&!b.onError&&"string"===typeof b.src&&b.src)return!0}return!1}
 var Fk=null;function Gk(){}
-function ek(a,b,c){if(null===Fk)throw Error(t(475));var d=Fk;if("stylesheet"===b.type&&("string"!==typeof c.media||!1!==matchMedia(c.media).matches)&&0===(b.state.loading&4)){if(null===b.instance){var e=vo(c.href),f=a.querySelector(xo(e));if(f){a=f._p;null!==a&&"object"===typeof a&&"function"===typeof a.then&&(d.count++,d=Eo.bind(d),a.then(d,d));b.state.loading|=4;b.instance=f;Sb(f);return}f=a.ownerDocument||a;c=Do(c);(e=ko.get(e))&&zo(c,e);f=f.createElement("link");Sb(f);var g=f;g._p=new Promise(function(h,
+function ek(a,b,c){if(null===Fk)throw Error(u(475));var d=Fk;if("stylesheet"===b.type&&("string"!==typeof c.media||!1!==matchMedia(c.media).matches)&&0===(b.state.loading&4)){if(null===b.instance){var e=vo(c.href),f=a.querySelector(xo(e));if(f){a=f._p;null!==a&&"object"===typeof a&&"function"===typeof a.then&&(d.count++,d=Eo.bind(d),a.then(d,d));b.state.loading|=4;b.instance=f;Sb(f);return}f=a.ownerDocument||a;c=Do(c);(e=ko.get(e))&&zo(c,e);f=f.createElement("link");Sb(f);var g=f;g._p=new Promise(function(h,
 l){g.onload=h;g.onerror=l});Hi(f,"link",c);b.instance=f}null===d.stylesheets&&(d.stylesheets=new Map);d.stylesheets.set(b,a);(a=b.state.preload)&&0===(b.state.loading&3)&&(d.count++,b=Eo.bind(d),a.addEventListener("load",b),a.addEventListener("error",b))}}
-function Hk(){if(null===Fk)throw Error(t(475));var a=Fk;a.stylesheets&&0===a.count&&Fo(a,a.stylesheets);return 0<a.count?function(b){var c=setTimeout(function(){a.stylesheets&&Fo(a,a.stylesheets);if(a.unsuspend){var d=a.unsuspend;a.unsuspend=null;d()}},6E4);a.unsuspend=b;return function(){a.unsuspend=null;clearTimeout(c)}}:null}function Eo(){this.count--;if(0===this.count)if(this.stylesheets)Fo(this,this.stylesheets);else if(this.unsuspend){var a=this.unsuspend;this.unsuspend=null;a()}}var Go=null;
+function Hk(){if(null===Fk)throw Error(u(475));var a=Fk;a.stylesheets&&0===a.count&&Fo(a,a.stylesheets);return 0<a.count?function(b){var c=setTimeout(function(){a.stylesheets&&Fo(a,a.stylesheets);if(a.unsuspend){var d=a.unsuspend;a.unsuspend=null;d()}},6E4);a.unsuspend=b;return function(){a.unsuspend=null;clearTimeout(c)}}:null}function Eo(){this.count--;if(0===this.count)if(this.stylesheets)Fo(this,this.stylesheets);else if(this.unsuspend){var a=this.unsuspend;this.unsuspend=null;a()}}var Go=null;
 function Fo(a,b){a.stylesheets=null;null!==a.unsuspend&&(a.count++,Go=new Map,b.forEach(Ho,a),Go=null,Eo.call(a))}
 function Ho(a,b){if(!(b.state.loading&4)){var c=Go.get(a);if(c)var d=c.get("last");else{c=new Map;Go.set(a,c);for(var e=a.querySelectorAll("link[data-precedence],style[data-precedence]"),f=0;f<e.length;f++){var g=e[f];if("link"===g.nodeName||"not all"!==g.getAttribute("media"))c.set("p"+g.dataset.precedence,g),d=g}d&&c.set("last",d)}e=b.instance;g=e.getAttribute("data-precedence");f=c.get("p"+g)||d;f===d&&c.set("last",e);c.set(g,e);this.count++;d=Eo.bind(this);e.addEventListener("load",d);e.addEventListener("error",
-d);f?f.parentNode.insertBefore(e,f.nextSibling):(a=9===a.nodeType?a.head:a,a.insertBefore(e,a.firstChild));b.state.loading|=4}}var Io=ca.Dispatcher;"undefined"!==typeof document&&(Io.current=to);var Jo="function"===typeof reportError?reportError:function(a){console.error(a)};function Ko(a){this._internalRoot=a}Lo.prototype.render=Ko.prototype.render=function(a){var b=this._internalRoot;if(null===b)throw Error(t(409));ll(a,b,null,null)};
+d);f?f.parentNode.insertBefore(e,f.nextSibling):(a=9===a.nodeType?a.head:a,a.insertBefore(e,a.firstChild));b.state.loading|=4}}var Io=ca.Dispatcher;"undefined"!==typeof document&&(Io.current=to);var Jo="function"===typeof reportError?reportError:function(a){console.error(a)};function Ko(a){this._internalRoot=a}Lo.prototype.render=Ko.prototype.render=function(a){var b=this._internalRoot;if(null===b)throw Error(u(409));ll(a,b,null,null)};
 Lo.prototype.unmount=Ko.prototype.unmount=function(){var a=this._internalRoot;if(null!==a){this._internalRoot=null;var b=a.containerInfo;Jk(function(){ll(null,a,null,null)});b[Eb]=null}};function Lo(a){this._internalRoot=a}Lo.prototype.unstable_scheduleHydration=function(a){if(a){var b=F;a={blockedOn:null,target:a,priority:b};for(var c=0;c<pm.length&&0!==b&&b<pm[c].priority;c++);pm.splice(c,0,a);0===c&&um(a)}};function Mo(a){return!(!a||1!==a.nodeType&&9!==a.nodeType&&11!==a.nodeType)}
 function No(a){return!(!a||1!==a.nodeType&&9!==a.nodeType&&11!==a.nodeType&&(8!==a.nodeType||" react-mount-point-unstable "!==a.nodeValue))}function Oo(){}
 function Po(a,b,c,d,e){if(e){if("function"===typeof d){var f=d;d=function(){var p=ml(g);f.call(p)}}var g=kl(b,d,a,0,null,!1,!1,"",Oo,null,null);a._reactRootContainer=g;a[Eb]=g.current;Ji(8===a.nodeType?a.parentNode:a);Jk();return g}jj(a);if("function"===typeof d){var h=d;d=function(){var p=ml(l);h.call(p)}}var l=hl(a,0,!1,null,null,!1,!1,"",Oo,null,null);a._reactRootContainer=l;a[Eb]=l.current;Ji(8===a.nodeType?a.parentNode:a);Jk(function(){ll(b,l,c,d)});return l}
-function Qo(a,b,c,d,e){var f=c._reactRootContainer;if(f){var g=f;if("function"===typeof e){var h=e;e=function(){var l=ml(g);h.call(l)}}ll(b,g,a,e)}else g=Po(c,b,a,e,d);return ml(g)}function Ro(a,b){if("font"===a)return"";if("string"===typeof b)return"use-credentials"===b?b:""}var So=ca.Dispatcher;ca.Events=[Ob,Pb,Qb,Lc,Mc,Ik];var To={findFiberByHostInstance:Mb,bundleType:0,version:"18.3.0-experimental-2983249dd-20231107",rendererPackageName:"react-dom"};
+function Qo(a,b,c,d,e){var f=c._reactRootContainer;if(f){var g=f;if("function"===typeof e){var h=e;e=function(){var l=ml(g);h.call(l)}}ll(b,g,a,e)}else g=Po(c,b,a,e,d);return ml(g)}function Ro(a,b){if("font"===a)return"";if("string"===typeof b)return"use-credentials"===b?b:""}var So=ca.Dispatcher;ca.Events=[Ob,Pb,Qb,Lc,Mc,Ik];var To={findFiberByHostInstance:Mb,bundleType:0,version:"18.3.0-experimental-7508dcd5c-20231108",rendererPackageName:"react-dom"};
 var Uo={bundleType:To.bundleType,version:To.version,rendererPackageName:To.rendererPackageName,rendererConfig:To.rendererConfig,overrideHookState:null,overrideHookStateDeletePath:null,overrideHookStateRenamePath:null,overrideProps:null,overridePropsDeletePath:null,overridePropsRenamePath:null,setErrorHandler:null,setSuspenseHandler:null,scheduleUpdate:null,currentDispatcherRef:da.ReactCurrentDispatcher,findHostInstanceByFiber:function(a){a=Rc(a);return null===a?null:a.stateNode},findFiberByHostInstance:To.findFiberByHostInstance||
-rl,findHostInstancesForRefresh:null,scheduleRefresh:null,scheduleRoot:null,setRefreshHandler:null,getCurrentFiber:null,reconcilerVersion:"18.3.0-experimental-2983249dd-20231107"};if("undefined"!==typeof __REACT_DEVTOOLS_GLOBAL_HOOK__){var Vo=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(!Vo.isDisabled&&Vo.supportsFiber)try{eb=Vo.inject(Uo),fb=Vo}catch(a){}}exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=ca;
-exports.createPortal=function(a,b){var c=2<arguments.length&&void 0!==arguments[2]?arguments[2]:null;if(!Mo(b))throw Error(t(200));return il(a,b,null,c)};
-exports.createRoot=function(a,b){if(!Mo(a))throw Error(t(299));var c=!1,d="",e=Jo,f=null;null!==b&&void 0!==b&&(!0===b.unstable_strictMode&&(c=!0),void 0!==b.identifierPrefix&&(d=b.identifierPrefix),void 0!==b.onRecoverableError&&(e=b.onRecoverableError),void 0!==b.unstable_transitionCallbacks&&(f=b.unstable_transitionCallbacks));b=hl(a,1,!1,null,null,c,!1,d,e,f,null);a[Eb]=b.current;Io.current=to;Ji(8===a.nodeType?a.parentNode:a);return new Ko(b)};
-exports.experimental_useFormState=function(a,b,c){return ja(a,b,c)};exports.experimental_useFormStatus=function(){return ia()};exports.findDOMNode=function(a){if(null==a)return null;if(1===a.nodeType)return a;var b=a._reactInternals;if(void 0===b){if("function"===typeof a.render)throw Error(t(188));a=Object.keys(a).join(",");throw Error(t(268,a));}a=Rc(b);a=null===a?null:a.stateNode;return a};exports.flushSync=function(a){return Jk(a)};
-exports.hydrate=function(a,b,c){if(!No(b))throw Error(t(200));return Qo(null,a,b,!0,c)};
-exports.hydrateRoot=function(a,b,c){if(!Mo(a))throw Error(t(405));var d=!1,e="",f=Jo,g=null,h=null;null!==c&&void 0!==c&&(!0===c.unstable_strictMode&&(d=!0),void 0!==c.identifierPrefix&&(e=c.identifierPrefix),void 0!==c.onRecoverableError&&(f=c.onRecoverableError),void 0!==c.unstable_transitionCallbacks&&(g=c.unstable_transitionCallbacks),void 0!==c.formState&&(h=c.formState));b=kl(b,null,a,1,null!=c?c:null,d,!1,e,f,g,h);a[Eb]=b.current;Io.current=to;Ji(a);return new Lo(b)};
+rl,findHostInstancesForRefresh:null,scheduleRefresh:null,scheduleRoot:null,setRefreshHandler:null,getCurrentFiber:null,reconcilerVersion:"18.3.0-experimental-7508dcd5c-20231108"};if("undefined"!==typeof __REACT_DEVTOOLS_GLOBAL_HOOK__){var Vo=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(!Vo.isDisabled&&Vo.supportsFiber)try{eb=Vo.inject(Uo),fb=Vo}catch(a){}}exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=ca;
+exports.createPortal=function(a,b){var c=2<arguments.length&&void 0!==arguments[2]?arguments[2]:null;if(!Mo(b))throw Error(u(200));return il(a,b,null,c)};
+exports.createRoot=function(a,b){if(!Mo(a))throw Error(u(299));var c=!1,d="",e=Jo,f=null;null!==b&&void 0!==b&&(!0===b.unstable_strictMode&&(c=!0),void 0!==b.identifierPrefix&&(d=b.identifierPrefix),void 0!==b.onRecoverableError&&(e=b.onRecoverableError),void 0!==b.unstable_transitionCallbacks&&(f=b.unstable_transitionCallbacks));b=hl(a,1,!1,null,null,c,!1,d,e,f,null);a[Eb]=b.current;Io.current=to;Ji(8===a.nodeType?a.parentNode:a);return new Ko(b)};
+exports.experimental_useFormState=function(a,b,c){return ja(a,b,c)};exports.experimental_useFormStatus=function(){return ia()};exports.findDOMNode=function(a){if(null==a)return null;if(1===a.nodeType)return a;var b=a._reactInternals;if(void 0===b){if("function"===typeof a.render)throw Error(u(188));a=Object.keys(a).join(",");throw Error(u(268,a));}a=Rc(b);a=null===a?null:a.stateNode;return a};exports.flushSync=function(a){return Jk(a)};
+exports.hydrate=function(a,b,c){if(!No(b))throw Error(u(200));return Qo(null,a,b,!0,c)};
+exports.hydrateRoot=function(a,b,c){if(!Mo(a))throw Error(u(405));var d=!1,e="",f=Jo,g=null,h=null;null!==c&&void 0!==c&&(!0===c.unstable_strictMode&&(d=!0),void 0!==c.identifierPrefix&&(e=c.identifierPrefix),void 0!==c.onRecoverableError&&(f=c.onRecoverableError),void 0!==c.unstable_transitionCallbacks&&(g=c.unstable_transitionCallbacks),void 0!==c.formState&&(h=c.formState));b=kl(b,null,a,1,null!=c?c:null,d,!1,e,f,g,h);a[Eb]=b.current;Io.current=to;Ji(a);return new Lo(b)};
 exports.preconnect=function(a,b){var c=So.current;c&&"string"===typeof a&&(b?(b=b.crossOrigin,b="string"===typeof b?"use-credentials"===b?b:"":void 0):b=null,c.preconnect(a,b))};exports.prefetchDNS=function(a){var b=So.current;b&&"string"===typeof a&&b.prefetchDNS(a)};
 exports.preinit=function(a,b){var c=So.current;if(c&&"string"===typeof a&&b&&"string"===typeof b.as){var d=b.as,e=Ro(d,b.crossOrigin),f="string"===typeof b.integrity?b.integrity:void 0,g="string"===typeof b.fetchPriority?b.fetchPriority:void 0;"style"===d?c.preinitStyle(a,"string"===typeof b.precedence?b.precedence:void 0,{crossOrigin:e,integrity:f,fetchPriority:g}):"script"===d&&c.preinitScript(a,{crossOrigin:e,integrity:f,fetchPriority:g,nonce:"string"===typeof b.nonce?b.nonce:void 0})}};
 exports.preinitModule=function(a,b){var c=So.current;if(c&&"string"===typeof a)if("object"===typeof b&&null!==b){if(null==b.as||"script"===b.as){var d=Ro(b.as,b.crossOrigin);c.preinitModuleScript(a,{crossOrigin:d,integrity:"string"===typeof b.integrity?b.integrity:void 0,nonce:"string"===typeof b.nonce?b.nonce:void 0})}}else null==b&&c.preinitModuleScript(a)};
 exports.preload=function(a,b){var c=So.current;if(c&&"string"===typeof a&&"object"===typeof b&&null!==b&&"string"===typeof b.as){var d=b.as,e=Ro(d,b.crossOrigin);c.preload(a,d,{crossOrigin:e,integrity:"string"===typeof b.integrity?b.integrity:void 0,nonce:"string"===typeof b.nonce?b.nonce:void 0,type:"string"===typeof b.type?b.type:void 0,fetchPriority:"string"===typeof b.fetchPriority?b.fetchPriority:void 0,referrerPolicy:"string"===typeof b.referrerPolicy?b.referrerPolicy:void 0,imageSrcSet:"string"===
-typeof b.imageSrcSet?b.imageSrcSet:void 0,imageSizes:"string"===typeof b.imageSizes?b.imageSizes:void 0})}};exports.preloadModule=function(a,b){var c=So.current;if(c&&"string"===typeof a)if(b){var d=Ro(b.as,b.crossOrigin);c.preloadModule(a,{as:"string"===typeof b.as&&"script"!==b.as?b.as:void 0,crossOrigin:d,integrity:"string"===typeof b.integrity?b.integrity:void 0})}else c.preloadModule(a)};exports.render=function(a,b,c){if(!No(b))throw Error(t(200));return Qo(null,a,b,!1,c)};
-exports.unmountComponentAtNode=function(a){if(!No(a))throw Error(t(40));return a._reactRootContainer?(Jk(function(){Qo(null,null,a,!1,function(){a._reactRootContainer=null;a[Eb]=null})}),!0):!1};exports.unstable_batchedUpdates=Ik;exports.unstable_renderSubtreeIntoContainer=function(a,b,c,d){if(!No(c))throw Error(t(200));if(null==a||void 0===a._reactInternals)throw Error(t(38));return Qo(a,b,c,!1,d)};exports.unstable_runWithPriority=yb;exports.useFormState=ja;exports.useFormStatus=ia;
-exports.version="18.3.0-experimental-2983249dd-20231107";
+typeof b.imageSrcSet?b.imageSrcSet:void 0,imageSizes:"string"===typeof b.imageSizes?b.imageSizes:void 0})}};exports.preloadModule=function(a,b){var c=So.current;if(c&&"string"===typeof a)if(b){var d=Ro(b.as,b.crossOrigin);c.preloadModule(a,{as:"string"===typeof b.as&&"script"!==b.as?b.as:void 0,crossOrigin:d,integrity:"string"===typeof b.integrity?b.integrity:void 0})}else c.preloadModule(a)};exports.render=function(a,b,c){if(!No(b))throw Error(u(200));return Qo(null,a,b,!1,c)};
+exports.unmountComponentAtNode=function(a){if(!No(a))throw Error(u(40));return a._reactRootContainer?(Jk(function(){Qo(null,null,a,!1,function(){a._reactRootContainer=null;a[Eb]=null})}),!0):!1};exports.unstable_batchedUpdates=Ik;exports.unstable_renderSubtreeIntoContainer=function(a,b,c,d){if(!No(c))throw Error(u(200));if(null==a||void 0===a._reactInternals)throw Error(u(38));return Qo(a,b,c,!1,d)};exports.unstable_runWithPriority=yb;exports.useFormState=ja;exports.useFormStatus=ia;
+exports.version="18.3.0-experimental-7508dcd5c-20231108";
+
+//# sourceMappingURL=react-dom.production.min.js.map
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.profiling.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.profiling.js
new file mode 100644
index 0000000000000..ea1210d733e7d
--- /dev/null
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.profiling.js
@@ -0,0 +1,29142 @@
+/**
+ * @license React
+ * react-dom.profiling.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+          'use strict';
+
+/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+if (
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===
+    'function'
+) {
+  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+}
+          var React = require("next/dist/compiled/react-experimental");
+var Scheduler = require("next/dist/compiled/scheduler-experimental");
+
+const Internals = {
+  usingClientEntryPoint: false,
+  Events: null,
+  Dispatcher: {
+    current: null
+  }
+};
+
+// Do not require this module directly! Use normal `invariant` calls with
+// template literal strings. The messages will be replaced with error codes
+// during build.
+function formatProdErrorMessage(code) {
+  let url = 'https://reactjs.org/docs/error-decoder.html?invariant=' + code;
+
+  for (let i = 1; i < arguments.length; i++) {
+    url += '&args[]=' + encodeURIComponent(arguments[i]);
+  }
+
+  return "Minified React error #" + code + "; visit " + url + " for the full message or " + 'use the non-minified dev environment for full errors and additional ' + 'helpful warnings.';
+}
+
+const assign = Object.assign;
+
+// -----------------------------------------------------------------------------
+// Killswitch
+//
+// Flags that exist solely to turn off a change in case it causes a regression
+// when it rolls out to prod. We should remove these as soon as possible.
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+// Land or remove (moderate effort)
+//
+// Flags that can be probably deleted or landed, but might require extra effort
+// like migrating internal callers or performance testing.
+// -----------------------------------------------------------------------------
+// TODO: Finish rolling out in www
+
+const enableClientRenderFallbackOnTextMismatch = true;
+const enableFormActions = true;
+const enableAsyncActions = true; // Not sure if www still uses this. We don't have a replacement but whatever we
+// Slated for removal in the future (significant effort)
+//
+// These are experiments that didn't work out, and never shipped, but we can't
+// delete from the codebase until we migrate internal callers.
+// -----------------------------------------------------------------------------
+// Add a callback property to suspense to notify which promises are currently
+// in the update queue. This allows reporting and tracing of what is causing
+// the user to see a loading state.
+//
+// Also allows hydration callbacks to fire when a dehydrated boundary gets
+// hydrated or deleted.
+//
+// This will eventually be replaced by the Transition Tracing proposal.
+
+const enableSuspenseCallback = false; // Experimental Scope support.
+
+const enableLazyContextPropagation = false; // FB-only usage. The new API has different semantics.
+
+const enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber
+const enableHostSingletons = true;
+const alwaysThrottleRetries = true;
+// Chopping Block
+//
+// Planned feature deprecations and breaking changes. Sorted roughly in order of
+// when we plan to enable them.
+// -----------------------------------------------------------------------------
+// This flag enables Strict Effects by default. We're not turning this on until
+// after 18 because it requires migration work. Recommendation is to use
+// <StrictMode /> to gradually upgrade components.
+// If TRUE, trees rendered with createRoot will be StrictEffectsMode.
+// If FALSE, these trees will be StrictLegacyMode.
+
+const createRootStrictEffectsByDefault = false;
+// React DOM Chopping Block
+//
+// Similar to main Chopping Block but only flags related to React DOM. These are
+// grouped because we will likely batch all of them into a single major release.
+// -----------------------------------------------------------------------------
+// Disable support for comment nodes as React DOM containers. Already disabled
+// in open source, but www codebase still relies on it. Need to remove.
+
+const disableCommentsAsDOMContainers = true; // Disable javascript: URL strings in href for XSS protection.
+// Debugging and DevTools
+// -----------------------------------------------------------------------------
+// Adds user timing marks for e.g. state updates, suspense, and work loop stuff,
+// for an experimental timeline tool.
+
+const enableSchedulingProfiler = true; // Helps identify side effects in render-phase lifecycle hooks and setState
+
+const enableProfilerTimer = true; // Record durations for commit and passive effects phases.
+
+const enableProfilerCommitHooks = true; // Phase param passed to onRender callback differentiates between an "update" and a "cascading-update".
+
+const enableProfilerNestedUpdatePhase = true; // Adds verbose console logging for e.g. state updates, suspense, and work loop
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactCurrentDispatcher$2 = ReactSharedInternals.ReactCurrentDispatcher; // Since the "not pending" value is always the same, we can reuse the
+// same object across all transitions.
+
+const sharedNotPendingObject = {
+  pending: false,
+  data: null,
+  method: null,
+  action: null
+};
+const NotPending = sharedNotPendingObject;
+
+function resolveDispatcher() {
+  // Copied from react/src/ReactHooks.js. It's the same thing but in a
+  // different package.
+  const dispatcher = ReactCurrentDispatcher$2.current;
+  // intentionally don't throw our own error because this is in a hot path.
+  // Also helps ensure this is inlined.
+
+
+  return dispatcher;
+}
+
+function useFormStatus() {
+  {
+    const dispatcher = resolveDispatcher(); // $FlowFixMe[not-a-function] We know this exists because of the feature check above.
+
+    return dispatcher.useHostTransitionStatus();
+  }
+}
+function useFormState(action, initialState, permalink) {
+  {
+    const dispatcher = resolveDispatcher(); // $FlowFixMe[not-a-function] This is unstable, thus optional
+
+    return dispatcher.useFormState(action, initialState, permalink);
+  }
+}
+
+const valueStack = [];
+
+let index = -1;
+
+function createCursor(defaultValue) {
+  return {
+    current: defaultValue
+  };
+}
+
+function pop(cursor, fiber) {
+  if (index < 0) {
+
+    return;
+  }
+
+  cursor.current = valueStack[index];
+  valueStack[index] = null;
+
+  index--;
+}
+
+function push(cursor, value, fiber) {
+  index++;
+  valueStack[index] = cursor.current;
+
+  cursor.current = value;
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+const REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_CONTEXT_TYPE = Symbol.for('react.context');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SCOPE_TYPE = Symbol.for('react.scope');
+const REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');
+const REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+const REACT_LEGACY_HIDDEN_TYPE = Symbol.for('react.legacy_hidden');
+const REACT_CACHE_TYPE = Symbol.for('react.cache');
+const REACT_TRACING_MARKER_TYPE = Symbol.for('react.tracing_marker');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+const contextStackCursor$1 = createCursor(null);
+const contextFiberStackCursor = createCursor(null);
+const rootInstanceStackCursor = createCursor(null); // Represents the nearest host transition provider (in React DOM, a <form />)
+// NOTE: Since forms cannot be nested, and this feature is only implemented by
+// React DOM, we don't technically need this to be a stack. It could be a single
+// module variable instead.
+
+const hostTransitionProviderCursor = createCursor(null); // TODO: This should initialize to NotPendingTransition, a constant
+// imported from the fiber config. However, because of a cycle in the module
+// graph, that value isn't defined during this module's initialization. I can't
+// think of a way to work around this without moving that value out of the
+// fiber config. For now, the "no provider" case is handled when reading,
+// inside useHostTransitionStatus.
+
+const HostTransitionContext = {
+  $$typeof: REACT_CONTEXT_TYPE,
+  _currentValue: null,
+  _currentValue2: null,
+  _threadCount: 0,
+  Provider: null,
+  Consumer: null,
+  _defaultValue: null,
+  _globalName: null
+};
+
+function requiredContext(c) {
+
+  return c;
+}
+
+function getCurrentRootHostContainer() {
+  return rootInstanceStackCursor.current;
+}
+
+function getRootHostContainer() {
+  const rootInstance = requiredContext(rootInstanceStackCursor.current);
+  return rootInstance;
+}
+
+function pushHostContainer(fiber, nextRootInstance) {
+  // Push current root instance onto the stack;
+  // This allows us to reset root when portals are popped.
+  push(rootInstanceStackCursor, nextRootInstance); // Track the context and the Fiber that provided it.
+  // This enables us to pop only Fibers that provide unique contexts.
+
+  push(contextFiberStackCursor, fiber); // Finally, we need to push the host context to the stack.
+  // However, we can't just call getRootHostContext() and push it because
+  // we'd have a different number of entries on the stack depending on
+  // whether getRootHostContext() throws somewhere in renderer code or not.
+  // So we push an empty value first. This lets us safely unwind on errors.
+
+  push(contextStackCursor$1, null);
+  const nextRootContext = getRootHostContext(nextRootInstance); // Now that we know this function doesn't throw, replace it.
+
+  pop(contextStackCursor$1);
+  push(contextStackCursor$1, nextRootContext);
+}
+
+function popHostContainer(fiber) {
+  pop(contextStackCursor$1);
+  pop(contextFiberStackCursor);
+  pop(rootInstanceStackCursor);
+}
+
+function getHostContext() {
+  const context = requiredContext(contextStackCursor$1.current);
+  return context;
+}
+
+function pushHostContext(fiber) {
+  {
+    const stateHook = fiber.memoizedState;
+
+    if (stateHook !== null) {
+      // Only provide context if this fiber has been upgraded by a host
+      // transition. We use the same optimization for regular host context below.
+      push(hostTransitionProviderCursor, fiber);
+    }
+  }
+
+  const context = requiredContext(contextStackCursor$1.current);
+  const nextContext = getChildHostContext(context, fiber.type); // Don't push this Fiber's context unless it's unique.
+
+  if (context !== nextContext) {
+    // Track the context and the Fiber that provided it.
+    // This enables us to pop only Fibers that provide unique contexts.
+    push(contextFiberStackCursor, fiber);
+    push(contextStackCursor$1, nextContext);
+  }
+}
+
+function popHostContext(fiber) {
+  if (contextFiberStackCursor.current === fiber) {
+    // Do not pop unless this Fiber provided the current context.
+    // pushHostContext() only pushes Fibers that provide unique contexts.
+    pop(contextStackCursor$1);
+    pop(contextFiberStackCursor);
+  }
+
+  {
+    if (hostTransitionProviderCursor.current === fiber) {
+      // Do not pop unless this Fiber provided the current context. This is mostly
+      // a performance optimization, but conveniently it also prevents a potential
+      // data race where a host provider is upgraded (i.e. memoizedState becomes
+      // non-null) during a concurrent event. This is a bit of a flaw in the way
+      // we upgrade host components, but because we're accounting for it here, it
+      // should be fine.
+      pop(hostTransitionProviderCursor); // When popping the transition provider, we reset the context value back
+      // to `null`. We can do this because you're not allowd to nest forms. If
+      // we allowed for multiple nested host transition providers, then we'd
+      // need to reset this to the parent provider's status.
+
+      {
+        HostTransitionContext._currentValue = null;
+      }
+    }
+  }
+}
+
+const NoFlags$1 =
+/*                      */
+0b0000000000000000000000000000;
+const PerformedWork =
+/*                */
+0b0000000000000000000000000001;
+const Placement =
+/*                    */
+0b0000000000000000000000000010;
+const DidCapture =
+/*                   */
+0b0000000000000000000010000000;
+const Hydrating =
+/*                    */
+0b0000000000000001000000000000; // You can change the rest (and add more).
+
+const Update =
+/*                       */
+0b0000000000000000000000000100;
+/* Skipped value:                                 0b0000000000000000000000001000; */
+
+const ChildDeletion =
+/*                */
+0b0000000000000000000000010000;
+const ContentReset =
+/*                 */
+0b0000000000000000000000100000;
+const Callback =
+/*                     */
+0b0000000000000000000001000000;
+/* Used by DidCapture:                            0b0000000000000000000010000000; */
+
+const ForceClientRender =
+/*            */
+0b0000000000000000000100000000;
+const Ref =
+/*                          */
+0b0000000000000000001000000000;
+const Snapshot =
+/*                     */
+0b0000000000000000010000000000;
+const Passive$1 =
+/*                      */
+0b0000000000000000100000000000;
+/* Used by Hydrating:                             0b0000000000000001000000000000; */
+
+const Visibility =
+/*                   */
+0b0000000000000010000000000000;
+const StoreConsistency =
+/*             */
+0b0000000000000100000000000000; // It's OK to reuse these bits because these flags are mutually exclusive for
+// different fiber types. We should really be doing this for as many flags as
+// possible, because we're about to run out of bits.
+
+const ScheduleRetry = StoreConsistency;
+const ShouldSuspendCommit = Visibility;
+const LifecycleEffectMask = Passive$1 | Update | Callback | Ref | Snapshot | StoreConsistency; // Union of all commit flags (flags with the lifetime of a particular commit)
+
+const HostEffectMask =
+/*               */
+0b0000000000000111111111111111; // These are not really side effects, but we still reuse this field.
+
+const Incomplete =
+/*                   */
+0b0000000000001000000000000000;
+const ShouldCapture =
+/*                */
+0b0000000000010000000000000000;
+const ForceUpdateForLegacySuspense =
+/* */
+0b0000000000100000000000000000;
+const Forked =
+/*                       */
+0b0000000100000000000000000000; // Static tags describe aspects of a fiber that are not specific to a render,
+// e.g. a fiber uses a passive effect (even if there are no updates on this particular render).
+// This enables us to defer more work in the unmount case,
+// since we can defer traversing the tree during layout to look for Passive effects,
+// and instead rely on the static flag as a signal that there may be cleanup work.
+
+const RefStatic =
+/*                    */
+0b0000001000000000000000000000;
+const LayoutStatic =
+/*                 */
+0b0000010000000000000000000000;
+const PassiveStatic =
+/*                */
+0b0000100000000000000000000000;
+const MaySuspendCommit =
+/*             */
+0b0001000000000000000000000000; // Flag used to identify newly inserted fibers. It isn't reset after commit unlike `Placement`.
+
+const PlacementDEV =
+/*                 */
+0b0010000000000000000000000000;
+// don't contain effects, by checking subtreeFlags.
+
+const BeforeMutationMask = // TODO: Remove Update flag from before mutation phase by re-landing Visibility
+// flag logic (see #20043)
+Update | Snapshot | (0);
+const MutationMask = Placement | Update | ChildDeletion | ContentReset | Ref | Hydrating | Visibility;
+const LayoutMask = Update | Callback | Ref | Visibility; // TODO: Split into PassiveMountMask and PassiveUnmountMask
+
+const PassiveMask = Passive$1 | Visibility | ChildDeletion; // Union of tags that don't get reset on clones.
+// This allows certain concepts to persist without recalculating them,
+// e.g. whether a subtree contains passive effects or portals.
+
+const StaticMask = LayoutStatic | PassiveStatic | RefStatic | MaySuspendCommit;
+
+// This module only exists as an ESM wrapper around the external CommonJS
+const scheduleCallback$3 = Scheduler.unstable_scheduleCallback;
+const cancelCallback$1 = Scheduler.unstable_cancelCallback;
+const shouldYield = Scheduler.unstable_shouldYield;
+const requestPaint = Scheduler.unstable_requestPaint;
+const now$1 = Scheduler.unstable_now;
+const getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel;
+const ImmediatePriority = Scheduler.unstable_ImmediatePriority;
+const UserBlockingPriority = Scheduler.unstable_UserBlockingPriority;
+const NormalPriority$1 = Scheduler.unstable_NormalPriority;
+const LowPriority = Scheduler.unstable_LowPriority;
+const IdlePriority = Scheduler.unstable_IdlePriority; // this doesn't actually exist on the scheduler, but it *does*
+
+let rendererID = null;
+let injectedHook = null;
+let injectedProfilingHooks = null;
+const isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined';
+function injectInternals(internals) {
+  if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {
+    // No DevTools
+    return false;
+  }
+
+  const hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+
+  if (hook.isDisabled) {
+    // This isn't a real property on the hook, but it can be set to opt out
+    // of DevTools integration and associated warnings and logs.
+    // https://github.com/facebook/react/issues/3877
+    return true;
+  }
+
+  if (!hook.supportsFiber) {
+
+
+    return true;
+  }
+
+  try {
+    if (enableSchedulingProfiler) {
+      // Conditionally inject these hooks only if Timeline profiler is supported by this build.
+      // This gives DevTools a way to feature detect that isn't tied to version number
+      // (since profiling and timeline are controlled by different feature flags).
+      internals = assign({}, internals, {
+        getLaneLabelMap,
+        injectProfilingHooks
+      });
+    }
+
+    rendererID = hook.inject(internals); // We have successfully injected, so now it is safe to set up hooks.
+
+    injectedHook = hook;
+  } catch (err) {
+  }
+
+  if (hook.checkDCE) {
+    // This is the real DevTools.
+    return true;
+  } else {
+    // This is likely a hook installed by Fast Refresh runtime.
+    return false;
+  }
+}
+function onCommitRoot(root, eventPriority) {
+  if (injectedHook && typeof injectedHook.onCommitFiberRoot === 'function') {
+    try {
+      const didError = (root.current.flags & DidCapture) === DidCapture;
+
+      if (enableProfilerTimer) {
+        let 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) {
+    }
+  }
+}
+function onPostCommitRoot(root) {
+  if (injectedHook && typeof injectedHook.onPostCommitFiberRoot === 'function') {
+    try {
+      injectedHook.onPostCommitFiberRoot(rendererID, root);
+    } catch (err) {
+    }
+  }
+}
+function onCommitUnmount(fiber) {
+  if (injectedHook && typeof injectedHook.onCommitFiberUnmount === 'function') {
+    try {
+      injectedHook.onCommitFiberUnmount(rendererID, fiber);
+    } catch (err) {
+    }
+  }
+}
+
+function injectProfilingHooks(profilingHooks) {
+  injectedProfilingHooks = profilingHooks;
+}
+
+function getLaneLabelMap() {
+  {
+    const map = new Map();
+    let lane = 1;
+
+    for (let index = 0; index < TotalLanes; index++) {
+      const label = getLabelForLane(lane);
+      map.set(lane, label);
+      lane *= 2;
+    }
+
+    return map;
+  }
+}
+
+function markCommitStarted(lanes) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markCommitStarted === 'function') {
+      injectedProfilingHooks.markCommitStarted(lanes);
+    }
+  }
+}
+function markCommitStopped() {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markCommitStopped === 'function') {
+      injectedProfilingHooks.markCommitStopped();
+    }
+  }
+}
+function markComponentRenderStarted(fiber) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentRenderStarted === 'function') {
+      injectedProfilingHooks.markComponentRenderStarted(fiber);
+    }
+  }
+}
+function markComponentRenderStopped() {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentRenderStopped === 'function') {
+      injectedProfilingHooks.markComponentRenderStopped();
+    }
+  }
+}
+function markComponentPassiveEffectMountStarted(fiber) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentPassiveEffectMountStarted === 'function') {
+      injectedProfilingHooks.markComponentPassiveEffectMountStarted(fiber);
+    }
+  }
+}
+function markComponentPassiveEffectMountStopped() {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentPassiveEffectMountStopped === 'function') {
+      injectedProfilingHooks.markComponentPassiveEffectMountStopped();
+    }
+  }
+}
+function markComponentPassiveEffectUnmountStarted(fiber) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentPassiveEffectUnmountStarted === 'function') {
+      injectedProfilingHooks.markComponentPassiveEffectUnmountStarted(fiber);
+    }
+  }
+}
+function markComponentPassiveEffectUnmountStopped() {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentPassiveEffectUnmountStopped === 'function') {
+      injectedProfilingHooks.markComponentPassiveEffectUnmountStopped();
+    }
+  }
+}
+function markComponentLayoutEffectMountStarted(fiber) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentLayoutEffectMountStarted === 'function') {
+      injectedProfilingHooks.markComponentLayoutEffectMountStarted(fiber);
+    }
+  }
+}
+function markComponentLayoutEffectMountStopped() {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentLayoutEffectMountStopped === 'function') {
+      injectedProfilingHooks.markComponentLayoutEffectMountStopped();
+    }
+  }
+}
+function markComponentLayoutEffectUnmountStarted(fiber) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStarted === 'function') {
+      injectedProfilingHooks.markComponentLayoutEffectUnmountStarted(fiber);
+    }
+  }
+}
+function markComponentLayoutEffectUnmountStopped() {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStopped === 'function') {
+      injectedProfilingHooks.markComponentLayoutEffectUnmountStopped();
+    }
+  }
+}
+function markComponentErrored(fiber, thrownValue, lanes) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentErrored === 'function') {
+      injectedProfilingHooks.markComponentErrored(fiber, thrownValue, lanes);
+    }
+  }
+}
+function markComponentSuspended(fiber, wakeable, lanes) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentSuspended === 'function') {
+      injectedProfilingHooks.markComponentSuspended(fiber, wakeable, lanes);
+    }
+  }
+}
+function markLayoutEffectsStarted(lanes) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markLayoutEffectsStarted === 'function') {
+      injectedProfilingHooks.markLayoutEffectsStarted(lanes);
+    }
+  }
+}
+function markLayoutEffectsStopped() {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markLayoutEffectsStopped === 'function') {
+      injectedProfilingHooks.markLayoutEffectsStopped();
+    }
+  }
+}
+function markPassiveEffectsStarted(lanes) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markPassiveEffectsStarted === 'function') {
+      injectedProfilingHooks.markPassiveEffectsStarted(lanes);
+    }
+  }
+}
+function markPassiveEffectsStopped() {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markPassiveEffectsStopped === 'function') {
+      injectedProfilingHooks.markPassiveEffectsStopped();
+    }
+  }
+}
+function markRenderStarted(lanes) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markRenderStarted === 'function') {
+      injectedProfilingHooks.markRenderStarted(lanes);
+    }
+  }
+}
+function markRenderYielded() {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markRenderYielded === 'function') {
+      injectedProfilingHooks.markRenderYielded();
+    }
+  }
+}
+function markRenderStopped() {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markRenderStopped === 'function') {
+      injectedProfilingHooks.markRenderStopped();
+    }
+  }
+}
+function markRenderScheduled(lane) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markRenderScheduled === 'function') {
+      injectedProfilingHooks.markRenderScheduled(lane);
+    }
+  }
+}
+function markForceUpdateScheduled(fiber, lane) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markForceUpdateScheduled === 'function') {
+      injectedProfilingHooks.markForceUpdateScheduled(fiber, lane);
+    }
+  }
+}
+function markStateUpdateScheduled(fiber, lane) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markStateUpdateScheduled === 'function') {
+      injectedProfilingHooks.markStateUpdateScheduled(fiber, lane);
+    }
+  }
+}
+
+const NoMode =
+/*                         */
+0b0000000; // TODO: Remove ConcurrentMode by reading from the root tag instead
+
+const ConcurrentMode =
+/*                 */
+0b0000001;
+const ProfileMode =
+/*                    */
+0b0000010;
+const StrictLegacyMode =
+/*               */
+0b0001000;
+const StrictEffectsMode =
+/*              */
+0b0010000;
+
+// TODO: This is pretty well supported by browsers. Maybe we can drop it.
+const 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
+
+const log = Math.log;
+const LN2 = Math.LN2;
+
+function clz32Fallback(x) {
+  const asUint = x >>> 0;
+
+  if (asUint === 0) {
+    return 32;
+  }
+
+  return 31 - (log(asUint) / LN2 | 0) | 0;
+}
+
+// TODO: Ideally these types would be opaque but that doesn't work well with
+// If those values are changed that package should be rebuilt and redeployed.
+
+const TotalLanes = 31;
+const NoLanes =
+/*                        */
+0b0000000000000000000000000000000;
+const NoLane =
+/*                          */
+0b0000000000000000000000000000000;
+const SyncHydrationLane =
+/*               */
+0b0000000000000000000000000000001;
+const SyncLane =
+/*                        */
+0b0000000000000000000000000000010;
+const SyncLaneIndex = 1;
+const InputContinuousHydrationLane =
+/*    */
+0b0000000000000000000000000000100;
+const InputContinuousLane =
+/*             */
+0b0000000000000000000000000001000;
+const DefaultHydrationLane =
+/*            */
+0b0000000000000000000000000010000;
+const DefaultLane =
+/*                     */
+0b0000000000000000000000000100000;
+const SyncUpdateLanes = SyncLane | InputContinuousLane | DefaultLane ;
+const TransitionHydrationLane =
+/*                */
+0b0000000000000000000000001000000;
+const TransitionLanes =
+/*                       */
+0b0000000001111111111111110000000;
+const TransitionLane1 =
+/*                        */
+0b0000000000000000000000010000000;
+const TransitionLane2 =
+/*                        */
+0b0000000000000000000000100000000;
+const TransitionLane3 =
+/*                        */
+0b0000000000000000000001000000000;
+const TransitionLane4 =
+/*                        */
+0b0000000000000000000010000000000;
+const TransitionLane5 =
+/*                        */
+0b0000000000000000000100000000000;
+const TransitionLane6 =
+/*                        */
+0b0000000000000000001000000000000;
+const TransitionLane7 =
+/*                        */
+0b0000000000000000010000000000000;
+const TransitionLane8 =
+/*                        */
+0b0000000000000000100000000000000;
+const TransitionLane9 =
+/*                        */
+0b0000000000000001000000000000000;
+const TransitionLane10 =
+/*                       */
+0b0000000000000010000000000000000;
+const TransitionLane11 =
+/*                       */
+0b0000000000000100000000000000000;
+const TransitionLane12 =
+/*                       */
+0b0000000000001000000000000000000;
+const TransitionLane13 =
+/*                       */
+0b0000000000010000000000000000000;
+const TransitionLane14 =
+/*                       */
+0b0000000000100000000000000000000;
+const TransitionLane15 =
+/*                       */
+0b0000000001000000000000000000000;
+const RetryLanes =
+/*                            */
+0b0000011110000000000000000000000;
+const RetryLane1 =
+/*                             */
+0b0000000010000000000000000000000;
+const RetryLane2 =
+/*                             */
+0b0000000100000000000000000000000;
+const RetryLane3 =
+/*                             */
+0b0000001000000000000000000000000;
+const RetryLane4 =
+/*                             */
+0b0000010000000000000000000000000;
+const SomeRetryLane = RetryLane1;
+const SelectiveHydrationLane =
+/*          */
+0b0000100000000000000000000000000;
+const NonIdleLanes =
+/*                          */
+0b0000111111111111111111111111111;
+const IdleHydrationLane =
+/*               */
+0b0001000000000000000000000000000;
+const IdleLane =
+/*                        */
+0b0010000000000000000000000000000;
+const OffscreenLane =
+/*                   */
+0b0100000000000000000000000000000;
+const DeferredLane =
+/*                    */
+0b1000000000000000000000000000000; // Any lane that might schedule an update. This is used to detect infinite
+// update loops, so it doesn't include hydration lanes or retries.
+
+const UpdateLanes = SyncLane | InputContinuousLane | DefaultLane | TransitionLanes; // 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 (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';
+    }
+
+    if (lane & DeferredLane) {
+      return 'Deferred';
+    }
+  }
+}
+const NoTimestamp = -1;
+let nextTransitionLane = TransitionLane1;
+let nextRetryLane = RetryLane1;
+
+function getHighestPriorityLanes(lanes) {
+  {
+    const pendingSyncLanes = lanes & SyncUpdateLanes;
+
+    if (pendingSyncLanes !== 0) {
+      return pendingSyncLanes;
+    }
+  }
+
+  switch (getHighestPriorityLane(lanes)) {
+    case SyncHydrationLane:
+      return SyncHydrationLane;
+
+    case SyncLane:
+      return SyncLane;
+
+    case InputContinuousHydrationLane:
+      return InputContinuousHydrationLane;
+
+    case InputContinuousLane:
+      return InputContinuousLane;
+
+    case DefaultHydrationLane:
+      return DefaultHydrationLane;
+
+    case DefaultLane:
+      return DefaultLane;
+
+    case TransitionHydrationLane:
+      return TransitionHydrationLane;
+
+    case TransitionLane1:
+    case TransitionLane2:
+    case TransitionLane3:
+    case TransitionLane4:
+    case TransitionLane5:
+    case TransitionLane6:
+    case TransitionLane7:
+    case TransitionLane8:
+    case TransitionLane9:
+    case TransitionLane10:
+    case TransitionLane11:
+    case TransitionLane12:
+    case TransitionLane13:
+    case TransitionLane14:
+    case TransitionLane15:
+      return lanes & TransitionLanes;
+
+    case RetryLane1:
+    case RetryLane2:
+    case RetryLane3:
+    case RetryLane4:
+      return lanes & RetryLanes;
+
+    case SelectiveHydrationLane:
+      return SelectiveHydrationLane;
+
+    case IdleHydrationLane:
+      return IdleHydrationLane;
+
+    case IdleLane:
+      return IdleLane;
+
+    case OffscreenLane:
+      return OffscreenLane;
+
+    case DeferredLane:
+      // This shouldn't be reachable because deferred work is always entangled
+      // with something else.
+      return NoLanes;
+
+    default:
+
+
+      return lanes;
+  }
+}
+
+function getNextLanes(root, wipLanes) {
+  // Early bailout if there's no pending work left.
+  const pendingLanes = root.pendingLanes;
+
+  if (pendingLanes === NoLanes) {
+    return NoLanes;
+  }
+
+  let nextLanes = NoLanes;
+  const suspendedLanes = root.suspendedLanes;
+  const pingedLanes = root.pingedLanes; // Do not work on any idle work until all the non-idle work has finished,
+  // even if the work is suspended.
+
+  const nonIdlePendingLanes = pendingLanes & NonIdleLanes;
+
+  if (nonIdlePendingLanes !== NoLanes) {
+    const nonIdleUnblockedLanes = nonIdlePendingLanes & ~suspendedLanes;
+
+    if (nonIdleUnblockedLanes !== NoLanes) {
+      nextLanes = getHighestPriorityLanes(nonIdleUnblockedLanes);
+    } else {
+      const nonIdlePingedLanes = nonIdlePendingLanes & pingedLanes;
+
+      if (nonIdlePingedLanes !== NoLanes) {
+        nextLanes = getHighestPriorityLanes(nonIdlePingedLanes);
+      }
+    }
+  } else {
+    // The only remaining work is Idle.
+    const unblockedLanes = pendingLanes & ~suspendedLanes;
+
+    if (unblockedLanes !== NoLanes) {
+      nextLanes = getHighestPriorityLanes(unblockedLanes);
+    } else {
+      if (pingedLanes !== NoLanes) {
+        nextLanes = getHighestPriorityLanes(pingedLanes);
+      }
+    }
+  }
+
+  if (nextLanes === NoLanes) {
+    // This should only be reachable if we're suspended
+    // TODO: Consider warning in this path if a fallback timer is not scheduled.
+    return NoLanes;
+  } // If we're already in the middle of a render, switching lanes will interrupt
+  // it and we'll lose our progress. We should only do this if the new lanes are
+  // higher priority.
+
+
+  if (wipLanes !== NoLanes && wipLanes !== nextLanes && // If we already suspended with a delay, then interrupting is fine. Don't
+  // bother waiting until the root is complete.
+  (wipLanes & suspendedLanes) === NoLanes) {
+    const nextLane = getHighestPriorityLane(nextLanes);
+    const wipLane = getHighestPriorityLane(wipLanes);
+
+    if ( // Tests whether the next lane is equal or lower priority than the wip
+    // one. This works because the bits decrease in priority as you go left.
+    nextLane >= wipLane || // Default priority updates should not interrupt transition updates. The
+    // only difference between default updates and transition updates is that
+    // default updates do not support refresh transitions.
+    nextLane === DefaultLane && (wipLane & TransitionLanes) !== NoLanes) {
+      // Keep working on the existing in-progress tree. Do not interrupt.
+      return wipLanes;
+    }
+  }
+
+  return nextLanes;
+}
+function getEntangledLanes(root, renderLanes) {
+  let entangledLanes = renderLanes;
+
+  if ((entangledLanes & InputContinuousLane) !== NoLanes) {
+    // When updates are sync by default, we entangle continuous priority updates
+    // and default updates, so they render in the same batch. The only reason
+    // they use separate lanes is because continuous updates should interrupt
+    // transitions, but default updates should not.
+    entangledLanes |= entangledLanes & DefaultLane;
+  } // Check for entangled lanes and add them to the batch.
+  //
+  // A lane is said to be entangled with another when it's not allowed to render
+  // in a batch that does not also include the other lane. Typically we do this
+  // when multiple updates have the same source, and we only want to respond to
+  // the most recent event from that source.
+  //
+  // Note that we apply entanglements *after* checking for partial work above.
+  // This means that if a lane is entangled during an interleaved event while
+  // it's already rendering, we won't interrupt it. This is intentional, since
+  // entanglement is usually "best effort": we'll try our best to render the
+  // lanes in the same batch, but it's not worth throwing out partially
+  // completed work in order to do it.
+  // TODO: Reconsider this. The counter-argument is that the partial work
+  // represents an intermediate state, which we don't want to show to the user.
+  // And by spending extra time finishing it, we're increasing the amount of
+  // time it takes to show the final state, which is what they are actually
+  // waiting for.
+  //
+  // For those exceptions where entanglement is semantically important,
+  // we should ensure that there is no partial work at the
+  // time we apply the entanglement.
+
+
+  const allEntangledLanes = root.entangledLanes;
+
+  if (allEntangledLanes !== NoLanes) {
+    const entanglements = root.entanglements;
+    let lanes = entangledLanes & allEntangledLanes;
+
+    while (lanes > 0) {
+      const index = pickArbitraryLaneIndex(lanes);
+      const lane = 1 << index;
+      entangledLanes |= entanglements[index];
+      lanes &= ~lane;
+    }
+  }
+
+  return entangledLanes;
+}
+
+function computeExpirationTime(lane, currentTime) {
+  switch (lane) {
+    case SyncHydrationLane:
+    case SyncLane:
+    case InputContinuousHydrationLane:
+    case InputContinuousLane:
+      // User interactions should expire slightly more quickly.
+      //
+      // NOTE: This is set to the corresponding constant as in Scheduler.js.
+      // When we made it larger, a product metric in www regressed, suggesting
+      // there's a user interaction that's being starved by a series of
+      // synchronous updates. If that theory is correct, the proper solution is
+      // to fix the starvation. However, this scenario supports the idea that
+      // expiration times are an important safeguard when starvation
+      // does happen.
+      return currentTime + 250;
+
+    case DefaultHydrationLane:
+    case DefaultLane:
+    case TransitionHydrationLane:
+    case TransitionLane1:
+    case TransitionLane2:
+    case TransitionLane3:
+    case TransitionLane4:
+    case TransitionLane5:
+    case TransitionLane6:
+    case TransitionLane7:
+    case TransitionLane8:
+    case TransitionLane9:
+    case TransitionLane10:
+    case TransitionLane11:
+    case TransitionLane12:
+    case TransitionLane13:
+    case TransitionLane14:
+    case TransitionLane15:
+      return currentTime + 5000;
+
+    case RetryLane1:
+    case RetryLane2:
+    case RetryLane3:
+    case RetryLane4:
+      // TODO: Retries should be allowed to expire if they are CPU bound for
+      // too long, but when I made this change it caused a spike in browser
+      // crashes. There must be some other underlying bug; not super urgent but
+      // ideally should figure out why and fix it. Unfortunately we don't have
+      // a repro for the crashes, only detected via production metrics.
+      return NoTimestamp;
+
+    case SelectiveHydrationLane:
+    case IdleHydrationLane:
+    case IdleLane:
+    case OffscreenLane:
+    case DeferredLane:
+      // Anything idle priority or lower should never expire.
+      return NoTimestamp;
+
+    default:
+
+      return NoTimestamp;
+  }
+}
+
+function markStarvedLanesAsExpired(root, currentTime) {
+  // TODO: This gets called every time we yield. We can optimize by storing
+  // the earliest expiration time on the root. Then use that to quickly bail out
+  // of this function.
+  const pendingLanes = root.pendingLanes;
+  const suspendedLanes = root.suspendedLanes;
+  const pingedLanes = root.pingedLanes;
+  const expirationTimes = root.expirationTimes; // Iterate through the pending lanes and check if we've reached their
+  // expiration time. If so, we'll assume the update is being starved and mark
+  // it as expired to force it to finish.
+  // TODO: We should be able to replace this with upgradePendingLanesToSync
+  //
+  // We exclude retry lanes because those must always be time sliced, in order
+  // to unwrap uncached promises.
+  // TODO: Write a test for this
+
+  let lanes = pendingLanes & ~RetryLanes;
+
+  while (lanes > 0) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+    const expirationTime = expirationTimes[index];
+
+    if (expirationTime === NoTimestamp) {
+      // Found a pending lane with no expiration time. If it's not suspended, or
+      // if it's pinged, assume it's CPU-bound. Compute a new expiration time
+      // using the current time.
+      if ((lane & suspendedLanes) === NoLanes || (lane & pingedLanes) !== NoLanes) {
+        // Assumes timestamps are monotonically increasing.
+        expirationTimes[index] = computeExpirationTime(lane, currentTime);
+      }
+    } else if (expirationTime <= currentTime) {
+      // This lane expired
+      root.expiredLanes |= lane;
+    }
+
+    lanes &= ~lane;
+  }
+} // This returns the highest priority pending lanes regardless of whether they
+// are suspended.
+
+function getHighestPriorityPendingLanes(root) {
+  return getHighestPriorityLanes(root.pendingLanes);
+}
+function getLanesToRetrySynchronouslyOnError(root, originallyAttemptedLanes) {
+  if (root.errorRecoveryDisabledLanes & originallyAttemptedLanes) {
+    // The error recovery mechanism is disabled until these lanes are cleared.
+    return NoLanes;
+  }
+
+  const everythingButOffscreen = root.pendingLanes & ~OffscreenLane;
+
+  if (everythingButOffscreen !== NoLanes) {
+    return everythingButOffscreen;
+  }
+
+  if (everythingButOffscreen & OffscreenLane) {
+    return OffscreenLane;
+  }
+
+  return NoLanes;
+}
+function includesSyncLane(lanes) {
+  return (lanes & (SyncLane | SyncHydrationLane)) !== NoLanes;
+}
+function includesNonIdleWork(lanes) {
+  return (lanes & NonIdleLanes) !== NoLanes;
+}
+function includesOnlyRetries(lanes) {
+  return (lanes & RetryLanes) === lanes;
+}
+function includesOnlyNonUrgentLanes(lanes) {
+  // TODO: Should hydration lanes be included here? This function is only
+  // used in `updateDeferredValueImpl`.
+  const UrgentLanes = SyncLane | InputContinuousLane | DefaultLane;
+  return (lanes & UrgentLanes) === NoLanes;
+}
+function includesOnlyTransitions(lanes) {
+  return (lanes & TransitionLanes) === lanes;
+}
+function includesBlockingLane(root, lanes) {
+
+  const SyncDefaultLanes = InputContinuousHydrationLane | InputContinuousLane | DefaultHydrationLane | DefaultLane;
+  return (lanes & SyncDefaultLanes) !== NoLanes;
+}
+function includesExpiredLane(root, lanes) {
+  // This is a separate check from includesBlockingLane because a lane can
+  // expire after a render has already started.
+  return (lanes & root.expiredLanes) !== NoLanes;
+}
+function isTransitionLane(lane) {
+  return (lane & TransitionLanes) !== NoLanes;
+}
+function claimNextTransitionLane() {
+  // Cycle through the lanes, assigning each new transition to the next lane.
+  // In most cases, this means every transition gets its own lane, until we
+  // run out of lanes and cycle back to the beginning.
+  const lane = nextTransitionLane;
+  nextTransitionLane <<= 1;
+
+  if ((nextTransitionLane & TransitionLanes) === NoLanes) {
+    nextTransitionLane = TransitionLane1;
+  }
+
+  return lane;
+}
+function claimNextRetryLane() {
+  const lane = nextRetryLane;
+  nextRetryLane <<= 1;
+
+  if ((nextRetryLane & RetryLanes) === NoLanes) {
+    nextRetryLane = RetryLane1;
+  }
+
+  return lane;
+}
+function getHighestPriorityLane(lanes) {
+  return lanes & -lanes;
+}
+function pickArbitraryLane(lanes) {
+  // This wrapper function gets inlined. Only exists so to communicate that it
+  // doesn't matter which bit is selected; you can pick any bit without
+  // affecting the algorithms where its used. Here I'm using
+  // getHighestPriorityLane because it requires the fewest operations.
+  return getHighestPriorityLane(lanes);
+}
+
+function pickArbitraryLaneIndex(lanes) {
+  return 31 - clz32(lanes);
+}
+
+function laneToIndex(lane) {
+  return pickArbitraryLaneIndex(lane);
+}
+
+function includesSomeLane(a, b) {
+  return (a & b) !== NoLanes;
+}
+function isSubsetOfLanes(set, subset) {
+  return (set & subset) === subset;
+}
+function mergeLanes(a, b) {
+  return a | b;
+}
+function removeLanes(set, subset) {
+  return set & ~subset;
+}
+function intersectLanes(a, b) {
+  return a & b;
+} // Seems redundant, but it changes the type from a single lane (used for
+// updates) to a group of lanes (used for flushing work).
+
+function laneToLanes(lane) {
+  return lane;
+}
+function higherPriorityLane(a, b) {
+  // This works because the bit ranges decrease in priority as you go left.
+  return a !== NoLane && a < b ? a : b;
+}
+function createLaneMap(initial) {
+  // Intentionally pushing one by one.
+  // https://v8.dev/blog/elements-kinds#avoid-creating-holes
+  const laneMap = [];
+
+  for (let i = 0; i < TotalLanes; i++) {
+    laneMap.push(initial);
+  }
+
+  return laneMap;
+}
+function markRootUpdated(root, updateLane) {
+  root.pendingLanes |= updateLane; // If there are any suspended transitions, it's possible this new update
+  // could unblock them. Clear the suspended lanes so that we can try rendering
+  // them again.
+  //
+  // TODO: We really only need to unsuspend only lanes that are in the
+  // `subtreeLanes` of the updated fiber, or the update lanes of the return
+  // path. This would exclude suspended updates in an unrelated sibling tree,
+  // since there's no way for this update to unblock it.
+  //
+  // We don't do this if the incoming update is idle, because we never process
+  // idle updates until after all the regular updates have finished; there's no
+  // way it could unblock a transition.
+
+  if (updateLane !== IdleLane) {
+    root.suspendedLanes = NoLanes;
+    root.pingedLanes = NoLanes;
+  }
+}
+function markRootSuspended$1(root, suspendedLanes, spawnedLane) {
+  root.suspendedLanes |= suspendedLanes;
+  root.pingedLanes &= ~suspendedLanes; // The suspended lanes are no longer CPU-bound. Clear their expiration times.
+
+  const expirationTimes = root.expirationTimes;
+  let lanes = suspendedLanes;
+
+  while (lanes > 0) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+    expirationTimes[index] = NoTimestamp;
+    lanes &= ~lane;
+  }
+
+  if (spawnedLane !== NoLane) {
+    markSpawnedDeferredLane(root, spawnedLane, suspendedLanes);
+  }
+}
+function markRootPinged(root, pingedLanes) {
+  root.pingedLanes |= root.suspendedLanes & pingedLanes;
+}
+function markRootFinished(root, remainingLanes, spawnedLane) {
+  const noLongerPendingLanes = root.pendingLanes & ~remainingLanes;
+  root.pendingLanes = remainingLanes; // Let's try everything again
+
+  root.suspendedLanes = NoLanes;
+  root.pingedLanes = NoLanes;
+  root.expiredLanes &= remainingLanes;
+  root.entangledLanes &= remainingLanes;
+  root.errorRecoveryDisabledLanes &= remainingLanes;
+  root.shellSuspendCounter = 0;
+  const entanglements = root.entanglements;
+  const expirationTimes = root.expirationTimes;
+  const hiddenUpdates = root.hiddenUpdates; // Clear the lanes that no longer have pending work
+
+  let lanes = noLongerPendingLanes;
+
+  while (lanes > 0) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+    entanglements[index] = NoLanes;
+    expirationTimes[index] = NoTimestamp;
+    const hiddenUpdatesForLane = hiddenUpdates[index];
+
+    if (hiddenUpdatesForLane !== null) {
+      hiddenUpdates[index] = null; // "Hidden" updates are updates that were made to a hidden component. They
+      // have special logic associated with them because they may be entangled
+      // with updates that occur outside that tree. But once the outer tree
+      // commits, they behave like regular updates.
+
+      for (let i = 0; i < hiddenUpdatesForLane.length; i++) {
+        const update = hiddenUpdatesForLane[i];
+
+        if (update !== null) {
+          update.lane &= ~OffscreenLane;
+        }
+      }
+    }
+
+    lanes &= ~lane;
+  }
+
+  if (spawnedLane !== NoLane) {
+    markSpawnedDeferredLane(root, spawnedLane, // This render finished successfully without suspending, so we don't need
+    // to entangle the spawned task with the parent task.
+    NoLanes);
+  }
+}
+
+function markSpawnedDeferredLane(root, spawnedLane, entangledLanes) {
+  // This render spawned a deferred task. Mark it as pending.
+  root.pendingLanes |= spawnedLane;
+  root.suspendedLanes &= ~spawnedLane; // Entangle the spawned lane with the DeferredLane bit so that we know it
+  // was the result of another render. This lets us avoid a useDeferredValue
+  // waterfall — only the first level will defer.
+
+  const spawnedLaneIndex = laneToIndex(spawnedLane);
+  root.entangledLanes |= spawnedLane;
+  root.entanglements[spawnedLaneIndex] |= DeferredLane | // If the parent render task suspended, we must also entangle those lanes
+  // with the spawned task, so that the deferred task includes all the same
+  // updates that the parent task did. We can exclude any lane that is not
+  // used for updates (e.g. Offscreen).
+  entangledLanes & UpdateLanes;
+}
+
+function markRootEntangled(root, entangledLanes) {
+  // In addition to entangling each of the given lanes with each other, we also
+  // have to consider _transitive_ entanglements. For each lane that is already
+  // entangled with *any* of the given lanes, that lane is now transitively
+  // entangled with *all* the given lanes.
+  //
+  // Translated: If C is entangled with A, then entangling A with B also
+  // entangles C with B.
+  //
+  // If this is hard to grasp, it might help to intentionally break this
+  // function and look at the tests that fail in ReactTransition-test.js. Try
+  // commenting out one of the conditions below.
+  const rootEntangledLanes = root.entangledLanes |= entangledLanes;
+  const entanglements = root.entanglements;
+  let lanes = rootEntangledLanes;
+
+  while (lanes) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+
+    if ( // Is this one of the newly entangled lanes?
+    lane & entangledLanes | // Is this lane transitively entangled with the newly entangled lanes?
+    entanglements[index] & entangledLanes) {
+      entanglements[index] |= entangledLanes;
+    }
+
+    lanes &= ~lane;
+  }
+}
+function upgradePendingLaneToSync(root, lane) {
+  // Since we're upgrading the priority of the given lane, there is now pending
+  // sync work.
+  root.pendingLanes |= SyncLane; // Entangle the sync lane with the lane we're upgrading. This means SyncLane
+  // will not be allowed to finish without also finishing the given lane.
+
+  root.entangledLanes |= SyncLane;
+  root.entanglements[SyncLaneIndex] |= lane;
+}
+function upgradePendingLanesToSync(root, lanesToUpgrade) {
+  // Same as upgradePendingLaneToSync but accepts multiple lanes, so it's a
+  // bit slower.
+  root.pendingLanes |= SyncLane;
+  root.entangledLanes |= SyncLane;
+  let lanes = lanesToUpgrade;
+
+  while (lanes) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+    root.entanglements[SyncLaneIndex] |= lane;
+    lanes &= ~lane;
+  }
+}
+function markHiddenUpdate(root, update, lane) {
+  const index = laneToIndex(lane);
+  const hiddenUpdates = root.hiddenUpdates;
+  const hiddenUpdatesForLane = hiddenUpdates[index];
+
+  if (hiddenUpdatesForLane === null) {
+    hiddenUpdates[index] = [update];
+  } else {
+    hiddenUpdatesForLane.push(update);
+  }
+
+  update.lane = lane | OffscreenLane;
+}
+function getBumpedLaneForHydration(root, renderLanes) {
+  const renderLane = getHighestPriorityLane(renderLanes);
+  let lane;
+
+  if ((renderLane & SyncUpdateLanes) !== NoLane) {
+    lane = SyncHydrationLane;
+  } else {
+    switch (renderLane) {
+      case SyncLane:
+        lane = SyncHydrationLane;
+        break;
+
+      case InputContinuousLane:
+        lane = InputContinuousHydrationLane;
+        break;
+
+      case DefaultLane:
+        lane = DefaultHydrationLane;
+        break;
+
+      case TransitionLane1:
+      case TransitionLane2:
+      case TransitionLane3:
+      case TransitionLane4:
+      case TransitionLane5:
+      case TransitionLane6:
+      case TransitionLane7:
+      case TransitionLane8:
+      case TransitionLane9:
+      case TransitionLane10:
+      case TransitionLane11:
+      case TransitionLane12:
+      case TransitionLane13:
+      case TransitionLane14:
+      case TransitionLane15:
+      case RetryLane1:
+      case RetryLane2:
+      case RetryLane3:
+      case RetryLane4:
+        lane = TransitionHydrationLane;
+        break;
+
+      case IdleLane:
+        lane = IdleHydrationLane;
+        break;
+
+      default:
+        // Everything else is already either a hydration lane, or shouldn't
+        // be retried at a hydration lane.
+        lane = NoLane;
+        break;
+    }
+  } // Check if the lane we chose is suspended. If so, that indicates that we
+  // already attempted and failed to hydrate at that level. Also check if we're
+  // already rendering that lane, which is rare but could happen.
+
+
+  if ((lane & (root.suspendedLanes | renderLanes)) !== NoLane) {
+    // Give up trying to hydrate and fall back to client render.
+    return NoLane;
+  }
+
+  return lane;
+}
+function addFiberToLanesMap(root, fiber, lanes) {
+
+  if (!isDevToolsPresent) {
+    return;
+  }
+
+  const pendingUpdatersLaneMap = root.pendingUpdatersLaneMap;
+
+  while (lanes > 0) {
+    const index = laneToIndex(lanes);
+    const lane = 1 << index;
+    const updaters = pendingUpdatersLaneMap[index];
+    updaters.add(fiber);
+    lanes &= ~lane;
+  }
+}
+function movePendingFibersToMemoized(root, lanes) {
+
+  if (!isDevToolsPresent) {
+    return;
+  }
+
+  const pendingUpdatersLaneMap = root.pendingUpdatersLaneMap;
+  const memoizedUpdaters = root.memoizedUpdaters;
+
+  while (lanes > 0) {
+    const index = laneToIndex(lanes);
+    const lane = 1 << index;
+    const updaters = pendingUpdatersLaneMap[index];
+
+    if (updaters.size > 0) {
+      updaters.forEach(fiber => {
+        const alternate = fiber.alternate;
+
+        if (alternate === null || !memoizedUpdaters.has(alternate)) {
+          memoizedUpdaters.add(fiber);
+        }
+      });
+      updaters.clear();
+    }
+
+    lanes &= ~lane;
+  }
+}
+function getTransitionsForLanes(root, lanes) {
+  {
+    return null;
+  }
+}
+
+const DiscreteEventPriority = SyncLane;
+const ContinuousEventPriority = InputContinuousLane;
+const DefaultEventPriority = DefaultLane;
+const IdleEventPriority = IdleLane;
+let currentUpdatePriority = NoLane;
+function getCurrentUpdatePriority() {
+  return currentUpdatePriority;
+}
+function setCurrentUpdatePriority(newPriority) {
+  currentUpdatePriority = newPriority;
+}
+function runWithPriority(priority, fn) {
+  const previousPriority = currentUpdatePriority;
+
+  try {
+    currentUpdatePriority = priority;
+    return fn();
+  } finally {
+    currentUpdatePriority = previousPriority;
+  }
+}
+function higherEventPriority(a, b) {
+  return a !== 0 && a < b ? a : b;
+}
+function lowerEventPriority(a, b) {
+  return a === 0 || a > b ? a : b;
+}
+function isHigherEventPriority(a, b) {
+  return a !== 0 && a < b;
+}
+function lanesToEventPriority(lanes) {
+  const lane = getHighestPriorityLane(lanes);
+
+  if (!isHigherEventPriority(DiscreteEventPriority, lane)) {
+    return DiscreteEventPriority;
+  }
+
+  if (!isHigherEventPriority(ContinuousEventPriority, lane)) {
+    return ContinuousEventPriority;
+  }
+
+  if (includesNonIdleWork(lane)) {
+    return DefaultEventPriority;
+  }
+
+  return IdleEventPriority;
+}
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+const FunctionComponent = 0;
+const ClassComponent = 1;
+const IndeterminateComponent = 2; // Before we know whether it is function or class
+
+const HostRoot = 3; // Root of a host tree. Could be nested inside another node.
+
+const HostPortal = 4; // A subtree. Could be an entry point to a different renderer.
+
+const HostComponent = 5;
+const HostText = 6;
+const Fragment = 7;
+const Mode = 8;
+const ContextConsumer = 9;
+const ContextProvider = 10;
+const ForwardRef = 11;
+const Profiler = 12;
+const SuspenseComponent = 13;
+const MemoComponent = 14;
+const SimpleMemoComponent = 15;
+const LazyComponent = 16;
+const IncompleteClassComponent = 17;
+const DehydratedFragment = 18;
+const SuspenseListComponent = 19;
+const ScopeComponent = 21;
+const OffscreenComponent = 22;
+const LegacyHiddenComponent = 23;
+const CacheComponent = 24;
+const TracingMarkerComponent = 25;
+const HostHoistable = 26;
+const HostSingleton = 27;
+
+const randomKey = Math.random().toString(36).slice(2);
+const internalInstanceKey = '__reactFiber$' + randomKey;
+const internalPropsKey = '__reactProps$' + randomKey;
+const internalContainerInstanceKey = '__reactContainer$' + randomKey;
+const internalEventHandlersKey = '__reactEvents$' + randomKey;
+const internalEventHandlerListenersKey = '__reactListeners$' + randomKey;
+const internalEventHandlesSetKey = '__reactHandles$' + randomKey;
+const internalRootNodeResourcesKey = '__reactResources$' + randomKey;
+const internalHoistableMarker = '__reactMarker$' + randomKey;
+function detachDeletedInstance(node) {
+  // TODO: This function is only called on host components. I don't think all of
+  // these fields are relevant.
+  delete node[internalInstanceKey];
+  delete node[internalPropsKey];
+  delete node[internalEventHandlersKey];
+  delete node[internalEventHandlerListenersKey];
+  delete node[internalEventHandlesSetKey];
+}
+function precacheFiberNode(hostInst, node) {
+  node[internalInstanceKey] = hostInst;
+}
+function markContainerAsRoot(hostRoot, node) {
+  // $FlowFixMe[prop-missing]
+  node[internalContainerInstanceKey] = hostRoot;
+}
+function unmarkContainerAsRoot(node) {
+  // $FlowFixMe[prop-missing]
+  node[internalContainerInstanceKey] = null;
+}
+function isContainerMarkedAsRoot(node) {
+  // $FlowFixMe[prop-missing]
+  return !!node[internalContainerInstanceKey];
+} // Given a DOM node, return the closest HostComponent or HostText fiber ancestor.
+// If the target node is part of a hydrated or not yet rendered subtree, then
+// this may also return a SuspenseComponent or HostRoot to indicate that.
+// Conceptually the HostRoot fiber is a child of the Container node. So if you
+// pass the Container node as the targetNode, you will not actually get the
+// HostRoot back. To get to the HostRoot, you need to pass a child of it.
+// The same thing applies to Suspense boundaries.
+
+function getClosestInstanceFromNode(targetNode) {
+  let targetInst = targetNode[internalInstanceKey];
+
+  if (targetInst) {
+    // Don't return HostRoot or SuspenseComponent here.
+    return targetInst;
+  } // If the direct event target isn't a React owned DOM node, we need to look
+  // to see if one of its parents is a React owned DOM node.
+
+
+  let parentNode = targetNode.parentNode;
+
+  while (parentNode) {
+    // We'll check if this is a container root that could include
+    // React nodes in the future. We need to check this first because
+    // if we're a child of a dehydrated container, we need to first
+    // find that inner container before moving on to finding the parent
+    // instance. Note that we don't check this field on  the targetNode
+    // itself because the fibers are conceptually between the container
+    // node and the first child. It isn't surrounding the container node.
+    // If it's not a container, we check if it's an instance.
+    targetInst = parentNode[internalContainerInstanceKey] || parentNode[internalInstanceKey];
+
+    if (targetInst) {
+      // Since this wasn't the direct target of the event, we might have
+      // stepped past dehydrated DOM nodes to get here. However they could
+      // also have been non-React nodes. We need to answer which one.
+      // If we the instance doesn't have any children, then there can't be
+      // a nested suspense boundary within it. So we can use this as a fast
+      // bailout. Most of the time, when people add non-React children to
+      // the tree, it is using a ref to a child-less DOM node.
+      // Normally we'd only need to check one of the fibers because if it
+      // has ever gone from having children to deleting them or vice versa
+      // it would have deleted the dehydrated boundary nested inside already.
+      // However, since the HostRoot starts out with an alternate it might
+      // have one on the alternate so we need to check in case this was a
+      // root.
+      const alternate = targetInst.alternate;
+
+      if (targetInst.child !== null || alternate !== null && alternate.child !== null) {
+        // Next we need to figure out if the node that skipped past is
+        // nested within a dehydrated boundary and if so, which one.
+        let suspenseInstance = getParentSuspenseInstance(targetNode);
+
+        while (suspenseInstance !== null) {
+          // We found a suspense instance. That means that we haven't
+          // hydrated it yet. Even though we leave the comments in the
+          // DOM after hydrating, and there are boundaries in the DOM
+          // that could already be hydrated, we wouldn't have found them
+          // through this pass since if the target is hydrated it would
+          // have had an internalInstanceKey on it.
+          // Let's get the fiber associated with the SuspenseComponent
+          // as the deepest instance.
+          // $FlowFixMe[prop-missing]
+          const targetSuspenseInst = suspenseInstance[internalInstanceKey];
+
+          if (targetSuspenseInst) {
+            return targetSuspenseInst;
+          } // If we don't find a Fiber on the comment, it might be because
+          // we haven't gotten to hydrate it yet. There might still be a
+          // parent boundary that hasn't above this one so we need to find
+          // the outer most that is known.
+
+
+          suspenseInstance = getParentSuspenseInstance(suspenseInstance); // If we don't find one, then that should mean that the parent
+          // host component also hasn't hydrated yet. We can return it
+          // below since it will bail out on the isMounted check later.
+        }
+      }
+
+      return targetInst;
+    }
+
+    targetNode = parentNode;
+    parentNode = targetNode.parentNode;
+  }
+
+  return null;
+}
+/**
+ * Given a DOM node, return the ReactDOMComponent or ReactDOMTextComponent
+ * instance, or null if the node was not rendered by this React.
+ */
+
+function getInstanceFromNode(node) {
+  const inst = node[internalInstanceKey] || node[internalContainerInstanceKey];
+
+  if (inst) {
+    const tag = inst.tag;
+
+    if (tag === HostComponent || tag === HostText || tag === SuspenseComponent || (tag === HostHoistable ) || (tag === HostSingleton ) || tag === HostRoot) {
+      return inst;
+    } else {
+      return null;
+    }
+  }
+
+  return null;
+}
+/**
+ * Given a ReactDOMComponent or ReactDOMTextComponent, return the corresponding
+ * DOM node.
+ */
+
+function getNodeFromInstance(inst) {
+  const tag = inst.tag;
+
+  if (tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton ) || tag === HostText) {
+    // In Fiber this, is just the state node right now. We assume it will be
+    // a host component or host text.
+    return inst.stateNode;
+  } // Without this first invariant, passing a non-DOM-component triggers the next
+  // invariant for a missing parent, which is super confusing.
+
+
+  throw Error(formatProdErrorMessage(33));
+}
+function getFiberCurrentPropsFromNode(node) {
+  return node[internalPropsKey] || null;
+}
+function updateFiberProps(node, props) {
+  node[internalPropsKey] = props;
+}
+function getEventListenerSet(node) {
+  let elementListenerSet = node[internalEventHandlersKey];
+
+  if (elementListenerSet === undefined) {
+    elementListenerSet = node[internalEventHandlersKey] = new Set();
+  }
+
+  return elementListenerSet;
+}
+function getResourcesFromRoot(root) {
+  let resources = root[internalRootNodeResourcesKey];
+
+  if (!resources) {
+    resources = root[internalRootNodeResourcesKey] = {
+      hoistableStyles: new Map(),
+      hoistableScripts: new Map()
+    };
+  }
+
+  return resources;
+}
+function isMarkedHoistable(node) {
+  return !!node[internalHoistableMarker];
+}
+function markNodeAsHoistable(node) {
+  node[internalHoistableMarker] = true;
+}
+function isOwnedInstance(node) {
+  return !!(node[internalHoistableMarker] || node[internalInstanceKey]);
+}
+
+const allNativeEvents = new Set();
+/**
+ * Mapping from registration name to event name
+ */
+
+
+const registrationNameDependencies = {};
+
+function registerTwoPhaseEvent(registrationName, dependencies) {
+  registerDirectEvent(registrationName, dependencies);
+  registerDirectEvent(registrationName + 'Capture', dependencies);
+}
+function registerDirectEvent(registrationName, dependencies) {
+
+  registrationNameDependencies[registrationName] = dependencies;
+
+  for (let i = 0; i < dependencies.length; i++) {
+    allNativeEvents.add(dependencies[i]);
+  }
+}
+
+const canUseDOM = !!(typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined');
+
+/* eslint-disable max-len */
+
+const ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
+/* eslint-enable max-len */
+
+const ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
+const VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+const illegalAttributeNameCache = {};
+const validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+  if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+    return true;
+  }
+
+  if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+    return false;
+  }
+
+  if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+    validatedAttributeNameCache[attributeName] = true;
+    return true;
+  }
+
+  illegalAttributeNameCache[attributeName] = true;
+
+  return false;
+}
+
+function setValueForAttribute(node, name, value) {
+  if (isAttributeNameSafe(name)) {
+    // If the prop isn't in the special list, treat it as a simple attribute.
+    // shouldRemoveAttribute
+    if (value === null) {
+      node.removeAttribute(name);
+      return;
+    }
+
+    switch (typeof value) {
+      case 'undefined':
+      case 'function':
+      case 'symbol':
+        // eslint-disable-line
+        node.removeAttribute(name);
+        return;
+
+      case 'boolean':
+        {
+          const prefix = name.toLowerCase().slice(0, 5);
+
+          if (prefix !== 'data-' && prefix !== 'aria-') {
+            node.removeAttribute(name);
+            return;
+          }
+        }
+    }
+
+    node.setAttribute(name, '' + value);
+  }
+}
+function setValueForKnownAttribute(node, name, value) {
+  if (value === null) {
+    node.removeAttribute(name);
+    return;
+  }
+
+  switch (typeof value) {
+    case 'undefined':
+    case 'function':
+    case 'symbol':
+    case 'boolean':
+      {
+        node.removeAttribute(name);
+        return;
+      }
+  }
+
+  node.setAttribute(name, '' + value);
+}
+function setValueForNamespacedAttribute(node, namespace, name, value) {
+  if (value === null) {
+    node.removeAttribute(name);
+    return;
+  }
+
+  switch (typeof value) {
+    case 'undefined':
+    case 'function':
+    case 'symbol':
+    case 'boolean':
+      {
+        node.removeAttribute(name);
+        return;
+      }
+  }
+
+  node.setAttributeNS(namespace, name, '' + value);
+}
+function setValueForPropertyOnCustomComponent(node, name, value) {
+  if (name[0] === 'o' && name[1] === 'n') {
+    const useCapture = name.endsWith('Capture');
+    const eventName = name.slice(2, useCapture ? name.length - 7 : undefined);
+    const prevProps = getFiberCurrentPropsFromNode(node);
+    const 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[incompatible-cast] value can't be casted to EventListener.
+
+
+      node.addEventListener(eventName, value, useCapture);
+      return;
+    }
+  }
+
+  if (name in node) {
+    node[name] = value;
+    return;
+  }
+
+  if (value === true) {
+    node.setAttribute(name, '');
+    return;
+  } // From here, it's the same as any attribute
+
+
+  setValueForAttribute(node, name, value);
+}
+
+let prefix;
+function describeBuiltInComponentFrame(name, source, ownerFn) {
+  {
+    if (prefix === undefined) {
+      // Extract the VM specific prefix used by each line.
+      try {
+        throw Error();
+      } catch (x) {
+        const match = x.stack.trim().match(/\n( *(at )?)/);
+        prefix = match && match[1] || '';
+      }
+    } // We use the prefix to ensure our stacks line up with native stack frames.
+
+
+    return '\n' + prefix + name;
+  }
+}
+let reentry = false;
+let componentFrameCache;
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
+
+function describeNativeComponentFrame(fn, construct) {
+  // If something asked for a stack inside a fake render, it should get ignored.
+  if (!fn || reentry) {
+    return '';
+  }
+
+  reentry = true;
+  const previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
+
+  Error.prepareStackTrace = undefined;
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
+
+
+  const RunInRootFrame = {
+    DetermineComponentFrameRoot() {
+      let control;
+
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          const Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
+
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
+
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
+
+
+          const maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
+
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(() => {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
+      }
+
+      return [null, null];
+    }
+
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  const namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
+
+  try {
+    const _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+          sampleStack = _RunInRootFrame$Deter[0],
+          controlStack = _RunInRootFrame$Deter[1];
+
+    if (sampleStack && controlStack) {
+      // This extracts the first frame from the sample that isn't also in the control.
+      // Skipping one frame that we assume is the frame that calls the two.
+      const sampleLines = sampleStack.split('\n');
+      const controlLines = controlStack.split('\n');
+      let s = 0;
+      let c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
+      }
+
+      for (; s >= 1 && c >= 0; s--, c--) {
+        // Next we find the first one that isn't the same which should be the
+        // frame that called our sample function and the control.
+        if (sampleLines[s] !== controlLines[c]) {
+          // In V8, the first line is describing the message but other VMs don't.
+          // If we're about to return the first line, and the control is also on the same
+          // line, that's a pretty good indicator that our sample threw at same line as
+          // the control. I.e. before we entered the sample frame. So we ignore this result.
+          // This can happen if you passed a class to function component, or non-function.
+          if (s !== 1 || c !== 1) {
+            do {
+              s--;
+              c--; // We may still have similar intermediate frames from the construct call.
+              // The next one that isn't the same should be our match though.
+
+              if (c < 0 || sampleLines[s] !== controlLines[c]) {
+                // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
+                let frame = '\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled "<anonymous>"
+                // but we have a user-provided "displayName"
+                // splice it in to make the stack more readable.
+
+                if (fn.displayName && frame.includes('<anonymous>')) {
+                  frame = frame.replace('<anonymous>', fn.displayName);
+                }
+
+                if (false) ; // Return the line we found.
+
+
+                return frame;
+              }
+            } while (s >= 1 && c >= 0);
+          }
+
+          break;
+        }
+      }
+    }
+  } finally {
+    reentry = false;
+
+    Error.prepareStackTrace = previousPrepareStackTrace;
+  } // Fallback to just using the name if we couldn't make it throw.
+
+
+  const name = fn ? fn.displayName || fn.name : '';
+  const syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';
+
+  return syntheticFrame;
+}
+
+function describeClassComponentFrame(ctor, source, ownerFn) {
+  {
+    return describeNativeComponentFrame(ctor, true);
+  }
+}
+function describeFunctionComponentFrame(fn, source, ownerFn) {
+  {
+    return describeNativeComponentFrame(fn, false);
+  }
+}
+
+function describeFiber(fiber) {
+
+  switch (fiber.tag) {
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      return describeBuiltInComponentFrame(fiber.type);
+
+    case LazyComponent:
+      return describeBuiltInComponentFrame('Lazy');
+
+    case SuspenseComponent:
+      return describeBuiltInComponentFrame('Suspense');
+
+    case SuspenseListComponent:
+      return describeBuiltInComponentFrame('SuspenseList');
+
+    case FunctionComponent:
+    case IndeterminateComponent:
+    case SimpleMemoComponent:
+      return describeFunctionComponentFrame(fiber.type);
+
+    case ForwardRef:
+      return describeFunctionComponentFrame(fiber.type.render);
+
+    case ClassComponent:
+      return describeClassComponentFrame(fiber.type);
+
+    default:
+      return '';
+  }
+}
+
+function getStackByFiberInDevAndProd(workInProgress) {
+  try {
+    let info = '';
+    let node = workInProgress;
+
+    do {
+      info += describeFiber(node); // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+      node = node.return;
+    } while (node);
+
+    return info;
+  } catch (x) {
+    return '\nError generating stack: ' + x.message + '\n' + x.stack;
+  }
+}
+
+function getWrappedName$1(outerType, innerType, wrapperName) {
+  const displayName = outerType.displayName;
+
+  if (displayName) {
+    return displayName;
+  }
+
+  const functionName = innerType.displayName || innerType.name || '';
+  return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
+} // Keep in sync with react-reconciler/getComponentNameFromFiber
+
+
+function getContextName$1(type) {
+  return type.displayName || 'Context';
+} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+
+function getComponentNameFromType(type) {
+  if (type == null) {
+    // Host root, text node or just invalid type.
+    return null;
+  }
+
+  if (typeof type === 'function') {
+    return type.displayName || type.name || null;
+  }
+
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_FRAGMENT_TYPE:
+      return 'Fragment';
+
+    case REACT_PORTAL_TYPE:
+      return 'Portal';
+
+    case REACT_PROFILER_TYPE:
+      return 'Profiler';
+
+    case REACT_STRICT_MODE_TYPE:
+      return 'StrictMode';
+
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+
+    case REACT_CACHE_TYPE:
+      {
+        return 'Cache';
+      }
+
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        const context = type;
+        return getContextName$1(context) + '.Consumer';
+
+      case REACT_PROVIDER_TYPE:
+        const provider = type;
+        return getContextName$1(provider._context) + '.Provider';
+
+      case REACT_FORWARD_REF_TYPE:
+        return getWrappedName$1(type, type.render, 'ForwardRef');
+
+      case REACT_MEMO_TYPE:
+        const outerName = type.displayName || null;
+
+        if (outerName !== null) {
+          return outerName;
+        }
+
+        return getComponentNameFromType(type.type) || 'Memo';
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            return getComponentNameFromType(init(payload));
+          } catch (x) {
+            return null;
+          }
+        }
+
+      case REACT_SERVER_CONTEXT_TYPE:
+        {
+          const context2 = type;
+          return (context2.displayName || context2._globalName) + '.Provider';
+        }
+
+    }
+  }
+
+  return null;
+}
+
+function getWrappedName(outerType, innerType, wrapperName) {
+  const functionName = innerType.displayName || innerType.name || '';
+  return outerType.displayName || (functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName);
+} // Keep in sync with shared/getComponentNameFromType
+
+
+function getContextName(type) {
+  return type.displayName || 'Context';
+}
+
+function getComponentNameFromFiber(fiber) {
+  const tag = fiber.tag,
+        type = fiber.type;
+
+  switch (tag) {
+    case CacheComponent:
+      return 'Cache';
+
+    case ContextConsumer:
+      const context = type;
+      return getContextName(context) + '.Consumer';
+
+    case ContextProvider:
+      const provider = type;
+      return getContextName(provider._context) + '.Provider';
+
+    case DehydratedFragment:
+      return 'DehydratedFragment';
+
+    case ForwardRef:
+      return getWrappedName(type, type.render, 'ForwardRef');
+
+    case Fragment:
+      return 'Fragment';
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      // Host component type is the display name (e.g. "div", "View")
+      return type;
+
+    case HostPortal:
+      return 'Portal';
+
+    case HostRoot:
+      return 'Root';
+
+    case HostText:
+      return 'Text';
+
+    case LazyComponent:
+      // Name comes from the type in this case; we don't have a tag.
+      return getComponentNameFromType(type);
+
+    case Mode:
+      if (type === REACT_STRICT_MODE_TYPE) {
+        // Don't be less specific than shared/getComponentNameFromType
+        return 'StrictMode';
+      }
+
+      return 'Mode';
+
+    case OffscreenComponent:
+      return 'Offscreen';
+
+    case Profiler:
+      return 'Profiler';
+
+    case ScopeComponent:
+      return 'Scope';
+
+    case SuspenseComponent:
+      return 'Suspense';
+
+    case SuspenseListComponent:
+      return 'SuspenseList';
+
+    case TracingMarkerComponent:
+      return 'TracingMarker';
+    // The display name for this tags come from the user-provided type:
+
+    case ClassComponent:
+    case FunctionComponent:
+    case IncompleteClassComponent:
+    case IndeterminateComponent:
+    case MemoComponent:
+    case SimpleMemoComponent:
+      if (typeof type === 'function') {
+        return type.displayName || type.name || null;
+      }
+
+      if (typeof type === 'string') {
+        return type;
+      }
+
+      break;
+
+  }
+
+  return null;
+}
+
+// around this limitation, we use an opaque type that can only be obtained by
+// passing the value through getToStringValue first.
+
+function toString(value) {
+  // The coercion safety check is performed in getToStringValue().
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  return '' + value;
+}
+function getToStringValue(value) {
+  switch (typeof value) {
+    case 'boolean':
+    case 'number':
+    case 'string':
+    case 'undefined':
+      return value;
+
+    case 'object':
+
+      return value;
+
+    default:
+      // function, symbol are assigned as empty strings
+      return '';
+  }
+}
+
+function isCheckable(elem) {
+  const type = elem.type;
+  const nodeName = elem.nodeName;
+  return nodeName && nodeName.toLowerCase() === 'input' && (type === 'checkbox' || type === 'radio');
+}
+
+function getTracker(node) {
+  return node._valueTracker;
+}
+
+function detachTracker(node) {
+  node._valueTracker = null;
+}
+
+function getValueFromNode(node) {
+  let value = '';
+
+  if (!node) {
+    return value;
+  }
+
+  if (isCheckable(node)) {
+    value = node.checked ? 'true' : 'false';
+  } else {
+    value = node.value;
+  }
+
+  return value;
+}
+
+function trackValueOnNode(node) {
+  const valueField = isCheckable(node) ? 'checked' : 'value';
+  const descriptor = Object.getOwnPropertyDescriptor(node.constructor.prototype, valueField);
+
+  let currentValue = '' + node[valueField]; // if someone has already defined a value or Safari, then bail
+  // and don't track value will cause over reporting of changes,
+  // but it's better then a hard failure
+  // (needed for certain tests that spyOn input values and Safari)
+
+  if (node.hasOwnProperty(valueField) || typeof descriptor === 'undefined' || typeof descriptor.get !== 'function' || typeof descriptor.set !== 'function') {
+    return;
+  }
+
+  const get = descriptor.get,
+        set = descriptor.set;
+  Object.defineProperty(node, valueField, {
+    configurable: true,
+    // $FlowFixMe[missing-this-annot]
+    get: function () {
+      return get.call(this);
+    },
+    // $FlowFixMe[missing-local-annot]
+    // $FlowFixMe[missing-this-annot]
+    set: function (value) {
+
+      currentValue = '' + value;
+      set.call(this, value);
+    }
+  }); // We could've passed this the first time
+  // but it triggers a bug in IE11 and Edge 14/15.
+  // Calling defineProperty() again should be equivalent.
+  // https://github.com/facebook/react/issues/11768
+
+  Object.defineProperty(node, valueField, {
+    enumerable: descriptor.enumerable
+  });
+  const tracker = {
+    getValue() {
+      return currentValue;
+    },
+
+    setValue(value) {
+
+      currentValue = '' + value;
+    },
+
+    stopTracking() {
+      detachTracker(node);
+      delete node[valueField];
+    }
+
+  };
+  return tracker;
+}
+
+function track(node) {
+  if (getTracker(node)) {
+    return;
+  }
+
+  node._valueTracker = trackValueOnNode(node);
+}
+function updateValueIfChanged(node) {
+  if (!node) {
+    return false;
+  }
+
+  const tracker = getTracker(node); // if there is no tracker at this point it's unlikely
+  // that trying again will succeed
+
+  if (!tracker) {
+    return true;
+  }
+
+  const lastValue = tracker.getValue();
+  const nextValue = getValueFromNode(node);
+
+  if (nextValue !== lastValue) {
+    tracker.setValue(nextValue);
+    return true;
+  }
+
+  return false;
+}
+
+function getActiveElement(doc) {
+  doc = doc || (typeof document !== 'undefined' ? document : undefined);
+
+  if (typeof doc === 'undefined') {
+    return null;
+  }
+
+  try {
+    return doc.activeElement || doc.body;
+  } catch (e) {
+    return doc.body;
+  }
+}
+
+// When passing user input into querySelector(All) the embedded string must not alter
+// the semantics of the query. This escape function is safe to use when we know the
+// provided value is going to be wrapped in double quotes as part of an attribute selector
+// Do not use it anywhere else
+// we escape double quotes and backslashes
+const escapeSelectorAttributeValueInsideDoubleQuotesRegex = /[\n\"\\]/g;
+function escapeSelectorAttributeValueInsideDoubleQuotes(value) {
+  return value.replace(escapeSelectorAttributeValueInsideDoubleQuotesRegex, ch => '\\' + ch.charCodeAt(0).toString(16) + ' ');
+}
+
+function updateInput(element, value, defaultValue, lastDefaultValue, checked, defaultChecked, type, name) {
+  const node = element; // Temporarily disconnect the input from any radio buttons.
+  // Changing the type or name as the same time as changing the checked value
+  // needs to be atomically applied. We can only ensure that by disconnecting
+  // the name while do the mutations and then reapply the name after that's done.
+
+  node.name = '';
+
+  if (type != null && typeof type !== 'function' && typeof type !== 'symbol' && typeof type !== 'boolean') {
+
+    node.type = type;
+  } else {
+    node.removeAttribute('type');
+  }
+
+  if (value != null) {
+    if (type === 'number') {
+      if ( // $FlowFixMe[incompatible-type]
+      value === 0 && node.value === '' || // We explicitly want to coerce to number here if possible.
+      // eslint-disable-next-line
+      node.value != value) {
+        node.value = toString(getToStringValue(value));
+      }
+    } else if (node.value !== toString(getToStringValue(value))) {
+      node.value = toString(getToStringValue(value));
+    }
+  } else if (type === 'submit' || type === 'reset') {
+    // Submit/reset inputs need the attribute removed completely to avoid
+    // blank-text buttons.
+    node.removeAttribute('value');
+  }
+
+  {
+    // When syncing the value attribute, the value comes from a cascade of
+    // properties:
+    //  1. The value React property
+    //  2. The defaultValue React property
+    //  3. Otherwise there should be no change
+    if (value != null) {
+      setDefaultValue(node, type, getToStringValue(value));
+    } else if (defaultValue != null) {
+      setDefaultValue(node, type, getToStringValue(defaultValue));
+    } else if (lastDefaultValue != null) {
+      node.removeAttribute('value');
+    }
+  }
+
+  {
+    // 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 (checked == null && defaultChecked != null) {
+      node.defaultChecked = !!defaultChecked;
+    }
+  }
+
+  if (checked != null) {
+    // Important to set this even if it's not a change in order to update input
+    // value tracking with radio buttons
+    // TODO: Should really update input value tracking for the whole radio
+    // button group in an effect or something (similar to #27024)
+    node.checked = checked && typeof checked !== 'function' && typeof checked !== 'symbol';
+  }
+
+  if (name != null && typeof name !== 'function' && typeof name !== 'symbol' && typeof name !== 'boolean') {
+
+    node.name = toString(getToStringValue(name));
+  } else {
+    node.removeAttribute('name');
+  }
+}
+function initInput(element, value, defaultValue, checked, defaultChecked, type, name, isHydrating) {
+  const node = element;
+
+  if (type != null && typeof type !== 'function' && typeof type !== 'symbol' && typeof type !== 'boolean') {
+
+    node.type = type;
+  }
+
+  if (value != null || defaultValue != null) {
+    const isButton = type === 'submit' || type === 'reset'; // Avoid setting value attribute on submit/reset inputs as it overrides the
+    // default value provided by the browser. See: #12872
+
+    if (isButton && (value === undefined || value === null)) {
+      return;
+    }
+
+    const defaultValueStr = defaultValue != null ? toString(getToStringValue(defaultValue)) : '';
+    const initialValue = value != null ? toString(getToStringValue(value)) : defaultValueStr; // Do not assign value if it is already set. This prevents user text input
+    // from being lost during SSR hydration.
+
+    if (!isHydrating) {
+      {
+        // When syncing the value attribute, the value property should use
+        // the wrapperState._initialValue property. This uses:
+        //
+        //   1. The value React property when present
+        //   2. The defaultValue React property when present
+        //   3. An empty string
+        if (initialValue !== node.value) {
+          node.value = initialValue;
+        }
+      }
+    }
+
+    {
+      // Otherwise, the value attribute is synchronized to the property,
+      // so we assign defaultValue to the same thing as the value property
+      // assignment step above.
+      node.defaultValue = initialValue;
+    }
+  } // Normally, we'd just do `node.checked = node.checked` upon initial mount, less this bug
+  // this is needed to work around a chrome bug where setting defaultChecked
+  // will sometimes influence the value of checked (even after detachment).
+  // Reference: https://bugs.chromium.org/p/chromium/issues/detail?id=608416
+  // We need to temporarily unset name to avoid disrupting radio button groups.
+
+
+  const checkedOrDefault = checked != null ? checked : defaultChecked; // TODO: This 'function' or 'symbol' check isn't replicated in other places
+  // so this semantic is inconsistent.
+
+  const initialChecked = typeof checkedOrDefault !== 'function' && typeof checkedOrDefault !== 'symbol' && !!checkedOrDefault;
+
+  if (isHydrating) {
+    // Detach .checked from .defaultChecked but leave user input alone
+    node.checked = node.checked;
+  } else {
+    node.checked = !!initialChecked;
+  }
+
+  {
+    // When syncing the checked attribute, both the checked property and
+    // attribute are assigned at the same time using defaultChecked. This uses:
+    //
+    //   1. The checked React property when present
+    //   2. The defaultChecked React property when present
+    //   3. Otherwise, false
+    node.defaultChecked = !node.defaultChecked;
+    node.defaultChecked = !!initialChecked;
+  } // Name needs to be set at the end so that it applies atomically to connected radio buttons.
+
+
+  if (name != null && typeof name !== 'function' && typeof name !== 'symbol' && typeof name !== 'boolean') {
+
+    node.name = name;
+  }
+}
+function restoreControlledInputState(element, props) {
+  const rootNode = element;
+  updateInput(rootNode, props.value, props.defaultValue, props.defaultValue, props.checked, props.defaultChecked, props.type, props.name);
+  const name = props.name;
+
+  if (props.type === 'radio' && name != null) {
+    let queryRoot = rootNode;
+
+    while (queryRoot.parentNode) {
+      queryRoot = queryRoot.parentNode;
+    } // If `rootNode.form` was non-null, then we could try `form.elements`,
+
+    const group = queryRoot.querySelectorAll('input[name="' + escapeSelectorAttributeValueInsideDoubleQuotes('' + name) + '"][type="radio"]');
+
+    for (let i = 0; i < group.length; i++) {
+      const otherNode = group[i];
+
+      if (otherNode === rootNode || otherNode.form !== rootNode.form) {
+        continue;
+      } // This will throw if radio buttons rendered by different copies of React
+      // and the same name are rendered into the same form (same as #1939).
+      // That's probably okay; we don't support it just as we don't support
+      // mixing React radio buttons with non-React ones.
+
+
+      const otherProps = getFiberCurrentPropsFromNode(otherNode);
+
+      if (!otherProps) {
+        throw Error(formatProdErrorMessage(90));
+      } // If this is a controlled radio button group, forcing the input that
+      // was previously checked to update will cause it to be come re-checked
+      // as appropriate.
+
+
+      updateInput(otherNode, otherProps.value, otherProps.defaultValue, otherProps.defaultValue, otherProps.checked, otherProps.defaultChecked, otherProps.type, otherProps.name);
+    } // If any updateInput() call set .checked to true, an input in this group
+    // (often, `rootNode` itself) may have become unchecked
+
+
+    for (let i = 0; i < group.length; i++) {
+      const otherNode = group[i];
+
+      if (otherNode.form !== rootNode.form) {
+        continue;
+      }
+
+      updateValueIfChanged(otherNode);
+    }
+  }
+} // In Chrome, assigning defaultValue to certain input types triggers input validation.
+// For number inputs, the display value loses trailing decimal points. For email inputs,
+// Chrome raises "The specified value <x> is not a valid email address".
+//
+// Here we check to see if the defaultValue has actually changed, avoiding these problems
+// when the user is inputting text
+//
+// https://github.com/facebook/react/issues/7253
+
+function setDefaultValue(node, type, value) {
+  if ( // Focused number inputs synchronize on blur. See ChangeEventPlugin.js
+  type !== 'number' || getActiveElement(node.ownerDocument) !== node) {
+    if (node.defaultValue !== toString(value)) {
+      node.defaultValue = toString(value);
+    }
+  }
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+// TODO: direct imports like some-package/src/* are bad. Fix me.
+
+function updateOptions(node, multiple, propValue, setDefaultSelected) {
+  const options = node.options;
+
+  if (multiple) {
+    const selectedValues = propValue;
+    const selectedValue = {};
+
+    for (let i = 0; i < selectedValues.length; i++) {
+      // Prefix to avoid chaos with special keys.
+      selectedValue['$' + selectedValues[i]] = true;
+    }
+
+    for (let i = 0; i < options.length; i++) {
+      const selected = selectedValue.hasOwnProperty('$' + options[i].value);
+
+      if (options[i].selected !== selected) {
+        options[i].selected = selected;
+      }
+
+      if (selected && setDefaultSelected) {
+        options[i].defaultSelected = true;
+      }
+    }
+  } else {
+    // Do not set `select.value` as exact behavior isn't consistent across all
+    // browsers for all cases.
+    const selectedValue = toString(getToStringValue(propValue));
+    let defaultSelected = null;
+
+    for (let i = 0; i < options.length; i++) {
+      if (options[i].value === selectedValue) {
+        options[i].selected = true;
+
+        if (setDefaultSelected) {
+          options[i].defaultSelected = true;
+        }
+
+        return;
+      }
+
+      if (defaultSelected === null && !options[i].disabled) {
+        defaultSelected = options[i];
+      }
+    }
+
+    if (defaultSelected !== null) {
+      defaultSelected.selected = true;
+    }
+  }
+}
+function initSelect(element, value, defaultValue, multiple) {
+  const node = element;
+  node.multiple = !!multiple;
+
+  if (value != null) {
+    updateOptions(node, !!multiple, value, false);
+  } else if (defaultValue != null) {
+    updateOptions(node, !!multiple, defaultValue, true);
+  }
+}
+function updateSelect(element, value, defaultValue, multiple, wasMultiple) {
+  const node = element;
+
+  if (value != null) {
+    updateOptions(node, !!multiple, value, false);
+  } else if (!!wasMultiple !== !!multiple) {
+    // For simplicity, reapply `defaultValue` if `multiple` is toggled.
+    if (defaultValue != null) {
+      updateOptions(node, !!multiple, defaultValue, true);
+    } else {
+      // Revert the select back to its default unselected state.
+      updateOptions(node, !!multiple, multiple ? [] : '', false);
+    }
+  }
+}
+function restoreControlledSelectState(element, props) {
+  const node = element;
+  const value = props.value;
+
+  if (value != null) {
+    updateOptions(node, !!props.multiple, value, false);
+  }
+}
+
+function updateTextarea(element, value, defaultValue) {
+  const node = element;
+
+  if (value != null) {
+    // Cast `value` to a string to ensure the value is set correctly. While
+    // browsers typically do this as necessary, jsdom doesn't.
+    const newValue = toString(getToStringValue(value)); // To avoid side effects (such as losing text selection), only set value if changed
+
+    if (newValue !== node.value) {
+      node.value = newValue;
+    } // TOOO: This should respect disableInputAttributeSyncing flag.
+
+
+    if (defaultValue == null) {
+      if (node.defaultValue !== newValue) {
+        node.defaultValue = newValue;
+      }
+
+      return;
+    }
+  }
+
+  if (defaultValue != null) {
+    node.defaultValue = toString(getToStringValue(defaultValue));
+  } else {
+    node.defaultValue = '';
+  }
+}
+function initTextarea(element, value, defaultValue, children) {
+  const node = element;
+  let initialValue = value; // Only bother fetching default value if we're going to use it
+
+  if (initialValue == null) {
+    if (children != null) {
+      {
+        if (defaultValue != null) {
+          throw Error(formatProdErrorMessage(92));
+        }
+
+        if (isArray(children)) {
+          if (children.length > 1) {
+            throw Error(formatProdErrorMessage(93));
+          }
+
+          children = children[0];
+        }
+
+        defaultValue = children;
+      }
+    }
+
+    if (defaultValue == null) {
+      defaultValue = '';
+    }
+
+    initialValue = defaultValue;
+  }
+
+  const stringValue = getToStringValue(initialValue);
+  node.defaultValue = stringValue; // This will be toString:ed.
+  // This is in postMount because we need access to the DOM node, which is not
+  // available until after the component has mounted.
+
+  const textContent = node.textContent; // Only set node.value if textContent is equal to the expected
+  // initial value. In IE10/IE11 there is a bug where the placeholder attribute
+  // will populate textContent as well.
+  // https://developer.microsoft.com/microsoft-edge/platform/issues/101525/
+
+  if (textContent === stringValue) {
+    if (textContent !== '' && textContent !== null) {
+      node.value = textContent;
+    }
+  }
+}
+function restoreControlledTextareaState(element, props) {
+  // DOM component is still mounted; update
+  updateTextarea(element, props.value, props.defaultValue);
+}
+
+const MATH_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
+const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
+
+/* globals MSApp */
+
+if (typeof MSApp !== 'undefined' && MSApp.execUnsafeLocalFunction) ;
+
+/**
+ * HTML nodeType values that represent the type of the node
+ */
+const ELEMENT_NODE = 1;
+const TEXT_NODE = 3;
+const COMMENT_NODE = 8;
+const DOCUMENT_NODE = 9;
+const DOCUMENT_TYPE_NODE = 10;
+const DOCUMENT_FRAGMENT_NODE = 11;
+
+/**
+ * Set the textContent property of a node. For text updates, it's faster
+ * to set the `nodeValue` of the Text node directly instead of using
+ * `.textContent` which will remove the existing node and create a new one.
+ *
+ * @param {DOMElement} node
+ * @param {string} text
+ * @internal
+ */
+
+function setTextContent(node, text) {
+  if (text) {
+    const firstChild = node.firstChild;
+
+    if (firstChild && firstChild === node.lastChild && firstChild.nodeType === TEXT_NODE) {
+      firstChild.nodeValue = text;
+      return;
+    }
+  }
+
+  node.textContent = text;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+const unitlessNumbers = new Set(['animationIterationCount', 'aspectRatio', 'borderImageOutset', 'borderImageSlice', 'borderImageWidth', 'boxFlex', 'boxFlexGroup', 'boxOrdinalGroup', 'columnCount', 'columns', 'flex', 'flexGrow', 'flexPositive', 'flexShrink', 'flexNegative', 'flexOrder', 'gridArea', 'gridRow', 'gridRowEnd', 'gridRowSpan', 'gridRowStart', 'gridColumn', 'gridColumnEnd', 'gridColumnSpan', 'gridColumnStart', 'fontWeight', 'lineClamp', 'lineHeight', 'opacity', 'order', 'orphans', 'scale', 'tabSize', 'widows', 'zIndex', 'zoom', 'fillOpacity', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'MozBoxFlexGroup', 'MozLineClamp', 'msAnimationIterationCount', 'msFlex', 'msZoom', 'msFlexGrow', 'msFlexNegative', 'msFlexOrder', 'msFlexPositive', 'msFlexShrink', 'msGridColumn', 'msGridColumnSpan', 'msGridRow', 'msGridRowSpan', 'WebkitAnimationIterationCount', 'WebkitBoxFlex', 'WebKitBoxFlexGroup', 'WebkitBoxOrdinalGroup', 'WebkitColumnCount', 'WebkitColumns', 'WebkitFlex', 'WebkitFlexGrow', 'WebkitFlexPositive', 'WebkitFlexShrink', 'WebkitLineClamp']);
+function isUnitlessNumber (name) {
+  return unitlessNumbers.has(name);
+}
+
+function setValueForStyle(style, styleName, value) {
+  const isCustomProperty = styleName.indexOf('--') === 0;
+
+  if (value == null || typeof value === 'boolean' || value === '') {
+    if (isCustomProperty) {
+      style.setProperty(styleName, '');
+    } else if (styleName === 'float') {
+      style.cssFloat = '';
+    } else {
+      style[styleName] = '';
+    }
+  } else if (isCustomProperty) {
+    style.setProperty(styleName, value);
+  } else if (typeof value === 'number' && value !== 0 && !isUnitlessNumber(styleName)) {
+    style[styleName] = value + 'px'; // Presumes implicit 'px' suffix for unitless numbers
+  } else {
+    if (styleName === 'float') {
+      style.cssFloat = value;
+    } else {
+
+      style[styleName] = ('' + value).trim();
+    }
+  }
+}
+/**
+ * Sets the value for multiple styles on a node.  If a value is specified as
+ * '' (empty string), the corresponding style property will be unset.
+ *
+ * @param {DOMElement} node
+ * @param {object} styles
+ */
+
+
+function setValueForStyles(node, styles, prevStyles) {
+  if (styles != null && typeof styles !== 'object') {
+    throw Error(formatProdErrorMessage(62));
+  }
+
+  const style = node.style;
+
+  if (prevStyles != null) {
+
+    for (const styleName in prevStyles) {
+      if (prevStyles.hasOwnProperty(styleName) && (styles == null || !styles.hasOwnProperty(styleName))) {
+        // Clear style
+        const isCustomProperty = styleName.indexOf('--') === 0;
+
+        if (isCustomProperty) {
+          style.setProperty(styleName, '');
+        } else if (styleName === 'float') {
+          style.cssFloat = '';
+        } else {
+          style[styleName] = '';
+        }
+      }
+    }
+
+    for (const styleName in styles) {
+      const value = styles[styleName];
+
+      if (styles.hasOwnProperty(styleName) && prevStyles[styleName] !== value) {
+        setValueForStyle(style, styleName, value);
+      }
+    }
+  } else {
+    for (const styleName in styles) {
+      if (styles.hasOwnProperty(styleName)) {
+        const value = styles[styleName];
+        setValueForStyle(style, styleName, value);
+      }
+    }
+  }
+}
+
+function isCustomElement(tagName, props) {
+  if (tagName.indexOf('-') === -1) {
+    return false;
+  }
+
+  switch (tagName) {
+    // These are reserved SVG and MathML elements.
+    // We don't mind this list too much because we expect it to never grow.
+    // The alternative is to track the namespace in a few places which is convoluted.
+    // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+    case 'annotation-xml':
+    case 'color-profile':
+    case 'font-face':
+    case 'font-face-src':
+    case 'font-face-uri':
+    case 'font-face-format':
+    case 'font-face-name':
+    case 'missing-glyph':
+      return false;
+
+    default:
+      return true;
+  }
+}
+
+const aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+  return aliases.get(name) || name;
+}
+
+function sanitizeURL(url) {
+
+  return url;
+}
+
+const IS_EVENT_HANDLE_NON_MANAGED_NODE = 1;
+const IS_NON_DELEGATED = 1 << 1;
+const IS_CAPTURE_PHASE = 1 << 2;
+// 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.
+// We also don't want to defer during event replaying.
+
+const SHOULD_NOT_PROCESS_POLYFILL_EVENT_PLUGINS = IS_EVENT_HANDLE_NON_MANAGED_NODE | IS_NON_DELEGATED | IS_CAPTURE_PHASE;
+
+// This exists to avoid circular dependency between ReactDOMEventReplaying
+// and DOMPluginEventSystem.
+let currentReplayingEvent = null;
+function setReplayingEvent(event) {
+
+  currentReplayingEvent = event;
+}
+function resetReplayingEvent() {
+
+  currentReplayingEvent = null;
+}
+function isReplayingEvent(event) {
+  return event === currentReplayingEvent;
+}
+
+/**
+ * Gets the target node from a native browser event by accounting for
+ * inconsistencies in browser DOM APIs.
+ *
+ * @param {object} nativeEvent Native browser event.
+ * @return {DOMEventTarget} Target node.
+ */
+
+function getEventTarget(nativeEvent) {
+  // Fallback to nativeEvent.srcElement for IE9
+  // https://github.com/facebook/react/issues/12506
+  let target = nativeEvent.target || nativeEvent.srcElement || window; // Normalize SVG <use> element events #4963
+
+  if (target.correspondingUseElement) {
+    target = target.correspondingUseElement;
+  } // Safari may fire events on text nodes (Node.TEXT_NODE is 3).
+  // @see http://www.quirksmode.org/js/events_properties.html
+
+
+  return target.nodeType === TEXT_NODE ? target.parentNode : target;
+}
+
+let restoreTarget = null;
+let restoreQueue = null;
+
+function restoreStateOfTarget(target) {
+  // We perform this translation at the end of the event loop so that we
+  // always receive the correct fiber here
+  const internalInstance = getInstanceFromNode(target);
+
+  if (!internalInstance) {
+    // Unmounted
+    return;
+  }
+
+  const stateNode = internalInstance.stateNode; // Guard against Fiber being unmounted.
+
+  if (stateNode) {
+    const props = getFiberCurrentPropsFromNode(stateNode);
+    restoreControlledState(internalInstance.stateNode, internalInstance.type, props);
+  }
+}
+
+function enqueueStateRestore(target) {
+  if (restoreTarget) {
+    if (restoreQueue) {
+      restoreQueue.push(target);
+    } else {
+      restoreQueue = [target];
+    }
+  } else {
+    restoreTarget = target;
+  }
+}
+function needsStateRestore() {
+  return restoreTarget !== null || restoreQueue !== null;
+}
+function restoreStateIfNeeded() {
+  if (!restoreTarget) {
+    return;
+  }
+
+  const target = restoreTarget;
+  const queuedTargets = restoreQueue;
+  restoreTarget = null;
+  restoreQueue = null;
+  restoreStateOfTarget(target);
+
+  if (queuedTargets) {
+    for (let i = 0; i < queuedTargets.length; i++) {
+      restoreStateOfTarget(queuedTargets[i]);
+    }
+  }
+}
+
+/**
+ * `ReactInstanceMap` maintains a mapping from a public facing stateful
+ * instance (key) and the internal representation (value). This allows public
+ * methods to accept the user facing instance as an argument and map them back
+ * to internal methods.
+ *
+ * Note that this module is currently shared and assumed to be stateless.
+ * If this becomes an actual Map, that will break.
+ */
+function get(key) {
+  return key._reactInternals;
+}
+function has(key) {
+  return key._reactInternals !== undefined;
+}
+function set(key, value) {
+  key._reactInternals = value;
+}
+
+function getNearestMountedFiber(fiber) {
+  let node = fiber;
+  let nearestMounted = fiber;
+
+  if (!fiber.alternate) {
+    // If there is no alternate, this might be a new tree that isn't inserted
+    // yet. If it is, then it will have a pending insertion effect on it.
+    let nextNode = node;
+
+    do {
+      node = nextNode;
+
+      if ((node.flags & (Placement | Hydrating)) !== NoFlags$1) {
+        // This is an insertion or in-progress hydration. The nearest possible
+        // mounted fiber is the parent but we need to continue to figure out
+        // if that one is still mounted.
+        nearestMounted = node.return;
+      } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+      nextNode = node.return;
+    } while (nextNode);
+  } else {
+    while (node.return) {
+      node = node.return;
+    }
+  }
+
+  if (node.tag === HostRoot) {
+    // TODO: Check if this was a nested HostRoot when used with
+    // renderContainerIntoSubtree.
+    return nearestMounted;
+  } // If we didn't hit the root, that means that we're in an disconnected tree
+  // that has been unmounted.
+
+
+  return null;
+}
+function getSuspenseInstanceFromFiber(fiber) {
+  if (fiber.tag === SuspenseComponent) {
+    let suspenseState = fiber.memoizedState;
+
+    if (suspenseState === null) {
+      const current = fiber.alternate;
+
+      if (current !== null) {
+        suspenseState = current.memoizedState;
+      }
+    }
+
+    if (suspenseState !== null) {
+      return suspenseState.dehydrated;
+    }
+  }
+
+  return null;
+}
+function getContainerFromFiber(fiber) {
+  return fiber.tag === HostRoot ? fiber.stateNode.containerInfo : null;
+}
+function isFiberMounted(fiber) {
+  return getNearestMountedFiber(fiber) === fiber;
+}
+function isMounted(component) {
+
+  const fiber = get(component);
+
+  if (!fiber) {
+    return false;
+  }
+
+  return getNearestMountedFiber(fiber) === fiber;
+}
+
+function assertIsMounted(fiber) {
+  if (getNearestMountedFiber(fiber) !== fiber) {
+    throw Error(formatProdErrorMessage(188));
+  }
+}
+
+function findCurrentFiberUsingSlowPath(fiber) {
+  const alternate = fiber.alternate;
+
+  if (!alternate) {
+    // If there is no alternate, then we only need to check if it is mounted.
+    const nearestMounted = getNearestMountedFiber(fiber);
+
+    if (nearestMounted === null) {
+      throw Error(formatProdErrorMessage(188));
+    }
+
+    if (nearestMounted !== fiber) {
+      return null;
+    }
+
+    return fiber;
+  } // If we have two possible branches, we'll walk backwards up to the root
+  // to see what path the root points to. On the way we may hit one of the
+  // special cases and we'll deal with them.
+
+
+  let a = fiber;
+  let b = alternate;
+
+  while (true) {
+    const parentA = a.return;
+
+    if (parentA === null) {
+      // We're at the root.
+      break;
+    }
+
+    const parentB = parentA.alternate;
+
+    if (parentB === null) {
+      // There is no alternate. This is an unusual case. Currently, it only
+      // happens when a Suspense component is hidden. An extra fragment fiber
+      // is inserted in between the Suspense fiber and its children. Skip
+      // over this extra fragment fiber and proceed to the next parent.
+      const nextParent = parentA.return;
+
+      if (nextParent !== null) {
+        a = b = nextParent;
+        continue;
+      } // If there's no parent, we're at the root.
+
+
+      break;
+    } // If both copies of the parent fiber point to the same child, we can
+    // assume that the child is current. This happens when we bailout on low
+    // priority: the bailed out fiber's child reuses the current child.
+
+
+    if (parentA.child === parentB.child) {
+      let child = parentA.child;
+
+      while (child) {
+        if (child === a) {
+          // We've determined that A is the current branch.
+          assertIsMounted(parentA);
+          return fiber;
+        }
+
+        if (child === b) {
+          // We've determined that B is the current branch.
+          assertIsMounted(parentA);
+          return alternate;
+        }
+
+        child = child.sibling;
+      } // We should never have an alternate for any mounting node. So the only
+      // way this could possibly happen is if this was unmounted, if at all.
+
+
+      throw Error(formatProdErrorMessage(188));
+    }
+
+    if (a.return !== b.return) {
+      // The return pointer of A and the return pointer of B point to different
+      // fibers. We assume that return pointers never criss-cross, so A must
+      // belong to the child set of A.return, and B must belong to the child
+      // set of B.return.
+      a = parentA;
+      b = parentB;
+    } else {
+      // The return pointers point to the same fiber. We'll have to use the
+      // default, slow path: scan the child sets of each parent alternate to see
+      // which child belongs to which set.
+      //
+      // Search parent A's child set
+      let didFindChild = false;
+      let child = parentA.child;
+
+      while (child) {
+        if (child === a) {
+          didFindChild = true;
+          a = parentA;
+          b = parentB;
+          break;
+        }
+
+        if (child === b) {
+          didFindChild = true;
+          b = parentA;
+          a = parentB;
+          break;
+        }
+
+        child = child.sibling;
+      }
+
+      if (!didFindChild) {
+        // Search parent B's child set
+        child = parentB.child;
+
+        while (child) {
+          if (child === a) {
+            didFindChild = true;
+            a = parentB;
+            b = parentA;
+            break;
+          }
+
+          if (child === b) {
+            didFindChild = true;
+            b = parentB;
+            a = parentA;
+            break;
+          }
+
+          child = child.sibling;
+        }
+
+        if (!didFindChild) {
+          throw Error(formatProdErrorMessage(189));
+        }
+      }
+    }
+
+    if (a.alternate !== b) {
+      throw Error(formatProdErrorMessage(190));
+    }
+  } // If the root is not a host container, we're in a disconnected tree. I.e.
+  // unmounted.
+
+
+  if (a.tag !== HostRoot) {
+    throw Error(formatProdErrorMessage(188));
+  }
+
+  if (a.stateNode.current === a) {
+    // We've determined that A is the current branch.
+    return fiber;
+  } // Otherwise B has to be current branch.
+
+
+  return alternate;
+}
+function findCurrentHostFiber(parent) {
+  const currentParent = findCurrentFiberUsingSlowPath(parent);
+  return currentParent !== null ? findCurrentHostFiberImpl(currentParent) : null;
+}
+
+function findCurrentHostFiberImpl(node) {
+  // Next we'll drill down this component to find the first HostComponent/Text.
+  const tag = node.tag;
+
+  if (tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton ) || tag === HostText) {
+    return node;
+  }
+
+  let child = node.child;
+
+  while (child !== null) {
+    const match = findCurrentHostFiberImpl(child);
+
+    if (match !== null) {
+      return match;
+    }
+
+    child = child.sibling;
+  }
+
+  return null;
+}
+
+const emptyContextObject = {};
+
+
+const contextStackCursor = createCursor(emptyContextObject); // A cursor to a boolean indicating whether the context has changed.
+
+const didPerformWorkStackCursor = createCursor(false); // Keep track of the previous context object that was on the stack.
+// We use this to get access to the parent context after we have already
+// pushed the next context provider, and now need to merge their contexts.
+
+let previousContext = emptyContextObject;
+
+function getUnmaskedContext(workInProgress, Component, didPushOwnContextIfProvider) {
+  {
+    if (didPushOwnContextIfProvider && isContextProvider(Component)) {
+      // If the fiber is a context provider itself, when we read its context
+      // we may have already pushed its own child context on the stack. A context
+      // provider should not "see" its own child context. Therefore we read the
+      // previous (parent) context instead for a context provider.
+      return previousContext;
+    }
+
+    return contextStackCursor.current;
+  }
+}
+
+function cacheContext(workInProgress, unmaskedContext, maskedContext) {
+  {
+    const instance = workInProgress.stateNode;
+    instance.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext;
+    instance.__reactInternalMemoizedMaskedChildContext = maskedContext;
+  }
+}
+
+function getMaskedContext(workInProgress, unmaskedContext) {
+  {
+    const type = workInProgress.type;
+    const contextTypes = type.contextTypes;
+
+    if (!contextTypes) {
+      return emptyContextObject;
+    } // Avoid recreating masked context unless unmasked context has changed.
+    // Failing to do this will result in unnecessary calls to componentWillReceiveProps.
+    // This may trigger infinite loops if componentWillReceiveProps calls setState.
+
+
+    const instance = workInProgress.stateNode;
+
+    if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) {
+      return instance.__reactInternalMemoizedMaskedChildContext;
+    }
+
+    const context = {};
+
+    for (const key in contextTypes) {
+      context[key] = unmaskedContext[key];
+    }
+    // Context is created before the class component is instantiated so check for instance.
+
+
+    if (instance) {
+      cacheContext(workInProgress, unmaskedContext, context);
+    }
+
+    return context;
+  }
+}
+
+function hasContextChanged() {
+  {
+    return didPerformWorkStackCursor.current;
+  }
+}
+
+function isContextProvider(type) {
+  {
+    const childContextTypes = type.childContextTypes;
+    return childContextTypes !== null && childContextTypes !== undefined;
+  }
+}
+
+function popContext(fiber) {
+  {
+    pop(didPerformWorkStackCursor);
+    pop(contextStackCursor);
+  }
+}
+
+function popTopLevelContextObject(fiber) {
+  {
+    pop(didPerformWorkStackCursor);
+    pop(contextStackCursor);
+  }
+}
+
+function pushTopLevelContextObject(fiber, context, didChange) {
+  {
+    if (contextStackCursor.current !== emptyContextObject) {
+      throw Error(formatProdErrorMessage(168));
+    }
+
+    push(contextStackCursor, context);
+    push(didPerformWorkStackCursor, didChange);
+  }
+}
+
+function processChildContext(fiber, type, parentContext) {
+  {
+    const instance = fiber.stateNode;
+    const childContextTypes = type.childContextTypes; // TODO (bvaughn) Replace this behavior with an invariant() in the future.
+    // It has only been added in Fiber to match the (unintentional) behavior in Stack.
+
+    if (typeof instance.getChildContext !== 'function') {
+
+      return parentContext;
+    }
+
+    const childContext = instance.getChildContext();
+
+    for (const contextKey in childContext) {
+      if (!(contextKey in childContextTypes)) {
+        throw Error(formatProdErrorMessage(108, getComponentNameFromFiber(fiber) || 'Unknown', contextKey));
+      }
+    }
+
+    return assign({}, parentContext, childContext);
+  }
+}
+
+function pushContextProvider(workInProgress) {
+  {
+    const instance = workInProgress.stateNode; // We push the context as early as possible to ensure stack integrity.
+    // If the instance does not exist yet, we will push null at first,
+    // and replace it on the stack later when invalidating the context.
+
+    const memoizedMergedChildContext = instance && instance.__reactInternalMemoizedMergedChildContext || emptyContextObject; // Remember the parent context so we can merge with it later.
+    // Inherit the parent's did-perform-work value to avoid inadvertently blocking updates.
+
+    previousContext = contextStackCursor.current;
+    push(contextStackCursor, memoizedMergedChildContext);
+    push(didPerformWorkStackCursor, didPerformWorkStackCursor.current);
+    return true;
+  }
+}
+
+function invalidateContextProvider(workInProgress, type, didChange) {
+  {
+    const instance = workInProgress.stateNode;
+
+    if (!instance) {
+      throw Error(formatProdErrorMessage(169));
+    }
+
+    if (didChange) {
+      // Merge parent and own context.
+      // Skip this if we're not updating due to sCU.
+      // This avoids unnecessarily recomputing memoized values.
+      const mergedContext = processChildContext(workInProgress, type, previousContext);
+      instance.__reactInternalMemoizedMergedChildContext = mergedContext; // Replace the old (or empty) context with the new one.
+      // It is important to unwind the context in the reverse order.
+
+      pop(didPerformWorkStackCursor);
+      pop(contextStackCursor); // Now push the new context and mark that it has changed.
+
+      push(contextStackCursor, mergedContext);
+      push(didPerformWorkStackCursor, didChange);
+    } else {
+      pop(didPerformWorkStackCursor);
+      push(didPerformWorkStackCursor, didChange);
+    }
+  }
+}
+
+function findCurrentUnmaskedContext(fiber) {
+  {
+    // Currently this is only used with renderSubtreeIntoContainer; not sure if it
+    // makes sense elsewhere
+    if (!isFiberMounted(fiber) || fiber.tag !== ClassComponent) {
+      throw Error(formatProdErrorMessage(170));
+    }
+
+    let node = fiber;
+
+    do {
+      switch (node.tag) {
+        case HostRoot:
+          return node.stateNode.context;
+
+        case ClassComponent:
+          {
+            const Component = node.type;
+
+            if (isContextProvider(Component)) {
+              return node.stateNode.__reactInternalMemoizedMergedChildContext;
+            }
+
+            break;
+          }
+      } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+      node = node.return;
+    } while (node !== null);
+
+    throw Error(formatProdErrorMessage(171));
+  }
+}
+
+const LegacyRoot = 0;
+const ConcurrentRoot = 1;
+
+// We use the existence of the state object as an indicator that the component
+// is hidden.
+const OffscreenVisible =
+/*                     */
+0b001;
+const OffscreenDetached =
+/*                    */
+0b010;
+const OffscreenPassiveEffectsConnected =
+/*     */
+0b100;
+function isOffscreenManual(offscreenFiber) {
+  return offscreenFiber.memoizedProps !== null && offscreenFiber.memoizedProps.mode === 'manual';
+}
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+
+const objectIs = // $FlowFixMe[method-unbinding]
+typeof Object.is === 'function' ? Object.is : is;
+
+// This is imported by the event replaying implementation in React DOM. It's
+// in a separate file to break a circular dependency between the renderer and
+// the reconciler.
+function isRootDehydrated(root) {
+  const currentState = root.current.memoizedState;
+  return currentState.isDehydrated;
+}
+
+// Ids are base 32 strings whose binary representation corresponds to the
+// 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.
+
+const forkStack = [];
+let forkStackIndex = 0;
+let treeForkProvider = null;
+let treeForkCount = 0;
+const idStack = [];
+let idStackIndex = 0;
+let treeContextProvider = null;
+let treeContextId = 1;
+let treeContextOverflow = '';
+function isForkedChild(workInProgress) {
+  return (workInProgress.flags & Forked) !== NoFlags$1;
+}
+function getForksAtLevel(workInProgress) {
+  return treeForkCount;
+}
+function getTreeId() {
+  const overflow = treeContextOverflow;
+  const idWithLeadingBit = treeContextId;
+  const id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
+  return id.toString(32) + overflow;
+}
+function pushTreeFork(workInProgress, totalChildren) {
+  forkStack[forkStackIndex++] = treeForkCount;
+  forkStack[forkStackIndex++] = treeForkProvider;
+  treeForkProvider = workInProgress;
+  treeForkCount = totalChildren;
+}
+function pushTreeId(workInProgress, totalChildren, index) {
+  idStack[idStackIndex++] = treeContextId;
+  idStack[idStackIndex++] = treeContextOverflow;
+  idStack[idStackIndex++] = treeContextProvider;
+  treeContextProvider = workInProgress;
+  const baseIdWithLeadingBit = treeContextId;
+  const baseOverflow = treeContextOverflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
+  // of the id; we use it to account for leading 0s.
+
+  const baseLength = getBitLength(baseIdWithLeadingBit) - 1;
+  const baseId = baseIdWithLeadingBit & ~(1 << baseLength);
+  const slot = index + 1;
+  const length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
+  // consideration the leading 1 we use to mark the end of the sequence.
+
+  if (length > 30) {
+    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
+    // This branch assumes the length of the base id is greater than 5; it won't
+    // work for smaller ids, because you need 5 bits per character.
+    //
+    // We encode the id in multiple steps: first the base id, then the
+    // remaining digits.
+    //
+    // Each 5 bit sequence corresponds to a single base 32 character. So for
+    // example, if the current id is 23 bits long, we can convert 20 of those
+    // bits into a string of 4 characters, with 3 bits left over.
+    //
+    // First calculate how many bits in the base id represent a complete
+    // sequence of characters.
+    const numberOfOverflowBits = baseLength - baseLength % 5; // Then create a bitmask that selects only those bits.
+
+    const newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
+
+    const newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
+
+    const restOfBaseId = baseId >> numberOfOverflowBits;
+    const restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
+    // we made more room, this time it won't overflow.
+
+    const restOfLength = getBitLength(totalChildren) + restOfBaseLength;
+    const restOfNewBits = slot << restOfBaseLength;
+    const id = restOfNewBits | restOfBaseId;
+    const overflow = newOverflow + baseOverflow;
+    treeContextId = 1 << restOfLength | id;
+    treeContextOverflow = overflow;
+  } else {
+    // Normal path
+    const newBits = slot << baseLength;
+    const id = newBits | baseId;
+    const overflow = baseOverflow;
+    treeContextId = 1 << length | id;
+    treeContextOverflow = overflow;
+  }
+}
+function pushMaterializedTreeId(workInProgress) {
+  // in its children.
+
+  const returnFiber = workInProgress.return;
+
+  if (returnFiber !== null) {
+    const numberOfForks = 1;
+    const slotIndex = 0;
+    pushTreeFork(workInProgress, numberOfForks);
+    pushTreeId(workInProgress, numberOfForks, slotIndex);
+  }
+}
+
+function getBitLength(number) {
+  return 32 - clz32(number);
+}
+
+function getLeadingBit(id) {
+  return 1 << getBitLength(id) - 1;
+}
+
+function popTreeContext(workInProgress) {
+  // Restore the previous values.
+  // This is a bit more complicated than other context-like modules in Fiber
+  // because the same Fiber may appear on the stack multiple times and for
+  // different reasons. We have to keep popping until the work-in-progress is
+  // no longer at the top of the stack.
+  while (workInProgress === treeForkProvider) {
+    treeForkProvider = forkStack[--forkStackIndex];
+    forkStack[forkStackIndex] = null;
+    treeForkCount = forkStack[--forkStackIndex];
+    forkStack[forkStackIndex] = null;
+  }
+
+  while (workInProgress === treeContextProvider) {
+    treeContextProvider = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+    treeContextOverflow = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+    treeContextId = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+  }
+}
+function getSuspendedTreeContext() {
+
+  if (treeContextProvider !== null) {
+    return {
+      id: treeContextId,
+      overflow: treeContextOverflow
+    };
+  } else {
+    return null;
+  }
+}
+function restoreSuspendedTreeContext(workInProgress, suspendedContext) {
+  idStack[idStackIndex++] = treeContextId;
+  idStack[idStackIndex++] = treeContextOverflow;
+  idStack[idStackIndex++] = treeContextProvider;
+  treeContextId = suspendedContext.id;
+  treeContextOverflow = suspendedContext.overflow;
+  treeContextProvider = workInProgress;
+}
+
+// This may have been an insertion or a hydration.
+
+let hydrationParentFiber = null;
+let nextHydratableInstance = null;
+let isHydrating = false; // This flag allows for warning supression when we expect there to be mismatches
+
+let hydrationErrors = null;
+let rootOrSingletonContext = false;
+
+function enterHydrationState(fiber) {
+
+  const parentInstance = fiber.stateNode.containerInfo;
+  nextHydratableInstance = getFirstHydratableChildWithinContainer(parentInstance);
+  hydrationParentFiber = fiber;
+  isHydrating = true;
+  hydrationErrors = null;
+  rootOrSingletonContext = true;
+  return true;
+}
+
+function reenterHydrationStateFromDehydratedSuspenseInstance(fiber, suspenseInstance, treeContext) {
+
+  nextHydratableInstance = getFirstHydratableChildWithinSuspenseInstance(suspenseInstance);
+  hydrationParentFiber = fiber;
+  isHydrating = true;
+  hydrationErrors = null;
+  rootOrSingletonContext = false;
+
+  if (treeContext !== null) {
+    restoreSuspendedTreeContext(fiber, treeContext);
+  }
+
+  return true;
+}
+
+function deleteHydratableInstance(returnFiber, instance) {
+  const childToDelete = createFiberFromHostInstanceForDeletion();
+  childToDelete.stateNode = instance;
+  childToDelete.return = returnFiber;
+  const deletions = returnFiber.deletions;
+
+  if (deletions === null) {
+    returnFiber.deletions = [childToDelete];
+    returnFiber.flags |= ChildDeletion;
+  } else {
+    deletions.push(childToDelete);
+  }
+}
+
+function insertNonHydratedInstance(returnFiber, fiber) {
+  fiber.flags = fiber.flags & ~Hydrating | Placement;
+}
+
+function tryHydrateInstance(fiber, nextInstance) {
+  // fiber is a HostComponent Fiber
+  const instance = canHydrateInstance(nextInstance, fiber.type, fiber.pendingProps, rootOrSingletonContext);
+
+  if (instance !== null) {
+    fiber.stateNode = instance;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = getFirstHydratableChild(instance);
+    rootOrSingletonContext = false;
+    return true;
+  }
+
+  return false;
+}
+
+function tryHydrateText(fiber, nextInstance) {
+  // fiber is a HostText Fiber
+  const text = fiber.pendingProps;
+  const textInstance = canHydrateTextInstance(nextInstance, text, rootOrSingletonContext);
+
+  if (textInstance !== null) {
+    fiber.stateNode = textInstance;
+    hydrationParentFiber = fiber; // Text Instances don't have children so there's nothing to hydrate.
+
+    nextHydratableInstance = null;
+    return true;
+  }
+
+  return false;
+}
+
+function tryHydrateSuspense(fiber, nextInstance) {
+  // fiber is a SuspenseComponent Fiber
+  const suspenseInstance = canHydrateSuspenseInstance(nextInstance, rootOrSingletonContext);
+
+  if (suspenseInstance !== null) {
+    const suspenseState = {
+      dehydrated: suspenseInstance,
+      treeContext: getSuspendedTreeContext(),
+      retryLane: OffscreenLane
+    };
+    fiber.memoizedState = suspenseState; // Store the dehydrated fragment as a child fiber.
+    // This simplifies the code for getHostSibling and deleting nodes,
+    // since it doesn't have to consider all Suspense boundaries and
+    // check if they're dehydrated ones or not.
+
+    const dehydratedFragment = createFiberFromDehydratedFragment(suspenseInstance);
+    dehydratedFragment.return = fiber;
+    fiber.child = dehydratedFragment;
+    hydrationParentFiber = fiber; // While a Suspense Instance does have children, we won't step into
+    // it during the first pass. Instead, we'll reenter it later.
+
+    nextHydratableInstance = null;
+    return true;
+  }
+
+  return false;
+}
+
+function shouldClientRenderOnMismatch(fiber) {
+  return (fiber.mode & ConcurrentMode) !== NoMode && (fiber.flags & DidCapture) === NoFlags$1;
+}
+
+function throwOnHydrationMismatch(fiber) {
+  throw Error(formatProdErrorMessage(418));
+}
+
+function claimHydratableSingleton(fiber) {
+  {
+    if (!isHydrating) {
+      return;
+    }
+
+    const currentRootContainer = getRootHostContainer();
+    const instance = fiber.stateNode = resolveSingletonInstance(fiber.type, fiber.pendingProps, currentRootContainer);
+    hydrationParentFiber = fiber;
+    rootOrSingletonContext = true;
+    nextHydratableInstance = getFirstHydratableChild(instance);
+  }
+}
+
+function tryToClaimNextHydratableInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
+
+  const initialInstance = nextHydratableInstance;
+  const nextInstance = nextHydratableInstance;
+
+  if (!nextInstance) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
+
+
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
+    return;
+  }
+
+  const firstAttemptedInstance = nextInstance;
+
+  if (!tryHydrateInstance(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
+
+
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    const prevHydrationParentFiber = hydrationParentFiber;
+
+    if (!nextHydratableInstance || !tryHydrateInstance(fiber, nextHydratableInstance)) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
+
+
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+  }
+}
+
+function tryToClaimNextHydratableTextInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
+
+  const text = fiber.pendingProps;
+  const isHydratable = isHydratableText(text);
+  const initialInstance = nextHydratableInstance;
+  const nextInstance = nextHydratableInstance;
+
+  if (!nextInstance || !isHydratable) {
+    // We exclude non hydrabable text because we know there are no matching hydratables.
+    // We either throw or insert depending on the render mode.
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
+
+
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
+    return;
+  }
+
+  const firstAttemptedInstance = nextInstance;
+
+  if (!tryHydrateText(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
+
+
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    const prevHydrationParentFiber = hydrationParentFiber;
+
+    if (!nextHydratableInstance || !tryHydrateText(fiber, nextHydratableInstance)) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
+
+
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+  }
+}
+
+function tryToClaimNextHydratableSuspenseInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
+
+  const initialInstance = nextHydratableInstance;
+  const nextInstance = nextHydratableInstance;
+
+  if (!nextInstance) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
+
+
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
+    return;
+  }
+
+  const firstAttemptedInstance = nextInstance;
+
+  if (!tryHydrateSuspense(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
+
+
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    const prevHydrationParentFiber = hydrationParentFiber;
+
+    if (!nextHydratableInstance || !tryHydrateSuspense(fiber, nextHydratableInstance)) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
+
+
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+  }
+}
+
+function tryToClaimNextHydratableFormMarkerInstance(fiber) {
+  if (!isHydrating) {
+    return false;
+  }
+
+  if (nextHydratableInstance) {
+    const markerInstance = canHydrateFormStateMarker(nextHydratableInstance, rootOrSingletonContext);
+
+    if (markerInstance) {
+      // Found the marker instance.
+      nextHydratableInstance = getNextHydratableSibling(markerInstance); // Return true if this marker instance should use the state passed
+      // to hydrateRoot.
+      // TODO: As an optimization, Fizz should only emit these markers if form
+      // state is passed at the root.
+
+      return isFormStateMarkerMatching(markerInstance);
+    }
+  } // Should have found a marker instance. Throw an error to trigger client
+  // rendering. We don't bother to check if we're in a concurrent root because
+  // useFormState is a new API, so backwards compat is not an issue.
+
+
+  throwOnHydrationMismatch();
+  return false;
+}
+
+function prepareToHydrateHostInstance(fiber, hostContext) {
+
+  const instance = fiber.stateNode;
+  hydrateInstance(instance, fiber.type, fiber.memoizedProps, hostContext, fiber);
+}
+
+function prepareToHydrateHostTextInstance(fiber) {
+
+  const textInstance = fiber.stateNode;
+  const textContent = fiber.memoizedProps;
+  const shouldUpdate = hydrateTextInstance(textInstance, textContent, fiber);
+
+  if (shouldUpdate) {
+    // We assume that prepareToHydrateHostTextInstance is called in a context where the
+    // hydration parent is the parent host component of this host text.
+    const returnFiber = hydrationParentFiber;
+
+    if (returnFiber !== null) {
+      switch (returnFiber.tag) {
+        case HostRoot:
+          {
+            const parentContainer = returnFiber.stateNode.containerInfo;
+            const isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
+            didNotMatchHydratedContainerTextInstance(parentContainer, textInstance, textContent, // TODO: Delete this argument when we remove the legacy root API.
+            isConcurrentMode);
+
+            if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {
+              // In concurrent mode we never update the mismatched text,
+              // even if the error was ignored.
+              return false;
+            }
+
+            break;
+          }
+
+        case HostSingleton:
+        case HostComponent:
+          {
+            const parentType = returnFiber.type;
+            const parentProps = returnFiber.memoizedProps;
+            const parentInstance = returnFiber.stateNode;
+            const isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
+            didNotMatchHydratedTextInstance(parentType, parentProps, parentInstance, textInstance, textContent, // TODO: Delete this argument when we remove the legacy root API.
+            isConcurrentMode);
+
+            if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {
+              // In concurrent mode we never update the mismatched text,
+              // even if the error was ignored.
+              return false;
+            }
+
+            break;
+          }
+      }
+    }
+  }
+
+  return shouldUpdate;
+}
+
+function prepareToHydrateHostSuspenseInstance(fiber) {
+
+  const suspenseState = fiber.memoizedState;
+  const suspenseInstance = suspenseState !== null ? suspenseState.dehydrated : null;
+
+  if (!suspenseInstance) {
+    throw Error(formatProdErrorMessage(317));
+  }
+
+  hydrateSuspenseInstance(suspenseInstance, fiber);
+}
+
+function skipPastDehydratedSuspenseInstance(fiber) {
+
+  const suspenseState = fiber.memoizedState;
+  const suspenseInstance = suspenseState !== null ? suspenseState.dehydrated : null;
+
+  if (!suspenseInstance) {
+    throw Error(formatProdErrorMessage(317));
+  }
+
+  return getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance);
+}
+
+function popToNextHostParent(fiber) {
+  hydrationParentFiber = fiber.return;
+
+  while (hydrationParentFiber) {
+    switch (hydrationParentFiber.tag) {
+      case HostRoot:
+      case HostSingleton:
+        rootOrSingletonContext = true;
+        return;
+
+      case HostComponent:
+      case SuspenseComponent:
+        rootOrSingletonContext = false;
+        return;
+
+      default:
+        hydrationParentFiber = hydrationParentFiber.return;
+    }
+  }
+}
+
+function popHydrationState(fiber) {
+
+  if (fiber !== hydrationParentFiber) {
+    // We're deeper than the current hydration context, inside an inserted
+    // tree.
+    return false;
+  }
+
+  if (!isHydrating) {
+    // If we're not currently hydrating but we're in a hydration context, then
+    // we were an insertion and now need to pop up reenter hydration of our
+    // siblings.
+    popToNextHostParent(fiber);
+    isHydrating = true;
+    return false;
+  }
+
+  let shouldClear = false;
+
+  {
+    // With float we never clear the Root, or Singleton instances. We also do not clear Instances
+    // that have singleton text content
+    if (fiber.tag !== HostRoot && fiber.tag !== HostSingleton && !(fiber.tag === HostComponent && (!shouldDeleteUnhydratedTailInstances(fiber.type) || shouldSetTextContent(fiber.type, fiber.memoizedProps)))) {
+      shouldClear = true;
+    }
+  }
+
+  if (shouldClear) {
+    let nextInstance = nextHydratableInstance;
+
+    if (nextInstance) {
+      if (shouldClientRenderOnMismatch(fiber)) {
+        warnIfUnhydratedTailNodes();
+        throwOnHydrationMismatch();
+      } else {
+        while (nextInstance) {
+          deleteHydratableInstance(fiber, nextInstance);
+          nextInstance = getNextHydratableSibling(nextInstance);
+        }
+      }
+    }
+  }
+
+  popToNextHostParent(fiber);
+
+  if (fiber.tag === SuspenseComponent) {
+    nextHydratableInstance = skipPastDehydratedSuspenseInstance(fiber);
+  } else {
+    nextHydratableInstance = hydrationParentFiber ? getNextHydratableSibling(fiber.stateNode) : null;
+  }
+
+  return true;
+}
+
+function hasUnhydratedTailNodes() {
+  return isHydrating && nextHydratableInstance !== null;
+}
+
+function warnIfUnhydratedTailNodes(fiber) {
+  let nextInstance = nextHydratableInstance;
+
+  while (nextInstance) {
+    nextInstance = getNextHydratableSibling(nextInstance);
+  }
+}
+
+function resetHydrationState() {
+
+  hydrationParentFiber = null;
+  nextHydratableInstance = null;
+  isHydrating = false;
+}
+
+function upgradeHydrationErrorsToRecoverable() {
+  if (hydrationErrors !== null) {
+    // Successfully completed a forced client render. The errors that occurred
+    // during the hydration attempt are now recovered. We will log them in
+    // commit phase, once the entire tree has finished.
+    queueRecoverableErrors(hydrationErrors);
+    hydrationErrors = null;
+  }
+}
+
+function getIsHydrating() {
+  return isHydrating;
+}
+
+function queueHydrationError(error) {
+  if (hydrationErrors === null) {
+    hydrationErrors = [error];
+  } else {
+    hydrationErrors.push(error);
+  }
+}
+
+// we wait until the current render is over (either finished or interrupted)
+// before adding it to the fiber/hook queue. Push to this array so we can
+// access the queue, fiber, update, et al later.
+
+const concurrentQueues = [];
+let concurrentQueuesIndex = 0;
+let concurrentlyUpdatedLanes = NoLanes;
+function finishQueueingConcurrentUpdates() {
+  const endIndex = concurrentQueuesIndex;
+  concurrentQueuesIndex = 0;
+  concurrentlyUpdatedLanes = NoLanes;
+  let i = 0;
+
+  while (i < endIndex) {
+    const fiber = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    const queue = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    const update = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    const lane = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+
+    if (queue !== null && update !== null) {
+      const pending = queue.pending;
+
+      if (pending === null) {
+        // This is the first update. Create a circular list.
+        update.next = update;
+      } else {
+        update.next = pending.next;
+        pending.next = update;
+      }
+
+      queue.pending = update;
+    }
+
+    if (lane !== NoLane) {
+      markUpdateLaneFromFiberToRoot(fiber, update, lane);
+    }
+  }
+}
+function getConcurrentlyUpdatedLanes() {
+  return concurrentlyUpdatedLanes;
+}
+
+function enqueueUpdate$1(fiber, queue, update, lane) {
+  // Don't update the `childLanes` on the return path yet. If we already in
+  // the middle of rendering, wait until after it has completed.
+  concurrentQueues[concurrentQueuesIndex++] = fiber;
+  concurrentQueues[concurrentQueuesIndex++] = queue;
+  concurrentQueues[concurrentQueuesIndex++] = update;
+  concurrentQueues[concurrentQueuesIndex++] = lane;
+  concurrentlyUpdatedLanes = mergeLanes(concurrentlyUpdatedLanes, lane); // The fiber's `lane` field is used in some places to check if any work is
+  // scheduled, to perform an eager bailout, so we need to update it immediately.
+  // TODO: We should probably move this to the "shared" queue instead.
+
+  fiber.lanes = mergeLanes(fiber.lanes, lane);
+  const alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, lane);
+  }
+}
+
+function enqueueConcurrentHookUpdate(fiber, queue, update, lane) {
+  const concurrentQueue = queue;
+  const concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane);
+  return getRootForUpdatedFiber(fiber);
+}
+function enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update) {
+  // This function is used to queue an update that doesn't need a rerender. The
+  // only reason we queue it is in case there's a subsequent higher priority
+  // update that causes it to be rebased.
+  const lane = NoLane;
+  const concurrentQueue = queue;
+  const concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane); // Usually we can rely on the upcoming render phase to process the concurrent
+  // queue. However, since this is a bail out, we're not scheduling any work
+  // here. So the update we just queued will leak until something else happens
+  // to schedule work (if ever).
+  //
+  // Check if we're currently in the middle of rendering a tree, and if not,
+  // process the queue immediately to prevent a leak.
+
+  const isConcurrentlyRendering = getWorkInProgressRoot() !== null;
+
+  if (!isConcurrentlyRendering) {
+    finishQueueingConcurrentUpdates();
+  }
+}
+function enqueueConcurrentClassUpdate(fiber, queue, update, lane) {
+  const concurrentQueue = queue;
+  const concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane);
+  return getRootForUpdatedFiber(fiber);
+}
+function enqueueConcurrentRenderForLane(fiber, lane) {
+  enqueueUpdate$1(fiber, null, null, lane);
+  return getRootForUpdatedFiber(fiber);
+} // Calling this function outside this module should only be done for backwards
+// compatibility and should always be accompanied by a warning.
+
+function unsafe_markUpdateLaneFromFiberToRoot(sourceFiber, lane) {
+  // NOTE: For Hyrum's Law reasons, if an infinite update loop is detected, it
+  // should throw before `markUpdateLaneFromFiberToRoot` is called. But this is
+  // undefined behavior and we can change it if we need to; it just so happens
+  // that, at the time of this writing, there's an internal product test that
+  // happens to rely on this.
+  const root = getRootForUpdatedFiber(sourceFiber);
+  markUpdateLaneFromFiberToRoot(sourceFiber, null, lane);
+  return root;
+}
+
+function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
+  // Update the source fiber's lanes
+  sourceFiber.lanes = mergeLanes(sourceFiber.lanes, lane);
+  let alternate = sourceFiber.alternate;
+
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, lane);
+  } // Walk the parent path to the root and update the child lanes.
+
+
+  let isHidden = false;
+  let parent = sourceFiber.return;
+  let node = sourceFiber;
+
+  while (parent !== null) {
+    parent.childLanes = mergeLanes(parent.childLanes, lane);
+    alternate = parent.alternate;
+
+    if (alternate !== null) {
+      alternate.childLanes = mergeLanes(alternate.childLanes, lane);
+    }
+
+    if (parent.tag === OffscreenComponent) {
+      // Check if this offscreen boundary is currently hidden.
+      //
+      // The instance may be null if the Offscreen parent was unmounted. Usually
+      // the parent wouldn't be reachable in that case because we disconnect
+      // fibers from the tree when they are deleted. However, there's a weird
+      // edge case where setState is called on a fiber that was interrupted
+      // before it ever mounted. Because it never mounts, it also never gets
+      // deleted. Because it never gets deleted, its return pointer never gets
+      // disconnected. Which means it may be attached to a deleted Offscreen
+      // parent node. (This discovery suggests it may be better for memory usage
+      // if we don't attach the `return` pointer until the commit phase, though
+      // in order to do that we'd need some other way to track the return
+      // pointer during the initial render, like on the stack.)
+      //
+      // This case is always accompanied by a warning, but we still need to
+      // account for it. (There may be other cases that we haven't discovered,
+      // too.)
+      const offscreenInstance = parent.stateNode;
+
+      if (offscreenInstance !== null && !(offscreenInstance._visibility & OffscreenVisible)) {
+        isHidden = true;
+      }
+    }
+
+    node = parent;
+    parent = parent.return;
+  }
+
+  if (isHidden && update !== null && node.tag === HostRoot) {
+    const root = node.stateNode;
+    markHiddenUpdate(root, update, lane);
+  }
+}
+
+function getRootForUpdatedFiber(sourceFiber) {
+  // TODO: We will detect and infinite update loop and throw even if this fiber
+  // has already unmounted. This isn't really necessary but it happens to be the
+  // current behavior we've used for several release cycles. Consider not
+  // performing this check if the updated fiber already unmounted, since it's
+  // not possible for that to cause an infinite update loop.
+  throwIfInfiniteUpdateLoopDetected(); // When a setState happens, we must ensure the root is scheduled. Because
+  let node = sourceFiber;
+  let parent = node.return;
+
+  while (parent !== null) {
+    node = parent;
+    parent = node.return;
+  }
+
+  return node.tag === HostRoot ? node.stateNode : null;
+}
+
+const UpdateState = 0;
+const ReplaceState = 1;
+const ForceUpdate = 2;
+const CaptureUpdate = 3; // Global state that is reset at the beginning of calling `processUpdateQueue`.
+// It should only be read right after calling `processUpdateQueue`, via
+// `checkHasForceUpdateAfterProcessing`.
+
+let hasForceUpdate = false;
+
+function initializeUpdateQueue(fiber) {
+  const queue = {
+    baseState: fiber.memoizedState,
+    firstBaseUpdate: null,
+    lastBaseUpdate: null,
+    shared: {
+      pending: null,
+      lanes: NoLanes,
+      hiddenCallbacks: null
+    },
+    callbacks: null
+  };
+  fiber.updateQueue = queue;
+}
+function cloneUpdateQueue(current, workInProgress) {
+  // Clone the update queue from current. Unless it's already a clone.
+  const queue = workInProgress.updateQueue;
+  const currentQueue = current.updateQueue;
+
+  if (queue === currentQueue) {
+    const clone = {
+      baseState: currentQueue.baseState,
+      firstBaseUpdate: currentQueue.firstBaseUpdate,
+      lastBaseUpdate: currentQueue.lastBaseUpdate,
+      shared: currentQueue.shared,
+      callbacks: null
+    };
+    workInProgress.updateQueue = clone;
+  }
+}
+function createUpdate(lane) {
+  const update = {
+    lane,
+    tag: UpdateState,
+    payload: null,
+    callback: null,
+    next: null
+  };
+  return update;
+}
+function enqueueUpdate(fiber, update, lane) {
+  const updateQueue = fiber.updateQueue;
+
+  if (updateQueue === null) {
+    // Only occurs if the fiber has been unmounted.
+    return null;
+  }
+
+  const sharedQueue = updateQueue.shared;
+
+  if (isUnsafeClassRenderPhaseUpdate()) {
+    // This is an unsafe render phase update. Add directly to the update
+    // queue so we can process it immediately during the current render.
+    const pending = sharedQueue.pending;
+
+    if (pending === null) {
+      // This is the first update. Create a circular list.
+      update.next = update;
+    } else {
+      update.next = pending.next;
+      pending.next = update;
+    }
+
+    sharedQueue.pending = update; // Update the childLanes even though we're most likely already rendering
+    // this fiber. This is for backwards compatibility in the case where you
+    // update a different component during render phase than the one that is
+    // currently renderings (a pattern that is accompanied by a warning).
+
+    return unsafe_markUpdateLaneFromFiberToRoot(fiber, lane);
+  } else {
+    return enqueueConcurrentClassUpdate(fiber, sharedQueue, update, lane);
+  }
+}
+function entangleTransitions(root, fiber, lane) {
+  const updateQueue = fiber.updateQueue;
+
+  if (updateQueue === null) {
+    // Only occurs if the fiber has been unmounted.
+    return;
+  }
+
+  const sharedQueue = updateQueue.shared;
+
+  if (isTransitionLane(lane)) {
+    let queueLanes = sharedQueue.lanes; // If any entangled lanes are no longer pending on the root, then they must
+    // have finished. We can remove them from the shared queue, which represents
+    // a superset of the actually pending lanes. In some cases we may entangle
+    // more than we need to, but that's OK. In fact it's worse if we *don't*
+    // entangle when we should.
+
+    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.
+
+    const newQueueLanes = mergeLanes(queueLanes, lane);
+    sharedQueue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if
+    // the lane finished since the last time we entangled it. So we need to
+    // entangle it again, just to be sure.
+
+    markRootEntangled(root, newQueueLanes);
+  }
+}
+function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
+  // Captured updates are updates that are thrown by a child during the render
+  // phase. They should be discarded if the render is aborted. Therefore,
+  // we should only put them on the work-in-progress queue, not the current one.
+  let queue = workInProgress.updateQueue; // Check if the work-in-progress queue is a clone.
+
+  const current = workInProgress.alternate;
+
+  if (current !== null) {
+    const currentQueue = current.updateQueue;
+
+    if (queue === currentQueue) {
+      // The work-in-progress queue is the same as current. This happens when
+      // we bail out on a parent fiber that then captures an error thrown by
+      // a child. Since we want to append the update only to the work-in
+      // -progress queue, we need to clone the updates. We usually clone during
+      // processUpdateQueue, but that didn't happen in this case because we
+      // skipped over the parent when we bailed out.
+      let newFirst = null;
+      let newLast = null;
+      const firstBaseUpdate = queue.firstBaseUpdate;
+
+      if (firstBaseUpdate !== null) {
+        // Loop through the updates and clone them.
+        let update = firstBaseUpdate;
+
+        do {
+          const clone = {
+            lane: update.lane,
+            tag: update.tag,
+            payload: update.payload,
+            // When this update is rebased, we should not fire its
+            // callback again.
+            callback: null,
+            next: null
+          };
+
+          if (newLast === null) {
+            newFirst = newLast = clone;
+          } else {
+            newLast.next = clone;
+            newLast = clone;
+          } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+          update = update.next;
+        } while (update !== null); // Append the captured update the end of the cloned list.
+
+
+        if (newLast === null) {
+          newFirst = newLast = capturedUpdate;
+        } else {
+          newLast.next = capturedUpdate;
+          newLast = capturedUpdate;
+        }
+      } else {
+        // There are no base updates.
+        newFirst = newLast = capturedUpdate;
+      }
+
+      queue = {
+        baseState: currentQueue.baseState,
+        firstBaseUpdate: newFirst,
+        lastBaseUpdate: newLast,
+        shared: currentQueue.shared,
+        callbacks: currentQueue.callbacks
+      };
+      workInProgress.updateQueue = queue;
+      return;
+    }
+  } // Append the update to the end of the list.
+
+
+  const lastBaseUpdate = queue.lastBaseUpdate;
+
+  if (lastBaseUpdate === null) {
+    queue.firstBaseUpdate = capturedUpdate;
+  } else {
+    lastBaseUpdate.next = capturedUpdate;
+  }
+
+  queue.lastBaseUpdate = capturedUpdate;
+}
+
+function getStateFromUpdate(workInProgress, queue, update, prevState, nextProps, instance) {
+  switch (update.tag) {
+    case ReplaceState:
+      {
+        const payload = update.payload;
+
+        if (typeof payload === 'function') {
+
+          const nextState = payload.call(instance, prevState, nextProps);
+
+          return nextState;
+        } // State object
+
+
+        return payload;
+      }
+
+    case CaptureUpdate:
+      {
+        workInProgress.flags = workInProgress.flags & ~ShouldCapture | DidCapture;
+      }
+    // Intentional fallthrough
+
+    case UpdateState:
+      {
+        const payload = update.payload;
+        let partialState;
+
+        if (typeof payload === 'function') {
+
+          partialState = payload.call(instance, prevState, nextProps);
+        } else {
+          // Partial state object
+          partialState = payload;
+        }
+
+        if (partialState === null || partialState === undefined) {
+          // Null and undefined are treated as no-ops.
+          return prevState;
+        } // Merge the partial state and the previous state.
+
+
+        return assign({}, prevState, partialState);
+      }
+
+    case ForceUpdate:
+      {
+        hasForceUpdate = true;
+        return prevState;
+      }
+  }
+
+  return prevState;
+}
+
+function processUpdateQueue(workInProgress, props, instance, renderLanes) {
+  // This is always non-null on a ClassComponent or HostRoot
+  const queue = workInProgress.updateQueue;
+  hasForceUpdate = false;
+
+  let firstBaseUpdate = queue.firstBaseUpdate;
+  let lastBaseUpdate = queue.lastBaseUpdate; // Check if there are pending updates. If so, transfer them to the base queue.
+
+  let pendingQueue = queue.shared.pending;
+
+  if (pendingQueue !== null) {
+    queue.shared.pending = null; // The pending queue is circular. Disconnect the pointer between first
+    // and last so that it's non-circular.
+
+    const lastPendingUpdate = pendingQueue;
+    const firstPendingUpdate = lastPendingUpdate.next;
+    lastPendingUpdate.next = null; // Append pending updates to base queue
+
+    if (lastBaseUpdate === null) {
+      firstBaseUpdate = firstPendingUpdate;
+    } else {
+      lastBaseUpdate.next = firstPendingUpdate;
+    }
+
+    lastBaseUpdate = lastPendingUpdate; // If there's a current queue, and it's different from the base queue, then
+    // we need to transfer the updates to that queue, too. Because the base
+    // queue is a singly-linked list with no cycles, we can append to both
+    // lists and take advantage of structural sharing.
+    // TODO: Pass `current` as argument
+
+    const current = workInProgress.alternate;
+
+    if (current !== null) {
+      // This is always non-null on a ClassComponent or HostRoot
+      const currentQueue = current.updateQueue;
+      const currentLastBaseUpdate = currentQueue.lastBaseUpdate;
+
+      if (currentLastBaseUpdate !== lastBaseUpdate) {
+        if (currentLastBaseUpdate === null) {
+          currentQueue.firstBaseUpdate = firstPendingUpdate;
+        } else {
+          currentLastBaseUpdate.next = firstPendingUpdate;
+        }
+
+        currentQueue.lastBaseUpdate = lastPendingUpdate;
+      }
+    }
+  } // These values may change as we process the queue.
+
+
+  if (firstBaseUpdate !== null) {
+    // Iterate through the list of updates to compute the result.
+    let newState = queue.baseState; // TODO: Don't need to accumulate this. Instead, we can remove renderLanes
+    // from the original lanes.
+
+    let newLanes = NoLanes;
+    let newBaseState = null;
+    let newFirstBaseUpdate = null;
+    let newLastBaseUpdate = null;
+    let update = firstBaseUpdate;
+
+    do {
+      // An extra OffscreenLane bit is added to updates that were made to
+      // a hidden tree, so that we can distinguish them from updates that were
+      // already there when the tree was hidden.
+      const updateLane = removeLanes(update.lane, OffscreenLane);
+      const isHiddenUpdate = updateLane !== update.lane; // Check if this update was made while the tree was hidden. If so, then
+      // it's not a "base" update and we should disregard the extra base lanes
+      // that were added to renderLanes when we entered the Offscreen tree.
+
+      const shouldSkipUpdate = isHiddenUpdate ? !isSubsetOfLanes(getWorkInProgressRootRenderLanes(), updateLane) : !isSubsetOfLanes(renderLanes, updateLane);
+
+      if (shouldSkipUpdate) {
+        // Priority is insufficient. Skip this update. If this is the first
+        // skipped update, the previous update/state is the new base
+        // update/state.
+        const clone = {
+          lane: updateLane,
+          tag: update.tag,
+          payload: update.payload,
+          callback: update.callback,
+          next: null
+        };
+
+        if (newLastBaseUpdate === null) {
+          newFirstBaseUpdate = newLastBaseUpdate = clone;
+          newBaseState = newState;
+        } else {
+          newLastBaseUpdate = newLastBaseUpdate.next = clone;
+        } // Update the remaining priority in the queue.
+
+
+        newLanes = mergeLanes(newLanes, updateLane);
+      } else {
+        // This update does have sufficient priority.
+        if (newLastBaseUpdate !== null) {
+          const clone = {
+            // This update is going to be committed so we never want uncommit
+            // it. Using NoLane works because 0 is a subset of all bitmasks, so
+            // this will never be skipped by the check above.
+            lane: NoLane,
+            tag: update.tag,
+            payload: update.payload,
+            // When this update is rebased, we should not fire its
+            // callback again.
+            callback: null,
+            next: null
+          };
+          newLastBaseUpdate = newLastBaseUpdate.next = clone;
+        } // Process this update.
+
+
+        newState = getStateFromUpdate(workInProgress, queue, update, newState, props, instance);
+        const callback = update.callback;
+
+        if (callback !== null) {
+          workInProgress.flags |= Callback;
+
+          if (isHiddenUpdate) {
+            workInProgress.flags |= Visibility;
+          }
+
+          const callbacks = queue.callbacks;
+
+          if (callbacks === null) {
+            queue.callbacks = [callback];
+          } else {
+            callbacks.push(callback);
+          }
+        }
+      } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+      update = update.next;
+
+      if (update === null) {
+        pendingQueue = queue.shared.pending;
+
+        if (pendingQueue === null) {
+          break;
+        } else {
+          // An update was scheduled from inside a reducer. Add the new
+          // pending updates to the end of the list and keep processing.
+          const lastPendingUpdate = pendingQueue; // Intentionally unsound. Pending updates form a circular list, but we
+          // unravel them when transferring them to the base queue.
+
+          const firstPendingUpdate = lastPendingUpdate.next;
+          lastPendingUpdate.next = null;
+          update = firstPendingUpdate;
+          queue.lastBaseUpdate = lastPendingUpdate;
+          queue.shared.pending = null;
+        }
+      }
+    } while (true);
+
+    if (newLastBaseUpdate === null) {
+      newBaseState = newState;
+    }
+
+    queue.baseState = newBaseState;
+    queue.firstBaseUpdate = newFirstBaseUpdate;
+    queue.lastBaseUpdate = newLastBaseUpdate;
+
+    if (firstBaseUpdate === null) {
+      // `queue.lanes` is used for entangling transitions. We can set it back to
+      // zero once the queue is empty.
+      queue.shared.lanes = NoLanes;
+    } // Set the remaining expiration time to be whatever is remaining in the queue.
+    // This should be fine because the only two other things that contribute to
+    // expiration time are props and context. We're already in the middle of the
+    // begin phase by the time we start processing the queue, so we've already
+    // dealt with the props. Context in components that specify
+    // shouldComponentUpdate is tricky; but we'll have to account for
+    // that regardless.
+
+
+    markSkippedUpdateLanes(newLanes);
+    workInProgress.lanes = newLanes;
+    workInProgress.memoizedState = newState;
+  }
+}
+
+function callCallback(callback, context) {
+  if (typeof callback !== 'function') {
+    throw Error(formatProdErrorMessage(191, callback));
+  }
+
+  callback.call(context);
+}
+
+function resetHasForceUpdateBeforeProcessing() {
+  hasForceUpdate = false;
+}
+function checkHasForceUpdateAfterProcessing() {
+  return hasForceUpdate;
+}
+function deferHiddenCallbacks(updateQueue) {
+  // When an update finishes on a hidden component, its callback should not
+  // be fired until/unless the component is made visible again. Stash the
+  // callback on the shared queue object so it can be fired later.
+  const newHiddenCallbacks = updateQueue.callbacks;
+
+  if (newHiddenCallbacks !== null) {
+    const existingHiddenCallbacks = updateQueue.shared.hiddenCallbacks;
+
+    if (existingHiddenCallbacks === null) {
+      updateQueue.shared.hiddenCallbacks = newHiddenCallbacks;
+    } else {
+      updateQueue.shared.hiddenCallbacks = existingHiddenCallbacks.concat(newHiddenCallbacks);
+    }
+  }
+}
+function commitHiddenCallbacks(updateQueue, context) {
+  // This component is switching from hidden -> visible. Commit any callbacks
+  // that were previously deferred.
+  const hiddenCallbacks = updateQueue.shared.hiddenCallbacks;
+
+  if (hiddenCallbacks !== null) {
+    updateQueue.shared.hiddenCallbacks = null;
+
+    for (let i = 0; i < hiddenCallbacks.length; i++) {
+      const callback = hiddenCallbacks[i];
+      callCallback(callback, context);
+    }
+  }
+}
+function commitCallbacks(updateQueue, context) {
+  const callbacks = updateQueue.callbacks;
+
+  if (callbacks !== null) {
+    updateQueue.callbacks = null;
+
+    for (let i = 0; i < callbacks.length; i++) {
+      const callback = callbacks[i];
+      callCallback(callback, context);
+    }
+  }
+}
+
+/**
+ * Performs equality by iterating through keys on an object and returning false
+ * when any key has values which are not strictly equal between the arguments.
+ * Returns true when the values of all keys are strictly equal.
+ */
+
+function shallowEqual(objA, objB) {
+  if (objectIs(objA, objB)) {
+    return true;
+  }
+
+  if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
+    return false;
+  }
+
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+
+  if (keysA.length !== keysB.length) {
+    return false;
+  } // Test for A's keys different from B.
+
+
+  for (let i = 0; i < keysA.length; i++) {
+    const currentKey = keysA[i];
+
+    if (!hasOwnProperty.call(objB, currentKey) || // $FlowFixMe[incompatible-use] lost refinement of `objB`
+    !objectIs(objA[currentKey], objB[currentKey])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+// detect this is caught by userspace, we'll log a warning in development.
+
+const SuspenseException = Error(formatProdErrorMessage(460));
+const SuspenseyCommitException = Error(formatProdErrorMessage(474)); // This is a noop thenable that we use to trigger a fallback in throwException.
+// TODO: It would be better to refactor throwException into multiple functions
+// so we can trigger a fallback directly without having to check the type. But
+// for now this will do.
+
+const noopSuspenseyCommitThenable = {
+  then() {
+  }
+
+};
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+function isThenableResolved(thenable) {
+  const status = thenable.status;
+  return status === 'fulfilled' || status === 'rejected';
+}
+
+function noop$2() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop$2, noop$2);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        checkIfUseWrappedInAsyncCatch(rejectedError);
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          // Attach a dummy listener, to ensure that any lazy initialization can
+          // happen. Flight lazily parses JSON when the value is actually awaited.
+          thenable.then(noop$2, noop$2);
+        } else {
+          // This is an uncached thenable that we haven't seen before.
+          // Detect infinite ping loops caused by uncached promises.
+          const root = getWorkInProgressRoot();
+
+          if (root !== null && root.shellSuspendCounter > 100) {
+            // This root has suspended repeatedly in the shell without making any
+            // progress (i.e. committing something). This is highly suggestive of
+            // an infinite ping loop, often caused by an accidental Async Client
+            // Component.
+            //
+            // During a transition, we can suspend the work loop until the promise
+            // to resolve, but this is a sync render, so that's not an option. We
+            // also can't show a fallback, because none was provided. So our last
+            // resort is to throw an error.
+            //
+            // TODO: Remove this error in a future release. Other ways of handling
+            // this case include forcing a concurrent render, or putting the whole
+            // root into offscreen mode.
+            throw Error(formatProdErrorMessage(482));
+          }
+
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously.
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                const rejectedError = rejectedThenable.reason;
+                checkIfUseWrappedInAsyncCatch(rejectedError);
+                throw rejectedError;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+
+        throw SuspenseException;
+      }
+  }
+}
+function suspendCommit() {
+  // This extra indirection only exists so it can handle passing
+  // noopSuspenseyCommitThenable through to throwException.
+  // TODO: Factor the thenable check out of throwException
+  suspendedThenable = noopSuspenseyCommitThenable;
+  throw SuspenseyCommitException;
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw Error(formatProdErrorMessage(459));
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+
+  return thenable;
+}
+function checkIfUseWrappedInAsyncCatch(rejectedReason) {
+  // This check runs in prod, too, because it prevents a more confusing
+  // downstream error, where SuspenseException is caught by a promise and
+  // thrown asynchronously.
+  // TODO: Another way to prevent SuspenseException from leaking into an async
+  // execution context is to check the dispatcher every time `use` is called,
+  // or some equivalent. That might be preferable for other reasons, too, since
+  // it matches how we prevent similar mistakes for other hooks.
+  if (rejectedReason === SuspenseException) {
+    throw Error(formatProdErrorMessage(483));
+  }
+}
+
+let thenableState$1 = null;
+let thenableIndexCounter$1 = 0;
+
+function unwrapThenable(thenable) {
+  const index = thenableIndexCounter$1;
+  thenableIndexCounter$1 += 1;
+
+  if (thenableState$1 === null) {
+    thenableState$1 = createThenableState();
+  }
+
+  return trackUsedThenable(thenableState$1, thenable, index);
+}
+
+function coerceRef(returnFiber, current, element) {
+  const mixedRef = element.ref;
+
+  if (mixedRef !== null && typeof mixedRef !== 'function' && typeof mixedRef !== 'object') {
+
+    if (element._owner) {
+      const owner = element._owner;
+      let inst;
+
+      if (owner) {
+        const ownerFiber = owner;
+
+        if (ownerFiber.tag !== ClassComponent) {
+          throw Error(formatProdErrorMessage(309));
+        }
+
+        inst = ownerFiber.stateNode;
+      }
+
+      if (!inst) {
+        throw Error(formatProdErrorMessage(147, mixedRef));
+      } // Assigning this to a const so Flow knows it won't change in the closure
+
+
+      const resolvedInst = inst;
+
+      const stringRef = '' + mixedRef; // Check if previous string ref matches new string ref
+
+      if (current !== null && current.ref !== null && typeof current.ref === 'function' && current.ref._stringRef === stringRef) {
+        return current.ref;
+      }
+
+      const ref = function (value) {
+        const refs = resolvedInst.refs;
+
+        if (value === null) {
+          delete refs[stringRef];
+        } else {
+          refs[stringRef] = value;
+        }
+      };
+
+      ref._stringRef = stringRef;
+      return ref;
+    } else {
+      if (typeof mixedRef !== 'string') {
+        throw Error(formatProdErrorMessage(284));
+      }
+
+      if (!element._owner) {
+        throw Error(formatProdErrorMessage(290, mixedRef));
+      }
+    }
+  }
+
+  return mixedRef;
+}
+
+function throwOnInvalidObjectType(returnFiber, newChild) {
+  // $FlowFixMe[method-unbinding]
+  const childString = Object.prototype.toString.call(newChild);
+  throw Error(formatProdErrorMessage(31, childString === '[object Object]' ? 'object with keys {' + Object.keys(newChild).join(', ') + '}' : childString));
+}
+
+function resolveLazy(lazyType) {
+  const payload = lazyType._payload;
+  const init = lazyType._init;
+  return init(payload);
+} // This wrapper function exists because I expect to clone the code in each path
+// to be able to optimize each path individually by branching early. This needs
+// a compiler or we can do it manually. Helpers that don't need this branching
+// live outside of this function.
+
+
+function createChildReconciler(shouldTrackSideEffects) {
+  function deleteChild(returnFiber, childToDelete) {
+    if (!shouldTrackSideEffects) {
+      // Noop.
+      return;
+    }
+
+    const deletions = returnFiber.deletions;
+
+    if (deletions === null) {
+      returnFiber.deletions = [childToDelete];
+      returnFiber.flags |= ChildDeletion;
+    } else {
+      deletions.push(childToDelete);
+    }
+  }
+
+  function deleteRemainingChildren(returnFiber, currentFirstChild) {
+    if (!shouldTrackSideEffects) {
+      // Noop.
+      return null;
+    } // TODO: For the shouldClone case, this could be micro-optimized a bit by
+    // assuming that after the first child we've already added everything.
+
+
+    let childToDelete = currentFirstChild;
+
+    while (childToDelete !== null) {
+      deleteChild(returnFiber, childToDelete);
+      childToDelete = childToDelete.sibling;
+    }
+
+    return null;
+  }
+
+  function mapRemainingChildren(returnFiber, currentFirstChild) {
+    // Add the remaining children to a temporary map so that we can find them by
+    // keys quickly. Implicit (null) keys get added to this set with their index
+    // instead.
+    const existingChildren = new Map();
+    let existingChild = currentFirstChild;
+
+    while (existingChild !== null) {
+      if (existingChild.key !== null) {
+        existingChildren.set(existingChild.key, existingChild);
+      } else {
+        existingChildren.set(existingChild.index, existingChild);
+      }
+
+      existingChild = existingChild.sibling;
+    }
+
+    return existingChildren;
+  }
+
+  function useFiber(fiber, pendingProps) {
+    // We currently set sibling to null and index to 0 here because it is easy
+    // to forget to do before returning it. E.g. for the single child case.
+    const clone = createWorkInProgress(fiber, pendingProps);
+    clone.index = 0;
+    clone.sibling = null;
+    return clone;
+  }
+
+  function placeChild(newFiber, lastPlacedIndex, newIndex) {
+    newFiber.index = newIndex;
+
+    if (!shouldTrackSideEffects) {
+      // During hydration, the useId algorithm needs to know which fibers are
+      // part of a list of children (arrays, iterators).
+      newFiber.flags |= Forked;
+      return lastPlacedIndex;
+    }
+
+    const current = newFiber.alternate;
+
+    if (current !== null) {
+      const oldIndex = current.index;
+
+      if (oldIndex < lastPlacedIndex) {
+        // This is a move.
+        newFiber.flags |= Placement | PlacementDEV;
+        return lastPlacedIndex;
+      } else {
+        // This item can stay in place.
+        return oldIndex;
+      }
+    } else {
+      // This is an insertion.
+      newFiber.flags |= Placement | PlacementDEV;
+      return lastPlacedIndex;
+    }
+  }
+
+  function placeSingleChild(newFiber) {
+    // This is simpler for the single child case. We only need to do a
+    // placement for inserting new children.
+    if (shouldTrackSideEffects && newFiber.alternate === null) {
+      newFiber.flags |= Placement | PlacementDEV;
+    }
+
+    return newFiber;
+  }
+
+  function updateTextNode(returnFiber, current, textContent, lanes) {
+    if (current === null || current.tag !== HostText) {
+      // Insert
+      const created = createFiberFromText(textContent, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      const existing = useFiber(current, textContent);
+      existing.return = returnFiber;
+      return existing;
+    }
+  }
+
+  function updateElement(returnFiber, current, element, lanes) {
+    const elementType = element.type;
+
+    if (elementType === REACT_FRAGMENT_TYPE) {
+      return updateFragment(returnFiber, current, element.props.children, lanes, element.key);
+    }
+
+    if (current !== null) {
+      if (current.elementType === elementType || ( // Keep this check inline so it only runs on the false path:
+      false) || // Lazy types should reconcile their resolved type.
+      // We need to do this after the Hot Reloading check above,
+      // because hot reloading has different semantics than prod because
+      // it doesn't resuspend. So we can't let the call below suspend.
+      typeof elementType === 'object' && elementType !== null && elementType.$$typeof === REACT_LAZY_TYPE && resolveLazy(elementType) === current.type) {
+        // Move based on index
+        const existing = useFiber(current, element.props);
+        existing.ref = coerceRef(returnFiber, current, element);
+        existing.return = returnFiber;
+
+        return existing;
+      }
+    } // Insert
+
+
+    const created = createFiberFromElement(element, returnFiber.mode, lanes);
+    created.ref = coerceRef(returnFiber, current, element);
+    created.return = returnFiber;
+    return created;
+  }
+
+  function updatePortal(returnFiber, current, portal, lanes) {
+    if (current === null || current.tag !== HostPortal || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation) {
+      // Insert
+      const created = createFiberFromPortal(portal, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      const existing = useFiber(current, portal.children || []);
+      existing.return = returnFiber;
+      return existing;
+    }
+  }
+
+  function updateFragment(returnFiber, current, fragment, lanes, key) {
+    if (current === null || current.tag !== Fragment) {
+      // Insert
+      const created = createFiberFromFragment(fragment, returnFiber.mode, lanes, key);
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      const existing = useFiber(current, fragment);
+      existing.return = returnFiber;
+      return existing;
+    }
+  }
+
+  function createChild(returnFiber, newChild, lanes) {
+    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {
+      // Text nodes don't have keys. If the previous node is implicitly keyed
+      // we can continue to replace it without aborting even if it is not a text
+      // node.
+      const created = createFiberFromText('' + newChild, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    }
+
+    if (typeof newChild === 'object' && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const created = createFiberFromElement(newChild, returnFiber.mode, lanes);
+            created.ref = coerceRef(returnFiber, null, newChild);
+            created.return = returnFiber;
+            return created;
+          }
+
+        case REACT_PORTAL_TYPE:
+          {
+            const created = createFiberFromPortal(newChild, returnFiber.mode, lanes);
+            created.return = returnFiber;
+            return created;
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = newChild._payload;
+            const init = newChild._init;
+            return createChild(returnFiber, init(payload), lanes);
+          }
+      }
+
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        const created = createFiberFromFragment(newChild, returnFiber.mode, lanes, null);
+        created.return = returnFiber;
+        return created;
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
+
+
+      if (typeof newChild.then === 'function') {
+        const thenable = newChild;
+        return createChild(returnFiber, unwrapThenable(thenable), lanes);
+      }
+
+      if (newChild.$$typeof === REACT_CONTEXT_TYPE || newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+        const context = newChild;
+        return createChild(returnFiber, readContextDuringReconcilation(returnFiber, context, lanes), lanes);
+      }
+
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+
+    return null;
+  }
+
+  function updateSlot(returnFiber, oldFiber, newChild, lanes) {
+    // Update the fiber if the keys match, otherwise return null.
+    const key = oldFiber !== null ? oldFiber.key : null;
+
+    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {
+      // Text nodes don't have keys. If the previous node is implicitly keyed
+      // we can continue to replace it without aborting even if it is not a text
+      // node.
+      if (key !== null) {
+        return null;
+      }
+
+      return updateTextNode(returnFiber, oldFiber, '' + newChild, lanes);
+    }
+
+    if (typeof newChild === 'object' && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            if (newChild.key === key) {
+              return updateElement(returnFiber, oldFiber, newChild, lanes);
+            } else {
+              return null;
+            }
+          }
+
+        case REACT_PORTAL_TYPE:
+          {
+            if (newChild.key === key) {
+              return updatePortal(returnFiber, oldFiber, newChild, lanes);
+            } else {
+              return null;
+            }
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = newChild._payload;
+            const init = newChild._init;
+            return updateSlot(returnFiber, oldFiber, init(payload), lanes);
+          }
+      }
+
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        if (key !== null) {
+          return null;
+        }
+
+        return updateFragment(returnFiber, oldFiber, newChild, lanes, null);
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
+
+
+      if (typeof newChild.then === 'function') {
+        const thenable = newChild;
+        return updateSlot(returnFiber, oldFiber, unwrapThenable(thenable), lanes);
+      }
+
+      if (newChild.$$typeof === REACT_CONTEXT_TYPE || newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+        const context = newChild;
+        return updateSlot(returnFiber, oldFiber, readContextDuringReconcilation(returnFiber, context, lanes), lanes);
+      }
+
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+
+    return null;
+  }
+
+  function updateFromMap(existingChildren, returnFiber, newIdx, newChild, lanes) {
+    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {
+      // Text nodes don't have keys, so we neither have to check the old nor
+      // new node for the key. If both are text nodes, they match.
+      const matchedFiber = existingChildren.get(newIdx) || null;
+      return updateTextNode(returnFiber, matchedFiber, '' + newChild, lanes);
+    }
+
+    if (typeof newChild === 'object' && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const matchedFiber = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;
+            return updateElement(returnFiber, matchedFiber, newChild, lanes);
+          }
+
+        case REACT_PORTAL_TYPE:
+          {
+            const matchedFiber = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;
+            return updatePortal(returnFiber, matchedFiber, newChild, lanes);
+          }
+
+        case REACT_LAZY_TYPE:
+          const payload = newChild._payload;
+          const init = newChild._init;
+          return updateFromMap(existingChildren, returnFiber, newIdx, init(payload), lanes);
+      }
+
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        const matchedFiber = existingChildren.get(newIdx) || null;
+        return updateFragment(returnFiber, matchedFiber, newChild, lanes, null);
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
+
+
+      if (typeof newChild.then === 'function') {
+        const thenable = newChild;
+        return updateFromMap(existingChildren, returnFiber, newIdx, unwrapThenable(thenable), lanes);
+      }
+
+      if (newChild.$$typeof === REACT_CONTEXT_TYPE || newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+        const context = newChild;
+        return updateFromMap(existingChildren, returnFiber, newIdx, readContextDuringReconcilation(returnFiber, context, lanes), lanes);
+      }
+
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+
+    return null;
+  }
+
+  function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, lanes) {
+
+    let resultingFirstChild = null;
+    let previousNewFiber = null;
+    let oldFiber = currentFirstChild;
+    let lastPlacedIndex = 0;
+    let newIdx = 0;
+    let nextOldFiber = null;
+
+    for (; oldFiber !== null && newIdx < newChildren.length; newIdx++) {
+      if (oldFiber.index > newIdx) {
+        nextOldFiber = oldFiber;
+        oldFiber = null;
+      } else {
+        nextOldFiber = oldFiber.sibling;
+      }
+
+      const newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], lanes);
+
+      if (newFiber === null) {
+        // TODO: This breaks on empty slots like null children. That's
+        // unfortunate because it triggers the slow path all the time. We need
+        // a better way to communicate whether this was a miss or null,
+        // boolean, undefined, etc.
+        if (oldFiber === null) {
+          oldFiber = nextOldFiber;
+        }
+
+        break;
+      }
+
+      if (shouldTrackSideEffects) {
+        if (oldFiber && newFiber.alternate === null) {
+          // We matched the slot, but we didn't reuse the existing fiber, so we
+          // need to delete the existing child.
+          deleteChild(returnFiber, oldFiber);
+        }
+      }
+
+      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+      if (previousNewFiber === null) {
+        // TODO: Move out of the loop. This only happens for the first run.
+        resultingFirstChild = newFiber;
+      } else {
+        // TODO: Defer siblings if we're not at the right index for this slot.
+        // I.e. if we had null values before, then we want to defer this
+        // for each null value. However, we also don't want to call updateSlot
+        // with the previous one.
+        previousNewFiber.sibling = newFiber;
+      }
+
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
+    }
+
+    if (newIdx === newChildren.length) {
+      // We've reached the end of the new children. We can delete the rest.
+      deleteRemainingChildren(returnFiber, oldFiber);
+
+      if (getIsHydrating()) {
+        const numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
+
+      return resultingFirstChild;
+    }
+
+    if (oldFiber === null) {
+      // If we don't have any more existing children we can choose a fast path
+      // since the rest will all be insertions.
+      for (; newIdx < newChildren.length; newIdx++) {
+        const newFiber = createChild(returnFiber, newChildren[newIdx], lanes);
+
+        if (newFiber === null) {
+          continue;
+        }
+
+        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          // TODO: Move out of the loop. This only happens for the first run.
+          resultingFirstChild = newFiber;
+        } else {
+          previousNewFiber.sibling = newFiber;
+        }
+
+        previousNewFiber = newFiber;
+      }
+
+      if (getIsHydrating()) {
+        const numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
+
+      return resultingFirstChild;
+    } // Add all children to a key map for quick lookups.
+
+
+    const existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
+
+    for (; newIdx < newChildren.length; newIdx++) {
+      const newFiber = updateFromMap(existingChildren, returnFiber, newIdx, newChildren[newIdx], lanes);
+
+      if (newFiber !== null) {
+        if (shouldTrackSideEffects) {
+          if (newFiber.alternate !== null) {
+            // The new fiber is a work in progress, but if there exists a
+            // current, that means that we reused the fiber. We need to delete
+            // it from the child list so that we don't add it to the deletion
+            // list.
+            existingChildren.delete(newFiber.key === null ? newIdx : newFiber.key);
+          }
+        }
+
+        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          resultingFirstChild = newFiber;
+        } else {
+          previousNewFiber.sibling = newFiber;
+        }
+
+        previousNewFiber = newFiber;
+      }
+    }
+
+    if (shouldTrackSideEffects) {
+      // Any existing children that weren't consumed above were deleted. We need
+      // to add them to the deletion list.
+      existingChildren.forEach(child => deleteChild(returnFiber, child));
+    }
+
+    if (getIsHydrating()) {
+      const numberOfForks = newIdx;
+      pushTreeFork(returnFiber, numberOfForks);
+    }
+
+    return resultingFirstChild;
+  }
+
+  function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildrenIterable, lanes) {
+    // This is the same implementation as reconcileChildrenArray(),
+    // but using the iterator instead.
+    const iteratorFn = getIteratorFn(newChildrenIterable);
+
+    if (typeof iteratorFn !== 'function') {
+      throw Error(formatProdErrorMessage(150));
+    }
+
+    const newChildren = iteratorFn.call(newChildrenIterable);
+
+    if (newChildren == null) {
+      throw Error(formatProdErrorMessage(151));
+    }
+
+    let resultingFirstChild = null;
+    let previousNewFiber = null;
+    let oldFiber = currentFirstChild;
+    let lastPlacedIndex = 0;
+    let newIdx = 0;
+    let nextOldFiber = null;
+    let step = newChildren.next();
+
+    for (; oldFiber !== null && !step.done; newIdx++, step = newChildren.next()) {
+      if (oldFiber.index > newIdx) {
+        nextOldFiber = oldFiber;
+        oldFiber = null;
+      } else {
+        nextOldFiber = oldFiber.sibling;
+      }
+
+      const newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
+
+      if (newFiber === null) {
+        // TODO: This breaks on empty slots like null children. That's
+        // unfortunate because it triggers the slow path all the time. We need
+        // a better way to communicate whether this was a miss or null,
+        // boolean, undefined, etc.
+        if (oldFiber === null) {
+          oldFiber = nextOldFiber;
+        }
+
+        break;
+      }
+
+      if (shouldTrackSideEffects) {
+        if (oldFiber && newFiber.alternate === null) {
+          // We matched the slot, but we didn't reuse the existing fiber, so we
+          // need to delete the existing child.
+          deleteChild(returnFiber, oldFiber);
+        }
+      }
+
+      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+      if (previousNewFiber === null) {
+        // TODO: Move out of the loop. This only happens for the first run.
+        resultingFirstChild = newFiber;
+      } else {
+        // TODO: Defer siblings if we're not at the right index for this slot.
+        // I.e. if we had null values before, then we want to defer this
+        // for each null value. However, we also don't want to call updateSlot
+        // with the previous one.
+        previousNewFiber.sibling = newFiber;
+      }
+
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
+    }
+
+    if (step.done) {
+      // We've reached the end of the new children. We can delete the rest.
+      deleteRemainingChildren(returnFiber, oldFiber);
+
+      if (getIsHydrating()) {
+        const numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
+
+      return resultingFirstChild;
+    }
+
+    if (oldFiber === null) {
+      // If we don't have any more existing children we can choose a fast path
+      // since the rest will all be insertions.
+      for (; !step.done; newIdx++, step = newChildren.next()) {
+        const newFiber = createChild(returnFiber, step.value, lanes);
+
+        if (newFiber === null) {
+          continue;
+        }
+
+        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          // TODO: Move out of the loop. This only happens for the first run.
+          resultingFirstChild = newFiber;
+        } else {
+          previousNewFiber.sibling = newFiber;
+        }
+
+        previousNewFiber = newFiber;
+      }
+
+      if (getIsHydrating()) {
+        const numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
+
+      return resultingFirstChild;
+    } // Add all children to a key map for quick lookups.
+
+
+    const existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
+
+    for (; !step.done; newIdx++, step = newChildren.next()) {
+      const newFiber = updateFromMap(existingChildren, returnFiber, newIdx, step.value, lanes);
+
+      if (newFiber !== null) {
+        if (shouldTrackSideEffects) {
+          if (newFiber.alternate !== null) {
+            // The new fiber is a work in progress, but if there exists a
+            // current, that means that we reused the fiber. We need to delete
+            // it from the child list so that we don't add it to the deletion
+            // list.
+            existingChildren.delete(newFiber.key === null ? newIdx : newFiber.key);
+          }
+        }
+
+        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          resultingFirstChild = newFiber;
+        } else {
+          previousNewFiber.sibling = newFiber;
+        }
+
+        previousNewFiber = newFiber;
+      }
+    }
+
+    if (shouldTrackSideEffects) {
+      // Any existing children that weren't consumed above were deleted. We need
+      // to add them to the deletion list.
+      existingChildren.forEach(child => deleteChild(returnFiber, child));
+    }
+
+    if (getIsHydrating()) {
+      const numberOfForks = newIdx;
+      pushTreeFork(returnFiber, numberOfForks);
+    }
+
+    return resultingFirstChild;
+  }
+
+  function reconcileSingleTextNode(returnFiber, currentFirstChild, textContent, lanes) {
+    // There's no need to check for keys on text nodes since we don't have a
+    // way to define them.
+    if (currentFirstChild !== null && currentFirstChild.tag === HostText) {
+      // We already have an existing node so let's just update it and delete
+      // the rest.
+      deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+      const existing = useFiber(currentFirstChild, textContent);
+      existing.return = returnFiber;
+      return existing;
+    } // The existing first child is not a text node so we need to create one
+    // and delete the existing ones.
+
+
+    deleteRemainingChildren(returnFiber, currentFirstChild);
+    const created = createFiberFromText(textContent, returnFiber.mode, lanes);
+    created.return = returnFiber;
+    return created;
+  }
+
+  function reconcileSingleElement(returnFiber, currentFirstChild, element, lanes) {
+    const key = element.key;
+    let child = currentFirstChild;
+
+    while (child !== null) {
+      // TODO: If key === null and child.key === null, then this only applies to
+      // the first item in the list.
+      if (child.key === key) {
+        const elementType = element.type;
+
+        if (elementType === REACT_FRAGMENT_TYPE) {
+          if (child.tag === Fragment) {
+            deleteRemainingChildren(returnFiber, child.sibling);
+            const existing = useFiber(child, element.props.children);
+            existing.return = returnFiber;
+
+            return existing;
+          }
+        } else {
+          if (child.elementType === elementType || ( // Keep this check inline so it only runs on the false path:
+          false) || // Lazy types should reconcile their resolved type.
+          // We need to do this after the Hot Reloading check above,
+          // because hot reloading has different semantics than prod because
+          // it doesn't resuspend. So we can't let the call below suspend.
+          typeof elementType === 'object' && elementType !== null && elementType.$$typeof === REACT_LAZY_TYPE && resolveLazy(elementType) === child.type) {
+            deleteRemainingChildren(returnFiber, child.sibling);
+            const existing = useFiber(child, element.props);
+            existing.ref = coerceRef(returnFiber, child, element);
+            existing.return = returnFiber;
+
+            return existing;
+          }
+        } // Didn't match.
+
+
+        deleteRemainingChildren(returnFiber, child);
+        break;
+      } else {
+        deleteChild(returnFiber, child);
+      }
+
+      child = child.sibling;
+    }
+
+    if (element.type === REACT_FRAGMENT_TYPE) {
+      const created = createFiberFromFragment(element.props.children, returnFiber.mode, lanes, element.key);
+      created.return = returnFiber;
+      return created;
+    } else {
+      const created = createFiberFromElement(element, returnFiber.mode, lanes);
+      created.ref = coerceRef(returnFiber, currentFirstChild, element);
+      created.return = returnFiber;
+      return created;
+    }
+  }
+
+  function reconcileSinglePortal(returnFiber, currentFirstChild, portal, lanes) {
+    const key = portal.key;
+    let child = currentFirstChild;
+
+    while (child !== null) {
+      // TODO: If key === null and child.key === null, then this only applies to
+      // the first item in the list.
+      if (child.key === key) {
+        if (child.tag === HostPortal && child.stateNode.containerInfo === portal.containerInfo && child.stateNode.implementation === portal.implementation) {
+          deleteRemainingChildren(returnFiber, child.sibling);
+          const existing = useFiber(child, portal.children || []);
+          existing.return = returnFiber;
+          return existing;
+        } else {
+          deleteRemainingChildren(returnFiber, child);
+          break;
+        }
+      } else {
+        deleteChild(returnFiber, child);
+      }
+
+      child = child.sibling;
+    }
+
+    const created = createFiberFromPortal(portal, returnFiber.mode, lanes);
+    created.return = returnFiber;
+    return created;
+  } // This API will tag the children with the side-effect of the reconciliation
+  // itself. They will be added to the side-effect list as we pass through the
+  // children and the parent.
+
+
+  function reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes) {
+    // This function is not recursive.
+    // If the top level item is an array, we treat it as a set of children,
+    // not as a fragment. Nested arrays on the other hand will be treated as
+    // fragment nodes. Recursion happens at the normal flow.
+    // Handle top level unkeyed fragments as if they were arrays.
+    // This leads to an ambiguity between <>{[...]}</> and <>...</>.
+    // We treat the ambiguous cases above the same.
+    // TODO: Let's use recursion like we do for Usable nodes?
+    const isUnkeyedTopLevelFragment = typeof newChild === 'object' && newChild !== null && newChild.type === REACT_FRAGMENT_TYPE && newChild.key === null;
+
+    if (isUnkeyedTopLevelFragment) {
+      newChild = newChild.props.children;
+    } // Handle object types
+
+
+    if (typeof newChild === 'object' && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          return placeSingleChild(reconcileSingleElement(returnFiber, currentFirstChild, newChild, lanes));
+
+        case REACT_PORTAL_TYPE:
+          return placeSingleChild(reconcileSinglePortal(returnFiber, currentFirstChild, newChild, lanes));
+
+        case REACT_LAZY_TYPE:
+          const payload = newChild._payload;
+          const init = newChild._init; // TODO: This function is supposed to be non-recursive.
+
+          return reconcileChildFibers(returnFiber, currentFirstChild, init(payload), lanes);
+      }
+
+      if (isArray(newChild)) {
+        return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, lanes);
+      }
+
+      if (getIteratorFn(newChild)) {
+        return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, lanes);
+      } // Usables are a valid React node type. When React encounters a Usable in
+      // a child position, it unwraps it using the same algorithm as `use`. For
+      // example, for promises, React will throw an exception to unwind the
+      // stack, then replay the component once the promise resolves.
+      //
+      // A difference from `use` is that React will keep unwrapping the value
+      // until it reaches a non-Usable type.
+      //
+      // e.g. Usable<Usable<Usable<T>>> should resolve to T
+      //
+      // The structure is a bit unfortunate. Ideally, we shouldn't need to
+      // replay the entire begin phase of the parent fiber in order to reconcile
+      // the children again. This would require a somewhat significant refactor,
+      // because reconcilation happens deep within the begin phase, and
+      // depending on the type of work, not always at the end. We should
+      // consider as an future improvement.
+
+
+      if (typeof newChild.then === 'function') {
+        const thenable = newChild;
+        return reconcileChildFibersImpl(returnFiber, currentFirstChild, unwrapThenable(thenable), lanes);
+      }
+
+      if (newChild.$$typeof === REACT_CONTEXT_TYPE || newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+        const context = newChild;
+        return reconcileChildFibersImpl(returnFiber, currentFirstChild, readContextDuringReconcilation(returnFiber, context, lanes), lanes);
+      }
+
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+
+    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {
+      return placeSingleChild(reconcileSingleTextNode(returnFiber, currentFirstChild, '' + newChild, lanes));
+    }
+
+
+    return deleteRemainingChildren(returnFiber, currentFirstChild);
+  }
+
+  function reconcileChildFibers(returnFiber, currentFirstChild, newChild, lanes) {
+    // This indirection only exists so we can reset `thenableState` at the end.
+    // It should get inlined by Closure.
+    thenableIndexCounter$1 = 0;
+    const firstChildFiber = reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes);
+    thenableState$1 = null; // Don't bother to reset `thenableIndexCounter` to 0 because it always gets
+    // set at the beginning.
+
+    return firstChildFiber;
+  }
+
+  return reconcileChildFibers;
+}
+
+const reconcileChildFibers = createChildReconciler(true);
+const mountChildFibers = createChildReconciler(false);
+function resetChildReconcilerOnUnwind() {
+  // On unwind, clear any pending thenables that were used.
+  thenableState$1 = null;
+  thenableIndexCounter$1 = 0;
+}
+function cloneChildFibers(current, workInProgress) {
+  if (current !== null && workInProgress.child !== current.child) {
+    throw Error(formatProdErrorMessage(153));
+  }
+
+  if (workInProgress.child === null) {
+    return;
+  }
+
+  let currentChild = workInProgress.child;
+  let newChild = createWorkInProgress(currentChild, currentChild.pendingProps);
+  workInProgress.child = newChild;
+  newChild.return = workInProgress;
+
+  while (currentChild.sibling !== null) {
+    currentChild = currentChild.sibling;
+    newChild = newChild.sibling = createWorkInProgress(currentChild, currentChild.pendingProps);
+    newChild.return = workInProgress;
+  }
+
+  newChild.sibling = null;
+} // Reset a workInProgress child set to prepare it for a second pass.
+
+function resetChildFibers(workInProgress, lanes) {
+  let child = workInProgress.child;
+
+  while (child !== null) {
+    resetWorkInProgress(child, lanes);
+    child = child.sibling;
+  }
+}
+
+// TODO: This isn't being used yet, but it's intended to replace the
+// InvisibleParentContext that is currently managed by SuspenseContext.
+
+const currentTreeHiddenStackCursor = createCursor(null);
+const prevEntangledRenderLanesCursor = createCursor(NoLanes);
+function pushHiddenContext(fiber, context) {
+  const prevEntangledRenderLanes = getEntangledRenderLanes();
+  push(prevEntangledRenderLanesCursor, prevEntangledRenderLanes);
+  push(currentTreeHiddenStackCursor, context); // When rendering a subtree that's currently hidden, we must include all
+  // lanes that would have rendered if the hidden subtree hadn't been deferred.
+  // That is, in order to reveal content from hidden -> visible, we must commit
+  // all the updates that we skipped when we originally hid the tree.
+
+  setEntangledRenderLanes(mergeLanes(prevEntangledRenderLanes, context.baseLanes));
+}
+function reuseHiddenContextOnStack(fiber) {
+  // This subtree is not currently hidden, so we don't need to add any lanes
+  // to the render lanes. But we still need to push something to avoid a
+  // context mismatch. Reuse the existing context on the stack.
+  push(prevEntangledRenderLanesCursor, getEntangledRenderLanes());
+  push(currentTreeHiddenStackCursor, currentTreeHiddenStackCursor.current);
+}
+function popHiddenContext(fiber) {
+  // Restore the previous render lanes from the stack
+  setEntangledRenderLanes(prevEntangledRenderLanesCursor.current);
+  pop(currentTreeHiddenStackCursor);
+  pop(prevEntangledRenderLanesCursor);
+}
+function isCurrentTreeHidden() {
+  return currentTreeHiddenStackCursor.current !== null;
+}
+
+// suspends, i.e. it's the nearest `catch` block on the stack.
+
+const suspenseHandlerStackCursor = createCursor(null); // Represents the outermost boundary that is not visible in the current tree.
+// Everything above this is the "shell". When this is null, it means we're
+// rendering in the shell of the app. If it's non-null, it means we're rendering
+// deeper than the shell, inside a new tree that wasn't already visible.
+//
+// The main way we use this concept is to determine whether showing a fallback
+// would result in a desirable or undesirable loading state. Activing a fallback
+// in the shell is considered an undersirable loading state, because it would
+// mean hiding visible (albeit stale) content in the current tree — we prefer to
+// show the stale content, rather than switch to a fallback. But showing a
+// fallback in a new tree is fine, because there's no stale content to
+// prefer instead.
+
+let shellBoundary = null;
+function getShellBoundary() {
+  return shellBoundary;
+}
+function pushPrimaryTreeSuspenseHandler(handler) {
+  // TODO: Pass as argument
+  const current = handler.alternate;
+  // propagated a single level. For example, when ForceSuspenseFallback is set,
+  // it should only force the nearest Suspense boundary into fallback mode.
+
+  pushSuspenseListContext(handler, setDefaultShallowSuspenseListContext(suspenseStackCursor.current)); // Experimental feature: Some Suspense boundaries are marked as having an
+  // to push a nested Suspense handler, because it will get replaced by the
+  // outer fallback, anyway. Consider this as a future optimization.
+
+
+  push(suspenseHandlerStackCursor, handler);
+
+  if (shellBoundary === null) {
+    if (current === null || isCurrentTreeHidden()) {
+      // This boundary is not visible in the current UI.
+      shellBoundary = handler;
+    } else {
+      const prevState = current.memoizedState;
+
+      if (prevState !== null) {
+        // This boundary is showing a fallback in the current UI.
+        shellBoundary = handler;
+      }
+    }
+  }
+}
+function pushFallbackTreeSuspenseHandler(fiber) {
+  // We're about to render the fallback. If something in the fallback suspends,
+  // it's akin to throwing inside of a `catch` block. This boundary should not
+  // capture. Reuse the existing handler on the stack.
+  reuseSuspenseHandlerOnStack(fiber);
+}
+function pushOffscreenSuspenseHandler(fiber) {
+  if (fiber.tag === OffscreenComponent) {
+    // A SuspenseList context is only pushed here to avoid a push/pop mismatch.
+    // Reuse the current value on the stack.
+    // TODO: We can avoid needing to push here by by forking popSuspenseHandler
+    // into separate functions for Suspense and Offscreen.
+    pushSuspenseListContext(fiber, suspenseStackCursor.current);
+    push(suspenseHandlerStackCursor, fiber);
+
+    if (shellBoundary !== null) ; else {
+      const current = fiber.alternate;
+
+      if (current !== null) {
+        const prevState = current.memoizedState;
+
+        if (prevState !== null) {
+          // This is the first boundary in the stack that's already showing
+          // a fallback. So everything outside is considered the shell.
+          shellBoundary = fiber;
+        }
+      }
+    }
+  } else {
+    // This is a LegacyHidden component.
+    reuseSuspenseHandlerOnStack(fiber);
+  }
+}
+function reuseSuspenseHandlerOnStack(fiber) {
+  pushSuspenseListContext(fiber, suspenseStackCursor.current);
+  push(suspenseHandlerStackCursor, getSuspenseHandler());
+}
+function getSuspenseHandler() {
+  return suspenseHandlerStackCursor.current;
+}
+function popSuspenseHandler(fiber) {
+  pop(suspenseHandlerStackCursor);
+
+  if (shellBoundary === fiber) {
+    // Popping back into the shell.
+    shellBoundary = null;
+  }
+
+  popSuspenseListContext();
+} // SuspenseList context
+// TODO: Move to a separate module? We may change the SuspenseList
+// implementation to hide/show in the commit phase, anyway.
+
+const DefaultSuspenseContext = 0b00;
+const SubtreeSuspenseContextMask = 0b01; // ForceSuspenseFallback can be used by SuspenseList to force newly added
+// items into their fallback state during one of the render passes.
+
+const ForceSuspenseFallback = 0b10;
+const suspenseStackCursor = createCursor(DefaultSuspenseContext);
+function hasSuspenseListContext(parentContext, flag) {
+  return (parentContext & flag) !== 0;
+}
+function setDefaultShallowSuspenseListContext(parentContext) {
+  return parentContext & SubtreeSuspenseContextMask;
+}
+function setShallowSuspenseListContext(parentContext, shallowContext) {
+  return parentContext & SubtreeSuspenseContextMask | shallowContext;
+}
+function pushSuspenseListContext(fiber, newContext) {
+  push(suspenseStackCursor, newContext);
+}
+function popSuspenseListContext(fiber) {
+  pop(suspenseStackCursor);
+}
+
+// A non-null SuspenseState means that it is blocked for one reason or another.
+// - A non-null dehydrated field means it's blocked pending hydration.
+//   - A non-null dehydrated field can use isSuspenseInstancePending or
+//     isSuspenseInstanceFallback to query the reason for being dehydrated.
+// - A null dehydrated field means it's blocked by something suspending and
+//   we're currently showing a fallback instead.
+
+function findFirstSuspended(row) {
+  let node = row;
+
+  while (node !== null) {
+    if (node.tag === SuspenseComponent) {
+      const state = node.memoizedState;
+
+      if (state !== null) {
+        const dehydrated = state.dehydrated;
+
+        if (dehydrated === null || isSuspenseInstancePending(dehydrated) || isSuspenseInstanceFallback(dehydrated)) {
+          return node;
+        }
+      }
+    } else if (node.tag === SuspenseListComponent && // revealOrder undefined can't be trusted because it don't
+    // keep track of whether it suspended or not.
+    node.memoizedProps.revealOrder !== undefined) {
+      const didSuspend = (node.flags & DidCapture) !== NoFlags$1;
+
+      if (didSuspend) {
+        return node;
+      }
+    } else if (node.child !== null) {
+      node.child.return = node;
+      node = node.child;
+      continue;
+    }
+
+    if (node === row) {
+      return null;
+    }
+
+    while (node.sibling === null) {
+      if (node.return === null || node.return === row) {
+        return null;
+      }
+
+      node = node.return;
+    }
+
+    node.sibling.return = node.return;
+    node = node.sibling;
+  }
+
+  return null;
+}
+
+const NoFlags =
+/*   */
+0b0000; // Represents whether effect should fire.
+
+const HasEffect =
+/* */
+0b0001; // Represents the phase in which the effect (not the clean-up) fires.
+
+const Insertion =
+/* */
+0b0010;
+const Layout =
+/*    */
+0b0100;
+const Passive =
+/*   */
+0b1000;
+
+// there's only a single root, but we do support multi root apps, hence this
+// extra complexity. But this module is optimized for the single root case.
+
+let firstScheduledRoot = null;
+let lastScheduledRoot = null; // Used to prevent redundant mircotasks from being scheduled.
+
+let didScheduleMicrotask = false; // `act` "microtasks" are scheduled on the `act` queue instead of an actual
+
+let mightHavePendingSyncWork = false;
+let isFlushingWork = false;
+let currentEventTransitionLane = NoLane;
+function ensureRootIsScheduled(root) {
+  // This function is called whenever a root receives an update. It does two
+  // things 1) it ensures the root is in the root schedule, and 2) it ensures
+  // there's a pending microtask to process the root schedule.
+  //
+  // Most of the actual scheduling logic does not happen until
+  // `scheduleTaskForRootDuringMicrotask` runs.
+  // Add the root to the schedule
+  if (root === lastScheduledRoot || root.next !== null) ; else {
+    if (lastScheduledRoot === null) {
+      firstScheduledRoot = lastScheduledRoot = root;
+    } else {
+      lastScheduledRoot.next = root;
+      lastScheduledRoot = root;
+    }
+  } // Any time a root received an update, we set this to true until the next time
+  // we process the schedule. If it's false, then we can quickly exit flushSync
+  // without consulting the schedule.
+
+
+  mightHavePendingSyncWork = true; // At the end of the current event, go through each of the roots and ensure
+  // there's a task scheduled for each one at the correct priority.
+
+  {
+    if (!didScheduleMicrotask) {
+      didScheduleMicrotask = true;
+      scheduleImmediateTask(processRootScheduleInMicrotask);
+    }
+  }
+}
+function flushSyncWorkOnAllRoots() {
+  // This is allowed to be called synchronously, but the caller should check
+  // the execution context first.
+  flushSyncWorkAcrossRoots_impl(false);
+}
+function flushSyncWorkOnLegacyRootsOnly() {
+  // This is allowed to be called synchronously, but the caller should check
+  // the execution context first.
+  flushSyncWorkAcrossRoots_impl(true);
+}
+
+function flushSyncWorkAcrossRoots_impl(onlyLegacy) {
+  if (isFlushingWork) {
+    // Prevent reentrancy.
+    // TODO: Is this overly defensive? The callers must check the execution
+    // context first regardless.
+    return;
+  }
+
+  if (!mightHavePendingSyncWork) {
+    // Fast path. There's no sync work to do.
+    return;
+  } // There may or may not be synchronous work scheduled. Let's check.
+
+
+  let didPerformSomeWork;
+  let errors = null;
+  isFlushingWork = true;
+
+  do {
+    didPerformSomeWork = false;
+    let root = firstScheduledRoot;
+
+    while (root !== null) {
+      if (onlyLegacy && root.tag !== LegacyRoot) ; else {
+        const workInProgressRoot = getWorkInProgressRoot();
+        const workInProgressRootRenderLanes = getWorkInProgressRootRenderLanes();
+        const nextLanes = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes);
+
+        if (includesSyncLane(nextLanes)) {
+          // This root has pending sync work. Flush it now.
+          try {
+            didPerformSomeWork = true;
+            performSyncWorkOnRoot(root, nextLanes);
+          } catch (error) {
+            // Collect errors so we can rethrow them at the end
+            if (errors === null) {
+              errors = [error];
+            } else {
+              errors.push(error);
+            }
+          }
+        }
+      }
+
+      root = root.next;
+    }
+  } while (didPerformSomeWork);
+
+  isFlushingWork = false; // If any errors were thrown, rethrow them right before exiting.
+  // TODO: Consider returning these to the caller, to allow them to decide
+  // how/when to rethrow.
+
+  if (errors !== null) {
+    if (errors.length > 1) {
+      if (typeof AggregateError === 'function') {
+        // eslint-disable-next-line no-undef
+        throw new AggregateError(errors);
+      } else {
+        for (let i = 1; i < errors.length; i++) {
+          scheduleImmediateTask(throwError.bind(null, errors[i]));
+        }
+
+        const firstError = errors[0];
+        throw firstError;
+      }
+    } else {
+      const error = errors[0];
+      throw error;
+    }
+  }
+}
+
+function throwError(error) {
+  throw error;
+}
+
+function processRootScheduleInMicrotask() {
+  // This function is always called inside a microtask. It should never be
+  // called synchronously.
+  didScheduleMicrotask = false;
+
+
+  mightHavePendingSyncWork = false;
+  const currentTime = now$1();
+  let prev = null;
+  let root = firstScheduledRoot;
+
+  while (root !== null) {
+    const next = root.next;
+
+    if (currentEventTransitionLane !== NoLane && shouldAttemptEagerTransition()) {
+      // A transition was scheduled during an event, but we're going to try to
+      // render it synchronously anyway. We do this during a popstate event to
+      // preserve the scroll position of the previous page.
+      upgradePendingLaneToSync(root, currentEventTransitionLane);
+    }
+
+    const nextLanes = scheduleTaskForRootDuringMicrotask(root, currentTime);
+
+    if (nextLanes === NoLane) {
+      // This root has no more pending work. Remove it from the schedule. To
+      // guard against subtle reentrancy bugs, this microtask is the only place
+      // we do this — you can add roots to the schedule whenever, but you can
+      // only remove them here.
+      // Null this out so we know it's been removed from the schedule.
+      root.next = null;
+
+      if (prev === null) {
+        // This is the new head of the list
+        firstScheduledRoot = next;
+      } else {
+        prev.next = next;
+      }
+
+      if (next === null) {
+        // This is the new tail of the list
+        lastScheduledRoot = prev;
+      }
+    } else {
+      // This root still has work. Keep it in the list.
+      prev = root;
+
+      if (includesSyncLane(nextLanes)) {
+        mightHavePendingSyncWork = true;
+      }
+    }
+
+    root = next;
+  }
+
+  currentEventTransitionLane = NoLane; // At the end of the microtask, flush any pending synchronous work. This has
+  // to come at the end, because it does actual rendering work that might throw.
+
+  flushSyncWorkOnAllRoots();
+}
+
+function scheduleTaskForRootDuringMicrotask(root, currentTime) {
+  // This function is always called inside a microtask, or at the very end of a
+  // rendering task right before we yield to the main thread. It should never be
+  // called synchronously.
+  //
+  // TODO: Unless enableDeferRootSchedulingToMicrotask is off. We need to land
+  // that ASAP to unblock additional features we have planned.
+  //
+  // This function also never performs React work synchronously; it should
+  // only schedule work to be performed later, in a separate task or microtask.
+  // Check if any lanes are being starved by other work. If so, mark them as
+  // expired so we know to work on those next.
+  markStarvedLanesAsExpired(root, currentTime); // Determine the next lanes to work on, and their priority.
+
+  const workInProgressRoot = getWorkInProgressRoot();
+  const workInProgressRootRenderLanes = getWorkInProgressRootRenderLanes();
+  const nextLanes = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes);
+  const existingCallbackNode = root.callbackNode;
+
+  if ( // Check if there's nothing to work on
+  nextLanes === NoLanes || // If this root is currently suspended and waiting for data to resolve, don't
+  // schedule a task to render it. We'll either wait for a ping, or wait to
+  // receive an update.
+  //
+  // Suspended render phase
+  root === workInProgressRoot && isWorkLoopSuspendedOnData() || // Suspended commit phase
+  root.cancelPendingCommit !== null) {
+    // Fast path: There's nothing to work on.
+    if (existingCallbackNode !== null) {
+      cancelCallback(existingCallbackNode);
+    }
+
+    root.callbackNode = null;
+    root.callbackPriority = NoLane;
+    return NoLane;
+  } // Schedule a new callback in the host environment.
+
+
+  if (includesSyncLane(nextLanes)) {
+    // Synchronous work is always flushed at the end of the microtask, so we
+    // don't need to schedule an additional task.
+    if (existingCallbackNode !== null) {
+      cancelCallback(existingCallbackNode);
+    }
+
+    root.callbackPriority = SyncLane;
+    root.callbackNode = null;
+    return SyncLane;
+  } else {
+    // We use the highest priority lane to represent the priority of the callback.
+    const existingCallbackPriority = root.callbackPriority;
+    const newCallbackPriority = getHighestPriorityLane(nextLanes);
+
+    if (newCallbackPriority === existingCallbackPriority && // Special case related to `act`. If the currently scheduled task is a
+    // Scheduler task, rather than an `act` task, cancel it and re-schedule
+    // on the `act` queue.
+    !(false  )) {
+      // The priority hasn't changed. We can reuse the existing task.
+      return newCallbackPriority;
+    } else {
+      // Cancel the existing callback. We'll schedule a new one below.
+      cancelCallback(existingCallbackNode);
+    }
+
+    let schedulerPriorityLevel;
+
+    switch (lanesToEventPriority(nextLanes)) {
+      case DiscreteEventPriority:
+        schedulerPriorityLevel = ImmediatePriority;
+        break;
+
+      case ContinuousEventPriority:
+        schedulerPriorityLevel = UserBlockingPriority;
+        break;
+
+      case DefaultEventPriority:
+        schedulerPriorityLevel = NormalPriority$1;
+        break;
+
+      case IdleEventPriority:
+        schedulerPriorityLevel = IdlePriority;
+        break;
+
+      default:
+        schedulerPriorityLevel = NormalPriority$1;
+        break;
+    }
+
+    const newCallbackNode = scheduleCallback$2(schedulerPriorityLevel, performConcurrentWorkOnRoot.bind(null, root));
+    root.callbackPriority = newCallbackPriority;
+    root.callbackNode = newCallbackNode;
+    return newCallbackPriority;
+  }
+}
+
+function getContinuationForRoot(root, originalCallbackNode) {
+  // This is called at the end of `performConcurrentWorkOnRoot` to determine
+  // if we need to schedule a continuation task.
+  //
+  // Usually `scheduleTaskForRootDuringMicrotask` only runs inside a microtask;
+  // however, since most of the logic for determining if we need a continuation
+  // versus a new task is the same, we cheat a bit and call it here. This is
+  // only safe to do because we know we're at the end of the browser task.
+  // So although it's not an actual microtask, it might as well be.
+  scheduleTaskForRootDuringMicrotask(root, now$1());
+
+  if (root.callbackNode === originalCallbackNode) {
+    // The task node scheduled for this root is the same one that's
+    // currently executed. Need to return a continuation.
+    return performConcurrentWorkOnRoot.bind(null, root);
+  }
+
+  return null;
+}
+
+function scheduleCallback$2(priorityLevel, callback) {
+  {
+    return scheduleCallback$3(priorityLevel, callback);
+  }
+}
+
+function cancelCallback(callbackNode) {
+  if (callbackNode !== null) {
+    cancelCallback$1(callbackNode);
+  }
+}
+
+function scheduleImmediateTask(cb) {
+  // Alternatively, can we move this check to the host config?
+
+
+  {
+    scheduleMicrotask(() => {
+      // In Safari, appending an iframe forces microtasks to run.
+      // https://github.com/facebook/react/issues/22459
+      // We don't support running callbacks in the middle of render
+      // or commit so we need to check against that.
+      const executionContext = getExecutionContext();
+
+      if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+        // Note that this would still prematurely flush the callbacks
+        // if this happens outside render or commit phase (e.g. in an event).
+        // Intentionally using a macrotask instead of a microtask here. This is
+        // wrong semantically but it prevents an infinite loop. The bug is
+        // Safari's, not ours, so we just do our best to not crash even though
+        // the behavior isn't completely correct.
+        scheduleCallback$3(ImmediatePriority, cb);
+        return;
+      }
+
+      cb();
+    });
+  }
+}
+
+function requestTransitionLane() {
+  // The algorithm for assigning an update to a lane should be stable for all
+  // updates at the same priority within the same event. To do this, the
+  // inputs to the algorithm must be the same.
+  //
+  // The trick we use is to cache the first of each of these inputs within an
+  // event. Then reset the cached values once we can be sure the event is
+  // over. Our heuristic for that is whenever we enter a concurrent work loop.
+  if (currentEventTransitionLane === NoLane) {
+    // All transitions within the same event are assigned the same lane.
+    currentEventTransitionLane = claimNextTransitionLane();
+  }
+
+  return currentEventTransitionLane;
+}
+
+// transition updates that occur while the async action is still in progress
+// are treated as part of the action.
+//
+// The ideal behavior would be to treat each async function as an independent
+// action. However, without a mechanism like AsyncContext, we can't tell which
+// action an update corresponds to. So instead, we entangle them all into one.
+// The listeners to notify once the entangled scope completes.
+
+let currentEntangledListeners = null; // The number of pending async actions in the entangled scope.
+
+let currentEntangledPendingCount = 0; // The transition lane shared by all updates in the entangled scope.
+
+let currentEntangledLane = NoLane;
+function requestAsyncActionContext(actionReturnValue, // If this is provided, this resulting thenable resolves to this value instead
+// of the return value of the action. This is a perf trick to avoid composing
+// an extra async function.
+overrideReturnValue) {
+  // This is an async action.
+  //
+  // Return a thenable that resolves once the action scope (i.e. the async
+  // function passed to startTransition) has finished running.
+  const thenable = actionReturnValue;
+  let entangledListeners;
+
+  if (currentEntangledListeners === null) {
+    // There's no outer async action scope. Create a new one.
+    entangledListeners = currentEntangledListeners = [];
+    currentEntangledPendingCount = 0;
+    currentEntangledLane = requestTransitionLane();
+  } else {
+    entangledListeners = currentEntangledListeners;
+  }
+
+  currentEntangledPendingCount++; // Create a thenable that represents the result of this action, but doesn't
+  // resolve until the entire entangled scope has finished.
+  //
+  // Expressed using promises:
+  //   const [thisResult] = await Promise.all([thisAction, entangledAction]);
+  //   return thisResult;
+
+  const resultThenable = createResultThenable(entangledListeners);
+  let resultStatus = 'pending';
+  let resultValue;
+  let rejectedReason;
+  thenable.then(value => {
+    resultStatus = 'fulfilled';
+    resultValue = overrideReturnValue !== null ? overrideReturnValue : value;
+    pingEngtangledActionScope();
+  }, error => {
+    resultStatus = 'rejected';
+    rejectedReason = error;
+    pingEngtangledActionScope();
+  }); // Attach a listener to fill in the result.
+
+  entangledListeners.push(() => {
+    switch (resultStatus) {
+      case 'fulfilled':
+        {
+          const fulfilledThenable = resultThenable;
+          fulfilledThenable.status = 'fulfilled';
+          fulfilledThenable.value = resultValue;
+          break;
+        }
+
+      case 'rejected':
+        {
+          const rejectedThenable = resultThenable;
+          rejectedThenable.status = 'rejected';
+          rejectedThenable.reason = rejectedReason;
+          break;
+        }
+
+      case 'pending':
+      default:
+        {
+          // The listener above should have been called first, so `resultStatus`
+          // should already be set to the correct value.
+          throw Error(formatProdErrorMessage(478));
+        }
+    }
+  });
+  return resultThenable;
+}
+function requestSyncActionContext(actionReturnValue, // If this is provided, this resulting thenable resolves to this value instead
+// of the return value of the action. This is a perf trick to avoid composing
+// an extra async function.
+overrideReturnValue) {
+  const resultValue = overrideReturnValue !== null ? overrideReturnValue : actionReturnValue; // This is not an async action, but it may be part of an outer async action.
+
+  if (currentEntangledListeners === null) {
+    return resultValue;
+  } else {
+    // Return a thenable that does not resolve until the entangled actions
+    // have finished.
+    const entangledListeners = currentEntangledListeners;
+    const resultThenable = createResultThenable(entangledListeners);
+    entangledListeners.push(() => {
+      const fulfilledThenable = resultThenable;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = resultValue;
+    });
+    return resultThenable;
+  }
+}
+
+function pingEngtangledActionScope() {
+  if (currentEntangledListeners !== null && --currentEntangledPendingCount === 0) {
+    // All the actions have finished. Close the entangled async action scope
+    // and notify all the listeners.
+    const listeners = currentEntangledListeners;
+    currentEntangledListeners = null;
+    currentEntangledLane = NoLane;
+
+    for (let i = 0; i < listeners.length; i++) {
+      const listener = listeners[i];
+      listener();
+    }
+  }
+}
+
+function createResultThenable(entangledListeners) {
+  // Waits for the entangled async action to complete, then resolves to the
+  // result of an individual action.
+  const resultThenable = {
+    status: 'pending',
+    value: null,
+    reason: null,
+
+    then(resolve) {
+      // This is a bit of a cheat. `resolve` expects a value of type `S` to be
+      // passed, but because we're instrumenting the `status` field ourselves,
+      // and we know this thenable will only be used by React, we also know
+      // the value isn't actually needed. So we add the resolve function
+      // directly to the entangled listeners.
+      //
+      // This is also why we don't need to check if the thenable is still
+      // pending; the Suspense implementation already performs that check.
+      const ping = resolve;
+      entangledListeners.push(ping);
+    }
+
+  };
+  return resultThenable;
+}
+
+function peekEntangledActionLane() {
+  return currentEntangledLane;
+}
+
+const ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
+      ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig;
+// lifetime of an effect. In Rust terms, a RefCell. We use it to store the
+// "destroy" function that is returned from an effect, because that is stateful.
+// The field is `undefined` if the effect is unmounted, or if the effect ran
+// but is not stateful. We don't explicitly track whether the effect is mounted
+// or unmounted because that can be inferred by the hiddenness of the fiber in
+// the tree, i.e. whether there is a hidden Offscreen fiber above it.
+//
+// It's unfortunate that this is stored on a separate object, because it adds
+// more memory per effect instance, but it's conceptually sound. I think there's
+// likely a better data structure we could use for effects; perhaps just one
+// array of effect instances per fiber. But I think this is OK for now despite
+// the additional memory and we can follow up with performance
+// optimizations later.
+// These are set right before calling the component.
+
+
+let renderLanes = NoLanes; // The work-in-progress fiber. I've named it differently to distinguish it from
+// the work-in-progress hook.
+
+let currentlyRenderingFiber$1 = null; // Hooks are stored as a linked list on the fiber's memoizedState field. The
+// current hook list is the list that belongs to the current fiber. The
+// work-in-progress hook list is a new list that will be added to the
+// work-in-progress fiber.
+
+let currentHook = null;
+let workInProgressHook = null; // Whether an update was scheduled at any point during the render phase. This
+// does not get reset if we do another render pass; only when we're completely
+// finished evaluating this component. This is an optimization so we know
+// whether we need to clear render phase updates after a throw.
+
+let didScheduleRenderPhaseUpdate = false; // Where an update was scheduled only during the current render pass. This
+// gets reset after each attempt.
+// TODO: Maybe there's some way to consolidate this with
+// `didScheduleRenderPhaseUpdate`. Or with `numberOfReRenders`.
+
+let didScheduleRenderPhaseUpdateDuringThisPass = false;
+let shouldDoubleInvokeUserFnsInHooksDEV = false; // Counts the number of useId hooks in this component.
+
+let localIdCounter = 0; // Counts number of `use`-d thenables
+
+let thenableIndexCounter = 0;
+let thenableState = null; // Used for ids that are generated completely client-side (i.e. not during
+// hydration). This counter is global, so client ids are not stable across
+// render attempts.
+
+let globalClientIdCounter = 0;
+const RE_RENDER_LIMIT = 25; // In DEV, this is the name of the currently executing primitive hook
+
+function throwInvalidHookError() {
+  throw Error(formatProdErrorMessage(321));
+}
+
+function areHookInputsEqual(nextDeps, prevDeps) {
+
+  if (prevDeps === null) {
+
+    return false;
+  }
+
+
+  for (let i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    if (objectIs(nextDeps[i], prevDeps[i])) {
+      continue;
+    }
+
+    return false;
+  }
+
+  return true;
+}
+
+function renderWithHooks(current, workInProgress, Component, props, secondArg, nextRenderLanes) {
+  renderLanes = nextRenderLanes;
+  currentlyRenderingFiber$1 = workInProgress;
+
+  workInProgress.memoizedState = null;
+  workInProgress.updateQueue = null;
+  workInProgress.lanes = NoLanes; // The following should have already been reset
+  // currentHook = null;
+  // workInProgressHook = null;
+  // didScheduleRenderPhaseUpdate = false;
+  // localIdCounter = 0;
+  // thenableIndexCounter = 0;
+  // thenableState = null;
+  // TODO Warn if no hooks are used at all during mount, then some are used during update.
+  // Currently we will identify the update render as a mount because memoizedState === null.
+  // This is tricky because it's valid for certain types of components (e.g. React.lazy)
+  // Using memoizedState to differentiate between mount/update only works if at least one stateful hook is used.
+  // Non-stateful hooks (e.g. context) don't get added to memoizedState,
+  // so memoizedState would be null during updates and mounts.
+
+  {
+    ReactCurrentDispatcher$1.current = current === null || current.memoizedState === null ? HooksDispatcherOnMount : HooksDispatcherOnUpdate;
+  } // In Strict Mode, during development, user functions are double invoked to
+  // help detect side effects. The logic for how this is implemented for in
+  // hook components is a bit complex so let's break it down.
+  //
+  // We will invoke the entire component function twice. However, during the
+  // second invocation of the component, the hook state from the first
+  // invocation will be reused. That means things like `useMemo` functions won't
+  // run again, because the deps will match and the memoized result will
+  // be reused.
+  //
+  // We want memoized functions to run twice, too, so account for this, user
+  // functions are double invoked during the *first* invocation of the component
+  // function, and are *not* double invoked during the second incovation:
+  //
+  // - First execution of component function: user functions are double invoked
+  // - Second execution of component function (in Strict Mode, during
+  //   development): user functions are not double invoked.
+  //
+  // This is intentional for a few reasons; most importantly, it's because of
+  // how `use` works when something suspends: it reuses the promise that was
+  // passed during the first attempt. This is itself a form of memoization.
+  // We need to be able to memoize the reactive inputs to the `use` call using
+  // a hook (i.e. `useMemo`), which means, the reactive inputs to `use` must
+  // come from the same component invocation as the output.
+  //
+  // There are plenty of tests to ensure this behavior is correct.
+
+
+  const shouldDoubleRenderDEV = false  ;
+  shouldDoubleInvokeUserFnsInHooksDEV = shouldDoubleRenderDEV;
+  let children = Component(props, secondArg);
+  shouldDoubleInvokeUserFnsInHooksDEV = false; // Check if there was a render phase update
+
+  if (didScheduleRenderPhaseUpdateDuringThisPass) {
+    // Keep rendering until the component stabilizes (there are no more render
+    // phase updates).
+    children = renderWithHooksAgain(workInProgress, Component, props, secondArg);
+  }
+
+  finishRenderingHooks();
+  return children;
+}
+
+function finishRenderingHooks(current, workInProgress, Component) {
+  // at the beginning of the render phase and there's no re-entrance.
+
+
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher; // This check uses currentHook so that it works the same in DEV and prod bundles.
+  // hookTypesDev could catch more cases (e.g. context) but only in DEV bundles.
+
+  const didRenderTooFewHooks = currentHook !== null && currentHook.next !== null;
+  renderLanes = NoLanes;
+  currentlyRenderingFiber$1 = null;
+  currentHook = null;
+  workInProgressHook = null;
+
+  didScheduleRenderPhaseUpdate = false; // This is reset by checkDidRenderIdHook
+  // localIdCounter = 0;
+
+  thenableIndexCounter = 0;
+  thenableState = null;
+
+  if (didRenderTooFewHooks) {
+    throw Error(formatProdErrorMessage(300));
+  }
+}
+
+function replaySuspendedComponentWithHooks(current, workInProgress, Component, props, secondArg) {
+
+  const children = renderWithHooksAgain(workInProgress, Component, props, secondArg);
+  finishRenderingHooks();
+  return children;
+}
+
+function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
+  // This is used to perform another render pass. It's used when setState is
+  // called during render, and for double invoking components in Strict Mode
+  // during development.
+  //
+  // The state from the previous pass is reused whenever possible. So, state
+  // updates that were already processed are not processed again, and memoized
+  // functions (`useMemo`) are not invoked again.
+  //
+  // Keep rendering in a loop for as long as render phase updates continue to
+  // be scheduled. Use a counter to prevent infinite loops.
+  currentlyRenderingFiber$1 = workInProgress;
+  let numberOfReRenders = 0;
+  let children;
+
+  do {
+    if (didScheduleRenderPhaseUpdateDuringThisPass) {
+      // It's possible that a use() value depended on a state that was updated in
+      // this rerender, so we need to watch for different thenables this time.
+      thenableState = null;
+    }
+
+    thenableIndexCounter = 0;
+    didScheduleRenderPhaseUpdateDuringThisPass = false;
+
+    if (numberOfReRenders >= RE_RENDER_LIMIT) {
+      throw Error(formatProdErrorMessage(301));
+    }
+
+    numberOfReRenders += 1;
+
+
+    currentHook = null;
+    workInProgressHook = null;
+    workInProgress.updateQueue = null;
+
+    ReactCurrentDispatcher$1.current = HooksDispatcherOnRerender;
+    children = Component(props, secondArg);
+  } while (didScheduleRenderPhaseUpdateDuringThisPass);
+
+  return children;
+}
+
+function renderTransitionAwareHostComponentWithHooks(current, workInProgress, lanes) {
+
+  return renderWithHooks(current, workInProgress, TransitionAwareHostComponent, null, null, lanes);
+}
+function TransitionAwareHostComponent() {
+
+  const dispatcher = ReactCurrentDispatcher$1.current;
+
+  const _dispatcher$useState = dispatcher.useState(),
+        maybeThenable = _dispatcher$useState[0];
+
+  if (typeof maybeThenable.then === 'function') {
+    const thenable = maybeThenable;
+    return useThenable(thenable);
+  } else {
+    const status = maybeThenable;
+    return status;
+  }
+}
+function checkDidRenderIdHook() {
+  // This should be called immediately after every renderWithHooks call.
+  // Conceptually, it's part of the return value of renderWithHooks; it's only a
+  // separate function to avoid using an array tuple.
+  const didRenderIdHook = localIdCounter !== 0;
+  localIdCounter = 0;
+  return didRenderIdHook;
+}
+function bailoutHooks(current, workInProgress, lanes) {
+  workInProgress.updateQueue = current.updateQueue; // TODO: Don't need to reset the flags here, because they're reset in the
+  // complete phase (bubbleProperties).
+
+  {
+    workInProgress.flags &= ~(Passive$1 | Update);
+  }
+
+  current.lanes = removeLanes(current.lanes, lanes);
+}
+function resetHooksAfterThrow() {
+  // This is called immediaetly after a throw. It shouldn't reset the entire
+  // module state, because the work loop might decide to replay the component
+  // again without rewinding.
+  //
+  // It should only reset things like the current dispatcher, to prevent hooks
+  // from being called outside of a component.
+  currentlyRenderingFiber$1 = null; // We can assume the previous dispatcher is always this one, since we set it
+  // at the beginning of the render phase and there's no re-entrance.
+
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+}
+function resetHooksOnUnwind(workInProgress) {
+  if (didScheduleRenderPhaseUpdate) {
+    // There were render phase updates. These are only valid for this render
+    // phase, which we are now aborting. Remove the updates from the queues so
+    // they do not persist to the next render. Do not remove updates from hooks
+    // that weren't processed.
+    //
+    // Only reset the updates from the queue if it has a clone. If it does
+    // not have a clone, that means it wasn't processed, and the updates were
+    // scheduled before we entered the render phase.
+    let hook = workInProgress.memoizedState;
+
+    while (hook !== null) {
+      const queue = hook.queue;
+
+      if (queue !== null) {
+        queue.pending = null;
+      }
+
+      hook = hook.next;
+    }
+
+    didScheduleRenderPhaseUpdate = false;
+  }
+
+  renderLanes = NoLanes;
+  currentlyRenderingFiber$1 = null;
+  currentHook = null;
+  workInProgressHook = null;
+
+  didScheduleRenderPhaseUpdateDuringThisPass = false;
+  localIdCounter = 0;
+  thenableIndexCounter = 0;
+  thenableState = null;
+}
+
+function mountWorkInProgressHook() {
+  const hook = {
+    memoizedState: null,
+    baseState: null,
+    baseQueue: null,
+    queue: null,
+    next: null
+  };
+
+  if (workInProgressHook === null) {
+    // This is the first hook in the list
+    currentlyRenderingFiber$1.memoizedState = workInProgressHook = hook;
+  } else {
+    // Append to the end of the list
+    workInProgressHook = workInProgressHook.next = hook;
+  }
+
+  return workInProgressHook;
+}
+
+function updateWorkInProgressHook() {
+  // This function is used both for updates and for re-renders triggered by a
+  // render phase update. It assumes there is either a current hook we can
+  // clone, or a work-in-progress hook from a previous render pass that we can
+  // use as a base.
+  let nextCurrentHook;
+
+  if (currentHook === null) {
+    const current = currentlyRenderingFiber$1.alternate;
+
+    if (current !== null) {
+      nextCurrentHook = current.memoizedState;
+    } else {
+      nextCurrentHook = null;
+    }
+  } else {
+    nextCurrentHook = currentHook.next;
+  }
+
+  let nextWorkInProgressHook;
+
+  if (workInProgressHook === null) {
+    nextWorkInProgressHook = currentlyRenderingFiber$1.memoizedState;
+  } else {
+    nextWorkInProgressHook = workInProgressHook.next;
+  }
+
+  if (nextWorkInProgressHook !== null) {
+    // There's already a work-in-progress. Reuse it.
+    workInProgressHook = nextWorkInProgressHook;
+    nextWorkInProgressHook = workInProgressHook.next;
+    currentHook = nextCurrentHook;
+  } else {
+    // Clone from the current hook.
+    if (nextCurrentHook === null) {
+      const currentFiber = currentlyRenderingFiber$1.alternate;
+
+      if (currentFiber === null) {
+        // This is the initial render. This branch is reached when the component
+        // suspends, resumes, then renders an additional hook.
+        // Should never be reached because we should switch to the mount dispatcher first.
+        throw Error(formatProdErrorMessage(467));
+      } else {
+        // This is an update. We should always have a current hook.
+        throw Error(formatProdErrorMessage(310));
+      }
+    }
+
+    currentHook = nextCurrentHook;
+    const newHook = {
+      memoizedState: currentHook.memoizedState,
+      baseState: currentHook.baseState,
+      baseQueue: currentHook.baseQueue,
+      queue: currentHook.queue,
+      next: null
+    };
+
+    if (workInProgressHook === null) {
+      // This is the first hook in the list.
+      currentlyRenderingFiber$1.memoizedState = workInProgressHook = newHook;
+    } else {
+      // Append to the end of the list.
+      workInProgressHook = workInProgressHook.next = newHook;
+    }
+  }
+
+  return workInProgressHook;
+} // NOTE: defining two versions of this function to avoid size impact when this feature is disabled.
+// Previously this function was inlined, the additional `memoCache` property makes it not inlined.
+
+
+let createFunctionComponentUpdateQueue;
+
+{
+  createFunctionComponentUpdateQueue = () => {
+    return {
+      lastEffect: null,
+      events: null,
+      stores: null,
+      memoCache: null
+    };
+  };
+}
+
+function useThenable(thenable) {
+  // Track the position of the thenable within this fiber.
+  const index = thenableIndexCounter;
+  thenableIndexCounter += 1;
+
+  if (thenableState === null) {
+    thenableState = createThenableState();
+  }
+
+  const result = trackUsedThenable(thenableState, thenable, index);
+
+  if (currentlyRenderingFiber$1.alternate === null && (workInProgressHook === null ? currentlyRenderingFiber$1.memoizedState === null : workInProgressHook.next === null)) {
+    // Initial render, and either this is the first time the component is
+    // called, or there were no Hooks called after this use() the previous
+    // time (perhaps because it threw). Subsequent Hook calls should use the
+    // mount dispatcher.
+    {
+      ReactCurrentDispatcher$1.current = HooksDispatcherOnMount;
+    }
+  }
+
+  return result;
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable;
+      return useThenable(thenable);
+    } else if (usable.$$typeof === REACT_CONTEXT_TYPE || usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+  throw Error(formatProdErrorMessage(438, String(usable)));
+}
+
+function useMemoCache(size) {
+  let memoCache = null; // Fast-path, load memo cache from wip fiber if already prepared
+
+  let updateQueue = currentlyRenderingFiber$1.updateQueue;
+
+  if (updateQueue !== null) {
+    memoCache = updateQueue.memoCache;
+  } // Otherwise clone from the current fiber
+
+
+  if (memoCache == null) {
+    const current = currentlyRenderingFiber$1.alternate;
+
+    if (current !== null) {
+      const currentUpdateQueue = current.updateQueue;
+
+      if (currentUpdateQueue !== null) {
+        const currentMemoCache = currentUpdateQueue.memoCache;
+
+        if (currentMemoCache != null) {
+          memoCache = {
+            data: currentMemoCache.data.map(array => 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;
+  let data = memoCache.data[memoCache.index];
+
+  if (data === undefined) {
+    data = memoCache.data[memoCache.index] = new Array(size);
+
+    for (let i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL;
+    }
+  }
+
+  memoCache.index++;
+  return data;
+}
+
+function basicStateReducer(state, action) {
+  // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
+  return typeof action === 'function' ? action(state) : action;
+}
+
+function mountReducer(reducer, initialArg, init) {
+  const hook = mountWorkInProgressHook();
+  let initialState;
+
+  if (init !== undefined) {
+    initialState = init(initialArg);
+  } else {
+    initialState = initialArg;
+  }
+
+  hook.memoizedState = hook.baseState = initialState;
+  const queue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    lastRenderedReducer: reducer,
+    lastRenderedState: initialState
+  };
+  hook.queue = queue;
+  const dispatch = queue.dispatch = dispatchReducerAction.bind(null, currentlyRenderingFiber$1, queue);
+  return [hook.memoizedState, dispatch];
+}
+
+function updateReducer(reducer, initialArg, init) {
+  const hook = updateWorkInProgressHook();
+  return updateReducerImpl(hook, currentHook, reducer);
+}
+
+function updateReducerImpl(hook, current, reducer) {
+  const queue = hook.queue;
+
+  if (queue === null) {
+    throw Error(formatProdErrorMessage(311));
+  }
+
+  queue.lastRenderedReducer = reducer; // The last rebase update that is NOT part of the base state.
+
+  let baseQueue = hook.baseQueue; // The last pending update that hasn't been processed yet.
+
+  const pendingQueue = queue.pending;
+
+  if (pendingQueue !== null) {
+    // We have new updates that haven't been processed yet.
+    // We'll add them to the base queue.
+    if (baseQueue !== null) {
+      // Merge the pending queue and the base queue.
+      const baseFirst = baseQueue.next;
+      const pendingFirst = pendingQueue.next;
+      baseQueue.next = pendingFirst;
+      pendingQueue.next = baseFirst;
+    }
+
+    current.baseQueue = baseQueue = pendingQueue;
+    queue.pending = null;
+  }
+
+  if (baseQueue !== null) {
+    // We have a queue to process.
+    const first = baseQueue.next;
+    let newState = hook.baseState;
+    let newBaseState = null;
+    let newBaseQueueFirst = null;
+    let newBaseQueueLast = null;
+    let update = first;
+
+    do {
+      // An extra OffscreenLane bit is added to updates that were made to
+      // a hidden tree, so that we can distinguish them from updates that were
+      // already there when the tree was hidden.
+      const updateLane = removeLanes(update.lane, OffscreenLane);
+      const isHiddenUpdate = updateLane !== update.lane; // Check if this update was made while the tree was hidden. If so, then
+      // it's not a "base" update and we should disregard the extra base lanes
+      // that were added to renderLanes when we entered the Offscreen tree.
+
+      const shouldSkipUpdate = isHiddenUpdate ? !isSubsetOfLanes(getWorkInProgressRootRenderLanes(), updateLane) : !isSubsetOfLanes(renderLanes, updateLane);
+
+      if (shouldSkipUpdate) {
+        // Priority is insufficient. Skip this update. If this is the first
+        // skipped update, the previous update/state is the new base
+        // update/state.
+        const clone = {
+          lane: updateLane,
+          revertLane: update.revertLane,
+          action: update.action,
+          hasEagerState: update.hasEagerState,
+          eagerState: update.eagerState,
+          next: null
+        };
+
+        if (newBaseQueueLast === null) {
+          newBaseQueueFirst = newBaseQueueLast = clone;
+          newBaseState = newState;
+        } else {
+          newBaseQueueLast = newBaseQueueLast.next = clone;
+        } // Update the remaining priority in the queue.
+        // TODO: Don't need to accumulate this. Instead, we can remove
+        // renderLanes from the original lanes.
+
+
+        currentlyRenderingFiber$1.lanes = mergeLanes(currentlyRenderingFiber$1.lanes, updateLane);
+        markSkippedUpdateLanes(updateLane);
+      } else {
+        // This update does have sufficient priority.
+        // Check if this is an optimistic update.
+        const revertLane = update.revertLane;
+
+        if (revertLane === NoLane) {
+          // This is not an optimistic update, and we're going to apply it now.
+          // But, if there were earlier updates that were skipped, we need to
+          // leave this update in the queue so it can be rebased later.
+          if (newBaseQueueLast !== null) {
+            const clone = {
+              // This update is going to be committed so we never want uncommit
+              // it. Using NoLane works because 0 is a subset of all bitmasks, so
+              // this will never be skipped by the check above.
+              lane: NoLane,
+              revertLane: NoLane,
+              action: update.action,
+              hasEagerState: update.hasEagerState,
+              eagerState: update.eagerState,
+              next: null
+            };
+            newBaseQueueLast = newBaseQueueLast.next = clone;
+          }
+        } else {
+          // This is an optimistic update. If the "revert" priority is
+          // sufficient, don't apply the update. Otherwise, apply the update,
+          // but leave it in the queue so it can be either reverted or
+          // rebased in a subsequent render.
+          if (isSubsetOfLanes(renderLanes, revertLane)) {
+            // The transition that this optimistic update is associated with
+            // has finished. Pretend the update doesn't exist by skipping
+            // over it.
+            update = update.next;
+            continue;
+          } else {
+            const clone = {
+              // Once we commit an optimistic update, we shouldn't uncommit it
+              // until the transition it is associated with has finished
+              // (represented by revertLane). Using NoLane here works because 0
+              // is a subset of all bitmasks, so this will never be skipped by
+              // the check above.
+              lane: NoLane,
+              // Reuse the same revertLane so we know when the transition
+              // has finished.
+              revertLane: update.revertLane,
+              action: update.action,
+              hasEagerState: update.hasEagerState,
+              eagerState: update.eagerState,
+              next: null
+            };
+
+            if (newBaseQueueLast === null) {
+              newBaseQueueFirst = newBaseQueueLast = clone;
+              newBaseState = newState;
+            } else {
+              newBaseQueueLast = newBaseQueueLast.next = clone;
+            } // Update the remaining priority in the queue.
+            // TODO: Don't need to accumulate this. Instead, we can remove
+            // renderLanes from the original lanes.
+
+
+            currentlyRenderingFiber$1.lanes = mergeLanes(currentlyRenderingFiber$1.lanes, revertLane);
+            markSkippedUpdateLanes(revertLane);
+          }
+        } // Process this update.
+
+
+        const action = update.action;
+
+        if (shouldDoubleInvokeUserFnsInHooksDEV) {
+          reducer(newState, action);
+        }
+
+        if (update.hasEagerState) {
+          // If this update is a state update (not a reducer) and was processed eagerly,
+          // we can use the eagerly computed state
+          newState = update.eagerState;
+        } else {
+          newState = reducer(newState, action);
+        }
+      }
+
+      update = update.next;
+    } while (update !== null && update !== first);
+
+    if (newBaseQueueLast === null) {
+      newBaseState = newState;
+    } else {
+      newBaseQueueLast.next = newBaseQueueFirst;
+    } // Mark that the fiber performed work, but only if the new state is
+    // different from the current state.
+
+
+    if (!objectIs(newState, hook.memoizedState)) {
+      markWorkInProgressReceivedUpdate();
+    }
+
+    hook.memoizedState = newState;
+    hook.baseState = newBaseState;
+    hook.baseQueue = newBaseQueueLast;
+    queue.lastRenderedState = newState;
+  }
+
+  if (baseQueue === null) {
+    // `queue.lanes` is used for entangling transitions. We can set it back to
+    // zero once the queue is empty.
+    queue.lanes = NoLanes;
+  }
+
+  const dispatch = queue.dispatch;
+  return [hook.memoizedState, dispatch];
+}
+
+function rerenderReducer(reducer, initialArg, init) {
+  const hook = updateWorkInProgressHook();
+  const queue = hook.queue;
+
+  if (queue === null) {
+    throw Error(formatProdErrorMessage(311));
+  }
+
+  queue.lastRenderedReducer = reducer; // This is a re-render. Apply the new render phase updates to the previous
+  // work-in-progress hook.
+
+  const dispatch = queue.dispatch;
+  const lastRenderPhaseUpdate = queue.pending;
+  let newState = hook.memoizedState;
+
+  if (lastRenderPhaseUpdate !== null) {
+    // The queue doesn't persist past this render pass.
+    queue.pending = null;
+    const firstRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+    let update = firstRenderPhaseUpdate;
+
+    do {
+      // Process this render phase update. We don't have to check the
+      // priority because it will always be the same as the current
+      // render's.
+      const action = update.action;
+      newState = reducer(newState, action);
+      update = update.next;
+    } while (update !== firstRenderPhaseUpdate); // Mark that the fiber performed work, but only if the new state is
+    // different from the current state.
+
+
+    if (!objectIs(newState, hook.memoizedState)) {
+      markWorkInProgressReceivedUpdate();
+    }
+
+    hook.memoizedState = newState; // Don't persist the state accumulated from the render phase updates to
+    // the base state unless the queue is empty.
+    // TODO: Not sure if this is the desired semantics, but it's what we
+    // do for gDSFP. I can't remember why.
+
+    if (hook.baseQueue === null) {
+      hook.baseState = newState;
+    }
+
+    queue.lastRenderedState = newState;
+  }
+
+  return [newState, dispatch];
+}
+
+function mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  const fiber = currentlyRenderingFiber$1;
+  const hook = mountWorkInProgressHook();
+  let nextSnapshot;
+  const isHydrating = getIsHydrating();
+
+  if (isHydrating) {
+    if (getServerSnapshot === undefined) {
+      throw Error(formatProdErrorMessage(407));
+    }
+
+    nextSnapshot = getServerSnapshot();
+  } else {
+    nextSnapshot = getSnapshot();
+    // Right before committing, we will walk the tree and check if any of the
+    // stores were mutated.
+    //
+    // We won't do this if we're hydrating server-rendered content, because if
+    // the content is stale, it's already visible anyway. Instead we'll patch
+    // it up in a passive effect.
+
+
+    const root = getWorkInProgressRoot();
+
+    if (root === null) {
+      throw Error(formatProdErrorMessage(349));
+    }
+
+    const rootRenderLanes = getWorkInProgressRootRenderLanes();
+
+    if (!includesBlockingLane(root, rootRenderLanes)) {
+      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+    }
+  } // Read the current snapshot from the store on every render. This breaks the
+  // normal rules of React, and only works because store updates are
+  // always synchronous.
+
+
+  hook.memoizedState = nextSnapshot;
+  const inst = {
+    value: nextSnapshot,
+    getSnapshot
+  };
+  hook.queue = inst; // Schedule an effect to subscribe to the store.
+
+  mountEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [subscribe]); // Schedule an effect to update the mutable instance fields. We will update
+  // this whenever subscribe, getSnapshot, or value changes. Because there's no
+  // clean-up function, and we track the deps correctly, we can call pushEffect
+  // directly, without storing any additional state. For the same reason, we
+  // don't need to set a static flag, either.
+
+  fiber.flags |= Passive$1;
+  pushEffect(HasEffect | Passive, updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot), createEffectInstance(), null);
+  return nextSnapshot;
+}
+
+function updateSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  const fiber = currentlyRenderingFiber$1;
+  const hook = updateWorkInProgressHook(); // Read the current snapshot from the store on every render. This breaks the
+  // normal rules of React, and only works because store updates are
+  // always synchronous.
+
+  let nextSnapshot;
+  const isHydrating = getIsHydrating();
+
+  if (isHydrating) {
+    // Needed for strict mode double render
+    if (getServerSnapshot === undefined) {
+      throw Error(formatProdErrorMessage(407));
+    }
+
+    nextSnapshot = getServerSnapshot();
+  } else {
+    nextSnapshot = getSnapshot();
+  }
+
+  const prevSnapshot = (currentHook || hook).memoizedState;
+  const snapshotChanged = !objectIs(prevSnapshot, nextSnapshot);
+
+  if (snapshotChanged) {
+    hook.memoizedState = nextSnapshot;
+    markWorkInProgressReceivedUpdate();
+  }
+
+  const inst = hook.queue;
+  updateEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [subscribe]); // Whenever getSnapshot or subscribe changes, we need to check in the
+  // commit phase if there was an interleaved mutation. In concurrent mode
+  // this can happen all the time, but even in synchronous mode, an earlier
+  // effect may have mutated the store.
+
+  if (inst.getSnapshot !== getSnapshot || snapshotChanged || // Check if the subscribe function changed. We can save some memory by
+  // checking whether we scheduled a subscription effect above.
+  workInProgressHook !== null && workInProgressHook.memoizedState.tag & HasEffect) {
+    fiber.flags |= Passive$1;
+    pushEffect(HasEffect | Passive, updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot), createEffectInstance(), null); // Unless we're rendering a blocking lane, schedule a consistency check.
+    // Right before committing, we will walk the tree and check if any of the
+    // stores were mutated.
+
+    const root = getWorkInProgressRoot();
+
+    if (root === null) {
+      throw Error(formatProdErrorMessage(349));
+    }
+
+    if (!isHydrating && !includesBlockingLane(root, renderLanes)) {
+      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+    }
+  }
+
+  return nextSnapshot;
+}
+
+function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
+  fiber.flags |= StoreConsistency;
+  const check = {
+    getSnapshot,
+    value: renderedSnapshot
+  };
+  let componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.stores = [check];
+  } else {
+    const stores = componentUpdateQueue.stores;
+
+    if (stores === null) {
+      componentUpdateQueue.stores = [check];
+    } else {
+      stores.push(check);
+    }
+  }
+}
+
+function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
+  // These are updated in the passive phase
+  inst.value = nextSnapshot;
+  inst.getSnapshot = getSnapshot; // Something may have been mutated in between render and commit. This could
+  // have been in an event that fired before the passive effects, or it could
+  // have been in a layout effect. In that case, we would have used the old
+  // snapsho and getSnapshot values to bail out. We need to check one more time.
+
+  if (checkIfSnapshotChanged(inst)) {
+    // Force a re-render.
+    forceStoreRerender(fiber);
+  }
+}
+
+function subscribeToStore(fiber, inst, subscribe) {
+  const handleStoreChange = () => {
+    // The store changed. Check if the snapshot changed since the last time we
+    // read from the store.
+    if (checkIfSnapshotChanged(inst)) {
+      // Force a re-render.
+      forceStoreRerender(fiber);
+    }
+  }; // Subscribe to the store and return a clean-up function.
+
+
+  return subscribe(handleStoreChange);
+}
+
+function checkIfSnapshotChanged(inst) {
+  const latestGetSnapshot = inst.getSnapshot;
+  const prevValue = inst.value;
+
+  try {
+    const nextValue = latestGetSnapshot();
+    return !objectIs(prevValue, nextValue);
+  } catch (error) {
+    return true;
+  }
+}
+
+function forceStoreRerender(fiber) {
+  const root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, fiber, SyncLane);
+  }
+}
+
+function mountStateImpl(initialState) {
+  const hook = mountWorkInProgressHook();
+
+  if (typeof initialState === 'function') {
+    // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
+    initialState = initialState();
+  }
+
+  hook.memoizedState = hook.baseState = initialState;
+  const queue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    lastRenderedReducer: basicStateReducer,
+    lastRenderedState: initialState
+  };
+  hook.queue = queue;
+  return hook;
+}
+
+function mountState(initialState) {
+  const hook = mountStateImpl(initialState);
+  const queue = hook.queue;
+  const dispatch = dispatchSetState.bind(null, currentlyRenderingFiber$1, queue);
+  queue.dispatch = dispatch;
+  return [hook.memoizedState, dispatch];
+}
+
+function updateState(initialState) {
+  return updateReducer(basicStateReducer);
+}
+
+function rerenderState(initialState) {
+  return rerenderReducer(basicStateReducer);
+}
+
+function mountOptimistic(passthrough, reducer) {
+  const hook = mountWorkInProgressHook();
+  hook.memoizedState = hook.baseState = passthrough;
+  const queue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    // Optimistic state does not use the eager update optimization.
+    lastRenderedReducer: null,
+    lastRenderedState: null
+  };
+  hook.queue = queue; // This is different than the normal setState function.
+
+  const dispatch = dispatchOptimisticSetState.bind(null, currentlyRenderingFiber$1, true, queue);
+  queue.dispatch = dispatch;
+  return [passthrough, dispatch];
+}
+
+function updateOptimistic(passthrough, reducer) {
+  const hook = updateWorkInProgressHook();
+  return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
+}
+
+function updateOptimisticImpl(hook, current, passthrough, reducer) {
+  // Optimistic updates are always rebased on top of the latest value passed in
+  // as an argument. It's called a passthrough because if there are no pending
+  // updates, it will be returned as-is.
+  //
+  // Reset the base state to the passthrough. Future updates will be applied
+  // on top of this.
+  hook.baseState = passthrough; // If a reducer is not provided, default to the same one used by useState.
+
+  const resolvedReducer = typeof reducer === 'function' ? reducer : basicStateReducer;
+  return updateReducerImpl(hook, currentHook, resolvedReducer);
+}
+
+function rerenderOptimistic(passthrough, reducer) {
+  // Unlike useState, useOptimistic doesn't support render phase updates.
+  // Also unlike useState, we need to replay all pending updates again in case
+  // the passthrough value changed.
+  //
+  // So instead of a forked re-render implementation that knows how to handle
+  // render phase udpates, we can use the same implementation as during a
+  // regular mount or update.
+  const hook = updateWorkInProgressHook();
+
+  if (currentHook !== null) {
+    // This is an update. Process the update queue.
+    return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
+  } // This is a mount. No updates to process.
+  // Reset the base state to the passthrough. Future updates will be applied
+  // on top of this.
+
+
+  hook.baseState = passthrough;
+  const dispatch = hook.queue.dispatch;
+  return [passthrough, dispatch];
+} // useFormState actions run sequentially, because each action receives the
+// previous state as an argument. We store pending actions on a queue.
+
+
+function dispatchFormState(fiber, actionQueue, setState, payload) {
+  if (isRenderPhaseUpdate(fiber)) {
+    throw Error(formatProdErrorMessage(485));
+  }
+
+  const last = actionQueue.pending;
+
+  if (last === null) {
+    // There are no pending actions; this is the first one. We can run
+    // it immediately.
+    const newLast = {
+      payload,
+      next: null // circular
+
+    };
+    newLast.next = actionQueue.pending = newLast;
+    runFormStateAction(actionQueue, setState, payload);
+  } else {
+    // There's already an action running. Add to the queue.
+    const first = last.next;
+    const newLast = {
+      payload,
+      next: first
+    };
+    actionQueue.pending = last.next = newLast;
+  }
+}
+
+function runFormStateAction(actionQueue, setState, payload) {
+  const action = actionQueue.action;
+  const prevState = actionQueue.state; // This is a fork of startTransition
+
+  const prevTransition = ReactCurrentBatchConfig$3.transition;
+  ReactCurrentBatchConfig$3.transition = {};
+
+  try {
+    const returnValue = action(prevState, payload);
+
+    if (returnValue !== null && typeof returnValue === 'object' && // $FlowFixMe[method-unbinding]
+    typeof returnValue.then === 'function') {
+      const thenable = returnValue; // Attach a listener to read the return state of the action. As soon as
+      // this resolves, we can run the next action in the sequence.
+
+      thenable.then(nextState => {
+        actionQueue.state = nextState;
+        finishRunningFormStateAction(actionQueue, setState);
+      }, () => finishRunningFormStateAction(actionQueue, setState));
+      const entangledResult = requestAsyncActionContext(thenable, null);
+      setState(entangledResult);
+    } else {
+      // This is either `returnValue` or a thenable that resolves to
+      // `returnValue`, depending on whether we're inside an async action scope.
+      const entangledResult = requestSyncActionContext(returnValue, null);
+      setState(entangledResult);
+      const nextState = returnValue;
+      actionQueue.state = nextState;
+      finishRunningFormStateAction(actionQueue, setState);
+    }
+  } catch (error) {
+    // This is a trick to get the `useFormState` hook to rethrow the error.
+    // When it unwraps the thenable with the `use` algorithm, the error
+    // will be thrown.
+    const rejectedThenable = {
+      then() {},
+
+      status: 'rejected',
+      reason: error // $FlowFixMe: Not sure why this doesn't work
+
+    };
+    setState(rejectedThenable);
+    finishRunningFormStateAction(actionQueue, setState);
+  } finally {
+    ReactCurrentBatchConfig$3.transition = prevTransition;
+  }
+}
+
+function finishRunningFormStateAction(actionQueue, setState) {
+  // The action finished running. Pop it from the queue and run the next pending
+  // action, if there are any.
+  const last = actionQueue.pending;
+
+  if (last !== null) {
+    const first = last.next;
+
+    if (first === last) {
+      // This was the last action in the queue.
+      actionQueue.pending = null;
+    } else {
+      // Remove the first node from the circular queue.
+      const next = first.next;
+      last.next = next; // Run the next action.
+
+      runFormStateAction(actionQueue, setState, next.payload);
+    }
+  }
+}
+
+function formStateReducer(oldState, newState) {
+  return newState;
+}
+
+function mountFormState(action, initialStateProp, permalink) {
+  let initialState = initialStateProp;
+
+  if (getIsHydrating()) {
+    const root = getWorkInProgressRoot();
+    const ssrFormState = root.formState; // If a formState option was passed to the root, there are form state
+    // markers that we need to hydrate. These indicate whether the form state
+    // matches this hook instance.
+
+    if (ssrFormState !== null) {
+      const isMatching = tryToClaimNextHydratableFormMarkerInstance();
+
+      if (isMatching) {
+        initialState = ssrFormState[0];
+      }
+    }
+  } // State hook. The state is stored in a thenable which is then unwrapped by
+  // the `use` algorithm during render.
+
+
+  const stateHook = mountWorkInProgressHook();
+  stateHook.memoizedState = stateHook.baseState = initialState; // TODO: Typing this "correctly" results in recursion limit errors
+  // const stateQueue: UpdateQueue<S | Awaited<S>, S | Awaited<S>> = {
+
+  const stateQueue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    lastRenderedReducer: formStateReducer,
+    lastRenderedState: initialState
+  };
+  stateHook.queue = stateQueue;
+  const setState = dispatchSetState.bind(null, currentlyRenderingFiber$1, stateQueue);
+  stateQueue.dispatch = setState; // Action queue hook. This is used to queue pending actions. The queue is
+  // shared between all instances of the hook. Similar to a regular state queue,
+  // but different because the actions are run sequentially, and they run in
+  // an event instead of during render.
+
+  const actionQueueHook = mountWorkInProgressHook();
+  const actionQueue = {
+    state: initialState,
+    dispatch: null,
+    // circular
+    action,
+    pending: null
+  };
+  actionQueueHook.queue = actionQueue;
+  const dispatch = dispatchFormState.bind(null, currentlyRenderingFiber$1, actionQueue, setState);
+  actionQueue.dispatch = dispatch; // Stash the action function on the memoized state of the hook. We'll use this
+  // to detect when the action function changes so we can update it in
+  // an effect.
+
+  actionQueueHook.memoizedState = action;
+  return [initialState, dispatch];
+}
+
+function updateFormState(action, initialState, permalink) {
+  const stateHook = updateWorkInProgressHook();
+  const currentStateHook = currentHook;
+  return updateFormStateImpl(stateHook, currentStateHook, action);
+}
+
+function updateFormStateImpl(stateHook, currentStateHook, action, initialState, permalink) {
+  const _updateReducerImpl = updateReducerImpl(stateHook, currentStateHook, formStateReducer),
+        actionResult = _updateReducerImpl[0]; // This will suspend until the action finishes.
+
+
+  const state = typeof actionResult === 'object' && actionResult !== null && // $FlowFixMe[method-unbinding]
+  typeof actionResult.then === 'function' ? useThenable(actionResult) : actionResult;
+  const actionQueueHook = updateWorkInProgressHook();
+  const actionQueue = actionQueueHook.queue;
+  const dispatch = actionQueue.dispatch; // Check if a new action was passed. If so, update it in an effect.
+
+  const prevAction = actionQueueHook.memoizedState;
+
+  if (action !== prevAction) {
+    currentlyRenderingFiber$1.flags |= Passive$1;
+    pushEffect(HasEffect | Passive, formStateActionEffect.bind(null, actionQueue, action), createEffectInstance(), null);
+  }
+
+  return [state, dispatch];
+}
+
+function formStateActionEffect(actionQueue, action) {
+  actionQueue.action = action;
+}
+
+function rerenderFormState(action, initialState, permalink) {
+  // Unlike useState, useFormState doesn't support render phase updates.
+  // Also unlike useState, we need to replay all pending updates again in case
+  // the passthrough value changed.
+  //
+  // So instead of a forked re-render implementation that knows how to handle
+  // render phase udpates, we can use the same implementation as during a
+  // regular mount or update.
+  const stateHook = updateWorkInProgressHook();
+  const currentStateHook = currentHook;
+
+  if (currentStateHook !== null) {
+    // This is an update. Process the update queue.
+    return updateFormStateImpl(stateHook, currentStateHook, action);
+  } // This is a mount. No updates to process.
+
+
+  const state = stateHook.memoizedState;
+  const actionQueueHook = updateWorkInProgressHook();
+  const actionQueue = actionQueueHook.queue;
+  const dispatch = actionQueue.dispatch; // This may have changed during the rerender.
+
+  actionQueueHook.memoizedState = action;
+  return [state, dispatch];
+}
+
+function pushEffect(tag, create, inst, deps) {
+  const effect = {
+    tag,
+    create,
+    inst,
+    deps,
+    // Circular
+    next: null
+  };
+  let componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.lastEffect = effect.next = effect;
+  } else {
+    const lastEffect = componentUpdateQueue.lastEffect;
+
+    if (lastEffect === null) {
+      componentUpdateQueue.lastEffect = effect.next = effect;
+    } else {
+      const firstEffect = lastEffect.next;
+      lastEffect.next = effect;
+      effect.next = firstEffect;
+      componentUpdateQueue.lastEffect = effect;
+    }
+  }
+
+  return effect;
+}
+
+function createEffectInstance() {
+  return {
+    destroy: undefined
+  };
+}
+
+function mountRef(initialValue) {
+  const hook = mountWorkInProgressHook();
+
+  {
+    const ref = {
+      current: initialValue
+    };
+    hook.memoizedState = ref;
+    return ref;
+  }
+}
+
+function updateRef(initialValue) {
+  const hook = updateWorkInProgressHook();
+  return hook.memoizedState;
+}
+
+function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
+  const hook = mountWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(HasEffect | hookFlags, create, createEffectInstance(), nextDeps);
+}
+
+function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
+  const hook = updateWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  const effect = hook.memoizedState;
+  const inst = effect.inst; // currentHook is null on initial mount when rerendering after a render phase
+  // state update or for strict mode.
+
+  if (currentHook !== null) {
+    if (nextDeps !== null) {
+      const prevEffect = currentHook.memoizedState;
+      const prevDeps = prevEffect.deps;
+
+      if (areHookInputsEqual(nextDeps, prevDeps)) {
+        hook.memoizedState = pushEffect(hookFlags, create, inst, nextDeps);
+        return;
+      }
+    }
+  }
+
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(HasEffect | hookFlags, create, inst, nextDeps);
+}
+
+function mountEffect(create, deps) {
+  {
+    mountEffectImpl(Passive$1 | PassiveStatic, Passive, create, deps);
+  }
+}
+
+function updateEffect(create, deps) {
+  updateEffectImpl(Passive$1, Passive, create, deps);
+}
+
+function useEffectEventImpl(payload) {
+  currentlyRenderingFiber$1.flags |= Update;
+  let componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.events = [payload];
+  } else {
+    const events = componentUpdateQueue.events;
+
+    if (events === null) {
+      componentUpdateQueue.events = [payload];
+    } else {
+      events.push(payload);
+    }
+  }
+}
+
+function mountEvent(callback) {
+  const hook = mountWorkInProgressHook();
+  const ref = {
+    impl: callback
+  };
+  hook.memoizedState = ref; // $FlowIgnore[incompatible-return]
+
+  return function eventFn() {
+    if (isInvalidExecutionContextForEventFunction()) {
+      throw Error(formatProdErrorMessage(440));
+    }
+
+    return ref.impl.apply(undefined, arguments);
+  };
+}
+
+function updateEvent(callback) {
+  const hook = updateWorkInProgressHook();
+  const ref = hook.memoizedState;
+  useEffectEventImpl({
+    ref,
+    nextImpl: callback
+  }); // $FlowIgnore[incompatible-return]
+
+  return function eventFn() {
+    if (isInvalidExecutionContextForEventFunction()) {
+      throw Error(formatProdErrorMessage(440));
+    }
+
+    return ref.impl.apply(undefined, arguments);
+  };
+}
+
+function mountInsertionEffect(create, deps) {
+  mountEffectImpl(Update, Insertion, create, deps);
+}
+
+function updateInsertionEffect(create, deps) {
+  return updateEffectImpl(Update, Insertion, create, deps);
+}
+
+function mountLayoutEffect(create, deps) {
+  let fiberFlags = Update | LayoutStatic;
+
+  return mountEffectImpl(fiberFlags, Layout, create, deps);
+}
+
+function updateLayoutEffect(create, deps) {
+  return updateEffectImpl(Update, Layout, create, deps);
+}
+
+function imperativeHandleEffect(create, ref) {
+  if (typeof ref === 'function') {
+    const refCallback = ref;
+    const inst = create();
+    refCallback(inst);
+    return () => {
+      refCallback(null);
+    };
+  } else if (ref !== null && ref !== undefined) {
+    const refObject = ref;
+
+    const inst = create();
+    refObject.current = inst;
+    return () => {
+      refObject.current = null;
+    };
+  }
+}
+
+function mountImperativeHandle(ref, create, deps) {
+
+
+  const effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+  let fiberFlags = Update | LayoutStatic;
+
+  mountEffectImpl(fiberFlags, Layout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
+}
+
+function updateImperativeHandle(ref, create, deps) {
+
+
+  const effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+  updateEffectImpl(Update, Layout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
+}
+
+function mountDebugValue(value, formatterFn) {// This hook is normally a no-op.
+  // The react-debug-hooks package injects its own implementation
+  // so that e.g. DevTools can display custom hook values.
+}
+
+const updateDebugValue = mountDebugValue;
+
+function mountCallback(callback, deps) {
+  const hook = mountWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  hook.memoizedState = [callback, nextDeps];
+  return callback;
+}
+
+function updateCallback(callback, deps) {
+  const hook = updateWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  const prevState = hook.memoizedState;
+
+  if (nextDeps !== null) {
+    const prevDeps = prevState[1];
+
+    if (areHookInputsEqual(nextDeps, prevDeps)) {
+      return prevState[0];
+    }
+  }
+
+  hook.memoizedState = [callback, nextDeps];
+  return callback;
+}
+
+function mountMemo(nextCreate, deps) {
+  const hook = mountWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+
+  if (shouldDoubleInvokeUserFnsInHooksDEV) {
+    nextCreate();
+  }
+
+  const nextValue = nextCreate();
+  hook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
+
+function updateMemo(nextCreate, deps) {
+  const hook = updateWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  const prevState = hook.memoizedState; // Assume these are defined. If they're not, areHookInputsEqual will warn.
+
+  if (nextDeps !== null) {
+    const prevDeps = prevState[1];
+
+    if (areHookInputsEqual(nextDeps, prevDeps)) {
+      return prevState[0];
+    }
+  }
+
+  if (shouldDoubleInvokeUserFnsInHooksDEV) {
+    nextCreate();
+  }
+
+  const nextValue = nextCreate();
+  hook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
+
+function mountDeferredValue(value, initialValue) {
+  const hook = mountWorkInProgressHook();
+  return mountDeferredValueImpl(hook, value, initialValue);
+}
+
+function updateDeferredValue(value, initialValue) {
+  const hook = updateWorkInProgressHook();
+  const resolvedCurrentHook = currentHook;
+  const prevValue = resolvedCurrentHook.memoizedState;
+  return updateDeferredValueImpl(hook, prevValue, value, initialValue);
+}
+
+function rerenderDeferredValue(value, initialValue) {
+  const hook = updateWorkInProgressHook();
+
+  if (currentHook === null) {
+    // This is a rerender during a mount.
+    return mountDeferredValueImpl(hook, value, initialValue);
+  } else {
+    // This is a rerender during an update.
+    const prevValue = currentHook.memoizedState;
+    return updateDeferredValueImpl(hook, prevValue, value, initialValue);
+  }
+}
+
+function mountDeferredValueImpl(hook, value, initialValue) {
+  if (// When `initialValue` is provided, we defer the initial render even if the
+  // current render is not synchronous.
+  initialValue !== undefined && // However, to avoid waterfalls, we do not defer if this render
+  // was itself spawned by an earlier useDeferredValue. Check if DeferredLane
+  // is part of the render lanes.
+  !includesSomeLane(renderLanes, DeferredLane)) {
+    // Render with the initial value
+    hook.memoizedState = initialValue; // Schedule a deferred render to switch to the final value.
+
+    const deferredLane = requestDeferredLane();
+    currentlyRenderingFiber$1.lanes = mergeLanes(currentlyRenderingFiber$1.lanes, deferredLane);
+    markSkippedUpdateLanes(deferredLane);
+    return initialValue;
+  } else {
+    hook.memoizedState = value;
+    return value;
+  }
+}
+
+function updateDeferredValueImpl(hook, prevValue, value, initialValue) {
+  if (objectIs(value, prevValue)) {
+    // The incoming value is referentially identical to the currently rendered
+    // value, so we can bail out quickly.
+    return value;
+  } else {
+    // Received a new value that's different from the current value.
+    // Check if we're inside a hidden tree
+    if (isCurrentTreeHidden()) {
+      // Revealing a prerendered tree is considered the same as mounting new
+      // one, so we reuse the "mount" path in this case.
+      const resultValue = mountDeferredValueImpl(hook, value, initialValue); // Unlike during an actual mount, we need to mark this as an update if
+      // the value changed.
+
+      if (!objectIs(resultValue, prevValue)) {
+        markWorkInProgressReceivedUpdate();
+      }
+
+      return resultValue;
+    }
+
+    const shouldDeferValue = !includesOnlyNonUrgentLanes(renderLanes);
+
+    if (shouldDeferValue) {
+      // This is an urgent update. Since the value has changed, keep using the
+      // previous value and spawn a deferred render to update it later.
+      // Schedule a deferred render
+      const deferredLane = requestDeferredLane();
+      currentlyRenderingFiber$1.lanes = mergeLanes(currentlyRenderingFiber$1.lanes, deferredLane);
+      markSkippedUpdateLanes(deferredLane); // Reuse the previous value. We do not need to mark this as an update,
+      // because we did not render a new value.
+
+      return prevValue;
+    } else {
+      // This is not an urgent update, so we can use the latest value regardless
+      // of what it is. No need to defer it.
+      // Mark this as an update to prevent the fiber from bailing out.
+      markWorkInProgressReceivedUpdate();
+      hook.memoizedState = value;
+      return value;
+    }
+  }
+}
+
+function startTransition(fiber, queue, pendingState, finishedState, callback, options) {
+  const previousPriority = getCurrentUpdatePriority();
+  setCurrentUpdatePriority(higherEventPriority(previousPriority, ContinuousEventPriority));
+  const prevTransition = ReactCurrentBatchConfig$3.transition;
+  const currentTransition = {};
+
+  {
+    // We don't really need to use an optimistic update here, because we
+    // schedule a second "revert" update below (which we use to suspend the
+    // transition until the async action scope has finished). But we'll use an
+    // optimistic update anyway to make it less likely the behavior accidentally
+    // diverges; for example, both an optimistic update and this one should
+    // share the same lane.
+    ReactCurrentBatchConfig$3.transition = currentTransition;
+    dispatchOptimisticSetState(fiber, false, queue, pendingState);
+  }
+
+  try {
+    if (enableAsyncActions) {
+      const returnValue = callback(); // Check if we're inside an async action scope. If so, we'll entangle
+      // this new action with the existing scope.
+      //
+      // If we're not already inside an async action scope, and this action is
+      // async, then we'll create a new async scope.
+      //
+      // In the async case, the resulting render will suspend until the async
+      // action scope has finished.
+
+      if (returnValue !== null && typeof returnValue === 'object' && typeof returnValue.then === 'function') {
+        const thenable = returnValue; // This is a thenable that resolves to `finishedState` once the async
+        // action scope has finished.
+
+        const entangledResult = requestAsyncActionContext(thenable, finishedState);
+        dispatchSetState(fiber, queue, entangledResult);
+      } else {
+        // This is either `finishedState` or a thenable that resolves to
+        // `finishedState`, depending on whether we're inside an async
+        // action scope.
+        const entangledResult = requestSyncActionContext(returnValue, finishedState);
+        dispatchSetState(fiber, queue, entangledResult);
+      }
+    }
+  } catch (error) {
+    {
+      // This is a trick to get the `useTransition` hook to rethrow the error.
+      // When it unwraps the thenable with the `use` algorithm, the error
+      // will be thrown.
+      const rejectedThenable = {
+        then() {},
+
+        status: 'rejected',
+        reason: error
+      };
+      dispatchSetState(fiber, queue, rejectedThenable);
+    }
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$3.transition = prevTransition;
+  }
+}
+
+function startHostTransition(formFiber, pendingState, callback, formData) {
+
+  if (formFiber.tag !== HostComponent) {
+    throw Error(formatProdErrorMessage(476));
+  }
+
+  let queue;
+
+  if (formFiber.memoizedState === null) {
+    // Upgrade this host component fiber to be stateful. We're going to pretend
+    // it was stateful all along so we can reuse most of the implementation
+    // for function components and useTransition.
+    //
+    // Create the state hook used by TransitionAwareHostComponent. This is
+    // essentially an inlined version of mountState.
+    const newQueue = {
+      pending: null,
+      lanes: NoLanes,
+      // We're going to cheat and intentionally not create a bound dispatch
+      // method, because we can call it directly in startTransition.
+      dispatch: null,
+      lastRenderedReducer: basicStateReducer,
+      lastRenderedState: NotPendingTransition
+    };
+    queue = newQueue;
+    const stateHook = {
+      memoizedState: NotPendingTransition,
+      baseState: NotPendingTransition,
+      baseQueue: null,
+      queue: newQueue,
+      next: null
+    }; // Add the state hook to both fiber alternates. The idea is that the fiber
+    // had this hook all along.
+
+    formFiber.memoizedState = stateHook;
+    const alternate = formFiber.alternate;
+
+    if (alternate !== null) {
+      alternate.memoizedState = stateHook;
+    }
+  } else {
+    // This fiber was already upgraded to be stateful.
+    const stateHook = formFiber.memoizedState;
+    queue = stateHook.queue;
+  }
+
+  startTransition(formFiber, queue, pendingState, NotPendingTransition, // TODO: We can avoid this extra wrapper, somehow. Figure out layering
+  // once more of this function is implemented.
+  () => callback(formData));
+}
+
+function mountTransition() {
+  const stateHook = mountStateImpl(false); // The `start` method never changes.
+
+  const start = startTransition.bind(null, currentlyRenderingFiber$1, stateHook.queue, true, false);
+  const hook = mountWorkInProgressHook();
+  hook.memoizedState = start;
+  return [false, start];
+}
+
+function updateTransition() {
+  const _updateState = updateState(),
+        booleanOrThenable = _updateState[0];
+
+  const hook = updateWorkInProgressHook();
+  const start = hook.memoizedState;
+  const isPending = typeof booleanOrThenable === 'boolean' ? booleanOrThenable : // This will suspend until the async action scope has finished.
+  useThenable(booleanOrThenable);
+  return [isPending, start];
+}
+
+function rerenderTransition() {
+  const _rerenderState = rerenderState(),
+        booleanOrThenable = _rerenderState[0];
+
+  const hook = updateWorkInProgressHook();
+  const start = hook.memoizedState;
+  const isPending = typeof booleanOrThenable === 'boolean' ? booleanOrThenable : // This will suspend until the async action scope has finished.
+  useThenable(booleanOrThenable);
+  return [isPending, start];
+}
+
+function useHostTransitionStatus() {
+
+  const status = readContext(HostTransitionContext);
+  return status !== null ? status : NotPendingTransition;
+}
+
+function mountId() {
+  const hook = mountWorkInProgressHook();
+  const root = getWorkInProgressRoot(); // TODO: In Fizz, id generation is specific to each server config. Maybe we
+  // should do this in Fiber, too? Deferring this decision for now because
+  // there's no other place to store the prefix except for an internal field on
+  // the public createRoot object, which the fiber tree does not currently have
+  // a reference to.
+
+  const identifierPrefix = root.identifierPrefix;
+  let id;
+
+  if (getIsHydrating()) {
+    const treeId = getTreeId(); // Use a captial R prefix for server-generated ids.
+
+    id = ':' + identifierPrefix + 'R' + treeId; // Unless this is the first id at this level, append a number at the end
+    // that represents the position of this useId hook among all the useId
+    // hooks for this fiber.
+
+    const localId = localIdCounter++;
+
+    if (localId > 0) {
+      id += 'H' + localId.toString(32);
+    }
+
+    id += ':';
+  } else {
+    // Use a lowercase r prefix for client-generated ids.
+    const globalClientId = globalClientIdCounter++;
+    id = ':' + identifierPrefix + 'r' + globalClientId.toString(32) + ':';
+  }
+
+  hook.memoizedState = id;
+  return id;
+}
+
+function updateId() {
+  const hook = updateWorkInProgressHook();
+  const id = hook.memoizedState;
+  return id;
+}
+
+function mountRefresh() {
+  const hook = mountWorkInProgressHook();
+  const refresh = hook.memoizedState = refreshCache.bind(null, currentlyRenderingFiber$1);
+  return refresh;
+}
+
+function updateRefresh() {
+  const hook = updateWorkInProgressHook();
+  return hook.memoizedState;
+}
+
+function refreshCache(fiber, seedKey, seedValue) {
+  // TODO: Consider warning if the refresh is at discrete priority, or if we
+  // otherwise suspect that it wasn't batched properly.
+
+
+  let provider = fiber.return;
+
+  while (provider !== null) {
+    switch (provider.tag) {
+      case CacheComponent:
+      case HostRoot:
+        {
+          // Schedule an update on the cache boundary to trigger a refresh.
+          const lane = requestUpdateLane(provider);
+          const refreshUpdate = createUpdate(lane);
+          const root = enqueueUpdate(provider, refreshUpdate, lane);
+
+          if (root !== null) {
+            scheduleUpdateOnFiber(root, provider, lane);
+            entangleTransitions(root, provider, lane);
+          } // TODO: If a refresh never commits, the new cache created here must be
+          // released. A simple case is start refreshing a cache boundary, but then
+          // unmount that boundary before the refresh completes.
+
+
+          const seededCache = createCache();
+
+          if (seedKey !== null && seedKey !== undefined && root !== null) {
+            {
+              // Seed the cache with the value passed by the caller. This could be
+              // from a server mutation, or it could be a streaming response.
+              seededCache.data.set(seedKey, seedValue);
+            }
+          }
+
+          const payload = {
+            cache: seededCache
+          };
+          refreshUpdate.payload = payload;
+          return;
+        }
+    }
+
+    provider = provider.return;
+  } // TODO: Warn if unmounted?
+
+}
+
+function dispatchReducerAction(fiber, queue, action) {
+
+  const lane = requestUpdateLane(fiber);
+  const update = {
+    lane,
+    revertLane: NoLane,
+    action,
+    hasEagerState: false,
+    eagerState: null,
+    next: null
+  };
+
+  if (isRenderPhaseUpdate(fiber)) {
+    enqueueRenderPhaseUpdate(queue, update);
+  } else {
+    const root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitionUpdate(root, queue, lane);
+    }
+  }
+
+  markUpdateInDevTools(fiber, lane);
+}
+
+function dispatchSetState(fiber, queue, action) {
+
+  const lane = requestUpdateLane(fiber);
+  const update = {
+    lane,
+    revertLane: NoLane,
+    action,
+    hasEagerState: false,
+    eagerState: null,
+    next: null
+  };
+
+  if (isRenderPhaseUpdate(fiber)) {
+    enqueueRenderPhaseUpdate(queue, update);
+  } else {
+    const alternate = fiber.alternate;
+
+    if (fiber.lanes === NoLanes && (alternate === null || alternate.lanes === NoLanes)) {
+      // The queue is currently empty, which means we can eagerly compute the
+      // next state before entering the render phase. If the new state is the
+      // same as the current state, we may be able to bail out entirely.
+      const lastRenderedReducer = queue.lastRenderedReducer;
+
+      if (lastRenderedReducer !== null) {
+
+        try {
+          const currentState = queue.lastRenderedState;
+          const eagerState = lastRenderedReducer(currentState, action); // Stash the eagerly computed state, and the reducer used to compute
+          // it, on the update object. If the reducer hasn't changed by the
+          // time we enter the render phase, then the eager state can be used
+          // without calling the reducer again.
+
+          update.hasEagerState = true;
+          update.eagerState = eagerState;
+
+          if (objectIs(eagerState, currentState)) {
+            // Fast path. We can bail out without scheduling React to re-render.
+            // It's still possible that we'll need to rebase this update later,
+            // if the component re-renders for a different reason and by that
+            // time the reducer has changed.
+            // TODO: Do we still need to entangle transitions in this case?
+            enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update);
+            return;
+          }
+        } catch (error) {// Suppress the error. It will throw again in the render phase.
+        } finally {
+        }
+      }
+    }
+
+    const root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitionUpdate(root, queue, lane);
+    }
+  }
+
+  markUpdateInDevTools(fiber, lane);
+}
+
+function dispatchOptimisticSetState(fiber, throwIfDuringRender, queue, action) {
+
+  const update = {
+    // An optimistic update commits synchronously.
+    lane: SyncLane,
+    // After committing, the optimistic update is "reverted" using the same
+    // lane as the transition it's associated with.
+    revertLane: requestTransitionLane(),
+    action,
+    hasEagerState: false,
+    eagerState: null,
+    next: null
+  };
+
+  if (isRenderPhaseUpdate(fiber)) {
+    // When calling startTransition during render, this warns instead of
+    // throwing because throwing would be a breaking change. setOptimisticState
+    // is a new API so it's OK to throw.
+    if (throwIfDuringRender) {
+      throw Error(formatProdErrorMessage(479));
+    }
+  } else {
+    const root = enqueueConcurrentHookUpdate(fiber, queue, update, SyncLane);
+
+    if (root !== null) {
+      // NOTE: The optimistic update implementation assumes that the transition
+      // will never be attempted before the optimistic update. This currently
+      // holds because the optimistic update is always synchronous. If we ever
+      // change that, we'll need to account for this.
+      scheduleUpdateOnFiber(root, fiber, SyncLane); // Optimistic updates are always synchronous, so we don't need to call
+      // entangleTransitionUpdate here.
+    }
+  }
+
+  markUpdateInDevTools(fiber, SyncLane);
+}
+
+function isRenderPhaseUpdate(fiber) {
+  const alternate = fiber.alternate;
+  return fiber === currentlyRenderingFiber$1 || alternate !== null && alternate === currentlyRenderingFiber$1;
+}
+
+function enqueueRenderPhaseUpdate(queue, update) {
+  // This is a render phase update. Stash it in a lazily-created map of
+  // queue -> linked list of updates. After this render pass, we'll restart
+  // and apply the stashed updates on top of the work-in-progress hook.
+  didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate = true;
+  const pending = queue.pending;
+
+  if (pending === null) {
+    // This is the first update. Create a circular list.
+    update.next = update;
+  } else {
+    update.next = pending.next;
+    pending.next = update;
+  }
+
+  queue.pending = update;
+} // TODO: Move to ReactFiberConcurrentUpdates?
+
+
+function entangleTransitionUpdate(root, queue, lane) {
+  if (isTransitionLane(lane)) {
+    let queueLanes = queue.lanes; // If any entangled lanes are no longer pending on the root, then they
+    // must have finished. We can remove them from the shared queue, which
+    // represents a superset of the actually pending lanes. In some cases we
+    // may entangle more than we need to, but that's OK. In fact it's worse if
+    // we *don't* entangle when we should.
+
+    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.
+
+    const newQueueLanes = mergeLanes(queueLanes, lane);
+    queue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if
+    // the lane finished since the last time we entangled it. So we need to
+    // entangle it again, just to be sure.
+
+    markRootEntangled(root, newQueueLanes);
+  }
+}
+
+function markUpdateInDevTools(fiber, lane, action) {
+
+  {
+    markStateUpdateScheduled(fiber, lane);
+  }
+}
+
+const ContextOnlyDispatcher = {
+  readContext,
+  use,
+  useCallback: throwInvalidHookError,
+  useContext: throwInvalidHookError,
+  useEffect: throwInvalidHookError,
+  useImperativeHandle: throwInvalidHookError,
+  useInsertionEffect: throwInvalidHookError,
+  useLayoutEffect: throwInvalidHookError,
+  useMemo: throwInvalidHookError,
+  useReducer: throwInvalidHookError,
+  useRef: throwInvalidHookError,
+  useState: throwInvalidHookError,
+  useDebugValue: throwInvalidHookError,
+  useDeferredValue: throwInvalidHookError,
+  useTransition: throwInvalidHookError,
+  useSyncExternalStore: throwInvalidHookError,
+  useId: throwInvalidHookError
+};
+
+{
+  ContextOnlyDispatcher.useCacheRefresh = throwInvalidHookError;
+}
+
+{
+  ContextOnlyDispatcher.useMemoCache = throwInvalidHookError;
+}
+
+{
+  ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
+}
+
+{
+  ContextOnlyDispatcher.useHostTransitionStatus = throwInvalidHookError;
+  ContextOnlyDispatcher.useFormState = throwInvalidHookError;
+}
+
+{
+  ContextOnlyDispatcher.useOptimistic = throwInvalidHookError;
+}
+
+const HooksDispatcherOnMount = {
+  readContext,
+  use,
+  useCallback: mountCallback,
+  useContext: readContext,
+  useEffect: mountEffect,
+  useImperativeHandle: mountImperativeHandle,
+  useLayoutEffect: mountLayoutEffect,
+  useInsertionEffect: mountInsertionEffect,
+  useMemo: mountMemo,
+  useReducer: mountReducer,
+  useRef: mountRef,
+  useState: mountState,
+  useDebugValue: mountDebugValue,
+  useDeferredValue: mountDeferredValue,
+  useTransition: mountTransition,
+  useSyncExternalStore: mountSyncExternalStore,
+  useId: mountId
+};
+
+{
+  HooksDispatcherOnMount.useCacheRefresh = mountRefresh;
+}
+
+{
+  HooksDispatcherOnMount.useMemoCache = useMemoCache;
+}
+
+{
+  HooksDispatcherOnMount.useEffectEvent = mountEvent;
+}
+
+{
+  HooksDispatcherOnMount.useHostTransitionStatus = useHostTransitionStatus;
+  HooksDispatcherOnMount.useFormState = mountFormState;
+}
+
+{
+  HooksDispatcherOnMount.useOptimistic = mountOptimistic;
+}
+
+const HooksDispatcherOnUpdate = {
+  readContext,
+  use,
+  useCallback: updateCallback,
+  useContext: readContext,
+  useEffect: updateEffect,
+  useImperativeHandle: updateImperativeHandle,
+  useInsertionEffect: updateInsertionEffect,
+  useLayoutEffect: updateLayoutEffect,
+  useMemo: updateMemo,
+  useReducer: updateReducer,
+  useRef: updateRef,
+  useState: updateState,
+  useDebugValue: updateDebugValue,
+  useDeferredValue: updateDeferredValue,
+  useTransition: updateTransition,
+  useSyncExternalStore: updateSyncExternalStore,
+  useId: updateId
+};
+
+{
+  HooksDispatcherOnUpdate.useCacheRefresh = updateRefresh;
+}
+
+{
+  HooksDispatcherOnUpdate.useMemoCache = useMemoCache;
+}
+
+{
+  HooksDispatcherOnUpdate.useEffectEvent = updateEvent;
+}
+
+{
+  HooksDispatcherOnUpdate.useHostTransitionStatus = useHostTransitionStatus;
+  HooksDispatcherOnUpdate.useFormState = updateFormState;
+}
+
+{
+  HooksDispatcherOnUpdate.useOptimistic = updateOptimistic;
+}
+
+const HooksDispatcherOnRerender = {
+  readContext,
+  use,
+  useCallback: updateCallback,
+  useContext: readContext,
+  useEffect: updateEffect,
+  useImperativeHandle: updateImperativeHandle,
+  useInsertionEffect: updateInsertionEffect,
+  useLayoutEffect: updateLayoutEffect,
+  useMemo: updateMemo,
+  useReducer: rerenderReducer,
+  useRef: updateRef,
+  useState: rerenderState,
+  useDebugValue: updateDebugValue,
+  useDeferredValue: rerenderDeferredValue,
+  useTransition: rerenderTransition,
+  useSyncExternalStore: updateSyncExternalStore,
+  useId: updateId
+};
+
+{
+  HooksDispatcherOnRerender.useCacheRefresh = updateRefresh;
+}
+
+{
+  HooksDispatcherOnRerender.useMemoCache = useMemoCache;
+}
+
+{
+  HooksDispatcherOnRerender.useEffectEvent = updateEvent;
+}
+
+{
+  HooksDispatcherOnRerender.useHostTransitionStatus = useHostTransitionStatus;
+  HooksDispatcherOnRerender.useFormState = rerenderFormState;
+}
+
+{
+  HooksDispatcherOnRerender.useOptimistic = rerenderOptimistic;
+}
+
+const now = Scheduler.unstable_now;
+let commitTime = 0;
+let layoutEffectStartTime = -1;
+let profilerStartTime = -1;
+let 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.
+ */
+
+let currentUpdateIsNested = false;
+let nestedUpdateScheduled = false;
+
+function isCurrentUpdateNested() {
+  return currentUpdateIsNested;
+}
+
+function markNestedUpdateScheduled() {
+  {
+    nestedUpdateScheduled = true;
+  }
+}
+
+function resetNestedUpdateFlag() {
+  {
+    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) {
+    const elapsedTime = now() - profilerStartTime;
+    fiber.actualDuration += elapsedTime;
+
+    if (overrideBaseTime) {
+      fiber.selfBaseDuration = elapsedTime;
+    }
+
+    profilerStartTime = -1;
+  }
+}
+
+function recordLayoutEffectDuration(fiber) {
+
+  if (layoutEffectStartTime >= 0) {
+    const elapsedTime = now() - layoutEffectStartTime;
+    layoutEffectStartTime = -1; // Store duration on the next nearest Profiler ancestor
+    // Or the root (for the DevTools Profiler to read)
+
+    let parentFiber = fiber.return;
+
+    while (parentFiber !== null) {
+      switch (parentFiber.tag) {
+        case HostRoot:
+          const root = parentFiber.stateNode;
+          root.effectDuration += elapsedTime;
+          return;
+
+        case Profiler:
+          const parentStateNode = parentFiber.stateNode;
+          parentStateNode.effectDuration += elapsedTime;
+          return;
+      }
+
+      parentFiber = parentFiber.return;
+    }
+  }
+}
+
+function recordPassiveEffectDuration(fiber) {
+
+  if (passiveEffectStartTime >= 0) {
+    const elapsedTime = now() - passiveEffectStartTime;
+    passiveEffectStartTime = -1; // Store duration on the next nearest Profiler ancestor
+    // Or the root (for the DevTools Profiler to read)
+
+    let parentFiber = fiber.return;
+
+    while (parentFiber !== null) {
+      switch (parentFiber.tag) {
+        case HostRoot:
+          const root = parentFiber.stateNode;
+
+          if (root !== null) {
+            root.passiveEffectDuration += elapsedTime;
+          }
+
+          return;
+
+        case Profiler:
+          const 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.
+  let child = fiber.child;
+
+  while (child) {
+    // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+    fiber.actualDuration += child.actualDuration;
+    child = child.sibling;
+  }
+}
+
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    // Resolve default props. Taken from ReactElement
+    const props = assign({}, baseProps);
+    const defaultProps = Component.defaultProps;
+
+    for (const propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+
+    return props;
+  }
+
+  return baseProps;
+}
+
+function applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, nextProps) {
+  const prevState = workInProgress.memoizedState;
+  let partialState = getDerivedStateFromProps(nextProps, prevState);
+
+
+  const memoizedState = partialState === null || partialState === undefined ? prevState : assign({}, prevState, partialState);
+  workInProgress.memoizedState = memoizedState; // Once the update queue is empty, persist the derived state onto the
+  // base state.
+
+  if (workInProgress.lanes === NoLanes) {
+    // Queue is always non-null for classes
+    const updateQueue = workInProgress.updateQueue;
+    updateQueue.baseState = memoizedState;
+  }
+}
+
+const classComponentUpdater = {
+  isMounted,
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueSetState(inst, payload, callback) {
+    const fiber = get(inst);
+    const lane = requestUpdateLane(fiber);
+    const update = createUpdate(lane);
+    update.payload = payload;
+
+    if (callback !== undefined && callback !== null) {
+
+      update.callback = callback;
+    }
+
+    const root = enqueueUpdate(fiber, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitions(root, fiber, lane);
+    }
+
+    {
+      markStateUpdateScheduled(fiber, lane);
+    }
+  },
+
+  enqueueReplaceState(inst, payload, callback) {
+    const fiber = get(inst);
+    const lane = requestUpdateLane(fiber);
+    const update = createUpdate(lane);
+    update.tag = ReplaceState;
+    update.payload = payload;
+
+    if (callback !== undefined && callback !== null) {
+
+      update.callback = callback;
+    }
+
+    const root = enqueueUpdate(fiber, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitions(root, fiber, lane);
+    }
+
+    {
+      markStateUpdateScheduled(fiber, lane);
+    }
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueForceUpdate(inst, callback) {
+    const fiber = get(inst);
+    const lane = requestUpdateLane(fiber);
+    const update = createUpdate(lane);
+    update.tag = ForceUpdate;
+
+    if (callback !== undefined && callback !== null) {
+
+      update.callback = callback;
+    }
+
+    const root = enqueueUpdate(fiber, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitions(root, fiber, lane);
+    }
+
+    {
+      markForceUpdateScheduled(fiber, lane);
+    }
+  }
+
+};
+
+function checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {
+  const instance = workInProgress.stateNode;
+
+  if (typeof instance.shouldComponentUpdate === 'function') {
+    let shouldUpdate = instance.shouldComponentUpdate(newProps, newState, nextContext);
+
+    return shouldUpdate;
+  }
+
+  if (ctor.prototype && ctor.prototype.isPureReactComponent) {
+    return !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState);
+  }
+
+  return true;
+}
+
+function adoptClassInstance(workInProgress, instance) {
+  instance.updater = classComponentUpdater;
+  workInProgress.stateNode = instance; // The instance needs access to the fiber so that it can schedule updates
+
+  set(instance, workInProgress);
+}
+
+function constructClassInstance(workInProgress, ctor, props) {
+  let isLegacyContextConsumer = false;
+  let unmaskedContext = emptyContextObject;
+  let context = emptyContextObject;
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    context = readContext(contextType);
+  } else {
+    unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    const contextTypes = ctor.contextTypes;
+    isLegacyContextConsumer = contextTypes !== null && contextTypes !== undefined;
+    context = isLegacyContextConsumer ? getMaskedContext(workInProgress, unmaskedContext) : emptyContextObject;
+  }
+
+  let instance = new ctor(props, context); // Instantiate twice to help detect side-effects.
+
+  workInProgress.memoizedState = instance.state !== null && instance.state !== undefined ? instance.state : null;
+  adoptClassInstance(workInProgress, instance);
+  // ReactFiberContext usually updates this cache but can't for newly-created instances.
+
+
+  if (isLegacyContextConsumer) {
+    cacheContext(workInProgress, unmaskedContext, context);
+  }
+
+  return instance;
+}
+
+function callComponentWillMount(workInProgress, instance) {
+  const oldState = instance.state;
+
+  if (typeof instance.componentWillMount === 'function') {
+    instance.componentWillMount();
+  }
+
+  if (typeof instance.UNSAFE_componentWillMount === 'function') {
+    instance.UNSAFE_componentWillMount();
+  }
+
+  if (oldState !== instance.state) {
+
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+}
+
+function callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {
+  const oldState = instance.state;
+
+  if (typeof instance.componentWillReceiveProps === 'function') {
+    instance.componentWillReceiveProps(newProps, nextContext);
+  }
+
+  if (typeof instance.UNSAFE_componentWillReceiveProps === 'function') {
+    instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+  }
+
+  if (instance.state !== oldState) {
+
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+} // Invokes the mount life-cycles on a previously never rendered instance.
+
+
+function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+
+  const instance = workInProgress.stateNode;
+  instance.props = newProps;
+  instance.state = workInProgress.memoizedState;
+  instance.refs = {};
+  initializeUpdateQueue(workInProgress);
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    instance.context = readContext(contextType);
+  } else {
+    const unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    instance.context = getMaskedContext(workInProgress, unmaskedContext);
+  }
+
+  instance.state = workInProgress.memoizedState;
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+    instance.state = workInProgress.memoizedState;
+  } // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+
+  if (typeof ctor.getDerivedStateFromProps !== 'function' && typeof instance.getSnapshotBeforeUpdate !== 'function' && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
+    callComponentWillMount(workInProgress, instance); // If we had additional state updates during this life-cycle, let's
+    // process them now.
+
+    processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+    instance.state = workInProgress.memoizedState;
+  }
+
+  if (typeof instance.componentDidMount === 'function') {
+    workInProgress.flags |= Update | LayoutStatic;
+  }
+}
+
+function resumeMountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+  const instance = workInProgress.stateNode;
+  const oldProps = workInProgress.memoizedProps;
+  instance.props = oldProps;
+  const oldContext = instance.context;
+  const contextType = ctor.contextType;
+  let nextContext = emptyContextObject;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    nextContext = readContext(contextType);
+  } else {
+    const nextLegacyUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    nextContext = getMaskedContext(workInProgress, nextLegacyUnmaskedContext);
+  }
+
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+  const hasNewLifecycles = typeof getDerivedStateFromProps === 'function' || typeof instance.getSnapshotBeforeUpdate === 'function'; // Note: During these life-cycles, instance.props/instance.state are what
+  // ever the previously attempted to render - not the "current". However,
+  // during componentDidUpdate we pass the "current" props.
+  // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+  if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === 'function' || typeof instance.componentWillReceiveProps === 'function')) {
+    if (oldProps !== newProps || oldContext !== nextContext) {
+      callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
+    }
+  }
+
+  resetHasForceUpdateBeforeProcessing();
+  const oldState = workInProgress.memoizedState;
+  let newState = instance.state = oldState;
+  processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+  newState = workInProgress.memoizedState;
+
+  if (oldProps === newProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing()) {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidMount === 'function') {
+      workInProgress.flags |= Update | LayoutStatic;
+    }
+
+    return false;
+  }
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+    newState = workInProgress.memoizedState;
+  }
+
+  const shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext);
+
+  if (shouldUpdate) {
+    // In order to support react-lifecycles-compat polyfilled components,
+    // Unsafe lifecycles should not be invoked for components using the new APIs.
+    if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
+      if (typeof instance.componentWillMount === 'function') {
+        instance.componentWillMount();
+      }
+
+      if (typeof instance.UNSAFE_componentWillMount === 'function') {
+        instance.UNSAFE_componentWillMount();
+      }
+    }
+
+    if (typeof instance.componentDidMount === 'function') {
+      workInProgress.flags |= Update | LayoutStatic;
+    }
+  } else {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidMount === 'function') {
+      workInProgress.flags |= Update | LayoutStatic;
+    }
+    // memoized state to indicate that this work can be reused.
+
+
+    workInProgress.memoizedProps = newProps;
+    workInProgress.memoizedState = newState;
+  } // Update the existing instance's state, props, and context pointers even
+  // if shouldComponentUpdate returns false.
+
+
+  instance.props = newProps;
+  instance.state = newState;
+  instance.context = nextContext;
+  return shouldUpdate;
+} // Invokes the update life-cycles and returns false if it shouldn't rerender.
+
+
+function updateClassInstance(current, workInProgress, ctor, newProps, renderLanes) {
+  const instance = workInProgress.stateNode;
+  cloneUpdateQueue(current, workInProgress);
+  const unresolvedOldProps = workInProgress.memoizedProps;
+  const oldProps = workInProgress.type === workInProgress.elementType ? unresolvedOldProps : resolveDefaultProps(workInProgress.type, unresolvedOldProps);
+  instance.props = oldProps;
+  const unresolvedNewProps = workInProgress.pendingProps;
+  const oldContext = instance.context;
+  const contextType = ctor.contextType;
+  let nextContext = emptyContextObject;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    nextContext = readContext(contextType);
+  } else {
+    const nextUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    nextContext = getMaskedContext(workInProgress, nextUnmaskedContext);
+  }
+
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+  const hasNewLifecycles = typeof getDerivedStateFromProps === 'function' || typeof instance.getSnapshotBeforeUpdate === 'function'; // Note: During these life-cycles, instance.props/instance.state are what
+  // ever the previously attempted to render - not the "current". However,
+  // during componentDidUpdate we pass the "current" props.
+  // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+  if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === 'function' || typeof instance.componentWillReceiveProps === 'function')) {
+    if (unresolvedOldProps !== unresolvedNewProps || oldContext !== nextContext) {
+      callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
+    }
+  }
+
+  resetHasForceUpdateBeforeProcessing();
+  const oldState = workInProgress.memoizedState;
+  let newState = instance.state = oldState;
+  processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+  newState = workInProgress.memoizedState;
+
+  if (unresolvedOldProps === unresolvedNewProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing() && !(enableLazyContextPropagation   )) {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidUpdate === 'function') {
+      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+        workInProgress.flags |= Update;
+      }
+    }
+
+    if (typeof instance.getSnapshotBeforeUpdate === 'function') {
+      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+        workInProgress.flags |= Snapshot;
+      }
+    }
+
+    return false;
+  }
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+    newState = workInProgress.memoizedState;
+  }
+
+  const shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) || // TODO: In some cases, we'll end up checking if context has changed twice,
+  // both before and after `shouldComponentUpdate` has been called. Not ideal,
+  // but I'm loath to refactor this function. This only happens for memoized
+  // components so it's not that common.
+  enableLazyContextPropagation   ;
+
+  if (shouldUpdate) {
+    // In order to support react-lifecycles-compat polyfilled components,
+    // Unsafe lifecycles should not be invoked for components using the new APIs.
+    if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillUpdate === 'function' || typeof instance.componentWillUpdate === 'function')) {
+      if (typeof instance.componentWillUpdate === 'function') {
+        instance.componentWillUpdate(newProps, newState, nextContext);
+      }
+
+      if (typeof instance.UNSAFE_componentWillUpdate === 'function') {
+        instance.UNSAFE_componentWillUpdate(newProps, newState, nextContext);
+      }
+    }
+
+    if (typeof instance.componentDidUpdate === 'function') {
+      workInProgress.flags |= Update;
+    }
+
+    if (typeof instance.getSnapshotBeforeUpdate === 'function') {
+      workInProgress.flags |= Snapshot;
+    }
+  } else {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidUpdate === 'function') {
+      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+        workInProgress.flags |= Update;
+      }
+    }
+
+    if (typeof instance.getSnapshotBeforeUpdate === 'function') {
+      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+        workInProgress.flags |= Snapshot;
+      }
+    } // If shouldComponentUpdate returned false, we should still update the
+    // memoized props/state to indicate that this work can be reused.
+
+
+    workInProgress.memoizedProps = newProps;
+    workInProgress.memoizedState = newState;
+  } // Update the existing instance's state, props, and context pointers even
+  // if shouldComponentUpdate returns false.
+
+
+  instance.props = newProps;
+  instance.state = newState;
+  instance.context = nextContext;
+  return shouldUpdate;
+}
+
+function createCapturedValueAtFiber(value, source) {
+  // If the value is an error, call this function immediately after it is thrown
+  // so the stack is accurate.
+  return {
+    value,
+    source,
+    stack: getStackByFiberInDevAndProd(source),
+    digest: null
+  };
+}
+function createCapturedValue(value, digest, stack) {
+  return {
+    value,
+    source: null,
+    stack: stack != null ? stack : null,
+    digest: digest != null ? digest : null
+  };
+}
+
+// This module is forked in different environments.
+// By default, return `true` to log errors to the console.
+// Forks can return `false` if this isn't desirable.
+function showErrorDialog(boundary, errorInfo) {
+  return true;
+}
+
+function logCapturedError(boundary, errorInfo) {
+  try {
+    const logError = showErrorDialog(boundary, errorInfo); // Allow injected showErrorDialog() to prevent default console.error logging.
+    // This enables renderers like ReactNative to better manage redbox behavior.
+
+    if (logError === false) ;
+
+    const error = errorInfo.value;
+
+    if (false) ; else {
+      // In production, we print the error directly.
+      // This will include the message, the JS stack, and anything the browser wants to show.
+      // We pass the error object instead of custom message so that the browser displays the error natively.
+      console['error'](error); // Don't transform to our wrapper
+    }
+  } catch (e) {
+    // This method must not throw, or React internal state will get messed up.
+    // If console.error is overridden, or logCapturedError() shows a dialog that throws,
+    // we want to report this error outside of the normal stack as a last resort.
+    // https://github.com/facebook/react/issues/13188
+    setTimeout(() => {
+      throw e;
+    });
+  }
+}
+
+function createRootErrorUpdate(fiber, errorInfo, lane) {
+  const update = createUpdate(lane); // Unmount the root by rendering null.
+
+  update.tag = CaptureUpdate; // Caution: React DevTools currently depends on this property
+  // being called "element".
+
+  update.payload = {
+    element: null
+  };
+  const error = errorInfo.value;
+
+  update.callback = () => {
+    onUncaughtError(error);
+    logCapturedError(fiber, errorInfo);
+  };
+
+  return update;
+}
+
+function createClassErrorUpdate(fiber, errorInfo, lane) {
+  const update = createUpdate(lane);
+  update.tag = CaptureUpdate;
+  const getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+
+  if (typeof getDerivedStateFromError === 'function') {
+    const error = errorInfo.value;
+
+    update.payload = () => {
+      return getDerivedStateFromError(error);
+    };
+
+    update.callback = () => {
+
+      logCapturedError(fiber, errorInfo);
+    };
+  }
+
+  const inst = fiber.stateNode;
+
+  if (inst !== null && typeof inst.componentDidCatch === 'function') {
+    // $FlowFixMe[missing-this-annot]
+    update.callback = function callback() {
+
+      logCapturedError(fiber, errorInfo);
+
+      if (typeof getDerivedStateFromError !== 'function') {
+        // To preserve the preexisting retry behavior of error boundaries,
+        // we keep track of which ones already failed during this batch.
+        // This gets reset before we yield back to the browser.
+        // TODO: Warn in strict mode if getDerivedStateFromError is
+        // not defined.
+        markLegacyErrorBoundaryAsFailed(this);
+      }
+
+      const error = errorInfo.value;
+      const stack = errorInfo.stack;
+      this.componentDidCatch(error, {
+        componentStack: stack !== null ? stack : ''
+      });
+    };
+  }
+
+  return update;
+}
+
+function resetSuspendedComponent(sourceFiber, rootRenderLanes) {
+  // A legacy mode Suspense quirk, only relevant to hook components.
+
+
+  const tag = sourceFiber.tag;
+
+  if ((sourceFiber.mode & ConcurrentMode) === NoMode && (tag === FunctionComponent || tag === ForwardRef || tag === SimpleMemoComponent)) {
+    const currentSource = sourceFiber.alternate;
+
+    if (currentSource) {
+      sourceFiber.updateQueue = currentSource.updateQueue;
+      sourceFiber.memoizedState = currentSource.memoizedState;
+      sourceFiber.lanes = currentSource.lanes;
+    } else {
+      sourceFiber.updateQueue = null;
+      sourceFiber.memoizedState = null;
+    }
+  }
+}
+
+function markSuspenseBoundaryShouldCapture(suspenseBoundary, returnFiber, sourceFiber, root, rootRenderLanes) {
+  // This marks a Suspense boundary so that when we're unwinding the stack,
+  // it captures the suspended "exception" and does a second (fallback) pass.
+  if ((suspenseBoundary.mode & ConcurrentMode) === NoMode) {
+    // Legacy Mode Suspense
+    //
+    // If the boundary is in legacy mode, we should *not*
+    // suspend the commit. Pretend as if the suspended component rendered
+    // null and keep rendering. When the Suspense boundary completes,
+    // we'll do a second pass to render the fallback.
+    if (suspenseBoundary === returnFiber) {
+      // Special case where we suspended while reconciling the children of
+      // a Suspense boundary's inner Offscreen wrapper fiber. This happens
+      // when a React.lazy component is a direct child of a
+      // Suspense boundary.
+      //
+      // Suspense boundaries are implemented as multiple fibers, but they
+      // are a single conceptual unit. The legacy mode behavior where we
+      // pretend the suspended fiber committed as `null` won't work,
+      // because in this case the "suspended" fiber is the inner
+      // Offscreen wrapper.
+      //
+      // Because the contents of the boundary haven't started rendering
+      // yet (i.e. nothing in the tree has partially rendered) we can
+      // switch to the regular, concurrent mode behavior: mark the
+      // boundary with ShouldCapture and enter the unwind phase.
+      suspenseBoundary.flags |= ShouldCapture;
+    } else {
+      suspenseBoundary.flags |= DidCapture;
+      sourceFiber.flags |= ForceUpdateForLegacySuspense; // We're going to commit this fiber even though it didn't complete.
+      // But we shouldn't call any lifecycle methods or callbacks. Remove
+      // all lifecycle effect tags.
+
+      sourceFiber.flags &= ~(LifecycleEffectMask | Incomplete);
+
+      if (sourceFiber.tag === ClassComponent) {
+        const currentSourceFiber = sourceFiber.alternate;
+
+        if (currentSourceFiber === null) {
+          // This is a new mount. Change the tag so it's not mistaken for a
+          // completed class component. For example, we should not call
+          // componentWillUnmount if it is deleted.
+          sourceFiber.tag = IncompleteClassComponent;
+        } else {
+          // When we try rendering again, we should not reuse the current fiber,
+          // since it's known to be in an inconsistent state. Use a force update to
+          // prevent a bail out.
+          const update = createUpdate(SyncLane);
+          update.tag = ForceUpdate;
+          enqueueUpdate(sourceFiber, update, SyncLane);
+        }
+      } // The source fiber did not complete. Mark it with Sync priority to
+      // indicate that it still has pending work.
+
+
+      sourceFiber.lanes = mergeLanes(sourceFiber.lanes, SyncLane);
+    }
+
+    return suspenseBoundary;
+  } // Confirmed that the boundary is in a concurrent mode tree. Continue
+  // with the normal suspend path.
+  //
+  // After this we'll use a set of heuristics to determine whether this
+  // render pass will run to completion or restart or "suspend" the commit.
+  // The actual logic for this is spread out in different places.
+  //
+  // This first principle is that if we're going to suspend when we complete
+  // a root, then we should also restart if we get an update or ping that
+  // might unsuspend it, and vice versa. The only reason to suspend is
+  // because you think you might want to restart before committing. However,
+  // it doesn't make sense to restart only while in the period we're suspended.
+  //
+  // Restarting too aggressively is also not good because it starves out any
+  // intermediate loading state. So we use heuristics to determine when.
+  // Suspense Heuristics
+  //
+  // If nothing threw a Promise or all the same fallbacks are already showing,
+  // then don't suspend/restart.
+  //
+  // If this is an initial render of a new tree of Suspense boundaries and
+  // those trigger a fallback, then don't suspend/restart. We want to ensure
+  // that we can show the initial loading state as quickly as possible.
+  //
+  // If we hit a "Delayed" case, such as when we'd switch from content back into
+  // a fallback, then we should always suspend/restart. Transitions apply
+  // to this case. If none is defined, JND is used instead.
+  //
+  // If we're already showing a fallback and it gets "retried", allowing us to show
+  // another level, but there's still an inner boundary that would show a fallback,
+  // then we suspend/restart for 500ms since the last time we showed a fallback
+  // anywhere in the tree. This effectively throttles progressive loading into a
+  // consistent train of commits. This also gives us an opportunity to restart to
+  // get to the completed state slightly earlier.
+  //
+  // If there's ambiguity due to batching it's resolved in preference of:
+  // 1) "delayed", 2) "initial render", 3) "retry".
+  //
+  // We want to ensure that a "busy" state doesn't get force committed. We want to
+  // ensure that new initial loading states can commit as soon as possible.
+
+
+  suspenseBoundary.flags |= ShouldCapture; // TODO: I think we can remove this, since we now use `DidCapture` in
+  // the begin phase to prevent an early bailout.
+
+  suspenseBoundary.lanes = rootRenderLanes;
+  return suspenseBoundary;
+}
+
+function throwException(root, returnFiber, sourceFiber, value, rootRenderLanes) {
+  // The source fiber did not complete.
+  sourceFiber.flags |= Incomplete;
+
+  {
+    if (isDevToolsPresent) {
+      // If we have pending work still, restore the original updaters
+      restorePendingUpdaters(root, rootRenderLanes);
+    }
+  }
+
+  if (value !== null && typeof value === 'object') {
+    if (value.$$typeof === REACT_POSTPONE_TYPE) {
+      // Act as if this is an infinitely suspending promise.
+      value = {
+        then: function () {}
+      };
+    }
+
+    if (typeof value.then === 'function') {
+      // This is a wakeable. The component suspended.
+      const wakeable = value;
+      resetSuspendedComponent(sourceFiber);
+
+
+      const suspenseBoundary = getSuspenseHandler();
+
+      if (suspenseBoundary !== null) {
+        switch (suspenseBoundary.tag) {
+          case SuspenseComponent:
+            {
+              // If this suspense boundary is not already showing a fallback, mark
+              // the in-progress render as suspended. We try to perform this logic
+              // as soon as soon as possible during the render phase, so the work
+              // loop can know things like whether it's OK to switch to other tasks,
+              // or whether it can wait for data to resolve before continuing.
+              // TODO: Most of these checks are already performed when entering a
+              // Suspense boundary. We should track the information on the stack so
+              // we don't have to recompute it on demand. This would also allow us
+              // to unify with `use` which needs to perform this logic even sooner,
+              // before `throwException` is called.
+              if (sourceFiber.mode & ConcurrentMode) {
+                if (getShellBoundary() === null) {
+                  // Suspended in the "shell" of the app. This is an undesirable
+                  // loading state. We should avoid committing this tree.
+                  renderDidSuspendDelayIfPossible();
+                } else {
+                  // If we suspended deeper than the shell, we don't need to delay
+                  // the commmit. However, we still call renderDidSuspend if this is
+                  // a new boundary, to tell the work loop that a new fallback has
+                  // appeared during this render.
+                  // TODO: Theoretically we should be able to delete this branch.
+                  // It's currently used for two things: 1) to throttle the
+                  // appearance of successive loading states, and 2) in
+                  // SuspenseList, to determine whether the children include any
+                  // pending fallbacks. For 1, we should apply throttling to all
+                  // retries, not just ones that render an additional fallback. For
+                  // 2, we should check subtreeFlags instead. Then we can delete
+                  // this branch.
+                  const current = suspenseBoundary.alternate;
+
+                  if (current === null) {
+                    renderDidSuspend();
+                  }
+                }
+              }
+
+              suspenseBoundary.flags &= ~ForceClientRender;
+              markSuspenseBoundaryShouldCapture(suspenseBoundary, returnFiber, sourceFiber, root, rootRenderLanes); // Retry listener
+              //
+              // If the fallback does commit, we need to attach a different type of
+              // listener. This one schedules an update on the Suspense boundary to
+              // turn the fallback state off.
+              //
+              // Stash the wakeable on the boundary fiber so we can access it in the
+              // commit phase.
+              //
+              // When the wakeable resolves, we'll attempt to render the boundary
+              // again ("retry").
+              // Check if this is a Suspensey resource. We do not attach retry
+              // listeners to these, because we don't actually need them for
+              // rendering. Only for committing. Instead, if a fallback commits
+              // and the only thing that suspended was a Suspensey resource, we
+              // retry immediately.
+              // TODO: Refactor throwException so that we don't have to do this type
+              // check. The caller already knows what the cause was.
+
+              const isSuspenseyResource = wakeable === noopSuspenseyCommitThenable;
+
+              if (isSuspenseyResource) {
+                suspenseBoundary.flags |= ScheduleRetry;
+              } else {
+                const retryQueue = suspenseBoundary.updateQueue;
+
+                if (retryQueue === null) {
+                  suspenseBoundary.updateQueue = new Set([wakeable]);
+                } else {
+                  retryQueue.add(wakeable);
+                } // We only attach ping listeners in concurrent mode. Legacy
+                // Suspense always commits fallbacks synchronously, so there are
+                // no pings.
+
+
+                if (suspenseBoundary.mode & ConcurrentMode) {
+                  attachPingListener(root, wakeable, rootRenderLanes);
+                }
+              }
+
+              return;
+            }
+
+          case OffscreenComponent:
+            {
+              if (suspenseBoundary.mode & ConcurrentMode) {
+                suspenseBoundary.flags |= ShouldCapture;
+                const isSuspenseyResource = wakeable === noopSuspenseyCommitThenable;
+
+                if (isSuspenseyResource) {
+                  suspenseBoundary.flags |= ScheduleRetry;
+                } else {
+                  const offscreenQueue = suspenseBoundary.updateQueue;
+
+                  if (offscreenQueue === null) {
+                    const newOffscreenQueue = {
+                      transitions: null,
+                      markerInstances: null,
+                      retryQueue: new Set([wakeable])
+                    };
+                    suspenseBoundary.updateQueue = newOffscreenQueue;
+                  } else {
+                    const retryQueue = offscreenQueue.retryQueue;
+
+                    if (retryQueue === null) {
+                      offscreenQueue.retryQueue = new Set([wakeable]);
+                    } else {
+                      retryQueue.add(wakeable);
+                    }
+                  }
+
+                  attachPingListener(root, wakeable, rootRenderLanes);
+                }
+
+                return;
+              }
+            }
+        }
+
+        throw Error(formatProdErrorMessage(435, suspenseBoundary.tag));
+      } else {
+        // No boundary was found. Unless this is a sync update, this is OK.
+        // We can suspend and wait for more data to arrive.
+        if (root.tag === ConcurrentRoot) {
+          // In a concurrent root, suspending without a Suspense boundary is
+          // allowed. It will suspend indefinitely without committing.
+          //
+          // TODO: Should we have different behavior for discrete updates? What
+          // about flushSync? Maybe it should put the tree into an inert state,
+          // and potentially log a warning. Revisit this for a future release.
+          attachPingListener(root, wakeable, rootRenderLanes);
+          renderDidSuspendDelayIfPossible();
+          return;
+        } else {
+          // In a legacy root, suspending without a boundary is always an error.
+          const uncaughtSuspenseError = Error(formatProdErrorMessage(426));
+          value = uncaughtSuspenseError;
+        }
+      }
+    }
+  } // This is a regular error, not a Suspense wakeable.
+
+
+  if (getIsHydrating() && sourceFiber.mode & ConcurrentMode) {
+    const suspenseBoundary = getSuspenseHandler(); // If the error was thrown during hydration, we may be able to recover by
+    // discarding the dehydrated content and switching to a client render.
+    // Instead of surfacing the error, find the nearest Suspense boundary
+    // and render it again without hydration.
+
+    if (suspenseBoundary !== null) {
+      if ((suspenseBoundary.flags & ShouldCapture) === NoFlags$1) {
+        // Set a flag to indicate that we should try rendering the normal
+        // children again, not the fallback.
+        suspenseBoundary.flags |= ForceClientRender;
+      }
+
+      markSuspenseBoundaryShouldCapture(suspenseBoundary, returnFiber, sourceFiber, root, rootRenderLanes); // Even though the user may not be affected by this error, we should
+      // still log it so it can be fixed.
+
+      queueHydrationError(createCapturedValueAtFiber(value, sourceFiber));
+      return;
+    }
+  }
+
+  value = createCapturedValueAtFiber(value, sourceFiber);
+  renderDidError(value); // We didn't find a boundary that could handle this type of exception. Start
+  // over and traverse parent path again, this time treating the exception
+  // as an error.
+
+  let workInProgress = returnFiber;
+
+  do {
+    switch (workInProgress.tag) {
+      case HostRoot:
+        {
+          const errorInfo = value;
+          workInProgress.flags |= ShouldCapture;
+          const lane = pickArbitraryLane(rootRenderLanes);
+          workInProgress.lanes = mergeLanes(workInProgress.lanes, lane);
+          const update = createRootErrorUpdate(workInProgress, errorInfo, lane);
+          enqueueCapturedUpdate(workInProgress, update);
+          return;
+        }
+
+      case ClassComponent:
+        // Capture and retry
+        const errorInfo = value;
+        const ctor = workInProgress.type;
+        const instance = workInProgress.stateNode;
+
+        if ((workInProgress.flags & DidCapture) === NoFlags$1 && (typeof ctor.getDerivedStateFromError === 'function' || instance !== null && typeof instance.componentDidCatch === 'function' && !isAlreadyFailedLegacyErrorBoundary(instance))) {
+          workInProgress.flags |= ShouldCapture;
+          const lane = pickArbitraryLane(rootRenderLanes);
+          workInProgress.lanes = mergeLanes(workInProgress.lanes, lane); // Schedule the error boundary to re-render using updated state
+
+          const update = createClassErrorUpdate(workInProgress, errorInfo, lane);
+          enqueueCapturedUpdate(workInProgress, update);
+          return;
+        }
+
+        break;
+    } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+    workInProgress = workInProgress.return;
+  } while (workInProgress !== null);
+}
+
+const ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner; // A special exception that's used to unwind the stack when an update flows
+// into a dehydrated boundary.
+
+const SelectiveHydrationException = Error(formatProdErrorMessage(461));
+let didReceiveUpdate = false;
+
+function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
+  if (current === null) {
+    // If this is a fresh new component that hasn't been rendered yet, we
+    // won't update its child set by applying minimal side-effects. Instead,
+    // we will add them all to the child before it gets rendered. That means
+    // we can optimize this reconciliation pass by not tracking side-effects.
+    workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderLanes);
+  } else {
+    // If the current child is the same as the work in progress, it means that
+    // we haven't yet started any work on these children. Therefore, we use
+    // the clone algorithm to create a copy of all the current children.
+    // If we had any progressed work already, that is invalid at this point so
+    // let's throw it out.
+    workInProgress.child = reconcileChildFibers(workInProgress, current.child, nextChildren, renderLanes);
+  }
+}
+
+function forceUnmountCurrentAndReconcile(current, workInProgress, nextChildren, renderLanes) {
+  // This function is fork of reconcileChildren. It's used in cases where we
+  // want to reconcile without matching against the existing set. This has the
+  // effect of all current children being unmounted; even if the type and key
+  // are the same, the old child is unmounted and a new child is created.
+  //
+  // To do this, we're going to go through the reconcile algorithm twice. In
+  // the first pass, we schedule a deletion for all the current children by
+  // passing null.
+  workInProgress.child = reconcileChildFibers(workInProgress, current.child, null, renderLanes); // In the second pass, we mount the new children. The trick here is that we
+  // pass null in place of where we usually pass the current child set. This has
+  // the effect of remounting all children regardless of whether their
+  // identities match.
+
+  workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderLanes);
+}
+
+function updateForwardRef(current, workInProgress, Component, nextProps, renderLanes) {
+
+  const render = Component.render;
+  const ref = workInProgress.ref; // The rest is a fork of updateFunctionComponent
+
+  let nextChildren;
+  let hasId;
+  prepareToReadContext(workInProgress, renderLanes);
+
+  {
+    markComponentRenderStarted(workInProgress);
+  }
+
+  {
+    nextChildren = renderWithHooks(current, workInProgress, render, nextProps, ref, renderLanes);
+    hasId = checkDidRenderIdHook();
+  }
+
+  {
+    markComponentRenderStopped();
+  }
+
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateMemoComponent(current, workInProgress, Component, nextProps, renderLanes) {
+  if (current === null) {
+    const type = Component.type;
+
+    if (isSimpleFunctionComponent(type) && Component.compare === null && // SimpleMemoComponent codepath doesn't resolve outer props either.
+    Component.defaultProps === undefined) {
+      let resolvedType = type;
+      // and with only the default shallow comparison, we upgrade it
+      // to a SimpleMemoComponent to allow fast path updates.
+
+
+      workInProgress.tag = SimpleMemoComponent;
+      workInProgress.type = resolvedType;
+
+      return updateSimpleMemoComponent(current, workInProgress, resolvedType, nextProps, renderLanes);
+    }
+
+    const child = createFiberFromTypeAndProps(Component.type, null, nextProps, null, workInProgress, workInProgress.mode, renderLanes);
+    child.ref = workInProgress.ref;
+    child.return = workInProgress;
+    workInProgress.child = child;
+    return child;
+  }
+
+  const currentChild = current.child; // This is always exactly one child
+
+  const hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(current, renderLanes);
+
+  if (!hasScheduledUpdateOrContext) {
+    // This will be the props with resolved defaultProps,
+    // unlike current.memoizedProps which will be the unresolved ones.
+    const prevProps = currentChild.memoizedProps; // Default to shallow comparison
+
+    let compare = Component.compare;
+    compare = compare !== null ? compare : shallowEqual;
+
+    if (compare(prevProps, nextProps) && current.ref === workInProgress.ref) {
+      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    }
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+  const newChild = createWorkInProgress(currentChild, nextProps);
+  newChild.ref = workInProgress.ref;
+  newChild.return = workInProgress;
+  workInProgress.child = newChild;
+  return newChild;
+}
+
+function updateSimpleMemoComponent(current, workInProgress, Component, nextProps, renderLanes) {
+
+  if (current !== null) {
+    const prevProps = current.memoizedProps;
+
+    if (shallowEqual(prevProps, nextProps) && current.ref === workInProgress.ref && ( // Prevent bailout if the implementation changed due to hot reload.
+    true)) {
+      didReceiveUpdate = false; // The props are shallowly equal. Reuse the previous props object, like we
+      // would during a normal fiber bailout.
+      //
+      // We don't have strong guarantees that the props object is referentially
+      // equal during updates where we can't bail out anyway — like if the props
+      // are shallowly equal, but there's a local state or context update in the
+      // same batch.
+      //
+      // However, as a principle, we should aim to make the behavior consistent
+      // across different ways of memoizing a component. For example, React.memo
+      // has a different internal Fiber layout if you pass a normal function
+      // component (SimpleMemoComponent) versus if you pass a different type
+      // like forwardRef (MemoComponent). But this is an implementation detail.
+      // Wrapping a component in forwardRef (or React.lazy, etc) shouldn't
+      // affect whether the props object is reused during a bailout.
+
+      workInProgress.pendingProps = nextProps = prevProps;
+
+      if (!checkScheduledUpdateOrContext(current, renderLanes)) {
+        // The pending lanes were cleared at the beginning of beginWork. We're
+        // about to bail out, but there might be other lanes that weren't
+        // included in the current render. Usually, the priority level of the
+        // remaining updates is accumulated during the evaluation of the
+        // component (i.e. when processing the update queue). But since since
+        // we're bailing out early *without* evaluating the component, we need
+        // to account for it here, too. Reset to the value of the current fiber.
+        // NOTE: This only applies to SimpleMemoComponent, not MemoComponent,
+        // because a MemoComponent fiber does not have hooks or an update queue;
+        // rather, it wraps around an inner component, which may or may not
+        // contains hooks.
+        // TODO: Move the reset at in beginWork out of the common path so that
+        // this is no longer necessary.
+        workInProgress.lanes = current.lanes;
+        return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+      } else if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags$1) {
+        // This is a special case that only exists for legacy mode.
+        // See https://github.com/facebook/react/pull/19216.
+        didReceiveUpdate = true;
+      }
+    }
+  }
+
+  return updateFunctionComponent(current, workInProgress, Component, nextProps, renderLanes);
+}
+
+function updateOffscreenComponent(current, workInProgress, renderLanes) {
+  const nextProps = workInProgress.pendingProps;
+  const nextChildren = nextProps.children;
+  const nextIsDetached = (workInProgress.stateNode._pendingVisibility & OffscreenDetached) !== 0;
+  const prevState = current !== null ? current.memoizedState : null;
+  markRef$1(current, workInProgress);
+
+  if (nextProps.mode === 'hidden' || enableLegacyHidden  || nextIsDetached) {
+    // Rendering a hidden tree.
+    const didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
+
+    if (didSuspend) {
+      // Something suspended inside a hidden tree
+      // Include the base lanes from the last render
+      const nextBaseLanes = prevState !== null ? mergeLanes(prevState.baseLanes, renderLanes) : renderLanes;
+
+      if (current !== null) {
+        // Reset to the current children
+        let currentChild = workInProgress.child = current.child; // The current render suspended, but there may be other lanes with
+        // pending work. We can't read `childLanes` from the current Offscreen
+        // fiber because we reset it when it was deferred; however, we can read
+        // the pending lanes from the child fibers.
+
+        let currentChildLanes = NoLanes;
+
+        while (currentChild !== null) {
+          currentChildLanes = mergeLanes(mergeLanes(currentChildLanes, currentChild.lanes), currentChild.childLanes);
+          currentChild = currentChild.sibling;
+        }
+
+        const lanesWeJustAttempted = nextBaseLanes;
+        const remainingChildLanes = removeLanes(currentChildLanes, lanesWeJustAttempted);
+        workInProgress.childLanes = remainingChildLanes;
+      } else {
+        workInProgress.childLanes = NoLanes;
+        workInProgress.child = null;
+      }
+
+      return deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes);
+    }
+
+    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+      // In legacy sync mode, don't defer the subtree. Render it now.
+      // TODO: Consider how Offscreen should work with transitions in the future
+      const nextState = {
+        baseLanes: NoLanes,
+        cachePool: null
+      };
+      workInProgress.memoizedState = nextState;
+
+      {
+        // push the cache pool even though we're going to bail out
+        // because otherwise there'd be a context mismatch
+        if (current !== null) {
+          pushTransition(workInProgress, null);
+        }
+      }
+
+      reuseHiddenContextOnStack();
+      pushOffscreenSuspenseHandler(workInProgress);
+    } else if (!includesSomeLane(renderLanes, OffscreenLane)) {
+      // We're hidden, and we're not rendering at Offscreen. We will bail out
+      // and resume this tree later.
+      // Schedule this fiber to re-render at Offscreen priority
+      workInProgress.lanes = workInProgress.childLanes = laneToLanes(OffscreenLane); // Include the base lanes from the last render
+
+      const nextBaseLanes = prevState !== null ? mergeLanes(prevState.baseLanes, renderLanes) : renderLanes;
+      return deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes);
+    } else {
+      // This is the second render. The surrounding visible content has already
+      // committed. Now we resume rendering the hidden tree.
+      // Rendering at offscreen, so we can clear the base lanes.
+      const nextState = {
+        baseLanes: NoLanes,
+        cachePool: null
+      };
+      workInProgress.memoizedState = nextState;
+
+      if (current !== null) {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        const 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);
+      } // Push the lanes that were skipped when we bailed out.
+
+
+      if (prevState !== null) {
+        pushHiddenContext(workInProgress, prevState);
+      } else {
+        reuseHiddenContextOnStack();
+      }
+
+      pushOffscreenSuspenseHandler(workInProgress);
+    }
+  } else {
+    // Rendering a visible tree.
+    if (prevState !== null) {
+      // We're going from hidden -> visible.
+      let prevCachePool = null;
+
+      {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        prevCachePool = prevState.cachePool;
+      }
+
+      pushTransition(workInProgress, prevCachePool); // Push the lanes that were skipped when we bailed out.
+
+      pushHiddenContext(workInProgress, prevState);
+      reuseSuspenseHandlerOnStack(workInProgress); // Since we're not hidden anymore, reset the state
+
+      workInProgress.memoizedState = null;
+    } else {
+      // We weren't previously hidden, and we still aren't, so there's nothing
+      // special to do. Need to push to the stack regardless, though, to avoid
+      // a push/pop misalignment.
+      {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        if (current !== null) {
+          pushTransition(workInProgress, null);
+        }
+      } // We're about to bail out, but we need to push this to the stack anyway
+      // to avoid a push/pop misalignment.
+
+
+      reuseHiddenContextOnStack();
+      reuseSuspenseHandlerOnStack(workInProgress);
+    }
+  }
+
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes, renderLanes) {
+  const nextState = {
+    baseLanes: nextBaseLanes,
+    // Save the cache pool so we can resume later.
+    cachePool: getOffscreenDeferredCache() 
+  };
+  workInProgress.memoizedState = nextState;
+
+  {
+    // push the cache pool even though we're going to bail out
+    // because otherwise there'd be a context mismatch
+    if (current !== null) {
+      pushTransition(workInProgress, null);
+    }
+  } // We're about to bail out, but we need to push this to the stack anyway
+  // to avoid a push/pop misalignment.
+
+
+  reuseHiddenContextOnStack();
+  pushOffscreenSuspenseHandler(workInProgress);
+
+  return null;
+} // Note: These happen to have identical begin phases, for now. We shouldn't hold
+
+function updateCacheComponent(current, workInProgress, renderLanes) {
+
+  prepareToReadContext(workInProgress, renderLanes);
+  const parentCache = readContext(CacheContext);
+
+  if (current === null) {
+    // Initial mount. Request a fresh cache from the pool.
+    const freshCache = requestCacheFromPool(renderLanes);
+    const initialState = {
+      parent: parentCache,
+      cache: freshCache
+    };
+    workInProgress.memoizedState = initialState;
+    initializeUpdateQueue(workInProgress);
+    pushCacheProvider(workInProgress, freshCache);
+  } else {
+    // Check for updates
+    if (includesSomeLane(current.lanes, renderLanes)) {
+      cloneUpdateQueue(current, workInProgress);
+      processUpdateQueue(workInProgress, null, null, renderLanes);
+    }
+
+    const prevState = current.memoizedState;
+    const nextState = workInProgress.memoizedState; // Compare the new parent cache to the previous to see detect there was
+    // a refresh.
+
+    if (prevState.parent !== parentCache) {
+      // Refresh in parent. Update the parent.
+      const derivedState = {
+        parent: parentCache,
+        cache: parentCache
+      }; // Copied from getDerivedStateFromProps implementation. Once the update
+      // queue is empty, persist the derived state onto the base state.
+
+      workInProgress.memoizedState = derivedState;
+
+      if (workInProgress.lanes === NoLanes) {
+        const updateQueue = workInProgress.updateQueue;
+        workInProgress.memoizedState = updateQueue.baseState = derivedState;
+      }
+
+      pushCacheProvider(workInProgress, parentCache); // No need to propagate a context change because the refreshed parent
+      // already did.
+    } else {
+      // The parent didn't refresh. Now check if this cache did.
+      const nextCache = nextState.cache;
+      pushCacheProvider(workInProgress, nextCache);
+
+      if (nextCache !== prevState.cache) {
+        // This cache refreshed. Propagate a context change.
+        propagateContextChange(workInProgress, CacheContext, renderLanes);
+      }
+    }
+  }
+
+  const nextChildren = workInProgress.pendingProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+} // This should only be called if the name changes
+
+function updateFragment(current, workInProgress, renderLanes) {
+  const nextChildren = workInProgress.pendingProps;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateMode(current, workInProgress, renderLanes) {
+  const nextChildren = workInProgress.pendingProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+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,
+      const stateNode = workInProgress.stateNode;
+      stateNode.effectDuration = 0;
+      stateNode.passiveEffectDuration = 0;
+    }
+  }
+
+  const nextProps = workInProgress.pendingProps;
+  const nextChildren = nextProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function markRef$1(current, workInProgress) {
+  const ref = workInProgress.ref;
+
+  if (current === null && ref !== null || current !== null && current.ref !== ref) {
+    // Schedule a Ref effect
+    workInProgress.flags |= Ref;
+    workInProgress.flags |= RefStatic;
+  }
+}
+
+function updateFunctionComponent(current, workInProgress, Component, nextProps, renderLanes) {
+
+  let context;
+
+  {
+    const unmaskedContext = getUnmaskedContext(workInProgress, Component, true);
+    context = getMaskedContext(workInProgress, unmaskedContext);
+  }
+
+  let nextChildren;
+  let hasId;
+  prepareToReadContext(workInProgress, renderLanes);
+
+  {
+    markComponentRenderStarted(workInProgress);
+  }
+
+  {
+    nextChildren = renderWithHooks(current, workInProgress, Component, nextProps, context, renderLanes);
+    hasId = checkDidRenderIdHook();
+  }
+
+  {
+    markComponentRenderStopped();
+  }
+
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function replayFunctionComponent(current, workInProgress, nextProps, Component, secondArg, renderLanes) {
+  // This function is used to replay a component that previously suspended,
+  // after its data resolves. It's a simplified version of
+  // updateFunctionComponent that reuses the hooks from the previous attempt.
+  prepareToReadContext(workInProgress, renderLanes);
+
+  {
+    markComponentRenderStarted(workInProgress);
+  }
+
+  const nextChildren = replaySuspendedComponentWithHooks(current, workInProgress, Component, nextProps, secondArg);
+  const hasId = checkDidRenderIdHook();
+
+  {
+    markComponentRenderStopped();
+  }
+
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateClassComponent(current, workInProgress, Component, nextProps, renderLanes) {
+  // During mounting we don't know the child context yet as the instance doesn't exist.
+  // We will invalidate the child context in finishClassComponent() right after rendering.
+
+
+  let hasContext;
+
+  if (isContextProvider(Component)) {
+    hasContext = true;
+    pushContextProvider(workInProgress);
+  } else {
+    hasContext = false;
+  }
+
+  prepareToReadContext(workInProgress, renderLanes);
+  const instance = workInProgress.stateNode;
+  let shouldUpdate;
+
+  if (instance === null) {
+    resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress); // In the initial pass we might need to construct the instance.
+
+    constructClassInstance(workInProgress, Component, nextProps);
+    mountClassInstance(workInProgress, Component, nextProps, renderLanes);
+    shouldUpdate = true;
+  } else if (current === null) {
+    // In a resume, we'll already have an instance we can reuse.
+    shouldUpdate = resumeMountClassInstance(workInProgress, Component, nextProps, renderLanes);
+  } else {
+    shouldUpdate = updateClassInstance(current, workInProgress, Component, nextProps, renderLanes);
+  }
+
+  const nextUnitOfWork = finishClassComponent(current, workInProgress, Component, shouldUpdate, hasContext, renderLanes);
+
+  return nextUnitOfWork;
+}
+
+function finishClassComponent(current, workInProgress, Component, shouldUpdate, hasContext, renderLanes) {
+  // Refs should update even if shouldComponentUpdate returns false
+  markRef$1(current, workInProgress);
+  const didCaptureError = (workInProgress.flags & DidCapture) !== NoFlags$1;
+
+  if (!shouldUpdate && !didCaptureError) {
+    // Context providers should defer to sCU for rendering
+    if (hasContext) {
+      invalidateContextProvider(workInProgress, Component, false);
+    }
+
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+
+  const instance = workInProgress.stateNode; // Rerender
+
+  ReactCurrentOwner$1.current = workInProgress;
+  let nextChildren;
+
+  if (didCaptureError && typeof Component.getDerivedStateFromError !== 'function') {
+    // If we captured an error, but getDerivedStateFromError is not defined,
+    // unmount all the children. componentDidCatch will schedule an update to
+    // re-render a fallback. This is temporary until we migrate everyone to
+    // the new API.
+    // TODO: Warn in a future release.
+    nextChildren = null;
+
+    {
+      stopProfilerTimerIfRunning();
+    }
+  } else {
+    {
+      markComponentRenderStarted(workInProgress);
+    }
+
+    {
+      nextChildren = instance.render();
+    }
+
+    {
+      markComponentRenderStopped();
+    }
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+
+  if (current !== null && didCaptureError) {
+    // If we're recovering from an error, reconcile without reusing any of
+    // the existing children. Conceptually, the normal children and the children
+    // that are shown on error are two different sets, so we shouldn't reuse
+    // normal children even if their identities match.
+    forceUnmountCurrentAndReconcile(current, workInProgress, nextChildren, renderLanes);
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  } // Memoize state using the values we just used to render.
+  // TODO: Restructure so we never read values from the instance.
+
+
+  workInProgress.memoizedState = instance.state; // The context might have changed so we need to recalculate it.
+
+  if (hasContext) {
+    invalidateContextProvider(workInProgress, Component, true);
+  }
+
+  return workInProgress.child;
+}
+
+function pushHostRootContext(workInProgress) {
+  const root = workInProgress.stateNode;
+
+  if (root.pendingContext) {
+    pushTopLevelContextObject(workInProgress, root.pendingContext, root.pendingContext !== root.context);
+  } else if (root.context) {
+    // Should always be set
+    pushTopLevelContextObject(workInProgress, root.context, false);
+  }
+
+  pushHostContainer(workInProgress, root.containerInfo);
+}
+
+function updateHostRoot(current, workInProgress, renderLanes) {
+  pushHostRootContext(workInProgress);
+
+  if (current === null) {
+    throw Error(formatProdErrorMessage(387));
+  }
+
+  const nextProps = workInProgress.pendingProps;
+  const prevState = workInProgress.memoizedState;
+  const prevChildren = prevState.element;
+  cloneUpdateQueue(current, workInProgress);
+  processUpdateQueue(workInProgress, nextProps, null, renderLanes);
+  const nextState = workInProgress.memoizedState;
+
+  {
+    const nextCache = nextState.cache;
+    pushCacheProvider(workInProgress, nextCache);
+
+    if (nextCache !== prevState.cache) {
+      // The root cache refreshed.
+      propagateContextChange(workInProgress, CacheContext, renderLanes);
+    }
+  } // Caution: React DevTools currently depends on this property
+  // being called "element".
+
+
+  const nextChildren = nextState.element;
+
+  if (prevState.isDehydrated) {
+    // This is a hydration root whose shell has not yet hydrated. We should
+    // attempt to hydrate.
+    // Flip isDehydrated to false to indicate that when this render
+    // finishes, the root will no longer be dehydrated.
+    const overrideState = {
+      element: nextChildren,
+      isDehydrated: false,
+      cache: nextState.cache
+    };
+    const updateQueue = workInProgress.updateQueue; // `baseState` can always be the last state because the root doesn't
+    // have reducer functions so it doesn't need rebasing.
+
+    updateQueue.baseState = overrideState;
+    workInProgress.memoizedState = overrideState;
+
+    if (workInProgress.flags & ForceClientRender) {
+      // Something errored during a previous attempt to hydrate the shell, so we
+      // forced a client render.
+      const recoverableError = createCapturedValueAtFiber(Error(formatProdErrorMessage(423)), workInProgress);
+      return mountHostRootWithoutHydrating(current, workInProgress, nextChildren, renderLanes, recoverableError);
+    } else if (nextChildren !== prevChildren) {
+      const recoverableError = createCapturedValueAtFiber(Error(formatProdErrorMessage(424)), workInProgress);
+      return mountHostRootWithoutHydrating(current, workInProgress, nextChildren, renderLanes, recoverableError);
+    } else {
+      // The outermost shell has not hydrated yet. Start hydrating.
+      enterHydrationState(workInProgress);
+      const child = mountChildFibers(workInProgress, null, nextChildren, renderLanes);
+      workInProgress.child = child;
+      let node = child;
+
+      while (node) {
+        // Mark each child as hydrating. This is a fast path to know whether this
+        // tree is part of a hydrating tree. This is used to determine if a child
+        // node has fully mounted yet, and for scheduling event replaying.
+        // Conceptually this is similar to Placement in that a new subtree is
+        // inserted into the React tree here. It just happens to not need DOM
+        // mutations because it already exists.
+        node.flags = node.flags & ~Placement | Hydrating;
+        node = node.sibling;
+      }
+    }
+  } else {
+    // Root is not dehydrated. Either this is a client-only root, or it
+    // already hydrated.
+    resetHydrationState();
+
+    if (nextChildren === prevChildren) {
+      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    }
+
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  }
+
+  return workInProgress.child;
+}
+
+function mountHostRootWithoutHydrating(current, workInProgress, nextChildren, renderLanes, recoverableError) {
+  // Revert to client rendering.
+  resetHydrationState();
+  queueHydrationError(recoverableError);
+  workInProgress.flags |= ForceClientRender;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateHostComponent$1(current, workInProgress, renderLanes) {
+  pushHostContext(workInProgress);
+
+  if (current === null) {
+    tryToClaimNextHydratableInstance(workInProgress);
+  }
+
+  const type = workInProgress.type;
+  const nextProps = workInProgress.pendingProps;
+  const prevProps = current !== null ? current.memoizedProps : null;
+  let nextChildren = nextProps.children;
+  const isDirectTextChild = shouldSetTextContent(type, nextProps);
+
+  if (isDirectTextChild) {
+    // We special case a direct text child of a host node. This is a common
+    // case. We won't handle it as a reified child. We will instead handle
+    // this in the host environment that also has access to this prop. That
+    // avoids allocating another HostText fiber and traversing it.
+    nextChildren = null;
+  } else if (prevProps !== null && shouldSetTextContent(type, prevProps)) {
+    // If we're switching from a direct text child to a normal child, or to
+    // empty, we need to schedule the text content to be reset.
+    workInProgress.flags |= ContentReset;
+  }
+
+  {
+    const memoizedState = workInProgress.memoizedState;
+
+    if (memoizedState !== null) {
+      // This fiber has been upgraded to a stateful component. The only way
+      // happens currently is for form actions. We use hooks to track the
+      // pending and error state of the form.
+      //
+      // Once a fiber is upgraded to be stateful, it remains stateful for the
+      // rest of its lifetime.
+      const newState = renderTransitionAwareHostComponentWithHooks(current, workInProgress, renderLanes); // If the transition state changed, propagate the change to all the
+      // descendents. We use Context as an implementation detail for this.
+      //
+      // This is intentionally set here instead of pushHostContext because
+      // pushHostContext gets called before we process the state hook, to avoid
+      // a state mismatch in the event that something suspends.
+      //
+      // NOTE: This assumes that there cannot be nested transition providers,
+      // because the only renderer that implements this feature is React DOM,
+      // and forms cannot be nested. If we did support nested providers, then
+      // we would need to push a context value even for host fibers that
+      // haven't been upgraded yet.
+
+      {
+        HostTransitionContext._currentValue = newState;
+      }
+
+      {
+        if (didReceiveUpdate) {
+          if (current !== null) {
+            const oldStateHook = current.memoizedState;
+            const oldState = oldStateHook.memoizedState; // This uses regular equality instead of Object.is because we assume
+            // that host transition state doesn't include NaN as a valid type.
+
+            if (oldState !== newState) {
+              propagateContextChange(workInProgress, HostTransitionContext, renderLanes);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  markRef$1(current, workInProgress);
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateHostHoistable(current, workInProgress, renderLanes) {
+  markRef$1(current, workInProgress);
+  const currentProps = current === null ? null : current.memoizedProps;
+  const resource = workInProgress.memoizedState = getResource(workInProgress.type, currentProps, workInProgress.pendingProps);
+
+  if (current === null) {
+    if (!getIsHydrating() && resource === null) {
+      // This is not a Resource Hoistable and we aren't hydrating so we construct the instance.
+      workInProgress.stateNode = createHoistableInstance(workInProgress.type, workInProgress.pendingProps, getRootHostContainer(), workInProgress);
+    }
+  } // Resources never have reconciler managed children. It is possible for
+  // the host implementation of getResource to consider children in the
+  // resource construction but they will otherwise be discarded. In practice
+  // this precludes all but the simplest children and Host specific warnings
+  // should be implemented to warn when children are passsed when otherwise not
+  // expected
+
+
+  return null;
+}
+
+function updateHostSingleton(current, workInProgress, renderLanes) {
+  pushHostContext(workInProgress);
+
+  if (current === null) {
+    claimHydratableSingleton(workInProgress);
+  }
+
+  const nextChildren = workInProgress.pendingProps.children;
+
+  if (current === null && !getIsHydrating()) {
+    // Similar to Portals we append Singleton children in the commit phase. So we
+    // Track insertions even on mount.
+    // TODO: Consider unifying this with how the root works.
+    workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderLanes);
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  }
+
+  markRef$1(current, workInProgress);
+  return workInProgress.child;
+}
+
+function updateHostText$1(current, workInProgress) {
+  if (current === null) {
+    tryToClaimNextHydratableTextInstance(workInProgress);
+  } // Nothing to do here. This is terminal. We'll do the completion step
+  // immediately after.
+
+
+  return null;
+}
+
+function mountLazyComponent(_current, workInProgress, elementType, renderLanes) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);
+  const props = workInProgress.pendingProps;
+  const lazyComponent = elementType;
+  const payload = lazyComponent._payload;
+  const init = lazyComponent._init;
+  let Component = init(payload); // Store the unwrapped component in the type.
+
+  workInProgress.type = Component;
+  const resolvedTag = workInProgress.tag = resolveLazyComponentTag(Component);
+  const resolvedProps = resolveDefaultProps(Component, props);
+  let child;
+
+  switch (resolvedTag) {
+    case FunctionComponent:
+      {
+
+        child = updateFunctionComponent(null, workInProgress, Component, resolvedProps, renderLanes);
+        return child;
+      }
+
+    case ClassComponent:
+      {
+
+        child = updateClassComponent(null, workInProgress, Component, resolvedProps, renderLanes);
+        return child;
+      }
+
+    case ForwardRef:
+      {
+
+        child = updateForwardRef(null, workInProgress, Component, resolvedProps, renderLanes);
+        return child;
+      }
+
+    case MemoComponent:
+      {
+
+        child = updateMemoComponent(null, workInProgress, Component, resolveDefaultProps(Component.type, resolvedProps), // The inner type can have defaults too
+        renderLanes);
+        return child;
+      }
+  }
+
+  let hint = '';
+  // because the fact that it's a separate type of work is an
+  // implementation detail.
+
+
+  throw Error(formatProdErrorMessage(306, Component, hint));
+}
+
+function mountIncompleteClassComponent(_current, workInProgress, Component, nextProps, renderLanes) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress); // Promote the fiber to a class and try rendering again.
+
+  workInProgress.tag = ClassComponent; // The rest of this function is a fork of `updateClassComponent`
+  // Push context providers early to prevent context stack mismatches.
+  // During mounting we don't know the child context yet as the instance doesn't exist.
+  // We will invalidate the child context in finishClassComponent() right after rendering.
+
+  let hasContext;
+
+  if (isContextProvider(Component)) {
+    hasContext = true;
+    pushContextProvider(workInProgress);
+  } else {
+    hasContext = false;
+  }
+
+  prepareToReadContext(workInProgress, renderLanes);
+  constructClassInstance(workInProgress, Component, nextProps);
+  mountClassInstance(workInProgress, Component, nextProps, renderLanes);
+  return finishClassComponent(null, workInProgress, Component, true, hasContext, renderLanes);
+}
+
+function mountIndeterminateComponent(_current, workInProgress, Component, renderLanes) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);
+  const props = workInProgress.pendingProps;
+  let context;
+
+  {
+    const unmaskedContext = getUnmaskedContext(workInProgress, Component, false);
+    context = getMaskedContext(workInProgress, unmaskedContext);
+  }
+
+  prepareToReadContext(workInProgress, renderLanes);
+  let value;
+  let hasId;
+
+  {
+    markComponentRenderStarted(workInProgress);
+  }
+
+  {
+    value = renderWithHooks(null, workInProgress, Component, props, context, renderLanes);
+    hasId = checkDidRenderIdHook();
+  }
+
+  {
+    markComponentRenderStopped();
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+
+  if ( // Run these checks in production only if the flag is off.
+  // Eventually we'll delete this branch altogether.
+  typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) {
+
+
+    workInProgress.tag = ClassComponent; // Throw out any hooks that were used.
+
+    workInProgress.memoizedState = null;
+    workInProgress.updateQueue = null; // Push context providers early to prevent context stack mismatches.
+    // During mounting we don't know the child context yet as the instance doesn't exist.
+    // We will invalidate the child context in finishClassComponent() right after rendering.
+
+    let hasContext = false;
+
+    if (isContextProvider(Component)) {
+      hasContext = true;
+      pushContextProvider(workInProgress);
+    } else {
+      hasContext = false;
+    }
+
+    workInProgress.memoizedState = value.state !== null && value.state !== undefined ? value.state : null;
+    initializeUpdateQueue(workInProgress);
+    adoptClassInstance(workInProgress, value);
+    mountClassInstance(workInProgress, Component, props, renderLanes);
+    return finishClassComponent(null, workInProgress, Component, true, hasContext, renderLanes);
+  } else {
+    // Proceed under the assumption that this is a function component
+    workInProgress.tag = FunctionComponent;
+
+    if (getIsHydrating() && hasId) {
+      pushMaterializedTreeId(workInProgress);
+    }
+
+    reconcileChildren(null, workInProgress, value, renderLanes);
+
+    return workInProgress.child;
+  }
+}
+
+const SUSPENDED_MARKER = {
+  dehydrated: null,
+  treeContext: null,
+  retryLane: NoLane
+};
+
+function mountSuspenseOffscreenState(renderLanes) {
+  return {
+    baseLanes: renderLanes,
+    cachePool: getSuspendedCache()
+  };
+}
+
+function updateSuspenseOffscreenState(prevOffscreenState, renderLanes) {
+  let cachePool = null;
+
+  {
+    const prevCachePool = prevOffscreenState.cachePool;
+
+    if (prevCachePool !== null) {
+      const parentCache = CacheContext._currentValue ;
+
+      if (prevCachePool.parent !== parentCache) {
+        // Detected a refresh in the parent. This overrides any previously
+        // suspended cache.
+        cachePool = {
+          parent: parentCache,
+          pool: parentCache
+        };
+      } else {
+        // We can reuse the cache from last time. The only thing that would have
+        // overridden it is a parent refresh, which we checked for above.
+        cachePool = prevCachePool;
+      }
+    } else {
+      // If there's no previous cache pool, grab the current one.
+      cachePool = getSuspendedCache();
+    }
+  }
+
+  return {
+    baseLanes: mergeLanes(prevOffscreenState.baseLanes, renderLanes),
+    cachePool
+  };
+} // TODO: Probably should inline this back
+
+
+function shouldRemainOnFallback(current, workInProgress, renderLanes) {
+  // If we're already showing a fallback, there are cases where we need to
+  // remain on that fallback regardless of whether the content has resolved.
+  // For example, SuspenseList coordinates when nested content appears.
+  // TODO: For compatibility with offscreen prerendering, this should also check
+  // whether the current fiber (if it exists) was visible in the previous tree.
+  if (current !== null) {
+    const suspenseState = current.memoizedState;
+
+    if (suspenseState === null) {
+      // Currently showing content. Don't hide it, even if ForceSuspenseFallback
+      // is true. More precise name might be "ForceRemainSuspenseFallback".
+      // Note: This is a factoring smell. Can't remain on a fallback if there's
+      // no fallback to remain on.
+      return false;
+    }
+  } // Not currently showing content. Consult the Suspense context.
+
+
+  const suspenseContext = suspenseStackCursor.current;
+  return hasSuspenseListContext(suspenseContext, ForceSuspenseFallback);
+}
+
+function getRemainingWorkInPrimaryTree(current, renderLanes) {
+  // TODO: Should not remove render lanes that were pinged during this render
+  return removeLanes(current.childLanes, renderLanes);
+}
+
+function updateSuspenseComponent(current, workInProgress, renderLanes) {
+  const nextProps = workInProgress.pendingProps; // This is used by DevTools to force a boundary to suspend.
+
+  let showFallback = false;
+  const didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
+
+  if (didSuspend || shouldRemainOnFallback(current)) {
+    // Something in this boundary's subtree already suspended. Switch to
+    // rendering the fallback children.
+    showFallback = true;
+    workInProgress.flags &= ~DidCapture;
+  } // OK, the next part is confusing. We're about to reconcile the Suspense
+  // boundary's children. This involves some custom reconciliation logic. Two
+  // main reasons this is so complicated.
+  //
+  // First, Legacy Mode has different semantics for backwards compatibility. The
+  // primary tree will commit in an inconsistent state, so when we do the
+  // second pass to render the fallback, we do some exceedingly, uh, clever
+  // hacks to make that not totally break. Like transferring effects and
+  // deletions from hidden tree. In Concurrent Mode, it's much simpler,
+  // because we bailout on the primary tree completely and leave it in its old
+  // state, no effects. Same as what we do for Offscreen (except that
+  // Offscreen doesn't have the first render pass).
+  //
+  // Second is hydration. During hydration, the Suspense fiber has a slightly
+  // different layout, where the child points to a dehydrated fragment, which
+  // contains the DOM rendered by the server.
+  //
+  // Third, even if you set all that aside, Suspense is like error boundaries in
+  // that we first we try to render one tree, and if that fails, we render again
+  // and switch to a different tree. Like a try/catch block. So we have to track
+  // which branch we're currently rendering. Ideally we would model this using
+  // a stack.
+
+
+  if (current === null) {
+    // Initial mount
+    // Special path for hydration
+    // If we're currently hydrating, try to hydrate this boundary.
+    if (getIsHydrating()) {
+      // We must push the suspense handler context *before* attempting to
+      // hydrate, to avoid a mismatch in case it errors.
+      if (showFallback) {
+        pushPrimaryTreeSuspenseHandler(workInProgress);
+      } else {
+        pushFallbackTreeSuspenseHandler(workInProgress);
+      }
+
+      tryToClaimNextHydratableSuspenseInstance(workInProgress); // This could've been a dehydrated suspense component.
+
+      const suspenseState = workInProgress.memoizedState;
+
+      if (suspenseState !== null) {
+        const dehydrated = suspenseState.dehydrated;
+
+        if (dehydrated !== null) {
+          return mountDehydratedSuspenseComponent(workInProgress, dehydrated);
+        }
+      } // If hydration didn't succeed, fall through to the normal Suspense path.
+      // To avoid a stack mismatch we need to pop the Suspense handler that we
+      // pushed above. This will become less awkward when move the hydration
+      // logic to its own fiber.
+
+
+      popSuspenseHandler(workInProgress);
+    }
+
+    const nextPrimaryChildren = nextProps.children;
+    const nextFallbackChildren = nextProps.fallback;
+
+    if (showFallback) {
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      const fallbackFragment = mountSuspenseFallbackChildren(workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);
+      const primaryChildFragment = workInProgress.child;
+      primaryChildFragment.memoizedState = mountSuspenseOffscreenState(renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+
+      return fallbackFragment;
+    } else if (typeof nextProps.unstable_expectedLoadTime === 'number') {
+      // This is a CPU-bound tree. Skip this tree and show a placeholder to
+      // unblock the surrounding content. Then immediately retry after the
+      // initial commit.
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      const fallbackFragment = mountSuspenseFallbackChildren(workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);
+      const primaryChildFragment = workInProgress.child;
+      primaryChildFragment.memoizedState = mountSuspenseOffscreenState(renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER; // TODO: Transition Tracing is not yet implemented for CPU Suspense.
+      // Since nothing actually suspended, there will nothing to ping this to
+      // get it started back up to attempt the next item. While in terms of
+      // priority this work has the same priority as this current render, it's
+      // not part of the same transition once the transition has committed. If
+      // it's sync, we still want to yield so that it can be painted.
+      // Conceptually, this is really the same as pinging. We can use any
+      // RetryLane even if it's the one currently rendering since we're leaving
+      // it behind on this node.
+
+      workInProgress.lanes = SomeRetryLane;
+      return fallbackFragment;
+    } else {
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      return mountSuspensePrimaryChildren(workInProgress, nextPrimaryChildren);
+    }
+  } else {
+    // This is an update.
+    // Special path for hydration
+    const prevState = current.memoizedState;
+
+    if (prevState !== null) {
+      const dehydrated = prevState.dehydrated;
+
+      if (dehydrated !== null) {
+        return updateDehydratedSuspenseComponent(current, workInProgress, didSuspend, nextProps, dehydrated, prevState, renderLanes);
+      }
+    }
+
+    if (showFallback) {
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      const nextFallbackChildren = nextProps.fallback;
+      const nextPrimaryChildren = nextProps.children;
+      const fallbackChildFragment = updateSuspenseFallbackChildren(current, workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);
+      const primaryChildFragment = workInProgress.child;
+      const prevOffscreenState = current.child.memoizedState;
+      primaryChildFragment.memoizedState = prevOffscreenState === null ? mountSuspenseOffscreenState(renderLanes) : updateSuspenseOffscreenState(prevOffscreenState, renderLanes);
+
+      primaryChildFragment.childLanes = getRemainingWorkInPrimaryTree(current, renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+      return fallbackChildFragment;
+    } else {
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      const nextPrimaryChildren = nextProps.children;
+      const primaryChildFragment = updateSuspensePrimaryChildren(current, workInProgress, nextPrimaryChildren, renderLanes);
+      workInProgress.memoizedState = null;
+      return primaryChildFragment;
+    }
+  }
+}
+
+function mountSuspensePrimaryChildren(workInProgress, primaryChildren, renderLanes) {
+  const mode = workInProgress.mode;
+  const primaryChildProps = {
+    mode: 'visible',
+    children: primaryChildren
+  };
+  const primaryChildFragment = mountWorkInProgressOffscreenFiber(primaryChildProps, mode);
+  primaryChildFragment.return = workInProgress;
+  workInProgress.child = primaryChildFragment;
+  return primaryChildFragment;
+}
+
+function mountSuspenseFallbackChildren(workInProgress, primaryChildren, fallbackChildren, renderLanes) {
+  const mode = workInProgress.mode;
+  const progressedPrimaryFragment = workInProgress.child;
+  const primaryChildProps = {
+    mode: 'hidden',
+    children: primaryChildren
+  };
+  let primaryChildFragment;
+  let fallbackChildFragment;
+
+  if ((mode & ConcurrentMode) === NoMode && progressedPrimaryFragment !== null) {
+    // In legacy mode, we commit the primary tree as if it successfully
+    // completed, even though it's in an inconsistent state.
+    primaryChildFragment = progressedPrimaryFragment;
+    primaryChildFragment.childLanes = NoLanes;
+    primaryChildFragment.pendingProps = primaryChildProps;
+
+    if (workInProgress.mode & ProfileMode) {
+      // Reset the durations from the first pass so they aren't included in the
+      // final amounts. This seems counterintuitive, since we're intentionally
+      // not measuring part of the render phase, but this makes it match what we
+      // do in Concurrent Mode.
+      primaryChildFragment.actualDuration = 0;
+      primaryChildFragment.actualStartTime = -1;
+      primaryChildFragment.selfBaseDuration = 0;
+      primaryChildFragment.treeBaseDuration = 0;
+    }
+
+    fallbackChildFragment = createFiberFromFragment(fallbackChildren, mode, renderLanes, null);
+  } else {
+    primaryChildFragment = mountWorkInProgressOffscreenFiber(primaryChildProps, mode);
+    fallbackChildFragment = createFiberFromFragment(fallbackChildren, mode, renderLanes, null);
+  }
+
+  primaryChildFragment.return = workInProgress;
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
+  return fallbackChildFragment;
+}
+
+function mountWorkInProgressOffscreenFiber(offscreenProps, mode, renderLanes) {
+  // The props argument to `createFiberFromOffscreen` is `any` typed, so we use
+  // this wrapper function to constrain it.
+  return createFiberFromOffscreen(offscreenProps, mode, NoLanes, null);
+}
+
+function updateWorkInProgressOffscreenFiber(current, offscreenProps) {
+  // The props argument to `createWorkInProgress` is `any` typed, so we use this
+  // wrapper function to constrain it.
+  return createWorkInProgress(current, offscreenProps);
+}
+
+function updateSuspensePrimaryChildren(current, workInProgress, primaryChildren, renderLanes) {
+  const currentPrimaryChildFragment = current.child;
+  const currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
+  const primaryChildFragment = updateWorkInProgressOffscreenFiber(currentPrimaryChildFragment, {
+    mode: 'visible',
+    children: primaryChildren
+  });
+
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    primaryChildFragment.lanes = renderLanes;
+  }
+
+  primaryChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = null;
+
+  if (currentFallbackChildFragment !== null) {
+    // Delete the fallback child fragment
+    const deletions = workInProgress.deletions;
+
+    if (deletions === null) {
+      workInProgress.deletions = [currentFallbackChildFragment];
+      workInProgress.flags |= ChildDeletion;
+    } else {
+      deletions.push(currentFallbackChildFragment);
+    }
+  }
+
+  workInProgress.child = primaryChildFragment;
+  return primaryChildFragment;
+}
+
+function updateSuspenseFallbackChildren(current, workInProgress, primaryChildren, fallbackChildren, renderLanes) {
+  const mode = workInProgress.mode;
+  const currentPrimaryChildFragment = current.child;
+  const currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
+  const primaryChildProps = {
+    mode: 'hidden',
+    children: primaryChildren
+  };
+  let primaryChildFragment;
+
+  if ( // In legacy mode, we commit the primary tree as if it successfully
+  // completed, even though it's in an inconsistent state.
+  (mode & ConcurrentMode) === NoMode && // Make sure we're on the second pass, i.e. the primary child fragment was
+  // already cloned. In legacy mode, the only case where this isn't true is
+  // when DevTools forces us to display a fallback; we skip the first render
+  // pass entirely and go straight to rendering the fallback. (In Concurrent
+  // Mode, SuspenseList can also trigger this scenario, but this is a legacy-
+  // only codepath.)
+  workInProgress.child !== currentPrimaryChildFragment) {
+    const progressedPrimaryFragment = workInProgress.child;
+    primaryChildFragment = progressedPrimaryFragment;
+    primaryChildFragment.childLanes = NoLanes;
+    primaryChildFragment.pendingProps = primaryChildProps;
+
+    if (workInProgress.mode & ProfileMode) {
+      // Reset the durations from the first pass so they aren't included in the
+      // final amounts. This seems counterintuitive, since we're intentionally
+      // not measuring part of the render phase, but this makes it match what we
+      // do in Concurrent Mode.
+      primaryChildFragment.actualDuration = 0;
+      primaryChildFragment.actualStartTime = -1;
+      primaryChildFragment.selfBaseDuration = currentPrimaryChildFragment.selfBaseDuration;
+      primaryChildFragment.treeBaseDuration = currentPrimaryChildFragment.treeBaseDuration;
+    } // The fallback fiber was added as a deletion during the first pass.
+    // However, since we're going to remain on the fallback, we no longer want
+    // to delete it.
+
+
+    workInProgress.deletions = null;
+  } else {
+    primaryChildFragment = updateWorkInProgressOffscreenFiber(currentPrimaryChildFragment, primaryChildProps); // Since we're reusing a current tree, we need to reuse the flags, too.
+    // (We don't do this in legacy mode, because in legacy mode we don't re-use
+    // the current tree; see previous branch.)
+
+    primaryChildFragment.subtreeFlags = currentPrimaryChildFragment.subtreeFlags & StaticMask;
+  }
+
+  let fallbackChildFragment;
+
+  if (currentFallbackChildFragment !== null) {
+    fallbackChildFragment = createWorkInProgress(currentFallbackChildFragment, fallbackChildren);
+  } else {
+    fallbackChildFragment = createFiberFromFragment(fallbackChildren, mode, renderLanes, null); // Needs a placement effect because the parent (the Suspense boundary) already
+    // mounted but this is a new fiber.
+
+    fallbackChildFragment.flags |= Placement;
+  }
+
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
+  return fallbackChildFragment;
+}
+
+function retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, recoverableError) {
+  // Falling back to client rendering. Because this has performance
+  // implications, it's considered a recoverable error, even though the user
+  // likely won't observe anything wrong with the UI.
+  //
+  // The error is passed in as an argument to enforce that every caller provide
+  // a custom message, or explicitly opt out (currently the only path that opts
+  // out is legacy mode; every concurrent path provides an error).
+  if (recoverableError !== null) {
+    queueHydrationError(recoverableError);
+  } // This will add the old fiber to the deletion list
+
+
+  reconcileChildFibers(workInProgress, current.child, null, renderLanes); // We're now not suspended nor dehydrated.
+
+  const nextProps = workInProgress.pendingProps;
+  const primaryChildren = nextProps.children;
+  const primaryChildFragment = mountSuspensePrimaryChildren(workInProgress, primaryChildren); // Needs a placement effect because the parent (the Suspense boundary) already
+  // mounted but this is a new fiber.
+
+  primaryChildFragment.flags |= Placement;
+  workInProgress.memoizedState = null;
+  return primaryChildFragment;
+}
+
+function mountSuspenseFallbackAfterRetryWithoutHydrating(current, workInProgress, primaryChildren, fallbackChildren, renderLanes) {
+  const fiberMode = workInProgress.mode;
+  const primaryChildProps = {
+    mode: 'visible',
+    children: primaryChildren
+  };
+  const primaryChildFragment = mountWorkInProgressOffscreenFiber(primaryChildProps, fiberMode);
+  const fallbackChildFragment = createFiberFromFragment(fallbackChildren, fiberMode, renderLanes, null); // Needs a placement effect because the parent (the Suspense
+  // boundary) already mounted but this is a new fiber.
+
+  fallbackChildFragment.flags |= Placement;
+  primaryChildFragment.return = workInProgress;
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
+
+  if ((workInProgress.mode & ConcurrentMode) !== NoMode) {
+    // We will have dropped the effect list which contains the
+    // deletion. We need to reconcile to delete the current child.
+    reconcileChildFibers(workInProgress, current.child, null, renderLanes);
+  }
+
+  return fallbackChildFragment;
+}
+
+function mountDehydratedSuspenseComponent(workInProgress, suspenseInstance, renderLanes) {
+  // During the first pass, we'll bail out and not drill into the children.
+  // Instead, we'll leave the content in place and try to hydrate it later.
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+
+    workInProgress.lanes = laneToLanes(SyncLane);
+  } else if (isSuspenseInstanceFallback(suspenseInstance)) {
+    // This is a client-only boundary. Since we won't get any content from the server
+    // for this, we need to schedule that at a higher priority based on when it would
+    // have timed out. In theory we could render it in this pass but it would have the
+    // wrong priority associated with it and will prevent hydration of parent path.
+    // Instead, we'll leave work left on it to render it in a separate commit.
+    // TODO This time should be the time at which the server rendered response that is
+    // a parent to this boundary was displayed. However, since we currently don't have
+    // a protocol to transfer that time, we'll just estimate it by using the current
+    // time. This will mean that Suspense timeouts are slightly shifted to later than
+    // they should be.
+    // Schedule a normal pri update to render this content.
+    workInProgress.lanes = laneToLanes(DefaultHydrationLane);
+  } else {
+    // We'll continue hydrating the rest at offscreen priority since we'll already
+    // be showing the right content coming from the server, it is no rush.
+    workInProgress.lanes = laneToLanes(OffscreenLane);
+  }
+
+  return null;
+}
+
+function updateDehydratedSuspenseComponent(current, workInProgress, didSuspend, nextProps, suspenseInstance, suspenseState, renderLanes) {
+  if (!didSuspend) {
+    // This is the first render pass. Attempt to hydrate.
+    pushPrimaryTreeSuspenseHandler(workInProgress); // We should never be hydrating at this point because it is the first pass,
+
+    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, null);
+    }
+
+    if (isSuspenseInstanceFallback(suspenseInstance)) {
+      // This boundary is in a permanent fallback state. In this case, we'll never
+      // get an update and we'll never be able to hydrate the final content. Let's just try the
+      // client side render instead.
+      let digest;
+      let stack;
+
+      {
+        var _getSuspenseInstanceF2 = getSuspenseInstanceFallbackErrorDetails(suspenseInstance);
+
+        digest = _getSuspenseInstanceF2.digest;
+      }
+
+      let capturedValue = null; // TODO: Figure out a better signal than encoding a magic digest value.
+
+      if (digest !== 'POSTPONE') {
+        let error;
+
+        {
+          error = Error(formatProdErrorMessage(419));
+        }
+
+        error.digest = digest;
+        capturedValue = createCapturedValue(error, digest, stack);
+      }
+
+      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, capturedValue);
+    }
+    // any context has changed, we need to treat is as if the input might have changed.
+
+
+    const hasContextChanged = includesSomeLane(renderLanes, current.childLanes);
+
+    if (didReceiveUpdate || hasContextChanged) {
+      // This boundary has changed since the first render. This means that we are now unable to
+      // hydrate it. We might still be able to hydrate it using a higher priority lane.
+      const root = getWorkInProgressRoot();
+
+      if (root !== null) {
+        const attemptHydrationAtLane = getBumpedLaneForHydration(root, renderLanes);
+
+        if (attemptHydrationAtLane !== NoLane && attemptHydrationAtLane !== suspenseState.retryLane) {
+          // Intentionally mutating since this render will get interrupted. This
+          // is one of the very rare times where we mutate the current tree
+          // during the render phase.
+          suspenseState.retryLane = attemptHydrationAtLane;
+          enqueueConcurrentRenderForLane(current, attemptHydrationAtLane);
+          scheduleUpdateOnFiber(root, current, attemptHydrationAtLane); // Throw a special object that signals to the work loop that it should
+          // interrupt the current render.
+          //
+          // Because we're inside a React-only execution stack, we don't
+          // strictly need to throw here — we could instead modify some internal
+          // work loop state. But using an exception means we don't need to
+          // check for this case on every iteration of the work loop. So doing
+          // it this way moves the check out of the fast path.
+
+          throw SelectiveHydrationException;
+        }
+      } // If we did not selectively hydrate, we'll continue rendering without
+      // hydrating. Mark this tree as suspended to prevent it from committing
+      // outside a transition.
+      //
+      // This path should only happen if the hydration lane already suspended.
+      // Currently, it also happens during sync updates because there is no
+      // hydration lane for sync updates.
+      // TODO: We should ideally have a sync hydration lane that we can apply to do
+      // a pass where we hydrate this subtree in place using the previous Context and then
+      // reapply the update afterwards.
+
+
+      if (isSuspenseInstancePending(suspenseInstance)) ; else {
+        renderDidSuspendDelayIfPossible();
+      }
+
+      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, null);
+    } else if (isSuspenseInstancePending(suspenseInstance)) {
+      // This component is still pending more data from the server, so we can't hydrate its
+      // content. We treat it as if this component suspended itself. It might seem as if
+      // we could just try to render it client-side instead. However, this will perform a
+      // lot of unnecessary work and is unlikely to complete since it often will suspend
+      // on missing data anyway. Additionally, the server might be able to render more
+      // than we can on the client yet. In that case we'd end up with more fallback states
+      // on the client than if we just leave it alone. If the server times out or errors
+      // these should update this boundary to the permanent Fallback state instead.
+      // Mark it as having captured (i.e. suspended).
+      workInProgress.flags |= DidCapture; // Leave the child in place. I.e. the dehydrated fragment.
+
+      workInProgress.child = current.child; // Register a callback to retry this boundary once the server has sent the result.
+
+      const retry = retryDehydratedSuspenseBoundary.bind(null, current);
+      registerSuspenseInstanceRetry(suspenseInstance, retry);
+      return null;
+    } else {
+      // This is the first attempt.
+      reenterHydrationStateFromDehydratedSuspenseInstance(workInProgress, suspenseInstance, suspenseState.treeContext);
+      const primaryChildren = nextProps.children;
+      const primaryChildFragment = mountSuspensePrimaryChildren(workInProgress, primaryChildren); // Mark the children as hydrating. This is a fast path to know whether this
+      // tree is part of a hydrating tree. This is used to determine if a child
+      // node has fully mounted yet, and for scheduling event replaying.
+      // Conceptually this is similar to Placement in that a new subtree is
+      // inserted into the React tree here. It just happens to not need DOM
+      // mutations because it already exists.
+
+      primaryChildFragment.flags |= Hydrating;
+      return primaryChildFragment;
+    }
+  } else {
+    // This is the second render pass. We already attempted to hydrated, but
+    // something either suspended or errored.
+    if (workInProgress.flags & ForceClientRender) {
+      // Something errored during hydration. Try again without hydrating.
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      workInProgress.flags &= ~ForceClientRender;
+      const capturedValue = createCapturedValue(Error(formatProdErrorMessage(422)));
+      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, capturedValue);
+    } else if (workInProgress.memoizedState !== null) {
+      // Something suspended and we should still be in dehydrated mode.
+      // Leave the existing child in place.
+      // Push to avoid a mismatch
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      workInProgress.child = current.child; // The dehydrated completion pass expects this flag to be there
+      // but the normal suspense pass doesn't.
+
+      workInProgress.flags |= DidCapture;
+      return null;
+    } else {
+      // Suspended but we should no longer be in dehydrated mode.
+      // Therefore we now have to render the fallback.
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      const nextPrimaryChildren = nextProps.children;
+      const nextFallbackChildren = nextProps.fallback;
+      const fallbackChildFragment = mountSuspenseFallbackAfterRetryWithoutHydrating(current, workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);
+      const primaryChildFragment = workInProgress.child;
+      primaryChildFragment.memoizedState = mountSuspenseOffscreenState(renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+      return fallbackChildFragment;
+    }
+  }
+}
+
+function scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {
+  fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
+  const alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+  }
+
+  scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);
+}
+
+function propagateSuspenseContextChange(workInProgress, firstChild, renderLanes) {
+  // Mark any Suspense boundaries with fallbacks as having work to do.
+  // If they were previously forced into fallbacks, they may now be able
+  // to unblock.
+  let node = firstChild;
+
+  while (node !== null) {
+    if (node.tag === SuspenseComponent) {
+      const state = node.memoizedState;
+
+      if (state !== null) {
+        scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);
+      }
+    } else if (node.tag === SuspenseListComponent) {
+      // If the tail is hidden there might not be an Suspense boundaries
+      // to schedule work on. In this case we have to schedule it on the
+      // list itself.
+      // We don't have to traverse to the children of the list since
+      // the list will propagate the change when it rerenders.
+      scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);
+    } else if (node.child !== null) {
+      node.child.return = node;
+      node = node.child;
+      continue;
+    }
+
+    if (node === workInProgress) {
+      return;
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    while (node.sibling === null) {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      if (node.return === null || node.return === workInProgress) {
+        return;
+      }
+
+      node = node.return;
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    node.sibling.return = node.return;
+    node = node.sibling;
+  }
+}
+
+function findLastContentRow(firstChild) {
+  // This is going to find the last row among these children that is already
+  // showing content on the screen, as opposed to being in fallback state or
+  // new. If a row has multiple Suspense boundaries, any of them being in the
+  // fallback state, counts as the whole row being in a fallback state.
+  // Note that the "rows" will be workInProgress, but any nested children
+  // will still be current since we haven't rendered them yet. The mounted
+  // order may not be the same as the new order. We use the new order.
+  let row = firstChild;
+  let lastContentRow = null;
+
+  while (row !== null) {
+    const currentRow = row.alternate; // New rows can't be content rows.
+
+    if (currentRow !== null && findFirstSuspended(currentRow) === null) {
+      lastContentRow = row;
+    }
+
+    row = row.sibling;
+  }
+
+  return lastContentRow;
+}
+
+function initSuspenseListRenderState(workInProgress, isBackwards, tail, lastContentRow, tailMode) {
+  const renderState = workInProgress.memoizedState;
+
+  if (renderState === null) {
+    workInProgress.memoizedState = {
+      isBackwards: isBackwards,
+      rendering: null,
+      renderingStartTime: 0,
+      last: lastContentRow,
+      tail: tail,
+      tailMode: tailMode
+    };
+  } else {
+    // We can reuse the existing object from previous renders.
+    renderState.isBackwards = isBackwards;
+    renderState.rendering = null;
+    renderState.renderingStartTime = 0;
+    renderState.last = lastContentRow;
+    renderState.tail = tail;
+    renderState.tailMode = tailMode;
+  }
+} // This can end up rendering this component multiple passes.
+// The first pass splits the children fibers into two sets. A head and tail.
+// We first render the head. If anything is in fallback state, we do another
+// pass through beginWork to rerender all children (including the tail) with
+// the force suspend context. If the first render didn't have anything in
+// in fallback state. Then we render each row in the tail one-by-one.
+// That happens in the completeWork phase without going back to beginWork.
+
+
+function updateSuspenseListComponent(current, workInProgress, renderLanes) {
+  const nextProps = workInProgress.pendingProps;
+  const revealOrder = nextProps.revealOrder;
+  const tailMode = nextProps.tail;
+  const newChildren = nextProps.children;
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  let suspenseContext = suspenseStackCursor.current;
+  const shouldForceFallback = hasSuspenseListContext(suspenseContext, ForceSuspenseFallback);
+
+  if (shouldForceFallback) {
+    suspenseContext = setShallowSuspenseListContext(suspenseContext, ForceSuspenseFallback);
+    workInProgress.flags |= DidCapture;
+  } else {
+    const didSuspendBefore = current !== null && (current.flags & DidCapture) !== NoFlags$1;
+
+    if (didSuspendBefore) {
+      // If we previously forced a fallback, we need to schedule work
+      // on any nested boundaries to let them know to try to render
+      // again. This is the same as context updating.
+      propagateSuspenseContextChange(workInProgress, workInProgress.child, renderLanes);
+    }
+
+    suspenseContext = setDefaultShallowSuspenseListContext(suspenseContext);
+  }
+
+  pushSuspenseListContext(workInProgress, suspenseContext);
+
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    // In legacy mode, SuspenseList doesn't work so we just
+    // use make it a noop by treating it as the default revealOrder.
+    workInProgress.memoizedState = null;
+  } else {
+    switch (revealOrder) {
+      case 'forwards':
+        {
+          const lastContentRow = findLastContentRow(workInProgress.child);
+          let tail;
+
+          if (lastContentRow === null) {
+            // The whole list is part of the tail.
+            // TODO: We could fast path by just rendering the tail now.
+            tail = workInProgress.child;
+            workInProgress.child = null;
+          } else {
+            // Disconnect the tail rows after the content row.
+            // We're going to render them separately later.
+            tail = lastContentRow.sibling;
+            lastContentRow.sibling = null;
+          }
+
+          initSuspenseListRenderState(workInProgress, false, // isBackwards
+          tail, lastContentRow, tailMode);
+          break;
+        }
+
+      case 'backwards':
+        {
+          // We're going to find the first row that has existing content.
+          // At the same time we're going to reverse the list of everything
+          // we pass in the meantime. That's going to be our tail in reverse
+          // order.
+          let tail = null;
+          let row = workInProgress.child;
+          workInProgress.child = null;
+
+          while (row !== null) {
+            const currentRow = row.alternate; // New rows can't be content rows.
+
+            if (currentRow !== null && findFirstSuspended(currentRow) === null) {
+              // This is the beginning of the main content.
+              workInProgress.child = row;
+              break;
+            }
+
+            const nextRow = row.sibling;
+            row.sibling = tail;
+            tail = row;
+            row = nextRow;
+          } // TODO: If workInProgress.child is null, we can continue on the tail immediately.
+
+
+          initSuspenseListRenderState(workInProgress, true, // isBackwards
+          tail, null, // last
+          tailMode);
+          break;
+        }
+
+      case 'together':
+        {
+          initSuspenseListRenderState(workInProgress, false, // isBackwards
+          null, // tail
+          null, // last
+          undefined);
+          break;
+        }
+
+      default:
+        {
+          // The default reveal order is the same as not having
+          // a boundary.
+          workInProgress.memoizedState = null;
+        }
+    }
+  }
+
+  return workInProgress.child;
+}
+
+function updatePortalComponent(current, workInProgress, renderLanes) {
+  pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+  const nextChildren = workInProgress.pendingProps;
+
+  if (current === null) {
+    // Portals are special because we don't append the children during mount
+    // but at commit. Therefore we need to track insertions which the normal
+    // flow doesn't do during mount. This doesn't happen at the root because
+    // the root always starts with a "current" with a null child.
+    // TODO: Consider unifying this with how the root works.
+    workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderLanes);
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  }
+
+  return workInProgress.child;
+}
+
+function updateContextProvider(current, workInProgress, renderLanes) {
+  const providerType = workInProgress.type;
+  const context = providerType._context;
+  const newProps = workInProgress.pendingProps;
+  const oldProps = workInProgress.memoizedProps;
+  const newValue = newProps.value;
+
+  pushProvider(workInProgress, context, newValue);
+
+  {
+    if (oldProps !== null) {
+      const oldValue = oldProps.value;
+
+      if (objectIs(oldValue, newValue)) {
+        // No change. Bailout early if children are the same.
+        if (oldProps.children === newProps.children && !hasContextChanged()) {
+          return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+        }
+      } else {
+        // The context value changed. Search for matching consumers and schedule
+        // them to update.
+        propagateContextChange(workInProgress, context, renderLanes);
+      }
+    }
+  }
+
+  const newChildren = newProps.children;
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateContextConsumer(current, workInProgress, renderLanes) {
+  let context = workInProgress.type; // The logic below for Context differs depending on PROD or DEV mode. In
+
+  const newProps = workInProgress.pendingProps;
+  const render = newProps.children;
+
+  prepareToReadContext(workInProgress, renderLanes);
+  const newValue = readContext(context);
+
+  {
+    markComponentRenderStarted(workInProgress);
+  }
+
+  let newChildren;
+
+  {
+    newChildren = render(newValue);
+  }
+
+  {
+    markComponentRenderStopped();
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function markWorkInProgressReceivedUpdate() {
+  didReceiveUpdate = true;
+}
+
+function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    if (current !== null) {
+      // A lazy component only mounts if it suspended inside a non-
+      // concurrent tree, in an inconsistent state. We want to treat it like
+      // a new mount, even though an empty version of it already committed.
+      // Disconnect the alternate pointers.
+      current.alternate = null;
+      workInProgress.alternate = null; // Since this is conceptually a new fiber, schedule a Placement effect
+
+      workInProgress.flags |= Placement;
+    }
+  }
+}
+
+function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
+  if (current !== null) {
+    // Reuse previous dependencies
+    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.
+    {
+      return null;
+    }
+  } // This fiber doesn't have work, but its subtree does. Clone the child
+  // fibers and continue.
+
+
+  cloneChildFibers(current, workInProgress);
+  return workInProgress.child;
+}
+
+function checkScheduledUpdateOrContext(current, renderLanes) {
+  // Before performing an early bailout, we must check if there are pending
+  // updates or context.
+  const updateLanes = current.lanes;
+
+  if (includesSomeLane(updateLanes, renderLanes)) {
+    return true;
+  } // No pending update, but because context is propagated lazily, we need
+
+  return false;
+}
+
+function attemptEarlyBailoutIfNoScheduledUpdate(current, workInProgress, renderLanes) {
+  // This fiber does not have any pending work. Bailout without entering
+  // the begin phase. There's still some bookkeeping we that needs to be done
+  // in this optimized path, mostly pushing stuff onto the stack.
+  switch (workInProgress.tag) {
+    case HostRoot:
+      pushHostRootContext(workInProgress);
+
+      {
+        const cache = current.memoizedState.cache;
+        pushCacheProvider(workInProgress, cache);
+      }
+
+      resetHydrationState();
+      break;
+
+    case HostSingleton:
+    case HostComponent:
+      pushHostContext(workInProgress);
+      break;
+
+    case ClassComponent:
+      {
+        const Component = workInProgress.type;
+
+        if (isContextProvider(Component)) {
+          pushContextProvider(workInProgress);
+        }
+
+        break;
+      }
+
+    case HostPortal:
+      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+      break;
+
+    case ContextProvider:
+      {
+        const newValue = workInProgress.memoizedProps.value;
+        const context = workInProgress.type._context;
+        pushProvider(workInProgress, context, newValue);
+        break;
+      }
+
+    case Profiler:
+      {
+        // Profiler should only call onRender when one of its descendants actually rendered.
+        const 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,
+          const stateNode = workInProgress.stateNode;
+          stateNode.effectDuration = 0;
+          stateNode.passiveEffectDuration = 0;
+        }
+      }
+
+      break;
+
+    case SuspenseComponent:
+      {
+        const state = workInProgress.memoizedState;
+
+        if (state !== null) {
+          if (state.dehydrated !== null) {
+            // We're not going to render the children, so this is just to maintain
+            // push/pop symmetry
+            pushPrimaryTreeSuspenseHandler(workInProgress); // We know that this component will suspend again because if it has
+            // been unsuspended it has committed as a resolved Suspense component.
+            // If it needs to be retried, it should have work scheduled on it.
+
+            workInProgress.flags |= DidCapture; // We should never render the children of a dehydrated boundary until we
+            // upgrade it. We return null instead of bailoutOnAlreadyFinishedWork.
+
+            return null;
+          } // If this boundary is currently timed out, we need to decide
+          // whether to retry the primary children, or to skip over it and
+          // go straight to the fallback. Check the priority of the primary
+          // child fragment.
+
+
+          const primaryChildFragment = workInProgress.child;
+          const primaryChildLanes = primaryChildFragment.childLanes;
+
+          if (includesSomeLane(renderLanes, primaryChildLanes)) {
+            // The primary children have pending work. Use the normal path
+            // to attempt to render the primary children again.
+            return updateSuspenseComponent(current, workInProgress, renderLanes);
+          } else {
+            // The primary child fragment does not have pending work marked
+            // on it
+            pushPrimaryTreeSuspenseHandler(workInProgress); // The primary children do not have pending work with sufficient
+            // priority. Bailout.
+
+            const child = bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+
+            if (child !== null) {
+              // The fallback children have pending work. Skip over the
+              // primary children and work on the fallback.
+              return child.sibling;
+            } else {
+              // Note: We can return `null` here because we already checked
+              // whether there were nested context consumers, via the call to
+              // `bailoutOnAlreadyFinishedWork` above.
+              return null;
+            }
+          }
+        } else {
+          pushPrimaryTreeSuspenseHandler(workInProgress);
+        }
+
+        break;
+      }
+
+    case SuspenseListComponent:
+      {
+        const didSuspendBefore = (current.flags & DidCapture) !== NoFlags$1;
+        let hasChildWork = includesSomeLane(renderLanes, workInProgress.childLanes);
+
+        if (didSuspendBefore) {
+          if (hasChildWork) {
+            // If something was in fallback state last time, and we have all the
+            // same children then we're still in progressive loading state.
+            // Something might get unblocked by state updates or retries in the
+            // tree which will affect the tail. So we need to use the normal
+            // path to compute the correct tail.
+            return updateSuspenseListComponent(current, workInProgress, renderLanes);
+          } // If none of the children had any work, that means that none of
+          // them got retried so they'll still be blocked in the same way
+          // as before. We can fast bail out.
+
+
+          workInProgress.flags |= DidCapture;
+        } // If nothing suspended before and we're rendering the same children,
+        // then the tail doesn't matter. Anything new that suspends will work
+        // in the "together" mode, so we can continue from the state we had.
+
+
+        const renderState = workInProgress.memoizedState;
+
+        if (renderState !== null) {
+          // Reset to the "together" mode in case we've started a different
+          // update in the past but didn't complete it.
+          renderState.rendering = null;
+          renderState.tail = null;
+          renderState.lastEffect = null;
+        }
+
+        pushSuspenseListContext(workInProgress, suspenseStackCursor.current);
+
+        if (hasChildWork) {
+          break;
+        } else {
+          // If none of the children had any work, that means that none of
+          // them got retried so they'll still be blocked in the same way
+          // as before. We can fast bail out.
+          return null;
+        }
+      }
+
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      {
+        // Need to check if the tree still needs to be deferred. This is
+        // almost identical to the logic used in the normal update path,
+        // so we'll just enter that. The only difference is we'll bail out
+        // at the next level instead of this one, because the child props
+        // have not changed. Which is fine.
+        // TODO: Probably should refactor `beginWork` to split the bailout
+        // path from the normal path. I'm tempted to do a labeled break here
+        // but I won't :)
+        workInProgress.lanes = NoLanes;
+        return updateOffscreenComponent(current, workInProgress, renderLanes);
+      }
+
+    case CacheComponent:
+      {
+        {
+          const cache = current.memoizedState.cache;
+          pushCacheProvider(workInProgress, cache);
+        }
+
+        break;
+      }
+  }
+
+  return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+}
+
+function beginWork$1(current, workInProgress, renderLanes) {
+
+  if (current !== null) {
+    const oldProps = current.memoizedProps;
+    const newProps = workInProgress.pendingProps;
+
+    if (oldProps !== newProps || hasContextChanged() || ( // Force a re-render if the implementation changed due to hot reload:
+    false)) {
+      // If props or context changed, mark the fiber as having performed work.
+      // This may be unset if the props are determined to be equal later (memo).
+      didReceiveUpdate = true;
+    } else {
+      // Neither props nor legacy context changes. Check if there's a pending
+      // update or context change.
+      const hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(current, renderLanes);
+
+      if (!hasScheduledUpdateOrContext && // If this is the second pass of an error or suspense boundary, there
+      // may not be work scheduled on `current`, so we check for this flag.
+      (workInProgress.flags & DidCapture) === NoFlags$1) {
+        // No pending updates or context. Bail out now.
+        didReceiveUpdate = false;
+        return attemptEarlyBailoutIfNoScheduledUpdate(current, workInProgress, renderLanes);
+      }
+
+      if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags$1) {
+        // This is a special case that only exists for legacy mode.
+        // See https://github.com/facebook/react/pull/19216.
+        didReceiveUpdate = true;
+      } else {
+        // An update was scheduled on this fiber, but there are no new props
+        // nor legacy context. Set this to false. If an update queue or context
+        // consumer produces a changed value, it will set this to true. Otherwise,
+        // the component will assume the children have not changed and bail out.
+        didReceiveUpdate = false;
+      }
+    }
+  } else {
+    didReceiveUpdate = false;
+
+    if (getIsHydrating() && isForkedChild(workInProgress)) {
+      // Check if this child belongs to a list of muliple children in
+      // its parent.
+      //
+      // In a true multi-threaded implementation, we would render children on
+      // parallel threads. This would represent the beginning of a new render
+      // thread for this subtree.
+      //
+      // We only use this for id generation during hydration, which is why the
+      // logic is located in this special branch.
+      const slotIndex = workInProgress.index;
+      const numberOfForks = getForksAtLevel();
+      pushTreeId(workInProgress, numberOfForks, slotIndex);
+    }
+  } // Before entering the begin phase, clear pending update priority.
+  // TODO: This assumes that we're about to evaluate the component and process
+  // the update queue. However, there's an exception: SimpleMemoComponent
+  // sometimes bails out later in the begin phase. This indicates that we should
+  // move this assignment out of the common path and into each branch.
+
+
+  workInProgress.lanes = NoLanes;
+
+  switch (workInProgress.tag) {
+    case IndeterminateComponent:
+      {
+        return mountIndeterminateComponent(current, workInProgress, workInProgress.type, renderLanes);
+      }
+
+    case LazyComponent:
+      {
+        const elementType = workInProgress.elementType;
+        return mountLazyComponent(current, workInProgress, elementType, renderLanes);
+      }
+
+    case FunctionComponent:
+      {
+        const Component = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps;
+        const resolvedProps = workInProgress.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        return updateFunctionComponent(current, workInProgress, Component, resolvedProps, renderLanes);
+      }
+
+    case ClassComponent:
+      {
+        const Component = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps;
+        const resolvedProps = workInProgress.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        return updateClassComponent(current, workInProgress, Component, resolvedProps, renderLanes);
+      }
+
+    case HostRoot:
+      return updateHostRoot(current, workInProgress, renderLanes);
+
+    case HostHoistable:
+      {
+        return updateHostHoistable(current, workInProgress);
+      }
+
+    // Fall through
+
+    case HostSingleton:
+      {
+        return updateHostSingleton(current, workInProgress, renderLanes);
+      }
+
+    // Fall through
+
+    case HostComponent:
+      return updateHostComponent$1(current, workInProgress, renderLanes);
+
+    case HostText:
+      return updateHostText$1(current, workInProgress);
+
+    case SuspenseComponent:
+      return updateSuspenseComponent(current, workInProgress, renderLanes);
+
+    case HostPortal:
+      return updatePortalComponent(current, workInProgress, renderLanes);
+
+    case ForwardRef:
+      {
+        const type = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps;
+        const resolvedProps = workInProgress.elementType === type ? unresolvedProps : resolveDefaultProps(type, unresolvedProps);
+        return updateForwardRef(current, workInProgress, type, resolvedProps, renderLanes);
+      }
+
+    case Fragment:
+      return updateFragment(current, workInProgress, renderLanes);
+
+    case Mode:
+      return updateMode(current, workInProgress, renderLanes);
+
+    case Profiler:
+      return updateProfiler(current, workInProgress, renderLanes);
+
+    case ContextProvider:
+      return updateContextProvider(current, workInProgress, renderLanes);
+
+    case ContextConsumer:
+      return updateContextConsumer(current, workInProgress, renderLanes);
+
+    case MemoComponent:
+      {
+        const type = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps; // Resolve outer props first, then resolve inner props.
+
+        let resolvedProps = resolveDefaultProps(type, unresolvedProps);
+
+        resolvedProps = resolveDefaultProps(type.type, resolvedProps);
+        return updateMemoComponent(current, workInProgress, type, resolvedProps, renderLanes);
+      }
+
+    case SimpleMemoComponent:
+      {
+        return updateSimpleMemoComponent(current, workInProgress, workInProgress.type, workInProgress.pendingProps, renderLanes);
+      }
+
+    case IncompleteClassComponent:
+      {
+        const Component = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps;
+        const resolvedProps = workInProgress.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        return mountIncompleteClassComponent(current, workInProgress, Component, resolvedProps, renderLanes);
+      }
+
+    case SuspenseListComponent:
+      {
+        return updateSuspenseListComponent(current, workInProgress, renderLanes);
+      }
+
+    case ScopeComponent:
+      {
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        return updateOffscreenComponent(current, workInProgress, renderLanes);
+      }
+
+    case LegacyHiddenComponent:
+      {
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        {
+          return updateCacheComponent(current, workInProgress, renderLanes);
+        }
+      }
+  }
+
+  throw Error(formatProdErrorMessage(156, workInProgress.tag));
+}
+
+const valueCursor = createCursor(null);
+
+let currentlyRenderingFiber = null;
+let lastContextDependency = null;
+let lastFullyObservedContext = null;
+function resetContextDependencies() {
+  // This is called right before React yields execution, to ensure `readContext`
+  // cannot be called outside the render phase.
+  currentlyRenderingFiber = null;
+  lastContextDependency = null;
+  lastFullyObservedContext = null;
+}
+function pushProvider(providerFiber, context, nextValue) {
+  {
+    push(valueCursor, context._currentValue);
+    context._currentValue = nextValue;
+  }
+}
+function popProvider(context, providerFiber) {
+  const currentValue = valueCursor.current;
+
+  {
+    if (currentValue === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      context._currentValue = context._defaultValue;
+    } else {
+      context._currentValue = currentValue;
+    }
+  }
+
+  pop(valueCursor);
+}
+function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
+  // Update the child lanes of all the ancestors, including the alternates.
+  let node = parent;
+
+  while (node !== null) {
+    const alternate = node.alternate;
+
+    if (!isSubsetOfLanes(node.childLanes, renderLanes)) {
+      node.childLanes = mergeLanes(node.childLanes, renderLanes);
+
+      if (alternate !== null) {
+        alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
+      }
+    } else if (alternate !== null && !isSubsetOfLanes(alternate.childLanes, renderLanes)) {
+      alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
+    } else ;
+
+    if (node === propagationRoot) {
+      break;
+    }
+
+    node = node.return;
+  }
+}
+function propagateContextChange(workInProgress, context, renderLanes) {
+  {
+    propagateContextChange_eager(workInProgress, context, renderLanes);
+  }
+}
+
+function propagateContextChange_eager(workInProgress, context, renderLanes) {
+
+  let 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) {
+    let nextFiber; // Visit this fiber.
+
+    const list = fiber.dependencies;
+
+    if (list !== null) {
+      nextFiber = fiber.child;
+      let dependency = list.firstContext;
+
+      while (dependency !== null) {
+        // Check if the context matches.
+        if (dependency.context === context) {
+          // Match! Schedule an update on this fiber.
+          if (fiber.tag === ClassComponent) {
+            // Schedule a force update on the work-in-progress.
+            const lane = pickArbitraryLane(renderLanes);
+            const update = createUpdate(lane);
+            update.tag = ForceUpdate; // TODO: Because we don't have a work-in-progress, this will add the
+            // update to the current fiber, too, which means it will persist even if
+            // this render is thrown away. Since it's a race condition, not sure it's
+            // worth fixing.
+            // Inlined `enqueueUpdate` to remove interleaved update check
+
+            const updateQueue = fiber.updateQueue;
+
+            if (updateQueue === null) ; else {
+              const sharedQueue = updateQueue.shared;
+              const pending = sharedQueue.pending;
+
+              if (pending === null) {
+                // This is the first update. Create a circular list.
+                update.next = update;
+              } else {
+                update.next = pending.next;
+                pending.next = update;
+              }
+
+              sharedQueue.pending = update;
+            }
+          }
+
+          fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
+          const alternate = fiber.alternate;
+
+          if (alternate !== null) {
+            alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+          }
+
+          scheduleContextWorkOnParentPath(fiber.return, renderLanes, workInProgress); // Mark the updated lanes on the list, too.
+
+          list.lanes = mergeLanes(list.lanes, renderLanes); // Since we already found a match, we can stop traversing the
+          // dependency list.
+
+          break;
+        }
+
+        dependency = dependency.next;
+      }
+    } else if (fiber.tag === ContextProvider) {
+      // Don't scan deeper if this is a matching provider
+      nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
+    } else if (fiber.tag === DehydratedFragment) {
+      // If a dehydrated suspense boundary is in this subtree, we don't know
+      // if it will have any context consumers in it. The best we can do is
+      // mark it as having updates.
+      const parentSuspense = fiber.return;
+
+      if (parentSuspense === null) {
+        throw Error(formatProdErrorMessage(341));
+      }
+
+      parentSuspense.lanes = mergeLanes(parentSuspense.lanes, renderLanes);
+      const alternate = parentSuspense.alternate;
+
+      if (alternate !== null) {
+        alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+      } // This is intentionally passing this fiber as the parent
+      // because we want to schedule this fiber as having work
+      // on its children. We'll use the childLanes on
+      // this fiber to indicate that a context has changed.
+
+
+      scheduleContextWorkOnParentPath(parentSuspense, renderLanes, workInProgress);
+      nextFiber = fiber.sibling;
+    } else {
+      // Traverse down.
+      nextFiber = fiber.child;
+    }
+
+    if (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;
+        }
+
+        const 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 prepareToReadContext(workInProgress, renderLanes) {
+  currentlyRenderingFiber = workInProgress;
+  lastContextDependency = null;
+  lastFullyObservedContext = null;
+  const dependencies = workInProgress.dependencies;
+
+  if (dependencies !== null) {
+    {
+      const firstContext = dependencies.firstContext;
+
+      if (firstContext !== null) {
+        if (includesSomeLane(dependencies.lanes, renderLanes)) {
+          // Context list has a pending update. Mark that this fiber performed work.
+          markWorkInProgressReceivedUpdate();
+        } // Reset the work-in-progress list
+
+
+        dependencies.firstContext = null;
+      }
+    }
+  }
+}
+function readContext(context) {
+
+  return readContextForConsumer(currentlyRenderingFiber, context);
+}
+function readContextDuringReconcilation(consumer, context, renderLanes) {
+  if (currentlyRenderingFiber === null) {
+    prepareToReadContext(consumer, renderLanes);
+  }
+
+  return readContextForConsumer(consumer, context);
+}
+
+function readContextForConsumer(consumer, context) {
+  const value = context._currentValue ;
+
+  if (lastFullyObservedContext === context) ; else {
+    const contextItem = {
+      context: context,
+      memoizedValue: value,
+      next: null
+    };
+
+    if (lastContextDependency === null) {
+      if (consumer === null) {
+        throw Error(formatProdErrorMessage(308));
+      } // This is the first dependency for this component. Create a new list.
+
+
+      lastContextDependency = contextItem;
+      consumer.dependencies = {
+        lanes: NoLanes,
+        firstContext: contextItem
+      };
+    } else {
+      // Append a new context item.
+      lastContextDependency = lastContextDependency.next = contextItem;
+    }
+  }
+
+  return value;
+}
+
+// replace it with a lightweight shim that only has the features we use.
+
+const AbortControllerLocal = typeof AbortController !== 'undefined' ? AbortController : // $FlowFixMe[missing-this-annot]
+// $FlowFixMe[prop-missing]
+function AbortControllerShim() {
+  const listeners = [];
+  const signal = this.signal = {
+    aborted: false,
+    addEventListener: (type, listener) => {
+      listeners.push(listener);
+    }
+  };
+
+  this.abort = () => {
+    signal.aborted = true;
+    listeners.forEach(listener => listener());
+  };
+} ; // Intentionally not named imports because Rollup would
+// use dynamic dispatch for CommonJS interop named imports.
+
+const scheduleCallback$1 = Scheduler.unstable_scheduleCallback,
+      NormalPriority = Scheduler.unstable_NormalPriority;
+const CacheContext = {
+  $$typeof: REACT_CONTEXT_TYPE,
+  // We don't use Consumer/Provider for Cache components. So we'll cheat.
+  Consumer: null,
+  Provider: null,
+  // We'll initialize these at the root.
+  _currentValue: null,
+  _currentValue2: null,
+  _threadCount: 0,
+  _defaultValue: null,
+  _globalName: null
+} ;
+// for retaining the cache once it is in use (retainCache), and releasing the cache
+// once it is no longer needed (releaseCache).
+
+
+function createCache() {
+
+  const cache = {
+    controller: new AbortControllerLocal(),
+    data: new Map(),
+    refCount: 0
+  };
+  return cache;
+}
+function retainCache(cache) {
+
+  cache.refCount++;
+} // Cleanup a cache instance, potentially freeing it if there are no more references
+
+function releaseCache(cache) {
+
+  cache.refCount--;
+
+  if (cache.refCount === 0) {
+    scheduleCallback$1(NormalPriority, () => {
+      cache.controller.abort();
+    });
+  }
+}
+function pushCacheProvider(workInProgress, cache) {
+
+  pushProvider(workInProgress, CacheContext, cache);
+}
+function popCacheProvider(workInProgress, cache) {
+
+  popProvider(CacheContext);
+}
+
+const ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig;
+const NoTransition = null;
+function requestCurrentTransition() {
+  return ReactCurrentBatchConfig$2.transition;
+} // When retrying a Suspense/Offscreen boundary, we restore the cache that was
+// used during the previous render by placing it here, on the stack.
+
+const resumedCache = createCursor(null); // During the render/synchronous commit phase, we don't actually process the
+
+function peekCacheFromPool() {
+  // If we're rendering inside a Suspense boundary that is currently hidden,
+  // we should use the same cache that we used during the previous render, if
+  // one exists.
+
+
+  const cacheResumedFromPreviousRender = resumedCache.current;
+
+  if (cacheResumedFromPreviousRender !== null) {
+    return cacheResumedFromPreviousRender;
+  } // Otherwise, check the root's cache pool.
+
+
+  const root = getWorkInProgressRoot();
+  const cacheFromRootCachePool = root.pooledCache;
+  return cacheFromRootCachePool;
+}
+
+function requestCacheFromPool(renderLanes) {
+  // Similar to previous function, except if there's not already a cache in the
+  // pool, we allocate a new one.
+  const cacheFromPool = peekCacheFromPool();
+
+  if (cacheFromPool !== null) {
+    return cacheFromPool;
+  } // Create a fresh cache and add it to the root cache pool. A cache can have
+  // multiple owners:
+  // - A cache pool that lives on the FiberRoot. This is where all fresh caches
+  //   are originally created (TODO: except during refreshes, until we implement
+  //   this correctly). The root takes ownership immediately when the cache is
+  //   created. Conceptually, root.pooledCache is an Option<Arc<Cache>> (owned),
+  //   and the return value of this function is a &Arc<Cache> (borrowed).
+  // - One of several fiber types: host root, cache boundary, suspense
+  //   component. These retain and release in the commit phase.
+
+
+  const root = getWorkInProgressRoot();
+  const freshCache = createCache();
+  root.pooledCache = freshCache;
+  retainCache(freshCache);
+
+  if (freshCache !== null) {
+    root.pooledCacheLanes |= renderLanes;
+  }
+
+  return freshCache;
+}
+function pushTransition(offscreenWorkInProgress, prevCachePool, newTransitions) {
+  {
+    if (prevCachePool === null) {
+      push(resumedCache, resumedCache.current);
+    } else {
+      push(resumedCache, prevCachePool.pool);
+    }
+  }
+}
+function popTransition(workInProgress, current) {
+  if (current !== null) {
+
+    {
+      pop(resumedCache);
+    }
+  }
+}
+function getSuspendedCache() {
+  // cache that would have been used to render fresh data during this render,
+  // if there was any, so that we can resume rendering with the same cache when
+  // we receive more data.
+
+
+  const cacheFromPool = peekCacheFromPool();
+
+  if (cacheFromPool === null) {
+    return null;
+  }
+
+  return {
+    // We must also save the parent, so that when we resume we can detect
+    // a refresh.
+    parent: CacheContext._currentValue ,
+    pool: cacheFromPool
+  };
+}
+function getOffscreenDeferredCache() {
+
+  const cacheFromPool = peekCacheFromPool();
+
+  if (cacheFromPool === null) {
+    return null;
+  }
+
+  return {
+    // We must also store the parent, so that when we resume we can detect
+    // a refresh.
+    parent: CacheContext._currentValue ,
+    pool: cacheFromPool
+  };
+}
+
+function markUpdate(workInProgress) {
+  // Tag the fiber with an update effect. This turns a Placement into
+  // a PlacementAndUpdate.
+  workInProgress.flags |= Update;
+}
+
+function markRef(workInProgress) {
+  workInProgress.flags |= Ref | RefStatic;
+}
+
+function appendAllChildren(parent, workInProgress, needsVisibilityToggle, isHidden) {
+  {
+    // We only have the top Fiber that was created but we need recurse down its
+    // children to find all the terminal nodes.
+    let node = workInProgress.child;
+
+    while (node !== null) {
+      if (node.tag === HostComponent || node.tag === HostText) {
+        appendInitialChild(parent, node.stateNode);
+      } else if (node.tag === HostPortal || (node.tag === HostSingleton )) ; else if (node.child !== null) {
+        node.child.return = node;
+        node = node.child;
+        continue;
+      }
+
+      if (node === workInProgress) {
+        return;
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+      while (node.sibling === null) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        if (node.return === null || node.return === workInProgress) {
+          return;
+        }
+
+        node = node.return;
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+      node.sibling.return = node.return;
+      node = node.sibling;
+    }
+  }
+} // An unfortunate fork of appendAllChildren because we have two different parent types.
+
+function updateHostComponent(current, workInProgress, type, newProps, renderLanes) {
+  {
+    // If we have an alternate, that means this is an update and we need to
+    // schedule a side-effect to do the updates.
+    const oldProps = current.memoizedProps;
+
+    if (oldProps === newProps) {
+      // In mutation mode, this is sufficient for a bailout because
+      // we won't touch this node even if children changed.
+      return;
+    }
+
+    markUpdate(workInProgress);
+  }
+} // This function must be called at the very end of the complete phase, because
+// it might throw to suspend, and if the resource immediately loads, the work
+// loop will resume rendering as if the work-in-progress completed. So it must
+// fully complete.
+// TODO: This should ideally move to begin phase, but currently the instance is
+// not created until the complete phase. For our existing use cases, host nodes
+// that suspend don't have children, so it doesn't matter. But that might not
+// always be true in the future.
+
+
+function preloadInstanceAndSuspendIfNeeded(workInProgress, type, props, renderLanes) {
+  {
+    // If this flag was set previously, we can remove it. The flag
+    // represents whether this particular set of props might ever need to
+    // suspend. The safest thing to do is for maySuspendCommit to always
+    // return true, but if the renderer is reasonably confident that the
+    // underlying resource won't be evicted, it can return false as a
+    // performance optimization.
+    workInProgress.flags &= ~MaySuspendCommit;
+    return;
+  } // Mark this fiber with a flag. This gets set on all host instances
+}
+
+function preloadResourceAndSuspendIfNeeded(workInProgress, resource, type, props, renderLanes) {
+  // This is a fork of preloadInstanceAndSuspendIfNeeded, but for resources.
+  if (!mayResourceSuspendCommit(resource)) {
+    workInProgress.flags &= ~MaySuspendCommit;
+    return;
+  }
+
+  workInProgress.flags |= MaySuspendCommit;
+  const rootRenderLanes = getWorkInProgressRootRenderLanes();
+
+  if (!includesOnlyNonUrgentLanes(rootRenderLanes)) ; else {
+    const isReady = preloadResource(resource);
+
+    if (!isReady) {
+      if (shouldRemainOnPreviousScreen()) {
+        workInProgress.flags |= ShouldSuspendCommit;
+      } else {
+        suspendCommit();
+      }
+    }
+  }
+}
+
+function scheduleRetryEffect(workInProgress, retryQueue) {
+  const wakeables = retryQueue;
+
+  if (wakeables !== null) {
+    // Schedule an effect to attach a retry listener to the promise.
+    // TODO: Move to passive phase
+    workInProgress.flags |= Update;
+  } else {
+    // This boundary suspended, but no wakeables were added to the retry
+    // queue. Check if the renderer suspended commit. If so, this means
+    // that once the fallback is committed, we can immediately retry
+    // rendering again, because rendering wasn't actually blocked. Only
+    // the commit phase.
+    // TODO: Consider a model where we always schedule an immediate retry, even
+    // for normal Suspense. That way the retry can partially render up to the
+    // first thing that suspends.
+    if (workInProgress.flags & ScheduleRetry) {
+      const retryLane = // TODO: This check should probably be moved into claimNextRetryLane
+      // I also suspect that we need some further consolidation of offscreen
+      // and retry lanes.
+      workInProgress.tag !== OffscreenComponent ? claimNextRetryLane() : OffscreenLane;
+      workInProgress.lanes = mergeLanes(workInProgress.lanes, retryLane);
+    }
+  }
+}
+
+function updateHostText(current, workInProgress, oldText, newText) {
+  {
+    // If the text differs, mark it as an update. All the work in done in commitWork.
+    if (oldText !== newText) {
+      markUpdate(workInProgress);
+    }
+  }
+}
+
+function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
+  if (getIsHydrating()) {
+    // If we're hydrating, we should consume as many items as we can
+    // so we don't leave any behind.
+    return;
+  }
+
+  switch (renderState.tailMode) {
+    case 'hidden':
+      {
+        // Any insertions at the end of the tail list after this point
+        // should be invisible. If there are already mounted boundaries
+        // anything before them are not considered for collapsing.
+        // Therefore we need to go through the whole tail to find if
+        // there are any.
+        let tailNode = renderState.tail;
+        let lastTailNode = null;
+
+        while (tailNode !== null) {
+          if (tailNode.alternate !== null) {
+            lastTailNode = tailNode;
+          }
+
+          tailNode = tailNode.sibling;
+        } // Next we're simply going to delete all insertions after the
+        // last rendered item.
+
+
+        if (lastTailNode === null) {
+          // All remaining items in the tail are insertions.
+          renderState.tail = null;
+        } else {
+          // Detach the insertion after the last node that was already
+          // inserted.
+          lastTailNode.sibling = null;
+        }
+
+        break;
+      }
+
+    case 'collapsed':
+      {
+        // Any insertions at the end of the tail list after this point
+        // should be invisible. If there are already mounted boundaries
+        // anything before them are not considered for collapsing.
+        // Therefore we need to go through the whole tail to find if
+        // there are any.
+        let tailNode = renderState.tail;
+        let lastTailNode = null;
+
+        while (tailNode !== null) {
+          if (tailNode.alternate !== null) {
+            lastTailNode = tailNode;
+          }
+
+          tailNode = tailNode.sibling;
+        } // Next we're simply going to delete all insertions after the
+        // last rendered item.
+
+
+        if (lastTailNode === null) {
+          // All remaining items in the tail are insertions.
+          if (!hasRenderedATailFallback && renderState.tail !== null) {
+            // We suspended during the head. We want to show at least one
+            // row at the tail. So we'll keep on and cut off the rest.
+            renderState.tail.sibling = null;
+          } else {
+            renderState.tail = null;
+          }
+        } else {
+          // Detach the insertion after the last node that was already
+          // inserted.
+          lastTailNode.sibling = null;
+        }
+
+        break;
+      }
+  }
+}
+
+function bubbleProperties(completedWork) {
+  const didBailout = completedWork.alternate !== null && completedWork.alternate.child === completedWork.child;
+  let newChildLanes = NoLanes;
+  let subtreeFlags = NoFlags$1;
+
+  if (!didBailout) {
+    // Bubble up the earliest expiration time.
+    if ((completedWork.mode & ProfileMode) !== NoMode) {
+      // In profiling mode, resetChildExpirationTime is also used to reset
+      // profiler durations.
+      let actualDuration = completedWork.actualDuration;
+      let treeBaseDuration = completedWork.selfBaseDuration;
+      let 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 {
+      let child = completedWork.child;
+
+      while (child !== null) {
+        newChildLanes = mergeLanes(newChildLanes, mergeLanes(child.lanes, child.childLanes));
+        subtreeFlags |= child.subtreeFlags;
+        subtreeFlags |= child.flags; // Update the return pointer so the tree is consistent. This is a code
+        // smell because it assumes the commit phase is never concurrent with
+        // the render phase. Will address during refactor to alternate model.
+
+        child.return = completedWork;
+        child = child.sibling;
+      }
+    }
+
+    completedWork.subtreeFlags |= subtreeFlags;
+  } else {
+    // Bubble up the earliest expiration time.
+    if ((completedWork.mode & ProfileMode) !== NoMode) {
+      // In profiling mode, resetChildExpirationTime is also used to reset
+      // profiler durations.
+      let treeBaseDuration = completedWork.selfBaseDuration;
+      let child = completedWork.child;
+
+      while (child !== null) {
+        newChildLanes = mergeLanes(newChildLanes, mergeLanes(child.lanes, child.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 |= child.subtreeFlags & StaticMask;
+        subtreeFlags |= child.flags & StaticMask; // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+
+        treeBaseDuration += child.treeBaseDuration;
+        child = child.sibling;
+      }
+
+      completedWork.treeBaseDuration = treeBaseDuration;
+    } else {
+      let child = completedWork.child;
+
+      while (child !== null) {
+        newChildLanes = mergeLanes(newChildLanes, mergeLanes(child.lanes, child.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 |= child.subtreeFlags & StaticMask;
+        subtreeFlags |= child.flags & StaticMask; // Update the return pointer so the tree is consistent. This is a code
+        // smell because it assumes the commit phase is never concurrent with
+        // the render phase. Will address during refactor to alternate model.
+
+        child.return = completedWork;
+        child = child.sibling;
+      }
+    }
+
+    completedWork.subtreeFlags |= subtreeFlags;
+  }
+
+  completedWork.childLanes = newChildLanes;
+  return didBailout;
+}
+
+function completeDehydratedSuspenseBoundary(current, workInProgress, nextState) {
+  if (hasUnhydratedTailNodes() && (workInProgress.mode & ConcurrentMode) !== NoMode && (workInProgress.flags & DidCapture) === NoFlags$1) {
+    warnIfUnhydratedTailNodes();
+    resetHydrationState();
+    workInProgress.flags |= ForceClientRender | DidCapture;
+    return false;
+  }
+
+  const wasHydrated = popHydrationState(workInProgress);
+
+  if (nextState !== null && nextState.dehydrated !== null) {
+    // We might be inside a hydration state the first time we're picking up this
+    // Suspense boundary, and also after we've reentered it for further hydration.
+    if (current === null) {
+      if (!wasHydrated) {
+        throw Error(formatProdErrorMessage(318));
+      }
+
+      prepareToHydrateHostSuspenseInstance(workInProgress);
+      bubbleProperties(workInProgress);
+
+      {
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          const isTimedOutSuspense = nextState !== null;
+
+          if (isTimedOutSuspense) {
+            // Don't count time spent in a timed out Suspense subtree as part of the base duration.
+            const primaryChildFragment = workInProgress.child;
+
+            if (primaryChildFragment !== null) {
+              // $FlowFixMe[unsafe-arithmetic] Flow doesn't support type casting in combination with the -= operator
+              workInProgress.treeBaseDuration -= primaryChildFragment.treeBaseDuration;
+            }
+          }
+        }
+      }
+
+      return false;
+    } else {
+      // We might have reentered this boundary to hydrate it. If so, we need to reset the hydration
+      // state since we're now exiting out of it. popHydrationState doesn't do that for us.
+      resetHydrationState();
+
+      if ((workInProgress.flags & DidCapture) === NoFlags$1) {
+        // This boundary did not suspend so it's now hydrated and unsuspended.
+        workInProgress.memoizedState = null;
+      } // If nothing suspended, we need to schedule an effect to mark this boundary
+      // as having hydrated so events know that they're free to be invoked.
+      // It's also a signal to replay events and the suspense callback.
+      // If something suspended, schedule an effect to attach retry listeners.
+      // So we might as well always mark this.
+
+
+      workInProgress.flags |= Update;
+      bubbleProperties(workInProgress);
+
+      {
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          const isTimedOutSuspense = nextState !== null;
+
+          if (isTimedOutSuspense) {
+            // Don't count time spent in a timed out Suspense subtree as part of the base duration.
+            const primaryChildFragment = workInProgress.child;
+
+            if (primaryChildFragment !== null) {
+              // $FlowFixMe[unsafe-arithmetic] Flow doesn't support type casting in combination with the -= operator
+              workInProgress.treeBaseDuration -= primaryChildFragment.treeBaseDuration;
+            }
+          }
+        }
+      }
+
+      return false;
+    }
+  } else {
+    // Successfully completed this tree. If this was a forced client render,
+    // there may have been recoverable errors during first hydration
+    // attempt. If so, add them to a queue so we can log them in the
+    // commit phase.
+    upgradeHydrationErrorsToRecoverable(); // Fall through to normal Suspense path
+
+    return true;
+  }
+}
+
+function completeWork(current, workInProgress, renderLanes) {
+  const newProps = workInProgress.pendingProps; // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
+
+  popTreeContext(workInProgress);
+
+  switch (workInProgress.tag) {
+    case IndeterminateComponent:
+    case LazyComponent:
+    case SimpleMemoComponent:
+    case FunctionComponent:
+    case ForwardRef:
+    case Fragment:
+    case Mode:
+    case Profiler:
+    case ContextConsumer:
+    case MemoComponent:
+      bubbleProperties(workInProgress);
+      return null;
+
+    case ClassComponent:
+      {
+        const Component = workInProgress.type;
+
+        if (isContextProvider(Component)) {
+          popContext();
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
+
+    case HostRoot:
+      {
+        const fiberRoot = workInProgress.stateNode;
+
+        {
+          let previousCache = null;
+
+          if (current !== null) {
+            previousCache = current.memoizedState.cache;
+          }
+
+          const cache = workInProgress.memoizedState.cache;
+
+          if (cache !== previousCache) {
+            // Run passive effects to retain/release the cache.
+            workInProgress.flags |= Passive$1;
+          }
+
+          popCacheProvider();
+        }
+        popHostContainer();
+        popTopLevelContextObject();
+
+        if (fiberRoot.pendingContext) {
+          fiberRoot.context = fiberRoot.pendingContext;
+          fiberRoot.pendingContext = null;
+        }
+
+        if (current === null || current.child === null) {
+          // If we hydrated, pop so that we can delete any remaining children
+          // that weren't hydrated.
+          const wasHydrated = popHydrationState(workInProgress);
+
+          if (wasHydrated) {
+            // If we hydrated, then we'll need to schedule an update for
+            // the commit side-effects on the root.
+            markUpdate(workInProgress);
+          } else {
+            if (current !== null) {
+              const prevState = current.memoizedState;
+
+              if ( // Check if this is a client root
+              !prevState.isDehydrated || // Check if we reverted to client rendering (e.g. due to an error)
+              (workInProgress.flags & ForceClientRender) !== NoFlags$1) {
+                // Schedule an effect to clear this container at the start of the
+                // next commit. This handles the case of React rendering into a
+                // container with previous children. It's also safe to do for
+                // updates too, because current.child would only be null if the
+                // previous render was null (so the container would already
+                // be empty).
+                workInProgress.flags |= Snapshot; // If this was a forced client render, there may have been
+                // recoverable errors during first hydration attempt. If so, add
+                // them to a queue so we can log them in the commit phase.
+
+                upgradeHydrationErrorsToRecoverable();
+              }
+            }
+          }
+        }
+        bubbleProperties(workInProgress);
+
+        return null;
+      }
+
+    case HostHoistable:
+      {
+        {
+          const nextResource = workInProgress.memoizedState;
+
+          if (current === null) {
+            // We are mounting and must Update this Hoistable in this commit
+            // @TODO refactor this block to create the instance here in complete
+            // phase if we are not hydrating.
+            markUpdate(workInProgress);
+
+            if (workInProgress.ref !== null) {
+              markRef(workInProgress);
+            }
+
+            if (nextResource !== null) {
+              // This is a Hoistable Resource
+              // This must come at the very end of the complete phase.
+              bubbleProperties(workInProgress);
+              preloadResourceAndSuspendIfNeeded(workInProgress, nextResource);
+              return null;
+            } else {
+              // This is a Hoistable Instance
+              // This must come at the very end of the complete phase.
+              bubbleProperties(workInProgress);
+              preloadInstanceAndSuspendIfNeeded(workInProgress);
+              return null;
+            }
+          } else {
+            // We are updating.
+            const currentResource = current.memoizedState;
+
+            if (nextResource !== currentResource) {
+              // We are transitioning to, from, or between Hoistable Resources
+              // and require an update
+              markUpdate(workInProgress);
+            }
+
+            if (current.ref !== workInProgress.ref) {
+              markRef(workInProgress);
+            }
+
+            if (nextResource !== null) {
+              // This is a Hoistable Resource
+              // This must come at the very end of the complete phase.
+              bubbleProperties(workInProgress);
+
+              if (nextResource === currentResource) {
+                workInProgress.flags &= ~MaySuspendCommit;
+              } else {
+                preloadResourceAndSuspendIfNeeded(workInProgress, nextResource);
+              }
+
+              return null;
+            } else {
+              // This is a Hoistable Instance
+              // We may have props to update on the Hoistable instance.
+              {
+                const oldProps = current.memoizedProps;
+
+                if (oldProps !== newProps) {
+                  markUpdate(workInProgress);
+                }
+              } // This must come at the very end of the complete phase.
+
+
+              bubbleProperties(workInProgress);
+              preloadInstanceAndSuspendIfNeeded(workInProgress);
+              return null;
+            }
+          }
+        } // Fall through
+
+      }
+
+    case HostSingleton:
+      {
+        {
+          popHostContext(workInProgress);
+          const rootContainerInstance = getRootHostContainer();
+          const type = workInProgress.type;
+
+          if (current !== null && workInProgress.stateNode != null) {
+            {
+              const oldProps = current.memoizedProps;
+
+              if (oldProps !== newProps) {
+                markUpdate(workInProgress);
+              }
+            }
+
+            if (current.ref !== workInProgress.ref) {
+              markRef(workInProgress);
+            }
+          } else {
+            if (!newProps) {
+              if (workInProgress.stateNode === null) {
+                throw Error(formatProdErrorMessage(166));
+              } // This can happen when we abort work.
+
+
+              bubbleProperties(workInProgress);
+              return null;
+            }
+
+            const currentHostContext = getHostContext();
+            const wasHydrated = popHydrationState(workInProgress);
+            let instance;
+
+            if (wasHydrated) {
+              // We ignore the boolean indicating there is an updateQueue because
+              // it is used only to set text children and HostSingletons do not
+              // use them.
+              prepareToHydrateHostInstance(workInProgress, currentHostContext);
+              instance = workInProgress.stateNode;
+            } else {
+              instance = resolveSingletonInstance(type, newProps, rootContainerInstance);
+              workInProgress.stateNode = instance;
+              markUpdate(workInProgress);
+            }
+
+            if (workInProgress.ref !== null) {
+              // If there is a ref on a host node we need to schedule a callback
+              markRef(workInProgress);
+            }
+          }
+
+          bubbleProperties(workInProgress);
+          return null;
+        } // Fall through
+
+      }
+
+    case HostComponent:
+      {
+        popHostContext(workInProgress);
+        const type = workInProgress.type;
+
+        if (current !== null && workInProgress.stateNode != null) {
+          updateHostComponent(current, workInProgress, type, newProps);
+
+          if (current.ref !== workInProgress.ref) {
+            markRef(workInProgress);
+          }
+        } else {
+          if (!newProps) {
+            if (workInProgress.stateNode === null) {
+              throw Error(formatProdErrorMessage(166));
+            } // This can happen when we abort work.
+
+
+            bubbleProperties(workInProgress);
+            return null;
+          }
+
+          const currentHostContext = getHostContext(); // TODO: Move createInstance to beginWork and keep it on a context
+          // "stack" as the parent. Then append children as we go in beginWork
+          // or completeWork depending on whether we want to add them top->down or
+          // bottom->up. Top->down is faster in IE11.
+
+          const wasHydrated = popHydrationState(workInProgress);
+
+          if (wasHydrated) {
+            // TODO: Move this and createInstance step into the beginPhase
+            // to consolidate.
+            prepareToHydrateHostInstance(workInProgress, currentHostContext);
+          } else {
+            const rootContainerInstance = getRootHostContainer();
+            const instance = createInstance(type, newProps, rootContainerInstance, currentHostContext, workInProgress); // TODO: For persistent renderers, we should pass children as part
+            // of the initial instance creation
+
+            appendAllChildren(instance, workInProgress);
+            workInProgress.stateNode = instance; // Certain renderers require commit-time effects for initial mount.
+            // (eg DOM renderer supports auto-focus for certain elements).
+            // Make sure such renderers get scheduled for later work.
+
+            if (finalizeInitialChildren(instance, type, newProps)) {
+              markUpdate(workInProgress);
+            }
+          }
+
+          if (workInProgress.ref !== null) {
+            // If there is a ref on a host node we need to schedule a callback
+            markRef(workInProgress);
+          }
+        }
+
+        bubbleProperties(workInProgress); // This must come at the very end of the complete phase, because it might
+        // throw to suspend, and if the resource immediately loads, the work loop
+        // will resume rendering as if the work-in-progress completed. So it must
+        // fully complete.
+
+        preloadInstanceAndSuspendIfNeeded(workInProgress);
+        return null;
+      }
+
+    case HostText:
+      {
+        const newText = newProps;
+
+        if (current && workInProgress.stateNode != null) {
+          const oldText = current.memoizedProps; // If we have an alternate, that means this is an update and we need
+          // to schedule a side-effect to do the updates.
+
+          updateHostText(current, workInProgress, oldText, newText);
+        } else {
+          if (typeof newText !== 'string') {
+            if (workInProgress.stateNode === null) {
+              throw Error(formatProdErrorMessage(166));
+            } // This can happen when we abort work.
+
+          }
+
+          const rootContainerInstance = getRootHostContainer();
+          const currentHostContext = getHostContext();
+          const wasHydrated = popHydrationState(workInProgress);
+
+          if (wasHydrated) {
+            if (prepareToHydrateHostTextInstance(workInProgress)) {
+              markUpdate(workInProgress);
+            }
+          } else {
+            workInProgress.stateNode = createTextInstance(newText, rootContainerInstance, currentHostContext, workInProgress);
+          }
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
+
+    case SuspenseComponent:
+      {
+        popSuspenseHandler(workInProgress);
+        const nextState = workInProgress.memoizedState; // Special path for dehydrated boundaries. We may eventually move this
+        // to its own fiber type so that we can add other kinds of hydration
+        // boundaries that aren't associated with a Suspense tree. In anticipation
+        // of such a refactor, all the hydration logic is contained in
+        // this branch.
+
+        if (current === null || current.memoizedState !== null && current.memoizedState.dehydrated !== null) {
+          const fallthroughToNormalSuspensePath = completeDehydratedSuspenseBoundary(current, workInProgress, nextState);
+
+          if (!fallthroughToNormalSuspensePath) {
+            if (workInProgress.flags & ForceClientRender) {
+              // Special case. There were remaining unhydrated nodes. We treat
+              // this as a mismatch. Revert to client rendering.
+              return workInProgress;
+            } else {
+              // Did not finish hydrating, either because this is the initial
+              // render or because something suspended.
+              return null;
+            }
+          } // Continue with the normal Suspense path.
+
+        }
+
+        if ((workInProgress.flags & DidCapture) !== NoFlags$1) {
+          // Something suspended. Re-render with the fallback children.
+          workInProgress.lanes = renderLanes; // Do not reset the effect list.
+
+          if ((workInProgress.mode & ProfileMode) !== NoMode) {
+            transferActualDuration(workInProgress);
+          } // Don't bubble properties in this case.
+
+
+          return workInProgress;
+        }
+
+        const nextDidTimeout = nextState !== null;
+        const prevDidTimeout = current !== null && current.memoizedState !== null;
+
+        if (nextDidTimeout) {
+          const offscreenFiber = workInProgress.child;
+          let previousCache = null;
+
+          if (offscreenFiber.alternate !== null && offscreenFiber.alternate.memoizedState !== null && offscreenFiber.alternate.memoizedState.cachePool !== null) {
+            previousCache = offscreenFiber.alternate.memoizedState.cachePool.pool;
+          }
+
+          let cache = null;
+
+          if (offscreenFiber.memoizedState !== null && offscreenFiber.memoizedState.cachePool !== null) {
+            cache = offscreenFiber.memoizedState.cachePool.pool;
+          }
+
+          if (cache !== previousCache) {
+            // Run passive effects to retain/release the cache.
+            offscreenFiber.flags |= Passive$1;
+          }
+        } // If the suspended state of the boundary changes, we need to schedule
+        // a passive effect, which is when we process the transitions
+
+
+        if (nextDidTimeout !== prevDidTimeout) {
+          // an effect to toggle the subtree's visibility. When we switch from
+          // fallback -> primary, the inner Offscreen fiber schedules this effect
+          // as part of its normal complete phase. But when we switch from
+          // primary -> fallback, the inner Offscreen fiber does not have a complete
+          // phase. So we need to schedule its effect here.
+          //
+          // We also use this flag to connect/disconnect the effects, but the same
+          // logic applies: when re-connecting, the Offscreen fiber's complete
+          // phase will handle scheduling the effect. It's only when the fallback
+          // is active that we have to do anything special.
+
+
+          if (nextDidTimeout) {
+            const offscreenFiber = workInProgress.child;
+            offscreenFiber.flags |= Visibility;
+          }
+        }
+
+        const retryQueue = workInProgress.updateQueue;
+        scheduleRetryEffect(workInProgress, retryQueue);
+
+        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.
+              const primaryChildFragment = workInProgress.child;
+
+              if (primaryChildFragment !== null) {
+                // $FlowFixMe[unsafe-arithmetic] Flow doesn't support type casting in combination with the -= operator
+                workInProgress.treeBaseDuration -= primaryChildFragment.treeBaseDuration;
+              }
+            }
+          }
+        }
+
+        return null;
+      }
+
+    case HostPortal:
+      popHostContainer();
+
+      if (current === null) {
+        preparePortalMount(workInProgress.stateNode.containerInfo);
+      }
+
+      bubbleProperties(workInProgress);
+      return null;
+
+    case ContextProvider:
+      // Pop provider fiber
+      const context = workInProgress.type._context;
+      popProvider(context);
+      bubbleProperties(workInProgress);
+      return null;
+
+    case IncompleteClassComponent:
+      {
+        // Same as class component case. I put it down here so that the tags are
+        // sequential to ensure this switch is compiled to a jump table.
+        const Component = workInProgress.type;
+
+        if (isContextProvider(Component)) {
+          popContext();
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
+
+    case SuspenseListComponent:
+      {
+        popSuspenseListContext();
+        const renderState = workInProgress.memoizedState;
+
+        if (renderState === null) {
+          // We're running in the default, "independent" mode.
+          // We don't do anything in this mode.
+          bubbleProperties(workInProgress);
+          return null;
+        }
+
+        let didSuspendAlready = (workInProgress.flags & DidCapture) !== NoFlags$1;
+        const renderedTail = renderState.rendering;
+
+        if (renderedTail === null) {
+          // We just rendered the head.
+          if (!didSuspendAlready) {
+            // This is the first pass. We need to figure out if anything is still
+            // suspended in the rendered set.
+            // If new content unsuspended, but there's still some content that
+            // didn't. Then we need to do a second pass that forces everything
+            // to keep showing their fallbacks.
+            // We might be suspended if something in this render pass suspended, or
+            // something in the previous committed pass suspended. Otherwise,
+            // there's no chance so we can skip the expensive call to
+            // findFirstSuspended.
+            const cannotBeSuspended = renderHasNotSuspendedYet() && (current === null || (current.flags & DidCapture) === NoFlags$1);
+
+            if (!cannotBeSuspended) {
+              let row = workInProgress.child;
+
+              while (row !== null) {
+                const suspended = findFirstSuspended(row);
+
+                if (suspended !== null) {
+                  didSuspendAlready = true;
+                  workInProgress.flags |= DidCapture;
+                  cutOffTailIfNeeded(renderState, false); // If this is a newly suspended tree, it might not get committed as
+                  // part of the second pass. In that case nothing will subscribe to
+                  // its thenables. Instead, we'll transfer its thenables to the
+                  // SuspenseList so that it can retry if they resolve.
+                  // There might be multiple of these in the list but since we're
+                  // going to wait for all of them anyway, it doesn't really matter
+                  // which ones gets to ping. In theory we could get clever and keep
+                  // track of how many dependencies remain but it gets tricky because
+                  // in the meantime, we can add/remove/change items and dependencies.
+                  // We might bail out of the loop before finding any but that
+                  // doesn't matter since that means that the other boundaries that
+                  // we did find already has their listeners attached.
+
+                  const retryQueue = suspended.updateQueue;
+                  workInProgress.updateQueue = retryQueue;
+                  scheduleRetryEffect(workInProgress, retryQueue); // Rerender the whole list, but this time, we'll force fallbacks
+                  // to stay in place.
+                  // Reset the effect flags before doing the second pass since that's now invalid.
+                  // Reset the child fibers to their original state.
+
+                  workInProgress.subtreeFlags = NoFlags$1;
+                  resetChildFibers(workInProgress, renderLanes); // Set up the Suspense List Context to force suspense and
+                  // immediately rerender the children.
+
+                  pushSuspenseListContext(workInProgress, setShallowSuspenseListContext(suspenseStackCursor.current, ForceSuspenseFallback)); // Don't bubble properties in this case.
+
+                  return workInProgress.child;
+                }
+
+                row = row.sibling;
+              }
+            }
+
+            if (renderState.tail !== null && now$1() > getRenderTargetTime()) {
+              // We have already passed our CPU deadline but we still have rows
+              // left in the tail. We'll just give up further attempts to render
+              // the main content and only render fallbacks.
+              workInProgress.flags |= DidCapture;
+              didSuspendAlready = true;
+              cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
+              // to get it started back up to attempt the next item. While in terms
+              // of priority this work has the same priority as this current render,
+              // it's not part of the same transition once the transition has
+              // committed. If it's sync, we still want to yield so that it can be
+              // painted. Conceptually, this is really the same as pinging.
+              // We can use any RetryLane even if it's the one currently rendering
+              // since we're leaving it behind on this node.
+
+              workInProgress.lanes = SomeRetryLane;
+            }
+          } else {
+            cutOffTailIfNeeded(renderState, false);
+          } // Next we're going to render the tail.
+
+        } else {
+          // Append the rendered row to the child list.
+          if (!didSuspendAlready) {
+            const suspended = findFirstSuspended(renderedTail);
+
+            if (suspended !== null) {
+              workInProgress.flags |= DidCapture;
+              didSuspendAlready = true; // Ensure we transfer the update queue to the parent so that it doesn't
+              // get lost if this row ends up dropped during a second pass.
+
+              const retryQueue = suspended.updateQueue;
+              workInProgress.updateQueue = retryQueue;
+              scheduleRetryEffect(workInProgress, retryQueue);
+              cutOffTailIfNeeded(renderState, true); // This might have been modified.
+
+              if (renderState.tail === null && renderState.tailMode === 'hidden' && !renderedTail.alternate && !getIsHydrating() // We don't cut it if we're hydrating.
+              ) {
+                  // We're done.
+                  bubbleProperties(workInProgress);
+                  return null;
+                }
+            } else if ( // The time it took to render last row is greater than the remaining
+            // time we have to render. So rendering one more row would likely
+            // exceed it.
+            now$1() * 2 - renderState.renderingStartTime > getRenderTargetTime() && renderLanes !== OffscreenLane) {
+              // We have now passed our CPU deadline and we'll just give up further
+              // attempts to render the main content and only render fallbacks.
+              // The assumption is that this is usually faster.
+              workInProgress.flags |= DidCapture;
+              didSuspendAlready = true;
+              cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
+              // to get it started back up to attempt the next item. While in terms
+              // of priority this work has the same priority as this current render,
+              // it's not part of the same transition once the transition has
+              // committed. If it's sync, we still want to yield so that it can be
+              // painted. Conceptually, this is really the same as pinging.
+              // We can use any RetryLane even if it's the one currently rendering
+              // since we're leaving it behind on this node.
+
+              workInProgress.lanes = SomeRetryLane;
+            }
+          }
+
+          if (renderState.isBackwards) {
+            // The effect list of the backwards tail will have been added
+            // to the end. This breaks the guarantee that life-cycles fire in
+            // sibling order but that isn't a strong guarantee promised by React.
+            // Especially since these might also just pop in during future commits.
+            // Append to the beginning of the list.
+            renderedTail.sibling = workInProgress.child;
+            workInProgress.child = renderedTail;
+          } else {
+            const previousSibling = renderState.last;
+
+            if (previousSibling !== null) {
+              previousSibling.sibling = renderedTail;
+            } else {
+              workInProgress.child = renderedTail;
+            }
+
+            renderState.last = renderedTail;
+          }
+        }
+
+        if (renderState.tail !== null) {
+          // We still have tail rows to render.
+          // Pop a row.
+          const next = renderState.tail;
+          renderState.rendering = next;
+          renderState.tail = next.sibling;
+          renderState.renderingStartTime = now$1();
+          next.sibling = null; // Restore the context.
+          // TODO: We can probably just avoid popping it instead and only
+          // setting it the first time we go from not suspended to suspended.
+
+          let suspenseContext = suspenseStackCursor.current;
+
+          if (didSuspendAlready) {
+            suspenseContext = setShallowSuspenseListContext(suspenseContext, ForceSuspenseFallback);
+          } else {
+            suspenseContext = setDefaultShallowSuspenseListContext(suspenseContext);
+          }
+
+          pushSuspenseListContext(workInProgress, suspenseContext); // Do a pass over the next row.
+          // Don't bubble properties in this case.
+
+          return next;
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
+
+    case ScopeComponent:
+      {
+
+        break;
+      }
+
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      {
+        popSuspenseHandler(workInProgress);
+        popHiddenContext();
+        const nextState = workInProgress.memoizedState;
+        const nextIsHidden = nextState !== null; // Schedule a Visibility effect if the visibility has changed
+
+        {
+          if (current !== null) {
+            const prevState = current.memoizedState;
+            const prevIsHidden = prevState !== null;
+
+            if (prevIsHidden !== nextIsHidden) {
+              workInProgress.flags |= Visibility;
+            }
+          } else {
+            // On initial mount, we only need a Visibility effect if the tree
+            // is hidden.
+            if (nextIsHidden) {
+              workInProgress.flags |= Visibility;
+            }
+          }
+        }
+
+        if (!nextIsHidden || (workInProgress.mode & ConcurrentMode) === NoMode) {
+          bubbleProperties(workInProgress);
+        } else {
+          // Don't bubble properties for hidden children unless we're rendering
+          // at offscreen priority.
+          if (includesSomeLane(renderLanes, OffscreenLane) && // Also don't bubble if the tree suspended
+          (workInProgress.flags & DidCapture) === NoLanes) {
+            bubbleProperties(workInProgress); // Check if there was an insertion or update in the hidden subtree.
+            // If so, we need to hide those nodes in the commit phase, so
+            // schedule a visibility effect.
+
+            if (workInProgress.subtreeFlags & (Placement | Update)) {
+              workInProgress.flags |= Visibility;
+            }
+          }
+        }
+
+        const offscreenQueue = workInProgress.updateQueue;
+
+        if (offscreenQueue !== null) {
+          const retryQueue = offscreenQueue.retryQueue;
+          scheduleRetryEffect(workInProgress, retryQueue);
+        }
+
+        {
+          let previousCache = null;
+
+          if (current !== null && current.memoizedState !== null && current.memoizedState.cachePool !== null) {
+            previousCache = current.memoizedState.cachePool.pool;
+          }
+
+          let cache = null;
+
+          if (workInProgress.memoizedState !== null && workInProgress.memoizedState.cachePool !== null) {
+            cache = workInProgress.memoizedState.cachePool.pool;
+          }
+
+          if (cache !== previousCache) {
+            // Run passive effects to retain/release the cache.
+            workInProgress.flags |= Passive$1;
+          }
+        }
+
+        popTransition(workInProgress, current);
+        return null;
+      }
+
+    case CacheComponent:
+      {
+        {
+          let previousCache = null;
+
+          if (current !== null) {
+            previousCache = current.memoizedState.cache;
+          }
+
+          const cache = workInProgress.memoizedState.cache;
+
+          if (cache !== previousCache) {
+            // Run passive effects to retain/release the cache.
+            workInProgress.flags |= Passive$1;
+          }
+
+          popCacheProvider();
+          bubbleProperties(workInProgress);
+        }
+
+        return null;
+      }
+
+    case TracingMarkerComponent:
+      {
+
+        return null;
+      }
+  }
+
+  throw Error(formatProdErrorMessage(156, workInProgress.tag));
+}
+
+function unwindWork(current, workInProgress, renderLanes) {
+  // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
+  popTreeContext(workInProgress);
+
+  switch (workInProgress.tag) {
+    case ClassComponent:
+      {
+        const Component = workInProgress.type;
+
+        if (isContextProvider(Component)) {
+          popContext();
+        }
+
+        const flags = workInProgress.flags;
+
+        if (flags & ShouldCapture) {
+          workInProgress.flags = flags & ~ShouldCapture | DidCapture;
+
+          if ((workInProgress.mode & ProfileMode) !== NoMode) {
+            transferActualDuration(workInProgress);
+          }
+
+          return workInProgress;
+        }
+
+        return null;
+      }
+
+    case HostRoot:
+      {
+
+        {
+          popCacheProvider();
+        }
+        popHostContainer();
+        popTopLevelContextObject();
+        const flags = workInProgress.flags;
+
+        if ((flags & ShouldCapture) !== NoFlags$1 && (flags & DidCapture) === NoFlags$1) {
+          // There was an error during render that wasn't captured by a suspense
+          // boundary. Do a second pass on the root to unmount the children.
+          workInProgress.flags = flags & ~ShouldCapture | DidCapture;
+          return workInProgress;
+        } // We unwound to the root without completing it. Exit.
+
+
+        return null;
+      }
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      {
+        // TODO: popHydrationState
+        popHostContext(workInProgress);
+        return null;
+      }
+
+    case SuspenseComponent:
+      {
+        popSuspenseHandler(workInProgress);
+        const suspenseState = workInProgress.memoizedState;
+
+        if (suspenseState !== null && suspenseState.dehydrated !== null) {
+          if (workInProgress.alternate === null) {
+            throw Error(formatProdErrorMessage(340));
+          }
+
+          resetHydrationState();
+        }
+
+        const flags = workInProgress.flags;
+
+        if (flags & ShouldCapture) {
+          workInProgress.flags = flags & ~ShouldCapture | DidCapture; // Captured a suspense effect. Re-render the boundary.
+
+          if ((workInProgress.mode & ProfileMode) !== NoMode) {
+            transferActualDuration(workInProgress);
+          }
+
+          return workInProgress;
+        }
+
+        return null;
+      }
+
+    case SuspenseListComponent:
+      {
+        popSuspenseListContext(); // SuspenseList doesn't actually catch anything. It should've been
+        // caught by a nested boundary. If not, it should bubble through.
+
+        return null;
+      }
+
+    case HostPortal:
+      popHostContainer();
+      return null;
+
+    case ContextProvider:
+      const context = workInProgress.type._context;
+      popProvider(context);
+      return null;
+
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      {
+        popSuspenseHandler(workInProgress);
+        popHiddenContext();
+        popTransition(workInProgress, current);
+        const flags = workInProgress.flags;
+
+        if (flags & ShouldCapture) {
+          workInProgress.flags = flags & ~ShouldCapture | DidCapture; // Captured a suspense effect. Re-render the boundary.
+
+          if ((workInProgress.mode & ProfileMode) !== NoMode) {
+            transferActualDuration(workInProgress);
+          }
+
+          return workInProgress;
+        }
+
+        return null;
+      }
+
+    case CacheComponent:
+      {
+        popCacheProvider();
+      }
+
+      return null;
+
+    case TracingMarkerComponent:
+
+      return null;
+
+    default:
+      return null;
+  }
+}
+
+function unwindInterruptedWork(current, interruptedWork, renderLanes) {
+  // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
+  popTreeContext(interruptedWork);
+
+  switch (interruptedWork.tag) {
+    case ClassComponent:
+      {
+        const childContextTypes = interruptedWork.type.childContextTypes;
+
+        if (childContextTypes !== null && childContextTypes !== undefined) {
+          popContext();
+        }
+
+        break;
+      }
+
+    case HostRoot:
+      {
+
+        {
+          popCacheProvider();
+        }
+        popHostContainer();
+        popTopLevelContextObject();
+        break;
+      }
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      {
+        popHostContext(interruptedWork);
+        break;
+      }
+
+    case HostPortal:
+      popHostContainer();
+      break;
+
+    case SuspenseComponent:
+      popSuspenseHandler(interruptedWork);
+      break;
+
+    case SuspenseListComponent:
+      popSuspenseListContext();
+      break;
+
+    case ContextProvider:
+      const context = interruptedWork.type._context;
+      popProvider(context);
+      break;
+
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      popSuspenseHandler(interruptedWork);
+      popHiddenContext();
+      popTransition(interruptedWork, current);
+      break;
+
+    case CacheComponent:
+      {
+        popCacheProvider();
+      }
+
+      break;
+  }
+}
+
+function invokeGuardedCallbackImpl(name, func, context) {
+  {
+    // $FlowFixMe[method-unbinding]
+    const funcArgs = Array.prototype.slice.call(arguments, 3);
+
+    try {
+      // $FlowFixMe[incompatible-call] Flow doesn't understand the arguments splicing.
+      func.apply(context, funcArgs);
+    } catch (error) {
+      this.onError(error);
+    }
+  }
+}
+
+let hasError = false;
+let caughtError = null; // Used by event system to capture/rethrow the first error.
+
+let hasRethrowError = false;
+let rethrowError = null;
+const reporter = {
+  onError(error) {
+    hasError = true;
+    caughtError = error;
+  }
+
+};
+/**
+ * Call a function while guarding against errors that happens within it.
+ * Returns an error if it throws, otherwise null.
+ *
+ * In production, this is implemented using a try-catch. The reason we don't
+ * use a try-catch directly is so that we can swap out a different
+ * implementation in DEV mode.
+ *
+ * @param {String} name of the guard to use for logging or debugging
+ * @param {Function} func The function to invoke
+ * @param {*} context The context to use when calling the function
+ * @param {...*} args Arguments for function
+ */
+
+function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+  hasError = false;
+  caughtError = null;
+  invokeGuardedCallbackImpl.apply(reporter, arguments);
+}
+/**
+ * Same as invokeGuardedCallback, but instead of returning an error, it stores
+ * it in a global so it can be rethrown by `rethrowCaughtError` later.
+ * TODO: See if caughtError and rethrowError can be unified.
+ *
+ * @param {String} name of the guard to use for logging or debugging
+ * @param {Function} func The function to invoke
+ * @param {*} context The context to use when calling the function
+ * @param {...*} args Arguments for function
+ */
+
+function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
+  invokeGuardedCallback.apply(this, arguments);
+
+  if (hasError) {
+    const error = clearCaughtError();
+
+    if (!hasRethrowError) {
+      hasRethrowError = true;
+      rethrowError = error;
+    }
+  }
+}
+/**
+ * During execution of guarded functions we will capture the first error which
+ * we will rethrow to be handled by the top level error handler.
+ */
+
+function rethrowCaughtError() {
+  if (hasRethrowError) {
+    const error = rethrowError;
+    hasRethrowError = false;
+    rethrowError = null;
+    throw error;
+  }
+}
+function clearCaughtError() {
+  if (hasError) {
+    const error = caughtError;
+    hasError = false;
+    caughtError = null;
+    return error;
+  } else {
+    throw Error(formatProdErrorMessage(198));
+  }
+}
+
+// Allows us to avoid traversing the return path to find the nearest Offscreen ancestor.
+
+
+let offscreenSubtreeIsHidden = false;
+let offscreenSubtreeWasHidden = false;
+const PossiblyWeakSet = typeof WeakSet === 'function' ? WeakSet : Set;
+let nextEffect = null; // Used for Profiling builds to track updaters.
+
+let inProgressLanes = null;
+let inProgressRoot = null;
+
+function shouldProfile(current) {
+  return (current.mode & ProfileMode) !== NoMode && (getExecutionContext() & CommitContext) !== NoContext;
+}
+
+function callComponentWillUnmountWithTimer(current, instance) {
+  instance.props = current.memoizedProps;
+  instance.state = current.memoizedState;
+
+  if (shouldProfile(current)) {
+    try {
+      startLayoutEffectTimer();
+      instance.componentWillUnmount();
+    } finally {
+      recordLayoutEffectDuration(current);
+    }
+  } else {
+    instance.componentWillUnmount();
+  }
+} // Capture errors so they don't interrupt unmounting.
+
+
+function safelyCallComponentWillUnmount(current, nearestMountedAncestor, instance) {
+  try {
+    callComponentWillUnmountWithTimer(current, instance);
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+} // Capture errors so they don't interrupt mounting.
+
+
+function safelyAttachRef(current, nearestMountedAncestor) {
+  try {
+    commitAttachRef(current);
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+}
+
+function safelyDetachRef(current, nearestMountedAncestor) {
+  const ref = current.ref;
+  const refCleanup = current.refCleanup;
+
+  if (ref !== null) {
+    if (typeof refCleanup === 'function') {
+      try {
+        if (shouldProfile(current)) {
+          try {
+            startLayoutEffectTimer();
+            refCleanup();
+          } finally {
+            recordLayoutEffectDuration(current);
+          }
+        } else {
+          refCleanup();
+        }
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
+      } finally {
+        // `refCleanup` has been called. Nullify all references to it to prevent double invocation.
+        current.refCleanup = null;
+        const finishedWork = current.alternate;
+
+        if (finishedWork != null) {
+          finishedWork.refCleanup = null;
+        }
+      }
+    } else if (typeof ref === 'function') {
+      let retVal;
+
+      try {
+        if (shouldProfile(current)) {
+          try {
+            startLayoutEffectTimer();
+            retVal = ref(null);
+          } finally {
+            recordLayoutEffectDuration(current);
+          }
+        } else {
+          retVal = ref(null);
+        }
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
+      }
+    } else {
+      // $FlowFixMe[incompatible-use] unable to narrow type to RefObject
+      ref.current = null;
+    }
+  }
+}
+
+function safelyCallDestroy(current, nearestMountedAncestor, destroy) {
+  try {
+    destroy();
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+}
+let shouldFireAfterActiveInstanceBlur = false;
+function commitBeforeMutationEffects(root, firstChild) {
+  prepareForCommit();
+  nextEffect = firstChild;
+  commitBeforeMutationEffects_begin(); // We no longer need to track the active instance fiber
+
+  const shouldFire = shouldFireAfterActiveInstanceBlur;
+  shouldFireAfterActiveInstanceBlur = false;
+  return shouldFire;
+}
+
+function commitBeforeMutationEffects_begin() {
+  while (nextEffect !== null) {
+    const fiber = nextEffect; // This phase is only used for beforeActiveInstanceBlur.
+
+    const child = fiber.child;
+
+    if ((fiber.subtreeFlags & BeforeMutationMask) !== NoFlags$1 && child !== null) {
+      child.return = fiber;
+      nextEffect = child;
+    } else {
+      commitBeforeMutationEffects_complete();
+    }
+  }
+}
+
+function commitBeforeMutationEffects_complete() {
+  while (nextEffect !== null) {
+    const fiber = nextEffect;
+
+    try {
+      commitBeforeMutationEffectsOnFiber(fiber);
+    } catch (error) {
+      captureCommitPhaseError(fiber, fiber.return, error);
+    }
+    const sibling = fiber.sibling;
+
+    if (sibling !== null) {
+      sibling.return = fiber.return;
+      nextEffect = sibling;
+      return;
+    }
+
+    nextEffect = fiber.return;
+  }
+}
+
+function commitBeforeMutationEffectsOnFiber(finishedWork) {
+  const current = finishedWork.alternate;
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+      {
+        {
+          if ((flags & Update) !== NoFlags$1) {
+            commitUseEffectEventMount(finishedWork);
+          }
+        }
+
+        break;
+      }
+
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        break;
+      }
+
+    case ClassComponent:
+      {
+        if ((flags & Snapshot) !== NoFlags$1) {
+          if (current !== null) {
+            const prevProps = current.memoizedProps;
+            const prevState = current.memoizedState;
+            const instance = finishedWork.stateNode; // We could update instance props and state here,
+
+            const snapshot = instance.getSnapshotBeforeUpdate(finishedWork.elementType === finishedWork.type ? prevProps : resolveDefaultProps(finishedWork.type, prevProps), prevState);
+
+            instance.__reactInternalSnapshotBeforeUpdate = snapshot;
+          }
+        }
+
+        break;
+      }
+
+    case HostRoot:
+      {
+        if ((flags & Snapshot) !== NoFlags$1) {
+          {
+            const root = finishedWork.stateNode;
+            clearContainer(root.containerInfo);
+          }
+        }
+
+        break;
+      }
+
+    case HostComponent:
+    case HostHoistable:
+    case HostSingleton:
+    case HostText:
+    case HostPortal:
+    case IncompleteClassComponent:
+      // Nothing to do for these component types
+      break;
+
+    default:
+      {
+        if ((flags & Snapshot) !== NoFlags$1) {
+          throw Error(formatProdErrorMessage(163));
+        }
+      }
+  }
+}
+
+function commitHookEffectListUnmount(flags, finishedWork, nearestMountedAncestor) {
+  const updateQueue = finishedWork.updateQueue;
+  const lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
+
+  if (lastEffect !== null) {
+    const firstEffect = lastEffect.next;
+    let effect = firstEffect;
+
+    do {
+      if ((effect.tag & flags) === flags) {
+        // Unmount
+        const inst = effect.inst;
+        const destroy = inst.destroy;
+
+        if (destroy !== undefined) {
+          inst.destroy = undefined;
+
+          {
+            if ((flags & Passive) !== NoFlags) {
+              markComponentPassiveEffectUnmountStarted(finishedWork);
+            } else if ((flags & Layout) !== NoFlags) {
+              markComponentLayoutEffectUnmountStarted(finishedWork);
+            }
+          }
+
+          safelyCallDestroy(finishedWork, nearestMountedAncestor, destroy);
+
+          {
+            if ((flags & Passive) !== NoFlags) {
+              markComponentPassiveEffectUnmountStopped();
+            } else if ((flags & Layout) !== NoFlags) {
+              markComponentLayoutEffectUnmountStopped();
+            }
+          }
+        }
+      }
+
+      effect = effect.next;
+    } while (effect !== firstEffect);
+  }
+}
+
+function commitHookEffectListMount(flags, finishedWork) {
+  const updateQueue = finishedWork.updateQueue;
+  const lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
+
+  if (lastEffect !== null) {
+    const firstEffect = lastEffect.next;
+    let effect = firstEffect;
+
+    do {
+      if ((effect.tag & flags) === flags) {
+        {
+          if ((flags & Passive) !== NoFlags) {
+            markComponentPassiveEffectMountStarted(finishedWork);
+          } else if ((flags & Layout) !== NoFlags) {
+            markComponentLayoutEffectMountStarted(finishedWork);
+          }
+        } // Mount
+
+
+        const create = effect.create;
+
+        const inst = effect.inst;
+        const destroy = create();
+        inst.destroy = destroy;
+
+        {
+          if ((flags & Passive) !== NoFlags) {
+            markComponentPassiveEffectMountStopped();
+          } else if ((flags & Layout) !== NoFlags) {
+            markComponentLayoutEffectMountStopped();
+          }
+        }
+      }
+
+      effect = effect.next;
+    } while (effect !== firstEffect);
+  }
+}
+
+function commitUseEffectEventMount(finishedWork) {
+  const updateQueue = finishedWork.updateQueue;
+  const eventPayloads = updateQueue !== null ? updateQueue.events : null;
+
+  if (eventPayloads !== null) {
+    for (let ii = 0; ii < eventPayloads.length; ii++) {
+      const _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:
+          {
+            const passiveEffectDuration = finishedWork.stateNode.passiveEffectDuration;
+            const _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.
+
+            const commitTime = getCommitTime();
+            let 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.
+
+
+            let parentFiber = finishedWork.return;
+
+            outer: while (parentFiber !== null) {
+              switch (parentFiber.tag) {
+                case HostRoot:
+                  const root = parentFiber.stateNode;
+                  root.passiveEffectDuration += passiveEffectDuration;
+                  break outer;
+
+                case Profiler:
+                  const 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) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
+
+function commitClassLayoutLifecycles(finishedWork, current) {
+  const instance = finishedWork.stateNode;
+
+  if (current === null) {
+
+    if (shouldProfile(finishedWork)) {
+      try {
+        startLayoutEffectTimer();
+        instance.componentDidMount();
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+
+      recordLayoutEffectDuration(finishedWork);
+    } else {
+      try {
+        instance.componentDidMount();
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+  } else {
+    const prevProps = finishedWork.elementType === finishedWork.type ? current.memoizedProps : resolveDefaultProps(finishedWork.type, current.memoizedProps);
+    const prevState = current.memoizedState; // We could update instance props and state here,
+
+    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, prevState, instance.__reactInternalSnapshotBeforeUpdate);
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+  }
+}
+
+function commitClassCallbacks(finishedWork) {
+  // TODO: I think this is now always non-null by the time it reaches the
+  // commit phase. Consider removing the type check.
+  const updateQueue = finishedWork.updateQueue;
+
+  if (updateQueue !== null) {
+    const instance = finishedWork.stateNode;
+    // but instead we rely on them being set during last render.
+    // TODO: revisit this when we implement resuming.
+
+
+    try {
+      commitCallbacks(updateQueue, instance);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
+
+function commitHostComponentMount(finishedWork) {
+  const type = finishedWork.type;
+  const props = finishedWork.memoizedProps;
+  const instance = finishedWork.stateNode;
+
+  try {
+    commitMount(instance, type, props, finishedWork);
+  } catch (error) {
+    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+  }
+}
+
+function commitProfilerUpdate(finishedWork, current) {
+  if (getExecutionContext() & CommitContext) {
+    try {
+      const _finishedWork$memoize2 = finishedWork.memoizedProps,
+            onCommit = _finishedWork$memoize2.onCommit,
+            onRender = _finishedWork$memoize2.onRender;
+      const effectDuration = finishedWork.stateNode.effectDuration;
+      const commitTime = getCommitTime();
+      let 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.
+
+        let parentFiber = finishedWork.return;
+
+        outer: while (parentFiber !== null) {
+          switch (parentFiber.tag) {
+            case HostRoot:
+              const root = parentFiber.stateNode;
+              root.effectDuration += effectDuration;
+              break outer;
+
+            case Profiler:
+              const parentStateNode = parentFiber.stateNode;
+              parentStateNode.effectDuration += effectDuration;
+              break outer;
+          }
+
+          parentFiber = parentFiber.return;
+        }
+      }
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
+
+function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork, committedLanes) {
+  // When updating this function, also update reappearLayoutEffects, which does
+  // most of the same things when an offscreen tree goes from hidden -> visible.
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+        if (flags & Update) {
+          commitHookLayoutEffects(finishedWork, Layout | HasEffect);
+        }
+
+        break;
+      }
+
+    case ClassComponent:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+        if (flags & Update) {
+          commitClassLayoutLifecycles(finishedWork, current);
+        }
+
+        if (flags & Callback) {
+          commitClassCallbacks(finishedWork);
+        }
+
+        if (flags & Ref) {
+          safelyAttachRef(finishedWork, finishedWork.return);
+        }
+
+        break;
+      }
+
+    case HostRoot:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+        if (flags & Callback) {
+          // TODO: I think this is now always non-null by the time it reaches the
+          // commit phase. Consider removing the type check.
+          const updateQueue = finishedWork.updateQueue;
+
+          if (updateQueue !== null) {
+            let instance = null;
+
+            if (finishedWork.child !== null) {
+              switch (finishedWork.child.tag) {
+                case HostSingleton:
+                case HostComponent:
+                  instance = getPublicInstance(finishedWork.child.stateNode);
+                  break;
+
+                case ClassComponent:
+                  instance = finishedWork.child.stateNode;
+                  break;
+              }
+            }
+
+            try {
+              commitCallbacks(updateQueue, instance);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+        }
+
+        break;
+      }
+
+    case HostHoistable:
+      {
+        {
+          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+          if (flags & Ref) {
+            safelyAttachRef(finishedWork, finishedWork.return);
+          }
+
+          break;
+        } // Fall through
+
+      }
+
+    case HostSingleton:
+    case HostComponent:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork); // Renderers may schedule work to be done after host components are mounted
+        // (eg DOM renderer may schedule auto-focus for inputs and form controls).
+        // These effects should only be committed when components are first mounted,
+        // aka when there is no current/alternate.
+
+        if (current === null && flags & Update) {
+          commitHostComponentMount(finishedWork);
+        }
+
+        if (flags & Ref) {
+          safelyAttachRef(finishedWork, finishedWork.return);
+        }
+
+        break;
+      }
+
+    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;
+      }
+
+    case SuspenseComponent:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+        if (flags & Update) {
+          commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
+        }
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const isModernRoot = (finishedWork.mode & ConcurrentMode) !== NoMode;
+
+        if (isModernRoot) {
+          const isHidden = finishedWork.memoizedState !== null;
+          const newOffscreenSubtreeIsHidden = isHidden || offscreenSubtreeIsHidden;
+
+          if (newOffscreenSubtreeIsHidden) ; else {
+            // The Offscreen tree is visible.
+            const wasHidden = current !== null && current.memoizedState !== null;
+            const newOffscreenSubtreeWasHidden = wasHidden || offscreenSubtreeWasHidden;
+            const prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
+            const prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+            offscreenSubtreeIsHidden = newOffscreenSubtreeIsHidden;
+            offscreenSubtreeWasHidden = newOffscreenSubtreeWasHidden;
+
+            if (offscreenSubtreeWasHidden && !prevOffscreenSubtreeWasHidden) {
+              // This is the root of a reappearing boundary. As we continue
+              // traversing the layout effects, we must also re-mount layout
+              // effects that were unmounted when the Offscreen subtree was
+              // hidden. So this is a superset of the normal commitLayoutEffects.
+              const includeWorkInProgressEffects = (finishedWork.subtreeFlags & LayoutMask) !== NoFlags$1;
+              recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+            } else {
+              recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+            }
+
+            offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+            offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+          }
+        } else {
+          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        }
+
+        if (flags & Ref) {
+          const props = finishedWork.memoizedProps;
+
+          if (props.mode === 'manual') {
+            safelyAttachRef(finishedWork, finishedWork.return);
+          } else {
+            safelyDetachRef(finishedWork, finishedWork.return);
+          }
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        break;
+      }
+  }
+}
+
+function hideOrUnhideAllChildren(finishedWork, isHidden) {
+  // Only hide or unhide the top-most host nodes.
+  let hostSubtreeRoot = null;
+
+  {
+    // We only have the top Fiber that was inserted but we need to recurse down its
+    // children to find all the terminal nodes.
+    let node = finishedWork;
+
+    while (true) {
+      if (node.tag === HostComponent || (node.tag === HostHoistable ) || (node.tag === HostSingleton )) {
+        if (hostSubtreeRoot === null) {
+          hostSubtreeRoot = node;
+
+          try {
+            const instance = node.stateNode;
+
+            if (isHidden) {
+              hideInstance(instance);
+            } else {
+              unhideInstance(node.stateNode, node.memoizedProps);
+            }
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      } else if (node.tag === HostText) {
+        if (hostSubtreeRoot === null) {
+          try {
+            const instance = node.stateNode;
+
+            if (isHidden) {
+              hideTextInstance(instance);
+            } else {
+              unhideTextInstance(instance, node.memoizedProps);
+            }
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      } else if ((node.tag === OffscreenComponent || node.tag === LegacyHiddenComponent) && node.memoizedState !== null && node !== finishedWork) ; else if (node.child !== null) {
+        node.child.return = node;
+        node = node.child;
+        continue;
+      }
+
+      if (node === finishedWork) {
+        return;
+      }
+
+      while (node.sibling === null) {
+        if (node.return === null || node.return === finishedWork) {
+          return;
+        }
+
+        if (hostSubtreeRoot === node) {
+          hostSubtreeRoot = null;
+        }
+
+        node = node.return;
+      }
+
+      if (hostSubtreeRoot === node) {
+        hostSubtreeRoot = null;
+      }
+
+      node.sibling.return = node.return;
+      node = node.sibling;
+    }
+  }
+}
+
+function commitAttachRef(finishedWork) {
+  const ref = finishedWork.ref;
+
+  if (ref !== null) {
+    const instance = finishedWork.stateNode;
+    let instanceToUse;
+
+    switch (finishedWork.tag) {
+      case HostHoistable:
+      case HostSingleton:
+      case HostComponent:
+        instanceToUse = getPublicInstance(instance);
+        break;
+
+      default:
+        instanceToUse = instance;
+    } // Moved outside to ensure DCE works with this flag
+
+    if (typeof ref === 'function') {
+      if (shouldProfile(finishedWork)) {
+        try {
+          startLayoutEffectTimer();
+          finishedWork.refCleanup = ref(instanceToUse);
+        } finally {
+          recordLayoutEffectDuration(finishedWork);
+        }
+      } else {
+        finishedWork.refCleanup = ref(instanceToUse);
+      }
+    } else {
+
+
+      ref.current = instanceToUse;
+    }
+  }
+}
+
+function detachFiberMutation(fiber) {
+  // Cut off the return pointer to disconnect it from the tree.
+  // This enables us to detect and warn against state updates on an unmounted component.
+  // It also prevents events from bubbling from within disconnected components.
+  //
+  // Ideally, we should also clear the child pointer of the parent alternate to let this
+  // get GC:ed but we don't know which for sure which parent is the current
+  // one so we'll settle for GC:ing the subtree of this child.
+  // This child itself will be GC:ed when the parent updates the next time.
+  //
+  // Note that we can't clear child or sibling pointers yet.
+  // They're needed for passive effects and for findDOMNode.
+  // We defer those fields, and all other cleanup, to the passive phase (see detachFiberAfterEffects).
+  //
+  // Don't reset the alternate yet, either. We need that so we can detach the
+  // alternate's fields in the passive phase. Clearing the return pointer is
+  // sufficient for findDOMNode semantics.
+  const alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    alternate.return = null;
+  }
+
+  fiber.return = null;
+}
+
+function detachFiberAfterEffects(fiber) {
+  const alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    fiber.alternate = null;
+    detachFiberAfterEffects(alternate);
+  } // Clear cyclical Fiber fields. This level alone is designed to roughly
+  // approximate the planned Fiber refactor. In that world, `setState` will be
+  // bound to a special "instance" object instead of a Fiber. The Instance
+  // object will not have any of these fields. It will only be connected to
+  // the fiber tree via a single link at the root. So if this level alone is
+  // sufficient to fix memory issues, that bodes well for our plans.
+
+
+  fiber.child = null;
+  fiber.deletions = null;
+  fiber.sibling = null; // The `stateNode` is cyclical because on host nodes it points to the host
+  // tree, which has its own pointers to children, parents, and siblings.
+  // The other host nodes also point back to fibers, so we should detach that
+  // one, too.
+
+  if (fiber.tag === HostComponent) {
+    const hostInstance = fiber.stateNode;
+
+    if (hostInstance !== null) {
+      detachDeletedInstance(hostInstance);
+    }
+  }
+
+  fiber.stateNode = null;
+  // disconnected the fiber from the tree. So even if something leaks this
+  // particular fiber, it won't leak anything else.
+
+
+  fiber.return = null;
+  fiber.dependencies = null;
+  fiber.memoizedProps = null;
+  fiber.memoizedState = null;
+  fiber.pendingProps = null;
+  fiber.stateNode = null; // TODO: Move to `commitPassiveUnmountInsideDeletedTreeOnFiber` instead.
+
+  fiber.updateQueue = null;
+}
+
+function getHostParentFiber(fiber) {
+  let parent = fiber.return;
+
+  while (parent !== null) {
+    if (isHostParent(parent)) {
+      return parent;
+    }
+
+    parent = parent.return;
+  }
+
+  throw Error(formatProdErrorMessage(160));
+}
+
+function isHostParent(fiber) {
+  return fiber.tag === HostComponent || fiber.tag === HostRoot || (fiber.tag === HostHoistable ) || (fiber.tag === HostSingleton ) || fiber.tag === HostPortal;
+}
+
+function getHostSibling(fiber) {
+  // We're going to search forward into the tree until we find a sibling host
+  // node. Unfortunately, if multiple insertions are done in a row we have to
+  // search past them. This leads to exponential search for the next sibling.
+  // TODO: Find a more efficient way to do this.
+  let node = fiber;
+
+  siblings: while (true) {
+    // If we didn't find anything, let's try the next sibling.
+    while (node.sibling === null) {
+      if (node.return === null || isHostParent(node.return)) {
+        // If we pop out of the root or hit the parent the fiber we are the
+        // last sibling.
+        return null;
+      } // $FlowFixMe[incompatible-type] found when upgrading Flow
+
+
+      node = node.return;
+    }
+
+    node.sibling.return = node.return;
+    node = node.sibling;
+
+    while (node.tag !== HostComponent && node.tag !== HostText && (node.tag !== HostSingleton) && node.tag !== DehydratedFragment) {
+      // If it is not host node and, we might have a host node inside it.
+      // Try to search down until we find one.
+      if (node.flags & Placement) {
+        // If we don't have a child, try the siblings instead.
+        continue siblings;
+      } // If we don't have a child, try the siblings instead.
+      // We also skip portals because they are not part of this host tree.
+
+
+      if (node.child === null || node.tag === HostPortal) {
+        continue siblings;
+      } else {
+        node.child.return = node;
+        node = node.child;
+      }
+    } // Check if this host node is stable or about to be placed.
+
+
+    if (!(node.flags & Placement)) {
+      // Found it!
+      return node.stateNode;
+    }
+  }
+}
+
+function commitPlacement(finishedWork) {
+
+  {
+    if (finishedWork.tag === HostSingleton) {
+      // Singletons are already in the Host and don't need to be placed
+      // Since they operate somewhat like Portals though their children will
+      // have Placement and will get placed inside them
+      return;
+    }
+  } // Recursively insert all host nodes into the parent.
+
+
+  const parentFiber = getHostParentFiber(finishedWork);
+
+  switch (parentFiber.tag) {
+    case HostSingleton:
+      {
+        {
+          const parent = parentFiber.stateNode;
+          const before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
+          // children to find all the terminal nodes.
+
+          insertOrAppendPlacementNode(finishedWork, before, parent);
+          break;
+        } // Fall through
+
+      }
+
+    case HostComponent:
+      {
+        const parent = parentFiber.stateNode;
+
+        if (parentFiber.flags & ContentReset) {
+          // Reset the text content of the parent before doing any insertions
+          resetTextContent(parent); // Clear ContentReset from the effect tag
+
+          parentFiber.flags &= ~ContentReset;
+        }
+
+        const before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
+        // children to find all the terminal nodes.
+
+        insertOrAppendPlacementNode(finishedWork, before, parent);
+        break;
+      }
+
+    case HostRoot:
+    case HostPortal:
+      {
+        const parent = parentFiber.stateNode.containerInfo;
+        const before = getHostSibling(finishedWork);
+        insertOrAppendPlacementNodeIntoContainer(finishedWork, before, parent);
+        break;
+      }
+
+    default:
+      throw Error(formatProdErrorMessage(161));
+  }
+}
+
+function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
+  const tag = node.tag;
+  const isHost = tag === HostComponent || tag === HostText;
+
+  if (isHost) {
+    const stateNode = node.stateNode;
+
+    if (before) {
+      insertInContainerBefore(parent, stateNode, before);
+    } else {
+      appendChildToContainer(parent, stateNode);
+    }
+  } else if (tag === HostPortal || (tag === HostSingleton )) ; else {
+    const child = node.child;
+
+    if (child !== null) {
+      insertOrAppendPlacementNodeIntoContainer(child, before, parent);
+      let sibling = child.sibling;
+
+      while (sibling !== null) {
+        insertOrAppendPlacementNodeIntoContainer(sibling, before, parent);
+        sibling = sibling.sibling;
+      }
+    }
+  }
+}
+
+function insertOrAppendPlacementNode(node, before, parent) {
+  const tag = node.tag;
+  const isHost = tag === HostComponent || tag === HostText;
+
+  if (isHost) {
+    const stateNode = node.stateNode;
+
+    if (before) {
+      insertBefore(parent, stateNode, before);
+    } else {
+      appendChild(parent, stateNode);
+    }
+  } else if (tag === HostPortal || (tag === HostSingleton )) ; else {
+    const child = node.child;
+
+    if (child !== null) {
+      insertOrAppendPlacementNode(child, before, parent);
+      let sibling = child.sibling;
+
+      while (sibling !== null) {
+        insertOrAppendPlacementNode(sibling, before, parent);
+        sibling = sibling.sibling;
+      }
+    }
+  }
+} // These are tracked on the stack as we recursively traverse a
+// deleted subtree.
+// TODO: Update these during the whole mutation phase, not just during
+// a deletion.
+
+
+let hostParent = null;
+let hostParentIsContainer = false;
+
+function commitDeletionEffects(root, returnFiber, deletedFiber) {
+  {
+    // We only have the top Fiber that was deleted but we need to recurse down its
+    // children to find all the terminal nodes.
+    // Recursively delete all host nodes from the parent, detach refs, clean
+    // up mounted layout effects, and call componentWillUnmount.
+    // We only need to remove the topmost host child in each branch. But then we
+    // still need to keep traversing to unmount effects, refs, and cWU. TODO: We
+    // could split this into two separate traversals functions, where the second
+    // one doesn't include any removeChild logic. This is maybe the same
+    // function as "disappearLayoutEffects" (or whatever that turns into after
+    // the layout phase is refactored to use recursion).
+    // Before starting, find the nearest host parent on the stack so we know
+    // which instance/container to remove the children from.
+    // TODO: Instead of searching up the fiber return path on every deletion, we
+    // can track the nearest host component on the JS stack as we traverse the
+    // tree during the commit phase. This would make insertions faster, too.
+    let parent = returnFiber;
+
+    findParent: while (parent !== null) {
+      switch (parent.tag) {
+        case HostSingleton:
+        case HostComponent:
+          {
+            hostParent = parent.stateNode;
+            hostParentIsContainer = false;
+            break findParent;
+          }
+
+        case HostRoot:
+          {
+            hostParent = parent.stateNode.containerInfo;
+            hostParentIsContainer = true;
+            break findParent;
+          }
+
+        case HostPortal:
+          {
+            hostParent = parent.stateNode.containerInfo;
+            hostParentIsContainer = true;
+            break findParent;
+          }
+      }
+
+      parent = parent.return;
+    }
+
+    if (hostParent === null) {
+      throw Error(formatProdErrorMessage(160));
+    }
+
+    commitDeletionEffectsOnFiber(root, returnFiber, deletedFiber);
+    hostParent = null;
+    hostParentIsContainer = false;
+  }
+
+  detachFiberMutation(deletedFiber);
+}
+
+function recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, parent) {
+  // TODO: Use a static flag to skip trees that don't have unmount effects
+  let child = parent.child;
+
+  while (child !== null) {
+    commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, child);
+    child = child.sibling;
+  }
+}
+
+function commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, deletedFiber) {
+  onCommitUnmount(deletedFiber); // The cases in this outer switch modify the stack before they traverse
+  // into their subtree. There are simpler cases in the inner switch
+  // that don't modify the stack.
+
+  switch (deletedFiber.tag) {
+    case HostHoistable:
+      {
+        {
+          if (!offscreenSubtreeWasHidden) {
+            safelyDetachRef(deletedFiber, nearestMountedAncestor);
+          }
+
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+
+          if (deletedFiber.memoizedState) {
+            releaseResource(deletedFiber.memoizedState);
+          } else if (deletedFiber.stateNode) {
+            unmountHoistable(deletedFiber.stateNode);
+          }
+
+          return;
+        } // Fall through
+
+      }
+
+    case HostSingleton:
+      {
+        {
+          if (!offscreenSubtreeWasHidden) {
+            safelyDetachRef(deletedFiber, nearestMountedAncestor);
+          }
+
+          const prevHostParent = hostParent;
+          const prevHostParentIsContainer = hostParentIsContainer;
+          hostParent = deletedFiber.stateNode;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber); // Normally this is called in passive unmount effect phase however with
+          // HostSingleton we warn if you acquire one that is already associated to
+          // a different fiber. To increase our chances of avoiding this, specifically
+          // if you keyed a HostSingleton so there will be a delete followed by a Placement
+          // we treat detach eagerly here
+
+          releaseSingletonInstance(deletedFiber.stateNode);
+          hostParent = prevHostParent;
+          hostParentIsContainer = prevHostParentIsContainer;
+          return;
+        } // Fall through
+
+      }
+
+    case HostComponent:
+      {
+        if (!offscreenSubtreeWasHidden) {
+          safelyDetachRef(deletedFiber, nearestMountedAncestor);
+        } // Intentional fallthrough to next branch
+
+      }
+
+    case HostText:
+      {
+        // We only need to remove the nearest host child. Set the host parent
+        // to `null` on the stack to indicate that nested children don't
+        // need to be removed.
+        {
+          const prevHostParent = hostParent;
+          const prevHostParentIsContainer = hostParentIsContainer;
+          hostParent = null;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          hostParent = prevHostParent;
+          hostParentIsContainer = prevHostParentIsContainer;
+
+          if (hostParent !== null) {
+            // Now that all the child effects have unmounted, we can remove the
+            // node from the tree.
+            if (hostParentIsContainer) {
+              removeChildFromContainer(hostParent, deletedFiber.stateNode);
+            } else {
+              removeChild(hostParent, deletedFiber.stateNode);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case DehydratedFragment:
+      {
+        // Delete the dehydrated suspense boundary and all of its content.
+
+
+        {
+          if (hostParent !== null) {
+            if (hostParentIsContainer) {
+              clearSuspenseBoundaryFromContainer(hostParent, deletedFiber.stateNode);
+            } else {
+              clearSuspenseBoundary(hostParent, deletedFiber.stateNode);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case HostPortal:
+      {
+        {
+          // When we go into a portal, it becomes the parent to remove from.
+          const prevHostParent = hostParent;
+          const prevHostParentIsContainer = hostParentIsContainer;
+          hostParent = deletedFiber.stateNode.containerInfo;
+          hostParentIsContainer = true;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          hostParent = prevHostParent;
+          hostParentIsContainer = prevHostParentIsContainer;
+        }
+
+        return;
+      }
+
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent:
+      {
+        if (!offscreenSubtreeWasHidden) {
+          const updateQueue = deletedFiber.updateQueue;
+
+          if (updateQueue !== null) {
+            const lastEffect = updateQueue.lastEffect;
+
+            if (lastEffect !== null) {
+              const firstEffect = lastEffect.next;
+              let effect = firstEffect;
+
+              do {
+                const tag = effect.tag;
+                const inst = effect.inst;
+                const destroy = inst.destroy;
+
+                if (destroy !== undefined) {
+                  if ((tag & Insertion) !== NoFlags) {
+                    inst.destroy = undefined;
+                    safelyCallDestroy(deletedFiber, nearestMountedAncestor, destroy);
+                  } else if ((tag & Layout) !== NoFlags) {
+                    {
+                      markComponentLayoutEffectUnmountStarted(deletedFiber);
+                    }
+
+                    if (shouldProfile(deletedFiber)) {
+                      startLayoutEffectTimer();
+                      inst.destroy = undefined;
+                      safelyCallDestroy(deletedFiber, nearestMountedAncestor, destroy);
+                      recordLayoutEffectDuration(deletedFiber);
+                    } else {
+                      inst.destroy = undefined;
+                      safelyCallDestroy(deletedFiber, nearestMountedAncestor, destroy);
+                    }
+
+                    {
+                      markComponentLayoutEffectUnmountStopped();
+                    }
+                  }
+                }
+
+                effect = effect.next;
+              } while (effect !== firstEffect);
+            }
+          }
+        }
+
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        return;
+      }
+
+    case ClassComponent:
+      {
+        if (!offscreenSubtreeWasHidden) {
+          safelyDetachRef(deletedFiber, nearestMountedAncestor);
+          const instance = deletedFiber.stateNode;
+
+          if (typeof instance.componentWillUnmount === 'function') {
+            safelyCallComponentWillUnmount(deletedFiber, nearestMountedAncestor, instance);
+          }
+        }
+
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        return;
+      }
+
+    case ScopeComponent:
+      {
+
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        return;
+      }
+
+    case OffscreenComponent:
+      {
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+
+        if (deletedFiber.mode & ConcurrentMode) {
+          // If this offscreen component is hidden, we already unmounted it. Before
+          // deleting the children, track that it's already unmounted so that we
+          // don't attempt to unmount the effects again.
+          // TODO: If the tree is hidden, in most cases we should be able to skip
+          // over the nested children entirely. An exception is we haven't yet found
+          // the topmost host node to delete, which we already track on the stack.
+          // But the other case is portals, which need to be detached no matter how
+          // deeply they are nested. We should use a subtree flag to track whether a
+          // subtree includes a nested portal.
+          const prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || deletedFiber.memoizedState !== null;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+        } else {
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        return;
+      }
+  }
+}
+
+function commitSuspenseCallback(finishedWork) {
+}
+
+function commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {
+
+  const newState = finishedWork.memoizedState;
+
+  if (newState === null) {
+    const current = finishedWork.alternate;
+
+    if (current !== null) {
+      const prevState = current.memoizedState;
+
+      if (prevState !== null) {
+        const suspenseInstance = prevState.dehydrated;
+
+        if (suspenseInstance !== null) {
+          try {
+            commitHydratedSuspenseInstance(suspenseInstance);
+
+            if (enableSuspenseCallback) ;
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      }
+    }
+  }
+}
+
+function getRetryCache(finishedWork) {
+  // TODO: Unify the interface for the retry cache so we don't have to switch
+  // on the tag like this.
+  switch (finishedWork.tag) {
+    case SuspenseComponent:
+    case SuspenseListComponent:
+      {
+        let retryCache = finishedWork.stateNode;
+
+        if (retryCache === null) {
+          retryCache = finishedWork.stateNode = new PossiblyWeakSet();
+        }
+
+        return retryCache;
+      }
+
+    case OffscreenComponent:
+      {
+        const instance = finishedWork.stateNode;
+        let retryCache = instance._retryCache;
+
+        if (retryCache === null) {
+          retryCache = instance._retryCache = new PossiblyWeakSet();
+        }
+
+        return retryCache;
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(435, finishedWork.tag));
+      }
+  }
+}
+
+function detachOffscreenInstance(instance) {
+  const fiber = instance._current;
+
+  if (fiber === null) {
+    throw Error(formatProdErrorMessage(456));
+  }
+
+  if ((instance._pendingVisibility & OffscreenDetached) !== NoFlags$1) {
+    // The instance is already detached, this is a noop.
+    return;
+  } // TODO: There is an opportunity to optimise this by not entering commit phase
+  // and unmounting effects directly.
+
+
+  const root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+  if (root !== null) {
+    instance._pendingVisibility |= OffscreenDetached;
+    scheduleUpdateOnFiber(root, fiber, SyncLane);
+  }
+}
+function attachOffscreenInstance(instance) {
+  const fiber = instance._current;
+
+  if (fiber === null) {
+    throw Error(formatProdErrorMessage(456));
+  }
+
+  if ((instance._pendingVisibility & OffscreenDetached) === NoFlags$1) {
+    // The instance is already attached, this is a noop.
+    return;
+  }
+
+  const root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+  if (root !== null) {
+    instance._pendingVisibility &= ~OffscreenDetached;
+    scheduleUpdateOnFiber(root, fiber, SyncLane);
+  }
+}
+
+function attachSuspenseRetryListeners(finishedWork, wakeables) {
+  // If this boundary just timed out, then it will have a set of wakeables.
+  // For each wakeable, attach a listener so that when it resolves, React
+  // attempts to re-render the boundary in the primary (pre-timeout) state.
+  const retryCache = getRetryCache(finishedWork);
+  wakeables.forEach(wakeable => {
+    // Memoize using the boundary fiber to prevent redundant listeners.
+    const retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
+
+    if (!retryCache.has(wakeable)) {
+      retryCache.add(wakeable);
+
+      {
+        if (isDevToolsPresent) {
+          if (inProgressLanes !== null && inProgressRoot !== null) {
+            // If we have pending work still, associate the original updaters with it.
+            restorePendingUpdaters(inProgressRoot, inProgressLanes);
+          } else {
+            throw Error(formatProdErrorMessage(413));
+          }
+        }
+      }
+
+      wakeable.then(retry, retry);
+    }
+  });
+} // This function detects when a Suspense boundary goes from visible to hidden.
+function commitMutationEffects(root, finishedWork, committedLanes) {
+  inProgressLanes = committedLanes;
+  inProgressRoot = root;
+  commitMutationEffectsOnFiber(finishedWork, root);
+  inProgressLanes = null;
+  inProgressRoot = null;
+}
+
+function recursivelyTraverseMutationEffects(root, parentFiber, lanes) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects hae fired.
+  const deletions = parentFiber.deletions;
+
+  if (deletions !== null) {
+    for (let i = 0; i < deletions.length; i++) {
+      const childToDelete = deletions[i];
+
+      try {
+        commitDeletionEffects(root, parentFiber, childToDelete);
+      } catch (error) {
+        captureCommitPhaseError(childToDelete, parentFiber, error);
+      }
+    }
+  }
+
+  if (parentFiber.subtreeFlags & MutationMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      commitMutationEffectsOnFiber(child, root);
+      child = child.sibling;
+    }
+  }
+}
+
+let currentHoistableRoot = null;
+
+function commitMutationEffectsOnFiber(finishedWork, root, lanes) {
+  const current = finishedWork.alternate;
+  const flags = finishedWork.flags; // The effect flag should be checked *after* we refine the type of fiber,
+  // because the fiber tag is more specific. An exception is any flag related
+  // to reconciliation, because those can be set on all fiber types.
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Update) {
+          try {
+            commitHookEffectListUnmount(Insertion | HasEffect, finishedWork, finishedWork.return);
+            commitHookEffectListMount(Insertion | HasEffect, finishedWork);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          } // Layout effects are destroyed during the mutation phase so that all
+          // destroy functions for all fibers are called before any create functions.
+          // This prevents sibling component effects from interfering with each other,
+          // e.g. a destroy function in one component should never override a ref set
+          // by a create function in another component during the same commit.
+
+
+          if (shouldProfile(finishedWork)) {
+            try {
+              startLayoutEffectTimer();
+              commitHookEffectListUnmount(Layout | HasEffect, finishedWork, finishedWork.return);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+
+            recordLayoutEffectDuration(finishedWork);
+          } else {
+            try {
+              commitHookEffectListUnmount(Layout | HasEffect, finishedWork, finishedWork.return);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case ClassComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Ref) {
+          if (current !== null) {
+            safelyDetachRef(current, current.return);
+          }
+        }
+
+        if (flags & Callback && offscreenSubtreeIsHidden) {
+          const updateQueue = finishedWork.updateQueue;
+
+          if (updateQueue !== null) {
+            deferHiddenCallbacks(updateQueue);
+          }
+        }
+
+        return;
+      }
+
+    case HostHoistable:
+      {
+        {
+          // We cast because we always set the root at the React root and so it cannot be
+          // null while we are processing mutation effects
+          const hoistableRoot = currentHoistableRoot;
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+
+          if (flags & Ref) {
+            if (current !== null) {
+              safelyDetachRef(current, current.return);
+            }
+          }
+
+          if (flags & Update) {
+            const currentResource = current !== null ? current.memoizedState : null;
+            const newResource = finishedWork.memoizedState;
+
+            if (current === null) {
+              // We are mounting a new HostHoistable Fiber. We fork the mount
+              // behavior based on whether this instance is a Hoistable Instance
+              // or a Hoistable Resource
+              if (newResource === null) {
+                if (finishedWork.stateNode === null) {
+                  finishedWork.stateNode = hydrateHoistable(hoistableRoot, finishedWork.type, finishedWork.memoizedProps, finishedWork);
+                } else {
+                  mountHoistable(hoistableRoot, finishedWork.type, finishedWork.stateNode);
+                }
+              } else {
+                finishedWork.stateNode = acquireResource(hoistableRoot, newResource, finishedWork.memoizedProps);
+              }
+            } else if (currentResource !== newResource) {
+              // We are moving to or from Hoistable Resource, or between different Hoistable Resources
+              if (currentResource === null) {
+                if (current.stateNode !== null) {
+                  unmountHoistable(current.stateNode);
+                }
+              } else {
+                releaseResource(currentResource);
+              }
+
+              if (newResource === null) {
+                mountHoistable(hoistableRoot, finishedWork.type, finishedWork.stateNode);
+              } else {
+                acquireResource(hoistableRoot, newResource, finishedWork.memoizedProps);
+              }
+            } else if (newResource === null && finishedWork.stateNode !== null) {
+              // We may have an update on a Hoistable element
+              const updatePayload = finishedWork.updateQueue;
+              finishedWork.updateQueue = null;
+
+              try {
+                commitUpdate(finishedWork.stateNode, updatePayload, finishedWork.type, current.memoizedProps, finishedWork.memoizedProps, finishedWork);
+              } catch (error) {
+                captureCommitPhaseError(finishedWork, finishedWork.return, error);
+              }
+            }
+          }
+
+          return;
+        } // Fall through
+
+      }
+
+    case HostSingleton:
+      {
+        {
+          if (flags & Update) {
+            const previousWork = finishedWork.alternate;
+
+            if (previousWork === null) {
+              const singleton = finishedWork.stateNode;
+              const props = finishedWork.memoizedProps; // This was a new mount, we need to clear and set initial properties
+
+              clearSingleton(singleton);
+              acquireSingletonInstance(finishedWork.type, props, singleton, finishedWork);
+            }
+          }
+        } // Fall through
+
+      }
+
+    case HostComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Ref) {
+          if (current !== null) {
+            safelyDetachRef(current, current.return);
+          }
+        }
+
+        {
+          // TODO: ContentReset gets cleared by the children during the commit
+          // phase. This is a refactor hazard because it means we must read
+          // flags the flags after `commitReconciliationEffects` has already run;
+          // the order matters. We should refactor so that ContentReset does not
+          // rely on mutating the flag during commit. Like by setting a flag
+          // during the render phase instead.
+          if (finishedWork.flags & ContentReset) {
+            const instance = finishedWork.stateNode;
+
+            try {
+              resetTextContent(instance);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+
+          if (flags & Update) {
+            const instance = finishedWork.stateNode;
+
+            if (instance != null) {
+              // Commit the work prepared earlier.
+              const newProps = finishedWork.memoizedProps; // For hydration we reuse the update path but we treat the oldProps
+              // as the newProps. The updatePayload will contain the real change in
+              // this case.
+
+              const oldProps = current !== null ? current.memoizedProps : newProps;
+              const type = finishedWork.type; // TODO: Type the updateQueue to be specific to host components.
+
+              const updatePayload = finishedWork.updateQueue;
+              finishedWork.updateQueue = null;
+
+              try {
+                commitUpdate(instance, updatePayload, type, oldProps, newProps, finishedWork);
+              } catch (error) {
+                captureCommitPhaseError(finishedWork, finishedWork.return, error);
+              }
+            }
+          }
+        }
+
+        return;
+      }
+
+    case HostText:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Update) {
+          {
+            if (finishedWork.stateNode === null) {
+              throw Error(formatProdErrorMessage(162));
+            }
+
+            const textInstance = finishedWork.stateNode;
+            const newText = finishedWork.memoizedProps; // For hydration we reuse the update path but we treat the oldProps
+            // as the newProps. The updatePayload will contain the real change in
+            // this case.
+
+            const oldText = current !== null ? current.memoizedProps : newText;
+
+            try {
+              commitTextUpdate(textInstance, oldText, newText);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case HostRoot:
+      {
+        {
+          prepareToCommitHoistables();
+          const previousHoistableRoot = currentHoistableRoot;
+          currentHoistableRoot = getHoistableRoot(root.containerInfo);
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          currentHoistableRoot = previousHoistableRoot;
+          commitReconciliationEffects(finishedWork);
+        }
+
+        if (flags & Update) {
+          {
+            if (current !== null) {
+              const prevRootState = current.memoizedState;
+
+              if (prevRootState.isDehydrated) {
+                try {
+                  commitHydratedContainer(root.containerInfo);
+                } catch (error) {
+                  captureCommitPhaseError(finishedWork, finishedWork.return, error);
+                }
+              }
+            }
+          }
+        }
+
+        return;
+      }
+
+    case HostPortal:
+      {
+        {
+          const previousHoistableRoot = currentHoistableRoot;
+          currentHoistableRoot = getHoistableRoot(finishedWork.stateNode.containerInfo);
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          currentHoistableRoot = previousHoistableRoot;
+        }
+
+        return;
+      }
+
+    case SuspenseComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork); // TODO: We should mark a flag on the Suspense fiber itself, rather than
+        // relying on the Offscreen fiber having a flag also being marked. The
+        // reason is that this offscreen fiber might not be part of the work-in-
+        // progress tree! It could have been reused from a previous render. This
+        // doesn't lead to incorrect behavior because we don't rely on the flag
+        // check alone; we also compare the states explicitly below. But for
+        // modeling purposes, we _should_ be able to rely on the flag check alone.
+        // So this is a bit fragile.
+        //
+        // Also, all this logic could/should move to the passive phase so it
+        // doesn't block paint.
+
+        const offscreenFiber = finishedWork.child;
+
+        if (offscreenFiber.flags & Visibility) {
+          // Throttle the appearance and disappearance of Suspense fallbacks.
+          const isShowingFallback = finishedWork.memoizedState !== null;
+          const wasShowingFallback = current !== null && current.memoizedState !== null;
+
+          {
+            if (isShowingFallback !== wasShowingFallback) {
+              // A fallback is either appearing or disappearing.
+              markCommitTimeOfFallback();
+            }
+          }
+        }
+
+        if (flags & Update) {
+          try {
+            commitSuspenseCallback(finishedWork);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+
+          const retryQueue = finishedWork.updateQueue;
+
+          if (retryQueue !== null) {
+            finishedWork.updateQueue = null;
+            attachSuspenseRetryListeners(finishedWork, retryQueue);
+          }
+        }
+
+        return;
+      }
+
+    case OffscreenComponent:
+      {
+        if (flags & Ref) {
+          if (current !== null) {
+            safelyDetachRef(current, current.return);
+          }
+        }
+
+        const newState = finishedWork.memoizedState;
+        const isHidden = newState !== null;
+        const wasHidden = current !== null && current.memoizedState !== null;
+
+        if (finishedWork.mode & ConcurrentMode) {
+          // Before committing the children, track on the stack whether this
+          // offscreen subtree was already hidden, so that we don't unmount the
+          // effects again.
+          const prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
+          const prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden || isHidden;
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || wasHidden;
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+        } else {
+          recursivelyTraverseMutationEffects(root, finishedWork);
+        }
+
+        commitReconciliationEffects(finishedWork);
+        const offscreenInstance = finishedWork.stateNode; // TODO: Add explicit effect flag to set _current.
+
+        offscreenInstance._current = finishedWork; // Offscreen stores pending changes to visibility in `_pendingVisibility`. This is
+        // to support batching of `attach` and `detach` calls.
+
+        offscreenInstance._visibility &= ~OffscreenDetached;
+        offscreenInstance._visibility |= offscreenInstance._pendingVisibility & OffscreenDetached;
+
+        if (flags & Visibility) {
+          // Track the current state on the Offscreen instance so we can
+          // read it during an event
+          if (isHidden) {
+            offscreenInstance._visibility &= ~OffscreenVisible;
+          } else {
+            offscreenInstance._visibility |= OffscreenVisible;
+          }
+
+          if (isHidden) {
+            const isUpdate = current !== null;
+            const wasHiddenByAncestorOffscreen = offscreenSubtreeIsHidden || offscreenSubtreeWasHidden; // Only trigger disapper layout effects if:
+            //   - This is an update, not first mount.
+            //   - This Offscreen was not hidden before.
+            //   - Ancestor Offscreen was not hidden in previous commit.
+
+            if (isUpdate && !wasHidden && !wasHiddenByAncestorOffscreen) {
+              if ((finishedWork.mode & ConcurrentMode) !== NoMode) {
+                // Disappear the layout effects of all the children
+                recursivelyTraverseDisappearLayoutEffects(finishedWork);
+              }
+            }
+          } // Offscreen with manual mode manages visibility manually.
+
+
+          if (!isOffscreenManual(finishedWork)) {
+            // TODO: This needs to run whenever there's an insertion or update
+            // inside a hidden Offscreen tree.
+            hideOrUnhideAllChildren(finishedWork, isHidden);
+          }
+        } // TODO: Move to passive phase
+
+
+        if (flags & Update) {
+          const offscreenQueue = finishedWork.updateQueue;
+
+          if (offscreenQueue !== null) {
+            const retryQueue = offscreenQueue.retryQueue;
+
+            if (retryQueue !== null) {
+              offscreenQueue.retryQueue = null;
+              attachSuspenseRetryListeners(finishedWork, retryQueue);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case SuspenseListComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Update) {
+          const retryQueue = finishedWork.updateQueue;
+
+          if (retryQueue !== null) {
+            finishedWork.updateQueue = null;
+            attachSuspenseRetryListeners(finishedWork, retryQueue);
+          }
+        }
+
+        return;
+      }
+
+    case ScopeComponent:
+      {
+
+        return;
+      }
+
+    default:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        return;
+      }
+  }
+}
+
+function commitReconciliationEffects(finishedWork) {
+  // Placement effects (insertions, reorders) can be scheduled on any fiber
+  // type. They needs to happen after the children effects have fired, but
+  // before the effects on this fiber have fired.
+  const flags = finishedWork.flags;
+
+  if (flags & Placement) {
+    try {
+      commitPlacement(finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    } // Clear the "placement" from effect tag so that we know that this is
+    // inserted, before any life-cycles like componentDidMount gets called.
+    // TODO: findDOMNode doesn't rely on this any more but isMounted does
+    // and isMounted is deprecated anyway so we should be able to kill this.
+
+
+    finishedWork.flags &= ~Placement;
+  }
+
+  if (flags & Hydrating) {
+    finishedWork.flags &= ~Hydrating;
+  }
+}
+
+function commitLayoutEffects(finishedWork, root, committedLanes) {
+  inProgressLanes = committedLanes;
+  inProgressRoot = root;
+  const current = finishedWork.alternate;
+  commitLayoutEffectOnFiber(root, current, finishedWork);
+  inProgressLanes = null;
+  inProgressRoot = null;
+}
+
+function recursivelyTraverseLayoutEffects(root, parentFiber, lanes) {
+
+  if (parentFiber.subtreeFlags & LayoutMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      const current = child.alternate;
+      commitLayoutEffectOnFiber(root, current, child);
+      child = child.sibling;
+    }
+  }
+}
+
+function disappearLayoutEffects(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent:
+      {
+        // TODO (Offscreen) Check: flags & LayoutStatic
+        if (shouldProfile(finishedWork)) {
+          try {
+            startLayoutEffectTimer();
+            commitHookEffectListUnmount(Layout, finishedWork, finishedWork.return);
+          } finally {
+            recordLayoutEffectDuration(finishedWork);
+          }
+        } else {
+          commitHookEffectListUnmount(Layout, finishedWork, finishedWork.return);
+        }
+
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      }
+
+    case ClassComponent:
+      {
+        // TODO (Offscreen) Check: flags & RefStatic
+        safelyDetachRef(finishedWork, finishedWork.return);
+        const instance = finishedWork.stateNode;
+
+        if (typeof instance.componentWillUnmount === 'function') {
+          safelyCallComponentWillUnmount(finishedWork, finishedWork.return, instance);
+        }
+
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      }
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      {
+        // TODO (Offscreen) Check: flags & RefStatic
+        safelyDetachRef(finishedWork, finishedWork.return);
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        // TODO (Offscreen) Check: flags & RefStatic
+        safelyDetachRef(finishedWork, finishedWork.return);
+        const isHidden = finishedWork.memoizedState !== null;
+
+        if (isHidden) ; else {
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
+  // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+  let child = parentFiber.child;
+
+  while (child !== null) {
+    disappearLayoutEffects(child);
+    child = child.sibling;
+  }
+}
+
+function reappearLayoutEffects(finishedRoot, current, finishedWork, // This function visits both newly finished work and nodes that were re-used
+// from a previously committed tree. We cannot check non-static flags if the
+// node was reused.
+includeWorkInProgressEffects) {
+  // Turn on layout effects in a tree that previously disappeared.
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // TODO: Check flags & LayoutStatic
+
+        commitHookLayoutEffects(finishedWork, Layout);
+        break;
+      }
+
+    case ClassComponent:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // TODO: Check for LayoutStatic flag
+
+        const instance = finishedWork.stateNode;
+
+        if (typeof instance.componentDidMount === 'function') {
+          try {
+            instance.componentDidMount();
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        } // Commit any callbacks that would have fired while the component
+        // was hidden.
+
+
+        const updateQueue = finishedWork.updateQueue;
+
+        if (updateQueue !== null) {
+          commitHiddenCallbacks(updateQueue, instance);
+        } // If this is newly finished work, check for setState callbacks
+
+
+        if (includeWorkInProgressEffects && flags & Callback) {
+          commitClassCallbacks(finishedWork);
+        } // TODO: Check flags & RefStatic
+
+
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      }
+    // Unlike commitLayoutEffectsOnFiber, we don't need to handle HostRoot
+    // because this function only visits nodes that are inside an
+    // Offscreen fiber.
+    // case HostRoot: {
+    //  ...
+    // }
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // Renderers may schedule work to be done after host components are mounted
+        // (eg DOM renderer may schedule auto-focus for inputs and form controls).
+        // These effects should only be committed when components are first mounted,
+        // aka when there is no current/alternate.
+
+        if (includeWorkInProgressEffects && current === null && flags & Update) {
+          commitHostComponentMount(finishedWork);
+        } // TODO: Check flags & Ref
+
+
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      }
+
+    case Profiler:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // TODO: Figure out how Profiler updates should work with Offscreen
+
+        if (includeWorkInProgressEffects && flags & Update) {
+          commitProfilerUpdate(finishedWork, current);
+        }
+
+        break;
+      }
+
+    case SuspenseComponent:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // TODO: Figure out how Suspense hydration callbacks should work
+        // with Offscreen.
+
+        if (includeWorkInProgressEffects && flags & Update) {
+          commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
+        }
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const offscreenState = finishedWork.memoizedState;
+        const isHidden = offscreenState !== null;
+
+        if (isHidden) ; else {
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+        } // TODO: Check flags & Ref
+
+
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseReappearLayoutEffects(finishedRoot, parentFiber, includeWorkInProgressEffects) {
+  // This function visits both newly finished work and nodes that were re-used
+  // from a previously committed tree. We cannot check non-static flags if the
+  // node was reused.
+  const childShouldIncludeWorkInProgressEffects = includeWorkInProgressEffects && (parentFiber.subtreeFlags & LayoutMask) !== NoFlags$1; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+  let child = parentFiber.child;
+
+  while (child !== null) {
+    const current = child.alternate;
+    reappearLayoutEffects(finishedRoot, current, child, childShouldIncludeWorkInProgressEffects);
+    child = child.sibling;
+  }
+}
+
+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) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
+
+function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
+  {
+    let previousCache = null;
+
+    if (current !== null && current.memoizedState !== null && current.memoizedState.cachePool !== null) {
+      previousCache = current.memoizedState.cachePool.pool;
+    }
+
+    let nextCache = null;
+
+    if (finishedWork.memoizedState !== null && finishedWork.memoizedState.cachePool !== null) {
+      nextCache = finishedWork.memoizedState.cachePool.pool;
+    } // Retain/release the cache used for pending (suspended) nodes.
+    // Note that this is only reached in the non-suspended/visible case:
+    // when the content is suspended/hidden, the retain/release occurs
+    // via the parent Suspense component (see case above).
+
+
+    if (nextCache !== previousCache) {
+      if (nextCache != null) {
+        retainCache(nextCache);
+      }
+
+      if (previousCache != null) {
+        releaseCache(previousCache);
+      }
+    }
+  }
+}
+
+function commitCachePassiveMountEffect(current, finishedWork) {
+  {
+    let previousCache = null;
+
+    if (finishedWork.alternate !== null) {
+      previousCache = finishedWork.alternate.memoizedState.cache;
+    }
+
+    const nextCache = finishedWork.memoizedState.cache; // Retain/release the cache. In theory the cache component
+    // could be "borrowing" a cache instance owned by some parent,
+    // in which case we could avoid retaining/releasing. But it
+    // is non-trivial to determine when that is the case, so we
+    // always retain/release.
+
+    if (nextCache !== previousCache) {
+      retainCache(nextCache);
+
+      if (previousCache != null) {
+        releaseCache(previousCache);
+      }
+    }
+  }
+}
+
+function commitPassiveMountEffects(root, finishedWork, committedLanes, committedTransitions) {
+  commitPassiveMountOnFiber(root, finishedWork, committedLanes, committedTransitions);
+}
+
+function recursivelyTraversePassiveMountEffects(root, parentFiber, committedLanes, committedTransitions) {
+
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      commitPassiveMountOnFiber(root, child, committedLanes, committedTransitions);
+      child = child.sibling;
+    }
+  }
+}
+
+function commitPassiveMountOnFiber(finishedRoot, finishedWork, committedLanes, committedTransitions) {
+  // When updating this function, also update reconnectPassiveEffects, which does
+  // most of the same things when an offscreen tree goes from hidden -> visible,
+  // or when toggling effects inside a hidden tree.
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+
+        if (flags & Passive$1) {
+          commitHookPassiveMountEffects(finishedWork, Passive | HasEffect);
+        }
+
+        break;
+      }
+
+    case HostRoot:
+      {
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+
+        if (flags & Passive$1) {
+          {
+            let previousCache = null;
+
+            if (finishedWork.alternate !== null) {
+              previousCache = finishedWork.alternate.memoizedState.cache;
+            }
+
+            const nextCache = finishedWork.memoizedState.cache; // Retain/release the root cache.
+            // Note that on initial mount, previousCache and nextCache will be the same
+            // and this retain won't occur. To counter this, we instead retain the HostRoot's
+            // initial cache when creating the root itself (see createFiberRoot() in
+            // ReactFiberRoot.js). Subsequent updates that change the cache are reflected
+            // here, such that previous/next caches are retained correctly.
+
+            if (nextCache !== previousCache) {
+              retainCache(nextCache);
+
+              if (previousCache != null) {
+                releaseCache(previousCache);
+              }
+            }
+          }
+        }
+
+        break;
+      }
+
+    case LegacyHiddenComponent:
+      {
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        // TODO: Pass `current` as argument to this function
+        const instance = finishedWork.stateNode;
+        const nextState = finishedWork.memoizedState;
+        const isHidden = nextState !== null;
+
+        if (isHidden) {
+          if (instance._visibility & OffscreenPassiveEffectsConnected) {
+            // The effects are currently connected. Update them.
+            recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          } else {
+            if (finishedWork.mode & ConcurrentMode) {
+              // The effects are currently disconnected. Since the tree is hidden,
+              // don't connect them. This also applies to the initial render.
+              {
+                // "Atomic" effects are ones that need to fire on every commit,
+                // even during pre-rendering. An example is updating the reference
+                // count on cache instances.
+                recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+              }
+            } else {
+              // Legacy Mode: Fire the effects even if the tree is hidden.
+              instance._visibility |= OffscreenPassiveEffectsConnected;
+              recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+            }
+          }
+        } else {
+          // Tree is visible
+          if (instance._visibility & OffscreenPassiveEffectsConnected) {
+            // The effects are currently connected. Update them.
+            recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          } else {
+            // The effects are currently disconnected. Reconnect them, while also
+            // firing effects inside newly mounted trees. This also applies to
+            // the initial render.
+            instance._visibility |= OffscreenPassiveEffectsConnected;
+            const includeWorkInProgressEffects = (finishedWork.subtreeFlags & PassiveMask) !== NoFlags$1;
+            recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+          }
+        }
+
+        if (flags & Passive$1) {
+          const current = finishedWork.alternate;
+          commitOffscreenPassiveMountEffects(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+
+        if (flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitCachePassiveMountEffect(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case TracingMarkerComponent:
+
+    default:
+      {
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseReconnectPassiveEffects(finishedRoot, parentFiber, committedLanes, committedTransitions, includeWorkInProgressEffects) {
+  // This function visits both newly finished work and nodes that were re-used
+  // from a previously committed tree. We cannot check non-static flags if the
+  // node was reused.
+  const childShouldIncludeWorkInProgressEffects = includeWorkInProgressEffects && (parentFiber.subtreeFlags & PassiveMask) !== NoFlags$1; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+  let child = parentFiber.child;
+
+  while (child !== null) {
+    reconnectPassiveEffects(finishedRoot, child, committedLanes, committedTransitions, childShouldIncludeWorkInProgressEffects);
+    child = child.sibling;
+  }
+}
+
+function reconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, // This function visits both newly finished work and nodes that were re-used
+// from a previously committed tree. We cannot check non-static flags if the
+// node was reused.
+includeWorkInProgressEffects) {
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects); // TODO: Check for PassiveStatic flag
+
+        commitHookPassiveMountEffects(finishedWork, Passive);
+        break;
+      }
+    // Unlike commitPassiveMountOnFiber, we don't need to handle HostRoot
+    // because this function only visits nodes that are inside an
+    // Offscreen fiber.
+    // case HostRoot: {
+    //  ...
+    // }
+
+    case LegacyHiddenComponent:
+      {
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const instance = finishedWork.stateNode;
+        const nextState = finishedWork.memoizedState;
+        const isHidden = nextState !== null;
+
+        if (isHidden) {
+          if (instance._visibility & OffscreenPassiveEffectsConnected) {
+            // The effects are currently connected. Update them.
+            recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+          } else {
+            if (finishedWork.mode & ConcurrentMode) {
+              // The effects are currently disconnected. Since the tree is hidden,
+              // don't connect them. This also applies to the initial render.
+              {
+                // "Atomic" effects are ones that need to fire on every commit,
+                // even during pre-rendering. An example is updating the reference
+                // count on cache instances.
+                recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+              }
+            } else {
+              // Legacy Mode: Fire the effects even if the tree is hidden.
+              instance._visibility |= OffscreenPassiveEffectsConnected;
+              recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+            }
+          }
+        } else {
+          // Tree is visible
+          // Since we're already inside a reconnecting tree, it doesn't matter
+          // whether the effects are currently connected. In either case, we'll
+          // continue traversing the tree and firing all the effects.
+          //
+          // We do need to set the "connected" flag on the instance, though.
+          instance._visibility |= OffscreenPassiveEffectsConnected;
+          recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+        }
+
+        if (includeWorkInProgressEffects && flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitOffscreenPassiveMountEffects(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+
+        if (includeWorkInProgressEffects && flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitCachePassiveMountEffect(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case TracingMarkerComponent:
+
+    default:
+      {
+        recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseAtomicPassiveEffects(finishedRoot, parentFiber, committedLanes, committedTransitions) {
+
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      commitAtomicPassiveEffects(finishedRoot, child);
+      child = child.sibling;
+    }
+  }
+}
+
+function commitAtomicPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions) {
+  // "Atomic" effects are ones that need to fire on every commit, even during
+  // pre-rendering. We call this function when traversing a hidden tree whose
+  // regular effects are currently disconnected.
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case OffscreenComponent:
+      {
+        recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+
+        if (flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitOffscreenPassiveMountEffects(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+
+        if (flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitCachePassiveMountEffect(current, finishedWork);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+        break;
+      }
+  }
+}
+
+function commitPassiveUnmountEffects(finishedWork) {
+  commitPassiveUnmountOnFiber(finishedWork);
+} // If we're inside a brand new tree, or a tree that was already visible, then we
+// should only suspend host components that have a ShouldSuspendCommit flag.
+// Components without it haven't changed since the last commit, so we can skip
+// over those.
+//
+// When we enter a tree that is being revealed (going from hidden -> visible),
+// we need to suspend _any_ component that _may_ suspend. Even if they're
+// already in the "current" tree. Because their visibility has changed, the
+// browser may not have prerendered them yet. So we check the MaySuspendCommit
+// flag instead.
+
+let suspenseyCommitFlag = ShouldSuspendCommit;
+function accumulateSuspenseyCommit(finishedWork) {
+  accumulateSuspenseyCommitOnFiber(finishedWork);
+}
+
+function recursivelyAccumulateSuspenseyCommit(parentFiber) {
+  if (parentFiber.subtreeFlags & suspenseyCommitFlag) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      accumulateSuspenseyCommitOnFiber(child);
+      child = child.sibling;
+    }
+  }
+}
+
+function accumulateSuspenseyCommitOnFiber(fiber) {
+  switch (fiber.tag) {
+    case HostHoistable:
+      {
+        recursivelyAccumulateSuspenseyCommit(fiber);
+
+        if (fiber.flags & suspenseyCommitFlag) {
+          if (fiber.memoizedState !== null) {
+            suspendResource( // This should always be set by visiting HostRoot first
+            currentHoistableRoot, fiber.memoizedState, fiber.memoizedProps);
+          }
+        }
+
+        break;
+      }
+
+    case HostComponent:
+      {
+        recursivelyAccumulateSuspenseyCommit(fiber);
+
+        break;
+      }
+
+    case HostRoot:
+    case HostPortal:
+      {
+        {
+          const previousHoistableRoot = currentHoistableRoot;
+          const container = fiber.stateNode.containerInfo;
+          currentHoistableRoot = getHoistableRoot(container);
+          recursivelyAccumulateSuspenseyCommit(fiber);
+          currentHoistableRoot = previousHoistableRoot;
+        }
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const isHidden = fiber.memoizedState !== null;
+
+        if (isHidden) ; else {
+          const current = fiber.alternate;
+          const wasHidden = current !== null && current.memoizedState !== null;
+
+          if (wasHidden) {
+            // This tree is being revealed. Visit all newly visible suspensey
+            // instances, even if they're in the current tree.
+            const prevFlags = suspenseyCommitFlag;
+            suspenseyCommitFlag = MaySuspendCommit;
+            recursivelyAccumulateSuspenseyCommit(fiber);
+            suspenseyCommitFlag = prevFlags;
+          } else {
+            recursivelyAccumulateSuspenseyCommit(fiber);
+          }
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyAccumulateSuspenseyCommit(fiber);
+      }
+  }
+}
+
+function detachAlternateSiblings(parentFiber) {
+  // A fiber was deleted from this parent fiber, but it's still part of the
+  // previous (alternate) parent fiber's list of children. Because children
+  // are a linked list, an earlier sibling that's still alive will be
+  // connected to the deleted fiber via its `alternate`:
+  //
+  //   live fiber --alternate--> previous live fiber --sibling--> deleted
+  //   fiber
+  //
+  // We can't disconnect `alternate` on nodes that haven't been deleted yet,
+  // but we can disconnect the `sibling` and `child` pointers.
+  const previousFiber = parentFiber.alternate;
+
+  if (previousFiber !== null) {
+    let detachedChild = previousFiber.child;
+
+    if (detachedChild !== null) {
+      previousFiber.child = null;
+
+      do {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        const detachedSibling = detachedChild.sibling; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+        detachedChild.sibling = null;
+        detachedChild = detachedSibling;
+      } while (detachedChild !== null);
+    }
+  }
+}
+
+function commitHookPassiveUnmountEffects(finishedWork, nearestMountedAncestor, hookFlags) {
+  if (shouldProfile(finishedWork)) {
+    startPassiveEffectTimer();
+    commitHookEffectListUnmount(hookFlags, finishedWork, nearestMountedAncestor);
+    recordPassiveEffectDuration(finishedWork);
+  } else {
+    commitHookEffectListUnmount(hookFlags, finishedWork, nearestMountedAncestor);
+  }
+}
+
+function recursivelyTraversePassiveUnmountEffects(parentFiber) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects have fired.
+  const deletions = parentFiber.deletions;
+
+  if ((parentFiber.flags & ChildDeletion) !== NoFlags$1) {
+    if (deletions !== null) {
+      for (let i = 0; i < deletions.length; i++) {
+        const childToDelete = deletions[i]; // TODO: Convert this to use recursion
+
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(childToDelete, parentFiber);
+      }
+    }
+
+    detachAlternateSiblings(parentFiber);
+  }
+
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      commitPassiveUnmountOnFiber(child);
+      child = child.sibling;
+    }
+  }
+}
+
+function commitPassiveUnmountOnFiber(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraversePassiveUnmountEffects(finishedWork);
+
+        if (finishedWork.flags & Passive$1) {
+          commitHookPassiveUnmountEffects(finishedWork, finishedWork.return, Passive | HasEffect);
+        }
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const instance = finishedWork.stateNode;
+        const nextState = finishedWork.memoizedState;
+        const isHidden = nextState !== null;
+
+        if (isHidden && instance._visibility & OffscreenPassiveEffectsConnected && ( // For backwards compatibility, don't unmount when a tree suspends. In
+        // the future we may change this to unmount after a delay.
+        finishedWork.return === null || finishedWork.return.tag !== SuspenseComponent)) {
+          // The effects are currently connected. Disconnect them.
+          // TODO: Add option or heuristic to delay before disconnecting the
+          // effects. Then if the tree reappears before the delay has elapsed, we
+          // can skip toggling the effects entirely.
+          instance._visibility &= ~OffscreenPassiveEffectsConnected;
+          recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+        } else {
+          recursivelyTraversePassiveUnmountEffects(finishedWork);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraversePassiveUnmountEffects(finishedWork);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects have fired.
+  const deletions = parentFiber.deletions;
+
+  if ((parentFiber.flags & ChildDeletion) !== NoFlags$1) {
+    if (deletions !== null) {
+      for (let i = 0; i < deletions.length; i++) {
+        const childToDelete = deletions[i]; // TODO: Convert this to use recursion
+
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(childToDelete, parentFiber);
+      }
+    }
+
+    detachAlternateSiblings(parentFiber);
+  }
+
+  let child = parentFiber.child;
+
+  while (child !== null) {
+    disconnectPassiveEffect(child);
+    child = child.sibling;
+  }
+}
+
+function disconnectPassiveEffect(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        // TODO: Check PassiveStatic flag
+        commitHookPassiveUnmountEffects(finishedWork, finishedWork.return, Passive); // When disconnecting passive effects, we fire the effects in the same
+        // order as during a deletiong: parent before child
+
+        recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const instance = finishedWork.stateNode;
+
+        if (instance._visibility & OffscreenPassiveEffectsConnected) {
+          instance._visibility &= ~OffscreenPassiveEffectsConnected;
+          recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+        break;
+      }
+  }
+}
+
+function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(deletedSubtreeRoot, nearestMountedAncestor) {
+  while (nextEffect !== null) {
+    const fiber = nextEffect; // Deletion effects fire in parent -> child order
+    commitPassiveUnmountInsideDeletedTreeOnFiber(fiber, nearestMountedAncestor);
+    const child = fiber.child; // TODO: Only traverse subtree if it has a PassiveStatic flag.
+
+    if (child !== null) {
+      child.return = fiber;
+      nextEffect = child;
+    } else {
+      commitPassiveUnmountEffectsInsideOfDeletedTree_complete(deletedSubtreeRoot);
+    }
+  }
+}
+
+function commitPassiveUnmountEffectsInsideOfDeletedTree_complete(deletedSubtreeRoot) {
+  while (nextEffect !== null) {
+    const fiber = nextEffect;
+    const sibling = fiber.sibling;
+    const returnFiber = fiber.return; // Recursively traverse the entire deleted tree and clean up fiber fields.
+    // This is more aggressive than ideal, and the long term goal is to only
+    // have to detach the deleted tree at the root.
+
+    detachFiberAfterEffects(fiber);
+
+    if (fiber === deletedSubtreeRoot) {
+      nextEffect = null;
+      return;
+    }
+
+    if (sibling !== null) {
+      sibling.return = returnFiber;
+      nextEffect = sibling;
+      return;
+    }
+
+    nextEffect = returnFiber;
+  }
+}
+
+function commitPassiveUnmountInsideDeletedTreeOnFiber(current, nearestMountedAncestor) {
+  switch (current.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        commitHookPassiveUnmountEffects(current, nearestMountedAncestor, Passive);
+        break;
+      }
+    // TODO: run passive unmount effects when unmounting a root.
+    // Because passive unmount effects are not currently run,
+    // the cache instance owned by the root will never be freed.
+    // When effects are run, the cache should be freed here:
+    // case HostRoot: {
+    //   if (enableCache) {
+    //     const cache = current.memoizedState.cache;
+    //     releaseCache(cache);
+    //   }
+    //   break;
+    // }
+
+    case LegacyHiddenComponent:
+    case OffscreenComponent:
+      {
+        {
+          if (current.memoizedState !== null && current.memoizedState.cachePool !== null) {
+            const cache = current.memoizedState.cachePool.pool; // Retain/release the cache used for pending (suspended) nodes.
+            // Note that this is only reached in the non-suspended/visible case:
+            // when the content is suspended/hidden, the retain/release occurs
+            // via the parent Suspense component (see case above).
+
+            if (cache != null) {
+              retainCache(cache);
+            }
+          }
+        }
+
+        break;
+      }
+
+    case SuspenseComponent:
+      {
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        {
+          const cache = current.memoizedState.cache;
+          releaseCache(cache);
+        }
+
+        break;
+      }
+  }
+}
+
+function getCacheSignal() {
+
+  const cache = readContext(CacheContext);
+  return cache.controller.signal;
+}
+
+function getCacheForType(resourceType) {
+
+  const cache = readContext(CacheContext);
+  let cacheForType = cache.data.get(resourceType);
+
+  if (cacheForType === undefined) {
+    cacheForType = resourceType();
+    cache.data.set(resourceType, cacheForType);
+  }
+
+  return cacheForType;
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal,
+  getCacheForType
+};
+
+const PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
+      ReactCurrentCache = ReactSharedInternals.ReactCurrentCache,
+      ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner,
+      ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig,
+      ReactCurrentActQueue = ReactSharedInternals.ReactCurrentActQueue;
+const NoContext =
+/*             */
+0b000;
+const BatchedContext =
+/*               */
+0b001;
+const RenderContext =
+/*         */
+0b010;
+const CommitContext =
+/*         */
+0b100;
+const RootInProgress = 0;
+const RootFatalErrored = 1;
+const RootErrored = 2;
+const RootSuspended = 3;
+const RootSuspendedWithDelay = 4;
+const RootCompleted = 5;
+const RootDidNotComplete = 6; // Describes where we are in the React execution stack
+
+let executionContext = NoContext; // The root we're working on
+
+let workInProgressRoot = null; // The fiber we're working on
+
+let workInProgress = null; // The lanes we're rendering
+
+let workInProgressRootRenderLanes = NoLanes;
+const NotSuspended = 0;
+const SuspendedOnError = 1;
+const SuspendedOnData = 2;
+const SuspendedOnImmediate = 3;
+const SuspendedOnInstance = 4;
+const SuspendedOnInstanceAndReadyToContinue = 5;
+const SuspendedOnDeprecatedThrowPromise = 6;
+const SuspendedAndReadyToContinue = 7;
+const SuspendedOnHydration = 8; // When this is true, the work-in-progress fiber just suspended (or errored) and
+// we've yet to unwind the stack. In some cases, we may yield to the main thread
+// after this happens. If the fiber is pinged before we resume, we can retry
+// immediately instead of unwinding the stack.
+
+let workInProgressSuspendedReason = NotSuspended;
+let workInProgressThrownValue = null; // Whether a ping listener was attached during this render. This is slightly
+// different that whether something suspended, because we don't add multiple
+// listeners to a promise we've already seen (per root and lane).
+
+let workInProgressRootDidAttachPingListener = false; // A contextual version of workInProgressRootRenderLanes. It is a superset of
+// the lanes that we started working on at the root. When we enter a subtree
+// that is currently hidden, we add the lanes that would have committed if
+// the hidden tree hadn't been deferred. This is modified by the
+// HiddenContext module.
+//
+// Most things in the work loop should deal with workInProgressRootRenderLanes.
+// Most things in begin/complete phases should deal with entangledRenderLanes.
+
+let entangledRenderLanes = NoLanes; // Whether to root completed, errored, suspended, etc.
+
+let workInProgressRootExitStatus = RootInProgress; // A fatal error, if one is thrown
+
+let workInProgressRootFatalError = null; // The work left over by components that were visited during this render. Only
+// includes unprocessed updates, not work in bailed out children.
+
+let workInProgressRootSkippedLanes = NoLanes; // Lanes that were updated (in an interleaved event) during this render.
+
+let workInProgressRootInterleavedUpdatedLanes = NoLanes; // Lanes that were updated during the render phase (*not* an interleaved event).
+
+let workInProgressRootPingedLanes = NoLanes; // If this lane scheduled deferred work, this is the lane of the deferred task.
+
+let workInProgressDeferredLane = NoLane; // Errors that are thrown during the render phase.
+
+let workInProgressRootConcurrentErrors = null; // These are errors that we recovered from without surfacing them to the UI.
+// We will log them once the tree commits.
+
+let workInProgressRootRecoverableErrors = null; // The most recent time we either committed a fallback, or when a fallback was
+// filled in with the resolved UI. This lets us throttle the appearance of new
+// content as it streams in, to minimize jank.
+// TODO: Think of a better name for this variable?
+
+let globalMostRecentFallbackTime = 0;
+const FALLBACK_THROTTLE_MS = 300; // The absolute time for when we should start giving up on rendering
+// more and prefer CPU suspense heuristics instead.
+
+let workInProgressRootRenderTargetTime = Infinity; // How long a render is supposed to take before we start following CPU
+// suspense heuristics and opt out of rendering more content.
+
+const RENDER_TIMEOUT_MS = 500;
+let workInProgressTransitions = null;
+
+function resetRenderTimer() {
+  workInProgressRootRenderTargetTime = now$1() + RENDER_TIMEOUT_MS;
+}
+
+function getRenderTargetTime() {
+  return workInProgressRootRenderTargetTime;
+}
+let hasUncaughtError = false;
+let firstUncaughtError = null;
+let legacyErrorBoundariesThatAlreadyFailed = null; // Only used when enableProfilerNestedUpdateScheduledHook is true;
+let rootDoesHavePassiveEffects = false;
+let rootWithPendingPassiveEffects = null;
+let pendingPassiveEffectsLanes = NoLanes;
+let pendingPassiveProfilerEffects = [];
+let pendingPassiveEffectsRemainingLanes = NoLanes;
+let pendingPassiveTransitions = null; // Use these to prevent an infinite loop of nested updates
+
+const NESTED_UPDATE_LIMIT = 50;
+let nestedUpdateCount = 0;
+let rootWithNestedUpdates = null;
+function getWorkInProgressRoot() {
+  return workInProgressRoot;
+}
+function getWorkInProgressRootRenderLanes() {
+  return workInProgressRootRenderLanes;
+}
+function isWorkLoopSuspendedOnData() {
+  return workInProgressSuspendedReason === SuspendedOnData;
+}
+function requestUpdateLane(fiber) {
+  // Special cases
+  const mode = fiber.mode;
+
+  if ((mode & ConcurrentMode) === NoMode) {
+    return SyncLane;
+  } else if ((executionContext & RenderContext) !== NoContext && workInProgressRootRenderLanes !== NoLanes) {
+    // This is a render phase update. These are not officially supported. The
+    // old behavior is to give this the same "thread" (lanes) as
+    // whatever is currently rendering. So if you call `setState` on a component
+    // that happens later in the same render, it will flush. Ideally, we want to
+    // remove the special case and treat them as if they came from an
+    // interleaved event. Regardless, this pattern is not officially supported.
+    // This behavior is only a fallback. The flag only exists until we can roll
+    // out the setState warning, since existing code might accidentally rely on
+    // the current behavior.
+    return pickArbitraryLane(workInProgressRootRenderLanes);
+  }
+
+  const isTransition = requestCurrentTransition() !== NoTransition;
+
+  if (isTransition) {
+
+    const actionScopeLane = peekEntangledActionLane();
+    return actionScopeLane !== NoLane ? // We're inside an async action scope. Reuse the same lane.
+    actionScopeLane : // We may or may not be inside an async action scope. If we are, this
+    // is the first update in that scope. Either way, we need to get a
+    // fresh transition lane.
+    requestTransitionLane();
+  } // Updates originating inside certain React methods, like flushSync, have
+  // their priority set by tracking it with a context variable.
+  //
+  // The opaque type returned by the host config is internally a lane, so we can
+  // use that directly.
+  // TODO: Move this type conversion to the event priority module.
+
+
+  const updateLane = getCurrentUpdatePriority();
+
+  if (updateLane !== NoLane) {
+    return updateLane;
+  } // This update originated outside React. Ask the host environment for an
+  // appropriate priority, based on the type of event.
+  //
+  // The opaque type returned by the host config is internally a lane, so we can
+  // use that directly.
+  // TODO: Move this type conversion to the event priority module.
+
+
+  const eventLane = getCurrentEventPriority();
+  return eventLane;
+}
+
+function requestRetryLane(fiber) {
+  // This is a fork of `requestUpdateLane` designed specifically for Suspense
+  // "retries" — a special update that attempts to flip a Suspense boundary
+  // from its placeholder state to its primary/resolved state.
+  // Special cases
+  const mode = fiber.mode;
+
+  if ((mode & ConcurrentMode) === NoMode) {
+    return SyncLane;
+  }
+
+  return claimNextRetryLane();
+}
+
+function requestDeferredLane() {
+  if (workInProgressDeferredLane === NoLane) {
+    // If there are multiple useDeferredValue hooks in the same render, the
+    // tasks that they spawn should all be batched together, so they should all
+    // receive the same lane.
+    // Check the priority of the current render to decide the priority of the
+    // deferred task.
+    // OffscreenLane is used for prerendering, but we also use OffscreenLane
+    // for incremental hydration. It's given the lowest priority because the
+    // initial HTML is the same as the final UI. But useDeferredValue during
+    // hydration is an exception — we need to upgrade the UI to the final
+    // value. So if we're currently hydrating, we treat it like a transition.
+    const isPrerendering = includesSomeLane(workInProgressRootRenderLanes, OffscreenLane) && !getIsHydrating();
+
+    if (isPrerendering) {
+      // There's only one OffscreenLane, so if it contains deferred work, we
+      // should just reschedule using the same lane.
+      workInProgressDeferredLane = OffscreenLane;
+    } else {
+      // Everything else is spawned as a transition.
+      workInProgressDeferredLane = requestTransitionLane();
+    }
+  }
+
+  return workInProgressDeferredLane;
+}
+function scheduleUpdateOnFiber(root, fiber, lane) {
+  // finish loading.
+
+
+  if ( // Suspended render phase
+  root === workInProgressRoot && workInProgressSuspendedReason === SuspendedOnData || // Suspended commit phase
+  root.cancelPendingCommit !== null) {
+    // The incoming update might unblock the current render. Interrupt the
+    // current attempt and restart from the top.
+    prepareFreshStack(root, NoLanes);
+    markRootSuspended(root, workInProgressRootRenderLanes, workInProgressDeferredLane);
+  } // Mark that the root has a pending update.
+
+
+  markRootUpdated(root, lane);
+
+  if ((executionContext & RenderContext) !== NoLanes && root === workInProgressRoot) ; else {
+    // This is a normal update, scheduled from outside the render phase. For
+    // example, during an input event.
+    {
+      if (isDevToolsPresent) {
+        addFiberToLanesMap(root, fiber, lane);
+      }
+    }
+
+    if (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.
+      if ((executionContext & RenderContext) === NoContext) {
+        workInProgressRootInterleavedUpdatedLanes = mergeLanes(workInProgressRootInterleavedUpdatedLanes, lane);
+      }
+
+      if (workInProgressRootExitStatus === RootSuspendedWithDelay) {
+        // The root already suspended with a delay, which means this render
+        // definitely won't finish. Since we have a new update, let's mark it as
+        // suspended now, right before marking the incoming update. This has the
+        // effect of interrupting the current render and switching to the update.
+        // TODO: Make sure this doesn't override pings that happen while we've
+        // already started rendering.
+        markRootSuspended(root, workInProgressRootRenderLanes, workInProgressDeferredLane);
+      }
+    }
+
+    ensureRootIsScheduled(root);
+
+    if (lane === SyncLane && executionContext === NoContext && (fiber.mode & ConcurrentMode) === NoMode) {
+      {
+        // Flush the synchronous work now, unless we're already working or inside
+        // a batch. This is intentionally inside scheduleUpdateOnFiber instead of
+        // scheduleCallbackForFiber to preserve the ability to schedule a callback
+        // without immediately flushing it. We only do this for user-initiated
+        // updates, to preserve historical behavior of legacy mode.
+        resetRenderTimer();
+        flushSyncWorkOnLegacyRootsOnly();
+      }
+    }
+  }
+}
+function scheduleInitialHydrationOnRoot(root, lane) {
+  // This is a special fork of scheduleUpdateOnFiber that is only used to
+  // schedule the initial hydration of a root that has just been created. Most
+  // of the stuff in scheduleUpdateOnFiber can be skipped.
+  //
+  // The main reason for this separate path, though, is to distinguish the
+  // initial children from subsequent updates. In fully client-rendered roots
+  // (createRoot instead of hydrateRoot), all top-level renders are modeled as
+  // updates, but hydration roots are special because the initial render must
+  // match what was rendered on the server.
+  const current = root.current;
+  current.lanes = lane;
+  markRootUpdated(root, lane);
+  ensureRootIsScheduled(root);
+}
+function isUnsafeClassRenderPhaseUpdate(fiber) {
+  // Check if this is a render phase update. Only called by class components,
+  // which special (deprecated) behavior for UNSAFE_componentWillReceive props.
+  return (executionContext & RenderContext) !== NoContext;
+} // This is the entry point for every concurrent task, i.e. anything that
+// goes through Scheduler.
+
+function performConcurrentWorkOnRoot(root, didTimeout) {
+  {
+    resetNestedUpdateFlag();
+  }
+
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw Error(formatProdErrorMessage(327));
+  } // Flush any pending passive effects before deciding which lanes to work on,
+  // in case they schedule additional work.
+
+
+  const originalCallbackNode = root.callbackNode;
+  const didFlushPassiveEffects = flushPassiveEffects();
+
+  if (didFlushPassiveEffects) {
+    // Something in the passive effect phase may have canceled the current task.
+    // Check if the task node for this root was changed.
+    if (root.callbackNode !== originalCallbackNode) {
+      // The current task was canceled. Exit. We don't need to call
+      // `ensureRootIsScheduled` because the check above implies either that
+      // there's a new task, or that there's no remaining work on this root.
+      return null;
+    }
+  } // Determine the next lanes to work on, using the fields stored
+  // on the root.
+  // TODO: This was already computed in the caller. Pass it as an argument.
+
+
+  let lanes = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes);
+
+  if (lanes === NoLanes) {
+    // Defensive coding. This is never expected to happen.
+    return null;
+  } // We disable time-slicing in some cases: if the work has been CPU-bound
+  // for too long ("expired" work, to prevent starvation), or we're in
+  // sync-updates-by-default mode.
+  // TODO: We only check `didTimeout` defensively, to account for a Scheduler
+  // bug we're still investigating. Once the bug in Scheduler is fixed,
+  // we can remove this, since we track expiration ourselves.
+
+
+  const shouldTimeSlice = !includesBlockingLane(root, lanes) && !includesExpiredLane(root, lanes) && (!didTimeout);
+  let exitStatus = shouldTimeSlice ? renderRootConcurrent(root, lanes) : renderRootSync(root, lanes);
+
+  if (exitStatus !== RootInProgress) {
+    let renderWasConcurrent = shouldTimeSlice;
+
+    do {
+      if (exitStatus === RootDidNotComplete) {
+        // The render unwound without completing the tree. This happens in special
+        // cases where need to exit the current render without producing a
+        // consistent tree or committing.
+        markRootSuspended(root, lanes, NoLane);
+      } else {
+        // The render completed.
+        // Check if this render may have yielded to a concurrent event, and if so,
+        // confirm that any newly rendered stores are consistent.
+        // TODO: It's possible that even a concurrent render may never have yielded
+        // to the main thread, if it was fast enough, or if it expired. We could
+        // skip the consistency check in that case, too.
+        const finishedWork = root.current.alternate;
+
+        if (renderWasConcurrent && !isRenderConsistentWithExternalStores(finishedWork)) {
+          // A store was mutated in an interleaved event. Render again,
+          // synchronously, to block further mutations.
+          exitStatus = renderRootSync(root, lanes); // We assume the tree is now consistent because we didn't yield to any
+          // concurrent events.
+
+          renderWasConcurrent = false; // Need to check the exit status again.
+
+          continue;
+        } // Check if something threw
+
+
+        if (exitStatus === RootErrored) {
+          const originallyAttemptedLanes = lanes;
+          const errorRetryLanes = getLanesToRetrySynchronouslyOnError(root, originallyAttemptedLanes);
+
+          if (errorRetryLanes !== NoLanes) {
+            lanes = errorRetryLanes;
+            exitStatus = recoverFromConcurrentError(root, originallyAttemptedLanes, errorRetryLanes);
+            renderWasConcurrent = false;
+          }
+        }
+
+        if (exitStatus === RootFatalErrored) {
+          const fatalError = workInProgressRootFatalError;
+          prepareFreshStack(root, NoLanes);
+          markRootSuspended(root, lanes, NoLane);
+          ensureRootIsScheduled(root);
+          throw fatalError;
+        } // We now have a consistent tree. The next step is either to commit it,
+        // or, if something suspended, wait to commit it after a timeout.
+
+
+        root.finishedWork = finishedWork;
+        root.finishedLanes = lanes;
+        finishConcurrentRender(root, exitStatus, finishedWork, lanes);
+      }
+
+      break;
+    } while (true);
+  }
+
+  ensureRootIsScheduled(root);
+  return getContinuationForRoot(root, originalCallbackNode);
+}
+
+function recoverFromConcurrentError(root, originallyAttemptedLanes, errorRetryLanes) {
+  // If an error occurred during hydration, discard server response and fall
+  // back to client side render.
+  // Before rendering again, save the errors from the previous attempt.
+  const errorsFromFirstAttempt = workInProgressRootConcurrentErrors;
+  const wasRootDehydrated = isRootDehydrated(root);
+
+  if (wasRootDehydrated) {
+    // The shell failed to hydrate. Set a flag to force a client rendering
+    // during the next attempt. To do this, we call prepareFreshStack now
+    // to create the root work-in-progress fiber. This is a bit weird in terms
+    // of factoring, because it relies on renderRootSync not calling
+    // prepareFreshStack again in the call below, which happens because the
+    // root and lanes haven't changed.
+    //
+    // TODO: I think what we should do is set ForceClientRender inside
+    // throwException, like we do for nested Suspense boundaries. The reason
+    // it's here instead is so we can switch to the synchronous work loop, too.
+    // Something to consider for a future refactor.
+    const rootWorkInProgress = prepareFreshStack(root, errorRetryLanes);
+    rootWorkInProgress.flags |= ForceClientRender;
+  }
+
+  const exitStatus = renderRootSync(root, errorRetryLanes);
+
+  if (exitStatus !== RootErrored) {
+    // Successfully finished rendering on retry
+    if (workInProgressRootDidAttachPingListener && !wasRootDehydrated) {
+      // During the synchronous render, we attached additional ping listeners.
+      // This is highly suggestive of an uncached promise (though it's not the
+      // only reason this would happen). If it was an uncached promise, then
+      // it may have masked a downstream error from ocurring without actually
+      // fixing it. Example:
+      //
+      //    use(Promise.resolve('uncached'))
+      //    throw new Error('Oops!')
+      //
+      // When this happens, there's a conflict between blocking potential
+      // concurrent data races and unwrapping uncached promise values. We
+      // have to choose one or the other. Because the data race recovery is
+      // a last ditch effort, we'll disable it.
+      root.errorRecoveryDisabledLanes = mergeLanes(root.errorRecoveryDisabledLanes, originallyAttemptedLanes); // Mark the current render as suspended and force it to restart. Once
+      // these lanes finish successfully, we'll re-enable the error recovery
+      // mechanism for subsequent updates.
+
+      workInProgressRootInterleavedUpdatedLanes |= originallyAttemptedLanes;
+      return RootSuspendedWithDelay;
+    } // The errors from the failed first attempt have been recovered. Add
+    // them to the collection of recoverable errors. We'll log them in the
+    // commit phase.
+
+
+    const errorsFromSecondAttempt = workInProgressRootRecoverableErrors;
+    workInProgressRootRecoverableErrors = errorsFromFirstAttempt; // The errors from the second attempt should be queued after the errors
+    // from the first attempt, to preserve the causal sequence.
+
+    if (errorsFromSecondAttempt !== null) {
+      queueRecoverableErrors(errorsFromSecondAttempt);
+    }
+  }
+
+  return exitStatus;
+}
+
+function queueRecoverableErrors(errors) {
+  if (workInProgressRootRecoverableErrors === null) {
+    workInProgressRootRecoverableErrors = errors;
+  } else {
+    // $FlowFixMe[method-unbinding]
+    workInProgressRootRecoverableErrors.push.apply(workInProgressRootRecoverableErrors, errors);
+  }
+}
+
+function finishConcurrentRender(root, exitStatus, finishedWork, lanes) {
+  // TODO: The fact that most of these branches are identical suggests that some
+  // of the exit statuses are not best modeled as exit statuses and should be
+  // tracked orthogonally.
+  switch (exitStatus) {
+    case RootInProgress:
+    case RootFatalErrored:
+      {
+        throw Error(formatProdErrorMessage(345));
+      }
+
+    case RootSuspendedWithDelay:
+      {
+        if (includesOnlyTransitions(lanes)) {
+          // This is a transition, so we should exit without committing a
+          // placeholder and without scheduling a timeout. Delay indefinitely
+          // until we receive more data.
+          markRootSuspended(root, lanes, workInProgressDeferredLane);
+          return;
+        } // Commit the placeholder.
+
+
+        break;
+      }
+
+    case RootErrored:
+    case RootSuspended:
+    case RootCompleted:
+      {
+        break;
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(329));
+      }
+  }
+
+  {
+    if (includesOnlyRetries(lanes) && (alwaysThrottleRetries )) {
+      // This render only included retries, no updates. Throttle committing
+      // retries so that we don't show too many loading states too quickly.
+      const msUntilTimeout = globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now$1(); // Don't bother with a very short suspense time.
+
+      if (msUntilTimeout > 10) {
+        markRootSuspended(root, lanes, workInProgressDeferredLane);
+        const nextLanes = getNextLanes(root, NoLanes);
+
+        if (nextLanes !== NoLanes) {
+          // There's additional work we can do on this root. We might as well
+          // attempt to work on that while we're suspended.
+          return;
+        } // The render is suspended, it hasn't timed out, and there's no
+        // lower priority work to do. Instead of committing the fallback
+        // immediately, wait for more data to arrive.
+        // TODO: Combine retry throttling with Suspensey commits. Right now they
+        // run one after the other.
+
+
+        root.timeoutHandle = scheduleTimeout(commitRootWhenReady.bind(null, root, finishedWork, workInProgressRootRecoverableErrors, workInProgressTransitions, lanes, workInProgressDeferredLane), msUntilTimeout);
+        return;
+      }
+    }
+
+    commitRootWhenReady(root, finishedWork, workInProgressRootRecoverableErrors, workInProgressTransitions, lanes, workInProgressDeferredLane);
+  }
+}
+
+function commitRootWhenReady(root, finishedWork, recoverableErrors, transitions, lanes, spawnedLane) {
+  // TODO: Combine retry throttling with Suspensey commits. Right now they run
+  // one after the other.
+  if (includesOnlyNonUrgentLanes(lanes)) {
+    // Before committing, ask the renderer whether the host tree is ready.
+    // If it's not, we'll wait until it notifies us.
+    startSuspendingCommit(); // This will walk the completed fiber tree and attach listeners to all
+    // the suspensey resources. The renderer is responsible for accumulating
+    // all the load events. This all happens in a single synchronous
+    // transaction, so it track state in its own module scope.
+
+    accumulateSuspenseyCommit(finishedWork); // At the end, ask the renderer if it's ready to commit, or if we should
+    // suspend. If it's not ready, it will return a callback to subscribe to
+    // a ready event.
+
+    const schedulePendingCommit = waitForCommitToBeReady();
+
+    if (schedulePendingCommit !== null) {
+      // NOTE: waitForCommitToBeReady returns a subscribe function so that we
+      // only allocate a function if the commit isn't ready yet. The other
+      // pattern would be to always pass a callback to waitForCommitToBeReady.
+      // Not yet ready to commit. Delay the commit until the renderer notifies
+      // us that it's ready. This will be canceled if we start work on the
+      // root again.
+      root.cancelPendingCommit = schedulePendingCommit(commitRoot.bind(null, root, recoverableErrors, transitions));
+      markRootSuspended(root, lanes, spawnedLane);
+      return;
+    }
+  } // Otherwise, commit immediately.
+
+
+  commitRoot(root, recoverableErrors, transitions, spawnedLane);
+}
+
+function isRenderConsistentWithExternalStores(finishedWork) {
+  // Search the rendered tree for external store reads, and check whether the
+  // stores were mutated in a concurrent event. Intentionally using an iterative
+  // loop instead of recursion so we can exit early.
+  let node = finishedWork;
+
+  while (true) {
+    if (node.flags & StoreConsistency) {
+      const updateQueue = node.updateQueue;
+
+      if (updateQueue !== null) {
+        const checks = updateQueue.stores;
+
+        if (checks !== null) {
+          for (let i = 0; i < checks.length; i++) {
+            const check = checks[i];
+            const getSnapshot = check.getSnapshot;
+            const renderedValue = check.value;
+
+            try {
+              if (!objectIs(getSnapshot(), renderedValue)) {
+                // Found an inconsistent store.
+                return false;
+              }
+            } catch (error) {
+              // If `getSnapshot` throws, return `false`. This will schedule
+              // a re-render, and the error will be rethrown during render.
+              return false;
+            }
+          }
+        }
+      }
+    }
+
+    const child = node.child;
+
+    if (node.subtreeFlags & StoreConsistency && child !== null) {
+      child.return = node;
+      node = child;
+      continue;
+    }
+
+    if (node === finishedWork) {
+      return true;
+    }
+
+    while (node.sibling === null) {
+      if (node.return === null || node.return === finishedWork) {
+        return true;
+      }
+
+      node = node.return;
+    }
+
+    node.sibling.return = node.return;
+    node = node.sibling;
+  } // Flow doesn't know this is unreachable, but eslint does
+  // eslint-disable-next-line no-unreachable
+
+
+  return true;
+}
+
+function markRootSuspended(root, suspendedLanes, spawnedLane) {
+  // When suspending, we should always exclude lanes that were pinged or (more
+  // rarely, since we try to avoid it) updated during the render phase.
+  // TODO: Lol maybe there's a better way to factor this besides this
+  // obnoxiously named function :)
+  suspendedLanes = removeLanes(suspendedLanes, workInProgressRootPingedLanes);
+  suspendedLanes = removeLanes(suspendedLanes, workInProgressRootInterleavedUpdatedLanes);
+  markRootSuspended$1(root, suspendedLanes, spawnedLane);
+} // This is the entry point for synchronous tasks that don't go
+// through Scheduler
+
+
+function performSyncWorkOnRoot(root, lanes) {
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw Error(formatProdErrorMessage(327));
+  }
+
+  const didFlushPassiveEffects = flushPassiveEffects();
+
+  if (didFlushPassiveEffects) {
+    // If passive effects were flushed, exit to the outer work loop in the root
+    // scheduler, so we can recompute the priority.
+    // TODO: We don't actually need this `ensureRootIsScheduled` call because
+    // this path is only reachable if the root is already part of the schedule.
+    // I'm including it only for consistency with the other exit points from
+    // this function. Can address in a subsequent refactor.
+    ensureRootIsScheduled(root);
+    return null;
+  }
+
+  {
+    syncNestedUpdateFlag();
+  }
+
+  let exitStatus = renderRootSync(root, lanes);
+
+  if (root.tag !== LegacyRoot && exitStatus === RootErrored) {
+    // If something threw an error, try rendering one more time. We'll render
+    // synchronously to block concurrent data mutations, and we'll includes
+    // all pending updates are included. If it still fails after the second
+    // attempt, we'll give up and commit the resulting tree.
+    const originallyAttemptedLanes = lanes;
+    const errorRetryLanes = getLanesToRetrySynchronouslyOnError(root, originallyAttemptedLanes);
+
+    if (errorRetryLanes !== NoLanes) {
+      lanes = errorRetryLanes;
+      exitStatus = recoverFromConcurrentError(root, originallyAttemptedLanes, errorRetryLanes);
+    }
+  }
+
+  if (exitStatus === RootFatalErrored) {
+    const fatalError = workInProgressRootFatalError;
+    prepareFreshStack(root, NoLanes);
+    markRootSuspended(root, lanes, NoLane);
+    ensureRootIsScheduled(root);
+    throw fatalError;
+  }
+
+  if (exitStatus === RootDidNotComplete) {
+    // The render unwound without completing the tree. This happens in special
+    // cases where need to exit the current render without producing a
+    // consistent tree or committing.
+    markRootSuspended(root, lanes, NoLane);
+    ensureRootIsScheduled(root);
+    return null;
+  } // We now have a consistent tree. Because this is a sync render, we
+  // will commit it even if something suspended.
+
+
+  const finishedWork = root.current.alternate;
+  root.finishedWork = finishedWork;
+  root.finishedLanes = lanes;
+  commitRoot(root, workInProgressRootRecoverableErrors, workInProgressTransitions, workInProgressDeferredLane); // Before exiting, make sure there's a callback scheduled for the next
+  // pending level.
+
+  ensureRootIsScheduled(root);
+  return null;
+}
+function flushRoot(root, lanes) {
+  if (lanes !== NoLanes) {
+    upgradePendingLanesToSync(root, lanes);
+    ensureRootIsScheduled(root);
+
+    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
+      resetRenderTimer(); // TODO: For historical reasons this flushes all sync work across all
+      // roots. It shouldn't really matter either way, but we could change this
+      // to only flush the given root.
+
+      flushSyncWorkOnAllRoots();
+    }
+  }
+}
+function getExecutionContext() {
+  return executionContext;
+}
+function batchedUpdates$1(fn, a) {
+  const prevExecutionContext = executionContext;
+  executionContext |= BatchedContext;
+
+  try {
+    return fn(a);
+  } finally {
+    executionContext = prevExecutionContext; // If there were legacy sync updates, flush them at the end of the outer
+    // most batchedUpdates-like method.
+
+    if (executionContext === NoContext && // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.
+    !(false )) {
+      resetRenderTimer();
+      flushSyncWorkOnLegacyRootsOnly();
+    }
+  }
+}
+// Warning, this opts-out of checking the function body.
+// eslint-disable-next-line no-unused-vars
+// eslint-disable-next-line no-redeclare
+// eslint-disable-next-line no-redeclare
+
+function flushSync$1(fn) {
+  // In legacy mode, we flush pending passive effects at the beginning of the
+  // next event, not at the end of the previous one.
+  if (rootWithPendingPassiveEffects !== null && rootWithPendingPassiveEffects.tag === LegacyRoot && (executionContext & (RenderContext | CommitContext)) === NoContext) {
+    flushPassiveEffects();
+  }
+
+  const prevExecutionContext = executionContext;
+  executionContext |= BatchedContext;
+  const prevTransition = ReactCurrentBatchConfig$1.transition;
+  const previousPriority = getCurrentUpdatePriority();
+
+  try {
+    ReactCurrentBatchConfig$1.transition = null;
+    setCurrentUpdatePriority(DiscreteEventPriority);
+
+    if (fn) {
+      return fn();
+    } else {
+      return undefined;
+    }
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+    executionContext = prevExecutionContext; // Flush the immediate callbacks that were scheduled during this batch.
+    // Note that this will happen even if batchedUpdates is higher up
+    // the stack.
+
+    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
+      flushSyncWorkOnAllRoots();
+    }
+  }
+}
+function isInvalidExecutionContextForEventFunction() {
+  // Used to throw if certain APIs are called from the wrong context.
+  return (executionContext & RenderContext) !== NoContext;
+} // This is called by the HiddenContext module when we enter or leave a
+// hidden subtree. The stack logic is managed there because that's the only
+// place that ever modifies it. Which module it lives in doesn't matter for
+// performance because this function will get inlined regardless
+
+function setEntangledRenderLanes(newEntangledRenderLanes) {
+  entangledRenderLanes = newEntangledRenderLanes;
+}
+function getEntangledRenderLanes() {
+  return entangledRenderLanes;
+}
+
+function resetWorkInProgressStack() {
+  if (workInProgress === null) return;
+  let interruptedWork;
+
+  if (workInProgressSuspendedReason === NotSuspended) {
+    // Normal case. Work-in-progress hasn't started yet. Unwind all
+    // its parents.
+    interruptedWork = workInProgress.return;
+  } else {
+    // Work-in-progress is in suspended state. Reset the work loop and unwind
+    // both the suspended fiber and all its parents.
+    resetSuspendedWorkLoopOnUnwind(workInProgress);
+    interruptedWork = workInProgress;
+  }
+
+  while (interruptedWork !== null) {
+    const current = interruptedWork.alternate;
+    unwindInterruptedWork(current, interruptedWork);
+    interruptedWork = interruptedWork.return;
+  }
+
+  workInProgress = null;
+}
+
+function prepareFreshStack(root, lanes) {
+  root.finishedWork = null;
+  root.finishedLanes = NoLanes;
+  const timeoutHandle = root.timeoutHandle;
+
+  if (timeoutHandle !== noTimeout) {
+    // The root previous suspended and scheduled a timeout to commit a fallback
+    // state. Now that we have additional work, cancel the timeout.
+    root.timeoutHandle = noTimeout; // $FlowFixMe[incompatible-call] Complains noTimeout is not a TimeoutID, despite the check above
+
+    cancelTimeout(timeoutHandle);
+  }
+
+  const cancelPendingCommit = root.cancelPendingCommit;
+
+  if (cancelPendingCommit !== null) {
+    root.cancelPendingCommit = null;
+    cancelPendingCommit();
+  }
+
+  resetWorkInProgressStack();
+  workInProgressRoot = root;
+  const rootWorkInProgress = createWorkInProgress(root.current, null);
+  workInProgress = rootWorkInProgress;
+  workInProgressRootRenderLanes = lanes;
+  workInProgressSuspendedReason = NotSuspended;
+  workInProgressThrownValue = null;
+  workInProgressRootDidAttachPingListener = false;
+  workInProgressRootExitStatus = RootInProgress;
+  workInProgressRootFatalError = null;
+  workInProgressRootSkippedLanes = NoLanes;
+  workInProgressRootInterleavedUpdatedLanes = NoLanes;
+  workInProgressRootPingedLanes = NoLanes;
+  workInProgressDeferredLane = NoLane;
+  workInProgressRootConcurrentErrors = null;
+  workInProgressRootRecoverableErrors = null; // Get the lanes that are entangled with whatever we're about to render. We
+  // track these separately so we can distinguish the priority of the render
+  // task from the priority of the lanes it is entangled with. For example, a
+  // transition may not be allowed to finish unless it includes the Sync lane,
+  // which is currently suspended. We should be able to render the Transition
+  // and Sync lane in the same batch, but at Transition priority, because the
+  // Sync lane already suspended.
+
+  entangledRenderLanes = getEntangledLanes(root, lanes);
+  finishQueueingConcurrentUpdates();
+
+  return rootWorkInProgress;
+}
+
+function resetSuspendedWorkLoopOnUnwind(fiber) {
+  // Reset module-level state that was set during the render phase.
+  resetContextDependencies();
+  resetHooksOnUnwind(fiber);
+  resetChildReconcilerOnUnwind();
+}
+
+function handleThrow(root, thrownValue) {
+  // A component threw an exception. Usually this is because it suspended, but
+  // it also includes regular program errors.
+  //
+  // We're either going to unwind the stack to show a Suspense or error
+  // boundary, or we're going to replay the component again. Like after a
+  // promise resolves.
+  //
+  // Until we decide whether we're going to unwind or replay, we should preserve
+  // the current state of the work loop without resetting anything.
+  //
+  // If we do decide to unwind the stack, module-level variables will be reset
+  // in resetSuspendedWorkLoopOnUnwind.
+  // These should be reset immediately because they're only supposed to be set
+  // when React is executing user code.
+  resetHooksAfterThrow();
+  ReactCurrentOwner.current = null;
+
+  if (thrownValue === SuspenseException) {
+    // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown value
+    // to be a thenable, because before `use` existed that was the (unstable)
+    // API for suspending. This implementation detail can change later, once we
+    // deprecate the old API in favor of `use`.
+    thrownValue = getSuspendedThenable();
+    workInProgressSuspendedReason = shouldRemainOnPreviousScreen() && // Check if there are other pending updates that might possibly unblock this
+    // component from suspending. This mirrors the check in
+    // renderDidSuspendDelayIfPossible. We should attempt to unify them somehow.
+    // TODO: Consider unwinding immediately, using the
+    // SuspendedOnHydration mechanism.
+    !includesNonIdleWork(workInProgressRootSkippedLanes) && !includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes) ? // Suspend work loop until data resolves
+    SuspendedOnData : // Don't suspend work loop, except to check if the data has
+    // immediately resolved (i.e. in a microtask). Otherwise, trigger the
+    // nearest Suspense fallback.
+    SuspendedOnImmediate;
+  } else if (thrownValue === SuspenseyCommitException) {
+    thrownValue = getSuspendedThenable();
+    workInProgressSuspendedReason = SuspendedOnInstance;
+  } else if (thrownValue === SelectiveHydrationException) {
+    // An update flowed into a dehydrated boundary. Before we can apply the
+    // update, we need to finish hydrating. Interrupt the work-in-progress
+    // render so we can restart at the hydration lane.
+    //
+    // The ideal implementation would be able to switch contexts without
+    // unwinding the current stack.
+    //
+    // We could name this something more general but as of now it's the only
+    // case where we think this should happen.
+    workInProgressSuspendedReason = SuspendedOnHydration;
+  } else {
+    // This is a regular error.
+    const isWakeable = thrownValue !== null && typeof thrownValue === 'object' && typeof thrownValue.then === 'function';
+    workInProgressSuspendedReason = isWakeable ? // A wakeable object was thrown by a legacy Suspense implementation.
+    // This has slightly different behavior than suspending with `use`.
+    SuspendedOnDeprecatedThrowPromise : // This is a regular error. If something earlier in the component already
+    // suspended, we must clear the thenable state to unblock the work loop.
+    SuspendedOnError;
+  }
+
+  workInProgressThrownValue = thrownValue;
+  const erroredWork = workInProgress;
+
+  if (erroredWork === null) {
+    // This is a fatal error
+    workInProgressRootExitStatus = RootFatalErrored;
+    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);
+  }
+
+  {
+    markComponentRenderStopped();
+
+    switch (workInProgressSuspendedReason) {
+      case SuspendedOnError:
+        {
+          markComponentErrored(erroredWork, thrownValue, workInProgressRootRenderLanes);
+          break;
+        }
+
+      case SuspendedOnData:
+      case SuspendedOnImmediate:
+      case SuspendedOnDeprecatedThrowPromise:
+      case SuspendedAndReadyToContinue:
+        {
+          const wakeable = thrownValue;
+          markComponentSuspended(erroredWork, wakeable, workInProgressRootRenderLanes);
+          break;
+        }
+    }
+  }
+}
+
+function shouldRemainOnPreviousScreen() {
+  // This is asking whether it's better to suspend the transition and remain
+  // on the previous screen, versus showing a fallback as soon as possible. It
+  // takes into account both the priority of render and also whether showing a
+  // fallback would produce a desirable user experience.
+  const handler = getSuspenseHandler();
+
+  if (handler === null) {
+    // There's no Suspense boundary that can provide a fallback. We have no
+    // choice but to remain on the previous screen.
+    // NOTE: We do this even for sync updates, for lack of any better option. In
+    // the future, we may change how we handle this, like by putting the whole
+    // root into a "detached" mode.
+    return true;
+  } // TODO: Once `use` has fully replaced the `throw promise` pattern, we should
+  // be able to remove the equivalent check in finishConcurrentRender, and rely
+  // just on this one.
+
+
+  if (includesOnlyTransitions(workInProgressRootRenderLanes)) {
+    if (getShellBoundary() === null) {
+      // We're rendering inside the "shell" of the app. Activating the nearest
+      // fallback would cause visible content to disappear. It's better to
+      // suspend the transition and remain on the previous screen.
+      return true;
+    } else {
+      // We're rendering content that wasn't part of the previous screen.
+      // Rather than block the transition, it's better to show a fallback as
+      // soon as possible. The appearance of any nested fallbacks will be
+      // throttled to avoid jank.
+      return false;
+    }
+  }
+
+  if (includesOnlyRetries(workInProgressRootRenderLanes) || // In this context, an OffscreenLane counts as a Retry
+  // TODO: It's become increasingly clear that Retries and Offscreen are
+  // deeply connected. They probably can be unified further.
+  includesSomeLane(workInProgressRootRenderLanes, OffscreenLane)) {
+    // During a retry, we can suspend rendering if the nearest Suspense boundary
+    // is the boundary of the "shell", because we're guaranteed not to block
+    // any new content from appearing.
+    //
+    // The reason we must check if this is a retry is because it guarantees
+    // that suspending the work loop won't block an actual update, because
+    // retries don't "update" anything; they fill in fallbacks that were left
+    // behind by a previous transition.
+    return handler === getShellBoundary();
+  } // For all other Lanes besides Transitions and Retries, we should not wait
+  // for the data to load.
+
+
+  return false;
+}
+
+function pushDispatcher(container) {
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = ContextOnlyDispatcher;
+
+  if (prevDispatcher === null) {
+    // The React isomorphic package does not include a default dispatcher.
+    // Instead the first renderer will lazily attach one, in order to give
+    // nicer error messages.
+    return ContextOnlyDispatcher;
+  } else {
+    return prevDispatcher;
+  }
+}
+
+function popDispatcher(prevDispatcher) {
+  ReactCurrentDispatcher.current = prevDispatcher;
+}
+
+function pushCacheDispatcher() {
+  {
+    const prevCacheDispatcher = ReactCurrentCache.current;
+    ReactCurrentCache.current = DefaultCacheDispatcher;
+    return prevCacheDispatcher;
+  }
+}
+
+function popCacheDispatcher(prevCacheDispatcher) {
+  {
+    ReactCurrentCache.current = prevCacheDispatcher;
+  }
+}
+
+function markCommitTimeOfFallback() {
+  globalMostRecentFallbackTime = now$1();
+}
+function markSkippedUpdateLanes(lane) {
+  workInProgressRootSkippedLanes = mergeLanes(lane, workInProgressRootSkippedLanes);
+}
+function renderDidSuspend() {
+  if (workInProgressRootExitStatus === RootInProgress) {
+    workInProgressRootExitStatus = RootSuspended;
+  }
+}
+function renderDidSuspendDelayIfPossible() {
+  workInProgressRootExitStatus = RootSuspendedWithDelay; // Check if there are updates that we skipped tree that might have unblocked
+  // this render.
+
+  if ((includesNonIdleWork(workInProgressRootSkippedLanes) || includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes)) && workInProgressRoot !== null) {
+    // Mark the current render as suspended so that we switch to working on
+    // the updates that were skipped. Usually we only suspend at the end of
+    // the render phase.
+    // TODO: We should probably always mark the root as suspended immediately
+    // (inside this function), since by suspending at the end of the render
+    // phase introduces a potential mistake where we suspend lanes that were
+    // pinged or updated while we were rendering.
+    // TODO: Consider unwinding immediately, using the
+    // SuspendedOnHydration mechanism.
+    markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes, workInProgressDeferredLane);
+  }
+}
+function renderDidError(error) {
+  if (workInProgressRootExitStatus !== RootSuspendedWithDelay) {
+    workInProgressRootExitStatus = RootErrored;
+  }
+
+  if (workInProgressRootConcurrentErrors === null) {
+    workInProgressRootConcurrentErrors = [error];
+  } else {
+    workInProgressRootConcurrentErrors.push(error);
+  }
+} // Called during render to determine if anything has suspended.
+// Returns false if we're not sure.
+
+function renderHasNotSuspendedYet() {
+  // If something errored or completed, we can't really be sure,
+  // so those are false.
+  return workInProgressRootExitStatus === RootInProgress;
+} // TODO: Over time, this function and renderRootConcurrent have become more
+// and more similar. Not sure it makes sense to maintain forked paths. Consider
+// unifying them again.
+
+function renderRootSync(root, lanes) {
+  const prevExecutionContext = executionContext;
+  executionContext |= RenderContext;
+  const prevDispatcher = pushDispatcher();
+  const prevCacheDispatcher = pushCacheDispatcher(); // If the root or lanes have changed, throw out the existing stack
+  // and prepare a fresh one. Otherwise we'll continue where we left off.
+
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
+    {
+      if (isDevToolsPresent) {
+        const 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();
+    prepareFreshStack(root, lanes);
+  }
+
+  {
+    markRenderStarted(lanes);
+  }
+
+  let didSuspendInShell = false;
+
+  outer: do {
+    try {
+      if (workInProgressSuspendedReason !== NotSuspended && workInProgress !== null) {
+        // The work loop is suspended. During a synchronous render, we don't
+        // yield to the main thread. Immediately unwind the stack. This will
+        // trigger either a fallback or an error boundary.
+        // TODO: For discrete and "default" updates (anything that's not
+        // flushSync), we want to wait for the microtasks the flush before
+        // unwinding. Will probably implement this using renderRootConcurrent,
+        // or merge renderRootSync and renderRootConcurrent into the same
+        // function and fork the behavior some other way.
+        const unitOfWork = workInProgress;
+        const thrownValue = workInProgressThrownValue;
+
+        switch (workInProgressSuspendedReason) {
+          case SuspendedOnHydration:
+            {
+              // Selective hydration. An update flowed into a dehydrated tree.
+              // Interrupt the current render so the work loop can switch to the
+              // hydration lane.
+              resetWorkInProgressStack();
+              workInProgressRootExitStatus = RootDidNotComplete;
+              break outer;
+            }
+
+          case SuspendedOnImmediate:
+          case SuspendedOnData:
+            {
+              if (!didSuspendInShell && getSuspenseHandler() === null) {
+                didSuspendInShell = true;
+              } // Intentional fallthrough
+
+            }
+
+          default:
+            {
+              // Unwind then continue with the normal work loop.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              break;
+            }
+        }
+      }
+
+      workLoopSync();
+      break;
+    } catch (thrownValue) {
+      handleThrow(root, thrownValue);
+    }
+  } while (true); // Check if something suspended in the shell. We use this to detect an
+  // infinite ping loop caused by an uncached promise.
+  //
+  // Only increment this counter once per synchronous render attempt across the
+  // whole tree. Even if there are many sibling components that suspend, this
+  // counter only gets incremented once.
+
+
+  if (didSuspendInShell) {
+    root.shellSuspendCounter++;
+  }
+
+  resetContextDependencies();
+  executionContext = prevExecutionContext;
+  popDispatcher(prevDispatcher);
+  popCacheDispatcher(prevCacheDispatcher);
+
+  if (workInProgress !== null) {
+    // This is a sync render, so we should have finished the whole tree.
+    throw Error(formatProdErrorMessage(261));
+  }
+
+  {
+    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.
+
+  finishQueueingConcurrentUpdates();
+  return workInProgressRootExitStatus;
+} // The work loop is an extremely hot path. Tell Closure not to inline it.
+
+/** @noinline */
+
+
+function workLoopSync() {
+  // Perform work without checking if we need to yield between fiber.
+  while (workInProgress !== null) {
+    performUnitOfWork(workInProgress);
+  }
+}
+
+function renderRootConcurrent(root, lanes) {
+  const prevExecutionContext = executionContext;
+  executionContext |= RenderContext;
+  const prevDispatcher = pushDispatcher();
+  const prevCacheDispatcher = pushCacheDispatcher(); // If the root or lanes have changed, throw out the existing stack
+  // and prepare a fresh one. Otherwise we'll continue where we left off.
+
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
+    {
+      if (isDevToolsPresent) {
+        const 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();
+    resetRenderTimer();
+    prepareFreshStack(root, lanes);
+  }
+
+  {
+    markRenderStarted(lanes);
+  }
+
+  outer: do {
+    try {
+      if (workInProgressSuspendedReason !== NotSuspended && workInProgress !== null) {
+        // The work loop is suspended. We need to either unwind the stack or
+        // replay the suspended component.
+        const unitOfWork = workInProgress;
+        const thrownValue = workInProgressThrownValue;
+
+        resumeOrUnwind: switch (workInProgressSuspendedReason) {
+          case SuspendedOnError:
+            {
+              // Unwind then continue with the normal work loop.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              break;
+            }
+
+          case SuspendedOnData:
+            {
+              const thenable = thrownValue;
+
+              if (isThenableResolved(thenable)) {
+                // The data resolved. Try rendering the component again.
+                workInProgressSuspendedReason = NotSuspended;
+                workInProgressThrownValue = null;
+                replaySuspendedUnitOfWork(unitOfWork);
+                break;
+              } // The work loop is suspended on data. We should wait for it to
+              // resolve before continuing to render.
+              // TODO: Handle the case where the promise resolves synchronously.
+              // Usually this is handled when we instrument the promise to add a
+              // `status` field, but if the promise already has a status, we won't
+              // have added a listener until right here.
+
+
+              const onResolution = () => {
+                // Check if the root is still suspended on this promise.
+                if (workInProgressSuspendedReason === SuspendedOnData && workInProgressRoot === root) {
+                  // Mark the root as ready to continue rendering.
+                  workInProgressSuspendedReason = SuspendedAndReadyToContinue;
+                } // Ensure the root is scheduled. We should do this even if we're
+                // currently working on a different root, so that we resume
+                // rendering later.
+
+
+                ensureRootIsScheduled(root);
+              };
+
+              thenable.then(onResolution, onResolution);
+              break outer;
+            }
+
+          case SuspendedOnImmediate:
+            {
+              // If this fiber just suspended, it's possible the data is already
+              // cached. Yield to the main thread to give it a chance to ping. If
+              // it does, we can retry immediately without unwinding the stack.
+              workInProgressSuspendedReason = SuspendedAndReadyToContinue;
+              break outer;
+            }
+
+          case SuspendedOnInstance:
+            {
+              workInProgressSuspendedReason = SuspendedOnInstanceAndReadyToContinue;
+              break outer;
+            }
+
+          case SuspendedAndReadyToContinue:
+            {
+              const thenable = thrownValue;
+
+              if (isThenableResolved(thenable)) {
+                // The data resolved. Try rendering the component again.
+                workInProgressSuspendedReason = NotSuspended;
+                workInProgressThrownValue = null;
+                replaySuspendedUnitOfWork(unitOfWork);
+              } else {
+                // Otherwise, unwind then continue with the normal work loop.
+                workInProgressSuspendedReason = NotSuspended;
+                workInProgressThrownValue = null;
+                throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              }
+
+              break;
+            }
+
+          case SuspendedOnInstanceAndReadyToContinue:
+            {
+              switch (workInProgress.tag) {
+                case HostComponent:
+                case HostHoistable:
+                case HostSingleton:
+                  {
+                    // Before unwinding the stack, check one more time if the
+                    // instance is ready. It may have loaded when React yielded to
+                    // the main thread.
+                    // Assigning this to a constant so Flow knows the binding won't
+                    // be mutated by `preloadInstance`.
+                    const hostFiber = workInProgress;
+                    const type = hostFiber.type;
+                    const props = hostFiber.pendingProps;
+                    const isReady = preloadInstance(type, props);
+
+                    if (isReady) {
+                      // The data resolved. Resume the work loop as if nothing
+                      // suspended. Unlike when a user component suspends, we don't
+                      // have to replay anything because the host fiber
+                      // already completed.
+                      workInProgressSuspendedReason = NotSuspended;
+                      workInProgressThrownValue = null;
+                      const sibling = hostFiber.sibling;
+
+                      if (sibling !== null) {
+                        workInProgress = sibling;
+                      } else {
+                        const returnFiber = hostFiber.return;
+
+                        if (returnFiber !== null) {
+                          workInProgress = returnFiber;
+                          completeUnitOfWork(returnFiber);
+                        } else {
+                          workInProgress = null;
+                        }
+                      }
+
+                      break resumeOrUnwind;
+                    }
+
+                    break;
+                  }
+
+                default:
+                  {
+                    // This will fail gracefully but it's not correct, so log a
+                    // warning in dev.
+                    if (false) ;
+
+                    break;
+                  }
+              } // Otherwise, unwind then continue with the normal work loop.
+
+
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              break;
+            }
+
+          case SuspendedOnDeprecatedThrowPromise:
+            {
+              // Suspended by an old implementation that uses the `throw promise`
+              // pattern. The newer replaying behavior can cause subtle issues
+              // like infinite ping loops. So we maintain the old behavior and
+              // always unwind.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              break;
+            }
+
+          case SuspendedOnHydration:
+            {
+              // Selective hydration. An update flowed into a dehydrated tree.
+              // Interrupt the current render so the work loop can switch to the
+              // hydration lane.
+              resetWorkInProgressStack();
+              workInProgressRootExitStatus = RootDidNotComplete;
+              break outer;
+            }
+
+          default:
+            {
+              throw Error(formatProdErrorMessage(462));
+            }
+        }
+      }
+
+      if (false && ReactCurrentActQueue.current !== null) ; else {
+        workLoopConcurrent();
+      }
+
+      break;
+    } catch (thrownValue) {
+      handleThrow(root, thrownValue);
+    }
+  } while (true);
+
+  resetContextDependencies();
+  popDispatcher(prevDispatcher);
+  popCacheDispatcher(prevCacheDispatcher);
+  executionContext = prevExecutionContext;
+
+
+  if (workInProgress !== null) {
+    // Still work remaining.
+    {
+      markRenderYielded();
+    }
+
+    return RootInProgress;
+  } else {
+    // Completed the tree.
+    {
+      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.
+
+    finishQueueingConcurrentUpdates(); // Return the final exit status.
+
+    return workInProgressRootExitStatus;
+  }
+}
+/** @noinline */
+
+
+function workLoopConcurrent() {
+  // Perform work until Scheduler asks us to yield
+  while (workInProgress !== null && !shouldYield()) {
+    // $FlowFixMe[incompatible-call] found when upgrading Flow
+    performUnitOfWork(workInProgress);
+  }
+}
+
+function performUnitOfWork(unitOfWork) {
+  // The current, flushed, state of this fiber is the alternate. Ideally
+  // nothing should rely on this, but relying on it here means that we don't
+  // need an additional field on the work in progress.
+  const current = unitOfWork.alternate;
+  let next;
+
+  if ((unitOfWork.mode & ProfileMode) !== NoMode) {
+    startProfilerTimer(unitOfWork);
+    next = beginWork(current, unitOfWork, entangledRenderLanes);
+    stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
+  } else {
+    next = beginWork(current, unitOfWork, entangledRenderLanes);
+  }
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+
+  if (next === null) {
+    // If this doesn't spawn new work, complete the current work.
+    completeUnitOfWork(unitOfWork);
+  } else {
+    workInProgress = next;
+  }
+
+  ReactCurrentOwner.current = null;
+}
+
+function replaySuspendedUnitOfWork(unitOfWork) {
+  // This is a fork of performUnitOfWork specifcally for replaying a fiber that
+  // just suspended.
+  //
+  const current = unitOfWork.alternate;
+  let next;
+  const isProfilingMode = (unitOfWork.mode & ProfileMode) !== NoMode;
+
+  if (isProfilingMode) {
+    startProfilerTimer(unitOfWork);
+  }
+
+  switch (unitOfWork.tag) {
+    case IndeterminateComponent:
+      {
+        // Because it suspended with `use`, we can assume it's a
+        // function component.
+        unitOfWork.tag = FunctionComponent; // Fallthrough to the next branch.
+      }
+
+    case SimpleMemoComponent:
+    case FunctionComponent:
+      {
+        // Resolve `defaultProps`. This logic is copied from `beginWork`.
+        // TODO: Consider moving this switch statement into that module. Also,
+        // could maybe use this as an opportunity to say `use` doesn't work with
+        // `defaultProps` :)
+        const Component = unitOfWork.type;
+        const unresolvedProps = unitOfWork.pendingProps;
+        const resolvedProps = unitOfWork.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        let context;
+
+        {
+          const unmaskedContext = getUnmaskedContext(unitOfWork, Component, true);
+          context = getMaskedContext(unitOfWork, unmaskedContext);
+        }
+
+        next = replayFunctionComponent(current, unitOfWork, resolvedProps, Component, context, workInProgressRootRenderLanes);
+        break;
+      }
+
+    case ForwardRef:
+      {
+        // Resolve `defaultProps`. This logic is copied from `beginWork`.
+        // TODO: Consider moving this switch statement into that module. Also,
+        // could maybe use this as an opportunity to say `use` doesn't work with
+        // `defaultProps` :)
+        const Component = unitOfWork.type.render;
+        const unresolvedProps = unitOfWork.pendingProps;
+        const resolvedProps = unitOfWork.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        next = replayFunctionComponent(current, unitOfWork, resolvedProps, Component, unitOfWork.ref, workInProgressRootRenderLanes);
+        break;
+      }
+
+    case HostComponent:
+      {
+        // Some host components are stateful (that's how we implement form
+        // actions) but we don't bother to reuse the memoized state because it's
+        // not worth the extra code. The main reason to reuse the previous hooks
+        // is to reuse uncached promises, but we happen to know that the only
+        // promises that a host component might suspend on are definitely cached
+        // because they are controlled by us. So don't bother.
+        resetHooksOnUnwind(unitOfWork); // Fallthrough to the next branch.
+      }
+
+    default:
+      {
+        // Other types besides function components are reset completely before
+        // being replayed. Currently this only happens when a Usable type is
+        // reconciled — the reconciler will suspend.
+        //
+        // We reset the fiber back to its original state; however, this isn't
+        // a full "unwind" because we're going to reuse the promises that were
+        // reconciled previously. So it's intentional that we don't call
+        // resetSuspendedWorkLoopOnUnwind here.
+        unwindInterruptedWork(current, unitOfWork);
+        unitOfWork = workInProgress = resetWorkInProgress(unitOfWork, entangledRenderLanes);
+        next = beginWork(current, unitOfWork, entangledRenderLanes);
+        break;
+      }
+  }
+
+  if (isProfilingMode) {
+    stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
+  } // The begin phase finished successfully without suspending. Return to the
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+
+  if (next === null) {
+    // If this doesn't spawn new work, complete the current work.
+    completeUnitOfWork(unitOfWork);
+  } else {
+    workInProgress = next;
+  }
+
+  ReactCurrentOwner.current = null;
+}
+
+function throwAndUnwindWorkLoop(unitOfWork, thrownValue) {
+  // This is a fork of performUnitOfWork specifcally for unwinding a fiber
+  // that threw an exception.
+  //
+  // Return to the normal work loop. This will unwind the stack, and potentially
+  // result in showing a fallback.
+  resetSuspendedWorkLoopOnUnwind(unitOfWork);
+  const returnFiber = unitOfWork.return;
+
+  if (returnFiber === null || workInProgressRoot === null) {
+    // Expected to be working on a non-root fiber. This is a fatal error
+    // because there's no ancestor that can handle it; the root is
+    // supposed to capture all errors that weren't caught by an error
+    // boundary.
+    workInProgressRootExitStatus = RootFatalErrored;
+    workInProgressRootFatalError = thrownValue; // Set `workInProgress` to null. This represents advancing to the next
+    // sibling, or the parent if there are no siblings. But since the root
+    // has no siblings nor a parent, we set it to null. Usually this is
+    // handled by `completeUnitOfWork` or `unwindWork`, but since we're
+    // intentionally not calling those, we need set it here.
+    // TODO: Consider calling `unwindWork` to pop the contexts.
+
+    workInProgress = null;
+    return;
+  }
+
+  try {
+    // Find and mark the nearest Suspense or error boundary that can handle
+    // this "exception".
+    throwException(workInProgressRoot, returnFiber, unitOfWork, thrownValue, workInProgressRootRenderLanes);
+  } catch (error) {
+    // We had trouble processing the error. An example of this happening is
+    // when accessing the `componentDidCatch` property of an error boundary
+    // throws an error. A weird edge case. There's a regression test for this.
+    // To prevent an infinite loop, bubble the error up to the next parent.
+    workInProgress = returnFiber;
+    throw error;
+  }
+
+  if (unitOfWork.flags & Incomplete) {
+    // Unwind the stack until we reach the nearest boundary.
+    unwindUnitOfWork(unitOfWork);
+  } else {
+    // Although the fiber suspended, we're intentionally going to commit it in
+    // an inconsistent state. We can do this safely in cases where we know the
+    // inconsistent tree will be hidden.
+    //
+    // This currently only applies to Legacy Suspense implementation, but we may
+    // port a version of this to concurrent roots, too, when performing a
+    // synchronous render. Because that will allow us to mutate the tree as we
+    // go instead of buffering mutations until the end. Though it's unclear if
+    // this particular path is how that would be implemented.
+    completeUnitOfWork(unitOfWork);
+  }
+}
+
+function completeUnitOfWork(unitOfWork) {
+  // Attempt to complete the current unit of work, then move to the next
+  // sibling. If there are no more siblings, return to the parent fiber.
+  let completedWork = unitOfWork;
+
+  do {
+    // nothing should rely on this, but relying on it here means that we don't
+    // need an additional field on the work in progress.
+
+
+    const current = completedWork.alternate;
+    const returnFiber = completedWork.return;
+    let next;
+
+    if ((completedWork.mode & ProfileMode) === NoMode) {
+      next = completeWork(current, completedWork, entangledRenderLanes);
+    } else {
+      startProfilerTimer(completedWork);
+      next = completeWork(current, completedWork, entangledRenderLanes); // Update render duration assuming we didn't error.
+
+      stopProfilerTimerIfRunningAndRecordDelta(completedWork, false);
+    }
+
+    if (next !== null) {
+      // Completing this fiber spawned new work. Work on that next.
+      workInProgress = next;
+      return;
+    }
+
+    const siblingFiber = completedWork.sibling;
+
+    if (siblingFiber !== null) {
+      // If there is more work to do in this returnFiber, do that next.
+      workInProgress = siblingFiber;
+      return;
+    } // Otherwise, return to the parent
+    // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+    completedWork = returnFiber; // Update the next thing we're working on in case something throws.
+
+    workInProgress = completedWork;
+  } while (completedWork !== null); // We've reached the root.
+
+
+  if (workInProgressRootExitStatus === RootInProgress) {
+    workInProgressRootExitStatus = RootCompleted;
+  }
+}
+
+function unwindUnitOfWork(unitOfWork) {
+  let incompleteWork = unitOfWork;
+
+  do {
+    // The current, flushed, state of this fiber is the alternate. Ideally
+    // nothing should rely on this, but relying on it here means that we don't
+    // need an additional field on the work in progress.
+    const current = incompleteWork.alternate; // This fiber did not complete because something threw. Pop values off
+    // the stack without entering the complete phase. If this is a boundary,
+    // capture values if possible.
+
+    const next = unwindWork(current, incompleteWork); // Because this fiber did not complete, don't reset its lanes.
+
+    if (next !== null) {
+      // Found a boundary that can handle this exception. Re-renter the
+      // begin phase. This branch will return us to the normal work loop.
+      //
+      // Since we're restarting, remove anything that is not a host effect
+      // from the effect tag.
+      next.flags &= HostEffectMask;
+      workInProgress = next;
+      return;
+    } // Keep unwinding until we reach either a boundary or the root.
+
+
+    if ((incompleteWork.mode & ProfileMode) !== NoMode) {
+      // Record the render duration for the fiber that errored.
+      stopProfilerTimerIfRunningAndRecordDelta(incompleteWork, false); // Include the time spent working on failed children before continuing.
+
+      let actualDuration = incompleteWork.actualDuration;
+      let child = incompleteWork.child;
+
+      while (child !== null) {
+        // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+        actualDuration += child.actualDuration;
+        child = child.sibling;
+      }
+
+      incompleteWork.actualDuration = actualDuration;
+    } // TODO: Once we stop prerendering siblings, instead of resetting the parent
+    // of the node being unwound, we should be able to reset node itself as we
+    // unwind the stack. Saves an additional null check.
+
+
+    const returnFiber = incompleteWork.return;
+
+    if (returnFiber !== null) {
+      // Mark the parent fiber as incomplete and clear its subtree flags.
+      // TODO: Once we stop prerendering siblings, we may be able to get rid of
+      // the Incomplete flag because unwinding to the nearest boundary will
+      // happen synchronously.
+      returnFiber.flags |= Incomplete;
+      returnFiber.subtreeFlags = NoFlags$1;
+      returnFiber.deletions = null;
+    } // NOTE: If we re-enable sibling prerendering in some cases, here we
+    // would switch to the normal completion path: check if a sibling
+    // exists, and if so, begin work on it.
+    // Otherwise, return to the parent
+    // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+    incompleteWork = returnFiber; // Update the next thing we're working on in case something throws.
+
+    workInProgress = incompleteWork;
+  } while (incompleteWork !== null); // We've unwound all the way to the root.
+
+
+  workInProgressRootExitStatus = RootDidNotComplete;
+  workInProgress = null;
+}
+
+function commitRoot(root, recoverableErrors, transitions, spawnedLane) {
+  // TODO: This no longer makes any sense. We already wrap the mutation and
+  // layout phases. Should be able to remove.
+  const previousUpdateLanePriority = getCurrentUpdatePriority();
+  const prevTransition = ReactCurrentBatchConfig$1.transition;
+
+  try {
+    ReactCurrentBatchConfig$1.transition = null;
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    commitRootImpl(root, recoverableErrors, transitions, previousUpdateLanePriority, spawnedLane);
+  } finally {
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+    setCurrentUpdatePriority(previousUpdateLanePriority);
+  }
+
+  return null;
+}
+
+function commitRootImpl(root, recoverableErrors, transitions, renderPriorityLevel, spawnedLane) {
+  do {
+    // `flushPassiveEffects` will call `flushSyncUpdateQueue` at the end, which
+    // means `flushPassiveEffects` will sometimes result in additional
+    // passive effects. So we need to keep flushing in a loop until there are
+    // no more pending effects.
+    // TODO: Might be better if `flushPassiveEffects` did not automatically
+    // flush synchronous work at the end, to avoid factoring hazards like this.
+    flushPassiveEffects();
+  } while (rootWithPendingPassiveEffects !== null);
+
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw Error(formatProdErrorMessage(327));
+  }
+
+  const finishedWork = root.finishedWork;
+  const lanes = root.finishedLanes;
+
+  {
+    markCommitStarted(lanes);
+  }
+
+  if (finishedWork === null) {
+
+    {
+      markCommitStopped();
+    }
+
+    return null;
+  }
+
+  root.finishedWork = null;
+  root.finishedLanes = NoLanes;
+
+  if (finishedWork === root.current) {
+    throw Error(formatProdErrorMessage(177));
+  } // commitRoot never returns a continuation; it always finishes synchronously.
+  // So we can clear these now to allow a new callback to be scheduled.
+
+
+  root.callbackNode = null;
+  root.callbackPriority = NoLane;
+  root.cancelPendingCommit = null; // Check which lanes no longer have any work scheduled on them, and mark
+  // those as finished.
+
+  let remainingLanes = mergeLanes(finishedWork.lanes, finishedWork.childLanes); // Make sure to account for lanes that were updated by a concurrent event
+  // during the render phase; don't mark them as finished.
+
+  const concurrentlyUpdatedLanes = getConcurrentlyUpdatedLanes();
+  remainingLanes = mergeLanes(remainingLanes, concurrentlyUpdatedLanes);
+  markRootFinished(root, remainingLanes, spawnedLane);
+
+  if (root === workInProgressRoot) {
+    // We can reset these now that they are finished.
+    workInProgressRoot = null;
+    workInProgress = null;
+    workInProgressRootRenderLanes = NoLanes;
+  } // If there are pending passive effects, schedule a callback to process them.
+  // Do this as early as possible, so it is queued before anything else that
+  // might get scheduled in the commit phase. (See #16714.)
+  // TODO: Delete all other places that schedule the passive effect callback
+  // They're redundant.
+
+
+  if ((finishedWork.subtreeFlags & PassiveMask) !== NoFlags$1 || (finishedWork.flags & PassiveMask) !== NoFlags$1) {
+    if (!rootDoesHavePassiveEffects) {
+      rootDoesHavePassiveEffects = true;
+      pendingPassiveEffectsRemainingLanes = remainingLanes; // workInProgressTransitions might be overwritten, so we want
+      // to store it in pendingPassiveTransitions until they get processed
+      // We need to pass this through as an argument to commitRoot
+      // because workInProgressTransitions might have changed between
+      // the previous render and commit if we throttle the commit
+      // with setTimeout
+
+      pendingPassiveTransitions = transitions;
+      scheduleCallback(NormalPriority$1, () => {
+        flushPassiveEffects(); // This render triggered passive effects: release the root cache pool
+        // *after* passive effects fire to avoid freeing a cache pool that may
+        // be referenced by a node in the tree (HostRoot, Cache boundary etc)
+
+        return null;
+      });
+    }
+  } // Check if there are any effects in the whole tree.
+  // TODO: This is left over from the effect list implementation, where we had
+  // to check for the existence of `firstEffect` to satisfy Flow. I think the
+  // only other reason this optimization exists is because it affects profiling.
+  // Reconsider whether this is necessary.
+
+
+  const subtreeHasEffects = (finishedWork.subtreeFlags & (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !== NoFlags$1;
+  const rootHasEffect = (finishedWork.flags & (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !== NoFlags$1;
+
+  if (subtreeHasEffects || rootHasEffect) {
+    const prevTransition = ReactCurrentBatchConfig$1.transition;
+    ReactCurrentBatchConfig$1.transition = null;
+    const previousPriority = getCurrentUpdatePriority();
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    const prevExecutionContext = executionContext;
+    executionContext |= CommitContext; // Reset this to null before calling lifecycles
+
+    ReactCurrentOwner.current = null; // The commit phase is broken into several sub-phases. We do a separate pass
+    // of the effect list for each phase: all mutation effects come before all
+    // layout effects, and so on.
+    // The first phase a "before mutation" phase. We use this phase to read the
+    // state of the host tree right before we mutate it. This is where
+    // getSnapshotBeforeUpdate is called.
+
+    commitBeforeMutationEffects(root, finishedWork);
+
+    {
+      // Mark the current commit time to be shared by all Profilers in this
+      // batch. This enables them to be grouped later.
+      recordCommitTime();
+    }
+
+
+    commitMutationEffects(root, finishedWork, lanes);
+
+    resetAfterCommit(); // The work-in-progress tree is now the current tree. This must come after
+    // the mutation phase, so that the previous tree is still current during
+    // componentWillUnmount, but before the layout phase, so that the finished
+    // work is current during componentDidMount/Update.
+
+    root.current = finishedWork; // The next phase is the layout phase, where we call effects that read
+
+    {
+      markLayoutEffectsStarted(lanes);
+    }
+
+    commitLayoutEffects(finishedWork, root, lanes);
+
+    {
+      markLayoutEffectsStopped();
+    }
+    // opportunity to paint.
+
+
+    requestPaint();
+    executionContext = prevExecutionContext; // Reset the priority to the previous non-sync value.
+
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+  } else {
+    // No effects.
+    root.current = finishedWork; // Measure these anyway so the flamegraph explicitly shows that there were
+    // no effects.
+    // TODO: Maybe there's a better way to report this.
+
+    {
+      recordCommitTime();
+    }
+  }
+
+  if (rootDoesHavePassiveEffects) {
+    // This commit has passive effects. Stash a reference to them. But don't
+    // schedule a callback until after flushing layout work.
+    rootDoesHavePassiveEffects = false;
+    rootWithPendingPassiveEffects = root;
+    pendingPassiveEffectsLanes = lanes;
+  } else {
+    // There were no passive effects, so we can immediately release the cache
+    // pool for this render.
+    releaseRootPooledCache(root, remainingLanes);
+  } // Read this again, since an effect might have updated it
+
+
+  remainingLanes = root.pendingLanes; // Check if there's remaining work on this root
+  // TODO: This is part of the `componentDidCatch` implementation. Its purpose
+  // is to detect whether something might have called setState inside
+  // `componentDidCatch`. The mechanism is known to be flawed because `setState`
+  // inside `componentDidCatch` is itself flawed — that's why we recommend
+  // `getDerivedStateFromError` instead. However, it could be improved by
+  // checking if remainingLanes includes Sync work, instead of whether there's
+  // any work remaining at all (which would also include stuff like Suspense
+  // retries or transitions). It's been like this for a while, though, so fixing
+  // it probably isn't that urgent.
+
+  if (remainingLanes === NoLanes) {
+    // If there's no remaining work, we can clear the set of already failed
+    // error boundaries.
+    legacyErrorBoundariesThatAlreadyFailed = null;
+  }
+
+  onCommitRoot(finishedWork.stateNode, renderPriorityLevel);
+
+  {
+    if (isDevToolsPresent) {
+      root.memoizedUpdaters.clear();
+    }
+  }
+  // additional work on this root is scheduled.
+
+
+  ensureRootIsScheduled(root);
+
+  if (recoverableErrors !== null) {
+    // There were errors during this render, but recovered from them without
+    // needing to surface it to the UI. We log them here.
+    const onRecoverableError = root.onRecoverableError;
+
+    for (let i = 0; i < recoverableErrors.length; i++) {
+      const recoverableError = recoverableErrors[i];
+      const errorInfo = makeErrorInfo(recoverableError.digest, recoverableError.stack);
+      onRecoverableError(recoverableError.value, errorInfo);
+    }
+  }
+
+  if (hasUncaughtError) {
+    hasUncaughtError = false;
+    const error = firstUncaughtError;
+    firstUncaughtError = null;
+    throw error;
+  } // If the passive effects are the result of a discrete render, flush them
+  // synchronously at the end of the current task so that the result is
+  // immediately observable. Otherwise, we assume that they are not
+  // order-dependent and do not need to be observed by external systems, so we
+  // can wait until after paint.
+  // TODO: We can optimize this by not scheduling the callback earlier. Since we
+  // currently schedule the callback in multiple places, will wait until those
+  // are consolidated.
+
+
+  if (includesSyncLane(pendingPassiveEffectsLanes) && root.tag !== LegacyRoot) {
+    flushPassiveEffects();
+  } // Read this again, since a passive effect might have updated it
+
+
+  remainingLanes = root.pendingLanes; // Check if this render scheduled a cascading synchronous update. This is a
+  // heurstic to detect infinite update loops. We are intentionally excluding
+  // hydration lanes in this check, because render triggered by selective
+  // hydration is conceptually not an update.
+
+  if ( // Was the finished render the result of an update (not hydration)?
+  includesSomeLane(lanes, UpdateLanes) && // Did it schedule a sync update?
+  includesSomeLane(remainingLanes, SyncUpdateLanes)) {
+    {
+      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) {
+      nestedUpdateCount++;
+    } else {
+      nestedUpdateCount = 0;
+      rootWithNestedUpdates = root;
+    }
+  } else {
+    nestedUpdateCount = 0;
+  } // If layout work was scheduled, flush it now.
+
+
+  flushSyncWorkOnAllRoots();
+
+  {
+    markCommitStopped();
+  }
+
+  return null;
+}
+
+function makeErrorInfo(digest, componentStack) {
+  {
+    return {
+      digest,
+      componentStack
+    };
+  }
+}
+
+function releaseRootPooledCache(root, remainingLanes) {
+  {
+    const pooledCacheLanes = root.pooledCacheLanes &= remainingLanes;
+
+    if (pooledCacheLanes === NoLanes) {
+      // None of the remaining work relies on the cache pool. Clear it so
+      // subsequent requests get a new cache
+      const pooledCache = root.pooledCache;
+
+      if (pooledCache != null) {
+        root.pooledCache = null;
+        releaseCache(pooledCache);
+      }
+    }
+  }
+}
+
+function flushPassiveEffects() {
+  // Returns whether passive effects were flushed.
+  // TODO: Combine this check with the one in flushPassiveEFfectsImpl. We should
+  // probably just combine the two functions. I believe they were only separate
+  // in the first place because we used to wrap it with
+  // `Scheduler.runWithPriority`, which accepts a function. But now we track the
+  // priority within React itself, so we can mutate the variable directly.
+  if (rootWithPendingPassiveEffects !== null) {
+    // Cache the root since rootWithPendingPassiveEffects is cleared in
+    // flushPassiveEffectsImpl
+    const root = rootWithPendingPassiveEffects; // Cache and clear the remaining lanes flag; it must be reset since this
+    // method can be called from various places, not always from commitRoot
+    // where the remaining lanes are known
+
+    const remainingLanes = pendingPassiveEffectsRemainingLanes;
+    pendingPassiveEffectsRemainingLanes = NoLanes;
+    const renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
+    const priority = lowerEventPriority(DefaultEventPriority, renderPriority);
+    const prevTransition = ReactCurrentBatchConfig$1.transition;
+    const previousPriority = getCurrentUpdatePriority();
+
+    try {
+      ReactCurrentBatchConfig$1.transition = null;
+      setCurrentUpdatePriority(priority);
+      return flushPassiveEffectsImpl();
+    } finally {
+      setCurrentUpdatePriority(previousPriority);
+      ReactCurrentBatchConfig$1.transition = prevTransition; // Once passive effects have run for the tree - giving components a
+      // chance to retain cache instances they use - release the pooled
+      // cache at the root (if there is one)
+
+      releaseRootPooledCache(root, remainingLanes);
+    }
+  }
+
+  return false;
+}
+function enqueuePendingPassiveProfilerEffect(fiber) {
+  {
+    pendingPassiveProfilerEffects.push(fiber);
+
+    if (!rootDoesHavePassiveEffects) {
+      rootDoesHavePassiveEffects = true;
+      scheduleCallback(NormalPriority$1, () => {
+        flushPassiveEffects();
+        return null;
+      });
+    }
+  }
+}
+
+function flushPassiveEffectsImpl() {
+  if (rootWithPendingPassiveEffects === null) {
+    return false;
+  } // Cache and clear the transitions flag
+
+
+  const transitions = pendingPassiveTransitions;
+  pendingPassiveTransitions = null;
+  const root = rootWithPendingPassiveEffects;
+  const lanes = pendingPassiveEffectsLanes;
+  rootWithPendingPassiveEffects = null; // TODO: This is sometimes out of sync with rootWithPendingPassiveEffects.
+  // Figure out why and fix it. It's not causing any known issues (probably
+  // because it's only used for profiling), but it's a refactor hazard.
+
+  pendingPassiveEffectsLanes = NoLanes;
+
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw Error(formatProdErrorMessage(331));
+  }
+
+  {
+    markPassiveEffectsStarted(lanes);
+  }
+
+  const prevExecutionContext = executionContext;
+  executionContext |= CommitContext;
+  commitPassiveUnmountEffects(root.current);
+  commitPassiveMountEffects(root, root.current, lanes, transitions); // TODO: Move to commitPassiveMountEffects
+
+  {
+    const profilerEffects = pendingPassiveProfilerEffects;
+    pendingPassiveProfilerEffects = [];
+
+    for (let i = 0; i < profilerEffects.length; i++) {
+      const fiber = profilerEffects[i];
+      commitPassiveEffectDurations(root, fiber);
+    }
+  }
+
+  {
+    markPassiveEffectsStopped();
+  }
+
+  executionContext = prevExecutionContext;
+  flushSyncWorkOnAllRoots();
+
+
+  onPostCommitRoot(root);
+
+  {
+    const stateNode = root.current.stateNode;
+    stateNode.effectDuration = 0;
+    stateNode.passiveEffectDuration = 0;
+  }
+
+  return true;
+}
+
+function isAlreadyFailedLegacyErrorBoundary(instance) {
+  return legacyErrorBoundariesThatAlreadyFailed !== null && legacyErrorBoundariesThatAlreadyFailed.has(instance);
+}
+function markLegacyErrorBoundaryAsFailed(instance) {
+  if (legacyErrorBoundariesThatAlreadyFailed === null) {
+    legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);
+  } else {
+    legacyErrorBoundariesThatAlreadyFailed.add(instance);
+  }
+}
+
+function prepareToThrowUncaughtError(error) {
+  if (!hasUncaughtError) {
+    hasUncaughtError = true;
+    firstUncaughtError = error;
+  }
+}
+
+const onUncaughtError = prepareToThrowUncaughtError;
+
+function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
+  const errorInfo = createCapturedValueAtFiber(error, sourceFiber);
+  const update = createRootErrorUpdate(rootFiber, errorInfo, SyncLane);
+  const root = enqueueUpdate(rootFiber, update, SyncLane);
+
+  if (root !== null) {
+    markRootUpdated(root, SyncLane);
+    ensureRootIsScheduled(root);
+  }
+}
+
+function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
+
+  if (sourceFiber.tag === HostRoot) {
+    // Error was thrown at the root. There is no parent, so the root
+    // itself should capture it.
+    captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
+    return;
+  }
+
+  let fiber = nearestMountedAncestor;
+
+  while (fiber !== null) {
+    if (fiber.tag === HostRoot) {
+      captureCommitPhaseErrorOnRoot(fiber, sourceFiber, error);
+      return;
+    } else if (fiber.tag === ClassComponent) {
+      const ctor = fiber.type;
+      const instance = fiber.stateNode;
+
+      if (typeof ctor.getDerivedStateFromError === 'function' || typeof instance.componentDidCatch === 'function' && !isAlreadyFailedLegacyErrorBoundary(instance)) {
+        const errorInfo = createCapturedValueAtFiber(error, sourceFiber);
+        const update = createClassErrorUpdate(fiber, errorInfo, SyncLane);
+        const root = enqueueUpdate(fiber, update, SyncLane);
+
+        if (root !== null) {
+          markRootUpdated(root, SyncLane);
+          ensureRootIsScheduled(root);
+        }
+
+        return;
+      }
+    }
+
+    fiber = fiber.return;
+  }
+}
+function attachPingListener(root, wakeable, lanes) {
+  // Attach a ping listener
+  //
+  // The data might resolve before we have a chance to commit the fallback. Or,
+  // in the case of a refresh, we'll never commit a fallback. So we need to
+  // attach a listener now. When it resolves ("pings"), we can decide whether to
+  // try rendering the tree again.
+  //
+  // Only attach a listener if one does not already exist for the lanes
+  // we're currently rendering (which acts like a "thread ID" here).
+  //
+  // We only need to do this in concurrent mode. Legacy Suspense always
+  // commits fallbacks synchronously, so there are no pings.
+  let pingCache = root.pingCache;
+  let threadIDs;
+
+  if (pingCache === null) {
+    pingCache = root.pingCache = new PossiblyWeakMap();
+    threadIDs = new Set();
+    pingCache.set(wakeable, threadIDs);
+  } else {
+    threadIDs = pingCache.get(wakeable);
+
+    if (threadIDs === undefined) {
+      threadIDs = new Set();
+      pingCache.set(wakeable, threadIDs);
+    }
+  }
+
+  if (!threadIDs.has(lanes)) {
+    workInProgressRootDidAttachPingListener = true; // Memoize using the thread ID to prevent redundant listeners.
+
+    threadIDs.add(lanes);
+    const 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);
+  }
+}
+
+function pingSuspendedRoot(root, wakeable, pingedLanes) {
+  const pingCache = root.pingCache;
+
+  if (pingCache !== null) {
+    // The wakeable resolved, so we no longer need to memoize, because it will
+    // never be thrown again.
+    pingCache.delete(wakeable);
+  }
+
+  markRootPinged(root, pingedLanes);
+
+  if (workInProgressRoot === root && isSubsetOfLanes(workInProgressRootRenderLanes, pingedLanes)) {
+    // Received a ping at the same priority level at which we're currently
+    // rendering. We might want to restart this render. This should mirror
+    // the logic of whether or not a root suspends once it completes.
+    // TODO: If we're rendering sync either due to Sync, Batched or expired,
+    // we should probably never restart.
+    // If we're suspended with delay, or if it's a retry, we'll always suspend
+    // so we can always restart.
+    if (workInProgressRootExitStatus === RootSuspendedWithDelay || workInProgressRootExitStatus === RootSuspended && includesOnlyRetries(workInProgressRootRenderLanes) && now$1() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS) {
+      // Force a restart from the root by unwinding the stack. Unless this is
+      // being called from the render phase, because that would cause a crash.
+      if ((executionContext & RenderContext) === NoContext) {
+        prepareFreshStack(root, NoLanes);
+      }
+    } else {
+      // Even though we can't restart right now, we might get an
+      // opportunity later. So we mark this render as having a ping.
+      workInProgressRootPingedLanes = mergeLanes(workInProgressRootPingedLanes, pingedLanes);
+    }
+  }
+
+  ensureRootIsScheduled(root);
+}
+
+function retryTimedOutBoundary(boundaryFiber, retryLane) {
+  // The boundary fiber (a Suspense component or SuspenseList component)
+  // previously was rendered in its fallback state. One of the promises that
+  // suspended it has resolved, which means at least part of the tree was
+  // likely unblocked. Try rendering again, at a new lanes.
+  if (retryLane === NoLane) {
+    // TODO: Assign this to `suspenseState.retryLane`? to avoid
+    // unnecessary entanglement?
+    retryLane = requestRetryLane(boundaryFiber);
+  } // TODO: Special case idle priority?
+
+
+  const root = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
+
+  if (root !== null) {
+    markRootUpdated(root, retryLane);
+    ensureRootIsScheduled(root);
+  }
+}
+
+function retryDehydratedSuspenseBoundary(boundaryFiber) {
+  const suspenseState = boundaryFiber.memoizedState;
+  let retryLane = NoLane;
+
+  if (suspenseState !== null) {
+    retryLane = suspenseState.retryLane;
+  }
+
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+}
+function resolveRetryWakeable(boundaryFiber, wakeable) {
+  let retryLane = NoLane; // Default
+
+  let retryCache;
+
+  switch (boundaryFiber.tag) {
+    case SuspenseComponent:
+      retryCache = boundaryFiber.stateNode;
+      const suspenseState = boundaryFiber.memoizedState;
+
+      if (suspenseState !== null) {
+        retryLane = suspenseState.retryLane;
+      }
+
+      break;
+
+    case SuspenseListComponent:
+      retryCache = boundaryFiber.stateNode;
+      break;
+
+    case OffscreenComponent:
+      {
+        const instance = boundaryFiber.stateNode;
+        retryCache = instance._retryCache;
+        break;
+      }
+
+    default:
+      throw Error(formatProdErrorMessage(314));
+  }
+
+  if (retryCache !== null) {
+    // The wakeable resolved, so we no longer need to memoize, because it will
+    // never be thrown again.
+    retryCache.delete(wakeable);
+  }
+
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+}
+function throwIfInfiniteUpdateLoopDetected() {
+  if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
+    nestedUpdateCount = 0;
+    rootWithNestedUpdates = null;
+    throw Error(formatProdErrorMessage(185));
+  }
+}
+let beginWork;
+
+{
+  beginWork = beginWork$1;
+}
+
+function restorePendingUpdaters(root, lanes) {
+  {
+    if (isDevToolsPresent) {
+      const memoizedUpdaters = root.memoizedUpdaters;
+      memoizedUpdaters.forEach(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).
+    }
+  }
+}
+
+function scheduleCallback(priorityLevel, callback) {
+  {
+    // In production, always call Scheduler. This function will be stripped out.
+    return scheduleCallback$3(priorityLevel, callback);
+  }
+}
+
+function FiberNode(tag, pendingProps, key, mode) {
+  // Instance
+  this.tag = tag;
+  this.key = key;
+  this.elementType = null;
+  this.type = null;
+  this.stateNode = null; // Fiber
+
+  this.return = null;
+  this.child = null;
+  this.sibling = null;
+  this.index = 0;
+  this.ref = null;
+  this.refCleanup = null;
+  this.pendingProps = pendingProps;
+  this.memoizedProps = null;
+  this.updateQueue = null;
+  this.memoizedState = null;
+  this.dependencies = null;
+  this.mode = mode; // Effects
+
+  this.flags = NoFlags$1;
+  this.subtreeFlags = NoFlags$1;
+  this.deletions = null;
+  this.lanes = NoLanes;
+  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 is a constructor function, rather than a POJO constructor, still
+// please ensure we do the following:
+// 1) Nobody should add any instance methods on this. Instance methods can be
+//    more difficult to predict when they get optimized and they are almost
+//    never inlined properly in static compilers.
+// 2) Nobody should rely on `instanceof Fiber` for type testing. We should
+//    always know when it is a fiber.
+// 3) We might want to experiment with using numeric keys since they are easier
+//    to optimize in a non-JIT environment.
+// 4) We can easily go from a constructor to a createFiber object literal if that
+//    is faster.
+// 5) It should be easy to port this to a C struct and keep a C implementation
+//    compatible.
+
+
+function createFiber(tag, pendingProps, key, mode) {
+  // $FlowFixMe[invalid-constructor]: the shapes are exact here but Flow doesn't like constructors
+  return new FiberNode(tag, pendingProps, key, mode);
+}
+
+function shouldConstruct(Component) {
+  const prototype = Component.prototype;
+  return !!(prototype && prototype.isReactComponent);
+}
+
+function isSimpleFunctionComponent(type) {
+  return typeof type === 'function' && !shouldConstruct(type) && type.defaultProps === undefined;
+}
+function resolveLazyComponentTag(Component) {
+  if (typeof Component === 'function') {
+    return shouldConstruct(Component) ? ClassComponent : FunctionComponent;
+  } else if (Component !== undefined && Component !== null) {
+    const $$typeof = Component.$$typeof;
+
+    if ($$typeof === REACT_FORWARD_REF_TYPE) {
+      return ForwardRef;
+    }
+
+    if ($$typeof === REACT_MEMO_TYPE) {
+      return MemoComponent;
+    }
+  }
+
+  return IndeterminateComponent;
+} // This is used to create an alternate fiber to do work on.
+
+function createWorkInProgress(current, pendingProps) {
+  let workInProgress = current.alternate;
+
+  if (workInProgress === null) {
+    // We use a double buffering pooling technique because we know that we'll
+    // only ever need at most two versions of a tree. We pool the "other" unused
+    // node that we're free to reuse. This is lazily created to avoid allocating
+    // extra objects for things that are never updated. It also allow us to
+    // reclaim the extra memory if needed.
+    workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode);
+    workInProgress.elementType = current.elementType;
+    workInProgress.type = current.type;
+    workInProgress.stateNode = current.stateNode;
+
+    workInProgress.alternate = current;
+    current.alternate = workInProgress;
+  } else {
+    workInProgress.pendingProps = pendingProps; // Needed because Blocks store data on type.
+
+    workInProgress.type = current.type; // We already have an alternate.
+    // Reset the effect tag.
+
+    workInProgress.flags = NoFlags$1; // The effects are no longer valid.
+
+    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.
+
+
+  workInProgress.flags = current.flags & StaticMask;
+  workInProgress.childLanes = current.childLanes;
+  workInProgress.lanes = current.lanes;
+  workInProgress.child = current.child;
+  workInProgress.memoizedProps = current.memoizedProps;
+  workInProgress.memoizedState = current.memoizedState;
+  workInProgress.updateQueue = current.updateQueue; // Clone the dependencies object. This is mutated during the render phase, so
+  // it cannot be shared with the current fiber.
+
+  const currentDependencies = current.dependencies;
+  workInProgress.dependencies = currentDependencies === null ? null : {
+    lanes: currentDependencies.lanes,
+    firstContext: currentDependencies.firstContext
+  }; // These will be overridden during the parent's reconciliation
+
+  workInProgress.sibling = current.sibling;
+  workInProgress.index = current.index;
+  workInProgress.ref = current.ref;
+  workInProgress.refCleanup = current.refCleanup;
+
+  {
+    workInProgress.selfBaseDuration = current.selfBaseDuration;
+    workInProgress.treeBaseDuration = current.treeBaseDuration;
+  }
+
+  return workInProgress;
+} // Used to reuse a Fiber for a second pass.
+
+function resetWorkInProgress(workInProgress, renderLanes) {
+  // This resets the Fiber to what createFiber or createWorkInProgress would
+  // have set the values to before during the first pass. Ideally this wouldn't
+  // be necessary but unfortunately many code paths reads from the workInProgress
+  // when they should be reading from current and writing to workInProgress.
+  // We assume pendingProps, index, key, ref, return are still untouched to
+  // avoid doing another reconciliation.
+  // Reset the effect flags but keep any Placement tags, since that's something
+  // that child fiber is setting, not the reconciliation.
+  workInProgress.flags &= StaticMask | Placement; // The effects are no longer valid.
+
+  const current = workInProgress.alternate;
+
+  if (current === null) {
+    // Reset to createFiber's initial values.
+    workInProgress.childLanes = NoLanes;
+    workInProgress.lanes = renderLanes;
+    workInProgress.child = null;
+    workInProgress.subtreeFlags = NoFlags$1;
+    workInProgress.memoizedProps = null;
+    workInProgress.memoizedState = null;
+    workInProgress.updateQueue = null;
+    workInProgress.dependencies = null;
+    workInProgress.stateNode = null;
+
+    {
+      // Note: We don't reset the actualTime counts. It's useful to accumulate
+      // actual time across multiple render passes.
+      workInProgress.selfBaseDuration = 0;
+      workInProgress.treeBaseDuration = 0;
+    }
+  } else {
+    // Reset to the cloned values that createWorkInProgress would've.
+    workInProgress.childLanes = current.childLanes;
+    workInProgress.lanes = current.lanes;
+    workInProgress.child = current.child;
+    workInProgress.subtreeFlags = NoFlags$1;
+    workInProgress.deletions = null;
+    workInProgress.memoizedProps = current.memoizedProps;
+    workInProgress.memoizedState = current.memoizedState;
+    workInProgress.updateQueue = current.updateQueue; // Needed because Blocks store data on type.
+
+    workInProgress.type = current.type; // Clone the dependencies object. This is mutated during the render phase, so
+    // it cannot be shared with the current fiber.
+
+    const currentDependencies = current.dependencies;
+    workInProgress.dependencies = currentDependencies === null ? null : {
+      lanes: currentDependencies.lanes,
+      firstContext: currentDependencies.firstContext
+    };
+
+    {
+      // Note: We don't reset the actualTime counts. It's useful to accumulate
+      // actual time across multiple render passes.
+      workInProgress.selfBaseDuration = current.selfBaseDuration;
+      workInProgress.treeBaseDuration = current.treeBaseDuration;
+    }
+  }
+
+  return workInProgress;
+}
+function createHostRootFiber(tag, isStrictMode, concurrentUpdatesByDefaultOverride) {
+  let mode;
+
+  if (tag === ConcurrentRoot) {
+    mode = ConcurrentMode;
+
+    if (isStrictMode === true || createRootStrictEffectsByDefault) {
+      mode |= StrictLegacyMode | StrictEffectsMode;
+    }
+  } else {
+    mode = NoMode;
+  }
+
+  if (isDevToolsPresent) {
+    // Always collect profile timings when DevTools are present.
+    // This enables DevTools to start capturing timing at any point–
+    // Without some nodes in the tree having empty base times.
+    mode |= ProfileMode;
+  }
+
+  return createFiber(HostRoot, null, null, mode);
+}
+function createFiberFromTypeAndProps(type, // React$ElementType
+key, pendingProps, source, owner, mode, lanes) {
+  let fiberTag = IndeterminateComponent; // The resolved type is set if we know what the final type will be. I.e. it's not lazy.
+
+  let resolvedType = type;
+
+  if (typeof type === 'function') {
+    if (shouldConstruct(type)) {
+      fiberTag = ClassComponent;
+    }
+  } else if (typeof type === 'string') {
+    {
+      const hostContext = getHostContext();
+      fiberTag = isHostHoistableType(type, pendingProps, hostContext) ? HostHoistable : isHostSingletonType(type) ? HostSingleton : HostComponent;
+    }
+  } else {
+    getTag: switch (type) {
+      case REACT_FRAGMENT_TYPE:
+        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
+
+      case REACT_STRICT_MODE_TYPE:
+        fiberTag = Mode;
+        mode |= StrictLegacyMode;
+
+        if ((mode & ConcurrentMode) !== NoMode) {
+          // Strict effects should never run on legacy roots
+          mode |= StrictEffectsMode;
+        }
+
+        break;
+
+      case REACT_PROFILER_TYPE:
+        return createFiberFromProfiler(pendingProps, mode, lanes, key);
+
+      case REACT_SUSPENSE_TYPE:
+        return createFiberFromSuspense(pendingProps, mode, lanes, key);
+
+      case REACT_SUSPENSE_LIST_TYPE:
+        return createFiberFromSuspenseList(pendingProps, mode, lanes, key);
+
+      case REACT_OFFSCREEN_TYPE:
+        return createFiberFromOffscreen(pendingProps, mode, lanes, key);
+
+      case REACT_LEGACY_HIDDEN_TYPE:
+
+      // Fall through
+
+      case REACT_SCOPE_TYPE:
+
+      // Fall through
+
+      case REACT_CACHE_TYPE:
+        {
+          return createFiberFromCache(pendingProps, mode, lanes, key);
+        }
+
+      // Fall through
+
+      case REACT_TRACING_MARKER_TYPE:
+
+      // Fall through
+
+      case REACT_DEBUG_TRACING_MODE_TYPE:
+
+      // Fall through
+
+      default:
+        {
+          if (typeof type === 'object' && type !== null) {
+            switch (type.$$typeof) {
+              case REACT_PROVIDER_TYPE:
+                fiberTag = ContextProvider;
+                break getTag;
+
+              case REACT_CONTEXT_TYPE:
+                // This is a consumer
+                fiberTag = ContextConsumer;
+                break getTag;
+
+              case REACT_FORWARD_REF_TYPE:
+                fiberTag = ForwardRef;
+
+                break getTag;
+
+              case REACT_MEMO_TYPE:
+                fiberTag = MemoComponent;
+                break getTag;
+
+              case REACT_LAZY_TYPE:
+                fiberTag = LazyComponent;
+                resolvedType = null;
+                break getTag;
+            }
+          }
+
+          let info = '';
+
+          throw Error(formatProdErrorMessage(130, type == null ? type : typeof type, info));
+        }
+    }
+  }
+
+  const fiber = createFiber(fiberTag, pendingProps, key, mode);
+  fiber.elementType = type;
+  fiber.type = resolvedType;
+  fiber.lanes = lanes;
+
+  return fiber;
+}
+function createFiberFromElement(element, mode, lanes) {
+  let source = null;
+  let owner = null;
+
+  const type = element.type;
+  const key = element.key;
+  const pendingProps = element.props;
+  const fiber = createFiberFromTypeAndProps(type, key, pendingProps, source, owner, mode, lanes);
+
+  return fiber;
+}
+function createFiberFromFragment(elements, mode, lanes, key) {
+  const fiber = createFiber(Fragment, elements, key, mode);
+  fiber.lanes = lanes;
+  return fiber;
+}
+
+function createFiberFromProfiler(pendingProps, mode, lanes, key) {
+
+  const fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);
+  fiber.elementType = REACT_PROFILER_TYPE;
+  fiber.lanes = lanes;
+
+  {
+    fiber.stateNode = {
+      effectDuration: 0,
+      passiveEffectDuration: 0
+    };
+  }
+
+  return fiber;
+}
+
+function createFiberFromSuspense(pendingProps, mode, lanes, key) {
+  const fiber = createFiber(SuspenseComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_SUSPENSE_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromSuspenseList(pendingProps, mode, lanes, key) {
+  const fiber = createFiber(SuspenseListComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_SUSPENSE_LIST_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
+  const fiber = createFiber(OffscreenComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_OFFSCREEN_TYPE;
+  fiber.lanes = lanes;
+  const primaryChildInstance = {
+    _visibility: OffscreenVisible,
+    _pendingVisibility: OffscreenVisible,
+    _pendingMarkers: null,
+    _retryCache: null,
+    _transitions: null,
+    _current: null,
+    detach: () => detachOffscreenInstance(primaryChildInstance),
+    attach: () => attachOffscreenInstance(primaryChildInstance)
+  };
+  fiber.stateNode = primaryChildInstance;
+  return fiber;
+}
+function createFiberFromCache(pendingProps, mode, lanes, key) {
+  const fiber = createFiber(CacheComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_CACHE_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromText(content, mode, lanes) {
+  const fiber = createFiber(HostText, content, null, mode);
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromHostInstanceForDeletion() {
+  const fiber = createFiber(HostComponent, null, null, NoMode);
+  fiber.elementType = 'DELETED';
+  return fiber;
+}
+function createFiberFromDehydratedFragment(dehydratedNode) {
+  const fiber = createFiber(DehydratedFragment, null, null, NoMode);
+  fiber.stateNode = dehydratedNode;
+  return fiber;
+}
+function createFiberFromPortal(portal, mode, lanes) {
+  const pendingProps = portal.children !== null ? portal.children : [];
+  const fiber = createFiber(HostPortal, pendingProps, portal.key, mode);
+  fiber.lanes = lanes;
+  fiber.stateNode = {
+    containerInfo: portal.containerInfo,
+    pendingChildren: null,
+    // Used by persistent updates
+    implementation: portal.implementation
+  };
+  return fiber;
+} // Used for stashing WIP properties to replay failed work in DEV.
+
+function FiberRootNode(containerInfo, // $FlowFixMe[missing-local-annot]
+tag, hydrate, identifierPrefix, onRecoverableError, formState) {
+  this.tag = tag;
+  this.containerInfo = containerInfo;
+  this.pendingChildren = null;
+  this.current = null;
+  this.pingCache = null;
+  this.finishedWork = null;
+  this.timeoutHandle = noTimeout;
+  this.cancelPendingCommit = null;
+  this.context = null;
+  this.pendingContext = null;
+  this.next = null;
+  this.callbackNode = null;
+  this.callbackPriority = NoLane;
+  this.expirationTimes = createLaneMap(NoTimestamp);
+  this.pendingLanes = NoLanes;
+  this.suspendedLanes = NoLanes;
+  this.pingedLanes = NoLanes;
+  this.expiredLanes = NoLanes;
+  this.finishedLanes = NoLanes;
+  this.errorRecoveryDisabledLanes = NoLanes;
+  this.shellSuspendCounter = 0;
+  this.entangledLanes = NoLanes;
+  this.entanglements = createLaneMap(NoLanes);
+  this.hiddenUpdates = createLaneMap(null);
+  this.identifierPrefix = identifierPrefix;
+  this.onRecoverableError = onRecoverableError;
+
+  {
+    this.pooledCache = null;
+    this.pooledCacheLanes = NoLanes;
+  }
+
+  this.formState = formState;
+  this.incompleteTransitions = new Map();
+
+  {
+    this.effectDuration = 0;
+    this.passiveEffectDuration = 0;
+  }
+
+  {
+    this.memoizedUpdaters = new Set();
+    const pendingUpdatersLaneMap = this.pendingUpdatersLaneMap = [];
+
+    for (let i = 0; i < TotalLanes; i++) {
+      pendingUpdatersLaneMap.push(new Set());
+    }
+  }
+}
+
+function createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, // TODO: We have several of these arguments that are conceptually part of the
+// host config, but because they are passed in at runtime, we have to thread
+// them through the root constructor. Perhaps we should put them all into a
+// single type, like a DynamicHostConfig that is defined by the renderer.
+identifierPrefix, onRecoverableError, transitionCallbacks, formState) {
+  // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
+  const root = new FiberRootNode(containerInfo, tag, hydrate, identifierPrefix, onRecoverableError, formState);
+  // stateNode is any.
+
+
+  const uninitializedFiber = createHostRootFiber(tag, isStrictMode);
+  root.current = uninitializedFiber;
+  uninitializedFiber.stateNode = root;
+
+  {
+    const initialCache = createCache();
+    retainCache(initialCache); // The pooledCache is a fresh cache instance that is used temporarily
+    // for newly mounted boundaries during a render. In general, the
+    // pooledCache is always cleared from the root at the end of a render:
+    // it is either released when render commits, or moved to an Offscreen
+    // component if rendering suspends. Because the lifetime of the pooled
+    // cache is distinct from the main memoizedState.cache, it must be
+    // retained separately.
+
+    root.pooledCache = initialCache;
+    retainCache(initialCache);
+    const initialState = {
+      element: initialChildren,
+      isDehydrated: hydrate,
+      cache: initialCache
+    };
+    uninitializedFiber.memoizedState = initialState;
+  }
+
+  initializeUpdateQueue(uninitializedFiber);
+  return root;
+}
+
+var ReactVersion = '18.3.0-experimental-7508dcd5c-20231108';
+
+function createPortal$1(children, containerInfo, // TODO: figure out the API for cross-renderer implementation.
+implementation) {
+  let key = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+
+  return {
+    // This tag allow us to uniquely identify this as a React Portal
+    $$typeof: REACT_PORTAL_TYPE,
+    key: key == null ? null : '' + key,
+    children,
+    containerInfo,
+    implementation
+  };
+}
+
+function getContextForSubtree(parentComponent) {
+  if (!parentComponent) {
+    return emptyContextObject;
+  }
+
+  const fiber = get(parentComponent);
+  const parentContext = findCurrentUnmaskedContext(fiber);
+
+  if (fiber.tag === ClassComponent) {
+    const Component = fiber.type;
+
+    if (isContextProvider(Component)) {
+      return processChildContext(fiber, Component, parentContext);
+    }
+  }
+
+  return parentContext;
+}
+
+function findHostInstance(component) {
+  const fiber = get(component);
+
+  if (fiber === undefined) {
+    if (typeof component.render === 'function') {
+      throw Error(formatProdErrorMessage(188));
+    } else {
+      const keys = Object.keys(component).join(',');
+      throw Error(formatProdErrorMessage(268, keys));
+    }
+  }
+
+  const hostFiber = findCurrentHostFiber(fiber);
+
+  if (hostFiber === null) {
+    return null;
+  }
+
+  return getPublicInstance(hostFiber.stateNode);
+}
+
+function createContainer(containerInfo, tag, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks) {
+  const hydrate = false;
+  const initialChildren = null;
+  return createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks, null);
+}
+function createHydrationContainer(initialChildren, // TODO: Remove `callback` when we delete legacy mode.
+callback, containerInfo, tag, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks, formState) {
+  const hydrate = true;
+  const root = createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks, formState); // TODO: Move this to FiberRoot constructor
+
+  root.context = getContextForSubtree(null); // Schedule the initial render. In a hydration root, this is different from
+  // a regular update because the initial render must match was was rendered
+  // on the server.
+  // NOTE: This update intentionally doesn't have a payload. We're only using
+  // the update to schedule work on the root fiber (and, for legacy roots, to
+  // enqueue the callback if one is provided).
+
+  const current = root.current;
+  const lane = requestUpdateLane(current);
+  const update = createUpdate(lane);
+  update.callback = callback !== undefined && callback !== null ? callback : null;
+  enqueueUpdate(current, update, lane);
+  scheduleInitialHydrationOnRoot(root, lane);
+  return root;
+}
+function updateContainer(element, container, parentComponent, callback) {
+
+  const current = container.current;
+  const lane = requestUpdateLane(current);
+
+  {
+    markRenderScheduled(lane);
+  }
+
+  const context = getContextForSubtree(parentComponent);
+
+  if (container.context === null) {
+    container.context = context;
+  } else {
+    container.pendingContext = context;
+  }
+
+  const update = createUpdate(lane); // Caution: React DevTools currently depends on this property
+  // being called "element".
+
+  update.payload = {
+    element
+  };
+  callback = callback === undefined ? null : callback;
+
+  if (callback !== null) {
+
+    update.callback = callback;
+  }
+
+  const root = enqueueUpdate(current, update, lane);
+
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, current, lane);
+    entangleTransitions(root, current, lane);
+  }
+
+  return lane;
+}
+function getPublicRootInstance(container) {
+  const containerFiber = container.current;
+
+  if (!containerFiber.child) {
+    return null;
+  }
+
+  switch (containerFiber.child.tag) {
+    case HostSingleton:
+    case HostComponent:
+      return getPublicInstance(containerFiber.child.stateNode);
+
+    default:
+      return containerFiber.child.stateNode;
+  }
+}
+function attemptSynchronousHydration(fiber) {
+  switch (fiber.tag) {
+    case HostRoot:
+      {
+        const root = fiber.stateNode;
+
+        if (isRootDehydrated(root)) {
+          // Flush the first scheduled "update".
+          const lanes = getHighestPriorityPendingLanes(root);
+          flushRoot(root, lanes);
+        }
+
+        break;
+      }
+
+    case SuspenseComponent:
+      {
+        flushSync$1(() => {
+          const root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+          if (root !== null) {
+            scheduleUpdateOnFiber(root, fiber, SyncLane);
+          }
+        }); // If we're still blocked after this, we need to increase
+        // the priority of any promises resolving within this
+        // boundary so that they next attempt also has higher pri.
+
+        const retryLane = SyncLane;
+        markRetryLaneIfNotHydrated(fiber, retryLane);
+        break;
+      }
+  }
+}
+
+function markRetryLaneImpl(fiber, retryLane) {
+  const suspenseState = fiber.memoizedState;
+
+  if (suspenseState !== null && suspenseState.dehydrated !== null) {
+    suspenseState.retryLane = higherPriorityLane(suspenseState.retryLane, retryLane);
+  }
+} // Increases the priority of thenables when they resolve within this boundary.
+
+
+function markRetryLaneIfNotHydrated(fiber, retryLane) {
+  markRetryLaneImpl(fiber, retryLane);
+  const alternate = fiber.alternate;
+
+  if (alternate) {
+    markRetryLaneImpl(alternate, retryLane);
+  }
+}
+
+function attemptContinuousHydration(fiber) {
+  if (fiber.tag !== SuspenseComponent) {
+    // We ignore HostRoots here because we can't increase
+    // their priority and they should not suspend on I/O,
+    // since you have to wrap anything that might suspend in
+    // Suspense.
+    return;
+  }
+
+  const lane = SelectiveHydrationLane;
+  const root = enqueueConcurrentRenderForLane(fiber, lane);
+
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, fiber, lane);
+  }
+
+  markRetryLaneIfNotHydrated(fiber, lane);
+}
+function attemptHydrationAtCurrentPriority(fiber) {
+  if (fiber.tag !== SuspenseComponent) {
+    // We ignore HostRoots here because we can't increase
+    // their priority other than synchronously flush it.
+    return;
+  }
+
+  const lane = requestUpdateLane(fiber);
+  const root = enqueueConcurrentRenderForLane(fiber, lane);
+
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, fiber, lane);
+  }
+
+  markRetryLaneIfNotHydrated(fiber, lane);
+}
+let overrideHookState = null;
+let overrideHookStateDeletePath = null;
+let overrideHookStateRenamePath = null;
+let overrideProps = null;
+let overridePropsDeletePath = null;
+let overridePropsRenamePath = null;
+let scheduleUpdate = null;
+let setErrorHandler = null;
+let setSuspenseHandler = null;
+
+function findHostInstanceByFiber(fiber) {
+  const hostFiber = findCurrentHostFiber(fiber);
+
+  if (hostFiber === null) {
+    return null;
+  }
+
+  return hostFiber.stateNode;
+}
+
+function emptyFindFiberByHostInstance(instance) {
+  return null;
+}
+
+function injectIntoDevTools(devToolsConfig) {
+  const findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
+  const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+  return injectInternals({
+    bundleType: devToolsConfig.bundleType,
+    version: devToolsConfig.version,
+    rendererPackageName: devToolsConfig.rendererPackageName,
+    rendererConfig: devToolsConfig.rendererConfig,
+    overrideHookState,
+    overrideHookStateDeletePath,
+    overrideHookStateRenamePath,
+    overrideProps,
+    overridePropsDeletePath,
+    overridePropsRenamePath,
+    setErrorHandler,
+    setSuspenseHandler,
+    scheduleUpdate,
+    currentDispatcherRef: ReactCurrentDispatcher,
+    findHostInstanceByFiber,
+    findFiberByHostInstance: findFiberByHostInstance || emptyFindFiberByHostInstance,
+    // React Refresh
+    findHostInstancesForRefresh: null,
+    scheduleRefresh: null,
+    scheduleRoot: null,
+    setRefreshHandler: null,
+    // Enables DevTools to append owner stacks to error messages in DEV mode.
+    getCurrentFiber: null,
+    // Enables DevTools to detect reconciler version rather than renderer version
+    // which may not match for third party renderers.
+    reconcilerVersion: ReactVersion
+  });
+}
+
+// the renderer. Such as when we're dispatching events or if third party
+// libraries need to call batchedUpdates. Eventually, this API will go away when
+// everything is batched by default. We'll then have a similar API to opt-out of
+// scheduled work and instead do synchronous work.
+
+let isInsideEventHandler = false;
+
+function finishEventHandler() {
+  // Here we wait until all updates have propagated, which is important
+  // when using controlled components within layers:
+  // https://github.com/facebook/react/issues/1698
+  // Then we restore state of any controlled component.
+  const controlledComponentsHavePendingUpdates = needsStateRestore();
+
+  if (controlledComponentsHavePendingUpdates) {
+    // If a controlled event was fired, we may need to restore the state of
+    // the DOM node back to the controlled value. This is necessary when React
+    // bails out of the update without touching the DOM.
+    // TODO: Restore state in the microtask, after the discrete updates flush,
+    // instead of early flushing them here.
+    flushSync$1();
+    restoreStateIfNeeded();
+  }
+}
+
+function batchedUpdates(fn, a, b) {
+  if (isInsideEventHandler) {
+    // If we are currently inside another batch, we need to wait until it
+    // fully completes before restoring state.
+    return fn(a, b);
+  }
+
+  isInsideEventHandler = true;
+
+  try {
+    return batchedUpdates$1(fn, a, b);
+  } finally {
+    isInsideEventHandler = false;
+    finishEventHandler();
+  }
+} // TODO: Replace with flushSync
+
+function isInteractive(tag) {
+  return tag === 'button' || tag === 'input' || tag === 'select' || tag === 'textarea';
+}
+
+function shouldPreventMouseEvent(name, type, props) {
+  switch (name) {
+    case 'onClick':
+    case 'onClickCapture':
+    case 'onDoubleClick':
+    case 'onDoubleClickCapture':
+    case 'onMouseDown':
+    case 'onMouseDownCapture':
+    case 'onMouseMove':
+    case 'onMouseMoveCapture':
+    case 'onMouseUp':
+    case 'onMouseUpCapture':
+    case 'onMouseEnter':
+      return !!(props.disabled && isInteractive(type));
+
+    default:
+      return false;
+  }
+}
+/**
+ * @param {object} inst The instance, which is the source of events.
+ * @param {string} registrationName Name of listener (e.g. `onClick`).
+ * @return {?function} The stored callback.
+ */
+
+
+function getListener(inst, registrationName) {
+  const stateNode = inst.stateNode;
+
+  if (stateNode === null) {
+    // Work in progress (ex: onload events in incremental mode).
+    return null;
+  }
+
+  const props = getFiberCurrentPropsFromNode(stateNode);
+
+  if (props === null) {
+    // Work in progress.
+    return null;
+  }
+
+  const listener = props[registrationName];
+
+  if (shouldPreventMouseEvent(registrationName, inst.type, props)) {
+    return null;
+  }
+
+  if (listener && typeof listener !== 'function') {
+    throw Error(formatProdErrorMessage(231, registrationName, typeof listener));
+  }
+
+  return listener;
+}
+
+let passiveBrowserEventsSupported = false; // Check if browser support events with passive listeners
+// https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support
+
+if (canUseDOM) {
+  try {
+    const options = {};
+    Object.defineProperty(options, 'passive', {
+      get: function () {
+        passiveBrowserEventsSupported = true;
+      }
+    });
+    window.addEventListener('test', options, options);
+    window.removeEventListener('test', options, options);
+  } catch (e) {
+    passiveBrowserEventsSupported = false;
+  }
+}
+
+/**
+ * `charCode` represents the actual "character code" and is safe to use with
+ * `String.fromCharCode`. As such, only keys that correspond to printable
+ * characters produce a valid `charCode`, the only exception to this is Enter.
+ * The Tab-key is considered non-printable and does not have a `charCode`,
+ * presumably because it does not produce a tab-character in browsers.
+ *
+ * @param {object} nativeEvent Native browser event.
+ * @return {number} Normalized `charCode` property.
+ */
+function getEventCharCode(nativeEvent) {
+  let charCode;
+  const keyCode = nativeEvent.keyCode;
+
+  if ('charCode' in nativeEvent) {
+    charCode = nativeEvent.charCode; // FF does not set `charCode` for the Enter-key, check against `keyCode`.
+
+    if (charCode === 0 && keyCode === 13) {
+      charCode = 13;
+    }
+  } else {
+    // IE8 does not implement `charCode`, but `keyCode` has the correct value.
+    charCode = keyCode;
+  } // IE and Edge (on Windows) and Chrome / Safari (on Windows and Linux)
+  // report Enter as charCode 10 when ctrl is pressed.
+
+
+  if (charCode === 10) {
+    charCode = 13;
+  } // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
+  // Must not discard the (non-)printable Enter-key.
+
+
+  if (charCode >= 32 || charCode === 13) {
+    return charCode;
+  }
+
+  return 0;
+}
+
+function functionThatReturnsTrue() {
+  return true;
+}
+
+function functionThatReturnsFalse() {
+  return false;
+} // This is intentionally a factory so that we have different returned constructors.
+// If we had a single constructor, it would be megamorphic and engines would deopt.
+
+
+function createSyntheticEvent(Interface) {
+  /**
+   * Synthetic events are dispatched by event plugins, typically in response to a
+   * top-level event delegation handler.
+   *
+   * These systems should generally use pooling to reduce the frequency of garbage
+   * collection. The system should check `isPersistent` to determine whether the
+   * event should be released into the pool after being dispatched. Users that
+   * need a persisted event should invoke `persist`.
+   *
+   * Synthetic events (and subclasses) implement the DOM Level 3 Events API by
+   * normalizing browser quirks. Subclasses do not necessarily have to implement a
+   * DOM interface; custom application-specific events can also subclass this.
+   */
+  // $FlowFixMe[missing-this-annot]
+  function SyntheticBaseEvent(reactName, reactEventType, targetInst, nativeEvent, nativeEventTarget) {
+    this._reactName = reactName;
+    this._targetInst = targetInst;
+    this.type = reactEventType;
+    this.nativeEvent = nativeEvent;
+    this.target = nativeEventTarget;
+    this.currentTarget = null;
+
+    for (const propName in Interface) {
+      if (!Interface.hasOwnProperty(propName)) {
+        continue;
+      }
+
+      const normalize = Interface[propName];
+
+      if (normalize) {
+        this[propName] = normalize(nativeEvent);
+      } else {
+        this[propName] = nativeEvent[propName];
+      }
+    }
+
+    const defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
+
+    if (defaultPrevented) {
+      this.isDefaultPrevented = functionThatReturnsTrue;
+    } else {
+      this.isDefaultPrevented = functionThatReturnsFalse;
+    }
+
+    this.isPropagationStopped = functionThatReturnsFalse;
+    return this;
+  } // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+  assign(SyntheticBaseEvent.prototype, {
+    // $FlowFixMe[missing-this-annot]
+    preventDefault: function () {
+      this.defaultPrevented = true;
+      const event = this.nativeEvent;
+
+      if (!event) {
+        return;
+      }
+
+      if (event.preventDefault) {
+        event.preventDefault(); // $FlowFixMe[illegal-typeof] - flow is not aware of `unknown` in IE
+      } else if (typeof event.returnValue !== 'unknown') {
+        event.returnValue = false;
+      }
+
+      this.isDefaultPrevented = functionThatReturnsTrue;
+    },
+    // $FlowFixMe[missing-this-annot]
+    stopPropagation: function () {
+      const event = this.nativeEvent;
+
+      if (!event) {
+        return;
+      }
+
+      if (event.stopPropagation) {
+        event.stopPropagation(); // $FlowFixMe[illegal-typeof] - flow is not aware of `unknown` in IE
+      } else if (typeof event.cancelBubble !== 'unknown') {
+        // The ChangeEventPlugin registers a "propertychange" event for
+        // IE. This event does not support bubbling or cancelling, and
+        // any references to cancelBubble throw "Member not found".  A
+        // typeof check of "unknown" circumvents this issue (and is also
+        // IE specific).
+        event.cancelBubble = true;
+      }
+
+      this.isPropagationStopped = functionThatReturnsTrue;
+    },
+
+    /**
+     * We release all dispatched `SyntheticEvent`s after each event loop, adding
+     * them back into the pool. This allows a way to hold onto a reference that
+     * won't be added back into the pool.
+     */
+    persist: function () {// Modern event system doesn't use pooling.
+    },
+
+    /**
+     * Checks if this event should be released back into the pool.
+     *
+     * @return {boolean} True if this should not be released, false otherwise.
+     */
+    isPersistent: functionThatReturnsTrue
+  });
+  return SyntheticBaseEvent;
+}
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+
+const EventInterface = {
+  eventPhase: 0,
+  bubbles: 0,
+  cancelable: 0,
+  timeStamp: function (event) {
+    return event.timeStamp || Date.now();
+  },
+  defaultPrevented: 0,
+  isTrusted: 0
+};
+const SyntheticEvent = createSyntheticEvent(EventInterface);
+
+const UIEventInterface = assign({}, EventInterface, {
+  view: 0,
+  detail: 0
+});
+
+const SyntheticUIEvent = createSyntheticEvent(UIEventInterface);
+let lastMovementX;
+let lastMovementY;
+let lastMouseEvent;
+
+function updateMouseMovementPolyfillState(event) {
+  if (event !== lastMouseEvent) {
+    if (lastMouseEvent && event.type === 'mousemove') {
+      // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+      lastMovementX = event.screenX - lastMouseEvent.screenX; // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+
+      lastMovementY = event.screenY - lastMouseEvent.screenY;
+    } else {
+      lastMovementX = 0;
+      lastMovementY = 0;
+    }
+
+    lastMouseEvent = event;
+  }
+}
+/**
+ * @interface MouseEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+
+const MouseEventInterface = assign({}, UIEventInterface, {
+  screenX: 0,
+  screenY: 0,
+  clientX: 0,
+  clientY: 0,
+  pageX: 0,
+  pageY: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  altKey: 0,
+  metaKey: 0,
+  getModifierState: getEventModifierState,
+  button: 0,
+  buttons: 0,
+  relatedTarget: function (event) {
+    if (event.relatedTarget === undefined) return event.fromElement === event.srcElement ? event.toElement : event.fromElement;
+    return event.relatedTarget;
+  },
+  movementX: function (event) {
+    if ('movementX' in event) {
+      return event.movementX;
+    }
+
+    updateMouseMovementPolyfillState(event);
+    return lastMovementX;
+  },
+  movementY: function (event) {
+    if ('movementY' in event) {
+      return event.movementY;
+    } // Don't need to call updateMouseMovementPolyfillState() here
+    // because it's guaranteed to have already run when movementX
+    // was copied.
+
+
+    return lastMovementY;
+  }
+});
+
+const SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface);
+/**
+ * @interface DragEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+const DragEventInterface = assign({}, MouseEventInterface, {
+  dataTransfer: 0
+});
+
+const SyntheticDragEvent = createSyntheticEvent(DragEventInterface);
+/**
+ * @interface FocusEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+const FocusEventInterface = assign({}, UIEventInterface, {
+  relatedTarget: 0
+});
+
+const SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent
+ */
+
+const AnimationEventInterface = assign({}, EventInterface, {
+  animationName: 0,
+  elapsedTime: 0,
+  pseudoElement: 0
+});
+
+const SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/clipboard-apis/
+ */
+
+const ClipboardEventInterface = assign({}, EventInterface, {
+  clipboardData: function (event) {
+    return 'clipboardData' in event ? event.clipboardData : window.clipboardData;
+  }
+});
+
+const SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents
+ */
+
+const CompositionEventInterface = assign({}, EventInterface, {
+  data: 0
+});
+
+const SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105
+ *      /#events-inputevents
+ */
+// Happens to share the same list for now.
+
+const SyntheticInputEvent = SyntheticCompositionEvent;
+/**
+ * Normalization of deprecated HTML5 `key` values
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
+ */
+
+const normalizeKey = {
+  Esc: 'Escape',
+  Spacebar: ' ',
+  Left: 'ArrowLeft',
+  Up: 'ArrowUp',
+  Right: 'ArrowRight',
+  Down: 'ArrowDown',
+  Del: 'Delete',
+  Win: 'OS',
+  Menu: 'ContextMenu',
+  Apps: 'ContextMenu',
+  Scroll: 'ScrollLock',
+  MozPrintableKey: 'Unidentified'
+};
+/**
+ * Translation from legacy `keyCode` to HTML5 `key`
+ * Only special keys supported, all others depend on keyboard layout or browser
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
+ */
+
+const translateToKey = {
+  '8': 'Backspace',
+  '9': 'Tab',
+  '12': 'Clear',
+  '13': 'Enter',
+  '16': 'Shift',
+  '17': 'Control',
+  '18': 'Alt',
+  '19': 'Pause',
+  '20': 'CapsLock',
+  '27': 'Escape',
+  '32': ' ',
+  '33': 'PageUp',
+  '34': 'PageDown',
+  '35': 'End',
+  '36': 'Home',
+  '37': 'ArrowLeft',
+  '38': 'ArrowUp',
+  '39': 'ArrowRight',
+  '40': 'ArrowDown',
+  '45': 'Insert',
+  '46': 'Delete',
+  '112': 'F1',
+  '113': 'F2',
+  '114': 'F3',
+  '115': 'F4',
+  '116': 'F5',
+  '117': 'F6',
+  '118': 'F7',
+  '119': 'F8',
+  '120': 'F9',
+  '121': 'F10',
+  '122': 'F11',
+  '123': 'F12',
+  '144': 'NumLock',
+  '145': 'ScrollLock',
+  '224': 'Meta'
+};
+/**
+ * @param {object} nativeEvent Native browser event.
+ * @return {string} Normalized `key` property.
+ */
+
+function getEventKey(nativeEvent) {
+  if (nativeEvent.key) {
+    // Normalize inconsistent values reported by browsers due to
+    // implementations of a working draft specification.
+    // FireFox implements `key` but returns `MozPrintableKey` for all
+    // printable characters (normalized to `Unidentified`), ignore it.
+    const key = // $FlowFixMe[invalid-computed-prop] unable to index with a `mixed` value
+    normalizeKey[nativeEvent.key] || nativeEvent.key;
+
+    if (key !== 'Unidentified') {
+      return key;
+    }
+  } // Browser does not implement `key`, polyfill as much of it as we can.
+
+
+  if (nativeEvent.type === 'keypress') {
+    const charCode = getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
+    nativeEvent); // The enter-key is technically both printable and non-printable and can
+    // thus be captured by `keypress`, no other non-printable key should.
+
+    return charCode === 13 ? 'Enter' : String.fromCharCode(charCode);
+  }
+
+  if (nativeEvent.type === 'keydown' || nativeEvent.type === 'keyup') {
+    // While user keyboard layout determines the actual meaning of each
+    // `keyCode` value, almost all function keys have a universal value.
+    // $FlowFixMe[invalid-computed-prop] unable to index with a `mixed` value
+    return translateToKey[nativeEvent.keyCode] || 'Unidentified';
+  }
+
+  return '';
+}
+/**
+ * Translation from modifier key to the associated property in the event.
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers
+ */
+
+
+const modifierKeyToProp = {
+  Alt: 'altKey',
+  Control: 'ctrlKey',
+  Meta: 'metaKey',
+  Shift: 'shiftKey'
+}; // Older browsers (Safari <= 10, iOS Safari <= 10.2) do not support
+// getModifierState. If getModifierState is not supported, we map it to a set of
+// modifier keys exposed by the event. In this case, Lock-keys are not supported.
+// $FlowFixMe[missing-local-annot]
+// $FlowFixMe[missing-this-annot]
+
+function modifierStateGetter(keyArg) {
+  const syntheticEvent = this;
+  const nativeEvent = syntheticEvent.nativeEvent;
+
+  if (nativeEvent.getModifierState) {
+    return nativeEvent.getModifierState(keyArg);
+  }
+
+  const keyProp = modifierKeyToProp[keyArg];
+  return keyProp ? !!nativeEvent[keyProp] : false;
+}
+
+function getEventModifierState(nativeEvent) {
+  return modifierStateGetter;
+}
+/**
+ * @interface KeyboardEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+
+const KeyboardEventInterface = assign({}, UIEventInterface, {
+  key: getEventKey,
+  code: 0,
+  location: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  altKey: 0,
+  metaKey: 0,
+  repeat: 0,
+  locale: 0,
+  getModifierState: getEventModifierState,
+  // Legacy Interface
+  charCode: function (event) {
+    // `charCode` is the result of a KeyPress event and represents the value of
+    // the actual printable character.
+    // KeyPress is deprecated, but its replacement is not yet final and not
+    // implemented in any major browser. Only KeyPress has charCode.
+    if (event.type === 'keypress') {
+      return getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
+      event);
+    }
+
+    return 0;
+  },
+  keyCode: function (event) {
+    // `keyCode` is the result of a KeyDown/Up event and represents the value of
+    // physical keyboard key.
+    // The actual meaning of the value depends on the users' keyboard layout
+    // which cannot be detected. Assuming that it is a US keyboard layout
+    // provides a surprisingly accurate mapping for US and European users.
+    // Due to this, it is left to the user to implement at this time.
+    if (event.type === 'keydown' || event.type === 'keyup') {
+      return event.keyCode;
+    }
+
+    return 0;
+  },
+  which: function (event) {
+    // `which` is an alias for either `keyCode` or `charCode` depending on the
+    // type of the event.
+    if (event.type === 'keypress') {
+      return getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
+      event);
+    }
+
+    if (event.type === 'keydown' || event.type === 'keyup') {
+      return event.keyCode;
+    }
+
+    return 0;
+  }
+});
+
+const SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface);
+/**
+ * @interface PointerEvent
+ * @see http://www.w3.org/TR/pointerevents/
+ */
+
+const PointerEventInterface = assign({}, MouseEventInterface, {
+  pointerId: 0,
+  width: 0,
+  height: 0,
+  pressure: 0,
+  tangentialPressure: 0,
+  tiltX: 0,
+  tiltY: 0,
+  twist: 0,
+  pointerType: 0,
+  isPrimary: 0
+});
+
+const SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface);
+/**
+ * @interface TouchEvent
+ * @see http://www.w3.org/TR/touch-events/
+ */
+
+const TouchEventInterface = assign({}, UIEventInterface, {
+  touches: 0,
+  targetTouches: 0,
+  changedTouches: 0,
+  altKey: 0,
+  metaKey: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  getModifierState: getEventModifierState
+});
+
+const SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent
+ */
+
+const TransitionEventInterface = assign({}, EventInterface, {
+  propertyName: 0,
+  elapsedTime: 0,
+  pseudoElement: 0
+});
+
+const SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface);
+/**
+ * @interface WheelEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+const WheelEventInterface = assign({}, MouseEventInterface, {
+  deltaX(event) {
+    return 'deltaX' in event ? event.deltaX : // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).
+    'wheelDeltaX' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+    -event.wheelDeltaX : 0;
+  },
+
+  deltaY(event) {
+    return 'deltaY' in event ? event.deltaY : // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
+    'wheelDeltaY' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+    -event.wheelDeltaY : // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
+    'wheelDelta' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+    -event.wheelDelta : 0;
+  },
+
+  deltaZ: 0,
+  // Browsers without "deltaMode" is reporting in raw wheel delta where one
+  // notch on the scroll is always +/- 120, roughly equivalent to pixels.
+  // A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or
+  // ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.
+  deltaMode: 0
+});
+
+const SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface);
+
+/**
+ * This plugin invokes action functions on forms, inputs and buttons if
+ * the form doesn't prevent default.
+ */
+
+function extractEvents$6(dispatchQueue, domEventName, maybeTargetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  if (domEventName !== 'submit') {
+    return;
+  }
+
+  if (!maybeTargetInst || maybeTargetInst.stateNode !== nativeEventTarget) {
+    // If we're inside a parent root that itself is a parent of this root, then
+    // its deepest target won't be the actual form that's being submitted.
+    return;
+  }
+
+  const formInst = maybeTargetInst;
+  const form = nativeEventTarget;
+  let action = getFiberCurrentPropsFromNode(form).action;
+  let submitter = nativeEvent.submitter;
+  let submitterAction;
+
+  if (submitter) {
+    const submitterProps = getFiberCurrentPropsFromNode(submitter);
+    submitterAction = submitterProps ? submitterProps.formAction : submitter.getAttribute('formAction');
+
+    if (submitterAction != null) {
+      // The submitter overrides the form action.
+      action = submitterAction; // If the action is a function, we don't want to pass its name
+      // value to the FormData since it's controlled by the server.
+
+      submitter = null;
+    }
+  }
+
+  if (typeof action !== 'function') {
+    return;
+  }
+
+  const event = new SyntheticEvent('action', 'action', null, nativeEvent, nativeEventTarget);
+
+  function submitForm() {
+    if (nativeEvent.defaultPrevented) {
+      // We let earlier events to prevent the action from submitting.
+      return;
+    } // Prevent native navigation.
+
+
+    event.preventDefault();
+    let formData;
+
+    if (submitter) {
+      // The submitter's value should be included in the FormData.
+      // It should be in the document order in the form.
+      // Since the FormData constructor invokes the formdata event it also
+      // needs to be available before that happens so after construction it's too
+      // late. We use a temporary fake node for the duration of this event.
+      // TODO: FormData takes a second argument that it's the submitter but this
+      // is fairly new so not all browsers support it yet. Switch to that technique
+      // when available.
+      const temp = submitter.ownerDocument.createElement('input');
+      temp.name = submitter.name;
+      temp.value = submitter.value;
+      submitter.parentNode.insertBefore(temp, submitter);
+      formData = new FormData(form);
+      temp.parentNode.removeChild(temp);
+    } else {
+      formData = new FormData(form);
+    }
+
+    const pendingState = {
+      pending: true,
+      data: formData,
+      method: form.method,
+      action: action
+    };
+
+    startHostTransition(formInst, pendingState, action, formData);
+  }
+
+  dispatchQueue.push({
+    event,
+    listeners: [{
+      instance: null,
+      listener: submitForm,
+      currentTarget: form
+    }]
+  });
+}
+function dispatchReplayedFormAction(formInst, form, action, formData) {
+  const pendingState = {
+    pending: true,
+    data: formData,
+    method: form.method,
+    action: action
+  };
+
+  startHostTransition(formInst, pendingState, action, formData);
+}
+
+// has this definition built-in.
+
+let hasScheduledReplayAttempt = false; // The last of each continuous event type. We only need to replay the last one
+// if the last target was dehydrated.
+
+let queuedFocus = null;
+let queuedDrag = null;
+let queuedMouse = null; // For pointer events there can be one latest event per pointerId.
+
+const queuedPointers = new Map();
+const queuedPointerCaptures = new Map(); // We could consider replaying selectionchange and touchmoves too.
+
+const queuedExplicitHydrationTargets = [];
+const discreteReplayableEvents = ['mousedown', 'mouseup', 'touchcancel', 'touchend', 'touchstart', 'auxclick', 'dblclick', 'pointercancel', 'pointerdown', 'pointerup', 'dragend', 'dragstart', 'drop', 'compositionend', 'compositionstart', 'keydown', 'keypress', 'keyup', 'input', 'textInput', // Intentionally camelCase
+'copy', 'cut', 'paste', 'click', 'change', 'contextmenu', 'reset' // 'submit', // stopPropagation blocks the replay mechanism
+];
+function isDiscreteEventThatRequiresHydration(eventType) {
+  return discreteReplayableEvents.indexOf(eventType) > -1;
+}
+
+function createQueuedReplayableEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+  return {
+    blockedOn,
+    domEventName,
+    eventSystemFlags,
+    nativeEvent,
+    targetContainers: [targetContainer]
+  };
+} // Resets the replaying for this type of continuous event to no event.
+
+
+function clearIfContinuousEvent(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case 'focusin':
+    case 'focusout':
+      queuedFocus = null;
+      break;
+
+    case 'dragenter':
+    case 'dragleave':
+      queuedDrag = null;
+      break;
+
+    case 'mouseover':
+    case 'mouseout':
+      queuedMouse = null;
+      break;
+
+    case 'pointerover':
+    case 'pointerout':
+      {
+        const pointerId = nativeEvent.pointerId;
+        queuedPointers.delete(pointerId);
+        break;
+      }
+
+    case 'gotpointercapture':
+    case 'lostpointercapture':
+      {
+        const pointerId = nativeEvent.pointerId;
+        queuedPointerCaptures.delete(pointerId);
+        break;
+      }
+  }
+}
+
+function accumulateOrCreateContinuousQueuedReplayableEvent(existingQueuedEvent, blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+  if (existingQueuedEvent === null || existingQueuedEvent.nativeEvent !== nativeEvent) {
+    const queuedEvent = createQueuedReplayableEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent);
+
+    if (blockedOn !== null) {
+      const fiber = getInstanceFromNode(blockedOn);
+
+      if (fiber !== null) {
+        // Attempt to increase the priority of this target.
+        attemptContinuousHydration(fiber);
+      }
+    }
+
+    return queuedEvent;
+  } // If we have already queued this exact event, then it's because
+  // the different event systems have different DOM event listeners.
+  // We can accumulate the flags, and the targetContainers, and
+  // store a single event to be replayed.
+
+
+  existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
+  const targetContainers = existingQueuedEvent.targetContainers;
+
+  if (targetContainer !== null && targetContainers.indexOf(targetContainer) === -1) {
+    targetContainers.push(targetContainer);
+  }
+
+  return existingQueuedEvent;
+}
+
+function queueIfContinuousEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+  // These set relatedTarget to null because the replayed event will be treated as if we
+  // moved from outside the window (no target) onto the target once it hydrates.
+  // Instead of mutating we could clone the event.
+  switch (domEventName) {
+    case 'focusin':
+      {
+        const focusEvent = nativeEvent;
+        queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(queuedFocus, blockedOn, domEventName, eventSystemFlags, targetContainer, focusEvent);
+        return true;
+      }
+
+    case 'dragenter':
+      {
+        const dragEvent = nativeEvent;
+        queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(queuedDrag, blockedOn, domEventName, eventSystemFlags, targetContainer, dragEvent);
+        return true;
+      }
+
+    case 'mouseover':
+      {
+        const mouseEvent = nativeEvent;
+        queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(queuedMouse, blockedOn, domEventName, eventSystemFlags, targetContainer, mouseEvent);
+        return true;
+      }
+
+    case 'pointerover':
+      {
+        const pointerEvent = nativeEvent;
+        const pointerId = pointerEvent.pointerId;
+        queuedPointers.set(pointerId, accumulateOrCreateContinuousQueuedReplayableEvent(queuedPointers.get(pointerId) || null, blockedOn, domEventName, eventSystemFlags, targetContainer, pointerEvent));
+        return true;
+      }
+
+    case 'gotpointercapture':
+      {
+        const pointerEvent = nativeEvent;
+        const pointerId = pointerEvent.pointerId;
+        queuedPointerCaptures.set(pointerId, accumulateOrCreateContinuousQueuedReplayableEvent(queuedPointerCaptures.get(pointerId) || null, blockedOn, domEventName, eventSystemFlags, targetContainer, pointerEvent));
+        return true;
+      }
+  }
+
+  return false;
+} // Check if this target is unblocked. Returns true if it's unblocked.
+
+function attemptExplicitHydrationTarget(queuedTarget) {
+  // TODO: This function shares a lot of logic with findInstanceBlockingEvent.
+  // Try to unify them. It's a bit tricky since it would require two return
+  // values.
+  const targetInst = getClosestInstanceFromNode(queuedTarget.target);
+
+  if (targetInst !== null) {
+    const nearestMounted = getNearestMountedFiber(targetInst);
+
+    if (nearestMounted !== null) {
+      const tag = nearestMounted.tag;
+
+      if (tag === SuspenseComponent) {
+        const instance = getSuspenseInstanceFromFiber(nearestMounted);
+
+        if (instance !== null) {
+          // We're blocked on hydrating this boundary.
+          // Increase its priority.
+          queuedTarget.blockedOn = instance;
+          runWithPriority(queuedTarget.priority, () => {
+            attemptHydrationAtCurrentPriority(nearestMounted);
+          });
+          return;
+        }
+      } else if (tag === HostRoot) {
+        const root = nearestMounted.stateNode;
+
+        if (isRootDehydrated(root)) {
+          queuedTarget.blockedOn = getContainerFromFiber(nearestMounted); // We don't currently have a way to increase the priority of
+          // a root other than sync.
+
+          return;
+        }
+      }
+    }
+  }
+
+  queuedTarget.blockedOn = null;
+}
+
+function queueExplicitHydrationTarget(target) {
+  // TODO: This will read the priority if it's dispatched by the React
+  // event system but not native events. Should read window.event.type, like
+  // we do for updates (getCurrentEventPriority).
+  const updatePriority = getCurrentUpdatePriority();
+  const queuedTarget = {
+    blockedOn: null,
+    target: target,
+    priority: updatePriority
+  };
+  let i = 0;
+
+  for (; i < queuedExplicitHydrationTargets.length; i++) {
+    // Stop once we hit the first target with lower priority than
+    if (!isHigherEventPriority(updatePriority, queuedExplicitHydrationTargets[i].priority)) {
+      break;
+    }
+  }
+
+  queuedExplicitHydrationTargets.splice(i, 0, queuedTarget);
+
+  if (i === 0) {
+    attemptExplicitHydrationTarget(queuedTarget);
+  }
+}
+
+function attemptReplayContinuousQueuedEvent(queuedEvent) {
+  if (queuedEvent.blockedOn !== null) {
+    return false;
+  }
+
+  const targetContainers = queuedEvent.targetContainers;
+
+  while (targetContainers.length > 0) {
+    const nextBlockedOn = findInstanceBlockingEvent(queuedEvent.nativeEvent);
+
+    if (nextBlockedOn === null) {
+      const nativeEvent = queuedEvent.nativeEvent;
+      const nativeEventClone = new nativeEvent.constructor(nativeEvent.type, nativeEvent);
+      setReplayingEvent(nativeEventClone);
+      nativeEvent.target.dispatchEvent(nativeEventClone);
+      resetReplayingEvent();
+    } else {
+      // We're still blocked. Try again later.
+      const fiber = getInstanceFromNode(nextBlockedOn);
+
+      if (fiber !== null) {
+        attemptContinuousHydration(fiber);
+      }
+
+      queuedEvent.blockedOn = nextBlockedOn;
+      return false;
+    } // This target container was successfully dispatched. Try the next.
+
+
+    targetContainers.shift();
+  }
+
+  return true;
+}
+
+function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
+  if (attemptReplayContinuousQueuedEvent(queuedEvent)) {
+    map.delete(key);
+  }
+}
+
+function replayUnblockedEvents() {
+  hasScheduledReplayAttempt = false; // Replay any continuous events.
+
+  if (queuedFocus !== null && attemptReplayContinuousQueuedEvent(queuedFocus)) {
+    queuedFocus = null;
+  }
+
+  if (queuedDrag !== null && attemptReplayContinuousQueuedEvent(queuedDrag)) {
+    queuedDrag = null;
+  }
+
+  if (queuedMouse !== null && attemptReplayContinuousQueuedEvent(queuedMouse)) {
+    queuedMouse = null;
+  }
+
+  queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
+  queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
+}
+
+function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
+  if (queuedEvent.blockedOn === unblocked) {
+    queuedEvent.blockedOn = null;
+
+    if (!hasScheduledReplayAttempt) {
+      hasScheduledReplayAttempt = true; // Schedule a callback to attempt replaying as many events as are
+      // now unblocked. This first might not actually be unblocked yet.
+      // We could check it early to avoid scheduling an unnecessary callback.
+
+      Scheduler.unstable_scheduleCallback(Scheduler.unstable_NormalPriority, replayUnblockedEvents);
+    }
+  }
+} // [form, submitter or action, formData...]
+
+
+let lastScheduledReplayQueue = null;
+
+function replayUnblockedFormActions(formReplayingQueue) {
+  if (lastScheduledReplayQueue === formReplayingQueue) {
+    lastScheduledReplayQueue = null;
+  }
+
+  for (let i = 0; i < formReplayingQueue.length; i += 3) {
+    const form = formReplayingQueue[i];
+    const submitterOrAction = formReplayingQueue[i + 1];
+    const formData = formReplayingQueue[i + 2];
+
+    if (typeof submitterOrAction !== 'function') {
+      // This action is not hydrated yet. This might be because it's blocked on
+      // a different React instance or higher up our tree.
+      const blockedOn = findInstanceBlockingTarget(submitterOrAction || form);
+
+      if (blockedOn === null) {
+        // We're not blocked but we don't have an action. This must mean that
+        // this is in another React instance. We'll just skip past it.
+        continue;
+      } else {
+        // We're blocked on something in this React instance. We'll retry later.
+        break;
+      }
+    }
+
+    const formInst = getInstanceFromNode(form);
+
+    if (formInst !== null) {
+      // This is part of our instance.
+      // We're ready to replay this. Let's delete it from the queue.
+      formReplayingQueue.splice(i, 3);
+      i -= 3;
+      dispatchReplayedFormAction(formInst, form, submitterOrAction, formData); // Continue without incrementing the index.
+
+      continue;
+    } // This form must've been part of a different React instance.
+    // If we want to preserve ordering between React instances on the same root
+    // we'd need some way for the other instance to ping us when it's done.
+    // We'll just skip this and let the other instance execute it.
+
+  }
+}
+
+function scheduleReplayQueueIfNeeded(formReplayingQueue) {
+  // Schedule a callback to execute any unblocked form actions in.
+  // We only keep track of the last queue which means that if multiple React oscillate
+  // commits, we could schedule more callbacks than necessary but it's not a big deal
+  // and we only really except one instance.
+  if (lastScheduledReplayQueue !== formReplayingQueue) {
+    lastScheduledReplayQueue = formReplayingQueue;
+    Scheduler.unstable_scheduleCallback(Scheduler.unstable_NormalPriority, () => replayUnblockedFormActions(formReplayingQueue));
+  }
+}
+
+function retryIfBlockedOn(unblocked) {
+  if (queuedFocus !== null) {
+    scheduleCallbackIfUnblocked(queuedFocus, unblocked);
+  }
+
+  if (queuedDrag !== null) {
+    scheduleCallbackIfUnblocked(queuedDrag, unblocked);
+  }
+
+  if (queuedMouse !== null) {
+    scheduleCallbackIfUnblocked(queuedMouse, unblocked);
+  }
+
+  const unblock = queuedEvent => scheduleCallbackIfUnblocked(queuedEvent, unblocked);
+
+  queuedPointers.forEach(unblock);
+  queuedPointerCaptures.forEach(unblock);
+
+  for (let i = 0; i < queuedExplicitHydrationTargets.length; i++) {
+    const queuedTarget = queuedExplicitHydrationTargets[i];
+
+    if (queuedTarget.blockedOn === unblocked) {
+      queuedTarget.blockedOn = null;
+    }
+  }
+
+  while (queuedExplicitHydrationTargets.length > 0) {
+    const nextExplicitTarget = queuedExplicitHydrationTargets[0];
+
+    if (nextExplicitTarget.blockedOn !== null) {
+      // We're still blocked.
+      break;
+    } else {
+      attemptExplicitHydrationTarget(nextExplicitTarget);
+
+      if (nextExplicitTarget.blockedOn === null) {
+        // We're unblocked.
+        queuedExplicitHydrationTargets.shift();
+      }
+    }
+  }
+
+  {
+    // Check the document if there are any queued form actions.
+    const root = unblocked.getRootNode();
+    const formReplayingQueue = root.$$reactFormReplay;
+
+    if (formReplayingQueue != null) {
+      for (let i = 0; i < formReplayingQueue.length; i += 3) {
+        const form = formReplayingQueue[i];
+        const submitterOrAction = formReplayingQueue[i + 1];
+        const formProps = getFiberCurrentPropsFromNode(form);
+
+        if (typeof submitterOrAction === 'function') {
+          // This action has already resolved. We're just waiting to dispatch it.
+          if (!formProps) {
+            // This was not part of this React instance. It might have been recently
+            // unblocking us from dispatching our events. So let's make sure we schedule
+            // a retry.
+            scheduleReplayQueueIfNeeded(formReplayingQueue);
+          }
+
+          continue;
+        }
+
+        let target = form;
+
+        if (formProps) {
+          // This form belongs to this React instance but the submitter might
+          // not be done yet.
+          let action = null;
+          const submitter = submitterOrAction;
+
+          if (submitter && submitter.hasAttribute('formAction')) {
+            // The submitter is the one that is responsible for the action.
+            target = submitter;
+            const submitterProps = getFiberCurrentPropsFromNode(submitter);
+
+            if (submitterProps) {
+              // The submitter is part of this instance.
+              action = submitterProps.formAction;
+            } else {
+              const blockedOn = findInstanceBlockingTarget(target);
+
+              if (blockedOn !== null) {
+                // The submitter is not hydrated yet. We'll wait for it.
+                continue;
+              } // The submitter must have been a part of a different React instance.
+              // Except the form isn't. We don't dispatch actions in this scenario.
+
+            }
+          } else {
+            action = formProps.action;
+          }
+
+          if (typeof action === 'function') {
+            formReplayingQueue[i + 1] = action;
+          } else {
+            // Something went wrong so let's just delete this action.
+            formReplayingQueue.splice(i, 3);
+            i -= 3;
+          } // Schedule a replay in case this unblocked something.
+
+
+          scheduleReplayQueueIfNeeded(formReplayingQueue);
+          continue;
+        } // Something above this target is still blocked so we can't continue yet.
+        // We're not sure if this target is actually part of this React instance
+        // yet. It could be a different React as a child but at least some parent is.
+        // We must continue for any further queued actions.
+
+      }
+    }
+  }
+}
+
+const ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig; // TODO: can we stop exporting these?
+
+let _enabled = true; // This is exported in FB builds for use by legacy FB layer infra.
+// We'd like to remove this but it's not clear if this is safe.
+
+function setEnabled(enabled) {
+  _enabled = !!enabled;
+}
+function isEnabled() {
+  return _enabled;
+}
+function createEventListenerWrapperWithPriority(targetContainer, domEventName, eventSystemFlags) {
+  const eventPriority = getEventPriority(domEventName);
+  let listenerWrapper;
+
+  switch (eventPriority) {
+    case DiscreteEventPriority:
+      listenerWrapper = dispatchDiscreteEvent;
+      break;
+
+    case ContinuousEventPriority:
+      listenerWrapper = dispatchContinuousEvent;
+      break;
+
+    case DefaultEventPriority:
+    default:
+      listenerWrapper = dispatchEvent;
+      break;
+  }
+
+  return listenerWrapper.bind(null, domEventName, eventSystemFlags, targetContainer);
+}
+
+function dispatchDiscreteEvent(domEventName, eventSystemFlags, container, nativeEvent) {
+  const previousPriority = getCurrentUpdatePriority();
+  const prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
+
+  try {
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig.transition = prevTransition;
+  }
+}
+
+function dispatchContinuousEvent(domEventName, eventSystemFlags, container, nativeEvent) {
+  const previousPriority = getCurrentUpdatePriority();
+  const prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
+
+  try {
+    setCurrentUpdatePriority(ContinuousEventPriority);
+    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig.transition = prevTransition;
+  }
+}
+
+function dispatchEvent(domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+  if (!_enabled) {
+    return;
+  }
+
+  let blockedOn = findInstanceBlockingEvent(nativeEvent);
+
+  if (blockedOn === null) {
+    dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, return_targetInst, targetContainer);
+    clearIfContinuousEvent(domEventName, nativeEvent);
+    return;
+  }
+
+  if (queueIfContinuousEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent)) {
+    nativeEvent.stopPropagation();
+    return;
+  } // We need to clear only if we didn't queue because
+  // queueing is accumulative.
+
+
+  clearIfContinuousEvent(domEventName, nativeEvent);
+
+  if (eventSystemFlags & IS_CAPTURE_PHASE && isDiscreteEventThatRequiresHydration(domEventName)) {
+    while (blockedOn !== null) {
+      const fiber = getInstanceFromNode(blockedOn);
+
+      if (fiber !== null) {
+        attemptSynchronousHydration(fiber);
+      }
+
+      const nextBlockedOn = findInstanceBlockingEvent(nativeEvent);
+
+      if (nextBlockedOn === null) {
+        dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, return_targetInst, targetContainer);
+      }
+
+      if (nextBlockedOn === blockedOn) {
+        break;
+      }
+
+      blockedOn = nextBlockedOn;
+    }
+
+    if (blockedOn !== null) {
+      nativeEvent.stopPropagation();
+    }
+
+    return;
+  } // 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 findInstanceBlockingEvent(nativeEvent) {
+  const nativeEventTarget = getEventTarget(nativeEvent);
+  return findInstanceBlockingTarget(nativeEventTarget);
+}
+let return_targetInst = null; // Returns a SuspenseInstance or Container if it's blocked.
+// The return_targetInst field above is conceptually part of the return value.
+
+function findInstanceBlockingTarget(targetNode) {
+  // TODO: Warn if _enabled is false.
+  return_targetInst = null;
+  let targetInst = getClosestInstanceFromNode(targetNode);
+
+  if (targetInst !== null) {
+    const nearestMounted = getNearestMountedFiber(targetInst);
+
+    if (nearestMounted === null) {
+      // This tree has been unmounted already. Dispatch without a target.
+      targetInst = null;
+    } else {
+      const tag = nearestMounted.tag;
+
+      if (tag === SuspenseComponent) {
+        const instance = getSuspenseInstanceFromFiber(nearestMounted);
+
+        if (instance !== null) {
+          // Queue the event to be replayed later. Abort dispatching since we
+          // don't want this event dispatched twice through the event system.
+          // TODO: If this is the first discrete event in the queue. Schedule an increased
+          // priority for this boundary.
+          return instance;
+        } // This shouldn't happen, something went wrong but to avoid blocking
+        // the whole system, dispatch the event without a target.
+        // TODO: Warn.
+
+
+        targetInst = null;
+      } else if (tag === HostRoot) {
+        const root = nearestMounted.stateNode;
+
+        if (isRootDehydrated(root)) {
+          // If this happens during a replay something went wrong and it might block
+          // the whole system.
+          return getContainerFromFiber(nearestMounted);
+        }
+
+        targetInst = null;
+      } else if (nearestMounted !== targetInst) {
+        // If we get an event (ex: img onload) before committing that
+        // component's mount, ignore it for now (that is, treat it as if it was an
+        // event on a non-React tree). We might also consider queueing events and
+        // dispatching them after the mount.
+        targetInst = null;
+      }
+    }
+  }
+
+  return_targetInst = targetInst; // We're not blocked on anything.
+
+  return null;
+}
+function getEventPriority(domEventName) {
+  switch (domEventName) {
+    // Used by SimpleEventPlugin:
+    case 'cancel':
+    case 'click':
+    case 'close':
+    case 'contextmenu':
+    case 'copy':
+    case 'cut':
+    case 'auxclick':
+    case 'dblclick':
+    case 'dragend':
+    case 'dragstart':
+    case 'drop':
+    case 'focusin':
+    case 'focusout':
+    case 'input':
+    case 'invalid':
+    case 'keydown':
+    case 'keypress':
+    case 'keyup':
+    case 'mousedown':
+    case 'mouseup':
+    case 'paste':
+    case 'pause':
+    case 'play':
+    case 'pointercancel':
+    case 'pointerdown':
+    case 'pointerup':
+    case 'ratechange':
+    case 'reset':
+    case 'resize':
+    case 'seeked':
+    case 'submit':
+    case 'touchcancel':
+    case 'touchend':
+    case 'touchstart':
+    case 'volumechange': // Used by polyfills: (fall through)
+
+    case 'change':
+    case 'selectionchange':
+    case 'textInput':
+    case 'compositionstart':
+    case 'compositionend':
+    case 'compositionupdate': // Only enableCreateEventHandleAPI: (fall through)
+
+    case 'beforeblur':
+    case 'afterblur': // Not used by React but could be by user code: (fall through)
+
+    case 'beforeinput':
+    case 'blur':
+    case 'fullscreenchange':
+    case 'focus':
+    case 'hashchange':
+    case 'popstate':
+    case 'select':
+    case 'selectstart':
+      return DiscreteEventPriority;
+
+    case 'drag':
+    case 'dragenter':
+    case 'dragexit':
+    case 'dragleave':
+    case 'dragover':
+    case 'mousemove':
+    case 'mouseout':
+    case 'mouseover':
+    case 'pointermove':
+    case 'pointerout':
+    case 'pointerover':
+    case 'scroll':
+    case 'toggle':
+    case 'touchmove':
+    case 'wheel': // Not used by React but could be by user code: (fall through)
+
+    case 'mouseenter':
+    case 'mouseleave':
+    case 'pointerenter':
+    case 'pointerleave':
+      return ContinuousEventPriority;
+
+    case 'message':
+      {
+        // We might be in the Scheduler callback.
+        // Eventually this mechanism will be replaced by a check
+        // of the current priority on the native scheduler.
+        const schedulerPriority = getCurrentPriorityLevel();
+
+        switch (schedulerPriority) {
+          case ImmediatePriority:
+            return DiscreteEventPriority;
+
+          case UserBlockingPriority:
+            return ContinuousEventPriority;
+
+          case NormalPriority$1:
+          case LowPriority:
+            // TODO: Handle LowSchedulerPriority, somehow. Maybe the same lane as hydration.
+            return DefaultEventPriority;
+
+          case IdlePriority:
+            return IdleEventPriority;
+
+          default:
+            return DefaultEventPriority;
+        }
+      }
+
+    default:
+      return DefaultEventPriority;
+  }
+}
+
+function addEventBubbleListener(target, eventType, listener) {
+  target.addEventListener(eventType, listener, false);
+  return listener;
+}
+function addEventCaptureListener(target, eventType, listener) {
+  target.addEventListener(eventType, listener, true);
+  return listener;
+}
+function addEventCaptureListenerWithPassiveFlag(target, eventType, listener, passive) {
+  target.addEventListener(eventType, listener, {
+    capture: true,
+    passive
+  });
+  return listener;
+}
+function addEventBubbleListenerWithPassiveFlag(target, eventType, listener, passive) {
+  target.addEventListener(eventType, listener, {
+    passive
+  });
+  return listener;
+}
+
+/**
+ * These variables store information about text content of a target node,
+ * allowing comparison of content before and after a given event.
+ *
+ * Identify the node where selection currently begins, then observe
+ * both its text content and its current position in the DOM. Since the
+ * browser may natively replace the target node during composition, we can
+ * use its position to find its replacement.
+ *
+ *
+ */
+let root = null;
+let startText = null;
+let fallbackText = null;
+function initialize(nativeEventTarget) {
+  root = nativeEventTarget;
+  startText = getText();
+  return true;
+}
+function reset() {
+  root = null;
+  startText = null;
+  fallbackText = null;
+}
+function getData() {
+  if (fallbackText) {
+    return fallbackText;
+  }
+
+  let start;
+  const startValue = startText;
+  const startLength = startValue.length;
+  let end;
+  const endValue = getText();
+  const endLength = endValue.length;
+
+  for (start = 0; start < startLength; start++) {
+    if (startValue[start] !== endValue[start]) {
+      break;
+    }
+  }
+
+  const minEnd = startLength - start;
+
+  for (end = 1; end <= minEnd; end++) {
+    if (startValue[startLength - end] !== endValue[endLength - end]) {
+      break;
+    }
+  }
+
+  const sliceTail = end > 1 ? 1 - end : undefined;
+  fallbackText = endValue.slice(start, sliceTail);
+  return fallbackText;
+}
+function getText() {
+  if ('value' in root) {
+    return root.value;
+  }
+
+  return root.textContent;
+}
+
+const END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space
+
+const START_KEYCODE = 229;
+const canUseCompositionEvent = canUseDOM && 'CompositionEvent' in window;
+let documentMode = null;
+
+if (canUseDOM && 'documentMode' in document) {
+  documentMode = document.documentMode;
+} // Webkit offers a very useful `textInput` event that can be used to
+// directly represent `beforeInput`. The IE `textinput` event is not as
+// useful, so we don't use it.
+
+
+const canUseTextInputEvent = canUseDOM && 'TextEvent' in window && !documentMode; // In IE9+, we have access to composition events, but the data supplied
+// by the native compositionend event may be incorrect. Japanese ideographic
+// spaces, for instance (\u3000) are not recorded correctly.
+
+const useFallbackCompositionData = canUseDOM && (!canUseCompositionEvent || documentMode && documentMode > 8 && documentMode <= 11);
+const SPACEBAR_CODE = 32;
+const SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);
+
+function registerEvents$3() {
+  registerTwoPhaseEvent('onBeforeInput', ['compositionend', 'keypress', 'textInput', 'paste']);
+  registerTwoPhaseEvent('onCompositionEnd', ['compositionend', 'focusout', 'keydown', 'keypress', 'keyup', 'mousedown']);
+  registerTwoPhaseEvent('onCompositionStart', ['compositionstart', 'focusout', 'keydown', 'keypress', 'keyup', 'mousedown']);
+  registerTwoPhaseEvent('onCompositionUpdate', ['compositionupdate', 'focusout', 'keydown', 'keypress', 'keyup', 'mousedown']);
+} // Track whether we've ever handled a keypress on the space key.
+
+
+let hasSpaceKeypress = false;
+/**
+ * Return whether a native keypress event is assumed to be a command.
+ * This is required because Firefox fires `keypress` events for key commands
+ * (cut, copy, select-all, etc.) even though no character is inserted.
+ */
+
+function isKeypressCommand(nativeEvent) {
+  return (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) && // ctrlKey && altKey is equivalent to AltGr, and is not a command.
+  !(nativeEvent.ctrlKey && nativeEvent.altKey);
+}
+/**
+ * Translate native top level events into event types.
+ */
+
+
+function getCompositionEventType(domEventName) {
+  switch (domEventName) {
+    case 'compositionstart':
+      return 'onCompositionStart';
+
+    case 'compositionend':
+      return 'onCompositionEnd';
+
+    case 'compositionupdate':
+      return 'onCompositionUpdate';
+  }
+}
+/**
+ * Does our fallback best-guess model think this event signifies that
+ * composition has begun?
+ */
+
+
+function isFallbackCompositionStart(domEventName, nativeEvent) {
+  return domEventName === 'keydown' && nativeEvent.keyCode === START_KEYCODE;
+}
+/**
+ * Does our fallback mode think that this event is the end of composition?
+ */
+
+
+function isFallbackCompositionEnd(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case 'keyup':
+      // Command keys insert or clear IME input.
+      return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1;
+
+    case 'keydown':
+      // Expect IME keyCode on each keydown. If we get any other
+      // code we must have exited earlier.
+      return nativeEvent.keyCode !== START_KEYCODE;
+
+    case 'keypress':
+    case 'mousedown':
+    case 'focusout':
+      // Events are not possible without cancelling IME.
+      return true;
+
+    default:
+      return false;
+  }
+}
+/**
+ * Google Input Tools provides composition data via a CustomEvent,
+ * with the `data` property populated in the `detail` object. If this
+ * is available on the event object, use it. If not, this is a plain
+ * composition event and we have nothing special to extract.
+ *
+ * @param {object} nativeEvent
+ * @return {?string}
+ */
+
+
+function getDataFromCustomEvent(nativeEvent) {
+  const detail = nativeEvent.detail;
+
+  if (typeof detail === 'object' && 'data' in detail) {
+    return detail.data;
+  }
+
+  return null;
+}
+/**
+ * Check if a composition event was triggered by Korean IME.
+ * Our fallback mode does not work well with IE's Korean IME,
+ * so just use native composition events when Korean IME is used.
+ * Although CompositionEvent.locale property is deprecated,
+ * it is available in IE, where our fallback mode is enabled.
+ *
+ * @param {object} nativeEvent
+ * @return {boolean}
+ */
+
+
+function isUsingKoreanIME(nativeEvent) {
+  return nativeEvent.locale === 'ko';
+} // Track the current IME composition status, if any.
+
+
+let isComposing = false;
+/**
+ * @return {?object} A SyntheticCompositionEvent.
+ */
+
+function extractCompositionEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget) {
+  let eventType;
+  let fallbackData;
+
+  if (canUseCompositionEvent) {
+    eventType = getCompositionEventType(domEventName);
+  } else if (!isComposing) {
+    if (isFallbackCompositionStart(domEventName, nativeEvent)) {
+      eventType = 'onCompositionStart';
+    }
+  } else if (isFallbackCompositionEnd(domEventName, nativeEvent)) {
+    eventType = 'onCompositionEnd';
+  }
+
+  if (!eventType) {
+    return null;
+  }
+
+  if (useFallbackCompositionData && !isUsingKoreanIME(nativeEvent)) {
+    // The current composition is stored statically and must not be
+    // overwritten while composition continues.
+    if (!isComposing && eventType === 'onCompositionStart') {
+      isComposing = initialize(nativeEventTarget);
+    } else if (eventType === 'onCompositionEnd') {
+      if (isComposing) {
+        fallbackData = getData();
+      }
+    }
+  }
+
+  const listeners = accumulateTwoPhaseListeners(targetInst, eventType);
+
+  if (listeners.length > 0) {
+    const event = new SyntheticCompositionEvent(eventType, domEventName, null, nativeEvent, nativeEventTarget);
+    dispatchQueue.push({
+      event,
+      listeners
+    });
+
+    if (fallbackData) {
+      // Inject data generated from fallback path into the synthetic event.
+      // This matches the property of native CompositionEventInterface.
+      // $FlowFixMe[incompatible-use]
+      event.data = fallbackData;
+    } else {
+      const customData = getDataFromCustomEvent(nativeEvent);
+
+      if (customData !== null) {
+        // $FlowFixMe[incompatible-use]
+        event.data = customData;
+      }
+    }
+  }
+}
+
+function getNativeBeforeInputChars(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case 'compositionend':
+      return getDataFromCustomEvent(nativeEvent);
+
+    case 'keypress':
+      /**
+       * If native `textInput` events are available, our goal is to make
+       * use of them. However, there is a special case: the spacebar key.
+       * In Webkit, preventing default on a spacebar `textInput` event
+       * cancels character insertion, but it *also* causes the browser
+       * to fall back to its default spacebar behavior of scrolling the
+       * page.
+       *
+       * Tracking at:
+       * https://code.google.com/p/chromium/issues/detail?id=355103
+       *
+       * To avoid this issue, use the keypress event as if no `textInput`
+       * event is available.
+       */
+      const which = nativeEvent.which;
+
+      if (which !== SPACEBAR_CODE) {
+        return null;
+      }
+
+      hasSpaceKeypress = true;
+      return SPACEBAR_CHAR;
+
+    case 'textInput':
+      // Record the characters to be added to the DOM.
+      const chars = nativeEvent.data; // If it's a spacebar character, assume that we have already handled
+      // it at the keypress level and bail immediately. Android Chrome
+      // doesn't give us keycodes, so we need to ignore it.
+
+      if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {
+        return null;
+      }
+
+      return chars;
+
+    default:
+      // For other native event types, do nothing.
+      return null;
+  }
+}
+/**
+ * For browsers that do not provide the `textInput` event, extract the
+ * appropriate string to use for SyntheticInputEvent.
+ */
+
+
+function getFallbackBeforeInputChars(domEventName, nativeEvent) {
+  // If we are currently composing (IME) and using a fallback to do so,
+  // try to extract the composed characters from the fallback object.
+  // If composition event is available, we extract a string only at
+  // compositionevent, otherwise extract it at fallback events.
+  if (isComposing) {
+    if (domEventName === 'compositionend' || !canUseCompositionEvent && isFallbackCompositionEnd(domEventName, nativeEvent)) {
+      const chars = getData();
+      reset();
+      isComposing = false;
+      return chars;
+    }
+
+    return null;
+  }
+
+  switch (domEventName) {
+    case 'paste':
+      // If a paste event occurs after a keypress, throw out the input
+      // chars. Paste events should not lead to BeforeInput events.
+      return null;
+
+    case 'keypress':
+      /**
+       * As of v27, Firefox may fire keypress events even when no character
+       * will be inserted. A few possibilities:
+       *
+       * - `which` is `0`. Arrow keys, Esc key, etc.
+       *
+       * - `which` is the pressed key code, but no char is available.
+       *   Ex: 'AltGr + d` in Polish. There is no modified character for
+       *   this key combination and no character is inserted into the
+       *   document, but FF fires the keypress for char code `100` anyway.
+       *   No `input` event will occur.
+       *
+       * - `which` is the pressed key code, but a command combination is
+       *   being used. Ex: `Cmd+C`. No character is inserted, and no
+       *   `input` event will occur.
+       */
+      if (!isKeypressCommand(nativeEvent)) {
+        // IE fires the `keypress` event when a user types an emoji via
+        // Touch keyboard of Windows.  In such a case, the `char` property
+        // holds an emoji character like `\uD83D\uDE0A`.  Because its length
+        // is 2, the property `which` does not represent an emoji correctly.
+        // In such a case, we directly return the `char` property instead of
+        // using `which`.
+        if (nativeEvent.char && nativeEvent.char.length > 1) {
+          return nativeEvent.char;
+        } else if (nativeEvent.which) {
+          return String.fromCharCode(nativeEvent.which);
+        }
+      }
+
+      return null;
+
+    case 'compositionend':
+      return useFallbackCompositionData && !isUsingKoreanIME(nativeEvent) ? null : nativeEvent.data;
+
+    default:
+      return null;
+  }
+}
+/**
+ * Extract a SyntheticInputEvent for `beforeInput`, based on either native
+ * `textInput` or fallback behavior.
+ *
+ * @return {?object} A SyntheticInputEvent.
+ */
+
+
+function extractBeforeInputEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget) {
+  let chars;
+
+  if (canUseTextInputEvent) {
+    chars = getNativeBeforeInputChars(domEventName, nativeEvent);
+  } else {
+    chars = getFallbackBeforeInputChars(domEventName, nativeEvent);
+  } // If no characters are being inserted, no BeforeInput event should
+  // be fired.
+
+
+  if (!chars) {
+    return null;
+  }
+
+  const listeners = accumulateTwoPhaseListeners(targetInst, 'onBeforeInput');
+
+  if (listeners.length > 0) {
+    const event = new SyntheticInputEvent('onBeforeInput', 'beforeinput', null, nativeEvent, nativeEventTarget);
+    dispatchQueue.push({
+      event,
+      listeners
+    }); // $FlowFixMe[incompatible-use]
+
+    event.data = chars;
+  }
+}
+/**
+ * Create an `onBeforeInput` event to match
+ * http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.
+ *
+ * This event plugin is based on the native `textInput` event
+ * available in Chrome, Safari, Opera, and IE. This event fires after
+ * `onKeyPress` and `onCompositionEnd`, but before `onInput`.
+ *
+ * `beforeInput` is spec'd but not implemented in any browsers, and
+ * the `input` event does not provide any useful information about what has
+ * actually been added, contrary to the spec. Thus, `textInput` is the best
+ * available event to identify the characters that have actually been inserted
+ * into the target node.
+ *
+ * This plugin is also responsible for emitting `composition` events, thus
+ * allowing us to share composition fallback code for both `beforeInput` and
+ * `composition` event types.
+ */
+
+
+function extractEvents$5(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  extractCompositionEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+  extractBeforeInputEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+}
+
+/**
+ * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary
+ */
+const supportedInputTypes = {
+  color: true,
+  date: true,
+  datetime: true,
+  'datetime-local': true,
+  email: true,
+  month: true,
+  number: true,
+  password: true,
+  range: true,
+  search: true,
+  tel: true,
+  text: true,
+  time: true,
+  url: true,
+  week: true
+};
+
+function isTextInputElement(elem) {
+  const nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+
+  if (nodeName === 'input') {
+    return !!supportedInputTypes[elem.type];
+  }
+
+  if (nodeName === 'textarea') {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Checks if an event is supported in the current execution environment.
+ *
+ * NOTE: This will not work correctly for non-generic events such as `change`,
+ * `reset`, `load`, `error`, and `select`.
+ *
+ * Borrows from Modernizr.
+ *
+ * @param {string} eventNameSuffix Event name, e.g. "click".
+ * @return {boolean} True if the event is supported.
+ * @internal
+ * @license Modernizr 3.0.0pre (Custom Build) | MIT
+ */
+
+function isEventSupported(eventNameSuffix) {
+  if (!canUseDOM) {
+    return false;
+  }
+
+  const eventName = 'on' + eventNameSuffix;
+  let isSupported = (eventName in document);
+
+  if (!isSupported) {
+    const element = document.createElement('div');
+    element.setAttribute(eventName, 'return;');
+    isSupported = typeof element[eventName] === 'function';
+  }
+
+  return isSupported;
+}
+
+function registerEvents$2() {
+  registerTwoPhaseEvent('onChange', ['change', 'click', 'focusin', 'focusout', 'input', 'keydown', 'keyup', 'selectionchange']);
+}
+
+function createAndAccumulateChangeEvent(dispatchQueue, inst, nativeEvent, target) {
+  // Flag this event loop as needing state restore.
+  enqueueStateRestore(target);
+  const listeners = accumulateTwoPhaseListeners(inst, 'onChange');
+
+  if (listeners.length > 0) {
+    const event = new SyntheticEvent('onChange', 'change', null, nativeEvent, target);
+    dispatchQueue.push({
+      event,
+      listeners
+    });
+  }
+}
+/**
+ * For IE shims
+ */
+
+
+let activeElement$1 = null;
+let activeElementInst$1 = null;
+/**
+ * SECTION: handle `change` event
+ */
+
+function shouldUseChangeEvent(elem) {
+  const nodeName = elem.nodeName && elem.nodeName.toLowerCase();
+  return nodeName === 'select' || nodeName === 'input' && elem.type === 'file';
+}
+
+function manualDispatchChangeEvent(nativeEvent) {
+  const dispatchQueue = [];
+  createAndAccumulateChangeEvent(dispatchQueue, activeElementInst$1, nativeEvent, getEventTarget(nativeEvent)); // If change and propertychange bubbled, we'd just bind to it like all the
+  // other events and have it go through ReactBrowserEventEmitter. Since it
+  // doesn't, we manually listen for the events and so we have to enqueue and
+  // process the abstract event manually.
+  //
+  // Batching is necessary here in order to ensure that all event handlers run
+  // before the next rerender (including event handlers attached to ancestor
+  // elements instead of directly on the input). Without this, controlled
+  // components don't work properly in conjunction with event bubbling because
+  // the component is rerendered and the value reverted before all the event
+  // handlers can run. See https://github.com/facebook/react/issues/708.
+
+  batchedUpdates(runEventInBatch, dispatchQueue);
+}
+
+function runEventInBatch(dispatchQueue) {
+  processDispatchQueue(dispatchQueue, 0);
+}
+
+function getInstIfValueChanged(targetInst) {
+  const targetNode = getNodeFromInstance(targetInst);
+
+  if (updateValueIfChanged(targetNode)) {
+    return targetInst;
+  }
+}
+
+function getTargetInstForChangeEvent(domEventName, targetInst) {
+  if (domEventName === 'change') {
+    return targetInst;
+  }
+}
+/**
+ * SECTION: handle `input` event
+ */
+
+
+let isInputEventSupported = false;
+
+if (canUseDOM) {
+  // IE9 claims to support the input event but fails to trigger it when
+  // deleting text, so we ignore its input events.
+  isInputEventSupported = isEventSupported('input') && (!document.documentMode || document.documentMode > 9);
+}
+/**
+ * (For IE <=9) Starts tracking propertychange events on the passed-in element
+ * and override the value property so that we can distinguish user events from
+ * value changes in JS.
+ */
+
+
+function startWatchingForValueChange(target, targetInst) {
+  activeElement$1 = target;
+  activeElementInst$1 = targetInst;
+  activeElement$1.attachEvent('onpropertychange', handlePropertyChange);
+}
+/**
+ * (For IE <=9) Removes the event listeners from the currently-tracked element,
+ * if any exists.
+ */
+
+
+function stopWatchingForValueChange() {
+  if (!activeElement$1) {
+    return;
+  }
+
+  activeElement$1.detachEvent('onpropertychange', handlePropertyChange);
+  activeElement$1 = null;
+  activeElementInst$1 = null;
+}
+/**
+ * (For IE <=9) Handles a propertychange event, sending a `change` event if
+ * the value of the active element has changed.
+ */
+// $FlowFixMe[missing-local-annot]
+
+
+function handlePropertyChange(nativeEvent) {
+  if (nativeEvent.propertyName !== 'value') {
+    return;
+  }
+
+  if (getInstIfValueChanged(activeElementInst$1)) {
+    manualDispatchChangeEvent(nativeEvent);
+  }
+}
+
+function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
+  if (domEventName === 'focusin') {
+    // In IE9, propertychange fires for most input events but is buggy and
+    // doesn't fire when text is deleted, but conveniently, selectionchange
+    // appears to fire in all of the remaining cases so we catch those and
+    // forward the event if the value has changed
+    // In either case, we don't want to call the event handler if the value
+    // is changed from JS so we redefine a setter for `.value` that updates
+    // our activeElementValue variable, allowing us to ignore those changes
+    //
+    // stopWatching() should be a noop here but we call it just in case we
+    // missed a blur event somehow.
+    stopWatchingForValueChange();
+    startWatchingForValueChange(target, targetInst);
+  } else if (domEventName === 'focusout') {
+    stopWatchingForValueChange();
+  }
+} // For IE8 and IE9.
+
+
+function getTargetInstForInputEventPolyfill(domEventName, targetInst) {
+  if (domEventName === 'selectionchange' || domEventName === 'keyup' || domEventName === 'keydown') {
+    // On the selectionchange event, the target is just document which isn't
+    // helpful for us so just check activeElement instead.
+    //
+    // 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire
+    // propertychange on the first input event after setting `value` from a
+    // script and fires only keydown, keypress, keyup. Catching keyup usually
+    // gets it and catching keydown lets us fire an event for the first
+    // keystroke if user does a key repeat (it'll be a little delayed: right
+    // before the second keystroke). Other input methods (e.g., paste) seem to
+    // fire selectionchange normally.
+    return getInstIfValueChanged(activeElementInst$1);
+  }
+}
+/**
+ * SECTION: handle `click` event
+ */
+
+
+function shouldUseClickEvent(elem) {
+  // Use the `click` event to detect changes to checkbox and radio inputs.
+  // This approach works across all browsers, whereas `change` does not fire
+  // until `blur` in IE8.
+  const nodeName = elem.nodeName;
+  return nodeName && nodeName.toLowerCase() === 'input' && (elem.type === 'checkbox' || elem.type === 'radio');
+}
+
+function getTargetInstForClickEvent(domEventName, targetInst) {
+  if (domEventName === 'click') {
+    return getInstIfValueChanged(targetInst);
+  }
+}
+
+function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
+  if (domEventName === 'input' || domEventName === 'change') {
+    return getInstIfValueChanged(targetInst);
+  }
+}
+
+function handleControlledInputBlur(node, props) {
+  if (node.type !== 'number') {
+    return;
+  }
+
+  {
+    const isControlled = props.value != null;
+
+    if (isControlled) {
+      // If controlled, assign the value attribute to the current value on blur
+      setDefaultValue(node, 'number', node.value);
+    }
+  }
+}
+/**
+ * This plugin creates an `onChange` event that normalizes change events
+ * across form elements. This event fires at a time when it's possible to
+ * change the element's value without seeing a flicker.
+ *
+ * Supported elements are:
+ * - input (see `isTextInputElement`)
+ * - textarea
+ * - select
+ */
+
+
+function extractEvents$4(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  const targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
+  let getTargetInstFunc, handleEventFunc;
+
+  if (shouldUseChangeEvent(targetNode)) {
+    getTargetInstFunc = getTargetInstForChangeEvent;
+  } else if (isTextInputElement(targetNode)) {
+    if (isInputEventSupported) {
+      getTargetInstFunc = getTargetInstForInputOrChangeEvent;
+    } else {
+      getTargetInstFunc = getTargetInstForInputEventPolyfill;
+      handleEventFunc = handleEventsForInputEventPolyfill;
+    }
+  } else if (shouldUseClickEvent(targetNode)) {
+    getTargetInstFunc = getTargetInstForClickEvent;
+  } else if (targetInst && isCustomElement(targetInst.elementType)) {
+    getTargetInstFunc = getTargetInstForChangeEvent;
+  }
+
+  if (getTargetInstFunc) {
+    const inst = getTargetInstFunc(domEventName, targetInst);
+
+    if (inst) {
+      createAndAccumulateChangeEvent(dispatchQueue, inst, nativeEvent, nativeEventTarget);
+      return;
+    }
+  }
+
+  if (handleEventFunc) {
+    handleEventFunc(domEventName, targetNode, targetInst);
+  } // When blurring, set the value attribute for number inputs
+
+
+  if (domEventName === 'focusout' && targetInst) {
+    // These props aren't necessarily the most current but we warn for changing
+    // between controlled and uncontrolled, so it doesn't matter and the previous
+    // code was also broken for changes.
+    const props = targetInst.memoizedProps;
+    handleControlledInputBlur(targetNode, props);
+  }
+}
+
+function registerEvents$1() {
+  registerDirectEvent('onMouseEnter', ['mouseout', 'mouseover']);
+  registerDirectEvent('onMouseLeave', ['mouseout', 'mouseover']);
+  registerDirectEvent('onPointerEnter', ['pointerout', 'pointerover']);
+  registerDirectEvent('onPointerLeave', ['pointerout', 'pointerover']);
+}
+/**
+ * For almost every interaction we care about, there will be both a top-level
+ * `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that
+ * we do not extract duplicate events. However, moving the mouse into the
+ * browser from outside will not fire a `mouseout` event. In this case, we use
+ * the `mouseover` top-level event.
+ */
+
+
+function extractEvents$3(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  const isOverEvent = domEventName === 'mouseover' || domEventName === 'pointerover';
+  const isOutEvent = domEventName === 'mouseout' || domEventName === 'pointerout';
+
+  if (isOverEvent && !isReplayingEvent(nativeEvent)) {
+    // If this is an over event with a target, we might have already dispatched
+    // the event in the out event of the other target. If this is replayed,
+    // then it's because we couldn't dispatch against this target previously
+    // so we have to do it now instead.
+    const related = nativeEvent.relatedTarget || nativeEvent.fromElement;
+
+    if (related) {
+      // If the related node is managed by React, we can assume that we have
+      // already dispatched the corresponding events during its mouseout.
+      if (getClosestInstanceFromNode(related) || isContainerMarkedAsRoot(related)) {
+        return;
+      }
+    }
+  }
+
+  if (!isOutEvent && !isOverEvent) {
+    // Must not be a mouse or pointer in or out - ignoring.
+    return;
+  }
+
+  let win; // TODO: why is this nullable in the types but we read from it?
+
+  if (nativeEventTarget.window === nativeEventTarget) {
+    // `nativeEventTarget` is probably a window object.
+    win = nativeEventTarget;
+  } else {
+    // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.
+    const doc = nativeEventTarget.ownerDocument;
+
+    if (doc) {
+      win = doc.defaultView || doc.parentWindow;
+    } else {
+      win = window;
+    }
+  }
+
+  let from;
+  let to;
+
+  if (isOutEvent) {
+    const related = nativeEvent.relatedTarget || nativeEvent.toElement;
+    from = targetInst;
+    to = related ? getClosestInstanceFromNode(related) : null;
+
+    if (to !== null) {
+      const nearestMounted = getNearestMountedFiber(to);
+      const tag = to.tag;
+
+      if (to !== nearestMounted || tag !== HostComponent && (tag !== HostSingleton) && tag !== HostText) {
+        to = null;
+      }
+    }
+  } else {
+    // Moving to a node from outside the window.
+    from = null;
+    to = targetInst;
+  }
+
+  if (from === to) {
+    // Nothing pertains to our managed components.
+    return;
+  }
+
+  let SyntheticEventCtor = SyntheticMouseEvent;
+  let leaveEventType = 'onMouseLeave';
+  let enterEventType = 'onMouseEnter';
+  let eventTypePrefix = 'mouse';
+
+  if (domEventName === 'pointerout' || domEventName === 'pointerover') {
+    SyntheticEventCtor = SyntheticPointerEvent;
+    leaveEventType = 'onPointerLeave';
+    enterEventType = 'onPointerEnter';
+    eventTypePrefix = 'pointer';
+  }
+
+  const fromNode = from == null ? win : getNodeFromInstance(from);
+  const toNode = to == null ? win : getNodeFromInstance(to);
+  const leave = new SyntheticEventCtor(leaveEventType, eventTypePrefix + 'leave', from, nativeEvent, nativeEventTarget);
+  leave.target = fromNode;
+  leave.relatedTarget = toNode;
+  let enter = null; // We should only process this nativeEvent if we are processing
+  // the first ancestor. Next time, we will ignore the event.
+
+  const nativeTargetInst = getClosestInstanceFromNode(nativeEventTarget);
+
+  if (nativeTargetInst === targetInst) {
+    const enterEvent = new SyntheticEventCtor(enterEventType, eventTypePrefix + 'enter', to, nativeEvent, nativeEventTarget);
+    enterEvent.target = toNode;
+    enterEvent.relatedTarget = fromNode;
+    enter = enterEvent;
+  }
+
+  accumulateEnterLeaveTwoPhaseListeners(dispatchQueue, leave, enter, from, to);
+}
+
+/**
+ * Given any node return the first leaf node without children.
+ *
+ * @param {DOMElement|DOMTextNode} node
+ * @return {DOMElement|DOMTextNode}
+ */
+
+function getLeafNode(node) {
+  while (node && node.firstChild) {
+    node = node.firstChild;
+  }
+
+  return node;
+}
+/**
+ * Get the next sibling within a container. This will walk up the
+ * DOM if a node's siblings have been exhausted.
+ *
+ * @param {DOMElement|DOMTextNode} node
+ * @return {?DOMElement|DOMTextNode}
+ */
+
+
+function getSiblingNode(node) {
+  while (node) {
+    if (node.nextSibling) {
+      return node.nextSibling;
+    }
+
+    node = node.parentNode;
+  }
+}
+/**
+ * Get object describing the nodes which contain characters at offset.
+ *
+ * @param {DOMElement|DOMTextNode} root
+ * @param {number} offset
+ * @return {?object}
+ */
+
+
+function getNodeForCharacterOffset(root, offset) {
+  let node = getLeafNode(root);
+  let nodeStart = 0;
+  let nodeEnd = 0;
+
+  while (node) {
+    if (node.nodeType === TEXT_NODE) {
+      nodeEnd = nodeStart + node.textContent.length;
+
+      if (nodeStart <= offset && nodeEnd >= offset) {
+        return {
+          node: node,
+          offset: offset - nodeStart
+        };
+      }
+
+      nodeStart = nodeEnd;
+    }
+
+    node = getLeafNode(getSiblingNode(node));
+  }
+}
+
+/**
+ * @param {DOMElement} outerNode
+ * @return {?object}
+ */
+
+function getOffsets(outerNode) {
+  const ownerDocument = outerNode.ownerDocument;
+  const win = ownerDocument && ownerDocument.defaultView || window;
+  const selection = win.getSelection && win.getSelection();
+
+  if (!selection || selection.rangeCount === 0) {
+    return null;
+  }
+
+  const anchorNode = selection.anchorNode,
+        anchorOffset = selection.anchorOffset,
+        focusNode = selection.focusNode,
+        focusOffset = selection.focusOffset; // In Firefox, anchorNode and focusNode can be "anonymous divs", e.g. the
+  // up/down buttons on an <input type="number">. Anonymous divs do not seem to
+  // expose properties, triggering a "Permission denied error" if any of its
+  // properties are accessed. The only seemingly possible way to avoid erroring
+  // is to access a property that typically works for non-anonymous divs and
+  // catch any error that may otherwise arise. See
+  // https://bugzilla.mozilla.org/show_bug.cgi?id=208427
+
+  try {
+    /* eslint-disable ft-flow/no-unused-expressions */
+    anchorNode.nodeType;
+    focusNode.nodeType;
+    /* eslint-enable ft-flow/no-unused-expressions */
+  } catch (e) {
+    return null;
+  }
+
+  return getModernOffsetsFromPoints(outerNode, anchorNode, anchorOffset, focusNode, focusOffset);
+}
+/**
+ * Returns {start, end} where `start` is the character/codepoint index of
+ * (anchorNode, anchorOffset) within the textContent of `outerNode`, and
+ * `end` is the index of (focusNode, focusOffset).
+ *
+ * Returns null if you pass in garbage input but we should probably just crash.
+ *
+ * Exported only for testing.
+ */
+
+function getModernOffsetsFromPoints(outerNode, anchorNode, anchorOffset, focusNode, focusOffset) {
+  let length = 0;
+  let start = -1;
+  let end = -1;
+  let indexWithinAnchor = 0;
+  let indexWithinFocus = 0;
+  let node = outerNode;
+  let parentNode = null;
+
+  outer: while (true) {
+    let next = null;
+
+    while (true) {
+      if (node === anchorNode && (anchorOffset === 0 || node.nodeType === TEXT_NODE)) {
+        start = length + anchorOffset;
+      }
+
+      if (node === focusNode && (focusOffset === 0 || node.nodeType === TEXT_NODE)) {
+        end = length + focusOffset;
+      }
+
+      if (node.nodeType === TEXT_NODE) {
+        length += node.nodeValue.length;
+      }
+
+      if ((next = node.firstChild) === null) {
+        break;
+      } // Moving from `node` to its first child `next`.
+
+
+      parentNode = node;
+      node = next;
+    }
+
+    while (true) {
+      if (node === outerNode) {
+        // If `outerNode` has children, this is always the second time visiting
+        // it. If it has no children, this is still the first loop, and the only
+        // valid selection is anchorNode and focusNode both equal to this node
+        // and both offsets 0, in which case we will have handled above.
+        break outer;
+      }
+
+      if (parentNode === anchorNode && ++indexWithinAnchor === anchorOffset) {
+        start = length;
+      }
+
+      if (parentNode === focusNode && ++indexWithinFocus === focusOffset) {
+        end = length;
+      }
+
+      if ((next = node.nextSibling) !== null) {
+        break;
+      }
+
+      node = parentNode;
+      parentNode = node.parentNode;
+    } // Moving from `node` to its next sibling `next`.
+
+
+    node = next;
+  }
+
+  if (start === -1 || end === -1) {
+    // This should never happen. (Would happen if the anchor/focus nodes aren't
+    // actually inside the passed-in node.)
+    return null;
+  }
+
+  return {
+    start: start,
+    end: end
+  };
+}
+/**
+ * In modern non-IE browsers, we can support both forward and backward
+ * selections.
+ *
+ * Note: IE10+ supports the Selection object, but it does not support
+ * the `extend` method, which means that even in modern IE, it's not possible
+ * to programmatically create a backward selection. Thus, for all IE
+ * versions, we use the old IE API to create our selections.
+ *
+ * @param {DOMElement|DOMTextNode} node
+ * @param {object} offsets
+ */
+
+function setOffsets(node, offsets) {
+  const doc = node.ownerDocument || document;
+  const win = doc && doc.defaultView || window; // Edge fails with "Object expected" in some scenarios.
+  // (For instance: TinyMCE editor used in a list component that supports pasting to add more,
+  // fails when pasting 100+ items)
+
+  if (!win.getSelection) {
+    return;
+  }
+
+  const selection = win.getSelection();
+  const length = node.textContent.length;
+  let start = Math.min(offsets.start, length);
+  let end = offsets.end === undefined ? start : Math.min(offsets.end, length); // IE 11 uses modern selection, but doesn't support the extend method.
+  // Flip backward selections, so we can set with a single range.
+
+  if (!selection.extend && start > end) {
+    const temp = end;
+    end = start;
+    start = temp;
+  }
+
+  const startMarker = getNodeForCharacterOffset(node, start);
+  const endMarker = getNodeForCharacterOffset(node, end);
+
+  if (startMarker && endMarker) {
+    if (selection.rangeCount === 1 && selection.anchorNode === startMarker.node && selection.anchorOffset === startMarker.offset && selection.focusNode === endMarker.node && selection.focusOffset === endMarker.offset) {
+      return;
+    }
+
+    const range = doc.createRange();
+    range.setStart(startMarker.node, startMarker.offset);
+    selection.removeAllRanges();
+
+    if (start > end) {
+      selection.addRange(range);
+      selection.extend(endMarker.node, endMarker.offset);
+    } else {
+      range.setEnd(endMarker.node, endMarker.offset);
+      selection.addRange(range);
+    }
+  }
+}
+
+function isTextNode(node) {
+  return node && node.nodeType === TEXT_NODE;
+}
+
+function containsNode(outerNode, innerNode) {
+  if (!outerNode || !innerNode) {
+    return false;
+  } else if (outerNode === innerNode) {
+    return true;
+  } else if (isTextNode(outerNode)) {
+    return false;
+  } else if (isTextNode(innerNode)) {
+    return containsNode(outerNode, innerNode.parentNode);
+  } else if ('contains' in outerNode) {
+    return outerNode.contains(innerNode);
+  } else if (outerNode.compareDocumentPosition) {
+    return !!(outerNode.compareDocumentPosition(innerNode) & 16);
+  } else {
+    return false;
+  }
+}
+
+function isInDocument(node) {
+  return node && node.ownerDocument && containsNode(node.ownerDocument.documentElement, node);
+}
+
+function isSameOriginFrame(iframe) {
+  try {
+    // Accessing the contentDocument of a HTMLIframeElement can cause the browser
+    // to throw, e.g. if it has a cross-origin src attribute.
+    // Safari will show an error in the console when the access results in "Blocked a frame with origin". e.g:
+    // iframe.contentDocument.defaultView;
+    // A safety way is to access one of the cross origin properties: Window or Location
+    // Which might result in "SecurityError" DOM Exception and it is compatible to Safari.
+    // https://html.spec.whatwg.org/multipage/browsers.html#integration-with-idl
+    return typeof iframe.contentWindow.location.href === 'string';
+  } catch (err) {
+    return false;
+  }
+}
+
+function getActiveElementDeep() {
+  let win = window;
+  let element = getActiveElement();
+
+  while (element instanceof win.HTMLIFrameElement) {
+    if (isSameOriginFrame(element)) {
+      win = element.contentWindow;
+    } else {
+      return element;
+    }
+
+    element = getActiveElement(win.document);
+  }
+
+  return element;
+}
+/**
+ * @ReactInputSelection: React input selection module. Based on Selection.js,
+ * but modified to be suitable for react and has a couple of bug fixes (doesn't
+ * assume buttons have range selections allowed).
+ * Input selection module for React.
+ */
+
+/**
+ * @hasSelectionCapabilities: we get the element types that support selection
+ * from https://html.spec.whatwg.org/#do-not-apply, looking at `selectionStart`
+ * and `selectionEnd` rows.
+ */
+
+
+function hasSelectionCapabilities(elem) {
+  const nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+  return nodeName && (nodeName === 'input' && (elem.type === 'text' || elem.type === 'search' || elem.type === 'tel' || elem.type === 'url' || elem.type === 'password') || nodeName === 'textarea' || elem.contentEditable === 'true');
+}
+function getSelectionInformation() {
+  const focusedElem = getActiveElementDeep();
+  return {
+    focusedElem: focusedElem,
+    selectionRange: hasSelectionCapabilities(focusedElem) ? getSelection$1(focusedElem) : null
+  };
+}
+/**
+ * @restoreSelection: If any selection information was potentially lost,
+ * restore it. This is useful when performing operations that could remove dom
+ * nodes and place them back in, resulting in focus being lost.
+ */
+
+function restoreSelection(priorSelectionInformation) {
+  const curFocusedElem = getActiveElementDeep();
+  const priorFocusedElem = priorSelectionInformation.focusedElem;
+  const priorSelectionRange = priorSelectionInformation.selectionRange;
+
+  if (curFocusedElem !== priorFocusedElem && isInDocument(priorFocusedElem)) {
+    if (priorSelectionRange !== null && hasSelectionCapabilities(priorFocusedElem)) {
+      setSelection(priorFocusedElem, priorSelectionRange);
+    } // Focusing a node can change the scroll position, which is undesirable
+
+
+    const ancestors = [];
+    let ancestor = priorFocusedElem;
+
+    while (ancestor = ancestor.parentNode) {
+      if (ancestor.nodeType === ELEMENT_NODE) {
+        ancestors.push({
+          element: ancestor,
+          left: ancestor.scrollLeft,
+          top: ancestor.scrollTop
+        });
+      }
+    }
+
+    if (typeof priorFocusedElem.focus === 'function') {
+      priorFocusedElem.focus();
+    }
+
+    for (let i = 0; i < ancestors.length; i++) {
+      const info = ancestors[i];
+      info.element.scrollLeft = info.left;
+      info.element.scrollTop = info.top;
+    }
+  }
+}
+/**
+ * @getSelection: Gets the selection bounds of a focused textarea, input or
+ * contentEditable node.
+ * -@input: Look up selection bounds of this input
+ * -@return {start: selectionStart, end: selectionEnd}
+ */
+
+function getSelection$1(input) {
+  let selection;
+
+  if ('selectionStart' in input) {
+    // Modern browser with input or textarea.
+    selection = {
+      start: input.selectionStart,
+      end: input.selectionEnd
+    };
+  } else {
+    // Content editable or old IE textarea.
+    selection = getOffsets(input);
+  }
+
+  return selection || {
+    start: 0,
+    end: 0
+  };
+}
+/**
+ * @setSelection: Sets the selection bounds of a textarea or input and focuses
+ * the input.
+ * -@input     Set selection bounds of this input or textarea
+ * -@offsets   Object of same form that is returned from get*
+ */
+
+function setSelection(input, offsets) {
+  const start = offsets.start;
+  let end = offsets.end;
+
+  if (end === undefined) {
+    end = start;
+  }
+
+  if ('selectionStart' in input) {
+    input.selectionStart = start;
+    input.selectionEnd = Math.min(end, input.value.length);
+  } else {
+    setOffsets(input, offsets);
+  }
+}
+
+const skipSelectionChangeEvent = canUseDOM && 'documentMode' in document && document.documentMode <= 11;
+
+function registerEvents() {
+  registerTwoPhaseEvent('onSelect', ['focusout', 'contextmenu', 'dragend', 'focusin', 'keydown', 'keyup', 'mousedown', 'mouseup', 'selectionchange']);
+}
+
+let activeElement = null;
+let activeElementInst = null;
+let lastSelection = null;
+let mouseDown = false;
+/**
+ * Get an object which is a unique representation of the current selection.
+ *
+ * The return value will not be consistent across nodes or browsers, but
+ * two identical selections on the same node will return identical objects.
+ */
+
+function getSelection(node) {
+  if ('selectionStart' in node && hasSelectionCapabilities(node)) {
+    return {
+      start: node.selectionStart,
+      end: node.selectionEnd
+    };
+  } else {
+    const win = node.ownerDocument && node.ownerDocument.defaultView || window;
+    const selection = win.getSelection();
+    return {
+      anchorNode: selection.anchorNode,
+      anchorOffset: selection.anchorOffset,
+      focusNode: selection.focusNode,
+      focusOffset: selection.focusOffset
+    };
+  }
+}
+/**
+ * Get document associated with the event target.
+ */
+
+
+function getEventTargetDocument(eventTarget) {
+  return eventTarget.window === eventTarget ? eventTarget.document : eventTarget.nodeType === DOCUMENT_NODE ? eventTarget : eventTarget.ownerDocument;
+}
+/**
+ * Poll selection to see whether it's changed.
+ *
+ * @param {object} nativeEvent
+ * @param {object} nativeEventTarget
+ * @return {?SyntheticEvent}
+ */
+
+
+function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
+  // Ensure we have the right element, and that the user is not dragging a
+  // selection (this matches native `select` event behavior). In HTML5, select
+  // fires only on input and textarea thus if there's no focused element we
+  // won't dispatch.
+  const doc = getEventTargetDocument(nativeEventTarget);
+
+  if (mouseDown || activeElement == null || activeElement !== getActiveElement(doc)) {
+    return;
+  } // Only fire when selection has actually changed.
+
+
+  const currentSelection = getSelection(activeElement);
+
+  if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {
+    lastSelection = currentSelection;
+    const listeners = accumulateTwoPhaseListeners(activeElementInst, 'onSelect');
+
+    if (listeners.length > 0) {
+      const event = new SyntheticEvent('onSelect', 'select', null, nativeEvent, nativeEventTarget);
+      dispatchQueue.push({
+        event,
+        listeners
+      });
+      event.target = activeElement;
+    }
+  }
+}
+/**
+ * This plugin creates an `onSelect` event that normalizes select events
+ * across form elements.
+ *
+ * Supported elements are:
+ * - input (see `isTextInputElement`)
+ * - textarea
+ * - contentEditable
+ *
+ * This differs from native browser implementations in the following ways:
+ * - Fires on contentEditable fields as well as inputs.
+ * - Fires for collapsed selection.
+ * - Fires after user input.
+ */
+
+
+function extractEvents$2(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  const targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
+
+  switch (domEventName) {
+    // Track the input node that has focus.
+    case 'focusin':
+      if (isTextInputElement(targetNode) || targetNode.contentEditable === 'true') {
+        activeElement = targetNode;
+        activeElementInst = targetInst;
+        lastSelection = null;
+      }
+
+      break;
+
+    case 'focusout':
+      activeElement = null;
+      activeElementInst = null;
+      lastSelection = null;
+      break;
+    // Don't fire the event while the user is dragging. This matches the
+    // semantics of the native select event.
+
+    case 'mousedown':
+      mouseDown = true;
+      break;
+
+    case 'contextmenu':
+    case 'mouseup':
+    case 'dragend':
+      mouseDown = false;
+      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+      break;
+    // Chrome and IE fire non-standard event when selection is changed (and
+    // sometimes when it hasn't). IE's event fires out of order with respect
+    // to key and input events on deletion, so we discard it.
+    //
+    // Firefox doesn't support selectionchange, so check selection status
+    // after each key entry. The selection changes after keydown and before
+    // keyup, but we check on keydown as well in the case of holding down a
+    // key, when multiple keydown events are fired but only one keyup is.
+    // This is also our approach for IE handling, for the reason above.
+
+    case 'selectionchange':
+      if (skipSelectionChangeEvent) {
+        break;
+      }
+
+    // falls through
+
+    case 'keydown':
+    case 'keyup':
+      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+  }
+}
+
+/**
+ * Generate a mapping of standard vendor prefixes using the defined style property and event name.
+ *
+ * @param {string} styleProp
+ * @param {string} eventName
+ * @returns {object}
+ */
+
+function makePrefixMap(styleProp, eventName) {
+  const prefixes = {};
+  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
+  prefixes['Webkit' + styleProp] = 'webkit' + eventName;
+  prefixes['Moz' + styleProp] = 'moz' + eventName;
+  return prefixes;
+}
+/**
+ * A list of event names to a configurable list of vendor prefixes.
+ */
+
+
+const vendorPrefixes = {
+  animationend: makePrefixMap('Animation', 'AnimationEnd'),
+  animationiteration: makePrefixMap('Animation', 'AnimationIteration'),
+  animationstart: makePrefixMap('Animation', 'AnimationStart'),
+  transitionend: makePrefixMap('Transition', 'TransitionEnd')
+};
+/**
+ * Event names that have already been detected and prefixed (if applicable).
+ */
+
+const prefixedEventNames = {};
+/**
+ * Element to check for prefixes on.
+ */
+
+let style = {};
+/**
+ * Bootstrap if a DOM exists.
+ */
+
+if (canUseDOM) {
+  style = document.createElement('div').style; // On some platforms, in particular some releases of Android 4.x,
+  // the un-prefixed "animation" and "transition" properties are defined on the
+  // style object but the events that fire will still be prefixed, so we need
+  // to check if the un-prefixed events are usable, and if not remove them from the map.
+
+  if (!('AnimationEvent' in window)) {
+    delete vendorPrefixes.animationend.animation;
+    delete vendorPrefixes.animationiteration.animation;
+    delete vendorPrefixes.animationstart.animation;
+  } // Same as above
+
+
+  if (!('TransitionEvent' in window)) {
+    delete vendorPrefixes.transitionend.transition;
+  }
+}
+/**
+ * Attempts to determine the correct vendor prefixed event name.
+ *
+ * @param {string} eventName
+ * @returns {string}
+ */
+
+
+function getVendorPrefixedEventName(eventName) {
+  if (prefixedEventNames[eventName]) {
+    return prefixedEventNames[eventName];
+  } else if (!vendorPrefixes[eventName]) {
+    return eventName;
+  }
+
+  const prefixMap = vendorPrefixes[eventName];
+
+  for (const styleProp in prefixMap) {
+    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {
+      return prefixedEventNames[eventName] = prefixMap[styleProp];
+    }
+  }
+
+  return eventName;
+}
+
+const ANIMATION_END = getVendorPrefixedEventName('animationend');
+const ANIMATION_ITERATION = getVendorPrefixedEventName('animationiteration');
+const ANIMATION_START = getVendorPrefixedEventName('animationstart');
+const TRANSITION_END = getVendorPrefixedEventName('transitionend');
+
+const topLevelEventsToReactNames = new Map(); // NOTE: Capitalization is important in this list!
+//
+// E.g. it needs "pointerDown", not "pointerdown".
+// This is because we derive both React name ("onPointerDown")
+// and DOM name ("pointerdown") from the same list.
+//
+// Exceptions that don't match this convention are listed separately.
+//
+// prettier-ignore
+
+const simpleEventPluginEvents = ['abort', 'auxClick', 'cancel', 'canPlay', 'canPlayThrough', 'click', 'close', 'contextMenu', 'copy', 'cut', 'drag', 'dragEnd', 'dragEnter', 'dragExit', 'dragLeave', 'dragOver', 'dragStart', 'drop', 'durationChange', 'emptied', 'encrypted', 'ended', 'error', 'gotPointerCapture', 'input', 'invalid', 'keyDown', 'keyPress', 'keyUp', 'load', 'loadedData', 'loadedMetadata', 'loadStart', 'lostPointerCapture', 'mouseDown', 'mouseMove', 'mouseOut', 'mouseOver', 'mouseUp', 'paste', 'pause', 'play', 'playing', 'pointerCancel', 'pointerDown', 'pointerMove', 'pointerOut', 'pointerOver', 'pointerUp', 'progress', 'rateChange', 'reset', 'resize', 'seeked', 'seeking', 'stalled', 'submit', 'suspend', 'timeUpdate', 'touchCancel', 'touchEnd', 'touchStart', 'volumeChange', 'scroll', 'scrollEnd', 'toggle', 'touchMove', 'waiting', 'wheel'];
+
+function registerSimpleEvent(domEventName, reactName) {
+  topLevelEventsToReactNames.set(domEventName, reactName);
+  registerTwoPhaseEvent(reactName, [domEventName]);
+}
+
+function registerSimpleEvents() {
+  for (let i = 0; i < simpleEventPluginEvents.length; i++) {
+    const eventName = simpleEventPluginEvents[i];
+    const domEventName = eventName.toLowerCase();
+    const capitalizedEvent = eventName[0].toUpperCase() + eventName.slice(1);
+    registerSimpleEvent(domEventName, 'on' + capitalizedEvent);
+  } // Special cases where event names don't match.
+
+
+  registerSimpleEvent(ANIMATION_END, 'onAnimationEnd');
+  registerSimpleEvent(ANIMATION_ITERATION, 'onAnimationIteration');
+  registerSimpleEvent(ANIMATION_START, 'onAnimationStart');
+  registerSimpleEvent('dblclick', 'onDoubleClick');
+  registerSimpleEvent('focusin', 'onFocus');
+  registerSimpleEvent('focusout', 'onBlur');
+  registerSimpleEvent(TRANSITION_END, 'onTransitionEnd');
+}
+
+function extractEvents$1(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  const reactName = topLevelEventsToReactNames.get(domEventName);
+
+  if (reactName === undefined) {
+    return;
+  }
+
+  let SyntheticEventCtor = SyntheticEvent;
+  let reactEventType = domEventName;
+
+  switch (domEventName) {
+    case 'keypress':
+      // Firefox creates a keypress event for function keys too. This removes
+      // the unwanted keypress events. Enter is however both printable and
+      // non-printable. One would expect Tab to be as well (but it isn't).
+      // TODO: Fixed in https://bugzilla.mozilla.org/show_bug.cgi?id=968056. Can
+      // probably remove.
+      if (getEventCharCode(nativeEvent) === 0) {
+        return;
+      }
+
+    /* falls through */
+
+    case 'keydown':
+    case 'keyup':
+      SyntheticEventCtor = SyntheticKeyboardEvent;
+      break;
+
+    case 'focusin':
+      reactEventType = 'focus';
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
+
+    case 'focusout':
+      reactEventType = 'blur';
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
+
+    case 'beforeblur':
+    case 'afterblur':
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
+
+    case 'click':
+      // Firefox creates a click event on right mouse clicks. This removes the
+      // unwanted click events.
+      // TODO: Fixed in https://phabricator.services.mozilla.com/D26793. Can
+      // probably remove.
+      if (nativeEvent.button === 2) {
+        return;
+      }
+
+    /* falls through */
+
+    case 'auxclick':
+    case 'dblclick':
+    case 'mousedown':
+    case 'mousemove':
+    case 'mouseup': // TODO: Disabled elements should not respond to mouse events
+
+    /* falls through */
+
+    case 'mouseout':
+    case 'mouseover':
+    case 'contextmenu':
+      SyntheticEventCtor = SyntheticMouseEvent;
+      break;
+
+    case 'drag':
+    case 'dragend':
+    case 'dragenter':
+    case 'dragexit':
+    case 'dragleave':
+    case 'dragover':
+    case 'dragstart':
+    case 'drop':
+      SyntheticEventCtor = SyntheticDragEvent;
+      break;
+
+    case 'touchcancel':
+    case 'touchend':
+    case 'touchmove':
+    case 'touchstart':
+      SyntheticEventCtor = SyntheticTouchEvent;
+      break;
+
+    case ANIMATION_END:
+    case ANIMATION_ITERATION:
+    case ANIMATION_START:
+      SyntheticEventCtor = SyntheticAnimationEvent;
+      break;
+
+    case TRANSITION_END:
+      SyntheticEventCtor = SyntheticTransitionEvent;
+      break;
+
+    case 'scroll':
+    case 'scrollend':
+      SyntheticEventCtor = SyntheticUIEvent;
+      break;
+
+    case 'wheel':
+      SyntheticEventCtor = SyntheticWheelEvent;
+      break;
+
+    case 'copy':
+    case 'cut':
+    case 'paste':
+      SyntheticEventCtor = SyntheticClipboardEvent;
+      break;
+
+    case 'gotpointercapture':
+    case 'lostpointercapture':
+    case 'pointercancel':
+    case 'pointerdown':
+    case 'pointermove':
+    case 'pointerout':
+    case 'pointerover':
+    case 'pointerup':
+      SyntheticEventCtor = SyntheticPointerEvent;
+      break;
+  }
+
+  const inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
+
+  {
+    // Some events don't bubble in the browser.
+    // In the past, React has always bubbled them, but this can be surprising.
+    // We're going to try aligning closer to the browser behavior by not bubbling
+    // them in React either. We'll start by not bubbling onScroll, and then expand.
+    const accumulateTargetOnly = !inCapturePhase && ( // TODO: ideally, we'd eventually add all events from
+    // nonDelegatedEvents list in DOMPluginEventSystem.
+    // Then we can remove this special list.
+    // This is a breaking change that can wait until React 18.
+    domEventName === 'scroll' || domEventName === 'scrollend');
+    const listeners = accumulateSinglePhaseListeners(targetInst, reactName, nativeEvent.type, inCapturePhase, accumulateTargetOnly);
+
+    if (listeners.length > 0) {
+      // Intentionally create event lazily.
+      const event = new SyntheticEventCtor(reactName, reactEventType, null, nativeEvent, nativeEventTarget);
+      dispatchQueue.push({
+        event,
+        listeners
+      });
+    }
+  }
+}
+
+registerSimpleEvents();
+registerEvents$1();
+registerEvents$2();
+registerEvents();
+registerEvents$3();
+
+function extractEvents(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  // TODO: we should remove the concept of a "SimpleEventPlugin".
+  // This is the basic functionality of the event system. All
+  // the other plugins are essentially polyfills. So the plugin
+  // should probably be inlined somewhere and have its logic
+  // be core the to event system. This would potentially allow
+  // us to ship builds of React without the polyfilled plugins below.
+  extractEvents$1(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags);
+  const shouldProcessPolyfillPlugins = (eventSystemFlags & SHOULD_NOT_PROCESS_POLYFILL_EVENT_PLUGINS) === 0; // We don't process these events unless we are in the
+  // event's native "bubble" phase, which means that we're
+  // not in the capture phase. That's because we emulate
+  // the capture phase here still. This is a trade-off,
+  // because in an ideal world we would not emulate and use
+  // the phases properly, like we do with the SimpleEvent
+  // plugin. However, the plugins below either expect
+  // emulation (EnterLeave) or use state localized to that
+  // plugin (BeforeInput, Change, Select). The state in
+  // these modules complicates things, as you'll essentially
+  // get the case where the capture phase event might change
+  // state, only for the following bubble event to come in
+  // later and not trigger anything as the state now
+  // invalidates the heuristics of the event plugin. We
+  // could alter all these plugins to work in such ways, but
+  // that might cause other unknown side-effects that we
+  // can't foresee right now.
+
+  if (shouldProcessPolyfillPlugins) {
+    extractEvents$3(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+    extractEvents$4(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+    extractEvents$2(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+    extractEvents$5(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+
+    {
+      extractEvents$6(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+    }
+  }
+} // List of events that need to be individually attached to media elements.
+
+
+const mediaEventTypes = ['abort', 'canplay', 'canplaythrough', 'durationchange', 'emptied', 'encrypted', 'ended', 'error', 'loadeddata', 'loadedmetadata', 'loadstart', 'pause', 'play', 'playing', 'progress', 'ratechange', 'resize', 'seeked', 'seeking', 'stalled', 'suspend', 'timeupdate', 'volumechange', 'waiting']; // We should not delegate these events to the container, but rather
+// set them on the actual target element itself. This is primarily
+// because these events do not consistently bubble in the DOM.
+
+const nonDelegatedEvents = new Set(['cancel', 'close', 'invalid', 'load', 'scroll', 'scrollend', 'toggle'].concat(mediaEventTypes));
+
+function executeDispatch(event, listener, currentTarget) {
+  const type = event.type || 'unknown-event';
+  event.currentTarget = currentTarget;
+  invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
+  event.currentTarget = null;
+}
+
+function processDispatchQueueItemsInOrder(event, dispatchListeners, inCapturePhase) {
+  let previousInstance;
+
+  if (inCapturePhase) {
+    for (let i = dispatchListeners.length - 1; i >= 0; i--) {
+      const _dispatchListeners$i = dispatchListeners[i],
+            instance = _dispatchListeners$i.instance,
+            currentTarget = _dispatchListeners$i.currentTarget,
+            listener = _dispatchListeners$i.listener;
+
+      if (instance !== previousInstance && event.isPropagationStopped()) {
+        return;
+      }
+
+      executeDispatch(event, listener, currentTarget);
+      previousInstance = instance;
+    }
+  } else {
+    for (let i = 0; i < dispatchListeners.length; i++) {
+      const _dispatchListeners$i2 = dispatchListeners[i],
+            instance = _dispatchListeners$i2.instance,
+            currentTarget = _dispatchListeners$i2.currentTarget,
+            listener = _dispatchListeners$i2.listener;
+
+      if (instance !== previousInstance && event.isPropagationStopped()) {
+        return;
+      }
+
+      executeDispatch(event, listener, currentTarget);
+      previousInstance = instance;
+    }
+  }
+}
+
+function processDispatchQueue(dispatchQueue, eventSystemFlags) {
+  const inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
+
+  for (let i = 0; i < dispatchQueue.length; i++) {
+    const _dispatchQueue$i = dispatchQueue[i],
+          event = _dispatchQueue$i.event,
+          listeners = _dispatchQueue$i.listeners;
+    processDispatchQueueItemsInOrder(event, listeners, inCapturePhase); //  event system doesn't use pooling.
+  } // This would be a good time to rethrow if any of the event handlers threw.
+
+
+  rethrowCaughtError();
+}
+
+function dispatchEventsForPlugins(domEventName, eventSystemFlags, nativeEvent, targetInst, targetContainer) {
+  const nativeEventTarget = getEventTarget(nativeEvent);
+  const dispatchQueue = [];
+  extractEvents(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags);
+  processDispatchQueue(dispatchQueue, eventSystemFlags);
+}
+
+function listenToNonDelegatedEvent(domEventName, targetElement) {
+
+  const isCapturePhaseListener = false;
+  const listenerSet = getEventListenerSet(targetElement);
+  const listenerSetKey = getListenerSetKey(domEventName, isCapturePhaseListener);
+
+  if (!listenerSet.has(listenerSetKey)) {
+    addTrappedEventListener(targetElement, domEventName, IS_NON_DELEGATED, isCapturePhaseListener);
+    listenerSet.add(listenerSetKey);
+  }
+}
+function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
+
+  let eventSystemFlags = 0;
+
+  if (isCapturePhaseListener) {
+    eventSystemFlags |= IS_CAPTURE_PHASE;
+  }
+
+  addTrappedEventListener(target, domEventName, eventSystemFlags, isCapturePhaseListener);
+} // This is only used by createEventHandle when the
+const listeningMarker = '_reactListening' + Math.random().toString(36).slice(2);
+function listenToAllSupportedEvents(rootContainerElement) {
+  if (!rootContainerElement[listeningMarker]) {
+    rootContainerElement[listeningMarker] = true;
+    allNativeEvents.forEach(domEventName => {
+      // We handle selectionchange separately because it
+      // doesn't bubble and needs to be on the document.
+      if (domEventName !== 'selectionchange') {
+        if (!nonDelegatedEvents.has(domEventName)) {
+          listenToNativeEvent(domEventName, false, rootContainerElement);
+        }
+
+        listenToNativeEvent(domEventName, true, rootContainerElement);
+      }
+    });
+    const ownerDocument = rootContainerElement.nodeType === DOCUMENT_NODE ? rootContainerElement : rootContainerElement.ownerDocument;
+
+    if (ownerDocument !== null) {
+      // The selectionchange event also needs deduplication
+      // but it is attached to the document.
+      if (!ownerDocument[listeningMarker]) {
+        ownerDocument[listeningMarker] = true;
+        listenToNativeEvent('selectionchange', false, ownerDocument);
+      }
+    }
+  }
+}
+
+function addTrappedEventListener(targetContainer, domEventName, eventSystemFlags, isCapturePhaseListener, isDeferredListenerForLegacyFBSupport) {
+  let listener = createEventListenerWrapperWithPriority(targetContainer, domEventName, eventSystemFlags); // If passive option is not supported, then the event will be
+  // active and not passive.
+
+  let isPassiveListener = undefined;
+
+  if (passiveBrowserEventsSupported) {
+    // Browsers introduced an intervention, making these events
+    // passive by default on document. React doesn't bind them
+    // to document anymore, but changing this now would undo
+    // the performance wins from the change. So we emulate
+    // the existing behavior manually on the roots now.
+    // https://github.com/facebook/react/issues/19651
+    if (domEventName === 'touchstart' || domEventName === 'touchmove' || domEventName === 'wheel') {
+      isPassiveListener = true;
+    }
+  }
+
+  targetContainer = targetContainer;
+
+
+  if (isCapturePhaseListener) {
+    if (isPassiveListener !== undefined) {
+      addEventCaptureListenerWithPassiveFlag(targetContainer, domEventName, listener, isPassiveListener);
+    } else {
+      addEventCaptureListener(targetContainer, domEventName, listener);
+    }
+  } else {
+    if (isPassiveListener !== undefined) {
+      addEventBubbleListenerWithPassiveFlag(targetContainer, domEventName, listener, isPassiveListener);
+    } else {
+      addEventBubbleListener(targetContainer, domEventName, listener);
+    }
+  }
+}
+
+function isMatchingRootContainer(grandContainer, targetContainer) {
+  return grandContainer === targetContainer || grandContainer.nodeType === COMMENT_NODE && grandContainer.parentNode === targetContainer;
+}
+
+function dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, targetInst, targetContainer) {
+  let ancestorInst = targetInst;
+
+  if ((eventSystemFlags & IS_EVENT_HANDLE_NON_MANAGED_NODE) === 0 && (eventSystemFlags & IS_NON_DELEGATED) === 0) {
+    const targetContainerNode = targetContainer; // If we are using the legacy FB support flag, we
+
+    if (targetInst !== null) {
+      // The below logic attempts to work out if we need to change
+      // the target fiber to a different ancestor. We had similar logic
+      // in the legacy event system, except the big difference between
+      // systems is that the modern event system now has an event listener
+      // attached to each React Root and React Portal Root. Together,
+      // the DOM nodes representing these roots are the "rootContainer".
+      // To figure out which ancestor instance we should use, we traverse
+      // up the fiber tree from the target instance and attempt to find
+      // root boundaries that match that of our current "rootContainer".
+      // If we find that "rootContainer", we find the parent fiber
+      // sub-tree for that root and make that our ancestor instance.
+      let node = targetInst;
+
+      mainLoop: while (true) {
+        if (node === null) {
+          return;
+        }
+
+        const nodeTag = node.tag;
+
+        if (nodeTag === HostRoot || nodeTag === HostPortal) {
+          let container = node.stateNode.containerInfo;
+
+          if (isMatchingRootContainer(container, targetContainerNode)) {
+            break;
+          }
+
+          if (nodeTag === HostPortal) {
+            // The target is a portal, but it's not the rootContainer we're looking for.
+            // Normally portals handle their own events all the way down to the root.
+            // So we should be able to stop now. However, we don't know if this portal
+            // was part of *our* root.
+            let grandNode = node.return;
+
+            while (grandNode !== null) {
+              const grandTag = grandNode.tag;
+
+              if (grandTag === HostRoot || grandTag === HostPortal) {
+                const grandContainer = grandNode.stateNode.containerInfo;
+
+                if (isMatchingRootContainer(grandContainer, targetContainerNode)) {
+                  // This is the rootContainer we're looking for and we found it as
+                  // a parent of the Portal. That means we can ignore it because the
+                  // Portal will bubble through to us.
+                  return;
+                }
+              }
+
+              grandNode = grandNode.return;
+            }
+          } // Now we need to find it's corresponding host fiber in the other
+          // tree. To do this we can use getClosestInstanceFromNode, but we
+          // need to validate that the fiber is a host instance, otherwise
+          // we need to traverse up through the DOM till we find the correct
+          // node that is from the other tree.
+
+
+          while (container !== null) {
+            const parentNode = getClosestInstanceFromNode(container);
+
+            if (parentNode === null) {
+              return;
+            }
+
+            const parentTag = parentNode.tag;
+
+            if (parentTag === HostComponent || parentTag === HostText || (parentTag === HostHoistable ) || (parentTag === HostSingleton )) {
+              node = ancestorInst = parentNode;
+              continue mainLoop;
+            }
+
+            container = container.parentNode;
+          }
+        }
+
+        node = node.return;
+      }
+    }
+  }
+
+  batchedUpdates(() => dispatchEventsForPlugins(domEventName, eventSystemFlags, nativeEvent, ancestorInst));
+}
+
+function createDispatchListener(instance, listener, currentTarget) {
+  return {
+    instance,
+    listener,
+    currentTarget
+  };
+}
+
+function accumulateSinglePhaseListeners(targetFiber, reactName, nativeEventType, inCapturePhase, accumulateTargetOnly, nativeEvent) {
+  const captureName = reactName !== null ? reactName + 'Capture' : null;
+  const reactEventName = inCapturePhase ? captureName : reactName;
+  let listeners = [];
+  let instance = targetFiber;
+  let lastHostComponent = null; // Accumulate all instances and listeners via the target -> root path.
+
+  while (instance !== null) {
+    const _instance = instance,
+          stateNode = _instance.stateNode,
+          tag = _instance.tag; // Handle listeners that are on HostComponents (i.e. <div>)
+
+    if ((tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton )) && stateNode !== null) {
+      lastHostComponent = stateNode; // createEventHandle listeners
+
+
+      if (reactEventName !== null) {
+        const listener = getListener(instance, reactEventName);
+
+        if (listener != null) {
+          listeners.push(createDispatchListener(instance, listener, lastHostComponent));
+        }
+      }
+    } // If we are only accumulating events for the target, then we don't
+    // continue to propagate through the React fiber tree to find other
+    // listeners.
+
+
+    if (accumulateTargetOnly) {
+      break;
+    } // If we are processing the onBeforeBlur event, then we need to take
+
+    instance = instance.return;
+  }
+
+  return listeners;
+} // We should only use this function for:
+// - BeforeInputEventPlugin
+// - ChangeEventPlugin
+// - SelectEventPlugin
+// This is because we only process these plugins
+// in the bubble phase, so we need to accumulate two
+// phase event listeners (via emulation).
+
+function accumulateTwoPhaseListeners(targetFiber, reactName) {
+  const captureName = reactName + 'Capture';
+  const listeners = [];
+  let instance = targetFiber; // Accumulate all instances and listeners via the target -> root path.
+
+  while (instance !== null) {
+    const _instance2 = instance,
+          stateNode = _instance2.stateNode,
+          tag = _instance2.tag; // Handle listeners that are on HostComponents (i.e. <div>)
+
+    if ((tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton )) && stateNode !== null) {
+      const currentTarget = stateNode;
+      const captureListener = getListener(instance, captureName);
+
+      if (captureListener != null) {
+        listeners.unshift(createDispatchListener(instance, captureListener, currentTarget));
+      }
+
+      const bubbleListener = getListener(instance, reactName);
+
+      if (bubbleListener != null) {
+        listeners.push(createDispatchListener(instance, bubbleListener, currentTarget));
+      }
+    }
+
+    instance = instance.return;
+  }
+
+  return listeners;
+}
+
+function getParent(inst) {
+  if (inst === null) {
+    return null;
+  }
+
+  do {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    inst = inst.return; // TODO: If this is a HostRoot we might want to bail out.
+    // That is depending on if we want nested subtrees (layers) to bubble
+    // events to their parent. We could also go through parentNode on the
+    // host node but that wouldn't work for React Native and doesn't let us
+    // do the portal feature.
+  } while (inst && inst.tag !== HostComponent && (inst.tag !== HostSingleton));
+
+  if (inst) {
+    return inst;
+  }
+
+  return null;
+}
+/**
+ * Return the lowest common ancestor of A and B, or null if they are in
+ * different trees.
+ */
+
+
+function getLowestCommonAncestor(instA, instB) {
+  let nodeA = instA;
+  let nodeB = instB;
+  let depthA = 0;
+
+  for (let tempA = nodeA; tempA; tempA = getParent(tempA)) {
+    depthA++;
+  }
+
+  let depthB = 0;
+
+  for (let tempB = nodeB; tempB; tempB = getParent(tempB)) {
+    depthB++;
+  } // If A is deeper, crawl up.
+
+
+  while (depthA - depthB > 0) {
+    nodeA = getParent(nodeA);
+    depthA--;
+  } // If B is deeper, crawl up.
+
+
+  while (depthB - depthA > 0) {
+    nodeB = getParent(nodeB);
+    depthB--;
+  } // Walk in lockstep until we find a match.
+
+
+  let depth = depthA;
+
+  while (depth--) {
+    if (nodeA === nodeB || nodeB !== null && nodeA === nodeB.alternate) {
+      return nodeA;
+    }
+
+    nodeA = getParent(nodeA);
+    nodeB = getParent(nodeB);
+  }
+
+  return null;
+}
+
+function accumulateEnterLeaveListenersForEvent(dispatchQueue, event, target, common, inCapturePhase) {
+  const registrationName = event._reactName;
+  const listeners = [];
+  let instance = target;
+
+  while (instance !== null) {
+    if (instance === common) {
+      break;
+    }
+
+    const _instance3 = instance,
+          alternate = _instance3.alternate,
+          stateNode = _instance3.stateNode,
+          tag = _instance3.tag;
+
+    if (alternate !== null && alternate === common) {
+      break;
+    }
+
+    if ((tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton )) && stateNode !== null) {
+      const currentTarget = stateNode;
+
+      if (inCapturePhase) {
+        const captureListener = getListener(instance, registrationName);
+
+        if (captureListener != null) {
+          listeners.unshift(createDispatchListener(instance, captureListener, currentTarget));
+        }
+      } else if (!inCapturePhase) {
+        const bubbleListener = getListener(instance, registrationName);
+
+        if (bubbleListener != null) {
+          listeners.push(createDispatchListener(instance, bubbleListener, currentTarget));
+        }
+      }
+    }
+
+    instance = instance.return;
+  }
+
+  if (listeners.length !== 0) {
+    dispatchQueue.push({
+      event,
+      listeners
+    });
+  }
+} // We should only use this function for:
+// - EnterLeaveEventPlugin
+// This is because we only process this plugin
+// in the bubble phase, so we need to accumulate two
+// phase event listeners.
+
+
+function accumulateEnterLeaveTwoPhaseListeners(dispatchQueue, leaveEvent, enterEvent, from, to) {
+  const common = from && to ? getLowestCommonAncestor(from, to) : null;
+
+  if (from !== null) {
+    accumulateEnterLeaveListenersForEvent(dispatchQueue, leaveEvent, from, common, false);
+  }
+
+  if (to !== null && enterEvent !== null) {
+    accumulateEnterLeaveListenersForEvent(dispatchQueue, enterEvent, to, common, true);
+  }
+}
+function getListenerSetKey(domEventName, capture) {
+  return domEventName + "__" + (capture ? 'capture' : 'bubble');
+}
+
+// It also can turn \u0000 into \uFFFD inside attributes.
+// https://www.w3.org/TR/html5/single-page.html#preprocessing-the-input-stream
+// If we have a mismatch, it might be caused by that.
+// We will still patch up in this case but not fire the warning.
+
+
+const NORMALIZE_NEWLINES_REGEX = /\r\n?/g;
+const NORMALIZE_NULL_AND_REPLACEMENT_REGEX = /\u0000|\uFFFD/g;
+
+function normalizeMarkupForTextOrAttribute(markup) {
+
+  const markupString = typeof markup === 'string' ? markup : '' + markup;
+  return markupString.replace(NORMALIZE_NEWLINES_REGEX, '\n').replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, '');
+}
+
+function checkForUnmatchedText(serverText, clientText, isConcurrentMode, shouldWarnDev) {
+  const normalizedClientText = normalizeMarkupForTextOrAttribute(clientText);
+  const normalizedServerText = normalizeMarkupForTextOrAttribute(serverText);
+
+  if (normalizedServerText === normalizedClientText) {
+    return;
+  }
+
+  if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {
+    // In concurrent roots, we throw when there's a text mismatch and revert to
+    // client rendering, up to the nearest Suspense boundary.
+    throw Error(formatProdErrorMessage(425));
+  }
+}
+
+function noop$1() {}
+
+function trapClickOnNonInteractiveElement(node) {
+  // Mobile Safari does not fire properly bubble click events on
+  // non-interactive elements, which means delegated click listeners do not
+  // fire. The workaround for this bug involves attaching an empty click
+  // listener on the target node.
+  // https://www.quirksmode.org/blog/archives/2010/09/click_event_del.html
+  // Just set it using the onclick property so that we don't have to manage any
+  // bookkeeping for it. Not sure if we need to clear it when the listener is
+  // removed.
+  // TODO: Only do this for the relevant Safaris maybe?
+  node.onclick = noop$1;
+}
+const xlinkNamespace = 'http://www.w3.org/1999/xlink';
+const xmlNamespace = 'http://www.w3.org/XML/1998/namespace';
+
+function setProp(domElement, tag, key, value, props, prevValue) {
+  switch (key) {
+    case 'children':
+      {
+        if (typeof value === 'string') {
+          // textContent on a <textarea> will cause the placeholder to not
+          // show within the <textarea> until it has been focused and blurred again.
+          // https://github.com/facebook/react/issues/6731#issuecomment-254874553
+
+
+          const canSetTextContent = (tag !== 'body') && (tag !== 'textarea' || value !== '');
+
+          if (canSetTextContent) {
+            setTextContent(domElement, value);
+          }
+        } else if (typeof value === 'number') {
+
+          const canSetTextContent = tag !== 'body';
+
+          if (canSetTextContent) {
+            setTextContent(domElement, '' + value);
+          }
+        }
+
+        break;
+      }
+    // These are very common props and therefore are in the beginning of the switch.
+    // TODO: aria-label is a very common prop but allows booleans so is not like the others
+    // but should ideally go in this list too.
+
+    case 'className':
+      setValueForKnownAttribute(domElement, 'class', value);
+      break;
+
+    case 'tabIndex':
+      // This has to be case sensitive in SVG.
+      setValueForKnownAttribute(domElement, 'tabindex', value);
+      break;
+
+    case 'dir':
+    case 'role':
+    case 'viewBox':
+    case 'width':
+    case 'height':
+      {
+        setValueForKnownAttribute(domElement, key, value);
+        break;
+      }
+
+    case 'style':
+      {
+        setValueForStyles(domElement, value, prevValue);
+        break;
+      }
+    // These attributes accept URLs. These must not allow javascript: URLS.
+
+    case 'src':
+    case 'href':
+      {
+        {
+          if (value === '') {
+
+            domElement.removeAttribute(key);
+            break;
+          }
+        }
+
+        if (value == null || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          domElement.removeAttribute(key);
+          break;
+        } // `setAttribute` with objects becomes only `[object]` in IE8/9,
+
+        const sanitizedValue = sanitizeURL('' + value);
+        domElement.setAttribute(key, sanitizedValue);
+        break;
+      }
+
+    case 'action':
+    case 'formAction':
+      {
+
+        {
+          if (typeof value === 'function') {
+            // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+            // because we'll preventDefault, but it can happen if a form is manually submitted or
+            // if someone calls stopPropagation before React gets the event.
+            // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+            // error message but the URL will be logged.
+            domElement.setAttribute(key, // eslint-disable-next-line no-script-url
+            "javascript:throw new Error('" + 'A React form was unexpectedly submitted. If you called form.submit() manually, ' + "consider using form.requestSubmit() instead. If you\\'re trying to use " + 'event.stopPropagation() in a submit event handler, consider also calling ' + 'event.preventDefault().' + "')");
+            break;
+          } else if (typeof prevValue === 'function') {
+            // When we're switching off a Server Action that was originally hydrated.
+            // The server control these fields during SSR that are now trailing.
+            // The regular diffing doesn't apply since we compare against the previous props.
+            // Instead, we need to force them to be set to whatever they should be now.
+            // This would be a lot cleaner if we did this whole fork in the per-tag approach.
+            if (key === 'formAction') {
+              if (tag !== 'input') {
+                // Setting the name here isn't completely safe for inputs if this is switching
+                // to become a radio button. In that case we let the tag based override take
+                // control.
+                setProp(domElement, tag, 'name', props.name, props, null);
+              }
+
+              setProp(domElement, tag, 'formEncType', props.formEncType, props, null);
+              setProp(domElement, tag, 'formMethod', props.formMethod, props, null);
+              setProp(domElement, tag, 'formTarget', props.formTarget, props, null);
+            } else {
+              setProp(domElement, tag, 'encType', props.encType, props, null);
+              setProp(domElement, tag, 'method', props.method, props, null);
+              setProp(domElement, tag, 'target', props.target, props, null);
+            }
+          }
+        }
+
+        if (value == null || !enableFormActions  || typeof value === 'symbol' || typeof value === 'boolean') {
+          domElement.removeAttribute(key);
+          break;
+        } // `setAttribute` with objects becomes only `[object]` in IE8/9,
+
+        const sanitizedValue = sanitizeURL('' + value);
+        domElement.setAttribute(key, sanitizedValue);
+        break;
+      }
+
+    case 'onClick':
+      {
+        // TODO: This cast may not be sound for SVG, MathML or custom elements.
+        if (value != null) {
+
+          trapClickOnNonInteractiveElement(domElement);
+        }
+
+        break;
+      }
+
+    case 'onScroll':
+      {
+        if (value != null) {
+
+          listenToNonDelegatedEvent('scroll', domElement);
+        }
+
+        break;
+      }
+
+    case 'onScrollEnd':
+      {
+        if (value != null) {
+
+          listenToNonDelegatedEvent('scrollend', domElement);
+        }
+
+        break;
+      }
+
+    case 'dangerouslySetInnerHTML':
+      {
+        if (value != null) {
+          if (typeof value !== 'object' || !('__html' in value)) {
+            throw Error(formatProdErrorMessage(61));
+          }
+
+          const nextHtml = value.__html;
+
+          if (nextHtml != null) {
+            if (props.children != null) {
+              throw Error(formatProdErrorMessage(60));
+            }
+
+            {
+              domElement.innerHTML = nextHtml;
+            }
+          }
+        }
+
+        break;
+      }
+    // Note: `option.selected` is not updated if `select.multiple` is
+    // disabled with `removeAttribute`. We have special logic for handling this.
+
+    case 'multiple':
+      {
+        domElement.multiple = value && typeof value !== 'function' && typeof value !== 'symbol';
+        break;
+      }
+
+    case 'muted':
+      {
+        domElement.muted = value && typeof value !== 'function' && typeof value !== 'symbol';
+        break;
+      }
+
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'defaultValue': // Reserved
+
+    case 'defaultChecked':
+    case 'innerHTML':
+      {
+        // Noop
+        break;
+      }
+
+    case 'autoFocus':
+      {
+        // We polyfill it separately on the client during commit.
+        // We could have excluded it in the property list instead of
+        // adding a special case here, but then it wouldn't be emitted
+        // on server rendering (but we *do* want to emit it in SSR).
+        break;
+      }
+
+    case 'xlinkHref':
+      {
+        if (value == null || typeof value === 'function' || typeof value === 'boolean' || typeof value === 'symbol') {
+          domElement.removeAttribute('xlink:href');
+          break;
+        } // `setAttribute` with objects becomes only `[object]` in IE8/9,
+
+        const sanitizedValue = sanitizeURL('' + value);
+        domElement.setAttributeNS(xlinkNamespace, 'xlink:href', sanitizedValue);
+        break;
+      }
+
+    case 'contentEditable':
+    case 'spellCheck':
+    case 'draggable':
+    case 'value':
+    case 'autoReverse':
+    case 'externalResourcesRequired':
+    case 'focusable':
+    case 'preserveAlpha':
+      {
+        // Booleanish String
+        // These are "enumerated" attributes that accept "true" and "false".
+        // In React, we let users pass `true` and `false` even though technically
+        // these aren't boolean attributes (they are coerced to strings).
+        // The SVG attributes are case-sensitive. Since the HTML attributes are
+        // insensitive they also work even though we canonically use lower case.
+        if (value != null && typeof value !== 'function' && typeof value !== 'symbol') {
+
+          domElement.setAttribute(key, '' + value);
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+    // Boolean
+
+    case 'allowFullScreen':
+    case 'async':
+    case 'autoPlay':
+    case 'controls':
+    case 'default':
+    case 'defer':
+    case 'disabled':
+    case 'disablePictureInPicture':
+    case 'disableRemotePlayback':
+    case 'formNoValidate':
+    case 'hidden':
+    case 'loop':
+    case 'noModule':
+    case 'noValidate':
+    case 'open':
+    case 'playsInline':
+    case 'readOnly':
+    case 'required':
+    case 'reversed':
+    case 'scoped':
+    case 'seamless':
+    case 'itemScope':
+      {
+        if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+          domElement.setAttribute(key, '');
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+    // Overloaded Boolean
+
+    case 'capture':
+    case 'download':
+      {
+        // An attribute that can be used as a flag as well as with a value.
+        // When true, it should be present (set either to an empty string or its name).
+        // When false, it should be omitted.
+        // For any other value, should be present with that value.
+        if (value === true) {
+          domElement.setAttribute(key, '');
+        } else if (value !== false && value != null && typeof value !== 'function' && typeof value !== 'symbol') {
+
+          domElement.setAttribute(key, value);
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+
+    case 'cols':
+    case 'rows':
+    case 'size':
+    case 'span':
+      {
+        // These are HTML attributes that must be positive numbers.
+        if (value != null && typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value) && value >= 1) {
+
+          domElement.setAttribute(key, value);
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+
+    case 'rowSpan':
+    case 'start':
+      {
+        // These are HTML attributes that must be numbers.
+        if (value != null && typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value)) {
+
+          domElement.setAttribute(key, value);
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+
+    case 'xlinkActuate':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:actuate', value);
+      break;
+
+    case 'xlinkArcrole':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:arcrole', value);
+      break;
+
+    case 'xlinkRole':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:role', value);
+      break;
+
+    case 'xlinkShow':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:show', value);
+      break;
+
+    case 'xlinkTitle':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:title', value);
+      break;
+
+    case 'xlinkType':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:type', value);
+      break;
+
+    case 'xmlBase':
+      setValueForNamespacedAttribute(domElement, xmlNamespace, 'xml:base', value);
+      break;
+
+    case 'xmlLang':
+      setValueForNamespacedAttribute(domElement, xmlNamespace, 'xml:lang', value);
+      break;
+
+    case 'xmlSpace':
+      setValueForNamespacedAttribute(domElement, xmlNamespace, 'xml:space', value);
+      break;
+    // Properties that should not be allowed on custom elements.
+
+    case 'is':
+      {
+        // passed it to createElement. We don't also need the attribute.
+        // However, our tests currently query for it so it's plausible someone
+        // else does too so it's break.
+
+
+        setValueForAttribute(domElement, 'is', value);
+        break;
+      }
+
+    case 'innerText':
+    case 'textContent':
+      {
+        break;
+      }
+
+    // Fall through
+
+    default:
+      {
+        if (key.length > 2 && (key[0] === 'o' || key[0] === 'O') && (key[1] === 'n' || key[1] === 'N')) ; else {
+          const attributeName = getAttributeAlias(key);
+          setValueForAttribute(domElement, attributeName, value);
+        }
+      }
+  }
+}
+
+function setPropOnCustomElement(domElement, tag, key, value, props, prevValue) {
+  switch (key) {
+    case 'style':
+      {
+        setValueForStyles(domElement, value, prevValue);
+        break;
+      }
+
+    case 'dangerouslySetInnerHTML':
+      {
+        if (value != null) {
+          if (typeof value !== 'object' || !('__html' in value)) {
+            throw Error(formatProdErrorMessage(61));
+          }
+
+          const nextHtml = value.__html;
+
+          if (nextHtml != null) {
+            if (props.children != null) {
+              throw Error(formatProdErrorMessage(60));
+            }
+
+            {
+              domElement.innerHTML = nextHtml;
+            }
+          }
+        }
+
+        break;
+      }
+
+    case 'children':
+      {
+        if (typeof value === 'string') {
+          setTextContent(domElement, value);
+        } else if (typeof value === 'number') {
+          setTextContent(domElement, '' + value);
+        }
+
+        break;
+      }
+
+    case 'onScroll':
+      {
+        if (value != null) {
+
+          listenToNonDelegatedEvent('scroll', domElement);
+        }
+
+        break;
+      }
+
+    case 'onScrollEnd':
+      {
+        if (value != null) {
+
+          listenToNonDelegatedEvent('scrollend', domElement);
+        }
+
+        break;
+      }
+
+    case 'onClick':
+      {
+        // TODO: This cast may not be sound for SVG, MathML or custom elements.
+        if (value != null) {
+
+          trapClickOnNonInteractiveElement(domElement);
+        }
+
+        break;
+      }
+
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'innerHTML':
+      {
+        // Noop
+        break;
+      }
+
+    case 'innerText': // Properties
+
+    case 'textContent':
+      {
+        break;
+      }
+
+    // Fall through
+
+    default:
+      {
+        if (registrationNameDependencies.hasOwnProperty(key)) ; else {
+          {
+            setValueForPropertyOnCustomComponent(domElement, key, value);
+          }
+        }
+      }
+  }
+}
+
+function setInitialProperties(domElement, tag, props) {
+
+
+  switch (tag) {
+    case 'div':
+    case 'span':
+    case 'svg':
+    case 'path':
+    case 'a':
+    case 'g':
+    case 'p':
+    case 'li':
+      {
+        // Fast track the most common tag types
+        break;
+      }
+
+    case 'input':
+      {
+        // listeners still fire for the invalid event.
+
+
+        listenToNonDelegatedEvent('invalid', domElement);
+        let name = null;
+        let type = null;
+        let value = null;
+        let defaultValue = null;
+        let checked = null;
+        let defaultChecked = null;
+
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'name':
+              {
+                name = propValue;
+                break;
+              }
+
+            case 'type':
+              {
+                type = propValue;
+                break;
+              }
+
+            case 'checked':
+              {
+                checked = propValue;
+                break;
+              }
+
+            case 'defaultChecked':
+              {
+                defaultChecked = propValue;
+                break;
+              }
+
+            case 'value':
+              {
+                value = propValue;
+                break;
+              }
+
+            case 'defaultValue':
+              {
+                defaultValue = propValue;
+                break;
+              }
+
+            case 'children':
+            case 'dangerouslySetInnerHTML':
+              {
+                if (propValue != null) {
+                  throw Error(formatProdErrorMessage(137, tag));
+                }
+
+                break;
+              }
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        } // TODO: Make sure we check if this is still unmounted or do any clean
+        initInput(domElement, value, defaultValue, checked, defaultChecked, type, name, false);
+        track(domElement);
+        return;
+      }
+
+    case 'select':
+      {
+        // listeners still fire for the invalid event.
+
+
+        listenToNonDelegatedEvent('invalid', domElement);
+        let value = null;
+        let defaultValue = null;
+        let multiple = null;
+
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'value':
+              {
+                value = propValue; // This is handled by initSelect below.
+
+                break;
+              }
+
+            case 'defaultValue':
+              {
+                defaultValue = propValue; // This is handled by initSelect below.
+
+                break;
+              }
+
+            case 'multiple':
+              {
+                multiple = propValue; // TODO: We don't actually have to fall through here because we set it
+                // in initSelect anyway. We can remove the special case in setProp.
+              }
+            // Fallthrough
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        }
+        initSelect(domElement, value, defaultValue, multiple);
+        return;
+      }
+
+    case 'textarea':
+      {
+        // listeners still fire for the invalid event.
+
+
+        listenToNonDelegatedEvent('invalid', domElement);
+        let value = null;
+        let defaultValue = null;
+        let children = null;
+
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'value':
+              {
+                value = propValue; // This is handled by initTextarea below.
+
+                break;
+              }
+
+            case 'defaultValue':
+              {
+                defaultValue = propValue;
+                break;
+              }
+
+            case 'children':
+              {
+                children = propValue; // Handled by initTextarea above.
+
+                break;
+              }
+
+            case 'dangerouslySetInnerHTML':
+              {
+                if (propValue != null) {
+                  // TODO: Do we really need a special error message for this. It's also pretty blunt.
+                  throw Error(formatProdErrorMessage(91));
+                }
+
+                break;
+              }
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        } // TODO: Make sure we check if this is still unmounted or do any clean
+        initTextarea(domElement, value, defaultValue, children);
+        track(domElement);
+        return;
+      }
+
+    case 'option':
+      {
+
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'selected':
+              {
+                // TODO: Remove support for selected on option.
+                domElement.selected = propValue && typeof propValue !== 'function' && typeof propValue !== 'symbol';
+                break;
+              }
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        }
+
+        return;
+      }
+
+    case 'dialog':
+      {
+        listenToNonDelegatedEvent('cancel', domElement);
+        listenToNonDelegatedEvent('close', domElement);
+        break;
+      }
+
+    case 'iframe':
+    case 'object':
+      {
+        // We listen to this event in case to ensure emulated bubble
+        // listeners still fire for the load event.
+        listenToNonDelegatedEvent('load', domElement);
+        break;
+      }
+
+    case 'video':
+    case 'audio':
+      {
+        // We listen to these events in case to ensure emulated bubble
+        // listeners still fire for all the media events.
+        for (let i = 0; i < mediaEventTypes.length; i++) {
+          listenToNonDelegatedEvent(mediaEventTypes[i], domElement);
+        }
+
+        break;
+      }
+
+    case 'image':
+      {
+        // We listen to these events in case to ensure emulated bubble
+        // listeners still fire for error and load events.
+        listenToNonDelegatedEvent('error', domElement);
+        listenToNonDelegatedEvent('load', domElement);
+        break;
+      }
+
+    case 'details':
+      {
+        // We listen to this event in case to ensure emulated bubble
+        // listeners still fire for the toggle event.
+        listenToNonDelegatedEvent('toggle', domElement);
+        break;
+      }
+
+    case 'embed':
+    case 'source':
+    case 'img':
+    case 'link':
+      {
+        // These are void elements that also need delegated events.
+        listenToNonDelegatedEvent('error', domElement);
+        listenToNonDelegatedEvent('load', domElement); // We fallthrough to the return of the void elements
+      }
+
+    case 'area':
+    case 'base':
+    case 'br':
+    case 'col':
+    case 'hr':
+    case 'keygen':
+    case 'meta':
+    case 'param':
+    case 'track':
+    case 'wbr':
+    case 'menuitem':
+      {
+        // Void elements
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'children':
+            case 'dangerouslySetInnerHTML':
+              {
+                // TODO: Can we make this a DEV warning to avoid this deny list?
+                throw Error(formatProdErrorMessage(137, tag));
+              }
+            // defaultChecked and defaultValue are ignored by setProp
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        }
+
+        return;
+      }
+
+    default:
+      {
+        if (isCustomElement(tag)) {
+          for (const propKey in props) {
+            if (!props.hasOwnProperty(propKey)) {
+              continue;
+            }
+
+            const propValue = props[propKey];
+
+            if (propValue == null) {
+              continue;
+            }
+
+            setPropOnCustomElement(domElement, tag, propKey, propValue, props, null);
+          }
+
+          return;
+        }
+      }
+  }
+
+  for (const propKey in props) {
+    if (!props.hasOwnProperty(propKey)) {
+      continue;
+    }
+
+    const propValue = props[propKey];
+
+    if (propValue == null) {
+      continue;
+    }
+
+    setProp(domElement, tag, propKey, propValue, props, null);
+  }
+}
+function updateProperties(domElement, tag, lastProps, nextProps) {
+
+  switch (tag) {
+    case 'div':
+    case 'span':
+    case 'svg':
+    case 'path':
+    case 'a':
+    case 'g':
+    case 'p':
+    case 'li':
+      {
+        // Fast track the most common tag types
+        break;
+      }
+
+    case 'input':
+      {
+        let name = null;
+        let type = null;
+        let value = null;
+        let defaultValue = null;
+        let lastDefaultValue = null;
+        let checked = null;
+        let defaultChecked = null;
+
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null) {
+            switch (propKey) {
+              case 'checked':
+                {
+                  break;
+                }
+
+              case 'value':
+                {
+                  // This is handled by updateWrapper below.
+                  break;
+                }
+
+              case 'defaultValue':
+                {
+                  lastDefaultValue = lastProp;
+                }
+              // defaultChecked and defaultValue are ignored by setProp
+              // Fallthrough
+
+              default:
+                {
+                  if (!nextProps.hasOwnProperty(propKey)) setProp(domElement, tag, propKey, null, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'type':
+                {
+                  type = nextProp;
+                  break;
+                }
+
+              case 'name':
+                {
+                  name = nextProp;
+                  break;
+                }
+
+              case 'checked':
+                {
+                  checked = nextProp;
+                  break;
+                }
+
+              case 'defaultChecked':
+                {
+                  defaultChecked = nextProp;
+                  break;
+                }
+
+              case 'value':
+                {
+                  value = nextProp;
+                  break;
+                }
+
+              case 'defaultValue':
+                {
+                  defaultValue = nextProp;
+                  break;
+                }
+
+              case 'children':
+              case 'dangerouslySetInnerHTML':
+                {
+                  if (nextProp != null) {
+                    throw Error(formatProdErrorMessage(137, tag));
+                  }
+
+                  break;
+                }
+
+              default:
+                {
+                  if (nextProp !== lastProp) setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        }
+        // happen after updating the rest of props. Otherwise HTML5 input validations
+        // raise warnings and prevent the new value from being assigned.
+
+
+        updateInput(domElement, value, defaultValue, lastDefaultValue, checked, defaultChecked, type, name);
+        return;
+      }
+
+    case 'select':
+      {
+        let value = null;
+        let defaultValue = null;
+        let multiple = null;
+        let wasMultiple = null;
+
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null) {
+            switch (propKey) {
+              case 'value':
+                {
+                  // This is handled by updateWrapper below.
+                  break;
+                }
+              // defaultValue are ignored by setProp
+
+              case 'multiple':
+                {
+                  wasMultiple = lastProp; // TODO: Move special case in here from setProp.
+                }
+              // Fallthrough
+
+              default:
+                {
+                  if (!nextProps.hasOwnProperty(propKey)) setProp(domElement, tag, propKey, null, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'value':
+                {
+                  value = nextProp; // This is handled by updateSelect below.
+
+                  break;
+                }
+
+              case 'defaultValue':
+                {
+                  defaultValue = nextProp;
+                  break;
+                }
+
+              case 'multiple':
+                {
+                  multiple = nextProp; // TODO: Just move the special case in here from setProp.
+                }
+              // Fallthrough
+
+              default:
+                {
+                  if (nextProp !== lastProp) setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        } // <select> value update needs to occur after <option> children
+        // reconciliation
+
+
+        updateSelect(domElement, value, defaultValue, multiple, wasMultiple);
+        return;
+      }
+
+    case 'textarea':
+      {
+        let value = null;
+        let defaultValue = null;
+
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+            switch (propKey) {
+              case 'value':
+                {
+                  // This is handled by updateTextarea below.
+                  break;
+                }
+
+              case 'children':
+                {
+                  // TODO: This doesn't actually do anything if it updates.
+                  break;
+                }
+              // defaultValue is ignored by setProp
+
+              default:
+                {
+                  setProp(domElement, tag, propKey, null, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'value':
+                {
+                  value = nextProp; // This is handled by updateTextarea below.
+
+                  break;
+                }
+
+              case 'defaultValue':
+                {
+                  defaultValue = nextProp;
+                  break;
+                }
+
+              case 'children':
+                {
+                  // TODO: This doesn't actually do anything if it updates.
+                  break;
+                }
+
+              case 'dangerouslySetInnerHTML':
+                {
+                  if (nextProp != null) {
+                    // TODO: Do we really need a special error message for this. It's also pretty blunt.
+                    throw Error(formatProdErrorMessage(91));
+                  }
+
+                  break;
+                }
+
+              default:
+                {
+                  if (nextProp !== lastProp) setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        updateTextarea(domElement, value, defaultValue);
+        return;
+      }
+
+    case 'option':
+      {
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+            switch (propKey) {
+              case 'selected':
+                {
+                  // TODO: Remove support for selected on option.
+                  domElement.selected = false;
+                  break;
+                }
+
+              default:
+                {
+                  setProp(domElement, tag, propKey, null, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && nextProp !== lastProp && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'selected':
+                {
+                  // TODO: Remove support for selected on option.
+                  domElement.selected = nextProp && typeof nextProp !== 'function' && typeof nextProp !== 'symbol';
+                  break;
+                }
+
+              default:
+                {
+                  setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        return;
+      }
+
+    case 'img':
+    case 'link':
+    case 'area':
+    case 'base':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'keygen':
+    case 'meta':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+    case 'menuitem':
+      {
+        // Void elements
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+            setProp(domElement, tag, propKey, null, nextProps, lastProp);
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && nextProp !== lastProp && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'children':
+              case 'dangerouslySetInnerHTML':
+                {
+                  if (nextProp != null) {
+                    // TODO: Can we make this a DEV warning to avoid this deny list?
+                    throw Error(formatProdErrorMessage(137, tag));
+                  }
+
+                  break;
+                }
+              // defaultChecked and defaultValue are ignored by setProp
+
+              default:
+                {
+                  setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        return;
+      }
+
+    default:
+      {
+        if (isCustomElement(tag)) {
+          for (const propKey in lastProps) {
+            const lastProp = lastProps[propKey];
+
+            if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+              setPropOnCustomElement(domElement, tag, propKey, null, nextProps, lastProp);
+            }
+          }
+
+          for (const propKey in nextProps) {
+            const nextProp = nextProps[propKey];
+            const lastProp = lastProps[propKey];
+
+            if (nextProps.hasOwnProperty(propKey) && nextProp !== lastProp && (nextProp != null || lastProp != null)) {
+              setPropOnCustomElement(domElement, tag, propKey, nextProp, nextProps, lastProp);
+            }
+          }
+
+          return;
+        }
+      }
+  }
+
+  for (const propKey in lastProps) {
+    const lastProp = lastProps[propKey];
+
+    if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+      setProp(domElement, tag, propKey, null, nextProps, lastProp);
+    }
+  }
+
+  for (const propKey in nextProps) {
+    const nextProp = nextProps[propKey];
+    const lastProp = lastProps[propKey];
+
+    if (nextProps.hasOwnProperty(propKey) && nextProp !== lastProp && (nextProp != null || lastProp != null)) {
+      setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+    }
+  }
+}
+
+function diffHydratedProperties(domElement, tag, props, isConcurrentMode, shouldWarnDev, hostContext) {
+
+
+  switch (tag) {
+    case 'dialog':
+      listenToNonDelegatedEvent('cancel', domElement);
+      listenToNonDelegatedEvent('close', domElement);
+      break;
+
+    case 'iframe':
+    case 'object':
+    case 'embed':
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the load event.
+      listenToNonDelegatedEvent('load', domElement);
+      break;
+
+    case 'video':
+    case 'audio':
+      // We listen to these events in case to ensure emulated bubble
+      // listeners still fire for all the media events.
+      for (let i = 0; i < mediaEventTypes.length; i++) {
+        listenToNonDelegatedEvent(mediaEventTypes[i], domElement);
+      }
+
+      break;
+
+    case 'source':
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the error event.
+      listenToNonDelegatedEvent('error', domElement);
+      break;
+
+    case 'img':
+    case 'image':
+    case 'link':
+      // We listen to these events in case to ensure emulated bubble
+      // listeners still fire for error and load events.
+      listenToNonDelegatedEvent('error', domElement);
+      listenToNonDelegatedEvent('load', domElement);
+      break;
+
+    case 'details':
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the toggle event.
+      listenToNonDelegatedEvent('toggle', domElement);
+      break;
+
+    case 'input':
+      // listeners still fire for the invalid event.
+
+
+      listenToNonDelegatedEvent('invalid', domElement); // TODO: Make sure we check if this is still unmounted or do any clean
+      // post mount to force it to diverge from attributes. However, for
+      // option and select we don't quite do the same thing and select
+      // is not resilient to the DOM state changing so we don't do that here.
+      // TODO: Consider not doing this for input and textarea.
+
+      initInput(domElement, props.value, props.defaultValue, props.checked, props.defaultChecked, props.type, props.name, true);
+      track(domElement);
+      break;
+
+    case 'option':
+      break;
+
+    case 'select':
+      // listeners still fire for the invalid event.
+
+
+      listenToNonDelegatedEvent('invalid', domElement);
+      break;
+
+    case 'textarea':
+      // listeners still fire for the invalid event.
+
+
+      listenToNonDelegatedEvent('invalid', domElement); // TODO: Make sure we check if this is still unmounted or do any clean
+      initTextarea(domElement, props.value, props.defaultValue, props.children);
+      track(domElement);
+      break;
+  }
+
+  const children = props.children; // For text content children we compare against textContent. This
+  // might match additional HTML that is hidden when we read it using
+  // textContent. E.g. "foo" will match "f<span>oo</span>" but that still
+  // satisfies our requirement. Our requirement is not to produce perfect
+  // HTML and attributes. Ideally we should preserve structure but it's
+  // ok not to if the visible content is still enough to indicate what
+  // even listeners these nodes might be wired up to.
+  // TODO: Warn if there is more than a single textNode as a child.
+  // TODO: Should we use domElement.firstChild.nodeValue to compare?
+
+  if (typeof children === 'string' || typeof children === 'number') {
+    if (domElement.textContent !== '' + children) {
+      if (props.suppressHydrationWarning !== true) {
+        checkForUnmatchedText(domElement.textContent, children, isConcurrentMode);
+      }
+
+      if (!isConcurrentMode || !enableClientRenderFallbackOnTextMismatch) {
+        // We really should be patching this in the commit phase but since
+        // this only affects legacy mode hydration which is deprecated anyway
+        // we can get away with it.
+        // Host singletons get their children appended and don't use the text
+        // content mechanism.
+        if (tag !== 'body') {
+          domElement.textContent = children;
+        }
+      }
+    }
+  }
+
+  if (props.onScroll != null) {
+    listenToNonDelegatedEvent('scroll', domElement);
+  }
+
+  if (props.onScrollEnd != null) {
+    listenToNonDelegatedEvent('scrollend', domElement);
+  }
+
+  if (props.onClick != null) {
+    // TODO: This cast may not be sound for SVG, MathML or custom elements.
+    trapClickOnNonInteractiveElement(domElement);
+  }
+}
+function diffHydratedText(textNode, text, isConcurrentMode) {
+  const isDifferent = textNode.nodeValue !== text;
+  return isDifferent;
+}
+function restoreControlledState(domElement, tag, props) {
+  switch (tag) {
+    case 'input':
+      restoreControlledInputState(domElement, props);
+      return;
+
+    case 'textarea':
+      restoreControlledTextareaState(domElement, props);
+      return;
+
+    case 'select':
+      restoreControlledSelectState(domElement, props);
+      return;
+  }
+}
+
+const SUPPRESS_HYDRATION_WARNING = 'suppressHydrationWarning';
+const SUSPENSE_START_DATA = '$';
+const SUSPENSE_END_DATA = '/$';
+const SUSPENSE_PENDING_START_DATA = '$?';
+const SUSPENSE_FALLBACK_START_DATA = '$!';
+const FORM_STATE_IS_MATCHING = 'F!';
+const FORM_STATE_IS_NOT_MATCHING = 'F';
+const STYLE = 'style';
+const HostContextNamespaceNone = 0;
+const HostContextNamespaceSvg = 1;
+const HostContextNamespaceMath = 2;
+let eventsEnabled = null;
+let selectionInformation = null;
+
+function getOwnerDocumentFromRootContainer(rootContainerElement) {
+  return rootContainerElement.nodeType === DOCUMENT_NODE ? rootContainerElement : rootContainerElement.ownerDocument;
+}
+
+function getRootHostContext(rootContainerInstance) {
+  let type;
+  let context;
+  const nodeType = rootContainerInstance.nodeType;
+
+  switch (nodeType) {
+    case DOCUMENT_NODE:
+    case DOCUMENT_FRAGMENT_NODE:
+      {
+        type = nodeType === DOCUMENT_NODE ? '#document' : '#fragment';
+        const root = rootContainerInstance.documentElement;
+
+        if (root) {
+          const namespaceURI = root.namespaceURI;
+          context = namespaceURI ? getOwnHostContext(namespaceURI) : HostContextNamespaceNone;
+        } else {
+          context = HostContextNamespaceNone;
+        }
+
+        break;
+      }
+
+    default:
+      {
+        const container = nodeType === COMMENT_NODE ? rootContainerInstance.parentNode : rootContainerInstance;
+        type = container.tagName;
+        const namespaceURI = container.namespaceURI;
+
+        if (!namespaceURI) {
+          switch (type) {
+            case 'svg':
+              context = HostContextNamespaceSvg;
+              break;
+
+            case 'math':
+              context = HostContextNamespaceMath;
+              break;
+
+            default:
+              context = HostContextNamespaceNone;
+              break;
+          }
+        } else {
+          const ownContext = getOwnHostContext(namespaceURI);
+          context = getChildHostContextProd(ownContext, type);
+        }
+
+        break;
+      }
+  }
+
+  return context;
+}
+
+function getOwnHostContext(namespaceURI) {
+  switch (namespaceURI) {
+    case SVG_NAMESPACE:
+      return HostContextNamespaceSvg;
+
+    case MATH_NAMESPACE:
+      return HostContextNamespaceMath;
+
+    default:
+      return HostContextNamespaceNone;
+  }
+}
+
+function getChildHostContextProd(parentNamespace, type) {
+  if (parentNamespace === HostContextNamespaceNone) {
+    // No (or default) parent namespace: potential entry point.
+    switch (type) {
+      case 'svg':
+        return HostContextNamespaceSvg;
+
+      case 'math':
+        return HostContextNamespaceMath;
+
+      default:
+        return HostContextNamespaceNone;
+    }
+  }
+
+  if (parentNamespace === HostContextNamespaceSvg && type === 'foreignObject') {
+    // We're leaving SVG.
+    return HostContextNamespaceNone;
+  } // By default, pass namespace below.
+
+
+  return parentNamespace;
+}
+
+function getChildHostContext(parentHostContext, type) {
+
+  const parentNamespace = parentHostContext;
+  return getChildHostContextProd(parentNamespace, type);
+}
+function getPublicInstance(instance) {
+  return instance;
+}
+function prepareForCommit(containerInfo) {
+  eventsEnabled = isEnabled();
+  selectionInformation = getSelectionInformation();
+  let activeInstance = null;
+
+  setEnabled(false);
+  return activeInstance;
+}
+function resetAfterCommit(containerInfo) {
+  restoreSelection(selectionInformation);
+  setEnabled(eventsEnabled);
+  eventsEnabled = null;
+  selectionInformation = null;
+}
+function createHoistableInstance(type, props, rootContainerInstance, internalInstanceHandle) {
+  const ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
+  const domElement = ownerDocument.createElement(type);
+  precacheFiberNode(internalInstanceHandle, domElement);
+  updateFiberProps(domElement, props);
+  setInitialProperties(domElement, type, props);
+  markNodeAsHoistable(domElement);
+  return domElement;
+}
+function createInstance(type, props, rootContainerInstance, hostContext, internalInstanceHandle) {
+  let hostContextProd;
+
+  {
+    hostContextProd = hostContext;
+  }
+
+  const ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
+  let domElement;
+
+  switch (hostContextProd) {
+    case HostContextNamespaceSvg:
+      domElement = ownerDocument.createElementNS(SVG_NAMESPACE, type);
+      break;
+
+    case HostContextNamespaceMath:
+      domElement = ownerDocument.createElementNS(MATH_NAMESPACE, type);
+      break;
+
+    default:
+      switch (type) {
+        case 'svg':
+          {
+            domElement = ownerDocument.createElementNS(SVG_NAMESPACE, type);
+            break;
+          }
+
+        case 'math':
+          {
+            domElement = ownerDocument.createElementNS(MATH_NAMESPACE, type);
+            break;
+          }
+
+        case 'script':
+          {
+            // Create the script via .innerHTML so its "parser-inserted" flag is
+            // set to true and it does not execute
+            const div = ownerDocument.createElement('div');
+
+            div.innerHTML = '<script><' + '/script>'; // eslint-disable-line
+            // This is guaranteed to yield a script element.
+
+            const firstChild = div.firstChild;
+            domElement = div.removeChild(firstChild);
+            break;
+          }
+
+        case 'select':
+          {
+            if (typeof props.is === 'string') {
+              domElement = ownerDocument.createElement('select', {
+                is: props.is
+              });
+            } else {
+              // Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.
+              // See discussion in https://github.com/facebook/react/pull/6896
+              // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
+              domElement = ownerDocument.createElement('select');
+            }
+
+            if (props.multiple) {
+              domElement.multiple = true;
+            } else if (props.size) {
+              // Setting a size greater than 1 causes a select to behave like `multiple=true`, where
+              // it is possible that no option is selected.
+              //
+              // This is only necessary when a select in "single selection mode".
+              domElement.size = props.size;
+            }
+
+            break;
+          }
+
+        default:
+          {
+            if (typeof props.is === 'string') {
+              domElement = ownerDocument.createElement(type, {
+                is: props.is
+              });
+            } else {
+              // Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.
+              // See discussion in https://github.com/facebook/react/pull/6896
+              // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
+              domElement = ownerDocument.createElement(type);
+            }
+          }
+      }
+
+  }
+
+  precacheFiberNode(internalInstanceHandle, domElement);
+  updateFiberProps(domElement, props);
+  return domElement;
+}
+function appendInitialChild(parentInstance, child) {
+  parentInstance.appendChild(child);
+}
+function finalizeInitialChildren(domElement, type, props, hostContext) {
+  setInitialProperties(domElement, type, props);
+
+  switch (type) {
+    case 'button':
+    case 'input':
+    case 'select':
+    case 'textarea':
+      return !!props.autoFocus;
+
+    case 'img':
+      return true;
+
+    default:
+      return false;
+  }
+}
+function shouldSetTextContent(type, props) {
+  return type === 'textarea' || type === 'noscript' || typeof props.children === 'string' || typeof props.children === 'number' || typeof props.dangerouslySetInnerHTML === 'object' && props.dangerouslySetInnerHTML !== null && props.dangerouslySetInnerHTML.__html != null;
+}
+function createTextInstance(text, rootContainerInstance, hostContext, internalInstanceHandle) {
+
+  const textNode = getOwnerDocumentFromRootContainer(rootContainerInstance).createTextNode(text);
+  precacheFiberNode(internalInstanceHandle, textNode);
+  return textNode;
+}
+function getCurrentEventPriority() {
+  const currentEvent = window.event;
+
+  if (currentEvent === undefined) {
+    return DefaultEventPriority;
+  }
+
+  return getEventPriority(currentEvent.type);
+}
+let currentPopstateTransitionEvent = null;
+function shouldAttemptEagerTransition() {
+  const event = window.event;
+
+  if (event && event.type === 'popstate') {
+    // This is a popstate event. Attempt to render any transition during this
+    // event synchronously. Unless we already attempted during this event.
+    if (event === currentPopstateTransitionEvent) {
+      // We already attempted to render this popstate transition synchronously.
+      // Any subsequent attempts must have happened as the result of a derived
+      // update, like startTransition inside useEffect, or useDV. Switch back to
+      // the default behavior for all remaining transitions during the current
+      // popstate event.
+      return false;
+    } else {
+      // Cache the current event in case a derived transition is scheduled.
+      // (Refer to previous branch.)
+      currentPopstateTransitionEvent = event;
+      return true;
+    }
+  } // We're not inside a popstate event.
+
+
+  currentPopstateTransitionEvent = null;
+  return false;
+}
+// if a component just imports ReactDOM (e.g. for findDOMNode).
+// Some environments might not have setTimeout or clearTimeout.
+
+const scheduleTimeout = typeof setTimeout === 'function' ? setTimeout : undefined;
+const cancelTimeout = typeof clearTimeout === 'function' ? clearTimeout : undefined;
+const noTimeout = -1;
+const localPromise = typeof Promise === 'function' ? Promise : undefined;
+function preparePortalMount(portalInstance) {
+  listenToAllSupportedEvents(portalInstance);
+}
+const scheduleMicrotask = typeof queueMicrotask === 'function' ? queueMicrotask : typeof localPromise !== 'undefined' ? callback => localPromise.resolve(null).then(callback).catch(handleErrorInNextTick) : scheduleTimeout; // TODO: Determine the best fallback here.
+
+function handleErrorInNextTick(error) {
+  setTimeout(() => {
+    throw error;
+  });
+} // -------------------
+function commitMount(domElement, type, newProps, internalInstanceHandle) {
+  // Despite the naming that might imply otherwise, this method only
+  // fires if there is an `Update` effect scheduled during mounting.
+  // This happens if `finalizeInitialChildren` returns `true` (which it
+  // does to implement the `autoFocus` attribute on the client). But
+  // there are also other cases when this might happen (such as patching
+  // up text content during hydration mismatch). So we'll check this again.
+  switch (type) {
+    case 'button':
+    case 'input':
+    case 'select':
+    case 'textarea':
+      if (newProps.autoFocus) {
+        domElement.focus();
+      }
+
+      return;
+
+    case 'img':
+      {
+        if (newProps.src) {
+          domElement.src = newProps.src;
+        }
+
+        return;
+      }
+  }
+}
+function commitUpdate(domElement, updatePayload, type, oldProps, newProps, internalInstanceHandle) {
+  // Diff and update the properties.
+  updateProperties(domElement, type, oldProps, newProps); // Update the props handle so that we know which props are the ones with
+  // with current event handlers.
+
+  updateFiberProps(domElement, newProps);
+}
+function resetTextContent(domElement) {
+  setTextContent(domElement, '');
+}
+function commitTextUpdate(textInstance, oldText, newText) {
+  textInstance.nodeValue = newText;
+}
+function appendChild(parentInstance, child) {
+  parentInstance.appendChild(child);
+}
+function appendChildToContainer(container, child) {
+  let parentNode;
+
+  if (container.nodeType === COMMENT_NODE) {
+    parentNode = container.parentNode;
+    parentNode.insertBefore(child, container);
+  } else {
+    parentNode = container;
+    parentNode.appendChild(child);
+  } // This container might be used for a portal.
+  // If something inside a portal is clicked, that click should bubble
+  // through the React tree. However, on Mobile Safari the click would
+  // never bubble through the *DOM* tree unless an ancestor with onclick
+  // event exists. So we wouldn't see it and dispatch it.
+  // This is why we ensure that non React root containers have inline onclick
+  // defined.
+  // https://github.com/facebook/react/issues/11918
+
+
+  const reactRootContainer = container._reactRootContainer;
+
+  if ((reactRootContainer === null || reactRootContainer === undefined) && parentNode.onclick === null) {
+    // TODO: This cast may not be sound for SVG, MathML or custom elements.
+    trapClickOnNonInteractiveElement(parentNode);
+  }
+}
+function insertBefore(parentInstance, child, beforeChild) {
+  parentInstance.insertBefore(child, beforeChild);
+}
+function insertInContainerBefore(container, child, beforeChild) {
+  if (container.nodeType === COMMENT_NODE) {
+    container.parentNode.insertBefore(child, beforeChild);
+  } else {
+    container.insertBefore(child, beforeChild);
+  }
+}
+
+function removeChild(parentInstance, child) {
+  parentInstance.removeChild(child);
+}
+function removeChildFromContainer(container, child) {
+  if (container.nodeType === COMMENT_NODE) {
+    container.parentNode.removeChild(child);
+  } else {
+    container.removeChild(child);
+  }
+}
+function clearSuspenseBoundary(parentInstance, suspenseInstance) {
+  let node = suspenseInstance; // Delete all nodes within this suspense boundary.
+  // There might be nested nodes so we need to keep track of how
+  // deep we are and only break out when we're back on top.
+
+  let depth = 0;
+
+  do {
+    const nextNode = node.nextSibling;
+    parentInstance.removeChild(node);
+
+    if (nextNode && nextNode.nodeType === COMMENT_NODE) {
+      const data = nextNode.data;
+
+      if (data === SUSPENSE_END_DATA) {
+        if (depth === 0) {
+          parentInstance.removeChild(nextNode); // Retry if any event replaying was blocked on this.
+
+          retryIfBlockedOn(suspenseInstance);
+          return;
+        } else {
+          depth--;
+        }
+      } else if (data === SUSPENSE_START_DATA || data === SUSPENSE_PENDING_START_DATA || data === SUSPENSE_FALLBACK_START_DATA) {
+        depth++;
+      }
+    } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+    node = nextNode;
+  } while (node); // TODO: Warn, we didn't find the end comment boundary.
+  // Retry if any event replaying was blocked on this.
+
+
+  retryIfBlockedOn(suspenseInstance);
+}
+function clearSuspenseBoundaryFromContainer(container, suspenseInstance) {
+  if (container.nodeType === COMMENT_NODE) {
+    clearSuspenseBoundary(container.parentNode, suspenseInstance);
+  } else if (container.nodeType === ELEMENT_NODE) {
+    clearSuspenseBoundary(container, suspenseInstance);
+  } else ; // Retry if any event replaying was blocked on this.
+
+
+  retryIfBlockedOn(container);
+}
+function hideInstance(instance) {
+  // TODO: Does this work for all element types? What about MathML? Should we
+  // pass host context to this method?
+  instance = instance;
+  const style = instance.style; // $FlowFixMe[method-unbinding]
+
+  if (typeof style.setProperty === 'function') {
+    style.setProperty('display', 'none', 'important');
+  } else {
+    style.display = 'none';
+  }
+}
+function hideTextInstance(textInstance) {
+  textInstance.nodeValue = '';
+}
+function unhideInstance(instance, props) {
+  instance = instance;
+  const styleProp = props[STYLE];
+  const display = styleProp !== undefined && styleProp !== null && styleProp.hasOwnProperty('display') ? styleProp.display : null;
+  instance.style.display = display == null || typeof display === 'boolean' ? '' : // The value would've errored already if it wasn't safe.
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  ('' + display).trim();
+}
+function unhideTextInstance(textInstance, text) {
+  textInstance.nodeValue = text;
+}
+function clearContainer(container) {
+  {
+    const nodeType = container.nodeType;
+
+    if (nodeType === DOCUMENT_NODE) {
+      clearContainerSparingly(container);
+    } else if (nodeType === ELEMENT_NODE) {
+      switch (container.nodeName) {
+        case 'HEAD':
+        case 'HTML':
+        case 'BODY':
+          clearContainerSparingly(container);
+          return;
+
+        default:
+          {
+            container.textContent = '';
+          }
+      }
+    }
+  }
+}
+
+function clearContainerSparingly(container) {
+  let node;
+  let nextNode = container.firstChild;
+
+  if (nextNode && nextNode.nodeType === DOCUMENT_TYPE_NODE) {
+    nextNode = nextNode.nextSibling;
+  }
+
+  while (nextNode) {
+    node = nextNode;
+    nextNode = nextNode.nextSibling;
+
+    switch (node.nodeName) {
+      case 'HTML':
+      case 'HEAD':
+      case 'BODY':
+        {
+          const element = node;
+          clearContainerSparingly(element); // If these singleton instances had previously been rendered with React they
+          // may still hold on to references to the previous fiber tree. We detatch them
+          // prospectively to reset them to a baseline starting state since we cannot create
+          // new instances.
+
+          detachDeletedInstance(element);
+          continue;
+        }
+      // Script tags are retained to avoid an edge case bug. Normally scripts will execute if they
+      // are ever inserted into the DOM. However when streaming if a script tag is opened but not
+      // yet closed some browsers create and insert the script DOM Node but the script cannot execute
+      // yet until the closing tag is parsed. If something causes React to call clearContainer while
+      // this DOM node is in the document but not yet executable the DOM node will be removed from the
+      // document and when the script closing tag comes in the script will not end up running. This seems
+      // to happen in Chrome/Firefox but not Safari at the moment though this is not necessarily specified
+      // behavior so it could change in future versions of browsers. While leaving all scripts is broader
+      // than strictly necessary this is the least amount of additional code to avoid this breaking
+      // edge case.
+      //
+      // Style tags are retained because they may likely come from 3rd party scripts and extensions
+
+      case 'SCRIPT':
+      case 'STYLE':
+        {
+          continue;
+        }
+      // Stylesheet tags are retained because tehy may likely come from 3rd party scripts and extensions
+
+      case 'LINK':
+        {
+          if (node.rel.toLowerCase() === 'stylesheet') {
+            continue;
+          }
+        }
+    }
+
+    container.removeChild(node);
+  }
+
+  return;
+} // Making this so we can eventually move all of the instance caching to the commit phase.
+function isHydratableText(text) {
+  return text !== '';
+}
+function canHydrateInstance(instance, type, props, inRootOrSingleton) {
+  while (instance.nodeType === ELEMENT_NODE) {
+    const element = instance;
+    const anyProps = props;
+
+    if (element.nodeName.toLowerCase() !== type.toLowerCase()) {
+      if (!inRootOrSingleton || !enableHostSingletons) {
+        // Usually we error for mismatched tags.
+        if (element.nodeName === 'INPUT' && element.type === 'hidden') ; else {
+          return null;
+        }
+      } // In root or singleton parents we skip past mismatched instances.
+
+    } else if (!inRootOrSingleton || !enableHostSingletons) {
+      // Match
+      if (type === 'input' && element.type === 'hidden') {
+
+        const name = anyProps.name == null ? null : '' + anyProps.name;
+
+        if (anyProps.type !== 'hidden' || element.getAttribute('name') !== name) ; else {
+          return element;
+        }
+      } else {
+        return element;
+      }
+    } else if (isMarkedHoistable(element)) ; else {
+      // We have an Element with the right type.
+      // We are going to try to exclude it if we can definitely identify it as a hoisted Node or if
+      // we can guess that the node is likely hoisted or was inserted by a 3rd party script or browser extension
+      // using high entropy attributes for certain types. This technique will fail for strange insertions like
+      // extension prepending <div> in the <body> but that already breaks before and that is an edge case.
+      switch (type) {
+        // case 'title':
+        //We assume all titles are matchable. You should only have one in the Document, at least in a hoistable scope
+        // and if you are a HostComponent with type title we must either be in an <svg> context or this title must have an `itemProp` prop.
+        case 'meta':
+          {
+            // The only way to opt out of hoisting meta tags is to give it an itemprop attribute. We assume there will be
+            // not 3rd party meta tags that are prepended, accepting the cases where this isn't true because meta tags
+            // are usually only functional for SSR so even in a rare case where we did bind to an injected tag the runtime
+            // implications are minimal
+            if (!element.hasAttribute('itemprop')) {
+              // This is a Hoistable
+              break;
+            }
+
+            return element;
+          }
+
+        case 'link':
+          {
+            // Links come in many forms and we do expect 3rd parties to inject them into <head> / <body>. We exclude known resources
+            // and then use high-entroy attributes like href which are almost always used and almost always unique to filter out unlikely
+            // matches.
+            const rel = element.getAttribute('rel');
+
+            if (rel === 'stylesheet' && element.hasAttribute('data-precedence')) {
+              // This is a stylesheet resource
+              break;
+            } else if (rel !== anyProps.rel || element.getAttribute('href') !== (anyProps.href == null ? null : anyProps.href) || element.getAttribute('crossorigin') !== (anyProps.crossOrigin == null ? null : anyProps.crossOrigin) || element.getAttribute('title') !== (anyProps.title == null ? null : anyProps.title)) {
+              // rel + href should usually be enough to uniquely identify a link however crossOrigin can vary for rel preconnect
+              // and title could vary for rel alternate
+              break;
+            }
+
+            return element;
+          }
+
+        case 'style':
+          {
+            // Styles are hard to match correctly. We can exclude known resources but otherwise we accept the fact that a non-hoisted style tags
+            // in <head> or <body> are likely never going to be unmounted given their position in the document and the fact they likely hold global styles
+            if (element.hasAttribute('data-precedence')) {
+              // This is a style resource
+              break;
+            }
+
+            return element;
+          }
+
+        case 'script':
+          {
+            // Scripts are a little tricky, we exclude known resources and then similar to links try to use high-entropy attributes
+            // to reject poor matches. One challenge with scripts are inline scripts. We don't attempt to check text content which could
+            // in theory lead to a hydration error later if a 3rd party injected an inline script before the React rendered nodes.
+            // Falling back to client rendering if this happens should be seemless though so we will try this hueristic and revisit later
+            // if we learn it is problematic
+            const srcAttr = element.getAttribute('src');
+
+            if (srcAttr !== (anyProps.src == null ? null : anyProps.src) || element.getAttribute('type') !== (anyProps.type == null ? null : anyProps.type) || element.getAttribute('crossorigin') !== (anyProps.crossOrigin == null ? null : anyProps.crossOrigin)) {
+              // This script is for a different src/type/crossOrigin. It may be a script resource
+              // or it may just be a mistmatch
+              if (srcAttr && element.hasAttribute('async') && !element.hasAttribute('itemprop')) {
+                // This is an async script resource
+                break;
+              }
+            }
+
+            return element;
+          }
+
+        default:
+          {
+            // We have excluded the most likely cases of mismatch between hoistable tags, 3rd party script inserted tags,
+            // and browser extension inserted tags. While it is possible this is not the right match it is a decent hueristic
+            // that should work in the vast majority of cases.
+            return element;
+          }
+      }
+    }
+
+    const nextInstance = getNextHydratableSibling(element);
+
+    if (nextInstance === null) {
+      break;
+    }
+
+    instance = nextInstance;
+  } // This is a suspense boundary or Text node or we got the end.
+  // Suspense Boundaries are never expected to be injected by 3rd parties. If we see one it should be matched
+  // and this is a hydration error.
+  // Text Nodes are also not expected to be injected by 3rd parties. This is less of a guarantee for <body>
+  // but it seems reasonable and conservative to reject this as a hydration error as well
+
+
+  return null;
+}
+function canHydrateTextInstance(instance, text, inRootOrSingleton) {
+  // Empty strings are not parsed by HTML so there won't be a correct match here.
+  if (text === '') return null;
+
+  while (instance.nodeType !== TEXT_NODE) {
+    if (instance.nodeType === ELEMENT_NODE && instance.nodeName === 'INPUT' && instance.type === 'hidden') ; else if (!inRootOrSingleton || !enableHostSingletons) {
+      return null;
+    }
+
+    const nextInstance = getNextHydratableSibling(instance);
+
+    if (nextInstance === null) {
+      return null;
+    }
+
+    instance = nextInstance;
+  } // This has now been refined to a text node.
+
+
+  return instance;
+}
+function canHydrateSuspenseInstance(instance, inRootOrSingleton) {
+  while (instance.nodeType !== COMMENT_NODE) {
+    if (!inRootOrSingleton || !enableHostSingletons) {
+      return null;
+    }
+
+    const nextInstance = getNextHydratableSibling(instance);
+
+    if (nextInstance === null) {
+      return null;
+    }
+
+    instance = nextInstance;
+  } // This has now been refined to a suspense node.
+
+
+  return instance;
+}
+function isSuspenseInstancePending(instance) {
+  return instance.data === SUSPENSE_PENDING_START_DATA;
+}
+function isSuspenseInstanceFallback(instance) {
+  return instance.data === SUSPENSE_FALLBACK_START_DATA;
+}
+function getSuspenseInstanceFallbackErrorDetails(instance) {
+  const dataset = instance.nextSibling && instance.nextSibling.dataset;
+  let digest;
+
+  if (dataset) {
+    digest = dataset.dgst;
+  }
+
+  {
+    // Object gets DCE'd if constructed in tail position and matches callsite destructuring
+    return {
+      digest
+    };
+  }
+}
+function registerSuspenseInstanceRetry(instance, callback) {
+  instance._reactRetry = callback;
+}
+function canHydrateFormStateMarker(instance, inRootOrSingleton) {
+  while (instance.nodeType !== COMMENT_NODE) {
+    if (!inRootOrSingleton || !enableHostSingletons) {
+      return null;
+    }
+
+    const nextInstance = getNextHydratableSibling(instance);
+
+    if (nextInstance === null) {
+      return null;
+    }
+
+    instance = nextInstance;
+  }
+
+  const nodeData = instance.data;
+
+  if (nodeData === FORM_STATE_IS_MATCHING || nodeData === FORM_STATE_IS_NOT_MATCHING) {
+    const markerInstance = instance;
+    return markerInstance;
+  }
+
+  return null;
+}
+function isFormStateMarkerMatching(markerInstance) {
+  return markerInstance.data === FORM_STATE_IS_MATCHING;
+}
+
+function getNextHydratable(node) {
+  // Skip non-hydratable nodes.
+  for (; node != null; node = node.nextSibling) {
+    const nodeType = node.nodeType;
+
+    if (nodeType === ELEMENT_NODE || nodeType === TEXT_NODE) {
+      break;
+    }
+
+    if (nodeType === COMMENT_NODE) {
+      const nodeData = node.data;
+
+      if (nodeData === SUSPENSE_START_DATA || nodeData === SUSPENSE_FALLBACK_START_DATA || nodeData === SUSPENSE_PENDING_START_DATA || (nodeData === FORM_STATE_IS_MATCHING || nodeData === FORM_STATE_IS_NOT_MATCHING)) {
+        break;
+      }
+
+      if (nodeData === SUSPENSE_END_DATA) {
+        return null;
+      }
+    }
+  }
+
+  return node;
+}
+
+function getNextHydratableSibling(instance) {
+  return getNextHydratable(instance.nextSibling);
+}
+function getFirstHydratableChild(parentInstance) {
+  return getNextHydratable(parentInstance.firstChild);
+}
+function getFirstHydratableChildWithinContainer(parentContainer) {
+  return getNextHydratable(parentContainer.firstChild);
+}
+function getFirstHydratableChildWithinSuspenseInstance(parentInstance) {
+  return getNextHydratable(parentInstance.nextSibling);
+}
+function hydrateInstance(instance, type, props, hostContext, internalInstanceHandle, shouldWarnDev) {
+  precacheFiberNode(internalInstanceHandle, instance); // TODO: Possibly defer this until the commit phase where all the events
+  // get attached.
+
+  updateFiberProps(instance, props); // TODO: Temporary hack to check if we're in a concurrent root. We can delete
+  // when the legacy root API is removed.
+
+  const isConcurrentMode = (internalInstanceHandle.mode & ConcurrentMode) !== NoMode;
+  diffHydratedProperties(instance, type, props, isConcurrentMode);
+}
+function hydrateTextInstance(textInstance, text, internalInstanceHandle, shouldWarnDev) {
+  precacheFiberNode(internalInstanceHandle, textInstance); // TODO: Temporary hack to check if we're in a concurrent root. We can delete
+  return diffHydratedText(textInstance, text);
+}
+function hydrateSuspenseInstance(suspenseInstance, internalInstanceHandle) {
+  precacheFiberNode(internalInstanceHandle, suspenseInstance);
+}
+function getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance) {
+  let node = suspenseInstance.nextSibling; // Skip past all nodes within this suspense boundary.
+  // There might be nested nodes so we need to keep track of how
+  // deep we are and only break out when we're back on top.
+
+  let depth = 0;
+
+  while (node) {
+    if (node.nodeType === COMMENT_NODE) {
+      const data = node.data;
+
+      if (data === SUSPENSE_END_DATA) {
+        if (depth === 0) {
+          return getNextHydratableSibling(node);
+        } else {
+          depth--;
+        }
+      } else if (data === SUSPENSE_START_DATA || data === SUSPENSE_FALLBACK_START_DATA || data === SUSPENSE_PENDING_START_DATA) {
+        depth++;
+      }
+    }
+
+    node = node.nextSibling;
+  } // TODO: Warn, we didn't find the end comment boundary.
+
+
+  return null;
+} // Returns the SuspenseInstance if this node is a direct child of a
+// SuspenseInstance. I.e. if its previous sibling is a Comment with
+// SUSPENSE_x_START_DATA. Otherwise, null.
+
+function getParentSuspenseInstance(targetInstance) {
+  let node = targetInstance.previousSibling; // Skip past all nodes within this suspense boundary.
+  // There might be nested nodes so we need to keep track of how
+  // deep we are and only break out when we're back on top.
+
+  let depth = 0;
+
+  while (node) {
+    if (node.nodeType === COMMENT_NODE) {
+      const data = node.data;
+
+      if (data === SUSPENSE_START_DATA || data === SUSPENSE_FALLBACK_START_DATA || data === SUSPENSE_PENDING_START_DATA) {
+        if (depth === 0) {
+          return node;
+        } else {
+          depth--;
+        }
+      } else if (data === SUSPENSE_END_DATA) {
+        depth++;
+      }
+    }
+
+    node = node.previousSibling;
+  }
+
+  return null;
+}
+function commitHydratedContainer(container) {
+  // Retry if any event replaying was blocked on this.
+  retryIfBlockedOn(container);
+}
+function commitHydratedSuspenseInstance(suspenseInstance) {
+  // Retry if any event replaying was blocked on this.
+  retryIfBlockedOn(suspenseInstance);
+}
+function shouldDeleteUnhydratedTailInstances(parentType) {
+  return (parentType !== 'form' && parentType !== 'button');
+}
+function didNotMatchHydratedContainerTextInstance(parentContainer, textInstance, text, isConcurrentMode, shouldWarnDev) {
+  checkForUnmatchedText(textInstance.nodeValue, text, isConcurrentMode);
+}
+function didNotMatchHydratedTextInstance(parentType, parentProps, parentInstance, textInstance, text, isConcurrentMode, shouldWarnDev) {
+  if (parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
+    checkForUnmatchedText(textInstance.nodeValue, text, isConcurrentMode);
+  }
+}
+function isHostSingletonType(type) {
+  return type === 'html' || type === 'head' || type === 'body';
+}
+function resolveSingletonInstance(type, props, rootContainerInstance, hostContext, validateDOMNestingDev) {
+
+  const ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
+
+  switch (type) {
+    case 'html':
+      {
+        const documentElement = ownerDocument.documentElement;
+
+        if (!documentElement) {
+          throw Error(formatProdErrorMessage(452));
+        }
+
+        return documentElement;
+      }
+
+    case 'head':
+      {
+        const head = ownerDocument.head;
+
+        if (!head) {
+          throw Error(formatProdErrorMessage(453));
+        }
+
+        return head;
+      }
+
+    case 'body':
+      {
+        const body = ownerDocument.body;
+
+        if (!body) {
+          throw Error(formatProdErrorMessage(454));
+        }
+
+        return body;
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(451));
+      }
+  }
+}
+function acquireSingletonInstance(type, props, instance, internalInstanceHandle) {
+
+  const attributes = instance.attributes;
+
+  while (attributes.length) {
+    instance.removeAttributeNode(attributes[0]);
+  }
+
+  setInitialProperties(instance, type, props);
+  precacheFiberNode(internalInstanceHandle, instance);
+  updateFiberProps(instance, props);
+}
+function releaseSingletonInstance(instance) {
+  const attributes = instance.attributes;
+
+  while (attributes.length) {
+    instance.removeAttributeNode(attributes[0]);
+  }
+
+  detachDeletedInstance(instance);
+}
+function clearSingleton(instance) {
+  const element = instance;
+  let node = element.firstChild;
+
+  while (node) {
+    const nextNode = node.nextSibling;
+    const nodeName = node.nodeName;
+
+    if (isMarkedHoistable(node) || nodeName === 'HEAD' || nodeName === 'BODY' || nodeName === 'SCRIPT' || nodeName === 'STYLE' || nodeName === 'LINK' && node.rel.toLowerCase() === 'stylesheet') ; else {
+      element.removeChild(node);
+    }
+
+    node = nextNode;
+  }
+
+  return;
+} // -------------------
+const NotLoaded =
+/*       */
+0b000;
+const Loaded =
+/*          */
+0b001;
+const Errored =
+/*         */
+0b010;
+const Settled =
+/*         */
+0b011;
+const Inserted =
+/*        */
+0b100;
+function prepareToCommitHoistables() {
+  tagCaches = null;
+} // global collections of Resources
+
+const preloadPropsMap = new Map();
+const preconnectsSet = new Set(); // getRootNode is missing from IE and old jsdom versions
+
+function getHoistableRoot(container) {
+  // $FlowFixMe[method-unbinding]
+  return typeof container.getRootNode === 'function' ?
+  /* $FlowFixMe[incompatible-return] Flow types this as returning a `Node`,
+   * but it's either a `Document` or `ShadowRoot`. */
+  container.getRootNode() : container.ownerDocument;
+}
+
+function getCurrentResourceRoot() {
+  const currentContainer = getCurrentRootHostContainer();
+  return currentContainer ? getHoistableRoot(currentContainer) : null;
+}
+
+function getDocumentFromRoot(root) {
+  return root.ownerDocument || root;
+} // We want this to be the default dispatcher on ReactDOMSharedInternals but we don't want to mutate
+// internals in Module scope. Instead we export it and Internals will import it. There is already a cycle
+// from Internals -> ReactDOM -> HostConfig -> Internals so this doesn't introduce a new one.
+
+
+const ReactDOMClientDispatcher = {
+  prefetchDNS: prefetchDNS$1,
+  preconnect: preconnect$1,
+  preload: preload$1,
+  preloadModule: preloadModule$1,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+}; // We expect this to get inlined. It is a function mostly to communicate the special nature of
+// how we resolve the HoistableRoot for ReactDOM.pre*() methods. Because we support calling
+// these methods outside of render there is no way to know which Document or ShadowRoot is 'scoped'
+// and so we have to fall back to something universal. Currently we just refer to the global document.
+// This is notable because nowhere else in ReactDOM do we actually reference the global document or window
+// because we may be rendering inside an iframe.
+
+function getDocumentForImperativeFloatMethods() {
+  return document;
+}
+
+function preconnectAs(rel, href, crossOrigin) {
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (typeof href === 'string' && href) {
+    const limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+    let key = "link[rel=\"" + rel + "\"][href=\"" + limitedEscapedHref + "\"]";
+
+    if (typeof crossOrigin === 'string') {
+      key += "[crossorigin=\"" + crossOrigin + "\"]";
+    }
+
+    if (!preconnectsSet.has(key)) {
+      preconnectsSet.add(key);
+      const preconnectProps = {
+        rel,
+        crossOrigin,
+        href
+      };
+
+      if (null === ownerDocument.querySelector(key)) {
+        const instance = ownerDocument.createElement('link');
+        setInitialProperties(instance, 'link', preconnectProps);
+        markNodeAsHoistable(instance);
+        ownerDocument.head.appendChild(instance);
+      }
+    }
+  }
+}
+
+function prefetchDNS$1(href) {
+
+  preconnectAs('dns-prefetch', href, null);
+}
+
+function preconnect$1(href, crossOrigin) {
+
+  preconnectAs('preconnect', href, crossOrigin);
+}
+
+function preload$1(href, as, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (href && as && ownerDocument) {
+    let preloadSelector = "link[rel=\"preload\"][as=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(as) + "\"]";
+
+    if (as === 'image') {
+      if (options && options.imageSrcSet) {
+        preloadSelector += "[imagesrcset=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(options.imageSrcSet) + "\"]";
+
+        if (typeof options.imageSizes === 'string') {
+          preloadSelector += "[imagesizes=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(options.imageSizes) + "\"]";
+        }
+      } else {
+        preloadSelector += "[href=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(href) + "\"]";
+      }
+    } else {
+      preloadSelector += "[href=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(href) + "\"]";
+    } // Some preloads are keyed under their selector. This happens when the preload is for
+    // an arbitrary type. Other preloads are keyed under the resource key they represent a preload for.
+    // Here we figure out which key to use to determine if we have a preload already.
+
+
+    let key = preloadSelector;
+
+    switch (as) {
+      case 'style':
+        key = getStyleKey(href);
+        break;
+
+      case 'script':
+        key = getScriptKey(href);
+        break;
+    }
+
+    if (!preloadPropsMap.has(key)) {
+      const preloadProps = assign({
+        rel: 'preload',
+        // There is a bug in Safari where imageSrcSet is not respected on preload links
+        // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+        // This harms older browers that do not support imageSrcSet by making their preloads not work
+        // but this population is shrinking fast and is already small so we accept this tradeoff.
+        href: as === 'image' && options && options.imageSrcSet ? undefined : href,
+        as
+      }, options);
+
+      preloadPropsMap.set(key, preloadProps);
+
+      if (null === ownerDocument.querySelector(preloadSelector)) {
+        if (as === 'style' && ownerDocument.querySelector(getStylesheetSelectorFromKey(key))) {
+          // We already have a stylesheet for this key. We don't need to preload it.
+          return;
+        } else if (as === 'script' && ownerDocument.querySelector(getScriptSelectorFromKey(key))) {
+          // We already have a stylesheet for this key. We don't need to preload it.
+          return;
+        }
+
+        const instance = ownerDocument.createElement('link');
+        setInitialProperties(instance, 'link', preloadProps);
+        markNodeAsHoistable(instance);
+        ownerDocument.head.appendChild(instance);
+      }
+    }
+  }
+}
+
+function preloadModule$1(href, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (href) {
+    const as = options && typeof options.as === 'string' ? options.as : 'script';
+    const preloadSelector = "link[rel=\"modulepreload\"][as=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(as) + "\"][href=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(href) + "\"]"; // Some preloads are keyed under their selector. This happens when the preload is for
+    // an arbitrary type. Other preloads are keyed under the resource key they represent a preload for.
+    // Here we figure out which key to use to determine if we have a preload already.
+
+    let key = preloadSelector;
+
+    switch (as) {
+      case 'audioworklet':
+      case 'paintworklet':
+      case 'serviceworker':
+      case 'sharedworker':
+      case 'worker':
+      case 'script':
+        {
+          key = getScriptKey(href);
+          break;
+        }
+    }
+
+    if (!preloadPropsMap.has(key)) {
+      const props = assign({
+        rel: 'modulepreload',
+        href
+      }, options);
+
+      preloadPropsMap.set(key, props);
+
+      if (null === ownerDocument.querySelector(preloadSelector)) {
+        switch (as) {
+          case 'audioworklet':
+          case 'paintworklet':
+          case 'serviceworker':
+          case 'sharedworker':
+          case 'worker':
+          case 'script':
+            {
+              if (ownerDocument.querySelector(getScriptSelectorFromKey(key))) {
+                return;
+              }
+            }
+        }
+
+        const instance = ownerDocument.createElement('link');
+        setInitialProperties(instance, 'link', props);
+        markNodeAsHoistable(instance);
+        ownerDocument.head.appendChild(instance);
+      }
+    }
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (href) {
+    const styles = getResourcesFromRoot(ownerDocument).hoistableStyles;
+    const key = getStyleKey(href);
+    precedence = precedence || 'default'; // Check if this resource already exists
+
+    let resource = styles.get(key);
+
+    if (resource) {
+      // We can early return. The resource exists and there is nothing
+      // more to do
+      return;
+    }
+
+    const state = {
+      loading: NotLoaded,
+      preload: null
+    }; // Attempt to hydrate instance from DOM
+
+    let instance = ownerDocument.querySelector(getStylesheetSelectorFromKey(key));
+
+    if (instance) {
+      state.loading = Loaded | Inserted;
+    } else {
+      // Construct a new instance and insert it
+      const stylesheetProps = assign({
+        rel: 'stylesheet',
+        href,
+        'data-precedence': precedence
+      }, options);
+
+      const preloadProps = preloadPropsMap.get(key);
+
+      if (preloadProps) {
+        adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps);
+      }
+
+      const link = instance = ownerDocument.createElement('link');
+      markNodeAsHoistable(link);
+      setInitialProperties(link, 'link', stylesheetProps);
+      link._p = new Promise((resolve, reject) => {
+        link.onload = resolve;
+        link.onerror = reject;
+      });
+      link.addEventListener('load', () => {
+        state.loading |= Loaded;
+      });
+      link.addEventListener('error', () => {
+        state.loading |= Errored;
+      });
+      state.loading |= Inserted;
+      insertStylesheet(instance, precedence, ownerDocument);
+    } // Construct a Resource and cache it
+
+
+    resource = {
+      type: 'stylesheet',
+      instance,
+      count: 1,
+      state
+    };
+    styles.set(key, resource);
+    return;
+  }
+}
+
+function preinitScript(src, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (src) {
+    const scripts = getResourcesFromRoot(ownerDocument).hoistableScripts;
+    const key = getScriptKey(src); // Check if this resource already exists
+
+    let resource = scripts.get(key);
+
+    if (resource) {
+      // We can early return. The resource exists and there is nothing
+      // more to do
+      return;
+    } // Attempt to hydrate instance from DOM
+
+
+    let instance = ownerDocument.querySelector(getScriptSelectorFromKey(key));
+
+    if (!instance) {
+      // Construct a new instance and insert it
+      const scriptProps = assign({
+        src,
+        async: true
+      }, options); // Adopt certain preload props
+
+
+      const preloadProps = preloadPropsMap.get(key);
+
+      if (preloadProps) {
+        adoptPreloadPropsForScript(scriptProps, preloadProps);
+      }
+
+      instance = ownerDocument.createElement('script');
+      markNodeAsHoistable(instance);
+      setInitialProperties(instance, 'link', scriptProps);
+      ownerDocument.head.appendChild(instance);
+    } // Construct a Resource and cache it
+
+
+    resource = {
+      type: 'script',
+      instance,
+      count: 1,
+      state: null
+    };
+    scripts.set(key, resource);
+    return;
+  }
+}
+
+function preinitModuleScript(src, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (src) {
+    const scripts = getResourcesFromRoot(ownerDocument).hoistableScripts;
+    const key = getScriptKey(src); // Check if this resource already exists
+
+    let resource = scripts.get(key);
+
+    if (resource) {
+      // We can early return. The resource exists and there is nothing
+      // more to do
+      return;
+    } // Attempt to hydrate instance from DOM
+
+
+    let instance = ownerDocument.querySelector(getScriptSelectorFromKey(key));
+
+    if (!instance) {
+      // Construct a new instance and insert it
+      const scriptProps = assign({
+        src,
+        async: true,
+        type: 'module'
+      }, options); // Adopt certain preload props
+
+
+      const preloadProps = preloadPropsMap.get(key);
+
+      if (preloadProps) {
+        adoptPreloadPropsForScript(scriptProps, preloadProps);
+      }
+
+      instance = ownerDocument.createElement('script');
+      markNodeAsHoistable(instance);
+      setInitialProperties(instance, 'link', scriptProps);
+      ownerDocument.head.appendChild(instance);
+    } // Construct a Resource and cache it
+
+
+    resource = {
+      type: 'script',
+      instance,
+      count: 1,
+      state: null
+    };
+    scripts.set(key, resource);
+    return;
+  }
+} // This function is called in begin work and we should always have a currentDocument set
+
+
+function getResource(type, currentProps, pendingProps) {
+  const resourceRoot = getCurrentResourceRoot();
+
+  if (!resourceRoot) {
+    throw Error(formatProdErrorMessage(446));
+  }
+
+  switch (type) {
+    case 'meta':
+    case 'title':
+      {
+        return null;
+      }
+
+    case 'style':
+      {
+        if (typeof pendingProps.precedence === 'string' && typeof pendingProps.href === 'string') {
+          const key = getStyleKey(pendingProps.href);
+          const styles = getResourcesFromRoot(resourceRoot).hoistableStyles;
+          let resource = styles.get(key);
+
+          if (!resource) {
+            resource = {
+              type: 'style',
+              instance: null,
+              count: 0,
+              state: null
+            };
+            styles.set(key, resource);
+          }
+
+          return resource;
+        }
+
+        return {
+          type: 'void',
+          instance: null,
+          count: 0,
+          state: null
+        };
+      }
+
+    case 'link':
+      {
+        if (pendingProps.rel === 'stylesheet' && typeof pendingProps.href === 'string' && typeof pendingProps.precedence === 'string') {
+          const qualifiedProps = pendingProps;
+          const key = getStyleKey(qualifiedProps.href);
+          const styles = getResourcesFromRoot(resourceRoot).hoistableStyles;
+          let resource = styles.get(key);
+
+          if (!resource) {
+            // We asserted this above but Flow can't figure out that the type satisfies
+            const ownerDocument = getDocumentFromRoot(resourceRoot);
+            resource = {
+              type: 'stylesheet',
+              instance: null,
+              count: 0,
+              state: {
+                loading: NotLoaded,
+                preload: null
+              }
+            };
+            styles.set(key, resource);
+
+            if (!preloadPropsMap.has(key)) {
+              preloadStylesheet(ownerDocument, key, preloadPropsFromStylesheet(qualifiedProps), resource.state);
+            }
+          }
+
+          return resource;
+        }
+
+        return null;
+      }
+
+    case 'script':
+      {
+        if (typeof pendingProps.src === 'string' && pendingProps.async === true) {
+          const scriptProps = pendingProps;
+          const key = getScriptKey(scriptProps.src);
+          const scripts = getResourcesFromRoot(resourceRoot).hoistableScripts;
+          let resource = scripts.get(key);
+
+          if (!resource) {
+            resource = {
+              type: 'script',
+              instance: null,
+              count: 0,
+              state: null
+            };
+            scripts.set(key, resource);
+          }
+
+          return resource;
+        }
+
+        return {
+          type: 'void',
+          instance: null,
+          count: 0,
+          state: null
+        };
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(444, type));
+      }
+  }
+}
+
+function styleTagPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    'data-href': rawProps.href,
+    'data-precedence': rawProps.precedence,
+    href: null,
+    precedence: null
+  });
+}
+
+function getStyleKey(href) {
+  const limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+  return "href=\"" + limitedEscapedHref + "\"";
+}
+
+function getStyleTagSelector(href) {
+  const limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+  return "style[data-href~=\"" + limitedEscapedHref + "\"]";
+}
+
+function getStylesheetSelectorFromKey(key) {
+  return "link[rel=\"stylesheet\"][" + key + "]";
+}
+
+function getPreloadStylesheetSelectorFromKey(key) {
+  return "link[rel=\"preload\"][as=\"style\"][" + key + "]";
+}
+
+function stylesheetPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    'data-precedence': rawProps.precedence,
+    precedence: null
+  });
+}
+
+function preloadStylesheet(ownerDocument, key, preloadProps, state) {
+  preloadPropsMap.set(key, preloadProps);
+
+  if (!ownerDocument.querySelector(getStylesheetSelectorFromKey(key))) {
+    // There is no matching stylesheet instance in the Document.
+    // We will insert a preload now to kick off loading because
+    // we expect this stylesheet to commit
+    const preloadEl = ownerDocument.querySelector(getPreloadStylesheetSelectorFromKey(key));
+
+    if (preloadEl) {
+      // If we find a preload already it was SSR'd and we won't have an actual
+      // loading state to track. For now we will just assume it is loaded
+      state.loading = Loaded;
+    } else {
+      const instance = ownerDocument.createElement('link');
+      state.preload = instance;
+      instance.addEventListener('load', () => state.loading |= Loaded);
+      instance.addEventListener('error', () => state.loading |= Errored);
+      setInitialProperties(instance, 'link', preloadProps);
+      markNodeAsHoistable(instance);
+      ownerDocument.head.appendChild(instance);
+    }
+  }
+}
+
+function preloadPropsFromStylesheet(props) {
+  return {
+    rel: 'preload',
+    as: 'style',
+    href: props.href,
+    crossOrigin: props.crossOrigin,
+    integrity: props.integrity,
+    media: props.media,
+    hrefLang: props.hrefLang,
+    referrerPolicy: props.referrerPolicy
+  };
+}
+
+function getScriptKey(src) {
+  const limitedEscapedSrc = escapeSelectorAttributeValueInsideDoubleQuotes(src);
+  return "[src=\"" + limitedEscapedSrc + "\"]";
+}
+
+function getScriptSelectorFromKey(key) {
+  return 'script[async]' + key;
+}
+
+function acquireResource(hoistableRoot, resource, props) {
+  resource.count++;
+
+  if (resource.instance === null) {
+    switch (resource.type) {
+      case 'style':
+        {
+          const qualifiedProps = props; // Attempt to hydrate instance from DOM
+
+          let instance = hoistableRoot.querySelector(getStyleTagSelector(qualifiedProps.href));
+
+          if (instance) {
+            resource.instance = instance;
+            markNodeAsHoistable(instance);
+            return instance;
+          }
+
+          const styleProps = styleTagPropsFromRawProps(props);
+          const ownerDocument = getDocumentFromRoot(hoistableRoot);
+          instance = ownerDocument.createElement('style');
+          markNodeAsHoistable(instance);
+          setInitialProperties(instance, 'style', styleProps); // TODO: `style` does not have loading state for tracking insertions. I
+          // guess because these aren't suspensey? Not sure whether this is a
+          // factoring smell.
+          // resource.state.loading |= Inserted;
+
+          insertStylesheet(instance, qualifiedProps.precedence, hoistableRoot);
+          resource.instance = instance;
+          return instance;
+        }
+
+      case 'stylesheet':
+        {
+          // This typing is enforce by `getResource`. If we change the logic
+          // there for what qualifies as a stylesheet resource we need to ensure
+          // this cast still makes sense;
+          const qualifiedProps = props;
+          const key = getStyleKey(qualifiedProps.href); // Attempt to hydrate instance from DOM
+
+          let instance = hoistableRoot.querySelector(getStylesheetSelectorFromKey(key));
+
+          if (instance) {
+            resource.state.loading |= Inserted;
+            resource.instance = instance;
+            markNodeAsHoistable(instance);
+            return instance;
+          }
+
+          const stylesheetProps = stylesheetPropsFromRawProps(props);
+          const preloadProps = preloadPropsMap.get(key);
+
+          if (preloadProps) {
+            adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps);
+          } // Construct and insert a new instance
+
+
+          const ownerDocument = getDocumentFromRoot(hoistableRoot);
+          instance = ownerDocument.createElement('link');
+          markNodeAsHoistable(instance);
+          const linkInstance = instance;
+          linkInstance._p = new Promise((resolve, reject) => {
+            linkInstance.onload = resolve;
+            linkInstance.onerror = reject;
+          });
+          setInitialProperties(instance, 'link', stylesheetProps);
+          resource.state.loading |= Inserted;
+          insertStylesheet(instance, qualifiedProps.precedence, hoistableRoot);
+          resource.instance = instance;
+          return instance;
+        }
+
+      case 'script':
+        {
+          // This typing is enforce by `getResource`. If we change the logic
+          // there for what qualifies as a stylesheet resource we need to ensure
+          // this cast still makes sense;
+          const borrowedScriptProps = props;
+          const key = getScriptKey(borrowedScriptProps.src); // Attempt to hydrate instance from DOM
+
+          let instance = hoistableRoot.querySelector(getScriptSelectorFromKey(key));
+
+          if (instance) {
+            resource.instance = instance;
+            markNodeAsHoistable(instance);
+            return instance;
+          }
+
+          let scriptProps = borrowedScriptProps;
+          const preloadProps = preloadPropsMap.get(key);
+
+          if (preloadProps) {
+            scriptProps = assign({}, borrowedScriptProps);
+            adoptPreloadPropsForScript(scriptProps, preloadProps);
+          } // Construct and insert a new instance
+
+
+          const ownerDocument = getDocumentFromRoot(hoistableRoot);
+          instance = ownerDocument.createElement('script');
+          markNodeAsHoistable(instance);
+          setInitialProperties(instance, 'link', scriptProps);
+          ownerDocument.head.appendChild(instance);
+          resource.instance = instance;
+          return instance;
+        }
+
+      case 'void':
+        {
+          return null;
+        }
+
+      default:
+        {
+          throw Error(formatProdErrorMessage(443, resource.type));
+        }
+    }
+  } else {
+    // In the case of stylesheets, they might have already been assigned an
+    // instance during `suspendResource`. But that doesn't mean they were
+    // inserted, because the commit might have been interrupted. So we need to
+    // check now.
+    //
+    // The other resource types are unaffected because they are not
+    // yet suspensey.
+    //
+    // TODO: This is a bit of a code smell. Consider refactoring how
+    // `suspendResource` and `acquireResource` work together. The idea is that
+    // `suspendResource` does all the same stuff as `acquireResource` except
+    // for the insertion.
+    if (resource.type === 'stylesheet' && (resource.state.loading & Inserted) === NotLoaded) {
+      const qualifiedProps = props;
+      const instance = resource.instance;
+      resource.state.loading |= Inserted;
+      insertStylesheet(instance, qualifiedProps.precedence, hoistableRoot);
+    }
+  }
+
+  return resource.instance;
+}
+function releaseResource(resource) {
+  resource.count--;
+}
+
+function insertStylesheet(instance, precedence, root) {
+  const nodes = root.querySelectorAll('link[rel="stylesheet"][data-precedence],style[data-precedence]');
+  const last = nodes.length ? nodes[nodes.length - 1] : null;
+  let prior = last;
+
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const nodePrecedence = node.dataset.precedence;
+
+    if (nodePrecedence === precedence) {
+      prior = node;
+    } else if (prior !== last) {
+      break;
+    }
+  }
+
+  if (prior) {
+    // We get the prior from the document so we know it is in the tree.
+    // We also know that links can't be the topmost Node so the parentNode
+    // must exist.
+    prior.parentNode.insertBefore(instance, prior.nextSibling);
+  } else {
+    const parent = root.nodeType === DOCUMENT_NODE ? root.head : root;
+    parent.insertBefore(instance, parent.firstChild);
+  }
+}
+
+function adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps) {
+  if (stylesheetProps.crossOrigin == null) stylesheetProps.crossOrigin = preloadProps.crossOrigin;
+  if (stylesheetProps.referrerPolicy == null) stylesheetProps.referrerPolicy = preloadProps.referrerPolicy;
+  if (stylesheetProps.title == null) stylesheetProps.title = preloadProps.title;
+}
+
+function adoptPreloadPropsForScript(scriptProps, preloadProps) {
+  if (scriptProps.crossOrigin == null) scriptProps.crossOrigin = preloadProps.crossOrigin;
+  if (scriptProps.referrerPolicy == null) scriptProps.referrerPolicy = preloadProps.referrerPolicy;
+  if (scriptProps.integrity == null) scriptProps.integrity = preloadProps.integrity;
+}
+
+let tagCaches = null;
+function hydrateHoistable(hoistableRoot, type, props, internalInstanceHandle) {
+  const ownerDocument = getDocumentFromRoot(hoistableRoot);
+  let instance = null;
+
+  getInstance: switch (type) {
+    case 'title':
+      {
+        instance = ownerDocument.getElementsByTagName('title')[0];
+
+        if (!instance || isOwnedInstance(instance) || instance.namespaceURI === SVG_NAMESPACE || instance.hasAttribute('itemprop')) {
+          instance = ownerDocument.createElement(type);
+          ownerDocument.head.insertBefore(instance, ownerDocument.querySelector('head > title'));
+        }
+
+        setInitialProperties(instance, type, props);
+        precacheFiberNode(internalInstanceHandle, instance);
+        markNodeAsHoistable(instance);
+        return instance;
+      }
+
+    case 'link':
+      {
+        const cache = getHydratableHoistableCache('link', 'href', ownerDocument);
+        const key = type + (props.href || '');
+        const maybeNodes = cache.get(key);
+
+        if (maybeNodes) {
+          const nodes = maybeNodes;
+
+          for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i];
+
+            if (node.getAttribute('href') !== (props.href == null ? null : props.href) || node.getAttribute('rel') !== (props.rel == null ? null : props.rel) || node.getAttribute('title') !== (props.title == null ? null : props.title) || node.getAttribute('crossorigin') !== (props.crossOrigin == null ? null : props.crossOrigin)) {
+              // mismatch, try the next node;
+              continue;
+            }
+
+            instance = node;
+            nodes.splice(i, 1);
+            break getInstance;
+          }
+        }
+
+        instance = ownerDocument.createElement(type);
+        setInitialProperties(instance, type, props);
+        ownerDocument.head.appendChild(instance);
+        break;
+      }
+
+    case 'meta':
+      {
+        const cache = getHydratableHoistableCache('meta', 'content', ownerDocument);
+        const key = type + (props.content || '');
+        const maybeNodes = cache.get(key);
+
+        if (maybeNodes) {
+          const nodes = maybeNodes;
+
+          for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i]; // We coerce content to string because it is the most likely one to
+
+            if (node.getAttribute('content') !== (props.content == null ? null : '' + props.content) || node.getAttribute('name') !== (props.name == null ? null : props.name) || node.getAttribute('property') !== (props.property == null ? null : props.property) || node.getAttribute('http-equiv') !== (props.httpEquiv == null ? null : props.httpEquiv) || node.getAttribute('charset') !== (props.charSet == null ? null : props.charSet)) {
+              // mismatch, try the next node;
+              continue;
+            }
+
+            instance = node;
+            nodes.splice(i, 1);
+            break getInstance;
+          }
+        }
+
+        instance = ownerDocument.createElement(type);
+        setInitialProperties(instance, type, props);
+        ownerDocument.head.appendChild(instance);
+        break;
+      }
+
+    default:
+      throw Error(formatProdErrorMessage(468, type));
+  } // This node is a match
+
+
+  precacheFiberNode(internalInstanceHandle, instance);
+  markNodeAsHoistable(instance);
+  return instance;
+}
+
+function getHydratableHoistableCache(type, keyAttribute, ownerDocument) {
+  let cache;
+  let caches;
+
+  if (tagCaches === null) {
+    cache = new Map();
+    caches = tagCaches = new Map();
+    caches.set(ownerDocument, cache);
+  } else {
+    caches = tagCaches;
+    const maybeCache = caches.get(ownerDocument);
+
+    if (!maybeCache) {
+      cache = new Map();
+      caches.set(ownerDocument, cache);
+    } else {
+      cache = maybeCache;
+    }
+  }
+
+  if (cache.has(type)) {
+    // We use type as a special key that signals that this cache has been seeded for this type
+    return cache;
+  } // Mark this cache as seeded for this type
+
+
+  cache.set(type, null);
+  const nodes = ownerDocument.getElementsByTagName(type);
+
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+
+    if (!isOwnedInstance(node) && (type !== 'link' || node.getAttribute('rel') !== 'stylesheet') && node.namespaceURI !== SVG_NAMESPACE) {
+      const nodeKey = node.getAttribute(keyAttribute) || '';
+      const key = type + nodeKey;
+      const existing = cache.get(key);
+
+      if (existing) {
+        existing.push(node);
+      } else {
+        cache.set(key, [node]);
+      }
+    }
+  }
+
+  return cache;
+}
+
+function mountHoistable(hoistableRoot, type, instance) {
+  const ownerDocument = getDocumentFromRoot(hoistableRoot);
+  ownerDocument.head.insertBefore(instance, type === 'title' ? ownerDocument.querySelector('head > title') : null);
+}
+function unmountHoistable(instance) {
+  instance.parentNode.removeChild(instance);
+}
+function isHostHoistableType(type, props, hostContext) {
+  let hostContextProd;
+
+  {
+    hostContextProd = hostContext;
+  } // Global opt out of hoisting for anything in SVG Namespace or anything with an itemProp inside an itemScope
+
+
+  if (hostContextProd === HostContextNamespaceSvg || props.itemProp != null) {
+
+    return false;
+  }
+
+  switch (type) {
+    case 'meta':
+    case 'title':
+      {
+        return true;
+      }
+
+    case 'style':
+      {
+        if (typeof props.precedence !== 'string' || typeof props.href !== 'string' || props.href === '') {
+
+          return false;
+        }
+
+        return true;
+      }
+
+    case 'link':
+      {
+        if (typeof props.rel !== 'string' || typeof props.href !== 'string' || props.href === '' || props.onLoad || props.onError) {
+
+          return false;
+        }
+
+        switch (props.rel) {
+          case 'stylesheet':
+            {
+              const precedence = props.precedence,
+                    disabled = props.disabled;
+
+              return typeof precedence === 'string' && disabled == null;
+            }
+
+          default:
+            {
+              return true;
+            }
+        }
+      }
+
+    case 'script':
+      {
+        if (props.async !== true || props.onLoad || props.onError || typeof props.src !== 'string' || !props.src) {
+
+          return false;
+        }
+
+        return true;
+      }
+
+    case 'noscript':
+    case 'template':
+      {
+
+        return false;
+      }
+  }
+
+  return false;
+}
+function mayResourceSuspendCommit(resource) {
+  return resource.type === 'stylesheet' && (resource.state.loading & Inserted) === NotLoaded;
+}
+function preloadInstance(type, props) {
+  // Return true to indicate it's already loaded
+  return true;
+}
+function preloadResource(resource) {
+  if (resource.type === 'stylesheet' && (resource.state.loading & Settled) === NotLoaded) {
+    // we have not finished loading the underlying stylesheet yet.
+    return false;
+  } // Return true to indicate it's already loaded
+
+
+  return true;
+}
+let suspendedState = null; // We use a noop function when we begin suspending because if possible we want the
+// waitfor step to finish synchronously. If it doesn't we'll return a function to
+// provide the actual unsuspend function and that will get completed when the count
+// hits zero or it will get cancelled if the root starts new work.
+
+function noop() {}
+
+function startSuspendingCommit() {
+  suspendedState = {
+    stylesheets: null,
+    count: 0,
+    unsuspend: noop
+  };
+}
+function suspendResource(hoistableRoot, resource, props) {
+  if (suspendedState === null) {
+    throw Error(formatProdErrorMessage(475));
+  }
+
+  const state = suspendedState;
+
+  if (resource.type === 'stylesheet') {
+    if (typeof props.media === 'string') {
+      // If we don't currently match media we avoid suspending on this resource
+      // and let it insert on the mutation path
+      if (matchMedia(props.media).matches === false) {
+        return;
+      }
+    }
+
+    if ((resource.state.loading & Inserted) === NotLoaded) {
+      if (resource.instance === null) {
+        const qualifiedProps = props;
+        const key = getStyleKey(qualifiedProps.href); // Attempt to hydrate instance from DOM
+
+        let instance = hoistableRoot.querySelector(getStylesheetSelectorFromKey(key));
+
+        if (instance) {
+          // If this instance has a loading state it came from the Fizz runtime.
+          // If there is not loading state it is assumed to have been server rendered
+          // as part of the preamble and therefore synchronously loaded. It could have
+          // errored however which we still do not yet have a means to detect. For now
+          // we assume it is loaded.
+          const maybeLoadingState = instance._p;
+
+          if (maybeLoadingState !== null && typeof maybeLoadingState === 'object' && // $FlowFixMe[method-unbinding]
+          typeof maybeLoadingState.then === 'function') {
+            const loadingState = maybeLoadingState;
+            state.count++;
+            const ping = onUnsuspend.bind(state);
+            loadingState.then(ping, ping);
+          }
+
+          resource.state.loading |= Inserted;
+          resource.instance = instance;
+          markNodeAsHoistable(instance);
+          return;
+        }
+
+        const ownerDocument = getDocumentFromRoot(hoistableRoot);
+        const stylesheetProps = stylesheetPropsFromRawProps(props);
+        const preloadProps = preloadPropsMap.get(key);
+
+        if (preloadProps) {
+          adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps);
+        } // Construct and insert a new instance
+
+
+        instance = ownerDocument.createElement('link');
+        markNodeAsHoistable(instance);
+        const linkInstance = instance; // This Promise is a loading state used by the Fizz runtime. We need this incase there is a race
+        // between this resource being rendered on the client and being rendered with a late completed boundary.
+
+        linkInstance._p = new Promise((resolve, reject) => {
+          linkInstance.onload = resolve;
+          linkInstance.onerror = reject;
+        });
+        setInitialProperties(instance, 'link', stylesheetProps);
+        resource.instance = instance;
+      }
+
+      if (state.stylesheets === null) {
+        state.stylesheets = new Map();
+      }
+
+      state.stylesheets.set(resource, hoistableRoot);
+      const preloadEl = resource.state.preload;
+
+      if (preloadEl && (resource.state.loading & Settled) === NotLoaded) {
+        state.count++;
+        const ping = onUnsuspend.bind(state);
+        preloadEl.addEventListener('load', ping);
+        preloadEl.addEventListener('error', ping);
+      }
+    }
+  }
+}
+function waitForCommitToBeReady() {
+  if (suspendedState === null) {
+    throw Error(formatProdErrorMessage(475));
+  }
+
+  const state = suspendedState;
+
+  if (state.stylesheets && state.count === 0) {
+    // We are not currently blocked but we have not inserted all stylesheets.
+    // If this insertion happens and loads or errors synchronously then we can
+    // avoid suspending the commit. To do this we check the count again immediately after
+    insertSuspendedStylesheets(state, state.stylesheets);
+  } // We need to check the count again because the inserted stylesheets may have led to new
+  // tasks to wait on.
+
+
+  if (state.count > 0) {
+    return commit => {
+      // We almost never want to show content before its styles have loaded. But
+      // eventually we will give up and allow unstyled content. So this number is
+      // somewhat arbitrary — big enough that you'd only reach it under
+      // extreme circumstances.
+      // TODO: Figure out what the browser engines do during initial page load and
+      // consider aligning our behavior with that.
+      const stylesheetTimer = setTimeout(() => {
+        if (state.stylesheets) {
+          insertSuspendedStylesheets(state, state.stylesheets);
+        }
+
+        if (state.unsuspend) {
+          const unsuspend = state.unsuspend;
+          state.unsuspend = null;
+          unsuspend();
+        }
+      }, 60000); // one minute
+
+      state.unsuspend = commit;
+      return () => {
+        state.unsuspend = null;
+        clearTimeout(stylesheetTimer);
+      };
+    };
+  }
+
+  return null;
+}
+
+function onUnsuspend() {
+  this.count--;
+
+  if (this.count === 0) {
+    if (this.stylesheets) {
+      // If we haven't actually inserted the stylesheets yet we need to do so now before starting the commit.
+      // The reason we do this after everything else has finished is because we want to have all the stylesheets
+      // load synchronously right before mutating. Ideally the new styles will cause a single recalc only on the
+      // new tree. When we filled up stylesheets we only inlcuded stylesheets with matching media attributes so we
+      // wait for them to load before actually continuing. We expect this to increase the count above zero
+      insertSuspendedStylesheets(this, this.stylesheets);
+    } else if (this.unsuspend) {
+      const unsuspend = this.unsuspend;
+      this.unsuspend = null;
+      unsuspend();
+    }
+  }
+} // This is typecast to non-null because it will always be set before read.
+// it is important that this not be used except when the stack guarantees it exists.
+// Currentlyt his is only during insertSuspendedStylesheet.
+
+
+let precedencesByRoot = null;
+
+function insertSuspendedStylesheets(state, resources) {
+  // We need to clear this out so we don't try to reinsert after the stylesheets have loaded
+  state.stylesheets = null;
+
+  if (state.unsuspend === null) {
+    // The suspended commit was cancelled. We don't need to insert any stylesheets.
+    return;
+  } // Temporarily increment count. we don't want any synchronously loaded stylesheets to try to unsuspend
+  // before we finish inserting all stylesheets.
+
+
+  state.count++;
+  precedencesByRoot = new Map();
+  resources.forEach(insertStylesheetIntoRoot, state);
+  precedencesByRoot = null; // We can remove our temporary count and if we're still at zero we can unsuspend.
+  // If we are in the synchronous phase before deciding if the commit should suspend and this
+  // ends up hitting the unsuspend path it will just invoke the noop unsuspend.
+
+  onUnsuspend.call(state);
+}
+
+function insertStylesheetIntoRoot(root, resource, map) {
+  if (resource.state.loading & Inserted) {
+    // This resource was inserted by another root committing. we don't need to insert it again
+    return;
+  }
+
+  let last;
+  let precedences = precedencesByRoot.get(root);
+
+  if (!precedences) {
+    precedences = new Map();
+    precedencesByRoot.set(root, precedences);
+    const nodes = root.querySelectorAll('link[data-precedence],style[data-precedence]');
+
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+
+      if (node.nodeName === 'link' || // We omit style tags with media="not all" because they are not in the right position
+      // and will be hoisted by the Fizz runtime imminently.
+      node.getAttribute('media') !== 'not all') {
+        precedences.set('p' + node.dataset.precedence, node);
+        last = node;
+      }
+    }
+
+    if (last) {
+      precedences.set('last', last);
+    }
+  } else {
+    last = precedences.get('last');
+  } // We only call this after we have constructed an instance so we assume it here
+
+
+  const instance = resource.instance; // We will always have a precedence for stylesheet instances
+
+  const precedence = instance.getAttribute('data-precedence');
+  const prior = precedences.get('p' + precedence) || last;
+
+  if (prior === last) {
+    precedences.set('last', instance);
+  }
+
+  precedences.set(precedence, instance);
+  this.count++;
+  const onComplete = onUnsuspend.bind(this);
+  instance.addEventListener('load', onComplete);
+  instance.addEventListener('error', onComplete);
+
+  if (prior) {
+    prior.parentNode.insertBefore(instance, prior.nextSibling);
+  } else {
+    const parent = root.nodeType === DOCUMENT_NODE ? root.head : root;
+    parent.insertBefore(instance, parent.firstChild);
+  }
+
+  resource.state.loading |= Inserted;
+}
+
+const NotPendingTransition = NotPending;
+
+const Dispatcher$1 = Internals.Dispatcher;
+
+if (typeof document !== 'undefined') {
+  // Set the default dispatcher to the client dispatcher
+  Dispatcher$1.current = ReactDOMClientDispatcher;
+}
+/* global reportError */
+
+const defaultOnRecoverableError = typeof reportError === 'function' ? // In modern browsers, reportError will dispatch an error event,
+// emulating an uncaught JavaScript error.
+reportError : error => {
+  // In older browsers and test environments, fallback to console.error.
+  // eslint-disable-next-line react-internal/no-production-logging
+  console['error'](error);
+}; // $FlowFixMe[missing-this-annot]
+
+function ReactDOMRoot(internalRoot) {
+  this._internalRoot = internalRoot;
+} // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+ReactDOMHydrationRoot.prototype.render = ReactDOMRoot.prototype.render = // $FlowFixMe[missing-this-annot]
+function (children) {
+  const root = this._internalRoot;
+
+  if (root === null) {
+    throw Error(formatProdErrorMessage(409));
+  }
+
+  updateContainer(children, root, null, null);
+}; // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+ReactDOMHydrationRoot.prototype.unmount = ReactDOMRoot.prototype.unmount = // $FlowFixMe[missing-this-annot]
+function () {
+
+  const root = this._internalRoot;
+
+  if (root !== null) {
+    this._internalRoot = null;
+    const container = root.containerInfo;
+
+    flushSync$1(() => {
+      updateContainer(null, root, null, null);
+    });
+    unmarkContainerAsRoot(container);
+  }
+};
+
+function createRoot$1(container, options) {
+  if (!isValidContainer(container)) {
+    throw Error(formatProdErrorMessage(299));
+  }
+  let isStrictMode = false;
+  let concurrentUpdatesByDefaultOverride = false;
+  let identifierPrefix = '';
+  let onRecoverableError = defaultOnRecoverableError;
+  let transitionCallbacks = null;
+
+  if (options !== null && options !== undefined) {
+
+    if (options.unstable_strictMode === true) {
+      isStrictMode = true;
+    }
+
+    if (options.identifierPrefix !== undefined) {
+      identifierPrefix = options.identifierPrefix;
+    }
+
+    if (options.onRecoverableError !== undefined) {
+      onRecoverableError = options.onRecoverableError;
+    }
+
+    if (options.unstable_transitionCallbacks !== undefined) {
+      transitionCallbacks = options.unstable_transitionCallbacks;
+    }
+  }
+
+  const root = createContainer(container, ConcurrentRoot, null, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks);
+  markContainerAsRoot(root.current, container);
+  Dispatcher$1.current = ReactDOMClientDispatcher;
+  const rootContainerElement = container.nodeType === COMMENT_NODE ? container.parentNode : container;
+  listenToAllSupportedEvents(rootContainerElement); // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
+
+  return new ReactDOMRoot(root);
+} // $FlowFixMe[missing-this-annot]
+
+function ReactDOMHydrationRoot(internalRoot) {
+  this._internalRoot = internalRoot;
+}
+
+function scheduleHydration(target) {
+  if (target) {
+    queueExplicitHydrationTarget(target);
+  }
+} // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+ReactDOMHydrationRoot.prototype.unstable_scheduleHydration = scheduleHydration;
+function hydrateRoot$1(container, initialChildren, options) {
+  if (!isValidContainer(container)) {
+    throw Error(formatProdErrorMessage(405));
+  }
+  // the hydration callbacks.
+
+
+  const hydrationCallbacks = options != null ? options : null;
+  let isStrictMode = false;
+  let concurrentUpdatesByDefaultOverride = false;
+  let identifierPrefix = '';
+  let onRecoverableError = defaultOnRecoverableError;
+  let transitionCallbacks = null;
+  let formState = null;
+
+  if (options !== null && options !== undefined) {
+    if (options.unstable_strictMode === true) {
+      isStrictMode = true;
+    }
+
+    if (options.identifierPrefix !== undefined) {
+      identifierPrefix = options.identifierPrefix;
+    }
+
+    if (options.onRecoverableError !== undefined) {
+      onRecoverableError = options.onRecoverableError;
+    }
+
+    if (options.unstable_transitionCallbacks !== undefined) {
+      transitionCallbacks = options.unstable_transitionCallbacks;
+    }
+
+    {
+      if (options.formState !== undefined) {
+        formState = options.formState;
+      }
+    }
+  }
+
+  const root = createHydrationContainer(initialChildren, null, container, ConcurrentRoot, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks, formState);
+  markContainerAsRoot(root.current, container);
+  Dispatcher$1.current = ReactDOMClientDispatcher; // This can't be a comment node since hydration doesn't work on comment nodes anyway.
+
+  listenToAllSupportedEvents(container); // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
+
+  return new ReactDOMHydrationRoot(root);
+}
+function isValidContainer(node) {
+  return !!(node && (node.nodeType === ELEMENT_NODE || node.nodeType === DOCUMENT_NODE || node.nodeType === DOCUMENT_FRAGMENT_NODE || !disableCommentsAsDOMContainers  ));
+} // TODO: Remove this function which also includes comment nodes.
+// We only use it in places that are currently more relaxed.
+
+function isValidContainerLegacy(node) {
+  return !!(node && (node.nodeType === ELEMENT_NODE || node.nodeType === DOCUMENT_NODE || node.nodeType === DOCUMENT_FRAGMENT_NODE || node.nodeType === COMMENT_NODE && node.nodeValue === ' react-mount-point-unstable '));
+}
+
+function noopOnRecoverableError() {// This isn't reachable because onRecoverableError isn't called in the
+  // legacy API.
+}
+
+function legacyCreateRootFromDOMContainer(container, initialChildren, parentComponent, callback, isHydrationContainer) {
+  if (isHydrationContainer) {
+    if (typeof callback === 'function') {
+      const originalCallback = callback;
+
+      callback = function () {
+        const instance = getPublicRootInstance(root);
+        originalCallback.call(instance);
+      };
+    }
+
+    const root = createHydrationContainer(initialChildren, callback, container, LegacyRoot, null, // hydrationCallbacks
+    false, // isStrictMode
+    false, // concurrentUpdatesByDefaultOverride,
+    '', // identifierPrefix
+    noopOnRecoverableError, // TODO(luna) Support hydration later
+    null, null);
+    container._reactRootContainer = root;
+    markContainerAsRoot(root.current, container);
+    const rootContainerElement = container.nodeType === COMMENT_NODE ? container.parentNode : container; // $FlowFixMe[incompatible-call]
+
+    listenToAllSupportedEvents(rootContainerElement);
+    flushSync$1();
+    return root;
+  } else {
+    // First clear any existing content.
+    clearContainer(container);
+
+    if (typeof callback === 'function') {
+      const originalCallback = callback;
+
+      callback = function () {
+        const instance = getPublicRootInstance(root);
+        originalCallback.call(instance);
+      };
+    }
+
+    const root = createContainer(container, LegacyRoot, null, // hydrationCallbacks
+    false, // isStrictMode
+    false, // concurrentUpdatesByDefaultOverride,
+    '', // identifierPrefix
+    noopOnRecoverableError, // onRecoverableError
+    null // transitionCallbacks
+    );
+    container._reactRootContainer = root;
+    markContainerAsRoot(root.current, container);
+    const rootContainerElement = container.nodeType === COMMENT_NODE ? container.parentNode : container; // $FlowFixMe[incompatible-call]
+
+    listenToAllSupportedEvents(rootContainerElement); // Initial mount should not be batched.
+
+    flushSync$1(() => {
+      updateContainer(initialChildren, root, parentComponent, callback);
+    });
+    return root;
+  }
+}
+
+function legacyRenderSubtreeIntoContainer(parentComponent, children, container, forceHydrate, callback) {
+
+  const maybeRoot = container._reactRootContainer;
+  let root;
+
+  if (!maybeRoot) {
+    // Initial mount
+    root = legacyCreateRootFromDOMContainer(container, children, parentComponent, callback, forceHydrate);
+  } else {
+    root = maybeRoot;
+
+    if (typeof callback === 'function') {
+      const originalCallback = callback;
+
+      callback = function () {
+        const instance = getPublicRootInstance(root);
+        originalCallback.call(instance);
+      };
+    } // Update
+
+
+    updateContainer(children, root, parentComponent, callback);
+  }
+
+  return getPublicRootInstance(root);
+}
+
+function findDOMNode(componentOrElement) {
+
+  if (componentOrElement == null) {
+    return null;
+  }
+
+  if (componentOrElement.nodeType === ELEMENT_NODE) {
+    return componentOrElement;
+  }
+
+  return findHostInstance(componentOrElement);
+}
+function hydrate(element, container, callback) {
+
+  if (!isValidContainerLegacy(container)) {
+    throw Error(formatProdErrorMessage(200));
+  }
+
+
+  return legacyRenderSubtreeIntoContainer(null, element, container, true, callback);
+}
+function render(element, container, callback) {
+
+  if (!isValidContainerLegacy(container)) {
+    throw Error(formatProdErrorMessage(200));
+  }
+
+  return legacyRenderSubtreeIntoContainer(null, element, container, false, callback);
+}
+function unstable_renderSubtreeIntoContainer(parentComponent, element, containerNode, callback) {
+
+  if (!isValidContainerLegacy(containerNode)) {
+    throw Error(formatProdErrorMessage(200));
+  }
+
+  if (parentComponent == null || !has(parentComponent)) {
+    throw Error(formatProdErrorMessage(38));
+  }
+
+  return legacyRenderSubtreeIntoContainer(parentComponent, element, containerNode, false, callback);
+}
+function unmountComponentAtNode(container) {
+  if (!isValidContainerLegacy(container)) {
+    throw Error(formatProdErrorMessage(40));
+  }
+
+  if (container._reactRootContainer) {
+
+
+    flushSync$1(() => {
+      legacyRenderSubtreeIntoContainer(null, null, container, false, () => {
+        // $FlowFixMe[incompatible-type] This should probably use `delete container._reactRootContainer`
+        container._reactRootContainer = null;
+        unmarkContainerAsRoot(container);
+      });
+    }); // If you call unmountComponentAtNode twice in quick succession, you'll
+    // get `true` twice. That's probably fine?
+
+    return true;
+  } else {
+
+    return false;
+  }
+}
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+function getCrossOriginStringAs(as, input) {
+  if (as === 'font') {
+    return '';
+  }
+
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+const Dispatcher = Internals.Dispatcher;
+function prefetchDNS(href) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    dispatcher.prefetchDNS(href);
+  } // We don't error because preconnect needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preconnect(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    const crossOrigin = options ? getCrossOriginString(options.crossOrigin) : null;
+    dispatcher.preconnect(href, crossOrigin);
+  } // We don't error because preconnect needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preload(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string' && // We check existence because we cannot enforce this function is actually called with the stated type
+  typeof options === 'object' && options !== null && typeof options.as === 'string') {
+    const as = options.as;
+    const crossOrigin = getCrossOriginStringAs(as, options.crossOrigin);
+    dispatcher.preload(href, as, {
+      crossOrigin,
+      integrity: typeof options.integrity === 'string' ? options.integrity : undefined,
+      nonce: typeof options.nonce === 'string' ? options.nonce : undefined,
+      type: typeof options.type === 'string' ? options.type : undefined,
+      fetchPriority: typeof options.fetchPriority === 'string' ? options.fetchPriority : undefined,
+      referrerPolicy: typeof options.referrerPolicy === 'string' ? options.referrerPolicy : undefined,
+      imageSrcSet: typeof options.imageSrcSet === 'string' ? options.imageSrcSet : undefined,
+      imageSizes: typeof options.imageSizes === 'string' ? options.imageSizes : undefined
+    });
+  } // We don't error because preload needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preloadModule(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    if (options) {
+      const crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);
+      dispatcher.preloadModule(href, {
+        as: typeof options.as === 'string' && options.as !== 'script' ? options.as : undefined,
+        crossOrigin,
+        integrity: typeof options.integrity === 'string' ? options.integrity : undefined
+      });
+    } else {
+      dispatcher.preloadModule(href);
+    }
+  } // We don't error because preload needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preinit(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string' && options && typeof options.as === 'string') {
+    const as = options.as;
+    const crossOrigin = getCrossOriginStringAs(as, options.crossOrigin);
+    const integrity = typeof options.integrity === 'string' ? options.integrity : undefined;
+    const fetchPriority = typeof options.fetchPriority === 'string' ? options.fetchPriority : undefined;
+
+    if (as === 'style') {
+      dispatcher.preinitStyle(href, typeof options.precedence === 'string' ? options.precedence : undefined, {
+        crossOrigin,
+        integrity,
+        fetchPriority
+      });
+    } else if (as === 'script') {
+      dispatcher.preinitScript(href, {
+        crossOrigin,
+        integrity,
+        fetchPriority,
+        nonce: typeof options.nonce === 'string' ? options.nonce : undefined
+      });
+    }
+  } // We don't error because preinit needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preinitModule(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    if (typeof options === 'object' && options !== null) {
+      if (options.as == null || options.as === 'script') {
+        const crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);
+        dispatcher.preinitModuleScript(href, {
+          crossOrigin,
+          integrity: typeof options.integrity === 'string' ? options.integrity : undefined,
+          nonce: typeof options.nonce === 'string' ? options.nonce : undefined
+        });
+      }
+    } else if (options == null) {
+      dispatcher.preinitModuleScript(href);
+    }
+  } // We don't error because preinit needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+
+function createPortal(children, container) {
+  let key = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+
+  if (!isValidContainer(container)) {
+    throw Error(formatProdErrorMessage(200));
+  } // TODO: pass ReactDOM portal implementation as third argument
+  // $FlowFixMe[incompatible-return] The Flow type is opaque but there's no way to actually create it.
+
+
+  return createPortal$1(children, container, null, key);
+}
+
+function renderSubtreeIntoContainer(parentComponent, element, containerNode, callback) {
+  return unstable_renderSubtreeIntoContainer(parentComponent, element, containerNode, callback);
+}
+
+function createRoot(container, options) {
+
+  return createRoot$1(container, options);
+}
+
+function hydrateRoot(container, initialChildren, options) {
+
+  return hydrateRoot$1(container, initialChildren, options);
+} // Overload the definition to the two valid signatures.
+// Warning, this opts-out of checking the function body.
+// eslint-disable-next-line no-redeclare
+// eslint-disable-next-line no-redeclare
+
+
+function flushSync(fn) {
+
+  return flushSync$1(fn);
+}
+// This is an array for better minification.
+
+Internals.Events = [getInstanceFromNode, getNodeFromInstance, getFiberCurrentPropsFromNode, enqueueStateRestore, restoreStateIfNeeded, batchedUpdates$1];
+injectIntoDevTools({
+  findFiberByHostInstance: getClosestInstanceFromNode,
+  bundleType: 0,
+  version: ReactVersion,
+  rendererPackageName: 'react-dom'
+});
+
+function experimental_useFormStatus() {
+
+  return useFormStatus();
+}
+function experimental_useFormState(action, initialState, permalink) {
+
+  return useFormState(action, initialState, permalink);
+}
+
+exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = Internals;
+exports.createPortal = createPortal;
+exports.createRoot = createRoot;
+exports.experimental_useFormState = experimental_useFormState;
+exports.experimental_useFormStatus = experimental_useFormStatus;
+exports.findDOMNode = findDOMNode;
+exports.flushSync = flushSync;
+exports.hydrate = hydrate;
+exports.hydrateRoot = hydrateRoot;
+exports.preconnect = preconnect;
+exports.prefetchDNS = prefetchDNS;
+exports.preinit = preinit;
+exports.preinitModule = preinitModule;
+exports.preload = preload;
+exports.preloadModule = preloadModule;
+exports.render = render;
+exports.unmountComponentAtNode = unmountComponentAtNode;
+exports.unstable_batchedUpdates = batchedUpdates$1;
+exports.unstable_renderSubtreeIntoContainer = renderSubtreeIntoContainer;
+exports.unstable_runWithPriority = runWithPriority;
+exports.useFormState = useFormState;
+exports.useFormStatus = useFormStatus;
+exports.version = ReactVersion;
+          /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+if (
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
+    'function'
+) {
+  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+}
+        
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.profiling.min.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.profiling.min.js
index 917160f2d2288..9a54b91e9542d 100644
--- a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.profiling.min.js
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.profiling.min.js
@@ -1,28 +1,16 @@
-/**
- * @license React
- * react-dom.profiling.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-dom.profiling.min.js
 
-          'use strict';
+ Copyright (c) Meta Platforms, Inc. and affiliates.
 
-/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
-if (
-  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
-  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===
-    'function'
-) {
-  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
-}
-          /*
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
  Modernizr 3.0.0pre (Custom Build) | MIT
 */
-'use strict';var aa=require("next/dist/compiled/react-experimental"),ba=require("next/dist/compiled/scheduler-experimental"),ca={usingClientEntryPoint:!1,Events:null,Dispatcher:{current:null}};function t(a){for(var b="https://reactjs.org/docs/error-decoder.html?invariant="+a,c=1;c<arguments.length;c++)b+="&args[]="+encodeURIComponent(arguments[c]);return"Minified React error #"+a+"; visit "+b+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}
-var w=Object.assign,da=aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,ea=da.ReactCurrentDispatcher,fa={pending:!1,data:null,method:null,action:null};function ha(){return ea.current.useHostTransitionStatus()}function ia(a,b,c){return ea.current.useFormState(a,b,c)}var ka=[],la=-1;function ma(a){return{current:a}}function D(a){0>la||(a.current=ka[la],ka[la]=null,la--)}function E(a,b){la++;ka[la]=a.current;a.current=b}
+'use strict';"undefined"!==typeof __REACT_DEVTOOLS_GLOBAL_HOOK__&&"function"===typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart&&__REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());var aa=require("next/dist/compiled/react-experimental"),ba=require("next/dist/compiled/scheduler-experimental"),ca={usingClientEntryPoint:!1,Events:null,Dispatcher:{current:null}};
+function u(a){for(var b="https://reactjs.org/docs/error-decoder.html?invariant="+a,c=1;c<arguments.length;c++)b+="&args[]="+encodeURIComponent(arguments[c]);return"Minified React error #"+a+"; visit "+b+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}var x=Object.assign,da=aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,ea=da.ReactCurrentDispatcher,fa={pending:!1,data:null,method:null,action:null};
+function ha(){return ea.current.useHostTransitionStatus()}function ia(a,b,c){return ea.current.useFormState(a,b,c)}var ka=[],la=-1;function ma(a){return{current:a}}function D(a){0>la||(a.current=ka[la],ka[la]=null,la--)}function E(a,b){la++;ka[la]=a.current;a.current=b}
 var na=Symbol.for("react.element"),oa=Symbol.for("react.portal"),pa=Symbol.for("react.fragment"),qa=Symbol.for("react.strict_mode"),ra=Symbol.for("react.profiler"),sa=Symbol.for("react.provider"),ta=Symbol.for("react.context"),ua=Symbol.for("react.server_context"),va=Symbol.for("react.forward_ref"),wa=Symbol.for("react.suspense"),xa=Symbol.for("react.suspense_list"),ya=Symbol.for("react.memo"),za=Symbol.for("react.lazy"),Aa=Symbol.for("react.scope");Symbol.for("react.debug_trace_mode");
 var Ba=Symbol.for("react.offscreen"),Ca=Symbol.for("react.legacy_hidden"),Da=Symbol.for("react.cache");Symbol.for("react.tracing_marker");var Ea=Symbol.for("react.default_value"),Fa=Symbol.for("react.memo_cache_sentinel"),Ga=Symbol.for("react.postpone"),Ha=Symbol.iterator;function Ia(a){if(null===a||"object"!==typeof a)return null;a=Ha&&a[Ha]||a["@@iterator"];return"function"===typeof a?a:null}
 var Ja=ma(null),Ka=ma(null),La=ma(null),Ma=ma(null),Na={$$typeof:ta,_currentValue:null,_currentValue2:null,_threadCount:0,Provider:null,Consumer:null,_defaultValue:null,_globalName:null};function Oa(a,b){E(La,b);E(Ka,a);E(Ja,null);a=b.nodeType;switch(a){case 9:case 11:b=(b=b.documentElement)?(b=b.namespaceURI)?Pa(b):0:0;break;default:if(a=8===a?b.parentNode:b,b=a.tagName,a=a.namespaceURI)a=Pa(a),b=Qa(a,b);else switch(b){case "svg":b=1;break;case "math":b=2;break;default:b=0}}D(Ja);E(Ja,b)}
@@ -36,18 +24,19 @@ function zb(a){var b=a&42;if(0!==b)return b;switch(a&-a){case 1:return 1;case 2:
 case 536870912:return 536870912;case 1073741824:return 0;default:return a}}function Ab(a,b){var c=a.pendingLanes;if(0===c)return 0;var d=0,e=a.suspendedLanes;a=a.pingedLanes;var f=c&134217727;0!==f?(c=f&~e,0!==c?d=zb(c):(a&=f,0!==a&&(d=zb(a)))):(c&=~e,0!==c?d=zb(c):0!==a&&(d=zb(a)));return 0===d?0:0!==b&&b!==d&&0===(b&e)&&(e=d&-d,a=b&-b,e>=a||32===e&&0!==(a&4194176))?b:d}
 function Bb(a,b){switch(a){case 1:case 2:case 4:case 8:return b+250;case 16:case 32:case 64: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:return b+5E3;case 4194304:case 8388608:case 16777216:case 33554432:return-1;case 67108864:case 134217728:case 268435456:case 536870912:case 1073741824:return-1;default:return-1}}
 function Cb(a,b){if(a.errorRecoveryDisabledLanes&b)return 0;a=a.pendingLanes&-536870913;return 0!==a?a:a&536870912?536870912:0}function Db(){var a=yb;yb<<=1;0===(yb&62914560)&&(yb=4194304);return a}function Eb(a){for(var b=[],c=0;31>c;c++)b.push(a);return b}function Fb(a,b){a.pendingLanes|=b;268435456!==b&&(a.suspendedLanes=0,a.pingedLanes=0)}
-function Gb(a,b,c){var d=a.pendingLanes&~b;a.pendingLanes=b;a.suspendedLanes=0;a.pingedLanes=0;a.expiredLanes&=b;a.entangledLanes&=b;a.errorRecoveryDisabledLanes&=b;a.shellSuspendCounter=0;b=a.entanglements;for(var e=a.expirationTimes,f=a.hiddenUpdates;0<d;){var g=31-ub(d),h=1<<g;b[g]=0;e[g]=-1;var l=f[g];if(null!==l)for(f[g]=null,g=0;g<l.length;g++){var p=l[g];null!==p&&(p.lane&=-536870913)}d&=~h}0!==c&&Hb(a,c,0)}
+function Gb(a,b,c){var d=a.pendingLanes&~b;a.pendingLanes=b;a.suspendedLanes=0;a.pingedLanes=0;a.expiredLanes&=b;a.entangledLanes&=b;a.errorRecoveryDisabledLanes&=b;a.shellSuspendCounter=0;b=a.entanglements;for(var e=a.expirationTimes,f=a.hiddenUpdates;0<d;){var g=31-ub(d),h=1<<g;b[g]=0;e[g]=-1;var l=f[g];if(null!==l)for(f[g]=null,g=0;g<l.length;g++){var n=l[g];null!==n&&(n.lane&=-536870913)}d&=~h}0!==c&&Hb(a,c,0)}
 function Hb(a,b,c){a.pendingLanes|=b;a.suspendedLanes&=~b;var d=31-ub(b);a.entangledLanes|=b;a.entanglements[d]=a.entanglements[d]|1073741824|c&4194218}function Ib(a,b){var c=a.entangledLanes|=b;for(a=a.entanglements;c;){var d=31-ub(c),e=1<<d;e&b|a[d]&b&&(a[d]|=b);c&=~e}}function Jb(a,b){a.pendingLanes|=2;for(a.entangledLanes|=2;b;){var c=1<<31-ub(b);a.entanglements[1]|=c;b&=~c}}function Kb(a,b,c){if(gb)for(a=a.pendingUpdatersLaneMap;0<c;){var d=31-ub(c),e=1<<d;a[d].add(b);c&=~e}}
 function Lb(a,b){if(gb)for(var c=a.pendingUpdatersLaneMap,d=a.memoizedUpdaters;0<b;){var e=31-ub(b);a=1<<e;e=c[e];0<e.size&&(e.forEach(function(f){var g=f.alternate;null!==g&&d.has(g)||d.add(f)}),e.clear());b&=~a}}var G=0;function Nb(a,b){var c=G;try{return G=a,b()}finally{G=c}}function Ob(a){a&=-a;return 2<a?8<a?0!==(a&134217727)?32:268435456:8:2}
 var Pb=Object.prototype.hasOwnProperty,Qb=Math.random().toString(36).slice(2),Rb="__reactFiber$"+Qb,Sb="__reactProps$"+Qb,Tb="__reactContainer$"+Qb,Ub="__reactEvents$"+Qb,Vb="__reactListeners$"+Qb,Wb="__reactHandles$"+Qb,Xb="__reactResources$"+Qb,Yb="__reactMarker$"+Qb;function Zb(a){delete a[Rb];delete a[Sb];delete a[Ub];delete a[Vb];delete a[Wb]}
-function $b(a){var b=a[Rb];if(b)return b;for(var c=a.parentNode;c;){if(b=c[Tb]||c[Rb]){c=b.alternate;if(null!==b.child||null!==c&&null!==c.child)for(a=ac(a);null!==a;){if(c=a[Rb])return c;a=ac(a)}return b}a=c;c=a.parentNode}return null}function bc(a){if(a=a[Rb]||a[Tb]){var b=a.tag;if(5===b||6===b||13===b||26===b||27===b||3===b)return a}return null}function cc(a){var b=a.tag;if(5===b||26===b||27===b||6===b)return a.stateNode;throw Error(t(33));}function dc(a){return a[Sb]||null}
+function $b(a){var b=a[Rb];if(b)return b;for(var c=a.parentNode;c;){if(b=c[Tb]||c[Rb]){c=b.alternate;if(null!==b.child||null!==c&&null!==c.child)for(a=ac(a);null!==a;){if(c=a[Rb])return c;a=ac(a)}return b}a=c;c=a.parentNode}return null}function bc(a){if(a=a[Rb]||a[Tb]){var b=a.tag;if(5===b||6===b||13===b||26===b||27===b||3===b)return a}return null}function cc(a){var b=a.tag;if(5===b||26===b||27===b||6===b)return a.stateNode;throw Error(u(33));}function dc(a){return a[Sb]||null}
 function ec(a){var b=a[Xb];b||(b=a[Xb]={hoistableStyles:new Map,hoistableScripts:new Map});return b}function fc(a){a[Yb]=!0}var gc=new Set,hc={};function ic(a,b){jc(a,b);jc(a+"Capture",b)}function jc(a,b){hc[a]=b;for(a=0;a<b.length;a++)gc.add(b[a])}
 var kc=!("undefined"===typeof window||"undefined"===typeof window.document||"undefined"===typeof window.document.createElement),lc=RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"),mc=
 {},nc={};function oc(a){if(Pb.call(nc,a))return!0;if(Pb.call(mc,a))return!1;if(lc.test(a))return nc[a]=!0;mc[a]=!0;return!1}function pc(a,b,c){if(oc(b))if(null===c)a.removeAttribute(b);else{switch(typeof c){case "undefined":case "function":case "symbol":a.removeAttribute(b);return;case "boolean":var d=b.toLowerCase().slice(0,5);if("data-"!==d&&"aria-"!==d){a.removeAttribute(b);return}}a.setAttribute(b,""+c)}}
 function qc(a,b,c){if(null===c)a.removeAttribute(b);else{switch(typeof c){case "undefined":case "function":case "symbol":case "boolean":a.removeAttribute(b);return}a.setAttribute(b,""+c)}}function rc(a,b,c,d){if(null===d)a.removeAttribute(c);else{switch(typeof d){case "undefined":case "function":case "symbol":case "boolean":a.removeAttribute(c);return}a.setAttributeNS(b,c,""+d)}}var sc;
 function tc(a){if(void 0===sc)try{throw Error();}catch(c){var b=c.stack.trim().match(/\n( *(at )?)/);sc=b&&b[1]||""}return"\n"+sc+a}var uc=!1;
-function vc(a,b){if(!a||uc)return"";uc=!0;var c=Error.prepareStackTrace;Error.prepareStackTrace=void 0;try{if(b)if(b=function(){throw Error();},Object.defineProperty(b.prototype,"props",{set:function(){throw Error();}}),"object"===typeof Reflect&&Reflect.construct){try{Reflect.construct(b,[])}catch(q){var d=q}Reflect.construct(a,[],b)}else{try{b.call()}catch(q){d=q}a.call(b.prototype)}else{try{throw Error();}catch(q){d=q}var e=a();e&&"function"===typeof e.catch&&e.catch(function(){})}}catch(q){if(q&&
-d&&"string"===typeof q.stack){for(var f=q.stack.split("\n"),g=d.stack.split("\n"),h=f.length-1,l=g.length-1;1<=h&&0<=l&&f[h]!==g[l];)l--;for(;1<=h&&0<=l;h--,l--)if(f[h]!==g[l]){if(1!==h||1!==l){do if(h--,l--,0>l||f[h]!==g[l]){var p="\n"+f[h].replace(" at new "," at ");a.displayName&&p.includes("<anonymous>")&&(p=p.replace("<anonymous>",a.displayName));return p}while(1<=h&&0<=l)}break}}}finally{uc=!1,Error.prepareStackTrace=c}return(a=a?a.displayName||a.name:"")?tc(a):""}
+function vc(a,b){if(!a||uc)return"";uc=!0;var c=Error.prepareStackTrace;Error.prepareStackTrace=void 0;var d={DetermineComponentFrameRoot:function(){try{if(b){var w=function(){throw Error();};Object.defineProperty(w.prototype,"props",{set:function(){throw Error();}});if("object"===typeof Reflect&&Reflect.construct){try{Reflect.construct(w,[])}catch(r){var t=r}Reflect.construct(a,[],w)}else{try{w.call()}catch(r){t=r}a.call(w.prototype)}}else{try{throw Error();}catch(r){t=r}(w=a())&&"function"===typeof w.catch&&
+w.catch(function(){})}}catch(r){if(r&&t&&"string"===typeof r.stack)return[r.stack,t.stack]}return[null,null]}};d.DetermineComponentFrameRoot.displayName="DetermineComponentFrameRoot";var e=Object.getOwnPropertyDescriptor(d.DetermineComponentFrameRoot,"name");e&&e.configurable&&Object.defineProperty(d.DetermineComponentFrameRoot,"name",{value:"DetermineComponentFrameRoot"});try{var f=d.DetermineComponentFrameRoot(),g=f[0],h=f[1];if(g&&h){var l=g.split("\n"),n=h.split("\n");for(e=d=0;d<l.length&&!l[d].includes("DetermineComponentFrameRoot");)d++;
+for(;e<n.length&&!n[e].includes("DetermineComponentFrameRoot");)e++;if(d===l.length||e===n.length)for(d=l.length-1,e=n.length-1;1<=d&&0<=e&&l[d]!==n[e];)e--;for(;1<=d&&0<=e;d--,e--)if(l[d]!==n[e]){if(1!==d||1!==e){do if(d--,e--,0>e||l[d]!==n[e]){var q="\n"+l[d].replace(" at new "," at ");a.displayName&&q.includes("<anonymous>")&&(q=q.replace("<anonymous>",a.displayName));return q}while(1<=d&&0<=e)}break}}}finally{uc=!1,Error.prepareStackTrace=c}return(c=a?a.displayName||a.name:"")?tc(c):""}
 function wc(a){switch(a.tag){case 26:case 27:case 5:return tc(a.type);case 16:return tc("Lazy");case 13:return tc("Suspense");case 19:return tc("SuspenseList");case 0:case 2:case 15:return a=vc(a.type,!1),a;case 11:return a=vc(a.type.render,!1),a;case 1:return a=vc(a.type,!0),a;default:return""}}
 function xc(a){if(null==a)return null;if("function"===typeof a)return a.displayName||a.name||null;if("string"===typeof a)return a;switch(a){case pa:return"Fragment";case oa:return"Portal";case ra:return"Profiler";case qa:return"StrictMode";case wa:return"Suspense";case xa:return"SuspenseList";case Da:return"Cache"}if("object"===typeof a)switch(a.$$typeof){case ta:return(a.displayName||"Context")+".Consumer";case sa:return(a._context.displayName||"Context")+".Provider";case va:var b=a.render;a=a.displayName;
 a||(a=b.displayName||b.name||"",a=""!==a?"ForwardRef("+a+")":"ForwardRef");return a;case ya:return b=a.displayName||null,null!==b?b:xc(a.type)||"Memo";case za:b=a._payload;a=a._init;try{return xc(a(b))}catch(c){break}case ua:return(a.displayName||a._globalName)+".Provider"}return null}
@@ -62,10 +51,10 @@ typeof e);null!=h&&"function"!==typeof h&&"symbol"!==typeof h&&"boolean"!==typeo
 function Jc(a,b,c,d,e,f,g,h){null!=f&&"function"!==typeof f&&"symbol"!==typeof f&&"boolean"!==typeof f&&(a.type=f);if(null!=b||null!=c){if(!("submit"!==f&&"reset"!==f||void 0!==b&&null!==b))return;c=null!=c?""+zc(c):"";b=null!=b?""+zc(b):c;h||b===a.value||(a.value=b);a.defaultValue=b}d=null!=d?d:e;d="function"!==typeof d&&"symbol"!==typeof d&&!!d;a.checked=h?a.checked:!!d;a.defaultChecked=!!d;null!=g&&"function"!==typeof g&&"symbol"!==typeof g&&"boolean"!==typeof g&&(a.name=g)}
 function Ic(a,b,c){"number"===b&&Ec(a.ownerDocument)===a||a.defaultValue===""+c||(a.defaultValue=""+c)}var Kc=Array.isArray;
 function Lc(a,b,c,d){a=a.options;if(b){b={};for(var e=0;e<c.length;e++)b["$"+c[e]]=!0;for(c=0;c<a.length;c++)e=b.hasOwnProperty("$"+a[c].value),a[c].selected!==e&&(a[c].selected=e),e&&d&&(a[c].defaultSelected=!0)}else{c=""+zc(c);b=null;for(e=0;e<a.length;e++){if(a[e].value===c){a[e].selected=!0;d&&(a[e].defaultSelected=!0);return}null!==b||a[e].disabled||(b=a[e])}null!==b&&(b.selected=!0)}}
-function Mc(a,b,c){if(null!=b&&(b=""+zc(b),b!==a.value&&(a.value=b),null==c)){a.defaultValue!==b&&(a.defaultValue=b);return}a.defaultValue=null!=c?""+zc(c):""}function Nc(a,b,c,d){if(null==b){if(null!=d){if(null!=c)throw Error(t(92));if(Kc(d)){if(1<d.length)throw Error(t(93));d=d[0]}c=d}null==c&&(c="");b=c}c=zc(b);a.defaultValue=c;d=a.textContent;d===c&&""!==d&&null!==d&&(a.value=d)}
+function Mc(a,b,c){if(null!=b&&(b=""+zc(b),b!==a.value&&(a.value=b),null==c)){a.defaultValue!==b&&(a.defaultValue=b);return}a.defaultValue=null!=c?""+zc(c):""}function Nc(a,b,c,d){if(null==b){if(null!=d){if(null!=c)throw Error(u(92));if(Kc(d)){if(1<d.length)throw Error(u(93));d=d[0]}c=d}null==c&&(c="");b=c}c=zc(b);a.defaultValue=c;d=a.textContent;d===c&&""!==d&&null!==d&&(a.value=d)}
 function Oc(a,b){if(b){var c=a.firstChild;if(c&&c===a.lastChild&&3===c.nodeType){c.nodeValue=b;return}}a.textContent=b}var Pc=new Set("animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp".split(" "));
 function Qc(a,b,c){var d=0===b.indexOf("--");null==c||"boolean"===typeof c||""===c?d?a.setProperty(b,""):"float"===b?a.cssFloat="":a[b]="":d?a.setProperty(b,c):"number"!==typeof c||0===c||Pc.has(b)?"float"===b?a.cssFloat=c:a[b]=(""+c).trim():a[b]=c+"px"}
-function Rc(a,b,c){if(null!=b&&"object"!==typeof b)throw Error(t(62));a=a.style;if(null!=c){for(var d in c)!c.hasOwnProperty(d)||null!=b&&b.hasOwnProperty(d)||(0===d.indexOf("--")?a.setProperty(d,""):"float"===d?a.cssFloat="":a[d]="");for(var e in b)d=b[e],b.hasOwnProperty(e)&&c[e]!==d&&Qc(a,e,d)}else for(var f in b)b.hasOwnProperty(f)&&Qc(a,f,b[f])}
+function Rc(a,b,c){if(null!=b&&"object"!==typeof b)throw Error(u(62));a=a.style;if(null!=c){for(var d in c)!c.hasOwnProperty(d)||null!=b&&b.hasOwnProperty(d)||(0===d.indexOf("--")?a.setProperty(d,""):"float"===d?a.cssFloat="":a[d]="");for(var e in b)d=b[e],b.hasOwnProperty(e)&&c[e]!==d&&Qc(a,e,d)}else for(var f in b)b.hasOwnProperty(f)&&Qc(a,f,b[f])}
 function Sc(a){if(-1===a.indexOf("-"))return!1;switch(a){case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph":return!1;default:return!0}}
 var Tc=new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv","http-equiv"],["crossOrigin","crossorigin"],["accentHeight","accent-height"],["alignmentBaseline","alignment-baseline"],["arabicForm","arabic-form"],["baselineShift","baseline-shift"],["capHeight","cap-height"],["clipPath","clip-path"],["clipRule","clip-rule"],["colorInterpolation","color-interpolation"],["colorInterpolationFilters","color-interpolation-filters"],["colorProfile","color-profile"],["colorRendering","color-rendering"],
 ["dominantBaseline","dominant-baseline"],["enableBackground","enable-background"],["fillOpacity","fill-opacity"],["fillRule","fill-rule"],["floodColor","flood-color"],["floodOpacity","flood-opacity"],["fontFamily","font-family"],["fontSize","font-size"],["fontSizeAdjust","font-size-adjust"],["fontStretch","font-stretch"],["fontStyle","font-style"],["fontVariant","font-variant"],["fontWeight","font-weight"],["glyphName","glyph-name"],["glyphOrientationHorizontal","glyph-orientation-horizontal"],["glyphOrientationVertical",
@@ -73,81 +62,81 @@ var Tc=new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv
 "shape-rendering"],["stopColor","stop-color"],["stopOpacity","stop-opacity"],["strikethroughPosition","strikethrough-position"],["strikethroughThickness","strikethrough-thickness"],["strokeDasharray","stroke-dasharray"],["strokeDashoffset","stroke-dashoffset"],["strokeLinecap","stroke-linecap"],["strokeLinejoin","stroke-linejoin"],["strokeMiterlimit","stroke-miterlimit"],["strokeOpacity","stroke-opacity"],["strokeWidth","stroke-width"],["textAnchor","text-anchor"],["textDecoration","text-decoration"],
 ["textRendering","text-rendering"],["transformOrigin","transform-origin"],["underlinePosition","underline-position"],["underlineThickness","underline-thickness"],["unicodeBidi","unicode-bidi"],["unicodeRange","unicode-range"],["unitsPerEm","units-per-em"],["vAlphabetic","v-alphabetic"],["vHanging","v-hanging"],["vIdeographic","v-ideographic"],["vMathematical","v-mathematical"],["vectorEffect","vector-effect"],["vertAdvY","vert-adv-y"],["vertOriginX","vert-origin-x"],["vertOriginY","vert-origin-y"],
 ["wordSpacing","word-spacing"],["writingMode","writing-mode"],["xmlnsXlink","xmlns:xlink"],["xHeight","x-height"]]),Uc=null;function Vc(a){a=a.target||a.srcElement||window;a.correspondingUseElement&&(a=a.correspondingUseElement);return 3===a.nodeType?a.parentNode:a}var Wc=null,Xc=null;
-function Yc(a){var b=bc(a);if(b&&(a=b.stateNode)){var c=dc(a);a:switch(a=b.stateNode,b.type){case "input":Hc(a,c.value,c.defaultValue,c.defaultValue,c.checked,c.defaultChecked,c.type,c.name);b=c.name;if("radio"===c.type&&null!=b){for(c=a;c.parentNode;)c=c.parentNode;c=c.querySelectorAll('input[name="'+Gc(""+b)+'"][type="radio"]');for(b=0;b<c.length;b++){var d=c[b];if(d!==a&&d.form===a.form){var e=dc(d);if(!e)throw Error(t(90));Hc(d,e.value,e.defaultValue,e.defaultValue,e.checked,e.defaultChecked,
+function Yc(a){var b=bc(a);if(b&&(a=b.stateNode)){var c=dc(a);a:switch(a=b.stateNode,b.type){case "input":Hc(a,c.value,c.defaultValue,c.defaultValue,c.checked,c.defaultChecked,c.type,c.name);b=c.name;if("radio"===c.type&&null!=b){for(c=a;c.parentNode;)c=c.parentNode;c=c.querySelectorAll('input[name="'+Gc(""+b)+'"][type="radio"]');for(b=0;b<c.length;b++){var d=c[b];if(d!==a&&d.form===a.form){var e=dc(d);if(!e)throw Error(u(90));Hc(d,e.value,e.defaultValue,e.defaultValue,e.checked,e.defaultChecked,
 e.type,e.name)}}for(b=0;b<c.length;b++)d=c[b],d.form===a.form&&Dc(d)}break a;case "textarea":Mc(a,c.value,c.defaultValue);break a;case "select":b=c.value,null!=b&&Lc(a,!!c.multiple,b,!1)}}}function Zc(a){Wc?Xc?Xc.push(a):Xc=[a]:Wc=a}function $c(){if(Wc){var a=Wc,b=Xc;Xc=Wc=null;Yc(a);if(b)for(a=0;a<b.length;a++)Yc(b[a])}}function ad(a){var b=a,c=a;if(a.alternate)for(;b.return;)b=b.return;else{a=b;do b=a,0!==(b.flags&4098)&&(c=b.return),a=b.return;while(a)}return 3===b.tag?c:null}
-function bd(a){if(13===a.tag){var b=a.memoizedState;null===b&&(a=a.alternate,null!==a&&(b=a.memoizedState));if(null!==b)return b.dehydrated}return null}function cd(a){if(ad(a)!==a)throw Error(t(188));}
-function dd(a){var b=a.alternate;if(!b){b=ad(a);if(null===b)throw Error(t(188));return b!==a?null:a}for(var c=a,d=b;;){var e=c.return;if(null===e)break;var f=e.alternate;if(null===f){d=e.return;if(null!==d){c=d;continue}break}if(e.child===f.child){for(f=e.child;f;){if(f===c)return cd(e),a;if(f===d)return cd(e),b;f=f.sibling}throw Error(t(188));}if(c.return!==d.return)c=e,d=f;else{for(var g=!1,h=e.child;h;){if(h===c){g=!0;c=e;d=f;break}if(h===d){g=!0;d=e;c=f;break}h=h.sibling}if(!g){for(h=f.child;h;){if(h===
-c){g=!0;c=f;d=e;break}if(h===d){g=!0;d=f;c=e;break}h=h.sibling}if(!g)throw Error(t(189));}}if(c.alternate!==d)throw Error(t(190));}if(3!==c.tag)throw Error(t(188));return c.stateNode.current===c?a:b}function ed(a){a=dd(a);return null!==a?fd(a):null}function fd(a){var b=a.tag;if(5===b||26===b||27===b||6===b)return a;for(a=a.child;null!==a;){b=fd(a);if(null!==b)return b;a=a.sibling}return null}var gd={},hd=ma(gd),id=ma(!1),jd=gd;
+function bd(a){if(13===a.tag){var b=a.memoizedState;null===b&&(a=a.alternate,null!==a&&(b=a.memoizedState));if(null!==b)return b.dehydrated}return null}function cd(a){if(ad(a)!==a)throw Error(u(188));}
+function dd(a){var b=a.alternate;if(!b){b=ad(a);if(null===b)throw Error(u(188));return b!==a?null:a}for(var c=a,d=b;;){var e=c.return;if(null===e)break;var f=e.alternate;if(null===f){d=e.return;if(null!==d){c=d;continue}break}if(e.child===f.child){for(f=e.child;f;){if(f===c)return cd(e),a;if(f===d)return cd(e),b;f=f.sibling}throw Error(u(188));}if(c.return!==d.return)c=e,d=f;else{for(var g=!1,h=e.child;h;){if(h===c){g=!0;c=e;d=f;break}if(h===d){g=!0;d=e;c=f;break}h=h.sibling}if(!g){for(h=f.child;h;){if(h===
+c){g=!0;c=f;d=e;break}if(h===d){g=!0;d=f;c=e;break}h=h.sibling}if(!g)throw Error(u(189));}}if(c.alternate!==d)throw Error(u(190));}if(3!==c.tag)throw Error(u(188));return c.stateNode.current===c?a:b}function ed(a){a=dd(a);return null!==a?fd(a):null}function fd(a){var b=a.tag;if(5===b||26===b||27===b||6===b)return a;for(a=a.child;null!==a;){b=fd(a);if(null!==b)return b;a=a.sibling}return null}var gd={},hd=ma(gd),id=ma(!1),jd=gd;
 function kd(a,b){var c=a.type.contextTypes;if(!c)return gd;var d=a.stateNode;if(d&&d.__reactInternalMemoizedUnmaskedChildContext===b)return d.__reactInternalMemoizedMaskedChildContext;var e={},f;for(f in c)e[f]=b[f];d&&(a=a.stateNode,a.__reactInternalMemoizedUnmaskedChildContext=b,a.__reactInternalMemoizedMaskedChildContext=e);return e}function ld(a){a=a.childContextTypes;return null!==a&&void 0!==a}function md(){D(id);D(hd)}
-function nd(a,b,c){if(hd.current!==gd)throw Error(t(168));E(hd,b);E(id,c)}function od(a,b,c){var d=a.stateNode;b=b.childContextTypes;if("function"!==typeof d.getChildContext)return c;d=d.getChildContext();for(var e in d)if(!(e in b))throw Error(t(108,yc(a)||"Unknown",e));return w({},c,d)}function pd(a){a=(a=a.stateNode)&&a.__reactInternalMemoizedMergedChildContext||gd;jd=hd.current;E(hd,a);E(id,id.current);return!0}
-function qd(a,b,c){var d=a.stateNode;if(!d)throw Error(t(169));c?(a=od(a,b,jd),d.__reactInternalMemoizedMergedChildContext=a,D(id),D(hd),E(hd,a)):D(id);E(id,c)}function rd(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var sd="function"===typeof Object.is?Object.is:rd,td=[],ud=0,vd=null,wd=0,xd=[],yd=0,zd=null,Ad=1,Bd="";function Cd(a,b){td[ud++]=wd;td[ud++]=vd;vd=a;wd=b}
+function nd(a,b,c){if(hd.current!==gd)throw Error(u(168));E(hd,b);E(id,c)}function od(a,b,c){var d=a.stateNode;b=b.childContextTypes;if("function"!==typeof d.getChildContext)return c;d=d.getChildContext();for(var e in d)if(!(e in b))throw Error(u(108,yc(a)||"Unknown",e));return x({},c,d)}function pd(a){a=(a=a.stateNode)&&a.__reactInternalMemoizedMergedChildContext||gd;jd=hd.current;E(hd,a);E(id,id.current);return!0}
+function qd(a,b,c){var d=a.stateNode;if(!d)throw Error(u(169));c?(a=od(a,b,jd),d.__reactInternalMemoizedMergedChildContext=a,D(id),D(hd),E(hd,a)):D(id);E(id,c)}function rd(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var sd="function"===typeof Object.is?Object.is:rd,td=[],ud=0,vd=null,wd=0,xd=[],yd=0,zd=null,Ad=1,Bd="";function Cd(a,b){td[ud++]=wd;td[ud++]=vd;vd=a;wd=b}
 function Dd(a,b,c){xd[yd++]=Ad;xd[yd++]=Bd;xd[yd++]=zd;zd=a;var d=Ad;a=Bd;var e=32-ub(d)-1;d&=~(1<<e);c+=1;var f=32-ub(b)+e;if(30<f){var g=e-e%5;f=(d&(1<<g)-1).toString(32);d>>=g;e-=g;Ad=1<<32-ub(b)+e|c<<e|d;Bd=f+a}else Ad=1<<f|c<<e|d,Bd=a}function Ed(a){null!==a.return&&(Cd(a,1),Dd(a,1,0))}function Fd(a){for(;a===vd;)vd=td[--ud],td[ud]=null,wd=td[--ud],td[ud]=null;for(;a===zd;)zd=xd[--yd],xd[yd]=null,Bd=xd[--yd],xd[yd]=null,Ad=xd[--yd],xd[yd]=null}var H=null,I=null,K=!1,Gd=null,Hd=!1;
 function Id(a,b){var c=Jd(5,null,null,0);c.elementType="DELETED";c.stateNode=b;c.return=a;b=a.deletions;null===b?(a.deletions=[c],a.flags|=16):b.push(c)}function Kd(a,b){b.flags=b.flags&-4097|2}function Ld(a,b){b=Md(b,a.type,a.pendingProps,Hd);return null!==b?(a.stateNode=b,H=a,I=Nd(b.firstChild),Hd=!1,!0):!1}function Od(a,b){b=Pd(b,a.pendingProps,Hd);return null!==b?(a.stateNode=b,H=a,I=null,!0):!1}
-function Qd(a,b){a:{var c=b;for(b=Hd;8!==c.nodeType;){if(!b){b=null;break a}c=Rd(c);if(null===c){b=null;break a}}b=c}return null!==b?(c=null!==zd?{id:Ad,overflow:Bd}:null,a.memoizedState={dehydrated:b,treeContext:c,retryLane:536870912},c=Jd(18,null,null,0),c.stateNode=b,c.return=a,a.child=c,H=a,I=null,!0):!1}function Sd(a){return 0!==(a.mode&1)&&0===(a.flags&128)}function Td(){throw Error(t(418));}
+function Qd(a,b){a:{var c=b;for(b=Hd;8!==c.nodeType;){if(!b){b=null;break a}c=Rd(c);if(null===c){b=null;break a}}b=c}return null!==b?(c=null!==zd?{id:Ad,overflow:Bd}:null,a.memoizedState={dehydrated:b,treeContext:c,retryLane:536870912},c=Jd(18,null,null,0),c.stateNode=b,c.return=a,a.child=c,H=a,I=null,!0):!1}function Sd(a){return 0!==(a.mode&1)&&0===(a.flags&128)}function Td(){throw Error(u(418));}
 function Ud(a){for(H=a.return;H;)switch(H.tag){case 3:case 27:Hd=!0;return;case 5:case 13:Hd=!1;return;default:H=H.return}}
-function Vd(a){if(a!==H)return!1;if(!K)return Ud(a),K=!0,!1;var b=!1,c;if(c=3!==a.tag&&27!==a.tag){if(c=5===a.tag)c=a.type,c=!("form"!==c&&"button"!==c)||Wd(a.type,a.memoizedProps);c=!c}c&&(b=!0);if(b&&(b=I))if(Sd(a))Xd(),Td();else for(;b;)Id(a,b),b=Rd(b);Ud(a);if(13===a.tag){a=a.memoizedState;a=null!==a?a.dehydrated:null;if(!a)throw Error(t(317));a:{a=a.nextSibling;for(b=0;a;){if(8===a.nodeType)if(c=a.data,"/$"===c){if(0===b){I=Rd(a);break a}b--}else"$"!==c&&"$!"!==c&&"$?"!==c||b++;a=a.nextSibling}I=
+function Vd(a){if(a!==H)return!1;if(!K)return Ud(a),K=!0,!1;var b=!1,c;if(c=3!==a.tag&&27!==a.tag){if(c=5===a.tag)c=a.type,c=!("form"!==c&&"button"!==c)||Wd(a.type,a.memoizedProps);c=!c}c&&(b=!0);if(b&&(b=I))if(Sd(a))Xd(),Td();else for(;b;)Id(a,b),b=Rd(b);Ud(a);if(13===a.tag){a=a.memoizedState;a=null!==a?a.dehydrated:null;if(!a)throw Error(u(317));a:{a=a.nextSibling;for(b=0;a;){if(8===a.nodeType)if(c=a.data,"/$"===c){if(0===b){I=Rd(a);break a}b--}else"$"!==c&&"$!"!==c&&"$?"!==c||b++;a=a.nextSibling}I=
 null}}else I=H?Rd(a.stateNode):null;return!0}function Xd(){for(var a=I;a;)a=Rd(a)}function Yd(){I=H=null;K=!1}function Zd(a){null===Gd?Gd=[a]:Gd.push(a)}var $d=[],ae=0,be=0;function ce(){for(var a=ae,b=be=ae=0;b<a;){var c=$d[b];$d[b++]=null;var d=$d[b];$d[b++]=null;var e=$d[b];$d[b++]=null;var f=$d[b];$d[b++]=null;if(null!==d&&null!==e){var g=d.pending;null===g?e.next=e:(e.next=g.next,g.next=e);d.pending=e}0!==f&&de(c,e,f)}}
 function ee(a,b,c,d){$d[ae++]=a;$d[ae++]=b;$d[ae++]=c;$d[ae++]=d;be|=d;a.lanes|=d;a=a.alternate;null!==a&&(a.lanes|=d)}function fe(a,b,c,d){ee(a,b,c,d);return ge(a)}function he(a,b){ee(a,null,null,b);return ge(a)}
-function de(a,b,c){a.lanes|=c;var d=a.alternate;null!==d&&(d.lanes|=c);for(var e=!1,f=a.return;null!==f;)f.childLanes|=c,d=f.alternate,null!==d&&(d.childLanes|=c),22===f.tag&&(a=f.stateNode,null===a||a._visibility&1||(e=!0)),a=f,f=f.return;e&&null!==b&&3===a.tag&&(f=a.stateNode,e=31-ub(c),f=f.hiddenUpdates,a=f[e],null===a?f[e]=[b]:a.push(b),b.lane=c|536870912)}function ge(a){if(50<ie)throw ie=0,je=null,Error(t(185));for(var b=a.return;null!==b;)a=b,b=a.return;return 3===a.tag?a.stateNode:null}
+function de(a,b,c){a.lanes|=c;var d=a.alternate;null!==d&&(d.lanes|=c);for(var e=!1,f=a.return;null!==f;)f.childLanes|=c,d=f.alternate,null!==d&&(d.childLanes|=c),22===f.tag&&(a=f.stateNode,null===a||a._visibility&1||(e=!0)),a=f,f=f.return;e&&null!==b&&3===a.tag&&(f=a.stateNode,e=31-ub(c),f=f.hiddenUpdates,a=f[e],null===a?f[e]=[b]:a.push(b),b.lane=c|536870912)}function ge(a){if(50<ie)throw ie=0,je=null,Error(u(185));for(var b=a.return;null!==b;)a=b,b=a.return;return 3===a.tag?a.stateNode:null}
 var ke=!1;function le(a){a.updateQueue={baseState:a.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,lanes:0,hiddenCallbacks:null},callbacks:null}}function me(a,b){a=a.updateQueue;b.updateQueue===a&&(b.updateQueue={baseState:a.baseState,firstBaseUpdate:a.firstBaseUpdate,lastBaseUpdate:a.lastBaseUpdate,shared:a.shared,callbacks:null})}function ne(a){return{lane:a,tag:0,payload:null,callback:null,next:null}}
 function oe(a,b,c){var d=a.updateQueue;if(null===d)return null;d=d.shared;if(0!==(N&2)){var e=d.pending;null===e?b.next=b:(b.next=e.next,e.next=b);d.pending=b;b=ge(a);de(a,null,c);return b}ee(a,d,b,c);return ge(a)}function pe(a,b,c){b=b.updateQueue;if(null!==b&&(b=b.shared,0!==(c&4194176))){var d=b.lanes;d&=a.pendingLanes;c|=d;b.lanes=c;Ib(a,c)}}
 function qe(a,b){var c=a.updateQueue,d=a.alternate;if(null!==d&&(d=d.updateQueue,c===d)){var e=null,f=null;c=c.firstBaseUpdate;if(null!==c){do{var g={lane:c.lane,tag:c.tag,payload:c.payload,callback:null,next:null};null===f?e=f=g:f=f.next=g;c=c.next}while(null!==c);null===f?e=f=b:f=f.next=b}else e=f=b;c={baseState:d.baseState,firstBaseUpdate:e,lastBaseUpdate:f,shared:d.shared,callbacks:d.callbacks};a.updateQueue=c;return}a=c.lastBaseUpdate;null===a?c.firstBaseUpdate=b:a.next=b;c.lastBaseUpdate=b}
-function re(a,b,c,d){var e=a.updateQueue;ke=!1;var f=e.firstBaseUpdate,g=e.lastBaseUpdate,h=e.shared.pending;if(null!==h){e.shared.pending=null;var l=h,p=l.next;l.next=null;null===g?f=p:g.next=p;g=l;var q=a.alternate;null!==q&&(q=q.updateQueue,h=q.lastBaseUpdate,h!==g&&(null===h?q.firstBaseUpdate=p:h.next=p,q.lastBaseUpdate=l))}if(null!==f){var x=e.baseState;g=0;q=p=l=null;h=f;do{var r=h.lane&-536870913,u=r!==h.lane;if(u?(O&r)===r:(d&r)===r){null!==q&&(q=q.next={lane:0,tag:h.tag,payload:h.payload,
-callback:null,next:null});a:{var A=a,C=h;r=b;var J=c;switch(C.tag){case 1:A=C.payload;if("function"===typeof A){x=A.call(J,x,r);break a}x=A;break a;case 3:A.flags=A.flags&-65537|128;case 0:A=C.payload;r="function"===typeof A?A.call(J,x,r):A;if(null===r||void 0===r)break a;x=w({},x,r);break a;case 2:ke=!0}}r=h.callback;null!==r&&(a.flags|=64,u&&(a.flags|=8192),u=e.callbacks,null===u?e.callbacks=[r]:u.push(r))}else u={lane:r,tag:h.tag,payload:h.payload,callback:h.callback,next:null},null===q?(p=q=u,
-l=x):q=q.next=u,g|=r;h=h.next;if(null===h)if(h=e.shared.pending,null===h)break;else u=h,h=u.next,u.next=null,e.lastBaseUpdate=u,e.shared.pending=null}while(1);null===q&&(l=x);e.baseState=l;e.firstBaseUpdate=p;e.lastBaseUpdate=q;null===f&&(e.shared.lanes=0);se|=g;a.lanes=g;a.memoizedState=x}}function te(a,b){if("function"!==typeof a)throw Error(t(191,a));a.call(b)}function ue(a,b){var c=a.callbacks;if(null!==c)for(a.callbacks=null,a=0;a<c.length;a++)te(c[a],b)}
-function ve(a,b){if(sd(a,b))return!0;if("object"!==typeof a||null===a||"object"!==typeof b||null===b)return!1;var c=Object.keys(a),d=Object.keys(b);if(c.length!==d.length)return!1;for(d=0;d<c.length;d++){var e=c[d];if(!Pb.call(b,e)||!sd(a[e],b[e]))return!1}return!0}var we=Error(t(460)),xe=Error(t(474)),ye={then:function(){}};function ze(a){a=a.status;return"fulfilled"===a||"rejected"===a}function Ae(){}
-function Be(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(Ae,Ae),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":a=b.reason;if(a===we)throw Error(t(483));throw a;default:if("string"===typeof b.status)b.then(Ae,Ae);else{a=P;if(null!==a&&100<a.shellSuspendCounter)throw Error(t(482));a=b;a.status="pending";a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}});switch(b.status){case "fulfilled":return b.value;
-case "rejected":a=b.reason;if(a===we)throw Error(t(483));throw a;}}Ce=b;throw we;}}var Ce=null;function De(){if(null===Ce)throw Error(t(459));var a=Ce;Ce=null;return a}var Ee=null,Fe=0;function Ge(a){var b=Fe;Fe+=1;null===Ee&&(Ee=[]);return Be(Ee,a,b)}
-function He(a,b,c){a=c.ref;if(null!==a&&"function"!==typeof a&&"object"!==typeof a){if(c._owner){c=c._owner;if(c){if(1!==c.tag)throw Error(t(309));var d=c.stateNode}if(!d)throw Error(t(147,a));var e=d,f=""+a;if(null!==b&&null!==b.ref&&"function"===typeof b.ref&&b.ref._stringRef===f)return b.ref;b=function(g){var h=e.refs;null===g?delete h[f]:h[f]=g};b._stringRef=f;return b}if("string"!==typeof a)throw Error(t(284));if(!c._owner)throw Error(t(290,a));}return a}
-function Ie(a,b){a=Object.prototype.toString.call(b);throw Error(t(31,"[object Object]"===a?"object with keys {"+Object.keys(b).join(", ")+"}":a));}function Je(a){var b=a._init;return b(a._payload)}
-function Ke(a){function b(m,k){if(a){var n=m.deletions;null===n?(m.deletions=[k],m.flags|=16):n.push(k)}}function c(m,k){if(!a)return null;for(;null!==k;)b(m,k),k=k.sibling;return null}function d(m,k){for(m=new Map;null!==k;)null!==k.key?m.set(k.key,k):m.set(k.index,k),k=k.sibling;return m}function e(m,k){m=Le(m,k);m.index=0;m.sibling=null;return m}function f(m,k,n){m.index=n;if(!a)return m.flags|=1048576,k;n=m.alternate;if(null!==n)return n=n.index,n<k?(m.flags|=33554434,k):n;m.flags|=33554434;return k}
-function g(m){a&&null===m.alternate&&(m.flags|=33554434);return m}function h(m,k,n,v){if(null===k||6!==k.tag)return k=Me(n,m.mode,v),k.return=m,k;k=e(k,n);k.return=m;return k}function l(m,k,n,v){var y=n.type;if(y===pa)return q(m,k,n.props.children,v,n.key);if(null!==k&&(k.elementType===y||"object"===typeof y&&null!==y&&y.$$typeof===za&&Je(y)===k.type))return v=e(k,n.props),v.ref=He(m,k,n),v.return=m,v;v=Ne(n.type,n.key,n.props,null,null,m.mode,v);v.ref=He(m,k,n);v.return=m;return v}function p(m,k,
-n,v){if(null===k||4!==k.tag||k.stateNode.containerInfo!==n.containerInfo||k.stateNode.implementation!==n.implementation)return k=Oe(n,m.mode,v),k.return=m,k;k=e(k,n.children||[]);k.return=m;return k}function q(m,k,n,v,y){if(null===k||7!==k.tag)return k=Pe(n,m.mode,v,y),k.return=m,k;k=e(k,n);k.return=m;return k}function x(m,k,n){if("string"===typeof k&&""!==k||"number"===typeof k)return k=Me(""+k,m.mode,n),k.return=m,k;if("object"===typeof k&&null!==k){switch(k.$$typeof){case na:return n=Ne(k.type,
-k.key,k.props,null,null,m.mode,n),n.ref=He(m,null,k),n.return=m,n;case oa:return k=Oe(k,m.mode,n),k.return=m,k;case za:var v=k._init;return x(m,v(k._payload),n)}if(Kc(k)||Ia(k))return k=Pe(k,m.mode,n,null),k.return=m,k;if("function"===typeof k.then)return x(m,Ge(k),n);if(k.$$typeof===ta||k.$$typeof===ua)return x(m,Qe(m,k,n),n);Ie(m,k)}return null}function r(m,k,n,v){var y=null!==k?k.key:null;if("string"===typeof n&&""!==n||"number"===typeof n)return null!==y?null:h(m,k,""+n,v);if("object"===typeof n&&
-null!==n){switch(n.$$typeof){case na:return n.key===y?l(m,k,n,v):null;case oa:return n.key===y?p(m,k,n,v):null;case za:return y=n._init,r(m,k,y(n._payload),v)}if(Kc(n)||Ia(n))return null!==y?null:q(m,k,n,v,null);if("function"===typeof n.then)return r(m,k,Ge(n),v);if(n.$$typeof===ta||n.$$typeof===ua)return r(m,k,Qe(m,n,v),v);Ie(m,n)}return null}function u(m,k,n,v,y){if("string"===typeof v&&""!==v||"number"===typeof v)return m=m.get(n)||null,h(k,m,""+v,y);if("object"===typeof v&&null!==v){switch(v.$$typeof){case na:return m=
-m.get(null===v.key?n:v.key)||null,l(k,m,v,y);case oa:return m=m.get(null===v.key?n:v.key)||null,p(k,m,v,y);case za:var B=v._init;return u(m,k,n,B(v._payload),y)}if(Kc(v)||Ia(v))return m=m.get(n)||null,q(k,m,v,y,null);if("function"===typeof v.then)return u(m,k,n,Ge(v),y);if(v.$$typeof===ta||v.$$typeof===ua)return u(m,k,n,Qe(k,v,y),y);Ie(k,v)}return null}function A(m,k,n,v){for(var y=null,B=null,z=k,L=k=0,ja=null;null!==z&&L<n.length;L++){z.index>L?(ja=z,z=null):ja=z.sibling;var M=r(m,z,n[L],v);if(null===
-M){null===z&&(z=ja);break}a&&z&&null===M.alternate&&b(m,z);k=f(M,k,L);null===B?y=M:B.sibling=M;B=M;z=ja}if(L===n.length)return c(m,z),K&&Cd(m,L),y;if(null===z){for(;L<n.length;L++)z=x(m,n[L],v),null!==z&&(k=f(z,k,L),null===B?y=z:B.sibling=z,B=z);K&&Cd(m,L);return y}for(z=d(m,z);L<n.length;L++)ja=u(z,m,L,n[L],v),null!==ja&&(a&&null!==ja.alternate&&z.delete(null===ja.key?L:ja.key),k=f(ja,k,L),null===B?y=ja:B.sibling=ja,B=ja);a&&z.forEach(function(Mb){return b(m,Mb)});K&&Cd(m,L);return y}function C(m,
-k,n,v){var y=Ia(n);if("function"!==typeof y)throw Error(t(150));n=y.call(n);if(null==n)throw Error(t(151));for(var B=y=null,z=k,L=k=0,ja=null,M=n.next();null!==z&&!M.done;L++,M=n.next()){z.index>L?(ja=z,z=null):ja=z.sibling;var Mb=r(m,z,M.value,v);if(null===Mb){null===z&&(z=ja);break}a&&z&&null===Mb.alternate&&b(m,z);k=f(Mb,k,L);null===B?y=Mb:B.sibling=Mb;B=Mb;z=ja}if(M.done)return c(m,z),K&&Cd(m,L),y;if(null===z){for(;!M.done;L++,M=n.next())M=x(m,M.value,v),null!==M&&(k=f(M,k,L),null===B?y=M:B.sibling=
-M,B=M);K&&Cd(m,L);return y}for(z=d(m,z);!M.done;L++,M=n.next())M=u(z,m,L,M.value,v),null!==M&&(a&&null!==M.alternate&&z.delete(null===M.key?L:M.key),k=f(M,k,L),null===B?y=M:B.sibling=M,B=M);a&&z.forEach(function(Bn){return b(m,Bn)});K&&Cd(m,L);return y}function J(m,k,n,v){"object"===typeof n&&null!==n&&n.type===pa&&null===n.key&&(n=n.props.children);if("object"===typeof n&&null!==n){switch(n.$$typeof){case na:a:{for(var y=n.key,B=k;null!==B;){if(B.key===y){y=n.type;if(y===pa){if(7===B.tag){c(m,B.sibling);
-k=e(B,n.props.children);k.return=m;m=k;break a}}else if(B.elementType===y||"object"===typeof y&&null!==y&&y.$$typeof===za&&Je(y)===B.type){c(m,B.sibling);k=e(B,n.props);k.ref=He(m,B,n);k.return=m;m=k;break a}c(m,B);break}else b(m,B);B=B.sibling}n.type===pa?(k=Pe(n.props.children,m.mode,v,n.key),k.return=m,m=k):(v=Ne(n.type,n.key,n.props,null,null,m.mode,v),v.ref=He(m,k,n),v.return=m,m=v)}return g(m);case oa:a:{for(B=n.key;null!==k;){if(k.key===B)if(4===k.tag&&k.stateNode.containerInfo===n.containerInfo&&
-k.stateNode.implementation===n.implementation){c(m,k.sibling);k=e(k,n.children||[]);k.return=m;m=k;break a}else{c(m,k);break}else b(m,k);k=k.sibling}k=Oe(n,m.mode,v);k.return=m;m=k}return g(m);case za:return B=n._init,Q(m,k,B(n._payload),v)}if(Kc(n))return A(m,k,n,v);if(Ia(n))return C(m,k,n,v);if("function"===typeof n.then)return J(m,k,Ge(n),v);if(n.$$typeof===ta||n.$$typeof===ua)return J(m,k,Qe(m,n,v),v);Ie(m,n)}return"string"===typeof n&&""!==n||"number"===typeof n?(n=""+n,null!==k&&6===k.tag?(c(m,
-k.sibling),k=e(k,n),k.return=m,m=k):(c(m,k),k=Me(n,m.mode,v),k.return=m,m=k),g(m)):c(m,k)}function Q(m,k,n,v){Fe=0;m=J(m,k,n,v);Ee=null;return m}return Q}var Re=Ke(!0),Se=Ke(!1),Te=ma(null),Ue=ma(0);function Ve(a,b){a=We;E(Ue,a);E(Te,b);We=a|b.baseLanes}function Xe(){E(Ue,We);E(Te,Te.current)}function Ye(){We=Ue.current;D(Te);D(Ue)}var Ze=ma(null),$e=null;function af(a){var b=a.alternate;E(bf,bf.current&1);E(Ze,a);null===$e&&(null===b||null!==Te.current?$e=a:null!==b.memoizedState&&($e=a))}
+function re(a,b,c,d){var e=a.updateQueue;ke=!1;var f=e.firstBaseUpdate,g=e.lastBaseUpdate,h=e.shared.pending;if(null!==h){e.shared.pending=null;var l=h,n=l.next;l.next=null;null===g?f=n:g.next=n;g=l;var q=a.alternate;null!==q&&(q=q.updateQueue,h=q.lastBaseUpdate,h!==g&&(null===h?q.firstBaseUpdate=n:h.next=n,q.lastBaseUpdate=l))}if(null!==f){var w=e.baseState;g=0;q=n=l=null;h=f;do{var t=h.lane&-536870913,r=t!==h.lane;if(r?(O&t)===t:(d&t)===t){null!==q&&(q=q.next={lane:0,tag:h.tag,payload:h.payload,
+callback:null,next:null});a:{var A=a,C=h;t=b;var J=c;switch(C.tag){case 1:A=C.payload;if("function"===typeof A){w=A.call(J,w,t);break a}w=A;break a;case 3:A.flags=A.flags&-65537|128;case 0:A=C.payload;t="function"===typeof A?A.call(J,w,t):A;if(null===t||void 0===t)break a;w=x({},w,t);break a;case 2:ke=!0}}t=h.callback;null!==t&&(a.flags|=64,r&&(a.flags|=8192),r=e.callbacks,null===r?e.callbacks=[t]:r.push(t))}else r={lane:t,tag:h.tag,payload:h.payload,callback:h.callback,next:null},null===q?(n=q=r,
+l=w):q=q.next=r,g|=t;h=h.next;if(null===h)if(h=e.shared.pending,null===h)break;else r=h,h=r.next,r.next=null,e.lastBaseUpdate=r,e.shared.pending=null}while(1);null===q&&(l=w);e.baseState=l;e.firstBaseUpdate=n;e.lastBaseUpdate=q;null===f&&(e.shared.lanes=0);se|=g;a.lanes=g;a.memoizedState=w}}function te(a,b){if("function"!==typeof a)throw Error(u(191,a));a.call(b)}function ue(a,b){var c=a.callbacks;if(null!==c)for(a.callbacks=null,a=0;a<c.length;a++)te(c[a],b)}
+function ve(a,b){if(sd(a,b))return!0;if("object"!==typeof a||null===a||"object"!==typeof b||null===b)return!1;var c=Object.keys(a),d=Object.keys(b);if(c.length!==d.length)return!1;for(d=0;d<c.length;d++){var e=c[d];if(!Pb.call(b,e)||!sd(a[e],b[e]))return!1}return!0}var we=Error(u(460)),xe=Error(u(474)),ye={then:function(){}};function ze(a){a=a.status;return"fulfilled"===a||"rejected"===a}function Ae(){}
+function Be(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(Ae,Ae),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":a=b.reason;if(a===we)throw Error(u(483));throw a;default:if("string"===typeof b.status)b.then(Ae,Ae);else{a=P;if(null!==a&&100<a.shellSuspendCounter)throw Error(u(482));a=b;a.status="pending";a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}});switch(b.status){case "fulfilled":return b.value;
+case "rejected":a=b.reason;if(a===we)throw Error(u(483));throw a;}}Ce=b;throw we;}}var Ce=null;function De(){if(null===Ce)throw Error(u(459));var a=Ce;Ce=null;return a}var Ee=null,Fe=0;function Ge(a){var b=Fe;Fe+=1;null===Ee&&(Ee=[]);return Be(Ee,a,b)}
+function He(a,b,c){a=c.ref;if(null!==a&&"function"!==typeof a&&"object"!==typeof a){if(c._owner){c=c._owner;if(c){if(1!==c.tag)throw Error(u(309));var d=c.stateNode}if(!d)throw Error(u(147,a));var e=d,f=""+a;if(null!==b&&null!==b.ref&&"function"===typeof b.ref&&b.ref._stringRef===f)return b.ref;b=function(g){var h=e.refs;null===g?delete h[f]:h[f]=g};b._stringRef=f;return b}if("string"!==typeof a)throw Error(u(284));if(!c._owner)throw Error(u(290,a));}return a}
+function Ie(a,b){a=Object.prototype.toString.call(b);throw Error(u(31,"[object Object]"===a?"object with keys {"+Object.keys(b).join(", ")+"}":a));}function Je(a){var b=a._init;return b(a._payload)}
+function Ke(a){function b(m,k){if(a){var p=m.deletions;null===p?(m.deletions=[k],m.flags|=16):p.push(k)}}function c(m,k){if(!a)return null;for(;null!==k;)b(m,k),k=k.sibling;return null}function d(m,k){for(m=new Map;null!==k;)null!==k.key?m.set(k.key,k):m.set(k.index,k),k=k.sibling;return m}function e(m,k){m=Le(m,k);m.index=0;m.sibling=null;return m}function f(m,k,p){m.index=p;if(!a)return m.flags|=1048576,k;p=m.alternate;if(null!==p)return p=p.index,p<k?(m.flags|=33554434,k):p;m.flags|=33554434;return k}
+function g(m){a&&null===m.alternate&&(m.flags|=33554434);return m}function h(m,k,p,v){if(null===k||6!==k.tag)return k=Me(p,m.mode,v),k.return=m,k;k=e(k,p);k.return=m;return k}function l(m,k,p,v){var y=p.type;if(y===pa)return q(m,k,p.props.children,v,p.key);if(null!==k&&(k.elementType===y||"object"===typeof y&&null!==y&&y.$$typeof===za&&Je(y)===k.type))return v=e(k,p.props),v.ref=He(m,k,p),v.return=m,v;v=Ne(p.type,p.key,p.props,null,null,m.mode,v);v.ref=He(m,k,p);v.return=m;return v}function n(m,k,
+p,v){if(null===k||4!==k.tag||k.stateNode.containerInfo!==p.containerInfo||k.stateNode.implementation!==p.implementation)return k=Oe(p,m.mode,v),k.return=m,k;k=e(k,p.children||[]);k.return=m;return k}function q(m,k,p,v,y){if(null===k||7!==k.tag)return k=Pe(p,m.mode,v,y),k.return=m,k;k=e(k,p);k.return=m;return k}function w(m,k,p){if("string"===typeof k&&""!==k||"number"===typeof k)return k=Me(""+k,m.mode,p),k.return=m,k;if("object"===typeof k&&null!==k){switch(k.$$typeof){case na:return p=Ne(k.type,
+k.key,k.props,null,null,m.mode,p),p.ref=He(m,null,k),p.return=m,p;case oa:return k=Oe(k,m.mode,p),k.return=m,k;case za:var v=k._init;return w(m,v(k._payload),p)}if(Kc(k)||Ia(k))return k=Pe(k,m.mode,p,null),k.return=m,k;if("function"===typeof k.then)return w(m,Ge(k),p);if(k.$$typeof===ta||k.$$typeof===ua)return w(m,Qe(m,k,p),p);Ie(m,k)}return null}function t(m,k,p,v){var y=null!==k?k.key:null;if("string"===typeof p&&""!==p||"number"===typeof p)return null!==y?null:h(m,k,""+p,v);if("object"===typeof p&&
+null!==p){switch(p.$$typeof){case na:return p.key===y?l(m,k,p,v):null;case oa:return p.key===y?n(m,k,p,v):null;case za:return y=p._init,t(m,k,y(p._payload),v)}if(Kc(p)||Ia(p))return null!==y?null:q(m,k,p,v,null);if("function"===typeof p.then)return t(m,k,Ge(p),v);if(p.$$typeof===ta||p.$$typeof===ua)return t(m,k,Qe(m,p,v),v);Ie(m,p)}return null}function r(m,k,p,v,y){if("string"===typeof v&&""!==v||"number"===typeof v)return m=m.get(p)||null,h(k,m,""+v,y);if("object"===typeof v&&null!==v){switch(v.$$typeof){case na:return m=
+m.get(null===v.key?p:v.key)||null,l(k,m,v,y);case oa:return m=m.get(null===v.key?p:v.key)||null,n(k,m,v,y);case za:var B=v._init;return r(m,k,p,B(v._payload),y)}if(Kc(v)||Ia(v))return m=m.get(p)||null,q(k,m,v,y,null);if("function"===typeof v.then)return r(m,k,p,Ge(v),y);if(v.$$typeof===ta||v.$$typeof===ua)return r(m,k,p,Qe(k,v,y),y);Ie(k,v)}return null}function A(m,k,p,v){for(var y=null,B=null,z=k,L=k=0,ja=null;null!==z&&L<p.length;L++){z.index>L?(ja=z,z=null):ja=z.sibling;var M=t(m,z,p[L],v);if(null===
+M){null===z&&(z=ja);break}a&&z&&null===M.alternate&&b(m,z);k=f(M,k,L);null===B?y=M:B.sibling=M;B=M;z=ja}if(L===p.length)return c(m,z),K&&Cd(m,L),y;if(null===z){for(;L<p.length;L++)z=w(m,p[L],v),null!==z&&(k=f(z,k,L),null===B?y=z:B.sibling=z,B=z);K&&Cd(m,L);return y}for(z=d(m,z);L<p.length;L++)ja=r(z,m,L,p[L],v),null!==ja&&(a&&null!==ja.alternate&&z.delete(null===ja.key?L:ja.key),k=f(ja,k,L),null===B?y=ja:B.sibling=ja,B=ja);a&&z.forEach(function(Mb){return b(m,Mb)});K&&Cd(m,L);return y}function C(m,
+k,p,v){var y=Ia(p);if("function"!==typeof y)throw Error(u(150));p=y.call(p);if(null==p)throw Error(u(151));for(var B=y=null,z=k,L=k=0,ja=null,M=p.next();null!==z&&!M.done;L++,M=p.next()){z.index>L?(ja=z,z=null):ja=z.sibling;var Mb=t(m,z,M.value,v);if(null===Mb){null===z&&(z=ja);break}a&&z&&null===Mb.alternate&&b(m,z);k=f(Mb,k,L);null===B?y=Mb:B.sibling=Mb;B=Mb;z=ja}if(M.done)return c(m,z),K&&Cd(m,L),y;if(null===z){for(;!M.done;L++,M=p.next())M=w(m,M.value,v),null!==M&&(k=f(M,k,L),null===B?y=M:B.sibling=
+M,B=M);K&&Cd(m,L);return y}for(z=d(m,z);!M.done;L++,M=p.next())M=r(z,m,L,M.value,v),null!==M&&(a&&null!==M.alternate&&z.delete(null===M.key?L:M.key),k=f(M,k,L),null===B?y=M:B.sibling=M,B=M);a&&z.forEach(function(Bn){return b(m,Bn)});K&&Cd(m,L);return y}function J(m,k,p,v){"object"===typeof p&&null!==p&&p.type===pa&&null===p.key&&(p=p.props.children);if("object"===typeof p&&null!==p){switch(p.$$typeof){case na:a:{for(var y=p.key,B=k;null!==B;){if(B.key===y){y=p.type;if(y===pa){if(7===B.tag){c(m,B.sibling);
+k=e(B,p.props.children);k.return=m;m=k;break a}}else if(B.elementType===y||"object"===typeof y&&null!==y&&y.$$typeof===za&&Je(y)===B.type){c(m,B.sibling);k=e(B,p.props);k.ref=He(m,B,p);k.return=m;m=k;break a}c(m,B);break}else b(m,B);B=B.sibling}p.type===pa?(k=Pe(p.props.children,m.mode,v,p.key),k.return=m,m=k):(v=Ne(p.type,p.key,p.props,null,null,m.mode,v),v.ref=He(m,k,p),v.return=m,m=v)}return g(m);case oa:a:{for(B=p.key;null!==k;){if(k.key===B)if(4===k.tag&&k.stateNode.containerInfo===p.containerInfo&&
+k.stateNode.implementation===p.implementation){c(m,k.sibling);k=e(k,p.children||[]);k.return=m;m=k;break a}else{c(m,k);break}else b(m,k);k=k.sibling}k=Oe(p,m.mode,v);k.return=m;m=k}return g(m);case za:return B=p._init,Q(m,k,B(p._payload),v)}if(Kc(p))return A(m,k,p,v);if(Ia(p))return C(m,k,p,v);if("function"===typeof p.then)return J(m,k,Ge(p),v);if(p.$$typeof===ta||p.$$typeof===ua)return J(m,k,Qe(m,p,v),v);Ie(m,p)}return"string"===typeof p&&""!==p||"number"===typeof p?(p=""+p,null!==k&&6===k.tag?(c(m,
+k.sibling),k=e(k,p),k.return=m,m=k):(c(m,k),k=Me(p,m.mode,v),k.return=m,m=k),g(m)):c(m,k)}function Q(m,k,p,v){Fe=0;m=J(m,k,p,v);Ee=null;return m}return Q}var Re=Ke(!0),Se=Ke(!1),Te=ma(null),Ue=ma(0);function Ve(a,b){a=We;E(Ue,a);E(Te,b);We=a|b.baseLanes}function Xe(){E(Ue,We);E(Te,Te.current)}function Ye(){We=Ue.current;D(Te);D(Ue)}var Ze=ma(null),$e=null;function af(a){var b=a.alternate;E(bf,bf.current&1);E(Ze,a);null===$e&&(null===b||null!==Te.current?$e=a:null!==b.memoizedState&&($e=a))}
 function cf(a){if(22===a.tag){if(E(bf,bf.current),E(Ze,a),null===$e){var b=a.alternate;null!==b&&null!==b.memoizedState&&($e=a)}}else df(a)}function df(){E(bf,bf.current);E(Ze,Ze.current)}function ef(a){D(Ze);$e===a&&($e=null);D(bf)}var bf=ma(0);
 function ff(a){for(var b=a;null!==b;){if(13===b.tag){var c=b.memoizedState;if(null!==c&&(c=c.dehydrated,null===c||"$?"===c.data||"$!"===c.data))return b}else if(19===b.tag&&void 0!==b.memoizedProps.revealOrder){if(0!==(b.flags&128))return b}else if(null!==b.child){b.child.return=b;b=b.child;continue}if(b===a)break;for(;null===b.sibling;){if(null===b.return||b.return===a)return null;b=b.return}b.sibling.return=b.return;b=b.sibling}return null}var gf=null,hf=null,jf=!1,kf=!1,lf=!1,mf=0;
 function nf(a){a!==hf&&null===a.next&&(null===hf?gf=hf=a:hf=hf.next=a);kf=!0;jf||(jf=!0,of(pf))}
-function qf(a){if(!lf&&kf){var b=null;lf=!0;do{var c=!1;for(var d=gf;null!==d;){if(!a||0===d.tag){var e=O,f=Ab(d,d===P?e:0);if(0!==(f&3))try{c=!0;e=d;if(0!==(N&6))throw Error(t(327));if(!rf()){sf=tf;tf=!1;var g=uf(e,f);if(0!==e.tag&&2===g){var h=f,l=Cb(e,h);0!==l&&(f=l,g=vf(e,h,l))}if(1===g)throw h=wf,xf(e,0),yf(e,f,0),nf(e),h;6===g?yf(e,f,0):(e.finishedWork=e.current.alternate,e.finishedLanes=f,zf(e,Af,Bf,Cf))}nf(e)}catch(p){null===b?b=[p]:b.push(p)}}d=d.next}}while(c);lf=!1;if(null!==b){if(1<b.length){if("function"===
+function qf(a){if(!lf&&kf){var b=null;lf=!0;do{var c=!1;for(var d=gf;null!==d;){if(!a||0===d.tag){var e=O,f=Ab(d,d===P?e:0);if(0!==(f&3))try{c=!0;e=d;if(0!==(N&6))throw Error(u(327));if(!rf()){sf=tf;tf=!1;var g=uf(e,f);if(0!==e.tag&&2===g){var h=f,l=Cb(e,h);0!==l&&(f=l,g=vf(e,h,l))}if(1===g)throw h=wf,xf(e,0),yf(e,f,0),nf(e),h;6===g?yf(e,f,0):(e.finishedWork=e.current.alternate,e.finishedLanes=f,zf(e,Af,Bf,Cf))}nf(e)}catch(n){null===b?b=[n]:b.push(n)}}d=d.next}}while(c);lf=!1;if(null!==b){if(1<b.length){if("function"===
 typeof AggregateError)throw new AggregateError(b);for(a=1;a<b.length;a++)of(Df.bind(null,b[a]))}throw b[0];}}}function Df(a){throw a;}function pf(){kf=jf=!1;for(var a=Ya(),b=null,c=gf;null!==c;){var d=c.next;if(0!==mf&&Ef()){var e=c,f=mf;e.pendingLanes|=2;e.entangledLanes|=2;e.entanglements[1]|=f}e=Ff(c,a);0===e?(c.next=null,null===b?gf=d:b.next=d,null===d&&(hf=b)):(b=c,0!==(e&3)&&(kf=!0));c=d}mf=0;qf(!1)}
 function Ff(a,b){for(var c=a.suspendedLanes,d=a.pingedLanes,e=a.expirationTimes,f=a.pendingLanes&-62914561;0<f;){var g=31-ub(f),h=1<<g,l=e[g];if(-1===l){if(0===(h&c)||0!==(h&d))e[g]=Bb(h,b)}else l<=b&&(a.expiredLanes|=h);f&=~h}b=P;c=O;c=Ab(a,a===b?c:0);d=a.callbackNode;if(0===c||a===b&&2===R||null!==a.cancelPendingCommit)return null!==d&&null!==d&&Va(d),a.callbackNode=null,a.callbackPriority=0;if(0!==(c&3))return null!==d&&null!==d&&Va(d),a.callbackPriority=2,a.callbackNode=null,2;b=c&-c;if(b===a.callbackPriority)return b;
 null!==d&&Va(d);switch(Ob(c)){case 2:c=$a;break;case 8:c=ab;break;case 32:c=bb;break;case 268435456:c=db;break;default:c=bb}d=Gf.bind(null,a);c=Ua(c,d);a.callbackPriority=b;a.callbackNode=c;return b}function of(a){Hf(function(){0!==(N&6)?Ua($a,a):a()})}function If(){if(0===mf){var a=xb;xb<<=1;0===(xb&4194176)&&(xb=128);mf=a}return mf}var Jf=null,Kf=0,Lf=0;
-function Mf(a,b){if(null===Jf){var c=Jf=[];Kf=0;Lf=If()}else c=Jf;Kf++;var d=Nf(c),e="pending",f,g;a.then(function(h){e="fulfilled";f=null!==b?b:h;Of()},function(h){e="rejected";g=h;Of()});c.push(function(){switch(e){case "fulfilled":d.status="fulfilled";d.value=f;break;case "rejected":d.status="rejected";d.reason=g;break;default:throw Error(t(478));}});return d}function Pf(a,b){var c=null!==b?b:a;if(null===Jf)return c;a=Jf;var d=Nf(a);a.push(function(){d.status="fulfilled";d.value=c});return d}
-function Of(){if(null!==Jf&&0===--Kf){var a=Jf;Jf=null;for(var b=Lf=0;b<a.length;b++)(0,a[b])()}}function Nf(a){return{status:"pending",value:null,reason:null,then:function(b){a.push(b)}}}var Qf=da.ReactCurrentDispatcher,Rf=da.ReactCurrentBatchConfig,Sf=0,S=null,T=null,Tf=null,Uf=!1,Vf=!1,Wf=!1,Xf=0,Yf=0,Zf=null,$f=0;function U(){throw Error(t(321));}function ag(a,b){if(null===b)return!1;for(var c=0;c<b.length&&c<a.length;c++)if(!sd(a[c],b[c]))return!1;return!0}
-function bg(a,b,c,d,e,f){Sf=f;S=b;b.memoizedState=null;b.updateQueue=null;b.lanes=0;Qf.current=null===a||null===a.memoizedState?cg:dg;Wf=!1;a=c(d,e);Wf=!1;Vf&&(a=eg(b,c,d,e));fg();return a}function fg(){Qf.current=gg;var a=null!==T&&null!==T.next;Sf=0;Tf=T=S=null;Uf=!1;Yf=0;Zf=null;if(a)throw Error(t(300));}function eg(a,b,c,d){S=a;var e=0;do{Vf&&(Zf=null);Yf=0;Vf=!1;if(25<=e)throw Error(t(301));e+=1;Tf=T=null;a.updateQueue=null;Qf.current=hg;var f=b(c,d)}while(Vf);return f}
+function Mf(a,b){if(null===Jf){var c=Jf=[];Kf=0;Lf=If()}else c=Jf;Kf++;var d=Nf(c),e="pending",f,g;a.then(function(h){e="fulfilled";f=null!==b?b:h;Of()},function(h){e="rejected";g=h;Of()});c.push(function(){switch(e){case "fulfilled":d.status="fulfilled";d.value=f;break;case "rejected":d.status="rejected";d.reason=g;break;default:throw Error(u(478));}});return d}function Pf(a,b){var c=null!==b?b:a;if(null===Jf)return c;a=Jf;var d=Nf(a);a.push(function(){d.status="fulfilled";d.value=c});return d}
+function Of(){if(null!==Jf&&0===--Kf){var a=Jf;Jf=null;for(var b=Lf=0;b<a.length;b++)(0,a[b])()}}function Nf(a){return{status:"pending",value:null,reason:null,then:function(b){a.push(b)}}}var Qf=da.ReactCurrentDispatcher,Rf=da.ReactCurrentBatchConfig,Sf=0,S=null,T=null,Tf=null,Uf=!1,Vf=!1,Wf=!1,Xf=0,Yf=0,Zf=null,$f=0;function U(){throw Error(u(321));}function ag(a,b){if(null===b)return!1;for(var c=0;c<b.length&&c<a.length;c++)if(!sd(a[c],b[c]))return!1;return!0}
+function bg(a,b,c,d,e,f){Sf=f;S=b;b.memoizedState=null;b.updateQueue=null;b.lanes=0;Qf.current=null===a||null===a.memoizedState?cg:dg;Wf=!1;a=c(d,e);Wf=!1;Vf&&(a=eg(b,c,d,e));fg();return a}function fg(){Qf.current=gg;var a=null!==T&&null!==T.next;Sf=0;Tf=T=S=null;Uf=!1;Yf=0;Zf=null;if(a)throw Error(u(300));}function eg(a,b,c,d){S=a;var e=0;do{Vf&&(Zf=null);Yf=0;Vf=!1;if(25<=e)throw Error(u(301));e+=1;Tf=T=null;a.updateQueue=null;Qf.current=hg;var f=b(c,d)}while(Vf);return f}
 function ig(){var a=Qf.current.useState()[0];return"function"===typeof a.then?jg(a):a}function kg(){var a=0!==Xf;Xf=0;return a}function lg(a,b,c){b.updateQueue=a.updateQueue;b.flags&=-2053;a.lanes&=~c}function mg(a){if(Uf){for(a=a.memoizedState;null!==a;){var b=a.queue;null!==b&&(b.pending=null);a=a.next}Uf=!1}Sf=0;Tf=T=S=null;Vf=!1;Yf=Xf=0;Zf=null}function ng(){var a={memoizedState:null,baseState:null,baseQueue:null,queue:null,next:null};null===Tf?S.memoizedState=Tf=a:Tf=Tf.next=a;return Tf}
-function og(){if(null===T){var a=S.alternate;a=null!==a?a.memoizedState:null}else a=T.next;var b=null===Tf?S.memoizedState:Tf.next;if(null!==b)Tf=b,T=a;else{if(null===a){if(null===S.alternate)throw Error(t(467));throw Error(t(310));}T=a;a={memoizedState:T.memoizedState,baseState:T.baseState,baseQueue:T.baseQueue,queue:T.queue,next:null};null===Tf?S.memoizedState=Tf=a:Tf=Tf.next=a}return Tf}var pg;pg=function(){return{lastEffect:null,events:null,stores:null,memoCache:null}};
-function jg(a){var b=Yf;Yf+=1;null===Zf&&(Zf=[]);a=Be(Zf,a,b);null===S.alternate&&(null===Tf?null===S.memoizedState:null===Tf.next)&&(Qf.current=cg);return a}function qg(a){if(null!==a&&"object"===typeof a){if("function"===typeof a.then)return jg(a);if(a.$$typeof===ta||a.$$typeof===ua)return rg(a)}throw Error(t(438,String(a)));}
+function og(){if(null===T){var a=S.alternate;a=null!==a?a.memoizedState:null}else a=T.next;var b=null===Tf?S.memoizedState:Tf.next;if(null!==b)Tf=b,T=a;else{if(null===a){if(null===S.alternate)throw Error(u(467));throw Error(u(310));}T=a;a={memoizedState:T.memoizedState,baseState:T.baseState,baseQueue:T.baseQueue,queue:T.queue,next:null};null===Tf?S.memoizedState=Tf=a:Tf=Tf.next=a}return Tf}var pg;pg=function(){return{lastEffect:null,events:null,stores:null,memoCache:null}};
+function jg(a){var b=Yf;Yf+=1;null===Zf&&(Zf=[]);a=Be(Zf,a,b);null===S.alternate&&(null===Tf?null===S.memoizedState:null===Tf.next)&&(Qf.current=cg);return a}function qg(a){if(null!==a&&"object"===typeof a){if("function"===typeof a.then)return jg(a);if(a.$$typeof===ta||a.$$typeof===ua)return rg(a)}throw Error(u(438,String(a)));}
 function sg(a){var b=null,c=S.updateQueue;null!==c&&(b=c.memoCache);if(null==b){var d=S.alternate;null!==d&&(d=d.updateQueue,null!==d&&(d=d.memoCache,null!=d&&(b={data:d.data.map(function(e){return e.slice()}),index:0})))}null==b&&(b={data:[],index:0});null===c&&(c=pg(),S.updateQueue=c);c.memoCache=b;c=b.data[b.index];if(void 0===c)for(c=b.data[b.index]=Array(a),d=0;d<a;d++)c[d]=Fa;b.index++;return c}function tg(a,b){return"function"===typeof b?b(a):b}function ug(a){var b=og();return vg(b,T,a)}
-function vg(a,b,c){var d=a.queue;if(null===d)throw Error(t(311));d.lastRenderedReducer=c;var e=a.baseQueue,f=d.pending;if(null!==f){if(null!==e){var g=e.next;e.next=f.next;f.next=g}b.baseQueue=e=f;d.pending=null}if(null!==e){b=e.next;f=a.baseState;var h=g=null,l=null,p=b;do{var q=p.lane&-536870913;if(q!==p.lane?(O&q)===q:(Sf&q)===q){q=p.revertLane;if(0===q)null!==l&&(l=l.next={lane:0,revertLane:0,action:p.action,hasEagerState:p.hasEagerState,eagerState:p.eagerState,next:null});else if((Sf&q)===q){p=
-p.next;continue}else{var x={lane:0,revertLane:p.revertLane,action:p.action,hasEagerState:p.hasEagerState,eagerState:p.eagerState,next:null};null===l?(h=l=x,g=f):l=l.next=x;S.lanes|=q;se|=q}q=p.action;Wf&&c(f,q);f=p.hasEagerState?p.eagerState:c(f,q)}else x={lane:q,revertLane:p.revertLane,action:p.action,hasEagerState:p.hasEagerState,eagerState:p.eagerState,next:null},null===l?(h=l=x,g=f):l=l.next=x,S.lanes|=q,se|=q;p=p.next}while(null!==p&&p!==b);null===l?g=f:l.next=h;sd(f,a.memoizedState)||(wg=!0);
-a.memoizedState=f;a.baseState=g;a.baseQueue=l;d.lastRenderedState=f}null===e&&(d.lanes=0);return[a.memoizedState,d.dispatch]}function xg(a){var b=og(),c=b.queue;if(null===c)throw Error(t(311));c.lastRenderedReducer=a;var d=c.dispatch,e=c.pending,f=b.memoizedState;if(null!==e){c.pending=null;var g=e=e.next;do f=a(f,g.action),g=g.next;while(g!==e);sd(f,b.memoizedState)||(wg=!0);b.memoizedState=f;null===b.baseQueue&&(b.baseState=f);c.lastRenderedState=f}return[f,d]}
-function yg(a,b,c){var d=S,e=og(),f=K;if(f){if(void 0===c)throw Error(t(407));c=c()}else c=b();var g=!sd((T||e).memoizedState,c);g&&(e.memoizedState=c,wg=!0);e=e.queue;zg(Ag.bind(null,d,e,a),[a]);if(e.getSnapshot!==b||g||null!==Tf&&Tf.memoizedState.tag&1){d.flags|=2048;Bg(9,Cg.bind(null,d,e,c,b),{destroy:void 0},null);if(null===P)throw Error(t(349));f||0!==(Sf&60)||Dg(d,b,c)}return c}
+function vg(a,b,c){var d=a.queue;if(null===d)throw Error(u(311));d.lastRenderedReducer=c;var e=a.baseQueue,f=d.pending;if(null!==f){if(null!==e){var g=e.next;e.next=f.next;f.next=g}b.baseQueue=e=f;d.pending=null}if(null!==e){b=e.next;f=a.baseState;var h=g=null,l=null,n=b;do{var q=n.lane&-536870913;if(q!==n.lane?(O&q)===q:(Sf&q)===q){q=n.revertLane;if(0===q)null!==l&&(l=l.next={lane:0,revertLane:0,action:n.action,hasEagerState:n.hasEagerState,eagerState:n.eagerState,next:null});else if((Sf&q)===q){n=
+n.next;continue}else{var w={lane:0,revertLane:n.revertLane,action:n.action,hasEagerState:n.hasEagerState,eagerState:n.eagerState,next:null};null===l?(h=l=w,g=f):l=l.next=w;S.lanes|=q;se|=q}q=n.action;Wf&&c(f,q);f=n.hasEagerState?n.eagerState:c(f,q)}else w={lane:q,revertLane:n.revertLane,action:n.action,hasEagerState:n.hasEagerState,eagerState:n.eagerState,next:null},null===l?(h=l=w,g=f):l=l.next=w,S.lanes|=q,se|=q;n=n.next}while(null!==n&&n!==b);null===l?g=f:l.next=h;sd(f,a.memoizedState)||(wg=!0);
+a.memoizedState=f;a.baseState=g;a.baseQueue=l;d.lastRenderedState=f}null===e&&(d.lanes=0);return[a.memoizedState,d.dispatch]}function xg(a){var b=og(),c=b.queue;if(null===c)throw Error(u(311));c.lastRenderedReducer=a;var d=c.dispatch,e=c.pending,f=b.memoizedState;if(null!==e){c.pending=null;var g=e=e.next;do f=a(f,g.action),g=g.next;while(g!==e);sd(f,b.memoizedState)||(wg=!0);b.memoizedState=f;null===b.baseQueue&&(b.baseState=f);c.lastRenderedState=f}return[f,d]}
+function yg(a,b,c){var d=S,e=og(),f=K;if(f){if(void 0===c)throw Error(u(407));c=c()}else c=b();var g=!sd((T||e).memoizedState,c);g&&(e.memoizedState=c,wg=!0);e=e.queue;zg(Ag.bind(null,d,e,a),[a]);if(e.getSnapshot!==b||g||null!==Tf&&Tf.memoizedState.tag&1){d.flags|=2048;Bg(9,Cg.bind(null,d,e,c,b),{destroy:void 0},null);if(null===P)throw Error(u(349));f||0!==(Sf&60)||Dg(d,b,c)}return c}
 function Dg(a,b,c){a.flags|=16384;a={getSnapshot:b,value:c};b=S.updateQueue;null===b?(b=pg(),S.updateQueue=b,b.stores=[a]):(c=b.stores,null===c?b.stores=[a]:c.push(a))}function Cg(a,b,c,d){b.value=c;b.getSnapshot=d;Eg(b)&&Fg(a)}function Ag(a,b,c){return c(function(){Eg(b)&&Fg(a)})}function Eg(a){var b=a.getSnapshot;a=a.value;try{var c=b();return!sd(a,c)}catch(d){return!0}}function Fg(a){var b=he(a,2);null!==b&&Gg(b,a,2)}
-function Hg(a){var b=ng();"function"===typeof a&&(a=a());b.memoizedState=b.baseState=a;b.queue={pending:null,lanes:0,dispatch:null,lastRenderedReducer:tg,lastRenderedState:a};return b}function Ig(a,b,c,d){a.baseState=c;return vg(a,T,"function"===typeof d?d:tg)}function Jg(a,b,c,d){if(Kg(a))throw Error(t(485));a=b.pending;null===a?(a={payload:d,next:null},a.next=b.pending=a,Lg(b,c,d)):b.pending=a.next={payload:d,next:a.next}}
-function Lg(a,b,c){var d=a.action,e=a.state,f=Rf.transition;Rf.transition={};try{var g=d(e,c);if(null!==g&&"object"===typeof g&&"function"===typeof g.then){g.then(function(p){a.state=p;Mg(a,b)},function(){return Mg(a,b)});var h=Mf(g,null);b(h)}else{var l=Pf(g,null);b(l);a.state=g;Mg(a,b)}}catch(p){b({then:function(){},status:"rejected",reason:p}),Mg(a,b)}finally{Rf.transition=f}}
+function Hg(a){var b=ng();"function"===typeof a&&(a=a());b.memoizedState=b.baseState=a;b.queue={pending:null,lanes:0,dispatch:null,lastRenderedReducer:tg,lastRenderedState:a};return b}function Ig(a,b,c,d){a.baseState=c;return vg(a,T,"function"===typeof d?d:tg)}function Jg(a,b,c,d){if(Kg(a))throw Error(u(485));a=b.pending;null===a?(a={payload:d,next:null},a.next=b.pending=a,Lg(b,c,d)):b.pending=a.next={payload:d,next:a.next}}
+function Lg(a,b,c){var d=a.action,e=a.state,f=Rf.transition;Rf.transition={};try{var g=d(e,c);if(null!==g&&"object"===typeof g&&"function"===typeof g.then){g.then(function(n){a.state=n;Mg(a,b)},function(){return Mg(a,b)});var h=Mf(g,null);b(h)}else{var l=Pf(g,null);b(l);a.state=g;Mg(a,b)}}catch(n){b({then:function(){},status:"rejected",reason:n}),Mg(a,b)}finally{Rf.transition=f}}
 function Mg(a,b){var c=a.pending;if(null!==c){var d=c.next;d===c?a.pending=null:(d=d.next,c.next=d,Lg(a,b,d.payload))}}function Ng(a,b){return b}function Og(a,b,c){a=vg(a,b,Ng)[0];a="object"===typeof a&&null!==a&&"function"===typeof a.then?jg(a):a;b=og();var d=b.queue,e=d.dispatch;c!==b.memoizedState&&(S.flags|=2048,Bg(9,Pg.bind(null,d,c),{destroy:void 0},null));return[a,e]}function Pg(a,b){a.action=b}
 function Bg(a,b,c,d){a={tag:a,create:b,inst:c,deps:d,next:null};b=S.updateQueue;null===b?(b=pg(),S.updateQueue=b,b.lastEffect=a.next=a):(c=b.lastEffect,null===c?b.lastEffect=a.next=a:(d=c.next,c.next=a,a.next=d,b.lastEffect=a));return a}function Qg(){return og().memoizedState}function Rg(a,b,c,d){var e=ng();S.flags|=a;e.memoizedState=Bg(1|b,c,{destroy:void 0},void 0===d?null:d)}
 function Sg(a,b,c,d){var e=og();d=void 0===d?null:d;var f=e.memoizedState.inst;null!==T&&null!==d&&ag(d,T.memoizedState.deps)?e.memoizedState=Bg(b,c,f,d):(S.flags|=a,e.memoizedState=Bg(1|b,c,f,d))}function Tg(a,b){Rg(8390656,8,a,b)}function zg(a,b){Sg(2048,8,a,b)}function Ug(a){S.flags|=4;var b=S.updateQueue;if(null===b)b=pg(),S.updateQueue=b,b.events=[a];else{var c=b.events;null===c?b.events=[a]:c.push(a)}}
-function Vg(a){var b=og().memoizedState;Ug({ref:b,nextImpl:a});return function(){if(0!==(N&2))throw Error(t(440));return b.impl.apply(void 0,arguments)}}function Wg(a,b){return Sg(4,2,a,b)}function Xg(a,b){return Sg(4,4,a,b)}function Yg(a,b){if("function"===typeof b)return a=a(),b(a),function(){b(null)};if(null!==b&&void 0!==b)return a=a(),b.current=a,function(){b.current=null}}function Zg(a,b,c){c=null!==c&&void 0!==c?c.concat([a]):null;Sg(4,4,Yg.bind(null,b,a),c)}function $g(){}
+function Vg(a){var b=og().memoizedState;Ug({ref:b,nextImpl:a});return function(){if(0!==(N&2))throw Error(u(440));return b.impl.apply(void 0,arguments)}}function Wg(a,b){return Sg(4,2,a,b)}function Xg(a,b){return Sg(4,4,a,b)}function Yg(a,b){if("function"===typeof b)return a=a(),b(a),function(){b(null)};if(null!==b&&void 0!==b)return a=a(),b.current=a,function(){b.current=null}}function Zg(a,b,c){c=null!==c&&void 0!==c?c.concat([a]):null;Sg(4,4,Yg.bind(null,b,a),c)}function $g(){}
 function ah(a,b){var c=og();b=void 0===b?null:b;var d=c.memoizedState;if(null!==b&&ag(b,d[1]))return d[0];c.memoizedState=[a,b];return a}function bh(a,b){var c=og();b=void 0===b?null:b;var d=c.memoizedState;if(null!==b&&ag(b,d[1]))return d[0];Wf&&a();a=a();c.memoizedState=[a,b];return a}function ch(a,b,c){if(void 0===c||0!==(Sf&1073741824))return a.memoizedState=b;a.memoizedState=c;a=dh();S.lanes|=a;se|=a;return c}
-function eh(a,b,c,d){if(sd(c,b))return c;if(null!==Te.current)return a=ch(a,c,d),sd(a,b)||(wg=!0),a;if(0===(Sf&42))return wg=!0,a.memoizedState=c;a=dh();S.lanes|=a;se|=a;return b}function fh(a,b,c,d,e){var f=G;G=0!==f&&8>f?f:8;var g=Rf.transition;Rf.transition={};gh(a,!1,b,c);try{var h=e();if(null!==h&&"object"===typeof h&&"function"===typeof h.then){var l=Mf(h,d);hh(a,b,l)}else{var p=Pf(h,d);hh(a,b,p)}}catch(q){hh(a,b,{then:function(){},status:"rejected",reason:q})}finally{G=f,Rf.transition=g}}
-function ih(a,b,c,d){if(5!==a.tag)throw Error(t(476));if(null===a.memoizedState){var e={pending:null,lanes:0,dispatch:null,lastRenderedReducer:tg,lastRenderedState:fa};var f=e;e={memoizedState:fa,baseState:fa,baseQueue:null,queue:e,next:null};a.memoizedState=e;var g=a.alternate;null!==g&&(g.memoizedState=e)}else f=a.memoizedState.queue;fh(a,f,b,fa,function(){return c(d)})}function jh(){var a=rg(Na);return null!==a?a:fa}function kh(){return og().memoizedState}
+function eh(a,b,c,d){if(sd(c,b))return c;if(null!==Te.current)return a=ch(a,c,d),sd(a,b)||(wg=!0),a;if(0===(Sf&42))return wg=!0,a.memoizedState=c;a=dh();S.lanes|=a;se|=a;return b}function fh(a,b,c,d,e){var f=G;G=0!==f&&8>f?f:8;var g=Rf.transition;Rf.transition={};gh(a,!1,b,c);try{var h=e();if(null!==h&&"object"===typeof h&&"function"===typeof h.then){var l=Mf(h,d);hh(a,b,l)}else{var n=Pf(h,d);hh(a,b,n)}}catch(q){hh(a,b,{then:function(){},status:"rejected",reason:q})}finally{G=f,Rf.transition=g}}
+function ih(a,b,c,d){if(5!==a.tag)throw Error(u(476));if(null===a.memoizedState){var e={pending:null,lanes:0,dispatch:null,lastRenderedReducer:tg,lastRenderedState:fa};var f=e;e={memoizedState:fa,baseState:fa,baseQueue:null,queue:e,next:null};a.memoizedState=e;var g=a.alternate;null!==g&&(g.memoizedState=e)}else f=a.memoizedState.queue;fh(a,f,b,fa,function(){return c(d)})}function jh(){var a=rg(Na);return null!==a?a:fa}function kh(){return og().memoizedState}
 function lh(){return og().memoizedState}function mh(a,b,c){for(var d=a.return;null!==d;){switch(d.tag){case 24:case 3:var e=nh(d);a=ne(e);var f=oe(d,a,e);null!==f&&(Gg(f,d,e),pe(f,d,e));d=oh();null!==b&&void 0!==b&&null!==f&&d.data.set(b,c);a.payload={cache:d};return}d=d.return}}function ph(a,b,c){var d=nh(a);c={lane:d,revertLane:0,action:c,hasEagerState:!1,eagerState:null,next:null};Kg(a)?qh(b,c):(c=fe(a,b,c,d),null!==c&&(Gg(c,a,d),rh(c,b,d)));sb(a,d)}
 function hh(a,b,c){var d=nh(a),e={lane:d,revertLane:0,action:c,hasEagerState:!1,eagerState:null,next:null};if(Kg(a))qh(b,e);else{var f=a.alternate;if(0===a.lanes&&(null===f||0===f.lanes)&&(f=b.lastRenderedReducer,null!==f))try{var g=b.lastRenderedState,h=f(g,c);e.hasEagerState=!0;e.eagerState=h;if(sd(h,g)){ee(a,b,e,0);null===P&&ce();return}}catch(l){}finally{}c=fe(a,b,e,d);null!==c&&(Gg(c,a,d),rh(c,b,d))}sb(a,d)}
-function gh(a,b,c,d){d={lane:2,revertLane:If(),action:d,hasEagerState:!1,eagerState:null,next:null};if(Kg(a)){if(b)throw Error(t(479));}else b=fe(a,c,d,2),null!==b&&Gg(b,a,2);sb(a,2)}function Kg(a){var b=a.alternate;return a===S||null!==b&&b===S}function qh(a,b){Vf=Uf=!0;var c=a.pending;null===c?b.next=b:(b.next=c.next,c.next=b);a.pending=b}function rh(a,b,c){if(0!==(c&4194176)){var d=b.lanes;d&=a.pendingLanes;c|=d;b.lanes=c;Ib(a,c)}}
+function gh(a,b,c,d){d={lane:2,revertLane:If(),action:d,hasEagerState:!1,eagerState:null,next:null};if(Kg(a)){if(b)throw Error(u(479));}else b=fe(a,c,d,2),null!==b&&Gg(b,a,2);sb(a,2)}function Kg(a){var b=a.alternate;return a===S||null!==b&&b===S}function qh(a,b){Vf=Uf=!0;var c=a.pending;null===c?b.next=b:(b.next=c.next,c.next=b);a.pending=b}function rh(a,b,c){if(0!==(c&4194176)){var d=b.lanes;d&=a.pendingLanes;c|=d;b.lanes=c;Ib(a,c)}}
 var gg={readContext:rg,use:qg,useCallback:U,useContext:U,useEffect:U,useImperativeHandle:U,useInsertionEffect:U,useLayoutEffect:U,useMemo:U,useReducer:U,useRef:U,useState:U,useDebugValue:U,useDeferredValue:U,useTransition:U,useSyncExternalStore:U,useId:U};gg.useCacheRefresh=U;gg.useMemoCache=U;gg.useEffectEvent=U;gg.useHostTransitionStatus=U;gg.useFormState=U;gg.useOptimistic=U;
 var cg={readContext:rg,use:qg,useCallback:function(a,b){ng().memoizedState=[a,void 0===b?null:b];return a},useContext:rg,useEffect:Tg,useImperativeHandle:function(a,b,c){c=null!==c&&void 0!==c?c.concat([a]):null;Rg(4194308,4,Yg.bind(null,b,a),c)},useLayoutEffect:function(a,b){return Rg(4194308,4,a,b)},useInsertionEffect:function(a,b){Rg(4,2,a,b)},useMemo:function(a,b){var c=ng();b=void 0===b?null:b;Wf&&a();a=a();c.memoizedState=[a,b];return a},useReducer:function(a,b,c){var d=ng();b=void 0!==c?c(b):
 b;d.memoizedState=d.baseState=b;a={pending:null,lanes:0,dispatch:null,lastRenderedReducer:a,lastRenderedState:b};d.queue=a;a=a.dispatch=ph.bind(null,S,a);return[d.memoizedState,a]},useRef:function(a){var b=ng();a={current:a};return b.memoizedState=a},useState:function(a){a=Hg(a);var b=a.queue,c=hh.bind(null,S,b);b.dispatch=c;return[a.memoizedState,c]},useDebugValue:$g,useDeferredValue:function(a,b){var c=ng();return ch(c,a,b)},useTransition:function(){var a=Hg(!1);a=fh.bind(null,S,a.queue,!0,!1);
-ng().memoizedState=a;return[!1,a]},useSyncExternalStore:function(a,b,c){var d=S,e=ng();if(K){if(void 0===c)throw Error(t(407));c=c()}else{c=b();if(null===P)throw Error(t(349));0!==(O&60)||Dg(d,b,c)}e.memoizedState=c;var f={value:c,getSnapshot:b};e.queue=f;Tg(Ag.bind(null,d,f,a),[a]);d.flags|=2048;Bg(9,Cg.bind(null,d,f,c,b),{destroy:void 0},null);return c},useId:function(){var a=ng(),b=P.identifierPrefix;if(K){var c=Bd;var d=Ad;c=(d&~(1<<32-ub(d)-1)).toString(32)+c;b=":"+b+"R"+c;c=Xf++;0<c&&(b+="H"+
-c.toString(32));b+=":"}else c=$f++,b=":"+b+"r"+c.toString(32)+":";return a.memoizedState=b},useCacheRefresh:function(){return ng().memoizedState=mh.bind(null,S)}};cg.useMemoCache=sg;cg.useEffectEvent=function(a){var b=ng(),c={impl:a};b.memoizedState=c;return function(){if(0!==(N&2))throw Error(t(440));return c.impl.apply(void 0,arguments)}};cg.useHostTransitionStatus=jh;
+ng().memoizedState=a;return[!1,a]},useSyncExternalStore:function(a,b,c){var d=S,e=ng();if(K){if(void 0===c)throw Error(u(407));c=c()}else{c=b();if(null===P)throw Error(u(349));0!==(O&60)||Dg(d,b,c)}e.memoizedState=c;var f={value:c,getSnapshot:b};e.queue=f;Tg(Ag.bind(null,d,f,a),[a]);d.flags|=2048;Bg(9,Cg.bind(null,d,f,c,b),{destroy:void 0},null);return c},useId:function(){var a=ng(),b=P.identifierPrefix;if(K){var c=Bd;var d=Ad;c=(d&~(1<<32-ub(d)-1)).toString(32)+c;b=":"+b+"R"+c;c=Xf++;0<c&&(b+="H"+
+c.toString(32));b+=":"}else c=$f++,b=":"+b+"r"+c.toString(32)+":";return a.memoizedState=b},useCacheRefresh:function(){return ng().memoizedState=mh.bind(null,S)}};cg.useMemoCache=sg;cg.useEffectEvent=function(a){var b=ng(),c={impl:a};b.memoizedState=c;return function(){if(0!==(N&2))throw Error(u(440));return c.impl.apply(void 0,arguments)}};cg.useHostTransitionStatus=jh;
 cg.useFormState=function(a,b){if(K){var c=P.formState;if(null!==c){a:{if(K){if(I){b:{var d=I;for(var e=Hd;8!==d.nodeType;){if(!e){d=null;break b}d=Rd(d);if(null===d){d=null;break b}}e=d.data;d="F!"===e||"F"===e?d:null}if(d){I=Rd(d);d="F!"===d.data;break a}}Td()}d=!1}d&&(b=c[0])}}c=ng();c.memoizedState=c.baseState=b;d={pending:null,lanes:0,dispatch:null,lastRenderedReducer:Ng,lastRenderedState:b};c.queue=d;c=hh.bind(null,S,d);d.dispatch=c;d=ng();e={state:b,dispatch:null,action:a,pending:null};d.queue=
 e;c=Jg.bind(null,S,e,c);e.dispatch=c;d.memoizedState=a;return[b,c]};cg.useOptimistic=function(a){var b=ng();b.memoizedState=b.baseState=a;var c={pending:null,lanes:0,dispatch:null,lastRenderedReducer:null,lastRenderedState:null};b.queue=c;b=gh.bind(null,S,!0,c);c.dispatch=b;return[a,b]};
 var dg={readContext:rg,use:qg,useCallback:ah,useContext:rg,useEffect:zg,useImperativeHandle:Zg,useInsertionEffect:Wg,useLayoutEffect:Xg,useMemo:bh,useReducer:ug,useRef:Qg,useState:function(){return ug(tg)},useDebugValue:$g,useDeferredValue:function(a,b){var c=og();return eh(c,T.memoizedState,a,b)},useTransition:function(){var a=ug(tg)[0],b=og().memoizedState;return["boolean"===typeof a?a:jg(a),b]},useSyncExternalStore:yg,useId:kh};dg.useCacheRefresh=lh;dg.useMemoCache=sg;dg.useEffectEvent=Vg;
@@ -155,8 +144,8 @@ dg.useHostTransitionStatus=jh;dg.useFormState=function(a){var b=og();return Og(b
 var hg={readContext:rg,use:qg,useCallback:ah,useContext:rg,useEffect:zg,useImperativeHandle:Zg,useInsertionEffect:Wg,useLayoutEffect:Xg,useMemo:bh,useReducer:xg,useRef:Qg,useState:function(){return xg(tg)},useDebugValue:$g,useDeferredValue:function(a,b){var c=og();return null===T?ch(c,a,b):eh(c,T.memoizedState,a,b)},useTransition:function(){var a=xg(tg)[0],b=og().memoizedState;return["boolean"===typeof a?a:jg(a),b]},useSyncExternalStore:yg,useId:kh};hg.useCacheRefresh=lh;hg.useMemoCache=sg;
 hg.useEffectEvent=Vg;hg.useHostTransitionStatus=jh;hg.useFormState=function(a){var b=og(),c=T;if(null!==c)return Og(b,c,a);b=b.memoizedState;c=og();var d=c.queue.dispatch;c.memoizedState=a;return[b,d]};hg.useOptimistic=function(a,b){var c=og();if(null!==T)return Ig(c,T,a,b);c.baseState=a;return[a,c.queue.dispatch]};var sh=ba.unstable_now,th=0,uh=-1,vh=-1,wh=-1,sf=!1,tf=!1;function xh(a){vh=sh();0>a.actualStartTime&&(a.actualStartTime=sh())}
 function yh(a,b){if(0<=vh){var c=sh()-vh;a.actualDuration+=c;b&&(a.selfBaseDuration=c);vh=-1}}function zh(a){if(0<=uh){var b=sh()-uh;uh=-1;for(a=a.return;null!==a;){switch(a.tag){case 3:a.stateNode.effectDuration+=b;return;case 12:a.stateNode.effectDuration+=b;return}a=a.return}}}
-function Ah(a){if(0<=wh){var b=sh()-wh;wh=-1;for(a=a.return;null!==a;){switch(a.tag){case 3:a=a.stateNode;null!==a&&(a.passiveEffectDuration+=b);return;case 12:a=a.stateNode;null!==a&&(a.passiveEffectDuration+=b);return}a=a.return}}}function Bh(){uh=sh()}function Ch(a){for(var b=a.child;b;)a.actualDuration+=b.actualDuration,b=b.sibling}function Dh(a,b){if(a&&a.defaultProps){b=w({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}
-function Eh(a,b,c,d){b=a.memoizedState;c=c(d,b);c=null===c||void 0===c?b:w({},b,c);a.memoizedState=c;0===a.lanes&&(a.updateQueue.baseState=c)}
+function Ah(a){if(0<=wh){var b=sh()-wh;wh=-1;for(a=a.return;null!==a;){switch(a.tag){case 3:a=a.stateNode;null!==a&&(a.passiveEffectDuration+=b);return;case 12:a=a.stateNode;null!==a&&(a.passiveEffectDuration+=b);return}a=a.return}}}function Bh(){uh=sh()}function Ch(a){for(var b=a.child;b;)a.actualDuration+=b.actualDuration,b=b.sibling}function Dh(a,b){if(a&&a.defaultProps){b=x({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}
+function Eh(a,b,c,d){b=a.memoizedState;c=c(d,b);c=null===c||void 0===c?b:x({},b,c);a.memoizedState=c;0===a.lanes&&(a.updateQueue.baseState=c)}
 var Fh={isMounted:function(a){return(a=a._reactInternals)?ad(a)===a:!1},enqueueSetState:function(a,b,c){a=a._reactInternals;var d=nh(a),e=ne(d);e.payload=b;void 0!==c&&null!==c&&(e.callback=c);b=oe(a,e,d);null!==b&&(Gg(b,a,d),pe(b,a,d));sb(a,d)},enqueueReplaceState:function(a,b,c){a=a._reactInternals;var d=nh(a),e=ne(d);e.tag=1;e.payload=b;void 0!==c&&null!==c&&(e.callback=c);b=oe(a,e,d);null!==b&&(Gg(b,a,d),pe(b,a,d));sb(a,d)},enqueueForceUpdate:function(a,b){a=a._reactInternals;var c=nh(a),d=ne(c);
 d.tag=2;void 0!==b&&null!==b&&(d.callback=b);b=oe(a,d,c);null!==b&&(Gg(b,a,c),pe(b,a,c));null!==F&&"function"===typeof F.markForceUpdateScheduled&&F.markForceUpdateScheduled(a,c)}};function Gh(a,b,c,d,e,f,g){a=a.stateNode;return"function"===typeof a.shouldComponentUpdate?a.shouldComponentUpdate(d,f,g):b.prototype&&b.prototype.isPureReactComponent?!ve(c,d)||!ve(e,f):!0}
 function Hh(a,b,c){var d=!1,e=gd;var f=b.contextType;"object"===typeof f&&null!==f?f=rg(f):(e=ld(b)?jd:hd.current,d=b.contextTypes,f=(d=null!==d&&void 0!==d)?kd(a,e):gd);b=new b(c,f);a.memoizedState=null!==b.state&&void 0!==b.state?b.state:null;b.updater=Fh;a.stateNode=b;b._reactInternals=a;d&&(a=a.stateNode,a.__reactInternalMemoizedUnmaskedChildContext=e,a.__reactInternalMemoizedMaskedChildContext=f);return b}
@@ -167,20 +156,20 @@ function Lh(a,b,c){return{value:a,source:null,stack:null!=c?c:null,digest:null!=
 function Qh(a,b,c){c=ne(c);c.tag=3;var d=a.type.getDerivedStateFromError;if("function"===typeof d){var e=b.value;c.payload=function(){return d(e)};c.callback=function(){Mh(a,b)}}var f=a.stateNode;null!==f&&"function"===typeof f.componentDidCatch&&(c.callback=function(){Mh(a,b);"function"!==typeof d&&(null===Rh?Rh=new Set([this]):Rh.add(this));var g=b.stack;this.componentDidCatch(b.value,{componentStack:null!==g?g:""})});return c}
 function Sh(a){var b=a.tag;0!==(a.mode&1)||0!==b&&11!==b&&15!==b||((b=a.alternate)?(a.updateQueue=b.updateQueue,a.memoizedState=b.memoizedState,a.lanes=b.lanes):(a.updateQueue=null,a.memoizedState=null))}function Th(a,b,c,d,e){if(0===(a.mode&1))return a===b?a.flags|=65536:(a.flags|=128,c.flags|=131072,c.flags&=-52805,1===c.tag&&(null===c.alternate?c.tag=17:(b=ne(2),b.tag=2,oe(c,b,2))),c.lanes|=2),a;a.flags|=65536;a.lanes=e;return a}
 function Uh(a,b,c,d,e){c.flags|=32768;gb&&Vh(a,e);if(null!==d&&"object"===typeof d&&(d.$$typeof===Ga&&(d={then:function(){}}),"function"===typeof d.then)){Sh(c);var f=Ze.current;if(null!==f){switch(f.tag){case 13:c.mode&1&&(null===$e?Wh():null===f.alternate&&0===Xh&&(Xh=3));f.flags&=-257;Th(f,b,c,a,e);d===ye?f.flags|=16384:(b=f.updateQueue,null===b?f.updateQueue=new Set([d]):b.add(d),f.mode&1&&Yh(a,d,e));return;case 22:if(f.mode&1){f.flags|=65536;d===ye?f.flags|=16384:(b=f.updateQueue,null===b?(b=
-{transitions:null,markerInstances:null,retryQueue:new Set([d])},f.updateQueue=b):(f=b.retryQueue,null===f?b.retryQueue=new Set([d]):f.add(d)),Yh(a,d,e));return}}throw Error(t(435,f.tag));}if(1===a.tag){Yh(a,d,e);Wh();return}d=Error(t(426))}if(K&&c.mode&1&&(f=Ze.current,null!==f)){0===(f.flags&65536)&&(f.flags|=256);Th(f,b,c,a,e);Zd(Kh(d,c));return}d=Kh(d,c);Zh(d);a=b;do{switch(a.tag){case 3:a.flags|=65536;e&=-e;a.lanes|=e;e=Nh(a,d,e);qe(a,e);return;case 1:if(f=d,b=a.type,c=a.stateNode,0===(a.flags&
-128)&&("function"===typeof b.getDerivedStateFromError||null!==c&&"function"===typeof c.componentDidCatch&&(null===Rh||!Rh.has(c)))){a.flags|=65536;e&=-e;a.lanes|=e;e=Qh(a,f,e);qe(a,e);return}}a=a.return}while(null!==a)}var $h=da.ReactCurrentOwner,ai=Error(t(461)),wg=!1;function bi(a,b,c,d){b.child=null===a?Se(b,null,c,d):Re(b,a.child,c,d)}
+{transitions:null,markerInstances:null,retryQueue:new Set([d])},f.updateQueue=b):(f=b.retryQueue,null===f?b.retryQueue=new Set([d]):f.add(d)),Yh(a,d,e));return}}throw Error(u(435,f.tag));}if(1===a.tag){Yh(a,d,e);Wh();return}d=Error(u(426))}if(K&&c.mode&1&&(f=Ze.current,null!==f)){0===(f.flags&65536)&&(f.flags|=256);Th(f,b,c,a,e);Zd(Kh(d,c));return}d=Kh(d,c);Zh(d);a=b;do{switch(a.tag){case 3:a.flags|=65536;e&=-e;a.lanes|=e;e=Nh(a,d,e);qe(a,e);return;case 1:if(f=d,b=a.type,c=a.stateNode,0===(a.flags&
+128)&&("function"===typeof b.getDerivedStateFromError||null!==c&&"function"===typeof c.componentDidCatch&&(null===Rh||!Rh.has(c)))){a.flags|=65536;e&=-e;a.lanes|=e;e=Qh(a,f,e);qe(a,e);return}}a=a.return}while(null!==a)}var $h=da.ReactCurrentOwner,ai=Error(u(461)),wg=!1;function bi(a,b,c,d){b.child=null===a?Se(b,null,c,d):Re(b,a.child,c,d)}
 function ci(a,b,c,d,e){c=c.render;var f=b.ref;di(b,e);mb(b);d=bg(a,b,c,d,f,e);c=kg();nb();if(null!==a&&!wg)return lg(a,b,e),ei(a,b,e);K&&c&&Ed(b);b.flags|=1;bi(a,b,d,e);return b.child}
 function fi(a,b,c,d,e){if(null===a){var f=c.type;if("function"===typeof f&&!gi(f)&&void 0===f.defaultProps&&null===c.compare&&void 0===c.defaultProps)return b.tag=15,b.type=f,hi(a,b,f,d,e);a=Ne(c.type,null,d,null,b,b.mode,e);a.ref=b.ref;a.return=b;return b.child=a}f=a.child;if(0===(a.lanes&e)){var g=f.memoizedProps;c=c.compare;c=null!==c?c:ve;if(c(g,d)&&a.ref===b.ref)return ei(a,b,e)}b.flags|=1;a=Le(f,d);a.ref=b.ref;a.return=b;return b.child=a}
 function hi(a,b,c,d,e){if(null!==a){var f=a.memoizedProps;if(ve(f,d)&&a.ref===b.ref)if(wg=!1,b.pendingProps=d=f,0!==(a.lanes&e))0!==(a.flags&131072)&&(wg=!0);else return b.lanes=a.lanes,ei(a,b,e)}return ii(a,b,c,d,e)}
 function ji(a,b,c){var d=b.pendingProps,e=d.children,f=0!==(b.stateNode._pendingVisibility&2),g=null!==a?a.memoizedState:null;ki(a,b);if("hidden"===d.mode||f){if(0!==(b.flags&128)){c=null!==g?g.baseLanes|c:c;if(null!==a){d=b.child=a.child;for(e=0;null!==d;)e=e|d.lanes|d.childLanes,d=d.sibling;b.childLanes=e&~c}else b.childLanes=0,b.child=null;return li(a,b,c)}if(0===(b.mode&1))b.memoizedState={baseLanes:0,cachePool:null},null!==a&&mi(b,null),Xe(),cf(b);else if(0!==(c&536870912))b.memoizedState={baseLanes:0,
 cachePool:null},null!==a&&mi(b,null!==g?g.cachePool:null),null!==g?Ve(b,g):Xe(),cf(b);else return b.lanes=b.childLanes=536870912,li(a,b,null!==g?g.baseLanes|c:c)}else null!==g?(mi(b,g.cachePool),Ve(b,g),df(b),b.memoizedState=null):(null!==a&&mi(b,null),Xe(),df(b));bi(a,b,e,c);return b.child}function li(a,b,c){var d=ni();d=null===d?null:{parent:oi._currentValue,pool:d};b.memoizedState={baseLanes:c,cachePool:d};null!==a&&mi(b,null);Xe();cf(b);return null}
 function ki(a,b){var c=b.ref;if(null===a&&null!==c||null!==a&&a.ref!==c)b.flags|=512,b.flags|=2097152}function ii(a,b,c,d,e){var f=ld(c)?jd:hd.current;f=kd(b,f);di(b,e);mb(b);c=bg(a,b,c,d,f,e);d=kg();nb();if(null!==a&&!wg)return lg(a,b,e),ei(a,b,e);K&&d&&Ed(b);b.flags|=1;bi(a,b,c,e);return b.child}function pi(a,b,c,d,e,f){di(b,f);mb(b);c=eg(b,d,c,e);fg();d=kg();nb();if(null!==a&&!wg)return lg(a,b,f),ei(a,b,f);K&&d&&Ed(b);b.flags|=1;bi(a,b,c,f);return b.child}
-function qi(a,b,c,d,e){if(ld(c)){var f=!0;pd(b)}else f=!1;di(b,e);if(null===b.stateNode)ri(a,b),Hh(b,c,d),Jh(b,c,d,e),d=!0;else if(null===a){var g=b.stateNode,h=b.memoizedProps;g.props=h;var l=g.context,p=c.contextType;"object"===typeof p&&null!==p?p=rg(p):(p=ld(c)?jd:hd.current,p=kd(b,p));var q=c.getDerivedStateFromProps,x="function"===typeof q||"function"===typeof g.getSnapshotBeforeUpdate;x||"function"!==typeof g.UNSAFE_componentWillReceiveProps&&"function"!==typeof g.componentWillReceiveProps||
-(h!==d||l!==p)&&Ih(b,g,d,p);ke=!1;var r=b.memoizedState;g.state=r;re(b,d,g,e);l=b.memoizedState;h!==d||r!==l||id.current||ke?("function"===typeof q&&(Eh(b,c,q,d),l=b.memoizedState),(h=ke||Gh(b,c,h,d,r,l,p))?(x||"function"!==typeof g.UNSAFE_componentWillMount&&"function"!==typeof g.componentWillMount||("function"===typeof g.componentWillMount&&g.componentWillMount(),"function"===typeof g.UNSAFE_componentWillMount&&g.UNSAFE_componentWillMount()),"function"===typeof g.componentDidMount&&(b.flags|=4194308)):
-("function"===typeof g.componentDidMount&&(b.flags|=4194308),b.memoizedProps=d,b.memoizedState=l),g.props=d,g.state=l,g.context=p,d=h):("function"===typeof g.componentDidMount&&(b.flags|=4194308),d=!1)}else{g=b.stateNode;me(a,b);h=b.memoizedProps;p=b.type===b.elementType?h:Dh(b.type,h);g.props=p;x=b.pendingProps;r=g.context;l=c.contextType;"object"===typeof l&&null!==l?l=rg(l):(l=ld(c)?jd:hd.current,l=kd(b,l));var u=c.getDerivedStateFromProps;(q="function"===typeof u||"function"===typeof g.getSnapshotBeforeUpdate)||
-"function"!==typeof g.UNSAFE_componentWillReceiveProps&&"function"!==typeof g.componentWillReceiveProps||(h!==x||r!==l)&&Ih(b,g,d,l);ke=!1;r=b.memoizedState;g.state=r;re(b,d,g,e);var A=b.memoizedState;h!==x||r!==A||id.current||ke?("function"===typeof u&&(Eh(b,c,u,d),A=b.memoizedState),(p=ke||Gh(b,c,p,d,r,A,l)||!1)?(q||"function"!==typeof g.UNSAFE_componentWillUpdate&&"function"!==typeof g.componentWillUpdate||("function"===typeof g.componentWillUpdate&&g.componentWillUpdate(d,A,l),"function"===typeof g.UNSAFE_componentWillUpdate&&
-g.UNSAFE_componentWillUpdate(d,A,l)),"function"===typeof g.componentDidUpdate&&(b.flags|=4),"function"===typeof g.getSnapshotBeforeUpdate&&(b.flags|=1024)):("function"!==typeof g.componentDidUpdate||h===a.memoizedProps&&r===a.memoizedState||(b.flags|=4),"function"!==typeof g.getSnapshotBeforeUpdate||h===a.memoizedProps&&r===a.memoizedState||(b.flags|=1024),b.memoizedProps=d,b.memoizedState=A),g.props=d,g.state=A,g.context=l,d=p):("function"!==typeof g.componentDidUpdate||h===a.memoizedProps&&r===
-a.memoizedState||(b.flags|=4),"function"!==typeof g.getSnapshotBeforeUpdate||h===a.memoizedProps&&r===a.memoizedState||(b.flags|=1024),d=!1)}return si(a,b,c,d,f,e)}
+function qi(a,b,c,d,e){if(ld(c)){var f=!0;pd(b)}else f=!1;di(b,e);if(null===b.stateNode)ri(a,b),Hh(b,c,d),Jh(b,c,d,e),d=!0;else if(null===a){var g=b.stateNode,h=b.memoizedProps;g.props=h;var l=g.context,n=c.contextType;"object"===typeof n&&null!==n?n=rg(n):(n=ld(c)?jd:hd.current,n=kd(b,n));var q=c.getDerivedStateFromProps,w="function"===typeof q||"function"===typeof g.getSnapshotBeforeUpdate;w||"function"!==typeof g.UNSAFE_componentWillReceiveProps&&"function"!==typeof g.componentWillReceiveProps||
+(h!==d||l!==n)&&Ih(b,g,d,n);ke=!1;var t=b.memoizedState;g.state=t;re(b,d,g,e);l=b.memoizedState;h!==d||t!==l||id.current||ke?("function"===typeof q&&(Eh(b,c,q,d),l=b.memoizedState),(h=ke||Gh(b,c,h,d,t,l,n))?(w||"function"!==typeof g.UNSAFE_componentWillMount&&"function"!==typeof g.componentWillMount||("function"===typeof g.componentWillMount&&g.componentWillMount(),"function"===typeof g.UNSAFE_componentWillMount&&g.UNSAFE_componentWillMount()),"function"===typeof g.componentDidMount&&(b.flags|=4194308)):
+("function"===typeof g.componentDidMount&&(b.flags|=4194308),b.memoizedProps=d,b.memoizedState=l),g.props=d,g.state=l,g.context=n,d=h):("function"===typeof g.componentDidMount&&(b.flags|=4194308),d=!1)}else{g=b.stateNode;me(a,b);h=b.memoizedProps;n=b.type===b.elementType?h:Dh(b.type,h);g.props=n;w=b.pendingProps;t=g.context;l=c.contextType;"object"===typeof l&&null!==l?l=rg(l):(l=ld(c)?jd:hd.current,l=kd(b,l));var r=c.getDerivedStateFromProps;(q="function"===typeof r||"function"===typeof g.getSnapshotBeforeUpdate)||
+"function"!==typeof g.UNSAFE_componentWillReceiveProps&&"function"!==typeof g.componentWillReceiveProps||(h!==w||t!==l)&&Ih(b,g,d,l);ke=!1;t=b.memoizedState;g.state=t;re(b,d,g,e);var A=b.memoizedState;h!==w||t!==A||id.current||ke?("function"===typeof r&&(Eh(b,c,r,d),A=b.memoizedState),(n=ke||Gh(b,c,n,d,t,A,l)||!1)?(q||"function"!==typeof g.UNSAFE_componentWillUpdate&&"function"!==typeof g.componentWillUpdate||("function"===typeof g.componentWillUpdate&&g.componentWillUpdate(d,A,l),"function"===typeof g.UNSAFE_componentWillUpdate&&
+g.UNSAFE_componentWillUpdate(d,A,l)),"function"===typeof g.componentDidUpdate&&(b.flags|=4),"function"===typeof g.getSnapshotBeforeUpdate&&(b.flags|=1024)):("function"!==typeof g.componentDidUpdate||h===a.memoizedProps&&t===a.memoizedState||(b.flags|=4),"function"!==typeof g.getSnapshotBeforeUpdate||h===a.memoizedProps&&t===a.memoizedState||(b.flags|=1024),b.memoizedProps=d,b.memoizedState=A),g.props=d,g.state=A,g.context=l,d=n):("function"!==typeof g.componentDidUpdate||h===a.memoizedProps&&t===
+a.memoizedState||(b.flags|=4),"function"!==typeof g.getSnapshotBeforeUpdate||h===a.memoizedProps&&t===a.memoizedState||(b.flags|=1024),d=!1)}return si(a,b,c,d,f,e)}
 function si(a,b,c,d,e,f){ki(a,b);var g=0!==(b.flags&128);if(!d&&!g)return e&&qd(b,c,!1),ei(a,b,f);d=b.stateNode;$h.current=b;if(g&&"function"!==typeof c.getDerivedStateFromError){var h=null;vh=-1}else mb(b),h=d.render(),nb();b.flags|=1;null!==a&&g?(g=h,b.child=Re(b,a.child,null,f),b.child=Re(b,null,g,f)):bi(a,b,h,f);b.memoizedState=d.state;e&&qd(b,c,!0);return b.child}
 function ti(a){var b=a.stateNode;b.pendingContext?nd(a,b.pendingContext,b.pendingContext!==b.context):b.context&&nd(a,b.context,!1);Oa(a,b.containerInfo)}function ui(a,b,c,d,e){Yd();Zd(e);b.flags|=256;bi(a,b,c,d);return b.child}var vi={dehydrated:null,treeContext:null,retryLane:0};function wi(a){return{baseLanes:a,cachePool:xi()}}
 function yi(a,b,c){var d=b.pendingProps,e=!1,f=0!==(b.flags&128),g;(g=f)||(g=null!==a&&null===a.memoizedState?!1:0!==(bf.current&2));g&&(e=!0,b.flags&=-129);if(null===a){if(K){e?af(b):df(b);K&&((f=a=I,f)?Qd(b,f)||(Sd(b)&&Td(),I=Rd(f),g=H,I&&Qd(b,I)?Id(g,f):(Kd(H,b),K=!1,H=b,I=a)):(Sd(b)&&Td(),Kd(H,b),K=!1,H=b,I=a));a=b.memoizedState;if(null!==a&&(a=a.dehydrated,null!==a))return 0===(b.mode&1)?b.lanes=2:"$!"===a.data?b.lanes=16:b.lanes=536870912,null;ef(b)}a=d.children;f=d.fallback;if(e)return df(b),
@@ -188,19 +177,19 @@ a=zi(b,a,f,c),b.child.memoizedState=wi(c),b.memoizedState=vi,a;if("number"===typ
 0,d.actualStartTime=-1,d.selfBaseDuration=g.selfBaseDuration,d.treeBaseDuration=g.treeBaseDuration),b.deletions=null):(d=Le(g,l),d.subtreeFlags=g.subtreeFlags&31457280);null!==h?e=Le(h,e):(e=Pe(e,f,c,null),e.flags|=2);e.return=b;d.return=b;d.sibling=e;b.child=d;d=e;e=b.child;f=a.child.memoizedState;null===f?f=wi(c):(g=f.cachePool,null!==g?(h=oi._currentValue,g=g.parent!==h?{parent:h,pool:h}:g):g=xi(),f={baseLanes:f.baseLanes|c,cachePool:g});e.memoizedState=f;e.childLanes=a.childLanes&~c;b.memoizedState=
 vi;return d}af(b);e=a.child;a=e.sibling;d=Le(e,{mode:"visible",children:d.children});0===(b.mode&1)&&(d.lanes=c);d.return=b;d.sibling=null;null!==a&&(c=b.deletions,null===c?(b.deletions=[a],b.flags|=16):c.push(a));b.child=d;b.memoizedState=null;return d}function Ai(a,b){b=Ci({mode:"visible",children:b},a.mode,0,null);b.return=a;return a.child=b}
 function zi(a,b,c,d){var e=a.mode,f=a.child;b={mode:"hidden",children:b};0===(e&1)&&null!==f?(f.childLanes=0,f.pendingProps=b,a.mode&2&&(f.actualDuration=0,f.actualStartTime=-1,f.selfBaseDuration=0,f.treeBaseDuration=0)):f=Ci(b,e,0,null);c=Pe(c,e,d,null);f.return=a;c.return=a;f.sibling=c;a.child=f;return c}function Di(a,b,c,d){null!==d&&Zd(d);Re(b,a.child,null,c);a=Ai(b,b.pendingProps.children);a.flags|=2;b.memoizedState=null;return a}
-function Bi(a,b,c,d,e,f,g){if(c){if(b.flags&256)return af(b),b.flags&=-257,e=Lh(Error(t(422))),Di(a,b,g,e);if(null!==b.memoizedState)return df(b),b.child=a.child,b.flags|=128,null;df(b);e=d.fallback;f=b.mode;d=Ci({mode:"visible",children:d.children},f,0,null);e=Pe(e,f,g,null);e.flags|=2;d.return=b;e.return=b;d.sibling=e;b.child=d;0!==(b.mode&1)&&Re(b,a.child,null,g);b.child.memoizedState=wi(g);b.memoizedState=vi;return e}af(b);if(0===(b.mode&1))return Di(a,b,g,null);if("$!"===e.data){e=e.nextSibling&&
-e.nextSibling.dataset;if(e)var h=e.dgst;e=h;f=null;"POSTPONE"!==e&&(f=Error(t(419)),f.digest=e,f=Lh(f,e,void 0));return Di(a,b,g,f)}h=0!==(g&a.childLanes);if(wg||h){d=P;if(null!==d){h=g&-g;if(0!==(h&42))h=1;else switch(h){case 2:h=1;break;case 8:h=4;break;case 32:h=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:h=64;break;
+function Bi(a,b,c,d,e,f,g){if(c){if(b.flags&256)return af(b),b.flags&=-257,e=Lh(Error(u(422))),Di(a,b,g,e);if(null!==b.memoizedState)return df(b),b.child=a.child,b.flags|=128,null;df(b);e=d.fallback;f=b.mode;d=Ci({mode:"visible",children:d.children},f,0,null);e=Pe(e,f,g,null);e.flags|=2;d.return=b;e.return=b;d.sibling=e;b.child=d;0!==(b.mode&1)&&Re(b,a.child,null,g);b.child.memoizedState=wi(g);b.memoizedState=vi;return e}af(b);if(0===(b.mode&1))return Di(a,b,g,null);if("$!"===e.data){e=e.nextSibling&&
+e.nextSibling.dataset;if(e)var h=e.dgst;e=h;f=null;"POSTPONE"!==e&&(f=Error(u(419)),f.digest=e,f=Lh(f,e,void 0));return Di(a,b,g,f)}h=0!==(g&a.childLanes);if(wg||h){d=P;if(null!==d){h=g&-g;if(0!==(h&42))h=1;else switch(h){case 2:h=1;break;case 8:h=4;break;case 32:h=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:h=64;break;
 case 268435456:h=134217728;break;default:h=0}h=0!==(h&(d.suspendedLanes|g))?0:h;if(0!==h&&h!==f.retryLane)throw f.retryLane=h,he(a,h),Gg(d,a,h),ai;}"$?"!==e.data&&Wh();return Di(a,b,g,null)}if("$?"===e.data)return b.flags|=128,b.child=a.child,b=Ei.bind(null,a),e._reactRetry=b,null;a=f.treeContext;I=Nd(e.nextSibling);H=b;K=!0;Gd=null;Hd=!1;null!==a&&(xd[yd++]=Ad,xd[yd++]=Bd,xd[yd++]=zd,Ad=a.id,Bd=a.overflow,zd=b);b=Ai(b,d.children);b.flags|=4096;return b}
 function Fi(a,b,c){a.lanes|=b;var d=a.alternate;null!==d&&(d.lanes|=b);Gi(a.return,b,c)}function Hi(a,b,c,d,e){var f=a.memoizedState;null===f?a.memoizedState={isBackwards:b,rendering:null,renderingStartTime:0,last:d,tail:c,tailMode:e}:(f.isBackwards=b,f.rendering=null,f.renderingStartTime=0,f.last=d,f.tail=c,f.tailMode=e)}
 function Ii(a,b,c){var d=b.pendingProps,e=d.revealOrder,f=d.tail;bi(a,b,d.children,c);d=bf.current;if(0!==(d&2))d=d&1|2,b.flags|=128;else{if(null!==a&&0!==(a.flags&128))a:for(a=b.child;null!==a;){if(13===a.tag)null!==a.memoizedState&&Fi(a,c,b);else if(19===a.tag)Fi(a,c,b);else if(null!==a.child){a.child.return=a;a=a.child;continue}if(a===b)break a;for(;null===a.sibling;){if(null===a.return||a.return===b)break a;a=a.return}a.sibling.return=a.return;a=a.sibling}d&=1}E(bf,d);if(0===(b.mode&1))b.memoizedState=
 null;else switch(e){case "forwards":c=b.child;for(e=null;null!==c;)a=c.alternate,null!==a&&null===ff(a)&&(e=c),c=c.sibling;c=e;null===c?(e=b.child,b.child=null):(e=c.sibling,c.sibling=null);Hi(b,!1,e,c,f);break;case "backwards":c=null;e=b.child;for(b.child=null;null!==e;){a=e.alternate;if(null!==a&&null===ff(a)){b.child=e;break}a=e.sibling;e.sibling=c;c=e;e=a}Hi(b,!0,c,null,f);break;case "together":Hi(b,!1,null,null,void 0);break;default:b.memoizedState=null}return b.child}
-function ri(a,b){0===(b.mode&1)&&null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2)}function ei(a,b,c){null!==a&&(b.dependencies=a.dependencies);vh=-1;se|=b.lanes;if(0===(c&b.childLanes))return null;if(null!==a&&b.child!==a.child)throw Error(t(153));if(null!==b.child){a=b.child;c=Le(a,a.pendingProps);b.child=c;for(c.return=b;null!==a.sibling;)a=a.sibling,c=c.sibling=Le(a,a.pendingProps),c.return=b;c.sibling=null}return b.child}
+function ri(a,b){0===(b.mode&1)&&null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2)}function ei(a,b,c){null!==a&&(b.dependencies=a.dependencies);vh=-1;se|=b.lanes;if(0===(c&b.childLanes))return null;if(null!==a&&b.child!==a.child)throw Error(u(153));if(null!==b.child){a=b.child;c=Le(a,a.pendingProps);b.child=c;for(c.return=b;null!==a.sibling;)a=a.sibling,c=c.sibling=Le(a,a.pendingProps),c.return=b;c.sibling=null}return b.child}
 function Ji(a,b,c){switch(b.tag){case 3:ti(b);Ki(b,oi,a.memoizedState.cache);Yd();break;case 27:case 5:Sa(b);break;case 1:ld(b.type)&&pd(b);break;case 4:Oa(b,b.stateNode.containerInfo);break;case 10:Ki(b,b.type._context,b.memoizedProps.value);break;case 12:0!==(c&b.childLanes)&&(b.flags|=4);var d=b.stateNode;d.effectDuration=0;d.passiveEffectDuration=0;break;case 13:d=b.memoizedState;if(null!==d){if(null!==d.dehydrated)return af(b),b.flags|=128,null;if(0!==(c&b.child.childLanes))return yi(a,b,c);
 af(b);a=ei(a,b,c);return null!==a?a.sibling:null}af(b);break;case 19:d=0!==(c&b.childLanes);if(0!==(a.flags&128)){if(d)return Ii(a,b,c);b.flags|=128}var e=b.memoizedState;null!==e&&(e.rendering=null,e.tail=null,e.lastEffect=null);E(bf,bf.current);if(d)break;else return null;case 22:case 23:return b.lanes=0,ji(a,b,c);case 24:Ki(b,oi,a.memoizedState.cache)}return ei(a,b,c)}var Li=ma(null),Mi=null,Ni=null,Oi=null;function Pi(){Oi=Ni=Mi=null}
 function Ki(a,b,c){E(Li,b._currentValue);b._currentValue=c}function Qi(a){var b=Li.current;a._currentValue=b===Ea?a._defaultValue:b;D(Li)}function Gi(a,b,c){for(;null!==a;){var d=a.alternate;(a.childLanes&b)!==b?(a.childLanes|=b,null!==d&&(d.childLanes|=b)):null!==d&&(d.childLanes&b)!==b&&(d.childLanes|=b);if(a===c)break;a=a.return}}
 function Ri(a,b,c){var d=a.child;null!==d&&(d.return=a);for(;null!==d;){var e=d.dependencies;if(null!==e){var f=d.child;for(var g=e.firstContext;null!==g;){if(g.context===b){if(1===d.tag){g=ne(c&-c);g.tag=2;var h=d.updateQueue;if(null!==h){h=h.shared;var l=h.pending;null===l?g.next=g:(g.next=l.next,l.next=g);h.pending=g}}d.lanes|=c;g=d.alternate;null!==g&&(g.lanes|=c);Gi(d.return,c,a);e.lanes|=c;break}g=g.next}}else if(10===d.tag)f=d.type===a.type?null:d.child;else if(18===d.tag){f=d.return;if(null===
-f)throw Error(t(341));f.lanes|=c;e=f.alternate;null!==e&&(e.lanes|=c);Gi(f,c,a);f=d.sibling}else f=d.child;if(null!==f)f.return=d;else for(f=d;null!==f;){if(f===a){f=null;break}d=f.sibling;if(null!==d){d.return=f.return;f=d;break}f=f.return}d=f}}function di(a,b){Mi=a;Oi=Ni=null;a=a.dependencies;null!==a&&null!==a.firstContext&&(0!==(a.lanes&b)&&(wg=!0),a.firstContext=null)}function rg(a){return Si(Mi,a)}function Qe(a,b,c){null===Mi&&di(a,c);return Si(a,b)}
-function Si(a,b){var c=b._currentValue;if(Oi!==b)if(b={context:b,memoizedValue:c,next:null},null===Ni){if(null===a)throw Error(t(308));Ni=b;a.dependencies={lanes:0,firstContext:b}}else Ni=Ni.next=b;return c}
+f)throw Error(u(341));f.lanes|=c;e=f.alternate;null!==e&&(e.lanes|=c);Gi(f,c,a);f=d.sibling}else f=d.child;if(null!==f)f.return=d;else for(f=d;null!==f;){if(f===a){f=null;break}d=f.sibling;if(null!==d){d.return=f.return;f=d;break}f=f.return}d=f}}function di(a,b){Mi=a;Oi=Ni=null;a=a.dependencies;null!==a&&null!==a.firstContext&&(0!==(a.lanes&b)&&(wg=!0),a.firstContext=null)}function rg(a){return Si(Mi,a)}function Qe(a,b,c){null===Mi&&di(a,c);return Si(a,b)}
+function Si(a,b){var c=b._currentValue;if(Oi!==b)if(b={context:b,memoizedValue:c,next:null},null===Ni){if(null===a)throw Error(u(308));Ni=b;a.dependencies={lanes:0,firstContext:b}}else Ni=Ni.next=b;return c}
 var Ti="undefined"!==typeof AbortController?AbortController:function(){var a=[],b=this.signal={aborted:!1,addEventListener:function(c,d){a.push(d)}};this.abort=function(){b.aborted=!0;a.forEach(function(c){return c()})}},Ui=ba.unstable_scheduleCallback,Vi=ba.unstable_NormalPriority,oi={$$typeof:ta,Consumer:null,Provider:null,_currentValue:null,_currentValue2:null,_threadCount:0,_defaultValue:null,_globalName:null};function oh(){return{controller:new Ti,data:new Map,refCount:0}}
 function Wi(a){a.refCount--;0===a.refCount&&Ui(Vi,function(){a.controller.abort()})}var Xi=da.ReactCurrentBatchConfig,Yi=ma(null);function ni(){var a=Yi.current;return null!==a?a:P.pooledCache}function mi(a,b){null===b?E(Yi,Yi.current):E(Yi,b.pool)}function xi(){var a=ni();return null===a?null:{parent:oi._currentValue,pool:a}}function Zi(a){a.flags|=4}function $i(a){a.flags|=2097664}
 function aj(a,b){if("stylesheet"!==b.type||0!==(b.state.loading&4))a.flags&=-16777217;else if(a.flags|=16777216,0===(O&42)&&(b="stylesheet"===b.type&&0===(b.state.loading&3)?!1:!0,!b))if(bj())a.flags|=8192;else throw Ce=ye,xe;}function cj(a,b){null!==b?a.flags|=4:a.flags&16384&&(b=22!==a.tag?Db():536870912,a.lanes|=b)}
@@ -208,27 +197,27 @@ function dj(a,b){if(!K)switch(a.tailMode){case "hidden":b=a.tail;for(var c=null;
 function V(a){var b=null!==a.alternate&&a.alternate.child===a.child,c=0,d=0;if(b)if(0!==(a.mode&2)){for(var e=a.selfBaseDuration,f=a.child;null!==f;)c|=f.lanes|f.childLanes,d|=f.subtreeFlags&31457280,d|=f.flags&31457280,e+=f.treeBaseDuration,f=f.sibling;a.treeBaseDuration=e}else for(e=a.child;null!==e;)c|=e.lanes|e.childLanes,d|=e.subtreeFlags&31457280,d|=e.flags&31457280,e.return=a,e=e.sibling;else if(0!==(a.mode&2)){e=a.actualDuration;f=a.selfBaseDuration;for(var g=a.child;null!==g;)c|=g.lanes|
 g.childLanes,d|=g.subtreeFlags,d|=g.flags,e+=g.actualDuration,f+=g.treeBaseDuration,g=g.sibling;a.actualDuration=e;a.treeBaseDuration=f}else for(e=a.child;null!==e;)c|=e.lanes|e.childLanes,d|=e.subtreeFlags,d|=e.flags,e.return=a,e=e.sibling;a.subtreeFlags|=d;a.childLanes=c;return b}
 function ej(a,b,c){var d=b.pendingProps;Fd(b);switch(b.tag){case 2:case 16:case 15:case 0:case 11:case 7:case 8:case 12:case 9:case 14:return V(b),null;case 1:return ld(b.type)&&md(),V(b),null;case 3:c=b.stateNode;d=null;null!==a&&(d=a.memoizedState.cache);b.memoizedState.cache!==d&&(b.flags|=2048);Qi(oi);Ra();D(id);D(hd);c.pendingContext&&(c.context=c.pendingContext,c.pendingContext=null);if(null===a||null===a.child)Vd(b)?Zi(b):null===a||a.memoizedState.isDehydrated&&0===(b.flags&256)||(b.flags|=
-1024,null!==Gd&&(fj(Gd),Gd=null));V(b);return null;case 26:c=b.memoizedState;if(null===a)Zi(b),null!==b.ref&&$i(b),null!==c?(V(b),aj(b,c)):(V(b),b.flags&=-16777217);else{var e=a.memoizedState;c!==e&&Zi(b);a.ref!==b.ref&&$i(b);null!==c?(V(b),c===e?b.flags&=-16777217:aj(b,c)):(a.memoizedProps!==d&&Zi(b),V(b),b.flags&=-16777217)}return null;case 27:Ta(b);c=La.current;e=b.type;if(null!==a&&null!=b.stateNode)a.memoizedProps!==d&&Zi(b),a.ref!==b.ref&&$i(b);else{if(!d){if(null===b.stateNode)throw Error(t(166));
-V(b);return null}a=Ja.current;Vd(b)?gj(b.stateNode,b.type,b.memoizedProps,a,b):(a=hj(e,d,c),b.stateNode=a,Zi(b));null!==b.ref&&$i(b)}V(b);return null;case 5:Ta(b);c=b.type;if(null!==a&&null!=b.stateNode)a.memoizedProps!==d&&Zi(b),a.ref!==b.ref&&$i(b);else{if(!d){if(null===b.stateNode)throw Error(t(166));V(b);return null}a=Ja.current;if(Vd(b))gj(b.stateNode,b.type,b.memoizedProps,a,b);else{e=ij(La.current);switch(a){case 1:a=e.createElementNS("http://www.w3.org/2000/svg",c);break;case 2:a=e.createElementNS("http://www.w3.org/1998/Math/MathML",
+1024,null!==Gd&&(fj(Gd),Gd=null));V(b);return null;case 26:c=b.memoizedState;if(null===a)Zi(b),null!==b.ref&&$i(b),null!==c?(V(b),aj(b,c)):(V(b),b.flags&=-16777217);else{var e=a.memoizedState;c!==e&&Zi(b);a.ref!==b.ref&&$i(b);null!==c?(V(b),c===e?b.flags&=-16777217:aj(b,c)):(a.memoizedProps!==d&&Zi(b),V(b),b.flags&=-16777217)}return null;case 27:Ta(b);c=La.current;e=b.type;if(null!==a&&null!=b.stateNode)a.memoizedProps!==d&&Zi(b),a.ref!==b.ref&&$i(b);else{if(!d){if(null===b.stateNode)throw Error(u(166));
+V(b);return null}a=Ja.current;Vd(b)?gj(b.stateNode,b.type,b.memoizedProps,a,b):(a=hj(e,d,c),b.stateNode=a,Zi(b));null!==b.ref&&$i(b)}V(b);return null;case 5:Ta(b);c=b.type;if(null!==a&&null!=b.stateNode)a.memoizedProps!==d&&Zi(b),a.ref!==b.ref&&$i(b);else{if(!d){if(null===b.stateNode)throw Error(u(166));V(b);return null}a=Ja.current;if(Vd(b))gj(b.stateNode,b.type,b.memoizedProps,a,b);else{e=ij(La.current);switch(a){case 1:a=e.createElementNS("http://www.w3.org/2000/svg",c);break;case 2:a=e.createElementNS("http://www.w3.org/1998/Math/MathML",
 c);break;default:switch(c){case "svg":a=e.createElementNS("http://www.w3.org/2000/svg",c);break;case "math":a=e.createElementNS("http://www.w3.org/1998/Math/MathML",c);break;case "script":a=e.createElement("div");a.innerHTML="<script>\x3c/script>";a=a.removeChild(a.firstChild);break;case "select":a="string"===typeof d.is?e.createElement("select",{is:d.is}):e.createElement("select");d.multiple?a.multiple=!0:d.size&&(a.size=d.size);break;default:a="string"===typeof d.is?e.createElement(c,{is:d.is}):
 e.createElement(c)}}a[Rb]=b;a[Sb]=d;a:for(e=b.child;null!==e;){if(5===e.tag||6===e.tag)a.appendChild(e.stateNode);else if(4!==e.tag&&27!==e.tag&&null!==e.child){e.child.return=e;e=e.child;continue}if(e===b)break a;for(;null===e.sibling;){if(null===e.return||e.return===b)break a;e=e.return}e.sibling.return=e.return;e=e.sibling}b.stateNode=a;a:switch(jj(a,c,d),c){case "button":case "input":case "select":case "textarea":a=!!d.autoFocus;break a;case "img":a=!0;break a;default:a=!1}a&&Zi(b)}null!==b.ref&&
-$i(b)}V(b);b.flags&=-16777217;return null;case 6:if(a&&null!=b.stateNode)a.memoizedProps!==d&&Zi(b);else{if("string"!==typeof d&&null===b.stateNode)throw Error(t(166));a=La.current;if(Vd(b)){a:{a=b.stateNode;c=b.memoizedProps;a[Rb]=b;if(d=a.nodeValue!==c)if(e=H,null!==e)switch(e.tag){case 3:e=0!==(e.mode&1);kj(a.nodeValue,c,e);if(e){a=!1;break a}break;case 27:case 5:var f=0!==(e.mode&1);!0!==e.memoizedProps.suppressHydrationWarning&&kj(a.nodeValue,c,f);if(f){a=!1;break a}}a=d}a&&Zi(b)}else a=ij(a).createTextNode(d),
-a[Rb]=b,b.stateNode=a}V(b);return null;case 13:ef(b);d=b.memoizedState;if(null===a||null!==a.memoizedState&&null!==a.memoizedState.dehydrated){if(K&&null!==I&&0!==(b.mode&1)&&0===(b.flags&128))Xd(),Yd(),b.flags|=384,e=!1;else if(e=Vd(b),null!==d&&null!==d.dehydrated){if(null===a){if(!e)throw Error(t(318));e=b.memoizedState;e=null!==e?e.dehydrated:null;if(!e)throw Error(t(317));e[Rb]=b;V(b);0!==(b.mode&2)&&null!==d&&(e=b.child,null!==e&&(b.treeBaseDuration-=e.treeBaseDuration))}else Yd(),0===(b.flags&
+$i(b)}V(b);b.flags&=-16777217;return null;case 6:if(a&&null!=b.stateNode)a.memoizedProps!==d&&Zi(b);else{if("string"!==typeof d&&null===b.stateNode)throw Error(u(166));a=La.current;if(Vd(b)){a:{a=b.stateNode;c=b.memoizedProps;a[Rb]=b;if(d=a.nodeValue!==c)if(e=H,null!==e)switch(e.tag){case 3:e=0!==(e.mode&1);kj(a.nodeValue,c,e);if(e){a=!1;break a}break;case 27:case 5:var f=0!==(e.mode&1);!0!==e.memoizedProps.suppressHydrationWarning&&kj(a.nodeValue,c,f);if(f){a=!1;break a}}a=d}a&&Zi(b)}else a=ij(a).createTextNode(d),
+a[Rb]=b,b.stateNode=a}V(b);return null;case 13:ef(b);d=b.memoizedState;if(null===a||null!==a.memoizedState&&null!==a.memoizedState.dehydrated){if(K&&null!==I&&0!==(b.mode&1)&&0===(b.flags&128))Xd(),Yd(),b.flags|=384,e=!1;else if(e=Vd(b),null!==d&&null!==d.dehydrated){if(null===a){if(!e)throw Error(u(318));e=b.memoizedState;e=null!==e?e.dehydrated:null;if(!e)throw Error(u(317));e[Rb]=b;V(b);0!==(b.mode&2)&&null!==d&&(e=b.child,null!==e&&(b.treeBaseDuration-=e.treeBaseDuration))}else Yd(),0===(b.flags&
 128)&&(b.memoizedState=null),b.flags|=4,V(b),0!==(b.mode&2)&&null!==d&&(e=b.child,null!==e&&(b.treeBaseDuration-=e.treeBaseDuration));e=!1}else null!==Gd&&(fj(Gd),Gd=null),e=!0;if(!e)return b.flags&256?b:null}if(0!==(b.flags&128))return b.lanes=c,0!==(b.mode&2)&&Ch(b),b;c=null!==d;a=null!==a&&null!==a.memoizedState;c&&(d=b.child,e=null,null!==d.alternate&&null!==d.alternate.memoizedState&&null!==d.alternate.memoizedState.cachePool&&(e=d.alternate.memoizedState.cachePool.pool),f=null,null!==d.memoizedState&&
 null!==d.memoizedState.cachePool&&(f=d.memoizedState.cachePool.pool),f!==e&&(d.flags|=2048));c!==a&&c&&(b.child.flags|=8192);cj(b,b.updateQueue);V(b);0!==(b.mode&2)&&c&&(a=b.child,null!==a&&(b.treeBaseDuration-=a.treeBaseDuration));return null;case 4:return Ra(),null===a&&lj(b.stateNode.containerInfo),V(b),null;case 10:return Qi(b.type._context),V(b),null;case 17:return ld(b.type)&&md(),V(b),null;case 19:D(bf);e=b.memoizedState;if(null===e)return V(b),null;d=0!==(b.flags&128);f=e.rendering;if(null===
 f)if(d)dj(e,!1);else{if(0!==Xh||null!==a&&0!==(a.flags&128))for(a=b.child;null!==a;){f=ff(a);if(null!==f){b.flags|=128;dj(e,!1);a=f.updateQueue;b.updateQueue=a;cj(b,a);b.subtreeFlags=0;a=c;for(c=b.child;null!==c;)mj(c,a),c=c.sibling;E(bf,bf.current&1|2);return b.child}a=a.sibling}null!==e.tail&&Ya()>nj&&(b.flags|=128,d=!0,dj(e,!1),b.lanes=4194304)}else{if(!d)if(a=ff(f),null!==a){if(b.flags|=128,d=!0,a=a.updateQueue,b.updateQueue=a,cj(b,a),dj(e,!0),null===e.tail&&"hidden"===e.tailMode&&!f.alternate&&
 !K)return V(b),null}else 2*Ya()-e.renderingStartTime>nj&&536870912!==c&&(b.flags|=128,d=!0,dj(e,!1),b.lanes=4194304);e.isBackwards?(f.sibling=b.child,b.child=f):(a=e.last,null!==a?a.sibling=f:b.child=f,e.last=f)}if(null!==e.tail)return b=e.tail,e.rendering=b,e.tail=b.sibling,e.renderingStartTime=Ya(),b.sibling=null,a=bf.current,E(bf,d?a&1|2:a&1),b;V(b);return null;case 22:case 23:return ef(b),Ye(),d=null!==b.memoizedState,null!==a?null!==a.memoizedState!==d&&(b.flags|=8192):d&&(b.flags|=8192),d&&
 0!==(b.mode&1)?0!==(c&536870912)&&0===(b.flags&128)&&(V(b),b.subtreeFlags&6&&(b.flags|=8192)):V(b),c=b.updateQueue,null!==c&&cj(b,c.retryQueue),c=null,null!==a&&null!==a.memoizedState&&null!==a.memoizedState.cachePool&&(c=a.memoizedState.cachePool.pool),d=null,null!==b.memoizedState&&null!==b.memoizedState.cachePool&&(d=b.memoizedState.cachePool.pool),d!==c&&(b.flags|=2048),null!==a&&D(Yi),null;case 24:return c=null,null!==a&&(c=a.memoizedState.cache),b.memoizedState.cache!==c&&(b.flags|=2048),Qi(oi),
-V(b),null;case 25:return null}throw Error(t(156,b.tag));}
-function oj(a,b){Fd(b);switch(b.tag){case 1:return ld(b.type)&&md(),a=b.flags,a&65536?(b.flags=a&-65537|128,0!==(b.mode&2)&&Ch(b),b):null;case 3:return Qi(oi),Ra(),D(id),D(hd),a=b.flags,0!==(a&65536)&&0===(a&128)?(b.flags=a&-65537|128,b):null;case 26:case 27:case 5:return Ta(b),null;case 13:ef(b);a=b.memoizedState;if(null!==a&&null!==a.dehydrated){if(null===b.alternate)throw Error(t(340));Yd()}a=b.flags;return a&65536?(b.flags=a&-65537|128,0!==(b.mode&2)&&Ch(b),b):null;case 19:return D(bf),null;case 4:return Ra(),
+V(b),null;case 25:return null}throw Error(u(156,b.tag));}
+function oj(a,b){Fd(b);switch(b.tag){case 1:return ld(b.type)&&md(),a=b.flags,a&65536?(b.flags=a&-65537|128,0!==(b.mode&2)&&Ch(b),b):null;case 3:return Qi(oi),Ra(),D(id),D(hd),a=b.flags,0!==(a&65536)&&0===(a&128)?(b.flags=a&-65537|128,b):null;case 26:case 27:case 5:return Ta(b),null;case 13:ef(b);a=b.memoizedState;if(null!==a&&null!==a.dehydrated){if(null===b.alternate)throw Error(u(340));Yd()}a=b.flags;return a&65536?(b.flags=a&-65537|128,0!==(b.mode&2)&&Ch(b),b):null;case 19:return D(bf),null;case 4:return Ra(),
 null;case 10:return Qi(b.type._context),null;case 22:case 23:return ef(b),Ye(),null!==a&&D(Yi),a=b.flags,a&65536?(b.flags=a&-65537|128,0!==(b.mode&2)&&Ch(b),b):null;case 24:return Qi(oi),null;case 25:return null;default:return null}}
 function pj(a,b){Fd(b);switch(b.tag){case 1:a=b.type.childContextTypes;null!==a&&void 0!==a&&md();break;case 3:Qi(oi);Ra();D(id);D(hd);break;case 26:case 27:case 5:Ta(b);break;case 4:Ra();break;case 13:ef(b);break;case 19:D(bf);break;case 10:Qi(b.type._context);break;case 22:case 23:ef(b);Ye();null!==a&&D(Yi);break;case 24:Qi(oi)}}function qj(a,b,c){var d=Array.prototype.slice.call(arguments,3);try{b.apply(c,d)}catch(e){this.onError(e)}}
-var rj=!1,sj=null,tj=!1,uj=null,vj={onError:function(a){rj=!0;sj=a}};function wj(a,b,c,d,e,f,g,h,l){rj=!1;sj=null;qj.apply(vj,arguments)}function xj(a,b,c,d,e,f,g,h,l){wj.apply(this,arguments);if(rj){if(rj){var p=sj;rj=!1;sj=null}else throw Error(t(198));tj||(tj=!0,uj=p)}}var yj=!1,zj=!1,Aj="function"===typeof WeakSet?WeakSet:Set,Bj=null,Cj=null,Dj=null;function Ej(a){return 0!==(a.mode&2)&&0!==(N&4)}
+var rj=!1,sj=null,tj=!1,uj=null,vj={onError:function(a){rj=!0;sj=a}};function wj(a,b,c,d,e,f,g,h,l){rj=!1;sj=null;qj.apply(vj,arguments)}function xj(a,b,c,d,e,f,g,h,l){wj.apply(this,arguments);if(rj){if(rj){var n=sj;rj=!1;sj=null}else throw Error(u(198));tj||(tj=!0,uj=n)}}var yj=!1,zj=!1,Aj="function"===typeof WeakSet?WeakSet:Set,Bj=null,Cj=null,Dj=null;function Ej(a){return 0!==(a.mode&2)&&0!==(N&4)}
 function Fj(a,b){b.props=a.memoizedProps;b.state=a.memoizedState;if(Ej(a))try{Bh(),b.componentWillUnmount()}finally{zh(a)}else b.componentWillUnmount()}function Gj(a,b){try{var c=a.ref;if(null!==c){var d=a.stateNode;switch(a.tag){case 26:case 27:case 5:var e=d;break;default:e=d}if("function"===typeof c)if(Ej(a))try{Bh(),a.refCleanup=c(e)}finally{zh(a)}else a.refCleanup=c(e);else c.current=e}}catch(f){W(a,b,f)}}
 function Hj(a,b){var c=a.ref,d=a.refCleanup;if(null!==c)if("function"===typeof d)try{if(Ej(a))try{Bh(),d()}finally{zh(a)}else d()}catch(e){W(a,b,e)}finally{a.refCleanup=null,a=a.alternate,null!=a&&(a.refCleanup=null)}else if("function"===typeof c)try{if(Ej(a))try{Bh(),c(null)}finally{zh(a)}else c(null)}catch(e){W(a,b,e)}else c.current=null}function Ij(a,b,c){try{c()}catch(d){W(a,b,d)}}var Jj=!1;
-function Kj(a,b){Lj=Mj;a=Nj();if(Oj(a)){if("selectionStart"in a)var c={start:a.selectionStart,end:a.selectionEnd};else a:{c=(c=a.ownerDocument)&&c.defaultView||window;var d=c.getSelection&&c.getSelection();if(d&&0!==d.rangeCount){c=d.anchorNode;var e=d.anchorOffset,f=d.focusNode;d=d.focusOffset;try{c.nodeType,f.nodeType}catch(B){c=null;break a}var g=0,h=-1,l=-1,p=0,q=0,x=a,r=null;b:for(;;){for(var u;;){x!==c||0!==e&&3!==x.nodeType||(h=g+e);x!==f||0!==d&&3!==x.nodeType||(l=g+d);3===x.nodeType&&(g+=
-x.nodeValue.length);if(null===(u=x.firstChild))break;r=x;x=u}for(;;){if(x===a)break b;r===c&&++p===e&&(h=g);r===f&&++q===d&&(l=g);if(null!==(u=x.nextSibling))break;x=r;r=x.parentNode}x=u}c=-1===h||-1===l?null:{start:h,end:l}}else c=null}c=c||{start:0,end:0}}else c=null;Pj={focusedElem:a,selectionRange:c};Mj=!1;for(Bj=b;null!==Bj;)if(b=Bj,a=b.child,0!==(b.subtreeFlags&1028)&&null!==a)a.return=b,Bj=a;else for(;null!==Bj;){b=Bj;try{var A=b.alternate,C=b.flags;switch(b.tag){case 0:if(0!==(C&4)){var J=
-b.updateQueue,Q=null!==J?J.events:null;if(null!==Q)for(a=0;a<Q.length;a++){var m=Q[a];m.ref.impl=m.nextImpl}}break;case 11:case 15:break;case 1:if(0!==(C&1024)&&null!==A){var k=A.memoizedProps,n=A.memoizedState,v=b.stateNode,y=v.getSnapshotBeforeUpdate(b.elementType===b.type?k:Dh(b.type,k),n);v.__reactInternalSnapshotBeforeUpdate=y}break;case 3:0!==(C&1024)&&Qj(b.stateNode.containerInfo);break;case 5:case 26:case 27:case 6:case 4:case 17:break;default:if(0!==(C&1024))throw Error(t(163));}}catch(B){W(b,
+function Kj(a,b){Lj=Mj;a=Nj();if(Oj(a)){if("selectionStart"in a)var c={start:a.selectionStart,end:a.selectionEnd};else a:{c=(c=a.ownerDocument)&&c.defaultView||window;var d=c.getSelection&&c.getSelection();if(d&&0!==d.rangeCount){c=d.anchorNode;var e=d.anchorOffset,f=d.focusNode;d=d.focusOffset;try{c.nodeType,f.nodeType}catch(B){c=null;break a}var g=0,h=-1,l=-1,n=0,q=0,w=a,t=null;b:for(;;){for(var r;;){w!==c||0!==e&&3!==w.nodeType||(h=g+e);w!==f||0!==d&&3!==w.nodeType||(l=g+d);3===w.nodeType&&(g+=
+w.nodeValue.length);if(null===(r=w.firstChild))break;t=w;w=r}for(;;){if(w===a)break b;t===c&&++n===e&&(h=g);t===f&&++q===d&&(l=g);if(null!==(r=w.nextSibling))break;w=t;t=w.parentNode}w=r}c=-1===h||-1===l?null:{start:h,end:l}}else c=null}c=c||{start:0,end:0}}else c=null;Pj={focusedElem:a,selectionRange:c};Mj=!1;for(Bj=b;null!==Bj;)if(b=Bj,a=b.child,0!==(b.subtreeFlags&1028)&&null!==a)a.return=b,Bj=a;else for(;null!==Bj;){b=Bj;try{var A=b.alternate,C=b.flags;switch(b.tag){case 0:if(0!==(C&4)){var J=
+b.updateQueue,Q=null!==J?J.events:null;if(null!==Q)for(a=0;a<Q.length;a++){var m=Q[a];m.ref.impl=m.nextImpl}}break;case 11:case 15:break;case 1:if(0!==(C&1024)&&null!==A){var k=A.memoizedProps,p=A.memoizedState,v=b.stateNode,y=v.getSnapshotBeforeUpdate(b.elementType===b.type?k:Dh(b.type,k),p);v.__reactInternalSnapshotBeforeUpdate=y}break;case 3:0!==(C&1024)&&Qj(b.stateNode.containerInfo);break;case 5:case 26:case 27:case 6:case 4:case 17:break;default:if(0!==(C&1024))throw Error(u(163));}}catch(B){W(b,
 b.return,B)}a=b.sibling;if(null!==a){a.return=b.return;Bj=a;break}Bj=b.return}A=Jj;Jj=!1;return A}
 function Rj(a,b,c){var d=b.updateQueue;d=null!==d?d.lastEffect:null;if(null!==d){var e=d=d.next;do{if((e.tag&a)===a){var f=e.inst,g=f.destroy;void 0!==g&&(f.destroy=void 0,0!==(a&8)?null!==F&&"function"===typeof F.markComponentPassiveEffectUnmountStarted&&F.markComponentPassiveEffectUnmountStarted(b):0!==(a&4)&&ob(b),Ij(b,c,g),0!==(a&8)?null!==F&&"function"===typeof F.markComponentPassiveEffectUnmountStopped&&F.markComponentPassiveEffectUnmountStopped():0!==(a&4)&&pb())}e=e.next}while(e!==d)}}
 function Sj(a,b){var c=b.updateQueue;c=null!==c?c.lastEffect:null;if(null!==c){var d=c=c.next;do{if((d.tag&a)===a){0!==(a&8)?null!==F&&"function"===typeof F.markComponentPassiveEffectMountStarted&&F.markComponentPassiveEffectMountStarted(b):0!==(a&4)&&null!==F&&"function"===typeof F.markComponentLayoutEffectMountStarted&&F.markComponentLayoutEffectMountStarted(b);var e=d.create,f=d.inst;e=e();f.destroy=e;0!==(a&8)?null!==F&&"function"===typeof F.markComponentPassiveEffectMountStopped&&F.markComponentPassiveEffectMountStopped():
@@ -245,21 +234,21 @@ function hk(a,b,c){var d=a.tag;if(5===d||6===d)a=a.stateNode,b?c.insertBefore(a,
 function lk(a,b,c){if(fb&&"function"===typeof fb.onCommitFiberUnmount)try{fb.onCommitFiberUnmount(eb,c)}catch(l){}switch(c.tag){case 26:zj||Hj(c,b);kk(a,b,c);c.memoizedState?c.memoizedState.count--:c.stateNode&&(c=c.stateNode,c.parentNode.removeChild(c));break;case 27:zj||Hj(c,b);var d=ik,e=jk;ik=c.stateNode;kk(a,b,c);c=c.stateNode;for(a=c.attributes;a.length;)c.removeAttributeNode(a[0]);Zb(c);ik=d;jk=e;break;case 5:zj||Hj(c,b);case 6:d=ik;e=jk;ik=null;kk(a,b,c);ik=d;jk=e;null!==ik&&(jk?(a=ik,c=c.stateNode,
 8===a.nodeType?a.parentNode.removeChild(c):a.removeChild(c)):ik.removeChild(c.stateNode));break;case 18:null!==ik&&(jk?(a=ik,c=c.stateNode,8===a.nodeType?mk(a.parentNode,c):1===a.nodeType&&mk(a,c),nk(a)):mk(ik,c.stateNode));break;case 4:d=ik;e=jk;ik=c.stateNode.containerInfo;jk=!0;kk(a,b,c);ik=d;jk=e;break;case 0:case 11:case 14:case 15:if(!zj&&(d=c.updateQueue,null!==d&&(d=d.lastEffect,null!==d))){e=d=d.next;do{var f=e.tag,g=e.inst,h=g.destroy;void 0!==h&&(0!==(f&2)?(g.destroy=void 0,Ij(c,b,h)):
 0!==(f&4)&&(ob(c),Ej(c)?(Bh(),g.destroy=void 0,Ij(c,b,h),zh(c)):(g.destroy=void 0,Ij(c,b,h)),pb()));e=e.next}while(e!==d)}kk(a,b,c);break;case 1:if(!zj&&(Hj(c,b),d=c.stateNode,"function"===typeof d.componentWillUnmount))try{Fj(c,d)}catch(l){W(c,b,l)}kk(a,b,c);break;case 21:kk(a,b,c);break;case 22:Hj(c,b);c.mode&1?(zj=(d=zj)||null!==c.memoizedState,kk(a,b,c),zj=d):kk(a,b,c);break;default:kk(a,b,c)}}
-function ak(a,b){if(null===b.memoizedState&&(a=b.alternate,null!==a&&(a=a.memoizedState,null!==a&&(a=a.dehydrated,null!==a))))try{nk(a)}catch(c){W(b,b.return,c)}}function ok(a){switch(a.tag){case 13:case 19:var b=a.stateNode;null===b&&(b=a.stateNode=new Aj);return b;case 22:return a=a.stateNode,b=a._retryCache,null===b&&(b=a._retryCache=new Aj),b;default:throw Error(t(435,a.tag));}}
-function pk(a,b){var c=ok(a);b.forEach(function(d){var e=qk.bind(null,a,d);if(!c.has(d)){c.add(d);if(gb)if(null!==Cj&&null!==Dj)Vh(Dj,Cj);else throw Error(t(413));d.then(e,e)}})}function rk(a,b,c){Cj=c;Dj=a;sk(b,a);Dj=Cj=null}
-function tk(a,b){var c=b.deletions;if(null!==c)for(var d=0;d<c.length;d++){var e=c[d];try{var f=a,g=b,h=g;a:for(;null!==h;){switch(h.tag){case 27:case 5:ik=h.stateNode;jk=!1;break a;case 3:ik=h.stateNode.containerInfo;jk=!0;break a;case 4:ik=h.stateNode.containerInfo;jk=!0;break a}h=h.return}if(null===ik)throw Error(t(160));lk(f,g,e);ik=null;jk=!1;var l=e.alternate;null!==l&&(l.return=null);e.return=null}catch(p){W(e,b,p)}}if(b.subtreeFlags&12854)for(b=b.child;null!==b;)sk(b,a),b=b.sibling}
+function ak(a,b){if(null===b.memoizedState&&(a=b.alternate,null!==a&&(a=a.memoizedState,null!==a&&(a=a.dehydrated,null!==a))))try{nk(a)}catch(c){W(b,b.return,c)}}function ok(a){switch(a.tag){case 13:case 19:var b=a.stateNode;null===b&&(b=a.stateNode=new Aj);return b;case 22:return a=a.stateNode,b=a._retryCache,null===b&&(b=a._retryCache=new Aj),b;default:throw Error(u(435,a.tag));}}
+function pk(a,b){var c=ok(a);b.forEach(function(d){var e=qk.bind(null,a,d);if(!c.has(d)){c.add(d);if(gb)if(null!==Cj&&null!==Dj)Vh(Dj,Cj);else throw Error(u(413));d.then(e,e)}})}function rk(a,b,c){Cj=c;Dj=a;sk(b,a);Dj=Cj=null}
+function tk(a,b){var c=b.deletions;if(null!==c)for(var d=0;d<c.length;d++){var e=c[d];try{var f=a,g=b,h=g;a:for(;null!==h;){switch(h.tag){case 27:case 5:ik=h.stateNode;jk=!1;break a;case 3:ik=h.stateNode.containerInfo;jk=!0;break a;case 4:ik=h.stateNode.containerInfo;jk=!0;break a}h=h.return}if(null===ik)throw Error(u(160));lk(f,g,e);ik=null;jk=!1;var l=e.alternate;null!==l&&(l.return=null);e.return=null}catch(n){W(e,b,n)}}if(b.subtreeFlags&12854)for(b=b.child;null!==b;)sk(b,a),b=b.sibling}
 var uk=null;
-function sk(a,b){var c=a.alternate,d=a.flags;switch(a.tag){case 0:case 11:case 14:case 15:tk(b,a);vk(a);if(d&4){try{Rj(3,a,a.return),Sj(3,a)}catch(u){W(a,a.return,u)}if(Ej(a)){try{Bh(),Rj(5,a,a.return)}catch(u){W(a,a.return,u)}zh(a)}else try{Rj(5,a,a.return)}catch(u){W(a,a.return,u)}}break;case 1:tk(b,a);vk(a);d&512&&null!==c&&Hj(c,c.return);d&64&&yj&&(a=a.updateQueue,null!==a&&(c=a.callbacks,null!==c&&(d=a.shared.hiddenCallbacks,a.shared.hiddenCallbacks=null===d?c:d.concat(c))));break;case 26:var e=
+function sk(a,b){var c=a.alternate,d=a.flags;switch(a.tag){case 0:case 11:case 14:case 15:tk(b,a);vk(a);if(d&4){try{Rj(3,a,a.return),Sj(3,a)}catch(r){W(a,a.return,r)}if(Ej(a)){try{Bh(),Rj(5,a,a.return)}catch(r){W(a,a.return,r)}zh(a)}else try{Rj(5,a,a.return)}catch(r){W(a,a.return,r)}}break;case 1:tk(b,a);vk(a);d&512&&null!==c&&Hj(c,c.return);d&64&&yj&&(a=a.updateQueue,null!==a&&(c=a.callbacks,null!==c&&(d=a.shared.hiddenCallbacks,a.shared.hiddenCallbacks=null===d?c:d.concat(c))));break;case 26:var e=
 uk;tk(b,a);vk(a);d&512&&null!==c&&Hj(c,c.return);if(d&4)if(b=null!==c?c.memoizedState:null,d=a.memoizedState,null===c)if(null===d)if(null===a.stateNode){a:{c=a.type;d=a.memoizedProps;b=e.ownerDocument||e;b:switch(c){case "title":e=b.getElementsByTagName("title")[0];if(!e||e[Yb]||e[Rb]||"http://www.w3.org/2000/svg"===e.namespaceURI||e.hasAttribute("itemprop"))e=b.createElement(c),b.head.insertBefore(e,b.querySelector("head > title"));jj(e,c,d);e[Rb]=a;fc(e);c=e;break a;case "link":var f=wk("link",
 "href",b).get(c+(d.href||""));if(f)for(var g=0;g<f.length;g++)if(e=f[g],e.getAttribute("href")===(null==d.href?null:d.href)&&e.getAttribute("rel")===(null==d.rel?null:d.rel)&&e.getAttribute("title")===(null==d.title?null:d.title)&&e.getAttribute("crossorigin")===(null==d.crossOrigin?null:d.crossOrigin)){f.splice(g,1);break b}e=b.createElement(c);jj(e,c,d);b.head.appendChild(e);break;case "meta":if(f=wk("meta","content",b).get(c+(d.content||"")))for(g=0;g<f.length;g++)if(e=f[g],e.getAttribute("content")===
-(null==d.content?null:""+d.content)&&e.getAttribute("name")===(null==d.name?null:d.name)&&e.getAttribute("property")===(null==d.property?null:d.property)&&e.getAttribute("http-equiv")===(null==d.httpEquiv?null:d.httpEquiv)&&e.getAttribute("charset")===(null==d.charSet?null:d.charSet)){f.splice(g,1);break b}e=b.createElement(c);jj(e,c,d);b.head.appendChild(e);break;default:throw Error(t(468,c));}e[Rb]=a;fc(e);c=e}a.stateNode=c}else xk(e,a.type,a.stateNode);else a.stateNode=yk(e,d,a.memoizedProps);
-else if(b!==d)null===b?null!==c.stateNode&&(c=c.stateNode,c.parentNode.removeChild(c)):b.count--,null===d?xk(e,a.type,a.stateNode):yk(e,d,a.memoizedProps);else if(null===d&&null!==a.stateNode){a.updateQueue=null;try{var h=a.stateNode,l=a.memoizedProps;zk(h,a.type,c.memoizedProps,l);h[Sb]=l}catch(u){W(a,a.return,u)}}break;case 27:if(d&4&&null===a.alternate){e=a.stateNode;f=a.memoizedProps;for(g=e.firstChild;g;){var p=g.nextSibling,q=g.nodeName;g[Yb]||"HEAD"===q||"BODY"===q||"SCRIPT"===q||"STYLE"===
-q||"LINK"===q&&"stylesheet"===g.rel.toLowerCase()||e.removeChild(g);g=p}g=a.type;for(p=e.attributes;p.length;)e.removeAttributeNode(p[0]);jj(e,g,f);e[Rb]=a;e[Sb]=f}case 5:tk(b,a);vk(a);d&512&&null!==c&&Hj(c,c.return);if(a.flags&32){b=a.stateNode;try{Oc(b,"")}catch(u){W(a,a.return,u)}}if(d&4&&(d=a.stateNode,null!=d)){b=a.memoizedProps;c=null!==c?c.memoizedProps:b;e=a.type;a.updateQueue=null;try{zk(d,e,c,b),d[Sb]=b}catch(u){W(a,a.return,u)}}break;case 6:tk(b,a);vk(a);if(d&4){if(null===a.stateNode)throw Error(t(162));
-c=a.stateNode;d=a.memoizedProps;try{c.nodeValue=d}catch(u){W(a,a.return,u)}}break;case 3:Ak=null;e=uk;uk=Bk(b.containerInfo);tk(b,a);uk=e;vk(a);if(d&4&&null!==c&&c.memoizedState.isDehydrated)try{nk(b.containerInfo)}catch(u){W(a,a.return,u)}break;case 4:c=uk;uk=Bk(a.stateNode.containerInfo);tk(b,a);vk(a);uk=c;break;case 13:tk(b,a);vk(a);a.child.flags&8192&&null!==a.memoizedState!==(null!==c&&null!==c.memoizedState)&&(Ck=Ya());d&4&&(c=a.updateQueue,null!==c&&(a.updateQueue=null,pk(a,c)));break;case 22:d&
-512&&null!==c&&Hj(c,c.return);h=null!==a.memoizedState;l=null!==c&&null!==c.memoizedState;if(a.mode&1){var x=yj,r=zj;yj=x||h;zj=r||l;tk(b,a);zj=r;yj=x}else tk(b,a);vk(a);b=a.stateNode;b._current=a;b._visibility&=-3;b._visibility|=b._pendingVisibility&2;if(d&8192&&(b._visibility=h?b._visibility&-2:b._visibility|1,h&&(b=yj||zj,null===c||l||b||0!==(a.mode&1)&&Dk(a)),null===a.memoizedProps||"manual"!==a.memoizedProps.mode))a:for(c=null,b=a;;){if(5===b.tag||26===b.tag||27===b.tag){if(null===c){c=b;try{e=
-b.stateNode,h?(f=e.style,"function"===typeof f.setProperty?f.setProperty("display","none","important"):f.display="none"):(g=b.stateNode,p=b.memoizedProps.style,q=void 0!==p&&null!==p&&p.hasOwnProperty("display")?p.display:null,g.style.display=null==q||"boolean"===typeof q?"":(""+q).trim())}catch(u){W(a,a.return,u)}}}else if(6===b.tag){if(null===c)try{b.stateNode.nodeValue=h?"":b.memoizedProps}catch(u){W(a,a.return,u)}}else if((22!==b.tag&&23!==b.tag||null===b.memoizedState||b===a)&&null!==b.child){b.child.return=
+(null==d.content?null:""+d.content)&&e.getAttribute("name")===(null==d.name?null:d.name)&&e.getAttribute("property")===(null==d.property?null:d.property)&&e.getAttribute("http-equiv")===(null==d.httpEquiv?null:d.httpEquiv)&&e.getAttribute("charset")===(null==d.charSet?null:d.charSet)){f.splice(g,1);break b}e=b.createElement(c);jj(e,c,d);b.head.appendChild(e);break;default:throw Error(u(468,c));}e[Rb]=a;fc(e);c=e}a.stateNode=c}else xk(e,a.type,a.stateNode);else a.stateNode=yk(e,d,a.memoizedProps);
+else if(b!==d)null===b?null!==c.stateNode&&(c=c.stateNode,c.parentNode.removeChild(c)):b.count--,null===d?xk(e,a.type,a.stateNode):yk(e,d,a.memoizedProps);else if(null===d&&null!==a.stateNode){a.updateQueue=null;try{var h=a.stateNode,l=a.memoizedProps;zk(h,a.type,c.memoizedProps,l);h[Sb]=l}catch(r){W(a,a.return,r)}}break;case 27:if(d&4&&null===a.alternate){e=a.stateNode;f=a.memoizedProps;for(g=e.firstChild;g;){var n=g.nextSibling,q=g.nodeName;g[Yb]||"HEAD"===q||"BODY"===q||"SCRIPT"===q||"STYLE"===
+q||"LINK"===q&&"stylesheet"===g.rel.toLowerCase()||e.removeChild(g);g=n}g=a.type;for(n=e.attributes;n.length;)e.removeAttributeNode(n[0]);jj(e,g,f);e[Rb]=a;e[Sb]=f}case 5:tk(b,a);vk(a);d&512&&null!==c&&Hj(c,c.return);if(a.flags&32){b=a.stateNode;try{Oc(b,"")}catch(r){W(a,a.return,r)}}if(d&4&&(d=a.stateNode,null!=d)){b=a.memoizedProps;c=null!==c?c.memoizedProps:b;e=a.type;a.updateQueue=null;try{zk(d,e,c,b),d[Sb]=b}catch(r){W(a,a.return,r)}}break;case 6:tk(b,a);vk(a);if(d&4){if(null===a.stateNode)throw Error(u(162));
+c=a.stateNode;d=a.memoizedProps;try{c.nodeValue=d}catch(r){W(a,a.return,r)}}break;case 3:Ak=null;e=uk;uk=Bk(b.containerInfo);tk(b,a);uk=e;vk(a);if(d&4&&null!==c&&c.memoizedState.isDehydrated)try{nk(b.containerInfo)}catch(r){W(a,a.return,r)}break;case 4:c=uk;uk=Bk(a.stateNode.containerInfo);tk(b,a);vk(a);uk=c;break;case 13:tk(b,a);vk(a);a.child.flags&8192&&null!==a.memoizedState!==(null!==c&&null!==c.memoizedState)&&(Ck=Ya());d&4&&(c=a.updateQueue,null!==c&&(a.updateQueue=null,pk(a,c)));break;case 22:d&
+512&&null!==c&&Hj(c,c.return);h=null!==a.memoizedState;l=null!==c&&null!==c.memoizedState;if(a.mode&1){var w=yj,t=zj;yj=w||h;zj=t||l;tk(b,a);zj=t;yj=w}else tk(b,a);vk(a);b=a.stateNode;b._current=a;b._visibility&=-3;b._visibility|=b._pendingVisibility&2;if(d&8192&&(b._visibility=h?b._visibility&-2:b._visibility|1,h&&(b=yj||zj,null===c||l||b||0!==(a.mode&1)&&Dk(a)),null===a.memoizedProps||"manual"!==a.memoizedProps.mode))a:for(c=null,b=a;;){if(5===b.tag||26===b.tag||27===b.tag){if(null===c){c=b;try{e=
+b.stateNode,h?(f=e.style,"function"===typeof f.setProperty?f.setProperty("display","none","important"):f.display="none"):(g=b.stateNode,n=b.memoizedProps.style,q=void 0!==n&&null!==n&&n.hasOwnProperty("display")?n.display:null,g.style.display=null==q||"boolean"===typeof q?"":(""+q).trim())}catch(r){W(a,a.return,r)}}}else if(6===b.tag){if(null===c)try{b.stateNode.nodeValue=h?"":b.memoizedProps}catch(r){W(a,a.return,r)}}else if((22!==b.tag&&23!==b.tag||null===b.memoizedState||b===a)&&null!==b.child){b.child.return=
 b;b=b.child;continue}if(b===a)break a;for(;null===b.sibling;){if(null===b.return||b.return===a)break a;c===b&&(c=null);b=b.return}c===b&&(c=null);b.sibling.return=b.return;b=b.sibling}d&4&&(c=a.updateQueue,null!==c&&(d=c.retryQueue,null!==d&&(c.retryQueue=null,pk(a,d))));break;case 19:tk(b,a);vk(a);d&4&&(c=a.updateQueue,null!==c&&(a.updateQueue=null,pk(a,c)));break;case 21:break;default:tk(b,a),vk(a)}}
-function vk(a){var b=a.flags;if(b&2){try{if(27!==a.tag){b:{for(var c=a.return;null!==c;){if(dk(c)){var d=c;break b}c=c.return}throw Error(t(160));}switch(d.tag){case 27:var e=d.stateNode,f=ek(a);hk(a,f,e);break;case 5:var g=d.stateNode;d.flags&32&&(Oc(g,""),d.flags&=-33);var h=ek(a);hk(a,h,g);break;case 3:case 4:var l=d.stateNode.containerInfo,p=ek(a);fk(a,p,l);break;default:throw Error(t(161));}}}catch(q){W(a,a.return,q)}a.flags&=-3}b&4096&&(a.flags&=-4097)}
+function vk(a){var b=a.flags;if(b&2){try{if(27!==a.tag){b:{for(var c=a.return;null!==c;){if(dk(c)){var d=c;break b}c=c.return}throw Error(u(160));}switch(d.tag){case 27:var e=d.stateNode,f=ek(a);hk(a,f,e);break;case 5:var g=d.stateNode;d.flags&32&&(Oc(g,""),d.flags&=-33);var h=ek(a);hk(a,h,g);break;case 3:case 4:var l=d.stateNode.containerInfo,n=ek(a);fk(a,n,l);break;default:throw Error(u(161));}}}catch(q){W(a,a.return,q)}a.flags&=-3}b&4096&&(a.flags&=-4097)}
 function Ek(a,b,c){Cj=c;Dj=b;Yj(b,a.alternate,a);Dj=Cj=null}function Zj(a,b){if(b.subtreeFlags&8772)for(b=b.child;null!==b;)Yj(a,b.alternate,b),b=b.sibling}
 function Dk(a){for(a=a.child;null!==a;){var b=a;switch(b.tag){case 0:case 11:case 14:case 15:if(Ej(b))try{Bh(),Rj(4,b,b.return)}finally{zh(b)}else Rj(4,b,b.return);Dk(b);break;case 1:Hj(b,b.return);var c=b.stateNode;if("function"===typeof c.componentWillUnmount){var d=b,e=b.return;try{Fj(d,c)}catch(f){W(d,e,f)}}Dk(b);break;case 26:case 27:case 5:Hj(b,b.return);Dk(b);break;case 22:Hj(b,b.return);null===b.memoizedState&&Dk(b);break;default:Dk(b)}a=a.sibling}}
 function bk(a,b,c){c=c&&0!==(b.subtreeFlags&8772);for(b=b.child;null!==b;){var d=b.alternate,e=a,f=b,g=f.flags;switch(f.tag){case 0:case 11:case 15:bk(e,f,c);Tj(f,4);break;case 1:bk(e,f,c);e=f.stateNode;if("function"===typeof e.componentDidMount)try{e.componentDidMount()}catch(l){W(f,f.return,l)}d=f.updateQueue;if(null!==d){var h=d.shared.hiddenCallbacks;if(null!==h)for(d.shared.hiddenCallbacks=null,d=0;d<h.length;d++)te(h[d],e)}c&&g&64&&Uj(f);Gj(f,f.return);break;case 26:case 27:case 5:bk(e,f,c);
@@ -268,7 +257,7 @@ function Gk(a,b){var c=null;null!==a&&null!==a.memoizedState&&null!==a.memoizedS
 function Ik(a,b,c,d){if(b.subtreeFlags&10256)for(b=b.child;null!==b;)Jk(a,b,c,d),b=b.sibling}
 function Jk(a,b,c,d){var e=b.flags;switch(b.tag){case 0:case 11:case 15:Ik(a,b,c,d);e&2048&&Fk(b,9);break;case 3:Ik(a,b,c,d);e&2048&&(a=null,null!==b.alternate&&(a=b.alternate.memoizedState.cache),b=b.memoizedState.cache,b!==a&&(b.refCount++,null!=a&&Wi(a)));break;case 23:break;case 22:var f=b.stateNode;null!==b.memoizedState?f._visibility&4?Ik(a,b,c,d):b.mode&1?Kk(a,b):(f._visibility|=4,Ik(a,b,c,d)):f._visibility&4?Ik(a,b,c,d):(f._visibility|=4,Lk(a,b,c,d,0!==(b.subtreeFlags&10256)));e&2048&&Gk(b.alternate,
 b);break;case 24:Ik(a,b,c,d);e&2048&&Hk(b.alternate,b);break;default:Ik(a,b,c,d)}}
-function Lk(a,b,c,d,e){e=e&&0!==(b.subtreeFlags&10256);for(b=b.child;null!==b;){var f=a,g=b,h=c,l=d,p=g.flags;switch(g.tag){case 0:case 11:case 15:Lk(f,g,h,l,e);Fk(g,8);break;case 23:break;case 22:var q=g.stateNode;null!==g.memoizedState?q._visibility&4?Lk(f,g,h,l,e):g.mode&1?Kk(f,g):(q._visibility|=4,Lk(f,g,h,l,e)):(q._visibility|=4,Lk(f,g,h,l,e));e&&p&2048&&Gk(g.alternate,g);break;case 24:Lk(f,g,h,l,e);e&&p&2048&&Hk(g.alternate,g);break;default:Lk(f,g,h,l,e)}b=b.sibling}}
+function Lk(a,b,c,d,e){e=e&&0!==(b.subtreeFlags&10256);for(b=b.child;null!==b;){var f=a,g=b,h=c,l=d,n=g.flags;switch(g.tag){case 0:case 11:case 15:Lk(f,g,h,l,e);Fk(g,8);break;case 23:break;case 22:var q=g.stateNode;null!==g.memoizedState?q._visibility&4?Lk(f,g,h,l,e):g.mode&1?Kk(f,g):(q._visibility|=4,Lk(f,g,h,l,e)):(q._visibility|=4,Lk(f,g,h,l,e));e&&n&2048&&Gk(g.alternate,g);break;case 24:Lk(f,g,h,l,e);e&&n&2048&&Hk(g.alternate,g);break;default:Lk(f,g,h,l,e)}b=b.sibling}}
 function Kk(a,b){if(b.subtreeFlags&10256)for(b=b.child;null!==b;){var c=a,d=b,e=d.flags;switch(d.tag){case 22:Kk(c,d);e&2048&&Gk(d.alternate,d);break;case 24:Kk(c,d);e&2048&&Hk(d.alternate,d);break;default:Kk(c,d)}b=b.sibling}}var Mk=8192;function Nk(a){if(a.subtreeFlags&Mk)for(a=a.child;null!==a;)Ok(a),a=a.sibling}
 function Ok(a){switch(a.tag){case 26:Nk(a);a.flags&Mk&&null!==a.memoizedState&&Pk(uk,a.memoizedState,a.memoizedProps);break;case 5:Nk(a);break;case 3:case 4:var b=uk;uk=Bk(a.stateNode.containerInfo);Nk(a);uk=b;break;case 22:null===a.memoizedState&&(b=a.alternate,null!==b&&null!==b.memoizedState?(b=Mk,Mk=16777216,Nk(a),Mk=b):Nk(a));break;default:Nk(a)}}function Qk(a){var b=a.alternate;if(null!==b&&(a=b.child,null!==a)){b.child=null;do b=a.sibling,a.sibling=null,a=b;while(null!==a)}}
 function Rk(a,b,c){Ej(a)?(wh=sh(),Rj(c,a,b),Ah(a)):Rj(c,a,b)}function Sk(a){var b=a.deletions;if(0!==(a.flags&16)){if(null!==b)for(var c=0;c<b.length;c++){var d=b[c];Bj=d;Tk(d,a)}Qk(a)}if(a.subtreeFlags&10256)for(a=a.child;null!==a;)Uk(a),a=a.sibling}
@@ -278,8 +267,8 @@ function Tk(a,b){for(;null!==Bj;){var c=Bj;switch(c.tag){case 0:case 11:case 15:
 var Wk={getCacheSignal:function(){return rg(oi).controller.signal},getCacheForType:function(a){var b=rg(oi),c=b.data.get(a);void 0===c&&(c=a(),b.data.set(a,c));return c}},Xk="function"===typeof WeakMap?WeakMap:Map,Yk=da.ReactCurrentDispatcher,Zk=da.ReactCurrentCache,$k=da.ReactCurrentOwner,al=da.ReactCurrentBatchConfig,N=0,P=null,X=null,O=0,R=0,bl=null,cl=!1,We=0,Xh=0,wf=null,se=0,dl=0,el=0,Cf=0,fl=null,Af=null,Ck=0,nj=Infinity,Bf=null,Oh=!1,Ph=null,Rh=null,gl=!1,hl=null,il=0,jl=[],kl=0,ll=null,ie=
 0,je=null;function nh(a){if(0===(a.mode&1))return 2;if(0!==(N&2)&&0!==O)return O&-O;if(null!==Xi.transition)return a=Lf,0!==a?a:If();a=G;if(0!==a)return a;a=window.event;a=void 0===a?32:ml(a.type);return a}function dh(){0===Cf&&(Cf=0===(O&536870912)||K?If():536870912);return Cf}
 function Gg(a,b,c){if(a===P&&2===R||null!==a.cancelPendingCommit)xf(a,0),yf(a,O,Cf);Fb(a,c);if(0===(N&2)||a!==P)gb&&Kb(a,b,c),a===P&&(0===(N&2)&&(dl|=c),4===Xh&&yf(a,O,Cf)),nf(a),2===c&&0===N&&0===(b.mode&1)&&(nj=Ya()+500,qf(!0))}
-function Gf(a,b){tf=sf=!1;if(0!==(N&6))throw Error(t(327));var c=a.callbackNode;if(rf()&&a.callbackNode!==c)return null;var d=Ab(a,a===P?O:0);if(0===d)return null;var e=0===(d&60)&&0===(d&a.expiredLanes)&&!b;b=e?nl(a,d):uf(a,d);if(0!==b){var f=e;do{if(6===b)yf(a,d,0);else{e=a.current.alternate;if(f&&!ol(e)){b=uf(a,d);f=!1;continue}if(2===b){f=d;var g=Cb(a,f);0!==g&&(d=g,b=vf(a,f,g))}if(1===b)throw c=wf,xf(a,0),yf(a,d,0),nf(a),c;a.finishedWork=e;a.finishedLanes=d;a:{f=a;switch(b){case 0:case 1:throw Error(t(345));
-case 4:if((d&4194176)===d){yf(f,d,Cf);break a}break;case 2:case 3:case 5:break;default:throw Error(t(329));}if((d&62914560)===d&&(b=Ck+300-Ya(),10<b)){yf(f,d,Cf);if(0!==Ab(f,0))break a;f.timeoutHandle=pl(ql.bind(null,f,e,Af,Bf,d,Cf),b);break a}ql(f,e,Af,Bf,d,Cf)}}break}while(1)}nf(a);Ff(a,Ya());a=a.callbackNode===c?Gf.bind(null,a):null;return a}
+function Gf(a,b){tf=sf=!1;if(0!==(N&6))throw Error(u(327));var c=a.callbackNode;if(rf()&&a.callbackNode!==c)return null;var d=Ab(a,a===P?O:0);if(0===d)return null;var e=0===(d&60)&&0===(d&a.expiredLanes)&&!b;b=e?nl(a,d):uf(a,d);if(0!==b){var f=e;do{if(6===b)yf(a,d,0);else{e=a.current.alternate;if(f&&!ol(e)){b=uf(a,d);f=!1;continue}if(2===b){f=d;var g=Cb(a,f);0!==g&&(d=g,b=vf(a,f,g))}if(1===b)throw c=wf,xf(a,0),yf(a,d,0),nf(a),c;a.finishedWork=e;a.finishedLanes=d;a:{f=a;switch(b){case 0:case 1:throw Error(u(345));
+case 4:if((d&4194176)===d){yf(f,d,Cf);break a}break;case 2:case 3:case 5:break;default:throw Error(u(329));}if((d&62914560)===d&&(b=Ck+300-Ya(),10<b)){yf(f,d,Cf);if(0!==Ab(f,0))break a;f.timeoutHandle=pl(ql.bind(null,f,e,Af,Bf,d,Cf),b);break a}ql(f,e,Af,Bf,d,Cf)}}break}while(1)}nf(a);Ff(a,Ya());a=a.callbackNode===c?Gf.bind(null,a):null;return a}
 function vf(a,b,c){var d=fl,e=a.current.memoizedState.isDehydrated;e&&(xf(a,c).flags|=256);c=uf(a,c);if(2!==c){if(cl&&!e)return a.errorRecoveryDisabledLanes|=b,dl|=b,4;a=Af;Af=d;null!==a&&fj(a)}return c}function fj(a){null===Af?Af=a:Af.push.apply(Af,a)}function ql(a,b,c,d,e,f){if(0===(e&42)&&(rl={stylesheets:null,count:0,unsuspend:sl},Ok(b),b=tl(),null!==b)){a.cancelPendingCommit=b(zf.bind(null,a,c,d));yf(a,e,f);return}zf(a,c,d,f)}
 function ol(a){for(var b=a;;){if(b.flags&16384){var c=b.updateQueue;if(null!==c&&(c=c.stores,null!==c))for(var d=0;d<c.length;d++){var e=c[d],f=e.getSnapshot;e=e.value;try{if(!sd(f(),e))return!1}catch(g){return!1}}}c=b.child;if(b.subtreeFlags&16384&&null!==c)c.return=b,b=c;else{if(b===a)break;for(;null===b.sibling;){if(null===b.return||b.return===a)return!0;b=b.return}b.sibling.return=b.return;b=b.sibling}}return!0}
 function yf(a,b,c){b&=~el;b&=~dl;a.suspendedLanes|=b;a.pingedLanes&=~b;for(var d=a.expirationTimes,e=b;0<e;){var f=31-ub(e),g=1<<f;d[f]=-1;e&=~g}0!==c&&Hb(a,c,b)}function ul(a,b){var c=N;N|=1;try{return a(b)}finally{N=c,0===N&&(nj=Ya()+500,qf(!0))}}function vl(a){null!==hl&&0===hl.tag&&0===(N&6)&&rf();var b=N;N|=1;var c=al.transition,d=G;try{if(al.transition=null,G=2,a)return a()}finally{G=d,al.transition=c,N=b,0===(N&6)&&qf(!1)}}
@@ -287,32 +276,32 @@ function wl(){if(null!==X){if(0===R)var a=X.return;else a=X,Pi(),mg(a),Ee=null,F
 function xf(a,b){a.finishedWork=null;a.finishedLanes=0;var c=a.timeoutHandle;-1!==c&&(a.timeoutHandle=-1,xl(c));c=a.cancelPendingCommit;null!==c&&(a.cancelPendingCommit=null,c());wl();P=a;X=c=Le(a.current,null);O=b;R=0;bl=null;cl=!1;Xh=0;wf=null;Cf=el=dl=se=0;Af=fl=null;0!==(b&8)&&(b|=b&32);var d=a.entangledLanes;if(0!==d)for(a=a.entanglements,d&=b;0<d;){var e=31-ub(d),f=1<<e;b|=a[e];d&=~f}We=b;ce();return c}
 function yl(a,b){S=null;Qf.current=gg;$k.current=null;b===we?(b=De(),R=bj()&&0===(se&134217727)&&0===(dl&134217727)?2:3):b===xe?(b=De(),R=4):R=b===ai?8:null!==b&&"object"===typeof b&&"function"===typeof b.then?6:1;bl=b;a=X;if(null===a)Xh=1,wf=b;else switch(a.mode&2&&yh(a,!0),nb(),R){case 1:null!==F&&"function"===typeof F.markComponentErrored&&F.markComponentErrored(a,b,O);break;case 2:case 3:case 6:case 7:null!==F&&"function"===typeof F.markComponentSuspended&&F.markComponentSuspended(a,b,O)}}
 function bj(){var a=Ze.current;return null===a?!0:(O&4194176)===O?null===$e?!0:!1:(O&62914560)===O||0!==(O&536870912)?a===$e:!1}function zl(){var a=Yk.current;Yk.current=gg;return null===a?gg:a}function Al(){var a=Zk.current;Zk.current=Wk;return a}function Wh(){Xh=4;0===(se&134217727)&&0===(dl&134217727)||null===P||yf(P,O,Cf)}function Zh(a){4!==Xh&&(Xh=2);null===fl?fl=[a]:fl.push(a)}
-function uf(a,b){var c=N;N|=2;var d=zl(),e=Al();if(P!==a||O!==b){if(gb){var f=a.memoizedUpdaters;0<f.size&&(Vh(a,O),f.clear());Lb(a,b)}Bf=null;xf(a,b)}qb(b);b=!1;a:do try{if(0!==R&&null!==X){f=X;var g=bl;switch(R){case 8:wl();Xh=6;break a;case 3:case 2:b||null!==Ze.current||(b=!0);default:R=0,bl=null,Bl(f,g)}}Cl();break}catch(h){yl(a,h)}while(1);b&&a.shellSuspendCounter++;Pi();N=c;Yk.current=d;Zk.current=e;if(null!==X)throw Error(t(261));rb();P=null;O=0;ce();return Xh}
+function uf(a,b){var c=N;N|=2;var d=zl(),e=Al();if(P!==a||O!==b){if(gb){var f=a.memoizedUpdaters;0<f.size&&(Vh(a,O),f.clear());Lb(a,b)}Bf=null;xf(a,b)}qb(b);b=!1;a:do try{if(0!==R&&null!==X){f=X;var g=bl;switch(R){case 8:wl();Xh=6;break a;case 3:case 2:b||null!==Ze.current||(b=!0);default:R=0,bl=null,Bl(f,g)}}Cl();break}catch(h){yl(a,h)}while(1);b&&a.shellSuspendCounter++;Pi();N=c;Yk.current=d;Zk.current=e;if(null!==X)throw Error(u(261));rb();P=null;O=0;ce();return Xh}
 function Cl(){for(;null!==X;)Dl(X)}
 function nl(a,b){var c=N;N|=2;var d=zl(),e=Al();if(P!==a||O!==b){if(gb){var f=a.memoizedUpdaters;0<f.size&&(Vh(a,O),f.clear());Lb(a,b)}Bf=null;nj=Ya()+500;xf(a,b)}qb(b);a:do try{if(0!==R&&null!==X)b:switch(b=X,f=bl,R){case 1:R=0;bl=null;Bl(b,f);break;case 2:if(ze(f)){R=0;bl=null;El(b);break}b=function(){2===R&&P===a&&(R=7);nf(a)};f.then(b,b);break a;case 3:R=7;break a;case 4:R=5;break a;case 7:ze(f)?(R=0,bl=null,El(b)):(R=0,bl=null,Bl(b,f));break;case 5:switch(X.tag){case 5:case 26:case 27:b=X;R=
-0;bl=null;var g=b.sibling;if(null!==g)X=g;else{var h=b.return;null!==h?(X=h,Fl(h)):X=null}break b}R=0;bl=null;Bl(b,f);break;case 6:R=0;bl=null;Bl(b,f);break;case 8:wl();Xh=6;break a;default:throw Error(t(462));}Gl();break}catch(l){yl(a,l)}while(1);Pi();Yk.current=d;Zk.current=e;N=c;if(null!==X)return null!==F&&"function"===typeof F.markRenderYielded&&F.markRenderYielded(),0;rb();P=null;O=0;ce();return Xh}function Gl(){for(;null!==X&&!Wa();)Dl(X)}
+0;bl=null;var g=b.sibling;if(null!==g)X=g;else{var h=b.return;null!==h?(X=h,Fl(h)):X=null}break b}R=0;bl=null;Bl(b,f);break;case 6:R=0;bl=null;Bl(b,f);break;case 8:wl();Xh=6;break a;default:throw Error(u(462));}Gl();break}catch(l){yl(a,l)}while(1);Pi();Yk.current=d;Zk.current=e;N=c;if(null!==X)return null!==F&&"function"===typeof F.markRenderYielded&&F.markRenderYielded(),0;rb();P=null;O=0;ce();return Xh}function Gl(){for(;null!==X&&!Wa();)Dl(X)}
 function Dl(a){var b=a.alternate;0!==(a.mode&2)?(xh(a),b=Hl(b,a,We),yh(a,!0)):b=Hl(b,a,We);a.memoizedProps=a.pendingProps;null===b?Fl(a):X=b;$k.current=null}
 function El(a){var b=a.alternate,c=0!==(a.mode&2);c&&xh(a);switch(a.tag){case 2:a.tag=0;case 15:case 0:var d=a.type,e=a.pendingProps;e=a.elementType===d?e:Dh(d,e);var f=ld(d)?jd:hd.current;f=kd(a,f);b=pi(b,a,e,d,f,O);break;case 11:d=a.type.render;e=a.pendingProps;e=a.elementType===d?e:Dh(d,e);b=pi(b,a,e,d,a.ref,O);break;case 5:mg(a);default:pj(b,a),a=X=mj(a,We),b=Hl(b,a,We)}c&&yh(a,!0);a.memoizedProps=a.pendingProps;null===b?Fl(a):X=b;$k.current=null}
 function Bl(a,b){Pi();mg(a);Ee=null;Fe=0;var c=a.return;if(null===c||null===P)Xh=1,wf=b,X=null;else{try{Uh(P,c,a,b,O)}catch(d){throw X=c,d;}if(a.flags&32768)a:{do{b=oj(a.alternate,a);if(null!==b){b.flags&=32767;X=b;break a}if(0!==(a.mode&2)){yh(a,!1);b=a.actualDuration;for(c=a.child;null!==c;)b+=c.actualDuration,c=c.sibling;a.actualDuration=b}a=a.return;null!==a&&(a.flags|=32768,a.subtreeFlags=0,a.deletions=null);X=a}while(null!==a);Xh=6;X=null}else Fl(a)}}
 function Fl(a){var b=a;do{var c=b.alternate;a=b.return;0===(b.mode&2)?c=ej(c,b,We):(xh(b),c=ej(c,b,We),yh(b,!1));if(null!==c){X=c;return}b=b.sibling;if(null!==b){X=b;return}X=b=a}while(null!==b);0===Xh&&(Xh=5)}function zf(a,b,c,d){var e=G,f=al.transition;try{al.transition=null,G=2,Il(a,b,c,e,d)}finally{al.transition=f,G=e}return null}
-function Il(a,b,c,d,e){do rf();while(null!==hl);if(0!==(N&6))throw Error(t(327));var f=a.finishedWork,g=a.finishedLanes;null!==F&&"function"===typeof F.markCommitStarted&&F.markCommitStarted(g);if(null===f)return lb(),null;a.finishedWork=null;a.finishedLanes=0;if(f===a.current)throw Error(t(177));a.callbackNode=null;a.callbackPriority=0;a.cancelPendingCommit=null;var h=f.lanes|f.childLanes;h|=be;Gb(a,h,e);a===P&&(X=P=null,O=0);0===(f.subtreeFlags&10256)&&0===(f.flags&10256)||gl||(gl=!0,kl=h,ll=c,
+function Il(a,b,c,d,e){do rf();while(null!==hl);if(0!==(N&6))throw Error(u(327));var f=a.finishedWork,g=a.finishedLanes;null!==F&&"function"===typeof F.markCommitStarted&&F.markCommitStarted(g);if(null===f)return lb(),null;a.finishedWork=null;a.finishedLanes=0;if(f===a.current)throw Error(u(177));a.callbackNode=null;a.callbackPriority=0;a.cancelPendingCommit=null;var h=f.lanes|f.childLanes;h|=be;Gb(a,h,e);a===P&&(X=P=null,O=0);0===(f.subtreeFlags&10256)&&0===(f.flags&10256)||gl||(gl=!0,kl=h,ll=c,
 Jl(bb,function(){rf();return null}));c=0!==(f.flags&15990);if(0!==(f.subtreeFlags&15990)||c){c=al.transition;al.transition=null;e=G;G=2;var l=N;N|=4;$k.current=null;Kj(a,f);th=sh();rk(a,f,g);Kl(Pj);Mj=!!Lj;Pj=Lj=null;a.current=f;null!==F&&"function"===typeof F.markLayoutEffectsStarted&&F.markLayoutEffectsStarted(g);Ek(f,a,g);null!==F&&"function"===typeof F.markLayoutEffectsStopped&&F.markLayoutEffectsStopped();Xa();N=l;G=e;al.transition=c}else a.current=f,th=sh();gl?(gl=!1,hl=a,il=g):Ll(a,h);h=a.pendingLanes;
 0===h&&(Rh=null);hb(f.stateNode,d);gb&&a.memoizedUpdaters.clear();nf(a);if(null!==b)for(d=a.onRecoverableError,f=0;f<b.length;f++)h=b[f],c={digest:h.digest,componentStack:h.stack},d(h.value,c);if(Oh)throw Oh=!1,a=Ph,Ph=null,a;0!==(il&3)&&0!==a.tag&&rf();h=a.pendingLanes;0!==(g&4194218)&&0!==(h&42)?(tf=!0,a===je?ie++:(ie=0,je=a)):ie=0;qf(!1);lb();return null}function Ll(a,b){0===(a.pooledCacheLanes&=b)&&(b=a.pooledCache,null!=b&&(a.pooledCache=null,Wi(b)))}
-function rf(){if(null!==hl){var a=hl,b=kl;kl=0;var c=Ob(il),d=32>c?32:c;c=al.transition;var e=G;try{al.transition=null;G=d;if(null===hl)var f=!1;else{var g=ll;ll=null;d=hl;var h=il;hl=null;il=0;if(0!==(N&6))throw Error(t(331));null!==F&&"function"===typeof F.markPassiveEffectsStarted&&F.markPassiveEffectsStarted(h);var l=N;N|=4;Uk(d.current);Jk(d,d.current,h,g);g=jl;jl=[];for(h=0;h<g.length;h++){var p=g[h];if(N&4&&0!==(p.flags&4))switch(p.tag){case 12:var q=p.stateNode.passiveEffectDuration,x=p.memoizedProps,
-r=x.id,u=x.onPostCommit,A=th,C=null===p.alternate?"mount":"update";sf&&(C="nested-update");"function"===typeof u&&u(r,C,q,A);var J=p.return;b:for(;null!==J;){switch(J.tag){case 3:J.stateNode.passiveEffectDuration+=q;break b;case 12:J.stateNode.passiveEffectDuration+=q;break b}J=J.return}}}null!==F&&"function"===typeof F.markPassiveEffectsStopped&&F.markPassiveEffectsStopped();N=l;qf(!1);if(fb&&"function"===typeof fb.onPostCommitFiberRoot)try{fb.onPostCommitFiberRoot(eb,d)}catch(m){}var Q=d.current.stateNode;
+function rf(){if(null!==hl){var a=hl,b=kl;kl=0;var c=Ob(il),d=32>c?32:c;c=al.transition;var e=G;try{al.transition=null;G=d;if(null===hl)var f=!1;else{var g=ll;ll=null;d=hl;var h=il;hl=null;il=0;if(0!==(N&6))throw Error(u(331));null!==F&&"function"===typeof F.markPassiveEffectsStarted&&F.markPassiveEffectsStarted(h);var l=N;N|=4;Uk(d.current);Jk(d,d.current,h,g);g=jl;jl=[];for(h=0;h<g.length;h++){var n=g[h];if(N&4&&0!==(n.flags&4))switch(n.tag){case 12:var q=n.stateNode.passiveEffectDuration,w=n.memoizedProps,
+t=w.id,r=w.onPostCommit,A=th,C=null===n.alternate?"mount":"update";sf&&(C="nested-update");"function"===typeof r&&r(t,C,q,A);var J=n.return;b:for(;null!==J;){switch(J.tag){case 3:J.stateNode.passiveEffectDuration+=q;break b;case 12:J.stateNode.passiveEffectDuration+=q;break b}J=J.return}}}null!==F&&"function"===typeof F.markPassiveEffectsStopped&&F.markPassiveEffectsStopped();N=l;qf(!1);if(fb&&"function"===typeof fb.onPostCommitFiberRoot)try{fb.onPostCommitFiberRoot(eb,d)}catch(m){}var Q=d.current.stateNode;
 Q.effectDuration=0;Q.passiveEffectDuration=0;f=!0}return f}finally{G=e,al.transition=c,Ll(a,b)}}return!1}function Xj(a){jl.push(a);gl||(gl=!0,Jl(bb,function(){rf();return null}))}function Ml(a,b,c){b=Kh(c,b);b=Nh(a,b,2);a=oe(a,b,2);null!==a&&(Fb(a,2),nf(a))}
 function W(a,b,c){if(3===a.tag)Ml(a,a,c);else for(;null!==b;){if(3===b.tag){Ml(b,a,c);break}else if(1===b.tag){var d=b.stateNode;if("function"===typeof b.type.getDerivedStateFromError||"function"===typeof d.componentDidCatch&&(null===Rh||!Rh.has(d))){a=Kh(c,a);a=Qh(b,a,2);b=oe(b,a,2);null!==b&&(Fb(b,2),nf(b));break}}b=b.return}}
 function Yh(a,b,c){var d=a.pingCache;if(null===d){d=a.pingCache=new Xk;var e=new Set;d.set(b,e)}else e=d.get(b),void 0===e&&(e=new Set,d.set(b,e));e.has(c)||(cl=!0,e.add(c),d=Nl.bind(null,a,b,c),gb&&Vh(a,c),b.then(d,d))}function Nl(a,b,c){var d=a.pingCache;null!==d&&d.delete(b);a.pingedLanes|=a.suspendedLanes&c;P===a&&(O&c)===c&&(4===Xh||3===Xh&&(O&62914560)===O&&300>Ya()-Ck?0===(N&2)&&xf(a,0):el|=c);nf(a)}function Ol(a,b){0===b&&(b=0===(a.mode&1)?2:Db());a=he(a,b);null!==a&&(Fb(a,b),nf(a))}
-function Ei(a){var b=a.memoizedState,c=0;null!==b&&(c=b.retryLane);Ol(a,c)}function qk(a,b){var c=0;switch(a.tag){case 13:var d=a.stateNode;var e=a.memoizedState;null!==e&&(c=e.retryLane);break;case 19:d=a.stateNode;break;case 22:d=a.stateNode._retryCache;break;default:throw Error(t(314));}null!==d&&d.delete(b);Ol(a,c)}var Hl;
+function Ei(a){var b=a.memoizedState,c=0;null!==b&&(c=b.retryLane);Ol(a,c)}function qk(a,b){var c=0;switch(a.tag){case 13:var d=a.stateNode;var e=a.memoizedState;null!==e&&(c=e.retryLane);break;case 19:d=a.stateNode;break;case 22:d=a.stateNode._retryCache;break;default:throw Error(u(314));}null!==d&&d.delete(b);Ol(a,c)}var Hl;
 Hl=function(a,b,c){if(null!==a)if(a.memoizedProps!==b.pendingProps||id.current)wg=!0;else{if(0===(a.lanes&c)&&0===(b.flags&128))return wg=!1,Ji(a,b,c);wg=0!==(a.flags&131072)?!0:!1}else wg=!1,K&&0!==(b.flags&1048576)&&Dd(b,wd,b.index);b.lanes=0;switch(b.tag){case 2:var d=b.type;ri(a,b);a=b.pendingProps;var e=kd(b,hd.current);di(b,c);mb(b);e=bg(null,b,d,a,e,c);var f=kg();nb();b.flags|=1;"object"===typeof e&&null!==e&&"function"===typeof e.render&&void 0===e.$$typeof?(b.tag=1,b.memoizedState=null,b.updateQueue=
-null,ld(d)?(f=!0,pd(b)):f=!1,b.memoizedState=null!==e.state&&void 0!==e.state?e.state:null,le(b),e.updater=Fh,b.stateNode=e,e._reactInternals=b,Jh(b,d,a,c),b=si(null,b,d,!0,f,c)):(b.tag=0,K&&f&&Ed(b),bi(null,b,e,c),b=b.child);return b;case 16:d=b.elementType;a:{ri(a,b);a=b.pendingProps;e=d._init;d=e(d._payload);b.type=d;e=b.tag=Pl(d);a=Dh(d,a);switch(e){case 0:b=ii(null,b,d,a,c);break a;case 1:b=qi(null,b,d,a,c);break a;case 11:b=ci(null,b,d,a,c);break a;case 14:b=fi(null,b,d,Dh(d.type,a),c);break a}throw Error(t(306,
-d,""));}return b;case 0:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Dh(d,e),ii(a,b,d,e,c);case 1:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Dh(d,e),qi(a,b,d,e,c);case 3:a:{ti(b);if(null===a)throw Error(t(387));e=b.pendingProps;f=b.memoizedState;d=f.element;me(a,b);re(b,e,null,c);var g=b.memoizedState;e=g.cache;Ki(b,oi,e);e!==f.cache&&Ri(b,oi,c);e=g.element;if(f.isDehydrated)if(f={element:e,isDehydrated:!1,cache:g.cache},b.updateQueue.baseState=f,b.memoizedState=f,b.flags&256){d=
-Kh(Error(t(423)),b);b=ui(a,b,e,c,d);break a}else if(e!==d){d=Kh(Error(t(424)),b);b=ui(a,b,e,c,d);break a}else for(I=Nd(b.stateNode.containerInfo.firstChild),H=b,K=!0,Gd=null,Hd=!0,c=Se(b,null,e,c),b.child=c;c;)c.flags=c.flags&-3|4096,c=c.sibling;else{Yd();if(e===d){b=ei(a,b,c);break a}bi(a,b,e,c)}b=b.child}return b;case 26:return ki(a,b),c=b.memoizedState=Ql(b.type,null===a?null:a.memoizedProps,b.pendingProps),null!==a||K||null!==c||(c=b.type,a=b.pendingProps,d=ij(La.current).createElement(c),d[Rb]=
+null,ld(d)?(f=!0,pd(b)):f=!1,b.memoizedState=null!==e.state&&void 0!==e.state?e.state:null,le(b),e.updater=Fh,b.stateNode=e,e._reactInternals=b,Jh(b,d,a,c),b=si(null,b,d,!0,f,c)):(b.tag=0,K&&f&&Ed(b),bi(null,b,e,c),b=b.child);return b;case 16:d=b.elementType;a:{ri(a,b);a=b.pendingProps;e=d._init;d=e(d._payload);b.type=d;e=b.tag=Pl(d);a=Dh(d,a);switch(e){case 0:b=ii(null,b,d,a,c);break a;case 1:b=qi(null,b,d,a,c);break a;case 11:b=ci(null,b,d,a,c);break a;case 14:b=fi(null,b,d,Dh(d.type,a),c);break a}throw Error(u(306,
+d,""));}return b;case 0:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Dh(d,e),ii(a,b,d,e,c);case 1:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Dh(d,e),qi(a,b,d,e,c);case 3:a:{ti(b);if(null===a)throw Error(u(387));e=b.pendingProps;f=b.memoizedState;d=f.element;me(a,b);re(b,e,null,c);var g=b.memoizedState;e=g.cache;Ki(b,oi,e);e!==f.cache&&Ri(b,oi,c);e=g.element;if(f.isDehydrated)if(f={element:e,isDehydrated:!1,cache:g.cache},b.updateQueue.baseState=f,b.memoizedState=f,b.flags&256){d=
+Kh(Error(u(423)),b);b=ui(a,b,e,c,d);break a}else if(e!==d){d=Kh(Error(u(424)),b);b=ui(a,b,e,c,d);break a}else for(I=Nd(b.stateNode.containerInfo.firstChild),H=b,K=!0,Gd=null,Hd=!0,c=Se(b,null,e,c),b.child=c;c;)c.flags=c.flags&-3|4096,c=c.sibling;else{Yd();if(e===d){b=ei(a,b,c);break a}bi(a,b,e,c)}b=b.child}return b;case 26:return ki(a,b),c=b.memoizedState=Ql(b.type,null===a?null:a.memoizedProps,b.pendingProps),null!==a||K||null!==c||(c=b.type,a=b.pendingProps,d=ij(La.current).createElement(c),d[Rb]=
 b,d[Sb]=a,jj(d,c,a),fc(d),b.stateNode=d),null;case 27:return Sa(b),null===a&&K&&(d=b.stateNode=hj(b.type,b.pendingProps,La.current),H=b,Hd=!0,I=Nd(d.firstChild)),d=b.pendingProps.children,null!==a||K?bi(a,b,d,c):b.child=Re(b,null,d,c),ki(a,b),b.child;case 5:return Sa(b),null===a&&K&&((e=d=I,e)?Ld(b,e)||(Sd(b)&&Td(),I=Rd(e),f=H,I&&Ld(b,I)?Id(f,e):(Kd(H,b),K=!1,H=b,I=d)):(Sd(b)&&Td(),Kd(H,b),K=!1,H=b,I=d)),e=b.type,f=b.pendingProps,g=null!==a?a.memoizedProps:null,d=f.children,Wd(e,f)?d=null:null!==
 g&&Wd(e,g)&&(b.flags|=32),null!==b.memoizedState&&(e=bg(a,b,ig,null,null,c),Na._currentValue=e,wg&&null!==a&&a.memoizedState.memoizedState!==e&&Ri(b,Na,c)),ki(a,b),bi(a,b,d,c),b.child;case 6:return null===a&&K&&((d=""!==b.pendingProps,a=c=I,a&&d)?Od(b,a)||(Sd(b)&&Td(),I=Rd(a),d=H,I&&Od(b,I)?Id(d,a):(Kd(H,b),K=!1,H=b,I=c)):(Sd(b)&&Td(),Kd(H,b),K=!1,H=b,I=c)),null;case 13:return yi(a,b,c);case 4:return Oa(b,b.stateNode.containerInfo),d=b.pendingProps,null===a?b.child=Re(b,null,d,c):bi(a,b,d,c),b.child;
 case 11:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Dh(d,e),ci(a,b,d,e,c);case 7:return bi(a,b,b.pendingProps,c),b.child;case 8:return bi(a,b,b.pendingProps.children,c),b.child;case 12:return b.flags|=4,d=b.stateNode,d.effectDuration=0,d.passiveEffectDuration=0,bi(a,b,b.pendingProps.children,c),b.child;case 10:a:{d=b.type._context;e=b.pendingProps;f=b.memoizedProps;g=e.value;Ki(b,d,g);if(null!==f)if(sd(f.value,g)){if(f.children===e.children&&!id.current){b=ei(a,b,c);break a}}else Ri(b,
 d,c);bi(a,b,e.children,c);b=b.child}return b;case 9:return e=b.type,d=b.pendingProps.children,di(b,c),e=rg(e),mb(b),d=d(e),nb(),b.flags|=1,bi(a,b,d,c),b.child;case 14:return d=b.type,e=Dh(d,b.pendingProps),e=Dh(d.type,e),fi(a,b,d,e,c);case 15:return hi(a,b,b.type,b.pendingProps,c);case 17:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Dh(d,e),ri(a,b),b.tag=1,ld(d)?(a=!0,pd(b)):a=!1,di(b,c),Hh(b,d,e),Jh(b,d,e,c),si(null,b,d,!0,a,c);case 19:return Ii(a,b,c);case 22:return ji(a,b,c);case 24:return di(b,
-c),d=rg(oi),null===a?(e=ni(),null===e&&(e=P,f=oh(),e.pooledCache=f,f.refCount++,null!==f&&(e.pooledCacheLanes|=c),e=f),b.memoizedState={parent:d,cache:e},le(b),Ki(b,oi,e)):(0!==(a.lanes&c)&&(me(a,b),re(b,null,null,c)),e=a.memoizedState,f=b.memoizedState,e.parent!==d?(e={parent:d,cache:d},b.memoizedState=e,0===b.lanes&&(b.memoizedState=b.updateQueue.baseState=e),Ki(b,oi,d)):(d=f.cache,Ki(b,oi,d),d!==e.cache&&Ri(b,oi,c))),bi(a,b,b.pendingProps.children,c),b.child}throw Error(t(156,b.tag));};
+c),d=rg(oi),null===a?(e=ni(),null===e&&(e=P,f=oh(),e.pooledCache=f,f.refCount++,null!==f&&(e.pooledCacheLanes|=c),e=f),b.memoizedState={parent:d,cache:e},le(b),Ki(b,oi,e)):(0!==(a.lanes&c)&&(me(a,b),re(b,null,null,c)),e=a.memoizedState,f=b.memoizedState,e.parent!==d?(e={parent:d,cache:d},b.memoizedState=e,0===b.lanes&&(b.memoizedState=b.updateQueue.baseState=e),Ki(b,oi,d)):(d=f.cache,Ki(b,oi,d),d!==e.cache&&Ri(b,oi,c))),bi(a,b,b.pendingProps.children,c),b.child}throw Error(u(156,b.tag));};
 function Vh(a,b){gb&&a.memoizedUpdaters.forEach(function(c){Kb(a,c,b)})}function Jl(a,b){return Ua(a,b)}
 function Rl(a,b,c,d){this.tag=a;this.key=c;this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null;this.index=0;this.refCleanup=this.ref=null;this.pendingProps=b;this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null;this.mode=d;this.subtreeFlags=this.flags=0;this.deletions=null;this.childLanes=this.lanes=0;this.alternate=null;this.actualDuration=0;this.actualStartTime=-1;this.treeBaseDuration=this.selfBaseDuration=0}
 function Jd(a,b,c,d){return new Rl(a,b,c,d)}function gi(a){a=a.prototype;return!(!a||!a.isReactComponent)}function Pl(a){if("function"===typeof a)return gi(a)?1:0;if(void 0!==a&&null!==a){a=a.$$typeof;if(a===va)return 11;if(a===ya)return 14}return 2}
@@ -321,30 +310,30 @@ function Le(a,b){var c=a.alternate;null===c?(c=Jd(a.tag,b,a.key,a.mode),c.elemen
 function mj(a,b){a.flags&=31457282;var c=a.alternate;null===c?(a.childLanes=0,a.lanes=b,a.child=null,a.subtreeFlags=0,a.memoizedProps=null,a.memoizedState=null,a.updateQueue=null,a.dependencies=null,a.stateNode=null,a.selfBaseDuration=0,a.treeBaseDuration=0):(a.childLanes=c.childLanes,a.lanes=c.lanes,a.child=c.child,a.subtreeFlags=0,a.deletions=null,a.memoizedProps=c.memoizedProps,a.memoizedState=c.memoizedState,a.updateQueue=c.updateQueue,a.type=c.type,b=c.dependencies,a.dependencies=null===b?null:
 {lanes:b.lanes,firstContext:b.firstContext},a.selfBaseDuration=c.selfBaseDuration,a.treeBaseDuration=c.treeBaseDuration);return a}
 function Ne(a,b,c,d,e,f,g){e=2;d=a;if("function"===typeof a)gi(a)&&(e=1);else if("string"===typeof a)e=Sl(a,c,Ja.current)?26:"html"===a||"head"===a||"body"===a?27:5;else a:switch(a){case pa:return Pe(c.children,f,g,b);case qa:e=8;f|=8;0!==(f&1)&&(f|=16);break;case ra:return a=Jd(12,c,b,f|2),a.elementType=ra,a.lanes=g,a.stateNode={effectDuration:0,passiveEffectDuration:0},a;case wa:return a=Jd(13,c,b,f),a.elementType=wa,a.lanes=g,a;case xa:return a=Jd(19,c,b,f),a.elementType=xa,a.lanes=g,a;case Ba:return Ci(c,
-f,g,b);case Ca:case Aa:case Da:return a=Jd(24,c,b,f),a.elementType=Da,a.lanes=g,a;default:if("object"===typeof a&&null!==a)switch(a.$$typeof){case sa:e=10;break a;case ta:e=9;break a;case va:e=11;break a;case ya:e=14;break a;case za:e=16;d=null;break a}throw Error(t(130,null==a?a:typeof a,""));}b=Jd(e,c,b,f);b.elementType=a;b.type=d;b.lanes=g;return b}function Pe(a,b,c,d){a=Jd(7,a,d,b);a.lanes=c;return a}
-function Ci(a,b,c,d){a=Jd(22,a,d,b);a.elementType=Ba;a.lanes=c;var e={_visibility:1,_pendingVisibility:1,_pendingMarkers:null,_retryCache:null,_transitions:null,_current:null,detach:function(){var f=e._current;if(null===f)throw Error(t(456));if(0===(e._pendingVisibility&2)){var g=he(f,2);null!==g&&(e._pendingVisibility|=2,Gg(g,f,2))}},attach:function(){var f=e._current;if(null===f)throw Error(t(456));if(0!==(e._pendingVisibility&2)){var g=he(f,2);null!==g&&(e._pendingVisibility&=-3,Gg(g,f,2))}}};
+f,g,b);case Ca:case Aa:case Da:return a=Jd(24,c,b,f),a.elementType=Da,a.lanes=g,a;default:if("object"===typeof a&&null!==a)switch(a.$$typeof){case sa:e=10;break a;case ta:e=9;break a;case va:e=11;break a;case ya:e=14;break a;case za:e=16;d=null;break a}throw Error(u(130,null==a?a:typeof a,""));}b=Jd(e,c,b,f);b.elementType=a;b.type=d;b.lanes=g;return b}function Pe(a,b,c,d){a=Jd(7,a,d,b);a.lanes=c;return a}
+function Ci(a,b,c,d){a=Jd(22,a,d,b);a.elementType=Ba;a.lanes=c;var e={_visibility:1,_pendingVisibility:1,_pendingMarkers:null,_retryCache:null,_transitions:null,_current:null,detach:function(){var f=e._current;if(null===f)throw Error(u(456));if(0===(e._pendingVisibility&2)){var g=he(f,2);null!==g&&(e._pendingVisibility|=2,Gg(g,f,2))}},attach:function(){var f=e._current;if(null===f)throw Error(u(456));if(0!==(e._pendingVisibility&2)){var g=he(f,2);null!==g&&(e._pendingVisibility&=-3,Gg(g,f,2))}}};
 a.stateNode=e;return a}function Me(a,b,c){a=Jd(6,a,null,b);a.lanes=c;return a}function Oe(a,b,c){b=Jd(4,null!==a.children?a.children:[],a.key,b);b.lanes=c;b.stateNode={containerInfo:a.containerInfo,pendingChildren:null,implementation:a.implementation};return b}
 function Tl(a,b,c,d,e,f){this.tag=b;this.containerInfo=a;this.finishedWork=this.pingCache=this.current=this.pendingChildren=null;this.timeoutHandle=-1;this.callbackNode=this.next=this.pendingContext=this.context=this.cancelPendingCommit=null;this.callbackPriority=0;this.expirationTimes=Eb(-1);this.entangledLanes=this.shellSuspendCounter=this.errorRecoveryDisabledLanes=this.finishedLanes=this.expiredLanes=this.pingedLanes=this.suspendedLanes=this.pendingLanes=0;this.entanglements=Eb(0);this.hiddenUpdates=
 Eb(null);this.identifierPrefix=d;this.onRecoverableError=e;this.pooledCache=null;this.pooledCacheLanes=0;this.formState=f;this.incompleteTransitions=new Map;this.passiveEffectDuration=this.effectDuration=0;this.memoizedUpdaters=new Set;a=this.pendingUpdatersLaneMap=[];for(b=0;31>b;b++)a.push(new Set)}
-function Ul(a,b,c,d,e,f,g,h,l,p,q){a=new Tl(a,b,c,h,l,q);1===b?(b=1,!0===f&&(b|=24)):b=0;gb&&(b|=2);f=Jd(3,null,null,b);a.current=f;f.stateNode=a;b=oh();b.refCount++;a.pooledCache=b;b.refCount++;f.memoizedState={element:d,isDehydrated:c,cache:b};le(f);return a}function Vl(a,b,c){var d=3<arguments.length&&void 0!==arguments[3]?arguments[3]:null;return{$$typeof:oa,key:null==d?null:""+d,children:a,containerInfo:b,implementation:c}}
-function Wl(a){if(!a)return gd;a=a._reactInternals;a:{if(ad(a)!==a||1!==a.tag)throw Error(t(170));var b=a;do{switch(b.tag){case 3:b=b.stateNode.context;break a;case 1:if(ld(b.type)){b=b.stateNode.__reactInternalMemoizedMergedChildContext;break a}}b=b.return}while(null!==b);throw Error(t(171));}if(1===a.tag){var c=a.type;if(ld(c))return od(a,c,b)}return b}
-function Xl(a,b,c,d,e,f,g,h,l,p,q){a=Ul(c,d,!0,a,e,f,g,h,l,p,q);a.context=Wl(null);c=a.current;d=nh(c);e=ne(d);e.callback=void 0!==b&&null!==b?b:null;oe(c,e,d);a.current.lanes=d;Fb(a,d);nf(a);return a}
+function Ul(a,b,c,d,e,f,g,h,l,n,q){a=new Tl(a,b,c,h,l,q);1===b?(b=1,!0===f&&(b|=24)):b=0;gb&&(b|=2);f=Jd(3,null,null,b);a.current=f;f.stateNode=a;b=oh();b.refCount++;a.pooledCache=b;b.refCount++;f.memoizedState={element:d,isDehydrated:c,cache:b};le(f);return a}function Vl(a,b,c){var d=3<arguments.length&&void 0!==arguments[3]?arguments[3]:null;return{$$typeof:oa,key:null==d?null:""+d,children:a,containerInfo:b,implementation:c}}
+function Wl(a){if(!a)return gd;a=a._reactInternals;a:{if(ad(a)!==a||1!==a.tag)throw Error(u(170));var b=a;do{switch(b.tag){case 3:b=b.stateNode.context;break a;case 1:if(ld(b.type)){b=b.stateNode.__reactInternalMemoizedMergedChildContext;break a}}b=b.return}while(null!==b);throw Error(u(171));}if(1===a.tag){var c=a.type;if(ld(c))return od(a,c,b)}return b}
+function Xl(a,b,c,d,e,f,g,h,l,n,q){a=Ul(c,d,!0,a,e,f,g,h,l,n,q);a.context=Wl(null);c=a.current;d=nh(c);e=ne(d);e.callback=void 0!==b&&null!==b?b:null;oe(c,e,d);a.current.lanes=d;Fb(a,d);nf(a);return a}
 function Yl(a,b,c,d){var e=b.current,f=nh(e);null!==F&&"function"===typeof F.markRenderScheduled&&F.markRenderScheduled(f);c=Wl(c);null===b.context?b.context=c:b.pendingContext=c;b=ne(f);b.payload={element:a};d=void 0===d?null:d;null!==d&&(b.callback=d);a=oe(e,b,f);null!==a&&(Gg(a,e,f),pe(a,e,f));return f}function Zl(a){a=a.current;if(!a.child)return null;switch(a.child.tag){case 27:case 5:return a.child.stateNode;default:return a.child.stateNode}}
 function $l(a){switch(a.tag){case 3:var b=a.stateNode;if(b.current.memoizedState.isDehydrated){var c=zb(b.pendingLanes);0!==c&&(Jb(b,c),nf(b),0===(N&6)&&(nj=Ya()+500,qf(!1)))}break;case 13:vl(function(){var d=he(a,2);null!==d&&Gg(d,a,2)}),am(a,2)}}function bm(a,b){a=a.memoizedState;if(null!==a&&null!==a.dehydrated){var c=a.retryLane;a.retryLane=0!==c&&c<b?c:b}}function am(a,b){bm(a,b);(a=a.alternate)&&bm(a,b)}
 function cm(a){if(13===a.tag){var b=he(a,67108864);null!==b&&Gg(b,a,67108864);am(a,67108864)}}function dm(){return null}var em=!1;function fm(a,b,c){if(em)return a(b,c);em=!0;try{return ul(a,b,c)}finally{if(em=!1,null!==Wc||null!==Xc)vl(),$c()}}
 function gm(a,b){var c=a.stateNode;if(null===c)return null;var d=dc(c);if(null===d)return null;c=d[b];a:switch(b){case "onClick":case "onClickCapture":case "onDoubleClick":case "onDoubleClickCapture":case "onMouseDown":case "onMouseDownCapture":case "onMouseMove":case "onMouseMoveCapture":case "onMouseUp":case "onMouseUpCapture":case "onMouseEnter":(d=!d.disabled)||(a=a.type,d=!("button"===a||"input"===a||"select"===a||"textarea"===a));a=!d;break a;default:a=!1}if(a)return null;if(c&&"function"!==
-typeof c)throw Error(t(231,b,typeof c));return c}var hm=!1;if(kc)try{var im={};Object.defineProperty(im,"passive",{get:function(){hm=!0}});window.addEventListener("test",im,im);window.removeEventListener("test",im,im)}catch(a){hm=!1}function jm(a){var b=a.keyCode;"charCode"in a?(a=a.charCode,0===a&&13===b&&(a=13)):a=b;10===a&&(a=13);return 32<=a||13===a?a:0}function km(){return!0}function lm(){return!1}
-function mm(a){function b(c,d,e,f,g){this._reactName=c;this._targetInst=e;this.type=d;this.nativeEvent=f;this.target=g;this.currentTarget=null;for(var h in a)a.hasOwnProperty(h)&&(c=a[h],this[h]=c?c(f):f[h]);this.isDefaultPrevented=(null!=f.defaultPrevented?f.defaultPrevented:!1===f.returnValue)?km:lm;this.isPropagationStopped=lm;return this}w(b.prototype,{preventDefault:function(){this.defaultPrevented=!0;var c=this.nativeEvent;c&&(c.preventDefault?c.preventDefault():"unknown"!==typeof c.returnValue&&
+typeof c)throw Error(u(231,b,typeof c));return c}var hm=!1;if(kc)try{var im={};Object.defineProperty(im,"passive",{get:function(){hm=!0}});window.addEventListener("test",im,im);window.removeEventListener("test",im,im)}catch(a){hm=!1}function jm(a){var b=a.keyCode;"charCode"in a?(a=a.charCode,0===a&&13===b&&(a=13)):a=b;10===a&&(a=13);return 32<=a||13===a?a:0}function km(){return!0}function lm(){return!1}
+function mm(a){function b(c,d,e,f,g){this._reactName=c;this._targetInst=e;this.type=d;this.nativeEvent=f;this.target=g;this.currentTarget=null;for(var h in a)a.hasOwnProperty(h)&&(c=a[h],this[h]=c?c(f):f[h]);this.isDefaultPrevented=(null!=f.defaultPrevented?f.defaultPrevented:!1===f.returnValue)?km:lm;this.isPropagationStopped=lm;return this}x(b.prototype,{preventDefault:function(){this.defaultPrevented=!0;var c=this.nativeEvent;c&&(c.preventDefault?c.preventDefault():"unknown"!==typeof c.returnValue&&
 (c.returnValue=!1),this.isDefaultPrevented=km)},stopPropagation:function(){var c=this.nativeEvent;c&&(c.stopPropagation?c.stopPropagation():"unknown"!==typeof c.cancelBubble&&(c.cancelBubble=!0),this.isPropagationStopped=km)},persist:function(){},isPersistent:km});return b}
-var nm={eventPhase:0,bubbles:0,cancelable:0,timeStamp:function(a){return a.timeStamp||Date.now()},defaultPrevented:0,isTrusted:0},om=mm(nm),pm=w({},nm,{view:0,detail:0}),qm=mm(pm),rm,sm,tm,vm=w({},pm,{screenX:0,screenY:0,clientX:0,clientY:0,pageX:0,pageY:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,getModifierState:um,button:0,buttons:0,relatedTarget:function(a){return void 0===a.relatedTarget?a.fromElement===a.srcElement?a.toElement:a.fromElement:a.relatedTarget},movementX:function(a){if("movementX"in
-a)return a.movementX;a!==tm&&(tm&&"mousemove"===a.type?(rm=a.screenX-tm.screenX,sm=a.screenY-tm.screenY):sm=rm=0,tm=a);return rm},movementY:function(a){return"movementY"in a?a.movementY:sm}}),wm=mm(vm),xm=w({},vm,{dataTransfer:0}),ym=mm(xm),zm=w({},pm,{relatedTarget:0}),Am=mm(zm),Bm=w({},nm,{animationName:0,elapsedTime:0,pseudoElement:0}),Cm=mm(Bm),Dm=w({},nm,{clipboardData:function(a){return"clipboardData"in a?a.clipboardData:window.clipboardData}}),Em=mm(Dm),Fm=w({},nm,{data:0}),Gm=mm(Fm),Hm={Esc:"Escape",
+var nm={eventPhase:0,bubbles:0,cancelable:0,timeStamp:function(a){return a.timeStamp||Date.now()},defaultPrevented:0,isTrusted:0},om=mm(nm),pm=x({},nm,{view:0,detail:0}),qm=mm(pm),rm,sm,tm,vm=x({},pm,{screenX:0,screenY:0,clientX:0,clientY:0,pageX:0,pageY:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,getModifierState:um,button:0,buttons:0,relatedTarget:function(a){return void 0===a.relatedTarget?a.fromElement===a.srcElement?a.toElement:a.fromElement:a.relatedTarget},movementX:function(a){if("movementX"in
+a)return a.movementX;a!==tm&&(tm&&"mousemove"===a.type?(rm=a.screenX-tm.screenX,sm=a.screenY-tm.screenY):sm=rm=0,tm=a);return rm},movementY:function(a){return"movementY"in a?a.movementY:sm}}),wm=mm(vm),xm=x({},vm,{dataTransfer:0}),ym=mm(xm),zm=x({},pm,{relatedTarget:0}),Am=mm(zm),Bm=x({},nm,{animationName:0,elapsedTime:0,pseudoElement:0}),Cm=mm(Bm),Dm=x({},nm,{clipboardData:function(a){return"clipboardData"in a?a.clipboardData:window.clipboardData}}),Em=mm(Dm),Fm=x({},nm,{data:0}),Gm=mm(Fm),Hm={Esc:"Escape",
 Spacebar:" ",Left:"ArrowLeft",Up:"ArrowUp",Right:"ArrowRight",Down:"ArrowDown",Del:"Delete",Win:"OS",Menu:"ContextMenu",Apps:"ContextMenu",Scroll:"ScrollLock",MozPrintableKey:"Unidentified"},Im={8:"Backspace",9:"Tab",12:"Clear",13:"Enter",16:"Shift",17:"Control",18:"Alt",19:"Pause",20:"CapsLock",27:"Escape",32:" ",33:"PageUp",34:"PageDown",35:"End",36:"Home",37:"ArrowLeft",38:"ArrowUp",39:"ArrowRight",40:"ArrowDown",45:"Insert",46:"Delete",112:"F1",113:"F2",114:"F3",115:"F4",116:"F5",117:"F6",118:"F7",
 119:"F8",120:"F9",121:"F10",122:"F11",123:"F12",144:"NumLock",145:"ScrollLock",224:"Meta"},Jm={Alt:"altKey",Control:"ctrlKey",Meta:"metaKey",Shift:"shiftKey"};function Km(a){var b=this.nativeEvent;return b.getModifierState?b.getModifierState(a):(a=Jm[a])?!!b[a]:!1}function um(){return Km}
-var Lm=w({},pm,{key:function(a){if(a.key){var b=Hm[a.key]||a.key;if("Unidentified"!==b)return b}return"keypress"===a.type?(a=jm(a),13===a?"Enter":String.fromCharCode(a)):"keydown"===a.type||"keyup"===a.type?Im[a.keyCode]||"Unidentified":""},code:0,location:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,repeat:0,locale:0,getModifierState:um,charCode:function(a){return"keypress"===a.type?jm(a):0},keyCode:function(a){return"keydown"===a.type||"keyup"===a.type?a.keyCode:0},which:function(a){return"keypress"===
-a.type?jm(a):"keydown"===a.type||"keyup"===a.type?a.keyCode:0}}),Mm=mm(Lm),Nm=w({},vm,{pointerId:0,width:0,height:0,pressure:0,tangentialPressure:0,tiltX:0,tiltY:0,twist:0,pointerType:0,isPrimary:0}),Om=mm(Nm),Pm=w({},pm,{touches:0,targetTouches:0,changedTouches:0,altKey:0,metaKey:0,ctrlKey:0,shiftKey:0,getModifierState:um}),Qm=mm(Pm),Rm=w({},nm,{propertyName:0,elapsedTime:0,pseudoElement:0}),Sm=mm(Rm),Tm=w({},vm,{deltaX:function(a){return"deltaX"in a?a.deltaX:"wheelDeltaX"in a?-a.wheelDeltaX:0},
+var Lm=x({},pm,{key:function(a){if(a.key){var b=Hm[a.key]||a.key;if("Unidentified"!==b)return b}return"keypress"===a.type?(a=jm(a),13===a?"Enter":String.fromCharCode(a)):"keydown"===a.type||"keyup"===a.type?Im[a.keyCode]||"Unidentified":""},code:0,location:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,repeat:0,locale:0,getModifierState:um,charCode:function(a){return"keypress"===a.type?jm(a):0},keyCode:function(a){return"keydown"===a.type||"keyup"===a.type?a.keyCode:0},which:function(a){return"keypress"===
+a.type?jm(a):"keydown"===a.type||"keyup"===a.type?a.keyCode:0}}),Mm=mm(Lm),Nm=x({},vm,{pointerId:0,width:0,height:0,pressure:0,tangentialPressure:0,tiltX:0,tiltY:0,twist:0,pointerType:0,isPrimary:0}),Om=mm(Nm),Pm=x({},pm,{touches:0,targetTouches:0,changedTouches:0,altKey:0,metaKey:0,ctrlKey:0,shiftKey:0,getModifierState:um}),Qm=mm(Pm),Rm=x({},nm,{propertyName:0,elapsedTime:0,pseudoElement:0}),Sm=mm(Rm),Tm=x({},vm,{deltaX:function(a){return"deltaX"in a?a.deltaX:"wheelDeltaX"in a?-a.wheelDeltaX:0},
 deltaY:function(a){return"deltaY"in a?a.deltaY:"wheelDeltaY"in a?-a.wheelDeltaY:"wheelDelta"in a?-a.wheelDelta:0},deltaZ:0,deltaMode:0}),Um=mm(Tm);
-function Vm(a,b,c,d,e){if("submit"===b&&c&&c.stateNode===e){var f=dc(e).action,g=d.submitter;g&&(b=(b=dc(g))?b.formAction:g.getAttribute("formAction"),null!=b&&(f=b,g=null));if("function"===typeof f){var h=new om("action","action",null,d,e);a.push({event:h,listeners:[{instance:null,listener:function(){if(!d.defaultPrevented){h.preventDefault();if(g){var l=g.ownerDocument.createElement("input");l.name=g.name;l.value=g.value;g.parentNode.insertBefore(l,g);var p=new FormData(e);l.parentNode.removeChild(l)}else p=
-new FormData(e);ih(c,{pending:!0,data:p,method:e.method,action:f},f,p)}},currentTarget:e}]})}}}var Wm=!1,Xm=null,Ym=null,Zm=null,$m=new Map,an=new Map,bn=[],cn="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".split(" ");
+function Vm(a,b,c,d,e){if("submit"===b&&c&&c.stateNode===e){var f=dc(e).action,g=d.submitter;g&&(b=(b=dc(g))?b.formAction:g.getAttribute("formAction"),null!=b&&(f=b,g=null));if("function"===typeof f){var h=new om("action","action",null,d,e);a.push({event:h,listeners:[{instance:null,listener:function(){if(!d.defaultPrevented){h.preventDefault();if(g){var l=g.ownerDocument.createElement("input");l.name=g.name;l.value=g.value;g.parentNode.insertBefore(l,g);var n=new FormData(e);l.parentNode.removeChild(l)}else n=
+new FormData(e);ih(c,{pending:!0,data:n,method:e.method,action:f},f,n)}},currentTarget:e}]})}}}var Wm=!1,Xm=null,Ym=null,Zm=null,$m=new Map,an=new Map,bn=[],cn="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".split(" ");
 function dn(a,b){switch(a){case "focusin":case "focusout":Xm=null;break;case "dragenter":case "dragleave":Ym=null;break;case "mouseover":case "mouseout":Zm=null;break;case "pointerover":case "pointerout":$m.delete(b.pointerId);break;case "gotpointercapture":case "lostpointercapture":an.delete(b.pointerId)}}
 function en(a,b,c,d,e,f){if(null===a||a.nativeEvent!==f)return a={blockedOn:b,domEventName:c,eventSystemFlags:d,nativeEvent:f,targetContainers:[e]},null!==b&&(b=bc(b),null!==b&&cm(b)),a;a.eventSystemFlags|=d;b=a.targetContainers;null!==e&&-1===b.indexOf(e)&&b.push(e);return a}
 function fn(a,b,c,d,e){switch(b){case "focusin":return Xm=en(Xm,a,b,c,d,e),!0;case "dragenter":return Ym=en(Ym,a,b,c,d,e),!0;case "mouseover":return Zm=en(Zm,a,b,c,d,e),!0;case "pointerover":var f=e.pointerId;$m.set(f,en($m.get(f)||null,a,b,c,d,e));return!0;case "gotpointercapture":return f=e.pointerId,an.set(f,en(an.get(f)||null,a,b,c,d,e)),!0}return!1}
@@ -375,41 +364,41 @@ function Bo(a,b){zo.set(a,b);ic(b,[a])}for(var Co=0;Co<Ao.length;Co++){var Do=Ao
 jc("onPointerLeave",["pointerout","pointerover"]);ic("onChange","change click focusin focusout input keydown keyup selectionchange".split(" "));ic("onSelect","focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(" "));ic("onBeforeInput",["compositionend","keypress","textInput","paste"]);ic("onCompositionEnd","compositionend focusout keydown keypress keyup mousedown".split(" "));ic("onCompositionStart","compositionstart focusout keydown keypress keyup mousedown".split(" "));
 ic("onCompositionUpdate","compositionupdate focusout keydown keypress keyup mousedown".split(" "));var Go="abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(" "),Ho=new Set("cancel close invalid load scroll scrollend toggle".split(" ").concat(Go));
 function Io(a,b,c){var d=a.type||"unknown-event";a.currentTarget=c;xj(d,b,void 0,a);a.currentTarget=null}
-function Un(a,b){b=0!==(b&4);for(var c=0;c<a.length;c++){var d=a[c],e=d.event;d=d.listeners;a:{var f=void 0;if(b)for(var g=d.length-1;0<=g;g--){var h=d[g],l=h.instance,p=h.currentTarget;h=h.listener;if(l!==f&&e.isPropagationStopped())break a;Io(e,h,p);f=l}else for(g=0;g<d.length;g++){h=d[g];l=h.instance;p=h.currentTarget;h=h.listener;if(l!==f&&e.isPropagationStopped())break a;Io(e,h,p);f=l}}}if(tj)throw a=uj,tj=!1,uj=null,a;}
+function Un(a,b){b=0!==(b&4);for(var c=0;c<a.length;c++){var d=a[c],e=d.event;d=d.listeners;a:{var f=void 0;if(b)for(var g=d.length-1;0<=g;g--){var h=d[g],l=h.instance,n=h.currentTarget;h=h.listener;if(l!==f&&e.isPropagationStopped())break a;Io(e,h,n);f=l}else for(g=0;g<d.length;g++){h=d[g];l=h.instance;n=h.currentTarget;h=h.listener;if(l!==f&&e.isPropagationStopped())break a;Io(e,h,n);f=l}}}if(tj)throw a=uj,tj=!1,uj=null,a;}
 function Y(a,b){var c=b[Ub];void 0===c&&(c=b[Ub]=new Set);var d=a+"__bubble";c.has(d)||(Jo(b,a,2,!1),c.add(d))}function Ko(a,b,c){var d=0;b&&(d|=4);Jo(c,a,d,b)}var Lo="_reactListening"+Math.random().toString(36).slice(2);function lj(a){if(!a[Lo]){a[Lo]=!0;gc.forEach(function(c){"selectionchange"!==c&&(Ho.has(c)||Ko(c,!1,a),Ko(c,!0,a))});var b=9===a.nodeType?a:a.ownerDocument;null===b||b[Lo]||(b[Lo]=!0,Ko("selectionchange",!1,b))}}
 function Jo(a,b,c,d){switch(ml(b)){case 2:var e=rn;break;case 8:e=tn;break;default:e=sn}c=e.bind(null,b,c,a);e=void 0;!hm||"touchstart"!==b&&"touchmove"!==b&&"wheel"!==b||(e=!0);d?void 0!==e?a.addEventListener(b,c,{capture:!0,passive:e}):a.addEventListener(b,c,!0):void 0!==e?a.addEventListener(b,c,{passive:e}):a.addEventListener(b,c,!1)}
-function un(a,b,c,d,e){var f=d;if(0===(b&1)&&0===(b&2)&&null!==d)a:for(;;){if(null===d)return;var g=d.tag;if(3===g||4===g){var h=d.stateNode.containerInfo;if(h===e||8===h.nodeType&&h.parentNode===e)break;if(4===g)for(g=d.return;null!==g;){var l=g.tag;if(3===l||4===l)if(l=g.stateNode.containerInfo,l===e||8===l.nodeType&&l.parentNode===e)return;g=g.return}for(;null!==h;){g=$b(h);if(null===g)return;l=g.tag;if(5===l||6===l||26===l||27===l){d=f=g;continue a}h=h.parentNode}}d=d.return}fm(function(){var p=
-f,q=Vc(c),x=[];a:{var r=zo.get(a);if(void 0!==r){var u=om,A=a;switch(a){case "keypress":if(0===jm(c))break a;case "keydown":case "keyup":u=Mm;break;case "focusin":A="focus";u=Am;break;case "focusout":A="blur";u=Am;break;case "beforeblur":case "afterblur":u=Am;break;case "click":if(2===c.button)break a;case "auxclick":case "dblclick":case "mousedown":case "mousemove":case "mouseup":case "mouseout":case "mouseover":case "contextmenu":u=wm;break;case "drag":case "dragend":case "dragenter":case "dragexit":case "dragleave":case "dragover":case "dragstart":case "drop":u=
-ym;break;case "touchcancel":case "touchend":case "touchmove":case "touchstart":u=Qm;break;case vo:case wo:case xo:u=Cm;break;case yo:u=Sm;break;case "scroll":case "scrollend":u=qm;break;case "wheel":u=Um;break;case "copy":case "cut":case "paste":u=Em;break;case "gotpointercapture":case "lostpointercapture":case "pointercancel":case "pointerdown":case "pointermove":case "pointerout":case "pointerover":case "pointerup":u=Om}var C=0!==(b&4),J=!C&&("scroll"===a||"scrollend"===a),Q=C?null!==r?r+"Capture":
-null:r;C=[];for(var m=p,k;null!==m;){var n=m;k=n.stateNode;n=n.tag;5!==n&&26!==n&&27!==n||null===k||null===Q||(n=gm(m,Q),null!=n&&C.push(Mo(m,n,k)));if(J)break;m=m.return}0<C.length&&(r=new u(r,A,null,c,q),x.push({event:r,listeners:C}))}}if(0===(b&7)){a:{r="mouseover"===a||"pointerover"===a;u="mouseout"===a||"pointerout"===a;if(r&&c!==Uc&&(A=c.relatedTarget||c.fromElement)&&($b(A)||A[Tb]))break a;if(u||r){r=q.window===q?q:(r=q.ownerDocument)?r.defaultView||r.parentWindow:window;if(u){if(A=c.relatedTarget||
-c.toElement,u=p,A=A?$b(A):null,null!==A&&(J=ad(A),C=A.tag,A!==J||5!==C&&27!==C&&6!==C))A=null}else u=null,A=p;if(u!==A){C=wm;n="onMouseLeave";Q="onMouseEnter";m="mouse";if("pointerout"===a||"pointerover"===a)C=Om,n="onPointerLeave",Q="onPointerEnter",m="pointer";J=null==u?r:cc(u);k=null==A?r:cc(A);r=new C(n,m+"leave",u,c,q);r.target=J;r.relatedTarget=k;n=null;$b(q)===p&&(C=new C(Q,m+"enter",A,c,q),C.target=k,C.relatedTarget=J,n=C);J=n;if(u&&A)b:{C=u;Q=A;m=0;for(k=C;k;k=No(k))m++;k=0;for(n=Q;n;n=No(n))k++;
-for(;0<m-k;)C=No(C),m--;for(;0<k-m;)Q=No(Q),k--;for(;m--;){if(C===Q||null!==Q&&C===Q.alternate)break b;C=No(C);Q=No(Q)}C=null}else C=null;null!==u&&Oo(x,r,u,C,!1);null!==A&&null!==J&&Oo(x,J,A,C,!0)}}}a:{r=p?cc(p):window;u=r.nodeName&&r.nodeName.toLowerCase();if("select"===u||"input"===u&&"file"===r.type)var v=Wn;else if(On(r))if(Xn)v=go;else{v=eo;var y=co}else u=r.nodeName,!u||"input"!==u.toLowerCase()||"checkbox"!==r.type&&"radio"!==r.type?p&&Sc(p.elementType)&&(v=Wn):v=fo;if(v&&(v=v(a,p))){Pn(x,
-v,c,q);break a}y&&y(a,r,p);"focusout"===a&&p&&"number"===r.type&&null!=p.memoizedProps.value&&Ic(r,"number",r.value)}y=p?cc(p):window;switch(a){case "focusin":if(On(y)||"true"===y.contentEditable)lo=y,mo=p,no=null;break;case "focusout":no=mo=lo=null;break;case "mousedown":oo=!0;break;case "contextmenu":case "mouseup":case "dragend":oo=!1;po(x,c,q);break;case "selectionchange":if(ko)break;case "keydown":case "keyup":po(x,c,q)}var B;if(Cn)b:{switch(a){case "compositionstart":var z="onCompositionStart";
-break b;case "compositionend":z="onCompositionEnd";break b;case "compositionupdate":z="onCompositionUpdate";break b}z=void 0}else Kn?In(a,c)&&(z="onCompositionEnd"):"keydown"===a&&229===c.keyCode&&(z="onCompositionStart");z&&(Fn&&"ko"!==c.locale&&(Kn||"onCompositionStart"!==z?"onCompositionEnd"===z&&Kn&&(B=zn()):(wn=q,xn="value"in wn?wn.value:wn.textContent,Kn=!0)),y=Qn(p,z),0<y.length&&(z=new Gm(z,a,null,c,q),x.push({event:z,listeners:y}),B?z.data=B:(B=Jn(c),null!==B&&(z.data=B))));if(B=En?Ln(a,
-c):Mn(a,c))z=Qn(p,"onBeforeInput"),0<z.length&&(y=new Gm("onBeforeInput","beforeinput",null,c,q),x.push({event:y,listeners:z}),y.data=B);Vm(x,a,p,c,q)}Un(x,b)})}function Mo(a,b,c){return{instance:a,listener:b,currentTarget:c}}function Qn(a,b){for(var c=b+"Capture",d=[];null!==a;){var e=a,f=e.stateNode;e=e.tag;5!==e&&26!==e&&27!==e||null===f||(e=gm(a,c),null!=e&&d.unshift(Mo(a,e,f)),e=gm(a,b),null!=e&&d.push(Mo(a,e,f)));a=a.return}return d}
-function No(a){if(null===a)return null;do a=a.return;while(a&&5!==a.tag&&27!==a.tag);return a?a:null}function Oo(a,b,c,d,e){for(var f=b._reactName,g=[];null!==c&&c!==d;){var h=c,l=h.alternate,p=h.stateNode;h=h.tag;if(null!==l&&l===d)break;5!==h&&26!==h&&27!==h||null===p||(l=p,e?(p=gm(c,f),null!=p&&g.unshift(Mo(c,p,l))):e||(p=gm(c,f),null!=p&&g.push(Mo(c,p,l))));c=c.return}0!==g.length&&a.push({event:b,listeners:g})}var Po=/\r\n?/g,Qo=/\u0000|\uFFFD/g;
-function Ro(a){return("string"===typeof a?a:""+a).replace(Po,"\n").replace(Qo,"")}function kj(a,b,c){b=Ro(b);if(Ro(a)!==b&&c)throw Error(t(425));}function gk(){}
+function un(a,b,c,d,e){var f=d;if(0===(b&1)&&0===(b&2)&&null!==d)a:for(;;){if(null===d)return;var g=d.tag;if(3===g||4===g){var h=d.stateNode.containerInfo;if(h===e||8===h.nodeType&&h.parentNode===e)break;if(4===g)for(g=d.return;null!==g;){var l=g.tag;if(3===l||4===l)if(l=g.stateNode.containerInfo,l===e||8===l.nodeType&&l.parentNode===e)return;g=g.return}for(;null!==h;){g=$b(h);if(null===g)return;l=g.tag;if(5===l||6===l||26===l||27===l){d=f=g;continue a}h=h.parentNode}}d=d.return}fm(function(){var n=
+f,q=Vc(c),w=[];a:{var t=zo.get(a);if(void 0!==t){var r=om,A=a;switch(a){case "keypress":if(0===jm(c))break a;case "keydown":case "keyup":r=Mm;break;case "focusin":A="focus";r=Am;break;case "focusout":A="blur";r=Am;break;case "beforeblur":case "afterblur":r=Am;break;case "click":if(2===c.button)break a;case "auxclick":case "dblclick":case "mousedown":case "mousemove":case "mouseup":case "mouseout":case "mouseover":case "contextmenu":r=wm;break;case "drag":case "dragend":case "dragenter":case "dragexit":case "dragleave":case "dragover":case "dragstart":case "drop":r=
+ym;break;case "touchcancel":case "touchend":case "touchmove":case "touchstart":r=Qm;break;case vo:case wo:case xo:r=Cm;break;case yo:r=Sm;break;case "scroll":case "scrollend":r=qm;break;case "wheel":r=Um;break;case "copy":case "cut":case "paste":r=Em;break;case "gotpointercapture":case "lostpointercapture":case "pointercancel":case "pointerdown":case "pointermove":case "pointerout":case "pointerover":case "pointerup":r=Om}var C=0!==(b&4),J=!C&&("scroll"===a||"scrollend"===a),Q=C?null!==t?t+"Capture":
+null:t;C=[];for(var m=n,k;null!==m;){var p=m;k=p.stateNode;p=p.tag;5!==p&&26!==p&&27!==p||null===k||null===Q||(p=gm(m,Q),null!=p&&C.push(Mo(m,p,k)));if(J)break;m=m.return}0<C.length&&(t=new r(t,A,null,c,q),w.push({event:t,listeners:C}))}}if(0===(b&7)){a:{t="mouseover"===a||"pointerover"===a;r="mouseout"===a||"pointerout"===a;if(t&&c!==Uc&&(A=c.relatedTarget||c.fromElement)&&($b(A)||A[Tb]))break a;if(r||t){t=q.window===q?q:(t=q.ownerDocument)?t.defaultView||t.parentWindow:window;if(r){if(A=c.relatedTarget||
+c.toElement,r=n,A=A?$b(A):null,null!==A&&(J=ad(A),C=A.tag,A!==J||5!==C&&27!==C&&6!==C))A=null}else r=null,A=n;if(r!==A){C=wm;p="onMouseLeave";Q="onMouseEnter";m="mouse";if("pointerout"===a||"pointerover"===a)C=Om,p="onPointerLeave",Q="onPointerEnter",m="pointer";J=null==r?t:cc(r);k=null==A?t:cc(A);t=new C(p,m+"leave",r,c,q);t.target=J;t.relatedTarget=k;p=null;$b(q)===n&&(C=new C(Q,m+"enter",A,c,q),C.target=k,C.relatedTarget=J,p=C);J=p;if(r&&A)b:{C=r;Q=A;m=0;for(k=C;k;k=No(k))m++;k=0;for(p=Q;p;p=No(p))k++;
+for(;0<m-k;)C=No(C),m--;for(;0<k-m;)Q=No(Q),k--;for(;m--;){if(C===Q||null!==Q&&C===Q.alternate)break b;C=No(C);Q=No(Q)}C=null}else C=null;null!==r&&Oo(w,t,r,C,!1);null!==A&&null!==J&&Oo(w,J,A,C,!0)}}}a:{t=n?cc(n):window;r=t.nodeName&&t.nodeName.toLowerCase();if("select"===r||"input"===r&&"file"===t.type)var v=Wn;else if(On(t))if(Xn)v=go;else{v=eo;var y=co}else r=t.nodeName,!r||"input"!==r.toLowerCase()||"checkbox"!==t.type&&"radio"!==t.type?n&&Sc(n.elementType)&&(v=Wn):v=fo;if(v&&(v=v(a,n))){Pn(w,
+v,c,q);break a}y&&y(a,t,n);"focusout"===a&&n&&"number"===t.type&&null!=n.memoizedProps.value&&Ic(t,"number",t.value)}y=n?cc(n):window;switch(a){case "focusin":if(On(y)||"true"===y.contentEditable)lo=y,mo=n,no=null;break;case "focusout":no=mo=lo=null;break;case "mousedown":oo=!0;break;case "contextmenu":case "mouseup":case "dragend":oo=!1;po(w,c,q);break;case "selectionchange":if(ko)break;case "keydown":case "keyup":po(w,c,q)}var B;if(Cn)b:{switch(a){case "compositionstart":var z="onCompositionStart";
+break b;case "compositionend":z="onCompositionEnd";break b;case "compositionupdate":z="onCompositionUpdate";break b}z=void 0}else Kn?In(a,c)&&(z="onCompositionEnd"):"keydown"===a&&229===c.keyCode&&(z="onCompositionStart");z&&(Fn&&"ko"!==c.locale&&(Kn||"onCompositionStart"!==z?"onCompositionEnd"===z&&Kn&&(B=zn()):(wn=q,xn="value"in wn?wn.value:wn.textContent,Kn=!0)),y=Qn(n,z),0<y.length&&(z=new Gm(z,a,null,c,q),w.push({event:z,listeners:y}),B?z.data=B:(B=Jn(c),null!==B&&(z.data=B))));if(B=En?Ln(a,
+c):Mn(a,c))z=Qn(n,"onBeforeInput"),0<z.length&&(y=new Gm("onBeforeInput","beforeinput",null,c,q),w.push({event:y,listeners:z}),y.data=B);Vm(w,a,n,c,q)}Un(w,b)})}function Mo(a,b,c){return{instance:a,listener:b,currentTarget:c}}function Qn(a,b){for(var c=b+"Capture",d=[];null!==a;){var e=a,f=e.stateNode;e=e.tag;5!==e&&26!==e&&27!==e||null===f||(e=gm(a,c),null!=e&&d.unshift(Mo(a,e,f)),e=gm(a,b),null!=e&&d.push(Mo(a,e,f)));a=a.return}return d}
+function No(a){if(null===a)return null;do a=a.return;while(a&&5!==a.tag&&27!==a.tag);return a?a:null}function Oo(a,b,c,d,e){for(var f=b._reactName,g=[];null!==c&&c!==d;){var h=c,l=h.alternate,n=h.stateNode;h=h.tag;if(null!==l&&l===d)break;5!==h&&26!==h&&27!==h||null===n||(l=n,e?(n=gm(c,f),null!=n&&g.unshift(Mo(c,n,l))):e||(n=gm(c,f),null!=n&&g.push(Mo(c,n,l))));c=c.return}0!==g.length&&a.push({event:b,listeners:g})}var Po=/\r\n?/g,Qo=/\u0000|\uFFFD/g;
+function Ro(a){return("string"===typeof a?a:""+a).replace(Po,"\n").replace(Qo,"")}function kj(a,b,c){b=Ro(b);if(Ro(a)!==b&&c)throw Error(u(425));}function gk(){}
 function Z(a,b,c,d,e,f){switch(c){case "children":"string"===typeof d?"body"===b||"textarea"===b&&""===d||Oc(a,d):"number"===typeof d&&"body"!==b&&Oc(a,""+d);break;case "className":qc(a,"class",d);break;case "tabIndex":qc(a,"tabindex",d);break;case "dir":case "role":case "viewBox":case "width":case "height":qc(a,c,d);break;case "style":Rc(a,d,f);break;case "src":case "href":if(""===d){a.removeAttribute(c);break}if(null==d||"function"===typeof d||"symbol"===typeof d||"boolean"===typeof d){a.removeAttribute(c);
 break}a.setAttribute(c,""+d);break;case "action":case "formAction":if("function"===typeof d){a.setAttribute(c,"javascript:throw new Error('A React form was unexpectedly submitted. If you called form.submit() manually, consider using form.requestSubmit() instead. If you\\'re trying to use event.stopPropagation() in a submit event handler, consider also calling event.preventDefault().')");break}else"function"===typeof f&&("formAction"===c?("input"!==b&&Z(a,b,"name",e.name,e,null),Z(a,b,"formEncType",
 e.formEncType,e,null),Z(a,b,"formMethod",e.formMethod,e,null),Z(a,b,"formTarget",e.formTarget,e,null)):(Z(a,b,"encType",e.encType,e,null),Z(a,b,"method",e.method,e,null),Z(a,b,"target",e.target,e,null)));if(null==d||"symbol"===typeof d||"boolean"===typeof d){a.removeAttribute(c);break}a.setAttribute(c,""+d);break;case "onClick":null!=d&&(a.onclick=gk);break;case "onScroll":null!=d&&Y("scroll",a);break;case "onScrollEnd":null!=d&&Y("scrollend",a);break;case "dangerouslySetInnerHTML":if(null!=d){if("object"!==
-typeof d||!("__html"in d))throw Error(t(61));d=d.__html;if(null!=d){if(null!=e.children)throw Error(t(60));a.innerHTML=d}}break;case "multiple":a.multiple=d&&"function"!==typeof d&&"symbol"!==typeof d;break;case "muted":a.muted=d&&"function"!==typeof d&&"symbol"!==typeof d;break;case "suppressContentEditableWarning":case "suppressHydrationWarning":case "defaultValue":case "defaultChecked":case "innerHTML":break;case "autoFocus":break;case "xlinkHref":if(null==d||"function"===typeof d||"boolean"===
+typeof d||!("__html"in d))throw Error(u(61));d=d.__html;if(null!=d){if(null!=e.children)throw Error(u(60));a.innerHTML=d}}break;case "multiple":a.multiple=d&&"function"!==typeof d&&"symbol"!==typeof d;break;case "muted":a.muted=d&&"function"!==typeof d&&"symbol"!==typeof d;break;case "suppressContentEditableWarning":case "suppressHydrationWarning":case "defaultValue":case "defaultChecked":case "innerHTML":break;case "autoFocus":break;case "xlinkHref":if(null==d||"function"===typeof d||"boolean"===
 typeof d||"symbol"===typeof d){a.removeAttribute("xlink:href");break}a.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",""+d);break;case "contentEditable":case "spellCheck":case "draggable":case "value":case "autoReverse":case "externalResourcesRequired":case "focusable":case "preserveAlpha":null!=d&&"function"!==typeof d&&"symbol"!==typeof d?a.setAttribute(c,""+d):a.removeAttribute(c);break;case "allowFullScreen":case "async":case "autoPlay":case "controls":case "default":case "defer":case "disabled":case "disablePictureInPicture":case "disableRemotePlayback":case "formNoValidate":case "hidden":case "loop":case "noModule":case "noValidate":case "open":case "playsInline":case "readOnly":case "required":case "reversed":case "scoped":case "seamless":case "itemScope":d&&
 "function"!==typeof d&&"symbol"!==typeof d?a.setAttribute(c,""):a.removeAttribute(c);break;case "capture":case "download":!0===d?a.setAttribute(c,""):!1!==d&&null!=d&&"function"!==typeof d&&"symbol"!==typeof d?a.setAttribute(c,d):a.removeAttribute(c);break;case "cols":case "rows":case "size":case "span":null!=d&&"function"!==typeof d&&"symbol"!==typeof d&&!isNaN(d)&&1<=d?a.setAttribute(c,d):a.removeAttribute(c);break;case "rowSpan":case "start":null==d||"function"===typeof d||"symbol"===typeof d||
 isNaN(d)?a.removeAttribute(c):a.setAttribute(c,d);break;case "xlinkActuate":rc(a,"http://www.w3.org/1999/xlink","xlink:actuate",d);break;case "xlinkArcrole":rc(a,"http://www.w3.org/1999/xlink","xlink:arcrole",d);break;case "xlinkRole":rc(a,"http://www.w3.org/1999/xlink","xlink:role",d);break;case "xlinkShow":rc(a,"http://www.w3.org/1999/xlink","xlink:show",d);break;case "xlinkTitle":rc(a,"http://www.w3.org/1999/xlink","xlink:title",d);break;case "xlinkType":rc(a,"http://www.w3.org/1999/xlink","xlink:type",
 d);break;case "xmlBase":rc(a,"http://www.w3.org/XML/1998/namespace","xml:base",d);break;case "xmlLang":rc(a,"http://www.w3.org/XML/1998/namespace","xml:lang",d);break;case "xmlSpace":rc(a,"http://www.w3.org/XML/1998/namespace","xml:space",d);break;case "is":pc(a,"is",d);break;case "innerText":case "textContent":break;default:if(!(2<c.length)||"o"!==c[0]&&"O"!==c[0]||"n"!==c[1]&&"N"!==c[1])e=Tc.get(c)||c,pc(a,e,d)}}
-function So(a,b,c,d,e,f){switch(c){case "style":Rc(a,d,f);break;case "dangerouslySetInnerHTML":if(null!=d){if("object"!==typeof d||!("__html"in d))throw Error(t(61));c=d.__html;if(null!=c){if(null!=e.children)throw Error(t(60));a.innerHTML=c}}break;case "children":"string"===typeof d?Oc(a,d):"number"===typeof d&&Oc(a,""+d);break;case "onScroll":null!=d&&Y("scroll",a);break;case "onScrollEnd":null!=d&&Y("scrollend",a);break;case "onClick":null!=d&&(a.onclick=gk);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":case "innerHTML":break;
+function So(a,b,c,d,e,f){switch(c){case "style":Rc(a,d,f);break;case "dangerouslySetInnerHTML":if(null!=d){if("object"!==typeof d||!("__html"in d))throw Error(u(61));c=d.__html;if(null!=c){if(null!=e.children)throw Error(u(60));a.innerHTML=c}}break;case "children":"string"===typeof d?Oc(a,d):"number"===typeof d&&Oc(a,""+d);break;case "onScroll":null!=d&&Y("scroll",a);break;case "onScrollEnd":null!=d&&Y("scrollend",a);break;case "onClick":null!=d&&(a.onclick=gk);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":case "innerHTML":break;
 case "innerText":case "textContent":break;default:if(!hc.hasOwnProperty(c))a:{if("o"===c[0]&&"n"===c[1]&&(e=c.endsWith("Capture"),b=c.slice(2,e?c.length-7:void 0),f=dc(a),f=null!=f?f[c]:null,"function"===typeof f&&a.removeEventListener(b,f,e),"function"===typeof d)){"function"!==typeof f&&null!==f&&(c in a?a[c]=null:a.hasAttribute(c)&&a.removeAttribute(c));a.addEventListener(b,d,e);break a}c in a?a[c]=d:!0===d?a.setAttribute(c,""):pc(a,c,d)}}}
-function jj(a,b,c){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "input":Y("invalid",a);var d=null,e=null,f=null,g=null,h=null,l=null;for(q in c)if(c.hasOwnProperty(q)){var p=c[q];if(null!=p)switch(q){case "name":d=p;break;case "type":e=p;break;case "checked":h=p;break;case "defaultChecked":l=p;break;case "value":f=p;break;case "defaultValue":g=p;break;case "children":case "dangerouslySetInnerHTML":if(null!=p)throw Error(t(137,b));break;default:Z(a,
-b,q,p,c,null)}}Jc(a,f,g,h,l,e,d,!1);Cc(a);return;case "select":Y("invalid",a);var q=e=f=null;for(d in c)if(c.hasOwnProperty(d)&&(g=c[d],null!=g))switch(d){case "value":f=g;break;case "defaultValue":e=g;break;case "multiple":q=g;default:Z(a,b,d,g,c,null)}b=f;c=e;a.multiple=!!q;null!=b?Lc(a,!!q,b,!1):null!=c&&Lc(a,!!q,c,!0);return;case "textarea":Y("invalid",a);f=d=q=null;for(e in c)if(c.hasOwnProperty(e)&&(g=c[e],null!=g))switch(e){case "value":q=g;break;case "defaultValue":d=g;break;case "children":f=
-g;break;case "dangerouslySetInnerHTML":if(null!=g)throw Error(t(91));break;default:Z(a,b,e,g,c,null)}Nc(a,q,d,f);Cc(a);return;case "option":for(g in c)if(c.hasOwnProperty(g)&&(q=c[g],null!=q))switch(g){case "selected":a.selected=q&&"function"!==typeof q&&"symbol"!==typeof q;break;default:Z(a,b,g,q,c,null)}return;case "dialog":Y("cancel",a);Y("close",a);break;case "iframe":case "object":Y("load",a);break;case "video":case "audio":for(q=0;q<Go.length;q++)Y(Go[q],a);break;case "image":Y("error",a);Y("load",
-a);break;case "details":Y("toggle",a);break;case "embed":case "source":case "img":case "link":Y("error",a),Y("load",a);case "area":case "base":case "br":case "col":case "hr":case "keygen":case "meta":case "param":case "track":case "wbr":case "menuitem":for(h in c)if(c.hasOwnProperty(h)&&(q=c[h],null!=q))switch(h){case "children":case "dangerouslySetInnerHTML":throw Error(t(137,b));default:Z(a,b,h,q,c,null)}return;default:if(Sc(b)){for(l in c)c.hasOwnProperty(l)&&(q=c[l],null!=q&&So(a,b,l,q,c,null));
+function jj(a,b,c){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "input":Y("invalid",a);var d=null,e=null,f=null,g=null,h=null,l=null;for(q in c)if(c.hasOwnProperty(q)){var n=c[q];if(null!=n)switch(q){case "name":d=n;break;case "type":e=n;break;case "checked":h=n;break;case "defaultChecked":l=n;break;case "value":f=n;break;case "defaultValue":g=n;break;case "children":case "dangerouslySetInnerHTML":if(null!=n)throw Error(u(137,b));break;default:Z(a,
+b,q,n,c,null)}}Jc(a,f,g,h,l,e,d,!1);Cc(a);return;case "select":Y("invalid",a);var q=e=f=null;for(d in c)if(c.hasOwnProperty(d)&&(g=c[d],null!=g))switch(d){case "value":f=g;break;case "defaultValue":e=g;break;case "multiple":q=g;default:Z(a,b,d,g,c,null)}b=f;c=e;a.multiple=!!q;null!=b?Lc(a,!!q,b,!1):null!=c&&Lc(a,!!q,c,!0);return;case "textarea":Y("invalid",a);f=d=q=null;for(e in c)if(c.hasOwnProperty(e)&&(g=c[e],null!=g))switch(e){case "value":q=g;break;case "defaultValue":d=g;break;case "children":f=
+g;break;case "dangerouslySetInnerHTML":if(null!=g)throw Error(u(91));break;default:Z(a,b,e,g,c,null)}Nc(a,q,d,f);Cc(a);return;case "option":for(g in c)if(c.hasOwnProperty(g)&&(q=c[g],null!=q))switch(g){case "selected":a.selected=q&&"function"!==typeof q&&"symbol"!==typeof q;break;default:Z(a,b,g,q,c,null)}return;case "dialog":Y("cancel",a);Y("close",a);break;case "iframe":case "object":Y("load",a);break;case "video":case "audio":for(q=0;q<Go.length;q++)Y(Go[q],a);break;case "image":Y("error",a);Y("load",
+a);break;case "details":Y("toggle",a);break;case "embed":case "source":case "img":case "link":Y("error",a),Y("load",a);case "area":case "base":case "br":case "col":case "hr":case "keygen":case "meta":case "param":case "track":case "wbr":case "menuitem":for(h in c)if(c.hasOwnProperty(h)&&(q=c[h],null!=q))switch(h){case "children":case "dangerouslySetInnerHTML":throw Error(u(137,b));default:Z(a,b,h,q,c,null)}return;default:if(Sc(b)){for(l in c)c.hasOwnProperty(l)&&(q=c[l],null!=q&&So(a,b,l,q,c,null));
 return}}for(f in c)c.hasOwnProperty(f)&&(q=c[f],null!=q&&Z(a,b,f,q,c,null))}
-function zk(a,b,c,d){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "input":var e=null,f=null,g=null,h=null,l=null,p=null,q=null;for(u in c){var x=c[u];if(c.hasOwnProperty(u)&&null!=x)switch(u){case "checked":break;case "value":break;case "defaultValue":l=x;default:d.hasOwnProperty(u)||Z(a,b,u,null,d,x)}}for(var r in d){var u=d[r];x=c[r];if(d.hasOwnProperty(r)&&(null!=u||null!=x))switch(r){case "type":f=u;break;case "name":e=u;break;case "checked":p=
-u;break;case "defaultChecked":q=u;break;case "value":g=u;break;case "defaultValue":h=u;break;case "children":case "dangerouslySetInnerHTML":if(null!=u)throw Error(t(137,b));break;default:u!==x&&Z(a,b,r,u,d,x)}}Hc(a,g,h,l,p,q,f,e);return;case "select":u=g=h=r=null;for(f in c)if(l=c[f],c.hasOwnProperty(f)&&null!=l)switch(f){case "value":break;case "multiple":u=l;default:d.hasOwnProperty(f)||Z(a,b,f,null,d,l)}for(e in d)if(f=d[e],l=c[e],d.hasOwnProperty(e)&&(null!=f||null!=l))switch(e){case "value":r=
-f;break;case "defaultValue":h=f;break;case "multiple":g=f;default:f!==l&&Z(a,b,e,f,d,l)}b=h;c=g;d=u;null!=r?Lc(a,!!c,r,!1):!!d!==!!c&&(null!=b?Lc(a,!!c,b,!0):Lc(a,!!c,c?[]:"",!1));return;case "textarea":u=r=null;for(h in c)if(e=c[h],c.hasOwnProperty(h)&&null!=e&&!d.hasOwnProperty(h))switch(h){case "value":break;case "children":break;default:Z(a,b,h,null,d,e)}for(g in d)if(e=d[g],f=c[g],d.hasOwnProperty(g)&&(null!=e||null!=f))switch(g){case "value":r=e;break;case "defaultValue":u=e;break;case "children":break;
-case "dangerouslySetInnerHTML":if(null!=e)throw Error(t(91));break;default:e!==f&&Z(a,b,g,e,d,f)}Mc(a,r,u);return;case "option":for(var A in c)if(r=c[A],c.hasOwnProperty(A)&&null!=r&&!d.hasOwnProperty(A))switch(A){case "selected":a.selected=!1;break;default:Z(a,b,A,null,d,r)}for(l in d)if(r=d[l],u=c[l],d.hasOwnProperty(l)&&r!==u&&(null!=r||null!=u))switch(l){case "selected":a.selected=r&&"function"!==typeof r&&"symbol"!==typeof r;break;default:Z(a,b,l,r,d,u)}return;case "img":case "link":case "area":case "base":case "br":case "col":case "embed":case "hr":case "keygen":case "meta":case "param":case "source":case "track":case "wbr":case "menuitem":for(var C in c)r=
-c[C],c.hasOwnProperty(C)&&null!=r&&!d.hasOwnProperty(C)&&Z(a,b,C,null,d,r);for(p in d)if(r=d[p],u=c[p],d.hasOwnProperty(p)&&r!==u&&(null!=r||null!=u))switch(p){case "children":case "dangerouslySetInnerHTML":if(null!=r)throw Error(t(137,b));break;default:Z(a,b,p,r,d,u)}return;default:if(Sc(b)){for(var J in c)r=c[J],c.hasOwnProperty(J)&&null!=r&&!d.hasOwnProperty(J)&&So(a,b,J,null,d,r);for(q in d)r=d[q],u=c[q],!d.hasOwnProperty(q)||r===u||null==r&&null==u||So(a,b,q,r,d,u);return}}for(var Q in c)r=c[Q],
-c.hasOwnProperty(Q)&&null!=r&&!d.hasOwnProperty(Q)&&Z(a,b,Q,null,d,r);for(x in d)r=d[x],u=c[x],!d.hasOwnProperty(x)||r===u||null==r&&null==u||Z(a,b,x,r,d,u)}var Lj=null,Pj=null;function ij(a){return 9===a.nodeType?a:a.ownerDocument}function Pa(a){switch(a){case "http://www.w3.org/2000/svg":return 1;case "http://www.w3.org/1998/Math/MathML":return 2;default:return 0}}
+function zk(a,b,c,d){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "input":var e=null,f=null,g=null,h=null,l=null,n=null,q=null;for(r in c){var w=c[r];if(c.hasOwnProperty(r)&&null!=w)switch(r){case "checked":break;case "value":break;case "defaultValue":l=w;default:d.hasOwnProperty(r)||Z(a,b,r,null,d,w)}}for(var t in d){var r=d[t];w=c[t];if(d.hasOwnProperty(t)&&(null!=r||null!=w))switch(t){case "type":f=r;break;case "name":e=r;break;case "checked":n=
+r;break;case "defaultChecked":q=r;break;case "value":g=r;break;case "defaultValue":h=r;break;case "children":case "dangerouslySetInnerHTML":if(null!=r)throw Error(u(137,b));break;default:r!==w&&Z(a,b,t,r,d,w)}}Hc(a,g,h,l,n,q,f,e);return;case "select":r=g=h=t=null;for(f in c)if(l=c[f],c.hasOwnProperty(f)&&null!=l)switch(f){case "value":break;case "multiple":r=l;default:d.hasOwnProperty(f)||Z(a,b,f,null,d,l)}for(e in d)if(f=d[e],l=c[e],d.hasOwnProperty(e)&&(null!=f||null!=l))switch(e){case "value":t=
+f;break;case "defaultValue":h=f;break;case "multiple":g=f;default:f!==l&&Z(a,b,e,f,d,l)}b=h;c=g;d=r;null!=t?Lc(a,!!c,t,!1):!!d!==!!c&&(null!=b?Lc(a,!!c,b,!0):Lc(a,!!c,c?[]:"",!1));return;case "textarea":r=t=null;for(h in c)if(e=c[h],c.hasOwnProperty(h)&&null!=e&&!d.hasOwnProperty(h))switch(h){case "value":break;case "children":break;default:Z(a,b,h,null,d,e)}for(g in d)if(e=d[g],f=c[g],d.hasOwnProperty(g)&&(null!=e||null!=f))switch(g){case "value":t=e;break;case "defaultValue":r=e;break;case "children":break;
+case "dangerouslySetInnerHTML":if(null!=e)throw Error(u(91));break;default:e!==f&&Z(a,b,g,e,d,f)}Mc(a,t,r);return;case "option":for(var A in c)if(t=c[A],c.hasOwnProperty(A)&&null!=t&&!d.hasOwnProperty(A))switch(A){case "selected":a.selected=!1;break;default:Z(a,b,A,null,d,t)}for(l in d)if(t=d[l],r=c[l],d.hasOwnProperty(l)&&t!==r&&(null!=t||null!=r))switch(l){case "selected":a.selected=t&&"function"!==typeof t&&"symbol"!==typeof t;break;default:Z(a,b,l,t,d,r)}return;case "img":case "link":case "area":case "base":case "br":case "col":case "embed":case "hr":case "keygen":case "meta":case "param":case "source":case "track":case "wbr":case "menuitem":for(var C in c)t=
+c[C],c.hasOwnProperty(C)&&null!=t&&!d.hasOwnProperty(C)&&Z(a,b,C,null,d,t);for(n in d)if(t=d[n],r=c[n],d.hasOwnProperty(n)&&t!==r&&(null!=t||null!=r))switch(n){case "children":case "dangerouslySetInnerHTML":if(null!=t)throw Error(u(137,b));break;default:Z(a,b,n,t,d,r)}return;default:if(Sc(b)){for(var J in c)t=c[J],c.hasOwnProperty(J)&&null!=t&&!d.hasOwnProperty(J)&&So(a,b,J,null,d,t);for(q in d)t=d[q],r=c[q],!d.hasOwnProperty(q)||t===r||null==t&&null==r||So(a,b,q,t,d,r);return}}for(var Q in c)t=c[Q],
+c.hasOwnProperty(Q)&&null!=t&&!d.hasOwnProperty(Q)&&Z(a,b,Q,null,d,t);for(w in d)t=d[w],r=c[w],!d.hasOwnProperty(w)||t===r||null==t&&null==r||Z(a,b,w,t,d,r)}var Lj=null,Pj=null;function ij(a){return 9===a.nodeType?a:a.ownerDocument}function Pa(a){switch(a){case "http://www.w3.org/2000/svg":return 1;case "http://www.w3.org/1998/Math/MathML":return 2;default:return 0}}
 function Qa(a,b){if(0===a)switch(b){case "svg":return 1;case "math":return 2;default:return 0}return 1===a&&"foreignObject"===b?0:a}function Wd(a,b){return"textarea"===a||"noscript"===a||"string"===typeof b.children||"number"===typeof b.children||"object"===typeof b.dangerouslySetInnerHTML&&null!==b.dangerouslySetInnerHTML&&null!=b.dangerouslySetInnerHTML.__html}var To=null;function Ef(){var a=window.event;if(a&&"popstate"===a.type){if(a===To)return!1;To=a;return!0}To=null;return!1}
 var pl="function"===typeof setTimeout?setTimeout:void 0,xl="function"===typeof clearTimeout?clearTimeout:void 0,Uo="function"===typeof Promise?Promise:void 0,Hf="function"===typeof queueMicrotask?queueMicrotask:"undefined"!==typeof Uo?function(a){return Uo.resolve(null).then(a).catch(Vo)}:pl;function Vo(a){setTimeout(function(){throw a;})}
 function mk(a,b){var c=b,d=0;do{var e=c.nextSibling;a.removeChild(c);if(e&&8===e.nodeType)if(c=e.data,"/$"===c){if(0===d){a.removeChild(e);nk(b);return}d--}else"$"!==c&&"$?"!==c&&"$!"!==c||d++;c=e}while(c);nk(b)}function Qj(a){var b=a.nodeType;if(9===b)Wo(a);else if(1===b)switch(a.nodeName){case "HEAD":case "HTML":case "BODY":Wo(a);break;default:a.textContent=""}}
@@ -419,59 +408,51 @@ a.getAttribute("href")!==(null==e.href?null:e.href)||a.getAttribute("crossorigin
 return a;default:return a}a=Rd(a);if(null===a)break}return null}function Pd(a,b,c){if(""===b)return null;for(;3!==a.nodeType;){if((1!==a.nodeType||"INPUT"!==a.nodeName||"hidden"!==a.type)&&!c)return null;a=Rd(a);if(null===a)return null}return a}function Nd(a){for(;null!=a;a=a.nextSibling){var b=a.nodeType;if(1===b||3===b)break;if(8===b){b=a.data;if("$"===b||"$!"===b||"$?"===b||"F!"===b||"F"===b)break;if("/$"===b)return null}}return a}function Rd(a){return Nd(a.nextSibling)}
 function gj(a,b,c,d,e){a[Rb]=e;a[Sb]=c;d=0!==(e.mode&1);switch(b){case "dialog":Y("cancel",a);Y("close",a);break;case "iframe":case "object":case "embed":Y("load",a);break;case "video":case "audio":for(e=0;e<Go.length;e++)Y(Go[e],a);break;case "source":Y("error",a);break;case "img":case "image":case "link":Y("error",a);Y("load",a);break;case "details":Y("toggle",a);break;case "input":Y("invalid",a);Jc(a,c.value,c.defaultValue,c.checked,c.defaultChecked,c.type,c.name,!0);Cc(a);break;case "select":Y("invalid",
 a);break;case "textarea":Y("invalid",a),Nc(a,c.value,c.defaultValue,c.children),Cc(a)}e=c.children;"string"!==typeof e&&"number"!==typeof e||a.textContent===""+e||(!0!==c.suppressHydrationWarning&&kj(a.textContent,e,d),d||"body"===b||(a.textContent=e));null!=c.onScroll&&Y("scroll",a);null!=c.onScrollEnd&&Y("scrollend",a);null!=c.onClick&&(a.onclick=gk)}
-function ac(a){a=a.previousSibling;for(var b=0;a;){if(8===a.nodeType){var c=a.data;if("$"===c||"$!"===c||"$?"===c){if(0===b)return a;b--}else"/$"===c&&b++}a=a.previousSibling}return null}function hj(a,b,c){b=ij(c);switch(a){case "html":a=b.documentElement;if(!a)throw Error(t(452));return a;case "head":a=b.head;if(!a)throw Error(t(453));return a;case "body":a=b.body;if(!a)throw Error(t(454));return a;default:throw Error(t(451));}}var Xo=new Map,Yo=new Set;
+function ac(a){a=a.previousSibling;for(var b=0;a;){if(8===a.nodeType){var c=a.data;if("$"===c||"$!"===c||"$?"===c){if(0===b)return a;b--}else"/$"===c&&b++}a=a.previousSibling}return null}function hj(a,b,c){b=ij(c);switch(a){case "html":a=b.documentElement;if(!a)throw Error(u(452));return a;case "head":a=b.head;if(!a)throw Error(u(453));return a;case "body":a=b.body;if(!a)throw Error(u(454));return a;default:throw Error(u(451));}}var Xo=new Map,Yo=new Set;
 function Bk(a){return"function"===typeof a.getRootNode?a.getRootNode():a.ownerDocument}var fp={prefetchDNS:Zo,preconnect:$o,preload:ap,preloadModule:bp,preinitStyle:cp,preinitScript:dp,preinitModuleScript:ep};
 function gp(a,b,c){var d=document;if("string"===typeof b&&b){var e=Gc(b);e='link[rel="'+a+'"][href="'+e+'"]';"string"===typeof c&&(e+='[crossorigin="'+c+'"]');Yo.has(e)||(Yo.add(e),a={rel:a,crossOrigin:c,href:b},null===d.querySelector(e)&&(b=d.createElement("link"),jj(b,"link",a),fc(b),d.head.appendChild(b)))}}function Zo(a){gp("dns-prefetch",a,null)}function $o(a,b){gp("preconnect",a,b)}
-function ap(a,b,c){var d=document;if(a&&b&&d){var e='link[rel="preload"][as="'+Gc(b)+'"]';"image"===b?c&&c.imageSrcSet?(e+='[imagesrcset="'+Gc(c.imageSrcSet)+'"]',"string"===typeof c.imageSizes&&(e+='[imagesizes="'+Gc(c.imageSizes)+'"]')):e+='[href="'+Gc(a)+'"]':e+='[href="'+Gc(a)+'"]';var f=e;switch(b){case "style":f=hp(a);break;case "script":f=ip(a)}Xo.has(f)||(a=w({rel:"preload",href:"image"===b&&c&&c.imageSrcSet?void 0:a,as:b},c),Xo.set(f,a),null!==d.querySelector(e)||"style"===b&&d.querySelector(jp(f))||
+function ap(a,b,c){var d=document;if(a&&b&&d){var e='link[rel="preload"][as="'+Gc(b)+'"]';"image"===b?c&&c.imageSrcSet?(e+='[imagesrcset="'+Gc(c.imageSrcSet)+'"]',"string"===typeof c.imageSizes&&(e+='[imagesizes="'+Gc(c.imageSizes)+'"]')):e+='[href="'+Gc(a)+'"]':e+='[href="'+Gc(a)+'"]';var f=e;switch(b){case "style":f=hp(a);break;case "script":f=ip(a)}Xo.has(f)||(a=x({rel:"preload",href:"image"===b&&c&&c.imageSrcSet?void 0:a,as:b},c),Xo.set(f,a),null!==d.querySelector(e)||"style"===b&&d.querySelector(jp(f))||
 "script"===b&&d.querySelector(kp(f))||(b=d.createElement("link"),jj(b,"link",a),fc(b),d.head.appendChild(b)))}}
-function bp(a,b){var c=document;if(a){var d=b&&"string"===typeof b.as?b.as:"script",e='link[rel="modulepreload"][as="'+Gc(d)+'"][href="'+Gc(a)+'"]',f=e;switch(d){case "audioworklet":case "paintworklet":case "serviceworker":case "sharedworker":case "worker":case "script":f=ip(a)}if(!Xo.has(f)&&(a=w({rel:"modulepreload",href:a},b),Xo.set(f,a),null===c.querySelector(e))){switch(d){case "audioworklet":case "paintworklet":case "serviceworker":case "sharedworker":case "worker":case "script":if(c.querySelector(kp(f)))return}d=c.createElement("link");
+function bp(a,b){var c=document;if(a){var d=b&&"string"===typeof b.as?b.as:"script",e='link[rel="modulepreload"][as="'+Gc(d)+'"][href="'+Gc(a)+'"]',f=e;switch(d){case "audioworklet":case "paintworklet":case "serviceworker":case "sharedworker":case "worker":case "script":f=ip(a)}if(!Xo.has(f)&&(a=x({rel:"modulepreload",href:a},b),Xo.set(f,a),null===c.querySelector(e))){switch(d){case "audioworklet":case "paintworklet":case "serviceworker":case "sharedworker":case "worker":case "script":if(c.querySelector(kp(f)))return}d=c.createElement("link");
 jj(d,"link",a);fc(d);c.head.appendChild(d)}}}
-function cp(a,b,c){var d=document;if(a){var e=ec(d).hoistableStyles,f=hp(a);b=b||"default";var g=e.get(f);if(!g){var h={loading:0,preload:null};if(g=d.querySelector(jp(f)))h.loading=5;else{a=w({rel:"stylesheet",href:a,"data-precedence":b},c);(c=Xo.get(f))&&lp(a,c);var l=g=d.createElement("link");fc(l);jj(l,"link",a);l._p=new Promise(function(p,q){l.onload=p;l.onerror=q});l.addEventListener("load",function(){h.loading|=1});l.addEventListener("error",function(){h.loading|=2});h.loading|=4;mp(g,b,d)}g=
-{type:"stylesheet",instance:g,count:1,state:h};e.set(f,g)}}}function dp(a,b){var c=document;if(a){var d=ec(c).hoistableScripts,e=ip(a),f=d.get(e);f||(f=c.querySelector(kp(e)),f||(a=w({src:a,async:!0},b),(b=Xo.get(e))&&np(a,b),f=c.createElement("script"),fc(f),jj(f,"link",a),c.head.appendChild(f)),f={type:"script",instance:f,count:1,state:null},d.set(e,f))}}
-function ep(a,b){var c=document;if(a){var d=ec(c).hoistableScripts,e=ip(a),f=d.get(e);f||(f=c.querySelector(kp(e)),f||(a=w({src:a,async:!0,type:"module"},b),(b=Xo.get(e))&&np(a,b),f=c.createElement("script"),fc(f),jj(f,"link",a),c.head.appendChild(f)),f={type:"script",instance:f,count:1,state:null},d.set(e,f))}}
-function Ql(a,b,c){b=(b=La.current)?Bk(b):null;if(!b)throw Error(t(446));switch(a){case "meta":case "title":return null;case "style":return"string"===typeof c.precedence&&"string"===typeof c.href?(c=hp(c.href),b=ec(b).hoistableStyles,a=b.get(c),a||(a={type:"style",instance:null,count:0,state:null},b.set(c,a)),a):{type:"void",instance:null,count:0,state:null};case "link":if("stylesheet"===c.rel&&"string"===typeof c.href&&"string"===typeof c.precedence){a=hp(c.href);var d=ec(b).hoistableStyles,e=d.get(a);
+function cp(a,b,c){var d=document;if(a){var e=ec(d).hoistableStyles,f=hp(a);b=b||"default";var g=e.get(f);if(!g){var h={loading:0,preload:null};if(g=d.querySelector(jp(f)))h.loading=5;else{a=x({rel:"stylesheet",href:a,"data-precedence":b},c);(c=Xo.get(f))&&lp(a,c);var l=g=d.createElement("link");fc(l);jj(l,"link",a);l._p=new Promise(function(n,q){l.onload=n;l.onerror=q});l.addEventListener("load",function(){h.loading|=1});l.addEventListener("error",function(){h.loading|=2});h.loading|=4;mp(g,b,d)}g=
+{type:"stylesheet",instance:g,count:1,state:h};e.set(f,g)}}}function dp(a,b){var c=document;if(a){var d=ec(c).hoistableScripts,e=ip(a),f=d.get(e);f||(f=c.querySelector(kp(e)),f||(a=x({src:a,async:!0},b),(b=Xo.get(e))&&np(a,b),f=c.createElement("script"),fc(f),jj(f,"link",a),c.head.appendChild(f)),f={type:"script",instance:f,count:1,state:null},d.set(e,f))}}
+function ep(a,b){var c=document;if(a){var d=ec(c).hoistableScripts,e=ip(a),f=d.get(e);f||(f=c.querySelector(kp(e)),f||(a=x({src:a,async:!0,type:"module"},b),(b=Xo.get(e))&&np(a,b),f=c.createElement("script"),fc(f),jj(f,"link",a),c.head.appendChild(f)),f={type:"script",instance:f,count:1,state:null},d.set(e,f))}}
+function Ql(a,b,c){b=(b=La.current)?Bk(b):null;if(!b)throw Error(u(446));switch(a){case "meta":case "title":return null;case "style":return"string"===typeof c.precedence&&"string"===typeof c.href?(c=hp(c.href),b=ec(b).hoistableStyles,a=b.get(c),a||(a={type:"style",instance:null,count:0,state:null},b.set(c,a)),a):{type:"void",instance:null,count:0,state:null};case "link":if("stylesheet"===c.rel&&"string"===typeof c.href&&"string"===typeof c.precedence){a=hp(c.href);var d=ec(b).hoistableStyles,e=d.get(a);
 e||(b=b.ownerDocument||b,e={type:"stylesheet",instance:null,count:0,state:{loading:0,preload:null}},d.set(a,e),Xo.has(a)||op(b,a,{rel:"preload",as:"style",href:c.href,crossOrigin:c.crossOrigin,integrity:c.integrity,media:c.media,hrefLang:c.hrefLang,referrerPolicy:c.referrerPolicy},e.state));return e}return null;case "script":return"string"===typeof c.src&&!0===c.async?(c=ip(c.src),b=ec(b).hoistableScripts,a=b.get(c),a||(a={type:"script",instance:null,count:0,state:null},b.set(c,a)),a):{type:"void",
-instance:null,count:0,state:null};default:throw Error(t(444,a));}}function hp(a){return'href="'+Gc(a)+'"'}function jp(a){return'link[rel="stylesheet"]['+a+"]"}function pp(a){return w({},a,{"data-precedence":a.precedence,precedence:null})}
+instance:null,count:0,state:null};default:throw Error(u(444,a));}}function hp(a){return'href="'+Gc(a)+'"'}function jp(a){return'link[rel="stylesheet"]['+a+"]"}function pp(a){return x({},a,{"data-precedence":a.precedence,precedence:null})}
 function op(a,b,c,d){Xo.set(b,c);a.querySelector(jp(b))||(a.querySelector('link[rel="preload"][as="style"]['+b+"]")?d.loading=1:(b=a.createElement("link"),d.preload=b,b.addEventListener("load",function(){return d.loading|=1}),b.addEventListener("error",function(){return d.loading|=2}),jj(b,"link",c),fc(b),a.head.appendChild(b)))}function ip(a){return'[src="'+Gc(a)+'"]'}function kp(a){return"script[async]"+a}
-function yk(a,b,c){b.count++;if(null===b.instance)switch(b.type){case "style":var d=a.querySelector('style[data-href~="'+Gc(c.href)+'"]');if(d)return b.instance=d,fc(d),d;var e=w({},c,{"data-href":c.href,"data-precedence":c.precedence,href:null,precedence:null});d=(a.ownerDocument||a).createElement("style");fc(d);jj(d,"style",e);mp(d,c.precedence,a);return b.instance=d;case "stylesheet":e=hp(c.href);var f=a.querySelector(jp(e));if(f)return b.state.loading|=4,b.instance=f,fc(f),f;d=pp(c);(e=Xo.get(e))&&
-lp(d,e);f=(a.ownerDocument||a).createElement("link");fc(f);var g=f;g._p=new Promise(function(h,l){g.onload=h;g.onerror=l});jj(f,"link",d);b.state.loading|=4;mp(f,c.precedence,a);return b.instance=f;case "script":f=ip(c.src);if(e=a.querySelector(kp(f)))return b.instance=e,fc(e),e;d=c;if(e=Xo.get(f))d=w({},c),np(d,e);a=a.ownerDocument||a;e=a.createElement("script");fc(e);jj(e,"link",d);a.head.appendChild(e);return b.instance=e;case "void":return null;default:throw Error(t(443,b.type));}else"stylesheet"===
+function yk(a,b,c){b.count++;if(null===b.instance)switch(b.type){case "style":var d=a.querySelector('style[data-href~="'+Gc(c.href)+'"]');if(d)return b.instance=d,fc(d),d;var e=x({},c,{"data-href":c.href,"data-precedence":c.precedence,href:null,precedence:null});d=(a.ownerDocument||a).createElement("style");fc(d);jj(d,"style",e);mp(d,c.precedence,a);return b.instance=d;case "stylesheet":e=hp(c.href);var f=a.querySelector(jp(e));if(f)return b.state.loading|=4,b.instance=f,fc(f),f;d=pp(c);(e=Xo.get(e))&&
+lp(d,e);f=(a.ownerDocument||a).createElement("link");fc(f);var g=f;g._p=new Promise(function(h,l){g.onload=h;g.onerror=l});jj(f,"link",d);b.state.loading|=4;mp(f,c.precedence,a);return b.instance=f;case "script":f=ip(c.src);if(e=a.querySelector(kp(f)))return b.instance=e,fc(e),e;d=c;if(e=Xo.get(f))d=x({},c),np(d,e);a=a.ownerDocument||a;e=a.createElement("script");fc(e);jj(e,"link",d);a.head.appendChild(e);return b.instance=e;case "void":return null;default:throw Error(u(443,b.type));}else"stylesheet"===
 b.type&&0===(b.state.loading&4)&&(d=b.instance,b.state.loading|=4,mp(d,c.precedence,a));return b.instance}function mp(a,b,c){for(var d=c.querySelectorAll('link[rel="stylesheet"][data-precedence],style[data-precedence]'),e=d.length?d[d.length-1]:null,f=e,g=0;g<d.length;g++){var h=d[g];if(h.dataset.precedence===b)f=h;else if(f!==e)break}f?f.parentNode.insertBefore(a,f.nextSibling):(b=9===c.nodeType?c.head:c,b.insertBefore(a,b.firstChild))}
 function lp(a,b){null==a.crossOrigin&&(a.crossOrigin=b.crossOrigin);null==a.referrerPolicy&&(a.referrerPolicy=b.referrerPolicy);null==a.title&&(a.title=b.title)}function np(a,b){null==a.crossOrigin&&(a.crossOrigin=b.crossOrigin);null==a.referrerPolicy&&(a.referrerPolicy=b.referrerPolicy);null==a.integrity&&(a.integrity=b.integrity)}var Ak=null;
 function wk(a,b,c){if(null===Ak){var d=new Map;var e=Ak=new Map;e.set(c,d)}else e=Ak,d=e.get(c),d||(d=new Map,e.set(c,d));if(d.has(a))return d;d.set(a,null);c=c.getElementsByTagName(a);for(e=0;e<c.length;e++){var f=c[e];if(!(f[Yb]||f[Rb]||"link"===a&&"stylesheet"===f.getAttribute("rel"))&&"http://www.w3.org/2000/svg"!==f.namespaceURI){var g=f.getAttribute(b)||"";g=a+g;var h=d.get(g);h?h.push(f):d.set(g,[f])}}return d}
 function xk(a,b,c){a=a.ownerDocument||a;a.head.insertBefore(c,"title"===b?a.querySelector("head > title"):null)}
 function Sl(a,b,c){if(1===c||null!=b.itemProp)return!1;switch(a){case "meta":case "title":return!0;case "style":if("string"!==typeof b.precedence||"string"!==typeof b.href||""===b.href)break;return!0;case "link":if("string"!==typeof b.rel||"string"!==typeof b.href||""===b.href||b.onLoad||b.onError)break;switch(b.rel){case "stylesheet":return a=b.disabled,"string"===typeof b.precedence&&null==a;default:return!0}case "script":if(!0===b.async&&!b.onLoad&&!b.onError&&"string"===typeof b.src&&b.src)return!0}return!1}
 var rl=null;function sl(){}
-function Pk(a,b,c){if(null===rl)throw Error(t(475));var d=rl;if("stylesheet"===b.type&&("string"!==typeof c.media||!1!==matchMedia(c.media).matches)&&0===(b.state.loading&4)){if(null===b.instance){var e=hp(c.href),f=a.querySelector(jp(e));if(f){a=f._p;null!==a&&"object"===typeof a&&"function"===typeof a.then&&(d.count++,d=qp.bind(d),a.then(d,d));b.state.loading|=4;b.instance=f;fc(f);return}f=a.ownerDocument||a;c=pp(c);(e=Xo.get(e))&&lp(c,e);f=f.createElement("link");fc(f);var g=f;g._p=new Promise(function(h,
+function Pk(a,b,c){if(null===rl)throw Error(u(475));var d=rl;if("stylesheet"===b.type&&("string"!==typeof c.media||!1!==matchMedia(c.media).matches)&&0===(b.state.loading&4)){if(null===b.instance){var e=hp(c.href),f=a.querySelector(jp(e));if(f){a=f._p;null!==a&&"object"===typeof a&&"function"===typeof a.then&&(d.count++,d=qp.bind(d),a.then(d,d));b.state.loading|=4;b.instance=f;fc(f);return}f=a.ownerDocument||a;c=pp(c);(e=Xo.get(e))&&lp(c,e);f=f.createElement("link");fc(f);var g=f;g._p=new Promise(function(h,
 l){g.onload=h;g.onerror=l});jj(f,"link",c);b.instance=f}null===d.stylesheets&&(d.stylesheets=new Map);d.stylesheets.set(b,a);(a=b.state.preload)&&0===(b.state.loading&3)&&(d.count++,b=qp.bind(d),a.addEventListener("load",b),a.addEventListener("error",b))}}
-function tl(){if(null===rl)throw Error(t(475));var a=rl;a.stylesheets&&0===a.count&&rp(a,a.stylesheets);return 0<a.count?function(b){var c=setTimeout(function(){a.stylesheets&&rp(a,a.stylesheets);if(a.unsuspend){var d=a.unsuspend;a.unsuspend=null;d()}},6E4);a.unsuspend=b;return function(){a.unsuspend=null;clearTimeout(c)}}:null}function qp(){this.count--;if(0===this.count)if(this.stylesheets)rp(this,this.stylesheets);else if(this.unsuspend){var a=this.unsuspend;this.unsuspend=null;a()}}var sp=null;
+function tl(){if(null===rl)throw Error(u(475));var a=rl;a.stylesheets&&0===a.count&&rp(a,a.stylesheets);return 0<a.count?function(b){var c=setTimeout(function(){a.stylesheets&&rp(a,a.stylesheets);if(a.unsuspend){var d=a.unsuspend;a.unsuspend=null;d()}},6E4);a.unsuspend=b;return function(){a.unsuspend=null;clearTimeout(c)}}:null}function qp(){this.count--;if(0===this.count)if(this.stylesheets)rp(this,this.stylesheets);else if(this.unsuspend){var a=this.unsuspend;this.unsuspend=null;a()}}var sp=null;
 function rp(a,b){a.stylesheets=null;null!==a.unsuspend&&(a.count++,sp=new Map,b.forEach(tp,a),sp=null,qp.call(a))}
 function tp(a,b){if(!(b.state.loading&4)){var c=sp.get(a);if(c)var d=c.get("last");else{c=new Map;sp.set(a,c);for(var e=a.querySelectorAll("link[data-precedence],style[data-precedence]"),f=0;f<e.length;f++){var g=e[f];if("link"===g.nodeName||"not all"!==g.getAttribute("media"))c.set("p"+g.dataset.precedence,g),d=g}d&&c.set("last",d)}e=b.instance;g=e.getAttribute("data-precedence");f=c.get("p"+g)||d;f===d&&c.set("last",e);c.set(g,e);this.count++;d=qp.bind(this);e.addEventListener("load",d);e.addEventListener("error",
-d);f?f.parentNode.insertBefore(e,f.nextSibling):(a=9===a.nodeType?a.head:a,a.insertBefore(e,a.firstChild));b.state.loading|=4}}var up=ca.Dispatcher;"undefined"!==typeof document&&(up.current=fp);var vp="function"===typeof reportError?reportError:function(a){console.error(a)};function wp(a){this._internalRoot=a}xp.prototype.render=wp.prototype.render=function(a){var b=this._internalRoot;if(null===b)throw Error(t(409));Yl(a,b,null,null)};
+d);f?f.parentNode.insertBefore(e,f.nextSibling):(a=9===a.nodeType?a.head:a,a.insertBefore(e,a.firstChild));b.state.loading|=4}}var up=ca.Dispatcher;"undefined"!==typeof document&&(up.current=fp);var vp="function"===typeof reportError?reportError:function(a){console.error(a)};function wp(a){this._internalRoot=a}xp.prototype.render=wp.prototype.render=function(a){var b=this._internalRoot;if(null===b)throw Error(u(409));Yl(a,b,null,null)};
 xp.prototype.unmount=wp.prototype.unmount=function(){var a=this._internalRoot;if(null!==a){this._internalRoot=null;var b=a.containerInfo;vl(function(){Yl(null,a,null,null)});b[Tb]=null}};function xp(a){this._internalRoot=a}xp.prototype.unstable_scheduleHydration=function(a){if(a){var b=G;a={blockedOn:null,target:a,priority:b};for(var c=0;c<bn.length&&0!==b&&b<bn[c].priority;c++);bn.splice(c,0,a);0===c&&gn(a)}};function yp(a){return!(!a||1!==a.nodeType&&9!==a.nodeType&&11!==a.nodeType)}
 function zp(a){return!(!a||1!==a.nodeType&&9!==a.nodeType&&11!==a.nodeType&&(8!==a.nodeType||" react-mount-point-unstable "!==a.nodeValue))}function Ap(){}
-function Bp(a,b,c,d,e){if(e){if("function"===typeof d){var f=d;d=function(){var p=Zl(g);f.call(p)}}var g=Xl(b,d,a,0,null,!1,!1,"",Ap,null,null);a._reactRootContainer=g;a[Tb]=g.current;lj(8===a.nodeType?a.parentNode:a);vl();return g}Qj(a);if("function"===typeof d){var h=d;d=function(){var p=Zl(l);h.call(p)}}var l=Ul(a,0,!1,null,null,!1,!1,"",Ap,null,null);a._reactRootContainer=l;a[Tb]=l.current;lj(8===a.nodeType?a.parentNode:a);vl(function(){Yl(b,l,c,d)});return l}
-function Cp(a,b,c,d,e){var f=c._reactRootContainer;if(f){var g=f;if("function"===typeof e){var h=e;e=function(){var l=Zl(g);h.call(l)}}Yl(b,g,a,e)}else g=Bp(c,b,a,e,d);return Zl(g)}function Dp(a,b){if("font"===a)return"";if("string"===typeof b)return"use-credentials"===b?b:""}var Ep=ca.Dispatcher;ca.Events=[bc,cc,dc,Zc,$c,ul];var Fp={findFiberByHostInstance:$b,bundleType:0,version:"18.3.0-experimental-2983249dd-20231107",rendererPackageName:"react-dom"};
-(function(a){if("undefined"===typeof __REACT_DEVTOOLS_GLOBAL_HOOK__)return!1;var b=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(b.isDisabled||!b.supportsFiber)return!0;try{a=w({},a,{getLaneLabelMap:jb,injectProfilingHooks:ib}),eb=b.inject(a),fb=b}catch(c){}return b.checkDCE?!0:!1})({bundleType:Fp.bundleType,version:Fp.version,rendererPackageName:Fp.rendererPackageName,rendererConfig:Fp.rendererConfig,overrideHookState:null,overrideHookStateDeletePath:null,overrideHookStateRenamePath:null,overrideProps:null,
-overridePropsDeletePath:null,overridePropsRenamePath:null,setErrorHandler:null,setSuspenseHandler:null,scheduleUpdate:null,currentDispatcherRef:da.ReactCurrentDispatcher,findHostInstanceByFiber:function(a){a=ed(a);return null===a?null:a.stateNode},findFiberByHostInstance:Fp.findFiberByHostInstance||dm,findHostInstancesForRefresh:null,scheduleRefresh:null,scheduleRoot:null,setRefreshHandler:null,getCurrentFiber:null,reconcilerVersion:"18.3.0-experimental-2983249dd-20231107"});
-exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=ca;exports.createPortal=function(a,b){var c=2<arguments.length&&void 0!==arguments[2]?arguments[2]:null;if(!yp(b))throw Error(t(200));return Vl(a,b,null,c)};
-exports.createRoot=function(a,b){if(!yp(a))throw Error(t(299));var c=!1,d="",e=vp,f=null;null!==b&&void 0!==b&&(!0===b.unstable_strictMode&&(c=!0),void 0!==b.identifierPrefix&&(d=b.identifierPrefix),void 0!==b.onRecoverableError&&(e=b.onRecoverableError),void 0!==b.unstable_transitionCallbacks&&(f=b.unstable_transitionCallbacks));b=Ul(a,1,!1,null,null,c,!1,d,e,f,null);a[Tb]=b.current;up.current=fp;lj(8===a.nodeType?a.parentNode:a);return new wp(b)};
-exports.experimental_useFormState=function(a,b,c){return ia(a,b,c)};exports.experimental_useFormStatus=function(){return ha()};exports.findDOMNode=function(a){if(null==a)return null;if(1===a.nodeType)return a;var b=a._reactInternals;if(void 0===b){if("function"===typeof a.render)throw Error(t(188));a=Object.keys(a).join(",");throw Error(t(268,a));}a=ed(b);a=null===a?null:a.stateNode;return a};exports.flushSync=function(a){return vl(a)};
-exports.hydrate=function(a,b,c){if(!zp(b))throw Error(t(200));return Cp(null,a,b,!0,c)};
-exports.hydrateRoot=function(a,b,c){if(!yp(a))throw Error(t(405));var d=!1,e="",f=vp,g=null,h=null;null!==c&&void 0!==c&&(!0===c.unstable_strictMode&&(d=!0),void 0!==c.identifierPrefix&&(e=c.identifierPrefix),void 0!==c.onRecoverableError&&(f=c.onRecoverableError),void 0!==c.unstable_transitionCallbacks&&(g=c.unstable_transitionCallbacks),void 0!==c.formState&&(h=c.formState));b=Xl(b,null,a,1,null!=c?c:null,d,!1,e,f,g,h);a[Tb]=b.current;up.current=fp;lj(a);return new xp(b)};
+function Bp(a,b,c,d,e){if(e){if("function"===typeof d){var f=d;d=function(){var n=Zl(g);f.call(n)}}var g=Xl(b,d,a,0,null,!1,!1,"",Ap,null,null);a._reactRootContainer=g;a[Tb]=g.current;lj(8===a.nodeType?a.parentNode:a);vl();return g}Qj(a);if("function"===typeof d){var h=d;d=function(){var n=Zl(l);h.call(n)}}var l=Ul(a,0,!1,null,null,!1,!1,"",Ap,null,null);a._reactRootContainer=l;a[Tb]=l.current;lj(8===a.nodeType?a.parentNode:a);vl(function(){Yl(b,l,c,d)});return l}
+function Cp(a,b,c,d,e){var f=c._reactRootContainer;if(f){var g=f;if("function"===typeof e){var h=e;e=function(){var l=Zl(g);h.call(l)}}Yl(b,g,a,e)}else g=Bp(c,b,a,e,d);return Zl(g)}function Dp(a,b){if("font"===a)return"";if("string"===typeof b)return"use-credentials"===b?b:""}var Ep=ca.Dispatcher;ca.Events=[bc,cc,dc,Zc,$c,ul];var Fp={findFiberByHostInstance:$b,bundleType:0,version:"18.3.0-experimental-7508dcd5c-20231108",rendererPackageName:"react-dom"};
+(function(a){if("undefined"===typeof __REACT_DEVTOOLS_GLOBAL_HOOK__)return!1;var b=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(b.isDisabled||!b.supportsFiber)return!0;try{a=x({},a,{getLaneLabelMap:jb,injectProfilingHooks:ib}),eb=b.inject(a),fb=b}catch(c){}return b.checkDCE?!0:!1})({bundleType:Fp.bundleType,version:Fp.version,rendererPackageName:Fp.rendererPackageName,rendererConfig:Fp.rendererConfig,overrideHookState:null,overrideHookStateDeletePath:null,overrideHookStateRenamePath:null,overrideProps:null,
+overridePropsDeletePath:null,overridePropsRenamePath:null,setErrorHandler:null,setSuspenseHandler:null,scheduleUpdate:null,currentDispatcherRef:da.ReactCurrentDispatcher,findHostInstanceByFiber:function(a){a=ed(a);return null===a?null:a.stateNode},findFiberByHostInstance:Fp.findFiberByHostInstance||dm,findHostInstancesForRefresh:null,scheduleRefresh:null,scheduleRoot:null,setRefreshHandler:null,getCurrentFiber:null,reconcilerVersion:"18.3.0-experimental-7508dcd5c-20231108"});
+exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=ca;exports.createPortal=function(a,b){var c=2<arguments.length&&void 0!==arguments[2]?arguments[2]:null;if(!yp(b))throw Error(u(200));return Vl(a,b,null,c)};
+exports.createRoot=function(a,b){if(!yp(a))throw Error(u(299));var c=!1,d="",e=vp,f=null;null!==b&&void 0!==b&&(!0===b.unstable_strictMode&&(c=!0),void 0!==b.identifierPrefix&&(d=b.identifierPrefix),void 0!==b.onRecoverableError&&(e=b.onRecoverableError),void 0!==b.unstable_transitionCallbacks&&(f=b.unstable_transitionCallbacks));b=Ul(a,1,!1,null,null,c,!1,d,e,f,null);a[Tb]=b.current;up.current=fp;lj(8===a.nodeType?a.parentNode:a);return new wp(b)};
+exports.experimental_useFormState=function(a,b,c){return ia(a,b,c)};exports.experimental_useFormStatus=function(){return ha()};exports.findDOMNode=function(a){if(null==a)return null;if(1===a.nodeType)return a;var b=a._reactInternals;if(void 0===b){if("function"===typeof a.render)throw Error(u(188));a=Object.keys(a).join(",");throw Error(u(268,a));}a=ed(b);a=null===a?null:a.stateNode;return a};exports.flushSync=function(a){return vl(a)};
+exports.hydrate=function(a,b,c){if(!zp(b))throw Error(u(200));return Cp(null,a,b,!0,c)};
+exports.hydrateRoot=function(a,b,c){if(!yp(a))throw Error(u(405));var d=!1,e="",f=vp,g=null,h=null;null!==c&&void 0!==c&&(!0===c.unstable_strictMode&&(d=!0),void 0!==c.identifierPrefix&&(e=c.identifierPrefix),void 0!==c.onRecoverableError&&(f=c.onRecoverableError),void 0!==c.unstable_transitionCallbacks&&(g=c.unstable_transitionCallbacks),void 0!==c.formState&&(h=c.formState));b=Xl(b,null,a,1,null!=c?c:null,d,!1,e,f,g,h);a[Tb]=b.current;up.current=fp;lj(a);return new xp(b)};
 exports.preconnect=function(a,b){var c=Ep.current;c&&"string"===typeof a&&(b?(b=b.crossOrigin,b="string"===typeof b?"use-credentials"===b?b:"":void 0):b=null,c.preconnect(a,b))};exports.prefetchDNS=function(a){var b=Ep.current;b&&"string"===typeof a&&b.prefetchDNS(a)};
 exports.preinit=function(a,b){var c=Ep.current;if(c&&"string"===typeof a&&b&&"string"===typeof b.as){var d=b.as,e=Dp(d,b.crossOrigin),f="string"===typeof b.integrity?b.integrity:void 0,g="string"===typeof b.fetchPriority?b.fetchPriority:void 0;"style"===d?c.preinitStyle(a,"string"===typeof b.precedence?b.precedence:void 0,{crossOrigin:e,integrity:f,fetchPriority:g}):"script"===d&&c.preinitScript(a,{crossOrigin:e,integrity:f,fetchPriority:g,nonce:"string"===typeof b.nonce?b.nonce:void 0})}};
 exports.preinitModule=function(a,b){var c=Ep.current;if(c&&"string"===typeof a)if("object"===typeof b&&null!==b){if(null==b.as||"script"===b.as){var d=Dp(b.as,b.crossOrigin);c.preinitModuleScript(a,{crossOrigin:d,integrity:"string"===typeof b.integrity?b.integrity:void 0,nonce:"string"===typeof b.nonce?b.nonce:void 0})}}else null==b&&c.preinitModuleScript(a)};
 exports.preload=function(a,b){var c=Ep.current;if(c&&"string"===typeof a&&"object"===typeof b&&null!==b&&"string"===typeof b.as){var d=b.as,e=Dp(d,b.crossOrigin);c.preload(a,d,{crossOrigin:e,integrity:"string"===typeof b.integrity?b.integrity:void 0,nonce:"string"===typeof b.nonce?b.nonce:void 0,type:"string"===typeof b.type?b.type:void 0,fetchPriority:"string"===typeof b.fetchPriority?b.fetchPriority:void 0,referrerPolicy:"string"===typeof b.referrerPolicy?b.referrerPolicy:void 0,imageSrcSet:"string"===
-typeof b.imageSrcSet?b.imageSrcSet:void 0,imageSizes:"string"===typeof b.imageSizes?b.imageSizes:void 0})}};exports.preloadModule=function(a,b){var c=Ep.current;if(c&&"string"===typeof a)if(b){var d=Dp(b.as,b.crossOrigin);c.preloadModule(a,{as:"string"===typeof b.as&&"script"!==b.as?b.as:void 0,crossOrigin:d,integrity:"string"===typeof b.integrity?b.integrity:void 0})}else c.preloadModule(a)};exports.render=function(a,b,c){if(!zp(b))throw Error(t(200));return Cp(null,a,b,!1,c)};
-exports.unmountComponentAtNode=function(a){if(!zp(a))throw Error(t(40));return a._reactRootContainer?(vl(function(){Cp(null,null,a,!1,function(){a._reactRootContainer=null;a[Tb]=null})}),!0):!1};exports.unstable_batchedUpdates=ul;exports.unstable_renderSubtreeIntoContainer=function(a,b,c,d){if(!zp(c))throw Error(t(200));if(null==a||void 0===a._reactInternals)throw Error(t(38));return Cp(a,b,c,!1,d)};exports.unstable_runWithPriority=Nb;exports.useFormState=ia;exports.useFormStatus=ha;
-exports.version="18.3.0-experimental-2983249dd-20231107";
+typeof b.imageSrcSet?b.imageSrcSet:void 0,imageSizes:"string"===typeof b.imageSizes?b.imageSizes:void 0})}};exports.preloadModule=function(a,b){var c=Ep.current;if(c&&"string"===typeof a)if(b){var d=Dp(b.as,b.crossOrigin);c.preloadModule(a,{as:"string"===typeof b.as&&"script"!==b.as?b.as:void 0,crossOrigin:d,integrity:"string"===typeof b.integrity?b.integrity:void 0})}else c.preloadModule(a)};exports.render=function(a,b,c){if(!zp(b))throw Error(u(200));return Cp(null,a,b,!1,c)};
+exports.unmountComponentAtNode=function(a){if(!zp(a))throw Error(u(40));return a._reactRootContainer?(vl(function(){Cp(null,null,a,!1,function(){a._reactRootContainer=null;a[Tb]=null})}),!0):!1};exports.unstable_batchedUpdates=ul;exports.unstable_renderSubtreeIntoContainer=function(a,b,c,d){if(!zp(c))throw Error(u(200));if(null==a||void 0===a._reactInternals)throw Error(u(38));return Cp(a,b,c,!1,d)};exports.unstable_runWithPriority=Nb;exports.useFormState=ia;exports.useFormStatus=ha;
+exports.version="18.3.0-experimental-7508dcd5c-20231108";"undefined"!==typeof __REACT_DEVTOOLS_GLOBAL_HOOK__&&"function"===typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop&&__REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
 
-          /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
-if (
-  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
-  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
-    'function'
-) {
-  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
-}
-        
+//# sourceMappingURL=react-dom.profiling.min.js.map
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.shared-subset.production.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.shared-subset.production.js
new file mode 100644
index 0000000000000..1b81aca57e482
--- /dev/null
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.shared-subset.production.js
@@ -0,0 +1,164 @@
+/**
+ * @license React
+ * react-dom.shared-subset.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+const Internals = {
+  usingClientEntryPoint: false,
+  Events: null,
+  Dispatcher: {
+    current: null
+  }
+};
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+function getCrossOriginStringAs(as, input) {
+  if (as === 'font') {
+    return '';
+  }
+
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+const Dispatcher = Internals.Dispatcher;
+function prefetchDNS(href) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    dispatcher.prefetchDNS(href);
+  } // We don't error because preconnect needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preconnect(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    const crossOrigin = options ? getCrossOriginString(options.crossOrigin) : null;
+    dispatcher.preconnect(href, crossOrigin);
+  } // We don't error because preconnect needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preload(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string' && // We check existence because we cannot enforce this function is actually called with the stated type
+  typeof options === 'object' && options !== null && typeof options.as === 'string') {
+    const as = options.as;
+    const crossOrigin = getCrossOriginStringAs(as, options.crossOrigin);
+    dispatcher.preload(href, as, {
+      crossOrigin,
+      integrity: typeof options.integrity === 'string' ? options.integrity : undefined,
+      nonce: typeof options.nonce === 'string' ? options.nonce : undefined,
+      type: typeof options.type === 'string' ? options.type : undefined,
+      fetchPriority: typeof options.fetchPriority === 'string' ? options.fetchPriority : undefined,
+      referrerPolicy: typeof options.referrerPolicy === 'string' ? options.referrerPolicy : undefined,
+      imageSrcSet: typeof options.imageSrcSet === 'string' ? options.imageSrcSet : undefined,
+      imageSizes: typeof options.imageSizes === 'string' ? options.imageSizes : undefined
+    });
+  } // We don't error because preload needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preloadModule(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    if (options) {
+      const crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);
+      dispatcher.preloadModule(href, {
+        as: typeof options.as === 'string' && options.as !== 'script' ? options.as : undefined,
+        crossOrigin,
+        integrity: typeof options.integrity === 'string' ? options.integrity : undefined
+      });
+    } else {
+      dispatcher.preloadModule(href);
+    }
+  } // We don't error because preload needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preinit(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string' && options && typeof options.as === 'string') {
+    const as = options.as;
+    const crossOrigin = getCrossOriginStringAs(as, options.crossOrigin);
+    const integrity = typeof options.integrity === 'string' ? options.integrity : undefined;
+    const fetchPriority = typeof options.fetchPriority === 'string' ? options.fetchPriority : undefined;
+
+    if (as === 'style') {
+      dispatcher.preinitStyle(href, typeof options.precedence === 'string' ? options.precedence : undefined, {
+        crossOrigin,
+        integrity,
+        fetchPriority
+      });
+    } else if (as === 'script') {
+      dispatcher.preinitScript(href, {
+        crossOrigin,
+        integrity,
+        fetchPriority,
+        nonce: typeof options.nonce === 'string' ? options.nonce : undefined
+      });
+    }
+  } // We don't error because preinit needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preinitModule(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    if (typeof options === 'object' && options !== null) {
+      if (options.as == null || options.as === 'script') {
+        const crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);
+        dispatcher.preinitModuleScript(href, {
+          crossOrigin,
+          integrity: typeof options.integrity === 'string' ? options.integrity : undefined,
+          nonce: typeof options.nonce === 'string' ? options.nonce : undefined
+        });
+      }
+    } else if (options == null) {
+      dispatcher.preinitModuleScript(href);
+    }
+  } // We don't error because preinit needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+
+exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = Internals;
+exports.preconnect = preconnect;
+exports.prefetchDNS = prefetchDNS;
+exports.preinit = preinit;
+exports.preinitModule = preinitModule;
+exports.preload = preload;
+exports.preloadModule = preloadModule;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.shared-subset.production.min.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.shared-subset.production.min.js
index c784b4f423903..5000c6fc89faf 100644
--- a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.shared-subset.production.min.js
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom.shared-subset.production.min.js
@@ -1,15 +1,17 @@
-/**
- * @license React
- * react-dom.shared-subset.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-dom.shared-subset.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var e={usingClientEntryPoint:!1,Events:null,Dispatcher:{current:null}};function f(b,a){if("font"===b)return"";if("string"===typeof a)return"use-credentials"===a?a:""}var h=e.Dispatcher;exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=e;exports.preconnect=function(b,a){var c=h.current;c&&"string"===typeof b&&(a?(a=a.crossOrigin,a="string"===typeof a?"use-credentials"===a?a:"":void 0):a=null,c.preconnect(b,a))};
 exports.prefetchDNS=function(b){var a=h.current;a&&"string"===typeof b&&a.prefetchDNS(b)};
 exports.preinit=function(b,a){var c=h.current;if(c&&"string"===typeof b&&a&&"string"===typeof a.as){var d=a.as,g=f(d,a.crossOrigin),k="string"===typeof a.integrity?a.integrity:void 0,l="string"===typeof a.fetchPriority?a.fetchPriority:void 0;"style"===d?c.preinitStyle(b,"string"===typeof a.precedence?a.precedence:void 0,{crossOrigin:g,integrity:k,fetchPriority:l}):"script"===d&&c.preinitScript(b,{crossOrigin:g,integrity:k,fetchPriority:l,nonce:"string"===typeof a.nonce?a.nonce:void 0})}};
 exports.preinitModule=function(b,a){var c=h.current;if(c&&"string"===typeof b)if("object"===typeof a&&null!==a){if(null==a.as||"script"===a.as){var d=f(a.as,a.crossOrigin);c.preinitModuleScript(b,{crossOrigin:d,integrity:"string"===typeof a.integrity?a.integrity:void 0,nonce:"string"===typeof a.nonce?a.nonce:void 0})}}else null==a&&c.preinitModuleScript(b)};
 exports.preload=function(b,a){var c=h.current;if(c&&"string"===typeof b&&"object"===typeof a&&null!==a&&"string"===typeof a.as){var d=a.as,g=f(d,a.crossOrigin);c.preload(b,d,{crossOrigin:g,integrity:"string"===typeof a.integrity?a.integrity:void 0,nonce:"string"===typeof a.nonce?a.nonce:void 0,type:"string"===typeof a.type?a.type:void 0,fetchPriority:"string"===typeof a.fetchPriority?a.fetchPriority:void 0,referrerPolicy:"string"===typeof a.referrerPolicy?a.referrerPolicy:void 0,imageSrcSet:"string"===
 typeof a.imageSrcSet?a.imageSrcSet:void 0,imageSizes:"string"===typeof a.imageSizes?a.imageSizes:void 0})}};exports.preloadModule=function(b,a){var c=h.current;if(c&&"string"===typeof b)if(a){var d=f(a.as,a.crossOrigin);c.preloadModule(b,{as:"string"===typeof a.as&&"script"!==a.as?a.as:void 0,crossOrigin:d,integrity:"string"===typeof a.integrity?a.integrity:void 0})}else c.preloadModule(b)};
+
+//# sourceMappingURL=react-dom.shared-subset.production.min.js.map
diff --git a/packages/next/src/compiled/react-dom-experimental/package.json b/packages/next/src/compiled/react-dom-experimental/package.json
index e83c125072d79..cd26b734e9b27 100644
--- a/packages/next/src/compiled/react-dom-experimental/package.json
+++ b/packages/next/src/compiled/react-dom-experimental/package.json
@@ -42,10 +42,10 @@
   },
   "dependencies": {
     "loose-envify": "^1.1.0",
-    "scheduler": "0.0.0-experimental-2983249dd-20231107"
+    "scheduler": "0.0.0-experimental-7508dcd5c-20231108"
   },
   "peerDependencies": {
-    "react": "0.0.0-experimental-2983249dd-20231107"
+    "react": "0.0.0-experimental-7508dcd5c-20231108"
   },
   "browser": {
     "./server.js": "./server.browser.js",
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.browser.development.js b/packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.browser.development.js
index 593c558b9ce01..299827f72afbf 100644
--- a/packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.browser.development.js
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.browser.development.js
@@ -17,7 +17,7 @@ if (process.env.NODE_ENV !== "production") {
 var React = require("next/dist/compiled/react");
 var ReactDOM = require('react-dom');
 
-var ReactVersion = '18.3.0-canary-2983249dd-20231107';
+var ReactVersion = '18.3.0-canary-7508dcd5c-20231108';
 
 var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
 
@@ -1729,11 +1729,14 @@ var DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS = 2000; // Allows us to keep tr
 // if passed externalRuntimeConfig and the enableFizzExternalRuntime feature flag
 // is set, the server will send instructions via data attributes (instead of inline scripts)
 
-function createRenderState$1(resumableState, nonce, bootstrapScriptContent, bootstrapScripts, bootstrapModules, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
+function createRenderState$1(resumableState, nonce, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
   var inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
   var idPrefix = resumableState.idPrefix;
   var bootstrapChunks = [];
   var externalRuntimeScript = null;
+  var bootstrapScriptContent = resumableState.bootstrapScriptContent,
+      bootstrapScripts = resumableState.bootstrapScripts,
+      bootstrapModules = resumableState.bootstrapModules;
 
   if (bootstrapScriptContent !== undefined) {
     bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapAndImportMapScriptContent(bootstrapScriptContent)), endInlineScript);
@@ -1922,7 +1925,7 @@ function createRenderState$1(resumableState, nonce, bootstrapScriptContent, boot
 
   return renderState;
 }
-function createResumableState(identifierPrefix, externalRuntimeConfig) {
+function createResumableState(identifierPrefix, externalRuntimeConfig, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
   var idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
   var streamingFormat = ScriptStreamingFormat;
 
@@ -1936,6 +1939,9 @@ function createResumableState(identifierPrefix, externalRuntimeConfig) {
     idPrefix: idPrefix,
     nextFormID: 0,
     streamingFormat: streamingFormat,
+    bootstrapScriptContent: bootstrapScriptContent,
+    bootstrapScripts: bootstrapScripts,
+    bootstrapModules: bootstrapModules,
     instructions: NothingSent,
     hasBody: false,
     hasHtml: false,
@@ -4373,7 +4379,10 @@ function pushEndInstance(target, type, props, resumableState, formatContext) {
   target.push(endChunkForTag(type));
 }
 
-function writeBootstrap(destination, renderState) {
+function writeBootstrap(destination, renderState, resumableState) {
+  resumableState.bootstrapScriptContent = undefined;
+  resumableState.bootstrapScripts = undefined;
+  resumableState.bootstrapModules = undefined;
   var bootstrapChunks = renderState.bootstrapChunks;
   var i = 0;
 
@@ -4390,8 +4399,8 @@ function writeBootstrap(destination, renderState) {
   return true;
 }
 
-function writeCompletedRoot(destination, renderState) {
-  return writeBootstrap(destination, renderState);
+function writeCompletedRoot(destination, renderState, resumableState) {
+  return writeBootstrap(destination, renderState, resumableState);
 } // Structural Nodes
 // A placeholder is a node inside a hidden partial tree that can be filled in later, but before
 // display. It's never visible to users. We use the template tag because it can be used in every
@@ -4748,7 +4757,7 @@ function writeCompletedBoundaryInstruction(destination, resumableState, renderSt
     writeMore = writeChunkAndReturn(destination, completeBoundaryDataEnd);
   }
 
-  return writeBootstrap(destination, renderState) && writeMore;
+  return writeBootstrap(destination, renderState, resumableState) && writeMore;
 }
 var clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
 var clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
@@ -6484,7 +6493,7 @@ function emitEarlyPreloads(renderState, resumableState, shellComplete) {
 }
 
 function createRenderState(resumableState, generateStaticMarkup) {
-  var renderState = createRenderState$1(resumableState, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+  var renderState = createRenderState$1(resumableState, undefined, undefined, undefined, undefined, undefined);
   return {
     // Keep this in sync with ReactFizzConfigDOM
     placeholderPrefix: renderState.placeholderPrefix,
@@ -6832,6 +6841,18 @@ var componentFrameCache;
   var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
   componentFrameCache = new PossiblyWeakMap();
 }
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
@@ -6847,7 +6868,6 @@ function describeNativeComponentFrame(fn, construct) {
     }
   }
 
-  var control;
   reentry = true;
   var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
 
@@ -6861,81 +6881,140 @@ function describeNativeComponentFrame(fn, construct) {
     ReactCurrentDispatcher$1.current = null;
     disableLogs();
   }
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
 
-  try {
-    // This should throw.
-    if (construct) {
-      // Something should be setting the props in the constructor.
-      var Fake = function () {
-        throw Error();
-      }; // $FlowFixMe[prop-missing]
 
+  var RunInRootFrame = {
+    DetermineComponentFrameRoot: function () {
+      var control;
 
-      Object.defineProperty(Fake.prototype, 'props', {
-        set: function () {
-          // We use a throwing setter instead of frozen or non-writable props
-          // because that won't throw in a non-strict mode function.
-          throw Error();
-        }
-      });
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          var Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
 
-      if (typeof Reflect === 'object' && Reflect.construct) {
-        // We construct a different control for this case to include any extra
-        // frames added by the construct call.
-        try {
-          Reflect.construct(Fake, []);
-        } catch (x) {
-          control = x;
-        }
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
 
-        Reflect.construct(fn, [], Fake);
-      } else {
-        try {
-          Fake.call();
-        } catch (x) {
-          control = x;
-        } // $FlowFixMe[prop-missing] found when upgrading Flow
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
 
 
-        fn.call(Fake.prototype);
-      }
-    } else {
-      try {
-        throw Error();
-      } catch (x) {
-        control = x;
-      } // TODO(luna): This will currently only throw if the function component
-      // tries to access React/ReactDOM/props. We should probably make this throw
-      // in simple components too
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
 
 
-      var maybePromise = fn(); // If the function component returns a promise, it's likely an async
-      // component, which we don't yet support. Attach a noop catch handler to
-      // silence the error.
-      // TODO: Implement component stacks for async client components?
+          var maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
 
-      if (maybePromise && typeof maybePromise.catch === 'function') {
-        maybePromise.catch(function () {});
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(function () {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
       }
+
+      return [null, null];
     }
-  } catch (sample) {
-    // This is inlined manually because closure doesn't do it for us.
-    if (sample && control && typeof sample.stack === 'string') {
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
+
+  try {
+    var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
+
+    if (sampleStack && controlStack) {
       // This extracts the first frame from the sample that isn't also in the control.
       // Skipping one frame that we assume is the frame that calls the two.
-      var sampleLines = sample.stack.split('\n');
-      var controlLines = control.stack.split('\n');
-      var s = sampleLines.length - 1;
-      var c = controlLines.length - 1;
-
-      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
-        // We expect at least one stack frame to be shared.
-        // Typically this will be the root most one. However, stack frames may be
-        // cut off due to maximum stack limits. In this case, one maybe cut off
-        // earlier than the other. We assume that the sample is longer or the same
-        // and there for cut off earlier. So we should find the root most frame in
-        // the sample somewhere in the control.
-        c--;
+      var sampleLines = sampleStack.split('\n');
+      var controlLines = controlStack.split('\n');
+      var s = 0;
+      var c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
       }
 
       for (; s >= 1 && c >= 0; s--, c--) {
@@ -6964,7 +7043,7 @@ function describeNativeComponentFrame(fn, construct) {
                   _frame = _frame.replace('<anonymous>', fn.displayName);
                 }
 
-                {
+                if (true) {
                   if (typeof fn === 'function') {
                     componentFrameCache.set(fn, _frame);
                   }
@@ -11338,7 +11417,7 @@ function flushCompletedQueues(request, destination) {
 
         flushSegment(request, destination, completedRootSegment);
         request.completedRootSegment = null;
-        writeCompletedRoot(destination, request.renderState);
+        writeCompletedRoot(destination, request.renderState, request.resumableState);
       } else {
         // We haven't flushed the root yet so we don't need to check any other branches further down
         return;
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.browser.production.js b/packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.browser.production.js
new file mode 100644
index 0000000000000..8cf001d84b992
--- /dev/null
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.browser.production.js
@@ -0,0 +1,8626 @@
+/**
+ * @license React
+ * react-dom-server-legacy.browser.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require("next/dist/compiled/react");
+var ReactDOM = require('react-dom');
+
+// Do not require this module directly! Use normal `invariant` calls with
+// template literal strings. The messages will be replaced with error codes
+// during build.
+function formatProdErrorMessage(code) {
+  let url = 'https://reactjs.org/docs/error-decoder.html?invariant=' + code;
+
+  for (let i = 1; i < arguments.length; i++) {
+    url += '&args[]=' + encodeURIComponent(arguments[i]);
+  }
+
+  return "Minified React error #" + code + "; visit " + url + " for the full message or " + 'use the non-minified dev environment for full errors and additional ' + 'helpful warnings.';
+}
+
+var ReactVersion = '18.3.0-canary-7508dcd5c-20231108';
+
+// A pure JS implementation of a string hashing function. We do not use it for
+// security or obfuscation purposes, only to create compact hashes. So we
+// prioritize speed over collision avoidance. For example, we use this to hash
+// the component key path used by useFormState for MPA-style submissions.
+//
+// In environments where built-in hashing functions are available, we prefer
+// those instead. Like Node's crypto module, or Bun.hash. Unfortunately this
+// does not include the web standard crypto API because those methods are all
+// async. For our purposes, we need it to be sync because the cost of context
+// switching is too high to be worth it.
+//
+// The most popular hashing algorithm that meets these requirements in the JS
+// ecosystem is MurmurHash3, and almost all implementations I could find used
+// some version of the implementation by Gary Court inlined below.
+function createFastHashJS(key) {
+  return murmurhash3_32_gc(key, 0);
+}
+/* eslint-disable prefer-const, no-fallthrough */
+
+/**
+ * @license
+ *
+ * JS Implementation of MurmurHash3 (r136) (as of May 20, 2011)
+ *
+ * Copyright (c) 2011 Gary Court
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+function murmurhash3_32_gc(key, seed) {
+  let remainder, bytes, h1, h1b, c1, c2, k1, i;
+  remainder = key.length & 3; // key.length % 4
+
+  bytes = key.length - remainder;
+  h1 = seed;
+  c1 = 0xcc9e2d51;
+  c2 = 0x1b873593;
+  i = 0;
+
+  while (i < bytes) {
+    k1 = key.charCodeAt(i) & 0xff | (key.charCodeAt(++i) & 0xff) << 8 | (key.charCodeAt(++i) & 0xff) << 16 | (key.charCodeAt(++i) & 0xff) << 24;
+    ++i;
+    k1 = (k1 & 0xffff) * c1 + (((k1 >>> 16) * c1 & 0xffff) << 16) & 0xffffffff;
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = (k1 & 0xffff) * c2 + (((k1 >>> 16) * c2 & 0xffff) << 16) & 0xffffffff;
+    h1 ^= k1;
+    h1 = h1 << 13 | h1 >>> 19;
+    h1b = (h1 & 0xffff) * 5 + (((h1 >>> 16) * 5 & 0xffff) << 16) & 0xffffffff;
+    h1 = (h1b & 0xffff) + 0x6b64 + (((h1b >>> 16) + 0xe654 & 0xffff) << 16);
+  }
+
+  k1 = 0;
+
+  switch (remainder) {
+    case 3:
+      k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
+
+    case 2:
+      k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
+
+    case 1:
+      k1 ^= key.charCodeAt(i) & 0xff;
+      k1 = (k1 & 0xffff) * c1 + (((k1 >>> 16) * c1 & 0xffff) << 16) & 0xffffffff;
+      k1 = k1 << 15 | k1 >>> 17;
+      k1 = (k1 & 0xffff) * c2 + (((k1 >>> 16) * c2 & 0xffff) << 16) & 0xffffffff;
+      h1 ^= k1;
+  }
+
+  h1 ^= key.length;
+  h1 ^= h1 >>> 16;
+  h1 = (h1 & 0xffff) * 0x85ebca6b + (((h1 >>> 16) * 0x85ebca6b & 0xffff) << 16) & 0xffffffff;
+  h1 ^= h1 >>> 13;
+  h1 = (h1 & 0xffff) * 0xc2b2ae35 + (((h1 >>> 16) * 0xc2b2ae35 & 0xffff) << 16) & 0xffffffff;
+  h1 ^= h1 >>> 16;
+  return h1 >>> 0;
+}
+
+function scheduleWork(callback) {
+  callback();
+}
+function beginWriting(destination) {}
+function writeChunk(destination, chunk) {
+  writeChunkAndReturn(destination, chunk);
+}
+function writeChunkAndReturn(destination, chunk) {
+  return destination.push(chunk);
+}
+function completeWriting(destination) {}
+function close(destination) {
+  destination.push(null);
+}
+function stringToChunk(content) {
+  return content;
+}
+function stringToPrecomputedChunk(content) {
+  return content;
+}
+function clonePrecomputedChunk(chunk) {
+  return chunk;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+  destination.destroy(error);
+}
+
+const assign = Object.assign;
+
+// -----------------------------------------------------------------------------
+const enableFloat = true; // Enables unstable_useMemoCache hook, intended as a compilation target for
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/* eslint-disable max-len */
+
+const ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
+/* eslint-enable max-len */
+
+const ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
+const VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+const illegalAttributeNameCache = {};
+const validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+  if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+    return true;
+  }
+
+  if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+    return false;
+  }
+
+  if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+    validatedAttributeNameCache[attributeName] = true;
+    return true;
+  }
+
+  illegalAttributeNameCache[attributeName] = true;
+
+  return false;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+const unitlessNumbers = new Set(['animationIterationCount', 'aspectRatio', 'borderImageOutset', 'borderImageSlice', 'borderImageWidth', 'boxFlex', 'boxFlexGroup', 'boxOrdinalGroup', 'columnCount', 'columns', 'flex', 'flexGrow', 'flexPositive', 'flexShrink', 'flexNegative', 'flexOrder', 'gridArea', 'gridRow', 'gridRowEnd', 'gridRowSpan', 'gridRowStart', 'gridColumn', 'gridColumnEnd', 'gridColumnSpan', 'gridColumnStart', 'fontWeight', 'lineClamp', 'lineHeight', 'opacity', 'order', 'orphans', 'scale', 'tabSize', 'widows', 'zIndex', 'zoom', 'fillOpacity', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'MozBoxFlexGroup', 'MozLineClamp', 'msAnimationIterationCount', 'msFlex', 'msZoom', 'msFlexGrow', 'msFlexNegative', 'msFlexOrder', 'msFlexPositive', 'msFlexShrink', 'msGridColumn', 'msGridColumnSpan', 'msGridRow', 'msGridRowSpan', 'WebkitAnimationIterationCount', 'WebkitBoxFlex', 'WebKitBoxFlexGroup', 'WebkitBoxOrdinalGroup', 'WebkitColumnCount', 'WebkitColumns', 'WebkitFlex', 'WebkitFlexGrow', 'WebkitFlexPositive', 'WebkitFlexShrink', 'WebkitLineClamp']);
+function isUnitlessNumber (name) {
+  return unitlessNumbers.has(name);
+}
+
+const aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+  return aliases.get(name) || name;
+}
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// code copied and modified from escape-html
+const matchHtmlRegExp = /["'&<>]/;
+/**
+ * Escapes special characters and HTML entities in a given html string.
+ *
+ * @param  {string} string HTML string to escape for later insertion
+ * @return {string}
+ * @public
+ */
+
+function escapeHtml(string) {
+
+  const str = '' + string;
+  const match = matchHtmlRegExp.exec(str);
+
+  if (!match) {
+    return str;
+  }
+
+  let escape;
+  let html = '';
+  let index;
+  let lastIndex = 0;
+
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        // "
+        escape = '&quot;';
+        break;
+
+      case 38:
+        // &
+        escape = '&amp;';
+        break;
+
+      case 39:
+        // '
+        escape = '&#x27;'; // modified from escape-html; used to be '&#39'
+
+        break;
+
+      case 60:
+        // <
+        escape = '&lt;';
+        break;
+
+      case 62:
+        // >
+        escape = '&gt;';
+        break;
+
+      default:
+        continue;
+    }
+
+    if (lastIndex !== index) {
+      html += str.slice(lastIndex, index);
+    }
+
+    lastIndex = index + 1;
+    html += escape;
+  }
+
+  return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+} // end code copied and modified from escape-html
+
+/**
+ * Escapes text to prevent scripting attacks.
+ *
+ * @param {*} text Text value to escape.
+ * @return {string} An escaped string.
+ */
+
+
+function escapeTextForBrowser(text) {
+  if (typeof text === 'boolean' || typeof text === 'number') {
+    // this shortcircuit helps perf for types that we know will never have
+    // special characters, especially given that this function is used often
+    // for numeric dom ids.
+    return '' + text;
+  }
+
+  return escapeHtml(text);
+}
+
+const uppercasePattern = /([A-Z])/g;
+const msPattern = /^ms-/;
+/**
+ * Hyphenates a camelcased CSS property name, for example:
+ *
+ *   > hyphenateStyleName('backgroundColor')
+ *   < "background-color"
+ *   > hyphenateStyleName('MozTransition')
+ *   < "-moz-transition"
+ *   > hyphenateStyleName('msTransition')
+ *   < "-ms-transition"
+ *
+ * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
+ * is converted to `-ms-`.
+ */
+
+function hyphenateStyleName(name) {
+  return name.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern, '-ms-');
+}
+
+function sanitizeURL(url) {
+
+  return url;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+// The build script is at scripts/rollup/generate-inline-fizz-runtime.js.
+// Run `yarn generate-inline-fizz-runtime` to generate.
+const clientRenderBoundary = '$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};';
+const completeBoundary = '$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};';
+const completeBoundaryWithStyles = '$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};';
+const completeSegment = '$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};';
+const formReplaying = 'addEventListener("submit",function(a){if(!a.defaultPrevented){var c=a.target,d=a.submitter,e=c.action,b=d;if(d){var f=d.getAttribute("formAction");null!=f&&(e=f,b=null)}"javascript:throw new Error(\'A React form was unexpectedly submitted.\')"===e&&(a.preventDefault(),b?(a=document.createElement("input"),a.name=b.name,a.value=b.value,b.parentNode.insertBefore(a,b),b=new FormData(c),a.parentNode.removeChild(a)):b=new FormData(c),a=c.getRootNode(),(a.$$reactFormReplay=a.$$reactFormReplay||[]).push(c,\nd,b))}});';
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+// same object across all transitions.
+
+const sharedNotPendingObject = {
+  pending: false,
+  data: null,
+  method: null,
+  action: null
+};
+const NotPending = sharedNotPendingObject;
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+const ReactDOMServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMServerDispatcher;
+} // We make every property of the descriptor optional because it is not a contract that
+const ScriptStreamingFormat = 0;
+const DataStreamingFormat = 1;
+const NothingSent
+/*                      */
+= 0b00000;
+const SentCompleteSegmentFunction
+/*      */
+= 0b00001;
+const SentCompleteBoundaryFunction
+/*     */
+= 0b00010;
+const SentClientRenderFunction
+/*         */
+= 0b00100;
+const SentStyleInsertionFunction
+/*       */
+= 0b01000;
+const SentFormReplayingRuntime
+/*         */
+= 0b10000; // Per request, global state that is not contextual to the rendering subtree.
+// This cannot be resumed and therefore should only contain things that are
+// temporary working state or are never used in the prerender pass.
+// Credentials here are things that affect whether a browser will make a request
+// as well as things that affect which connection the browser will use for that request.
+// We want these to be aligned across preloads and resources because otherwise the preload
+// will be wasted.
+// We investigated whether referrerPolicy should be included here but from experimentation
+// it seems that browsers do not treat this as part of the http cache key and does not affect
+// which connection is used.
+
+const EXISTS = null; // This constant is to mark preloads that have no unique credentials
+// to convey. It should never be checked by identity and we should not
+// assume Preload values in ResumableState equal this value because they
+// will have come from some parsed input.
+
+const PRELOAD_NO_CREDS = [];
+// This is resumable and therefore should be serializable.
+
+
+const dataElementQuotedEnd = stringToPrecomputedChunk('"></template>');
+const startInlineScript = stringToPrecomputedChunk('<script>');
+const endInlineScript = stringToPrecomputedChunk('</script>');
+const startScriptSrc = stringToPrecomputedChunk('<script src="');
+const startModuleSrc = stringToPrecomputedChunk('<script type="module" src="');
+const scriptNonce = stringToPrecomputedChunk('" nonce="');
+const scriptIntegirty = stringToPrecomputedChunk('" integrity="');
+const scriptCrossOrigin = stringToPrecomputedChunk('" crossorigin="');
+const endAsyncScript = stringToPrecomputedChunk('" async=""></script>');
+/**
+ * This escaping function is designed to work with bootstrapScriptContent and importMap only.
+ * because we know we are escaping the entire script. We can avoid for instance
+ * escaping html comment string sequences that are valid javascript as well because
+ * if there are no sebsequent <script sequences the html parser will never enter
+ * script data double escaped state (see: https://www.w3.org/TR/html53/syntax.html#script-data-double-escaped-state)
+ *
+ * While untrusted script content should be made safe before using this api it will
+ * ensure that the script cannot be early terminated or never terminated state
+ */
+
+function escapeBootstrapAndImportMapScriptContent(scriptText) {
+
+  return ('' + scriptText).replace(scriptRegex, scriptReplacer);
+}
+
+const scriptRegex = /(<\/|<)(s)(cript)/gi;
+
+const scriptReplacer = (match, prefix, s, suffix) => "" + prefix + (s === 's' ? '\\u0073' : '\\u0053') + suffix;
+
+const importMapScriptStart = stringToPrecomputedChunk('<script type="importmap">');
+const importMapScriptEnd = stringToPrecomputedChunk('</script>'); // Since we store headers as strings we deal with their length in utf16 code units
+// rather than visual characters or the utf8 encoding that is used for most binary
+// serialization. Some common HTTP servers only allow for headers to be 4kB in length.
+// We choose a default length that is likely to be well under this already limited length however
+// pathological cases may still cause the utf-8 encoding of the headers to approach this limit.
+// It should also be noted that this maximum is a soft maximum. we have not reached the limit we will
+// allow one more header to be captured which means in practice if the limit is approached it will be exceeded
+
+const DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS = 2000; // Allows us to keep track of what we've already written so we can refer back to it.
+// if passed externalRuntimeConfig and the enableFizzExternalRuntime feature flag
+// is set, the server will send instructions via data attributes (instead of inline scripts)
+
+function createRenderState$1(resumableState, nonce, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
+  const inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
+  const idPrefix = resumableState.idPrefix;
+  const bootstrapChunks = [];
+  let externalRuntimeScript = null;
+  const bootstrapScriptContent = resumableState.bootstrapScriptContent,
+        bootstrapScripts = resumableState.bootstrapScripts,
+        bootstrapModules = resumableState.bootstrapModules;
+
+  if (bootstrapScriptContent !== undefined) {
+    bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapAndImportMapScriptContent(bootstrapScriptContent)), endInlineScript);
+  }
+
+  {
+
+    if (externalRuntimeConfig !== undefined) {
+      if (typeof externalRuntimeConfig === 'string') {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig,
+          async: true,
+          integrity: undefined,
+          nonce: nonce
+        });
+      } else {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig.src,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig.src,
+          async: true,
+          integrity: externalRuntimeConfig.integrity,
+          nonce: nonce
+        });
+      }
+    }
+  }
+
+  const importMapChunks = [];
+
+  if (importMap !== undefined) {
+    const map = importMap;
+    importMapChunks.push(importMapScriptStart);
+    importMapChunks.push(stringToChunk(escapeBootstrapAndImportMapScriptContent(JSON.stringify(map))));
+    importMapChunks.push(importMapScriptEnd);
+  }
+
+  const headers = onHeaders ? {
+    preconnects: '',
+    fontPreloads: '',
+    highImagePreloads: '',
+    remainingCapacity: typeof maxHeadersLength === 'number' ? maxHeadersLength : DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS
+  } : null;
+  const renderState = {
+    placeholderPrefix: stringToPrecomputedChunk(idPrefix + 'P:'),
+    segmentPrefix: stringToPrecomputedChunk(idPrefix + 'S:'),
+    boundaryPrefix: stringToPrecomputedChunk(idPrefix + 'B:'),
+    startInlineScript: inlineScriptWithNonce,
+    htmlChunks: null,
+    headChunks: null,
+    externalRuntimeScript: externalRuntimeScript,
+    bootstrapChunks: bootstrapChunks,
+    onHeaders,
+    headers,
+    resets: {
+      font: {},
+      dns: {},
+      connect: {
+        default: {},
+        anonymous: {},
+        credentials: {}
+      },
+      image: {},
+      style: {}
+    },
+    charsetChunks: [],
+    preconnectChunks: [],
+    importMapChunks,
+    preloadChunks: [],
+    hoistableChunks: [],
+    // cleared on flush
+    preconnects: new Set(),
+    fontPreloads: new Set(),
+    highImagePreloads: new Set(),
+    // usedImagePreloads: new Set(),
+    styles: new Map(),
+    bootstrapScripts: new Set(),
+    scripts: new Set(),
+    bulkPreloads: new Set(),
+    preloads: {
+      images: new Map(),
+      stylesheets: new Map(),
+      scripts: new Map(),
+      moduleScripts: new Map()
+    },
+    nonce,
+    // like a module global for currently rendering boundary
+    boundaryResources: null,
+    stylesToHoist: false
+  };
+
+  if (bootstrapScripts !== undefined) {
+    for (let i = 0; i < bootstrapScripts.length; i++) {
+      const scriptConfig = bootstrapScripts[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'preload',
+        as: 'script',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startScriptSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  if (bootstrapModules !== undefined) {
+    for (let i = 0; i < bootstrapModules.length; i++) {
+      const scriptConfig = bootstrapModules[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'modulepreload',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startModuleSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  return renderState;
+}
+function createResumableState(identifierPrefix, externalRuntimeConfig, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
+  const idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
+  let streamingFormat = ScriptStreamingFormat;
+
+  {
+    if (externalRuntimeConfig !== undefined) {
+      streamingFormat = DataStreamingFormat;
+    }
+  }
+
+  return {
+    idPrefix: idPrefix,
+    nextFormID: 0,
+    streamingFormat,
+    bootstrapScriptContent,
+    bootstrapScripts,
+    bootstrapModules,
+    instructions: NothingSent,
+    hasBody: false,
+    hasHtml: false,
+    // @TODO add bootstrap script to implicit preloads
+    // persistent
+    unknownResources: {},
+    dnsResources: {},
+    connectResources: {
+      default: {},
+      anonymous: {},
+      credentials: {}
+    },
+    imageResources: {},
+    styleResources: {},
+    scriptResources: {},
+    moduleUnknownResources: {},
+    moduleScriptResources: {}
+  };
+}
+// modes. We only include the variants as they matter for the sake of our purposes.
+// We don't actually provide the namespace therefore we use constants instead of the string.
+
+const ROOT_HTML_MODE = 0; // Used for the root most element tag.
+// We have a less than HTML_HTML_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const HTML_HTML_MODE = 1; // Used for the <html> if it is at the top level.
+
+const HTML_MODE = 2;
+const SVG_MODE = 3;
+const MATHML_MODE = 4;
+const HTML_TABLE_MODE = 5;
+const HTML_TABLE_BODY_MODE = 6;
+const HTML_TABLE_ROW_MODE = 7;
+const HTML_COLGROUP_MODE = 8; // We have a greater than HTML_TABLE_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const NO_SCOPE =
+/*         */
+0b00;
+const NOSCRIPT_SCOPE =
+/*   */
+0b01;
+const PICTURE_SCOPE =
+/*    */
+0b10; // Lets us keep track of contextual state and pick it back up after suspending.
+
+function createFormatContext(insertionMode, selectedValue, tagScope) {
+  return {
+    insertionMode,
+    selectedValue,
+    tagScope
+  };
+}
+
+function createRootFormatContext(namespaceURI) {
+  const insertionMode = namespaceURI === 'http://www.w3.org/2000/svg' ? SVG_MODE : namespaceURI === 'http://www.w3.org/1998/Math/MathML' ? MATHML_MODE : ROOT_HTML_MODE;
+  return createFormatContext(insertionMode, null, NO_SCOPE);
+}
+function getChildFormatContext(parentContext, type, props) {
+  switch (type) {
+    case 'noscript':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | NOSCRIPT_SCOPE);
+
+    case 'select':
+      return createFormatContext(HTML_MODE, props.value != null ? props.value : props.defaultValue, parentContext.tagScope);
+
+    case 'svg':
+      return createFormatContext(SVG_MODE, null, parentContext.tagScope);
+
+    case 'picture':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | PICTURE_SCOPE);
+
+    case 'math':
+      return createFormatContext(MATHML_MODE, null, parentContext.tagScope);
+
+    case 'foreignObject':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    // Table parents are special in that their children can only be created at all if they're
+    // wrapped in a table parent. So we need to encode that we're entering this mode.
+
+    case 'table':
+      return createFormatContext(HTML_TABLE_MODE, null, parentContext.tagScope);
+
+    case 'thead':
+    case 'tbody':
+    case 'tfoot':
+      return createFormatContext(HTML_TABLE_BODY_MODE, null, parentContext.tagScope);
+
+    case 'colgroup':
+      return createFormatContext(HTML_COLGROUP_MODE, null, parentContext.tagScope);
+
+    case 'tr':
+      return createFormatContext(HTML_TABLE_ROW_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode >= HTML_TABLE_MODE) {
+    // Whatever tag this was, it wasn't a table parent or other special parent, so we must have
+    // entered plain HTML again.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode === ROOT_HTML_MODE) {
+    if (type === 'html') {
+      // We've emitted the root and is now in <html> mode.
+      return createFormatContext(HTML_HTML_MODE, null, parentContext.tagScope);
+    } else {
+      // We've emitted the root and is now in plain HTML mode.
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    }
+  } else if (parentContext.insertionMode === HTML_HTML_MODE) {
+    // We've emitted the document element and is now in plain HTML mode.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  return parentContext;
+}
+function makeId(resumableState, treeId, localId) {
+  const idPrefix = resumableState.idPrefix;
+  let id = ':' + idPrefix + 'R' + treeId; // Unless this is the first id at this level, append a number at the end
+  // that represents the position of this useId hook among all the useId
+  // hooks for this fiber.
+
+  if (localId > 0) {
+    id += 'H' + localId.toString(32);
+  }
+
+  return id + ':';
+}
+
+function encodeHTMLTextNode(text) {
+  return escapeTextForBrowser(text);
+}
+
+const textSeparator = stringToPrecomputedChunk('<!-- -->');
+function pushTextInstance$1(target, text, renderState, textEmbedded) {
+  if (text === '') {
+    // Empty text doesn't have a DOM node representation and the hydration is aware of this.
+    return textEmbedded;
+  }
+
+  if (textEmbedded) {
+    target.push(textSeparator);
+  }
+
+  target.push(stringToChunk(encodeHTMLTextNode(text)));
+  return true;
+} // Called when Fizz is done with a Segment. Currently the only purpose is to conditionally
+// emit a text separator when we don't know for sure it is safe to omit
+
+function pushSegmentFinale$1(target, renderState, lastPushedText, textEmbedded) {
+  if (lastPushedText && textEmbedded) {
+    target.push(textSeparator);
+  }
+}
+const styleNameCache = new Map();
+
+function processStyleName(styleName) {
+  const chunk = styleNameCache.get(styleName);
+
+  if (chunk !== undefined) {
+    return chunk;
+  }
+
+  const result = stringToPrecomputedChunk(escapeTextForBrowser(hyphenateStyleName(styleName)));
+  styleNameCache.set(styleName, result);
+  return result;
+}
+
+const styleAttributeStart = stringToPrecomputedChunk(' style="');
+const styleAssign = stringToPrecomputedChunk(':');
+const styleSeparator = stringToPrecomputedChunk(';');
+
+function pushStyleAttribute(target, style) {
+  if (typeof style !== 'object') {
+    throw Error(formatProdErrorMessage(62));
+  }
+
+  let isFirst = true;
+
+  for (const styleName in style) {
+    if (!hasOwnProperty.call(style, styleName)) {
+      continue;
+    } // If you provide unsafe user data here they can inject arbitrary CSS
+    // which may be problematic (I couldn't repro this):
+    // https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet
+    // http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/
+    // This is not an XSS hole but instead a potential CSS injection issue
+    // which has lead to a greater discussion about how we're going to
+    // trust URLs moving forward. See #2115901
+
+
+    const styleValue = style[styleName];
+
+    if (styleValue == null || typeof styleValue === 'boolean' || styleValue === '') {
+      // TODO: We used to set empty string as a style with an empty value. Does that ever make sense?
+      continue;
+    }
+
+    let nameChunk;
+    let valueChunk;
+    const isCustomProperty = styleName.indexOf('--') === 0;
+
+    if (isCustomProperty) {
+      nameChunk = stringToChunk(escapeTextForBrowser(styleName));
+
+      valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+    } else {
+
+      nameChunk = processStyleName(styleName);
+
+      if (typeof styleValue === 'number') {
+        if (styleValue !== 0 && !isUnitlessNumber(styleName)) {
+          valueChunk = stringToChunk(styleValue + 'px'); // Presumes implicit 'px' suffix for unitless numbers
+        } else {
+          valueChunk = stringToChunk('' + styleValue);
+        }
+      } else {
+
+        valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+      }
+    }
+
+    if (isFirst) {
+      isFirst = false; // If it's first, we don't need any separators prefixed.
+
+      target.push(styleAttributeStart, nameChunk, styleAssign, valueChunk);
+    } else {
+      target.push(styleSeparator, nameChunk, styleAssign, valueChunk);
+    }
+  }
+
+  if (!isFirst) {
+    target.push(attributeEnd);
+  }
+}
+
+const attributeSeparator = stringToPrecomputedChunk(' ');
+const attributeAssign = stringToPrecomputedChunk('="');
+const attributeEnd = stringToPrecomputedChunk('"');
+const attributeEmptyString = stringToPrecomputedChunk('=""');
+
+function pushBooleanAttribute(target, name, value) // not null or undefined
+{
+  if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+    target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+  }
+}
+
+function pushStringAttribute(target, name, value) // not null or undefined
+{
+  if (typeof value !== 'function' && typeof value !== 'symbol' && typeof value !== 'boolean') {
+    target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+  }
+}
+
+function makeFormFieldPrefix(resumableState) {
+  const id = resumableState.nextFormID++;
+  return resumableState.idPrefix + id;
+} // Since this will likely be repeated a lot in the HTML, we use a more concise message
+// than on the client and hopefully it's googleable.
+
+
+const actionJavaScriptURL = stringToPrecomputedChunk(escapeTextForBrowser( // eslint-disable-next-line no-script-url
+"javascript:throw new Error('A React form was unexpectedly submitted.')"));
+const startHiddenInputChunk = stringToPrecomputedChunk('<input type="hidden"');
+
+function pushAdditionalFormField(value, key) {
+  const target = this;
+  target.push(startHiddenInputChunk);
+
+  if (typeof value !== 'string') {
+    throw Error(formatProdErrorMessage(480));
+  }
+
+  pushStringAttribute(target, 'name', key);
+  pushStringAttribute(target, 'value', value);
+  target.push(endOfStartTagSelfClosing);
+}
+
+function pushAdditionalFormFields(target, formData) {
+  if (formData !== null) {
+    // $FlowFixMe[prop-missing]: FormData has forEach.
+    formData.forEach(pushAdditionalFormField, target);
+  }
+}
+
+function pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name) {
+  let formData = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      name = customFields.name;
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('formAction'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      name = null;
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (name != null) {
+    pushAttribute(target, 'name', name);
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'formAction', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'formEncType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'formMethod', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'formTarget', formTarget);
+  }
+
+  return formData;
+}
+
+function pushAttribute(target, name, value) // not null or undefined
+{
+  switch (name) {
+    // These are very common props and therefore are in the beginning of the switch.
+    // TODO: aria-label is a very common prop but allows booleans so is not like the others
+    // but should ideally go in this list too.
+    case 'className':
+      {
+        pushStringAttribute(target, 'class', value);
+        break;
+      }
+
+    case 'tabIndex':
+      {
+        pushStringAttribute(target, 'tabindex', value);
+        break;
+      }
+
+    case 'dir':
+    case 'role':
+    case 'viewBox':
+    case 'width':
+    case 'height':
+      {
+        pushStringAttribute(target, name, value);
+        break;
+      }
+
+    case 'style':
+      {
+        pushStyleAttribute(target, value);
+        return;
+      }
+
+    case 'src':
+    case 'href':
+    // Fall through to the last case which shouldn't remove empty strings.
+
+    case 'action':
+    case 'formAction':
+      {
+        // TODO: Consider only special casing these for each tag.
+        if (value == null || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'defaultValue':
+    case 'defaultChecked': // These shouldn't be set as attributes on generic HTML elements.
+
+    case 'innerHTML': // Must use dangerouslySetInnerHTML instead.
+
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+      // Ignored. These are built-in to React on the client.
+      return;
+
+    case 'autoFocus':
+    case 'multiple':
+    case 'muted':
+      {
+        pushBooleanAttribute(target, name.toLowerCase(), value);
+        return;
+      }
+
+    case 'xlinkHref':
+      {
+        if (typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk('xlink:href'), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'contentEditable':
+    case 'spellCheck':
+    case 'draggable':
+    case 'value':
+    case 'autoReverse':
+    case 'externalResourcesRequired':
+    case 'focusable':
+    case 'preserveAlpha':
+      {
+        // Booleanish String
+        // These are "enumerated" attributes that accept "true" and "false".
+        // In React, we let users pass `true` and `false` even though technically
+        // these aren't boolean attributes (they are coerced to strings).
+        if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'allowFullScreen':
+    case 'async':
+    case 'autoPlay':
+    case 'controls':
+    case 'default':
+    case 'defer':
+    case 'disabled':
+    case 'disablePictureInPicture':
+    case 'disableRemotePlayback':
+    case 'formNoValidate':
+    case 'hidden':
+    case 'loop':
+    case 'noModule':
+    case 'noValidate':
+    case 'open':
+    case 'playsInline':
+    case 'readOnly':
+    case 'required':
+    case 'reversed':
+    case 'scoped':
+    case 'seamless':
+    case 'itemScope':
+      {
+        // Boolean
+        if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        }
+
+        return;
+      }
+
+    case 'capture':
+    case 'download':
+      {
+        // Overloaded Boolean
+        if (value === true) {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        } else if (value === false) ; else if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'cols':
+    case 'rows':
+    case 'size':
+    case 'span':
+      {
+        // These are HTML attributes that must be positive numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value) && value >= 1) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'rowSpan':
+    case 'start':
+      {
+        // These are HTML attributes that must be numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value)) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'xlinkActuate':
+      pushStringAttribute(target, 'xlink:actuate', value);
+      return;
+
+    case 'xlinkArcrole':
+      pushStringAttribute(target, 'xlink:arcrole', value);
+      return;
+
+    case 'xlinkRole':
+      pushStringAttribute(target, 'xlink:role', value);
+      return;
+
+    case 'xlinkShow':
+      pushStringAttribute(target, 'xlink:show', value);
+      return;
+
+    case 'xlinkTitle':
+      pushStringAttribute(target, 'xlink:title', value);
+      return;
+
+    case 'xlinkType':
+      pushStringAttribute(target, 'xlink:type', value);
+      return;
+
+    case 'xmlBase':
+      pushStringAttribute(target, 'xml:base', value);
+      return;
+
+    case 'xmlLang':
+      pushStringAttribute(target, 'xml:lang', value);
+      return;
+
+    case 'xmlSpace':
+      pushStringAttribute(target, 'xml:space', value);
+      return;
+
+    default:
+      if ( // shouldIgnoreAttribute
+      // We have already filtered out null/undefined and reserved words.
+      name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+        return;
+      }
+
+      const attributeName = getAttributeAlias(name);
+
+      if (isAttributeNameSafe(attributeName)) {
+        // shouldRemoveAttribute
+        switch (typeof value) {
+          case 'function':
+          case 'symbol':
+            // eslint-disable-line
+            return;
+
+          case 'boolean':
+            {
+              const prefix = attributeName.toLowerCase().slice(0, 5);
+
+              if (prefix !== 'data-' && prefix !== 'aria-') {
+                return;
+              }
+            }
+        }
+
+        target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+      }
+
+  }
+}
+
+const endOfStartTag = stringToPrecomputedChunk('>');
+const endOfStartTagSelfClosing = stringToPrecomputedChunk('/>');
+
+function pushInnerHTML(target, innerHTML, children) {
+  if (innerHTML != null) {
+    if (children != null) {
+      throw Error(formatProdErrorMessage(60));
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw Error(formatProdErrorMessage(61));
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+
+      target.push(stringToChunk('' + html));
+    }
+  }
+} // TODO: Move these to RenderState so that we warn for every request.
+
+function pushStartSelect(target, props) {
+
+  target.push(startChunkForTag('select'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          // TODO: This doesn't really make sense for select since it can't use the controlled
+          // value in the innerHTML.
+          innerHTML = propValue;
+          break;
+
+        case 'defaultValue':
+        case 'value':
+          // These are set on the Context instead and applied to the nested options.
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+function flattenOptionChildren(children) {
+  let content = ''; // Flatten children and warn if they aren't strings or numbers;
+  // invalid types are ignored.
+
+  React.Children.forEach(children, function (child) {
+    if (child == null) {
+      return;
+    }
+
+    content += child;
+  });
+  return content;
+}
+
+const selectedMarkerAttribute = stringToPrecomputedChunk(' selected=""');
+
+function pushStartOption(target, props, formatContext) {
+  const selectedValue = formatContext.selectedValue;
+  target.push(startChunkForTag('option'));
+  let children = null;
+  let value = null;
+  let selected = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'selected':
+          // ignore
+          selected = propValue;
+
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+        // We intentionally fallthrough to also set the attribute on the node.
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (selectedValue != null) {
+    let stringValue;
+
+    if (value !== null) {
+
+      stringValue = '' + value;
+    } else {
+
+      stringValue = flattenOptionChildren(children);
+    }
+
+    if (isArray(selectedValue)) {
+      // multiple
+      for (let i = 0; i < selectedValue.length; i++) {
+
+        const v = '' + selectedValue[i];
+
+        if (v === stringValue) {
+          target.push(selectedMarkerAttribute);
+          break;
+        }
+      }
+    } else {
+
+      if ('' + selectedValue === stringValue) {
+        target.push(selectedMarkerAttribute);
+      }
+    }
+  } else if (selected) {
+    target.push(selectedMarkerAttribute);
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const formReplayingRuntimeScript = stringToPrecomputedChunk(formReplaying);
+
+function injectFormReplayingRuntime(resumableState, renderState) {
+  // If we haven't sent it yet, inject the runtime that tracks submitted JS actions
+  // for later replaying by Fiber. If we use an external runtime, we don't need
+  // to emit anything. It's always used.
+  if ((resumableState.instructions & SentFormReplayingRuntime) === NothingSent && (!renderState.externalRuntimeScript)) {
+    resumableState.instructions |= SentFormReplayingRuntime;
+    renderState.bootstrapChunks.unshift(renderState.startInlineScript, formReplayingRuntimeScript, endInlineScript);
+  }
+}
+
+const formStateMarkerIsMatching = stringToPrecomputedChunk('<!--F!-->');
+const formStateMarkerIsNotMatching = stringToPrecomputedChunk('<!--F-->');
+function pushFormStateMarkerIsMatching(target) {
+  target.push(formStateMarkerIsMatching);
+}
+function pushFormStateMarkerIsNotMatching(target) {
+  target.push(formStateMarkerIsNotMatching);
+}
+
+function pushStartForm(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('form'));
+  let children = null;
+  let innerHTML = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'action':
+          formAction = propValue;
+          break;
+
+        case 'encType':
+          formEncType = propValue;
+          break;
+
+        case 'method':
+          formMethod = propValue;
+          break;
+
+        case 'target':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  let formData = null;
+  let formActionName = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+      formActionName = customFields.name;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('action'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'action', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'encType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'method', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'target', formTarget);
+  }
+
+  target.push(endOfStartTag);
+
+  if (formActionName !== null) {
+    target.push(startHiddenInputChunk);
+    pushStringAttribute(target, 'name', formActionName);
+    target.push(endOfStartTagSelfClosing);
+    pushAdditionalFormFields(target, formData);
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushInput(target, props, resumableState, renderState) {
+
+  target.push(startChunkForTag('input'));
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+  let value = null;
+  let defaultValue = null;
+  let checked = null;
+  let defaultChecked = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(399, 'input'));
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        case 'defaultChecked':
+          defaultChecked = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'checked':
+          checked = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+
+  if (checked !== null) {
+    pushBooleanAttribute(target, 'checked', checked);
+  } else if (defaultChecked !== null) {
+    pushBooleanAttribute(target, 'checked', defaultChecked);
+  }
+
+  if (value !== null) {
+    pushAttribute(target, 'value', value);
+  } else if (defaultValue !== null) {
+    pushAttribute(target, 'value', defaultValue);
+  }
+
+  target.push(endOfStartTagSelfClosing); // We place any additional hidden form fields after the input.
+
+  pushAdditionalFormFields(target, formData);
+  return null;
+}
+
+function pushStartButton(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('button'));
+  let children = null;
+  let innerHTML = null;
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+  target.push(endOfStartTag); // We place any additional hidden form fields we need to include inside the button itself.
+
+  pushAdditionalFormFields(target, formData);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartTextArea(target, props) {
+
+  target.push(startChunkForTag('textarea'));
+  let value = null;
+  let defaultValue = null;
+  let children = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(91));
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (value === null && defaultValue !== null) {
+    value = defaultValue;
+  }
+
+  target.push(endOfStartTag); // TODO (yungsters): Remove support for children content in <textarea>.
+
+  if (children != null) {
+
+    if (value != null) {
+      throw Error(formatProdErrorMessage(92));
+    }
+
+    if (isArray(children)) {
+      if (children.length > 1) {
+        throw Error(formatProdErrorMessage(93));
+      } // TODO: remove the coercion and the DEV check below because it will
+
+      value = '' + children[0];
+    }
+
+    value = '' + children;
+  }
+
+  if (typeof value === 'string' && value[0] === '\n') {
+    // text/html ignores the first character in these tags if it's a newline
+    // Prefer to break application/xml over text/html (for now) by adding
+    // a newline specifically to get eaten by the parser. (Alternately for
+    // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+    // \r is normalized out by HTMLTextAreaElement#value.)
+    // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+    // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+    // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+    // See: Parsing of "textarea" "listing" and "pre" elements
+    //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+    target.push(leadingNewline);
+  } // ToString and push directly instead of recurse over children.
+  // We don't really support complex children in the value anyway.
+  // This also currently avoids a trailing comment node which breaks textarea.
+
+
+  if (value !== null) {
+
+    target.push(stringToChunk(encodeHTMLTextNode('' + value)));
+  }
+
+  return null;
+}
+
+function pushMeta(target, props, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      return pushSelfClosing(target, props, 'meta');
+    } else {
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      if (typeof props.charSet === 'string') {
+        return pushSelfClosing(renderState.charsetChunks, props, 'meta');
+      } else if (props.name === 'viewport') {
+        // "viewport" isn't related to preconnect but it has the right priority
+        return pushSelfClosing(renderState.preconnectChunks, props, 'meta');
+      } else {
+        return pushSelfClosing(renderState.hoistableChunks, props, 'meta');
+      }
+    }
+  }
+}
+
+function pushLink(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const rel = props.rel;
+    const href = props.href;
+    const precedence = props.precedence;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof rel !== 'string' || typeof href !== 'string' || href === '') {
+
+      pushLinkImpl(target, props);
+      return null;
+    }
+
+    if (props.rel === 'stylesheet') {
+      // This <link> may hoistable as a Stylesheet Resource, otherwise it will emit in place
+      const key = getResourceKey(href);
+
+      if (typeof precedence !== 'string' || props.disabled != null || props.onLoad || props.onError) {
+
+        return pushLinkImpl(target, props);
+      } else {
+        // This stylesheet refers to a Resource and we create a new one if necessary
+        let styleQueue = renderState.styles.get(precedence);
+        const hasKey = resumableState.styleResources.hasOwnProperty(key);
+        const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+        if (resourceState !== EXISTS) {
+          // We are going to create this resource now so it is marked as Exists
+          resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+          // to create a StyleQueue
+
+          if (!styleQueue) {
+            styleQueue = {
+              precedence: stringToChunk(escapeTextForBrowser(precedence)),
+              rules: [],
+              hrefs: [],
+              sheets: new Map()
+            };
+            renderState.styles.set(precedence, styleQueue);
+          }
+
+          const resource = {
+            state: PENDING$1,
+            props: stylesheetPropsFromRawProps(props)
+          };
+
+          if (resourceState) {
+            // When resourceState is truty it is a Preload state. We cast it for clarity
+            const preloadState = resourceState;
+
+            if (preloadState.length === 2) {
+              adoptPreloadCredentials(resource.props, preloadState);
+            }
+
+            const preloadResource = renderState.preloads.stylesheets.get(key);
+
+            if (preloadResource && preloadResource.length > 0) {
+              // The Preload for this resource was created in this render pass and has not flushed yet so
+              // we need to clear it to avoid it flushing.
+              preloadResource.length = 0;
+            } else {
+              // Either the preload resource from this render already flushed in this render pass
+              // or the preload flushed in a prior pass (prerender). In either case we need to mark
+              // this resource as already having been preloaded.
+              resource.state = PRELOADED;
+            }
+          } // We add the newly created resource to our StyleQueue and if necessary
+          // track the resource with the currently rendering boundary
+
+
+          styleQueue.sheets.set(key, resource);
+
+          if (renderState.boundaryResources) {
+            renderState.boundaryResources.stylesheets.add(resource);
+          }
+        } else {
+          // We need to track whether this boundary should wait on this resource or not.
+          // Typically this resource should always exist since we either had it or just created
+          // it. However, it's possible when you resume that the style has already been emitted
+          // and then it wouldn't be recreated in the RenderState and there's no need to track
+          // it again since we should've hoisted it to the shell already.
+          if (styleQueue) {
+            const resource = styleQueue.sheets.get(key);
+
+            if (resource) {
+              if (renderState.boundaryResources) {
+                renderState.boundaryResources.stylesheets.add(resource);
+              }
+            }
+          }
+        }
+
+        if (textEmbedded) {
+          // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+          // to be safe and assume text will follow by inserting a textSeparator
+          target.push(textSeparator);
+        }
+
+        return null;
+      }
+    } else if (props.onLoad || props.onError) {
+      // When using load handlers we cannot hoist and need to emit links in place
+      return pushLinkImpl(target, props);
+    } else {
+      // We can hoist this link so we may need to emit a text separator.
+      // @TODO refactor text separators so we don't have to defensively add
+      // them when we don't end up emitting a tag as a result of pushStartInstance
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      switch (props.rel) {
+        case 'preconnect':
+        case 'dns-prefetch':
+          return pushLinkImpl(renderState.preconnectChunks, props);
+
+        case 'preload':
+          return pushLinkImpl(renderState.preloadChunks, props);
+
+        default:
+          return pushLinkImpl(renderState.hoistableChunks, props);
+      }
+    }
+  }
+}
+
+function pushLinkImpl(target, props) {
+  target.push(startChunkForTag('link'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(399, 'link'));
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStyle(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+
+  {
+    const precedence = props.precedence;
+    const href = props.href;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof precedence !== 'string' || typeof href !== 'string' || href === '') {
+      // This style tag is not able to be turned into a Style Resource
+      return pushStyleImpl(target, props);
+    }
+
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS;
+
+      if (!styleQueue) {
+        // This is the first time we've encountered this precedence we need
+        // to create a StyleQueue.
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [stringToChunk(escapeTextForBrowser(href))],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      } else {
+        // We have seen this precedence before and need to track this href
+        styleQueue.hrefs.push(stringToChunk(escapeTextForBrowser(href)));
+      }
+
+      pushStyleContents(styleQueue.rules, props);
+    }
+
+    if (styleQueue) {
+      // We need to track whether this boundary should wait on this resource or not.
+      // Typically this resource should always exist since we either had it or just created
+      // it. However, it's possible when you resume that the style has already been emitted
+      // and then it wouldn't be recreated in the RenderState and there's no need to track
+      // it again since we should've hoisted it to the shell already.
+      if (renderState.boundaryResources) {
+        renderState.boundaryResources.styles.add(styleQueue);
+      }
+    }
+
+    if (textEmbedded) {
+      // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+  }
+}
+
+function pushStyleImpl(target, props) {
+  target.push(startChunkForTag('style'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('style'));
+  return null;
+}
+
+function pushStyleContents(target, props) {
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+      }
+    }
+  }
+
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  return;
+}
+
+function pushImg(target, props, resumableState, renderState, pictureTagInScope) {
+  const src = props.src,
+        srcSet = props.srcSet;
+
+  if (props.loading !== 'lazy' && (src || srcSet) && (typeof src === 'string' || src == null) && (typeof srcSet === 'string' || srcSet == null) && props.fetchPriority !== 'low' && pictureTagInScope === false && // We exclude data URIs in src and srcSet since these should not be preloaded
+  !(typeof src === 'string' && src[4] === ':' && (src[0] === 'd' || src[0] === 'D') && (src[1] === 'a' || src[1] === 'A') && (src[2] === 't' || src[2] === 'T') && (src[3] === 'a' || src[3] === 'A')) && !(typeof srcSet === 'string' && srcSet[4] === ':' && (srcSet[0] === 'd' || srcSet[0] === 'D') && (srcSet[1] === 'a' || srcSet[1] === 'A') && (srcSet[2] === 't' || srcSet[2] === 'T') && (srcSet[3] === 'a' || srcSet[3] === 'A'))) {
+    // We have a suspensey image and ought to preload it to optimize the loading of display blocking
+    // resumableState.
+    const sizes = typeof props.sizes === 'string' ? props.sizes : undefined;
+    const key = getImageResourceKey(src, srcSet, sizes);
+    const promotablePreloads = renderState.preloads.images;
+    let resource = promotablePreloads.get(key);
+
+    if (resource) {
+      // We consider whether this preload can be promoted to higher priority flushing queue.
+      // The only time a resource will exist here is if it was created during this render
+      // and was not already in the high priority queue.
+      if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+        // Delete the resource from the map since we are promoting it and don't want to
+        // reenter this branch in a second pass for duplicate img hrefs.
+        promotablePreloads.delete(key); // $FlowFixMe - Flow should understand that this is a Resource if the condition was true
+
+        renderState.highImagePreloads.add(resource);
+      }
+    } else if (!resumableState.imageResources.hasOwnProperty(key)) {
+      // We must construct a new preload resource
+      resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+      const crossOrigin = getCrossOriginString(props.crossOrigin);
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // this is a hueristic similar to capping element preloads to 10 unless explicitly
+      // fetchPriority="high". We use length here which means it will fit fewer images when
+      // the urls are long and more when short. arguably byte size is a better hueristic because
+      // it directly translates to how much we send down before content is actually seen.
+      // We could unify the counts and also make it so the total is tracked regardless of
+      // flushing output but since the headers are likely to be go earlier than content
+      // they don't really conflict so for now I've kept them separate
+      props.fetchPriority === 'high' || headers.highImagePreloads.length < 500) && ( // We manually construct the options for the preload only from strings. We don't want to pollute
+      // the params list with arbitrary props and if we copied everything over as it we might get
+      // coercion errors. We have checks for this in Dev but it seems safer to just only accept values
+      // that are strings
+      header = getPreloadAsHeader(src, 'image', {
+        imageSrcSet: props.srcSet,
+        imageSizes: props.sizes,
+        crossOrigin,
+        integrity: props.integrity,
+        nonce: props.nonce,
+        type: props.type,
+        fetchPriority: props.fetchPriority,
+        referrerPolicy: props.refererPolicy
+      }), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // If we postpone in the shell we will still emit this preload so we track
+        // it to make sure we don't reset it.
+        renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+        if (headers.highImagePreloads) {
+          headers.highImagePreloads += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.highImagePreloads += header;
+      } else {
+        resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preload',
+          as: 'image',
+          // There is a bug in Safari where imageSrcSet is not respected on preload links
+          // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+          // This harms older browers that do not support imageSrcSet by making their preloads not work
+          // but this population is shrinking fast and is already small so we accept this tradeoff.
+          href: srcSet ? undefined : src,
+          imageSrcSet: srcSet,
+          imageSizes: sizes,
+          crossOrigin: crossOrigin,
+          integrity: props.integrity,
+          type: props.type,
+          fetchPriority: props.fetchPriority,
+          referrerPolicy: props.referrerPolicy
+        });
+
+        if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+          renderState.highImagePreloads.add(resource);
+        } else {
+          renderState.bulkPreloads.add(resource); // We can bump the priority up if the same img is rendered later
+          // with fetchPriority="high"
+
+          promotablePreloads.set(key, resource);
+        }
+      }
+    }
+  }
+
+  return pushSelfClosing(target, props, 'img');
+}
+
+function pushSelfClosing(target, props, tag) {
+  target.push(startChunkForTag(tag));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(399, tag));
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStartMenuItem(target, props) {
+  target.push(startChunkForTag('menuitem'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(400));
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  return null;
+}
+
+function pushTitle(target, props, renderState, insertionMode, noscriptTagInScope) {
+
+  {
+    if (insertionMode !== SVG_MODE && !noscriptTagInScope && props.itemProp == null) {
+      pushTitleImpl(renderState.hoistableChunks, props);
+      return null;
+    } else {
+      return pushTitleImpl(target, props);
+    }
+  }
+}
+
+function pushTitleImpl(target, props) {
+  target.push(startChunkForTag('title'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('title'));
+  return null;
+}
+
+function pushStartHead(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode < HTML_MODE && renderState.headChunks === null) {
+      // This <head> is the Document.head and should be part of the preamble
+      renderState.headChunks = [];
+      return pushStartGenericElement(renderState.headChunks, props, 'head');
+    } else {
+      // This <head> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'head');
+    }
+  }
+}
+
+function pushStartHtml(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode === ROOT_HTML_MODE && renderState.htmlChunks === null) {
+      // This <html> is the Document.documentElement and should be part of the preamble
+      renderState.htmlChunks = [doctypeChunk];
+      return pushStartGenericElement(renderState.htmlChunks, props, 'html');
+    } else {
+      // This <html> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'html');
+    }
+  }
+}
+
+function pushScript(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const asyncProp = props.async;
+
+    if (typeof props.src !== 'string' || !props.src || !(asyncProp && typeof asyncProp !== 'function' && typeof asyncProp !== 'symbol') || props.onLoad || props.onError || insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      // This script will not be a resource, we bailout early and emit it in place.
+      return pushScriptImpl(target, props);
+    }
+
+    const src = props.src;
+    const key = getResourceKey(src); // We can make this <script> into a ScriptResource
+
+    let resources, preloads;
+
+    if (props.type === 'module') {
+      resources = resumableState.moduleScriptResources;
+      preloads = renderState.preloads.moduleScripts;
+    } else {
+      resources = resumableState.scriptResources;
+      preloads = renderState.preloads.scripts;
+    }
+
+    const hasKey = resources.hasOwnProperty(key);
+    const resourceState = hasKey ? resources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resources[key] = EXISTS;
+      let scriptProps = props;
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          scriptProps = assign({}, props);
+          adoptPreloadCredentials(scriptProps, preloadState);
+        }
+
+        const preloadResource = preloads.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, scriptProps);
+    }
+
+    if (textEmbedded) {
+      // This script follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+
+    return null;
+  }
+}
+
+function pushScriptImpl(target, props) {
+  target.push(startChunkForTag('script'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+  }
+
+  target.push(endChunkForTag('script'));
+  return null;
+}
+
+function pushStartGenericElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartCustomElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      let propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      let attributeName = propKey;
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'style':
+          pushStyleAttribute(target, propValue);
+          break;
+
+        case 'suppressContentEditableWarning':
+        case 'suppressHydrationWarning':
+          // Ignored. These are built-in to React on the client.
+          break;
+
+        case 'className':
+
+        // intentional fallthrough
+
+        default:
+          if (isAttributeNameSafe(propKey) && typeof propValue !== 'function' && typeof propValue !== 'symbol') {
+
+            target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(propValue)), attributeEnd);
+          }
+
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const leadingNewline = stringToPrecomputedChunk('\n');
+
+function pushStartPreformattedElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag); // text/html ignores the first character in these tags if it's a newline
+  // Prefer to break application/xml over text/html (for now) by adding
+  // a newline specifically to get eaten by the parser. (Alternately for
+  // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+  // \r is normalized out by HTMLTextAreaElement#value.)
+  // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+  // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+  // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+  // See: Parsing of "textarea" "listing" and "pre" elements
+  //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+  // TODO: This doesn't deal with the case where the child is an array
+  // or component that returns a string.
+
+  if (innerHTML != null) {
+    if (children != null) {
+      throw Error(formatProdErrorMessage(60));
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw Error(formatProdErrorMessage(61));
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+      if (typeof html === 'string' && html.length > 0 && html[0] === '\n') {
+        target.push(leadingNewline, stringToChunk(html));
+      } else {
+
+        target.push(stringToChunk('' + html));
+      }
+    }
+  }
+
+  if (typeof children === 'string' && children[0] === '\n') {
+    target.push(leadingNewline);
+  }
+
+  return children;
+} // We accept any tag to be rendered but since this gets injected into arbitrary
+// HTML, we want to make sure that it's a safe tag.
+// http://www.w3.org/TR/REC-xml/#NT-Name
+
+
+const VALID_TAG_REGEX = /^[a-zA-Z][a-zA-Z:_\.\-\d]*$/; // Simplified subset
+
+const validatedTagCache = new Map();
+
+function startChunkForTag(tag) {
+  let tagStartChunk = validatedTagCache.get(tag);
+
+  if (tagStartChunk === undefined) {
+    if (!VALID_TAG_REGEX.test(tag)) {
+      throw Error(formatProdErrorMessage(65, tag));
+    }
+
+    tagStartChunk = stringToPrecomputedChunk('<' + tag);
+    validatedTagCache.set(tag, tagStartChunk);
+  }
+
+  return tagStartChunk;
+}
+function pushStartInstance(target, type, props, resumableState, renderState, formatContext, textEmbedded) {
+
+  switch (type) {
+    case 'div':
+    case 'span':
+    case 'svg':
+    case 'path':
+    case 'a':
+    case 'g':
+    case 'p':
+    case 'li':
+      // Fast track very common tags
+      break;
+    // Special tags
+
+    case 'select':
+      return pushStartSelect(target, props);
+
+    case 'option':
+      return pushStartOption(target, props, formatContext);
+
+    case 'textarea':
+      return pushStartTextArea(target, props);
+
+    case 'input':
+      return pushInput(target, props, resumableState, renderState);
+
+    case 'button':
+      return pushStartButton(target, props, resumableState, renderState);
+
+    case 'form':
+      return pushStartForm(target, props, resumableState, renderState);
+
+    case 'menuitem':
+      return pushStartMenuItem(target, props);
+
+    case 'title':
+      return pushTitle(target, props, renderState, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'link':
+      return pushLink(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'script':
+      return pushScript(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'style':
+      return pushStyle(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'meta':
+      return pushMeta(target, props, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+    // Newline eating tags
+
+    case 'listing':
+    case 'pre':
+      {
+        return pushStartPreformattedElement(target, props, type);
+      }
+
+    case 'img':
+      {
+        return pushImg(target, props, resumableState, renderState, !!(formatContext.tagScope & PICTURE_SCOPE)) ;
+      }
+    // Omitted close tags
+
+    case 'base':
+    case 'area':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'keygen':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        return pushSelfClosing(target, props, type);
+      }
+    // These are reserved SVG and MathML elements, that are never custom elements.
+    // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+
+    case 'annotation-xml':
+    case 'color-profile':
+    case 'font-face':
+    case 'font-face-src':
+    case 'font-face-uri':
+    case 'font-face-format':
+    case 'font-face-name':
+    case 'missing-glyph':
+      {
+        break;
+      }
+    // Preamble start tags
+
+    case 'head':
+      return pushStartHead(target, props, renderState, formatContext.insertionMode);
+
+    case 'html':
+      {
+        return pushStartHtml(target, props, renderState, formatContext.insertionMode);
+      }
+
+    default:
+      {
+        if (type.indexOf('-') !== -1) {
+          // Custom element
+          return pushStartCustomElement(target, props, type);
+        }
+      }
+  } // Generic element
+
+
+  return pushStartGenericElement(target, props, type);
+}
+const endTagCache = new Map();
+
+function endChunkForTag(tag) {
+  let chunk = endTagCache.get(tag);
+
+  if (chunk === undefined) {
+    chunk = stringToPrecomputedChunk('</' + tag + '>');
+    endTagCache.set(tag, chunk);
+  }
+
+  return chunk;
+}
+
+function pushEndInstance(target, type, props, resumableState, formatContext) {
+  switch (type) {
+    // When float is on we expect title and script tags to always be pushed in
+    // a unit and never return children. when we end up pushing the end tag we
+    // want to ensure there is no extra closing tag pushed
+    case 'title':
+    case 'style':
+    case 'script':
+    // Omitted close tags
+    // TODO: Instead of repeating this switch we could try to pass a flag from above.
+    // That would require returning a tuple. Which might be ok if it gets inlined.
+
+    case 'area':
+    case 'base':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'img':
+    case 'input':
+    case 'keygen':
+    case 'link':
+    case 'meta':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        // No close tag needed.
+        return;
+      }
+    // Postamble end tags
+    // When float is enabled we omit the end tags for body and html when
+    // they represent the Document.body and Document.documentElement Nodes.
+    // This is so we can withhold them until the postamble when we know
+    // we won't emit any more tags
+
+    case 'body':
+      {
+        if (formatContext.insertionMode <= HTML_HTML_MODE) {
+          resumableState.hasBody = true;
+          return;
+        }
+
+        break;
+      }
+
+    case 'html':
+      if (formatContext.insertionMode === ROOT_HTML_MODE) {
+        resumableState.hasHtml = true;
+        return;
+      }
+
+      break;
+  }
+
+  target.push(endChunkForTag(type));
+}
+
+function writeBootstrap(destination, renderState, resumableState) {
+  resumableState.bootstrapScriptContent = undefined;
+  resumableState.bootstrapScripts = undefined;
+  resumableState.bootstrapModules = undefined;
+  const bootstrapChunks = renderState.bootstrapChunks;
+  let i = 0;
+
+  for (; i < bootstrapChunks.length - 1; i++) {
+    writeChunk(destination, bootstrapChunks[i]);
+  }
+
+  if (i < bootstrapChunks.length) {
+    const lastChunk = bootstrapChunks[i];
+    bootstrapChunks.length = 0;
+    return writeChunkAndReturn(destination, lastChunk);
+  }
+
+  return true;
+}
+
+function writeCompletedRoot(destination, renderState, resumableState) {
+  return writeBootstrap(destination, renderState, resumableState);
+} // Structural Nodes
+// A placeholder is a node inside a hidden partial tree that can be filled in later, but before
+// display. It's never visible to users. We use the template tag because it can be used in every
+// type of parent. <script> tags also work in every other tag except <colgroup>.
+
+const placeholder1 = stringToPrecomputedChunk('<template id="');
+const placeholder2 = stringToPrecomputedChunk('"></template>');
+function writePlaceholder(destination, renderState, id) {
+  writeChunk(destination, placeholder1);
+  writeChunk(destination, renderState.placeholderPrefix);
+  const formattedID = stringToChunk(id.toString(16));
+  writeChunk(destination, formattedID);
+  return writeChunkAndReturn(destination, placeholder2);
+} // Suspense boundaries are encoded as comments.
+
+const startCompletedSuspenseBoundary = stringToPrecomputedChunk('<!--$-->');
+const startPendingSuspenseBoundary1 = stringToPrecomputedChunk('<!--$?--><template id="');
+const startPendingSuspenseBoundary2 = stringToPrecomputedChunk('"></template>');
+const startClientRenderedSuspenseBoundary = stringToPrecomputedChunk('<!--$!-->');
+const endSuspenseBoundary = stringToPrecomputedChunk('<!--/$-->');
+const clientRenderedSuspenseBoundaryError1 = stringToPrecomputedChunk('<template');
+const clientRenderedSuspenseBoundaryErrorAttrInterstitial = stringToPrecomputedChunk('"');
+const clientRenderedSuspenseBoundaryError1A = stringToPrecomputedChunk(' data-dgst="');
+const clientRenderedSuspenseBoundaryError2 = stringToPrecomputedChunk('></template>');
+function writeStartCompletedSuspenseBoundary$1(destination, renderState) {
+  return writeChunkAndReturn(destination, startCompletedSuspenseBoundary);
+}
+function writeStartPendingSuspenseBoundary(destination, renderState, id) {
+  writeChunk(destination, startPendingSuspenseBoundary1);
+
+  if (id === null) {
+    throw Error(formatProdErrorMessage(395));
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+  return writeChunkAndReturn(destination, startPendingSuspenseBoundary2);
+}
+function writeStartClientRenderedSuspenseBoundary$1(destination, renderState, errorDigest, errorMesssage, errorComponentStack) {
+  let result;
+  result = writeChunkAndReturn(destination, startClientRenderedSuspenseBoundary);
+  writeChunk(destination, clientRenderedSuspenseBoundaryError1);
+
+  if (errorDigest) {
+    writeChunk(destination, clientRenderedSuspenseBoundaryError1A);
+    writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest)));
+    writeChunk(destination, clientRenderedSuspenseBoundaryErrorAttrInterstitial);
+  }
+
+  result = writeChunkAndReturn(destination, clientRenderedSuspenseBoundaryError2);
+  return result;
+}
+function writeEndCompletedSuspenseBoundary$1(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndPendingSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndClientRenderedSuspenseBoundary$1(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+const startSegmentHTML = stringToPrecomputedChunk('<div hidden id="');
+const startSegmentHTML2 = stringToPrecomputedChunk('">');
+const endSegmentHTML = stringToPrecomputedChunk('</div>');
+const startSegmentSVG = stringToPrecomputedChunk('<svg aria-hidden="true" style="display:none" id="');
+const startSegmentSVG2 = stringToPrecomputedChunk('">');
+const endSegmentSVG = stringToPrecomputedChunk('</svg>');
+const startSegmentMathML = stringToPrecomputedChunk('<math aria-hidden="true" style="display:none" id="');
+const startSegmentMathML2 = stringToPrecomputedChunk('">');
+const endSegmentMathML = stringToPrecomputedChunk('</math>');
+const startSegmentTable = stringToPrecomputedChunk('<table hidden id="');
+const startSegmentTable2 = stringToPrecomputedChunk('">');
+const endSegmentTable = stringToPrecomputedChunk('</table>');
+const startSegmentTableBody = stringToPrecomputedChunk('<table hidden><tbody id="');
+const startSegmentTableBody2 = stringToPrecomputedChunk('">');
+const endSegmentTableBody = stringToPrecomputedChunk('</tbody></table>');
+const startSegmentTableRow = stringToPrecomputedChunk('<table hidden><tr id="');
+const startSegmentTableRow2 = stringToPrecomputedChunk('">');
+const endSegmentTableRow = stringToPrecomputedChunk('</tr></table>');
+const startSegmentColGroup = stringToPrecomputedChunk('<table hidden><colgroup id="');
+const startSegmentColGroup2 = stringToPrecomputedChunk('">');
+const endSegmentColGroup = stringToPrecomputedChunk('</colgroup></table>');
+function writeStartSegment(destination, renderState, formatContext, id) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        writeChunk(destination, startSegmentHTML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentHTML2);
+      }
+
+    case SVG_MODE:
+      {
+        writeChunk(destination, startSegmentSVG);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentSVG2);
+      }
+
+    case MATHML_MODE:
+      {
+        writeChunk(destination, startSegmentMathML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentMathML2);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        writeChunk(destination, startSegmentTable);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTable2);
+      }
+    // TODO: For the rest of these, there will be extra wrapper nodes that never
+    // get deleted from the document. We need to delete the table too as part
+    // of the injected scripts. They are invisible though so it's not too terrible
+    // and it's kind of an edge case to suspend in a table. Totally supported though.
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        writeChunk(destination, startSegmentTableBody);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableBody2);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        writeChunk(destination, startSegmentTableRow);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableRow2);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        writeChunk(destination, startSegmentColGroup);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentColGroup2);
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(397));
+      }
+  }
+}
+function writeEndSegment(destination, formatContext) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentHTML);
+      }
+
+    case SVG_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentSVG);
+      }
+
+    case MATHML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentMathML);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTable);
+      }
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableBody);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableRow);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentColGroup);
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(397));
+      }
+  }
+}
+const completeSegmentScript1Full = stringToPrecomputedChunk(completeSegment + '$RS("');
+const completeSegmentScript1Partial = stringToPrecomputedChunk('$RS("');
+const completeSegmentScript2 = stringToPrecomputedChunk('","');
+const completeSegmentScriptEnd = stringToPrecomputedChunk('")</script>');
+const completeSegmentData1 = stringToPrecomputedChunk('<template data-rsi="" data-sid="');
+const completeSegmentData2 = stringToPrecomputedChunk('" data-pid="');
+const completeSegmentDataEnd = dataElementQuotedEnd;
+function writeCompletedSegmentInstruction(destination, resumableState, renderState, contentSegmentID) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentCompleteSegmentFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentCompleteSegmentFunction;
+      writeChunk(destination, completeSegmentScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, completeSegmentScript1Partial);
+    }
+  } else {
+    writeChunk(destination, completeSegmentData1);
+  } // Write function arguments, which are string literals
+
+
+  writeChunk(destination, renderState.segmentPrefix);
+  const formattedID = stringToChunk(contentSegmentID.toString(16));
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    writeChunk(destination, completeSegmentScript2);
+  } else {
+    writeChunk(destination, completeSegmentData2);
+  }
+
+  writeChunk(destination, renderState.placeholderPrefix);
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    return writeChunkAndReturn(destination, completeSegmentScriptEnd);
+  } else {
+    return writeChunkAndReturn(destination, completeSegmentDataEnd);
+  }
+}
+const completeBoundaryScript1Full = stringToPrecomputedChunk(completeBoundary + '$RC("');
+const completeBoundaryScript1Partial = stringToPrecomputedChunk('$RC("');
+const completeBoundaryWithStylesScript1FullBoth = stringToPrecomputedChunk(completeBoundary + completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1FullPartial = stringToPrecomputedChunk(completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1Partial = stringToPrecomputedChunk('$RR("');
+const completeBoundaryScript2 = stringToPrecomputedChunk('","');
+const completeBoundaryScript3a = stringToPrecomputedChunk('",');
+const completeBoundaryScript3b = stringToPrecomputedChunk('"');
+const completeBoundaryScriptEnd = stringToPrecomputedChunk(')</script>');
+const completeBoundaryData1 = stringToPrecomputedChunk('<template data-rci="" data-bid="');
+const completeBoundaryWithStylesData1 = stringToPrecomputedChunk('<template data-rri="" data-bid="');
+const completeBoundaryData2 = stringToPrecomputedChunk('" data-sid="');
+const completeBoundaryData3a = stringToPrecomputedChunk('" data-sty="');
+const completeBoundaryDataEnd = dataElementQuotedEnd;
+function writeCompletedBoundaryInstruction(destination, resumableState, renderState, id, boundaryResources) {
+  let requiresStyleInsertion;
+
+  {
+    requiresStyleInsertion = renderState.stylesToHoist; // If necessary stylesheets will be flushed with this instruction.
+    // Any style tags not yet hoisted in the Document will also be hoisted.
+    // We reset this state since after this instruction executes all styles
+    // up to this point will have been hoisted
+
+    renderState.stylesToHoist = false;
+  }
+
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if (requiresStyleInsertion) {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction | SentCompleteBoundaryFunction;
+        writeChunk(destination, clonePrecomputedChunk(completeBoundaryWithStylesScript1FullBoth));
+      } else if ((resumableState.instructions & SentStyleInsertionFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction;
+        writeChunk(destination, completeBoundaryWithStylesScript1FullPartial);
+      } else {
+        writeChunk(destination, completeBoundaryWithStylesScript1Partial);
+      }
+    } else {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentCompleteBoundaryFunction;
+        writeChunk(destination, completeBoundaryScript1Full);
+      } else {
+        writeChunk(destination, completeBoundaryScript1Partial);
+      }
+    }
+  } else {
+    if (requiresStyleInsertion) {
+      writeChunk(destination, completeBoundaryWithStylesData1);
+    } else {
+      writeChunk(destination, completeBoundaryData1);
+    }
+  }
+
+  const idChunk = stringToChunk(id.toString(16));
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, idChunk); // Write function arguments, which are string and array literals
+
+  if (scriptFormat) {
+    writeChunk(destination, completeBoundaryScript2);
+  } else {
+    writeChunk(destination, completeBoundaryData2);
+  }
+
+  writeChunk(destination, renderState.segmentPrefix);
+  writeChunk(destination, idChunk);
+
+  if (requiresStyleInsertion) {
+    // Script and data writers must format this differently:
+    //  - script writer emits an array literal, whose string elements are
+    //    escaped for javascript  e.g. ["A", "B"]
+    //  - data writer emits a string literal, which is escaped as html
+    //    e.g. [&#34;A&#34;, &#34;B&#34;]
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3a); // boundaryResources encodes an array literal
+
+      writeStyleResourceDependenciesInJS(destination, boundaryResources);
+    } else {
+      writeChunk(destination, completeBoundaryData3a);
+      writeStyleResourceDependenciesInAttr(destination, boundaryResources);
+    }
+  } else {
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3b);
+    }
+  }
+
+  let writeMore;
+
+  if (scriptFormat) {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryScriptEnd);
+  } else {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryDataEnd);
+  }
+
+  return writeBootstrap(destination, renderState, resumableState) && writeMore;
+}
+const clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
+const clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
+const clientRenderScript1A = stringToPrecomputedChunk('"');
+const clientRenderErrorScriptArgInterstitial = stringToPrecomputedChunk(',');
+const clientRenderScriptEnd = stringToPrecomputedChunk(')</script>');
+const clientRenderData1 = stringToPrecomputedChunk('<template data-rxi="" data-bid="');
+const clientRenderData2 = stringToPrecomputedChunk('" data-dgst="');
+const clientRenderData3 = stringToPrecomputedChunk('" data-msg="');
+const clientRenderData4 = stringToPrecomputedChunk('" data-stck="');
+const clientRenderDataEnd = dataElementQuotedEnd;
+function writeClientRenderBoundaryInstruction(destination, resumableState, renderState, id, errorDigest, errorMessage, errorComponentStack) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentClientRenderFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentClientRenderFunction;
+      writeChunk(destination, clientRenderScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, clientRenderScript1Partial);
+    }
+  } else {
+    // <template data-rxi="" data-bid="
+    writeChunk(destination, clientRenderData1);
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+
+  if (scriptFormat) {
+    // " needs to be inserted for scripts, since ArgInterstitual does not contain
+    // leading or trailing quotes
+    writeChunk(destination, clientRenderScript1A);
+  }
+
+  if (errorDigest || errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorDigest || '')));
+    } else {
+      // " data-dgst="HTMLString
+      writeChunk(destination, clientRenderData2);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest || '')));
+    }
+  }
+
+  if (errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorMessage || '')));
+    } else {
+      // " data-msg="HTMLString
+      writeChunk(destination, clientRenderData3);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorMessage || '')));
+    }
+  }
+
+  if (errorComponentStack) {
+    // ,"JSONString"
+    if (scriptFormat) {
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorComponentStack)));
+    } else {
+      // " data-stck="HTMLString
+      writeChunk(destination, clientRenderData4);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorComponentStack)));
+    }
+  }
+
+  if (scriptFormat) {
+    // ></script>
+    return writeChunkAndReturn(destination, clientRenderScriptEnd);
+  } else {
+    // "></template>
+    return writeChunkAndReturn(destination, clientRenderDataEnd);
+  }
+}
+const regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
+
+function escapeJSStringsForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInInstructionScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const regexForJSStringsInScripts = /[&><\u2028\u2029]/g;
+
+function escapeJSObjectForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '&':
+        return '\\u0026';
+
+      case '>':
+        return '\\u003e';
+
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const lateStyleTagResourceOpen1 = stringToPrecomputedChunk('<style media="not all" data-precedence="');
+const lateStyleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const lateStyleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const lateStyleTagTemplateClose = stringToPrecomputedChunk('</style>'); // Tracks whether the boundary currently flushing is flushign style tags or has any
+// stylesheet dependencies not flushed in the Preamble.
+
+let currentlyRenderingBoundaryHasStylesToHoist = false; // Acts as a return value for the forEach execution of style tag flushing.
+
+let destinationHasCapacity = true;
+
+function flushStyleTagsLateForBoundary(styleQueue) {
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs;
+
+  let i = 0;
+
+  if (hrefs.length) {
+    writeChunk(this, lateStyleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    writeChunk(this, lateStyleTagResourceOpen2);
+
+    for (; i < hrefs.length - 1; i++) {
+      writeChunk(this, hrefs[i]);
+      writeChunk(this, spaceSeparator);
+    }
+
+    writeChunk(this, hrefs[i]);
+    writeChunk(this, lateStyleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    destinationHasCapacity = writeChunkAndReturn(this, lateStyleTagTemplateClose); // We wrote style tags for this boundary and we may need to emit a script
+    // to hoist them.
+
+    currentlyRenderingBoundaryHasStylesToHoist = true; // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function hasStylesToHoist(stylesheet) {
+  // We need to reveal boundaries with styles whenever a stylesheet it depends on is either
+  // not flushed or flushed after the preamble (shell).
+  if (stylesheet.state !== PREAMBLE) {
+    currentlyRenderingBoundaryHasStylesToHoist = true;
+    return true;
+  }
+
+  return false;
+}
+
+function writeResourcesForBoundary(destination, boundaryResources, renderState) {
+  // Reset these on each invocation, they are only safe to read in this function
+  currentlyRenderingBoundaryHasStylesToHoist = false;
+  destinationHasCapacity = true; // Flush style tags for each precedence this boundary depends on
+
+  boundaryResources.styles.forEach(flushStyleTagsLateForBoundary, destination); // Determine if this boundary has stylesheets that need to be awaited upon completion
+
+  boundaryResources.stylesheets.forEach(hasStylesToHoist);
+
+  if (currentlyRenderingBoundaryHasStylesToHoist) {
+    renderState.stylesToHoist = true;
+  }
+
+  return destinationHasCapacity;
+}
+
+function flushResource(resource) {
+  for (let i = 0; i < resource.length; i++) {
+    writeChunk(this, resource[i]);
+  }
+
+  resource.length = 0;
+}
+
+const stylesheetFlushingQueue = [];
+
+function flushStyleInPreamble(stylesheet, key, map) {
+  // We still need to encode stylesheet chunks
+  // because unlike most Hoistables and Resources we do not eagerly encode
+  // them during render. This is because if we flush late we have to send a
+  // different encoding and we don't want to encode multiple times
+  pushLinkImpl(stylesheetFlushingQueue, stylesheet.props);
+
+  for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+    writeChunk(this, stylesheetFlushingQueue[i]);
+  }
+
+  stylesheetFlushingQueue.length = 0;
+  stylesheet.state = PREAMBLE;
+}
+
+const styleTagResourceOpen1 = stringToPrecomputedChunk('<style data-precedence="');
+const styleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const spaceSeparator = stringToPrecomputedChunk(' ');
+const styleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const styleTagResourceClose = stringToPrecomputedChunk('</style>');
+
+function flushStylesInPreamble(styleQueue, precedence) {
+  const hasStylesheets = styleQueue.sheets.size > 0;
+  styleQueue.sheets.forEach(flushStyleInPreamble, this);
+  styleQueue.sheets.clear();
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs; // If we don't emit any stylesheets at this precedence we still need to maintain the precedence
+  // order so even if there are no rules for style tags at this precedence we emit an empty style
+  // tag with the data-precedence attribute
+
+  if (!hasStylesheets || hrefs.length) {
+    writeChunk(this, styleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    let i = 0;
+
+    if (hrefs.length) {
+      writeChunk(this, styleTagResourceOpen2);
+
+      for (; i < hrefs.length - 1; i++) {
+        writeChunk(this, hrefs[i]);
+        writeChunk(this, spaceSeparator);
+      }
+
+      writeChunk(this, hrefs[i]);
+    }
+
+    writeChunk(this, styleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    writeChunk(this, styleTagResourceClose); // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function preloadLateStyle(stylesheet) {
+  if (stylesheet.state === PENDING$1) {
+    stylesheet.state = PRELOADED;
+    const preloadProps = preloadAsStylePropsFromProps(stylesheet.props.href, stylesheet.props);
+    pushLinkImpl(stylesheetFlushingQueue, preloadProps);
+
+    for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+      writeChunk(this, stylesheetFlushingQueue[i]);
+    }
+
+    stylesheetFlushingQueue.length = 0;
+  }
+}
+
+function preloadLateStyles(styleQueue) {
+  styleQueue.sheets.forEach(preloadLateStyle, this);
+  styleQueue.sheets.clear();
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+
+function writePreamble(destination, resumableState, renderState, willFlushAllSegments) {
+  // This function must be called exactly once on every request
+  if (!willFlushAllSegments && renderState.externalRuntimeScript) {
+    // If the root segment is incomplete due to suspended tasks
+    // (e.g. willFlushAllSegments = false) and we are using data
+    // streaming format, ensure the external runtime is sent.
+    // (User code could choose to send this even earlier by calling
+    //  preinit(...), if they know they will suspend).
+    const _renderState$external = renderState.externalRuntimeScript,
+          src = _renderState$external.src,
+          chunks = _renderState$external.chunks;
+    internalPreinitScript(resumableState, renderState, src, chunks);
+  }
+
+  const htmlChunks = renderState.htmlChunks;
+  const headChunks = renderState.headChunks;
+  let i = 0; // Emit open tags before Hoistables and Resources
+
+  if (htmlChunks) {
+    // We have an <html> to emit as part of the preamble
+    for (i = 0; i < htmlChunks.length; i++) {
+      writeChunk(destination, htmlChunks[i]);
+    }
+
+    if (headChunks) {
+      for (i = 0; i < headChunks.length; i++) {
+        writeChunk(destination, headChunks[i]);
+      }
+    } else {
+      // We did not render a head but we emitted an <html> so we emit one now
+      writeChunk(destination, startChunkForTag('head'));
+      writeChunk(destination, endOfStartTag);
+    }
+  } else if (headChunks) {
+    // We do not have an <html> but we do have a <head>
+    for (i = 0; i < headChunks.length; i++) {
+      writeChunk(destination, headChunks[i]);
+    }
+  } // Emit high priority Hoistables
+
+
+  const charsetChunks = renderState.charsetChunks;
+
+  for (i = 0; i < charsetChunks.length; i++) {
+    writeChunk(destination, charsetChunks[i]);
+  }
+
+  charsetChunks.length = 0; // emit preconnect resources
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Flush unblocked stylesheets by precedence
+
+  renderState.styles.forEach(flushStylesInPreamble, destination);
+  const importMapChunks = renderState.importMapChunks;
+
+  for (i = 0; i < importMapChunks.length; i++) {
+    writeChunk(destination, importMapChunks[i]);
+  }
+
+  importMapChunks.length = 0;
+  renderState.bootstrapScripts.forEach(flushResource, destination);
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0; // Flush closing head if necessary
+
+  if (htmlChunks && headChunks === null) {
+    // We have an <html> rendered but no <head> rendered. We however inserted
+    // a <head> up above so we need to emit the </head> now. This is safe because
+    // if the main content contained the </head> it would also have provided a
+    // <head>. This means that all the content inside <html> is either <body> or
+    // invalid HTML
+    writeChunk(destination, endChunkForTag('head'));
+  }
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+function writeHoistables(destination, resumableState, renderState) {
+  let i = 0; // Emit high priority Hoistables
+  // We omit charsetChunks because we have already sent the shell and if it wasn't
+  // already sent it is too late now.
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Preload any stylesheets. these will emit in a render instruction that follows this
+  // but we want to kick off preloading as soon as possible
+
+  renderState.styles.forEach(preloadLateStyles, destination); // We only hoist importmaps that are configured through createResponse and that will
+  // always flush in the preamble. Generally we don't expect people to render them as
+  // tags when using React but if you do they are going to be treated like regular inline
+  // scripts and flush after other hoistables which is problematic
+  // bootstrap scripts should flush above script priority but these can only flush in the preamble
+  // so we elide the code here for performance
+
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0;
+}
+function writePostamble(destination, resumableState) {
+  if (resumableState.hasBody) {
+    writeChunk(destination, endChunkForTag('body'));
+  }
+
+  if (resumableState.hasHtml) {
+    writeChunk(destination, endChunkForTag('html'));
+  }
+}
+const arrayFirstOpenBracket = stringToPrecomputedChunk('[');
+const arraySubsequentOpenBracket = stringToPrecomputedChunk(',[');
+const arrayInterstitial = stringToPrecomputedChunk(',');
+const arrayCloseBracket = stringToPrecomputedChunk(']'); // This function writes a 2D array of strings to be embedded in javascript.
+// E.g.
+//  [["JS_escaped_string1", "JS_escaped_string2"]]
+
+function writeStyleResourceDependenciesInJS(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInJS(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInJS(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInJS(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+}
+
+function writeStyleResourceDependencyInJS(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedPrecedence)));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(399, 'link'));
+
+        default:
+          writeStyleResourceAttributeInJS(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInJS(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeName)));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeValue)));
+} // This function writes a 2D array of strings to be embedded in an attribute
+// value and read with JSON.parse in ReactDOMServerExternalRuntime.js
+// E.g.
+//  [[&quot;JSON_escaped_string1&quot;, &quot;JSON_escaped_string2&quot;]]
+
+
+function writeStyleResourceDependenciesInAttr(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInAttr(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInAttr(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInAttr(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+}
+
+function writeStyleResourceDependencyInAttr(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedPrecedence))));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(399, 'link'));
+
+        default:
+          writeStyleResourceAttributeInAttr(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInAttr(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeName))));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeValue))));
+}
+/**
+ * Resources
+ */
+
+
+const PENDING$1 = 0;
+const PRELOADED = 1;
+const PREAMBLE = 2;
+const LATE = 3;
+function createBoundaryResources() {
+  return {
+    styles: new Set(),
+    stylesheets: new Set()
+  };
+}
+function setCurrentlyRenderingBoundaryResourcesTarget(renderState, boundaryResources) {
+  renderState.boundaryResources = boundaryResources;
+}
+
+function getResourceKey(href) {
+  return href;
+}
+
+function getImageResourceKey(href, imageSrcSet, imageSizes) {
+  if (imageSrcSet) {
+    return imageSrcSet + '\n' + (imageSizes || '');
+  }
+
+  return href;
+}
+
+function prefetchDNS(href) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const key = getResourceKey(href);
+
+    if (!resumableState.dnsResources.hasOwnProperty(key)) {
+      resumableState.dnsResources[key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPrefetchDNSAsHeader(href), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this as resettable in case we are prerendering and postpone in the Shell
+        renderState.resets.dns[key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        // Encode as element
+        const resource = [];
+        pushLinkImpl(resource, {
+          href,
+          rel: 'dns-prefetch'
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preconnect(href, crossOrigin) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const bucket = crossOrigin === 'use-credentials' ? 'credentials' : typeof crossOrigin === 'string' ? 'anonymous' : 'default';
+    const key = getResourceKey(href);
+
+    if (!resumableState.connectResources[bucket].hasOwnProperty(key)) {
+      resumableState.connectResources[bucket][key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPreconnectAsHeader(href, crossOrigin), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this in resettableState in case we are prerending and postpone in the Shell
+        renderState.resets.connect[bucket][key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        const resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preconnect',
+          href,
+          crossOrigin
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preload(href, as, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (as && href) {
+    switch (as) {
+      case 'image':
+        {
+          let imageSrcSet, imageSizes, fetchPriority;
+
+          if (options) {
+            imageSrcSet = options.imageSrcSet;
+            imageSizes = options.imageSizes;
+            fetchPriority = options.fetchPriority;
+          }
+
+          const key = getImageResourceKey(href, imageSrcSet, imageSizes);
+
+          if (resumableState.imageResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && fetchPriority === 'high' && ( // Compute the header since we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit a preload as a header so we
+            // track this to make sure we don't reset it.
+            renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+            if (headers.highImagePreloads) {
+              headers.highImagePreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.highImagePreloads += header;
+          } else {
+            // If we don't have headers to write to we have to encode as elements to flush in the head
+            // When we have imageSrcSet the browser probably cannot load the right version from headers
+            // (this should be verified by testing). For now we assume these need to go in the head
+            // as elements even if headers are available.
+            const resource = [];
+            pushLinkImpl(resource, assign({
+              rel: 'preload',
+              // There is a bug in Safari where imageSrcSet is not respected on preload links
+              // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+              // This harms older browers that do not support imageSrcSet by making their preloads not work
+              // but this population is shrinking fast and is already small so we accept this tradeoff.
+              href: imageSrcSet ? undefined : href,
+              as
+            }, options));
+
+            if (fetchPriority === 'high') {
+              renderState.highImagePreloads.add(resource);
+            } else {
+              renderState.bulkPreloads.add(resource); // Stash the resource in case we need to promote it to higher priority
+              // when an img tag is rendered
+
+              renderState.preloads.images.set(key, resource);
+            }
+          }
+
+          break;
+        }
+
+      case 'style':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.styleResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.styleResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.stylesheets.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          break;
+        }
+
+      case 'script':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.scriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          renderState.preloads.scripts.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.scriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          break;
+        }
+
+      default:
+        {
+          const key = getResourceKey(href);
+          const hasAsType = resumableState.unknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.unknownResources[as] = resources;
+          }
+
+          resources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && as === 'font' && ( // We compute the header here because we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit this preload so we
+            // track it here to prevent it from being reset.
+            renderState.resets.font[key] = PRELOAD_NO_CREDS;
+
+            if (headers.fontPreloads) {
+              headers.fontPreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.fontPreloads += header;
+          } else {
+            // We either don't have headers or we are preloading something that does
+            // not warrant elevated priority so we encode as an element.
+            const resource = [];
+
+            const props = assign({
+              rel: 'preload',
+              href,
+              as
+            }, options);
+
+            pushLinkImpl(resource, props);
+
+            switch (as) {
+              case 'font':
+                renderState.fontPreloads.add(resource);
+                break;
+              // intentional fall through
+
+              default:
+                renderState.bulkPreloads.add(resource);
+            }
+          }
+        }
+    } // If we got this far we created a new resource
+
+
+    flushResources(request);
+  }
+}
+
+function preloadModule(href, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    const key = getResourceKey(href);
+    const as = options && typeof options.as === 'string' ? options.as : 'script';
+    let resource;
+
+    switch (as) {
+      case 'script':
+        {
+          if (resumableState.moduleScriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resource = [];
+          resumableState.moduleScriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.moduleScripts.set(key, resource);
+          break;
+        }
+
+      default:
+        {
+          const hasAsType = resumableState.moduleUnknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.moduleUnknownResources[as] = resources;
+          }
+
+          resource = [];
+          resources[key] = PRELOAD_NO_CREDS;
+        }
+    }
+
+    pushLinkImpl(resource, assign({
+      rel: 'modulepreload',
+      href
+    }, options));
+    renderState.bulkPreloads.add(resource); // If we got this far we created a new resource
+
+    flushResources(request);
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    precedence = precedence || 'default';
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+      // to create a StyleQueue
+
+      if (!styleQueue) {
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      }
+
+      const resource = {
+        state: PENDING$1,
+        props: assign({
+          rel: 'stylesheet',
+          href,
+          'data-precedence': precedence
+        }, options)
+      };
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(resource.props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.stylesheets.get(key);
+
+        if (preloadResource && preloadResource.length > 0) {
+          // The Preload for this resource was created in this render pass and has not flushed yet so
+          // we need to clear it to avoid it flushing.
+          preloadResource.length = 0;
+        } else {
+          // Either the preload resource from this render already flushed in this render pass
+          // or the preload flushed in a prior pass (prerender). In either case we need to mark
+          // this resource as already having been preloaded.
+          resource.state = PRELOADED;
+        }
+      } // We add the newly created resource to our StyleQueue and if necessary
+      // track the resource with the currently rendering boundary
+
+
+      styleQueue.sheets.set(key, resource); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+  }
+}
+
+function preinitScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.scriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.scriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.scriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.scripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+}
+
+function preinitModuleScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.moduleScriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.moduleScriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.moduleScriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        type: 'module',
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.moduleScripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+} // This function is only safe to call at Request start time since it assumes
+// that each module has not already been preloaded. If we find a need to preload
+// scripts at any other point in time we will need to check whether the preload
+// already exists and not assume it
+
+
+function preloadBootstrapScriptOrModule(resumableState, renderState, href, props) {
+
+  const key = getResourceKey(href);
+  // used to preinit the resource. If a script can be preinited then it shouldn't
+  // be a bootstrap script/module and if it is a bootstrap script/module then it
+  // must not be safe to emit early. To avoid possibly allowing for preinits of
+  // bootstrap scripts/modules we occlude these keys.
+
+
+  resumableState.scriptResources[key] = EXISTS;
+  resumableState.moduleScriptResources[key] = EXISTS;
+  const resource = [];
+  pushLinkImpl(resource, props);
+  renderState.bootstrapScripts.add(resource);
+}
+
+function internalPreinitScript(resumableState, renderState, src, chunks) {
+  const key = getResourceKey(src);
+
+  if (!resumableState.scriptResources.hasOwnProperty(key)) {
+    const resource = chunks;
+    resumableState.scriptResources[key] = EXISTS;
+    renderState.scripts.add(resource);
+  }
+
+  return;
+}
+
+function preloadAsStylePropsFromProps(href, props) {
+  return {
+    rel: 'preload',
+    as: 'style',
+    href: href,
+    crossOrigin: props.crossOrigin,
+    fetchPriority: props.fetchPriority,
+    integrity: props.integrity,
+    media: props.media,
+    hrefLang: props.hrefLang,
+    referrerPolicy: props.referrerPolicy
+  };
+}
+
+function stylesheetPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    'data-precedence': rawProps.precedence,
+    precedence: null
+  });
+}
+
+function adoptPreloadCredentials(target, preloadState) {
+  if (target.crossOrigin == null) target.crossOrigin = preloadState[0];
+  if (target.integrity == null) target.integrity = preloadState[1];
+}
+
+function getPrefetchDNSAsHeader(href) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  return "<" + escapedHref + ">; rel=dns-prefetch";
+}
+
+function getPreconnectAsHeader(href, crossOrigin) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  let value = "<" + escapedHref + ">; rel=preconnect";
+
+  if (typeof crossOrigin === 'string') {
+    const escapedCrossOrigin = escapeStringForLinkHeaderQuotedParamValueContext(crossOrigin);
+    value += "; crossorigin=\"" + escapedCrossOrigin + "\"";
+  }
+
+  return value;
+}
+
+function getPreloadAsHeader(href, as, params) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  const escapedAs = escapeStringForLinkHeaderQuotedParamValueContext(as);
+  let value = "<" + escapedHref + ">; rel=preload; as=\"" + escapedAs + "\"";
+
+  for (const paramName in params) {
+    if (hasOwnProperty.call(params, paramName)) {
+      const paramValue = params[paramName];
+
+      if (typeof paramValue === 'string') {
+        value += "; " + paramName.toLowerCase() + "=\"" + escapeStringForLinkHeaderQuotedParamValueContext(paramValue) + "\"";
+      }
+    }
+  }
+
+  return value;
+}
+
+function getStylesheetPreloadAsHeader(stylesheet) {
+  const props = stylesheet.props;
+  const preloadOptions = {
+    crossOrigin: props.crossOrigin,
+    integrity: props.integrity,
+    nonce: props.nonce,
+    type: props.type,
+    fetchPriority: props.fetchPriority,
+    referrerPolicy: props.referrerPolicy,
+    media: props.media
+  };
+  return getPreloadAsHeader(props.href, 'style', preloadOptions);
+} // This escaping function is only safe to use for href values being written into
+// a "Link" header in between `<` and `>` characters. The primary concern with the href is
+// to escape the bounding characters as well as new lines. This is unsafe to use in any other
+// context
+
+
+const regexForHrefInLinkHeaderURLContext = /[<>\r\n]/g;
+
+function escapeHrefForLinkHeaderURLContext(hrefInput) {
+
+  const coercedHref = '' + hrefInput;
+  return coercedHref.replace(regexForHrefInLinkHeaderURLContext, escapeHrefForLinkHeaderURLContextReplacer);
+}
+
+function escapeHrefForLinkHeaderURLContextReplacer(match) {
+  switch (match) {
+    case '<':
+      return '%3C';
+
+    case '>':
+      return '%3E';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeLinkHrefForHeaderContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+} // This escaping function is only safe to use for quoted param values in an HTTP header.
+// It is unsafe to use for any value not inside quote marks in parater value position.
+
+
+const regexForLinkHeaderQuotedParamValueContext = /["';,\r\n]/g;
+
+function escapeStringForLinkHeaderQuotedParamValueContext(value, name) {
+
+  const coerced = '' + value;
+  return coerced.replace(regexForLinkHeaderQuotedParamValueContext, escapeStringForLinkHeaderQuotedParamValueContextReplacer);
+}
+
+function escapeStringForLinkHeaderQuotedParamValueContextReplacer(match) {
+  switch (match) {
+    case '"':
+      return '%22';
+
+    case "'":
+      return '%27';
+
+    case ';':
+      return '%3B';
+
+    case ',':
+      return '%2C';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeStringForLinkHeaderQuotedParamValueContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+}
+
+function hoistStyleQueueDependency(styleQueue) {
+  this.styles.add(styleQueue);
+}
+
+function hoistStylesheetDependency(stylesheet) {
+  this.stylesheets.add(stylesheet);
+}
+
+function hoistResources(renderState, source) {
+  const currentBoundaryResources = renderState.boundaryResources;
+
+  if (currentBoundaryResources) {
+    source.styles.forEach(hoistStyleQueueDependency, currentBoundaryResources);
+    source.stylesheets.forEach(hoistStylesheetDependency, currentBoundaryResources);
+  }
+} // This function is called at various times depending on whether we are rendering
+// or prerendering. In this implementation we only actually emit headers once and
+// subsequent calls are ignored. We track whether the request has a completed shell
+// to determine whether we will follow headers with a flush including stylesheets.
+// In the context of prerrender we don't have a completed shell when the request finishes
+// with a postpone in the shell. In the context of a render we don't have a completed shell
+// if this is called before the shell finishes rendering which usually will happen anytime
+// anything suspends in the shell.
+
+function emitEarlyPreloads(renderState, resumableState, shellComplete) {
+  const onHeaders = renderState.onHeaders;
+
+  if (onHeaders) {
+    const headers = renderState.headers;
+
+    if (headers) {
+      let linkHeader = headers.preconnects;
+
+      if (headers.fontPreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.fontPreloads;
+      }
+
+      if (headers.highImagePreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.highImagePreloads;
+      }
+
+      if (!shellComplete) {
+        // We use raw iterators because we want to be able to halt iteration
+        // We could refactor renderState to store these dually in arrays to
+        // make this more efficient at the cost of additional memory and
+        // write overhead. However this code only runs once per request so
+        // for now I consider this sufficient.
+        const queueIter = renderState.styles.values();
+
+        outer: for (let queueStep = queueIter.next(); headers.remainingCapacity > 0 && !queueStep.done; queueStep = queueIter.next()) {
+          const sheets = queueStep.value.sheets;
+          const sheetIter = sheets.values();
+
+          for (let sheetStep = sheetIter.next(); headers.remainingCapacity > 0 && !sheetStep.done; sheetStep = sheetIter.next()) {
+            const sheet = sheetStep.value;
+            const props = sheet.props;
+            const key = getResourceKey(props.href);
+            const header = getStylesheetPreloadAsHeader(sheet); // We mutate the capacity b/c we don't want to keep checking if later headers will fit.
+            // This means that a particularly long header might close out the header queue where later
+            // headers could still fit. We could in the future alter the behavior here based on prerender vs render
+            // since during prerender we aren't as concerned with pure runtime performance.
+
+            if ((headers.remainingCapacity -= header.length) >= 2) {
+              renderState.resets.style[key] = PRELOAD_NO_CREDS;
+
+              if (linkHeader) {
+                linkHeader += ', ';
+              }
+
+              linkHeader += header; // We already track that the resource exists in resumableState however
+              // if the resumableState resets because we postponed in the shell
+              // which is what is happening in this branch if we are prerendering
+              // then we will end up resetting the resumableState. When it resets we
+              // want to record the fact that this stylesheet was already preloaded
+
+              renderState.resets.style[key] = typeof props.crossOrigin === 'string' || typeof props.integrity === 'string' ? [props.crossOrigin, props.integrity] : PRELOAD_NO_CREDS;
+            } else {
+              break outer;
+            }
+          }
+        }
+      }
+
+      if (linkHeader) {
+        onHeaders({
+          Link: linkHeader
+        });
+      } else {
+        // We still call this with no headers because a user may be using it as a signal that
+        // it React will not provide any headers
+        onHeaders({});
+      }
+
+      renderState.headers = null;
+      return;
+    }
+  }
+}
+
+function createRenderState(resumableState, generateStaticMarkup) {
+  const renderState = createRenderState$1(resumableState, undefined, undefined, undefined, undefined, undefined);
+  return {
+    // Keep this in sync with ReactFizzConfigDOM
+    placeholderPrefix: renderState.placeholderPrefix,
+    segmentPrefix: renderState.segmentPrefix,
+    boundaryPrefix: renderState.boundaryPrefix,
+    startInlineScript: renderState.startInlineScript,
+    htmlChunks: renderState.htmlChunks,
+    headChunks: renderState.headChunks,
+    externalRuntimeScript: renderState.externalRuntimeScript,
+    bootstrapChunks: renderState.bootstrapChunks,
+    onHeaders: renderState.onHeaders,
+    headers: renderState.headers,
+    resets: renderState.resets,
+    charsetChunks: renderState.charsetChunks,
+    preconnectChunks: renderState.preconnectChunks,
+    importMapChunks: renderState.importMapChunks,
+    preloadChunks: renderState.preloadChunks,
+    hoistableChunks: renderState.hoistableChunks,
+    preconnects: renderState.preconnects,
+    fontPreloads: renderState.fontPreloads,
+    highImagePreloads: renderState.highImagePreloads,
+    // usedImagePreloads: renderState.usedImagePreloads,
+    styles: renderState.styles,
+    bootstrapScripts: renderState.bootstrapScripts,
+    scripts: renderState.scripts,
+    bulkPreloads: renderState.bulkPreloads,
+    preloads: renderState.preloads,
+    boundaryResources: renderState.boundaryResources,
+    stylesToHoist: renderState.stylesToHoist,
+    // This is an extra field for the legacy renderer
+    generateStaticMarkup
+  };
+}
+
+const doctypeChunk = stringToPrecomputedChunk('');
+function pushTextInstance(target, text, renderState, textEmbedded) {
+  if (renderState.generateStaticMarkup) {
+    target.push(stringToChunk(escapeTextForBrowser(text)));
+    return false;
+  } else {
+    return pushTextInstance$1(target, text, renderState, textEmbedded);
+  }
+}
+function pushSegmentFinale(target, renderState, lastPushedText, textEmbedded) {
+  if (renderState.generateStaticMarkup) {
+    return;
+  } else {
+    return pushSegmentFinale$1(target, renderState, lastPushedText, textEmbedded);
+  }
+}
+function writeStartCompletedSuspenseBoundary(destination, renderState) {
+  if (renderState.generateStaticMarkup) {
+    // A completed boundary is done and doesn't need a representation in the HTML
+    // if we're not going to be hydrating it.
+    return true;
+  }
+
+  return writeStartCompletedSuspenseBoundary$1(destination);
+}
+function writeStartClientRenderedSuspenseBoundary(destination, renderState, // flushing these error arguments are not currently supported in this legacy streaming format.
+errorDigest, errorMessage, errorComponentStack) {
+  if (renderState.generateStaticMarkup) {
+    // A client rendered boundary is done and doesn't need a representation in the HTML
+    // since we'll never hydrate it. This is arguably an error in static generation.
+    return true;
+  }
+
+  return writeStartClientRenderedSuspenseBoundary$1(destination, renderState, errorDigest);
+}
+function writeEndCompletedSuspenseBoundary(destination, renderState) {
+  if (renderState.generateStaticMarkup) {
+    return true;
+  }
+
+  return writeEndCompletedSuspenseBoundary$1(destination);
+}
+function writeEndClientRenderedSuspenseBoundary(destination, renderState) {
+  if (renderState.generateStaticMarkup) {
+    return true;
+  }
+
+  return writeEndClientRenderedSuspenseBoundary$1(destination);
+}
+const NotPendingTransition = NotPending;
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+const REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_CONTEXT_TYPE = Symbol.for('react.context');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SCOPE_TYPE = Symbol.for('react.scope');
+const REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');
+const REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+const REACT_LEGACY_HIDDEN_TYPE = Symbol.for('react.legacy_hidden');
+const REACT_CACHE_TYPE = Symbol.for('react.cache');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+function getWrappedName(outerType, innerType, wrapperName) {
+  const displayName = outerType.displayName;
+
+  if (displayName) {
+    return displayName;
+  }
+
+  const functionName = innerType.displayName || innerType.name || '';
+  return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
+} // Keep in sync with react-reconciler/getComponentNameFromFiber
+
+
+function getContextName(type) {
+  return type.displayName || 'Context';
+} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+
+function getComponentNameFromType(type) {
+  if (type == null) {
+    // Host root, text node or just invalid type.
+    return null;
+  }
+
+  if (typeof type === 'function') {
+    return type.displayName || type.name || null;
+  }
+
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_FRAGMENT_TYPE:
+      return 'Fragment';
+
+    case REACT_PORTAL_TYPE:
+      return 'Portal';
+
+    case REACT_PROFILER_TYPE:
+      return 'Profiler';
+
+    case REACT_STRICT_MODE_TYPE:
+      return 'StrictMode';
+
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+
+    case REACT_CACHE_TYPE:
+      {
+        return 'Cache';
+      }
+
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        const context = type;
+        return getContextName(context) + '.Consumer';
+
+      case REACT_PROVIDER_TYPE:
+        const provider = type;
+        return getContextName(provider._context) + '.Provider';
+
+      case REACT_FORWARD_REF_TYPE:
+        return getWrappedName(type, type.render, 'ForwardRef');
+
+      case REACT_MEMO_TYPE:
+        const outerName = type.displayName || null;
+
+        if (outerName !== null) {
+          return outerName;
+        }
+
+        return getComponentNameFromType(type.type) || 'Memo';
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            return getComponentNameFromType(init(payload));
+          } catch (x) {
+            return null;
+          }
+        }
+
+    }
+  }
+
+  return null;
+}
+
+const emptyContextObject = {};
+
+function getMaskedContext(type, unmaskedContext) {
+  {
+    const contextTypes = type.contextTypes;
+
+    if (!contextTypes) {
+      return emptyContextObject;
+    }
+
+    const context = {};
+
+    for (const key in contextTypes) {
+      context[key] = unmaskedContext[key];
+    }
+
+    return context;
+  }
+}
+function processChildContext(instance, type, parentContext, childContextTypes) {
+  {
+    // TODO (bvaughn) Replace this behavior with an invariant() in the future.
+    // It has only been added in Fiber to match the (unintentional) behavior in Stack.
+    if (typeof instance.getChildContext !== 'function') {
+
+      return parentContext;
+    }
+
+    const childContext = instance.getChildContext();
+
+    for (const contextKey in childContext) {
+      if (!(contextKey in childContextTypes)) {
+        throw Error(formatProdErrorMessage(108, getComponentNameFromType(type) || 'Unknown', contextKey));
+      }
+    }
+
+    return assign({}, parentContext, childContext);
+  }
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue2 = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue2 = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw Error(formatProdErrorMessage(401));
+      }
+    } else {
+      if (parentNext === null) {
+        throw Error(formatProdErrorMessage(401));
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext);
+    } // On the way back, we push the new ones that weren't common.
+
+
+    pushNode(next);
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw Error(formatProdErrorMessage(402));
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw Error(formatProdErrorMessage(402));
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function pushProvider(context, nextValue) {
+  let prevValue;
+
+  {
+    prevValue = context._currentValue2;
+    context._currentValue2 = nextValue;
+  }
+
+  const prevNode = currentActiveSnapshot;
+  const newNode = {
+    parent: prevNode,
+    depth: prevNode === null ? 0 : prevNode.depth + 1,
+    context: context,
+    parentValue: prevValue,
+    value: nextValue
+  };
+  currentActiveSnapshot = newNode;
+  return newNode;
+}
+function popProvider(context) {
+  const prevSnapshot = currentActiveSnapshot;
+
+  if (prevSnapshot === null) {
+    throw Error(formatProdErrorMessage(403));
+  }
+
+  {
+    const value = prevSnapshot.parentValue;
+
+    if (value === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      prevSnapshot.context._currentValue2 = prevSnapshot.context._defaultValue;
+    } else {
+      prevSnapshot.context._currentValue2 = value;
+    }
+  }
+
+  return currentActiveSnapshot = prevSnapshot.parent;
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue2;
+  return value;
+}
+
+/**
+ * `ReactInstanceMap` maintains a mapping from a public facing stateful
+ * instance (key) and the internal representation (value). This allows public
+ * methods to accept the user facing instance as an argument and map them back
+ * to internal methods.
+ *
+ * Note that this module is currently shared and assumed to be stateless.
+ * If this becomes an actual Map, that will break.
+ */
+function get(key) {
+  return key._reactInternals;
+}
+function set(key, value) {
+  key._reactInternals = value;
+}
+
+const classComponentUpdater = {
+  isMounted(inst) {
+    return false;
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueSetState(inst, payload, callback) {
+    const internals = get(inst);
+
+    if (internals.queue === null) ; else {
+      internals.queue.push(payload);
+    }
+  },
+
+  enqueueReplaceState(inst, payload, callback) {
+    const internals = get(inst);
+    internals.replace = true;
+    internals.queue = [payload];
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueForceUpdate(inst, callback) {
+  }
+
+};
+
+function applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, prevState, nextProps) {
+  const partialState = getDerivedStateFromProps(nextProps, prevState);
+
+
+  const newState = partialState === null || partialState === undefined ? prevState : assign({}, prevState, partialState);
+  return newState;
+}
+
+function constructClassInstance(ctor, props, maskedLegacyContext) {
+  let context = emptyContextObject;
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    context = readContext$1(contextType);
+  } else {
+    context = maskedLegacyContext;
+  }
+
+  const instance = new ctor(props, context);
+
+  return instance;
+}
+
+function callComponentWillMount(type, instance) {
+  const oldState = instance.state;
+
+  if (typeof instance.componentWillMount === 'function') {
+
+    instance.componentWillMount();
+  }
+
+  if (typeof instance.UNSAFE_componentWillMount === 'function') {
+    instance.UNSAFE_componentWillMount();
+  }
+
+  if (oldState !== instance.state) {
+
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+}
+
+function processUpdateQueue(internalInstance, inst, props, maskedLegacyContext) {
+  if (internalInstance.queue !== null && internalInstance.queue.length > 0) {
+    const oldQueue = internalInstance.queue;
+    const oldReplace = internalInstance.replace;
+    internalInstance.queue = null;
+    internalInstance.replace = false;
+
+    if (oldReplace && oldQueue.length === 1) {
+      inst.state = oldQueue[0];
+    } else {
+      let nextState = oldReplace ? oldQueue[0] : inst.state;
+      let dontMutate = true;
+
+      for (let i = oldReplace ? 1 : 0; i < oldQueue.length; i++) {
+        const partial = oldQueue[i];
+        const partialState = typeof partial === 'function' ? partial.call(inst, nextState, props, maskedLegacyContext) : partial;
+
+        if (partialState != null) {
+          if (dontMutate) {
+            dontMutate = false;
+            nextState = assign({}, nextState, partialState);
+          } else {
+            assign(nextState, partialState);
+          }
+        }
+      }
+
+      inst.state = nextState;
+    }
+  } else {
+    internalInstance.queue = null;
+  }
+} // Invokes the mount life-cycles on a previously never rendered instance.
+
+
+function mountClassInstance(instance, ctor, newProps, maskedLegacyContext) {
+
+  const initialState = instance.state !== undefined ? instance.state : null;
+  instance.updater = classComponentUpdater;
+  instance.props = newProps;
+  instance.state = initialState; // We don't bother initializing the refs object on the server, since we're not going to resolve them anyway.
+  // The internal instance will be used to manage updates that happen during this mount.
+
+  const internalInstance = {
+    queue: [],
+    replace: false
+  };
+  set(instance, internalInstance);
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    instance.context = readContext$1(contextType);
+  } else {
+    instance.context = maskedLegacyContext;
+  }
+
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    instance.state = applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, initialState, newProps);
+  } // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+
+  if (typeof ctor.getDerivedStateFromProps !== 'function' && typeof instance.getSnapshotBeforeUpdate !== 'function' && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
+    callComponentWillMount(ctor, instance); // If we had additional state updates during this life-cycle, let's
+    // process them now.
+
+    processUpdateQueue(internalInstance, instance, newProps, maskedLegacyContext);
+  }
+}
+
+// Ids are base 32 strings whose binary representation corresponds to the
+// position of a node in a tree.
+// Every time the tree forks into multiple children, we add additional bits to
+// the left of the sequence that represent the position of the child within the
+// current level of children.
+//
+//      00101       00010001011010101
+//      ╰─┬─╯       ╰───────┬───────╯
+//   Fork 5 of 20       Parent id
+//
+// The leading 0s are important. In the above example, you only need 3 bits to
+// represent slot 5. However, you need 5 bits to represent all the forks at
+// the current level, so we must account for the empty bits at the end.
+//
+// For this same reason, slots are 1-indexed instead of 0-indexed. Otherwise,
+// the zeroth id at a level would be indistinguishable from its parent.
+//
+// If a node has only one child, and does not materialize an id (i.e. does not
+// contain a useId hook), then we don't need to allocate any space in the
+// sequence. It's treated as a transparent indirection. For example, these two
+// trees produce the same ids:
+//
+// <>                          <>
+//   <Indirection>               <A />
+//     <A />                     <B />
+//   </Indirection>            </>
+//   <B />
+// </>
+//
+// However, we cannot skip any node that materializes an id. Otherwise, a parent
+// id that does not fork would be indistinguishable from its child id. For
+// example, this tree does not fork, but the parent and child must have
+// different ids.
+//
+// <Parent>
+//   <Child />
+// </Parent>
+//
+// To handle this scenario, every time we materialize an id, we allocate a
+// new level with a single slot. You can think of this as a fork with only one
+// prong, or an array of children with length 1.
+//
+// It's possible for the size of the sequence to exceed 32 bits, the max
+// size for bitwise operations. When this happens, we make more room by
+// converting the right part of the id to a string and storing it in an overflow
+// variable. We use a base 32 string representation, because 32 is the largest
+// power of 2 that is supported by toString(). We want the base to be large so
+// that the resulting ids are compact, and we want the base to be a power of 2
+// because every log2(base) bits corresponds to a single character, i.e. every
+// log2(32) = 5 bits. That means we can lop bits off the end 5 at a time without
+// affecting the final result.
+const emptyTreeContext = {
+  id: 1,
+  overflow: ''
+};
+function getTreeId(context) {
+  const overflow = context.overflow;
+  const idWithLeadingBit = context.id;
+  const id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
+  return id.toString(32) + overflow;
+}
+function pushTreeContext(baseContext, totalChildren, index) {
+  const baseIdWithLeadingBit = baseContext.id;
+  const baseOverflow = baseContext.overflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
+  // of the id; we use it to account for leading 0s.
+
+  const baseLength = getBitLength(baseIdWithLeadingBit) - 1;
+  const baseId = baseIdWithLeadingBit & ~(1 << baseLength);
+  const slot = index + 1;
+  const length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
+  // consideration the leading 1 we use to mark the end of the sequence.
+
+  if (length > 30) {
+    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
+    // This branch assumes the length of the base id is greater than 5; it won't
+    // work for smaller ids, because you need 5 bits per character.
+    //
+    // We encode the id in multiple steps: first the base id, then the
+    // remaining digits.
+    //
+    // Each 5 bit sequence corresponds to a single base 32 character. So for
+    // example, if the current id is 23 bits long, we can convert 20 of those
+    // bits into a string of 4 characters, with 3 bits left over.
+    //
+    // First calculate how many bits in the base id represent a complete
+    // sequence of characters.
+    const numberOfOverflowBits = baseLength - baseLength % 5; // Then create a bitmask that selects only those bits.
+
+    const newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
+
+    const newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
+
+    const restOfBaseId = baseId >> numberOfOverflowBits;
+    const restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
+    // we made more room, this time it won't overflow.
+
+    const restOfLength = getBitLength(totalChildren) + restOfBaseLength;
+    const restOfNewBits = slot << restOfBaseLength;
+    const id = restOfNewBits | restOfBaseId;
+    const overflow = newOverflow + baseOverflow;
+    return {
+      id: 1 << restOfLength | id,
+      overflow
+    };
+  } else {
+    // Normal path
+    const newBits = slot << baseLength;
+    const id = newBits | baseId;
+    const overflow = baseOverflow;
+    return {
+      id: 1 << length | id,
+      overflow
+    };
+  }
+}
+
+function getBitLength(number) {
+  return 32 - clz32(number);
+}
+
+function getLeadingBit(id) {
+  return 1 << getBitLength(id) - 1;
+} // TODO: Math.clz32 is supported in Node 12+. Maybe we can drop the fallback.
+
+
+const 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
+
+const log = Math.log;
+const LN2 = Math.LN2;
+
+function clz32Fallback(x) {
+  const asUint = x >>> 0;
+
+  if (asUint === 0) {
+    return 32;
+  }
+
+  return 31 - (log(asUint) / LN2 | 0) | 0;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFlightWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = Error(formatProdErrorMessage(460));
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop$2() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop$2, noop$2);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw Error(formatProdErrorMessage(459));
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+
+const objectIs = // $FlowFixMe[method-unbinding]
+typeof Object.is === 'function' ? Object.is : is;
+
+let currentlyRenderingComponent = null;
+let currentlyRenderingTask = null;
+let currentlyRenderingRequest = null;
+let currentlyRenderingKeyPath = null;
+let firstWorkInProgressHook = null;
+let workInProgressHook = null; // Whether the work-in-progress hook is a re-rendered hook
+
+let isReRender = false; // Whether an update was scheduled during the currently executing render pass.
+
+let didScheduleRenderPhaseUpdate = false; // Counts the number of useId hooks in this component
+
+let localIdCounter = 0; // Chunks that should be pushed to the stream once the component
+// finishes rendering.
+// Counts the number of useFormState calls in this component
+
+let formStateCounter = 0; // The index of the useFormState hook that matches the one passed in at the
+// root during an MPA navigation, if any.
+
+let formStateMatchingIndex = -1; // Counts the number of use(thenable) calls in this component
+
+let thenableIndexCounter = 0;
+let thenableState = null; // Lazily created map of render-phase updates
+
+let renderPhaseUpdates = null; // Counter to prevent infinite loops.
+
+let numberOfReRenders = 0;
+const RE_RENDER_LIMIT = 25;
+
+function resolveCurrentlyRenderingComponent() {
+  if (currentlyRenderingComponent === null) {
+    throw Error(formatProdErrorMessage(321));
+  }
+
+  return currentlyRenderingComponent;
+}
+
+function areHookInputsEqual(nextDeps, prevDeps) {
+  if (prevDeps === null) {
+
+    return false;
+  }
+
+
+  for (let i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    if (objectIs(nextDeps[i], prevDeps[i])) {
+      continue;
+    }
+
+    return false;
+  }
+
+  return true;
+}
+
+function createHook() {
+  if (numberOfReRenders > 0) {
+    throw Error(formatProdErrorMessage(312));
+  }
+
+  return {
+    memoizedState: null,
+    queue: null,
+    next: null
+  };
+}
+
+function createWorkInProgressHook() {
+  if (workInProgressHook === null) {
+    // This is the first hook in the list
+    if (firstWorkInProgressHook === null) {
+      isReRender = false;
+      firstWorkInProgressHook = workInProgressHook = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = firstWorkInProgressHook;
+    }
+  } else {
+    if (workInProgressHook.next === null) {
+      isReRender = false; // Append to the end of the list
+
+      workInProgressHook = workInProgressHook.next = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = workInProgressHook.next;
+    }
+  }
+
+  return workInProgressHook;
+}
+
+function prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState) {
+  currentlyRenderingComponent = componentIdentity;
+  currentlyRenderingTask = task;
+  currentlyRenderingRequest = request;
+  currentlyRenderingKeyPath = keyPath;
+  // didScheduleRenderPhaseUpdate = false;
+  // firstWorkInProgressHook = null;
+  // numberOfReRenders = 0;
+  // renderPhaseUpdates = null;
+  // workInProgressHook = null;
+
+
+  localIdCounter = 0;
+  formStateCounter = 0;
+  formStateMatchingIndex = -1;
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function finishHooks(Component, props, children, refOrContext) {
+  // This must be called after every function component to prevent hooks from
+  // being used in classes.
+  while (didScheduleRenderPhaseUpdate) {
+    // Updates were scheduled during the render phase. They are stored in
+    // the `renderPhaseUpdates` map. Call the component again, reusing the
+    // work-in-progress hooks and applying the additional updates on top. Keep
+    // restarting until no more updates are scheduled.
+    didScheduleRenderPhaseUpdate = false;
+    localIdCounter = 0;
+    formStateCounter = 0;
+    formStateMatchingIndex = -1;
+    thenableIndexCounter = 0;
+    numberOfReRenders += 1; // Start over from the beginning of the list
+
+    workInProgressHook = null;
+    children = Component(props, refOrContext);
+  }
+
+  resetHooksState();
+  return children;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+function checkDidRenderIdHook() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  const didRenderIdHook = localIdCounter !== 0;
+  return didRenderIdHook;
+}
+function getFormStateCount() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateCounter;
+}
+function getFormStateMatchingIndex() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateMatchingIndex;
+} // Reset the internal hooks state if an error occurs while rendering a component
+
+function resetHooksState() {
+
+  currentlyRenderingComponent = null;
+  currentlyRenderingTask = null;
+  currentlyRenderingRequest = null;
+  currentlyRenderingKeyPath = null;
+  didScheduleRenderPhaseUpdate = false;
+  firstWorkInProgressHook = null;
+  numberOfReRenders = 0;
+  renderPhaseUpdates = null;
+  workInProgressHook = null;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+function useContext(context) {
+
+  resolveCurrentlyRenderingComponent();
+  return readContext$1(context);
+}
+
+function basicStateReducer(state, action) {
+  // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
+  return typeof action === 'function' ? action(state) : action;
+}
+
+function useState(initialState) {
+
+  return useReducer(basicStateReducer, // useReducer has a special case to support lazy useState initializers
+  initialState);
+}
+function useReducer(reducer, initialArg, init) {
+
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+
+  if (isReRender) {
+    // This is a re-render. Apply the new render phase updates to the previous
+    // current hook.
+    const queue = workInProgressHook.queue;
+    const dispatch = queue.dispatch;
+
+    if (renderPhaseUpdates !== null) {
+      // Render phase updates are stored in a map of queue -> linked list
+      const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+      if (firstRenderPhaseUpdate !== undefined) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        renderPhaseUpdates.delete(queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+        let newState = workInProgressHook.memoizedState;
+        let update = firstRenderPhaseUpdate;
+
+        do {
+          // Process this render phase update. We don't have to check the
+          // priority because it will always be the same as the current
+          // render's.
+          const action = update.action;
+
+          newState = reducer(newState, action);
+
+
+          update = update.next;
+        } while (update !== null); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+        workInProgressHook.memoizedState = newState;
+        return [newState, dispatch];
+      }
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    return [workInProgressHook.memoizedState, dispatch];
+  } else {
+
+    let initialState;
+
+    if (reducer === basicStateReducer) {
+      // Special case for `useState`.
+      initialState = typeof initialArg === 'function' ? initialArg() : initialArg;
+    } else {
+      initialState = init !== undefined ? init(initialArg) : initialArg;
+    }
+
+
+    workInProgressHook.memoizedState = initialState; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    const queue = workInProgressHook.queue = {
+      last: null,
+      dispatch: null
+    };
+    const dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingComponent, queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    return [workInProgressHook.memoizedState, dispatch];
+  }
+}
+
+function useMemo(nextCreate, deps) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+
+  if (workInProgressHook !== null) {
+    const prevState = workInProgressHook.memoizedState;
+
+    if (prevState !== null) {
+      if (nextDeps !== null) {
+        const prevDeps = prevState[1];
+
+        if (areHookInputsEqual(nextDeps, prevDeps)) {
+          return prevState[0];
+        }
+      }
+    }
+  }
+
+  const nextValue = nextCreate();
+
+
+  workInProgressHook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
+
+function useRef(initialValue) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const previousRef = workInProgressHook.memoizedState;
+
+  if (previousRef === null) {
+    const ref = {
+      current: initialValue
+    };
+
+
+    workInProgressHook.memoizedState = ref;
+    return ref;
+  } else {
+    return previousRef;
+  }
+}
+
+function dispatchAction(componentIdentity, queue, action) {
+  if (numberOfReRenders >= RE_RENDER_LIMIT) {
+    throw Error(formatProdErrorMessage(301));
+  }
+
+  if (componentIdentity === currentlyRenderingComponent) {
+    // This is a render phase update. Stash it in a lazily-created map of
+    // queue -> linked list of updates. After this render pass, we'll restart
+    // and apply the stashed updates on top of the work-in-progress hook.
+    didScheduleRenderPhaseUpdate = true;
+    const update = {
+      action,
+      next: null
+    };
+
+    if (renderPhaseUpdates === null) {
+      renderPhaseUpdates = new Map();
+    }
+
+    const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+    if (firstRenderPhaseUpdate === undefined) {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      renderPhaseUpdates.set(queue, update);
+    } else {
+      // Append the update to the end of the list.
+      let lastRenderPhaseUpdate = firstRenderPhaseUpdate;
+
+      while (lastRenderPhaseUpdate.next !== null) {
+        lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+      }
+
+      lastRenderPhaseUpdate.next = update;
+    }
+  }
+}
+
+function useCallback(callback, deps) {
+  return useMemo(() => callback, deps);
+}
+
+function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  if (getServerSnapshot === undefined) {
+    throw Error(formatProdErrorMessage(407));
+  }
+
+  return getServerSnapshot();
+}
+
+function useDeferredValue(value, initialValue) {
+  resolveCurrentlyRenderingComponent();
+
+  {
+    return value;
+  }
+}
+
+function unsupportedStartTransition() {
+  throw Error(formatProdErrorMessage(394));
+}
+
+function useTransition() {
+  resolveCurrentlyRenderingComponent();
+  return [false, unsupportedStartTransition];
+}
+
+function useHostTransitionStatus() {
+  resolveCurrentlyRenderingComponent();
+  return NotPendingTransition;
+}
+
+function unsupportedSetOptimisticState() {
+  throw Error(formatProdErrorMessage(479));
+}
+
+function useOptimistic(passthrough, reducer) {
+  resolveCurrentlyRenderingComponent();
+  return [passthrough, unsupportedSetOptimisticState];
+}
+
+function createPostbackFormStateKey(permalink, componentKeyPath, hookIndex) {
+  if (permalink !== undefined) {
+    // Don't bother to hash a permalink-based key since it's already short.
+    return 'p' + permalink;
+  } else {
+    // Append a node to the key path that represents the form state hook.
+    const keyPath = [componentKeyPath, null, hookIndex]; // Key paths are hashed to reduce the size. It does not need to be secure,
+    // and it's more important that it's fast than that it's completely
+    // collision-free.
+
+    const keyPathHash = createFastHashJS(JSON.stringify(keyPath));
+    return 'k' + keyPathHash;
+  }
+}
+
+function useFormState(action, initialState, permalink) {
+  resolveCurrentlyRenderingComponent(); // Count the number of useFormState hooks per component. We also use this to
+  // track the position of this useFormState hook relative to the other ones in
+  // this component, so we can generate a unique key for each one.
+
+  const formStateHookIndex = formStateCounter++;
+  const request = currentlyRenderingRequest; // $FlowIgnore[prop-missing]
+
+  const formAction = action.$$FORM_ACTION;
+
+  if (typeof formAction === 'function') {
+    // This is a server action. These have additional features to enable
+    // MPA-style form submissions with progressive enhancement.
+    // TODO: If the same permalink is passed to multiple useFormStates, and
+    // they all have the same action signature, Fizz will pass the postback
+    // state to all of them. We should probably only pass it to the first one,
+    // and/or warn.
+    // The key is lazily generated and deduped so the that the keypath doesn't
+    // get JSON.stringify-ed unnecessarily, and at most once.
+    let nextPostbackStateKey = null; // Determine the current form state. If we received state during an MPA form
+    // submission, then we will reuse that, if the action identity matches.
+    // Otherwise we'll use the initial state argument. We will emit a comment
+    // marker into the stream that indicates whether the state was reused.
+
+    let state = initialState;
+    const componentKeyPath = currentlyRenderingKeyPath;
+    const postbackFormState = getFormState(request); // $FlowIgnore[prop-missing]
+
+    const isSignatureEqual = action.$$IS_SIGNATURE_EQUAL;
+
+    if (postbackFormState !== null && typeof isSignatureEqual === 'function') {
+      const postbackKey = postbackFormState[1];
+      const postbackReferenceId = postbackFormState[2];
+      const postbackBoundArity = postbackFormState[3];
+
+      if (isSignatureEqual.call(action, postbackReferenceId, postbackBoundArity)) {
+        nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+
+        if (postbackKey === nextPostbackStateKey) {
+          // This was a match
+          formStateMatchingIndex = formStateHookIndex; // Reuse the state that was submitted by the form.
+
+          state = postbackFormState[0];
+        }
+      }
+    } // Bind the state to the first argument of the action.
+
+
+    const boundAction = action.bind(null, state); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    }; // $FlowIgnore[prop-missing]
+
+
+    if (typeof boundAction.$$FORM_ACTION === 'function') {
+      // $FlowIgnore[prop-missing]
+      dispatch.$$FORM_ACTION = prefix => {
+        const metadata = boundAction.$$FORM_ACTION(prefix); // Override the action URL
+
+        if (permalink !== undefined) {
+
+          permalink += '';
+          metadata.action = permalink;
+        }
+
+        const formData = metadata.data;
+
+        if (formData) {
+          if (nextPostbackStateKey === null) {
+            nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+          }
+
+          formData.append('$ACTION_KEY', nextPostbackStateKey);
+        }
+
+        return metadata;
+      };
+    }
+
+    return [state, dispatch];
+  } else {
+    // This is not a server action, so the implementation is much simpler.
+    // Bind the state to the first argument of the action.
+    const boundAction = action.bind(null, initialState); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    };
+
+    return [initialState, dispatch];
+  }
+}
+
+function useId() {
+  const task = currentlyRenderingTask;
+  const treeId = getTreeId(task.treeContext);
+  const resumableState = currentResumableState;
+
+  if (resumableState === null) {
+    throw Error(formatProdErrorMessage(404));
+  }
+
+  const localId = localIdCounter++;
+  return makeId(resumableState, treeId, localId);
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable;
+      return unwrapThenable(thenable);
+    } else if (usable.$$typeof === REACT_CONTEXT_TYPE || usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+  throw Error(formatProdErrorMessage(438, String(usable)));
+}
+
+function unwrapThenable(thenable) {
+  const index = thenableIndexCounter;
+  thenableIndexCounter += 1;
+
+  if (thenableState === null) {
+    thenableState = createThenableState();
+  }
+
+  return trackUsedThenable(thenableState, thenable, index);
+}
+
+function unsupportedRefresh() {
+  throw Error(formatProdErrorMessage(393));
+}
+
+function useCacheRefresh() {
+  return unsupportedRefresh;
+}
+
+function noop$1() {}
+
+const HooksDispatcher = {
+  readContext,
+  use,
+  useContext,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+  useInsertionEffect: noop$1,
+  useLayoutEffect: noop$1,
+  useCallback,
+  // useImperativeHandle is not run in the server environment
+  useImperativeHandle: noop$1,
+  // Effects are not run in the server environment.
+  useEffect: noop$1,
+  // Debugging effect
+  useDebugValue: noop$1,
+  useDeferredValue,
+  useTransition,
+  useId,
+  // Subscriptions are not setup in a server environment.
+  useSyncExternalStore
+};
+
+{
+  HooksDispatcher.useCacheRefresh = useCacheRefresh;
+}
+
+{
+  HooksDispatcher.useHostTransitionStatus = useHostTransitionStatus;
+}
+
+{
+  HooksDispatcher.useOptimistic = useOptimistic;
+  HooksDispatcher.useFormState = useFormState;
+}
+
+let currentResumableState = null;
+function setCurrentResumableState(resumableState) {
+  currentResumableState = resumableState;
+}
+
+function getCacheSignal() {
+  throw Error(formatProdErrorMessage(248));
+}
+
+function getCacheForType(resourceType) {
+  throw Error(formatProdErrorMessage(248));
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal,
+  getCacheForType
+};
+
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+const ReactCurrentCache = ReactSharedInternals.ReactCurrentCache;
+// The name might be minified but we assume that it's going to be the same generated name. Typically
+// because it's just the same compiled output in practice.
+// resume with segmentID at the index
+
+const CLIENT_RENDERED = 4; // if it errors or infinitely suspends
+
+const PENDING = 0;
+const COMPLETED = 1;
+const FLUSHED = 2;
+const ABORTED = 3;
+const ERRORED = 4;
+const POSTPONED = 5;
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2; // This is a default heuristic for how to split up the HTML content into progressive
+// loading. Our goal is to be able to display additional new content about every 500ms.
+// Faster than that is unnecessary and should be throttled on the client. It also
+// adds unnecessary overhead to do more splits. We don't know if it's a higher or lower
+// end device but higher end suffer less from the overhead than lower end does from
+// not getting small enough pieces. We error on the side of low end.
+// We base this on low end 3G speeds which is about 500kbits per second. We assume
+// that there can be a reasonable drop off from max bandwidth which leaves you with
+// as little as 80%. We can receive half of that each 500ms - at best. In practice,
+// a little bandwidth is lost to processing and contention - e.g. CSS and images that
+// are downloaded along with the main content. So we estimate about half of that to be
+// the lower end throughput. In other words, we expect that you can at least show
+// about 12.5kb of content per 500ms. Not counting starting latency for the first
+// paint.
+// 500 * 1024 / 8 * .8 * 0.5 / 2
+
+const DEFAULT_PROGRESSIVE_CHUNK_SIZE = 12800;
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+
+  return null;
+}
+
+function noop() {}
+
+function createRequest(children, resumableState, renderState, rootFormatContext, progressiveChunkSize, onError, onAllReady, onShellReady, onShellError, onFatalError, onPostpone, formState) {
+  prepareHostDispatcher();
+  const pingedTasks = [];
+  const abortSet = new Set();
+  const request = {
+    destination: null,
+    flushScheduled: false,
+    resumableState,
+    renderState,
+    rootFormatContext,
+    progressiveChunkSize: progressiveChunkSize === undefined ? DEFAULT_PROGRESSIVE_CHUNK_SIZE : progressiveChunkSize,
+    status: OPEN,
+    fatalError: null,
+    nextSegmentId: 0,
+    allPendingTasks: 0,
+    pendingRootTasks: 0,
+    completedRootSegment: null,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    clientRenderedBoundaries: [],
+    completedBoundaries: [],
+    partialBoundaries: [],
+    trackedPostpones: null,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? noop : onPostpone,
+    onAllReady: onAllReady === undefined ? noop : onAllReady,
+    onShellReady: onShellReady === undefined ? noop : onShellReady,
+    onShellError: onShellError === undefined ? noop : onShellError,
+    onFatalError: onFatalError === undefined ? noop : onFatalError,
+    formState: formState === undefined ? null : formState
+  }; // This segment represents the root fallback.
+
+  const rootSegment = createPendingSegment(request, 0, null, rootFormatContext, // Root segments are never embedded in Text on either edge
+  false, false); // There is no parent so conceptually, we're unblocked to flush this segment.
+
+  rootSegment.parentFlushed = true;
+  const rootTask = createRenderTask(request, null, children, -1, null, rootSegment, abortSet, null, rootFormatContext, emptyContextObject, rootContextSnapshot, emptyTreeContext);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  return null;
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (request.pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createSuspenseBoundary(request, fallbackAbortableTasks) {
+  return {
+    status: PENDING,
+    rootSegmentID: -1,
+    parentFlushed: false,
+    pendingTasks: 0,
+    completedSegments: [],
+    byteSize: 0,
+    fallbackAbortableTasks,
+    errorDigest: null,
+    resources: createBoundaryResources(),
+    trackedContentKeyPath: null,
+    trackedFallbackNode: null
+  };
+}
+
+function createRenderTask(request, thenableState, node, childIndex, blockedBoundary, blockedSegment, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  const task = {
+    replay: null,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createReplayTask(request, thenableState, replay, node, childIndex, blockedBoundary, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  replay.pendingTasks++;
+  const task = {
+    replay,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment: null,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createPendingSegment(request, index, boundary, parentFormatContext, lastPushedText, textEmbedded) {
+  return {
+    status: PENDING,
+    id: -1,
+    // lazily assigned later
+    index,
+    parentFlushed: false,
+    chunks: [],
+    children: [],
+    parentFormatContext,
+    boundary,
+    lastPushedText,
+    textEmbedded
+  };
+} // DEV-only global reference to the currently executing task
+
+function popComponentStackInDEV(task) {
+} // stash the component stack of an unwinding error until it is processed
+
+function logRecoverableError(request, error) {
+  // If this callback errors, we intentionally let that error bubble up to become a fatal error
+  // so that someone fixes the error reporting instead of hiding it.
+  const errorDigest = request.onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest;
+}
+
+function fatalError(request, error) {
+  // This is called outside error handling code such as if the root errors outside
+  // a suspense boundary or if the root suspense boundary's fallback errors.
+  // It's also called if React itself or its host configs errors.
+  const onShellError = request.onShellError;
+  onShellError(error);
+  const onFatalError = request.onFatalError;
+  onFatalError(error);
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function renderSuspenseBoundary(request, someTask, keyPath, props) {
+  if (someTask.replay !== null) {
+    // If we're replaying through this pass, it means we're replaying through
+    // an already completed Suspense boundary. It's too late to do anything about it
+    // so we can just render through it.
+    const prevKeyPath = someTask.keyPath;
+    someTask.keyPath = keyPath;
+    const content = props.children;
+
+    try {
+      renderNode(request, someTask, content, -1);
+    } finally {
+      someTask.keyPath = prevKeyPath;
+    }
+
+    return;
+  } // $FlowFixMe: Refined.
+
+
+  const task = someTask;
+  const prevKeyPath = task.keyPath;
+  const parentBoundary = task.blockedBoundary;
+  const parentSegment = task.blockedSegment; // Each time we enter a suspense boundary, we split out into a new segment for
+  // the fallback so that we can later replace that segment with the content.
+  // This also lets us split out the main content even if it doesn't suspend,
+  // in case it ends up generating a large subtree of content.
+
+  const fallback = props.fallback;
+  const content = props.children;
+  const fallbackAbortSet = new Set();
+  const newBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+
+  if (request.trackedPostpones !== null) {
+    newBoundary.trackedContentKeyPath = keyPath;
+  }
+
+  const insertionIndex = parentSegment.chunks.length; // The children of the boundary segment is actually the fallback.
+
+  const boundarySegment = createPendingSegment(request, insertionIndex, newBoundary, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false);
+  parentSegment.children.push(boundarySegment); // The parentSegment has a child Segment at this index so we reset the lastPushedText marker on the parent
+
+  parentSegment.lastPushedText = false; // This segment is the actual child content. We can start rendering that immediately.
+
+  const contentRootSegment = createPendingSegment(request, 0, null, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false); // We mark the root segment as having its parent flushed. It's not really flushed but there is
+  // no parent segment so there's nothing to wait on.
+
+  contentRootSegment.parentFlushed = true; // Currently this is running synchronously. We could instead schedule this to pingedTasks.
+  // I suspect that there might be some efficiency benefits from not creating the suspended task
+  // and instead just using the stack if possible.
+  // TODO: Call this directly instead of messing with saving and restoring contexts.
+  // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and which segment
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = newBoundary;
+  task.blockedSegment = contentRootSegment;
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, newBoundary.resources);
+  }
+
+  task.keyPath = keyPath;
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+    pushSegmentFinale(contentRootSegment.chunks, request.renderState, contentRootSegment.lastPushedText, contentRootSegment.textEmbedded);
+    contentRootSegment.status = COMPLETED;
+    queueCompletedSegment(newBoundary, contentRootSegment);
+
+    if (newBoundary.pendingTasks === 0 && newBoundary.status === PENDING) {
+      newBoundary.status = COMPLETED; // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    contentRootSegment.status = ERRORED;
+    newBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    newBoundary.errorDigest = errorDigest;
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.blockedSegment = parentSegment;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]];
+  const trackedPostpones = request.trackedPostpones;
+
+  if (trackedPostpones !== null) {
+    // We create a detached replay node to track any postpones inside the fallback.
+    const fallbackReplayNode = [fallbackKeyPath[1], fallbackKeyPath[2], [], null];
+    trackedPostpones.workingMap.set(fallbackKeyPath, fallbackReplayNode);
+
+    if (newBoundary.status === POSTPONED) {
+      // This must exist now.
+      const boundaryReplayNode = trackedPostpones.workingMap.get(keyPath);
+      boundaryReplayNode[4] = fallbackReplayNode;
+    } else {
+      // We might not inject it into the postponed tree, unless the content actually
+      // postpones too. We need to keep track of it until that happpens.
+      newBoundary.trackedFallbackNode = fallbackReplayNode;
+    }
+  } // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+
+  const suspendedFallbackTask = createRenderTask(request, null, fallback, -1, parentBoundary, boundarySegment, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function replaySuspenseBoundary(request, task, keyPath, props, id, childNodes, childSlots, fallbackNodes, fallbackSlots) {
+  const prevKeyPath = task.keyPath;
+  const previousReplaySet = task.replay;
+  const parentBoundary = task.blockedBoundary;
+  const content = props.children;
+  const fallback = props.fallback;
+  const fallbackAbortSet = new Set();
+  const resumedBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = id; // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and replay node
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = resumedBoundary;
+  task.replay = {
+    nodes: childNodes,
+    slots: childSlots,
+    pendingTasks: 1
+  };
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, resumedBoundary.resources);
+  }
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw Error(formatProdErrorMessage(488));
+    }
+
+    task.replay.pendingTasks--;
+
+    if (resumedBoundary.pendingTasks === 0 && resumedBoundary.status === PENDING) {
+      resumedBoundary.status = COMPLETED;
+      request.completedBoundaries.push(resumedBoundary); // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    resumedBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    resumedBoundary.errorDigest = errorDigest;
+
+    task.replay.pendingTasks--; // The parent already flushed in the prerender so we need to schedule this to be emitted.
+
+    request.clientRenderedBoundaries.push(resumedBoundary); // We don't need to decrement any task numbers because we didn't spawn any new task.
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.replay = previousReplaySet;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]]; // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+  const fallbackReplay = {
+    nodes: fallbackNodes,
+    slots: fallbackSlots,
+    pendingTasks: 0
+  };
+  const suspendedFallbackTask = createReplayTask(request, null, fallbackReplay, fallback, -1, parentBoundary, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function renderHostElement(request, task, keyPath, type, props) {
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    const children = props.children; // TODO: Make this a Config for replaying.
+
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+  } else {
+    // Render
+    const children = pushStartInstance(segment.chunks, type, props, request.resumableState, request.renderState, task.formatContext, segment.lastPushedText);
+    segment.lastPushedText = false;
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+    pushEndInstance(segment.chunks, type, props, request.resumableState, prevContext);
+    segment.lastPushedText = false;
+  }
+}
+
+function shouldConstruct(Component) {
+  return Component.prototype && Component.prototype.isReactComponent;
+}
+
+function renderWithHooks(request, task, keyPath, prevThenableState, Component, props, secondArg) {
+  const componentIdentity = {};
+  prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState);
+  const result = Component(props, secondArg);
+  return finishHooks(Component, props, result, secondArg);
+}
+
+function finishClassComponent(request, task, keyPath, instance, Component, props) {
+  const nextChildren = instance.render();
+
+  {
+    const childContextTypes = Component.childContextTypes;
+
+    if (childContextTypes !== null && childContextTypes !== undefined) {
+      const previousContext = task.legacyContext;
+      const mergedContext = processChildContext(instance, Component, previousContext, childContextTypes);
+      task.legacyContext = mergedContext;
+      renderNodeDestructive(request, task, null, nextChildren, -1);
+      task.legacyContext = previousContext;
+      return;
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, nextChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderClassComponent(request, task, keyPath, Component, props) {
+  const maskedContext = getMaskedContext(Component, task.legacyContext) ;
+  const instance = constructClassInstance(Component, props, maskedContext);
+  mountClassInstance(instance, Component, props, maskedContext);
+  finishClassComponent(request, task, keyPath, instance, Component);
+}
+// components for some reason.
+
+function renderIndeterminateComponent(request, task, keyPath, prevThenableState, Component, props) {
+  let legacyContext;
+
+  {
+    legacyContext = getMaskedContext(Component, task.legacyContext);
+  }
+
+  const value = renderWithHooks(request, task, keyPath, prevThenableState, Component, props, legacyContext);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+
+  if ( // Run these checks in production only if the flag is off.
+  // Eventually we'll delete this branch altogether.
+  typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) {
+
+    mountClassInstance(value, Component, props, legacyContext);
+    finishClassComponent(request, task, keyPath, value, Component);
+  } else {
+
+    finishFunctionComponent(request, task, keyPath, value, hasId, formStateCount, formStateMatchingIndex);
+  }
+}
+
+function finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex) {
+  let didEmitFormStateMarkers = false;
+
+  if (formStateCount !== 0 && request.formState !== null) {
+    // For each useFormState hook, emit a marker that indicates whether we
+    // rendered using the form state passed at the root. We only emit these
+    // markers if form state is passed at the root.
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      didEmitFormStateMarkers = true;
+      const target = segment.chunks;
+
+      for (let i = 0; i < formStateCount; i++) {
+        if (i === formStateMatchingIndex) {
+          pushFormStateMarkerIsMatching(target);
+        } else {
+          pushFormStateMarkerIsNotMatching(target);
+        }
+      }
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+
+  if (hasId) {
+    // This component materialized an id. We treat this as its own level, with
+    // a single "child" slot.
+    const prevTreeContext = task.treeContext;
+    const totalChildren = 1;
+    const index = 0; // Modify the id context. Because we'll need to reset this if something
+    // suspends or errors, we'll use the non-destructive render path.
+
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, index);
+    renderNode(request, task, children, -1); // Like the other contexts, this does not need to be in a finally block
+    // because renderNode takes care of unwinding the stack.
+
+    task.treeContext = prevTreeContext;
+  } else if (didEmitFormStateMarkers) {
+    // If there were formState hooks, we must use the non-destructive path
+    // because this component is not a pure indirection; we emitted markers
+    // to the stream.
+    renderNode(request, task, children, -1);
+  } else {
+    // We're now successfully past this task, and we haven't modified the
+    // context stack. We don't have to pop back to the previous task every
+    // again, so we can use the destructive recursive form.
+    renderNodeDestructive(request, task, null, children, -1);
+  }
+
+  task.keyPath = prevKeyPath;
+}
+
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    // Resolve default props. Taken from ReactElement
+    const props = assign({}, baseProps);
+    const defaultProps = Component.defaultProps;
+
+    for (const propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+
+    return props;
+  }
+
+  return baseProps;
+}
+
+function renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref) {
+  const children = renderWithHooks(request, task, keyPath, prevThenableState, type.render, props, ref);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+  finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex);
+}
+
+function renderMemo(request, task, keyPath, prevThenableState, type, props, ref) {
+  const innerType = type.type;
+  const resolvedProps = resolveDefaultProps(innerType, props);
+  renderElement(request, task, keyPath, prevThenableState, innerType, resolvedProps, ref);
+}
+
+function renderContextConsumer(request, task, keyPath, context, props) {
+
+  const render = props.children;
+
+  const newValue = readContext$1(context);
+  const newChildren = render(newValue);
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, newChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderContextProvider(request, task, keyPath, type, props) {
+  const context = type._context;
+  const value = props.value;
+  const children = props.children;
+
+  const prevKeyPath = task.keyPath;
+  task.context = pushProvider(context, value);
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, children, -1);
+  task.context = popProvider();
+  task.keyPath = prevKeyPath;
+}
+
+function renderLazyComponent(request, task, keyPath, prevThenableState, lazyComponent, props, ref) {
+  const payload = lazyComponent._payload;
+  const init = lazyComponent._init;
+  const Component = init(payload);
+  const resolvedProps = resolveDefaultProps(Component, props);
+  renderElement(request, task, keyPath, prevThenableState, Component, resolvedProps, ref);
+}
+
+function renderOffscreen(request, task, keyPath, props) {
+  const mode = props.mode;
+
+  if (mode === 'hidden') ; else {
+    // A visible Offscreen boundary is treated exactly like a fragment: a
+    // pure indirection.
+    const prevKeyPath = task.keyPath;
+    task.keyPath = keyPath;
+    renderNodeDestructive(request, task, null, props.children, -1);
+    task.keyPath = prevKeyPath;
+  }
+}
+
+function renderElement(request, task, keyPath, prevThenableState, type, props, ref) {
+  if (typeof type === 'function') {
+    if (shouldConstruct(type)) {
+      renderClassComponent(request, task, keyPath, type, props);
+      return;
+    } else {
+      renderIndeterminateComponent(request, task, keyPath, prevThenableState, type, props);
+      return;
+    }
+  }
+
+  if (typeof type === 'string') {
+    renderHostElement(request, task, keyPath, type, props);
+    return;
+  }
+
+  switch (type) {
+    // LegacyHidden acts the same as a fragment. This only works because we
+    // currently assume that every instance of LegacyHidden is accompanied by a
+    // host component wrapper. In the hidden mode, the host component is given a
+    // `hidden` attribute, which ensures that the initial HTML is not visible.
+    // To support the use of LegacyHidden as a true fragment, without an extra
+    // DOM node, we would have to hide the initial HTML in some other way.
+    // TODO: Delete in LegacyHidden. It's an unstable API only used in the
+    // www build. As a migration step, we could add a special prop to Offscreen
+    // that simulates the old behavior (no hiding, no change to effects).
+    case REACT_LEGACY_HIDDEN_TYPE:
+    case REACT_DEBUG_TRACING_MODE_TYPE:
+    case REACT_STRICT_MODE_TYPE:
+    case REACT_PROFILER_TYPE:
+    case REACT_FRAGMENT_TYPE:
+      {
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_OFFSCREEN_TYPE:
+      {
+        renderOffscreen(request, task, keyPath, props);
+        return;
+      }
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      {
+
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_SCOPE_TYPE:
+      {
+
+        throw Error(formatProdErrorMessage(343));
+      }
+
+    case REACT_SUSPENSE_TYPE:
+      {
+        {
+          renderSuspenseBoundary(request, task, keyPath, props);
+        }
+
+        return;
+      }
+  }
+
+  if (typeof type === 'object' && type !== null) {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        {
+          renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          renderMemo(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_PROVIDER_TYPE:
+        {
+          renderContextProvider(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_CONTEXT_TYPE:
+        {
+          renderContextConsumer(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_LAZY_TYPE:
+        {
+          renderLazyComponent(request, task, keyPath, prevThenableState, type, props);
+          return;
+        }
+    }
+  }
+
+  let info = '';
+
+  throw Error(formatProdErrorMessage(130, type == null ? type : typeof type, info));
+}
+
+function resumeNode(request, task, segmentId, node, childIndex) {
+  const prevReplay = task.replay;
+  const blockedBoundary = task.blockedBoundary;
+  const resumedSegment = createPendingSegment(request, 0, null, task.formatContext, false, false);
+  resumedSegment.id = segmentId;
+  resumedSegment.parentFlushed = true;
+
+  try {
+    // Convert the current ReplayTask to a RenderTask.
+    const renderTask = task;
+    renderTask.replay = null;
+    renderTask.blockedSegment = resumedSegment;
+    renderNode(request, task, node, childIndex);
+    resumedSegment.status = COMPLETED;
+
+    if (blockedBoundary === null) {
+      request.completedRootSegment = resumedSegment;
+    } else {
+      queueCompletedSegment(blockedBoundary, resumedSegment);
+
+      if (blockedBoundary.parentFlushed) {
+        request.partialBoundaries.push(blockedBoundary);
+      }
+    }
+  } finally {
+    // Restore to a ReplayTask.
+    task.replay = prevReplay;
+    task.blockedSegment = null;
+  }
+}
+
+function replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, replay) {
+  // We're replaying. Find the path to follow.
+  const replayNodes = replay.nodes;
+
+  for (let i = 0; i < replayNodes.length; i++) {
+    // Flow doesn't support refinement on tuples so we do it manually here.
+    const node = replayNodes[i];
+
+    if (keyOrIndex !== node[1]) {
+      continue;
+    }
+
+    if (node.length === 4) {
+      // Matched a replayable path.
+      // Let's double check that the component name matches as a precaution.
+      if (name !== null && name !== node[0]) {
+        throw Error(formatProdErrorMessage(490, node[0], name));
+      }
+
+      const childNodes = node[2];
+      const childSlots = node[3];
+      const currentNode = task.node;
+      task.replay = {
+        nodes: childNodes,
+        slots: childSlots,
+        pendingTasks: 1
+      };
+
+      try {
+        renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+
+        if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0 // TODO check remaining slots
+        ) {
+            throw Error(formatProdErrorMessage(488));
+          }
+
+        task.replay.pendingTasks--;
+      } catch (x) {
+        if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+          // Suspend
+          if (task.node === currentNode) {
+            // This same element suspended so we need to pop the replay we just added.
+            task.replay = replay;
+          }
+
+          throw x;
+        }
+
+        task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+        // during a replay. That's because this component didn't actually error
+        // in the original prerender. What's unable to complete is the child
+        // replay nodes which might be Suspense boundaries which are able to
+        // absorb the error and we can still continue with siblings.
+
+        erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+      }
+
+      task.replay = replay;
+    } else {
+      // Let's double check that the component type matches.
+      if (type !== REACT_SUSPENSE_TYPE) {
+        const expectedType = 'Suspense';
+        throw Error(formatProdErrorMessage(490, expectedType, getComponentNameFromType(type) || 'Unknown'));
+      } // Matched a replayable path.
+
+
+      replaySuspenseBoundary(request, task, keyPath, props, node[5], node[2], node[3], node[4] === null ? [] : node[4][2], node[4] === null ? null : node[4][3]);
+    } // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+
+    replayNodes.splice(i, 1);
+    return;
+  } // We didn't find any matching nodes. We assume that this element was already
+  // rendered in the prelude and skip it.
+
+} // $FlowFixMe[missing-local-annot]
+
+function renderNodeDestructive(request, task, // The thenable state reused from the previous attempt, if any. This is almost
+// always null, except when called by retryTask.
+prevThenableState, node, childIndex) {
+  {
+    return renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex);
+  }
+} // This function by it self renders a node and consumes the task by mutating it
+// to update the current execution state.
+
+
+function renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex) {
+  if (task.replay !== null && typeof task.replay.slots === 'number') {
+    // TODO: Figure out a cheaper place than this hot path to do this check.
+    const resumeSegmentID = task.replay.slots;
+    resumeNode(request, task, resumeSegmentID, node, childIndex);
+    return;
+  } // Stash the node we're working on. We'll pick up from this task in case
+  // something suspends.
+
+
+  task.node = node;
+  task.childIndex = childIndex; // Handle object types
+
+  if (typeof node === 'object' && node !== null) {
+    switch (node.$$typeof) {
+      case REACT_ELEMENT_TYPE:
+        {
+          const element = node;
+          const type = element.type;
+          const key = element.key;
+          const props = element.props;
+          const ref = element.ref;
+          const name = getComponentNameFromType(type);
+          const keyOrIndex = key == null ? childIndex === -1 ? 0 : childIndex : key;
+          const keyPath = [task.keyPath, name, keyOrIndex];
+
+          if (task.replay !== null) {
+            replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, task.replay); // No matches found for this node. We assume it's already emitted in the
+            // prelude and skip it during the replay.
+          } else {
+            // We're doing a plain render.
+            renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+          }
+
+          return;
+        }
+
+      case REACT_PORTAL_TYPE:
+        throw Error(formatProdErrorMessage(257));
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyNode = node;
+          const payload = lazyNode._payload;
+          const init = lazyNode._init;
+          let resolvedNode;
+
+          {
+            resolvedNode = init(payload);
+          }
+
+          renderNodeDestructive(request, task, null, resolvedNode, childIndex);
+          return;
+        }
+    }
+
+    if (isArray(node)) {
+      renderChildrenArray(request, task, node, childIndex);
+      return;
+    }
+
+    const iteratorFn = getIteratorFn(node);
+
+    if (iteratorFn) {
+
+      const iterator = iteratorFn.call(node);
+
+      if (iterator) {
+        // We need to know how many total children are in this set, so that we
+        // can allocate enough id slots to acommodate them. So we must exhaust
+        // the iterator before we start recursively rendering the children.
+        // TODO: This is not great but I think it's inherent to the id
+        // generation algorithm.
+        let step = iterator.next(); // If there are not entries, we need to push an empty so we start by checking that.
+
+        if (!step.done) {
+          const children = [];
+
+          do {
+            children.push(step.value);
+            step = iterator.next();
+          } while (!step.done);
+
+          renderChildrenArray(request, task, children, childIndex);
+          return;
+        }
+
+        return;
+      }
+    } // Usables are a valid React node type. When React encounters a Usable in
+    // a child position, it unwraps it using the same algorithm as `use`. For
+    // example, for promises, React will throw an exception to unwind the
+    // stack, then replay the component once the promise resolves.
+    //
+    // A difference from `use` is that React will keep unwrapping the value
+    // until it reaches a non-Usable type.
+    //
+    // e.g. Usable<Usable<Usable<T>>> should resolve to T
+
+
+    const maybeUsable = node;
+
+    if (typeof maybeUsable.then === 'function') {
+      const thenable = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, unwrapThenable(thenable), childIndex);
+    }
+
+    if (maybeUsable.$$typeof === REACT_CONTEXT_TYPE || maybeUsable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, readContext$1(context), childIndex);
+    } // $FlowFixMe[method-unbinding]
+
+
+    const childString = Object.prototype.toString.call(node);
+    throw Error(formatProdErrorMessage(31, childString === '[object Object]' ? 'object with keys {' + Object.keys(node).join(', ') + '}' : childString));
+  }
+
+  if (typeof node === 'string') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+
+  if (typeof node === 'number') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, '' + node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+}
+
+function replayFragment(request, task, children, childIndex) {
+  // If we're supposed follow this array, we'd expect to see a ReplayNode matching
+  // this fragment.
+  const replay = task.replay;
+  const replayNodes = replay.nodes;
+
+  for (let j = 0; j < replayNodes.length; j++) {
+    const node = replayNodes[j];
+
+    if (node[1] !== childIndex) {
+      continue;
+    } // Matched a replayable path.
+
+
+    const childNodes = node[2];
+    const childSlots = node[3];
+    task.replay = {
+      nodes: childNodes,
+      slots: childSlots,
+      pendingTasks: 1
+    };
+
+    try {
+      renderChildrenArray(request, task, children, -1);
+
+      if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+        throw Error(formatProdErrorMessage(488));
+      }
+
+      task.replay.pendingTasks--;
+    } catch (x) {
+      if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+        // Suspend
+        throw x;
+      }
+
+      task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+      // during a replay. That's because this component didn't actually error
+      // in the original prerender. What's unable to complete is the child
+      // replay nodes which might be Suspense boundaries which are able to
+      // absorb the error and we can still continue with siblings.
+      // This is an error, stash the component stack if it is null.
+
+      erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+    }
+
+    task.replay = replay; // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+    replayNodes.splice(j, 1);
+    break;
+  }
+}
+
+function renderChildrenArray(request, task, children, childIndex) {
+  const prevKeyPath = task.keyPath;
+
+  if (childIndex !== -1) {
+    task.keyPath = [task.keyPath, 'Fragment', childIndex];
+
+    if (task.replay !== null) {
+      replayFragment(request, // $FlowFixMe: Refined.
+      task, children, childIndex);
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  const prevTreeContext = task.treeContext;
+  const totalChildren = children.length;
+
+  if (task.replay !== null) {
+    // Replay
+    // First we need to check if we have any resume slots at this level.
+    const resumeSlots = task.replay.slots;
+
+    if (resumeSlots !== null && typeof resumeSlots === 'object') {
+      for (let i = 0; i < totalChildren; i++) {
+        const node = children[i];
+        task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+        // up and render the sibling if something suspends.
+
+        const resumeSegmentID = resumeSlots[i]; // TODO: If this errors we should still continue with the next sibling.
+
+        if (typeof resumeSegmentID === 'number') {
+          resumeNode(request, task, resumeSegmentID, node, i); // We finished rendering this node, so now we can consume this
+          // slot. This must happen after in case we rerender this task.
+
+          delete resumeSlots[i];
+        } else {
+          renderNode(request, task, node, i);
+        }
+      }
+
+      task.treeContext = prevTreeContext;
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  for (let i = 0; i < totalChildren; i++) {
+    const node = children[i];
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+    // up and render the sibling if something suspends.
+
+    renderNode(request, task, node, i);
+  } // Because this context is always set right before rendering every child, we
+  // only need to reset it to the previous value at the very end.
+
+
+  task.treeContext = prevTreeContext;
+  task.keyPath = prevKeyPath;
+}
+
+function spawnNewSuspendedReplayTask(request, task, thenableState, x) {
+  const newTask = createReplayTask(request, thenableState, task.replay, task.node, task.childIndex, task.blockedBoundary, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+}
+
+function spawnNewSuspendedRenderTask(request, task, thenableState, x) {
+  // Something suspended, we'll need to create a new segment and resolve it later.
+  const segment = task.blockedSegment;
+  const insertionIndex = segment.chunks.length;
+  const newSegment = createPendingSegment(request, insertionIndex, null, task.formatContext, // Adopt the parent segment's leading text embed
+  segment.lastPushedText, // Assume we are text embedded at the trailing edge
+  true);
+  segment.children.push(newSegment); // Reset lastPushedText for current Segment since the new Segment "consumed" it
+
+  segment.lastPushedText = false;
+  const newTask = createRenderTask(request, thenableState, task.node, task.childIndex, task.blockedBoundary, newSegment, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+} // This is a non-destructive form of rendering a node. If it suspends it spawns
+// a new task and restores the context of this task to what it was before.
+
+
+function renderNode(request, task, node, childIndex) {
+  // Snapshot the current context in case something throws to interrupt the
+  // process.
+  const previousFormatContext = task.formatContext;
+  const previousLegacyContext = task.legacyContext;
+  const previousContext = task.context;
+  const previousKeyPath = task.keyPath;
+  const previousTreeContext = task.treeContext;
+
+  let x; // Store how much we've pushed at this point so we can reset it in case something
+  // suspended partially through writing something.
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState();
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedReplayTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+      } // TODO: Abort any undiscovered Suspense boundaries in the ReplayNode.
+
+    }
+  } else {
+    // Render
+    const childrenLength = segment.children.length;
+    const chunkLength = segment.chunks.length;
+
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState(); // Reset the write pointers to where we started.
+
+      segment.children.length = childrenLength;
+      segment.chunks.length = chunkLength;
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedRenderTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+      }
+    }
+  } // Restore the context. We assume that this will be restored by the inner
+  // functions in case nothing throws so we don't use "finally" here.
+
+
+  task.formatContext = previousFormatContext;
+  task.legacyContext = previousLegacyContext;
+  task.context = previousContext;
+  task.keyPath = previousKeyPath;
+  task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+  switchContext(previousContext);
+  // Let's terminate the rest of the tree and don't render any siblings.
+
+
+  throw x;
+}
+
+function erroredReplay(request, boundary, error, replayNodes, resumeSlots) {
+  // Erroring during a replay doesn't actually cause an error by itself because
+  // that component has already rendered. What causes the error is the resumable
+  // points that we did not yet finish which will be below the point of the reset.
+  // For example, if we're replaying a path to a Suspense boundary that is not done
+  // that doesn't error the parent Suspense boundary.
+  // This might be a bit strange that the error in a parent gets thrown at a child.
+  // We log it only once and reuse the digest.
+  let errorDigest;
+
+  {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  abortRemainingReplayNodes(request, boundary, replayNodes, resumeSlots, error, errorDigest);
+}
+
+function erroredTask(request, boundary, error) {
+  // Report the error to a global handler.
+  let errorDigest;
+
+  {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  if (boundary === null) {
+    fatalError(request, error);
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+      // so we can flush it, if the parent already flushed.
+
+
+      if (boundary.parentFlushed) {
+        // We don't have a preference where in the queue this goes since it's likely
+        // to error on the client anyway. However, intentionally client-rendered
+        // boundaries should be flushed earlier so that they can start on the client.
+        // We reuse the same queue for errors.
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function abortTaskSoft(task) {
+  // This aborts task without aborting the parent boundary that it blocks.
+  // It's used for when we didn't need this task to complete the tree.
+  // If task was needed, then it should use abortTask instead.
+  const request = this;
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+    finishedTask(request, boundary, segment);
+  }
+}
+
+function abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest) {
+  const resumedBoundary = createSuspenseBoundary(request, new Set());
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = rootSegmentID;
+  resumedBoundary.status = CLIENT_RENDERED;
+  resumedBoundary.errorDigest = errorDigest;
+
+  if (resumedBoundary.parentFlushed) {
+    request.clientRenderedBoundaries.push(resumedBoundary);
+  }
+}
+
+function abortRemainingReplayNodes(request, boundary, nodes, slots, error, errorDigest) {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+
+    if (node.length === 4) {
+      abortRemainingReplayNodes(request, boundary, node[2], node[3], error, errorDigest);
+    } else {
+      const boundaryNode = node;
+      const rootSegmentID = boundaryNode[5];
+      abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest);
+    }
+  } // Empty the set, since we've cleared it now.
+
+
+  nodes.length = 0;
+
+  if (slots !== null) {
+    // We had something still to resume in the parent boundary. We must trigger
+    // the error on the parent boundary since it's not able to complete.
+    if (boundary === null) {
+      throw Error(formatProdErrorMessage(487));
+    } else if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // Empty the set
+
+
+    if (typeof slots === 'object') {
+      for (const index in slots) {
+        delete slots[index];
+      }
+    }
+  }
+}
+
+function abortTask(task, request, error) {
+  // This aborts the task and aborts the parent that it blocks, putting it into
+  // client rendered mode.
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+  }
+
+  if (boundary === null) {
+    if (request.status !== CLOSING && request.status !== CLOSED) {
+      const replay = task.replay;
+
+      if (replay === null) {
+        // We didn't complete the root so we have nothing to show. We can close
+        // the request;
+        logRecoverableError(request, error);
+        fatalError(request, error);
+        return;
+      } else {
+        // If the shell aborts during a replay, that's not a fatal error. Instead
+        // we should be able to recover by client rendering all the root boundaries in
+        // the ReplaySet.
+        replay.pendingTasks--;
+
+        if (replay.pendingTasks === 0 && replay.nodes.length > 0) {
+          const errorDigest = logRecoverableError(request, error);
+          abortRemainingReplayNodes(request, null, replay.nodes, replay.slots, error, errorDigest);
+        }
+
+        request.pendingRootTasks--;
+
+        if (request.pendingRootTasks === 0) {
+          completeShell(request);
+        }
+      }
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = logRecoverableError(request, error);
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // If this boundary was still pending then we haven't already cancelled its fallbacks.
+    // We'll need to abort the fallbacks, which will also error that parent boundary.
+
+
+    boundary.fallbackAbortableTasks.forEach(fallbackTask => abortTask(fallbackTask, request, error));
+    boundary.fallbackAbortableTasks.clear();
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeShell(request) {
+  if (request.trackedPostpones === null) {
+    // We only emit early preloads on shell completion for renders. For prerenders
+    // we wait for the entire Request to finish because we are not responding to a
+    // live request and can wait for as much data as possible.
+    // we should only be calling completeShell when the shell is complete so we
+    // just use a literal here
+    const shellComplete = true;
+    emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  } // We have completed the shell so the shell can't error anymore.
+
+
+  request.onShellError = noop;
+  const onShellReady = request.onShellReady;
+  onShellReady();
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeAll(request) {
+  // During a render the shell must be complete if the entire request is finished
+  // however during a Prerender it is possible that the shell is incomplete because
+  // it postponed. We cannot use rootPendingTasks in the prerender case because
+  // those hit zero even when the shell postpones. Instead we look at the completedRootSegment
+  const shellComplete = request.trackedPostpones === null ? // Render, we assume it is completed
+  true : // Prerender Request, we use the state of the root segment
+  request.completedRootSegment === null || request.completedRootSegment.status !== POSTPONED;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  const onAllReady = request.onAllReady;
+  onAllReady();
+}
+
+function queueCompletedSegment(boundary, segment) {
+  if (segment.chunks.length === 0 && segment.children.length === 1 && segment.children[0].boundary === null) {
+    // This is an empty segment. There's nothing to write, so we can instead transfer the ID
+    // to the child. That way any existing references point to the child.
+    const childSegment = segment.children[0];
+    childSegment.id = segment.id;
+    childSegment.parentFlushed = true;
+
+    if (childSegment.status === COMPLETED) {
+      queueCompletedSegment(boundary, childSegment);
+    }
+  } else {
+    const completedSegments = boundary.completedSegments;
+    completedSegments.push(segment);
+  }
+}
+
+function finishedTask(request, boundary, segment) {
+  if (boundary === null) {
+    if (segment !== null && segment.parentFlushed) {
+      if (request.completedRootSegment !== null) {
+        throw Error(formatProdErrorMessage(389));
+      }
+
+      request.completedRootSegment = segment;
+    }
+
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status === CLIENT_RENDERED) ; else if (boundary.pendingTasks === 0) {
+      if (boundary.status === PENDING) {
+        boundary.status = COMPLETED;
+      } // This must have been the last segment we were waiting on. This boundary is now complete.
+
+
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent segment already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+        }
+      }
+
+      if (boundary.parentFlushed) {
+        // The segment might be part of a segment that didn't flush yet, but if the boundary's
+        // parent flushed, we need to schedule the boundary to be emitted.
+        request.completedBoundaries.push(boundary);
+      } // We can now cancel any pending task on the fallback since we won't need to show it anymore.
+      // This needs to happen after we read the parentFlushed flags because aborting can finish
+      // work which can trigger user code, which can start flushing, which can change those flags.
+      // If the boundary was POSTPONED, we still need to finish the fallback first.
+
+
+      if (boundary.status === COMPLETED) {
+        boundary.fallbackAbortableTasks.forEach(abortTaskSoft, request);
+        boundary.fallbackAbortableTasks.clear();
+      }
+    } else {
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+          const completedSegments = boundary.completedSegments;
+
+          if (completedSegments.length === 1) {
+            // This is the first time since we last flushed that we completed anything.
+            // We can schedule this boundary to emit its partially completed segments early
+            // in case the parent has already been flushed.
+            if (boundary.parentFlushed) {
+              request.partialBoundaries.push(boundary);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function retryTask(request, task) {
+  {
+    const blockedBoundary = task.blockedBoundary;
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, blockedBoundary ? blockedBoundary.resources : null);
+  }
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    retryReplayTask(request, // $FlowFixMe: Refined.
+    task);
+  } else {
+    retryRenderTask(request, // $FlowFixMe: Refined.
+    task, segment);
+  }
+}
+
+function retryRenderTask(request, task, segment) {
+  if (segment.status !== PENDING) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  const childrenLength = segment.children.length;
+  const chunkLength = segment.chunks.length;
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+    pushSegmentFinale(segment.chunks, request.renderState, segment.lastPushedText, segment.textEmbedded);
+    task.abortSet.delete(task);
+    segment.status = COMPLETED;
+    finishedTask(request, task.blockedBoundary, segment);
+  } catch (thrownValue) {
+    resetHooksState(); // Reset the write pointers to where we started.
+
+    segment.children.length = childrenLength;
+    segment.chunks.length = chunkLength;
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    task.abortSet.delete(task);
+    segment.status = ERRORED;
+    erroredTask(request, task.blockedBoundary, x);
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function retryReplayTask(request, task) {
+  if (task.replay.pendingTasks === 0) {
+    // There are no pending tasks working on this set, so we must have aborted.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw Error(formatProdErrorMessage(488));
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    finishedTask(request, task.blockedBoundary, null);
+  } catch (thrownValue) {
+    resetHooksState();
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    erroredReplay(request, task.blockedBoundary, x, task.replay.nodes, task.replay.slots);
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+
+    request.allPendingTasks--;
+
+    if (request.allPendingTasks === 0) {
+      completeAll(request);
+    }
+
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function performWork(request) {
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  const prevContext = getActiveContext();
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  let prevCacheDispatcher;
+
+  {
+    prevCacheDispatcher = ReactCurrentCache.current;
+    ReactCurrentCache.current = DefaultCacheDispatcher;
+  }
+
+  const prevRequest = currentRequest;
+  currentRequest = request;
+
+  const prevResumableState = currentResumableState;
+  setCurrentResumableState(request.resumableState);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    let i;
+
+    for (i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    pingedTasks.splice(0, i);
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    setCurrentResumableState(prevResumableState);
+    ReactCurrentDispatcher.current = prevDispatcher;
+
+    {
+      ReactCurrentCache.current = prevCacheDispatcher;
+    }
+
+    if (prevDispatcher === HooksDispatcher) {
+      // This means that we were in a reentrant work loop. This could happen
+      // in a renderer that supports synchronous work like renderToString,
+      // when it's called from within another renderer.
+      // Normally we don't bother switching the contexts to their root/default
+      // values when leaving because we'll likely need the same or similar
+      // context again. However, when we're inside a synchronous loop like this
+      // we'll to restore the context to what it was before returning.
+      switchContext(prevContext);
+    }
+
+    currentRequest = prevRequest;
+  }
+}
+
+function flushSubtree(request, destination, segment) {
+  segment.parentFlushed = true;
+
+  switch (segment.status) {
+    case PENDING:
+      {
+        // We're emitting a placeholder for this segment to be filled in later.
+        // Therefore we'll need to assign it an ID - to refer to it by.
+        segment.id = request.nextSegmentId++; // Fallthrough
+      }
+
+    case POSTPONED:
+      {
+        const segmentID = segment.id; // When this segment finally completes it won't be embedded in text since it will flush separately
+
+        segment.lastPushedText = false;
+        segment.textEmbedded = false;
+        return writePlaceholder(destination, request.renderState, segmentID);
+      }
+
+    case COMPLETED:
+      {
+        segment.status = FLUSHED;
+        let r = true;
+        const chunks = segment.chunks;
+        let chunkIdx = 0;
+        const children = segment.children;
+
+        for (let childIdx = 0; childIdx < children.length; childIdx++) {
+          const nextChild = children[childIdx]; // Write all the chunks up until the next child.
+
+          for (; chunkIdx < nextChild.index; chunkIdx++) {
+            writeChunk(destination, chunks[chunkIdx]);
+          }
+
+          r = flushSegment(request, destination, nextChild);
+        } // Finally just write all the remaining chunks
+
+
+        for (; chunkIdx < chunks.length - 1; chunkIdx++) {
+          writeChunk(destination, chunks[chunkIdx]);
+        }
+
+        if (chunkIdx < chunks.length) {
+          r = writeChunkAndReturn(destination, chunks[chunkIdx]);
+        }
+
+        return r;
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(390));
+      }
+  }
+}
+
+function flushSegment(request, destination, segment) {
+  const boundary = segment.boundary;
+
+  if (boundary === null) {
+    // Not a suspense boundary.
+    return flushSubtree(request, destination, segment);
+  }
+
+  boundary.parentFlushed = true; // This segment is a Suspense boundary. We need to decide whether to
+  // emit the content or the fallback now.
+
+  if (boundary.status === CLIENT_RENDERED) {
+    // Emit a client rendered suspense boundary wrapper.
+    // We never queue the inner boundary so we'll never emit its content or partial segments.
+    writeStartClientRenderedSuspenseBoundary(destination, request.renderState, boundary.errorDigest); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndClientRenderedSuspenseBoundary(destination, request.renderState);
+  } else if (boundary.status !== COMPLETED) {
+    if (boundary.status === PENDING) {
+      // For pending boundaries we lazily assign an ID to the boundary
+      // and root segment.
+      boundary.rootSegmentID = request.nextSegmentId++;
+    }
+
+    if (boundary.completedSegments.length > 0) {
+      // If this is at least partially complete, we can queue it to be partially emitted early.
+      request.partialBoundaries.push(boundary);
+    } // This boundary is still loading. Emit a pending suspense boundary wrapper.
+
+
+    const id = boundary.rootSegmentID;
+    writeStartPendingSuspenseBoundary(destination, request.renderState, id); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else if (boundary.byteSize > request.progressiveChunkSize) {
+    // This boundary is large and will be emitted separately so that we can progressively show
+    // other content. We add it to the queue during the flush because we have to ensure that
+    // the parent flushes first so that there's something to inject it into.
+    // We also have to make sure that it's emitted into the queue in a deterministic slot.
+    // I.e. we can't insert it here when it completes.
+    // Assign an ID to refer to the future content by.
+    boundary.rootSegmentID = request.nextSegmentId++;
+    request.completedBoundaries.push(boundary); // Emit a pending rendered suspense boundary wrapper.
+
+    writeStartPendingSuspenseBoundary(destination, request.renderState, boundary.rootSegmentID); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else {
+    {
+      hoistResources(request.renderState, boundary.resources);
+    } // We can inline this boundary's content as a complete boundary.
+
+
+    writeStartCompletedSuspenseBoundary(destination, request.renderState);
+    const completedSegments = boundary.completedSegments;
+
+    if (completedSegments.length !== 1) {
+      throw Error(formatProdErrorMessage(391));
+    }
+
+    const contentSegment = completedSegments[0];
+    flushSegment(request, destination, contentSegment);
+    return writeEndCompletedSuspenseBoundary(destination, request.renderState);
+  }
+}
+
+function flushClientRenderedBoundary(request, destination, boundary) {
+  return writeClientRenderBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.errorDigest, boundary.errorMessage, boundary.errorComponentStack);
+}
+
+function flushSegmentContainer(request, destination, segment) {
+  writeStartSegment(destination, request.renderState, segment.parentFormatContext, segment.id);
+  flushSegment(request, destination, segment);
+  return writeEndSegment(destination, segment.parentFormatContext);
+}
+
+function flushCompletedBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+    flushPartiallyCompletedSegment(request, destination, boundary, segment);
+  }
+
+  completedSegments.length = 0;
+
+  {
+    writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+
+  return writeCompletedBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.resources);
+}
+
+function flushPartialBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+
+    if (!flushPartiallyCompletedSegment(request, destination, boundary, segment)) {
+      i++;
+      completedSegments.splice(0, i); // Only write as much as the buffer wants. Something higher priority
+      // might want to write later.
+
+      return false;
+    }
+  }
+
+  completedSegments.splice(0, i);
+
+  {
+    // The way this is structured we only write resources for partial boundaries
+    // if there is no backpressure. Later before we complete the boundary we
+    // will write resources regardless of backpressure before we emit the
+    // completion instruction
+    return writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+}
+
+function flushPartiallyCompletedSegment(request, destination, boundary, segment) {
+  if (segment.status === FLUSHED) {
+    // We've already flushed this inline.
+    return true;
+  }
+
+  const segmentID = segment.id;
+
+  if (segmentID === -1) {
+    // This segment wasn't previously referred to. This happens at the root of
+    // a boundary. We make kind of a leap here and assume this is the root.
+    const rootSegmentID = segment.id = boundary.rootSegmentID;
+
+    if (rootSegmentID === -1) {
+      throw Error(formatProdErrorMessage(392));
+    }
+
+    return flushSegmentContainer(request, destination, segment);
+  } else if (segmentID === boundary.rootSegmentID) {
+    // When we emit postponed boundaries, we might have assigned the ID already
+    // but it's still the root segment so we can't inject it into the parent yet.
+    return flushSegmentContainer(request, destination, segment);
+  } else {
+    flushSegmentContainer(request, destination, segment);
+    return writeCompletedSegmentInstruction(destination, request.resumableState, request.renderState, segmentID);
+  }
+}
+
+function flushCompletedQueues(request, destination) {
+
+  try {
+    // The structure of this is to go through each queue one by one and write
+    // until the sink tells us to stop. When we should stop, we still finish writing
+    // that item fully and then yield. At that point we remove the already completed
+    // items up until the point we completed them.
+    let i;
+    const completedRootSegment = request.completedRootSegment;
+
+    if (completedRootSegment !== null) {
+      if (completedRootSegment.status === POSTPONED) {
+        // We postponed the root, so we write nothing.
+        return;
+      } else if (request.pendingRootTasks === 0) {
+        if (enableFloat) {
+          writePreamble(destination, request.resumableState, request.renderState, request.allPendingTasks === 0 && request.trackedPostpones === null);
+        }
+
+        flushSegment(request, destination, completedRootSegment);
+        request.completedRootSegment = null;
+        writeCompletedRoot(destination, request.renderState, request.resumableState);
+      } else {
+        // We haven't flushed the root yet so we don't need to check any other branches further down
+        return;
+      }
+    }
+
+    if (enableFloat) {
+      writeHoistables(destination, request.resumableState, request.renderState);
+    } // We emit client rendering instructions for already emitted boundaries first.
+    // This is so that we can signal to the client to start client rendering them as
+    // soon as possible.
+
+
+    const clientRenderedBoundaries = request.clientRenderedBoundaries;
+
+    for (i = 0; i < clientRenderedBoundaries.length; i++) {
+      const boundary = clientRenderedBoundaries[i];
+
+      if (!flushClientRenderedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        clientRenderedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    clientRenderedBoundaries.splice(0, i); // Next we emit any complete boundaries. It's better to favor boundaries
+    // that are completely done since we can actually show them, than it is to emit
+    // any individual segments from a partially complete boundary.
+
+    const completedBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < completedBoundaries.length; i++) {
+      const boundary = completedBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        completedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    completedBoundaries.splice(0, i); // Allow anything written so far to flush to the underlying sink before
+    // we continue with lower priorities.
+
+    completeWriting(destination);
+    beginWriting(destination); // TODO: Here we'll emit data used by hydration.
+    // Next we emit any segments of any boundaries that are partially complete
+    // but not deeply complete.
+
+    const partialBoundaries = request.partialBoundaries;
+
+    for (i = 0; i < partialBoundaries.length; i++) {
+      const boundary = partialBoundaries[i];
+
+      if (!flushPartialBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        partialBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    partialBoundaries.splice(0, i); // Next we check the completed boundaries again. This may have had
+    // boundaries added to it in case they were too larged to be inlined.
+    // New ones might be added in this loop.
+
+    const largeBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < largeBoundaries.length; i++) {
+      const boundary = largeBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        largeBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    largeBoundaries.splice(0, i);
+  } finally {
+    if (request.allPendingTasks === 0 && request.pingedTasks.length === 0 && request.clientRenderedBoundaries.length === 0 && request.completedBoundaries.length === 0 // We don't need to check any partially completed segments because
+    // either they have pending task or they're complete.
+    ) {
+        request.flushScheduled = false;
+
+        {
+          // We write the trailing tags but only if don't have any data to resume.
+          // If we need to resume we'll write the postamble in the resume instead.
+          {
+            writePostamble(destination, request.resumableState);
+          }
+        }
+
+
+        close(destination); // We need to stop flowing now because we do not want any async contexts which might call
+        // float methods to initiate any flushes after this point
+
+        stopFlowing(request);
+      }
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  {
+    scheduleWork(() => performWork(request));
+  }
+
+  if (request.trackedPostpones === null) {
+    // this is either a regular render or a resume. For regular render we want
+    // to call emitEarlyPreloads after the first performWork because we want
+    // are responding to a live request and need to balance sending something early
+    // (i.e. don't want for the shell to finish) but we need something to send.
+    // The only implementation of this is for DOM at the moment and during resumes nothing
+    // actually emits but the code paths here are the same.
+    // During a prerender we don't want to be too aggressive in emitting early preloads
+    // because we aren't responding to a live request and we can wait for the prerender to
+    // postpone before we emit anything.
+    {
+      scheduleWork(() => enqueueEarlyPreloadsAfterInitialWork(request));
+    }
+  }
+}
+
+function enqueueEarlyPreloadsAfterInitialWork(request) {
+  const shellComplete = request.pendingRootTasks === 0;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    request.flushScheduled = true;
+    scheduleWork(() => {
+      // We need to existence check destination again here because it might go away
+      // in between the enqueueFlush call and the work execution
+      const destination = request.destination;
+
+      if (destination) {
+        flushCompletedQueues(request, destination);
+      } else {
+        request.flushScheduled = false;
+      }
+    });
+  }
+} // This function is intented to only be called during the pipe function for the Node builds.
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedQueues(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function stopFlowing(request) {
+  request.destination = null;
+} // This is called to early terminate a request. It puts all pending boundaries in client rendered state.
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      const error = reason === undefined ? Error(formatProdErrorMessage(432)) : reason;
+      abortableTasks.forEach(task => abortTask(task, request, error));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function flushResources(request) {
+  enqueueFlush(request);
+}
+function getFormState(request) {
+  return request.formState;
+}
+function getResumableState(request) {
+  return request.resumableState;
+}
+function getRenderState(request) {
+  return request.renderState;
+}
+
+function onError() {// Non-fatal errors are ignored.
+}
+
+function renderToStringImpl(children, options, generateStaticMarkup, abortReason) {
+  let didFatal = false;
+  let fatalError = null;
+  let result = '';
+  const destination = {
+    // $FlowFixMe[missing-local-annot]
+    push(chunk) {
+      if (chunk !== null) {
+        result += chunk;
+      }
+
+      return true;
+    },
+
+    // $FlowFixMe[missing-local-annot]
+    destroy(error) {
+      didFatal = true;
+      fatalError = error;
+    }
+
+  };
+  let readyToStream = false;
+
+  function onShellReady() {
+    readyToStream = true;
+  }
+
+  const resumableState = createResumableState(options ? options.identifierPrefix : undefined, undefined);
+  const request = createRequest(children, resumableState, createRenderState(resumableState, generateStaticMarkup), createRootFormatContext(), Infinity, onError, undefined, onShellReady, undefined, undefined, undefined);
+  startWork(request); // If anything suspended and is still pending, we'll abort it before writing.
+  // That way we write only client-rendered boundaries from the start.
+
+  abort(request, abortReason);
+  startFlowing(request, destination);
+
+  if (didFatal && fatalError !== abortReason) {
+    throw fatalError;
+  }
+
+  if (!readyToStream) {
+    // Note: This error message is the one we use on the client. It doesn't
+    // really make sense here. But this is the legacy server renderer, anyway.
+    // We're going to delete it soon.
+    throw Error(formatProdErrorMessage(426));
+  }
+
+  return result;
+}
+
+function renderToString(children, options) {
+  return renderToStringImpl(children, options, false, 'The server used "renderToString" which does not support Suspense. If you intended for this Suspense boundary to render the fallback content on the server consider throwing an Error somewhere within the Suspense boundary. If you intended to have the server wait for the suspended component please switch to "renderToReadableStream" which supports Suspense on the server');
+}
+
+function renderToStaticMarkup(children, options) {
+  return renderToStringImpl(children, options, true, 'The server used "renderToStaticMarkup" which does not support Suspense. If you intended to have the server wait for the suspended component please switch to "renderToReadableStream" which supports Suspense on the server');
+}
+
+function renderToNodeStream() {
+  throw Error(formatProdErrorMessage(207));
+}
+
+function renderToStaticNodeStream() {
+  throw Error(formatProdErrorMessage(208));
+}
+
+exports.renderToNodeStream = renderToNodeStream;
+exports.renderToStaticMarkup = renderToStaticMarkup;
+exports.renderToStaticNodeStream = renderToStaticNodeStream;
+exports.renderToString = renderToString;
+exports.version = ReactVersion;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.browser.production.min.js b/packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.browser.production.min.js
index 4ce5b34f7d37f..cadf2545ea635 100644
--- a/packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.browser.production.min.js
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.browser.production.min.js
@@ -1,13 +1,11 @@
-/**
- * @license React
- * react-dom-server-legacy.browser.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
 /*
+ React
+ react-dom-server-legacy.browser.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
 
 
  JS Implementation of MurmurHash3 (r136) (as of May 20, 2011)
@@ -31,168 +29,174 @@
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
 */
-'use strict';var ea=require("next/dist/compiled/react"),ka=require("react-dom");function p(a){for(var b="https://reactjs.org/docs/error-decoder.html?invariant="+a,c=1;c<arguments.length;c++)b+="&args[]="+encodeURIComponent(arguments[c]);return"Minified React error #"+a+"; visit "+b+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}
-function la(a,b){var c=a.length&3;var d=a.length-c;var e=b;for(b=0;b<d;){var f=a.charCodeAt(b)&255|(a.charCodeAt(++b)&255)<<8|(a.charCodeAt(++b)&255)<<16|(a.charCodeAt(++b)&255)<<24;++b;f=3432918353*(f&65535)+((3432918353*(f>>>16)&65535)<<16)&4294967295;f=f<<15|f>>>17;f=461845907*(f&65535)+((461845907*(f>>>16)&65535)<<16)&4294967295;e^=f;e=e<<13|e>>>19;e=5*(e&65535)+((5*(e>>>16)&65535)<<16)&4294967295;e=(e&65535)+27492+(((e>>>16)+58964&65535)<<16)}f=0;switch(c){case 3:f^=(a.charCodeAt(b+2)&255)<<
+'use strict';var aa=require("next/dist/compiled/react"),ba=require("react-dom");function q(a){for(var b="https://reactjs.org/docs/error-decoder.html?invariant="+a,c=1;c<arguments.length;c++)b+="&args[]="+encodeURIComponent(arguments[c]);return"Minified React error #"+a+"; visit "+b+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}
+function ea(a,b){var c=a.length&3;var d=a.length-c;var e=b;for(b=0;b<d;){var f=a.charCodeAt(b)&255|(a.charCodeAt(++b)&255)<<8|(a.charCodeAt(++b)&255)<<16|(a.charCodeAt(++b)&255)<<24;++b;f=3432918353*(f&65535)+((3432918353*(f>>>16)&65535)<<16)&4294967295;f=f<<15|f>>>17;f=461845907*(f&65535)+((461845907*(f>>>16)&65535)<<16)&4294967295;e^=f;e=e<<13|e>>>19;e=5*(e&65535)+((5*(e>>>16)&65535)<<16)&4294967295;e=(e&65535)+27492+(((e>>>16)+58964&65535)<<16)}f=0;switch(c){case 3:f^=(a.charCodeAt(b+2)&255)<<
 16;case 2:f^=(a.charCodeAt(b+1)&255)<<8;case 1:f^=a.charCodeAt(b)&255,f=3432918353*(f&65535)+((3432918353*(f>>>16)&65535)<<16)&4294967295,f=f<<15|f>>>17,e^=461845907*(f&65535)+((461845907*(f>>>16)&65535)<<16)&4294967295}e^=a.length;e^=e>>>16;e=2246822507*(e&65535)+((2246822507*(e>>>16)&65535)<<16)&4294967295;e^=e>>>13;e=3266489909*(e&65535)+((3266489909*(e>>>16)&65535)<<16)&4294967295;return(e^e>>>16)>>>0}
-var t=Object.assign,v=Object.prototype.hasOwnProperty,ma=RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"),za={},Aa={};
-function Ba(a){if(v.call(Aa,a))return!0;if(v.call(za,a))return!1;if(ma.test(a))return Aa[a]=!0;za[a]=!0;return!1}
-var Ca=new Set("animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp".split(" ")),Da=
+var t=Object.assign,y=Object.prototype.hasOwnProperty,ka=RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"),la={},ma={};
+function za(a){if(y.call(ma,a))return!0;if(y.call(la,a))return!1;if(ka.test(a))return ma[a]=!0;la[a]=!0;return!1}
+var Aa=new Set("animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp".split(" ")),Ba=
 new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv","http-equiv"],["crossOrigin","crossorigin"],["accentHeight","accent-height"],["alignmentBaseline","alignment-baseline"],["arabicForm","arabic-form"],["baselineShift","baseline-shift"],["capHeight","cap-height"],["clipPath","clip-path"],["clipRule","clip-rule"],["colorInterpolation","color-interpolation"],["colorInterpolationFilters","color-interpolation-filters"],["colorProfile","color-profile"],["colorRendering","color-rendering"],
 ["dominantBaseline","dominant-baseline"],["enableBackground","enable-background"],["fillOpacity","fill-opacity"],["fillRule","fill-rule"],["floodColor","flood-color"],["floodOpacity","flood-opacity"],["fontFamily","font-family"],["fontSize","font-size"],["fontSizeAdjust","font-size-adjust"],["fontStretch","font-stretch"],["fontStyle","font-style"],["fontVariant","font-variant"],["fontWeight","font-weight"],["glyphName","glyph-name"],["glyphOrientationHorizontal","glyph-orientation-horizontal"],["glyphOrientationVertical",
 "glyph-orientation-vertical"],["horizAdvX","horiz-adv-x"],["horizOriginX","horiz-origin-x"],["imageRendering","image-rendering"],["letterSpacing","letter-spacing"],["lightingColor","lighting-color"],["markerEnd","marker-end"],["markerMid","marker-mid"],["markerStart","marker-start"],["overlinePosition","overline-position"],["overlineThickness","overline-thickness"],["paintOrder","paint-order"],["panose-1","panose-1"],["pointerEvents","pointer-events"],["renderingIntent","rendering-intent"],["shapeRendering",
 "shape-rendering"],["stopColor","stop-color"],["stopOpacity","stop-opacity"],["strikethroughPosition","strikethrough-position"],["strikethroughThickness","strikethrough-thickness"],["strokeDasharray","stroke-dasharray"],["strokeDashoffset","stroke-dashoffset"],["strokeLinecap","stroke-linecap"],["strokeLinejoin","stroke-linejoin"],["strokeMiterlimit","stroke-miterlimit"],["strokeOpacity","stroke-opacity"],["strokeWidth","stroke-width"],["textAnchor","text-anchor"],["textDecoration","text-decoration"],
 ["textRendering","text-rendering"],["transformOrigin","transform-origin"],["underlinePosition","underline-position"],["underlineThickness","underline-thickness"],["unicodeBidi","unicode-bidi"],["unicodeRange","unicode-range"],["unitsPerEm","units-per-em"],["vAlphabetic","v-alphabetic"],["vHanging","v-hanging"],["vIdeographic","v-ideographic"],["vMathematical","v-mathematical"],["vectorEffect","vector-effect"],["vertAdvY","vert-adv-y"],["vertOriginX","vert-origin-x"],["vertOriginY","vert-origin-y"],
-["wordSpacing","word-spacing"],["writingMode","writing-mode"],["xmlnsXlink","xmlns:xlink"],["xHeight","x-height"]]),Ja=/["'&<>]/;
-function w(a){if("boolean"===typeof a||"number"===typeof a)return""+a;a=""+a;var b=Ja.exec(a);if(b){var c="",d,e=0;for(d=b.index;d<a.length;d++){switch(a.charCodeAt(d)){case 34:b="&quot;";break;case 38:b="&amp;";break;case 39:b="&#x27;";break;case 60:b="&lt;";break;case 62:b="&gt;";break;default:continue}e!==d&&(c+=a.slice(e,d));e=d+1;c+=b}a=e!==d?c+a.slice(e,d):c}return a}
-var Ka=/([A-Z])/g,La=/^ms-/,Ma=Array.isArray,Na=ea.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,Oa={pending:!1,data:null,method:null,action:null},Pa=ka.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Dispatcher,mb={prefetchDNS:fb,preconnect:gb,preload:hb,preloadModule:ib,preinitStyle:jb,preinitScript:kb,preinitModuleScript:lb},y=[];
-function nb(a,b){var c=0;void 0!==b&&(c=1);return{idPrefix:void 0===a?"":a,nextFormID:0,streamingFormat:c,instructions:0,hasBody:!1,hasHtml:!1,unknownResources:{},dnsResources:{},connectResources:{default:{},anonymous:{},credentials:{}},imageResources:{},styleResources:{},scriptResources:{},moduleUnknownResources:{},moduleScriptResources:{}}}function D(a,b,c){return{insertionMode:a,selectedValue:b,tagScope:c}}
-function ob(a,b,c){switch(b){case "noscript":return D(2,null,a.tagScope|1);case "select":return D(2,null!=c.value?c.value:c.defaultValue,a.tagScope);case "svg":return D(3,null,a.tagScope);case "picture":return D(2,null,a.tagScope|2);case "math":return D(4,null,a.tagScope);case "foreignObject":return D(2,null,a.tagScope);case "table":return D(5,null,a.tagScope);case "thead":case "tbody":case "tfoot":return D(6,null,a.tagScope);case "colgroup":return D(8,null,a.tagScope);case "tr":return D(7,null,a.tagScope)}return 5<=
-a.insertionMode?D(2,null,a.tagScope):0===a.insertionMode?"html"===b?D(1,null,a.tagScope):D(2,null,a.tagScope):1===a.insertionMode?D(2,null,a.tagScope):a}var pb=new Map;
-function qb(a,b){if("object"!==typeof b)throw Error(p(62));var c=!0,d;for(d in b)if(v.call(b,d)){var e=b[d];if(null!=e&&"boolean"!==typeof e&&""!==e){if(0===d.indexOf("--")){var f=w(d);e=w((""+e).trim())}else f=pb.get(d),void 0===f&&(f=w(d.replace(Ka,"-$1").toLowerCase().replace(La,"-ms-")),pb.set(d,f)),e="number"===typeof e?0===e||Ca.has(d)?""+e:e+"px":w((""+e).trim());c?(c=!1,a.push(' style="',f,":",e)):a.push(";",f,":",e)}}c||a.push('"')}
-function Ab(a,b,c){c&&"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'=""')}function E(a,b,c){"function"!==typeof c&&"symbol"!==typeof c&&"boolean"!==typeof c&&a.push(" ",b,'="',w(c),'"')}function Bb(a){var b=a.nextFormID++;return a.idPrefix+b}var Cb=w("javascript:throw new Error('A React form was unexpectedly submitted.')");function Db(a,b){this.push('<input type="hidden"');if("string"!==typeof a)throw Error(p(480));E(this,"name",b);E(this,"value",a);this.push("/>")}
-function Eb(a,b,c,d,e,f,g,h){var k=null;"function"===typeof d&&("function"===typeof d.$$FORM_ACTION?(e=Bb(b),b=d.$$FORM_ACTION(e),h=b.name,d=b.action||"",e=b.encType,f=b.method,g=b.target,k=b.data):(a.push(" ","formAction",'="',Cb,'"'),g=f=e=d=h=null,Fb(b,c)));null!=h&&F(a,"name",h);null!=d&&F(a,"formAction",d);null!=e&&F(a,"formEncType",e);null!=f&&F(a,"formMethod",f);null!=g&&F(a,"formTarget",g);return k}
-function F(a,b,c){switch(b){case "className":E(a,"class",c);break;case "tabIndex":E(a,"tabindex",c);break;case "dir":case "role":case "viewBox":case "width":case "height":E(a,b,c);break;case "style":qb(a,c);break;case "src":case "href":case "action":case "formAction":if(null==c||"function"===typeof c||"symbol"===typeof c||"boolean"===typeof c)break;a.push(" ",b,'="',w(""+c),'"');break;case "defaultValue":case "defaultChecked":case "innerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":break;
-case "autoFocus":case "multiple":case "muted":Ab(a,b.toLowerCase(),c);break;case "xlinkHref":if("function"===typeof c||"symbol"===typeof c||"boolean"===typeof c)break;a.push(" ","xlink:href",'="',w(""+c),'"');break;case "contentEditable":case "spellCheck":case "draggable":case "value":case "autoReverse":case "externalResourcesRequired":case "focusable":case "preserveAlpha":"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'="',w(c),'"');break;case "allowFullScreen":case "async":case "autoPlay":case "controls":case "default":case "defer":case "disabled":case "disablePictureInPicture":case "disableRemotePlayback":case "formNoValidate":case "hidden":case "loop":case "noModule":case "noValidate":case "open":case "playsInline":case "readOnly":case "required":case "reversed":case "scoped":case "seamless":case "itemScope":c&&
-"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'=""');break;case "capture":case "download":!0===c?a.push(" ",b,'=""'):!1!==c&&"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'="',w(c),'"');break;case "cols":case "rows":case "size":case "span":"function"!==typeof c&&"symbol"!==typeof c&&!isNaN(c)&&1<=c&&a.push(" ",b,'="',w(c),'"');break;case "rowSpan":case "start":"function"===typeof c||"symbol"===typeof c||isNaN(c)||a.push(" ",b,'="',w(c),'"');break;case "xlinkActuate":E(a,"xlink:actuate",
-c);break;case "xlinkArcrole":E(a,"xlink:arcrole",c);break;case "xlinkRole":E(a,"xlink:role",c);break;case "xlinkShow":E(a,"xlink:show",c);break;case "xlinkTitle":E(a,"xlink:title",c);break;case "xlinkType":E(a,"xlink:type",c);break;case "xmlBase":E(a,"xml:base",c);break;case "xmlLang":E(a,"xml:lang",c);break;case "xmlSpace":E(a,"xml:space",c);break;default:if(!(2<b.length)||"o"!==b[0]&&"O"!==b[0]||"n"!==b[1]&&"N"!==b[1])if(b=Da.get(b)||b,Ba(b)){switch(typeof c){case "function":case "symbol":return;
-case "boolean":var d=b.toLowerCase().slice(0,5);if("data-"!==d&&"aria-"!==d)return}a.push(" ",b,'="',w(c),'"')}}}function J(a,b,c){if(null!=b){if(null!=c)throw Error(p(60));if("object"!==typeof b||!("__html"in b))throw Error(p(61));b=b.__html;null!==b&&void 0!==b&&a.push(""+b)}}function Gb(a){var b="";ea.Children.forEach(a,function(c){null!=c&&(b+=c)});return b}
+["wordSpacing","word-spacing"],["writingMode","writing-mode"],["xmlnsXlink","xmlns:xlink"],["xHeight","x-height"]]),Ca=/["'&<>]/;
+function z(a){if("boolean"===typeof a||"number"===typeof a)return""+a;a=""+a;var b=Ca.exec(a);if(b){var c="",d,e=0;for(d=b.index;d<a.length;d++){switch(a.charCodeAt(d)){case 34:b="&quot;";break;case 38:b="&amp;";break;case 39:b="&#x27;";break;case 60:b="&lt;";break;case 62:b="&gt;";break;default:continue}e!==d&&(c+=a.slice(e,d));e=d+1;c+=b}a=e!==d?c+a.slice(e,d):c}return a}
+var Da=/([A-Z])/g,Ja=/^ms-/,Ka=Array.isArray,La=aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,Ma={pending:!1,data:null,method:null,action:null},Na=ba.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Dispatcher,kb={prefetchDNS:Oa,preconnect:Pa,preload:fb,preloadModule:gb,preinitStyle:hb,preinitScript:ib,preinitModuleScript:jb},B=[],lb=/(<\/|<)(s)(cript)/gi;function mb(a,b,c,d){return""+b+("s"===c?"\\u0073":"\\u0053")+d}
+function nb(a,b,c,d,e){var f=0;void 0!==b&&(f=1);return{idPrefix:void 0===a?"":a,nextFormID:0,streamingFormat:f,bootstrapScriptContent:c,bootstrapScripts:d,bootstrapModules:e,instructions:0,hasBody:!1,hasHtml:!1,unknownResources:{},dnsResources:{},connectResources:{default:{},anonymous:{},credentials:{}},imageResources:{},styleResources:{},scriptResources:{},moduleUnknownResources:{},moduleScriptResources:{}}}function E(a,b,c){return{insertionMode:a,selectedValue:b,tagScope:c}}
+function ob(a,b,c){switch(b){case "noscript":return E(2,null,a.tagScope|1);case "select":return E(2,null!=c.value?c.value:c.defaultValue,a.tagScope);case "svg":return E(3,null,a.tagScope);case "picture":return E(2,null,a.tagScope|2);case "math":return E(4,null,a.tagScope);case "foreignObject":return E(2,null,a.tagScope);case "table":return E(5,null,a.tagScope);case "thead":case "tbody":case "tfoot":return E(6,null,a.tagScope);case "colgroup":return E(8,null,a.tagScope);case "tr":return E(7,null,a.tagScope)}return 5<=
+a.insertionMode?E(2,null,a.tagScope):0===a.insertionMode?"html"===b?E(1,null,a.tagScope):E(2,null,a.tagScope):1===a.insertionMode?E(2,null,a.tagScope):a}var pb=new Map;
+function qb(a,b){if("object"!==typeof b)throw Error(q(62));var c=!0,d;for(d in b)if(y.call(b,d)){var e=b[d];if(null!=e&&"boolean"!==typeof e&&""!==e){if(0===d.indexOf("--")){var f=z(d);e=z((""+e).trim())}else f=pb.get(d),void 0===f&&(f=z(d.replace(Da,"-$1").toLowerCase().replace(Ja,"-ms-")),pb.set(d,f)),e="number"===typeof e?0===e||Aa.has(d)?""+e:e+"px":z((""+e).trim());c?(c=!1,a.push(' style="',f,":",e)):a.push(";",f,":",e)}}c||a.push('"')}
+function Ab(a,b,c){c&&"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'=""')}function I(a,b,c){"function"!==typeof c&&"symbol"!==typeof c&&"boolean"!==typeof c&&a.push(" ",b,'="',z(c),'"')}function Bb(a){var b=a.nextFormID++;return a.idPrefix+b}var Cb=z("javascript:throw new Error('A React form was unexpectedly submitted.')");function Db(a,b){this.push('<input type="hidden"');if("string"!==typeof a)throw Error(q(480));I(this,"name",b);I(this,"value",a);this.push("/>")}
+function Eb(a,b,c,d,e,f,g,h){var k=null;"function"===typeof d&&("function"===typeof d.$$FORM_ACTION?(e=Bb(b),b=d.$$FORM_ACTION(e),h=b.name,d=b.action||"",e=b.encType,f=b.method,g=b.target,k=b.data):(a.push(" ","formAction",'="',Cb,'"'),g=f=e=d=h=null,Fb(b,c)));null!=h&&J(a,"name",h);null!=d&&J(a,"formAction",d);null!=e&&J(a,"formEncType",e);null!=f&&J(a,"formMethod",f);null!=g&&J(a,"formTarget",g);return k}
+function J(a,b,c){switch(b){case "className":I(a,"class",c);break;case "tabIndex":I(a,"tabindex",c);break;case "dir":case "role":case "viewBox":case "width":case "height":I(a,b,c);break;case "style":qb(a,c);break;case "src":case "href":case "action":case "formAction":if(null==c||"function"===typeof c||"symbol"===typeof c||"boolean"===typeof c)break;a.push(" ",b,'="',z(""+c),'"');break;case "defaultValue":case "defaultChecked":case "innerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":break;
+case "autoFocus":case "multiple":case "muted":Ab(a,b.toLowerCase(),c);break;case "xlinkHref":if("function"===typeof c||"symbol"===typeof c||"boolean"===typeof c)break;a.push(" ","xlink:href",'="',z(""+c),'"');break;case "contentEditable":case "spellCheck":case "draggable":case "value":case "autoReverse":case "externalResourcesRequired":case "focusable":case "preserveAlpha":"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'="',z(c),'"');break;case "allowFullScreen":case "async":case "autoPlay":case "controls":case "default":case "defer":case "disabled":case "disablePictureInPicture":case "disableRemotePlayback":case "formNoValidate":case "hidden":case "loop":case "noModule":case "noValidate":case "open":case "playsInline":case "readOnly":case "required":case "reversed":case "scoped":case "seamless":case "itemScope":c&&
+"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'=""');break;case "capture":case "download":!0===c?a.push(" ",b,'=""'):!1!==c&&"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'="',z(c),'"');break;case "cols":case "rows":case "size":case "span":"function"!==typeof c&&"symbol"!==typeof c&&!isNaN(c)&&1<=c&&a.push(" ",b,'="',z(c),'"');break;case "rowSpan":case "start":"function"===typeof c||"symbol"===typeof c||isNaN(c)||a.push(" ",b,'="',z(c),'"');break;case "xlinkActuate":I(a,"xlink:actuate",
+c);break;case "xlinkArcrole":I(a,"xlink:arcrole",c);break;case "xlinkRole":I(a,"xlink:role",c);break;case "xlinkShow":I(a,"xlink:show",c);break;case "xlinkTitle":I(a,"xlink:title",c);break;case "xlinkType":I(a,"xlink:type",c);break;case "xmlBase":I(a,"xml:base",c);break;case "xmlLang":I(a,"xml:lang",c);break;case "xmlSpace":I(a,"xml:space",c);break;default:if(!(2<b.length)||"o"!==b[0]&&"O"!==b[0]||"n"!==b[1]&&"N"!==b[1])if(b=Ba.get(b)||b,za(b)){switch(typeof c){case "function":case "symbol":return;
+case "boolean":var d=b.toLowerCase().slice(0,5);if("data-"!==d&&"aria-"!==d)return}a.push(" ",b,'="',z(c),'"')}}}function L(a,b,c){if(null!=b){if(null!=c)throw Error(q(60));if("object"!==typeof b||!("__html"in b))throw Error(q(61));b=b.__html;null!==b&&void 0!==b&&a.push(""+b)}}function Gb(a){var b="";aa.Children.forEach(a,function(c){null!=c&&(b+=c)});return b}
 function Fb(a,b){0!==(a.instructions&16)||b.externalRuntimeScript||(a.instructions|=16,b.bootstrapChunks.unshift(b.startInlineScript,'addEventListener("submit",function(a){if(!a.defaultPrevented){var c=a.target,d=a.submitter,e=c.action,b=d;if(d){var f=d.getAttribute("formAction");null!=f&&(e=f,b=null)}"javascript:throw new Error(\'A React form was unexpectedly submitted.\')"===e&&(a.preventDefault(),b?(a=document.createElement("input"),a.name=b.name,a.value=b.value,b.parentNode.insertBefore(a,b),b=new FormData(c),a.parentNode.removeChild(a)):b=new FormData(c),a=c.getRootNode(),(a.$$reactFormReplay=a.$$reactFormReplay||[]).push(c,\nd,b))}});',"\x3c/script>"))}
-function Hb(a,b,c,d,e,f,g){var h=b.rel,k=b.href,l=b.precedence;if(3===f||g||null!=b.itemProp||"string"!==typeof h||"string"!==typeof k||""===k)return K(a,b),null;if("stylesheet"===b.rel){if("string"!==typeof l||null!=b.disabled||b.onLoad||b.onError)return K(a,b);f=d.styles.get(l);g=c.styleResources.hasOwnProperty(k)?c.styleResources[k]:void 0;null!==g?(c.styleResources[k]=null,f||(f={precedence:w(l),rules:[],hrefs:[],sheets:new Map},d.styles.set(l,f)),b={state:0,props:t({},b,{"data-precedence":b.precedence,
-precedence:null})},g&&(2===g.length&&Ib(b.props,g),(c=d.preloads.stylesheets.get(k))&&0<c.length?c.length=0:b.state=1),f.sheets.set(k,b),d.boundaryResources&&d.boundaryResources.stylesheets.add(b)):f&&(k=f.sheets.get(k))&&d.boundaryResources&&d.boundaryResources.stylesheets.add(k);e&&a.push("\x3c!-- --\x3e");return null}if(b.onLoad||b.onError)return K(a,b);e&&a.push("\x3c!-- --\x3e");switch(b.rel){case "preconnect":case "dns-prefetch":return K(d.preconnectChunks,b);case "preload":return K(d.preloadChunks,
-b);default:return K(d.hoistableChunks,b)}}function K(a,b){a.push(L("link"));for(var c in b)if(v.call(b,c)){var d=b[c];if(null!=d)switch(c){case "children":case "dangerouslySetInnerHTML":throw Error(p(399,"link"));default:F(a,c,d)}}a.push("/>");return null}function Jb(a,b,c){a.push(L(c));for(var d in b)if(v.call(b,d)){var e=b[d];if(null!=e)switch(d){case "children":case "dangerouslySetInnerHTML":throw Error(p(399,c));default:F(a,d,e)}}a.push("/>");return null}
-function Kb(a,b){a.push(L("title"));var c=null,d=null,e;for(e in b)if(v.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:F(a,e,f)}}a.push(">");b=Array.isArray(c)?2>c.length?c[0]:null:c;"function"!==typeof b&&"symbol"!==typeof b&&null!==b&&void 0!==b&&a.push(w(""+b));J(a,d,c);a.push(Lb("title"));return null}
-function Mb(a,b){a.push(L("script"));var c=null,d=null,e;for(e in b)if(v.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:F(a,e,f)}}a.push(">");J(a,d,c);"string"===typeof c&&a.push(w(c));a.push(Lb("script"));return null}
-function Nb(a,b,c){a.push(L(c));var d=c=null,e;for(e in b)if(v.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:F(a,e,f)}}a.push(">");J(a,d,c);return"string"===typeof c?(a.push(w(c)),null):c}var Ob=/^[a-zA-Z][a-zA-Z:_\.\-\d]*$/,Pb=new Map;function L(a){var b=Pb.get(a);if(void 0===b){if(!Ob.test(a))throw Error(p(65,a));b="<"+a;Pb.set(a,b)}return b}
-function Qb(a,b,c,d,e,f,g){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "select":a.push(L("select"));var h=null,k=null,l;for(l in c)if(v.call(c,l)){var n=c[l];if(null!=n)switch(l){case "children":h=n;break;case "dangerouslySetInnerHTML":k=n;break;case "defaultValue":case "value":break;default:F(a,l,n)}}a.push(">");J(a,k,h);return h;case "option":var r=f.selectedValue;a.push(L("option"));var m=null,G=null,A=null,T=null,u;for(u in c)if(v.call(c,
-u)){var z=c[u];if(null!=z)switch(u){case "children":m=z;break;case "selected":A=z;break;case "dangerouslySetInnerHTML":T=z;break;case "value":G=z;default:F(a,u,z)}}if(null!=r){var q=null!==G?""+G:Gb(m);if(Ma(r))for(var aa=0;aa<r.length;aa++){if(""+r[aa]===q){a.push(' selected=""');break}}else""+r===q&&a.push(' selected=""')}else A&&a.push(' selected=""');a.push(">");J(a,T,m);return m;case "textarea":a.push(L("textarea"));var H=null,ba=null,B=null,M;for(M in c)if(v.call(c,M)){var x=c[M];if(null!=x)switch(M){case "children":B=
-x;break;case "value":H=x;break;case "defaultValue":ba=x;break;case "dangerouslySetInnerHTML":throw Error(p(91));default:F(a,M,x)}}null===H&&null!==ba&&(H=ba);a.push(">");if(null!=B){if(null!=H)throw Error(p(92));if(Ma(B)){if(1<B.length)throw Error(p(93));H=""+B[0]}H=""+B}"string"===typeof H&&"\n"===H[0]&&a.push("\n");null!==H&&a.push(w(""+H));return null;case "input":a.push(L("input"));var fa=null,R=null,N=null,na=null,ha=null,W=null,Qa=null,Ra=null,Sa=null,oa;for(oa in c)if(v.call(c,oa)){var P=c[oa];
-if(null!=P)switch(oa){case "children":case "dangerouslySetInnerHTML":throw Error(p(399,"input"));case "name":fa=P;break;case "formAction":R=P;break;case "formEncType":N=P;break;case "formMethod":na=P;break;case "formTarget":ha=P;break;case "defaultChecked":Sa=P;break;case "defaultValue":Qa=P;break;case "checked":Ra=P;break;case "value":W=P;break;default:F(a,oa,P)}}var rb=Eb(a,d,e,R,N,na,ha,fa);null!==Ra?Ab(a,"checked",Ra):null!==Sa&&Ab(a,"checked",Sa);null!==W?F(a,"value",W):null!==Qa&&F(a,"value",
-Qa);a.push("/>");null!==rb&&rb.forEach(Db,a);return null;case "button":a.push(L("button"));var pa=null,qa=null,ca=null,ra=null,sa=null,Ta=null,ta=null,Ua;for(Ua in c)if(v.call(c,Ua)){var da=c[Ua];if(null!=da)switch(Ua){case "children":pa=da;break;case "dangerouslySetInnerHTML":qa=da;break;case "name":ca=da;break;case "formAction":ra=da;break;case "formEncType":sa=da;break;case "formMethod":Ta=da;break;case "formTarget":ta=da;break;default:F(a,Ua,da)}}var Mc=Eb(a,d,e,ra,sa,Ta,ta,ca);a.push(">");null!==
-Mc&&Mc.forEach(Db,a);J(a,qa,pa);if("string"===typeof pa){a.push(w(pa));var Nc=null}else Nc=pa;return Nc;case "form":a.push(L("form"));var Va=null,Oc=null,ia=null,Wa=null,Xa=null,Ya=null,Za;for(Za in c)if(v.call(c,Za)){var ja=c[Za];if(null!=ja)switch(Za){case "children":Va=ja;break;case "dangerouslySetInnerHTML":Oc=ja;break;case "action":ia=ja;break;case "encType":Wa=ja;break;case "method":Xa=ja;break;case "target":Ya=ja;break;default:F(a,Za,ja)}}var Xb=null,Yb=null;if("function"===typeof ia)if("function"===
-typeof ia.$$FORM_ACTION){var qe=Bb(d),Ea=ia.$$FORM_ACTION(qe);ia=Ea.action||"";Wa=Ea.encType;Xa=Ea.method;Ya=Ea.target;Xb=Ea.data;Yb=Ea.name}else a.push(" ","action",'="',Cb,'"'),Ya=Xa=Wa=ia=null,Fb(d,e);null!=ia&&F(a,"action",ia);null!=Wa&&F(a,"encType",Wa);null!=Xa&&F(a,"method",Xa);null!=Ya&&F(a,"target",Ya);a.push(">");null!==Yb&&(a.push('<input type="hidden"'),E(a,"name",Yb),a.push("/>"),null!==Xb&&Xb.forEach(Db,a));J(a,Oc,Va);if("string"===typeof Va){a.push(w(Va));var Pc=null}else Pc=Va;return Pc;
-case "menuitem":a.push(L("menuitem"));for(var sb in c)if(v.call(c,sb)){var Qc=c[sb];if(null!=Qc)switch(sb){case "children":case "dangerouslySetInnerHTML":throw Error(p(400));default:F(a,sb,Qc)}}a.push(">");return null;case "title":if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp)var Rc=Kb(a,c);else Kb(e.hoistableChunks,c),Rc=null;return Rc;case "link":return Hb(a,c,d,e,g,f.insertionMode,!!(f.tagScope&1));case "script":var Zb=c.async;if("string"!==typeof c.src||!c.src||!Zb||"function"===typeof Zb||
+function Hb(a,b,c,d,e,f,g){var h=b.rel,k=b.href,l=b.precedence;if(3===f||g||null!=b.itemProp||"string"!==typeof h||"string"!==typeof k||""===k)return M(a,b),null;if("stylesheet"===b.rel){if("string"!==typeof l||null!=b.disabled||b.onLoad||b.onError)return M(a,b);f=d.styles.get(l);g=c.styleResources.hasOwnProperty(k)?c.styleResources[k]:void 0;null!==g?(c.styleResources[k]=null,f||(f={precedence:z(l),rules:[],hrefs:[],sheets:new Map},d.styles.set(l,f)),b={state:0,props:t({},b,{"data-precedence":b.precedence,
+precedence:null})},g&&(2===g.length&&Ib(b.props,g),(c=d.preloads.stylesheets.get(k))&&0<c.length?c.length=0:b.state=1),f.sheets.set(k,b),d.boundaryResources&&d.boundaryResources.stylesheets.add(b)):f&&(k=f.sheets.get(k))&&d.boundaryResources&&d.boundaryResources.stylesheets.add(k);e&&a.push("\x3c!-- --\x3e");return null}if(b.onLoad||b.onError)return M(a,b);e&&a.push("\x3c!-- --\x3e");switch(b.rel){case "preconnect":case "dns-prefetch":return M(d.preconnectChunks,b);case "preload":return M(d.preloadChunks,
+b);default:return M(d.hoistableChunks,b)}}function M(a,b){a.push(N("link"));for(var c in b)if(y.call(b,c)){var d=b[c];if(null!=d)switch(c){case "children":case "dangerouslySetInnerHTML":throw Error(q(399,"link"));default:J(a,c,d)}}a.push("/>");return null}function Jb(a,b,c){a.push(N(c));for(var d in b)if(y.call(b,d)){var e=b[d];if(null!=e)switch(d){case "children":case "dangerouslySetInnerHTML":throw Error(q(399,c));default:J(a,d,e)}}a.push("/>");return null}
+function Kb(a,b){a.push(N("title"));var c=null,d=null,e;for(e in b)if(y.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:J(a,e,f)}}a.push(">");b=Array.isArray(c)?2>c.length?c[0]:null:c;"function"!==typeof b&&"symbol"!==typeof b&&null!==b&&void 0!==b&&a.push(z(""+b));L(a,d,c);a.push(Lb("title"));return null}
+function Mb(a,b){a.push(N("script"));var c=null,d=null,e;for(e in b)if(y.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:J(a,e,f)}}a.push(">");L(a,d,c);"string"===typeof c&&a.push(z(c));a.push(Lb("script"));return null}
+function Nb(a,b,c){a.push(N(c));var d=c=null,e;for(e in b)if(y.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:J(a,e,f)}}a.push(">");L(a,d,c);return"string"===typeof c?(a.push(z(c)),null):c}var Ob=/^[a-zA-Z][a-zA-Z:_\.\-\d]*$/,Pb=new Map;function N(a){var b=Pb.get(a);if(void 0===b){if(!Ob.test(a))throw Error(q(65,a));b="<"+a;Pb.set(a,b)}return b}
+function Qb(a,b,c,d,e,f,g){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "select":a.push(N("select"));var h=null,k=null,l;for(l in c)if(y.call(c,l)){var n=c[l];if(null!=n)switch(l){case "children":h=n;break;case "dangerouslySetInnerHTML":k=n;break;case "defaultValue":case "value":break;default:J(a,l,n)}}a.push(">");L(a,k,h);return h;case "option":var r=f.selectedValue;a.push(N("option"));var m=null,F=null,D=null,R=null,v;for(v in c)if(y.call(c,
+v)){var u=c[v];if(null!=u)switch(v){case "children":m=u;break;case "selected":D=u;break;case "dangerouslySetInnerHTML":R=u;break;case "value":F=u;default:J(a,v,u)}}if(null!=r){var p=null!==F?""+F:Gb(m);if(Ka(r))for(var G=0;G<r.length;G++){if(""+r[G]===p){a.push(' selected=""');break}}else""+r===p&&a.push(' selected=""')}else D&&a.push(' selected=""');a.push(">");L(a,R,m);return m;case "textarea":a.push(N("textarea"));var x=null,w=null,C=null,O;for(O in c)if(y.call(c,O)){var A=c[O];if(null!=A)switch(O){case "children":C=
+A;break;case "value":x=A;break;case "defaultValue":w=A;break;case "dangerouslySetInnerHTML":throw Error(q(91));default:J(a,O,A)}}null===x&&null!==w&&(x=w);a.push(">");if(null!=C){if(null!=x)throw Error(q(92));if(Ka(C)){if(1<C.length)throw Error(q(93));x=""+C[0]}x=""+C}"string"===typeof x&&"\n"===x[0]&&a.push("\n");null!==x&&a.push(z(""+x));return null;case "input":a.push(N("input"));var fa=null,U=null,P=null,na=null,ha=null,Y=null,Qa=null,Ra=null,Sa=null,oa;for(oa in c)if(y.call(c,oa)){var S=c[oa];
+if(null!=S)switch(oa){case "children":case "dangerouslySetInnerHTML":throw Error(q(399,"input"));case "name":fa=S;break;case "formAction":U=S;break;case "formEncType":P=S;break;case "formMethod":na=S;break;case "formTarget":ha=S;break;case "defaultChecked":Sa=S;break;case "defaultValue":Qa=S;break;case "checked":Ra=S;break;case "value":Y=S;break;default:J(a,oa,S)}}var rb=Eb(a,d,e,U,P,na,ha,fa);null!==Ra?Ab(a,"checked",Ra):null!==Sa&&Ab(a,"checked",Sa);null!==Y?J(a,"value",Y):null!==Qa&&J(a,"value",
+Qa);a.push("/>");null!==rb&&rb.forEach(Db,a);return null;case "button":a.push(N("button"));var pa=null,qa=null,ca=null,ra=null,sa=null,Ta=null,ta=null,Ua;for(Ua in c)if(y.call(c,Ua)){var da=c[Ua];if(null!=da)switch(Ua){case "children":pa=da;break;case "dangerouslySetInnerHTML":qa=da;break;case "name":ca=da;break;case "formAction":ra=da;break;case "formEncType":sa=da;break;case "formMethod":Ta=da;break;case "formTarget":ta=da;break;default:J(a,Ua,da)}}var Mc=Eb(a,d,e,ra,sa,Ta,ta,ca);a.push(">");null!==
+Mc&&Mc.forEach(Db,a);L(a,qa,pa);if("string"===typeof pa){a.push(z(pa));var Nc=null}else Nc=pa;return Nc;case "form":a.push(N("form"));var Va=null,Oc=null,ia=null,Wa=null,Xa=null,Ya=null,Za;for(Za in c)if(y.call(c,Za)){var ja=c[Za];if(null!=ja)switch(Za){case "children":Va=ja;break;case "dangerouslySetInnerHTML":Oc=ja;break;case "action":ia=ja;break;case "encType":Wa=ja;break;case "method":Xa=ja;break;case "target":Ya=ja;break;default:J(a,Za,ja)}}var Xb=null,Yb=null;if("function"===typeof ia)if("function"===
+typeof ia.$$FORM_ACTION){var se=Bb(d),Ea=ia.$$FORM_ACTION(se);ia=Ea.action||"";Wa=Ea.encType;Xa=Ea.method;Ya=Ea.target;Xb=Ea.data;Yb=Ea.name}else a.push(" ","action",'="',Cb,'"'),Ya=Xa=Wa=ia=null,Fb(d,e);null!=ia&&J(a,"action",ia);null!=Wa&&J(a,"encType",Wa);null!=Xa&&J(a,"method",Xa);null!=Ya&&J(a,"target",Ya);a.push(">");null!==Yb&&(a.push('<input type="hidden"'),I(a,"name",Yb),a.push("/>"),null!==Xb&&Xb.forEach(Db,a));L(a,Oc,Va);if("string"===typeof Va){a.push(z(Va));var Pc=null}else Pc=Va;return Pc;
+case "menuitem":a.push(N("menuitem"));for(var sb in c)if(y.call(c,sb)){var Qc=c[sb];if(null!=Qc)switch(sb){case "children":case "dangerouslySetInnerHTML":throw Error(q(400));default:J(a,sb,Qc)}}a.push(">");return null;case "title":if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp)var Rc=Kb(a,c);else Kb(e.hoistableChunks,c),Rc=null;return Rc;case "link":return Hb(a,c,d,e,g,f.insertionMode,!!(f.tagScope&1));case "script":var Zb=c.async;if("string"!==typeof c.src||!c.src||!Zb||"function"===typeof Zb||
 "symbol"===typeof Zb||c.onLoad||c.onError||3===f.insertionMode||f.tagScope&1||null!=c.itemProp)var Sc=Mb(a,c);else{var tb=c.src;if("module"===c.type){var ub=d.moduleScriptResources;var Tc=e.preloads.moduleScripts}else ub=d.scriptResources,Tc=e.preloads.scripts;var vb=ub.hasOwnProperty(tb)?ub[tb]:void 0;if(null!==vb){ub[tb]=null;var $b=c;if(vb){2===vb.length&&($b=t({},c),Ib($b,vb));var Uc=Tc.get(tb);Uc&&(Uc.length=0)}var Vc=[];e.scripts.add(Vc);Mb(Vc,$b)}g&&a.push("\x3c!-- --\x3e");Sc=null}return Sc;
-case "style":var wb=c.precedence,ua=c.href;if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp||"string"!==typeof wb||"string"!==typeof ua||""===ua){a.push(L("style"));var Fa=null,Wc=null,$a;for($a in c)if(v.call(c,$a)){var xb=c[$a];if(null!=xb)switch($a){case "children":Fa=xb;break;case "dangerouslySetInnerHTML":Wc=xb;break;default:F(a,$a,xb)}}a.push(">");var ab=Array.isArray(Fa)?2>Fa.length?Fa[0]:null:Fa;"function"!==typeof ab&&"symbol"!==typeof ab&&null!==ab&&void 0!==ab&&a.push(w(""+ab));J(a,
-Wc,Fa);a.push(Lb("style"));var Xc=null}else{var va=e.styles.get(wb);if(null!==(d.styleResources.hasOwnProperty(ua)?d.styleResources[ua]:void 0)){d.styleResources[ua]=null;va?va.hrefs.push(w(ua)):(va={precedence:w(wb),rules:[],hrefs:[w(ua)],sheets:new Map},e.styles.set(wb,va));var Yc=va.rules,Ga=null,Zc=null,yb;for(yb in c)if(v.call(c,yb)){var ac=c[yb];if(null!=ac)switch(yb){case "children":Ga=ac;break;case "dangerouslySetInnerHTML":Zc=ac}}var bb=Array.isArray(Ga)?2>Ga.length?Ga[0]:null:Ga;"function"!==
-typeof bb&&"symbol"!==typeof bb&&null!==bb&&void 0!==bb&&Yc.push(w(""+bb));J(Yc,Zc,Ga)}va&&e.boundaryResources&&e.boundaryResources.styles.add(va);g&&a.push("\x3c!-- --\x3e");Xc=void 0}return Xc;case "meta":if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp)var $c=Jb(a,c,"meta");else g&&a.push("\x3c!-- --\x3e"),$c="string"===typeof c.charSet?Jb(e.charsetChunks,c,"meta"):"viewport"===c.name?Jb(e.preconnectChunks,c,"meta"):Jb(e.hoistableChunks,c,"meta");return $c;case "listing":case "pre":a.push(L(b));
-var cb=null,db=null,eb;for(eb in c)if(v.call(c,eb)){var zb=c[eb];if(null!=zb)switch(eb){case "children":cb=zb;break;case "dangerouslySetInnerHTML":db=zb;break;default:F(a,eb,zb)}}a.push(">");if(null!=db){if(null!=cb)throw Error(p(60));if("object"!==typeof db||!("__html"in db))throw Error(p(61));var wa=db.__html;null!==wa&&void 0!==wa&&("string"===typeof wa&&0<wa.length&&"\n"===wa[0]?a.push("\n",wa):a.push(""+wa))}"string"===typeof cb&&"\n"===cb[0]&&a.push("\n");return cb;case "img":var I=c.src,C=
-c.srcSet;if(!("lazy"===c.loading||!I&&!C||"string"!==typeof I&&null!=I||"string"!==typeof C&&null!=C)&&"low"!==c.fetchPriority&&!1===!!(f.tagScope&2)&&("string"!==typeof I||":"!==I[4]||"d"!==I[0]&&"D"!==I[0]||"a"!==I[1]&&"A"!==I[1]||"t"!==I[2]&&"T"!==I[2]||"a"!==I[3]&&"A"!==I[3])&&("string"!==typeof C||":"!==C[4]||"d"!==C[0]&&"D"!==C[0]||"a"!==C[1]&&"A"!==C[1]||"t"!==C[2]&&"T"!==C[2]||"a"!==C[3]&&"A"!==C[3])){var ad="string"===typeof c.sizes?c.sizes:void 0,Ha=C?C+"\n"+(ad||""):I,bc=e.preloads.images,
-xa=bc.get(Ha);if(xa){if("high"===c.fetchPriority||10>e.highImagePreloads.size)bc.delete(Ha),e.highImagePreloads.add(xa)}else if(!d.imageResources.hasOwnProperty(Ha)){d.imageResources[Ha]=y;var cc=c.crossOrigin;var bd="string"===typeof cc?"use-credentials"===cc?cc:"":void 0;var X=e.headers,dc;X&&0<X.remainingCapacity&&("high"===c.fetchPriority||500>X.highImagePreloads.length)&&(dc=Rb(I,"image",{imageSrcSet:c.srcSet,imageSizes:c.sizes,crossOrigin:bd,integrity:c.integrity,nonce:c.nonce,type:c.type,fetchPriority:c.fetchPriority,
-referrerPolicy:c.refererPolicy}),2<=(X.remainingCapacity-=dc.length))?(e.resets.image[Ha]=y,X.highImagePreloads&&(X.highImagePreloads+=", "),X.highImagePreloads+=dc):(xa=[],K(xa,{rel:"preload",as:"image",href:C?void 0:I,imageSrcSet:C,imageSizes:ad,crossOrigin:bd,integrity:c.integrity,type:c.type,fetchPriority:c.fetchPriority,referrerPolicy:c.referrerPolicy}),"high"===c.fetchPriority||10>e.highImagePreloads.size?e.highImagePreloads.add(xa):(e.bulkPreloads.add(xa),bc.set(Ha,xa)))}}return Jb(a,c,"img");
+case "style":var wb=c.precedence,ua=c.href;if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp||"string"!==typeof wb||"string"!==typeof ua||""===ua){a.push(N("style"));var Fa=null,Wc=null,$a;for($a in c)if(y.call(c,$a)){var xb=c[$a];if(null!=xb)switch($a){case "children":Fa=xb;break;case "dangerouslySetInnerHTML":Wc=xb;break;default:J(a,$a,xb)}}a.push(">");var ab=Array.isArray(Fa)?2>Fa.length?Fa[0]:null:Fa;"function"!==typeof ab&&"symbol"!==typeof ab&&null!==ab&&void 0!==ab&&a.push(z(""+ab));L(a,
+Wc,Fa);a.push(Lb("style"));var Xc=null}else{var va=e.styles.get(wb);if(null!==(d.styleResources.hasOwnProperty(ua)?d.styleResources[ua]:void 0)){d.styleResources[ua]=null;va?va.hrefs.push(z(ua)):(va={precedence:z(wb),rules:[],hrefs:[z(ua)],sheets:new Map},e.styles.set(wb,va));var Yc=va.rules,Ga=null,Zc=null,yb;for(yb in c)if(y.call(c,yb)){var ac=c[yb];if(null!=ac)switch(yb){case "children":Ga=ac;break;case "dangerouslySetInnerHTML":Zc=ac}}var bb=Array.isArray(Ga)?2>Ga.length?Ga[0]:null:Ga;"function"!==
+typeof bb&&"symbol"!==typeof bb&&null!==bb&&void 0!==bb&&Yc.push(z(""+bb));L(Yc,Zc,Ga)}va&&e.boundaryResources&&e.boundaryResources.styles.add(va);g&&a.push("\x3c!-- --\x3e");Xc=void 0}return Xc;case "meta":if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp)var $c=Jb(a,c,"meta");else g&&a.push("\x3c!-- --\x3e"),$c="string"===typeof c.charSet?Jb(e.charsetChunks,c,"meta"):"viewport"===c.name?Jb(e.preconnectChunks,c,"meta"):Jb(e.hoistableChunks,c,"meta");return $c;case "listing":case "pre":a.push(N(b));
+var cb=null,db=null,eb;for(eb in c)if(y.call(c,eb)){var zb=c[eb];if(null!=zb)switch(eb){case "children":cb=zb;break;case "dangerouslySetInnerHTML":db=zb;break;default:J(a,eb,zb)}}a.push(">");if(null!=db){if(null!=cb)throw Error(q(60));if("object"!==typeof db||!("__html"in db))throw Error(q(61));var wa=db.__html;null!==wa&&void 0!==wa&&("string"===typeof wa&&0<wa.length&&"\n"===wa[0]?a.push("\n",wa):a.push(""+wa))}"string"===typeof cb&&"\n"===cb[0]&&a.push("\n");return cb;case "img":var K=c.src,H=
+c.srcSet;if(!("lazy"===c.loading||!K&&!H||"string"!==typeof K&&null!=K||"string"!==typeof H&&null!=H)&&"low"!==c.fetchPriority&&!1===!!(f.tagScope&2)&&("string"!==typeof K||":"!==K[4]||"d"!==K[0]&&"D"!==K[0]||"a"!==K[1]&&"A"!==K[1]||"t"!==K[2]&&"T"!==K[2]||"a"!==K[3]&&"A"!==K[3])&&("string"!==typeof H||":"!==H[4]||"d"!==H[0]&&"D"!==H[0]||"a"!==H[1]&&"A"!==H[1]||"t"!==H[2]&&"T"!==H[2]||"a"!==H[3]&&"A"!==H[3])){var ad="string"===typeof c.sizes?c.sizes:void 0,Ha=H?H+"\n"+(ad||""):K,bc=e.preloads.images,
+xa=bc.get(Ha);if(xa){if("high"===c.fetchPriority||10>e.highImagePreloads.size)bc.delete(Ha),e.highImagePreloads.add(xa)}else if(!d.imageResources.hasOwnProperty(Ha)){d.imageResources[Ha]=B;var cc=c.crossOrigin;var bd="string"===typeof cc?"use-credentials"===cc?cc:"":void 0;var Z=e.headers,dc;Z&&0<Z.remainingCapacity&&("high"===c.fetchPriority||500>Z.highImagePreloads.length)&&(dc=Rb(K,"image",{imageSrcSet:c.srcSet,imageSizes:c.sizes,crossOrigin:bd,integrity:c.integrity,nonce:c.nonce,type:c.type,fetchPriority:c.fetchPriority,
+referrerPolicy:c.refererPolicy}),2<=(Z.remainingCapacity-=dc.length))?(e.resets.image[Ha]=B,Z.highImagePreloads&&(Z.highImagePreloads+=", "),Z.highImagePreloads+=dc):(xa=[],M(xa,{rel:"preload",as:"image",href:H?void 0:K,imageSrcSet:H,imageSizes:ad,crossOrigin:bd,integrity:c.integrity,type:c.type,fetchPriority:c.fetchPriority,referrerPolicy:c.referrerPolicy}),"high"===c.fetchPriority||10>e.highImagePreloads.size?e.highImagePreloads.add(xa):(e.bulkPreloads.add(xa),bc.set(Ha,xa)))}}return Jb(a,c,"img");
 case "base":case "area":case "br":case "col":case "embed":case "hr":case "keygen":case "param":case "source":case "track":case "wbr":return Jb(a,c,b);case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph":break;case "head":if(2>f.insertionMode&&null===e.headChunks){e.headChunks=[];var cd=Nb(e.headChunks,c,"head")}else cd=Nb(a,c,"head");return cd;case "html":if(0===f.insertionMode&&null===
-e.htmlChunks){e.htmlChunks=[""];var dd=Nb(e.htmlChunks,c,"html")}else dd=Nb(a,c,"html");return dd;default:if(-1!==b.indexOf("-")){a.push(L(b));var ec=null,ed=null,Ia;for(Ia in c)if(v.call(c,Ia)){var ya=c[Ia];if(null!=ya){var re=Ia;switch(Ia){case "children":ec=ya;break;case "dangerouslySetInnerHTML":ed=ya;break;case "style":qb(a,ya);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":break;default:Ba(Ia)&&"function"!==typeof ya&&"symbol"!==typeof ya&&a.push(" ",re,'="',w(ya),
-'"')}}}a.push(">");J(a,ed,ec);return ec}}return Nb(a,c,b)}var Sb=new Map;function Lb(a){var b=Sb.get(a);void 0===b&&(b="</"+a+">",Sb.set(a,b));return b}function Tb(a,b){b=b.bootstrapChunks;for(var c=0;c<b.length-1;c++)a.push(b[c]);return c<b.length?(c=b[c],b.length=0,a.push(c)):!0}function Ub(a,b,c){a.push('\x3c!--$?--\x3e<template id="');if(null===c)throw Error(p(395));a.push(b.boundaryPrefix);b=c.toString(16);a.push(b);return a.push('"></template>')}
+e.htmlChunks){e.htmlChunks=[""];var dd=Nb(e.htmlChunks,c,"html")}else dd=Nb(a,c,"html");return dd;default:if(-1!==b.indexOf("-")){a.push(N(b));var ec=null,ed=null,Ia;for(Ia in c)if(y.call(c,Ia)){var ya=c[Ia];if(null!=ya){var te=Ia;switch(Ia){case "children":ec=ya;break;case "dangerouslySetInnerHTML":ed=ya;break;case "style":qb(a,ya);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":break;default:za(Ia)&&"function"!==typeof ya&&"symbol"!==typeof ya&&a.push(" ",te,'="',z(ya),
+'"')}}}a.push(">");L(a,ed,ec);return ec}}return Nb(a,c,b)}var Sb=new Map;function Lb(a){var b=Sb.get(a);void 0===b&&(b="</"+a+">",Sb.set(a,b));return b}function Tb(a,b,c){c.bootstrapScriptContent=void 0;c.bootstrapScripts=void 0;c.bootstrapModules=void 0;b=b.bootstrapChunks;for(c=0;c<b.length-1;c++)a.push(b[c]);return c<b.length?(c=b[c],b.length=0,a.push(c)):!0}
+function Ub(a,b,c){a.push('\x3c!--$?--\x3e<template id="');if(null===c)throw Error(q(395));a.push(b.boundaryPrefix);b=c.toString(16);a.push(b);return a.push('"></template>')}
 function Vb(a,b,c,d){switch(c.insertionMode){case 0:case 1:case 2:return a.push('<div hidden id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 3:return a.push('<svg aria-hidden="true" style="display:none" id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 4:return a.push('<math aria-hidden="true" style="display:none" id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 5:return a.push('<table hidden id="'),a.push(b.segmentPrefix),
-b=d.toString(16),a.push(b),a.push('">');case 6:return a.push('<table hidden><tbody id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 7:return a.push('<table hidden><tr id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 8:return a.push('<table hidden><colgroup id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');default:throw Error(p(397));}}
-function Wb(a,b){switch(b.insertionMode){case 0:case 1:case 2:return a.push("</div>");case 3:return a.push("</svg>");case 4:return a.push("</math>");case 5:return a.push("</table>");case 6:return a.push("</tbody></table>");case 7:return a.push("</tr></table>");case 8:return a.push("</colgroup></table>");default:throw Error(p(397));}}var fc=/[<\u2028\u2029]/g;
+b=d.toString(16),a.push(b),a.push('">');case 6:return a.push('<table hidden><tbody id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 7:return a.push('<table hidden><tr id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 8:return a.push('<table hidden><colgroup id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');default:throw Error(q(397));}}
+function Wb(a,b){switch(b.insertionMode){case 0:case 1:case 2:return a.push("</div>");case 3:return a.push("</svg>");case 4:return a.push("</math>");case 5:return a.push("</table>");case 6:return a.push("</tbody></table>");case 7:return a.push("</tr></table>");case 8:return a.push("</colgroup></table>");default:throw Error(q(397));}}var fc=/[<\u2028\u2029]/g;
 function gc(a){return JSON.stringify(a).replace(fc,function(b){switch(b){case "<":return"\\u003c";case "\u2028":return"\\u2028";case "\u2029":return"\\u2029";default:throw Error("escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}})}var hc=/[&><\u2028\u2029]/g;
 function ic(a){return JSON.stringify(a).replace(hc,function(b){switch(b){case "&":return"\\u0026";case ">":return"\\u003e";case "<":return"\\u003c";case "\u2028":return"\\u2028";case "\u2029":return"\\u2029";default:throw Error("escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}})}var jc=!1,kc=!0;
 function lc(a){var b=a.rules,c=a.hrefs,d=0;if(c.length){this.push('<style media="not all" data-precedence="');this.push(a.precedence);for(this.push('" data-href="');d<c.length-1;d++)this.push(c[d]),this.push(" ");this.push(c[d]);this.push('">');for(d=0;d<b.length;d++)this.push(b[d]);kc=this.push("</style>");jc=!0;b.length=0;c.length=0}}function mc(a){return 2!==a.state?jc=!0:!1}function nc(a,b,c){jc=!1;kc=!0;b.styles.forEach(lc,a);b.stylesheets.forEach(mc);jc&&(c.stylesToHoist=!0);return kc}
-function O(a){for(var b=0;b<a.length;b++)this.push(a[b]);a.length=0}var oc=[];function pc(a){K(oc,a.props);for(var b=0;b<oc.length;b++)this.push(oc[b]);oc.length=0;a.state=2}
+function Q(a){for(var b=0;b<a.length;b++)this.push(a[b]);a.length=0}var oc=[];function pc(a){M(oc,a.props);for(var b=0;b<oc.length;b++)this.push(oc[b]);oc.length=0;a.state=2}
 function qc(a){var b=0<a.sheets.size;a.sheets.forEach(pc,this);a.sheets.clear();var c=a.rules,d=a.hrefs;if(!b||d.length){this.push('<style data-precedence="');this.push(a.precedence);a=0;if(d.length){for(this.push('" data-href="');a<d.length-1;a++)this.push(d[a]),this.push(" ");this.push(d[a])}this.push('">');for(a=0;a<c.length;a++)this.push(c[a]);this.push("</style>");c.length=0;d.length=0}}
-function rc(a){if(0===a.state){a.state=1;var b=a.props;K(oc,{rel:"preload",as:"style",href:a.props.href,crossOrigin:b.crossOrigin,fetchPriority:b.fetchPriority,integrity:b.integrity,media:b.media,hrefLang:b.hrefLang,referrerPolicy:b.referrerPolicy});for(a=0;a<oc.length;a++)this.push(oc[a]);oc.length=0}}function sc(a){a.sheets.forEach(rc,this);a.sheets.clear()}
-function tc(a,b){a.push("[");var c="[";b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)a.push(c),d=ic(""+d.props.href),a.push(d),a.push("]"),c=",[";else{a.push(c);var e=d.props["data-precedence"],f=d.props,g=ic(""+d.props.href);a.push(g);e=""+e;a.push(",");e=ic(e);a.push(e);for(var h in f)if(v.call(f,h)&&(g=f[h],null!=g))switch(h){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error(p(399,"link"));default:a:{e=
-a;var k=h.toLowerCase();switch(typeof g){case "function":case "symbol":break a}switch(h){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":k="class";g=""+g;break;case "hidden":if(!1===g)break a;g="";break;case "src":case "href":g=""+g;break;default:if(2<h.length&&("o"===h[0]||"O"===h[0])&&("n"===h[1]||"N"===h[1])||!Ba(h))break a;g=""+g}e.push(",");k=ic(k);e.push(k);e.push(",");g=ic(g);e.push(g)}}a.push("]");
+function rc(a){if(0===a.state){a.state=1;var b=a.props;M(oc,{rel:"preload",as:"style",href:a.props.href,crossOrigin:b.crossOrigin,fetchPriority:b.fetchPriority,integrity:b.integrity,media:b.media,hrefLang:b.hrefLang,referrerPolicy:b.referrerPolicy});for(a=0;a<oc.length;a++)this.push(oc[a]);oc.length=0}}function sc(a){a.sheets.forEach(rc,this);a.sheets.clear()}
+function tc(a,b){a.push("[");var c="[";b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)a.push(c),d=ic(""+d.props.href),a.push(d),a.push("]"),c=",[";else{a.push(c);var e=d.props["data-precedence"],f=d.props,g=ic(""+d.props.href);a.push(g);e=""+e;a.push(",");e=ic(e);a.push(e);for(var h in f)if(y.call(f,h)&&(g=f[h],null!=g))switch(h){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error(q(399,"link"));default:a:{e=
+a;var k=h.toLowerCase();switch(typeof g){case "function":case "symbol":break a}switch(h){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":k="class";g=""+g;break;case "hidden":if(!1===g)break a;g="";break;case "src":case "href":g=""+g;break;default:if(2<h.length&&("o"===h[0]||"O"===h[0])&&("n"===h[1]||"N"===h[1])||!za(h))break a;g=""+g}e.push(",");k=ic(k);e.push(k);e.push(",");g=ic(g);e.push(g)}}a.push("]");
 c=",[";d.state=3}});a.push("]")}
-function uc(a,b){a.push("[");var c="[";b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)a.push(c),d=w(JSON.stringify(""+d.props.href)),a.push(d),a.push("]"),c=",[";else{a.push(c);var e=d.props["data-precedence"],f=d.props,g=w(JSON.stringify(""+d.props.href));a.push(g);e=""+e;a.push(",");e=w(JSON.stringify(e));a.push(e);for(var h in f)if(v.call(f,h)&&(g=f[h],null!=g))switch(h){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error(p(399,"link"));
-default:a:{e=a;var k=h.toLowerCase();switch(typeof g){case "function":case "symbol":break a}switch(h){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":k="class";g=""+g;break;case "hidden":if(!1===g)break a;g="";break;case "src":case "href":g=""+g;break;default:if(2<h.length&&("o"===h[0]||"O"===h[0])&&("n"===h[1]||"N"===h[1])||!Ba(h))break a;g=""+g}e.push(",");k=w(JSON.stringify(k));e.push(k);
-e.push(",");g=w(JSON.stringify(g));e.push(g)}}a.push("]");c=",[";d.state=3}});a.push("]")}
-function fb(a){var b=Q?Q:null;if(b){var c=b.resumableState,d=b.renderState;if("string"===typeof a&&a){if(!c.dnsResources.hasOwnProperty(a)){c.dnsResources[a]=null;c=d.headers;var e,f;if(f=c&&0<c.remainingCapacity)f=(e="<"+(""+a).replace(vc,wc)+">; rel=dns-prefetch",2<=(c.remainingCapacity-=e.length));f?(d.resets.dns[a]=null,c.preconnects&&(c.preconnects+=", "),c.preconnects+=e):(e=[],K(e,{href:a,rel:"dns-prefetch"}),d.preconnects.add(e))}xc(b)}}}
-function gb(a,b){var c=Q?Q:null;if(c){var d=c.resumableState,e=c.renderState;if("string"===typeof a&&a){var f="use-credentials"===b?"credentials":"string"===typeof b?"anonymous":"default";if(!d.connectResources[f].hasOwnProperty(a)){d.connectResources[f][a]=null;d=e.headers;var g,h;if(h=d&&0<d.remainingCapacity){h="<"+(""+a).replace(vc,wc)+">; rel=preconnect";if("string"===typeof b){var k=(""+b).replace(yc,zc);h+='; crossorigin="'+k+'"'}h=(g=h,2<=(d.remainingCapacity-=g.length))}h?(e.resets.connect[f][a]=
-null,d.preconnects&&(d.preconnects+=", "),d.preconnects+=g):(f=[],K(f,{rel:"preconnect",href:a,crossOrigin:b}),e.preconnects.add(f))}xc(c)}}}
-function hb(a,b,c){var d=Q?Q:null;if(d){var e=d.resumableState,f=d.renderState;if(b&&a){switch(b){case "image":if(c){var g=c.imageSrcSet;var h=c.imageSizes;var k=c.fetchPriority}var l=g?g+"\n"+(h||""):a;if(e.imageResources.hasOwnProperty(l))return;e.imageResources[l]=y;e=f.headers;var n;e&&0<e.remainingCapacity&&"high"===k&&(n=Rb(a,b,c),2<=(e.remainingCapacity-=n.length))?(f.resets.image[l]=y,e.highImagePreloads&&(e.highImagePreloads+=", "),e.highImagePreloads+=n):(e=[],K(e,t({rel:"preload",href:g?
-void 0:a,as:b},c)),"high"===k?f.highImagePreloads.add(e):(f.bulkPreloads.add(e),f.preloads.images.set(l,e)));break;case "style":if(e.styleResources.hasOwnProperty(a))return;g=[];K(g,t({rel:"preload",href:a,as:b},c));e.styleResources[a]=!c||"string"!==typeof c.crossOrigin&&"string"!==typeof c.integrity?y:[c.crossOrigin,c.integrity];f.preloads.stylesheets.set(a,g);f.bulkPreloads.add(g);break;case "script":if(e.scriptResources.hasOwnProperty(a))return;g=[];f.preloads.scripts.set(a,g);f.bulkPreloads.add(g);
-K(g,t({rel:"preload",href:a,as:b},c));e.scriptResources[a]=!c||"string"!==typeof c.crossOrigin&&"string"!==typeof c.integrity?y:[c.crossOrigin,c.integrity];break;default:if(e.unknownResources.hasOwnProperty(b)){if(g=e.unknownResources[b],g.hasOwnProperty(a))return}else g={},e.unknownResources[b]=g;g[a]=y;if((e=f.headers)&&0<e.remainingCapacity&&"font"===b&&(l=Rb(a,b,c),2<=(e.remainingCapacity-=l.length)))f.resets.font[a]=y,e.fontPreloads&&(e.fontPreloads+=", "),e.fontPreloads+=l;else switch(e=[],
-a=t({rel:"preload",href:a,as:b},c),K(e,a),b){case "font":f.fontPreloads.add(e);break;default:f.bulkPreloads.add(e)}}xc(d)}}}
-function ib(a,b){var c=Q?Q:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=b&&"string"===typeof b.as?b.as:"script";switch(f){case "script":if(d.moduleScriptResources.hasOwnProperty(a))return;f=[];d.moduleScriptResources[a]=!b||"string"!==typeof b.crossOrigin&&"string"!==typeof b.integrity?y:[b.crossOrigin,b.integrity];e.preloads.moduleScripts.set(a,f);break;default:if(d.moduleUnknownResources.hasOwnProperty(f)){var g=d.unknownResources[f];if(g.hasOwnProperty(a))return}else g={},d.moduleUnknownResources[f]=
-g;f=[];g[a]=y}K(f,t({rel:"modulepreload",href:a},b));e.bulkPreloads.add(f);xc(c)}}}
-function jb(a,b,c){var d=Q?Q:null;if(d){var e=d.resumableState,f=d.renderState;if(a){b=b||"default";var g=f.styles.get(b),h=e.styleResources.hasOwnProperty(a)?e.styleResources[a]:void 0;null!==h&&(e.styleResources[a]=null,g||(g={precedence:w(b),rules:[],hrefs:[],sheets:new Map},f.styles.set(b,g)),b={state:0,props:t({rel:"stylesheet",href:a,"data-precedence":b},c)},h&&(2===h.length&&Ib(b.props,h),(f=f.preloads.stylesheets.get(a))&&0<f.length?f.length=0:b.state=1),g.sheets.set(a,b),xc(d))}}}
-function kb(a,b){var c=Q?Q:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=d.scriptResources.hasOwnProperty(a)?d.scriptResources[a]:void 0;null!==f&&(d.scriptResources[a]=null,b=t({src:a,async:!0},b),f&&(2===f.length&&Ib(b,f),a=e.preloads.scripts.get(a))&&(a.length=0),a=[],e.scripts.add(a),Mb(a,b),xc(c))}}}
-function lb(a,b){var c=Q?Q:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=d.moduleScriptResources.hasOwnProperty(a)?d.moduleScriptResources[a]:void 0;null!==f&&(d.moduleScriptResources[a]=null,b=t({src:a,type:"module",async:!0},b),f&&(2===f.length&&Ib(b,f),a=e.preloads.moduleScripts.get(a))&&(a.length=0),a=[],e.scripts.add(a),Mb(a,b),xc(c))}}}function Ib(a,b){null==a.crossOrigin&&(a.crossOrigin=b[0]);null==a.integrity&&(a.integrity=b[1])}
-function Rb(a,b,c){a=(""+a).replace(vc,wc);b=(""+b).replace(yc,zc);b="<"+a+'>; rel=preload; as="'+b+'"';for(var d in c)v.call(c,d)&&(a=c[d],"string"===typeof a&&(b+="; "+d.toLowerCase()+'="'+(""+a).replace(yc,zc)+'"'));return b}var vc=/[<>\r\n]/g;
+function uc(a,b){a.push("[");var c="[";b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)a.push(c),d=z(JSON.stringify(""+d.props.href)),a.push(d),a.push("]"),c=",[";else{a.push(c);var e=d.props["data-precedence"],f=d.props,g=z(JSON.stringify(""+d.props.href));a.push(g);e=""+e;a.push(",");e=z(JSON.stringify(e));a.push(e);for(var h in f)if(y.call(f,h)&&(g=f[h],null!=g))switch(h){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error(q(399,"link"));
+default:a:{e=a;var k=h.toLowerCase();switch(typeof g){case "function":case "symbol":break a}switch(h){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":k="class";g=""+g;break;case "hidden":if(!1===g)break a;g="";break;case "src":case "href":g=""+g;break;default:if(2<h.length&&("o"===h[0]||"O"===h[0])&&("n"===h[1]||"N"===h[1])||!za(h))break a;g=""+g}e.push(",");k=z(JSON.stringify(k));e.push(k);
+e.push(",");g=z(JSON.stringify(g));e.push(g)}}a.push("]");c=",[";d.state=3}});a.push("]")}
+function Oa(a){var b=T?T:null;if(b){var c=b.resumableState,d=b.renderState;if("string"===typeof a&&a){if(!c.dnsResources.hasOwnProperty(a)){c.dnsResources[a]=null;c=d.headers;var e,f;if(f=c&&0<c.remainingCapacity)f=(e="<"+(""+a).replace(vc,wc)+">; rel=dns-prefetch",2<=(c.remainingCapacity-=e.length));f?(d.resets.dns[a]=null,c.preconnects&&(c.preconnects+=", "),c.preconnects+=e):(e=[],M(e,{href:a,rel:"dns-prefetch"}),d.preconnects.add(e))}xc(b)}}}
+function Pa(a,b){var c=T?T:null;if(c){var d=c.resumableState,e=c.renderState;if("string"===typeof a&&a){var f="use-credentials"===b?"credentials":"string"===typeof b?"anonymous":"default";if(!d.connectResources[f].hasOwnProperty(a)){d.connectResources[f][a]=null;d=e.headers;var g,h;if(h=d&&0<d.remainingCapacity){h="<"+(""+a).replace(vc,wc)+">; rel=preconnect";if("string"===typeof b){var k=(""+b).replace(yc,zc);h+='; crossorigin="'+k+'"'}h=(g=h,2<=(d.remainingCapacity-=g.length))}h?(e.resets.connect[f][a]=
+null,d.preconnects&&(d.preconnects+=", "),d.preconnects+=g):(f=[],M(f,{rel:"preconnect",href:a,crossOrigin:b}),e.preconnects.add(f))}xc(c)}}}
+function fb(a,b,c){var d=T?T:null;if(d){var e=d.resumableState,f=d.renderState;if(b&&a){switch(b){case "image":if(c){var g=c.imageSrcSet;var h=c.imageSizes;var k=c.fetchPriority}var l=g?g+"\n"+(h||""):a;if(e.imageResources.hasOwnProperty(l))return;e.imageResources[l]=B;e=f.headers;var n;e&&0<e.remainingCapacity&&"high"===k&&(n=Rb(a,b,c),2<=(e.remainingCapacity-=n.length))?(f.resets.image[l]=B,e.highImagePreloads&&(e.highImagePreloads+=", "),e.highImagePreloads+=n):(e=[],M(e,t({rel:"preload",href:g?
+void 0:a,as:b},c)),"high"===k?f.highImagePreloads.add(e):(f.bulkPreloads.add(e),f.preloads.images.set(l,e)));break;case "style":if(e.styleResources.hasOwnProperty(a))return;g=[];M(g,t({rel:"preload",href:a,as:b},c));e.styleResources[a]=!c||"string"!==typeof c.crossOrigin&&"string"!==typeof c.integrity?B:[c.crossOrigin,c.integrity];f.preloads.stylesheets.set(a,g);f.bulkPreloads.add(g);break;case "script":if(e.scriptResources.hasOwnProperty(a))return;g=[];f.preloads.scripts.set(a,g);f.bulkPreloads.add(g);
+M(g,t({rel:"preload",href:a,as:b},c));e.scriptResources[a]=!c||"string"!==typeof c.crossOrigin&&"string"!==typeof c.integrity?B:[c.crossOrigin,c.integrity];break;default:if(e.unknownResources.hasOwnProperty(b)){if(g=e.unknownResources[b],g.hasOwnProperty(a))return}else g={},e.unknownResources[b]=g;g[a]=B;if((e=f.headers)&&0<e.remainingCapacity&&"font"===b&&(l=Rb(a,b,c),2<=(e.remainingCapacity-=l.length)))f.resets.font[a]=B,e.fontPreloads&&(e.fontPreloads+=", "),e.fontPreloads+=l;else switch(e=[],
+a=t({rel:"preload",href:a,as:b},c),M(e,a),b){case "font":f.fontPreloads.add(e);break;default:f.bulkPreloads.add(e)}}xc(d)}}}
+function gb(a,b){var c=T?T:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=b&&"string"===typeof b.as?b.as:"script";switch(f){case "script":if(d.moduleScriptResources.hasOwnProperty(a))return;f=[];d.moduleScriptResources[a]=!b||"string"!==typeof b.crossOrigin&&"string"!==typeof b.integrity?B:[b.crossOrigin,b.integrity];e.preloads.moduleScripts.set(a,f);break;default:if(d.moduleUnknownResources.hasOwnProperty(f)){var g=d.unknownResources[f];if(g.hasOwnProperty(a))return}else g={},d.moduleUnknownResources[f]=
+g;f=[];g[a]=B}M(f,t({rel:"modulepreload",href:a},b));e.bulkPreloads.add(f);xc(c)}}}
+function hb(a,b,c){var d=T?T:null;if(d){var e=d.resumableState,f=d.renderState;if(a){b=b||"default";var g=f.styles.get(b),h=e.styleResources.hasOwnProperty(a)?e.styleResources[a]:void 0;null!==h&&(e.styleResources[a]=null,g||(g={precedence:z(b),rules:[],hrefs:[],sheets:new Map},f.styles.set(b,g)),b={state:0,props:t({rel:"stylesheet",href:a,"data-precedence":b},c)},h&&(2===h.length&&Ib(b.props,h),(f=f.preloads.stylesheets.get(a))&&0<f.length?f.length=0:b.state=1),g.sheets.set(a,b),xc(d))}}}
+function ib(a,b){var c=T?T:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=d.scriptResources.hasOwnProperty(a)?d.scriptResources[a]:void 0;null!==f&&(d.scriptResources[a]=null,b=t({src:a,async:!0},b),f&&(2===f.length&&Ib(b,f),a=e.preloads.scripts.get(a))&&(a.length=0),a=[],e.scripts.add(a),Mb(a,b),xc(c))}}}
+function jb(a,b){var c=T?T:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=d.moduleScriptResources.hasOwnProperty(a)?d.moduleScriptResources[a]:void 0;null!==f&&(d.moduleScriptResources[a]=null,b=t({src:a,type:"module",async:!0},b),f&&(2===f.length&&Ib(b,f),a=e.preloads.moduleScripts.get(a))&&(a.length=0),a=[],e.scripts.add(a),Mb(a,b),xc(c))}}}function Ib(a,b){null==a.crossOrigin&&(a.crossOrigin=b[0]);null==a.integrity&&(a.integrity=b[1])}
+function Rb(a,b,c){a=(""+a).replace(vc,wc);b=(""+b).replace(yc,zc);b="<"+a+'>; rel=preload; as="'+b+'"';for(var d in c)y.call(c,d)&&(a=c[d],"string"===typeof a&&(b+="; "+d.toLowerCase()+'="'+(""+a).replace(yc,zc)+'"'));return b}var vc=/[<>\r\n]/g;
 function wc(a){switch(a){case "<":return"%3C";case ">":return"%3E";case "\n":return"%0A";case "\r":return"%0D";default:throw Error("escapeLinkHrefForHeaderContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}}var yc=/["';,\r\n]/g;
 function zc(a){switch(a){case '"':return"%22";case "'":return"%27";case ";":return"%3B";case ",":return"%2C";case "\n":return"%0A";case "\r":return"%0D";default:throw Error("escapeStringForLinkHeaderQuotedParamValueContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}}function Ac(a){this.styles.add(a)}function Bc(a){this.stylesheets.add(a)}
 function Cc(a,b,c){if(b=a.onHeaders){var d=a.headers;if(d){var e=d.preconnects;d.fontPreloads&&(e&&(e+=", "),e+=d.fontPreloads);d.highImagePreloads&&(e&&(e+=", "),e+=d.highImagePreloads);if(!c){c=a.styles.values();var f=c.next();a:for(;0<d.remainingCapacity&&!f.done;f=c.next()){f=f.value.sheets.values();for(var g=f.next();0<d.remainingCapacity&&!g.done;g=f.next()){var h=g.value;g=h.props;var k=g.href;h=h.props;h=Rb(h.href,"style",{crossOrigin:h.crossOrigin,integrity:h.integrity,nonce:h.nonce,type:h.type,
-fetchPriority:h.fetchPriority,referrerPolicy:h.referrerPolicy,media:h.media});if(2<=(d.remainingCapacity-=h.length))a.resets.style[k]=y,e&&(e+=", "),e+=h,a.resets.style[k]="string"===typeof g.crossOrigin||"string"===typeof g.integrity?[g.crossOrigin,g.integrity]:y;else break a}}}e?b({Link:e}):b({});a.headers=null}}}
-function Dc(a,b){var c=a.idPrefix;a=c+"P:";var d=c+"S:";c+="B:";var e=new Set,f=new Set,g=new Set,h=new Map,k=new Set,l=new Set,n=new Set,r={images:new Map,stylesheets:new Map,scripts:new Map,moduleScripts:new Map};return{placeholderPrefix:a,segmentPrefix:d,boundaryPrefix:c,startInlineScript:"<script>",htmlChunks:null,headChunks:null,externalRuntimeScript:null,bootstrapChunks:[],onHeaders:void 0,headers:null,resets:{font:{},dns:{},connect:{default:{},anonymous:{},credentials:{}},image:{},style:{}},
-charsetChunks:[],preconnectChunks:[],importMapChunks:[],preloadChunks:[],hoistableChunks:[],preconnects:e,fontPreloads:f,highImagePreloads:g,styles:h,bootstrapScripts:k,scripts:l,bulkPreloads:n,preloads:r,boundaryResources:null,stylesToHoist:!1,generateStaticMarkup:b}}function Ec(a,b,c,d){if(c.generateStaticMarkup)return a.push(w(b)),!1;""===b?a=d:(d&&a.push("\x3c!-- --\x3e"),a.push(w(b)),a=!0);return a}
+fetchPriority:h.fetchPriority,referrerPolicy:h.referrerPolicy,media:h.media});if(2<=(d.remainingCapacity-=h.length))a.resets.style[k]=B,e&&(e+=", "),e+=h,a.resets.style[k]="string"===typeof g.crossOrigin||"string"===typeof g.integrity?[g.crossOrigin,g.integrity]:B;else break a}}}e?b({Link:e}):b({});a.headers=null}}}
+function Dc(a,b){var c=a.idPrefix,d=[],e=a.bootstrapScriptContent,f=a.bootstrapScripts,g=a.bootstrapModules;void 0!==e&&d.push("<script>",(""+e).replace(lb,mb),"\x3c/script>");e=c+"P:";var h=c+"S:";c+="B:";var k=new Set,l=new Set,n=new Set,r=new Map,m=new Set,F=new Set,D=new Set,R={images:new Map,stylesheets:new Map,scripts:new Map,moduleScripts:new Map};if(void 0!==f)for(var v=0;v<f.length;v++){var u=f[v],p,G=void 0,x=void 0,w={rel:"preload",as:"script",fetchPriority:"low",nonce:void 0};"string"===
+typeof u?w.href=p=u:(w.href=p=u.src,w.integrity=x="string"===typeof u.integrity?u.integrity:void 0,w.crossOrigin=G="string"===typeof u||null==u.crossOrigin?void 0:"use-credentials"===u.crossOrigin?"use-credentials":"");u=a;var C=p;u.scriptResources[C]=null;u.moduleScriptResources[C]=null;u=[];M(u,w);m.add(u);d.push('<script src="',z(p));"string"===typeof x&&d.push('" integrity="',z(x));"string"===typeof G&&d.push('" crossorigin="',z(G));d.push('" async="">\x3c/script>')}if(void 0!==g)for(f=0;f<g.length;f++)w=
+g[f],G=p=void 0,x={rel:"modulepreload",fetchPriority:"low",nonce:void 0},"string"===typeof w?x.href=v=w:(x.href=v=w.src,x.integrity=G="string"===typeof w.integrity?w.integrity:void 0,x.crossOrigin=p="string"===typeof w||null==w.crossOrigin?void 0:"use-credentials"===w.crossOrigin?"use-credentials":""),w=a,u=v,w.scriptResources[u]=null,w.moduleScriptResources[u]=null,w=[],M(w,x),m.add(w),d.push('<script type="module" src="',z(v)),"string"===typeof G&&d.push('" integrity="',z(G)),"string"===typeof p&&
+d.push('" crossorigin="',z(p)),d.push('" async="">\x3c/script>');return{placeholderPrefix:e,segmentPrefix:h,boundaryPrefix:c,startInlineScript:"<script>",htmlChunks:null,headChunks:null,externalRuntimeScript:null,bootstrapChunks:d,onHeaders:void 0,headers:null,resets:{font:{},dns:{},connect:{default:{},anonymous:{},credentials:{}},image:{},style:{}},charsetChunks:[],preconnectChunks:[],importMapChunks:[],preloadChunks:[],hoistableChunks:[],preconnects:k,fontPreloads:l,highImagePreloads:n,styles:r,
+bootstrapScripts:m,scripts:F,bulkPreloads:D,preloads:R,boundaryResources:null,stylesToHoist:!1,generateStaticMarkup:b}}function Ec(a,b,c,d){if(c.generateStaticMarkup)return a.push(z(b)),!1;""===b?a=d:(d&&a.push("\x3c!-- --\x3e"),a.push(z(b)),a=!0);return a}
 var Fc=Symbol.for("react.element"),Gc=Symbol.for("react.portal"),Hc=Symbol.for("react.fragment"),Ic=Symbol.for("react.strict_mode"),Jc=Symbol.for("react.profiler"),Kc=Symbol.for("react.provider"),Lc=Symbol.for("react.context"),fd=Symbol.for("react.server_context"),gd=Symbol.for("react.forward_ref"),hd=Symbol.for("react.suspense"),id=Symbol.for("react.suspense_list"),jd=Symbol.for("react.memo"),kd=Symbol.for("react.lazy"),ld=Symbol.for("react.scope"),md=Symbol.for("react.debug_trace_mode"),nd=Symbol.for("react.offscreen"),
 od=Symbol.for("react.legacy_hidden"),pd=Symbol.for("react.cache"),qd=Symbol.for("react.default_value"),rd=Symbol.iterator;
 function sd(a){if(null==a)return null;if("function"===typeof a)return a.displayName||a.name||null;if("string"===typeof a)return a;switch(a){case Hc:return"Fragment";case Gc:return"Portal";case Jc:return"Profiler";case Ic:return"StrictMode";case hd:return"Suspense";case id:return"SuspenseList";case pd:return"Cache"}if("object"===typeof a)switch(a.$$typeof){case Lc:return(a.displayName||"Context")+".Consumer";case Kc:return(a._context.displayName||"Context")+".Provider";case gd:var b=a.render;a=a.displayName;
 a||(a=b.displayName||b.name||"",a=""!==a?"ForwardRef("+a+")":"ForwardRef");return a;case jd:return b=a.displayName||null,null!==b?b:sd(a.type)||"Memo";case kd:b=a._payload;a=a._init;try{return sd(a(b))}catch(c){}}return null}var td={};function ud(a,b){a=a.contextTypes;if(!a)return td;var c={},d;for(d in a)c[d]=b[d];return c}var vd=null;
-function wd(a,b){if(a!==b){a.context._currentValue2=a.parentValue;a=a.parent;var c=b.parent;if(null===a){if(null!==c)throw Error(p(401));}else{if(null===c)throw Error(p(401));wd(a,c)}b.context._currentValue2=b.value}}function xd(a){a.context._currentValue2=a.parentValue;a=a.parent;null!==a&&xd(a)}function yd(a){var b=a.parent;null!==b&&yd(b);a.context._currentValue2=a.value}
-function zd(a,b){a.context._currentValue2=a.parentValue;a=a.parent;if(null===a)throw Error(p(402));a.depth===b.depth?wd(a,b):zd(a,b)}function Ad(a,b){var c=b.parent;if(null===c)throw Error(p(402));a.depth===c.depth?wd(a,c):Ad(a,c);b.context._currentValue2=b.value}function Bd(a){var b=vd;b!==a&&(null===b?yd(a):null===a?xd(b):b.depth===a.depth?wd(b,a):b.depth>a.depth?zd(b,a):Ad(b,a),vd=a)}
+function wd(a,b){if(a!==b){a.context._currentValue2=a.parentValue;a=a.parent;var c=b.parent;if(null===a){if(null!==c)throw Error(q(401));}else{if(null===c)throw Error(q(401));wd(a,c)}b.context._currentValue2=b.value}}function xd(a){a.context._currentValue2=a.parentValue;a=a.parent;null!==a&&xd(a)}function yd(a){var b=a.parent;null!==b&&yd(b);a.context._currentValue2=a.value}
+function zd(a,b){a.context._currentValue2=a.parentValue;a=a.parent;if(null===a)throw Error(q(402));a.depth===b.depth?wd(a,b):zd(a,b)}function Ad(a,b){var c=b.parent;if(null===c)throw Error(q(402));a.depth===c.depth?wd(a,c):Ad(a,c);b.context._currentValue2=b.value}function Bd(a){var b=vd;b!==a&&(null===b?yd(a):null===a?xd(b):b.depth===a.depth?wd(b,a):b.depth>a.depth?zd(b,a):Ad(b,a),vd=a)}
 var Cd={isMounted:function(){return!1},enqueueSetState:function(a,b){a=a._reactInternals;null!==a.queue&&a.queue.push(b)},enqueueReplaceState:function(a,b){a=a._reactInternals;a.replace=!0;a.queue=[b]},enqueueForceUpdate:function(){}};
 function Dd(a,b,c,d){var e=void 0!==a.state?a.state:null;a.updater=Cd;a.props=c;a.state=e;var f={queue:[],replace:!1};a._reactInternals=f;var g=b.contextType;a.context="object"===typeof g&&null!==g?g._currentValue2:d;g=b.getDerivedStateFromProps;"function"===typeof g&&(g=g(c,e),e=null===g||void 0===g?e:t({},e,g),a.state=e);if("function"!==typeof b.getDerivedStateFromProps&&"function"!==typeof a.getSnapshotBeforeUpdate&&("function"===typeof a.UNSAFE_componentWillMount||"function"===typeof a.componentWillMount))if(b=
 a.state,"function"===typeof a.componentWillMount&&a.componentWillMount(),"function"===typeof a.UNSAFE_componentWillMount&&a.UNSAFE_componentWillMount(),b!==a.state&&Cd.enqueueReplaceState(a,a.state,null),null!==f.queue&&0<f.queue.length)if(b=f.queue,g=f.replace,f.queue=null,f.replace=!1,g&&1===b.length)a.state=b[0];else{f=g?b[0]:a.state;e=!0;for(g=g?1:0;g<b.length;g++){var h=b[g];h="function"===typeof h?h.call(a,f,c,d):h;null!=h&&(e?(e=!1,f=t({},f,h)):t(f,h))}a.state=f}else f.queue=null}
-var Ed={id:1,overflow:""};function Fd(a,b,c){var d=a.id;a=a.overflow;var e=32-Gd(d)-1;d&=~(1<<e);c+=1;var f=32-Gd(b)+e;if(30<f){var g=e-e%5;f=(d&(1<<g)-1).toString(32);d>>=g;e-=g;return{id:1<<32-Gd(b)+e|c<<e|d,overflow:f+a}}return{id:1<<f|c<<e|d,overflow:a}}var Gd=Math.clz32?Math.clz32:Hd,Id=Math.log,Jd=Math.LN2;function Hd(a){a>>>=0;return 0===a?32:31-(Id(a)/Jd|0)|0}var Kd=Error(p(460));function Ld(){}
+var Ed={id:1,overflow:""};function Fd(a,b,c){var d=a.id;a=a.overflow;var e=32-Gd(d)-1;d&=~(1<<e);c+=1;var f=32-Gd(b)+e;if(30<f){var g=e-e%5;f=(d&(1<<g)-1).toString(32);d>>=g;e-=g;return{id:1<<32-Gd(b)+e|c<<e|d,overflow:f+a}}return{id:1<<f|c<<e|d,overflow:a}}var Gd=Math.clz32?Math.clz32:Hd,Id=Math.log,Jd=Math.LN2;function Hd(a){a>>>=0;return 0===a?32:31-(Id(a)/Jd|0)|0}var Kd=Error(q(460));function Ld(){}
 function Md(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(Ld,Ld),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;default:if("string"!==typeof b.status)switch(a=b,a.status="pending",a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}}),b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;}Nd=b;throw Kd;}}var Nd=null;
-function Od(){if(null===Nd)throw Error(p(459));var a=Nd;Nd=null;return a}function Pd(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var Qd="function"===typeof Object.is?Object.is:Pd,S=null,Rd=null,Sd=null,Td=null,Ud=null,U=null,Vd=!1,Wd=!1,Xd=0,Yd=0,Zd=-1,$d=0,ae=null,be=null,ce=0;function de(){if(null===S)throw Error(p(321));return S}function ee(){if(0<ce)throw Error(p(312));return{memoizedState:null,queue:null,next:null}}
-function fe(){null===U?null===Ud?(Vd=!1,Ud=U=ee()):(Vd=!0,U=Ud):null===U.next?(Vd=!1,U=U.next=ee()):(Vd=!0,U=U.next);return U}function ge(a,b,c,d){for(;Wd;)Wd=!1,Yd=Xd=0,Zd=-1,$d=0,ce+=1,U=null,c=a(b,d);he();return c}function ie(){var a=ae;ae=null;return a}function he(){Td=Sd=Rd=S=null;Wd=!1;Ud=null;ce=0;U=be=null}function je(a,b){return"function"===typeof b?b(a):b}
-function ke(a,b,c){S=de();U=fe();if(Vd){var d=U.queue;b=d.dispatch;if(null!==be&&(c=be.get(d),void 0!==c)){be.delete(d);d=U.memoizedState;do d=a(d,c.action),c=c.next;while(null!==c);U.memoizedState=d;return[d,b]}return[U.memoizedState,b]}a=a===je?"function"===typeof b?b():b:void 0!==c?c(b):b;U.memoizedState=a;a=U.queue={last:null,dispatch:null};a=a.dispatch=le.bind(null,S,a);return[U.memoizedState,a]}
-function me(a,b){S=de();U=fe();b=void 0===b?null:b;if(null!==U){var c=U.memoizedState;if(null!==c&&null!==b){var d=c[1];a:if(null===d)d=!1;else{for(var e=0;e<d.length&&e<b.length;e++)if(!Qd(b[e],d[e])){d=!1;break a}d=!0}if(d)return c[0]}}a=a();U.memoizedState=[a,b];return a}function le(a,b,c){if(25<=ce)throw Error(p(301));if(a===S)if(Wd=!0,a={action:c,next:null},null===be&&(be=new Map),c=be.get(b),void 0===c)be.set(b,a);else{for(b=c;null!==b.next;)b=b.next;b.next=a}}
-function ne(){throw Error(p(394));}function oe(){throw Error(p(479));}function pe(a){var b=$d;$d+=1;null===ae&&(ae=[]);return Md(ae,a,b)}function se(){throw Error(p(393));}function te(){}
-var ve={readContext:function(a){return a._currentValue2},use:function(a){if(null!==a&&"object"===typeof a){if("function"===typeof a.then)return pe(a);if(a.$$typeof===Lc||a.$$typeof===fd)return a._currentValue2}throw Error(p(438,String(a)));},useContext:function(a){de();return a._currentValue2},useMemo:me,useReducer:ke,useRef:function(a){S=de();U=fe();var b=U.memoizedState;return null===b?(a={current:a},U.memoizedState=a):b},useState:function(a){return ke(je,a)},useInsertionEffect:te,useLayoutEffect:te,
-useCallback:function(a,b){return me(function(){return a},b)},useImperativeHandle:te,useEffect:te,useDebugValue:te,useDeferredValue:function(a){de();return a},useTransition:function(){de();return[!1,ne]},useId:function(){var a=Rd.treeContext;var b=a.overflow;a=a.id;a=(a&~(1<<32-Gd(a)-1)).toString(32)+b;var c=ue;if(null===c)throw Error(p(404));b=Xd++;a=":"+c.idPrefix+"R"+a;0<b&&(a+="H"+b.toString(32));return a+":"},useSyncExternalStore:function(a,b,c){if(void 0===c)throw Error(p(407));return c()},useCacheRefresh:function(){return se},
-useHostTransitionStatus:function(){de();return Oa},useOptimistic:function(a){de();return[a,oe]},useFormState:function(a,b,c){de();var d=Yd++,e=Sd;if("function"===typeof a.$$FORM_ACTION){var f=null,g=Td;e=e.formState;var h=a.$$IS_SIGNATURE_EQUAL;if(null!==e&&"function"===typeof h){var k=e[1];h.call(a,e[2],e[3])&&(f=void 0!==c?"p"+c:"k"+la(JSON.stringify([g,null,d]),0),k===f&&(Zd=d,b=e[0]))}var l=a.bind(null,b);a=function(r){l(r)};"function"===typeof l.$$FORM_ACTION&&(a.$$FORM_ACTION=function(r){r=
-l.$$FORM_ACTION(r);void 0!==c&&(c+="",r.action=c);var m=r.data;m&&(null===f&&(f=void 0!==c?"p"+c:"k"+la(JSON.stringify([g,null,d]),0)),m.append("$ACTION_KEY",f));return r});return[b,a]}var n=a.bind(null,b);return[b,function(r){n(r)}]}},ue=null,we={getCacheSignal:function(){throw Error(p(248));},getCacheForType:function(){throw Error(p(248));}},xe=Na.ReactCurrentDispatcher,ye=Na.ReactCurrentCache;function ze(a){console.error(a);return null}function Ae(){}
-function Be(a,b,c,d,e,f,g,h,k,l,n,r){Pa.current=mb;var m=[],G=new Set;b={destination:null,flushScheduled:!1,resumableState:b,renderState:c,rootFormatContext:d,progressiveChunkSize:void 0===e?12800:e,status:0,fatalError:null,nextSegmentId:0,allPendingTasks:0,pendingRootTasks:0,completedRootSegment:null,abortableTasks:G,pingedTasks:m,clientRenderedBoundaries:[],completedBoundaries:[],partialBoundaries:[],trackedPostpones:null,onError:void 0===f?ze:f,onPostpone:void 0===n?Ae:n,onAllReady:void 0===g?
-Ae:g,onShellReady:void 0===h?Ae:h,onShellError:void 0===k?Ae:k,onFatalError:void 0===l?Ae:l,formState:void 0===r?null:r};c=Ce(b,0,null,d,!1,!1);c.parentFlushed=!0;a=De(b,null,a,-1,null,c,G,null,d,td,null,Ed);m.push(a);return b}var Q=null;function Ee(a,b){a.pingedTasks.push(b);1===a.pingedTasks.length&&(a.flushScheduled=null!==a.destination,Fe(a))}
-function Ge(a,b){return{status:0,rootSegmentID:-1,parentFlushed:!1,pendingTasks:0,completedSegments:[],byteSize:0,fallbackAbortableTasks:b,errorDigest:null,resources:{styles:new Set,stylesheets:new Set},trackedContentKeyPath:null,trackedFallbackNode:null}}
-function De(a,b,c,d,e,f,g,h,k,l,n,r){a.allPendingTasks++;null===e?a.pendingRootTasks++:e.pendingTasks++;var m={replay:null,node:c,childIndex:d,ping:function(){return Ee(a,m)},blockedBoundary:e,blockedSegment:f,abortSet:g,keyPath:h,formatContext:k,legacyContext:l,context:n,treeContext:r,thenableState:b};g.add(m);return m}
-function He(a,b,c,d,e,f,g,h,k,l,n,r){a.allPendingTasks++;null===f?a.pendingRootTasks++:f.pendingTasks++;c.pendingTasks++;var m={replay:c,node:d,childIndex:e,ping:function(){return Ee(a,m)},blockedBoundary:f,blockedSegment:null,abortSet:g,keyPath:h,formatContext:k,legacyContext:l,context:n,treeContext:r,thenableState:b};g.add(m);return m}function Ce(a,b,c,d,e,f){return{status:0,id:-1,index:b,parentFlushed:!1,chunks:[],children:[],parentFormatContext:d,boundary:c,lastPushedText:e,textEmbedded:f}}
-function V(a,b){a=a.onError(b);if(null!=a&&"string"!==typeof a)throw Error('onError returned something with a type other than "string". onError should return a string and may return null or undefined but must not return anything else. It received something of type "'+typeof a+'" instead');return a}function Ie(a,b){var c=a.onShellError;c(b);c=a.onFatalError;c(b);null!==a.destination?(a.status=2,a.destination.destroy(b)):(a.status=1,a.fatalError=b)}
-function Je(a,b,c,d,e){var f=d.render(),g=e.childContextTypes;if(null!==g&&void 0!==g){c=b.legacyContext;if("function"!==typeof d.getChildContext)e=c;else{d=d.getChildContext();for(var h in d)if(!(h in g))throw Error(p(108,sd(e)||"Unknown",h));e=t({},c,d)}b.legacyContext=e;Y(a,b,null,f,-1);b.legacyContext=c}else e=b.keyPath,b.keyPath=c,Y(a,b,null,f,-1),b.keyPath=e}
-function Ke(a,b,c,d,e,f,g){var h=!1;if(0!==f&&null!==a.formState){var k=b.blockedSegment;if(null!==k){h=!0;k=k.chunks;for(var l=0;l<f;l++)l===g?k.push("\x3c!--F!--\x3e"):k.push("\x3c!--F--\x3e")}}f=b.keyPath;b.keyPath=c;e?(c=b.treeContext,b.treeContext=Fd(c,1,0),Z(a,b,d,-1),b.treeContext=c):h?Z(a,b,d,-1):Y(a,b,null,d,-1);b.keyPath=f}function Le(a,b){if(a&&a.defaultProps){b=t({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}
-function Me(a,b,c,d,e,f,g){if("function"===typeof e)if(e.prototype&&e.prototype.isReactComponent){d=ud(e,b.legacyContext);var h=e.contextType;h=new e(f,"object"===typeof h&&null!==h?h._currentValue2:d);Dd(h,e,f,d);Je(a,b,c,h,e)}else{h=ud(e,b.legacyContext);S={};Rd=b;Sd=a;Td=c;Yd=Xd=0;Zd=-1;$d=0;ae=d;d=e(f,h);d=ge(e,f,d,h);g=0!==Xd;var k=Yd,l=Zd;"object"===typeof d&&null!==d&&"function"===typeof d.render&&void 0===d.$$typeof?(Dd(d,e,f,h),Je(a,b,c,d,e)):Ke(a,b,c,d,g,k,l)}else if("string"===typeof e)if(d=
-b.blockedSegment,null===d)d=f.children,h=b.formatContext,g=b.keyPath,b.formatContext=ob(h,e,f),b.keyPath=c,Z(a,b,d,-1),b.formatContext=h,b.keyPath=g;else{g=Qb(d.chunks,e,f,a.resumableState,a.renderState,b.formatContext,d.lastPushedText);d.lastPushedText=!1;h=b.formatContext;k=b.keyPath;b.formatContext=ob(h,e,f);b.keyPath=c;Z(a,b,g,-1);b.formatContext=h;b.keyPath=k;a:{b=d.chunks;a=a.resumableState;switch(e){case "title":case "style":case "script":case "area":case "base":case "br":case "col":case "embed":case "hr":case "img":case "input":case "keygen":case "link":case "meta":case "param":case "source":case "track":case "wbr":break a;
-case "body":if(1>=h.insertionMode){a.hasBody=!0;break a}break;case "html":if(0===h.insertionMode){a.hasHtml=!0;break a}}b.push(Lb(e))}d.lastPushedText=!1}else{switch(e){case od:case md:case Ic:case Jc:case Hc:e=b.keyPath;b.keyPath=c;Y(a,b,null,f.children,-1);b.keyPath=e;return;case nd:"hidden"!==f.mode&&(e=b.keyPath,b.keyPath=c,Y(a,b,null,f.children,-1),b.keyPath=e);return;case id:e=b.keyPath;b.keyPath=c;Y(a,b,null,f.children,-1);b.keyPath=e;return;case ld:throw Error(p(343));case hd:a:if(null!==
-b.replay){e=b.keyPath;b.keyPath=c;c=f.children;try{Z(a,b,c,-1)}finally{b.keyPath=e}}else{l=b.keyPath;e=b.blockedBoundary;var n=b.blockedSegment;d=f.fallback;var r=f.children;f=new Set;g=Ge(a,f);null!==a.trackedPostpones&&(g.trackedContentKeyPath=c);k=Ce(a,n.chunks.length,g,b.formatContext,!1,!1);n.children.push(k);n.lastPushedText=!1;var m=Ce(a,0,null,b.formatContext,!1,!1);m.parentFlushed=!0;b.blockedBoundary=g;b.blockedSegment=m;a.renderState.boundaryResources=g.resources;b.keyPath=c;try{if(Z(a,
-b,r,-1),a.renderState.generateStaticMarkup||m.lastPushedText&&m.textEmbedded&&m.chunks.push("\x3c!-- --\x3e"),m.status=1,Ne(g,m),0===g.pendingTasks&&0===g.status){g.status=1;break a}}catch(G){m.status=4,g.status=4,h=V(a,G),g.errorDigest=h}finally{a.renderState.boundaryResources=e?e.resources:null,b.blockedBoundary=e,b.blockedSegment=n,b.keyPath=l}h=[c[0],"Suspense Fallback",c[2]];l=a.trackedPostpones;null!==l&&(n=[h[1],h[2],[],null],l.workingMap.set(h,n),5===g.status?l.workingMap.get(c)[4]=n:g.trackedFallbackNode=
-n);b=De(a,null,d,-1,e,k,f,h,b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}return}if("object"===typeof e&&null!==e)switch(e.$$typeof){case gd:e=e.render;S={};Rd=b;Sd=a;Td=c;Yd=Xd=0;Zd=-1;$d=0;ae=d;d=e(f,g);f=ge(e,f,d,g);Ke(a,b,c,f,0!==Xd,Yd,Zd);return;case jd:e=e.type;f=Le(e,f);Me(a,b,c,d,e,f,g);return;case Kc:h=f.children;d=b.keyPath;e=e._context;f=f.value;g=e._currentValue2;e._currentValue2=f;k=vd;vd=f={parent:k,depth:null===k?0:k.depth+1,context:e,parentValue:g,
-value:f};b.context=f;b.keyPath=c;Y(a,b,null,h,-1);a=vd;if(null===a)throw Error(p(403));c=a.parentValue;a.context._currentValue2=c===qd?a.context._defaultValue:c;a=vd=a.parent;b.context=a;b.keyPath=d;return;case Lc:f=f.children;f=f(e._currentValue2);e=b.keyPath;b.keyPath=c;Y(a,b,null,f,-1);b.keyPath=e;return;case kd:h=e._init;e=h(e._payload);f=Le(e,f);Me(a,b,c,d,e,f,void 0);return}throw Error(p(130,null==e?e:typeof e,""));}}
-function Oe(a,b,c,d,e){var f=b.replay,g=b.blockedBoundary,h=Ce(a,0,null,b.formatContext,!1,!1);h.id=c;h.parentFlushed=!0;try{b.replay=null,b.blockedSegment=h,Z(a,b,d,e),h.status=1,null===g?a.completedRootSegment=h:(Ne(g,h),g.parentFlushed&&a.partialBoundaries.push(g))}finally{b.replay=f,b.blockedSegment=null}}
-function Y(a,b,c,d,e){if(null!==b.replay&&"number"===typeof b.replay.slots)Oe(a,b,b.replay.slots,d,e);else{b.node=d;b.childIndex=e;if("object"===typeof d&&null!==d){switch(d.$$typeof){case Fc:var f=d.type,g=d.key,h=d.props,k=d.ref,l=sd(f),n=null==g?-1===e?0:e:g;g=[b.keyPath,l,n];if(null!==b.replay)a:{var r=b.replay;e=r.nodes;for(d=0;d<e.length;d++){var m=e[d];if(n===m[1]){if(4===m.length){if(null!==l&&l!==m[0])throw Error(p(490,m[0],l));l=m[2];m=m[3];n=b.node;b.replay={nodes:l,slots:m,pendingTasks:1};
-try{Me(a,b,g,c,f,h,k);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error(p(488));b.replay.pendingTasks--}catch(q){if("object"===typeof q&&null!==q&&(q===Kd||"function"===typeof q.then))throw b.node===n&&(b.replay=r),q;b.replay.pendingTasks--;g=a;a=b.blockedBoundary;c=q;h=V(g,c);Pe(g,a,l,m,c,h)}b.replay=r}else{if(f!==hd)throw Error(p(490,"Suspense",sd(f)||"Unknown"));b:{r=void 0;c=m[5];f=m[2];k=m[3];l=null===m[4]?[]:m[4][2];m=null===m[4]?null:m[4][3];n=b.keyPath;var G=b.replay,A=b.blockedBoundary,
-T=h.children;h=h.fallback;var u=new Set,z=Ge(a,u);z.parentFlushed=!0;z.rootSegmentID=c;b.blockedBoundary=z;b.replay={nodes:f,slots:k,pendingTasks:1};a.renderState.boundaryResources=z.resources;try{Z(a,b,T,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error(p(488));b.replay.pendingTasks--;if(0===z.pendingTasks&&0===z.status){z.status=1;a.completedBoundaries.push(z);break b}}catch(q){z.status=4,r=V(a,q),z.errorDigest=r,b.replay.pendingTasks--,a.clientRenderedBoundaries.push(z)}finally{a.renderState.boundaryResources=
-A?A.resources:null,b.blockedBoundary=A,b.replay=G,b.keyPath=n}b=He(a,null,{nodes:l,slots:m,pendingTasks:0},h,-1,A,u,[g[0],"Suspense Fallback",g[2]],b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}}e.splice(d,1);break a}}}else Me(a,b,g,c,f,h,k);return;case Gc:throw Error(p(257));case kd:h=d._init;d=h(d._payload);Y(a,b,null,d,e);return}if(Ma(d)){Qe(a,b,d,e);return}null===d||"object"!==typeof d?h=null:(h=rd&&d[rd]||d["@@iterator"],h="function"===typeof h?h:null);if(h&&
-(h=h.call(d))){d=h.next();if(!d.done){g=[];do g.push(d.value),d=h.next();while(!d.done);Qe(a,b,g,e)}return}if("function"===typeof d.then)return Y(a,b,null,pe(d),e);if(d.$$typeof===Lc||d.$$typeof===fd)return Y(a,b,null,d._currentValue2,e);e=Object.prototype.toString.call(d);throw Error(p(31,"[object Object]"===e?"object with keys {"+Object.keys(d).join(", ")+"}":e));}"string"===typeof d?(e=b.blockedSegment,null!==e&&(e.lastPushedText=Ec(e.chunks,d,a.renderState,e.lastPushedText))):"number"===typeof d&&
+function Od(){if(null===Nd)throw Error(q(459));var a=Nd;Nd=null;return a}function Pd(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var Qd="function"===typeof Object.is?Object.is:Pd,Rd=null,Sd=null,Td=null,Ud=null,Vd=null,V=null,Wd=!1,Xd=!1,Yd=0,Zd=0,$d=-1,ae=0,be=null,ce=null,de=0;function ee(){if(null===Rd)throw Error(q(321));return Rd}function fe(){if(0<de)throw Error(q(312));return{memoizedState:null,queue:null,next:null}}
+function ge(){null===V?null===Vd?(Wd=!1,Vd=V=fe()):(Wd=!0,V=Vd):null===V.next?(Wd=!1,V=V.next=fe()):(Wd=!0,V=V.next);return V}function he(a,b,c,d){for(;Xd;)Xd=!1,Zd=Yd=0,$d=-1,ae=0,de+=1,V=null,c=a(b,d);ie();return c}function je(){var a=be;be=null;return a}function ie(){Ud=Td=Sd=Rd=null;Xd=!1;Vd=null;de=0;V=ce=null}function ke(a,b){return"function"===typeof b?b(a):b}
+function le(a,b,c){Rd=ee();V=ge();if(Wd){var d=V.queue;b=d.dispatch;if(null!==ce&&(c=ce.get(d),void 0!==c)){ce.delete(d);d=V.memoizedState;do d=a(d,c.action),c=c.next;while(null!==c);V.memoizedState=d;return[d,b]}return[V.memoizedState,b]}a=a===ke?"function"===typeof b?b():b:void 0!==c?c(b):b;V.memoizedState=a;a=V.queue={last:null,dispatch:null};a=a.dispatch=me.bind(null,Rd,a);return[V.memoizedState,a]}
+function ne(a,b){Rd=ee();V=ge();b=void 0===b?null:b;if(null!==V){var c=V.memoizedState;if(null!==c&&null!==b){var d=c[1];a:if(null===d)d=!1;else{for(var e=0;e<d.length&&e<b.length;e++)if(!Qd(b[e],d[e])){d=!1;break a}d=!0}if(d)return c[0]}}a=a();V.memoizedState=[a,b];return a}function me(a,b,c){if(25<=de)throw Error(q(301));if(a===Rd)if(Xd=!0,a={action:c,next:null},null===ce&&(ce=new Map),c=ce.get(b),void 0===c)ce.set(b,a);else{for(b=c;null!==b.next;)b=b.next;b.next=a}}
+function oe(){throw Error(q(394));}function pe(){throw Error(q(479));}function qe(a){var b=ae;ae+=1;null===be&&(be=[]);return Md(be,a,b)}function re(){throw Error(q(393));}function ue(){}
+var we={readContext:function(a){return a._currentValue2},use:function(a){if(null!==a&&"object"===typeof a){if("function"===typeof a.then)return qe(a);if(a.$$typeof===Lc||a.$$typeof===fd)return a._currentValue2}throw Error(q(438,String(a)));},useContext:function(a){ee();return a._currentValue2},useMemo:ne,useReducer:le,useRef:function(a){Rd=ee();V=ge();var b=V.memoizedState;return null===b?(a={current:a},V.memoizedState=a):b},useState:function(a){return le(ke,a)},useInsertionEffect:ue,useLayoutEffect:ue,
+useCallback:function(a,b){return ne(function(){return a},b)},useImperativeHandle:ue,useEffect:ue,useDebugValue:ue,useDeferredValue:function(a){ee();return a},useTransition:function(){ee();return[!1,oe]},useId:function(){var a=Sd.treeContext;var b=a.overflow;a=a.id;a=(a&~(1<<32-Gd(a)-1)).toString(32)+b;var c=ve;if(null===c)throw Error(q(404));b=Yd++;a=":"+c.idPrefix+"R"+a;0<b&&(a+="H"+b.toString(32));return a+":"},useSyncExternalStore:function(a,b,c){if(void 0===c)throw Error(q(407));return c()},useCacheRefresh:function(){return re},
+useHostTransitionStatus:function(){ee();return Ma},useOptimistic:function(a){ee();return[a,pe]},useFormState:function(a,b,c){ee();var d=Zd++,e=Td;if("function"===typeof a.$$FORM_ACTION){var f=null,g=Ud;e=e.formState;var h=a.$$IS_SIGNATURE_EQUAL;if(null!==e&&"function"===typeof h){var k=e[1];h.call(a,e[2],e[3])&&(f=void 0!==c?"p"+c:"k"+ea(JSON.stringify([g,null,d]),0),k===f&&($d=d,b=e[0]))}var l=a.bind(null,b);a=function(r){l(r)};"function"===typeof l.$$FORM_ACTION&&(a.$$FORM_ACTION=function(r){r=
+l.$$FORM_ACTION(r);void 0!==c&&(c+="",r.action=c);var m=r.data;m&&(null===f&&(f=void 0!==c?"p"+c:"k"+ea(JSON.stringify([g,null,d]),0)),m.append("$ACTION_KEY",f));return r});return[b,a]}var n=a.bind(null,b);return[b,function(r){n(r)}]}},ve=null,xe={getCacheSignal:function(){throw Error(q(248));},getCacheForType:function(){throw Error(q(248));}},ye=La.ReactCurrentDispatcher,ze=La.ReactCurrentCache;function Ae(a){console.error(a);return null}function Be(){}
+function Ce(a,b,c,d,e,f,g,h,k,l,n,r){Na.current=kb;var m=[],F=new Set;b={destination:null,flushScheduled:!1,resumableState:b,renderState:c,rootFormatContext:d,progressiveChunkSize:void 0===e?12800:e,status:0,fatalError:null,nextSegmentId:0,allPendingTasks:0,pendingRootTasks:0,completedRootSegment:null,abortableTasks:F,pingedTasks:m,clientRenderedBoundaries:[],completedBoundaries:[],partialBoundaries:[],trackedPostpones:null,onError:void 0===f?Ae:f,onPostpone:void 0===n?Be:n,onAllReady:void 0===g?
+Be:g,onShellReady:void 0===h?Be:h,onShellError:void 0===k?Be:k,onFatalError:void 0===l?Be:l,formState:void 0===r?null:r};c=De(b,0,null,d,!1,!1);c.parentFlushed=!0;a=Ee(b,null,a,-1,null,c,F,null,d,td,null,Ed);m.push(a);return b}var T=null;function Fe(a,b){a.pingedTasks.push(b);1===a.pingedTasks.length&&(a.flushScheduled=null!==a.destination,Ge(a))}
+function He(a,b){return{status:0,rootSegmentID:-1,parentFlushed:!1,pendingTasks:0,completedSegments:[],byteSize:0,fallbackAbortableTasks:b,errorDigest:null,resources:{styles:new Set,stylesheets:new Set},trackedContentKeyPath:null,trackedFallbackNode:null}}
+function Ee(a,b,c,d,e,f,g,h,k,l,n,r){a.allPendingTasks++;null===e?a.pendingRootTasks++:e.pendingTasks++;var m={replay:null,node:c,childIndex:d,ping:function(){return Fe(a,m)},blockedBoundary:e,blockedSegment:f,abortSet:g,keyPath:h,formatContext:k,legacyContext:l,context:n,treeContext:r,thenableState:b};g.add(m);return m}
+function Ie(a,b,c,d,e,f,g,h,k,l,n,r){a.allPendingTasks++;null===f?a.pendingRootTasks++:f.pendingTasks++;c.pendingTasks++;var m={replay:c,node:d,childIndex:e,ping:function(){return Fe(a,m)},blockedBoundary:f,blockedSegment:null,abortSet:g,keyPath:h,formatContext:k,legacyContext:l,context:n,treeContext:r,thenableState:b};g.add(m);return m}function De(a,b,c,d,e,f){return{status:0,id:-1,index:b,parentFlushed:!1,chunks:[],children:[],parentFormatContext:d,boundary:c,lastPushedText:e,textEmbedded:f}}
+function W(a,b){a=a.onError(b);if(null!=a&&"string"!==typeof a)throw Error('onError returned something with a type other than "string". onError should return a string and may return null or undefined but must not return anything else. It received something of type "'+typeof a+'" instead');return a}function Je(a,b){var c=a.onShellError;c(b);c=a.onFatalError;c(b);null!==a.destination?(a.status=2,a.destination.destroy(b)):(a.status=1,a.fatalError=b)}
+function Ke(a,b,c,d,e){var f=d.render(),g=e.childContextTypes;if(null!==g&&void 0!==g){c=b.legacyContext;if("function"!==typeof d.getChildContext)e=c;else{d=d.getChildContext();for(var h in d)if(!(h in g))throw Error(q(108,sd(e)||"Unknown",h));e=t({},c,d)}b.legacyContext=e;X(a,b,null,f,-1);b.legacyContext=c}else e=b.keyPath,b.keyPath=c,X(a,b,null,f,-1),b.keyPath=e}
+function Le(a,b,c,d,e,f,g){var h=!1;if(0!==f&&null!==a.formState){var k=b.blockedSegment;if(null!==k){h=!0;k=k.chunks;for(var l=0;l<f;l++)l===g?k.push("\x3c!--F!--\x3e"):k.push("\x3c!--F--\x3e")}}f=b.keyPath;b.keyPath=c;e?(c=b.treeContext,b.treeContext=Fd(c,1,0),Me(a,b,d,-1),b.treeContext=c):h?Me(a,b,d,-1):X(a,b,null,d,-1);b.keyPath=f}function Ne(a,b){if(a&&a.defaultProps){b=t({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}
+function Oe(a,b,c,d,e,f,g){if("function"===typeof e)if(e.prototype&&e.prototype.isReactComponent){d=ud(e,b.legacyContext);var h=e.contextType;h=new e(f,"object"===typeof h&&null!==h?h._currentValue2:d);Dd(h,e,f,d);Ke(a,b,c,h,e)}else{h=ud(e,b.legacyContext);Rd={};Sd=b;Td=a;Ud=c;Zd=Yd=0;$d=-1;ae=0;be=d;d=e(f,h);d=he(e,f,d,h);g=0!==Yd;var k=Zd,l=$d;"object"===typeof d&&null!==d&&"function"===typeof d.render&&void 0===d.$$typeof?(Dd(d,e,f,h),Ke(a,b,c,d,e)):Le(a,b,c,d,g,k,l)}else if("string"===typeof e)if(d=
+b.blockedSegment,null===d)d=f.children,h=b.formatContext,g=b.keyPath,b.formatContext=ob(h,e,f),b.keyPath=c,Me(a,b,d,-1),b.formatContext=h,b.keyPath=g;else{g=Qb(d.chunks,e,f,a.resumableState,a.renderState,b.formatContext,d.lastPushedText);d.lastPushedText=!1;h=b.formatContext;k=b.keyPath;b.formatContext=ob(h,e,f);b.keyPath=c;Me(a,b,g,-1);b.formatContext=h;b.keyPath=k;a:{b=d.chunks;a=a.resumableState;switch(e){case "title":case "style":case "script":case "area":case "base":case "br":case "col":case "embed":case "hr":case "img":case "input":case "keygen":case "link":case "meta":case "param":case "source":case "track":case "wbr":break a;
+case "body":if(1>=h.insertionMode){a.hasBody=!0;break a}break;case "html":if(0===h.insertionMode){a.hasHtml=!0;break a}}b.push(Lb(e))}d.lastPushedText=!1}else{switch(e){case od:case md:case Ic:case Jc:case Hc:e=b.keyPath;b.keyPath=c;X(a,b,null,f.children,-1);b.keyPath=e;return;case nd:"hidden"!==f.mode&&(e=b.keyPath,b.keyPath=c,X(a,b,null,f.children,-1),b.keyPath=e);return;case id:e=b.keyPath;b.keyPath=c;X(a,b,null,f.children,-1);b.keyPath=e;return;case ld:throw Error(q(343));case hd:a:if(null!==
+b.replay){e=b.keyPath;b.keyPath=c;c=f.children;try{Me(a,b,c,-1)}finally{b.keyPath=e}}else{l=b.keyPath;e=b.blockedBoundary;var n=b.blockedSegment;d=f.fallback;var r=f.children;f=new Set;g=He(a,f);null!==a.trackedPostpones&&(g.trackedContentKeyPath=c);k=De(a,n.chunks.length,g,b.formatContext,!1,!1);n.children.push(k);n.lastPushedText=!1;var m=De(a,0,null,b.formatContext,!1,!1);m.parentFlushed=!0;b.blockedBoundary=g;b.blockedSegment=m;a.renderState.boundaryResources=g.resources;b.keyPath=c;try{if(Me(a,
+b,r,-1),a.renderState.generateStaticMarkup||m.lastPushedText&&m.textEmbedded&&m.chunks.push("\x3c!-- --\x3e"),m.status=1,Pe(g,m),0===g.pendingTasks&&0===g.status){g.status=1;break a}}catch(F){m.status=4,g.status=4,h=W(a,F),g.errorDigest=h}finally{a.renderState.boundaryResources=e?e.resources:null,b.blockedBoundary=e,b.blockedSegment=n,b.keyPath=l}h=[c[0],"Suspense Fallback",c[2]];l=a.trackedPostpones;null!==l&&(n=[h[1],h[2],[],null],l.workingMap.set(h,n),5===g.status?l.workingMap.get(c)[4]=n:g.trackedFallbackNode=
+n);b=Ee(a,null,d,-1,e,k,f,h,b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}return}if("object"===typeof e&&null!==e)switch(e.$$typeof){case gd:e=e.render;Rd={};Sd=b;Td=a;Ud=c;Zd=Yd=0;$d=-1;ae=0;be=d;d=e(f,g);f=he(e,f,d,g);Le(a,b,c,f,0!==Yd,Zd,$d);return;case jd:e=e.type;f=Ne(e,f);Oe(a,b,c,d,e,f,g);return;case Kc:h=f.children;d=b.keyPath;e=e._context;f=f.value;g=e._currentValue2;e._currentValue2=f;k=vd;vd=f={parent:k,depth:null===k?0:k.depth+1,context:e,parentValue:g,
+value:f};b.context=f;b.keyPath=c;X(a,b,null,h,-1);a=vd;if(null===a)throw Error(q(403));c=a.parentValue;a.context._currentValue2=c===qd?a.context._defaultValue:c;a=vd=a.parent;b.context=a;b.keyPath=d;return;case Lc:f=f.children;f=f(e._currentValue2);e=b.keyPath;b.keyPath=c;X(a,b,null,f,-1);b.keyPath=e;return;case kd:h=e._init;e=h(e._payload);f=Ne(e,f);Oe(a,b,c,d,e,f,void 0);return}throw Error(q(130,null==e?e:typeof e,""));}}
+function Qe(a,b,c,d,e){var f=b.replay,g=b.blockedBoundary,h=De(a,0,null,b.formatContext,!1,!1);h.id=c;h.parentFlushed=!0;try{b.replay=null,b.blockedSegment=h,Me(a,b,d,e),h.status=1,null===g?a.completedRootSegment=h:(Pe(g,h),g.parentFlushed&&a.partialBoundaries.push(g))}finally{b.replay=f,b.blockedSegment=null}}
+function X(a,b,c,d,e){if(null!==b.replay&&"number"===typeof b.replay.slots)Qe(a,b,b.replay.slots,d,e);else{b.node=d;b.childIndex=e;if("object"===typeof d&&null!==d){switch(d.$$typeof){case Fc:var f=d.type,g=d.key,h=d.props,k=d.ref,l=sd(f),n=null==g?-1===e?0:e:g;g=[b.keyPath,l,n];if(null!==b.replay)a:{var r=b.replay;e=r.nodes;for(d=0;d<e.length;d++){var m=e[d];if(n===m[1]){if(4===m.length){if(null!==l&&l!==m[0])throw Error(q(490,m[0],l));l=m[2];m=m[3];n=b.node;b.replay={nodes:l,slots:m,pendingTasks:1};
+try{Oe(a,b,g,c,f,h,k);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error(q(488));b.replay.pendingTasks--}catch(p){if("object"===typeof p&&null!==p&&(p===Kd||"function"===typeof p.then))throw b.node===n&&(b.replay=r),p;b.replay.pendingTasks--;g=a;a=b.blockedBoundary;c=p;h=W(g,c);Re(g,a,l,m,c,h)}b.replay=r}else{if(f!==hd)throw Error(q(490,"Suspense",sd(f)||"Unknown"));b:{r=void 0;c=m[5];f=m[2];k=m[3];l=null===m[4]?[]:m[4][2];m=null===m[4]?null:m[4][3];n=b.keyPath;var F=b.replay,D=b.blockedBoundary,
+R=h.children;h=h.fallback;var v=new Set,u=He(a,v);u.parentFlushed=!0;u.rootSegmentID=c;b.blockedBoundary=u;b.replay={nodes:f,slots:k,pendingTasks:1};a.renderState.boundaryResources=u.resources;try{Me(a,b,R,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error(q(488));b.replay.pendingTasks--;if(0===u.pendingTasks&&0===u.status){u.status=1;a.completedBoundaries.push(u);break b}}catch(p){u.status=4,r=W(a,p),u.errorDigest=r,b.replay.pendingTasks--,a.clientRenderedBoundaries.push(u)}finally{a.renderState.boundaryResources=
+D?D.resources:null,b.blockedBoundary=D,b.replay=F,b.keyPath=n}b=Ie(a,null,{nodes:l,slots:m,pendingTasks:0},h,-1,D,v,[g[0],"Suspense Fallback",g[2]],b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}}e.splice(d,1);break a}}}else Oe(a,b,g,c,f,h,k);return;case Gc:throw Error(q(257));case kd:h=d._init;d=h(d._payload);X(a,b,null,d,e);return}if(Ka(d)){Se(a,b,d,e);return}null===d||"object"!==typeof d?h=null:(h=rd&&d[rd]||d["@@iterator"],h="function"===typeof h?h:null);if(h&&
+(h=h.call(d))){d=h.next();if(!d.done){g=[];do g.push(d.value),d=h.next();while(!d.done);Se(a,b,g,e)}return}if("function"===typeof d.then)return X(a,b,null,qe(d),e);if(d.$$typeof===Lc||d.$$typeof===fd)return X(a,b,null,d._currentValue2,e);e=Object.prototype.toString.call(d);throw Error(q(31,"[object Object]"===e?"object with keys {"+Object.keys(d).join(", ")+"}":e));}"string"===typeof d?(e=b.blockedSegment,null!==e&&(e.lastPushedText=Ec(e.chunks,d,a.renderState,e.lastPushedText))):"number"===typeof d&&
 (e=b.blockedSegment,null!==e&&(e.lastPushedText=Ec(e.chunks,""+d,a.renderState,e.lastPushedText)))}}
-function Qe(a,b,c,d){var e=b.keyPath;if(-1!==d&&(b.keyPath=[b.keyPath,"Fragment",d],null!==b.replay)){for(var f=b.replay,g=f.nodes,h=0;h<g.length;h++){var k=g[h];if(k[1]===d){d=k[2];k=k[3];b.replay={nodes:d,slots:k,pendingTasks:1};try{Qe(a,b,c,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error(p(488));b.replay.pendingTasks--}catch(r){if("object"===typeof r&&null!==r&&(r===Kd||"function"===typeof r.then))throw r;b.replay.pendingTasks--;c=a;var l=b.blockedBoundary,n=r;a=V(c,n);Pe(c,
-l,d,k,n,a)}b.replay=f;g.splice(h,1);break}}b.keyPath=e;return}f=b.treeContext;g=c.length;if(null!==b.replay&&(h=b.replay.slots,null!==h&&"object"===typeof h)){for(d=0;d<g;d++)k=c[d],b.treeContext=Fd(f,g,d),l=h[d],"number"===typeof l?(Oe(a,b,l,k,d),delete h[d]):Z(a,b,k,d);b.treeContext=f;b.keyPath=e;return}for(h=0;h<g;h++)d=c[h],b.treeContext=Fd(f,g,h),Z(a,b,d,h);b.treeContext=f;b.keyPath=e}
-function Z(a,b,c,d){var e=b.formatContext,f=b.legacyContext,g=b.context,h=b.keyPath,k=b.treeContext,l=b.blockedSegment;if(null===l)try{return Y(a,b,null,c,d)}catch(m){if(he(),c=m===Kd?Od():m,"object"===typeof c&&null!==c&&"function"===typeof c.then){d=ie();a=He(a,d,b.replay,b.node,b.childIndex,b.blockedBoundary,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Bd(g);return}}else{var n=
-l.children.length,r=l.chunks.length;try{return Y(a,b,null,c,d)}catch(m){if(he(),l.children.length=n,l.chunks.length=r,c=m===Kd?Od():m,"object"===typeof c&&null!==c&&"function"===typeof c.then){d=ie();l=b.blockedSegment;n=Ce(a,l.chunks.length,null,b.formatContext,l.lastPushedText,!0);l.children.push(n);l.lastPushedText=!1;a=De(a,d,b.node,b.childIndex,b.blockedBoundary,n,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=
-f;b.context=g;b.keyPath=h;b.treeContext=k;Bd(g);return}}}b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Bd(g);throw c;}function Re(a){var b=a.blockedBoundary;a=a.blockedSegment;null!==a&&(a.status=3,Se(this,b,a))}
-function Pe(a,b,c,d,e,f){for(var g=0;g<c.length;g++){var h=c[g];if(4===h.length)Pe(a,b,h[2],h[3],e,f);else{h=h[5];var k=a,l=f,n=Ge(k,new Set);n.parentFlushed=!0;n.rootSegmentID=h;n.status=4;n.errorDigest=l;n.parentFlushed&&k.clientRenderedBoundaries.push(n)}}c.length=0;if(null!==d){if(null===b)throw Error(p(487));4!==b.status&&(b.status=4,b.errorDigest=f,b.parentFlushed&&a.clientRenderedBoundaries.push(b));if("object"===typeof d)for(var r in d)delete d[r]}}
-function Te(a,b,c){var d=a.blockedBoundary,e=a.blockedSegment;null!==e&&(e.status=3);if(null===d){if(1!==b.status&&2!==b.status){a=a.replay;if(null===a){V(b,c);Ie(b,c);return}a.pendingTasks--;0===a.pendingTasks&&0<a.nodes.length&&(d=V(b,c),Pe(b,null,a.nodes,a.slots,c,d));b.pendingRootTasks--;0===b.pendingRootTasks&&Ue(b)}}else d.pendingTasks--,4!==d.status&&(d.status=4,d.errorDigest=V(b,c),d.parentFlushed&&b.clientRenderedBoundaries.push(d)),d.fallbackAbortableTasks.forEach(function(f){return Te(f,
-b,c)}),d.fallbackAbortableTasks.clear();b.allPendingTasks--;0===b.allPendingTasks&&Ve(b)}function Ue(a){null===a.trackedPostpones&&Cc(a.renderState,a.resumableState,!0);a.onShellError=Ae;a=a.onShellReady;a()}function Ve(a){Cc(a.renderState,a.resumableState,null===a.trackedPostpones?!0:null===a.completedRootSegment||5!==a.completedRootSegment.status);a=a.onAllReady;a()}
-function Ne(a,b){if(0===b.chunks.length&&1===b.children.length&&null===b.children[0].boundary){var c=b.children[0];c.id=b.id;c.parentFlushed=!0;1===c.status&&Ne(a,c)}else a.completedSegments.push(b)}
-function Se(a,b,c){if(null===b){if(null!==c&&c.parentFlushed){if(null!==a.completedRootSegment)throw Error(p(389));a.completedRootSegment=c}a.pendingRootTasks--;0===a.pendingRootTasks&&Ue(a)}else b.pendingTasks--,4!==b.status&&(0===b.pendingTasks?(0===b.status&&(b.status=1),null!==c&&c.parentFlushed&&1===c.status&&Ne(b,c),b.parentFlushed&&a.completedBoundaries.push(b),1===b.status&&(b.fallbackAbortableTasks.forEach(Re,a),b.fallbackAbortableTasks.clear())):null!==c&&c.parentFlushed&&1===c.status&&
-(Ne(b,c),1===b.completedSegments.length&&b.parentFlushed&&a.partialBoundaries.push(b)));a.allPendingTasks--;0===a.allPendingTasks&&Ve(a)}
-function Fe(a){if(2!==a.status){var b=vd,c=xe.current;xe.current=ve;var d=ye.current;ye.current=we;var e=Q;Q=a;var f=ue;ue=a.resumableState;try{var g=a.pingedTasks,h;for(h=0;h<g.length;h++){var k=g[h],l=a,n=k.blockedBoundary;l.renderState.boundaryResources=n?n.resources:null;var r=k.blockedSegment;if(null===r){var m=l;if(0!==k.replay.pendingTasks){Bd(k.context);try{var G=k.thenableState;k.thenableState=null;Y(m,k,G,k.node,k.childIndex);if(1===k.replay.pendingTasks&&0<k.replay.nodes.length)throw Error(p(488));
-k.replay.pendingTasks--;k.abortSet.delete(k);Se(m,k.blockedBoundary,null)}catch(N){he();var A=N===Kd?Od():N;if("object"===typeof A&&null!==A&&"function"===typeof A.then){var T=k.ping;A.then(T,T);k.thenableState=ie()}else{k.replay.pendingTasks--;k.abortSet.delete(k);l=void 0;var u=m,z=k.blockedBoundary,q=A,aa=k.replay.nodes,H=k.replay.slots;l=V(u,q);Pe(u,z,aa,H,q,l);m.pendingRootTasks--;0===m.pendingRootTasks&&Ue(m);m.allPendingTasks--;0===m.allPendingTasks&&Ve(m)}}finally{m.renderState.boundaryResources=
-null}}}else if(m=void 0,u=r,0===u.status){Bd(k.context);var ba=u.children.length,B=u.chunks.length;try{var M=k.thenableState;k.thenableState=null;Y(l,k,M,k.node,k.childIndex);l.renderState.generateStaticMarkup||u.lastPushedText&&u.textEmbedded&&u.chunks.push("\x3c!-- --\x3e");k.abortSet.delete(k);u.status=1;Se(l,k.blockedBoundary,u)}catch(N){he();u.children.length=ba;u.chunks.length=B;var x=N===Kd?Od():N;if("object"===typeof x&&null!==x&&"function"===typeof x.then){var fa=k.ping;x.then(fa,fa);k.thenableState=
-ie()}else{k.abortSet.delete(k);u.status=4;var R=k.blockedBoundary;m=V(l,x);null===R?Ie(l,x):(R.pendingTasks--,4!==R.status&&(R.status=4,R.errorDigest=m,R.parentFlushed&&l.clientRenderedBoundaries.push(R)));l.allPendingTasks--;0===l.allPendingTasks&&Ve(l)}}finally{l.renderState.boundaryResources=null}}}g.splice(0,h);null!==a.destination&&We(a,a.destination)}catch(N){V(a,N),Ie(a,N)}finally{ue=f,xe.current=c,ye.current=d,c===ve&&Bd(b),Q=e}}}
-function Xe(a,b,c){c.parentFlushed=!0;switch(c.status){case 0:c.id=a.nextSegmentId++;case 5:var d=c.id;c.lastPushedText=!1;c.textEmbedded=!1;a=a.renderState;b.push('<template id="');b.push(a.placeholderPrefix);a=d.toString(16);b.push(a);return b.push('"></template>');case 1:c.status=2;var e=!0;d=c.chunks;var f=0;c=c.children;for(var g=0;g<c.length;g++){for(e=c[g];f<e.index;f++)b.push(d[f]);e=Ye(a,b,e)}for(;f<d.length-1;f++)b.push(d[f]);f<d.length&&(e=b.push(d[f]));return e;default:throw Error(p(390));
+function Se(a,b,c,d){var e=b.keyPath;if(-1!==d&&(b.keyPath=[b.keyPath,"Fragment",d],null!==b.replay)){for(var f=b.replay,g=f.nodes,h=0;h<g.length;h++){var k=g[h];if(k[1]===d){d=k[2];k=k[3];b.replay={nodes:d,slots:k,pendingTasks:1};try{Se(a,b,c,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error(q(488));b.replay.pendingTasks--}catch(r){if("object"===typeof r&&null!==r&&(r===Kd||"function"===typeof r.then))throw r;b.replay.pendingTasks--;c=a;var l=b.blockedBoundary,n=r;a=W(c,n);Re(c,
+l,d,k,n,a)}b.replay=f;g.splice(h,1);break}}b.keyPath=e;return}f=b.treeContext;g=c.length;if(null!==b.replay&&(h=b.replay.slots,null!==h&&"object"===typeof h)){for(d=0;d<g;d++)k=c[d],b.treeContext=Fd(f,g,d),l=h[d],"number"===typeof l?(Qe(a,b,l,k,d),delete h[d]):Me(a,b,k,d);b.treeContext=f;b.keyPath=e;return}for(h=0;h<g;h++)d=c[h],b.treeContext=Fd(f,g,h),Me(a,b,d,h);b.treeContext=f;b.keyPath=e}
+function Me(a,b,c,d){var e=b.formatContext,f=b.legacyContext,g=b.context,h=b.keyPath,k=b.treeContext,l=b.blockedSegment;if(null===l)try{return X(a,b,null,c,d)}catch(m){if(ie(),c=m===Kd?Od():m,"object"===typeof c&&null!==c&&"function"===typeof c.then){d=je();a=Ie(a,d,b.replay,b.node,b.childIndex,b.blockedBoundary,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Bd(g);return}}else{var n=
+l.children.length,r=l.chunks.length;try{return X(a,b,null,c,d)}catch(m){if(ie(),l.children.length=n,l.chunks.length=r,c=m===Kd?Od():m,"object"===typeof c&&null!==c&&"function"===typeof c.then){d=je();l=b.blockedSegment;n=De(a,l.chunks.length,null,b.formatContext,l.lastPushedText,!0);l.children.push(n);l.lastPushedText=!1;a=Ee(a,d,b.node,b.childIndex,b.blockedBoundary,n,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=
+f;b.context=g;b.keyPath=h;b.treeContext=k;Bd(g);return}}}b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Bd(g);throw c;}function Te(a){var b=a.blockedBoundary;a=a.blockedSegment;null!==a&&(a.status=3,Ue(this,b,a))}
+function Re(a,b,c,d,e,f){for(var g=0;g<c.length;g++){var h=c[g];if(4===h.length)Re(a,b,h[2],h[3],e,f);else{h=h[5];var k=a,l=f,n=He(k,new Set);n.parentFlushed=!0;n.rootSegmentID=h;n.status=4;n.errorDigest=l;n.parentFlushed&&k.clientRenderedBoundaries.push(n)}}c.length=0;if(null!==d){if(null===b)throw Error(q(487));4!==b.status&&(b.status=4,b.errorDigest=f,b.parentFlushed&&a.clientRenderedBoundaries.push(b));if("object"===typeof d)for(var r in d)delete d[r]}}
+function Ve(a,b,c){var d=a.blockedBoundary,e=a.blockedSegment;null!==e&&(e.status=3);if(null===d){if(1!==b.status&&2!==b.status){a=a.replay;if(null===a){W(b,c);Je(b,c);return}a.pendingTasks--;0===a.pendingTasks&&0<a.nodes.length&&(d=W(b,c),Re(b,null,a.nodes,a.slots,c,d));b.pendingRootTasks--;0===b.pendingRootTasks&&We(b)}}else d.pendingTasks--,4!==d.status&&(d.status=4,d.errorDigest=W(b,c),d.parentFlushed&&b.clientRenderedBoundaries.push(d)),d.fallbackAbortableTasks.forEach(function(f){return Ve(f,
+b,c)}),d.fallbackAbortableTasks.clear();b.allPendingTasks--;0===b.allPendingTasks&&Xe(b)}function We(a){null===a.trackedPostpones&&Cc(a.renderState,a.resumableState,!0);a.onShellError=Be;a=a.onShellReady;a()}function Xe(a){Cc(a.renderState,a.resumableState,null===a.trackedPostpones?!0:null===a.completedRootSegment||5!==a.completedRootSegment.status);a=a.onAllReady;a()}
+function Pe(a,b){if(0===b.chunks.length&&1===b.children.length&&null===b.children[0].boundary){var c=b.children[0];c.id=b.id;c.parentFlushed=!0;1===c.status&&Pe(a,c)}else a.completedSegments.push(b)}
+function Ue(a,b,c){if(null===b){if(null!==c&&c.parentFlushed){if(null!==a.completedRootSegment)throw Error(q(389));a.completedRootSegment=c}a.pendingRootTasks--;0===a.pendingRootTasks&&We(a)}else b.pendingTasks--,4!==b.status&&(0===b.pendingTasks?(0===b.status&&(b.status=1),null!==c&&c.parentFlushed&&1===c.status&&Pe(b,c),b.parentFlushed&&a.completedBoundaries.push(b),1===b.status&&(b.fallbackAbortableTasks.forEach(Te,a),b.fallbackAbortableTasks.clear())):null!==c&&c.parentFlushed&&1===c.status&&
+(Pe(b,c),1===b.completedSegments.length&&b.parentFlushed&&a.partialBoundaries.push(b)));a.allPendingTasks--;0===a.allPendingTasks&&Xe(a)}
+function Ge(a){if(2!==a.status){var b=vd,c=ye.current;ye.current=we;var d=ze.current;ze.current=xe;var e=T;T=a;var f=ve;ve=a.resumableState;try{var g=a.pingedTasks,h;for(h=0;h<g.length;h++){var k=g[h],l=a,n=k.blockedBoundary;l.renderState.boundaryResources=n?n.resources:null;var r=k.blockedSegment;if(null===r){var m=l;if(0!==k.replay.pendingTasks){Bd(k.context);try{var F=k.thenableState;k.thenableState=null;X(m,k,F,k.node,k.childIndex);if(1===k.replay.pendingTasks&&0<k.replay.nodes.length)throw Error(q(488));
+k.replay.pendingTasks--;k.abortSet.delete(k);Ue(m,k.blockedBoundary,null)}catch(P){ie();var D=P===Kd?Od():P;if("object"===typeof D&&null!==D&&"function"===typeof D.then){var R=k.ping;D.then(R,R);k.thenableState=je()}else{k.replay.pendingTasks--;k.abortSet.delete(k);l=void 0;var v=m,u=k.blockedBoundary,p=D,G=k.replay.nodes,x=k.replay.slots;l=W(v,p);Re(v,u,G,x,p,l);m.pendingRootTasks--;0===m.pendingRootTasks&&We(m);m.allPendingTasks--;0===m.allPendingTasks&&Xe(m)}}finally{m.renderState.boundaryResources=
+null}}}else if(m=void 0,v=r,0===v.status){Bd(k.context);var w=v.children.length,C=v.chunks.length;try{var O=k.thenableState;k.thenableState=null;X(l,k,O,k.node,k.childIndex);l.renderState.generateStaticMarkup||v.lastPushedText&&v.textEmbedded&&v.chunks.push("\x3c!-- --\x3e");k.abortSet.delete(k);v.status=1;Ue(l,k.blockedBoundary,v)}catch(P){ie();v.children.length=w;v.chunks.length=C;var A=P===Kd?Od():P;if("object"===typeof A&&null!==A&&"function"===typeof A.then){var fa=k.ping;A.then(fa,fa);k.thenableState=
+je()}else{k.abortSet.delete(k);v.status=4;var U=k.blockedBoundary;m=W(l,A);null===U?Je(l,A):(U.pendingTasks--,4!==U.status&&(U.status=4,U.errorDigest=m,U.parentFlushed&&l.clientRenderedBoundaries.push(U)));l.allPendingTasks--;0===l.allPendingTasks&&Xe(l)}}finally{l.renderState.boundaryResources=null}}}g.splice(0,h);null!==a.destination&&Ye(a,a.destination)}catch(P){W(a,P),Je(a,P)}finally{ve=f,ye.current=c,ze.current=d,c===we&&Bd(b),T=e}}}
+function Ze(a,b,c){c.parentFlushed=!0;switch(c.status){case 0:c.id=a.nextSegmentId++;case 5:var d=c.id;c.lastPushedText=!1;c.textEmbedded=!1;a=a.renderState;b.push('<template id="');b.push(a.placeholderPrefix);a=d.toString(16);b.push(a);return b.push('"></template>');case 1:c.status=2;var e=!0;d=c.chunks;var f=0;c=c.children;for(var g=0;g<c.length;g++){for(e=c[g];f<e.index;f++)b.push(d[f]);e=$e(a,b,e)}for(;f<d.length-1;f++)b.push(d[f]);f<d.length&&(e=b.push(d[f]));return e;default:throw Error(q(390));
 }}
-function Ye(a,b,c){var d=c.boundary;if(null===d)return Xe(a,b,c);d.parentFlushed=!0;if(4===d.status)return a.renderState.generateStaticMarkup||(d=d.errorDigest,b.push("\x3c!--$!--\x3e"),b.push("<template"),d&&(b.push(' data-dgst="'),d=w(d),b.push(d),b.push('"')),b.push("></template>")),Xe(a,b,c),a=a.renderState.generateStaticMarkup?!0:b.push("\x3c!--/$--\x3e"),a;if(1!==d.status)return 0===d.status&&(d.rootSegmentID=a.nextSegmentId++),0<d.completedSegments.length&&a.partialBoundaries.push(d),Ub(b,a.renderState,
-d.rootSegmentID),Xe(a,b,c),b.push("\x3c!--/$--\x3e");if(d.byteSize>a.progressiveChunkSize)return d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),Ub(b,a.renderState,d.rootSegmentID),Xe(a,b,c),b.push("\x3c!--/$--\x3e");c=d.resources;var e=a.renderState.boundaryResources;e&&(c.styles.forEach(Ac,e),c.stylesheets.forEach(Bc,e));a.renderState.generateStaticMarkup||b.push("\x3c!--$--\x3e");c=d.completedSegments;if(1!==c.length)throw Error(p(391));Ye(a,b,c[0]);a=a.renderState.generateStaticMarkup?
-!0:b.push("\x3c!--/$--\x3e");return a}function Ze(a,b,c){Vb(b,a.renderState,c.parentFormatContext,c.id);Ye(a,b,c);return Wb(b,c.parentFormatContext)}
-function $e(a,b,c){a.renderState.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e<d.length;e++)af(a,b,c,d[e]);d.length=0;nc(b,c.resources,a.renderState);d=a.resumableState;a=a.renderState;e=c.rootSegmentID;c=c.resources;var f=a.stylesToHoist;a.stylesToHoist=!1;var g=0===d.streamingFormat;g?(b.push(a.startInlineScript),f?0===(d.instructions&2)?(d.instructions|=10,b.push('$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};$RR("')):
+function $e(a,b,c){var d=c.boundary;if(null===d)return Ze(a,b,c);d.parentFlushed=!0;if(4===d.status)return a.renderState.generateStaticMarkup||(d=d.errorDigest,b.push("\x3c!--$!--\x3e"),b.push("<template"),d&&(b.push(' data-dgst="'),d=z(d),b.push(d),b.push('"')),b.push("></template>")),Ze(a,b,c),a=a.renderState.generateStaticMarkup?!0:b.push("\x3c!--/$--\x3e"),a;if(1!==d.status)return 0===d.status&&(d.rootSegmentID=a.nextSegmentId++),0<d.completedSegments.length&&a.partialBoundaries.push(d),Ub(b,a.renderState,
+d.rootSegmentID),Ze(a,b,c),b.push("\x3c!--/$--\x3e");if(d.byteSize>a.progressiveChunkSize)return d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),Ub(b,a.renderState,d.rootSegmentID),Ze(a,b,c),b.push("\x3c!--/$--\x3e");c=d.resources;var e=a.renderState.boundaryResources;e&&(c.styles.forEach(Ac,e),c.stylesheets.forEach(Bc,e));a.renderState.generateStaticMarkup||b.push("\x3c!--$--\x3e");c=d.completedSegments;if(1!==c.length)throw Error(q(391));$e(a,b,c[0]);a=a.renderState.generateStaticMarkup?
+!0:b.push("\x3c!--/$--\x3e");return a}function af(a,b,c){Vb(b,a.renderState,c.parentFormatContext,c.id);$e(a,b,c);return Wb(b,c.parentFormatContext)}
+function bf(a,b,c){a.renderState.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e<d.length;e++)cf(a,b,c,d[e]);d.length=0;nc(b,c.resources,a.renderState);d=a.resumableState;a=a.renderState;e=c.rootSegmentID;c=c.resources;var f=a.stylesToHoist;a.stylesToHoist=!1;var g=0===d.streamingFormat;g?(b.push(a.startInlineScript),f?0===(d.instructions&2)?(d.instructions|=10,b.push('$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};$RR("')):
 0===(d.instructions&8)?(d.instructions|=8,b.push('$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};$RR("')):
 b.push('$RR("'):0===(d.instructions&2)?(d.instructions|=2,b.push('$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};$RC("')):
-b.push('$RC("')):f?b.push('<template data-rri="" data-bid="'):b.push('<template data-rci="" data-bid="');d=e.toString(16);b.push(a.boundaryPrefix);b.push(d);g?b.push('","'):b.push('" data-sid="');b.push(a.segmentPrefix);b.push(d);f?g?(b.push('",'),tc(b,c)):(b.push('" data-sty="'),uc(b,c)):g&&b.push('"');d=g?b.push(")\x3c/script>"):b.push('"></template>');return Tb(b,a)&&d}
-function af(a,b,c,d){if(2===d.status)return!0;var e=d.id;if(-1===e){if(-1===(d.id=c.rootSegmentID))throw Error(p(392));return Ze(a,b,d)}if(e===c.rootSegmentID)return Ze(a,b,d);Ze(a,b,d);c=a.resumableState;a=a.renderState;(d=0===c.streamingFormat)?(b.push(a.startInlineScript),0===(c.instructions&1)?(c.instructions|=1,b.push('$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};$RS("')):
+b.push('$RC("')):f?b.push('<template data-rri="" data-bid="'):b.push('<template data-rci="" data-bid="');e=e.toString(16);b.push(a.boundaryPrefix);b.push(e);g?b.push('","'):b.push('" data-sid="');b.push(a.segmentPrefix);b.push(e);f?g?(b.push('",'),tc(b,c)):(b.push('" data-sty="'),uc(b,c)):g&&b.push('"');c=g?b.push(")\x3c/script>"):b.push('"></template>');return Tb(b,a,d)&&c}
+function cf(a,b,c,d){if(2===d.status)return!0;var e=d.id;if(-1===e){if(-1===(d.id=c.rootSegmentID))throw Error(q(392));return af(a,b,d)}if(e===c.rootSegmentID)return af(a,b,d);af(a,b,d);c=a.resumableState;a=a.renderState;(d=0===c.streamingFormat)?(b.push(a.startInlineScript),0===(c.instructions&1)?(c.instructions|=1,b.push('$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};$RS("')):
 b.push('$RS("')):b.push('<template data-rsi="" data-sid="');b.push(a.segmentPrefix);e=e.toString(16);b.push(e);d?b.push('","'):b.push('" data-pid="');b.push(a.placeholderPrefix);b.push(e);b=d?b.push('")\x3c/script>'):b.push('"></template>');return b}
-function We(a,b){try{var c,d=a.completedRootSegment;if(null!==d)if(5!==d.status&&0===a.pendingRootTasks){var e=a.renderState;if((0!==a.allPendingTasks||null!==a.trackedPostpones)&&e.externalRuntimeScript){var f=e.externalRuntimeScript,g=a.resumableState,h=f.src,k=f.chunks;g.scriptResources.hasOwnProperty(h)||(g.scriptResources[h]=null,e.scripts.add(k))}var l=e.htmlChunks,n=e.headChunks;f=0;if(l){for(f=0;f<l.length;f++)b.push(l[f]);if(n)for(f=0;f<n.length;f++)b.push(n[f]);else{var r=L("head");b.push(r);
-b.push(">")}}else if(n)for(f=0;f<n.length;f++)b.push(n[f]);var m=e.charsetChunks;for(f=0;f<m.length;f++)b.push(m[f]);m.length=0;e.preconnects.forEach(O,b);e.preconnects.clear();var G=e.preconnectChunks;for(f=0;f<G.length;f++)b.push(G[f]);G.length=0;e.fontPreloads.forEach(O,b);e.fontPreloads.clear();e.highImagePreloads.forEach(O,b);e.highImagePreloads.clear();e.styles.forEach(qc,b);var A=e.importMapChunks;for(f=0;f<A.length;f++)b.push(A[f]);A.length=0;e.bootstrapScripts.forEach(O,b);e.scripts.forEach(O,
-b);e.scripts.clear();e.bulkPreloads.forEach(O,b);e.bulkPreloads.clear();var T=e.preloadChunks;for(f=0;f<T.length;f++)b.push(T[f]);T.length=0;var u=e.hoistableChunks;for(f=0;f<u.length;f++)b.push(u[f]);u.length=0;if(l&&null===n){var z=Lb("head");b.push(z)}Ye(a,b,d);a.completedRootSegment=null;Tb(b,a.renderState)}else return;var q=a.renderState;d=0;q.preconnects.forEach(O,b);q.preconnects.clear();var aa=q.preconnectChunks;for(d=0;d<aa.length;d++)b.push(aa[d]);aa.length=0;q.fontPreloads.forEach(O,b);
-q.fontPreloads.clear();q.highImagePreloads.forEach(O,b);q.highImagePreloads.clear();q.styles.forEach(sc,b);q.scripts.forEach(O,b);q.scripts.clear();q.bulkPreloads.forEach(O,b);q.bulkPreloads.clear();var H=q.preloadChunks;for(d=0;d<H.length;d++)b.push(H[d]);H.length=0;var ba=q.hoistableChunks;for(d=0;d<ba.length;d++)b.push(ba[d]);ba.length=0;var B=a.clientRenderedBoundaries;for(c=0;c<B.length;c++){var M=B[c];q=b;var x=a.resumableState,fa=a.renderState,R=M.rootSegmentID,N=M.errorDigest,na=M.errorMessage,
-ha=M.errorComponentStack,W=0===x.streamingFormat;W?(q.push(fa.startInlineScript),0===(x.instructions&4)?(x.instructions|=4,q.push('$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};;$RX("')):q.push('$RX("')):q.push('<template data-rxi="" data-bid="');q.push(fa.boundaryPrefix);var Qa=R.toString(16);q.push(Qa);W&&q.push('"');if(N||na||ha)if(W){q.push(",");var Ra=gc(N||"");q.push(Ra)}else{q.push('" data-dgst="');
-var Sa=w(N||"");q.push(Sa)}if(na||ha)if(W){q.push(",");var oa=gc(na||"");q.push(oa)}else{q.push('" data-msg="');var P=w(na||"");q.push(P)}if(ha)if(W){q.push(",");var rb=gc(ha);q.push(rb)}else{q.push('" data-stck="');var pa=w(ha);q.push(pa)}if(W?!q.push(")\x3c/script>"):!q.push('"></template>')){a.destination=null;c++;B.splice(0,c);return}}B.splice(0,c);var qa=a.completedBoundaries;for(c=0;c<qa.length;c++)if(!$e(a,b,qa[c])){a.destination=null;c++;qa.splice(0,c);return}qa.splice(0,c);var ca=a.partialBoundaries;
-for(c=0;c<ca.length;c++){var ra=ca[c];a:{B=a;M=b;B.renderState.boundaryResources=ra.resources;var sa=ra.completedSegments;for(x=0;x<sa.length;x++)if(!af(B,M,ra,sa[x])){x++;sa.splice(0,x);var Ta=!1;break a}sa.splice(0,x);Ta=nc(M,ra.resources,B.renderState)}if(!Ta){a.destination=null;c++;ca.splice(0,c);return}}ca.splice(0,c);var ta=a.completedBoundaries;for(c=0;c<ta.length;c++)if(!$e(a,b,ta[c])){a.destination=null;c++;ta.splice(0,c);return}ta.splice(0,c)}finally{0===a.allPendingTasks&&0===a.pingedTasks.length&&
-0===a.clientRenderedBoundaries.length&&0===a.completedBoundaries.length&&(a.flushScheduled=!1,c=a.resumableState,c.hasBody&&(ca=Lb("body"),b.push(ca)),c.hasHtml&&(c=Lb("html"),b.push(c)),b.push(null),a.destination=null)}}function xc(a){if(!1===a.flushScheduled&&0===a.pingedTasks.length&&null!==a.destination){a.flushScheduled=!0;var b=a.destination;b?We(a,b):a.flushScheduled=!1}}
-function bf(a,b){try{var c=a.abortableTasks;if(0<c.size){var d=void 0===b?Error(p(432)):b;c.forEach(function(e){return Te(e,a,d)});c.clear()}null!==a.destination&&We(a,a.destination)}catch(e){V(a,e),Ie(a,e)}}function cf(){}
-function df(a,b,c,d){var e=!1,f=null,g="",h={push:function(l){null!==l&&(g+=l);return!0},destroy:function(l){e=!0;f=l}},k=!1;b=nb(b?b.identifierPrefix:void 0,void 0);a=Be(a,b,Dc(b,c),D(0,null,0),Infinity,cf,void 0,function(){k=!0},void 0,void 0,void 0);a.flushScheduled=null!==a.destination;Fe(a);null===a.trackedPostpones&&Cc(a.renderState,a.resumableState,0===a.pendingRootTasks);bf(a,d);if(1===a.status)a.status=2,h.destroy(a.fatalError);else if(2!==a.status&&null===a.destination){a.destination=h;
-try{We(a,h)}catch(l){V(a,l),Ie(a,l)}}if(e&&f!==d)throw f;if(!k)throw Error(p(426));return g}exports.renderToNodeStream=function(){throw Error(p(207));};exports.renderToStaticMarkup=function(a,b){return df(a,b,!0,'The server used "renderToStaticMarkup" which does not support Suspense. If you intended to have the server wait for the suspended component please switch to "renderToReadableStream" which supports Suspense on the server')};exports.renderToStaticNodeStream=function(){throw Error(p(208));};
-exports.renderToString=function(a,b){return df(a,b,!1,'The server used "renderToString" which does not support Suspense. If you intended for this Suspense boundary to render the fallback content on the server consider throwing an Error somewhere within the Suspense boundary. If you intended to have the server wait for the suspended component please switch to "renderToReadableStream" which supports Suspense on the server')};exports.version="18.3.0-canary-2983249dd-20231107";
+function Ye(a,b){try{var c,d=a.completedRootSegment;if(null!==d)if(5!==d.status&&0===a.pendingRootTasks){var e=a.renderState;if((0!==a.allPendingTasks||null!==a.trackedPostpones)&&e.externalRuntimeScript){var f=e.externalRuntimeScript,g=a.resumableState,h=f.src,k=f.chunks;g.scriptResources.hasOwnProperty(h)||(g.scriptResources[h]=null,e.scripts.add(k))}var l=e.htmlChunks,n=e.headChunks;f=0;if(l){for(f=0;f<l.length;f++)b.push(l[f]);if(n)for(f=0;f<n.length;f++)b.push(n[f]);else{var r=N("head");b.push(r);
+b.push(">")}}else if(n)for(f=0;f<n.length;f++)b.push(n[f]);var m=e.charsetChunks;for(f=0;f<m.length;f++)b.push(m[f]);m.length=0;e.preconnects.forEach(Q,b);e.preconnects.clear();var F=e.preconnectChunks;for(f=0;f<F.length;f++)b.push(F[f]);F.length=0;e.fontPreloads.forEach(Q,b);e.fontPreloads.clear();e.highImagePreloads.forEach(Q,b);e.highImagePreloads.clear();e.styles.forEach(qc,b);var D=e.importMapChunks;for(f=0;f<D.length;f++)b.push(D[f]);D.length=0;e.bootstrapScripts.forEach(Q,b);e.scripts.forEach(Q,
+b);e.scripts.clear();e.bulkPreloads.forEach(Q,b);e.bulkPreloads.clear();var R=e.preloadChunks;for(f=0;f<R.length;f++)b.push(R[f]);R.length=0;var v=e.hoistableChunks;for(f=0;f<v.length;f++)b.push(v[f]);v.length=0;if(l&&null===n){var u=Lb("head");b.push(u)}$e(a,b,d);a.completedRootSegment=null;Tb(b,a.renderState,a.resumableState)}else return;var p=a.renderState;d=0;p.preconnects.forEach(Q,b);p.preconnects.clear();var G=p.preconnectChunks;for(d=0;d<G.length;d++)b.push(G[d]);G.length=0;p.fontPreloads.forEach(Q,
+b);p.fontPreloads.clear();p.highImagePreloads.forEach(Q,b);p.highImagePreloads.clear();p.styles.forEach(sc,b);p.scripts.forEach(Q,b);p.scripts.clear();p.bulkPreloads.forEach(Q,b);p.bulkPreloads.clear();var x=p.preloadChunks;for(d=0;d<x.length;d++)b.push(x[d]);x.length=0;var w=p.hoistableChunks;for(d=0;d<w.length;d++)b.push(w[d]);w.length=0;var C=a.clientRenderedBoundaries;for(c=0;c<C.length;c++){var O=C[c];p=b;var A=a.resumableState,fa=a.renderState,U=O.rootSegmentID,P=O.errorDigest,na=O.errorMessage,
+ha=O.errorComponentStack,Y=0===A.streamingFormat;Y?(p.push(fa.startInlineScript),0===(A.instructions&4)?(A.instructions|=4,p.push('$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};;$RX("')):p.push('$RX("')):p.push('<template data-rxi="" data-bid="');p.push(fa.boundaryPrefix);var Qa=U.toString(16);p.push(Qa);Y&&p.push('"');if(P||na||ha)if(Y){p.push(",");var Ra=gc(P||"");p.push(Ra)}else{p.push('" data-dgst="');
+var Sa=z(P||"");p.push(Sa)}if(na||ha)if(Y){p.push(",");var oa=gc(na||"");p.push(oa)}else{p.push('" data-msg="');var S=z(na||"");p.push(S)}if(ha)if(Y){p.push(",");var rb=gc(ha);p.push(rb)}else{p.push('" data-stck="');var pa=z(ha);p.push(pa)}if(Y?!p.push(")\x3c/script>"):!p.push('"></template>')){a.destination=null;c++;C.splice(0,c);return}}C.splice(0,c);var qa=a.completedBoundaries;for(c=0;c<qa.length;c++)if(!bf(a,b,qa[c])){a.destination=null;c++;qa.splice(0,c);return}qa.splice(0,c);var ca=a.partialBoundaries;
+for(c=0;c<ca.length;c++){var ra=ca[c];a:{C=a;O=b;C.renderState.boundaryResources=ra.resources;var sa=ra.completedSegments;for(A=0;A<sa.length;A++)if(!cf(C,O,ra,sa[A])){A++;sa.splice(0,A);var Ta=!1;break a}sa.splice(0,A);Ta=nc(O,ra.resources,C.renderState)}if(!Ta){a.destination=null;c++;ca.splice(0,c);return}}ca.splice(0,c);var ta=a.completedBoundaries;for(c=0;c<ta.length;c++)if(!bf(a,b,ta[c])){a.destination=null;c++;ta.splice(0,c);return}ta.splice(0,c)}finally{0===a.allPendingTasks&&0===a.pingedTasks.length&&
+0===a.clientRenderedBoundaries.length&&0===a.completedBoundaries.length&&(a.flushScheduled=!1,c=a.resumableState,c.hasBody&&(ca=Lb("body"),b.push(ca)),c.hasHtml&&(c=Lb("html"),b.push(c)),b.push(null),a.destination=null)}}function xc(a){if(!1===a.flushScheduled&&0===a.pingedTasks.length&&null!==a.destination){a.flushScheduled=!0;var b=a.destination;b?Ye(a,b):a.flushScheduled=!1}}
+function df(a,b){try{var c=a.abortableTasks;if(0<c.size){var d=void 0===b?Error(q(432)):b;c.forEach(function(e){return Ve(e,a,d)});c.clear()}null!==a.destination&&Ye(a,a.destination)}catch(e){W(a,e),Je(a,e)}}function ef(){}
+function ff(a,b,c,d){var e=!1,f=null,g="",h={push:function(l){null!==l&&(g+=l);return!0},destroy:function(l){e=!0;f=l}},k=!1;b=nb(b?b.identifierPrefix:void 0,void 0);a=Ce(a,b,Dc(b,c),E(0,null,0),Infinity,ef,void 0,function(){k=!0},void 0,void 0,void 0);a.flushScheduled=null!==a.destination;Ge(a);null===a.trackedPostpones&&Cc(a.renderState,a.resumableState,0===a.pendingRootTasks);df(a,d);if(1===a.status)a.status=2,h.destroy(a.fatalError);else if(2!==a.status&&null===a.destination){a.destination=h;
+try{Ye(a,h)}catch(l){W(a,l),Je(a,l)}}if(e&&f!==d)throw f;if(!k)throw Error(q(426));return g}exports.renderToNodeStream=function(){throw Error(q(207));};exports.renderToStaticMarkup=function(a,b){return ff(a,b,!0,'The server used "renderToStaticMarkup" which does not support Suspense. If you intended to have the server wait for the suspended component please switch to "renderToReadableStream" which supports Suspense on the server')};exports.renderToStaticNodeStream=function(){throw Error(q(208));};
+exports.renderToString=function(a,b){return ff(a,b,!1,'The server used "renderToString" which does not support Suspense. If you intended for this Suspense boundary to render the fallback content on the server consider throwing an Error somewhere within the Suspense boundary. If you intended to have the server wait for the suspended component please switch to "renderToReadableStream" which supports Suspense on the server')};exports.version="18.3.0-canary-7508dcd5c-20231108";
+
+//# sourceMappingURL=react-dom-server-legacy.browser.production.min.js.map
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.node.development.js b/packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.node.development.js
index 4683dd9df0bc6..6ba96b067cb7a 100644
--- a/packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.node.development.js
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.node.development.js
@@ -18,7 +18,7 @@ var React = require("next/dist/compiled/react");
 var ReactDOM = require('react-dom');
 var stream = require('stream');
 
-var ReactVersion = '18.3.0-canary-2983249dd-20231107';
+var ReactVersion = '18.3.0-canary-7508dcd5c-20231108';
 
 var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
 
@@ -1730,11 +1730,14 @@ var DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS = 2000; // Allows us to keep tr
 // if passed externalRuntimeConfig and the enableFizzExternalRuntime feature flag
 // is set, the server will send instructions via data attributes (instead of inline scripts)
 
-function createRenderState$1(resumableState, nonce, bootstrapScriptContent, bootstrapScripts, bootstrapModules, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
+function createRenderState$1(resumableState, nonce, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
   var inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
   var idPrefix = resumableState.idPrefix;
   var bootstrapChunks = [];
   var externalRuntimeScript = null;
+  var bootstrapScriptContent = resumableState.bootstrapScriptContent,
+      bootstrapScripts = resumableState.bootstrapScripts,
+      bootstrapModules = resumableState.bootstrapModules;
 
   if (bootstrapScriptContent !== undefined) {
     bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapAndImportMapScriptContent(bootstrapScriptContent)), endInlineScript);
@@ -1923,7 +1926,7 @@ function createRenderState$1(resumableState, nonce, bootstrapScriptContent, boot
 
   return renderState;
 }
-function createResumableState(identifierPrefix, externalRuntimeConfig) {
+function createResumableState(identifierPrefix, externalRuntimeConfig, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
   var idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
   var streamingFormat = ScriptStreamingFormat;
 
@@ -1937,6 +1940,9 @@ function createResumableState(identifierPrefix, externalRuntimeConfig) {
     idPrefix: idPrefix,
     nextFormID: 0,
     streamingFormat: streamingFormat,
+    bootstrapScriptContent: bootstrapScriptContent,
+    bootstrapScripts: bootstrapScripts,
+    bootstrapModules: bootstrapModules,
     instructions: NothingSent,
     hasBody: false,
     hasHtml: false,
@@ -4374,7 +4380,10 @@ function pushEndInstance(target, type, props, resumableState, formatContext) {
   target.push(endChunkForTag(type));
 }
 
-function writeBootstrap(destination, renderState) {
+function writeBootstrap(destination, renderState, resumableState) {
+  resumableState.bootstrapScriptContent = undefined;
+  resumableState.bootstrapScripts = undefined;
+  resumableState.bootstrapModules = undefined;
   var bootstrapChunks = renderState.bootstrapChunks;
   var i = 0;
 
@@ -4391,8 +4400,8 @@ function writeBootstrap(destination, renderState) {
   return true;
 }
 
-function writeCompletedRoot(destination, renderState) {
-  return writeBootstrap(destination, renderState);
+function writeCompletedRoot(destination, renderState, resumableState) {
+  return writeBootstrap(destination, renderState, resumableState);
 } // Structural Nodes
 // A placeholder is a node inside a hidden partial tree that can be filled in later, but before
 // display. It's never visible to users. We use the template tag because it can be used in every
@@ -4749,7 +4758,7 @@ function writeCompletedBoundaryInstruction(destination, resumableState, renderSt
     writeMore = writeChunkAndReturn(destination, completeBoundaryDataEnd);
   }
 
-  return writeBootstrap(destination, renderState) && writeMore;
+  return writeBootstrap(destination, renderState, resumableState) && writeMore;
 }
 var clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
 var clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
@@ -6485,7 +6494,7 @@ function emitEarlyPreloads(renderState, resumableState, shellComplete) {
 }
 
 function createRenderState(resumableState, generateStaticMarkup) {
-  var renderState = createRenderState$1(resumableState, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+  var renderState = createRenderState$1(resumableState, undefined, undefined, undefined, undefined, undefined);
   return {
     // Keep this in sync with ReactFizzConfigDOM
     placeholderPrefix: renderState.placeholderPrefix,
@@ -6833,6 +6842,18 @@ var componentFrameCache;
   var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
   componentFrameCache = new PossiblyWeakMap();
 }
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
@@ -6848,7 +6869,6 @@ function describeNativeComponentFrame(fn, construct) {
     }
   }
 
-  var control;
   reentry = true;
   var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
 
@@ -6862,81 +6882,140 @@ function describeNativeComponentFrame(fn, construct) {
     ReactCurrentDispatcher$1.current = null;
     disableLogs();
   }
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
 
-  try {
-    // This should throw.
-    if (construct) {
-      // Something should be setting the props in the constructor.
-      var Fake = function () {
-        throw Error();
-      }; // $FlowFixMe[prop-missing]
 
+  var RunInRootFrame = {
+    DetermineComponentFrameRoot: function () {
+      var control;
 
-      Object.defineProperty(Fake.prototype, 'props', {
-        set: function () {
-          // We use a throwing setter instead of frozen or non-writable props
-          // because that won't throw in a non-strict mode function.
-          throw Error();
-        }
-      });
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          var Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
 
-      if (typeof Reflect === 'object' && Reflect.construct) {
-        // We construct a different control for this case to include any extra
-        // frames added by the construct call.
-        try {
-          Reflect.construct(Fake, []);
-        } catch (x) {
-          control = x;
-        }
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
 
-        Reflect.construct(fn, [], Fake);
-      } else {
-        try {
-          Fake.call();
-        } catch (x) {
-          control = x;
-        } // $FlowFixMe[prop-missing] found when upgrading Flow
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
 
 
-        fn.call(Fake.prototype);
-      }
-    } else {
-      try {
-        throw Error();
-      } catch (x) {
-        control = x;
-      } // TODO(luna): This will currently only throw if the function component
-      // tries to access React/ReactDOM/props. We should probably make this throw
-      // in simple components too
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
 
 
-      var maybePromise = fn(); // If the function component returns a promise, it's likely an async
-      // component, which we don't yet support. Attach a noop catch handler to
-      // silence the error.
-      // TODO: Implement component stacks for async client components?
+          var maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
 
-      if (maybePromise && typeof maybePromise.catch === 'function') {
-        maybePromise.catch(function () {});
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(function () {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
       }
+
+      return [null, null];
     }
-  } catch (sample) {
-    // This is inlined manually because closure doesn't do it for us.
-    if (sample && control && typeof sample.stack === 'string') {
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
+
+  try {
+    var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
+
+    if (sampleStack && controlStack) {
       // This extracts the first frame from the sample that isn't also in the control.
       // Skipping one frame that we assume is the frame that calls the two.
-      var sampleLines = sample.stack.split('\n');
-      var controlLines = control.stack.split('\n');
-      var s = sampleLines.length - 1;
-      var c = controlLines.length - 1;
-
-      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
-        // We expect at least one stack frame to be shared.
-        // Typically this will be the root most one. However, stack frames may be
-        // cut off due to maximum stack limits. In this case, one maybe cut off
-        // earlier than the other. We assume that the sample is longer or the same
-        // and there for cut off earlier. So we should find the root most frame in
-        // the sample somewhere in the control.
-        c--;
+      var sampleLines = sampleStack.split('\n');
+      var controlLines = controlStack.split('\n');
+      var s = 0;
+      var c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
       }
 
       for (; s >= 1 && c >= 0; s--, c--) {
@@ -6965,7 +7044,7 @@ function describeNativeComponentFrame(fn, construct) {
                   _frame = _frame.replace('<anonymous>', fn.displayName);
                 }
 
-                {
+                if (true) {
                   if (typeof fn === 'function') {
                     componentFrameCache.set(fn, _frame);
                   }
@@ -11339,7 +11418,7 @@ function flushCompletedQueues(request, destination) {
 
         flushSegment(request, destination, completedRootSegment);
         request.completedRootSegment = null;
-        writeCompletedRoot(destination, request.renderState);
+        writeCompletedRoot(destination, request.renderState, request.resumableState);
       } else {
         // We haven't flushed the root yet so we don't need to check any other branches further down
         return;
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.node.production.js b/packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.node.production.js
new file mode 100644
index 0000000000000..34828e3c5bf58
--- /dev/null
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.node.production.js
@@ -0,0 +1,8674 @@
+/**
+ * @license React
+ * react-dom-server-legacy.node.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require("next/dist/compiled/react");
+var ReactDOM = require('react-dom');
+var stream = require('stream');
+
+var ReactVersion = '18.3.0-canary-7508dcd5c-20231108';
+
+// A pure JS implementation of a string hashing function. We do not use it for
+// security or obfuscation purposes, only to create compact hashes. So we
+// prioritize speed over collision avoidance. For example, we use this to hash
+// the component key path used by useFormState for MPA-style submissions.
+//
+// In environments where built-in hashing functions are available, we prefer
+// those instead. Like Node's crypto module, or Bun.hash. Unfortunately this
+// does not include the web standard crypto API because those methods are all
+// async. For our purposes, we need it to be sync because the cost of context
+// switching is too high to be worth it.
+//
+// The most popular hashing algorithm that meets these requirements in the JS
+// ecosystem is MurmurHash3, and almost all implementations I could find used
+// some version of the implementation by Gary Court inlined below.
+function createFastHashJS(key) {
+  return murmurhash3_32_gc(key, 0);
+}
+/* eslint-disable prefer-const, no-fallthrough */
+
+/**
+ * @license
+ *
+ * JS Implementation of MurmurHash3 (r136) (as of May 20, 2011)
+ *
+ * Copyright (c) 2011 Gary Court
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+function murmurhash3_32_gc(key, seed) {
+  let remainder, bytes, h1, h1b, c1, c2, k1, i;
+  remainder = key.length & 3; // key.length % 4
+
+  bytes = key.length - remainder;
+  h1 = seed;
+  c1 = 0xcc9e2d51;
+  c2 = 0x1b873593;
+  i = 0;
+
+  while (i < bytes) {
+    k1 = key.charCodeAt(i) & 0xff | (key.charCodeAt(++i) & 0xff) << 8 | (key.charCodeAt(++i) & 0xff) << 16 | (key.charCodeAt(++i) & 0xff) << 24;
+    ++i;
+    k1 = (k1 & 0xffff) * c1 + (((k1 >>> 16) * c1 & 0xffff) << 16) & 0xffffffff;
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = (k1 & 0xffff) * c2 + (((k1 >>> 16) * c2 & 0xffff) << 16) & 0xffffffff;
+    h1 ^= k1;
+    h1 = h1 << 13 | h1 >>> 19;
+    h1b = (h1 & 0xffff) * 5 + (((h1 >>> 16) * 5 & 0xffff) << 16) & 0xffffffff;
+    h1 = (h1b & 0xffff) + 0x6b64 + (((h1b >>> 16) + 0xe654 & 0xffff) << 16);
+  }
+
+  k1 = 0;
+
+  switch (remainder) {
+    case 3:
+      k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
+
+    case 2:
+      k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
+
+    case 1:
+      k1 ^= key.charCodeAt(i) & 0xff;
+      k1 = (k1 & 0xffff) * c1 + (((k1 >>> 16) * c1 & 0xffff) << 16) & 0xffffffff;
+      k1 = k1 << 15 | k1 >>> 17;
+      k1 = (k1 & 0xffff) * c2 + (((k1 >>> 16) * c2 & 0xffff) << 16) & 0xffffffff;
+      h1 ^= k1;
+  }
+
+  h1 ^= key.length;
+  h1 ^= h1 >>> 16;
+  h1 = (h1 & 0xffff) * 0x85ebca6b + (((h1 >>> 16) * 0x85ebca6b & 0xffff) << 16) & 0xffffffff;
+  h1 ^= h1 >>> 13;
+  h1 = (h1 & 0xffff) * 0xc2b2ae35 + (((h1 >>> 16) * 0xc2b2ae35 & 0xffff) << 16) & 0xffffffff;
+  h1 ^= h1 >>> 16;
+  return h1 >>> 0;
+}
+
+function scheduleWork(callback) {
+  callback();
+}
+function beginWriting(destination) {}
+function writeChunk(destination, chunk) {
+  writeChunkAndReturn(destination, chunk);
+}
+function writeChunkAndReturn(destination, chunk) {
+  return destination.push(chunk);
+}
+function completeWriting(destination) {}
+function close(destination) {
+  destination.push(null);
+}
+function stringToChunk(content) {
+  return content;
+}
+function stringToPrecomputedChunk(content) {
+  return content;
+}
+function clonePrecomputedChunk(chunk) {
+  return chunk;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+  destination.destroy(error);
+}
+
+const assign = Object.assign;
+
+// -----------------------------------------------------------------------------
+const enableFloat = true; // Enables unstable_useMemoCache hook, intended as a compilation target for
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/* eslint-disable max-len */
+
+const ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
+/* eslint-enable max-len */
+
+const ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
+const VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+const illegalAttributeNameCache = {};
+const validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+  if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+    return true;
+  }
+
+  if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+    return false;
+  }
+
+  if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+    validatedAttributeNameCache[attributeName] = true;
+    return true;
+  }
+
+  illegalAttributeNameCache[attributeName] = true;
+
+  return false;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+const unitlessNumbers = new Set(['animationIterationCount', 'aspectRatio', 'borderImageOutset', 'borderImageSlice', 'borderImageWidth', 'boxFlex', 'boxFlexGroup', 'boxOrdinalGroup', 'columnCount', 'columns', 'flex', 'flexGrow', 'flexPositive', 'flexShrink', 'flexNegative', 'flexOrder', 'gridArea', 'gridRow', 'gridRowEnd', 'gridRowSpan', 'gridRowStart', 'gridColumn', 'gridColumnEnd', 'gridColumnSpan', 'gridColumnStart', 'fontWeight', 'lineClamp', 'lineHeight', 'opacity', 'order', 'orphans', 'scale', 'tabSize', 'widows', 'zIndex', 'zoom', 'fillOpacity', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'MozBoxFlexGroup', 'MozLineClamp', 'msAnimationIterationCount', 'msFlex', 'msZoom', 'msFlexGrow', 'msFlexNegative', 'msFlexOrder', 'msFlexPositive', 'msFlexShrink', 'msGridColumn', 'msGridColumnSpan', 'msGridRow', 'msGridRowSpan', 'WebkitAnimationIterationCount', 'WebkitBoxFlex', 'WebKitBoxFlexGroup', 'WebkitBoxOrdinalGroup', 'WebkitColumnCount', 'WebkitColumns', 'WebkitFlex', 'WebkitFlexGrow', 'WebkitFlexPositive', 'WebkitFlexShrink', 'WebkitLineClamp']);
+function isUnitlessNumber (name) {
+  return unitlessNumbers.has(name);
+}
+
+const aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+  return aliases.get(name) || name;
+}
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// code copied and modified from escape-html
+const matchHtmlRegExp = /["'&<>]/;
+/**
+ * Escapes special characters and HTML entities in a given html string.
+ *
+ * @param  {string} string HTML string to escape for later insertion
+ * @return {string}
+ * @public
+ */
+
+function escapeHtml(string) {
+
+  const str = '' + string;
+  const match = matchHtmlRegExp.exec(str);
+
+  if (!match) {
+    return str;
+  }
+
+  let escape;
+  let html = '';
+  let index;
+  let lastIndex = 0;
+
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        // "
+        escape = '&quot;';
+        break;
+
+      case 38:
+        // &
+        escape = '&amp;';
+        break;
+
+      case 39:
+        // '
+        escape = '&#x27;'; // modified from escape-html; used to be '&#39'
+
+        break;
+
+      case 60:
+        // <
+        escape = '&lt;';
+        break;
+
+      case 62:
+        // >
+        escape = '&gt;';
+        break;
+
+      default:
+        continue;
+    }
+
+    if (lastIndex !== index) {
+      html += str.slice(lastIndex, index);
+    }
+
+    lastIndex = index + 1;
+    html += escape;
+  }
+
+  return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+} // end code copied and modified from escape-html
+
+/**
+ * Escapes text to prevent scripting attacks.
+ *
+ * @param {*} text Text value to escape.
+ * @return {string} An escaped string.
+ */
+
+
+function escapeTextForBrowser(text) {
+  if (typeof text === 'boolean' || typeof text === 'number') {
+    // this shortcircuit helps perf for types that we know will never have
+    // special characters, especially given that this function is used often
+    // for numeric dom ids.
+    return '' + text;
+  }
+
+  return escapeHtml(text);
+}
+
+const uppercasePattern = /([A-Z])/g;
+const msPattern = /^ms-/;
+/**
+ * Hyphenates a camelcased CSS property name, for example:
+ *
+ *   > hyphenateStyleName('backgroundColor')
+ *   < "background-color"
+ *   > hyphenateStyleName('MozTransition')
+ *   < "-moz-transition"
+ *   > hyphenateStyleName('msTransition')
+ *   < "-ms-transition"
+ *
+ * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
+ * is converted to `-ms-`.
+ */
+
+function hyphenateStyleName(name) {
+  return name.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern, '-ms-');
+}
+
+function sanitizeURL(url) {
+
+  return url;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+// The build script is at scripts/rollup/generate-inline-fizz-runtime.js.
+// Run `yarn generate-inline-fizz-runtime` to generate.
+const clientRenderBoundary = '$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};';
+const completeBoundary = '$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};';
+const completeBoundaryWithStyles = '$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};';
+const completeSegment = '$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};';
+const formReplaying = 'addEventListener("submit",function(a){if(!a.defaultPrevented){var c=a.target,d=a.submitter,e=c.action,b=d;if(d){var f=d.getAttribute("formAction");null!=f&&(e=f,b=null)}"javascript:throw new Error(\'A React form was unexpectedly submitted.\')"===e&&(a.preventDefault(),b?(a=document.createElement("input"),a.name=b.name,a.value=b.value,b.parentNode.insertBefore(a,b),b=new FormData(c),a.parentNode.removeChild(a)):b=new FormData(c),a=c.getRootNode(),(a.$$reactFormReplay=a.$$reactFormReplay||[]).push(c,\nd,b))}});';
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+// same object across all transitions.
+
+const sharedNotPendingObject = {
+  pending: false,
+  data: null,
+  method: null,
+  action: null
+};
+const NotPending = sharedNotPendingObject;
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+const ReactDOMServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMServerDispatcher;
+} // We make every property of the descriptor optional because it is not a contract that
+const ScriptStreamingFormat = 0;
+const DataStreamingFormat = 1;
+const NothingSent
+/*                      */
+= 0b00000;
+const SentCompleteSegmentFunction
+/*      */
+= 0b00001;
+const SentCompleteBoundaryFunction
+/*     */
+= 0b00010;
+const SentClientRenderFunction
+/*         */
+= 0b00100;
+const SentStyleInsertionFunction
+/*       */
+= 0b01000;
+const SentFormReplayingRuntime
+/*         */
+= 0b10000; // Per request, global state that is not contextual to the rendering subtree.
+// This cannot be resumed and therefore should only contain things that are
+// temporary working state or are never used in the prerender pass.
+// Credentials here are things that affect whether a browser will make a request
+// as well as things that affect which connection the browser will use for that request.
+// We want these to be aligned across preloads and resources because otherwise the preload
+// will be wasted.
+// We investigated whether referrerPolicy should be included here but from experimentation
+// it seems that browsers do not treat this as part of the http cache key and does not affect
+// which connection is used.
+
+const EXISTS = null; // This constant is to mark preloads that have no unique credentials
+// to convey. It should never be checked by identity and we should not
+// assume Preload values in ResumableState equal this value because they
+// will have come from some parsed input.
+
+const PRELOAD_NO_CREDS = [];
+// This is resumable and therefore should be serializable.
+
+
+const dataElementQuotedEnd = stringToPrecomputedChunk('"></template>');
+const startInlineScript = stringToPrecomputedChunk('<script>');
+const endInlineScript = stringToPrecomputedChunk('</script>');
+const startScriptSrc = stringToPrecomputedChunk('<script src="');
+const startModuleSrc = stringToPrecomputedChunk('<script type="module" src="');
+const scriptNonce = stringToPrecomputedChunk('" nonce="');
+const scriptIntegirty = stringToPrecomputedChunk('" integrity="');
+const scriptCrossOrigin = stringToPrecomputedChunk('" crossorigin="');
+const endAsyncScript = stringToPrecomputedChunk('" async=""></script>');
+/**
+ * This escaping function is designed to work with bootstrapScriptContent and importMap only.
+ * because we know we are escaping the entire script. We can avoid for instance
+ * escaping html comment string sequences that are valid javascript as well because
+ * if there are no sebsequent <script sequences the html parser will never enter
+ * script data double escaped state (see: https://www.w3.org/TR/html53/syntax.html#script-data-double-escaped-state)
+ *
+ * While untrusted script content should be made safe before using this api it will
+ * ensure that the script cannot be early terminated or never terminated state
+ */
+
+function escapeBootstrapAndImportMapScriptContent(scriptText) {
+
+  return ('' + scriptText).replace(scriptRegex, scriptReplacer);
+}
+
+const scriptRegex = /(<\/|<)(s)(cript)/gi;
+
+const scriptReplacer = (match, prefix, s, suffix) => "" + prefix + (s === 's' ? '\\u0073' : '\\u0053') + suffix;
+
+const importMapScriptStart = stringToPrecomputedChunk('<script type="importmap">');
+const importMapScriptEnd = stringToPrecomputedChunk('</script>'); // Since we store headers as strings we deal with their length in utf16 code units
+// rather than visual characters or the utf8 encoding that is used for most binary
+// serialization. Some common HTTP servers only allow for headers to be 4kB in length.
+// We choose a default length that is likely to be well under this already limited length however
+// pathological cases may still cause the utf-8 encoding of the headers to approach this limit.
+// It should also be noted that this maximum is a soft maximum. we have not reached the limit we will
+// allow one more header to be captured which means in practice if the limit is approached it will be exceeded
+
+const DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS = 2000; // Allows us to keep track of what we've already written so we can refer back to it.
+// if passed externalRuntimeConfig and the enableFizzExternalRuntime feature flag
+// is set, the server will send instructions via data attributes (instead of inline scripts)
+
+function createRenderState$1(resumableState, nonce, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
+  const inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
+  const idPrefix = resumableState.idPrefix;
+  const bootstrapChunks = [];
+  let externalRuntimeScript = null;
+  const bootstrapScriptContent = resumableState.bootstrapScriptContent,
+        bootstrapScripts = resumableState.bootstrapScripts,
+        bootstrapModules = resumableState.bootstrapModules;
+
+  if (bootstrapScriptContent !== undefined) {
+    bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapAndImportMapScriptContent(bootstrapScriptContent)), endInlineScript);
+  }
+
+  {
+
+    if (externalRuntimeConfig !== undefined) {
+      if (typeof externalRuntimeConfig === 'string') {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig,
+          async: true,
+          integrity: undefined,
+          nonce: nonce
+        });
+      } else {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig.src,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig.src,
+          async: true,
+          integrity: externalRuntimeConfig.integrity,
+          nonce: nonce
+        });
+      }
+    }
+  }
+
+  const importMapChunks = [];
+
+  if (importMap !== undefined) {
+    const map = importMap;
+    importMapChunks.push(importMapScriptStart);
+    importMapChunks.push(stringToChunk(escapeBootstrapAndImportMapScriptContent(JSON.stringify(map))));
+    importMapChunks.push(importMapScriptEnd);
+  }
+
+  const headers = onHeaders ? {
+    preconnects: '',
+    fontPreloads: '',
+    highImagePreloads: '',
+    remainingCapacity: typeof maxHeadersLength === 'number' ? maxHeadersLength : DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS
+  } : null;
+  const renderState = {
+    placeholderPrefix: stringToPrecomputedChunk(idPrefix + 'P:'),
+    segmentPrefix: stringToPrecomputedChunk(idPrefix + 'S:'),
+    boundaryPrefix: stringToPrecomputedChunk(idPrefix + 'B:'),
+    startInlineScript: inlineScriptWithNonce,
+    htmlChunks: null,
+    headChunks: null,
+    externalRuntimeScript: externalRuntimeScript,
+    bootstrapChunks: bootstrapChunks,
+    onHeaders,
+    headers,
+    resets: {
+      font: {},
+      dns: {},
+      connect: {
+        default: {},
+        anonymous: {},
+        credentials: {}
+      },
+      image: {},
+      style: {}
+    },
+    charsetChunks: [],
+    preconnectChunks: [],
+    importMapChunks,
+    preloadChunks: [],
+    hoistableChunks: [],
+    // cleared on flush
+    preconnects: new Set(),
+    fontPreloads: new Set(),
+    highImagePreloads: new Set(),
+    // usedImagePreloads: new Set(),
+    styles: new Map(),
+    bootstrapScripts: new Set(),
+    scripts: new Set(),
+    bulkPreloads: new Set(),
+    preloads: {
+      images: new Map(),
+      stylesheets: new Map(),
+      scripts: new Map(),
+      moduleScripts: new Map()
+    },
+    nonce,
+    // like a module global for currently rendering boundary
+    boundaryResources: null,
+    stylesToHoist: false
+  };
+
+  if (bootstrapScripts !== undefined) {
+    for (let i = 0; i < bootstrapScripts.length; i++) {
+      const scriptConfig = bootstrapScripts[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'preload',
+        as: 'script',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startScriptSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  if (bootstrapModules !== undefined) {
+    for (let i = 0; i < bootstrapModules.length; i++) {
+      const scriptConfig = bootstrapModules[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'modulepreload',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startModuleSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  return renderState;
+}
+function createResumableState(identifierPrefix, externalRuntimeConfig, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
+  const idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
+  let streamingFormat = ScriptStreamingFormat;
+
+  {
+    if (externalRuntimeConfig !== undefined) {
+      streamingFormat = DataStreamingFormat;
+    }
+  }
+
+  return {
+    idPrefix: idPrefix,
+    nextFormID: 0,
+    streamingFormat,
+    bootstrapScriptContent,
+    bootstrapScripts,
+    bootstrapModules,
+    instructions: NothingSent,
+    hasBody: false,
+    hasHtml: false,
+    // @TODO add bootstrap script to implicit preloads
+    // persistent
+    unknownResources: {},
+    dnsResources: {},
+    connectResources: {
+      default: {},
+      anonymous: {},
+      credentials: {}
+    },
+    imageResources: {},
+    styleResources: {},
+    scriptResources: {},
+    moduleUnknownResources: {},
+    moduleScriptResources: {}
+  };
+}
+// modes. We only include the variants as they matter for the sake of our purposes.
+// We don't actually provide the namespace therefore we use constants instead of the string.
+
+const ROOT_HTML_MODE = 0; // Used for the root most element tag.
+// We have a less than HTML_HTML_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const HTML_HTML_MODE = 1; // Used for the <html> if it is at the top level.
+
+const HTML_MODE = 2;
+const SVG_MODE = 3;
+const MATHML_MODE = 4;
+const HTML_TABLE_MODE = 5;
+const HTML_TABLE_BODY_MODE = 6;
+const HTML_TABLE_ROW_MODE = 7;
+const HTML_COLGROUP_MODE = 8; // We have a greater than HTML_TABLE_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const NO_SCOPE =
+/*         */
+0b00;
+const NOSCRIPT_SCOPE =
+/*   */
+0b01;
+const PICTURE_SCOPE =
+/*    */
+0b10; // Lets us keep track of contextual state and pick it back up after suspending.
+
+function createFormatContext(insertionMode, selectedValue, tagScope) {
+  return {
+    insertionMode,
+    selectedValue,
+    tagScope
+  };
+}
+
+function createRootFormatContext(namespaceURI) {
+  const insertionMode = namespaceURI === 'http://www.w3.org/2000/svg' ? SVG_MODE : namespaceURI === 'http://www.w3.org/1998/Math/MathML' ? MATHML_MODE : ROOT_HTML_MODE;
+  return createFormatContext(insertionMode, null, NO_SCOPE);
+}
+function getChildFormatContext(parentContext, type, props) {
+  switch (type) {
+    case 'noscript':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | NOSCRIPT_SCOPE);
+
+    case 'select':
+      return createFormatContext(HTML_MODE, props.value != null ? props.value : props.defaultValue, parentContext.tagScope);
+
+    case 'svg':
+      return createFormatContext(SVG_MODE, null, parentContext.tagScope);
+
+    case 'picture':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | PICTURE_SCOPE);
+
+    case 'math':
+      return createFormatContext(MATHML_MODE, null, parentContext.tagScope);
+
+    case 'foreignObject':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    // Table parents are special in that their children can only be created at all if they're
+    // wrapped in a table parent. So we need to encode that we're entering this mode.
+
+    case 'table':
+      return createFormatContext(HTML_TABLE_MODE, null, parentContext.tagScope);
+
+    case 'thead':
+    case 'tbody':
+    case 'tfoot':
+      return createFormatContext(HTML_TABLE_BODY_MODE, null, parentContext.tagScope);
+
+    case 'colgroup':
+      return createFormatContext(HTML_COLGROUP_MODE, null, parentContext.tagScope);
+
+    case 'tr':
+      return createFormatContext(HTML_TABLE_ROW_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode >= HTML_TABLE_MODE) {
+    // Whatever tag this was, it wasn't a table parent or other special parent, so we must have
+    // entered plain HTML again.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode === ROOT_HTML_MODE) {
+    if (type === 'html') {
+      // We've emitted the root and is now in <html> mode.
+      return createFormatContext(HTML_HTML_MODE, null, parentContext.tagScope);
+    } else {
+      // We've emitted the root and is now in plain HTML mode.
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    }
+  } else if (parentContext.insertionMode === HTML_HTML_MODE) {
+    // We've emitted the document element and is now in plain HTML mode.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  return parentContext;
+}
+function makeId(resumableState, treeId, localId) {
+  const idPrefix = resumableState.idPrefix;
+  let id = ':' + idPrefix + 'R' + treeId; // Unless this is the first id at this level, append a number at the end
+  // that represents the position of this useId hook among all the useId
+  // hooks for this fiber.
+
+  if (localId > 0) {
+    id += 'H' + localId.toString(32);
+  }
+
+  return id + ':';
+}
+
+function encodeHTMLTextNode(text) {
+  return escapeTextForBrowser(text);
+}
+
+const textSeparator = stringToPrecomputedChunk('<!-- -->');
+function pushTextInstance$1(target, text, renderState, textEmbedded) {
+  if (text === '') {
+    // Empty text doesn't have a DOM node representation and the hydration is aware of this.
+    return textEmbedded;
+  }
+
+  if (textEmbedded) {
+    target.push(textSeparator);
+  }
+
+  target.push(stringToChunk(encodeHTMLTextNode(text)));
+  return true;
+} // Called when Fizz is done with a Segment. Currently the only purpose is to conditionally
+// emit a text separator when we don't know for sure it is safe to omit
+
+function pushSegmentFinale$1(target, renderState, lastPushedText, textEmbedded) {
+  if (lastPushedText && textEmbedded) {
+    target.push(textSeparator);
+  }
+}
+const styleNameCache = new Map();
+
+function processStyleName(styleName) {
+  const chunk = styleNameCache.get(styleName);
+
+  if (chunk !== undefined) {
+    return chunk;
+  }
+
+  const result = stringToPrecomputedChunk(escapeTextForBrowser(hyphenateStyleName(styleName)));
+  styleNameCache.set(styleName, result);
+  return result;
+}
+
+const styleAttributeStart = stringToPrecomputedChunk(' style="');
+const styleAssign = stringToPrecomputedChunk(':');
+const styleSeparator = stringToPrecomputedChunk(';');
+
+function pushStyleAttribute(target, style) {
+  if (typeof style !== 'object') {
+    throw new Error('The `style` prop expects a mapping from style properties to values, ' + "not a string. For example, style={{marginRight: spacing + 'em'}} when " + 'using JSX.');
+  }
+
+  let isFirst = true;
+
+  for (const styleName in style) {
+    if (!hasOwnProperty.call(style, styleName)) {
+      continue;
+    } // If you provide unsafe user data here they can inject arbitrary CSS
+    // which may be problematic (I couldn't repro this):
+    // https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet
+    // http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/
+    // This is not an XSS hole but instead a potential CSS injection issue
+    // which has lead to a greater discussion about how we're going to
+    // trust URLs moving forward. See #2115901
+
+
+    const styleValue = style[styleName];
+
+    if (styleValue == null || typeof styleValue === 'boolean' || styleValue === '') {
+      // TODO: We used to set empty string as a style with an empty value. Does that ever make sense?
+      continue;
+    }
+
+    let nameChunk;
+    let valueChunk;
+    const isCustomProperty = styleName.indexOf('--') === 0;
+
+    if (isCustomProperty) {
+      nameChunk = stringToChunk(escapeTextForBrowser(styleName));
+
+      valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+    } else {
+
+      nameChunk = processStyleName(styleName);
+
+      if (typeof styleValue === 'number') {
+        if (styleValue !== 0 && !isUnitlessNumber(styleName)) {
+          valueChunk = stringToChunk(styleValue + 'px'); // Presumes implicit 'px' suffix for unitless numbers
+        } else {
+          valueChunk = stringToChunk('' + styleValue);
+        }
+      } else {
+
+        valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+      }
+    }
+
+    if (isFirst) {
+      isFirst = false; // If it's first, we don't need any separators prefixed.
+
+      target.push(styleAttributeStart, nameChunk, styleAssign, valueChunk);
+    } else {
+      target.push(styleSeparator, nameChunk, styleAssign, valueChunk);
+    }
+  }
+
+  if (!isFirst) {
+    target.push(attributeEnd);
+  }
+}
+
+const attributeSeparator = stringToPrecomputedChunk(' ');
+const attributeAssign = stringToPrecomputedChunk('="');
+const attributeEnd = stringToPrecomputedChunk('"');
+const attributeEmptyString = stringToPrecomputedChunk('=""');
+
+function pushBooleanAttribute(target, name, value) // not null or undefined
+{
+  if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+    target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+  }
+}
+
+function pushStringAttribute(target, name, value) // not null or undefined
+{
+  if (typeof value !== 'function' && typeof value !== 'symbol' && typeof value !== 'boolean') {
+    target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+  }
+}
+
+function makeFormFieldPrefix(resumableState) {
+  const id = resumableState.nextFormID++;
+  return resumableState.idPrefix + id;
+} // Since this will likely be repeated a lot in the HTML, we use a more concise message
+// than on the client and hopefully it's googleable.
+
+
+const actionJavaScriptURL = stringToPrecomputedChunk(escapeTextForBrowser( // eslint-disable-next-line no-script-url
+"javascript:throw new Error('A React form was unexpectedly submitted.')"));
+const startHiddenInputChunk = stringToPrecomputedChunk('<input type="hidden"');
+
+function pushAdditionalFormField(value, key) {
+  const target = this;
+  target.push(startHiddenInputChunk);
+
+  if (typeof value !== 'string') {
+    throw new Error('File/Blob fields are not yet supported in progressive forms. ' + 'It probably means you are closing over binary data or FormData in a Server Action.');
+  }
+
+  pushStringAttribute(target, 'name', key);
+  pushStringAttribute(target, 'value', value);
+  target.push(endOfStartTagSelfClosing);
+}
+
+function pushAdditionalFormFields(target, formData) {
+  if (formData !== null) {
+    // $FlowFixMe[prop-missing]: FormData has forEach.
+    formData.forEach(pushAdditionalFormField, target);
+  }
+}
+
+function pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name) {
+  let formData = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      name = customFields.name;
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('formAction'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      name = null;
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (name != null) {
+    pushAttribute(target, 'name', name);
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'formAction', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'formEncType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'formMethod', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'formTarget', formTarget);
+  }
+
+  return formData;
+}
+
+function pushAttribute(target, name, value) // not null or undefined
+{
+  switch (name) {
+    // These are very common props and therefore are in the beginning of the switch.
+    // TODO: aria-label is a very common prop but allows booleans so is not like the others
+    // but should ideally go in this list too.
+    case 'className':
+      {
+        pushStringAttribute(target, 'class', value);
+        break;
+      }
+
+    case 'tabIndex':
+      {
+        pushStringAttribute(target, 'tabindex', value);
+        break;
+      }
+
+    case 'dir':
+    case 'role':
+    case 'viewBox':
+    case 'width':
+    case 'height':
+      {
+        pushStringAttribute(target, name, value);
+        break;
+      }
+
+    case 'style':
+      {
+        pushStyleAttribute(target, value);
+        return;
+      }
+
+    case 'src':
+    case 'href':
+    // Fall through to the last case which shouldn't remove empty strings.
+
+    case 'action':
+    case 'formAction':
+      {
+        // TODO: Consider only special casing these for each tag.
+        if (value == null || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'defaultValue':
+    case 'defaultChecked': // These shouldn't be set as attributes on generic HTML elements.
+
+    case 'innerHTML': // Must use dangerouslySetInnerHTML instead.
+
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+      // Ignored. These are built-in to React on the client.
+      return;
+
+    case 'autoFocus':
+    case 'multiple':
+    case 'muted':
+      {
+        pushBooleanAttribute(target, name.toLowerCase(), value);
+        return;
+      }
+
+    case 'xlinkHref':
+      {
+        if (typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk('xlink:href'), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'contentEditable':
+    case 'spellCheck':
+    case 'draggable':
+    case 'value':
+    case 'autoReverse':
+    case 'externalResourcesRequired':
+    case 'focusable':
+    case 'preserveAlpha':
+      {
+        // Booleanish String
+        // These are "enumerated" attributes that accept "true" and "false".
+        // In React, we let users pass `true` and `false` even though technically
+        // these aren't boolean attributes (they are coerced to strings).
+        if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'allowFullScreen':
+    case 'async':
+    case 'autoPlay':
+    case 'controls':
+    case 'default':
+    case 'defer':
+    case 'disabled':
+    case 'disablePictureInPicture':
+    case 'disableRemotePlayback':
+    case 'formNoValidate':
+    case 'hidden':
+    case 'loop':
+    case 'noModule':
+    case 'noValidate':
+    case 'open':
+    case 'playsInline':
+    case 'readOnly':
+    case 'required':
+    case 'reversed':
+    case 'scoped':
+    case 'seamless':
+    case 'itemScope':
+      {
+        // Boolean
+        if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        }
+
+        return;
+      }
+
+    case 'capture':
+    case 'download':
+      {
+        // Overloaded Boolean
+        if (value === true) {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        } else if (value === false) ; else if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'cols':
+    case 'rows':
+    case 'size':
+    case 'span':
+      {
+        // These are HTML attributes that must be positive numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value) && value >= 1) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'rowSpan':
+    case 'start':
+      {
+        // These are HTML attributes that must be numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value)) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'xlinkActuate':
+      pushStringAttribute(target, 'xlink:actuate', value);
+      return;
+
+    case 'xlinkArcrole':
+      pushStringAttribute(target, 'xlink:arcrole', value);
+      return;
+
+    case 'xlinkRole':
+      pushStringAttribute(target, 'xlink:role', value);
+      return;
+
+    case 'xlinkShow':
+      pushStringAttribute(target, 'xlink:show', value);
+      return;
+
+    case 'xlinkTitle':
+      pushStringAttribute(target, 'xlink:title', value);
+      return;
+
+    case 'xlinkType':
+      pushStringAttribute(target, 'xlink:type', value);
+      return;
+
+    case 'xmlBase':
+      pushStringAttribute(target, 'xml:base', value);
+      return;
+
+    case 'xmlLang':
+      pushStringAttribute(target, 'xml:lang', value);
+      return;
+
+    case 'xmlSpace':
+      pushStringAttribute(target, 'xml:space', value);
+      return;
+
+    default:
+      if ( // shouldIgnoreAttribute
+      // We have already filtered out null/undefined and reserved words.
+      name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+        return;
+      }
+
+      const attributeName = getAttributeAlias(name);
+
+      if (isAttributeNameSafe(attributeName)) {
+        // shouldRemoveAttribute
+        switch (typeof value) {
+          case 'function':
+          case 'symbol':
+            // eslint-disable-line
+            return;
+
+          case 'boolean':
+            {
+              const prefix = attributeName.toLowerCase().slice(0, 5);
+
+              if (prefix !== 'data-' && prefix !== 'aria-') {
+                return;
+              }
+            }
+        }
+
+        target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+      }
+
+  }
+}
+
+const endOfStartTag = stringToPrecomputedChunk('>');
+const endOfStartTagSelfClosing = stringToPrecomputedChunk('/>');
+
+function pushInnerHTML(target, innerHTML, children) {
+  if (innerHTML != null) {
+    if (children != null) {
+      throw new Error('Can only set one of `children` or `props.dangerouslySetInnerHTML`.');
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw new Error('`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. ' + 'Please visit https://reactjs.org/link/dangerously-set-inner-html ' + 'for more information.');
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+
+      target.push(stringToChunk('' + html));
+    }
+  }
+} // TODO: Move these to RenderState so that we warn for every request.
+
+function pushStartSelect(target, props) {
+
+  target.push(startChunkForTag('select'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          // TODO: This doesn't really make sense for select since it can't use the controlled
+          // value in the innerHTML.
+          innerHTML = propValue;
+          break;
+
+        case 'defaultValue':
+        case 'value':
+          // These are set on the Context instead and applied to the nested options.
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+function flattenOptionChildren(children) {
+  let content = ''; // Flatten children and warn if they aren't strings or numbers;
+  // invalid types are ignored.
+
+  React.Children.forEach(children, function (child) {
+    if (child == null) {
+      return;
+    }
+
+    content += child;
+  });
+  return content;
+}
+
+const selectedMarkerAttribute = stringToPrecomputedChunk(' selected=""');
+
+function pushStartOption(target, props, formatContext) {
+  const selectedValue = formatContext.selectedValue;
+  target.push(startChunkForTag('option'));
+  let children = null;
+  let value = null;
+  let selected = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'selected':
+          // ignore
+          selected = propValue;
+
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+        // We intentionally fallthrough to also set the attribute on the node.
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (selectedValue != null) {
+    let stringValue;
+
+    if (value !== null) {
+
+      stringValue = '' + value;
+    } else {
+
+      stringValue = flattenOptionChildren(children);
+    }
+
+    if (isArray(selectedValue)) {
+      // multiple
+      for (let i = 0; i < selectedValue.length; i++) {
+
+        const v = '' + selectedValue[i];
+
+        if (v === stringValue) {
+          target.push(selectedMarkerAttribute);
+          break;
+        }
+      }
+    } else {
+
+      if ('' + selectedValue === stringValue) {
+        target.push(selectedMarkerAttribute);
+      }
+    }
+  } else if (selected) {
+    target.push(selectedMarkerAttribute);
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const formReplayingRuntimeScript = stringToPrecomputedChunk(formReplaying);
+
+function injectFormReplayingRuntime(resumableState, renderState) {
+  // If we haven't sent it yet, inject the runtime that tracks submitted JS actions
+  // for later replaying by Fiber. If we use an external runtime, we don't need
+  // to emit anything. It's always used.
+  if ((resumableState.instructions & SentFormReplayingRuntime) === NothingSent && (!renderState.externalRuntimeScript)) {
+    resumableState.instructions |= SentFormReplayingRuntime;
+    renderState.bootstrapChunks.unshift(renderState.startInlineScript, formReplayingRuntimeScript, endInlineScript);
+  }
+}
+
+const formStateMarkerIsMatching = stringToPrecomputedChunk('<!--F!-->');
+const formStateMarkerIsNotMatching = stringToPrecomputedChunk('<!--F-->');
+function pushFormStateMarkerIsMatching(target) {
+  target.push(formStateMarkerIsMatching);
+}
+function pushFormStateMarkerIsNotMatching(target) {
+  target.push(formStateMarkerIsNotMatching);
+}
+
+function pushStartForm(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('form'));
+  let children = null;
+  let innerHTML = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'action':
+          formAction = propValue;
+          break;
+
+        case 'encType':
+          formEncType = propValue;
+          break;
+
+        case 'method':
+          formMethod = propValue;
+          break;
+
+        case 'target':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  let formData = null;
+  let formActionName = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+      formActionName = customFields.name;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('action'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'action', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'encType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'method', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'target', formTarget);
+  }
+
+  target.push(endOfStartTag);
+
+  if (formActionName !== null) {
+    target.push(startHiddenInputChunk);
+    pushStringAttribute(target, 'name', formActionName);
+    target.push(endOfStartTagSelfClosing);
+    pushAdditionalFormFields(target, formData);
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushInput(target, props, resumableState, renderState) {
+
+  target.push(startChunkForTag('input'));
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+  let value = null;
+  let defaultValue = null;
+  let checked = null;
+  let defaultChecked = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('input' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        case 'defaultChecked':
+          defaultChecked = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'checked':
+          checked = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+
+  if (checked !== null) {
+    pushBooleanAttribute(target, 'checked', checked);
+  } else if (defaultChecked !== null) {
+    pushBooleanAttribute(target, 'checked', defaultChecked);
+  }
+
+  if (value !== null) {
+    pushAttribute(target, 'value', value);
+  } else if (defaultValue !== null) {
+    pushAttribute(target, 'value', defaultValue);
+  }
+
+  target.push(endOfStartTagSelfClosing); // We place any additional hidden form fields after the input.
+
+  pushAdditionalFormFields(target, formData);
+  return null;
+}
+
+function pushStartButton(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('button'));
+  let children = null;
+  let innerHTML = null;
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+  target.push(endOfStartTag); // We place any additional hidden form fields we need to include inside the button itself.
+
+  pushAdditionalFormFields(target, formData);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartTextArea(target, props) {
+
+  target.push(startChunkForTag('textarea'));
+  let value = null;
+  let defaultValue = null;
+  let children = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          throw new Error('`dangerouslySetInnerHTML` does not make sense on <textarea>.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (value === null && defaultValue !== null) {
+    value = defaultValue;
+  }
+
+  target.push(endOfStartTag); // TODO (yungsters): Remove support for children content in <textarea>.
+
+  if (children != null) {
+
+    if (value != null) {
+      throw new Error('If you supply `defaultValue` on a <textarea>, do not pass children.');
+    }
+
+    if (isArray(children)) {
+      if (children.length > 1) {
+        throw new Error('<textarea> can only have at most one child.');
+      } // TODO: remove the coercion and the DEV check below because it will
+
+      value = '' + children[0];
+    }
+
+    value = '' + children;
+  }
+
+  if (typeof value === 'string' && value[0] === '\n') {
+    // text/html ignores the first character in these tags if it's a newline
+    // Prefer to break application/xml over text/html (for now) by adding
+    // a newline specifically to get eaten by the parser. (Alternately for
+    // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+    // \r is normalized out by HTMLTextAreaElement#value.)
+    // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+    // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+    // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+    // See: Parsing of "textarea" "listing" and "pre" elements
+    //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+    target.push(leadingNewline);
+  } // ToString and push directly instead of recurse over children.
+  // We don't really support complex children in the value anyway.
+  // This also currently avoids a trailing comment node which breaks textarea.
+
+
+  if (value !== null) {
+
+    target.push(stringToChunk(encodeHTMLTextNode('' + value)));
+  }
+
+  return null;
+}
+
+function pushMeta(target, props, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      return pushSelfClosing(target, props, 'meta');
+    } else {
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      if (typeof props.charSet === 'string') {
+        return pushSelfClosing(renderState.charsetChunks, props, 'meta');
+      } else if (props.name === 'viewport') {
+        // "viewport" isn't related to preconnect but it has the right priority
+        return pushSelfClosing(renderState.preconnectChunks, props, 'meta');
+      } else {
+        return pushSelfClosing(renderState.hoistableChunks, props, 'meta');
+      }
+    }
+  }
+}
+
+function pushLink(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const rel = props.rel;
+    const href = props.href;
+    const precedence = props.precedence;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof rel !== 'string' || typeof href !== 'string' || href === '') {
+
+      pushLinkImpl(target, props);
+      return null;
+    }
+
+    if (props.rel === 'stylesheet') {
+      // This <link> may hoistable as a Stylesheet Resource, otherwise it will emit in place
+      const key = getResourceKey(href);
+
+      if (typeof precedence !== 'string' || props.disabled != null || props.onLoad || props.onError) {
+
+        return pushLinkImpl(target, props);
+      } else {
+        // This stylesheet refers to a Resource and we create a new one if necessary
+        let styleQueue = renderState.styles.get(precedence);
+        const hasKey = resumableState.styleResources.hasOwnProperty(key);
+        const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+        if (resourceState !== EXISTS) {
+          // We are going to create this resource now so it is marked as Exists
+          resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+          // to create a StyleQueue
+
+          if (!styleQueue) {
+            styleQueue = {
+              precedence: stringToChunk(escapeTextForBrowser(precedence)),
+              rules: [],
+              hrefs: [],
+              sheets: new Map()
+            };
+            renderState.styles.set(precedence, styleQueue);
+          }
+
+          const resource = {
+            state: PENDING$1,
+            props: stylesheetPropsFromRawProps(props)
+          };
+
+          if (resourceState) {
+            // When resourceState is truty it is a Preload state. We cast it for clarity
+            const preloadState = resourceState;
+
+            if (preloadState.length === 2) {
+              adoptPreloadCredentials(resource.props, preloadState);
+            }
+
+            const preloadResource = renderState.preloads.stylesheets.get(key);
+
+            if (preloadResource && preloadResource.length > 0) {
+              // The Preload for this resource was created in this render pass and has not flushed yet so
+              // we need to clear it to avoid it flushing.
+              preloadResource.length = 0;
+            } else {
+              // Either the preload resource from this render already flushed in this render pass
+              // or the preload flushed in a prior pass (prerender). In either case we need to mark
+              // this resource as already having been preloaded.
+              resource.state = PRELOADED;
+            }
+          } // We add the newly created resource to our StyleQueue and if necessary
+          // track the resource with the currently rendering boundary
+
+
+          styleQueue.sheets.set(key, resource);
+
+          if (renderState.boundaryResources) {
+            renderState.boundaryResources.stylesheets.add(resource);
+          }
+        } else {
+          // We need to track whether this boundary should wait on this resource or not.
+          // Typically this resource should always exist since we either had it or just created
+          // it. However, it's possible when you resume that the style has already been emitted
+          // and then it wouldn't be recreated in the RenderState and there's no need to track
+          // it again since we should've hoisted it to the shell already.
+          if (styleQueue) {
+            const resource = styleQueue.sheets.get(key);
+
+            if (resource) {
+              if (renderState.boundaryResources) {
+                renderState.boundaryResources.stylesheets.add(resource);
+              }
+            }
+          }
+        }
+
+        if (textEmbedded) {
+          // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+          // to be safe and assume text will follow by inserting a textSeparator
+          target.push(textSeparator);
+        }
+
+        return null;
+      }
+    } else if (props.onLoad || props.onError) {
+      // When using load handlers we cannot hoist and need to emit links in place
+      return pushLinkImpl(target, props);
+    } else {
+      // We can hoist this link so we may need to emit a text separator.
+      // @TODO refactor text separators so we don't have to defensively add
+      // them when we don't end up emitting a tag as a result of pushStartInstance
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      switch (props.rel) {
+        case 'preconnect':
+        case 'dns-prefetch':
+          return pushLinkImpl(renderState.preconnectChunks, props);
+
+        case 'preload':
+          return pushLinkImpl(renderState.preloadChunks, props);
+
+        default:
+          return pushLinkImpl(renderState.hoistableChunks, props);
+      }
+    }
+  }
+}
+
+function pushLinkImpl(target, props) {
+  target.push(startChunkForTag('link'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStyle(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+
+  {
+    const precedence = props.precedence;
+    const href = props.href;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof precedence !== 'string' || typeof href !== 'string' || href === '') {
+      // This style tag is not able to be turned into a Style Resource
+      return pushStyleImpl(target, props);
+    }
+
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS;
+
+      if (!styleQueue) {
+        // This is the first time we've encountered this precedence we need
+        // to create a StyleQueue.
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [stringToChunk(escapeTextForBrowser(href))],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      } else {
+        // We have seen this precedence before and need to track this href
+        styleQueue.hrefs.push(stringToChunk(escapeTextForBrowser(href)));
+      }
+
+      pushStyleContents(styleQueue.rules, props);
+    }
+
+    if (styleQueue) {
+      // We need to track whether this boundary should wait on this resource or not.
+      // Typically this resource should always exist since we either had it or just created
+      // it. However, it's possible when you resume that the style has already been emitted
+      // and then it wouldn't be recreated in the RenderState and there's no need to track
+      // it again since we should've hoisted it to the shell already.
+      if (renderState.boundaryResources) {
+        renderState.boundaryResources.styles.add(styleQueue);
+      }
+    }
+
+    if (textEmbedded) {
+      // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+  }
+}
+
+function pushStyleImpl(target, props) {
+  target.push(startChunkForTag('style'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('style'));
+  return null;
+}
+
+function pushStyleContents(target, props) {
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+      }
+    }
+  }
+
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  return;
+}
+
+function pushImg(target, props, resumableState, renderState, pictureTagInScope) {
+  const src = props.src,
+        srcSet = props.srcSet;
+
+  if (props.loading !== 'lazy' && (src || srcSet) && (typeof src === 'string' || src == null) && (typeof srcSet === 'string' || srcSet == null) && props.fetchPriority !== 'low' && pictureTagInScope === false && // We exclude data URIs in src and srcSet since these should not be preloaded
+  !(typeof src === 'string' && src[4] === ':' && (src[0] === 'd' || src[0] === 'D') && (src[1] === 'a' || src[1] === 'A') && (src[2] === 't' || src[2] === 'T') && (src[3] === 'a' || src[3] === 'A')) && !(typeof srcSet === 'string' && srcSet[4] === ':' && (srcSet[0] === 'd' || srcSet[0] === 'D') && (srcSet[1] === 'a' || srcSet[1] === 'A') && (srcSet[2] === 't' || srcSet[2] === 'T') && (srcSet[3] === 'a' || srcSet[3] === 'A'))) {
+    // We have a suspensey image and ought to preload it to optimize the loading of display blocking
+    // resumableState.
+    const sizes = typeof props.sizes === 'string' ? props.sizes : undefined;
+    const key = getImageResourceKey(src, srcSet, sizes);
+    const promotablePreloads = renderState.preloads.images;
+    let resource = promotablePreloads.get(key);
+
+    if (resource) {
+      // We consider whether this preload can be promoted to higher priority flushing queue.
+      // The only time a resource will exist here is if it was created during this render
+      // and was not already in the high priority queue.
+      if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+        // Delete the resource from the map since we are promoting it and don't want to
+        // reenter this branch in a second pass for duplicate img hrefs.
+        promotablePreloads.delete(key); // $FlowFixMe - Flow should understand that this is a Resource if the condition was true
+
+        renderState.highImagePreloads.add(resource);
+      }
+    } else if (!resumableState.imageResources.hasOwnProperty(key)) {
+      // We must construct a new preload resource
+      resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+      const crossOrigin = getCrossOriginString(props.crossOrigin);
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // this is a hueristic similar to capping element preloads to 10 unless explicitly
+      // fetchPriority="high". We use length here which means it will fit fewer images when
+      // the urls are long and more when short. arguably byte size is a better hueristic because
+      // it directly translates to how much we send down before content is actually seen.
+      // We could unify the counts and also make it so the total is tracked regardless of
+      // flushing output but since the headers are likely to be go earlier than content
+      // they don't really conflict so for now I've kept them separate
+      props.fetchPriority === 'high' || headers.highImagePreloads.length < 500) && ( // We manually construct the options for the preload only from strings. We don't want to pollute
+      // the params list with arbitrary props and if we copied everything over as it we might get
+      // coercion errors. We have checks for this in Dev but it seems safer to just only accept values
+      // that are strings
+      header = getPreloadAsHeader(src, 'image', {
+        imageSrcSet: props.srcSet,
+        imageSizes: props.sizes,
+        crossOrigin,
+        integrity: props.integrity,
+        nonce: props.nonce,
+        type: props.type,
+        fetchPriority: props.fetchPriority,
+        referrerPolicy: props.refererPolicy
+      }), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // If we postpone in the shell we will still emit this preload so we track
+        // it to make sure we don't reset it.
+        renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+        if (headers.highImagePreloads) {
+          headers.highImagePreloads += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.highImagePreloads += header;
+      } else {
+        resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preload',
+          as: 'image',
+          // There is a bug in Safari where imageSrcSet is not respected on preload links
+          // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+          // This harms older browers that do not support imageSrcSet by making their preloads not work
+          // but this population is shrinking fast and is already small so we accept this tradeoff.
+          href: srcSet ? undefined : src,
+          imageSrcSet: srcSet,
+          imageSizes: sizes,
+          crossOrigin: crossOrigin,
+          integrity: props.integrity,
+          type: props.type,
+          fetchPriority: props.fetchPriority,
+          referrerPolicy: props.referrerPolicy
+        });
+
+        if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+          renderState.highImagePreloads.add(resource);
+        } else {
+          renderState.bulkPreloads.add(resource); // We can bump the priority up if the same img is rendered later
+          // with fetchPriority="high"
+
+          promotablePreloads.set(key, resource);
+        }
+      }
+    }
+  }
+
+  return pushSelfClosing(target, props, 'img');
+}
+
+function pushSelfClosing(target, props, tag) {
+  target.push(startChunkForTag(tag));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error(tag + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStartMenuItem(target, props) {
+  target.push(startChunkForTag('menuitem'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('menuitems cannot have `children` nor `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  return null;
+}
+
+function pushTitle(target, props, renderState, insertionMode, noscriptTagInScope) {
+
+  {
+    if (insertionMode !== SVG_MODE && !noscriptTagInScope && props.itemProp == null) {
+      pushTitleImpl(renderState.hoistableChunks, props);
+      return null;
+    } else {
+      return pushTitleImpl(target, props);
+    }
+  }
+}
+
+function pushTitleImpl(target, props) {
+  target.push(startChunkForTag('title'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('title'));
+  return null;
+}
+
+function pushStartHead(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode < HTML_MODE && renderState.headChunks === null) {
+      // This <head> is the Document.head and should be part of the preamble
+      renderState.headChunks = [];
+      return pushStartGenericElement(renderState.headChunks, props, 'head');
+    } else {
+      // This <head> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'head');
+    }
+  }
+}
+
+function pushStartHtml(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode === ROOT_HTML_MODE && renderState.htmlChunks === null) {
+      // This <html> is the Document.documentElement and should be part of the preamble
+      renderState.htmlChunks = [doctypeChunk];
+      return pushStartGenericElement(renderState.htmlChunks, props, 'html');
+    } else {
+      // This <html> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'html');
+    }
+  }
+}
+
+function pushScript(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const asyncProp = props.async;
+
+    if (typeof props.src !== 'string' || !props.src || !(asyncProp && typeof asyncProp !== 'function' && typeof asyncProp !== 'symbol') || props.onLoad || props.onError || insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      // This script will not be a resource, we bailout early and emit it in place.
+      return pushScriptImpl(target, props);
+    }
+
+    const src = props.src;
+    const key = getResourceKey(src); // We can make this <script> into a ScriptResource
+
+    let resources, preloads;
+
+    if (props.type === 'module') {
+      resources = resumableState.moduleScriptResources;
+      preloads = renderState.preloads.moduleScripts;
+    } else {
+      resources = resumableState.scriptResources;
+      preloads = renderState.preloads.scripts;
+    }
+
+    const hasKey = resources.hasOwnProperty(key);
+    const resourceState = hasKey ? resources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resources[key] = EXISTS;
+      let scriptProps = props;
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          scriptProps = assign({}, props);
+          adoptPreloadCredentials(scriptProps, preloadState);
+        }
+
+        const preloadResource = preloads.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, scriptProps);
+    }
+
+    if (textEmbedded) {
+      // This script follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+
+    return null;
+  }
+}
+
+function pushScriptImpl(target, props) {
+  target.push(startChunkForTag('script'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+  }
+
+  target.push(endChunkForTag('script'));
+  return null;
+}
+
+function pushStartGenericElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartCustomElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      let propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      let attributeName = propKey;
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'style':
+          pushStyleAttribute(target, propValue);
+          break;
+
+        case 'suppressContentEditableWarning':
+        case 'suppressHydrationWarning':
+          // Ignored. These are built-in to React on the client.
+          break;
+
+        case 'className':
+
+        // intentional fallthrough
+
+        default:
+          if (isAttributeNameSafe(propKey) && typeof propValue !== 'function' && typeof propValue !== 'symbol') {
+
+            target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(propValue)), attributeEnd);
+          }
+
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const leadingNewline = stringToPrecomputedChunk('\n');
+
+function pushStartPreformattedElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag); // text/html ignores the first character in these tags if it's a newline
+  // Prefer to break application/xml over text/html (for now) by adding
+  // a newline specifically to get eaten by the parser. (Alternately for
+  // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+  // \r is normalized out by HTMLTextAreaElement#value.)
+  // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+  // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+  // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+  // See: Parsing of "textarea" "listing" and "pre" elements
+  //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+  // TODO: This doesn't deal with the case where the child is an array
+  // or component that returns a string.
+
+  if (innerHTML != null) {
+    if (children != null) {
+      throw new Error('Can only set one of `children` or `props.dangerouslySetInnerHTML`.');
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw new Error('`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. ' + 'Please visit https://reactjs.org/link/dangerously-set-inner-html ' + 'for more information.');
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+      if (typeof html === 'string' && html.length > 0 && html[0] === '\n') {
+        target.push(leadingNewline, stringToChunk(html));
+      } else {
+
+        target.push(stringToChunk('' + html));
+      }
+    }
+  }
+
+  if (typeof children === 'string' && children[0] === '\n') {
+    target.push(leadingNewline);
+  }
+
+  return children;
+} // We accept any tag to be rendered but since this gets injected into arbitrary
+// HTML, we want to make sure that it's a safe tag.
+// http://www.w3.org/TR/REC-xml/#NT-Name
+
+
+const VALID_TAG_REGEX = /^[a-zA-Z][a-zA-Z:_\.\-\d]*$/; // Simplified subset
+
+const validatedTagCache = new Map();
+
+function startChunkForTag(tag) {
+  let tagStartChunk = validatedTagCache.get(tag);
+
+  if (tagStartChunk === undefined) {
+    if (!VALID_TAG_REGEX.test(tag)) {
+      throw new Error("Invalid tag: " + tag);
+    }
+
+    tagStartChunk = stringToPrecomputedChunk('<' + tag);
+    validatedTagCache.set(tag, tagStartChunk);
+  }
+
+  return tagStartChunk;
+}
+function pushStartInstance(target, type, props, resumableState, renderState, formatContext, textEmbedded) {
+
+  switch (type) {
+    case 'div':
+    case 'span':
+    case 'svg':
+    case 'path':
+    case 'a':
+    case 'g':
+    case 'p':
+    case 'li':
+      // Fast track very common tags
+      break;
+    // Special tags
+
+    case 'select':
+      return pushStartSelect(target, props);
+
+    case 'option':
+      return pushStartOption(target, props, formatContext);
+
+    case 'textarea':
+      return pushStartTextArea(target, props);
+
+    case 'input':
+      return pushInput(target, props, resumableState, renderState);
+
+    case 'button':
+      return pushStartButton(target, props, resumableState, renderState);
+
+    case 'form':
+      return pushStartForm(target, props, resumableState, renderState);
+
+    case 'menuitem':
+      return pushStartMenuItem(target, props);
+
+    case 'title':
+      return pushTitle(target, props, renderState, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'link':
+      return pushLink(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'script':
+      return pushScript(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'style':
+      return pushStyle(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'meta':
+      return pushMeta(target, props, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+    // Newline eating tags
+
+    case 'listing':
+    case 'pre':
+      {
+        return pushStartPreformattedElement(target, props, type);
+      }
+
+    case 'img':
+      {
+        return pushImg(target, props, resumableState, renderState, !!(formatContext.tagScope & PICTURE_SCOPE)) ;
+      }
+    // Omitted close tags
+
+    case 'base':
+    case 'area':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'keygen':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        return pushSelfClosing(target, props, type);
+      }
+    // These are reserved SVG and MathML elements, that are never custom elements.
+    // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+
+    case 'annotation-xml':
+    case 'color-profile':
+    case 'font-face':
+    case 'font-face-src':
+    case 'font-face-uri':
+    case 'font-face-format':
+    case 'font-face-name':
+    case 'missing-glyph':
+      {
+        break;
+      }
+    // Preamble start tags
+
+    case 'head':
+      return pushStartHead(target, props, renderState, formatContext.insertionMode);
+
+    case 'html':
+      {
+        return pushStartHtml(target, props, renderState, formatContext.insertionMode);
+      }
+
+    default:
+      {
+        if (type.indexOf('-') !== -1) {
+          // Custom element
+          return pushStartCustomElement(target, props, type);
+        }
+      }
+  } // Generic element
+
+
+  return pushStartGenericElement(target, props, type);
+}
+const endTagCache = new Map();
+
+function endChunkForTag(tag) {
+  let chunk = endTagCache.get(tag);
+
+  if (chunk === undefined) {
+    chunk = stringToPrecomputedChunk('</' + tag + '>');
+    endTagCache.set(tag, chunk);
+  }
+
+  return chunk;
+}
+
+function pushEndInstance(target, type, props, resumableState, formatContext) {
+  switch (type) {
+    // When float is on we expect title and script tags to always be pushed in
+    // a unit and never return children. when we end up pushing the end tag we
+    // want to ensure there is no extra closing tag pushed
+    case 'title':
+    case 'style':
+    case 'script':
+    // Omitted close tags
+    // TODO: Instead of repeating this switch we could try to pass a flag from above.
+    // That would require returning a tuple. Which might be ok if it gets inlined.
+
+    case 'area':
+    case 'base':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'img':
+    case 'input':
+    case 'keygen':
+    case 'link':
+    case 'meta':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        // No close tag needed.
+        return;
+      }
+    // Postamble end tags
+    // When float is enabled we omit the end tags for body and html when
+    // they represent the Document.body and Document.documentElement Nodes.
+    // This is so we can withhold them until the postamble when we know
+    // we won't emit any more tags
+
+    case 'body':
+      {
+        if (formatContext.insertionMode <= HTML_HTML_MODE) {
+          resumableState.hasBody = true;
+          return;
+        }
+
+        break;
+      }
+
+    case 'html':
+      if (formatContext.insertionMode === ROOT_HTML_MODE) {
+        resumableState.hasHtml = true;
+        return;
+      }
+
+      break;
+  }
+
+  target.push(endChunkForTag(type));
+}
+
+function writeBootstrap(destination, renderState, resumableState) {
+  resumableState.bootstrapScriptContent = undefined;
+  resumableState.bootstrapScripts = undefined;
+  resumableState.bootstrapModules = undefined;
+  const bootstrapChunks = renderState.bootstrapChunks;
+  let i = 0;
+
+  for (; i < bootstrapChunks.length - 1; i++) {
+    writeChunk(destination, bootstrapChunks[i]);
+  }
+
+  if (i < bootstrapChunks.length) {
+    const lastChunk = bootstrapChunks[i];
+    bootstrapChunks.length = 0;
+    return writeChunkAndReturn(destination, lastChunk);
+  }
+
+  return true;
+}
+
+function writeCompletedRoot(destination, renderState, resumableState) {
+  return writeBootstrap(destination, renderState, resumableState);
+} // Structural Nodes
+// A placeholder is a node inside a hidden partial tree that can be filled in later, but before
+// display. It's never visible to users. We use the template tag because it can be used in every
+// type of parent. <script> tags also work in every other tag except <colgroup>.
+
+const placeholder1 = stringToPrecomputedChunk('<template id="');
+const placeholder2 = stringToPrecomputedChunk('"></template>');
+function writePlaceholder(destination, renderState, id) {
+  writeChunk(destination, placeholder1);
+  writeChunk(destination, renderState.placeholderPrefix);
+  const formattedID = stringToChunk(id.toString(16));
+  writeChunk(destination, formattedID);
+  return writeChunkAndReturn(destination, placeholder2);
+} // Suspense boundaries are encoded as comments.
+
+const startCompletedSuspenseBoundary = stringToPrecomputedChunk('<!--$-->');
+const startPendingSuspenseBoundary1 = stringToPrecomputedChunk('<!--$?--><template id="');
+const startPendingSuspenseBoundary2 = stringToPrecomputedChunk('"></template>');
+const startClientRenderedSuspenseBoundary = stringToPrecomputedChunk('<!--$!-->');
+const endSuspenseBoundary = stringToPrecomputedChunk('<!--/$-->');
+const clientRenderedSuspenseBoundaryError1 = stringToPrecomputedChunk('<template');
+const clientRenderedSuspenseBoundaryErrorAttrInterstitial = stringToPrecomputedChunk('"');
+const clientRenderedSuspenseBoundaryError1A = stringToPrecomputedChunk(' data-dgst="');
+const clientRenderedSuspenseBoundaryError2 = stringToPrecomputedChunk('></template>');
+function writeStartCompletedSuspenseBoundary$1(destination, renderState) {
+  return writeChunkAndReturn(destination, startCompletedSuspenseBoundary);
+}
+function writeStartPendingSuspenseBoundary(destination, renderState, id) {
+  writeChunk(destination, startPendingSuspenseBoundary1);
+
+  if (id === null) {
+    throw new Error('An ID must have been assigned before we can complete the boundary.');
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+  return writeChunkAndReturn(destination, startPendingSuspenseBoundary2);
+}
+function writeStartClientRenderedSuspenseBoundary$1(destination, renderState, errorDigest, errorMesssage, errorComponentStack) {
+  let result;
+  result = writeChunkAndReturn(destination, startClientRenderedSuspenseBoundary);
+  writeChunk(destination, clientRenderedSuspenseBoundaryError1);
+
+  if (errorDigest) {
+    writeChunk(destination, clientRenderedSuspenseBoundaryError1A);
+    writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest)));
+    writeChunk(destination, clientRenderedSuspenseBoundaryErrorAttrInterstitial);
+  }
+
+  result = writeChunkAndReturn(destination, clientRenderedSuspenseBoundaryError2);
+  return result;
+}
+function writeEndCompletedSuspenseBoundary$1(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndPendingSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndClientRenderedSuspenseBoundary$1(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+const startSegmentHTML = stringToPrecomputedChunk('<div hidden id="');
+const startSegmentHTML2 = stringToPrecomputedChunk('">');
+const endSegmentHTML = stringToPrecomputedChunk('</div>');
+const startSegmentSVG = stringToPrecomputedChunk('<svg aria-hidden="true" style="display:none" id="');
+const startSegmentSVG2 = stringToPrecomputedChunk('">');
+const endSegmentSVG = stringToPrecomputedChunk('</svg>');
+const startSegmentMathML = stringToPrecomputedChunk('<math aria-hidden="true" style="display:none" id="');
+const startSegmentMathML2 = stringToPrecomputedChunk('">');
+const endSegmentMathML = stringToPrecomputedChunk('</math>');
+const startSegmentTable = stringToPrecomputedChunk('<table hidden id="');
+const startSegmentTable2 = stringToPrecomputedChunk('">');
+const endSegmentTable = stringToPrecomputedChunk('</table>');
+const startSegmentTableBody = stringToPrecomputedChunk('<table hidden><tbody id="');
+const startSegmentTableBody2 = stringToPrecomputedChunk('">');
+const endSegmentTableBody = stringToPrecomputedChunk('</tbody></table>');
+const startSegmentTableRow = stringToPrecomputedChunk('<table hidden><tr id="');
+const startSegmentTableRow2 = stringToPrecomputedChunk('">');
+const endSegmentTableRow = stringToPrecomputedChunk('</tr></table>');
+const startSegmentColGroup = stringToPrecomputedChunk('<table hidden><colgroup id="');
+const startSegmentColGroup2 = stringToPrecomputedChunk('">');
+const endSegmentColGroup = stringToPrecomputedChunk('</colgroup></table>');
+function writeStartSegment(destination, renderState, formatContext, id) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        writeChunk(destination, startSegmentHTML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentHTML2);
+      }
+
+    case SVG_MODE:
+      {
+        writeChunk(destination, startSegmentSVG);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentSVG2);
+      }
+
+    case MATHML_MODE:
+      {
+        writeChunk(destination, startSegmentMathML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentMathML2);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        writeChunk(destination, startSegmentTable);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTable2);
+      }
+    // TODO: For the rest of these, there will be extra wrapper nodes that never
+    // get deleted from the document. We need to delete the table too as part
+    // of the injected scripts. They are invisible though so it's not too terrible
+    // and it's kind of an edge case to suspend in a table. Totally supported though.
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        writeChunk(destination, startSegmentTableBody);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableBody2);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        writeChunk(destination, startSegmentTableRow);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableRow2);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        writeChunk(destination, startSegmentColGroup);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentColGroup2);
+      }
+
+    default:
+      {
+        throw new Error('Unknown insertion mode. This is a bug in React.');
+      }
+  }
+}
+function writeEndSegment(destination, formatContext) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentHTML);
+      }
+
+    case SVG_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentSVG);
+      }
+
+    case MATHML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentMathML);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTable);
+      }
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableBody);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableRow);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentColGroup);
+      }
+
+    default:
+      {
+        throw new Error('Unknown insertion mode. This is a bug in React.');
+      }
+  }
+}
+const completeSegmentScript1Full = stringToPrecomputedChunk(completeSegment + '$RS("');
+const completeSegmentScript1Partial = stringToPrecomputedChunk('$RS("');
+const completeSegmentScript2 = stringToPrecomputedChunk('","');
+const completeSegmentScriptEnd = stringToPrecomputedChunk('")</script>');
+const completeSegmentData1 = stringToPrecomputedChunk('<template data-rsi="" data-sid="');
+const completeSegmentData2 = stringToPrecomputedChunk('" data-pid="');
+const completeSegmentDataEnd = dataElementQuotedEnd;
+function writeCompletedSegmentInstruction(destination, resumableState, renderState, contentSegmentID) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentCompleteSegmentFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentCompleteSegmentFunction;
+      writeChunk(destination, completeSegmentScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, completeSegmentScript1Partial);
+    }
+  } else {
+    writeChunk(destination, completeSegmentData1);
+  } // Write function arguments, which are string literals
+
+
+  writeChunk(destination, renderState.segmentPrefix);
+  const formattedID = stringToChunk(contentSegmentID.toString(16));
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    writeChunk(destination, completeSegmentScript2);
+  } else {
+    writeChunk(destination, completeSegmentData2);
+  }
+
+  writeChunk(destination, renderState.placeholderPrefix);
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    return writeChunkAndReturn(destination, completeSegmentScriptEnd);
+  } else {
+    return writeChunkAndReturn(destination, completeSegmentDataEnd);
+  }
+}
+const completeBoundaryScript1Full = stringToPrecomputedChunk(completeBoundary + '$RC("');
+const completeBoundaryScript1Partial = stringToPrecomputedChunk('$RC("');
+const completeBoundaryWithStylesScript1FullBoth = stringToPrecomputedChunk(completeBoundary + completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1FullPartial = stringToPrecomputedChunk(completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1Partial = stringToPrecomputedChunk('$RR("');
+const completeBoundaryScript2 = stringToPrecomputedChunk('","');
+const completeBoundaryScript3a = stringToPrecomputedChunk('",');
+const completeBoundaryScript3b = stringToPrecomputedChunk('"');
+const completeBoundaryScriptEnd = stringToPrecomputedChunk(')</script>');
+const completeBoundaryData1 = stringToPrecomputedChunk('<template data-rci="" data-bid="');
+const completeBoundaryWithStylesData1 = stringToPrecomputedChunk('<template data-rri="" data-bid="');
+const completeBoundaryData2 = stringToPrecomputedChunk('" data-sid="');
+const completeBoundaryData3a = stringToPrecomputedChunk('" data-sty="');
+const completeBoundaryDataEnd = dataElementQuotedEnd;
+function writeCompletedBoundaryInstruction(destination, resumableState, renderState, id, boundaryResources) {
+  let requiresStyleInsertion;
+
+  {
+    requiresStyleInsertion = renderState.stylesToHoist; // If necessary stylesheets will be flushed with this instruction.
+    // Any style tags not yet hoisted in the Document will also be hoisted.
+    // We reset this state since after this instruction executes all styles
+    // up to this point will have been hoisted
+
+    renderState.stylesToHoist = false;
+  }
+
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if (requiresStyleInsertion) {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction | SentCompleteBoundaryFunction;
+        writeChunk(destination, clonePrecomputedChunk(completeBoundaryWithStylesScript1FullBoth));
+      } else if ((resumableState.instructions & SentStyleInsertionFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction;
+        writeChunk(destination, completeBoundaryWithStylesScript1FullPartial);
+      } else {
+        writeChunk(destination, completeBoundaryWithStylesScript1Partial);
+      }
+    } else {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentCompleteBoundaryFunction;
+        writeChunk(destination, completeBoundaryScript1Full);
+      } else {
+        writeChunk(destination, completeBoundaryScript1Partial);
+      }
+    }
+  } else {
+    if (requiresStyleInsertion) {
+      writeChunk(destination, completeBoundaryWithStylesData1);
+    } else {
+      writeChunk(destination, completeBoundaryData1);
+    }
+  }
+
+  const idChunk = stringToChunk(id.toString(16));
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, idChunk); // Write function arguments, which are string and array literals
+
+  if (scriptFormat) {
+    writeChunk(destination, completeBoundaryScript2);
+  } else {
+    writeChunk(destination, completeBoundaryData2);
+  }
+
+  writeChunk(destination, renderState.segmentPrefix);
+  writeChunk(destination, idChunk);
+
+  if (requiresStyleInsertion) {
+    // Script and data writers must format this differently:
+    //  - script writer emits an array literal, whose string elements are
+    //    escaped for javascript  e.g. ["A", "B"]
+    //  - data writer emits a string literal, which is escaped as html
+    //    e.g. [&#34;A&#34;, &#34;B&#34;]
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3a); // boundaryResources encodes an array literal
+
+      writeStyleResourceDependenciesInJS(destination, boundaryResources);
+    } else {
+      writeChunk(destination, completeBoundaryData3a);
+      writeStyleResourceDependenciesInAttr(destination, boundaryResources);
+    }
+  } else {
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3b);
+    }
+  }
+
+  let writeMore;
+
+  if (scriptFormat) {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryScriptEnd);
+  } else {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryDataEnd);
+  }
+
+  return writeBootstrap(destination, renderState, resumableState) && writeMore;
+}
+const clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
+const clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
+const clientRenderScript1A = stringToPrecomputedChunk('"');
+const clientRenderErrorScriptArgInterstitial = stringToPrecomputedChunk(',');
+const clientRenderScriptEnd = stringToPrecomputedChunk(')</script>');
+const clientRenderData1 = stringToPrecomputedChunk('<template data-rxi="" data-bid="');
+const clientRenderData2 = stringToPrecomputedChunk('" data-dgst="');
+const clientRenderData3 = stringToPrecomputedChunk('" data-msg="');
+const clientRenderData4 = stringToPrecomputedChunk('" data-stck="');
+const clientRenderDataEnd = dataElementQuotedEnd;
+function writeClientRenderBoundaryInstruction(destination, resumableState, renderState, id, errorDigest, errorMessage, errorComponentStack) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentClientRenderFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentClientRenderFunction;
+      writeChunk(destination, clientRenderScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, clientRenderScript1Partial);
+    }
+  } else {
+    // <template data-rxi="" data-bid="
+    writeChunk(destination, clientRenderData1);
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+
+  if (scriptFormat) {
+    // " needs to be inserted for scripts, since ArgInterstitual does not contain
+    // leading or trailing quotes
+    writeChunk(destination, clientRenderScript1A);
+  }
+
+  if (errorDigest || errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorDigest || '')));
+    } else {
+      // " data-dgst="HTMLString
+      writeChunk(destination, clientRenderData2);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest || '')));
+    }
+  }
+
+  if (errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorMessage || '')));
+    } else {
+      // " data-msg="HTMLString
+      writeChunk(destination, clientRenderData3);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorMessage || '')));
+    }
+  }
+
+  if (errorComponentStack) {
+    // ,"JSONString"
+    if (scriptFormat) {
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorComponentStack)));
+    } else {
+      // " data-stck="HTMLString
+      writeChunk(destination, clientRenderData4);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorComponentStack)));
+    }
+  }
+
+  if (scriptFormat) {
+    // ></script>
+    return writeChunkAndReturn(destination, clientRenderScriptEnd);
+  } else {
+    // "></template>
+    return writeChunkAndReturn(destination, clientRenderDataEnd);
+  }
+}
+const regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
+
+function escapeJSStringsForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInInstructionScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const regexForJSStringsInScripts = /[&><\u2028\u2029]/g;
+
+function escapeJSObjectForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '&':
+        return '\\u0026';
+
+      case '>':
+        return '\\u003e';
+
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const lateStyleTagResourceOpen1 = stringToPrecomputedChunk('<style media="not all" data-precedence="');
+const lateStyleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const lateStyleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const lateStyleTagTemplateClose = stringToPrecomputedChunk('</style>'); // Tracks whether the boundary currently flushing is flushign style tags or has any
+// stylesheet dependencies not flushed in the Preamble.
+
+let currentlyRenderingBoundaryHasStylesToHoist = false; // Acts as a return value for the forEach execution of style tag flushing.
+
+let destinationHasCapacity = true;
+
+function flushStyleTagsLateForBoundary(styleQueue) {
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs;
+
+  let i = 0;
+
+  if (hrefs.length) {
+    writeChunk(this, lateStyleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    writeChunk(this, lateStyleTagResourceOpen2);
+
+    for (; i < hrefs.length - 1; i++) {
+      writeChunk(this, hrefs[i]);
+      writeChunk(this, spaceSeparator);
+    }
+
+    writeChunk(this, hrefs[i]);
+    writeChunk(this, lateStyleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    destinationHasCapacity = writeChunkAndReturn(this, lateStyleTagTemplateClose); // We wrote style tags for this boundary and we may need to emit a script
+    // to hoist them.
+
+    currentlyRenderingBoundaryHasStylesToHoist = true; // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function hasStylesToHoist(stylesheet) {
+  // We need to reveal boundaries with styles whenever a stylesheet it depends on is either
+  // not flushed or flushed after the preamble (shell).
+  if (stylesheet.state !== PREAMBLE) {
+    currentlyRenderingBoundaryHasStylesToHoist = true;
+    return true;
+  }
+
+  return false;
+}
+
+function writeResourcesForBoundary(destination, boundaryResources, renderState) {
+  // Reset these on each invocation, they are only safe to read in this function
+  currentlyRenderingBoundaryHasStylesToHoist = false;
+  destinationHasCapacity = true; // Flush style tags for each precedence this boundary depends on
+
+  boundaryResources.styles.forEach(flushStyleTagsLateForBoundary, destination); // Determine if this boundary has stylesheets that need to be awaited upon completion
+
+  boundaryResources.stylesheets.forEach(hasStylesToHoist);
+
+  if (currentlyRenderingBoundaryHasStylesToHoist) {
+    renderState.stylesToHoist = true;
+  }
+
+  return destinationHasCapacity;
+}
+
+function flushResource(resource) {
+  for (let i = 0; i < resource.length; i++) {
+    writeChunk(this, resource[i]);
+  }
+
+  resource.length = 0;
+}
+
+const stylesheetFlushingQueue = [];
+
+function flushStyleInPreamble(stylesheet, key, map) {
+  // We still need to encode stylesheet chunks
+  // because unlike most Hoistables and Resources we do not eagerly encode
+  // them during render. This is because if we flush late we have to send a
+  // different encoding and we don't want to encode multiple times
+  pushLinkImpl(stylesheetFlushingQueue, stylesheet.props);
+
+  for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+    writeChunk(this, stylesheetFlushingQueue[i]);
+  }
+
+  stylesheetFlushingQueue.length = 0;
+  stylesheet.state = PREAMBLE;
+}
+
+const styleTagResourceOpen1 = stringToPrecomputedChunk('<style data-precedence="');
+const styleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const spaceSeparator = stringToPrecomputedChunk(' ');
+const styleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const styleTagResourceClose = stringToPrecomputedChunk('</style>');
+
+function flushStylesInPreamble(styleQueue, precedence) {
+  const hasStylesheets = styleQueue.sheets.size > 0;
+  styleQueue.sheets.forEach(flushStyleInPreamble, this);
+  styleQueue.sheets.clear();
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs; // If we don't emit any stylesheets at this precedence we still need to maintain the precedence
+  // order so even if there are no rules for style tags at this precedence we emit an empty style
+  // tag with the data-precedence attribute
+
+  if (!hasStylesheets || hrefs.length) {
+    writeChunk(this, styleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    let i = 0;
+
+    if (hrefs.length) {
+      writeChunk(this, styleTagResourceOpen2);
+
+      for (; i < hrefs.length - 1; i++) {
+        writeChunk(this, hrefs[i]);
+        writeChunk(this, spaceSeparator);
+      }
+
+      writeChunk(this, hrefs[i]);
+    }
+
+    writeChunk(this, styleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    writeChunk(this, styleTagResourceClose); // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function preloadLateStyle(stylesheet) {
+  if (stylesheet.state === PENDING$1) {
+    stylesheet.state = PRELOADED;
+    const preloadProps = preloadAsStylePropsFromProps(stylesheet.props.href, stylesheet.props);
+    pushLinkImpl(stylesheetFlushingQueue, preloadProps);
+
+    for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+      writeChunk(this, stylesheetFlushingQueue[i]);
+    }
+
+    stylesheetFlushingQueue.length = 0;
+  }
+}
+
+function preloadLateStyles(styleQueue) {
+  styleQueue.sheets.forEach(preloadLateStyle, this);
+  styleQueue.sheets.clear();
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+
+function writePreamble(destination, resumableState, renderState, willFlushAllSegments) {
+  // This function must be called exactly once on every request
+  if (!willFlushAllSegments && renderState.externalRuntimeScript) {
+    // If the root segment is incomplete due to suspended tasks
+    // (e.g. willFlushAllSegments = false) and we are using data
+    // streaming format, ensure the external runtime is sent.
+    // (User code could choose to send this even earlier by calling
+    //  preinit(...), if they know they will suspend).
+    const _renderState$external = renderState.externalRuntimeScript,
+          src = _renderState$external.src,
+          chunks = _renderState$external.chunks;
+    internalPreinitScript(resumableState, renderState, src, chunks);
+  }
+
+  const htmlChunks = renderState.htmlChunks;
+  const headChunks = renderState.headChunks;
+  let i = 0; // Emit open tags before Hoistables and Resources
+
+  if (htmlChunks) {
+    // We have an <html> to emit as part of the preamble
+    for (i = 0; i < htmlChunks.length; i++) {
+      writeChunk(destination, htmlChunks[i]);
+    }
+
+    if (headChunks) {
+      for (i = 0; i < headChunks.length; i++) {
+        writeChunk(destination, headChunks[i]);
+      }
+    } else {
+      // We did not render a head but we emitted an <html> so we emit one now
+      writeChunk(destination, startChunkForTag('head'));
+      writeChunk(destination, endOfStartTag);
+    }
+  } else if (headChunks) {
+    // We do not have an <html> but we do have a <head>
+    for (i = 0; i < headChunks.length; i++) {
+      writeChunk(destination, headChunks[i]);
+    }
+  } // Emit high priority Hoistables
+
+
+  const charsetChunks = renderState.charsetChunks;
+
+  for (i = 0; i < charsetChunks.length; i++) {
+    writeChunk(destination, charsetChunks[i]);
+  }
+
+  charsetChunks.length = 0; // emit preconnect resources
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Flush unblocked stylesheets by precedence
+
+  renderState.styles.forEach(flushStylesInPreamble, destination);
+  const importMapChunks = renderState.importMapChunks;
+
+  for (i = 0; i < importMapChunks.length; i++) {
+    writeChunk(destination, importMapChunks[i]);
+  }
+
+  importMapChunks.length = 0;
+  renderState.bootstrapScripts.forEach(flushResource, destination);
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0; // Flush closing head if necessary
+
+  if (htmlChunks && headChunks === null) {
+    // We have an <html> rendered but no <head> rendered. We however inserted
+    // a <head> up above so we need to emit the </head> now. This is safe because
+    // if the main content contained the </head> it would also have provided a
+    // <head>. This means that all the content inside <html> is either <body> or
+    // invalid HTML
+    writeChunk(destination, endChunkForTag('head'));
+  }
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+function writeHoistables(destination, resumableState, renderState) {
+  let i = 0; // Emit high priority Hoistables
+  // We omit charsetChunks because we have already sent the shell and if it wasn't
+  // already sent it is too late now.
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Preload any stylesheets. these will emit in a render instruction that follows this
+  // but we want to kick off preloading as soon as possible
+
+  renderState.styles.forEach(preloadLateStyles, destination); // We only hoist importmaps that are configured through createResponse and that will
+  // always flush in the preamble. Generally we don't expect people to render them as
+  // tags when using React but if you do they are going to be treated like regular inline
+  // scripts and flush after other hoistables which is problematic
+  // bootstrap scripts should flush above script priority but these can only flush in the preamble
+  // so we elide the code here for performance
+
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0;
+}
+function writePostamble(destination, resumableState) {
+  if (resumableState.hasBody) {
+    writeChunk(destination, endChunkForTag('body'));
+  }
+
+  if (resumableState.hasHtml) {
+    writeChunk(destination, endChunkForTag('html'));
+  }
+}
+const arrayFirstOpenBracket = stringToPrecomputedChunk('[');
+const arraySubsequentOpenBracket = stringToPrecomputedChunk(',[');
+const arrayInterstitial = stringToPrecomputedChunk(',');
+const arrayCloseBracket = stringToPrecomputedChunk(']'); // This function writes a 2D array of strings to be embedded in javascript.
+// E.g.
+//  [["JS_escaped_string1", "JS_escaped_string2"]]
+
+function writeStyleResourceDependenciesInJS(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInJS(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInJS(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInJS(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+}
+
+function writeStyleResourceDependencyInJS(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedPrecedence)));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          writeStyleResourceAttributeInJS(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInJS(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeName)));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeValue)));
+} // This function writes a 2D array of strings to be embedded in an attribute
+// value and read with JSON.parse in ReactDOMServerExternalRuntime.js
+// E.g.
+//  [[&quot;JSON_escaped_string1&quot;, &quot;JSON_escaped_string2&quot;]]
+
+
+function writeStyleResourceDependenciesInAttr(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInAttr(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInAttr(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInAttr(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+}
+
+function writeStyleResourceDependencyInAttr(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedPrecedence))));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          writeStyleResourceAttributeInAttr(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInAttr(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeName))));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeValue))));
+}
+/**
+ * Resources
+ */
+
+
+const PENDING$1 = 0;
+const PRELOADED = 1;
+const PREAMBLE = 2;
+const LATE = 3;
+function createBoundaryResources() {
+  return {
+    styles: new Set(),
+    stylesheets: new Set()
+  };
+}
+function setCurrentlyRenderingBoundaryResourcesTarget(renderState, boundaryResources) {
+  renderState.boundaryResources = boundaryResources;
+}
+
+function getResourceKey(href) {
+  return href;
+}
+
+function getImageResourceKey(href, imageSrcSet, imageSizes) {
+  if (imageSrcSet) {
+    return imageSrcSet + '\n' + (imageSizes || '');
+  }
+
+  return href;
+}
+
+function prefetchDNS(href) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const key = getResourceKey(href);
+
+    if (!resumableState.dnsResources.hasOwnProperty(key)) {
+      resumableState.dnsResources[key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPrefetchDNSAsHeader(href), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this as resettable in case we are prerendering and postpone in the Shell
+        renderState.resets.dns[key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        // Encode as element
+        const resource = [];
+        pushLinkImpl(resource, {
+          href,
+          rel: 'dns-prefetch'
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preconnect(href, crossOrigin) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const bucket = crossOrigin === 'use-credentials' ? 'credentials' : typeof crossOrigin === 'string' ? 'anonymous' : 'default';
+    const key = getResourceKey(href);
+
+    if (!resumableState.connectResources[bucket].hasOwnProperty(key)) {
+      resumableState.connectResources[bucket][key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPreconnectAsHeader(href, crossOrigin), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this in resettableState in case we are prerending and postpone in the Shell
+        renderState.resets.connect[bucket][key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        const resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preconnect',
+          href,
+          crossOrigin
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preload(href, as, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (as && href) {
+    switch (as) {
+      case 'image':
+        {
+          let imageSrcSet, imageSizes, fetchPriority;
+
+          if (options) {
+            imageSrcSet = options.imageSrcSet;
+            imageSizes = options.imageSizes;
+            fetchPriority = options.fetchPriority;
+          }
+
+          const key = getImageResourceKey(href, imageSrcSet, imageSizes);
+
+          if (resumableState.imageResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && fetchPriority === 'high' && ( // Compute the header since we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit a preload as a header so we
+            // track this to make sure we don't reset it.
+            renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+            if (headers.highImagePreloads) {
+              headers.highImagePreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.highImagePreloads += header;
+          } else {
+            // If we don't have headers to write to we have to encode as elements to flush in the head
+            // When we have imageSrcSet the browser probably cannot load the right version from headers
+            // (this should be verified by testing). For now we assume these need to go in the head
+            // as elements even if headers are available.
+            const resource = [];
+            pushLinkImpl(resource, assign({
+              rel: 'preload',
+              // There is a bug in Safari where imageSrcSet is not respected on preload links
+              // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+              // This harms older browers that do not support imageSrcSet by making their preloads not work
+              // but this population is shrinking fast and is already small so we accept this tradeoff.
+              href: imageSrcSet ? undefined : href,
+              as
+            }, options));
+
+            if (fetchPriority === 'high') {
+              renderState.highImagePreloads.add(resource);
+            } else {
+              renderState.bulkPreloads.add(resource); // Stash the resource in case we need to promote it to higher priority
+              // when an img tag is rendered
+
+              renderState.preloads.images.set(key, resource);
+            }
+          }
+
+          break;
+        }
+
+      case 'style':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.styleResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.styleResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.stylesheets.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          break;
+        }
+
+      case 'script':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.scriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          renderState.preloads.scripts.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.scriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          break;
+        }
+
+      default:
+        {
+          const key = getResourceKey(href);
+          const hasAsType = resumableState.unknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.unknownResources[as] = resources;
+          }
+
+          resources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && as === 'font' && ( // We compute the header here because we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit this preload so we
+            // track it here to prevent it from being reset.
+            renderState.resets.font[key] = PRELOAD_NO_CREDS;
+
+            if (headers.fontPreloads) {
+              headers.fontPreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.fontPreloads += header;
+          } else {
+            // We either don't have headers or we are preloading something that does
+            // not warrant elevated priority so we encode as an element.
+            const resource = [];
+
+            const props = assign({
+              rel: 'preload',
+              href,
+              as
+            }, options);
+
+            pushLinkImpl(resource, props);
+
+            switch (as) {
+              case 'font':
+                renderState.fontPreloads.add(resource);
+                break;
+              // intentional fall through
+
+              default:
+                renderState.bulkPreloads.add(resource);
+            }
+          }
+        }
+    } // If we got this far we created a new resource
+
+
+    flushResources(request);
+  }
+}
+
+function preloadModule(href, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    const key = getResourceKey(href);
+    const as = options && typeof options.as === 'string' ? options.as : 'script';
+    let resource;
+
+    switch (as) {
+      case 'script':
+        {
+          if (resumableState.moduleScriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resource = [];
+          resumableState.moduleScriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.moduleScripts.set(key, resource);
+          break;
+        }
+
+      default:
+        {
+          const hasAsType = resumableState.moduleUnknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.moduleUnknownResources[as] = resources;
+          }
+
+          resource = [];
+          resources[key] = PRELOAD_NO_CREDS;
+        }
+    }
+
+    pushLinkImpl(resource, assign({
+      rel: 'modulepreload',
+      href
+    }, options));
+    renderState.bulkPreloads.add(resource); // If we got this far we created a new resource
+
+    flushResources(request);
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    precedence = precedence || 'default';
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+      // to create a StyleQueue
+
+      if (!styleQueue) {
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      }
+
+      const resource = {
+        state: PENDING$1,
+        props: assign({
+          rel: 'stylesheet',
+          href,
+          'data-precedence': precedence
+        }, options)
+      };
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(resource.props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.stylesheets.get(key);
+
+        if (preloadResource && preloadResource.length > 0) {
+          // The Preload for this resource was created in this render pass and has not flushed yet so
+          // we need to clear it to avoid it flushing.
+          preloadResource.length = 0;
+        } else {
+          // Either the preload resource from this render already flushed in this render pass
+          // or the preload flushed in a prior pass (prerender). In either case we need to mark
+          // this resource as already having been preloaded.
+          resource.state = PRELOADED;
+        }
+      } // We add the newly created resource to our StyleQueue and if necessary
+      // track the resource with the currently rendering boundary
+
+
+      styleQueue.sheets.set(key, resource); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+  }
+}
+
+function preinitScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.scriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.scriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.scriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.scripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+}
+
+function preinitModuleScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.moduleScriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.moduleScriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.moduleScriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        type: 'module',
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.moduleScripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+} // This function is only safe to call at Request start time since it assumes
+// that each module has not already been preloaded. If we find a need to preload
+// scripts at any other point in time we will need to check whether the preload
+// already exists and not assume it
+
+
+function preloadBootstrapScriptOrModule(resumableState, renderState, href, props) {
+
+  const key = getResourceKey(href);
+  // used to preinit the resource. If a script can be preinited then it shouldn't
+  // be a bootstrap script/module and if it is a bootstrap script/module then it
+  // must not be safe to emit early. To avoid possibly allowing for preinits of
+  // bootstrap scripts/modules we occlude these keys.
+
+
+  resumableState.scriptResources[key] = EXISTS;
+  resumableState.moduleScriptResources[key] = EXISTS;
+  const resource = [];
+  pushLinkImpl(resource, props);
+  renderState.bootstrapScripts.add(resource);
+}
+
+function internalPreinitScript(resumableState, renderState, src, chunks) {
+  const key = getResourceKey(src);
+
+  if (!resumableState.scriptResources.hasOwnProperty(key)) {
+    const resource = chunks;
+    resumableState.scriptResources[key] = EXISTS;
+    renderState.scripts.add(resource);
+  }
+
+  return;
+}
+
+function preloadAsStylePropsFromProps(href, props) {
+  return {
+    rel: 'preload',
+    as: 'style',
+    href: href,
+    crossOrigin: props.crossOrigin,
+    fetchPriority: props.fetchPriority,
+    integrity: props.integrity,
+    media: props.media,
+    hrefLang: props.hrefLang,
+    referrerPolicy: props.referrerPolicy
+  };
+}
+
+function stylesheetPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    'data-precedence': rawProps.precedence,
+    precedence: null
+  });
+}
+
+function adoptPreloadCredentials(target, preloadState) {
+  if (target.crossOrigin == null) target.crossOrigin = preloadState[0];
+  if (target.integrity == null) target.integrity = preloadState[1];
+}
+
+function getPrefetchDNSAsHeader(href) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  return "<" + escapedHref + ">; rel=dns-prefetch";
+}
+
+function getPreconnectAsHeader(href, crossOrigin) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  let value = "<" + escapedHref + ">; rel=preconnect";
+
+  if (typeof crossOrigin === 'string') {
+    const escapedCrossOrigin = escapeStringForLinkHeaderQuotedParamValueContext(crossOrigin);
+    value += "; crossorigin=\"" + escapedCrossOrigin + "\"";
+  }
+
+  return value;
+}
+
+function getPreloadAsHeader(href, as, params) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  const escapedAs = escapeStringForLinkHeaderQuotedParamValueContext(as);
+  let value = "<" + escapedHref + ">; rel=preload; as=\"" + escapedAs + "\"";
+
+  for (const paramName in params) {
+    if (hasOwnProperty.call(params, paramName)) {
+      const paramValue = params[paramName];
+
+      if (typeof paramValue === 'string') {
+        value += "; " + paramName.toLowerCase() + "=\"" + escapeStringForLinkHeaderQuotedParamValueContext(paramValue) + "\"";
+      }
+    }
+  }
+
+  return value;
+}
+
+function getStylesheetPreloadAsHeader(stylesheet) {
+  const props = stylesheet.props;
+  const preloadOptions = {
+    crossOrigin: props.crossOrigin,
+    integrity: props.integrity,
+    nonce: props.nonce,
+    type: props.type,
+    fetchPriority: props.fetchPriority,
+    referrerPolicy: props.referrerPolicy,
+    media: props.media
+  };
+  return getPreloadAsHeader(props.href, 'style', preloadOptions);
+} // This escaping function is only safe to use for href values being written into
+// a "Link" header in between `<` and `>` characters. The primary concern with the href is
+// to escape the bounding characters as well as new lines. This is unsafe to use in any other
+// context
+
+
+const regexForHrefInLinkHeaderURLContext = /[<>\r\n]/g;
+
+function escapeHrefForLinkHeaderURLContext(hrefInput) {
+
+  const coercedHref = '' + hrefInput;
+  return coercedHref.replace(regexForHrefInLinkHeaderURLContext, escapeHrefForLinkHeaderURLContextReplacer);
+}
+
+function escapeHrefForLinkHeaderURLContextReplacer(match) {
+  switch (match) {
+    case '<':
+      return '%3C';
+
+    case '>':
+      return '%3E';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeLinkHrefForHeaderContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+} // This escaping function is only safe to use for quoted param values in an HTTP header.
+// It is unsafe to use for any value not inside quote marks in parater value position.
+
+
+const regexForLinkHeaderQuotedParamValueContext = /["';,\r\n]/g;
+
+function escapeStringForLinkHeaderQuotedParamValueContext(value, name) {
+
+  const coerced = '' + value;
+  return coerced.replace(regexForLinkHeaderQuotedParamValueContext, escapeStringForLinkHeaderQuotedParamValueContextReplacer);
+}
+
+function escapeStringForLinkHeaderQuotedParamValueContextReplacer(match) {
+  switch (match) {
+    case '"':
+      return '%22';
+
+    case "'":
+      return '%27';
+
+    case ';':
+      return '%3B';
+
+    case ',':
+      return '%2C';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeStringForLinkHeaderQuotedParamValueContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+}
+
+function hoistStyleQueueDependency(styleQueue) {
+  this.styles.add(styleQueue);
+}
+
+function hoistStylesheetDependency(stylesheet) {
+  this.stylesheets.add(stylesheet);
+}
+
+function hoistResources(renderState, source) {
+  const currentBoundaryResources = renderState.boundaryResources;
+
+  if (currentBoundaryResources) {
+    source.styles.forEach(hoistStyleQueueDependency, currentBoundaryResources);
+    source.stylesheets.forEach(hoistStylesheetDependency, currentBoundaryResources);
+  }
+} // This function is called at various times depending on whether we are rendering
+// or prerendering. In this implementation we only actually emit headers once and
+// subsequent calls are ignored. We track whether the request has a completed shell
+// to determine whether we will follow headers with a flush including stylesheets.
+// In the context of prerrender we don't have a completed shell when the request finishes
+// with a postpone in the shell. In the context of a render we don't have a completed shell
+// if this is called before the shell finishes rendering which usually will happen anytime
+// anything suspends in the shell.
+
+function emitEarlyPreloads(renderState, resumableState, shellComplete) {
+  const onHeaders = renderState.onHeaders;
+
+  if (onHeaders) {
+    const headers = renderState.headers;
+
+    if (headers) {
+      let linkHeader = headers.preconnects;
+
+      if (headers.fontPreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.fontPreloads;
+      }
+
+      if (headers.highImagePreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.highImagePreloads;
+      }
+
+      if (!shellComplete) {
+        // We use raw iterators because we want to be able to halt iteration
+        // We could refactor renderState to store these dually in arrays to
+        // make this more efficient at the cost of additional memory and
+        // write overhead. However this code only runs once per request so
+        // for now I consider this sufficient.
+        const queueIter = renderState.styles.values();
+
+        outer: for (let queueStep = queueIter.next(); headers.remainingCapacity > 0 && !queueStep.done; queueStep = queueIter.next()) {
+          const sheets = queueStep.value.sheets;
+          const sheetIter = sheets.values();
+
+          for (let sheetStep = sheetIter.next(); headers.remainingCapacity > 0 && !sheetStep.done; sheetStep = sheetIter.next()) {
+            const sheet = sheetStep.value;
+            const props = sheet.props;
+            const key = getResourceKey(props.href);
+            const header = getStylesheetPreloadAsHeader(sheet); // We mutate the capacity b/c we don't want to keep checking if later headers will fit.
+            // This means that a particularly long header might close out the header queue where later
+            // headers could still fit. We could in the future alter the behavior here based on prerender vs render
+            // since during prerender we aren't as concerned with pure runtime performance.
+
+            if ((headers.remainingCapacity -= header.length) >= 2) {
+              renderState.resets.style[key] = PRELOAD_NO_CREDS;
+
+              if (linkHeader) {
+                linkHeader += ', ';
+              }
+
+              linkHeader += header; // We already track that the resource exists in resumableState however
+              // if the resumableState resets because we postponed in the shell
+              // which is what is happening in this branch if we are prerendering
+              // then we will end up resetting the resumableState. When it resets we
+              // want to record the fact that this stylesheet was already preloaded
+
+              renderState.resets.style[key] = typeof props.crossOrigin === 'string' || typeof props.integrity === 'string' ? [props.crossOrigin, props.integrity] : PRELOAD_NO_CREDS;
+            } else {
+              break outer;
+            }
+          }
+        }
+      }
+
+      if (linkHeader) {
+        onHeaders({
+          Link: linkHeader
+        });
+      } else {
+        // We still call this with no headers because a user may be using it as a signal that
+        // it React will not provide any headers
+        onHeaders({});
+      }
+
+      renderState.headers = null;
+      return;
+    }
+  }
+}
+
+function createRenderState(resumableState, generateStaticMarkup) {
+  const renderState = createRenderState$1(resumableState, undefined, undefined, undefined, undefined, undefined);
+  return {
+    // Keep this in sync with ReactFizzConfigDOM
+    placeholderPrefix: renderState.placeholderPrefix,
+    segmentPrefix: renderState.segmentPrefix,
+    boundaryPrefix: renderState.boundaryPrefix,
+    startInlineScript: renderState.startInlineScript,
+    htmlChunks: renderState.htmlChunks,
+    headChunks: renderState.headChunks,
+    externalRuntimeScript: renderState.externalRuntimeScript,
+    bootstrapChunks: renderState.bootstrapChunks,
+    onHeaders: renderState.onHeaders,
+    headers: renderState.headers,
+    resets: renderState.resets,
+    charsetChunks: renderState.charsetChunks,
+    preconnectChunks: renderState.preconnectChunks,
+    importMapChunks: renderState.importMapChunks,
+    preloadChunks: renderState.preloadChunks,
+    hoistableChunks: renderState.hoistableChunks,
+    preconnects: renderState.preconnects,
+    fontPreloads: renderState.fontPreloads,
+    highImagePreloads: renderState.highImagePreloads,
+    // usedImagePreloads: renderState.usedImagePreloads,
+    styles: renderState.styles,
+    bootstrapScripts: renderState.bootstrapScripts,
+    scripts: renderState.scripts,
+    bulkPreloads: renderState.bulkPreloads,
+    preloads: renderState.preloads,
+    boundaryResources: renderState.boundaryResources,
+    stylesToHoist: renderState.stylesToHoist,
+    // This is an extra field for the legacy renderer
+    generateStaticMarkup
+  };
+}
+
+const doctypeChunk = stringToPrecomputedChunk('');
+function pushTextInstance(target, text, renderState, textEmbedded) {
+  if (renderState.generateStaticMarkup) {
+    target.push(stringToChunk(escapeTextForBrowser(text)));
+    return false;
+  } else {
+    return pushTextInstance$1(target, text, renderState, textEmbedded);
+  }
+}
+function pushSegmentFinale(target, renderState, lastPushedText, textEmbedded) {
+  if (renderState.generateStaticMarkup) {
+    return;
+  } else {
+    return pushSegmentFinale$1(target, renderState, lastPushedText, textEmbedded);
+  }
+}
+function writeStartCompletedSuspenseBoundary(destination, renderState) {
+  if (renderState.generateStaticMarkup) {
+    // A completed boundary is done and doesn't need a representation in the HTML
+    // if we're not going to be hydrating it.
+    return true;
+  }
+
+  return writeStartCompletedSuspenseBoundary$1(destination);
+}
+function writeStartClientRenderedSuspenseBoundary(destination, renderState, // flushing these error arguments are not currently supported in this legacy streaming format.
+errorDigest, errorMessage, errorComponentStack) {
+  if (renderState.generateStaticMarkup) {
+    // A client rendered boundary is done and doesn't need a representation in the HTML
+    // since we'll never hydrate it. This is arguably an error in static generation.
+    return true;
+  }
+
+  return writeStartClientRenderedSuspenseBoundary$1(destination, renderState, errorDigest);
+}
+function writeEndCompletedSuspenseBoundary(destination, renderState) {
+  if (renderState.generateStaticMarkup) {
+    return true;
+  }
+
+  return writeEndCompletedSuspenseBoundary$1(destination);
+}
+function writeEndClientRenderedSuspenseBoundary(destination, renderState) {
+  if (renderState.generateStaticMarkup) {
+    return true;
+  }
+
+  return writeEndClientRenderedSuspenseBoundary$1(destination);
+}
+const NotPendingTransition = NotPending;
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+const REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_CONTEXT_TYPE = Symbol.for('react.context');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SCOPE_TYPE = Symbol.for('react.scope');
+const REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');
+const REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+const REACT_LEGACY_HIDDEN_TYPE = Symbol.for('react.legacy_hidden');
+const REACT_CACHE_TYPE = Symbol.for('react.cache');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+function getWrappedName(outerType, innerType, wrapperName) {
+  const displayName = outerType.displayName;
+
+  if (displayName) {
+    return displayName;
+  }
+
+  const functionName = innerType.displayName || innerType.name || '';
+  return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
+} // Keep in sync with react-reconciler/getComponentNameFromFiber
+
+
+function getContextName(type) {
+  return type.displayName || 'Context';
+} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+
+function getComponentNameFromType(type) {
+  if (type == null) {
+    // Host root, text node or just invalid type.
+    return null;
+  }
+
+  if (typeof type === 'function') {
+    return type.displayName || type.name || null;
+  }
+
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_FRAGMENT_TYPE:
+      return 'Fragment';
+
+    case REACT_PORTAL_TYPE:
+      return 'Portal';
+
+    case REACT_PROFILER_TYPE:
+      return 'Profiler';
+
+    case REACT_STRICT_MODE_TYPE:
+      return 'StrictMode';
+
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+
+    case REACT_CACHE_TYPE:
+      {
+        return 'Cache';
+      }
+
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        const context = type;
+        return getContextName(context) + '.Consumer';
+
+      case REACT_PROVIDER_TYPE:
+        const provider = type;
+        return getContextName(provider._context) + '.Provider';
+
+      case REACT_FORWARD_REF_TYPE:
+        return getWrappedName(type, type.render, 'ForwardRef');
+
+      case REACT_MEMO_TYPE:
+        const outerName = type.displayName || null;
+
+        if (outerName !== null) {
+          return outerName;
+        }
+
+        return getComponentNameFromType(type.type) || 'Memo';
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            return getComponentNameFromType(init(payload));
+          } catch (x) {
+            return null;
+          }
+        }
+
+    }
+  }
+
+  return null;
+}
+
+const emptyContextObject = {};
+
+function getMaskedContext(type, unmaskedContext) {
+  {
+    const contextTypes = type.contextTypes;
+
+    if (!contextTypes) {
+      return emptyContextObject;
+    }
+
+    const context = {};
+
+    for (const key in contextTypes) {
+      context[key] = unmaskedContext[key];
+    }
+
+    return context;
+  }
+}
+function processChildContext(instance, type, parentContext, childContextTypes) {
+  {
+    // TODO (bvaughn) Replace this behavior with an invariant() in the future.
+    // It has only been added in Fiber to match the (unintentional) behavior in Stack.
+    if (typeof instance.getChildContext !== 'function') {
+
+      return parentContext;
+    }
+
+    const childContext = instance.getChildContext();
+
+    for (const contextKey in childContext) {
+      if (!(contextKey in childContextTypes)) {
+        throw new Error((getComponentNameFromType(type) || 'Unknown') + ".getChildContext(): key \"" + contextKey + "\" is not defined in childContextTypes.");
+      }
+    }
+
+    return assign({}, parentContext, childContext);
+  }
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue2 = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue2 = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext);
+    } // On the way back, we push the new ones that weren't common.
+
+
+    pushNode(next);
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function pushProvider(context, nextValue) {
+  let prevValue;
+
+  {
+    prevValue = context._currentValue2;
+    context._currentValue2 = nextValue;
+  }
+
+  const prevNode = currentActiveSnapshot;
+  const newNode = {
+    parent: prevNode,
+    depth: prevNode === null ? 0 : prevNode.depth + 1,
+    context: context,
+    parentValue: prevValue,
+    value: nextValue
+  };
+  currentActiveSnapshot = newNode;
+  return newNode;
+}
+function popProvider(context) {
+  const prevSnapshot = currentActiveSnapshot;
+
+  if (prevSnapshot === null) {
+    throw new Error('Tried to pop a Context at the root of the app. This is a bug in React.');
+  }
+
+  {
+    const value = prevSnapshot.parentValue;
+
+    if (value === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      prevSnapshot.context._currentValue2 = prevSnapshot.context._defaultValue;
+    } else {
+      prevSnapshot.context._currentValue2 = value;
+    }
+  }
+
+  return currentActiveSnapshot = prevSnapshot.parent;
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue2;
+  return value;
+}
+
+/**
+ * `ReactInstanceMap` maintains a mapping from a public facing stateful
+ * instance (key) and the internal representation (value). This allows public
+ * methods to accept the user facing instance as an argument and map them back
+ * to internal methods.
+ *
+ * Note that this module is currently shared and assumed to be stateless.
+ * If this becomes an actual Map, that will break.
+ */
+function get(key) {
+  return key._reactInternals;
+}
+function set(key, value) {
+  key._reactInternals = value;
+}
+
+const classComponentUpdater = {
+  isMounted(inst) {
+    return false;
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueSetState(inst, payload, callback) {
+    const internals = get(inst);
+
+    if (internals.queue === null) ; else {
+      internals.queue.push(payload);
+    }
+  },
+
+  enqueueReplaceState(inst, payload, callback) {
+    const internals = get(inst);
+    internals.replace = true;
+    internals.queue = [payload];
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueForceUpdate(inst, callback) {
+  }
+
+};
+
+function applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, prevState, nextProps) {
+  const partialState = getDerivedStateFromProps(nextProps, prevState);
+
+
+  const newState = partialState === null || partialState === undefined ? prevState : assign({}, prevState, partialState);
+  return newState;
+}
+
+function constructClassInstance(ctor, props, maskedLegacyContext) {
+  let context = emptyContextObject;
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    context = readContext$1(contextType);
+  } else {
+    context = maskedLegacyContext;
+  }
+
+  const instance = new ctor(props, context);
+
+  return instance;
+}
+
+function callComponentWillMount(type, instance) {
+  const oldState = instance.state;
+
+  if (typeof instance.componentWillMount === 'function') {
+
+    instance.componentWillMount();
+  }
+
+  if (typeof instance.UNSAFE_componentWillMount === 'function') {
+    instance.UNSAFE_componentWillMount();
+  }
+
+  if (oldState !== instance.state) {
+
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+}
+
+function processUpdateQueue(internalInstance, inst, props, maskedLegacyContext) {
+  if (internalInstance.queue !== null && internalInstance.queue.length > 0) {
+    const oldQueue = internalInstance.queue;
+    const oldReplace = internalInstance.replace;
+    internalInstance.queue = null;
+    internalInstance.replace = false;
+
+    if (oldReplace && oldQueue.length === 1) {
+      inst.state = oldQueue[0];
+    } else {
+      let nextState = oldReplace ? oldQueue[0] : inst.state;
+      let dontMutate = true;
+
+      for (let i = oldReplace ? 1 : 0; i < oldQueue.length; i++) {
+        const partial = oldQueue[i];
+        const partialState = typeof partial === 'function' ? partial.call(inst, nextState, props, maskedLegacyContext) : partial;
+
+        if (partialState != null) {
+          if (dontMutate) {
+            dontMutate = false;
+            nextState = assign({}, nextState, partialState);
+          } else {
+            assign(nextState, partialState);
+          }
+        }
+      }
+
+      inst.state = nextState;
+    }
+  } else {
+    internalInstance.queue = null;
+  }
+} // Invokes the mount life-cycles on a previously never rendered instance.
+
+
+function mountClassInstance(instance, ctor, newProps, maskedLegacyContext) {
+
+  const initialState = instance.state !== undefined ? instance.state : null;
+  instance.updater = classComponentUpdater;
+  instance.props = newProps;
+  instance.state = initialState; // We don't bother initializing the refs object on the server, since we're not going to resolve them anyway.
+  // The internal instance will be used to manage updates that happen during this mount.
+
+  const internalInstance = {
+    queue: [],
+    replace: false
+  };
+  set(instance, internalInstance);
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    instance.context = readContext$1(contextType);
+  } else {
+    instance.context = maskedLegacyContext;
+  }
+
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    instance.state = applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, initialState, newProps);
+  } // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+
+  if (typeof ctor.getDerivedStateFromProps !== 'function' && typeof instance.getSnapshotBeforeUpdate !== 'function' && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
+    callComponentWillMount(ctor, instance); // If we had additional state updates during this life-cycle, let's
+    // process them now.
+
+    processUpdateQueue(internalInstance, instance, newProps, maskedLegacyContext);
+  }
+}
+
+// Ids are base 32 strings whose binary representation corresponds to the
+// position of a node in a tree.
+// Every time the tree forks into multiple children, we add additional bits to
+// the left of the sequence that represent the position of the child within the
+// current level of children.
+//
+//      00101       00010001011010101
+//      ╰─┬─╯       ╰───────┬───────╯
+//   Fork 5 of 20       Parent id
+//
+// The leading 0s are important. In the above example, you only need 3 bits to
+// represent slot 5. However, you need 5 bits to represent all the forks at
+// the current level, so we must account for the empty bits at the end.
+//
+// For this same reason, slots are 1-indexed instead of 0-indexed. Otherwise,
+// the zeroth id at a level would be indistinguishable from its parent.
+//
+// If a node has only one child, and does not materialize an id (i.e. does not
+// contain a useId hook), then we don't need to allocate any space in the
+// sequence. It's treated as a transparent indirection. For example, these two
+// trees produce the same ids:
+//
+// <>                          <>
+//   <Indirection>               <A />
+//     <A />                     <B />
+//   </Indirection>            </>
+//   <B />
+// </>
+//
+// However, we cannot skip any node that materializes an id. Otherwise, a parent
+// id that does not fork would be indistinguishable from its child id. For
+// example, this tree does not fork, but the parent and child must have
+// different ids.
+//
+// <Parent>
+//   <Child />
+// </Parent>
+//
+// To handle this scenario, every time we materialize an id, we allocate a
+// new level with a single slot. You can think of this as a fork with only one
+// prong, or an array of children with length 1.
+//
+// It's possible for the size of the sequence to exceed 32 bits, the max
+// size for bitwise operations. When this happens, we make more room by
+// converting the right part of the id to a string and storing it in an overflow
+// variable. We use a base 32 string representation, because 32 is the largest
+// power of 2 that is supported by toString(). We want the base to be large so
+// that the resulting ids are compact, and we want the base to be a power of 2
+// because every log2(base) bits corresponds to a single character, i.e. every
+// log2(32) = 5 bits. That means we can lop bits off the end 5 at a time without
+// affecting the final result.
+const emptyTreeContext = {
+  id: 1,
+  overflow: ''
+};
+function getTreeId(context) {
+  const overflow = context.overflow;
+  const idWithLeadingBit = context.id;
+  const id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
+  return id.toString(32) + overflow;
+}
+function pushTreeContext(baseContext, totalChildren, index) {
+  const baseIdWithLeadingBit = baseContext.id;
+  const baseOverflow = baseContext.overflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
+  // of the id; we use it to account for leading 0s.
+
+  const baseLength = getBitLength(baseIdWithLeadingBit) - 1;
+  const baseId = baseIdWithLeadingBit & ~(1 << baseLength);
+  const slot = index + 1;
+  const length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
+  // consideration the leading 1 we use to mark the end of the sequence.
+
+  if (length > 30) {
+    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
+    // This branch assumes the length of the base id is greater than 5; it won't
+    // work for smaller ids, because you need 5 bits per character.
+    //
+    // We encode the id in multiple steps: first the base id, then the
+    // remaining digits.
+    //
+    // Each 5 bit sequence corresponds to a single base 32 character. So for
+    // example, if the current id is 23 bits long, we can convert 20 of those
+    // bits into a string of 4 characters, with 3 bits left over.
+    //
+    // First calculate how many bits in the base id represent a complete
+    // sequence of characters.
+    const numberOfOverflowBits = baseLength - baseLength % 5; // Then create a bitmask that selects only those bits.
+
+    const newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
+
+    const newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
+
+    const restOfBaseId = baseId >> numberOfOverflowBits;
+    const restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
+    // we made more room, this time it won't overflow.
+
+    const restOfLength = getBitLength(totalChildren) + restOfBaseLength;
+    const restOfNewBits = slot << restOfBaseLength;
+    const id = restOfNewBits | restOfBaseId;
+    const overflow = newOverflow + baseOverflow;
+    return {
+      id: 1 << restOfLength | id,
+      overflow
+    };
+  } else {
+    // Normal path
+    const newBits = slot << baseLength;
+    const id = newBits | baseId;
+    const overflow = baseOverflow;
+    return {
+      id: 1 << length | id,
+      overflow
+    };
+  }
+}
+
+function getBitLength(number) {
+  return 32 - clz32(number);
+}
+
+function getLeadingBit(id) {
+  return 1 << getBitLength(id) - 1;
+} // TODO: Math.clz32 is supported in Node 12+. Maybe we can drop the fallback.
+
+
+const 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
+
+const log = Math.log;
+const LN2 = Math.LN2;
+
+function clz32Fallback(x) {
+  const asUint = x >>> 0;
+
+  if (asUint === 0) {
+    return 32;
+  }
+
+  return 31 - (log(asUint) / LN2 | 0) | 0;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFlightWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop$2() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop$2, noop$2);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+
+const objectIs = // $FlowFixMe[method-unbinding]
+typeof Object.is === 'function' ? Object.is : is;
+
+let currentlyRenderingComponent = null;
+let currentlyRenderingTask = null;
+let currentlyRenderingRequest = null;
+let currentlyRenderingKeyPath = null;
+let firstWorkInProgressHook = null;
+let workInProgressHook = null; // Whether the work-in-progress hook is a re-rendered hook
+
+let isReRender = false; // Whether an update was scheduled during the currently executing render pass.
+
+let didScheduleRenderPhaseUpdate = false; // Counts the number of useId hooks in this component
+
+let localIdCounter = 0; // Chunks that should be pushed to the stream once the component
+// finishes rendering.
+// Counts the number of useFormState calls in this component
+
+let formStateCounter = 0; // The index of the useFormState hook that matches the one passed in at the
+// root during an MPA navigation, if any.
+
+let formStateMatchingIndex = -1; // Counts the number of use(thenable) calls in this component
+
+let thenableIndexCounter = 0;
+let thenableState = null; // Lazily created map of render-phase updates
+
+let renderPhaseUpdates = null; // Counter to prevent infinite loops.
+
+let numberOfReRenders = 0;
+const RE_RENDER_LIMIT = 25;
+
+function resolveCurrentlyRenderingComponent() {
+  if (currentlyRenderingComponent === null) {
+    throw new Error('Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for' + ' one of the following reasons:\n' + '1. You might have mismatching versions of React and the renderer (such as React DOM)\n' + '2. You might be breaking the Rules of Hooks\n' + '3. You might have more than one copy of React in the same app\n' + 'See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.');
+  }
+
+  return currentlyRenderingComponent;
+}
+
+function areHookInputsEqual(nextDeps, prevDeps) {
+  if (prevDeps === null) {
+
+    return false;
+  }
+
+
+  for (let i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    if (objectIs(nextDeps[i], prevDeps[i])) {
+      continue;
+    }
+
+    return false;
+  }
+
+  return true;
+}
+
+function createHook() {
+  if (numberOfReRenders > 0) {
+    throw new Error('Rendered more hooks than during the previous render');
+  }
+
+  return {
+    memoizedState: null,
+    queue: null,
+    next: null
+  };
+}
+
+function createWorkInProgressHook() {
+  if (workInProgressHook === null) {
+    // This is the first hook in the list
+    if (firstWorkInProgressHook === null) {
+      isReRender = false;
+      firstWorkInProgressHook = workInProgressHook = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = firstWorkInProgressHook;
+    }
+  } else {
+    if (workInProgressHook.next === null) {
+      isReRender = false; // Append to the end of the list
+
+      workInProgressHook = workInProgressHook.next = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = workInProgressHook.next;
+    }
+  }
+
+  return workInProgressHook;
+}
+
+function prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState) {
+  currentlyRenderingComponent = componentIdentity;
+  currentlyRenderingTask = task;
+  currentlyRenderingRequest = request;
+  currentlyRenderingKeyPath = keyPath;
+  // didScheduleRenderPhaseUpdate = false;
+  // firstWorkInProgressHook = null;
+  // numberOfReRenders = 0;
+  // renderPhaseUpdates = null;
+  // workInProgressHook = null;
+
+
+  localIdCounter = 0;
+  formStateCounter = 0;
+  formStateMatchingIndex = -1;
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function finishHooks(Component, props, children, refOrContext) {
+  // This must be called after every function component to prevent hooks from
+  // being used in classes.
+  while (didScheduleRenderPhaseUpdate) {
+    // Updates were scheduled during the render phase. They are stored in
+    // the `renderPhaseUpdates` map. Call the component again, reusing the
+    // work-in-progress hooks and applying the additional updates on top. Keep
+    // restarting until no more updates are scheduled.
+    didScheduleRenderPhaseUpdate = false;
+    localIdCounter = 0;
+    formStateCounter = 0;
+    formStateMatchingIndex = -1;
+    thenableIndexCounter = 0;
+    numberOfReRenders += 1; // Start over from the beginning of the list
+
+    workInProgressHook = null;
+    children = Component(props, refOrContext);
+  }
+
+  resetHooksState();
+  return children;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+function checkDidRenderIdHook() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  const didRenderIdHook = localIdCounter !== 0;
+  return didRenderIdHook;
+}
+function getFormStateCount() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateCounter;
+}
+function getFormStateMatchingIndex() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateMatchingIndex;
+} // Reset the internal hooks state if an error occurs while rendering a component
+
+function resetHooksState() {
+
+  currentlyRenderingComponent = null;
+  currentlyRenderingTask = null;
+  currentlyRenderingRequest = null;
+  currentlyRenderingKeyPath = null;
+  didScheduleRenderPhaseUpdate = false;
+  firstWorkInProgressHook = null;
+  numberOfReRenders = 0;
+  renderPhaseUpdates = null;
+  workInProgressHook = null;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+function useContext(context) {
+
+  resolveCurrentlyRenderingComponent();
+  return readContext$1(context);
+}
+
+function basicStateReducer(state, action) {
+  // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
+  return typeof action === 'function' ? action(state) : action;
+}
+
+function useState(initialState) {
+
+  return useReducer(basicStateReducer, // useReducer has a special case to support lazy useState initializers
+  initialState);
+}
+function useReducer(reducer, initialArg, init) {
+
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+
+  if (isReRender) {
+    // This is a re-render. Apply the new render phase updates to the previous
+    // current hook.
+    const queue = workInProgressHook.queue;
+    const dispatch = queue.dispatch;
+
+    if (renderPhaseUpdates !== null) {
+      // Render phase updates are stored in a map of queue -> linked list
+      const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+      if (firstRenderPhaseUpdate !== undefined) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        renderPhaseUpdates.delete(queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+        let newState = workInProgressHook.memoizedState;
+        let update = firstRenderPhaseUpdate;
+
+        do {
+          // Process this render phase update. We don't have to check the
+          // priority because it will always be the same as the current
+          // render's.
+          const action = update.action;
+
+          newState = reducer(newState, action);
+
+
+          update = update.next;
+        } while (update !== null); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+        workInProgressHook.memoizedState = newState;
+        return [newState, dispatch];
+      }
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    return [workInProgressHook.memoizedState, dispatch];
+  } else {
+
+    let initialState;
+
+    if (reducer === basicStateReducer) {
+      // Special case for `useState`.
+      initialState = typeof initialArg === 'function' ? initialArg() : initialArg;
+    } else {
+      initialState = init !== undefined ? init(initialArg) : initialArg;
+    }
+
+
+    workInProgressHook.memoizedState = initialState; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    const queue = workInProgressHook.queue = {
+      last: null,
+      dispatch: null
+    };
+    const dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingComponent, queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    return [workInProgressHook.memoizedState, dispatch];
+  }
+}
+
+function useMemo(nextCreate, deps) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+
+  if (workInProgressHook !== null) {
+    const prevState = workInProgressHook.memoizedState;
+
+    if (prevState !== null) {
+      if (nextDeps !== null) {
+        const prevDeps = prevState[1];
+
+        if (areHookInputsEqual(nextDeps, prevDeps)) {
+          return prevState[0];
+        }
+      }
+    }
+  }
+
+  const nextValue = nextCreate();
+
+
+  workInProgressHook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
+
+function useRef(initialValue) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const previousRef = workInProgressHook.memoizedState;
+
+  if (previousRef === null) {
+    const ref = {
+      current: initialValue
+    };
+
+
+    workInProgressHook.memoizedState = ref;
+    return ref;
+  } else {
+    return previousRef;
+  }
+}
+
+function dispatchAction(componentIdentity, queue, action) {
+  if (numberOfReRenders >= RE_RENDER_LIMIT) {
+    throw new Error('Too many re-renders. React limits the number of renders to prevent ' + 'an infinite loop.');
+  }
+
+  if (componentIdentity === currentlyRenderingComponent) {
+    // This is a render phase update. Stash it in a lazily-created map of
+    // queue -> linked list of updates. After this render pass, we'll restart
+    // and apply the stashed updates on top of the work-in-progress hook.
+    didScheduleRenderPhaseUpdate = true;
+    const update = {
+      action,
+      next: null
+    };
+
+    if (renderPhaseUpdates === null) {
+      renderPhaseUpdates = new Map();
+    }
+
+    const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+    if (firstRenderPhaseUpdate === undefined) {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      renderPhaseUpdates.set(queue, update);
+    } else {
+      // Append the update to the end of the list.
+      let lastRenderPhaseUpdate = firstRenderPhaseUpdate;
+
+      while (lastRenderPhaseUpdate.next !== null) {
+        lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+      }
+
+      lastRenderPhaseUpdate.next = update;
+    }
+  }
+}
+
+function useCallback(callback, deps) {
+  return useMemo(() => callback, deps);
+}
+
+function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  if (getServerSnapshot === undefined) {
+    throw new Error('Missing getServerSnapshot, which is required for ' + 'server-rendered content. Will revert to client rendering.');
+  }
+
+  return getServerSnapshot();
+}
+
+function useDeferredValue(value, initialValue) {
+  resolveCurrentlyRenderingComponent();
+
+  {
+    return value;
+  }
+}
+
+function unsupportedStartTransition() {
+  throw new Error('startTransition cannot be called during server rendering.');
+}
+
+function useTransition() {
+  resolveCurrentlyRenderingComponent();
+  return [false, unsupportedStartTransition];
+}
+
+function useHostTransitionStatus() {
+  resolveCurrentlyRenderingComponent();
+  return NotPendingTransition;
+}
+
+function unsupportedSetOptimisticState() {
+  throw new Error('Cannot update optimistic state while rendering.');
+}
+
+function useOptimistic(passthrough, reducer) {
+  resolveCurrentlyRenderingComponent();
+  return [passthrough, unsupportedSetOptimisticState];
+}
+
+function createPostbackFormStateKey(permalink, componentKeyPath, hookIndex) {
+  if (permalink !== undefined) {
+    // Don't bother to hash a permalink-based key since it's already short.
+    return 'p' + permalink;
+  } else {
+    // Append a node to the key path that represents the form state hook.
+    const keyPath = [componentKeyPath, null, hookIndex]; // Key paths are hashed to reduce the size. It does not need to be secure,
+    // and it's more important that it's fast than that it's completely
+    // collision-free.
+
+    const keyPathHash = createFastHashJS(JSON.stringify(keyPath));
+    return 'k' + keyPathHash;
+  }
+}
+
+function useFormState(action, initialState, permalink) {
+  resolveCurrentlyRenderingComponent(); // Count the number of useFormState hooks per component. We also use this to
+  // track the position of this useFormState hook relative to the other ones in
+  // this component, so we can generate a unique key for each one.
+
+  const formStateHookIndex = formStateCounter++;
+  const request = currentlyRenderingRequest; // $FlowIgnore[prop-missing]
+
+  const formAction = action.$$FORM_ACTION;
+
+  if (typeof formAction === 'function') {
+    // This is a server action. These have additional features to enable
+    // MPA-style form submissions with progressive enhancement.
+    // TODO: If the same permalink is passed to multiple useFormStates, and
+    // they all have the same action signature, Fizz will pass the postback
+    // state to all of them. We should probably only pass it to the first one,
+    // and/or warn.
+    // The key is lazily generated and deduped so the that the keypath doesn't
+    // get JSON.stringify-ed unnecessarily, and at most once.
+    let nextPostbackStateKey = null; // Determine the current form state. If we received state during an MPA form
+    // submission, then we will reuse that, if the action identity matches.
+    // Otherwise we'll use the initial state argument. We will emit a comment
+    // marker into the stream that indicates whether the state was reused.
+
+    let state = initialState;
+    const componentKeyPath = currentlyRenderingKeyPath;
+    const postbackFormState = getFormState(request); // $FlowIgnore[prop-missing]
+
+    const isSignatureEqual = action.$$IS_SIGNATURE_EQUAL;
+
+    if (postbackFormState !== null && typeof isSignatureEqual === 'function') {
+      const postbackKey = postbackFormState[1];
+      const postbackReferenceId = postbackFormState[2];
+      const postbackBoundArity = postbackFormState[3];
+
+      if (isSignatureEqual.call(action, postbackReferenceId, postbackBoundArity)) {
+        nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+
+        if (postbackKey === nextPostbackStateKey) {
+          // This was a match
+          formStateMatchingIndex = formStateHookIndex; // Reuse the state that was submitted by the form.
+
+          state = postbackFormState[0];
+        }
+      }
+    } // Bind the state to the first argument of the action.
+
+
+    const boundAction = action.bind(null, state); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    }; // $FlowIgnore[prop-missing]
+
+
+    if (typeof boundAction.$$FORM_ACTION === 'function') {
+      // $FlowIgnore[prop-missing]
+      dispatch.$$FORM_ACTION = prefix => {
+        const metadata = boundAction.$$FORM_ACTION(prefix); // Override the action URL
+
+        if (permalink !== undefined) {
+
+          permalink += '';
+          metadata.action = permalink;
+        }
+
+        const formData = metadata.data;
+
+        if (formData) {
+          if (nextPostbackStateKey === null) {
+            nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+          }
+
+          formData.append('$ACTION_KEY', nextPostbackStateKey);
+        }
+
+        return metadata;
+      };
+    }
+
+    return [state, dispatch];
+  } else {
+    // This is not a server action, so the implementation is much simpler.
+    // Bind the state to the first argument of the action.
+    const boundAction = action.bind(null, initialState); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    };
+
+    return [initialState, dispatch];
+  }
+}
+
+function useId() {
+  const task = currentlyRenderingTask;
+  const treeId = getTreeId(task.treeContext);
+  const resumableState = currentResumableState;
+
+  if (resumableState === null) {
+    throw new Error('Invalid hook call. Hooks can only be called inside of the body of a function component.');
+  }
+
+  const localId = localIdCounter++;
+  return makeId(resumableState, treeId, localId);
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable;
+      return unwrapThenable(thenable);
+    } else if (usable.$$typeof === REACT_CONTEXT_TYPE || usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function unwrapThenable(thenable) {
+  const index = thenableIndexCounter;
+  thenableIndexCounter += 1;
+
+  if (thenableState === null) {
+    thenableState = createThenableState();
+  }
+
+  return trackUsedThenable(thenableState, thenable, index);
+}
+
+function unsupportedRefresh() {
+  throw new Error('Cache cannot be refreshed during server rendering.');
+}
+
+function useCacheRefresh() {
+  return unsupportedRefresh;
+}
+
+function noop$1() {}
+
+const HooksDispatcher = {
+  readContext,
+  use,
+  useContext,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+  useInsertionEffect: noop$1,
+  useLayoutEffect: noop$1,
+  useCallback,
+  // useImperativeHandle is not run in the server environment
+  useImperativeHandle: noop$1,
+  // Effects are not run in the server environment.
+  useEffect: noop$1,
+  // Debugging effect
+  useDebugValue: noop$1,
+  useDeferredValue,
+  useTransition,
+  useId,
+  // Subscriptions are not setup in a server environment.
+  useSyncExternalStore
+};
+
+{
+  HooksDispatcher.useCacheRefresh = useCacheRefresh;
+}
+
+{
+  HooksDispatcher.useHostTransitionStatus = useHostTransitionStatus;
+}
+
+{
+  HooksDispatcher.useOptimistic = useOptimistic;
+  HooksDispatcher.useFormState = useFormState;
+}
+
+let currentResumableState = null;
+function setCurrentResumableState(resumableState) {
+  currentResumableState = resumableState;
+}
+
+function getCacheSignal() {
+  throw new Error('Not implemented.');
+}
+
+function getCacheForType(resourceType) {
+  throw new Error('Not implemented.');
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal,
+  getCacheForType
+};
+
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+const ReactCurrentCache = ReactSharedInternals.ReactCurrentCache;
+// The name might be minified but we assume that it's going to be the same generated name. Typically
+// because it's just the same compiled output in practice.
+// resume with segmentID at the index
+
+const CLIENT_RENDERED = 4; // if it errors or infinitely suspends
+
+const PENDING = 0;
+const COMPLETED = 1;
+const FLUSHED = 2;
+const ABORTED = 3;
+const ERRORED = 4;
+const POSTPONED = 5;
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2; // This is a default heuristic for how to split up the HTML content into progressive
+// loading. Our goal is to be able to display additional new content about every 500ms.
+// Faster than that is unnecessary and should be throttled on the client. It also
+// adds unnecessary overhead to do more splits. We don't know if it's a higher or lower
+// end device but higher end suffer less from the overhead than lower end does from
+// not getting small enough pieces. We error on the side of low end.
+// We base this on low end 3G speeds which is about 500kbits per second. We assume
+// that there can be a reasonable drop off from max bandwidth which leaves you with
+// as little as 80%. We can receive half of that each 500ms - at best. In practice,
+// a little bandwidth is lost to processing and contention - e.g. CSS and images that
+// are downloaded along with the main content. So we estimate about half of that to be
+// the lower end throughput. In other words, we expect that you can at least show
+// about 12.5kb of content per 500ms. Not counting starting latency for the first
+// paint.
+// 500 * 1024 / 8 * .8 * 0.5 / 2
+
+const DEFAULT_PROGRESSIVE_CHUNK_SIZE = 12800;
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+
+  return null;
+}
+
+function noop() {}
+
+function createRequest(children, resumableState, renderState, rootFormatContext, progressiveChunkSize, onError, onAllReady, onShellReady, onShellError, onFatalError, onPostpone, formState) {
+  prepareHostDispatcher();
+  const pingedTasks = [];
+  const abortSet = new Set();
+  const request = {
+    destination: null,
+    flushScheduled: false,
+    resumableState,
+    renderState,
+    rootFormatContext,
+    progressiveChunkSize: progressiveChunkSize === undefined ? DEFAULT_PROGRESSIVE_CHUNK_SIZE : progressiveChunkSize,
+    status: OPEN,
+    fatalError: null,
+    nextSegmentId: 0,
+    allPendingTasks: 0,
+    pendingRootTasks: 0,
+    completedRootSegment: null,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    clientRenderedBoundaries: [],
+    completedBoundaries: [],
+    partialBoundaries: [],
+    trackedPostpones: null,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? noop : onPostpone,
+    onAllReady: onAllReady === undefined ? noop : onAllReady,
+    onShellReady: onShellReady === undefined ? noop : onShellReady,
+    onShellError: onShellError === undefined ? noop : onShellError,
+    onFatalError: onFatalError === undefined ? noop : onFatalError,
+    formState: formState === undefined ? null : formState
+  }; // This segment represents the root fallback.
+
+  const rootSegment = createPendingSegment(request, 0, null, rootFormatContext, // Root segments are never embedded in Text on either edge
+  false, false); // There is no parent so conceptually, we're unblocked to flush this segment.
+
+  rootSegment.parentFlushed = true;
+  const rootTask = createRenderTask(request, null, children, -1, null, rootSegment, abortSet, null, rootFormatContext, emptyContextObject, rootContextSnapshot, emptyTreeContext);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  return null;
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (request.pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createSuspenseBoundary(request, fallbackAbortableTasks) {
+  return {
+    status: PENDING,
+    rootSegmentID: -1,
+    parentFlushed: false,
+    pendingTasks: 0,
+    completedSegments: [],
+    byteSize: 0,
+    fallbackAbortableTasks,
+    errorDigest: null,
+    resources: createBoundaryResources(),
+    trackedContentKeyPath: null,
+    trackedFallbackNode: null
+  };
+}
+
+function createRenderTask(request, thenableState, node, childIndex, blockedBoundary, blockedSegment, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  const task = {
+    replay: null,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createReplayTask(request, thenableState, replay, node, childIndex, blockedBoundary, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  replay.pendingTasks++;
+  const task = {
+    replay,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment: null,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createPendingSegment(request, index, boundary, parentFormatContext, lastPushedText, textEmbedded) {
+  return {
+    status: PENDING,
+    id: -1,
+    // lazily assigned later
+    index,
+    parentFlushed: false,
+    chunks: [],
+    children: [],
+    parentFormatContext,
+    boundary,
+    lastPushedText,
+    textEmbedded
+  };
+} // DEV-only global reference to the currently executing task
+
+function popComponentStackInDEV(task) {
+} // stash the component stack of an unwinding error until it is processed
+
+function logRecoverableError(request, error) {
+  // If this callback errors, we intentionally let that error bubble up to become a fatal error
+  // so that someone fixes the error reporting instead of hiding it.
+  const errorDigest = request.onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest;
+}
+
+function fatalError(request, error) {
+  // This is called outside error handling code such as if the root errors outside
+  // a suspense boundary or if the root suspense boundary's fallback errors.
+  // It's also called if React itself or its host configs errors.
+  const onShellError = request.onShellError;
+  onShellError(error);
+  const onFatalError = request.onFatalError;
+  onFatalError(error);
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function renderSuspenseBoundary(request, someTask, keyPath, props) {
+  if (someTask.replay !== null) {
+    // If we're replaying through this pass, it means we're replaying through
+    // an already completed Suspense boundary. It's too late to do anything about it
+    // so we can just render through it.
+    const prevKeyPath = someTask.keyPath;
+    someTask.keyPath = keyPath;
+    const content = props.children;
+
+    try {
+      renderNode(request, someTask, content, -1);
+    } finally {
+      someTask.keyPath = prevKeyPath;
+    }
+
+    return;
+  } // $FlowFixMe: Refined.
+
+
+  const task = someTask;
+  const prevKeyPath = task.keyPath;
+  const parentBoundary = task.blockedBoundary;
+  const parentSegment = task.blockedSegment; // Each time we enter a suspense boundary, we split out into a new segment for
+  // the fallback so that we can later replace that segment with the content.
+  // This also lets us split out the main content even if it doesn't suspend,
+  // in case it ends up generating a large subtree of content.
+
+  const fallback = props.fallback;
+  const content = props.children;
+  const fallbackAbortSet = new Set();
+  const newBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+
+  if (request.trackedPostpones !== null) {
+    newBoundary.trackedContentKeyPath = keyPath;
+  }
+
+  const insertionIndex = parentSegment.chunks.length; // The children of the boundary segment is actually the fallback.
+
+  const boundarySegment = createPendingSegment(request, insertionIndex, newBoundary, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false);
+  parentSegment.children.push(boundarySegment); // The parentSegment has a child Segment at this index so we reset the lastPushedText marker on the parent
+
+  parentSegment.lastPushedText = false; // This segment is the actual child content. We can start rendering that immediately.
+
+  const contentRootSegment = createPendingSegment(request, 0, null, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false); // We mark the root segment as having its parent flushed. It's not really flushed but there is
+  // no parent segment so there's nothing to wait on.
+
+  contentRootSegment.parentFlushed = true; // Currently this is running synchronously. We could instead schedule this to pingedTasks.
+  // I suspect that there might be some efficiency benefits from not creating the suspended task
+  // and instead just using the stack if possible.
+  // TODO: Call this directly instead of messing with saving and restoring contexts.
+  // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and which segment
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = newBoundary;
+  task.blockedSegment = contentRootSegment;
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, newBoundary.resources);
+  }
+
+  task.keyPath = keyPath;
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+    pushSegmentFinale(contentRootSegment.chunks, request.renderState, contentRootSegment.lastPushedText, contentRootSegment.textEmbedded);
+    contentRootSegment.status = COMPLETED;
+    queueCompletedSegment(newBoundary, contentRootSegment);
+
+    if (newBoundary.pendingTasks === 0 && newBoundary.status === PENDING) {
+      newBoundary.status = COMPLETED; // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    contentRootSegment.status = ERRORED;
+    newBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    newBoundary.errorDigest = errorDigest;
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.blockedSegment = parentSegment;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]];
+  const trackedPostpones = request.trackedPostpones;
+
+  if (trackedPostpones !== null) {
+    // We create a detached replay node to track any postpones inside the fallback.
+    const fallbackReplayNode = [fallbackKeyPath[1], fallbackKeyPath[2], [], null];
+    trackedPostpones.workingMap.set(fallbackKeyPath, fallbackReplayNode);
+
+    if (newBoundary.status === POSTPONED) {
+      // This must exist now.
+      const boundaryReplayNode = trackedPostpones.workingMap.get(keyPath);
+      boundaryReplayNode[4] = fallbackReplayNode;
+    } else {
+      // We might not inject it into the postponed tree, unless the content actually
+      // postpones too. We need to keep track of it until that happpens.
+      newBoundary.trackedFallbackNode = fallbackReplayNode;
+    }
+  } // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+
+  const suspendedFallbackTask = createRenderTask(request, null, fallback, -1, parentBoundary, boundarySegment, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function replaySuspenseBoundary(request, task, keyPath, props, id, childNodes, childSlots, fallbackNodes, fallbackSlots) {
+  const prevKeyPath = task.keyPath;
+  const previousReplaySet = task.replay;
+  const parentBoundary = task.blockedBoundary;
+  const content = props.children;
+  const fallback = props.fallback;
+  const fallbackAbortSet = new Set();
+  const resumedBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = id; // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and replay node
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = resumedBoundary;
+  task.replay = {
+    nodes: childNodes,
+    slots: childSlots,
+    pendingTasks: 1
+  };
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, resumedBoundary.resources);
+  }
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+    }
+
+    task.replay.pendingTasks--;
+
+    if (resumedBoundary.pendingTasks === 0 && resumedBoundary.status === PENDING) {
+      resumedBoundary.status = COMPLETED;
+      request.completedBoundaries.push(resumedBoundary); // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    resumedBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    resumedBoundary.errorDigest = errorDigest;
+
+    task.replay.pendingTasks--; // The parent already flushed in the prerender so we need to schedule this to be emitted.
+
+    request.clientRenderedBoundaries.push(resumedBoundary); // We don't need to decrement any task numbers because we didn't spawn any new task.
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.replay = previousReplaySet;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]]; // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+  const fallbackReplay = {
+    nodes: fallbackNodes,
+    slots: fallbackSlots,
+    pendingTasks: 0
+  };
+  const suspendedFallbackTask = createReplayTask(request, null, fallbackReplay, fallback, -1, parentBoundary, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function renderHostElement(request, task, keyPath, type, props) {
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    const children = props.children; // TODO: Make this a Config for replaying.
+
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+  } else {
+    // Render
+    const children = pushStartInstance(segment.chunks, type, props, request.resumableState, request.renderState, task.formatContext, segment.lastPushedText);
+    segment.lastPushedText = false;
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+    pushEndInstance(segment.chunks, type, props, request.resumableState, prevContext);
+    segment.lastPushedText = false;
+  }
+}
+
+function shouldConstruct(Component) {
+  return Component.prototype && Component.prototype.isReactComponent;
+}
+
+function renderWithHooks(request, task, keyPath, prevThenableState, Component, props, secondArg) {
+  const componentIdentity = {};
+  prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState);
+  const result = Component(props, secondArg);
+  return finishHooks(Component, props, result, secondArg);
+}
+
+function finishClassComponent(request, task, keyPath, instance, Component, props) {
+  const nextChildren = instance.render();
+
+  {
+    const childContextTypes = Component.childContextTypes;
+
+    if (childContextTypes !== null && childContextTypes !== undefined) {
+      const previousContext = task.legacyContext;
+      const mergedContext = processChildContext(instance, Component, previousContext, childContextTypes);
+      task.legacyContext = mergedContext;
+      renderNodeDestructive(request, task, null, nextChildren, -1);
+      task.legacyContext = previousContext;
+      return;
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, nextChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderClassComponent(request, task, keyPath, Component, props) {
+  const maskedContext = getMaskedContext(Component, task.legacyContext) ;
+  const instance = constructClassInstance(Component, props, maskedContext);
+  mountClassInstance(instance, Component, props, maskedContext);
+  finishClassComponent(request, task, keyPath, instance, Component);
+}
+// components for some reason.
+
+function renderIndeterminateComponent(request, task, keyPath, prevThenableState, Component, props) {
+  let legacyContext;
+
+  {
+    legacyContext = getMaskedContext(Component, task.legacyContext);
+  }
+
+  const value = renderWithHooks(request, task, keyPath, prevThenableState, Component, props, legacyContext);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+
+  if ( // Run these checks in production only if the flag is off.
+  // Eventually we'll delete this branch altogether.
+  typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) {
+
+    mountClassInstance(value, Component, props, legacyContext);
+    finishClassComponent(request, task, keyPath, value, Component);
+  } else {
+
+    finishFunctionComponent(request, task, keyPath, value, hasId, formStateCount, formStateMatchingIndex);
+  }
+}
+
+function finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex) {
+  let didEmitFormStateMarkers = false;
+
+  if (formStateCount !== 0 && request.formState !== null) {
+    // For each useFormState hook, emit a marker that indicates whether we
+    // rendered using the form state passed at the root. We only emit these
+    // markers if form state is passed at the root.
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      didEmitFormStateMarkers = true;
+      const target = segment.chunks;
+
+      for (let i = 0; i < formStateCount; i++) {
+        if (i === formStateMatchingIndex) {
+          pushFormStateMarkerIsMatching(target);
+        } else {
+          pushFormStateMarkerIsNotMatching(target);
+        }
+      }
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+
+  if (hasId) {
+    // This component materialized an id. We treat this as its own level, with
+    // a single "child" slot.
+    const prevTreeContext = task.treeContext;
+    const totalChildren = 1;
+    const index = 0; // Modify the id context. Because we'll need to reset this if something
+    // suspends or errors, we'll use the non-destructive render path.
+
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, index);
+    renderNode(request, task, children, -1); // Like the other contexts, this does not need to be in a finally block
+    // because renderNode takes care of unwinding the stack.
+
+    task.treeContext = prevTreeContext;
+  } else if (didEmitFormStateMarkers) {
+    // If there were formState hooks, we must use the non-destructive path
+    // because this component is not a pure indirection; we emitted markers
+    // to the stream.
+    renderNode(request, task, children, -1);
+  } else {
+    // We're now successfully past this task, and we haven't modified the
+    // context stack. We don't have to pop back to the previous task every
+    // again, so we can use the destructive recursive form.
+    renderNodeDestructive(request, task, null, children, -1);
+  }
+
+  task.keyPath = prevKeyPath;
+}
+
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    // Resolve default props. Taken from ReactElement
+    const props = assign({}, baseProps);
+    const defaultProps = Component.defaultProps;
+
+    for (const propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+
+    return props;
+  }
+
+  return baseProps;
+}
+
+function renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref) {
+  const children = renderWithHooks(request, task, keyPath, prevThenableState, type.render, props, ref);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+  finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex);
+}
+
+function renderMemo(request, task, keyPath, prevThenableState, type, props, ref) {
+  const innerType = type.type;
+  const resolvedProps = resolveDefaultProps(innerType, props);
+  renderElement(request, task, keyPath, prevThenableState, innerType, resolvedProps, ref);
+}
+
+function renderContextConsumer(request, task, keyPath, context, props) {
+
+  const render = props.children;
+
+  const newValue = readContext$1(context);
+  const newChildren = render(newValue);
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, newChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderContextProvider(request, task, keyPath, type, props) {
+  const context = type._context;
+  const value = props.value;
+  const children = props.children;
+
+  const prevKeyPath = task.keyPath;
+  task.context = pushProvider(context, value);
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, children, -1);
+  task.context = popProvider();
+  task.keyPath = prevKeyPath;
+}
+
+function renderLazyComponent(request, task, keyPath, prevThenableState, lazyComponent, props, ref) {
+  const payload = lazyComponent._payload;
+  const init = lazyComponent._init;
+  const Component = init(payload);
+  const resolvedProps = resolveDefaultProps(Component, props);
+  renderElement(request, task, keyPath, prevThenableState, Component, resolvedProps, ref);
+}
+
+function renderOffscreen(request, task, keyPath, props) {
+  const mode = props.mode;
+
+  if (mode === 'hidden') ; else {
+    // A visible Offscreen boundary is treated exactly like a fragment: a
+    // pure indirection.
+    const prevKeyPath = task.keyPath;
+    task.keyPath = keyPath;
+    renderNodeDestructive(request, task, null, props.children, -1);
+    task.keyPath = prevKeyPath;
+  }
+}
+
+function renderElement(request, task, keyPath, prevThenableState, type, props, ref) {
+  if (typeof type === 'function') {
+    if (shouldConstruct(type)) {
+      renderClassComponent(request, task, keyPath, type, props);
+      return;
+    } else {
+      renderIndeterminateComponent(request, task, keyPath, prevThenableState, type, props);
+      return;
+    }
+  }
+
+  if (typeof type === 'string') {
+    renderHostElement(request, task, keyPath, type, props);
+    return;
+  }
+
+  switch (type) {
+    // LegacyHidden acts the same as a fragment. This only works because we
+    // currently assume that every instance of LegacyHidden is accompanied by a
+    // host component wrapper. In the hidden mode, the host component is given a
+    // `hidden` attribute, which ensures that the initial HTML is not visible.
+    // To support the use of LegacyHidden as a true fragment, without an extra
+    // DOM node, we would have to hide the initial HTML in some other way.
+    // TODO: Delete in LegacyHidden. It's an unstable API only used in the
+    // www build. As a migration step, we could add a special prop to Offscreen
+    // that simulates the old behavior (no hiding, no change to effects).
+    case REACT_LEGACY_HIDDEN_TYPE:
+    case REACT_DEBUG_TRACING_MODE_TYPE:
+    case REACT_STRICT_MODE_TYPE:
+    case REACT_PROFILER_TYPE:
+    case REACT_FRAGMENT_TYPE:
+      {
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_OFFSCREEN_TYPE:
+      {
+        renderOffscreen(request, task, keyPath, props);
+        return;
+      }
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      {
+
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_SCOPE_TYPE:
+      {
+
+        throw new Error('ReactDOMServer does not yet support scope components.');
+      }
+
+    case REACT_SUSPENSE_TYPE:
+      {
+        {
+          renderSuspenseBoundary(request, task, keyPath, props);
+        }
+
+        return;
+      }
+  }
+
+  if (typeof type === 'object' && type !== null) {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        {
+          renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          renderMemo(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_PROVIDER_TYPE:
+        {
+          renderContextProvider(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_CONTEXT_TYPE:
+        {
+          renderContextConsumer(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_LAZY_TYPE:
+        {
+          renderLazyComponent(request, task, keyPath, prevThenableState, type, props);
+          return;
+        }
+    }
+  }
+
+  let info = '';
+
+  throw new Error('Element type is invalid: expected a string (for built-in ' + 'components) or a class/function (for composite components) ' + ("but got: " + (type == null ? type : typeof type) + "." + info));
+}
+
+function resumeNode(request, task, segmentId, node, childIndex) {
+  const prevReplay = task.replay;
+  const blockedBoundary = task.blockedBoundary;
+  const resumedSegment = createPendingSegment(request, 0, null, task.formatContext, false, false);
+  resumedSegment.id = segmentId;
+  resumedSegment.parentFlushed = true;
+
+  try {
+    // Convert the current ReplayTask to a RenderTask.
+    const renderTask = task;
+    renderTask.replay = null;
+    renderTask.blockedSegment = resumedSegment;
+    renderNode(request, task, node, childIndex);
+    resumedSegment.status = COMPLETED;
+
+    if (blockedBoundary === null) {
+      request.completedRootSegment = resumedSegment;
+    } else {
+      queueCompletedSegment(blockedBoundary, resumedSegment);
+
+      if (blockedBoundary.parentFlushed) {
+        request.partialBoundaries.push(blockedBoundary);
+      }
+    }
+  } finally {
+    // Restore to a ReplayTask.
+    task.replay = prevReplay;
+    task.blockedSegment = null;
+  }
+}
+
+function replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, replay) {
+  // We're replaying. Find the path to follow.
+  const replayNodes = replay.nodes;
+
+  for (let i = 0; i < replayNodes.length; i++) {
+    // Flow doesn't support refinement on tuples so we do it manually here.
+    const node = replayNodes[i];
+
+    if (keyOrIndex !== node[1]) {
+      continue;
+    }
+
+    if (node.length === 4) {
+      // Matched a replayable path.
+      // Let's double check that the component name matches as a precaution.
+      if (name !== null && name !== node[0]) {
+        throw new Error('Expected the resume to render <' + node[0] + '> in this slot but instead it rendered <' + name + '>. ' + "The tree doesn't match so React will fallback to client rendering.");
+      }
+
+      const childNodes = node[2];
+      const childSlots = node[3];
+      const currentNode = task.node;
+      task.replay = {
+        nodes: childNodes,
+        slots: childSlots,
+        pendingTasks: 1
+      };
+
+      try {
+        renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+
+        if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0 // TODO check remaining slots
+        ) {
+            throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+          }
+
+        task.replay.pendingTasks--;
+      } catch (x) {
+        if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+          // Suspend
+          if (task.node === currentNode) {
+            // This same element suspended so we need to pop the replay we just added.
+            task.replay = replay;
+          }
+
+          throw x;
+        }
+
+        task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+        // during a replay. That's because this component didn't actually error
+        // in the original prerender. What's unable to complete is the child
+        // replay nodes which might be Suspense boundaries which are able to
+        // absorb the error and we can still continue with siblings.
+
+        erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+      }
+
+      task.replay = replay;
+    } else {
+      // Let's double check that the component type matches.
+      if (type !== REACT_SUSPENSE_TYPE) {
+        const expectedType = 'Suspense';
+        throw new Error('Expected the resume to render <' + expectedType + '> in this slot but instead it rendered <' + (getComponentNameFromType(type) || 'Unknown') + '>. ' + "The tree doesn't match so React will fallback to client rendering.");
+      } // Matched a replayable path.
+
+
+      replaySuspenseBoundary(request, task, keyPath, props, node[5], node[2], node[3], node[4] === null ? [] : node[4][2], node[4] === null ? null : node[4][3]);
+    } // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+
+    replayNodes.splice(i, 1);
+    return;
+  } // We didn't find any matching nodes. We assume that this element was already
+  // rendered in the prelude and skip it.
+
+} // $FlowFixMe[missing-local-annot]
+
+function renderNodeDestructive(request, task, // The thenable state reused from the previous attempt, if any. This is almost
+// always null, except when called by retryTask.
+prevThenableState, node, childIndex) {
+  {
+    return renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex);
+  }
+} // This function by it self renders a node and consumes the task by mutating it
+// to update the current execution state.
+
+
+function renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex) {
+  if (task.replay !== null && typeof task.replay.slots === 'number') {
+    // TODO: Figure out a cheaper place than this hot path to do this check.
+    const resumeSegmentID = task.replay.slots;
+    resumeNode(request, task, resumeSegmentID, node, childIndex);
+    return;
+  } // Stash the node we're working on. We'll pick up from this task in case
+  // something suspends.
+
+
+  task.node = node;
+  task.childIndex = childIndex; // Handle object types
+
+  if (typeof node === 'object' && node !== null) {
+    switch (node.$$typeof) {
+      case REACT_ELEMENT_TYPE:
+        {
+          const element = node;
+          const type = element.type;
+          const key = element.key;
+          const props = element.props;
+          const ref = element.ref;
+          const name = getComponentNameFromType(type);
+          const keyOrIndex = key == null ? childIndex === -1 ? 0 : childIndex : key;
+          const keyPath = [task.keyPath, name, keyOrIndex];
+
+          if (task.replay !== null) {
+            replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, task.replay); // No matches found for this node. We assume it's already emitted in the
+            // prelude and skip it during the replay.
+          } else {
+            // We're doing a plain render.
+            renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+          }
+
+          return;
+        }
+
+      case REACT_PORTAL_TYPE:
+        throw new Error('Portals are not currently supported by the server renderer. ' + 'Render them conditionally so that they only appear on the client render.');
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyNode = node;
+          const payload = lazyNode._payload;
+          const init = lazyNode._init;
+          let resolvedNode;
+
+          {
+            resolvedNode = init(payload);
+          }
+
+          renderNodeDestructive(request, task, null, resolvedNode, childIndex);
+          return;
+        }
+    }
+
+    if (isArray(node)) {
+      renderChildrenArray(request, task, node, childIndex);
+      return;
+    }
+
+    const iteratorFn = getIteratorFn(node);
+
+    if (iteratorFn) {
+
+      const iterator = iteratorFn.call(node);
+
+      if (iterator) {
+        // We need to know how many total children are in this set, so that we
+        // can allocate enough id slots to acommodate them. So we must exhaust
+        // the iterator before we start recursively rendering the children.
+        // TODO: This is not great but I think it's inherent to the id
+        // generation algorithm.
+        let step = iterator.next(); // If there are not entries, we need to push an empty so we start by checking that.
+
+        if (!step.done) {
+          const children = [];
+
+          do {
+            children.push(step.value);
+            step = iterator.next();
+          } while (!step.done);
+
+          renderChildrenArray(request, task, children, childIndex);
+          return;
+        }
+
+        return;
+      }
+    } // Usables are a valid React node type. When React encounters a Usable in
+    // a child position, it unwraps it using the same algorithm as `use`. For
+    // example, for promises, React will throw an exception to unwind the
+    // stack, then replay the component once the promise resolves.
+    //
+    // A difference from `use` is that React will keep unwrapping the value
+    // until it reaches a non-Usable type.
+    //
+    // e.g. Usable<Usable<Usable<T>>> should resolve to T
+
+
+    const maybeUsable = node;
+
+    if (typeof maybeUsable.then === 'function') {
+      const thenable = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, unwrapThenable(thenable), childIndex);
+    }
+
+    if (maybeUsable.$$typeof === REACT_CONTEXT_TYPE || maybeUsable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, readContext$1(context), childIndex);
+    } // $FlowFixMe[method-unbinding]
+
+
+    const childString = Object.prototype.toString.call(node);
+    throw new Error("Objects are not valid as a React child (found: " + (childString === '[object Object]' ? 'object with keys {' + Object.keys(node).join(', ') + '}' : childString) + "). " + 'If you meant to render a collection of children, use an array ' + 'instead.');
+  }
+
+  if (typeof node === 'string') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+
+  if (typeof node === 'number') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, '' + node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+}
+
+function replayFragment(request, task, children, childIndex) {
+  // If we're supposed follow this array, we'd expect to see a ReplayNode matching
+  // this fragment.
+  const replay = task.replay;
+  const replayNodes = replay.nodes;
+
+  for (let j = 0; j < replayNodes.length; j++) {
+    const node = replayNodes[j];
+
+    if (node[1] !== childIndex) {
+      continue;
+    } // Matched a replayable path.
+
+
+    const childNodes = node[2];
+    const childSlots = node[3];
+    task.replay = {
+      nodes: childNodes,
+      slots: childSlots,
+      pendingTasks: 1
+    };
+
+    try {
+      renderChildrenArray(request, task, children, -1);
+
+      if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+        throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+      }
+
+      task.replay.pendingTasks--;
+    } catch (x) {
+      if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+        // Suspend
+        throw x;
+      }
+
+      task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+      // during a replay. That's because this component didn't actually error
+      // in the original prerender. What's unable to complete is the child
+      // replay nodes which might be Suspense boundaries which are able to
+      // absorb the error and we can still continue with siblings.
+      // This is an error, stash the component stack if it is null.
+
+      erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+    }
+
+    task.replay = replay; // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+    replayNodes.splice(j, 1);
+    break;
+  }
+}
+
+function renderChildrenArray(request, task, children, childIndex) {
+  const prevKeyPath = task.keyPath;
+
+  if (childIndex !== -1) {
+    task.keyPath = [task.keyPath, 'Fragment', childIndex];
+
+    if (task.replay !== null) {
+      replayFragment(request, // $FlowFixMe: Refined.
+      task, children, childIndex);
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  const prevTreeContext = task.treeContext;
+  const totalChildren = children.length;
+
+  if (task.replay !== null) {
+    // Replay
+    // First we need to check if we have any resume slots at this level.
+    const resumeSlots = task.replay.slots;
+
+    if (resumeSlots !== null && typeof resumeSlots === 'object') {
+      for (let i = 0; i < totalChildren; i++) {
+        const node = children[i];
+        task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+        // up and render the sibling if something suspends.
+
+        const resumeSegmentID = resumeSlots[i]; // TODO: If this errors we should still continue with the next sibling.
+
+        if (typeof resumeSegmentID === 'number') {
+          resumeNode(request, task, resumeSegmentID, node, i); // We finished rendering this node, so now we can consume this
+          // slot. This must happen after in case we rerender this task.
+
+          delete resumeSlots[i];
+        } else {
+          renderNode(request, task, node, i);
+        }
+      }
+
+      task.treeContext = prevTreeContext;
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  for (let i = 0; i < totalChildren; i++) {
+    const node = children[i];
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+    // up and render the sibling if something suspends.
+
+    renderNode(request, task, node, i);
+  } // Because this context is always set right before rendering every child, we
+  // only need to reset it to the previous value at the very end.
+
+
+  task.treeContext = prevTreeContext;
+  task.keyPath = prevKeyPath;
+}
+
+function spawnNewSuspendedReplayTask(request, task, thenableState, x) {
+  const newTask = createReplayTask(request, thenableState, task.replay, task.node, task.childIndex, task.blockedBoundary, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+}
+
+function spawnNewSuspendedRenderTask(request, task, thenableState, x) {
+  // Something suspended, we'll need to create a new segment and resolve it later.
+  const segment = task.blockedSegment;
+  const insertionIndex = segment.chunks.length;
+  const newSegment = createPendingSegment(request, insertionIndex, null, task.formatContext, // Adopt the parent segment's leading text embed
+  segment.lastPushedText, // Assume we are text embedded at the trailing edge
+  true);
+  segment.children.push(newSegment); // Reset lastPushedText for current Segment since the new Segment "consumed" it
+
+  segment.lastPushedText = false;
+  const newTask = createRenderTask(request, thenableState, task.node, task.childIndex, task.blockedBoundary, newSegment, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+} // This is a non-destructive form of rendering a node. If it suspends it spawns
+// a new task and restores the context of this task to what it was before.
+
+
+function renderNode(request, task, node, childIndex) {
+  // Snapshot the current context in case something throws to interrupt the
+  // process.
+  const previousFormatContext = task.formatContext;
+  const previousLegacyContext = task.legacyContext;
+  const previousContext = task.context;
+  const previousKeyPath = task.keyPath;
+  const previousTreeContext = task.treeContext;
+
+  let x; // Store how much we've pushed at this point so we can reset it in case something
+  // suspended partially through writing something.
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState();
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedReplayTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+      } // TODO: Abort any undiscovered Suspense boundaries in the ReplayNode.
+
+    }
+  } else {
+    // Render
+    const childrenLength = segment.children.length;
+    const chunkLength = segment.chunks.length;
+
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState(); // Reset the write pointers to where we started.
+
+      segment.children.length = childrenLength;
+      segment.chunks.length = chunkLength;
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedRenderTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+      }
+    }
+  } // Restore the context. We assume that this will be restored by the inner
+  // functions in case nothing throws so we don't use "finally" here.
+
+
+  task.formatContext = previousFormatContext;
+  task.legacyContext = previousLegacyContext;
+  task.context = previousContext;
+  task.keyPath = previousKeyPath;
+  task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+  switchContext(previousContext);
+  // Let's terminate the rest of the tree and don't render any siblings.
+
+
+  throw x;
+}
+
+function erroredReplay(request, boundary, error, replayNodes, resumeSlots) {
+  // Erroring during a replay doesn't actually cause an error by itself because
+  // that component has already rendered. What causes the error is the resumable
+  // points that we did not yet finish which will be below the point of the reset.
+  // For example, if we're replaying a path to a Suspense boundary that is not done
+  // that doesn't error the parent Suspense boundary.
+  // This might be a bit strange that the error in a parent gets thrown at a child.
+  // We log it only once and reuse the digest.
+  let errorDigest;
+
+  {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  abortRemainingReplayNodes(request, boundary, replayNodes, resumeSlots, error, errorDigest);
+}
+
+function erroredTask(request, boundary, error) {
+  // Report the error to a global handler.
+  let errorDigest;
+
+  {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  if (boundary === null) {
+    fatalError(request, error);
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+      // so we can flush it, if the parent already flushed.
+
+
+      if (boundary.parentFlushed) {
+        // We don't have a preference where in the queue this goes since it's likely
+        // to error on the client anyway. However, intentionally client-rendered
+        // boundaries should be flushed earlier so that they can start on the client.
+        // We reuse the same queue for errors.
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function abortTaskSoft(task) {
+  // This aborts task without aborting the parent boundary that it blocks.
+  // It's used for when we didn't need this task to complete the tree.
+  // If task was needed, then it should use abortTask instead.
+  const request = this;
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+    finishedTask(request, boundary, segment);
+  }
+}
+
+function abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest) {
+  const resumedBoundary = createSuspenseBoundary(request, new Set());
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = rootSegmentID;
+  resumedBoundary.status = CLIENT_RENDERED;
+  resumedBoundary.errorDigest = errorDigest;
+
+  if (resumedBoundary.parentFlushed) {
+    request.clientRenderedBoundaries.push(resumedBoundary);
+  }
+}
+
+function abortRemainingReplayNodes(request, boundary, nodes, slots, error, errorDigest) {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+
+    if (node.length === 4) {
+      abortRemainingReplayNodes(request, boundary, node[2], node[3], error, errorDigest);
+    } else {
+      const boundaryNode = node;
+      const rootSegmentID = boundaryNode[5];
+      abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest);
+    }
+  } // Empty the set, since we've cleared it now.
+
+
+  nodes.length = 0;
+
+  if (slots !== null) {
+    // We had something still to resume in the parent boundary. We must trigger
+    // the error on the parent boundary since it's not able to complete.
+    if (boundary === null) {
+      throw new Error('We should not have any resumable nodes in the shell. ' + 'This is a bug in React.');
+    } else if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // Empty the set
+
+
+    if (typeof slots === 'object') {
+      for (const index in slots) {
+        delete slots[index];
+      }
+    }
+  }
+}
+
+function abortTask(task, request, error) {
+  // This aborts the task and aborts the parent that it blocks, putting it into
+  // client rendered mode.
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+  }
+
+  if (boundary === null) {
+    if (request.status !== CLOSING && request.status !== CLOSED) {
+      const replay = task.replay;
+
+      if (replay === null) {
+        // We didn't complete the root so we have nothing to show. We can close
+        // the request;
+        logRecoverableError(request, error);
+        fatalError(request, error);
+        return;
+      } else {
+        // If the shell aborts during a replay, that's not a fatal error. Instead
+        // we should be able to recover by client rendering all the root boundaries in
+        // the ReplaySet.
+        replay.pendingTasks--;
+
+        if (replay.pendingTasks === 0 && replay.nodes.length > 0) {
+          const errorDigest = logRecoverableError(request, error);
+          abortRemainingReplayNodes(request, null, replay.nodes, replay.slots, error, errorDigest);
+        }
+
+        request.pendingRootTasks--;
+
+        if (request.pendingRootTasks === 0) {
+          completeShell(request);
+        }
+      }
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = logRecoverableError(request, error);
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // If this boundary was still pending then we haven't already cancelled its fallbacks.
+    // We'll need to abort the fallbacks, which will also error that parent boundary.
+
+
+    boundary.fallbackAbortableTasks.forEach(fallbackTask => abortTask(fallbackTask, request, error));
+    boundary.fallbackAbortableTasks.clear();
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeShell(request) {
+  if (request.trackedPostpones === null) {
+    // We only emit early preloads on shell completion for renders. For prerenders
+    // we wait for the entire Request to finish because we are not responding to a
+    // live request and can wait for as much data as possible.
+    // we should only be calling completeShell when the shell is complete so we
+    // just use a literal here
+    const shellComplete = true;
+    emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  } // We have completed the shell so the shell can't error anymore.
+
+
+  request.onShellError = noop;
+  const onShellReady = request.onShellReady;
+  onShellReady();
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeAll(request) {
+  // During a render the shell must be complete if the entire request is finished
+  // however during a Prerender it is possible that the shell is incomplete because
+  // it postponed. We cannot use rootPendingTasks in the prerender case because
+  // those hit zero even when the shell postpones. Instead we look at the completedRootSegment
+  const shellComplete = request.trackedPostpones === null ? // Render, we assume it is completed
+  true : // Prerender Request, we use the state of the root segment
+  request.completedRootSegment === null || request.completedRootSegment.status !== POSTPONED;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  const onAllReady = request.onAllReady;
+  onAllReady();
+}
+
+function queueCompletedSegment(boundary, segment) {
+  if (segment.chunks.length === 0 && segment.children.length === 1 && segment.children[0].boundary === null) {
+    // This is an empty segment. There's nothing to write, so we can instead transfer the ID
+    // to the child. That way any existing references point to the child.
+    const childSegment = segment.children[0];
+    childSegment.id = segment.id;
+    childSegment.parentFlushed = true;
+
+    if (childSegment.status === COMPLETED) {
+      queueCompletedSegment(boundary, childSegment);
+    }
+  } else {
+    const completedSegments = boundary.completedSegments;
+    completedSegments.push(segment);
+  }
+}
+
+function finishedTask(request, boundary, segment) {
+  if (boundary === null) {
+    if (segment !== null && segment.parentFlushed) {
+      if (request.completedRootSegment !== null) {
+        throw new Error('There can only be one root segment. This is a bug in React.');
+      }
+
+      request.completedRootSegment = segment;
+    }
+
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status === CLIENT_RENDERED) ; else if (boundary.pendingTasks === 0) {
+      if (boundary.status === PENDING) {
+        boundary.status = COMPLETED;
+      } // This must have been the last segment we were waiting on. This boundary is now complete.
+
+
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent segment already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+        }
+      }
+
+      if (boundary.parentFlushed) {
+        // The segment might be part of a segment that didn't flush yet, but if the boundary's
+        // parent flushed, we need to schedule the boundary to be emitted.
+        request.completedBoundaries.push(boundary);
+      } // We can now cancel any pending task on the fallback since we won't need to show it anymore.
+      // This needs to happen after we read the parentFlushed flags because aborting can finish
+      // work which can trigger user code, which can start flushing, which can change those flags.
+      // If the boundary was POSTPONED, we still need to finish the fallback first.
+
+
+      if (boundary.status === COMPLETED) {
+        boundary.fallbackAbortableTasks.forEach(abortTaskSoft, request);
+        boundary.fallbackAbortableTasks.clear();
+      }
+    } else {
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+          const completedSegments = boundary.completedSegments;
+
+          if (completedSegments.length === 1) {
+            // This is the first time since we last flushed that we completed anything.
+            // We can schedule this boundary to emit its partially completed segments early
+            // in case the parent has already been flushed.
+            if (boundary.parentFlushed) {
+              request.partialBoundaries.push(boundary);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function retryTask(request, task) {
+  {
+    const blockedBoundary = task.blockedBoundary;
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, blockedBoundary ? blockedBoundary.resources : null);
+  }
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    retryReplayTask(request, // $FlowFixMe: Refined.
+    task);
+  } else {
+    retryRenderTask(request, // $FlowFixMe: Refined.
+    task, segment);
+  }
+}
+
+function retryRenderTask(request, task, segment) {
+  if (segment.status !== PENDING) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  const childrenLength = segment.children.length;
+  const chunkLength = segment.chunks.length;
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+    pushSegmentFinale(segment.chunks, request.renderState, segment.lastPushedText, segment.textEmbedded);
+    task.abortSet.delete(task);
+    segment.status = COMPLETED;
+    finishedTask(request, task.blockedBoundary, segment);
+  } catch (thrownValue) {
+    resetHooksState(); // Reset the write pointers to where we started.
+
+    segment.children.length = childrenLength;
+    segment.chunks.length = chunkLength;
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    task.abortSet.delete(task);
+    segment.status = ERRORED;
+    erroredTask(request, task.blockedBoundary, x);
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function retryReplayTask(request, task) {
+  if (task.replay.pendingTasks === 0) {
+    // There are no pending tasks working on this set, so we must have aborted.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    finishedTask(request, task.blockedBoundary, null);
+  } catch (thrownValue) {
+    resetHooksState();
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    erroredReplay(request, task.blockedBoundary, x, task.replay.nodes, task.replay.slots);
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+
+    request.allPendingTasks--;
+
+    if (request.allPendingTasks === 0) {
+      completeAll(request);
+    }
+
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function performWork(request) {
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  const prevContext = getActiveContext();
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  let prevCacheDispatcher;
+
+  {
+    prevCacheDispatcher = ReactCurrentCache.current;
+    ReactCurrentCache.current = DefaultCacheDispatcher;
+  }
+
+  const prevRequest = currentRequest;
+  currentRequest = request;
+
+  const prevResumableState = currentResumableState;
+  setCurrentResumableState(request.resumableState);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    let i;
+
+    for (i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    pingedTasks.splice(0, i);
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    setCurrentResumableState(prevResumableState);
+    ReactCurrentDispatcher.current = prevDispatcher;
+
+    {
+      ReactCurrentCache.current = prevCacheDispatcher;
+    }
+
+    if (prevDispatcher === HooksDispatcher) {
+      // This means that we were in a reentrant work loop. This could happen
+      // in a renderer that supports synchronous work like renderToString,
+      // when it's called from within another renderer.
+      // Normally we don't bother switching the contexts to their root/default
+      // values when leaving because we'll likely need the same or similar
+      // context again. However, when we're inside a synchronous loop like this
+      // we'll to restore the context to what it was before returning.
+      switchContext(prevContext);
+    }
+
+    currentRequest = prevRequest;
+  }
+}
+
+function flushSubtree(request, destination, segment) {
+  segment.parentFlushed = true;
+
+  switch (segment.status) {
+    case PENDING:
+      {
+        // We're emitting a placeholder for this segment to be filled in later.
+        // Therefore we'll need to assign it an ID - to refer to it by.
+        segment.id = request.nextSegmentId++; // Fallthrough
+      }
+
+    case POSTPONED:
+      {
+        const segmentID = segment.id; // When this segment finally completes it won't be embedded in text since it will flush separately
+
+        segment.lastPushedText = false;
+        segment.textEmbedded = false;
+        return writePlaceholder(destination, request.renderState, segmentID);
+      }
+
+    case COMPLETED:
+      {
+        segment.status = FLUSHED;
+        let r = true;
+        const chunks = segment.chunks;
+        let chunkIdx = 0;
+        const children = segment.children;
+
+        for (let childIdx = 0; childIdx < children.length; childIdx++) {
+          const nextChild = children[childIdx]; // Write all the chunks up until the next child.
+
+          for (; chunkIdx < nextChild.index; chunkIdx++) {
+            writeChunk(destination, chunks[chunkIdx]);
+          }
+
+          r = flushSegment(request, destination, nextChild);
+        } // Finally just write all the remaining chunks
+
+
+        for (; chunkIdx < chunks.length - 1; chunkIdx++) {
+          writeChunk(destination, chunks[chunkIdx]);
+        }
+
+        if (chunkIdx < chunks.length) {
+          r = writeChunkAndReturn(destination, chunks[chunkIdx]);
+        }
+
+        return r;
+      }
+
+    default:
+      {
+        throw new Error('Aborted, errored or already flushed boundaries should not be flushed again. This is a bug in React.');
+      }
+  }
+}
+
+function flushSegment(request, destination, segment) {
+  const boundary = segment.boundary;
+
+  if (boundary === null) {
+    // Not a suspense boundary.
+    return flushSubtree(request, destination, segment);
+  }
+
+  boundary.parentFlushed = true; // This segment is a Suspense boundary. We need to decide whether to
+  // emit the content or the fallback now.
+
+  if (boundary.status === CLIENT_RENDERED) {
+    // Emit a client rendered suspense boundary wrapper.
+    // We never queue the inner boundary so we'll never emit its content or partial segments.
+    writeStartClientRenderedSuspenseBoundary(destination, request.renderState, boundary.errorDigest); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndClientRenderedSuspenseBoundary(destination, request.renderState);
+  } else if (boundary.status !== COMPLETED) {
+    if (boundary.status === PENDING) {
+      // For pending boundaries we lazily assign an ID to the boundary
+      // and root segment.
+      boundary.rootSegmentID = request.nextSegmentId++;
+    }
+
+    if (boundary.completedSegments.length > 0) {
+      // If this is at least partially complete, we can queue it to be partially emitted early.
+      request.partialBoundaries.push(boundary);
+    } // This boundary is still loading. Emit a pending suspense boundary wrapper.
+
+
+    const id = boundary.rootSegmentID;
+    writeStartPendingSuspenseBoundary(destination, request.renderState, id); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else if (boundary.byteSize > request.progressiveChunkSize) {
+    // This boundary is large and will be emitted separately so that we can progressively show
+    // other content. We add it to the queue during the flush because we have to ensure that
+    // the parent flushes first so that there's something to inject it into.
+    // We also have to make sure that it's emitted into the queue in a deterministic slot.
+    // I.e. we can't insert it here when it completes.
+    // Assign an ID to refer to the future content by.
+    boundary.rootSegmentID = request.nextSegmentId++;
+    request.completedBoundaries.push(boundary); // Emit a pending rendered suspense boundary wrapper.
+
+    writeStartPendingSuspenseBoundary(destination, request.renderState, boundary.rootSegmentID); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else {
+    {
+      hoistResources(request.renderState, boundary.resources);
+    } // We can inline this boundary's content as a complete boundary.
+
+
+    writeStartCompletedSuspenseBoundary(destination, request.renderState);
+    const completedSegments = boundary.completedSegments;
+
+    if (completedSegments.length !== 1) {
+      throw new Error('A previously unvisited boundary must have exactly one root segment. This is a bug in React.');
+    }
+
+    const contentSegment = completedSegments[0];
+    flushSegment(request, destination, contentSegment);
+    return writeEndCompletedSuspenseBoundary(destination, request.renderState);
+  }
+}
+
+function flushClientRenderedBoundary(request, destination, boundary) {
+  return writeClientRenderBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.errorDigest, boundary.errorMessage, boundary.errorComponentStack);
+}
+
+function flushSegmentContainer(request, destination, segment) {
+  writeStartSegment(destination, request.renderState, segment.parentFormatContext, segment.id);
+  flushSegment(request, destination, segment);
+  return writeEndSegment(destination, segment.parentFormatContext);
+}
+
+function flushCompletedBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+    flushPartiallyCompletedSegment(request, destination, boundary, segment);
+  }
+
+  completedSegments.length = 0;
+
+  {
+    writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+
+  return writeCompletedBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.resources);
+}
+
+function flushPartialBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+
+    if (!flushPartiallyCompletedSegment(request, destination, boundary, segment)) {
+      i++;
+      completedSegments.splice(0, i); // Only write as much as the buffer wants. Something higher priority
+      // might want to write later.
+
+      return false;
+    }
+  }
+
+  completedSegments.splice(0, i);
+
+  {
+    // The way this is structured we only write resources for partial boundaries
+    // if there is no backpressure. Later before we complete the boundary we
+    // will write resources regardless of backpressure before we emit the
+    // completion instruction
+    return writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+}
+
+function flushPartiallyCompletedSegment(request, destination, boundary, segment) {
+  if (segment.status === FLUSHED) {
+    // We've already flushed this inline.
+    return true;
+  }
+
+  const segmentID = segment.id;
+
+  if (segmentID === -1) {
+    // This segment wasn't previously referred to. This happens at the root of
+    // a boundary. We make kind of a leap here and assume this is the root.
+    const rootSegmentID = segment.id = boundary.rootSegmentID;
+
+    if (rootSegmentID === -1) {
+      throw new Error('A root segment ID must have been assigned by now. This is a bug in React.');
+    }
+
+    return flushSegmentContainer(request, destination, segment);
+  } else if (segmentID === boundary.rootSegmentID) {
+    // When we emit postponed boundaries, we might have assigned the ID already
+    // but it's still the root segment so we can't inject it into the parent yet.
+    return flushSegmentContainer(request, destination, segment);
+  } else {
+    flushSegmentContainer(request, destination, segment);
+    return writeCompletedSegmentInstruction(destination, request.resumableState, request.renderState, segmentID);
+  }
+}
+
+function flushCompletedQueues(request, destination) {
+
+  try {
+    // The structure of this is to go through each queue one by one and write
+    // until the sink tells us to stop. When we should stop, we still finish writing
+    // that item fully and then yield. At that point we remove the already completed
+    // items up until the point we completed them.
+    let i;
+    const completedRootSegment = request.completedRootSegment;
+
+    if (completedRootSegment !== null) {
+      if (completedRootSegment.status === POSTPONED) {
+        // We postponed the root, so we write nothing.
+        return;
+      } else if (request.pendingRootTasks === 0) {
+        if (enableFloat) {
+          writePreamble(destination, request.resumableState, request.renderState, request.allPendingTasks === 0 && request.trackedPostpones === null);
+        }
+
+        flushSegment(request, destination, completedRootSegment);
+        request.completedRootSegment = null;
+        writeCompletedRoot(destination, request.renderState, request.resumableState);
+      } else {
+        // We haven't flushed the root yet so we don't need to check any other branches further down
+        return;
+      }
+    }
+
+    if (enableFloat) {
+      writeHoistables(destination, request.resumableState, request.renderState);
+    } // We emit client rendering instructions for already emitted boundaries first.
+    // This is so that we can signal to the client to start client rendering them as
+    // soon as possible.
+
+
+    const clientRenderedBoundaries = request.clientRenderedBoundaries;
+
+    for (i = 0; i < clientRenderedBoundaries.length; i++) {
+      const boundary = clientRenderedBoundaries[i];
+
+      if (!flushClientRenderedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        clientRenderedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    clientRenderedBoundaries.splice(0, i); // Next we emit any complete boundaries. It's better to favor boundaries
+    // that are completely done since we can actually show them, than it is to emit
+    // any individual segments from a partially complete boundary.
+
+    const completedBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < completedBoundaries.length; i++) {
+      const boundary = completedBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        completedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    completedBoundaries.splice(0, i); // Allow anything written so far to flush to the underlying sink before
+    // we continue with lower priorities.
+
+    completeWriting(destination);
+    beginWriting(destination); // TODO: Here we'll emit data used by hydration.
+    // Next we emit any segments of any boundaries that are partially complete
+    // but not deeply complete.
+
+    const partialBoundaries = request.partialBoundaries;
+
+    for (i = 0; i < partialBoundaries.length; i++) {
+      const boundary = partialBoundaries[i];
+
+      if (!flushPartialBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        partialBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    partialBoundaries.splice(0, i); // Next we check the completed boundaries again. This may have had
+    // boundaries added to it in case they were too larged to be inlined.
+    // New ones might be added in this loop.
+
+    const largeBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < largeBoundaries.length; i++) {
+      const boundary = largeBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        largeBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    largeBoundaries.splice(0, i);
+  } finally {
+    if (request.allPendingTasks === 0 && request.pingedTasks.length === 0 && request.clientRenderedBoundaries.length === 0 && request.completedBoundaries.length === 0 // We don't need to check any partially completed segments because
+    // either they have pending task or they're complete.
+    ) {
+        request.flushScheduled = false;
+
+        {
+          // We write the trailing tags but only if don't have any data to resume.
+          // If we need to resume we'll write the postamble in the resume instead.
+          {
+            writePostamble(destination, request.resumableState);
+          }
+        }
+
+
+        close(destination); // We need to stop flowing now because we do not want any async contexts which might call
+        // float methods to initiate any flushes after this point
+
+        stopFlowing(request);
+      }
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  {
+    scheduleWork(() => performWork(request));
+  }
+
+  if (request.trackedPostpones === null) {
+    // this is either a regular render or a resume. For regular render we want
+    // to call emitEarlyPreloads after the first performWork because we want
+    // are responding to a live request and need to balance sending something early
+    // (i.e. don't want for the shell to finish) but we need something to send.
+    // The only implementation of this is for DOM at the moment and during resumes nothing
+    // actually emits but the code paths here are the same.
+    // During a prerender we don't want to be too aggressive in emitting early preloads
+    // because we aren't responding to a live request and we can wait for the prerender to
+    // postpone before we emit anything.
+    {
+      scheduleWork(() => enqueueEarlyPreloadsAfterInitialWork(request));
+    }
+  }
+}
+
+function enqueueEarlyPreloadsAfterInitialWork(request) {
+  const shellComplete = request.pendingRootTasks === 0;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    request.flushScheduled = true;
+    scheduleWork(() => {
+      // We need to existence check destination again here because it might go away
+      // in between the enqueueFlush call and the work execution
+      const destination = request.destination;
+
+      if (destination) {
+        flushCompletedQueues(request, destination);
+      } else {
+        request.flushScheduled = false;
+      }
+    });
+  }
+} // This function is intented to only be called during the pipe function for the Node builds.
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedQueues(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function stopFlowing(request) {
+  request.destination = null;
+} // This is called to early terminate a request. It puts all pending boundaries in client rendered state.
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+      abortableTasks.forEach(task => abortTask(task, request, error));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function flushResources(request) {
+  enqueueFlush(request);
+}
+function getFormState(request) {
+  return request.formState;
+}
+function getResumableState(request) {
+  return request.resumableState;
+}
+function getRenderState(request) {
+  return request.renderState;
+}
+
+function onError$1() {// Non-fatal errors are ignored.
+}
+
+function renderToStringImpl(children, options, generateStaticMarkup, abortReason) {
+  let didFatal = false;
+  let fatalError = null;
+  let result = '';
+  const destination = {
+    // $FlowFixMe[missing-local-annot]
+    push(chunk) {
+      if (chunk !== null) {
+        result += chunk;
+      }
+
+      return true;
+    },
+
+    // $FlowFixMe[missing-local-annot]
+    destroy(error) {
+      didFatal = true;
+      fatalError = error;
+    }
+
+  };
+  let readyToStream = false;
+
+  function onShellReady() {
+    readyToStream = true;
+  }
+
+  const resumableState = createResumableState(options ? options.identifierPrefix : undefined, undefined);
+  const request = createRequest(children, resumableState, createRenderState(resumableState, generateStaticMarkup), createRootFormatContext(), Infinity, onError$1, undefined, onShellReady, undefined, undefined, undefined);
+  startWork(request); // If anything suspended and is still pending, we'll abort it before writing.
+  // That way we write only client-rendered boundaries from the start.
+
+  abort(request, abortReason);
+  startFlowing(request, destination);
+
+  if (didFatal && fatalError !== abortReason) {
+    throw fatalError;
+  }
+
+  if (!readyToStream) {
+    // Note: This error message is the one we use on the client. It doesn't
+    // really make sense here. But this is the legacy server renderer, anyway.
+    // We're going to delete it soon.
+    throw new Error('A component suspended while responding to synchronous input. This ' + 'will cause the UI to be replaced with a loading indicator. To fix, ' + 'updates that suspend should be wrapped with startTransition.');
+  }
+
+  return result;
+}
+
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  subClass.__proto__ = superClass;
+}
+
+let ReactMarkupReadableStream = /*#__PURE__*/function (_Readable) {
+  _inheritsLoose(ReactMarkupReadableStream, _Readable);
+
+  function ReactMarkupReadableStream() {
+    var _this;
+
+    // Calls the stream.Readable(options) constructor. Consider exposing built-in
+    // features like highWaterMark in the future.
+    _this = _Readable.call(this, {}) || this;
+    _this.request = void 0;
+    _this.startedFlowing = void 0;
+    _this.request = null;
+    _this.startedFlowing = false;
+    return _this;
+  } // $FlowFixMe[missing-local-annot]
+
+
+  var _proto = ReactMarkupReadableStream.prototype;
+
+  _proto._destroy = function _destroy(err, callback) {
+    abort(this.request);
+    callback(err);
+  } // $FlowFixMe[missing-local-annot]
+  ;
+
+  _proto._read = function _read(size) {
+    if (this.startedFlowing) {
+      startFlowing(this.request, this);
+    }
+  };
+
+  return ReactMarkupReadableStream;
+}(stream.Readable);
+
+function onError() {// Non-fatal errors are ignored.
+}
+
+function renderToNodeStreamImpl(children, options, generateStaticMarkup) {
+  function onAllReady() {
+    // We wait until everything has loaded before starting to write.
+    // That way we only end up with fully resolved HTML even if we suspend.
+    destination.startedFlowing = true;
+    startFlowing(request, destination);
+  }
+
+  const destination = new ReactMarkupReadableStream();
+  const resumableState = createResumableState(options ? options.identifierPrefix : undefined, undefined);
+  const request = createRequest(children, resumableState, createRenderState(resumableState, false), createRootFormatContext(), Infinity, onError, onAllReady, undefined, undefined, undefined);
+  destination.request = request;
+  startWork(request);
+  return destination;
+}
+
+function renderToNodeStream(children, options) {
+
+  return renderToNodeStreamImpl(children, options);
+}
+
+function renderToStaticNodeStream(children, options) {
+  return renderToNodeStreamImpl(children, options);
+}
+
+function renderToString(children, options) {
+  return renderToStringImpl(children, options, false, 'The server used "renderToString" which does not support Suspense. If you intended for this Suspense boundary to render the fallback content on the server consider throwing an Error somewhere within the Suspense boundary. If you intended to have the server wait for the suspended component please switch to "renderToPipeableStream" which supports Suspense on the server');
+}
+
+function renderToStaticMarkup(children, options) {
+  return renderToStringImpl(children, options, true, 'The server used "renderToStaticMarkup" which does not support Suspense. If you intended to have the server wait for the suspended component please switch to "renderToPipeableStream" which supports Suspense on the server');
+}
+
+exports.renderToNodeStream = renderToNodeStream;
+exports.renderToStaticMarkup = renderToStaticMarkup;
+exports.renderToStaticNodeStream = renderToStaticNodeStream;
+exports.renderToString = renderToString;
+exports.version = ReactVersion;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.node.production.min.js b/packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.node.production.min.js
index 58baa62e18901..5af836faae567 100644
--- a/packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.node.production.min.js
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom-server-legacy.node.production.min.js
@@ -1,13 +1,11 @@
-/**
- * @license React
- * react-dom-server-legacy.node.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
 /*
+ React
+ react-dom-server-legacy.node.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
 
 
  JS Implementation of MurmurHash3 (r136) (as of May 20, 2011)
@@ -31,183 +29,188 @@
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
 */
-'use strict';var da=require("next/dist/compiled/react"),ja=require("react-dom"),ka=require("stream");
-function la(a,b){var c=a.length&3;var d=a.length-c;var e=b;for(b=0;b<d;){var f=a.charCodeAt(b)&255|(a.charCodeAt(++b)&255)<<8|(a.charCodeAt(++b)&255)<<16|(a.charCodeAt(++b)&255)<<24;++b;f=3432918353*(f&65535)+((3432918353*(f>>>16)&65535)<<16)&4294967295;f=f<<15|f>>>17;f=461845907*(f&65535)+((461845907*(f>>>16)&65535)<<16)&4294967295;e^=f;e=e<<13|e>>>19;e=5*(e&65535)+((5*(e>>>16)&65535)<<16)&4294967295;e=(e&65535)+27492+(((e>>>16)+58964&65535)<<16)}f=0;switch(c){case 3:f^=(a.charCodeAt(b+2)&255)<<
+'use strict';var aa=require("next/dist/compiled/react"),da=require("react-dom"),ja=require("stream");
+function ka(a,b){var c=a.length&3;var d=a.length-c;var e=b;for(b=0;b<d;){var f=a.charCodeAt(b)&255|(a.charCodeAt(++b)&255)<<8|(a.charCodeAt(++b)&255)<<16|(a.charCodeAt(++b)&255)<<24;++b;f=3432918353*(f&65535)+((3432918353*(f>>>16)&65535)<<16)&4294967295;f=f<<15|f>>>17;f=461845907*(f&65535)+((461845907*(f>>>16)&65535)<<16)&4294967295;e^=f;e=e<<13|e>>>19;e=5*(e&65535)+((5*(e>>>16)&65535)<<16)&4294967295;e=(e&65535)+27492+(((e>>>16)+58964&65535)<<16)}f=0;switch(c){case 3:f^=(a.charCodeAt(b+2)&255)<<
 16;case 2:f^=(a.charCodeAt(b+1)&255)<<8;case 1:f^=a.charCodeAt(b)&255,f=3432918353*(f&65535)+((3432918353*(f>>>16)&65535)<<16)&4294967295,f=f<<15|f>>>17,e^=461845907*(f&65535)+((461845907*(f>>>16)&65535)<<16)&4294967295}e^=a.length;e^=e>>>16;e=2246822507*(e&65535)+((2246822507*(e>>>16)&65535)<<16)&4294967295;e^=e>>>13;e=3266489909*(e&65535)+((3266489909*(e>>>16)&65535)<<16)&4294967295;return(e^e>>>16)>>>0}
-var r=Object.assign,u=Object.prototype.hasOwnProperty,ya=RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"),za={},Aa={};
-function Ba(a){if(u.call(Aa,a))return!0;if(u.call(za,a))return!1;if(ya.test(a))return Aa[a]=!0;za[a]=!0;return!1}
-var Ca=new Set("animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp".split(" ")),Ia=
+var r=Object.assign,x=Object.prototype.hasOwnProperty,la=RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"),ya={},za={};
+function Aa(a){if(x.call(za,a))return!0;if(x.call(ya,a))return!1;if(la.test(a))return za[a]=!0;ya[a]=!0;return!1}
+var Ba=new Set("animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp".split(" ")),Ca=
 new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv","http-equiv"],["crossOrigin","crossorigin"],["accentHeight","accent-height"],["alignmentBaseline","alignment-baseline"],["arabicForm","arabic-form"],["baselineShift","baseline-shift"],["capHeight","cap-height"],["clipPath","clip-path"],["clipRule","clip-rule"],["colorInterpolation","color-interpolation"],["colorInterpolationFilters","color-interpolation-filters"],["colorProfile","color-profile"],["colorRendering","color-rendering"],
 ["dominantBaseline","dominant-baseline"],["enableBackground","enable-background"],["fillOpacity","fill-opacity"],["fillRule","fill-rule"],["floodColor","flood-color"],["floodOpacity","flood-opacity"],["fontFamily","font-family"],["fontSize","font-size"],["fontSizeAdjust","font-size-adjust"],["fontStretch","font-stretch"],["fontStyle","font-style"],["fontVariant","font-variant"],["fontWeight","font-weight"],["glyphName","glyph-name"],["glyphOrientationHorizontal","glyph-orientation-horizontal"],["glyphOrientationVertical",
 "glyph-orientation-vertical"],["horizAdvX","horiz-adv-x"],["horizOriginX","horiz-origin-x"],["imageRendering","image-rendering"],["letterSpacing","letter-spacing"],["lightingColor","lighting-color"],["markerEnd","marker-end"],["markerMid","marker-mid"],["markerStart","marker-start"],["overlinePosition","overline-position"],["overlineThickness","overline-thickness"],["paintOrder","paint-order"],["panose-1","panose-1"],["pointerEvents","pointer-events"],["renderingIntent","rendering-intent"],["shapeRendering",
 "shape-rendering"],["stopColor","stop-color"],["stopOpacity","stop-opacity"],["strikethroughPosition","strikethrough-position"],["strikethroughThickness","strikethrough-thickness"],["strokeDasharray","stroke-dasharray"],["strokeDashoffset","stroke-dashoffset"],["strokeLinecap","stroke-linecap"],["strokeLinejoin","stroke-linejoin"],["strokeMiterlimit","stroke-miterlimit"],["strokeOpacity","stroke-opacity"],["strokeWidth","stroke-width"],["textAnchor","text-anchor"],["textDecoration","text-decoration"],
 ["textRendering","text-rendering"],["transformOrigin","transform-origin"],["underlinePosition","underline-position"],["underlineThickness","underline-thickness"],["unicodeBidi","unicode-bidi"],["unicodeRange","unicode-range"],["unitsPerEm","units-per-em"],["vAlphabetic","v-alphabetic"],["vHanging","v-hanging"],["vIdeographic","v-ideographic"],["vMathematical","v-mathematical"],["vectorEffect","vector-effect"],["vertAdvY","vert-adv-y"],["vertOriginX","vert-origin-x"],["vertOriginY","vert-origin-y"],
-["wordSpacing","word-spacing"],["writingMode","writing-mode"],["xmlnsXlink","xmlns:xlink"],["xHeight","x-height"]]),Ja=/["'&<>]/;
-function v(a){if("boolean"===typeof a||"number"===typeof a)return""+a;a=""+a;var b=Ja.exec(a);if(b){var c="",d,e=0;for(d=b.index;d<a.length;d++){switch(a.charCodeAt(d)){case 34:b="&quot;";break;case 38:b="&amp;";break;case 39:b="&#x27;";break;case 60:b="&lt;";break;case 62:b="&gt;";break;default:continue}e!==d&&(c+=a.slice(e,d));e=d+1;c+=b}a=e!==d?c+a.slice(e,d):c}return a}
-var Ka=/([A-Z])/g,La=/^ms-/,Ma=Array.isArray,Na=da.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,Oa={pending:!1,data:null,method:null,action:null},eb=ja.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Dispatcher,mb={prefetchDNS:fb,preconnect:gb,preload:hb,preloadModule:ib,preinitStyle:jb,preinitScript:kb,preinitModuleScript:lb},x=[];
-function nb(a,b){var c=0;void 0!==b&&(c=1);return{idPrefix:void 0===a?"":a,nextFormID:0,streamingFormat:c,instructions:0,hasBody:!1,hasHtml:!1,unknownResources:{},dnsResources:{},connectResources:{default:{},anonymous:{},credentials:{}},imageResources:{},styleResources:{},scriptResources:{},moduleUnknownResources:{},moduleScriptResources:{}}}function C(a,b,c){return{insertionMode:a,selectedValue:b,tagScope:c}}
-function ob(a){return C("http://www.w3.org/2000/svg"===a?3:"http://www.w3.org/1998/Math/MathML"===a?4:0,null,0)}
-function pb(a,b,c){switch(b){case "noscript":return C(2,null,a.tagScope|1);case "select":return C(2,null!=c.value?c.value:c.defaultValue,a.tagScope);case "svg":return C(3,null,a.tagScope);case "picture":return C(2,null,a.tagScope|2);case "math":return C(4,null,a.tagScope);case "foreignObject":return C(2,null,a.tagScope);case "table":return C(5,null,a.tagScope);case "thead":case "tbody":case "tfoot":return C(6,null,a.tagScope);case "colgroup":return C(8,null,a.tagScope);case "tr":return C(7,null,a.tagScope)}return 5<=
-a.insertionMode?C(2,null,a.tagScope):0===a.insertionMode?"html"===b?C(1,null,a.tagScope):C(2,null,a.tagScope):1===a.insertionMode?C(2,null,a.tagScope):a}var zb=new Map;
-function Ab(a,b){if("object"!==typeof b)throw Error("The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + 'em'}} when using JSX.");var c=!0,d;for(d in b)if(u.call(b,d)){var e=b[d];if(null!=e&&"boolean"!==typeof e&&""!==e){if(0===d.indexOf("--")){var f=v(d);e=v((""+e).trim())}else f=zb.get(d),void 0===f&&(f=v(d.replace(Ka,"-$1").toLowerCase().replace(La,"-ms-")),zb.set(d,f)),e="number"===typeof e?0===e||Ca.has(d)?""+e:e+"px":
-v((""+e).trim());c?(c=!1,a.push(' style="',f,":",e)):a.push(";",f,":",e)}}c||a.push('"')}function Bb(a,b,c){c&&"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'=""')}function D(a,b,c){"function"!==typeof c&&"symbol"!==typeof c&&"boolean"!==typeof c&&a.push(" ",b,'="',v(c),'"')}function Cb(a){var b=a.nextFormID++;return a.idPrefix+b}var Db=v("javascript:throw new Error('A React form was unexpectedly submitted.')");
-function Eb(a,b){this.push('<input type="hidden"');if("string"!==typeof a)throw Error("File/Blob fields are not yet supported in progressive forms. It probably means you are closing over binary data or FormData in a Server Action.");D(this,"name",b);D(this,"value",a);this.push("/>")}
-function Fb(a,b,c,d,e,f,g,h){var k=null;"function"===typeof d&&("function"===typeof d.$$FORM_ACTION?(e=Cb(b),b=d.$$FORM_ACTION(e),h=b.name,d=b.action||"",e=b.encType,f=b.method,g=b.target,k=b.data):(a.push(" ","formAction",'="',Db,'"'),g=f=e=d=h=null,Gb(b,c)));null!=h&&E(a,"name",h);null!=d&&E(a,"formAction",d);null!=e&&E(a,"formEncType",e);null!=f&&E(a,"formMethod",f);null!=g&&E(a,"formTarget",g);return k}
-function E(a,b,c){switch(b){case "className":D(a,"class",c);break;case "tabIndex":D(a,"tabindex",c);break;case "dir":case "role":case "viewBox":case "width":case "height":D(a,b,c);break;case "style":Ab(a,c);break;case "src":case "href":case "action":case "formAction":if(null==c||"function"===typeof c||"symbol"===typeof c||"boolean"===typeof c)break;a.push(" ",b,'="',v(""+c),'"');break;case "defaultValue":case "defaultChecked":case "innerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":break;
-case "autoFocus":case "multiple":case "muted":Bb(a,b.toLowerCase(),c);break;case "xlinkHref":if("function"===typeof c||"symbol"===typeof c||"boolean"===typeof c)break;a.push(" ","xlink:href",'="',v(""+c),'"');break;case "contentEditable":case "spellCheck":case "draggable":case "value":case "autoReverse":case "externalResourcesRequired":case "focusable":case "preserveAlpha":"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'="',v(c),'"');break;case "allowFullScreen":case "async":case "autoPlay":case "controls":case "default":case "defer":case "disabled":case "disablePictureInPicture":case "disableRemotePlayback":case "formNoValidate":case "hidden":case "loop":case "noModule":case "noValidate":case "open":case "playsInline":case "readOnly":case "required":case "reversed":case "scoped":case "seamless":case "itemScope":c&&
-"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'=""');break;case "capture":case "download":!0===c?a.push(" ",b,'=""'):!1!==c&&"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'="',v(c),'"');break;case "cols":case "rows":case "size":case "span":"function"!==typeof c&&"symbol"!==typeof c&&!isNaN(c)&&1<=c&&a.push(" ",b,'="',v(c),'"');break;case "rowSpan":case "start":"function"===typeof c||"symbol"===typeof c||isNaN(c)||a.push(" ",b,'="',v(c),'"');break;case "xlinkActuate":D(a,"xlink:actuate",
-c);break;case "xlinkArcrole":D(a,"xlink:arcrole",c);break;case "xlinkRole":D(a,"xlink:role",c);break;case "xlinkShow":D(a,"xlink:show",c);break;case "xlinkTitle":D(a,"xlink:title",c);break;case "xlinkType":D(a,"xlink:type",c);break;case "xmlBase":D(a,"xml:base",c);break;case "xmlLang":D(a,"xml:lang",c);break;case "xmlSpace":D(a,"xml:space",c);break;default:if(!(2<b.length)||"o"!==b[0]&&"O"!==b[0]||"n"!==b[1]&&"N"!==b[1])if(b=Ia.get(b)||b,Ba(b)){switch(typeof c){case "function":case "symbol":return;
-case "boolean":var d=b.toLowerCase().slice(0,5);if("data-"!==d&&"aria-"!==d)return}a.push(" ",b,'="',v(c),'"')}}}function I(a,b,c){if(null!=b){if(null!=c)throw Error("Can only set one of `children` or `props.dangerouslySetInnerHTML`.");if("object"!==typeof b||!("__html"in b))throw Error("`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://reactjs.org/link/dangerously-set-inner-html for more information.");b=b.__html;null!==b&&void 0!==b&&a.push(""+b)}}
-function Hb(a){var b="";da.Children.forEach(a,function(c){null!=c&&(b+=c)});return b}
-function Gb(a,b){0!==(a.instructions&16)||b.externalRuntimeScript||(a.instructions|=16,b.bootstrapChunks.unshift(b.startInlineScript,'addEventListener("submit",function(a){if(!a.defaultPrevented){var c=a.target,d=a.submitter,e=c.action,b=d;if(d){var f=d.getAttribute("formAction");null!=f&&(e=f,b=null)}"javascript:throw new Error(\'A React form was unexpectedly submitted.\')"===e&&(a.preventDefault(),b?(a=document.createElement("input"),a.name=b.name,a.value=b.value,b.parentNode.insertBefore(a,b),b=new FormData(c),a.parentNode.removeChild(a)):b=new FormData(c),a=c.getRootNode(),(a.$$reactFormReplay=a.$$reactFormReplay||[]).push(c,\nd,b))}});',"\x3c/script>"))}
-function Ib(a,b,c,d,e,f,g){var h=b.rel,k=b.href,l=b.precedence;if(3===f||g||null!=b.itemProp||"string"!==typeof h||"string"!==typeof k||""===k)return J(a,b),null;if("stylesheet"===b.rel){if("string"!==typeof l||null!=b.disabled||b.onLoad||b.onError)return J(a,b);f=d.styles.get(l);g=c.styleResources.hasOwnProperty(k)?c.styleResources[k]:void 0;null!==g?(c.styleResources[k]=null,f||(f={precedence:v(l),rules:[],hrefs:[],sheets:new Map},d.styles.set(l,f)),b={state:0,props:r({},b,{"data-precedence":b.precedence,
-precedence:null})},g&&(2===g.length&&Jb(b.props,g),(c=d.preloads.stylesheets.get(k))&&0<c.length?c.length=0:b.state=1),f.sheets.set(k,b),d.boundaryResources&&d.boundaryResources.stylesheets.add(b)):f&&(k=f.sheets.get(k))&&d.boundaryResources&&d.boundaryResources.stylesheets.add(k);e&&a.push("\x3c!-- --\x3e");return null}if(b.onLoad||b.onError)return J(a,b);e&&a.push("\x3c!-- --\x3e");switch(b.rel){case "preconnect":case "dns-prefetch":return J(d.preconnectChunks,b);case "preload":return J(d.preloadChunks,
-b);default:return J(d.hoistableChunks,b)}}function J(a,b){a.push(K("link"));for(var c in b)if(u.call(b,c)){var d=b[c];if(null!=d)switch(c){case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");default:E(a,c,d)}}a.push("/>");return null}
-function Kb(a,b,c){a.push(K(c));for(var d in b)if(u.call(b,d)){var e=b[d];if(null!=e)switch(d){case "children":case "dangerouslySetInnerHTML":throw Error(c+" is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");default:E(a,d,e)}}a.push("/>");return null}
-function Lb(a,b){a.push(K("title"));var c=null,d=null,e;for(e in b)if(u.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:E(a,e,f)}}a.push(">");b=Array.isArray(c)?2>c.length?c[0]:null:c;"function"!==typeof b&&"symbol"!==typeof b&&null!==b&&void 0!==b&&a.push(v(""+b));I(a,d,c);a.push(Mb("title"));return null}
-function Nb(a,b){a.push(K("script"));var c=null,d=null,e;for(e in b)if(u.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:E(a,e,f)}}a.push(">");I(a,d,c);"string"===typeof c&&a.push(v(c));a.push(Mb("script"));return null}
-function Ob(a,b,c){a.push(K(c));var d=c=null,e;for(e in b)if(u.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:E(a,e,f)}}a.push(">");I(a,d,c);return"string"===typeof c?(a.push(v(c)),null):c}var Pb=/^[a-zA-Z][a-zA-Z:_\.\-\d]*$/,Qb=new Map;function K(a){var b=Qb.get(a);if(void 0===b){if(!Pb.test(a))throw Error("Invalid tag: "+a);b="<"+a;Qb.set(a,b)}return b}
-function Rb(a,b,c,d,e,f,g){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "select":a.push(K("select"));var h=null,k=null,l;for(l in c)if(u.call(c,l)){var n=c[l];if(null!=n)switch(l){case "children":h=n;break;case "dangerouslySetInnerHTML":k=n;break;case "defaultValue":case "value":break;default:E(a,l,n)}}a.push(">");I(a,k,h);return h;case "option":var q=f.selectedValue;a.push(K("option"));var m=null,F=null,z=null,S=null,t;for(t in c)if(u.call(c,
-t)){var y=c[t];if(null!=y)switch(t){case "children":m=y;break;case "selected":z=y;break;case "dangerouslySetInnerHTML":S=y;break;case "value":F=y;default:E(a,t,y)}}if(null!=q){var p=null!==F?""+F:Hb(m);if(Ma(q))for(var Z=0;Z<q.length;Z++){if(""+q[Z]===p){a.push(' selected=""');break}}else""+q===p&&a.push(' selected=""')}else z&&a.push(' selected=""');a.push(">");I(a,S,m);return m;case "textarea":a.push(K("textarea"));var G=null,aa=null,A=null,L;for(L in c)if(u.call(c,L)){var w=c[L];if(null!=w)switch(L){case "children":A=
-w;break;case "value":G=w;break;case "defaultValue":aa=w;break;case "dangerouslySetInnerHTML":throw Error("`dangerouslySetInnerHTML` does not make sense on <textarea>.");default:E(a,L,w)}}null===G&&null!==aa&&(G=aa);a.push(">");if(null!=A){if(null!=G)throw Error("If you supply `defaultValue` on a <textarea>, do not pass children.");if(Ma(A)){if(1<A.length)throw Error("<textarea> can only have at most one child.");G=""+A[0]}G=""+A}"string"===typeof G&&"\n"===G[0]&&a.push("\n");null!==G&&a.push(v(""+
-G));return null;case "input":a.push(K("input"));var ea=null,Q=null,M=null,ma=null,fa=null,V=null,Pa=null,Qa=null,Ra=null,na;for(na in c)if(u.call(c,na)){var O=c[na];if(null!=O)switch(na){case "children":case "dangerouslySetInnerHTML":throw Error("input is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");case "name":ea=O;break;case "formAction":Q=O;break;case "formEncType":M=O;break;case "formMethod":ma=O;break;case "formTarget":fa=O;break;case "defaultChecked":Ra=
-O;break;case "defaultValue":Pa=O;break;case "checked":Qa=O;break;case "value":V=O;break;default:E(a,na,O)}}var qb=Fb(a,d,e,Q,M,ma,fa,ea);null!==Qa?Bb(a,"checked",Qa):null!==Ra&&Bb(a,"checked",Ra);null!==V?E(a,"value",V):null!==Pa&&E(a,"value",Pa);a.push("/>");null!==qb&&qb.forEach(Eb,a);return null;case "button":a.push(K("button"));var oa=null,pa=null,ba=null,qa=null,ra=null,Sa=null,sa=null,Ta;for(Ta in c)if(u.call(c,Ta)){var ca=c[Ta];if(null!=ca)switch(Ta){case "children":oa=ca;break;case "dangerouslySetInnerHTML":pa=
-ca;break;case "name":ba=ca;break;case "formAction":qa=ca;break;case "formEncType":ra=ca;break;case "formMethod":Sa=ca;break;case "formTarget":sa=ca;break;default:E(a,Ta,ca)}}var Oc=Fb(a,d,e,qa,ra,Sa,sa,ba);a.push(">");null!==Oc&&Oc.forEach(Eb,a);I(a,pa,oa);if("string"===typeof oa){a.push(v(oa));var Pc=null}else Pc=oa;return Pc;case "form":a.push(K("form"));var Ua=null,Qc=null,ha=null,Va=null,Wa=null,Xa=null,Ya;for(Ya in c)if(u.call(c,Ya)){var ia=c[Ya];if(null!=ia)switch(Ya){case "children":Ua=ia;
-break;case "dangerouslySetInnerHTML":Qc=ia;break;case "action":ha=ia;break;case "encType":Va=ia;break;case "method":Wa=ia;break;case "target":Xa=ia;break;default:E(a,Ya,ia)}}var Wb=null,Xb=null;if("function"===typeof ha)if("function"===typeof ha.$$FORM_ACTION){var xe=Cb(d),Da=ha.$$FORM_ACTION(xe);ha=Da.action||"";Va=Da.encType;Wa=Da.method;Xa=Da.target;Wb=Da.data;Xb=Da.name}else a.push(" ","action",'="',Db,'"'),Xa=Wa=Va=ha=null,Gb(d,e);null!=ha&&E(a,"action",ha);null!=Va&&E(a,"encType",Va);null!=
-Wa&&E(a,"method",Wa);null!=Xa&&E(a,"target",Xa);a.push(">");null!==Xb&&(a.push('<input type="hidden"'),D(a,"name",Xb),a.push("/>"),null!==Wb&&Wb.forEach(Eb,a));I(a,Qc,Ua);if("string"===typeof Ua){a.push(v(Ua));var Rc=null}else Rc=Ua;return Rc;case "menuitem":a.push(K("menuitem"));for(var rb in c)if(u.call(c,rb)){var Sc=c[rb];if(null!=Sc)switch(rb){case "children":case "dangerouslySetInnerHTML":throw Error("menuitems cannot have `children` nor `dangerouslySetInnerHTML`.");default:E(a,rb,Sc)}}a.push(">");
-return null;case "title":if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp)var Tc=Lb(a,c);else Lb(e.hoistableChunks,c),Tc=null;return Tc;case "link":return Ib(a,c,d,e,g,f.insertionMode,!!(f.tagScope&1));case "script":var Yb=c.async;if("string"!==typeof c.src||!c.src||!Yb||"function"===typeof Yb||"symbol"===typeof Yb||c.onLoad||c.onError||3===f.insertionMode||f.tagScope&1||null!=c.itemProp)var Uc=Nb(a,c);else{var sb=c.src;if("module"===c.type){var tb=d.moduleScriptResources;var Vc=e.preloads.moduleScripts}else tb=
-d.scriptResources,Vc=e.preloads.scripts;var ub=tb.hasOwnProperty(sb)?tb[sb]:void 0;if(null!==ub){tb[sb]=null;var Zb=c;if(ub){2===ub.length&&(Zb=r({},c),Jb(Zb,ub));var Wc=Vc.get(sb);Wc&&(Wc.length=0)}var Xc=[];e.scripts.add(Xc);Nb(Xc,Zb)}g&&a.push("\x3c!-- --\x3e");Uc=null}return Uc;case "style":var vb=c.precedence,ta=c.href;if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp||"string"!==typeof vb||"string"!==typeof ta||""===ta){a.push(K("style"));var Ea=null,Yc=null,Za;for(Za in c)if(u.call(c,
-Za)){var wb=c[Za];if(null!=wb)switch(Za){case "children":Ea=wb;break;case "dangerouslySetInnerHTML":Yc=wb;break;default:E(a,Za,wb)}}a.push(">");var $a=Array.isArray(Ea)?2>Ea.length?Ea[0]:null:Ea;"function"!==typeof $a&&"symbol"!==typeof $a&&null!==$a&&void 0!==$a&&a.push(v(""+$a));I(a,Yc,Ea);a.push(Mb("style"));var Zc=null}else{var ua=e.styles.get(vb);if(null!==(d.styleResources.hasOwnProperty(ta)?d.styleResources[ta]:void 0)){d.styleResources[ta]=null;ua?ua.hrefs.push(v(ta)):(ua={precedence:v(vb),
-rules:[],hrefs:[v(ta)],sheets:new Map},e.styles.set(vb,ua));var $c=ua.rules,Fa=null,ad=null,xb;for(xb in c)if(u.call(c,xb)){var $b=c[xb];if(null!=$b)switch(xb){case "children":Fa=$b;break;case "dangerouslySetInnerHTML":ad=$b}}var ab=Array.isArray(Fa)?2>Fa.length?Fa[0]:null:Fa;"function"!==typeof ab&&"symbol"!==typeof ab&&null!==ab&&void 0!==ab&&$c.push(v(""+ab));I($c,ad,Fa)}ua&&e.boundaryResources&&e.boundaryResources.styles.add(ua);g&&a.push("\x3c!-- --\x3e");Zc=void 0}return Zc;case "meta":if(3===
-f.insertionMode||f.tagScope&1||null!=c.itemProp)var bd=Kb(a,c,"meta");else g&&a.push("\x3c!-- --\x3e"),bd="string"===typeof c.charSet?Kb(e.charsetChunks,c,"meta"):"viewport"===c.name?Kb(e.preconnectChunks,c,"meta"):Kb(e.hoistableChunks,c,"meta");return bd;case "listing":case "pre":a.push(K(b));var bb=null,cb=null,db;for(db in c)if(u.call(c,db)){var yb=c[db];if(null!=yb)switch(db){case "children":bb=yb;break;case "dangerouslySetInnerHTML":cb=yb;break;default:E(a,db,yb)}}a.push(">");if(null!=cb){if(null!=
-bb)throw Error("Can only set one of `children` or `props.dangerouslySetInnerHTML`.");if("object"!==typeof cb||!("__html"in cb))throw Error("`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://reactjs.org/link/dangerously-set-inner-html for more information.");var va=cb.__html;null!==va&&void 0!==va&&("string"===typeof va&&0<va.length&&"\n"===va[0]?a.push("\n",va):a.push(""+va))}"string"===typeof bb&&"\n"===bb[0]&&a.push("\n");return bb;case "img":var H=c.src,
-B=c.srcSet;if(!("lazy"===c.loading||!H&&!B||"string"!==typeof H&&null!=H||"string"!==typeof B&&null!=B)&&"low"!==c.fetchPriority&&!1===!!(f.tagScope&2)&&("string"!==typeof H||":"!==H[4]||"d"!==H[0]&&"D"!==H[0]||"a"!==H[1]&&"A"!==H[1]||"t"!==H[2]&&"T"!==H[2]||"a"!==H[3]&&"A"!==H[3])&&("string"!==typeof B||":"!==B[4]||"d"!==B[0]&&"D"!==B[0]||"a"!==B[1]&&"A"!==B[1]||"t"!==B[2]&&"T"!==B[2]||"a"!==B[3]&&"A"!==B[3])){var cd="string"===typeof c.sizes?c.sizes:void 0,Ga=B?B+"\n"+(cd||""):H,ac=e.preloads.images,
-wa=ac.get(Ga);if(wa){if("high"===c.fetchPriority||10>e.highImagePreloads.size)ac.delete(Ga),e.highImagePreloads.add(wa)}else if(!d.imageResources.hasOwnProperty(Ga)){d.imageResources[Ga]=x;var bc=c.crossOrigin;var dd="string"===typeof bc?"use-credentials"===bc?bc:"":void 0;var W=e.headers,cc;W&&0<W.remainingCapacity&&("high"===c.fetchPriority||500>W.highImagePreloads.length)&&(cc=Sb(H,"image",{imageSrcSet:c.srcSet,imageSizes:c.sizes,crossOrigin:dd,integrity:c.integrity,nonce:c.nonce,type:c.type,fetchPriority:c.fetchPriority,
-referrerPolicy:c.refererPolicy}),2<=(W.remainingCapacity-=cc.length))?(e.resets.image[Ga]=x,W.highImagePreloads&&(W.highImagePreloads+=", "),W.highImagePreloads+=cc):(wa=[],J(wa,{rel:"preload",as:"image",href:B?void 0:H,imageSrcSet:B,imageSizes:cd,crossOrigin:dd,integrity:c.integrity,type:c.type,fetchPriority:c.fetchPriority,referrerPolicy:c.referrerPolicy}),"high"===c.fetchPriority||10>e.highImagePreloads.size?e.highImagePreloads.add(wa):(e.bulkPreloads.add(wa),ac.set(Ga,wa)))}}return Kb(a,c,"img");
-case "base":case "area":case "br":case "col":case "embed":case "hr":case "keygen":case "param":case "source":case "track":case "wbr":return Kb(a,c,b);case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph":break;case "head":if(2>f.insertionMode&&null===e.headChunks){e.headChunks=[];var ed=Ob(e.headChunks,c,"head")}else ed=Ob(a,c,"head");return ed;case "html":if(0===f.insertionMode&&null===
-e.htmlChunks){e.htmlChunks=[""];var fd=Ob(e.htmlChunks,c,"html")}else fd=Ob(a,c,"html");return fd;default:if(-1!==b.indexOf("-")){a.push(K(b));var dc=null,gd=null,Ha;for(Ha in c)if(u.call(c,Ha)){var xa=c[Ha];if(null!=xa){var ye=Ha;switch(Ha){case "children":dc=xa;break;case "dangerouslySetInnerHTML":gd=xa;break;case "style":Ab(a,xa);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":break;default:Ba(Ha)&&"function"!==typeof xa&&"symbol"!==typeof xa&&a.push(" ",ye,'="',v(xa),
-'"')}}}a.push(">");I(a,gd,dc);return dc}}return Ob(a,c,b)}var Tb=new Map;function Mb(a){var b=Tb.get(a);void 0===b&&(b="</"+a+">",Tb.set(a,b));return b}function Ub(a,b){b=b.bootstrapChunks;for(var c=0;c<b.length-1;c++)a.push(b[c]);return c<b.length?(c=b[c],b.length=0,a.push(c)):!0}
-function Vb(a,b,c){a.push('\x3c!--$?--\x3e<template id="');if(null===c)throw Error("An ID must have been assigned before we can complete the boundary.");a.push(b.boundaryPrefix);b=c.toString(16);a.push(b);return a.push('"></template>')}
-function ec(a,b,c,d){switch(c.insertionMode){case 0:case 1:case 2:return a.push('<div hidden id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 3:return a.push('<svg aria-hidden="true" style="display:none" id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 4:return a.push('<math aria-hidden="true" style="display:none" id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 5:return a.push('<table hidden id="'),a.push(b.segmentPrefix),
+["wordSpacing","word-spacing"],["writingMode","writing-mode"],["xmlnsXlink","xmlns:xlink"],["xHeight","x-height"]]),Ia=/["'&<>]/;
+function y(a){if("boolean"===typeof a||"number"===typeof a)return""+a;a=""+a;var b=Ia.exec(a);if(b){var c="",d,e=0;for(d=b.index;d<a.length;d++){switch(a.charCodeAt(d)){case 34:b="&quot;";break;case 38:b="&amp;";break;case 39:b="&#x27;";break;case 60:b="&lt;";break;case 62:b="&gt;";break;default:continue}e!==d&&(c+=a.slice(e,d));e=d+1;c+=b}a=e!==d?c+a.slice(e,d):c}return a}
+var Ja=/([A-Z])/g,Ka=/^ms-/,La=Array.isArray,Ma=aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,Na={pending:!1,data:null,method:null,action:null},Oa=da.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Dispatcher,lb={prefetchDNS:eb,preconnect:fb,preload:gb,preloadModule:hb,preinitStyle:ib,preinitScript:jb,preinitModuleScript:kb},A=[],mb=/(<\/|<)(s)(cript)/gi;function nb(a,b,c,d){return""+b+("s"===c?"\\u0073":"\\u0053")+d}
+function ob(a,b,c,d,e){var f=0;void 0!==b&&(f=1);return{idPrefix:void 0===a?"":a,nextFormID:0,streamingFormat:f,bootstrapScriptContent:c,bootstrapScripts:d,bootstrapModules:e,instructions:0,hasBody:!1,hasHtml:!1,unknownResources:{},dnsResources:{},connectResources:{default:{},anonymous:{},credentials:{}},imageResources:{},styleResources:{},scriptResources:{},moduleUnknownResources:{},moduleScriptResources:{}}}function D(a,b,c){return{insertionMode:a,selectedValue:b,tagScope:c}}
+function pb(a){return D("http://www.w3.org/2000/svg"===a?3:"http://www.w3.org/1998/Math/MathML"===a?4:0,null,0)}
+function zb(a,b,c){switch(b){case "noscript":return D(2,null,a.tagScope|1);case "select":return D(2,null!=c.value?c.value:c.defaultValue,a.tagScope);case "svg":return D(3,null,a.tagScope);case "picture":return D(2,null,a.tagScope|2);case "math":return D(4,null,a.tagScope);case "foreignObject":return D(2,null,a.tagScope);case "table":return D(5,null,a.tagScope);case "thead":case "tbody":case "tfoot":return D(6,null,a.tagScope);case "colgroup":return D(8,null,a.tagScope);case "tr":return D(7,null,a.tagScope)}return 5<=
+a.insertionMode?D(2,null,a.tagScope):0===a.insertionMode?"html"===b?D(1,null,a.tagScope):D(2,null,a.tagScope):1===a.insertionMode?D(2,null,a.tagScope):a}var Ab=new Map;
+function Bb(a,b){if("object"!==typeof b)throw Error("The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + 'em'}} when using JSX.");var c=!0,d;for(d in b)if(x.call(b,d)){var e=b[d];if(null!=e&&"boolean"!==typeof e&&""!==e){if(0===d.indexOf("--")){var f=y(d);e=y((""+e).trim())}else f=Ab.get(d),void 0===f&&(f=y(d.replace(Ja,"-$1").toLowerCase().replace(Ka,"-ms-")),Ab.set(d,f)),e="number"===typeof e?0===e||Ba.has(d)?""+e:e+"px":
+y((""+e).trim());c?(c=!1,a.push(' style="',f,":",e)):a.push(";",f,":",e)}}c||a.push('"')}function Cb(a,b,c){c&&"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'=""')}function H(a,b,c){"function"!==typeof c&&"symbol"!==typeof c&&"boolean"!==typeof c&&a.push(" ",b,'="',y(c),'"')}function Db(a){var b=a.nextFormID++;return a.idPrefix+b}var Eb=y("javascript:throw new Error('A React form was unexpectedly submitted.')");
+function Fb(a,b){this.push('<input type="hidden"');if("string"!==typeof a)throw Error("File/Blob fields are not yet supported in progressive forms. It probably means you are closing over binary data or FormData in a Server Action.");H(this,"name",b);H(this,"value",a);this.push("/>")}
+function Gb(a,b,c,d,e,f,g,h){var k=null;"function"===typeof d&&("function"===typeof d.$$FORM_ACTION?(e=Db(b),b=d.$$FORM_ACTION(e),h=b.name,d=b.action||"",e=b.encType,f=b.method,g=b.target,k=b.data):(a.push(" ","formAction",'="',Eb,'"'),g=f=e=d=h=null,Hb(b,c)));null!=h&&I(a,"name",h);null!=d&&I(a,"formAction",d);null!=e&&I(a,"formEncType",e);null!=f&&I(a,"formMethod",f);null!=g&&I(a,"formTarget",g);return k}
+function I(a,b,c){switch(b){case "className":H(a,"class",c);break;case "tabIndex":H(a,"tabindex",c);break;case "dir":case "role":case "viewBox":case "width":case "height":H(a,b,c);break;case "style":Bb(a,c);break;case "src":case "href":case "action":case "formAction":if(null==c||"function"===typeof c||"symbol"===typeof c||"boolean"===typeof c)break;a.push(" ",b,'="',y(""+c),'"');break;case "defaultValue":case "defaultChecked":case "innerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":break;
+case "autoFocus":case "multiple":case "muted":Cb(a,b.toLowerCase(),c);break;case "xlinkHref":if("function"===typeof c||"symbol"===typeof c||"boolean"===typeof c)break;a.push(" ","xlink:href",'="',y(""+c),'"');break;case "contentEditable":case "spellCheck":case "draggable":case "value":case "autoReverse":case "externalResourcesRequired":case "focusable":case "preserveAlpha":"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'="',y(c),'"');break;case "allowFullScreen":case "async":case "autoPlay":case "controls":case "default":case "defer":case "disabled":case "disablePictureInPicture":case "disableRemotePlayback":case "formNoValidate":case "hidden":case "loop":case "noModule":case "noValidate":case "open":case "playsInline":case "readOnly":case "required":case "reversed":case "scoped":case "seamless":case "itemScope":c&&
+"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'=""');break;case "capture":case "download":!0===c?a.push(" ",b,'=""'):!1!==c&&"function"!==typeof c&&"symbol"!==typeof c&&a.push(" ",b,'="',y(c),'"');break;case "cols":case "rows":case "size":case "span":"function"!==typeof c&&"symbol"!==typeof c&&!isNaN(c)&&1<=c&&a.push(" ",b,'="',y(c),'"');break;case "rowSpan":case "start":"function"===typeof c||"symbol"===typeof c||isNaN(c)||a.push(" ",b,'="',y(c),'"');break;case "xlinkActuate":H(a,"xlink:actuate",
+c);break;case "xlinkArcrole":H(a,"xlink:arcrole",c);break;case "xlinkRole":H(a,"xlink:role",c);break;case "xlinkShow":H(a,"xlink:show",c);break;case "xlinkTitle":H(a,"xlink:title",c);break;case "xlinkType":H(a,"xlink:type",c);break;case "xmlBase":H(a,"xml:base",c);break;case "xmlLang":H(a,"xml:lang",c);break;case "xmlSpace":H(a,"xml:space",c);break;default:if(!(2<b.length)||"o"!==b[0]&&"O"!==b[0]||"n"!==b[1]&&"N"!==b[1])if(b=Ca.get(b)||b,Aa(b)){switch(typeof c){case "function":case "symbol":return;
+case "boolean":var d=b.toLowerCase().slice(0,5);if("data-"!==d&&"aria-"!==d)return}a.push(" ",b,'="',y(c),'"')}}}function K(a,b,c){if(null!=b){if(null!=c)throw Error("Can only set one of `children` or `props.dangerouslySetInnerHTML`.");if("object"!==typeof b||!("__html"in b))throw Error("`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://reactjs.org/link/dangerously-set-inner-html for more information.");b=b.__html;null!==b&&void 0!==b&&a.push(""+b)}}
+function Ib(a){var b="";aa.Children.forEach(a,function(c){null!=c&&(b+=c)});return b}
+function Hb(a,b){0!==(a.instructions&16)||b.externalRuntimeScript||(a.instructions|=16,b.bootstrapChunks.unshift(b.startInlineScript,'addEventListener("submit",function(a){if(!a.defaultPrevented){var c=a.target,d=a.submitter,e=c.action,b=d;if(d){var f=d.getAttribute("formAction");null!=f&&(e=f,b=null)}"javascript:throw new Error(\'A React form was unexpectedly submitted.\')"===e&&(a.preventDefault(),b?(a=document.createElement("input"),a.name=b.name,a.value=b.value,b.parentNode.insertBefore(a,b),b=new FormData(c),a.parentNode.removeChild(a)):b=new FormData(c),a=c.getRootNode(),(a.$$reactFormReplay=a.$$reactFormReplay||[]).push(c,\nd,b))}});',"\x3c/script>"))}
+function Jb(a,b,c,d,e,f,g){var h=b.rel,k=b.href,l=b.precedence;if(3===f||g||null!=b.itemProp||"string"!==typeof h||"string"!==typeof k||""===k)return L(a,b),null;if("stylesheet"===b.rel){if("string"!==typeof l||null!=b.disabled||b.onLoad||b.onError)return L(a,b);f=d.styles.get(l);g=c.styleResources.hasOwnProperty(k)?c.styleResources[k]:void 0;null!==g?(c.styleResources[k]=null,f||(f={precedence:y(l),rules:[],hrefs:[],sheets:new Map},d.styles.set(l,f)),b={state:0,props:r({},b,{"data-precedence":b.precedence,
+precedence:null})},g&&(2===g.length&&Kb(b.props,g),(c=d.preloads.stylesheets.get(k))&&0<c.length?c.length=0:b.state=1),f.sheets.set(k,b),d.boundaryResources&&d.boundaryResources.stylesheets.add(b)):f&&(k=f.sheets.get(k))&&d.boundaryResources&&d.boundaryResources.stylesheets.add(k);e&&a.push("\x3c!-- --\x3e");return null}if(b.onLoad||b.onError)return L(a,b);e&&a.push("\x3c!-- --\x3e");switch(b.rel){case "preconnect":case "dns-prefetch":return L(d.preconnectChunks,b);case "preload":return L(d.preloadChunks,
+b);default:return L(d.hoistableChunks,b)}}function L(a,b){a.push(M("link"));for(var c in b)if(x.call(b,c)){var d=b[c];if(null!=d)switch(c){case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");default:I(a,c,d)}}a.push("/>");return null}
+function Lb(a,b,c){a.push(M(c));for(var d in b)if(x.call(b,d)){var e=b[d];if(null!=e)switch(d){case "children":case "dangerouslySetInnerHTML":throw Error(c+" is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");default:I(a,d,e)}}a.push("/>");return null}
+function Mb(a,b){a.push(M("title"));var c=null,d=null,e;for(e in b)if(x.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:I(a,e,f)}}a.push(">");b=Array.isArray(c)?2>c.length?c[0]:null:c;"function"!==typeof b&&"symbol"!==typeof b&&null!==b&&void 0!==b&&a.push(y(""+b));K(a,d,c);a.push(Nb("title"));return null}
+function Ob(a,b){a.push(M("script"));var c=null,d=null,e;for(e in b)if(x.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:I(a,e,f)}}a.push(">");K(a,d,c);"string"===typeof c&&a.push(y(c));a.push(Nb("script"));return null}
+function Pb(a,b,c){a.push(M(c));var d=c=null,e;for(e in b)if(x.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:I(a,e,f)}}a.push(">");K(a,d,c);return"string"===typeof c?(a.push(y(c)),null):c}var Qb=/^[a-zA-Z][a-zA-Z:_\.\-\d]*$/,Rb=new Map;function M(a){var b=Rb.get(a);if(void 0===b){if(!Qb.test(a))throw Error("Invalid tag: "+a);b="<"+a;Rb.set(a,b)}return b}
+function Sb(a,b,c,d,e,f,g){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "select":a.push(M("select"));var h=null,k=null,l;for(l in c)if(x.call(c,l)){var n=c[l];if(null!=n)switch(l){case "children":h=n;break;case "dangerouslySetInnerHTML":k=n;break;case "defaultValue":case "value":break;default:I(a,l,n)}}a.push(">");K(a,k,h);return h;case "option":var q=f.selectedValue;a.push(M("option"));var m=null,E=null,C=null,Q=null,u;for(u in c)if(x.call(c,
+u)){var t=c[u];if(null!=t)switch(u){case "children":m=t;break;case "selected":C=t;break;case "dangerouslySetInnerHTML":Q=t;break;case "value":E=t;default:I(a,u,t)}}if(null!=q){var p=null!==E?""+E:Ib(m);if(La(q))for(var F=0;F<q.length;F++){if(""+q[F]===p){a.push(' selected=""');break}}else""+q===p&&a.push(' selected=""')}else C&&a.push(' selected=""');a.push(">");K(a,Q,m);return m;case "textarea":a.push(M("textarea"));var w=null,v=null,B=null,N;for(N in c)if(x.call(c,N)){var z=c[N];if(null!=z)switch(N){case "children":B=
+z;break;case "value":w=z;break;case "defaultValue":v=z;break;case "dangerouslySetInnerHTML":throw Error("`dangerouslySetInnerHTML` does not make sense on <textarea>.");default:I(a,N,z)}}null===w&&null!==v&&(w=v);a.push(">");if(null!=B){if(null!=w)throw Error("If you supply `defaultValue` on a <textarea>, do not pass children.");if(La(B)){if(1<B.length)throw Error("<textarea> can only have at most one child.");w=""+B[0]}w=""+B}"string"===typeof w&&"\n"===w[0]&&a.push("\n");null!==w&&a.push(y(""+w));
+return null;case "input":a.push(M("input"));var ea=null,T=null,O=null,ma=null,fa=null,X=null,Pa=null,Qa=null,Ra=null,na;for(na in c)if(x.call(c,na)){var R=c[na];if(null!=R)switch(na){case "children":case "dangerouslySetInnerHTML":throw Error("input is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");case "name":ea=R;break;case "formAction":T=R;break;case "formEncType":O=R;break;case "formMethod":ma=R;break;case "formTarget":fa=R;break;case "defaultChecked":Ra=
+R;break;case "defaultValue":Pa=R;break;case "checked":Qa=R;break;case "value":X=R;break;default:I(a,na,R)}}var qb=Gb(a,d,e,T,O,ma,fa,ea);null!==Qa?Cb(a,"checked",Qa):null!==Ra&&Cb(a,"checked",Ra);null!==X?I(a,"value",X):null!==Pa&&I(a,"value",Pa);a.push("/>");null!==qb&&qb.forEach(Fb,a);return null;case "button":a.push(M("button"));var oa=null,pa=null,ba=null,qa=null,ra=null,Sa=null,sa=null,Ta;for(Ta in c)if(x.call(c,Ta)){var ca=c[Ta];if(null!=ca)switch(Ta){case "children":oa=ca;break;case "dangerouslySetInnerHTML":pa=
+ca;break;case "name":ba=ca;break;case "formAction":qa=ca;break;case "formEncType":ra=ca;break;case "formMethod":Sa=ca;break;case "formTarget":sa=ca;break;default:I(a,Ta,ca)}}var Oc=Gb(a,d,e,qa,ra,Sa,sa,ba);a.push(">");null!==Oc&&Oc.forEach(Fb,a);K(a,pa,oa);if("string"===typeof oa){a.push(y(oa));var Pc=null}else Pc=oa;return Pc;case "form":a.push(M("form"));var Ua=null,Qc=null,ha=null,Va=null,Wa=null,Xa=null,Ya;for(Ya in c)if(x.call(c,Ya)){var ia=c[Ya];if(null!=ia)switch(Ya){case "children":Ua=ia;
+break;case "dangerouslySetInnerHTML":Qc=ia;break;case "action":ha=ia;break;case "encType":Va=ia;break;case "method":Wa=ia;break;case "target":Xa=ia;break;default:I(a,Ya,ia)}}var Wb=null,Xb=null;if("function"===typeof ha)if("function"===typeof ha.$$FORM_ACTION){var ze=Db(d),Da=ha.$$FORM_ACTION(ze);ha=Da.action||"";Va=Da.encType;Wa=Da.method;Xa=Da.target;Wb=Da.data;Xb=Da.name}else a.push(" ","action",'="',Eb,'"'),Xa=Wa=Va=ha=null,Hb(d,e);null!=ha&&I(a,"action",ha);null!=Va&&I(a,"encType",Va);null!=
+Wa&&I(a,"method",Wa);null!=Xa&&I(a,"target",Xa);a.push(">");null!==Xb&&(a.push('<input type="hidden"'),H(a,"name",Xb),a.push("/>"),null!==Wb&&Wb.forEach(Fb,a));K(a,Qc,Ua);if("string"===typeof Ua){a.push(y(Ua));var Rc=null}else Rc=Ua;return Rc;case "menuitem":a.push(M("menuitem"));for(var rb in c)if(x.call(c,rb)){var Sc=c[rb];if(null!=Sc)switch(rb){case "children":case "dangerouslySetInnerHTML":throw Error("menuitems cannot have `children` nor `dangerouslySetInnerHTML`.");default:I(a,rb,Sc)}}a.push(">");
+return null;case "title":if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp)var Tc=Mb(a,c);else Mb(e.hoistableChunks,c),Tc=null;return Tc;case "link":return Jb(a,c,d,e,g,f.insertionMode,!!(f.tagScope&1));case "script":var Yb=c.async;if("string"!==typeof c.src||!c.src||!Yb||"function"===typeof Yb||"symbol"===typeof Yb||c.onLoad||c.onError||3===f.insertionMode||f.tagScope&1||null!=c.itemProp)var Uc=Ob(a,c);else{var sb=c.src;if("module"===c.type){var tb=d.moduleScriptResources;var Vc=e.preloads.moduleScripts}else tb=
+d.scriptResources,Vc=e.preloads.scripts;var ub=tb.hasOwnProperty(sb)?tb[sb]:void 0;if(null!==ub){tb[sb]=null;var Zb=c;if(ub){2===ub.length&&(Zb=r({},c),Kb(Zb,ub));var Wc=Vc.get(sb);Wc&&(Wc.length=0)}var Xc=[];e.scripts.add(Xc);Ob(Xc,Zb)}g&&a.push("\x3c!-- --\x3e");Uc=null}return Uc;case "style":var vb=c.precedence,ta=c.href;if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp||"string"!==typeof vb||"string"!==typeof ta||""===ta){a.push(M("style"));var Ea=null,Yc=null,Za;for(Za in c)if(x.call(c,
+Za)){var wb=c[Za];if(null!=wb)switch(Za){case "children":Ea=wb;break;case "dangerouslySetInnerHTML":Yc=wb;break;default:I(a,Za,wb)}}a.push(">");var $a=Array.isArray(Ea)?2>Ea.length?Ea[0]:null:Ea;"function"!==typeof $a&&"symbol"!==typeof $a&&null!==$a&&void 0!==$a&&a.push(y(""+$a));K(a,Yc,Ea);a.push(Nb("style"));var Zc=null}else{var ua=e.styles.get(vb);if(null!==(d.styleResources.hasOwnProperty(ta)?d.styleResources[ta]:void 0)){d.styleResources[ta]=null;ua?ua.hrefs.push(y(ta)):(ua={precedence:y(vb),
+rules:[],hrefs:[y(ta)],sheets:new Map},e.styles.set(vb,ua));var $c=ua.rules,Fa=null,ad=null,xb;for(xb in c)if(x.call(c,xb)){var $b=c[xb];if(null!=$b)switch(xb){case "children":Fa=$b;break;case "dangerouslySetInnerHTML":ad=$b}}var ab=Array.isArray(Fa)?2>Fa.length?Fa[0]:null:Fa;"function"!==typeof ab&&"symbol"!==typeof ab&&null!==ab&&void 0!==ab&&$c.push(y(""+ab));K($c,ad,Fa)}ua&&e.boundaryResources&&e.boundaryResources.styles.add(ua);g&&a.push("\x3c!-- --\x3e");Zc=void 0}return Zc;case "meta":if(3===
+f.insertionMode||f.tagScope&1||null!=c.itemProp)var bd=Lb(a,c,"meta");else g&&a.push("\x3c!-- --\x3e"),bd="string"===typeof c.charSet?Lb(e.charsetChunks,c,"meta"):"viewport"===c.name?Lb(e.preconnectChunks,c,"meta"):Lb(e.hoistableChunks,c,"meta");return bd;case "listing":case "pre":a.push(M(b));var bb=null,cb=null,db;for(db in c)if(x.call(c,db)){var yb=c[db];if(null!=yb)switch(db){case "children":bb=yb;break;case "dangerouslySetInnerHTML":cb=yb;break;default:I(a,db,yb)}}a.push(">");if(null!=cb){if(null!=
+bb)throw Error("Can only set one of `children` or `props.dangerouslySetInnerHTML`.");if("object"!==typeof cb||!("__html"in cb))throw Error("`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://reactjs.org/link/dangerously-set-inner-html for more information.");var va=cb.__html;null!==va&&void 0!==va&&("string"===typeof va&&0<va.length&&"\n"===va[0]?a.push("\n",va):a.push(""+va))}"string"===typeof bb&&"\n"===bb[0]&&a.push("\n");return bb;case "img":var J=c.src,
+G=c.srcSet;if(!("lazy"===c.loading||!J&&!G||"string"!==typeof J&&null!=J||"string"!==typeof G&&null!=G)&&"low"!==c.fetchPriority&&!1===!!(f.tagScope&2)&&("string"!==typeof J||":"!==J[4]||"d"!==J[0]&&"D"!==J[0]||"a"!==J[1]&&"A"!==J[1]||"t"!==J[2]&&"T"!==J[2]||"a"!==J[3]&&"A"!==J[3])&&("string"!==typeof G||":"!==G[4]||"d"!==G[0]&&"D"!==G[0]||"a"!==G[1]&&"A"!==G[1]||"t"!==G[2]&&"T"!==G[2]||"a"!==G[3]&&"A"!==G[3])){var cd="string"===typeof c.sizes?c.sizes:void 0,Ga=G?G+"\n"+(cd||""):J,ac=e.preloads.images,
+wa=ac.get(Ga);if(wa){if("high"===c.fetchPriority||10>e.highImagePreloads.size)ac.delete(Ga),e.highImagePreloads.add(wa)}else if(!d.imageResources.hasOwnProperty(Ga)){d.imageResources[Ga]=A;var bc=c.crossOrigin;var dd="string"===typeof bc?"use-credentials"===bc?bc:"":void 0;var Y=e.headers,cc;Y&&0<Y.remainingCapacity&&("high"===c.fetchPriority||500>Y.highImagePreloads.length)&&(cc=Tb(J,"image",{imageSrcSet:c.srcSet,imageSizes:c.sizes,crossOrigin:dd,integrity:c.integrity,nonce:c.nonce,type:c.type,fetchPriority:c.fetchPriority,
+referrerPolicy:c.refererPolicy}),2<=(Y.remainingCapacity-=cc.length))?(e.resets.image[Ga]=A,Y.highImagePreloads&&(Y.highImagePreloads+=", "),Y.highImagePreloads+=cc):(wa=[],L(wa,{rel:"preload",as:"image",href:G?void 0:J,imageSrcSet:G,imageSizes:cd,crossOrigin:dd,integrity:c.integrity,type:c.type,fetchPriority:c.fetchPriority,referrerPolicy:c.referrerPolicy}),"high"===c.fetchPriority||10>e.highImagePreloads.size?e.highImagePreloads.add(wa):(e.bulkPreloads.add(wa),ac.set(Ga,wa)))}}return Lb(a,c,"img");
+case "base":case "area":case "br":case "col":case "embed":case "hr":case "keygen":case "param":case "source":case "track":case "wbr":return Lb(a,c,b);case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph":break;case "head":if(2>f.insertionMode&&null===e.headChunks){e.headChunks=[];var ed=Pb(e.headChunks,c,"head")}else ed=Pb(a,c,"head");return ed;case "html":if(0===f.insertionMode&&null===
+e.htmlChunks){e.htmlChunks=[""];var fd=Pb(e.htmlChunks,c,"html")}else fd=Pb(a,c,"html");return fd;default:if(-1!==b.indexOf("-")){a.push(M(b));var dc=null,gd=null,Ha;for(Ha in c)if(x.call(c,Ha)){var xa=c[Ha];if(null!=xa){var Ae=Ha;switch(Ha){case "children":dc=xa;break;case "dangerouslySetInnerHTML":gd=xa;break;case "style":Bb(a,xa);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":break;default:Aa(Ha)&&"function"!==typeof xa&&"symbol"!==typeof xa&&a.push(" ",Ae,'="',y(xa),
+'"')}}}a.push(">");K(a,gd,dc);return dc}}return Pb(a,c,b)}var Ub=new Map;function Nb(a){var b=Ub.get(a);void 0===b&&(b="</"+a+">",Ub.set(a,b));return b}function Vb(a,b,c){c.bootstrapScriptContent=void 0;c.bootstrapScripts=void 0;c.bootstrapModules=void 0;b=b.bootstrapChunks;for(c=0;c<b.length-1;c++)a.push(b[c]);return c<b.length?(c=b[c],b.length=0,a.push(c)):!0}
+function ec(a,b,c){a.push('\x3c!--$?--\x3e<template id="');if(null===c)throw Error("An ID must have been assigned before we can complete the boundary.");a.push(b.boundaryPrefix);b=c.toString(16);a.push(b);return a.push('"></template>')}
+function fc(a,b,c,d){switch(c.insertionMode){case 0:case 1:case 2:return a.push('<div hidden id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 3:return a.push('<svg aria-hidden="true" style="display:none" id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 4:return a.push('<math aria-hidden="true" style="display:none" id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 5:return a.push('<table hidden id="'),a.push(b.segmentPrefix),
 b=d.toString(16),a.push(b),a.push('">');case 6:return a.push('<table hidden><tbody id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 7:return a.push('<table hidden><tr id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');case 8:return a.push('<table hidden><colgroup id="'),a.push(b.segmentPrefix),b=d.toString(16),a.push(b),a.push('">');default:throw Error("Unknown insertion mode. This is a bug in React.");}}
-function fc(a,b){switch(b.insertionMode){case 0:case 1:case 2:return a.push("</div>");case 3:return a.push("</svg>");case 4:return a.push("</math>");case 5:return a.push("</table>");case 6:return a.push("</tbody></table>");case 7:return a.push("</tr></table>");case 8:return a.push("</colgroup></table>");default:throw Error("Unknown insertion mode. This is a bug in React.");}}var gc=/[<\u2028\u2029]/g;
-function hc(a){return JSON.stringify(a).replace(gc,function(b){switch(b){case "<":return"\\u003c";case "\u2028":return"\\u2028";case "\u2029":return"\\u2029";default:throw Error("escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}})}var ic=/[&><\u2028\u2029]/g;
-function jc(a){return JSON.stringify(a).replace(ic,function(b){switch(b){case "&":return"\\u0026";case ">":return"\\u003e";case "<":return"\\u003c";case "\u2028":return"\\u2028";case "\u2029":return"\\u2029";default:throw Error("escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}})}var kc=!1,lc=!0;
-function mc(a){var b=a.rules,c=a.hrefs,d=0;if(c.length){this.push('<style media="not all" data-precedence="');this.push(a.precedence);for(this.push('" data-href="');d<c.length-1;d++)this.push(c[d]),this.push(" ");this.push(c[d]);this.push('">');for(d=0;d<b.length;d++)this.push(b[d]);lc=this.push("</style>");kc=!0;b.length=0;c.length=0}}function nc(a){return 2!==a.state?kc=!0:!1}function oc(a,b,c){kc=!1;lc=!0;b.styles.forEach(mc,a);b.stylesheets.forEach(nc);kc&&(c.stylesToHoist=!0);return lc}
-function N(a){for(var b=0;b<a.length;b++)this.push(a[b]);a.length=0}var pc=[];function qc(a){J(pc,a.props);for(var b=0;b<pc.length;b++)this.push(pc[b]);pc.length=0;a.state=2}
-function rc(a){var b=0<a.sheets.size;a.sheets.forEach(qc,this);a.sheets.clear();var c=a.rules,d=a.hrefs;if(!b||d.length){this.push('<style data-precedence="');this.push(a.precedence);a=0;if(d.length){for(this.push('" data-href="');a<d.length-1;a++)this.push(d[a]),this.push(" ");this.push(d[a])}this.push('">');for(a=0;a<c.length;a++)this.push(c[a]);this.push("</style>");c.length=0;d.length=0}}
-function sc(a){if(0===a.state){a.state=1;var b=a.props;J(pc,{rel:"preload",as:"style",href:a.props.href,crossOrigin:b.crossOrigin,fetchPriority:b.fetchPriority,integrity:b.integrity,media:b.media,hrefLang:b.hrefLang,referrerPolicy:b.referrerPolicy});for(a=0;a<pc.length;a++)this.push(pc[a]);pc.length=0}}function tc(a){a.sheets.forEach(sc,this);a.sheets.clear()}
-function uc(a,b){a.push("[");var c="[";b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)a.push(c),d=jc(""+d.props.href),a.push(d),a.push("]"),c=",[";else{a.push(c);var e=d.props["data-precedence"],f=d.props,g=jc(""+d.props.href);a.push(g);e=""+e;a.push(",");e=jc(e);a.push(e);for(var h in f)if(u.call(f,h)&&(g=f[h],null!=g))switch(h){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");
-default:a:{e=a;var k=h.toLowerCase();switch(typeof g){case "function":case "symbol":break a}switch(h){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":k="class";g=""+g;break;case "hidden":if(!1===g)break a;g="";break;case "src":case "href":g=""+g;break;default:if(2<h.length&&("o"===h[0]||"O"===h[0])&&("n"===h[1]||"N"===h[1])||!Ba(h))break a;g=""+g}e.push(",");k=jc(k);e.push(k);e.push(",");g=
-jc(g);e.push(g)}}a.push("]");c=",[";d.state=3}});a.push("]")}
-function vc(a,b){a.push("[");var c="[";b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)a.push(c),d=v(JSON.stringify(""+d.props.href)),a.push(d),a.push("]"),c=",[";else{a.push(c);var e=d.props["data-precedence"],f=d.props,g=v(JSON.stringify(""+d.props.href));a.push(g);e=""+e;a.push(",");e=v(JSON.stringify(e));a.push(e);for(var h in f)if(u.call(f,h)&&(g=f[h],null!=g))switch(h){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");
-default:a:{e=a;var k=h.toLowerCase();switch(typeof g){case "function":case "symbol":break a}switch(h){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":k="class";g=""+g;break;case "hidden":if(!1===g)break a;g="";break;case "src":case "href":g=""+g;break;default:if(2<h.length&&("o"===h[0]||"O"===h[0])&&("n"===h[1]||"N"===h[1])||!Ba(h))break a;g=""+g}e.push(",");k=v(JSON.stringify(k));e.push(k);
-e.push(",");g=v(JSON.stringify(g));e.push(g)}}a.push("]");c=",[";d.state=3}});a.push("]")}
-function fb(a){var b=P?P:null;if(b){var c=b.resumableState,d=b.renderState;if("string"===typeof a&&a){if(!c.dnsResources.hasOwnProperty(a)){c.dnsResources[a]=null;c=d.headers;var e,f;if(f=c&&0<c.remainingCapacity)f=(e="<"+(""+a).replace(wc,xc)+">; rel=dns-prefetch",2<=(c.remainingCapacity-=e.length));f?(d.resets.dns[a]=null,c.preconnects&&(c.preconnects+=", "),c.preconnects+=e):(e=[],J(e,{href:a,rel:"dns-prefetch"}),d.preconnects.add(e))}yc(b)}}}
-function gb(a,b){var c=P?P:null;if(c){var d=c.resumableState,e=c.renderState;if("string"===typeof a&&a){var f="use-credentials"===b?"credentials":"string"===typeof b?"anonymous":"default";if(!d.connectResources[f].hasOwnProperty(a)){d.connectResources[f][a]=null;d=e.headers;var g,h;if(h=d&&0<d.remainingCapacity){h="<"+(""+a).replace(wc,xc)+">; rel=preconnect";if("string"===typeof b){var k=(""+b).replace(zc,Ac);h+='; crossorigin="'+k+'"'}h=(g=h,2<=(d.remainingCapacity-=g.length))}h?(e.resets.connect[f][a]=
-null,d.preconnects&&(d.preconnects+=", "),d.preconnects+=g):(f=[],J(f,{rel:"preconnect",href:a,crossOrigin:b}),e.preconnects.add(f))}yc(c)}}}
-function hb(a,b,c){var d=P?P:null;if(d){var e=d.resumableState,f=d.renderState;if(b&&a){switch(b){case "image":if(c){var g=c.imageSrcSet;var h=c.imageSizes;var k=c.fetchPriority}var l=g?g+"\n"+(h||""):a;if(e.imageResources.hasOwnProperty(l))return;e.imageResources[l]=x;e=f.headers;var n;e&&0<e.remainingCapacity&&"high"===k&&(n=Sb(a,b,c),2<=(e.remainingCapacity-=n.length))?(f.resets.image[l]=x,e.highImagePreloads&&(e.highImagePreloads+=", "),e.highImagePreloads+=n):(e=[],J(e,r({rel:"preload",href:g?
-void 0:a,as:b},c)),"high"===k?f.highImagePreloads.add(e):(f.bulkPreloads.add(e),f.preloads.images.set(l,e)));break;case "style":if(e.styleResources.hasOwnProperty(a))return;g=[];J(g,r({rel:"preload",href:a,as:b},c));e.styleResources[a]=!c||"string"!==typeof c.crossOrigin&&"string"!==typeof c.integrity?x:[c.crossOrigin,c.integrity];f.preloads.stylesheets.set(a,g);f.bulkPreloads.add(g);break;case "script":if(e.scriptResources.hasOwnProperty(a))return;g=[];f.preloads.scripts.set(a,g);f.bulkPreloads.add(g);
-J(g,r({rel:"preload",href:a,as:b},c));e.scriptResources[a]=!c||"string"!==typeof c.crossOrigin&&"string"!==typeof c.integrity?x:[c.crossOrigin,c.integrity];break;default:if(e.unknownResources.hasOwnProperty(b)){if(g=e.unknownResources[b],g.hasOwnProperty(a))return}else g={},e.unknownResources[b]=g;g[a]=x;if((e=f.headers)&&0<e.remainingCapacity&&"font"===b&&(l=Sb(a,b,c),2<=(e.remainingCapacity-=l.length)))f.resets.font[a]=x,e.fontPreloads&&(e.fontPreloads+=", "),e.fontPreloads+=l;else switch(e=[],
-a=r({rel:"preload",href:a,as:b},c),J(e,a),b){case "font":f.fontPreloads.add(e);break;default:f.bulkPreloads.add(e)}}yc(d)}}}
-function ib(a,b){var c=P?P:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=b&&"string"===typeof b.as?b.as:"script";switch(f){case "script":if(d.moduleScriptResources.hasOwnProperty(a))return;f=[];d.moduleScriptResources[a]=!b||"string"!==typeof b.crossOrigin&&"string"!==typeof b.integrity?x:[b.crossOrigin,b.integrity];e.preloads.moduleScripts.set(a,f);break;default:if(d.moduleUnknownResources.hasOwnProperty(f)){var g=d.unknownResources[f];if(g.hasOwnProperty(a))return}else g={},d.moduleUnknownResources[f]=
-g;f=[];g[a]=x}J(f,r({rel:"modulepreload",href:a},b));e.bulkPreloads.add(f);yc(c)}}}
-function jb(a,b,c){var d=P?P:null;if(d){var e=d.resumableState,f=d.renderState;if(a){b=b||"default";var g=f.styles.get(b),h=e.styleResources.hasOwnProperty(a)?e.styleResources[a]:void 0;null!==h&&(e.styleResources[a]=null,g||(g={precedence:v(b),rules:[],hrefs:[],sheets:new Map},f.styles.set(b,g)),b={state:0,props:r({rel:"stylesheet",href:a,"data-precedence":b},c)},h&&(2===h.length&&Jb(b.props,h),(f=f.preloads.stylesheets.get(a))&&0<f.length?f.length=0:b.state=1),g.sheets.set(a,b),yc(d))}}}
-function kb(a,b){var c=P?P:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=d.scriptResources.hasOwnProperty(a)?d.scriptResources[a]:void 0;null!==f&&(d.scriptResources[a]=null,b=r({src:a,async:!0},b),f&&(2===f.length&&Jb(b,f),a=e.preloads.scripts.get(a))&&(a.length=0),a=[],e.scripts.add(a),Nb(a,b),yc(c))}}}
-function lb(a,b){var c=P?P:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=d.moduleScriptResources.hasOwnProperty(a)?d.moduleScriptResources[a]:void 0;null!==f&&(d.moduleScriptResources[a]=null,b=r({src:a,type:"module",async:!0},b),f&&(2===f.length&&Jb(b,f),a=e.preloads.moduleScripts.get(a))&&(a.length=0),a=[],e.scripts.add(a),Nb(a,b),yc(c))}}}function Jb(a,b){null==a.crossOrigin&&(a.crossOrigin=b[0]);null==a.integrity&&(a.integrity=b[1])}
-function Sb(a,b,c){a=(""+a).replace(wc,xc);b=(""+b).replace(zc,Ac);b="<"+a+'>; rel=preload; as="'+b+'"';for(var d in c)u.call(c,d)&&(a=c[d],"string"===typeof a&&(b+="; "+d.toLowerCase()+'="'+(""+a).replace(zc,Ac)+'"'));return b}var wc=/[<>\r\n]/g;
-function xc(a){switch(a){case "<":return"%3C";case ">":return"%3E";case "\n":return"%0A";case "\r":return"%0D";default:throw Error("escapeLinkHrefForHeaderContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}}var zc=/["';,\r\n]/g;
-function Ac(a){switch(a){case '"':return"%22";case "'":return"%27";case ";":return"%3B";case ",":return"%2C";case "\n":return"%0A";case "\r":return"%0D";default:throw Error("escapeStringForLinkHeaderQuotedParamValueContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}}function Bc(a){this.styles.add(a)}function Cc(a){this.stylesheets.add(a)}
-function Dc(a,b,c){if(b=a.onHeaders){var d=a.headers;if(d){var e=d.preconnects;d.fontPreloads&&(e&&(e+=", "),e+=d.fontPreloads);d.highImagePreloads&&(e&&(e+=", "),e+=d.highImagePreloads);if(!c){c=a.styles.values();var f=c.next();a:for(;0<d.remainingCapacity&&!f.done;f=c.next()){f=f.value.sheets.values();for(var g=f.next();0<d.remainingCapacity&&!g.done;g=f.next()){var h=g.value;g=h.props;var k=g.href;h=h.props;h=Sb(h.href,"style",{crossOrigin:h.crossOrigin,integrity:h.integrity,nonce:h.nonce,type:h.type,
-fetchPriority:h.fetchPriority,referrerPolicy:h.referrerPolicy,media:h.media});if(2<=(d.remainingCapacity-=h.length))a.resets.style[k]=x,e&&(e+=", "),e+=h,a.resets.style[k]="string"===typeof g.crossOrigin||"string"===typeof g.integrity?[g.crossOrigin,g.integrity]:x;else break a}}}e?b({Link:e}):b({});a.headers=null}}}
-function Ec(a,b){var c=a.idPrefix;a=c+"P:";var d=c+"S:";c+="B:";var e=new Set,f=new Set,g=new Set,h=new Map,k=new Set,l=new Set,n=new Set,q={images:new Map,stylesheets:new Map,scripts:new Map,moduleScripts:new Map};return{placeholderPrefix:a,segmentPrefix:d,boundaryPrefix:c,startInlineScript:"<script>",htmlChunks:null,headChunks:null,externalRuntimeScript:null,bootstrapChunks:[],onHeaders:void 0,headers:null,resets:{font:{},dns:{},connect:{default:{},anonymous:{},credentials:{}},image:{},style:{}},
-charsetChunks:[],preconnectChunks:[],importMapChunks:[],preloadChunks:[],hoistableChunks:[],preconnects:e,fontPreloads:f,highImagePreloads:g,styles:h,bootstrapScripts:k,scripts:l,bulkPreloads:n,preloads:q,boundaryResources:null,stylesToHoist:!1,generateStaticMarkup:b}}function Fc(a,b,c,d){if(c.generateStaticMarkup)return a.push(v(b)),!1;""===b?a=d:(d&&a.push("\x3c!-- --\x3e"),a.push(v(b)),a=!0);return a}
-var Gc=Symbol.for("react.element"),Hc=Symbol.for("react.portal"),Ic=Symbol.for("react.fragment"),Jc=Symbol.for("react.strict_mode"),Kc=Symbol.for("react.profiler"),Lc=Symbol.for("react.provider"),Mc=Symbol.for("react.context"),Nc=Symbol.for("react.server_context"),hd=Symbol.for("react.forward_ref"),id=Symbol.for("react.suspense"),jd=Symbol.for("react.suspense_list"),kd=Symbol.for("react.memo"),ld=Symbol.for("react.lazy"),md=Symbol.for("react.scope"),nd=Symbol.for("react.debug_trace_mode"),od=Symbol.for("react.offscreen"),
-pd=Symbol.for("react.legacy_hidden"),qd=Symbol.for("react.cache"),rd=Symbol.for("react.default_value"),sd=Symbol.iterator;
-function td(a){if(null==a)return null;if("function"===typeof a)return a.displayName||a.name||null;if("string"===typeof a)return a;switch(a){case Ic:return"Fragment";case Hc:return"Portal";case Kc:return"Profiler";case Jc:return"StrictMode";case id:return"Suspense";case jd:return"SuspenseList";case qd:return"Cache"}if("object"===typeof a)switch(a.$$typeof){case Mc:return(a.displayName||"Context")+".Consumer";case Lc:return(a._context.displayName||"Context")+".Provider";case hd:var b=a.render;a=a.displayName;
-a||(a=b.displayName||b.name||"",a=""!==a?"ForwardRef("+a+")":"ForwardRef");return a;case kd:return b=a.displayName||null,null!==b?b:td(a.type)||"Memo";case ld:b=a._payload;a=a._init;try{return td(a(b))}catch(c){}}return null}var ud={};function vd(a,b){a=a.contextTypes;if(!a)return ud;var c={},d;for(d in a)c[d]=b[d];return c}var wd=null;
-function xd(a,b){if(a!==b){a.context._currentValue2=a.parentValue;a=a.parent;var c=b.parent;if(null===a){if(null!==c)throw Error("The stacks must reach the root at the same time. This is a bug in React.");}else{if(null===c)throw Error("The stacks must reach the root at the same time. This is a bug in React.");xd(a,c)}b.context._currentValue2=b.value}}function yd(a){a.context._currentValue2=a.parentValue;a=a.parent;null!==a&&yd(a)}
-function zd(a){var b=a.parent;null!==b&&zd(b);a.context._currentValue2=a.value}function Ad(a,b){a.context._currentValue2=a.parentValue;a=a.parent;if(null===a)throw Error("The depth must equal at least at zero before reaching the root. This is a bug in React.");a.depth===b.depth?xd(a,b):Ad(a,b)}
-function Bd(a,b){var c=b.parent;if(null===c)throw Error("The depth must equal at least at zero before reaching the root. This is a bug in React.");a.depth===c.depth?xd(a,c):Bd(a,c);b.context._currentValue2=b.value}function Cd(a){var b=wd;b!==a&&(null===b?zd(a):null===a?yd(b):b.depth===a.depth?xd(b,a):b.depth>a.depth?Ad(b,a):Bd(b,a),wd=a)}
-var Dd={isMounted:function(){return!1},enqueueSetState:function(a,b){a=a._reactInternals;null!==a.queue&&a.queue.push(b)},enqueueReplaceState:function(a,b){a=a._reactInternals;a.replace=!0;a.queue=[b]},enqueueForceUpdate:function(){}};
-function Ed(a,b,c,d){var e=void 0!==a.state?a.state:null;a.updater=Dd;a.props=c;a.state=e;var f={queue:[],replace:!1};a._reactInternals=f;var g=b.contextType;a.context="object"===typeof g&&null!==g?g._currentValue2:d;g=b.getDerivedStateFromProps;"function"===typeof g&&(g=g(c,e),e=null===g||void 0===g?e:r({},e,g),a.state=e);if("function"!==typeof b.getDerivedStateFromProps&&"function"!==typeof a.getSnapshotBeforeUpdate&&("function"===typeof a.UNSAFE_componentWillMount||"function"===typeof a.componentWillMount))if(b=
-a.state,"function"===typeof a.componentWillMount&&a.componentWillMount(),"function"===typeof a.UNSAFE_componentWillMount&&a.UNSAFE_componentWillMount(),b!==a.state&&Dd.enqueueReplaceState(a,a.state,null),null!==f.queue&&0<f.queue.length)if(b=f.queue,g=f.replace,f.queue=null,f.replace=!1,g&&1===b.length)a.state=b[0];else{f=g?b[0]:a.state;e=!0;for(g=g?1:0;g<b.length;g++){var h=b[g];h="function"===typeof h?h.call(a,f,c,d):h;null!=h&&(e?(e=!1,f=r({},f,h)):r(f,h))}a.state=f}else f.queue=null}
-var Fd={id:1,overflow:""};function Gd(a,b,c){var d=a.id;a=a.overflow;var e=32-Hd(d)-1;d&=~(1<<e);c+=1;var f=32-Hd(b)+e;if(30<f){var g=e-e%5;f=(d&(1<<g)-1).toString(32);d>>=g;e-=g;return{id:1<<32-Hd(b)+e|c<<e|d,overflow:f+a}}return{id:1<<f|c<<e|d,overflow:a}}var Hd=Math.clz32?Math.clz32:Id,Jd=Math.log,Kd=Math.LN2;function Id(a){a>>>=0;return 0===a?32:31-(Jd(a)/Kd|0)|0}var Ld=Error("Suspense Exception: This is not a real error! It's an implementation detail of `use` to interrupt the current render. You must either rethrow it immediately, or move the `use` call outside of the `try/catch` block. Capturing without rethrowing will lead to unexpected behavior.\n\nTo handle async errors, wrap your component in an error boundary, or call the promise's `.catch` method and pass the result to `use`");
-function Md(){}function Nd(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(Md,Md),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;default:if("string"!==typeof b.status)switch(a=b,a.status="pending",a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}}),b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;}Od=b;throw Ld;}}var Od=null;
-function Pd(){if(null===Od)throw Error("Expected a suspended thenable. This is a bug in React. Please file an issue.");var a=Od;Od=null;return a}function Qd(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var Rd="function"===typeof Object.is?Object.is:Qd,R=null,Sd=null,Td=null,Ud=null,Vd=null,T=null,Wd=!1,Xd=!1,Yd=0,Zd=0,$d=-1,ae=0,be=null,ce=null,de=0;
-function ee(){if(null===R)throw Error("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.");return R}
-function fe(){if(0<de)throw Error("Rendered more hooks than during the previous render");return{memoizedState:null,queue:null,next:null}}function ge(){null===T?null===Vd?(Wd=!1,Vd=T=fe()):(Wd=!0,T=Vd):null===T.next?(Wd=!1,T=T.next=fe()):(Wd=!0,T=T.next);return T}function he(a,b,c,d){for(;Xd;)Xd=!1,Zd=Yd=0,$d=-1,ae=0,de+=1,T=null,c=a(b,d);ie();return c}function je(){var a=be;be=null;return a}function ie(){Ud=Td=Sd=R=null;Xd=!1;Vd=null;de=0;T=ce=null}
-function ke(a,b){return"function"===typeof b?b(a):b}function le(a,b,c){R=ee();T=ge();if(Wd){var d=T.queue;b=d.dispatch;if(null!==ce&&(c=ce.get(d),void 0!==c)){ce.delete(d);d=T.memoizedState;do d=a(d,c.action),c=c.next;while(null!==c);T.memoizedState=d;return[d,b]}return[T.memoizedState,b]}a=a===ke?"function"===typeof b?b():b:void 0!==c?c(b):b;T.memoizedState=a;a=T.queue={last:null,dispatch:null};a=a.dispatch=me.bind(null,R,a);return[T.memoizedState,a]}
-function ne(a,b){R=ee();T=ge();b=void 0===b?null:b;if(null!==T){var c=T.memoizedState;if(null!==c&&null!==b){var d=c[1];a:if(null===d)d=!1;else{for(var e=0;e<d.length&&e<b.length;e++)if(!Rd(b[e],d[e])){d=!1;break a}d=!0}if(d)return c[0]}}a=a();T.memoizedState=[a,b];return a}
-function me(a,b,c){if(25<=de)throw Error("Too many re-renders. React limits the number of renders to prevent an infinite loop.");if(a===R)if(Xd=!0,a={action:c,next:null},null===ce&&(ce=new Map),c=ce.get(b),void 0===c)ce.set(b,a);else{for(b=c;null!==b.next;)b=b.next;b.next=a}}function oe(){throw Error("startTransition cannot be called during server rendering.");}function pe(){throw Error("Cannot update optimistic state while rendering.");}
-function qe(a){var b=ae;ae+=1;null===be&&(be=[]);return Nd(be,a,b)}function re(){throw Error("Cache cannot be refreshed during server rendering.");}function se(){}
-var ue={readContext:function(a){return a._currentValue2},use:function(a){if(null!==a&&"object"===typeof a){if("function"===typeof a.then)return qe(a);if(a.$$typeof===Mc||a.$$typeof===Nc)return a._currentValue2}throw Error("An unsupported type was passed to use(): "+String(a));},useContext:function(a){ee();return a._currentValue2},useMemo:ne,useReducer:le,useRef:function(a){R=ee();T=ge();var b=T.memoizedState;return null===b?(a={current:a},T.memoizedState=a):b},useState:function(a){return le(ke,a)},
-useInsertionEffect:se,useLayoutEffect:se,useCallback:function(a,b){return ne(function(){return a},b)},useImperativeHandle:se,useEffect:se,useDebugValue:se,useDeferredValue:function(a){ee();return a},useTransition:function(){ee();return[!1,oe]},useId:function(){var a=Sd.treeContext;var b=a.overflow;a=a.id;a=(a&~(1<<32-Hd(a)-1)).toString(32)+b;var c=te;if(null===c)throw Error("Invalid hook call. Hooks can only be called inside of the body of a function component.");b=Yd++;a=":"+c.idPrefix+"R"+a;0<b&&
-(a+="H"+b.toString(32));return a+":"},useSyncExternalStore:function(a,b,c){if(void 0===c)throw Error("Missing getServerSnapshot, which is required for server-rendered content. Will revert to client rendering.");return c()},useCacheRefresh:function(){return re},useHostTransitionStatus:function(){ee();return Oa},useOptimistic:function(a){ee();return[a,pe]},useFormState:function(a,b,c){ee();var d=Zd++,e=Td;if("function"===typeof a.$$FORM_ACTION){var f=null,g=Ud;e=e.formState;var h=a.$$IS_SIGNATURE_EQUAL;
-if(null!==e&&"function"===typeof h){var k=e[1];h.call(a,e[2],e[3])&&(f=void 0!==c?"p"+c:"k"+la(JSON.stringify([g,null,d]),0),k===f&&($d=d,b=e[0]))}var l=a.bind(null,b);a=function(q){l(q)};"function"===typeof l.$$FORM_ACTION&&(a.$$FORM_ACTION=function(q){q=l.$$FORM_ACTION(q);void 0!==c&&(c+="",q.action=c);var m=q.data;m&&(null===f&&(f=void 0!==c?"p"+c:"k"+la(JSON.stringify([g,null,d]),0)),m.append("$ACTION_KEY",f));return q});return[b,a]}var n=a.bind(null,b);return[b,function(q){n(q)}]}},te=null,ve=
-{getCacheSignal:function(){throw Error("Not implemented.");},getCacheForType:function(){throw Error("Not implemented.");}},we=Na.ReactCurrentDispatcher,ze=Na.ReactCurrentCache;function Ae(a){console.error(a);return null}function Be(){}
-function Ce(a,b,c,d,e,f,g,h,k,l,n,q){eb.current=mb;var m=[],F=new Set;b={destination:null,flushScheduled:!1,resumableState:b,renderState:c,rootFormatContext:d,progressiveChunkSize:void 0===e?12800:e,status:0,fatalError:null,nextSegmentId:0,allPendingTasks:0,pendingRootTasks:0,completedRootSegment:null,abortableTasks:F,pingedTasks:m,clientRenderedBoundaries:[],completedBoundaries:[],partialBoundaries:[],trackedPostpones:null,onError:void 0===f?Ae:f,onPostpone:void 0===n?Be:n,onAllReady:void 0===g?
-Be:g,onShellReady:void 0===h?Be:h,onShellError:void 0===k?Be:k,onFatalError:void 0===l?Be:l,formState:void 0===q?null:q};c=De(b,0,null,d,!1,!1);c.parentFlushed=!0;a=Ee(b,null,a,-1,null,c,F,null,d,ud,null,Fd);m.push(a);return b}var P=null;function Fe(a,b){a.pingedTasks.push(b);1===a.pingedTasks.length&&(a.flushScheduled=null!==a.destination,Ge(a))}
-function He(a,b){return{status:0,rootSegmentID:-1,parentFlushed:!1,pendingTasks:0,completedSegments:[],byteSize:0,fallbackAbortableTasks:b,errorDigest:null,resources:{styles:new Set,stylesheets:new Set},trackedContentKeyPath:null,trackedFallbackNode:null}}
-function Ee(a,b,c,d,e,f,g,h,k,l,n,q){a.allPendingTasks++;null===e?a.pendingRootTasks++:e.pendingTasks++;var m={replay:null,node:c,childIndex:d,ping:function(){return Fe(a,m)},blockedBoundary:e,blockedSegment:f,abortSet:g,keyPath:h,formatContext:k,legacyContext:l,context:n,treeContext:q,thenableState:b};g.add(m);return m}
-function Ie(a,b,c,d,e,f,g,h,k,l,n,q){a.allPendingTasks++;null===f?a.pendingRootTasks++:f.pendingTasks++;c.pendingTasks++;var m={replay:c,node:d,childIndex:e,ping:function(){return Fe(a,m)},blockedBoundary:f,blockedSegment:null,abortSet:g,keyPath:h,formatContext:k,legacyContext:l,context:n,treeContext:q,thenableState:b};g.add(m);return m}function De(a,b,c,d,e,f){return{status:0,id:-1,index:b,parentFlushed:!1,chunks:[],children:[],parentFormatContext:d,boundary:c,lastPushedText:e,textEmbedded:f}}
-function U(a,b){a=a.onError(b);if(null!=a&&"string"!==typeof a)throw Error('onError returned something with a type other than "string". onError should return a string and may return null or undefined but must not return anything else. It received something of type "'+typeof a+'" instead');return a}function Je(a,b){var c=a.onShellError;c(b);c=a.onFatalError;c(b);null!==a.destination?(a.status=2,a.destination.destroy(b)):(a.status=1,a.fatalError=b)}
-function Ke(a,b,c,d,e){var f=d.render(),g=e.childContextTypes;if(null!==g&&void 0!==g){c=b.legacyContext;if("function"!==typeof d.getChildContext)e=c;else{d=d.getChildContext();for(var h in d)if(!(h in g))throw Error((td(e)||"Unknown")+'.getChildContext(): key "'+h+'" is not defined in childContextTypes.');e=r({},c,d)}b.legacyContext=e;X(a,b,null,f,-1);b.legacyContext=c}else e=b.keyPath,b.keyPath=c,X(a,b,null,f,-1),b.keyPath=e}
-function Le(a,b,c,d,e,f,g){var h=!1;if(0!==f&&null!==a.formState){var k=b.blockedSegment;if(null!==k){h=!0;k=k.chunks;for(var l=0;l<f;l++)l===g?k.push("\x3c!--F!--\x3e"):k.push("\x3c!--F--\x3e")}}f=b.keyPath;b.keyPath=c;e?(c=b.treeContext,b.treeContext=Gd(c,1,0),Y(a,b,d,-1),b.treeContext=c):h?Y(a,b,d,-1):X(a,b,null,d,-1);b.keyPath=f}function Me(a,b){if(a&&a.defaultProps){b=r({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}
-function Ne(a,b,c,d,e,f,g){if("function"===typeof e)if(e.prototype&&e.prototype.isReactComponent){d=vd(e,b.legacyContext);var h=e.contextType;h=new e(f,"object"===typeof h&&null!==h?h._currentValue2:d);Ed(h,e,f,d);Ke(a,b,c,h,e)}else{h=vd(e,b.legacyContext);R={};Sd=b;Td=a;Ud=c;Zd=Yd=0;$d=-1;ae=0;be=d;d=e(f,h);d=he(e,f,d,h);g=0!==Yd;var k=Zd,l=$d;"object"===typeof d&&null!==d&&"function"===typeof d.render&&void 0===d.$$typeof?(Ed(d,e,f,h),Ke(a,b,c,d,e)):Le(a,b,c,d,g,k,l)}else if("string"===typeof e)if(d=
-b.blockedSegment,null===d)d=f.children,h=b.formatContext,g=b.keyPath,b.formatContext=pb(h,e,f),b.keyPath=c,Y(a,b,d,-1),b.formatContext=h,b.keyPath=g;else{g=Rb(d.chunks,e,f,a.resumableState,a.renderState,b.formatContext,d.lastPushedText);d.lastPushedText=!1;h=b.formatContext;k=b.keyPath;b.formatContext=pb(h,e,f);b.keyPath=c;Y(a,b,g,-1);b.formatContext=h;b.keyPath=k;a:{b=d.chunks;a=a.resumableState;switch(e){case "title":case "style":case "script":case "area":case "base":case "br":case "col":case "embed":case "hr":case "img":case "input":case "keygen":case "link":case "meta":case "param":case "source":case "track":case "wbr":break a;
-case "body":if(1>=h.insertionMode){a.hasBody=!0;break a}break;case "html":if(0===h.insertionMode){a.hasHtml=!0;break a}}b.push(Mb(e))}d.lastPushedText=!1}else{switch(e){case pd:case nd:case Jc:case Kc:case Ic:e=b.keyPath;b.keyPath=c;X(a,b,null,f.children,-1);b.keyPath=e;return;case od:"hidden"!==f.mode&&(e=b.keyPath,b.keyPath=c,X(a,b,null,f.children,-1),b.keyPath=e);return;case jd:e=b.keyPath;b.keyPath=c;X(a,b,null,f.children,-1);b.keyPath=e;return;case md:throw Error("ReactDOMServer does not yet support scope components.");
-case id:a:if(null!==b.replay){e=b.keyPath;b.keyPath=c;c=f.children;try{Y(a,b,c,-1)}finally{b.keyPath=e}}else{l=b.keyPath;e=b.blockedBoundary;var n=b.blockedSegment;d=f.fallback;var q=f.children;f=new Set;g=He(a,f);null!==a.trackedPostpones&&(g.trackedContentKeyPath=c);k=De(a,n.chunks.length,g,b.formatContext,!1,!1);n.children.push(k);n.lastPushedText=!1;var m=De(a,0,null,b.formatContext,!1,!1);m.parentFlushed=!0;b.blockedBoundary=g;b.blockedSegment=m;a.renderState.boundaryResources=g.resources;b.keyPath=
-c;try{if(Y(a,b,q,-1),a.renderState.generateStaticMarkup||m.lastPushedText&&m.textEmbedded&&m.chunks.push("\x3c!-- --\x3e"),m.status=1,Oe(g,m),0===g.pendingTasks&&0===g.status){g.status=1;break a}}catch(F){m.status=4,g.status=4,h=U(a,F),g.errorDigest=h}finally{a.renderState.boundaryResources=e?e.resources:null,b.blockedBoundary=e,b.blockedSegment=n,b.keyPath=l}h=[c[0],"Suspense Fallback",c[2]];l=a.trackedPostpones;null!==l&&(n=[h[1],h[2],[],null],l.workingMap.set(h,n),5===g.status?l.workingMap.get(c)[4]=
-n:g.trackedFallbackNode=n);b=Ee(a,null,d,-1,e,k,f,h,b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}return}if("object"===typeof e&&null!==e)switch(e.$$typeof){case hd:e=e.render;R={};Sd=b;Td=a;Ud=c;Zd=Yd=0;$d=-1;ae=0;be=d;d=e(f,g);f=he(e,f,d,g);Le(a,b,c,f,0!==Yd,Zd,$d);return;case kd:e=e.type;f=Me(e,f);Ne(a,b,c,d,e,f,g);return;case Lc:h=f.children;d=b.keyPath;e=e._context;f=f.value;g=e._currentValue2;e._currentValue2=f;k=wd;wd=f={parent:k,depth:null===k?0:k.depth+1,
-context:e,parentValue:g,value:f};b.context=f;b.keyPath=c;X(a,b,null,h,-1);a=wd;if(null===a)throw Error("Tried to pop a Context at the root of the app. This is a bug in React.");c=a.parentValue;a.context._currentValue2=c===rd?a.context._defaultValue:c;a=wd=a.parent;b.context=a;b.keyPath=d;return;case Mc:f=f.children;f=f(e._currentValue2);e=b.keyPath;b.keyPath=c;X(a,b,null,f,-1);b.keyPath=e;return;case ld:h=e._init;e=h(e._payload);f=Me(e,f);Ne(a,b,c,d,e,f,void 0);return}throw Error("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: "+
-((null==e?e:typeof e)+"."));}}function Pe(a,b,c,d,e){var f=b.replay,g=b.blockedBoundary,h=De(a,0,null,b.formatContext,!1,!1);h.id=c;h.parentFlushed=!0;try{b.replay=null,b.blockedSegment=h,Y(a,b,d,e),h.status=1,null===g?a.completedRootSegment=h:(Oe(g,h),g.parentFlushed&&a.partialBoundaries.push(g))}finally{b.replay=f,b.blockedSegment=null}}
-function X(a,b,c,d,e){if(null!==b.replay&&"number"===typeof b.replay.slots)Pe(a,b,b.replay.slots,d,e);else{b.node=d;b.childIndex=e;if("object"===typeof d&&null!==d){switch(d.$$typeof){case Gc:var f=d.type,g=d.key,h=d.props,k=d.ref,l=td(f),n=null==g?-1===e?0:e:g;g=[b.keyPath,l,n];if(null!==b.replay)a:{var q=b.replay;e=q.nodes;for(d=0;d<e.length;d++){var m=e[d];if(n===m[1]){if(4===m.length){if(null!==l&&l!==m[0])throw Error("Expected the resume to render <"+m[0]+"> in this slot but instead it rendered <"+
-l+">. The tree doesn't match so React will fallback to client rendering.");l=m[2];m=m[3];n=b.node;b.replay={nodes:l,slots:m,pendingTasks:1};try{Ne(a,b,g,c,f,h,k);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--}catch(p){if("object"===typeof p&&null!==p&&(p===Ld||"function"===typeof p.then))throw b.node===n&&(b.replay=q),p;b.replay.pendingTasks--;
-g=a;a=b.blockedBoundary;c=p;h=U(g,c);Qe(g,a,l,m,c,h)}b.replay=q}else{if(f!==id)throw Error("Expected the resume to render <Suspense> in this slot but instead it rendered <"+(td(f)||"Unknown")+">. The tree doesn't match so React will fallback to client rendering.");b:{q=void 0;c=m[5];f=m[2];k=m[3];l=null===m[4]?[]:m[4][2];m=null===m[4]?null:m[4][3];n=b.keyPath;var F=b.replay,z=b.blockedBoundary,S=h.children;h=h.fallback;var t=new Set,y=He(a,t);y.parentFlushed=!0;y.rootSegmentID=c;b.blockedBoundary=
-y;b.replay={nodes:f,slots:k,pendingTasks:1};a.renderState.boundaryResources=y.resources;try{Y(a,b,S,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--;if(0===y.pendingTasks&&0===y.status){y.status=1;a.completedBoundaries.push(y);break b}}catch(p){y.status=4,q=U(a,p),y.errorDigest=q,b.replay.pendingTasks--,a.clientRenderedBoundaries.push(y)}finally{a.renderState.boundaryResources=
-z?z.resources:null,b.blockedBoundary=z,b.replay=F,b.keyPath=n}b=Ie(a,null,{nodes:l,slots:m,pendingTasks:0},h,-1,z,t,[g[0],"Suspense Fallback",g[2]],b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}}e.splice(d,1);break a}}}else Ne(a,b,g,c,f,h,k);return;case Hc:throw Error("Portals are not currently supported by the server renderer. Render them conditionally so that they only appear on the client render.");case ld:h=d._init;d=h(d._payload);X(a,b,null,d,e);return}if(Ma(d)){Re(a,
-b,d,e);return}null===d||"object"!==typeof d?h=null:(h=sd&&d[sd]||d["@@iterator"],h="function"===typeof h?h:null);if(h&&(h=h.call(d))){d=h.next();if(!d.done){g=[];do g.push(d.value),d=h.next();while(!d.done);Re(a,b,g,e)}return}if("function"===typeof d.then)return X(a,b,null,qe(d),e);if(d.$$typeof===Mc||d.$$typeof===Nc)return X(a,b,null,d._currentValue2,e);e=Object.prototype.toString.call(d);throw Error("Objects are not valid as a React child (found: "+("[object Object]"===e?"object with keys {"+Object.keys(d).join(", ")+
-"}":e)+"). If you meant to render a collection of children, use an array instead.");}"string"===typeof d?(e=b.blockedSegment,null!==e&&(e.lastPushedText=Fc(e.chunks,d,a.renderState,e.lastPushedText))):"number"===typeof d&&(e=b.blockedSegment,null!==e&&(e.lastPushedText=Fc(e.chunks,""+d,a.renderState,e.lastPushedText)))}}
-function Re(a,b,c,d){var e=b.keyPath;if(-1!==d&&(b.keyPath=[b.keyPath,"Fragment",d],null!==b.replay)){for(var f=b.replay,g=f.nodes,h=0;h<g.length;h++){var k=g[h];if(k[1]===d){d=k[2];k=k[3];b.replay={nodes:d,slots:k,pendingTasks:1};try{Re(a,b,c,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--}catch(q){if("object"===typeof q&&
-null!==q&&(q===Ld||"function"===typeof q.then))throw q;b.replay.pendingTasks--;c=a;var l=b.blockedBoundary,n=q;a=U(c,n);Qe(c,l,d,k,n,a)}b.replay=f;g.splice(h,1);break}}b.keyPath=e;return}f=b.treeContext;g=c.length;if(null!==b.replay&&(h=b.replay.slots,null!==h&&"object"===typeof h)){for(d=0;d<g;d++)k=c[d],b.treeContext=Gd(f,g,d),l=h[d],"number"===typeof l?(Pe(a,b,l,k,d),delete h[d]):Y(a,b,k,d);b.treeContext=f;b.keyPath=e;return}for(h=0;h<g;h++)d=c[h],b.treeContext=Gd(f,g,h),Y(a,b,d,h);b.treeContext=
+function gc(a,b){switch(b.insertionMode){case 0:case 1:case 2:return a.push("</div>");case 3:return a.push("</svg>");case 4:return a.push("</math>");case 5:return a.push("</table>");case 6:return a.push("</tbody></table>");case 7:return a.push("</tr></table>");case 8:return a.push("</colgroup></table>");default:throw Error("Unknown insertion mode. This is a bug in React.");}}var hc=/[<\u2028\u2029]/g;
+function ic(a){return JSON.stringify(a).replace(hc,function(b){switch(b){case "<":return"\\u003c";case "\u2028":return"\\u2028";case "\u2029":return"\\u2029";default:throw Error("escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}})}var jc=/[&><\u2028\u2029]/g;
+function kc(a){return JSON.stringify(a).replace(jc,function(b){switch(b){case "&":return"\\u0026";case ">":return"\\u003e";case "<":return"\\u003c";case "\u2028":return"\\u2028";case "\u2029":return"\\u2029";default:throw Error("escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}})}var lc=!1,mc=!0;
+function nc(a){var b=a.rules,c=a.hrefs,d=0;if(c.length){this.push('<style media="not all" data-precedence="');this.push(a.precedence);for(this.push('" data-href="');d<c.length-1;d++)this.push(c[d]),this.push(" ");this.push(c[d]);this.push('">');for(d=0;d<b.length;d++)this.push(b[d]);mc=this.push("</style>");lc=!0;b.length=0;c.length=0}}function oc(a){return 2!==a.state?lc=!0:!1}function pc(a,b,c){lc=!1;mc=!0;b.styles.forEach(nc,a);b.stylesheets.forEach(oc);lc&&(c.stylesToHoist=!0);return mc}
+function P(a){for(var b=0;b<a.length;b++)this.push(a[b]);a.length=0}var qc=[];function rc(a){L(qc,a.props);for(var b=0;b<qc.length;b++)this.push(qc[b]);qc.length=0;a.state=2}
+function sc(a){var b=0<a.sheets.size;a.sheets.forEach(rc,this);a.sheets.clear();var c=a.rules,d=a.hrefs;if(!b||d.length){this.push('<style data-precedence="');this.push(a.precedence);a=0;if(d.length){for(this.push('" data-href="');a<d.length-1;a++)this.push(d[a]),this.push(" ");this.push(d[a])}this.push('">');for(a=0;a<c.length;a++)this.push(c[a]);this.push("</style>");c.length=0;d.length=0}}
+function tc(a){if(0===a.state){a.state=1;var b=a.props;L(qc,{rel:"preload",as:"style",href:a.props.href,crossOrigin:b.crossOrigin,fetchPriority:b.fetchPriority,integrity:b.integrity,media:b.media,hrefLang:b.hrefLang,referrerPolicy:b.referrerPolicy});for(a=0;a<qc.length;a++)this.push(qc[a]);qc.length=0}}function uc(a){a.sheets.forEach(tc,this);a.sheets.clear()}
+function vc(a,b){a.push("[");var c="[";b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)a.push(c),d=kc(""+d.props.href),a.push(d),a.push("]"),c=",[";else{a.push(c);var e=d.props["data-precedence"],f=d.props,g=kc(""+d.props.href);a.push(g);e=""+e;a.push(",");e=kc(e);a.push(e);for(var h in f)if(x.call(f,h)&&(g=f[h],null!=g))switch(h){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");
+default:a:{e=a;var k=h.toLowerCase();switch(typeof g){case "function":case "symbol":break a}switch(h){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":k="class";g=""+g;break;case "hidden":if(!1===g)break a;g="";break;case "src":case "href":g=""+g;break;default:if(2<h.length&&("o"===h[0]||"O"===h[0])&&("n"===h[1]||"N"===h[1])||!Aa(h))break a;g=""+g}e.push(",");k=kc(k);e.push(k);e.push(",");g=
+kc(g);e.push(g)}}a.push("]");c=",[";d.state=3}});a.push("]")}
+function wc(a,b){a.push("[");var c="[";b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)a.push(c),d=y(JSON.stringify(""+d.props.href)),a.push(d),a.push("]"),c=",[";else{a.push(c);var e=d.props["data-precedence"],f=d.props,g=y(JSON.stringify(""+d.props.href));a.push(g);e=""+e;a.push(",");e=y(JSON.stringify(e));a.push(e);for(var h in f)if(x.call(f,h)&&(g=f[h],null!=g))switch(h){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");
+default:a:{e=a;var k=h.toLowerCase();switch(typeof g){case "function":case "symbol":break a}switch(h){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":k="class";g=""+g;break;case "hidden":if(!1===g)break a;g="";break;case "src":case "href":g=""+g;break;default:if(2<h.length&&("o"===h[0]||"O"===h[0])&&("n"===h[1]||"N"===h[1])||!Aa(h))break a;g=""+g}e.push(",");k=y(JSON.stringify(k));e.push(k);
+e.push(",");g=y(JSON.stringify(g));e.push(g)}}a.push("]");c=",[";d.state=3}});a.push("]")}
+function eb(a){var b=S?S:null;if(b){var c=b.resumableState,d=b.renderState;if("string"===typeof a&&a){if(!c.dnsResources.hasOwnProperty(a)){c.dnsResources[a]=null;c=d.headers;var e,f;if(f=c&&0<c.remainingCapacity)f=(e="<"+(""+a).replace(xc,yc)+">; rel=dns-prefetch",2<=(c.remainingCapacity-=e.length));f?(d.resets.dns[a]=null,c.preconnects&&(c.preconnects+=", "),c.preconnects+=e):(e=[],L(e,{href:a,rel:"dns-prefetch"}),d.preconnects.add(e))}zc(b)}}}
+function fb(a,b){var c=S?S:null;if(c){var d=c.resumableState,e=c.renderState;if("string"===typeof a&&a){var f="use-credentials"===b?"credentials":"string"===typeof b?"anonymous":"default";if(!d.connectResources[f].hasOwnProperty(a)){d.connectResources[f][a]=null;d=e.headers;var g,h;if(h=d&&0<d.remainingCapacity){h="<"+(""+a).replace(xc,yc)+">; rel=preconnect";if("string"===typeof b){var k=(""+b).replace(Ac,Bc);h+='; crossorigin="'+k+'"'}h=(g=h,2<=(d.remainingCapacity-=g.length))}h?(e.resets.connect[f][a]=
+null,d.preconnects&&(d.preconnects+=", "),d.preconnects+=g):(f=[],L(f,{rel:"preconnect",href:a,crossOrigin:b}),e.preconnects.add(f))}zc(c)}}}
+function gb(a,b,c){var d=S?S:null;if(d){var e=d.resumableState,f=d.renderState;if(b&&a){switch(b){case "image":if(c){var g=c.imageSrcSet;var h=c.imageSizes;var k=c.fetchPriority}var l=g?g+"\n"+(h||""):a;if(e.imageResources.hasOwnProperty(l))return;e.imageResources[l]=A;e=f.headers;var n;e&&0<e.remainingCapacity&&"high"===k&&(n=Tb(a,b,c),2<=(e.remainingCapacity-=n.length))?(f.resets.image[l]=A,e.highImagePreloads&&(e.highImagePreloads+=", "),e.highImagePreloads+=n):(e=[],L(e,r({rel:"preload",href:g?
+void 0:a,as:b},c)),"high"===k?f.highImagePreloads.add(e):(f.bulkPreloads.add(e),f.preloads.images.set(l,e)));break;case "style":if(e.styleResources.hasOwnProperty(a))return;g=[];L(g,r({rel:"preload",href:a,as:b},c));e.styleResources[a]=!c||"string"!==typeof c.crossOrigin&&"string"!==typeof c.integrity?A:[c.crossOrigin,c.integrity];f.preloads.stylesheets.set(a,g);f.bulkPreloads.add(g);break;case "script":if(e.scriptResources.hasOwnProperty(a))return;g=[];f.preloads.scripts.set(a,g);f.bulkPreloads.add(g);
+L(g,r({rel:"preload",href:a,as:b},c));e.scriptResources[a]=!c||"string"!==typeof c.crossOrigin&&"string"!==typeof c.integrity?A:[c.crossOrigin,c.integrity];break;default:if(e.unknownResources.hasOwnProperty(b)){if(g=e.unknownResources[b],g.hasOwnProperty(a))return}else g={},e.unknownResources[b]=g;g[a]=A;if((e=f.headers)&&0<e.remainingCapacity&&"font"===b&&(l=Tb(a,b,c),2<=(e.remainingCapacity-=l.length)))f.resets.font[a]=A,e.fontPreloads&&(e.fontPreloads+=", "),e.fontPreloads+=l;else switch(e=[],
+a=r({rel:"preload",href:a,as:b},c),L(e,a),b){case "font":f.fontPreloads.add(e);break;default:f.bulkPreloads.add(e)}}zc(d)}}}
+function hb(a,b){var c=S?S:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=b&&"string"===typeof b.as?b.as:"script";switch(f){case "script":if(d.moduleScriptResources.hasOwnProperty(a))return;f=[];d.moduleScriptResources[a]=!b||"string"!==typeof b.crossOrigin&&"string"!==typeof b.integrity?A:[b.crossOrigin,b.integrity];e.preloads.moduleScripts.set(a,f);break;default:if(d.moduleUnknownResources.hasOwnProperty(f)){var g=d.unknownResources[f];if(g.hasOwnProperty(a))return}else g={},d.moduleUnknownResources[f]=
+g;f=[];g[a]=A}L(f,r({rel:"modulepreload",href:a},b));e.bulkPreloads.add(f);zc(c)}}}
+function ib(a,b,c){var d=S?S:null;if(d){var e=d.resumableState,f=d.renderState;if(a){b=b||"default";var g=f.styles.get(b),h=e.styleResources.hasOwnProperty(a)?e.styleResources[a]:void 0;null!==h&&(e.styleResources[a]=null,g||(g={precedence:y(b),rules:[],hrefs:[],sheets:new Map},f.styles.set(b,g)),b={state:0,props:r({rel:"stylesheet",href:a,"data-precedence":b},c)},h&&(2===h.length&&Kb(b.props,h),(f=f.preloads.stylesheets.get(a))&&0<f.length?f.length=0:b.state=1),g.sheets.set(a,b),zc(d))}}}
+function jb(a,b){var c=S?S:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=d.scriptResources.hasOwnProperty(a)?d.scriptResources[a]:void 0;null!==f&&(d.scriptResources[a]=null,b=r({src:a,async:!0},b),f&&(2===f.length&&Kb(b,f),a=e.preloads.scripts.get(a))&&(a.length=0),a=[],e.scripts.add(a),Ob(a,b),zc(c))}}}
+function kb(a,b){var c=S?S:null;if(c){var d=c.resumableState,e=c.renderState;if(a){var f=d.moduleScriptResources.hasOwnProperty(a)?d.moduleScriptResources[a]:void 0;null!==f&&(d.moduleScriptResources[a]=null,b=r({src:a,type:"module",async:!0},b),f&&(2===f.length&&Kb(b,f),a=e.preloads.moduleScripts.get(a))&&(a.length=0),a=[],e.scripts.add(a),Ob(a,b),zc(c))}}}function Kb(a,b){null==a.crossOrigin&&(a.crossOrigin=b[0]);null==a.integrity&&(a.integrity=b[1])}
+function Tb(a,b,c){a=(""+a).replace(xc,yc);b=(""+b).replace(Ac,Bc);b="<"+a+'>; rel=preload; as="'+b+'"';for(var d in c)x.call(c,d)&&(a=c[d],"string"===typeof a&&(b+="; "+d.toLowerCase()+'="'+(""+a).replace(Ac,Bc)+'"'));return b}var xc=/[<>\r\n]/g;
+function yc(a){switch(a){case "<":return"%3C";case ">":return"%3E";case "\n":return"%0A";case "\r":return"%0D";default:throw Error("escapeLinkHrefForHeaderContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}}var Ac=/["';,\r\n]/g;
+function Bc(a){switch(a){case '"':return"%22";case "'":return"%27";case ";":return"%3B";case ",":return"%2C";case "\n":return"%0A";case "\r":return"%0D";default:throw Error("escapeStringForLinkHeaderQuotedParamValueContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}}function Cc(a){this.styles.add(a)}function Dc(a){this.stylesheets.add(a)}
+function Ec(a,b,c){if(b=a.onHeaders){var d=a.headers;if(d){var e=d.preconnects;d.fontPreloads&&(e&&(e+=", "),e+=d.fontPreloads);d.highImagePreloads&&(e&&(e+=", "),e+=d.highImagePreloads);if(!c){c=a.styles.values();var f=c.next();a:for(;0<d.remainingCapacity&&!f.done;f=c.next()){f=f.value.sheets.values();for(var g=f.next();0<d.remainingCapacity&&!g.done;g=f.next()){var h=g.value;g=h.props;var k=g.href;h=h.props;h=Tb(h.href,"style",{crossOrigin:h.crossOrigin,integrity:h.integrity,nonce:h.nonce,type:h.type,
+fetchPriority:h.fetchPriority,referrerPolicy:h.referrerPolicy,media:h.media});if(2<=(d.remainingCapacity-=h.length))a.resets.style[k]=A,e&&(e+=", "),e+=h,a.resets.style[k]="string"===typeof g.crossOrigin||"string"===typeof g.integrity?[g.crossOrigin,g.integrity]:A;else break a}}}e?b({Link:e}):b({});a.headers=null}}}
+function Fc(a,b){var c=a.idPrefix,d=[],e=a.bootstrapScriptContent,f=a.bootstrapScripts,g=a.bootstrapModules;void 0!==e&&d.push("<script>",(""+e).replace(mb,nb),"\x3c/script>");e=c+"P:";var h=c+"S:";c+="B:";var k=new Set,l=new Set,n=new Set,q=new Map,m=new Set,E=new Set,C=new Set,Q={images:new Map,stylesheets:new Map,scripts:new Map,moduleScripts:new Map};if(void 0!==f)for(var u=0;u<f.length;u++){var t=f[u],p,F=void 0,w=void 0,v={rel:"preload",as:"script",fetchPriority:"low",nonce:void 0};"string"===
+typeof t?v.href=p=t:(v.href=p=t.src,v.integrity=w="string"===typeof t.integrity?t.integrity:void 0,v.crossOrigin=F="string"===typeof t||null==t.crossOrigin?void 0:"use-credentials"===t.crossOrigin?"use-credentials":"");t=a;var B=p;t.scriptResources[B]=null;t.moduleScriptResources[B]=null;t=[];L(t,v);m.add(t);d.push('<script src="',y(p));"string"===typeof w&&d.push('" integrity="',y(w));"string"===typeof F&&d.push('" crossorigin="',y(F));d.push('" async="">\x3c/script>')}if(void 0!==g)for(f=0;f<g.length;f++)v=
+g[f],F=p=void 0,w={rel:"modulepreload",fetchPriority:"low",nonce:void 0},"string"===typeof v?w.href=u=v:(w.href=u=v.src,w.integrity=F="string"===typeof v.integrity?v.integrity:void 0,w.crossOrigin=p="string"===typeof v||null==v.crossOrigin?void 0:"use-credentials"===v.crossOrigin?"use-credentials":""),v=a,t=u,v.scriptResources[t]=null,v.moduleScriptResources[t]=null,v=[],L(v,w),m.add(v),d.push('<script type="module" src="',y(u)),"string"===typeof F&&d.push('" integrity="',y(F)),"string"===typeof p&&
+d.push('" crossorigin="',y(p)),d.push('" async="">\x3c/script>');return{placeholderPrefix:e,segmentPrefix:h,boundaryPrefix:c,startInlineScript:"<script>",htmlChunks:null,headChunks:null,externalRuntimeScript:null,bootstrapChunks:d,onHeaders:void 0,headers:null,resets:{font:{},dns:{},connect:{default:{},anonymous:{},credentials:{}},image:{},style:{}},charsetChunks:[],preconnectChunks:[],importMapChunks:[],preloadChunks:[],hoistableChunks:[],preconnects:k,fontPreloads:l,highImagePreloads:n,styles:q,
+bootstrapScripts:m,scripts:E,bulkPreloads:C,preloads:Q,boundaryResources:null,stylesToHoist:!1,generateStaticMarkup:b}}function Gc(a,b,c,d){if(c.generateStaticMarkup)return a.push(y(b)),!1;""===b?a=d:(d&&a.push("\x3c!-- --\x3e"),a.push(y(b)),a=!0);return a}
+var Hc=Symbol.for("react.element"),Ic=Symbol.for("react.portal"),Jc=Symbol.for("react.fragment"),Kc=Symbol.for("react.strict_mode"),Lc=Symbol.for("react.profiler"),Mc=Symbol.for("react.provider"),Nc=Symbol.for("react.context"),hd=Symbol.for("react.server_context"),id=Symbol.for("react.forward_ref"),jd=Symbol.for("react.suspense"),kd=Symbol.for("react.suspense_list"),ld=Symbol.for("react.memo"),md=Symbol.for("react.lazy"),nd=Symbol.for("react.scope"),od=Symbol.for("react.debug_trace_mode"),pd=Symbol.for("react.offscreen"),
+qd=Symbol.for("react.legacy_hidden"),rd=Symbol.for("react.cache"),sd=Symbol.for("react.default_value"),td=Symbol.iterator;
+function ud(a){if(null==a)return null;if("function"===typeof a)return a.displayName||a.name||null;if("string"===typeof a)return a;switch(a){case Jc:return"Fragment";case Ic:return"Portal";case Lc:return"Profiler";case Kc:return"StrictMode";case jd:return"Suspense";case kd:return"SuspenseList";case rd:return"Cache"}if("object"===typeof a)switch(a.$$typeof){case Nc:return(a.displayName||"Context")+".Consumer";case Mc:return(a._context.displayName||"Context")+".Provider";case id:var b=a.render;a=a.displayName;
+a||(a=b.displayName||b.name||"",a=""!==a?"ForwardRef("+a+")":"ForwardRef");return a;case ld:return b=a.displayName||null,null!==b?b:ud(a.type)||"Memo";case md:b=a._payload;a=a._init;try{return ud(a(b))}catch(c){}}return null}var vd={};function wd(a,b){a=a.contextTypes;if(!a)return vd;var c={},d;for(d in a)c[d]=b[d];return c}var xd=null;
+function yd(a,b){if(a!==b){a.context._currentValue2=a.parentValue;a=a.parent;var c=b.parent;if(null===a){if(null!==c)throw Error("The stacks must reach the root at the same time. This is a bug in React.");}else{if(null===c)throw Error("The stacks must reach the root at the same time. This is a bug in React.");yd(a,c)}b.context._currentValue2=b.value}}function zd(a){a.context._currentValue2=a.parentValue;a=a.parent;null!==a&&zd(a)}
+function Ad(a){var b=a.parent;null!==b&&Ad(b);a.context._currentValue2=a.value}function Bd(a,b){a.context._currentValue2=a.parentValue;a=a.parent;if(null===a)throw Error("The depth must equal at least at zero before reaching the root. This is a bug in React.");a.depth===b.depth?yd(a,b):Bd(a,b)}
+function Cd(a,b){var c=b.parent;if(null===c)throw Error("The depth must equal at least at zero before reaching the root. This is a bug in React.");a.depth===c.depth?yd(a,c):Cd(a,c);b.context._currentValue2=b.value}function Dd(a){var b=xd;b!==a&&(null===b?Ad(a):null===a?zd(b):b.depth===a.depth?yd(b,a):b.depth>a.depth?Bd(b,a):Cd(b,a),xd=a)}
+var Ed={isMounted:function(){return!1},enqueueSetState:function(a,b){a=a._reactInternals;null!==a.queue&&a.queue.push(b)},enqueueReplaceState:function(a,b){a=a._reactInternals;a.replace=!0;a.queue=[b]},enqueueForceUpdate:function(){}};
+function Fd(a,b,c,d){var e=void 0!==a.state?a.state:null;a.updater=Ed;a.props=c;a.state=e;var f={queue:[],replace:!1};a._reactInternals=f;var g=b.contextType;a.context="object"===typeof g&&null!==g?g._currentValue2:d;g=b.getDerivedStateFromProps;"function"===typeof g&&(g=g(c,e),e=null===g||void 0===g?e:r({},e,g),a.state=e);if("function"!==typeof b.getDerivedStateFromProps&&"function"!==typeof a.getSnapshotBeforeUpdate&&("function"===typeof a.UNSAFE_componentWillMount||"function"===typeof a.componentWillMount))if(b=
+a.state,"function"===typeof a.componentWillMount&&a.componentWillMount(),"function"===typeof a.UNSAFE_componentWillMount&&a.UNSAFE_componentWillMount(),b!==a.state&&Ed.enqueueReplaceState(a,a.state,null),null!==f.queue&&0<f.queue.length)if(b=f.queue,g=f.replace,f.queue=null,f.replace=!1,g&&1===b.length)a.state=b[0];else{f=g?b[0]:a.state;e=!0;for(g=g?1:0;g<b.length;g++){var h=b[g];h="function"===typeof h?h.call(a,f,c,d):h;null!=h&&(e?(e=!1,f=r({},f,h)):r(f,h))}a.state=f}else f.queue=null}
+var Gd={id:1,overflow:""};function Hd(a,b,c){var d=a.id;a=a.overflow;var e=32-Id(d)-1;d&=~(1<<e);c+=1;var f=32-Id(b)+e;if(30<f){var g=e-e%5;f=(d&(1<<g)-1).toString(32);d>>=g;e-=g;return{id:1<<32-Id(b)+e|c<<e|d,overflow:f+a}}return{id:1<<f|c<<e|d,overflow:a}}var Id=Math.clz32?Math.clz32:Jd,Kd=Math.log,Ld=Math.LN2;function Jd(a){a>>>=0;return 0===a?32:31-(Kd(a)/Ld|0)|0}var Md=Error("Suspense Exception: This is not a real error! It's an implementation detail of `use` to interrupt the current render. You must either rethrow it immediately, or move the `use` call outside of the `try/catch` block. Capturing without rethrowing will lead to unexpected behavior.\n\nTo handle async errors, wrap your component in an error boundary, or call the promise's `.catch` method and pass the result to `use`");
+function Nd(){}function Od(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(Nd,Nd),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;default:if("string"!==typeof b.status)switch(a=b,a.status="pending",a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}}),b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;}Pd=b;throw Md;}}var Pd=null;
+function Qd(){if(null===Pd)throw Error("Expected a suspended thenable. This is a bug in React. Please file an issue.");var a=Pd;Pd=null;return a}function Rd(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var Sd="function"===typeof Object.is?Object.is:Rd,U=null,Td=null,Ud=null,Vd=null,Wd=null,V=null,Xd=!1,Yd=!1,Zd=0,$d=0,ae=-1,be=0,ce=null,de=null,ee=0;
+function fe(){if(null===U)throw Error("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.");return U}
+function ge(){if(0<ee)throw Error("Rendered more hooks than during the previous render");return{memoizedState:null,queue:null,next:null}}function he(){null===V?null===Wd?(Xd=!1,Wd=V=ge()):(Xd=!0,V=Wd):null===V.next?(Xd=!1,V=V.next=ge()):(Xd=!0,V=V.next);return V}function ie(a,b,c,d){for(;Yd;)Yd=!1,$d=Zd=0,ae=-1,be=0,ee+=1,V=null,c=a(b,d);je();return c}function ke(){var a=ce;ce=null;return a}function je(){Vd=Ud=Td=U=null;Yd=!1;Wd=null;ee=0;V=de=null}
+function le(a,b){return"function"===typeof b?b(a):b}function me(a,b,c){U=fe();V=he();if(Xd){var d=V.queue;b=d.dispatch;if(null!==de&&(c=de.get(d),void 0!==c)){de.delete(d);d=V.memoizedState;do d=a(d,c.action),c=c.next;while(null!==c);V.memoizedState=d;return[d,b]}return[V.memoizedState,b]}a=a===le?"function"===typeof b?b():b:void 0!==c?c(b):b;V.memoizedState=a;a=V.queue={last:null,dispatch:null};a=a.dispatch=ne.bind(null,U,a);return[V.memoizedState,a]}
+function oe(a,b){U=fe();V=he();b=void 0===b?null:b;if(null!==V){var c=V.memoizedState;if(null!==c&&null!==b){var d=c[1];a:if(null===d)d=!1;else{for(var e=0;e<d.length&&e<b.length;e++)if(!Sd(b[e],d[e])){d=!1;break a}d=!0}if(d)return c[0]}}a=a();V.memoizedState=[a,b];return a}
+function ne(a,b,c){if(25<=ee)throw Error("Too many re-renders. React limits the number of renders to prevent an infinite loop.");if(a===U)if(Yd=!0,a={action:c,next:null},null===de&&(de=new Map),c=de.get(b),void 0===c)de.set(b,a);else{for(b=c;null!==b.next;)b=b.next;b.next=a}}function pe(){throw Error("startTransition cannot be called during server rendering.");}function qe(){throw Error("Cannot update optimistic state while rendering.");}
+function re(a){var b=be;be+=1;null===ce&&(ce=[]);return Od(ce,a,b)}function se(){throw Error("Cache cannot be refreshed during server rendering.");}function te(){}
+var ve={readContext:function(a){return a._currentValue2},use:function(a){if(null!==a&&"object"===typeof a){if("function"===typeof a.then)return re(a);if(a.$$typeof===Nc||a.$$typeof===hd)return a._currentValue2}throw Error("An unsupported type was passed to use(): "+String(a));},useContext:function(a){fe();return a._currentValue2},useMemo:oe,useReducer:me,useRef:function(a){U=fe();V=he();var b=V.memoizedState;return null===b?(a={current:a},V.memoizedState=a):b},useState:function(a){return me(le,a)},
+useInsertionEffect:te,useLayoutEffect:te,useCallback:function(a,b){return oe(function(){return a},b)},useImperativeHandle:te,useEffect:te,useDebugValue:te,useDeferredValue:function(a){fe();return a},useTransition:function(){fe();return[!1,pe]},useId:function(){var a=Td.treeContext;var b=a.overflow;a=a.id;a=(a&~(1<<32-Id(a)-1)).toString(32)+b;var c=ue;if(null===c)throw Error("Invalid hook call. Hooks can only be called inside of the body of a function component.");b=Zd++;a=":"+c.idPrefix+"R"+a;0<b&&
+(a+="H"+b.toString(32));return a+":"},useSyncExternalStore:function(a,b,c){if(void 0===c)throw Error("Missing getServerSnapshot, which is required for server-rendered content. Will revert to client rendering.");return c()},useCacheRefresh:function(){return se},useHostTransitionStatus:function(){fe();return Na},useOptimistic:function(a){fe();return[a,qe]},useFormState:function(a,b,c){fe();var d=$d++,e=Ud;if("function"===typeof a.$$FORM_ACTION){var f=null,g=Vd;e=e.formState;var h=a.$$IS_SIGNATURE_EQUAL;
+if(null!==e&&"function"===typeof h){var k=e[1];h.call(a,e[2],e[3])&&(f=void 0!==c?"p"+c:"k"+ka(JSON.stringify([g,null,d]),0),k===f&&(ae=d,b=e[0]))}var l=a.bind(null,b);a=function(q){l(q)};"function"===typeof l.$$FORM_ACTION&&(a.$$FORM_ACTION=function(q){q=l.$$FORM_ACTION(q);void 0!==c&&(c+="",q.action=c);var m=q.data;m&&(null===f&&(f=void 0!==c?"p"+c:"k"+ka(JSON.stringify([g,null,d]),0)),m.append("$ACTION_KEY",f));return q});return[b,a]}var n=a.bind(null,b);return[b,function(q){n(q)}]}},ue=null,we=
+{getCacheSignal:function(){throw Error("Not implemented.");},getCacheForType:function(){throw Error("Not implemented.");}},xe=Ma.ReactCurrentDispatcher,ye=Ma.ReactCurrentCache;function Be(a){console.error(a);return null}function Ce(){}
+function De(a,b,c,d,e,f,g,h,k,l,n,q){Oa.current=lb;var m=[],E=new Set;b={destination:null,flushScheduled:!1,resumableState:b,renderState:c,rootFormatContext:d,progressiveChunkSize:void 0===e?12800:e,status:0,fatalError:null,nextSegmentId:0,allPendingTasks:0,pendingRootTasks:0,completedRootSegment:null,abortableTasks:E,pingedTasks:m,clientRenderedBoundaries:[],completedBoundaries:[],partialBoundaries:[],trackedPostpones:null,onError:void 0===f?Be:f,onPostpone:void 0===n?Ce:n,onAllReady:void 0===g?
+Ce:g,onShellReady:void 0===h?Ce:h,onShellError:void 0===k?Ce:k,onFatalError:void 0===l?Ce:l,formState:void 0===q?null:q};c=Ee(b,0,null,d,!1,!1);c.parentFlushed=!0;a=Fe(b,null,a,-1,null,c,E,null,d,vd,null,Gd);m.push(a);return b}var S=null;function Ge(a,b){a.pingedTasks.push(b);1===a.pingedTasks.length&&(a.flushScheduled=null!==a.destination,He(a))}
+function Ie(a,b){return{status:0,rootSegmentID:-1,parentFlushed:!1,pendingTasks:0,completedSegments:[],byteSize:0,fallbackAbortableTasks:b,errorDigest:null,resources:{styles:new Set,stylesheets:new Set},trackedContentKeyPath:null,trackedFallbackNode:null}}
+function Fe(a,b,c,d,e,f,g,h,k,l,n,q){a.allPendingTasks++;null===e?a.pendingRootTasks++:e.pendingTasks++;var m={replay:null,node:c,childIndex:d,ping:function(){return Ge(a,m)},blockedBoundary:e,blockedSegment:f,abortSet:g,keyPath:h,formatContext:k,legacyContext:l,context:n,treeContext:q,thenableState:b};g.add(m);return m}
+function Je(a,b,c,d,e,f,g,h,k,l,n,q){a.allPendingTasks++;null===f?a.pendingRootTasks++:f.pendingTasks++;c.pendingTasks++;var m={replay:c,node:d,childIndex:e,ping:function(){return Ge(a,m)},blockedBoundary:f,blockedSegment:null,abortSet:g,keyPath:h,formatContext:k,legacyContext:l,context:n,treeContext:q,thenableState:b};g.add(m);return m}function Ee(a,b,c,d,e,f){return{status:0,id:-1,index:b,parentFlushed:!1,chunks:[],children:[],parentFormatContext:d,boundary:c,lastPushedText:e,textEmbedded:f}}
+function W(a,b){a=a.onError(b);if(null!=a&&"string"!==typeof a)throw Error('onError returned something with a type other than "string". onError should return a string and may return null or undefined but must not return anything else. It received something of type "'+typeof a+'" instead');return a}function Ke(a,b){var c=a.onShellError;c(b);c=a.onFatalError;c(b);null!==a.destination?(a.status=2,a.destination.destroy(b)):(a.status=1,a.fatalError=b)}
+function Le(a,b,c,d,e){var f=d.render(),g=e.childContextTypes;if(null!==g&&void 0!==g){c=b.legacyContext;if("function"!==typeof d.getChildContext)e=c;else{d=d.getChildContext();for(var h in d)if(!(h in g))throw Error((ud(e)||"Unknown")+'.getChildContext(): key "'+h+'" is not defined in childContextTypes.');e=r({},c,d)}b.legacyContext=e;Z(a,b,null,f,-1);b.legacyContext=c}else e=b.keyPath,b.keyPath=c,Z(a,b,null,f,-1),b.keyPath=e}
+function Me(a,b,c,d,e,f,g){var h=!1;if(0!==f&&null!==a.formState){var k=b.blockedSegment;if(null!==k){h=!0;k=k.chunks;for(var l=0;l<f;l++)l===g?k.push("\x3c!--F!--\x3e"):k.push("\x3c!--F--\x3e")}}f=b.keyPath;b.keyPath=c;e?(c=b.treeContext,b.treeContext=Hd(c,1,0),Ne(a,b,d,-1),b.treeContext=c):h?Ne(a,b,d,-1):Z(a,b,null,d,-1);b.keyPath=f}function Oe(a,b){if(a&&a.defaultProps){b=r({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}
+function Pe(a,b,c,d,e,f,g){if("function"===typeof e)if(e.prototype&&e.prototype.isReactComponent){d=wd(e,b.legacyContext);var h=e.contextType;h=new e(f,"object"===typeof h&&null!==h?h._currentValue2:d);Fd(h,e,f,d);Le(a,b,c,h,e)}else{h=wd(e,b.legacyContext);U={};Td=b;Ud=a;Vd=c;$d=Zd=0;ae=-1;be=0;ce=d;d=e(f,h);d=ie(e,f,d,h);g=0!==Zd;var k=$d,l=ae;"object"===typeof d&&null!==d&&"function"===typeof d.render&&void 0===d.$$typeof?(Fd(d,e,f,h),Le(a,b,c,d,e)):Me(a,b,c,d,g,k,l)}else if("string"===typeof e)if(d=
+b.blockedSegment,null===d)d=f.children,h=b.formatContext,g=b.keyPath,b.formatContext=zb(h,e,f),b.keyPath=c,Ne(a,b,d,-1),b.formatContext=h,b.keyPath=g;else{g=Sb(d.chunks,e,f,a.resumableState,a.renderState,b.formatContext,d.lastPushedText);d.lastPushedText=!1;h=b.formatContext;k=b.keyPath;b.formatContext=zb(h,e,f);b.keyPath=c;Ne(a,b,g,-1);b.formatContext=h;b.keyPath=k;a:{b=d.chunks;a=a.resumableState;switch(e){case "title":case "style":case "script":case "area":case "base":case "br":case "col":case "embed":case "hr":case "img":case "input":case "keygen":case "link":case "meta":case "param":case "source":case "track":case "wbr":break a;
+case "body":if(1>=h.insertionMode){a.hasBody=!0;break a}break;case "html":if(0===h.insertionMode){a.hasHtml=!0;break a}}b.push(Nb(e))}d.lastPushedText=!1}else{switch(e){case qd:case od:case Kc:case Lc:case Jc:e=b.keyPath;b.keyPath=c;Z(a,b,null,f.children,-1);b.keyPath=e;return;case pd:"hidden"!==f.mode&&(e=b.keyPath,b.keyPath=c,Z(a,b,null,f.children,-1),b.keyPath=e);return;case kd:e=b.keyPath;b.keyPath=c;Z(a,b,null,f.children,-1);b.keyPath=e;return;case nd:throw Error("ReactDOMServer does not yet support scope components.");
+case jd:a:if(null!==b.replay){e=b.keyPath;b.keyPath=c;c=f.children;try{Ne(a,b,c,-1)}finally{b.keyPath=e}}else{l=b.keyPath;e=b.blockedBoundary;var n=b.blockedSegment;d=f.fallback;var q=f.children;f=new Set;g=Ie(a,f);null!==a.trackedPostpones&&(g.trackedContentKeyPath=c);k=Ee(a,n.chunks.length,g,b.formatContext,!1,!1);n.children.push(k);n.lastPushedText=!1;var m=Ee(a,0,null,b.formatContext,!1,!1);m.parentFlushed=!0;b.blockedBoundary=g;b.blockedSegment=m;a.renderState.boundaryResources=g.resources;b.keyPath=
+c;try{if(Ne(a,b,q,-1),a.renderState.generateStaticMarkup||m.lastPushedText&&m.textEmbedded&&m.chunks.push("\x3c!-- --\x3e"),m.status=1,Qe(g,m),0===g.pendingTasks&&0===g.status){g.status=1;break a}}catch(E){m.status=4,g.status=4,h=W(a,E),g.errorDigest=h}finally{a.renderState.boundaryResources=e?e.resources:null,b.blockedBoundary=e,b.blockedSegment=n,b.keyPath=l}h=[c[0],"Suspense Fallback",c[2]];l=a.trackedPostpones;null!==l&&(n=[h[1],h[2],[],null],l.workingMap.set(h,n),5===g.status?l.workingMap.get(c)[4]=
+n:g.trackedFallbackNode=n);b=Fe(a,null,d,-1,e,k,f,h,b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}return}if("object"===typeof e&&null!==e)switch(e.$$typeof){case id:e=e.render;U={};Td=b;Ud=a;Vd=c;$d=Zd=0;ae=-1;be=0;ce=d;d=e(f,g);f=ie(e,f,d,g);Me(a,b,c,f,0!==Zd,$d,ae);return;case ld:e=e.type;f=Oe(e,f);Pe(a,b,c,d,e,f,g);return;case Mc:h=f.children;d=b.keyPath;e=e._context;f=f.value;g=e._currentValue2;e._currentValue2=f;k=xd;xd=f={parent:k,depth:null===k?0:k.depth+1,
+context:e,parentValue:g,value:f};b.context=f;b.keyPath=c;Z(a,b,null,h,-1);a=xd;if(null===a)throw Error("Tried to pop a Context at the root of the app. This is a bug in React.");c=a.parentValue;a.context._currentValue2=c===sd?a.context._defaultValue:c;a=xd=a.parent;b.context=a;b.keyPath=d;return;case Nc:f=f.children;f=f(e._currentValue2);e=b.keyPath;b.keyPath=c;Z(a,b,null,f,-1);b.keyPath=e;return;case md:h=e._init;e=h(e._payload);f=Oe(e,f);Pe(a,b,c,d,e,f,void 0);return}throw Error("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: "+
+((null==e?e:typeof e)+"."));}}function Re(a,b,c,d,e){var f=b.replay,g=b.blockedBoundary,h=Ee(a,0,null,b.formatContext,!1,!1);h.id=c;h.parentFlushed=!0;try{b.replay=null,b.blockedSegment=h,Ne(a,b,d,e),h.status=1,null===g?a.completedRootSegment=h:(Qe(g,h),g.parentFlushed&&a.partialBoundaries.push(g))}finally{b.replay=f,b.blockedSegment=null}}
+function Z(a,b,c,d,e){if(null!==b.replay&&"number"===typeof b.replay.slots)Re(a,b,b.replay.slots,d,e);else{b.node=d;b.childIndex=e;if("object"===typeof d&&null!==d){switch(d.$$typeof){case Hc:var f=d.type,g=d.key,h=d.props,k=d.ref,l=ud(f),n=null==g?-1===e?0:e:g;g=[b.keyPath,l,n];if(null!==b.replay)a:{var q=b.replay;e=q.nodes;for(d=0;d<e.length;d++){var m=e[d];if(n===m[1]){if(4===m.length){if(null!==l&&l!==m[0])throw Error("Expected the resume to render <"+m[0]+"> in this slot but instead it rendered <"+
+l+">. The tree doesn't match so React will fallback to client rendering.");l=m[2];m=m[3];n=b.node;b.replay={nodes:l,slots:m,pendingTasks:1};try{Pe(a,b,g,c,f,h,k);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--}catch(p){if("object"===typeof p&&null!==p&&(p===Md||"function"===typeof p.then))throw b.node===n&&(b.replay=q),p;b.replay.pendingTasks--;
+g=a;a=b.blockedBoundary;c=p;h=W(g,c);Se(g,a,l,m,c,h)}b.replay=q}else{if(f!==jd)throw Error("Expected the resume to render <Suspense> in this slot but instead it rendered <"+(ud(f)||"Unknown")+">. The tree doesn't match so React will fallback to client rendering.");b:{q=void 0;c=m[5];f=m[2];k=m[3];l=null===m[4]?[]:m[4][2];m=null===m[4]?null:m[4][3];n=b.keyPath;var E=b.replay,C=b.blockedBoundary,Q=h.children;h=h.fallback;var u=new Set,t=Ie(a,u);t.parentFlushed=!0;t.rootSegmentID=c;b.blockedBoundary=
+t;b.replay={nodes:f,slots:k,pendingTasks:1};a.renderState.boundaryResources=t.resources;try{Ne(a,b,Q,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--;if(0===t.pendingTasks&&0===t.status){t.status=1;a.completedBoundaries.push(t);break b}}catch(p){t.status=4,q=W(a,p),t.errorDigest=q,b.replay.pendingTasks--,a.clientRenderedBoundaries.push(t)}finally{a.renderState.boundaryResources=
+C?C.resources:null,b.blockedBoundary=C,b.replay=E,b.keyPath=n}b=Je(a,null,{nodes:l,slots:m,pendingTasks:0},h,-1,C,u,[g[0],"Suspense Fallback",g[2]],b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}}e.splice(d,1);break a}}}else Pe(a,b,g,c,f,h,k);return;case Ic:throw Error("Portals are not currently supported by the server renderer. Render them conditionally so that they only appear on the client render.");case md:h=d._init;d=h(d._payload);Z(a,b,null,d,e);return}if(La(d)){Te(a,
+b,d,e);return}null===d||"object"!==typeof d?h=null:(h=td&&d[td]||d["@@iterator"],h="function"===typeof h?h:null);if(h&&(h=h.call(d))){d=h.next();if(!d.done){g=[];do g.push(d.value),d=h.next();while(!d.done);Te(a,b,g,e)}return}if("function"===typeof d.then)return Z(a,b,null,re(d),e);if(d.$$typeof===Nc||d.$$typeof===hd)return Z(a,b,null,d._currentValue2,e);e=Object.prototype.toString.call(d);throw Error("Objects are not valid as a React child (found: "+("[object Object]"===e?"object with keys {"+Object.keys(d).join(", ")+
+"}":e)+"). If you meant to render a collection of children, use an array instead.");}"string"===typeof d?(e=b.blockedSegment,null!==e&&(e.lastPushedText=Gc(e.chunks,d,a.renderState,e.lastPushedText))):"number"===typeof d&&(e=b.blockedSegment,null!==e&&(e.lastPushedText=Gc(e.chunks,""+d,a.renderState,e.lastPushedText)))}}
+function Te(a,b,c,d){var e=b.keyPath;if(-1!==d&&(b.keyPath=[b.keyPath,"Fragment",d],null!==b.replay)){for(var f=b.replay,g=f.nodes,h=0;h<g.length;h++){var k=g[h];if(k[1]===d){d=k[2];k=k[3];b.replay={nodes:d,slots:k,pendingTasks:1};try{Te(a,b,c,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--}catch(q){if("object"===typeof q&&
+null!==q&&(q===Md||"function"===typeof q.then))throw q;b.replay.pendingTasks--;c=a;var l=b.blockedBoundary,n=q;a=W(c,n);Se(c,l,d,k,n,a)}b.replay=f;g.splice(h,1);break}}b.keyPath=e;return}f=b.treeContext;g=c.length;if(null!==b.replay&&(h=b.replay.slots,null!==h&&"object"===typeof h)){for(d=0;d<g;d++)k=c[d],b.treeContext=Hd(f,g,d),l=h[d],"number"===typeof l?(Re(a,b,l,k,d),delete h[d]):Ne(a,b,k,d);b.treeContext=f;b.keyPath=e;return}for(h=0;h<g;h++)d=c[h],b.treeContext=Hd(f,g,h),Ne(a,b,d,h);b.treeContext=
 f;b.keyPath=e}
-function Y(a,b,c,d){var e=b.formatContext,f=b.legacyContext,g=b.context,h=b.keyPath,k=b.treeContext,l=b.blockedSegment;if(null===l)try{return X(a,b,null,c,d)}catch(m){if(ie(),c=m===Ld?Pd():m,"object"===typeof c&&null!==c&&"function"===typeof c.then){d=je();a=Ie(a,d,b.replay,b.node,b.childIndex,b.blockedBoundary,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Cd(g);return}}else{var n=
-l.children.length,q=l.chunks.length;try{return X(a,b,null,c,d)}catch(m){if(ie(),l.children.length=n,l.chunks.length=q,c=m===Ld?Pd():m,"object"===typeof c&&null!==c&&"function"===typeof c.then){d=je();l=b.blockedSegment;n=De(a,l.chunks.length,null,b.formatContext,l.lastPushedText,!0);l.children.push(n);l.lastPushedText=!1;a=Ee(a,d,b.node,b.childIndex,b.blockedBoundary,n,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=
-f;b.context=g;b.keyPath=h;b.treeContext=k;Cd(g);return}}}b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Cd(g);throw c;}function Se(a){var b=a.blockedBoundary;a=a.blockedSegment;null!==a&&(a.status=3,Te(this,b,a))}
-function Qe(a,b,c,d,e,f){for(var g=0;g<c.length;g++){var h=c[g];if(4===h.length)Qe(a,b,h[2],h[3],e,f);else{h=h[5];var k=a,l=f,n=He(k,new Set);n.parentFlushed=!0;n.rootSegmentID=h;n.status=4;n.errorDigest=l;n.parentFlushed&&k.clientRenderedBoundaries.push(n)}}c.length=0;if(null!==d){if(null===b)throw Error("We should not have any resumable nodes in the shell. This is a bug in React.");4!==b.status&&(b.status=4,b.errorDigest=f,b.parentFlushed&&a.clientRenderedBoundaries.push(b));if("object"===typeof d)for(var q in d)delete d[q]}}
-function Ue(a,b,c){var d=a.blockedBoundary,e=a.blockedSegment;null!==e&&(e.status=3);if(null===d){if(1!==b.status&&2!==b.status){a=a.replay;if(null===a){U(b,c);Je(b,c);return}a.pendingTasks--;0===a.pendingTasks&&0<a.nodes.length&&(d=U(b,c),Qe(b,null,a.nodes,a.slots,c,d));b.pendingRootTasks--;0===b.pendingRootTasks&&Ve(b)}}else d.pendingTasks--,4!==d.status&&(d.status=4,d.errorDigest=U(b,c),d.parentFlushed&&b.clientRenderedBoundaries.push(d)),d.fallbackAbortableTasks.forEach(function(f){return Ue(f,
-b,c)}),d.fallbackAbortableTasks.clear();b.allPendingTasks--;0===b.allPendingTasks&&We(b)}function Ve(a){null===a.trackedPostpones&&Dc(a.renderState,a.resumableState,!0);a.onShellError=Be;a=a.onShellReady;a()}function We(a){Dc(a.renderState,a.resumableState,null===a.trackedPostpones?!0:null===a.completedRootSegment||5!==a.completedRootSegment.status);a=a.onAllReady;a()}
-function Oe(a,b){if(0===b.chunks.length&&1===b.children.length&&null===b.children[0].boundary){var c=b.children[0];c.id=b.id;c.parentFlushed=!0;1===c.status&&Oe(a,c)}else a.completedSegments.push(b)}
-function Te(a,b,c){if(null===b){if(null!==c&&c.parentFlushed){if(null!==a.completedRootSegment)throw Error("There can only be one root segment. This is a bug in React.");a.completedRootSegment=c}a.pendingRootTasks--;0===a.pendingRootTasks&&Ve(a)}else b.pendingTasks--,4!==b.status&&(0===b.pendingTasks?(0===b.status&&(b.status=1),null!==c&&c.parentFlushed&&1===c.status&&Oe(b,c),b.parentFlushed&&a.completedBoundaries.push(b),1===b.status&&(b.fallbackAbortableTasks.forEach(Se,a),b.fallbackAbortableTasks.clear())):
-null!==c&&c.parentFlushed&&1===c.status&&(Oe(b,c),1===b.completedSegments.length&&b.parentFlushed&&a.partialBoundaries.push(b)));a.allPendingTasks--;0===a.allPendingTasks&&We(a)}
-function Ge(a){if(2!==a.status){var b=wd,c=we.current;we.current=ue;var d=ze.current;ze.current=ve;var e=P;P=a;var f=te;te=a.resumableState;try{var g=a.pingedTasks,h;for(h=0;h<g.length;h++){var k=g[h],l=a,n=k.blockedBoundary;l.renderState.boundaryResources=n?n.resources:null;var q=k.blockedSegment;if(null===q){var m=l;if(0!==k.replay.pendingTasks){Cd(k.context);try{var F=k.thenableState;k.thenableState=null;X(m,k,F,k.node,k.childIndex);if(1===k.replay.pendingTasks&&0<k.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");
-k.replay.pendingTasks--;k.abortSet.delete(k);Te(m,k.blockedBoundary,null)}catch(M){ie();var z=M===Ld?Pd():M;if("object"===typeof z&&null!==z&&"function"===typeof z.then){var S=k.ping;z.then(S,S);k.thenableState=je()}else{k.replay.pendingTasks--;k.abortSet.delete(k);l=void 0;var t=m,y=k.blockedBoundary,p=z,Z=k.replay.nodes,G=k.replay.slots;l=U(t,p);Qe(t,y,Z,G,p,l);m.pendingRootTasks--;0===m.pendingRootTasks&&Ve(m);m.allPendingTasks--;0===m.allPendingTasks&&We(m)}}finally{m.renderState.boundaryResources=
-null}}}else if(m=void 0,t=q,0===t.status){Cd(k.context);var aa=t.children.length,A=t.chunks.length;try{var L=k.thenableState;k.thenableState=null;X(l,k,L,k.node,k.childIndex);l.renderState.generateStaticMarkup||t.lastPushedText&&t.textEmbedded&&t.chunks.push("\x3c!-- --\x3e");k.abortSet.delete(k);t.status=1;Te(l,k.blockedBoundary,t)}catch(M){ie();t.children.length=aa;t.chunks.length=A;var w=M===Ld?Pd():M;if("object"===typeof w&&null!==w&&"function"===typeof w.then){var ea=k.ping;w.then(ea,ea);k.thenableState=
-je()}else{k.abortSet.delete(k);t.status=4;var Q=k.blockedBoundary;m=U(l,w);null===Q?Je(l,w):(Q.pendingTasks--,4!==Q.status&&(Q.status=4,Q.errorDigest=m,Q.parentFlushed&&l.clientRenderedBoundaries.push(Q)));l.allPendingTasks--;0===l.allPendingTasks&&We(l)}}finally{l.renderState.boundaryResources=null}}}g.splice(0,h);null!==a.destination&&Xe(a,a.destination)}catch(M){U(a,M),Je(a,M)}finally{te=f,we.current=c,ze.current=d,c===ue&&Cd(b),P=e}}}
-function Ye(a,b,c){c.parentFlushed=!0;switch(c.status){case 0:c.id=a.nextSegmentId++;case 5:var d=c.id;c.lastPushedText=!1;c.textEmbedded=!1;a=a.renderState;b.push('<template id="');b.push(a.placeholderPrefix);a=d.toString(16);b.push(a);return b.push('"></template>');case 1:c.status=2;var e=!0;d=c.chunks;var f=0;c=c.children;for(var g=0;g<c.length;g++){for(e=c[g];f<e.index;f++)b.push(d[f]);e=Ze(a,b,e)}for(;f<d.length-1;f++)b.push(d[f]);f<d.length&&(e=b.push(d[f]));return e;default:throw Error("Aborted, errored or already flushed boundaries should not be flushed again. This is a bug in React.");
+function Ne(a,b,c,d){var e=b.formatContext,f=b.legacyContext,g=b.context,h=b.keyPath,k=b.treeContext,l=b.blockedSegment;if(null===l)try{return Z(a,b,null,c,d)}catch(m){if(je(),c=m===Md?Qd():m,"object"===typeof c&&null!==c&&"function"===typeof c.then){d=ke();a=Je(a,d,b.replay,b.node,b.childIndex,b.blockedBoundary,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Dd(g);return}}else{var n=
+l.children.length,q=l.chunks.length;try{return Z(a,b,null,c,d)}catch(m){if(je(),l.children.length=n,l.chunks.length=q,c=m===Md?Qd():m,"object"===typeof c&&null!==c&&"function"===typeof c.then){d=ke();l=b.blockedSegment;n=Ee(a,l.chunks.length,null,b.formatContext,l.lastPushedText,!0);l.children.push(n);l.lastPushedText=!1;a=Fe(a,d,b.node,b.childIndex,b.blockedBoundary,n,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=
+f;b.context=g;b.keyPath=h;b.treeContext=k;Dd(g);return}}}b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=k;Dd(g);throw c;}function Ue(a){var b=a.blockedBoundary;a=a.blockedSegment;null!==a&&(a.status=3,Ve(this,b,a))}
+function Se(a,b,c,d,e,f){for(var g=0;g<c.length;g++){var h=c[g];if(4===h.length)Se(a,b,h[2],h[3],e,f);else{h=h[5];var k=a,l=f,n=Ie(k,new Set);n.parentFlushed=!0;n.rootSegmentID=h;n.status=4;n.errorDigest=l;n.parentFlushed&&k.clientRenderedBoundaries.push(n)}}c.length=0;if(null!==d){if(null===b)throw Error("We should not have any resumable nodes in the shell. This is a bug in React.");4!==b.status&&(b.status=4,b.errorDigest=f,b.parentFlushed&&a.clientRenderedBoundaries.push(b));if("object"===typeof d)for(var q in d)delete d[q]}}
+function We(a,b,c){var d=a.blockedBoundary,e=a.blockedSegment;null!==e&&(e.status=3);if(null===d){if(1!==b.status&&2!==b.status){a=a.replay;if(null===a){W(b,c);Ke(b,c);return}a.pendingTasks--;0===a.pendingTasks&&0<a.nodes.length&&(d=W(b,c),Se(b,null,a.nodes,a.slots,c,d));b.pendingRootTasks--;0===b.pendingRootTasks&&Xe(b)}}else d.pendingTasks--,4!==d.status&&(d.status=4,d.errorDigest=W(b,c),d.parentFlushed&&b.clientRenderedBoundaries.push(d)),d.fallbackAbortableTasks.forEach(function(f){return We(f,
+b,c)}),d.fallbackAbortableTasks.clear();b.allPendingTasks--;0===b.allPendingTasks&&Ye(b)}function Xe(a){null===a.trackedPostpones&&Ec(a.renderState,a.resumableState,!0);a.onShellError=Ce;a=a.onShellReady;a()}function Ye(a){Ec(a.renderState,a.resumableState,null===a.trackedPostpones?!0:null===a.completedRootSegment||5!==a.completedRootSegment.status);a=a.onAllReady;a()}
+function Qe(a,b){if(0===b.chunks.length&&1===b.children.length&&null===b.children[0].boundary){var c=b.children[0];c.id=b.id;c.parentFlushed=!0;1===c.status&&Qe(a,c)}else a.completedSegments.push(b)}
+function Ve(a,b,c){if(null===b){if(null!==c&&c.parentFlushed){if(null!==a.completedRootSegment)throw Error("There can only be one root segment. This is a bug in React.");a.completedRootSegment=c}a.pendingRootTasks--;0===a.pendingRootTasks&&Xe(a)}else b.pendingTasks--,4!==b.status&&(0===b.pendingTasks?(0===b.status&&(b.status=1),null!==c&&c.parentFlushed&&1===c.status&&Qe(b,c),b.parentFlushed&&a.completedBoundaries.push(b),1===b.status&&(b.fallbackAbortableTasks.forEach(Ue,a),b.fallbackAbortableTasks.clear())):
+null!==c&&c.parentFlushed&&1===c.status&&(Qe(b,c),1===b.completedSegments.length&&b.parentFlushed&&a.partialBoundaries.push(b)));a.allPendingTasks--;0===a.allPendingTasks&&Ye(a)}
+function He(a){if(2!==a.status){var b=xd,c=xe.current;xe.current=ve;var d=ye.current;ye.current=we;var e=S;S=a;var f=ue;ue=a.resumableState;try{var g=a.pingedTasks,h;for(h=0;h<g.length;h++){var k=g[h],l=a,n=k.blockedBoundary;l.renderState.boundaryResources=n?n.resources:null;var q=k.blockedSegment;if(null===q){var m=l;if(0!==k.replay.pendingTasks){Dd(k.context);try{var E=k.thenableState;k.thenableState=null;Z(m,k,E,k.node,k.childIndex);if(1===k.replay.pendingTasks&&0<k.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");
+k.replay.pendingTasks--;k.abortSet.delete(k);Ve(m,k.blockedBoundary,null)}catch(O){je();var C=O===Md?Qd():O;if("object"===typeof C&&null!==C&&"function"===typeof C.then){var Q=k.ping;C.then(Q,Q);k.thenableState=ke()}else{k.replay.pendingTasks--;k.abortSet.delete(k);l=void 0;var u=m,t=k.blockedBoundary,p=C,F=k.replay.nodes,w=k.replay.slots;l=W(u,p);Se(u,t,F,w,p,l);m.pendingRootTasks--;0===m.pendingRootTasks&&Xe(m);m.allPendingTasks--;0===m.allPendingTasks&&Ye(m)}}finally{m.renderState.boundaryResources=
+null}}}else if(m=void 0,u=q,0===u.status){Dd(k.context);var v=u.children.length,B=u.chunks.length;try{var N=k.thenableState;k.thenableState=null;Z(l,k,N,k.node,k.childIndex);l.renderState.generateStaticMarkup||u.lastPushedText&&u.textEmbedded&&u.chunks.push("\x3c!-- --\x3e");k.abortSet.delete(k);u.status=1;Ve(l,k.blockedBoundary,u)}catch(O){je();u.children.length=v;u.chunks.length=B;var z=O===Md?Qd():O;if("object"===typeof z&&null!==z&&"function"===typeof z.then){var ea=k.ping;z.then(ea,ea);k.thenableState=
+ke()}else{k.abortSet.delete(k);u.status=4;var T=k.blockedBoundary;m=W(l,z);null===T?Ke(l,z):(T.pendingTasks--,4!==T.status&&(T.status=4,T.errorDigest=m,T.parentFlushed&&l.clientRenderedBoundaries.push(T)));l.allPendingTasks--;0===l.allPendingTasks&&Ye(l)}}finally{l.renderState.boundaryResources=null}}}g.splice(0,h);null!==a.destination&&Ze(a,a.destination)}catch(O){W(a,O),Ke(a,O)}finally{ue=f,xe.current=c,ye.current=d,c===ve&&Dd(b),S=e}}}
+function $e(a,b,c){c.parentFlushed=!0;switch(c.status){case 0:c.id=a.nextSegmentId++;case 5:var d=c.id;c.lastPushedText=!1;c.textEmbedded=!1;a=a.renderState;b.push('<template id="');b.push(a.placeholderPrefix);a=d.toString(16);b.push(a);return b.push('"></template>');case 1:c.status=2;var e=!0;d=c.chunks;var f=0;c=c.children;for(var g=0;g<c.length;g++){for(e=c[g];f<e.index;f++)b.push(d[f]);e=af(a,b,e)}for(;f<d.length-1;f++)b.push(d[f]);f<d.length&&(e=b.push(d[f]));return e;default:throw Error("Aborted, errored or already flushed boundaries should not be flushed again. This is a bug in React.");
 }}
-function Ze(a,b,c){var d=c.boundary;if(null===d)return Ye(a,b,c);d.parentFlushed=!0;if(4===d.status)return a.renderState.generateStaticMarkup||(d=d.errorDigest,b.push("\x3c!--$!--\x3e"),b.push("<template"),d&&(b.push(' data-dgst="'),d=v(d),b.push(d),b.push('"')),b.push("></template>")),Ye(a,b,c),a=a.renderState.generateStaticMarkup?!0:b.push("\x3c!--/$--\x3e"),a;if(1!==d.status)return 0===d.status&&(d.rootSegmentID=a.nextSegmentId++),0<d.completedSegments.length&&a.partialBoundaries.push(d),Vb(b,a.renderState,
-d.rootSegmentID),Ye(a,b,c),b.push("\x3c!--/$--\x3e");if(d.byteSize>a.progressiveChunkSize)return d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),Vb(b,a.renderState,d.rootSegmentID),Ye(a,b,c),b.push("\x3c!--/$--\x3e");c=d.resources;var e=a.renderState.boundaryResources;e&&(c.styles.forEach(Bc,e),c.stylesheets.forEach(Cc,e));a.renderState.generateStaticMarkup||b.push("\x3c!--$--\x3e");c=d.completedSegments;if(1!==c.length)throw Error("A previously unvisited boundary must have exactly one root segment. This is a bug in React.");
-Ze(a,b,c[0]);a=a.renderState.generateStaticMarkup?!0:b.push("\x3c!--/$--\x3e");return a}function $e(a,b,c){ec(b,a.renderState,c.parentFormatContext,c.id);Ze(a,b,c);return fc(b,c.parentFormatContext)}
-function af(a,b,c){a.renderState.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e<d.length;e++)bf(a,b,c,d[e]);d.length=0;oc(b,c.resources,a.renderState);d=a.resumableState;a=a.renderState;e=c.rootSegmentID;c=c.resources;var f=a.stylesToHoist;a.stylesToHoist=!1;var g=0===d.streamingFormat;g?(b.push(a.startInlineScript),f?0===(d.instructions&2)?(d.instructions|=10,b.push('$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};$RR("')):
+function af(a,b,c){var d=c.boundary;if(null===d)return $e(a,b,c);d.parentFlushed=!0;if(4===d.status)return a.renderState.generateStaticMarkup||(d=d.errorDigest,b.push("\x3c!--$!--\x3e"),b.push("<template"),d&&(b.push(' data-dgst="'),d=y(d),b.push(d),b.push('"')),b.push("></template>")),$e(a,b,c),a=a.renderState.generateStaticMarkup?!0:b.push("\x3c!--/$--\x3e"),a;if(1!==d.status)return 0===d.status&&(d.rootSegmentID=a.nextSegmentId++),0<d.completedSegments.length&&a.partialBoundaries.push(d),ec(b,a.renderState,
+d.rootSegmentID),$e(a,b,c),b.push("\x3c!--/$--\x3e");if(d.byteSize>a.progressiveChunkSize)return d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),ec(b,a.renderState,d.rootSegmentID),$e(a,b,c),b.push("\x3c!--/$--\x3e");c=d.resources;var e=a.renderState.boundaryResources;e&&(c.styles.forEach(Cc,e),c.stylesheets.forEach(Dc,e));a.renderState.generateStaticMarkup||b.push("\x3c!--$--\x3e");c=d.completedSegments;if(1!==c.length)throw Error("A previously unvisited boundary must have exactly one root segment. This is a bug in React.");
+af(a,b,c[0]);a=a.renderState.generateStaticMarkup?!0:b.push("\x3c!--/$--\x3e");return a}function bf(a,b,c){fc(b,a.renderState,c.parentFormatContext,c.id);af(a,b,c);return gc(b,c.parentFormatContext)}
+function cf(a,b,c){a.renderState.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e<d.length;e++)df(a,b,c,d[e]);d.length=0;pc(b,c.resources,a.renderState);d=a.resumableState;a=a.renderState;e=c.rootSegmentID;c=c.resources;var f=a.stylesToHoist;a.stylesToHoist=!1;var g=0===d.streamingFormat;g?(b.push(a.startInlineScript),f?0===(d.instructions&2)?(d.instructions|=10,b.push('$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};$RR("')):
 0===(d.instructions&8)?(d.instructions|=8,b.push('$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};$RR("')):
 b.push('$RR("'):0===(d.instructions&2)?(d.instructions|=2,b.push('$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};$RC("')):
-b.push('$RC("')):f?b.push('<template data-rri="" data-bid="'):b.push('<template data-rci="" data-bid="');d=e.toString(16);b.push(a.boundaryPrefix);b.push(d);g?b.push('","'):b.push('" data-sid="');b.push(a.segmentPrefix);b.push(d);f?g?(b.push('",'),uc(b,c)):(b.push('" data-sty="'),vc(b,c)):g&&b.push('"');d=g?b.push(")\x3c/script>"):b.push('"></template>');return Ub(b,a)&&d}
-function bf(a,b,c,d){if(2===d.status)return!0;var e=d.id;if(-1===e){if(-1===(d.id=c.rootSegmentID))throw Error("A root segment ID must have been assigned by now. This is a bug in React.");return $e(a,b,d)}if(e===c.rootSegmentID)return $e(a,b,d);$e(a,b,d);c=a.resumableState;a=a.renderState;(d=0===c.streamingFormat)?(b.push(a.startInlineScript),0===(c.instructions&1)?(c.instructions|=1,b.push('$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};$RS("')):
+b.push('$RC("')):f?b.push('<template data-rri="" data-bid="'):b.push('<template data-rci="" data-bid="');e=e.toString(16);b.push(a.boundaryPrefix);b.push(e);g?b.push('","'):b.push('" data-sid="');b.push(a.segmentPrefix);b.push(e);f?g?(b.push('",'),vc(b,c)):(b.push('" data-sty="'),wc(b,c)):g&&b.push('"');c=g?b.push(")\x3c/script>"):b.push('"></template>');return Vb(b,a,d)&&c}
+function df(a,b,c,d){if(2===d.status)return!0;var e=d.id;if(-1===e){if(-1===(d.id=c.rootSegmentID))throw Error("A root segment ID must have been assigned by now. This is a bug in React.");return bf(a,b,d)}if(e===c.rootSegmentID)return bf(a,b,d);bf(a,b,d);c=a.resumableState;a=a.renderState;(d=0===c.streamingFormat)?(b.push(a.startInlineScript),0===(c.instructions&1)?(c.instructions|=1,b.push('$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};$RS("')):
 b.push('$RS("')):b.push('<template data-rsi="" data-sid="');b.push(a.segmentPrefix);e=e.toString(16);b.push(e);d?b.push('","'):b.push('" data-pid="');b.push(a.placeholderPrefix);b.push(e);b=d?b.push('")\x3c/script>'):b.push('"></template>');return b}
-function Xe(a,b){try{var c,d=a.completedRootSegment;if(null!==d)if(5!==d.status&&0===a.pendingRootTasks){var e=a.renderState;if((0!==a.allPendingTasks||null!==a.trackedPostpones)&&e.externalRuntimeScript){var f=e.externalRuntimeScript,g=a.resumableState,h=f.src,k=f.chunks;g.scriptResources.hasOwnProperty(h)||(g.scriptResources[h]=null,e.scripts.add(k))}var l=e.htmlChunks,n=e.headChunks;f=0;if(l){for(f=0;f<l.length;f++)b.push(l[f]);if(n)for(f=0;f<n.length;f++)b.push(n[f]);else{var q=K("head");b.push(q);
-b.push(">")}}else if(n)for(f=0;f<n.length;f++)b.push(n[f]);var m=e.charsetChunks;for(f=0;f<m.length;f++)b.push(m[f]);m.length=0;e.preconnects.forEach(N,b);e.preconnects.clear();var F=e.preconnectChunks;for(f=0;f<F.length;f++)b.push(F[f]);F.length=0;e.fontPreloads.forEach(N,b);e.fontPreloads.clear();e.highImagePreloads.forEach(N,b);e.highImagePreloads.clear();e.styles.forEach(rc,b);var z=e.importMapChunks;for(f=0;f<z.length;f++)b.push(z[f]);z.length=0;e.bootstrapScripts.forEach(N,b);e.scripts.forEach(N,
-b);e.scripts.clear();e.bulkPreloads.forEach(N,b);e.bulkPreloads.clear();var S=e.preloadChunks;for(f=0;f<S.length;f++)b.push(S[f]);S.length=0;var t=e.hoistableChunks;for(f=0;f<t.length;f++)b.push(t[f]);t.length=0;if(l&&null===n){var y=Mb("head");b.push(y)}Ze(a,b,d);a.completedRootSegment=null;Ub(b,a.renderState)}else return;var p=a.renderState;d=0;p.preconnects.forEach(N,b);p.preconnects.clear();var Z=p.preconnectChunks;for(d=0;d<Z.length;d++)b.push(Z[d]);Z.length=0;p.fontPreloads.forEach(N,b);p.fontPreloads.clear();
-p.highImagePreloads.forEach(N,b);p.highImagePreloads.clear();p.styles.forEach(tc,b);p.scripts.forEach(N,b);p.scripts.clear();p.bulkPreloads.forEach(N,b);p.bulkPreloads.clear();var G=p.preloadChunks;for(d=0;d<G.length;d++)b.push(G[d]);G.length=0;var aa=p.hoistableChunks;for(d=0;d<aa.length;d++)b.push(aa[d]);aa.length=0;var A=a.clientRenderedBoundaries;for(c=0;c<A.length;c++){var L=A[c];p=b;var w=a.resumableState,ea=a.renderState,Q=L.rootSegmentID,M=L.errorDigest,ma=L.errorMessage,fa=L.errorComponentStack,
-V=0===w.streamingFormat;V?(p.push(ea.startInlineScript),0===(w.instructions&4)?(w.instructions|=4,p.push('$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};;$RX("')):p.push('$RX("')):p.push('<template data-rxi="" data-bid="');p.push(ea.boundaryPrefix);var Pa=Q.toString(16);p.push(Pa);V&&p.push('"');if(M||ma||fa)if(V){p.push(",");var Qa=hc(M||"");p.push(Qa)}else{p.push('" data-dgst="');
-var Ra=v(M||"");p.push(Ra)}if(ma||fa)if(V){p.push(",");var na=hc(ma||"");p.push(na)}else{p.push('" data-msg="');var O=v(ma||"");p.push(O)}if(fa)if(V){p.push(",");var qb=hc(fa);p.push(qb)}else{p.push('" data-stck="');var oa=v(fa);p.push(oa)}if(V?!p.push(")\x3c/script>"):!p.push('"></template>')){a.destination=null;c++;A.splice(0,c);return}}A.splice(0,c);var pa=a.completedBoundaries;for(c=0;c<pa.length;c++)if(!af(a,b,pa[c])){a.destination=null;c++;pa.splice(0,c);return}pa.splice(0,c);var ba=a.partialBoundaries;
-for(c=0;c<ba.length;c++){var qa=ba[c];a:{A=a;L=b;A.renderState.boundaryResources=qa.resources;var ra=qa.completedSegments;for(w=0;w<ra.length;w++)if(!bf(A,L,qa,ra[w])){w++;ra.splice(0,w);var Sa=!1;break a}ra.splice(0,w);Sa=oc(L,qa.resources,A.renderState)}if(!Sa){a.destination=null;c++;ba.splice(0,c);return}}ba.splice(0,c);var sa=a.completedBoundaries;for(c=0;c<sa.length;c++)if(!af(a,b,sa[c])){a.destination=null;c++;sa.splice(0,c);return}sa.splice(0,c)}finally{0===a.allPendingTasks&&0===a.pingedTasks.length&&
-0===a.clientRenderedBoundaries.length&&0===a.completedBoundaries.length&&(a.flushScheduled=!1,c=a.resumableState,c.hasBody&&(ba=Mb("body"),b.push(ba)),c.hasHtml&&(c=Mb("html"),b.push(c)),b.push(null),a.destination=null)}}function cf(a){a.flushScheduled=null!==a.destination;Ge(a);null===a.trackedPostpones&&Dc(a.renderState,a.resumableState,0===a.pendingRootTasks)}
-function yc(a){if(!1===a.flushScheduled&&0===a.pingedTasks.length&&null!==a.destination){a.flushScheduled=!0;var b=a.destination;b?Xe(a,b):a.flushScheduled=!1}}function df(a,b){if(1===a.status)a.status=2,b.destroy(a.fatalError);else if(2!==a.status&&null===a.destination){a.destination=b;try{Xe(a,b)}catch(c){U(a,c),Je(a,c)}}}
-function ef(a,b){try{var c=a.abortableTasks;if(0<c.size){var d=void 0===b?Error("The render was aborted by the server without a reason."):b;c.forEach(function(e){return Ue(e,a,d)});c.clear()}null!==a.destination&&Xe(a,a.destination)}catch(e){U(a,e),Je(a,e)}}function ff(){}
-function gf(a,b,c,d){var e=!1,f=null,g="",h=!1;b=nb(b?b.identifierPrefix:void 0,void 0);a=Ce(a,b,Ec(b,c),ob(),Infinity,ff,void 0,function(){h=!0},void 0,void 0,void 0);cf(a);ef(a,d);df(a,{push:function(k){null!==k&&(g+=k);return!0},destroy:function(k){e=!0;f=k}});if(e&&f!==d)throw f;if(!h)throw Error("A component suspended while responding to synchronous input. This will cause the UI to be replaced with a loading indicator. To fix, updates that suspend should be wrapped with startTransition.");return g}
-function hf(a,b){a.prototype=Object.create(b.prototype);a.prototype.constructor=a;a.__proto__=b}var jf=function(a){function b(){var d=a.call(this,{})||this;d.request=null;d.startedFlowing=!1;return d}hf(b,a);var c=b.prototype;c._destroy=function(d,e){ef(this.request);e(d)};c._read=function(){this.startedFlowing&&df(this.request,this)};return b}(ka.Readable);function kf(){}
-function lf(a,b){var c=new jf;b=nb(b?b.identifierPrefix:void 0,void 0);var d=Ce(a,b,Ec(b,!1),ob(),Infinity,kf,function(){c.startedFlowing=!0;df(d,c)},void 0,void 0,void 0);c.request=d;cf(d);return c}exports.renderToNodeStream=function(a,b){return lf(a,b)};exports.renderToStaticMarkup=function(a,b){return gf(a,b,!0,'The server used "renderToStaticMarkup" which does not support Suspense. If you intended to have the server wait for the suspended component please switch to "renderToPipeableStream" which supports Suspense on the server')};
-exports.renderToStaticNodeStream=function(a,b){return lf(a,b)};exports.renderToString=function(a,b){return gf(a,b,!1,'The server used "renderToString" which does not support Suspense. If you intended for this Suspense boundary to render the fallback content on the server consider throwing an Error somewhere within the Suspense boundary. If you intended to have the server wait for the suspended component please switch to "renderToPipeableStream" which supports Suspense on the server')};
-exports.version="18.3.0-canary-2983249dd-20231107";
+function Ze(a,b){try{var c,d=a.completedRootSegment;if(null!==d)if(5!==d.status&&0===a.pendingRootTasks){var e=a.renderState;if((0!==a.allPendingTasks||null!==a.trackedPostpones)&&e.externalRuntimeScript){var f=e.externalRuntimeScript,g=a.resumableState,h=f.src,k=f.chunks;g.scriptResources.hasOwnProperty(h)||(g.scriptResources[h]=null,e.scripts.add(k))}var l=e.htmlChunks,n=e.headChunks;f=0;if(l){for(f=0;f<l.length;f++)b.push(l[f]);if(n)for(f=0;f<n.length;f++)b.push(n[f]);else{var q=M("head");b.push(q);
+b.push(">")}}else if(n)for(f=0;f<n.length;f++)b.push(n[f]);var m=e.charsetChunks;for(f=0;f<m.length;f++)b.push(m[f]);m.length=0;e.preconnects.forEach(P,b);e.preconnects.clear();var E=e.preconnectChunks;for(f=0;f<E.length;f++)b.push(E[f]);E.length=0;e.fontPreloads.forEach(P,b);e.fontPreloads.clear();e.highImagePreloads.forEach(P,b);e.highImagePreloads.clear();e.styles.forEach(sc,b);var C=e.importMapChunks;for(f=0;f<C.length;f++)b.push(C[f]);C.length=0;e.bootstrapScripts.forEach(P,b);e.scripts.forEach(P,
+b);e.scripts.clear();e.bulkPreloads.forEach(P,b);e.bulkPreloads.clear();var Q=e.preloadChunks;for(f=0;f<Q.length;f++)b.push(Q[f]);Q.length=0;var u=e.hoistableChunks;for(f=0;f<u.length;f++)b.push(u[f]);u.length=0;if(l&&null===n){var t=Nb("head");b.push(t)}af(a,b,d);a.completedRootSegment=null;Vb(b,a.renderState,a.resumableState)}else return;var p=a.renderState;d=0;p.preconnects.forEach(P,b);p.preconnects.clear();var F=p.preconnectChunks;for(d=0;d<F.length;d++)b.push(F[d]);F.length=0;p.fontPreloads.forEach(P,
+b);p.fontPreloads.clear();p.highImagePreloads.forEach(P,b);p.highImagePreloads.clear();p.styles.forEach(uc,b);p.scripts.forEach(P,b);p.scripts.clear();p.bulkPreloads.forEach(P,b);p.bulkPreloads.clear();var w=p.preloadChunks;for(d=0;d<w.length;d++)b.push(w[d]);w.length=0;var v=p.hoistableChunks;for(d=0;d<v.length;d++)b.push(v[d]);v.length=0;var B=a.clientRenderedBoundaries;for(c=0;c<B.length;c++){var N=B[c];p=b;var z=a.resumableState,ea=a.renderState,T=N.rootSegmentID,O=N.errorDigest,ma=N.errorMessage,
+fa=N.errorComponentStack,X=0===z.streamingFormat;X?(p.push(ea.startInlineScript),0===(z.instructions&4)?(z.instructions|=4,p.push('$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};;$RX("')):p.push('$RX("')):p.push('<template data-rxi="" data-bid="');p.push(ea.boundaryPrefix);var Pa=T.toString(16);p.push(Pa);X&&p.push('"');if(O||ma||fa)if(X){p.push(",");var Qa=ic(O||"");p.push(Qa)}else{p.push('" data-dgst="');
+var Ra=y(O||"");p.push(Ra)}if(ma||fa)if(X){p.push(",");var na=ic(ma||"");p.push(na)}else{p.push('" data-msg="');var R=y(ma||"");p.push(R)}if(fa)if(X){p.push(",");var qb=ic(fa);p.push(qb)}else{p.push('" data-stck="');var oa=y(fa);p.push(oa)}if(X?!p.push(")\x3c/script>"):!p.push('"></template>')){a.destination=null;c++;B.splice(0,c);return}}B.splice(0,c);var pa=a.completedBoundaries;for(c=0;c<pa.length;c++)if(!cf(a,b,pa[c])){a.destination=null;c++;pa.splice(0,c);return}pa.splice(0,c);var ba=a.partialBoundaries;
+for(c=0;c<ba.length;c++){var qa=ba[c];a:{B=a;N=b;B.renderState.boundaryResources=qa.resources;var ra=qa.completedSegments;for(z=0;z<ra.length;z++)if(!df(B,N,qa,ra[z])){z++;ra.splice(0,z);var Sa=!1;break a}ra.splice(0,z);Sa=pc(N,qa.resources,B.renderState)}if(!Sa){a.destination=null;c++;ba.splice(0,c);return}}ba.splice(0,c);var sa=a.completedBoundaries;for(c=0;c<sa.length;c++)if(!cf(a,b,sa[c])){a.destination=null;c++;sa.splice(0,c);return}sa.splice(0,c)}finally{0===a.allPendingTasks&&0===a.pingedTasks.length&&
+0===a.clientRenderedBoundaries.length&&0===a.completedBoundaries.length&&(a.flushScheduled=!1,c=a.resumableState,c.hasBody&&(ba=Nb("body"),b.push(ba)),c.hasHtml&&(c=Nb("html"),b.push(c)),b.push(null),a.destination=null)}}function ef(a){a.flushScheduled=null!==a.destination;He(a);null===a.trackedPostpones&&Ec(a.renderState,a.resumableState,0===a.pendingRootTasks)}
+function zc(a){if(!1===a.flushScheduled&&0===a.pingedTasks.length&&null!==a.destination){a.flushScheduled=!0;var b=a.destination;b?Ze(a,b):a.flushScheduled=!1}}function ff(a,b){if(1===a.status)a.status=2,b.destroy(a.fatalError);else if(2!==a.status&&null===a.destination){a.destination=b;try{Ze(a,b)}catch(c){W(a,c),Ke(a,c)}}}
+function gf(a,b){try{var c=a.abortableTasks;if(0<c.size){var d=void 0===b?Error("The render was aborted by the server without a reason."):b;c.forEach(function(e){return We(e,a,d)});c.clear()}null!==a.destination&&Ze(a,a.destination)}catch(e){W(a,e),Ke(a,e)}}function hf(){}
+function jf(a,b,c,d){var e=!1,f=null,g="",h=!1;b=ob(b?b.identifierPrefix:void 0,void 0);a=De(a,b,Fc(b,c),pb(),Infinity,hf,void 0,function(){h=!0},void 0,void 0,void 0);ef(a);gf(a,d);ff(a,{push:function(k){null!==k&&(g+=k);return!0},destroy:function(k){e=!0;f=k}});if(e&&f!==d)throw f;if(!h)throw Error("A component suspended while responding to synchronous input. This will cause the UI to be replaced with a loading indicator. To fix, updates that suspend should be wrapped with startTransition.");return g}
+function kf(a,b){a.prototype=Object.create(b.prototype);a.prototype.constructor=a;a.__proto__=b}var lf=function(a){function b(){var d=a.call(this,{})||this;d.request=null;d.startedFlowing=!1;return d}kf(b,a);var c=b.prototype;c._destroy=function(d,e){gf(this.request);e(d)};c._read=function(){this.startedFlowing&&ff(this.request,this)};return b}(ja.Readable);function mf(){}
+function nf(a,b){var c=new lf;b=ob(b?b.identifierPrefix:void 0,void 0);var d=De(a,b,Fc(b,!1),pb(),Infinity,mf,function(){c.startedFlowing=!0;ff(d,c)},void 0,void 0,void 0);c.request=d;ef(d);return c}exports.renderToNodeStream=function(a,b){return nf(a,b)};exports.renderToStaticMarkup=function(a,b){return jf(a,b,!0,'The server used "renderToStaticMarkup" which does not support Suspense. If you intended to have the server wait for the suspended component please switch to "renderToPipeableStream" which supports Suspense on the server')};
+exports.renderToStaticNodeStream=function(a,b){return nf(a,b)};exports.renderToString=function(a,b){return jf(a,b,!1,'The server used "renderToString" which does not support Suspense. If you intended for this Suspense boundary to render the fallback content on the server consider throwing an Error somewhere within the Suspense boundary. If you intended to have the server wait for the suspended component please switch to "renderToPipeableStream" which supports Suspense on the server')};
+exports.version="18.3.0-canary-7508dcd5c-20231108";
+
+//# sourceMappingURL=react-dom-server-legacy.node.production.min.js.map
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom-server-rendering-stub.development.js b/packages/next/src/compiled/react-dom/cjs/react-dom-server-rendering-stub.development.js
index 4e4dbf4906657..11738a4d927e7 100644
--- a/packages/next/src/compiled/react-dom/cjs/react-dom-server-rendering-stub.development.js
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom-server-rendering-stub.development.js
@@ -55,7 +55,7 @@ function printWarning(level, format, args) {
   }
 }
 
-var ReactVersion = '18.3.0-canary-2983249dd-20231107';
+var ReactVersion = '18.3.0-canary-7508dcd5c-20231108';
 
 var Internals = {
   usingClientEntryPoint: false,
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom-server-rendering-stub.production.js b/packages/next/src/compiled/react-dom/cjs/react-dom-server-rendering-stub.production.js
new file mode 100644
index 0000000000000..3b8850a727e45
--- /dev/null
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom-server-rendering-stub.production.js
@@ -0,0 +1,243 @@
+/**
+ * @license React
+ * react-dom-server-rendering-stub.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require("next/dist/compiled/react");
+
+var ReactVersion = '18.3.0-canary-7508dcd5c-20231108';
+
+const Internals = {
+  usingClientEntryPoint: false,
+  Events: null,
+  Dispatcher: {
+    current: null
+  }
+};
+
+// Do not require this module directly! Use normal `invariant` calls with
+// template literal strings. The messages will be replaced with error codes
+// during build.
+function formatProdErrorMessage(code) {
+  let url = 'https://reactjs.org/docs/error-decoder.html?invariant=' + code;
+
+  for (let i = 1; i < arguments.length; i++) {
+    url += '&args[]=' + encodeURIComponent(arguments[i]);
+  }
+
+  return "Minified React error #" + code + "; visit " + url + " for the full message or " + 'use the non-minified dev environment for full errors and additional ' + 'helpful warnings.';
+}
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+function getCrossOriginStringAs(as, input) {
+  if (as === 'font') {
+    return '';
+  }
+
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+const Dispatcher = Internals.Dispatcher;
+function prefetchDNS(href) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    dispatcher.prefetchDNS(href);
+  } // We don't error because preconnect needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preconnect(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    const crossOrigin = options ? getCrossOriginString(options.crossOrigin) : null;
+    dispatcher.preconnect(href, crossOrigin);
+  } // We don't error because preconnect needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preload(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string' && // We check existence because we cannot enforce this function is actually called with the stated type
+  typeof options === 'object' && options !== null && typeof options.as === 'string') {
+    const as = options.as;
+    const crossOrigin = getCrossOriginStringAs(as, options.crossOrigin);
+    dispatcher.preload(href, as, {
+      crossOrigin,
+      integrity: typeof options.integrity === 'string' ? options.integrity : undefined,
+      nonce: typeof options.nonce === 'string' ? options.nonce : undefined,
+      type: typeof options.type === 'string' ? options.type : undefined,
+      fetchPriority: typeof options.fetchPriority === 'string' ? options.fetchPriority : undefined,
+      referrerPolicy: typeof options.referrerPolicy === 'string' ? options.referrerPolicy : undefined,
+      imageSrcSet: typeof options.imageSrcSet === 'string' ? options.imageSrcSet : undefined,
+      imageSizes: typeof options.imageSizes === 'string' ? options.imageSizes : undefined
+    });
+  } // We don't error because preload needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preloadModule(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    if (options) {
+      const crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);
+      dispatcher.preloadModule(href, {
+        as: typeof options.as === 'string' && options.as !== 'script' ? options.as : undefined,
+        crossOrigin,
+        integrity: typeof options.integrity === 'string' ? options.integrity : undefined
+      });
+    } else {
+      dispatcher.preloadModule(href);
+    }
+  } // We don't error because preload needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preinit(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string' && options && typeof options.as === 'string') {
+    const as = options.as;
+    const crossOrigin = getCrossOriginStringAs(as, options.crossOrigin);
+    const integrity = typeof options.integrity === 'string' ? options.integrity : undefined;
+    const fetchPriority = typeof options.fetchPriority === 'string' ? options.fetchPriority : undefined;
+
+    if (as === 'style') {
+      dispatcher.preinitStyle(href, typeof options.precedence === 'string' ? options.precedence : undefined, {
+        crossOrigin,
+        integrity,
+        fetchPriority
+      });
+    } else if (as === 'script') {
+      dispatcher.preinitScript(href, {
+        crossOrigin,
+        integrity,
+        fetchPriority,
+        nonce: typeof options.nonce === 'string' ? options.nonce : undefined
+      });
+    }
+  } // We don't error because preinit needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preinitModule(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    if (typeof options === 'object' && options !== null) {
+      if (options.as == null || options.as === 'script') {
+        const crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);
+        dispatcher.preinitModuleScript(href, {
+          crossOrigin,
+          integrity: typeof options.integrity === 'string' ? options.integrity : undefined,
+          nonce: typeof options.nonce === 'string' ? options.nonce : undefined
+        });
+      }
+    } else if (options == null) {
+      dispatcher.preinitModuleScript(href);
+    }
+  } // We don't error because preinit needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher; // Since the "not pending" value is always the same, we can reuse the
+
+function resolveDispatcher() {
+  // Copied from react/src/ReactHooks.js. It's the same thing but in a
+  // different package.
+  const dispatcher = ReactCurrentDispatcher.current;
+  // intentionally don't throw our own error because this is in a hot path.
+  // Also helps ensure this is inlined.
+
+
+  return dispatcher;
+}
+
+function useFormStatus() {
+  {
+    const dispatcher = resolveDispatcher(); // $FlowFixMe[not-a-function] We know this exists because of the feature check above.
+
+    return dispatcher.useHostTransitionStatus();
+  }
+}
+function useFormState(action, initialState, permalink) {
+  {
+    const dispatcher = resolveDispatcher(); // $FlowFixMe[not-a-function] This is unstable, thus optional
+
+    return dispatcher.useFormState(action, initialState, permalink);
+  }
+}
+
+function createPortal() {
+  throw Error(formatProdErrorMessage(448));
+}
+function flushSync() {
+  throw Error(formatProdErrorMessage(449));
+} // on the server we just call the callback because there is
+// not update mechanism. Really this should not be called on the
+// server but since the semantics are generally clear enough we
+// can provide this trivial implementation.
+
+function batchedUpdates(fn, a) {
+  return fn(a);
+}
+
+// Export all exports so that they're available in tests.
+function experimental_useFormStatus() {
+
+  return useFormStatus();
+}
+function experimental_useFormState(action, initialState, permalink) {
+
+  return useFormState(action, initialState, permalink);
+}
+
+exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = Internals;
+exports.createPortal = createPortal;
+exports.experimental_useFormState = experimental_useFormState;
+exports.experimental_useFormStatus = experimental_useFormStatus;
+exports.flushSync = flushSync;
+exports.preconnect = preconnect;
+exports.prefetchDNS = prefetchDNS;
+exports.preinit = preinit;
+exports.preinitModule = preinitModule;
+exports.preload = preload;
+exports.preloadModule = preloadModule;
+exports.unstable_batchedUpdates = batchedUpdates;
+exports.useFormState = useFormState;
+exports.useFormStatus = useFormStatus;
+exports.version = ReactVersion;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom-server-rendering-stub.production.min.js b/packages/next/src/compiled/react-dom/cjs/react-dom-server-rendering-stub.production.min.js
index a3f2fd6f3640f..3d777d05dbc3f 100644
--- a/packages/next/src/compiled/react-dom/cjs/react-dom-server-rendering-stub.production.min.js
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom-server-rendering-stub.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-dom-server-rendering-stub.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-dom-server-rendering-stub.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var e=require("next/dist/compiled/react"),f={usingClientEntryPoint:!1,Events:null,Dispatcher:{current:null}};function h(b){for(var a="https://reactjs.org/docs/error-decoder.html?invariant="+b,c=1;c<arguments.length;c++)a+="&args[]="+encodeURIComponent(arguments[c]);return"Minified React error #"+b+"; visit "+a+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}
 function k(b,a){if("font"===b)return"";if("string"===typeof a)return"use-credentials"===a?a:""}var l=f.Dispatcher,m=e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentDispatcher;function n(){return m.current.useHostTransitionStatus()}function r(b,a,c){return m.current.useFormState(b,a,c)}exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=f;exports.createPortal=function(){throw Error(h(448));};exports.experimental_useFormState=function(b,a,c){return r(b,a,c)};
 exports.experimental_useFormStatus=function(){return n()};exports.flushSync=function(){throw Error(h(449));};exports.preconnect=function(b,a){var c=l.current;c&&"string"===typeof b&&(a?(a=a.crossOrigin,a="string"===typeof a?"use-credentials"===a?a:"":void 0):a=null,c.preconnect(b,a))};exports.prefetchDNS=function(b){var a=l.current;a&&"string"===typeof b&&a.prefetchDNS(b)};
@@ -14,4 +14,6 @@ exports.preinit=function(b,a){var c=l.current;if(c&&"string"===typeof b&&a&&"str
 exports.preinitModule=function(b,a){var c=l.current;if(c&&"string"===typeof b)if("object"===typeof a&&null!==a){if(null==a.as||"script"===a.as){var d=k(a.as,a.crossOrigin);c.preinitModuleScript(b,{crossOrigin:d,integrity:"string"===typeof a.integrity?a.integrity:void 0,nonce:"string"===typeof a.nonce?a.nonce:void 0})}}else null==a&&c.preinitModuleScript(b)};
 exports.preload=function(b,a){var c=l.current;if(c&&"string"===typeof b&&"object"===typeof a&&null!==a&&"string"===typeof a.as){var d=a.as,g=k(d,a.crossOrigin);c.preload(b,d,{crossOrigin:g,integrity:"string"===typeof a.integrity?a.integrity:void 0,nonce:"string"===typeof a.nonce?a.nonce:void 0,type:"string"===typeof a.type?a.type:void 0,fetchPriority:"string"===typeof a.fetchPriority?a.fetchPriority:void 0,referrerPolicy:"string"===typeof a.referrerPolicy?a.referrerPolicy:void 0,imageSrcSet:"string"===
 typeof a.imageSrcSet?a.imageSrcSet:void 0,imageSizes:"string"===typeof a.imageSizes?a.imageSizes:void 0})}};exports.preloadModule=function(b,a){var c=l.current;if(c&&"string"===typeof b)if(a){var d=k(a.as,a.crossOrigin);c.preloadModule(b,{as:"string"===typeof a.as&&"script"!==a.as?a.as:void 0,crossOrigin:d,integrity:"string"===typeof a.integrity?a.integrity:void 0})}else c.preloadModule(b)};exports.unstable_batchedUpdates=function(b,a){return b(a)};exports.useFormState=r;exports.useFormStatus=n;
-exports.version="18.3.0-canary-2983249dd-20231107";
+exports.version="18.3.0-canary-7508dcd5c-20231108";
+
+//# sourceMappingURL=react-dom-server-rendering-stub.production.min.js.map
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom-server.browser.development.js b/packages/next/src/compiled/react-dom/cjs/react-dom-server.browser.development.js
index 81563e20c831a..dbbc8ba23253a 100644
--- a/packages/next/src/compiled/react-dom/cjs/react-dom-server.browser.development.js
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom-server.browser.development.js
@@ -17,7 +17,7 @@ if (process.env.NODE_ENV !== "production") {
 var React = require("next/dist/compiled/react");
 var ReactDOM = require('react-dom');
 
-var ReactVersion = '18.3.0-canary-2983249dd-20231107';
+var ReactVersion = '18.3.0-canary-7508dcd5c-20231108';
 
 var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
 
@@ -1809,11 +1809,14 @@ var DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS = 2000; // Allows us to keep tr
 // if passed externalRuntimeConfig and the enableFizzExternalRuntime feature flag
 // is set, the server will send instructions via data attributes (instead of inline scripts)
 
-function createRenderState(resumableState, nonce, bootstrapScriptContent, bootstrapScripts, bootstrapModules, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
+function createRenderState(resumableState, nonce, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
   var inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
   var idPrefix = resumableState.idPrefix;
   var bootstrapChunks = [];
   var externalRuntimeScript = null;
+  var bootstrapScriptContent = resumableState.bootstrapScriptContent,
+      bootstrapScripts = resumableState.bootstrapScripts,
+      bootstrapModules = resumableState.bootstrapModules;
 
   if (bootstrapScriptContent !== undefined) {
     bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapAndImportMapScriptContent(bootstrapScriptContent)), endInlineScript);
@@ -2002,7 +2005,7 @@ function createRenderState(resumableState, nonce, bootstrapScriptContent, bootst
 
   return renderState;
 }
-function createResumableState(identifierPrefix, externalRuntimeConfig) {
+function createResumableState(identifierPrefix, externalRuntimeConfig, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
   var idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
   var streamingFormat = ScriptStreamingFormat;
 
@@ -2016,6 +2019,9 @@ function createResumableState(identifierPrefix, externalRuntimeConfig) {
     idPrefix: idPrefix,
     nextFormID: 0,
     streamingFormat: streamingFormat,
+    bootstrapScriptContent: bootstrapScriptContent,
+    bootstrapScripts: bootstrapScripts,
+    bootstrapModules: bootstrapModules,
     instructions: NothingSent,
     hasBody: false,
     hasHtml: false,
@@ -4455,7 +4461,10 @@ function pushEndInstance(target, type, props, resumableState, formatContext) {
   target.push(endChunkForTag(type));
 }
 
-function writeBootstrap(destination, renderState) {
+function writeBootstrap(destination, renderState, resumableState) {
+  resumableState.bootstrapScriptContent = undefined;
+  resumableState.bootstrapScripts = undefined;
+  resumableState.bootstrapModules = undefined;
   var bootstrapChunks = renderState.bootstrapChunks;
   var i = 0;
 
@@ -4472,8 +4481,8 @@ function writeBootstrap(destination, renderState) {
   return true;
 }
 
-function writeCompletedRoot(destination, renderState) {
-  return writeBootstrap(destination, renderState);
+function writeCompletedRoot(destination, renderState, resumableState) {
+  return writeBootstrap(destination, renderState, resumableState);
 } // Structural Nodes
 // A placeholder is a node inside a hidden partial tree that can be filled in later, but before
 // display. It's never visible to users. We use the template tag because it can be used in every
@@ -4830,7 +4839,7 @@ function writeCompletedBoundaryInstruction(destination, resumableState, renderSt
     writeMore = writeChunkAndReturn(destination, completeBoundaryDataEnd);
   }
 
-  return writeBootstrap(destination, renderState) && writeMore;
+  return writeBootstrap(destination, renderState, resumableState) && writeMore;
 }
 var clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
 var clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
@@ -6828,6 +6837,18 @@ var componentFrameCache;
   var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
   componentFrameCache = new PossiblyWeakMap();
 }
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
@@ -6843,7 +6864,6 @@ function describeNativeComponentFrame(fn, construct) {
     }
   }
 
-  var control;
   reentry = true;
   var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
 
@@ -6857,81 +6877,140 @@ function describeNativeComponentFrame(fn, construct) {
     ReactCurrentDispatcher$1.current = null;
     disableLogs();
   }
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
 
-  try {
-    // This should throw.
-    if (construct) {
-      // Something should be setting the props in the constructor.
-      var Fake = function () {
-        throw Error();
-      }; // $FlowFixMe[prop-missing]
 
+  var RunInRootFrame = {
+    DetermineComponentFrameRoot: function () {
+      var control;
 
-      Object.defineProperty(Fake.prototype, 'props', {
-        set: function () {
-          // We use a throwing setter instead of frozen or non-writable props
-          // because that won't throw in a non-strict mode function.
-          throw Error();
-        }
-      });
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          var Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
 
-      if (typeof Reflect === 'object' && Reflect.construct) {
-        // We construct a different control for this case to include any extra
-        // frames added by the construct call.
-        try {
-          Reflect.construct(Fake, []);
-        } catch (x) {
-          control = x;
-        }
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
 
-        Reflect.construct(fn, [], Fake);
-      } else {
-        try {
-          Fake.call();
-        } catch (x) {
-          control = x;
-        } // $FlowFixMe[prop-missing] found when upgrading Flow
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
 
 
-        fn.call(Fake.prototype);
-      }
-    } else {
-      try {
-        throw Error();
-      } catch (x) {
-        control = x;
-      } // TODO(luna): This will currently only throw if the function component
-      // tries to access React/ReactDOM/props. We should probably make this throw
-      // in simple components too
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
 
 
-      var maybePromise = fn(); // If the function component returns a promise, it's likely an async
-      // component, which we don't yet support. Attach a noop catch handler to
-      // silence the error.
-      // TODO: Implement component stacks for async client components?
+          var maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
 
-      if (maybePromise && typeof maybePromise.catch === 'function') {
-        maybePromise.catch(function () {});
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(function () {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
       }
+
+      return [null, null];
     }
-  } catch (sample) {
-    // This is inlined manually because closure doesn't do it for us.
-    if (sample && control && typeof sample.stack === 'string') {
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
+
+  try {
+    var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
+
+    if (sampleStack && controlStack) {
       // This extracts the first frame from the sample that isn't also in the control.
       // Skipping one frame that we assume is the frame that calls the two.
-      var sampleLines = sample.stack.split('\n');
-      var controlLines = control.stack.split('\n');
-      var s = sampleLines.length - 1;
-      var c = controlLines.length - 1;
-
-      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
-        // We expect at least one stack frame to be shared.
-        // Typically this will be the root most one. However, stack frames may be
-        // cut off due to maximum stack limits. In this case, one maybe cut off
-        // earlier than the other. We assume that the sample is longer or the same
-        // and there for cut off earlier. So we should find the root most frame in
-        // the sample somewhere in the control.
-        c--;
+      var sampleLines = sampleStack.split('\n');
+      var controlLines = controlStack.split('\n');
+      var s = 0;
+      var c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
       }
 
       for (; s >= 1 && c >= 0; s--, c--) {
@@ -6960,7 +7039,7 @@ function describeNativeComponentFrame(fn, construct) {
                   _frame = _frame.replace('<anonymous>', fn.displayName);
                 }
 
-                {
+                if (true) {
                   if (typeof fn === 'function') {
                     componentFrameCache.set(fn, _frame);
                   }
@@ -11335,7 +11414,7 @@ function flushCompletedQueues(request, destination) {
 
         flushSegment(request, destination, completedRootSegment);
         request.completedRootSegment = null;
-        writeCompletedRoot(destination, request.renderState);
+        writeCompletedRoot(destination, request.renderState, request.resumableState);
       } else {
         // We haven't flushed the root yet so we don't need to check any other branches further down
         return;
@@ -11609,8 +11688,8 @@ function renderToReadableStream(children, options) {
       };
     }
 
-    var resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined);
-    var request = createRequest(children, resumableState, createRenderState(resumableState, options ? options.nonce : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, onHeadersImpl, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, onShellReady, onShellError, onFatalError, options ? options.onPostpone : undefined, options ? options.formState : undefined);
+    var resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined);
+    var request = createRequest(children, resumableState, createRenderState(resumableState, options ? options.nonce : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, onHeadersImpl, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, onShellReady, onShellError, onFatalError, options ? options.onPostpone : undefined, options ? options.formState : undefined);
 
     if (options && options.signal) {
       var signal = options.signal;
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom-server.browser.production.js b/packages/next/src/compiled/react-dom/cjs/react-dom-server.browser.production.js
new file mode 100644
index 0000000000000..b23c34debb9ed
--- /dev/null
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom-server.browser.production.js
@@ -0,0 +1,8615 @@
+/**
+ * @license React
+ * react-dom-server.browser.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require("next/dist/compiled/react");
+var ReactDOM = require('react-dom');
+
+var ReactVersion = '18.3.0-canary-7508dcd5c-20231108';
+
+// Do not require this module directly! Use normal `invariant` calls with
+// template literal strings. The messages will be replaced with error codes
+// during build.
+function formatProdErrorMessage(code) {
+  let url = 'https://reactjs.org/docs/error-decoder.html?invariant=' + code;
+
+  for (let i = 1; i < arguments.length; i++) {
+    url += '&args[]=' + encodeURIComponent(arguments[i]);
+  }
+
+  return "Minified React error #" + code + "; visit " + url + " for the full message or " + 'use the non-minified dev environment for full errors and additional ' + 'helpful warnings.';
+}
+
+// A pure JS implementation of a string hashing function. We do not use it for
+// security or obfuscation purposes, only to create compact hashes. So we
+// prioritize speed over collision avoidance. For example, we use this to hash
+// the component key path used by useFormState for MPA-style submissions.
+//
+// In environments where built-in hashing functions are available, we prefer
+// those instead. Like Node's crypto module, or Bun.hash. Unfortunately this
+// does not include the web standard crypto API because those methods are all
+// async. For our purposes, we need it to be sync because the cost of context
+// switching is too high to be worth it.
+//
+// The most popular hashing algorithm that meets these requirements in the JS
+// ecosystem is MurmurHash3, and almost all implementations I could find used
+// some version of the implementation by Gary Court inlined below.
+function createFastHashJS(key) {
+  return murmurhash3_32_gc(key, 0);
+}
+/* eslint-disable prefer-const, no-fallthrough */
+
+/**
+ * @license
+ *
+ * JS Implementation of MurmurHash3 (r136) (as of May 20, 2011)
+ *
+ * Copyright (c) 2011 Gary Court
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+function murmurhash3_32_gc(key, seed) {
+  let remainder, bytes, h1, h1b, c1, c2, k1, i;
+  remainder = key.length & 3; // key.length % 4
+
+  bytes = key.length - remainder;
+  h1 = seed;
+  c1 = 0xcc9e2d51;
+  c2 = 0x1b873593;
+  i = 0;
+
+  while (i < bytes) {
+    k1 = key.charCodeAt(i) & 0xff | (key.charCodeAt(++i) & 0xff) << 8 | (key.charCodeAt(++i) & 0xff) << 16 | (key.charCodeAt(++i) & 0xff) << 24;
+    ++i;
+    k1 = (k1 & 0xffff) * c1 + (((k1 >>> 16) * c1 & 0xffff) << 16) & 0xffffffff;
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = (k1 & 0xffff) * c2 + (((k1 >>> 16) * c2 & 0xffff) << 16) & 0xffffffff;
+    h1 ^= k1;
+    h1 = h1 << 13 | h1 >>> 19;
+    h1b = (h1 & 0xffff) * 5 + (((h1 >>> 16) * 5 & 0xffff) << 16) & 0xffffffff;
+    h1 = (h1b & 0xffff) + 0x6b64 + (((h1b >>> 16) + 0xe654 & 0xffff) << 16);
+  }
+
+  k1 = 0;
+
+  switch (remainder) {
+    case 3:
+      k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
+
+    case 2:
+      k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
+
+    case 1:
+      k1 ^= key.charCodeAt(i) & 0xff;
+      k1 = (k1 & 0xffff) * c1 + (((k1 >>> 16) * c1 & 0xffff) << 16) & 0xffffffff;
+      k1 = k1 << 15 | k1 >>> 17;
+      k1 = (k1 & 0xffff) * c2 + (((k1 >>> 16) * c2 & 0xffff) << 16) & 0xffffffff;
+      h1 ^= k1;
+  }
+
+  h1 ^= key.length;
+  h1 ^= h1 >>> 16;
+  h1 = (h1 & 0xffff) * 0x85ebca6b + (((h1 >>> 16) * 0x85ebca6b & 0xffff) << 16) & 0xffffffff;
+  h1 ^= h1 >>> 13;
+  h1 = (h1 & 0xffff) * 0xc2b2ae35 + (((h1 >>> 16) * 0xc2b2ae35 & 0xffff) << 16) & 0xffffffff;
+  h1 ^= h1 >>> 16;
+  return h1 >>> 0;
+}
+
+function scheduleWork(callback) {
+  callback();
+}
+const VIEW_SIZE = 512;
+let currentView = null;
+let writtenBytes = 0;
+function beginWriting(destination) {
+  currentView = new Uint8Array(VIEW_SIZE);
+  writtenBytes = 0;
+}
+function writeChunk(destination, chunk) {
+  if (chunk.byteLength === 0) {
+    return;
+  }
+
+  if (chunk.byteLength > VIEW_SIZE) {
+    // one that is cached by the streaming renderer. We will enqueu
+    // it directly and expect it is not re-used
+
+
+    if (writtenBytes > 0) {
+      destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    destination.enqueue(chunk);
+    return;
+  }
+
+  let bytesToWrite = chunk;
+  const allowableBytes = currentView.length - writtenBytes;
+
+  if (allowableBytes < bytesToWrite.byteLength) {
+    // this chunk would overflow the current view. We enqueue a full view
+    // and start a new view with the remaining chunk
+    if (allowableBytes === 0) {
+      // the current view is already full, send it
+      destination.enqueue(currentView);
+    } else {
+      // fill up the current view and apply the remaining chunk bytes
+      // to a new view.
+      currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes); // writtenBytes += allowableBytes; // this can be skipped because we are going to immediately reset the view
+
+      destination.enqueue(currentView);
+      bytesToWrite = bytesToWrite.subarray(allowableBytes);
+    }
+
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+
+  currentView.set(bytesToWrite, writtenBytes);
+  writtenBytes += bytesToWrite.byteLength;
+}
+function writeChunkAndReturn(destination, chunk) {
+  writeChunk(destination, chunk); // in web streams there is no backpressure so we can alwas write more
+
+  return true;
+}
+function completeWriting(destination) {
+  if (currentView && writtenBytes > 0) {
+    destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+    currentView = null;
+    writtenBytes = 0;
+  }
+}
+function close(destination) {
+  destination.close();
+}
+const textEncoder = new TextEncoder();
+function stringToChunk(content) {
+  return textEncoder.encode(content);
+}
+function stringToPrecomputedChunk(content) {
+  const precomputedChunk = textEncoder.encode(content);
+
+  return precomputedChunk;
+}
+function clonePrecomputedChunk(precomputedChunk) {
+  return precomputedChunk.byteLength > VIEW_SIZE ? precomputedChunk.slice() : precomputedChunk;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[method-unbinding]
+  if (typeof destination.error === 'function') {
+    // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+    destination.error(error);
+  } else {
+    // Earlier implementations doesn't support this method. In that environment you're
+    // supposed to throw from a promise returned but we don't return a promise in our
+    // approach. We could fork this implementation but this is environment is an edge
+    // case to begin with. It's even less common to run this in an older environment.
+    // Even then, this is not where errors are supposed to happen and they get reported
+    // to a global callback in addition to this anyway. So it's fine just to close this.
+    destination.close();
+  }
+}
+
+const assign = Object.assign;
+
+// -----------------------------------------------------------------------------
+const enableFloat = true; // Enables unstable_useMemoCache hook, intended as a compilation target for
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/* eslint-disable max-len */
+
+const ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
+/* eslint-enable max-len */
+
+const ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
+const VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+const illegalAttributeNameCache = {};
+const validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+  if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+    return true;
+  }
+
+  if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+    return false;
+  }
+
+  if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+    validatedAttributeNameCache[attributeName] = true;
+    return true;
+  }
+
+  illegalAttributeNameCache[attributeName] = true;
+
+  return false;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+const unitlessNumbers = new Set(['animationIterationCount', 'aspectRatio', 'borderImageOutset', 'borderImageSlice', 'borderImageWidth', 'boxFlex', 'boxFlexGroup', 'boxOrdinalGroup', 'columnCount', 'columns', 'flex', 'flexGrow', 'flexPositive', 'flexShrink', 'flexNegative', 'flexOrder', 'gridArea', 'gridRow', 'gridRowEnd', 'gridRowSpan', 'gridRowStart', 'gridColumn', 'gridColumnEnd', 'gridColumnSpan', 'gridColumnStart', 'fontWeight', 'lineClamp', 'lineHeight', 'opacity', 'order', 'orphans', 'scale', 'tabSize', 'widows', 'zIndex', 'zoom', 'fillOpacity', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'MozBoxFlexGroup', 'MozLineClamp', 'msAnimationIterationCount', 'msFlex', 'msZoom', 'msFlexGrow', 'msFlexNegative', 'msFlexOrder', 'msFlexPositive', 'msFlexShrink', 'msGridColumn', 'msGridColumnSpan', 'msGridRow', 'msGridRowSpan', 'WebkitAnimationIterationCount', 'WebkitBoxFlex', 'WebKitBoxFlexGroup', 'WebkitBoxOrdinalGroup', 'WebkitColumnCount', 'WebkitColumns', 'WebkitFlex', 'WebkitFlexGrow', 'WebkitFlexPositive', 'WebkitFlexShrink', 'WebkitLineClamp']);
+function isUnitlessNumber (name) {
+  return unitlessNumbers.has(name);
+}
+
+const aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+  return aliases.get(name) || name;
+}
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// code copied and modified from escape-html
+const matchHtmlRegExp = /["'&<>]/;
+/**
+ * Escapes special characters and HTML entities in a given html string.
+ *
+ * @param  {string} string HTML string to escape for later insertion
+ * @return {string}
+ * @public
+ */
+
+function escapeHtml(string) {
+
+  const str = '' + string;
+  const match = matchHtmlRegExp.exec(str);
+
+  if (!match) {
+    return str;
+  }
+
+  let escape;
+  let html = '';
+  let index;
+  let lastIndex = 0;
+
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        // "
+        escape = '&quot;';
+        break;
+
+      case 38:
+        // &
+        escape = '&amp;';
+        break;
+
+      case 39:
+        // '
+        escape = '&#x27;'; // modified from escape-html; used to be '&#39'
+
+        break;
+
+      case 60:
+        // <
+        escape = '&lt;';
+        break;
+
+      case 62:
+        // >
+        escape = '&gt;';
+        break;
+
+      default:
+        continue;
+    }
+
+    if (lastIndex !== index) {
+      html += str.slice(lastIndex, index);
+    }
+
+    lastIndex = index + 1;
+    html += escape;
+  }
+
+  return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+} // end code copied and modified from escape-html
+
+/**
+ * Escapes text to prevent scripting attacks.
+ *
+ * @param {*} text Text value to escape.
+ * @return {string} An escaped string.
+ */
+
+
+function escapeTextForBrowser(text) {
+  if (typeof text === 'boolean' || typeof text === 'number') {
+    // this shortcircuit helps perf for types that we know will never have
+    // special characters, especially given that this function is used often
+    // for numeric dom ids.
+    return '' + text;
+  }
+
+  return escapeHtml(text);
+}
+
+const uppercasePattern = /([A-Z])/g;
+const msPattern = /^ms-/;
+/**
+ * Hyphenates a camelcased CSS property name, for example:
+ *
+ *   > hyphenateStyleName('backgroundColor')
+ *   < "background-color"
+ *   > hyphenateStyleName('MozTransition')
+ *   < "-moz-transition"
+ *   > hyphenateStyleName('msTransition')
+ *   < "-ms-transition"
+ *
+ * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
+ * is converted to `-ms-`.
+ */
+
+function hyphenateStyleName(name) {
+  return name.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern, '-ms-');
+}
+
+function sanitizeURL(url) {
+
+  return url;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+// The build script is at scripts/rollup/generate-inline-fizz-runtime.js.
+// Run `yarn generate-inline-fizz-runtime` to generate.
+const clientRenderBoundary = '$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};';
+const completeBoundary = '$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};';
+const completeBoundaryWithStyles = '$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};';
+const completeSegment = '$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};';
+const formReplaying = 'addEventListener("submit",function(a){if(!a.defaultPrevented){var c=a.target,d=a.submitter,e=c.action,b=d;if(d){var f=d.getAttribute("formAction");null!=f&&(e=f,b=null)}"javascript:throw new Error(\'A React form was unexpectedly submitted.\')"===e&&(a.preventDefault(),b?(a=document.createElement("input"),a.name=b.name,a.value=b.value,b.parentNode.insertBefore(a,b),b=new FormData(c),a.parentNode.removeChild(a)):b=new FormData(c),a=c.getRootNode(),(a.$$reactFormReplay=a.$$reactFormReplay||[]).push(c,\nd,b))}});';
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+// same object across all transitions.
+
+const sharedNotPendingObject = {
+  pending: false,
+  data: null,
+  method: null,
+  action: null
+};
+const NotPending = sharedNotPendingObject;
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+const ReactDOMServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMServerDispatcher;
+} // We make every property of the descriptor optional because it is not a contract that
+const ScriptStreamingFormat = 0;
+const DataStreamingFormat = 1;
+const NothingSent
+/*                      */
+= 0b00000;
+const SentCompleteSegmentFunction
+/*      */
+= 0b00001;
+const SentCompleteBoundaryFunction
+/*     */
+= 0b00010;
+const SentClientRenderFunction
+/*         */
+= 0b00100;
+const SentStyleInsertionFunction
+/*       */
+= 0b01000;
+const SentFormReplayingRuntime
+/*         */
+= 0b10000; // Per request, global state that is not contextual to the rendering subtree.
+// This cannot be resumed and therefore should only contain things that are
+// temporary working state or are never used in the prerender pass.
+// Credentials here are things that affect whether a browser will make a request
+// as well as things that affect which connection the browser will use for that request.
+// We want these to be aligned across preloads and resources because otherwise the preload
+// will be wasted.
+// We investigated whether referrerPolicy should be included here but from experimentation
+// it seems that browsers do not treat this as part of the http cache key and does not affect
+// which connection is used.
+
+const EXISTS = null; // This constant is to mark preloads that have no unique credentials
+// to convey. It should never be checked by identity and we should not
+// assume Preload values in ResumableState equal this value because they
+// will have come from some parsed input.
+
+const PRELOAD_NO_CREDS = [];
+// This is resumable and therefore should be serializable.
+
+
+const dataElementQuotedEnd = stringToPrecomputedChunk('"></template>');
+const startInlineScript = stringToPrecomputedChunk('<script>');
+const endInlineScript = stringToPrecomputedChunk('</script>');
+const startScriptSrc = stringToPrecomputedChunk('<script src="');
+const startModuleSrc = stringToPrecomputedChunk('<script type="module" src="');
+const scriptNonce = stringToPrecomputedChunk('" nonce="');
+const scriptIntegirty = stringToPrecomputedChunk('" integrity="');
+const scriptCrossOrigin = stringToPrecomputedChunk('" crossorigin="');
+const endAsyncScript = stringToPrecomputedChunk('" async=""></script>');
+/**
+ * This escaping function is designed to work with bootstrapScriptContent and importMap only.
+ * because we know we are escaping the entire script. We can avoid for instance
+ * escaping html comment string sequences that are valid javascript as well because
+ * if there are no sebsequent <script sequences the html parser will never enter
+ * script data double escaped state (see: https://www.w3.org/TR/html53/syntax.html#script-data-double-escaped-state)
+ *
+ * While untrusted script content should be made safe before using this api it will
+ * ensure that the script cannot be early terminated or never terminated state
+ */
+
+function escapeBootstrapAndImportMapScriptContent(scriptText) {
+
+  return ('' + scriptText).replace(scriptRegex, scriptReplacer);
+}
+
+const scriptRegex = /(<\/|<)(s)(cript)/gi;
+
+const scriptReplacer = (match, prefix, s, suffix) => "" + prefix + (s === 's' ? '\\u0073' : '\\u0053') + suffix;
+
+const importMapScriptStart = stringToPrecomputedChunk('<script type="importmap">');
+const importMapScriptEnd = stringToPrecomputedChunk('</script>'); // Since we store headers as strings we deal with their length in utf16 code units
+// rather than visual characters or the utf8 encoding that is used for most binary
+// serialization. Some common HTTP servers only allow for headers to be 4kB in length.
+// We choose a default length that is likely to be well under this already limited length however
+// pathological cases may still cause the utf-8 encoding of the headers to approach this limit.
+// It should also be noted that this maximum is a soft maximum. we have not reached the limit we will
+// allow one more header to be captured which means in practice if the limit is approached it will be exceeded
+
+const DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS = 2000; // Allows us to keep track of what we've already written so we can refer back to it.
+// if passed externalRuntimeConfig and the enableFizzExternalRuntime feature flag
+// is set, the server will send instructions via data attributes (instead of inline scripts)
+
+function createRenderState(resumableState, nonce, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
+  const inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
+  const idPrefix = resumableState.idPrefix;
+  const bootstrapChunks = [];
+  let externalRuntimeScript = null;
+  const bootstrapScriptContent = resumableState.bootstrapScriptContent,
+        bootstrapScripts = resumableState.bootstrapScripts,
+        bootstrapModules = resumableState.bootstrapModules;
+
+  if (bootstrapScriptContent !== undefined) {
+    bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapAndImportMapScriptContent(bootstrapScriptContent)), endInlineScript);
+  }
+
+  {
+
+    if (externalRuntimeConfig !== undefined) {
+      if (typeof externalRuntimeConfig === 'string') {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig,
+          async: true,
+          integrity: undefined,
+          nonce: nonce
+        });
+      } else {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig.src,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig.src,
+          async: true,
+          integrity: externalRuntimeConfig.integrity,
+          nonce: nonce
+        });
+      }
+    }
+  }
+
+  const importMapChunks = [];
+
+  if (importMap !== undefined) {
+    const map = importMap;
+    importMapChunks.push(importMapScriptStart);
+    importMapChunks.push(stringToChunk(escapeBootstrapAndImportMapScriptContent(JSON.stringify(map))));
+    importMapChunks.push(importMapScriptEnd);
+  }
+
+  const headers = onHeaders ? {
+    preconnects: '',
+    fontPreloads: '',
+    highImagePreloads: '',
+    remainingCapacity: typeof maxHeadersLength === 'number' ? maxHeadersLength : DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS
+  } : null;
+  const renderState = {
+    placeholderPrefix: stringToPrecomputedChunk(idPrefix + 'P:'),
+    segmentPrefix: stringToPrecomputedChunk(idPrefix + 'S:'),
+    boundaryPrefix: stringToPrecomputedChunk(idPrefix + 'B:'),
+    startInlineScript: inlineScriptWithNonce,
+    htmlChunks: null,
+    headChunks: null,
+    externalRuntimeScript: externalRuntimeScript,
+    bootstrapChunks: bootstrapChunks,
+    onHeaders,
+    headers,
+    resets: {
+      font: {},
+      dns: {},
+      connect: {
+        default: {},
+        anonymous: {},
+        credentials: {}
+      },
+      image: {},
+      style: {}
+    },
+    charsetChunks: [],
+    preconnectChunks: [],
+    importMapChunks,
+    preloadChunks: [],
+    hoistableChunks: [],
+    // cleared on flush
+    preconnects: new Set(),
+    fontPreloads: new Set(),
+    highImagePreloads: new Set(),
+    // usedImagePreloads: new Set(),
+    styles: new Map(),
+    bootstrapScripts: new Set(),
+    scripts: new Set(),
+    bulkPreloads: new Set(),
+    preloads: {
+      images: new Map(),
+      stylesheets: new Map(),
+      scripts: new Map(),
+      moduleScripts: new Map()
+    },
+    nonce,
+    // like a module global for currently rendering boundary
+    boundaryResources: null,
+    stylesToHoist: false
+  };
+
+  if (bootstrapScripts !== undefined) {
+    for (let i = 0; i < bootstrapScripts.length; i++) {
+      const scriptConfig = bootstrapScripts[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'preload',
+        as: 'script',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startScriptSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  if (bootstrapModules !== undefined) {
+    for (let i = 0; i < bootstrapModules.length; i++) {
+      const scriptConfig = bootstrapModules[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'modulepreload',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startModuleSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  return renderState;
+}
+function createResumableState(identifierPrefix, externalRuntimeConfig, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
+  const idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
+  let streamingFormat = ScriptStreamingFormat;
+
+  {
+    if (externalRuntimeConfig !== undefined) {
+      streamingFormat = DataStreamingFormat;
+    }
+  }
+
+  return {
+    idPrefix: idPrefix,
+    nextFormID: 0,
+    streamingFormat,
+    bootstrapScriptContent,
+    bootstrapScripts,
+    bootstrapModules,
+    instructions: NothingSent,
+    hasBody: false,
+    hasHtml: false,
+    // @TODO add bootstrap script to implicit preloads
+    // persistent
+    unknownResources: {},
+    dnsResources: {},
+    connectResources: {
+      default: {},
+      anonymous: {},
+      credentials: {}
+    },
+    imageResources: {},
+    styleResources: {},
+    scriptResources: {},
+    moduleUnknownResources: {},
+    moduleScriptResources: {}
+  };
+}
+// modes. We only include the variants as they matter for the sake of our purposes.
+// We don't actually provide the namespace therefore we use constants instead of the string.
+
+const ROOT_HTML_MODE = 0; // Used for the root most element tag.
+// We have a less than HTML_HTML_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const HTML_HTML_MODE = 1; // Used for the <html> if it is at the top level.
+
+const HTML_MODE = 2;
+const SVG_MODE = 3;
+const MATHML_MODE = 4;
+const HTML_TABLE_MODE = 5;
+const HTML_TABLE_BODY_MODE = 6;
+const HTML_TABLE_ROW_MODE = 7;
+const HTML_COLGROUP_MODE = 8; // We have a greater than HTML_TABLE_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const NO_SCOPE =
+/*         */
+0b00;
+const NOSCRIPT_SCOPE =
+/*   */
+0b01;
+const PICTURE_SCOPE =
+/*    */
+0b10; // Lets us keep track of contextual state and pick it back up after suspending.
+
+function createFormatContext(insertionMode, selectedValue, tagScope) {
+  return {
+    insertionMode,
+    selectedValue,
+    tagScope
+  };
+}
+
+function createRootFormatContext(namespaceURI) {
+  const insertionMode = namespaceURI === 'http://www.w3.org/2000/svg' ? SVG_MODE : namespaceURI === 'http://www.w3.org/1998/Math/MathML' ? MATHML_MODE : ROOT_HTML_MODE;
+  return createFormatContext(insertionMode, null, NO_SCOPE);
+}
+function getChildFormatContext(parentContext, type, props) {
+  switch (type) {
+    case 'noscript':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | NOSCRIPT_SCOPE);
+
+    case 'select':
+      return createFormatContext(HTML_MODE, props.value != null ? props.value : props.defaultValue, parentContext.tagScope);
+
+    case 'svg':
+      return createFormatContext(SVG_MODE, null, parentContext.tagScope);
+
+    case 'picture':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | PICTURE_SCOPE);
+
+    case 'math':
+      return createFormatContext(MATHML_MODE, null, parentContext.tagScope);
+
+    case 'foreignObject':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    // Table parents are special in that their children can only be created at all if they're
+    // wrapped in a table parent. So we need to encode that we're entering this mode.
+
+    case 'table':
+      return createFormatContext(HTML_TABLE_MODE, null, parentContext.tagScope);
+
+    case 'thead':
+    case 'tbody':
+    case 'tfoot':
+      return createFormatContext(HTML_TABLE_BODY_MODE, null, parentContext.tagScope);
+
+    case 'colgroup':
+      return createFormatContext(HTML_COLGROUP_MODE, null, parentContext.tagScope);
+
+    case 'tr':
+      return createFormatContext(HTML_TABLE_ROW_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode >= HTML_TABLE_MODE) {
+    // Whatever tag this was, it wasn't a table parent or other special parent, so we must have
+    // entered plain HTML again.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode === ROOT_HTML_MODE) {
+    if (type === 'html') {
+      // We've emitted the root and is now in <html> mode.
+      return createFormatContext(HTML_HTML_MODE, null, parentContext.tagScope);
+    } else {
+      // We've emitted the root and is now in plain HTML mode.
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    }
+  } else if (parentContext.insertionMode === HTML_HTML_MODE) {
+    // We've emitted the document element and is now in plain HTML mode.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  return parentContext;
+}
+function makeId(resumableState, treeId, localId) {
+  const idPrefix = resumableState.idPrefix;
+  let id = ':' + idPrefix + 'R' + treeId; // Unless this is the first id at this level, append a number at the end
+  // that represents the position of this useId hook among all the useId
+  // hooks for this fiber.
+
+  if (localId > 0) {
+    id += 'H' + localId.toString(32);
+  }
+
+  return id + ':';
+}
+
+function encodeHTMLTextNode(text) {
+  return escapeTextForBrowser(text);
+}
+
+const textSeparator = stringToPrecomputedChunk('<!-- -->');
+function pushTextInstance(target, text, renderState, textEmbedded) {
+  if (text === '') {
+    // Empty text doesn't have a DOM node representation and the hydration is aware of this.
+    return textEmbedded;
+  }
+
+  if (textEmbedded) {
+    target.push(textSeparator);
+  }
+
+  target.push(stringToChunk(encodeHTMLTextNode(text)));
+  return true;
+} // Called when Fizz is done with a Segment. Currently the only purpose is to conditionally
+// emit a text separator when we don't know for sure it is safe to omit
+
+function pushSegmentFinale(target, renderState, lastPushedText, textEmbedded) {
+  if (lastPushedText && textEmbedded) {
+    target.push(textSeparator);
+  }
+}
+const styleNameCache = new Map();
+
+function processStyleName(styleName) {
+  const chunk = styleNameCache.get(styleName);
+
+  if (chunk !== undefined) {
+    return chunk;
+  }
+
+  const result = stringToPrecomputedChunk(escapeTextForBrowser(hyphenateStyleName(styleName)));
+  styleNameCache.set(styleName, result);
+  return result;
+}
+
+const styleAttributeStart = stringToPrecomputedChunk(' style="');
+const styleAssign = stringToPrecomputedChunk(':');
+const styleSeparator = stringToPrecomputedChunk(';');
+
+function pushStyleAttribute(target, style) {
+  if (typeof style !== 'object') {
+    throw Error(formatProdErrorMessage(62));
+  }
+
+  let isFirst = true;
+
+  for (const styleName in style) {
+    if (!hasOwnProperty.call(style, styleName)) {
+      continue;
+    } // If you provide unsafe user data here they can inject arbitrary CSS
+    // which may be problematic (I couldn't repro this):
+    // https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet
+    // http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/
+    // This is not an XSS hole but instead a potential CSS injection issue
+    // which has lead to a greater discussion about how we're going to
+    // trust URLs moving forward. See #2115901
+
+
+    const styleValue = style[styleName];
+
+    if (styleValue == null || typeof styleValue === 'boolean' || styleValue === '') {
+      // TODO: We used to set empty string as a style with an empty value. Does that ever make sense?
+      continue;
+    }
+
+    let nameChunk;
+    let valueChunk;
+    const isCustomProperty = styleName.indexOf('--') === 0;
+
+    if (isCustomProperty) {
+      nameChunk = stringToChunk(escapeTextForBrowser(styleName));
+
+      valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+    } else {
+
+      nameChunk = processStyleName(styleName);
+
+      if (typeof styleValue === 'number') {
+        if (styleValue !== 0 && !isUnitlessNumber(styleName)) {
+          valueChunk = stringToChunk(styleValue + 'px'); // Presumes implicit 'px' suffix for unitless numbers
+        } else {
+          valueChunk = stringToChunk('' + styleValue);
+        }
+      } else {
+
+        valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+      }
+    }
+
+    if (isFirst) {
+      isFirst = false; // If it's first, we don't need any separators prefixed.
+
+      target.push(styleAttributeStart, nameChunk, styleAssign, valueChunk);
+    } else {
+      target.push(styleSeparator, nameChunk, styleAssign, valueChunk);
+    }
+  }
+
+  if (!isFirst) {
+    target.push(attributeEnd);
+  }
+}
+
+const attributeSeparator = stringToPrecomputedChunk(' ');
+const attributeAssign = stringToPrecomputedChunk('="');
+const attributeEnd = stringToPrecomputedChunk('"');
+const attributeEmptyString = stringToPrecomputedChunk('=""');
+
+function pushBooleanAttribute(target, name, value) // not null or undefined
+{
+  if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+    target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+  }
+}
+
+function pushStringAttribute(target, name, value) // not null or undefined
+{
+  if (typeof value !== 'function' && typeof value !== 'symbol' && typeof value !== 'boolean') {
+    target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+  }
+}
+
+function makeFormFieldPrefix(resumableState) {
+  const id = resumableState.nextFormID++;
+  return resumableState.idPrefix + id;
+} // Since this will likely be repeated a lot in the HTML, we use a more concise message
+// than on the client and hopefully it's googleable.
+
+
+const actionJavaScriptURL = stringToPrecomputedChunk(escapeTextForBrowser( // eslint-disable-next-line no-script-url
+"javascript:throw new Error('A React form was unexpectedly submitted.')"));
+const startHiddenInputChunk = stringToPrecomputedChunk('<input type="hidden"');
+
+function pushAdditionalFormField(value, key) {
+  const target = this;
+  target.push(startHiddenInputChunk);
+
+  if (typeof value !== 'string') {
+    throw Error(formatProdErrorMessage(480));
+  }
+
+  pushStringAttribute(target, 'name', key);
+  pushStringAttribute(target, 'value', value);
+  target.push(endOfStartTagSelfClosing);
+}
+
+function pushAdditionalFormFields(target, formData) {
+  if (formData !== null) {
+    // $FlowFixMe[prop-missing]: FormData has forEach.
+    formData.forEach(pushAdditionalFormField, target);
+  }
+}
+
+function pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name) {
+  let formData = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      name = customFields.name;
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('formAction'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      name = null;
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (name != null) {
+    pushAttribute(target, 'name', name);
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'formAction', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'formEncType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'formMethod', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'formTarget', formTarget);
+  }
+
+  return formData;
+}
+
+function pushAttribute(target, name, value) // not null or undefined
+{
+  switch (name) {
+    // These are very common props and therefore are in the beginning of the switch.
+    // TODO: aria-label is a very common prop but allows booleans so is not like the others
+    // but should ideally go in this list too.
+    case 'className':
+      {
+        pushStringAttribute(target, 'class', value);
+        break;
+      }
+
+    case 'tabIndex':
+      {
+        pushStringAttribute(target, 'tabindex', value);
+        break;
+      }
+
+    case 'dir':
+    case 'role':
+    case 'viewBox':
+    case 'width':
+    case 'height':
+      {
+        pushStringAttribute(target, name, value);
+        break;
+      }
+
+    case 'style':
+      {
+        pushStyleAttribute(target, value);
+        return;
+      }
+
+    case 'src':
+    case 'href':
+    // Fall through to the last case which shouldn't remove empty strings.
+
+    case 'action':
+    case 'formAction':
+      {
+        // TODO: Consider only special casing these for each tag.
+        if (value == null || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'defaultValue':
+    case 'defaultChecked': // These shouldn't be set as attributes on generic HTML elements.
+
+    case 'innerHTML': // Must use dangerouslySetInnerHTML instead.
+
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+      // Ignored. These are built-in to React on the client.
+      return;
+
+    case 'autoFocus':
+    case 'multiple':
+    case 'muted':
+      {
+        pushBooleanAttribute(target, name.toLowerCase(), value);
+        return;
+      }
+
+    case 'xlinkHref':
+      {
+        if (typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk('xlink:href'), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'contentEditable':
+    case 'spellCheck':
+    case 'draggable':
+    case 'value':
+    case 'autoReverse':
+    case 'externalResourcesRequired':
+    case 'focusable':
+    case 'preserveAlpha':
+      {
+        // Booleanish String
+        // These are "enumerated" attributes that accept "true" and "false".
+        // In React, we let users pass `true` and `false` even though technically
+        // these aren't boolean attributes (they are coerced to strings).
+        if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'allowFullScreen':
+    case 'async':
+    case 'autoPlay':
+    case 'controls':
+    case 'default':
+    case 'defer':
+    case 'disabled':
+    case 'disablePictureInPicture':
+    case 'disableRemotePlayback':
+    case 'formNoValidate':
+    case 'hidden':
+    case 'loop':
+    case 'noModule':
+    case 'noValidate':
+    case 'open':
+    case 'playsInline':
+    case 'readOnly':
+    case 'required':
+    case 'reversed':
+    case 'scoped':
+    case 'seamless':
+    case 'itemScope':
+      {
+        // Boolean
+        if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        }
+
+        return;
+      }
+
+    case 'capture':
+    case 'download':
+      {
+        // Overloaded Boolean
+        if (value === true) {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        } else if (value === false) ; else if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'cols':
+    case 'rows':
+    case 'size':
+    case 'span':
+      {
+        // These are HTML attributes that must be positive numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value) && value >= 1) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'rowSpan':
+    case 'start':
+      {
+        // These are HTML attributes that must be numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value)) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'xlinkActuate':
+      pushStringAttribute(target, 'xlink:actuate', value);
+      return;
+
+    case 'xlinkArcrole':
+      pushStringAttribute(target, 'xlink:arcrole', value);
+      return;
+
+    case 'xlinkRole':
+      pushStringAttribute(target, 'xlink:role', value);
+      return;
+
+    case 'xlinkShow':
+      pushStringAttribute(target, 'xlink:show', value);
+      return;
+
+    case 'xlinkTitle':
+      pushStringAttribute(target, 'xlink:title', value);
+      return;
+
+    case 'xlinkType':
+      pushStringAttribute(target, 'xlink:type', value);
+      return;
+
+    case 'xmlBase':
+      pushStringAttribute(target, 'xml:base', value);
+      return;
+
+    case 'xmlLang':
+      pushStringAttribute(target, 'xml:lang', value);
+      return;
+
+    case 'xmlSpace':
+      pushStringAttribute(target, 'xml:space', value);
+      return;
+
+    default:
+      if ( // shouldIgnoreAttribute
+      // We have already filtered out null/undefined and reserved words.
+      name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+        return;
+      }
+
+      const attributeName = getAttributeAlias(name);
+
+      if (isAttributeNameSafe(attributeName)) {
+        // shouldRemoveAttribute
+        switch (typeof value) {
+          case 'function':
+          case 'symbol':
+            // eslint-disable-line
+            return;
+
+          case 'boolean':
+            {
+              const prefix = attributeName.toLowerCase().slice(0, 5);
+
+              if (prefix !== 'data-' && prefix !== 'aria-') {
+                return;
+              }
+            }
+        }
+
+        target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+      }
+
+  }
+}
+
+const endOfStartTag = stringToPrecomputedChunk('>');
+const endOfStartTagSelfClosing = stringToPrecomputedChunk('/>');
+
+function pushInnerHTML(target, innerHTML, children) {
+  if (innerHTML != null) {
+    if (children != null) {
+      throw Error(formatProdErrorMessage(60));
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw Error(formatProdErrorMessage(61));
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+
+      target.push(stringToChunk('' + html));
+    }
+  }
+} // TODO: Move these to RenderState so that we warn for every request.
+
+function pushStartSelect(target, props) {
+
+  target.push(startChunkForTag('select'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          // TODO: This doesn't really make sense for select since it can't use the controlled
+          // value in the innerHTML.
+          innerHTML = propValue;
+          break;
+
+        case 'defaultValue':
+        case 'value':
+          // These are set on the Context instead and applied to the nested options.
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+function flattenOptionChildren(children) {
+  let content = ''; // Flatten children and warn if they aren't strings or numbers;
+  // invalid types are ignored.
+
+  React.Children.forEach(children, function (child) {
+    if (child == null) {
+      return;
+    }
+
+    content += child;
+  });
+  return content;
+}
+
+const selectedMarkerAttribute = stringToPrecomputedChunk(' selected=""');
+
+function pushStartOption(target, props, formatContext) {
+  const selectedValue = formatContext.selectedValue;
+  target.push(startChunkForTag('option'));
+  let children = null;
+  let value = null;
+  let selected = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'selected':
+          // ignore
+          selected = propValue;
+
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+        // We intentionally fallthrough to also set the attribute on the node.
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (selectedValue != null) {
+    let stringValue;
+
+    if (value !== null) {
+
+      stringValue = '' + value;
+    } else {
+
+      stringValue = flattenOptionChildren(children);
+    }
+
+    if (isArray(selectedValue)) {
+      // multiple
+      for (let i = 0; i < selectedValue.length; i++) {
+
+        const v = '' + selectedValue[i];
+
+        if (v === stringValue) {
+          target.push(selectedMarkerAttribute);
+          break;
+        }
+      }
+    } else {
+
+      if ('' + selectedValue === stringValue) {
+        target.push(selectedMarkerAttribute);
+      }
+    }
+  } else if (selected) {
+    target.push(selectedMarkerAttribute);
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const formReplayingRuntimeScript = stringToPrecomputedChunk(formReplaying);
+
+function injectFormReplayingRuntime(resumableState, renderState) {
+  // If we haven't sent it yet, inject the runtime that tracks submitted JS actions
+  // for later replaying by Fiber. If we use an external runtime, we don't need
+  // to emit anything. It's always used.
+  if ((resumableState.instructions & SentFormReplayingRuntime) === NothingSent && (!renderState.externalRuntimeScript)) {
+    resumableState.instructions |= SentFormReplayingRuntime;
+    renderState.bootstrapChunks.unshift(renderState.startInlineScript, formReplayingRuntimeScript, endInlineScript);
+  }
+}
+
+const formStateMarkerIsMatching = stringToPrecomputedChunk('<!--F!-->');
+const formStateMarkerIsNotMatching = stringToPrecomputedChunk('<!--F-->');
+function pushFormStateMarkerIsMatching(target) {
+  target.push(formStateMarkerIsMatching);
+}
+function pushFormStateMarkerIsNotMatching(target) {
+  target.push(formStateMarkerIsNotMatching);
+}
+
+function pushStartForm(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('form'));
+  let children = null;
+  let innerHTML = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'action':
+          formAction = propValue;
+          break;
+
+        case 'encType':
+          formEncType = propValue;
+          break;
+
+        case 'method':
+          formMethod = propValue;
+          break;
+
+        case 'target':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  let formData = null;
+  let formActionName = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+      formActionName = customFields.name;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('action'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'action', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'encType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'method', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'target', formTarget);
+  }
+
+  target.push(endOfStartTag);
+
+  if (formActionName !== null) {
+    target.push(startHiddenInputChunk);
+    pushStringAttribute(target, 'name', formActionName);
+    target.push(endOfStartTagSelfClosing);
+    pushAdditionalFormFields(target, formData);
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushInput(target, props, resumableState, renderState) {
+
+  target.push(startChunkForTag('input'));
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+  let value = null;
+  let defaultValue = null;
+  let checked = null;
+  let defaultChecked = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(399, 'input'));
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        case 'defaultChecked':
+          defaultChecked = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'checked':
+          checked = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+
+  if (checked !== null) {
+    pushBooleanAttribute(target, 'checked', checked);
+  } else if (defaultChecked !== null) {
+    pushBooleanAttribute(target, 'checked', defaultChecked);
+  }
+
+  if (value !== null) {
+    pushAttribute(target, 'value', value);
+  } else if (defaultValue !== null) {
+    pushAttribute(target, 'value', defaultValue);
+  }
+
+  target.push(endOfStartTagSelfClosing); // We place any additional hidden form fields after the input.
+
+  pushAdditionalFormFields(target, formData);
+  return null;
+}
+
+function pushStartButton(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('button'));
+  let children = null;
+  let innerHTML = null;
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+  target.push(endOfStartTag); // We place any additional hidden form fields we need to include inside the button itself.
+
+  pushAdditionalFormFields(target, formData);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartTextArea(target, props) {
+
+  target.push(startChunkForTag('textarea'));
+  let value = null;
+  let defaultValue = null;
+  let children = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(91));
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (value === null && defaultValue !== null) {
+    value = defaultValue;
+  }
+
+  target.push(endOfStartTag); // TODO (yungsters): Remove support for children content in <textarea>.
+
+  if (children != null) {
+
+    if (value != null) {
+      throw Error(formatProdErrorMessage(92));
+    }
+
+    if (isArray(children)) {
+      if (children.length > 1) {
+        throw Error(formatProdErrorMessage(93));
+      } // TODO: remove the coercion and the DEV check below because it will
+
+      value = '' + children[0];
+    }
+
+    value = '' + children;
+  }
+
+  if (typeof value === 'string' && value[0] === '\n') {
+    // text/html ignores the first character in these tags if it's a newline
+    // Prefer to break application/xml over text/html (for now) by adding
+    // a newline specifically to get eaten by the parser. (Alternately for
+    // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+    // \r is normalized out by HTMLTextAreaElement#value.)
+    // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+    // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+    // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+    // See: Parsing of "textarea" "listing" and "pre" elements
+    //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+    target.push(leadingNewline);
+  } // ToString and push directly instead of recurse over children.
+  // We don't really support complex children in the value anyway.
+  // This also currently avoids a trailing comment node which breaks textarea.
+
+
+  if (value !== null) {
+
+    target.push(stringToChunk(encodeHTMLTextNode('' + value)));
+  }
+
+  return null;
+}
+
+function pushMeta(target, props, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      return pushSelfClosing(target, props, 'meta');
+    } else {
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      if (typeof props.charSet === 'string') {
+        return pushSelfClosing(renderState.charsetChunks, props, 'meta');
+      } else if (props.name === 'viewport') {
+        // "viewport" isn't related to preconnect but it has the right priority
+        return pushSelfClosing(renderState.preconnectChunks, props, 'meta');
+      } else {
+        return pushSelfClosing(renderState.hoistableChunks, props, 'meta');
+      }
+    }
+  }
+}
+
+function pushLink(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const rel = props.rel;
+    const href = props.href;
+    const precedence = props.precedence;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof rel !== 'string' || typeof href !== 'string' || href === '') {
+
+      pushLinkImpl(target, props);
+      return null;
+    }
+
+    if (props.rel === 'stylesheet') {
+      // This <link> may hoistable as a Stylesheet Resource, otherwise it will emit in place
+      const key = getResourceKey(href);
+
+      if (typeof precedence !== 'string' || props.disabled != null || props.onLoad || props.onError) {
+
+        return pushLinkImpl(target, props);
+      } else {
+        // This stylesheet refers to a Resource and we create a new one if necessary
+        let styleQueue = renderState.styles.get(precedence);
+        const hasKey = resumableState.styleResources.hasOwnProperty(key);
+        const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+        if (resourceState !== EXISTS) {
+          // We are going to create this resource now so it is marked as Exists
+          resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+          // to create a StyleQueue
+
+          if (!styleQueue) {
+            styleQueue = {
+              precedence: stringToChunk(escapeTextForBrowser(precedence)),
+              rules: [],
+              hrefs: [],
+              sheets: new Map()
+            };
+            renderState.styles.set(precedence, styleQueue);
+          }
+
+          const resource = {
+            state: PENDING$1,
+            props: stylesheetPropsFromRawProps(props)
+          };
+
+          if (resourceState) {
+            // When resourceState is truty it is a Preload state. We cast it for clarity
+            const preloadState = resourceState;
+
+            if (preloadState.length === 2) {
+              adoptPreloadCredentials(resource.props, preloadState);
+            }
+
+            const preloadResource = renderState.preloads.stylesheets.get(key);
+
+            if (preloadResource && preloadResource.length > 0) {
+              // The Preload for this resource was created in this render pass and has not flushed yet so
+              // we need to clear it to avoid it flushing.
+              preloadResource.length = 0;
+            } else {
+              // Either the preload resource from this render already flushed in this render pass
+              // or the preload flushed in a prior pass (prerender). In either case we need to mark
+              // this resource as already having been preloaded.
+              resource.state = PRELOADED;
+            }
+          } // We add the newly created resource to our StyleQueue and if necessary
+          // track the resource with the currently rendering boundary
+
+
+          styleQueue.sheets.set(key, resource);
+
+          if (renderState.boundaryResources) {
+            renderState.boundaryResources.stylesheets.add(resource);
+          }
+        } else {
+          // We need to track whether this boundary should wait on this resource or not.
+          // Typically this resource should always exist since we either had it or just created
+          // it. However, it's possible when you resume that the style has already been emitted
+          // and then it wouldn't be recreated in the RenderState and there's no need to track
+          // it again since we should've hoisted it to the shell already.
+          if (styleQueue) {
+            const resource = styleQueue.sheets.get(key);
+
+            if (resource) {
+              if (renderState.boundaryResources) {
+                renderState.boundaryResources.stylesheets.add(resource);
+              }
+            }
+          }
+        }
+
+        if (textEmbedded) {
+          // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+          // to be safe and assume text will follow by inserting a textSeparator
+          target.push(textSeparator);
+        }
+
+        return null;
+      }
+    } else if (props.onLoad || props.onError) {
+      // When using load handlers we cannot hoist and need to emit links in place
+      return pushLinkImpl(target, props);
+    } else {
+      // We can hoist this link so we may need to emit a text separator.
+      // @TODO refactor text separators so we don't have to defensively add
+      // them when we don't end up emitting a tag as a result of pushStartInstance
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      switch (props.rel) {
+        case 'preconnect':
+        case 'dns-prefetch':
+          return pushLinkImpl(renderState.preconnectChunks, props);
+
+        case 'preload':
+          return pushLinkImpl(renderState.preloadChunks, props);
+
+        default:
+          return pushLinkImpl(renderState.hoistableChunks, props);
+      }
+    }
+  }
+}
+
+function pushLinkImpl(target, props) {
+  target.push(startChunkForTag('link'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(399, 'link'));
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStyle(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+
+  {
+    const precedence = props.precedence;
+    const href = props.href;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof precedence !== 'string' || typeof href !== 'string' || href === '') {
+      // This style tag is not able to be turned into a Style Resource
+      return pushStyleImpl(target, props);
+    }
+
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS;
+
+      if (!styleQueue) {
+        // This is the first time we've encountered this precedence we need
+        // to create a StyleQueue.
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [stringToChunk(escapeTextForBrowser(href))],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      } else {
+        // We have seen this precedence before and need to track this href
+        styleQueue.hrefs.push(stringToChunk(escapeTextForBrowser(href)));
+      }
+
+      pushStyleContents(styleQueue.rules, props);
+    }
+
+    if (styleQueue) {
+      // We need to track whether this boundary should wait on this resource or not.
+      // Typically this resource should always exist since we either had it or just created
+      // it. However, it's possible when you resume that the style has already been emitted
+      // and then it wouldn't be recreated in the RenderState and there's no need to track
+      // it again since we should've hoisted it to the shell already.
+      if (renderState.boundaryResources) {
+        renderState.boundaryResources.styles.add(styleQueue);
+      }
+    }
+
+    if (textEmbedded) {
+      // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+  }
+}
+
+function pushStyleImpl(target, props) {
+  target.push(startChunkForTag('style'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('style'));
+  return null;
+}
+
+function pushStyleContents(target, props) {
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+      }
+    }
+  }
+
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  return;
+}
+
+function pushImg(target, props, resumableState, renderState, pictureTagInScope) {
+  const src = props.src,
+        srcSet = props.srcSet;
+
+  if (props.loading !== 'lazy' && (src || srcSet) && (typeof src === 'string' || src == null) && (typeof srcSet === 'string' || srcSet == null) && props.fetchPriority !== 'low' && pictureTagInScope === false && // We exclude data URIs in src and srcSet since these should not be preloaded
+  !(typeof src === 'string' && src[4] === ':' && (src[0] === 'd' || src[0] === 'D') && (src[1] === 'a' || src[1] === 'A') && (src[2] === 't' || src[2] === 'T') && (src[3] === 'a' || src[3] === 'A')) && !(typeof srcSet === 'string' && srcSet[4] === ':' && (srcSet[0] === 'd' || srcSet[0] === 'D') && (srcSet[1] === 'a' || srcSet[1] === 'A') && (srcSet[2] === 't' || srcSet[2] === 'T') && (srcSet[3] === 'a' || srcSet[3] === 'A'))) {
+    // We have a suspensey image and ought to preload it to optimize the loading of display blocking
+    // resumableState.
+    const sizes = typeof props.sizes === 'string' ? props.sizes : undefined;
+    const key = getImageResourceKey(src, srcSet, sizes);
+    const promotablePreloads = renderState.preloads.images;
+    let resource = promotablePreloads.get(key);
+
+    if (resource) {
+      // We consider whether this preload can be promoted to higher priority flushing queue.
+      // The only time a resource will exist here is if it was created during this render
+      // and was not already in the high priority queue.
+      if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+        // Delete the resource from the map since we are promoting it and don't want to
+        // reenter this branch in a second pass for duplicate img hrefs.
+        promotablePreloads.delete(key); // $FlowFixMe - Flow should understand that this is a Resource if the condition was true
+
+        renderState.highImagePreloads.add(resource);
+      }
+    } else if (!resumableState.imageResources.hasOwnProperty(key)) {
+      // We must construct a new preload resource
+      resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+      const crossOrigin = getCrossOriginString(props.crossOrigin);
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // this is a hueristic similar to capping element preloads to 10 unless explicitly
+      // fetchPriority="high". We use length here which means it will fit fewer images when
+      // the urls are long and more when short. arguably byte size is a better hueristic because
+      // it directly translates to how much we send down before content is actually seen.
+      // We could unify the counts and also make it so the total is tracked regardless of
+      // flushing output but since the headers are likely to be go earlier than content
+      // they don't really conflict so for now I've kept them separate
+      props.fetchPriority === 'high' || headers.highImagePreloads.length < 500) && ( // We manually construct the options for the preload only from strings. We don't want to pollute
+      // the params list with arbitrary props and if we copied everything over as it we might get
+      // coercion errors. We have checks for this in Dev but it seems safer to just only accept values
+      // that are strings
+      header = getPreloadAsHeader(src, 'image', {
+        imageSrcSet: props.srcSet,
+        imageSizes: props.sizes,
+        crossOrigin,
+        integrity: props.integrity,
+        nonce: props.nonce,
+        type: props.type,
+        fetchPriority: props.fetchPriority,
+        referrerPolicy: props.refererPolicy
+      }), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // If we postpone in the shell we will still emit this preload so we track
+        // it to make sure we don't reset it.
+        renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+        if (headers.highImagePreloads) {
+          headers.highImagePreloads += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.highImagePreloads += header;
+      } else {
+        resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preload',
+          as: 'image',
+          // There is a bug in Safari where imageSrcSet is not respected on preload links
+          // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+          // This harms older browers that do not support imageSrcSet by making their preloads not work
+          // but this population is shrinking fast and is already small so we accept this tradeoff.
+          href: srcSet ? undefined : src,
+          imageSrcSet: srcSet,
+          imageSizes: sizes,
+          crossOrigin: crossOrigin,
+          integrity: props.integrity,
+          type: props.type,
+          fetchPriority: props.fetchPriority,
+          referrerPolicy: props.referrerPolicy
+        });
+
+        if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+          renderState.highImagePreloads.add(resource);
+        } else {
+          renderState.bulkPreloads.add(resource); // We can bump the priority up if the same img is rendered later
+          // with fetchPriority="high"
+
+          promotablePreloads.set(key, resource);
+        }
+      }
+    }
+  }
+
+  return pushSelfClosing(target, props, 'img');
+}
+
+function pushSelfClosing(target, props, tag) {
+  target.push(startChunkForTag(tag));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(399, tag));
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStartMenuItem(target, props) {
+  target.push(startChunkForTag('menuitem'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(400));
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  return null;
+}
+
+function pushTitle(target, props, renderState, insertionMode, noscriptTagInScope) {
+
+  {
+    if (insertionMode !== SVG_MODE && !noscriptTagInScope && props.itemProp == null) {
+      pushTitleImpl(renderState.hoistableChunks, props);
+      return null;
+    } else {
+      return pushTitleImpl(target, props);
+    }
+  }
+}
+
+function pushTitleImpl(target, props) {
+  target.push(startChunkForTag('title'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('title'));
+  return null;
+}
+
+function pushStartHead(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode < HTML_MODE && renderState.headChunks === null) {
+      // This <head> is the Document.head and should be part of the preamble
+      renderState.headChunks = [];
+      return pushStartGenericElement(renderState.headChunks, props, 'head');
+    } else {
+      // This <head> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'head');
+    }
+  }
+}
+
+function pushStartHtml(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode === ROOT_HTML_MODE && renderState.htmlChunks === null) {
+      // This <html> is the Document.documentElement and should be part of the preamble
+      renderState.htmlChunks = [doctypeChunk];
+      return pushStartGenericElement(renderState.htmlChunks, props, 'html');
+    } else {
+      // This <html> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'html');
+    }
+  }
+}
+
+function pushScript(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const asyncProp = props.async;
+
+    if (typeof props.src !== 'string' || !props.src || !(asyncProp && typeof asyncProp !== 'function' && typeof asyncProp !== 'symbol') || props.onLoad || props.onError || insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      // This script will not be a resource, we bailout early and emit it in place.
+      return pushScriptImpl(target, props);
+    }
+
+    const src = props.src;
+    const key = getResourceKey(src); // We can make this <script> into a ScriptResource
+
+    let resources, preloads;
+
+    if (props.type === 'module') {
+      resources = resumableState.moduleScriptResources;
+      preloads = renderState.preloads.moduleScripts;
+    } else {
+      resources = resumableState.scriptResources;
+      preloads = renderState.preloads.scripts;
+    }
+
+    const hasKey = resources.hasOwnProperty(key);
+    const resourceState = hasKey ? resources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resources[key] = EXISTS;
+      let scriptProps = props;
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          scriptProps = assign({}, props);
+          adoptPreloadCredentials(scriptProps, preloadState);
+        }
+
+        const preloadResource = preloads.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, scriptProps);
+    }
+
+    if (textEmbedded) {
+      // This script follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+
+    return null;
+  }
+}
+
+function pushScriptImpl(target, props) {
+  target.push(startChunkForTag('script'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+  }
+
+  target.push(endChunkForTag('script'));
+  return null;
+}
+
+function pushStartGenericElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartCustomElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      let propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      let attributeName = propKey;
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'style':
+          pushStyleAttribute(target, propValue);
+          break;
+
+        case 'suppressContentEditableWarning':
+        case 'suppressHydrationWarning':
+          // Ignored. These are built-in to React on the client.
+          break;
+
+        case 'className':
+
+        // intentional fallthrough
+
+        default:
+          if (isAttributeNameSafe(propKey) && typeof propValue !== 'function' && typeof propValue !== 'symbol') {
+
+            target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(propValue)), attributeEnd);
+          }
+
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const leadingNewline = stringToPrecomputedChunk('\n');
+
+function pushStartPreformattedElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag); // text/html ignores the first character in these tags if it's a newline
+  // Prefer to break application/xml over text/html (for now) by adding
+  // a newline specifically to get eaten by the parser. (Alternately for
+  // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+  // \r is normalized out by HTMLTextAreaElement#value.)
+  // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+  // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+  // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+  // See: Parsing of "textarea" "listing" and "pre" elements
+  //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+  // TODO: This doesn't deal with the case where the child is an array
+  // or component that returns a string.
+
+  if (innerHTML != null) {
+    if (children != null) {
+      throw Error(formatProdErrorMessage(60));
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw Error(formatProdErrorMessage(61));
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+      if (typeof html === 'string' && html.length > 0 && html[0] === '\n') {
+        target.push(leadingNewline, stringToChunk(html));
+      } else {
+
+        target.push(stringToChunk('' + html));
+      }
+    }
+  }
+
+  if (typeof children === 'string' && children[0] === '\n') {
+    target.push(leadingNewline);
+  }
+
+  return children;
+} // We accept any tag to be rendered but since this gets injected into arbitrary
+// HTML, we want to make sure that it's a safe tag.
+// http://www.w3.org/TR/REC-xml/#NT-Name
+
+
+const VALID_TAG_REGEX = /^[a-zA-Z][a-zA-Z:_\.\-\d]*$/; // Simplified subset
+
+const validatedTagCache = new Map();
+
+function startChunkForTag(tag) {
+  let tagStartChunk = validatedTagCache.get(tag);
+
+  if (tagStartChunk === undefined) {
+    if (!VALID_TAG_REGEX.test(tag)) {
+      throw Error(formatProdErrorMessage(65, tag));
+    }
+
+    tagStartChunk = stringToPrecomputedChunk('<' + tag);
+    validatedTagCache.set(tag, tagStartChunk);
+  }
+
+  return tagStartChunk;
+}
+
+const doctypeChunk = stringToPrecomputedChunk('<!DOCTYPE html>');
+function pushStartInstance(target, type, props, resumableState, renderState, formatContext, textEmbedded) {
+
+  switch (type) {
+    case 'div':
+    case 'span':
+    case 'svg':
+    case 'path':
+    case 'a':
+    case 'g':
+    case 'p':
+    case 'li':
+      // Fast track very common tags
+      break;
+    // Special tags
+
+    case 'select':
+      return pushStartSelect(target, props);
+
+    case 'option':
+      return pushStartOption(target, props, formatContext);
+
+    case 'textarea':
+      return pushStartTextArea(target, props);
+
+    case 'input':
+      return pushInput(target, props, resumableState, renderState);
+
+    case 'button':
+      return pushStartButton(target, props, resumableState, renderState);
+
+    case 'form':
+      return pushStartForm(target, props, resumableState, renderState);
+
+    case 'menuitem':
+      return pushStartMenuItem(target, props);
+
+    case 'title':
+      return pushTitle(target, props, renderState, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'link':
+      return pushLink(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'script':
+      return pushScript(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'style':
+      return pushStyle(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'meta':
+      return pushMeta(target, props, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+    // Newline eating tags
+
+    case 'listing':
+    case 'pre':
+      {
+        return pushStartPreformattedElement(target, props, type);
+      }
+
+    case 'img':
+      {
+        return pushImg(target, props, resumableState, renderState, !!(formatContext.tagScope & PICTURE_SCOPE)) ;
+      }
+    // Omitted close tags
+
+    case 'base':
+    case 'area':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'keygen':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        return pushSelfClosing(target, props, type);
+      }
+    // These are reserved SVG and MathML elements, that are never custom elements.
+    // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+
+    case 'annotation-xml':
+    case 'color-profile':
+    case 'font-face':
+    case 'font-face-src':
+    case 'font-face-uri':
+    case 'font-face-format':
+    case 'font-face-name':
+    case 'missing-glyph':
+      {
+        break;
+      }
+    // Preamble start tags
+
+    case 'head':
+      return pushStartHead(target, props, renderState, formatContext.insertionMode);
+
+    case 'html':
+      {
+        return pushStartHtml(target, props, renderState, formatContext.insertionMode);
+      }
+
+    default:
+      {
+        if (type.indexOf('-') !== -1) {
+          // Custom element
+          return pushStartCustomElement(target, props, type);
+        }
+      }
+  } // Generic element
+
+
+  return pushStartGenericElement(target, props, type);
+}
+const endTagCache = new Map();
+
+function endChunkForTag(tag) {
+  let chunk = endTagCache.get(tag);
+
+  if (chunk === undefined) {
+    chunk = stringToPrecomputedChunk('</' + tag + '>');
+    endTagCache.set(tag, chunk);
+  }
+
+  return chunk;
+}
+
+function pushEndInstance(target, type, props, resumableState, formatContext) {
+  switch (type) {
+    // When float is on we expect title and script tags to always be pushed in
+    // a unit and never return children. when we end up pushing the end tag we
+    // want to ensure there is no extra closing tag pushed
+    case 'title':
+    case 'style':
+    case 'script':
+    // Omitted close tags
+    // TODO: Instead of repeating this switch we could try to pass a flag from above.
+    // That would require returning a tuple. Which might be ok if it gets inlined.
+
+    case 'area':
+    case 'base':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'img':
+    case 'input':
+    case 'keygen':
+    case 'link':
+    case 'meta':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        // No close tag needed.
+        return;
+      }
+    // Postamble end tags
+    // When float is enabled we omit the end tags for body and html when
+    // they represent the Document.body and Document.documentElement Nodes.
+    // This is so we can withhold them until the postamble when we know
+    // we won't emit any more tags
+
+    case 'body':
+      {
+        if (formatContext.insertionMode <= HTML_HTML_MODE) {
+          resumableState.hasBody = true;
+          return;
+        }
+
+        break;
+      }
+
+    case 'html':
+      if (formatContext.insertionMode === ROOT_HTML_MODE) {
+        resumableState.hasHtml = true;
+        return;
+      }
+
+      break;
+  }
+
+  target.push(endChunkForTag(type));
+}
+
+function writeBootstrap(destination, renderState, resumableState) {
+  resumableState.bootstrapScriptContent = undefined;
+  resumableState.bootstrapScripts = undefined;
+  resumableState.bootstrapModules = undefined;
+  const bootstrapChunks = renderState.bootstrapChunks;
+  let i = 0;
+
+  for (; i < bootstrapChunks.length - 1; i++) {
+    writeChunk(destination, bootstrapChunks[i]);
+  }
+
+  if (i < bootstrapChunks.length) {
+    const lastChunk = bootstrapChunks[i];
+    bootstrapChunks.length = 0;
+    return writeChunkAndReturn(destination, lastChunk);
+  }
+
+  return true;
+}
+
+function writeCompletedRoot(destination, renderState, resumableState) {
+  return writeBootstrap(destination, renderState, resumableState);
+} // Structural Nodes
+// A placeholder is a node inside a hidden partial tree that can be filled in later, but before
+// display. It's never visible to users. We use the template tag because it can be used in every
+// type of parent. <script> tags also work in every other tag except <colgroup>.
+
+const placeholder1 = stringToPrecomputedChunk('<template id="');
+const placeholder2 = stringToPrecomputedChunk('"></template>');
+function writePlaceholder(destination, renderState, id) {
+  writeChunk(destination, placeholder1);
+  writeChunk(destination, renderState.placeholderPrefix);
+  const formattedID = stringToChunk(id.toString(16));
+  writeChunk(destination, formattedID);
+  return writeChunkAndReturn(destination, placeholder2);
+} // Suspense boundaries are encoded as comments.
+
+const startCompletedSuspenseBoundary = stringToPrecomputedChunk('<!--$-->');
+const startPendingSuspenseBoundary1 = stringToPrecomputedChunk('<!--$?--><template id="');
+const startPendingSuspenseBoundary2 = stringToPrecomputedChunk('"></template>');
+const startClientRenderedSuspenseBoundary = stringToPrecomputedChunk('<!--$!-->');
+const endSuspenseBoundary = stringToPrecomputedChunk('<!--/$-->');
+const clientRenderedSuspenseBoundaryError1 = stringToPrecomputedChunk('<template');
+const clientRenderedSuspenseBoundaryErrorAttrInterstitial = stringToPrecomputedChunk('"');
+const clientRenderedSuspenseBoundaryError1A = stringToPrecomputedChunk(' data-dgst="');
+stringToPrecomputedChunk(' data-msg="');
+stringToPrecomputedChunk(' data-stck="');
+const clientRenderedSuspenseBoundaryError2 = stringToPrecomputedChunk('></template>');
+function writeStartCompletedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, startCompletedSuspenseBoundary);
+}
+function writeStartPendingSuspenseBoundary(destination, renderState, id) {
+  writeChunk(destination, startPendingSuspenseBoundary1);
+
+  if (id === null) {
+    throw Error(formatProdErrorMessage(395));
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+  return writeChunkAndReturn(destination, startPendingSuspenseBoundary2);
+}
+function writeStartClientRenderedSuspenseBoundary(destination, renderState, errorDigest, errorMesssage, errorComponentStack) {
+  let result;
+  result = writeChunkAndReturn(destination, startClientRenderedSuspenseBoundary);
+  writeChunk(destination, clientRenderedSuspenseBoundaryError1);
+
+  if (errorDigest) {
+    writeChunk(destination, clientRenderedSuspenseBoundaryError1A);
+    writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest)));
+    writeChunk(destination, clientRenderedSuspenseBoundaryErrorAttrInterstitial);
+  }
+
+  result = writeChunkAndReturn(destination, clientRenderedSuspenseBoundaryError2);
+  return result;
+}
+function writeEndCompletedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndPendingSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndClientRenderedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+const startSegmentHTML = stringToPrecomputedChunk('<div hidden id="');
+const startSegmentHTML2 = stringToPrecomputedChunk('">');
+const endSegmentHTML = stringToPrecomputedChunk('</div>');
+const startSegmentSVG = stringToPrecomputedChunk('<svg aria-hidden="true" style="display:none" id="');
+const startSegmentSVG2 = stringToPrecomputedChunk('">');
+const endSegmentSVG = stringToPrecomputedChunk('</svg>');
+const startSegmentMathML = stringToPrecomputedChunk('<math aria-hidden="true" style="display:none" id="');
+const startSegmentMathML2 = stringToPrecomputedChunk('">');
+const endSegmentMathML = stringToPrecomputedChunk('</math>');
+const startSegmentTable = stringToPrecomputedChunk('<table hidden id="');
+const startSegmentTable2 = stringToPrecomputedChunk('">');
+const endSegmentTable = stringToPrecomputedChunk('</table>');
+const startSegmentTableBody = stringToPrecomputedChunk('<table hidden><tbody id="');
+const startSegmentTableBody2 = stringToPrecomputedChunk('">');
+const endSegmentTableBody = stringToPrecomputedChunk('</tbody></table>');
+const startSegmentTableRow = stringToPrecomputedChunk('<table hidden><tr id="');
+const startSegmentTableRow2 = stringToPrecomputedChunk('">');
+const endSegmentTableRow = stringToPrecomputedChunk('</tr></table>');
+const startSegmentColGroup = stringToPrecomputedChunk('<table hidden><colgroup id="');
+const startSegmentColGroup2 = stringToPrecomputedChunk('">');
+const endSegmentColGroup = stringToPrecomputedChunk('</colgroup></table>');
+function writeStartSegment(destination, renderState, formatContext, id) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        writeChunk(destination, startSegmentHTML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentHTML2);
+      }
+
+    case SVG_MODE:
+      {
+        writeChunk(destination, startSegmentSVG);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentSVG2);
+      }
+
+    case MATHML_MODE:
+      {
+        writeChunk(destination, startSegmentMathML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentMathML2);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        writeChunk(destination, startSegmentTable);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTable2);
+      }
+    // TODO: For the rest of these, there will be extra wrapper nodes that never
+    // get deleted from the document. We need to delete the table too as part
+    // of the injected scripts. They are invisible though so it's not too terrible
+    // and it's kind of an edge case to suspend in a table. Totally supported though.
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        writeChunk(destination, startSegmentTableBody);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableBody2);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        writeChunk(destination, startSegmentTableRow);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableRow2);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        writeChunk(destination, startSegmentColGroup);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentColGroup2);
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(397));
+      }
+  }
+}
+function writeEndSegment(destination, formatContext) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentHTML);
+      }
+
+    case SVG_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentSVG);
+      }
+
+    case MATHML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentMathML);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTable);
+      }
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableBody);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableRow);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentColGroup);
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(397));
+      }
+  }
+}
+const completeSegmentScript1Full = stringToPrecomputedChunk(completeSegment + '$RS("');
+const completeSegmentScript1Partial = stringToPrecomputedChunk('$RS("');
+const completeSegmentScript2 = stringToPrecomputedChunk('","');
+const completeSegmentScriptEnd = stringToPrecomputedChunk('")</script>');
+const completeSegmentData1 = stringToPrecomputedChunk('<template data-rsi="" data-sid="');
+const completeSegmentData2 = stringToPrecomputedChunk('" data-pid="');
+const completeSegmentDataEnd = dataElementQuotedEnd;
+function writeCompletedSegmentInstruction(destination, resumableState, renderState, contentSegmentID) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentCompleteSegmentFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentCompleteSegmentFunction;
+      writeChunk(destination, completeSegmentScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, completeSegmentScript1Partial);
+    }
+  } else {
+    writeChunk(destination, completeSegmentData1);
+  } // Write function arguments, which are string literals
+
+
+  writeChunk(destination, renderState.segmentPrefix);
+  const formattedID = stringToChunk(contentSegmentID.toString(16));
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    writeChunk(destination, completeSegmentScript2);
+  } else {
+    writeChunk(destination, completeSegmentData2);
+  }
+
+  writeChunk(destination, renderState.placeholderPrefix);
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    return writeChunkAndReturn(destination, completeSegmentScriptEnd);
+  } else {
+    return writeChunkAndReturn(destination, completeSegmentDataEnd);
+  }
+}
+const completeBoundaryScript1Full = stringToPrecomputedChunk(completeBoundary + '$RC("');
+const completeBoundaryScript1Partial = stringToPrecomputedChunk('$RC("');
+const completeBoundaryWithStylesScript1FullBoth = stringToPrecomputedChunk(completeBoundary + completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1FullPartial = stringToPrecomputedChunk(completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1Partial = stringToPrecomputedChunk('$RR("');
+const completeBoundaryScript2 = stringToPrecomputedChunk('","');
+const completeBoundaryScript3a = stringToPrecomputedChunk('",');
+const completeBoundaryScript3b = stringToPrecomputedChunk('"');
+const completeBoundaryScriptEnd = stringToPrecomputedChunk(')</script>');
+const completeBoundaryData1 = stringToPrecomputedChunk('<template data-rci="" data-bid="');
+const completeBoundaryWithStylesData1 = stringToPrecomputedChunk('<template data-rri="" data-bid="');
+const completeBoundaryData2 = stringToPrecomputedChunk('" data-sid="');
+const completeBoundaryData3a = stringToPrecomputedChunk('" data-sty="');
+const completeBoundaryDataEnd = dataElementQuotedEnd;
+function writeCompletedBoundaryInstruction(destination, resumableState, renderState, id, boundaryResources) {
+  let requiresStyleInsertion;
+
+  {
+    requiresStyleInsertion = renderState.stylesToHoist; // If necessary stylesheets will be flushed with this instruction.
+    // Any style tags not yet hoisted in the Document will also be hoisted.
+    // We reset this state since after this instruction executes all styles
+    // up to this point will have been hoisted
+
+    renderState.stylesToHoist = false;
+  }
+
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if (requiresStyleInsertion) {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction | SentCompleteBoundaryFunction;
+        writeChunk(destination, clonePrecomputedChunk(completeBoundaryWithStylesScript1FullBoth));
+      } else if ((resumableState.instructions & SentStyleInsertionFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction;
+        writeChunk(destination, completeBoundaryWithStylesScript1FullPartial);
+      } else {
+        writeChunk(destination, completeBoundaryWithStylesScript1Partial);
+      }
+    } else {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentCompleteBoundaryFunction;
+        writeChunk(destination, completeBoundaryScript1Full);
+      } else {
+        writeChunk(destination, completeBoundaryScript1Partial);
+      }
+    }
+  } else {
+    if (requiresStyleInsertion) {
+      writeChunk(destination, completeBoundaryWithStylesData1);
+    } else {
+      writeChunk(destination, completeBoundaryData1);
+    }
+  }
+
+  const idChunk = stringToChunk(id.toString(16));
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, idChunk); // Write function arguments, which are string and array literals
+
+  if (scriptFormat) {
+    writeChunk(destination, completeBoundaryScript2);
+  } else {
+    writeChunk(destination, completeBoundaryData2);
+  }
+
+  writeChunk(destination, renderState.segmentPrefix);
+  writeChunk(destination, idChunk);
+
+  if (requiresStyleInsertion) {
+    // Script and data writers must format this differently:
+    //  - script writer emits an array literal, whose string elements are
+    //    escaped for javascript  e.g. ["A", "B"]
+    //  - data writer emits a string literal, which is escaped as html
+    //    e.g. [&#34;A&#34;, &#34;B&#34;]
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3a); // boundaryResources encodes an array literal
+
+      writeStyleResourceDependenciesInJS(destination, boundaryResources);
+    } else {
+      writeChunk(destination, completeBoundaryData3a);
+      writeStyleResourceDependenciesInAttr(destination, boundaryResources);
+    }
+  } else {
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3b);
+    }
+  }
+
+  let writeMore;
+
+  if (scriptFormat) {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryScriptEnd);
+  } else {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryDataEnd);
+  }
+
+  return writeBootstrap(destination, renderState, resumableState) && writeMore;
+}
+const clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
+const clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
+const clientRenderScript1A = stringToPrecomputedChunk('"');
+const clientRenderErrorScriptArgInterstitial = stringToPrecomputedChunk(',');
+const clientRenderScriptEnd = stringToPrecomputedChunk(')</script>');
+const clientRenderData1 = stringToPrecomputedChunk('<template data-rxi="" data-bid="');
+const clientRenderData2 = stringToPrecomputedChunk('" data-dgst="');
+const clientRenderData3 = stringToPrecomputedChunk('" data-msg="');
+const clientRenderData4 = stringToPrecomputedChunk('" data-stck="');
+const clientRenderDataEnd = dataElementQuotedEnd;
+function writeClientRenderBoundaryInstruction(destination, resumableState, renderState, id, errorDigest, errorMessage, errorComponentStack) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentClientRenderFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentClientRenderFunction;
+      writeChunk(destination, clientRenderScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, clientRenderScript1Partial);
+    }
+  } else {
+    // <template data-rxi="" data-bid="
+    writeChunk(destination, clientRenderData1);
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+
+  if (scriptFormat) {
+    // " needs to be inserted for scripts, since ArgInterstitual does not contain
+    // leading or trailing quotes
+    writeChunk(destination, clientRenderScript1A);
+  }
+
+  if (errorDigest || errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorDigest || '')));
+    } else {
+      // " data-dgst="HTMLString
+      writeChunk(destination, clientRenderData2);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest || '')));
+    }
+  }
+
+  if (errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorMessage || '')));
+    } else {
+      // " data-msg="HTMLString
+      writeChunk(destination, clientRenderData3);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorMessage || '')));
+    }
+  }
+
+  if (errorComponentStack) {
+    // ,"JSONString"
+    if (scriptFormat) {
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorComponentStack)));
+    } else {
+      // " data-stck="HTMLString
+      writeChunk(destination, clientRenderData4);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorComponentStack)));
+    }
+  }
+
+  if (scriptFormat) {
+    // ></script>
+    return writeChunkAndReturn(destination, clientRenderScriptEnd);
+  } else {
+    // "></template>
+    return writeChunkAndReturn(destination, clientRenderDataEnd);
+  }
+}
+const regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
+
+function escapeJSStringsForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInInstructionScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const regexForJSStringsInScripts = /[&><\u2028\u2029]/g;
+
+function escapeJSObjectForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '&':
+        return '\\u0026';
+
+      case '>':
+        return '\\u003e';
+
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const lateStyleTagResourceOpen1 = stringToPrecomputedChunk('<style media="not all" data-precedence="');
+const lateStyleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const lateStyleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const lateStyleTagTemplateClose = stringToPrecomputedChunk('</style>'); // Tracks whether the boundary currently flushing is flushign style tags or has any
+// stylesheet dependencies not flushed in the Preamble.
+
+let currentlyRenderingBoundaryHasStylesToHoist = false; // Acts as a return value for the forEach execution of style tag flushing.
+
+let destinationHasCapacity = true;
+
+function flushStyleTagsLateForBoundary(styleQueue) {
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs;
+
+  let i = 0;
+
+  if (hrefs.length) {
+    writeChunk(this, lateStyleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    writeChunk(this, lateStyleTagResourceOpen2);
+
+    for (; i < hrefs.length - 1; i++) {
+      writeChunk(this, hrefs[i]);
+      writeChunk(this, spaceSeparator);
+    }
+
+    writeChunk(this, hrefs[i]);
+    writeChunk(this, lateStyleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    destinationHasCapacity = writeChunkAndReturn(this, lateStyleTagTemplateClose); // We wrote style tags for this boundary and we may need to emit a script
+    // to hoist them.
+
+    currentlyRenderingBoundaryHasStylesToHoist = true; // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function hasStylesToHoist(stylesheet) {
+  // We need to reveal boundaries with styles whenever a stylesheet it depends on is either
+  // not flushed or flushed after the preamble (shell).
+  if (stylesheet.state !== PREAMBLE) {
+    currentlyRenderingBoundaryHasStylesToHoist = true;
+    return true;
+  }
+
+  return false;
+}
+
+function writeResourcesForBoundary(destination, boundaryResources, renderState) {
+  // Reset these on each invocation, they are only safe to read in this function
+  currentlyRenderingBoundaryHasStylesToHoist = false;
+  destinationHasCapacity = true; // Flush style tags for each precedence this boundary depends on
+
+  boundaryResources.styles.forEach(flushStyleTagsLateForBoundary, destination); // Determine if this boundary has stylesheets that need to be awaited upon completion
+
+  boundaryResources.stylesheets.forEach(hasStylesToHoist);
+
+  if (currentlyRenderingBoundaryHasStylesToHoist) {
+    renderState.stylesToHoist = true;
+  }
+
+  return destinationHasCapacity;
+}
+
+function flushResource(resource) {
+  for (let i = 0; i < resource.length; i++) {
+    writeChunk(this, resource[i]);
+  }
+
+  resource.length = 0;
+}
+
+const stylesheetFlushingQueue = [];
+
+function flushStyleInPreamble(stylesheet, key, map) {
+  // We still need to encode stylesheet chunks
+  // because unlike most Hoistables and Resources we do not eagerly encode
+  // them during render. This is because if we flush late we have to send a
+  // different encoding and we don't want to encode multiple times
+  pushLinkImpl(stylesheetFlushingQueue, stylesheet.props);
+
+  for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+    writeChunk(this, stylesheetFlushingQueue[i]);
+  }
+
+  stylesheetFlushingQueue.length = 0;
+  stylesheet.state = PREAMBLE;
+}
+
+const styleTagResourceOpen1 = stringToPrecomputedChunk('<style data-precedence="');
+const styleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const spaceSeparator = stringToPrecomputedChunk(' ');
+const styleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const styleTagResourceClose = stringToPrecomputedChunk('</style>');
+
+function flushStylesInPreamble(styleQueue, precedence) {
+  const hasStylesheets = styleQueue.sheets.size > 0;
+  styleQueue.sheets.forEach(flushStyleInPreamble, this);
+  styleQueue.sheets.clear();
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs; // If we don't emit any stylesheets at this precedence we still need to maintain the precedence
+  // order so even if there are no rules for style tags at this precedence we emit an empty style
+  // tag with the data-precedence attribute
+
+  if (!hasStylesheets || hrefs.length) {
+    writeChunk(this, styleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    let i = 0;
+
+    if (hrefs.length) {
+      writeChunk(this, styleTagResourceOpen2);
+
+      for (; i < hrefs.length - 1; i++) {
+        writeChunk(this, hrefs[i]);
+        writeChunk(this, spaceSeparator);
+      }
+
+      writeChunk(this, hrefs[i]);
+    }
+
+    writeChunk(this, styleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    writeChunk(this, styleTagResourceClose); // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function preloadLateStyle(stylesheet) {
+  if (stylesheet.state === PENDING$1) {
+    stylesheet.state = PRELOADED;
+    const preloadProps = preloadAsStylePropsFromProps(stylesheet.props.href, stylesheet.props);
+    pushLinkImpl(stylesheetFlushingQueue, preloadProps);
+
+    for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+      writeChunk(this, stylesheetFlushingQueue[i]);
+    }
+
+    stylesheetFlushingQueue.length = 0;
+  }
+}
+
+function preloadLateStyles(styleQueue) {
+  styleQueue.sheets.forEach(preloadLateStyle, this);
+  styleQueue.sheets.clear();
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+
+function writePreamble(destination, resumableState, renderState, willFlushAllSegments) {
+  // This function must be called exactly once on every request
+  if (!willFlushAllSegments && renderState.externalRuntimeScript) {
+    // If the root segment is incomplete due to suspended tasks
+    // (e.g. willFlushAllSegments = false) and we are using data
+    // streaming format, ensure the external runtime is sent.
+    // (User code could choose to send this even earlier by calling
+    //  preinit(...), if they know they will suspend).
+    const _renderState$external = renderState.externalRuntimeScript,
+          src = _renderState$external.src,
+          chunks = _renderState$external.chunks;
+    internalPreinitScript(resumableState, renderState, src, chunks);
+  }
+
+  const htmlChunks = renderState.htmlChunks;
+  const headChunks = renderState.headChunks;
+  let i = 0; // Emit open tags before Hoistables and Resources
+
+  if (htmlChunks) {
+    // We have an <html> to emit as part of the preamble
+    for (i = 0; i < htmlChunks.length; i++) {
+      writeChunk(destination, htmlChunks[i]);
+    }
+
+    if (headChunks) {
+      for (i = 0; i < headChunks.length; i++) {
+        writeChunk(destination, headChunks[i]);
+      }
+    } else {
+      // We did not render a head but we emitted an <html> so we emit one now
+      writeChunk(destination, startChunkForTag('head'));
+      writeChunk(destination, endOfStartTag);
+    }
+  } else if (headChunks) {
+    // We do not have an <html> but we do have a <head>
+    for (i = 0; i < headChunks.length; i++) {
+      writeChunk(destination, headChunks[i]);
+    }
+  } // Emit high priority Hoistables
+
+
+  const charsetChunks = renderState.charsetChunks;
+
+  for (i = 0; i < charsetChunks.length; i++) {
+    writeChunk(destination, charsetChunks[i]);
+  }
+
+  charsetChunks.length = 0; // emit preconnect resources
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Flush unblocked stylesheets by precedence
+
+  renderState.styles.forEach(flushStylesInPreamble, destination);
+  const importMapChunks = renderState.importMapChunks;
+
+  for (i = 0; i < importMapChunks.length; i++) {
+    writeChunk(destination, importMapChunks[i]);
+  }
+
+  importMapChunks.length = 0;
+  renderState.bootstrapScripts.forEach(flushResource, destination);
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0; // Flush closing head if necessary
+
+  if (htmlChunks && headChunks === null) {
+    // We have an <html> rendered but no <head> rendered. We however inserted
+    // a <head> up above so we need to emit the </head> now. This is safe because
+    // if the main content contained the </head> it would also have provided a
+    // <head>. This means that all the content inside <html> is either <body> or
+    // invalid HTML
+    writeChunk(destination, endChunkForTag('head'));
+  }
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+function writeHoistables(destination, resumableState, renderState) {
+  let i = 0; // Emit high priority Hoistables
+  // We omit charsetChunks because we have already sent the shell and if it wasn't
+  // already sent it is too late now.
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Preload any stylesheets. these will emit in a render instruction that follows this
+  // but we want to kick off preloading as soon as possible
+
+  renderState.styles.forEach(preloadLateStyles, destination); // We only hoist importmaps that are configured through createResponse and that will
+  // always flush in the preamble. Generally we don't expect people to render them as
+  // tags when using React but if you do they are going to be treated like regular inline
+  // scripts and flush after other hoistables which is problematic
+  // bootstrap scripts should flush above script priority but these can only flush in the preamble
+  // so we elide the code here for performance
+
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0;
+}
+function writePostamble(destination, resumableState) {
+  if (resumableState.hasBody) {
+    writeChunk(destination, endChunkForTag('body'));
+  }
+
+  if (resumableState.hasHtml) {
+    writeChunk(destination, endChunkForTag('html'));
+  }
+}
+const arrayFirstOpenBracket = stringToPrecomputedChunk('[');
+const arraySubsequentOpenBracket = stringToPrecomputedChunk(',[');
+const arrayInterstitial = stringToPrecomputedChunk(',');
+const arrayCloseBracket = stringToPrecomputedChunk(']'); // This function writes a 2D array of strings to be embedded in javascript.
+// E.g.
+//  [["JS_escaped_string1", "JS_escaped_string2"]]
+
+function writeStyleResourceDependenciesInJS(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInJS(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInJS(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInJS(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+}
+
+function writeStyleResourceDependencyInJS(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedPrecedence)));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(399, 'link'));
+
+        default:
+          writeStyleResourceAttributeInJS(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInJS(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeName)));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeValue)));
+} // This function writes a 2D array of strings to be embedded in an attribute
+// value and read with JSON.parse in ReactDOMServerExternalRuntime.js
+// E.g.
+//  [[&quot;JSON_escaped_string1&quot;, &quot;JSON_escaped_string2&quot;]]
+
+
+function writeStyleResourceDependenciesInAttr(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInAttr(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInAttr(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInAttr(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+}
+
+function writeStyleResourceDependencyInAttr(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedPrecedence))));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw Error(formatProdErrorMessage(399, 'link'));
+
+        default:
+          writeStyleResourceAttributeInAttr(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInAttr(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeName))));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeValue))));
+}
+/**
+ * Resources
+ */
+
+
+const PENDING$1 = 0;
+const PRELOADED = 1;
+const PREAMBLE = 2;
+const LATE = 3;
+function createBoundaryResources() {
+  return {
+    styles: new Set(),
+    stylesheets: new Set()
+  };
+}
+function setCurrentlyRenderingBoundaryResourcesTarget(renderState, boundaryResources) {
+  renderState.boundaryResources = boundaryResources;
+}
+
+function getResourceKey(href) {
+  return href;
+}
+
+function getImageResourceKey(href, imageSrcSet, imageSizes) {
+  if (imageSrcSet) {
+    return imageSrcSet + '\n' + (imageSizes || '');
+  }
+
+  return href;
+}
+
+function prefetchDNS(href) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const key = getResourceKey(href);
+
+    if (!resumableState.dnsResources.hasOwnProperty(key)) {
+      resumableState.dnsResources[key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPrefetchDNSAsHeader(href), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this as resettable in case we are prerendering and postpone in the Shell
+        renderState.resets.dns[key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        // Encode as element
+        const resource = [];
+        pushLinkImpl(resource, {
+          href,
+          rel: 'dns-prefetch'
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preconnect(href, crossOrigin) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const bucket = crossOrigin === 'use-credentials' ? 'credentials' : typeof crossOrigin === 'string' ? 'anonymous' : 'default';
+    const key = getResourceKey(href);
+
+    if (!resumableState.connectResources[bucket].hasOwnProperty(key)) {
+      resumableState.connectResources[bucket][key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPreconnectAsHeader(href, crossOrigin), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this in resettableState in case we are prerending and postpone in the Shell
+        renderState.resets.connect[bucket][key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        const resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preconnect',
+          href,
+          crossOrigin
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preload(href, as, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (as && href) {
+    switch (as) {
+      case 'image':
+        {
+          let imageSrcSet, imageSizes, fetchPriority;
+
+          if (options) {
+            imageSrcSet = options.imageSrcSet;
+            imageSizes = options.imageSizes;
+            fetchPriority = options.fetchPriority;
+          }
+
+          const key = getImageResourceKey(href, imageSrcSet, imageSizes);
+
+          if (resumableState.imageResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && fetchPriority === 'high' && ( // Compute the header since we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit a preload as a header so we
+            // track this to make sure we don't reset it.
+            renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+            if (headers.highImagePreloads) {
+              headers.highImagePreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.highImagePreloads += header;
+          } else {
+            // If we don't have headers to write to we have to encode as elements to flush in the head
+            // When we have imageSrcSet the browser probably cannot load the right version from headers
+            // (this should be verified by testing). For now we assume these need to go in the head
+            // as elements even if headers are available.
+            const resource = [];
+            pushLinkImpl(resource, assign({
+              rel: 'preload',
+              // There is a bug in Safari where imageSrcSet is not respected on preload links
+              // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+              // This harms older browers that do not support imageSrcSet by making their preloads not work
+              // but this population is shrinking fast and is already small so we accept this tradeoff.
+              href: imageSrcSet ? undefined : href,
+              as
+            }, options));
+
+            if (fetchPriority === 'high') {
+              renderState.highImagePreloads.add(resource);
+            } else {
+              renderState.bulkPreloads.add(resource); // Stash the resource in case we need to promote it to higher priority
+              // when an img tag is rendered
+
+              renderState.preloads.images.set(key, resource);
+            }
+          }
+
+          break;
+        }
+
+      case 'style':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.styleResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.styleResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.stylesheets.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          break;
+        }
+
+      case 'script':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.scriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          renderState.preloads.scripts.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.scriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          break;
+        }
+
+      default:
+        {
+          const key = getResourceKey(href);
+          const hasAsType = resumableState.unknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.unknownResources[as] = resources;
+          }
+
+          resources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && as === 'font' && ( // We compute the header here because we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit this preload so we
+            // track it here to prevent it from being reset.
+            renderState.resets.font[key] = PRELOAD_NO_CREDS;
+
+            if (headers.fontPreloads) {
+              headers.fontPreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.fontPreloads += header;
+          } else {
+            // We either don't have headers or we are preloading something that does
+            // not warrant elevated priority so we encode as an element.
+            const resource = [];
+
+            const props = assign({
+              rel: 'preload',
+              href,
+              as
+            }, options);
+
+            pushLinkImpl(resource, props);
+
+            switch (as) {
+              case 'font':
+                renderState.fontPreloads.add(resource);
+                break;
+              // intentional fall through
+
+              default:
+                renderState.bulkPreloads.add(resource);
+            }
+          }
+        }
+    } // If we got this far we created a new resource
+
+
+    flushResources(request);
+  }
+}
+
+function preloadModule(href, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    const key = getResourceKey(href);
+    const as = options && typeof options.as === 'string' ? options.as : 'script';
+    let resource;
+
+    switch (as) {
+      case 'script':
+        {
+          if (resumableState.moduleScriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resource = [];
+          resumableState.moduleScriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.moduleScripts.set(key, resource);
+          break;
+        }
+
+      default:
+        {
+          const hasAsType = resumableState.moduleUnknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.moduleUnknownResources[as] = resources;
+          }
+
+          resource = [];
+          resources[key] = PRELOAD_NO_CREDS;
+        }
+    }
+
+    pushLinkImpl(resource, assign({
+      rel: 'modulepreload',
+      href
+    }, options));
+    renderState.bulkPreloads.add(resource); // If we got this far we created a new resource
+
+    flushResources(request);
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    precedence = precedence || 'default';
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+      // to create a StyleQueue
+
+      if (!styleQueue) {
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      }
+
+      const resource = {
+        state: PENDING$1,
+        props: assign({
+          rel: 'stylesheet',
+          href,
+          'data-precedence': precedence
+        }, options)
+      };
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(resource.props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.stylesheets.get(key);
+
+        if (preloadResource && preloadResource.length > 0) {
+          // The Preload for this resource was created in this render pass and has not flushed yet so
+          // we need to clear it to avoid it flushing.
+          preloadResource.length = 0;
+        } else {
+          // Either the preload resource from this render already flushed in this render pass
+          // or the preload flushed in a prior pass (prerender). In either case we need to mark
+          // this resource as already having been preloaded.
+          resource.state = PRELOADED;
+        }
+      } // We add the newly created resource to our StyleQueue and if necessary
+      // track the resource with the currently rendering boundary
+
+
+      styleQueue.sheets.set(key, resource); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+  }
+}
+
+function preinitScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.scriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.scriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.scriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.scripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+}
+
+function preinitModuleScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.moduleScriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.moduleScriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.moduleScriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        type: 'module',
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.moduleScripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+} // This function is only safe to call at Request start time since it assumes
+// that each module has not already been preloaded. If we find a need to preload
+// scripts at any other point in time we will need to check whether the preload
+// already exists and not assume it
+
+
+function preloadBootstrapScriptOrModule(resumableState, renderState, href, props) {
+
+  const key = getResourceKey(href);
+  // used to preinit the resource. If a script can be preinited then it shouldn't
+  // be a bootstrap script/module and if it is a bootstrap script/module then it
+  // must not be safe to emit early. To avoid possibly allowing for preinits of
+  // bootstrap scripts/modules we occlude these keys.
+
+
+  resumableState.scriptResources[key] = EXISTS;
+  resumableState.moduleScriptResources[key] = EXISTS;
+  const resource = [];
+  pushLinkImpl(resource, props);
+  renderState.bootstrapScripts.add(resource);
+}
+
+function internalPreinitScript(resumableState, renderState, src, chunks) {
+  const key = getResourceKey(src);
+
+  if (!resumableState.scriptResources.hasOwnProperty(key)) {
+    const resource = chunks;
+    resumableState.scriptResources[key] = EXISTS;
+    renderState.scripts.add(resource);
+  }
+
+  return;
+}
+
+function preloadAsStylePropsFromProps(href, props) {
+  return {
+    rel: 'preload',
+    as: 'style',
+    href: href,
+    crossOrigin: props.crossOrigin,
+    fetchPriority: props.fetchPriority,
+    integrity: props.integrity,
+    media: props.media,
+    hrefLang: props.hrefLang,
+    referrerPolicy: props.referrerPolicy
+  };
+}
+
+function stylesheetPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    'data-precedence': rawProps.precedence,
+    precedence: null
+  });
+}
+
+function adoptPreloadCredentials(target, preloadState) {
+  if (target.crossOrigin == null) target.crossOrigin = preloadState[0];
+  if (target.integrity == null) target.integrity = preloadState[1];
+}
+
+function getPrefetchDNSAsHeader(href) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  return "<" + escapedHref + ">; rel=dns-prefetch";
+}
+
+function getPreconnectAsHeader(href, crossOrigin) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  let value = "<" + escapedHref + ">; rel=preconnect";
+
+  if (typeof crossOrigin === 'string') {
+    const escapedCrossOrigin = escapeStringForLinkHeaderQuotedParamValueContext(crossOrigin);
+    value += "; crossorigin=\"" + escapedCrossOrigin + "\"";
+  }
+
+  return value;
+}
+
+function getPreloadAsHeader(href, as, params) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  const escapedAs = escapeStringForLinkHeaderQuotedParamValueContext(as);
+  let value = "<" + escapedHref + ">; rel=preload; as=\"" + escapedAs + "\"";
+
+  for (const paramName in params) {
+    if (hasOwnProperty.call(params, paramName)) {
+      const paramValue = params[paramName];
+
+      if (typeof paramValue === 'string') {
+        value += "; " + paramName.toLowerCase() + "=\"" + escapeStringForLinkHeaderQuotedParamValueContext(paramValue) + "\"";
+      }
+    }
+  }
+
+  return value;
+}
+
+function getStylesheetPreloadAsHeader(stylesheet) {
+  const props = stylesheet.props;
+  const preloadOptions = {
+    crossOrigin: props.crossOrigin,
+    integrity: props.integrity,
+    nonce: props.nonce,
+    type: props.type,
+    fetchPriority: props.fetchPriority,
+    referrerPolicy: props.referrerPolicy,
+    media: props.media
+  };
+  return getPreloadAsHeader(props.href, 'style', preloadOptions);
+} // This escaping function is only safe to use for href values being written into
+// a "Link" header in between `<` and `>` characters. The primary concern with the href is
+// to escape the bounding characters as well as new lines. This is unsafe to use in any other
+// context
+
+
+const regexForHrefInLinkHeaderURLContext = /[<>\r\n]/g;
+
+function escapeHrefForLinkHeaderURLContext(hrefInput) {
+
+  const coercedHref = '' + hrefInput;
+  return coercedHref.replace(regexForHrefInLinkHeaderURLContext, escapeHrefForLinkHeaderURLContextReplacer);
+}
+
+function escapeHrefForLinkHeaderURLContextReplacer(match) {
+  switch (match) {
+    case '<':
+      return '%3C';
+
+    case '>':
+      return '%3E';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeLinkHrefForHeaderContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+} // This escaping function is only safe to use for quoted param values in an HTTP header.
+// It is unsafe to use for any value not inside quote marks in parater value position.
+
+
+const regexForLinkHeaderQuotedParamValueContext = /["';,\r\n]/g;
+
+function escapeStringForLinkHeaderQuotedParamValueContext(value, name) {
+
+  const coerced = '' + value;
+  return coerced.replace(regexForLinkHeaderQuotedParamValueContext, escapeStringForLinkHeaderQuotedParamValueContextReplacer);
+}
+
+function escapeStringForLinkHeaderQuotedParamValueContextReplacer(match) {
+  switch (match) {
+    case '"':
+      return '%22';
+
+    case "'":
+      return '%27';
+
+    case ';':
+      return '%3B';
+
+    case ',':
+      return '%2C';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeStringForLinkHeaderQuotedParamValueContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+}
+
+function hoistStyleQueueDependency(styleQueue) {
+  this.styles.add(styleQueue);
+}
+
+function hoistStylesheetDependency(stylesheet) {
+  this.stylesheets.add(stylesheet);
+}
+
+function hoistResources(renderState, source) {
+  const currentBoundaryResources = renderState.boundaryResources;
+
+  if (currentBoundaryResources) {
+    source.styles.forEach(hoistStyleQueueDependency, currentBoundaryResources);
+    source.stylesheets.forEach(hoistStylesheetDependency, currentBoundaryResources);
+  }
+} // This function is called at various times depending on whether we are rendering
+// or prerendering. In this implementation we only actually emit headers once and
+// subsequent calls are ignored. We track whether the request has a completed shell
+// to determine whether we will follow headers with a flush including stylesheets.
+// In the context of prerrender we don't have a completed shell when the request finishes
+// with a postpone in the shell. In the context of a render we don't have a completed shell
+// if this is called before the shell finishes rendering which usually will happen anytime
+// anything suspends in the shell.
+
+function emitEarlyPreloads(renderState, resumableState, shellComplete) {
+  const onHeaders = renderState.onHeaders;
+
+  if (onHeaders) {
+    const headers = renderState.headers;
+
+    if (headers) {
+      let linkHeader = headers.preconnects;
+
+      if (headers.fontPreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.fontPreloads;
+      }
+
+      if (headers.highImagePreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.highImagePreloads;
+      }
+
+      if (!shellComplete) {
+        // We use raw iterators because we want to be able to halt iteration
+        // We could refactor renderState to store these dually in arrays to
+        // make this more efficient at the cost of additional memory and
+        // write overhead. However this code only runs once per request so
+        // for now I consider this sufficient.
+        const queueIter = renderState.styles.values();
+
+        outer: for (let queueStep = queueIter.next(); headers.remainingCapacity > 0 && !queueStep.done; queueStep = queueIter.next()) {
+          const sheets = queueStep.value.sheets;
+          const sheetIter = sheets.values();
+
+          for (let sheetStep = sheetIter.next(); headers.remainingCapacity > 0 && !sheetStep.done; sheetStep = sheetIter.next()) {
+            const sheet = sheetStep.value;
+            const props = sheet.props;
+            const key = getResourceKey(props.href);
+            const header = getStylesheetPreloadAsHeader(sheet); // We mutate the capacity b/c we don't want to keep checking if later headers will fit.
+            // This means that a particularly long header might close out the header queue where later
+            // headers could still fit. We could in the future alter the behavior here based on prerender vs render
+            // since during prerender we aren't as concerned with pure runtime performance.
+
+            if ((headers.remainingCapacity -= header.length) >= 2) {
+              renderState.resets.style[key] = PRELOAD_NO_CREDS;
+
+              if (linkHeader) {
+                linkHeader += ', ';
+              }
+
+              linkHeader += header; // We already track that the resource exists in resumableState however
+              // if the resumableState resets because we postponed in the shell
+              // which is what is happening in this branch if we are prerendering
+              // then we will end up resetting the resumableState. When it resets we
+              // want to record the fact that this stylesheet was already preloaded
+
+              renderState.resets.style[key] = typeof props.crossOrigin === 'string' || typeof props.integrity === 'string' ? [props.crossOrigin, props.integrity] : PRELOAD_NO_CREDS;
+            } else {
+              break outer;
+            }
+          }
+        }
+      }
+
+      if (linkHeader) {
+        onHeaders({
+          Link: linkHeader
+        });
+      } else {
+        // We still call this with no headers because a user may be using it as a signal that
+        // it React will not provide any headers
+        onHeaders({});
+      }
+
+      renderState.headers = null;
+      return;
+    }
+  }
+}
+const NotPendingTransition = NotPending;
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+const REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_CONTEXT_TYPE = Symbol.for('react.context');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SCOPE_TYPE = Symbol.for('react.scope');
+const REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');
+const REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+const REACT_LEGACY_HIDDEN_TYPE = Symbol.for('react.legacy_hidden');
+const REACT_CACHE_TYPE = Symbol.for('react.cache');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+function getWrappedName(outerType, innerType, wrapperName) {
+  const displayName = outerType.displayName;
+
+  if (displayName) {
+    return displayName;
+  }
+
+  const functionName = innerType.displayName || innerType.name || '';
+  return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
+} // Keep in sync with react-reconciler/getComponentNameFromFiber
+
+
+function getContextName(type) {
+  return type.displayName || 'Context';
+} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+
+function getComponentNameFromType(type) {
+  if (type == null) {
+    // Host root, text node or just invalid type.
+    return null;
+  }
+
+  if (typeof type === 'function') {
+    return type.displayName || type.name || null;
+  }
+
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_FRAGMENT_TYPE:
+      return 'Fragment';
+
+    case REACT_PORTAL_TYPE:
+      return 'Portal';
+
+    case REACT_PROFILER_TYPE:
+      return 'Profiler';
+
+    case REACT_STRICT_MODE_TYPE:
+      return 'StrictMode';
+
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+
+    case REACT_CACHE_TYPE:
+      {
+        return 'Cache';
+      }
+
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        const context = type;
+        return getContextName(context) + '.Consumer';
+
+      case REACT_PROVIDER_TYPE:
+        const provider = type;
+        return getContextName(provider._context) + '.Provider';
+
+      case REACT_FORWARD_REF_TYPE:
+        return getWrappedName(type, type.render, 'ForwardRef');
+
+      case REACT_MEMO_TYPE:
+        const outerName = type.displayName || null;
+
+        if (outerName !== null) {
+          return outerName;
+        }
+
+        return getComponentNameFromType(type.type) || 'Memo';
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            return getComponentNameFromType(init(payload));
+          } catch (x) {
+            return null;
+          }
+        }
+
+    }
+  }
+
+  return null;
+}
+
+const emptyContextObject = {};
+
+function getMaskedContext(type, unmaskedContext) {
+  {
+    const contextTypes = type.contextTypes;
+
+    if (!contextTypes) {
+      return emptyContextObject;
+    }
+
+    const context = {};
+
+    for (const key in contextTypes) {
+      context[key] = unmaskedContext[key];
+    }
+
+    return context;
+  }
+}
+function processChildContext(instance, type, parentContext, childContextTypes) {
+  {
+    // TODO (bvaughn) Replace this behavior with an invariant() in the future.
+    // It has only been added in Fiber to match the (unintentional) behavior in Stack.
+    if (typeof instance.getChildContext !== 'function') {
+
+      return parentContext;
+    }
+
+    const childContext = instance.getChildContext();
+
+    for (const contextKey in childContext) {
+      if (!(contextKey in childContextTypes)) {
+        throw Error(formatProdErrorMessage(108, getComponentNameFromType(type) || 'Unknown', contextKey));
+      }
+    }
+
+    return assign({}, parentContext, childContext);
+  }
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw Error(formatProdErrorMessage(401));
+      }
+    } else {
+      if (parentNext === null) {
+        throw Error(formatProdErrorMessage(401));
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext);
+    } // On the way back, we push the new ones that weren't common.
+
+
+    pushNode(next);
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw Error(formatProdErrorMessage(402));
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw Error(formatProdErrorMessage(402));
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function pushProvider(context, nextValue) {
+  let prevValue;
+
+  {
+    prevValue = context._currentValue;
+    context._currentValue = nextValue;
+  }
+
+  const prevNode = currentActiveSnapshot;
+  const newNode = {
+    parent: prevNode,
+    depth: prevNode === null ? 0 : prevNode.depth + 1,
+    context: context,
+    parentValue: prevValue,
+    value: nextValue
+  };
+  currentActiveSnapshot = newNode;
+  return newNode;
+}
+function popProvider(context) {
+  const prevSnapshot = currentActiveSnapshot;
+
+  if (prevSnapshot === null) {
+    throw Error(formatProdErrorMessage(403));
+  }
+
+  {
+    const value = prevSnapshot.parentValue;
+
+    if (value === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      prevSnapshot.context._currentValue = prevSnapshot.context._defaultValue;
+    } else {
+      prevSnapshot.context._currentValue = value;
+    }
+  }
+
+  return currentActiveSnapshot = prevSnapshot.parent;
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+/**
+ * `ReactInstanceMap` maintains a mapping from a public facing stateful
+ * instance (key) and the internal representation (value). This allows public
+ * methods to accept the user facing instance as an argument and map them back
+ * to internal methods.
+ *
+ * Note that this module is currently shared and assumed to be stateless.
+ * If this becomes an actual Map, that will break.
+ */
+function get(key) {
+  return key._reactInternals;
+}
+function set(key, value) {
+  key._reactInternals = value;
+}
+
+const classComponentUpdater = {
+  isMounted(inst) {
+    return false;
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueSetState(inst, payload, callback) {
+    const internals = get(inst);
+
+    if (internals.queue === null) ; else {
+      internals.queue.push(payload);
+    }
+  },
+
+  enqueueReplaceState(inst, payload, callback) {
+    const internals = get(inst);
+    internals.replace = true;
+    internals.queue = [payload];
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueForceUpdate(inst, callback) {
+  }
+
+};
+
+function applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, prevState, nextProps) {
+  const partialState = getDerivedStateFromProps(nextProps, prevState);
+
+
+  const newState = partialState === null || partialState === undefined ? prevState : assign({}, prevState, partialState);
+  return newState;
+}
+
+function constructClassInstance(ctor, props, maskedLegacyContext) {
+  let context = emptyContextObject;
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    context = readContext$1(contextType);
+  } else {
+    context = maskedLegacyContext;
+  }
+
+  const instance = new ctor(props, context);
+
+  return instance;
+}
+
+function callComponentWillMount(type, instance) {
+  const oldState = instance.state;
+
+  if (typeof instance.componentWillMount === 'function') {
+
+    instance.componentWillMount();
+  }
+
+  if (typeof instance.UNSAFE_componentWillMount === 'function') {
+    instance.UNSAFE_componentWillMount();
+  }
+
+  if (oldState !== instance.state) {
+
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+}
+
+function processUpdateQueue(internalInstance, inst, props, maskedLegacyContext) {
+  if (internalInstance.queue !== null && internalInstance.queue.length > 0) {
+    const oldQueue = internalInstance.queue;
+    const oldReplace = internalInstance.replace;
+    internalInstance.queue = null;
+    internalInstance.replace = false;
+
+    if (oldReplace && oldQueue.length === 1) {
+      inst.state = oldQueue[0];
+    } else {
+      let nextState = oldReplace ? oldQueue[0] : inst.state;
+      let dontMutate = true;
+
+      for (let i = oldReplace ? 1 : 0; i < oldQueue.length; i++) {
+        const partial = oldQueue[i];
+        const partialState = typeof partial === 'function' ? partial.call(inst, nextState, props, maskedLegacyContext) : partial;
+
+        if (partialState != null) {
+          if (dontMutate) {
+            dontMutate = false;
+            nextState = assign({}, nextState, partialState);
+          } else {
+            assign(nextState, partialState);
+          }
+        }
+      }
+
+      inst.state = nextState;
+    }
+  } else {
+    internalInstance.queue = null;
+  }
+} // Invokes the mount life-cycles on a previously never rendered instance.
+
+
+function mountClassInstance(instance, ctor, newProps, maskedLegacyContext) {
+
+  const initialState = instance.state !== undefined ? instance.state : null;
+  instance.updater = classComponentUpdater;
+  instance.props = newProps;
+  instance.state = initialState; // We don't bother initializing the refs object on the server, since we're not going to resolve them anyway.
+  // The internal instance will be used to manage updates that happen during this mount.
+
+  const internalInstance = {
+    queue: [],
+    replace: false
+  };
+  set(instance, internalInstance);
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    instance.context = readContext$1(contextType);
+  } else {
+    instance.context = maskedLegacyContext;
+  }
+
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    instance.state = applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, initialState, newProps);
+  } // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+
+  if (typeof ctor.getDerivedStateFromProps !== 'function' && typeof instance.getSnapshotBeforeUpdate !== 'function' && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
+    callComponentWillMount(ctor, instance); // If we had additional state updates during this life-cycle, let's
+    // process them now.
+
+    processUpdateQueue(internalInstance, instance, newProps, maskedLegacyContext);
+  }
+}
+
+// Ids are base 32 strings whose binary representation corresponds to the
+// position of a node in a tree.
+// Every time the tree forks into multiple children, we add additional bits to
+// the left of the sequence that represent the position of the child within the
+// current level of children.
+//
+//      00101       00010001011010101
+//      ╰─┬─╯       ╰───────┬───────╯
+//   Fork 5 of 20       Parent id
+//
+// The leading 0s are important. In the above example, you only need 3 bits to
+// represent slot 5. However, you need 5 bits to represent all the forks at
+// the current level, so we must account for the empty bits at the end.
+//
+// For this same reason, slots are 1-indexed instead of 0-indexed. Otherwise,
+// the zeroth id at a level would be indistinguishable from its parent.
+//
+// If a node has only one child, and does not materialize an id (i.e. does not
+// contain a useId hook), then we don't need to allocate any space in the
+// sequence. It's treated as a transparent indirection. For example, these two
+// trees produce the same ids:
+//
+// <>                          <>
+//   <Indirection>               <A />
+//     <A />                     <B />
+//   </Indirection>            </>
+//   <B />
+// </>
+//
+// However, we cannot skip any node that materializes an id. Otherwise, a parent
+// id that does not fork would be indistinguishable from its child id. For
+// example, this tree does not fork, but the parent and child must have
+// different ids.
+//
+// <Parent>
+//   <Child />
+// </Parent>
+//
+// To handle this scenario, every time we materialize an id, we allocate a
+// new level with a single slot. You can think of this as a fork with only one
+// prong, or an array of children with length 1.
+//
+// It's possible for the size of the sequence to exceed 32 bits, the max
+// size for bitwise operations. When this happens, we make more room by
+// converting the right part of the id to a string and storing it in an overflow
+// variable. We use a base 32 string representation, because 32 is the largest
+// power of 2 that is supported by toString(). We want the base to be large so
+// that the resulting ids are compact, and we want the base to be a power of 2
+// because every log2(base) bits corresponds to a single character, i.e. every
+// log2(32) = 5 bits. That means we can lop bits off the end 5 at a time without
+// affecting the final result.
+const emptyTreeContext = {
+  id: 1,
+  overflow: ''
+};
+function getTreeId(context) {
+  const overflow = context.overflow;
+  const idWithLeadingBit = context.id;
+  const id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
+  return id.toString(32) + overflow;
+}
+function pushTreeContext(baseContext, totalChildren, index) {
+  const baseIdWithLeadingBit = baseContext.id;
+  const baseOverflow = baseContext.overflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
+  // of the id; we use it to account for leading 0s.
+
+  const baseLength = getBitLength(baseIdWithLeadingBit) - 1;
+  const baseId = baseIdWithLeadingBit & ~(1 << baseLength);
+  const slot = index + 1;
+  const length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
+  // consideration the leading 1 we use to mark the end of the sequence.
+
+  if (length > 30) {
+    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
+    // This branch assumes the length of the base id is greater than 5; it won't
+    // work for smaller ids, because you need 5 bits per character.
+    //
+    // We encode the id in multiple steps: first the base id, then the
+    // remaining digits.
+    //
+    // Each 5 bit sequence corresponds to a single base 32 character. So for
+    // example, if the current id is 23 bits long, we can convert 20 of those
+    // bits into a string of 4 characters, with 3 bits left over.
+    //
+    // First calculate how many bits in the base id represent a complete
+    // sequence of characters.
+    const numberOfOverflowBits = baseLength - baseLength % 5; // Then create a bitmask that selects only those bits.
+
+    const newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
+
+    const newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
+
+    const restOfBaseId = baseId >> numberOfOverflowBits;
+    const restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
+    // we made more room, this time it won't overflow.
+
+    const restOfLength = getBitLength(totalChildren) + restOfBaseLength;
+    const restOfNewBits = slot << restOfBaseLength;
+    const id = restOfNewBits | restOfBaseId;
+    const overflow = newOverflow + baseOverflow;
+    return {
+      id: 1 << restOfLength | id,
+      overflow
+    };
+  } else {
+    // Normal path
+    const newBits = slot << baseLength;
+    const id = newBits | baseId;
+    const overflow = baseOverflow;
+    return {
+      id: 1 << length | id,
+      overflow
+    };
+  }
+}
+
+function getBitLength(number) {
+  return 32 - clz32(number);
+}
+
+function getLeadingBit(id) {
+  return 1 << getBitLength(id) - 1;
+} // TODO: Math.clz32 is supported in Node 12+. Maybe we can drop the fallback.
+
+
+const 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
+
+const log = Math.log;
+const LN2 = Math.LN2;
+
+function clz32Fallback(x) {
+  const asUint = x >>> 0;
+
+  if (asUint === 0) {
+    return 32;
+  }
+
+  return 31 - (log(asUint) / LN2 | 0) | 0;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFlightWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = Error(formatProdErrorMessage(460));
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop$2() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop$2, noop$2);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw Error(formatProdErrorMessage(459));
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+
+const objectIs = // $FlowFixMe[method-unbinding]
+typeof Object.is === 'function' ? Object.is : is;
+
+let currentlyRenderingComponent = null;
+let currentlyRenderingTask = null;
+let currentlyRenderingRequest = null;
+let currentlyRenderingKeyPath = null;
+let firstWorkInProgressHook = null;
+let workInProgressHook = null; // Whether the work-in-progress hook is a re-rendered hook
+
+let isReRender = false; // Whether an update was scheduled during the currently executing render pass.
+
+let didScheduleRenderPhaseUpdate = false; // Counts the number of useId hooks in this component
+
+let localIdCounter = 0; // Chunks that should be pushed to the stream once the component
+// finishes rendering.
+// Counts the number of useFormState calls in this component
+
+let formStateCounter = 0; // The index of the useFormState hook that matches the one passed in at the
+// root during an MPA navigation, if any.
+
+let formStateMatchingIndex = -1; // Counts the number of use(thenable) calls in this component
+
+let thenableIndexCounter = 0;
+let thenableState = null; // Lazily created map of render-phase updates
+
+let renderPhaseUpdates = null; // Counter to prevent infinite loops.
+
+let numberOfReRenders = 0;
+const RE_RENDER_LIMIT = 25;
+
+function resolveCurrentlyRenderingComponent() {
+  if (currentlyRenderingComponent === null) {
+    throw Error(formatProdErrorMessage(321));
+  }
+
+  return currentlyRenderingComponent;
+}
+
+function areHookInputsEqual(nextDeps, prevDeps) {
+  if (prevDeps === null) {
+
+    return false;
+  }
+
+
+  for (let i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    if (objectIs(nextDeps[i], prevDeps[i])) {
+      continue;
+    }
+
+    return false;
+  }
+
+  return true;
+}
+
+function createHook() {
+  if (numberOfReRenders > 0) {
+    throw Error(formatProdErrorMessage(312));
+  }
+
+  return {
+    memoizedState: null,
+    queue: null,
+    next: null
+  };
+}
+
+function createWorkInProgressHook() {
+  if (workInProgressHook === null) {
+    // This is the first hook in the list
+    if (firstWorkInProgressHook === null) {
+      isReRender = false;
+      firstWorkInProgressHook = workInProgressHook = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = firstWorkInProgressHook;
+    }
+  } else {
+    if (workInProgressHook.next === null) {
+      isReRender = false; // Append to the end of the list
+
+      workInProgressHook = workInProgressHook.next = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = workInProgressHook.next;
+    }
+  }
+
+  return workInProgressHook;
+}
+
+function prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState) {
+  currentlyRenderingComponent = componentIdentity;
+  currentlyRenderingTask = task;
+  currentlyRenderingRequest = request;
+  currentlyRenderingKeyPath = keyPath;
+  // didScheduleRenderPhaseUpdate = false;
+  // firstWorkInProgressHook = null;
+  // numberOfReRenders = 0;
+  // renderPhaseUpdates = null;
+  // workInProgressHook = null;
+
+
+  localIdCounter = 0;
+  formStateCounter = 0;
+  formStateMatchingIndex = -1;
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function finishHooks(Component, props, children, refOrContext) {
+  // This must be called after every function component to prevent hooks from
+  // being used in classes.
+  while (didScheduleRenderPhaseUpdate) {
+    // Updates were scheduled during the render phase. They are stored in
+    // the `renderPhaseUpdates` map. Call the component again, reusing the
+    // work-in-progress hooks and applying the additional updates on top. Keep
+    // restarting until no more updates are scheduled.
+    didScheduleRenderPhaseUpdate = false;
+    localIdCounter = 0;
+    formStateCounter = 0;
+    formStateMatchingIndex = -1;
+    thenableIndexCounter = 0;
+    numberOfReRenders += 1; // Start over from the beginning of the list
+
+    workInProgressHook = null;
+    children = Component(props, refOrContext);
+  }
+
+  resetHooksState();
+  return children;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+function checkDidRenderIdHook() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  const didRenderIdHook = localIdCounter !== 0;
+  return didRenderIdHook;
+}
+function getFormStateCount() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateCounter;
+}
+function getFormStateMatchingIndex() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateMatchingIndex;
+} // Reset the internal hooks state if an error occurs while rendering a component
+
+function resetHooksState() {
+
+  currentlyRenderingComponent = null;
+  currentlyRenderingTask = null;
+  currentlyRenderingRequest = null;
+  currentlyRenderingKeyPath = null;
+  didScheduleRenderPhaseUpdate = false;
+  firstWorkInProgressHook = null;
+  numberOfReRenders = 0;
+  renderPhaseUpdates = null;
+  workInProgressHook = null;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+function useContext(context) {
+
+  resolveCurrentlyRenderingComponent();
+  return readContext$1(context);
+}
+
+function basicStateReducer(state, action) {
+  // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
+  return typeof action === 'function' ? action(state) : action;
+}
+
+function useState(initialState) {
+
+  return useReducer(basicStateReducer, // useReducer has a special case to support lazy useState initializers
+  initialState);
+}
+function useReducer(reducer, initialArg, init) {
+
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+
+  if (isReRender) {
+    // This is a re-render. Apply the new render phase updates to the previous
+    // current hook.
+    const queue = workInProgressHook.queue;
+    const dispatch = queue.dispatch;
+
+    if (renderPhaseUpdates !== null) {
+      // Render phase updates are stored in a map of queue -> linked list
+      const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+      if (firstRenderPhaseUpdate !== undefined) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        renderPhaseUpdates.delete(queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+        let newState = workInProgressHook.memoizedState;
+        let update = firstRenderPhaseUpdate;
+
+        do {
+          // Process this render phase update. We don't have to check the
+          // priority because it will always be the same as the current
+          // render's.
+          const action = update.action;
+
+          newState = reducer(newState, action);
+
+
+          update = update.next;
+        } while (update !== null); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+        workInProgressHook.memoizedState = newState;
+        return [newState, dispatch];
+      }
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    return [workInProgressHook.memoizedState, dispatch];
+  } else {
+
+    let initialState;
+
+    if (reducer === basicStateReducer) {
+      // Special case for `useState`.
+      initialState = typeof initialArg === 'function' ? initialArg() : initialArg;
+    } else {
+      initialState = init !== undefined ? init(initialArg) : initialArg;
+    }
+
+
+    workInProgressHook.memoizedState = initialState; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    const queue = workInProgressHook.queue = {
+      last: null,
+      dispatch: null
+    };
+    const dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingComponent, queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    return [workInProgressHook.memoizedState, dispatch];
+  }
+}
+
+function useMemo(nextCreate, deps) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+
+  if (workInProgressHook !== null) {
+    const prevState = workInProgressHook.memoizedState;
+
+    if (prevState !== null) {
+      if (nextDeps !== null) {
+        const prevDeps = prevState[1];
+
+        if (areHookInputsEqual(nextDeps, prevDeps)) {
+          return prevState[0];
+        }
+      }
+    }
+  }
+
+  const nextValue = nextCreate();
+
+
+  workInProgressHook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
+
+function useRef(initialValue) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const previousRef = workInProgressHook.memoizedState;
+
+  if (previousRef === null) {
+    const ref = {
+      current: initialValue
+    };
+
+
+    workInProgressHook.memoizedState = ref;
+    return ref;
+  } else {
+    return previousRef;
+  }
+}
+
+function dispatchAction(componentIdentity, queue, action) {
+  if (numberOfReRenders >= RE_RENDER_LIMIT) {
+    throw Error(formatProdErrorMessage(301));
+  }
+
+  if (componentIdentity === currentlyRenderingComponent) {
+    // This is a render phase update. Stash it in a lazily-created map of
+    // queue -> linked list of updates. After this render pass, we'll restart
+    // and apply the stashed updates on top of the work-in-progress hook.
+    didScheduleRenderPhaseUpdate = true;
+    const update = {
+      action,
+      next: null
+    };
+
+    if (renderPhaseUpdates === null) {
+      renderPhaseUpdates = new Map();
+    }
+
+    const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+    if (firstRenderPhaseUpdate === undefined) {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      renderPhaseUpdates.set(queue, update);
+    } else {
+      // Append the update to the end of the list.
+      let lastRenderPhaseUpdate = firstRenderPhaseUpdate;
+
+      while (lastRenderPhaseUpdate.next !== null) {
+        lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+      }
+
+      lastRenderPhaseUpdate.next = update;
+    }
+  }
+}
+
+function useCallback(callback, deps) {
+  return useMemo(() => callback, deps);
+}
+
+function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  if (getServerSnapshot === undefined) {
+    throw Error(formatProdErrorMessage(407));
+  }
+
+  return getServerSnapshot();
+}
+
+function useDeferredValue(value, initialValue) {
+  resolveCurrentlyRenderingComponent();
+
+  {
+    return value;
+  }
+}
+
+function unsupportedStartTransition() {
+  throw Error(formatProdErrorMessage(394));
+}
+
+function useTransition() {
+  resolveCurrentlyRenderingComponent();
+  return [false, unsupportedStartTransition];
+}
+
+function useHostTransitionStatus() {
+  resolveCurrentlyRenderingComponent();
+  return NotPendingTransition;
+}
+
+function unsupportedSetOptimisticState() {
+  throw Error(formatProdErrorMessage(479));
+}
+
+function useOptimistic(passthrough, reducer) {
+  resolveCurrentlyRenderingComponent();
+  return [passthrough, unsupportedSetOptimisticState];
+}
+
+function createPostbackFormStateKey(permalink, componentKeyPath, hookIndex) {
+  if (permalink !== undefined) {
+    // Don't bother to hash a permalink-based key since it's already short.
+    return 'p' + permalink;
+  } else {
+    // Append a node to the key path that represents the form state hook.
+    const keyPath = [componentKeyPath, null, hookIndex]; // Key paths are hashed to reduce the size. It does not need to be secure,
+    // and it's more important that it's fast than that it's completely
+    // collision-free.
+
+    const keyPathHash = createFastHashJS(JSON.stringify(keyPath));
+    return 'k' + keyPathHash;
+  }
+}
+
+function useFormState(action, initialState, permalink) {
+  resolveCurrentlyRenderingComponent(); // Count the number of useFormState hooks per component. We also use this to
+  // track the position of this useFormState hook relative to the other ones in
+  // this component, so we can generate a unique key for each one.
+
+  const formStateHookIndex = formStateCounter++;
+  const request = currentlyRenderingRequest; // $FlowIgnore[prop-missing]
+
+  const formAction = action.$$FORM_ACTION;
+
+  if (typeof formAction === 'function') {
+    // This is a server action. These have additional features to enable
+    // MPA-style form submissions with progressive enhancement.
+    // TODO: If the same permalink is passed to multiple useFormStates, and
+    // they all have the same action signature, Fizz will pass the postback
+    // state to all of them. We should probably only pass it to the first one,
+    // and/or warn.
+    // The key is lazily generated and deduped so the that the keypath doesn't
+    // get JSON.stringify-ed unnecessarily, and at most once.
+    let nextPostbackStateKey = null; // Determine the current form state. If we received state during an MPA form
+    // submission, then we will reuse that, if the action identity matches.
+    // Otherwise we'll use the initial state argument. We will emit a comment
+    // marker into the stream that indicates whether the state was reused.
+
+    let state = initialState;
+    const componentKeyPath = currentlyRenderingKeyPath;
+    const postbackFormState = getFormState(request); // $FlowIgnore[prop-missing]
+
+    const isSignatureEqual = action.$$IS_SIGNATURE_EQUAL;
+
+    if (postbackFormState !== null && typeof isSignatureEqual === 'function') {
+      const postbackKey = postbackFormState[1];
+      const postbackReferenceId = postbackFormState[2];
+      const postbackBoundArity = postbackFormState[3];
+
+      if (isSignatureEqual.call(action, postbackReferenceId, postbackBoundArity)) {
+        nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+
+        if (postbackKey === nextPostbackStateKey) {
+          // This was a match
+          formStateMatchingIndex = formStateHookIndex; // Reuse the state that was submitted by the form.
+
+          state = postbackFormState[0];
+        }
+      }
+    } // Bind the state to the first argument of the action.
+
+
+    const boundAction = action.bind(null, state); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    }; // $FlowIgnore[prop-missing]
+
+
+    if (typeof boundAction.$$FORM_ACTION === 'function') {
+      // $FlowIgnore[prop-missing]
+      dispatch.$$FORM_ACTION = prefix => {
+        const metadata = boundAction.$$FORM_ACTION(prefix); // Override the action URL
+
+        if (permalink !== undefined) {
+
+          permalink += '';
+          metadata.action = permalink;
+        }
+
+        const formData = metadata.data;
+
+        if (formData) {
+          if (nextPostbackStateKey === null) {
+            nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+          }
+
+          formData.append('$ACTION_KEY', nextPostbackStateKey);
+        }
+
+        return metadata;
+      };
+    }
+
+    return [state, dispatch];
+  } else {
+    // This is not a server action, so the implementation is much simpler.
+    // Bind the state to the first argument of the action.
+    const boundAction = action.bind(null, initialState); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    };
+
+    return [initialState, dispatch];
+  }
+}
+
+function useId() {
+  const task = currentlyRenderingTask;
+  const treeId = getTreeId(task.treeContext);
+  const resumableState = currentResumableState;
+
+  if (resumableState === null) {
+    throw Error(formatProdErrorMessage(404));
+  }
+
+  const localId = localIdCounter++;
+  return makeId(resumableState, treeId, localId);
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable;
+      return unwrapThenable(thenable);
+    } else if (usable.$$typeof === REACT_CONTEXT_TYPE || usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+  throw Error(formatProdErrorMessage(438, String(usable)));
+}
+
+function unwrapThenable(thenable) {
+  const index = thenableIndexCounter;
+  thenableIndexCounter += 1;
+
+  if (thenableState === null) {
+    thenableState = createThenableState();
+  }
+
+  return trackUsedThenable(thenableState, thenable, index);
+}
+
+function unsupportedRefresh() {
+  throw Error(formatProdErrorMessage(393));
+}
+
+function useCacheRefresh() {
+  return unsupportedRefresh;
+}
+
+function noop$1() {}
+
+const HooksDispatcher = {
+  readContext,
+  use,
+  useContext,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+  useInsertionEffect: noop$1,
+  useLayoutEffect: noop$1,
+  useCallback,
+  // useImperativeHandle is not run in the server environment
+  useImperativeHandle: noop$1,
+  // Effects are not run in the server environment.
+  useEffect: noop$1,
+  // Debugging effect
+  useDebugValue: noop$1,
+  useDeferredValue,
+  useTransition,
+  useId,
+  // Subscriptions are not setup in a server environment.
+  useSyncExternalStore
+};
+
+{
+  HooksDispatcher.useCacheRefresh = useCacheRefresh;
+}
+
+{
+  HooksDispatcher.useHostTransitionStatus = useHostTransitionStatus;
+}
+
+{
+  HooksDispatcher.useOptimistic = useOptimistic;
+  HooksDispatcher.useFormState = useFormState;
+}
+
+let currentResumableState = null;
+function setCurrentResumableState(resumableState) {
+  currentResumableState = resumableState;
+}
+
+function getCacheSignal() {
+  throw Error(formatProdErrorMessage(248));
+}
+
+function getCacheForType(resourceType) {
+  throw Error(formatProdErrorMessage(248));
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal,
+  getCacheForType
+};
+
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+const ReactCurrentCache = ReactSharedInternals.ReactCurrentCache;
+// The name might be minified but we assume that it's going to be the same generated name. Typically
+// because it's just the same compiled output in practice.
+// resume with segmentID at the index
+
+const CLIENT_RENDERED = 4; // if it errors or infinitely suspends
+
+const PENDING = 0;
+const COMPLETED = 1;
+const FLUSHED = 2;
+const ABORTED = 3;
+const ERRORED = 4;
+const POSTPONED = 5;
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2; // This is a default heuristic for how to split up the HTML content into progressive
+// loading. Our goal is to be able to display additional new content about every 500ms.
+// Faster than that is unnecessary and should be throttled on the client. It also
+// adds unnecessary overhead to do more splits. We don't know if it's a higher or lower
+// end device but higher end suffer less from the overhead than lower end does from
+// not getting small enough pieces. We error on the side of low end.
+// We base this on low end 3G speeds which is about 500kbits per second. We assume
+// that there can be a reasonable drop off from max bandwidth which leaves you with
+// as little as 80%. We can receive half of that each 500ms - at best. In practice,
+// a little bandwidth is lost to processing and contention - e.g. CSS and images that
+// are downloaded along with the main content. So we estimate about half of that to be
+// the lower end throughput. In other words, we expect that you can at least show
+// about 12.5kb of content per 500ms. Not counting starting latency for the first
+// paint.
+// 500 * 1024 / 8 * .8 * 0.5 / 2
+
+const DEFAULT_PROGRESSIVE_CHUNK_SIZE = 12800;
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+
+  return null;
+}
+
+function noop() {}
+
+function createRequest(children, resumableState, renderState, rootFormatContext, progressiveChunkSize, onError, onAllReady, onShellReady, onShellError, onFatalError, onPostpone, formState) {
+  prepareHostDispatcher();
+  const pingedTasks = [];
+  const abortSet = new Set();
+  const request = {
+    destination: null,
+    flushScheduled: false,
+    resumableState,
+    renderState,
+    rootFormatContext,
+    progressiveChunkSize: progressiveChunkSize === undefined ? DEFAULT_PROGRESSIVE_CHUNK_SIZE : progressiveChunkSize,
+    status: OPEN,
+    fatalError: null,
+    nextSegmentId: 0,
+    allPendingTasks: 0,
+    pendingRootTasks: 0,
+    completedRootSegment: null,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    clientRenderedBoundaries: [],
+    completedBoundaries: [],
+    partialBoundaries: [],
+    trackedPostpones: null,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? noop : onPostpone,
+    onAllReady: onAllReady === undefined ? noop : onAllReady,
+    onShellReady: onShellReady === undefined ? noop : onShellReady,
+    onShellError: onShellError === undefined ? noop : onShellError,
+    onFatalError: onFatalError === undefined ? noop : onFatalError,
+    formState: formState === undefined ? null : formState
+  }; // This segment represents the root fallback.
+
+  const rootSegment = createPendingSegment(request, 0, null, rootFormatContext, // Root segments are never embedded in Text on either edge
+  false, false); // There is no parent so conceptually, we're unblocked to flush this segment.
+
+  rootSegment.parentFlushed = true;
+  const rootTask = createRenderTask(request, null, children, -1, null, rootSegment, abortSet, null, rootFormatContext, emptyContextObject, rootContextSnapshot, emptyTreeContext);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  return null;
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (request.pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createSuspenseBoundary(request, fallbackAbortableTasks) {
+  return {
+    status: PENDING,
+    rootSegmentID: -1,
+    parentFlushed: false,
+    pendingTasks: 0,
+    completedSegments: [],
+    byteSize: 0,
+    fallbackAbortableTasks,
+    errorDigest: null,
+    resources: createBoundaryResources(),
+    trackedContentKeyPath: null,
+    trackedFallbackNode: null
+  };
+}
+
+function createRenderTask(request, thenableState, node, childIndex, blockedBoundary, blockedSegment, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  const task = {
+    replay: null,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createReplayTask(request, thenableState, replay, node, childIndex, blockedBoundary, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  replay.pendingTasks++;
+  const task = {
+    replay,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment: null,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createPendingSegment(request, index, boundary, parentFormatContext, lastPushedText, textEmbedded) {
+  return {
+    status: PENDING,
+    id: -1,
+    // lazily assigned later
+    index,
+    parentFlushed: false,
+    chunks: [],
+    children: [],
+    parentFormatContext,
+    boundary,
+    lastPushedText,
+    textEmbedded
+  };
+} // DEV-only global reference to the currently executing task
+
+function popComponentStackInDEV(task) {
+} // stash the component stack of an unwinding error until it is processed
+
+function logRecoverableError(request, error) {
+  // If this callback errors, we intentionally let that error bubble up to become a fatal error
+  // so that someone fixes the error reporting instead of hiding it.
+  const errorDigest = request.onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest;
+}
+
+function fatalError(request, error) {
+  // This is called outside error handling code such as if the root errors outside
+  // a suspense boundary or if the root suspense boundary's fallback errors.
+  // It's also called if React itself or its host configs errors.
+  const onShellError = request.onShellError;
+  onShellError(error);
+  const onFatalError = request.onFatalError;
+  onFatalError(error);
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function renderSuspenseBoundary(request, someTask, keyPath, props) {
+  if (someTask.replay !== null) {
+    // If we're replaying through this pass, it means we're replaying through
+    // an already completed Suspense boundary. It's too late to do anything about it
+    // so we can just render through it.
+    const prevKeyPath = someTask.keyPath;
+    someTask.keyPath = keyPath;
+    const content = props.children;
+
+    try {
+      renderNode(request, someTask, content, -1);
+    } finally {
+      someTask.keyPath = prevKeyPath;
+    }
+
+    return;
+  } // $FlowFixMe: Refined.
+
+
+  const task = someTask;
+  const prevKeyPath = task.keyPath;
+  const parentBoundary = task.blockedBoundary;
+  const parentSegment = task.blockedSegment; // Each time we enter a suspense boundary, we split out into a new segment for
+  // the fallback so that we can later replace that segment with the content.
+  // This also lets us split out the main content even if it doesn't suspend,
+  // in case it ends up generating a large subtree of content.
+
+  const fallback = props.fallback;
+  const content = props.children;
+  const fallbackAbortSet = new Set();
+  const newBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+
+  if (request.trackedPostpones !== null) {
+    newBoundary.trackedContentKeyPath = keyPath;
+  }
+
+  const insertionIndex = parentSegment.chunks.length; // The children of the boundary segment is actually the fallback.
+
+  const boundarySegment = createPendingSegment(request, insertionIndex, newBoundary, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false);
+  parentSegment.children.push(boundarySegment); // The parentSegment has a child Segment at this index so we reset the lastPushedText marker on the parent
+
+  parentSegment.lastPushedText = false; // This segment is the actual child content. We can start rendering that immediately.
+
+  const contentRootSegment = createPendingSegment(request, 0, null, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false); // We mark the root segment as having its parent flushed. It's not really flushed but there is
+  // no parent segment so there's nothing to wait on.
+
+  contentRootSegment.parentFlushed = true; // Currently this is running synchronously. We could instead schedule this to pingedTasks.
+  // I suspect that there might be some efficiency benefits from not creating the suspended task
+  // and instead just using the stack if possible.
+  // TODO: Call this directly instead of messing with saving and restoring contexts.
+  // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and which segment
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = newBoundary;
+  task.blockedSegment = contentRootSegment;
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, newBoundary.resources);
+  }
+
+  task.keyPath = keyPath;
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+    pushSegmentFinale(contentRootSegment.chunks, request.renderState, contentRootSegment.lastPushedText, contentRootSegment.textEmbedded);
+    contentRootSegment.status = COMPLETED;
+    queueCompletedSegment(newBoundary, contentRootSegment);
+
+    if (newBoundary.pendingTasks === 0 && newBoundary.status === PENDING) {
+      newBoundary.status = COMPLETED; // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    contentRootSegment.status = ERRORED;
+    newBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    newBoundary.errorDigest = errorDigest;
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.blockedSegment = parentSegment;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]];
+  const trackedPostpones = request.trackedPostpones;
+
+  if (trackedPostpones !== null) {
+    // We create a detached replay node to track any postpones inside the fallback.
+    const fallbackReplayNode = [fallbackKeyPath[1], fallbackKeyPath[2], [], null];
+    trackedPostpones.workingMap.set(fallbackKeyPath, fallbackReplayNode);
+
+    if (newBoundary.status === POSTPONED) {
+      // This must exist now.
+      const boundaryReplayNode = trackedPostpones.workingMap.get(keyPath);
+      boundaryReplayNode[4] = fallbackReplayNode;
+    } else {
+      // We might not inject it into the postponed tree, unless the content actually
+      // postpones too. We need to keep track of it until that happpens.
+      newBoundary.trackedFallbackNode = fallbackReplayNode;
+    }
+  } // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+
+  const suspendedFallbackTask = createRenderTask(request, null, fallback, -1, parentBoundary, boundarySegment, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function replaySuspenseBoundary(request, task, keyPath, props, id, childNodes, childSlots, fallbackNodes, fallbackSlots) {
+  const prevKeyPath = task.keyPath;
+  const previousReplaySet = task.replay;
+  const parentBoundary = task.blockedBoundary;
+  const content = props.children;
+  const fallback = props.fallback;
+  const fallbackAbortSet = new Set();
+  const resumedBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = id; // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and replay node
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = resumedBoundary;
+  task.replay = {
+    nodes: childNodes,
+    slots: childSlots,
+    pendingTasks: 1
+  };
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, resumedBoundary.resources);
+  }
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw Error(formatProdErrorMessage(488));
+    }
+
+    task.replay.pendingTasks--;
+
+    if (resumedBoundary.pendingTasks === 0 && resumedBoundary.status === PENDING) {
+      resumedBoundary.status = COMPLETED;
+      request.completedBoundaries.push(resumedBoundary); // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    resumedBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    resumedBoundary.errorDigest = errorDigest;
+
+    task.replay.pendingTasks--; // The parent already flushed in the prerender so we need to schedule this to be emitted.
+
+    request.clientRenderedBoundaries.push(resumedBoundary); // We don't need to decrement any task numbers because we didn't spawn any new task.
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.replay = previousReplaySet;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]]; // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+  const fallbackReplay = {
+    nodes: fallbackNodes,
+    slots: fallbackSlots,
+    pendingTasks: 0
+  };
+  const suspendedFallbackTask = createReplayTask(request, null, fallbackReplay, fallback, -1, parentBoundary, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function renderHostElement(request, task, keyPath, type, props) {
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    const children = props.children; // TODO: Make this a Config for replaying.
+
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+  } else {
+    // Render
+    const children = pushStartInstance(segment.chunks, type, props, request.resumableState, request.renderState, task.formatContext, segment.lastPushedText);
+    segment.lastPushedText = false;
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+    pushEndInstance(segment.chunks, type, props, request.resumableState, prevContext);
+    segment.lastPushedText = false;
+  }
+}
+
+function shouldConstruct(Component) {
+  return Component.prototype && Component.prototype.isReactComponent;
+}
+
+function renderWithHooks(request, task, keyPath, prevThenableState, Component, props, secondArg) {
+  const componentIdentity = {};
+  prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState);
+  const result = Component(props, secondArg);
+  return finishHooks(Component, props, result, secondArg);
+}
+
+function finishClassComponent(request, task, keyPath, instance, Component, props) {
+  const nextChildren = instance.render();
+
+  {
+    const childContextTypes = Component.childContextTypes;
+
+    if (childContextTypes !== null && childContextTypes !== undefined) {
+      const previousContext = task.legacyContext;
+      const mergedContext = processChildContext(instance, Component, previousContext, childContextTypes);
+      task.legacyContext = mergedContext;
+      renderNodeDestructive(request, task, null, nextChildren, -1);
+      task.legacyContext = previousContext;
+      return;
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, nextChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderClassComponent(request, task, keyPath, Component, props) {
+  const maskedContext = getMaskedContext(Component, task.legacyContext) ;
+  const instance = constructClassInstance(Component, props, maskedContext);
+  mountClassInstance(instance, Component, props, maskedContext);
+  finishClassComponent(request, task, keyPath, instance, Component);
+}
+// components for some reason.
+
+function renderIndeterminateComponent(request, task, keyPath, prevThenableState, Component, props) {
+  let legacyContext;
+
+  {
+    legacyContext = getMaskedContext(Component, task.legacyContext);
+  }
+
+  const value = renderWithHooks(request, task, keyPath, prevThenableState, Component, props, legacyContext);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+
+  if ( // Run these checks in production only if the flag is off.
+  // Eventually we'll delete this branch altogether.
+  typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) {
+
+    mountClassInstance(value, Component, props, legacyContext);
+    finishClassComponent(request, task, keyPath, value, Component);
+  } else {
+
+    finishFunctionComponent(request, task, keyPath, value, hasId, formStateCount, formStateMatchingIndex);
+  }
+}
+
+function finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex) {
+  let didEmitFormStateMarkers = false;
+
+  if (formStateCount !== 0 && request.formState !== null) {
+    // For each useFormState hook, emit a marker that indicates whether we
+    // rendered using the form state passed at the root. We only emit these
+    // markers if form state is passed at the root.
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      didEmitFormStateMarkers = true;
+      const target = segment.chunks;
+
+      for (let i = 0; i < formStateCount; i++) {
+        if (i === formStateMatchingIndex) {
+          pushFormStateMarkerIsMatching(target);
+        } else {
+          pushFormStateMarkerIsNotMatching(target);
+        }
+      }
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+
+  if (hasId) {
+    // This component materialized an id. We treat this as its own level, with
+    // a single "child" slot.
+    const prevTreeContext = task.treeContext;
+    const totalChildren = 1;
+    const index = 0; // Modify the id context. Because we'll need to reset this if something
+    // suspends or errors, we'll use the non-destructive render path.
+
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, index);
+    renderNode(request, task, children, -1); // Like the other contexts, this does not need to be in a finally block
+    // because renderNode takes care of unwinding the stack.
+
+    task.treeContext = prevTreeContext;
+  } else if (didEmitFormStateMarkers) {
+    // If there were formState hooks, we must use the non-destructive path
+    // because this component is not a pure indirection; we emitted markers
+    // to the stream.
+    renderNode(request, task, children, -1);
+  } else {
+    // We're now successfully past this task, and we haven't modified the
+    // context stack. We don't have to pop back to the previous task every
+    // again, so we can use the destructive recursive form.
+    renderNodeDestructive(request, task, null, children, -1);
+  }
+
+  task.keyPath = prevKeyPath;
+}
+
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    // Resolve default props. Taken from ReactElement
+    const props = assign({}, baseProps);
+    const defaultProps = Component.defaultProps;
+
+    for (const propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+
+    return props;
+  }
+
+  return baseProps;
+}
+
+function renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref) {
+  const children = renderWithHooks(request, task, keyPath, prevThenableState, type.render, props, ref);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+  finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex);
+}
+
+function renderMemo(request, task, keyPath, prevThenableState, type, props, ref) {
+  const innerType = type.type;
+  const resolvedProps = resolveDefaultProps(innerType, props);
+  renderElement(request, task, keyPath, prevThenableState, innerType, resolvedProps, ref);
+}
+
+function renderContextConsumer(request, task, keyPath, context, props) {
+
+  const render = props.children;
+
+  const newValue = readContext$1(context);
+  const newChildren = render(newValue);
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, newChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderContextProvider(request, task, keyPath, type, props) {
+  const context = type._context;
+  const value = props.value;
+  const children = props.children;
+
+  const prevKeyPath = task.keyPath;
+  task.context = pushProvider(context, value);
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, children, -1);
+  task.context = popProvider();
+  task.keyPath = prevKeyPath;
+}
+
+function renderLazyComponent(request, task, keyPath, prevThenableState, lazyComponent, props, ref) {
+  const payload = lazyComponent._payload;
+  const init = lazyComponent._init;
+  const Component = init(payload);
+  const resolvedProps = resolveDefaultProps(Component, props);
+  renderElement(request, task, keyPath, prevThenableState, Component, resolvedProps, ref);
+}
+
+function renderOffscreen(request, task, keyPath, props) {
+  const mode = props.mode;
+
+  if (mode === 'hidden') ; else {
+    // A visible Offscreen boundary is treated exactly like a fragment: a
+    // pure indirection.
+    const prevKeyPath = task.keyPath;
+    task.keyPath = keyPath;
+    renderNodeDestructive(request, task, null, props.children, -1);
+    task.keyPath = prevKeyPath;
+  }
+}
+
+function renderElement(request, task, keyPath, prevThenableState, type, props, ref) {
+  if (typeof type === 'function') {
+    if (shouldConstruct(type)) {
+      renderClassComponent(request, task, keyPath, type, props);
+      return;
+    } else {
+      renderIndeterminateComponent(request, task, keyPath, prevThenableState, type, props);
+      return;
+    }
+  }
+
+  if (typeof type === 'string') {
+    renderHostElement(request, task, keyPath, type, props);
+    return;
+  }
+
+  switch (type) {
+    // LegacyHidden acts the same as a fragment. This only works because we
+    // currently assume that every instance of LegacyHidden is accompanied by a
+    // host component wrapper. In the hidden mode, the host component is given a
+    // `hidden` attribute, which ensures that the initial HTML is not visible.
+    // To support the use of LegacyHidden as a true fragment, without an extra
+    // DOM node, we would have to hide the initial HTML in some other way.
+    // TODO: Delete in LegacyHidden. It's an unstable API only used in the
+    // www build. As a migration step, we could add a special prop to Offscreen
+    // that simulates the old behavior (no hiding, no change to effects).
+    case REACT_LEGACY_HIDDEN_TYPE:
+    case REACT_DEBUG_TRACING_MODE_TYPE:
+    case REACT_STRICT_MODE_TYPE:
+    case REACT_PROFILER_TYPE:
+    case REACT_FRAGMENT_TYPE:
+      {
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_OFFSCREEN_TYPE:
+      {
+        renderOffscreen(request, task, keyPath, props);
+        return;
+      }
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      {
+
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_SCOPE_TYPE:
+      {
+
+        throw Error(formatProdErrorMessage(343));
+      }
+
+    case REACT_SUSPENSE_TYPE:
+      {
+        {
+          renderSuspenseBoundary(request, task, keyPath, props);
+        }
+
+        return;
+      }
+  }
+
+  if (typeof type === 'object' && type !== null) {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        {
+          renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          renderMemo(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_PROVIDER_TYPE:
+        {
+          renderContextProvider(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_CONTEXT_TYPE:
+        {
+          renderContextConsumer(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_LAZY_TYPE:
+        {
+          renderLazyComponent(request, task, keyPath, prevThenableState, type, props);
+          return;
+        }
+    }
+  }
+
+  let info = '';
+
+  throw Error(formatProdErrorMessage(130, type == null ? type : typeof type, info));
+}
+
+function resumeNode(request, task, segmentId, node, childIndex) {
+  const prevReplay = task.replay;
+  const blockedBoundary = task.blockedBoundary;
+  const resumedSegment = createPendingSegment(request, 0, null, task.formatContext, false, false);
+  resumedSegment.id = segmentId;
+  resumedSegment.parentFlushed = true;
+
+  try {
+    // Convert the current ReplayTask to a RenderTask.
+    const renderTask = task;
+    renderTask.replay = null;
+    renderTask.blockedSegment = resumedSegment;
+    renderNode(request, task, node, childIndex);
+    resumedSegment.status = COMPLETED;
+
+    if (blockedBoundary === null) {
+      request.completedRootSegment = resumedSegment;
+    } else {
+      queueCompletedSegment(blockedBoundary, resumedSegment);
+
+      if (blockedBoundary.parentFlushed) {
+        request.partialBoundaries.push(blockedBoundary);
+      }
+    }
+  } finally {
+    // Restore to a ReplayTask.
+    task.replay = prevReplay;
+    task.blockedSegment = null;
+  }
+}
+
+function replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, replay) {
+  // We're replaying. Find the path to follow.
+  const replayNodes = replay.nodes;
+
+  for (let i = 0; i < replayNodes.length; i++) {
+    // Flow doesn't support refinement on tuples so we do it manually here.
+    const node = replayNodes[i];
+
+    if (keyOrIndex !== node[1]) {
+      continue;
+    }
+
+    if (node.length === 4) {
+      // Matched a replayable path.
+      // Let's double check that the component name matches as a precaution.
+      if (name !== null && name !== node[0]) {
+        throw Error(formatProdErrorMessage(490, node[0], name));
+      }
+
+      const childNodes = node[2];
+      const childSlots = node[3];
+      const currentNode = task.node;
+      task.replay = {
+        nodes: childNodes,
+        slots: childSlots,
+        pendingTasks: 1
+      };
+
+      try {
+        renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+
+        if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0 // TODO check remaining slots
+        ) {
+            throw Error(formatProdErrorMessage(488));
+          }
+
+        task.replay.pendingTasks--;
+      } catch (x) {
+        if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+          // Suspend
+          if (task.node === currentNode) {
+            // This same element suspended so we need to pop the replay we just added.
+            task.replay = replay;
+          }
+
+          throw x;
+        }
+
+        task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+        // during a replay. That's because this component didn't actually error
+        // in the original prerender. What's unable to complete is the child
+        // replay nodes which might be Suspense boundaries which are able to
+        // absorb the error and we can still continue with siblings.
+
+        erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+      }
+
+      task.replay = replay;
+    } else {
+      // Let's double check that the component type matches.
+      if (type !== REACT_SUSPENSE_TYPE) {
+        const expectedType = 'Suspense';
+        throw Error(formatProdErrorMessage(490, expectedType, getComponentNameFromType(type) || 'Unknown'));
+      } // Matched a replayable path.
+
+
+      replaySuspenseBoundary(request, task, keyPath, props, node[5], node[2], node[3], node[4] === null ? [] : node[4][2], node[4] === null ? null : node[4][3]);
+    } // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+
+    replayNodes.splice(i, 1);
+    return;
+  } // We didn't find any matching nodes. We assume that this element was already
+  // rendered in the prelude and skip it.
+
+} // $FlowFixMe[missing-local-annot]
+
+function renderNodeDestructive(request, task, // The thenable state reused from the previous attempt, if any. This is almost
+// always null, except when called by retryTask.
+prevThenableState, node, childIndex) {
+  {
+    return renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex);
+  }
+} // This function by it self renders a node and consumes the task by mutating it
+// to update the current execution state.
+
+
+function renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex) {
+  if (task.replay !== null && typeof task.replay.slots === 'number') {
+    // TODO: Figure out a cheaper place than this hot path to do this check.
+    const resumeSegmentID = task.replay.slots;
+    resumeNode(request, task, resumeSegmentID, node, childIndex);
+    return;
+  } // Stash the node we're working on. We'll pick up from this task in case
+  // something suspends.
+
+
+  task.node = node;
+  task.childIndex = childIndex; // Handle object types
+
+  if (typeof node === 'object' && node !== null) {
+    switch (node.$$typeof) {
+      case REACT_ELEMENT_TYPE:
+        {
+          const element = node;
+          const type = element.type;
+          const key = element.key;
+          const props = element.props;
+          const ref = element.ref;
+          const name = getComponentNameFromType(type);
+          const keyOrIndex = key == null ? childIndex === -1 ? 0 : childIndex : key;
+          const keyPath = [task.keyPath, name, keyOrIndex];
+
+          if (task.replay !== null) {
+            replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, task.replay); // No matches found for this node. We assume it's already emitted in the
+            // prelude and skip it during the replay.
+          } else {
+            // We're doing a plain render.
+            renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+          }
+
+          return;
+        }
+
+      case REACT_PORTAL_TYPE:
+        throw Error(formatProdErrorMessage(257));
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyNode = node;
+          const payload = lazyNode._payload;
+          const init = lazyNode._init;
+          let resolvedNode;
+
+          {
+            resolvedNode = init(payload);
+          }
+
+          renderNodeDestructive(request, task, null, resolvedNode, childIndex);
+          return;
+        }
+    }
+
+    if (isArray(node)) {
+      renderChildrenArray(request, task, node, childIndex);
+      return;
+    }
+
+    const iteratorFn = getIteratorFn(node);
+
+    if (iteratorFn) {
+
+      const iterator = iteratorFn.call(node);
+
+      if (iterator) {
+        // We need to know how many total children are in this set, so that we
+        // can allocate enough id slots to acommodate them. So we must exhaust
+        // the iterator before we start recursively rendering the children.
+        // TODO: This is not great but I think it's inherent to the id
+        // generation algorithm.
+        let step = iterator.next(); // If there are not entries, we need to push an empty so we start by checking that.
+
+        if (!step.done) {
+          const children = [];
+
+          do {
+            children.push(step.value);
+            step = iterator.next();
+          } while (!step.done);
+
+          renderChildrenArray(request, task, children, childIndex);
+          return;
+        }
+
+        return;
+      }
+    } // Usables are a valid React node type. When React encounters a Usable in
+    // a child position, it unwraps it using the same algorithm as `use`. For
+    // example, for promises, React will throw an exception to unwind the
+    // stack, then replay the component once the promise resolves.
+    //
+    // A difference from `use` is that React will keep unwrapping the value
+    // until it reaches a non-Usable type.
+    //
+    // e.g. Usable<Usable<Usable<T>>> should resolve to T
+
+
+    const maybeUsable = node;
+
+    if (typeof maybeUsable.then === 'function') {
+      const thenable = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, unwrapThenable(thenable), childIndex);
+    }
+
+    if (maybeUsable.$$typeof === REACT_CONTEXT_TYPE || maybeUsable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, readContext$1(context), childIndex);
+    } // $FlowFixMe[method-unbinding]
+
+
+    const childString = Object.prototype.toString.call(node);
+    throw Error(formatProdErrorMessage(31, childString === '[object Object]' ? 'object with keys {' + Object.keys(node).join(', ') + '}' : childString));
+  }
+
+  if (typeof node === 'string') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+
+  if (typeof node === 'number') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, '' + node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+}
+
+function replayFragment(request, task, children, childIndex) {
+  // If we're supposed follow this array, we'd expect to see a ReplayNode matching
+  // this fragment.
+  const replay = task.replay;
+  const replayNodes = replay.nodes;
+
+  for (let j = 0; j < replayNodes.length; j++) {
+    const node = replayNodes[j];
+
+    if (node[1] !== childIndex) {
+      continue;
+    } // Matched a replayable path.
+
+
+    const childNodes = node[2];
+    const childSlots = node[3];
+    task.replay = {
+      nodes: childNodes,
+      slots: childSlots,
+      pendingTasks: 1
+    };
+
+    try {
+      renderChildrenArray(request, task, children, -1);
+
+      if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+        throw Error(formatProdErrorMessage(488));
+      }
+
+      task.replay.pendingTasks--;
+    } catch (x) {
+      if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+        // Suspend
+        throw x;
+      }
+
+      task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+      // during a replay. That's because this component didn't actually error
+      // in the original prerender. What's unable to complete is the child
+      // replay nodes which might be Suspense boundaries which are able to
+      // absorb the error and we can still continue with siblings.
+      // This is an error, stash the component stack if it is null.
+
+      erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+    }
+
+    task.replay = replay; // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+    replayNodes.splice(j, 1);
+    break;
+  }
+}
+
+function renderChildrenArray(request, task, children, childIndex) {
+  const prevKeyPath = task.keyPath;
+
+  if (childIndex !== -1) {
+    task.keyPath = [task.keyPath, 'Fragment', childIndex];
+
+    if (task.replay !== null) {
+      replayFragment(request, // $FlowFixMe: Refined.
+      task, children, childIndex);
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  const prevTreeContext = task.treeContext;
+  const totalChildren = children.length;
+
+  if (task.replay !== null) {
+    // Replay
+    // First we need to check if we have any resume slots at this level.
+    const resumeSlots = task.replay.slots;
+
+    if (resumeSlots !== null && typeof resumeSlots === 'object') {
+      for (let i = 0; i < totalChildren; i++) {
+        const node = children[i];
+        task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+        // up and render the sibling if something suspends.
+
+        const resumeSegmentID = resumeSlots[i]; // TODO: If this errors we should still continue with the next sibling.
+
+        if (typeof resumeSegmentID === 'number') {
+          resumeNode(request, task, resumeSegmentID, node, i); // We finished rendering this node, so now we can consume this
+          // slot. This must happen after in case we rerender this task.
+
+          delete resumeSlots[i];
+        } else {
+          renderNode(request, task, node, i);
+        }
+      }
+
+      task.treeContext = prevTreeContext;
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  for (let i = 0; i < totalChildren; i++) {
+    const node = children[i];
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+    // up and render the sibling if something suspends.
+
+    renderNode(request, task, node, i);
+  } // Because this context is always set right before rendering every child, we
+  // only need to reset it to the previous value at the very end.
+
+
+  task.treeContext = prevTreeContext;
+  task.keyPath = prevKeyPath;
+}
+
+function spawnNewSuspendedReplayTask(request, task, thenableState, x) {
+  const newTask = createReplayTask(request, thenableState, task.replay, task.node, task.childIndex, task.blockedBoundary, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+}
+
+function spawnNewSuspendedRenderTask(request, task, thenableState, x) {
+  // Something suspended, we'll need to create a new segment and resolve it later.
+  const segment = task.blockedSegment;
+  const insertionIndex = segment.chunks.length;
+  const newSegment = createPendingSegment(request, insertionIndex, null, task.formatContext, // Adopt the parent segment's leading text embed
+  segment.lastPushedText, // Assume we are text embedded at the trailing edge
+  true);
+  segment.children.push(newSegment); // Reset lastPushedText for current Segment since the new Segment "consumed" it
+
+  segment.lastPushedText = false;
+  const newTask = createRenderTask(request, thenableState, task.node, task.childIndex, task.blockedBoundary, newSegment, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+} // This is a non-destructive form of rendering a node. If it suspends it spawns
+// a new task and restores the context of this task to what it was before.
+
+
+function renderNode(request, task, node, childIndex) {
+  // Snapshot the current context in case something throws to interrupt the
+  // process.
+  const previousFormatContext = task.formatContext;
+  const previousLegacyContext = task.legacyContext;
+  const previousContext = task.context;
+  const previousKeyPath = task.keyPath;
+  const previousTreeContext = task.treeContext;
+
+  let x; // Store how much we've pushed at this point so we can reset it in case something
+  // suspended partially through writing something.
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState();
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedReplayTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+      } // TODO: Abort any undiscovered Suspense boundaries in the ReplayNode.
+
+    }
+  } else {
+    // Render
+    const childrenLength = segment.children.length;
+    const chunkLength = segment.chunks.length;
+
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState(); // Reset the write pointers to where we started.
+
+      segment.children.length = childrenLength;
+      segment.chunks.length = chunkLength;
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedRenderTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+      }
+    }
+  } // Restore the context. We assume that this will be restored by the inner
+  // functions in case nothing throws so we don't use "finally" here.
+
+
+  task.formatContext = previousFormatContext;
+  task.legacyContext = previousLegacyContext;
+  task.context = previousContext;
+  task.keyPath = previousKeyPath;
+  task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+  switchContext(previousContext);
+  // Let's terminate the rest of the tree and don't render any siblings.
+
+
+  throw x;
+}
+
+function erroredReplay(request, boundary, error, replayNodes, resumeSlots) {
+  // Erroring during a replay doesn't actually cause an error by itself because
+  // that component has already rendered. What causes the error is the resumable
+  // points that we did not yet finish which will be below the point of the reset.
+  // For example, if we're replaying a path to a Suspense boundary that is not done
+  // that doesn't error the parent Suspense boundary.
+  // This might be a bit strange that the error in a parent gets thrown at a child.
+  // We log it only once and reuse the digest.
+  let errorDigest;
+
+  {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  abortRemainingReplayNodes(request, boundary, replayNodes, resumeSlots, error, errorDigest);
+}
+
+function erroredTask(request, boundary, error) {
+  // Report the error to a global handler.
+  let errorDigest;
+
+  {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  if (boundary === null) {
+    fatalError(request, error);
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+      // so we can flush it, if the parent already flushed.
+
+
+      if (boundary.parentFlushed) {
+        // We don't have a preference where in the queue this goes since it's likely
+        // to error on the client anyway. However, intentionally client-rendered
+        // boundaries should be flushed earlier so that they can start on the client.
+        // We reuse the same queue for errors.
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function abortTaskSoft(task) {
+  // This aborts task without aborting the parent boundary that it blocks.
+  // It's used for when we didn't need this task to complete the tree.
+  // If task was needed, then it should use abortTask instead.
+  const request = this;
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+    finishedTask(request, boundary, segment);
+  }
+}
+
+function abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest) {
+  const resumedBoundary = createSuspenseBoundary(request, new Set());
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = rootSegmentID;
+  resumedBoundary.status = CLIENT_RENDERED;
+  resumedBoundary.errorDigest = errorDigest;
+
+  if (resumedBoundary.parentFlushed) {
+    request.clientRenderedBoundaries.push(resumedBoundary);
+  }
+}
+
+function abortRemainingReplayNodes(request, boundary, nodes, slots, error, errorDigest) {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+
+    if (node.length === 4) {
+      abortRemainingReplayNodes(request, boundary, node[2], node[3], error, errorDigest);
+    } else {
+      const boundaryNode = node;
+      const rootSegmentID = boundaryNode[5];
+      abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest);
+    }
+  } // Empty the set, since we've cleared it now.
+
+
+  nodes.length = 0;
+
+  if (slots !== null) {
+    // We had something still to resume in the parent boundary. We must trigger
+    // the error on the parent boundary since it's not able to complete.
+    if (boundary === null) {
+      throw Error(formatProdErrorMessage(487));
+    } else if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // Empty the set
+
+
+    if (typeof slots === 'object') {
+      for (const index in slots) {
+        delete slots[index];
+      }
+    }
+  }
+}
+
+function abortTask(task, request, error) {
+  // This aborts the task and aborts the parent that it blocks, putting it into
+  // client rendered mode.
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+  }
+
+  if (boundary === null) {
+    if (request.status !== CLOSING && request.status !== CLOSED) {
+      const replay = task.replay;
+
+      if (replay === null) {
+        // We didn't complete the root so we have nothing to show. We can close
+        // the request;
+        logRecoverableError(request, error);
+        fatalError(request, error);
+        return;
+      } else {
+        // If the shell aborts during a replay, that's not a fatal error. Instead
+        // we should be able to recover by client rendering all the root boundaries in
+        // the ReplaySet.
+        replay.pendingTasks--;
+
+        if (replay.pendingTasks === 0 && replay.nodes.length > 0) {
+          const errorDigest = logRecoverableError(request, error);
+          abortRemainingReplayNodes(request, null, replay.nodes, replay.slots, error, errorDigest);
+        }
+
+        request.pendingRootTasks--;
+
+        if (request.pendingRootTasks === 0) {
+          completeShell(request);
+        }
+      }
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = logRecoverableError(request, error);
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // If this boundary was still pending then we haven't already cancelled its fallbacks.
+    // We'll need to abort the fallbacks, which will also error that parent boundary.
+
+
+    boundary.fallbackAbortableTasks.forEach(fallbackTask => abortTask(fallbackTask, request, error));
+    boundary.fallbackAbortableTasks.clear();
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeShell(request) {
+  if (request.trackedPostpones === null) {
+    // We only emit early preloads on shell completion for renders. For prerenders
+    // we wait for the entire Request to finish because we are not responding to a
+    // live request and can wait for as much data as possible.
+    // we should only be calling completeShell when the shell is complete so we
+    // just use a literal here
+    const shellComplete = true;
+    emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  } // We have completed the shell so the shell can't error anymore.
+
+
+  request.onShellError = noop;
+  const onShellReady = request.onShellReady;
+  onShellReady();
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeAll(request) {
+  // During a render the shell must be complete if the entire request is finished
+  // however during a Prerender it is possible that the shell is incomplete because
+  // it postponed. We cannot use rootPendingTasks in the prerender case because
+  // those hit zero even when the shell postpones. Instead we look at the completedRootSegment
+  const shellComplete = request.trackedPostpones === null ? // Render, we assume it is completed
+  true : // Prerender Request, we use the state of the root segment
+  request.completedRootSegment === null || request.completedRootSegment.status !== POSTPONED;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  const onAllReady = request.onAllReady;
+  onAllReady();
+}
+
+function queueCompletedSegment(boundary, segment) {
+  if (segment.chunks.length === 0 && segment.children.length === 1 && segment.children[0].boundary === null) {
+    // This is an empty segment. There's nothing to write, so we can instead transfer the ID
+    // to the child. That way any existing references point to the child.
+    const childSegment = segment.children[0];
+    childSegment.id = segment.id;
+    childSegment.parentFlushed = true;
+
+    if (childSegment.status === COMPLETED) {
+      queueCompletedSegment(boundary, childSegment);
+    }
+  } else {
+    const completedSegments = boundary.completedSegments;
+    completedSegments.push(segment);
+  }
+}
+
+function finishedTask(request, boundary, segment) {
+  if (boundary === null) {
+    if (segment !== null && segment.parentFlushed) {
+      if (request.completedRootSegment !== null) {
+        throw Error(formatProdErrorMessage(389));
+      }
+
+      request.completedRootSegment = segment;
+    }
+
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status === CLIENT_RENDERED) ; else if (boundary.pendingTasks === 0) {
+      if (boundary.status === PENDING) {
+        boundary.status = COMPLETED;
+      } // This must have been the last segment we were waiting on. This boundary is now complete.
+
+
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent segment already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+        }
+      }
+
+      if (boundary.parentFlushed) {
+        // The segment might be part of a segment that didn't flush yet, but if the boundary's
+        // parent flushed, we need to schedule the boundary to be emitted.
+        request.completedBoundaries.push(boundary);
+      } // We can now cancel any pending task on the fallback since we won't need to show it anymore.
+      // This needs to happen after we read the parentFlushed flags because aborting can finish
+      // work which can trigger user code, which can start flushing, which can change those flags.
+      // If the boundary was POSTPONED, we still need to finish the fallback first.
+
+
+      if (boundary.status === COMPLETED) {
+        boundary.fallbackAbortableTasks.forEach(abortTaskSoft, request);
+        boundary.fallbackAbortableTasks.clear();
+      }
+    } else {
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+          const completedSegments = boundary.completedSegments;
+
+          if (completedSegments.length === 1) {
+            // This is the first time since we last flushed that we completed anything.
+            // We can schedule this boundary to emit its partially completed segments early
+            // in case the parent has already been flushed.
+            if (boundary.parentFlushed) {
+              request.partialBoundaries.push(boundary);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function retryTask(request, task) {
+  {
+    const blockedBoundary = task.blockedBoundary;
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, blockedBoundary ? blockedBoundary.resources : null);
+  }
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    retryReplayTask(request, // $FlowFixMe: Refined.
+    task);
+  } else {
+    retryRenderTask(request, // $FlowFixMe: Refined.
+    task, segment);
+  }
+}
+
+function retryRenderTask(request, task, segment) {
+  if (segment.status !== PENDING) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  const childrenLength = segment.children.length;
+  const chunkLength = segment.chunks.length;
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+    pushSegmentFinale(segment.chunks, request.renderState, segment.lastPushedText, segment.textEmbedded);
+    task.abortSet.delete(task);
+    segment.status = COMPLETED;
+    finishedTask(request, task.blockedBoundary, segment);
+  } catch (thrownValue) {
+    resetHooksState(); // Reset the write pointers to where we started.
+
+    segment.children.length = childrenLength;
+    segment.chunks.length = chunkLength;
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    task.abortSet.delete(task);
+    segment.status = ERRORED;
+    erroredTask(request, task.blockedBoundary, x);
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function retryReplayTask(request, task) {
+  if (task.replay.pendingTasks === 0) {
+    // There are no pending tasks working on this set, so we must have aborted.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw Error(formatProdErrorMessage(488));
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    finishedTask(request, task.blockedBoundary, null);
+  } catch (thrownValue) {
+    resetHooksState();
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    erroredReplay(request, task.blockedBoundary, x, task.replay.nodes, task.replay.slots);
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+
+    request.allPendingTasks--;
+
+    if (request.allPendingTasks === 0) {
+      completeAll(request);
+    }
+
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function performWork(request) {
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  const prevContext = getActiveContext();
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  let prevCacheDispatcher;
+
+  {
+    prevCacheDispatcher = ReactCurrentCache.current;
+    ReactCurrentCache.current = DefaultCacheDispatcher;
+  }
+
+  const prevRequest = currentRequest;
+  currentRequest = request;
+
+  const prevResumableState = currentResumableState;
+  setCurrentResumableState(request.resumableState);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    let i;
+
+    for (i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    pingedTasks.splice(0, i);
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    setCurrentResumableState(prevResumableState);
+    ReactCurrentDispatcher.current = prevDispatcher;
+
+    {
+      ReactCurrentCache.current = prevCacheDispatcher;
+    }
+
+    if (prevDispatcher === HooksDispatcher) {
+      // This means that we were in a reentrant work loop. This could happen
+      // in a renderer that supports synchronous work like renderToString,
+      // when it's called from within another renderer.
+      // Normally we don't bother switching the contexts to their root/default
+      // values when leaving because we'll likely need the same or similar
+      // context again. However, when we're inside a synchronous loop like this
+      // we'll to restore the context to what it was before returning.
+      switchContext(prevContext);
+    }
+
+    currentRequest = prevRequest;
+  }
+}
+
+function flushSubtree(request, destination, segment) {
+  segment.parentFlushed = true;
+
+  switch (segment.status) {
+    case PENDING:
+      {
+        // We're emitting a placeholder for this segment to be filled in later.
+        // Therefore we'll need to assign it an ID - to refer to it by.
+        segment.id = request.nextSegmentId++; // Fallthrough
+      }
+
+    case POSTPONED:
+      {
+        const segmentID = segment.id; // When this segment finally completes it won't be embedded in text since it will flush separately
+
+        segment.lastPushedText = false;
+        segment.textEmbedded = false;
+        return writePlaceholder(destination, request.renderState, segmentID);
+      }
+
+    case COMPLETED:
+      {
+        segment.status = FLUSHED;
+        let r = true;
+        const chunks = segment.chunks;
+        let chunkIdx = 0;
+        const children = segment.children;
+
+        for (let childIdx = 0; childIdx < children.length; childIdx++) {
+          const nextChild = children[childIdx]; // Write all the chunks up until the next child.
+
+          for (; chunkIdx < nextChild.index; chunkIdx++) {
+            writeChunk(destination, chunks[chunkIdx]);
+          }
+
+          r = flushSegment(request, destination, nextChild);
+        } // Finally just write all the remaining chunks
+
+
+        for (; chunkIdx < chunks.length - 1; chunkIdx++) {
+          writeChunk(destination, chunks[chunkIdx]);
+        }
+
+        if (chunkIdx < chunks.length) {
+          r = writeChunkAndReturn(destination, chunks[chunkIdx]);
+        }
+
+        return r;
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(390));
+      }
+  }
+}
+
+function flushSegment(request, destination, segment) {
+  const boundary = segment.boundary;
+
+  if (boundary === null) {
+    // Not a suspense boundary.
+    return flushSubtree(request, destination, segment);
+  }
+
+  boundary.parentFlushed = true; // This segment is a Suspense boundary. We need to decide whether to
+  // emit the content or the fallback now.
+
+  if (boundary.status === CLIENT_RENDERED) {
+    // Emit a client rendered suspense boundary wrapper.
+    // We never queue the inner boundary so we'll never emit its content or partial segments.
+    writeStartClientRenderedSuspenseBoundary(destination, request.renderState, boundary.errorDigest); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndClientRenderedSuspenseBoundary(destination);
+  } else if (boundary.status !== COMPLETED) {
+    if (boundary.status === PENDING) {
+      // For pending boundaries we lazily assign an ID to the boundary
+      // and root segment.
+      boundary.rootSegmentID = request.nextSegmentId++;
+    }
+
+    if (boundary.completedSegments.length > 0) {
+      // If this is at least partially complete, we can queue it to be partially emitted early.
+      request.partialBoundaries.push(boundary);
+    } // This boundary is still loading. Emit a pending suspense boundary wrapper.
+
+
+    const id = boundary.rootSegmentID;
+    writeStartPendingSuspenseBoundary(destination, request.renderState, id); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else if (boundary.byteSize > request.progressiveChunkSize) {
+    // This boundary is large and will be emitted separately so that we can progressively show
+    // other content. We add it to the queue during the flush because we have to ensure that
+    // the parent flushes first so that there's something to inject it into.
+    // We also have to make sure that it's emitted into the queue in a deterministic slot.
+    // I.e. we can't insert it here when it completes.
+    // Assign an ID to refer to the future content by.
+    boundary.rootSegmentID = request.nextSegmentId++;
+    request.completedBoundaries.push(boundary); // Emit a pending rendered suspense boundary wrapper.
+
+    writeStartPendingSuspenseBoundary(destination, request.renderState, boundary.rootSegmentID); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else {
+    {
+      hoistResources(request.renderState, boundary.resources);
+    } // We can inline this boundary's content as a complete boundary.
+
+
+    writeStartCompletedSuspenseBoundary(destination);
+    const completedSegments = boundary.completedSegments;
+
+    if (completedSegments.length !== 1) {
+      throw Error(formatProdErrorMessage(391));
+    }
+
+    const contentSegment = completedSegments[0];
+    flushSegment(request, destination, contentSegment);
+    return writeEndCompletedSuspenseBoundary(destination);
+  }
+}
+
+function flushClientRenderedBoundary(request, destination, boundary) {
+  return writeClientRenderBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.errorDigest, boundary.errorMessage, boundary.errorComponentStack);
+}
+
+function flushSegmentContainer(request, destination, segment) {
+  writeStartSegment(destination, request.renderState, segment.parentFormatContext, segment.id);
+  flushSegment(request, destination, segment);
+  return writeEndSegment(destination, segment.parentFormatContext);
+}
+
+function flushCompletedBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+    flushPartiallyCompletedSegment(request, destination, boundary, segment);
+  }
+
+  completedSegments.length = 0;
+
+  {
+    writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+
+  return writeCompletedBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.resources);
+}
+
+function flushPartialBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+
+    if (!flushPartiallyCompletedSegment(request, destination, boundary, segment)) {
+      i++;
+      completedSegments.splice(0, i); // Only write as much as the buffer wants. Something higher priority
+      // might want to write later.
+
+      return false;
+    }
+  }
+
+  completedSegments.splice(0, i);
+
+  {
+    // The way this is structured we only write resources for partial boundaries
+    // if there is no backpressure. Later before we complete the boundary we
+    // will write resources regardless of backpressure before we emit the
+    // completion instruction
+    return writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+}
+
+function flushPartiallyCompletedSegment(request, destination, boundary, segment) {
+  if (segment.status === FLUSHED) {
+    // We've already flushed this inline.
+    return true;
+  }
+
+  const segmentID = segment.id;
+
+  if (segmentID === -1) {
+    // This segment wasn't previously referred to. This happens at the root of
+    // a boundary. We make kind of a leap here and assume this is the root.
+    const rootSegmentID = segment.id = boundary.rootSegmentID;
+
+    if (rootSegmentID === -1) {
+      throw Error(formatProdErrorMessage(392));
+    }
+
+    return flushSegmentContainer(request, destination, segment);
+  } else if (segmentID === boundary.rootSegmentID) {
+    // When we emit postponed boundaries, we might have assigned the ID already
+    // but it's still the root segment so we can't inject it into the parent yet.
+    return flushSegmentContainer(request, destination, segment);
+  } else {
+    flushSegmentContainer(request, destination, segment);
+    return writeCompletedSegmentInstruction(destination, request.resumableState, request.renderState, segmentID);
+  }
+}
+
+function flushCompletedQueues(request, destination) {
+  beginWriting();
+
+  try {
+    // The structure of this is to go through each queue one by one and write
+    // until the sink tells us to stop. When we should stop, we still finish writing
+    // that item fully and then yield. At that point we remove the already completed
+    // items up until the point we completed them.
+    let i;
+    const completedRootSegment = request.completedRootSegment;
+
+    if (completedRootSegment !== null) {
+      if (completedRootSegment.status === POSTPONED) {
+        // We postponed the root, so we write nothing.
+        return;
+      } else if (request.pendingRootTasks === 0) {
+        if (enableFloat) {
+          writePreamble(destination, request.resumableState, request.renderState, request.allPendingTasks === 0 && request.trackedPostpones === null);
+        }
+
+        flushSegment(request, destination, completedRootSegment);
+        request.completedRootSegment = null;
+        writeCompletedRoot(destination, request.renderState, request.resumableState);
+      } else {
+        // We haven't flushed the root yet so we don't need to check any other branches further down
+        return;
+      }
+    }
+
+    if (enableFloat) {
+      writeHoistables(destination, request.resumableState, request.renderState);
+    } // We emit client rendering instructions for already emitted boundaries first.
+    // This is so that we can signal to the client to start client rendering them as
+    // soon as possible.
+
+
+    const clientRenderedBoundaries = request.clientRenderedBoundaries;
+
+    for (i = 0; i < clientRenderedBoundaries.length; i++) {
+      const boundary = clientRenderedBoundaries[i];
+
+      if (!flushClientRenderedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        clientRenderedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    clientRenderedBoundaries.splice(0, i); // Next we emit any complete boundaries. It's better to favor boundaries
+    // that are completely done since we can actually show them, than it is to emit
+    // any individual segments from a partially complete boundary.
+
+    const completedBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < completedBoundaries.length; i++) {
+      const boundary = completedBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        completedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    completedBoundaries.splice(0, i); // Allow anything written so far to flush to the underlying sink before
+    // we continue with lower priorities.
+
+    completeWriting(destination);
+    beginWriting(destination); // TODO: Here we'll emit data used by hydration.
+    // Next we emit any segments of any boundaries that are partially complete
+    // but not deeply complete.
+
+    const partialBoundaries = request.partialBoundaries;
+
+    for (i = 0; i < partialBoundaries.length; i++) {
+      const boundary = partialBoundaries[i];
+
+      if (!flushPartialBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        partialBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    partialBoundaries.splice(0, i); // Next we check the completed boundaries again. This may have had
+    // boundaries added to it in case they were too larged to be inlined.
+    // New ones might be added in this loop.
+
+    const largeBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < largeBoundaries.length; i++) {
+      const boundary = largeBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        largeBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    largeBoundaries.splice(0, i);
+  } finally {
+    if (request.allPendingTasks === 0 && request.pingedTasks.length === 0 && request.clientRenderedBoundaries.length === 0 && request.completedBoundaries.length === 0 // We don't need to check any partially completed segments because
+    // either they have pending task or they're complete.
+    ) {
+        request.flushScheduled = false;
+
+        {
+          // We write the trailing tags but only if don't have any data to resume.
+          // If we need to resume we'll write the postamble in the resume instead.
+          {
+            writePostamble(destination, request.resumableState);
+          }
+        }
+
+        completeWriting(destination);
+
+
+        close(destination); // We need to stop flowing now because we do not want any async contexts which might call
+        // float methods to initiate any flushes after this point
+
+        stopFlowing(request);
+      } else {
+      completeWriting(destination);
+    }
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  {
+    scheduleWork(() => performWork(request));
+  }
+
+  if (request.trackedPostpones === null) {
+    // this is either a regular render or a resume. For regular render we want
+    // to call emitEarlyPreloads after the first performWork because we want
+    // are responding to a live request and need to balance sending something early
+    // (i.e. don't want for the shell to finish) but we need something to send.
+    // The only implementation of this is for DOM at the moment and during resumes nothing
+    // actually emits but the code paths here are the same.
+    // During a prerender we don't want to be too aggressive in emitting early preloads
+    // because we aren't responding to a live request and we can wait for the prerender to
+    // postpone before we emit anything.
+    {
+      scheduleWork(() => enqueueEarlyPreloadsAfterInitialWork(request));
+    }
+  }
+}
+
+function enqueueEarlyPreloadsAfterInitialWork(request) {
+  const shellComplete = request.pendingRootTasks === 0;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    request.flushScheduled = true;
+    scheduleWork(() => {
+      // We need to existence check destination again here because it might go away
+      // in between the enqueueFlush call and the work execution
+      const destination = request.destination;
+
+      if (destination) {
+        flushCompletedQueues(request, destination);
+      } else {
+        request.flushScheduled = false;
+      }
+    });
+  }
+} // This function is intented to only be called during the pipe function for the Node builds.
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedQueues(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function stopFlowing(request) {
+  request.destination = null;
+} // This is called to early terminate a request. It puts all pending boundaries in client rendered state.
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      const error = reason === undefined ? Error(formatProdErrorMessage(432)) : reason;
+      abortableTasks.forEach(task => abortTask(task, request, error));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function flushResources(request) {
+  enqueueFlush(request);
+}
+function getFormState(request) {
+  return request.formState;
+}
+function getResumableState(request) {
+  return request.resumableState;
+}
+function getRenderState(request) {
+  return request.renderState;
+}
+
+function renderToReadableStream(children, options) {
+  return new Promise((resolve, reject) => {
+    let onFatalError;
+    let onAllReady;
+    const allReady = new Promise((res, rej) => {
+      onAllReady = res;
+      onFatalError = rej;
+    });
+
+    function onShellReady() {
+      const stream = new ReadableStream({
+        type: 'bytes',
+        pull: controller => {
+          startFlowing(request, controller);
+        },
+        cancel: reason => {
+          stopFlowing(request);
+          abort(request, reason);
+        }
+      }, // $FlowFixMe[prop-missing] size() methods are not allowed on byte streams.
+      {
+        highWaterMark: 0
+      }); // TODO: Move to sub-classing ReadableStream.
+
+      stream.allReady = allReady;
+      resolve(stream);
+    }
+
+    function onShellError(error) {
+      // If the shell errors the caller of `renderToReadableStream` won't have access to `allReady`.
+      // However, `allReady` will be rejected by `onFatalError` as well.
+      // So we need to catch the duplicate, uncatchable fatal error in `allReady` to prevent a `UnhandledPromiseRejection`.
+      allReady.catch(() => {});
+      reject(error);
+    }
+
+    const onHeaders = options ? options.onHeaders : undefined;
+    let onHeadersImpl;
+
+    if (onHeaders) {
+      onHeadersImpl = headersDescriptor => {
+        onHeaders(new Headers(headersDescriptor));
+      };
+    }
+
+    const resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined);
+    const request = createRequest(children, resumableState, createRenderState(resumableState, options ? options.nonce : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, onHeadersImpl, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, onShellReady, onShellError, onFatalError, options ? options.onPostpone : undefined, options ? options.formState : undefined);
+
+    if (options && options.signal) {
+      const signal = options.signal;
+
+      if (signal.aborted) {
+        abort(request, signal.reason);
+      } else {
+        const listener = () => {
+          abort(request, signal.reason);
+          signal.removeEventListener('abort', listener);
+        };
+
+        signal.addEventListener('abort', listener);
+      }
+    }
+
+    startWork(request);
+  });
+}
+
+exports.renderToReadableStream = renderToReadableStream;
+exports.version = ReactVersion;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom-server.browser.production.min.js b/packages/next/src/compiled/react-dom/cjs/react-dom-server.browser.production.min.js
index c444836796320..4bd43716a27fd 100644
--- a/packages/next/src/compiled/react-dom/cjs/react-dom-server.browser.production.min.js
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom-server.browser.production.min.js
@@ -1,13 +1,11 @@
-/**
- * @license React
- * react-dom-server.browser.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
 /*
+ React
+ react-dom-server.browser.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
 
 
  JS Implementation of MurmurHash3 (r136) (as of May 20, 2011)
@@ -33,8 +31,8 @@
 */
 'use strict';var aa=require("next/dist/compiled/react"),ba=require("react-dom");function k(a){for(var b="https://reactjs.org/docs/error-decoder.html?invariant="+a,c=1;c<arguments.length;c++)b+="&args[]="+encodeURIComponent(arguments[c]);return"Minified React error #"+a+"; visit "+b+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}
 function ca(a,b){var c=a.length&3;var d=a.length-c;var e=b;for(b=0;b<d;){var f=a.charCodeAt(b)&255|(a.charCodeAt(++b)&255)<<8|(a.charCodeAt(++b)&255)<<16|(a.charCodeAt(++b)&255)<<24;++b;f=3432918353*(f&65535)+((3432918353*(f>>>16)&65535)<<16)&4294967295;f=f<<15|f>>>17;f=461845907*(f&65535)+((461845907*(f>>>16)&65535)<<16)&4294967295;e^=f;e=e<<13|e>>>19;e=5*(e&65535)+((5*(e>>>16)&65535)<<16)&4294967295;e=(e&65535)+27492+(((e>>>16)+58964&65535)<<16)}f=0;switch(c){case 3:f^=(a.charCodeAt(b+2)&255)<<
-16;case 2:f^=(a.charCodeAt(b+1)&255)<<8;case 1:f^=a.charCodeAt(b)&255,f=3432918353*(f&65535)+((3432918353*(f>>>16)&65535)<<16)&4294967295,f=f<<15|f>>>17,e^=461845907*(f&65535)+((461845907*(f>>>16)&65535)<<16)&4294967295}e^=a.length;e^=e>>>16;e=2246822507*(e&65535)+((2246822507*(e>>>16)&65535)<<16)&4294967295;e^=e>>>13;e=3266489909*(e&65535)+((3266489909*(e>>>16)&65535)<<16)&4294967295;return(e^e>>>16)>>>0}var m=null,r=0;
-function v(a,b){if(0!==b.byteLength)if(512<b.byteLength)0<r&&(a.enqueue(new Uint8Array(m.buffer,0,r)),m=new Uint8Array(512),r=0),a.enqueue(b);else{var c=m.length-r;c<b.byteLength&&(0===c?a.enqueue(m):(m.set(b.subarray(0,c),r),a.enqueue(m),b=b.subarray(c)),m=new Uint8Array(512),r=0);m.set(b,r);r+=b.byteLength}}function w(a,b){v(a,b);return!0}function ea(a){m&&0<r&&(a.enqueue(new Uint8Array(m.buffer,0,r)),m=null,r=0)}var fa=new TextEncoder;function x(a){return fa.encode(a)}
+16;case 2:f^=(a.charCodeAt(b+1)&255)<<8;case 1:f^=a.charCodeAt(b)&255,f=3432918353*(f&65535)+((3432918353*(f>>>16)&65535)<<16)&4294967295,f=f<<15|f>>>17,e^=461845907*(f&65535)+((461845907*(f>>>16)&65535)<<16)&4294967295}e^=a.length;e^=e>>>16;e=2246822507*(e&65535)+((2246822507*(e>>>16)&65535)<<16)&4294967295;e^=e>>>13;e=3266489909*(e&65535)+((3266489909*(e>>>16)&65535)<<16)&4294967295;return(e^e>>>16)>>>0}var m=null,q=0;
+function v(a,b){if(0!==b.byteLength)if(512<b.byteLength)0<q&&(a.enqueue(new Uint8Array(m.buffer,0,q)),m=new Uint8Array(512),q=0),a.enqueue(b);else{var c=m.length-q;c<b.byteLength&&(0===c?a.enqueue(m):(m.set(b.subarray(0,c),q),a.enqueue(m),b=b.subarray(c)),m=new Uint8Array(512),q=0);m.set(b,q);q+=b.byteLength}}function w(a,b){v(a,b);return!0}function ea(a){m&&0<q&&(a.enqueue(new Uint8Array(m.buffer,0,q)),m=null,q=0)}var fa=new TextEncoder;function x(a){return fa.encode(a)}
 function y(a){return fa.encode(a)}function ka(a,b){"function"===typeof a.error?a.error(b):a.close()}
 var z=Object.assign,D=Object.prototype.hasOwnProperty,la=RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"),qa={},ra={};
 function xa(a){if(D.call(ra,a))return!0;if(D.call(qa,a))return!1;if(la.test(a))return ra[a]=!0;qa[a]=!0;return!1}
@@ -48,12 +46,12 @@ new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv","http
 function G(a){if("boolean"===typeof a||"number"===typeof a)return""+a;a=""+a;var b=Ga.exec(a);if(b){var c="",d,e=0;for(d=b.index;d<a.length;d++){switch(a.charCodeAt(d)){case 34:b="&quot;";break;case 38:b="&amp;";break;case 39:b="&#x27;";break;case 60:b="&lt;";break;case 62:b="&gt;";break;default:continue}e!==d&&(c+=a.slice(e,d));e=d+1;c+=b}a=e!==d?c+a.slice(e,d):c}return a}
 var Ha=/([A-Z])/g,Ia=/^ms-/,Ja=Array.isArray,Ka=aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,La={pending:!1,data:null,method:null,action:null},Sa=ba.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Dispatcher,$a={prefetchDNS:Ta,preconnect:Ua,preload:Va,preloadModule:Wa,preinitStyle:Xa,preinitScript:Ya,preinitModuleScript:Za},K=[],ab=y('"></template>'),ob=y("<script>"),pb=y("\x3c/script>"),qb=y('<script src="'),rb=y('<script type="module" src="'),sb=y('" nonce="'),tb=y('" integrity="'),
 ub=y('" crossorigin="'),vb=y('" async="">\x3c/script>'),wb=/(<\/|<)(s)(cript)/gi;function xb(a,b,c,d){return""+b+("s"===c?"\\u0073":"\\u0053")+d}var yb=y('<script type="importmap">'),Hb=y("\x3c/script>");
-function Ib(a,b,c,d,e,f,g,h,l){var n=void 0===b?ob:y('<script nonce="'+G(b)+'">'),p=a.idPrefix,t=[],q=null;void 0!==c&&t.push(n,x((""+c).replace(wb,xb)),pb);void 0!==f&&("string"===typeof f?(q={src:f,chunks:[]},Jb(q.chunks,{src:f,async:!0,integrity:void 0,nonce:b})):(q={src:f.src,chunks:[]},Jb(q.chunks,{src:f.src,async:!0,integrity:f.integrity,nonce:b})));c=[];void 0!==g&&(c.push(yb),c.push(x((""+JSON.stringify(g)).replace(wb,xb))),c.push(Hb));g=h?{preconnects:"",fontPreloads:"",highImagePreloads:"",
-remainingCapacity:"number"===typeof l?l:2E3}:null;h={placeholderPrefix:y(p+"P:"),segmentPrefix:y(p+"S:"),boundaryPrefix:y(p+"B:"),startInlineScript:n,htmlChunks:null,headChunks:null,externalRuntimeScript:q,bootstrapChunks:t,onHeaders:h,headers:g,resets:{font:{},dns:{},connect:{default:{},anonymous:{},credentials:{}},image:{},style:{}},charsetChunks:[],preconnectChunks:[],importMapChunks:c,preloadChunks:[],hoistableChunks:[],preconnects:new Set,fontPreloads:new Set,highImagePreloads:new Set,styles:new Map,
-bootstrapScripts:new Set,scripts:new Set,bulkPreloads:new Set,preloads:{images:new Map,stylesheets:new Map,scripts:new Map,moduleScripts:new Map},nonce:b,boundaryResources:null,stylesToHoist:!1};if(void 0!==d)for(n=0;n<d.length;n++)c=d[n],g=q=void 0,l={rel:"preload",as:"script",fetchPriority:"low",nonce:b},"string"===typeof c?l.href=p=c:(l.href=p=c.src,l.integrity=g="string"===typeof c.integrity?c.integrity:void 0,l.crossOrigin=q="string"===typeof c||null==c.crossOrigin?void 0:"use-credentials"===
-c.crossOrigin?"use-credentials":""),c=a,f=p,c.scriptResources[f]=null,c.moduleScriptResources[f]=null,c=[],L(c,l),h.bootstrapScripts.add(c),t.push(qb,x(G(p))),b&&t.push(sb,x(G(b))),"string"===typeof g&&t.push(tb,x(G(g))),"string"===typeof q&&t.push(ub,x(G(q))),t.push(vb);if(void 0!==e)for(d=0;d<e.length;d++)l=e[d],q=p=void 0,g={rel:"modulepreload",fetchPriority:"low",nonce:b},"string"===typeof l?g.href=n=l:(g.href=n=l.src,g.integrity=q="string"===typeof l.integrity?l.integrity:void 0,g.crossOrigin=
-p="string"===typeof l||null==l.crossOrigin?void 0:"use-credentials"===l.crossOrigin?"use-credentials":""),l=a,c=n,l.scriptResources[c]=null,l.moduleScriptResources[c]=null,l=[],L(l,g),h.bootstrapScripts.add(l),t.push(rb,x(G(n))),b&&t.push(sb,x(G(b))),"string"===typeof q&&t.push(tb,x(G(q))),"string"===typeof p&&t.push(ub,x(G(p))),t.push(vb);return h}
-function Kb(a,b){var c=0;void 0!==b&&(c=1);return{idPrefix:void 0===a?"":a,nextFormID:0,streamingFormat:c,instructions:0,hasBody:!1,hasHtml:!1,unknownResources:{},dnsResources:{},connectResources:{default:{},anonymous:{},credentials:{}},imageResources:{},styleResources:{},scriptResources:{},moduleUnknownResources:{},moduleScriptResources:{}}}function N(a,b,c){return{insertionMode:a,selectedValue:b,tagScope:c}}
+function Ib(a,b,c,d,e,f){var g=void 0===b?ob:y('<script nonce="'+G(b)+'">'),h=a.idPrefix,l=[],n=null,p=a.bootstrapScriptContent,t=a.bootstrapScripts,r=a.bootstrapModules;void 0!==p&&l.push(g,x((""+p).replace(wb,xb)),pb);void 0!==c&&("string"===typeof c?(n={src:c,chunks:[]},Jb(n.chunks,{src:c,async:!0,integrity:void 0,nonce:b})):(n={src:c.src,chunks:[]},Jb(n.chunks,{src:c.src,async:!0,integrity:c.integrity,nonce:b})));c=[];void 0!==d&&(c.push(yb),c.push(x((""+JSON.stringify(d)).replace(wb,xb))),c.push(Hb));
+d=e?{preconnects:"",fontPreloads:"",highImagePreloads:"",remainingCapacity:"number"===typeof f?f:2E3}:null;e={placeholderPrefix:y(h+"P:"),segmentPrefix:y(h+"S:"),boundaryPrefix:y(h+"B:"),startInlineScript:g,htmlChunks:null,headChunks:null,externalRuntimeScript:n,bootstrapChunks:l,onHeaders:e,headers:d,resets:{font:{},dns:{},connect:{default:{},anonymous:{},credentials:{}},image:{},style:{}},charsetChunks:[],preconnectChunks:[],importMapChunks:c,preloadChunks:[],hoistableChunks:[],preconnects:new Set,
+fontPreloads:new Set,highImagePreloads:new Set,styles:new Map,bootstrapScripts:new Set,scripts:new Set,bulkPreloads:new Set,preloads:{images:new Map,stylesheets:new Map,scripts:new Map,moduleScripts:new Map},nonce:b,boundaryResources:null,stylesToHoist:!1};if(void 0!==t)for(g=0;g<t.length;g++)c=t[g],d=n=void 0,f={rel:"preload",as:"script",fetchPriority:"low",nonce:b},"string"===typeof c?f.href=h=c:(f.href=h=c.src,f.integrity=d="string"===typeof c.integrity?c.integrity:void 0,f.crossOrigin=n="string"===
+typeof c||null==c.crossOrigin?void 0:"use-credentials"===c.crossOrigin?"use-credentials":""),c=a,p=h,c.scriptResources[p]=null,c.moduleScriptResources[p]=null,c=[],L(c,f),e.bootstrapScripts.add(c),l.push(qb,x(G(h))),b&&l.push(sb,x(G(b))),"string"===typeof d&&l.push(tb,x(G(d))),"string"===typeof n&&l.push(ub,x(G(n))),l.push(vb);if(void 0!==r)for(t=0;t<r.length;t++)f=r[t],n=h=void 0,d={rel:"modulepreload",fetchPriority:"low",nonce:b},"string"===typeof f?d.href=g=f:(d.href=g=f.src,d.integrity=n="string"===
+typeof f.integrity?f.integrity:void 0,d.crossOrigin=h="string"===typeof f||null==f.crossOrigin?void 0:"use-credentials"===f.crossOrigin?"use-credentials":""),f=a,c=g,f.scriptResources[c]=null,f.moduleScriptResources[c]=null,f=[],L(f,d),e.bootstrapScripts.add(f),l.push(rb,x(G(g))),b&&l.push(sb,x(G(b))),"string"===typeof n&&l.push(tb,x(G(n))),"string"===typeof h&&l.push(ub,x(G(h))),l.push(vb);return e}
+function Kb(a,b,c,d,e){var f=0;void 0!==b&&(f=1);return{idPrefix:void 0===a?"":a,nextFormID:0,streamingFormat:f,bootstrapScriptContent:c,bootstrapScripts:d,bootstrapModules:e,instructions:0,hasBody:!1,hasHtml:!1,unknownResources:{},dnsResources:{},connectResources:{default:{},anonymous:{},credentials:{}},imageResources:{},styleResources:{},scriptResources:{},moduleUnknownResources:{},moduleScriptResources:{}}}function N(a,b,c){return{insertionMode:a,selectedValue:b,tagScope:c}}
 function Lb(a){return N("http://www.w3.org/2000/svg"===a?3:"http://www.w3.org/1998/Math/MathML"===a?4:0,null,0)}
 function Mb(a,b,c){switch(b){case "noscript":return N(2,null,a.tagScope|1);case "select":return N(2,null!=c.value?c.value:c.defaultValue,a.tagScope);case "svg":return N(3,null,a.tagScope);case "picture":return N(2,null,a.tagScope|2);case "math":return N(4,null,a.tagScope);case "foreignObject":return N(2,null,a.tagScope);case "table":return N(5,null,a.tagScope);case "thead":case "tbody":case "tfoot":return N(6,null,a.tagScope);case "colgroup":return N(8,null,a.tagScope);case "tr":return N(7,null,a.tagScope)}return 5<=
 a.insertionMode?N(2,null,a.tagScope):0===a.insertionMode?"html"===b?N(1,null,a.tagScope):N(2,null,a.tagScope):1===a.insertionMode?N(2,null,a.tagScope):a}var Nb=y("\x3c!-- --\x3e");function Ob(a,b,c,d){if(""===b)return d;d&&a.push(Nb);a.push(x(G(b)));return!0}var Pb=new Map,Qb=y(' style="'),Rb=y(":"),Sb=y(";");
@@ -72,8 +70,8 @@ b)}}function L(a,b){a.push(V("link"));for(var c in b)if(D.call(b,c)){var d=b[c];
 function wc(a,b){a.push(V("title"));var c=null,d=null,e;for(e in b)if(D.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:R(a,e,f)}}a.push(S);b=Array.isArray(c)?2>c.length?c[0]:null:c;"function"!==typeof b&&"symbol"!==typeof b&&null!==b&&void 0!==b&&a.push(x(G(""+b)));ec(a,d,c);a.push(xc("title"));return null}
 function Jb(a,b){a.push(V("script"));var c=null,d=null,e;for(e in b)if(D.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:R(a,e,f)}}a.push(S);ec(a,d,c);"string"===typeof c&&a.push(x(G(c)));a.push(xc("script"));return null}
 function yc(a,b,c){a.push(V(c));var d=c=null,e;for(e in b)if(D.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:R(a,e,f)}}a.push(S);ec(a,d,c);return"string"===typeof c?(a.push(x(G(c))),null):c}var zc=y("\n"),Ac=/^[a-zA-Z][a-zA-Z:_\.\-\d]*$/,Bc=new Map;function V(a){var b=Bc.get(a);if(void 0===b){if(!Ac.test(a))throw Error(k(65,a));b=y("<"+a);Bc.set(a,b)}return b}var Cc=y("<!DOCTYPE html>");
-function Dc(a,b,c,d,e,f,g){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "select":a.push(V("select"));var h=null,l=null,n;for(n in c)if(D.call(c,n)){var p=c[n];if(null!=p)switch(n){case "children":h=p;break;case "dangerouslySetInnerHTML":l=p;break;case "defaultValue":case "value":break;default:R(a,n,p)}}a.push(S);ec(a,l,h);return h;case "option":var t=f.selectedValue;a.push(V("option"));var q=null,A=null,B=null,T=null,u;for(u in c)if(D.call(c,
-u)){var C=c[u];if(null!=C)switch(u){case "children":q=C;break;case "selected":B=C;break;case "dangerouslySetInnerHTML":T=C;break;case "value":A=C;default:R(a,u,C)}}if(null!=t){var H=null!==A?""+A:fc(q);if(Ja(t))for(var ma=0;ma<t.length;ma++){if(""+t[ma]===H){a.push(gc);break}}else""+t===H&&a.push(gc)}else B&&a.push(gc);a.push(S);ec(a,T,q);return q;case "textarea":a.push(V("textarea"));var E=null,Y=null,F=null,ha;for(ha in c)if(D.call(c,ha)){var U=c[ha];if(null!=U)switch(ha){case "children":F=U;break;
+function Dc(a,b,c,d,e,f,g){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "select":a.push(V("select"));var h=null,l=null,n;for(n in c)if(D.call(c,n)){var p=c[n];if(null!=p)switch(n){case "children":h=p;break;case "dangerouslySetInnerHTML":l=p;break;case "defaultValue":case "value":break;default:R(a,n,p)}}a.push(S);ec(a,l,h);return h;case "option":var t=f.selectedValue;a.push(V("option"));var r=null,A=null,B=null,T=null,u;for(u in c)if(D.call(c,
+u)){var C=c[u];if(null!=C)switch(u){case "children":r=C;break;case "selected":B=C;break;case "dangerouslySetInnerHTML":T=C;break;case "value":A=C;default:R(a,u,C)}}if(null!=t){var H=null!==A?""+A:fc(r);if(Ja(t))for(var ma=0;ma<t.length;ma++){if(""+t[ma]===H){a.push(gc);break}}else""+t===H&&a.push(gc)}else B&&a.push(gc);a.push(S);ec(a,T,r);return r;case "textarea":a.push(V("textarea"));var E=null,Y=null,F=null,ha;for(ha in c)if(D.call(c,ha)){var U=c[ha];if(null!=U)switch(ha){case "children":F=U;break;
 case "value":E=U;break;case "defaultValue":Y=U;break;case "dangerouslySetInnerHTML":throw Error(k(91));default:R(a,ha,U)}}null===E&&null!==Y&&(E=Y);a.push(S);if(null!=F){if(null!=E)throw Error(k(92));if(Ja(F)){if(1<F.length)throw Error(k(93));E=""+F[0]}E=""+F}"string"===typeof E&&"\n"===E[0]&&a.push(zc);null!==E&&a.push(x(G(""+E)));return null;case "input":a.push(V("input"));var na=null,Q=null,I=null,oa=null,Aa=null,sa=null,ta=null,ua=null,Ma=null,ia;for(ia in c)if(D.call(c,ia)){var da=c[ia];if(null!=
 da)switch(ia){case "children":case "dangerouslySetInnerHTML":throw Error(k(399,"input"));case "name":na=da;break;case "formAction":Q=da;break;case "formEncType":I=da;break;case "formMethod":oa=da;break;case "formTarget":Aa=da;break;case "defaultChecked":Ma=da;break;case "defaultValue":ta=da;break;case "checked":ua=da;break;case "value":sa=da;break;default:R(a,ia,da)}}var od=cc(a,d,e,Q,I,oa,Aa,na);null!==ua?Xb(a,"checked",ua):null!==Ma&&Xb(a,"checked",Ma);null!==sa?R(a,"value",sa):null!==ta&&R(a,"value",
 ta);a.push(bc);null!==od&&od.forEach(ac,a);return null;case "button":a.push(V("button"));var bb=null,pd=null,qd=null,rd=null,sd=null,td=null,ud=null,cb;for(cb in c)if(D.call(c,cb)){var pa=c[cb];if(null!=pa)switch(cb){case "children":bb=pa;break;case "dangerouslySetInnerHTML":pd=pa;break;case "name":qd=pa;break;case "formAction":rd=pa;break;case "formEncType":sd=pa;break;case "formMethod":td=pa;break;case "formTarget":ud=pa;break;default:R(a,cb,pa)}}var vd=cc(a,d,e,rd,sd,td,ud,qd);a.push(S);null!==
@@ -90,8 +88,8 @@ e.highImagePreloads.add(Ea)}else if(!d.imageResources.hasOwnProperty(Qa)){d.imag
 rc.length))?(e.resets.image[Qa]=K,ja.highImagePreloads&&(ja.highImagePreloads+=", "),ja.highImagePreloads+=rc):(Ea=[],L(Ea,{rel:"preload",as:"image",href:J?void 0:M,imageSrcSet:J,imageSizes:Kd,crossOrigin:Ld,integrity:c.integrity,type:c.type,fetchPriority:c.fetchPriority,referrerPolicy:c.referrerPolicy}),"high"===c.fetchPriority||10>e.highImagePreloads.size?e.highImagePreloads.add(Ea):(e.bulkPreloads.add(Ea),pc.set(Qa,Ea)))}}return vc(a,c,"img");case "base":case "area":case "br":case "col":case "embed":case "hr":case "keygen":case "param":case "source":case "track":case "wbr":return vc(a,
 c,b);case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph":break;case "head":if(2>f.insertionMode&&null===e.headChunks){e.headChunks=[];var Md=yc(e.headChunks,c,"head")}else Md=yc(a,c,"head");return Md;case "html":if(0===f.insertionMode&&null===e.htmlChunks){e.htmlChunks=[Cc];var Nd=yc(e.htmlChunks,c,"html")}else Nd=yc(a,c,"html");return Nd;default:if(-1!==b.indexOf("-")){a.push(V(b));
 var sc=null,Od=null,Ra;for(Ra in c)if(D.call(c,Ra)){var Fa=c[Ra];if(null!=Fa){var nf=Ra;switch(Ra){case "children":sc=Fa;break;case "dangerouslySetInnerHTML":Od=Fa;break;case "style":Tb(a,Fa);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":break;default:xa(Ra)&&"function"!==typeof Fa&&"symbol"!==typeof Fa&&a.push(O,x(nf),Vb,x(G(Fa)),Ub)}}}a.push(S);ec(a,Od,sc);return sc}}return yc(a,c,b)}var Fc=new Map;
-function xc(a){var b=Fc.get(a);void 0===b&&(b=y("</"+a+">"),Fc.set(a,b));return b}function Gc(a,b){b=b.bootstrapChunks;for(var c=0;c<b.length-1;c++)v(a,b[c]);return c<b.length?(c=b[c],b.length=0,w(a,c)):!0}var Hc=y('<template id="'),Ic=y('"></template>'),Jc=y("\x3c!--$--\x3e"),Kc=y('\x3c!--$?--\x3e<template id="'),Lc=y('"></template>'),Mc=y("\x3c!--$!--\x3e"),Nc=y("\x3c!--/$--\x3e"),Oc=y("<template"),Pc=y('"'),Qc=y(' data-dgst="');y(' data-msg="');y(' data-stck="');var Rc=y("></template>");
-function Sc(a,b,c){v(a,Kc);if(null===c)throw Error(k(395));v(a,b.boundaryPrefix);v(a,x(c.toString(16)));return w(a,Lc)}
+function xc(a){var b=Fc.get(a);void 0===b&&(b=y("</"+a+">"),Fc.set(a,b));return b}function Gc(a,b,c){c.bootstrapScriptContent=void 0;c.bootstrapScripts=void 0;c.bootstrapModules=void 0;b=b.bootstrapChunks;for(c=0;c<b.length-1;c++)v(a,b[c]);return c<b.length?(c=b[c],b.length=0,w(a,c)):!0}var Hc=y('<template id="'),Ic=y('"></template>'),Jc=y("\x3c!--$--\x3e"),Kc=y('\x3c!--$?--\x3e<template id="'),Lc=y('"></template>'),Mc=y("\x3c!--$!--\x3e"),Nc=y("\x3c!--/$--\x3e"),Oc=y("<template"),Pc=y('"'),Qc=y(' data-dgst="');
+y(' data-msg="');y(' data-stck="');var Rc=y("></template>");function Sc(a,b,c){v(a,Kc);if(null===c)throw Error(k(395));v(a,b.boundaryPrefix);v(a,x(c.toString(16)));return w(a,Lc)}
 var Tc=y('<div hidden id="'),Uc=y('">'),Vc=y("</div>"),Wc=y('<svg aria-hidden="true" style="display:none" id="'),Xc=y('">'),Yc=y("</svg>"),Zc=y('<math aria-hidden="true" style="display:none" id="'),$c=y('">'),ad=y("</math>"),bd=y('<table hidden id="'),cd=y('">'),dd=y("</table>"),ed=y('<table hidden><tbody id="'),fd=y('">'),gd=y("</tbody></table>"),hd=y('<table hidden><tr id="'),id=y('">'),jd=y("</tr></table>"),kd=y('<table hidden><colgroup id="'),ld=y('">'),md=y("</colgroup></table>");
 function nd(a,b,c,d){switch(c.insertionMode){case 0:case 1:case 2:return v(a,Tc),v(a,b.segmentPrefix),v(a,x(d.toString(16))),w(a,Uc);case 3:return v(a,Wc),v(a,b.segmentPrefix),v(a,x(d.toString(16))),w(a,Xc);case 4:return v(a,Zc),v(a,b.segmentPrefix),v(a,x(d.toString(16))),w(a,$c);case 5:return v(a,bd),v(a,b.segmentPrefix),v(a,x(d.toString(16))),w(a,cd);case 6:return v(a,ed),v(a,b.segmentPrefix),v(a,x(d.toString(16))),w(a,fd);case 7:return v(a,hd),v(a,b.segmentPrefix),v(a,x(d.toString(16))),w(a,id);
 case 8:return v(a,kd),v(a,b.segmentPrefix),v(a,x(d.toString(16))),w(a,ld);default:throw Error(k(397));}}function Pd(a,b){switch(b.insertionMode){case 0:case 1:case 2:return w(a,Vc);case 3:return w(a,Yc);case 4:return w(a,ad);case 5:return w(a,dd);case 6:return w(a,gd);case 7:return w(a,jd);case 8:return w(a,md);default:throw Error(k(397));}}
@@ -146,33 +144,33 @@ function vg(){throw Error(k(394));}function wg(){throw Error(k(479));}function x
 var Bg={readContext:function(a){return a._currentValue},use:function(a){if(null!==a&&"object"===typeof a){if("function"===typeof a.then)return xg(a);if(a.$$typeof===jf||a.$$typeof===kf)return a._currentValue}throw Error(k(438,String(a)));},useContext:function(a){lg();return a._currentValue},useMemo:ug,useReducer:sg,useRef:function(a){Yf=lg();X=ng();var b=X.memoizedState;return null===b?(a={current:a},X.memoizedState=a):b},useState:function(a){return sg(rg,a)},useInsertionEffect:zg,useLayoutEffect:zg,
 useCallback:function(a,b){return ug(function(){return a},b)},useImperativeHandle:zg,useEffect:zg,useDebugValue:zg,useDeferredValue:function(a){lg();return a},useTransition:function(){lg();return[!1,vg]},useId:function(){var a=Zf.treeContext;var b=a.overflow;a=a.id;a=(a&~(1<<32-Nf(a)-1)).toString(32)+b;var c=Ag;if(null===c)throw Error(k(404));b=eg++;a=":"+c.idPrefix+"R"+a;0<b&&(a+="H"+b.toString(32));return a+":"},useSyncExternalStore:function(a,b,c){if(void 0===c)throw Error(k(407));return c()},useCacheRefresh:function(){return yg},
 useHostTransitionStatus:function(){lg();return La},useOptimistic:function(a){lg();return[a,wg]},useFormState:function(a,b,c){lg();var d=fg++,e=$f;if("function"===typeof a.$$FORM_ACTION){var f=null,g=ag;e=e.formState;var h=a.$$IS_SIGNATURE_EQUAL;if(null!==e&&"function"===typeof h){var l=e[1];h.call(a,e[2],e[3])&&(f=void 0!==c?"p"+c:"k"+ca(JSON.stringify([g,null,d]),0),l===f&&(gg=d,b=e[0]))}var n=a.bind(null,b);a=function(t){n(t)};"function"===typeof n.$$FORM_ACTION&&(a.$$FORM_ACTION=function(t){t=
-n.$$FORM_ACTION(t);void 0!==c&&(c+="",t.action=c);var q=t.data;q&&(null===f&&(f=void 0!==c?"p"+c:"k"+ca(JSON.stringify([g,null,d]),0)),q.append("$ACTION_KEY",f));return t});return[b,a]}var p=a.bind(null,b);return[b,function(t){p(t)}]}},Ag=null,Cg={getCacheSignal:function(){throw Error(k(248));},getCacheForType:function(){throw Error(k(248));}},Dg=Ka.ReactCurrentDispatcher,Eg=Ka.ReactCurrentCache;function Fg(a){console.error(a);return null}function Gg(){}
-function Hg(a,b,c,d,e,f,g,h,l,n,p,t){Sa.current=$a;var q=[],A=new Set;b={destination:null,flushScheduled:!1,resumableState:b,renderState:c,rootFormatContext:d,progressiveChunkSize:void 0===e?12800:e,status:0,fatalError:null,nextSegmentId:0,allPendingTasks:0,pendingRootTasks:0,completedRootSegment:null,abortableTasks:A,pingedTasks:q,clientRenderedBoundaries:[],completedBoundaries:[],partialBoundaries:[],trackedPostpones:null,onError:void 0===f?Fg:f,onPostpone:void 0===p?Gg:p,onAllReady:void 0===g?
-Gg:g,onShellReady:void 0===h?Gg:h,onShellError:void 0===l?Gg:l,onFatalError:void 0===n?Gg:n,formState:void 0===t?null:t};c=Ig(b,0,null,d,!1,!1);c.parentFlushed=!0;a=Jg(b,null,a,-1,null,c,A,null,d,Af,null,Lf);q.push(a);return b}var W=null;function Kg(a,b){a.pingedTasks.push(b);1===a.pingedTasks.length&&(a.flushScheduled=null!==a.destination,Lg(a))}
+n.$$FORM_ACTION(t);void 0!==c&&(c+="",t.action=c);var r=t.data;r&&(null===f&&(f=void 0!==c?"p"+c:"k"+ca(JSON.stringify([g,null,d]),0)),r.append("$ACTION_KEY",f));return t});return[b,a]}var p=a.bind(null,b);return[b,function(t){p(t)}]}},Ag=null,Cg={getCacheSignal:function(){throw Error(k(248));},getCacheForType:function(){throw Error(k(248));}},Dg=Ka.ReactCurrentDispatcher,Eg=Ka.ReactCurrentCache;function Fg(a){console.error(a);return null}function Gg(){}
+function Hg(a,b,c,d,e,f,g,h,l,n,p,t){Sa.current=$a;var r=[],A=new Set;b={destination:null,flushScheduled:!1,resumableState:b,renderState:c,rootFormatContext:d,progressiveChunkSize:void 0===e?12800:e,status:0,fatalError:null,nextSegmentId:0,allPendingTasks:0,pendingRootTasks:0,completedRootSegment:null,abortableTasks:A,pingedTasks:r,clientRenderedBoundaries:[],completedBoundaries:[],partialBoundaries:[],trackedPostpones:null,onError:void 0===f?Fg:f,onPostpone:void 0===p?Gg:p,onAllReady:void 0===g?
+Gg:g,onShellReady:void 0===h?Gg:h,onShellError:void 0===l?Gg:l,onFatalError:void 0===n?Gg:n,formState:void 0===t?null:t};c=Ig(b,0,null,d,!1,!1);c.parentFlushed=!0;a=Jg(b,null,a,-1,null,c,A,null,d,Af,null,Lf);r.push(a);return b}var W=null;function Kg(a,b){a.pingedTasks.push(b);1===a.pingedTasks.length&&(a.flushScheduled=null!==a.destination,Lg(a))}
 function Mg(a,b){return{status:0,rootSegmentID:-1,parentFlushed:!1,pendingTasks:0,completedSegments:[],byteSize:0,fallbackAbortableTasks:b,errorDigest:null,resources:{styles:new Set,stylesheets:new Set},trackedContentKeyPath:null,trackedFallbackNode:null}}
-function Jg(a,b,c,d,e,f,g,h,l,n,p,t){a.allPendingTasks++;null===e?a.pendingRootTasks++:e.pendingTasks++;var q={replay:null,node:c,childIndex:d,ping:function(){return Kg(a,q)},blockedBoundary:e,blockedSegment:f,abortSet:g,keyPath:h,formatContext:l,legacyContext:n,context:p,treeContext:t,thenableState:b};g.add(q);return q}
-function Ng(a,b,c,d,e,f,g,h,l,n,p,t){a.allPendingTasks++;null===f?a.pendingRootTasks++:f.pendingTasks++;c.pendingTasks++;var q={replay:c,node:d,childIndex:e,ping:function(){return Kg(a,q)},blockedBoundary:f,blockedSegment:null,abortSet:g,keyPath:h,formatContext:l,legacyContext:n,context:p,treeContext:t,thenableState:b};g.add(q);return q}function Ig(a,b,c,d,e,f){return{status:0,id:-1,index:b,parentFlushed:!1,chunks:[],children:[],parentFormatContext:d,boundary:c,lastPushedText:e,textEmbedded:f}}
+function Jg(a,b,c,d,e,f,g,h,l,n,p,t){a.allPendingTasks++;null===e?a.pendingRootTasks++:e.pendingTasks++;var r={replay:null,node:c,childIndex:d,ping:function(){return Kg(a,r)},blockedBoundary:e,blockedSegment:f,abortSet:g,keyPath:h,formatContext:l,legacyContext:n,context:p,treeContext:t,thenableState:b};g.add(r);return r}
+function Ng(a,b,c,d,e,f,g,h,l,n,p,t){a.allPendingTasks++;null===f?a.pendingRootTasks++:f.pendingTasks++;c.pendingTasks++;var r={replay:c,node:d,childIndex:e,ping:function(){return Kg(a,r)},blockedBoundary:f,blockedSegment:null,abortSet:g,keyPath:h,formatContext:l,legacyContext:n,context:p,treeContext:t,thenableState:b};g.add(r);return r}function Ig(a,b,c,d,e,f){return{status:0,id:-1,index:b,parentFlushed:!1,chunks:[],children:[],parentFormatContext:d,boundary:c,lastPushedText:e,textEmbedded:f}}
 function Og(a,b){a=a.onError(b);if(null!=a&&"string"!==typeof a)throw Error('onError returned something with a type other than "string". onError should return a string and may return null or undefined but must not return anything else. It received something of type "'+typeof a+'" instead');return a}function Pg(a,b){var c=a.onShellError;c(b);c=a.onFatalError;c(b);null!==a.destination?(a.status=2,ka(a.destination,b)):(a.status=1,a.fatalError=b)}
 function Qg(a,b,c,d,e){var f=d.render(),g=e.childContextTypes;if(null!==g&&void 0!==g){c=b.legacyContext;if("function"!==typeof d.getChildContext)e=c;else{d=d.getChildContext();for(var h in d)if(!(h in g))throw Error(k(108,zf(e)||"Unknown",h));e=z({},c,d)}b.legacyContext=e;Z(a,b,null,f,-1);b.legacyContext=c}else e=b.keyPath,b.keyPath=c,Z(a,b,null,f,-1),b.keyPath=e}
 function Rg(a,b,c,d,e,f,g){var h=!1;if(0!==f&&null!==a.formState){var l=b.blockedSegment;if(null!==l){h=!0;l=l.chunks;for(var n=0;n<f;n++)n===g?l.push(ic):l.push(jc)}}f=b.keyPath;b.keyPath=c;e?(c=b.treeContext,b.treeContext=Mf(c,1,0),Sg(a,b,d,-1),b.treeContext=c):h?Sg(a,b,d,-1):Z(a,b,null,d,-1);b.keyPath=f}function Tg(a,b){if(a&&a.defaultProps){b=z({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}
 function Ug(a,b,c,d,e,f,g){if("function"===typeof e)if(e.prototype&&e.prototype.isReactComponent){d=Bf(e,b.legacyContext);var h=e.contextType;h=new e(f,"object"===typeof h&&null!==h?h._currentValue:d);Kf(h,e,f,d);Qg(a,b,c,h,e)}else{h=Bf(e,b.legacyContext);Yf={};Zf=b;$f=a;ag=c;fg=eg=0;gg=-1;hg=0;ig=d;d=e(f,h);d=og(e,f,d,h);g=0!==eg;var l=fg,n=gg;"object"===typeof d&&null!==d&&"function"===typeof d.render&&void 0===d.$$typeof?(Kf(d,e,f,h),Qg(a,b,c,d,e)):Rg(a,b,c,d,g,l,n)}else if("string"===typeof e)if(d=
 b.blockedSegment,null===d)d=f.children,h=b.formatContext,g=b.keyPath,b.formatContext=Mb(h,e,f),b.keyPath=c,Sg(a,b,d,-1),b.formatContext=h,b.keyPath=g;else{g=Dc(d.chunks,e,f,a.resumableState,a.renderState,b.formatContext,d.lastPushedText);d.lastPushedText=!1;h=b.formatContext;l=b.keyPath;b.formatContext=Mb(h,e,f);b.keyPath=c;Sg(a,b,g,-1);b.formatContext=h;b.keyPath=l;a:{b=d.chunks;a=a.resumableState;switch(e){case "title":case "style":case "script":case "area":case "base":case "br":case "col":case "embed":case "hr":case "img":case "input":case "keygen":case "link":case "meta":case "param":case "source":case "track":case "wbr":break a;
 case "body":if(1>=h.insertionMode){a.hasBody=!0;break a}break;case "html":if(0===h.insertionMode){a.hasHtml=!0;break a}}b.push(xc(e))}d.lastPushedText=!1}else{switch(e){case vf:case tf:case ff:case gf:case ef:e=b.keyPath;b.keyPath=c;Z(a,b,null,f.children,-1);b.keyPath=e;return;case uf:"hidden"!==f.mode&&(e=b.keyPath,b.keyPath=c,Z(a,b,null,f.children,-1),b.keyPath=e);return;case pf:e=b.keyPath;b.keyPath=c;Z(a,b,null,f.children,-1);b.keyPath=e;return;case sf:throw Error(k(343));case of:a:if(null!==
-b.replay){e=b.keyPath;b.keyPath=c;c=f.children;try{Sg(a,b,c,-1)}finally{b.keyPath=e}}else{n=b.keyPath;e=b.blockedBoundary;var p=b.blockedSegment;d=f.fallback;var t=f.children;f=new Set;g=Mg(a,f);null!==a.trackedPostpones&&(g.trackedContentKeyPath=c);l=Ig(a,p.chunks.length,g,b.formatContext,!1,!1);p.children.push(l);p.lastPushedText=!1;var q=Ig(a,0,null,b.formatContext,!1,!1);q.parentFlushed=!0;b.blockedBoundary=g;b.blockedSegment=q;a.renderState.boundaryResources=g.resources;b.keyPath=c;try{if(Sg(a,
-b,t,-1),q.lastPushedText&&q.textEmbedded&&q.chunks.push(Nb),q.status=1,Vg(g,q),0===g.pendingTasks&&0===g.status){g.status=1;break a}}catch(A){q.status=4,g.status=4,h=Og(a,A),g.errorDigest=h}finally{a.renderState.boundaryResources=e?e.resources:null,b.blockedBoundary=e,b.blockedSegment=p,b.keyPath=n}h=[c[0],"Suspense Fallback",c[2]];n=a.trackedPostpones;null!==n&&(p=[h[1],h[2],[],null],n.workingMap.set(h,p),5===g.status?n.workingMap.get(c)[4]=p:g.trackedFallbackNode=p);b=Jg(a,null,d,-1,e,l,f,h,b.formatContext,
+b.replay){e=b.keyPath;b.keyPath=c;c=f.children;try{Sg(a,b,c,-1)}finally{b.keyPath=e}}else{n=b.keyPath;e=b.blockedBoundary;var p=b.blockedSegment;d=f.fallback;var t=f.children;f=new Set;g=Mg(a,f);null!==a.trackedPostpones&&(g.trackedContentKeyPath=c);l=Ig(a,p.chunks.length,g,b.formatContext,!1,!1);p.children.push(l);p.lastPushedText=!1;var r=Ig(a,0,null,b.formatContext,!1,!1);r.parentFlushed=!0;b.blockedBoundary=g;b.blockedSegment=r;a.renderState.boundaryResources=g.resources;b.keyPath=c;try{if(Sg(a,
+b,t,-1),r.lastPushedText&&r.textEmbedded&&r.chunks.push(Nb),r.status=1,Vg(g,r),0===g.pendingTasks&&0===g.status){g.status=1;break a}}catch(A){r.status=4,g.status=4,h=Og(a,A),g.errorDigest=h}finally{a.renderState.boundaryResources=e?e.resources:null,b.blockedBoundary=e,b.blockedSegment=p,b.keyPath=n}h=[c[0],"Suspense Fallback",c[2]];n=a.trackedPostpones;null!==n&&(p=[h[1],h[2],[],null],n.workingMap.set(h,p),5===g.status?n.workingMap.get(c)[4]=p:g.trackedFallbackNode=p);b=Jg(a,null,d,-1,e,l,f,h,b.formatContext,
 b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}return}if("object"===typeof e&&null!==e)switch(e.$$typeof){case lf:e=e.render;Yf={};Zf=b;$f=a;ag=c;fg=eg=0;gg=-1;hg=0;ig=d;d=e(f,g);f=og(e,f,d,g);Rg(a,b,c,f,0!==eg,fg,gg);return;case qf:e=e.type;f=Tg(e,f);Ug(a,b,c,d,e,f,g);return;case hf:h=f.children;d=b.keyPath;e=e._context;f=f.value;g=e._currentValue;e._currentValue=f;l=Cf;Cf=f={parent:l,depth:null===l?0:l.depth+1,context:e,parentValue:g,value:f};b.context=f;b.keyPath=c;Z(a,b,null,h,
 -1);a=Cf;if(null===a)throw Error(k(403));c=a.parentValue;a.context._currentValue=c===xf?a.context._defaultValue:c;a=Cf=a.parent;b.context=a;b.keyPath=d;return;case jf:f=f.children;f=f(e._currentValue);e=b.keyPath;b.keyPath=c;Z(a,b,null,f,-1);b.keyPath=e;return;case rf:h=e._init;e=h(e._payload);f=Tg(e,f);Ug(a,b,c,d,e,f,void 0);return}throw Error(k(130,null==e?e:typeof e,""));}}
 function Wg(a,b,c,d,e){var f=b.replay,g=b.blockedBoundary,h=Ig(a,0,null,b.formatContext,!1,!1);h.id=c;h.parentFlushed=!0;try{b.replay=null,b.blockedSegment=h,Sg(a,b,d,e),h.status=1,null===g?a.completedRootSegment=h:(Vg(g,h),g.parentFlushed&&a.partialBoundaries.push(g))}finally{b.replay=f,b.blockedSegment=null}}
-function Z(a,b,c,d,e){if(null!==b.replay&&"number"===typeof b.replay.slots)Wg(a,b,b.replay.slots,d,e);else{b.node=d;b.childIndex=e;if("object"===typeof d&&null!==d){switch(d.$$typeof){case cf:var f=d.type,g=d.key,h=d.props,l=d.ref,n=zf(f),p=null==g?-1===e?0:e:g;g=[b.keyPath,n,p];if(null!==b.replay)a:{var t=b.replay;e=t.nodes;for(d=0;d<e.length;d++){var q=e[d];if(p===q[1]){if(4===q.length){if(null!==n&&n!==q[0])throw Error(k(490,q[0],n));n=q[2];q=q[3];p=b.node;b.replay={nodes:n,slots:q,pendingTasks:1};
-try{Ug(a,b,g,c,f,h,l);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error(k(488));b.replay.pendingTasks--}catch(H){if("object"===typeof H&&null!==H&&(H===Rf||"function"===typeof H.then))throw b.node===p&&(b.replay=t),H;b.replay.pendingTasks--;g=a;a=b.blockedBoundary;c=H;h=Og(g,c);Xg(g,a,n,q,c,h)}b.replay=t}else{if(f!==of)throw Error(k(490,"Suspense",zf(f)||"Unknown"));b:{t=void 0;c=q[5];f=q[2];l=q[3];n=null===q[4]?[]:q[4][2];q=null===q[4]?null:q[4][3];p=b.keyPath;var A=b.replay,B=b.blockedBoundary,
+function Z(a,b,c,d,e){if(null!==b.replay&&"number"===typeof b.replay.slots)Wg(a,b,b.replay.slots,d,e);else{b.node=d;b.childIndex=e;if("object"===typeof d&&null!==d){switch(d.$$typeof){case cf:var f=d.type,g=d.key,h=d.props,l=d.ref,n=zf(f),p=null==g?-1===e?0:e:g;g=[b.keyPath,n,p];if(null!==b.replay)a:{var t=b.replay;e=t.nodes;for(d=0;d<e.length;d++){var r=e[d];if(p===r[1]){if(4===r.length){if(null!==n&&n!==r[0])throw Error(k(490,r[0],n));n=r[2];r=r[3];p=b.node;b.replay={nodes:n,slots:r,pendingTasks:1};
+try{Ug(a,b,g,c,f,h,l);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error(k(488));b.replay.pendingTasks--}catch(H){if("object"===typeof H&&null!==H&&(H===Rf||"function"===typeof H.then))throw b.node===p&&(b.replay=t),H;b.replay.pendingTasks--;g=a;a=b.blockedBoundary;c=H;h=Og(g,c);Xg(g,a,n,r,c,h)}b.replay=t}else{if(f!==of)throw Error(k(490,"Suspense",zf(f)||"Unknown"));b:{t=void 0;c=r[5];f=r[2];l=r[3];n=null===r[4]?[]:r[4][2];r=null===r[4]?null:r[4][3];p=b.keyPath;var A=b.replay,B=b.blockedBoundary,
 T=h.children;h=h.fallback;var u=new Set,C=Mg(a,u);C.parentFlushed=!0;C.rootSegmentID=c;b.blockedBoundary=C;b.replay={nodes:f,slots:l,pendingTasks:1};a.renderState.boundaryResources=C.resources;try{Sg(a,b,T,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error(k(488));b.replay.pendingTasks--;if(0===C.pendingTasks&&0===C.status){C.status=1;a.completedBoundaries.push(C);break b}}catch(H){C.status=4,t=Og(a,H),C.errorDigest=t,b.replay.pendingTasks--,a.clientRenderedBoundaries.push(C)}finally{a.renderState.boundaryResources=
-B?B.resources:null,b.blockedBoundary=B,b.replay=A,b.keyPath=p}b=Ng(a,null,{nodes:n,slots:q,pendingTasks:0},h,-1,B,u,[g[0],"Suspense Fallback",g[2]],b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}}e.splice(d,1);break a}}}else Ug(a,b,g,c,f,h,l);return;case df:throw Error(k(257));case rf:h=d._init;d=h(d._payload);Z(a,b,null,d,e);return}if(Ja(d)){Yg(a,b,d,e);return}null===d||"object"!==typeof d?h=null:(h=yf&&d[yf]||d["@@iterator"],h="function"===typeof h?h:null);if(h&&
+B?B.resources:null,b.blockedBoundary=B,b.replay=A,b.keyPath=p}b=Ng(a,null,{nodes:n,slots:r,pendingTasks:0},h,-1,B,u,[g[0],"Suspense Fallback",g[2]],b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}}e.splice(d,1);break a}}}else Ug(a,b,g,c,f,h,l);return;case df:throw Error(k(257));case rf:h=d._init;d=h(d._payload);Z(a,b,null,d,e);return}if(Ja(d)){Yg(a,b,d,e);return}null===d||"object"!==typeof d?h=null:(h=yf&&d[yf]||d["@@iterator"],h="function"===typeof h?h:null);if(h&&
 (h=h.call(d))){d=h.next();if(!d.done){g=[];do g.push(d.value),d=h.next();while(!d.done);Yg(a,b,g,e)}return}if("function"===typeof d.then)return Z(a,b,null,xg(d),e);if(d.$$typeof===jf||d.$$typeof===kf)return Z(a,b,null,d._currentValue,e);e=Object.prototype.toString.call(d);throw Error(k(31,"[object Object]"===e?"object with keys {"+Object.keys(d).join(", ")+"}":e));}"string"===typeof d?(e=b.blockedSegment,null!==e&&(e.lastPushedText=Ob(e.chunks,d,a.renderState,e.lastPushedText))):"number"===typeof d&&
 (e=b.blockedSegment,null!==e&&(e.lastPushedText=Ob(e.chunks,""+d,a.renderState,e.lastPushedText)))}}
 function Yg(a,b,c,d){var e=b.keyPath;if(-1!==d&&(b.keyPath=[b.keyPath,"Fragment",d],null!==b.replay)){for(var f=b.replay,g=f.nodes,h=0;h<g.length;h++){var l=g[h];if(l[1]===d){d=l[2];l=l[3];b.replay={nodes:d,slots:l,pendingTasks:1};try{Yg(a,b,c,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error(k(488));b.replay.pendingTasks--}catch(t){if("object"===typeof t&&null!==t&&(t===Rf||"function"===typeof t.then))throw t;b.replay.pendingTasks--;c=a;var n=b.blockedBoundary,p=t;a=Og(c,p);Xg(c,
 n,d,l,p,a)}b.replay=f;g.splice(h,1);break}}b.keyPath=e;return}f=b.treeContext;g=c.length;if(null!==b.replay&&(h=b.replay.slots,null!==h&&"object"===typeof h)){for(d=0;d<g;d++)l=c[d],b.treeContext=Mf(f,g,d),n=h[d],"number"===typeof n?(Wg(a,b,n,l,d),delete h[d]):Sg(a,b,l,d);b.treeContext=f;b.keyPath=e;return}for(h=0;h<g;h++)d=c[h],b.treeContext=Mf(f,g,h),Sg(a,b,d,h);b.treeContext=f;b.keyPath=e}
-function Sg(a,b,c,d){var e=b.formatContext,f=b.legacyContext,g=b.context,h=b.keyPath,l=b.treeContext,n=b.blockedSegment;if(null===n)try{return Z(a,b,null,c,d)}catch(q){if(pg(),c=q===Rf?Vf():q,"object"===typeof c&&null!==c&&"function"===typeof c.then){d=qg();a=Ng(a,d,b.replay,b.node,b.childIndex,b.blockedBoundary,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=l;If(g);return}}else{var p=
-n.children.length,t=n.chunks.length;try{return Z(a,b,null,c,d)}catch(q){if(pg(),n.children.length=p,n.chunks.length=t,c=q===Rf?Vf():q,"object"===typeof c&&null!==c&&"function"===typeof c.then){d=qg();n=b.blockedSegment;p=Ig(a,n.chunks.length,null,b.formatContext,n.lastPushedText,!0);n.children.push(p);n.lastPushedText=!1;a=Jg(a,d,b.node,b.childIndex,b.blockedBoundary,p,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=
+function Sg(a,b,c,d){var e=b.formatContext,f=b.legacyContext,g=b.context,h=b.keyPath,l=b.treeContext,n=b.blockedSegment;if(null===n)try{return Z(a,b,null,c,d)}catch(r){if(pg(),c=r===Rf?Vf():r,"object"===typeof c&&null!==c&&"function"===typeof c.then){d=qg();a=Ng(a,d,b.replay,b.node,b.childIndex,b.blockedBoundary,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=l;If(g);return}}else{var p=
+n.children.length,t=n.chunks.length;try{return Z(a,b,null,c,d)}catch(r){if(pg(),n.children.length=p,n.chunks.length=t,c=r===Rf?Vf():r,"object"===typeof c&&null!==c&&"function"===typeof c.then){d=qg();n=b.blockedSegment;p=Ig(a,n.chunks.length,null,b.formatContext,n.lastPushedText,!0);n.children.push(p);n.lastPushedText=!1;a=Jg(a,d,b.node,b.childIndex,b.blockedBoundary,p,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=
 f;b.context=g;b.keyPath=h;b.treeContext=l;If(g);return}}}b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=l;If(g);throw c;}function Zg(a){var b=a.blockedBoundary;a=a.blockedSegment;null!==a&&(a.status=3,$g(this,b,a))}
 function Xg(a,b,c,d,e,f){for(var g=0;g<c.length;g++){var h=c[g];if(4===h.length)Xg(a,b,h[2],h[3],e,f);else{h=h[5];var l=a,n=f,p=Mg(l,new Set);p.parentFlushed=!0;p.rootSegmentID=h;p.status=4;p.errorDigest=n;p.parentFlushed&&l.clientRenderedBoundaries.push(p)}}c.length=0;if(null!==d){if(null===b)throw Error(k(487));4!==b.status&&(b.status=4,b.errorDigest=f,b.parentFlushed&&a.clientRenderedBoundaries.push(b));if("object"===typeof d)for(var t in d)delete d[t]}}
 function ah(a,b,c){var d=a.blockedBoundary,e=a.blockedSegment;null!==e&&(e.status=3);if(null===d){if(1!==b.status&&2!==b.status){a=a.replay;if(null===a){Og(b,c);Pg(b,c);return}a.pendingTasks--;0===a.pendingTasks&&0<a.nodes.length&&(d=Og(b,c),Xg(b,null,a.nodes,a.slots,c,d));b.pendingRootTasks--;0===b.pendingRootTasks&&bh(b)}}else d.pendingTasks--,4!==d.status&&(d.status=4,d.errorDigest=Og(b,c),d.parentFlushed&&b.clientRenderedBoundaries.push(d)),d.fallbackAbortableTasks.forEach(function(f){return ah(f,
@@ -180,24 +178,26 @@ b,c)}),d.fallbackAbortableTasks.clear();b.allPendingTasks--;0===b.allPendingTask
 function Vg(a,b){if(0===b.chunks.length&&1===b.children.length&&null===b.children[0].boundary){var c=b.children[0];c.id=b.id;c.parentFlushed=!0;1===c.status&&Vg(a,c)}else a.completedSegments.push(b)}
 function $g(a,b,c){if(null===b){if(null!==c&&c.parentFlushed){if(null!==a.completedRootSegment)throw Error(k(389));a.completedRootSegment=c}a.pendingRootTasks--;0===a.pendingRootTasks&&bh(a)}else b.pendingTasks--,4!==b.status&&(0===b.pendingTasks?(0===b.status&&(b.status=1),null!==c&&c.parentFlushed&&1===c.status&&Vg(b,c),b.parentFlushed&&a.completedBoundaries.push(b),1===b.status&&(b.fallbackAbortableTasks.forEach(Zg,a),b.fallbackAbortableTasks.clear())):null!==c&&c.parentFlushed&&1===c.status&&
 (Vg(b,c),1===b.completedSegments.length&&b.parentFlushed&&a.partialBoundaries.push(b)));a.allPendingTasks--;0===a.allPendingTasks&&ch(a)}
-function Lg(a){if(2!==a.status){var b=Cf,c=Dg.current;Dg.current=Bg;var d=Eg.current;Eg.current=Cg;var e=W;W=a;var f=Ag;Ag=a.resumableState;try{var g=a.pingedTasks,h;for(h=0;h<g.length;h++){var l=g[h],n=a,p=l.blockedBoundary;n.renderState.boundaryResources=p?p.resources:null;var t=l.blockedSegment;if(null===t){var q=n;if(0!==l.replay.pendingTasks){If(l.context);try{var A=l.thenableState;l.thenableState=null;Z(q,l,A,l.node,l.childIndex);if(1===l.replay.pendingTasks&&0<l.replay.nodes.length)throw Error(k(488));
-l.replay.pendingTasks--;l.abortSet.delete(l);$g(q,l.blockedBoundary,null)}catch(I){pg();var B=I===Rf?Vf():I;if("object"===typeof B&&null!==B&&"function"===typeof B.then){var T=l.ping;B.then(T,T);l.thenableState=qg()}else{l.replay.pendingTasks--;l.abortSet.delete(l);n=void 0;var u=q,C=l.blockedBoundary,H=B,ma=l.replay.nodes,E=l.replay.slots;n=Og(u,H);Xg(u,C,ma,E,H,n);q.pendingRootTasks--;0===q.pendingRootTasks&&bh(q);q.allPendingTasks--;0===q.allPendingTasks&&ch(q)}}finally{q.renderState.boundaryResources=
-null}}}else if(q=void 0,u=t,0===u.status){If(l.context);var Y=u.children.length,F=u.chunks.length;try{var ha=l.thenableState;l.thenableState=null;Z(n,l,ha,l.node,l.childIndex);u.lastPushedText&&u.textEmbedded&&u.chunks.push(Nb);l.abortSet.delete(l);u.status=1;$g(n,l.blockedBoundary,u)}catch(I){pg();u.children.length=Y;u.chunks.length=F;var U=I===Rf?Vf():I;if("object"===typeof U&&null!==U&&"function"===typeof U.then){var na=l.ping;U.then(na,na);l.thenableState=qg()}else{l.abortSet.delete(l);u.status=
-4;var Q=l.blockedBoundary;q=Og(n,U);null===Q?Pg(n,U):(Q.pendingTasks--,4!==Q.status&&(Q.status=4,Q.errorDigest=q,Q.parentFlushed&&n.clientRenderedBoundaries.push(Q)));n.allPendingTasks--;0===n.allPendingTasks&&ch(n)}}finally{n.renderState.boundaryResources=null}}}g.splice(0,h);null!==a.destination&&dh(a,a.destination)}catch(I){Og(a,I),Pg(a,I)}finally{Ag=f,Dg.current=c,Eg.current=d,c===Bg&&If(b),W=e}}}
+function Lg(a){if(2!==a.status){var b=Cf,c=Dg.current;Dg.current=Bg;var d=Eg.current;Eg.current=Cg;var e=W;W=a;var f=Ag;Ag=a.resumableState;try{var g=a.pingedTasks,h;for(h=0;h<g.length;h++){var l=g[h],n=a,p=l.blockedBoundary;n.renderState.boundaryResources=p?p.resources:null;var t=l.blockedSegment;if(null===t){var r=n;if(0!==l.replay.pendingTasks){If(l.context);try{var A=l.thenableState;l.thenableState=null;Z(r,l,A,l.node,l.childIndex);if(1===l.replay.pendingTasks&&0<l.replay.nodes.length)throw Error(k(488));
+l.replay.pendingTasks--;l.abortSet.delete(l);$g(r,l.blockedBoundary,null)}catch(I){pg();var B=I===Rf?Vf():I;if("object"===typeof B&&null!==B&&"function"===typeof B.then){var T=l.ping;B.then(T,T);l.thenableState=qg()}else{l.replay.pendingTasks--;l.abortSet.delete(l);n=void 0;var u=r,C=l.blockedBoundary,H=B,ma=l.replay.nodes,E=l.replay.slots;n=Og(u,H);Xg(u,C,ma,E,H,n);r.pendingRootTasks--;0===r.pendingRootTasks&&bh(r);r.allPendingTasks--;0===r.allPendingTasks&&ch(r)}}finally{r.renderState.boundaryResources=
+null}}}else if(r=void 0,u=t,0===u.status){If(l.context);var Y=u.children.length,F=u.chunks.length;try{var ha=l.thenableState;l.thenableState=null;Z(n,l,ha,l.node,l.childIndex);u.lastPushedText&&u.textEmbedded&&u.chunks.push(Nb);l.abortSet.delete(l);u.status=1;$g(n,l.blockedBoundary,u)}catch(I){pg();u.children.length=Y;u.chunks.length=F;var U=I===Rf?Vf():I;if("object"===typeof U&&null!==U&&"function"===typeof U.then){var na=l.ping;U.then(na,na);l.thenableState=qg()}else{l.abortSet.delete(l);u.status=
+4;var Q=l.blockedBoundary;r=Og(n,U);null===Q?Pg(n,U):(Q.pendingTasks--,4!==Q.status&&(Q.status=4,Q.errorDigest=r,Q.parentFlushed&&n.clientRenderedBoundaries.push(Q)));n.allPendingTasks--;0===n.allPendingTasks&&ch(n)}}finally{n.renderState.boundaryResources=null}}}g.splice(0,h);null!==a.destination&&dh(a,a.destination)}catch(I){Og(a,I),Pg(a,I)}finally{Ag=f,Dg.current=c,Eg.current=d,c===Bg&&If(b),W=e}}}
 function eh(a,b,c){c.parentFlushed=!0;switch(c.status){case 0:c.id=a.nextSegmentId++;case 5:var d=c.id;c.lastPushedText=!1;c.textEmbedded=!1;a=a.renderState;v(b,Hc);v(b,a.placeholderPrefix);a=x(d.toString(16));v(b,a);return w(b,Ic);case 1:c.status=2;var e=!0;d=c.chunks;var f=0;c=c.children;for(var g=0;g<c.length;g++){for(e=c[g];f<e.index;f++)v(b,d[f]);e=fh(a,b,e)}for(;f<d.length-1;f++)v(b,d[f]);f<d.length&&(e=w(b,d[f]));return e;default:throw Error(k(390));}}
 function fh(a,b,c){var d=c.boundary;if(null===d)return eh(a,b,c);d.parentFlushed=!0;if(4===d.status)d=d.errorDigest,w(b,Mc),v(b,Oc),d&&(v(b,Qc),v(b,x(G(d))),v(b,Pc)),w(b,Rc),eh(a,b,c);else if(1!==d.status)0===d.status&&(d.rootSegmentID=a.nextSegmentId++),0<d.completedSegments.length&&a.partialBoundaries.push(d),Sc(b,a.renderState,d.rootSegmentID),eh(a,b,c);else if(d.byteSize>a.progressiveChunkSize)d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),Sc(b,a.renderState,d.rootSegmentID),
 eh(a,b,c);else{c=d.resources;var e=a.renderState.boundaryResources;e&&(c.styles.forEach($e,e),c.stylesheets.forEach(af,e));w(b,Jc);d=d.completedSegments;if(1!==d.length)throw Error(k(391));fh(a,b,d[0])}return w(b,Nc)}function gh(a,b,c){nd(b,a.renderState,c.parentFormatContext,c.id);fh(a,b,c);return Pd(b,c.parentFormatContext)}
 function hh(a,b,c){a.renderState.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e<d.length;e++)ih(a,b,c,d[e]);d.length=0;Ee(b,c.resources,a.renderState);d=a.resumableState;a=a.renderState;e=c.rootSegmentID;c=c.resources;var f=a.stylesToHoist;a.stylesToHoist=!1;var g=0===d.streamingFormat;g?(v(b,a.startInlineScript),f?0===(d.instructions&2)?(d.instructions|=10,v(b,512<Yd.byteLength?Yd.slice():Yd)):0===(d.instructions&8)?(d.instructions|=8,v(b,Zd)):v(b,$d):0===(d.instructions&2)?(d.instructions|=
-2,v(b,Wd)):v(b,Xd)):f?v(b,fe):v(b,ee);d=x(e.toString(16));v(b,a.boundaryPrefix);v(b,d);g?v(b,ae):v(b,ge);v(b,a.segmentPrefix);v(b,d);f?g?(v(b,be),Te(b,c)):(v(b,he),Ue(b,c)):g&&v(b,ce);d=g?w(b,de):w(b,ab);return Gc(b,a)&&d}
+2,v(b,Wd)):v(b,Xd)):f?v(b,fe):v(b,ee);e=x(e.toString(16));v(b,a.boundaryPrefix);v(b,e);g?v(b,ae):v(b,ge);v(b,a.segmentPrefix);v(b,e);f?g?(v(b,be),Te(b,c)):(v(b,he),Ue(b,c)):g&&v(b,ce);c=g?w(b,de):w(b,ab);return Gc(b,a,d)&&c}
 function ih(a,b,c,d){if(2===d.status)return!0;var e=d.id;if(-1===e){if(-1===(d.id=c.rootSegmentID))throw Error(k(392));return gh(a,b,d)}if(e===c.rootSegmentID)return gh(a,b,d);gh(a,b,d);c=a.resumableState;a=a.renderState;(d=0===c.streamingFormat)?(v(b,a.startInlineScript),0===(c.instructions&1)?(c.instructions|=1,v(b,Qd)):v(b,Rd)):v(b,Ud);v(b,a.segmentPrefix);e=x(e.toString(16));v(b,e);d?v(b,Sd):v(b,Vd);v(b,a.placeholderPrefix);v(b,e);b=d?w(b,Td):w(b,ab);return b}
-function dh(a,b){m=new Uint8Array(512);r=0;try{var c,d=a.completedRootSegment;if(null!==d)if(5!==d.status&&0===a.pendingRootTasks){var e=a.renderState;if((0!==a.allPendingTasks||null!==a.trackedPostpones)&&e.externalRuntimeScript){var f=e.externalRuntimeScript,g=a.resumableState,h=f.src,l=f.chunks;g.scriptResources.hasOwnProperty(h)||(g.scriptResources[h]=null,e.scripts.add(l))}var n=e.htmlChunks,p=e.headChunks;f=0;if(n){for(f=0;f<n.length;f++)v(b,n[f]);if(p)for(f=0;f<p.length;f++)v(b,p[f]);else v(b,
-V("head")),v(b,S)}else if(p)for(f=0;f<p.length;f++)v(b,p[f]);var t=e.charsetChunks;for(f=0;f<t.length;f++)v(b,t[f]);t.length=0;e.preconnects.forEach(Fe,b);e.preconnects.clear();var q=e.preconnectChunks;for(f=0;f<q.length;f++)v(b,q[f]);q.length=0;e.fontPreloads.forEach(Fe,b);e.fontPreloads.clear();e.highImagePreloads.forEach(Fe,b);e.highImagePreloads.clear();e.styles.forEach(Me,b);var A=e.importMapChunks;for(f=0;f<A.length;f++)v(b,A[f]);A.length=0;e.bootstrapScripts.forEach(Fe,b);e.scripts.forEach(Fe,
-b);e.scripts.clear();e.bulkPreloads.forEach(Fe,b);e.bulkPreloads.clear();var B=e.preloadChunks;for(f=0;f<B.length;f++)v(b,B[f]);B.length=0;var T=e.hoistableChunks;for(f=0;f<T.length;f++)v(b,T[f]);T.length=0;n&&null===p&&v(b,xc("head"));fh(a,b,d);a.completedRootSegment=null;Gc(b,a.renderState)}else return;var u=a.renderState;d=0;u.preconnects.forEach(Fe,b);u.preconnects.clear();var C=u.preconnectChunks;for(d=0;d<C.length;d++)v(b,C[d]);C.length=0;u.fontPreloads.forEach(Fe,b);u.fontPreloads.clear();
+function dh(a,b){m=new Uint8Array(512);q=0;try{var c,d=a.completedRootSegment;if(null!==d)if(5!==d.status&&0===a.pendingRootTasks){var e=a.renderState;if((0!==a.allPendingTasks||null!==a.trackedPostpones)&&e.externalRuntimeScript){var f=e.externalRuntimeScript,g=a.resumableState,h=f.src,l=f.chunks;g.scriptResources.hasOwnProperty(h)||(g.scriptResources[h]=null,e.scripts.add(l))}var n=e.htmlChunks,p=e.headChunks;f=0;if(n){for(f=0;f<n.length;f++)v(b,n[f]);if(p)for(f=0;f<p.length;f++)v(b,p[f]);else v(b,
+V("head")),v(b,S)}else if(p)for(f=0;f<p.length;f++)v(b,p[f]);var t=e.charsetChunks;for(f=0;f<t.length;f++)v(b,t[f]);t.length=0;e.preconnects.forEach(Fe,b);e.preconnects.clear();var r=e.preconnectChunks;for(f=0;f<r.length;f++)v(b,r[f]);r.length=0;e.fontPreloads.forEach(Fe,b);e.fontPreloads.clear();e.highImagePreloads.forEach(Fe,b);e.highImagePreloads.clear();e.styles.forEach(Me,b);var A=e.importMapChunks;for(f=0;f<A.length;f++)v(b,A[f]);A.length=0;e.bootstrapScripts.forEach(Fe,b);e.scripts.forEach(Fe,
+b);e.scripts.clear();e.bulkPreloads.forEach(Fe,b);e.bulkPreloads.clear();var B=e.preloadChunks;for(f=0;f<B.length;f++)v(b,B[f]);B.length=0;var T=e.hoistableChunks;for(f=0;f<T.length;f++)v(b,T[f]);T.length=0;n&&null===p&&v(b,xc("head"));fh(a,b,d);a.completedRootSegment=null;Gc(b,a.renderState,a.resumableState)}else return;var u=a.renderState;d=0;u.preconnects.forEach(Fe,b);u.preconnects.clear();var C=u.preconnectChunks;for(d=0;d<C.length;d++)v(b,C[d]);C.length=0;u.fontPreloads.forEach(Fe,b);u.fontPreloads.clear();
 u.highImagePreloads.forEach(Fe,b);u.highImagePreloads.clear();u.styles.forEach(Oe,b);u.scripts.forEach(Fe,b);u.scripts.clear();u.bulkPreloads.forEach(Fe,b);u.bulkPreloads.clear();var H=u.preloadChunks;for(d=0;d<H.length;d++)v(b,H[d]);H.length=0;var ma=u.hoistableChunks;for(d=0;d<ma.length;d++)v(b,ma[d]);ma.length=0;var E=a.clientRenderedBoundaries;for(c=0;c<E.length;c++){var Y=E[c];u=b;var F=a.resumableState,ha=a.renderState,U=Y.rootSegmentID,na=Y.errorDigest,Q=Y.errorMessage,I=Y.errorComponentStack,
 oa=0===F.streamingFormat;oa?(v(u,ha.startInlineScript),0===(F.instructions&4)?(F.instructions|=4,v(u,ie)):v(u,je)):v(u,ne);v(u,ha.boundaryPrefix);v(u,x(U.toString(16)));oa&&v(u,ke);if(na||Q||I)oa?(v(u,le),v(u,x(se(na||"")))):(v(u,oe),v(u,x(G(na||""))));if(Q||I)oa?(v(u,le),v(u,x(se(Q||"")))):(v(u,pe),v(u,x(G(Q||""))));I&&(oa?(v(u,le),v(u,x(se(I)))):(v(u,qe),v(u,x(G(I)))));if(oa?!w(u,me):!w(u,ab)){a.destination=null;c++;E.splice(0,c);return}}E.splice(0,c);var Aa=a.completedBoundaries;for(c=0;c<Aa.length;c++)if(!hh(a,
-b,Aa[c])){a.destination=null;c++;Aa.splice(0,c);return}Aa.splice(0,c);ea(b);m=new Uint8Array(512);r=0;var sa=a.partialBoundaries;for(c=0;c<sa.length;c++){var ta=sa[c];a:{E=a;Y=b;E.renderState.boundaryResources=ta.resources;var ua=ta.completedSegments;for(F=0;F<ua.length;F++)if(!ih(E,Y,ta,ua[F])){F++;ua.splice(0,F);var Ma=!1;break a}ua.splice(0,F);Ma=Ee(Y,ta.resources,E.renderState)}if(!Ma){a.destination=null;c++;sa.splice(0,c);return}}sa.splice(0,c);var ia=a.completedBoundaries;for(c=0;c<ia.length;c++)if(!hh(a,
+b,Aa[c])){a.destination=null;c++;Aa.splice(0,c);return}Aa.splice(0,c);ea(b);m=new Uint8Array(512);q=0;var sa=a.partialBoundaries;for(c=0;c<sa.length;c++){var ta=sa[c];a:{E=a;Y=b;E.renderState.boundaryResources=ta.resources;var ua=ta.completedSegments;for(F=0;F<ua.length;F++)if(!ih(E,Y,ta,ua[F])){F++;ua.splice(0,F);var Ma=!1;break a}ua.splice(0,F);Ma=Ee(Y,ta.resources,E.renderState)}if(!Ma){a.destination=null;c++;sa.splice(0,c);return}}sa.splice(0,c);var ia=a.completedBoundaries;for(c=0;c<ia.length;c++)if(!hh(a,
 b,ia[c])){a.destination=null;c++;ia.splice(0,c);return}ia.splice(0,c)}finally{0===a.allPendingTasks&&0===a.pingedTasks.length&&0===a.clientRenderedBoundaries.length&&0===a.completedBoundaries.length?(a.flushScheduled=!1,c=a.resumableState,c.hasBody&&v(b,xc("body")),c.hasHtml&&v(b,xc("html")),ea(b),b.close(),a.destination=null):ea(b)}}function Xe(a){if(!1===a.flushScheduled&&0===a.pingedTasks.length&&null!==a.destination){a.flushScheduled=!0;var b=a.destination;b?dh(a,b):a.flushScheduled=!1}}
 function jh(a,b){try{var c=a.abortableTasks;if(0<c.size){var d=void 0===b?Error(k(432)):b;c.forEach(function(e){return ah(e,a,d)});c.clear()}null!==a.destination&&dh(a,a.destination)}catch(e){Og(a,e),Pg(a,e)}}
-exports.renderToReadableStream=function(a,b){return new Promise(function(c,d){var e,f,g=new Promise(function(A,B){f=A;e=B}),h=b?b.onHeaders:void 0,l;h&&(l=function(A){h(new Headers(A))});var n=Kb(b?b.identifierPrefix:void 0,b?b.unstable_externalRuntimeSrc:void 0),p=Hg(a,n,Ib(n,b?b.nonce:void 0,b?b.bootstrapScriptContent:void 0,b?b.bootstrapScripts:void 0,b?b.bootstrapModules:void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.importMap:void 0,l,b?b.maxHeadersLength:void 0),Lb(b?b.namespaceURI:void 0),
-b?b.progressiveChunkSize:void 0,b?b.onError:void 0,f,function(){var A=new ReadableStream({type:"bytes",pull:function(B){if(1===p.status)p.status=2,ka(B,p.fatalError);else if(2!==p.status&&null===p.destination){p.destination=B;try{dh(p,B)}catch(T){Og(p,T),Pg(p,T)}}},cancel:function(B){p.destination=null;jh(p,B)}},{highWaterMark:0});A.allReady=g;c(A)},function(A){g.catch(function(){});d(A)},e,b?b.onPostpone:void 0,b?b.formState:void 0);if(b&&b.signal){var t=b.signal;if(t.aborted)jh(p,t.reason);else{var q=
-function(){jh(p,t.reason);t.removeEventListener("abort",q)};t.addEventListener("abort",q)}}p.flushScheduled=null!==p.destination;Lg(p);null===p.trackedPostpones&&bf(p.renderState,p.resumableState,0===p.pendingRootTasks)})};exports.version="18.3.0-canary-2983249dd-20231107";
+exports.renderToReadableStream=function(a,b){return new Promise(function(c,d){var e,f,g=new Promise(function(A,B){f=A;e=B}),h=b?b.onHeaders:void 0,l;h&&(l=function(A){h(new Headers(A))});var n=Kb(b?b.identifierPrefix:void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.bootstrapScriptContent:void 0,b?b.bootstrapScripts:void 0,b?b.bootstrapModules:void 0),p=Hg(a,n,Ib(n,b?b.nonce:void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.importMap:void 0,l,b?b.maxHeadersLength:void 0),Lb(b?b.namespaceURI:void 0),
+b?b.progressiveChunkSize:void 0,b?b.onError:void 0,f,function(){var A=new ReadableStream({type:"bytes",pull:function(B){if(1===p.status)p.status=2,ka(B,p.fatalError);else if(2!==p.status&&null===p.destination){p.destination=B;try{dh(p,B)}catch(T){Og(p,T),Pg(p,T)}}},cancel:function(B){p.destination=null;jh(p,B)}},{highWaterMark:0});A.allReady=g;c(A)},function(A){g.catch(function(){});d(A)},e,b?b.onPostpone:void 0,b?b.formState:void 0);if(b&&b.signal){var t=b.signal;if(t.aborted)jh(p,t.reason);else{var r=
+function(){jh(p,t.reason);t.removeEventListener("abort",r)};t.addEventListener("abort",r)}}p.flushScheduled=null!==p.destination;Lg(p);null===p.trackedPostpones&&bf(p.renderState,p.resumableState,0===p.pendingRootTasks)})};exports.version="18.3.0-canary-7508dcd5c-20231108";
+
+//# sourceMappingURL=react-dom-server.browser.production.min.js.map
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom-server.bun.production.js b/packages/next/src/compiled/react-dom/cjs/react-dom-server.bun.production.js
new file mode 100644
index 0000000000000..818f9647d97ad
--- /dev/null
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom-server.bun.production.js
@@ -0,0 +1,8463 @@
+/**
+* @license React
+ * react-dom-server.bun.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+var React = require("next/dist/compiled/react");
+var ReactDOM = require('react-dom');
+
+var ReactVersion = '18.3.0-canary-7508dcd5c-20231108';
+
+/* global Bun */
+function scheduleWork(callback) {
+  callback();
+}
+function beginWriting(destination) {}
+function writeChunk(destination, chunk) {
+  if (chunk.length === 0) {
+    return;
+  }
+
+  destination.write(chunk);
+}
+function writeChunkAndReturn(destination, chunk) {
+  return !!destination.write(chunk);
+}
+function completeWriting(destination) {}
+function close(destination) {
+  destination.end();
+}
+function stringToChunk(content) {
+  return content;
+}
+function stringToPrecomputedChunk(content) {
+  return content;
+}
+function clonePrecomputedChunk(chunk) {
+  return chunk;
+}
+function closeWithError(destination, error) {
+  if (typeof destination.error === 'function') {
+    // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+    destination.error(error);
+  } else {
+    // Earlier implementations doesn't support this method. In that environment you're
+    // supposed to throw from a promise returned but we don't return a promise in our
+    // approach. We could fork this implementation but this is environment is an edge
+    // case to begin with. It's even less common to run this in an older environment.
+    // Even then, this is not where errors are supposed to happen and they get reported
+    // to a global callback in addition to this anyway. So it's fine just to close this.
+    destination.close();
+  }
+}
+function createFastHash(input) {
+  return Bun.hash(input);
+}
+
+const assign = Object.assign;
+
+// -----------------------------------------------------------------------------
+const enableFloat = true; // Enables unstable_useMemoCache hook, intended as a compilation target for
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/* eslint-disable max-len */
+
+const ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
+/* eslint-enable max-len */
+
+const ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
+const VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+const illegalAttributeNameCache = {};
+const validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+  if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+    return true;
+  }
+
+  if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+    return false;
+  }
+
+  if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+    validatedAttributeNameCache[attributeName] = true;
+    return true;
+  }
+
+  illegalAttributeNameCache[attributeName] = true;
+
+  return false;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+const unitlessNumbers = new Set(['animationIterationCount', 'aspectRatio', 'borderImageOutset', 'borderImageSlice', 'borderImageWidth', 'boxFlex', 'boxFlexGroup', 'boxOrdinalGroup', 'columnCount', 'columns', 'flex', 'flexGrow', 'flexPositive', 'flexShrink', 'flexNegative', 'flexOrder', 'gridArea', 'gridRow', 'gridRowEnd', 'gridRowSpan', 'gridRowStart', 'gridColumn', 'gridColumnEnd', 'gridColumnSpan', 'gridColumnStart', 'fontWeight', 'lineClamp', 'lineHeight', 'opacity', 'order', 'orphans', 'scale', 'tabSize', 'widows', 'zIndex', 'zoom', 'fillOpacity', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'MozBoxFlexGroup', 'MozLineClamp', 'msAnimationIterationCount', 'msFlex', 'msZoom', 'msFlexGrow', 'msFlexNegative', 'msFlexOrder', 'msFlexPositive', 'msFlexShrink', 'msGridColumn', 'msGridColumnSpan', 'msGridRow', 'msGridRowSpan', 'WebkitAnimationIterationCount', 'WebkitBoxFlex', 'WebKitBoxFlexGroup', 'WebkitBoxOrdinalGroup', 'WebkitColumnCount', 'WebkitColumns', 'WebkitFlex', 'WebkitFlexGrow', 'WebkitFlexPositive', 'WebkitFlexShrink', 'WebkitLineClamp']);
+function isUnitlessNumber (name) {
+  return unitlessNumbers.has(name);
+}
+
+const aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+  return aliases.get(name) || name;
+}
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// code copied and modified from escape-html
+const matchHtmlRegExp = /["'&<>]/;
+/**
+ * Escapes special characters and HTML entities in a given html string.
+ *
+ * @param  {string} string HTML string to escape for later insertion
+ * @return {string}
+ * @public
+ */
+
+function escapeHtml(string) {
+
+  const str = '' + string;
+  const match = matchHtmlRegExp.exec(str);
+
+  if (!match) {
+    return str;
+  }
+
+  let escape;
+  let html = '';
+  let index;
+  let lastIndex = 0;
+
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        // "
+        escape = '&quot;';
+        break;
+
+      case 38:
+        // &
+        escape = '&amp;';
+        break;
+
+      case 39:
+        // '
+        escape = '&#x27;'; // modified from escape-html; used to be '&#39'
+
+        break;
+
+      case 60:
+        // <
+        escape = '&lt;';
+        break;
+
+      case 62:
+        // >
+        escape = '&gt;';
+        break;
+
+      default:
+        continue;
+    }
+
+    if (lastIndex !== index) {
+      html += str.slice(lastIndex, index);
+    }
+
+    lastIndex = index + 1;
+    html += escape;
+  }
+
+  return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+} // end code copied and modified from escape-html
+
+/**
+ * Escapes text to prevent scripting attacks.
+ *
+ * @param {*} text Text value to escape.
+ * @return {string} An escaped string.
+ */
+
+
+function escapeTextForBrowser(text) {
+  if (typeof text === 'boolean' || typeof text === 'number') {
+    // this shortcircuit helps perf for types that we know will never have
+    // special characters, especially given that this function is used often
+    // for numeric dom ids.
+    return '' + text;
+  }
+
+  return escapeHtml(text);
+}
+
+const uppercasePattern = /([A-Z])/g;
+const msPattern = /^ms-/;
+/**
+ * Hyphenates a camelcased CSS property name, for example:
+ *
+ *   > hyphenateStyleName('backgroundColor')
+ *   < "background-color"
+ *   > hyphenateStyleName('MozTransition')
+ *   < "-moz-transition"
+ *   > hyphenateStyleName('msTransition')
+ *   < "-ms-transition"
+ *
+ * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
+ * is converted to `-ms-`.
+ */
+
+function hyphenateStyleName(name) {
+  return name.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern, '-ms-');
+}
+
+function sanitizeURL(url) {
+
+  return url;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+// The build script is at scripts/rollup/generate-inline-fizz-runtime.js.
+// Run `yarn generate-inline-fizz-runtime` to generate.
+const clientRenderBoundary = '$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};';
+const completeBoundary = '$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};';
+const completeBoundaryWithStyles = '$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};';
+const completeSegment = '$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};';
+const formReplaying = 'addEventListener("submit",function(a){if(!a.defaultPrevented){var c=a.target,d=a.submitter,e=c.action,b=d;if(d){var f=d.getAttribute("formAction");null!=f&&(e=f,b=null)}"javascript:throw new Error(\'A React form was unexpectedly submitted.\')"===e&&(a.preventDefault(),b?(a=document.createElement("input"),a.name=b.name,a.value=b.value,b.parentNode.insertBefore(a,b),b=new FormData(c),a.parentNode.removeChild(a)):b=new FormData(c),a=c.getRootNode(),(a.$$reactFormReplay=a.$$reactFormReplay||[]).push(c,\nd,b))}});';
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+// same object across all transitions.
+
+const sharedNotPendingObject = {
+  pending: false,
+  data: null,
+  method: null,
+  action: null
+};
+const NotPending = sharedNotPendingObject;
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+const ReactDOMServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMServerDispatcher;
+} // We make every property of the descriptor optional because it is not a contract that
+const ScriptStreamingFormat = 0;
+const DataStreamingFormat = 1;
+const NothingSent
+/*                      */
+= 0b00000;
+const SentCompleteSegmentFunction
+/*      */
+= 0b00001;
+const SentCompleteBoundaryFunction
+/*     */
+= 0b00010;
+const SentClientRenderFunction
+/*         */
+= 0b00100;
+const SentStyleInsertionFunction
+/*       */
+= 0b01000;
+const SentFormReplayingRuntime
+/*         */
+= 0b10000; // Per request, global state that is not contextual to the rendering subtree.
+// This cannot be resumed and therefore should only contain things that are
+// temporary working state or are never used in the prerender pass.
+// Credentials here are things that affect whether a browser will make a request
+// as well as things that affect which connection the browser will use for that request.
+// We want these to be aligned across preloads and resources because otherwise the preload
+// will be wasted.
+// We investigated whether referrerPolicy should be included here but from experimentation
+// it seems that browsers do not treat this as part of the http cache key and does not affect
+// which connection is used.
+
+const EXISTS = null; // This constant is to mark preloads that have no unique credentials
+// to convey. It should never be checked by identity and we should not
+// assume Preload values in ResumableState equal this value because they
+// will have come from some parsed input.
+
+const PRELOAD_NO_CREDS = [];
+// This is resumable and therefore should be serializable.
+
+
+const dataElementQuotedEnd = stringToPrecomputedChunk('"></template>');
+const startInlineScript = stringToPrecomputedChunk('<script>');
+const endInlineScript = stringToPrecomputedChunk('</script>');
+const startScriptSrc = stringToPrecomputedChunk('<script src="');
+const startModuleSrc = stringToPrecomputedChunk('<script type="module" src="');
+const scriptNonce = stringToPrecomputedChunk('" nonce="');
+const scriptIntegirty = stringToPrecomputedChunk('" integrity="');
+const scriptCrossOrigin = stringToPrecomputedChunk('" crossorigin="');
+const endAsyncScript = stringToPrecomputedChunk('" async=""></script>');
+/**
+ * This escaping function is designed to work with bootstrapScriptContent and importMap only.
+ * because we know we are escaping the entire script. We can avoid for instance
+ * escaping html comment string sequences that are valid javascript as well because
+ * if there are no sebsequent <script sequences the html parser will never enter
+ * script data double escaped state (see: https://www.w3.org/TR/html53/syntax.html#script-data-double-escaped-state)
+ *
+ * While untrusted script content should be made safe before using this api it will
+ * ensure that the script cannot be early terminated or never terminated state
+ */
+
+function escapeBootstrapAndImportMapScriptContent(scriptText) {
+
+  return ('' + scriptText).replace(scriptRegex, scriptReplacer);
+}
+
+const scriptRegex = /(<\/|<)(s)(cript)/gi;
+
+const scriptReplacer = (match, prefix, s, suffix) => "" + prefix + (s === 's' ? '\\u0073' : '\\u0053') + suffix;
+
+const importMapScriptStart = stringToPrecomputedChunk('<script type="importmap">');
+const importMapScriptEnd = stringToPrecomputedChunk('</script>'); // Since we store headers as strings we deal with their length in utf16 code units
+// rather than visual characters or the utf8 encoding that is used for most binary
+// serialization. Some common HTTP servers only allow for headers to be 4kB in length.
+// We choose a default length that is likely to be well under this already limited length however
+// pathological cases may still cause the utf-8 encoding of the headers to approach this limit.
+// It should also be noted that this maximum is a soft maximum. we have not reached the limit we will
+// allow one more header to be captured which means in practice if the limit is approached it will be exceeded
+
+const DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS = 2000; // Allows us to keep track of what we've already written so we can refer back to it.
+// if passed externalRuntimeConfig and the enableFizzExternalRuntime feature flag
+// is set, the server will send instructions via data attributes (instead of inline scripts)
+
+function createRenderState(resumableState, nonce, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
+  const inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
+  const idPrefix = resumableState.idPrefix;
+  const bootstrapChunks = [];
+  let externalRuntimeScript = null;
+  const bootstrapScriptContent = resumableState.bootstrapScriptContent,
+        bootstrapScripts = resumableState.bootstrapScripts,
+        bootstrapModules = resumableState.bootstrapModules;
+
+  if (bootstrapScriptContent !== undefined) {
+    bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapAndImportMapScriptContent(bootstrapScriptContent)), endInlineScript);
+  }
+
+  {
+
+    if (externalRuntimeConfig !== undefined) {
+      if (typeof externalRuntimeConfig === 'string') {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig,
+          async: true,
+          integrity: undefined,
+          nonce: nonce
+        });
+      } else {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig.src,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig.src,
+          async: true,
+          integrity: externalRuntimeConfig.integrity,
+          nonce: nonce
+        });
+      }
+    }
+  }
+
+  const importMapChunks = [];
+
+  if (importMap !== undefined) {
+    const map = importMap;
+    importMapChunks.push(importMapScriptStart);
+    importMapChunks.push(stringToChunk(escapeBootstrapAndImportMapScriptContent(JSON.stringify(map))));
+    importMapChunks.push(importMapScriptEnd);
+  }
+
+  const headers = onHeaders ? {
+    preconnects: '',
+    fontPreloads: '',
+    highImagePreloads: '',
+    remainingCapacity: typeof maxHeadersLength === 'number' ? maxHeadersLength : DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS
+  } : null;
+  const renderState = {
+    placeholderPrefix: stringToPrecomputedChunk(idPrefix + 'P:'),
+    segmentPrefix: stringToPrecomputedChunk(idPrefix + 'S:'),
+    boundaryPrefix: stringToPrecomputedChunk(idPrefix + 'B:'),
+    startInlineScript: inlineScriptWithNonce,
+    htmlChunks: null,
+    headChunks: null,
+    externalRuntimeScript: externalRuntimeScript,
+    bootstrapChunks: bootstrapChunks,
+    onHeaders,
+    headers,
+    resets: {
+      font: {},
+      dns: {},
+      connect: {
+        default: {},
+        anonymous: {},
+        credentials: {}
+      },
+      image: {},
+      style: {}
+    },
+    charsetChunks: [],
+    preconnectChunks: [],
+    importMapChunks,
+    preloadChunks: [],
+    hoistableChunks: [],
+    // cleared on flush
+    preconnects: new Set(),
+    fontPreloads: new Set(),
+    highImagePreloads: new Set(),
+    // usedImagePreloads: new Set(),
+    styles: new Map(),
+    bootstrapScripts: new Set(),
+    scripts: new Set(),
+    bulkPreloads: new Set(),
+    preloads: {
+      images: new Map(),
+      stylesheets: new Map(),
+      scripts: new Map(),
+      moduleScripts: new Map()
+    },
+    nonce,
+    // like a module global for currently rendering boundary
+    boundaryResources: null,
+    stylesToHoist: false
+  };
+
+  if (bootstrapScripts !== undefined) {
+    for (let i = 0; i < bootstrapScripts.length; i++) {
+      const scriptConfig = bootstrapScripts[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'preload',
+        as: 'script',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startScriptSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  if (bootstrapModules !== undefined) {
+    for (let i = 0; i < bootstrapModules.length; i++) {
+      const scriptConfig = bootstrapModules[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'modulepreload',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startModuleSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  return renderState;
+}
+function createResumableState(identifierPrefix, externalRuntimeConfig, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
+  const idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
+  let streamingFormat = ScriptStreamingFormat;
+
+  {
+    if (externalRuntimeConfig !== undefined) {
+      streamingFormat = DataStreamingFormat;
+    }
+  }
+
+  return {
+    idPrefix: idPrefix,
+    nextFormID: 0,
+    streamingFormat,
+    bootstrapScriptContent,
+    bootstrapScripts,
+    bootstrapModules,
+    instructions: NothingSent,
+    hasBody: false,
+    hasHtml: false,
+    // @TODO add bootstrap script to implicit preloads
+    // persistent
+    unknownResources: {},
+    dnsResources: {},
+    connectResources: {
+      default: {},
+      anonymous: {},
+      credentials: {}
+    },
+    imageResources: {},
+    styleResources: {},
+    scriptResources: {},
+    moduleUnknownResources: {},
+    moduleScriptResources: {}
+  };
+}
+// modes. We only include the variants as they matter for the sake of our purposes.
+// We don't actually provide the namespace therefore we use constants instead of the string.
+
+const ROOT_HTML_MODE = 0; // Used for the root most element tag.
+// We have a less than HTML_HTML_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const HTML_HTML_MODE = 1; // Used for the <html> if it is at the top level.
+
+const HTML_MODE = 2;
+const SVG_MODE = 3;
+const MATHML_MODE = 4;
+const HTML_TABLE_MODE = 5;
+const HTML_TABLE_BODY_MODE = 6;
+const HTML_TABLE_ROW_MODE = 7;
+const HTML_COLGROUP_MODE = 8; // We have a greater than HTML_TABLE_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const NO_SCOPE =
+/*         */
+0b00;
+const NOSCRIPT_SCOPE =
+/*   */
+0b01;
+const PICTURE_SCOPE =
+/*    */
+0b10; // Lets us keep track of contextual state and pick it back up after suspending.
+
+function createFormatContext(insertionMode, selectedValue, tagScope) {
+  return {
+    insertionMode,
+    selectedValue,
+    tagScope
+  };
+}
+
+function createRootFormatContext(namespaceURI) {
+  const insertionMode = namespaceURI === 'http://www.w3.org/2000/svg' ? SVG_MODE : namespaceURI === 'http://www.w3.org/1998/Math/MathML' ? MATHML_MODE : ROOT_HTML_MODE;
+  return createFormatContext(insertionMode, null, NO_SCOPE);
+}
+function getChildFormatContext(parentContext, type, props) {
+  switch (type) {
+    case 'noscript':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | NOSCRIPT_SCOPE);
+
+    case 'select':
+      return createFormatContext(HTML_MODE, props.value != null ? props.value : props.defaultValue, parentContext.tagScope);
+
+    case 'svg':
+      return createFormatContext(SVG_MODE, null, parentContext.tagScope);
+
+    case 'picture':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | PICTURE_SCOPE);
+
+    case 'math':
+      return createFormatContext(MATHML_MODE, null, parentContext.tagScope);
+
+    case 'foreignObject':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    // Table parents are special in that their children can only be created at all if they're
+    // wrapped in a table parent. So we need to encode that we're entering this mode.
+
+    case 'table':
+      return createFormatContext(HTML_TABLE_MODE, null, parentContext.tagScope);
+
+    case 'thead':
+    case 'tbody':
+    case 'tfoot':
+      return createFormatContext(HTML_TABLE_BODY_MODE, null, parentContext.tagScope);
+
+    case 'colgroup':
+      return createFormatContext(HTML_COLGROUP_MODE, null, parentContext.tagScope);
+
+    case 'tr':
+      return createFormatContext(HTML_TABLE_ROW_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode >= HTML_TABLE_MODE) {
+    // Whatever tag this was, it wasn't a table parent or other special parent, so we must have
+    // entered plain HTML again.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode === ROOT_HTML_MODE) {
+    if (type === 'html') {
+      // We've emitted the root and is now in <html> mode.
+      return createFormatContext(HTML_HTML_MODE, null, parentContext.tagScope);
+    } else {
+      // We've emitted the root and is now in plain HTML mode.
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    }
+  } else if (parentContext.insertionMode === HTML_HTML_MODE) {
+    // We've emitted the document element and is now in plain HTML mode.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  return parentContext;
+}
+function makeId(resumableState, treeId, localId) {
+  const idPrefix = resumableState.idPrefix;
+  let id = ':' + idPrefix + 'R' + treeId; // Unless this is the first id at this level, append a number at the end
+  // that represents the position of this useId hook among all the useId
+  // hooks for this fiber.
+
+  if (localId > 0) {
+    id += 'H' + localId.toString(32);
+  }
+
+  return id + ':';
+}
+
+function encodeHTMLTextNode(text) {
+  return escapeTextForBrowser(text);
+}
+
+const textSeparator = stringToPrecomputedChunk('<!-- -->');
+function pushTextInstance(target, text, renderState, textEmbedded) {
+  if (text === '') {
+    // Empty text doesn't have a DOM node representation and the hydration is aware of this.
+    return textEmbedded;
+  }
+
+  if (textEmbedded) {
+    target.push(textSeparator);
+  }
+
+  target.push(stringToChunk(encodeHTMLTextNode(text)));
+  return true;
+} // Called when Fizz is done with a Segment. Currently the only purpose is to conditionally
+// emit a text separator when we don't know for sure it is safe to omit
+
+function pushSegmentFinale(target, renderState, lastPushedText, textEmbedded) {
+  if (lastPushedText && textEmbedded) {
+    target.push(textSeparator);
+  }
+}
+const styleNameCache = new Map();
+
+function processStyleName(styleName) {
+  const chunk = styleNameCache.get(styleName);
+
+  if (chunk !== undefined) {
+    return chunk;
+  }
+
+  const result = stringToPrecomputedChunk(escapeTextForBrowser(hyphenateStyleName(styleName)));
+  styleNameCache.set(styleName, result);
+  return result;
+}
+
+const styleAttributeStart = stringToPrecomputedChunk(' style="');
+const styleAssign = stringToPrecomputedChunk(':');
+const styleSeparator = stringToPrecomputedChunk(';');
+
+function pushStyleAttribute(target, style) {
+  if (typeof style !== 'object') {
+    throw new Error('The `style` prop expects a mapping from style properties to values, ' + "not a string. For example, style={{marginRight: spacing + 'em'}} when " + 'using JSX.');
+  }
+
+  let isFirst = true;
+
+  for (const styleName in style) {
+    if (!hasOwnProperty.call(style, styleName)) {
+      continue;
+    } // If you provide unsafe user data here they can inject arbitrary CSS
+    // which may be problematic (I couldn't repro this):
+    // https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet
+    // http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/
+    // This is not an XSS hole but instead a potential CSS injection issue
+    // which has lead to a greater discussion about how we're going to
+    // trust URLs moving forward. See #2115901
+
+
+    const styleValue = style[styleName];
+
+    if (styleValue == null || typeof styleValue === 'boolean' || styleValue === '') {
+      // TODO: We used to set empty string as a style with an empty value. Does that ever make sense?
+      continue;
+    }
+
+    let nameChunk;
+    let valueChunk;
+    const isCustomProperty = styleName.indexOf('--') === 0;
+
+    if (isCustomProperty) {
+      nameChunk = stringToChunk(escapeTextForBrowser(styleName));
+
+      valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+    } else {
+
+      nameChunk = processStyleName(styleName);
+
+      if (typeof styleValue === 'number') {
+        if (styleValue !== 0 && !isUnitlessNumber(styleName)) {
+          valueChunk = stringToChunk(styleValue + 'px'); // Presumes implicit 'px' suffix for unitless numbers
+        } else {
+          valueChunk = stringToChunk('' + styleValue);
+        }
+      } else {
+
+        valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+      }
+    }
+
+    if (isFirst) {
+      isFirst = false; // If it's first, we don't need any separators prefixed.
+
+      target.push(styleAttributeStart, nameChunk, styleAssign, valueChunk);
+    } else {
+      target.push(styleSeparator, nameChunk, styleAssign, valueChunk);
+    }
+  }
+
+  if (!isFirst) {
+    target.push(attributeEnd);
+  }
+}
+
+const attributeSeparator = stringToPrecomputedChunk(' ');
+const attributeAssign = stringToPrecomputedChunk('="');
+const attributeEnd = stringToPrecomputedChunk('"');
+const attributeEmptyString = stringToPrecomputedChunk('=""');
+
+function pushBooleanAttribute(target, name, value) // not null or undefined
+{
+  if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+    target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+  }
+}
+
+function pushStringAttribute(target, name, value) // not null or undefined
+{
+  if (typeof value !== 'function' && typeof value !== 'symbol' && typeof value !== 'boolean') {
+    target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+  }
+}
+
+function makeFormFieldPrefix(resumableState) {
+  const id = resumableState.nextFormID++;
+  return resumableState.idPrefix + id;
+} // Since this will likely be repeated a lot in the HTML, we use a more concise message
+// than on the client and hopefully it's googleable.
+
+
+const actionJavaScriptURL = stringToPrecomputedChunk(escapeTextForBrowser( // eslint-disable-next-line no-script-url
+"javascript:throw new Error('A React form was unexpectedly submitted.')"));
+const startHiddenInputChunk = stringToPrecomputedChunk('<input type="hidden"');
+
+function pushAdditionalFormField(value, key) {
+  const target = this;
+  target.push(startHiddenInputChunk);
+
+  if (typeof value !== 'string') {
+    throw new Error('File/Blob fields are not yet supported in progressive forms. ' + 'It probably means you are closing over binary data or FormData in a Server Action.');
+  }
+
+  pushStringAttribute(target, 'name', key);
+  pushStringAttribute(target, 'value', value);
+  target.push(endOfStartTagSelfClosing);
+}
+
+function pushAdditionalFormFields(target, formData) {
+  if (formData !== null) {
+    // $FlowFixMe[prop-missing]: FormData has forEach.
+    formData.forEach(pushAdditionalFormField, target);
+  }
+}
+
+function pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name) {
+  let formData = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      name = customFields.name;
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('formAction'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      name = null;
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (name != null) {
+    pushAttribute(target, 'name', name);
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'formAction', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'formEncType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'formMethod', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'formTarget', formTarget);
+  }
+
+  return formData;
+}
+
+function pushAttribute(target, name, value) // not null or undefined
+{
+  switch (name) {
+    // These are very common props and therefore are in the beginning of the switch.
+    // TODO: aria-label is a very common prop but allows booleans so is not like the others
+    // but should ideally go in this list too.
+    case 'className':
+      {
+        pushStringAttribute(target, 'class', value);
+        break;
+      }
+
+    case 'tabIndex':
+      {
+        pushStringAttribute(target, 'tabindex', value);
+        break;
+      }
+
+    case 'dir':
+    case 'role':
+    case 'viewBox':
+    case 'width':
+    case 'height':
+      {
+        pushStringAttribute(target, name, value);
+        break;
+      }
+
+    case 'style':
+      {
+        pushStyleAttribute(target, value);
+        return;
+      }
+
+    case 'src':
+    case 'href':
+    // Fall through to the last case which shouldn't remove empty strings.
+
+    case 'action':
+    case 'formAction':
+      {
+        // TODO: Consider only special casing these for each tag.
+        if (value == null || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'defaultValue':
+    case 'defaultChecked': // These shouldn't be set as attributes on generic HTML elements.
+
+    case 'innerHTML': // Must use dangerouslySetInnerHTML instead.
+
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+      // Ignored. These are built-in to React on the client.
+      return;
+
+    case 'autoFocus':
+    case 'multiple':
+    case 'muted':
+      {
+        pushBooleanAttribute(target, name.toLowerCase(), value);
+        return;
+      }
+
+    case 'xlinkHref':
+      {
+        if (typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk('xlink:href'), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'contentEditable':
+    case 'spellCheck':
+    case 'draggable':
+    case 'value':
+    case 'autoReverse':
+    case 'externalResourcesRequired':
+    case 'focusable':
+    case 'preserveAlpha':
+      {
+        // Booleanish String
+        // These are "enumerated" attributes that accept "true" and "false".
+        // In React, we let users pass `true` and `false` even though technically
+        // these aren't boolean attributes (they are coerced to strings).
+        if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'allowFullScreen':
+    case 'async':
+    case 'autoPlay':
+    case 'controls':
+    case 'default':
+    case 'defer':
+    case 'disabled':
+    case 'disablePictureInPicture':
+    case 'disableRemotePlayback':
+    case 'formNoValidate':
+    case 'hidden':
+    case 'loop':
+    case 'noModule':
+    case 'noValidate':
+    case 'open':
+    case 'playsInline':
+    case 'readOnly':
+    case 'required':
+    case 'reversed':
+    case 'scoped':
+    case 'seamless':
+    case 'itemScope':
+      {
+        // Boolean
+        if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        }
+
+        return;
+      }
+
+    case 'capture':
+    case 'download':
+      {
+        // Overloaded Boolean
+        if (value === true) {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        } else if (value === false) ; else if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'cols':
+    case 'rows':
+    case 'size':
+    case 'span':
+      {
+        // These are HTML attributes that must be positive numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value) && value >= 1) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'rowSpan':
+    case 'start':
+      {
+        // These are HTML attributes that must be numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value)) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'xlinkActuate':
+      pushStringAttribute(target, 'xlink:actuate', value);
+      return;
+
+    case 'xlinkArcrole':
+      pushStringAttribute(target, 'xlink:arcrole', value);
+      return;
+
+    case 'xlinkRole':
+      pushStringAttribute(target, 'xlink:role', value);
+      return;
+
+    case 'xlinkShow':
+      pushStringAttribute(target, 'xlink:show', value);
+      return;
+
+    case 'xlinkTitle':
+      pushStringAttribute(target, 'xlink:title', value);
+      return;
+
+    case 'xlinkType':
+      pushStringAttribute(target, 'xlink:type', value);
+      return;
+
+    case 'xmlBase':
+      pushStringAttribute(target, 'xml:base', value);
+      return;
+
+    case 'xmlLang':
+      pushStringAttribute(target, 'xml:lang', value);
+      return;
+
+    case 'xmlSpace':
+      pushStringAttribute(target, 'xml:space', value);
+      return;
+
+    default:
+      if ( // shouldIgnoreAttribute
+      // We have already filtered out null/undefined and reserved words.
+      name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+        return;
+      }
+
+      const attributeName = getAttributeAlias(name);
+
+      if (isAttributeNameSafe(attributeName)) {
+        // shouldRemoveAttribute
+        switch (typeof value) {
+          case 'function':
+          case 'symbol':
+            // eslint-disable-line
+            return;
+
+          case 'boolean':
+            {
+              const prefix = attributeName.toLowerCase().slice(0, 5);
+
+              if (prefix !== 'data-' && prefix !== 'aria-') {
+                return;
+              }
+            }
+        }
+
+        target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+      }
+
+  }
+}
+
+const endOfStartTag = stringToPrecomputedChunk('>');
+const endOfStartTagSelfClosing = stringToPrecomputedChunk('/>');
+
+function pushInnerHTML(target, innerHTML, children) {
+  if (innerHTML != null) {
+    if (children != null) {
+      throw new Error('Can only set one of `children` or `props.dangerouslySetInnerHTML`.');
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw new Error('`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. ' + 'Please visit https://reactjs.org/link/dangerously-set-inner-html ' + 'for more information.');
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+
+      target.push(stringToChunk('' + html));
+    }
+  }
+} // TODO: Move these to RenderState so that we warn for every request.
+
+function pushStartSelect(target, props) {
+
+  target.push(startChunkForTag('select'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          // TODO: This doesn't really make sense for select since it can't use the controlled
+          // value in the innerHTML.
+          innerHTML = propValue;
+          break;
+
+        case 'defaultValue':
+        case 'value':
+          // These are set on the Context instead and applied to the nested options.
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+function flattenOptionChildren(children) {
+  let content = ''; // Flatten children and warn if they aren't strings or numbers;
+  // invalid types are ignored.
+
+  React.Children.forEach(children, function (child) {
+    if (child == null) {
+      return;
+    }
+
+    content += child;
+  });
+  return content;
+}
+
+const selectedMarkerAttribute = stringToPrecomputedChunk(' selected=""');
+
+function pushStartOption(target, props, formatContext) {
+  const selectedValue = formatContext.selectedValue;
+  target.push(startChunkForTag('option'));
+  let children = null;
+  let value = null;
+  let selected = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'selected':
+          // ignore
+          selected = propValue;
+
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+        // We intentionally fallthrough to also set the attribute on the node.
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (selectedValue != null) {
+    let stringValue;
+
+    if (value !== null) {
+
+      stringValue = '' + value;
+    } else {
+
+      stringValue = flattenOptionChildren(children);
+    }
+
+    if (isArray(selectedValue)) {
+      // multiple
+      for (let i = 0; i < selectedValue.length; i++) {
+
+        const v = '' + selectedValue[i];
+
+        if (v === stringValue) {
+          target.push(selectedMarkerAttribute);
+          break;
+        }
+      }
+    } else {
+
+      if ('' + selectedValue === stringValue) {
+        target.push(selectedMarkerAttribute);
+      }
+    }
+  } else if (selected) {
+    target.push(selectedMarkerAttribute);
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const formReplayingRuntimeScript = stringToPrecomputedChunk(formReplaying);
+
+function injectFormReplayingRuntime(resumableState, renderState) {
+  // If we haven't sent it yet, inject the runtime that tracks submitted JS actions
+  // for later replaying by Fiber. If we use an external runtime, we don't need
+  // to emit anything. It's always used.
+  if ((resumableState.instructions & SentFormReplayingRuntime) === NothingSent && (!renderState.externalRuntimeScript)) {
+    resumableState.instructions |= SentFormReplayingRuntime;
+    renderState.bootstrapChunks.unshift(renderState.startInlineScript, formReplayingRuntimeScript, endInlineScript);
+  }
+}
+
+const formStateMarkerIsMatching = stringToPrecomputedChunk('<!--F!-->');
+const formStateMarkerIsNotMatching = stringToPrecomputedChunk('<!--F-->');
+function pushFormStateMarkerIsMatching(target) {
+  target.push(formStateMarkerIsMatching);
+}
+function pushFormStateMarkerIsNotMatching(target) {
+  target.push(formStateMarkerIsNotMatching);
+}
+
+function pushStartForm(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('form'));
+  let children = null;
+  let innerHTML = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'action':
+          formAction = propValue;
+          break;
+
+        case 'encType':
+          formEncType = propValue;
+          break;
+
+        case 'method':
+          formMethod = propValue;
+          break;
+
+        case 'target':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  let formData = null;
+  let formActionName = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+      formActionName = customFields.name;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('action'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'action', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'encType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'method', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'target', formTarget);
+  }
+
+  target.push(endOfStartTag);
+
+  if (formActionName !== null) {
+    target.push(startHiddenInputChunk);
+    pushStringAttribute(target, 'name', formActionName);
+    target.push(endOfStartTagSelfClosing);
+    pushAdditionalFormFields(target, formData);
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushInput(target, props, resumableState, renderState) {
+
+  target.push(startChunkForTag('input'));
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+  let value = null;
+  let defaultValue = null;
+  let checked = null;
+  let defaultChecked = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('input' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        case 'defaultChecked':
+          defaultChecked = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'checked':
+          checked = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+
+  if (checked !== null) {
+    pushBooleanAttribute(target, 'checked', checked);
+  } else if (defaultChecked !== null) {
+    pushBooleanAttribute(target, 'checked', defaultChecked);
+  }
+
+  if (value !== null) {
+    pushAttribute(target, 'value', value);
+  } else if (defaultValue !== null) {
+    pushAttribute(target, 'value', defaultValue);
+  }
+
+  target.push(endOfStartTagSelfClosing); // We place any additional hidden form fields after the input.
+
+  pushAdditionalFormFields(target, formData);
+  return null;
+}
+
+function pushStartButton(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('button'));
+  let children = null;
+  let innerHTML = null;
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+  target.push(endOfStartTag); // We place any additional hidden form fields we need to include inside the button itself.
+
+  pushAdditionalFormFields(target, formData);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartTextArea(target, props) {
+
+  target.push(startChunkForTag('textarea'));
+  let value = null;
+  let defaultValue = null;
+  let children = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          throw new Error('`dangerouslySetInnerHTML` does not make sense on <textarea>.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (value === null && defaultValue !== null) {
+    value = defaultValue;
+  }
+
+  target.push(endOfStartTag); // TODO (yungsters): Remove support for children content in <textarea>.
+
+  if (children != null) {
+
+    if (value != null) {
+      throw new Error('If you supply `defaultValue` on a <textarea>, do not pass children.');
+    }
+
+    if (isArray(children)) {
+      if (children.length > 1) {
+        throw new Error('<textarea> can only have at most one child.');
+      } // TODO: remove the coercion and the DEV check below because it will
+
+      value = '' + children[0];
+    }
+
+    value = '' + children;
+  }
+
+  if (typeof value === 'string' && value[0] === '\n') {
+    // text/html ignores the first character in these tags if it's a newline
+    // Prefer to break application/xml over text/html (for now) by adding
+    // a newline specifically to get eaten by the parser. (Alternately for
+    // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+    // \r is normalized out by HTMLTextAreaElement#value.)
+    // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+    // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+    // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+    // See: Parsing of "textarea" "listing" and "pre" elements
+    //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+    target.push(leadingNewline);
+  } // ToString and push directly instead of recurse over children.
+  // We don't really support complex children in the value anyway.
+  // This also currently avoids a trailing comment node which breaks textarea.
+
+
+  if (value !== null) {
+
+    target.push(stringToChunk(encodeHTMLTextNode('' + value)));
+  }
+
+  return null;
+}
+
+function pushMeta(target, props, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      return pushSelfClosing(target, props, 'meta');
+    } else {
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      if (typeof props.charSet === 'string') {
+        return pushSelfClosing(renderState.charsetChunks, props, 'meta');
+      } else if (props.name === 'viewport') {
+        // "viewport" isn't related to preconnect but it has the right priority
+        return pushSelfClosing(renderState.preconnectChunks, props, 'meta');
+      } else {
+        return pushSelfClosing(renderState.hoistableChunks, props, 'meta');
+      }
+    }
+  }
+}
+
+function pushLink(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const rel = props.rel;
+    const href = props.href;
+    const precedence = props.precedence;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof rel !== 'string' || typeof href !== 'string' || href === '') {
+
+      pushLinkImpl(target, props);
+      return null;
+    }
+
+    if (props.rel === 'stylesheet') {
+      // This <link> may hoistable as a Stylesheet Resource, otherwise it will emit in place
+      const key = getResourceKey(href);
+
+      if (typeof precedence !== 'string' || props.disabled != null || props.onLoad || props.onError) {
+
+        return pushLinkImpl(target, props);
+      } else {
+        // This stylesheet refers to a Resource and we create a new one if necessary
+        let styleQueue = renderState.styles.get(precedence);
+        const hasKey = resumableState.styleResources.hasOwnProperty(key);
+        const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+        if (resourceState !== EXISTS) {
+          // We are going to create this resource now so it is marked as Exists
+          resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+          // to create a StyleQueue
+
+          if (!styleQueue) {
+            styleQueue = {
+              precedence: stringToChunk(escapeTextForBrowser(precedence)),
+              rules: [],
+              hrefs: [],
+              sheets: new Map()
+            };
+            renderState.styles.set(precedence, styleQueue);
+          }
+
+          const resource = {
+            state: PENDING$1,
+            props: stylesheetPropsFromRawProps(props)
+          };
+
+          if (resourceState) {
+            // When resourceState is truty it is a Preload state. We cast it for clarity
+            const preloadState = resourceState;
+
+            if (preloadState.length === 2) {
+              adoptPreloadCredentials(resource.props, preloadState);
+            }
+
+            const preloadResource = renderState.preloads.stylesheets.get(key);
+
+            if (preloadResource && preloadResource.length > 0) {
+              // The Preload for this resource was created in this render pass and has not flushed yet so
+              // we need to clear it to avoid it flushing.
+              preloadResource.length = 0;
+            } else {
+              // Either the preload resource from this render already flushed in this render pass
+              // or the preload flushed in a prior pass (prerender). In either case we need to mark
+              // this resource as already having been preloaded.
+              resource.state = PRELOADED;
+            }
+          } // We add the newly created resource to our StyleQueue and if necessary
+          // track the resource with the currently rendering boundary
+
+
+          styleQueue.sheets.set(key, resource);
+
+          if (renderState.boundaryResources) {
+            renderState.boundaryResources.stylesheets.add(resource);
+          }
+        } else {
+          // We need to track whether this boundary should wait on this resource or not.
+          // Typically this resource should always exist since we either had it or just created
+          // it. However, it's possible when you resume that the style has already been emitted
+          // and then it wouldn't be recreated in the RenderState and there's no need to track
+          // it again since we should've hoisted it to the shell already.
+          if (styleQueue) {
+            const resource = styleQueue.sheets.get(key);
+
+            if (resource) {
+              if (renderState.boundaryResources) {
+                renderState.boundaryResources.stylesheets.add(resource);
+              }
+            }
+          }
+        }
+
+        if (textEmbedded) {
+          // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+          // to be safe and assume text will follow by inserting a textSeparator
+          target.push(textSeparator);
+        }
+
+        return null;
+      }
+    } else if (props.onLoad || props.onError) {
+      // When using load handlers we cannot hoist and need to emit links in place
+      return pushLinkImpl(target, props);
+    } else {
+      // We can hoist this link so we may need to emit a text separator.
+      // @TODO refactor text separators so we don't have to defensively add
+      // them when we don't end up emitting a tag as a result of pushStartInstance
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      switch (props.rel) {
+        case 'preconnect':
+        case 'dns-prefetch':
+          return pushLinkImpl(renderState.preconnectChunks, props);
+
+        case 'preload':
+          return pushLinkImpl(renderState.preloadChunks, props);
+
+        default:
+          return pushLinkImpl(renderState.hoistableChunks, props);
+      }
+    }
+  }
+}
+
+function pushLinkImpl(target, props) {
+  target.push(startChunkForTag('link'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStyle(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+
+  {
+    const precedence = props.precedence;
+    const href = props.href;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof precedence !== 'string' || typeof href !== 'string' || href === '') {
+      // This style tag is not able to be turned into a Style Resource
+      return pushStyleImpl(target, props);
+    }
+
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS;
+
+      if (!styleQueue) {
+        // This is the first time we've encountered this precedence we need
+        // to create a StyleQueue.
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [stringToChunk(escapeTextForBrowser(href))],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      } else {
+        // We have seen this precedence before and need to track this href
+        styleQueue.hrefs.push(stringToChunk(escapeTextForBrowser(href)));
+      }
+
+      pushStyleContents(styleQueue.rules, props);
+    }
+
+    if (styleQueue) {
+      // We need to track whether this boundary should wait on this resource or not.
+      // Typically this resource should always exist since we either had it or just created
+      // it. However, it's possible when you resume that the style has already been emitted
+      // and then it wouldn't be recreated in the RenderState and there's no need to track
+      // it again since we should've hoisted it to the shell already.
+      if (renderState.boundaryResources) {
+        renderState.boundaryResources.styles.add(styleQueue);
+      }
+    }
+
+    if (textEmbedded) {
+      // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+  }
+}
+
+function pushStyleImpl(target, props) {
+  target.push(startChunkForTag('style'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('style'));
+  return null;
+}
+
+function pushStyleContents(target, props) {
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+      }
+    }
+  }
+
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  return;
+}
+
+function pushImg(target, props, resumableState, renderState, pictureTagInScope) {
+  const src = props.src,
+        srcSet = props.srcSet;
+
+  if (props.loading !== 'lazy' && (src || srcSet) && (typeof src === 'string' || src == null) && (typeof srcSet === 'string' || srcSet == null) && props.fetchPriority !== 'low' && pictureTagInScope === false && // We exclude data URIs in src and srcSet since these should not be preloaded
+  !(typeof src === 'string' && src[4] === ':' && (src[0] === 'd' || src[0] === 'D') && (src[1] === 'a' || src[1] === 'A') && (src[2] === 't' || src[2] === 'T') && (src[3] === 'a' || src[3] === 'A')) && !(typeof srcSet === 'string' && srcSet[4] === ':' && (srcSet[0] === 'd' || srcSet[0] === 'D') && (srcSet[1] === 'a' || srcSet[1] === 'A') && (srcSet[2] === 't' || srcSet[2] === 'T') && (srcSet[3] === 'a' || srcSet[3] === 'A'))) {
+    // We have a suspensey image and ought to preload it to optimize the loading of display blocking
+    // resumableState.
+    const sizes = typeof props.sizes === 'string' ? props.sizes : undefined;
+    const key = getImageResourceKey(src, srcSet, sizes);
+    const promotablePreloads = renderState.preloads.images;
+    let resource = promotablePreloads.get(key);
+
+    if (resource) {
+      // We consider whether this preload can be promoted to higher priority flushing queue.
+      // The only time a resource will exist here is if it was created during this render
+      // and was not already in the high priority queue.
+      if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+        // Delete the resource from the map since we are promoting it and don't want to
+        // reenter this branch in a second pass for duplicate img hrefs.
+        promotablePreloads.delete(key); // $FlowFixMe - Flow should understand that this is a Resource if the condition was true
+
+        renderState.highImagePreloads.add(resource);
+      }
+    } else if (!resumableState.imageResources.hasOwnProperty(key)) {
+      // We must construct a new preload resource
+      resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+      const crossOrigin = getCrossOriginString(props.crossOrigin);
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // this is a hueristic similar to capping element preloads to 10 unless explicitly
+      // fetchPriority="high". We use length here which means it will fit fewer images when
+      // the urls are long and more when short. arguably byte size is a better hueristic because
+      // it directly translates to how much we send down before content is actually seen.
+      // We could unify the counts and also make it so the total is tracked regardless of
+      // flushing output but since the headers are likely to be go earlier than content
+      // they don't really conflict so for now I've kept them separate
+      props.fetchPriority === 'high' || headers.highImagePreloads.length < 500) && ( // We manually construct the options for the preload only from strings. We don't want to pollute
+      // the params list with arbitrary props and if we copied everything over as it we might get
+      // coercion errors. We have checks for this in Dev but it seems safer to just only accept values
+      // that are strings
+      header = getPreloadAsHeader(src, 'image', {
+        imageSrcSet: props.srcSet,
+        imageSizes: props.sizes,
+        crossOrigin,
+        integrity: props.integrity,
+        nonce: props.nonce,
+        type: props.type,
+        fetchPriority: props.fetchPriority,
+        referrerPolicy: props.refererPolicy
+      }), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // If we postpone in the shell we will still emit this preload so we track
+        // it to make sure we don't reset it.
+        renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+        if (headers.highImagePreloads) {
+          headers.highImagePreloads += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.highImagePreloads += header;
+      } else {
+        resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preload',
+          as: 'image',
+          // There is a bug in Safari where imageSrcSet is not respected on preload links
+          // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+          // This harms older browers that do not support imageSrcSet by making their preloads not work
+          // but this population is shrinking fast and is already small so we accept this tradeoff.
+          href: srcSet ? undefined : src,
+          imageSrcSet: srcSet,
+          imageSizes: sizes,
+          crossOrigin: crossOrigin,
+          integrity: props.integrity,
+          type: props.type,
+          fetchPriority: props.fetchPriority,
+          referrerPolicy: props.referrerPolicy
+        });
+
+        if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+          renderState.highImagePreloads.add(resource);
+        } else {
+          renderState.bulkPreloads.add(resource); // We can bump the priority up if the same img is rendered later
+          // with fetchPriority="high"
+
+          promotablePreloads.set(key, resource);
+        }
+      }
+    }
+  }
+
+  return pushSelfClosing(target, props, 'img');
+}
+
+function pushSelfClosing(target, props, tag) {
+  target.push(startChunkForTag(tag));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error(tag + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStartMenuItem(target, props) {
+  target.push(startChunkForTag('menuitem'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('menuitems cannot have `children` nor `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  return null;
+}
+
+function pushTitle(target, props, renderState, insertionMode, noscriptTagInScope) {
+
+  {
+    if (insertionMode !== SVG_MODE && !noscriptTagInScope && props.itemProp == null) {
+      pushTitleImpl(renderState.hoistableChunks, props);
+      return null;
+    } else {
+      return pushTitleImpl(target, props);
+    }
+  }
+}
+
+function pushTitleImpl(target, props) {
+  target.push(startChunkForTag('title'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('title'));
+  return null;
+}
+
+function pushStartHead(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode < HTML_MODE && renderState.headChunks === null) {
+      // This <head> is the Document.head and should be part of the preamble
+      renderState.headChunks = [];
+      return pushStartGenericElement(renderState.headChunks, props, 'head');
+    } else {
+      // This <head> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'head');
+    }
+  }
+}
+
+function pushStartHtml(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode === ROOT_HTML_MODE && renderState.htmlChunks === null) {
+      // This <html> is the Document.documentElement and should be part of the preamble
+      renderState.htmlChunks = [doctypeChunk];
+      return pushStartGenericElement(renderState.htmlChunks, props, 'html');
+    } else {
+      // This <html> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'html');
+    }
+  }
+}
+
+function pushScript(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const asyncProp = props.async;
+
+    if (typeof props.src !== 'string' || !props.src || !(asyncProp && typeof asyncProp !== 'function' && typeof asyncProp !== 'symbol') || props.onLoad || props.onError || insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      // This script will not be a resource, we bailout early and emit it in place.
+      return pushScriptImpl(target, props);
+    }
+
+    const src = props.src;
+    const key = getResourceKey(src); // We can make this <script> into a ScriptResource
+
+    let resources, preloads;
+
+    if (props.type === 'module') {
+      resources = resumableState.moduleScriptResources;
+      preloads = renderState.preloads.moduleScripts;
+    } else {
+      resources = resumableState.scriptResources;
+      preloads = renderState.preloads.scripts;
+    }
+
+    const hasKey = resources.hasOwnProperty(key);
+    const resourceState = hasKey ? resources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resources[key] = EXISTS;
+      let scriptProps = props;
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          scriptProps = assign({}, props);
+          adoptPreloadCredentials(scriptProps, preloadState);
+        }
+
+        const preloadResource = preloads.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, scriptProps);
+    }
+
+    if (textEmbedded) {
+      // This script follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+
+    return null;
+  }
+}
+
+function pushScriptImpl(target, props) {
+  target.push(startChunkForTag('script'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+  }
+
+  target.push(endChunkForTag('script'));
+  return null;
+}
+
+function pushStartGenericElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartCustomElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      let propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      let attributeName = propKey;
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'style':
+          pushStyleAttribute(target, propValue);
+          break;
+
+        case 'suppressContentEditableWarning':
+        case 'suppressHydrationWarning':
+          // Ignored. These are built-in to React on the client.
+          break;
+
+        case 'className':
+
+        // intentional fallthrough
+
+        default:
+          if (isAttributeNameSafe(propKey) && typeof propValue !== 'function' && typeof propValue !== 'symbol') {
+
+            target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(propValue)), attributeEnd);
+          }
+
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const leadingNewline = stringToPrecomputedChunk('\n');
+
+function pushStartPreformattedElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag); // text/html ignores the first character in these tags if it's a newline
+  // Prefer to break application/xml over text/html (for now) by adding
+  // a newline specifically to get eaten by the parser. (Alternately for
+  // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+  // \r is normalized out by HTMLTextAreaElement#value.)
+  // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+  // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+  // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+  // See: Parsing of "textarea" "listing" and "pre" elements
+  //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+  // TODO: This doesn't deal with the case where the child is an array
+  // or component that returns a string.
+
+  if (innerHTML != null) {
+    if (children != null) {
+      throw new Error('Can only set one of `children` or `props.dangerouslySetInnerHTML`.');
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw new Error('`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. ' + 'Please visit https://reactjs.org/link/dangerously-set-inner-html ' + 'for more information.');
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+      if (typeof html === 'string' && html.length > 0 && html[0] === '\n') {
+        target.push(leadingNewline, stringToChunk(html));
+      } else {
+
+        target.push(stringToChunk('' + html));
+      }
+    }
+  }
+
+  if (typeof children === 'string' && children[0] === '\n') {
+    target.push(leadingNewline);
+  }
+
+  return children;
+} // We accept any tag to be rendered but since this gets injected into arbitrary
+// HTML, we want to make sure that it's a safe tag.
+// http://www.w3.org/TR/REC-xml/#NT-Name
+
+
+const VALID_TAG_REGEX = /^[a-zA-Z][a-zA-Z:_\.\-\d]*$/; // Simplified subset
+
+const validatedTagCache = new Map();
+
+function startChunkForTag(tag) {
+  let tagStartChunk = validatedTagCache.get(tag);
+
+  if (tagStartChunk === undefined) {
+    if (!VALID_TAG_REGEX.test(tag)) {
+      throw new Error("Invalid tag: " + tag);
+    }
+
+    tagStartChunk = stringToPrecomputedChunk('<' + tag);
+    validatedTagCache.set(tag, tagStartChunk);
+  }
+
+  return tagStartChunk;
+}
+
+const doctypeChunk = stringToPrecomputedChunk('<!DOCTYPE html>');
+function pushStartInstance(target, type, props, resumableState, renderState, formatContext, textEmbedded) {
+
+  switch (type) {
+    case 'div':
+    case 'span':
+    case 'svg':
+    case 'path':
+    case 'a':
+    case 'g':
+    case 'p':
+    case 'li':
+      // Fast track very common tags
+      break;
+    // Special tags
+
+    case 'select':
+      return pushStartSelect(target, props);
+
+    case 'option':
+      return pushStartOption(target, props, formatContext);
+
+    case 'textarea':
+      return pushStartTextArea(target, props);
+
+    case 'input':
+      return pushInput(target, props, resumableState, renderState);
+
+    case 'button':
+      return pushStartButton(target, props, resumableState, renderState);
+
+    case 'form':
+      return pushStartForm(target, props, resumableState, renderState);
+
+    case 'menuitem':
+      return pushStartMenuItem(target, props);
+
+    case 'title':
+      return pushTitle(target, props, renderState, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'link':
+      return pushLink(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'script':
+      return pushScript(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'style':
+      return pushStyle(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'meta':
+      return pushMeta(target, props, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+    // Newline eating tags
+
+    case 'listing':
+    case 'pre':
+      {
+        return pushStartPreformattedElement(target, props, type);
+      }
+
+    case 'img':
+      {
+        return pushImg(target, props, resumableState, renderState, !!(formatContext.tagScope & PICTURE_SCOPE)) ;
+      }
+    // Omitted close tags
+
+    case 'base':
+    case 'area':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'keygen':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        return pushSelfClosing(target, props, type);
+      }
+    // These are reserved SVG and MathML elements, that are never custom elements.
+    // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+
+    case 'annotation-xml':
+    case 'color-profile':
+    case 'font-face':
+    case 'font-face-src':
+    case 'font-face-uri':
+    case 'font-face-format':
+    case 'font-face-name':
+    case 'missing-glyph':
+      {
+        break;
+      }
+    // Preamble start tags
+
+    case 'head':
+      return pushStartHead(target, props, renderState, formatContext.insertionMode);
+
+    case 'html':
+      {
+        return pushStartHtml(target, props, renderState, formatContext.insertionMode);
+      }
+
+    default:
+      {
+        if (type.indexOf('-') !== -1) {
+          // Custom element
+          return pushStartCustomElement(target, props, type);
+        }
+      }
+  } // Generic element
+
+
+  return pushStartGenericElement(target, props, type);
+}
+const endTagCache = new Map();
+
+function endChunkForTag(tag) {
+  let chunk = endTagCache.get(tag);
+
+  if (chunk === undefined) {
+    chunk = stringToPrecomputedChunk('</' + tag + '>');
+    endTagCache.set(tag, chunk);
+  }
+
+  return chunk;
+}
+
+function pushEndInstance(target, type, props, resumableState, formatContext) {
+  switch (type) {
+    // When float is on we expect title and script tags to always be pushed in
+    // a unit and never return children. when we end up pushing the end tag we
+    // want to ensure there is no extra closing tag pushed
+    case 'title':
+    case 'style':
+    case 'script':
+    // Omitted close tags
+    // TODO: Instead of repeating this switch we could try to pass a flag from above.
+    // That would require returning a tuple. Which might be ok if it gets inlined.
+
+    case 'area':
+    case 'base':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'img':
+    case 'input':
+    case 'keygen':
+    case 'link':
+    case 'meta':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        // No close tag needed.
+        return;
+      }
+    // Postamble end tags
+    // When float is enabled we omit the end tags for body and html when
+    // they represent the Document.body and Document.documentElement Nodes.
+    // This is so we can withhold them until the postamble when we know
+    // we won't emit any more tags
+
+    case 'body':
+      {
+        if (formatContext.insertionMode <= HTML_HTML_MODE) {
+          resumableState.hasBody = true;
+          return;
+        }
+
+        break;
+      }
+
+    case 'html':
+      if (formatContext.insertionMode === ROOT_HTML_MODE) {
+        resumableState.hasHtml = true;
+        return;
+      }
+
+      break;
+  }
+
+  target.push(endChunkForTag(type));
+}
+
+function writeBootstrap(destination, renderState, resumableState) {
+  resumableState.bootstrapScriptContent = undefined;
+  resumableState.bootstrapScripts = undefined;
+  resumableState.bootstrapModules = undefined;
+  const bootstrapChunks = renderState.bootstrapChunks;
+  let i = 0;
+
+  for (; i < bootstrapChunks.length - 1; i++) {
+    writeChunk(destination, bootstrapChunks[i]);
+  }
+
+  if (i < bootstrapChunks.length) {
+    const lastChunk = bootstrapChunks[i];
+    bootstrapChunks.length = 0;
+    return writeChunkAndReturn(destination, lastChunk);
+  }
+
+  return true;
+}
+
+function writeCompletedRoot(destination, renderState, resumableState) {
+  return writeBootstrap(destination, renderState, resumableState);
+} // Structural Nodes
+// A placeholder is a node inside a hidden partial tree that can be filled in later, but before
+// display. It's never visible to users. We use the template tag because it can be used in every
+// type of parent. <script> tags also work in every other tag except <colgroup>.
+
+const placeholder1 = stringToPrecomputedChunk('<template id="');
+const placeholder2 = stringToPrecomputedChunk('"></template>');
+function writePlaceholder(destination, renderState, id) {
+  writeChunk(destination, placeholder1);
+  writeChunk(destination, renderState.placeholderPrefix);
+  const formattedID = stringToChunk(id.toString(16));
+  writeChunk(destination, formattedID);
+  return writeChunkAndReturn(destination, placeholder2);
+} // Suspense boundaries are encoded as comments.
+
+const startCompletedSuspenseBoundary = stringToPrecomputedChunk('<!--$-->');
+const startPendingSuspenseBoundary1 = stringToPrecomputedChunk('<!--$?--><template id="');
+const startPendingSuspenseBoundary2 = stringToPrecomputedChunk('"></template>');
+const startClientRenderedSuspenseBoundary = stringToPrecomputedChunk('<!--$!-->');
+const endSuspenseBoundary = stringToPrecomputedChunk('<!--/$-->');
+const clientRenderedSuspenseBoundaryError1 = stringToPrecomputedChunk('<template');
+const clientRenderedSuspenseBoundaryErrorAttrInterstitial = stringToPrecomputedChunk('"');
+const clientRenderedSuspenseBoundaryError1A = stringToPrecomputedChunk(' data-dgst="');
+const clientRenderedSuspenseBoundaryError2 = stringToPrecomputedChunk('></template>');
+function writeStartCompletedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, startCompletedSuspenseBoundary);
+}
+function writeStartPendingSuspenseBoundary(destination, renderState, id) {
+  writeChunk(destination, startPendingSuspenseBoundary1);
+
+  if (id === null) {
+    throw new Error('An ID must have been assigned before we can complete the boundary.');
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+  return writeChunkAndReturn(destination, startPendingSuspenseBoundary2);
+}
+function writeStartClientRenderedSuspenseBoundary(destination, renderState, errorDigest, errorMesssage, errorComponentStack) {
+  let result;
+  result = writeChunkAndReturn(destination, startClientRenderedSuspenseBoundary);
+  writeChunk(destination, clientRenderedSuspenseBoundaryError1);
+
+  if (errorDigest) {
+    writeChunk(destination, clientRenderedSuspenseBoundaryError1A);
+    writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest)));
+    writeChunk(destination, clientRenderedSuspenseBoundaryErrorAttrInterstitial);
+  }
+
+  result = writeChunkAndReturn(destination, clientRenderedSuspenseBoundaryError2);
+  return result;
+}
+function writeEndCompletedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndPendingSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndClientRenderedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+const startSegmentHTML = stringToPrecomputedChunk('<div hidden id="');
+const startSegmentHTML2 = stringToPrecomputedChunk('">');
+const endSegmentHTML = stringToPrecomputedChunk('</div>');
+const startSegmentSVG = stringToPrecomputedChunk('<svg aria-hidden="true" style="display:none" id="');
+const startSegmentSVG2 = stringToPrecomputedChunk('">');
+const endSegmentSVG = stringToPrecomputedChunk('</svg>');
+const startSegmentMathML = stringToPrecomputedChunk('<math aria-hidden="true" style="display:none" id="');
+const startSegmentMathML2 = stringToPrecomputedChunk('">');
+const endSegmentMathML = stringToPrecomputedChunk('</math>');
+const startSegmentTable = stringToPrecomputedChunk('<table hidden id="');
+const startSegmentTable2 = stringToPrecomputedChunk('">');
+const endSegmentTable = stringToPrecomputedChunk('</table>');
+const startSegmentTableBody = stringToPrecomputedChunk('<table hidden><tbody id="');
+const startSegmentTableBody2 = stringToPrecomputedChunk('">');
+const endSegmentTableBody = stringToPrecomputedChunk('</tbody></table>');
+const startSegmentTableRow = stringToPrecomputedChunk('<table hidden><tr id="');
+const startSegmentTableRow2 = stringToPrecomputedChunk('">');
+const endSegmentTableRow = stringToPrecomputedChunk('</tr></table>');
+const startSegmentColGroup = stringToPrecomputedChunk('<table hidden><colgroup id="');
+const startSegmentColGroup2 = stringToPrecomputedChunk('">');
+const endSegmentColGroup = stringToPrecomputedChunk('</colgroup></table>');
+function writeStartSegment(destination, renderState, formatContext, id) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        writeChunk(destination, startSegmentHTML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentHTML2);
+      }
+
+    case SVG_MODE:
+      {
+        writeChunk(destination, startSegmentSVG);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentSVG2);
+      }
+
+    case MATHML_MODE:
+      {
+        writeChunk(destination, startSegmentMathML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentMathML2);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        writeChunk(destination, startSegmentTable);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTable2);
+      }
+    // TODO: For the rest of these, there will be extra wrapper nodes that never
+    // get deleted from the document. We need to delete the table too as part
+    // of the injected scripts. They are invisible though so it's not too terrible
+    // and it's kind of an edge case to suspend in a table. Totally supported though.
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        writeChunk(destination, startSegmentTableBody);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableBody2);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        writeChunk(destination, startSegmentTableRow);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableRow2);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        writeChunk(destination, startSegmentColGroup);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentColGroup2);
+      }
+
+    default:
+      {
+        throw new Error('Unknown insertion mode. This is a bug in React.');
+      }
+  }
+}
+function writeEndSegment(destination, formatContext) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentHTML);
+      }
+
+    case SVG_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentSVG);
+      }
+
+    case MATHML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentMathML);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTable);
+      }
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableBody);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableRow);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentColGroup);
+      }
+
+    default:
+      {
+        throw new Error('Unknown insertion mode. This is a bug in React.');
+      }
+  }
+}
+const completeSegmentScript1Full = stringToPrecomputedChunk(completeSegment + '$RS("');
+const completeSegmentScript1Partial = stringToPrecomputedChunk('$RS("');
+const completeSegmentScript2 = stringToPrecomputedChunk('","');
+const completeSegmentScriptEnd = stringToPrecomputedChunk('")</script>');
+const completeSegmentData1 = stringToPrecomputedChunk('<template data-rsi="" data-sid="');
+const completeSegmentData2 = stringToPrecomputedChunk('" data-pid="');
+const completeSegmentDataEnd = dataElementQuotedEnd;
+function writeCompletedSegmentInstruction(destination, resumableState, renderState, contentSegmentID) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentCompleteSegmentFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentCompleteSegmentFunction;
+      writeChunk(destination, completeSegmentScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, completeSegmentScript1Partial);
+    }
+  } else {
+    writeChunk(destination, completeSegmentData1);
+  } // Write function arguments, which are string literals
+
+
+  writeChunk(destination, renderState.segmentPrefix);
+  const formattedID = stringToChunk(contentSegmentID.toString(16));
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    writeChunk(destination, completeSegmentScript2);
+  } else {
+    writeChunk(destination, completeSegmentData2);
+  }
+
+  writeChunk(destination, renderState.placeholderPrefix);
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    return writeChunkAndReturn(destination, completeSegmentScriptEnd);
+  } else {
+    return writeChunkAndReturn(destination, completeSegmentDataEnd);
+  }
+}
+const completeBoundaryScript1Full = stringToPrecomputedChunk(completeBoundary + '$RC("');
+const completeBoundaryScript1Partial = stringToPrecomputedChunk('$RC("');
+const completeBoundaryWithStylesScript1FullBoth = stringToPrecomputedChunk(completeBoundary + completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1FullPartial = stringToPrecomputedChunk(completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1Partial = stringToPrecomputedChunk('$RR("');
+const completeBoundaryScript2 = stringToPrecomputedChunk('","');
+const completeBoundaryScript3a = stringToPrecomputedChunk('",');
+const completeBoundaryScript3b = stringToPrecomputedChunk('"');
+const completeBoundaryScriptEnd = stringToPrecomputedChunk(')</script>');
+const completeBoundaryData1 = stringToPrecomputedChunk('<template data-rci="" data-bid="');
+const completeBoundaryWithStylesData1 = stringToPrecomputedChunk('<template data-rri="" data-bid="');
+const completeBoundaryData2 = stringToPrecomputedChunk('" data-sid="');
+const completeBoundaryData3a = stringToPrecomputedChunk('" data-sty="');
+const completeBoundaryDataEnd = dataElementQuotedEnd;
+function writeCompletedBoundaryInstruction(destination, resumableState, renderState, id, boundaryResources) {
+  let requiresStyleInsertion;
+
+  {
+    requiresStyleInsertion = renderState.stylesToHoist; // If necessary stylesheets will be flushed with this instruction.
+    // Any style tags not yet hoisted in the Document will also be hoisted.
+    // We reset this state since after this instruction executes all styles
+    // up to this point will have been hoisted
+
+    renderState.stylesToHoist = false;
+  }
+
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if (requiresStyleInsertion) {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction | SentCompleteBoundaryFunction;
+        writeChunk(destination, clonePrecomputedChunk(completeBoundaryWithStylesScript1FullBoth));
+      } else if ((resumableState.instructions & SentStyleInsertionFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction;
+        writeChunk(destination, completeBoundaryWithStylesScript1FullPartial);
+      } else {
+        writeChunk(destination, completeBoundaryWithStylesScript1Partial);
+      }
+    } else {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentCompleteBoundaryFunction;
+        writeChunk(destination, completeBoundaryScript1Full);
+      } else {
+        writeChunk(destination, completeBoundaryScript1Partial);
+      }
+    }
+  } else {
+    if (requiresStyleInsertion) {
+      writeChunk(destination, completeBoundaryWithStylesData1);
+    } else {
+      writeChunk(destination, completeBoundaryData1);
+    }
+  }
+
+  const idChunk = stringToChunk(id.toString(16));
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, idChunk); // Write function arguments, which are string and array literals
+
+  if (scriptFormat) {
+    writeChunk(destination, completeBoundaryScript2);
+  } else {
+    writeChunk(destination, completeBoundaryData2);
+  }
+
+  writeChunk(destination, renderState.segmentPrefix);
+  writeChunk(destination, idChunk);
+
+  if (requiresStyleInsertion) {
+    // Script and data writers must format this differently:
+    //  - script writer emits an array literal, whose string elements are
+    //    escaped for javascript  e.g. ["A", "B"]
+    //  - data writer emits a string literal, which is escaped as html
+    //    e.g. [&#34;A&#34;, &#34;B&#34;]
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3a); // boundaryResources encodes an array literal
+
+      writeStyleResourceDependenciesInJS(destination, boundaryResources);
+    } else {
+      writeChunk(destination, completeBoundaryData3a);
+      writeStyleResourceDependenciesInAttr(destination, boundaryResources);
+    }
+  } else {
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3b);
+    }
+  }
+
+  let writeMore;
+
+  if (scriptFormat) {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryScriptEnd);
+  } else {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryDataEnd);
+  }
+
+  return writeBootstrap(destination, renderState, resumableState) && writeMore;
+}
+const clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
+const clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
+const clientRenderScript1A = stringToPrecomputedChunk('"');
+const clientRenderErrorScriptArgInterstitial = stringToPrecomputedChunk(',');
+const clientRenderScriptEnd = stringToPrecomputedChunk(')</script>');
+const clientRenderData1 = stringToPrecomputedChunk('<template data-rxi="" data-bid="');
+const clientRenderData2 = stringToPrecomputedChunk('" data-dgst="');
+const clientRenderData3 = stringToPrecomputedChunk('" data-msg="');
+const clientRenderData4 = stringToPrecomputedChunk('" data-stck="');
+const clientRenderDataEnd = dataElementQuotedEnd;
+function writeClientRenderBoundaryInstruction(destination, resumableState, renderState, id, errorDigest, errorMessage, errorComponentStack) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentClientRenderFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentClientRenderFunction;
+      writeChunk(destination, clientRenderScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, clientRenderScript1Partial);
+    }
+  } else {
+    // <template data-rxi="" data-bid="
+    writeChunk(destination, clientRenderData1);
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+
+  if (scriptFormat) {
+    // " needs to be inserted for scripts, since ArgInterstitual does not contain
+    // leading or trailing quotes
+    writeChunk(destination, clientRenderScript1A);
+  }
+
+  if (errorDigest || errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorDigest || '')));
+    } else {
+      // " data-dgst="HTMLString
+      writeChunk(destination, clientRenderData2);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest || '')));
+    }
+  }
+
+  if (errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorMessage || '')));
+    } else {
+      // " data-msg="HTMLString
+      writeChunk(destination, clientRenderData3);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorMessage || '')));
+    }
+  }
+
+  if (errorComponentStack) {
+    // ,"JSONString"
+    if (scriptFormat) {
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorComponentStack)));
+    } else {
+      // " data-stck="HTMLString
+      writeChunk(destination, clientRenderData4);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorComponentStack)));
+    }
+  }
+
+  if (scriptFormat) {
+    // ></script>
+    return writeChunkAndReturn(destination, clientRenderScriptEnd);
+  } else {
+    // "></template>
+    return writeChunkAndReturn(destination, clientRenderDataEnd);
+  }
+}
+const regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
+
+function escapeJSStringsForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInInstructionScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const regexForJSStringsInScripts = /[&><\u2028\u2029]/g;
+
+function escapeJSObjectForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '&':
+        return '\\u0026';
+
+      case '>':
+        return '\\u003e';
+
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const lateStyleTagResourceOpen1 = stringToPrecomputedChunk('<style media="not all" data-precedence="');
+const lateStyleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const lateStyleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const lateStyleTagTemplateClose = stringToPrecomputedChunk('</style>'); // Tracks whether the boundary currently flushing is flushign style tags or has any
+// stylesheet dependencies not flushed in the Preamble.
+
+let currentlyRenderingBoundaryHasStylesToHoist = false; // Acts as a return value for the forEach execution of style tag flushing.
+
+let destinationHasCapacity = true;
+
+function flushStyleTagsLateForBoundary(styleQueue) {
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs;
+
+  let i = 0;
+
+  if (hrefs.length) {
+    writeChunk(this, lateStyleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    writeChunk(this, lateStyleTagResourceOpen2);
+
+    for (; i < hrefs.length - 1; i++) {
+      writeChunk(this, hrefs[i]);
+      writeChunk(this, spaceSeparator);
+    }
+
+    writeChunk(this, hrefs[i]);
+    writeChunk(this, lateStyleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    destinationHasCapacity = writeChunkAndReturn(this, lateStyleTagTemplateClose); // We wrote style tags for this boundary and we may need to emit a script
+    // to hoist them.
+
+    currentlyRenderingBoundaryHasStylesToHoist = true; // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function hasStylesToHoist(stylesheet) {
+  // We need to reveal boundaries with styles whenever a stylesheet it depends on is either
+  // not flushed or flushed after the preamble (shell).
+  if (stylesheet.state !== PREAMBLE) {
+    currentlyRenderingBoundaryHasStylesToHoist = true;
+    return true;
+  }
+
+  return false;
+}
+
+function writeResourcesForBoundary(destination, boundaryResources, renderState) {
+  // Reset these on each invocation, they are only safe to read in this function
+  currentlyRenderingBoundaryHasStylesToHoist = false;
+  destinationHasCapacity = true; // Flush style tags for each precedence this boundary depends on
+
+  boundaryResources.styles.forEach(flushStyleTagsLateForBoundary, destination); // Determine if this boundary has stylesheets that need to be awaited upon completion
+
+  boundaryResources.stylesheets.forEach(hasStylesToHoist);
+
+  if (currentlyRenderingBoundaryHasStylesToHoist) {
+    renderState.stylesToHoist = true;
+  }
+
+  return destinationHasCapacity;
+}
+
+function flushResource(resource) {
+  for (let i = 0; i < resource.length; i++) {
+    writeChunk(this, resource[i]);
+  }
+
+  resource.length = 0;
+}
+
+const stylesheetFlushingQueue = [];
+
+function flushStyleInPreamble(stylesheet, key, map) {
+  // We still need to encode stylesheet chunks
+  // because unlike most Hoistables and Resources we do not eagerly encode
+  // them during render. This is because if we flush late we have to send a
+  // different encoding and we don't want to encode multiple times
+  pushLinkImpl(stylesheetFlushingQueue, stylesheet.props);
+
+  for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+    writeChunk(this, stylesheetFlushingQueue[i]);
+  }
+
+  stylesheetFlushingQueue.length = 0;
+  stylesheet.state = PREAMBLE;
+}
+
+const styleTagResourceOpen1 = stringToPrecomputedChunk('<style data-precedence="');
+const styleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const spaceSeparator = stringToPrecomputedChunk(' ');
+const styleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const styleTagResourceClose = stringToPrecomputedChunk('</style>');
+
+function flushStylesInPreamble(styleQueue, precedence) {
+  const hasStylesheets = styleQueue.sheets.size > 0;
+  styleQueue.sheets.forEach(flushStyleInPreamble, this);
+  styleQueue.sheets.clear();
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs; // If we don't emit any stylesheets at this precedence we still need to maintain the precedence
+  // order so even if there are no rules for style tags at this precedence we emit an empty style
+  // tag with the data-precedence attribute
+
+  if (!hasStylesheets || hrefs.length) {
+    writeChunk(this, styleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    let i = 0;
+
+    if (hrefs.length) {
+      writeChunk(this, styleTagResourceOpen2);
+
+      for (; i < hrefs.length - 1; i++) {
+        writeChunk(this, hrefs[i]);
+        writeChunk(this, spaceSeparator);
+      }
+
+      writeChunk(this, hrefs[i]);
+    }
+
+    writeChunk(this, styleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    writeChunk(this, styleTagResourceClose); // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function preloadLateStyle(stylesheet) {
+  if (stylesheet.state === PENDING$1) {
+    stylesheet.state = PRELOADED;
+    const preloadProps = preloadAsStylePropsFromProps(stylesheet.props.href, stylesheet.props);
+    pushLinkImpl(stylesheetFlushingQueue, preloadProps);
+
+    for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+      writeChunk(this, stylesheetFlushingQueue[i]);
+    }
+
+    stylesheetFlushingQueue.length = 0;
+  }
+}
+
+function preloadLateStyles(styleQueue) {
+  styleQueue.sheets.forEach(preloadLateStyle, this);
+  styleQueue.sheets.clear();
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+
+function writePreamble(destination, resumableState, renderState, willFlushAllSegments) {
+  // This function must be called exactly once on every request
+  if (!willFlushAllSegments && renderState.externalRuntimeScript) {
+    // If the root segment is incomplete due to suspended tasks
+    // (e.g. willFlushAllSegments = false) and we are using data
+    // streaming format, ensure the external runtime is sent.
+    // (User code could choose to send this even earlier by calling
+    //  preinit(...), if they know they will suspend).
+    const _renderState$external = renderState.externalRuntimeScript,
+          src = _renderState$external.src,
+          chunks = _renderState$external.chunks;
+    internalPreinitScript(resumableState, renderState, src, chunks);
+  }
+
+  const htmlChunks = renderState.htmlChunks;
+  const headChunks = renderState.headChunks;
+  let i = 0; // Emit open tags before Hoistables and Resources
+
+  if (htmlChunks) {
+    // We have an <html> to emit as part of the preamble
+    for (i = 0; i < htmlChunks.length; i++) {
+      writeChunk(destination, htmlChunks[i]);
+    }
+
+    if (headChunks) {
+      for (i = 0; i < headChunks.length; i++) {
+        writeChunk(destination, headChunks[i]);
+      }
+    } else {
+      // We did not render a head but we emitted an <html> so we emit one now
+      writeChunk(destination, startChunkForTag('head'));
+      writeChunk(destination, endOfStartTag);
+    }
+  } else if (headChunks) {
+    // We do not have an <html> but we do have a <head>
+    for (i = 0; i < headChunks.length; i++) {
+      writeChunk(destination, headChunks[i]);
+    }
+  } // Emit high priority Hoistables
+
+
+  const charsetChunks = renderState.charsetChunks;
+
+  for (i = 0; i < charsetChunks.length; i++) {
+    writeChunk(destination, charsetChunks[i]);
+  }
+
+  charsetChunks.length = 0; // emit preconnect resources
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Flush unblocked stylesheets by precedence
+
+  renderState.styles.forEach(flushStylesInPreamble, destination);
+  const importMapChunks = renderState.importMapChunks;
+
+  for (i = 0; i < importMapChunks.length; i++) {
+    writeChunk(destination, importMapChunks[i]);
+  }
+
+  importMapChunks.length = 0;
+  renderState.bootstrapScripts.forEach(flushResource, destination);
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0; // Flush closing head if necessary
+
+  if (htmlChunks && headChunks === null) {
+    // We have an <html> rendered but no <head> rendered. We however inserted
+    // a <head> up above so we need to emit the </head> now. This is safe because
+    // if the main content contained the </head> it would also have provided a
+    // <head>. This means that all the content inside <html> is either <body> or
+    // invalid HTML
+    writeChunk(destination, endChunkForTag('head'));
+  }
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+function writeHoistables(destination, resumableState, renderState) {
+  let i = 0; // Emit high priority Hoistables
+  // We omit charsetChunks because we have already sent the shell and if it wasn't
+  // already sent it is too late now.
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Preload any stylesheets. these will emit in a render instruction that follows this
+  // but we want to kick off preloading as soon as possible
+
+  renderState.styles.forEach(preloadLateStyles, destination); // We only hoist importmaps that are configured through createResponse and that will
+  // always flush in the preamble. Generally we don't expect people to render them as
+  // tags when using React but if you do they are going to be treated like regular inline
+  // scripts and flush after other hoistables which is problematic
+  // bootstrap scripts should flush above script priority but these can only flush in the preamble
+  // so we elide the code here for performance
+
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0;
+}
+function writePostamble(destination, resumableState) {
+  if (resumableState.hasBody) {
+    writeChunk(destination, endChunkForTag('body'));
+  }
+
+  if (resumableState.hasHtml) {
+    writeChunk(destination, endChunkForTag('html'));
+  }
+}
+const arrayFirstOpenBracket = stringToPrecomputedChunk('[');
+const arraySubsequentOpenBracket = stringToPrecomputedChunk(',[');
+const arrayInterstitial = stringToPrecomputedChunk(',');
+const arrayCloseBracket = stringToPrecomputedChunk(']'); // This function writes a 2D array of strings to be embedded in javascript.
+// E.g.
+//  [["JS_escaped_string1", "JS_escaped_string2"]]
+
+function writeStyleResourceDependenciesInJS(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInJS(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInJS(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInJS(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+}
+
+function writeStyleResourceDependencyInJS(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedPrecedence)));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          writeStyleResourceAttributeInJS(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInJS(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeName)));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeValue)));
+} // This function writes a 2D array of strings to be embedded in an attribute
+// value and read with JSON.parse in ReactDOMServerExternalRuntime.js
+// E.g.
+//  [[&quot;JSON_escaped_string1&quot;, &quot;JSON_escaped_string2&quot;]]
+
+
+function writeStyleResourceDependenciesInAttr(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInAttr(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInAttr(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInAttr(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+}
+
+function writeStyleResourceDependencyInAttr(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedPrecedence))));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          writeStyleResourceAttributeInAttr(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInAttr(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeName))));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeValue))));
+}
+/**
+ * Resources
+ */
+
+
+const PENDING$1 = 0;
+const PRELOADED = 1;
+const PREAMBLE = 2;
+const LATE = 3;
+function createBoundaryResources() {
+  return {
+    styles: new Set(),
+    stylesheets: new Set()
+  };
+}
+function setCurrentlyRenderingBoundaryResourcesTarget(renderState, boundaryResources) {
+  renderState.boundaryResources = boundaryResources;
+}
+
+function getResourceKey(href) {
+  return href;
+}
+
+function getImageResourceKey(href, imageSrcSet, imageSizes) {
+  if (imageSrcSet) {
+    return imageSrcSet + '\n' + (imageSizes || '');
+  }
+
+  return href;
+}
+
+function prefetchDNS(href) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const key = getResourceKey(href);
+
+    if (!resumableState.dnsResources.hasOwnProperty(key)) {
+      resumableState.dnsResources[key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPrefetchDNSAsHeader(href), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this as resettable in case we are prerendering and postpone in the Shell
+        renderState.resets.dns[key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        // Encode as element
+        const resource = [];
+        pushLinkImpl(resource, {
+          href,
+          rel: 'dns-prefetch'
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preconnect(href, crossOrigin) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const bucket = crossOrigin === 'use-credentials' ? 'credentials' : typeof crossOrigin === 'string' ? 'anonymous' : 'default';
+    const key = getResourceKey(href);
+
+    if (!resumableState.connectResources[bucket].hasOwnProperty(key)) {
+      resumableState.connectResources[bucket][key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPreconnectAsHeader(href, crossOrigin), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this in resettableState in case we are prerending and postpone in the Shell
+        renderState.resets.connect[bucket][key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        const resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preconnect',
+          href,
+          crossOrigin
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preload(href, as, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (as && href) {
+    switch (as) {
+      case 'image':
+        {
+          let imageSrcSet, imageSizes, fetchPriority;
+
+          if (options) {
+            imageSrcSet = options.imageSrcSet;
+            imageSizes = options.imageSizes;
+            fetchPriority = options.fetchPriority;
+          }
+
+          const key = getImageResourceKey(href, imageSrcSet, imageSizes);
+
+          if (resumableState.imageResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && fetchPriority === 'high' && ( // Compute the header since we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit a preload as a header so we
+            // track this to make sure we don't reset it.
+            renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+            if (headers.highImagePreloads) {
+              headers.highImagePreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.highImagePreloads += header;
+          } else {
+            // If we don't have headers to write to we have to encode as elements to flush in the head
+            // When we have imageSrcSet the browser probably cannot load the right version from headers
+            // (this should be verified by testing). For now we assume these need to go in the head
+            // as elements even if headers are available.
+            const resource = [];
+            pushLinkImpl(resource, assign({
+              rel: 'preload',
+              // There is a bug in Safari where imageSrcSet is not respected on preload links
+              // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+              // This harms older browers that do not support imageSrcSet by making their preloads not work
+              // but this population is shrinking fast and is already small so we accept this tradeoff.
+              href: imageSrcSet ? undefined : href,
+              as
+            }, options));
+
+            if (fetchPriority === 'high') {
+              renderState.highImagePreloads.add(resource);
+            } else {
+              renderState.bulkPreloads.add(resource); // Stash the resource in case we need to promote it to higher priority
+              // when an img tag is rendered
+
+              renderState.preloads.images.set(key, resource);
+            }
+          }
+
+          break;
+        }
+
+      case 'style':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.styleResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.styleResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.stylesheets.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          break;
+        }
+
+      case 'script':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.scriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          renderState.preloads.scripts.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.scriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          break;
+        }
+
+      default:
+        {
+          const key = getResourceKey(href);
+          const hasAsType = resumableState.unknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.unknownResources[as] = resources;
+          }
+
+          resources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && as === 'font' && ( // We compute the header here because we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit this preload so we
+            // track it here to prevent it from being reset.
+            renderState.resets.font[key] = PRELOAD_NO_CREDS;
+
+            if (headers.fontPreloads) {
+              headers.fontPreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.fontPreloads += header;
+          } else {
+            // We either don't have headers or we are preloading something that does
+            // not warrant elevated priority so we encode as an element.
+            const resource = [];
+
+            const props = assign({
+              rel: 'preload',
+              href,
+              as
+            }, options);
+
+            pushLinkImpl(resource, props);
+
+            switch (as) {
+              case 'font':
+                renderState.fontPreloads.add(resource);
+                break;
+              // intentional fall through
+
+              default:
+                renderState.bulkPreloads.add(resource);
+            }
+          }
+        }
+    } // If we got this far we created a new resource
+
+
+    flushResources(request);
+  }
+}
+
+function preloadModule(href, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    const key = getResourceKey(href);
+    const as = options && typeof options.as === 'string' ? options.as : 'script';
+    let resource;
+
+    switch (as) {
+      case 'script':
+        {
+          if (resumableState.moduleScriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resource = [];
+          resumableState.moduleScriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.moduleScripts.set(key, resource);
+          break;
+        }
+
+      default:
+        {
+          const hasAsType = resumableState.moduleUnknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.moduleUnknownResources[as] = resources;
+          }
+
+          resource = [];
+          resources[key] = PRELOAD_NO_CREDS;
+        }
+    }
+
+    pushLinkImpl(resource, assign({
+      rel: 'modulepreload',
+      href
+    }, options));
+    renderState.bulkPreloads.add(resource); // If we got this far we created a new resource
+
+    flushResources(request);
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    precedence = precedence || 'default';
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+      // to create a StyleQueue
+
+      if (!styleQueue) {
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      }
+
+      const resource = {
+        state: PENDING$1,
+        props: assign({
+          rel: 'stylesheet',
+          href,
+          'data-precedence': precedence
+        }, options)
+      };
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(resource.props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.stylesheets.get(key);
+
+        if (preloadResource && preloadResource.length > 0) {
+          // The Preload for this resource was created in this render pass and has not flushed yet so
+          // we need to clear it to avoid it flushing.
+          preloadResource.length = 0;
+        } else {
+          // Either the preload resource from this render already flushed in this render pass
+          // or the preload flushed in a prior pass (prerender). In either case we need to mark
+          // this resource as already having been preloaded.
+          resource.state = PRELOADED;
+        }
+      } // We add the newly created resource to our StyleQueue and if necessary
+      // track the resource with the currently rendering boundary
+
+
+      styleQueue.sheets.set(key, resource); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+  }
+}
+
+function preinitScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.scriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.scriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.scriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.scripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+}
+
+function preinitModuleScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.moduleScriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.moduleScriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.moduleScriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        type: 'module',
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.moduleScripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+} // This function is only safe to call at Request start time since it assumes
+// that each module has not already been preloaded. If we find a need to preload
+// scripts at any other point in time we will need to check whether the preload
+// already exists and not assume it
+
+
+function preloadBootstrapScriptOrModule(resumableState, renderState, href, props) {
+
+  const key = getResourceKey(href);
+  // used to preinit the resource. If a script can be preinited then it shouldn't
+  // be a bootstrap script/module and if it is a bootstrap script/module then it
+  // must not be safe to emit early. To avoid possibly allowing for preinits of
+  // bootstrap scripts/modules we occlude these keys.
+
+
+  resumableState.scriptResources[key] = EXISTS;
+  resumableState.moduleScriptResources[key] = EXISTS;
+  const resource = [];
+  pushLinkImpl(resource, props);
+  renderState.bootstrapScripts.add(resource);
+}
+
+function internalPreinitScript(resumableState, renderState, src, chunks) {
+  const key = getResourceKey(src);
+
+  if (!resumableState.scriptResources.hasOwnProperty(key)) {
+    const resource = chunks;
+    resumableState.scriptResources[key] = EXISTS;
+    renderState.scripts.add(resource);
+  }
+
+  return;
+}
+
+function preloadAsStylePropsFromProps(href, props) {
+  return {
+    rel: 'preload',
+    as: 'style',
+    href: href,
+    crossOrigin: props.crossOrigin,
+    fetchPriority: props.fetchPriority,
+    integrity: props.integrity,
+    media: props.media,
+    hrefLang: props.hrefLang,
+    referrerPolicy: props.referrerPolicy
+  };
+}
+
+function stylesheetPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    'data-precedence': rawProps.precedence,
+    precedence: null
+  });
+}
+
+function adoptPreloadCredentials(target, preloadState) {
+  if (target.crossOrigin == null) target.crossOrigin = preloadState[0];
+  if (target.integrity == null) target.integrity = preloadState[1];
+}
+
+function getPrefetchDNSAsHeader(href) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  return "<" + escapedHref + ">; rel=dns-prefetch";
+}
+
+function getPreconnectAsHeader(href, crossOrigin) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  let value = "<" + escapedHref + ">; rel=preconnect";
+
+  if (typeof crossOrigin === 'string') {
+    const escapedCrossOrigin = escapeStringForLinkHeaderQuotedParamValueContext(crossOrigin);
+    value += "; crossorigin=\"" + escapedCrossOrigin + "\"";
+  }
+
+  return value;
+}
+
+function getPreloadAsHeader(href, as, params) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  const escapedAs = escapeStringForLinkHeaderQuotedParamValueContext(as);
+  let value = "<" + escapedHref + ">; rel=preload; as=\"" + escapedAs + "\"";
+
+  for (const paramName in params) {
+    if (hasOwnProperty.call(params, paramName)) {
+      const paramValue = params[paramName];
+
+      if (typeof paramValue === 'string') {
+        value += "; " + paramName.toLowerCase() + "=\"" + escapeStringForLinkHeaderQuotedParamValueContext(paramValue) + "\"";
+      }
+    }
+  }
+
+  return value;
+}
+
+function getStylesheetPreloadAsHeader(stylesheet) {
+  const props = stylesheet.props;
+  const preloadOptions = {
+    crossOrigin: props.crossOrigin,
+    integrity: props.integrity,
+    nonce: props.nonce,
+    type: props.type,
+    fetchPriority: props.fetchPriority,
+    referrerPolicy: props.referrerPolicy,
+    media: props.media
+  };
+  return getPreloadAsHeader(props.href, 'style', preloadOptions);
+} // This escaping function is only safe to use for href values being written into
+// a "Link" header in between `<` and `>` characters. The primary concern with the href is
+// to escape the bounding characters as well as new lines. This is unsafe to use in any other
+// context
+
+
+const regexForHrefInLinkHeaderURLContext = /[<>\r\n]/g;
+
+function escapeHrefForLinkHeaderURLContext(hrefInput) {
+
+  const coercedHref = '' + hrefInput;
+  return coercedHref.replace(regexForHrefInLinkHeaderURLContext, escapeHrefForLinkHeaderURLContextReplacer);
+}
+
+function escapeHrefForLinkHeaderURLContextReplacer(match) {
+  switch (match) {
+    case '<':
+      return '%3C';
+
+    case '>':
+      return '%3E';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeLinkHrefForHeaderContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+} // This escaping function is only safe to use for quoted param values in an HTTP header.
+// It is unsafe to use for any value not inside quote marks in parater value position.
+
+
+const regexForLinkHeaderQuotedParamValueContext = /["';,\r\n]/g;
+
+function escapeStringForLinkHeaderQuotedParamValueContext(value, name) {
+
+  const coerced = '' + value;
+  return coerced.replace(regexForLinkHeaderQuotedParamValueContext, escapeStringForLinkHeaderQuotedParamValueContextReplacer);
+}
+
+function escapeStringForLinkHeaderQuotedParamValueContextReplacer(match) {
+  switch (match) {
+    case '"':
+      return '%22';
+
+    case "'":
+      return '%27';
+
+    case ';':
+      return '%3B';
+
+    case ',':
+      return '%2C';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeStringForLinkHeaderQuotedParamValueContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+}
+
+function hoistStyleQueueDependency(styleQueue) {
+  this.styles.add(styleQueue);
+}
+
+function hoistStylesheetDependency(stylesheet) {
+  this.stylesheets.add(stylesheet);
+}
+
+function hoistResources(renderState, source) {
+  const currentBoundaryResources = renderState.boundaryResources;
+
+  if (currentBoundaryResources) {
+    source.styles.forEach(hoistStyleQueueDependency, currentBoundaryResources);
+    source.stylesheets.forEach(hoistStylesheetDependency, currentBoundaryResources);
+  }
+} // This function is called at various times depending on whether we are rendering
+// or prerendering. In this implementation we only actually emit headers once and
+// subsequent calls are ignored. We track whether the request has a completed shell
+// to determine whether we will follow headers with a flush including stylesheets.
+// In the context of prerrender we don't have a completed shell when the request finishes
+// with a postpone in the shell. In the context of a render we don't have a completed shell
+// if this is called before the shell finishes rendering which usually will happen anytime
+// anything suspends in the shell.
+
+function emitEarlyPreloads(renderState, resumableState, shellComplete) {
+  const onHeaders = renderState.onHeaders;
+
+  if (onHeaders) {
+    const headers = renderState.headers;
+
+    if (headers) {
+      let linkHeader = headers.preconnects;
+
+      if (headers.fontPreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.fontPreloads;
+      }
+
+      if (headers.highImagePreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.highImagePreloads;
+      }
+
+      if (!shellComplete) {
+        // We use raw iterators because we want to be able to halt iteration
+        // We could refactor renderState to store these dually in arrays to
+        // make this more efficient at the cost of additional memory and
+        // write overhead. However this code only runs once per request so
+        // for now I consider this sufficient.
+        const queueIter = renderState.styles.values();
+
+        outer: for (let queueStep = queueIter.next(); headers.remainingCapacity > 0 && !queueStep.done; queueStep = queueIter.next()) {
+          const sheets = queueStep.value.sheets;
+          const sheetIter = sheets.values();
+
+          for (let sheetStep = sheetIter.next(); headers.remainingCapacity > 0 && !sheetStep.done; sheetStep = sheetIter.next()) {
+            const sheet = sheetStep.value;
+            const props = sheet.props;
+            const key = getResourceKey(props.href);
+            const header = getStylesheetPreloadAsHeader(sheet); // We mutate the capacity b/c we don't want to keep checking if later headers will fit.
+            // This means that a particularly long header might close out the header queue where later
+            // headers could still fit. We could in the future alter the behavior here based on prerender vs render
+            // since during prerender we aren't as concerned with pure runtime performance.
+
+            if ((headers.remainingCapacity -= header.length) >= 2) {
+              renderState.resets.style[key] = PRELOAD_NO_CREDS;
+
+              if (linkHeader) {
+                linkHeader += ', ';
+              }
+
+              linkHeader += header; // We already track that the resource exists in resumableState however
+              // if the resumableState resets because we postponed in the shell
+              // which is what is happening in this branch if we are prerendering
+              // then we will end up resetting the resumableState. When it resets we
+              // want to record the fact that this stylesheet was already preloaded
+
+              renderState.resets.style[key] = typeof props.crossOrigin === 'string' || typeof props.integrity === 'string' ? [props.crossOrigin, props.integrity] : PRELOAD_NO_CREDS;
+            } else {
+              break outer;
+            }
+          }
+        }
+      }
+
+      if (linkHeader) {
+        onHeaders({
+          Link: linkHeader
+        });
+      } else {
+        // We still call this with no headers because a user may be using it as a signal that
+        // it React will not provide any headers
+        onHeaders({});
+      }
+
+      renderState.headers = null;
+      return;
+    }
+  }
+}
+const NotPendingTransition = NotPending;
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+const REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_CONTEXT_TYPE = Symbol.for('react.context');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SCOPE_TYPE = Symbol.for('react.scope');
+const REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');
+const REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+const REACT_LEGACY_HIDDEN_TYPE = Symbol.for('react.legacy_hidden');
+const REACT_CACHE_TYPE = Symbol.for('react.cache');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+function getWrappedName(outerType, innerType, wrapperName) {
+  const displayName = outerType.displayName;
+
+  if (displayName) {
+    return displayName;
+  }
+
+  const functionName = innerType.displayName || innerType.name || '';
+  return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
+} // Keep in sync with react-reconciler/getComponentNameFromFiber
+
+
+function getContextName(type) {
+  return type.displayName || 'Context';
+} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+
+function getComponentNameFromType(type) {
+  if (type == null) {
+    // Host root, text node or just invalid type.
+    return null;
+  }
+
+  if (typeof type === 'function') {
+    return type.displayName || type.name || null;
+  }
+
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_FRAGMENT_TYPE:
+      return 'Fragment';
+
+    case REACT_PORTAL_TYPE:
+      return 'Portal';
+
+    case REACT_PROFILER_TYPE:
+      return 'Profiler';
+
+    case REACT_STRICT_MODE_TYPE:
+      return 'StrictMode';
+
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+
+    case REACT_CACHE_TYPE:
+      {
+        return 'Cache';
+      }
+
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        const context = type;
+        return getContextName(context) + '.Consumer';
+
+      case REACT_PROVIDER_TYPE:
+        const provider = type;
+        return getContextName(provider._context) + '.Provider';
+
+      case REACT_FORWARD_REF_TYPE:
+        return getWrappedName(type, type.render, 'ForwardRef');
+
+      case REACT_MEMO_TYPE:
+        const outerName = type.displayName || null;
+
+        if (outerName !== null) {
+          return outerName;
+        }
+
+        return getComponentNameFromType(type.type) || 'Memo';
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            return getComponentNameFromType(init(payload));
+          } catch (x) {
+            return null;
+          }
+        }
+
+    }
+  }
+
+  return null;
+}
+
+const emptyContextObject = {};
+
+function getMaskedContext(type, unmaskedContext) {
+  {
+    const contextTypes = type.contextTypes;
+
+    if (!contextTypes) {
+      return emptyContextObject;
+    }
+
+    const context = {};
+
+    for (const key in contextTypes) {
+      context[key] = unmaskedContext[key];
+    }
+
+    return context;
+  }
+}
+function processChildContext(instance, type, parentContext, childContextTypes) {
+  {
+    // TODO (bvaughn) Replace this behavior with an invariant() in the future.
+    // It has only been added in Fiber to match the (unintentional) behavior in Stack.
+    if (typeof instance.getChildContext !== 'function') {
+
+      return parentContext;
+    }
+
+    const childContext = instance.getChildContext();
+
+    for (const contextKey in childContext) {
+      if (!(contextKey in childContextTypes)) {
+        throw new Error((getComponentNameFromType(type) || 'Unknown') + ".getChildContext(): key \"" + contextKey + "\" is not defined in childContextTypes.");
+      }
+    }
+
+    return assign({}, parentContext, childContext);
+  }
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext);
+    } // On the way back, we push the new ones that weren't common.
+
+
+    pushNode(next);
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function pushProvider(context, nextValue) {
+  let prevValue;
+
+  {
+    prevValue = context._currentValue;
+    context._currentValue = nextValue;
+  }
+
+  const prevNode = currentActiveSnapshot;
+  const newNode = {
+    parent: prevNode,
+    depth: prevNode === null ? 0 : prevNode.depth + 1,
+    context: context,
+    parentValue: prevValue,
+    value: nextValue
+  };
+  currentActiveSnapshot = newNode;
+  return newNode;
+}
+function popProvider(context) {
+  const prevSnapshot = currentActiveSnapshot;
+
+  if (prevSnapshot === null) {
+    throw new Error('Tried to pop a Context at the root of the app. This is a bug in React.');
+  }
+
+  {
+    const value = prevSnapshot.parentValue;
+
+    if (value === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      prevSnapshot.context._currentValue = prevSnapshot.context._defaultValue;
+    } else {
+      prevSnapshot.context._currentValue = value;
+    }
+  }
+
+  return currentActiveSnapshot = prevSnapshot.parent;
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+/**
+ * `ReactInstanceMap` maintains a mapping from a public facing stateful
+ * instance (key) and the internal representation (value). This allows public
+ * methods to accept the user facing instance as an argument and map them back
+ * to internal methods.
+ *
+ * Note that this module is currently shared and assumed to be stateless.
+ * If this becomes an actual Map, that will break.
+ */
+function get(key) {
+  return key._reactInternals;
+}
+function set(key, value) {
+  key._reactInternals = value;
+}
+
+const classComponentUpdater = {
+  isMounted(inst) {
+    return false;
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueSetState(inst, payload, callback) {
+    const internals = get(inst);
+
+    if (internals.queue === null) ; else {
+      internals.queue.push(payload);
+    }
+  },
+
+  enqueueReplaceState(inst, payload, callback) {
+    const internals = get(inst);
+    internals.replace = true;
+    internals.queue = [payload];
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueForceUpdate(inst, callback) {
+  }
+
+};
+
+function applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, prevState, nextProps) {
+  const partialState = getDerivedStateFromProps(nextProps, prevState);
+
+
+  const newState = partialState === null || partialState === undefined ? prevState : assign({}, prevState, partialState);
+  return newState;
+}
+
+function constructClassInstance(ctor, props, maskedLegacyContext) {
+  let context = emptyContextObject;
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    context = readContext$1(contextType);
+  } else {
+    context = maskedLegacyContext;
+  }
+
+  const instance = new ctor(props, context);
+
+  return instance;
+}
+
+function callComponentWillMount(type, instance) {
+  const oldState = instance.state;
+
+  if (typeof instance.componentWillMount === 'function') {
+
+    instance.componentWillMount();
+  }
+
+  if (typeof instance.UNSAFE_componentWillMount === 'function') {
+    instance.UNSAFE_componentWillMount();
+  }
+
+  if (oldState !== instance.state) {
+
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+}
+
+function processUpdateQueue(internalInstance, inst, props, maskedLegacyContext) {
+  if (internalInstance.queue !== null && internalInstance.queue.length > 0) {
+    const oldQueue = internalInstance.queue;
+    const oldReplace = internalInstance.replace;
+    internalInstance.queue = null;
+    internalInstance.replace = false;
+
+    if (oldReplace && oldQueue.length === 1) {
+      inst.state = oldQueue[0];
+    } else {
+      let nextState = oldReplace ? oldQueue[0] : inst.state;
+      let dontMutate = true;
+
+      for (let i = oldReplace ? 1 : 0; i < oldQueue.length; i++) {
+        const partial = oldQueue[i];
+        const partialState = typeof partial === 'function' ? partial.call(inst, nextState, props, maskedLegacyContext) : partial;
+
+        if (partialState != null) {
+          if (dontMutate) {
+            dontMutate = false;
+            nextState = assign({}, nextState, partialState);
+          } else {
+            assign(nextState, partialState);
+          }
+        }
+      }
+
+      inst.state = nextState;
+    }
+  } else {
+    internalInstance.queue = null;
+  }
+} // Invokes the mount life-cycles on a previously never rendered instance.
+
+
+function mountClassInstance(instance, ctor, newProps, maskedLegacyContext) {
+
+  const initialState = instance.state !== undefined ? instance.state : null;
+  instance.updater = classComponentUpdater;
+  instance.props = newProps;
+  instance.state = initialState; // We don't bother initializing the refs object on the server, since we're not going to resolve them anyway.
+  // The internal instance will be used to manage updates that happen during this mount.
+
+  const internalInstance = {
+    queue: [],
+    replace: false
+  };
+  set(instance, internalInstance);
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    instance.context = readContext$1(contextType);
+  } else {
+    instance.context = maskedLegacyContext;
+  }
+
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    instance.state = applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, initialState, newProps);
+  } // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+
+  if (typeof ctor.getDerivedStateFromProps !== 'function' && typeof instance.getSnapshotBeforeUpdate !== 'function' && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
+    callComponentWillMount(ctor, instance); // If we had additional state updates during this life-cycle, let's
+    // process them now.
+
+    processUpdateQueue(internalInstance, instance, newProps, maskedLegacyContext);
+  }
+}
+
+// Ids are base 32 strings whose binary representation corresponds to the
+// position of a node in a tree.
+// Every time the tree forks into multiple children, we add additional bits to
+// the left of the sequence that represent the position of the child within the
+// current level of children.
+//
+//      00101       00010001011010101
+//      ╰─┬─╯       ╰───────┬───────╯
+//   Fork 5 of 20       Parent id
+//
+// The leading 0s are important. In the above example, you only need 3 bits to
+// represent slot 5. However, you need 5 bits to represent all the forks at
+// the current level, so we must account for the empty bits at the end.
+//
+// For this same reason, slots are 1-indexed instead of 0-indexed. Otherwise,
+// the zeroth id at a level would be indistinguishable from its parent.
+//
+// If a node has only one child, and does not materialize an id (i.e. does not
+// contain a useId hook), then we don't need to allocate any space in the
+// sequence. It's treated as a transparent indirection. For example, these two
+// trees produce the same ids:
+//
+// <>                          <>
+//   <Indirection>               <A />
+//     <A />                     <B />
+//   </Indirection>            </>
+//   <B />
+// </>
+//
+// However, we cannot skip any node that materializes an id. Otherwise, a parent
+// id that does not fork would be indistinguishable from its child id. For
+// example, this tree does not fork, but the parent and child must have
+// different ids.
+//
+// <Parent>
+//   <Child />
+// </Parent>
+//
+// To handle this scenario, every time we materialize an id, we allocate a
+// new level with a single slot. You can think of this as a fork with only one
+// prong, or an array of children with length 1.
+//
+// It's possible for the size of the sequence to exceed 32 bits, the max
+// size for bitwise operations. When this happens, we make more room by
+// converting the right part of the id to a string and storing it in an overflow
+// variable. We use a base 32 string representation, because 32 is the largest
+// power of 2 that is supported by toString(). We want the base to be large so
+// that the resulting ids are compact, and we want the base to be a power of 2
+// because every log2(base) bits corresponds to a single character, i.e. every
+// log2(32) = 5 bits. That means we can lop bits off the end 5 at a time without
+// affecting the final result.
+const emptyTreeContext = {
+  id: 1,
+  overflow: ''
+};
+function getTreeId(context) {
+  const overflow = context.overflow;
+  const idWithLeadingBit = context.id;
+  const id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
+  return id.toString(32) + overflow;
+}
+function pushTreeContext(baseContext, totalChildren, index) {
+  const baseIdWithLeadingBit = baseContext.id;
+  const baseOverflow = baseContext.overflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
+  // of the id; we use it to account for leading 0s.
+
+  const baseLength = getBitLength(baseIdWithLeadingBit) - 1;
+  const baseId = baseIdWithLeadingBit & ~(1 << baseLength);
+  const slot = index + 1;
+  const length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
+  // consideration the leading 1 we use to mark the end of the sequence.
+
+  if (length > 30) {
+    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
+    // This branch assumes the length of the base id is greater than 5; it won't
+    // work for smaller ids, because you need 5 bits per character.
+    //
+    // We encode the id in multiple steps: first the base id, then the
+    // remaining digits.
+    //
+    // Each 5 bit sequence corresponds to a single base 32 character. So for
+    // example, if the current id is 23 bits long, we can convert 20 of those
+    // bits into a string of 4 characters, with 3 bits left over.
+    //
+    // First calculate how many bits in the base id represent a complete
+    // sequence of characters.
+    const numberOfOverflowBits = baseLength - baseLength % 5; // Then create a bitmask that selects only those bits.
+
+    const newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
+
+    const newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
+
+    const restOfBaseId = baseId >> numberOfOverflowBits;
+    const restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
+    // we made more room, this time it won't overflow.
+
+    const restOfLength = getBitLength(totalChildren) + restOfBaseLength;
+    const restOfNewBits = slot << restOfBaseLength;
+    const id = restOfNewBits | restOfBaseId;
+    const overflow = newOverflow + baseOverflow;
+    return {
+      id: 1 << restOfLength | id,
+      overflow
+    };
+  } else {
+    // Normal path
+    const newBits = slot << baseLength;
+    const id = newBits | baseId;
+    const overflow = baseOverflow;
+    return {
+      id: 1 << length | id,
+      overflow
+    };
+  }
+}
+
+function getBitLength(number) {
+  return 32 - clz32(number);
+}
+
+function getLeadingBit(id) {
+  return 1 << getBitLength(id) - 1;
+} // TODO: Math.clz32 is supported in Node 12+. Maybe we can drop the fallback.
+
+
+const 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
+
+const log = Math.log;
+const LN2 = Math.LN2;
+
+function clz32Fallback(x) {
+  const asUint = x >>> 0;
+
+  if (asUint === 0) {
+    return 32;
+  }
+
+  return 31 - (log(asUint) / LN2 | 0) | 0;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFlightWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop$2() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop$2, noop$2);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+
+const objectIs = // $FlowFixMe[method-unbinding]
+typeof Object.is === 'function' ? Object.is : is;
+
+let currentlyRenderingComponent = null;
+let currentlyRenderingTask = null;
+let currentlyRenderingRequest = null;
+let currentlyRenderingKeyPath = null;
+let firstWorkInProgressHook = null;
+let workInProgressHook = null; // Whether the work-in-progress hook is a re-rendered hook
+
+let isReRender = false; // Whether an update was scheduled during the currently executing render pass.
+
+let didScheduleRenderPhaseUpdate = false; // Counts the number of useId hooks in this component
+
+let localIdCounter = 0; // Chunks that should be pushed to the stream once the component
+// finishes rendering.
+// Counts the number of useFormState calls in this component
+
+let formStateCounter = 0; // The index of the useFormState hook that matches the one passed in at the
+// root during an MPA navigation, if any.
+
+let formStateMatchingIndex = -1; // Counts the number of use(thenable) calls in this component
+
+let thenableIndexCounter = 0;
+let thenableState = null; // Lazily created map of render-phase updates
+
+let renderPhaseUpdates = null; // Counter to prevent infinite loops.
+
+let numberOfReRenders = 0;
+const RE_RENDER_LIMIT = 25;
+
+function resolveCurrentlyRenderingComponent() {
+  if (currentlyRenderingComponent === null) {
+    throw new Error('Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for' + ' one of the following reasons:\n' + '1. You might have mismatching versions of React and the renderer (such as React DOM)\n' + '2. You might be breaking the Rules of Hooks\n' + '3. You might have more than one copy of React in the same app\n' + 'See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.');
+  }
+
+  return currentlyRenderingComponent;
+}
+
+function areHookInputsEqual(nextDeps, prevDeps) {
+  if (prevDeps === null) {
+
+    return false;
+  }
+
+
+  for (let i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    if (objectIs(nextDeps[i], prevDeps[i])) {
+      continue;
+    }
+
+    return false;
+  }
+
+  return true;
+}
+
+function createHook() {
+  if (numberOfReRenders > 0) {
+    throw new Error('Rendered more hooks than during the previous render');
+  }
+
+  return {
+    memoizedState: null,
+    queue: null,
+    next: null
+  };
+}
+
+function createWorkInProgressHook() {
+  if (workInProgressHook === null) {
+    // This is the first hook in the list
+    if (firstWorkInProgressHook === null) {
+      isReRender = false;
+      firstWorkInProgressHook = workInProgressHook = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = firstWorkInProgressHook;
+    }
+  } else {
+    if (workInProgressHook.next === null) {
+      isReRender = false; // Append to the end of the list
+
+      workInProgressHook = workInProgressHook.next = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = workInProgressHook.next;
+    }
+  }
+
+  return workInProgressHook;
+}
+
+function prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState) {
+  currentlyRenderingComponent = componentIdentity;
+  currentlyRenderingTask = task;
+  currentlyRenderingRequest = request;
+  currentlyRenderingKeyPath = keyPath;
+  // didScheduleRenderPhaseUpdate = false;
+  // firstWorkInProgressHook = null;
+  // numberOfReRenders = 0;
+  // renderPhaseUpdates = null;
+  // workInProgressHook = null;
+
+
+  localIdCounter = 0;
+  formStateCounter = 0;
+  formStateMatchingIndex = -1;
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function finishHooks(Component, props, children, refOrContext) {
+  // This must be called after every function component to prevent hooks from
+  // being used in classes.
+  while (didScheduleRenderPhaseUpdate) {
+    // Updates were scheduled during the render phase. They are stored in
+    // the `renderPhaseUpdates` map. Call the component again, reusing the
+    // work-in-progress hooks and applying the additional updates on top. Keep
+    // restarting until no more updates are scheduled.
+    didScheduleRenderPhaseUpdate = false;
+    localIdCounter = 0;
+    formStateCounter = 0;
+    formStateMatchingIndex = -1;
+    thenableIndexCounter = 0;
+    numberOfReRenders += 1; // Start over from the beginning of the list
+
+    workInProgressHook = null;
+    children = Component(props, refOrContext);
+  }
+
+  resetHooksState();
+  return children;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+function checkDidRenderIdHook() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  const didRenderIdHook = localIdCounter !== 0;
+  return didRenderIdHook;
+}
+function getFormStateCount() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateCounter;
+}
+function getFormStateMatchingIndex() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateMatchingIndex;
+} // Reset the internal hooks state if an error occurs while rendering a component
+
+function resetHooksState() {
+
+  currentlyRenderingComponent = null;
+  currentlyRenderingTask = null;
+  currentlyRenderingRequest = null;
+  currentlyRenderingKeyPath = null;
+  didScheduleRenderPhaseUpdate = false;
+  firstWorkInProgressHook = null;
+  numberOfReRenders = 0;
+  renderPhaseUpdates = null;
+  workInProgressHook = null;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+function useContext(context) {
+
+  resolveCurrentlyRenderingComponent();
+  return readContext$1(context);
+}
+
+function basicStateReducer(state, action) {
+  // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
+  return typeof action === 'function' ? action(state) : action;
+}
+
+function useState(initialState) {
+
+  return useReducer(basicStateReducer, // useReducer has a special case to support lazy useState initializers
+  initialState);
+}
+function useReducer(reducer, initialArg, init) {
+
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+
+  if (isReRender) {
+    // This is a re-render. Apply the new render phase updates to the previous
+    // current hook.
+    const queue = workInProgressHook.queue;
+    const dispatch = queue.dispatch;
+
+    if (renderPhaseUpdates !== null) {
+      // Render phase updates are stored in a map of queue -> linked list
+      const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+      if (firstRenderPhaseUpdate !== undefined) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        renderPhaseUpdates.delete(queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+        let newState = workInProgressHook.memoizedState;
+        let update = firstRenderPhaseUpdate;
+
+        do {
+          // Process this render phase update. We don't have to check the
+          // priority because it will always be the same as the current
+          // render's.
+          const action = update.action;
+
+          newState = reducer(newState, action);
+
+
+          update = update.next;
+        } while (update !== null); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+        workInProgressHook.memoizedState = newState;
+        return [newState, dispatch];
+      }
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    return [workInProgressHook.memoizedState, dispatch];
+  } else {
+
+    let initialState;
+
+    if (reducer === basicStateReducer) {
+      // Special case for `useState`.
+      initialState = typeof initialArg === 'function' ? initialArg() : initialArg;
+    } else {
+      initialState = init !== undefined ? init(initialArg) : initialArg;
+    }
+
+
+    workInProgressHook.memoizedState = initialState; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    const queue = workInProgressHook.queue = {
+      last: null,
+      dispatch: null
+    };
+    const dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingComponent, queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    return [workInProgressHook.memoizedState, dispatch];
+  }
+}
+
+function useMemo(nextCreate, deps) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+
+  if (workInProgressHook !== null) {
+    const prevState = workInProgressHook.memoizedState;
+
+    if (prevState !== null) {
+      if (nextDeps !== null) {
+        const prevDeps = prevState[1];
+
+        if (areHookInputsEqual(nextDeps, prevDeps)) {
+          return prevState[0];
+        }
+      }
+    }
+  }
+
+  const nextValue = nextCreate();
+
+
+  workInProgressHook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
+
+function useRef(initialValue) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const previousRef = workInProgressHook.memoizedState;
+
+  if (previousRef === null) {
+    const ref = {
+      current: initialValue
+    };
+
+
+    workInProgressHook.memoizedState = ref;
+    return ref;
+  } else {
+    return previousRef;
+  }
+}
+
+function dispatchAction(componentIdentity, queue, action) {
+  if (numberOfReRenders >= RE_RENDER_LIMIT) {
+    throw new Error('Too many re-renders. React limits the number of renders to prevent ' + 'an infinite loop.');
+  }
+
+  if (componentIdentity === currentlyRenderingComponent) {
+    // This is a render phase update. Stash it in a lazily-created map of
+    // queue -> linked list of updates. After this render pass, we'll restart
+    // and apply the stashed updates on top of the work-in-progress hook.
+    didScheduleRenderPhaseUpdate = true;
+    const update = {
+      action,
+      next: null
+    };
+
+    if (renderPhaseUpdates === null) {
+      renderPhaseUpdates = new Map();
+    }
+
+    const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+    if (firstRenderPhaseUpdate === undefined) {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      renderPhaseUpdates.set(queue, update);
+    } else {
+      // Append the update to the end of the list.
+      let lastRenderPhaseUpdate = firstRenderPhaseUpdate;
+
+      while (lastRenderPhaseUpdate.next !== null) {
+        lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+      }
+
+      lastRenderPhaseUpdate.next = update;
+    }
+  }
+}
+
+function useCallback(callback, deps) {
+  return useMemo(() => callback, deps);
+}
+
+function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  if (getServerSnapshot === undefined) {
+    throw new Error('Missing getServerSnapshot, which is required for ' + 'server-rendered content. Will revert to client rendering.');
+  }
+
+  return getServerSnapshot();
+}
+
+function useDeferredValue(value, initialValue) {
+  resolveCurrentlyRenderingComponent();
+
+  {
+    return value;
+  }
+}
+
+function unsupportedStartTransition() {
+  throw new Error('startTransition cannot be called during server rendering.');
+}
+
+function useTransition() {
+  resolveCurrentlyRenderingComponent();
+  return [false, unsupportedStartTransition];
+}
+
+function useHostTransitionStatus() {
+  resolveCurrentlyRenderingComponent();
+  return NotPendingTransition;
+}
+
+function unsupportedSetOptimisticState() {
+  throw new Error('Cannot update optimistic state while rendering.');
+}
+
+function useOptimistic(passthrough, reducer) {
+  resolveCurrentlyRenderingComponent();
+  return [passthrough, unsupportedSetOptimisticState];
+}
+
+function createPostbackFormStateKey(permalink, componentKeyPath, hookIndex) {
+  if (permalink !== undefined) {
+    // Don't bother to hash a permalink-based key since it's already short.
+    return 'p' + permalink;
+  } else {
+    // Append a node to the key path that represents the form state hook.
+    const keyPath = [componentKeyPath, null, hookIndex]; // Key paths are hashed to reduce the size. It does not need to be secure,
+    // and it's more important that it's fast than that it's completely
+    // collision-free.
+
+    const keyPathHash = createFastHash(JSON.stringify(keyPath));
+    return 'k' + keyPathHash;
+  }
+}
+
+function useFormState(action, initialState, permalink) {
+  resolveCurrentlyRenderingComponent(); // Count the number of useFormState hooks per component. We also use this to
+  // track the position of this useFormState hook relative to the other ones in
+  // this component, so we can generate a unique key for each one.
+
+  const formStateHookIndex = formStateCounter++;
+  const request = currentlyRenderingRequest; // $FlowIgnore[prop-missing]
+
+  const formAction = action.$$FORM_ACTION;
+
+  if (typeof formAction === 'function') {
+    // This is a server action. These have additional features to enable
+    // MPA-style form submissions with progressive enhancement.
+    // TODO: If the same permalink is passed to multiple useFormStates, and
+    // they all have the same action signature, Fizz will pass the postback
+    // state to all of them. We should probably only pass it to the first one,
+    // and/or warn.
+    // The key is lazily generated and deduped so the that the keypath doesn't
+    // get JSON.stringify-ed unnecessarily, and at most once.
+    let nextPostbackStateKey = null; // Determine the current form state. If we received state during an MPA form
+    // submission, then we will reuse that, if the action identity matches.
+    // Otherwise we'll use the initial state argument. We will emit a comment
+    // marker into the stream that indicates whether the state was reused.
+
+    let state = initialState;
+    const componentKeyPath = currentlyRenderingKeyPath;
+    const postbackFormState = getFormState(request); // $FlowIgnore[prop-missing]
+
+    const isSignatureEqual = action.$$IS_SIGNATURE_EQUAL;
+
+    if (postbackFormState !== null && typeof isSignatureEqual === 'function') {
+      const postbackKey = postbackFormState[1];
+      const postbackReferenceId = postbackFormState[2];
+      const postbackBoundArity = postbackFormState[3];
+
+      if (isSignatureEqual.call(action, postbackReferenceId, postbackBoundArity)) {
+        nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+
+        if (postbackKey === nextPostbackStateKey) {
+          // This was a match
+          formStateMatchingIndex = formStateHookIndex; // Reuse the state that was submitted by the form.
+
+          state = postbackFormState[0];
+        }
+      }
+    } // Bind the state to the first argument of the action.
+
+
+    const boundAction = action.bind(null, state); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    }; // $FlowIgnore[prop-missing]
+
+
+    if (typeof boundAction.$$FORM_ACTION === 'function') {
+      // $FlowIgnore[prop-missing]
+      dispatch.$$FORM_ACTION = prefix => {
+        const metadata = boundAction.$$FORM_ACTION(prefix); // Override the action URL
+
+        if (permalink !== undefined) {
+
+          permalink += '';
+          metadata.action = permalink;
+        }
+
+        const formData = metadata.data;
+
+        if (formData) {
+          if (nextPostbackStateKey === null) {
+            nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+          }
+
+          formData.append('$ACTION_KEY', nextPostbackStateKey);
+        }
+
+        return metadata;
+      };
+    }
+
+    return [state, dispatch];
+  } else {
+    // This is not a server action, so the implementation is much simpler.
+    // Bind the state to the first argument of the action.
+    const boundAction = action.bind(null, initialState); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    };
+
+    return [initialState, dispatch];
+  }
+}
+
+function useId() {
+  const task = currentlyRenderingTask;
+  const treeId = getTreeId(task.treeContext);
+  const resumableState = currentResumableState;
+
+  if (resumableState === null) {
+    throw new Error('Invalid hook call. Hooks can only be called inside of the body of a function component.');
+  }
+
+  const localId = localIdCounter++;
+  return makeId(resumableState, treeId, localId);
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable;
+      return unwrapThenable(thenable);
+    } else if (usable.$$typeof === REACT_CONTEXT_TYPE || usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function unwrapThenable(thenable) {
+  const index = thenableIndexCounter;
+  thenableIndexCounter += 1;
+
+  if (thenableState === null) {
+    thenableState = createThenableState();
+  }
+
+  return trackUsedThenable(thenableState, thenable, index);
+}
+
+function unsupportedRefresh() {
+  throw new Error('Cache cannot be refreshed during server rendering.');
+}
+
+function useCacheRefresh() {
+  return unsupportedRefresh;
+}
+
+function noop$1() {}
+
+const HooksDispatcher = {
+  readContext,
+  use,
+  useContext,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+  useInsertionEffect: noop$1,
+  useLayoutEffect: noop$1,
+  useCallback,
+  // useImperativeHandle is not run in the server environment
+  useImperativeHandle: noop$1,
+  // Effects are not run in the server environment.
+  useEffect: noop$1,
+  // Debugging effect
+  useDebugValue: noop$1,
+  useDeferredValue,
+  useTransition,
+  useId,
+  // Subscriptions are not setup in a server environment.
+  useSyncExternalStore
+};
+
+{
+  HooksDispatcher.useCacheRefresh = useCacheRefresh;
+}
+
+{
+  HooksDispatcher.useHostTransitionStatus = useHostTransitionStatus;
+}
+
+{
+  HooksDispatcher.useOptimistic = useOptimistic;
+  HooksDispatcher.useFormState = useFormState;
+}
+
+let currentResumableState = null;
+function setCurrentResumableState(resumableState) {
+  currentResumableState = resumableState;
+}
+
+function getCacheSignal() {
+  throw new Error('Not implemented.');
+}
+
+function getCacheForType(resourceType) {
+  throw new Error('Not implemented.');
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal,
+  getCacheForType
+};
+
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+const ReactCurrentCache = ReactSharedInternals.ReactCurrentCache;
+// The name might be minified but we assume that it's going to be the same generated name. Typically
+// because it's just the same compiled output in practice.
+// resume with segmentID at the index
+
+const CLIENT_RENDERED = 4; // if it errors or infinitely suspends
+
+const PENDING = 0;
+const COMPLETED = 1;
+const FLUSHED = 2;
+const ABORTED = 3;
+const ERRORED = 4;
+const POSTPONED = 5;
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2; // This is a default heuristic for how to split up the HTML content into progressive
+// loading. Our goal is to be able to display additional new content about every 500ms.
+// Faster than that is unnecessary and should be throttled on the client. It also
+// adds unnecessary overhead to do more splits. We don't know if it's a higher or lower
+// end device but higher end suffer less from the overhead than lower end does from
+// not getting small enough pieces. We error on the side of low end.
+// We base this on low end 3G speeds which is about 500kbits per second. We assume
+// that there can be a reasonable drop off from max bandwidth which leaves you with
+// as little as 80%. We can receive half of that each 500ms - at best. In practice,
+// a little bandwidth is lost to processing and contention - e.g. CSS and images that
+// are downloaded along with the main content. So we estimate about half of that to be
+// the lower end throughput. In other words, we expect that you can at least show
+// about 12.5kb of content per 500ms. Not counting starting latency for the first
+// paint.
+// 500 * 1024 / 8 * .8 * 0.5 / 2
+
+const DEFAULT_PROGRESSIVE_CHUNK_SIZE = 12800;
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+
+  return null;
+}
+
+function noop() {}
+
+function createRequest(children, resumableState, renderState, rootFormatContext, progressiveChunkSize, onError, onAllReady, onShellReady, onShellError, onFatalError, onPostpone, formState) {
+  prepareHostDispatcher();
+  const pingedTasks = [];
+  const abortSet = new Set();
+  const request = {
+    destination: null,
+    flushScheduled: false,
+    resumableState,
+    renderState,
+    rootFormatContext,
+    progressiveChunkSize: progressiveChunkSize === undefined ? DEFAULT_PROGRESSIVE_CHUNK_SIZE : progressiveChunkSize,
+    status: OPEN,
+    fatalError: null,
+    nextSegmentId: 0,
+    allPendingTasks: 0,
+    pendingRootTasks: 0,
+    completedRootSegment: null,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    clientRenderedBoundaries: [],
+    completedBoundaries: [],
+    partialBoundaries: [],
+    trackedPostpones: null,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? noop : onPostpone,
+    onAllReady: onAllReady === undefined ? noop : onAllReady,
+    onShellReady: onShellReady === undefined ? noop : onShellReady,
+    onShellError: onShellError === undefined ? noop : onShellError,
+    onFatalError: onFatalError === undefined ? noop : onFatalError,
+    formState: formState === undefined ? null : formState
+  }; // This segment represents the root fallback.
+
+  const rootSegment = createPendingSegment(request, 0, null, rootFormatContext, // Root segments are never embedded in Text on either edge
+  false, false); // There is no parent so conceptually, we're unblocked to flush this segment.
+
+  rootSegment.parentFlushed = true;
+  const rootTask = createRenderTask(request, null, children, -1, null, rootSegment, abortSet, null, rootFormatContext, emptyContextObject, rootContextSnapshot, emptyTreeContext);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  return null;
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (request.pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createSuspenseBoundary(request, fallbackAbortableTasks) {
+  return {
+    status: PENDING,
+    rootSegmentID: -1,
+    parentFlushed: false,
+    pendingTasks: 0,
+    completedSegments: [],
+    byteSize: 0,
+    fallbackAbortableTasks,
+    errorDigest: null,
+    resources: createBoundaryResources(),
+    trackedContentKeyPath: null,
+    trackedFallbackNode: null
+  };
+}
+
+function createRenderTask(request, thenableState, node, childIndex, blockedBoundary, blockedSegment, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  const task = {
+    replay: null,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createReplayTask(request, thenableState, replay, node, childIndex, blockedBoundary, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  replay.pendingTasks++;
+  const task = {
+    replay,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment: null,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createPendingSegment(request, index, boundary, parentFormatContext, lastPushedText, textEmbedded) {
+  return {
+    status: PENDING,
+    id: -1,
+    // lazily assigned later
+    index,
+    parentFlushed: false,
+    chunks: [],
+    children: [],
+    parentFormatContext,
+    boundary,
+    lastPushedText,
+    textEmbedded
+  };
+} // DEV-only global reference to the currently executing task
+
+function popComponentStackInDEV(task) {
+} // stash the component stack of an unwinding error until it is processed
+
+function logRecoverableError(request, error) {
+  // If this callback errors, we intentionally let that error bubble up to become a fatal error
+  // so that someone fixes the error reporting instead of hiding it.
+  const errorDigest = request.onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest;
+}
+
+function fatalError(request, error) {
+  // This is called outside error handling code such as if the root errors outside
+  // a suspense boundary or if the root suspense boundary's fallback errors.
+  // It's also called if React itself or its host configs errors.
+  const onShellError = request.onShellError;
+  onShellError(error);
+  const onFatalError = request.onFatalError;
+  onFatalError(error);
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function renderSuspenseBoundary(request, someTask, keyPath, props) {
+  if (someTask.replay !== null) {
+    // If we're replaying through this pass, it means we're replaying through
+    // an already completed Suspense boundary. It's too late to do anything about it
+    // so we can just render through it.
+    const prevKeyPath = someTask.keyPath;
+    someTask.keyPath = keyPath;
+    const content = props.children;
+
+    try {
+      renderNode(request, someTask, content, -1);
+    } finally {
+      someTask.keyPath = prevKeyPath;
+    }
+
+    return;
+  } // $FlowFixMe: Refined.
+
+
+  const task = someTask;
+  const prevKeyPath = task.keyPath;
+  const parentBoundary = task.blockedBoundary;
+  const parentSegment = task.blockedSegment; // Each time we enter a suspense boundary, we split out into a new segment for
+  // the fallback so that we can later replace that segment with the content.
+  // This also lets us split out the main content even if it doesn't suspend,
+  // in case it ends up generating a large subtree of content.
+
+  const fallback = props.fallback;
+  const content = props.children;
+  const fallbackAbortSet = new Set();
+  const newBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+
+  if (request.trackedPostpones !== null) {
+    newBoundary.trackedContentKeyPath = keyPath;
+  }
+
+  const insertionIndex = parentSegment.chunks.length; // The children of the boundary segment is actually the fallback.
+
+  const boundarySegment = createPendingSegment(request, insertionIndex, newBoundary, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false);
+  parentSegment.children.push(boundarySegment); // The parentSegment has a child Segment at this index so we reset the lastPushedText marker on the parent
+
+  parentSegment.lastPushedText = false; // This segment is the actual child content. We can start rendering that immediately.
+
+  const contentRootSegment = createPendingSegment(request, 0, null, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false); // We mark the root segment as having its parent flushed. It's not really flushed but there is
+  // no parent segment so there's nothing to wait on.
+
+  contentRootSegment.parentFlushed = true; // Currently this is running synchronously. We could instead schedule this to pingedTasks.
+  // I suspect that there might be some efficiency benefits from not creating the suspended task
+  // and instead just using the stack if possible.
+  // TODO: Call this directly instead of messing with saving and restoring contexts.
+  // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and which segment
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = newBoundary;
+  task.blockedSegment = contentRootSegment;
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, newBoundary.resources);
+  }
+
+  task.keyPath = keyPath;
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+    pushSegmentFinale(contentRootSegment.chunks, request.renderState, contentRootSegment.lastPushedText, contentRootSegment.textEmbedded);
+    contentRootSegment.status = COMPLETED;
+    queueCompletedSegment(newBoundary, contentRootSegment);
+
+    if (newBoundary.pendingTasks === 0 && newBoundary.status === PENDING) {
+      newBoundary.status = COMPLETED; // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    contentRootSegment.status = ERRORED;
+    newBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    newBoundary.errorDigest = errorDigest;
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.blockedSegment = parentSegment;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]];
+  const trackedPostpones = request.trackedPostpones;
+
+  if (trackedPostpones !== null) {
+    // We create a detached replay node to track any postpones inside the fallback.
+    const fallbackReplayNode = [fallbackKeyPath[1], fallbackKeyPath[2], [], null];
+    trackedPostpones.workingMap.set(fallbackKeyPath, fallbackReplayNode);
+
+    if (newBoundary.status === POSTPONED) {
+      // This must exist now.
+      const boundaryReplayNode = trackedPostpones.workingMap.get(keyPath);
+      boundaryReplayNode[4] = fallbackReplayNode;
+    } else {
+      // We might not inject it into the postponed tree, unless the content actually
+      // postpones too. We need to keep track of it until that happpens.
+      newBoundary.trackedFallbackNode = fallbackReplayNode;
+    }
+  } // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+
+  const suspendedFallbackTask = createRenderTask(request, null, fallback, -1, parentBoundary, boundarySegment, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function replaySuspenseBoundary(request, task, keyPath, props, id, childNodes, childSlots, fallbackNodes, fallbackSlots) {
+  const prevKeyPath = task.keyPath;
+  const previousReplaySet = task.replay;
+  const parentBoundary = task.blockedBoundary;
+  const content = props.children;
+  const fallback = props.fallback;
+  const fallbackAbortSet = new Set();
+  const resumedBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = id; // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and replay node
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = resumedBoundary;
+  task.replay = {
+    nodes: childNodes,
+    slots: childSlots,
+    pendingTasks: 1
+  };
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, resumedBoundary.resources);
+  }
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+    }
+
+    task.replay.pendingTasks--;
+
+    if (resumedBoundary.pendingTasks === 0 && resumedBoundary.status === PENDING) {
+      resumedBoundary.status = COMPLETED;
+      request.completedBoundaries.push(resumedBoundary); // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    resumedBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    resumedBoundary.errorDigest = errorDigest;
+
+    task.replay.pendingTasks--; // The parent already flushed in the prerender so we need to schedule this to be emitted.
+
+    request.clientRenderedBoundaries.push(resumedBoundary); // We don't need to decrement any task numbers because we didn't spawn any new task.
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.replay = previousReplaySet;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]]; // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+  const fallbackReplay = {
+    nodes: fallbackNodes,
+    slots: fallbackSlots,
+    pendingTasks: 0
+  };
+  const suspendedFallbackTask = createReplayTask(request, null, fallbackReplay, fallback, -1, parentBoundary, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function renderHostElement(request, task, keyPath, type, props) {
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    const children = props.children; // TODO: Make this a Config for replaying.
+
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+  } else {
+    // Render
+    const children = pushStartInstance(segment.chunks, type, props, request.resumableState, request.renderState, task.formatContext, segment.lastPushedText);
+    segment.lastPushedText = false;
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+    pushEndInstance(segment.chunks, type, props, request.resumableState, prevContext);
+    segment.lastPushedText = false;
+  }
+}
+
+function shouldConstruct(Component) {
+  return Component.prototype && Component.prototype.isReactComponent;
+}
+
+function renderWithHooks(request, task, keyPath, prevThenableState, Component, props, secondArg) {
+  const componentIdentity = {};
+  prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState);
+  const result = Component(props, secondArg);
+  return finishHooks(Component, props, result, secondArg);
+}
+
+function finishClassComponent(request, task, keyPath, instance, Component, props) {
+  const nextChildren = instance.render();
+
+  {
+    const childContextTypes = Component.childContextTypes;
+
+    if (childContextTypes !== null && childContextTypes !== undefined) {
+      const previousContext = task.legacyContext;
+      const mergedContext = processChildContext(instance, Component, previousContext, childContextTypes);
+      task.legacyContext = mergedContext;
+      renderNodeDestructive(request, task, null, nextChildren, -1);
+      task.legacyContext = previousContext;
+      return;
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, nextChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderClassComponent(request, task, keyPath, Component, props) {
+  const maskedContext = getMaskedContext(Component, task.legacyContext) ;
+  const instance = constructClassInstance(Component, props, maskedContext);
+  mountClassInstance(instance, Component, props, maskedContext);
+  finishClassComponent(request, task, keyPath, instance, Component);
+}
+// components for some reason.
+
+function renderIndeterminateComponent(request, task, keyPath, prevThenableState, Component, props) {
+  let legacyContext;
+
+  {
+    legacyContext = getMaskedContext(Component, task.legacyContext);
+  }
+
+  const value = renderWithHooks(request, task, keyPath, prevThenableState, Component, props, legacyContext);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+
+  if ( // Run these checks in production only if the flag is off.
+  // Eventually we'll delete this branch altogether.
+  typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) {
+
+    mountClassInstance(value, Component, props, legacyContext);
+    finishClassComponent(request, task, keyPath, value, Component);
+  } else {
+
+    finishFunctionComponent(request, task, keyPath, value, hasId, formStateCount, formStateMatchingIndex);
+  }
+}
+
+function finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex) {
+  let didEmitFormStateMarkers = false;
+
+  if (formStateCount !== 0 && request.formState !== null) {
+    // For each useFormState hook, emit a marker that indicates whether we
+    // rendered using the form state passed at the root. We only emit these
+    // markers if form state is passed at the root.
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      didEmitFormStateMarkers = true;
+      const target = segment.chunks;
+
+      for (let i = 0; i < formStateCount; i++) {
+        if (i === formStateMatchingIndex) {
+          pushFormStateMarkerIsMatching(target);
+        } else {
+          pushFormStateMarkerIsNotMatching(target);
+        }
+      }
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+
+  if (hasId) {
+    // This component materialized an id. We treat this as its own level, with
+    // a single "child" slot.
+    const prevTreeContext = task.treeContext;
+    const totalChildren = 1;
+    const index = 0; // Modify the id context. Because we'll need to reset this if something
+    // suspends or errors, we'll use the non-destructive render path.
+
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, index);
+    renderNode(request, task, children, -1); // Like the other contexts, this does not need to be in a finally block
+    // because renderNode takes care of unwinding the stack.
+
+    task.treeContext = prevTreeContext;
+  } else if (didEmitFormStateMarkers) {
+    // If there were formState hooks, we must use the non-destructive path
+    // because this component is not a pure indirection; we emitted markers
+    // to the stream.
+    renderNode(request, task, children, -1);
+  } else {
+    // We're now successfully past this task, and we haven't modified the
+    // context stack. We don't have to pop back to the previous task every
+    // again, so we can use the destructive recursive form.
+    renderNodeDestructive(request, task, null, children, -1);
+  }
+
+  task.keyPath = prevKeyPath;
+}
+
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    // Resolve default props. Taken from ReactElement
+    const props = assign({}, baseProps);
+    const defaultProps = Component.defaultProps;
+
+    for (const propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+
+    return props;
+  }
+
+  return baseProps;
+}
+
+function renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref) {
+  const children = renderWithHooks(request, task, keyPath, prevThenableState, type.render, props, ref);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+  finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex);
+}
+
+function renderMemo(request, task, keyPath, prevThenableState, type, props, ref) {
+  const innerType = type.type;
+  const resolvedProps = resolveDefaultProps(innerType, props);
+  renderElement(request, task, keyPath, prevThenableState, innerType, resolvedProps, ref);
+}
+
+function renderContextConsumer(request, task, keyPath, context, props) {
+
+  const render = props.children;
+
+  const newValue = readContext$1(context);
+  const newChildren = render(newValue);
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, newChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderContextProvider(request, task, keyPath, type, props) {
+  const context = type._context;
+  const value = props.value;
+  const children = props.children;
+
+  const prevKeyPath = task.keyPath;
+  task.context = pushProvider(context, value);
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, children, -1);
+  task.context = popProvider();
+  task.keyPath = prevKeyPath;
+}
+
+function renderLazyComponent(request, task, keyPath, prevThenableState, lazyComponent, props, ref) {
+  const payload = lazyComponent._payload;
+  const init = lazyComponent._init;
+  const Component = init(payload);
+  const resolvedProps = resolveDefaultProps(Component, props);
+  renderElement(request, task, keyPath, prevThenableState, Component, resolvedProps, ref);
+}
+
+function renderOffscreen(request, task, keyPath, props) {
+  const mode = props.mode;
+
+  if (mode === 'hidden') ; else {
+    // A visible Offscreen boundary is treated exactly like a fragment: a
+    // pure indirection.
+    const prevKeyPath = task.keyPath;
+    task.keyPath = keyPath;
+    renderNodeDestructive(request, task, null, props.children, -1);
+    task.keyPath = prevKeyPath;
+  }
+}
+
+function renderElement(request, task, keyPath, prevThenableState, type, props, ref) {
+  if (typeof type === 'function') {
+    if (shouldConstruct(type)) {
+      renderClassComponent(request, task, keyPath, type, props);
+      return;
+    } else {
+      renderIndeterminateComponent(request, task, keyPath, prevThenableState, type, props);
+      return;
+    }
+  }
+
+  if (typeof type === 'string') {
+    renderHostElement(request, task, keyPath, type, props);
+    return;
+  }
+
+  switch (type) {
+    // LegacyHidden acts the same as a fragment. This only works because we
+    // currently assume that every instance of LegacyHidden is accompanied by a
+    // host component wrapper. In the hidden mode, the host component is given a
+    // `hidden` attribute, which ensures that the initial HTML is not visible.
+    // To support the use of LegacyHidden as a true fragment, without an extra
+    // DOM node, we would have to hide the initial HTML in some other way.
+    // TODO: Delete in LegacyHidden. It's an unstable API only used in the
+    // www build. As a migration step, we could add a special prop to Offscreen
+    // that simulates the old behavior (no hiding, no change to effects).
+    case REACT_LEGACY_HIDDEN_TYPE:
+    case REACT_DEBUG_TRACING_MODE_TYPE:
+    case REACT_STRICT_MODE_TYPE:
+    case REACT_PROFILER_TYPE:
+    case REACT_FRAGMENT_TYPE:
+      {
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_OFFSCREEN_TYPE:
+      {
+        renderOffscreen(request, task, keyPath, props);
+        return;
+      }
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      {
+
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_SCOPE_TYPE:
+      {
+
+        throw new Error('ReactDOMServer does not yet support scope components.');
+      }
+
+    case REACT_SUSPENSE_TYPE:
+      {
+        {
+          renderSuspenseBoundary(request, task, keyPath, props);
+        }
+
+        return;
+      }
+  }
+
+  if (typeof type === 'object' && type !== null) {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        {
+          renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          renderMemo(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_PROVIDER_TYPE:
+        {
+          renderContextProvider(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_CONTEXT_TYPE:
+        {
+          renderContextConsumer(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_LAZY_TYPE:
+        {
+          renderLazyComponent(request, task, keyPath, prevThenableState, type, props);
+          return;
+        }
+    }
+  }
+
+  let info = '';
+
+  throw new Error('Element type is invalid: expected a string (for built-in ' + 'components) or a class/function (for composite components) ' + ("but got: " + (type == null ? type : typeof type) + "." + info));
+}
+
+function resumeNode(request, task, segmentId, node, childIndex) {
+  const prevReplay = task.replay;
+  const blockedBoundary = task.blockedBoundary;
+  const resumedSegment = createPendingSegment(request, 0, null, task.formatContext, false, false);
+  resumedSegment.id = segmentId;
+  resumedSegment.parentFlushed = true;
+
+  try {
+    // Convert the current ReplayTask to a RenderTask.
+    const renderTask = task;
+    renderTask.replay = null;
+    renderTask.blockedSegment = resumedSegment;
+    renderNode(request, task, node, childIndex);
+    resumedSegment.status = COMPLETED;
+
+    if (blockedBoundary === null) {
+      request.completedRootSegment = resumedSegment;
+    } else {
+      queueCompletedSegment(blockedBoundary, resumedSegment);
+
+      if (blockedBoundary.parentFlushed) {
+        request.partialBoundaries.push(blockedBoundary);
+      }
+    }
+  } finally {
+    // Restore to a ReplayTask.
+    task.replay = prevReplay;
+    task.blockedSegment = null;
+  }
+}
+
+function replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, replay) {
+  // We're replaying. Find the path to follow.
+  const replayNodes = replay.nodes;
+
+  for (let i = 0; i < replayNodes.length; i++) {
+    // Flow doesn't support refinement on tuples so we do it manually here.
+    const node = replayNodes[i];
+
+    if (keyOrIndex !== node[1]) {
+      continue;
+    }
+
+    if (node.length === 4) {
+      // Matched a replayable path.
+      // Let's double check that the component name matches as a precaution.
+      if (name !== null && name !== node[0]) {
+        throw new Error('Expected the resume to render <' + node[0] + '> in this slot but instead it rendered <' + name + '>. ' + "The tree doesn't match so React will fallback to client rendering.");
+      }
+
+      const childNodes = node[2];
+      const childSlots = node[3];
+      const currentNode = task.node;
+      task.replay = {
+        nodes: childNodes,
+        slots: childSlots,
+        pendingTasks: 1
+      };
+
+      try {
+        renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+
+        if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0 // TODO check remaining slots
+        ) {
+            throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+          }
+
+        task.replay.pendingTasks--;
+      } catch (x) {
+        if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+          // Suspend
+          if (task.node === currentNode) {
+            // This same element suspended so we need to pop the replay we just added.
+            task.replay = replay;
+          }
+
+          throw x;
+        }
+
+        task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+        // during a replay. That's because this component didn't actually error
+        // in the original prerender. What's unable to complete is the child
+        // replay nodes which might be Suspense boundaries which are able to
+        // absorb the error and we can still continue with siblings.
+
+        erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+      }
+
+      task.replay = replay;
+    } else {
+      // Let's double check that the component type matches.
+      if (type !== REACT_SUSPENSE_TYPE) {
+        const expectedType = 'Suspense';
+        throw new Error('Expected the resume to render <' + expectedType + '> in this slot but instead it rendered <' + (getComponentNameFromType(type) || 'Unknown') + '>. ' + "The tree doesn't match so React will fallback to client rendering.");
+      } // Matched a replayable path.
+
+
+      replaySuspenseBoundary(request, task, keyPath, props, node[5], node[2], node[3], node[4] === null ? [] : node[4][2], node[4] === null ? null : node[4][3]);
+    } // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+
+    replayNodes.splice(i, 1);
+    return;
+  } // We didn't find any matching nodes. We assume that this element was already
+  // rendered in the prelude and skip it.
+
+} // $FlowFixMe[missing-local-annot]
+
+function renderNodeDestructive(request, task, // The thenable state reused from the previous attempt, if any. This is almost
+// always null, except when called by retryTask.
+prevThenableState, node, childIndex) {
+  {
+    return renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex);
+  }
+} // This function by it self renders a node and consumes the task by mutating it
+// to update the current execution state.
+
+
+function renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex) {
+  if (task.replay !== null && typeof task.replay.slots === 'number') {
+    // TODO: Figure out a cheaper place than this hot path to do this check.
+    const resumeSegmentID = task.replay.slots;
+    resumeNode(request, task, resumeSegmentID, node, childIndex);
+    return;
+  } // Stash the node we're working on. We'll pick up from this task in case
+  // something suspends.
+
+
+  task.node = node;
+  task.childIndex = childIndex; // Handle object types
+
+  if (typeof node === 'object' && node !== null) {
+    switch (node.$$typeof) {
+      case REACT_ELEMENT_TYPE:
+        {
+          const element = node;
+          const type = element.type;
+          const key = element.key;
+          const props = element.props;
+          const ref = element.ref;
+          const name = getComponentNameFromType(type);
+          const keyOrIndex = key == null ? childIndex === -1 ? 0 : childIndex : key;
+          const keyPath = [task.keyPath, name, keyOrIndex];
+
+          if (task.replay !== null) {
+            replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, task.replay); // No matches found for this node. We assume it's already emitted in the
+            // prelude and skip it during the replay.
+          } else {
+            // We're doing a plain render.
+            renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+          }
+
+          return;
+        }
+
+      case REACT_PORTAL_TYPE:
+        throw new Error('Portals are not currently supported by the server renderer. ' + 'Render them conditionally so that they only appear on the client render.');
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyNode = node;
+          const payload = lazyNode._payload;
+          const init = lazyNode._init;
+          let resolvedNode;
+
+          {
+            resolvedNode = init(payload);
+          }
+
+          renderNodeDestructive(request, task, null, resolvedNode, childIndex);
+          return;
+        }
+    }
+
+    if (isArray(node)) {
+      renderChildrenArray(request, task, node, childIndex);
+      return;
+    }
+
+    const iteratorFn = getIteratorFn(node);
+
+    if (iteratorFn) {
+
+      const iterator = iteratorFn.call(node);
+
+      if (iterator) {
+        // We need to know how many total children are in this set, so that we
+        // can allocate enough id slots to acommodate them. So we must exhaust
+        // the iterator before we start recursively rendering the children.
+        // TODO: This is not great but I think it's inherent to the id
+        // generation algorithm.
+        let step = iterator.next(); // If there are not entries, we need to push an empty so we start by checking that.
+
+        if (!step.done) {
+          const children = [];
+
+          do {
+            children.push(step.value);
+            step = iterator.next();
+          } while (!step.done);
+
+          renderChildrenArray(request, task, children, childIndex);
+          return;
+        }
+
+        return;
+      }
+    } // Usables are a valid React node type. When React encounters a Usable in
+    // a child position, it unwraps it using the same algorithm as `use`. For
+    // example, for promises, React will throw an exception to unwind the
+    // stack, then replay the component once the promise resolves.
+    //
+    // A difference from `use` is that React will keep unwrapping the value
+    // until it reaches a non-Usable type.
+    //
+    // e.g. Usable<Usable<Usable<T>>> should resolve to T
+
+
+    const maybeUsable = node;
+
+    if (typeof maybeUsable.then === 'function') {
+      const thenable = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, unwrapThenable(thenable), childIndex);
+    }
+
+    if (maybeUsable.$$typeof === REACT_CONTEXT_TYPE || maybeUsable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, readContext$1(context), childIndex);
+    } // $FlowFixMe[method-unbinding]
+
+
+    const childString = Object.prototype.toString.call(node);
+    throw new Error("Objects are not valid as a React child (found: " + (childString === '[object Object]' ? 'object with keys {' + Object.keys(node).join(', ') + '}' : childString) + "). " + 'If you meant to render a collection of children, use an array ' + 'instead.');
+  }
+
+  if (typeof node === 'string') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+
+  if (typeof node === 'number') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, '' + node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+}
+
+function replayFragment(request, task, children, childIndex) {
+  // If we're supposed follow this array, we'd expect to see a ReplayNode matching
+  // this fragment.
+  const replay = task.replay;
+  const replayNodes = replay.nodes;
+
+  for (let j = 0; j < replayNodes.length; j++) {
+    const node = replayNodes[j];
+
+    if (node[1] !== childIndex) {
+      continue;
+    } // Matched a replayable path.
+
+
+    const childNodes = node[2];
+    const childSlots = node[3];
+    task.replay = {
+      nodes: childNodes,
+      slots: childSlots,
+      pendingTasks: 1
+    };
+
+    try {
+      renderChildrenArray(request, task, children, -1);
+
+      if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+        throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+      }
+
+      task.replay.pendingTasks--;
+    } catch (x) {
+      if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+        // Suspend
+        throw x;
+      }
+
+      task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+      // during a replay. That's because this component didn't actually error
+      // in the original prerender. What's unable to complete is the child
+      // replay nodes which might be Suspense boundaries which are able to
+      // absorb the error and we can still continue with siblings.
+      // This is an error, stash the component stack if it is null.
+
+      erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+    }
+
+    task.replay = replay; // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+    replayNodes.splice(j, 1);
+    break;
+  }
+}
+
+function renderChildrenArray(request, task, children, childIndex) {
+  const prevKeyPath = task.keyPath;
+
+  if (childIndex !== -1) {
+    task.keyPath = [task.keyPath, 'Fragment', childIndex];
+
+    if (task.replay !== null) {
+      replayFragment(request, // $FlowFixMe: Refined.
+      task, children, childIndex);
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  const prevTreeContext = task.treeContext;
+  const totalChildren = children.length;
+
+  if (task.replay !== null) {
+    // Replay
+    // First we need to check if we have any resume slots at this level.
+    const resumeSlots = task.replay.slots;
+
+    if (resumeSlots !== null && typeof resumeSlots === 'object') {
+      for (let i = 0; i < totalChildren; i++) {
+        const node = children[i];
+        task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+        // up and render the sibling if something suspends.
+
+        const resumeSegmentID = resumeSlots[i]; // TODO: If this errors we should still continue with the next sibling.
+
+        if (typeof resumeSegmentID === 'number') {
+          resumeNode(request, task, resumeSegmentID, node, i); // We finished rendering this node, so now we can consume this
+          // slot. This must happen after in case we rerender this task.
+
+          delete resumeSlots[i];
+        } else {
+          renderNode(request, task, node, i);
+        }
+      }
+
+      task.treeContext = prevTreeContext;
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  for (let i = 0; i < totalChildren; i++) {
+    const node = children[i];
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+    // up and render the sibling if something suspends.
+
+    renderNode(request, task, node, i);
+  } // Because this context is always set right before rendering every child, we
+  // only need to reset it to the previous value at the very end.
+
+
+  task.treeContext = prevTreeContext;
+  task.keyPath = prevKeyPath;
+}
+
+function spawnNewSuspendedReplayTask(request, task, thenableState, x) {
+  const newTask = createReplayTask(request, thenableState, task.replay, task.node, task.childIndex, task.blockedBoundary, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+}
+
+function spawnNewSuspendedRenderTask(request, task, thenableState, x) {
+  // Something suspended, we'll need to create a new segment and resolve it later.
+  const segment = task.blockedSegment;
+  const insertionIndex = segment.chunks.length;
+  const newSegment = createPendingSegment(request, insertionIndex, null, task.formatContext, // Adopt the parent segment's leading text embed
+  segment.lastPushedText, // Assume we are text embedded at the trailing edge
+  true);
+  segment.children.push(newSegment); // Reset lastPushedText for current Segment since the new Segment "consumed" it
+
+  segment.lastPushedText = false;
+  const newTask = createRenderTask(request, thenableState, task.node, task.childIndex, task.blockedBoundary, newSegment, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+} // This is a non-destructive form of rendering a node. If it suspends it spawns
+// a new task and restores the context of this task to what it was before.
+
+
+function renderNode(request, task, node, childIndex) {
+  // Snapshot the current context in case something throws to interrupt the
+  // process.
+  const previousFormatContext = task.formatContext;
+  const previousLegacyContext = task.legacyContext;
+  const previousContext = task.context;
+  const previousKeyPath = task.keyPath;
+  const previousTreeContext = task.treeContext;
+
+  let x; // Store how much we've pushed at this point so we can reset it in case something
+  // suspended partially through writing something.
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState();
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedReplayTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+      } // TODO: Abort any undiscovered Suspense boundaries in the ReplayNode.
+
+    }
+  } else {
+    // Render
+    const childrenLength = segment.children.length;
+    const chunkLength = segment.chunks.length;
+
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState(); // Reset the write pointers to where we started.
+
+      segment.children.length = childrenLength;
+      segment.chunks.length = chunkLength;
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedRenderTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+      }
+    }
+  } // Restore the context. We assume that this will be restored by the inner
+  // functions in case nothing throws so we don't use "finally" here.
+
+
+  task.formatContext = previousFormatContext;
+  task.legacyContext = previousLegacyContext;
+  task.context = previousContext;
+  task.keyPath = previousKeyPath;
+  task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+  switchContext(previousContext);
+  // Let's terminate the rest of the tree and don't render any siblings.
+
+
+  throw x;
+}
+
+function erroredReplay(request, boundary, error, replayNodes, resumeSlots) {
+  // Erroring during a replay doesn't actually cause an error by itself because
+  // that component has already rendered. What causes the error is the resumable
+  // points that we did not yet finish which will be below the point of the reset.
+  // For example, if we're replaying a path to a Suspense boundary that is not done
+  // that doesn't error the parent Suspense boundary.
+  // This might be a bit strange that the error in a parent gets thrown at a child.
+  // We log it only once and reuse the digest.
+  let errorDigest;
+
+  {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  abortRemainingReplayNodes(request, boundary, replayNodes, resumeSlots, error, errorDigest);
+}
+
+function erroredTask(request, boundary, error) {
+  // Report the error to a global handler.
+  let errorDigest;
+
+  {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  if (boundary === null) {
+    fatalError(request, error);
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+      // so we can flush it, if the parent already flushed.
+
+
+      if (boundary.parentFlushed) {
+        // We don't have a preference where in the queue this goes since it's likely
+        // to error on the client anyway. However, intentionally client-rendered
+        // boundaries should be flushed earlier so that they can start on the client.
+        // We reuse the same queue for errors.
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function abortTaskSoft(task) {
+  // This aborts task without aborting the parent boundary that it blocks.
+  // It's used for when we didn't need this task to complete the tree.
+  // If task was needed, then it should use abortTask instead.
+  const request = this;
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+    finishedTask(request, boundary, segment);
+  }
+}
+
+function abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest) {
+  const resumedBoundary = createSuspenseBoundary(request, new Set());
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = rootSegmentID;
+  resumedBoundary.status = CLIENT_RENDERED;
+  resumedBoundary.errorDigest = errorDigest;
+
+  if (resumedBoundary.parentFlushed) {
+    request.clientRenderedBoundaries.push(resumedBoundary);
+  }
+}
+
+function abortRemainingReplayNodes(request, boundary, nodes, slots, error, errorDigest) {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+
+    if (node.length === 4) {
+      abortRemainingReplayNodes(request, boundary, node[2], node[3], error, errorDigest);
+    } else {
+      const boundaryNode = node;
+      const rootSegmentID = boundaryNode[5];
+      abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest);
+    }
+  } // Empty the set, since we've cleared it now.
+
+
+  nodes.length = 0;
+
+  if (slots !== null) {
+    // We had something still to resume in the parent boundary. We must trigger
+    // the error on the parent boundary since it's not able to complete.
+    if (boundary === null) {
+      throw new Error('We should not have any resumable nodes in the shell. ' + 'This is a bug in React.');
+    } else if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // Empty the set
+
+
+    if (typeof slots === 'object') {
+      for (const index in slots) {
+        delete slots[index];
+      }
+    }
+  }
+}
+
+function abortTask(task, request, error) {
+  // This aborts the task and aborts the parent that it blocks, putting it into
+  // client rendered mode.
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+  }
+
+  if (boundary === null) {
+    if (request.status !== CLOSING && request.status !== CLOSED) {
+      const replay = task.replay;
+
+      if (replay === null) {
+        // We didn't complete the root so we have nothing to show. We can close
+        // the request;
+        logRecoverableError(request, error);
+        fatalError(request, error);
+        return;
+      } else {
+        // If the shell aborts during a replay, that's not a fatal error. Instead
+        // we should be able to recover by client rendering all the root boundaries in
+        // the ReplaySet.
+        replay.pendingTasks--;
+
+        if (replay.pendingTasks === 0 && replay.nodes.length > 0) {
+          const errorDigest = logRecoverableError(request, error);
+          abortRemainingReplayNodes(request, null, replay.nodes, replay.slots, error, errorDigest);
+        }
+
+        request.pendingRootTasks--;
+
+        if (request.pendingRootTasks === 0) {
+          completeShell(request);
+        }
+      }
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = logRecoverableError(request, error);
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // If this boundary was still pending then we haven't already cancelled its fallbacks.
+    // We'll need to abort the fallbacks, which will also error that parent boundary.
+
+
+    boundary.fallbackAbortableTasks.forEach(fallbackTask => abortTask(fallbackTask, request, error));
+    boundary.fallbackAbortableTasks.clear();
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeShell(request) {
+  if (request.trackedPostpones === null) {
+    // We only emit early preloads on shell completion for renders. For prerenders
+    // we wait for the entire Request to finish because we are not responding to a
+    // live request and can wait for as much data as possible.
+    // we should only be calling completeShell when the shell is complete so we
+    // just use a literal here
+    const shellComplete = true;
+    emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  } // We have completed the shell so the shell can't error anymore.
+
+
+  request.onShellError = noop;
+  const onShellReady = request.onShellReady;
+  onShellReady();
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeAll(request) {
+  // During a render the shell must be complete if the entire request is finished
+  // however during a Prerender it is possible that the shell is incomplete because
+  // it postponed. We cannot use rootPendingTasks in the prerender case because
+  // those hit zero even when the shell postpones. Instead we look at the completedRootSegment
+  const shellComplete = request.trackedPostpones === null ? // Render, we assume it is completed
+  true : // Prerender Request, we use the state of the root segment
+  request.completedRootSegment === null || request.completedRootSegment.status !== POSTPONED;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  const onAllReady = request.onAllReady;
+  onAllReady();
+}
+
+function queueCompletedSegment(boundary, segment) {
+  if (segment.chunks.length === 0 && segment.children.length === 1 && segment.children[0].boundary === null) {
+    // This is an empty segment. There's nothing to write, so we can instead transfer the ID
+    // to the child. That way any existing references point to the child.
+    const childSegment = segment.children[0];
+    childSegment.id = segment.id;
+    childSegment.parentFlushed = true;
+
+    if (childSegment.status === COMPLETED) {
+      queueCompletedSegment(boundary, childSegment);
+    }
+  } else {
+    const completedSegments = boundary.completedSegments;
+    completedSegments.push(segment);
+  }
+}
+
+function finishedTask(request, boundary, segment) {
+  if (boundary === null) {
+    if (segment !== null && segment.parentFlushed) {
+      if (request.completedRootSegment !== null) {
+        throw new Error('There can only be one root segment. This is a bug in React.');
+      }
+
+      request.completedRootSegment = segment;
+    }
+
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status === CLIENT_RENDERED) ; else if (boundary.pendingTasks === 0) {
+      if (boundary.status === PENDING) {
+        boundary.status = COMPLETED;
+      } // This must have been the last segment we were waiting on. This boundary is now complete.
+
+
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent segment already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+        }
+      }
+
+      if (boundary.parentFlushed) {
+        // The segment might be part of a segment that didn't flush yet, but if the boundary's
+        // parent flushed, we need to schedule the boundary to be emitted.
+        request.completedBoundaries.push(boundary);
+      } // We can now cancel any pending task on the fallback since we won't need to show it anymore.
+      // This needs to happen after we read the parentFlushed flags because aborting can finish
+      // work which can trigger user code, which can start flushing, which can change those flags.
+      // If the boundary was POSTPONED, we still need to finish the fallback first.
+
+
+      if (boundary.status === COMPLETED) {
+        boundary.fallbackAbortableTasks.forEach(abortTaskSoft, request);
+        boundary.fallbackAbortableTasks.clear();
+      }
+    } else {
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+          const completedSegments = boundary.completedSegments;
+
+          if (completedSegments.length === 1) {
+            // This is the first time since we last flushed that we completed anything.
+            // We can schedule this boundary to emit its partially completed segments early
+            // in case the parent has already been flushed.
+            if (boundary.parentFlushed) {
+              request.partialBoundaries.push(boundary);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function retryTask(request, task) {
+  {
+    const blockedBoundary = task.blockedBoundary;
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, blockedBoundary ? blockedBoundary.resources : null);
+  }
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    retryReplayTask(request, // $FlowFixMe: Refined.
+    task);
+  } else {
+    retryRenderTask(request, // $FlowFixMe: Refined.
+    task, segment);
+  }
+}
+
+function retryRenderTask(request, task, segment) {
+  if (segment.status !== PENDING) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  const childrenLength = segment.children.length;
+  const chunkLength = segment.chunks.length;
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+    pushSegmentFinale(segment.chunks, request.renderState, segment.lastPushedText, segment.textEmbedded);
+    task.abortSet.delete(task);
+    segment.status = COMPLETED;
+    finishedTask(request, task.blockedBoundary, segment);
+  } catch (thrownValue) {
+    resetHooksState(); // Reset the write pointers to where we started.
+
+    segment.children.length = childrenLength;
+    segment.chunks.length = chunkLength;
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    task.abortSet.delete(task);
+    segment.status = ERRORED;
+    erroredTask(request, task.blockedBoundary, x);
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function retryReplayTask(request, task) {
+  if (task.replay.pendingTasks === 0) {
+    // There are no pending tasks working on this set, so we must have aborted.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    finishedTask(request, task.blockedBoundary, null);
+  } catch (thrownValue) {
+    resetHooksState();
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    erroredReplay(request, task.blockedBoundary, x, task.replay.nodes, task.replay.slots);
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+
+    request.allPendingTasks--;
+
+    if (request.allPendingTasks === 0) {
+      completeAll(request);
+    }
+
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function performWork(request) {
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  const prevContext = getActiveContext();
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  let prevCacheDispatcher;
+
+  {
+    prevCacheDispatcher = ReactCurrentCache.current;
+    ReactCurrentCache.current = DefaultCacheDispatcher;
+  }
+
+  const prevRequest = currentRequest;
+  currentRequest = request;
+
+  const prevResumableState = currentResumableState;
+  setCurrentResumableState(request.resumableState);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    let i;
+
+    for (i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    pingedTasks.splice(0, i);
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    setCurrentResumableState(prevResumableState);
+    ReactCurrentDispatcher.current = prevDispatcher;
+
+    {
+      ReactCurrentCache.current = prevCacheDispatcher;
+    }
+
+    if (prevDispatcher === HooksDispatcher) {
+      // This means that we were in a reentrant work loop. This could happen
+      // in a renderer that supports synchronous work like renderToString,
+      // when it's called from within another renderer.
+      // Normally we don't bother switching the contexts to their root/default
+      // values when leaving because we'll likely need the same or similar
+      // context again. However, when we're inside a synchronous loop like this
+      // we'll to restore the context to what it was before returning.
+      switchContext(prevContext);
+    }
+
+    currentRequest = prevRequest;
+  }
+}
+
+function flushSubtree(request, destination, segment) {
+  segment.parentFlushed = true;
+
+  switch (segment.status) {
+    case PENDING:
+      {
+        // We're emitting a placeholder for this segment to be filled in later.
+        // Therefore we'll need to assign it an ID - to refer to it by.
+        segment.id = request.nextSegmentId++; // Fallthrough
+      }
+
+    case POSTPONED:
+      {
+        const segmentID = segment.id; // When this segment finally completes it won't be embedded in text since it will flush separately
+
+        segment.lastPushedText = false;
+        segment.textEmbedded = false;
+        return writePlaceholder(destination, request.renderState, segmentID);
+      }
+
+    case COMPLETED:
+      {
+        segment.status = FLUSHED;
+        let r = true;
+        const chunks = segment.chunks;
+        let chunkIdx = 0;
+        const children = segment.children;
+
+        for (let childIdx = 0; childIdx < children.length; childIdx++) {
+          const nextChild = children[childIdx]; // Write all the chunks up until the next child.
+
+          for (; chunkIdx < nextChild.index; chunkIdx++) {
+            writeChunk(destination, chunks[chunkIdx]);
+          }
+
+          r = flushSegment(request, destination, nextChild);
+        } // Finally just write all the remaining chunks
+
+
+        for (; chunkIdx < chunks.length - 1; chunkIdx++) {
+          writeChunk(destination, chunks[chunkIdx]);
+        }
+
+        if (chunkIdx < chunks.length) {
+          r = writeChunkAndReturn(destination, chunks[chunkIdx]);
+        }
+
+        return r;
+      }
+
+    default:
+      {
+        throw new Error('Aborted, errored or already flushed boundaries should not be flushed again. This is a bug in React.');
+      }
+  }
+}
+
+function flushSegment(request, destination, segment) {
+  const boundary = segment.boundary;
+
+  if (boundary === null) {
+    // Not a suspense boundary.
+    return flushSubtree(request, destination, segment);
+  }
+
+  boundary.parentFlushed = true; // This segment is a Suspense boundary. We need to decide whether to
+  // emit the content or the fallback now.
+
+  if (boundary.status === CLIENT_RENDERED) {
+    // Emit a client rendered suspense boundary wrapper.
+    // We never queue the inner boundary so we'll never emit its content or partial segments.
+    writeStartClientRenderedSuspenseBoundary(destination, request.renderState, boundary.errorDigest); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndClientRenderedSuspenseBoundary(destination);
+  } else if (boundary.status !== COMPLETED) {
+    if (boundary.status === PENDING) {
+      // For pending boundaries we lazily assign an ID to the boundary
+      // and root segment.
+      boundary.rootSegmentID = request.nextSegmentId++;
+    }
+
+    if (boundary.completedSegments.length > 0) {
+      // If this is at least partially complete, we can queue it to be partially emitted early.
+      request.partialBoundaries.push(boundary);
+    } // This boundary is still loading. Emit a pending suspense boundary wrapper.
+
+
+    const id = boundary.rootSegmentID;
+    writeStartPendingSuspenseBoundary(destination, request.renderState, id); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else if (boundary.byteSize > request.progressiveChunkSize) {
+    // This boundary is large and will be emitted separately so that we can progressively show
+    // other content. We add it to the queue during the flush because we have to ensure that
+    // the parent flushes first so that there's something to inject it into.
+    // We also have to make sure that it's emitted into the queue in a deterministic slot.
+    // I.e. we can't insert it here when it completes.
+    // Assign an ID to refer to the future content by.
+    boundary.rootSegmentID = request.nextSegmentId++;
+    request.completedBoundaries.push(boundary); // Emit a pending rendered suspense boundary wrapper.
+
+    writeStartPendingSuspenseBoundary(destination, request.renderState, boundary.rootSegmentID); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else {
+    {
+      hoistResources(request.renderState, boundary.resources);
+    } // We can inline this boundary's content as a complete boundary.
+
+
+    writeStartCompletedSuspenseBoundary(destination);
+    const completedSegments = boundary.completedSegments;
+
+    if (completedSegments.length !== 1) {
+      throw new Error('A previously unvisited boundary must have exactly one root segment. This is a bug in React.');
+    }
+
+    const contentSegment = completedSegments[0];
+    flushSegment(request, destination, contentSegment);
+    return writeEndCompletedSuspenseBoundary(destination);
+  }
+}
+
+function flushClientRenderedBoundary(request, destination, boundary) {
+  return writeClientRenderBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.errorDigest, boundary.errorMessage, boundary.errorComponentStack);
+}
+
+function flushSegmentContainer(request, destination, segment) {
+  writeStartSegment(destination, request.renderState, segment.parentFormatContext, segment.id);
+  flushSegment(request, destination, segment);
+  return writeEndSegment(destination, segment.parentFormatContext);
+}
+
+function flushCompletedBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+    flushPartiallyCompletedSegment(request, destination, boundary, segment);
+  }
+
+  completedSegments.length = 0;
+
+  {
+    writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+
+  return writeCompletedBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.resources);
+}
+
+function flushPartialBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+
+    if (!flushPartiallyCompletedSegment(request, destination, boundary, segment)) {
+      i++;
+      completedSegments.splice(0, i); // Only write as much as the buffer wants. Something higher priority
+      // might want to write later.
+
+      return false;
+    }
+  }
+
+  completedSegments.splice(0, i);
+
+  {
+    // The way this is structured we only write resources for partial boundaries
+    // if there is no backpressure. Later before we complete the boundary we
+    // will write resources regardless of backpressure before we emit the
+    // completion instruction
+    return writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+}
+
+function flushPartiallyCompletedSegment(request, destination, boundary, segment) {
+  if (segment.status === FLUSHED) {
+    // We've already flushed this inline.
+    return true;
+  }
+
+  const segmentID = segment.id;
+
+  if (segmentID === -1) {
+    // This segment wasn't previously referred to. This happens at the root of
+    // a boundary. We make kind of a leap here and assume this is the root.
+    const rootSegmentID = segment.id = boundary.rootSegmentID;
+
+    if (rootSegmentID === -1) {
+      throw new Error('A root segment ID must have been assigned by now. This is a bug in React.');
+    }
+
+    return flushSegmentContainer(request, destination, segment);
+  } else if (segmentID === boundary.rootSegmentID) {
+    // When we emit postponed boundaries, we might have assigned the ID already
+    // but it's still the root segment so we can't inject it into the parent yet.
+    return flushSegmentContainer(request, destination, segment);
+  } else {
+    flushSegmentContainer(request, destination, segment);
+    return writeCompletedSegmentInstruction(destination, request.resumableState, request.renderState, segmentID);
+  }
+}
+
+function flushCompletedQueues(request, destination) {
+
+  try {
+    // The structure of this is to go through each queue one by one and write
+    // until the sink tells us to stop. When we should stop, we still finish writing
+    // that item fully and then yield. At that point we remove the already completed
+    // items up until the point we completed them.
+    let i;
+    const completedRootSegment = request.completedRootSegment;
+
+    if (completedRootSegment !== null) {
+      if (completedRootSegment.status === POSTPONED) {
+        // We postponed the root, so we write nothing.
+        return;
+      } else if (request.pendingRootTasks === 0) {
+        if (enableFloat) {
+          writePreamble(destination, request.resumableState, request.renderState, request.allPendingTasks === 0 && request.trackedPostpones === null);
+        }
+
+        flushSegment(request, destination, completedRootSegment);
+        request.completedRootSegment = null;
+        writeCompletedRoot(destination, request.renderState, request.resumableState);
+      } else {
+        // We haven't flushed the root yet so we don't need to check any other branches further down
+        return;
+      }
+    }
+
+    if (enableFloat) {
+      writeHoistables(destination, request.resumableState, request.renderState);
+    } // We emit client rendering instructions for already emitted boundaries first.
+    // This is so that we can signal to the client to start client rendering them as
+    // soon as possible.
+
+
+    const clientRenderedBoundaries = request.clientRenderedBoundaries;
+
+    for (i = 0; i < clientRenderedBoundaries.length; i++) {
+      const boundary = clientRenderedBoundaries[i];
+
+      if (!flushClientRenderedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        clientRenderedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    clientRenderedBoundaries.splice(0, i); // Next we emit any complete boundaries. It's better to favor boundaries
+    // that are completely done since we can actually show them, than it is to emit
+    // any individual segments from a partially complete boundary.
+
+    const completedBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < completedBoundaries.length; i++) {
+      const boundary = completedBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        completedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    completedBoundaries.splice(0, i); // Allow anything written so far to flush to the underlying sink before
+    // we continue with lower priorities.
+
+    completeWriting(destination);
+    beginWriting(destination); // TODO: Here we'll emit data used by hydration.
+    // Next we emit any segments of any boundaries that are partially complete
+    // but not deeply complete.
+
+    const partialBoundaries = request.partialBoundaries;
+
+    for (i = 0; i < partialBoundaries.length; i++) {
+      const boundary = partialBoundaries[i];
+
+      if (!flushPartialBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        partialBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    partialBoundaries.splice(0, i); // Next we check the completed boundaries again. This may have had
+    // boundaries added to it in case they were too larged to be inlined.
+    // New ones might be added in this loop.
+
+    const largeBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < largeBoundaries.length; i++) {
+      const boundary = largeBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        largeBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    largeBoundaries.splice(0, i);
+  } finally {
+    if (request.allPendingTasks === 0 && request.pingedTasks.length === 0 && request.clientRenderedBoundaries.length === 0 && request.completedBoundaries.length === 0 // We don't need to check any partially completed segments because
+    // either they have pending task or they're complete.
+    ) {
+        request.flushScheduled = false;
+
+        {
+          // We write the trailing tags but only if don't have any data to resume.
+          // If we need to resume we'll write the postamble in the resume instead.
+          {
+            writePostamble(destination, request.resumableState);
+          }
+        }
+
+
+        close(destination); // We need to stop flowing now because we do not want any async contexts which might call
+        // float methods to initiate any flushes after this point
+
+        stopFlowing(request);
+      }
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  {
+    scheduleWork(() => performWork(request));
+  }
+
+  if (request.trackedPostpones === null) {
+    // this is either a regular render or a resume. For regular render we want
+    // to call emitEarlyPreloads after the first performWork because we want
+    // are responding to a live request and need to balance sending something early
+    // (i.e. don't want for the shell to finish) but we need something to send.
+    // The only implementation of this is for DOM at the moment and during resumes nothing
+    // actually emits but the code paths here are the same.
+    // During a prerender we don't want to be too aggressive in emitting early preloads
+    // because we aren't responding to a live request and we can wait for the prerender to
+    // postpone before we emit anything.
+    {
+      scheduleWork(() => enqueueEarlyPreloadsAfterInitialWork(request));
+    }
+  }
+}
+
+function enqueueEarlyPreloadsAfterInitialWork(request) {
+  const shellComplete = request.pendingRootTasks === 0;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    request.flushScheduled = true;
+    scheduleWork(() => {
+      // We need to existence check destination again here because it might go away
+      // in between the enqueueFlush call and the work execution
+      const destination = request.destination;
+
+      if (destination) {
+        flushCompletedQueues(request, destination);
+      } else {
+        request.flushScheduled = false;
+      }
+    });
+  }
+} // This function is intented to only be called during the pipe function for the Node builds.
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedQueues(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function stopFlowing(request) {
+  request.destination = null;
+} // This is called to early terminate a request. It puts all pending boundaries in client rendered state.
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+      abortableTasks.forEach(task => abortTask(task, request, error));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function flushResources(request) {
+  enqueueFlush(request);
+}
+function getFormState(request) {
+  return request.formState;
+}
+function getResumableState(request) {
+  return request.resumableState;
+}
+function getRenderState(request) {
+  return request.renderState;
+}
+
+function renderToReadableStream(children, options) {
+  return new Promise((resolve, reject) => {
+    let onFatalError;
+    let onAllReady;
+    const allReady = new Promise((res, rej) => {
+      onAllReady = res;
+      onFatalError = rej;
+    });
+
+    function onShellReady() {
+      const stream = new ReadableStream({
+        type: 'direct',
+        pull: controller => {
+          // $FlowIgnore
+          startFlowing(request, controller);
+        },
+        cancel: reason => {
+          stopFlowing(request);
+          abort(request, reason);
+        }
+      }, // $FlowFixMe[prop-missing] size() methods are not allowed on byte streams.
+      {
+        highWaterMark: 2048
+      }); // TODO: Move to sub-classing ReadableStream.
+
+      stream.allReady = allReady;
+      resolve(stream);
+    }
+
+    function onShellError(error) {
+      // If the shell errors the caller of `renderToReadableStream` won't have access to `allReady`.
+      // However, `allReady` will be rejected by `onFatalError` as well.
+      // So we need to catch the duplicate, uncatchable fatal error in `allReady` to prevent a `UnhandledPromiseRejection`.
+      allReady.catch(() => {});
+      reject(error);
+    }
+
+    const onHeaders = options ? options.onHeaders : undefined;
+    let onHeadersImpl;
+
+    if (onHeaders) {
+      onHeadersImpl = headersDescriptor => {
+        onHeaders(new Headers(headersDescriptor));
+      };
+    }
+
+    const resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined);
+    const request = createRequest(children, resumableState, createRenderState(resumableState, options ? options.nonce : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, onHeadersImpl, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, onShellReady, onShellError, onFatalError, options ? options.onPostpone : undefined, options ? options.formState : undefined);
+
+    if (options && options.signal) {
+      const signal = options.signal;
+
+      if (signal.aborted) {
+        abort(request, signal.reason);
+      } else {
+        const listener = () => {
+          abort(request, signal.reason);
+          signal.removeEventListener('abort', listener);
+        };
+
+        signal.addEventListener('abort', listener);
+      }
+    }
+
+    startWork(request);
+  });
+}
+
+function renderToNodeStream() {
+  throw new Error('ReactDOMServer.renderToNodeStream(): The Node Stream API is not available ' + 'in Bun. Use ReactDOMServer.renderToReadableStream() instead.');
+}
+
+function renderToStaticNodeStream() {
+  throw new Error('ReactDOMServer.renderToStaticNodeStream(): The Node Stream API is not available ' + 'in Bun. Use ReactDOMServer.renderToReadableStream() instead.');
+}
+
+exports.renderToNodeStream = renderToNodeStream;
+exports.renderToReadableStream = renderToReadableStream;
+exports.renderToStaticNodeStream = renderToStaticNodeStream;
+exports.version = ReactVersion;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom-server.edge.development.js b/packages/next/src/compiled/react-dom/cjs/react-dom-server.edge.development.js
index ce56f4c3238b5..6704296583e2b 100644
--- a/packages/next/src/compiled/react-dom/cjs/react-dom-server.edge.development.js
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom-server.edge.development.js
@@ -17,7 +17,7 @@ if (process.env.NODE_ENV !== "production") {
 var React = require("next/dist/compiled/react");
 var ReactDOM = require('react-dom');
 
-var ReactVersion = '18.3.0-canary-2983249dd-20231107';
+var ReactVersion = '18.3.0-canary-7508dcd5c-20231108';
 
 var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
 
@@ -1809,11 +1809,14 @@ var DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS = 2000; // Allows us to keep tr
 // if passed externalRuntimeConfig and the enableFizzExternalRuntime feature flag
 // is set, the server will send instructions via data attributes (instead of inline scripts)
 
-function createRenderState(resumableState, nonce, bootstrapScriptContent, bootstrapScripts, bootstrapModules, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
+function createRenderState(resumableState, nonce, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
   var inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
   var idPrefix = resumableState.idPrefix;
   var bootstrapChunks = [];
   var externalRuntimeScript = null;
+  var bootstrapScriptContent = resumableState.bootstrapScriptContent,
+      bootstrapScripts = resumableState.bootstrapScripts,
+      bootstrapModules = resumableState.bootstrapModules;
 
   if (bootstrapScriptContent !== undefined) {
     bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapAndImportMapScriptContent(bootstrapScriptContent)), endInlineScript);
@@ -2002,7 +2005,7 @@ function createRenderState(resumableState, nonce, bootstrapScriptContent, bootst
 
   return renderState;
 }
-function createResumableState(identifierPrefix, externalRuntimeConfig) {
+function createResumableState(identifierPrefix, externalRuntimeConfig, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
   var idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
   var streamingFormat = ScriptStreamingFormat;
 
@@ -2016,6 +2019,9 @@ function createResumableState(identifierPrefix, externalRuntimeConfig) {
     idPrefix: idPrefix,
     nextFormID: 0,
     streamingFormat: streamingFormat,
+    bootstrapScriptContent: bootstrapScriptContent,
+    bootstrapScripts: bootstrapScripts,
+    bootstrapModules: bootstrapModules,
     instructions: NothingSent,
     hasBody: false,
     hasHtml: false,
@@ -4455,7 +4461,10 @@ function pushEndInstance(target, type, props, resumableState, formatContext) {
   target.push(endChunkForTag(type));
 }
 
-function writeBootstrap(destination, renderState) {
+function writeBootstrap(destination, renderState, resumableState) {
+  resumableState.bootstrapScriptContent = undefined;
+  resumableState.bootstrapScripts = undefined;
+  resumableState.bootstrapModules = undefined;
   var bootstrapChunks = renderState.bootstrapChunks;
   var i = 0;
 
@@ -4472,8 +4481,8 @@ function writeBootstrap(destination, renderState) {
   return true;
 }
 
-function writeCompletedRoot(destination, renderState) {
-  return writeBootstrap(destination, renderState);
+function writeCompletedRoot(destination, renderState, resumableState) {
+  return writeBootstrap(destination, renderState, resumableState);
 } // Structural Nodes
 // A placeholder is a node inside a hidden partial tree that can be filled in later, but before
 // display. It's never visible to users. We use the template tag because it can be used in every
@@ -4830,7 +4839,7 @@ function writeCompletedBoundaryInstruction(destination, resumableState, renderSt
     writeMore = writeChunkAndReturn(destination, completeBoundaryDataEnd);
   }
 
-  return writeBootstrap(destination, renderState) && writeMore;
+  return writeBootstrap(destination, renderState, resumableState) && writeMore;
 }
 var clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
 var clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
@@ -6831,6 +6840,18 @@ var componentFrameCache;
   var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
   componentFrameCache = new PossiblyWeakMap();
 }
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
@@ -6846,7 +6867,6 @@ function describeNativeComponentFrame(fn, construct) {
     }
   }
 
-  var control;
   reentry = true;
   var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
 
@@ -6860,81 +6880,140 @@ function describeNativeComponentFrame(fn, construct) {
     ReactCurrentDispatcher$1.current = null;
     disableLogs();
   }
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
 
-  try {
-    // This should throw.
-    if (construct) {
-      // Something should be setting the props in the constructor.
-      var Fake = function () {
-        throw Error();
-      }; // $FlowFixMe[prop-missing]
 
+  var RunInRootFrame = {
+    DetermineComponentFrameRoot: function () {
+      var control;
 
-      Object.defineProperty(Fake.prototype, 'props', {
-        set: function () {
-          // We use a throwing setter instead of frozen or non-writable props
-          // because that won't throw in a non-strict mode function.
-          throw Error();
-        }
-      });
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          var Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
 
-      if (typeof Reflect === 'object' && Reflect.construct) {
-        // We construct a different control for this case to include any extra
-        // frames added by the construct call.
-        try {
-          Reflect.construct(Fake, []);
-        } catch (x) {
-          control = x;
-        }
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
 
-        Reflect.construct(fn, [], Fake);
-      } else {
-        try {
-          Fake.call();
-        } catch (x) {
-          control = x;
-        } // $FlowFixMe[prop-missing] found when upgrading Flow
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
 
 
-        fn.call(Fake.prototype);
-      }
-    } else {
-      try {
-        throw Error();
-      } catch (x) {
-        control = x;
-      } // TODO(luna): This will currently only throw if the function component
-      // tries to access React/ReactDOM/props. We should probably make this throw
-      // in simple components too
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
 
 
-      var maybePromise = fn(); // If the function component returns a promise, it's likely an async
-      // component, which we don't yet support. Attach a noop catch handler to
-      // silence the error.
-      // TODO: Implement component stacks for async client components?
+          var maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
 
-      if (maybePromise && typeof maybePromise.catch === 'function') {
-        maybePromise.catch(function () {});
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(function () {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
       }
+
+      return [null, null];
     }
-  } catch (sample) {
-    // This is inlined manually because closure doesn't do it for us.
-    if (sample && control && typeof sample.stack === 'string') {
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
+
+  try {
+    var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
+
+    if (sampleStack && controlStack) {
       // This extracts the first frame from the sample that isn't also in the control.
       // Skipping one frame that we assume is the frame that calls the two.
-      var sampleLines = sample.stack.split('\n');
-      var controlLines = control.stack.split('\n');
-      var s = sampleLines.length - 1;
-      var c = controlLines.length - 1;
-
-      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
-        // We expect at least one stack frame to be shared.
-        // Typically this will be the root most one. However, stack frames may be
-        // cut off due to maximum stack limits. In this case, one maybe cut off
-        // earlier than the other. We assume that the sample is longer or the same
-        // and there for cut off earlier. So we should find the root most frame in
-        // the sample somewhere in the control.
-        c--;
+      var sampleLines = sampleStack.split('\n');
+      var controlLines = controlStack.split('\n');
+      var s = 0;
+      var c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
       }
 
       for (; s >= 1 && c >= 0; s--, c--) {
@@ -6963,7 +7042,7 @@ function describeNativeComponentFrame(fn, construct) {
                   _frame = _frame.replace('<anonymous>', fn.displayName);
                 }
 
-                {
+                if (true) {
                   if (typeof fn === 'function') {
                     componentFrameCache.set(fn, _frame);
                   }
@@ -11343,7 +11422,7 @@ function flushCompletedQueues(request, destination) {
 
         flushSegment(request, destination, completedRootSegment);
         request.completedRootSegment = null;
-        writeCompletedRoot(destination, request.renderState);
+        writeCompletedRoot(destination, request.renderState, request.resumableState);
       } else {
         // We haven't flushed the root yet so we don't need to check any other branches further down
         return;
@@ -11625,8 +11704,8 @@ function renderToReadableStream(children, options) {
       };
     }
 
-    var resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined);
-    var request = createRequest(children, resumableState, createRenderState(resumableState, options ? options.nonce : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, onHeadersImpl, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, onShellReady, onShellError, onFatalError, options ? options.onPostpone : undefined, options ? options.formState : undefined);
+    var resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined);
+    var request = createRequest(children, resumableState, createRenderState(resumableState, options ? options.nonce : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, onHeadersImpl, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, onShellReady, onShellError, onFatalError, options ? options.onPostpone : undefined, options ? options.formState : undefined);
 
     if (options && options.signal) {
       var signal = options.signal;
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom-server.edge.production.js b/packages/next/src/compiled/react-dom/cjs/react-dom-server.edge.production.js
new file mode 100644
index 0000000000000..dccb492307c39
--- /dev/null
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom-server.edge.production.js
@@ -0,0 +1,8614 @@
+/**
+ * @license React
+ * react-dom-server.edge.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require("next/dist/compiled/react");
+var ReactDOM = require('react-dom');
+
+var ReactVersion = '18.3.0-canary-7508dcd5c-20231108';
+
+// A pure JS implementation of a string hashing function. We do not use it for
+// security or obfuscation purposes, only to create compact hashes. So we
+// prioritize speed over collision avoidance. For example, we use this to hash
+// the component key path used by useFormState for MPA-style submissions.
+//
+// In environments where built-in hashing functions are available, we prefer
+// those instead. Like Node's crypto module, or Bun.hash. Unfortunately this
+// does not include the web standard crypto API because those methods are all
+// async. For our purposes, we need it to be sync because the cost of context
+// switching is too high to be worth it.
+//
+// The most popular hashing algorithm that meets these requirements in the JS
+// ecosystem is MurmurHash3, and almost all implementations I could find used
+// some version of the implementation by Gary Court inlined below.
+function createFastHashJS(key) {
+  return murmurhash3_32_gc(key, 0);
+}
+/* eslint-disable prefer-const, no-fallthrough */
+
+/**
+ * @license
+ *
+ * JS Implementation of MurmurHash3 (r136) (as of May 20, 2011)
+ *
+ * Copyright (c) 2011 Gary Court
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+function murmurhash3_32_gc(key, seed) {
+  let remainder, bytes, h1, h1b, c1, c2, k1, i;
+  remainder = key.length & 3; // key.length % 4
+
+  bytes = key.length - remainder;
+  h1 = seed;
+  c1 = 0xcc9e2d51;
+  c2 = 0x1b873593;
+  i = 0;
+
+  while (i < bytes) {
+    k1 = key.charCodeAt(i) & 0xff | (key.charCodeAt(++i) & 0xff) << 8 | (key.charCodeAt(++i) & 0xff) << 16 | (key.charCodeAt(++i) & 0xff) << 24;
+    ++i;
+    k1 = (k1 & 0xffff) * c1 + (((k1 >>> 16) * c1 & 0xffff) << 16) & 0xffffffff;
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = (k1 & 0xffff) * c2 + (((k1 >>> 16) * c2 & 0xffff) << 16) & 0xffffffff;
+    h1 ^= k1;
+    h1 = h1 << 13 | h1 >>> 19;
+    h1b = (h1 & 0xffff) * 5 + (((h1 >>> 16) * 5 & 0xffff) << 16) & 0xffffffff;
+    h1 = (h1b & 0xffff) + 0x6b64 + (((h1b >>> 16) + 0xe654 & 0xffff) << 16);
+  }
+
+  k1 = 0;
+
+  switch (remainder) {
+    case 3:
+      k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
+
+    case 2:
+      k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
+
+    case 1:
+      k1 ^= key.charCodeAt(i) & 0xff;
+      k1 = (k1 & 0xffff) * c1 + (((k1 >>> 16) * c1 & 0xffff) << 16) & 0xffffffff;
+      k1 = k1 << 15 | k1 >>> 17;
+      k1 = (k1 & 0xffff) * c2 + (((k1 >>> 16) * c2 & 0xffff) << 16) & 0xffffffff;
+      h1 ^= k1;
+  }
+
+  h1 ^= key.length;
+  h1 ^= h1 >>> 16;
+  h1 = (h1 & 0xffff) * 0x85ebca6b + (((h1 >>> 16) * 0x85ebca6b & 0xffff) << 16) & 0xffffffff;
+  h1 ^= h1 >>> 13;
+  h1 = (h1 & 0xffff) * 0xc2b2ae35 + (((h1 >>> 16) * 0xc2b2ae35 & 0xffff) << 16) & 0xffffffff;
+  h1 ^= h1 >>> 16;
+  return h1 >>> 0;
+}
+
+function scheduleWork(callback) {
+  setTimeout(callback, 0);
+}
+const VIEW_SIZE = 512;
+let currentView = null;
+let writtenBytes = 0;
+function beginWriting(destination) {
+  currentView = new Uint8Array(VIEW_SIZE);
+  writtenBytes = 0;
+}
+function writeChunk(destination, chunk) {
+  if (chunk.byteLength === 0) {
+    return;
+  }
+
+  if (chunk.byteLength > VIEW_SIZE) {
+    // one that is cached by the streaming renderer. We will enqueu
+    // it directly and expect it is not re-used
+
+
+    if (writtenBytes > 0) {
+      destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    destination.enqueue(chunk);
+    return;
+  }
+
+  let bytesToWrite = chunk;
+  const allowableBytes = currentView.length - writtenBytes;
+
+  if (allowableBytes < bytesToWrite.byteLength) {
+    // this chunk would overflow the current view. We enqueue a full view
+    // and start a new view with the remaining chunk
+    if (allowableBytes === 0) {
+      // the current view is already full, send it
+      destination.enqueue(currentView);
+    } else {
+      // fill up the current view and apply the remaining chunk bytes
+      // to a new view.
+      currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes); // writtenBytes += allowableBytes; // this can be skipped because we are going to immediately reset the view
+
+      destination.enqueue(currentView);
+      bytesToWrite = bytesToWrite.subarray(allowableBytes);
+    }
+
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+
+  currentView.set(bytesToWrite, writtenBytes);
+  writtenBytes += bytesToWrite.byteLength;
+}
+function writeChunkAndReturn(destination, chunk) {
+  writeChunk(destination, chunk); // in web streams there is no backpressure so we can alwas write more
+
+  return true;
+}
+function completeWriting(destination) {
+  if (currentView && writtenBytes > 0) {
+    destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+    currentView = null;
+    writtenBytes = 0;
+  }
+}
+function close(destination) {
+  destination.close();
+}
+const textEncoder = new TextEncoder();
+function stringToChunk(content) {
+  return textEncoder.encode(content);
+}
+function stringToPrecomputedChunk(content) {
+  const precomputedChunk = textEncoder.encode(content);
+
+  return precomputedChunk;
+}
+function clonePrecomputedChunk(precomputedChunk) {
+  return precomputedChunk.byteLength > VIEW_SIZE ? precomputedChunk.slice() : precomputedChunk;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[method-unbinding]
+  if (typeof destination.error === 'function') {
+    // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+    destination.error(error);
+  } else {
+    // Earlier implementations doesn't support this method. In that environment you're
+    // supposed to throw from a promise returned but we don't return a promise in our
+    // approach. We could fork this implementation but this is environment is an edge
+    // case to begin with. It's even less common to run this in an older environment.
+    // Even then, this is not where errors are supposed to happen and they get reported
+    // to a global callback in addition to this anyway. So it's fine just to close this.
+    destination.close();
+  }
+}
+
+const assign = Object.assign;
+
+// -----------------------------------------------------------------------------
+const enableFloat = true; // Enables unstable_useMemoCache hook, intended as a compilation target for
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/* eslint-disable max-len */
+
+const ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
+/* eslint-enable max-len */
+
+const ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
+const VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+const illegalAttributeNameCache = {};
+const validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+  if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+    return true;
+  }
+
+  if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+    return false;
+  }
+
+  if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+    validatedAttributeNameCache[attributeName] = true;
+    return true;
+  }
+
+  illegalAttributeNameCache[attributeName] = true;
+
+  return false;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+const unitlessNumbers = new Set(['animationIterationCount', 'aspectRatio', 'borderImageOutset', 'borderImageSlice', 'borderImageWidth', 'boxFlex', 'boxFlexGroup', 'boxOrdinalGroup', 'columnCount', 'columns', 'flex', 'flexGrow', 'flexPositive', 'flexShrink', 'flexNegative', 'flexOrder', 'gridArea', 'gridRow', 'gridRowEnd', 'gridRowSpan', 'gridRowStart', 'gridColumn', 'gridColumnEnd', 'gridColumnSpan', 'gridColumnStart', 'fontWeight', 'lineClamp', 'lineHeight', 'opacity', 'order', 'orphans', 'scale', 'tabSize', 'widows', 'zIndex', 'zoom', 'fillOpacity', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'MozBoxFlexGroup', 'MozLineClamp', 'msAnimationIterationCount', 'msFlex', 'msZoom', 'msFlexGrow', 'msFlexNegative', 'msFlexOrder', 'msFlexPositive', 'msFlexShrink', 'msGridColumn', 'msGridColumnSpan', 'msGridRow', 'msGridRowSpan', 'WebkitAnimationIterationCount', 'WebkitBoxFlex', 'WebKitBoxFlexGroup', 'WebkitBoxOrdinalGroup', 'WebkitColumnCount', 'WebkitColumns', 'WebkitFlex', 'WebkitFlexGrow', 'WebkitFlexPositive', 'WebkitFlexShrink', 'WebkitLineClamp']);
+function isUnitlessNumber (name) {
+  return unitlessNumbers.has(name);
+}
+
+const aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+  return aliases.get(name) || name;
+}
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// code copied and modified from escape-html
+const matchHtmlRegExp = /["'&<>]/;
+/**
+ * Escapes special characters and HTML entities in a given html string.
+ *
+ * @param  {string} string HTML string to escape for later insertion
+ * @return {string}
+ * @public
+ */
+
+function escapeHtml(string) {
+
+  const str = '' + string;
+  const match = matchHtmlRegExp.exec(str);
+
+  if (!match) {
+    return str;
+  }
+
+  let escape;
+  let html = '';
+  let index;
+  let lastIndex = 0;
+
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        // "
+        escape = '&quot;';
+        break;
+
+      case 38:
+        // &
+        escape = '&amp;';
+        break;
+
+      case 39:
+        // '
+        escape = '&#x27;'; // modified from escape-html; used to be '&#39'
+
+        break;
+
+      case 60:
+        // <
+        escape = '&lt;';
+        break;
+
+      case 62:
+        // >
+        escape = '&gt;';
+        break;
+
+      default:
+        continue;
+    }
+
+    if (lastIndex !== index) {
+      html += str.slice(lastIndex, index);
+    }
+
+    lastIndex = index + 1;
+    html += escape;
+  }
+
+  return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+} // end code copied and modified from escape-html
+
+/**
+ * Escapes text to prevent scripting attacks.
+ *
+ * @param {*} text Text value to escape.
+ * @return {string} An escaped string.
+ */
+
+
+function escapeTextForBrowser(text) {
+  if (typeof text === 'boolean' || typeof text === 'number') {
+    // this shortcircuit helps perf for types that we know will never have
+    // special characters, especially given that this function is used often
+    // for numeric dom ids.
+    return '' + text;
+  }
+
+  return escapeHtml(text);
+}
+
+const uppercasePattern = /([A-Z])/g;
+const msPattern = /^ms-/;
+/**
+ * Hyphenates a camelcased CSS property name, for example:
+ *
+ *   > hyphenateStyleName('backgroundColor')
+ *   < "background-color"
+ *   > hyphenateStyleName('MozTransition')
+ *   < "-moz-transition"
+ *   > hyphenateStyleName('msTransition')
+ *   < "-ms-transition"
+ *
+ * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
+ * is converted to `-ms-`.
+ */
+
+function hyphenateStyleName(name) {
+  return name.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern, '-ms-');
+}
+
+function sanitizeURL(url) {
+
+  return url;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+// The build script is at scripts/rollup/generate-inline-fizz-runtime.js.
+// Run `yarn generate-inline-fizz-runtime` to generate.
+const clientRenderBoundary = '$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};';
+const completeBoundary = '$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};';
+const completeBoundaryWithStyles = '$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};';
+const completeSegment = '$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};';
+const formReplaying = 'addEventListener("submit",function(a){if(!a.defaultPrevented){var c=a.target,d=a.submitter,e=c.action,b=d;if(d){var f=d.getAttribute("formAction");null!=f&&(e=f,b=null)}"javascript:throw new Error(\'A React form was unexpectedly submitted.\')"===e&&(a.preventDefault(),b?(a=document.createElement("input"),a.name=b.name,a.value=b.value,b.parentNode.insertBefore(a,b),b=new FormData(c),a.parentNode.removeChild(a)):b=new FormData(c),a=c.getRootNode(),(a.$$reactFormReplay=a.$$reactFormReplay||[]).push(c,\nd,b))}});';
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+// same object across all transitions.
+
+const sharedNotPendingObject = {
+  pending: false,
+  data: null,
+  method: null,
+  action: null
+};
+const NotPending = sharedNotPendingObject;
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+const ReactDOMServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMServerDispatcher;
+} // We make every property of the descriptor optional because it is not a contract that
+const ScriptStreamingFormat = 0;
+const DataStreamingFormat = 1;
+const NothingSent
+/*                      */
+= 0b00000;
+const SentCompleteSegmentFunction
+/*      */
+= 0b00001;
+const SentCompleteBoundaryFunction
+/*     */
+= 0b00010;
+const SentClientRenderFunction
+/*         */
+= 0b00100;
+const SentStyleInsertionFunction
+/*       */
+= 0b01000;
+const SentFormReplayingRuntime
+/*         */
+= 0b10000; // Per request, global state that is not contextual to the rendering subtree.
+// This cannot be resumed and therefore should only contain things that are
+// temporary working state or are never used in the prerender pass.
+// Credentials here are things that affect whether a browser will make a request
+// as well as things that affect which connection the browser will use for that request.
+// We want these to be aligned across preloads and resources because otherwise the preload
+// will be wasted.
+// We investigated whether referrerPolicy should be included here but from experimentation
+// it seems that browsers do not treat this as part of the http cache key and does not affect
+// which connection is used.
+
+const EXISTS = null; // This constant is to mark preloads that have no unique credentials
+// to convey. It should never be checked by identity and we should not
+// assume Preload values in ResumableState equal this value because they
+// will have come from some parsed input.
+
+const PRELOAD_NO_CREDS = [];
+// This is resumable and therefore should be serializable.
+
+
+const dataElementQuotedEnd = stringToPrecomputedChunk('"></template>');
+const startInlineScript = stringToPrecomputedChunk('<script>');
+const endInlineScript = stringToPrecomputedChunk('</script>');
+const startScriptSrc = stringToPrecomputedChunk('<script src="');
+const startModuleSrc = stringToPrecomputedChunk('<script type="module" src="');
+const scriptNonce = stringToPrecomputedChunk('" nonce="');
+const scriptIntegirty = stringToPrecomputedChunk('" integrity="');
+const scriptCrossOrigin = stringToPrecomputedChunk('" crossorigin="');
+const endAsyncScript = stringToPrecomputedChunk('" async=""></script>');
+/**
+ * This escaping function is designed to work with bootstrapScriptContent and importMap only.
+ * because we know we are escaping the entire script. We can avoid for instance
+ * escaping html comment string sequences that are valid javascript as well because
+ * if there are no sebsequent <script sequences the html parser will never enter
+ * script data double escaped state (see: https://www.w3.org/TR/html53/syntax.html#script-data-double-escaped-state)
+ *
+ * While untrusted script content should be made safe before using this api it will
+ * ensure that the script cannot be early terminated or never terminated state
+ */
+
+function escapeBootstrapAndImportMapScriptContent(scriptText) {
+
+  return ('' + scriptText).replace(scriptRegex, scriptReplacer);
+}
+
+const scriptRegex = /(<\/|<)(s)(cript)/gi;
+
+const scriptReplacer = (match, prefix, s, suffix) => "" + prefix + (s === 's' ? '\\u0073' : '\\u0053') + suffix;
+
+const importMapScriptStart = stringToPrecomputedChunk('<script type="importmap">');
+const importMapScriptEnd = stringToPrecomputedChunk('</script>'); // Since we store headers as strings we deal with their length in utf16 code units
+// rather than visual characters or the utf8 encoding that is used for most binary
+// serialization. Some common HTTP servers only allow for headers to be 4kB in length.
+// We choose a default length that is likely to be well under this already limited length however
+// pathological cases may still cause the utf-8 encoding of the headers to approach this limit.
+// It should also be noted that this maximum is a soft maximum. we have not reached the limit we will
+// allow one more header to be captured which means in practice if the limit is approached it will be exceeded
+
+const DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS = 2000; // Allows us to keep track of what we've already written so we can refer back to it.
+// if passed externalRuntimeConfig and the enableFizzExternalRuntime feature flag
+// is set, the server will send instructions via data attributes (instead of inline scripts)
+
+function createRenderState(resumableState, nonce, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
+  const inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
+  const idPrefix = resumableState.idPrefix;
+  const bootstrapChunks = [];
+  let externalRuntimeScript = null;
+  const bootstrapScriptContent = resumableState.bootstrapScriptContent,
+        bootstrapScripts = resumableState.bootstrapScripts,
+        bootstrapModules = resumableState.bootstrapModules;
+
+  if (bootstrapScriptContent !== undefined) {
+    bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapAndImportMapScriptContent(bootstrapScriptContent)), endInlineScript);
+  }
+
+  {
+
+    if (externalRuntimeConfig !== undefined) {
+      if (typeof externalRuntimeConfig === 'string') {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig,
+          async: true,
+          integrity: undefined,
+          nonce: nonce
+        });
+      } else {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig.src,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig.src,
+          async: true,
+          integrity: externalRuntimeConfig.integrity,
+          nonce: nonce
+        });
+      }
+    }
+  }
+
+  const importMapChunks = [];
+
+  if (importMap !== undefined) {
+    const map = importMap;
+    importMapChunks.push(importMapScriptStart);
+    importMapChunks.push(stringToChunk(escapeBootstrapAndImportMapScriptContent(JSON.stringify(map))));
+    importMapChunks.push(importMapScriptEnd);
+  }
+
+  const headers = onHeaders ? {
+    preconnects: '',
+    fontPreloads: '',
+    highImagePreloads: '',
+    remainingCapacity: typeof maxHeadersLength === 'number' ? maxHeadersLength : DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS
+  } : null;
+  const renderState = {
+    placeholderPrefix: stringToPrecomputedChunk(idPrefix + 'P:'),
+    segmentPrefix: stringToPrecomputedChunk(idPrefix + 'S:'),
+    boundaryPrefix: stringToPrecomputedChunk(idPrefix + 'B:'),
+    startInlineScript: inlineScriptWithNonce,
+    htmlChunks: null,
+    headChunks: null,
+    externalRuntimeScript: externalRuntimeScript,
+    bootstrapChunks: bootstrapChunks,
+    onHeaders,
+    headers,
+    resets: {
+      font: {},
+      dns: {},
+      connect: {
+        default: {},
+        anonymous: {},
+        credentials: {}
+      },
+      image: {},
+      style: {}
+    },
+    charsetChunks: [],
+    preconnectChunks: [],
+    importMapChunks,
+    preloadChunks: [],
+    hoistableChunks: [],
+    // cleared on flush
+    preconnects: new Set(),
+    fontPreloads: new Set(),
+    highImagePreloads: new Set(),
+    // usedImagePreloads: new Set(),
+    styles: new Map(),
+    bootstrapScripts: new Set(),
+    scripts: new Set(),
+    bulkPreloads: new Set(),
+    preloads: {
+      images: new Map(),
+      stylesheets: new Map(),
+      scripts: new Map(),
+      moduleScripts: new Map()
+    },
+    nonce,
+    // like a module global for currently rendering boundary
+    boundaryResources: null,
+    stylesToHoist: false
+  };
+
+  if (bootstrapScripts !== undefined) {
+    for (let i = 0; i < bootstrapScripts.length; i++) {
+      const scriptConfig = bootstrapScripts[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'preload',
+        as: 'script',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startScriptSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  if (bootstrapModules !== undefined) {
+    for (let i = 0; i < bootstrapModules.length; i++) {
+      const scriptConfig = bootstrapModules[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'modulepreload',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startModuleSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  return renderState;
+}
+function createResumableState(identifierPrefix, externalRuntimeConfig, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
+  const idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
+  let streamingFormat = ScriptStreamingFormat;
+
+  {
+    if (externalRuntimeConfig !== undefined) {
+      streamingFormat = DataStreamingFormat;
+    }
+  }
+
+  return {
+    idPrefix: idPrefix,
+    nextFormID: 0,
+    streamingFormat,
+    bootstrapScriptContent,
+    bootstrapScripts,
+    bootstrapModules,
+    instructions: NothingSent,
+    hasBody: false,
+    hasHtml: false,
+    // @TODO add bootstrap script to implicit preloads
+    // persistent
+    unknownResources: {},
+    dnsResources: {},
+    connectResources: {
+      default: {},
+      anonymous: {},
+      credentials: {}
+    },
+    imageResources: {},
+    styleResources: {},
+    scriptResources: {},
+    moduleUnknownResources: {},
+    moduleScriptResources: {}
+  };
+}
+// modes. We only include the variants as they matter for the sake of our purposes.
+// We don't actually provide the namespace therefore we use constants instead of the string.
+
+const ROOT_HTML_MODE = 0; // Used for the root most element tag.
+// We have a less than HTML_HTML_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const HTML_HTML_MODE = 1; // Used for the <html> if it is at the top level.
+
+const HTML_MODE = 2;
+const SVG_MODE = 3;
+const MATHML_MODE = 4;
+const HTML_TABLE_MODE = 5;
+const HTML_TABLE_BODY_MODE = 6;
+const HTML_TABLE_ROW_MODE = 7;
+const HTML_COLGROUP_MODE = 8; // We have a greater than HTML_TABLE_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const NO_SCOPE =
+/*         */
+0b00;
+const NOSCRIPT_SCOPE =
+/*   */
+0b01;
+const PICTURE_SCOPE =
+/*    */
+0b10; // Lets us keep track of contextual state and pick it back up after suspending.
+
+function createFormatContext(insertionMode, selectedValue, tagScope) {
+  return {
+    insertionMode,
+    selectedValue,
+    tagScope
+  };
+}
+
+function createRootFormatContext(namespaceURI) {
+  const insertionMode = namespaceURI === 'http://www.w3.org/2000/svg' ? SVG_MODE : namespaceURI === 'http://www.w3.org/1998/Math/MathML' ? MATHML_MODE : ROOT_HTML_MODE;
+  return createFormatContext(insertionMode, null, NO_SCOPE);
+}
+function getChildFormatContext(parentContext, type, props) {
+  switch (type) {
+    case 'noscript':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | NOSCRIPT_SCOPE);
+
+    case 'select':
+      return createFormatContext(HTML_MODE, props.value != null ? props.value : props.defaultValue, parentContext.tagScope);
+
+    case 'svg':
+      return createFormatContext(SVG_MODE, null, parentContext.tagScope);
+
+    case 'picture':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | PICTURE_SCOPE);
+
+    case 'math':
+      return createFormatContext(MATHML_MODE, null, parentContext.tagScope);
+
+    case 'foreignObject':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    // Table parents are special in that their children can only be created at all if they're
+    // wrapped in a table parent. So we need to encode that we're entering this mode.
+
+    case 'table':
+      return createFormatContext(HTML_TABLE_MODE, null, parentContext.tagScope);
+
+    case 'thead':
+    case 'tbody':
+    case 'tfoot':
+      return createFormatContext(HTML_TABLE_BODY_MODE, null, parentContext.tagScope);
+
+    case 'colgroup':
+      return createFormatContext(HTML_COLGROUP_MODE, null, parentContext.tagScope);
+
+    case 'tr':
+      return createFormatContext(HTML_TABLE_ROW_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode >= HTML_TABLE_MODE) {
+    // Whatever tag this was, it wasn't a table parent or other special parent, so we must have
+    // entered plain HTML again.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode === ROOT_HTML_MODE) {
+    if (type === 'html') {
+      // We've emitted the root and is now in <html> mode.
+      return createFormatContext(HTML_HTML_MODE, null, parentContext.tagScope);
+    } else {
+      // We've emitted the root and is now in plain HTML mode.
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    }
+  } else if (parentContext.insertionMode === HTML_HTML_MODE) {
+    // We've emitted the document element and is now in plain HTML mode.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  return parentContext;
+}
+function makeId(resumableState, treeId, localId) {
+  const idPrefix = resumableState.idPrefix;
+  let id = ':' + idPrefix + 'R' + treeId; // Unless this is the first id at this level, append a number at the end
+  // that represents the position of this useId hook among all the useId
+  // hooks for this fiber.
+
+  if (localId > 0) {
+    id += 'H' + localId.toString(32);
+  }
+
+  return id + ':';
+}
+
+function encodeHTMLTextNode(text) {
+  return escapeTextForBrowser(text);
+}
+
+const textSeparator = stringToPrecomputedChunk('<!-- -->');
+function pushTextInstance(target, text, renderState, textEmbedded) {
+  if (text === '') {
+    // Empty text doesn't have a DOM node representation and the hydration is aware of this.
+    return textEmbedded;
+  }
+
+  if (textEmbedded) {
+    target.push(textSeparator);
+  }
+
+  target.push(stringToChunk(encodeHTMLTextNode(text)));
+  return true;
+} // Called when Fizz is done with a Segment. Currently the only purpose is to conditionally
+// emit a text separator when we don't know for sure it is safe to omit
+
+function pushSegmentFinale(target, renderState, lastPushedText, textEmbedded) {
+  if (lastPushedText && textEmbedded) {
+    target.push(textSeparator);
+  }
+}
+const styleNameCache = new Map();
+
+function processStyleName(styleName) {
+  const chunk = styleNameCache.get(styleName);
+
+  if (chunk !== undefined) {
+    return chunk;
+  }
+
+  const result = stringToPrecomputedChunk(escapeTextForBrowser(hyphenateStyleName(styleName)));
+  styleNameCache.set(styleName, result);
+  return result;
+}
+
+const styleAttributeStart = stringToPrecomputedChunk(' style="');
+const styleAssign = stringToPrecomputedChunk(':');
+const styleSeparator = stringToPrecomputedChunk(';');
+
+function pushStyleAttribute(target, style) {
+  if (typeof style !== 'object') {
+    throw new Error('The `style` prop expects a mapping from style properties to values, ' + "not a string. For example, style={{marginRight: spacing + 'em'}} when " + 'using JSX.');
+  }
+
+  let isFirst = true;
+
+  for (const styleName in style) {
+    if (!hasOwnProperty.call(style, styleName)) {
+      continue;
+    } // If you provide unsafe user data here they can inject arbitrary CSS
+    // which may be problematic (I couldn't repro this):
+    // https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet
+    // http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/
+    // This is not an XSS hole but instead a potential CSS injection issue
+    // which has lead to a greater discussion about how we're going to
+    // trust URLs moving forward. See #2115901
+
+
+    const styleValue = style[styleName];
+
+    if (styleValue == null || typeof styleValue === 'boolean' || styleValue === '') {
+      // TODO: We used to set empty string as a style with an empty value. Does that ever make sense?
+      continue;
+    }
+
+    let nameChunk;
+    let valueChunk;
+    const isCustomProperty = styleName.indexOf('--') === 0;
+
+    if (isCustomProperty) {
+      nameChunk = stringToChunk(escapeTextForBrowser(styleName));
+
+      valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+    } else {
+
+      nameChunk = processStyleName(styleName);
+
+      if (typeof styleValue === 'number') {
+        if (styleValue !== 0 && !isUnitlessNumber(styleName)) {
+          valueChunk = stringToChunk(styleValue + 'px'); // Presumes implicit 'px' suffix for unitless numbers
+        } else {
+          valueChunk = stringToChunk('' + styleValue);
+        }
+      } else {
+
+        valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+      }
+    }
+
+    if (isFirst) {
+      isFirst = false; // If it's first, we don't need any separators prefixed.
+
+      target.push(styleAttributeStart, nameChunk, styleAssign, valueChunk);
+    } else {
+      target.push(styleSeparator, nameChunk, styleAssign, valueChunk);
+    }
+  }
+
+  if (!isFirst) {
+    target.push(attributeEnd);
+  }
+}
+
+const attributeSeparator = stringToPrecomputedChunk(' ');
+const attributeAssign = stringToPrecomputedChunk('="');
+const attributeEnd = stringToPrecomputedChunk('"');
+const attributeEmptyString = stringToPrecomputedChunk('=""');
+
+function pushBooleanAttribute(target, name, value) // not null or undefined
+{
+  if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+    target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+  }
+}
+
+function pushStringAttribute(target, name, value) // not null or undefined
+{
+  if (typeof value !== 'function' && typeof value !== 'symbol' && typeof value !== 'boolean') {
+    target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+  }
+}
+
+function makeFormFieldPrefix(resumableState) {
+  const id = resumableState.nextFormID++;
+  return resumableState.idPrefix + id;
+} // Since this will likely be repeated a lot in the HTML, we use a more concise message
+// than on the client and hopefully it's googleable.
+
+
+const actionJavaScriptURL = stringToPrecomputedChunk(escapeTextForBrowser( // eslint-disable-next-line no-script-url
+"javascript:throw new Error('A React form was unexpectedly submitted.')"));
+const startHiddenInputChunk = stringToPrecomputedChunk('<input type="hidden"');
+
+function pushAdditionalFormField(value, key) {
+  const target = this;
+  target.push(startHiddenInputChunk);
+
+  if (typeof value !== 'string') {
+    throw new Error('File/Blob fields are not yet supported in progressive forms. ' + 'It probably means you are closing over binary data or FormData in a Server Action.');
+  }
+
+  pushStringAttribute(target, 'name', key);
+  pushStringAttribute(target, 'value', value);
+  target.push(endOfStartTagSelfClosing);
+}
+
+function pushAdditionalFormFields(target, formData) {
+  if (formData !== null) {
+    // $FlowFixMe[prop-missing]: FormData has forEach.
+    formData.forEach(pushAdditionalFormField, target);
+  }
+}
+
+function pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name) {
+  let formData = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      name = customFields.name;
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('formAction'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      name = null;
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (name != null) {
+    pushAttribute(target, 'name', name);
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'formAction', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'formEncType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'formMethod', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'formTarget', formTarget);
+  }
+
+  return formData;
+}
+
+function pushAttribute(target, name, value) // not null or undefined
+{
+  switch (name) {
+    // These are very common props and therefore are in the beginning of the switch.
+    // TODO: aria-label is a very common prop but allows booleans so is not like the others
+    // but should ideally go in this list too.
+    case 'className':
+      {
+        pushStringAttribute(target, 'class', value);
+        break;
+      }
+
+    case 'tabIndex':
+      {
+        pushStringAttribute(target, 'tabindex', value);
+        break;
+      }
+
+    case 'dir':
+    case 'role':
+    case 'viewBox':
+    case 'width':
+    case 'height':
+      {
+        pushStringAttribute(target, name, value);
+        break;
+      }
+
+    case 'style':
+      {
+        pushStyleAttribute(target, value);
+        return;
+      }
+
+    case 'src':
+    case 'href':
+    // Fall through to the last case which shouldn't remove empty strings.
+
+    case 'action':
+    case 'formAction':
+      {
+        // TODO: Consider only special casing these for each tag.
+        if (value == null || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'defaultValue':
+    case 'defaultChecked': // These shouldn't be set as attributes on generic HTML elements.
+
+    case 'innerHTML': // Must use dangerouslySetInnerHTML instead.
+
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+      // Ignored. These are built-in to React on the client.
+      return;
+
+    case 'autoFocus':
+    case 'multiple':
+    case 'muted':
+      {
+        pushBooleanAttribute(target, name.toLowerCase(), value);
+        return;
+      }
+
+    case 'xlinkHref':
+      {
+        if (typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk('xlink:href'), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'contentEditable':
+    case 'spellCheck':
+    case 'draggable':
+    case 'value':
+    case 'autoReverse':
+    case 'externalResourcesRequired':
+    case 'focusable':
+    case 'preserveAlpha':
+      {
+        // Booleanish String
+        // These are "enumerated" attributes that accept "true" and "false".
+        // In React, we let users pass `true` and `false` even though technically
+        // these aren't boolean attributes (they are coerced to strings).
+        if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'allowFullScreen':
+    case 'async':
+    case 'autoPlay':
+    case 'controls':
+    case 'default':
+    case 'defer':
+    case 'disabled':
+    case 'disablePictureInPicture':
+    case 'disableRemotePlayback':
+    case 'formNoValidate':
+    case 'hidden':
+    case 'loop':
+    case 'noModule':
+    case 'noValidate':
+    case 'open':
+    case 'playsInline':
+    case 'readOnly':
+    case 'required':
+    case 'reversed':
+    case 'scoped':
+    case 'seamless':
+    case 'itemScope':
+      {
+        // Boolean
+        if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        }
+
+        return;
+      }
+
+    case 'capture':
+    case 'download':
+      {
+        // Overloaded Boolean
+        if (value === true) {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        } else if (value === false) ; else if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'cols':
+    case 'rows':
+    case 'size':
+    case 'span':
+      {
+        // These are HTML attributes that must be positive numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value) && value >= 1) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'rowSpan':
+    case 'start':
+      {
+        // These are HTML attributes that must be numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value)) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'xlinkActuate':
+      pushStringAttribute(target, 'xlink:actuate', value);
+      return;
+
+    case 'xlinkArcrole':
+      pushStringAttribute(target, 'xlink:arcrole', value);
+      return;
+
+    case 'xlinkRole':
+      pushStringAttribute(target, 'xlink:role', value);
+      return;
+
+    case 'xlinkShow':
+      pushStringAttribute(target, 'xlink:show', value);
+      return;
+
+    case 'xlinkTitle':
+      pushStringAttribute(target, 'xlink:title', value);
+      return;
+
+    case 'xlinkType':
+      pushStringAttribute(target, 'xlink:type', value);
+      return;
+
+    case 'xmlBase':
+      pushStringAttribute(target, 'xml:base', value);
+      return;
+
+    case 'xmlLang':
+      pushStringAttribute(target, 'xml:lang', value);
+      return;
+
+    case 'xmlSpace':
+      pushStringAttribute(target, 'xml:space', value);
+      return;
+
+    default:
+      if ( // shouldIgnoreAttribute
+      // We have already filtered out null/undefined and reserved words.
+      name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+        return;
+      }
+
+      const attributeName = getAttributeAlias(name);
+
+      if (isAttributeNameSafe(attributeName)) {
+        // shouldRemoveAttribute
+        switch (typeof value) {
+          case 'function':
+          case 'symbol':
+            // eslint-disable-line
+            return;
+
+          case 'boolean':
+            {
+              const prefix = attributeName.toLowerCase().slice(0, 5);
+
+              if (prefix !== 'data-' && prefix !== 'aria-') {
+                return;
+              }
+            }
+        }
+
+        target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+      }
+
+  }
+}
+
+const endOfStartTag = stringToPrecomputedChunk('>');
+const endOfStartTagSelfClosing = stringToPrecomputedChunk('/>');
+
+function pushInnerHTML(target, innerHTML, children) {
+  if (innerHTML != null) {
+    if (children != null) {
+      throw new Error('Can only set one of `children` or `props.dangerouslySetInnerHTML`.');
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw new Error('`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. ' + 'Please visit https://reactjs.org/link/dangerously-set-inner-html ' + 'for more information.');
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+
+      target.push(stringToChunk('' + html));
+    }
+  }
+} // TODO: Move these to RenderState so that we warn for every request.
+
+function pushStartSelect(target, props) {
+
+  target.push(startChunkForTag('select'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          // TODO: This doesn't really make sense for select since it can't use the controlled
+          // value in the innerHTML.
+          innerHTML = propValue;
+          break;
+
+        case 'defaultValue':
+        case 'value':
+          // These are set on the Context instead and applied to the nested options.
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+function flattenOptionChildren(children) {
+  let content = ''; // Flatten children and warn if they aren't strings or numbers;
+  // invalid types are ignored.
+
+  React.Children.forEach(children, function (child) {
+    if (child == null) {
+      return;
+    }
+
+    content += child;
+  });
+  return content;
+}
+
+const selectedMarkerAttribute = stringToPrecomputedChunk(' selected=""');
+
+function pushStartOption(target, props, formatContext) {
+  const selectedValue = formatContext.selectedValue;
+  target.push(startChunkForTag('option'));
+  let children = null;
+  let value = null;
+  let selected = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'selected':
+          // ignore
+          selected = propValue;
+
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+        // We intentionally fallthrough to also set the attribute on the node.
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (selectedValue != null) {
+    let stringValue;
+
+    if (value !== null) {
+
+      stringValue = '' + value;
+    } else {
+
+      stringValue = flattenOptionChildren(children);
+    }
+
+    if (isArray(selectedValue)) {
+      // multiple
+      for (let i = 0; i < selectedValue.length; i++) {
+
+        const v = '' + selectedValue[i];
+
+        if (v === stringValue) {
+          target.push(selectedMarkerAttribute);
+          break;
+        }
+      }
+    } else {
+
+      if ('' + selectedValue === stringValue) {
+        target.push(selectedMarkerAttribute);
+      }
+    }
+  } else if (selected) {
+    target.push(selectedMarkerAttribute);
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const formReplayingRuntimeScript = stringToPrecomputedChunk(formReplaying);
+
+function injectFormReplayingRuntime(resumableState, renderState) {
+  // If we haven't sent it yet, inject the runtime that tracks submitted JS actions
+  // for later replaying by Fiber. If we use an external runtime, we don't need
+  // to emit anything. It's always used.
+  if ((resumableState.instructions & SentFormReplayingRuntime) === NothingSent && (!renderState.externalRuntimeScript)) {
+    resumableState.instructions |= SentFormReplayingRuntime;
+    renderState.bootstrapChunks.unshift(renderState.startInlineScript, formReplayingRuntimeScript, endInlineScript);
+  }
+}
+
+const formStateMarkerIsMatching = stringToPrecomputedChunk('<!--F!-->');
+const formStateMarkerIsNotMatching = stringToPrecomputedChunk('<!--F-->');
+function pushFormStateMarkerIsMatching(target) {
+  target.push(formStateMarkerIsMatching);
+}
+function pushFormStateMarkerIsNotMatching(target) {
+  target.push(formStateMarkerIsNotMatching);
+}
+
+function pushStartForm(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('form'));
+  let children = null;
+  let innerHTML = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'action':
+          formAction = propValue;
+          break;
+
+        case 'encType':
+          formEncType = propValue;
+          break;
+
+        case 'method':
+          formMethod = propValue;
+          break;
+
+        case 'target':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  let formData = null;
+  let formActionName = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+      formActionName = customFields.name;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('action'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'action', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'encType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'method', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'target', formTarget);
+  }
+
+  target.push(endOfStartTag);
+
+  if (formActionName !== null) {
+    target.push(startHiddenInputChunk);
+    pushStringAttribute(target, 'name', formActionName);
+    target.push(endOfStartTagSelfClosing);
+    pushAdditionalFormFields(target, formData);
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushInput(target, props, resumableState, renderState) {
+
+  target.push(startChunkForTag('input'));
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+  let value = null;
+  let defaultValue = null;
+  let checked = null;
+  let defaultChecked = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('input' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        case 'defaultChecked':
+          defaultChecked = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'checked':
+          checked = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+
+  if (checked !== null) {
+    pushBooleanAttribute(target, 'checked', checked);
+  } else if (defaultChecked !== null) {
+    pushBooleanAttribute(target, 'checked', defaultChecked);
+  }
+
+  if (value !== null) {
+    pushAttribute(target, 'value', value);
+  } else if (defaultValue !== null) {
+    pushAttribute(target, 'value', defaultValue);
+  }
+
+  target.push(endOfStartTagSelfClosing); // We place any additional hidden form fields after the input.
+
+  pushAdditionalFormFields(target, formData);
+  return null;
+}
+
+function pushStartButton(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('button'));
+  let children = null;
+  let innerHTML = null;
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+  target.push(endOfStartTag); // We place any additional hidden form fields we need to include inside the button itself.
+
+  pushAdditionalFormFields(target, formData);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartTextArea(target, props) {
+
+  target.push(startChunkForTag('textarea'));
+  let value = null;
+  let defaultValue = null;
+  let children = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          throw new Error('`dangerouslySetInnerHTML` does not make sense on <textarea>.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (value === null && defaultValue !== null) {
+    value = defaultValue;
+  }
+
+  target.push(endOfStartTag); // TODO (yungsters): Remove support for children content in <textarea>.
+
+  if (children != null) {
+
+    if (value != null) {
+      throw new Error('If you supply `defaultValue` on a <textarea>, do not pass children.');
+    }
+
+    if (isArray(children)) {
+      if (children.length > 1) {
+        throw new Error('<textarea> can only have at most one child.');
+      } // TODO: remove the coercion and the DEV check below because it will
+
+      value = '' + children[0];
+    }
+
+    value = '' + children;
+  }
+
+  if (typeof value === 'string' && value[0] === '\n') {
+    // text/html ignores the first character in these tags if it's a newline
+    // Prefer to break application/xml over text/html (for now) by adding
+    // a newline specifically to get eaten by the parser. (Alternately for
+    // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+    // \r is normalized out by HTMLTextAreaElement#value.)
+    // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+    // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+    // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+    // See: Parsing of "textarea" "listing" and "pre" elements
+    //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+    target.push(leadingNewline);
+  } // ToString and push directly instead of recurse over children.
+  // We don't really support complex children in the value anyway.
+  // This also currently avoids a trailing comment node which breaks textarea.
+
+
+  if (value !== null) {
+
+    target.push(stringToChunk(encodeHTMLTextNode('' + value)));
+  }
+
+  return null;
+}
+
+function pushMeta(target, props, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      return pushSelfClosing(target, props, 'meta');
+    } else {
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      if (typeof props.charSet === 'string') {
+        return pushSelfClosing(renderState.charsetChunks, props, 'meta');
+      } else if (props.name === 'viewport') {
+        // "viewport" isn't related to preconnect but it has the right priority
+        return pushSelfClosing(renderState.preconnectChunks, props, 'meta');
+      } else {
+        return pushSelfClosing(renderState.hoistableChunks, props, 'meta');
+      }
+    }
+  }
+}
+
+function pushLink(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const rel = props.rel;
+    const href = props.href;
+    const precedence = props.precedence;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof rel !== 'string' || typeof href !== 'string' || href === '') {
+
+      pushLinkImpl(target, props);
+      return null;
+    }
+
+    if (props.rel === 'stylesheet') {
+      // This <link> may hoistable as a Stylesheet Resource, otherwise it will emit in place
+      const key = getResourceKey(href);
+
+      if (typeof precedence !== 'string' || props.disabled != null || props.onLoad || props.onError) {
+
+        return pushLinkImpl(target, props);
+      } else {
+        // This stylesheet refers to a Resource and we create a new one if necessary
+        let styleQueue = renderState.styles.get(precedence);
+        const hasKey = resumableState.styleResources.hasOwnProperty(key);
+        const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+        if (resourceState !== EXISTS) {
+          // We are going to create this resource now so it is marked as Exists
+          resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+          // to create a StyleQueue
+
+          if (!styleQueue) {
+            styleQueue = {
+              precedence: stringToChunk(escapeTextForBrowser(precedence)),
+              rules: [],
+              hrefs: [],
+              sheets: new Map()
+            };
+            renderState.styles.set(precedence, styleQueue);
+          }
+
+          const resource = {
+            state: PENDING$1,
+            props: stylesheetPropsFromRawProps(props)
+          };
+
+          if (resourceState) {
+            // When resourceState is truty it is a Preload state. We cast it for clarity
+            const preloadState = resourceState;
+
+            if (preloadState.length === 2) {
+              adoptPreloadCredentials(resource.props, preloadState);
+            }
+
+            const preloadResource = renderState.preloads.stylesheets.get(key);
+
+            if (preloadResource && preloadResource.length > 0) {
+              // The Preload for this resource was created in this render pass and has not flushed yet so
+              // we need to clear it to avoid it flushing.
+              preloadResource.length = 0;
+            } else {
+              // Either the preload resource from this render already flushed in this render pass
+              // or the preload flushed in a prior pass (prerender). In either case we need to mark
+              // this resource as already having been preloaded.
+              resource.state = PRELOADED;
+            }
+          } // We add the newly created resource to our StyleQueue and if necessary
+          // track the resource with the currently rendering boundary
+
+
+          styleQueue.sheets.set(key, resource);
+
+          if (renderState.boundaryResources) {
+            renderState.boundaryResources.stylesheets.add(resource);
+          }
+        } else {
+          // We need to track whether this boundary should wait on this resource or not.
+          // Typically this resource should always exist since we either had it or just created
+          // it. However, it's possible when you resume that the style has already been emitted
+          // and then it wouldn't be recreated in the RenderState and there's no need to track
+          // it again since we should've hoisted it to the shell already.
+          if (styleQueue) {
+            const resource = styleQueue.sheets.get(key);
+
+            if (resource) {
+              if (renderState.boundaryResources) {
+                renderState.boundaryResources.stylesheets.add(resource);
+              }
+            }
+          }
+        }
+
+        if (textEmbedded) {
+          // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+          // to be safe and assume text will follow by inserting a textSeparator
+          target.push(textSeparator);
+        }
+
+        return null;
+      }
+    } else if (props.onLoad || props.onError) {
+      // When using load handlers we cannot hoist and need to emit links in place
+      return pushLinkImpl(target, props);
+    } else {
+      // We can hoist this link so we may need to emit a text separator.
+      // @TODO refactor text separators so we don't have to defensively add
+      // them when we don't end up emitting a tag as a result of pushStartInstance
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      switch (props.rel) {
+        case 'preconnect':
+        case 'dns-prefetch':
+          return pushLinkImpl(renderState.preconnectChunks, props);
+
+        case 'preload':
+          return pushLinkImpl(renderState.preloadChunks, props);
+
+        default:
+          return pushLinkImpl(renderState.hoistableChunks, props);
+      }
+    }
+  }
+}
+
+function pushLinkImpl(target, props) {
+  target.push(startChunkForTag('link'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStyle(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+
+  {
+    const precedence = props.precedence;
+    const href = props.href;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof precedence !== 'string' || typeof href !== 'string' || href === '') {
+      // This style tag is not able to be turned into a Style Resource
+      return pushStyleImpl(target, props);
+    }
+
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS;
+
+      if (!styleQueue) {
+        // This is the first time we've encountered this precedence we need
+        // to create a StyleQueue.
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [stringToChunk(escapeTextForBrowser(href))],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      } else {
+        // We have seen this precedence before and need to track this href
+        styleQueue.hrefs.push(stringToChunk(escapeTextForBrowser(href)));
+      }
+
+      pushStyleContents(styleQueue.rules, props);
+    }
+
+    if (styleQueue) {
+      // We need to track whether this boundary should wait on this resource or not.
+      // Typically this resource should always exist since we either had it or just created
+      // it. However, it's possible when you resume that the style has already been emitted
+      // and then it wouldn't be recreated in the RenderState and there's no need to track
+      // it again since we should've hoisted it to the shell already.
+      if (renderState.boundaryResources) {
+        renderState.boundaryResources.styles.add(styleQueue);
+      }
+    }
+
+    if (textEmbedded) {
+      // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+  }
+}
+
+function pushStyleImpl(target, props) {
+  target.push(startChunkForTag('style'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('style'));
+  return null;
+}
+
+function pushStyleContents(target, props) {
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+      }
+    }
+  }
+
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  return;
+}
+
+function pushImg(target, props, resumableState, renderState, pictureTagInScope) {
+  const src = props.src,
+        srcSet = props.srcSet;
+
+  if (props.loading !== 'lazy' && (src || srcSet) && (typeof src === 'string' || src == null) && (typeof srcSet === 'string' || srcSet == null) && props.fetchPriority !== 'low' && pictureTagInScope === false && // We exclude data URIs in src and srcSet since these should not be preloaded
+  !(typeof src === 'string' && src[4] === ':' && (src[0] === 'd' || src[0] === 'D') && (src[1] === 'a' || src[1] === 'A') && (src[2] === 't' || src[2] === 'T') && (src[3] === 'a' || src[3] === 'A')) && !(typeof srcSet === 'string' && srcSet[4] === ':' && (srcSet[0] === 'd' || srcSet[0] === 'D') && (srcSet[1] === 'a' || srcSet[1] === 'A') && (srcSet[2] === 't' || srcSet[2] === 'T') && (srcSet[3] === 'a' || srcSet[3] === 'A'))) {
+    // We have a suspensey image and ought to preload it to optimize the loading of display blocking
+    // resumableState.
+    const sizes = typeof props.sizes === 'string' ? props.sizes : undefined;
+    const key = getImageResourceKey(src, srcSet, sizes);
+    const promotablePreloads = renderState.preloads.images;
+    let resource = promotablePreloads.get(key);
+
+    if (resource) {
+      // We consider whether this preload can be promoted to higher priority flushing queue.
+      // The only time a resource will exist here is if it was created during this render
+      // and was not already in the high priority queue.
+      if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+        // Delete the resource from the map since we are promoting it and don't want to
+        // reenter this branch in a second pass for duplicate img hrefs.
+        promotablePreloads.delete(key); // $FlowFixMe - Flow should understand that this is a Resource if the condition was true
+
+        renderState.highImagePreloads.add(resource);
+      }
+    } else if (!resumableState.imageResources.hasOwnProperty(key)) {
+      // We must construct a new preload resource
+      resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+      const crossOrigin = getCrossOriginString(props.crossOrigin);
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // this is a hueristic similar to capping element preloads to 10 unless explicitly
+      // fetchPriority="high". We use length here which means it will fit fewer images when
+      // the urls are long and more when short. arguably byte size is a better hueristic because
+      // it directly translates to how much we send down before content is actually seen.
+      // We could unify the counts and also make it so the total is tracked regardless of
+      // flushing output but since the headers are likely to be go earlier than content
+      // they don't really conflict so for now I've kept them separate
+      props.fetchPriority === 'high' || headers.highImagePreloads.length < 500) && ( // We manually construct the options for the preload only from strings. We don't want to pollute
+      // the params list with arbitrary props and if we copied everything over as it we might get
+      // coercion errors. We have checks for this in Dev but it seems safer to just only accept values
+      // that are strings
+      header = getPreloadAsHeader(src, 'image', {
+        imageSrcSet: props.srcSet,
+        imageSizes: props.sizes,
+        crossOrigin,
+        integrity: props.integrity,
+        nonce: props.nonce,
+        type: props.type,
+        fetchPriority: props.fetchPriority,
+        referrerPolicy: props.refererPolicy
+      }), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // If we postpone in the shell we will still emit this preload so we track
+        // it to make sure we don't reset it.
+        renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+        if (headers.highImagePreloads) {
+          headers.highImagePreloads += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.highImagePreloads += header;
+      } else {
+        resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preload',
+          as: 'image',
+          // There is a bug in Safari where imageSrcSet is not respected on preload links
+          // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+          // This harms older browers that do not support imageSrcSet by making their preloads not work
+          // but this population is shrinking fast and is already small so we accept this tradeoff.
+          href: srcSet ? undefined : src,
+          imageSrcSet: srcSet,
+          imageSizes: sizes,
+          crossOrigin: crossOrigin,
+          integrity: props.integrity,
+          type: props.type,
+          fetchPriority: props.fetchPriority,
+          referrerPolicy: props.referrerPolicy
+        });
+
+        if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+          renderState.highImagePreloads.add(resource);
+        } else {
+          renderState.bulkPreloads.add(resource); // We can bump the priority up if the same img is rendered later
+          // with fetchPriority="high"
+
+          promotablePreloads.set(key, resource);
+        }
+      }
+    }
+  }
+
+  return pushSelfClosing(target, props, 'img');
+}
+
+function pushSelfClosing(target, props, tag) {
+  target.push(startChunkForTag(tag));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error(tag + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStartMenuItem(target, props) {
+  target.push(startChunkForTag('menuitem'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('menuitems cannot have `children` nor `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  return null;
+}
+
+function pushTitle(target, props, renderState, insertionMode, noscriptTagInScope) {
+
+  {
+    if (insertionMode !== SVG_MODE && !noscriptTagInScope && props.itemProp == null) {
+      pushTitleImpl(renderState.hoistableChunks, props);
+      return null;
+    } else {
+      return pushTitleImpl(target, props);
+    }
+  }
+}
+
+function pushTitleImpl(target, props) {
+  target.push(startChunkForTag('title'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('title'));
+  return null;
+}
+
+function pushStartHead(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode < HTML_MODE && renderState.headChunks === null) {
+      // This <head> is the Document.head and should be part of the preamble
+      renderState.headChunks = [];
+      return pushStartGenericElement(renderState.headChunks, props, 'head');
+    } else {
+      // This <head> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'head');
+    }
+  }
+}
+
+function pushStartHtml(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode === ROOT_HTML_MODE && renderState.htmlChunks === null) {
+      // This <html> is the Document.documentElement and should be part of the preamble
+      renderState.htmlChunks = [doctypeChunk];
+      return pushStartGenericElement(renderState.htmlChunks, props, 'html');
+    } else {
+      // This <html> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'html');
+    }
+  }
+}
+
+function pushScript(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const asyncProp = props.async;
+
+    if (typeof props.src !== 'string' || !props.src || !(asyncProp && typeof asyncProp !== 'function' && typeof asyncProp !== 'symbol') || props.onLoad || props.onError || insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      // This script will not be a resource, we bailout early and emit it in place.
+      return pushScriptImpl(target, props);
+    }
+
+    const src = props.src;
+    const key = getResourceKey(src); // We can make this <script> into a ScriptResource
+
+    let resources, preloads;
+
+    if (props.type === 'module') {
+      resources = resumableState.moduleScriptResources;
+      preloads = renderState.preloads.moduleScripts;
+    } else {
+      resources = resumableState.scriptResources;
+      preloads = renderState.preloads.scripts;
+    }
+
+    const hasKey = resources.hasOwnProperty(key);
+    const resourceState = hasKey ? resources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resources[key] = EXISTS;
+      let scriptProps = props;
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          scriptProps = assign({}, props);
+          adoptPreloadCredentials(scriptProps, preloadState);
+        }
+
+        const preloadResource = preloads.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, scriptProps);
+    }
+
+    if (textEmbedded) {
+      // This script follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+
+    return null;
+  }
+}
+
+function pushScriptImpl(target, props) {
+  target.push(startChunkForTag('script'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+  }
+
+  target.push(endChunkForTag('script'));
+  return null;
+}
+
+function pushStartGenericElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartCustomElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      let propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      let attributeName = propKey;
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'style':
+          pushStyleAttribute(target, propValue);
+          break;
+
+        case 'suppressContentEditableWarning':
+        case 'suppressHydrationWarning':
+          // Ignored. These are built-in to React on the client.
+          break;
+
+        case 'className':
+
+        // intentional fallthrough
+
+        default:
+          if (isAttributeNameSafe(propKey) && typeof propValue !== 'function' && typeof propValue !== 'symbol') {
+
+            target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(propValue)), attributeEnd);
+          }
+
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const leadingNewline = stringToPrecomputedChunk('\n');
+
+function pushStartPreformattedElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag); // text/html ignores the first character in these tags if it's a newline
+  // Prefer to break application/xml over text/html (for now) by adding
+  // a newline specifically to get eaten by the parser. (Alternately for
+  // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+  // \r is normalized out by HTMLTextAreaElement#value.)
+  // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+  // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+  // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+  // See: Parsing of "textarea" "listing" and "pre" elements
+  //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+  // TODO: This doesn't deal with the case where the child is an array
+  // or component that returns a string.
+
+  if (innerHTML != null) {
+    if (children != null) {
+      throw new Error('Can only set one of `children` or `props.dangerouslySetInnerHTML`.');
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw new Error('`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. ' + 'Please visit https://reactjs.org/link/dangerously-set-inner-html ' + 'for more information.');
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+      if (typeof html === 'string' && html.length > 0 && html[0] === '\n') {
+        target.push(leadingNewline, stringToChunk(html));
+      } else {
+
+        target.push(stringToChunk('' + html));
+      }
+    }
+  }
+
+  if (typeof children === 'string' && children[0] === '\n') {
+    target.push(leadingNewline);
+  }
+
+  return children;
+} // We accept any tag to be rendered but since this gets injected into arbitrary
+// HTML, we want to make sure that it's a safe tag.
+// http://www.w3.org/TR/REC-xml/#NT-Name
+
+
+const VALID_TAG_REGEX = /^[a-zA-Z][a-zA-Z:_\.\-\d]*$/; // Simplified subset
+
+const validatedTagCache = new Map();
+
+function startChunkForTag(tag) {
+  let tagStartChunk = validatedTagCache.get(tag);
+
+  if (tagStartChunk === undefined) {
+    if (!VALID_TAG_REGEX.test(tag)) {
+      throw new Error("Invalid tag: " + tag);
+    }
+
+    tagStartChunk = stringToPrecomputedChunk('<' + tag);
+    validatedTagCache.set(tag, tagStartChunk);
+  }
+
+  return tagStartChunk;
+}
+
+const doctypeChunk = stringToPrecomputedChunk('<!DOCTYPE html>');
+function pushStartInstance(target, type, props, resumableState, renderState, formatContext, textEmbedded) {
+
+  switch (type) {
+    case 'div':
+    case 'span':
+    case 'svg':
+    case 'path':
+    case 'a':
+    case 'g':
+    case 'p':
+    case 'li':
+      // Fast track very common tags
+      break;
+    // Special tags
+
+    case 'select':
+      return pushStartSelect(target, props);
+
+    case 'option':
+      return pushStartOption(target, props, formatContext);
+
+    case 'textarea':
+      return pushStartTextArea(target, props);
+
+    case 'input':
+      return pushInput(target, props, resumableState, renderState);
+
+    case 'button':
+      return pushStartButton(target, props, resumableState, renderState);
+
+    case 'form':
+      return pushStartForm(target, props, resumableState, renderState);
+
+    case 'menuitem':
+      return pushStartMenuItem(target, props);
+
+    case 'title':
+      return pushTitle(target, props, renderState, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'link':
+      return pushLink(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'script':
+      return pushScript(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'style':
+      return pushStyle(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'meta':
+      return pushMeta(target, props, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+    // Newline eating tags
+
+    case 'listing':
+    case 'pre':
+      {
+        return pushStartPreformattedElement(target, props, type);
+      }
+
+    case 'img':
+      {
+        return pushImg(target, props, resumableState, renderState, !!(formatContext.tagScope & PICTURE_SCOPE)) ;
+      }
+    // Omitted close tags
+
+    case 'base':
+    case 'area':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'keygen':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        return pushSelfClosing(target, props, type);
+      }
+    // These are reserved SVG and MathML elements, that are never custom elements.
+    // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+
+    case 'annotation-xml':
+    case 'color-profile':
+    case 'font-face':
+    case 'font-face-src':
+    case 'font-face-uri':
+    case 'font-face-format':
+    case 'font-face-name':
+    case 'missing-glyph':
+      {
+        break;
+      }
+    // Preamble start tags
+
+    case 'head':
+      return pushStartHead(target, props, renderState, formatContext.insertionMode);
+
+    case 'html':
+      {
+        return pushStartHtml(target, props, renderState, formatContext.insertionMode);
+      }
+
+    default:
+      {
+        if (type.indexOf('-') !== -1) {
+          // Custom element
+          return pushStartCustomElement(target, props, type);
+        }
+      }
+  } // Generic element
+
+
+  return pushStartGenericElement(target, props, type);
+}
+const endTagCache = new Map();
+
+function endChunkForTag(tag) {
+  let chunk = endTagCache.get(tag);
+
+  if (chunk === undefined) {
+    chunk = stringToPrecomputedChunk('</' + tag + '>');
+    endTagCache.set(tag, chunk);
+  }
+
+  return chunk;
+}
+
+function pushEndInstance(target, type, props, resumableState, formatContext) {
+  switch (type) {
+    // When float is on we expect title and script tags to always be pushed in
+    // a unit and never return children. when we end up pushing the end tag we
+    // want to ensure there is no extra closing tag pushed
+    case 'title':
+    case 'style':
+    case 'script':
+    // Omitted close tags
+    // TODO: Instead of repeating this switch we could try to pass a flag from above.
+    // That would require returning a tuple. Which might be ok if it gets inlined.
+
+    case 'area':
+    case 'base':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'img':
+    case 'input':
+    case 'keygen':
+    case 'link':
+    case 'meta':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        // No close tag needed.
+        return;
+      }
+    // Postamble end tags
+    // When float is enabled we omit the end tags for body and html when
+    // they represent the Document.body and Document.documentElement Nodes.
+    // This is so we can withhold them until the postamble when we know
+    // we won't emit any more tags
+
+    case 'body':
+      {
+        if (formatContext.insertionMode <= HTML_HTML_MODE) {
+          resumableState.hasBody = true;
+          return;
+        }
+
+        break;
+      }
+
+    case 'html':
+      if (formatContext.insertionMode === ROOT_HTML_MODE) {
+        resumableState.hasHtml = true;
+        return;
+      }
+
+      break;
+  }
+
+  target.push(endChunkForTag(type));
+}
+
+function writeBootstrap(destination, renderState, resumableState) {
+  resumableState.bootstrapScriptContent = undefined;
+  resumableState.bootstrapScripts = undefined;
+  resumableState.bootstrapModules = undefined;
+  const bootstrapChunks = renderState.bootstrapChunks;
+  let i = 0;
+
+  for (; i < bootstrapChunks.length - 1; i++) {
+    writeChunk(destination, bootstrapChunks[i]);
+  }
+
+  if (i < bootstrapChunks.length) {
+    const lastChunk = bootstrapChunks[i];
+    bootstrapChunks.length = 0;
+    return writeChunkAndReturn(destination, lastChunk);
+  }
+
+  return true;
+}
+
+function writeCompletedRoot(destination, renderState, resumableState) {
+  return writeBootstrap(destination, renderState, resumableState);
+} // Structural Nodes
+// A placeholder is a node inside a hidden partial tree that can be filled in later, but before
+// display. It's never visible to users. We use the template tag because it can be used in every
+// type of parent. <script> tags also work in every other tag except <colgroup>.
+
+const placeholder1 = stringToPrecomputedChunk('<template id="');
+const placeholder2 = stringToPrecomputedChunk('"></template>');
+function writePlaceholder(destination, renderState, id) {
+  writeChunk(destination, placeholder1);
+  writeChunk(destination, renderState.placeholderPrefix);
+  const formattedID = stringToChunk(id.toString(16));
+  writeChunk(destination, formattedID);
+  return writeChunkAndReturn(destination, placeholder2);
+} // Suspense boundaries are encoded as comments.
+
+const startCompletedSuspenseBoundary = stringToPrecomputedChunk('<!--$-->');
+const startPendingSuspenseBoundary1 = stringToPrecomputedChunk('<!--$?--><template id="');
+const startPendingSuspenseBoundary2 = stringToPrecomputedChunk('"></template>');
+const startClientRenderedSuspenseBoundary = stringToPrecomputedChunk('<!--$!-->');
+const endSuspenseBoundary = stringToPrecomputedChunk('<!--/$-->');
+const clientRenderedSuspenseBoundaryError1 = stringToPrecomputedChunk('<template');
+const clientRenderedSuspenseBoundaryErrorAttrInterstitial = stringToPrecomputedChunk('"');
+const clientRenderedSuspenseBoundaryError1A = stringToPrecomputedChunk(' data-dgst="');
+stringToPrecomputedChunk(' data-msg="');
+stringToPrecomputedChunk(' data-stck="');
+const clientRenderedSuspenseBoundaryError2 = stringToPrecomputedChunk('></template>');
+function writeStartCompletedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, startCompletedSuspenseBoundary);
+}
+function writeStartPendingSuspenseBoundary(destination, renderState, id) {
+  writeChunk(destination, startPendingSuspenseBoundary1);
+
+  if (id === null) {
+    throw new Error('An ID must have been assigned before we can complete the boundary.');
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+  return writeChunkAndReturn(destination, startPendingSuspenseBoundary2);
+}
+function writeStartClientRenderedSuspenseBoundary(destination, renderState, errorDigest, errorMesssage, errorComponentStack) {
+  let result;
+  result = writeChunkAndReturn(destination, startClientRenderedSuspenseBoundary);
+  writeChunk(destination, clientRenderedSuspenseBoundaryError1);
+
+  if (errorDigest) {
+    writeChunk(destination, clientRenderedSuspenseBoundaryError1A);
+    writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest)));
+    writeChunk(destination, clientRenderedSuspenseBoundaryErrorAttrInterstitial);
+  }
+
+  result = writeChunkAndReturn(destination, clientRenderedSuspenseBoundaryError2);
+  return result;
+}
+function writeEndCompletedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndPendingSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndClientRenderedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+const startSegmentHTML = stringToPrecomputedChunk('<div hidden id="');
+const startSegmentHTML2 = stringToPrecomputedChunk('">');
+const endSegmentHTML = stringToPrecomputedChunk('</div>');
+const startSegmentSVG = stringToPrecomputedChunk('<svg aria-hidden="true" style="display:none" id="');
+const startSegmentSVG2 = stringToPrecomputedChunk('">');
+const endSegmentSVG = stringToPrecomputedChunk('</svg>');
+const startSegmentMathML = stringToPrecomputedChunk('<math aria-hidden="true" style="display:none" id="');
+const startSegmentMathML2 = stringToPrecomputedChunk('">');
+const endSegmentMathML = stringToPrecomputedChunk('</math>');
+const startSegmentTable = stringToPrecomputedChunk('<table hidden id="');
+const startSegmentTable2 = stringToPrecomputedChunk('">');
+const endSegmentTable = stringToPrecomputedChunk('</table>');
+const startSegmentTableBody = stringToPrecomputedChunk('<table hidden><tbody id="');
+const startSegmentTableBody2 = stringToPrecomputedChunk('">');
+const endSegmentTableBody = stringToPrecomputedChunk('</tbody></table>');
+const startSegmentTableRow = stringToPrecomputedChunk('<table hidden><tr id="');
+const startSegmentTableRow2 = stringToPrecomputedChunk('">');
+const endSegmentTableRow = stringToPrecomputedChunk('</tr></table>');
+const startSegmentColGroup = stringToPrecomputedChunk('<table hidden><colgroup id="');
+const startSegmentColGroup2 = stringToPrecomputedChunk('">');
+const endSegmentColGroup = stringToPrecomputedChunk('</colgroup></table>');
+function writeStartSegment(destination, renderState, formatContext, id) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        writeChunk(destination, startSegmentHTML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentHTML2);
+      }
+
+    case SVG_MODE:
+      {
+        writeChunk(destination, startSegmentSVG);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentSVG2);
+      }
+
+    case MATHML_MODE:
+      {
+        writeChunk(destination, startSegmentMathML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentMathML2);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        writeChunk(destination, startSegmentTable);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTable2);
+      }
+    // TODO: For the rest of these, there will be extra wrapper nodes that never
+    // get deleted from the document. We need to delete the table too as part
+    // of the injected scripts. They are invisible though so it's not too terrible
+    // and it's kind of an edge case to suspend in a table. Totally supported though.
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        writeChunk(destination, startSegmentTableBody);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableBody2);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        writeChunk(destination, startSegmentTableRow);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableRow2);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        writeChunk(destination, startSegmentColGroup);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentColGroup2);
+      }
+
+    default:
+      {
+        throw new Error('Unknown insertion mode. This is a bug in React.');
+      }
+  }
+}
+function writeEndSegment(destination, formatContext) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentHTML);
+      }
+
+    case SVG_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentSVG);
+      }
+
+    case MATHML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentMathML);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTable);
+      }
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableBody);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableRow);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentColGroup);
+      }
+
+    default:
+      {
+        throw new Error('Unknown insertion mode. This is a bug in React.');
+      }
+  }
+}
+const completeSegmentScript1Full = stringToPrecomputedChunk(completeSegment + '$RS("');
+const completeSegmentScript1Partial = stringToPrecomputedChunk('$RS("');
+const completeSegmentScript2 = stringToPrecomputedChunk('","');
+const completeSegmentScriptEnd = stringToPrecomputedChunk('")</script>');
+const completeSegmentData1 = stringToPrecomputedChunk('<template data-rsi="" data-sid="');
+const completeSegmentData2 = stringToPrecomputedChunk('" data-pid="');
+const completeSegmentDataEnd = dataElementQuotedEnd;
+function writeCompletedSegmentInstruction(destination, resumableState, renderState, contentSegmentID) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentCompleteSegmentFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentCompleteSegmentFunction;
+      writeChunk(destination, completeSegmentScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, completeSegmentScript1Partial);
+    }
+  } else {
+    writeChunk(destination, completeSegmentData1);
+  } // Write function arguments, which are string literals
+
+
+  writeChunk(destination, renderState.segmentPrefix);
+  const formattedID = stringToChunk(contentSegmentID.toString(16));
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    writeChunk(destination, completeSegmentScript2);
+  } else {
+    writeChunk(destination, completeSegmentData2);
+  }
+
+  writeChunk(destination, renderState.placeholderPrefix);
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    return writeChunkAndReturn(destination, completeSegmentScriptEnd);
+  } else {
+    return writeChunkAndReturn(destination, completeSegmentDataEnd);
+  }
+}
+const completeBoundaryScript1Full = stringToPrecomputedChunk(completeBoundary + '$RC("');
+const completeBoundaryScript1Partial = stringToPrecomputedChunk('$RC("');
+const completeBoundaryWithStylesScript1FullBoth = stringToPrecomputedChunk(completeBoundary + completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1FullPartial = stringToPrecomputedChunk(completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1Partial = stringToPrecomputedChunk('$RR("');
+const completeBoundaryScript2 = stringToPrecomputedChunk('","');
+const completeBoundaryScript3a = stringToPrecomputedChunk('",');
+const completeBoundaryScript3b = stringToPrecomputedChunk('"');
+const completeBoundaryScriptEnd = stringToPrecomputedChunk(')</script>');
+const completeBoundaryData1 = stringToPrecomputedChunk('<template data-rci="" data-bid="');
+const completeBoundaryWithStylesData1 = stringToPrecomputedChunk('<template data-rri="" data-bid="');
+const completeBoundaryData2 = stringToPrecomputedChunk('" data-sid="');
+const completeBoundaryData3a = stringToPrecomputedChunk('" data-sty="');
+const completeBoundaryDataEnd = dataElementQuotedEnd;
+function writeCompletedBoundaryInstruction(destination, resumableState, renderState, id, boundaryResources) {
+  let requiresStyleInsertion;
+
+  {
+    requiresStyleInsertion = renderState.stylesToHoist; // If necessary stylesheets will be flushed with this instruction.
+    // Any style tags not yet hoisted in the Document will also be hoisted.
+    // We reset this state since after this instruction executes all styles
+    // up to this point will have been hoisted
+
+    renderState.stylesToHoist = false;
+  }
+
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if (requiresStyleInsertion) {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction | SentCompleteBoundaryFunction;
+        writeChunk(destination, clonePrecomputedChunk(completeBoundaryWithStylesScript1FullBoth));
+      } else if ((resumableState.instructions & SentStyleInsertionFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction;
+        writeChunk(destination, completeBoundaryWithStylesScript1FullPartial);
+      } else {
+        writeChunk(destination, completeBoundaryWithStylesScript1Partial);
+      }
+    } else {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentCompleteBoundaryFunction;
+        writeChunk(destination, completeBoundaryScript1Full);
+      } else {
+        writeChunk(destination, completeBoundaryScript1Partial);
+      }
+    }
+  } else {
+    if (requiresStyleInsertion) {
+      writeChunk(destination, completeBoundaryWithStylesData1);
+    } else {
+      writeChunk(destination, completeBoundaryData1);
+    }
+  }
+
+  const idChunk = stringToChunk(id.toString(16));
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, idChunk); // Write function arguments, which are string and array literals
+
+  if (scriptFormat) {
+    writeChunk(destination, completeBoundaryScript2);
+  } else {
+    writeChunk(destination, completeBoundaryData2);
+  }
+
+  writeChunk(destination, renderState.segmentPrefix);
+  writeChunk(destination, idChunk);
+
+  if (requiresStyleInsertion) {
+    // Script and data writers must format this differently:
+    //  - script writer emits an array literal, whose string elements are
+    //    escaped for javascript  e.g. ["A", "B"]
+    //  - data writer emits a string literal, which is escaped as html
+    //    e.g. [&#34;A&#34;, &#34;B&#34;]
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3a); // boundaryResources encodes an array literal
+
+      writeStyleResourceDependenciesInJS(destination, boundaryResources);
+    } else {
+      writeChunk(destination, completeBoundaryData3a);
+      writeStyleResourceDependenciesInAttr(destination, boundaryResources);
+    }
+  } else {
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3b);
+    }
+  }
+
+  let writeMore;
+
+  if (scriptFormat) {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryScriptEnd);
+  } else {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryDataEnd);
+  }
+
+  return writeBootstrap(destination, renderState, resumableState) && writeMore;
+}
+const clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
+const clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
+const clientRenderScript1A = stringToPrecomputedChunk('"');
+const clientRenderErrorScriptArgInterstitial = stringToPrecomputedChunk(',');
+const clientRenderScriptEnd = stringToPrecomputedChunk(')</script>');
+const clientRenderData1 = stringToPrecomputedChunk('<template data-rxi="" data-bid="');
+const clientRenderData2 = stringToPrecomputedChunk('" data-dgst="');
+const clientRenderData3 = stringToPrecomputedChunk('" data-msg="');
+const clientRenderData4 = stringToPrecomputedChunk('" data-stck="');
+const clientRenderDataEnd = dataElementQuotedEnd;
+function writeClientRenderBoundaryInstruction(destination, resumableState, renderState, id, errorDigest, errorMessage, errorComponentStack) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentClientRenderFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentClientRenderFunction;
+      writeChunk(destination, clientRenderScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, clientRenderScript1Partial);
+    }
+  } else {
+    // <template data-rxi="" data-bid="
+    writeChunk(destination, clientRenderData1);
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+
+  if (scriptFormat) {
+    // " needs to be inserted for scripts, since ArgInterstitual does not contain
+    // leading or trailing quotes
+    writeChunk(destination, clientRenderScript1A);
+  }
+
+  if (errorDigest || errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorDigest || '')));
+    } else {
+      // " data-dgst="HTMLString
+      writeChunk(destination, clientRenderData2);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest || '')));
+    }
+  }
+
+  if (errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorMessage || '')));
+    } else {
+      // " data-msg="HTMLString
+      writeChunk(destination, clientRenderData3);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorMessage || '')));
+    }
+  }
+
+  if (errorComponentStack) {
+    // ,"JSONString"
+    if (scriptFormat) {
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorComponentStack)));
+    } else {
+      // " data-stck="HTMLString
+      writeChunk(destination, clientRenderData4);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorComponentStack)));
+    }
+  }
+
+  if (scriptFormat) {
+    // ></script>
+    return writeChunkAndReturn(destination, clientRenderScriptEnd);
+  } else {
+    // "></template>
+    return writeChunkAndReturn(destination, clientRenderDataEnd);
+  }
+}
+const regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
+
+function escapeJSStringsForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInInstructionScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const regexForJSStringsInScripts = /[&><\u2028\u2029]/g;
+
+function escapeJSObjectForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '&':
+        return '\\u0026';
+
+      case '>':
+        return '\\u003e';
+
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const lateStyleTagResourceOpen1 = stringToPrecomputedChunk('<style media="not all" data-precedence="');
+const lateStyleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const lateStyleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const lateStyleTagTemplateClose = stringToPrecomputedChunk('</style>'); // Tracks whether the boundary currently flushing is flushign style tags or has any
+// stylesheet dependencies not flushed in the Preamble.
+
+let currentlyRenderingBoundaryHasStylesToHoist = false; // Acts as a return value for the forEach execution of style tag flushing.
+
+let destinationHasCapacity = true;
+
+function flushStyleTagsLateForBoundary(styleQueue) {
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs;
+
+  let i = 0;
+
+  if (hrefs.length) {
+    writeChunk(this, lateStyleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    writeChunk(this, lateStyleTagResourceOpen2);
+
+    for (; i < hrefs.length - 1; i++) {
+      writeChunk(this, hrefs[i]);
+      writeChunk(this, spaceSeparator);
+    }
+
+    writeChunk(this, hrefs[i]);
+    writeChunk(this, lateStyleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    destinationHasCapacity = writeChunkAndReturn(this, lateStyleTagTemplateClose); // We wrote style tags for this boundary and we may need to emit a script
+    // to hoist them.
+
+    currentlyRenderingBoundaryHasStylesToHoist = true; // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function hasStylesToHoist(stylesheet) {
+  // We need to reveal boundaries with styles whenever a stylesheet it depends on is either
+  // not flushed or flushed after the preamble (shell).
+  if (stylesheet.state !== PREAMBLE) {
+    currentlyRenderingBoundaryHasStylesToHoist = true;
+    return true;
+  }
+
+  return false;
+}
+
+function writeResourcesForBoundary(destination, boundaryResources, renderState) {
+  // Reset these on each invocation, they are only safe to read in this function
+  currentlyRenderingBoundaryHasStylesToHoist = false;
+  destinationHasCapacity = true; // Flush style tags for each precedence this boundary depends on
+
+  boundaryResources.styles.forEach(flushStyleTagsLateForBoundary, destination); // Determine if this boundary has stylesheets that need to be awaited upon completion
+
+  boundaryResources.stylesheets.forEach(hasStylesToHoist);
+
+  if (currentlyRenderingBoundaryHasStylesToHoist) {
+    renderState.stylesToHoist = true;
+  }
+
+  return destinationHasCapacity;
+}
+
+function flushResource(resource) {
+  for (let i = 0; i < resource.length; i++) {
+    writeChunk(this, resource[i]);
+  }
+
+  resource.length = 0;
+}
+
+const stylesheetFlushingQueue = [];
+
+function flushStyleInPreamble(stylesheet, key, map) {
+  // We still need to encode stylesheet chunks
+  // because unlike most Hoistables and Resources we do not eagerly encode
+  // them during render. This is because if we flush late we have to send a
+  // different encoding and we don't want to encode multiple times
+  pushLinkImpl(stylesheetFlushingQueue, stylesheet.props);
+
+  for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+    writeChunk(this, stylesheetFlushingQueue[i]);
+  }
+
+  stylesheetFlushingQueue.length = 0;
+  stylesheet.state = PREAMBLE;
+}
+
+const styleTagResourceOpen1 = stringToPrecomputedChunk('<style data-precedence="');
+const styleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const spaceSeparator = stringToPrecomputedChunk(' ');
+const styleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const styleTagResourceClose = stringToPrecomputedChunk('</style>');
+
+function flushStylesInPreamble(styleQueue, precedence) {
+  const hasStylesheets = styleQueue.sheets.size > 0;
+  styleQueue.sheets.forEach(flushStyleInPreamble, this);
+  styleQueue.sheets.clear();
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs; // If we don't emit any stylesheets at this precedence we still need to maintain the precedence
+  // order so even if there are no rules for style tags at this precedence we emit an empty style
+  // tag with the data-precedence attribute
+
+  if (!hasStylesheets || hrefs.length) {
+    writeChunk(this, styleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    let i = 0;
+
+    if (hrefs.length) {
+      writeChunk(this, styleTagResourceOpen2);
+
+      for (; i < hrefs.length - 1; i++) {
+        writeChunk(this, hrefs[i]);
+        writeChunk(this, spaceSeparator);
+      }
+
+      writeChunk(this, hrefs[i]);
+    }
+
+    writeChunk(this, styleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    writeChunk(this, styleTagResourceClose); // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function preloadLateStyle(stylesheet) {
+  if (stylesheet.state === PENDING$1) {
+    stylesheet.state = PRELOADED;
+    const preloadProps = preloadAsStylePropsFromProps(stylesheet.props.href, stylesheet.props);
+    pushLinkImpl(stylesheetFlushingQueue, preloadProps);
+
+    for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+      writeChunk(this, stylesheetFlushingQueue[i]);
+    }
+
+    stylesheetFlushingQueue.length = 0;
+  }
+}
+
+function preloadLateStyles(styleQueue) {
+  styleQueue.sheets.forEach(preloadLateStyle, this);
+  styleQueue.sheets.clear();
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+
+function writePreamble(destination, resumableState, renderState, willFlushAllSegments) {
+  // This function must be called exactly once on every request
+  if (!willFlushAllSegments && renderState.externalRuntimeScript) {
+    // If the root segment is incomplete due to suspended tasks
+    // (e.g. willFlushAllSegments = false) and we are using data
+    // streaming format, ensure the external runtime is sent.
+    // (User code could choose to send this even earlier by calling
+    //  preinit(...), if they know they will suspend).
+    const _renderState$external = renderState.externalRuntimeScript,
+          src = _renderState$external.src,
+          chunks = _renderState$external.chunks;
+    internalPreinitScript(resumableState, renderState, src, chunks);
+  }
+
+  const htmlChunks = renderState.htmlChunks;
+  const headChunks = renderState.headChunks;
+  let i = 0; // Emit open tags before Hoistables and Resources
+
+  if (htmlChunks) {
+    // We have an <html> to emit as part of the preamble
+    for (i = 0; i < htmlChunks.length; i++) {
+      writeChunk(destination, htmlChunks[i]);
+    }
+
+    if (headChunks) {
+      for (i = 0; i < headChunks.length; i++) {
+        writeChunk(destination, headChunks[i]);
+      }
+    } else {
+      // We did not render a head but we emitted an <html> so we emit one now
+      writeChunk(destination, startChunkForTag('head'));
+      writeChunk(destination, endOfStartTag);
+    }
+  } else if (headChunks) {
+    // We do not have an <html> but we do have a <head>
+    for (i = 0; i < headChunks.length; i++) {
+      writeChunk(destination, headChunks[i]);
+    }
+  } // Emit high priority Hoistables
+
+
+  const charsetChunks = renderState.charsetChunks;
+
+  for (i = 0; i < charsetChunks.length; i++) {
+    writeChunk(destination, charsetChunks[i]);
+  }
+
+  charsetChunks.length = 0; // emit preconnect resources
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Flush unblocked stylesheets by precedence
+
+  renderState.styles.forEach(flushStylesInPreamble, destination);
+  const importMapChunks = renderState.importMapChunks;
+
+  for (i = 0; i < importMapChunks.length; i++) {
+    writeChunk(destination, importMapChunks[i]);
+  }
+
+  importMapChunks.length = 0;
+  renderState.bootstrapScripts.forEach(flushResource, destination);
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0; // Flush closing head if necessary
+
+  if (htmlChunks && headChunks === null) {
+    // We have an <html> rendered but no <head> rendered. We however inserted
+    // a <head> up above so we need to emit the </head> now. This is safe because
+    // if the main content contained the </head> it would also have provided a
+    // <head>. This means that all the content inside <html> is either <body> or
+    // invalid HTML
+    writeChunk(destination, endChunkForTag('head'));
+  }
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+function writeHoistables(destination, resumableState, renderState) {
+  let i = 0; // Emit high priority Hoistables
+  // We omit charsetChunks because we have already sent the shell and if it wasn't
+  // already sent it is too late now.
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Preload any stylesheets. these will emit in a render instruction that follows this
+  // but we want to kick off preloading as soon as possible
+
+  renderState.styles.forEach(preloadLateStyles, destination); // We only hoist importmaps that are configured through createResponse and that will
+  // always flush in the preamble. Generally we don't expect people to render them as
+  // tags when using React but if you do they are going to be treated like regular inline
+  // scripts and flush after other hoistables which is problematic
+  // bootstrap scripts should flush above script priority but these can only flush in the preamble
+  // so we elide the code here for performance
+
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0;
+}
+function writePostamble(destination, resumableState) {
+  if (resumableState.hasBody) {
+    writeChunk(destination, endChunkForTag('body'));
+  }
+
+  if (resumableState.hasHtml) {
+    writeChunk(destination, endChunkForTag('html'));
+  }
+}
+const arrayFirstOpenBracket = stringToPrecomputedChunk('[');
+const arraySubsequentOpenBracket = stringToPrecomputedChunk(',[');
+const arrayInterstitial = stringToPrecomputedChunk(',');
+const arrayCloseBracket = stringToPrecomputedChunk(']'); // This function writes a 2D array of strings to be embedded in javascript.
+// E.g.
+//  [["JS_escaped_string1", "JS_escaped_string2"]]
+
+function writeStyleResourceDependenciesInJS(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInJS(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInJS(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInJS(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+}
+
+function writeStyleResourceDependencyInJS(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedPrecedence)));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          writeStyleResourceAttributeInJS(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInJS(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeName)));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeValue)));
+} // This function writes a 2D array of strings to be embedded in an attribute
+// value and read with JSON.parse in ReactDOMServerExternalRuntime.js
+// E.g.
+//  [[&quot;JSON_escaped_string1&quot;, &quot;JSON_escaped_string2&quot;]]
+
+
+function writeStyleResourceDependenciesInAttr(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInAttr(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInAttr(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInAttr(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+}
+
+function writeStyleResourceDependencyInAttr(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedPrecedence))));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          writeStyleResourceAttributeInAttr(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInAttr(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeName))));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeValue))));
+}
+/**
+ * Resources
+ */
+
+
+const PENDING$1 = 0;
+const PRELOADED = 1;
+const PREAMBLE = 2;
+const LATE = 3;
+function createBoundaryResources() {
+  return {
+    styles: new Set(),
+    stylesheets: new Set()
+  };
+}
+function setCurrentlyRenderingBoundaryResourcesTarget(renderState, boundaryResources) {
+  renderState.boundaryResources = boundaryResources;
+}
+
+function getResourceKey(href) {
+  return href;
+}
+
+function getImageResourceKey(href, imageSrcSet, imageSizes) {
+  if (imageSrcSet) {
+    return imageSrcSet + '\n' + (imageSizes || '');
+  }
+
+  return href;
+}
+
+function prefetchDNS(href) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const key = getResourceKey(href);
+
+    if (!resumableState.dnsResources.hasOwnProperty(key)) {
+      resumableState.dnsResources[key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPrefetchDNSAsHeader(href), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this as resettable in case we are prerendering and postpone in the Shell
+        renderState.resets.dns[key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        // Encode as element
+        const resource = [];
+        pushLinkImpl(resource, {
+          href,
+          rel: 'dns-prefetch'
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preconnect(href, crossOrigin) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const bucket = crossOrigin === 'use-credentials' ? 'credentials' : typeof crossOrigin === 'string' ? 'anonymous' : 'default';
+    const key = getResourceKey(href);
+
+    if (!resumableState.connectResources[bucket].hasOwnProperty(key)) {
+      resumableState.connectResources[bucket][key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPreconnectAsHeader(href, crossOrigin), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this in resettableState in case we are prerending and postpone in the Shell
+        renderState.resets.connect[bucket][key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        const resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preconnect',
+          href,
+          crossOrigin
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preload(href, as, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (as && href) {
+    switch (as) {
+      case 'image':
+        {
+          let imageSrcSet, imageSizes, fetchPriority;
+
+          if (options) {
+            imageSrcSet = options.imageSrcSet;
+            imageSizes = options.imageSizes;
+            fetchPriority = options.fetchPriority;
+          }
+
+          const key = getImageResourceKey(href, imageSrcSet, imageSizes);
+
+          if (resumableState.imageResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && fetchPriority === 'high' && ( // Compute the header since we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit a preload as a header so we
+            // track this to make sure we don't reset it.
+            renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+            if (headers.highImagePreloads) {
+              headers.highImagePreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.highImagePreloads += header;
+          } else {
+            // If we don't have headers to write to we have to encode as elements to flush in the head
+            // When we have imageSrcSet the browser probably cannot load the right version from headers
+            // (this should be verified by testing). For now we assume these need to go in the head
+            // as elements even if headers are available.
+            const resource = [];
+            pushLinkImpl(resource, assign({
+              rel: 'preload',
+              // There is a bug in Safari where imageSrcSet is not respected on preload links
+              // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+              // This harms older browers that do not support imageSrcSet by making their preloads not work
+              // but this population is shrinking fast and is already small so we accept this tradeoff.
+              href: imageSrcSet ? undefined : href,
+              as
+            }, options));
+
+            if (fetchPriority === 'high') {
+              renderState.highImagePreloads.add(resource);
+            } else {
+              renderState.bulkPreloads.add(resource); // Stash the resource in case we need to promote it to higher priority
+              // when an img tag is rendered
+
+              renderState.preloads.images.set(key, resource);
+            }
+          }
+
+          break;
+        }
+
+      case 'style':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.styleResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.styleResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.stylesheets.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          break;
+        }
+
+      case 'script':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.scriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          renderState.preloads.scripts.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.scriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          break;
+        }
+
+      default:
+        {
+          const key = getResourceKey(href);
+          const hasAsType = resumableState.unknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.unknownResources[as] = resources;
+          }
+
+          resources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && as === 'font' && ( // We compute the header here because we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit this preload so we
+            // track it here to prevent it from being reset.
+            renderState.resets.font[key] = PRELOAD_NO_CREDS;
+
+            if (headers.fontPreloads) {
+              headers.fontPreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.fontPreloads += header;
+          } else {
+            // We either don't have headers or we are preloading something that does
+            // not warrant elevated priority so we encode as an element.
+            const resource = [];
+
+            const props = assign({
+              rel: 'preload',
+              href,
+              as
+            }, options);
+
+            pushLinkImpl(resource, props);
+
+            switch (as) {
+              case 'font':
+                renderState.fontPreloads.add(resource);
+                break;
+              // intentional fall through
+
+              default:
+                renderState.bulkPreloads.add(resource);
+            }
+          }
+        }
+    } // If we got this far we created a new resource
+
+
+    flushResources(request);
+  }
+}
+
+function preloadModule(href, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    const key = getResourceKey(href);
+    const as = options && typeof options.as === 'string' ? options.as : 'script';
+    let resource;
+
+    switch (as) {
+      case 'script':
+        {
+          if (resumableState.moduleScriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resource = [];
+          resumableState.moduleScriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.moduleScripts.set(key, resource);
+          break;
+        }
+
+      default:
+        {
+          const hasAsType = resumableState.moduleUnknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.moduleUnknownResources[as] = resources;
+          }
+
+          resource = [];
+          resources[key] = PRELOAD_NO_CREDS;
+        }
+    }
+
+    pushLinkImpl(resource, assign({
+      rel: 'modulepreload',
+      href
+    }, options));
+    renderState.bulkPreloads.add(resource); // If we got this far we created a new resource
+
+    flushResources(request);
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    precedence = precedence || 'default';
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+      // to create a StyleQueue
+
+      if (!styleQueue) {
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      }
+
+      const resource = {
+        state: PENDING$1,
+        props: assign({
+          rel: 'stylesheet',
+          href,
+          'data-precedence': precedence
+        }, options)
+      };
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(resource.props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.stylesheets.get(key);
+
+        if (preloadResource && preloadResource.length > 0) {
+          // The Preload for this resource was created in this render pass and has not flushed yet so
+          // we need to clear it to avoid it flushing.
+          preloadResource.length = 0;
+        } else {
+          // Either the preload resource from this render already flushed in this render pass
+          // or the preload flushed in a prior pass (prerender). In either case we need to mark
+          // this resource as already having been preloaded.
+          resource.state = PRELOADED;
+        }
+      } // We add the newly created resource to our StyleQueue and if necessary
+      // track the resource with the currently rendering boundary
+
+
+      styleQueue.sheets.set(key, resource); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+  }
+}
+
+function preinitScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.scriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.scriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.scriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.scripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+}
+
+function preinitModuleScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.moduleScriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.moduleScriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.moduleScriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        type: 'module',
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.moduleScripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+} // This function is only safe to call at Request start time since it assumes
+// that each module has not already been preloaded. If we find a need to preload
+// scripts at any other point in time we will need to check whether the preload
+// already exists and not assume it
+
+
+function preloadBootstrapScriptOrModule(resumableState, renderState, href, props) {
+
+  const key = getResourceKey(href);
+  // used to preinit the resource. If a script can be preinited then it shouldn't
+  // be a bootstrap script/module and if it is a bootstrap script/module then it
+  // must not be safe to emit early. To avoid possibly allowing for preinits of
+  // bootstrap scripts/modules we occlude these keys.
+
+
+  resumableState.scriptResources[key] = EXISTS;
+  resumableState.moduleScriptResources[key] = EXISTS;
+  const resource = [];
+  pushLinkImpl(resource, props);
+  renderState.bootstrapScripts.add(resource);
+}
+
+function internalPreinitScript(resumableState, renderState, src, chunks) {
+  const key = getResourceKey(src);
+
+  if (!resumableState.scriptResources.hasOwnProperty(key)) {
+    const resource = chunks;
+    resumableState.scriptResources[key] = EXISTS;
+    renderState.scripts.add(resource);
+  }
+
+  return;
+}
+
+function preloadAsStylePropsFromProps(href, props) {
+  return {
+    rel: 'preload',
+    as: 'style',
+    href: href,
+    crossOrigin: props.crossOrigin,
+    fetchPriority: props.fetchPriority,
+    integrity: props.integrity,
+    media: props.media,
+    hrefLang: props.hrefLang,
+    referrerPolicy: props.referrerPolicy
+  };
+}
+
+function stylesheetPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    'data-precedence': rawProps.precedence,
+    precedence: null
+  });
+}
+
+function adoptPreloadCredentials(target, preloadState) {
+  if (target.crossOrigin == null) target.crossOrigin = preloadState[0];
+  if (target.integrity == null) target.integrity = preloadState[1];
+}
+
+function getPrefetchDNSAsHeader(href) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  return "<" + escapedHref + ">; rel=dns-prefetch";
+}
+
+function getPreconnectAsHeader(href, crossOrigin) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  let value = "<" + escapedHref + ">; rel=preconnect";
+
+  if (typeof crossOrigin === 'string') {
+    const escapedCrossOrigin = escapeStringForLinkHeaderQuotedParamValueContext(crossOrigin);
+    value += "; crossorigin=\"" + escapedCrossOrigin + "\"";
+  }
+
+  return value;
+}
+
+function getPreloadAsHeader(href, as, params) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  const escapedAs = escapeStringForLinkHeaderQuotedParamValueContext(as);
+  let value = "<" + escapedHref + ">; rel=preload; as=\"" + escapedAs + "\"";
+
+  for (const paramName in params) {
+    if (hasOwnProperty.call(params, paramName)) {
+      const paramValue = params[paramName];
+
+      if (typeof paramValue === 'string') {
+        value += "; " + paramName.toLowerCase() + "=\"" + escapeStringForLinkHeaderQuotedParamValueContext(paramValue) + "\"";
+      }
+    }
+  }
+
+  return value;
+}
+
+function getStylesheetPreloadAsHeader(stylesheet) {
+  const props = stylesheet.props;
+  const preloadOptions = {
+    crossOrigin: props.crossOrigin,
+    integrity: props.integrity,
+    nonce: props.nonce,
+    type: props.type,
+    fetchPriority: props.fetchPriority,
+    referrerPolicy: props.referrerPolicy,
+    media: props.media
+  };
+  return getPreloadAsHeader(props.href, 'style', preloadOptions);
+} // This escaping function is only safe to use for href values being written into
+// a "Link" header in between `<` and `>` characters. The primary concern with the href is
+// to escape the bounding characters as well as new lines. This is unsafe to use in any other
+// context
+
+
+const regexForHrefInLinkHeaderURLContext = /[<>\r\n]/g;
+
+function escapeHrefForLinkHeaderURLContext(hrefInput) {
+
+  const coercedHref = '' + hrefInput;
+  return coercedHref.replace(regexForHrefInLinkHeaderURLContext, escapeHrefForLinkHeaderURLContextReplacer);
+}
+
+function escapeHrefForLinkHeaderURLContextReplacer(match) {
+  switch (match) {
+    case '<':
+      return '%3C';
+
+    case '>':
+      return '%3E';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeLinkHrefForHeaderContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+} // This escaping function is only safe to use for quoted param values in an HTTP header.
+// It is unsafe to use for any value not inside quote marks in parater value position.
+
+
+const regexForLinkHeaderQuotedParamValueContext = /["';,\r\n]/g;
+
+function escapeStringForLinkHeaderQuotedParamValueContext(value, name) {
+
+  const coerced = '' + value;
+  return coerced.replace(regexForLinkHeaderQuotedParamValueContext, escapeStringForLinkHeaderQuotedParamValueContextReplacer);
+}
+
+function escapeStringForLinkHeaderQuotedParamValueContextReplacer(match) {
+  switch (match) {
+    case '"':
+      return '%22';
+
+    case "'":
+      return '%27';
+
+    case ';':
+      return '%3B';
+
+    case ',':
+      return '%2C';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeStringForLinkHeaderQuotedParamValueContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+}
+
+function hoistStyleQueueDependency(styleQueue) {
+  this.styles.add(styleQueue);
+}
+
+function hoistStylesheetDependency(stylesheet) {
+  this.stylesheets.add(stylesheet);
+}
+
+function hoistResources(renderState, source) {
+  const currentBoundaryResources = renderState.boundaryResources;
+
+  if (currentBoundaryResources) {
+    source.styles.forEach(hoistStyleQueueDependency, currentBoundaryResources);
+    source.stylesheets.forEach(hoistStylesheetDependency, currentBoundaryResources);
+  }
+} // This function is called at various times depending on whether we are rendering
+// or prerendering. In this implementation we only actually emit headers once and
+// subsequent calls are ignored. We track whether the request has a completed shell
+// to determine whether we will follow headers with a flush including stylesheets.
+// In the context of prerrender we don't have a completed shell when the request finishes
+// with a postpone in the shell. In the context of a render we don't have a completed shell
+// if this is called before the shell finishes rendering which usually will happen anytime
+// anything suspends in the shell.
+
+function emitEarlyPreloads(renderState, resumableState, shellComplete) {
+  const onHeaders = renderState.onHeaders;
+
+  if (onHeaders) {
+    const headers = renderState.headers;
+
+    if (headers) {
+      let linkHeader = headers.preconnects;
+
+      if (headers.fontPreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.fontPreloads;
+      }
+
+      if (headers.highImagePreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.highImagePreloads;
+      }
+
+      if (!shellComplete) {
+        // We use raw iterators because we want to be able to halt iteration
+        // We could refactor renderState to store these dually in arrays to
+        // make this more efficient at the cost of additional memory and
+        // write overhead. However this code only runs once per request so
+        // for now I consider this sufficient.
+        const queueIter = renderState.styles.values();
+
+        outer: for (let queueStep = queueIter.next(); headers.remainingCapacity > 0 && !queueStep.done; queueStep = queueIter.next()) {
+          const sheets = queueStep.value.sheets;
+          const sheetIter = sheets.values();
+
+          for (let sheetStep = sheetIter.next(); headers.remainingCapacity > 0 && !sheetStep.done; sheetStep = sheetIter.next()) {
+            const sheet = sheetStep.value;
+            const props = sheet.props;
+            const key = getResourceKey(props.href);
+            const header = getStylesheetPreloadAsHeader(sheet); // We mutate the capacity b/c we don't want to keep checking if later headers will fit.
+            // This means that a particularly long header might close out the header queue where later
+            // headers could still fit. We could in the future alter the behavior here based on prerender vs render
+            // since during prerender we aren't as concerned with pure runtime performance.
+
+            if ((headers.remainingCapacity -= header.length) >= 2) {
+              renderState.resets.style[key] = PRELOAD_NO_CREDS;
+
+              if (linkHeader) {
+                linkHeader += ', ';
+              }
+
+              linkHeader += header; // We already track that the resource exists in resumableState however
+              // if the resumableState resets because we postponed in the shell
+              // which is what is happening in this branch if we are prerendering
+              // then we will end up resetting the resumableState. When it resets we
+              // want to record the fact that this stylesheet was already preloaded
+
+              renderState.resets.style[key] = typeof props.crossOrigin === 'string' || typeof props.integrity === 'string' ? [props.crossOrigin, props.integrity] : PRELOAD_NO_CREDS;
+            } else {
+              break outer;
+            }
+          }
+        }
+      }
+
+      if (linkHeader) {
+        onHeaders({
+          Link: linkHeader
+        });
+      } else {
+        // We still call this with no headers because a user may be using it as a signal that
+        // it React will not provide any headers
+        onHeaders({});
+      }
+
+      renderState.headers = null;
+      return;
+    }
+  }
+}
+const NotPendingTransition = NotPending;
+
+const supportsRequestStorage = typeof AsyncLocalStorage === 'function';
+const requestStorage = supportsRequestStorage ? new AsyncLocalStorage() : null;
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+const REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_CONTEXT_TYPE = Symbol.for('react.context');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SCOPE_TYPE = Symbol.for('react.scope');
+const REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');
+const REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+const REACT_LEGACY_HIDDEN_TYPE = Symbol.for('react.legacy_hidden');
+const REACT_CACHE_TYPE = Symbol.for('react.cache');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+function getWrappedName(outerType, innerType, wrapperName) {
+  const displayName = outerType.displayName;
+
+  if (displayName) {
+    return displayName;
+  }
+
+  const functionName = innerType.displayName || innerType.name || '';
+  return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
+} // Keep in sync with react-reconciler/getComponentNameFromFiber
+
+
+function getContextName(type) {
+  return type.displayName || 'Context';
+} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+
+function getComponentNameFromType(type) {
+  if (type == null) {
+    // Host root, text node or just invalid type.
+    return null;
+  }
+
+  if (typeof type === 'function') {
+    return type.displayName || type.name || null;
+  }
+
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_FRAGMENT_TYPE:
+      return 'Fragment';
+
+    case REACT_PORTAL_TYPE:
+      return 'Portal';
+
+    case REACT_PROFILER_TYPE:
+      return 'Profiler';
+
+    case REACT_STRICT_MODE_TYPE:
+      return 'StrictMode';
+
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+
+    case REACT_CACHE_TYPE:
+      {
+        return 'Cache';
+      }
+
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        const context = type;
+        return getContextName(context) + '.Consumer';
+
+      case REACT_PROVIDER_TYPE:
+        const provider = type;
+        return getContextName(provider._context) + '.Provider';
+
+      case REACT_FORWARD_REF_TYPE:
+        return getWrappedName(type, type.render, 'ForwardRef');
+
+      case REACT_MEMO_TYPE:
+        const outerName = type.displayName || null;
+
+        if (outerName !== null) {
+          return outerName;
+        }
+
+        return getComponentNameFromType(type.type) || 'Memo';
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            return getComponentNameFromType(init(payload));
+          } catch (x) {
+            return null;
+          }
+        }
+
+    }
+  }
+
+  return null;
+}
+
+const emptyContextObject = {};
+
+function getMaskedContext(type, unmaskedContext) {
+  {
+    const contextTypes = type.contextTypes;
+
+    if (!contextTypes) {
+      return emptyContextObject;
+    }
+
+    const context = {};
+
+    for (const key in contextTypes) {
+      context[key] = unmaskedContext[key];
+    }
+
+    return context;
+  }
+}
+function processChildContext(instance, type, parentContext, childContextTypes) {
+  {
+    // TODO (bvaughn) Replace this behavior with an invariant() in the future.
+    // It has only been added in Fiber to match the (unintentional) behavior in Stack.
+    if (typeof instance.getChildContext !== 'function') {
+
+      return parentContext;
+    }
+
+    const childContext = instance.getChildContext();
+
+    for (const contextKey in childContext) {
+      if (!(contextKey in childContextTypes)) {
+        throw new Error((getComponentNameFromType(type) || 'Unknown') + ".getChildContext(): key \"" + contextKey + "\" is not defined in childContextTypes.");
+      }
+    }
+
+    return assign({}, parentContext, childContext);
+  }
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext);
+    } // On the way back, we push the new ones that weren't common.
+
+
+    pushNode(next);
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function pushProvider(context, nextValue) {
+  let prevValue;
+
+  {
+    prevValue = context._currentValue;
+    context._currentValue = nextValue;
+  }
+
+  const prevNode = currentActiveSnapshot;
+  const newNode = {
+    parent: prevNode,
+    depth: prevNode === null ? 0 : prevNode.depth + 1,
+    context: context,
+    parentValue: prevValue,
+    value: nextValue
+  };
+  currentActiveSnapshot = newNode;
+  return newNode;
+}
+function popProvider(context) {
+  const prevSnapshot = currentActiveSnapshot;
+
+  if (prevSnapshot === null) {
+    throw new Error('Tried to pop a Context at the root of the app. This is a bug in React.');
+  }
+
+  {
+    const value = prevSnapshot.parentValue;
+
+    if (value === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      prevSnapshot.context._currentValue = prevSnapshot.context._defaultValue;
+    } else {
+      prevSnapshot.context._currentValue = value;
+    }
+  }
+
+  return currentActiveSnapshot = prevSnapshot.parent;
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+/**
+ * `ReactInstanceMap` maintains a mapping from a public facing stateful
+ * instance (key) and the internal representation (value). This allows public
+ * methods to accept the user facing instance as an argument and map them back
+ * to internal methods.
+ *
+ * Note that this module is currently shared and assumed to be stateless.
+ * If this becomes an actual Map, that will break.
+ */
+function get(key) {
+  return key._reactInternals;
+}
+function set(key, value) {
+  key._reactInternals = value;
+}
+
+const classComponentUpdater = {
+  isMounted(inst) {
+    return false;
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueSetState(inst, payload, callback) {
+    const internals = get(inst);
+
+    if (internals.queue === null) ; else {
+      internals.queue.push(payload);
+    }
+  },
+
+  enqueueReplaceState(inst, payload, callback) {
+    const internals = get(inst);
+    internals.replace = true;
+    internals.queue = [payload];
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueForceUpdate(inst, callback) {
+  }
+
+};
+
+function applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, prevState, nextProps) {
+  const partialState = getDerivedStateFromProps(nextProps, prevState);
+
+
+  const newState = partialState === null || partialState === undefined ? prevState : assign({}, prevState, partialState);
+  return newState;
+}
+
+function constructClassInstance(ctor, props, maskedLegacyContext) {
+  let context = emptyContextObject;
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    context = readContext$1(contextType);
+  } else {
+    context = maskedLegacyContext;
+  }
+
+  const instance = new ctor(props, context);
+
+  return instance;
+}
+
+function callComponentWillMount(type, instance) {
+  const oldState = instance.state;
+
+  if (typeof instance.componentWillMount === 'function') {
+
+    instance.componentWillMount();
+  }
+
+  if (typeof instance.UNSAFE_componentWillMount === 'function') {
+    instance.UNSAFE_componentWillMount();
+  }
+
+  if (oldState !== instance.state) {
+
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+}
+
+function processUpdateQueue(internalInstance, inst, props, maskedLegacyContext) {
+  if (internalInstance.queue !== null && internalInstance.queue.length > 0) {
+    const oldQueue = internalInstance.queue;
+    const oldReplace = internalInstance.replace;
+    internalInstance.queue = null;
+    internalInstance.replace = false;
+
+    if (oldReplace && oldQueue.length === 1) {
+      inst.state = oldQueue[0];
+    } else {
+      let nextState = oldReplace ? oldQueue[0] : inst.state;
+      let dontMutate = true;
+
+      for (let i = oldReplace ? 1 : 0; i < oldQueue.length; i++) {
+        const partial = oldQueue[i];
+        const partialState = typeof partial === 'function' ? partial.call(inst, nextState, props, maskedLegacyContext) : partial;
+
+        if (partialState != null) {
+          if (dontMutate) {
+            dontMutate = false;
+            nextState = assign({}, nextState, partialState);
+          } else {
+            assign(nextState, partialState);
+          }
+        }
+      }
+
+      inst.state = nextState;
+    }
+  } else {
+    internalInstance.queue = null;
+  }
+} // Invokes the mount life-cycles on a previously never rendered instance.
+
+
+function mountClassInstance(instance, ctor, newProps, maskedLegacyContext) {
+
+  const initialState = instance.state !== undefined ? instance.state : null;
+  instance.updater = classComponentUpdater;
+  instance.props = newProps;
+  instance.state = initialState; // We don't bother initializing the refs object on the server, since we're not going to resolve them anyway.
+  // The internal instance will be used to manage updates that happen during this mount.
+
+  const internalInstance = {
+    queue: [],
+    replace: false
+  };
+  set(instance, internalInstance);
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    instance.context = readContext$1(contextType);
+  } else {
+    instance.context = maskedLegacyContext;
+  }
+
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    instance.state = applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, initialState, newProps);
+  } // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+
+  if (typeof ctor.getDerivedStateFromProps !== 'function' && typeof instance.getSnapshotBeforeUpdate !== 'function' && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
+    callComponentWillMount(ctor, instance); // If we had additional state updates during this life-cycle, let's
+    // process them now.
+
+    processUpdateQueue(internalInstance, instance, newProps, maskedLegacyContext);
+  }
+}
+
+// Ids are base 32 strings whose binary representation corresponds to the
+// position of a node in a tree.
+// Every time the tree forks into multiple children, we add additional bits to
+// the left of the sequence that represent the position of the child within the
+// current level of children.
+//
+//      00101       00010001011010101
+//      ╰─┬─╯       ╰───────┬───────╯
+//   Fork 5 of 20       Parent id
+//
+// The leading 0s are important. In the above example, you only need 3 bits to
+// represent slot 5. However, you need 5 bits to represent all the forks at
+// the current level, so we must account for the empty bits at the end.
+//
+// For this same reason, slots are 1-indexed instead of 0-indexed. Otherwise,
+// the zeroth id at a level would be indistinguishable from its parent.
+//
+// If a node has only one child, and does not materialize an id (i.e. does not
+// contain a useId hook), then we don't need to allocate any space in the
+// sequence. It's treated as a transparent indirection. For example, these two
+// trees produce the same ids:
+//
+// <>                          <>
+//   <Indirection>               <A />
+//     <A />                     <B />
+//   </Indirection>            </>
+//   <B />
+// </>
+//
+// However, we cannot skip any node that materializes an id. Otherwise, a parent
+// id that does not fork would be indistinguishable from its child id. For
+// example, this tree does not fork, but the parent and child must have
+// different ids.
+//
+// <Parent>
+//   <Child />
+// </Parent>
+//
+// To handle this scenario, every time we materialize an id, we allocate a
+// new level with a single slot. You can think of this as a fork with only one
+// prong, or an array of children with length 1.
+//
+// It's possible for the size of the sequence to exceed 32 bits, the max
+// size for bitwise operations. When this happens, we make more room by
+// converting the right part of the id to a string and storing it in an overflow
+// variable. We use a base 32 string representation, because 32 is the largest
+// power of 2 that is supported by toString(). We want the base to be large so
+// that the resulting ids are compact, and we want the base to be a power of 2
+// because every log2(base) bits corresponds to a single character, i.e. every
+// log2(32) = 5 bits. That means we can lop bits off the end 5 at a time without
+// affecting the final result.
+const emptyTreeContext = {
+  id: 1,
+  overflow: ''
+};
+function getTreeId(context) {
+  const overflow = context.overflow;
+  const idWithLeadingBit = context.id;
+  const id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
+  return id.toString(32) + overflow;
+}
+function pushTreeContext(baseContext, totalChildren, index) {
+  const baseIdWithLeadingBit = baseContext.id;
+  const baseOverflow = baseContext.overflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
+  // of the id; we use it to account for leading 0s.
+
+  const baseLength = getBitLength(baseIdWithLeadingBit) - 1;
+  const baseId = baseIdWithLeadingBit & ~(1 << baseLength);
+  const slot = index + 1;
+  const length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
+  // consideration the leading 1 we use to mark the end of the sequence.
+
+  if (length > 30) {
+    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
+    // This branch assumes the length of the base id is greater than 5; it won't
+    // work for smaller ids, because you need 5 bits per character.
+    //
+    // We encode the id in multiple steps: first the base id, then the
+    // remaining digits.
+    //
+    // Each 5 bit sequence corresponds to a single base 32 character. So for
+    // example, if the current id is 23 bits long, we can convert 20 of those
+    // bits into a string of 4 characters, with 3 bits left over.
+    //
+    // First calculate how many bits in the base id represent a complete
+    // sequence of characters.
+    const numberOfOverflowBits = baseLength - baseLength % 5; // Then create a bitmask that selects only those bits.
+
+    const newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
+
+    const newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
+
+    const restOfBaseId = baseId >> numberOfOverflowBits;
+    const restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
+    // we made more room, this time it won't overflow.
+
+    const restOfLength = getBitLength(totalChildren) + restOfBaseLength;
+    const restOfNewBits = slot << restOfBaseLength;
+    const id = restOfNewBits | restOfBaseId;
+    const overflow = newOverflow + baseOverflow;
+    return {
+      id: 1 << restOfLength | id,
+      overflow
+    };
+  } else {
+    // Normal path
+    const newBits = slot << baseLength;
+    const id = newBits | baseId;
+    const overflow = baseOverflow;
+    return {
+      id: 1 << length | id,
+      overflow
+    };
+  }
+}
+
+function getBitLength(number) {
+  return 32 - clz32(number);
+}
+
+function getLeadingBit(id) {
+  return 1 << getBitLength(id) - 1;
+} // TODO: Math.clz32 is supported in Node 12+. Maybe we can drop the fallback.
+
+
+const 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
+
+const log = Math.log;
+const LN2 = Math.LN2;
+
+function clz32Fallback(x) {
+  const asUint = x >>> 0;
+
+  if (asUint === 0) {
+    return 32;
+  }
+
+  return 31 - (log(asUint) / LN2 | 0) | 0;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFlightWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop$2() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop$2, noop$2);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+
+const objectIs = // $FlowFixMe[method-unbinding]
+typeof Object.is === 'function' ? Object.is : is;
+
+let currentlyRenderingComponent = null;
+let currentlyRenderingTask = null;
+let currentlyRenderingRequest = null;
+let currentlyRenderingKeyPath = null;
+let firstWorkInProgressHook = null;
+let workInProgressHook = null; // Whether the work-in-progress hook is a re-rendered hook
+
+let isReRender = false; // Whether an update was scheduled during the currently executing render pass.
+
+let didScheduleRenderPhaseUpdate = false; // Counts the number of useId hooks in this component
+
+let localIdCounter = 0; // Chunks that should be pushed to the stream once the component
+// finishes rendering.
+// Counts the number of useFormState calls in this component
+
+let formStateCounter = 0; // The index of the useFormState hook that matches the one passed in at the
+// root during an MPA navigation, if any.
+
+let formStateMatchingIndex = -1; // Counts the number of use(thenable) calls in this component
+
+let thenableIndexCounter = 0;
+let thenableState = null; // Lazily created map of render-phase updates
+
+let renderPhaseUpdates = null; // Counter to prevent infinite loops.
+
+let numberOfReRenders = 0;
+const RE_RENDER_LIMIT = 25;
+
+function resolveCurrentlyRenderingComponent() {
+  if (currentlyRenderingComponent === null) {
+    throw new Error('Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for' + ' one of the following reasons:\n' + '1. You might have mismatching versions of React and the renderer (such as React DOM)\n' + '2. You might be breaking the Rules of Hooks\n' + '3. You might have more than one copy of React in the same app\n' + 'See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.');
+  }
+
+  return currentlyRenderingComponent;
+}
+
+function areHookInputsEqual(nextDeps, prevDeps) {
+  if (prevDeps === null) {
+
+    return false;
+  }
+
+
+  for (let i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    if (objectIs(nextDeps[i], prevDeps[i])) {
+      continue;
+    }
+
+    return false;
+  }
+
+  return true;
+}
+
+function createHook() {
+  if (numberOfReRenders > 0) {
+    throw new Error('Rendered more hooks than during the previous render');
+  }
+
+  return {
+    memoizedState: null,
+    queue: null,
+    next: null
+  };
+}
+
+function createWorkInProgressHook() {
+  if (workInProgressHook === null) {
+    // This is the first hook in the list
+    if (firstWorkInProgressHook === null) {
+      isReRender = false;
+      firstWorkInProgressHook = workInProgressHook = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = firstWorkInProgressHook;
+    }
+  } else {
+    if (workInProgressHook.next === null) {
+      isReRender = false; // Append to the end of the list
+
+      workInProgressHook = workInProgressHook.next = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = workInProgressHook.next;
+    }
+  }
+
+  return workInProgressHook;
+}
+
+function prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState) {
+  currentlyRenderingComponent = componentIdentity;
+  currentlyRenderingTask = task;
+  currentlyRenderingRequest = request;
+  currentlyRenderingKeyPath = keyPath;
+  // didScheduleRenderPhaseUpdate = false;
+  // firstWorkInProgressHook = null;
+  // numberOfReRenders = 0;
+  // renderPhaseUpdates = null;
+  // workInProgressHook = null;
+
+
+  localIdCounter = 0;
+  formStateCounter = 0;
+  formStateMatchingIndex = -1;
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function finishHooks(Component, props, children, refOrContext) {
+  // This must be called after every function component to prevent hooks from
+  // being used in classes.
+  while (didScheduleRenderPhaseUpdate) {
+    // Updates were scheduled during the render phase. They are stored in
+    // the `renderPhaseUpdates` map. Call the component again, reusing the
+    // work-in-progress hooks and applying the additional updates on top. Keep
+    // restarting until no more updates are scheduled.
+    didScheduleRenderPhaseUpdate = false;
+    localIdCounter = 0;
+    formStateCounter = 0;
+    formStateMatchingIndex = -1;
+    thenableIndexCounter = 0;
+    numberOfReRenders += 1; // Start over from the beginning of the list
+
+    workInProgressHook = null;
+    children = Component(props, refOrContext);
+  }
+
+  resetHooksState();
+  return children;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+function checkDidRenderIdHook() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  const didRenderIdHook = localIdCounter !== 0;
+  return didRenderIdHook;
+}
+function getFormStateCount() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateCounter;
+}
+function getFormStateMatchingIndex() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateMatchingIndex;
+} // Reset the internal hooks state if an error occurs while rendering a component
+
+function resetHooksState() {
+
+  currentlyRenderingComponent = null;
+  currentlyRenderingTask = null;
+  currentlyRenderingRequest = null;
+  currentlyRenderingKeyPath = null;
+  didScheduleRenderPhaseUpdate = false;
+  firstWorkInProgressHook = null;
+  numberOfReRenders = 0;
+  renderPhaseUpdates = null;
+  workInProgressHook = null;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+function useContext(context) {
+
+  resolveCurrentlyRenderingComponent();
+  return readContext$1(context);
+}
+
+function basicStateReducer(state, action) {
+  // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
+  return typeof action === 'function' ? action(state) : action;
+}
+
+function useState(initialState) {
+
+  return useReducer(basicStateReducer, // useReducer has a special case to support lazy useState initializers
+  initialState);
+}
+function useReducer(reducer, initialArg, init) {
+
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+
+  if (isReRender) {
+    // This is a re-render. Apply the new render phase updates to the previous
+    // current hook.
+    const queue = workInProgressHook.queue;
+    const dispatch = queue.dispatch;
+
+    if (renderPhaseUpdates !== null) {
+      // Render phase updates are stored in a map of queue -> linked list
+      const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+      if (firstRenderPhaseUpdate !== undefined) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        renderPhaseUpdates.delete(queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+        let newState = workInProgressHook.memoizedState;
+        let update = firstRenderPhaseUpdate;
+
+        do {
+          // Process this render phase update. We don't have to check the
+          // priority because it will always be the same as the current
+          // render's.
+          const action = update.action;
+
+          newState = reducer(newState, action);
+
+
+          update = update.next;
+        } while (update !== null); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+        workInProgressHook.memoizedState = newState;
+        return [newState, dispatch];
+      }
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    return [workInProgressHook.memoizedState, dispatch];
+  } else {
+
+    let initialState;
+
+    if (reducer === basicStateReducer) {
+      // Special case for `useState`.
+      initialState = typeof initialArg === 'function' ? initialArg() : initialArg;
+    } else {
+      initialState = init !== undefined ? init(initialArg) : initialArg;
+    }
+
+
+    workInProgressHook.memoizedState = initialState; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    const queue = workInProgressHook.queue = {
+      last: null,
+      dispatch: null
+    };
+    const dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingComponent, queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    return [workInProgressHook.memoizedState, dispatch];
+  }
+}
+
+function useMemo(nextCreate, deps) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+
+  if (workInProgressHook !== null) {
+    const prevState = workInProgressHook.memoizedState;
+
+    if (prevState !== null) {
+      if (nextDeps !== null) {
+        const prevDeps = prevState[1];
+
+        if (areHookInputsEqual(nextDeps, prevDeps)) {
+          return prevState[0];
+        }
+      }
+    }
+  }
+
+  const nextValue = nextCreate();
+
+
+  workInProgressHook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
+
+function useRef(initialValue) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const previousRef = workInProgressHook.memoizedState;
+
+  if (previousRef === null) {
+    const ref = {
+      current: initialValue
+    };
+
+
+    workInProgressHook.memoizedState = ref;
+    return ref;
+  } else {
+    return previousRef;
+  }
+}
+
+function dispatchAction(componentIdentity, queue, action) {
+  if (numberOfReRenders >= RE_RENDER_LIMIT) {
+    throw new Error('Too many re-renders. React limits the number of renders to prevent ' + 'an infinite loop.');
+  }
+
+  if (componentIdentity === currentlyRenderingComponent) {
+    // This is a render phase update. Stash it in a lazily-created map of
+    // queue -> linked list of updates. After this render pass, we'll restart
+    // and apply the stashed updates on top of the work-in-progress hook.
+    didScheduleRenderPhaseUpdate = true;
+    const update = {
+      action,
+      next: null
+    };
+
+    if (renderPhaseUpdates === null) {
+      renderPhaseUpdates = new Map();
+    }
+
+    const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+    if (firstRenderPhaseUpdate === undefined) {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      renderPhaseUpdates.set(queue, update);
+    } else {
+      // Append the update to the end of the list.
+      let lastRenderPhaseUpdate = firstRenderPhaseUpdate;
+
+      while (lastRenderPhaseUpdate.next !== null) {
+        lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+      }
+
+      lastRenderPhaseUpdate.next = update;
+    }
+  }
+}
+
+function useCallback(callback, deps) {
+  return useMemo(() => callback, deps);
+}
+
+function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  if (getServerSnapshot === undefined) {
+    throw new Error('Missing getServerSnapshot, which is required for ' + 'server-rendered content. Will revert to client rendering.');
+  }
+
+  return getServerSnapshot();
+}
+
+function useDeferredValue(value, initialValue) {
+  resolveCurrentlyRenderingComponent();
+
+  {
+    return value;
+  }
+}
+
+function unsupportedStartTransition() {
+  throw new Error('startTransition cannot be called during server rendering.');
+}
+
+function useTransition() {
+  resolveCurrentlyRenderingComponent();
+  return [false, unsupportedStartTransition];
+}
+
+function useHostTransitionStatus() {
+  resolveCurrentlyRenderingComponent();
+  return NotPendingTransition;
+}
+
+function unsupportedSetOptimisticState() {
+  throw new Error('Cannot update optimistic state while rendering.');
+}
+
+function useOptimistic(passthrough, reducer) {
+  resolveCurrentlyRenderingComponent();
+  return [passthrough, unsupportedSetOptimisticState];
+}
+
+function createPostbackFormStateKey(permalink, componentKeyPath, hookIndex) {
+  if (permalink !== undefined) {
+    // Don't bother to hash a permalink-based key since it's already short.
+    return 'p' + permalink;
+  } else {
+    // Append a node to the key path that represents the form state hook.
+    const keyPath = [componentKeyPath, null, hookIndex]; // Key paths are hashed to reduce the size. It does not need to be secure,
+    // and it's more important that it's fast than that it's completely
+    // collision-free.
+
+    const keyPathHash = createFastHashJS(JSON.stringify(keyPath));
+    return 'k' + keyPathHash;
+  }
+}
+
+function useFormState(action, initialState, permalink) {
+  resolveCurrentlyRenderingComponent(); // Count the number of useFormState hooks per component. We also use this to
+  // track the position of this useFormState hook relative to the other ones in
+  // this component, so we can generate a unique key for each one.
+
+  const formStateHookIndex = formStateCounter++;
+  const request = currentlyRenderingRequest; // $FlowIgnore[prop-missing]
+
+  const formAction = action.$$FORM_ACTION;
+
+  if (typeof formAction === 'function') {
+    // This is a server action. These have additional features to enable
+    // MPA-style form submissions with progressive enhancement.
+    // TODO: If the same permalink is passed to multiple useFormStates, and
+    // they all have the same action signature, Fizz will pass the postback
+    // state to all of them. We should probably only pass it to the first one,
+    // and/or warn.
+    // The key is lazily generated and deduped so the that the keypath doesn't
+    // get JSON.stringify-ed unnecessarily, and at most once.
+    let nextPostbackStateKey = null; // Determine the current form state. If we received state during an MPA form
+    // submission, then we will reuse that, if the action identity matches.
+    // Otherwise we'll use the initial state argument. We will emit a comment
+    // marker into the stream that indicates whether the state was reused.
+
+    let state = initialState;
+    const componentKeyPath = currentlyRenderingKeyPath;
+    const postbackFormState = getFormState(request); // $FlowIgnore[prop-missing]
+
+    const isSignatureEqual = action.$$IS_SIGNATURE_EQUAL;
+
+    if (postbackFormState !== null && typeof isSignatureEqual === 'function') {
+      const postbackKey = postbackFormState[1];
+      const postbackReferenceId = postbackFormState[2];
+      const postbackBoundArity = postbackFormState[3];
+
+      if (isSignatureEqual.call(action, postbackReferenceId, postbackBoundArity)) {
+        nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+
+        if (postbackKey === nextPostbackStateKey) {
+          // This was a match
+          formStateMatchingIndex = formStateHookIndex; // Reuse the state that was submitted by the form.
+
+          state = postbackFormState[0];
+        }
+      }
+    } // Bind the state to the first argument of the action.
+
+
+    const boundAction = action.bind(null, state); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    }; // $FlowIgnore[prop-missing]
+
+
+    if (typeof boundAction.$$FORM_ACTION === 'function') {
+      // $FlowIgnore[prop-missing]
+      dispatch.$$FORM_ACTION = prefix => {
+        const metadata = boundAction.$$FORM_ACTION(prefix); // Override the action URL
+
+        if (permalink !== undefined) {
+
+          permalink += '';
+          metadata.action = permalink;
+        }
+
+        const formData = metadata.data;
+
+        if (formData) {
+          if (nextPostbackStateKey === null) {
+            nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+          }
+
+          formData.append('$ACTION_KEY', nextPostbackStateKey);
+        }
+
+        return metadata;
+      };
+    }
+
+    return [state, dispatch];
+  } else {
+    // This is not a server action, so the implementation is much simpler.
+    // Bind the state to the first argument of the action.
+    const boundAction = action.bind(null, initialState); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    };
+
+    return [initialState, dispatch];
+  }
+}
+
+function useId() {
+  const task = currentlyRenderingTask;
+  const treeId = getTreeId(task.treeContext);
+  const resumableState = currentResumableState;
+
+  if (resumableState === null) {
+    throw new Error('Invalid hook call. Hooks can only be called inside of the body of a function component.');
+  }
+
+  const localId = localIdCounter++;
+  return makeId(resumableState, treeId, localId);
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable;
+      return unwrapThenable(thenable);
+    } else if (usable.$$typeof === REACT_CONTEXT_TYPE || usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function unwrapThenable(thenable) {
+  const index = thenableIndexCounter;
+  thenableIndexCounter += 1;
+
+  if (thenableState === null) {
+    thenableState = createThenableState();
+  }
+
+  return trackUsedThenable(thenableState, thenable, index);
+}
+
+function unsupportedRefresh() {
+  throw new Error('Cache cannot be refreshed during server rendering.');
+}
+
+function useCacheRefresh() {
+  return unsupportedRefresh;
+}
+
+function noop$1() {}
+
+const HooksDispatcher = {
+  readContext,
+  use,
+  useContext,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+  useInsertionEffect: noop$1,
+  useLayoutEffect: noop$1,
+  useCallback,
+  // useImperativeHandle is not run in the server environment
+  useImperativeHandle: noop$1,
+  // Effects are not run in the server environment.
+  useEffect: noop$1,
+  // Debugging effect
+  useDebugValue: noop$1,
+  useDeferredValue,
+  useTransition,
+  useId,
+  // Subscriptions are not setup in a server environment.
+  useSyncExternalStore
+};
+
+{
+  HooksDispatcher.useCacheRefresh = useCacheRefresh;
+}
+
+{
+  HooksDispatcher.useHostTransitionStatus = useHostTransitionStatus;
+}
+
+{
+  HooksDispatcher.useOptimistic = useOptimistic;
+  HooksDispatcher.useFormState = useFormState;
+}
+
+let currentResumableState = null;
+function setCurrentResumableState(resumableState) {
+  currentResumableState = resumableState;
+}
+
+function getCacheSignal() {
+  throw new Error('Not implemented.');
+}
+
+function getCacheForType(resourceType) {
+  throw new Error('Not implemented.');
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal,
+  getCacheForType
+};
+
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+const ReactCurrentCache = ReactSharedInternals.ReactCurrentCache;
+// The name might be minified but we assume that it's going to be the same generated name. Typically
+// because it's just the same compiled output in practice.
+// resume with segmentID at the index
+
+const CLIENT_RENDERED = 4; // if it errors or infinitely suspends
+
+const PENDING = 0;
+const COMPLETED = 1;
+const FLUSHED = 2;
+const ABORTED = 3;
+const ERRORED = 4;
+const POSTPONED = 5;
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2; // This is a default heuristic for how to split up the HTML content into progressive
+// loading. Our goal is to be able to display additional new content about every 500ms.
+// Faster than that is unnecessary and should be throttled on the client. It also
+// adds unnecessary overhead to do more splits. We don't know if it's a higher or lower
+// end device but higher end suffer less from the overhead than lower end does from
+// not getting small enough pieces. We error on the side of low end.
+// We base this on low end 3G speeds which is about 500kbits per second. We assume
+// that there can be a reasonable drop off from max bandwidth which leaves you with
+// as little as 80%. We can receive half of that each 500ms - at best. In practice,
+// a little bandwidth is lost to processing and contention - e.g. CSS and images that
+// are downloaded along with the main content. So we estimate about half of that to be
+// the lower end throughput. In other words, we expect that you can at least show
+// about 12.5kb of content per 500ms. Not counting starting latency for the first
+// paint.
+// 500 * 1024 / 8 * .8 * 0.5 / 2
+
+const DEFAULT_PROGRESSIVE_CHUNK_SIZE = 12800;
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+
+  return null;
+}
+
+function noop() {}
+
+function createRequest(children, resumableState, renderState, rootFormatContext, progressiveChunkSize, onError, onAllReady, onShellReady, onShellError, onFatalError, onPostpone, formState) {
+  prepareHostDispatcher();
+  const pingedTasks = [];
+  const abortSet = new Set();
+  const request = {
+    destination: null,
+    flushScheduled: false,
+    resumableState,
+    renderState,
+    rootFormatContext,
+    progressiveChunkSize: progressiveChunkSize === undefined ? DEFAULT_PROGRESSIVE_CHUNK_SIZE : progressiveChunkSize,
+    status: OPEN,
+    fatalError: null,
+    nextSegmentId: 0,
+    allPendingTasks: 0,
+    pendingRootTasks: 0,
+    completedRootSegment: null,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    clientRenderedBoundaries: [],
+    completedBoundaries: [],
+    partialBoundaries: [],
+    trackedPostpones: null,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? noop : onPostpone,
+    onAllReady: onAllReady === undefined ? noop : onAllReady,
+    onShellReady: onShellReady === undefined ? noop : onShellReady,
+    onShellError: onShellError === undefined ? noop : onShellError,
+    onFatalError: onFatalError === undefined ? noop : onFatalError,
+    formState: formState === undefined ? null : formState
+  }; // This segment represents the root fallback.
+
+  const rootSegment = createPendingSegment(request, 0, null, rootFormatContext, // Root segments are never embedded in Text on either edge
+  false, false); // There is no parent so conceptually, we're unblocked to flush this segment.
+
+  rootSegment.parentFlushed = true;
+  const rootTask = createRenderTask(request, null, children, -1, null, rootSegment, abortSet, null, rootFormatContext, emptyContextObject, rootContextSnapshot, emptyTreeContext);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  if (supportsRequestStorage) {
+    const store = requestStorage.getStore();
+    if (store) return store;
+  }
+
+  return null;
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (request.pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createSuspenseBoundary(request, fallbackAbortableTasks) {
+  return {
+    status: PENDING,
+    rootSegmentID: -1,
+    parentFlushed: false,
+    pendingTasks: 0,
+    completedSegments: [],
+    byteSize: 0,
+    fallbackAbortableTasks,
+    errorDigest: null,
+    resources: createBoundaryResources(),
+    trackedContentKeyPath: null,
+    trackedFallbackNode: null
+  };
+}
+
+function createRenderTask(request, thenableState, node, childIndex, blockedBoundary, blockedSegment, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  const task = {
+    replay: null,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createReplayTask(request, thenableState, replay, node, childIndex, blockedBoundary, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  replay.pendingTasks++;
+  const task = {
+    replay,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment: null,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createPendingSegment(request, index, boundary, parentFormatContext, lastPushedText, textEmbedded) {
+  return {
+    status: PENDING,
+    id: -1,
+    // lazily assigned later
+    index,
+    parentFlushed: false,
+    chunks: [],
+    children: [],
+    parentFormatContext,
+    boundary,
+    lastPushedText,
+    textEmbedded
+  };
+} // DEV-only global reference to the currently executing task
+
+function popComponentStackInDEV(task) {
+} // stash the component stack of an unwinding error until it is processed
+
+function logRecoverableError(request, error) {
+  // If this callback errors, we intentionally let that error bubble up to become a fatal error
+  // so that someone fixes the error reporting instead of hiding it.
+  const errorDigest = request.onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest;
+}
+
+function fatalError(request, error) {
+  // This is called outside error handling code such as if the root errors outside
+  // a suspense boundary or if the root suspense boundary's fallback errors.
+  // It's also called if React itself or its host configs errors.
+  const onShellError = request.onShellError;
+  onShellError(error);
+  const onFatalError = request.onFatalError;
+  onFatalError(error);
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function renderSuspenseBoundary(request, someTask, keyPath, props) {
+  if (someTask.replay !== null) {
+    // If we're replaying through this pass, it means we're replaying through
+    // an already completed Suspense boundary. It's too late to do anything about it
+    // so we can just render through it.
+    const prevKeyPath = someTask.keyPath;
+    someTask.keyPath = keyPath;
+    const content = props.children;
+
+    try {
+      renderNode(request, someTask, content, -1);
+    } finally {
+      someTask.keyPath = prevKeyPath;
+    }
+
+    return;
+  } // $FlowFixMe: Refined.
+
+
+  const task = someTask;
+  const prevKeyPath = task.keyPath;
+  const parentBoundary = task.blockedBoundary;
+  const parentSegment = task.blockedSegment; // Each time we enter a suspense boundary, we split out into a new segment for
+  // the fallback so that we can later replace that segment with the content.
+  // This also lets us split out the main content even if it doesn't suspend,
+  // in case it ends up generating a large subtree of content.
+
+  const fallback = props.fallback;
+  const content = props.children;
+  const fallbackAbortSet = new Set();
+  const newBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+
+  if (request.trackedPostpones !== null) {
+    newBoundary.trackedContentKeyPath = keyPath;
+  }
+
+  const insertionIndex = parentSegment.chunks.length; // The children of the boundary segment is actually the fallback.
+
+  const boundarySegment = createPendingSegment(request, insertionIndex, newBoundary, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false);
+  parentSegment.children.push(boundarySegment); // The parentSegment has a child Segment at this index so we reset the lastPushedText marker on the parent
+
+  parentSegment.lastPushedText = false; // This segment is the actual child content. We can start rendering that immediately.
+
+  const contentRootSegment = createPendingSegment(request, 0, null, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false); // We mark the root segment as having its parent flushed. It's not really flushed but there is
+  // no parent segment so there's nothing to wait on.
+
+  contentRootSegment.parentFlushed = true; // Currently this is running synchronously. We could instead schedule this to pingedTasks.
+  // I suspect that there might be some efficiency benefits from not creating the suspended task
+  // and instead just using the stack if possible.
+  // TODO: Call this directly instead of messing with saving and restoring contexts.
+  // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and which segment
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = newBoundary;
+  task.blockedSegment = contentRootSegment;
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, newBoundary.resources);
+  }
+
+  task.keyPath = keyPath;
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+    pushSegmentFinale(contentRootSegment.chunks, request.renderState, contentRootSegment.lastPushedText, contentRootSegment.textEmbedded);
+    contentRootSegment.status = COMPLETED;
+    queueCompletedSegment(newBoundary, contentRootSegment);
+
+    if (newBoundary.pendingTasks === 0 && newBoundary.status === PENDING) {
+      newBoundary.status = COMPLETED; // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    contentRootSegment.status = ERRORED;
+    newBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    newBoundary.errorDigest = errorDigest;
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.blockedSegment = parentSegment;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]];
+  const trackedPostpones = request.trackedPostpones;
+
+  if (trackedPostpones !== null) {
+    // We create a detached replay node to track any postpones inside the fallback.
+    const fallbackReplayNode = [fallbackKeyPath[1], fallbackKeyPath[2], [], null];
+    trackedPostpones.workingMap.set(fallbackKeyPath, fallbackReplayNode);
+
+    if (newBoundary.status === POSTPONED) {
+      // This must exist now.
+      const boundaryReplayNode = trackedPostpones.workingMap.get(keyPath);
+      boundaryReplayNode[4] = fallbackReplayNode;
+    } else {
+      // We might not inject it into the postponed tree, unless the content actually
+      // postpones too. We need to keep track of it until that happpens.
+      newBoundary.trackedFallbackNode = fallbackReplayNode;
+    }
+  } // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+
+  const suspendedFallbackTask = createRenderTask(request, null, fallback, -1, parentBoundary, boundarySegment, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function replaySuspenseBoundary(request, task, keyPath, props, id, childNodes, childSlots, fallbackNodes, fallbackSlots) {
+  const prevKeyPath = task.keyPath;
+  const previousReplaySet = task.replay;
+  const parentBoundary = task.blockedBoundary;
+  const content = props.children;
+  const fallback = props.fallback;
+  const fallbackAbortSet = new Set();
+  const resumedBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = id; // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and replay node
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = resumedBoundary;
+  task.replay = {
+    nodes: childNodes,
+    slots: childSlots,
+    pendingTasks: 1
+  };
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, resumedBoundary.resources);
+  }
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+    }
+
+    task.replay.pendingTasks--;
+
+    if (resumedBoundary.pendingTasks === 0 && resumedBoundary.status === PENDING) {
+      resumedBoundary.status = COMPLETED;
+      request.completedBoundaries.push(resumedBoundary); // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    resumedBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    resumedBoundary.errorDigest = errorDigest;
+
+    task.replay.pendingTasks--; // The parent already flushed in the prerender so we need to schedule this to be emitted.
+
+    request.clientRenderedBoundaries.push(resumedBoundary); // We don't need to decrement any task numbers because we didn't spawn any new task.
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.replay = previousReplaySet;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]]; // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+  const fallbackReplay = {
+    nodes: fallbackNodes,
+    slots: fallbackSlots,
+    pendingTasks: 0
+  };
+  const suspendedFallbackTask = createReplayTask(request, null, fallbackReplay, fallback, -1, parentBoundary, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function renderHostElement(request, task, keyPath, type, props) {
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    const children = props.children; // TODO: Make this a Config for replaying.
+
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+  } else {
+    // Render
+    const children = pushStartInstance(segment.chunks, type, props, request.resumableState, request.renderState, task.formatContext, segment.lastPushedText);
+    segment.lastPushedText = false;
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+    pushEndInstance(segment.chunks, type, props, request.resumableState, prevContext);
+    segment.lastPushedText = false;
+  }
+}
+
+function shouldConstruct(Component) {
+  return Component.prototype && Component.prototype.isReactComponent;
+}
+
+function renderWithHooks(request, task, keyPath, prevThenableState, Component, props, secondArg) {
+  const componentIdentity = {};
+  prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState);
+  const result = Component(props, secondArg);
+  return finishHooks(Component, props, result, secondArg);
+}
+
+function finishClassComponent(request, task, keyPath, instance, Component, props) {
+  const nextChildren = instance.render();
+
+  {
+    const childContextTypes = Component.childContextTypes;
+
+    if (childContextTypes !== null && childContextTypes !== undefined) {
+      const previousContext = task.legacyContext;
+      const mergedContext = processChildContext(instance, Component, previousContext, childContextTypes);
+      task.legacyContext = mergedContext;
+      renderNodeDestructive(request, task, null, nextChildren, -1);
+      task.legacyContext = previousContext;
+      return;
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, nextChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderClassComponent(request, task, keyPath, Component, props) {
+  const maskedContext = getMaskedContext(Component, task.legacyContext) ;
+  const instance = constructClassInstance(Component, props, maskedContext);
+  mountClassInstance(instance, Component, props, maskedContext);
+  finishClassComponent(request, task, keyPath, instance, Component);
+}
+// components for some reason.
+
+function renderIndeterminateComponent(request, task, keyPath, prevThenableState, Component, props) {
+  let legacyContext;
+
+  {
+    legacyContext = getMaskedContext(Component, task.legacyContext);
+  }
+
+  const value = renderWithHooks(request, task, keyPath, prevThenableState, Component, props, legacyContext);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+
+  if ( // Run these checks in production only if the flag is off.
+  // Eventually we'll delete this branch altogether.
+  typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) {
+
+    mountClassInstance(value, Component, props, legacyContext);
+    finishClassComponent(request, task, keyPath, value, Component);
+  } else {
+
+    finishFunctionComponent(request, task, keyPath, value, hasId, formStateCount, formStateMatchingIndex);
+  }
+}
+
+function finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex) {
+  let didEmitFormStateMarkers = false;
+
+  if (formStateCount !== 0 && request.formState !== null) {
+    // For each useFormState hook, emit a marker that indicates whether we
+    // rendered using the form state passed at the root. We only emit these
+    // markers if form state is passed at the root.
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      didEmitFormStateMarkers = true;
+      const target = segment.chunks;
+
+      for (let i = 0; i < formStateCount; i++) {
+        if (i === formStateMatchingIndex) {
+          pushFormStateMarkerIsMatching(target);
+        } else {
+          pushFormStateMarkerIsNotMatching(target);
+        }
+      }
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+
+  if (hasId) {
+    // This component materialized an id. We treat this as its own level, with
+    // a single "child" slot.
+    const prevTreeContext = task.treeContext;
+    const totalChildren = 1;
+    const index = 0; // Modify the id context. Because we'll need to reset this if something
+    // suspends or errors, we'll use the non-destructive render path.
+
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, index);
+    renderNode(request, task, children, -1); // Like the other contexts, this does not need to be in a finally block
+    // because renderNode takes care of unwinding the stack.
+
+    task.treeContext = prevTreeContext;
+  } else if (didEmitFormStateMarkers) {
+    // If there were formState hooks, we must use the non-destructive path
+    // because this component is not a pure indirection; we emitted markers
+    // to the stream.
+    renderNode(request, task, children, -1);
+  } else {
+    // We're now successfully past this task, and we haven't modified the
+    // context stack. We don't have to pop back to the previous task every
+    // again, so we can use the destructive recursive form.
+    renderNodeDestructive(request, task, null, children, -1);
+  }
+
+  task.keyPath = prevKeyPath;
+}
+
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    // Resolve default props. Taken from ReactElement
+    const props = assign({}, baseProps);
+    const defaultProps = Component.defaultProps;
+
+    for (const propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+
+    return props;
+  }
+
+  return baseProps;
+}
+
+function renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref) {
+  const children = renderWithHooks(request, task, keyPath, prevThenableState, type.render, props, ref);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+  finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex);
+}
+
+function renderMemo(request, task, keyPath, prevThenableState, type, props, ref) {
+  const innerType = type.type;
+  const resolvedProps = resolveDefaultProps(innerType, props);
+  renderElement(request, task, keyPath, prevThenableState, innerType, resolvedProps, ref);
+}
+
+function renderContextConsumer(request, task, keyPath, context, props) {
+
+  const render = props.children;
+
+  const newValue = readContext$1(context);
+  const newChildren = render(newValue);
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, newChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderContextProvider(request, task, keyPath, type, props) {
+  const context = type._context;
+  const value = props.value;
+  const children = props.children;
+
+  const prevKeyPath = task.keyPath;
+  task.context = pushProvider(context, value);
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, children, -1);
+  task.context = popProvider();
+  task.keyPath = prevKeyPath;
+}
+
+function renderLazyComponent(request, task, keyPath, prevThenableState, lazyComponent, props, ref) {
+  const payload = lazyComponent._payload;
+  const init = lazyComponent._init;
+  const Component = init(payload);
+  const resolvedProps = resolveDefaultProps(Component, props);
+  renderElement(request, task, keyPath, prevThenableState, Component, resolvedProps, ref);
+}
+
+function renderOffscreen(request, task, keyPath, props) {
+  const mode = props.mode;
+
+  if (mode === 'hidden') ; else {
+    // A visible Offscreen boundary is treated exactly like a fragment: a
+    // pure indirection.
+    const prevKeyPath = task.keyPath;
+    task.keyPath = keyPath;
+    renderNodeDestructive(request, task, null, props.children, -1);
+    task.keyPath = prevKeyPath;
+  }
+}
+
+function renderElement(request, task, keyPath, prevThenableState, type, props, ref) {
+  if (typeof type === 'function') {
+    if (shouldConstruct(type)) {
+      renderClassComponent(request, task, keyPath, type, props);
+      return;
+    } else {
+      renderIndeterminateComponent(request, task, keyPath, prevThenableState, type, props);
+      return;
+    }
+  }
+
+  if (typeof type === 'string') {
+    renderHostElement(request, task, keyPath, type, props);
+    return;
+  }
+
+  switch (type) {
+    // LegacyHidden acts the same as a fragment. This only works because we
+    // currently assume that every instance of LegacyHidden is accompanied by a
+    // host component wrapper. In the hidden mode, the host component is given a
+    // `hidden` attribute, which ensures that the initial HTML is not visible.
+    // To support the use of LegacyHidden as a true fragment, without an extra
+    // DOM node, we would have to hide the initial HTML in some other way.
+    // TODO: Delete in LegacyHidden. It's an unstable API only used in the
+    // www build. As a migration step, we could add a special prop to Offscreen
+    // that simulates the old behavior (no hiding, no change to effects).
+    case REACT_LEGACY_HIDDEN_TYPE:
+    case REACT_DEBUG_TRACING_MODE_TYPE:
+    case REACT_STRICT_MODE_TYPE:
+    case REACT_PROFILER_TYPE:
+    case REACT_FRAGMENT_TYPE:
+      {
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_OFFSCREEN_TYPE:
+      {
+        renderOffscreen(request, task, keyPath, props);
+        return;
+      }
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      {
+
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_SCOPE_TYPE:
+      {
+
+        throw new Error('ReactDOMServer does not yet support scope components.');
+      }
+
+    case REACT_SUSPENSE_TYPE:
+      {
+        {
+          renderSuspenseBoundary(request, task, keyPath, props);
+        }
+
+        return;
+      }
+  }
+
+  if (typeof type === 'object' && type !== null) {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        {
+          renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          renderMemo(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_PROVIDER_TYPE:
+        {
+          renderContextProvider(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_CONTEXT_TYPE:
+        {
+          renderContextConsumer(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_LAZY_TYPE:
+        {
+          renderLazyComponent(request, task, keyPath, prevThenableState, type, props);
+          return;
+        }
+    }
+  }
+
+  let info = '';
+
+  throw new Error('Element type is invalid: expected a string (for built-in ' + 'components) or a class/function (for composite components) ' + ("but got: " + (type == null ? type : typeof type) + "." + info));
+}
+
+function resumeNode(request, task, segmentId, node, childIndex) {
+  const prevReplay = task.replay;
+  const blockedBoundary = task.blockedBoundary;
+  const resumedSegment = createPendingSegment(request, 0, null, task.formatContext, false, false);
+  resumedSegment.id = segmentId;
+  resumedSegment.parentFlushed = true;
+
+  try {
+    // Convert the current ReplayTask to a RenderTask.
+    const renderTask = task;
+    renderTask.replay = null;
+    renderTask.blockedSegment = resumedSegment;
+    renderNode(request, task, node, childIndex);
+    resumedSegment.status = COMPLETED;
+
+    if (blockedBoundary === null) {
+      request.completedRootSegment = resumedSegment;
+    } else {
+      queueCompletedSegment(blockedBoundary, resumedSegment);
+
+      if (blockedBoundary.parentFlushed) {
+        request.partialBoundaries.push(blockedBoundary);
+      }
+    }
+  } finally {
+    // Restore to a ReplayTask.
+    task.replay = prevReplay;
+    task.blockedSegment = null;
+  }
+}
+
+function replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, replay) {
+  // We're replaying. Find the path to follow.
+  const replayNodes = replay.nodes;
+
+  for (let i = 0; i < replayNodes.length; i++) {
+    // Flow doesn't support refinement on tuples so we do it manually here.
+    const node = replayNodes[i];
+
+    if (keyOrIndex !== node[1]) {
+      continue;
+    }
+
+    if (node.length === 4) {
+      // Matched a replayable path.
+      // Let's double check that the component name matches as a precaution.
+      if (name !== null && name !== node[0]) {
+        throw new Error('Expected the resume to render <' + node[0] + '> in this slot but instead it rendered <' + name + '>. ' + "The tree doesn't match so React will fallback to client rendering.");
+      }
+
+      const childNodes = node[2];
+      const childSlots = node[3];
+      const currentNode = task.node;
+      task.replay = {
+        nodes: childNodes,
+        slots: childSlots,
+        pendingTasks: 1
+      };
+
+      try {
+        renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+
+        if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0 // TODO check remaining slots
+        ) {
+            throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+          }
+
+        task.replay.pendingTasks--;
+      } catch (x) {
+        if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+          // Suspend
+          if (task.node === currentNode) {
+            // This same element suspended so we need to pop the replay we just added.
+            task.replay = replay;
+          }
+
+          throw x;
+        }
+
+        task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+        // during a replay. That's because this component didn't actually error
+        // in the original prerender. What's unable to complete is the child
+        // replay nodes which might be Suspense boundaries which are able to
+        // absorb the error and we can still continue with siblings.
+
+        erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+      }
+
+      task.replay = replay;
+    } else {
+      // Let's double check that the component type matches.
+      if (type !== REACT_SUSPENSE_TYPE) {
+        const expectedType = 'Suspense';
+        throw new Error('Expected the resume to render <' + expectedType + '> in this slot but instead it rendered <' + (getComponentNameFromType(type) || 'Unknown') + '>. ' + "The tree doesn't match so React will fallback to client rendering.");
+      } // Matched a replayable path.
+
+
+      replaySuspenseBoundary(request, task, keyPath, props, node[5], node[2], node[3], node[4] === null ? [] : node[4][2], node[4] === null ? null : node[4][3]);
+    } // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+
+    replayNodes.splice(i, 1);
+    return;
+  } // We didn't find any matching nodes. We assume that this element was already
+  // rendered in the prelude and skip it.
+
+} // $FlowFixMe[missing-local-annot]
+
+function renderNodeDestructive(request, task, // The thenable state reused from the previous attempt, if any. This is almost
+// always null, except when called by retryTask.
+prevThenableState, node, childIndex) {
+  {
+    return renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex);
+  }
+} // This function by it self renders a node and consumes the task by mutating it
+// to update the current execution state.
+
+
+function renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex) {
+  if (task.replay !== null && typeof task.replay.slots === 'number') {
+    // TODO: Figure out a cheaper place than this hot path to do this check.
+    const resumeSegmentID = task.replay.slots;
+    resumeNode(request, task, resumeSegmentID, node, childIndex);
+    return;
+  } // Stash the node we're working on. We'll pick up from this task in case
+  // something suspends.
+
+
+  task.node = node;
+  task.childIndex = childIndex; // Handle object types
+
+  if (typeof node === 'object' && node !== null) {
+    switch (node.$$typeof) {
+      case REACT_ELEMENT_TYPE:
+        {
+          const element = node;
+          const type = element.type;
+          const key = element.key;
+          const props = element.props;
+          const ref = element.ref;
+          const name = getComponentNameFromType(type);
+          const keyOrIndex = key == null ? childIndex === -1 ? 0 : childIndex : key;
+          const keyPath = [task.keyPath, name, keyOrIndex];
+
+          if (task.replay !== null) {
+            replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, task.replay); // No matches found for this node. We assume it's already emitted in the
+            // prelude and skip it during the replay.
+          } else {
+            // We're doing a plain render.
+            renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+          }
+
+          return;
+        }
+
+      case REACT_PORTAL_TYPE:
+        throw new Error('Portals are not currently supported by the server renderer. ' + 'Render them conditionally so that they only appear on the client render.');
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyNode = node;
+          const payload = lazyNode._payload;
+          const init = lazyNode._init;
+          let resolvedNode;
+
+          {
+            resolvedNode = init(payload);
+          }
+
+          renderNodeDestructive(request, task, null, resolvedNode, childIndex);
+          return;
+        }
+    }
+
+    if (isArray(node)) {
+      renderChildrenArray(request, task, node, childIndex);
+      return;
+    }
+
+    const iteratorFn = getIteratorFn(node);
+
+    if (iteratorFn) {
+
+      const iterator = iteratorFn.call(node);
+
+      if (iterator) {
+        // We need to know how many total children are in this set, so that we
+        // can allocate enough id slots to acommodate them. So we must exhaust
+        // the iterator before we start recursively rendering the children.
+        // TODO: This is not great but I think it's inherent to the id
+        // generation algorithm.
+        let step = iterator.next(); // If there are not entries, we need to push an empty so we start by checking that.
+
+        if (!step.done) {
+          const children = [];
+
+          do {
+            children.push(step.value);
+            step = iterator.next();
+          } while (!step.done);
+
+          renderChildrenArray(request, task, children, childIndex);
+          return;
+        }
+
+        return;
+      }
+    } // Usables are a valid React node type. When React encounters a Usable in
+    // a child position, it unwraps it using the same algorithm as `use`. For
+    // example, for promises, React will throw an exception to unwind the
+    // stack, then replay the component once the promise resolves.
+    //
+    // A difference from `use` is that React will keep unwrapping the value
+    // until it reaches a non-Usable type.
+    //
+    // e.g. Usable<Usable<Usable<T>>> should resolve to T
+
+
+    const maybeUsable = node;
+
+    if (typeof maybeUsable.then === 'function') {
+      const thenable = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, unwrapThenable(thenable), childIndex);
+    }
+
+    if (maybeUsable.$$typeof === REACT_CONTEXT_TYPE || maybeUsable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, readContext$1(context), childIndex);
+    } // $FlowFixMe[method-unbinding]
+
+
+    const childString = Object.prototype.toString.call(node);
+    throw new Error("Objects are not valid as a React child (found: " + (childString === '[object Object]' ? 'object with keys {' + Object.keys(node).join(', ') + '}' : childString) + "). " + 'If you meant to render a collection of children, use an array ' + 'instead.');
+  }
+
+  if (typeof node === 'string') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+
+  if (typeof node === 'number') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, '' + node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+}
+
+function replayFragment(request, task, children, childIndex) {
+  // If we're supposed follow this array, we'd expect to see a ReplayNode matching
+  // this fragment.
+  const replay = task.replay;
+  const replayNodes = replay.nodes;
+
+  for (let j = 0; j < replayNodes.length; j++) {
+    const node = replayNodes[j];
+
+    if (node[1] !== childIndex) {
+      continue;
+    } // Matched a replayable path.
+
+
+    const childNodes = node[2];
+    const childSlots = node[3];
+    task.replay = {
+      nodes: childNodes,
+      slots: childSlots,
+      pendingTasks: 1
+    };
+
+    try {
+      renderChildrenArray(request, task, children, -1);
+
+      if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+        throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+      }
+
+      task.replay.pendingTasks--;
+    } catch (x) {
+      if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+        // Suspend
+        throw x;
+      }
+
+      task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+      // during a replay. That's because this component didn't actually error
+      // in the original prerender. What's unable to complete is the child
+      // replay nodes which might be Suspense boundaries which are able to
+      // absorb the error and we can still continue with siblings.
+      // This is an error, stash the component stack if it is null.
+
+      erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+    }
+
+    task.replay = replay; // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+    replayNodes.splice(j, 1);
+    break;
+  }
+}
+
+function renderChildrenArray(request, task, children, childIndex) {
+  const prevKeyPath = task.keyPath;
+
+  if (childIndex !== -1) {
+    task.keyPath = [task.keyPath, 'Fragment', childIndex];
+
+    if (task.replay !== null) {
+      replayFragment(request, // $FlowFixMe: Refined.
+      task, children, childIndex);
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  const prevTreeContext = task.treeContext;
+  const totalChildren = children.length;
+
+  if (task.replay !== null) {
+    // Replay
+    // First we need to check if we have any resume slots at this level.
+    const resumeSlots = task.replay.slots;
+
+    if (resumeSlots !== null && typeof resumeSlots === 'object') {
+      for (let i = 0; i < totalChildren; i++) {
+        const node = children[i];
+        task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+        // up and render the sibling if something suspends.
+
+        const resumeSegmentID = resumeSlots[i]; // TODO: If this errors we should still continue with the next sibling.
+
+        if (typeof resumeSegmentID === 'number') {
+          resumeNode(request, task, resumeSegmentID, node, i); // We finished rendering this node, so now we can consume this
+          // slot. This must happen after in case we rerender this task.
+
+          delete resumeSlots[i];
+        } else {
+          renderNode(request, task, node, i);
+        }
+      }
+
+      task.treeContext = prevTreeContext;
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  for (let i = 0; i < totalChildren; i++) {
+    const node = children[i];
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+    // up and render the sibling if something suspends.
+
+    renderNode(request, task, node, i);
+  } // Because this context is always set right before rendering every child, we
+  // only need to reset it to the previous value at the very end.
+
+
+  task.treeContext = prevTreeContext;
+  task.keyPath = prevKeyPath;
+}
+
+function spawnNewSuspendedReplayTask(request, task, thenableState, x) {
+  const newTask = createReplayTask(request, thenableState, task.replay, task.node, task.childIndex, task.blockedBoundary, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+}
+
+function spawnNewSuspendedRenderTask(request, task, thenableState, x) {
+  // Something suspended, we'll need to create a new segment and resolve it later.
+  const segment = task.blockedSegment;
+  const insertionIndex = segment.chunks.length;
+  const newSegment = createPendingSegment(request, insertionIndex, null, task.formatContext, // Adopt the parent segment's leading text embed
+  segment.lastPushedText, // Assume we are text embedded at the trailing edge
+  true);
+  segment.children.push(newSegment); // Reset lastPushedText for current Segment since the new Segment "consumed" it
+
+  segment.lastPushedText = false;
+  const newTask = createRenderTask(request, thenableState, task.node, task.childIndex, task.blockedBoundary, newSegment, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+} // This is a non-destructive form of rendering a node. If it suspends it spawns
+// a new task and restores the context of this task to what it was before.
+
+
+function renderNode(request, task, node, childIndex) {
+  // Snapshot the current context in case something throws to interrupt the
+  // process.
+  const previousFormatContext = task.formatContext;
+  const previousLegacyContext = task.legacyContext;
+  const previousContext = task.context;
+  const previousKeyPath = task.keyPath;
+  const previousTreeContext = task.treeContext;
+
+  let x; // Store how much we've pushed at this point so we can reset it in case something
+  // suspended partially through writing something.
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState();
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedReplayTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+      } // TODO: Abort any undiscovered Suspense boundaries in the ReplayNode.
+
+    }
+  } else {
+    // Render
+    const childrenLength = segment.children.length;
+    const chunkLength = segment.chunks.length;
+
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState(); // Reset the write pointers to where we started.
+
+      segment.children.length = childrenLength;
+      segment.chunks.length = chunkLength;
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedRenderTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+      }
+    }
+  } // Restore the context. We assume that this will be restored by the inner
+  // functions in case nothing throws so we don't use "finally" here.
+
+
+  task.formatContext = previousFormatContext;
+  task.legacyContext = previousLegacyContext;
+  task.context = previousContext;
+  task.keyPath = previousKeyPath;
+  task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+  switchContext(previousContext);
+  // Let's terminate the rest of the tree and don't render any siblings.
+
+
+  throw x;
+}
+
+function erroredReplay(request, boundary, error, replayNodes, resumeSlots) {
+  // Erroring during a replay doesn't actually cause an error by itself because
+  // that component has already rendered. What causes the error is the resumable
+  // points that we did not yet finish which will be below the point of the reset.
+  // For example, if we're replaying a path to a Suspense boundary that is not done
+  // that doesn't error the parent Suspense boundary.
+  // This might be a bit strange that the error in a parent gets thrown at a child.
+  // We log it only once and reuse the digest.
+  let errorDigest;
+
+  {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  abortRemainingReplayNodes(request, boundary, replayNodes, resumeSlots, error, errorDigest);
+}
+
+function erroredTask(request, boundary, error) {
+  // Report the error to a global handler.
+  let errorDigest;
+
+  {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  if (boundary === null) {
+    fatalError(request, error);
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+      // so we can flush it, if the parent already flushed.
+
+
+      if (boundary.parentFlushed) {
+        // We don't have a preference where in the queue this goes since it's likely
+        // to error on the client anyway. However, intentionally client-rendered
+        // boundaries should be flushed earlier so that they can start on the client.
+        // We reuse the same queue for errors.
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function abortTaskSoft(task) {
+  // This aborts task without aborting the parent boundary that it blocks.
+  // It's used for when we didn't need this task to complete the tree.
+  // If task was needed, then it should use abortTask instead.
+  const request = this;
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+    finishedTask(request, boundary, segment);
+  }
+}
+
+function abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest) {
+  const resumedBoundary = createSuspenseBoundary(request, new Set());
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = rootSegmentID;
+  resumedBoundary.status = CLIENT_RENDERED;
+  resumedBoundary.errorDigest = errorDigest;
+
+  if (resumedBoundary.parentFlushed) {
+    request.clientRenderedBoundaries.push(resumedBoundary);
+  }
+}
+
+function abortRemainingReplayNodes(request, boundary, nodes, slots, error, errorDigest) {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+
+    if (node.length === 4) {
+      abortRemainingReplayNodes(request, boundary, node[2], node[3], error, errorDigest);
+    } else {
+      const boundaryNode = node;
+      const rootSegmentID = boundaryNode[5];
+      abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest);
+    }
+  } // Empty the set, since we've cleared it now.
+
+
+  nodes.length = 0;
+
+  if (slots !== null) {
+    // We had something still to resume in the parent boundary. We must trigger
+    // the error on the parent boundary since it's not able to complete.
+    if (boundary === null) {
+      throw new Error('We should not have any resumable nodes in the shell. ' + 'This is a bug in React.');
+    } else if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // Empty the set
+
+
+    if (typeof slots === 'object') {
+      for (const index in slots) {
+        delete slots[index];
+      }
+    }
+  }
+}
+
+function abortTask(task, request, error) {
+  // This aborts the task and aborts the parent that it blocks, putting it into
+  // client rendered mode.
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+  }
+
+  if (boundary === null) {
+    if (request.status !== CLOSING && request.status !== CLOSED) {
+      const replay = task.replay;
+
+      if (replay === null) {
+        // We didn't complete the root so we have nothing to show. We can close
+        // the request;
+        logRecoverableError(request, error);
+        fatalError(request, error);
+        return;
+      } else {
+        // If the shell aborts during a replay, that's not a fatal error. Instead
+        // we should be able to recover by client rendering all the root boundaries in
+        // the ReplaySet.
+        replay.pendingTasks--;
+
+        if (replay.pendingTasks === 0 && replay.nodes.length > 0) {
+          const errorDigest = logRecoverableError(request, error);
+          abortRemainingReplayNodes(request, null, replay.nodes, replay.slots, error, errorDigest);
+        }
+
+        request.pendingRootTasks--;
+
+        if (request.pendingRootTasks === 0) {
+          completeShell(request);
+        }
+      }
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = logRecoverableError(request, error);
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // If this boundary was still pending then we haven't already cancelled its fallbacks.
+    // We'll need to abort the fallbacks, which will also error that parent boundary.
+
+
+    boundary.fallbackAbortableTasks.forEach(fallbackTask => abortTask(fallbackTask, request, error));
+    boundary.fallbackAbortableTasks.clear();
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeShell(request) {
+  if (request.trackedPostpones === null) {
+    // We only emit early preloads on shell completion for renders. For prerenders
+    // we wait for the entire Request to finish because we are not responding to a
+    // live request and can wait for as much data as possible.
+    // we should only be calling completeShell when the shell is complete so we
+    // just use a literal here
+    const shellComplete = true;
+    emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  } // We have completed the shell so the shell can't error anymore.
+
+
+  request.onShellError = noop;
+  const onShellReady = request.onShellReady;
+  onShellReady();
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeAll(request) {
+  // During a render the shell must be complete if the entire request is finished
+  // however during a Prerender it is possible that the shell is incomplete because
+  // it postponed. We cannot use rootPendingTasks in the prerender case because
+  // those hit zero even when the shell postpones. Instead we look at the completedRootSegment
+  const shellComplete = request.trackedPostpones === null ? // Render, we assume it is completed
+  true : // Prerender Request, we use the state of the root segment
+  request.completedRootSegment === null || request.completedRootSegment.status !== POSTPONED;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  const onAllReady = request.onAllReady;
+  onAllReady();
+}
+
+function queueCompletedSegment(boundary, segment) {
+  if (segment.chunks.length === 0 && segment.children.length === 1 && segment.children[0].boundary === null) {
+    // This is an empty segment. There's nothing to write, so we can instead transfer the ID
+    // to the child. That way any existing references point to the child.
+    const childSegment = segment.children[0];
+    childSegment.id = segment.id;
+    childSegment.parentFlushed = true;
+
+    if (childSegment.status === COMPLETED) {
+      queueCompletedSegment(boundary, childSegment);
+    }
+  } else {
+    const completedSegments = boundary.completedSegments;
+    completedSegments.push(segment);
+  }
+}
+
+function finishedTask(request, boundary, segment) {
+  if (boundary === null) {
+    if (segment !== null && segment.parentFlushed) {
+      if (request.completedRootSegment !== null) {
+        throw new Error('There can only be one root segment. This is a bug in React.');
+      }
+
+      request.completedRootSegment = segment;
+    }
+
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status === CLIENT_RENDERED) ; else if (boundary.pendingTasks === 0) {
+      if (boundary.status === PENDING) {
+        boundary.status = COMPLETED;
+      } // This must have been the last segment we were waiting on. This boundary is now complete.
+
+
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent segment already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+        }
+      }
+
+      if (boundary.parentFlushed) {
+        // The segment might be part of a segment that didn't flush yet, but if the boundary's
+        // parent flushed, we need to schedule the boundary to be emitted.
+        request.completedBoundaries.push(boundary);
+      } // We can now cancel any pending task on the fallback since we won't need to show it anymore.
+      // This needs to happen after we read the parentFlushed flags because aborting can finish
+      // work which can trigger user code, which can start flushing, which can change those flags.
+      // If the boundary was POSTPONED, we still need to finish the fallback first.
+
+
+      if (boundary.status === COMPLETED) {
+        boundary.fallbackAbortableTasks.forEach(abortTaskSoft, request);
+        boundary.fallbackAbortableTasks.clear();
+      }
+    } else {
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+          const completedSegments = boundary.completedSegments;
+
+          if (completedSegments.length === 1) {
+            // This is the first time since we last flushed that we completed anything.
+            // We can schedule this boundary to emit its partially completed segments early
+            // in case the parent has already been flushed.
+            if (boundary.parentFlushed) {
+              request.partialBoundaries.push(boundary);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function retryTask(request, task) {
+  {
+    const blockedBoundary = task.blockedBoundary;
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, blockedBoundary ? blockedBoundary.resources : null);
+  }
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    retryReplayTask(request, // $FlowFixMe: Refined.
+    task);
+  } else {
+    retryRenderTask(request, // $FlowFixMe: Refined.
+    task, segment);
+  }
+}
+
+function retryRenderTask(request, task, segment) {
+  if (segment.status !== PENDING) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  const childrenLength = segment.children.length;
+  const chunkLength = segment.chunks.length;
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+    pushSegmentFinale(segment.chunks, request.renderState, segment.lastPushedText, segment.textEmbedded);
+    task.abortSet.delete(task);
+    segment.status = COMPLETED;
+    finishedTask(request, task.blockedBoundary, segment);
+  } catch (thrownValue) {
+    resetHooksState(); // Reset the write pointers to where we started.
+
+    segment.children.length = childrenLength;
+    segment.chunks.length = chunkLength;
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    task.abortSet.delete(task);
+    segment.status = ERRORED;
+    erroredTask(request, task.blockedBoundary, x);
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function retryReplayTask(request, task) {
+  if (task.replay.pendingTasks === 0) {
+    // There are no pending tasks working on this set, so we must have aborted.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    finishedTask(request, task.blockedBoundary, null);
+  } catch (thrownValue) {
+    resetHooksState();
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    erroredReplay(request, task.blockedBoundary, x, task.replay.nodes, task.replay.slots);
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+
+    request.allPendingTasks--;
+
+    if (request.allPendingTasks === 0) {
+      completeAll(request);
+    }
+
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function performWork(request) {
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  const prevContext = getActiveContext();
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  let prevCacheDispatcher;
+
+  {
+    prevCacheDispatcher = ReactCurrentCache.current;
+    ReactCurrentCache.current = DefaultCacheDispatcher;
+  }
+
+  const prevRequest = currentRequest;
+  currentRequest = request;
+
+  const prevResumableState = currentResumableState;
+  setCurrentResumableState(request.resumableState);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    let i;
+
+    for (i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    pingedTasks.splice(0, i);
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    setCurrentResumableState(prevResumableState);
+    ReactCurrentDispatcher.current = prevDispatcher;
+
+    {
+      ReactCurrentCache.current = prevCacheDispatcher;
+    }
+
+    if (prevDispatcher === HooksDispatcher) {
+      // This means that we were in a reentrant work loop. This could happen
+      // in a renderer that supports synchronous work like renderToString,
+      // when it's called from within another renderer.
+      // Normally we don't bother switching the contexts to their root/default
+      // values when leaving because we'll likely need the same or similar
+      // context again. However, when we're inside a synchronous loop like this
+      // we'll to restore the context to what it was before returning.
+      switchContext(prevContext);
+    }
+
+    currentRequest = prevRequest;
+  }
+}
+
+function flushSubtree(request, destination, segment) {
+  segment.parentFlushed = true;
+
+  switch (segment.status) {
+    case PENDING:
+      {
+        // We're emitting a placeholder for this segment to be filled in later.
+        // Therefore we'll need to assign it an ID - to refer to it by.
+        segment.id = request.nextSegmentId++; // Fallthrough
+      }
+
+    case POSTPONED:
+      {
+        const segmentID = segment.id; // When this segment finally completes it won't be embedded in text since it will flush separately
+
+        segment.lastPushedText = false;
+        segment.textEmbedded = false;
+        return writePlaceholder(destination, request.renderState, segmentID);
+      }
+
+    case COMPLETED:
+      {
+        segment.status = FLUSHED;
+        let r = true;
+        const chunks = segment.chunks;
+        let chunkIdx = 0;
+        const children = segment.children;
+
+        for (let childIdx = 0; childIdx < children.length; childIdx++) {
+          const nextChild = children[childIdx]; // Write all the chunks up until the next child.
+
+          for (; chunkIdx < nextChild.index; chunkIdx++) {
+            writeChunk(destination, chunks[chunkIdx]);
+          }
+
+          r = flushSegment(request, destination, nextChild);
+        } // Finally just write all the remaining chunks
+
+
+        for (; chunkIdx < chunks.length - 1; chunkIdx++) {
+          writeChunk(destination, chunks[chunkIdx]);
+        }
+
+        if (chunkIdx < chunks.length) {
+          r = writeChunkAndReturn(destination, chunks[chunkIdx]);
+        }
+
+        return r;
+      }
+
+    default:
+      {
+        throw new Error('Aborted, errored or already flushed boundaries should not be flushed again. This is a bug in React.');
+      }
+  }
+}
+
+function flushSegment(request, destination, segment) {
+  const boundary = segment.boundary;
+
+  if (boundary === null) {
+    // Not a suspense boundary.
+    return flushSubtree(request, destination, segment);
+  }
+
+  boundary.parentFlushed = true; // This segment is a Suspense boundary. We need to decide whether to
+  // emit the content or the fallback now.
+
+  if (boundary.status === CLIENT_RENDERED) {
+    // Emit a client rendered suspense boundary wrapper.
+    // We never queue the inner boundary so we'll never emit its content or partial segments.
+    writeStartClientRenderedSuspenseBoundary(destination, request.renderState, boundary.errorDigest); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndClientRenderedSuspenseBoundary(destination);
+  } else if (boundary.status !== COMPLETED) {
+    if (boundary.status === PENDING) {
+      // For pending boundaries we lazily assign an ID to the boundary
+      // and root segment.
+      boundary.rootSegmentID = request.nextSegmentId++;
+    }
+
+    if (boundary.completedSegments.length > 0) {
+      // If this is at least partially complete, we can queue it to be partially emitted early.
+      request.partialBoundaries.push(boundary);
+    } // This boundary is still loading. Emit a pending suspense boundary wrapper.
+
+
+    const id = boundary.rootSegmentID;
+    writeStartPendingSuspenseBoundary(destination, request.renderState, id); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else if (boundary.byteSize > request.progressiveChunkSize) {
+    // This boundary is large and will be emitted separately so that we can progressively show
+    // other content. We add it to the queue during the flush because we have to ensure that
+    // the parent flushes first so that there's something to inject it into.
+    // We also have to make sure that it's emitted into the queue in a deterministic slot.
+    // I.e. we can't insert it here when it completes.
+    // Assign an ID to refer to the future content by.
+    boundary.rootSegmentID = request.nextSegmentId++;
+    request.completedBoundaries.push(boundary); // Emit a pending rendered suspense boundary wrapper.
+
+    writeStartPendingSuspenseBoundary(destination, request.renderState, boundary.rootSegmentID); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else {
+    {
+      hoistResources(request.renderState, boundary.resources);
+    } // We can inline this boundary's content as a complete boundary.
+
+
+    writeStartCompletedSuspenseBoundary(destination);
+    const completedSegments = boundary.completedSegments;
+
+    if (completedSegments.length !== 1) {
+      throw new Error('A previously unvisited boundary must have exactly one root segment. This is a bug in React.');
+    }
+
+    const contentSegment = completedSegments[0];
+    flushSegment(request, destination, contentSegment);
+    return writeEndCompletedSuspenseBoundary(destination);
+  }
+}
+
+function flushClientRenderedBoundary(request, destination, boundary) {
+  return writeClientRenderBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.errorDigest, boundary.errorMessage, boundary.errorComponentStack);
+}
+
+function flushSegmentContainer(request, destination, segment) {
+  writeStartSegment(destination, request.renderState, segment.parentFormatContext, segment.id);
+  flushSegment(request, destination, segment);
+  return writeEndSegment(destination, segment.parentFormatContext);
+}
+
+function flushCompletedBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+    flushPartiallyCompletedSegment(request, destination, boundary, segment);
+  }
+
+  completedSegments.length = 0;
+
+  {
+    writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+
+  return writeCompletedBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.resources);
+}
+
+function flushPartialBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+
+    if (!flushPartiallyCompletedSegment(request, destination, boundary, segment)) {
+      i++;
+      completedSegments.splice(0, i); // Only write as much as the buffer wants. Something higher priority
+      // might want to write later.
+
+      return false;
+    }
+  }
+
+  completedSegments.splice(0, i);
+
+  {
+    // The way this is structured we only write resources for partial boundaries
+    // if there is no backpressure. Later before we complete the boundary we
+    // will write resources regardless of backpressure before we emit the
+    // completion instruction
+    return writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+}
+
+function flushPartiallyCompletedSegment(request, destination, boundary, segment) {
+  if (segment.status === FLUSHED) {
+    // We've already flushed this inline.
+    return true;
+  }
+
+  const segmentID = segment.id;
+
+  if (segmentID === -1) {
+    // This segment wasn't previously referred to. This happens at the root of
+    // a boundary. We make kind of a leap here and assume this is the root.
+    const rootSegmentID = segment.id = boundary.rootSegmentID;
+
+    if (rootSegmentID === -1) {
+      throw new Error('A root segment ID must have been assigned by now. This is a bug in React.');
+    }
+
+    return flushSegmentContainer(request, destination, segment);
+  } else if (segmentID === boundary.rootSegmentID) {
+    // When we emit postponed boundaries, we might have assigned the ID already
+    // but it's still the root segment so we can't inject it into the parent yet.
+    return flushSegmentContainer(request, destination, segment);
+  } else {
+    flushSegmentContainer(request, destination, segment);
+    return writeCompletedSegmentInstruction(destination, request.resumableState, request.renderState, segmentID);
+  }
+}
+
+function flushCompletedQueues(request, destination) {
+  beginWriting();
+
+  try {
+    // The structure of this is to go through each queue one by one and write
+    // until the sink tells us to stop. When we should stop, we still finish writing
+    // that item fully and then yield. At that point we remove the already completed
+    // items up until the point we completed them.
+    let i;
+    const completedRootSegment = request.completedRootSegment;
+
+    if (completedRootSegment !== null) {
+      if (completedRootSegment.status === POSTPONED) {
+        // We postponed the root, so we write nothing.
+        return;
+      } else if (request.pendingRootTasks === 0) {
+        if (enableFloat) {
+          writePreamble(destination, request.resumableState, request.renderState, request.allPendingTasks === 0 && request.trackedPostpones === null);
+        }
+
+        flushSegment(request, destination, completedRootSegment);
+        request.completedRootSegment = null;
+        writeCompletedRoot(destination, request.renderState, request.resumableState);
+      } else {
+        // We haven't flushed the root yet so we don't need to check any other branches further down
+        return;
+      }
+    }
+
+    if (enableFloat) {
+      writeHoistables(destination, request.resumableState, request.renderState);
+    } // We emit client rendering instructions for already emitted boundaries first.
+    // This is so that we can signal to the client to start client rendering them as
+    // soon as possible.
+
+
+    const clientRenderedBoundaries = request.clientRenderedBoundaries;
+
+    for (i = 0; i < clientRenderedBoundaries.length; i++) {
+      const boundary = clientRenderedBoundaries[i];
+
+      if (!flushClientRenderedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        clientRenderedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    clientRenderedBoundaries.splice(0, i); // Next we emit any complete boundaries. It's better to favor boundaries
+    // that are completely done since we can actually show them, than it is to emit
+    // any individual segments from a partially complete boundary.
+
+    const completedBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < completedBoundaries.length; i++) {
+      const boundary = completedBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        completedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    completedBoundaries.splice(0, i); // Allow anything written so far to flush to the underlying sink before
+    // we continue with lower priorities.
+
+    completeWriting(destination);
+    beginWriting(destination); // TODO: Here we'll emit data used by hydration.
+    // Next we emit any segments of any boundaries that are partially complete
+    // but not deeply complete.
+
+    const partialBoundaries = request.partialBoundaries;
+
+    for (i = 0; i < partialBoundaries.length; i++) {
+      const boundary = partialBoundaries[i];
+
+      if (!flushPartialBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        partialBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    partialBoundaries.splice(0, i); // Next we check the completed boundaries again. This may have had
+    // boundaries added to it in case they were too larged to be inlined.
+    // New ones might be added in this loop.
+
+    const largeBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < largeBoundaries.length; i++) {
+      const boundary = largeBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        largeBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    largeBoundaries.splice(0, i);
+  } finally {
+    if (request.allPendingTasks === 0 && request.pingedTasks.length === 0 && request.clientRenderedBoundaries.length === 0 && request.completedBoundaries.length === 0 // We don't need to check any partially completed segments because
+    // either they have pending task or they're complete.
+    ) {
+        request.flushScheduled = false;
+
+        {
+          // We write the trailing tags but only if don't have any data to resume.
+          // If we need to resume we'll write the postamble in the resume instead.
+          {
+            writePostamble(destination, request.resumableState);
+          }
+        }
+
+        completeWriting(destination);
+
+
+        close(destination); // We need to stop flowing now because we do not want any async contexts which might call
+        // float methods to initiate any flushes after this point
+
+        stopFlowing(request);
+      } else {
+      completeWriting(destination);
+    }
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  if (supportsRequestStorage) {
+    scheduleWork(() => requestStorage.run(request, performWork, request));
+  } else {
+    scheduleWork(() => performWork(request));
+  }
+
+  if (request.trackedPostpones === null) {
+    // this is either a regular render or a resume. For regular render we want
+    // to call emitEarlyPreloads after the first performWork because we want
+    // are responding to a live request and need to balance sending something early
+    // (i.e. don't want for the shell to finish) but we need something to send.
+    // The only implementation of this is for DOM at the moment and during resumes nothing
+    // actually emits but the code paths here are the same.
+    // During a prerender we don't want to be too aggressive in emitting early preloads
+    // because we aren't responding to a live request and we can wait for the prerender to
+    // postpone before we emit anything.
+    if (supportsRequestStorage) {
+      scheduleWork(() => requestStorage.run(request, enqueueEarlyPreloadsAfterInitialWork, request));
+    } else {
+      scheduleWork(() => enqueueEarlyPreloadsAfterInitialWork(request));
+    }
+  }
+}
+
+function enqueueEarlyPreloadsAfterInitialWork(request) {
+  const shellComplete = request.pendingRootTasks === 0;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    request.flushScheduled = true;
+    scheduleWork(() => {
+      // We need to existence check destination again here because it might go away
+      // in between the enqueueFlush call and the work execution
+      const destination = request.destination;
+
+      if (destination) {
+        flushCompletedQueues(request, destination);
+      } else {
+        request.flushScheduled = false;
+      }
+    });
+  }
+} // This function is intented to only be called during the pipe function for the Node builds.
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedQueues(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function stopFlowing(request) {
+  request.destination = null;
+} // This is called to early terminate a request. It puts all pending boundaries in client rendered state.
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+      abortableTasks.forEach(task => abortTask(task, request, error));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function flushResources(request) {
+  enqueueFlush(request);
+}
+function getFormState(request) {
+  return request.formState;
+}
+function getResumableState(request) {
+  return request.resumableState;
+}
+function getRenderState(request) {
+  return request.renderState;
+}
+
+function renderToReadableStream(children, options) {
+  return new Promise((resolve, reject) => {
+    let onFatalError;
+    let onAllReady;
+    const allReady = new Promise((res, rej) => {
+      onAllReady = res;
+      onFatalError = rej;
+    });
+
+    function onShellReady() {
+      const stream = new ReadableStream({
+        type: 'bytes',
+        pull: controller => {
+          startFlowing(request, controller);
+        },
+        cancel: reason => {
+          stopFlowing(request);
+          abort(request, reason);
+        }
+      }, // $FlowFixMe[prop-missing] size() methods are not allowed on byte streams.
+      {
+        highWaterMark: 0
+      }); // TODO: Move to sub-classing ReadableStream.
+
+      stream.allReady = allReady;
+      resolve(stream);
+    }
+
+    function onShellError(error) {
+      // If the shell errors the caller of `renderToReadableStream` won't have access to `allReady`.
+      // However, `allReady` will be rejected by `onFatalError` as well.
+      // So we need to catch the duplicate, uncatchable fatal error in `allReady` to prevent a `UnhandledPromiseRejection`.
+      allReady.catch(() => {});
+      reject(error);
+    }
+
+    const onHeaders = options ? options.onHeaders : undefined;
+    let onHeadersImpl;
+
+    if (onHeaders) {
+      onHeadersImpl = headersDescriptor => {
+        onHeaders(new Headers(headersDescriptor));
+      };
+    }
+
+    const resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined);
+    const request = createRequest(children, resumableState, createRenderState(resumableState, options ? options.nonce : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, onHeadersImpl, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, onShellReady, onShellError, onFatalError, options ? options.onPostpone : undefined, options ? options.formState : undefined);
+
+    if (options && options.signal) {
+      const signal = options.signal;
+
+      if (signal.aborted) {
+        abort(request, signal.reason);
+      } else {
+        const listener = () => {
+          abort(request, signal.reason);
+          signal.removeEventListener('abort', listener);
+        };
+
+        signal.addEventListener('abort', listener);
+      }
+    }
+
+    startWork(request);
+  });
+}
+
+exports.renderToReadableStream = renderToReadableStream;
+exports.version = ReactVersion;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom-server.edge.production.min.js b/packages/next/src/compiled/react-dom/cjs/react-dom-server.edge.production.min.js
index 19b765a7a057a..770c2990ed1d3 100644
--- a/packages/next/src/compiled/react-dom/cjs/react-dom-server.edge.production.min.js
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom-server.edge.production.min.js
@@ -1,13 +1,11 @@
-/**
- * @license React
- * react-dom-server.edge.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
 /*
+ React
+ react-dom-server.edge.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
 
 
  JS Implementation of MurmurHash3 (r136) (as of May 20, 2011)
@@ -34,7 +32,7 @@
 'use strict';var aa=require("next/dist/compiled/react"),ca=require("react-dom");
 function da(a,b){var c=a.length&3;var d=a.length-c;var e=b;for(b=0;b<d;){var f=a.charCodeAt(b)&255|(a.charCodeAt(++b)&255)<<8|(a.charCodeAt(++b)&255)<<16|(a.charCodeAt(++b)&255)<<24;++b;f=3432918353*(f&65535)+((3432918353*(f>>>16)&65535)<<16)&4294967295;f=f<<15|f>>>17;f=461845907*(f&65535)+((461845907*(f>>>16)&65535)<<16)&4294967295;e^=f;e=e<<13|e>>>19;e=5*(e&65535)+((5*(e>>>16)&65535)<<16)&4294967295;e=(e&65535)+27492+(((e>>>16)+58964&65535)<<16)}f=0;switch(c){case 3:f^=(a.charCodeAt(b+2)&255)<<
 16;case 2:f^=(a.charCodeAt(b+1)&255)<<8;case 1:f^=a.charCodeAt(b)&255,f=3432918353*(f&65535)+((3432918353*(f>>>16)&65535)<<16)&4294967295,f=f<<15|f>>>17,e^=461845907*(f&65535)+((461845907*(f>>>16)&65535)<<16)&4294967295}e^=a.length;e^=e>>>16;e=2246822507*(e&65535)+((2246822507*(e>>>16)&65535)<<16)&4294967295;e^=e>>>13;e=3266489909*(e&65535)+((3266489909*(e>>>16)&65535)<<16)&4294967295;return(e^e>>>16)>>>0}var k=null,m=0;
-function r(a,b){if(0!==b.byteLength)if(512<b.byteLength)0<m&&(a.enqueue(new Uint8Array(k.buffer,0,m)),k=new Uint8Array(512),m=0),a.enqueue(b);else{var c=k.length-m;c<b.byteLength&&(0===c?a.enqueue(k):(k.set(b.subarray(0,c),m),a.enqueue(k),b=b.subarray(c)),k=new Uint8Array(512),m=0);k.set(b,m);m+=b.byteLength}}function v(a,b){r(a,b);return!0}function ia(a){k&&0<m&&(a.enqueue(new Uint8Array(k.buffer,0,m)),k=null,m=0)}var ja=new TextEncoder;function w(a){return ja.encode(a)}
+function p(a,b){if(0!==b.byteLength)if(512<b.byteLength)0<m&&(a.enqueue(new Uint8Array(k.buffer,0,m)),k=new Uint8Array(512),m=0),a.enqueue(b);else{var c=k.length-m;c<b.byteLength&&(0===c?a.enqueue(k):(k.set(b.subarray(0,c),m),a.enqueue(k),b=b.subarray(c)),k=new Uint8Array(512),m=0);k.set(b,m);m+=b.byteLength}}function v(a,b){p(a,b);return!0}function ia(a){k&&0<m&&(a.enqueue(new Uint8Array(k.buffer,0,m)),k=null,m=0)}var ja=new TextEncoder;function w(a){return ja.encode(a)}
 function x(a){return ja.encode(a)}function oa(a,b){"function"===typeof a.error?a.error(b):a.close()}
 var y=Object.assign,C=Object.prototype.hasOwnProperty,pa=RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"),va={},wa={};
 function xa(a){if(C.call(wa,a))return!0;if(C.call(va,a))return!1;if(pa.test(a))return wa[a]=!0;va[a]=!0;return!1}
@@ -48,12 +46,12 @@ new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv","http
 function F(a){if("boolean"===typeof a||"number"===typeof a)return""+a;a=""+a;var b=Ga.exec(a);if(b){var c="",d,e=0;for(d=b.index;d<a.length;d++){switch(a.charCodeAt(d)){case 34:b="&quot;";break;case 38:b="&amp;";break;case 39:b="&#x27;";break;case 60:b="&lt;";break;case 62:b="&gt;";break;default:continue}e!==d&&(c+=a.slice(e,d));e=d+1;c+=b}a=e!==d?c+a.slice(e,d):c}return a}
 var Ha=/([A-Z])/g,Ia=/^ms-/,Ja=Array.isArray,Ka=aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,Ra={pending:!1,data:null,method:null,action:null},Sa=ca.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Dispatcher,$a={prefetchDNS:Ta,preconnect:Ua,preload:Va,preloadModule:Wa,preinitStyle:Xa,preinitScript:Ya,preinitModuleScript:Za},J=[],nb=x('"></template>'),ob=x("<script>"),pb=x("\x3c/script>"),qb=x('<script src="'),rb=x('<script type="module" src="'),sb=x('" nonce="'),tb=x('" integrity="'),
 ub=x('" crossorigin="'),vb=x('" async="">\x3c/script>'),wb=/(<\/|<)(s)(cript)/gi;function xb(a,b,c,d){return""+b+("s"===c?"\\u0073":"\\u0053")+d}var yb=x('<script type="importmap">'),Hb=x("\x3c/script>");
-function Ib(a,b,c,d,e,f,g,h,l){var n=void 0===b?ob:x('<script nonce="'+F(b)+'">'),q=a.idPrefix,t=[],p=null;void 0!==c&&t.push(n,w((""+c).replace(wb,xb)),pb);void 0!==f&&("string"===typeof f?(p={src:f,chunks:[]},Jb(p.chunks,{src:f,async:!0,integrity:void 0,nonce:b})):(p={src:f.src,chunks:[]},Jb(p.chunks,{src:f.src,async:!0,integrity:f.integrity,nonce:b})));c=[];void 0!==g&&(c.push(yb),c.push(w((""+JSON.stringify(g)).replace(wb,xb))),c.push(Hb));g=h?{preconnects:"",fontPreloads:"",highImagePreloads:"",
-remainingCapacity:"number"===typeof l?l:2E3}:null;h={placeholderPrefix:x(q+"P:"),segmentPrefix:x(q+"S:"),boundaryPrefix:x(q+"B:"),startInlineScript:n,htmlChunks:null,headChunks:null,externalRuntimeScript:p,bootstrapChunks:t,onHeaders:h,headers:g,resets:{font:{},dns:{},connect:{default:{},anonymous:{},credentials:{}},image:{},style:{}},charsetChunks:[],preconnectChunks:[],importMapChunks:c,preloadChunks:[],hoistableChunks:[],preconnects:new Set,fontPreloads:new Set,highImagePreloads:new Set,styles:new Map,
-bootstrapScripts:new Set,scripts:new Set,bulkPreloads:new Set,preloads:{images:new Map,stylesheets:new Map,scripts:new Map,moduleScripts:new Map},nonce:b,boundaryResources:null,stylesToHoist:!1};if(void 0!==d)for(n=0;n<d.length;n++)c=d[n],g=p=void 0,l={rel:"preload",as:"script",fetchPriority:"low",nonce:b},"string"===typeof c?l.href=q=c:(l.href=q=c.src,l.integrity=g="string"===typeof c.integrity?c.integrity:void 0,l.crossOrigin=p="string"===typeof c||null==c.crossOrigin?void 0:"use-credentials"===
-c.crossOrigin?"use-credentials":""),c=a,f=q,c.scriptResources[f]=null,c.moduleScriptResources[f]=null,c=[],L(c,l),h.bootstrapScripts.add(c),t.push(qb,w(F(q))),b&&t.push(sb,w(F(b))),"string"===typeof g&&t.push(tb,w(F(g))),"string"===typeof p&&t.push(ub,w(F(p))),t.push(vb);if(void 0!==e)for(d=0;d<e.length;d++)l=e[d],p=q=void 0,g={rel:"modulepreload",fetchPriority:"low",nonce:b},"string"===typeof l?g.href=n=l:(g.href=n=l.src,g.integrity=p="string"===typeof l.integrity?l.integrity:void 0,g.crossOrigin=
-q="string"===typeof l||null==l.crossOrigin?void 0:"use-credentials"===l.crossOrigin?"use-credentials":""),l=a,c=n,l.scriptResources[c]=null,l.moduleScriptResources[c]=null,l=[],L(l,g),h.bootstrapScripts.add(l),t.push(rb,w(F(n))),b&&t.push(sb,w(F(b))),"string"===typeof p&&t.push(tb,w(F(p))),"string"===typeof q&&t.push(ub,w(F(q))),t.push(vb);return h}
-function Kb(a,b){var c=0;void 0!==b&&(c=1);return{idPrefix:void 0===a?"":a,nextFormID:0,streamingFormat:c,instructions:0,hasBody:!1,hasHtml:!1,unknownResources:{},dnsResources:{},connectResources:{default:{},anonymous:{},credentials:{}},imageResources:{},styleResources:{},scriptResources:{},moduleUnknownResources:{},moduleScriptResources:{}}}function M(a,b,c){return{insertionMode:a,selectedValue:b,tagScope:c}}
+function Ib(a,b,c,d,e,f){var g=void 0===b?ob:x('<script nonce="'+F(b)+'">'),h=a.idPrefix,l=[],n=null,q=a.bootstrapScriptContent,t=a.bootstrapScripts,r=a.bootstrapModules;void 0!==q&&l.push(g,w((""+q).replace(wb,xb)),pb);void 0!==c&&("string"===typeof c?(n={src:c,chunks:[]},Jb(n.chunks,{src:c,async:!0,integrity:void 0,nonce:b})):(n={src:c.src,chunks:[]},Jb(n.chunks,{src:c.src,async:!0,integrity:c.integrity,nonce:b})));c=[];void 0!==d&&(c.push(yb),c.push(w((""+JSON.stringify(d)).replace(wb,xb))),c.push(Hb));
+d=e?{preconnects:"",fontPreloads:"",highImagePreloads:"",remainingCapacity:"number"===typeof f?f:2E3}:null;e={placeholderPrefix:x(h+"P:"),segmentPrefix:x(h+"S:"),boundaryPrefix:x(h+"B:"),startInlineScript:g,htmlChunks:null,headChunks:null,externalRuntimeScript:n,bootstrapChunks:l,onHeaders:e,headers:d,resets:{font:{},dns:{},connect:{default:{},anonymous:{},credentials:{}},image:{},style:{}},charsetChunks:[],preconnectChunks:[],importMapChunks:c,preloadChunks:[],hoistableChunks:[],preconnects:new Set,
+fontPreloads:new Set,highImagePreloads:new Set,styles:new Map,bootstrapScripts:new Set,scripts:new Set,bulkPreloads:new Set,preloads:{images:new Map,stylesheets:new Map,scripts:new Map,moduleScripts:new Map},nonce:b,boundaryResources:null,stylesToHoist:!1};if(void 0!==t)for(g=0;g<t.length;g++)c=t[g],d=n=void 0,f={rel:"preload",as:"script",fetchPriority:"low",nonce:b},"string"===typeof c?f.href=h=c:(f.href=h=c.src,f.integrity=d="string"===typeof c.integrity?c.integrity:void 0,f.crossOrigin=n="string"===
+typeof c||null==c.crossOrigin?void 0:"use-credentials"===c.crossOrigin?"use-credentials":""),c=a,q=h,c.scriptResources[q]=null,c.moduleScriptResources[q]=null,c=[],L(c,f),e.bootstrapScripts.add(c),l.push(qb,w(F(h))),b&&l.push(sb,w(F(b))),"string"===typeof d&&l.push(tb,w(F(d))),"string"===typeof n&&l.push(ub,w(F(n))),l.push(vb);if(void 0!==r)for(t=0;t<r.length;t++)f=r[t],n=h=void 0,d={rel:"modulepreload",fetchPriority:"low",nonce:b},"string"===typeof f?d.href=g=f:(d.href=g=f.src,d.integrity=n="string"===
+typeof f.integrity?f.integrity:void 0,d.crossOrigin=h="string"===typeof f||null==f.crossOrigin?void 0:"use-credentials"===f.crossOrigin?"use-credentials":""),f=a,c=g,f.scriptResources[c]=null,f.moduleScriptResources[c]=null,f=[],L(f,d),e.bootstrapScripts.add(f),l.push(rb,w(F(g))),b&&l.push(sb,w(F(b))),"string"===typeof n&&l.push(tb,w(F(n))),"string"===typeof h&&l.push(ub,w(F(h))),l.push(vb);return e}
+function Kb(a,b,c,d,e){var f=0;void 0!==b&&(f=1);return{idPrefix:void 0===a?"":a,nextFormID:0,streamingFormat:f,bootstrapScriptContent:c,bootstrapScripts:d,bootstrapModules:e,instructions:0,hasBody:!1,hasHtml:!1,unknownResources:{},dnsResources:{},connectResources:{default:{},anonymous:{},credentials:{}},imageResources:{},styleResources:{},scriptResources:{},moduleUnknownResources:{},moduleScriptResources:{}}}function M(a,b,c){return{insertionMode:a,selectedValue:b,tagScope:c}}
 function Lb(a){return M("http://www.w3.org/2000/svg"===a?3:"http://www.w3.org/1998/Math/MathML"===a?4:0,null,0)}
 function Mb(a,b,c){switch(b){case "noscript":return M(2,null,a.tagScope|1);case "select":return M(2,null!=c.value?c.value:c.defaultValue,a.tagScope);case "svg":return M(3,null,a.tagScope);case "picture":return M(2,null,a.tagScope|2);case "math":return M(4,null,a.tagScope);case "foreignObject":return M(2,null,a.tagScope);case "table":return M(5,null,a.tagScope);case "thead":case "tbody":case "tfoot":return M(6,null,a.tagScope);case "colgroup":return M(8,null,a.tagScope);case "tr":return M(7,null,a.tagScope)}return 5<=
 a.insertionMode?M(2,null,a.tagScope):0===a.insertionMode?"html"===b?M(1,null,a.tagScope):M(2,null,a.tagScope):1===a.insertionMode?M(2,null,a.tagScope):a}var Nb=x("\x3c!-- --\x3e");function Ob(a,b,c,d){if(""===b)return d;d&&a.push(Nb);a.push(w(F(b)));return!0}var Pb=new Map,Qb=x(' style="'),Rb=x(":"),Sb=x(";");
@@ -75,8 +73,8 @@ function uc(a,b,c){a.push(V(c));for(var d in b)if(C.call(b,d)){var e=b[d];if(nul
 function vc(a,b){a.push(V("title"));var c=null,d=null,e;for(e in b)if(C.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:T(a,e,f)}}a.push(U);b=Array.isArray(c)?2>c.length?c[0]:null:c;"function"!==typeof b&&"symbol"!==typeof b&&null!==b&&void 0!==b&&a.push(w(F(""+b)));dc(a,d,c);a.push(wc("title"));return null}
 function Jb(a,b){a.push(V("script"));var c=null,d=null,e;for(e in b)if(C.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:T(a,e,f)}}a.push(U);dc(a,d,c);"string"===typeof c&&a.push(w(F(c)));a.push(wc("script"));return null}
 function xc(a,b,c){a.push(V(c));var d=c=null,e;for(e in b)if(C.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:T(a,e,f)}}a.push(U);dc(a,d,c);return"string"===typeof c?(a.push(w(F(c))),null):c}var yc=x("\n"),zc=/^[a-zA-Z][a-zA-Z:_\.\-\d]*$/,Ac=new Map;function V(a){var b=Ac.get(a);if(void 0===b){if(!zc.test(a))throw Error("Invalid tag: "+a);b=x("<"+a);Ac.set(a,b)}return b}var Bc=x("<!DOCTYPE html>");
-function Cc(a,b,c,d,e,f,g){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "select":a.push(V("select"));var h=null,l=null,n;for(n in c)if(C.call(c,n)){var q=c[n];if(null!=q)switch(n){case "children":h=q;break;case "dangerouslySetInnerHTML":l=q;break;case "defaultValue":case "value":break;default:T(a,n,q)}}a.push(U);dc(a,l,h);return h;case "option":var t=f.selectedValue;a.push(V("option"));var p=null,z=null,A=null,R=null,u;for(u in c)if(C.call(c,
-u)){var B=c[u];if(null!=B)switch(u){case "children":p=B;break;case "selected":A=B;break;case "dangerouslySetInnerHTML":R=B;break;case "value":z=B;default:T(a,u,B)}}if(null!=t){var G=null!==z?""+z:ec(p);if(Ja(t))for(var ka=0;ka<t.length;ka++){if(""+t[ka]===G){a.push(fc);break}}else""+t===G&&a.push(fc)}else A&&a.push(fc);a.push(U);dc(a,R,p);return p;case "textarea":a.push(V("textarea"));var D=null,W=null,E=null,ea;for(ea in c)if(C.call(c,ea)){var S=c[ea];if(null!=S)switch(ea){case "children":E=S;break;
+function Cc(a,b,c,d,e,f,g){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "select":a.push(V("select"));var h=null,l=null,n;for(n in c)if(C.call(c,n)){var q=c[n];if(null!=q)switch(n){case "children":h=q;break;case "dangerouslySetInnerHTML":l=q;break;case "defaultValue":case "value":break;default:T(a,n,q)}}a.push(U);dc(a,l,h);return h;case "option":var t=f.selectedValue;a.push(V("option"));var r=null,z=null,A=null,R=null,u;for(u in c)if(C.call(c,
+u)){var B=c[u];if(null!=B)switch(u){case "children":r=B;break;case "selected":A=B;break;case "dangerouslySetInnerHTML":R=B;break;case "value":z=B;default:T(a,u,B)}}if(null!=t){var G=null!==z?""+z:ec(r);if(Ja(t))for(var ka=0;ka<t.length;ka++){if(""+t[ka]===G){a.push(fc);break}}else""+t===G&&a.push(fc)}else A&&a.push(fc);a.push(U);dc(a,R,r);return r;case "textarea":a.push(V("textarea"));var D=null,W=null,E=null,ea;for(ea in c)if(C.call(c,ea)){var S=c[ea];if(null!=S)switch(ea){case "children":E=S;break;
 case "value":D=S;break;case "defaultValue":W=S;break;case "dangerouslySetInnerHTML":throw Error("`dangerouslySetInnerHTML` does not make sense on <textarea>.");default:T(a,ea,S)}}null===D&&null!==W&&(D=W);a.push(U);if(null!=E){if(null!=D)throw Error("If you supply `defaultValue` on a <textarea>, do not pass children.");if(Ja(E)){if(1<E.length)throw Error("<textarea> can only have at most one child.");D=""+E[0]}D=""+E}"string"===typeof D&&"\n"===D[0]&&a.push(yc);null!==D&&a.push(w(F(""+D)));return null;
 case "input":a.push(V("input"));var la=null,O=null,H=null,ma=null,ya=null,qa=null,ra=null,sa=null,La=null,fa;for(fa in c)if(C.call(c,fa)){var ba=c[fa];if(null!=ba)switch(fa){case "children":case "dangerouslySetInnerHTML":throw Error("input is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");case "name":la=ba;break;case "formAction":O=ba;break;case "formEncType":H=ba;break;case "formMethod":ma=ba;break;case "formTarget":ya=ba;break;case "defaultChecked":La=ba;
 break;case "defaultValue":ra=ba;break;case "checked":sa=ba;break;case "value":qa=ba;break;default:T(a,fa,ba)}}var rd=bc(a,d,e,O,H,ma,ya,la);null!==sa?Wb(a,"checked",sa):null!==La&&Wb(a,"checked",La);null!==qa?T(a,"value",qa):null!==ra&&T(a,"value",ra);a.push(ac);null!==rd&&rd.forEach($b,a);return null;case "button":a.push(V("button"));var ab=null,sd=null,td=null,ud=null,vd=null,wd=null,xd=null,bb;for(bb in c)if(C.call(c,bb)){var na=c[bb];if(null!=na)switch(bb){case "children":ab=na;break;case "dangerouslySetInnerHTML":sd=
@@ -94,27 +92,27 @@ e.highImagePreloads.add(Ca)}else if(!d.imageResources.hasOwnProperty(Pa)){d.imag
 sc.length))?(e.resets.image[Pa]=J,ha.highImagePreloads&&(ha.highImagePreloads+=", "),ha.highImagePreloads+=sc):(Ca=[],L(Ca,{rel:"preload",as:"image",href:I?void 0:K,imageSrcSet:I,imageSizes:Nd,crossOrigin:Od,integrity:c.integrity,type:c.type,fetchPriority:c.fetchPriority,referrerPolicy:c.referrerPolicy}),"high"===c.fetchPriority||10>e.highImagePreloads.size?e.highImagePreloads.add(Ca):(e.bulkPreloads.add(Ca),qc.set(Pa,Ca)))}}return uc(a,c,"img");case "base":case "area":case "br":case "col":case "embed":case "hr":case "keygen":case "param":case "source":case "track":case "wbr":return uc(a,
 c,b);case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph":break;case "head":if(2>f.insertionMode&&null===e.headChunks){e.headChunks=[];var Pd=xc(e.headChunks,c,"head")}else Pd=xc(a,c,"head");return Pd;case "html":if(0===f.insertionMode&&null===e.htmlChunks){e.htmlChunks=[Bc];var Qd=xc(e.htmlChunks,c,"html")}else Qd=xc(a,c,"html");return Qd;default:if(-1!==b.indexOf("-")){a.push(V(b));
 var tc=null,Rd=null,Qa;for(Qa in c)if(C.call(c,Qa)){var Da=c[Qa];if(null!=Da){var qf=Qa;switch(Qa){case "children":tc=Da;break;case "dangerouslySetInnerHTML":Rd=Da;break;case "style":Tb(a,Da);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":break;default:xa(Qa)&&"function"!==typeof Da&&"symbol"!==typeof Da&&a.push(P,w(qf),Ub,w(F(Da)),N)}}}a.push(U);dc(a,Rd,tc);return tc}}return xc(a,c,b)}var Ec=new Map;
-function wc(a){var b=Ec.get(a);void 0===b&&(b=x("</"+a+">"),Ec.set(a,b));return b}function Fc(a,b){b=b.bootstrapChunks;for(var c=0;c<b.length-1;c++)r(a,b[c]);return c<b.length?(c=b[c],b.length=0,v(a,c)):!0}var Gc=x('<template id="'),Hc=x('"></template>'),Ic=x("\x3c!--$--\x3e"),Jc=x('\x3c!--$?--\x3e<template id="'),Kc=x('"></template>'),Lc=x("\x3c!--$!--\x3e"),Mc=x("\x3c!--/$--\x3e"),Nc=x("<template"),Oc=x('"'),Pc=x(' data-dgst="');x(' data-msg="');x(' data-stck="');var Qc=x("></template>");
-function Rc(a,b,c){r(a,Jc);if(null===c)throw Error("An ID must have been assigned before we can complete the boundary.");r(a,b.boundaryPrefix);r(a,w(c.toString(16)));return v(a,Kc)}
+function wc(a){var b=Ec.get(a);void 0===b&&(b=x("</"+a+">"),Ec.set(a,b));return b}function Fc(a,b,c){c.bootstrapScriptContent=void 0;c.bootstrapScripts=void 0;c.bootstrapModules=void 0;b=b.bootstrapChunks;for(c=0;c<b.length-1;c++)p(a,b[c]);return c<b.length?(c=b[c],b.length=0,v(a,c)):!0}var Gc=x('<template id="'),Hc=x('"></template>'),Ic=x("\x3c!--$--\x3e"),Jc=x('\x3c!--$?--\x3e<template id="'),Kc=x('"></template>'),Lc=x("\x3c!--$!--\x3e"),Mc=x("\x3c!--/$--\x3e"),Nc=x("<template"),Oc=x('"'),Pc=x(' data-dgst="');
+x(' data-msg="');x(' data-stck="');var Qc=x("></template>");function Rc(a,b,c){p(a,Jc);if(null===c)throw Error("An ID must have been assigned before we can complete the boundary.");p(a,b.boundaryPrefix);p(a,w(c.toString(16)));return v(a,Kc)}
 var Sc=x('<div hidden id="'),Tc=x('">'),Uc=x("</div>"),Vc=x('<svg aria-hidden="true" style="display:none" id="'),Wc=x('">'),Xc=x("</svg>"),Yc=x('<math aria-hidden="true" style="display:none" id="'),Zc=x('">'),$c=x("</math>"),ad=x('<table hidden id="'),bd=x('">'),cd=x("</table>"),dd=x('<table hidden><tbody id="'),ed=x('">'),fd=x("</tbody></table>"),gd=x('<table hidden><tr id="'),hd=x('">'),id=x("</tr></table>"),jd=x('<table hidden><colgroup id="'),kd=x('">'),ld=x("</colgroup></table>");
-function md(a,b,c,d){switch(c.insertionMode){case 0:case 1:case 2:return r(a,Sc),r(a,b.segmentPrefix),r(a,w(d.toString(16))),v(a,Tc);case 3:return r(a,Vc),r(a,b.segmentPrefix),r(a,w(d.toString(16))),v(a,Wc);case 4:return r(a,Yc),r(a,b.segmentPrefix),r(a,w(d.toString(16))),v(a,Zc);case 5:return r(a,ad),r(a,b.segmentPrefix),r(a,w(d.toString(16))),v(a,bd);case 6:return r(a,dd),r(a,b.segmentPrefix),r(a,w(d.toString(16))),v(a,ed);case 7:return r(a,gd),r(a,b.segmentPrefix),r(a,w(d.toString(16))),v(a,hd);
-case 8:return r(a,jd),r(a,b.segmentPrefix),r(a,w(d.toString(16))),v(a,kd);default:throw Error("Unknown insertion mode. This is a bug in React.");}}function nd(a,b){switch(b.insertionMode){case 0:case 1:case 2:return v(a,Uc);case 3:return v(a,Xc);case 4:return v(a,$c);case 5:return v(a,cd);case 6:return v(a,fd);case 7:return v(a,id);case 8:return v(a,ld);default:throw Error("Unknown insertion mode. This is a bug in React.");}}
+function md(a,b,c,d){switch(c.insertionMode){case 0:case 1:case 2:return p(a,Sc),p(a,b.segmentPrefix),p(a,w(d.toString(16))),v(a,Tc);case 3:return p(a,Vc),p(a,b.segmentPrefix),p(a,w(d.toString(16))),v(a,Wc);case 4:return p(a,Yc),p(a,b.segmentPrefix),p(a,w(d.toString(16))),v(a,Zc);case 5:return p(a,ad),p(a,b.segmentPrefix),p(a,w(d.toString(16))),v(a,bd);case 6:return p(a,dd),p(a,b.segmentPrefix),p(a,w(d.toString(16))),v(a,ed);case 7:return p(a,gd),p(a,b.segmentPrefix),p(a,w(d.toString(16))),v(a,hd);
+case 8:return p(a,jd),p(a,b.segmentPrefix),p(a,w(d.toString(16))),v(a,kd);default:throw Error("Unknown insertion mode. This is a bug in React.");}}function nd(a,b){switch(b.insertionMode){case 0:case 1:case 2:return v(a,Uc);case 3:return v(a,Xc);case 4:return v(a,$c);case 5:return v(a,cd);case 6:return v(a,fd);case 7:return v(a,id);case 8:return v(a,ld);default:throw Error("Unknown insertion mode. This is a bug in React.");}}
 var od=x('$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};$RS("'),pd=x('$RS("'),qd=x('","'),Sd=x('")\x3c/script>'),Td=x('<template data-rsi="" data-sid="'),Ud=x('" data-pid="'),Vd=x('$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};$RC("'),
 Wd=x('$RC("'),Xd=x('$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};$RR("'),
 Yd=x('$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};$RR("'),
 Zd=x('$RR("'),$d=x('","'),ae=x('",'),be=x('"'),ce=x(")\x3c/script>"),de=x('<template data-rci="" data-bid="'),ee=x('<template data-rri="" data-bid="'),fe=x('" data-sid="'),ge=x('" data-sty="'),he=x('$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};;$RX("'),ie=x('$RX("'),je=x('"'),ke=x(","),le=x(")\x3c/script>"),me=x('<template data-rxi="" data-bid="'),ne=x('" data-dgst="'),
 oe=x('" data-msg="'),pe=x('" data-stck="'),qe=/[<\u2028\u2029]/g;function re(a){return JSON.stringify(a).replace(qe,function(b){switch(b){case "<":return"\\u003c";case "\u2028":return"\\u2028";case "\u2029":return"\\u2029";default:throw Error("escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}})}var se=/[&><\u2028\u2029]/g;
 function te(a){return JSON.stringify(a).replace(se,function(b){switch(b){case "&":return"\\u0026";case ">":return"\\u003e";case "<":return"\\u003c";case "\u2028":return"\\u2028";case "\u2029":return"\\u2029";default:throw Error("escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}})}
-var ue=x('<style media="not all" data-precedence="'),ve=x('" data-href="'),we=x('">'),xe=x("</style>"),ye=!1,ze=!0;function Ae(a){var b=a.rules,c=a.hrefs,d=0;if(c.length){r(this,ue);r(this,a.precedence);for(r(this,ve);d<c.length-1;d++)r(this,c[d]),r(this,Be);r(this,c[d]);r(this,we);for(d=0;d<b.length;d++)r(this,b[d]);ze=v(this,xe);ye=!0;b.length=0;c.length=0}}function Ce(a){return 2!==a.state?ye=!0:!1}
-function De(a,b,c){ye=!1;ze=!0;b.styles.forEach(Ae,a);b.stylesheets.forEach(Ce);ye&&(c.stylesToHoist=!0);return ze}function Ee(a){for(var b=0;b<a.length;b++)r(this,a[b]);a.length=0}var Fe=[];function Ge(a){L(Fe,a.props);for(var b=0;b<Fe.length;b++)r(this,Fe[b]);Fe.length=0;a.state=2}var He=x('<style data-precedence="'),Ie=x('" data-href="'),Be=x(" "),Je=x('">'),Ke=x("</style>");
-function Le(a){var b=0<a.sheets.size;a.sheets.forEach(Ge,this);a.sheets.clear();var c=a.rules,d=a.hrefs;if(!b||d.length){r(this,He);r(this,a.precedence);a=0;if(d.length){for(r(this,Ie);a<d.length-1;a++)r(this,d[a]),r(this,Be);r(this,d[a])}r(this,Je);for(a=0;a<c.length;a++)r(this,c[a]);r(this,Ke);c.length=0;d.length=0}}
-function Me(a){if(0===a.state){a.state=1;var b=a.props;L(Fe,{rel:"preload",as:"style",href:a.props.href,crossOrigin:b.crossOrigin,fetchPriority:b.fetchPriority,integrity:b.integrity,media:b.media,hrefLang:b.hrefLang,referrerPolicy:b.referrerPolicy});for(a=0;a<Fe.length;a++)r(this,Fe[a]);Fe.length=0}}function Ne(a){a.sheets.forEach(Me,this);a.sheets.clear()}var Oe=x("["),Pe=x(",["),Qe=x(","),Re=x("]");
-function Se(a,b){r(a,Oe);var c=Oe;b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)r(a,c),r(a,w(te(""+d.props.href))),r(a,Re),c=Pe;else{r(a,c);var e=d.props["data-precedence"],f=d.props;r(a,w(te(""+d.props.href)));e=""+e;r(a,Qe);r(a,w(te(e)));for(var g in f)if(C.call(f,g)){var h=f[g];if(null!=h)switch(g){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");
-default:a:{e=a;var l=g.toLowerCase();switch(typeof h){case "function":case "symbol":break a}switch(g){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":l="class";h=""+h;break;case "hidden":if(!1===h)break a;h="";break;case "src":case "href":h=""+h;break;default:if(2<g.length&&("o"===g[0]||"O"===g[0])&&("n"===g[1]||"N"===g[1])||!xa(g))break a;h=""+h}r(e,Qe);r(e,w(te(l)));r(e,Qe);r(e,w(te(h)))}}}r(a,
-Re);c=Pe;d.state=3}});r(a,Re)}
-function Te(a,b){r(a,Oe);var c=Oe;b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)r(a,c),r(a,w(F(JSON.stringify(""+d.props.href)))),r(a,Re),c=Pe;else{r(a,c);var e=d.props["data-precedence"],f=d.props;r(a,w(F(JSON.stringify(""+d.props.href))));e=""+e;r(a,Qe);r(a,w(F(JSON.stringify(e))));for(var g in f)if(C.call(f,g)){var h=f[g];if(null!=h)switch(g){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");default:a:{e=
-a;var l=g.toLowerCase();switch(typeof h){case "function":case "symbol":break a}switch(g){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":l="class";h=""+h;break;case "hidden":if(!1===h)break a;h="";break;case "src":case "href":h=""+h;break;default:if(2<g.length&&("o"===g[0]||"O"===g[0])&&("n"===g[1]||"N"===g[1])||!xa(g))break a;h=""+h}r(e,Qe);r(e,w(F(JSON.stringify(l))));r(e,Qe);r(e,w(F(JSON.stringify(h))))}}}r(a,
-Re);c=Pe;d.state=3}});r(a,Re)}function Ta(a){var b=Ue();if(b){var c=b.resumableState,d=b.renderState;if("string"===typeof a&&a){if(!c.dnsResources.hasOwnProperty(a)){c.dnsResources[a]=null;c=d.headers;var e,f;if(f=c&&0<c.remainingCapacity)f=(e="<"+(""+a).replace(Ve,We)+">; rel=dns-prefetch",2<=(c.remainingCapacity-=e.length));f?(d.resets.dns[a]=null,c.preconnects&&(c.preconnects+=", "),c.preconnects+=e):(e=[],L(e,{href:a,rel:"dns-prefetch"}),d.preconnects.add(e))}Xe(b)}}}
+var ue=x('<style media="not all" data-precedence="'),ve=x('" data-href="'),we=x('">'),xe=x("</style>"),ye=!1,ze=!0;function Ae(a){var b=a.rules,c=a.hrefs,d=0;if(c.length){p(this,ue);p(this,a.precedence);for(p(this,ve);d<c.length-1;d++)p(this,c[d]),p(this,Be);p(this,c[d]);p(this,we);for(d=0;d<b.length;d++)p(this,b[d]);ze=v(this,xe);ye=!0;b.length=0;c.length=0}}function Ce(a){return 2!==a.state?ye=!0:!1}
+function De(a,b,c){ye=!1;ze=!0;b.styles.forEach(Ae,a);b.stylesheets.forEach(Ce);ye&&(c.stylesToHoist=!0);return ze}function Ee(a){for(var b=0;b<a.length;b++)p(this,a[b]);a.length=0}var Fe=[];function Ge(a){L(Fe,a.props);for(var b=0;b<Fe.length;b++)p(this,Fe[b]);Fe.length=0;a.state=2}var He=x('<style data-precedence="'),Ie=x('" data-href="'),Be=x(" "),Je=x('">'),Ke=x("</style>");
+function Le(a){var b=0<a.sheets.size;a.sheets.forEach(Ge,this);a.sheets.clear();var c=a.rules,d=a.hrefs;if(!b||d.length){p(this,He);p(this,a.precedence);a=0;if(d.length){for(p(this,Ie);a<d.length-1;a++)p(this,d[a]),p(this,Be);p(this,d[a])}p(this,Je);for(a=0;a<c.length;a++)p(this,c[a]);p(this,Ke);c.length=0;d.length=0}}
+function Me(a){if(0===a.state){a.state=1;var b=a.props;L(Fe,{rel:"preload",as:"style",href:a.props.href,crossOrigin:b.crossOrigin,fetchPriority:b.fetchPriority,integrity:b.integrity,media:b.media,hrefLang:b.hrefLang,referrerPolicy:b.referrerPolicy});for(a=0;a<Fe.length;a++)p(this,Fe[a]);Fe.length=0}}function Ne(a){a.sheets.forEach(Me,this);a.sheets.clear()}var Oe=x("["),Pe=x(",["),Qe=x(","),Re=x("]");
+function Se(a,b){p(a,Oe);var c=Oe;b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)p(a,c),p(a,w(te(""+d.props.href))),p(a,Re),c=Pe;else{p(a,c);var e=d.props["data-precedence"],f=d.props;p(a,w(te(""+d.props.href)));e=""+e;p(a,Qe);p(a,w(te(e)));for(var g in f)if(C.call(f,g)){var h=f[g];if(null!=h)switch(g){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");
+default:a:{e=a;var l=g.toLowerCase();switch(typeof h){case "function":case "symbol":break a}switch(g){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":l="class";h=""+h;break;case "hidden":if(!1===h)break a;h="";break;case "src":case "href":h=""+h;break;default:if(2<g.length&&("o"===g[0]||"O"===g[0])&&("n"===g[1]||"N"===g[1])||!xa(g))break a;h=""+h}p(e,Qe);p(e,w(te(l)));p(e,Qe);p(e,w(te(h)))}}}p(a,
+Re);c=Pe;d.state=3}});p(a,Re)}
+function Te(a,b){p(a,Oe);var c=Oe;b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)p(a,c),p(a,w(F(JSON.stringify(""+d.props.href)))),p(a,Re),c=Pe;else{p(a,c);var e=d.props["data-precedence"],f=d.props;p(a,w(F(JSON.stringify(""+d.props.href))));e=""+e;p(a,Qe);p(a,w(F(JSON.stringify(e))));for(var g in f)if(C.call(f,g)){var h=f[g];if(null!=h)switch(g){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");default:a:{e=
+a;var l=g.toLowerCase();switch(typeof h){case "function":case "symbol":break a}switch(g){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":l="class";h=""+h;break;case "hidden":if(!1===h)break a;h="";break;case "src":case "href":h=""+h;break;default:if(2<g.length&&("o"===g[0]||"O"===g[0])&&("n"===g[1]||"N"===g[1])||!xa(g))break a;h=""+h}p(e,Qe);p(e,w(F(JSON.stringify(l))));p(e,Qe);p(e,w(F(JSON.stringify(h))))}}}p(a,
+Re);c=Pe;d.state=3}});p(a,Re)}function Ta(a){var b=Ue();if(b){var c=b.resumableState,d=b.renderState;if("string"===typeof a&&a){if(!c.dnsResources.hasOwnProperty(a)){c.dnsResources[a]=null;c=d.headers;var e,f;if(f=c&&0<c.remainingCapacity)f=(e="<"+(""+a).replace(Ve,We)+">; rel=dns-prefetch",2<=(c.remainingCapacity-=e.length));f?(d.resets.dns[a]=null,c.preconnects&&(c.preconnects+=", "),c.preconnects+=e):(e=[],L(e,{href:a,rel:"dns-prefetch"}),d.preconnects.add(e))}Xe(b)}}}
 function Ua(a,b){var c=Ue();if(c){var d=c.resumableState,e=c.renderState;if("string"===typeof a&&a){var f="use-credentials"===b?"credentials":"string"===typeof b?"anonymous":"default";if(!d.connectResources[f].hasOwnProperty(a)){d.connectResources[f][a]=null;d=e.headers;var g,h;if(h=d&&0<d.remainingCapacity){h="<"+(""+a).replace(Ve,We)+">; rel=preconnect";if("string"===typeof b){var l=(""+b).replace(Ye,Ze);h+='; crossorigin="'+l+'"'}h=(g=h,2<=(d.remainingCapacity-=g.length))}h?(e.resets.connect[f][a]=
 null,d.preconnects&&(d.preconnects+=", "),d.preconnects+=g):(f=[],L(f,{rel:"preconnect",href:a,crossOrigin:b}),e.preconnects.add(f))}Xe(c)}}}
 function Va(a,b,c){var d=Ue();if(d){var e=d.resumableState,f=d.renderState;if(b&&a){switch(b){case "image":if(c){var g=c.imageSrcSet;var h=c.imageSizes;var l=c.fetchPriority}var n=g?g+"\n"+(h||""):a;if(e.imageResources.hasOwnProperty(n))return;e.imageResources[n]=J;e=f.headers;var q;e&&0<e.remainingCapacity&&"high"===l&&(q=Dc(a,b,c),2<=(e.remainingCapacity-=q.length))?(f.resets.image[n]=J,e.highImagePreloads&&(e.highImagePreloads+=", "),e.highImagePreloads+=q):(e=[],L(e,y({rel:"preload",href:g?void 0:
@@ -153,36 +151,36 @@ function zg(a){var b=jg;jg+=1;null===kg&&(kg=[]);return Vf(kg,a,b)}function Ag()
 var Dg={readContext:function(a){return a._currentValue},use:function(a){if(null!==a&&"object"===typeof a){if("function"===typeof a.then)return zg(a);if(a.$$typeof===lf||a.$$typeof===mf)return a._currentValue}throw Error("An unsupported type was passed to use(): "+String(a));},useContext:function(a){ng();return a._currentValue},useMemo:wg,useReducer:ug,useRef:function(a){$f=ng();X=pg();var b=X.memoizedState;return null===b?(a={current:a},X.memoizedState=a):b},useState:function(a){return ug(tg,a)},
 useInsertionEffect:Bg,useLayoutEffect:Bg,useCallback:function(a,b){return wg(function(){return a},b)},useImperativeHandle:Bg,useEffect:Bg,useDebugValue:Bg,useDeferredValue:function(a){ng();return a},useTransition:function(){ng();return[!1,xg]},useId:function(){var a=ag.treeContext;var b=a.overflow;a=a.id;a=(a&~(1<<32-Pf(a)-1)).toString(32)+b;var c=Cg;if(null===c)throw Error("Invalid hook call. Hooks can only be called inside of the body of a function component.");b=gg++;a=":"+c.idPrefix+"R"+a;0<b&&
 (a+="H"+b.toString(32));return a+":"},useSyncExternalStore:function(a,b,c){if(void 0===c)throw Error("Missing getServerSnapshot, which is required for server-rendered content. Will revert to client rendering.");return c()},useCacheRefresh:function(){return Ag},useHostTransitionStatus:function(){ng();return Ra},useOptimistic:function(a){ng();return[a,yg]},useFormState:function(a,b,c){ng();var d=hg++,e=bg;if("function"===typeof a.$$FORM_ACTION){var f=null,g=cg;e=e.formState;var h=a.$$IS_SIGNATURE_EQUAL;
-if(null!==e&&"function"===typeof h){var l=e[1];h.call(a,e[2],e[3])&&(f=void 0!==c?"p"+c:"k"+da(JSON.stringify([g,null,d]),0),l===f&&(ig=d,b=e[0]))}var n=a.bind(null,b);a=function(t){n(t)};"function"===typeof n.$$FORM_ACTION&&(a.$$FORM_ACTION=function(t){t=n.$$FORM_ACTION(t);void 0!==c&&(c+="",t.action=c);var p=t.data;p&&(null===f&&(f=void 0!==c?"p"+c:"k"+da(JSON.stringify([g,null,d]),0)),p.append("$ACTION_KEY",f));return t});return[b,a]}var q=a.bind(null,b);return[b,function(t){q(t)}]}},Cg=null,Eg=
+if(null!==e&&"function"===typeof h){var l=e[1];h.call(a,e[2],e[3])&&(f=void 0!==c?"p"+c:"k"+da(JSON.stringify([g,null,d]),0),l===f&&(ig=d,b=e[0]))}var n=a.bind(null,b);a=function(t){n(t)};"function"===typeof n.$$FORM_ACTION&&(a.$$FORM_ACTION=function(t){t=n.$$FORM_ACTION(t);void 0!==c&&(c+="",t.action=c);var r=t.data;r&&(null===f&&(f=void 0!==c?"p"+c:"k"+da(JSON.stringify([g,null,d]),0)),r.append("$ACTION_KEY",f));return t});return[b,a]}var q=a.bind(null,b);return[b,function(t){q(t)}]}},Cg=null,Eg=
 {getCacheSignal:function(){throw Error("Not implemented.");},getCacheForType:function(){throw Error("Not implemented.");}},Fg=Ka.ReactCurrentDispatcher,Gg=Ka.ReactCurrentCache;function Hg(a){console.error(a);return null}function Ig(){}
-function Jg(a,b,c,d,e,f,g,h,l,n,q,t){Sa.current=$a;var p=[],z=new Set;b={destination:null,flushScheduled:!1,resumableState:b,renderState:c,rootFormatContext:d,progressiveChunkSize:void 0===e?12800:e,status:0,fatalError:null,nextSegmentId:0,allPendingTasks:0,pendingRootTasks:0,completedRootSegment:null,abortableTasks:z,pingedTasks:p,clientRenderedBoundaries:[],completedBoundaries:[],partialBoundaries:[],trackedPostpones:null,onError:void 0===f?Hg:f,onPostpone:void 0===q?Ig:q,onAllReady:void 0===g?
-Ig:g,onShellReady:void 0===h?Ig:h,onShellError:void 0===l?Ig:l,onFatalError:void 0===n?Ig:n,formState:void 0===t?null:t};c=Kg(b,0,null,d,!1,!1);c.parentFlushed=!0;a=Lg(b,null,a,-1,null,c,z,null,d,Cf,null,Nf);p.push(a);return b}var Mg=null;function Ue(){if(Mg)return Mg;if(cf){var a=df.getStore();if(a)return a}return null}function Ng(a,b){a.pingedTasks.push(b);1===a.pingedTasks.length&&(a.flushScheduled=null!==a.destination,setTimeout(function(){return Og(a)},0))}
+function Jg(a,b,c,d,e,f,g,h,l,n,q,t){Sa.current=$a;var r=[],z=new Set;b={destination:null,flushScheduled:!1,resumableState:b,renderState:c,rootFormatContext:d,progressiveChunkSize:void 0===e?12800:e,status:0,fatalError:null,nextSegmentId:0,allPendingTasks:0,pendingRootTasks:0,completedRootSegment:null,abortableTasks:z,pingedTasks:r,clientRenderedBoundaries:[],completedBoundaries:[],partialBoundaries:[],trackedPostpones:null,onError:void 0===f?Hg:f,onPostpone:void 0===q?Ig:q,onAllReady:void 0===g?
+Ig:g,onShellReady:void 0===h?Ig:h,onShellError:void 0===l?Ig:l,onFatalError:void 0===n?Ig:n,formState:void 0===t?null:t};c=Kg(b,0,null,d,!1,!1);c.parentFlushed=!0;a=Lg(b,null,a,-1,null,c,z,null,d,Cf,null,Nf);r.push(a);return b}var Mg=null;function Ue(){if(Mg)return Mg;if(cf){var a=df.getStore();if(a)return a}return null}function Ng(a,b){a.pingedTasks.push(b);1===a.pingedTasks.length&&(a.flushScheduled=null!==a.destination,setTimeout(function(){return Og(a)},0))}
 function Pg(a,b){return{status:0,rootSegmentID:-1,parentFlushed:!1,pendingTasks:0,completedSegments:[],byteSize:0,fallbackAbortableTasks:b,errorDigest:null,resources:{styles:new Set,stylesheets:new Set},trackedContentKeyPath:null,trackedFallbackNode:null}}
-function Lg(a,b,c,d,e,f,g,h,l,n,q,t){a.allPendingTasks++;null===e?a.pendingRootTasks++:e.pendingTasks++;var p={replay:null,node:c,childIndex:d,ping:function(){return Ng(a,p)},blockedBoundary:e,blockedSegment:f,abortSet:g,keyPath:h,formatContext:l,legacyContext:n,context:q,treeContext:t,thenableState:b};g.add(p);return p}
-function Qg(a,b,c,d,e,f,g,h,l,n,q,t){a.allPendingTasks++;null===f?a.pendingRootTasks++:f.pendingTasks++;c.pendingTasks++;var p={replay:c,node:d,childIndex:e,ping:function(){return Ng(a,p)},blockedBoundary:f,blockedSegment:null,abortSet:g,keyPath:h,formatContext:l,legacyContext:n,context:q,treeContext:t,thenableState:b};g.add(p);return p}function Kg(a,b,c,d,e,f){return{status:0,id:-1,index:b,parentFlushed:!1,chunks:[],children:[],parentFormatContext:d,boundary:c,lastPushedText:e,textEmbedded:f}}
+function Lg(a,b,c,d,e,f,g,h,l,n,q,t){a.allPendingTasks++;null===e?a.pendingRootTasks++:e.pendingTasks++;var r={replay:null,node:c,childIndex:d,ping:function(){return Ng(a,r)},blockedBoundary:e,blockedSegment:f,abortSet:g,keyPath:h,formatContext:l,legacyContext:n,context:q,treeContext:t,thenableState:b};g.add(r);return r}
+function Qg(a,b,c,d,e,f,g,h,l,n,q,t){a.allPendingTasks++;null===f?a.pendingRootTasks++:f.pendingTasks++;c.pendingTasks++;var r={replay:c,node:d,childIndex:e,ping:function(){return Ng(a,r)},blockedBoundary:f,blockedSegment:null,abortSet:g,keyPath:h,formatContext:l,legacyContext:n,context:q,treeContext:t,thenableState:b};g.add(r);return r}function Kg(a,b,c,d,e,f){return{status:0,id:-1,index:b,parentFlushed:!1,chunks:[],children:[],parentFormatContext:d,boundary:c,lastPushedText:e,textEmbedded:f}}
 function Y(a,b){a=a.onError(b);if(null!=a&&"string"!==typeof a)throw Error('onError returned something with a type other than "string". onError should return a string and may return null or undefined but must not return anything else. It received something of type "'+typeof a+'" instead');return a}function Rg(a,b){var c=a.onShellError;c(b);c=a.onFatalError;c(b);null!==a.destination?(a.status=2,oa(a.destination,b)):(a.status=1,a.fatalError=b)}
 function Sg(a,b,c,d,e){var f=d.render(),g=e.childContextTypes;if(null!==g&&void 0!==g){c=b.legacyContext;if("function"!==typeof d.getChildContext)e=c;else{d=d.getChildContext();for(var h in d)if(!(h in g))throw Error((Bf(e)||"Unknown")+'.getChildContext(): key "'+h+'" is not defined in childContextTypes.');e=y({},c,d)}b.legacyContext=e;Z(a,b,null,f,-1);b.legacyContext=c}else e=b.keyPath,b.keyPath=c,Z(a,b,null,f,-1),b.keyPath=e}
 function Tg(a,b,c,d,e,f,g){var h=!1;if(0!==f&&null!==a.formState){var l=b.blockedSegment;if(null!==l){h=!0;l=l.chunks;for(var n=0;n<f;n++)n===g?l.push(hc):l.push(ic)}}f=b.keyPath;b.keyPath=c;e?(c=b.treeContext,b.treeContext=Of(c,1,0),Ug(a,b,d,-1),b.treeContext=c):h?Ug(a,b,d,-1):Z(a,b,null,d,-1);b.keyPath=f}function Vg(a,b){if(a&&a.defaultProps){b=y({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}
 function Wg(a,b,c,d,e,f,g){if("function"===typeof e)if(e.prototype&&e.prototype.isReactComponent){d=Df(e,b.legacyContext);var h=e.contextType;h=new e(f,"object"===typeof h&&null!==h?h._currentValue:d);Mf(h,e,f,d);Sg(a,b,c,h,e)}else{h=Df(e,b.legacyContext);$f={};ag=b;bg=a;cg=c;hg=gg=0;ig=-1;jg=0;kg=d;d=e(f,h);d=qg(e,f,d,h);g=0!==gg;var l=hg,n=ig;"object"===typeof d&&null!==d&&"function"===typeof d.render&&void 0===d.$$typeof?(Mf(d,e,f,h),Sg(a,b,c,d,e)):Tg(a,b,c,d,g,l,n)}else if("string"===typeof e)if(d=
 b.blockedSegment,null===d)d=f.children,h=b.formatContext,g=b.keyPath,b.formatContext=Mb(h,e,f),b.keyPath=c,Ug(a,b,d,-1),b.formatContext=h,b.keyPath=g;else{g=Cc(d.chunks,e,f,a.resumableState,a.renderState,b.formatContext,d.lastPushedText);d.lastPushedText=!1;h=b.formatContext;l=b.keyPath;b.formatContext=Mb(h,e,f);b.keyPath=c;Ug(a,b,g,-1);b.formatContext=h;b.keyPath=l;a:{b=d.chunks;a=a.resumableState;switch(e){case "title":case "style":case "script":case "area":case "base":case "br":case "col":case "embed":case "hr":case "img":case "input":case "keygen":case "link":case "meta":case "param":case "source":case "track":case "wbr":break a;
 case "body":if(1>=h.insertionMode){a.hasBody=!0;break a}break;case "html":if(0===h.insertionMode){a.hasHtml=!0;break a}}b.push(wc(e))}d.lastPushedText=!1}else{switch(e){case xf:case vf:case hf:case jf:case gf:e=b.keyPath;b.keyPath=c;Z(a,b,null,f.children,-1);b.keyPath=e;return;case wf:"hidden"!==f.mode&&(e=b.keyPath,b.keyPath=c,Z(a,b,null,f.children,-1),b.keyPath=e);return;case rf:e=b.keyPath;b.keyPath=c;Z(a,b,null,f.children,-1);b.keyPath=e;return;case uf:throw Error("ReactDOMServer does not yet support scope components.");
-case of:a:if(null!==b.replay){e=b.keyPath;b.keyPath=c;c=f.children;try{Ug(a,b,c,-1)}finally{b.keyPath=e}}else{n=b.keyPath;e=b.blockedBoundary;var q=b.blockedSegment;d=f.fallback;var t=f.children;f=new Set;g=Pg(a,f);null!==a.trackedPostpones&&(g.trackedContentKeyPath=c);l=Kg(a,q.chunks.length,g,b.formatContext,!1,!1);q.children.push(l);q.lastPushedText=!1;var p=Kg(a,0,null,b.formatContext,!1,!1);p.parentFlushed=!0;b.blockedBoundary=g;b.blockedSegment=p;a.renderState.boundaryResources=g.resources;b.keyPath=
-c;try{if(Ug(a,b,t,-1),p.lastPushedText&&p.textEmbedded&&p.chunks.push(Nb),p.status=1,Xg(g,p),0===g.pendingTasks&&0===g.status){g.status=1;break a}}catch(z){p.status=4,g.status=4,h=Y(a,z),g.errorDigest=h}finally{a.renderState.boundaryResources=e?e.resources:null,b.blockedBoundary=e,b.blockedSegment=q,b.keyPath=n}h=[c[0],"Suspense Fallback",c[2]];n=a.trackedPostpones;null!==n&&(q=[h[1],h[2],[],null],n.workingMap.set(h,q),5===g.status?n.workingMap.get(c)[4]=q:g.trackedFallbackNode=q);b=Lg(a,null,d,-1,
+case of:a:if(null!==b.replay){e=b.keyPath;b.keyPath=c;c=f.children;try{Ug(a,b,c,-1)}finally{b.keyPath=e}}else{n=b.keyPath;e=b.blockedBoundary;var q=b.blockedSegment;d=f.fallback;var t=f.children;f=new Set;g=Pg(a,f);null!==a.trackedPostpones&&(g.trackedContentKeyPath=c);l=Kg(a,q.chunks.length,g,b.formatContext,!1,!1);q.children.push(l);q.lastPushedText=!1;var r=Kg(a,0,null,b.formatContext,!1,!1);r.parentFlushed=!0;b.blockedBoundary=g;b.blockedSegment=r;a.renderState.boundaryResources=g.resources;b.keyPath=
+c;try{if(Ug(a,b,t,-1),r.lastPushedText&&r.textEmbedded&&r.chunks.push(Nb),r.status=1,Xg(g,r),0===g.pendingTasks&&0===g.status){g.status=1;break a}}catch(z){r.status=4,g.status=4,h=Y(a,z),g.errorDigest=h}finally{a.renderState.boundaryResources=e?e.resources:null,b.blockedBoundary=e,b.blockedSegment=q,b.keyPath=n}h=[c[0],"Suspense Fallback",c[2]];n=a.trackedPostpones;null!==n&&(q=[h[1],h[2],[],null],n.workingMap.set(h,q),5===g.status?n.workingMap.get(c)[4]=q:g.trackedFallbackNode=q);b=Lg(a,null,d,-1,
 e,l,f,h,b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}return}if("object"===typeof e&&null!==e)switch(e.$$typeof){case nf:e=e.render;$f={};ag=b;bg=a;cg=c;hg=gg=0;ig=-1;jg=0;kg=d;d=e(f,g);f=qg(e,f,d,g);Tg(a,b,c,f,0!==gg,hg,ig);return;case sf:e=e.type;f=Vg(e,f);Wg(a,b,c,d,e,f,g);return;case kf:h=f.children;d=b.keyPath;e=e._context;f=f.value;g=e._currentValue;e._currentValue=f;l=Ef;Ef=f={parent:l,depth:null===l?0:l.depth+1,context:e,parentValue:g,value:f};b.context=f;
 b.keyPath=c;Z(a,b,null,h,-1);a=Ef;if(null===a)throw Error("Tried to pop a Context at the root of the app. This is a bug in React.");c=a.parentValue;a.context._currentValue=c===zf?a.context._defaultValue:c;a=Ef=a.parent;b.context=a;b.keyPath=d;return;case lf:f=f.children;f=f(e._currentValue);e=b.keyPath;b.keyPath=c;Z(a,b,null,f,-1);b.keyPath=e;return;case tf:h=e._init;e=h(e._payload);f=Vg(e,f);Wg(a,b,c,d,e,f,void 0);return}throw Error("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: "+
 ((null==e?e:typeof e)+"."));}}function Yg(a,b,c,d,e){var f=b.replay,g=b.blockedBoundary,h=Kg(a,0,null,b.formatContext,!1,!1);h.id=c;h.parentFlushed=!0;try{b.replay=null,b.blockedSegment=h,Ug(a,b,d,e),h.status=1,null===g?a.completedRootSegment=h:(Xg(g,h),g.parentFlushed&&a.partialBoundaries.push(g))}finally{b.replay=f,b.blockedSegment=null}}
-function Z(a,b,c,d,e){if(null!==b.replay&&"number"===typeof b.replay.slots)Yg(a,b,b.replay.slots,d,e);else{b.node=d;b.childIndex=e;if("object"===typeof d&&null!==d){switch(d.$$typeof){case ef:var f=d.type,g=d.key,h=d.props,l=d.ref,n=Bf(f),q=null==g?-1===e?0:e:g;g=[b.keyPath,n,q];if(null!==b.replay)a:{var t=b.replay;e=t.nodes;for(d=0;d<e.length;d++){var p=e[d];if(q===p[1]){if(4===p.length){if(null!==n&&n!==p[0])throw Error("Expected the resume to render <"+p[0]+"> in this slot but instead it rendered <"+
-n+">. The tree doesn't match so React will fallback to client rendering.");n=p[2];p=p[3];q=b.node;b.replay={nodes:n,slots:p,pendingTasks:1};try{Wg(a,b,g,c,f,h,l);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--}catch(G){if("object"===typeof G&&null!==G&&(G===Tf||"function"===typeof G.then))throw b.node===q&&(b.replay=t),G;b.replay.pendingTasks--;
-g=a;a=b.blockedBoundary;c=G;h=Y(g,c);Zg(g,a,n,p,c,h)}b.replay=t}else{if(f!==of)throw Error("Expected the resume to render <Suspense> in this slot but instead it rendered <"+(Bf(f)||"Unknown")+">. The tree doesn't match so React will fallback to client rendering.");b:{t=void 0;c=p[5];f=p[2];l=p[3];n=null===p[4]?[]:p[4][2];p=null===p[4]?null:p[4][3];q=b.keyPath;var z=b.replay,A=b.blockedBoundary,R=h.children;h=h.fallback;var u=new Set,B=Pg(a,u);B.parentFlushed=!0;B.rootSegmentID=c;b.blockedBoundary=
+function Z(a,b,c,d,e){if(null!==b.replay&&"number"===typeof b.replay.slots)Yg(a,b,b.replay.slots,d,e);else{b.node=d;b.childIndex=e;if("object"===typeof d&&null!==d){switch(d.$$typeof){case ef:var f=d.type,g=d.key,h=d.props,l=d.ref,n=Bf(f),q=null==g?-1===e?0:e:g;g=[b.keyPath,n,q];if(null!==b.replay)a:{var t=b.replay;e=t.nodes;for(d=0;d<e.length;d++){var r=e[d];if(q===r[1]){if(4===r.length){if(null!==n&&n!==r[0])throw Error("Expected the resume to render <"+r[0]+"> in this slot but instead it rendered <"+
+n+">. The tree doesn't match so React will fallback to client rendering.");n=r[2];r=r[3];q=b.node;b.replay={nodes:n,slots:r,pendingTasks:1};try{Wg(a,b,g,c,f,h,l);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--}catch(G){if("object"===typeof G&&null!==G&&(G===Tf||"function"===typeof G.then))throw b.node===q&&(b.replay=t),G;b.replay.pendingTasks--;
+g=a;a=b.blockedBoundary;c=G;h=Y(g,c);Zg(g,a,n,r,c,h)}b.replay=t}else{if(f!==of)throw Error("Expected the resume to render <Suspense> in this slot but instead it rendered <"+(Bf(f)||"Unknown")+">. The tree doesn't match so React will fallback to client rendering.");b:{t=void 0;c=r[5];f=r[2];l=r[3];n=null===r[4]?[]:r[4][2];r=null===r[4]?null:r[4][3];q=b.keyPath;var z=b.replay,A=b.blockedBoundary,R=h.children;h=h.fallback;var u=new Set,B=Pg(a,u);B.parentFlushed=!0;B.rootSegmentID=c;b.blockedBoundary=
 B;b.replay={nodes:f,slots:l,pendingTasks:1};a.renderState.boundaryResources=B.resources;try{Ug(a,b,R,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--;if(0===B.pendingTasks&&0===B.status){B.status=1;a.completedBoundaries.push(B);break b}}catch(G){B.status=4,t=Y(a,G),B.errorDigest=t,b.replay.pendingTasks--,a.clientRenderedBoundaries.push(B)}finally{a.renderState.boundaryResources=
-A?A.resources:null,b.blockedBoundary=A,b.replay=z,b.keyPath=q}b=Qg(a,null,{nodes:n,slots:p,pendingTasks:0},h,-1,A,u,[g[0],"Suspense Fallback",g[2]],b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}}e.splice(d,1);break a}}}else Wg(a,b,g,c,f,h,l);return;case ff:throw Error("Portals are not currently supported by the server renderer. Render them conditionally so that they only appear on the client render.");case tf:h=d._init;d=h(d._payload);Z(a,b,null,d,e);return}if(Ja(d)){$g(a,
+A?A.resources:null,b.blockedBoundary=A,b.replay=z,b.keyPath=q}b=Qg(a,null,{nodes:n,slots:r,pendingTasks:0},h,-1,A,u,[g[0],"Suspense Fallback",g[2]],b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}}e.splice(d,1);break a}}}else Wg(a,b,g,c,f,h,l);return;case ff:throw Error("Portals are not currently supported by the server renderer. Render them conditionally so that they only appear on the client render.");case tf:h=d._init;d=h(d._payload);Z(a,b,null,d,e);return}if(Ja(d)){$g(a,
 b,d,e);return}null===d||"object"!==typeof d?h=null:(h=Af&&d[Af]||d["@@iterator"],h="function"===typeof h?h:null);if(h&&(h=h.call(d))){d=h.next();if(!d.done){g=[];do g.push(d.value),d=h.next();while(!d.done);$g(a,b,g,e)}return}if("function"===typeof d.then)return Z(a,b,null,zg(d),e);if(d.$$typeof===lf||d.$$typeof===mf)return Z(a,b,null,d._currentValue,e);e=Object.prototype.toString.call(d);throw Error("Objects are not valid as a React child (found: "+("[object Object]"===e?"object with keys {"+Object.keys(d).join(", ")+
 "}":e)+"). If you meant to render a collection of children, use an array instead.");}"string"===typeof d?(e=b.blockedSegment,null!==e&&(e.lastPushedText=Ob(e.chunks,d,a.renderState,e.lastPushedText))):"number"===typeof d&&(e=b.blockedSegment,null!==e&&(e.lastPushedText=Ob(e.chunks,""+d,a.renderState,e.lastPushedText)))}}
 function $g(a,b,c,d){var e=b.keyPath;if(-1!==d&&(b.keyPath=[b.keyPath,"Fragment",d],null!==b.replay)){for(var f=b.replay,g=f.nodes,h=0;h<g.length;h++){var l=g[h];if(l[1]===d){d=l[2];l=l[3];b.replay={nodes:d,slots:l,pendingTasks:1};try{$g(a,b,c,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--}catch(t){if("object"===typeof t&&
 null!==t&&(t===Tf||"function"===typeof t.then))throw t;b.replay.pendingTasks--;c=a;var n=b.blockedBoundary,q=t;a=Y(c,q);Zg(c,n,d,l,q,a)}b.replay=f;g.splice(h,1);break}}b.keyPath=e;return}f=b.treeContext;g=c.length;if(null!==b.replay&&(h=b.replay.slots,null!==h&&"object"===typeof h)){for(d=0;d<g;d++)l=c[d],b.treeContext=Of(f,g,d),n=h[d],"number"===typeof n?(Yg(a,b,n,l,d),delete h[d]):Ug(a,b,l,d);b.treeContext=f;b.keyPath=e;return}for(h=0;h<g;h++)d=c[h],b.treeContext=Of(f,g,h),Ug(a,b,d,h);b.treeContext=
 f;b.keyPath=e}
-function Ug(a,b,c,d){var e=b.formatContext,f=b.legacyContext,g=b.context,h=b.keyPath,l=b.treeContext,n=b.blockedSegment;if(null===n)try{return Z(a,b,null,c,d)}catch(p){if(rg(),c=p===Tf?Xf():p,"object"===typeof c&&null!==c&&"function"===typeof c.then){d=sg();a=Qg(a,d,b.replay,b.node,b.childIndex,b.blockedBoundary,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=l;Kf(g);return}}else{var q=
-n.children.length,t=n.chunks.length;try{return Z(a,b,null,c,d)}catch(p){if(rg(),n.children.length=q,n.chunks.length=t,c=p===Tf?Xf():p,"object"===typeof c&&null!==c&&"function"===typeof c.then){d=sg();n=b.blockedSegment;q=Kg(a,n.chunks.length,null,b.formatContext,n.lastPushedText,!0);n.children.push(q);n.lastPushedText=!1;a=Lg(a,d,b.node,b.childIndex,b.blockedBoundary,q,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=
+function Ug(a,b,c,d){var e=b.formatContext,f=b.legacyContext,g=b.context,h=b.keyPath,l=b.treeContext,n=b.blockedSegment;if(null===n)try{return Z(a,b,null,c,d)}catch(r){if(rg(),c=r===Tf?Xf():r,"object"===typeof c&&null!==c&&"function"===typeof c.then){d=sg();a=Qg(a,d,b.replay,b.node,b.childIndex,b.blockedBoundary,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=l;Kf(g);return}}else{var q=
+n.children.length,t=n.chunks.length;try{return Z(a,b,null,c,d)}catch(r){if(rg(),n.children.length=q,n.chunks.length=t,c=r===Tf?Xf():r,"object"===typeof c&&null!==c&&"function"===typeof c.then){d=sg();n=b.blockedSegment;q=Kg(a,n.chunks.length,null,b.formatContext,n.lastPushedText,!0);n.children.push(q);n.lastPushedText=!1;a=Lg(a,d,b.node,b.childIndex,b.blockedBoundary,q,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=
 f;b.context=g;b.keyPath=h;b.treeContext=l;Kf(g);return}}}b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=l;Kf(g);throw c;}function ah(a){var b=a.blockedBoundary;a=a.blockedSegment;null!==a&&(a.status=3,bh(this,b,a))}
 function Zg(a,b,c,d,e,f){for(var g=0;g<c.length;g++){var h=c[g];if(4===h.length)Zg(a,b,h[2],h[3],e,f);else{h=h[5];var l=a,n=f,q=Pg(l,new Set);q.parentFlushed=!0;q.rootSegmentID=h;q.status=4;q.errorDigest=n;q.parentFlushed&&l.clientRenderedBoundaries.push(q)}}c.length=0;if(null!==d){if(null===b)throw Error("We should not have any resumable nodes in the shell. This is a bug in React.");4!==b.status&&(b.status=4,b.errorDigest=f,b.parentFlushed&&a.clientRenderedBoundaries.push(b));if("object"===typeof d)for(var t in d)delete d[t]}}
 function ch(a,b,c){var d=a.blockedBoundary,e=a.blockedSegment;null!==e&&(e.status=3);if(null===d){if(1!==b.status&&2!==b.status){a=a.replay;if(null===a){Y(b,c);Rg(b,c);return}a.pendingTasks--;0===a.pendingTasks&&0<a.nodes.length&&(d=Y(b,c),Zg(b,null,a.nodes,a.slots,c,d));b.pendingRootTasks--;0===b.pendingRootTasks&&dh(b)}}else d.pendingTasks--,4!==d.status&&(d.status=4,d.errorDigest=Y(b,c),d.parentFlushed&&b.clientRenderedBoundaries.push(d)),d.fallbackAbortableTasks.forEach(function(f){return ch(f,
@@ -190,27 +188,29 @@ b,c)}),d.fallbackAbortableTasks.clear();b.allPendingTasks--;0===b.allPendingTask
 function Xg(a,b){if(0===b.chunks.length&&1===b.children.length&&null===b.children[0].boundary){var c=b.children[0];c.id=b.id;c.parentFlushed=!0;1===c.status&&Xg(a,c)}else a.completedSegments.push(b)}
 function bh(a,b,c){if(null===b){if(null!==c&&c.parentFlushed){if(null!==a.completedRootSegment)throw Error("There can only be one root segment. This is a bug in React.");a.completedRootSegment=c}a.pendingRootTasks--;0===a.pendingRootTasks&&dh(a)}else b.pendingTasks--,4!==b.status&&(0===b.pendingTasks?(0===b.status&&(b.status=1),null!==c&&c.parentFlushed&&1===c.status&&Xg(b,c),b.parentFlushed&&a.completedBoundaries.push(b),1===b.status&&(b.fallbackAbortableTasks.forEach(ah,a),b.fallbackAbortableTasks.clear())):
 null!==c&&c.parentFlushed&&1===c.status&&(Xg(b,c),1===b.completedSegments.length&&b.parentFlushed&&a.partialBoundaries.push(b)));a.allPendingTasks--;0===a.allPendingTasks&&eh(a)}
-function Og(a){if(2!==a.status){var b=Ef,c=Fg.current;Fg.current=Dg;var d=Gg.current;Gg.current=Eg;var e=Mg;Mg=a;var f=Cg;Cg=a.resumableState;try{var g=a.pingedTasks,h;for(h=0;h<g.length;h++){var l=g[h],n=a,q=l.blockedBoundary;n.renderState.boundaryResources=q?q.resources:null;var t=l.blockedSegment;if(null===t){var p=n;if(0!==l.replay.pendingTasks){Kf(l.context);try{var z=l.thenableState;l.thenableState=null;Z(p,l,z,l.node,l.childIndex);if(1===l.replay.pendingTasks&&0<l.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");
-l.replay.pendingTasks--;l.abortSet.delete(l);bh(p,l.blockedBoundary,null)}catch(H){rg();var A=H===Tf?Xf():H;if("object"===typeof A&&null!==A&&"function"===typeof A.then){var R=l.ping;A.then(R,R);l.thenableState=sg()}else{l.replay.pendingTasks--;l.abortSet.delete(l);n=void 0;var u=p,B=l.blockedBoundary,G=A,ka=l.replay.nodes,D=l.replay.slots;n=Y(u,G);Zg(u,B,ka,D,G,n);p.pendingRootTasks--;0===p.pendingRootTasks&&dh(p);p.allPendingTasks--;0===p.allPendingTasks&&eh(p)}}finally{p.renderState.boundaryResources=
-null}}}else if(p=void 0,u=t,0===u.status){Kf(l.context);var W=u.children.length,E=u.chunks.length;try{var ea=l.thenableState;l.thenableState=null;Z(n,l,ea,l.node,l.childIndex);u.lastPushedText&&u.textEmbedded&&u.chunks.push(Nb);l.abortSet.delete(l);u.status=1;bh(n,l.blockedBoundary,u)}catch(H){rg();u.children.length=W;u.chunks.length=E;var S=H===Tf?Xf():H;if("object"===typeof S&&null!==S&&"function"===typeof S.then){var la=l.ping;S.then(la,la);l.thenableState=sg()}else{l.abortSet.delete(l);u.status=
-4;var O=l.blockedBoundary;p=Y(n,S);null===O?Rg(n,S):(O.pendingTasks--,4!==O.status&&(O.status=4,O.errorDigest=p,O.parentFlushed&&n.clientRenderedBoundaries.push(O)));n.allPendingTasks--;0===n.allPendingTasks&&eh(n)}}finally{n.renderState.boundaryResources=null}}}g.splice(0,h);null!==a.destination&&fh(a,a.destination)}catch(H){Y(a,H),Rg(a,H)}finally{Cg=f,Fg.current=c,Gg.current=d,c===Dg&&Kf(b),Mg=e}}}
-function gh(a,b,c){c.parentFlushed=!0;switch(c.status){case 0:c.id=a.nextSegmentId++;case 5:var d=c.id;c.lastPushedText=!1;c.textEmbedded=!1;a=a.renderState;r(b,Gc);r(b,a.placeholderPrefix);a=w(d.toString(16));r(b,a);return v(b,Hc);case 1:c.status=2;var e=!0;d=c.chunks;var f=0;c=c.children;for(var g=0;g<c.length;g++){for(e=c[g];f<e.index;f++)r(b,d[f]);e=hh(a,b,e)}for(;f<d.length-1;f++)r(b,d[f]);f<d.length&&(e=v(b,d[f]));return e;default:throw Error("Aborted, errored or already flushed boundaries should not be flushed again. This is a bug in React.");
+function Og(a){if(2!==a.status){var b=Ef,c=Fg.current;Fg.current=Dg;var d=Gg.current;Gg.current=Eg;var e=Mg;Mg=a;var f=Cg;Cg=a.resumableState;try{var g=a.pingedTasks,h;for(h=0;h<g.length;h++){var l=g[h],n=a,q=l.blockedBoundary;n.renderState.boundaryResources=q?q.resources:null;var t=l.blockedSegment;if(null===t){var r=n;if(0!==l.replay.pendingTasks){Kf(l.context);try{var z=l.thenableState;l.thenableState=null;Z(r,l,z,l.node,l.childIndex);if(1===l.replay.pendingTasks&&0<l.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");
+l.replay.pendingTasks--;l.abortSet.delete(l);bh(r,l.blockedBoundary,null)}catch(H){rg();var A=H===Tf?Xf():H;if("object"===typeof A&&null!==A&&"function"===typeof A.then){var R=l.ping;A.then(R,R);l.thenableState=sg()}else{l.replay.pendingTasks--;l.abortSet.delete(l);n=void 0;var u=r,B=l.blockedBoundary,G=A,ka=l.replay.nodes,D=l.replay.slots;n=Y(u,G);Zg(u,B,ka,D,G,n);r.pendingRootTasks--;0===r.pendingRootTasks&&dh(r);r.allPendingTasks--;0===r.allPendingTasks&&eh(r)}}finally{r.renderState.boundaryResources=
+null}}}else if(r=void 0,u=t,0===u.status){Kf(l.context);var W=u.children.length,E=u.chunks.length;try{var ea=l.thenableState;l.thenableState=null;Z(n,l,ea,l.node,l.childIndex);u.lastPushedText&&u.textEmbedded&&u.chunks.push(Nb);l.abortSet.delete(l);u.status=1;bh(n,l.blockedBoundary,u)}catch(H){rg();u.children.length=W;u.chunks.length=E;var S=H===Tf?Xf():H;if("object"===typeof S&&null!==S&&"function"===typeof S.then){var la=l.ping;S.then(la,la);l.thenableState=sg()}else{l.abortSet.delete(l);u.status=
+4;var O=l.blockedBoundary;r=Y(n,S);null===O?Rg(n,S):(O.pendingTasks--,4!==O.status&&(O.status=4,O.errorDigest=r,O.parentFlushed&&n.clientRenderedBoundaries.push(O)));n.allPendingTasks--;0===n.allPendingTasks&&eh(n)}}finally{n.renderState.boundaryResources=null}}}g.splice(0,h);null!==a.destination&&fh(a,a.destination)}catch(H){Y(a,H),Rg(a,H)}finally{Cg=f,Fg.current=c,Gg.current=d,c===Dg&&Kf(b),Mg=e}}}
+function gh(a,b,c){c.parentFlushed=!0;switch(c.status){case 0:c.id=a.nextSegmentId++;case 5:var d=c.id;c.lastPushedText=!1;c.textEmbedded=!1;a=a.renderState;p(b,Gc);p(b,a.placeholderPrefix);a=w(d.toString(16));p(b,a);return v(b,Hc);case 1:c.status=2;var e=!0;d=c.chunks;var f=0;c=c.children;for(var g=0;g<c.length;g++){for(e=c[g];f<e.index;f++)p(b,d[f]);e=hh(a,b,e)}for(;f<d.length-1;f++)p(b,d[f]);f<d.length&&(e=v(b,d[f]));return e;default:throw Error("Aborted, errored or already flushed boundaries should not be flushed again. This is a bug in React.");
 }}
-function hh(a,b,c){var d=c.boundary;if(null===d)return gh(a,b,c);d.parentFlushed=!0;if(4===d.status)d=d.errorDigest,v(b,Lc),r(b,Nc),d&&(r(b,Pc),r(b,w(F(d))),r(b,Oc)),v(b,Qc),gh(a,b,c);else if(1!==d.status)0===d.status&&(d.rootSegmentID=a.nextSegmentId++),0<d.completedSegments.length&&a.partialBoundaries.push(d),Rc(b,a.renderState,d.rootSegmentID),gh(a,b,c);else if(d.byteSize>a.progressiveChunkSize)d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),Rc(b,a.renderState,d.rootSegmentID),gh(a,
+function hh(a,b,c){var d=c.boundary;if(null===d)return gh(a,b,c);d.parentFlushed=!0;if(4===d.status)d=d.errorDigest,v(b,Lc),p(b,Nc),d&&(p(b,Pc),p(b,w(F(d))),p(b,Oc)),v(b,Qc),gh(a,b,c);else if(1!==d.status)0===d.status&&(d.rootSegmentID=a.nextSegmentId++),0<d.completedSegments.length&&a.partialBoundaries.push(d),Rc(b,a.renderState,d.rootSegmentID),gh(a,b,c);else if(d.byteSize>a.progressiveChunkSize)d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),Rc(b,a.renderState,d.rootSegmentID),gh(a,
 b,c);else{c=d.resources;var e=a.renderState.boundaryResources;e&&(c.styles.forEach($e,e),c.stylesheets.forEach(af,e));v(b,Ic);d=d.completedSegments;if(1!==d.length)throw Error("A previously unvisited boundary must have exactly one root segment. This is a bug in React.");hh(a,b,d[0])}return v(b,Mc)}function ih(a,b,c){md(b,a.renderState,c.parentFormatContext,c.id);hh(a,b,c);return nd(b,c.parentFormatContext)}
-function jh(a,b,c){a.renderState.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e<d.length;e++)kh(a,b,c,d[e]);d.length=0;De(b,c.resources,a.renderState);d=a.resumableState;a=a.renderState;e=c.rootSegmentID;c=c.resources;var f=a.stylesToHoist;a.stylesToHoist=!1;var g=0===d.streamingFormat;g?(r(b,a.startInlineScript),f?0===(d.instructions&2)?(d.instructions|=10,r(b,512<Xd.byteLength?Xd.slice():Xd)):0===(d.instructions&8)?(d.instructions|=8,r(b,Yd)):r(b,Zd):0===(d.instructions&2)?(d.instructions|=
-2,r(b,Vd)):r(b,Wd)):f?r(b,ee):r(b,de);d=w(e.toString(16));r(b,a.boundaryPrefix);r(b,d);g?r(b,$d):r(b,fe);r(b,a.segmentPrefix);r(b,d);f?g?(r(b,ae),Se(b,c)):(r(b,ge),Te(b,c)):g&&r(b,be);d=g?v(b,ce):v(b,nb);return Fc(b,a)&&d}
-function kh(a,b,c,d){if(2===d.status)return!0;var e=d.id;if(-1===e){if(-1===(d.id=c.rootSegmentID))throw Error("A root segment ID must have been assigned by now. This is a bug in React.");return ih(a,b,d)}if(e===c.rootSegmentID)return ih(a,b,d);ih(a,b,d);c=a.resumableState;a=a.renderState;(d=0===c.streamingFormat)?(r(b,a.startInlineScript),0===(c.instructions&1)?(c.instructions|=1,r(b,od)):r(b,pd)):r(b,Td);r(b,a.segmentPrefix);e=w(e.toString(16));r(b,e);d?r(b,qd):r(b,Ud);r(b,a.placeholderPrefix);
-r(b,e);b=d?v(b,Sd):v(b,nb);return b}
-function fh(a,b){k=new Uint8Array(512);m=0;try{var c,d=a.completedRootSegment;if(null!==d)if(5!==d.status&&0===a.pendingRootTasks){var e=a.renderState;if((0!==a.allPendingTasks||null!==a.trackedPostpones)&&e.externalRuntimeScript){var f=e.externalRuntimeScript,g=a.resumableState,h=f.src,l=f.chunks;g.scriptResources.hasOwnProperty(h)||(g.scriptResources[h]=null,e.scripts.add(l))}var n=e.htmlChunks,q=e.headChunks;f=0;if(n){for(f=0;f<n.length;f++)r(b,n[f]);if(q)for(f=0;f<q.length;f++)r(b,q[f]);else r(b,
-V("head")),r(b,U)}else if(q)for(f=0;f<q.length;f++)r(b,q[f]);var t=e.charsetChunks;for(f=0;f<t.length;f++)r(b,t[f]);t.length=0;e.preconnects.forEach(Ee,b);e.preconnects.clear();var p=e.preconnectChunks;for(f=0;f<p.length;f++)r(b,p[f]);p.length=0;e.fontPreloads.forEach(Ee,b);e.fontPreloads.clear();e.highImagePreloads.forEach(Ee,b);e.highImagePreloads.clear();e.styles.forEach(Le,b);var z=e.importMapChunks;for(f=0;f<z.length;f++)r(b,z[f]);z.length=0;e.bootstrapScripts.forEach(Ee,b);e.scripts.forEach(Ee,
-b);e.scripts.clear();e.bulkPreloads.forEach(Ee,b);e.bulkPreloads.clear();var A=e.preloadChunks;for(f=0;f<A.length;f++)r(b,A[f]);A.length=0;var R=e.hoistableChunks;for(f=0;f<R.length;f++)r(b,R[f]);R.length=0;n&&null===q&&r(b,wc("head"));hh(a,b,d);a.completedRootSegment=null;Fc(b,a.renderState)}else return;var u=a.renderState;d=0;u.preconnects.forEach(Ee,b);u.preconnects.clear();var B=u.preconnectChunks;for(d=0;d<B.length;d++)r(b,B[d]);B.length=0;u.fontPreloads.forEach(Ee,b);u.fontPreloads.clear();
-u.highImagePreloads.forEach(Ee,b);u.highImagePreloads.clear();u.styles.forEach(Ne,b);u.scripts.forEach(Ee,b);u.scripts.clear();u.bulkPreloads.forEach(Ee,b);u.bulkPreloads.clear();var G=u.preloadChunks;for(d=0;d<G.length;d++)r(b,G[d]);G.length=0;var ka=u.hoistableChunks;for(d=0;d<ka.length;d++)r(b,ka[d]);ka.length=0;var D=a.clientRenderedBoundaries;for(c=0;c<D.length;c++){var W=D[c];u=b;var E=a.resumableState,ea=a.renderState,S=W.rootSegmentID,la=W.errorDigest,O=W.errorMessage,H=W.errorComponentStack,
-ma=0===E.streamingFormat;ma?(r(u,ea.startInlineScript),0===(E.instructions&4)?(E.instructions|=4,r(u,he)):r(u,ie)):r(u,me);r(u,ea.boundaryPrefix);r(u,w(S.toString(16)));ma&&r(u,je);if(la||O||H)ma?(r(u,ke),r(u,w(re(la||"")))):(r(u,ne),r(u,w(F(la||""))));if(O||H)ma?(r(u,ke),r(u,w(re(O||"")))):(r(u,oe),r(u,w(F(O||""))));H&&(ma?(r(u,ke),r(u,w(re(H)))):(r(u,pe),r(u,w(F(H)))));if(ma?!v(u,le):!v(u,nb)){a.destination=null;c++;D.splice(0,c);return}}D.splice(0,c);var ya=a.completedBoundaries;for(c=0;c<ya.length;c++)if(!jh(a,
+function jh(a,b,c){a.renderState.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e<d.length;e++)kh(a,b,c,d[e]);d.length=0;De(b,c.resources,a.renderState);d=a.resumableState;a=a.renderState;e=c.rootSegmentID;c=c.resources;var f=a.stylesToHoist;a.stylesToHoist=!1;var g=0===d.streamingFormat;g?(p(b,a.startInlineScript),f?0===(d.instructions&2)?(d.instructions|=10,p(b,512<Xd.byteLength?Xd.slice():Xd)):0===(d.instructions&8)?(d.instructions|=8,p(b,Yd)):p(b,Zd):0===(d.instructions&2)?(d.instructions|=
+2,p(b,Vd)):p(b,Wd)):f?p(b,ee):p(b,de);e=w(e.toString(16));p(b,a.boundaryPrefix);p(b,e);g?p(b,$d):p(b,fe);p(b,a.segmentPrefix);p(b,e);f?g?(p(b,ae),Se(b,c)):(p(b,ge),Te(b,c)):g&&p(b,be);c=g?v(b,ce):v(b,nb);return Fc(b,a,d)&&c}
+function kh(a,b,c,d){if(2===d.status)return!0;var e=d.id;if(-1===e){if(-1===(d.id=c.rootSegmentID))throw Error("A root segment ID must have been assigned by now. This is a bug in React.");return ih(a,b,d)}if(e===c.rootSegmentID)return ih(a,b,d);ih(a,b,d);c=a.resumableState;a=a.renderState;(d=0===c.streamingFormat)?(p(b,a.startInlineScript),0===(c.instructions&1)?(c.instructions|=1,p(b,od)):p(b,pd)):p(b,Td);p(b,a.segmentPrefix);e=w(e.toString(16));p(b,e);d?p(b,qd):p(b,Ud);p(b,a.placeholderPrefix);
+p(b,e);b=d?v(b,Sd):v(b,nb);return b}
+function fh(a,b){k=new Uint8Array(512);m=0;try{var c,d=a.completedRootSegment;if(null!==d)if(5!==d.status&&0===a.pendingRootTasks){var e=a.renderState;if((0!==a.allPendingTasks||null!==a.trackedPostpones)&&e.externalRuntimeScript){var f=e.externalRuntimeScript,g=a.resumableState,h=f.src,l=f.chunks;g.scriptResources.hasOwnProperty(h)||(g.scriptResources[h]=null,e.scripts.add(l))}var n=e.htmlChunks,q=e.headChunks;f=0;if(n){for(f=0;f<n.length;f++)p(b,n[f]);if(q)for(f=0;f<q.length;f++)p(b,q[f]);else p(b,
+V("head")),p(b,U)}else if(q)for(f=0;f<q.length;f++)p(b,q[f]);var t=e.charsetChunks;for(f=0;f<t.length;f++)p(b,t[f]);t.length=0;e.preconnects.forEach(Ee,b);e.preconnects.clear();var r=e.preconnectChunks;for(f=0;f<r.length;f++)p(b,r[f]);r.length=0;e.fontPreloads.forEach(Ee,b);e.fontPreloads.clear();e.highImagePreloads.forEach(Ee,b);e.highImagePreloads.clear();e.styles.forEach(Le,b);var z=e.importMapChunks;for(f=0;f<z.length;f++)p(b,z[f]);z.length=0;e.bootstrapScripts.forEach(Ee,b);e.scripts.forEach(Ee,
+b);e.scripts.clear();e.bulkPreloads.forEach(Ee,b);e.bulkPreloads.clear();var A=e.preloadChunks;for(f=0;f<A.length;f++)p(b,A[f]);A.length=0;var R=e.hoistableChunks;for(f=0;f<R.length;f++)p(b,R[f]);R.length=0;n&&null===q&&p(b,wc("head"));hh(a,b,d);a.completedRootSegment=null;Fc(b,a.renderState,a.resumableState)}else return;var u=a.renderState;d=0;u.preconnects.forEach(Ee,b);u.preconnects.clear();var B=u.preconnectChunks;for(d=0;d<B.length;d++)p(b,B[d]);B.length=0;u.fontPreloads.forEach(Ee,b);u.fontPreloads.clear();
+u.highImagePreloads.forEach(Ee,b);u.highImagePreloads.clear();u.styles.forEach(Ne,b);u.scripts.forEach(Ee,b);u.scripts.clear();u.bulkPreloads.forEach(Ee,b);u.bulkPreloads.clear();var G=u.preloadChunks;for(d=0;d<G.length;d++)p(b,G[d]);G.length=0;var ka=u.hoistableChunks;for(d=0;d<ka.length;d++)p(b,ka[d]);ka.length=0;var D=a.clientRenderedBoundaries;for(c=0;c<D.length;c++){var W=D[c];u=b;var E=a.resumableState,ea=a.renderState,S=W.rootSegmentID,la=W.errorDigest,O=W.errorMessage,H=W.errorComponentStack,
+ma=0===E.streamingFormat;ma?(p(u,ea.startInlineScript),0===(E.instructions&4)?(E.instructions|=4,p(u,he)):p(u,ie)):p(u,me);p(u,ea.boundaryPrefix);p(u,w(S.toString(16)));ma&&p(u,je);if(la||O||H)ma?(p(u,ke),p(u,w(re(la||"")))):(p(u,ne),p(u,w(F(la||""))));if(O||H)ma?(p(u,ke),p(u,w(re(O||"")))):(p(u,oe),p(u,w(F(O||""))));H&&(ma?(p(u,ke),p(u,w(re(H)))):(p(u,pe),p(u,w(F(H)))));if(ma?!v(u,le):!v(u,nb)){a.destination=null;c++;D.splice(0,c);return}}D.splice(0,c);var ya=a.completedBoundaries;for(c=0;c<ya.length;c++)if(!jh(a,
 b,ya[c])){a.destination=null;c++;ya.splice(0,c);return}ya.splice(0,c);ia(b);k=new Uint8Array(512);m=0;var qa=a.partialBoundaries;for(c=0;c<qa.length;c++){var ra=qa[c];a:{D=a;W=b;D.renderState.boundaryResources=ra.resources;var sa=ra.completedSegments;for(E=0;E<sa.length;E++)if(!kh(D,W,ra,sa[E])){E++;sa.splice(0,E);var La=!1;break a}sa.splice(0,E);La=De(W,ra.resources,D.renderState)}if(!La){a.destination=null;c++;qa.splice(0,c);return}}qa.splice(0,c);var fa=a.completedBoundaries;for(c=0;c<fa.length;c++)if(!jh(a,
-b,fa[c])){a.destination=null;c++;fa.splice(0,c);return}fa.splice(0,c)}finally{0===a.allPendingTasks&&0===a.pingedTasks.length&&0===a.clientRenderedBoundaries.length&&0===a.completedBoundaries.length?(a.flushScheduled=!1,c=a.resumableState,c.hasBody&&r(b,wc("body")),c.hasHtml&&r(b,wc("html")),ia(b),b.close(),a.destination=null):ia(b)}}
+b,fa[c])){a.destination=null;c++;fa.splice(0,c);return}fa.splice(0,c)}finally{0===a.allPendingTasks&&0===a.pingedTasks.length&&0===a.clientRenderedBoundaries.length&&0===a.completedBoundaries.length?(a.flushScheduled=!1,c=a.resumableState,c.hasBody&&p(b,wc("body")),c.hasHtml&&p(b,wc("html")),ia(b),b.close(),a.destination=null):ia(b)}}
 function lh(a){a.flushScheduled=null!==a.destination;cf?setTimeout(function(){return df.run(a,Og,a)},0):setTimeout(function(){return Og(a)},0);null===a.trackedPostpones&&(cf?setTimeout(function(){return df.run(a,mh,a)},0):setTimeout(function(){return mh(a)},0))}function mh(a){bf(a.renderState,a.resumableState,0===a.pendingRootTasks)}
 function Xe(a){!1===a.flushScheduled&&0===a.pingedTasks.length&&null!==a.destination&&(a.flushScheduled=!0,setTimeout(function(){var b=a.destination;b?fh(a,b):a.flushScheduled=!1},0))}function nh(a,b){try{var c=a.abortableTasks;if(0<c.size){var d=void 0===b?Error("The render was aborted by the server without a reason."):b;c.forEach(function(e){return ch(e,a,d)});c.clear()}null!==a.destination&&fh(a,a.destination)}catch(e){Y(a,e),Rg(a,e)}}
-exports.renderToReadableStream=function(a,b){return new Promise(function(c,d){var e,f,g=new Promise(function(z,A){f=z;e=A}),h=b?b.onHeaders:void 0,l;h&&(l=function(z){h(new Headers(z))});var n=Kb(b?b.identifierPrefix:void 0,b?b.unstable_externalRuntimeSrc:void 0),q=Jg(a,n,Ib(n,b?b.nonce:void 0,b?b.bootstrapScriptContent:void 0,b?b.bootstrapScripts:void 0,b?b.bootstrapModules:void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.importMap:void 0,l,b?b.maxHeadersLength:void 0),Lb(b?b.namespaceURI:void 0),
-b?b.progressiveChunkSize:void 0,b?b.onError:void 0,f,function(){var z=new ReadableStream({type:"bytes",pull:function(A){if(1===q.status)q.status=2,oa(A,q.fatalError);else if(2!==q.status&&null===q.destination){q.destination=A;try{fh(q,A)}catch(R){Y(q,R),Rg(q,R)}}},cancel:function(A){q.destination=null;nh(q,A)}},{highWaterMark:0});z.allReady=g;c(z)},function(z){g.catch(function(){});d(z)},e,b?b.onPostpone:void 0,b?b.formState:void 0);if(b&&b.signal){var t=b.signal;if(t.aborted)nh(q,t.reason);else{var p=
-function(){nh(q,t.reason);t.removeEventListener("abort",p)};t.addEventListener("abort",p)}}lh(q)})};exports.version="18.3.0-canary-2983249dd-20231107";
+exports.renderToReadableStream=function(a,b){return new Promise(function(c,d){var e,f,g=new Promise(function(z,A){f=z;e=A}),h=b?b.onHeaders:void 0,l;h&&(l=function(z){h(new Headers(z))});var n=Kb(b?b.identifierPrefix:void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.bootstrapScriptContent:void 0,b?b.bootstrapScripts:void 0,b?b.bootstrapModules:void 0),q=Jg(a,n,Ib(n,b?b.nonce:void 0,b?b.unstable_externalRuntimeSrc:void 0,b?b.importMap:void 0,l,b?b.maxHeadersLength:void 0),Lb(b?b.namespaceURI:void 0),
+b?b.progressiveChunkSize:void 0,b?b.onError:void 0,f,function(){var z=new ReadableStream({type:"bytes",pull:function(A){if(1===q.status)q.status=2,oa(A,q.fatalError);else if(2!==q.status&&null===q.destination){q.destination=A;try{fh(q,A)}catch(R){Y(q,R),Rg(q,R)}}},cancel:function(A){q.destination=null;nh(q,A)}},{highWaterMark:0});z.allReady=g;c(z)},function(z){g.catch(function(){});d(z)},e,b?b.onPostpone:void 0,b?b.formState:void 0);if(b&&b.signal){var t=b.signal;if(t.aborted)nh(q,t.reason);else{var r=
+function(){nh(q,t.reason);t.removeEventListener("abort",r)};t.addEventListener("abort",r)}}lh(q)})};exports.version="18.3.0-canary-7508dcd5c-20231108";
+
+//# sourceMappingURL=react-dom-server.edge.production.min.js.map
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom-server.node.development.js b/packages/next/src/compiled/react-dom/cjs/react-dom-server.node.development.js
index 7cb8fd6006981..9ad9e3564d1ff 100644
--- a/packages/next/src/compiled/react-dom/cjs/react-dom-server.node.development.js
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom-server.node.development.js
@@ -20,7 +20,7 @@ var crypto = require('crypto');
 var async_hooks = require('async_hooks');
 var ReactDOM = require('react-dom');
 
-var ReactVersion = '18.3.0-canary-2983249dd-20231107';
+var ReactVersion = '18.3.0-canary-7508dcd5c-20231108';
 
 var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
 
@@ -1791,11 +1791,14 @@ var DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS = 2000; // Allows us to keep tr
 // if passed externalRuntimeConfig and the enableFizzExternalRuntime feature flag
 // is set, the server will send instructions via data attributes (instead of inline scripts)
 
-function createRenderState(resumableState, nonce, bootstrapScriptContent, bootstrapScripts, bootstrapModules, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
+function createRenderState(resumableState, nonce, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
   var inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
   var idPrefix = resumableState.idPrefix;
   var bootstrapChunks = [];
   var externalRuntimeScript = null;
+  var bootstrapScriptContent = resumableState.bootstrapScriptContent,
+      bootstrapScripts = resumableState.bootstrapScripts,
+      bootstrapModules = resumableState.bootstrapModules;
 
   if (bootstrapScriptContent !== undefined) {
     bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapAndImportMapScriptContent(bootstrapScriptContent)), endInlineScript);
@@ -1984,7 +1987,7 @@ function createRenderState(resumableState, nonce, bootstrapScriptContent, bootst
 
   return renderState;
 }
-function createResumableState(identifierPrefix, externalRuntimeConfig) {
+function createResumableState(identifierPrefix, externalRuntimeConfig, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
   var idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
   var streamingFormat = ScriptStreamingFormat;
 
@@ -1998,6 +2001,9 @@ function createResumableState(identifierPrefix, externalRuntimeConfig) {
     idPrefix: idPrefix,
     nextFormID: 0,
     streamingFormat: streamingFormat,
+    bootstrapScriptContent: bootstrapScriptContent,
+    bootstrapScripts: bootstrapScripts,
+    bootstrapModules: bootstrapModules,
     instructions: NothingSent,
     hasBody: false,
     hasHtml: false,
@@ -4437,7 +4443,10 @@ function pushEndInstance(target, type, props, resumableState, formatContext) {
   target.push(endChunkForTag(type));
 }
 
-function writeBootstrap(destination, renderState) {
+function writeBootstrap(destination, renderState, resumableState) {
+  resumableState.bootstrapScriptContent = undefined;
+  resumableState.bootstrapScripts = undefined;
+  resumableState.bootstrapModules = undefined;
   var bootstrapChunks = renderState.bootstrapChunks;
   var i = 0;
 
@@ -4454,8 +4463,8 @@ function writeBootstrap(destination, renderState) {
   return true;
 }
 
-function writeCompletedRoot(destination, renderState) {
-  return writeBootstrap(destination, renderState);
+function writeCompletedRoot(destination, renderState, resumableState) {
+  return writeBootstrap(destination, renderState, resumableState);
 } // Structural Nodes
 // A placeholder is a node inside a hidden partial tree that can be filled in later, but before
 // display. It's never visible to users. We use the template tag because it can be used in every
@@ -4812,7 +4821,7 @@ function writeCompletedBoundaryInstruction(destination, resumableState, renderSt
     writeMore = writeChunkAndReturn(destination, completeBoundaryDataEnd);
   }
 
-  return writeBootstrap(destination, renderState) && writeMore;
+  return writeBootstrap(destination, renderState, resumableState) && writeMore;
 }
 var clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
 var clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
@@ -6812,6 +6821,18 @@ var componentFrameCache;
   var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
   componentFrameCache = new PossiblyWeakMap();
 }
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
@@ -6827,7 +6848,6 @@ function describeNativeComponentFrame(fn, construct) {
     }
   }
 
-  var control;
   reentry = true;
   var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
 
@@ -6841,81 +6861,140 @@ function describeNativeComponentFrame(fn, construct) {
     ReactCurrentDispatcher$1.current = null;
     disableLogs();
   }
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
 
-  try {
-    // This should throw.
-    if (construct) {
-      // Something should be setting the props in the constructor.
-      var Fake = function () {
-        throw Error();
-      }; // $FlowFixMe[prop-missing]
 
+  var RunInRootFrame = {
+    DetermineComponentFrameRoot: function () {
+      var control;
 
-      Object.defineProperty(Fake.prototype, 'props', {
-        set: function () {
-          // We use a throwing setter instead of frozen or non-writable props
-          // because that won't throw in a non-strict mode function.
-          throw Error();
-        }
-      });
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          var Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
 
-      if (typeof Reflect === 'object' && Reflect.construct) {
-        // We construct a different control for this case to include any extra
-        // frames added by the construct call.
-        try {
-          Reflect.construct(Fake, []);
-        } catch (x) {
-          control = x;
-        }
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
 
-        Reflect.construct(fn, [], Fake);
-      } else {
-        try {
-          Fake.call();
-        } catch (x) {
-          control = x;
-        } // $FlowFixMe[prop-missing] found when upgrading Flow
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
 
 
-        fn.call(Fake.prototype);
-      }
-    } else {
-      try {
-        throw Error();
-      } catch (x) {
-        control = x;
-      } // TODO(luna): This will currently only throw if the function component
-      // tries to access React/ReactDOM/props. We should probably make this throw
-      // in simple components too
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
 
 
-      var maybePromise = fn(); // If the function component returns a promise, it's likely an async
-      // component, which we don't yet support. Attach a noop catch handler to
-      // silence the error.
-      // TODO: Implement component stacks for async client components?
+          var maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
 
-      if (maybePromise && typeof maybePromise.catch === 'function') {
-        maybePromise.catch(function () {});
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(function () {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
       }
+
+      return [null, null];
     }
-  } catch (sample) {
-    // This is inlined manually because closure doesn't do it for us.
-    if (sample && control && typeof sample.stack === 'string') {
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
+
+  try {
+    var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
+
+    if (sampleStack && controlStack) {
       // This extracts the first frame from the sample that isn't also in the control.
       // Skipping one frame that we assume is the frame that calls the two.
-      var sampleLines = sample.stack.split('\n');
-      var controlLines = control.stack.split('\n');
-      var s = sampleLines.length - 1;
-      var c = controlLines.length - 1;
-
-      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
-        // We expect at least one stack frame to be shared.
-        // Typically this will be the root most one. However, stack frames may be
-        // cut off due to maximum stack limits. In this case, one maybe cut off
-        // earlier than the other. We assume that the sample is longer or the same
-        // and there for cut off earlier. So we should find the root most frame in
-        // the sample somewhere in the control.
-        c--;
+      var sampleLines = sampleStack.split('\n');
+      var controlLines = controlStack.split('\n');
+      var s = 0;
+      var c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
       }
 
       for (; s >= 1 && c >= 0; s--, c--) {
@@ -6944,7 +7023,7 @@ function describeNativeComponentFrame(fn, construct) {
                   _frame = _frame.replace('<anonymous>', fn.displayName);
                 }
 
-                {
+                if (true) {
                   if (typeof fn === 'function') {
                     componentFrameCache.set(fn, _frame);
                   }
@@ -11324,7 +11403,7 @@ function flushCompletedQueues(request, destination) {
 
         flushSegment(request, destination, completedRootSegment);
         request.completedRootSegment = null;
-        writeCompletedRoot(destination, request.renderState);
+        writeCompletedRoot(destination, request.renderState, request.resumableState);
       } else {
         // We haven't flushed the root yet so we don't need to check any other branches further down
         return;
@@ -11586,8 +11665,8 @@ function createCancelHandler(request, reason) {
 }
 
 function createRequestImpl(children, options) {
-  var resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined);
-  return createRequest(children, resumableState, createRenderState(resumableState, options ? options.nonce : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, options ? options.onHeaders : undefined, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, options ? options.onAllReady : undefined, options ? options.onShellReady : undefined, options ? options.onShellError : undefined, undefined, options ? options.onPostpone : undefined, options ? options.formState : undefined);
+  var resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined);
+  return createRequest(children, resumableState, createRenderState(resumableState, options ? options.nonce : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, options ? options.onHeaders : undefined, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, options ? options.onAllReady : undefined, options ? options.onShellReady : undefined, options ? options.onShellError : undefined, undefined, options ? options.onPostpone : undefined, options ? options.formState : undefined);
 }
 
 function renderToPipeableStream(children, options) {
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom-server.node.production.js b/packages/next/src/compiled/react-dom/cjs/react-dom-server.node.production.js
new file mode 100644
index 0000000000000..6e7567d28e370
--- /dev/null
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom-server.node.production.js
@@ -0,0 +1,8583 @@
+/**
+ * @license React
+ * react-dom-server.node.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var util = require('util');
+var crypto = require('crypto');
+var async_hooks = require('async_hooks');
+var React = require("next/dist/compiled/react");
+var ReactDOM = require('react-dom');
+
+var ReactVersion = '18.3.0-canary-7508dcd5c-20231108';
+
+function scheduleWork(callback) {
+  setImmediate(callback);
+}
+function flushBuffered(destination) {
+  // If we don't have any more data to send right now.
+  // Flush whatever is in the buffer to the wire.
+  if (typeof destination.flush === 'function') {
+    // By convention the Zlib streams provide a flush function for this purpose.
+    // For Express, compression middleware adds this method.
+    destination.flush();
+  }
+}
+const VIEW_SIZE = 2048;
+let currentView = null;
+let writtenBytes = 0;
+let destinationHasCapacity$1 = true;
+function beginWriting(destination) {
+  currentView = new Uint8Array(VIEW_SIZE);
+  writtenBytes = 0;
+  destinationHasCapacity$1 = true;
+}
+
+function writeStringChunk(destination, stringChunk) {
+  if (stringChunk.length === 0) {
+    return;
+  } // maximum possible view needed to encode entire string
+
+
+  if (stringChunk.length * 3 > VIEW_SIZE) {
+    if (writtenBytes > 0) {
+      writeToDestination(destination, currentView.subarray(0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    writeToDestination(destination, textEncoder.encode(stringChunk));
+    return;
+  }
+
+  let target = currentView;
+
+  if (writtenBytes > 0) {
+    target = currentView.subarray(writtenBytes);
+  }
+
+  const _textEncoder$encodeIn = textEncoder.encodeInto(stringChunk, target),
+        read = _textEncoder$encodeIn.read,
+        written = _textEncoder$encodeIn.written;
+
+  writtenBytes += written;
+
+  if (read < stringChunk.length) {
+    writeToDestination(destination, currentView.subarray(0, writtenBytes));
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = textEncoder.encodeInto(stringChunk.slice(read), currentView).written;
+  }
+
+  if (writtenBytes === VIEW_SIZE) {
+    writeToDestination(destination, currentView);
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+}
+
+function writeViewChunk(destination, chunk) {
+  if (chunk.byteLength === 0) {
+    return;
+  }
+
+  if (chunk.byteLength > VIEW_SIZE) {
+    // one that is cached by the streaming renderer. We will enqueu
+    // it directly and expect it is not re-used
+
+
+    if (writtenBytes > 0) {
+      writeToDestination(destination, currentView.subarray(0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    writeToDestination(destination, chunk);
+    return;
+  }
+
+  let bytesToWrite = chunk;
+  const allowableBytes = currentView.length - writtenBytes;
+
+  if (allowableBytes < bytesToWrite.byteLength) {
+    // this chunk would overflow the current view. We enqueue a full view
+    // and start a new view with the remaining chunk
+    if (allowableBytes === 0) {
+      // the current view is already full, send it
+      writeToDestination(destination, currentView);
+    } else {
+      // fill up the current view and apply the remaining chunk bytes
+      // to a new view.
+      currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes);
+      writtenBytes += allowableBytes;
+      writeToDestination(destination, currentView);
+      bytesToWrite = bytesToWrite.subarray(allowableBytes);
+    }
+
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+
+  currentView.set(bytesToWrite, writtenBytes);
+  writtenBytes += bytesToWrite.byteLength;
+
+  if (writtenBytes === VIEW_SIZE) {
+    writeToDestination(destination, currentView);
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+}
+
+function writeChunk(destination, chunk) {
+  if (typeof chunk === 'string') {
+    writeStringChunk(destination, chunk);
+  } else {
+    writeViewChunk(destination, chunk);
+  }
+}
+
+function writeToDestination(destination, view) {
+  const currentHasCapacity = destination.write(view);
+  destinationHasCapacity$1 = destinationHasCapacity$1 && currentHasCapacity;
+}
+
+function writeChunkAndReturn(destination, chunk) {
+  writeChunk(destination, chunk);
+  return destinationHasCapacity$1;
+}
+function completeWriting(destination) {
+  if (currentView && writtenBytes > 0) {
+    destination.write(currentView.subarray(0, writtenBytes));
+  }
+
+  currentView = null;
+  writtenBytes = 0;
+  destinationHasCapacity$1 = true;
+}
+function close(destination) {
+  destination.end();
+}
+const textEncoder = new util.TextEncoder();
+function stringToChunk(content) {
+  return content;
+}
+function stringToPrecomputedChunk(content) {
+  const precomputedChunk = textEncoder.encode(content);
+
+  return precomputedChunk;
+}
+function clonePrecomputedChunk(precomputedChunk) {
+  return precomputedChunk.length > VIEW_SIZE ? precomputedChunk.slice() : precomputedChunk;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+  destination.destroy(error);
+}
+function createFastHash(input) {
+  const hash = crypto.createHash('md5');
+  hash.update(input);
+  return hash.digest('hex');
+}
+
+const assign = Object.assign;
+
+// -----------------------------------------------------------------------------
+const enableFloat = true; // Enables unstable_useMemoCache hook, intended as a compilation target for
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/* eslint-disable max-len */
+
+const ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
+/* eslint-enable max-len */
+
+const ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
+const VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+const illegalAttributeNameCache = {};
+const validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+  if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+    return true;
+  }
+
+  if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+    return false;
+  }
+
+  if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+    validatedAttributeNameCache[attributeName] = true;
+    return true;
+  }
+
+  illegalAttributeNameCache[attributeName] = true;
+
+  return false;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+const unitlessNumbers = new Set(['animationIterationCount', 'aspectRatio', 'borderImageOutset', 'borderImageSlice', 'borderImageWidth', 'boxFlex', 'boxFlexGroup', 'boxOrdinalGroup', 'columnCount', 'columns', 'flex', 'flexGrow', 'flexPositive', 'flexShrink', 'flexNegative', 'flexOrder', 'gridArea', 'gridRow', 'gridRowEnd', 'gridRowSpan', 'gridRowStart', 'gridColumn', 'gridColumnEnd', 'gridColumnSpan', 'gridColumnStart', 'fontWeight', 'lineClamp', 'lineHeight', 'opacity', 'order', 'orphans', 'scale', 'tabSize', 'widows', 'zIndex', 'zoom', 'fillOpacity', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'MozBoxFlexGroup', 'MozLineClamp', 'msAnimationIterationCount', 'msFlex', 'msZoom', 'msFlexGrow', 'msFlexNegative', 'msFlexOrder', 'msFlexPositive', 'msFlexShrink', 'msGridColumn', 'msGridColumnSpan', 'msGridRow', 'msGridRowSpan', 'WebkitAnimationIterationCount', 'WebkitBoxFlex', 'WebKitBoxFlexGroup', 'WebkitBoxOrdinalGroup', 'WebkitColumnCount', 'WebkitColumns', 'WebkitFlex', 'WebkitFlexGrow', 'WebkitFlexPositive', 'WebkitFlexShrink', 'WebkitLineClamp']);
+function isUnitlessNumber (name) {
+  return unitlessNumbers.has(name);
+}
+
+const aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+  return aliases.get(name) || name;
+}
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// code copied and modified from escape-html
+const matchHtmlRegExp = /["'&<>]/;
+/**
+ * Escapes special characters and HTML entities in a given html string.
+ *
+ * @param  {string} string HTML string to escape for later insertion
+ * @return {string}
+ * @public
+ */
+
+function escapeHtml(string) {
+
+  const str = '' + string;
+  const match = matchHtmlRegExp.exec(str);
+
+  if (!match) {
+    return str;
+  }
+
+  let escape;
+  let html = '';
+  let index;
+  let lastIndex = 0;
+
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        // "
+        escape = '&quot;';
+        break;
+
+      case 38:
+        // &
+        escape = '&amp;';
+        break;
+
+      case 39:
+        // '
+        escape = '&#x27;'; // modified from escape-html; used to be '&#39'
+
+        break;
+
+      case 60:
+        // <
+        escape = '&lt;';
+        break;
+
+      case 62:
+        // >
+        escape = '&gt;';
+        break;
+
+      default:
+        continue;
+    }
+
+    if (lastIndex !== index) {
+      html += str.slice(lastIndex, index);
+    }
+
+    lastIndex = index + 1;
+    html += escape;
+  }
+
+  return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+} // end code copied and modified from escape-html
+
+/**
+ * Escapes text to prevent scripting attacks.
+ *
+ * @param {*} text Text value to escape.
+ * @return {string} An escaped string.
+ */
+
+
+function escapeTextForBrowser(text) {
+  if (typeof text === 'boolean' || typeof text === 'number') {
+    // this shortcircuit helps perf for types that we know will never have
+    // special characters, especially given that this function is used often
+    // for numeric dom ids.
+    return '' + text;
+  }
+
+  return escapeHtml(text);
+}
+
+const uppercasePattern = /([A-Z])/g;
+const msPattern = /^ms-/;
+/**
+ * Hyphenates a camelcased CSS property name, for example:
+ *
+ *   > hyphenateStyleName('backgroundColor')
+ *   < "background-color"
+ *   > hyphenateStyleName('MozTransition')
+ *   < "-moz-transition"
+ *   > hyphenateStyleName('msTransition')
+ *   < "-ms-transition"
+ *
+ * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
+ * is converted to `-ms-`.
+ */
+
+function hyphenateStyleName(name) {
+  return name.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern, '-ms-');
+}
+
+function sanitizeURL(url) {
+
+  return url;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+// The build script is at scripts/rollup/generate-inline-fizz-runtime.js.
+// Run `yarn generate-inline-fizz-runtime` to generate.
+const clientRenderBoundary = '$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};';
+const completeBoundary = '$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};';
+const completeBoundaryWithStyles = '$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};';
+const completeSegment = '$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};';
+const formReplaying = 'addEventListener("submit",function(a){if(!a.defaultPrevented){var c=a.target,d=a.submitter,e=c.action,b=d;if(d){var f=d.getAttribute("formAction");null!=f&&(e=f,b=null)}"javascript:throw new Error(\'A React form was unexpectedly submitted.\')"===e&&(a.preventDefault(),b?(a=document.createElement("input"),a.name=b.name,a.value=b.value,b.parentNode.insertBefore(a,b),b=new FormData(c),a.parentNode.removeChild(a)):b=new FormData(c),a=c.getRootNode(),(a.$$reactFormReplay=a.$$reactFormReplay||[]).push(c,\nd,b))}});';
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+// same object across all transitions.
+
+const sharedNotPendingObject = {
+  pending: false,
+  data: null,
+  method: null,
+  action: null
+};
+const NotPending = sharedNotPendingObject;
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+const ReactDOMServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMServerDispatcher;
+} // We make every property of the descriptor optional because it is not a contract that
+const ScriptStreamingFormat = 0;
+const DataStreamingFormat = 1;
+const NothingSent
+/*                      */
+= 0b00000;
+const SentCompleteSegmentFunction
+/*      */
+= 0b00001;
+const SentCompleteBoundaryFunction
+/*     */
+= 0b00010;
+const SentClientRenderFunction
+/*         */
+= 0b00100;
+const SentStyleInsertionFunction
+/*       */
+= 0b01000;
+const SentFormReplayingRuntime
+/*         */
+= 0b10000; // Per request, global state that is not contextual to the rendering subtree.
+// This cannot be resumed and therefore should only contain things that are
+// temporary working state or are never used in the prerender pass.
+// Credentials here are things that affect whether a browser will make a request
+// as well as things that affect which connection the browser will use for that request.
+// We want these to be aligned across preloads and resources because otherwise the preload
+// will be wasted.
+// We investigated whether referrerPolicy should be included here but from experimentation
+// it seems that browsers do not treat this as part of the http cache key and does not affect
+// which connection is used.
+
+const EXISTS = null; // This constant is to mark preloads that have no unique credentials
+// to convey. It should never be checked by identity and we should not
+// assume Preload values in ResumableState equal this value because they
+// will have come from some parsed input.
+
+const PRELOAD_NO_CREDS = [];
+// This is resumable and therefore should be serializable.
+
+
+const dataElementQuotedEnd = stringToPrecomputedChunk('"></template>');
+const startInlineScript = stringToPrecomputedChunk('<script>');
+const endInlineScript = stringToPrecomputedChunk('</script>');
+const startScriptSrc = stringToPrecomputedChunk('<script src="');
+const startModuleSrc = stringToPrecomputedChunk('<script type="module" src="');
+const scriptNonce = stringToPrecomputedChunk('" nonce="');
+const scriptIntegirty = stringToPrecomputedChunk('" integrity="');
+const scriptCrossOrigin = stringToPrecomputedChunk('" crossorigin="');
+const endAsyncScript = stringToPrecomputedChunk('" async=""></script>');
+/**
+ * This escaping function is designed to work with bootstrapScriptContent and importMap only.
+ * because we know we are escaping the entire script. We can avoid for instance
+ * escaping html comment string sequences that are valid javascript as well because
+ * if there are no sebsequent <script sequences the html parser will never enter
+ * script data double escaped state (see: https://www.w3.org/TR/html53/syntax.html#script-data-double-escaped-state)
+ *
+ * While untrusted script content should be made safe before using this api it will
+ * ensure that the script cannot be early terminated or never terminated state
+ */
+
+function escapeBootstrapAndImportMapScriptContent(scriptText) {
+
+  return ('' + scriptText).replace(scriptRegex, scriptReplacer);
+}
+
+const scriptRegex = /(<\/|<)(s)(cript)/gi;
+
+const scriptReplacer = (match, prefix, s, suffix) => "" + prefix + (s === 's' ? '\\u0073' : '\\u0053') + suffix;
+
+const importMapScriptStart = stringToPrecomputedChunk('<script type="importmap">');
+const importMapScriptEnd = stringToPrecomputedChunk('</script>'); // Since we store headers as strings we deal with their length in utf16 code units
+// rather than visual characters or the utf8 encoding that is used for most binary
+// serialization. Some common HTTP servers only allow for headers to be 4kB in length.
+// We choose a default length that is likely to be well under this already limited length however
+// pathological cases may still cause the utf-8 encoding of the headers to approach this limit.
+// It should also be noted that this maximum is a soft maximum. we have not reached the limit we will
+// allow one more header to be captured which means in practice if the limit is approached it will be exceeded
+
+const DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS = 2000; // Allows us to keep track of what we've already written so we can refer back to it.
+// if passed externalRuntimeConfig and the enableFizzExternalRuntime feature flag
+// is set, the server will send instructions via data attributes (instead of inline scripts)
+
+function createRenderState(resumableState, nonce, externalRuntimeConfig, importMap, onHeaders, maxHeadersLength) {
+  const inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
+  const idPrefix = resumableState.idPrefix;
+  const bootstrapChunks = [];
+  let externalRuntimeScript = null;
+  const bootstrapScriptContent = resumableState.bootstrapScriptContent,
+        bootstrapScripts = resumableState.bootstrapScripts,
+        bootstrapModules = resumableState.bootstrapModules;
+
+  if (bootstrapScriptContent !== undefined) {
+    bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapAndImportMapScriptContent(bootstrapScriptContent)), endInlineScript);
+  }
+
+  {
+
+    if (externalRuntimeConfig !== undefined) {
+      if (typeof externalRuntimeConfig === 'string') {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig,
+          async: true,
+          integrity: undefined,
+          nonce: nonce
+        });
+      } else {
+        externalRuntimeScript = {
+          src: externalRuntimeConfig.src,
+          chunks: []
+        };
+        pushScriptImpl(externalRuntimeScript.chunks, {
+          src: externalRuntimeConfig.src,
+          async: true,
+          integrity: externalRuntimeConfig.integrity,
+          nonce: nonce
+        });
+      }
+    }
+  }
+
+  const importMapChunks = [];
+
+  if (importMap !== undefined) {
+    const map = importMap;
+    importMapChunks.push(importMapScriptStart);
+    importMapChunks.push(stringToChunk(escapeBootstrapAndImportMapScriptContent(JSON.stringify(map))));
+    importMapChunks.push(importMapScriptEnd);
+  }
+
+  const headers = onHeaders ? {
+    preconnects: '',
+    fontPreloads: '',
+    highImagePreloads: '',
+    remainingCapacity: typeof maxHeadersLength === 'number' ? maxHeadersLength : DEFAULT_HEADERS_CAPACITY_IN_UTF16_CODE_UNITS
+  } : null;
+  const renderState = {
+    placeholderPrefix: stringToPrecomputedChunk(idPrefix + 'P:'),
+    segmentPrefix: stringToPrecomputedChunk(idPrefix + 'S:'),
+    boundaryPrefix: stringToPrecomputedChunk(idPrefix + 'B:'),
+    startInlineScript: inlineScriptWithNonce,
+    htmlChunks: null,
+    headChunks: null,
+    externalRuntimeScript: externalRuntimeScript,
+    bootstrapChunks: bootstrapChunks,
+    onHeaders,
+    headers,
+    resets: {
+      font: {},
+      dns: {},
+      connect: {
+        default: {},
+        anonymous: {},
+        credentials: {}
+      },
+      image: {},
+      style: {}
+    },
+    charsetChunks: [],
+    preconnectChunks: [],
+    importMapChunks,
+    preloadChunks: [],
+    hoistableChunks: [],
+    // cleared on flush
+    preconnects: new Set(),
+    fontPreloads: new Set(),
+    highImagePreloads: new Set(),
+    // usedImagePreloads: new Set(),
+    styles: new Map(),
+    bootstrapScripts: new Set(),
+    scripts: new Set(),
+    bulkPreloads: new Set(),
+    preloads: {
+      images: new Map(),
+      stylesheets: new Map(),
+      scripts: new Map(),
+      moduleScripts: new Map()
+    },
+    nonce,
+    // like a module global for currently rendering boundary
+    boundaryResources: null,
+    stylesToHoist: false
+  };
+
+  if (bootstrapScripts !== undefined) {
+    for (let i = 0; i < bootstrapScripts.length; i++) {
+      const scriptConfig = bootstrapScripts[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'preload',
+        as: 'script',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startScriptSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  if (bootstrapModules !== undefined) {
+    for (let i = 0; i < bootstrapModules.length; i++) {
+      const scriptConfig = bootstrapModules[i];
+      let src, crossOrigin, integrity;
+      const props = {
+        rel: 'modulepreload',
+        fetchPriority: 'low',
+        nonce
+      };
+
+      if (typeof scriptConfig === 'string') {
+        props.href = src = scriptConfig;
+      } else {
+        props.href = src = scriptConfig.src;
+        props.integrity = integrity = typeof scriptConfig.integrity === 'string' ? scriptConfig.integrity : undefined;
+        props.crossOrigin = crossOrigin = typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null ? undefined : scriptConfig.crossOrigin === 'use-credentials' ? 'use-credentials' : '';
+      }
+
+      preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
+      bootstrapChunks.push(startModuleSrc, stringToChunk(escapeTextForBrowser(src)));
+
+      if (nonce) {
+        bootstrapChunks.push(scriptNonce, stringToChunk(escapeTextForBrowser(nonce)));
+      }
+
+      if (typeof integrity === 'string') {
+        bootstrapChunks.push(scriptIntegirty, stringToChunk(escapeTextForBrowser(integrity)));
+      }
+
+      if (typeof crossOrigin === 'string') {
+        bootstrapChunks.push(scriptCrossOrigin, stringToChunk(escapeTextForBrowser(crossOrigin)));
+      }
+
+      bootstrapChunks.push(endAsyncScript);
+    }
+  }
+
+  return renderState;
+}
+function createResumableState(identifierPrefix, externalRuntimeConfig, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
+  const idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
+  let streamingFormat = ScriptStreamingFormat;
+
+  {
+    if (externalRuntimeConfig !== undefined) {
+      streamingFormat = DataStreamingFormat;
+    }
+  }
+
+  return {
+    idPrefix: idPrefix,
+    nextFormID: 0,
+    streamingFormat,
+    bootstrapScriptContent,
+    bootstrapScripts,
+    bootstrapModules,
+    instructions: NothingSent,
+    hasBody: false,
+    hasHtml: false,
+    // @TODO add bootstrap script to implicit preloads
+    // persistent
+    unknownResources: {},
+    dnsResources: {},
+    connectResources: {
+      default: {},
+      anonymous: {},
+      credentials: {}
+    },
+    imageResources: {},
+    styleResources: {},
+    scriptResources: {},
+    moduleUnknownResources: {},
+    moduleScriptResources: {}
+  };
+}
+// modes. We only include the variants as they matter for the sake of our purposes.
+// We don't actually provide the namespace therefore we use constants instead of the string.
+
+const ROOT_HTML_MODE = 0; // Used for the root most element tag.
+// We have a less than HTML_HTML_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const HTML_HTML_MODE = 1; // Used for the <html> if it is at the top level.
+
+const HTML_MODE = 2;
+const SVG_MODE = 3;
+const MATHML_MODE = 4;
+const HTML_TABLE_MODE = 5;
+const HTML_TABLE_BODY_MODE = 6;
+const HTML_TABLE_ROW_MODE = 7;
+const HTML_COLGROUP_MODE = 8; // We have a greater than HTML_TABLE_MODE check elsewhere. If you add more cases here, make sure it
+// still makes sense
+
+const NO_SCOPE =
+/*         */
+0b00;
+const NOSCRIPT_SCOPE =
+/*   */
+0b01;
+const PICTURE_SCOPE =
+/*    */
+0b10; // Lets us keep track of contextual state and pick it back up after suspending.
+
+function createFormatContext(insertionMode, selectedValue, tagScope) {
+  return {
+    insertionMode,
+    selectedValue,
+    tagScope
+  };
+}
+
+function createRootFormatContext(namespaceURI) {
+  const insertionMode = namespaceURI === 'http://www.w3.org/2000/svg' ? SVG_MODE : namespaceURI === 'http://www.w3.org/1998/Math/MathML' ? MATHML_MODE : ROOT_HTML_MODE;
+  return createFormatContext(insertionMode, null, NO_SCOPE);
+}
+function getChildFormatContext(parentContext, type, props) {
+  switch (type) {
+    case 'noscript':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | NOSCRIPT_SCOPE);
+
+    case 'select':
+      return createFormatContext(HTML_MODE, props.value != null ? props.value : props.defaultValue, parentContext.tagScope);
+
+    case 'svg':
+      return createFormatContext(SVG_MODE, null, parentContext.tagScope);
+
+    case 'picture':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope | PICTURE_SCOPE);
+
+    case 'math':
+      return createFormatContext(MATHML_MODE, null, parentContext.tagScope);
+
+    case 'foreignObject':
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    // Table parents are special in that their children can only be created at all if they're
+    // wrapped in a table parent. So we need to encode that we're entering this mode.
+
+    case 'table':
+      return createFormatContext(HTML_TABLE_MODE, null, parentContext.tagScope);
+
+    case 'thead':
+    case 'tbody':
+    case 'tfoot':
+      return createFormatContext(HTML_TABLE_BODY_MODE, null, parentContext.tagScope);
+
+    case 'colgroup':
+      return createFormatContext(HTML_COLGROUP_MODE, null, parentContext.tagScope);
+
+    case 'tr':
+      return createFormatContext(HTML_TABLE_ROW_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode >= HTML_TABLE_MODE) {
+    // Whatever tag this was, it wasn't a table parent or other special parent, so we must have
+    // entered plain HTML again.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  if (parentContext.insertionMode === ROOT_HTML_MODE) {
+    if (type === 'html') {
+      // We've emitted the root and is now in <html> mode.
+      return createFormatContext(HTML_HTML_MODE, null, parentContext.tagScope);
+    } else {
+      // We've emitted the root and is now in plain HTML mode.
+      return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+    }
+  } else if (parentContext.insertionMode === HTML_HTML_MODE) {
+    // We've emitted the document element and is now in plain HTML mode.
+    return createFormatContext(HTML_MODE, null, parentContext.tagScope);
+  }
+
+  return parentContext;
+}
+function makeId(resumableState, treeId, localId) {
+  const idPrefix = resumableState.idPrefix;
+  let id = ':' + idPrefix + 'R' + treeId; // Unless this is the first id at this level, append a number at the end
+  // that represents the position of this useId hook among all the useId
+  // hooks for this fiber.
+
+  if (localId > 0) {
+    id += 'H' + localId.toString(32);
+  }
+
+  return id + ':';
+}
+
+function encodeHTMLTextNode(text) {
+  return escapeTextForBrowser(text);
+}
+
+const textSeparator = stringToPrecomputedChunk('<!-- -->');
+function pushTextInstance(target, text, renderState, textEmbedded) {
+  if (text === '') {
+    // Empty text doesn't have a DOM node representation and the hydration is aware of this.
+    return textEmbedded;
+  }
+
+  if (textEmbedded) {
+    target.push(textSeparator);
+  }
+
+  target.push(stringToChunk(encodeHTMLTextNode(text)));
+  return true;
+} // Called when Fizz is done with a Segment. Currently the only purpose is to conditionally
+// emit a text separator when we don't know for sure it is safe to omit
+
+function pushSegmentFinale(target, renderState, lastPushedText, textEmbedded) {
+  if (lastPushedText && textEmbedded) {
+    target.push(textSeparator);
+  }
+}
+const styleNameCache = new Map();
+
+function processStyleName(styleName) {
+  const chunk = styleNameCache.get(styleName);
+
+  if (chunk !== undefined) {
+    return chunk;
+  }
+
+  const result = stringToPrecomputedChunk(escapeTextForBrowser(hyphenateStyleName(styleName)));
+  styleNameCache.set(styleName, result);
+  return result;
+}
+
+const styleAttributeStart = stringToPrecomputedChunk(' style="');
+const styleAssign = stringToPrecomputedChunk(':');
+const styleSeparator = stringToPrecomputedChunk(';');
+
+function pushStyleAttribute(target, style) {
+  if (typeof style !== 'object') {
+    throw new Error('The `style` prop expects a mapping from style properties to values, ' + "not a string. For example, style={{marginRight: spacing + 'em'}} when " + 'using JSX.');
+  }
+
+  let isFirst = true;
+
+  for (const styleName in style) {
+    if (!hasOwnProperty.call(style, styleName)) {
+      continue;
+    } // If you provide unsafe user data here they can inject arbitrary CSS
+    // which may be problematic (I couldn't repro this):
+    // https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet
+    // http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/
+    // This is not an XSS hole but instead a potential CSS injection issue
+    // which has lead to a greater discussion about how we're going to
+    // trust URLs moving forward. See #2115901
+
+
+    const styleValue = style[styleName];
+
+    if (styleValue == null || typeof styleValue === 'boolean' || styleValue === '') {
+      // TODO: We used to set empty string as a style with an empty value. Does that ever make sense?
+      continue;
+    }
+
+    let nameChunk;
+    let valueChunk;
+    const isCustomProperty = styleName.indexOf('--') === 0;
+
+    if (isCustomProperty) {
+      nameChunk = stringToChunk(escapeTextForBrowser(styleName));
+
+      valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+    } else {
+
+      nameChunk = processStyleName(styleName);
+
+      if (typeof styleValue === 'number') {
+        if (styleValue !== 0 && !isUnitlessNumber(styleName)) {
+          valueChunk = stringToChunk(styleValue + 'px'); // Presumes implicit 'px' suffix for unitless numbers
+        } else {
+          valueChunk = stringToChunk('' + styleValue);
+        }
+      } else {
+
+        valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
+      }
+    }
+
+    if (isFirst) {
+      isFirst = false; // If it's first, we don't need any separators prefixed.
+
+      target.push(styleAttributeStart, nameChunk, styleAssign, valueChunk);
+    } else {
+      target.push(styleSeparator, nameChunk, styleAssign, valueChunk);
+    }
+  }
+
+  if (!isFirst) {
+    target.push(attributeEnd);
+  }
+}
+
+const attributeSeparator = stringToPrecomputedChunk(' ');
+const attributeAssign = stringToPrecomputedChunk('="');
+const attributeEnd = stringToPrecomputedChunk('"');
+const attributeEmptyString = stringToPrecomputedChunk('=""');
+
+function pushBooleanAttribute(target, name, value) // not null or undefined
+{
+  if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+    target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+  }
+}
+
+function pushStringAttribute(target, name, value) // not null or undefined
+{
+  if (typeof value !== 'function' && typeof value !== 'symbol' && typeof value !== 'boolean') {
+    target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+  }
+}
+
+function makeFormFieldPrefix(resumableState) {
+  const id = resumableState.nextFormID++;
+  return resumableState.idPrefix + id;
+} // Since this will likely be repeated a lot in the HTML, we use a more concise message
+// than on the client and hopefully it's googleable.
+
+
+const actionJavaScriptURL = stringToPrecomputedChunk(escapeTextForBrowser( // eslint-disable-next-line no-script-url
+"javascript:throw new Error('A React form was unexpectedly submitted.')"));
+const startHiddenInputChunk = stringToPrecomputedChunk('<input type="hidden"');
+
+function pushAdditionalFormField(value, key) {
+  const target = this;
+  target.push(startHiddenInputChunk);
+
+  if (typeof value !== 'string') {
+    throw new Error('File/Blob fields are not yet supported in progressive forms. ' + 'It probably means you are closing over binary data or FormData in a Server Action.');
+  }
+
+  pushStringAttribute(target, 'name', key);
+  pushStringAttribute(target, 'value', value);
+  target.push(endOfStartTagSelfClosing);
+}
+
+function pushAdditionalFormFields(target, formData) {
+  if (formData !== null) {
+    // $FlowFixMe[prop-missing]: FormData has forEach.
+    formData.forEach(pushAdditionalFormField, target);
+  }
+}
+
+function pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name) {
+  let formData = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      name = customFields.name;
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('formAction'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      name = null;
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (name != null) {
+    pushAttribute(target, 'name', name);
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'formAction', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'formEncType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'formMethod', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'formTarget', formTarget);
+  }
+
+  return formData;
+}
+
+function pushAttribute(target, name, value) // not null or undefined
+{
+  switch (name) {
+    // These are very common props and therefore are in the beginning of the switch.
+    // TODO: aria-label is a very common prop but allows booleans so is not like the others
+    // but should ideally go in this list too.
+    case 'className':
+      {
+        pushStringAttribute(target, 'class', value);
+        break;
+      }
+
+    case 'tabIndex':
+      {
+        pushStringAttribute(target, 'tabindex', value);
+        break;
+      }
+
+    case 'dir':
+    case 'role':
+    case 'viewBox':
+    case 'width':
+    case 'height':
+      {
+        pushStringAttribute(target, name, value);
+        break;
+      }
+
+    case 'style':
+      {
+        pushStyleAttribute(target, value);
+        return;
+      }
+
+    case 'src':
+    case 'href':
+    // Fall through to the last case which shouldn't remove empty strings.
+
+    case 'action':
+    case 'formAction':
+      {
+        // TODO: Consider only special casing these for each tag.
+        if (value == null || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'defaultValue':
+    case 'defaultChecked': // These shouldn't be set as attributes on generic HTML elements.
+
+    case 'innerHTML': // Must use dangerouslySetInnerHTML instead.
+
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+      // Ignored. These are built-in to React on the client.
+      return;
+
+    case 'autoFocus':
+    case 'multiple':
+    case 'muted':
+      {
+        pushBooleanAttribute(target, name.toLowerCase(), value);
+        return;
+      }
+
+    case 'xlinkHref':
+      {
+        if (typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          return;
+        }
+
+        const sanitizedValue = sanitizeURL('' + value);
+        target.push(attributeSeparator, stringToChunk('xlink:href'), attributeAssign, stringToChunk(escapeTextForBrowser(sanitizedValue)), attributeEnd);
+        return;
+      }
+
+    case 'contentEditable':
+    case 'spellCheck':
+    case 'draggable':
+    case 'value':
+    case 'autoReverse':
+    case 'externalResourcesRequired':
+    case 'focusable':
+    case 'preserveAlpha':
+      {
+        // Booleanish String
+        // These are "enumerated" attributes that accept "true" and "false".
+        // In React, we let users pass `true` and `false` even though technically
+        // these aren't boolean attributes (they are coerced to strings).
+        if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'allowFullScreen':
+    case 'async':
+    case 'autoPlay':
+    case 'controls':
+    case 'default':
+    case 'defer':
+    case 'disabled':
+    case 'disablePictureInPicture':
+    case 'disableRemotePlayback':
+    case 'formNoValidate':
+    case 'hidden':
+    case 'loop':
+    case 'noModule':
+    case 'noValidate':
+    case 'open':
+    case 'playsInline':
+    case 'readOnly':
+    case 'required':
+    case 'reversed':
+    case 'scoped':
+    case 'seamless':
+    case 'itemScope':
+      {
+        // Boolean
+        if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        }
+
+        return;
+      }
+
+    case 'capture':
+    case 'download':
+      {
+        // Overloaded Boolean
+        if (value === true) {
+          target.push(attributeSeparator, stringToChunk(name), attributeEmptyString);
+        } else if (value === false) ; else if (typeof value !== 'function' && typeof value !== 'symbol') {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'cols':
+    case 'rows':
+    case 'size':
+    case 'span':
+      {
+        // These are HTML attributes that must be positive numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value) && value >= 1) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'rowSpan':
+    case 'start':
+      {
+        // These are HTML attributes that must be numbers.
+        if (typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value)) {
+          target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+        }
+
+        return;
+      }
+
+    case 'xlinkActuate':
+      pushStringAttribute(target, 'xlink:actuate', value);
+      return;
+
+    case 'xlinkArcrole':
+      pushStringAttribute(target, 'xlink:arcrole', value);
+      return;
+
+    case 'xlinkRole':
+      pushStringAttribute(target, 'xlink:role', value);
+      return;
+
+    case 'xlinkShow':
+      pushStringAttribute(target, 'xlink:show', value);
+      return;
+
+    case 'xlinkTitle':
+      pushStringAttribute(target, 'xlink:title', value);
+      return;
+
+    case 'xlinkType':
+      pushStringAttribute(target, 'xlink:type', value);
+      return;
+
+    case 'xmlBase':
+      pushStringAttribute(target, 'xml:base', value);
+      return;
+
+    case 'xmlLang':
+      pushStringAttribute(target, 'xml:lang', value);
+      return;
+
+    case 'xmlSpace':
+      pushStringAttribute(target, 'xml:space', value);
+      return;
+
+    default:
+      if ( // shouldIgnoreAttribute
+      // We have already filtered out null/undefined and reserved words.
+      name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+        return;
+      }
+
+      const attributeName = getAttributeAlias(name);
+
+      if (isAttributeNameSafe(attributeName)) {
+        // shouldRemoveAttribute
+        switch (typeof value) {
+          case 'function':
+          case 'symbol':
+            // eslint-disable-line
+            return;
+
+          case 'boolean':
+            {
+              const prefix = attributeName.toLowerCase().slice(0, 5);
+
+              if (prefix !== 'data-' && prefix !== 'aria-') {
+                return;
+              }
+            }
+        }
+
+        target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
+      }
+
+  }
+}
+
+const endOfStartTag = stringToPrecomputedChunk('>');
+const endOfStartTagSelfClosing = stringToPrecomputedChunk('/>');
+
+function pushInnerHTML(target, innerHTML, children) {
+  if (innerHTML != null) {
+    if (children != null) {
+      throw new Error('Can only set one of `children` or `props.dangerouslySetInnerHTML`.');
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw new Error('`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. ' + 'Please visit https://reactjs.org/link/dangerously-set-inner-html ' + 'for more information.');
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+
+      target.push(stringToChunk('' + html));
+    }
+  }
+} // TODO: Move these to RenderState so that we warn for every request.
+
+function pushStartSelect(target, props) {
+
+  target.push(startChunkForTag('select'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          // TODO: This doesn't really make sense for select since it can't use the controlled
+          // value in the innerHTML.
+          innerHTML = propValue;
+          break;
+
+        case 'defaultValue':
+        case 'value':
+          // These are set on the Context instead and applied to the nested options.
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+function flattenOptionChildren(children) {
+  let content = ''; // Flatten children and warn if they aren't strings or numbers;
+  // invalid types are ignored.
+
+  React.Children.forEach(children, function (child) {
+    if (child == null) {
+      return;
+    }
+
+    content += child;
+  });
+  return content;
+}
+
+const selectedMarkerAttribute = stringToPrecomputedChunk(' selected=""');
+
+function pushStartOption(target, props, formatContext) {
+  const selectedValue = formatContext.selectedValue;
+  target.push(startChunkForTag('option'));
+  let children = null;
+  let value = null;
+  let selected = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'selected':
+          // ignore
+          selected = propValue;
+
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+        // We intentionally fallthrough to also set the attribute on the node.
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (selectedValue != null) {
+    let stringValue;
+
+    if (value !== null) {
+
+      stringValue = '' + value;
+    } else {
+
+      stringValue = flattenOptionChildren(children);
+    }
+
+    if (isArray(selectedValue)) {
+      // multiple
+      for (let i = 0; i < selectedValue.length; i++) {
+
+        const v = '' + selectedValue[i];
+
+        if (v === stringValue) {
+          target.push(selectedMarkerAttribute);
+          break;
+        }
+      }
+    } else {
+
+      if ('' + selectedValue === stringValue) {
+        target.push(selectedMarkerAttribute);
+      }
+    }
+  } else if (selected) {
+    target.push(selectedMarkerAttribute);
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const formReplayingRuntimeScript = stringToPrecomputedChunk(formReplaying);
+
+function injectFormReplayingRuntime(resumableState, renderState) {
+  // If we haven't sent it yet, inject the runtime that tracks submitted JS actions
+  // for later replaying by Fiber. If we use an external runtime, we don't need
+  // to emit anything. It's always used.
+  if ((resumableState.instructions & SentFormReplayingRuntime) === NothingSent && (!renderState.externalRuntimeScript)) {
+    resumableState.instructions |= SentFormReplayingRuntime;
+    renderState.bootstrapChunks.unshift(renderState.startInlineScript, formReplayingRuntimeScript, endInlineScript);
+  }
+}
+
+const formStateMarkerIsMatching = stringToPrecomputedChunk('<!--F!-->');
+const formStateMarkerIsNotMatching = stringToPrecomputedChunk('<!--F-->');
+function pushFormStateMarkerIsMatching(target) {
+  target.push(formStateMarkerIsMatching);
+}
+function pushFormStateMarkerIsNotMatching(target) {
+  target.push(formStateMarkerIsNotMatching);
+}
+
+function pushStartForm(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('form'));
+  let children = null;
+  let innerHTML = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'action':
+          formAction = propValue;
+          break;
+
+        case 'encType':
+          formEncType = propValue;
+          break;
+
+        case 'method':
+          formMethod = propValue;
+          break;
+
+        case 'target':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  let formData = null;
+  let formActionName = null;
+
+  if (typeof formAction === 'function') {
+
+    const customAction = formAction.$$FORM_ACTION;
+
+    if (typeof customAction === 'function') {
+      // This action has a custom progressive enhancement form that can submit the form
+      // back to the server if it's invoked before hydration. Such as a Server Action.
+      const prefix = makeFormFieldPrefix(resumableState);
+      const customFields = formAction.$$FORM_ACTION(prefix);
+      formAction = customFields.action || '';
+      formEncType = customFields.encType;
+      formMethod = customFields.method;
+      formTarget = customFields.target;
+      formData = customFields.data;
+      formActionName = customFields.name;
+    } else {
+      // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+      // because we'll preventDefault in the Fizz runtime, but it can happen if a form is
+      // manually submitted or if someone calls stopPropagation before React gets the event.
+      // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+      // error message but the URL will be logged.
+      target.push(attributeSeparator, stringToChunk('action'), attributeAssign, actionJavaScriptURL, attributeEnd);
+      formAction = null;
+      formEncType = null;
+      formMethod = null;
+      formTarget = null;
+      injectFormReplayingRuntime(resumableState, renderState);
+    }
+  }
+
+  if (formAction != null) {
+    pushAttribute(target, 'action', formAction);
+  }
+
+  if (formEncType != null) {
+    pushAttribute(target, 'encType', formEncType);
+  }
+
+  if (formMethod != null) {
+    pushAttribute(target, 'method', formMethod);
+  }
+
+  if (formTarget != null) {
+    pushAttribute(target, 'target', formTarget);
+  }
+
+  target.push(endOfStartTag);
+
+  if (formActionName !== null) {
+    target.push(startHiddenInputChunk);
+    pushStringAttribute(target, 'name', formActionName);
+    target.push(endOfStartTagSelfClosing);
+    pushAdditionalFormFields(target, formData);
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushInput(target, props, resumableState, renderState) {
+
+  target.push(startChunkForTag('input'));
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+  let value = null;
+  let defaultValue = null;
+  let checked = null;
+  let defaultChecked = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('input' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        case 'defaultChecked':
+          defaultChecked = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'checked':
+          checked = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+
+  if (checked !== null) {
+    pushBooleanAttribute(target, 'checked', checked);
+  } else if (defaultChecked !== null) {
+    pushBooleanAttribute(target, 'checked', defaultChecked);
+  }
+
+  if (value !== null) {
+    pushAttribute(target, 'value', value);
+  } else if (defaultValue !== null) {
+    pushAttribute(target, 'value', defaultValue);
+  }
+
+  target.push(endOfStartTagSelfClosing); // We place any additional hidden form fields after the input.
+
+  pushAdditionalFormFields(target, formData);
+  return null;
+}
+
+function pushStartButton(target, props, resumableState, renderState) {
+  target.push(startChunkForTag('button'));
+  let children = null;
+  let innerHTML = null;
+  let name = null;
+  let formAction = null;
+  let formEncType = null;
+  let formMethod = null;
+  let formTarget = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'name':
+          name = propValue;
+          break;
+
+        case 'formAction':
+          formAction = propValue;
+          break;
+
+        case 'formEncType':
+          formEncType = propValue;
+          break;
+
+        case 'formMethod':
+          formMethod = propValue;
+          break;
+
+        case 'formTarget':
+          formTarget = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  const formData = pushFormActionAttribute(target, resumableState, renderState, formAction, formEncType, formMethod, formTarget, name);
+  target.push(endOfStartTag); // We place any additional hidden form fields we need to include inside the button itself.
+
+  pushAdditionalFormFields(target, formData);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartTextArea(target, props) {
+
+  target.push(startChunkForTag('textarea'));
+  let value = null;
+  let defaultValue = null;
+  let children = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'value':
+          value = propValue;
+          break;
+
+        case 'defaultValue':
+          defaultValue = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          throw new Error('`dangerouslySetInnerHTML` does not make sense on <textarea>.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  if (value === null && defaultValue !== null) {
+    value = defaultValue;
+  }
+
+  target.push(endOfStartTag); // TODO (yungsters): Remove support for children content in <textarea>.
+
+  if (children != null) {
+
+    if (value != null) {
+      throw new Error('If you supply `defaultValue` on a <textarea>, do not pass children.');
+    }
+
+    if (isArray(children)) {
+      if (children.length > 1) {
+        throw new Error('<textarea> can only have at most one child.');
+      } // TODO: remove the coercion and the DEV check below because it will
+
+      value = '' + children[0];
+    }
+
+    value = '' + children;
+  }
+
+  if (typeof value === 'string' && value[0] === '\n') {
+    // text/html ignores the first character in these tags if it's a newline
+    // Prefer to break application/xml over text/html (for now) by adding
+    // a newline specifically to get eaten by the parser. (Alternately for
+    // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+    // \r is normalized out by HTMLTextAreaElement#value.)
+    // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+    // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+    // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+    // See: Parsing of "textarea" "listing" and "pre" elements
+    //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+    target.push(leadingNewline);
+  } // ToString and push directly instead of recurse over children.
+  // We don't really support complex children in the value anyway.
+  // This also currently avoids a trailing comment node which breaks textarea.
+
+
+  if (value !== null) {
+
+    target.push(stringToChunk(encodeHTMLTextNode('' + value)));
+  }
+
+  return null;
+}
+
+function pushMeta(target, props, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      return pushSelfClosing(target, props, 'meta');
+    } else {
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      if (typeof props.charSet === 'string') {
+        return pushSelfClosing(renderState.charsetChunks, props, 'meta');
+      } else if (props.name === 'viewport') {
+        // "viewport" isn't related to preconnect but it has the right priority
+        return pushSelfClosing(renderState.preconnectChunks, props, 'meta');
+      } else {
+        return pushSelfClosing(renderState.hoistableChunks, props, 'meta');
+      }
+    }
+  }
+}
+
+function pushLink(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const rel = props.rel;
+    const href = props.href;
+    const precedence = props.precedence;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof rel !== 'string' || typeof href !== 'string' || href === '') {
+
+      pushLinkImpl(target, props);
+      return null;
+    }
+
+    if (props.rel === 'stylesheet') {
+      // This <link> may hoistable as a Stylesheet Resource, otherwise it will emit in place
+      const key = getResourceKey(href);
+
+      if (typeof precedence !== 'string' || props.disabled != null || props.onLoad || props.onError) {
+
+        return pushLinkImpl(target, props);
+      } else {
+        // This stylesheet refers to a Resource and we create a new one if necessary
+        let styleQueue = renderState.styles.get(precedence);
+        const hasKey = resumableState.styleResources.hasOwnProperty(key);
+        const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+        if (resourceState !== EXISTS) {
+          // We are going to create this resource now so it is marked as Exists
+          resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+          // to create a StyleQueue
+
+          if (!styleQueue) {
+            styleQueue = {
+              precedence: stringToChunk(escapeTextForBrowser(precedence)),
+              rules: [],
+              hrefs: [],
+              sheets: new Map()
+            };
+            renderState.styles.set(precedence, styleQueue);
+          }
+
+          const resource = {
+            state: PENDING$1,
+            props: stylesheetPropsFromRawProps(props)
+          };
+
+          if (resourceState) {
+            // When resourceState is truty it is a Preload state. We cast it for clarity
+            const preloadState = resourceState;
+
+            if (preloadState.length === 2) {
+              adoptPreloadCredentials(resource.props, preloadState);
+            }
+
+            const preloadResource = renderState.preloads.stylesheets.get(key);
+
+            if (preloadResource && preloadResource.length > 0) {
+              // The Preload for this resource was created in this render pass and has not flushed yet so
+              // we need to clear it to avoid it flushing.
+              preloadResource.length = 0;
+            } else {
+              // Either the preload resource from this render already flushed in this render pass
+              // or the preload flushed in a prior pass (prerender). In either case we need to mark
+              // this resource as already having been preloaded.
+              resource.state = PRELOADED;
+            }
+          } // We add the newly created resource to our StyleQueue and if necessary
+          // track the resource with the currently rendering boundary
+
+
+          styleQueue.sheets.set(key, resource);
+
+          if (renderState.boundaryResources) {
+            renderState.boundaryResources.stylesheets.add(resource);
+          }
+        } else {
+          // We need to track whether this boundary should wait on this resource or not.
+          // Typically this resource should always exist since we either had it or just created
+          // it. However, it's possible when you resume that the style has already been emitted
+          // and then it wouldn't be recreated in the RenderState and there's no need to track
+          // it again since we should've hoisted it to the shell already.
+          if (styleQueue) {
+            const resource = styleQueue.sheets.get(key);
+
+            if (resource) {
+              if (renderState.boundaryResources) {
+                renderState.boundaryResources.stylesheets.add(resource);
+              }
+            }
+          }
+        }
+
+        if (textEmbedded) {
+          // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+          // to be safe and assume text will follow by inserting a textSeparator
+          target.push(textSeparator);
+        }
+
+        return null;
+      }
+    } else if (props.onLoad || props.onError) {
+      // When using load handlers we cannot hoist and need to emit links in place
+      return pushLinkImpl(target, props);
+    } else {
+      // We can hoist this link so we may need to emit a text separator.
+      // @TODO refactor text separators so we don't have to defensively add
+      // them when we don't end up emitting a tag as a result of pushStartInstance
+      if (textEmbedded) {
+        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+        // to be safe and assume text will follow by inserting a textSeparator
+        target.push(textSeparator);
+      }
+
+      switch (props.rel) {
+        case 'preconnect':
+        case 'dns-prefetch':
+          return pushLinkImpl(renderState.preconnectChunks, props);
+
+        case 'preload':
+          return pushLinkImpl(renderState.preloadChunks, props);
+
+        default:
+          return pushLinkImpl(renderState.hoistableChunks, props);
+      }
+    }
+  }
+}
+
+function pushLinkImpl(target, props) {
+  target.push(startChunkForTag('link'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStyle(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+
+  {
+    const precedence = props.precedence;
+    const href = props.href;
+
+    if (insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null || typeof precedence !== 'string' || typeof href !== 'string' || href === '') {
+      // This style tag is not able to be turned into a Style Resource
+      return pushStyleImpl(target, props);
+    }
+
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS;
+
+      if (!styleQueue) {
+        // This is the first time we've encountered this precedence we need
+        // to create a StyleQueue.
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [stringToChunk(escapeTextForBrowser(href))],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      } else {
+        // We have seen this precedence before and need to track this href
+        styleQueue.hrefs.push(stringToChunk(escapeTextForBrowser(href)));
+      }
+
+      pushStyleContents(styleQueue.rules, props);
+    }
+
+    if (styleQueue) {
+      // We need to track whether this boundary should wait on this resource or not.
+      // Typically this resource should always exist since we either had it or just created
+      // it. However, it's possible when you resume that the style has already been emitted
+      // and then it wouldn't be recreated in the RenderState and there's no need to track
+      // it again since we should've hoisted it to the shell already.
+      if (renderState.boundaryResources) {
+        renderState.boundaryResources.styles.add(styleQueue);
+      }
+    }
+
+    if (textEmbedded) {
+      // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+  }
+}
+
+function pushStyleImpl(target, props) {
+  target.push(startChunkForTag('style'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('style'));
+  return null;
+}
+
+function pushStyleContents(target, props) {
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+      }
+    }
+  }
+
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  return;
+}
+
+function pushImg(target, props, resumableState, renderState, pictureTagInScope) {
+  const src = props.src,
+        srcSet = props.srcSet;
+
+  if (props.loading !== 'lazy' && (src || srcSet) && (typeof src === 'string' || src == null) && (typeof srcSet === 'string' || srcSet == null) && props.fetchPriority !== 'low' && pictureTagInScope === false && // We exclude data URIs in src and srcSet since these should not be preloaded
+  !(typeof src === 'string' && src[4] === ':' && (src[0] === 'd' || src[0] === 'D') && (src[1] === 'a' || src[1] === 'A') && (src[2] === 't' || src[2] === 'T') && (src[3] === 'a' || src[3] === 'A')) && !(typeof srcSet === 'string' && srcSet[4] === ':' && (srcSet[0] === 'd' || srcSet[0] === 'D') && (srcSet[1] === 'a' || srcSet[1] === 'A') && (srcSet[2] === 't' || srcSet[2] === 'T') && (srcSet[3] === 'a' || srcSet[3] === 'A'))) {
+    // We have a suspensey image and ought to preload it to optimize the loading of display blocking
+    // resumableState.
+    const sizes = typeof props.sizes === 'string' ? props.sizes : undefined;
+    const key = getImageResourceKey(src, srcSet, sizes);
+    const promotablePreloads = renderState.preloads.images;
+    let resource = promotablePreloads.get(key);
+
+    if (resource) {
+      // We consider whether this preload can be promoted to higher priority flushing queue.
+      // The only time a resource will exist here is if it was created during this render
+      // and was not already in the high priority queue.
+      if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+        // Delete the resource from the map since we are promoting it and don't want to
+        // reenter this branch in a second pass for duplicate img hrefs.
+        promotablePreloads.delete(key); // $FlowFixMe - Flow should understand that this is a Resource if the condition was true
+
+        renderState.highImagePreloads.add(resource);
+      }
+    } else if (!resumableState.imageResources.hasOwnProperty(key)) {
+      // We must construct a new preload resource
+      resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+      const crossOrigin = getCrossOriginString(props.crossOrigin);
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // this is a hueristic similar to capping element preloads to 10 unless explicitly
+      // fetchPriority="high". We use length here which means it will fit fewer images when
+      // the urls are long and more when short. arguably byte size is a better hueristic because
+      // it directly translates to how much we send down before content is actually seen.
+      // We could unify the counts and also make it so the total is tracked regardless of
+      // flushing output but since the headers are likely to be go earlier than content
+      // they don't really conflict so for now I've kept them separate
+      props.fetchPriority === 'high' || headers.highImagePreloads.length < 500) && ( // We manually construct the options for the preload only from strings. We don't want to pollute
+      // the params list with arbitrary props and if we copied everything over as it we might get
+      // coercion errors. We have checks for this in Dev but it seems safer to just only accept values
+      // that are strings
+      header = getPreloadAsHeader(src, 'image', {
+        imageSrcSet: props.srcSet,
+        imageSizes: props.sizes,
+        crossOrigin,
+        integrity: props.integrity,
+        nonce: props.nonce,
+        type: props.type,
+        fetchPriority: props.fetchPriority,
+        referrerPolicy: props.refererPolicy
+      }), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // If we postpone in the shell we will still emit this preload so we track
+        // it to make sure we don't reset it.
+        renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+        if (headers.highImagePreloads) {
+          headers.highImagePreloads += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.highImagePreloads += header;
+      } else {
+        resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preload',
+          as: 'image',
+          // There is a bug in Safari where imageSrcSet is not respected on preload links
+          // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+          // This harms older browers that do not support imageSrcSet by making their preloads not work
+          // but this population is shrinking fast and is already small so we accept this tradeoff.
+          href: srcSet ? undefined : src,
+          imageSrcSet: srcSet,
+          imageSizes: sizes,
+          crossOrigin: crossOrigin,
+          integrity: props.integrity,
+          type: props.type,
+          fetchPriority: props.fetchPriority,
+          referrerPolicy: props.referrerPolicy
+        });
+
+        if (props.fetchPriority === 'high' || renderState.highImagePreloads.size < 10) {
+          renderState.highImagePreloads.add(resource);
+        } else {
+          renderState.bulkPreloads.add(resource); // We can bump the priority up if the same img is rendered later
+          // with fetchPriority="high"
+
+          promotablePreloads.set(key, resource);
+        }
+      }
+    }
+  }
+
+  return pushSelfClosing(target, props, 'img');
+}
+
+function pushSelfClosing(target, props, tag) {
+  target.push(startChunkForTag(tag));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error(tag + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTagSelfClosing);
+  return null;
+}
+
+function pushStartMenuItem(target, props) {
+  target.push(startChunkForTag('menuitem'));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('menuitems cannot have `children` nor `dangerouslySetInnerHTML`.');
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  return null;
+}
+
+function pushTitle(target, props, renderState, insertionMode, noscriptTagInScope) {
+
+  {
+    if (insertionMode !== SVG_MODE && !noscriptTagInScope && props.itemProp == null) {
+      pushTitleImpl(renderState.hoistableChunks, props);
+      return null;
+    } else {
+      return pushTitleImpl(target, props);
+    }
+  }
+}
+
+function pushTitleImpl(target, props) {
+  target.push(startChunkForTag('title'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  const child = Array.isArray(children) ? children.length < 2 ? children[0] : null : children;
+
+  if (typeof child !== 'function' && typeof child !== 'symbol' && child !== null && child !== undefined) {
+    // eslint-disable-next-line react-internal/safe-string-coercion
+    target.push(stringToChunk(escapeTextForBrowser('' + child)));
+  }
+
+  pushInnerHTML(target, innerHTML, children);
+  target.push(endChunkForTag('title'));
+  return null;
+}
+
+function pushStartHead(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode < HTML_MODE && renderState.headChunks === null) {
+      // This <head> is the Document.head and should be part of the preamble
+      renderState.headChunks = [];
+      return pushStartGenericElement(renderState.headChunks, props, 'head');
+    } else {
+      // This <head> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'head');
+    }
+  }
+}
+
+function pushStartHtml(target, props, renderState, insertionMode) {
+  {
+    if (insertionMode === ROOT_HTML_MODE && renderState.htmlChunks === null) {
+      // This <html> is the Document.documentElement and should be part of the preamble
+      renderState.htmlChunks = [doctypeChunk];
+      return pushStartGenericElement(renderState.htmlChunks, props, 'html');
+    } else {
+      // This <html> is deep and is likely just an error. we emit it inline though.
+      // Validation should warn that this tag is the the wrong spot.
+      return pushStartGenericElement(target, props, 'html');
+    }
+  }
+}
+
+function pushScript(target, props, resumableState, renderState, textEmbedded, insertionMode, noscriptTagInScope) {
+  {
+    const asyncProp = props.async;
+
+    if (typeof props.src !== 'string' || !props.src || !(asyncProp && typeof asyncProp !== 'function' && typeof asyncProp !== 'symbol') || props.onLoad || props.onError || insertionMode === SVG_MODE || noscriptTagInScope || props.itemProp != null) {
+      // This script will not be a resource, we bailout early and emit it in place.
+      return pushScriptImpl(target, props);
+    }
+
+    const src = props.src;
+    const key = getResourceKey(src); // We can make this <script> into a ScriptResource
+
+    let resources, preloads;
+
+    if (props.type === 'module') {
+      resources = resumableState.moduleScriptResources;
+      preloads = renderState.preloads.moduleScripts;
+    } else {
+      resources = resumableState.scriptResources;
+      preloads = renderState.preloads.scripts;
+    }
+
+    const hasKey = resources.hasOwnProperty(key);
+    const resourceState = hasKey ? resources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resources[key] = EXISTS;
+      let scriptProps = props;
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          scriptProps = assign({}, props);
+          adoptPreloadCredentials(scriptProps, preloadState);
+        }
+
+        const preloadResource = preloads.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, scriptProps);
+    }
+
+    if (textEmbedded) {
+      // This script follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+
+    return null;
+  }
+}
+
+function pushScriptImpl(target, props) {
+  target.push(startChunkForTag('script'));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+  }
+
+  target.push(endChunkForTag('script'));
+  return null;
+}
+
+function pushStartGenericElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+
+  if (typeof children === 'string') {
+    // Special case children as a string to avoid the unnecessary comment.
+    // TODO: Remove this special case after the general optimization is in place.
+    target.push(stringToChunk(encodeHTMLTextNode(children)));
+    return null;
+  }
+
+  return children;
+}
+
+function pushStartCustomElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      let propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      let attributeName = propKey;
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        case 'style':
+          pushStyleAttribute(target, propValue);
+          break;
+
+        case 'suppressContentEditableWarning':
+        case 'suppressHydrationWarning':
+          // Ignored. These are built-in to React on the client.
+          break;
+
+        case 'className':
+
+        // intentional fallthrough
+
+        default:
+          if (isAttributeNameSafe(propKey) && typeof propValue !== 'function' && typeof propValue !== 'symbol') {
+
+            target.push(attributeSeparator, stringToChunk(attributeName), attributeAssign, stringToChunk(escapeTextForBrowser(propValue)), attributeEnd);
+          }
+
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag);
+  pushInnerHTML(target, innerHTML, children);
+  return children;
+}
+
+const leadingNewline = stringToPrecomputedChunk('\n');
+
+function pushStartPreformattedElement(target, props, tag) {
+  target.push(startChunkForTag(tag));
+  let children = null;
+  let innerHTML = null;
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'children':
+          children = propValue;
+          break;
+
+        case 'dangerouslySetInnerHTML':
+          innerHTML = propValue;
+          break;
+
+        default:
+          pushAttribute(target, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  target.push(endOfStartTag); // text/html ignores the first character in these tags if it's a newline
+  // Prefer to break application/xml over text/html (for now) by adding
+  // a newline specifically to get eaten by the parser. (Alternately for
+  // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+  // \r is normalized out by HTMLTextAreaElement#value.)
+  // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+  // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+  // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+  // See: Parsing of "textarea" "listing" and "pre" elements
+  //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+  // TODO: This doesn't deal with the case where the child is an array
+  // or component that returns a string.
+
+  if (innerHTML != null) {
+    if (children != null) {
+      throw new Error('Can only set one of `children` or `props.dangerouslySetInnerHTML`.');
+    }
+
+    if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
+      throw new Error('`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. ' + 'Please visit https://reactjs.org/link/dangerously-set-inner-html ' + 'for more information.');
+    }
+
+    const html = innerHTML.__html;
+
+    if (html !== null && html !== undefined) {
+      if (typeof html === 'string' && html.length > 0 && html[0] === '\n') {
+        target.push(leadingNewline, stringToChunk(html));
+      } else {
+
+        target.push(stringToChunk('' + html));
+      }
+    }
+  }
+
+  if (typeof children === 'string' && children[0] === '\n') {
+    target.push(leadingNewline);
+  }
+
+  return children;
+} // We accept any tag to be rendered but since this gets injected into arbitrary
+// HTML, we want to make sure that it's a safe tag.
+// http://www.w3.org/TR/REC-xml/#NT-Name
+
+
+const VALID_TAG_REGEX = /^[a-zA-Z][a-zA-Z:_\.\-\d]*$/; // Simplified subset
+
+const validatedTagCache = new Map();
+
+function startChunkForTag(tag) {
+  let tagStartChunk = validatedTagCache.get(tag);
+
+  if (tagStartChunk === undefined) {
+    if (!VALID_TAG_REGEX.test(tag)) {
+      throw new Error("Invalid tag: " + tag);
+    }
+
+    tagStartChunk = stringToPrecomputedChunk('<' + tag);
+    validatedTagCache.set(tag, tagStartChunk);
+  }
+
+  return tagStartChunk;
+}
+
+const doctypeChunk = stringToPrecomputedChunk('<!DOCTYPE html>');
+function pushStartInstance(target, type, props, resumableState, renderState, formatContext, textEmbedded) {
+
+  switch (type) {
+    case 'div':
+    case 'span':
+    case 'svg':
+    case 'path':
+    case 'a':
+    case 'g':
+    case 'p':
+    case 'li':
+      // Fast track very common tags
+      break;
+    // Special tags
+
+    case 'select':
+      return pushStartSelect(target, props);
+
+    case 'option':
+      return pushStartOption(target, props, formatContext);
+
+    case 'textarea':
+      return pushStartTextArea(target, props);
+
+    case 'input':
+      return pushInput(target, props, resumableState, renderState);
+
+    case 'button':
+      return pushStartButton(target, props, resumableState, renderState);
+
+    case 'form':
+      return pushStartForm(target, props, resumableState, renderState);
+
+    case 'menuitem':
+      return pushStartMenuItem(target, props);
+
+    case 'title':
+      return pushTitle(target, props, renderState, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'link':
+      return pushLink(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'script':
+      return pushScript(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE)) ;
+
+    case 'style':
+      return pushStyle(target, props, resumableState, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+
+    case 'meta':
+      return pushMeta(target, props, renderState, textEmbedded, formatContext.insertionMode, !!(formatContext.tagScope & NOSCRIPT_SCOPE));
+    // Newline eating tags
+
+    case 'listing':
+    case 'pre':
+      {
+        return pushStartPreformattedElement(target, props, type);
+      }
+
+    case 'img':
+      {
+        return pushImg(target, props, resumableState, renderState, !!(formatContext.tagScope & PICTURE_SCOPE)) ;
+      }
+    // Omitted close tags
+
+    case 'base':
+    case 'area':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'keygen':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        return pushSelfClosing(target, props, type);
+      }
+    // These are reserved SVG and MathML elements, that are never custom elements.
+    // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+
+    case 'annotation-xml':
+    case 'color-profile':
+    case 'font-face':
+    case 'font-face-src':
+    case 'font-face-uri':
+    case 'font-face-format':
+    case 'font-face-name':
+    case 'missing-glyph':
+      {
+        break;
+      }
+    // Preamble start tags
+
+    case 'head':
+      return pushStartHead(target, props, renderState, formatContext.insertionMode);
+
+    case 'html':
+      {
+        return pushStartHtml(target, props, renderState, formatContext.insertionMode);
+      }
+
+    default:
+      {
+        if (type.indexOf('-') !== -1) {
+          // Custom element
+          return pushStartCustomElement(target, props, type);
+        }
+      }
+  } // Generic element
+
+
+  return pushStartGenericElement(target, props, type);
+}
+const endTagCache = new Map();
+
+function endChunkForTag(tag) {
+  let chunk = endTagCache.get(tag);
+
+  if (chunk === undefined) {
+    chunk = stringToPrecomputedChunk('</' + tag + '>');
+    endTagCache.set(tag, chunk);
+  }
+
+  return chunk;
+}
+
+function pushEndInstance(target, type, props, resumableState, formatContext) {
+  switch (type) {
+    // When float is on we expect title and script tags to always be pushed in
+    // a unit and never return children. when we end up pushing the end tag we
+    // want to ensure there is no extra closing tag pushed
+    case 'title':
+    case 'style':
+    case 'script':
+    // Omitted close tags
+    // TODO: Instead of repeating this switch we could try to pass a flag from above.
+    // That would require returning a tuple. Which might be ok if it gets inlined.
+
+    case 'area':
+    case 'base':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'img':
+    case 'input':
+    case 'keygen':
+    case 'link':
+    case 'meta':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+      {
+        // No close tag needed.
+        return;
+      }
+    // Postamble end tags
+    // When float is enabled we omit the end tags for body and html when
+    // they represent the Document.body and Document.documentElement Nodes.
+    // This is so we can withhold them until the postamble when we know
+    // we won't emit any more tags
+
+    case 'body':
+      {
+        if (formatContext.insertionMode <= HTML_HTML_MODE) {
+          resumableState.hasBody = true;
+          return;
+        }
+
+        break;
+      }
+
+    case 'html':
+      if (formatContext.insertionMode === ROOT_HTML_MODE) {
+        resumableState.hasHtml = true;
+        return;
+      }
+
+      break;
+  }
+
+  target.push(endChunkForTag(type));
+}
+
+function writeBootstrap(destination, renderState, resumableState) {
+  resumableState.bootstrapScriptContent = undefined;
+  resumableState.bootstrapScripts = undefined;
+  resumableState.bootstrapModules = undefined;
+  const bootstrapChunks = renderState.bootstrapChunks;
+  let i = 0;
+
+  for (; i < bootstrapChunks.length - 1; i++) {
+    writeChunk(destination, bootstrapChunks[i]);
+  }
+
+  if (i < bootstrapChunks.length) {
+    const lastChunk = bootstrapChunks[i];
+    bootstrapChunks.length = 0;
+    return writeChunkAndReturn(destination, lastChunk);
+  }
+
+  return true;
+}
+
+function writeCompletedRoot(destination, renderState, resumableState) {
+  return writeBootstrap(destination, renderState, resumableState);
+} // Structural Nodes
+// A placeholder is a node inside a hidden partial tree that can be filled in later, but before
+// display. It's never visible to users. We use the template tag because it can be used in every
+// type of parent. <script> tags also work in every other tag except <colgroup>.
+
+const placeholder1 = stringToPrecomputedChunk('<template id="');
+const placeholder2 = stringToPrecomputedChunk('"></template>');
+function writePlaceholder(destination, renderState, id) {
+  writeChunk(destination, placeholder1);
+  writeChunk(destination, renderState.placeholderPrefix);
+  const formattedID = stringToChunk(id.toString(16));
+  writeChunk(destination, formattedID);
+  return writeChunkAndReturn(destination, placeholder2);
+} // Suspense boundaries are encoded as comments.
+
+const startCompletedSuspenseBoundary = stringToPrecomputedChunk('<!--$-->');
+const startPendingSuspenseBoundary1 = stringToPrecomputedChunk('<!--$?--><template id="');
+const startPendingSuspenseBoundary2 = stringToPrecomputedChunk('"></template>');
+const startClientRenderedSuspenseBoundary = stringToPrecomputedChunk('<!--$!-->');
+const endSuspenseBoundary = stringToPrecomputedChunk('<!--/$-->');
+const clientRenderedSuspenseBoundaryError1 = stringToPrecomputedChunk('<template');
+const clientRenderedSuspenseBoundaryErrorAttrInterstitial = stringToPrecomputedChunk('"');
+const clientRenderedSuspenseBoundaryError1A = stringToPrecomputedChunk(' data-dgst="');
+stringToPrecomputedChunk(' data-msg="');
+stringToPrecomputedChunk(' data-stck="');
+const clientRenderedSuspenseBoundaryError2 = stringToPrecomputedChunk('></template>');
+function writeStartCompletedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, startCompletedSuspenseBoundary);
+}
+function writeStartPendingSuspenseBoundary(destination, renderState, id) {
+  writeChunk(destination, startPendingSuspenseBoundary1);
+
+  if (id === null) {
+    throw new Error('An ID must have been assigned before we can complete the boundary.');
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+  return writeChunkAndReturn(destination, startPendingSuspenseBoundary2);
+}
+function writeStartClientRenderedSuspenseBoundary(destination, renderState, errorDigest, errorMesssage, errorComponentStack) {
+  let result;
+  result = writeChunkAndReturn(destination, startClientRenderedSuspenseBoundary);
+  writeChunk(destination, clientRenderedSuspenseBoundaryError1);
+
+  if (errorDigest) {
+    writeChunk(destination, clientRenderedSuspenseBoundaryError1A);
+    writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest)));
+    writeChunk(destination, clientRenderedSuspenseBoundaryErrorAttrInterstitial);
+  }
+
+  result = writeChunkAndReturn(destination, clientRenderedSuspenseBoundaryError2);
+  return result;
+}
+function writeEndCompletedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndPendingSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+function writeEndClientRenderedSuspenseBoundary(destination, renderState) {
+  return writeChunkAndReturn(destination, endSuspenseBoundary);
+}
+const startSegmentHTML = stringToPrecomputedChunk('<div hidden id="');
+const startSegmentHTML2 = stringToPrecomputedChunk('">');
+const endSegmentHTML = stringToPrecomputedChunk('</div>');
+const startSegmentSVG = stringToPrecomputedChunk('<svg aria-hidden="true" style="display:none" id="');
+const startSegmentSVG2 = stringToPrecomputedChunk('">');
+const endSegmentSVG = stringToPrecomputedChunk('</svg>');
+const startSegmentMathML = stringToPrecomputedChunk('<math aria-hidden="true" style="display:none" id="');
+const startSegmentMathML2 = stringToPrecomputedChunk('">');
+const endSegmentMathML = stringToPrecomputedChunk('</math>');
+const startSegmentTable = stringToPrecomputedChunk('<table hidden id="');
+const startSegmentTable2 = stringToPrecomputedChunk('">');
+const endSegmentTable = stringToPrecomputedChunk('</table>');
+const startSegmentTableBody = stringToPrecomputedChunk('<table hidden><tbody id="');
+const startSegmentTableBody2 = stringToPrecomputedChunk('">');
+const endSegmentTableBody = stringToPrecomputedChunk('</tbody></table>');
+const startSegmentTableRow = stringToPrecomputedChunk('<table hidden><tr id="');
+const startSegmentTableRow2 = stringToPrecomputedChunk('">');
+const endSegmentTableRow = stringToPrecomputedChunk('</tr></table>');
+const startSegmentColGroup = stringToPrecomputedChunk('<table hidden><colgroup id="');
+const startSegmentColGroup2 = stringToPrecomputedChunk('">');
+const endSegmentColGroup = stringToPrecomputedChunk('</colgroup></table>');
+function writeStartSegment(destination, renderState, formatContext, id) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        writeChunk(destination, startSegmentHTML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentHTML2);
+      }
+
+    case SVG_MODE:
+      {
+        writeChunk(destination, startSegmentSVG);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentSVG2);
+      }
+
+    case MATHML_MODE:
+      {
+        writeChunk(destination, startSegmentMathML);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentMathML2);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        writeChunk(destination, startSegmentTable);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTable2);
+      }
+    // TODO: For the rest of these, there will be extra wrapper nodes that never
+    // get deleted from the document. We need to delete the table too as part
+    // of the injected scripts. They are invisible though so it's not too terrible
+    // and it's kind of an edge case to suspend in a table. Totally supported though.
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        writeChunk(destination, startSegmentTableBody);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableBody2);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        writeChunk(destination, startSegmentTableRow);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentTableRow2);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        writeChunk(destination, startSegmentColGroup);
+        writeChunk(destination, renderState.segmentPrefix);
+        writeChunk(destination, stringToChunk(id.toString(16)));
+        return writeChunkAndReturn(destination, startSegmentColGroup2);
+      }
+
+    default:
+      {
+        throw new Error('Unknown insertion mode. This is a bug in React.');
+      }
+  }
+}
+function writeEndSegment(destination, formatContext) {
+  switch (formatContext.insertionMode) {
+    case ROOT_HTML_MODE:
+    case HTML_HTML_MODE:
+    case HTML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentHTML);
+      }
+
+    case SVG_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentSVG);
+      }
+
+    case MATHML_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentMathML);
+      }
+
+    case HTML_TABLE_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTable);
+      }
+
+    case HTML_TABLE_BODY_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableBody);
+      }
+
+    case HTML_TABLE_ROW_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentTableRow);
+      }
+
+    case HTML_COLGROUP_MODE:
+      {
+        return writeChunkAndReturn(destination, endSegmentColGroup);
+      }
+
+    default:
+      {
+        throw new Error('Unknown insertion mode. This is a bug in React.');
+      }
+  }
+}
+const completeSegmentScript1Full = stringToPrecomputedChunk(completeSegment + '$RS("');
+const completeSegmentScript1Partial = stringToPrecomputedChunk('$RS("');
+const completeSegmentScript2 = stringToPrecomputedChunk('","');
+const completeSegmentScriptEnd = stringToPrecomputedChunk('")</script>');
+const completeSegmentData1 = stringToPrecomputedChunk('<template data-rsi="" data-sid="');
+const completeSegmentData2 = stringToPrecomputedChunk('" data-pid="');
+const completeSegmentDataEnd = dataElementQuotedEnd;
+function writeCompletedSegmentInstruction(destination, resumableState, renderState, contentSegmentID) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentCompleteSegmentFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentCompleteSegmentFunction;
+      writeChunk(destination, completeSegmentScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, completeSegmentScript1Partial);
+    }
+  } else {
+    writeChunk(destination, completeSegmentData1);
+  } // Write function arguments, which are string literals
+
+
+  writeChunk(destination, renderState.segmentPrefix);
+  const formattedID = stringToChunk(contentSegmentID.toString(16));
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    writeChunk(destination, completeSegmentScript2);
+  } else {
+    writeChunk(destination, completeSegmentData2);
+  }
+
+  writeChunk(destination, renderState.placeholderPrefix);
+  writeChunk(destination, formattedID);
+
+  if (scriptFormat) {
+    return writeChunkAndReturn(destination, completeSegmentScriptEnd);
+  } else {
+    return writeChunkAndReturn(destination, completeSegmentDataEnd);
+  }
+}
+const completeBoundaryScript1Full = stringToPrecomputedChunk(completeBoundary + '$RC("');
+const completeBoundaryScript1Partial = stringToPrecomputedChunk('$RC("');
+const completeBoundaryWithStylesScript1FullBoth = stringToPrecomputedChunk(completeBoundary + completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1FullPartial = stringToPrecomputedChunk(completeBoundaryWithStyles + '$RR("');
+const completeBoundaryWithStylesScript1Partial = stringToPrecomputedChunk('$RR("');
+const completeBoundaryScript2 = stringToPrecomputedChunk('","');
+const completeBoundaryScript3a = stringToPrecomputedChunk('",');
+const completeBoundaryScript3b = stringToPrecomputedChunk('"');
+const completeBoundaryScriptEnd = stringToPrecomputedChunk(')</script>');
+const completeBoundaryData1 = stringToPrecomputedChunk('<template data-rci="" data-bid="');
+const completeBoundaryWithStylesData1 = stringToPrecomputedChunk('<template data-rri="" data-bid="');
+const completeBoundaryData2 = stringToPrecomputedChunk('" data-sid="');
+const completeBoundaryData3a = stringToPrecomputedChunk('" data-sty="');
+const completeBoundaryDataEnd = dataElementQuotedEnd;
+function writeCompletedBoundaryInstruction(destination, resumableState, renderState, id, boundaryResources) {
+  let requiresStyleInsertion;
+
+  {
+    requiresStyleInsertion = renderState.stylesToHoist; // If necessary stylesheets will be flushed with this instruction.
+    // Any style tags not yet hoisted in the Document will also be hoisted.
+    // We reset this state since after this instruction executes all styles
+    // up to this point will have been hoisted
+
+    renderState.stylesToHoist = false;
+  }
+
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if (requiresStyleInsertion) {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction | SentCompleteBoundaryFunction;
+        writeChunk(destination, clonePrecomputedChunk(completeBoundaryWithStylesScript1FullBoth));
+      } else if ((resumableState.instructions & SentStyleInsertionFunction) === NothingSent) {
+        resumableState.instructions |= SentStyleInsertionFunction;
+        writeChunk(destination, completeBoundaryWithStylesScript1FullPartial);
+      } else {
+        writeChunk(destination, completeBoundaryWithStylesScript1Partial);
+      }
+    } else {
+      if ((resumableState.instructions & SentCompleteBoundaryFunction) === NothingSent) {
+        resumableState.instructions |= SentCompleteBoundaryFunction;
+        writeChunk(destination, completeBoundaryScript1Full);
+      } else {
+        writeChunk(destination, completeBoundaryScript1Partial);
+      }
+    }
+  } else {
+    if (requiresStyleInsertion) {
+      writeChunk(destination, completeBoundaryWithStylesData1);
+    } else {
+      writeChunk(destination, completeBoundaryData1);
+    }
+  }
+
+  const idChunk = stringToChunk(id.toString(16));
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, idChunk); // Write function arguments, which are string and array literals
+
+  if (scriptFormat) {
+    writeChunk(destination, completeBoundaryScript2);
+  } else {
+    writeChunk(destination, completeBoundaryData2);
+  }
+
+  writeChunk(destination, renderState.segmentPrefix);
+  writeChunk(destination, idChunk);
+
+  if (requiresStyleInsertion) {
+    // Script and data writers must format this differently:
+    //  - script writer emits an array literal, whose string elements are
+    //    escaped for javascript  e.g. ["A", "B"]
+    //  - data writer emits a string literal, which is escaped as html
+    //    e.g. [&#34;A&#34;, &#34;B&#34;]
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3a); // boundaryResources encodes an array literal
+
+      writeStyleResourceDependenciesInJS(destination, boundaryResources);
+    } else {
+      writeChunk(destination, completeBoundaryData3a);
+      writeStyleResourceDependenciesInAttr(destination, boundaryResources);
+    }
+  } else {
+    if (scriptFormat) {
+      writeChunk(destination, completeBoundaryScript3b);
+    }
+  }
+
+  let writeMore;
+
+  if (scriptFormat) {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryScriptEnd);
+  } else {
+    writeMore = writeChunkAndReturn(destination, completeBoundaryDataEnd);
+  }
+
+  return writeBootstrap(destination, renderState, resumableState) && writeMore;
+}
+const clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
+const clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
+const clientRenderScript1A = stringToPrecomputedChunk('"');
+const clientRenderErrorScriptArgInterstitial = stringToPrecomputedChunk(',');
+const clientRenderScriptEnd = stringToPrecomputedChunk(')</script>');
+const clientRenderData1 = stringToPrecomputedChunk('<template data-rxi="" data-bid="');
+const clientRenderData2 = stringToPrecomputedChunk('" data-dgst="');
+const clientRenderData3 = stringToPrecomputedChunk('" data-msg="');
+const clientRenderData4 = stringToPrecomputedChunk('" data-stck="');
+const clientRenderDataEnd = dataElementQuotedEnd;
+function writeClientRenderBoundaryInstruction(destination, resumableState, renderState, id, errorDigest, errorMessage, errorComponentStack) {
+  const scriptFormat = resumableState.streamingFormat === ScriptStreamingFormat;
+
+  if (scriptFormat) {
+    writeChunk(destination, renderState.startInlineScript);
+
+    if ((resumableState.instructions & SentClientRenderFunction) === NothingSent) {
+      // The first time we write this, we'll need to include the full implementation.
+      resumableState.instructions |= SentClientRenderFunction;
+      writeChunk(destination, clientRenderScript1Full);
+    } else {
+      // Future calls can just reuse the same function.
+      writeChunk(destination, clientRenderScript1Partial);
+    }
+  } else {
+    // <template data-rxi="" data-bid="
+    writeChunk(destination, clientRenderData1);
+  }
+
+  writeChunk(destination, renderState.boundaryPrefix);
+  writeChunk(destination, stringToChunk(id.toString(16)));
+
+  if (scriptFormat) {
+    // " needs to be inserted for scripts, since ArgInterstitual does not contain
+    // leading or trailing quotes
+    writeChunk(destination, clientRenderScript1A);
+  }
+
+  if (errorDigest || errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorDigest || '')));
+    } else {
+      // " data-dgst="HTMLString
+      writeChunk(destination, clientRenderData2);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest || '')));
+    }
+  }
+
+  if (errorMessage || errorComponentStack) {
+    if (scriptFormat) {
+      // ,"JSONString"
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorMessage || '')));
+    } else {
+      // " data-msg="HTMLString
+      writeChunk(destination, clientRenderData3);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorMessage || '')));
+    }
+  }
+
+  if (errorComponentStack) {
+    // ,"JSONString"
+    if (scriptFormat) {
+      writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+      writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorComponentStack)));
+    } else {
+      // " data-stck="HTMLString
+      writeChunk(destination, clientRenderData4);
+      writeChunk(destination, stringToChunk(escapeTextForBrowser(errorComponentStack)));
+    }
+  }
+
+  if (scriptFormat) {
+    // ></script>
+    return writeChunkAndReturn(destination, clientRenderScriptEnd);
+  } else {
+    // "></template>
+    return writeChunkAndReturn(destination, clientRenderDataEnd);
+  }
+}
+const regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
+
+function escapeJSStringsForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInInstructionScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const regexForJSStringsInScripts = /[&><\u2028\u2029]/g;
+
+function escapeJSObjectForInstructionScripts(input) {
+  const escaped = JSON.stringify(input);
+  return escaped.replace(regexForJSStringsInScripts, match => {
+    switch (match) {
+      // santizing breaking out of strings and script tags
+      case '&':
+        return '\\u0026';
+
+      case '>':
+        return '\\u003e';
+
+      case '<':
+        return '\\u003c';
+
+      case '\u2028':
+        return '\\u2028';
+
+      case '\u2029':
+        return '\\u2029';
+
+      default:
+        {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error('escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+        }
+    }
+  });
+}
+
+const lateStyleTagResourceOpen1 = stringToPrecomputedChunk('<style media="not all" data-precedence="');
+const lateStyleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const lateStyleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const lateStyleTagTemplateClose = stringToPrecomputedChunk('</style>'); // Tracks whether the boundary currently flushing is flushign style tags or has any
+// stylesheet dependencies not flushed in the Preamble.
+
+let currentlyRenderingBoundaryHasStylesToHoist = false; // Acts as a return value for the forEach execution of style tag flushing.
+
+let destinationHasCapacity = true;
+
+function flushStyleTagsLateForBoundary(styleQueue) {
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs;
+
+  let i = 0;
+
+  if (hrefs.length) {
+    writeChunk(this, lateStyleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    writeChunk(this, lateStyleTagResourceOpen2);
+
+    for (; i < hrefs.length - 1; i++) {
+      writeChunk(this, hrefs[i]);
+      writeChunk(this, spaceSeparator);
+    }
+
+    writeChunk(this, hrefs[i]);
+    writeChunk(this, lateStyleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    destinationHasCapacity = writeChunkAndReturn(this, lateStyleTagTemplateClose); // We wrote style tags for this boundary and we may need to emit a script
+    // to hoist them.
+
+    currentlyRenderingBoundaryHasStylesToHoist = true; // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function hasStylesToHoist(stylesheet) {
+  // We need to reveal boundaries with styles whenever a stylesheet it depends on is either
+  // not flushed or flushed after the preamble (shell).
+  if (stylesheet.state !== PREAMBLE) {
+    currentlyRenderingBoundaryHasStylesToHoist = true;
+    return true;
+  }
+
+  return false;
+}
+
+function writeResourcesForBoundary(destination, boundaryResources, renderState) {
+  // Reset these on each invocation, they are only safe to read in this function
+  currentlyRenderingBoundaryHasStylesToHoist = false;
+  destinationHasCapacity = true; // Flush style tags for each precedence this boundary depends on
+
+  boundaryResources.styles.forEach(flushStyleTagsLateForBoundary, destination); // Determine if this boundary has stylesheets that need to be awaited upon completion
+
+  boundaryResources.stylesheets.forEach(hasStylesToHoist);
+
+  if (currentlyRenderingBoundaryHasStylesToHoist) {
+    renderState.stylesToHoist = true;
+  }
+
+  return destinationHasCapacity;
+}
+
+function flushResource(resource) {
+  for (let i = 0; i < resource.length; i++) {
+    writeChunk(this, resource[i]);
+  }
+
+  resource.length = 0;
+}
+
+const stylesheetFlushingQueue = [];
+
+function flushStyleInPreamble(stylesheet, key, map) {
+  // We still need to encode stylesheet chunks
+  // because unlike most Hoistables and Resources we do not eagerly encode
+  // them during render. This is because if we flush late we have to send a
+  // different encoding and we don't want to encode multiple times
+  pushLinkImpl(stylesheetFlushingQueue, stylesheet.props);
+
+  for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+    writeChunk(this, stylesheetFlushingQueue[i]);
+  }
+
+  stylesheetFlushingQueue.length = 0;
+  stylesheet.state = PREAMBLE;
+}
+
+const styleTagResourceOpen1 = stringToPrecomputedChunk('<style data-precedence="');
+const styleTagResourceOpen2 = stringToPrecomputedChunk('" data-href="');
+const spaceSeparator = stringToPrecomputedChunk(' ');
+const styleTagResourceOpen3 = stringToPrecomputedChunk('">');
+const styleTagResourceClose = stringToPrecomputedChunk('</style>');
+
+function flushStylesInPreamble(styleQueue, precedence) {
+  const hasStylesheets = styleQueue.sheets.size > 0;
+  styleQueue.sheets.forEach(flushStyleInPreamble, this);
+  styleQueue.sheets.clear();
+  const rules = styleQueue.rules;
+  const hrefs = styleQueue.hrefs; // If we don't emit any stylesheets at this precedence we still need to maintain the precedence
+  // order so even if there are no rules for style tags at this precedence we emit an empty style
+  // tag with the data-precedence attribute
+
+  if (!hasStylesheets || hrefs.length) {
+    writeChunk(this, styleTagResourceOpen1);
+    writeChunk(this, styleQueue.precedence);
+    let i = 0;
+
+    if (hrefs.length) {
+      writeChunk(this, styleTagResourceOpen2);
+
+      for (; i < hrefs.length - 1; i++) {
+        writeChunk(this, hrefs[i]);
+        writeChunk(this, spaceSeparator);
+      }
+
+      writeChunk(this, hrefs[i]);
+    }
+
+    writeChunk(this, styleTagResourceOpen3);
+
+    for (i = 0; i < rules.length; i++) {
+      writeChunk(this, rules[i]);
+    }
+
+    writeChunk(this, styleTagResourceClose); // style resources can flush continuously since more rules may be written into
+    // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+    // and hrefs
+
+    rules.length = 0;
+    hrefs.length = 0;
+  }
+}
+
+function preloadLateStyle(stylesheet) {
+  if (stylesheet.state === PENDING$1) {
+    stylesheet.state = PRELOADED;
+    const preloadProps = preloadAsStylePropsFromProps(stylesheet.props.href, stylesheet.props);
+    pushLinkImpl(stylesheetFlushingQueue, preloadProps);
+
+    for (let i = 0; i < stylesheetFlushingQueue.length; i++) {
+      writeChunk(this, stylesheetFlushingQueue[i]);
+    }
+
+    stylesheetFlushingQueue.length = 0;
+  }
+}
+
+function preloadLateStyles(styleQueue) {
+  styleQueue.sheets.forEach(preloadLateStyle, this);
+  styleQueue.sheets.clear();
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+
+function writePreamble(destination, resumableState, renderState, willFlushAllSegments) {
+  // This function must be called exactly once on every request
+  if (!willFlushAllSegments && renderState.externalRuntimeScript) {
+    // If the root segment is incomplete due to suspended tasks
+    // (e.g. willFlushAllSegments = false) and we are using data
+    // streaming format, ensure the external runtime is sent.
+    // (User code could choose to send this even earlier by calling
+    //  preinit(...), if they know they will suspend).
+    const _renderState$external = renderState.externalRuntimeScript,
+          src = _renderState$external.src,
+          chunks = _renderState$external.chunks;
+    internalPreinitScript(resumableState, renderState, src, chunks);
+  }
+
+  const htmlChunks = renderState.htmlChunks;
+  const headChunks = renderState.headChunks;
+  let i = 0; // Emit open tags before Hoistables and Resources
+
+  if (htmlChunks) {
+    // We have an <html> to emit as part of the preamble
+    for (i = 0; i < htmlChunks.length; i++) {
+      writeChunk(destination, htmlChunks[i]);
+    }
+
+    if (headChunks) {
+      for (i = 0; i < headChunks.length; i++) {
+        writeChunk(destination, headChunks[i]);
+      }
+    } else {
+      // We did not render a head but we emitted an <html> so we emit one now
+      writeChunk(destination, startChunkForTag('head'));
+      writeChunk(destination, endOfStartTag);
+    }
+  } else if (headChunks) {
+    // We do not have an <html> but we do have a <head>
+    for (i = 0; i < headChunks.length; i++) {
+      writeChunk(destination, headChunks[i]);
+    }
+  } // Emit high priority Hoistables
+
+
+  const charsetChunks = renderState.charsetChunks;
+
+  for (i = 0; i < charsetChunks.length; i++) {
+    writeChunk(destination, charsetChunks[i]);
+  }
+
+  charsetChunks.length = 0; // emit preconnect resources
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Flush unblocked stylesheets by precedence
+
+  renderState.styles.forEach(flushStylesInPreamble, destination);
+  const importMapChunks = renderState.importMapChunks;
+
+  for (i = 0; i < importMapChunks.length; i++) {
+    writeChunk(destination, importMapChunks[i]);
+  }
+
+  importMapChunks.length = 0;
+  renderState.bootstrapScripts.forEach(flushResource, destination);
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0; // Flush closing head if necessary
+
+  if (htmlChunks && headChunks === null) {
+    // We have an <html> rendered but no <head> rendered. We however inserted
+    // a <head> up above so we need to emit the </head> now. This is safe because
+    // if the main content contained the </head> it would also have provided a
+    // <head>. This means that all the content inside <html> is either <body> or
+    // invalid HTML
+    writeChunk(destination, endChunkForTag('head'));
+  }
+} // We don't bother reporting backpressure at the moment because we expect to
+// flush the entire preamble in a single pass. This probably should be modified
+// in the future to be backpressure sensitive but that requires a larger refactor
+// of the flushing code in Fizz.
+
+function writeHoistables(destination, resumableState, renderState) {
+  let i = 0; // Emit high priority Hoistables
+  // We omit charsetChunks because we have already sent the shell and if it wasn't
+  // already sent it is too late now.
+
+  renderState.preconnects.forEach(flushResource, destination);
+  renderState.preconnects.clear();
+  const preconnectChunks = renderState.preconnectChunks;
+
+  for (i = 0; i < preconnectChunks.length; i++) {
+    writeChunk(destination, preconnectChunks[i]);
+  }
+
+  preconnectChunks.length = 0;
+  renderState.fontPreloads.forEach(flushResource, destination);
+  renderState.fontPreloads.clear();
+  renderState.highImagePreloads.forEach(flushResource, destination);
+  renderState.highImagePreloads.clear(); // Preload any stylesheets. these will emit in a render instruction that follows this
+  // but we want to kick off preloading as soon as possible
+
+  renderState.styles.forEach(preloadLateStyles, destination); // We only hoist importmaps that are configured through createResponse and that will
+  // always flush in the preamble. Generally we don't expect people to render them as
+  // tags when using React but if you do they are going to be treated like regular inline
+  // scripts and flush after other hoistables which is problematic
+  // bootstrap scripts should flush above script priority but these can only flush in the preamble
+  // so we elide the code here for performance
+
+  renderState.scripts.forEach(flushResource, destination);
+  renderState.scripts.clear();
+  renderState.bulkPreloads.forEach(flushResource, destination);
+  renderState.bulkPreloads.clear(); // Write embedding preloadChunks
+
+  const preloadChunks = renderState.preloadChunks;
+
+  for (i = 0; i < preloadChunks.length; i++) {
+    writeChunk(destination, preloadChunks[i]);
+  }
+
+  preloadChunks.length = 0; // Write embedding hoistableChunks
+
+  const hoistableChunks = renderState.hoistableChunks;
+
+  for (i = 0; i < hoistableChunks.length; i++) {
+    writeChunk(destination, hoistableChunks[i]);
+  }
+
+  hoistableChunks.length = 0;
+}
+function writePostamble(destination, resumableState) {
+  if (resumableState.hasBody) {
+    writeChunk(destination, endChunkForTag('body'));
+  }
+
+  if (resumableState.hasHtml) {
+    writeChunk(destination, endChunkForTag('html'));
+  }
+}
+const arrayFirstOpenBracket = stringToPrecomputedChunk('[');
+const arraySubsequentOpenBracket = stringToPrecomputedChunk(',[');
+const arrayInterstitial = stringToPrecomputedChunk(',');
+const arrayCloseBracket = stringToPrecomputedChunk(']'); // This function writes a 2D array of strings to be embedded in javascript.
+// E.g.
+//  [["JS_escaped_string1", "JS_escaped_string2"]]
+
+function writeStyleResourceDependenciesInJS(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInJS(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInJS(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInJS(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+}
+
+function writeStyleResourceDependencyInJS(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedPrecedence)));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          writeStyleResourceAttributeInJS(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInJS(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeName)));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeValue)));
+} // This function writes a 2D array of strings to be embedded in an attribute
+// value and read with JSON.parse in ReactDOMServerExternalRuntime.js
+// E.g.
+//  [[&quot;JSON_escaped_string1&quot;, &quot;JSON_escaped_string2&quot;]]
+
+
+function writeStyleResourceDependenciesInAttr(destination, boundaryResources) {
+  writeChunk(destination, arrayFirstOpenBracket);
+  let nextArrayOpenBrackChunk = arrayFirstOpenBracket;
+  boundaryResources.stylesheets.forEach(resource => {
+    if (resource.state === PREAMBLE) ; else if (resource.state === LATE) {
+      // We only need to emit the href because this resource flushed in an earlier
+      // boundary already which encoded the attributes necessary to construct
+      // the resource instance on the client.
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyHrefOnlyInAttr(destination, resource.props.href);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+    } else {
+      // We need to emit the whole resource for insertion on the client
+      writeChunk(destination, nextArrayOpenBrackChunk);
+      writeStyleResourceDependencyInAttr(destination, resource.props.href, resource.props['data-precedence'], resource.props);
+      writeChunk(destination, arrayCloseBracket);
+      nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
+      resource.state = LATE;
+    }
+  });
+  writeChunk(destination, arrayCloseBracket);
+}
+/* Helper functions */
+
+
+function writeStyleResourceDependencyHrefOnlyInAttr(destination, href) {
+
+  const coercedHref = '' + href;
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+}
+
+function writeStyleResourceDependencyInAttr(destination, href, precedence, props) {
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  const coercedHref = sanitizeURL('' + href);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedHref))));
+
+  const coercedPrecedence = '' + precedence;
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(coercedPrecedence))));
+
+  for (const propKey in props) {
+    if (hasOwnProperty.call(props, propKey)) {
+      const propValue = props[propKey];
+
+      if (propValue == null) {
+        continue;
+      }
+
+      switch (propKey) {
+        case 'href':
+        case 'rel':
+        case 'precedence':
+        case 'data-precedence':
+          {
+            break;
+          }
+
+        case 'children':
+        case 'dangerouslySetInnerHTML':
+          throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
+
+        default:
+          writeStyleResourceAttributeInAttr(destination, propKey, propValue);
+          break;
+      }
+    }
+  }
+
+  return null;
+}
+
+function writeStyleResourceAttributeInAttr(destination, name, value) // not null or undefined
+{
+  let attributeName = name.toLowerCase();
+  let attributeValue;
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+      return;
+  }
+
+  switch (name) {
+    // Reserved names
+    case 'innerHTML':
+    case 'dangerouslySetInnerHTML':
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'style':
+      // Ignored
+      return;
+    // Attribute renames
+
+    case 'className':
+      {
+        attributeName = 'class';
+
+        attributeValue = '' + value;
+        break;
+      }
+    // Booleans
+
+    case 'hidden':
+      {
+        if (value === false) {
+          return;
+        }
+
+        attributeValue = '';
+        break;
+      }
+    // Santized URLs
+
+    case 'src':
+    case 'href':
+      {
+        value = sanitizeURL(value);
+
+        attributeValue = '' + value;
+        break;
+      }
+
+    default:
+      {
+        if ( // unrecognized event handlers are not SSR'd and we (apparently)
+        // use on* as hueristic for these handler props
+        name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
+          return;
+        }
+
+        if (!isAttributeNameSafe(name)) {
+          return;
+        }
+
+        attributeValue = '' + value;
+      }
+  }
+
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeName))));
+  writeChunk(destination, arrayInterstitial);
+  writeChunk(destination, stringToChunk(escapeTextForBrowser(JSON.stringify(attributeValue))));
+}
+/**
+ * Resources
+ */
+
+
+const PENDING$1 = 0;
+const PRELOADED = 1;
+const PREAMBLE = 2;
+const LATE = 3;
+function createBoundaryResources() {
+  return {
+    styles: new Set(),
+    stylesheets: new Set()
+  };
+}
+function setCurrentlyRenderingBoundaryResourcesTarget(renderState, boundaryResources) {
+  renderState.boundaryResources = boundaryResources;
+}
+
+function getResourceKey(href) {
+  return href;
+}
+
+function getImageResourceKey(href, imageSrcSet, imageSizes) {
+  if (imageSrcSet) {
+    return imageSrcSet + '\n' + (imageSizes || '');
+  }
+
+  return href;
+}
+
+function prefetchDNS(href) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const key = getResourceKey(href);
+
+    if (!resumableState.dnsResources.hasOwnProperty(key)) {
+      resumableState.dnsResources[key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPrefetchDNSAsHeader(href), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this as resettable in case we are prerendering and postpone in the Shell
+        renderState.resets.dns[key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        // Encode as element
+        const resource = [];
+        pushLinkImpl(resource, {
+          href,
+          rel: 'dns-prefetch'
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preconnect(href, crossOrigin) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (typeof href === 'string' && href) {
+    const bucket = crossOrigin === 'use-credentials' ? 'credentials' : typeof crossOrigin === 'string' ? 'anonymous' : 'default';
+    const key = getResourceKey(href);
+
+    if (!resumableState.connectResources[bucket].hasOwnProperty(key)) {
+      resumableState.connectResources[bucket][key] = EXISTS;
+      const headers = renderState.headers;
+      let header;
+
+      if (headers && headers.remainingCapacity > 0 && ( // Compute the header since we might be able to fit it in the max length
+      header = getPreconnectAsHeader(href, crossOrigin), // We always consume the header length since once we find one header that doesn't fit
+      // we assume all the rest won't as well. This is to avoid getting into a situation
+      // where we have a very small remaining capacity but no headers will ever fit and we end
+      // up constantly trying to see if the next resource might make it. In the future we can
+      // make this behavior different between render and prerender since in the latter case
+      // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+      // headers.
+      (headers.remainingCapacity -= header.length) >= 2)) {
+        // Store this in resettableState in case we are prerending and postpone in the Shell
+        renderState.resets.connect[bucket][key] = EXISTS;
+
+        if (headers.preconnects) {
+          headers.preconnects += ', ';
+        } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+        headers.preconnects += header;
+      } else {
+        const resource = [];
+        pushLinkImpl(resource, {
+          rel: 'preconnect',
+          href,
+          crossOrigin
+        });
+        renderState.preconnects.add(resource);
+      }
+    }
+
+    flushResources(request);
+  }
+}
+
+function preload(href, as, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (as && href) {
+    switch (as) {
+      case 'image':
+        {
+          let imageSrcSet, imageSizes, fetchPriority;
+
+          if (options) {
+            imageSrcSet = options.imageSrcSet;
+            imageSizes = options.imageSizes;
+            fetchPriority = options.fetchPriority;
+          }
+
+          const key = getImageResourceKey(href, imageSrcSet, imageSizes);
+
+          if (resumableState.imageResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resumableState.imageResources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && fetchPriority === 'high' && ( // Compute the header since we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit a preload as a header so we
+            // track this to make sure we don't reset it.
+            renderState.resets.image[key] = PRELOAD_NO_CREDS;
+
+            if (headers.highImagePreloads) {
+              headers.highImagePreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.highImagePreloads += header;
+          } else {
+            // If we don't have headers to write to we have to encode as elements to flush in the head
+            // When we have imageSrcSet the browser probably cannot load the right version from headers
+            // (this should be verified by testing). For now we assume these need to go in the head
+            // as elements even if headers are available.
+            const resource = [];
+            pushLinkImpl(resource, assign({
+              rel: 'preload',
+              // There is a bug in Safari where imageSrcSet is not respected on preload links
+              // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+              // This harms older browers that do not support imageSrcSet by making their preloads not work
+              // but this population is shrinking fast and is already small so we accept this tradeoff.
+              href: imageSrcSet ? undefined : href,
+              as
+            }, options));
+
+            if (fetchPriority === 'high') {
+              renderState.highImagePreloads.add(resource);
+            } else {
+              renderState.bulkPreloads.add(resource); // Stash the resource in case we need to promote it to higher priority
+              // when an img tag is rendered
+
+              renderState.preloads.images.set(key, resource);
+            }
+          }
+
+          break;
+        }
+
+      case 'style':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.styleResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.styleResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.stylesheets.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          break;
+        }
+
+      case 'script':
+        {
+          const key = getResourceKey(href);
+
+          if (resumableState.scriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          const resource = [];
+          renderState.preloads.scripts.set(key, resource);
+          renderState.bulkPreloads.add(resource);
+          pushLinkImpl(resource, assign({
+            rel: 'preload',
+            href,
+            as
+          }, options));
+          resumableState.scriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          break;
+        }
+
+      default:
+        {
+          const key = getResourceKey(href);
+          const hasAsType = resumableState.unknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.unknownResources[as] = resources;
+          }
+
+          resources[key] = PRELOAD_NO_CREDS;
+          const headers = renderState.headers;
+          let header;
+
+          if (headers && headers.remainingCapacity > 0 && as === 'font' && ( // We compute the header here because we might be able to fit it in the max length
+          header = getPreloadAsHeader(href, as, options), // We always consume the header length since once we find one header that doesn't fit
+          // we assume all the rest won't as well. This is to avoid getting into a situation
+          // where we have a very small remaining capacity but no headers will ever fit and we end
+          // up constantly trying to see if the next resource might make it. In the future we can
+          // make this behavior different between render and prerender since in the latter case
+          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
+          // headers.
+          (headers.remainingCapacity -= header.length) >= 2)) {
+            // If we postpone in the shell we will still emit this preload so we
+            // track it here to prevent it from being reset.
+            renderState.resets.font[key] = PRELOAD_NO_CREDS;
+
+            if (headers.fontPreloads) {
+              headers.fontPreloads += ', ';
+            } // $FlowFixMe[unsafe-addition]: we assign header during the if condition
+
+
+            headers.fontPreloads += header;
+          } else {
+            // We either don't have headers or we are preloading something that does
+            // not warrant elevated priority so we encode as an element.
+            const resource = [];
+
+            const props = assign({
+              rel: 'preload',
+              href,
+              as
+            }, options);
+
+            pushLinkImpl(resource, props);
+
+            switch (as) {
+              case 'font':
+                renderState.fontPreloads.add(resource);
+                break;
+              // intentional fall through
+
+              default:
+                renderState.bulkPreloads.add(resource);
+            }
+          }
+        }
+    } // If we got this far we created a new resource
+
+
+    flushResources(request);
+  }
+}
+
+function preloadModule(href, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    const key = getResourceKey(href);
+    const as = options && typeof options.as === 'string' ? options.as : 'script';
+    let resource;
+
+    switch (as) {
+      case 'script':
+        {
+          if (resumableState.moduleScriptResources.hasOwnProperty(key)) {
+            // we can return if we already have this resource
+            return;
+          }
+
+          resource = [];
+          resumableState.moduleScriptResources[key] = options && (typeof options.crossOrigin === 'string' || typeof options.integrity === 'string') ? [options.crossOrigin, options.integrity] : PRELOAD_NO_CREDS;
+          renderState.preloads.moduleScripts.set(key, resource);
+          break;
+        }
+
+      default:
+        {
+          const hasAsType = resumableState.moduleUnknownResources.hasOwnProperty(as);
+          let resources;
+
+          if (hasAsType) {
+            resources = resumableState.unknownResources[as];
+
+            if (resources.hasOwnProperty(key)) {
+              // we can return if we already have this resource
+              return;
+            }
+          } else {
+            resources = {};
+            resumableState.moduleUnknownResources[as] = resources;
+          }
+
+          resource = [];
+          resources[key] = PRELOAD_NO_CREDS;
+        }
+    }
+
+    pushLinkImpl(resource, assign({
+      rel: 'modulepreload',
+      href
+    }, options));
+    renderState.bulkPreloads.add(resource); // If we got this far we created a new resource
+
+    flushResources(request);
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (href) {
+    precedence = precedence || 'default';
+    const key = getResourceKey(href);
+    let styleQueue = renderState.styles.get(precedence);
+    const hasKey = resumableState.styleResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.styleResources[key] = EXISTS; // If this is the first time we've encountered this precedence we need
+      // to create a StyleQueue
+
+      if (!styleQueue) {
+        styleQueue = {
+          precedence: stringToChunk(escapeTextForBrowser(precedence)),
+          rules: [],
+          hrefs: [],
+          sheets: new Map()
+        };
+        renderState.styles.set(precedence, styleQueue);
+      }
+
+      const resource = {
+        state: PENDING$1,
+        props: assign({
+          rel: 'stylesheet',
+          href,
+          'data-precedence': precedence
+        }, options)
+      };
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(resource.props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.stylesheets.get(key);
+
+        if (preloadResource && preloadResource.length > 0) {
+          // The Preload for this resource was created in this render pass and has not flushed yet so
+          // we need to clear it to avoid it flushing.
+          preloadResource.length = 0;
+        } else {
+          // Either the preload resource from this render already flushed in this render pass
+          // or the preload flushed in a prior pass (prerender). In either case we need to mark
+          // this resource as already having been preloaded.
+          resource.state = PRELOADED;
+        }
+      } // We add the newly created resource to our StyleQueue and if necessary
+      // track the resource with the currently rendering boundary
+
+
+      styleQueue.sheets.set(key, resource); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+  }
+}
+
+function preinitScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.scriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.scriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.scriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.scripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+}
+
+function preinitModuleScript(src, options) {
+
+  const request = resolveRequest();
+
+  if (!request) {
+    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
+    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
+    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
+    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
+    // fetching) and we don't want to warn in those cases.
+    return;
+  }
+
+  const resumableState = getResumableState(request);
+  const renderState = getRenderState(request);
+
+  if (src) {
+    const key = getResourceKey(src);
+    const hasKey = resumableState.moduleScriptResources.hasOwnProperty(key);
+    const resourceState = hasKey ? resumableState.moduleScriptResources[key] : undefined;
+
+    if (resourceState !== EXISTS) {
+      // We are going to create this resource now so it is marked as Exists
+      resumableState.moduleScriptResources[key] = EXISTS;
+
+      const props = assign({
+        src,
+        type: 'module',
+        async: true
+      }, options);
+
+      if (resourceState) {
+        // When resourceState is truty it is a Preload state. We cast it for clarity
+        const preloadState = resourceState;
+
+        if (preloadState.length === 2) {
+          adoptPreloadCredentials(props, preloadState);
+        }
+
+        const preloadResource = renderState.preloads.moduleScripts.get(key);
+
+        if (preloadResource) {
+          // the preload resource exists was created in this render. Now that we have
+          // a script resource which will emit earlier than a preload would if it
+          // hasn't already flushed we prevent it from flushing by zeroing the length
+          preloadResource.length = 0;
+        }
+      }
+
+      const resource = []; // Add to the script flushing queue
+
+      renderState.scripts.add(resource); // encode the tag as Chunks
+
+      pushScriptImpl(resource, props); // Notify the request that there are resources to flush even if no work is currently happening
+
+      flushResources(request);
+    }
+
+    return;
+  }
+} // This function is only safe to call at Request start time since it assumes
+// that each module has not already been preloaded. If we find a need to preload
+// scripts at any other point in time we will need to check whether the preload
+// already exists and not assume it
+
+
+function preloadBootstrapScriptOrModule(resumableState, renderState, href, props) {
+
+  const key = getResourceKey(href);
+  // used to preinit the resource. If a script can be preinited then it shouldn't
+  // be a bootstrap script/module and if it is a bootstrap script/module then it
+  // must not be safe to emit early. To avoid possibly allowing for preinits of
+  // bootstrap scripts/modules we occlude these keys.
+
+
+  resumableState.scriptResources[key] = EXISTS;
+  resumableState.moduleScriptResources[key] = EXISTS;
+  const resource = [];
+  pushLinkImpl(resource, props);
+  renderState.bootstrapScripts.add(resource);
+}
+
+function internalPreinitScript(resumableState, renderState, src, chunks) {
+  const key = getResourceKey(src);
+
+  if (!resumableState.scriptResources.hasOwnProperty(key)) {
+    const resource = chunks;
+    resumableState.scriptResources[key] = EXISTS;
+    renderState.scripts.add(resource);
+  }
+
+  return;
+}
+
+function preloadAsStylePropsFromProps(href, props) {
+  return {
+    rel: 'preload',
+    as: 'style',
+    href: href,
+    crossOrigin: props.crossOrigin,
+    fetchPriority: props.fetchPriority,
+    integrity: props.integrity,
+    media: props.media,
+    hrefLang: props.hrefLang,
+    referrerPolicy: props.referrerPolicy
+  };
+}
+
+function stylesheetPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    'data-precedence': rawProps.precedence,
+    precedence: null
+  });
+}
+
+function adoptPreloadCredentials(target, preloadState) {
+  if (target.crossOrigin == null) target.crossOrigin = preloadState[0];
+  if (target.integrity == null) target.integrity = preloadState[1];
+}
+
+function getPrefetchDNSAsHeader(href) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  return "<" + escapedHref + ">; rel=dns-prefetch";
+}
+
+function getPreconnectAsHeader(href, crossOrigin) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  let value = "<" + escapedHref + ">; rel=preconnect";
+
+  if (typeof crossOrigin === 'string') {
+    const escapedCrossOrigin = escapeStringForLinkHeaderQuotedParamValueContext(crossOrigin);
+    value += "; crossorigin=\"" + escapedCrossOrigin + "\"";
+  }
+
+  return value;
+}
+
+function getPreloadAsHeader(href, as, params) {
+  const escapedHref = escapeHrefForLinkHeaderURLContext(href);
+  const escapedAs = escapeStringForLinkHeaderQuotedParamValueContext(as);
+  let value = "<" + escapedHref + ">; rel=preload; as=\"" + escapedAs + "\"";
+
+  for (const paramName in params) {
+    if (hasOwnProperty.call(params, paramName)) {
+      const paramValue = params[paramName];
+
+      if (typeof paramValue === 'string') {
+        value += "; " + paramName.toLowerCase() + "=\"" + escapeStringForLinkHeaderQuotedParamValueContext(paramValue) + "\"";
+      }
+    }
+  }
+
+  return value;
+}
+
+function getStylesheetPreloadAsHeader(stylesheet) {
+  const props = stylesheet.props;
+  const preloadOptions = {
+    crossOrigin: props.crossOrigin,
+    integrity: props.integrity,
+    nonce: props.nonce,
+    type: props.type,
+    fetchPriority: props.fetchPriority,
+    referrerPolicy: props.referrerPolicy,
+    media: props.media
+  };
+  return getPreloadAsHeader(props.href, 'style', preloadOptions);
+} // This escaping function is only safe to use for href values being written into
+// a "Link" header in between `<` and `>` characters. The primary concern with the href is
+// to escape the bounding characters as well as new lines. This is unsafe to use in any other
+// context
+
+
+const regexForHrefInLinkHeaderURLContext = /[<>\r\n]/g;
+
+function escapeHrefForLinkHeaderURLContext(hrefInput) {
+
+  const coercedHref = '' + hrefInput;
+  return coercedHref.replace(regexForHrefInLinkHeaderURLContext, escapeHrefForLinkHeaderURLContextReplacer);
+}
+
+function escapeHrefForLinkHeaderURLContextReplacer(match) {
+  switch (match) {
+    case '<':
+      return '%3C';
+
+    case '>':
+      return '%3E';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeLinkHrefForHeaderContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+} // This escaping function is only safe to use for quoted param values in an HTTP header.
+// It is unsafe to use for any value not inside quote marks in parater value position.
+
+
+const regexForLinkHeaderQuotedParamValueContext = /["';,\r\n]/g;
+
+function escapeStringForLinkHeaderQuotedParamValueContext(value, name) {
+
+  const coerced = '' + value;
+  return coerced.replace(regexForLinkHeaderQuotedParamValueContext, escapeStringForLinkHeaderQuotedParamValueContextReplacer);
+}
+
+function escapeStringForLinkHeaderQuotedParamValueContextReplacer(match) {
+  switch (match) {
+    case '"':
+      return '%22';
+
+    case "'":
+      return '%27';
+
+    case ';':
+      return '%3B';
+
+    case ',':
+      return '%2C';
+
+    case '\n':
+      return '%0A';
+
+    case '\r':
+      return '%0D';
+
+    default:
+      {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error('escapeStringForLinkHeaderQuotedParamValueContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
+      }
+  }
+}
+
+function hoistStyleQueueDependency(styleQueue) {
+  this.styles.add(styleQueue);
+}
+
+function hoistStylesheetDependency(stylesheet) {
+  this.stylesheets.add(stylesheet);
+}
+
+function hoistResources(renderState, source) {
+  const currentBoundaryResources = renderState.boundaryResources;
+
+  if (currentBoundaryResources) {
+    source.styles.forEach(hoistStyleQueueDependency, currentBoundaryResources);
+    source.stylesheets.forEach(hoistStylesheetDependency, currentBoundaryResources);
+  }
+} // This function is called at various times depending on whether we are rendering
+// or prerendering. In this implementation we only actually emit headers once and
+// subsequent calls are ignored. We track whether the request has a completed shell
+// to determine whether we will follow headers with a flush including stylesheets.
+// In the context of prerrender we don't have a completed shell when the request finishes
+// with a postpone in the shell. In the context of a render we don't have a completed shell
+// if this is called before the shell finishes rendering which usually will happen anytime
+// anything suspends in the shell.
+
+function emitEarlyPreloads(renderState, resumableState, shellComplete) {
+  const onHeaders = renderState.onHeaders;
+
+  if (onHeaders) {
+    const headers = renderState.headers;
+
+    if (headers) {
+      let linkHeader = headers.preconnects;
+
+      if (headers.fontPreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.fontPreloads;
+      }
+
+      if (headers.highImagePreloads) {
+        if (linkHeader) {
+          linkHeader += ', ';
+        }
+
+        linkHeader += headers.highImagePreloads;
+      }
+
+      if (!shellComplete) {
+        // We use raw iterators because we want to be able to halt iteration
+        // We could refactor renderState to store these dually in arrays to
+        // make this more efficient at the cost of additional memory and
+        // write overhead. However this code only runs once per request so
+        // for now I consider this sufficient.
+        const queueIter = renderState.styles.values();
+
+        outer: for (let queueStep = queueIter.next(); headers.remainingCapacity > 0 && !queueStep.done; queueStep = queueIter.next()) {
+          const sheets = queueStep.value.sheets;
+          const sheetIter = sheets.values();
+
+          for (let sheetStep = sheetIter.next(); headers.remainingCapacity > 0 && !sheetStep.done; sheetStep = sheetIter.next()) {
+            const sheet = sheetStep.value;
+            const props = sheet.props;
+            const key = getResourceKey(props.href);
+            const header = getStylesheetPreloadAsHeader(sheet); // We mutate the capacity b/c we don't want to keep checking if later headers will fit.
+            // This means that a particularly long header might close out the header queue where later
+            // headers could still fit. We could in the future alter the behavior here based on prerender vs render
+            // since during prerender we aren't as concerned with pure runtime performance.
+
+            if ((headers.remainingCapacity -= header.length) >= 2) {
+              renderState.resets.style[key] = PRELOAD_NO_CREDS;
+
+              if (linkHeader) {
+                linkHeader += ', ';
+              }
+
+              linkHeader += header; // We already track that the resource exists in resumableState however
+              // if the resumableState resets because we postponed in the shell
+              // which is what is happening in this branch if we are prerendering
+              // then we will end up resetting the resumableState. When it resets we
+              // want to record the fact that this stylesheet was already preloaded
+
+              renderState.resets.style[key] = typeof props.crossOrigin === 'string' || typeof props.integrity === 'string' ? [props.crossOrigin, props.integrity] : PRELOAD_NO_CREDS;
+            } else {
+              break outer;
+            }
+          }
+        }
+      }
+
+      if (linkHeader) {
+        onHeaders({
+          Link: linkHeader
+        });
+      } else {
+        // We still call this with no headers because a user may be using it as a signal that
+        // it React will not provide any headers
+        onHeaders({});
+      }
+
+      renderState.headers = null;
+      return;
+    }
+  }
+}
+const NotPendingTransition = NotPending;
+
+const requestStorage = new async_hooks.AsyncLocalStorage();
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+const REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_CONTEXT_TYPE = Symbol.for('react.context');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SCOPE_TYPE = Symbol.for('react.scope');
+const REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');
+const REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+const REACT_LEGACY_HIDDEN_TYPE = Symbol.for('react.legacy_hidden');
+const REACT_CACHE_TYPE = Symbol.for('react.cache');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+function getWrappedName(outerType, innerType, wrapperName) {
+  const displayName = outerType.displayName;
+
+  if (displayName) {
+    return displayName;
+  }
+
+  const functionName = innerType.displayName || innerType.name || '';
+  return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
+} // Keep in sync with react-reconciler/getComponentNameFromFiber
+
+
+function getContextName(type) {
+  return type.displayName || 'Context';
+} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+
+function getComponentNameFromType(type) {
+  if (type == null) {
+    // Host root, text node or just invalid type.
+    return null;
+  }
+
+  if (typeof type === 'function') {
+    return type.displayName || type.name || null;
+  }
+
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_FRAGMENT_TYPE:
+      return 'Fragment';
+
+    case REACT_PORTAL_TYPE:
+      return 'Portal';
+
+    case REACT_PROFILER_TYPE:
+      return 'Profiler';
+
+    case REACT_STRICT_MODE_TYPE:
+      return 'StrictMode';
+
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+
+    case REACT_CACHE_TYPE:
+      {
+        return 'Cache';
+      }
+
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        const context = type;
+        return getContextName(context) + '.Consumer';
+
+      case REACT_PROVIDER_TYPE:
+        const provider = type;
+        return getContextName(provider._context) + '.Provider';
+
+      case REACT_FORWARD_REF_TYPE:
+        return getWrappedName(type, type.render, 'ForwardRef');
+
+      case REACT_MEMO_TYPE:
+        const outerName = type.displayName || null;
+
+        if (outerName !== null) {
+          return outerName;
+        }
+
+        return getComponentNameFromType(type.type) || 'Memo';
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            return getComponentNameFromType(init(payload));
+          } catch (x) {
+            return null;
+          }
+        }
+
+    }
+  }
+
+  return null;
+}
+
+const emptyContextObject = {};
+
+function getMaskedContext(type, unmaskedContext) {
+  {
+    const contextTypes = type.contextTypes;
+
+    if (!contextTypes) {
+      return emptyContextObject;
+    }
+
+    const context = {};
+
+    for (const key in contextTypes) {
+      context[key] = unmaskedContext[key];
+    }
+
+    return context;
+  }
+}
+function processChildContext(instance, type, parentContext, childContextTypes) {
+  {
+    // TODO (bvaughn) Replace this behavior with an invariant() in the future.
+    // It has only been added in Fiber to match the (unintentional) behavior in Stack.
+    if (typeof instance.getChildContext !== 'function') {
+
+      return parentContext;
+    }
+
+    const childContext = instance.getChildContext();
+
+    for (const contextKey in childContext) {
+      if (!(contextKey in childContextTypes)) {
+        throw new Error((getComponentNameFromType(type) || 'Unknown') + ".getChildContext(): key \"" + contextKey + "\" is not defined in childContextTypes.");
+      }
+    }
+
+    return assign({}, parentContext, childContext);
+  }
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext);
+    } // On the way back, we push the new ones that weren't common.
+
+
+    pushNode(next);
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function pushProvider(context, nextValue) {
+  let prevValue;
+
+  {
+    prevValue = context._currentValue;
+    context._currentValue = nextValue;
+  }
+
+  const prevNode = currentActiveSnapshot;
+  const newNode = {
+    parent: prevNode,
+    depth: prevNode === null ? 0 : prevNode.depth + 1,
+    context: context,
+    parentValue: prevValue,
+    value: nextValue
+  };
+  currentActiveSnapshot = newNode;
+  return newNode;
+}
+function popProvider(context) {
+  const prevSnapshot = currentActiveSnapshot;
+
+  if (prevSnapshot === null) {
+    throw new Error('Tried to pop a Context at the root of the app. This is a bug in React.');
+  }
+
+  {
+    const value = prevSnapshot.parentValue;
+
+    if (value === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      prevSnapshot.context._currentValue = prevSnapshot.context._defaultValue;
+    } else {
+      prevSnapshot.context._currentValue = value;
+    }
+  }
+
+  return currentActiveSnapshot = prevSnapshot.parent;
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+/**
+ * `ReactInstanceMap` maintains a mapping from a public facing stateful
+ * instance (key) and the internal representation (value). This allows public
+ * methods to accept the user facing instance as an argument and map them back
+ * to internal methods.
+ *
+ * Note that this module is currently shared and assumed to be stateless.
+ * If this becomes an actual Map, that will break.
+ */
+function get(key) {
+  return key._reactInternals;
+}
+function set(key, value) {
+  key._reactInternals = value;
+}
+
+const classComponentUpdater = {
+  isMounted(inst) {
+    return false;
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueSetState(inst, payload, callback) {
+    const internals = get(inst);
+
+    if (internals.queue === null) ; else {
+      internals.queue.push(payload);
+    }
+  },
+
+  enqueueReplaceState(inst, payload, callback) {
+    const internals = get(inst);
+    internals.replace = true;
+    internals.queue = [payload];
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueForceUpdate(inst, callback) {
+  }
+
+};
+
+function applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, prevState, nextProps) {
+  const partialState = getDerivedStateFromProps(nextProps, prevState);
+
+
+  const newState = partialState === null || partialState === undefined ? prevState : assign({}, prevState, partialState);
+  return newState;
+}
+
+function constructClassInstance(ctor, props, maskedLegacyContext) {
+  let context = emptyContextObject;
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    context = readContext$1(contextType);
+  } else {
+    context = maskedLegacyContext;
+  }
+
+  const instance = new ctor(props, context);
+
+  return instance;
+}
+
+function callComponentWillMount(type, instance) {
+  const oldState = instance.state;
+
+  if (typeof instance.componentWillMount === 'function') {
+
+    instance.componentWillMount();
+  }
+
+  if (typeof instance.UNSAFE_componentWillMount === 'function') {
+    instance.UNSAFE_componentWillMount();
+  }
+
+  if (oldState !== instance.state) {
+
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+}
+
+function processUpdateQueue(internalInstance, inst, props, maskedLegacyContext) {
+  if (internalInstance.queue !== null && internalInstance.queue.length > 0) {
+    const oldQueue = internalInstance.queue;
+    const oldReplace = internalInstance.replace;
+    internalInstance.queue = null;
+    internalInstance.replace = false;
+
+    if (oldReplace && oldQueue.length === 1) {
+      inst.state = oldQueue[0];
+    } else {
+      let nextState = oldReplace ? oldQueue[0] : inst.state;
+      let dontMutate = true;
+
+      for (let i = oldReplace ? 1 : 0; i < oldQueue.length; i++) {
+        const partial = oldQueue[i];
+        const partialState = typeof partial === 'function' ? partial.call(inst, nextState, props, maskedLegacyContext) : partial;
+
+        if (partialState != null) {
+          if (dontMutate) {
+            dontMutate = false;
+            nextState = assign({}, nextState, partialState);
+          } else {
+            assign(nextState, partialState);
+          }
+        }
+      }
+
+      inst.state = nextState;
+    }
+  } else {
+    internalInstance.queue = null;
+  }
+} // Invokes the mount life-cycles on a previously never rendered instance.
+
+
+function mountClassInstance(instance, ctor, newProps, maskedLegacyContext) {
+
+  const initialState = instance.state !== undefined ? instance.state : null;
+  instance.updater = classComponentUpdater;
+  instance.props = newProps;
+  instance.state = initialState; // We don't bother initializing the refs object on the server, since we're not going to resolve them anyway.
+  // The internal instance will be used to manage updates that happen during this mount.
+
+  const internalInstance = {
+    queue: [],
+    replace: false
+  };
+  set(instance, internalInstance);
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    instance.context = readContext$1(contextType);
+  } else {
+    instance.context = maskedLegacyContext;
+  }
+
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    instance.state = applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, initialState, newProps);
+  } // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+
+  if (typeof ctor.getDerivedStateFromProps !== 'function' && typeof instance.getSnapshotBeforeUpdate !== 'function' && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
+    callComponentWillMount(ctor, instance); // If we had additional state updates during this life-cycle, let's
+    // process them now.
+
+    processUpdateQueue(internalInstance, instance, newProps, maskedLegacyContext);
+  }
+}
+
+// Ids are base 32 strings whose binary representation corresponds to the
+// position of a node in a tree.
+// Every time the tree forks into multiple children, we add additional bits to
+// the left of the sequence that represent the position of the child within the
+// current level of children.
+//
+//      00101       00010001011010101
+//      ╰─┬─╯       ╰───────┬───────╯
+//   Fork 5 of 20       Parent id
+//
+// The leading 0s are important. In the above example, you only need 3 bits to
+// represent slot 5. However, you need 5 bits to represent all the forks at
+// the current level, so we must account for the empty bits at the end.
+//
+// For this same reason, slots are 1-indexed instead of 0-indexed. Otherwise,
+// the zeroth id at a level would be indistinguishable from its parent.
+//
+// If a node has only one child, and does not materialize an id (i.e. does not
+// contain a useId hook), then we don't need to allocate any space in the
+// sequence. It's treated as a transparent indirection. For example, these two
+// trees produce the same ids:
+//
+// <>                          <>
+//   <Indirection>               <A />
+//     <A />                     <B />
+//   </Indirection>            </>
+//   <B />
+// </>
+//
+// However, we cannot skip any node that materializes an id. Otherwise, a parent
+// id that does not fork would be indistinguishable from its child id. For
+// example, this tree does not fork, but the parent and child must have
+// different ids.
+//
+// <Parent>
+//   <Child />
+// </Parent>
+//
+// To handle this scenario, every time we materialize an id, we allocate a
+// new level with a single slot. You can think of this as a fork with only one
+// prong, or an array of children with length 1.
+//
+// It's possible for the size of the sequence to exceed 32 bits, the max
+// size for bitwise operations. When this happens, we make more room by
+// converting the right part of the id to a string and storing it in an overflow
+// variable. We use a base 32 string representation, because 32 is the largest
+// power of 2 that is supported by toString(). We want the base to be large so
+// that the resulting ids are compact, and we want the base to be a power of 2
+// because every log2(base) bits corresponds to a single character, i.e. every
+// log2(32) = 5 bits. That means we can lop bits off the end 5 at a time without
+// affecting the final result.
+const emptyTreeContext = {
+  id: 1,
+  overflow: ''
+};
+function getTreeId(context) {
+  const overflow = context.overflow;
+  const idWithLeadingBit = context.id;
+  const id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
+  return id.toString(32) + overflow;
+}
+function pushTreeContext(baseContext, totalChildren, index) {
+  const baseIdWithLeadingBit = baseContext.id;
+  const baseOverflow = baseContext.overflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
+  // of the id; we use it to account for leading 0s.
+
+  const baseLength = getBitLength(baseIdWithLeadingBit) - 1;
+  const baseId = baseIdWithLeadingBit & ~(1 << baseLength);
+  const slot = index + 1;
+  const length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
+  // consideration the leading 1 we use to mark the end of the sequence.
+
+  if (length > 30) {
+    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
+    // This branch assumes the length of the base id is greater than 5; it won't
+    // work for smaller ids, because you need 5 bits per character.
+    //
+    // We encode the id in multiple steps: first the base id, then the
+    // remaining digits.
+    //
+    // Each 5 bit sequence corresponds to a single base 32 character. So for
+    // example, if the current id is 23 bits long, we can convert 20 of those
+    // bits into a string of 4 characters, with 3 bits left over.
+    //
+    // First calculate how many bits in the base id represent a complete
+    // sequence of characters.
+    const numberOfOverflowBits = baseLength - baseLength % 5; // Then create a bitmask that selects only those bits.
+
+    const newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
+
+    const newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
+
+    const restOfBaseId = baseId >> numberOfOverflowBits;
+    const restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
+    // we made more room, this time it won't overflow.
+
+    const restOfLength = getBitLength(totalChildren) + restOfBaseLength;
+    const restOfNewBits = slot << restOfBaseLength;
+    const id = restOfNewBits | restOfBaseId;
+    const overflow = newOverflow + baseOverflow;
+    return {
+      id: 1 << restOfLength | id,
+      overflow
+    };
+  } else {
+    // Normal path
+    const newBits = slot << baseLength;
+    const id = newBits | baseId;
+    const overflow = baseOverflow;
+    return {
+      id: 1 << length | id,
+      overflow
+    };
+  }
+}
+
+function getBitLength(number) {
+  return 32 - clz32(number);
+}
+
+function getLeadingBit(id) {
+  return 1 << getBitLength(id) - 1;
+} // TODO: Math.clz32 is supported in Node 12+. Maybe we can drop the fallback.
+
+
+const 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
+
+const log = Math.log;
+const LN2 = Math.LN2;
+
+function clz32Fallback(x) {
+  const asUint = x >>> 0;
+
+  if (asUint === 0) {
+    return 32;
+  }
+
+  return 31 - (log(asUint) / LN2 | 0) | 0;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFlightWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop$2() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop$2, noop$2);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+
+const objectIs = // $FlowFixMe[method-unbinding]
+typeof Object.is === 'function' ? Object.is : is;
+
+let currentlyRenderingComponent = null;
+let currentlyRenderingTask = null;
+let currentlyRenderingRequest = null;
+let currentlyRenderingKeyPath = null;
+let firstWorkInProgressHook = null;
+let workInProgressHook = null; // Whether the work-in-progress hook is a re-rendered hook
+
+let isReRender = false; // Whether an update was scheduled during the currently executing render pass.
+
+let didScheduleRenderPhaseUpdate = false; // Counts the number of useId hooks in this component
+
+let localIdCounter = 0; // Chunks that should be pushed to the stream once the component
+// finishes rendering.
+// Counts the number of useFormState calls in this component
+
+let formStateCounter = 0; // The index of the useFormState hook that matches the one passed in at the
+// root during an MPA navigation, if any.
+
+let formStateMatchingIndex = -1; // Counts the number of use(thenable) calls in this component
+
+let thenableIndexCounter = 0;
+let thenableState = null; // Lazily created map of render-phase updates
+
+let renderPhaseUpdates = null; // Counter to prevent infinite loops.
+
+let numberOfReRenders = 0;
+const RE_RENDER_LIMIT = 25;
+
+function resolveCurrentlyRenderingComponent() {
+  if (currentlyRenderingComponent === null) {
+    throw new Error('Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for' + ' one of the following reasons:\n' + '1. You might have mismatching versions of React and the renderer (such as React DOM)\n' + '2. You might be breaking the Rules of Hooks\n' + '3. You might have more than one copy of React in the same app\n' + 'See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.');
+  }
+
+  return currentlyRenderingComponent;
+}
+
+function areHookInputsEqual(nextDeps, prevDeps) {
+  if (prevDeps === null) {
+
+    return false;
+  }
+
+
+  for (let i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    if (objectIs(nextDeps[i], prevDeps[i])) {
+      continue;
+    }
+
+    return false;
+  }
+
+  return true;
+}
+
+function createHook() {
+  if (numberOfReRenders > 0) {
+    throw new Error('Rendered more hooks than during the previous render');
+  }
+
+  return {
+    memoizedState: null,
+    queue: null,
+    next: null
+  };
+}
+
+function createWorkInProgressHook() {
+  if (workInProgressHook === null) {
+    // This is the first hook in the list
+    if (firstWorkInProgressHook === null) {
+      isReRender = false;
+      firstWorkInProgressHook = workInProgressHook = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = firstWorkInProgressHook;
+    }
+  } else {
+    if (workInProgressHook.next === null) {
+      isReRender = false; // Append to the end of the list
+
+      workInProgressHook = workInProgressHook.next = createHook();
+    } else {
+      // There's already a work-in-progress. Reuse it.
+      isReRender = true;
+      workInProgressHook = workInProgressHook.next;
+    }
+  }
+
+  return workInProgressHook;
+}
+
+function prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState) {
+  currentlyRenderingComponent = componentIdentity;
+  currentlyRenderingTask = task;
+  currentlyRenderingRequest = request;
+  currentlyRenderingKeyPath = keyPath;
+  // didScheduleRenderPhaseUpdate = false;
+  // firstWorkInProgressHook = null;
+  // numberOfReRenders = 0;
+  // renderPhaseUpdates = null;
+  // workInProgressHook = null;
+
+
+  localIdCounter = 0;
+  formStateCounter = 0;
+  formStateMatchingIndex = -1;
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function finishHooks(Component, props, children, refOrContext) {
+  // This must be called after every function component to prevent hooks from
+  // being used in classes.
+  while (didScheduleRenderPhaseUpdate) {
+    // Updates were scheduled during the render phase. They are stored in
+    // the `renderPhaseUpdates` map. Call the component again, reusing the
+    // work-in-progress hooks and applying the additional updates on top. Keep
+    // restarting until no more updates are scheduled.
+    didScheduleRenderPhaseUpdate = false;
+    localIdCounter = 0;
+    formStateCounter = 0;
+    formStateMatchingIndex = -1;
+    thenableIndexCounter = 0;
+    numberOfReRenders += 1; // Start over from the beginning of the list
+
+    workInProgressHook = null;
+    children = Component(props, refOrContext);
+  }
+
+  resetHooksState();
+  return children;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+function checkDidRenderIdHook() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  const didRenderIdHook = localIdCounter !== 0;
+  return didRenderIdHook;
+}
+function getFormStateCount() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateCounter;
+}
+function getFormStateMatchingIndex() {
+  // This should be called immediately after every finishHooks call.
+  // Conceptually, it's part of the return value of finishHooks; it's only a
+  // separate function to avoid using an array tuple.
+  return formStateMatchingIndex;
+} // Reset the internal hooks state if an error occurs while rendering a component
+
+function resetHooksState() {
+
+  currentlyRenderingComponent = null;
+  currentlyRenderingTask = null;
+  currentlyRenderingRequest = null;
+  currentlyRenderingKeyPath = null;
+  didScheduleRenderPhaseUpdate = false;
+  firstWorkInProgressHook = null;
+  numberOfReRenders = 0;
+  renderPhaseUpdates = null;
+  workInProgressHook = null;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+function useContext(context) {
+
+  resolveCurrentlyRenderingComponent();
+  return readContext$1(context);
+}
+
+function basicStateReducer(state, action) {
+  // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
+  return typeof action === 'function' ? action(state) : action;
+}
+
+function useState(initialState) {
+
+  return useReducer(basicStateReducer, // useReducer has a special case to support lazy useState initializers
+  initialState);
+}
+function useReducer(reducer, initialArg, init) {
+
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+
+  if (isReRender) {
+    // This is a re-render. Apply the new render phase updates to the previous
+    // current hook.
+    const queue = workInProgressHook.queue;
+    const dispatch = queue.dispatch;
+
+    if (renderPhaseUpdates !== null) {
+      // Render phase updates are stored in a map of queue -> linked list
+      const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+      if (firstRenderPhaseUpdate !== undefined) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        renderPhaseUpdates.delete(queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+        let newState = workInProgressHook.memoizedState;
+        let update = firstRenderPhaseUpdate;
+
+        do {
+          // Process this render phase update. We don't have to check the
+          // priority because it will always be the same as the current
+          // render's.
+          const action = update.action;
+
+          newState = reducer(newState, action);
+
+
+          update = update.next;
+        } while (update !== null); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+        workInProgressHook.memoizedState = newState;
+        return [newState, dispatch];
+      }
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    return [workInProgressHook.memoizedState, dispatch];
+  } else {
+
+    let initialState;
+
+    if (reducer === basicStateReducer) {
+      // Special case for `useState`.
+      initialState = typeof initialArg === 'function' ? initialArg() : initialArg;
+    } else {
+      initialState = init !== undefined ? init(initialArg) : initialArg;
+    }
+
+
+    workInProgressHook.memoizedState = initialState; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    const queue = workInProgressHook.queue = {
+      last: null,
+      dispatch: null
+    };
+    const dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingComponent, queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+    return [workInProgressHook.memoizedState, dispatch];
+  }
+}
+
+function useMemo(nextCreate, deps) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+
+  if (workInProgressHook !== null) {
+    const prevState = workInProgressHook.memoizedState;
+
+    if (prevState !== null) {
+      if (nextDeps !== null) {
+        const prevDeps = prevState[1];
+
+        if (areHookInputsEqual(nextDeps, prevDeps)) {
+          return prevState[0];
+        }
+      }
+    }
+  }
+
+  const nextValue = nextCreate();
+
+
+  workInProgressHook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
+
+function useRef(initialValue) {
+  currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
+  workInProgressHook = createWorkInProgressHook();
+  const previousRef = workInProgressHook.memoizedState;
+
+  if (previousRef === null) {
+    const ref = {
+      current: initialValue
+    };
+
+
+    workInProgressHook.memoizedState = ref;
+    return ref;
+  } else {
+    return previousRef;
+  }
+}
+
+function dispatchAction(componentIdentity, queue, action) {
+  if (numberOfReRenders >= RE_RENDER_LIMIT) {
+    throw new Error('Too many re-renders. React limits the number of renders to prevent ' + 'an infinite loop.');
+  }
+
+  if (componentIdentity === currentlyRenderingComponent) {
+    // This is a render phase update. Stash it in a lazily-created map of
+    // queue -> linked list of updates. After this render pass, we'll restart
+    // and apply the stashed updates on top of the work-in-progress hook.
+    didScheduleRenderPhaseUpdate = true;
+    const update = {
+      action,
+      next: null
+    };
+
+    if (renderPhaseUpdates === null) {
+      renderPhaseUpdates = new Map();
+    }
+
+    const firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+    if (firstRenderPhaseUpdate === undefined) {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      renderPhaseUpdates.set(queue, update);
+    } else {
+      // Append the update to the end of the list.
+      let lastRenderPhaseUpdate = firstRenderPhaseUpdate;
+
+      while (lastRenderPhaseUpdate.next !== null) {
+        lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+      }
+
+      lastRenderPhaseUpdate.next = update;
+    }
+  }
+}
+
+function useCallback(callback, deps) {
+  return useMemo(() => callback, deps);
+}
+
+function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  if (getServerSnapshot === undefined) {
+    throw new Error('Missing getServerSnapshot, which is required for ' + 'server-rendered content. Will revert to client rendering.');
+  }
+
+  return getServerSnapshot();
+}
+
+function useDeferredValue(value, initialValue) {
+  resolveCurrentlyRenderingComponent();
+
+  {
+    return value;
+  }
+}
+
+function unsupportedStartTransition() {
+  throw new Error('startTransition cannot be called during server rendering.');
+}
+
+function useTransition() {
+  resolveCurrentlyRenderingComponent();
+  return [false, unsupportedStartTransition];
+}
+
+function useHostTransitionStatus() {
+  resolveCurrentlyRenderingComponent();
+  return NotPendingTransition;
+}
+
+function unsupportedSetOptimisticState() {
+  throw new Error('Cannot update optimistic state while rendering.');
+}
+
+function useOptimistic(passthrough, reducer) {
+  resolveCurrentlyRenderingComponent();
+  return [passthrough, unsupportedSetOptimisticState];
+}
+
+function createPostbackFormStateKey(permalink, componentKeyPath, hookIndex) {
+  if (permalink !== undefined) {
+    // Don't bother to hash a permalink-based key since it's already short.
+    return 'p' + permalink;
+  } else {
+    // Append a node to the key path that represents the form state hook.
+    const keyPath = [componentKeyPath, null, hookIndex]; // Key paths are hashed to reduce the size. It does not need to be secure,
+    // and it's more important that it's fast than that it's completely
+    // collision-free.
+
+    const keyPathHash = createFastHash(JSON.stringify(keyPath));
+    return 'k' + keyPathHash;
+  }
+}
+
+function useFormState(action, initialState, permalink) {
+  resolveCurrentlyRenderingComponent(); // Count the number of useFormState hooks per component. We also use this to
+  // track the position of this useFormState hook relative to the other ones in
+  // this component, so we can generate a unique key for each one.
+
+  const formStateHookIndex = formStateCounter++;
+  const request = currentlyRenderingRequest; // $FlowIgnore[prop-missing]
+
+  const formAction = action.$$FORM_ACTION;
+
+  if (typeof formAction === 'function') {
+    // This is a server action. These have additional features to enable
+    // MPA-style form submissions with progressive enhancement.
+    // TODO: If the same permalink is passed to multiple useFormStates, and
+    // they all have the same action signature, Fizz will pass the postback
+    // state to all of them. We should probably only pass it to the first one,
+    // and/or warn.
+    // The key is lazily generated and deduped so the that the keypath doesn't
+    // get JSON.stringify-ed unnecessarily, and at most once.
+    let nextPostbackStateKey = null; // Determine the current form state. If we received state during an MPA form
+    // submission, then we will reuse that, if the action identity matches.
+    // Otherwise we'll use the initial state argument. We will emit a comment
+    // marker into the stream that indicates whether the state was reused.
+
+    let state = initialState;
+    const componentKeyPath = currentlyRenderingKeyPath;
+    const postbackFormState = getFormState(request); // $FlowIgnore[prop-missing]
+
+    const isSignatureEqual = action.$$IS_SIGNATURE_EQUAL;
+
+    if (postbackFormState !== null && typeof isSignatureEqual === 'function') {
+      const postbackKey = postbackFormState[1];
+      const postbackReferenceId = postbackFormState[2];
+      const postbackBoundArity = postbackFormState[3];
+
+      if (isSignatureEqual.call(action, postbackReferenceId, postbackBoundArity)) {
+        nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+
+        if (postbackKey === nextPostbackStateKey) {
+          // This was a match
+          formStateMatchingIndex = formStateHookIndex; // Reuse the state that was submitted by the form.
+
+          state = postbackFormState[0];
+        }
+      }
+    } // Bind the state to the first argument of the action.
+
+
+    const boundAction = action.bind(null, state); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    }; // $FlowIgnore[prop-missing]
+
+
+    if (typeof boundAction.$$FORM_ACTION === 'function') {
+      // $FlowIgnore[prop-missing]
+      dispatch.$$FORM_ACTION = prefix => {
+        const metadata = boundAction.$$FORM_ACTION(prefix); // Override the action URL
+
+        if (permalink !== undefined) {
+
+          permalink += '';
+          metadata.action = permalink;
+        }
+
+        const formData = metadata.data;
+
+        if (formData) {
+          if (nextPostbackStateKey === null) {
+            nextPostbackStateKey = createPostbackFormStateKey(permalink, componentKeyPath, formStateHookIndex);
+          }
+
+          formData.append('$ACTION_KEY', nextPostbackStateKey);
+        }
+
+        return metadata;
+      };
+    }
+
+    return [state, dispatch];
+  } else {
+    // This is not a server action, so the implementation is much simpler.
+    // Bind the state to the first argument of the action.
+    const boundAction = action.bind(null, initialState); // Wrap the action so the return value is void.
+
+    const dispatch = payload => {
+      boundAction(payload);
+    };
+
+    return [initialState, dispatch];
+  }
+}
+
+function useId() {
+  const task = currentlyRenderingTask;
+  const treeId = getTreeId(task.treeContext);
+  const resumableState = currentResumableState;
+
+  if (resumableState === null) {
+    throw new Error('Invalid hook call. Hooks can only be called inside of the body of a function component.');
+  }
+
+  const localId = localIdCounter++;
+  return makeId(resumableState, treeId, localId);
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable;
+      return unwrapThenable(thenable);
+    } else if (usable.$$typeof === REACT_CONTEXT_TYPE || usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function unwrapThenable(thenable) {
+  const index = thenableIndexCounter;
+  thenableIndexCounter += 1;
+
+  if (thenableState === null) {
+    thenableState = createThenableState();
+  }
+
+  return trackUsedThenable(thenableState, thenable, index);
+}
+
+function unsupportedRefresh() {
+  throw new Error('Cache cannot be refreshed during server rendering.');
+}
+
+function useCacheRefresh() {
+  return unsupportedRefresh;
+}
+
+function noop$1() {}
+
+const HooksDispatcher = {
+  readContext,
+  use,
+  useContext,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+  useInsertionEffect: noop$1,
+  useLayoutEffect: noop$1,
+  useCallback,
+  // useImperativeHandle is not run in the server environment
+  useImperativeHandle: noop$1,
+  // Effects are not run in the server environment.
+  useEffect: noop$1,
+  // Debugging effect
+  useDebugValue: noop$1,
+  useDeferredValue,
+  useTransition,
+  useId,
+  // Subscriptions are not setup in a server environment.
+  useSyncExternalStore
+};
+
+{
+  HooksDispatcher.useCacheRefresh = useCacheRefresh;
+}
+
+{
+  HooksDispatcher.useHostTransitionStatus = useHostTransitionStatus;
+}
+
+{
+  HooksDispatcher.useOptimistic = useOptimistic;
+  HooksDispatcher.useFormState = useFormState;
+}
+
+let currentResumableState = null;
+function setCurrentResumableState(resumableState) {
+  currentResumableState = resumableState;
+}
+
+function getCacheSignal() {
+  throw new Error('Not implemented.');
+}
+
+function getCacheForType(resourceType) {
+  throw new Error('Not implemented.');
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal,
+  getCacheForType
+};
+
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+const ReactCurrentCache = ReactSharedInternals.ReactCurrentCache;
+// The name might be minified but we assume that it's going to be the same generated name. Typically
+// because it's just the same compiled output in practice.
+// resume with segmentID at the index
+
+const CLIENT_RENDERED = 4; // if it errors or infinitely suspends
+
+const PENDING = 0;
+const COMPLETED = 1;
+const FLUSHED = 2;
+const ABORTED = 3;
+const ERRORED = 4;
+const POSTPONED = 5;
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2; // This is a default heuristic for how to split up the HTML content into progressive
+// loading. Our goal is to be able to display additional new content about every 500ms.
+// Faster than that is unnecessary and should be throttled on the client. It also
+// adds unnecessary overhead to do more splits. We don't know if it's a higher or lower
+// end device but higher end suffer less from the overhead than lower end does from
+// not getting small enough pieces. We error on the side of low end.
+// We base this on low end 3G speeds which is about 500kbits per second. We assume
+// that there can be a reasonable drop off from max bandwidth which leaves you with
+// as little as 80%. We can receive half of that each 500ms - at best. In practice,
+// a little bandwidth is lost to processing and contention - e.g. CSS and images that
+// are downloaded along with the main content. So we estimate about half of that to be
+// the lower end throughput. In other words, we expect that you can at least show
+// about 12.5kb of content per 500ms. Not counting starting latency for the first
+// paint.
+// 500 * 1024 / 8 * .8 * 0.5 / 2
+
+const DEFAULT_PROGRESSIVE_CHUNK_SIZE = 12800;
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+
+  return null;
+}
+
+function noop() {}
+
+function createRequest(children, resumableState, renderState, rootFormatContext, progressiveChunkSize, onError, onAllReady, onShellReady, onShellError, onFatalError, onPostpone, formState) {
+  prepareHostDispatcher();
+  const pingedTasks = [];
+  const abortSet = new Set();
+  const request = {
+    destination: null,
+    flushScheduled: false,
+    resumableState,
+    renderState,
+    rootFormatContext,
+    progressiveChunkSize: progressiveChunkSize === undefined ? DEFAULT_PROGRESSIVE_CHUNK_SIZE : progressiveChunkSize,
+    status: OPEN,
+    fatalError: null,
+    nextSegmentId: 0,
+    allPendingTasks: 0,
+    pendingRootTasks: 0,
+    completedRootSegment: null,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    clientRenderedBoundaries: [],
+    completedBoundaries: [],
+    partialBoundaries: [],
+    trackedPostpones: null,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? noop : onPostpone,
+    onAllReady: onAllReady === undefined ? noop : onAllReady,
+    onShellReady: onShellReady === undefined ? noop : onShellReady,
+    onShellError: onShellError === undefined ? noop : onShellError,
+    onFatalError: onFatalError === undefined ? noop : onFatalError,
+    formState: formState === undefined ? null : formState
+  }; // This segment represents the root fallback.
+
+  const rootSegment = createPendingSegment(request, 0, null, rootFormatContext, // Root segments are never embedded in Text on either edge
+  false, false); // There is no parent so conceptually, we're unblocked to flush this segment.
+
+  rootSegment.parentFlushed = true;
+  const rootTask = createRenderTask(request, null, children, -1, null, rootSegment, abortSet, null, rootFormatContext, emptyContextObject, rootContextSnapshot, emptyTreeContext);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  {
+    const store = requestStorage.getStore();
+    if (store) return store;
+  }
+
+  return null;
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (request.pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createSuspenseBoundary(request, fallbackAbortableTasks) {
+  return {
+    status: PENDING,
+    rootSegmentID: -1,
+    parentFlushed: false,
+    pendingTasks: 0,
+    completedSegments: [],
+    byteSize: 0,
+    fallbackAbortableTasks,
+    errorDigest: null,
+    resources: createBoundaryResources(),
+    trackedContentKeyPath: null,
+    trackedFallbackNode: null
+  };
+}
+
+function createRenderTask(request, thenableState, node, childIndex, blockedBoundary, blockedSegment, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  const task = {
+    replay: null,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createReplayTask(request, thenableState, replay, node, childIndex, blockedBoundary, abortSet, keyPath, formatContext, legacyContext, context, treeContext) {
+  request.allPendingTasks++;
+
+  if (blockedBoundary === null) {
+    request.pendingRootTasks++;
+  } else {
+    blockedBoundary.pendingTasks++;
+  }
+
+  replay.pendingTasks++;
+  const task = {
+    replay,
+    node,
+    childIndex,
+    ping: () => pingTask(request, task),
+    blockedBoundary,
+    blockedSegment: null,
+    abortSet,
+    keyPath,
+    formatContext,
+    legacyContext,
+    context,
+    treeContext,
+    thenableState
+  };
+
+  abortSet.add(task);
+  return task;
+}
+
+function createPendingSegment(request, index, boundary, parentFormatContext, lastPushedText, textEmbedded) {
+  return {
+    status: PENDING,
+    id: -1,
+    // lazily assigned later
+    index,
+    parentFlushed: false,
+    chunks: [],
+    children: [],
+    parentFormatContext,
+    boundary,
+    lastPushedText,
+    textEmbedded
+  };
+} // DEV-only global reference to the currently executing task
+
+function popComponentStackInDEV(task) {
+} // stash the component stack of an unwinding error until it is processed
+
+function logRecoverableError(request, error) {
+  // If this callback errors, we intentionally let that error bubble up to become a fatal error
+  // so that someone fixes the error reporting instead of hiding it.
+  const errorDigest = request.onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest;
+}
+
+function fatalError(request, error) {
+  // This is called outside error handling code such as if the root errors outside
+  // a suspense boundary or if the root suspense boundary's fallback errors.
+  // It's also called if React itself or its host configs errors.
+  const onShellError = request.onShellError;
+  onShellError(error);
+  const onFatalError = request.onFatalError;
+  onFatalError(error);
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function renderSuspenseBoundary(request, someTask, keyPath, props) {
+  if (someTask.replay !== null) {
+    // If we're replaying through this pass, it means we're replaying through
+    // an already completed Suspense boundary. It's too late to do anything about it
+    // so we can just render through it.
+    const prevKeyPath = someTask.keyPath;
+    someTask.keyPath = keyPath;
+    const content = props.children;
+
+    try {
+      renderNode(request, someTask, content, -1);
+    } finally {
+      someTask.keyPath = prevKeyPath;
+    }
+
+    return;
+  } // $FlowFixMe: Refined.
+
+
+  const task = someTask;
+  const prevKeyPath = task.keyPath;
+  const parentBoundary = task.blockedBoundary;
+  const parentSegment = task.blockedSegment; // Each time we enter a suspense boundary, we split out into a new segment for
+  // the fallback so that we can later replace that segment with the content.
+  // This also lets us split out the main content even if it doesn't suspend,
+  // in case it ends up generating a large subtree of content.
+
+  const fallback = props.fallback;
+  const content = props.children;
+  const fallbackAbortSet = new Set();
+  const newBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+
+  if (request.trackedPostpones !== null) {
+    newBoundary.trackedContentKeyPath = keyPath;
+  }
+
+  const insertionIndex = parentSegment.chunks.length; // The children of the boundary segment is actually the fallback.
+
+  const boundarySegment = createPendingSegment(request, insertionIndex, newBoundary, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false);
+  parentSegment.children.push(boundarySegment); // The parentSegment has a child Segment at this index so we reset the lastPushedText marker on the parent
+
+  parentSegment.lastPushedText = false; // This segment is the actual child content. We can start rendering that immediately.
+
+  const contentRootSegment = createPendingSegment(request, 0, null, task.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
+  false, false); // We mark the root segment as having its parent flushed. It's not really flushed but there is
+  // no parent segment so there's nothing to wait on.
+
+  contentRootSegment.parentFlushed = true; // Currently this is running synchronously. We could instead schedule this to pingedTasks.
+  // I suspect that there might be some efficiency benefits from not creating the suspended task
+  // and instead just using the stack if possible.
+  // TODO: Call this directly instead of messing with saving and restoring contexts.
+  // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and which segment
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = newBoundary;
+  task.blockedSegment = contentRootSegment;
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, newBoundary.resources);
+  }
+
+  task.keyPath = keyPath;
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+    pushSegmentFinale(contentRootSegment.chunks, request.renderState, contentRootSegment.lastPushedText, contentRootSegment.textEmbedded);
+    contentRootSegment.status = COMPLETED;
+    queueCompletedSegment(newBoundary, contentRootSegment);
+
+    if (newBoundary.pendingTasks === 0 && newBoundary.status === PENDING) {
+      newBoundary.status = COMPLETED; // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    contentRootSegment.status = ERRORED;
+    newBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    newBoundary.errorDigest = errorDigest;
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.blockedSegment = parentSegment;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]];
+  const trackedPostpones = request.trackedPostpones;
+
+  if (trackedPostpones !== null) {
+    // We create a detached replay node to track any postpones inside the fallback.
+    const fallbackReplayNode = [fallbackKeyPath[1], fallbackKeyPath[2], [], null];
+    trackedPostpones.workingMap.set(fallbackKeyPath, fallbackReplayNode);
+
+    if (newBoundary.status === POSTPONED) {
+      // This must exist now.
+      const boundaryReplayNode = trackedPostpones.workingMap.get(keyPath);
+      boundaryReplayNode[4] = fallbackReplayNode;
+    } else {
+      // We might not inject it into the postponed tree, unless the content actually
+      // postpones too. We need to keep track of it until that happpens.
+      newBoundary.trackedFallbackNode = fallbackReplayNode;
+    }
+  } // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+
+  const suspendedFallbackTask = createRenderTask(request, null, fallback, -1, parentBoundary, boundarySegment, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function replaySuspenseBoundary(request, task, keyPath, props, id, childNodes, childSlots, fallbackNodes, fallbackSlots) {
+  const prevKeyPath = task.keyPath;
+  const previousReplaySet = task.replay;
+  const parentBoundary = task.blockedBoundary;
+  const content = props.children;
+  const fallback = props.fallback;
+  const fallbackAbortSet = new Set();
+  const resumedBoundary = createSuspenseBoundary(request, fallbackAbortSet);
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = id; // We can reuse the current context and task to render the content immediately without
+  // context switching. We just need to temporarily switch which boundary and replay node
+  // we're writing to. If something suspends, it'll spawn new suspended task with that context.
+
+  task.blockedBoundary = resumedBoundary;
+  task.replay = {
+    nodes: childNodes,
+    slots: childSlots,
+    pendingTasks: 1
+  };
+
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, resumedBoundary.resources);
+  }
+
+  try {
+    // We use the safe form because we don't handle suspending here. Only error handling.
+    renderNode(request, task, content, -1);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+    }
+
+    task.replay.pendingTasks--;
+
+    if (resumedBoundary.pendingTasks === 0 && resumedBoundary.status === PENDING) {
+      resumedBoundary.status = COMPLETED;
+      request.completedBoundaries.push(resumedBoundary); // This must have been the last segment we were waiting on. This boundary is now complete.
+      // Therefore we won't need the fallback. We early return so that we don't have to create
+      // the fallback.
+
+      popComponentStackInDEV(task);
+      return;
+    }
+  } catch (error) {
+    resumedBoundary.status = CLIENT_RENDERED;
+    let errorDigest;
+
+    {
+      errorDigest = logRecoverableError(request, error);
+    }
+
+    resumedBoundary.errorDigest = errorDigest;
+
+    task.replay.pendingTasks--; // The parent already flushed in the prerender so we need to schedule this to be emitted.
+
+    request.clientRenderedBoundaries.push(resumedBoundary); // We don't need to decrement any task numbers because we didn't spawn any new task.
+    // We don't need to schedule any task because we know the parent has written yet.
+    // We do need to fallthrough to create the fallback though.
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, parentBoundary ? parentBoundary.resources : null);
+    }
+
+    task.blockedBoundary = parentBoundary;
+    task.replay = previousReplaySet;
+    task.keyPath = prevKeyPath;
+  }
+
+  const fallbackKeyPath = [keyPath[0], 'Suspense Fallback', keyPath[2]]; // We create suspended task for the fallback because we don't want to actually work
+  // on it yet in case we finish the main content, so we queue for later.
+
+  const fallbackReplay = {
+    nodes: fallbackNodes,
+    slots: fallbackSlots,
+    pendingTasks: 0
+  };
+  const suspendedFallbackTask = createReplayTask(request, null, fallbackReplay, fallback, -1, parentBoundary, fallbackAbortSet, fallbackKeyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+  // on preparing fallbacks if we don't have any more main content to task on.
+
+
+  request.pingedTasks.push(suspendedFallbackTask);
+}
+
+function renderHostElement(request, task, keyPath, type, props) {
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    const children = props.children; // TODO: Make this a Config for replaying.
+
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+  } else {
+    // Render
+    const children = pushStartInstance(segment.chunks, type, props, request.resumableState, request.renderState, task.formatContext, segment.lastPushedText);
+    segment.lastPushedText = false;
+    const prevContext = task.formatContext;
+    const prevKeyPath = task.keyPath;
+    task.formatContext = getChildFormatContext(prevContext, type, props);
+    task.keyPath = keyPath; // We use the non-destructive form because if something suspends, we still
+    // need to pop back up and finish this subtree of HTML.
+
+    renderNode(request, task, children, -1); // We expect that errors will fatal the whole task and that we don't need
+    // the correct context. Therefore this is not in a finally.
+
+    task.formatContext = prevContext;
+    task.keyPath = prevKeyPath;
+    pushEndInstance(segment.chunks, type, props, request.resumableState, prevContext);
+    segment.lastPushedText = false;
+  }
+}
+
+function shouldConstruct(Component) {
+  return Component.prototype && Component.prototype.isReactComponent;
+}
+
+function renderWithHooks(request, task, keyPath, prevThenableState, Component, props, secondArg) {
+  const componentIdentity = {};
+  prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState);
+  const result = Component(props, secondArg);
+  return finishHooks(Component, props, result, secondArg);
+}
+
+function finishClassComponent(request, task, keyPath, instance, Component, props) {
+  const nextChildren = instance.render();
+
+  {
+    const childContextTypes = Component.childContextTypes;
+
+    if (childContextTypes !== null && childContextTypes !== undefined) {
+      const previousContext = task.legacyContext;
+      const mergedContext = processChildContext(instance, Component, previousContext, childContextTypes);
+      task.legacyContext = mergedContext;
+      renderNodeDestructive(request, task, null, nextChildren, -1);
+      task.legacyContext = previousContext;
+      return;
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, nextChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderClassComponent(request, task, keyPath, Component, props) {
+  const maskedContext = getMaskedContext(Component, task.legacyContext) ;
+  const instance = constructClassInstance(Component, props, maskedContext);
+  mountClassInstance(instance, Component, props, maskedContext);
+  finishClassComponent(request, task, keyPath, instance, Component);
+}
+// components for some reason.
+
+function renderIndeterminateComponent(request, task, keyPath, prevThenableState, Component, props) {
+  let legacyContext;
+
+  {
+    legacyContext = getMaskedContext(Component, task.legacyContext);
+  }
+
+  const value = renderWithHooks(request, task, keyPath, prevThenableState, Component, props, legacyContext);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+
+  if ( // Run these checks in production only if the flag is off.
+  // Eventually we'll delete this branch altogether.
+  typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) {
+
+    mountClassInstance(value, Component, props, legacyContext);
+    finishClassComponent(request, task, keyPath, value, Component);
+  } else {
+
+    finishFunctionComponent(request, task, keyPath, value, hasId, formStateCount, formStateMatchingIndex);
+  }
+}
+
+function finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex) {
+  let didEmitFormStateMarkers = false;
+
+  if (formStateCount !== 0 && request.formState !== null) {
+    // For each useFormState hook, emit a marker that indicates whether we
+    // rendered using the form state passed at the root. We only emit these
+    // markers if form state is passed at the root.
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      didEmitFormStateMarkers = true;
+      const target = segment.chunks;
+
+      for (let i = 0; i < formStateCount; i++) {
+        if (i === formStateMatchingIndex) {
+          pushFormStateMarkerIsMatching(target);
+        } else {
+          pushFormStateMarkerIsNotMatching(target);
+        }
+      }
+    }
+  }
+
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+
+  if (hasId) {
+    // This component materialized an id. We treat this as its own level, with
+    // a single "child" slot.
+    const prevTreeContext = task.treeContext;
+    const totalChildren = 1;
+    const index = 0; // Modify the id context. Because we'll need to reset this if something
+    // suspends or errors, we'll use the non-destructive render path.
+
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, index);
+    renderNode(request, task, children, -1); // Like the other contexts, this does not need to be in a finally block
+    // because renderNode takes care of unwinding the stack.
+
+    task.treeContext = prevTreeContext;
+  } else if (didEmitFormStateMarkers) {
+    // If there were formState hooks, we must use the non-destructive path
+    // because this component is not a pure indirection; we emitted markers
+    // to the stream.
+    renderNode(request, task, children, -1);
+  } else {
+    // We're now successfully past this task, and we haven't modified the
+    // context stack. We don't have to pop back to the previous task every
+    // again, so we can use the destructive recursive form.
+    renderNodeDestructive(request, task, null, children, -1);
+  }
+
+  task.keyPath = prevKeyPath;
+}
+
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    // Resolve default props. Taken from ReactElement
+    const props = assign({}, baseProps);
+    const defaultProps = Component.defaultProps;
+
+    for (const propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+
+    return props;
+  }
+
+  return baseProps;
+}
+
+function renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref) {
+  const children = renderWithHooks(request, task, keyPath, prevThenableState, type.render, props, ref);
+  const hasId = checkDidRenderIdHook();
+  const formStateCount = getFormStateCount();
+  const formStateMatchingIndex = getFormStateMatchingIndex();
+  finishFunctionComponent(request, task, keyPath, children, hasId, formStateCount, formStateMatchingIndex);
+}
+
+function renderMemo(request, task, keyPath, prevThenableState, type, props, ref) {
+  const innerType = type.type;
+  const resolvedProps = resolveDefaultProps(innerType, props);
+  renderElement(request, task, keyPath, prevThenableState, innerType, resolvedProps, ref);
+}
+
+function renderContextConsumer(request, task, keyPath, context, props) {
+
+  const render = props.children;
+
+  const newValue = readContext$1(context);
+  const newChildren = render(newValue);
+  const prevKeyPath = task.keyPath;
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, newChildren, -1);
+  task.keyPath = prevKeyPath;
+}
+
+function renderContextProvider(request, task, keyPath, type, props) {
+  const context = type._context;
+  const value = props.value;
+  const children = props.children;
+
+  const prevKeyPath = task.keyPath;
+  task.context = pushProvider(context, value);
+  task.keyPath = keyPath;
+  renderNodeDestructive(request, task, null, children, -1);
+  task.context = popProvider();
+  task.keyPath = prevKeyPath;
+}
+
+function renderLazyComponent(request, task, keyPath, prevThenableState, lazyComponent, props, ref) {
+  const payload = lazyComponent._payload;
+  const init = lazyComponent._init;
+  const Component = init(payload);
+  const resolvedProps = resolveDefaultProps(Component, props);
+  renderElement(request, task, keyPath, prevThenableState, Component, resolvedProps, ref);
+}
+
+function renderOffscreen(request, task, keyPath, props) {
+  const mode = props.mode;
+
+  if (mode === 'hidden') ; else {
+    // A visible Offscreen boundary is treated exactly like a fragment: a
+    // pure indirection.
+    const prevKeyPath = task.keyPath;
+    task.keyPath = keyPath;
+    renderNodeDestructive(request, task, null, props.children, -1);
+    task.keyPath = prevKeyPath;
+  }
+}
+
+function renderElement(request, task, keyPath, prevThenableState, type, props, ref) {
+  if (typeof type === 'function') {
+    if (shouldConstruct(type)) {
+      renderClassComponent(request, task, keyPath, type, props);
+      return;
+    } else {
+      renderIndeterminateComponent(request, task, keyPath, prevThenableState, type, props);
+      return;
+    }
+  }
+
+  if (typeof type === 'string') {
+    renderHostElement(request, task, keyPath, type, props);
+    return;
+  }
+
+  switch (type) {
+    // LegacyHidden acts the same as a fragment. This only works because we
+    // currently assume that every instance of LegacyHidden is accompanied by a
+    // host component wrapper. In the hidden mode, the host component is given a
+    // `hidden` attribute, which ensures that the initial HTML is not visible.
+    // To support the use of LegacyHidden as a true fragment, without an extra
+    // DOM node, we would have to hide the initial HTML in some other way.
+    // TODO: Delete in LegacyHidden. It's an unstable API only used in the
+    // www build. As a migration step, we could add a special prop to Offscreen
+    // that simulates the old behavior (no hiding, no change to effects).
+    case REACT_LEGACY_HIDDEN_TYPE:
+    case REACT_DEBUG_TRACING_MODE_TYPE:
+    case REACT_STRICT_MODE_TYPE:
+    case REACT_PROFILER_TYPE:
+    case REACT_FRAGMENT_TYPE:
+      {
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_OFFSCREEN_TYPE:
+      {
+        renderOffscreen(request, task, keyPath, props);
+        return;
+      }
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      {
+
+        const prevKeyPath = task.keyPath;
+        task.keyPath = keyPath;
+        renderNodeDestructive(request, task, null, props.children, -1);
+        task.keyPath = prevKeyPath;
+        return;
+      }
+
+    case REACT_SCOPE_TYPE:
+      {
+
+        throw new Error('ReactDOMServer does not yet support scope components.');
+      }
+
+    case REACT_SUSPENSE_TYPE:
+      {
+        {
+          renderSuspenseBoundary(request, task, keyPath, props);
+        }
+
+        return;
+      }
+  }
+
+  if (typeof type === 'object' && type !== null) {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        {
+          renderForwardRef(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          renderMemo(request, task, keyPath, prevThenableState, type, props, ref);
+          return;
+        }
+
+      case REACT_PROVIDER_TYPE:
+        {
+          renderContextProvider(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_CONTEXT_TYPE:
+        {
+          renderContextConsumer(request, task, keyPath, type, props);
+          return;
+        }
+
+      case REACT_LAZY_TYPE:
+        {
+          renderLazyComponent(request, task, keyPath, prevThenableState, type, props);
+          return;
+        }
+    }
+  }
+
+  let info = '';
+
+  throw new Error('Element type is invalid: expected a string (for built-in ' + 'components) or a class/function (for composite components) ' + ("but got: " + (type == null ? type : typeof type) + "." + info));
+}
+
+function resumeNode(request, task, segmentId, node, childIndex) {
+  const prevReplay = task.replay;
+  const blockedBoundary = task.blockedBoundary;
+  const resumedSegment = createPendingSegment(request, 0, null, task.formatContext, false, false);
+  resumedSegment.id = segmentId;
+  resumedSegment.parentFlushed = true;
+
+  try {
+    // Convert the current ReplayTask to a RenderTask.
+    const renderTask = task;
+    renderTask.replay = null;
+    renderTask.blockedSegment = resumedSegment;
+    renderNode(request, task, node, childIndex);
+    resumedSegment.status = COMPLETED;
+
+    if (blockedBoundary === null) {
+      request.completedRootSegment = resumedSegment;
+    } else {
+      queueCompletedSegment(blockedBoundary, resumedSegment);
+
+      if (blockedBoundary.parentFlushed) {
+        request.partialBoundaries.push(blockedBoundary);
+      }
+    }
+  } finally {
+    // Restore to a ReplayTask.
+    task.replay = prevReplay;
+    task.blockedSegment = null;
+  }
+}
+
+function replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, replay) {
+  // We're replaying. Find the path to follow.
+  const replayNodes = replay.nodes;
+
+  for (let i = 0; i < replayNodes.length; i++) {
+    // Flow doesn't support refinement on tuples so we do it manually here.
+    const node = replayNodes[i];
+
+    if (keyOrIndex !== node[1]) {
+      continue;
+    }
+
+    if (node.length === 4) {
+      // Matched a replayable path.
+      // Let's double check that the component name matches as a precaution.
+      if (name !== null && name !== node[0]) {
+        throw new Error('Expected the resume to render <' + node[0] + '> in this slot but instead it rendered <' + name + '>. ' + "The tree doesn't match so React will fallback to client rendering.");
+      }
+
+      const childNodes = node[2];
+      const childSlots = node[3];
+      const currentNode = task.node;
+      task.replay = {
+        nodes: childNodes,
+        slots: childSlots,
+        pendingTasks: 1
+      };
+
+      try {
+        renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+
+        if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0 // TODO check remaining slots
+        ) {
+            throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+          }
+
+        task.replay.pendingTasks--;
+      } catch (x) {
+        if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+          // Suspend
+          if (task.node === currentNode) {
+            // This same element suspended so we need to pop the replay we just added.
+            task.replay = replay;
+          }
+
+          throw x;
+        }
+
+        task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+        // during a replay. That's because this component didn't actually error
+        // in the original prerender. What's unable to complete is the child
+        // replay nodes which might be Suspense boundaries which are able to
+        // absorb the error and we can still continue with siblings.
+
+        erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+      }
+
+      task.replay = replay;
+    } else {
+      // Let's double check that the component type matches.
+      if (type !== REACT_SUSPENSE_TYPE) {
+        const expectedType = 'Suspense';
+        throw new Error('Expected the resume to render <' + expectedType + '> in this slot but instead it rendered <' + (getComponentNameFromType(type) || 'Unknown') + '>. ' + "The tree doesn't match so React will fallback to client rendering.");
+      } // Matched a replayable path.
+
+
+      replaySuspenseBoundary(request, task, keyPath, props, node[5], node[2], node[3], node[4] === null ? [] : node[4][2], node[4] === null ? null : node[4][3]);
+    } // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+
+    replayNodes.splice(i, 1);
+    return;
+  } // We didn't find any matching nodes. We assume that this element was already
+  // rendered in the prelude and skip it.
+
+} // $FlowFixMe[missing-local-annot]
+
+function renderNodeDestructive(request, task, // The thenable state reused from the previous attempt, if any. This is almost
+// always null, except when called by retryTask.
+prevThenableState, node, childIndex) {
+  {
+    return renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex);
+  }
+} // This function by it self renders a node and consumes the task by mutating it
+// to update the current execution state.
+
+
+function renderNodeDestructiveImpl(request, task, prevThenableState, node, childIndex) {
+  if (task.replay !== null && typeof task.replay.slots === 'number') {
+    // TODO: Figure out a cheaper place than this hot path to do this check.
+    const resumeSegmentID = task.replay.slots;
+    resumeNode(request, task, resumeSegmentID, node, childIndex);
+    return;
+  } // Stash the node we're working on. We'll pick up from this task in case
+  // something suspends.
+
+
+  task.node = node;
+  task.childIndex = childIndex; // Handle object types
+
+  if (typeof node === 'object' && node !== null) {
+    switch (node.$$typeof) {
+      case REACT_ELEMENT_TYPE:
+        {
+          const element = node;
+          const type = element.type;
+          const key = element.key;
+          const props = element.props;
+          const ref = element.ref;
+          const name = getComponentNameFromType(type);
+          const keyOrIndex = key == null ? childIndex === -1 ? 0 : childIndex : key;
+          const keyPath = [task.keyPath, name, keyOrIndex];
+
+          if (task.replay !== null) {
+            replayElement(request, task, keyPath, prevThenableState, name, keyOrIndex, childIndex, type, props, ref, task.replay); // No matches found for this node. We assume it's already emitted in the
+            // prelude and skip it during the replay.
+          } else {
+            // We're doing a plain render.
+            renderElement(request, task, keyPath, prevThenableState, type, props, ref);
+          }
+
+          return;
+        }
+
+      case REACT_PORTAL_TYPE:
+        throw new Error('Portals are not currently supported by the server renderer. ' + 'Render them conditionally so that they only appear on the client render.');
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyNode = node;
+          const payload = lazyNode._payload;
+          const init = lazyNode._init;
+          let resolvedNode;
+
+          {
+            resolvedNode = init(payload);
+          }
+
+          renderNodeDestructive(request, task, null, resolvedNode, childIndex);
+          return;
+        }
+    }
+
+    if (isArray(node)) {
+      renderChildrenArray(request, task, node, childIndex);
+      return;
+    }
+
+    const iteratorFn = getIteratorFn(node);
+
+    if (iteratorFn) {
+
+      const iterator = iteratorFn.call(node);
+
+      if (iterator) {
+        // We need to know how many total children are in this set, so that we
+        // can allocate enough id slots to acommodate them. So we must exhaust
+        // the iterator before we start recursively rendering the children.
+        // TODO: This is not great but I think it's inherent to the id
+        // generation algorithm.
+        let step = iterator.next(); // If there are not entries, we need to push an empty so we start by checking that.
+
+        if (!step.done) {
+          const children = [];
+
+          do {
+            children.push(step.value);
+            step = iterator.next();
+          } while (!step.done);
+
+          renderChildrenArray(request, task, children, childIndex);
+          return;
+        }
+
+        return;
+      }
+    } // Usables are a valid React node type. When React encounters a Usable in
+    // a child position, it unwraps it using the same algorithm as `use`. For
+    // example, for promises, React will throw an exception to unwind the
+    // stack, then replay the component once the promise resolves.
+    //
+    // A difference from `use` is that React will keep unwrapping the value
+    // until it reaches a non-Usable type.
+    //
+    // e.g. Usable<Usable<Usable<T>>> should resolve to T
+
+
+    const maybeUsable = node;
+
+    if (typeof maybeUsable.then === 'function') {
+      const thenable = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, unwrapThenable(thenable), childIndex);
+    }
+
+    if (maybeUsable.$$typeof === REACT_CONTEXT_TYPE || maybeUsable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = maybeUsable;
+      return renderNodeDestructiveImpl(request, task, null, readContext$1(context), childIndex);
+    } // $FlowFixMe[method-unbinding]
+
+
+    const childString = Object.prototype.toString.call(node);
+    throw new Error("Objects are not valid as a React child (found: " + (childString === '[object Object]' ? 'object with keys {' + Object.keys(node).join(', ') + '}' : childString) + "). " + 'If you meant to render a collection of children, use an array ' + 'instead.');
+  }
+
+  if (typeof node === 'string') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+
+  if (typeof node === 'number') {
+    const segment = task.blockedSegment;
+
+    if (segment === null) ; else {
+      segment.lastPushedText = pushTextInstance(segment.chunks, '' + node, request.renderState, segment.lastPushedText);
+    }
+
+    return;
+  }
+}
+
+function replayFragment(request, task, children, childIndex) {
+  // If we're supposed follow this array, we'd expect to see a ReplayNode matching
+  // this fragment.
+  const replay = task.replay;
+  const replayNodes = replay.nodes;
+
+  for (let j = 0; j < replayNodes.length; j++) {
+    const node = replayNodes[j];
+
+    if (node[1] !== childIndex) {
+      continue;
+    } // Matched a replayable path.
+
+
+    const childNodes = node[2];
+    const childSlots = node[3];
+    task.replay = {
+      nodes: childNodes,
+      slots: childSlots,
+      pendingTasks: 1
+    };
+
+    try {
+      renderChildrenArray(request, task, children, -1);
+
+      if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+        throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+      }
+
+      task.replay.pendingTasks--;
+    } catch (x) {
+      if (typeof x === 'object' && x !== null && (x === SuspenseException || typeof x.then === 'function')) {
+        // Suspend
+        throw x;
+      }
+
+      task.replay.pendingTasks--; // Unlike regular render, we don't terminate the siblings if we error
+      // during a replay. That's because this component didn't actually error
+      // in the original prerender. What's unable to complete is the child
+      // replay nodes which might be Suspense boundaries which are able to
+      // absorb the error and we can still continue with siblings.
+      // This is an error, stash the component stack if it is null.
+
+      erroredReplay(request, task.blockedBoundary, x, childNodes, childSlots);
+    }
+
+    task.replay = replay; // We finished rendering this node, so now we can consume this
+    // slot. This must happen after in case we rerender this task.
+
+    replayNodes.splice(j, 1);
+    break;
+  }
+}
+
+function renderChildrenArray(request, task, children, childIndex) {
+  const prevKeyPath = task.keyPath;
+
+  if (childIndex !== -1) {
+    task.keyPath = [task.keyPath, 'Fragment', childIndex];
+
+    if (task.replay !== null) {
+      replayFragment(request, // $FlowFixMe: Refined.
+      task, children, childIndex);
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  const prevTreeContext = task.treeContext;
+  const totalChildren = children.length;
+
+  if (task.replay !== null) {
+    // Replay
+    // First we need to check if we have any resume slots at this level.
+    const resumeSlots = task.replay.slots;
+
+    if (resumeSlots !== null && typeof resumeSlots === 'object') {
+      for (let i = 0; i < totalChildren; i++) {
+        const node = children[i];
+        task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+        // up and render the sibling if something suspends.
+
+        const resumeSegmentID = resumeSlots[i]; // TODO: If this errors we should still continue with the next sibling.
+
+        if (typeof resumeSegmentID === 'number') {
+          resumeNode(request, task, resumeSegmentID, node, i); // We finished rendering this node, so now we can consume this
+          // slot. This must happen after in case we rerender this task.
+
+          delete resumeSlots[i];
+        } else {
+          renderNode(request, task, node, i);
+        }
+      }
+
+      task.treeContext = prevTreeContext;
+      task.keyPath = prevKeyPath;
+      return;
+    }
+  }
+
+  for (let i = 0; i < totalChildren; i++) {
+    const node = children[i];
+    task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i); // We need to use the non-destructive form so that we can safely pop back
+    // up and render the sibling if something suspends.
+
+    renderNode(request, task, node, i);
+  } // Because this context is always set right before rendering every child, we
+  // only need to reset it to the previous value at the very end.
+
+
+  task.treeContext = prevTreeContext;
+  task.keyPath = prevKeyPath;
+}
+
+function spawnNewSuspendedReplayTask(request, task, thenableState, x) {
+  const newTask = createReplayTask(request, thenableState, task.replay, task.node, task.childIndex, task.blockedBoundary, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+}
+
+function spawnNewSuspendedRenderTask(request, task, thenableState, x) {
+  // Something suspended, we'll need to create a new segment and resolve it later.
+  const segment = task.blockedSegment;
+  const insertionIndex = segment.chunks.length;
+  const newSegment = createPendingSegment(request, insertionIndex, null, task.formatContext, // Adopt the parent segment's leading text embed
+  segment.lastPushedText, // Assume we are text embedded at the trailing edge
+  true);
+  segment.children.push(newSegment); // Reset lastPushedText for current Segment since the new Segment "consumed" it
+
+  segment.lastPushedText = false;
+  const newTask = createRenderTask(request, thenableState, task.node, task.childIndex, task.blockedBoundary, newSegment, task.abortSet, task.keyPath, task.formatContext, task.legacyContext, task.context, task.treeContext);
+
+  const ping = newTask.ping;
+  x.then(ping, ping);
+} // This is a non-destructive form of rendering a node. If it suspends it spawns
+// a new task and restores the context of this task to what it was before.
+
+
+function renderNode(request, task, node, childIndex) {
+  // Snapshot the current context in case something throws to interrupt the
+  // process.
+  const previousFormatContext = task.formatContext;
+  const previousLegacyContext = task.legacyContext;
+  const previousContext = task.context;
+  const previousKeyPath = task.keyPath;
+  const previousTreeContext = task.treeContext;
+
+  let x; // Store how much we've pushed at this point so we can reset it in case something
+  // suspended partially through writing something.
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    // Replay
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState();
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedReplayTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+      } // TODO: Abort any undiscovered Suspense boundaries in the ReplayNode.
+
+    }
+  } else {
+    // Render
+    const childrenLength = segment.children.length;
+    const chunkLength = segment.chunks.length;
+
+    try {
+      return renderNodeDestructive(request, task, null, node, childIndex);
+    } catch (thrownValue) {
+      resetHooksState(); // Reset the write pointers to where we started.
+
+      segment.children.length = childrenLength;
+      segment.chunks.length = chunkLength;
+      x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          const wakeable = x;
+          const thenableState = getThenableStateAfterSuspending();
+          spawnNewSuspendedRenderTask(request, // $FlowFixMe: Refined.
+          task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
+          // functions in case nothing throws so we don't use "finally" here.
+
+          task.formatContext = previousFormatContext;
+          task.legacyContext = previousLegacyContext;
+          task.context = previousContext;
+          task.keyPath = previousKeyPath;
+          task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+          switchContext(previousContext);
+
+          return;
+        }
+      }
+    }
+  } // Restore the context. We assume that this will be restored by the inner
+  // functions in case nothing throws so we don't use "finally" here.
+
+
+  task.formatContext = previousFormatContext;
+  task.legacyContext = previousLegacyContext;
+  task.context = previousContext;
+  task.keyPath = previousKeyPath;
+  task.treeContext = previousTreeContext; // Restore all active ReactContexts to what they were before.
+
+  switchContext(previousContext);
+  // Let's terminate the rest of the tree and don't render any siblings.
+
+
+  throw x;
+}
+
+function erroredReplay(request, boundary, error, replayNodes, resumeSlots) {
+  // Erroring during a replay doesn't actually cause an error by itself because
+  // that component has already rendered. What causes the error is the resumable
+  // points that we did not yet finish which will be below the point of the reset.
+  // For example, if we're replaying a path to a Suspense boundary that is not done
+  // that doesn't error the parent Suspense boundary.
+  // This might be a bit strange that the error in a parent gets thrown at a child.
+  // We log it only once and reuse the digest.
+  let errorDigest;
+
+  {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  abortRemainingReplayNodes(request, boundary, replayNodes, resumeSlots, error, errorDigest);
+}
+
+function erroredTask(request, boundary, error) {
+  // Report the error to a global handler.
+  let errorDigest;
+
+  {
+    errorDigest = logRecoverableError(request, error);
+  }
+
+  if (boundary === null) {
+    fatalError(request, error);
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+      // so we can flush it, if the parent already flushed.
+
+
+      if (boundary.parentFlushed) {
+        // We don't have a preference where in the queue this goes since it's likely
+        // to error on the client anyway. However, intentionally client-rendered
+        // boundaries should be flushed earlier so that they can start on the client.
+        // We reuse the same queue for errors.
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function abortTaskSoft(task) {
+  // This aborts task without aborting the parent boundary that it blocks.
+  // It's used for when we didn't need this task to complete the tree.
+  // If task was needed, then it should use abortTask instead.
+  const request = this;
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+    finishedTask(request, boundary, segment);
+  }
+}
+
+function abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest) {
+  const resumedBoundary = createSuspenseBoundary(request, new Set());
+  resumedBoundary.parentFlushed = true; // We restore the same id of this boundary as was used during prerender.
+
+  resumedBoundary.rootSegmentID = rootSegmentID;
+  resumedBoundary.status = CLIENT_RENDERED;
+  resumedBoundary.errorDigest = errorDigest;
+
+  if (resumedBoundary.parentFlushed) {
+    request.clientRenderedBoundaries.push(resumedBoundary);
+  }
+}
+
+function abortRemainingReplayNodes(request, boundary, nodes, slots, error, errorDigest) {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+
+    if (node.length === 4) {
+      abortRemainingReplayNodes(request, boundary, node[2], node[3], error, errorDigest);
+    } else {
+      const boundaryNode = node;
+      const rootSegmentID = boundaryNode[5];
+      abortRemainingSuspenseBoundary(request, rootSegmentID, error, errorDigest);
+    }
+  } // Empty the set, since we've cleared it now.
+
+
+  nodes.length = 0;
+
+  if (slots !== null) {
+    // We had something still to resume in the parent boundary. We must trigger
+    // the error on the parent boundary since it's not able to complete.
+    if (boundary === null) {
+      throw new Error('We should not have any resumable nodes in the shell. ' + 'This is a bug in React.');
+    } else if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = errorDigest;
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // Empty the set
+
+
+    if (typeof slots === 'object') {
+      for (const index in slots) {
+        delete slots[index];
+      }
+    }
+  }
+}
+
+function abortTask(task, request, error) {
+  // This aborts the task and aborts the parent that it blocks, putting it into
+  // client rendered mode.
+  const boundary = task.blockedBoundary;
+  const segment = task.blockedSegment;
+
+  if (segment !== null) {
+    segment.status = ABORTED;
+  }
+
+  if (boundary === null) {
+    if (request.status !== CLOSING && request.status !== CLOSED) {
+      const replay = task.replay;
+
+      if (replay === null) {
+        // We didn't complete the root so we have nothing to show. We can close
+        // the request;
+        logRecoverableError(request, error);
+        fatalError(request, error);
+        return;
+      } else {
+        // If the shell aborts during a replay, that's not a fatal error. Instead
+        // we should be able to recover by client rendering all the root boundaries in
+        // the ReplaySet.
+        replay.pendingTasks--;
+
+        if (replay.pendingTasks === 0 && replay.nodes.length > 0) {
+          const errorDigest = logRecoverableError(request, error);
+          abortRemainingReplayNodes(request, null, replay.nodes, replay.slots, error, errorDigest);
+        }
+
+        request.pendingRootTasks--;
+
+        if (request.pendingRootTasks === 0) {
+          completeShell(request);
+        }
+      }
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status !== CLIENT_RENDERED) {
+      boundary.status = CLIENT_RENDERED;
+      boundary.errorDigest = logRecoverableError(request, error);
+
+      if (boundary.parentFlushed) {
+        request.clientRenderedBoundaries.push(boundary);
+      }
+    } // If this boundary was still pending then we haven't already cancelled its fallbacks.
+    // We'll need to abort the fallbacks, which will also error that parent boundary.
+
+
+    boundary.fallbackAbortableTasks.forEach(fallbackTask => abortTask(fallbackTask, request, error));
+    boundary.fallbackAbortableTasks.clear();
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeShell(request) {
+  if (request.trackedPostpones === null) {
+    // We only emit early preloads on shell completion for renders. For prerenders
+    // we wait for the entire Request to finish because we are not responding to a
+    // live request and can wait for as much data as possible.
+    // we should only be calling completeShell when the shell is complete so we
+    // just use a literal here
+    const shellComplete = true;
+    emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  } // We have completed the shell so the shell can't error anymore.
+
+
+  request.onShellError = noop;
+  const onShellReady = request.onShellReady;
+  onShellReady();
+} // I extracted this function out because we want to ensure we consistently emit preloads before
+// transitioning to the next request stage and this transition can happen in multiple places in this
+// implementation.
+
+
+function completeAll(request) {
+  // During a render the shell must be complete if the entire request is finished
+  // however during a Prerender it is possible that the shell is incomplete because
+  // it postponed. We cannot use rootPendingTasks in the prerender case because
+  // those hit zero even when the shell postpones. Instead we look at the completedRootSegment
+  const shellComplete = request.trackedPostpones === null ? // Render, we assume it is completed
+  true : // Prerender Request, we use the state of the root segment
+  request.completedRootSegment === null || request.completedRootSegment.status !== POSTPONED;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+  const onAllReady = request.onAllReady;
+  onAllReady();
+}
+
+function queueCompletedSegment(boundary, segment) {
+  if (segment.chunks.length === 0 && segment.children.length === 1 && segment.children[0].boundary === null) {
+    // This is an empty segment. There's nothing to write, so we can instead transfer the ID
+    // to the child. That way any existing references point to the child.
+    const childSegment = segment.children[0];
+    childSegment.id = segment.id;
+    childSegment.parentFlushed = true;
+
+    if (childSegment.status === COMPLETED) {
+      queueCompletedSegment(boundary, childSegment);
+    }
+  } else {
+    const completedSegments = boundary.completedSegments;
+    completedSegments.push(segment);
+  }
+}
+
+function finishedTask(request, boundary, segment) {
+  if (boundary === null) {
+    if (segment !== null && segment.parentFlushed) {
+      if (request.completedRootSegment !== null) {
+        throw new Error('There can only be one root segment. This is a bug in React.');
+      }
+
+      request.completedRootSegment = segment;
+    }
+
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+  } else {
+    boundary.pendingTasks--;
+
+    if (boundary.status === CLIENT_RENDERED) ; else if (boundary.pendingTasks === 0) {
+      if (boundary.status === PENDING) {
+        boundary.status = COMPLETED;
+      } // This must have been the last segment we were waiting on. This boundary is now complete.
+
+
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent segment already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+        }
+      }
+
+      if (boundary.parentFlushed) {
+        // The segment might be part of a segment that didn't flush yet, but if the boundary's
+        // parent flushed, we need to schedule the boundary to be emitted.
+        request.completedBoundaries.push(boundary);
+      } // We can now cancel any pending task on the fallback since we won't need to show it anymore.
+      // This needs to happen after we read the parentFlushed flags because aborting can finish
+      // work which can trigger user code, which can start flushing, which can change those flags.
+      // If the boundary was POSTPONED, we still need to finish the fallback first.
+
+
+      if (boundary.status === COMPLETED) {
+        boundary.fallbackAbortableTasks.forEach(abortTaskSoft, request);
+        boundary.fallbackAbortableTasks.clear();
+      }
+    } else {
+      if (segment !== null && segment.parentFlushed) {
+        // Our parent already flushed, so we need to schedule this segment to be emitted.
+        // If it is a segment that was aborted, we'll write other content instead so we don't need
+        // to emit it.
+        if (segment.status === COMPLETED) {
+          queueCompletedSegment(boundary, segment);
+          const completedSegments = boundary.completedSegments;
+
+          if (completedSegments.length === 1) {
+            // This is the first time since we last flushed that we completed anything.
+            // We can schedule this boundary to emit its partially completed segments early
+            // in case the parent has already been flushed.
+            if (boundary.parentFlushed) {
+              request.partialBoundaries.push(boundary);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  request.allPendingTasks--;
+
+  if (request.allPendingTasks === 0) {
+    completeAll(request);
+  }
+}
+
+function retryTask(request, task) {
+  {
+    const blockedBoundary = task.blockedBoundary;
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, blockedBoundary ? blockedBoundary.resources : null);
+  }
+
+  const segment = task.blockedSegment;
+
+  if (segment === null) {
+    retryReplayTask(request, // $FlowFixMe: Refined.
+    task);
+  } else {
+    retryRenderTask(request, // $FlowFixMe: Refined.
+    task, segment);
+  }
+}
+
+function retryRenderTask(request, task, segment) {
+  if (segment.status !== PENDING) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  const childrenLength = segment.children.length;
+  const chunkLength = segment.chunks.length;
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+    pushSegmentFinale(segment.chunks, request.renderState, segment.lastPushedText, segment.textEmbedded);
+    task.abortSet.delete(task);
+    segment.status = COMPLETED;
+    finishedTask(request, task.blockedBoundary, segment);
+  } catch (thrownValue) {
+    resetHooksState(); // Reset the write pointers to where we started.
+
+    segment.children.length = childrenLength;
+    segment.chunks.length = chunkLength;
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    task.abortSet.delete(task);
+    segment.status = ERRORED;
+    erroredTask(request, task.blockedBoundary, x);
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function retryReplayTask(request, task) {
+  if (task.replay.pendingTasks === 0) {
+    // There are no pending tasks working on this set, so we must have aborted.
+    return;
+  } // We restore the context to what it was when we suspended.
+  // We don't restore it after we leave because it's likely that we'll end up
+  // needing a very similar context soon again.
+
+
+  switchContext(task.context);
+
+  try {
+    // We call the destructive form that mutates this task. That way if something
+    // suspends again, we can reuse the same task instead of spawning a new one.
+    // Reset the task's thenable state before continuing, so that if a later
+    // component suspends we can reuse the same task object. If the same
+    // component suspends again, the thenable state will be restored.
+    const prevThenableState = task.thenableState;
+    task.thenableState = null;
+    renderNodeDestructive(request, task, prevThenableState, task.node, task.childIndex);
+
+    if (task.replay.pendingTasks === 1 && task.replay.nodes.length > 0) {
+      throw new Error("Couldn't find all resumable slots by key/index during replaying. " + "The tree doesn't match so React will fallback to client rendering.");
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    finishedTask(request, task.blockedBoundary, null);
+  } catch (thrownValue) {
+    resetHooksState();
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    task.replay.pendingTasks--;
+    task.abortSet.delete(task);
+    erroredReplay(request, task.blockedBoundary, x, task.replay.nodes, task.replay.slots);
+    request.pendingRootTasks--;
+
+    if (request.pendingRootTasks === 0) {
+      completeShell(request);
+    }
+
+    request.allPendingTasks--;
+
+    if (request.allPendingTasks === 0) {
+      completeAll(request);
+    }
+
+    return;
+  } finally {
+    {
+      setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, null);
+    }
+  }
+}
+
+function performWork(request) {
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  const prevContext = getActiveContext();
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  let prevCacheDispatcher;
+
+  {
+    prevCacheDispatcher = ReactCurrentCache.current;
+    ReactCurrentCache.current = DefaultCacheDispatcher;
+  }
+
+  const prevRequest = currentRequest;
+  currentRequest = request;
+
+  const prevResumableState = currentResumableState;
+  setCurrentResumableState(request.resumableState);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    let i;
+
+    for (i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    pingedTasks.splice(0, i);
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    setCurrentResumableState(prevResumableState);
+    ReactCurrentDispatcher.current = prevDispatcher;
+
+    {
+      ReactCurrentCache.current = prevCacheDispatcher;
+    }
+
+    if (prevDispatcher === HooksDispatcher) {
+      // This means that we were in a reentrant work loop. This could happen
+      // in a renderer that supports synchronous work like renderToString,
+      // when it's called from within another renderer.
+      // Normally we don't bother switching the contexts to their root/default
+      // values when leaving because we'll likely need the same or similar
+      // context again. However, when we're inside a synchronous loop like this
+      // we'll to restore the context to what it was before returning.
+      switchContext(prevContext);
+    }
+
+    currentRequest = prevRequest;
+  }
+}
+
+function flushSubtree(request, destination, segment) {
+  segment.parentFlushed = true;
+
+  switch (segment.status) {
+    case PENDING:
+      {
+        // We're emitting a placeholder for this segment to be filled in later.
+        // Therefore we'll need to assign it an ID - to refer to it by.
+        segment.id = request.nextSegmentId++; // Fallthrough
+      }
+
+    case POSTPONED:
+      {
+        const segmentID = segment.id; // When this segment finally completes it won't be embedded in text since it will flush separately
+
+        segment.lastPushedText = false;
+        segment.textEmbedded = false;
+        return writePlaceholder(destination, request.renderState, segmentID);
+      }
+
+    case COMPLETED:
+      {
+        segment.status = FLUSHED;
+        let r = true;
+        const chunks = segment.chunks;
+        let chunkIdx = 0;
+        const children = segment.children;
+
+        for (let childIdx = 0; childIdx < children.length; childIdx++) {
+          const nextChild = children[childIdx]; // Write all the chunks up until the next child.
+
+          for (; chunkIdx < nextChild.index; chunkIdx++) {
+            writeChunk(destination, chunks[chunkIdx]);
+          }
+
+          r = flushSegment(request, destination, nextChild);
+        } // Finally just write all the remaining chunks
+
+
+        for (; chunkIdx < chunks.length - 1; chunkIdx++) {
+          writeChunk(destination, chunks[chunkIdx]);
+        }
+
+        if (chunkIdx < chunks.length) {
+          r = writeChunkAndReturn(destination, chunks[chunkIdx]);
+        }
+
+        return r;
+      }
+
+    default:
+      {
+        throw new Error('Aborted, errored or already flushed boundaries should not be flushed again. This is a bug in React.');
+      }
+  }
+}
+
+function flushSegment(request, destination, segment) {
+  const boundary = segment.boundary;
+
+  if (boundary === null) {
+    // Not a suspense boundary.
+    return flushSubtree(request, destination, segment);
+  }
+
+  boundary.parentFlushed = true; // This segment is a Suspense boundary. We need to decide whether to
+  // emit the content or the fallback now.
+
+  if (boundary.status === CLIENT_RENDERED) {
+    // Emit a client rendered suspense boundary wrapper.
+    // We never queue the inner boundary so we'll never emit its content or partial segments.
+    writeStartClientRenderedSuspenseBoundary(destination, request.renderState, boundary.errorDigest); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndClientRenderedSuspenseBoundary(destination);
+  } else if (boundary.status !== COMPLETED) {
+    if (boundary.status === PENDING) {
+      // For pending boundaries we lazily assign an ID to the boundary
+      // and root segment.
+      boundary.rootSegmentID = request.nextSegmentId++;
+    }
+
+    if (boundary.completedSegments.length > 0) {
+      // If this is at least partially complete, we can queue it to be partially emitted early.
+      request.partialBoundaries.push(boundary);
+    } // This boundary is still loading. Emit a pending suspense boundary wrapper.
+
+
+    const id = boundary.rootSegmentID;
+    writeStartPendingSuspenseBoundary(destination, request.renderState, id); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else if (boundary.byteSize > request.progressiveChunkSize) {
+    // This boundary is large and will be emitted separately so that we can progressively show
+    // other content. We add it to the queue during the flush because we have to ensure that
+    // the parent flushes first so that there's something to inject it into.
+    // We also have to make sure that it's emitted into the queue in a deterministic slot.
+    // I.e. we can't insert it here when it completes.
+    // Assign an ID to refer to the future content by.
+    boundary.rootSegmentID = request.nextSegmentId++;
+    request.completedBoundaries.push(boundary); // Emit a pending rendered suspense boundary wrapper.
+
+    writeStartPendingSuspenseBoundary(destination, request.renderState, boundary.rootSegmentID); // Flush the fallback.
+
+    flushSubtree(request, destination, segment);
+    return writeEndPendingSuspenseBoundary(destination);
+  } else {
+    {
+      hoistResources(request.renderState, boundary.resources);
+    } // We can inline this boundary's content as a complete boundary.
+
+
+    writeStartCompletedSuspenseBoundary(destination);
+    const completedSegments = boundary.completedSegments;
+
+    if (completedSegments.length !== 1) {
+      throw new Error('A previously unvisited boundary must have exactly one root segment. This is a bug in React.');
+    }
+
+    const contentSegment = completedSegments[0];
+    flushSegment(request, destination, contentSegment);
+    return writeEndCompletedSuspenseBoundary(destination);
+  }
+}
+
+function flushClientRenderedBoundary(request, destination, boundary) {
+  return writeClientRenderBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.errorDigest, boundary.errorMessage, boundary.errorComponentStack);
+}
+
+function flushSegmentContainer(request, destination, segment) {
+  writeStartSegment(destination, request.renderState, segment.parentFormatContext, segment.id);
+  flushSegment(request, destination, segment);
+  return writeEndSegment(destination, segment.parentFormatContext);
+}
+
+function flushCompletedBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+    flushPartiallyCompletedSegment(request, destination, boundary, segment);
+  }
+
+  completedSegments.length = 0;
+
+  {
+    writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+
+  return writeCompletedBoundaryInstruction(destination, request.resumableState, request.renderState, boundary.rootSegmentID, boundary.resources);
+}
+
+function flushPartialBoundary(request, destination, boundary) {
+  {
+    setCurrentlyRenderingBoundaryResourcesTarget(request.renderState, boundary.resources);
+  }
+
+  const completedSegments = boundary.completedSegments;
+  let i = 0;
+
+  for (; i < completedSegments.length; i++) {
+    const segment = completedSegments[i];
+
+    if (!flushPartiallyCompletedSegment(request, destination, boundary, segment)) {
+      i++;
+      completedSegments.splice(0, i); // Only write as much as the buffer wants. Something higher priority
+      // might want to write later.
+
+      return false;
+    }
+  }
+
+  completedSegments.splice(0, i);
+
+  {
+    // The way this is structured we only write resources for partial boundaries
+    // if there is no backpressure. Later before we complete the boundary we
+    // will write resources regardless of backpressure before we emit the
+    // completion instruction
+    return writeResourcesForBoundary(destination, boundary.resources, request.renderState);
+  }
+}
+
+function flushPartiallyCompletedSegment(request, destination, boundary, segment) {
+  if (segment.status === FLUSHED) {
+    // We've already flushed this inline.
+    return true;
+  }
+
+  const segmentID = segment.id;
+
+  if (segmentID === -1) {
+    // This segment wasn't previously referred to. This happens at the root of
+    // a boundary. We make kind of a leap here and assume this is the root.
+    const rootSegmentID = segment.id = boundary.rootSegmentID;
+
+    if (rootSegmentID === -1) {
+      throw new Error('A root segment ID must have been assigned by now. This is a bug in React.');
+    }
+
+    return flushSegmentContainer(request, destination, segment);
+  } else if (segmentID === boundary.rootSegmentID) {
+    // When we emit postponed boundaries, we might have assigned the ID already
+    // but it's still the root segment so we can't inject it into the parent yet.
+    return flushSegmentContainer(request, destination, segment);
+  } else {
+    flushSegmentContainer(request, destination, segment);
+    return writeCompletedSegmentInstruction(destination, request.resumableState, request.renderState, segmentID);
+  }
+}
+
+function flushCompletedQueues(request, destination) {
+  beginWriting();
+
+  try {
+    // The structure of this is to go through each queue one by one and write
+    // until the sink tells us to stop. When we should stop, we still finish writing
+    // that item fully and then yield. At that point we remove the already completed
+    // items up until the point we completed them.
+    let i;
+    const completedRootSegment = request.completedRootSegment;
+
+    if (completedRootSegment !== null) {
+      if (completedRootSegment.status === POSTPONED) {
+        // We postponed the root, so we write nothing.
+        return;
+      } else if (request.pendingRootTasks === 0) {
+        if (enableFloat) {
+          writePreamble(destination, request.resumableState, request.renderState, request.allPendingTasks === 0 && request.trackedPostpones === null);
+        }
+
+        flushSegment(request, destination, completedRootSegment);
+        request.completedRootSegment = null;
+        writeCompletedRoot(destination, request.renderState, request.resumableState);
+      } else {
+        // We haven't flushed the root yet so we don't need to check any other branches further down
+        return;
+      }
+    }
+
+    if (enableFloat) {
+      writeHoistables(destination, request.resumableState, request.renderState);
+    } // We emit client rendering instructions for already emitted boundaries first.
+    // This is so that we can signal to the client to start client rendering them as
+    // soon as possible.
+
+
+    const clientRenderedBoundaries = request.clientRenderedBoundaries;
+
+    for (i = 0; i < clientRenderedBoundaries.length; i++) {
+      const boundary = clientRenderedBoundaries[i];
+
+      if (!flushClientRenderedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        clientRenderedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    clientRenderedBoundaries.splice(0, i); // Next we emit any complete boundaries. It's better to favor boundaries
+    // that are completely done since we can actually show them, than it is to emit
+    // any individual segments from a partially complete boundary.
+
+    const completedBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < completedBoundaries.length; i++) {
+      const boundary = completedBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        completedBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    completedBoundaries.splice(0, i); // Allow anything written so far to flush to the underlying sink before
+    // we continue with lower priorities.
+
+    completeWriting(destination);
+    beginWriting(destination); // TODO: Here we'll emit data used by hydration.
+    // Next we emit any segments of any boundaries that are partially complete
+    // but not deeply complete.
+
+    const partialBoundaries = request.partialBoundaries;
+
+    for (i = 0; i < partialBoundaries.length; i++) {
+      const boundary = partialBoundaries[i];
+
+      if (!flushPartialBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        partialBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    partialBoundaries.splice(0, i); // Next we check the completed boundaries again. This may have had
+    // boundaries added to it in case they were too larged to be inlined.
+    // New ones might be added in this loop.
+
+    const largeBoundaries = request.completedBoundaries;
+
+    for (i = 0; i < largeBoundaries.length; i++) {
+      const boundary = largeBoundaries[i];
+
+      if (!flushCompletedBoundary(request, destination, boundary)) {
+        request.destination = null;
+        i++;
+        largeBoundaries.splice(0, i);
+        return;
+      }
+    }
+
+    largeBoundaries.splice(0, i);
+  } finally {
+    if (request.allPendingTasks === 0 && request.pingedTasks.length === 0 && request.clientRenderedBoundaries.length === 0 && request.completedBoundaries.length === 0 // We don't need to check any partially completed segments because
+    // either they have pending task or they're complete.
+    ) {
+        request.flushScheduled = false;
+
+        {
+          // We write the trailing tags but only if don't have any data to resume.
+          // If we need to resume we'll write the postamble in the resume instead.
+          {
+            writePostamble(destination, request.resumableState);
+          }
+        }
+
+        completeWriting(destination);
+        flushBuffered(destination);
+
+
+        close(destination); // We need to stop flowing now because we do not want any async contexts which might call
+        // float methods to initiate any flushes after this point
+
+        stopFlowing(request);
+      } else {
+      completeWriting(destination);
+      flushBuffered(destination);
+    }
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  {
+    scheduleWork(() => requestStorage.run(request, performWork, request));
+  }
+
+  if (request.trackedPostpones === null) {
+    // this is either a regular render or a resume. For regular render we want
+    // to call emitEarlyPreloads after the first performWork because we want
+    // are responding to a live request and need to balance sending something early
+    // (i.e. don't want for the shell to finish) but we need something to send.
+    // The only implementation of this is for DOM at the moment and during resumes nothing
+    // actually emits but the code paths here are the same.
+    // During a prerender we don't want to be too aggressive in emitting early preloads
+    // because we aren't responding to a live request and we can wait for the prerender to
+    // postpone before we emit anything.
+    {
+      scheduleWork(() => requestStorage.run(request, enqueueEarlyPreloadsAfterInitialWork, request));
+    }
+  }
+}
+
+function enqueueEarlyPreloadsAfterInitialWork(request) {
+  const shellComplete = request.pendingRootTasks === 0;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    request.flushScheduled = true;
+    scheduleWork(() => {
+      // We need to existence check destination again here because it might go away
+      // in between the enqueueFlush call and the work execution
+      const destination = request.destination;
+
+      if (destination) {
+        flushCompletedQueues(request, destination);
+      } else {
+        request.flushScheduled = false;
+      }
+    });
+  }
+} // This function is intented to only be called during the pipe function for the Node builds.
+// The reason we need this is because `renderToPipeableStream` is the only API which allows
+// you to start flowing before the shell is complete and we've had a chance to emit early
+// preloads already. This is really just defensive programming to ensure that we give hosts an
+// opportunity to flush early preloads before streaming begins in case they are in an environment
+// that only supports a single call to emitEarlyPreloads like the DOM renderers. It's unfortunate
+// to put this Node only function directly in ReactFizzServer but it'd be more ackward to factor it
+// by moving the implementation into ReactServerStreamConfigNode and even then we may not be able to
+// eliminate all the wasted branching.
+
+
+function prepareForStartFlowingIfBeforeAllReady(request) {
+  const shellComplete = request.trackedPostpones === null ? // Render Request, we define shell complete by the pending root tasks
+  request.pendingRootTasks === 0 : // Prerender Request, we define shell complete by completedRootSegemtn
+  request.completedRootSegment === null ? request.pendingRootTasks === 0 : request.completedRootSegment.status !== POSTPONED;
+  emitEarlyPreloads(request.renderState, request.resumableState, shellComplete);
+}
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedQueues(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function stopFlowing(request) {
+  request.destination = null;
+} // This is called to early terminate a request. It puts all pending boundaries in client rendered state.
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+      abortableTasks.forEach(task => abortTask(task, request, error));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedQueues(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function flushResources(request) {
+  enqueueFlush(request);
+}
+function getFormState(request) {
+  return request.formState;
+}
+function getResumableState(request) {
+  return request.resumableState;
+}
+function getRenderState(request) {
+  return request.renderState;
+}
+
+function createDrainHandler(destination, request) {
+  return () => startFlowing(request, destination);
+}
+
+function createCancelHandler(request, reason) {
+  return () => {
+    stopFlowing(request); // eslint-disable-next-line react-internal/prod-error-codes
+
+    abort(request, new Error(reason));
+  };
+}
+
+function createRequestImpl(children, options) {
+  const resumableState = createResumableState(options ? options.identifierPrefix : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined);
+  return createRequest(children, resumableState, createRenderState(resumableState, options ? options.nonce : undefined, options ? options.unstable_externalRuntimeSrc : undefined, options ? options.importMap : undefined, options ? options.onHeaders : undefined, options ? options.maxHeadersLength : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, options ? options.onAllReady : undefined, options ? options.onShellReady : undefined, options ? options.onShellError : undefined, undefined, options ? options.onPostpone : undefined, options ? options.formState : undefined);
+}
+
+function renderToPipeableStream(children, options) {
+  const request = createRequestImpl(children, options);
+  let hasStartedFlowing = false;
+  startWork(request);
+  return {
+    pipe(destination) {
+      if (hasStartedFlowing) {
+        throw new Error('React currently only supports piping to one writable stream.');
+      }
+
+      hasStartedFlowing = true;
+      prepareForStartFlowingIfBeforeAllReady(request);
+      startFlowing(request, destination);
+      destination.on('drain', createDrainHandler(destination, request));
+      destination.on('error', createCancelHandler(request, 'The destination stream errored while writing data.'));
+      destination.on('close', createCancelHandler(request, 'The destination stream closed early.'));
+      return destination;
+    },
+
+    abort(reason) {
+      abort(request, reason);
+    }
+
+  };
+}
+
+exports.renderToPipeableStream = renderToPipeableStream;
+exports.version = ReactVersion;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom-server.node.production.min.js b/packages/next/src/compiled/react-dom/cjs/react-dom-server.node.production.min.js
index b4d5502147a07..09f84a6c92b37 100644
--- a/packages/next/src/compiled/react-dom/cjs/react-dom-server.node.production.min.js
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom-server.node.production.min.js
@@ -1,17 +1,17 @@
-/**
- * @license React
- * react-dom-server.node.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-dom-server.node.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var ba=require("util"),ca=require("crypto"),ha=require("async_hooks"),ia=require("next/dist/compiled/react"),ja=require("react-dom");function oa(a){"function"===typeof a.flush&&a.flush()}var k=null,m=0,pa=!0;
 function u(a,b){if("string"===typeof b){if(0!==b.length)if(2048<3*b.length)0<m&&(va(a,k.subarray(0,m)),k=new Uint8Array(2048),m=0),va(a,wa.encode(b));else{var c=k;0<m&&(c=k.subarray(m));c=wa.encodeInto(b,c);var d=c.read;m+=c.written;d<b.length&&(va(a,k.subarray(0,m)),k=new Uint8Array(2048),m=wa.encodeInto(b.slice(d),k).written);2048===m&&(va(a,k),k=new Uint8Array(2048),m=0)}}else 0!==b.byteLength&&(2048<b.byteLength?(0<m&&(va(a,k.subarray(0,m)),k=new Uint8Array(2048),m=0),va(a,b)):(c=k.length-m,c<
-b.byteLength&&(0===c?va(a,k):(k.set(b.subarray(0,c),m),m+=c,va(a,k),b=b.subarray(c)),k=new Uint8Array(2048),m=0),k.set(b,m),m+=b.byteLength,2048===m&&(va(a,k),k=new Uint8Array(2048),m=0)))}function va(a,b){a=a.write(b);pa=pa&&a}function w(a,b){u(a,b);return pa}function xa(a){k&&0<m&&a.write(k.subarray(0,m));k=null;m=0;pa=!0}var wa=new ba.TextEncoder;function y(a){return wa.encode(a)}
-var z=Object.assign,A=Object.prototype.hasOwnProperty,Ea=RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"),Fa={},Ga={};
-function Ha(a){if(A.call(Ga,a))return!0;if(A.call(Fa,a))return!1;if(Ea.test(a))return Ga[a]=!0;Fa[a]=!0;return!1}
+b.byteLength&&(0===c?va(a,k):(k.set(b.subarray(0,c),m),m+=c,va(a,k),b=b.subarray(c)),k=new Uint8Array(2048),m=0),k.set(b,m),m+=b.byteLength,2048===m&&(va(a,k),k=new Uint8Array(2048),m=0)))}function va(a,b){a=a.write(b);pa=pa&&a}function v(a,b){u(a,b);return pa}function xa(a){k&&0<m&&a.write(k.subarray(0,m));k=null;m=0;pa=!0}var wa=new ba.TextEncoder;function w(a){return wa.encode(a)}
+var x=Object.assign,y=Object.prototype.hasOwnProperty,Ea=RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"),Fa={},Ga={};
+function Ha(a){if(y.call(Ga,a))return!0;if(y.call(Fa,a))return!1;if(Ea.test(a))return Ga[a]=!0;Fa[a]=!0;return!1}
 var Ia=new Set("animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp".split(" ")),Ja=
 new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv","http-equiv"],["crossOrigin","crossorigin"],["accentHeight","accent-height"],["alignmentBaseline","alignment-baseline"],["arabicForm","arabic-form"],["baselineShift","baseline-shift"],["capHeight","cap-height"],["clipPath","clip-path"],["clipRule","clip-rule"],["colorInterpolation","color-interpolation"],["colorInterpolationFilters","color-interpolation-filters"],["colorProfile","color-profile"],["colorRendering","color-rendering"],
 ["dominantBaseline","dominant-baseline"],["enableBackground","enable-background"],["fillOpacity","fill-opacity"],["fillRule","fill-rule"],["floodColor","flood-color"],["floodOpacity","flood-opacity"],["fontFamily","font-family"],["fontSize","font-size"],["fontSizeAdjust","font-size-adjust"],["fontStretch","font-stretch"],["fontStyle","font-style"],["fontVariant","font-variant"],["fontWeight","font-weight"],["glyphName","glyph-name"],["glyphOrientationHorizontal","glyph-orientation-horizontal"],["glyphOrientationVertical",
@@ -19,81 +19,81 @@ new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv","http
 "shape-rendering"],["stopColor","stop-color"],["stopOpacity","stop-opacity"],["strikethroughPosition","strikethrough-position"],["strikethroughThickness","strikethrough-thickness"],["strokeDasharray","stroke-dasharray"],["strokeDashoffset","stroke-dashoffset"],["strokeLinecap","stroke-linecap"],["strokeLinejoin","stroke-linejoin"],["strokeMiterlimit","stroke-miterlimit"],["strokeOpacity","stroke-opacity"],["strokeWidth","stroke-width"],["textAnchor","text-anchor"],["textDecoration","text-decoration"],
 ["textRendering","text-rendering"],["transformOrigin","transform-origin"],["underlinePosition","underline-position"],["underlineThickness","underline-thickness"],["unicodeBidi","unicode-bidi"],["unicodeRange","unicode-range"],["unitsPerEm","units-per-em"],["vAlphabetic","v-alphabetic"],["vHanging","v-hanging"],["vIdeographic","v-ideographic"],["vMathematical","v-mathematical"],["vectorEffect","vector-effect"],["vertAdvY","vert-adv-y"],["vertOriginX","vert-origin-x"],["vertOriginY","vert-origin-y"],
 ["wordSpacing","word-spacing"],["writingMode","writing-mode"],["xmlnsXlink","xmlns:xlink"],["xHeight","x-height"]]),Ka=/["'&<>]/;
-function B(a){if("boolean"===typeof a||"number"===typeof a)return""+a;a=""+a;var b=Ka.exec(a);if(b){var c="",d,e=0;for(d=b.index;d<a.length;d++){switch(a.charCodeAt(d)){case 34:b="&quot;";break;case 38:b="&amp;";break;case 39:b="&#x27;";break;case 60:b="&lt;";break;case 62:b="&gt;";break;default:continue}e!==d&&(c+=a.slice(e,d));e=d+1;c+=b}a=e!==d?c+a.slice(e,d):c}return a}
-var La=/([A-Z])/g,Sa=/^ms-/,Ta=Array.isArray,Ua=ia.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,Va={pending:!1,data:null,method:null,action:null},Wa=ja.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Dispatcher,qb={prefetchDNS:Xa,preconnect:Ya,preload:Za,preloadModule:$a,preinitStyle:ab,preinitScript:ob,preinitModuleScript:pb},D=[],rb=y('"></template>'),sb=y("<script>"),tb=y("\x3c/script>"),ub=y('<script src="'),vb=y('<script type="module" src="'),wb=y('" nonce="'),xb=y('" integrity="'),
-yb=y('" crossorigin="'),zb=y('" async="">\x3c/script>'),Ab=/(<\/|<)(s)(cript)/gi;function Jb(a,b,c,d){return""+b+("s"===c?"\\u0073":"\\u0053")+d}var Kb=y('<script type="importmap">'),Lb=y("\x3c/script>");function G(a,b,c){return{insertionMode:a,selectedValue:b,tagScope:c}}
+function z(a){if("boolean"===typeof a||"number"===typeof a)return""+a;a=""+a;var b=Ka.exec(a);if(b){var c="",d,e=0;for(d=b.index;d<a.length;d++){switch(a.charCodeAt(d)){case 34:b="&quot;";break;case 38:b="&amp;";break;case 39:b="&#x27;";break;case 60:b="&lt;";break;case 62:b="&gt;";break;default:continue}e!==d&&(c+=a.slice(e,d));e=d+1;c+=b}a=e!==d?c+a.slice(e,d):c}return a}
+var La=/([A-Z])/g,Sa=/^ms-/,Ta=Array.isArray,Ua=ia.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,Va={pending:!1,data:null,method:null,action:null},Wa=ja.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Dispatcher,qb={prefetchDNS:Xa,preconnect:Ya,preload:Za,preloadModule:$a,preinitStyle:ab,preinitScript:ob,preinitModuleScript:pb},D=[],rb=w('"></template>'),sb=w("<script>"),tb=w("\x3c/script>"),ub=w('<script src="'),vb=w('<script type="module" src="'),wb=w('" nonce="'),xb=w('" integrity="'),
+yb=w('" crossorigin="'),zb=w('" async="">\x3c/script>'),Ab=/(<\/|<)(s)(cript)/gi;function Jb(a,b,c,d){return""+b+("s"===c?"\\u0073":"\\u0053")+d}var Kb=w('<script type="importmap">'),Lb=w("\x3c/script>");function G(a,b,c){return{insertionMode:a,selectedValue:b,tagScope:c}}
 function Mb(a,b,c){switch(b){case "noscript":return G(2,null,a.tagScope|1);case "select":return G(2,null!=c.value?c.value:c.defaultValue,a.tagScope);case "svg":return G(3,null,a.tagScope);case "picture":return G(2,null,a.tagScope|2);case "math":return G(4,null,a.tagScope);case "foreignObject":return G(2,null,a.tagScope);case "table":return G(5,null,a.tagScope);case "thead":case "tbody":case "tfoot":return G(6,null,a.tagScope);case "colgroup":return G(8,null,a.tagScope);case "tr":return G(7,null,a.tagScope)}return 5<=
-a.insertionMode?G(2,null,a.tagScope):0===a.insertionMode?"html"===b?G(1,null,a.tagScope):G(2,null,a.tagScope):1===a.insertionMode?G(2,null,a.tagScope):a}var Nb=y("\x3c!-- --\x3e");function Ob(a,b,c,d){if(""===b)return d;d&&a.push(Nb);a.push(B(b));return!0}var Pb=new Map,Qb=y(' style="'),Rb=y(":"),Sb=y(";");
-function Tb(a,b){if("object"!==typeof b)throw Error("The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + 'em'}} when using JSX.");var c=!0,d;for(d in b)if(A.call(b,d)){var e=b[d];if(null!=e&&"boolean"!==typeof e&&""!==e){if(0===d.indexOf("--")){var f=B(d);e=B((""+e).trim())}else f=Pb.get(d),void 0===f&&(f=y(B(d.replace(La,"-$1").toLowerCase().replace(Sa,"-ms-"))),Pb.set(d,f)),e="number"===typeof e?0===e||Ia.has(d)?""+e:e+"px":
-B((""+e).trim());c?(c=!1,a.push(Qb,f,Rb,e)):a.push(Sb,f,Rb,e)}}c||a.push(K)}var M=y(" "),N=y('="'),K=y('"'),Ub=y('=""');function Vb(a,b,c){c&&"function"!==typeof c&&"symbol"!==typeof c&&a.push(M,b,Ub)}function O(a,b,c){"function"!==typeof c&&"symbol"!==typeof c&&"boolean"!==typeof c&&a.push(M,b,N,B(c),K)}function Wb(a){var b=a.nextFormID++;return a.idPrefix+b}var Xb=y(B("javascript:throw new Error('A React form was unexpectedly submitted.')")),Yb=y('<input type="hidden"');
+a.insertionMode?G(2,null,a.tagScope):0===a.insertionMode?"html"===b?G(1,null,a.tagScope):G(2,null,a.tagScope):1===a.insertionMode?G(2,null,a.tagScope):a}var Nb=w("\x3c!-- --\x3e");function Ob(a,b,c,d){if(""===b)return d;d&&a.push(Nb);a.push(z(b));return!0}var Pb=new Map,Qb=w(' style="'),Rb=w(":"),Sb=w(";");
+function Tb(a,b){if("object"!==typeof b)throw Error("The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + 'em'}} when using JSX.");var c=!0,d;for(d in b)if(y.call(b,d)){var e=b[d];if(null!=e&&"boolean"!==typeof e&&""!==e){if(0===d.indexOf("--")){var f=z(d);e=z((""+e).trim())}else f=Pb.get(d),void 0===f&&(f=w(z(d.replace(La,"-$1").toLowerCase().replace(Sa,"-ms-"))),Pb.set(d,f)),e="number"===typeof e?0===e||Ia.has(d)?""+e:e+"px":
+z((""+e).trim());c?(c=!1,a.push(Qb,f,Rb,e)):a.push(Sb,f,Rb,e)}}c||a.push(K)}var M=w(" "),N=w('="'),K=w('"'),Ub=w('=""');function Vb(a,b,c){c&&"function"!==typeof c&&"symbol"!==typeof c&&a.push(M,b,Ub)}function O(a,b,c){"function"!==typeof c&&"symbol"!==typeof c&&"boolean"!==typeof c&&a.push(M,b,N,z(c),K)}function Wb(a){var b=a.nextFormID++;return a.idPrefix+b}var Xb=w(z("javascript:throw new Error('A React form was unexpectedly submitted.')")),Yb=w('<input type="hidden"');
 function Zb(a,b){this.push(Yb);if("string"!==typeof a)throw Error("File/Blob fields are not yet supported in progressive forms. It probably means you are closing over binary data or FormData in a Server Action.");O(this,"name",b);O(this,"value",a);this.push($b)}
 function ac(a,b,c,d,e,f,g,h){var l=null;"function"===typeof d&&("function"===typeof d.$$FORM_ACTION?(e=Wb(b),b=d.$$FORM_ACTION(e),h=b.name,d=b.action||"",e=b.encType,f=b.method,g=b.target,l=b.data):(a.push(M,"formAction",N,Xb,K),g=f=e=d=h=null,bc(b,c)));null!=h&&Q(a,"name",h);null!=d&&Q(a,"formAction",d);null!=e&&Q(a,"formEncType",e);null!=f&&Q(a,"formMethod",f);null!=g&&Q(a,"formTarget",g);return l}
-function Q(a,b,c){switch(b){case "className":O(a,"class",c);break;case "tabIndex":O(a,"tabindex",c);break;case "dir":case "role":case "viewBox":case "width":case "height":O(a,b,c);break;case "style":Tb(a,c);break;case "src":case "href":case "action":case "formAction":if(null==c||"function"===typeof c||"symbol"===typeof c||"boolean"===typeof c)break;a.push(M,b,N,B(""+c),K);break;case "defaultValue":case "defaultChecked":case "innerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":break;
-case "autoFocus":case "multiple":case "muted":Vb(a,b.toLowerCase(),c);break;case "xlinkHref":if("function"===typeof c||"symbol"===typeof c||"boolean"===typeof c)break;a.push(M,"xlink:href",N,B(""+c),K);break;case "contentEditable":case "spellCheck":case "draggable":case "value":case "autoReverse":case "externalResourcesRequired":case "focusable":case "preserveAlpha":"function"!==typeof c&&"symbol"!==typeof c&&a.push(M,b,N,B(c),K);break;case "allowFullScreen":case "async":case "autoPlay":case "controls":case "default":case "defer":case "disabled":case "disablePictureInPicture":case "disableRemotePlayback":case "formNoValidate":case "hidden":case "loop":case "noModule":case "noValidate":case "open":case "playsInline":case "readOnly":case "required":case "reversed":case "scoped":case "seamless":case "itemScope":c&&
-"function"!==typeof c&&"symbol"!==typeof c&&a.push(M,b,Ub);break;case "capture":case "download":!0===c?a.push(M,b,Ub):!1!==c&&"function"!==typeof c&&"symbol"!==typeof c&&a.push(M,b,N,B(c),K);break;case "cols":case "rows":case "size":case "span":"function"!==typeof c&&"symbol"!==typeof c&&!isNaN(c)&&1<=c&&a.push(M,b,N,B(c),K);break;case "rowSpan":case "start":"function"===typeof c||"symbol"===typeof c||isNaN(c)||a.push(M,b,N,B(c),K);break;case "xlinkActuate":O(a,"xlink:actuate",c);break;case "xlinkArcrole":O(a,
+function Q(a,b,c){switch(b){case "className":O(a,"class",c);break;case "tabIndex":O(a,"tabindex",c);break;case "dir":case "role":case "viewBox":case "width":case "height":O(a,b,c);break;case "style":Tb(a,c);break;case "src":case "href":case "action":case "formAction":if(null==c||"function"===typeof c||"symbol"===typeof c||"boolean"===typeof c)break;a.push(M,b,N,z(""+c),K);break;case "defaultValue":case "defaultChecked":case "innerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":break;
+case "autoFocus":case "multiple":case "muted":Vb(a,b.toLowerCase(),c);break;case "xlinkHref":if("function"===typeof c||"symbol"===typeof c||"boolean"===typeof c)break;a.push(M,"xlink:href",N,z(""+c),K);break;case "contentEditable":case "spellCheck":case "draggable":case "value":case "autoReverse":case "externalResourcesRequired":case "focusable":case "preserveAlpha":"function"!==typeof c&&"symbol"!==typeof c&&a.push(M,b,N,z(c),K);break;case "allowFullScreen":case "async":case "autoPlay":case "controls":case "default":case "defer":case "disabled":case "disablePictureInPicture":case "disableRemotePlayback":case "formNoValidate":case "hidden":case "loop":case "noModule":case "noValidate":case "open":case "playsInline":case "readOnly":case "required":case "reversed":case "scoped":case "seamless":case "itemScope":c&&
+"function"!==typeof c&&"symbol"!==typeof c&&a.push(M,b,Ub);break;case "capture":case "download":!0===c?a.push(M,b,Ub):!1!==c&&"function"!==typeof c&&"symbol"!==typeof c&&a.push(M,b,N,z(c),K);break;case "cols":case "rows":case "size":case "span":"function"!==typeof c&&"symbol"!==typeof c&&!isNaN(c)&&1<=c&&a.push(M,b,N,z(c),K);break;case "rowSpan":case "start":"function"===typeof c||"symbol"===typeof c||isNaN(c)||a.push(M,b,N,z(c),K);break;case "xlinkActuate":O(a,"xlink:actuate",c);break;case "xlinkArcrole":O(a,
 "xlink:arcrole",c);break;case "xlinkRole":O(a,"xlink:role",c);break;case "xlinkShow":O(a,"xlink:show",c);break;case "xlinkTitle":O(a,"xlink:title",c);break;case "xlinkType":O(a,"xlink:type",c);break;case "xmlBase":O(a,"xml:base",c);break;case "xmlLang":O(a,"xml:lang",c);break;case "xmlSpace":O(a,"xml:space",c);break;default:if(!(2<b.length)||"o"!==b[0]&&"O"!==b[0]||"n"!==b[1]&&"N"!==b[1])if(b=Ja.get(b)||b,Ha(b)){switch(typeof c){case "function":case "symbol":return;case "boolean":var d=b.toLowerCase().slice(0,
-5);if("data-"!==d&&"aria-"!==d)return}a.push(M,b,N,B(c),K)}}}var R=y(">"),$b=y("/>");function cc(a,b,c){if(null!=b){if(null!=c)throw Error("Can only set one of `children` or `props.dangerouslySetInnerHTML`.");if("object"!==typeof b||!("__html"in b))throw Error("`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://reactjs.org/link/dangerously-set-inner-html for more information.");b=b.__html;null!==b&&void 0!==b&&a.push(""+b)}}
-function dc(a){var b="";ia.Children.forEach(a,function(c){null!=c&&(b+=c)});return b}var ec=y(' selected=""'),fc=y('addEventListener("submit",function(a){if(!a.defaultPrevented){var c=a.target,d=a.submitter,e=c.action,b=d;if(d){var f=d.getAttribute("formAction");null!=f&&(e=f,b=null)}"javascript:throw new Error(\'A React form was unexpectedly submitted.\')"===e&&(a.preventDefault(),b?(a=document.createElement("input"),a.name=b.name,a.value=b.value,b.parentNode.insertBefore(a,b),b=new FormData(c),a.parentNode.removeChild(a)):b=new FormData(c),a=c.getRootNode(),(a.$$reactFormReplay=a.$$reactFormReplay||[]).push(c,\nd,b))}});');
-function bc(a,b){0!==(a.instructions&16)||b.externalRuntimeScript||(a.instructions|=16,b.bootstrapChunks.unshift(b.startInlineScript,fc,tb))}var gc=y("\x3c!--F!--\x3e"),hc=y("\x3c!--F--\x3e");
-function ic(a,b,c,d,e,f,g){var h=b.rel,l=b.href,n=b.precedence;if(3===f||g||null!=b.itemProp||"string"!==typeof h||"string"!==typeof l||""===l)return T(a,b),null;if("stylesheet"===b.rel){if("string"!==typeof n||null!=b.disabled||b.onLoad||b.onError)return T(a,b);f=d.styles.get(n);g=c.styleResources.hasOwnProperty(l)?c.styleResources[l]:void 0;null!==g?(c.styleResources[l]=null,f||(f={precedence:B(n),rules:[],hrefs:[],sheets:new Map},d.styles.set(n,f)),b={state:0,props:z({},b,{"data-precedence":b.precedence,
+5);if("data-"!==d&&"aria-"!==d)return}a.push(M,b,N,z(c),K)}}}var R=w(">"),$b=w("/>");function cc(a,b,c){if(null!=b){if(null!=c)throw Error("Can only set one of `children` or `props.dangerouslySetInnerHTML`.");if("object"!==typeof b||!("__html"in b))throw Error("`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://reactjs.org/link/dangerously-set-inner-html for more information.");b=b.__html;null!==b&&void 0!==b&&a.push(""+b)}}
+function dc(a){var b="";ia.Children.forEach(a,function(c){null!=c&&(b+=c)});return b}var ec=w(' selected=""'),fc=w('addEventListener("submit",function(a){if(!a.defaultPrevented){var c=a.target,d=a.submitter,e=c.action,b=d;if(d){var f=d.getAttribute("formAction");null!=f&&(e=f,b=null)}"javascript:throw new Error(\'A React form was unexpectedly submitted.\')"===e&&(a.preventDefault(),b?(a=document.createElement("input"),a.name=b.name,a.value=b.value,b.parentNode.insertBefore(a,b),b=new FormData(c),a.parentNode.removeChild(a)):b=new FormData(c),a=c.getRootNode(),(a.$$reactFormReplay=a.$$reactFormReplay||[]).push(c,\nd,b))}});');
+function bc(a,b){0!==(a.instructions&16)||b.externalRuntimeScript||(a.instructions|=16,b.bootstrapChunks.unshift(b.startInlineScript,fc,tb))}var gc=w("\x3c!--F!--\x3e"),hc=w("\x3c!--F--\x3e");
+function ic(a,b,c,d,e,f,g){var h=b.rel,l=b.href,n=b.precedence;if(3===f||g||null!=b.itemProp||"string"!==typeof h||"string"!==typeof l||""===l)return T(a,b),null;if("stylesheet"===b.rel){if("string"!==typeof n||null!=b.disabled||b.onLoad||b.onError)return T(a,b);f=d.styles.get(n);g=c.styleResources.hasOwnProperty(l)?c.styleResources[l]:void 0;null!==g?(c.styleResources[l]=null,f||(f={precedence:z(n),rules:[],hrefs:[],sheets:new Map},d.styles.set(n,f)),b={state:0,props:x({},b,{"data-precedence":b.precedence,
 precedence:null})},g&&(2===g.length&&jc(b.props,g),(c=d.preloads.stylesheets.get(l))&&0<c.length?c.length=0:b.state=1),f.sheets.set(l,b),d.boundaryResources&&d.boundaryResources.stylesheets.add(b)):f&&(l=f.sheets.get(l))&&d.boundaryResources&&d.boundaryResources.stylesheets.add(l);e&&a.push(Nb);return null}if(b.onLoad||b.onError)return T(a,b);e&&a.push(Nb);switch(b.rel){case "preconnect":case "dns-prefetch":return T(d.preconnectChunks,b);case "preload":return T(d.preloadChunks,b);default:return T(d.hoistableChunks,
-b)}}function T(a,b){a.push(V("link"));for(var c in b)if(A.call(b,c)){var d=b[c];if(null!=d)switch(c){case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");default:Q(a,c,d)}}a.push($b);return null}
-function kc(a,b,c){a.push(V(c));for(var d in b)if(A.call(b,d)){var e=b[d];if(null!=e)switch(d){case "children":case "dangerouslySetInnerHTML":throw Error(c+" is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");default:Q(a,d,e)}}a.push($b);return null}
-function lc(a,b){a.push(V("title"));var c=null,d=null,e;for(e in b)if(A.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:Q(a,e,f)}}a.push(R);b=Array.isArray(c)?2>c.length?c[0]:null:c;"function"!==typeof b&&"symbol"!==typeof b&&null!==b&&void 0!==b&&a.push(B(""+b));cc(a,d,c);a.push(mc("title"));return null}
-function wc(a,b){a.push(V("script"));var c=null,d=null,e;for(e in b)if(A.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:Q(a,e,f)}}a.push(R);cc(a,d,c);"string"===typeof c&&a.push(B(c));a.push(mc("script"));return null}
-function xc(a,b,c){a.push(V(c));var d=c=null,e;for(e in b)if(A.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:Q(a,e,f)}}a.push(R);cc(a,d,c);return"string"===typeof c?(a.push(B(c)),null):c}var yc=y("\n"),zc=/^[a-zA-Z][a-zA-Z:_\.\-\d]*$/,Ac=new Map;function V(a){var b=Ac.get(a);if(void 0===b){if(!zc.test(a))throw Error("Invalid tag: "+a);b=y("<"+a);Ac.set(a,b)}return b}var Bc=y("<!DOCTYPE html>");
-function Cc(a,b,c,d,e,f,g){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "select":a.push(V("select"));var h=null,l=null,n;for(n in c)if(A.call(c,n)){var p=c[n];if(null!=p)switch(n){case "children":h=p;break;case "dangerouslySetInnerHTML":l=p;break;case "defaultValue":case "value":break;default:Q(a,n,p)}}a.push(R);cc(a,l,h);return h;case "option":var r=f.selectedValue;a.push(V("option"));var q=null,x=null,v=null,Z=null,t;for(t in c)if(A.call(c,
-t)){var C=c[t];if(null!=C)switch(t){case "children":q=C;break;case "selected":v=C;break;case "dangerouslySetInnerHTML":Z=C;break;case "value":x=C;default:Q(a,t,C)}}if(null!=r){var H=null!==x?""+x:dc(q);if(Ta(r))for(var ka=0;ka<r.length;ka++){if(""+r[ka]===H){a.push(ec);break}}else""+r===H&&a.push(ec)}else v&&a.push(ec);a.push(R);cc(a,Z,q);return q;case "textarea":a.push(V("textarea"));var E=null,U=null,F=null,da;for(da in c)if(A.call(c,da)){var S=c[da];if(null!=S)switch(da){case "children":F=S;break;
-case "value":E=S;break;case "defaultValue":U=S;break;case "dangerouslySetInnerHTML":throw Error("`dangerouslySetInnerHTML` does not make sense on <textarea>.");default:Q(a,da,S)}}null===E&&null!==U&&(E=U);a.push(R);if(null!=F){if(null!=E)throw Error("If you supply `defaultValue` on a <textarea>, do not pass children.");if(Ta(F)){if(1<F.length)throw Error("<textarea> can only have at most one child.");E=""+F[0]}E=""+F}"string"===typeof E&&"\n"===E[0]&&a.push(yc);null!==E&&a.push(B(""+E));return null;
-case "input":a.push(V("input"));var la=null,P=null,I=null,ma=null,ya=null,qa=null,ra=null,sa=null,Ma=null,ea;for(ea in c)if(A.call(c,ea)){var aa=c[ea];if(null!=aa)switch(ea){case "children":case "dangerouslySetInnerHTML":throw Error("input is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");case "name":la=aa;break;case "formAction":P=aa;break;case "formEncType":I=aa;break;case "formMethod":ma=aa;break;case "formTarget":ya=aa;break;case "defaultChecked":Ma=aa;
-break;case "defaultValue":ra=aa;break;case "checked":sa=aa;break;case "value":qa=aa;break;default:Q(a,ea,aa)}}var od=ac(a,d,e,P,I,ma,ya,la);null!==sa?Vb(a,"checked",sa):null!==Ma&&Vb(a,"checked",Ma);null!==qa?Q(a,"value",qa):null!==ra&&Q(a,"value",ra);a.push($b);null!==od&&od.forEach(Zb,a);return null;case "button":a.push(V("button"));var bb=null,pd=null,qd=null,rd=null,sd=null,td=null,ud=null,cb;for(cb in c)if(A.call(c,cb)){var na=c[cb];if(null!=na)switch(cb){case "children":bb=na;break;case "dangerouslySetInnerHTML":pd=
-na;break;case "name":qd=na;break;case "formAction":rd=na;break;case "formEncType":sd=na;break;case "formMethod":td=na;break;case "formTarget":ud=na;break;default:Q(a,cb,na)}}var vd=ac(a,d,e,rd,sd,td,ud,qd);a.push(R);null!==vd&&vd.forEach(Zb,a);cc(a,pd,bb);if("string"===typeof bb){a.push(B(bb));var wd=null}else wd=bb;return wd;case "form":a.push(V("form"));var db=null,xd=null,ta=null,eb=null,fb=null,gb=null,hb;for(hb in c)if(A.call(c,hb)){var ua=c[hb];if(null!=ua)switch(hb){case "children":db=ua;break;
+b)}}function T(a,b){a.push(V("link"));for(var c in b)if(y.call(b,c)){var d=b[c];if(null!=d)switch(c){case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");default:Q(a,c,d)}}a.push($b);return null}
+function kc(a,b,c){a.push(V(c));for(var d in b)if(y.call(b,d)){var e=b[d];if(null!=e)switch(d){case "children":case "dangerouslySetInnerHTML":throw Error(c+" is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");default:Q(a,d,e)}}a.push($b);return null}
+function lc(a,b){a.push(V("title"));var c=null,d=null,e;for(e in b)if(y.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:Q(a,e,f)}}a.push(R);b=Array.isArray(c)?2>c.length?c[0]:null:c;"function"!==typeof b&&"symbol"!==typeof b&&null!==b&&void 0!==b&&a.push(z(""+b));cc(a,d,c);a.push(mc("title"));return null}
+function wc(a,b){a.push(V("script"));var c=null,d=null,e;for(e in b)if(y.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:Q(a,e,f)}}a.push(R);cc(a,d,c);"string"===typeof c&&a.push(z(c));a.push(mc("script"));return null}
+function xc(a,b,c){a.push(V(c));var d=c=null,e;for(e in b)if(y.call(b,e)){var f=b[e];if(null!=f)switch(e){case "children":c=f;break;case "dangerouslySetInnerHTML":d=f;break;default:Q(a,e,f)}}a.push(R);cc(a,d,c);return"string"===typeof c?(a.push(z(c)),null):c}var yc=w("\n"),zc=/^[a-zA-Z][a-zA-Z:_\.\-\d]*$/,Ac=new Map;function V(a){var b=Ac.get(a);if(void 0===b){if(!zc.test(a))throw Error("Invalid tag: "+a);b=w("<"+a);Ac.set(a,b)}return b}var Bc=w("<!DOCTYPE html>");
+function Cc(a,b,c,d,e,f,g){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "select":a.push(V("select"));var h=null,l=null,n;for(n in c)if(y.call(c,n)){var q=c[n];if(null!=q)switch(n){case "children":h=q;break;case "dangerouslySetInnerHTML":l=q;break;case "defaultValue":case "value":break;default:Q(a,n,q)}}a.push(R);cc(a,l,h);return h;case "option":var r=f.selectedValue;a.push(V("option"));var p=null,A=null,B=null,Z=null,t;for(t in c)if(y.call(c,
+t)){var C=c[t];if(null!=C)switch(t){case "children":p=C;break;case "selected":B=C;break;case "dangerouslySetInnerHTML":Z=C;break;case "value":A=C;default:Q(a,t,C)}}if(null!=r){var H=null!==A?""+A:dc(p);if(Ta(r))for(var ka=0;ka<r.length;ka++){if(""+r[ka]===H){a.push(ec);break}}else""+r===H&&a.push(ec)}else B&&a.push(ec);a.push(R);cc(a,Z,p);return p;case "textarea":a.push(V("textarea"));var E=null,U=null,F=null,da;for(da in c)if(y.call(c,da)){var S=c[da];if(null!=S)switch(da){case "children":F=S;break;
+case "value":E=S;break;case "defaultValue":U=S;break;case "dangerouslySetInnerHTML":throw Error("`dangerouslySetInnerHTML` does not make sense on <textarea>.");default:Q(a,da,S)}}null===E&&null!==U&&(E=U);a.push(R);if(null!=F){if(null!=E)throw Error("If you supply `defaultValue` on a <textarea>, do not pass children.");if(Ta(F)){if(1<F.length)throw Error("<textarea> can only have at most one child.");E=""+F[0]}E=""+F}"string"===typeof E&&"\n"===E[0]&&a.push(yc);null!==E&&a.push(z(""+E));return null;
+case "input":a.push(V("input"));var la=null,P=null,I=null,ma=null,ya=null,qa=null,ra=null,sa=null,Ma=null,ea;for(ea in c)if(y.call(c,ea)){var aa=c[ea];if(null!=aa)switch(ea){case "children":case "dangerouslySetInnerHTML":throw Error("input is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");case "name":la=aa;break;case "formAction":P=aa;break;case "formEncType":I=aa;break;case "formMethod":ma=aa;break;case "formTarget":ya=aa;break;case "defaultChecked":Ma=aa;
+break;case "defaultValue":ra=aa;break;case "checked":sa=aa;break;case "value":qa=aa;break;default:Q(a,ea,aa)}}var od=ac(a,d,e,P,I,ma,ya,la);null!==sa?Vb(a,"checked",sa):null!==Ma&&Vb(a,"checked",Ma);null!==qa?Q(a,"value",qa):null!==ra&&Q(a,"value",ra);a.push($b);null!==od&&od.forEach(Zb,a);return null;case "button":a.push(V("button"));var bb=null,pd=null,qd=null,rd=null,sd=null,td=null,ud=null,cb;for(cb in c)if(y.call(c,cb)){var na=c[cb];if(null!=na)switch(cb){case "children":bb=na;break;case "dangerouslySetInnerHTML":pd=
+na;break;case "name":qd=na;break;case "formAction":rd=na;break;case "formEncType":sd=na;break;case "formMethod":td=na;break;case "formTarget":ud=na;break;default:Q(a,cb,na)}}var vd=ac(a,d,e,rd,sd,td,ud,qd);a.push(R);null!==vd&&vd.forEach(Zb,a);cc(a,pd,bb);if("string"===typeof bb){a.push(z(bb));var wd=null}else wd=bb;return wd;case "form":a.push(V("form"));var db=null,xd=null,ta=null,eb=null,fb=null,gb=null,hb;for(hb in c)if(y.call(c,hb)){var ua=c[hb];if(null!=ua)switch(hb){case "children":db=ua;break;
 case "dangerouslySetInnerHTML":xd=ua;break;case "action":ta=ua;break;case "encType":eb=ua;break;case "method":fb=ua;break;case "target":gb=ua;break;default:Q(a,hb,ua)}}var nc=null,oc=null;if("function"===typeof ta)if("function"===typeof ta.$$FORM_ACTION){var qf=Wb(d),Na=ta.$$FORM_ACTION(qf);ta=Na.action||"";eb=Na.encType;fb=Na.method;gb=Na.target;nc=Na.data;oc=Na.name}else a.push(M,"action",N,Xb,K),gb=fb=eb=ta=null,bc(d,e);null!=ta&&Q(a,"action",ta);null!=eb&&Q(a,"encType",eb);null!=fb&&Q(a,"method",
-fb);null!=gb&&Q(a,"target",gb);a.push(R);null!==oc&&(a.push(Yb),O(a,"name",oc),a.push($b),null!==nc&&nc.forEach(Zb,a));cc(a,xd,db);if("string"===typeof db){a.push(B(db));var yd=null}else yd=db;return yd;case "menuitem":a.push(V("menuitem"));for(var Bb in c)if(A.call(c,Bb)){var zd=c[Bb];if(null!=zd)switch(Bb){case "children":case "dangerouslySetInnerHTML":throw Error("menuitems cannot have `children` nor `dangerouslySetInnerHTML`.");default:Q(a,Bb,zd)}}a.push(R);return null;case "title":if(3===f.insertionMode||
+fb);null!=gb&&Q(a,"target",gb);a.push(R);null!==oc&&(a.push(Yb),O(a,"name",oc),a.push($b),null!==nc&&nc.forEach(Zb,a));cc(a,xd,db);if("string"===typeof db){a.push(z(db));var yd=null}else yd=db;return yd;case "menuitem":a.push(V("menuitem"));for(var Bb in c)if(y.call(c,Bb)){var zd=c[Bb];if(null!=zd)switch(Bb){case "children":case "dangerouslySetInnerHTML":throw Error("menuitems cannot have `children` nor `dangerouslySetInnerHTML`.");default:Q(a,Bb,zd)}}a.push(R);return null;case "title":if(3===f.insertionMode||
 f.tagScope&1||null!=c.itemProp)var Ad=lc(a,c);else lc(e.hoistableChunks,c),Ad=null;return Ad;case "link":return ic(a,c,d,e,g,f.insertionMode,!!(f.tagScope&1));case "script":var pc=c.async;if("string"!==typeof c.src||!c.src||!pc||"function"===typeof pc||"symbol"===typeof pc||c.onLoad||c.onError||3===f.insertionMode||f.tagScope&1||null!=c.itemProp)var Bd=wc(a,c);else{var Cb=c.src;if("module"===c.type){var Db=d.moduleScriptResources;var Cd=e.preloads.moduleScripts}else Db=d.scriptResources,Cd=e.preloads.scripts;
-var Eb=Db.hasOwnProperty(Cb)?Db[Cb]:void 0;if(null!==Eb){Db[Cb]=null;var qc=c;if(Eb){2===Eb.length&&(qc=z({},c),jc(qc,Eb));var Dd=Cd.get(Cb);Dd&&(Dd.length=0)}var Ed=[];e.scripts.add(Ed);wc(Ed,qc)}g&&a.push(Nb);Bd=null}return Bd;case "style":var Fb=c.precedence,za=c.href;if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp||"string"!==typeof Fb||"string"!==typeof za||""===za){a.push(V("style"));var Oa=null,Fd=null,ib;for(ib in c)if(A.call(c,ib)){var Gb=c[ib];if(null!=Gb)switch(ib){case "children":Oa=
-Gb;break;case "dangerouslySetInnerHTML":Fd=Gb;break;default:Q(a,ib,Gb)}}a.push(R);var jb=Array.isArray(Oa)?2>Oa.length?Oa[0]:null:Oa;"function"!==typeof jb&&"symbol"!==typeof jb&&null!==jb&&void 0!==jb&&a.push(B(""+jb));cc(a,Fd,Oa);a.push(mc("style"));var Gd=null}else{var Aa=e.styles.get(Fb);if(null!==(d.styleResources.hasOwnProperty(za)?d.styleResources[za]:void 0)){d.styleResources[za]=null;Aa?Aa.hrefs.push(B(za)):(Aa={precedence:B(Fb),rules:[],hrefs:[B(za)],sheets:new Map},e.styles.set(Fb,Aa));
-var Hd=Aa.rules,Pa=null,Id=null,Hb;for(Hb in c)if(A.call(c,Hb)){var rc=c[Hb];if(null!=rc)switch(Hb){case "children":Pa=rc;break;case "dangerouslySetInnerHTML":Id=rc}}var kb=Array.isArray(Pa)?2>Pa.length?Pa[0]:null:Pa;"function"!==typeof kb&&"symbol"!==typeof kb&&null!==kb&&void 0!==kb&&Hd.push(B(""+kb));cc(Hd,Id,Pa)}Aa&&e.boundaryResources&&e.boundaryResources.styles.add(Aa);g&&a.push(Nb);Gd=void 0}return Gd;case "meta":if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp)var Jd=kc(a,c,"meta");
-else g&&a.push(Nb),Jd="string"===typeof c.charSet?kc(e.charsetChunks,c,"meta"):"viewport"===c.name?kc(e.preconnectChunks,c,"meta"):kc(e.hoistableChunks,c,"meta");return Jd;case "listing":case "pre":a.push(V(b));var lb=null,mb=null,nb;for(nb in c)if(A.call(c,nb)){var Ib=c[nb];if(null!=Ib)switch(nb){case "children":lb=Ib;break;case "dangerouslySetInnerHTML":mb=Ib;break;default:Q(a,nb,Ib)}}a.push(R);if(null!=mb){if(null!=lb)throw Error("Can only set one of `children` or `props.dangerouslySetInnerHTML`.");
+var Eb=Db.hasOwnProperty(Cb)?Db[Cb]:void 0;if(null!==Eb){Db[Cb]=null;var qc=c;if(Eb){2===Eb.length&&(qc=x({},c),jc(qc,Eb));var Dd=Cd.get(Cb);Dd&&(Dd.length=0)}var Ed=[];e.scripts.add(Ed);wc(Ed,qc)}g&&a.push(Nb);Bd=null}return Bd;case "style":var Fb=c.precedence,za=c.href;if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp||"string"!==typeof Fb||"string"!==typeof za||""===za){a.push(V("style"));var Oa=null,Fd=null,ib;for(ib in c)if(y.call(c,ib)){var Gb=c[ib];if(null!=Gb)switch(ib){case "children":Oa=
+Gb;break;case "dangerouslySetInnerHTML":Fd=Gb;break;default:Q(a,ib,Gb)}}a.push(R);var jb=Array.isArray(Oa)?2>Oa.length?Oa[0]:null:Oa;"function"!==typeof jb&&"symbol"!==typeof jb&&null!==jb&&void 0!==jb&&a.push(z(""+jb));cc(a,Fd,Oa);a.push(mc("style"));var Gd=null}else{var Aa=e.styles.get(Fb);if(null!==(d.styleResources.hasOwnProperty(za)?d.styleResources[za]:void 0)){d.styleResources[za]=null;Aa?Aa.hrefs.push(z(za)):(Aa={precedence:z(Fb),rules:[],hrefs:[z(za)],sheets:new Map},e.styles.set(Fb,Aa));
+var Hd=Aa.rules,Pa=null,Id=null,Hb;for(Hb in c)if(y.call(c,Hb)){var rc=c[Hb];if(null!=rc)switch(Hb){case "children":Pa=rc;break;case "dangerouslySetInnerHTML":Id=rc}}var kb=Array.isArray(Pa)?2>Pa.length?Pa[0]:null:Pa;"function"!==typeof kb&&"symbol"!==typeof kb&&null!==kb&&void 0!==kb&&Hd.push(z(""+kb));cc(Hd,Id,Pa)}Aa&&e.boundaryResources&&e.boundaryResources.styles.add(Aa);g&&a.push(Nb);Gd=void 0}return Gd;case "meta":if(3===f.insertionMode||f.tagScope&1||null!=c.itemProp)var Jd=kc(a,c,"meta");
+else g&&a.push(Nb),Jd="string"===typeof c.charSet?kc(e.charsetChunks,c,"meta"):"viewport"===c.name?kc(e.preconnectChunks,c,"meta"):kc(e.hoistableChunks,c,"meta");return Jd;case "listing":case "pre":a.push(V(b));var lb=null,mb=null,nb;for(nb in c)if(y.call(c,nb)){var Ib=c[nb];if(null!=Ib)switch(nb){case "children":lb=Ib;break;case "dangerouslySetInnerHTML":mb=Ib;break;default:Q(a,nb,Ib)}}a.push(R);if(null!=mb){if(null!=lb)throw Error("Can only set one of `children` or `props.dangerouslySetInnerHTML`.");
 if("object"!==typeof mb||!("__html"in mb))throw Error("`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://reactjs.org/link/dangerously-set-inner-html for more information.");var Ba=mb.__html;null!==Ba&&void 0!==Ba&&("string"===typeof Ba&&0<Ba.length&&"\n"===Ba[0]?a.push(yc,Ba):a.push(""+Ba))}"string"===typeof lb&&"\n"===lb[0]&&a.push(yc);return lb;case "img":var L=c.src,J=c.srcSet;if(!("lazy"===c.loading||!L&&!J||"string"!==typeof L&&null!=L||"string"!==typeof J&&
 null!=J)&&"low"!==c.fetchPriority&&!1===!!(f.tagScope&2)&&("string"!==typeof L||":"!==L[4]||"d"!==L[0]&&"D"!==L[0]||"a"!==L[1]&&"A"!==L[1]||"t"!==L[2]&&"T"!==L[2]||"a"!==L[3]&&"A"!==L[3])&&("string"!==typeof J||":"!==J[4]||"d"!==J[0]&&"D"!==J[0]||"a"!==J[1]&&"A"!==J[1]||"t"!==J[2]&&"T"!==J[2]||"a"!==J[3]&&"A"!==J[3])){var Kd="string"===typeof c.sizes?c.sizes:void 0,Qa=J?J+"\n"+(Kd||""):L,sc=e.preloads.images,Ca=sc.get(Qa);if(Ca){if("high"===c.fetchPriority||10>e.highImagePreloads.size)sc.delete(Qa),
 e.highImagePreloads.add(Ca)}else if(!d.imageResources.hasOwnProperty(Qa)){d.imageResources[Qa]=D;var tc=c.crossOrigin;var Ld="string"===typeof tc?"use-credentials"===tc?tc:"":void 0;var fa=e.headers,uc;fa&&0<fa.remainingCapacity&&("high"===c.fetchPriority||500>fa.highImagePreloads.length)&&(uc=Dc(L,"image",{imageSrcSet:c.srcSet,imageSizes:c.sizes,crossOrigin:Ld,integrity:c.integrity,nonce:c.nonce,type:c.type,fetchPriority:c.fetchPriority,referrerPolicy:c.refererPolicy}),2<=(fa.remainingCapacity-=
 uc.length))?(e.resets.image[Qa]=D,fa.highImagePreloads&&(fa.highImagePreloads+=", "),fa.highImagePreloads+=uc):(Ca=[],T(Ca,{rel:"preload",as:"image",href:J?void 0:L,imageSrcSet:J,imageSizes:Kd,crossOrigin:Ld,integrity:c.integrity,type:c.type,fetchPriority:c.fetchPriority,referrerPolicy:c.referrerPolicy}),"high"===c.fetchPriority||10>e.highImagePreloads.size?e.highImagePreloads.add(Ca):(e.bulkPreloads.add(Ca),sc.set(Qa,Ca)))}}return kc(a,c,"img");case "base":case "area":case "br":case "col":case "embed":case "hr":case "keygen":case "param":case "source":case "track":case "wbr":return kc(a,
 c,b);case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph":break;case "head":if(2>f.insertionMode&&null===e.headChunks){e.headChunks=[];var Md=xc(e.headChunks,c,"head")}else Md=xc(a,c,"head");return Md;case "html":if(0===f.insertionMode&&null===e.htmlChunks){e.htmlChunks=[Bc];var Nd=xc(e.htmlChunks,c,"html")}else Nd=xc(a,c,"html");return Nd;default:if(-1!==b.indexOf("-")){a.push(V(b));
-var vc=null,Od=null,Ra;for(Ra in c)if(A.call(c,Ra)){var Da=c[Ra];if(null!=Da){var rf=Ra;switch(Ra){case "children":vc=Da;break;case "dangerouslySetInnerHTML":Od=Da;break;case "style":Tb(a,Da);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":break;default:Ha(Ra)&&"function"!==typeof Da&&"symbol"!==typeof Da&&a.push(M,rf,N,B(Da),K)}}}a.push(R);cc(a,Od,vc);return vc}}return xc(a,c,b)}var Ec=new Map;
-function mc(a){var b=Ec.get(a);void 0===b&&(b=y("</"+a+">"),Ec.set(a,b));return b}function Fc(a,b){b=b.bootstrapChunks;for(var c=0;c<b.length-1;c++)u(a,b[c]);return c<b.length?(c=b[c],b.length=0,w(a,c)):!0}var Gc=y('<template id="'),Hc=y('"></template>'),Ic=y("\x3c!--$--\x3e"),Jc=y('\x3c!--$?--\x3e<template id="'),Kc=y('"></template>'),Lc=y("\x3c!--$!--\x3e"),Mc=y("\x3c!--/$--\x3e"),Nc=y("<template"),Oc=y('"'),Pc=y(' data-dgst="');y(' data-msg="');y(' data-stck="');var Qc=y("></template>");
-function Rc(a,b,c){u(a,Jc);if(null===c)throw Error("An ID must have been assigned before we can complete the boundary.");u(a,b.boundaryPrefix);u(a,c.toString(16));return w(a,Kc)}
-var Sc=y('<div hidden id="'),Tc=y('">'),Uc=y("</div>"),Vc=y('<svg aria-hidden="true" style="display:none" id="'),Wc=y('">'),Xc=y("</svg>"),Yc=y('<math aria-hidden="true" style="display:none" id="'),Zc=y('">'),$c=y("</math>"),ad=y('<table hidden id="'),bd=y('">'),cd=y("</table>"),dd=y('<table hidden><tbody id="'),ed=y('">'),fd=y("</tbody></table>"),gd=y('<table hidden><tr id="'),hd=y('">'),id=y("</tr></table>"),jd=y('<table hidden><colgroup id="'),kd=y('">'),ld=y("</colgroup></table>");
-function md(a,b,c,d){switch(c.insertionMode){case 0:case 1:case 2:return u(a,Sc),u(a,b.segmentPrefix),u(a,d.toString(16)),w(a,Tc);case 3:return u(a,Vc),u(a,b.segmentPrefix),u(a,d.toString(16)),w(a,Wc);case 4:return u(a,Yc),u(a,b.segmentPrefix),u(a,d.toString(16)),w(a,Zc);case 5:return u(a,ad),u(a,b.segmentPrefix),u(a,d.toString(16)),w(a,bd);case 6:return u(a,dd),u(a,b.segmentPrefix),u(a,d.toString(16)),w(a,ed);case 7:return u(a,gd),u(a,b.segmentPrefix),u(a,d.toString(16)),w(a,hd);case 8:return u(a,
-jd),u(a,b.segmentPrefix),u(a,d.toString(16)),w(a,kd);default:throw Error("Unknown insertion mode. This is a bug in React.");}}function nd(a,b){switch(b.insertionMode){case 0:case 1:case 2:return w(a,Uc);case 3:return w(a,Xc);case 4:return w(a,$c);case 5:return w(a,cd);case 6:return w(a,fd);case 7:return w(a,id);case 8:return w(a,ld);default:throw Error("Unknown insertion mode. This is a bug in React.");}}
-var Pd=y('$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};$RS("'),Qd=y('$RS("'),Rd=y('","'),Sd=y('")\x3c/script>'),Td=y('<template data-rsi="" data-sid="'),Ud=y('" data-pid="'),Vd=y('$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};$RC("'),
-Wd=y('$RC("'),Xd=y('$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};$RR("'),
-Yd=y('$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};$RR("'),
-Zd=y('$RR("'),$d=y('","'),ae=y('",'),be=y('"'),ce=y(")\x3c/script>"),de=y('<template data-rci="" data-bid="'),ee=y('<template data-rri="" data-bid="'),fe=y('" data-sid="'),ge=y('" data-sty="'),he=y('$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};;$RX("'),ie=y('$RX("'),je=y('"'),ke=y(","),le=y(")\x3c/script>"),me=y('<template data-rxi="" data-bid="'),ne=y('" data-dgst="'),
-oe=y('" data-msg="'),pe=y('" data-stck="'),qe=/[<\u2028\u2029]/g;function re(a){return JSON.stringify(a).replace(qe,function(b){switch(b){case "<":return"\\u003c";case "\u2028":return"\\u2028";case "\u2029":return"\\u2029";default:throw Error("escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}})}var se=/[&><\u2028\u2029]/g;
+var vc=null,Od=null,Ra;for(Ra in c)if(y.call(c,Ra)){var Da=c[Ra];if(null!=Da){var rf=Ra;switch(Ra){case "children":vc=Da;break;case "dangerouslySetInnerHTML":Od=Da;break;case "style":Tb(a,Da);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":break;default:Ha(Ra)&&"function"!==typeof Da&&"symbol"!==typeof Da&&a.push(M,rf,N,z(Da),K)}}}a.push(R);cc(a,Od,vc);return vc}}return xc(a,c,b)}var Ec=new Map;
+function mc(a){var b=Ec.get(a);void 0===b&&(b=w("</"+a+">"),Ec.set(a,b));return b}function Fc(a,b,c){c.bootstrapScriptContent=void 0;c.bootstrapScripts=void 0;c.bootstrapModules=void 0;b=b.bootstrapChunks;for(c=0;c<b.length-1;c++)u(a,b[c]);return c<b.length?(c=b[c],b.length=0,v(a,c)):!0}var Gc=w('<template id="'),Hc=w('"></template>'),Ic=w("\x3c!--$--\x3e"),Jc=w('\x3c!--$?--\x3e<template id="'),Kc=w('"></template>'),Lc=w("\x3c!--$!--\x3e"),Mc=w("\x3c!--/$--\x3e"),Nc=w("<template"),Oc=w('"'),Pc=w(' data-dgst="');
+w(' data-msg="');w(' data-stck="');var Qc=w("></template>");function Rc(a,b,c){u(a,Jc);if(null===c)throw Error("An ID must have been assigned before we can complete the boundary.");u(a,b.boundaryPrefix);u(a,c.toString(16));return v(a,Kc)}
+var Sc=w('<div hidden id="'),Tc=w('">'),Uc=w("</div>"),Vc=w('<svg aria-hidden="true" style="display:none" id="'),Wc=w('">'),Xc=w("</svg>"),Yc=w('<math aria-hidden="true" style="display:none" id="'),Zc=w('">'),$c=w("</math>"),ad=w('<table hidden id="'),bd=w('">'),cd=w("</table>"),dd=w('<table hidden><tbody id="'),ed=w('">'),fd=w("</tbody></table>"),gd=w('<table hidden><tr id="'),hd=w('">'),id=w("</tr></table>"),jd=w('<table hidden><colgroup id="'),kd=w('">'),ld=w("</colgroup></table>");
+function md(a,b,c,d){switch(c.insertionMode){case 0:case 1:case 2:return u(a,Sc),u(a,b.segmentPrefix),u(a,d.toString(16)),v(a,Tc);case 3:return u(a,Vc),u(a,b.segmentPrefix),u(a,d.toString(16)),v(a,Wc);case 4:return u(a,Yc),u(a,b.segmentPrefix),u(a,d.toString(16)),v(a,Zc);case 5:return u(a,ad),u(a,b.segmentPrefix),u(a,d.toString(16)),v(a,bd);case 6:return u(a,dd),u(a,b.segmentPrefix),u(a,d.toString(16)),v(a,ed);case 7:return u(a,gd),u(a,b.segmentPrefix),u(a,d.toString(16)),v(a,hd);case 8:return u(a,
+jd),u(a,b.segmentPrefix),u(a,d.toString(16)),v(a,kd);default:throw Error("Unknown insertion mode. This is a bug in React.");}}function nd(a,b){switch(b.insertionMode){case 0:case 1:case 2:return v(a,Uc);case 3:return v(a,Xc);case 4:return v(a,$c);case 5:return v(a,cd);case 6:return v(a,fd);case 7:return v(a,id);case 8:return v(a,ld);default:throw Error("Unknown insertion mode. This is a bug in React.");}}
+var Pd=w('$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};$RS("'),Qd=w('$RS("'),Rd=w('","'),Sd=w('")\x3c/script>'),Td=w('<template data-rsi="" data-sid="'),Ud=w('" data-pid="'),Vd=w('$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};$RC("'),
+Wd=w('$RC("'),Xd=w('$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};$RR("'),
+Yd=w('$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};$RR("'),
+Zd=w('$RR("'),$d=w('","'),ae=w('",'),be=w('"'),ce=w(")\x3c/script>"),de=w('<template data-rci="" data-bid="'),ee=w('<template data-rri="" data-bid="'),fe=w('" data-sid="'),ge=w('" data-sty="'),he=w('$RX=function(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())};;$RX("'),ie=w('$RX("'),je=w('"'),ke=w(","),le=w(")\x3c/script>"),me=w('<template data-rxi="" data-bid="'),ne=w('" data-dgst="'),
+oe=w('" data-msg="'),pe=w('" data-stck="'),qe=/[<\u2028\u2029]/g;function re(a){return JSON.stringify(a).replace(qe,function(b){switch(b){case "<":return"\\u003c";case "\u2028":return"\\u2028";case "\u2029":return"\\u2029";default:throw Error("escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}})}var se=/[&><\u2028\u2029]/g;
 function te(a){return JSON.stringify(a).replace(se,function(b){switch(b){case "&":return"\\u0026";case ">":return"\\u003e";case "<":return"\\u003c";case "\u2028":return"\\u2028";case "\u2029":return"\\u2029";default:throw Error("escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}})}
-var ue=y('<style media="not all" data-precedence="'),ve=y('" data-href="'),we=y('">'),xe=y("</style>"),ye=!1,ze=!0;function Ae(a){var b=a.rules,c=a.hrefs,d=0;if(c.length){u(this,ue);u(this,a.precedence);for(u(this,ve);d<c.length-1;d++)u(this,c[d]),u(this,Be);u(this,c[d]);u(this,we);for(d=0;d<b.length;d++)u(this,b[d]);ze=w(this,xe);ye=!0;b.length=0;c.length=0}}function Ce(a){return 2!==a.state?ye=!0:!1}
-function De(a,b,c){ye=!1;ze=!0;b.styles.forEach(Ae,a);b.stylesheets.forEach(Ce);ye&&(c.stylesToHoist=!0);return ze}function Ee(a){for(var b=0;b<a.length;b++)u(this,a[b]);a.length=0}var Fe=[];function Ge(a){T(Fe,a.props);for(var b=0;b<Fe.length;b++)u(this,Fe[b]);Fe.length=0;a.state=2}var He=y('<style data-precedence="'),Ie=y('" data-href="'),Be=y(" "),Je=y('">'),Ke=y("</style>");
+var ue=w('<style media="not all" data-precedence="'),ve=w('" data-href="'),we=w('">'),xe=w("</style>"),ye=!1,ze=!0;function Ae(a){var b=a.rules,c=a.hrefs,d=0;if(c.length){u(this,ue);u(this,a.precedence);for(u(this,ve);d<c.length-1;d++)u(this,c[d]),u(this,Be);u(this,c[d]);u(this,we);for(d=0;d<b.length;d++)u(this,b[d]);ze=v(this,xe);ye=!0;b.length=0;c.length=0}}function Ce(a){return 2!==a.state?ye=!0:!1}
+function De(a,b,c){ye=!1;ze=!0;b.styles.forEach(Ae,a);b.stylesheets.forEach(Ce);ye&&(c.stylesToHoist=!0);return ze}function Ee(a){for(var b=0;b<a.length;b++)u(this,a[b]);a.length=0}var Fe=[];function Ge(a){T(Fe,a.props);for(var b=0;b<Fe.length;b++)u(this,Fe[b]);Fe.length=0;a.state=2}var He=w('<style data-precedence="'),Ie=w('" data-href="'),Be=w(" "),Je=w('">'),Ke=w("</style>");
 function Le(a){var b=0<a.sheets.size;a.sheets.forEach(Ge,this);a.sheets.clear();var c=a.rules,d=a.hrefs;if(!b||d.length){u(this,He);u(this,a.precedence);a=0;if(d.length){for(u(this,Ie);a<d.length-1;a++)u(this,d[a]),u(this,Be);u(this,d[a])}u(this,Je);for(a=0;a<c.length;a++)u(this,c[a]);u(this,Ke);c.length=0;d.length=0}}
-function Me(a){if(0===a.state){a.state=1;var b=a.props;T(Fe,{rel:"preload",as:"style",href:a.props.href,crossOrigin:b.crossOrigin,fetchPriority:b.fetchPriority,integrity:b.integrity,media:b.media,hrefLang:b.hrefLang,referrerPolicy:b.referrerPolicy});for(a=0;a<Fe.length;a++)u(this,Fe[a]);Fe.length=0}}function Ne(a){a.sheets.forEach(Me,this);a.sheets.clear()}var Oe=y("["),Pe=y(",["),Qe=y(","),Re=y("]");
-function Se(a,b){u(a,Oe);var c=Oe;b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)u(a,c),u(a,te(""+d.props.href)),u(a,Re),c=Pe;else{u(a,c);var e=d.props["data-precedence"],f=d.props;u(a,te(""+d.props.href));e=""+e;u(a,Qe);u(a,te(e));for(var g in f)if(A.call(f,g)){var h=f[g];if(null!=h)switch(g){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");
+function Me(a){if(0===a.state){a.state=1;var b=a.props;T(Fe,{rel:"preload",as:"style",href:a.props.href,crossOrigin:b.crossOrigin,fetchPriority:b.fetchPriority,integrity:b.integrity,media:b.media,hrefLang:b.hrefLang,referrerPolicy:b.referrerPolicy});for(a=0;a<Fe.length;a++)u(this,Fe[a]);Fe.length=0}}function Ne(a){a.sheets.forEach(Me,this);a.sheets.clear()}var Oe=w("["),Pe=w(",["),Qe=w(","),Re=w("]");
+function Se(a,b){u(a,Oe);var c=Oe;b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)u(a,c),u(a,te(""+d.props.href)),u(a,Re),c=Pe;else{u(a,c);var e=d.props["data-precedence"],f=d.props;u(a,te(""+d.props.href));e=""+e;u(a,Qe);u(a,te(e));for(var g in f)if(y.call(f,g)){var h=f[g];if(null!=h)switch(g){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");
 default:a:{e=a;var l=g.toLowerCase();switch(typeof h){case "function":case "symbol":break a}switch(g){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":l="class";h=""+h;break;case "hidden":if(!1===h)break a;h="";break;case "src":case "href":h=""+h;break;default:if(2<g.length&&("o"===g[0]||"O"===g[0])&&("n"===g[1]||"N"===g[1])||!Ha(g))break a;h=""+h}u(e,Qe);u(e,te(l));u(e,Qe);u(e,te(h))}}}u(a,
 Re);c=Pe;d.state=3}});u(a,Re)}
-function Te(a,b){u(a,Oe);var c=Oe;b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)u(a,c),u(a,B(JSON.stringify(""+d.props.href))),u(a,Re),c=Pe;else{u(a,c);var e=d.props["data-precedence"],f=d.props;u(a,B(JSON.stringify(""+d.props.href)));e=""+e;u(a,Qe);u(a,B(JSON.stringify(e)));for(var g in f)if(A.call(f,g)){var h=f[g];if(null!=h)switch(g){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");default:a:{e=
-a;var l=g.toLowerCase();switch(typeof h){case "function":case "symbol":break a}switch(g){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":l="class";h=""+h;break;case "hidden":if(!1===h)break a;h="";break;case "src":case "href":h=""+h;break;default:if(2<g.length&&("o"===g[0]||"O"===g[0])&&("n"===g[1]||"N"===g[1])||!Ha(g))break a;h=""+h}u(e,Qe);u(e,B(JSON.stringify(l)));u(e,Qe);u(e,B(JSON.stringify(h)))}}}u(a,
+function Te(a,b){u(a,Oe);var c=Oe;b.stylesheets.forEach(function(d){if(2!==d.state)if(3===d.state)u(a,c),u(a,z(JSON.stringify(""+d.props.href))),u(a,Re),c=Pe;else{u(a,c);var e=d.props["data-precedence"],f=d.props;u(a,z(JSON.stringify(""+d.props.href)));e=""+e;u(a,Qe);u(a,z(JSON.stringify(e)));for(var g in f)if(y.call(f,g)){var h=f[g];if(null!=h)switch(g){case "href":case "rel":case "precedence":case "data-precedence":break;case "children":case "dangerouslySetInnerHTML":throw Error("link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");default:a:{e=
+a;var l=g.toLowerCase();switch(typeof h){case "function":case "symbol":break a}switch(g){case "innerHTML":case "dangerouslySetInnerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":case "style":break a;case "className":l="class";h=""+h;break;case "hidden":if(!1===h)break a;h="";break;case "src":case "href":h=""+h;break;default:if(2<g.length&&("o"===g[0]||"O"===g[0])&&("n"===g[1]||"N"===g[1])||!Ha(g))break a;h=""+h}u(e,Qe);u(e,z(JSON.stringify(l)));u(e,Qe);u(e,z(JSON.stringify(h)))}}}u(a,
 Re);c=Pe;d.state=3}});u(a,Re)}function Xa(a){var b=Ue();if(b){var c=b.resumableState,d=b.renderState;if("string"===typeof a&&a){if(!c.dnsResources.hasOwnProperty(a)){c.dnsResources[a]=null;c=d.headers;var e,f;if(f=c&&0<c.remainingCapacity)f=(e="<"+(""+a).replace(Ve,We)+">; rel=dns-prefetch",2<=(c.remainingCapacity-=e.length));f?(d.resets.dns[a]=null,c.preconnects&&(c.preconnects+=", "),c.preconnects+=e):(e=[],T(e,{href:a,rel:"dns-prefetch"}),d.preconnects.add(e))}Xe(b)}}}
 function Ya(a,b){var c=Ue();if(c){var d=c.resumableState,e=c.renderState;if("string"===typeof a&&a){var f="use-credentials"===b?"credentials":"string"===typeof b?"anonymous":"default";if(!d.connectResources[f].hasOwnProperty(a)){d.connectResources[f][a]=null;d=e.headers;var g,h;if(h=d&&0<d.remainingCapacity){h="<"+(""+a).replace(Ve,We)+">; rel=preconnect";if("string"===typeof b){var l=(""+b).replace(Ye,Ze);h+='; crossorigin="'+l+'"'}h=(g=h,2<=(d.remainingCapacity-=g.length))}h?(e.resets.connect[f][a]=
 null,d.preconnects&&(d.preconnects+=", "),d.preconnects+=g):(f=[],T(f,{rel:"preconnect",href:a,crossOrigin:b}),e.preconnects.add(f))}Xe(c)}}}
-function Za(a,b,c){var d=Ue();if(d){var e=d.resumableState,f=d.renderState;if(b&&a){switch(b){case "image":if(c){var g=c.imageSrcSet;var h=c.imageSizes;var l=c.fetchPriority}var n=g?g+"\n"+(h||""):a;if(e.imageResources.hasOwnProperty(n))return;e.imageResources[n]=D;e=f.headers;var p;e&&0<e.remainingCapacity&&"high"===l&&(p=Dc(a,b,c),2<=(e.remainingCapacity-=p.length))?(f.resets.image[n]=D,e.highImagePreloads&&(e.highImagePreloads+=", "),e.highImagePreloads+=p):(e=[],T(e,z({rel:"preload",href:g?void 0:
-a,as:b},c)),"high"===l?f.highImagePreloads.add(e):(f.bulkPreloads.add(e),f.preloads.images.set(n,e)));break;case "style":if(e.styleResources.hasOwnProperty(a))return;g=[];T(g,z({rel:"preload",href:a,as:b},c));e.styleResources[a]=!c||"string"!==typeof c.crossOrigin&&"string"!==typeof c.integrity?D:[c.crossOrigin,c.integrity];f.preloads.stylesheets.set(a,g);f.bulkPreloads.add(g);break;case "script":if(e.scriptResources.hasOwnProperty(a))return;g=[];f.preloads.scripts.set(a,g);f.bulkPreloads.add(g);
-T(g,z({rel:"preload",href:a,as:b},c));e.scriptResources[a]=!c||"string"!==typeof c.crossOrigin&&"string"!==typeof c.integrity?D:[c.crossOrigin,c.integrity];break;default:if(e.unknownResources.hasOwnProperty(b)){if(g=e.unknownResources[b],g.hasOwnProperty(a))return}else g={},e.unknownResources[b]=g;g[a]=D;if((e=f.headers)&&0<e.remainingCapacity&&"font"===b&&(n=Dc(a,b,c),2<=(e.remainingCapacity-=n.length)))f.resets.font[a]=D,e.fontPreloads&&(e.fontPreloads+=", "),e.fontPreloads+=n;else switch(e=[],
-a=z({rel:"preload",href:a,as:b},c),T(e,a),b){case "font":f.fontPreloads.add(e);break;default:f.bulkPreloads.add(e)}}Xe(d)}}}
+function Za(a,b,c){var d=Ue();if(d){var e=d.resumableState,f=d.renderState;if(b&&a){switch(b){case "image":if(c){var g=c.imageSrcSet;var h=c.imageSizes;var l=c.fetchPriority}var n=g?g+"\n"+(h||""):a;if(e.imageResources.hasOwnProperty(n))return;e.imageResources[n]=D;e=f.headers;var q;e&&0<e.remainingCapacity&&"high"===l&&(q=Dc(a,b,c),2<=(e.remainingCapacity-=q.length))?(f.resets.image[n]=D,e.highImagePreloads&&(e.highImagePreloads+=", "),e.highImagePreloads+=q):(e=[],T(e,x({rel:"preload",href:g?void 0:
+a,as:b},c)),"high"===l?f.highImagePreloads.add(e):(f.bulkPreloads.add(e),f.preloads.images.set(n,e)));break;case "style":if(e.styleResources.hasOwnProperty(a))return;g=[];T(g,x({rel:"preload",href:a,as:b},c));e.styleResources[a]=!c||"string"!==typeof c.crossOrigin&&"string"!==typeof c.integrity?D:[c.crossOrigin,c.integrity];f.preloads.stylesheets.set(a,g);f.bulkPreloads.add(g);break;case "script":if(e.scriptResources.hasOwnProperty(a))return;g=[];f.preloads.scripts.set(a,g);f.bulkPreloads.add(g);
+T(g,x({rel:"preload",href:a,as:b},c));e.scriptResources[a]=!c||"string"!==typeof c.crossOrigin&&"string"!==typeof c.integrity?D:[c.crossOrigin,c.integrity];break;default:if(e.unknownResources.hasOwnProperty(b)){if(g=e.unknownResources[b],g.hasOwnProperty(a))return}else g={},e.unknownResources[b]=g;g[a]=D;if((e=f.headers)&&0<e.remainingCapacity&&"font"===b&&(n=Dc(a,b,c),2<=(e.remainingCapacity-=n.length)))f.resets.font[a]=D,e.fontPreloads&&(e.fontPreloads+=", "),e.fontPreloads+=n;else switch(e=[],
+a=x({rel:"preload",href:a,as:b},c),T(e,a),b){case "font":f.fontPreloads.add(e);break;default:f.bulkPreloads.add(e)}}Xe(d)}}}
 function $a(a,b){var c=Ue();if(c){var d=c.resumableState,e=c.renderState;if(a){var f=b&&"string"===typeof b.as?b.as:"script";switch(f){case "script":if(d.moduleScriptResources.hasOwnProperty(a))return;f=[];d.moduleScriptResources[a]=!b||"string"!==typeof b.crossOrigin&&"string"!==typeof b.integrity?D:[b.crossOrigin,b.integrity];e.preloads.moduleScripts.set(a,f);break;default:if(d.moduleUnknownResources.hasOwnProperty(f)){var g=d.unknownResources[f];if(g.hasOwnProperty(a))return}else g={},d.moduleUnknownResources[f]=
-g;f=[];g[a]=D}T(f,z({rel:"modulepreload",href:a},b));e.bulkPreloads.add(f);Xe(c)}}}
-function ab(a,b,c){var d=Ue();if(d){var e=d.resumableState,f=d.renderState;if(a){b=b||"default";var g=f.styles.get(b),h=e.styleResources.hasOwnProperty(a)?e.styleResources[a]:void 0;null!==h&&(e.styleResources[a]=null,g||(g={precedence:B(b),rules:[],hrefs:[],sheets:new Map},f.styles.set(b,g)),b={state:0,props:z({rel:"stylesheet",href:a,"data-precedence":b},c)},h&&(2===h.length&&jc(b.props,h),(f=f.preloads.stylesheets.get(a))&&0<f.length?f.length=0:b.state=1),g.sheets.set(a,b),Xe(d))}}}
-function ob(a,b){var c=Ue();if(c){var d=c.resumableState,e=c.renderState;if(a){var f=d.scriptResources.hasOwnProperty(a)?d.scriptResources[a]:void 0;null!==f&&(d.scriptResources[a]=null,b=z({src:a,async:!0},b),f&&(2===f.length&&jc(b,f),a=e.preloads.scripts.get(a))&&(a.length=0),a=[],e.scripts.add(a),wc(a,b),Xe(c))}}}
-function pb(a,b){var c=Ue();if(c){var d=c.resumableState,e=c.renderState;if(a){var f=d.moduleScriptResources.hasOwnProperty(a)?d.moduleScriptResources[a]:void 0;null!==f&&(d.moduleScriptResources[a]=null,b=z({src:a,type:"module",async:!0},b),f&&(2===f.length&&jc(b,f),a=e.preloads.moduleScripts.get(a))&&(a.length=0),a=[],e.scripts.add(a),wc(a,b),Xe(c))}}}function jc(a,b){null==a.crossOrigin&&(a.crossOrigin=b[0]);null==a.integrity&&(a.integrity=b[1])}
-function Dc(a,b,c){a=(""+a).replace(Ve,We);b=(""+b).replace(Ye,Ze);b="<"+a+'>; rel=preload; as="'+b+'"';for(var d in c)A.call(c,d)&&(a=c[d],"string"===typeof a&&(b+="; "+d.toLowerCase()+'="'+(""+a).replace(Ye,Ze)+'"'));return b}var Ve=/[<>\r\n]/g;
+g;f=[];g[a]=D}T(f,x({rel:"modulepreload",href:a},b));e.bulkPreloads.add(f);Xe(c)}}}
+function ab(a,b,c){var d=Ue();if(d){var e=d.resumableState,f=d.renderState;if(a){b=b||"default";var g=f.styles.get(b),h=e.styleResources.hasOwnProperty(a)?e.styleResources[a]:void 0;null!==h&&(e.styleResources[a]=null,g||(g={precedence:z(b),rules:[],hrefs:[],sheets:new Map},f.styles.set(b,g)),b={state:0,props:x({rel:"stylesheet",href:a,"data-precedence":b},c)},h&&(2===h.length&&jc(b.props,h),(f=f.preloads.stylesheets.get(a))&&0<f.length?f.length=0:b.state=1),g.sheets.set(a,b),Xe(d))}}}
+function ob(a,b){var c=Ue();if(c){var d=c.resumableState,e=c.renderState;if(a){var f=d.scriptResources.hasOwnProperty(a)?d.scriptResources[a]:void 0;null!==f&&(d.scriptResources[a]=null,b=x({src:a,async:!0},b),f&&(2===f.length&&jc(b,f),a=e.preloads.scripts.get(a))&&(a.length=0),a=[],e.scripts.add(a),wc(a,b),Xe(c))}}}
+function pb(a,b){var c=Ue();if(c){var d=c.resumableState,e=c.renderState;if(a){var f=d.moduleScriptResources.hasOwnProperty(a)?d.moduleScriptResources[a]:void 0;null!==f&&(d.moduleScriptResources[a]=null,b=x({src:a,type:"module",async:!0},b),f&&(2===f.length&&jc(b,f),a=e.preloads.moduleScripts.get(a))&&(a.length=0),a=[],e.scripts.add(a),wc(a,b),Xe(c))}}}function jc(a,b){null==a.crossOrigin&&(a.crossOrigin=b[0]);null==a.integrity&&(a.integrity=b[1])}
+function Dc(a,b,c){a=(""+a).replace(Ve,We);b=(""+b).replace(Ye,Ze);b="<"+a+'>; rel=preload; as="'+b+'"';for(var d in c)y.call(c,d)&&(a=c[d],"string"===typeof a&&(b+="; "+d.toLowerCase()+'="'+(""+a).replace(Ye,Ze)+'"'));return b}var Ve=/[<>\r\n]/g;
 function We(a){switch(a){case "<":return"%3C";case ">":return"%3E";case "\n":return"%0A";case "\r":return"%0D";default:throw Error("escapeLinkHrefForHeaderContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}}var Ye=/["';,\r\n]/g;
 function Ze(a){switch(a){case '"':return"%22";case "'":return"%27";case ";":return"%3B";case ",":return"%2C";case "\n":return"%0A";case "\r":return"%0D";default:throw Error("escapeStringForLinkHeaderQuotedParamValueContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React");}}function $e(a){this.styles.add(a)}function af(a){this.stylesheets.add(a)}
 function bf(a,b,c){if(b=a.onHeaders){var d=a.headers;if(d){var e=d.preconnects;d.fontPreloads&&(e&&(e+=", "),e+=d.fontPreloads);d.highImagePreloads&&(e&&(e+=", "),e+=d.highImagePreloads);if(!c){c=a.styles.values();var f=c.next();a:for(;0<d.remainingCapacity&&!f.done;f=c.next()){f=f.value.sheets.values();for(var g=f.next();0<d.remainingCapacity&&!g.done;g=f.next()){var h=g.value;g=h.props;var l=g.href;h=h.props;h=Dc(h.href,"style",{crossOrigin:h.crossOrigin,integrity:h.integrity,nonce:h.nonce,type:h.type,
@@ -106,8 +106,8 @@ function Ef(a,b){if(a!==b){a.context._currentValue=a.parentValue;a=a.parent;var
 function Gf(a){var b=a.parent;null!==b&&Gf(b);a.context._currentValue=a.value}function Hf(a,b){a.context._currentValue=a.parentValue;a=a.parent;if(null===a)throw Error("The depth must equal at least at zero before reaching the root. This is a bug in React.");a.depth===b.depth?Ef(a,b):Hf(a,b)}
 function If(a,b){var c=b.parent;if(null===c)throw Error("The depth must equal at least at zero before reaching the root. This is a bug in React.");a.depth===c.depth?Ef(a,c):If(a,c);b.context._currentValue=b.value}function Jf(a){var b=Df;b!==a&&(null===b?Gf(a):null===a?Ff(b):b.depth===a.depth?Ef(b,a):b.depth>a.depth?Hf(b,a):If(b,a),Df=a)}
 var Kf={isMounted:function(){return!1},enqueueSetState:function(a,b){a=a._reactInternals;null!==a.queue&&a.queue.push(b)},enqueueReplaceState:function(a,b){a=a._reactInternals;a.replace=!0;a.queue=[b]},enqueueForceUpdate:function(){}};
-function Lf(a,b,c,d){var e=void 0!==a.state?a.state:null;a.updater=Kf;a.props=c;a.state=e;var f={queue:[],replace:!1};a._reactInternals=f;var g=b.contextType;a.context="object"===typeof g&&null!==g?g._currentValue:d;g=b.getDerivedStateFromProps;"function"===typeof g&&(g=g(c,e),e=null===g||void 0===g?e:z({},e,g),a.state=e);if("function"!==typeof b.getDerivedStateFromProps&&"function"!==typeof a.getSnapshotBeforeUpdate&&("function"===typeof a.UNSAFE_componentWillMount||"function"===typeof a.componentWillMount))if(b=
-a.state,"function"===typeof a.componentWillMount&&a.componentWillMount(),"function"===typeof a.UNSAFE_componentWillMount&&a.UNSAFE_componentWillMount(),b!==a.state&&Kf.enqueueReplaceState(a,a.state,null),null!==f.queue&&0<f.queue.length)if(b=f.queue,g=f.replace,f.queue=null,f.replace=!1,g&&1===b.length)a.state=b[0];else{f=g?b[0]:a.state;e=!0;for(g=g?1:0;g<b.length;g++){var h=b[g];h="function"===typeof h?h.call(a,f,c,d):h;null!=h&&(e?(e=!1,f=z({},f,h)):z(f,h))}a.state=f}else f.queue=null}
+function Lf(a,b,c,d){var e=void 0!==a.state?a.state:null;a.updater=Kf;a.props=c;a.state=e;var f={queue:[],replace:!1};a._reactInternals=f;var g=b.contextType;a.context="object"===typeof g&&null!==g?g._currentValue:d;g=b.getDerivedStateFromProps;"function"===typeof g&&(g=g(c,e),e=null===g||void 0===g?e:x({},e,g),a.state=e);if("function"!==typeof b.getDerivedStateFromProps&&"function"!==typeof a.getSnapshotBeforeUpdate&&("function"===typeof a.UNSAFE_componentWillMount||"function"===typeof a.componentWillMount))if(b=
+a.state,"function"===typeof a.componentWillMount&&a.componentWillMount(),"function"===typeof a.UNSAFE_componentWillMount&&a.UNSAFE_componentWillMount(),b!==a.state&&Kf.enqueueReplaceState(a,a.state,null),null!==f.queue&&0<f.queue.length)if(b=f.queue,g=f.replace,f.queue=null,f.replace=!1,g&&1===b.length)a.state=b[0];else{f=g?b[0]:a.state;e=!0;for(g=g?1:0;g<b.length;g++){var h=b[g];h="function"===typeof h?h.call(a,f,c,d):h;null!=h&&(e?(e=!1,f=x({},f,h)):x(f,h))}a.state=f}else f.queue=null}
 var Mf={id:1,overflow:""};function Nf(a,b,c){var d=a.id;a=a.overflow;var e=32-Of(d)-1;d&=~(1<<e);c+=1;var f=32-Of(b)+e;if(30<f){var g=e-e%5;f=(d&(1<<g)-1).toString(32);d>>=g;e-=g;return{id:1<<32-Of(b)+e|c<<e|d,overflow:f+a}}return{id:1<<f|c<<e|d,overflow:a}}var Of=Math.clz32?Math.clz32:Pf,Qf=Math.log,Rf=Math.LN2;function Pf(a){a>>>=0;return 0===a?32:31-(Qf(a)/Rf|0)|0}var Sf=Error("Suspense Exception: This is not a real error! It's an implementation detail of `use` to interrupt the current render. You must either rethrow it immediately, or move the `use` call outside of the `try/catch` block. Capturing without rethrowing will lead to unexpected behavior.\n\nTo handle async errors, wrap your component in an error boundary, or call the promise's `.catch` method and pass the result to `use`");
 function Tf(){}function Uf(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(Tf,Tf),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;default:if("string"!==typeof b.status)switch(a=b,a.status="pending",a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}}),b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;}Vf=b;throw Sf;}}var Vf=null;
 function Wf(){if(null===Vf)throw Error("Expected a suspended thenable. This is a bug in React. Please file an issue.");var a=Vf;Vf=null;return a}function Xf(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var Yf="function"===typeof Object.is?Object.is:Xf,Zf=null,$f=null,ag=null,bg=null,cg=null,W=null,dg=!1,eg=!1,fg=0,gg=0,hg=-1,ig=0,jg=null,kg=null,lg=0;
@@ -120,70 +120,72 @@ function yg(a,b,c){if(void 0!==a)return"p"+a;a=JSON.stringify([b,null,c]);b=ca.c
 var Dg={readContext:function(a){return a._currentValue},use:function(a){if(null!==a&&"object"===typeof a){if("function"===typeof a.then)return zg(a);if(a.$$typeof===kf||a.$$typeof===lf)return a._currentValue}throw Error("An unsupported type was passed to use(): "+String(a));},useContext:function(a){mg();return a._currentValue},useMemo:vg,useReducer:tg,useRef:function(a){Zf=mg();W=og();var b=W.memoizedState;return null===b?(a={current:a},W.memoizedState=a):b},useState:function(a){return tg(sg,a)},
 useInsertionEffect:Bg,useLayoutEffect:Bg,useCallback:function(a,b){return vg(function(){return a},b)},useImperativeHandle:Bg,useEffect:Bg,useDebugValue:Bg,useDeferredValue:function(a){mg();return a},useTransition:function(){mg();return[!1,wg]},useId:function(){var a=$f.treeContext;var b=a.overflow;a=a.id;a=(a&~(1<<32-Of(a)-1)).toString(32)+b;var c=Cg;if(null===c)throw Error("Invalid hook call. Hooks can only be called inside of the body of a function component.");b=fg++;a=":"+c.idPrefix+"R"+a;0<b&&
 (a+="H"+b.toString(32));return a+":"},useSyncExternalStore:function(a,b,c){if(void 0===c)throw Error("Missing getServerSnapshot, which is required for server-rendered content. Will revert to client rendering.");return c()},useCacheRefresh:function(){return Ag},useHostTransitionStatus:function(){mg();return Va},useOptimistic:function(a){mg();return[a,xg]},useFormState:function(a,b,c){mg();var d=gg++,e=ag;if("function"===typeof a.$$FORM_ACTION){var f=null,g=bg;e=e.formState;var h=a.$$IS_SIGNATURE_EQUAL;
-if(null!==e&&"function"===typeof h){var l=e[1];h.call(a,e[2],e[3])&&(f=yg(c,g,d),l===f&&(hg=d,b=e[0]))}var n=a.bind(null,b);a=function(r){n(r)};"function"===typeof n.$$FORM_ACTION&&(a.$$FORM_ACTION=function(r){r=n.$$FORM_ACTION(r);void 0!==c&&(c+="",r.action=c);var q=r.data;q&&(null===f&&(f=yg(c,g,d)),q.append("$ACTION_KEY",f));return r});return[b,a]}var p=a.bind(null,b);return[b,function(r){p(r)}]}},Cg=null,Eg={getCacheSignal:function(){throw Error("Not implemented.");},getCacheForType:function(){throw Error("Not implemented.");
+if(null!==e&&"function"===typeof h){var l=e[1];h.call(a,e[2],e[3])&&(f=yg(c,g,d),l===f&&(hg=d,b=e[0]))}var n=a.bind(null,b);a=function(r){n(r)};"function"===typeof n.$$FORM_ACTION&&(a.$$FORM_ACTION=function(r){r=n.$$FORM_ACTION(r);void 0!==c&&(c+="",r.action=c);var p=r.data;p&&(null===f&&(f=yg(c,g,d)),p.append("$ACTION_KEY",f));return r});return[b,a]}var q=a.bind(null,b);return[b,function(r){q(r)}]}},Cg=null,Eg={getCacheSignal:function(){throw Error("Not implemented.");},getCacheForType:function(){throw Error("Not implemented.");
 }},Fg=Ua.ReactCurrentDispatcher,Gg=Ua.ReactCurrentCache;function Hg(a){console.error(a);return null}function Ig(){}var Jg=null;function Ue(){if(Jg)return Jg;var a=cf.getStore();return a?a:null}function Kg(a,b){a.pingedTasks.push(b);1===a.pingedTasks.length&&(a.flushScheduled=null!==a.destination,setImmediate(function(){return Lg(a)}))}
 function Mg(a,b){return{status:0,rootSegmentID:-1,parentFlushed:!1,pendingTasks:0,completedSegments:[],byteSize:0,fallbackAbortableTasks:b,errorDigest:null,resources:{styles:new Set,stylesheets:new Set},trackedContentKeyPath:null,trackedFallbackNode:null}}
-function Ng(a,b,c,d,e,f,g,h,l,n,p,r){a.allPendingTasks++;null===e?a.pendingRootTasks++:e.pendingTasks++;var q={replay:null,node:c,childIndex:d,ping:function(){return Kg(a,q)},blockedBoundary:e,blockedSegment:f,abortSet:g,keyPath:h,formatContext:l,legacyContext:n,context:p,treeContext:r,thenableState:b};g.add(q);return q}
-function Og(a,b,c,d,e,f,g,h,l,n,p,r){a.allPendingTasks++;null===f?a.pendingRootTasks++:f.pendingTasks++;c.pendingTasks++;var q={replay:c,node:d,childIndex:e,ping:function(){return Kg(a,q)},blockedBoundary:f,blockedSegment:null,abortSet:g,keyPath:h,formatContext:l,legacyContext:n,context:p,treeContext:r,thenableState:b};g.add(q);return q}function Pg(a,b,c,d,e,f){return{status:0,id:-1,index:b,parentFlushed:!1,chunks:[],children:[],parentFormatContext:d,boundary:c,lastPushedText:e,textEmbedded:f}}
+function Ng(a,b,c,d,e,f,g,h,l,n,q,r){a.allPendingTasks++;null===e?a.pendingRootTasks++:e.pendingTasks++;var p={replay:null,node:c,childIndex:d,ping:function(){return Kg(a,p)},blockedBoundary:e,blockedSegment:f,abortSet:g,keyPath:h,formatContext:l,legacyContext:n,context:q,treeContext:r,thenableState:b};g.add(p);return p}
+function Og(a,b,c,d,e,f,g,h,l,n,q,r){a.allPendingTasks++;null===f?a.pendingRootTasks++:f.pendingTasks++;c.pendingTasks++;var p={replay:c,node:d,childIndex:e,ping:function(){return Kg(a,p)},blockedBoundary:f,blockedSegment:null,abortSet:g,keyPath:h,formatContext:l,legacyContext:n,context:q,treeContext:r,thenableState:b};g.add(p);return p}function Pg(a,b,c,d,e,f){return{status:0,id:-1,index:b,parentFlushed:!1,chunks:[],children:[],parentFormatContext:d,boundary:c,lastPushedText:e,textEmbedded:f}}
 function X(a,b){a=a.onError(b);if(null!=a&&"string"!==typeof a)throw Error('onError returned something with a type other than "string". onError should return a string and may return null or undefined but must not return anything else. It received something of type "'+typeof a+'" instead');return a}function Qg(a,b){var c=a.onShellError;c(b);c=a.onFatalError;c(b);null!==a.destination?(a.status=2,a.destination.destroy(b)):(a.status=1,a.fatalError=b)}
-function Rg(a,b,c,d,e){var f=d.render(),g=e.childContextTypes;if(null!==g&&void 0!==g){c=b.legacyContext;if("function"!==typeof d.getChildContext)e=c;else{d=d.getChildContext();for(var h in d)if(!(h in g))throw Error((Af(e)||"Unknown")+'.getChildContext(): key "'+h+'" is not defined in childContextTypes.');e=z({},c,d)}b.legacyContext=e;Y(a,b,null,f,-1);b.legacyContext=c}else e=b.keyPath,b.keyPath=c,Y(a,b,null,f,-1),b.keyPath=e}
-function Sg(a,b,c,d,e,f,g){var h=!1;if(0!==f&&null!==a.formState){var l=b.blockedSegment;if(null!==l){h=!0;l=l.chunks;for(var n=0;n<f;n++)n===g?l.push(gc):l.push(hc)}}f=b.keyPath;b.keyPath=c;e?(c=b.treeContext,b.treeContext=Nf(c,1,0),Tg(a,b,d,-1),b.treeContext=c):h?Tg(a,b,d,-1):Y(a,b,null,d,-1);b.keyPath=f}function Ug(a,b){if(a&&a.defaultProps){b=z({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}
+function Rg(a,b,c,d,e){var f=d.render(),g=e.childContextTypes;if(null!==g&&void 0!==g){c=b.legacyContext;if("function"!==typeof d.getChildContext)e=c;else{d=d.getChildContext();for(var h in d)if(!(h in g))throw Error((Af(e)||"Unknown")+'.getChildContext(): key "'+h+'" is not defined in childContextTypes.');e=x({},c,d)}b.legacyContext=e;Y(a,b,null,f,-1);b.legacyContext=c}else e=b.keyPath,b.keyPath=c,Y(a,b,null,f,-1),b.keyPath=e}
+function Sg(a,b,c,d,e,f,g){var h=!1;if(0!==f&&null!==a.formState){var l=b.blockedSegment;if(null!==l){h=!0;l=l.chunks;for(var n=0;n<f;n++)n===g?l.push(gc):l.push(hc)}}f=b.keyPath;b.keyPath=c;e?(c=b.treeContext,b.treeContext=Nf(c,1,0),Tg(a,b,d,-1),b.treeContext=c):h?Tg(a,b,d,-1):Y(a,b,null,d,-1);b.keyPath=f}function Ug(a,b){if(a&&a.defaultProps){b=x({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}
 function Vg(a,b,c,d,e,f,g){if("function"===typeof e)if(e.prototype&&e.prototype.isReactComponent){d=Cf(e,b.legacyContext);var h=e.contextType;h=new e(f,"object"===typeof h&&null!==h?h._currentValue:d);Lf(h,e,f,d);Rg(a,b,c,h,e)}else{h=Cf(e,b.legacyContext);Zf={};$f=b;ag=a;bg=c;gg=fg=0;hg=-1;ig=0;jg=d;d=e(f,h);d=pg(e,f,d,h);g=0!==fg;var l=gg,n=hg;"object"===typeof d&&null!==d&&"function"===typeof d.render&&void 0===d.$$typeof?(Lf(d,e,f,h),Rg(a,b,c,d,e)):Sg(a,b,c,d,g,l,n)}else if("string"===typeof e)if(d=
 b.blockedSegment,null===d)d=f.children,h=b.formatContext,g=b.keyPath,b.formatContext=Mb(h,e,f),b.keyPath=c,Tg(a,b,d,-1),b.formatContext=h,b.keyPath=g;else{g=Cc(d.chunks,e,f,a.resumableState,a.renderState,b.formatContext,d.lastPushedText);d.lastPushedText=!1;h=b.formatContext;l=b.keyPath;b.formatContext=Mb(h,e,f);b.keyPath=c;Tg(a,b,g,-1);b.formatContext=h;b.keyPath=l;a:{b=d.chunks;a=a.resumableState;switch(e){case "title":case "style":case "script":case "area":case "base":case "br":case "col":case "embed":case "hr":case "img":case "input":case "keygen":case "link":case "meta":case "param":case "source":case "track":case "wbr":break a;
 case "body":if(1>=h.insertionMode){a.hasBody=!0;break a}break;case "html":if(0===h.insertionMode){a.hasHtml=!0;break a}}b.push(mc(e))}d.lastPushedText=!1}else{switch(e){case wf:case uf:case gf:case hf:case ff:e=b.keyPath;b.keyPath=c;Y(a,b,null,f.children,-1);b.keyPath=e;return;case vf:"hidden"!==f.mode&&(e=b.keyPath,b.keyPath=c,Y(a,b,null,f.children,-1),b.keyPath=e);return;case of:e=b.keyPath;b.keyPath=c;Y(a,b,null,f.children,-1);b.keyPath=e;return;case tf:throw Error("ReactDOMServer does not yet support scope components.");
-case nf:a:if(null!==b.replay){e=b.keyPath;b.keyPath=c;c=f.children;try{Tg(a,b,c,-1)}finally{b.keyPath=e}}else{n=b.keyPath;e=b.blockedBoundary;var p=b.blockedSegment;d=f.fallback;var r=f.children;f=new Set;g=Mg(a,f);null!==a.trackedPostpones&&(g.trackedContentKeyPath=c);l=Pg(a,p.chunks.length,g,b.formatContext,!1,!1);p.children.push(l);p.lastPushedText=!1;var q=Pg(a,0,null,b.formatContext,!1,!1);q.parentFlushed=!0;b.blockedBoundary=g;b.blockedSegment=q;a.renderState.boundaryResources=g.resources;b.keyPath=
-c;try{if(Tg(a,b,r,-1),q.lastPushedText&&q.textEmbedded&&q.chunks.push(Nb),q.status=1,Wg(g,q),0===g.pendingTasks&&0===g.status){g.status=1;break a}}catch(x){q.status=4,g.status=4,h=X(a,x),g.errorDigest=h}finally{a.renderState.boundaryResources=e?e.resources:null,b.blockedBoundary=e,b.blockedSegment=p,b.keyPath=n}h=[c[0],"Suspense Fallback",c[2]];n=a.trackedPostpones;null!==n&&(p=[h[1],h[2],[],null],n.workingMap.set(h,p),5===g.status?n.workingMap.get(c)[4]=p:g.trackedFallbackNode=p);b=Ng(a,null,d,-1,
+case nf:a:if(null!==b.replay){e=b.keyPath;b.keyPath=c;c=f.children;try{Tg(a,b,c,-1)}finally{b.keyPath=e}}else{n=b.keyPath;e=b.blockedBoundary;var q=b.blockedSegment;d=f.fallback;var r=f.children;f=new Set;g=Mg(a,f);null!==a.trackedPostpones&&(g.trackedContentKeyPath=c);l=Pg(a,q.chunks.length,g,b.formatContext,!1,!1);q.children.push(l);q.lastPushedText=!1;var p=Pg(a,0,null,b.formatContext,!1,!1);p.parentFlushed=!0;b.blockedBoundary=g;b.blockedSegment=p;a.renderState.boundaryResources=g.resources;b.keyPath=
+c;try{if(Tg(a,b,r,-1),p.lastPushedText&&p.textEmbedded&&p.chunks.push(Nb),p.status=1,Wg(g,p),0===g.pendingTasks&&0===g.status){g.status=1;break a}}catch(A){p.status=4,g.status=4,h=X(a,A),g.errorDigest=h}finally{a.renderState.boundaryResources=e?e.resources:null,b.blockedBoundary=e,b.blockedSegment=q,b.keyPath=n}h=[c[0],"Suspense Fallback",c[2]];n=a.trackedPostpones;null!==n&&(q=[h[1],h[2],[],null],n.workingMap.set(h,q),5===g.status?n.workingMap.get(c)[4]=q:g.trackedFallbackNode=q);b=Ng(a,null,d,-1,
 e,l,f,h,b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}return}if("object"===typeof e&&null!==e)switch(e.$$typeof){case mf:e=e.render;Zf={};$f=b;ag=a;bg=c;gg=fg=0;hg=-1;ig=0;jg=d;d=e(f,g);f=pg(e,f,d,g);Sg(a,b,c,f,0!==fg,gg,hg);return;case pf:e=e.type;f=Ug(e,f);Vg(a,b,c,d,e,f,g);return;case jf:h=f.children;d=b.keyPath;e=e._context;f=f.value;g=e._currentValue;e._currentValue=f;l=Df;Df=f={parent:l,depth:null===l?0:l.depth+1,context:e,parentValue:g,value:f};b.context=f;
 b.keyPath=c;Y(a,b,null,h,-1);a=Df;if(null===a)throw Error("Tried to pop a Context at the root of the app. This is a bug in React.");c=a.parentValue;a.context._currentValue=c===yf?a.context._defaultValue:c;a=Df=a.parent;b.context=a;b.keyPath=d;return;case kf:f=f.children;f=f(e._currentValue);e=b.keyPath;b.keyPath=c;Y(a,b,null,f,-1);b.keyPath=e;return;case sf:h=e._init;e=h(e._payload);f=Ug(e,f);Vg(a,b,c,d,e,f,void 0);return}throw Error("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: "+
 ((null==e?e:typeof e)+"."));}}function Xg(a,b,c,d,e){var f=b.replay,g=b.blockedBoundary,h=Pg(a,0,null,b.formatContext,!1,!1);h.id=c;h.parentFlushed=!0;try{b.replay=null,b.blockedSegment=h,Tg(a,b,d,e),h.status=1,null===g?a.completedRootSegment=h:(Wg(g,h),g.parentFlushed&&a.partialBoundaries.push(g))}finally{b.replay=f,b.blockedSegment=null}}
-function Y(a,b,c,d,e){if(null!==b.replay&&"number"===typeof b.replay.slots)Xg(a,b,b.replay.slots,d,e);else{b.node=d;b.childIndex=e;if("object"===typeof d&&null!==d){switch(d.$$typeof){case df:var f=d.type,g=d.key,h=d.props,l=d.ref,n=Af(f),p=null==g?-1===e?0:e:g;g=[b.keyPath,n,p];if(null!==b.replay)a:{var r=b.replay;e=r.nodes;for(d=0;d<e.length;d++){var q=e[d];if(p===q[1]){if(4===q.length){if(null!==n&&n!==q[0])throw Error("Expected the resume to render <"+q[0]+"> in this slot but instead it rendered <"+
-n+">. The tree doesn't match so React will fallback to client rendering.");n=q[2];q=q[3];p=b.node;b.replay={nodes:n,slots:q,pendingTasks:1};try{Vg(a,b,g,c,f,h,l);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--}catch(H){if("object"===typeof H&&null!==H&&(H===Sf||"function"===typeof H.then))throw b.node===p&&(b.replay=r),H;b.replay.pendingTasks--;
-g=a;a=b.blockedBoundary;c=H;h=X(g,c);Yg(g,a,n,q,c,h)}b.replay=r}else{if(f!==nf)throw Error("Expected the resume to render <Suspense> in this slot but instead it rendered <"+(Af(f)||"Unknown")+">. The tree doesn't match so React will fallback to client rendering.");b:{r=void 0;c=q[5];f=q[2];l=q[3];n=null===q[4]?[]:q[4][2];q=null===q[4]?null:q[4][3];p=b.keyPath;var x=b.replay,v=b.blockedBoundary,Z=h.children;h=h.fallback;var t=new Set,C=Mg(a,t);C.parentFlushed=!0;C.rootSegmentID=c;b.blockedBoundary=
+function Y(a,b,c,d,e){if(null!==b.replay&&"number"===typeof b.replay.slots)Xg(a,b,b.replay.slots,d,e);else{b.node=d;b.childIndex=e;if("object"===typeof d&&null!==d){switch(d.$$typeof){case df:var f=d.type,g=d.key,h=d.props,l=d.ref,n=Af(f),q=null==g?-1===e?0:e:g;g=[b.keyPath,n,q];if(null!==b.replay)a:{var r=b.replay;e=r.nodes;for(d=0;d<e.length;d++){var p=e[d];if(q===p[1]){if(4===p.length){if(null!==n&&n!==p[0])throw Error("Expected the resume to render <"+p[0]+"> in this slot but instead it rendered <"+
+n+">. The tree doesn't match so React will fallback to client rendering.");n=p[2];p=p[3];q=b.node;b.replay={nodes:n,slots:p,pendingTasks:1};try{Vg(a,b,g,c,f,h,l);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--}catch(H){if("object"===typeof H&&null!==H&&(H===Sf||"function"===typeof H.then))throw b.node===q&&(b.replay=r),H;b.replay.pendingTasks--;
+g=a;a=b.blockedBoundary;c=H;h=X(g,c);Yg(g,a,n,p,c,h)}b.replay=r}else{if(f!==nf)throw Error("Expected the resume to render <Suspense> in this slot but instead it rendered <"+(Af(f)||"Unknown")+">. The tree doesn't match so React will fallback to client rendering.");b:{r=void 0;c=p[5];f=p[2];l=p[3];n=null===p[4]?[]:p[4][2];p=null===p[4]?null:p[4][3];q=b.keyPath;var A=b.replay,B=b.blockedBoundary,Z=h.children;h=h.fallback;var t=new Set,C=Mg(a,t);C.parentFlushed=!0;C.rootSegmentID=c;b.blockedBoundary=
 C;b.replay={nodes:f,slots:l,pendingTasks:1};a.renderState.boundaryResources=C.resources;try{Tg(a,b,Z,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--;if(0===C.pendingTasks&&0===C.status){C.status=1;a.completedBoundaries.push(C);break b}}catch(H){C.status=4,r=X(a,H),C.errorDigest=r,b.replay.pendingTasks--,a.clientRenderedBoundaries.push(C)}finally{a.renderState.boundaryResources=
-v?v.resources:null,b.blockedBoundary=v,b.replay=x,b.keyPath=p}b=Og(a,null,{nodes:n,slots:q,pendingTasks:0},h,-1,v,t,[g[0],"Suspense Fallback",g[2]],b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}}e.splice(d,1);break a}}}else Vg(a,b,g,c,f,h,l);return;case ef:throw Error("Portals are not currently supported by the server renderer. Render them conditionally so that they only appear on the client render.");case sf:h=d._init;d=h(d._payload);Y(a,b,null,d,e);return}if(Ta(d)){Zg(a,
+B?B.resources:null,b.blockedBoundary=B,b.replay=A,b.keyPath=q}b=Og(a,null,{nodes:n,slots:p,pendingTasks:0},h,-1,B,t,[g[0],"Suspense Fallback",g[2]],b.formatContext,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}}e.splice(d,1);break a}}}else Vg(a,b,g,c,f,h,l);return;case ef:throw Error("Portals are not currently supported by the server renderer. Render them conditionally so that they only appear on the client render.");case sf:h=d._init;d=h(d._payload);Y(a,b,null,d,e);return}if(Ta(d)){Zg(a,
 b,d,e);return}null===d||"object"!==typeof d?h=null:(h=zf&&d[zf]||d["@@iterator"],h="function"===typeof h?h:null);if(h&&(h=h.call(d))){d=h.next();if(!d.done){g=[];do g.push(d.value),d=h.next();while(!d.done);Zg(a,b,g,e)}return}if("function"===typeof d.then)return Y(a,b,null,zg(d),e);if(d.$$typeof===kf||d.$$typeof===lf)return Y(a,b,null,d._currentValue,e);e=Object.prototype.toString.call(d);throw Error("Objects are not valid as a React child (found: "+("[object Object]"===e?"object with keys {"+Object.keys(d).join(", ")+
 "}":e)+"). If you meant to render a collection of children, use an array instead.");}"string"===typeof d?(e=b.blockedSegment,null!==e&&(e.lastPushedText=Ob(e.chunks,d,a.renderState,e.lastPushedText))):"number"===typeof d&&(e=b.blockedSegment,null!==e&&(e.lastPushedText=Ob(e.chunks,""+d,a.renderState,e.lastPushedText)))}}
 function Zg(a,b,c,d){var e=b.keyPath;if(-1!==d&&(b.keyPath=[b.keyPath,"Fragment",d],null!==b.replay)){for(var f=b.replay,g=f.nodes,h=0;h<g.length;h++){var l=g[h];if(l[1]===d){d=l[2];l=l[3];b.replay={nodes:d,slots:l,pendingTasks:1};try{Zg(a,b,c,-1);if(1===b.replay.pendingTasks&&0<b.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");b.replay.pendingTasks--}catch(r){if("object"===typeof r&&
-null!==r&&(r===Sf||"function"===typeof r.then))throw r;b.replay.pendingTasks--;c=a;var n=b.blockedBoundary,p=r;a=X(c,p);Yg(c,n,d,l,p,a)}b.replay=f;g.splice(h,1);break}}b.keyPath=e;return}f=b.treeContext;g=c.length;if(null!==b.replay&&(h=b.replay.slots,null!==h&&"object"===typeof h)){for(d=0;d<g;d++)l=c[d],b.treeContext=Nf(f,g,d),n=h[d],"number"===typeof n?(Xg(a,b,n,l,d),delete h[d]):Tg(a,b,l,d);b.treeContext=f;b.keyPath=e;return}for(h=0;h<g;h++)d=c[h],b.treeContext=Nf(f,g,h),Tg(a,b,d,h);b.treeContext=
+null!==r&&(r===Sf||"function"===typeof r.then))throw r;b.replay.pendingTasks--;c=a;var n=b.blockedBoundary,q=r;a=X(c,q);Yg(c,n,d,l,q,a)}b.replay=f;g.splice(h,1);break}}b.keyPath=e;return}f=b.treeContext;g=c.length;if(null!==b.replay&&(h=b.replay.slots,null!==h&&"object"===typeof h)){for(d=0;d<g;d++)l=c[d],b.treeContext=Nf(f,g,d),n=h[d],"number"===typeof n?(Xg(a,b,n,l,d),delete h[d]):Tg(a,b,l,d);b.treeContext=f;b.keyPath=e;return}for(h=0;h<g;h++)d=c[h],b.treeContext=Nf(f,g,h),Tg(a,b,d,h);b.treeContext=
 f;b.keyPath=e}
-function Tg(a,b,c,d){var e=b.formatContext,f=b.legacyContext,g=b.context,h=b.keyPath,l=b.treeContext,n=b.blockedSegment;if(null===n)try{return Y(a,b,null,c,d)}catch(q){if(qg(),c=q===Sf?Wf():q,"object"===typeof c&&null!==c&&"function"===typeof c.then){d=rg();a=Og(a,d,b.replay,b.node,b.childIndex,b.blockedBoundary,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=l;Jf(g);return}}else{var p=
-n.children.length,r=n.chunks.length;try{return Y(a,b,null,c,d)}catch(q){if(qg(),n.children.length=p,n.chunks.length=r,c=q===Sf?Wf():q,"object"===typeof c&&null!==c&&"function"===typeof c.then){d=rg();n=b.blockedSegment;p=Pg(a,n.chunks.length,null,b.formatContext,n.lastPushedText,!0);n.children.push(p);n.lastPushedText=!1;a=Ng(a,d,b.node,b.childIndex,b.blockedBoundary,p,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=
+function Tg(a,b,c,d){var e=b.formatContext,f=b.legacyContext,g=b.context,h=b.keyPath,l=b.treeContext,n=b.blockedSegment;if(null===n)try{return Y(a,b,null,c,d)}catch(p){if(qg(),c=p===Sf?Wf():p,"object"===typeof c&&null!==c&&"function"===typeof c.then){d=rg();a=Og(a,d,b.replay,b.node,b.childIndex,b.blockedBoundary,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=l;Jf(g);return}}else{var q=
+n.children.length,r=n.chunks.length;try{return Y(a,b,null,c,d)}catch(p){if(qg(),n.children.length=q,n.chunks.length=r,c=p===Sf?Wf():p,"object"===typeof c&&null!==c&&"function"===typeof c.then){d=rg();n=b.blockedSegment;q=Pg(a,n.chunks.length,null,b.formatContext,n.lastPushedText,!0);n.children.push(q);n.lastPushedText=!1;a=Ng(a,d,b.node,b.childIndex,b.blockedBoundary,q,b.abortSet,b.keyPath,b.formatContext,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.formatContext=e;b.legacyContext=
 f;b.context=g;b.keyPath=h;b.treeContext=l;Jf(g);return}}}b.formatContext=e;b.legacyContext=f;b.context=g;b.keyPath=h;b.treeContext=l;Jf(g);throw c;}function $g(a){var b=a.blockedBoundary;a=a.blockedSegment;null!==a&&(a.status=3,ah(this,b,a))}
-function Yg(a,b,c,d,e,f){for(var g=0;g<c.length;g++){var h=c[g];if(4===h.length)Yg(a,b,h[2],h[3],e,f);else{h=h[5];var l=a,n=f,p=Mg(l,new Set);p.parentFlushed=!0;p.rootSegmentID=h;p.status=4;p.errorDigest=n;p.parentFlushed&&l.clientRenderedBoundaries.push(p)}}c.length=0;if(null!==d){if(null===b)throw Error("We should not have any resumable nodes in the shell. This is a bug in React.");4!==b.status&&(b.status=4,b.errorDigest=f,b.parentFlushed&&a.clientRenderedBoundaries.push(b));if("object"===typeof d)for(var r in d)delete d[r]}}
+function Yg(a,b,c,d,e,f){for(var g=0;g<c.length;g++){var h=c[g];if(4===h.length)Yg(a,b,h[2],h[3],e,f);else{h=h[5];var l=a,n=f,q=Mg(l,new Set);q.parentFlushed=!0;q.rootSegmentID=h;q.status=4;q.errorDigest=n;q.parentFlushed&&l.clientRenderedBoundaries.push(q)}}c.length=0;if(null!==d){if(null===b)throw Error("We should not have any resumable nodes in the shell. This is a bug in React.");4!==b.status&&(b.status=4,b.errorDigest=f,b.parentFlushed&&a.clientRenderedBoundaries.push(b));if("object"===typeof d)for(var r in d)delete d[r]}}
 function bh(a,b,c){var d=a.blockedBoundary,e=a.blockedSegment;null!==e&&(e.status=3);if(null===d){if(1!==b.status&&2!==b.status){a=a.replay;if(null===a){X(b,c);Qg(b,c);return}a.pendingTasks--;0===a.pendingTasks&&0<a.nodes.length&&(d=X(b,c),Yg(b,null,a.nodes,a.slots,c,d));b.pendingRootTasks--;0===b.pendingRootTasks&&ch(b)}}else d.pendingTasks--,4!==d.status&&(d.status=4,d.errorDigest=X(b,c),d.parentFlushed&&b.clientRenderedBoundaries.push(d)),d.fallbackAbortableTasks.forEach(function(f){return bh(f,
 b,c)}),d.fallbackAbortableTasks.clear();b.allPendingTasks--;0===b.allPendingTasks&&dh(b)}function ch(a){null===a.trackedPostpones&&bf(a.renderState,a.resumableState,!0);a.onShellError=Ig;a=a.onShellReady;a()}function dh(a){bf(a.renderState,a.resumableState,null===a.trackedPostpones?!0:null===a.completedRootSegment||5!==a.completedRootSegment.status);a=a.onAllReady;a()}
 function Wg(a,b){if(0===b.chunks.length&&1===b.children.length&&null===b.children[0].boundary){var c=b.children[0];c.id=b.id;c.parentFlushed=!0;1===c.status&&Wg(a,c)}else a.completedSegments.push(b)}
 function ah(a,b,c){if(null===b){if(null!==c&&c.parentFlushed){if(null!==a.completedRootSegment)throw Error("There can only be one root segment. This is a bug in React.");a.completedRootSegment=c}a.pendingRootTasks--;0===a.pendingRootTasks&&ch(a)}else b.pendingTasks--,4!==b.status&&(0===b.pendingTasks?(0===b.status&&(b.status=1),null!==c&&c.parentFlushed&&1===c.status&&Wg(b,c),b.parentFlushed&&a.completedBoundaries.push(b),1===b.status&&(b.fallbackAbortableTasks.forEach($g,a),b.fallbackAbortableTasks.clear())):
 null!==c&&c.parentFlushed&&1===c.status&&(Wg(b,c),1===b.completedSegments.length&&b.parentFlushed&&a.partialBoundaries.push(b)));a.allPendingTasks--;0===a.allPendingTasks&&dh(a)}
-function Lg(a){if(2!==a.status){var b=Df,c=Fg.current;Fg.current=Dg;var d=Gg.current;Gg.current=Eg;var e=Jg;Jg=a;var f=Cg;Cg=a.resumableState;try{var g=a.pingedTasks,h;for(h=0;h<g.length;h++){var l=g[h],n=a,p=l.blockedBoundary;n.renderState.boundaryResources=p?p.resources:null;var r=l.blockedSegment;if(null===r){var q=n;if(0!==l.replay.pendingTasks){Jf(l.context);try{var x=l.thenableState;l.thenableState=null;Y(q,l,x,l.node,l.childIndex);if(1===l.replay.pendingTasks&&0<l.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");
-l.replay.pendingTasks--;l.abortSet.delete(l);ah(q,l.blockedBoundary,null)}catch(I){qg();var v=I===Sf?Wf():I;if("object"===typeof v&&null!==v&&"function"===typeof v.then){var Z=l.ping;v.then(Z,Z);l.thenableState=rg()}else{l.replay.pendingTasks--;l.abortSet.delete(l);n=void 0;var t=q,C=l.blockedBoundary,H=v,ka=l.replay.nodes,E=l.replay.slots;n=X(t,H);Yg(t,C,ka,E,H,n);q.pendingRootTasks--;0===q.pendingRootTasks&&ch(q);q.allPendingTasks--;0===q.allPendingTasks&&dh(q)}}finally{q.renderState.boundaryResources=
-null}}}else if(q=void 0,t=r,0===t.status){Jf(l.context);var U=t.children.length,F=t.chunks.length;try{var da=l.thenableState;l.thenableState=null;Y(n,l,da,l.node,l.childIndex);t.lastPushedText&&t.textEmbedded&&t.chunks.push(Nb);l.abortSet.delete(l);t.status=1;ah(n,l.blockedBoundary,t)}catch(I){qg();t.children.length=U;t.chunks.length=F;var S=I===Sf?Wf():I;if("object"===typeof S&&null!==S&&"function"===typeof S.then){var la=l.ping;S.then(la,la);l.thenableState=rg()}else{l.abortSet.delete(l);t.status=
-4;var P=l.blockedBoundary;q=X(n,S);null===P?Qg(n,S):(P.pendingTasks--,4!==P.status&&(P.status=4,P.errorDigest=q,P.parentFlushed&&n.clientRenderedBoundaries.push(P)));n.allPendingTasks--;0===n.allPendingTasks&&dh(n)}}finally{n.renderState.boundaryResources=null}}}g.splice(0,h);null!==a.destination&&eh(a,a.destination)}catch(I){X(a,I),Qg(a,I)}finally{Cg=f,Fg.current=c,Gg.current=d,c===Dg&&Jf(b),Jg=e}}}
-function fh(a,b,c){c.parentFlushed=!0;switch(c.status){case 0:c.id=a.nextSegmentId++;case 5:var d=c.id;c.lastPushedText=!1;c.textEmbedded=!1;a=a.renderState;u(b,Gc);u(b,a.placeholderPrefix);a=d.toString(16);u(b,a);return w(b,Hc);case 1:c.status=2;var e=!0;d=c.chunks;var f=0;c=c.children;for(var g=0;g<c.length;g++){for(e=c[g];f<e.index;f++)u(b,d[f]);e=gh(a,b,e)}for(;f<d.length-1;f++)u(b,d[f]);f<d.length&&(e=w(b,d[f]));return e;default:throw Error("Aborted, errored or already flushed boundaries should not be flushed again. This is a bug in React.");
+function Lg(a){if(2!==a.status){var b=Df,c=Fg.current;Fg.current=Dg;var d=Gg.current;Gg.current=Eg;var e=Jg;Jg=a;var f=Cg;Cg=a.resumableState;try{var g=a.pingedTasks,h;for(h=0;h<g.length;h++){var l=g[h],n=a,q=l.blockedBoundary;n.renderState.boundaryResources=q?q.resources:null;var r=l.blockedSegment;if(null===r){var p=n;if(0!==l.replay.pendingTasks){Jf(l.context);try{var A=l.thenableState;l.thenableState=null;Y(p,l,A,l.node,l.childIndex);if(1===l.replay.pendingTasks&&0<l.replay.nodes.length)throw Error("Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering.");
+l.replay.pendingTasks--;l.abortSet.delete(l);ah(p,l.blockedBoundary,null)}catch(I){qg();var B=I===Sf?Wf():I;if("object"===typeof B&&null!==B&&"function"===typeof B.then){var Z=l.ping;B.then(Z,Z);l.thenableState=rg()}else{l.replay.pendingTasks--;l.abortSet.delete(l);n=void 0;var t=p,C=l.blockedBoundary,H=B,ka=l.replay.nodes,E=l.replay.slots;n=X(t,H);Yg(t,C,ka,E,H,n);p.pendingRootTasks--;0===p.pendingRootTasks&&ch(p);p.allPendingTasks--;0===p.allPendingTasks&&dh(p)}}finally{p.renderState.boundaryResources=
+null}}}else if(p=void 0,t=r,0===t.status){Jf(l.context);var U=t.children.length,F=t.chunks.length;try{var da=l.thenableState;l.thenableState=null;Y(n,l,da,l.node,l.childIndex);t.lastPushedText&&t.textEmbedded&&t.chunks.push(Nb);l.abortSet.delete(l);t.status=1;ah(n,l.blockedBoundary,t)}catch(I){qg();t.children.length=U;t.chunks.length=F;var S=I===Sf?Wf():I;if("object"===typeof S&&null!==S&&"function"===typeof S.then){var la=l.ping;S.then(la,la);l.thenableState=rg()}else{l.abortSet.delete(l);t.status=
+4;var P=l.blockedBoundary;p=X(n,S);null===P?Qg(n,S):(P.pendingTasks--,4!==P.status&&(P.status=4,P.errorDigest=p,P.parentFlushed&&n.clientRenderedBoundaries.push(P)));n.allPendingTasks--;0===n.allPendingTasks&&dh(n)}}finally{n.renderState.boundaryResources=null}}}g.splice(0,h);null!==a.destination&&eh(a,a.destination)}catch(I){X(a,I),Qg(a,I)}finally{Cg=f,Fg.current=c,Gg.current=d,c===Dg&&Jf(b),Jg=e}}}
+function fh(a,b,c){c.parentFlushed=!0;switch(c.status){case 0:c.id=a.nextSegmentId++;case 5:var d=c.id;c.lastPushedText=!1;c.textEmbedded=!1;a=a.renderState;u(b,Gc);u(b,a.placeholderPrefix);a=d.toString(16);u(b,a);return v(b,Hc);case 1:c.status=2;var e=!0;d=c.chunks;var f=0;c=c.children;for(var g=0;g<c.length;g++){for(e=c[g];f<e.index;f++)u(b,d[f]);e=gh(a,b,e)}for(;f<d.length-1;f++)u(b,d[f]);f<d.length&&(e=v(b,d[f]));return e;default:throw Error("Aborted, errored or already flushed boundaries should not be flushed again. This is a bug in React.");
 }}
-function gh(a,b,c){var d=c.boundary;if(null===d)return fh(a,b,c);d.parentFlushed=!0;if(4===d.status)d=d.errorDigest,w(b,Lc),u(b,Nc),d&&(u(b,Pc),u(b,B(d)),u(b,Oc)),w(b,Qc),fh(a,b,c);else if(1!==d.status)0===d.status&&(d.rootSegmentID=a.nextSegmentId++),0<d.completedSegments.length&&a.partialBoundaries.push(d),Rc(b,a.renderState,d.rootSegmentID),fh(a,b,c);else if(d.byteSize>a.progressiveChunkSize)d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),Rc(b,a.renderState,d.rootSegmentID),fh(a,b,
-c);else{c=d.resources;var e=a.renderState.boundaryResources;e&&(c.styles.forEach($e,e),c.stylesheets.forEach(af,e));w(b,Ic);d=d.completedSegments;if(1!==d.length)throw Error("A previously unvisited boundary must have exactly one root segment. This is a bug in React.");gh(a,b,d[0])}return w(b,Mc)}function hh(a,b,c){md(b,a.renderState,c.parentFormatContext,c.id);gh(a,b,c);return nd(b,c.parentFormatContext)}
+function gh(a,b,c){var d=c.boundary;if(null===d)return fh(a,b,c);d.parentFlushed=!0;if(4===d.status)d=d.errorDigest,v(b,Lc),u(b,Nc),d&&(u(b,Pc),u(b,z(d)),u(b,Oc)),v(b,Qc),fh(a,b,c);else if(1!==d.status)0===d.status&&(d.rootSegmentID=a.nextSegmentId++),0<d.completedSegments.length&&a.partialBoundaries.push(d),Rc(b,a.renderState,d.rootSegmentID),fh(a,b,c);else if(d.byteSize>a.progressiveChunkSize)d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),Rc(b,a.renderState,d.rootSegmentID),fh(a,b,
+c);else{c=d.resources;var e=a.renderState.boundaryResources;e&&(c.styles.forEach($e,e),c.stylesheets.forEach(af,e));v(b,Ic);d=d.completedSegments;if(1!==d.length)throw Error("A previously unvisited boundary must have exactly one root segment. This is a bug in React.");gh(a,b,d[0])}return v(b,Mc)}function hh(a,b,c){md(b,a.renderState,c.parentFormatContext,c.id);gh(a,b,c);return nd(b,c.parentFormatContext)}
 function ih(a,b,c){a.renderState.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e<d.length;e++)jh(a,b,c,d[e]);d.length=0;De(b,c.resources,a.renderState);d=a.resumableState;a=a.renderState;e=c.rootSegmentID;c=c.resources;var f=a.stylesToHoist;a.stylesToHoist=!1;var g=0===d.streamingFormat;g?(u(b,a.startInlineScript),f?0===(d.instructions&2)?(d.instructions|=10,u(b,2048<Xd.length?Xd.slice():Xd)):0===(d.instructions&8)?(d.instructions|=8,u(b,Yd)):u(b,Zd):0===(d.instructions&2)?(d.instructions|=
-2,u(b,Vd)):u(b,Wd)):f?u(b,ee):u(b,de);d=e.toString(16);u(b,a.boundaryPrefix);u(b,d);g?u(b,$d):u(b,fe);u(b,a.segmentPrefix);u(b,d);f?g?(u(b,ae),Se(b,c)):(u(b,ge),Te(b,c)):g&&u(b,be);d=g?w(b,ce):w(b,rb);return Fc(b,a)&&d}
+2,u(b,Vd)):u(b,Wd)):f?u(b,ee):u(b,de);e=e.toString(16);u(b,a.boundaryPrefix);u(b,e);g?u(b,$d):u(b,fe);u(b,a.segmentPrefix);u(b,e);f?g?(u(b,ae),Se(b,c)):(u(b,ge),Te(b,c)):g&&u(b,be);c=g?v(b,ce):v(b,rb);return Fc(b,a,d)&&c}
 function jh(a,b,c,d){if(2===d.status)return!0;var e=d.id;if(-1===e){if(-1===(d.id=c.rootSegmentID))throw Error("A root segment ID must have been assigned by now. This is a bug in React.");return hh(a,b,d)}if(e===c.rootSegmentID)return hh(a,b,d);hh(a,b,d);c=a.resumableState;a=a.renderState;(d=0===c.streamingFormat)?(u(b,a.startInlineScript),0===(c.instructions&1)?(c.instructions|=1,u(b,Pd)):u(b,Qd)):u(b,Td);u(b,a.segmentPrefix);e=e.toString(16);u(b,e);d?u(b,Rd):u(b,Ud);u(b,a.placeholderPrefix);u(b,
-e);b=d?w(b,Sd):w(b,rb);return b}
-function eh(a,b){k=new Uint8Array(2048);m=0;pa=!0;try{var c,d=a.completedRootSegment;if(null!==d)if(5!==d.status&&0===a.pendingRootTasks){var e=a.renderState;if((0!==a.allPendingTasks||null!==a.trackedPostpones)&&e.externalRuntimeScript){var f=e.externalRuntimeScript,g=a.resumableState,h=f.src,l=f.chunks;g.scriptResources.hasOwnProperty(h)||(g.scriptResources[h]=null,e.scripts.add(l))}var n=e.htmlChunks,p=e.headChunks;f=0;if(n){for(f=0;f<n.length;f++)u(b,n[f]);if(p)for(f=0;f<p.length;f++)u(b,p[f]);
-else u(b,V("head")),u(b,R)}else if(p)for(f=0;f<p.length;f++)u(b,p[f]);var r=e.charsetChunks;for(f=0;f<r.length;f++)u(b,r[f]);r.length=0;e.preconnects.forEach(Ee,b);e.preconnects.clear();var q=e.preconnectChunks;for(f=0;f<q.length;f++)u(b,q[f]);q.length=0;e.fontPreloads.forEach(Ee,b);e.fontPreloads.clear();e.highImagePreloads.forEach(Ee,b);e.highImagePreloads.clear();e.styles.forEach(Le,b);var x=e.importMapChunks;for(f=0;f<x.length;f++)u(b,x[f]);x.length=0;e.bootstrapScripts.forEach(Ee,b);e.scripts.forEach(Ee,
-b);e.scripts.clear();e.bulkPreloads.forEach(Ee,b);e.bulkPreloads.clear();var v=e.preloadChunks;for(f=0;f<v.length;f++)u(b,v[f]);v.length=0;var Z=e.hoistableChunks;for(f=0;f<Z.length;f++)u(b,Z[f]);Z.length=0;n&&null===p&&u(b,mc("head"));gh(a,b,d);a.completedRootSegment=null;Fc(b,a.renderState)}else return;var t=a.renderState;d=0;t.preconnects.forEach(Ee,b);t.preconnects.clear();var C=t.preconnectChunks;for(d=0;d<C.length;d++)u(b,C[d]);C.length=0;t.fontPreloads.forEach(Ee,b);t.fontPreloads.clear();
+e);b=d?v(b,Sd):v(b,rb);return b}
+function eh(a,b){k=new Uint8Array(2048);m=0;pa=!0;try{var c,d=a.completedRootSegment;if(null!==d)if(5!==d.status&&0===a.pendingRootTasks){var e=a.renderState;if((0!==a.allPendingTasks||null!==a.trackedPostpones)&&e.externalRuntimeScript){var f=e.externalRuntimeScript,g=a.resumableState,h=f.src,l=f.chunks;g.scriptResources.hasOwnProperty(h)||(g.scriptResources[h]=null,e.scripts.add(l))}var n=e.htmlChunks,q=e.headChunks;f=0;if(n){for(f=0;f<n.length;f++)u(b,n[f]);if(q)for(f=0;f<q.length;f++)u(b,q[f]);
+else u(b,V("head")),u(b,R)}else if(q)for(f=0;f<q.length;f++)u(b,q[f]);var r=e.charsetChunks;for(f=0;f<r.length;f++)u(b,r[f]);r.length=0;e.preconnects.forEach(Ee,b);e.preconnects.clear();var p=e.preconnectChunks;for(f=0;f<p.length;f++)u(b,p[f]);p.length=0;e.fontPreloads.forEach(Ee,b);e.fontPreloads.clear();e.highImagePreloads.forEach(Ee,b);e.highImagePreloads.clear();e.styles.forEach(Le,b);var A=e.importMapChunks;for(f=0;f<A.length;f++)u(b,A[f]);A.length=0;e.bootstrapScripts.forEach(Ee,b);e.scripts.forEach(Ee,
+b);e.scripts.clear();e.bulkPreloads.forEach(Ee,b);e.bulkPreloads.clear();var B=e.preloadChunks;for(f=0;f<B.length;f++)u(b,B[f]);B.length=0;var Z=e.hoistableChunks;for(f=0;f<Z.length;f++)u(b,Z[f]);Z.length=0;n&&null===q&&u(b,mc("head"));gh(a,b,d);a.completedRootSegment=null;Fc(b,a.renderState,a.resumableState)}else return;var t=a.renderState;d=0;t.preconnects.forEach(Ee,b);t.preconnects.clear();var C=t.preconnectChunks;for(d=0;d<C.length;d++)u(b,C[d]);C.length=0;t.fontPreloads.forEach(Ee,b);t.fontPreloads.clear();
 t.highImagePreloads.forEach(Ee,b);t.highImagePreloads.clear();t.styles.forEach(Ne,b);t.scripts.forEach(Ee,b);t.scripts.clear();t.bulkPreloads.forEach(Ee,b);t.bulkPreloads.clear();var H=t.preloadChunks;for(d=0;d<H.length;d++)u(b,H[d]);H.length=0;var ka=t.hoistableChunks;for(d=0;d<ka.length;d++)u(b,ka[d]);ka.length=0;var E=a.clientRenderedBoundaries;for(c=0;c<E.length;c++){var U=E[c];t=b;var F=a.resumableState,da=a.renderState,S=U.rootSegmentID,la=U.errorDigest,P=U.errorMessage,I=U.errorComponentStack,
-ma=0===F.streamingFormat;ma?(u(t,da.startInlineScript),0===(F.instructions&4)?(F.instructions|=4,u(t,he)):u(t,ie)):u(t,me);u(t,da.boundaryPrefix);u(t,S.toString(16));ma&&u(t,je);if(la||P||I)ma?(u(t,ke),u(t,re(la||""))):(u(t,ne),u(t,B(la||"")));if(P||I)ma?(u(t,ke),u(t,re(P||""))):(u(t,oe),u(t,B(P||"")));I&&(ma?(u(t,ke),u(t,re(I))):(u(t,pe),u(t,B(I))));if(ma?!w(t,le):!w(t,rb)){a.destination=null;c++;E.splice(0,c);return}}E.splice(0,c);var ya=a.completedBoundaries;for(c=0;c<ya.length;c++)if(!ih(a,b,
+ma=0===F.streamingFormat;ma?(u(t,da.startInlineScript),0===(F.instructions&4)?(F.instructions|=4,u(t,he)):u(t,ie)):u(t,me);u(t,da.boundaryPrefix);u(t,S.toString(16));ma&&u(t,je);if(la||P||I)ma?(u(t,ke),u(t,re(la||""))):(u(t,ne),u(t,z(la||"")));if(P||I)ma?(u(t,ke),u(t,re(P||""))):(u(t,oe),u(t,z(P||"")));I&&(ma?(u(t,ke),u(t,re(I))):(u(t,pe),u(t,z(I))));if(ma?!v(t,le):!v(t,rb)){a.destination=null;c++;E.splice(0,c);return}}E.splice(0,c);var ya=a.completedBoundaries;for(c=0;c<ya.length;c++)if(!ih(a,b,
 ya[c])){a.destination=null;c++;ya.splice(0,c);return}ya.splice(0,c);xa(b);k=new Uint8Array(2048);m=0;pa=!0;var qa=a.partialBoundaries;for(c=0;c<qa.length;c++){var ra=qa[c];a:{E=a;U=b;E.renderState.boundaryResources=ra.resources;var sa=ra.completedSegments;for(F=0;F<sa.length;F++)if(!jh(E,U,ra,sa[F])){F++;sa.splice(0,F);var Ma=!1;break a}sa.splice(0,F);Ma=De(U,ra.resources,E.renderState)}if(!Ma){a.destination=null;c++;qa.splice(0,c);return}}qa.splice(0,c);var ea=a.completedBoundaries;for(c=0;c<ea.length;c++)if(!ih(a,
 b,ea[c])){a.destination=null;c++;ea.splice(0,c);return}ea.splice(0,c)}finally{0===a.allPendingTasks&&0===a.pingedTasks.length&&0===a.clientRenderedBoundaries.length&&0===a.completedBoundaries.length?(a.flushScheduled=!1,c=a.resumableState,c.hasBody&&u(b,mc("body")),c.hasHtml&&u(b,mc("html")),xa(b),oa(b),b.end(),a.destination=null):(xa(b),oa(b))}}
 function kh(a){a.flushScheduled=null!==a.destination;setImmediate(function(){return cf.run(a,Lg,a)});null===a.trackedPostpones&&setImmediate(function(){return cf.run(a,lh,a)})}function lh(a){bf(a.renderState,a.resumableState,0===a.pendingRootTasks)}function Xe(a){!1===a.flushScheduled&&0===a.pingedTasks.length&&null!==a.destination&&(a.flushScheduled=!0,setImmediate(function(){var b=a.destination;b?eh(a,b):a.flushScheduled=!1}))}
 function mh(a,b){if(1===a.status)a.status=2,b.destroy(a.fatalError);else if(2!==a.status&&null===a.destination){a.destination=b;try{eh(a,b)}catch(c){X(a,c),Qg(a,c)}}}function nh(a,b){try{var c=a.abortableTasks;if(0<c.size){var d=void 0===b?Error("The render was aborted by the server without a reason."):b;c.forEach(function(e){return bh(e,a,d)});c.clear()}null!==a.destination&&eh(a,a.destination)}catch(e){X(a,e),Qg(a,e)}}function oh(a,b){return function(){return mh(b,a)}}
 function ph(a,b){return function(){a.destination=null;nh(a,Error(b))}}
-function qh(a,b){var c=b?b.identifierPrefix:void 0;var d=0;void 0!==(b?b.unstable_externalRuntimeSrc:void 0)&&(d=1);c={idPrefix:void 0===c?"":c,nextFormID:0,streamingFormat:d,instructions:0,hasBody:!1,hasHtml:!1,unknownResources:{},dnsResources:{},connectResources:{default:{},anonymous:{},credentials:{}},imageResources:{},styleResources:{},scriptResources:{},moduleUnknownResources:{},moduleScriptResources:{}};var e=b?b.nonce:void 0,f=b?b.bootstrapScriptContent:void 0,g=b?b.bootstrapScripts:void 0,
-h=b?b.bootstrapModules:void 0,l=b?b.unstable_externalRuntimeSrc:void 0,n=b?b.importMap:void 0;d=b?b.onHeaders:void 0;var p=b?b.maxHeadersLength:void 0,r=void 0===e?sb:y('<script nonce="'+B(e)+'">'),q=c.idPrefix,x=[],v=null;void 0!==f&&x.push(r,(""+f).replace(Ab,Jb),tb);void 0!==l&&("string"===typeof l?(v={src:l,chunks:[]},wc(v.chunks,{src:l,async:!0,integrity:void 0,nonce:e})):(v={src:l.src,chunks:[]},wc(v.chunks,{src:l.src,async:!0,integrity:l.integrity,nonce:e})));f=[];void 0!==n&&(f.push(Kb),f.push((""+
-JSON.stringify(n)).replace(Ab,Jb)),f.push(Lb));n=d?{preconnects:"",fontPreloads:"",highImagePreloads:"",remainingCapacity:"number"===typeof p?p:2E3}:null;d={placeholderPrefix:y(q+"P:"),segmentPrefix:y(q+"S:"),boundaryPrefix:y(q+"B:"),startInlineScript:r,htmlChunks:null,headChunks:null,externalRuntimeScript:v,bootstrapChunks:x,onHeaders:d,headers:n,resets:{font:{},dns:{},connect:{default:{},anonymous:{},credentials:{}},image:{},style:{}},charsetChunks:[],preconnectChunks:[],importMapChunks:f,preloadChunks:[],
-hoistableChunks:[],preconnects:new Set,fontPreloads:new Set,highImagePreloads:new Set,styles:new Map,bootstrapScripts:new Set,scripts:new Set,bulkPreloads:new Set,preloads:{images:new Map,stylesheets:new Map,scripts:new Map,moduleScripts:new Map},nonce:e,boundaryResources:null,stylesToHoist:!1};if(void 0!==g)for(r=0;r<g.length;r++)f=g[r],n=v=void 0,p={rel:"preload",as:"script",fetchPriority:"low",nonce:e},"string"===typeof f?p.href=q=f:(p.href=q=f.src,p.integrity=n="string"===typeof f.integrity?f.integrity:
-void 0,p.crossOrigin=v="string"===typeof f||null==f.crossOrigin?void 0:"use-credentials"===f.crossOrigin?"use-credentials":""),f=c,l=q,f.scriptResources[l]=null,f.moduleScriptResources[l]=null,f=[],T(f,p),d.bootstrapScripts.add(f),x.push(ub,B(q)),e&&x.push(wb,B(e)),"string"===typeof n&&x.push(xb,B(n)),"string"===typeof v&&x.push(yb,B(v)),x.push(zb);if(void 0!==h)for(g=0;g<h.length;g++)p=h[g],v=q=void 0,n={rel:"modulepreload",fetchPriority:"low",nonce:e},"string"===typeof p?n.href=r=p:(n.href=r=p.src,
-n.integrity=v="string"===typeof p.integrity?p.integrity:void 0,n.crossOrigin=q="string"===typeof p||null==p.crossOrigin?void 0:"use-credentials"===p.crossOrigin?"use-credentials":""),p=c,f=r,p.scriptResources[f]=null,p.moduleScriptResources[f]=null,p=[],T(p,n),d.bootstrapScripts.add(p),x.push(vb,B(r)),e&&x.push(wb,B(e)),"string"===typeof v&&x.push(xb,B(v)),"string"===typeof q&&x.push(yb,B(q)),x.push(zb);e=b?b.namespaceURI:void 0;e=G("http://www.w3.org/2000/svg"===e?3:"http://www.w3.org/1998/Math/MathML"===
-e?4:0,null,0);x=b?b.progressiveChunkSize:void 0;g=b?b.onError:void 0;r=b?b.onAllReady:void 0;q=b?b.onShellReady:void 0;v=b?b.onShellError:void 0;n=b?b.onPostpone:void 0;p=b?b.formState:void 0;Wa.current=qb;b=[];h=new Set;c={destination:null,flushScheduled:!1,resumableState:c,renderState:d,rootFormatContext:e,progressiveChunkSize:void 0===x?12800:x,status:0,fatalError:null,nextSegmentId:0,allPendingTasks:0,pendingRootTasks:0,completedRootSegment:null,abortableTasks:h,pingedTasks:b,clientRenderedBoundaries:[],
-completedBoundaries:[],partialBoundaries:[],trackedPostpones:null,onError:void 0===g?Hg:g,onPostpone:void 0===n?Ig:n,onAllReady:void 0===r?Ig:r,onShellReady:void 0===q?Ig:q,onShellError:void 0===v?Ig:v,onFatalError:Ig,formState:void 0===p?null:p};d=Pg(c,0,null,e,!1,!1);d.parentFlushed=!0;a=Ng(c,null,a,-1,null,d,h,null,e,Bf,null,Mf);b.push(a);return c}
+function qh(a,b){var c=b?b.identifierPrefix:void 0;var d=0;void 0!==(b?b.unstable_externalRuntimeSrc:void 0)&&(d=1);c={idPrefix:void 0===c?"":c,nextFormID:0,streamingFormat:d,bootstrapScriptContent:b?b.bootstrapScriptContent:void 0,bootstrapScripts:b?b.bootstrapScripts:void 0,bootstrapModules:b?b.bootstrapModules:void 0,instructions:0,hasBody:!1,hasHtml:!1,unknownResources:{},dnsResources:{},connectResources:{default:{},anonymous:{},credentials:{}},imageResources:{},styleResources:{},scriptResources:{},
+moduleUnknownResources:{},moduleScriptResources:{}};var e=b?b.nonce:void 0,f=b?b.unstable_externalRuntimeSrc:void 0,g=b?b.importMap:void 0;d=b?b.onHeaders:void 0;var h=b?b.maxHeadersLength:void 0,l=void 0===e?sb:w('<script nonce="'+z(e)+'">'),n=c.idPrefix,q=[],r=null,p=c.bootstrapScriptContent,A=c.bootstrapScripts,B=c.bootstrapModules;void 0!==p&&q.push(l,(""+p).replace(Ab,Jb),tb);void 0!==f&&("string"===typeof f?(r={src:f,chunks:[]},wc(r.chunks,{src:f,async:!0,integrity:void 0,nonce:e})):(r={src:f.src,
+chunks:[]},wc(r.chunks,{src:f.src,async:!0,integrity:f.integrity,nonce:e})));f=[];void 0!==g&&(f.push(Kb),f.push((""+JSON.stringify(g)).replace(Ab,Jb)),f.push(Lb));g=d?{preconnects:"",fontPreloads:"",highImagePreloads:"",remainingCapacity:"number"===typeof h?h:2E3}:null;d={placeholderPrefix:w(n+"P:"),segmentPrefix:w(n+"S:"),boundaryPrefix:w(n+"B:"),startInlineScript:l,htmlChunks:null,headChunks:null,externalRuntimeScript:r,bootstrapChunks:q,onHeaders:d,headers:g,resets:{font:{},dns:{},connect:{default:{},
+anonymous:{},credentials:{}},image:{},style:{}},charsetChunks:[],preconnectChunks:[],importMapChunks:f,preloadChunks:[],hoistableChunks:[],preconnects:new Set,fontPreloads:new Set,highImagePreloads:new Set,styles:new Map,bootstrapScripts:new Set,scripts:new Set,bulkPreloads:new Set,preloads:{images:new Map,stylesheets:new Map,scripts:new Map,moduleScripts:new Map},nonce:e,boundaryResources:null,stylesToHoist:!1};if(void 0!==A)for(l=0;l<A.length;l++)f=A[l],g=r=void 0,h={rel:"preload",as:"script",fetchPriority:"low",
+nonce:e},"string"===typeof f?h.href=n=f:(h.href=n=f.src,h.integrity=g="string"===typeof f.integrity?f.integrity:void 0,h.crossOrigin=r="string"===typeof f||null==f.crossOrigin?void 0:"use-credentials"===f.crossOrigin?"use-credentials":""),f=c,p=n,f.scriptResources[p]=null,f.moduleScriptResources[p]=null,f=[],T(f,h),d.bootstrapScripts.add(f),q.push(ub,z(n)),e&&q.push(wb,z(e)),"string"===typeof g&&q.push(xb,z(g)),"string"===typeof r&&q.push(yb,z(r)),q.push(zb);if(void 0!==B)for(A=0;A<B.length;A++)h=
+B[A],r=n=void 0,g={rel:"modulepreload",fetchPriority:"low",nonce:e},"string"===typeof h?g.href=l=h:(g.href=l=h.src,g.integrity=r="string"===typeof h.integrity?h.integrity:void 0,g.crossOrigin=n="string"===typeof h||null==h.crossOrigin?void 0:"use-credentials"===h.crossOrigin?"use-credentials":""),h=c,f=l,h.scriptResources[f]=null,h.moduleScriptResources[f]=null,h=[],T(h,g),d.bootstrapScripts.add(h),q.push(vb,z(l)),e&&q.push(wb,z(e)),"string"===typeof r&&q.push(xb,z(r)),"string"===typeof n&&q.push(yb,
+z(n)),q.push(zb);e=b?b.namespaceURI:void 0;e=G("http://www.w3.org/2000/svg"===e?3:"http://www.w3.org/1998/Math/MathML"===e?4:0,null,0);B=b?b.progressiveChunkSize:void 0;A=b?b.onError:void 0;l=b?b.onAllReady:void 0;n=b?b.onShellReady:void 0;r=b?b.onShellError:void 0;g=b?b.onPostpone:void 0;h=b?b.formState:void 0;Wa.current=qb;b=[];q=new Set;c={destination:null,flushScheduled:!1,resumableState:c,renderState:d,rootFormatContext:e,progressiveChunkSize:void 0===B?12800:B,status:0,fatalError:null,nextSegmentId:0,
+allPendingTasks:0,pendingRootTasks:0,completedRootSegment:null,abortableTasks:q,pingedTasks:b,clientRenderedBoundaries:[],completedBoundaries:[],partialBoundaries:[],trackedPostpones:null,onError:void 0===A?Hg:A,onPostpone:void 0===g?Ig:g,onAllReady:void 0===l?Ig:l,onShellReady:void 0===n?Ig:n,onShellError:void 0===r?Ig:r,onFatalError:Ig,formState:void 0===h?null:h};d=Pg(c,0,null,e,!1,!1);d.parentFlushed=!0;a=Ng(c,null,a,-1,null,d,q,null,e,Bf,null,Mf);b.push(a);return c}
 exports.renderToPipeableStream=function(a,b){var c=qh(a,b),d=!1;kh(c);return{pipe:function(e){if(d)throw Error("React currently only supports piping to one writable stream.");d=!0;bf(c.renderState,c.resumableState,null===c.trackedPostpones?0===c.pendingRootTasks:null===c.completedRootSegment?0===c.pendingRootTasks:5!==c.completedRootSegment.status);mh(c,e);e.on("drain",oh(e,c));e.on("error",ph(c,"The destination stream errored while writing data."));e.on("close",ph(c,"The destination stream closed early."));
-return e},abort:function(e){nh(c,e)}}};exports.version="18.3.0-canary-2983249dd-20231107";
+return e},abort:function(e){nh(c,e)}}};exports.version="18.3.0-canary-7508dcd5c-20231108";
+
+//# sourceMappingURL=react-dom-server.node.production.min.js.map
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom-test-utils.production.js b/packages/next/src/compiled/react-dom/cjs/react-dom-test-utils.production.js
new file mode 100644
index 0000000000000..a288bec4ae723
--- /dev/null
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom-test-utils.production.js
@@ -0,0 +1,1532 @@
+/**
+ * @license React
+ * react-dom-test-utils.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require("next/dist/compiled/react");
+var ReactDOM = require('react-dom');
+
+/**
+ * `ReactInstanceMap` maintains a mapping from a public facing stateful
+ * instance (key) and the internal representation (value). This allows public
+ * methods to accept the user facing instance as an argument and map them back
+ * to internal methods.
+ *
+ * Note that this module is currently shared and assumed to be stateless.
+ * If this becomes an actual Map, that will break.
+ */
+function get(key) {
+  return key._reactInternals;
+}
+
+const FunctionComponent = 0;
+const ClassComponent = 1;
+
+const HostRoot = 3; // Root of a host tree. Could be nested inside another node.
+
+const HostComponent = 5;
+const HostText = 6;
+const HostHoistable = 26;
+const HostSingleton = 27;
+
+const NoFlags =
+/*                      */
+0b0000000000000000000000000000;
+const Placement =
+/*                    */
+0b0000000000000000000000000010;
+const Hydrating =
+/*                    */
+0b0000000000000001000000000000; // You can change the rest (and add more).
+
+function getNearestMountedFiber(fiber) {
+  let node = fiber;
+  let nearestMounted = fiber;
+
+  if (!fiber.alternate) {
+    // If there is no alternate, this might be a new tree that isn't inserted
+    // yet. If it is, then it will have a pending insertion effect on it.
+    let nextNode = node;
+
+    do {
+      node = nextNode;
+
+      if ((node.flags & (Placement | Hydrating)) !== NoFlags) {
+        // This is an insertion or in-progress hydration. The nearest possible
+        // mounted fiber is the parent but we need to continue to figure out
+        // if that one is still mounted.
+        nearestMounted = node.return;
+      } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+      nextNode = node.return;
+    } while (nextNode);
+  } else {
+    while (node.return) {
+      node = node.return;
+    }
+  }
+
+  if (node.tag === HostRoot) {
+    // TODO: Check if this was a nested HostRoot when used with
+    // renderContainerIntoSubtree.
+    return nearestMounted;
+  } // If we didn't hit the root, that means that we're in an disconnected tree
+  // that has been unmounted.
+
+
+  return null;
+}
+
+function assertIsMounted(fiber) {
+  if (getNearestMountedFiber(fiber) !== fiber) {
+    throw new Error('Unable to find node on an unmounted component.');
+  }
+}
+
+function findCurrentFiberUsingSlowPath(fiber) {
+  const alternate = fiber.alternate;
+
+  if (!alternate) {
+    // If there is no alternate, then we only need to check if it is mounted.
+    const nearestMounted = getNearestMountedFiber(fiber);
+
+    if (nearestMounted === null) {
+      throw new Error('Unable to find node on an unmounted component.');
+    }
+
+    if (nearestMounted !== fiber) {
+      return null;
+    }
+
+    return fiber;
+  } // If we have two possible branches, we'll walk backwards up to the root
+  // to see what path the root points to. On the way we may hit one of the
+  // special cases and we'll deal with them.
+
+
+  let a = fiber;
+  let b = alternate;
+
+  while (true) {
+    const parentA = a.return;
+
+    if (parentA === null) {
+      // We're at the root.
+      break;
+    }
+
+    const parentB = parentA.alternate;
+
+    if (parentB === null) {
+      // There is no alternate. This is an unusual case. Currently, it only
+      // happens when a Suspense component is hidden. An extra fragment fiber
+      // is inserted in between the Suspense fiber and its children. Skip
+      // over this extra fragment fiber and proceed to the next parent.
+      const nextParent = parentA.return;
+
+      if (nextParent !== null) {
+        a = b = nextParent;
+        continue;
+      } // If there's no parent, we're at the root.
+
+
+      break;
+    } // If both copies of the parent fiber point to the same child, we can
+    // assume that the child is current. This happens when we bailout on low
+    // priority: the bailed out fiber's child reuses the current child.
+
+
+    if (parentA.child === parentB.child) {
+      let child = parentA.child;
+
+      while (child) {
+        if (child === a) {
+          // We've determined that A is the current branch.
+          assertIsMounted(parentA);
+          return fiber;
+        }
+
+        if (child === b) {
+          // We've determined that B is the current branch.
+          assertIsMounted(parentA);
+          return alternate;
+        }
+
+        child = child.sibling;
+      } // We should never have an alternate for any mounting node. So the only
+      // way this could possibly happen is if this was unmounted, if at all.
+
+
+      throw new Error('Unable to find node on an unmounted component.');
+    }
+
+    if (a.return !== b.return) {
+      // The return pointer of A and the return pointer of B point to different
+      // fibers. We assume that return pointers never criss-cross, so A must
+      // belong to the child set of A.return, and B must belong to the child
+      // set of B.return.
+      a = parentA;
+      b = parentB;
+    } else {
+      // The return pointers point to the same fiber. We'll have to use the
+      // default, slow path: scan the child sets of each parent alternate to see
+      // which child belongs to which set.
+      //
+      // Search parent A's child set
+      let didFindChild = false;
+      let child = parentA.child;
+
+      while (child) {
+        if (child === a) {
+          didFindChild = true;
+          a = parentA;
+          b = parentB;
+          break;
+        }
+
+        if (child === b) {
+          didFindChild = true;
+          b = parentA;
+          a = parentB;
+          break;
+        }
+
+        child = child.sibling;
+      }
+
+      if (!didFindChild) {
+        // Search parent B's child set
+        child = parentB.child;
+
+        while (child) {
+          if (child === a) {
+            didFindChild = true;
+            a = parentB;
+            b = parentA;
+            break;
+          }
+
+          if (child === b) {
+            didFindChild = true;
+            b = parentB;
+            a = parentA;
+            break;
+          }
+
+          child = child.sibling;
+        }
+
+        if (!didFindChild) {
+          throw new Error('Child was not found in either parent set. This indicates a bug ' + 'in React related to the return pointer. Please file an issue.');
+        }
+      }
+    }
+
+    if (a.alternate !== b) {
+      throw new Error("Return fibers should always be each others' alternates. " + 'This error is likely caused by a bug in React. Please file an issue.');
+    }
+  } // If the root is not a host container, we're in a disconnected tree. I.e.
+  // unmounted.
+
+
+  if (a.tag !== HostRoot) {
+    throw new Error('Unable to find node on an unmounted component.');
+  }
+
+  if (a.stateNode.current === a) {
+    // We've determined that A is the current branch.
+    return fiber;
+  } // Otherwise B has to be current branch.
+
+
+  return alternate;
+}
+
+const assign = Object.assign;
+
+/**
+ * `charCode` represents the actual "character code" and is safe to use with
+ * `String.fromCharCode`. As such, only keys that correspond to printable
+ * characters produce a valid `charCode`, the only exception to this is Enter.
+ * The Tab-key is considered non-printable and does not have a `charCode`,
+ * presumably because it does not produce a tab-character in browsers.
+ *
+ * @param {object} nativeEvent Native browser event.
+ * @return {number} Normalized `charCode` property.
+ */
+function getEventCharCode(nativeEvent) {
+  let charCode;
+  const keyCode = nativeEvent.keyCode;
+
+  if ('charCode' in nativeEvent) {
+    charCode = nativeEvent.charCode; // FF does not set `charCode` for the Enter-key, check against `keyCode`.
+
+    if (charCode === 0 && keyCode === 13) {
+      charCode = 13;
+    }
+  } else {
+    // IE8 does not implement `charCode`, but `keyCode` has the correct value.
+    charCode = keyCode;
+  } // IE and Edge (on Windows) and Chrome / Safari (on Windows and Linux)
+  // report Enter as charCode 10 when ctrl is pressed.
+
+
+  if (charCode === 10) {
+    charCode = 13;
+  } // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
+  // Must not discard the (non-)printable Enter-key.
+
+
+  if (charCode >= 32 || charCode === 13) {
+    return charCode;
+  }
+
+  return 0;
+}
+
+function functionThatReturnsTrue() {
+  return true;
+}
+
+function functionThatReturnsFalse() {
+  return false;
+} // This is intentionally a factory so that we have different returned constructors.
+// If we had a single constructor, it would be megamorphic and engines would deopt.
+
+
+function createSyntheticEvent(Interface) {
+  /**
+   * Synthetic events are dispatched by event plugins, typically in response to a
+   * top-level event delegation handler.
+   *
+   * These systems should generally use pooling to reduce the frequency of garbage
+   * collection. The system should check `isPersistent` to determine whether the
+   * event should be released into the pool after being dispatched. Users that
+   * need a persisted event should invoke `persist`.
+   *
+   * Synthetic events (and subclasses) implement the DOM Level 3 Events API by
+   * normalizing browser quirks. Subclasses do not necessarily have to implement a
+   * DOM interface; custom application-specific events can also subclass this.
+   */
+  // $FlowFixMe[missing-this-annot]
+  function SyntheticBaseEvent(reactName, reactEventType, targetInst, nativeEvent, nativeEventTarget) {
+    this._reactName = reactName;
+    this._targetInst = targetInst;
+    this.type = reactEventType;
+    this.nativeEvent = nativeEvent;
+    this.target = nativeEventTarget;
+    this.currentTarget = null;
+
+    for (const propName in Interface) {
+      if (!Interface.hasOwnProperty(propName)) {
+        continue;
+      }
+
+      const normalize = Interface[propName];
+
+      if (normalize) {
+        this[propName] = normalize(nativeEvent);
+      } else {
+        this[propName] = nativeEvent[propName];
+      }
+    }
+
+    const defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
+
+    if (defaultPrevented) {
+      this.isDefaultPrevented = functionThatReturnsTrue;
+    } else {
+      this.isDefaultPrevented = functionThatReturnsFalse;
+    }
+
+    this.isPropagationStopped = functionThatReturnsFalse;
+    return this;
+  } // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+  assign(SyntheticBaseEvent.prototype, {
+    // $FlowFixMe[missing-this-annot]
+    preventDefault: function () {
+      this.defaultPrevented = true;
+      const event = this.nativeEvent;
+
+      if (!event) {
+        return;
+      }
+
+      if (event.preventDefault) {
+        event.preventDefault(); // $FlowFixMe[illegal-typeof] - flow is not aware of `unknown` in IE
+      } else if (typeof event.returnValue !== 'unknown') {
+        event.returnValue = false;
+      }
+
+      this.isDefaultPrevented = functionThatReturnsTrue;
+    },
+    // $FlowFixMe[missing-this-annot]
+    stopPropagation: function () {
+      const event = this.nativeEvent;
+
+      if (!event) {
+        return;
+      }
+
+      if (event.stopPropagation) {
+        event.stopPropagation(); // $FlowFixMe[illegal-typeof] - flow is not aware of `unknown` in IE
+      } else if (typeof event.cancelBubble !== 'unknown') {
+        // The ChangeEventPlugin registers a "propertychange" event for
+        // IE. This event does not support bubbling or cancelling, and
+        // any references to cancelBubble throw "Member not found".  A
+        // typeof check of "unknown" circumvents this issue (and is also
+        // IE specific).
+        event.cancelBubble = true;
+      }
+
+      this.isPropagationStopped = functionThatReturnsTrue;
+    },
+
+    /**
+     * We release all dispatched `SyntheticEvent`s after each event loop, adding
+     * them back into the pool. This allows a way to hold onto a reference that
+     * won't be added back into the pool.
+     */
+    persist: function () {// Modern event system doesn't use pooling.
+    },
+
+    /**
+     * Checks if this event should be released back into the pool.
+     *
+     * @return {boolean} True if this should not be released, false otherwise.
+     */
+    isPersistent: functionThatReturnsTrue
+  });
+  return SyntheticBaseEvent;
+}
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+
+const EventInterface = {
+  eventPhase: 0,
+  bubbles: 0,
+  cancelable: 0,
+  timeStamp: function (event) {
+    return event.timeStamp || Date.now();
+  },
+  defaultPrevented: 0,
+  isTrusted: 0
+};
+const SyntheticEvent = createSyntheticEvent(EventInterface);
+
+const UIEventInterface = assign({}, EventInterface, {
+  view: 0,
+  detail: 0
+});
+
+createSyntheticEvent(UIEventInterface);
+let lastMovementX;
+let lastMovementY;
+let lastMouseEvent;
+
+function updateMouseMovementPolyfillState(event) {
+  if (event !== lastMouseEvent) {
+    if (lastMouseEvent && event.type === 'mousemove') {
+      // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+      lastMovementX = event.screenX - lastMouseEvent.screenX; // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+
+      lastMovementY = event.screenY - lastMouseEvent.screenY;
+    } else {
+      lastMovementX = 0;
+      lastMovementY = 0;
+    }
+
+    lastMouseEvent = event;
+  }
+}
+/**
+ * @interface MouseEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+
+const MouseEventInterface = assign({}, UIEventInterface, {
+  screenX: 0,
+  screenY: 0,
+  clientX: 0,
+  clientY: 0,
+  pageX: 0,
+  pageY: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  altKey: 0,
+  metaKey: 0,
+  getModifierState: getEventModifierState,
+  button: 0,
+  buttons: 0,
+  relatedTarget: function (event) {
+    if (event.relatedTarget === undefined) return event.fromElement === event.srcElement ? event.toElement : event.fromElement;
+    return event.relatedTarget;
+  },
+  movementX: function (event) {
+    if ('movementX' in event) {
+      return event.movementX;
+    }
+
+    updateMouseMovementPolyfillState(event);
+    return lastMovementX;
+  },
+  movementY: function (event) {
+    if ('movementY' in event) {
+      return event.movementY;
+    } // Don't need to call updateMouseMovementPolyfillState() here
+    // because it's guaranteed to have already run when movementX
+    // was copied.
+
+
+    return lastMovementY;
+  }
+});
+
+createSyntheticEvent(MouseEventInterface);
+/**
+ * @interface DragEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+const DragEventInterface = assign({}, MouseEventInterface, {
+  dataTransfer: 0
+});
+
+createSyntheticEvent(DragEventInterface);
+/**
+ * @interface FocusEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+const FocusEventInterface = assign({}, UIEventInterface, {
+  relatedTarget: 0
+});
+
+createSyntheticEvent(FocusEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent
+ */
+
+const AnimationEventInterface = assign({}, EventInterface, {
+  animationName: 0,
+  elapsedTime: 0,
+  pseudoElement: 0
+});
+
+createSyntheticEvent(AnimationEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/clipboard-apis/
+ */
+
+const ClipboardEventInterface = assign({}, EventInterface, {
+  clipboardData: function (event) {
+    return 'clipboardData' in event ? event.clipboardData : window.clipboardData;
+  }
+});
+
+createSyntheticEvent(ClipboardEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents
+ */
+
+const CompositionEventInterface = assign({}, EventInterface, {
+  data: 0
+});
+
+createSyntheticEvent(CompositionEventInterface);
+/**
+ * Normalization of deprecated HTML5 `key` values
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
+ */
+
+const normalizeKey = {
+  Esc: 'Escape',
+  Spacebar: ' ',
+  Left: 'ArrowLeft',
+  Up: 'ArrowUp',
+  Right: 'ArrowRight',
+  Down: 'ArrowDown',
+  Del: 'Delete',
+  Win: 'OS',
+  Menu: 'ContextMenu',
+  Apps: 'ContextMenu',
+  Scroll: 'ScrollLock',
+  MozPrintableKey: 'Unidentified'
+};
+/**
+ * Translation from legacy `keyCode` to HTML5 `key`
+ * Only special keys supported, all others depend on keyboard layout or browser
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
+ */
+
+const translateToKey = {
+  '8': 'Backspace',
+  '9': 'Tab',
+  '12': 'Clear',
+  '13': 'Enter',
+  '16': 'Shift',
+  '17': 'Control',
+  '18': 'Alt',
+  '19': 'Pause',
+  '20': 'CapsLock',
+  '27': 'Escape',
+  '32': ' ',
+  '33': 'PageUp',
+  '34': 'PageDown',
+  '35': 'End',
+  '36': 'Home',
+  '37': 'ArrowLeft',
+  '38': 'ArrowUp',
+  '39': 'ArrowRight',
+  '40': 'ArrowDown',
+  '45': 'Insert',
+  '46': 'Delete',
+  '112': 'F1',
+  '113': 'F2',
+  '114': 'F3',
+  '115': 'F4',
+  '116': 'F5',
+  '117': 'F6',
+  '118': 'F7',
+  '119': 'F8',
+  '120': 'F9',
+  '121': 'F10',
+  '122': 'F11',
+  '123': 'F12',
+  '144': 'NumLock',
+  '145': 'ScrollLock',
+  '224': 'Meta'
+};
+/**
+ * @param {object} nativeEvent Native browser event.
+ * @return {string} Normalized `key` property.
+ */
+
+function getEventKey(nativeEvent) {
+  if (nativeEvent.key) {
+    // Normalize inconsistent values reported by browsers due to
+    // implementations of a working draft specification.
+    // FireFox implements `key` but returns `MozPrintableKey` for all
+    // printable characters (normalized to `Unidentified`), ignore it.
+    const key = // $FlowFixMe[invalid-computed-prop] unable to index with a `mixed` value
+    normalizeKey[nativeEvent.key] || nativeEvent.key;
+
+    if (key !== 'Unidentified') {
+      return key;
+    }
+  } // Browser does not implement `key`, polyfill as much of it as we can.
+
+
+  if (nativeEvent.type === 'keypress') {
+    const charCode = getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
+    nativeEvent); // The enter-key is technically both printable and non-printable and can
+    // thus be captured by `keypress`, no other non-printable key should.
+
+    return charCode === 13 ? 'Enter' : String.fromCharCode(charCode);
+  }
+
+  if (nativeEvent.type === 'keydown' || nativeEvent.type === 'keyup') {
+    // While user keyboard layout determines the actual meaning of each
+    // `keyCode` value, almost all function keys have a universal value.
+    // $FlowFixMe[invalid-computed-prop] unable to index with a `mixed` value
+    return translateToKey[nativeEvent.keyCode] || 'Unidentified';
+  }
+
+  return '';
+}
+/**
+ * Translation from modifier key to the associated property in the event.
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers
+ */
+
+
+const modifierKeyToProp = {
+  Alt: 'altKey',
+  Control: 'ctrlKey',
+  Meta: 'metaKey',
+  Shift: 'shiftKey'
+}; // Older browsers (Safari <= 10, iOS Safari <= 10.2) do not support
+// getModifierState. If getModifierState is not supported, we map it to a set of
+// modifier keys exposed by the event. In this case, Lock-keys are not supported.
+// $FlowFixMe[missing-local-annot]
+// $FlowFixMe[missing-this-annot]
+
+function modifierStateGetter(keyArg) {
+  const syntheticEvent = this;
+  const nativeEvent = syntheticEvent.nativeEvent;
+
+  if (nativeEvent.getModifierState) {
+    return nativeEvent.getModifierState(keyArg);
+  }
+
+  const keyProp = modifierKeyToProp[keyArg];
+  return keyProp ? !!nativeEvent[keyProp] : false;
+}
+
+function getEventModifierState(nativeEvent) {
+  return modifierStateGetter;
+}
+/**
+ * @interface KeyboardEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+
+const KeyboardEventInterface = assign({}, UIEventInterface, {
+  key: getEventKey,
+  code: 0,
+  location: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  altKey: 0,
+  metaKey: 0,
+  repeat: 0,
+  locale: 0,
+  getModifierState: getEventModifierState,
+  // Legacy Interface
+  charCode: function (event) {
+    // `charCode` is the result of a KeyPress event and represents the value of
+    // the actual printable character.
+    // KeyPress is deprecated, but its replacement is not yet final and not
+    // implemented in any major browser. Only KeyPress has charCode.
+    if (event.type === 'keypress') {
+      return getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
+      event);
+    }
+
+    return 0;
+  },
+  keyCode: function (event) {
+    // `keyCode` is the result of a KeyDown/Up event and represents the value of
+    // physical keyboard key.
+    // The actual meaning of the value depends on the users' keyboard layout
+    // which cannot be detected. Assuming that it is a US keyboard layout
+    // provides a surprisingly accurate mapping for US and European users.
+    // Due to this, it is left to the user to implement at this time.
+    if (event.type === 'keydown' || event.type === 'keyup') {
+      return event.keyCode;
+    }
+
+    return 0;
+  },
+  which: function (event) {
+    // `which` is an alias for either `keyCode` or `charCode` depending on the
+    // type of the event.
+    if (event.type === 'keypress') {
+      return getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
+      event);
+    }
+
+    if (event.type === 'keydown' || event.type === 'keyup') {
+      return event.keyCode;
+    }
+
+    return 0;
+  }
+});
+
+createSyntheticEvent(KeyboardEventInterface);
+/**
+ * @interface PointerEvent
+ * @see http://www.w3.org/TR/pointerevents/
+ */
+
+const PointerEventInterface = assign({}, MouseEventInterface, {
+  pointerId: 0,
+  width: 0,
+  height: 0,
+  pressure: 0,
+  tangentialPressure: 0,
+  tiltX: 0,
+  tiltY: 0,
+  twist: 0,
+  pointerType: 0,
+  isPrimary: 0
+});
+
+createSyntheticEvent(PointerEventInterface);
+/**
+ * @interface TouchEvent
+ * @see http://www.w3.org/TR/touch-events/
+ */
+
+const TouchEventInterface = assign({}, UIEventInterface, {
+  touches: 0,
+  targetTouches: 0,
+  changedTouches: 0,
+  altKey: 0,
+  metaKey: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  getModifierState: getEventModifierState
+});
+
+createSyntheticEvent(TouchEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent
+ */
+
+const TransitionEventInterface = assign({}, EventInterface, {
+  propertyName: 0,
+  elapsedTime: 0,
+  pseudoElement: 0
+});
+
+createSyntheticEvent(TransitionEventInterface);
+/**
+ * @interface WheelEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+const WheelEventInterface = assign({}, MouseEventInterface, {
+  deltaX(event) {
+    return 'deltaX' in event ? event.deltaX : // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).
+    'wheelDeltaX' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+    -event.wheelDeltaX : 0;
+  },
+
+  deltaY(event) {
+    return 'deltaY' in event ? event.deltaY : // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
+    'wheelDeltaY' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+    -event.wheelDeltaY : // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
+    'wheelDelta' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+    -event.wheelDelta : 0;
+  },
+
+  deltaZ: 0,
+  // Browsers without "deltaMode" is reporting in raw wheel delta where one
+  // notch on the scroll is always +/- 120, roughly equivalent to pixels.
+  // A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or
+  // ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.
+  deltaMode: 0
+});
+
+createSyntheticEvent(WheelEventInterface);
+
+/**
+ * HTML nodeType values that represent the type of the node
+ */
+const ELEMENT_NODE = 1;
+
+function invokeGuardedCallbackImpl(name, func, context) {
+  {
+    // $FlowFixMe[method-unbinding]
+    const funcArgs = Array.prototype.slice.call(arguments, 3);
+
+    try {
+      // $FlowFixMe[incompatible-call] Flow doesn't understand the arguments splicing.
+      func.apply(context, funcArgs);
+    } catch (error) {
+      this.onError(error);
+    }
+  }
+}
+
+let hasError = false;
+let caughtError = null; // Used by event system to capture/rethrow the first error.
+
+let hasRethrowError = false;
+let rethrowError = null;
+const reporter = {
+  onError(error) {
+    hasError = true;
+    caughtError = error;
+  }
+
+};
+/**
+ * Call a function while guarding against errors that happens within it.
+ * Returns an error if it throws, otherwise null.
+ *
+ * In production, this is implemented using a try-catch. The reason we don't
+ * use a try-catch directly is so that we can swap out a different
+ * implementation in DEV mode.
+ *
+ * @param {String} name of the guard to use for logging or debugging
+ * @param {Function} func The function to invoke
+ * @param {*} context The context to use when calling the function
+ * @param {...*} args Arguments for function
+ */
+
+function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+  hasError = false;
+  caughtError = null;
+  invokeGuardedCallbackImpl.apply(reporter, arguments);
+}
+/**
+ * Same as invokeGuardedCallback, but instead of returning an error, it stores
+ * it in a global so it can be rethrown by `rethrowCaughtError` later.
+ * TODO: See if caughtError and rethrowError can be unified.
+ *
+ * @param {String} name of the guard to use for logging or debugging
+ * @param {Function} func The function to invoke
+ * @param {*} context The context to use when calling the function
+ * @param {...*} args Arguments for function
+ */
+
+function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
+  invokeGuardedCallback.apply(this, arguments);
+
+  if (hasError) {
+    const error = clearCaughtError();
+
+    if (!hasRethrowError) {
+      hasRethrowError = true;
+      rethrowError = error;
+    }
+  }
+}
+/**
+ * During execution of guarded functions we will capture the first error which
+ * we will rethrow to be handled by the top level error handler.
+ */
+
+function rethrowCaughtError() {
+  if (hasRethrowError) {
+    const error = rethrowError;
+    hasRethrowError = false;
+    rethrowError = null;
+    throw error;
+  }
+}
+function clearCaughtError() {
+  if (hasError) {
+    const error = caughtError;
+    hasError = false;
+    caughtError = null;
+    return error;
+  } else {
+    throw new Error('clearCaughtError was called but no error was captured. This error ' + 'is likely caused by a bug in React. Please file an issue.');
+  }
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const SecretInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+const EventInternals = SecretInternals.Events;
+const getInstanceFromNode = EventInternals[0];
+const getNodeFromInstance = EventInternals[1];
+const getFiberCurrentPropsFromNode = EventInternals[2];
+const enqueueStateRestore = EventInternals[3];
+const restoreStateIfNeeded = EventInternals[4];
+const act = React.unstable_act;
+
+function Event(suffix) {}
+/**
+ * @class ReactTestUtils
+ */
+
+function findAllInRenderedFiberTreeInternal(fiber, test) {
+  if (!fiber) {
+    return [];
+  }
+
+  const currentParent = findCurrentFiberUsingSlowPath(fiber);
+
+  if (!currentParent) {
+    return [];
+  }
+
+  let node = currentParent;
+  const ret = [];
+
+  while (true) {
+    if (node.tag === HostComponent || node.tag === HostText || node.tag === ClassComponent || node.tag === FunctionComponent || (node.tag === HostHoistable ) || (node.tag === HostSingleton )) {
+      const publicInst = node.stateNode;
+
+      if (test(publicInst)) {
+        ret.push(publicInst);
+      }
+    }
+
+    if (node.child) {
+      node.child.return = node;
+      node = node.child;
+      continue;
+    }
+
+    if (node === currentParent) {
+      return ret;
+    }
+
+    while (!node.sibling) {
+      if (!node.return || node.return === currentParent) {
+        return ret;
+      }
+
+      node = node.return;
+    }
+
+    node.sibling.return = node.return;
+    node = node.sibling;
+  }
+}
+
+function validateClassInstance(inst, methodName) {
+  if (!inst) {
+    // This is probably too relaxed but it's existing behavior.
+    return;
+  }
+
+  if (get(inst)) {
+    // This is a public instance indeed.
+    return;
+  }
+
+  let received;
+  const stringified = String(inst);
+
+  if (isArray(inst)) {
+    received = 'an array';
+  } else if (inst && inst.nodeType === ELEMENT_NODE && inst.tagName) {
+    received = 'a DOM node';
+  } else if (stringified === '[object Object]') {
+    received = 'object with keys {' + Object.keys(inst).join(', ') + '}';
+  } else {
+    received = stringified;
+  }
+
+  throw new Error(methodName + "(...): the first argument must be a React class instance. " + ("Instead received: " + received + "."));
+}
+/**
+ * Utilities for making it easy to test React components.
+ *
+ * See https://reactjs.org/docs/test-utils.html
+ *
+ * Todo: Support the entire DOM.scry query syntax. For now, these simple
+ * utilities will suffice for testing purposes.
+ * @lends ReactTestUtils
+ */
+
+
+function renderIntoDocument(element) {
+  const div = document.createElement('div'); // None of our tests actually require attaching the container to the
+  // DOM, and doing so creates a mess that we rely on test isolation to
+  // clean up, so we're going to stop honoring the name of this method
+  // (and probably rename it eventually) if no problems arise.
+  // document.documentElement.appendChild(div);
+
+  return ReactDOM.render(element, div);
+}
+
+function isElement(element) {
+  return React.isValidElement(element);
+}
+
+function isElementOfType(inst, convenienceConstructor) {
+  return React.isValidElement(inst) && inst.type === convenienceConstructor;
+}
+
+function isDOMComponent(inst) {
+  return !!(inst && inst.nodeType === ELEMENT_NODE && inst.tagName);
+}
+
+function isDOMComponentElement(inst) {
+  return !!(inst && React.isValidElement(inst) && !!inst.tagName);
+}
+
+function isCompositeComponent(inst) {
+  if (isDOMComponent(inst)) {
+    // Accessing inst.setState warns; just return false as that'll be what
+    // this returns when we have DOM nodes as refs directly
+    return false;
+  }
+
+  return inst != null && typeof inst.render === 'function' && typeof inst.setState === 'function';
+}
+
+function isCompositeComponentWithType(inst, type) {
+  if (!isCompositeComponent(inst)) {
+    return false;
+  }
+
+  const internalInstance = get(inst);
+  const constructor = internalInstance.type;
+  return constructor === type;
+}
+
+function findAllInRenderedTree(inst, test) {
+  validateClassInstance(inst, 'findAllInRenderedTree');
+
+  if (!inst) {
+    return [];
+  }
+
+  const internalInstance = get(inst);
+  return findAllInRenderedFiberTreeInternal(internalInstance, test);
+}
+/**
+ * Finds all instances of components in the rendered tree that are DOM
+ * components with the class name matching `className`.
+ * @return {array} an array of all the matches.
+ */
+
+
+function scryRenderedDOMComponentsWithClass(root, classNames) {
+  validateClassInstance(root, 'scryRenderedDOMComponentsWithClass');
+  return findAllInRenderedTree(root, function (inst) {
+    if (isDOMComponent(inst)) {
+      let className = inst.className;
+
+      if (typeof className !== 'string') {
+        // SVG, probably.
+        className = inst.getAttribute('class') || '';
+      }
+
+      const classList = className.split(/\s+/);
+
+      if (!isArray(classNames)) {
+        if (classNames === undefined) {
+          throw new Error('TestUtils.scryRenderedDOMComponentsWithClass expects a ' + 'className as a second argument.');
+        }
+
+        classNames = classNames.split(/\s+/);
+      }
+
+      return classNames.every(function (name) {
+        return classList.indexOf(name) !== -1;
+      });
+    }
+
+    return false;
+  });
+}
+/**
+ * Like scryRenderedDOMComponentsWithClass but expects there to be one result,
+ * and returns that one result, or throws exception if there is any other
+ * number of matches besides one.
+ * @return {!ReactDOMComponent} The one match.
+ */
+
+
+function findRenderedDOMComponentWithClass(root, className) {
+  validateClassInstance(root, 'findRenderedDOMComponentWithClass');
+  const all = scryRenderedDOMComponentsWithClass(root, className);
+
+  if (all.length !== 1) {
+    throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for class:' + className);
+  }
+
+  return all[0];
+}
+/**
+ * Finds all instances of components in the rendered tree that are DOM
+ * components with the tag name matching `tagName`.
+ * @return {array} an array of all the matches.
+ */
+
+
+function scryRenderedDOMComponentsWithTag(root, tagName) {
+  validateClassInstance(root, 'scryRenderedDOMComponentsWithTag');
+  return findAllInRenderedTree(root, function (inst) {
+    return isDOMComponent(inst) && inst.tagName.toUpperCase() === tagName.toUpperCase();
+  });
+}
+/**
+ * Like scryRenderedDOMComponentsWithTag but expects there to be one result,
+ * and returns that one result, or throws exception if there is any other
+ * number of matches besides one.
+ * @return {!ReactDOMComponent} The one match.
+ */
+
+
+function findRenderedDOMComponentWithTag(root, tagName) {
+  validateClassInstance(root, 'findRenderedDOMComponentWithTag');
+  const all = scryRenderedDOMComponentsWithTag(root, tagName);
+
+  if (all.length !== 1) {
+    throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for tag:' + tagName);
+  }
+
+  return all[0];
+}
+/**
+ * Finds all instances of components with type equal to `componentType`.
+ * @return {array} an array of all the matches.
+ */
+
+
+function scryRenderedComponentsWithType(root, componentType) {
+  validateClassInstance(root, 'scryRenderedComponentsWithType');
+  return findAllInRenderedTree(root, function (inst) {
+    return isCompositeComponentWithType(inst, componentType);
+  });
+}
+/**
+ * Same as `scryRenderedComponentsWithType` but expects there to be one result
+ * and returns that one result, or throws exception if there is any other
+ * number of matches besides one.
+ * @return {!ReactComponent} The one match.
+ */
+
+
+function findRenderedComponentWithType(root, componentType) {
+  validateClassInstance(root, 'findRenderedComponentWithType');
+  const all = scryRenderedComponentsWithType(root, componentType);
+
+  if (all.length !== 1) {
+    throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for componentType:' + componentType);
+  }
+
+  return all[0];
+}
+/**
+ * Pass a mocked component module to this method to augment it with
+ * useful methods that allow it to be used as a dummy React component.
+ * Instead of rendering as usual, the component will become a simple
+ * <div> containing any provided children.
+ *
+ * @param {object} module the mock function object exported from a
+ *                        module that defines the component to be mocked
+ * @param {?string} mockTagName optional dummy root tag name to return
+ *                              from render method (overrides
+ *                              module.mockTagName if provided)
+ * @return {object} the ReactTestUtils object (for chaining)
+ */
+
+
+function mockComponent(module, mockTagName) {
+
+  mockTagName = mockTagName || module.mockTagName || 'div';
+  module.prototype.render.mockImplementation(function () {
+    return React.createElement(mockTagName, null, this.props.children);
+  });
+  return this;
+}
+
+function nativeTouchData(x, y) {
+  return {
+    touches: [{
+      pageX: x,
+      pageY: y
+    }]
+  };
+} // Start of inline: the below functions were inlined from
+// EventPropagator.js, as they deviated from ReactDOM's newer
+// implementations.
+
+/**
+ * Dispatch the event to the listener.
+ * @param {SyntheticEvent} event SyntheticEvent to handle
+ * @param {function} listener Application-level callback
+ * @param {*} inst Internal component instance
+ */
+
+
+function executeDispatch(event, listener, inst) {
+  const type = event.type || 'unknown-event';
+  event.currentTarget = getNodeFromInstance(inst);
+  invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
+  event.currentTarget = null;
+}
+/**
+ * Standard/simple iteration through an event's collected dispatches.
+ */
+
+
+function executeDispatchesInOrder(event) {
+  const dispatchListeners = event._dispatchListeners;
+  const dispatchInstances = event._dispatchInstances;
+
+  if (isArray(dispatchListeners)) {
+    for (let i = 0; i < dispatchListeners.length; i++) {
+      if (event.isPropagationStopped()) {
+        break;
+      } // Listeners and Instances are two parallel arrays that are always in sync.
+
+
+      executeDispatch(event, dispatchListeners[i], dispatchInstances[i]);
+    }
+  } else if (dispatchListeners) {
+    executeDispatch(event, dispatchListeners, dispatchInstances);
+  }
+
+  event._dispatchListeners = null;
+  event._dispatchInstances = null;
+}
+/**
+ * Dispatches an event and releases it back into the pool, unless persistent.
+ *
+ * @param {?object} event Synthetic event to be dispatched.
+ * @private
+ */
+
+
+function executeDispatchesAndRelease(event
+/* ReactSyntheticEvent */
+) {
+  if (event) {
+    executeDispatchesInOrder(event);
+
+    if (!event.isPersistent()) {
+      event.constructor.release(event);
+    }
+  }
+}
+
+function isInteractive(tag) {
+  return tag === 'button' || tag === 'input' || tag === 'select' || tag === 'textarea';
+}
+
+function getParent(inst) {
+  do {
+    inst = inst.return; // TODO: If this is a HostRoot we might want to bail out.
+    // That is depending on if we want nested subtrees (layers) to bubble
+    // events to their parent. We could also go through parentNode on the
+    // host node but that wouldn't work for React Native and doesn't let us
+    // do the portal feature.
+  } while (inst && inst.tag !== HostComponent && (inst.tag !== HostSingleton));
+
+  if (inst) {
+    return inst;
+  }
+
+  return null;
+}
+/**
+ * Simulates the traversal of a two-phase, capture/bubble event dispatch.
+ */
+
+
+function traverseTwoPhase(inst, fn, arg) {
+  const path = [];
+
+  while (inst) {
+    path.push(inst);
+    inst = getParent(inst);
+  }
+
+  let i;
+
+  for (i = path.length; i-- > 0;) {
+    fn(path[i], 'captured', arg);
+  }
+
+  for (i = 0; i < path.length; i++) {
+    fn(path[i], 'bubbled', arg);
+  }
+}
+
+function shouldPreventMouseEvent(name, type, props) {
+  switch (name) {
+    case 'onClick':
+    case 'onClickCapture':
+    case 'onDoubleClick':
+    case 'onDoubleClickCapture':
+    case 'onMouseDown':
+    case 'onMouseDownCapture':
+    case 'onMouseMove':
+    case 'onMouseMoveCapture':
+    case 'onMouseUp':
+    case 'onMouseUpCapture':
+    case 'onMouseEnter':
+      return !!(props.disabled && isInteractive(type));
+
+    default:
+      return false;
+  }
+}
+/**
+ * @param {object} inst The instance, which is the source of events.
+ * @param {string} registrationName Name of listener (e.g. `onClick`).
+ * @return {?function} The stored callback.
+ */
+
+
+function getListener(inst
+/* Fiber */
+, registrationName) {
+  // TODO: shouldPreventMouseEvent is DOM-specific and definitely should not
+  // live here; needs to be moved to a better place soon
+  const stateNode = inst.stateNode;
+
+  if (!stateNode) {
+    // Work in progress (ex: onload events in incremental mode).
+    return null;
+  }
+
+  const props = getFiberCurrentPropsFromNode(stateNode);
+
+  if (!props) {
+    // Work in progress.
+    return null;
+  }
+
+  const listener = props[registrationName];
+
+  if (shouldPreventMouseEvent(registrationName, inst.type, props)) {
+    return null;
+  }
+
+  if (listener && typeof listener !== 'function') {
+    throw new Error("Expected `" + registrationName + "` listener to be a function, instead got a value of `" + typeof listener + "` type.");
+  }
+
+  return listener;
+}
+
+function listenerAtPhase(inst, event, propagationPhase) {
+  let registrationName = event._reactName;
+
+  if (propagationPhase === 'captured') {
+    registrationName += 'Capture';
+  }
+
+  return getListener(inst, registrationName);
+}
+
+function accumulateDispatches(inst, ignoredDirection, event) {
+  if (inst && event && event._reactName) {
+    const registrationName = event._reactName;
+    const listener = getListener(inst, registrationName);
+
+    if (listener) {
+      if (event._dispatchListeners == null) {
+        event._dispatchListeners = [];
+      }
+
+      if (event._dispatchInstances == null) {
+        event._dispatchInstances = [];
+      }
+
+      event._dispatchListeners.push(listener);
+
+      event._dispatchInstances.push(inst);
+    }
+  }
+}
+
+function accumulateDirectionalDispatches(inst, phase, event) {
+
+  const listener = listenerAtPhase(inst, event, phase);
+
+  if (listener) {
+    if (event._dispatchListeners == null) {
+      event._dispatchListeners = [];
+    }
+
+    if (event._dispatchInstances == null) {
+      event._dispatchInstances = [];
+    }
+
+    event._dispatchListeners.push(listener);
+
+    event._dispatchInstances.push(inst);
+  }
+}
+
+function accumulateDirectDispatchesSingle(event) {
+  if (event && event._reactName) {
+    accumulateDispatches(event._targetInst, null, event);
+  }
+}
+
+function accumulateTwoPhaseDispatchesSingle(event) {
+  if (event && event._reactName) {
+    traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
+  }
+} // End of inline
+
+
+const Simulate = {};
+const directDispatchEventTypes = new Set(['mouseEnter', 'mouseLeave', 'pointerEnter', 'pointerLeave']);
+/**
+ * Exports:
+ *
+ * - `Simulate.click(Element)`
+ * - `Simulate.mouseMove(Element)`
+ * - `Simulate.change(Element)`
+ * - ... (All keys from event plugin `eventTypes` objects)
+ */
+
+function makeSimulator(eventType) {
+  return function (domNode, eventData) {
+    if (React.isValidElement(domNode)) {
+      throw new Error('TestUtils.Simulate expected a DOM node as the first argument but received ' + 'a React element. Pass the DOM node you wish to simulate the event on instead. ' + 'Note that TestUtils.Simulate will not work if you are using shallow rendering.');
+    }
+
+    if (isCompositeComponent(domNode)) {
+      throw new Error('TestUtils.Simulate expected a DOM node as the first argument but received ' + 'a component instance. Pass the DOM node you wish to simulate the event on instead.');
+    }
+
+    const reactName = 'on' + eventType[0].toUpperCase() + eventType.slice(1);
+    const fakeNativeEvent = new Event();
+    fakeNativeEvent.target = domNode;
+    fakeNativeEvent.type = eventType.toLowerCase();
+    const targetInst = getInstanceFromNode(domNode);
+    const event = new SyntheticEvent(reactName, fakeNativeEvent.type, targetInst, fakeNativeEvent, domNode); // Since we aren't using pooling, always persist the event. This will make
+    // sure it's marked and won't warn when setting additional properties.
+
+    event.persist();
+    assign(event, eventData);
+
+    if (directDispatchEventTypes.has(eventType)) {
+      accumulateDirectDispatchesSingle(event);
+    } else {
+      accumulateTwoPhaseDispatchesSingle(event);
+    }
+
+    ReactDOM.unstable_batchedUpdates(function () {
+      // Normally extractEvent enqueues a state restore, but we'll just always
+      // do that since we're by-passing it here.
+      enqueueStateRestore(domNode);
+      executeDispatchesAndRelease(event);
+      rethrowCaughtError();
+    });
+    restoreStateIfNeeded();
+  };
+} // A one-time snapshot with no plans to update. We'll probably want to deprecate Simulate API.
+
+
+const simulatedEventTypes = ['blur', 'cancel', 'click', 'close', 'contextMenu', 'copy', 'cut', 'auxClick', 'doubleClick', 'dragEnd', 'dragStart', 'drop', 'focus', 'input', 'invalid', 'keyDown', 'keyPress', 'keyUp', 'mouseDown', 'mouseUp', 'paste', 'pause', 'play', 'pointerCancel', 'pointerDown', 'pointerUp', 'rateChange', 'reset', 'resize', 'seeked', 'submit', 'touchCancel', 'touchEnd', 'touchStart', 'volumeChange', 'drag', 'dragEnter', 'dragExit', 'dragLeave', 'dragOver', 'mouseMove', 'mouseOut', 'mouseOver', 'pointerMove', 'pointerOut', 'pointerOver', 'scroll', 'toggle', 'touchMove', 'wheel', 'abort', 'animationEnd', 'animationIteration', 'animationStart', 'canPlay', 'canPlayThrough', 'durationChange', 'emptied', 'encrypted', 'ended', 'error', 'gotPointerCapture', 'load', 'loadedData', 'loadedMetadata', 'loadStart', 'lostPointerCapture', 'playing', 'progress', 'seeking', 'stalled', 'suspend', 'timeUpdate', 'transitionEnd', 'waiting', 'mouseEnter', 'mouseLeave', 'pointerEnter', 'pointerLeave', 'change', 'select', 'beforeInput', 'compositionEnd', 'compositionStart', 'compositionUpdate'];
+
+function buildSimulators() {
+  simulatedEventTypes.forEach(eventType => {
+    Simulate[eventType] = makeSimulator(eventType);
+  });
+}
+
+buildSimulators();
+
+exports.Simulate = Simulate;
+exports.act = act;
+exports.findAllInRenderedTree = findAllInRenderedTree;
+exports.findRenderedComponentWithType = findRenderedComponentWithType;
+exports.findRenderedDOMComponentWithClass = findRenderedDOMComponentWithClass;
+exports.findRenderedDOMComponentWithTag = findRenderedDOMComponentWithTag;
+exports.isCompositeComponent = isCompositeComponent;
+exports.isCompositeComponentWithType = isCompositeComponentWithType;
+exports.isDOMComponent = isDOMComponent;
+exports.isDOMComponentElement = isDOMComponentElement;
+exports.isElement = isElement;
+exports.isElementOfType = isElementOfType;
+exports.mockComponent = mockComponent;
+exports.nativeTouchData = nativeTouchData;
+exports.renderIntoDocument = renderIntoDocument;
+exports.scryRenderedComponentsWithType = scryRenderedComponentsWithType;
+exports.scryRenderedDOMComponentsWithClass = scryRenderedDOMComponentsWithClass;
+exports.scryRenderedDOMComponentsWithTag = scryRenderedDOMComponentsWithTag;
+exports.traverseTwoPhase = traverseTwoPhase;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom.development.js b/packages/next/src/compiled/react-dom/cjs/react-dom.development.js
index 65b6ddc4f6c62..e57be62adbcc6 100644
--- a/packages/next/src/compiled/react-dom/cjs/react-dom.development.js
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom.development.js
@@ -1079,7 +1079,7 @@ var DefaultHydrationLane =
 var DefaultLane =
 /*                     */
 32;
-var SyncUpdateLanes = SyncLane;
+var SyncUpdateLanes = SyncLane | InputContinuousLane | DefaultLane ;
 var TransitionHydrationLane =
 /*                */
 64;
@@ -1234,6 +1234,13 @@ var nextTransitionLane = TransitionLane1;
 var nextRetryLane = RetryLane1;
 
 function getHighestPriorityLanes(lanes) {
+  {
+    var pendingSyncLanes = lanes & SyncUpdateLanes;
+
+    if (pendingSyncLanes !== 0) {
+      return pendingSyncLanes;
+    }
+  }
 
   switch (getHighestPriorityLane(lanes)) {
     case SyncHydrationLane:
@@ -1833,7 +1840,9 @@ function getBumpedLaneForHydration(root, renderLanes) {
   var renderLane = getHighestPriorityLane(renderLanes);
   var lane;
 
-  {
+  if ((renderLane & SyncUpdateLanes) !== NoLane) {
+    lane = SyncHydrationLane;
+  } else {
     switch (renderLane) {
       case SyncLane:
         lane = SyncHydrationLane;
@@ -2615,6 +2624,18 @@ var componentFrameCache;
   var PossiblyWeakMap$1 = typeof WeakMap === 'function' ? WeakMap : Map;
   componentFrameCache = new PossiblyWeakMap$1();
 }
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
@@ -2630,7 +2651,6 @@ function describeNativeComponentFrame(fn, construct) {
     }
   }
 
-  var control;
   reentry = true;
   var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
 
@@ -2644,81 +2664,140 @@ function describeNativeComponentFrame(fn, construct) {
     ReactCurrentDispatcher$2.current = null;
     disableLogs();
   }
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
 
-  try {
-    // This should throw.
-    if (construct) {
-      // Something should be setting the props in the constructor.
-      var Fake = function () {
-        throw Error();
-      }; // $FlowFixMe[prop-missing]
 
+  var RunInRootFrame = {
+    DetermineComponentFrameRoot: function () {
+      var control;
 
-      Object.defineProperty(Fake.prototype, 'props', {
-        set: function () {
-          // We use a throwing setter instead of frozen or non-writable props
-          // because that won't throw in a non-strict mode function.
-          throw Error();
-        }
-      });
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          var Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
 
-      if (typeof Reflect === 'object' && Reflect.construct) {
-        // We construct a different control for this case to include any extra
-        // frames added by the construct call.
-        try {
-          Reflect.construct(Fake, []);
-        } catch (x) {
-          control = x;
-        }
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
 
-        Reflect.construct(fn, [], Fake);
-      } else {
-        try {
-          Fake.call();
-        } catch (x) {
-          control = x;
-        } // $FlowFixMe[prop-missing] found when upgrading Flow
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
 
 
-        fn.call(Fake.prototype);
-      }
-    } else {
-      try {
-        throw Error();
-      } catch (x) {
-        control = x;
-      } // TODO(luna): This will currently only throw if the function component
-      // tries to access React/ReactDOM/props. We should probably make this throw
-      // in simple components too
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
 
 
-      var maybePromise = fn(); // If the function component returns a promise, it's likely an async
-      // component, which we don't yet support. Attach a noop catch handler to
-      // silence the error.
-      // TODO: Implement component stacks for async client components?
+          var maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
 
-      if (maybePromise && typeof maybePromise.catch === 'function') {
-        maybePromise.catch(function () {});
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(function () {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
       }
+
+      return [null, null];
     }
-  } catch (sample) {
-    // This is inlined manually because closure doesn't do it for us.
-    if (sample && control && typeof sample.stack === 'string') {
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
+
+  try {
+    var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
+
+    if (sampleStack && controlStack) {
       // This extracts the first frame from the sample that isn't also in the control.
       // Skipping one frame that we assume is the frame that calls the two.
-      var sampleLines = sample.stack.split('\n');
-      var controlLines = control.stack.split('\n');
-      var s = sampleLines.length - 1;
-      var c = controlLines.length - 1;
+      var sampleLines = sampleStack.split('\n');
+      var controlLines = controlStack.split('\n');
+      var s = 0;
+      var c = 0;
 
-      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
-        // We expect at least one stack frame to be shared.
-        // Typically this will be the root most one. However, stack frames may be
-        // cut off due to maximum stack limits. In this case, one maybe cut off
-        // earlier than the other. We assume that the sample is longer or the same
-        // and there for cut off earlier. So we should find the root most frame in
-        // the sample somewhere in the control.
-        c--;
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
       }
 
       for (; s >= 1 && c >= 0; s--, c--) {
@@ -2747,7 +2826,7 @@ function describeNativeComponentFrame(fn, construct) {
                   _frame = _frame.replace('<anonymous>', fn.displayName);
                 }
 
-                {
+                if (true) {
                   if (typeof fn === 'function') {
                     componentFrameCache.set(fn, _frame);
                   }
@@ -27948,7 +28027,7 @@ identifierPrefix, onRecoverableError, transitionCallbacks, formState) {
   return root;
 }
 
-var ReactVersion = '18.3.0-canary-2983249dd-20231107';
+var ReactVersion = '18.3.0-canary-7508dcd5c-20231108';
 
 function createPortal$1(children, containerInfo, // TODO: figure out the API for cross-renderer implementation.
 implementation) {
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom.production.js b/packages/next/src/compiled/react-dom/cjs/react-dom.production.js
new file mode 100644
index 0000000000000..adbf76534a666
--- /dev/null
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom.production.js
@@ -0,0 +1,27570 @@
+/**
+ * @license React
+ * react-dom.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require("next/dist/compiled/react");
+var Scheduler = require("next/dist/compiled/scheduler");
+
+const Internals = {
+  usingClientEntryPoint: false,
+  Events: null,
+  Dispatcher: {
+    current: null
+  }
+};
+
+// Do not require this module directly! Use normal `invariant` calls with
+// template literal strings. The messages will be replaced with error codes
+// during build.
+function formatProdErrorMessage(code) {
+  let url = 'https://reactjs.org/docs/error-decoder.html?invariant=' + code;
+
+  for (let i = 1; i < arguments.length; i++) {
+    url += '&args[]=' + encodeURIComponent(arguments[i]);
+  }
+
+  return "Minified React error #" + code + "; visit " + url + " for the full message or " + 'use the non-minified dev environment for full errors and additional ' + 'helpful warnings.';
+}
+
+const assign = Object.assign;
+
+// -----------------------------------------------------------------------------
+// Killswitch
+//
+// Flags that exist solely to turn off a change in case it causes a regression
+// when it rolls out to prod. We should remove these as soon as possible.
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+// Land or remove (moderate effort)
+//
+// Flags that can be probably deleted or landed, but might require extra effort
+// like migrating internal callers or performance testing.
+// -----------------------------------------------------------------------------
+// TODO: Finish rolling out in www
+
+const enableClientRenderFallbackOnTextMismatch = true;
+const enableFormActions = true;
+const enableAsyncActions = true; // Not sure if www still uses this. We don't have a replacement but whatever we
+// Slated for removal in the future (significant effort)
+//
+// These are experiments that didn't work out, and never shipped, but we can't
+// delete from the codebase until we migrate internal callers.
+// -----------------------------------------------------------------------------
+// Add a callback property to suspense to notify which promises are currently
+// in the update queue. This allows reporting and tracing of what is causing
+// the user to see a loading state.
+//
+// Also allows hydration callbacks to fire when a dehydrated boundary gets
+// hydrated or deleted.
+//
+// This will eventually be replaced by the Transition Tracing proposal.
+
+const enableSuspenseCallback = false; // Experimental Scope support.
+
+const enableLazyContextPropagation = false; // FB-only usage. The new API has different semantics.
+
+const enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber
+const enableHostSingletons = true;
+const alwaysThrottleRetries = true;
+// Chopping Block
+//
+// Planned feature deprecations and breaking changes. Sorted roughly in order of
+// when we plan to enable them.
+// -----------------------------------------------------------------------------
+// This flag enables Strict Effects by default. We're not turning this on until
+// after 18 because it requires migration work. Recommendation is to use
+// <StrictMode /> to gradually upgrade components.
+// If TRUE, trees rendered with createRoot will be StrictEffectsMode.
+// If FALSE, these trees will be StrictLegacyMode.
+
+const createRootStrictEffectsByDefault = false;
+// React DOM Chopping Block
+//
+// Similar to main Chopping Block but only flags related to React DOM. These are
+// grouped because we will likely batch all of them into a single major release.
+// -----------------------------------------------------------------------------
+// Disable support for comment nodes as React DOM containers. Already disabled
+// in open source, but www codebase still relies on it. Need to remove.
+
+const disableCommentsAsDOMContainers = true; // Disable javascript: URL strings in href for XSS protection.
+// Debugging and DevTools
+// -----------------------------------------------------------------------------
+// Adds user timing marks for e.g. state updates, suspense, and work loop stuff,
+// for an experimental timeline tool.
+
+const enableSchedulingProfiler = false; // Helps identify side effects in render-phase lifecycle hooks and setState
+
+const enableProfilerTimer = false; // Record durations for commit and passive effects phases.
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactCurrentDispatcher$2 = ReactSharedInternals.ReactCurrentDispatcher; // Since the "not pending" value is always the same, we can reuse the
+// same object across all transitions.
+
+const sharedNotPendingObject = {
+  pending: false,
+  data: null,
+  method: null,
+  action: null
+};
+const NotPending = sharedNotPendingObject;
+
+function resolveDispatcher() {
+  // Copied from react/src/ReactHooks.js. It's the same thing but in a
+  // different package.
+  const dispatcher = ReactCurrentDispatcher$2.current;
+  // intentionally don't throw our own error because this is in a hot path.
+  // Also helps ensure this is inlined.
+
+
+  return dispatcher;
+}
+
+function useFormStatus() {
+  {
+    const dispatcher = resolveDispatcher(); // $FlowFixMe[not-a-function] We know this exists because of the feature check above.
+
+    return dispatcher.useHostTransitionStatus();
+  }
+}
+function useFormState(action, initialState, permalink) {
+  {
+    const dispatcher = resolveDispatcher(); // $FlowFixMe[not-a-function] This is unstable, thus optional
+
+    return dispatcher.useFormState(action, initialState, permalink);
+  }
+}
+
+const valueStack = [];
+
+let index = -1;
+
+function createCursor(defaultValue) {
+  return {
+    current: defaultValue
+  };
+}
+
+function pop(cursor, fiber) {
+  if (index < 0) {
+
+    return;
+  }
+
+  cursor.current = valueStack[index];
+  valueStack[index] = null;
+
+  index--;
+}
+
+function push(cursor, value, fiber) {
+  index++;
+  valueStack[index] = cursor.current;
+
+  cursor.current = value;
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+const REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_CONTEXT_TYPE = Symbol.for('react.context');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SCOPE_TYPE = Symbol.for('react.scope');
+const REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');
+const REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+const REACT_LEGACY_HIDDEN_TYPE = Symbol.for('react.legacy_hidden');
+const REACT_CACHE_TYPE = Symbol.for('react.cache');
+const REACT_TRACING_MARKER_TYPE = Symbol.for('react.tracing_marker');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+const contextStackCursor$1 = createCursor(null);
+const contextFiberStackCursor = createCursor(null);
+const rootInstanceStackCursor = createCursor(null); // Represents the nearest host transition provider (in React DOM, a <form />)
+// NOTE: Since forms cannot be nested, and this feature is only implemented by
+// React DOM, we don't technically need this to be a stack. It could be a single
+// module variable instead.
+
+const hostTransitionProviderCursor = createCursor(null); // TODO: This should initialize to NotPendingTransition, a constant
+// imported from the fiber config. However, because of a cycle in the module
+// graph, that value isn't defined during this module's initialization. I can't
+// think of a way to work around this without moving that value out of the
+// fiber config. For now, the "no provider" case is handled when reading,
+// inside useHostTransitionStatus.
+
+const HostTransitionContext = {
+  $$typeof: REACT_CONTEXT_TYPE,
+  _currentValue: null,
+  _currentValue2: null,
+  _threadCount: 0,
+  Provider: null,
+  Consumer: null,
+  _defaultValue: null,
+  _globalName: null
+};
+
+function requiredContext(c) {
+
+  return c;
+}
+
+function getCurrentRootHostContainer() {
+  return rootInstanceStackCursor.current;
+}
+
+function getRootHostContainer() {
+  const rootInstance = requiredContext(rootInstanceStackCursor.current);
+  return rootInstance;
+}
+
+function pushHostContainer(fiber, nextRootInstance) {
+  // Push current root instance onto the stack;
+  // This allows us to reset root when portals are popped.
+  push(rootInstanceStackCursor, nextRootInstance); // Track the context and the Fiber that provided it.
+  // This enables us to pop only Fibers that provide unique contexts.
+
+  push(contextFiberStackCursor, fiber); // Finally, we need to push the host context to the stack.
+  // However, we can't just call getRootHostContext() and push it because
+  // we'd have a different number of entries on the stack depending on
+  // whether getRootHostContext() throws somewhere in renderer code or not.
+  // So we push an empty value first. This lets us safely unwind on errors.
+
+  push(contextStackCursor$1, null);
+  const nextRootContext = getRootHostContext(nextRootInstance); // Now that we know this function doesn't throw, replace it.
+
+  pop(contextStackCursor$1);
+  push(contextStackCursor$1, nextRootContext);
+}
+
+function popHostContainer(fiber) {
+  pop(contextStackCursor$1);
+  pop(contextFiberStackCursor);
+  pop(rootInstanceStackCursor);
+}
+
+function getHostContext() {
+  const context = requiredContext(contextStackCursor$1.current);
+  return context;
+}
+
+function pushHostContext(fiber) {
+  {
+    const stateHook = fiber.memoizedState;
+
+    if (stateHook !== null) {
+      // Only provide context if this fiber has been upgraded by a host
+      // transition. We use the same optimization for regular host context below.
+      push(hostTransitionProviderCursor, fiber);
+    }
+  }
+
+  const context = requiredContext(contextStackCursor$1.current);
+  const nextContext = getChildHostContext(context, fiber.type); // Don't push this Fiber's context unless it's unique.
+
+  if (context !== nextContext) {
+    // Track the context and the Fiber that provided it.
+    // This enables us to pop only Fibers that provide unique contexts.
+    push(contextFiberStackCursor, fiber);
+    push(contextStackCursor$1, nextContext);
+  }
+}
+
+function popHostContext(fiber) {
+  if (contextFiberStackCursor.current === fiber) {
+    // Do not pop unless this Fiber provided the current context.
+    // pushHostContext() only pushes Fibers that provide unique contexts.
+    pop(contextStackCursor$1);
+    pop(contextFiberStackCursor);
+  }
+
+  {
+    if (hostTransitionProviderCursor.current === fiber) {
+      // Do not pop unless this Fiber provided the current context. This is mostly
+      // a performance optimization, but conveniently it also prevents a potential
+      // data race where a host provider is upgraded (i.e. memoizedState becomes
+      // non-null) during a concurrent event. This is a bit of a flaw in the way
+      // we upgrade host components, but because we're accounting for it here, it
+      // should be fine.
+      pop(hostTransitionProviderCursor); // When popping the transition provider, we reset the context value back
+      // to `null`. We can do this because you're not allowd to nest forms. If
+      // we allowed for multiple nested host transition providers, then we'd
+      // need to reset this to the parent provider's status.
+
+      {
+        HostTransitionContext._currentValue = null;
+      }
+    }
+  }
+}
+
+const NoFlags$1 =
+/*                      */
+0b0000000000000000000000000000;
+const PerformedWork =
+/*                */
+0b0000000000000000000000000001;
+const Placement =
+/*                    */
+0b0000000000000000000000000010;
+const DidCapture =
+/*                   */
+0b0000000000000000000010000000;
+const Hydrating =
+/*                    */
+0b0000000000000001000000000000; // You can change the rest (and add more).
+
+const Update =
+/*                       */
+0b0000000000000000000000000100;
+/* Skipped value:                                 0b0000000000000000000000001000; */
+
+const ChildDeletion =
+/*                */
+0b0000000000000000000000010000;
+const ContentReset =
+/*                 */
+0b0000000000000000000000100000;
+const Callback =
+/*                     */
+0b0000000000000000000001000000;
+/* Used by DidCapture:                            0b0000000000000000000010000000; */
+
+const ForceClientRender =
+/*            */
+0b0000000000000000000100000000;
+const Ref =
+/*                          */
+0b0000000000000000001000000000;
+const Snapshot =
+/*                     */
+0b0000000000000000010000000000;
+const Passive$1 =
+/*                      */
+0b0000000000000000100000000000;
+/* Used by Hydrating:                             0b0000000000000001000000000000; */
+
+const Visibility =
+/*                   */
+0b0000000000000010000000000000;
+const StoreConsistency =
+/*             */
+0b0000000000000100000000000000; // It's OK to reuse these bits because these flags are mutually exclusive for
+// different fiber types. We should really be doing this for as many flags as
+// possible, because we're about to run out of bits.
+
+const ScheduleRetry = StoreConsistency;
+const ShouldSuspendCommit = Visibility;
+const LifecycleEffectMask = Passive$1 | Update | Callback | Ref | Snapshot | StoreConsistency; // Union of all commit flags (flags with the lifetime of a particular commit)
+
+const HostEffectMask =
+/*               */
+0b0000000000000111111111111111; // These are not really side effects, but we still reuse this field.
+
+const Incomplete =
+/*                   */
+0b0000000000001000000000000000;
+const ShouldCapture =
+/*                */
+0b0000000000010000000000000000;
+const ForceUpdateForLegacySuspense =
+/* */
+0b0000000000100000000000000000;
+const Forked =
+/*                       */
+0b0000000100000000000000000000; // Static tags describe aspects of a fiber that are not specific to a render,
+// e.g. a fiber uses a passive effect (even if there are no updates on this particular render).
+// This enables us to defer more work in the unmount case,
+// since we can defer traversing the tree during layout to look for Passive effects,
+// and instead rely on the static flag as a signal that there may be cleanup work.
+
+const RefStatic =
+/*                    */
+0b0000001000000000000000000000;
+const LayoutStatic =
+/*                 */
+0b0000010000000000000000000000;
+const PassiveStatic =
+/*                */
+0b0000100000000000000000000000;
+const MaySuspendCommit =
+/*             */
+0b0001000000000000000000000000; // Flag used to identify newly inserted fibers. It isn't reset after commit unlike `Placement`.
+
+const PlacementDEV =
+/*                 */
+0b0010000000000000000000000000;
+// don't contain effects, by checking subtreeFlags.
+
+const BeforeMutationMask = // TODO: Remove Update flag from before mutation phase by re-landing Visibility
+// flag logic (see #20043)
+Update | Snapshot | (0);
+const MutationMask = Placement | Update | ChildDeletion | ContentReset | Ref | Hydrating | Visibility;
+const LayoutMask = Update | Callback | Ref | Visibility; // TODO: Split into PassiveMountMask and PassiveUnmountMask
+
+const PassiveMask = Passive$1 | Visibility | ChildDeletion; // Union of tags that don't get reset on clones.
+// This allows certain concepts to persist without recalculating them,
+// e.g. whether a subtree contains passive effects or portals.
+
+const StaticMask = LayoutStatic | PassiveStatic | RefStatic | MaySuspendCommit;
+
+// This module only exists as an ESM wrapper around the external CommonJS
+const scheduleCallback$3 = Scheduler.unstable_scheduleCallback;
+const cancelCallback$1 = Scheduler.unstable_cancelCallback;
+const shouldYield = Scheduler.unstable_shouldYield;
+const requestPaint = Scheduler.unstable_requestPaint;
+const now = Scheduler.unstable_now;
+const getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel;
+const ImmediatePriority = Scheduler.unstable_ImmediatePriority;
+const UserBlockingPriority = Scheduler.unstable_UserBlockingPriority;
+const NormalPriority$1 = Scheduler.unstable_NormalPriority;
+const LowPriority = Scheduler.unstable_LowPriority;
+const IdlePriority = Scheduler.unstable_IdlePriority; // this doesn't actually exist on the scheduler, but it *does*
+
+let rendererID = null;
+let injectedHook = null;
+function injectInternals(internals) {
+  if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {
+    // No DevTools
+    return false;
+  }
+
+  const hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+
+  if (hook.isDisabled) {
+    // This isn't a real property on the hook, but it can be set to opt out
+    // of DevTools integration and associated warnings and logs.
+    // https://github.com/facebook/react/issues/3877
+    return true;
+  }
+
+  if (!hook.supportsFiber) {
+
+
+    return true;
+  }
+
+  try {
+    if (enableSchedulingProfiler) ;
+
+    rendererID = hook.inject(internals); // We have successfully injected, so now it is safe to set up hooks.
+
+    injectedHook = hook;
+  } catch (err) {
+  }
+
+  if (hook.checkDCE) {
+    // This is the real DevTools.
+    return true;
+  } else {
+    // This is likely a hook installed by Fast Refresh runtime.
+    return false;
+  }
+}
+function onCommitRoot(root, eventPriority) {
+  if (injectedHook && typeof injectedHook.onCommitFiberRoot === 'function') {
+    try {
+      const didError = (root.current.flags & DidCapture) === DidCapture;
+
+      if (enableProfilerTimer) ; else {
+        injectedHook.onCommitFiberRoot(rendererID, root, undefined, didError);
+      }
+    } catch (err) {
+    }
+  }
+}
+function onPostCommitRoot(root) {
+  if (injectedHook && typeof injectedHook.onPostCommitFiberRoot === 'function') {
+    try {
+      injectedHook.onPostCommitFiberRoot(rendererID, root);
+    } catch (err) {
+    }
+  }
+}
+function onCommitUnmount(fiber) {
+  if (injectedHook && typeof injectedHook.onCommitFiberUnmount === 'function') {
+    try {
+      injectedHook.onCommitFiberUnmount(rendererID, fiber);
+    } catch (err) {
+    }
+  }
+}
+
+function injectProfilingHooks(profilingHooks) {
+}
+
+function getLaneLabelMap() {
+  {
+    return null;
+  }
+}
+
+const NoMode =
+/*                         */
+0b0000000; // TODO: Remove ConcurrentMode by reading from the root tag instead
+
+const ConcurrentMode =
+/*                 */
+0b0000001;
+const ProfileMode =
+/*                    */
+0b0000010;
+const StrictLegacyMode =
+/*               */
+0b0001000;
+const StrictEffectsMode =
+/*              */
+0b0010000;
+
+// TODO: This is pretty well supported by browsers. Maybe we can drop it.
+const 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
+
+const log = Math.log;
+const LN2 = Math.LN2;
+
+function clz32Fallback(x) {
+  const asUint = x >>> 0;
+
+  if (asUint === 0) {
+    return 32;
+  }
+
+  return 31 - (log(asUint) / LN2 | 0) | 0;
+}
+
+// TODO: Ideally these types would be opaque but that doesn't work well with
+// If those values are changed that package should be rebuilt and redeployed.
+
+const TotalLanes = 31;
+const NoLanes =
+/*                        */
+0b0000000000000000000000000000000;
+const NoLane =
+/*                          */
+0b0000000000000000000000000000000;
+const SyncHydrationLane =
+/*               */
+0b0000000000000000000000000000001;
+const SyncLane =
+/*                        */
+0b0000000000000000000000000000010;
+const SyncLaneIndex = 1;
+const InputContinuousHydrationLane =
+/*    */
+0b0000000000000000000000000000100;
+const InputContinuousLane =
+/*             */
+0b0000000000000000000000000001000;
+const DefaultHydrationLane =
+/*            */
+0b0000000000000000000000000010000;
+const DefaultLane =
+/*                     */
+0b0000000000000000000000000100000;
+const SyncUpdateLanes = SyncLane | InputContinuousLane | DefaultLane ;
+const TransitionHydrationLane =
+/*                */
+0b0000000000000000000000001000000;
+const TransitionLanes =
+/*                       */
+0b0000000001111111111111110000000;
+const TransitionLane1 =
+/*                        */
+0b0000000000000000000000010000000;
+const TransitionLane2 =
+/*                        */
+0b0000000000000000000000100000000;
+const TransitionLane3 =
+/*                        */
+0b0000000000000000000001000000000;
+const TransitionLane4 =
+/*                        */
+0b0000000000000000000010000000000;
+const TransitionLane5 =
+/*                        */
+0b0000000000000000000100000000000;
+const TransitionLane6 =
+/*                        */
+0b0000000000000000001000000000000;
+const TransitionLane7 =
+/*                        */
+0b0000000000000000010000000000000;
+const TransitionLane8 =
+/*                        */
+0b0000000000000000100000000000000;
+const TransitionLane9 =
+/*                        */
+0b0000000000000001000000000000000;
+const TransitionLane10 =
+/*                       */
+0b0000000000000010000000000000000;
+const TransitionLane11 =
+/*                       */
+0b0000000000000100000000000000000;
+const TransitionLane12 =
+/*                       */
+0b0000000000001000000000000000000;
+const TransitionLane13 =
+/*                       */
+0b0000000000010000000000000000000;
+const TransitionLane14 =
+/*                       */
+0b0000000000100000000000000000000;
+const TransitionLane15 =
+/*                       */
+0b0000000001000000000000000000000;
+const RetryLanes =
+/*                            */
+0b0000011110000000000000000000000;
+const RetryLane1 =
+/*                             */
+0b0000000010000000000000000000000;
+const RetryLane2 =
+/*                             */
+0b0000000100000000000000000000000;
+const RetryLane3 =
+/*                             */
+0b0000001000000000000000000000000;
+const RetryLane4 =
+/*                             */
+0b0000010000000000000000000000000;
+const SomeRetryLane = RetryLane1;
+const SelectiveHydrationLane =
+/*          */
+0b0000100000000000000000000000000;
+const NonIdleLanes =
+/*                          */
+0b0000111111111111111111111111111;
+const IdleHydrationLane =
+/*               */
+0b0001000000000000000000000000000;
+const IdleLane =
+/*                        */
+0b0010000000000000000000000000000;
+const OffscreenLane =
+/*                   */
+0b0100000000000000000000000000000;
+const DeferredLane =
+/*                    */
+0b1000000000000000000000000000000; // Any lane that might schedule an update. This is used to detect infinite
+// update loops, so it doesn't include hydration lanes or retries.
+
+const UpdateLanes = SyncLane | InputContinuousLane | DefaultLane | TransitionLanes; // This function is used for the experimental timeline (react-devtools-timeline)
+const NoTimestamp = -1;
+let nextTransitionLane = TransitionLane1;
+let nextRetryLane = RetryLane1;
+
+function getHighestPriorityLanes(lanes) {
+  {
+    const pendingSyncLanes = lanes & SyncUpdateLanes;
+
+    if (pendingSyncLanes !== 0) {
+      return pendingSyncLanes;
+    }
+  }
+
+  switch (getHighestPriorityLane(lanes)) {
+    case SyncHydrationLane:
+      return SyncHydrationLane;
+
+    case SyncLane:
+      return SyncLane;
+
+    case InputContinuousHydrationLane:
+      return InputContinuousHydrationLane;
+
+    case InputContinuousLane:
+      return InputContinuousLane;
+
+    case DefaultHydrationLane:
+      return DefaultHydrationLane;
+
+    case DefaultLane:
+      return DefaultLane;
+
+    case TransitionHydrationLane:
+      return TransitionHydrationLane;
+
+    case TransitionLane1:
+    case TransitionLane2:
+    case TransitionLane3:
+    case TransitionLane4:
+    case TransitionLane5:
+    case TransitionLane6:
+    case TransitionLane7:
+    case TransitionLane8:
+    case TransitionLane9:
+    case TransitionLane10:
+    case TransitionLane11:
+    case TransitionLane12:
+    case TransitionLane13:
+    case TransitionLane14:
+    case TransitionLane15:
+      return lanes & TransitionLanes;
+
+    case RetryLane1:
+    case RetryLane2:
+    case RetryLane3:
+    case RetryLane4:
+      return lanes & RetryLanes;
+
+    case SelectiveHydrationLane:
+      return SelectiveHydrationLane;
+
+    case IdleHydrationLane:
+      return IdleHydrationLane;
+
+    case IdleLane:
+      return IdleLane;
+
+    case OffscreenLane:
+      return OffscreenLane;
+
+    case DeferredLane:
+      // This shouldn't be reachable because deferred work is always entangled
+      // with something else.
+      return NoLanes;
+
+    default:
+
+
+      return lanes;
+  }
+}
+
+function getNextLanes(root, wipLanes) {
+  // Early bailout if there's no pending work left.
+  const pendingLanes = root.pendingLanes;
+
+  if (pendingLanes === NoLanes) {
+    return NoLanes;
+  }
+
+  let nextLanes = NoLanes;
+  const suspendedLanes = root.suspendedLanes;
+  const pingedLanes = root.pingedLanes; // Do not work on any idle work until all the non-idle work has finished,
+  // even if the work is suspended.
+
+  const nonIdlePendingLanes = pendingLanes & NonIdleLanes;
+
+  if (nonIdlePendingLanes !== NoLanes) {
+    const nonIdleUnblockedLanes = nonIdlePendingLanes & ~suspendedLanes;
+
+    if (nonIdleUnblockedLanes !== NoLanes) {
+      nextLanes = getHighestPriorityLanes(nonIdleUnblockedLanes);
+    } else {
+      const nonIdlePingedLanes = nonIdlePendingLanes & pingedLanes;
+
+      if (nonIdlePingedLanes !== NoLanes) {
+        nextLanes = getHighestPriorityLanes(nonIdlePingedLanes);
+      }
+    }
+  } else {
+    // The only remaining work is Idle.
+    const unblockedLanes = pendingLanes & ~suspendedLanes;
+
+    if (unblockedLanes !== NoLanes) {
+      nextLanes = getHighestPriorityLanes(unblockedLanes);
+    } else {
+      if (pingedLanes !== NoLanes) {
+        nextLanes = getHighestPriorityLanes(pingedLanes);
+      }
+    }
+  }
+
+  if (nextLanes === NoLanes) {
+    // This should only be reachable if we're suspended
+    // TODO: Consider warning in this path if a fallback timer is not scheduled.
+    return NoLanes;
+  } // If we're already in the middle of a render, switching lanes will interrupt
+  // it and we'll lose our progress. We should only do this if the new lanes are
+  // higher priority.
+
+
+  if (wipLanes !== NoLanes && wipLanes !== nextLanes && // If we already suspended with a delay, then interrupting is fine. Don't
+  // bother waiting until the root is complete.
+  (wipLanes & suspendedLanes) === NoLanes) {
+    const nextLane = getHighestPriorityLane(nextLanes);
+    const wipLane = getHighestPriorityLane(wipLanes);
+
+    if ( // Tests whether the next lane is equal or lower priority than the wip
+    // one. This works because the bits decrease in priority as you go left.
+    nextLane >= wipLane || // Default priority updates should not interrupt transition updates. The
+    // only difference between default updates and transition updates is that
+    // default updates do not support refresh transitions.
+    nextLane === DefaultLane && (wipLane & TransitionLanes) !== NoLanes) {
+      // Keep working on the existing in-progress tree. Do not interrupt.
+      return wipLanes;
+    }
+  }
+
+  return nextLanes;
+}
+function getEntangledLanes(root, renderLanes) {
+  let entangledLanes = renderLanes;
+
+  if ((entangledLanes & InputContinuousLane) !== NoLanes) {
+    // When updates are sync by default, we entangle continuous priority updates
+    // and default updates, so they render in the same batch. The only reason
+    // they use separate lanes is because continuous updates should interrupt
+    // transitions, but default updates should not.
+    entangledLanes |= entangledLanes & DefaultLane;
+  } // Check for entangled lanes and add them to the batch.
+  //
+  // A lane is said to be entangled with another when it's not allowed to render
+  // in a batch that does not also include the other lane. Typically we do this
+  // when multiple updates have the same source, and we only want to respond to
+  // the most recent event from that source.
+  //
+  // Note that we apply entanglements *after* checking for partial work above.
+  // This means that if a lane is entangled during an interleaved event while
+  // it's already rendering, we won't interrupt it. This is intentional, since
+  // entanglement is usually "best effort": we'll try our best to render the
+  // lanes in the same batch, but it's not worth throwing out partially
+  // completed work in order to do it.
+  // TODO: Reconsider this. The counter-argument is that the partial work
+  // represents an intermediate state, which we don't want to show to the user.
+  // And by spending extra time finishing it, we're increasing the amount of
+  // time it takes to show the final state, which is what they are actually
+  // waiting for.
+  //
+  // For those exceptions where entanglement is semantically important,
+  // we should ensure that there is no partial work at the
+  // time we apply the entanglement.
+
+
+  const allEntangledLanes = root.entangledLanes;
+
+  if (allEntangledLanes !== NoLanes) {
+    const entanglements = root.entanglements;
+    let lanes = entangledLanes & allEntangledLanes;
+
+    while (lanes > 0) {
+      const index = pickArbitraryLaneIndex(lanes);
+      const lane = 1 << index;
+      entangledLanes |= entanglements[index];
+      lanes &= ~lane;
+    }
+  }
+
+  return entangledLanes;
+}
+
+function computeExpirationTime(lane, currentTime) {
+  switch (lane) {
+    case SyncHydrationLane:
+    case SyncLane:
+    case InputContinuousHydrationLane:
+    case InputContinuousLane:
+      // User interactions should expire slightly more quickly.
+      //
+      // NOTE: This is set to the corresponding constant as in Scheduler.js.
+      // When we made it larger, a product metric in www regressed, suggesting
+      // there's a user interaction that's being starved by a series of
+      // synchronous updates. If that theory is correct, the proper solution is
+      // to fix the starvation. However, this scenario supports the idea that
+      // expiration times are an important safeguard when starvation
+      // does happen.
+      return currentTime + 250;
+
+    case DefaultHydrationLane:
+    case DefaultLane:
+    case TransitionHydrationLane:
+    case TransitionLane1:
+    case TransitionLane2:
+    case TransitionLane3:
+    case TransitionLane4:
+    case TransitionLane5:
+    case TransitionLane6:
+    case TransitionLane7:
+    case TransitionLane8:
+    case TransitionLane9:
+    case TransitionLane10:
+    case TransitionLane11:
+    case TransitionLane12:
+    case TransitionLane13:
+    case TransitionLane14:
+    case TransitionLane15:
+      return currentTime + 5000;
+
+    case RetryLane1:
+    case RetryLane2:
+    case RetryLane3:
+    case RetryLane4:
+      // TODO: Retries should be allowed to expire if they are CPU bound for
+      // too long, but when I made this change it caused a spike in browser
+      // crashes. There must be some other underlying bug; not super urgent but
+      // ideally should figure out why and fix it. Unfortunately we don't have
+      // a repro for the crashes, only detected via production metrics.
+      return NoTimestamp;
+
+    case SelectiveHydrationLane:
+    case IdleHydrationLane:
+    case IdleLane:
+    case OffscreenLane:
+    case DeferredLane:
+      // Anything idle priority or lower should never expire.
+      return NoTimestamp;
+
+    default:
+
+      return NoTimestamp;
+  }
+}
+
+function markStarvedLanesAsExpired(root, currentTime) {
+  // TODO: This gets called every time we yield. We can optimize by storing
+  // the earliest expiration time on the root. Then use that to quickly bail out
+  // of this function.
+  const pendingLanes = root.pendingLanes;
+  const suspendedLanes = root.suspendedLanes;
+  const pingedLanes = root.pingedLanes;
+  const expirationTimes = root.expirationTimes; // Iterate through the pending lanes and check if we've reached their
+  // expiration time. If so, we'll assume the update is being starved and mark
+  // it as expired to force it to finish.
+  // TODO: We should be able to replace this with upgradePendingLanesToSync
+  //
+  // We exclude retry lanes because those must always be time sliced, in order
+  // to unwrap uncached promises.
+  // TODO: Write a test for this
+
+  let lanes = pendingLanes & ~RetryLanes;
+
+  while (lanes > 0) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+    const expirationTime = expirationTimes[index];
+
+    if (expirationTime === NoTimestamp) {
+      // Found a pending lane with no expiration time. If it's not suspended, or
+      // if it's pinged, assume it's CPU-bound. Compute a new expiration time
+      // using the current time.
+      if ((lane & suspendedLanes) === NoLanes || (lane & pingedLanes) !== NoLanes) {
+        // Assumes timestamps are monotonically increasing.
+        expirationTimes[index] = computeExpirationTime(lane, currentTime);
+      }
+    } else if (expirationTime <= currentTime) {
+      // This lane expired
+      root.expiredLanes |= lane;
+    }
+
+    lanes &= ~lane;
+  }
+} // This returns the highest priority pending lanes regardless of whether they
+// are suspended.
+
+function getHighestPriorityPendingLanes(root) {
+  return getHighestPriorityLanes(root.pendingLanes);
+}
+function getLanesToRetrySynchronouslyOnError(root, originallyAttemptedLanes) {
+  if (root.errorRecoveryDisabledLanes & originallyAttemptedLanes) {
+    // The error recovery mechanism is disabled until these lanes are cleared.
+    return NoLanes;
+  }
+
+  const everythingButOffscreen = root.pendingLanes & ~OffscreenLane;
+
+  if (everythingButOffscreen !== NoLanes) {
+    return everythingButOffscreen;
+  }
+
+  if (everythingButOffscreen & OffscreenLane) {
+    return OffscreenLane;
+  }
+
+  return NoLanes;
+}
+function includesSyncLane(lanes) {
+  return (lanes & (SyncLane | SyncHydrationLane)) !== NoLanes;
+}
+function includesNonIdleWork(lanes) {
+  return (lanes & NonIdleLanes) !== NoLanes;
+}
+function includesOnlyRetries(lanes) {
+  return (lanes & RetryLanes) === lanes;
+}
+function includesOnlyNonUrgentLanes(lanes) {
+  // TODO: Should hydration lanes be included here? This function is only
+  // used in `updateDeferredValueImpl`.
+  const UrgentLanes = SyncLane | InputContinuousLane | DefaultLane;
+  return (lanes & UrgentLanes) === NoLanes;
+}
+function includesOnlyTransitions(lanes) {
+  return (lanes & TransitionLanes) === lanes;
+}
+function includesBlockingLane(root, lanes) {
+
+  const SyncDefaultLanes = InputContinuousHydrationLane | InputContinuousLane | DefaultHydrationLane | DefaultLane;
+  return (lanes & SyncDefaultLanes) !== NoLanes;
+}
+function includesExpiredLane(root, lanes) {
+  // This is a separate check from includesBlockingLane because a lane can
+  // expire after a render has already started.
+  return (lanes & root.expiredLanes) !== NoLanes;
+}
+function isTransitionLane(lane) {
+  return (lane & TransitionLanes) !== NoLanes;
+}
+function claimNextTransitionLane() {
+  // Cycle through the lanes, assigning each new transition to the next lane.
+  // In most cases, this means every transition gets its own lane, until we
+  // run out of lanes and cycle back to the beginning.
+  const lane = nextTransitionLane;
+  nextTransitionLane <<= 1;
+
+  if ((nextTransitionLane & TransitionLanes) === NoLanes) {
+    nextTransitionLane = TransitionLane1;
+  }
+
+  return lane;
+}
+function claimNextRetryLane() {
+  const lane = nextRetryLane;
+  nextRetryLane <<= 1;
+
+  if ((nextRetryLane & RetryLanes) === NoLanes) {
+    nextRetryLane = RetryLane1;
+  }
+
+  return lane;
+}
+function getHighestPriorityLane(lanes) {
+  return lanes & -lanes;
+}
+function pickArbitraryLane(lanes) {
+  // This wrapper function gets inlined. Only exists so to communicate that it
+  // doesn't matter which bit is selected; you can pick any bit without
+  // affecting the algorithms where its used. Here I'm using
+  // getHighestPriorityLane because it requires the fewest operations.
+  return getHighestPriorityLane(lanes);
+}
+
+function pickArbitraryLaneIndex(lanes) {
+  return 31 - clz32(lanes);
+}
+
+function laneToIndex(lane) {
+  return pickArbitraryLaneIndex(lane);
+}
+
+function includesSomeLane(a, b) {
+  return (a & b) !== NoLanes;
+}
+function isSubsetOfLanes(set, subset) {
+  return (set & subset) === subset;
+}
+function mergeLanes(a, b) {
+  return a | b;
+}
+function removeLanes(set, subset) {
+  return set & ~subset;
+}
+function intersectLanes(a, b) {
+  return a & b;
+} // Seems redundant, but it changes the type from a single lane (used for
+// updates) to a group of lanes (used for flushing work).
+
+function laneToLanes(lane) {
+  return lane;
+}
+function higherPriorityLane(a, b) {
+  // This works because the bit ranges decrease in priority as you go left.
+  return a !== NoLane && a < b ? a : b;
+}
+function createLaneMap(initial) {
+  // Intentionally pushing one by one.
+  // https://v8.dev/blog/elements-kinds#avoid-creating-holes
+  const laneMap = [];
+
+  for (let i = 0; i < TotalLanes; i++) {
+    laneMap.push(initial);
+  }
+
+  return laneMap;
+}
+function markRootUpdated(root, updateLane) {
+  root.pendingLanes |= updateLane; // If there are any suspended transitions, it's possible this new update
+  // could unblock them. Clear the suspended lanes so that we can try rendering
+  // them again.
+  //
+  // TODO: We really only need to unsuspend only lanes that are in the
+  // `subtreeLanes` of the updated fiber, or the update lanes of the return
+  // path. This would exclude suspended updates in an unrelated sibling tree,
+  // since there's no way for this update to unblock it.
+  //
+  // We don't do this if the incoming update is idle, because we never process
+  // idle updates until after all the regular updates have finished; there's no
+  // way it could unblock a transition.
+
+  if (updateLane !== IdleLane) {
+    root.suspendedLanes = NoLanes;
+    root.pingedLanes = NoLanes;
+  }
+}
+function markRootSuspended$1(root, suspendedLanes, spawnedLane) {
+  root.suspendedLanes |= suspendedLanes;
+  root.pingedLanes &= ~suspendedLanes; // The suspended lanes are no longer CPU-bound. Clear their expiration times.
+
+  const expirationTimes = root.expirationTimes;
+  let lanes = suspendedLanes;
+
+  while (lanes > 0) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+    expirationTimes[index] = NoTimestamp;
+    lanes &= ~lane;
+  }
+
+  if (spawnedLane !== NoLane) {
+    markSpawnedDeferredLane(root, spawnedLane, suspendedLanes);
+  }
+}
+function markRootPinged(root, pingedLanes) {
+  root.pingedLanes |= root.suspendedLanes & pingedLanes;
+}
+function markRootFinished(root, remainingLanes, spawnedLane) {
+  const noLongerPendingLanes = root.pendingLanes & ~remainingLanes;
+  root.pendingLanes = remainingLanes; // Let's try everything again
+
+  root.suspendedLanes = NoLanes;
+  root.pingedLanes = NoLanes;
+  root.expiredLanes &= remainingLanes;
+  root.entangledLanes &= remainingLanes;
+  root.errorRecoveryDisabledLanes &= remainingLanes;
+  root.shellSuspendCounter = 0;
+  const entanglements = root.entanglements;
+  const expirationTimes = root.expirationTimes;
+  const hiddenUpdates = root.hiddenUpdates; // Clear the lanes that no longer have pending work
+
+  let lanes = noLongerPendingLanes;
+
+  while (lanes > 0) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+    entanglements[index] = NoLanes;
+    expirationTimes[index] = NoTimestamp;
+    const hiddenUpdatesForLane = hiddenUpdates[index];
+
+    if (hiddenUpdatesForLane !== null) {
+      hiddenUpdates[index] = null; // "Hidden" updates are updates that were made to a hidden component. They
+      // have special logic associated with them because they may be entangled
+      // with updates that occur outside that tree. But once the outer tree
+      // commits, they behave like regular updates.
+
+      for (let i = 0; i < hiddenUpdatesForLane.length; i++) {
+        const update = hiddenUpdatesForLane[i];
+
+        if (update !== null) {
+          update.lane &= ~OffscreenLane;
+        }
+      }
+    }
+
+    lanes &= ~lane;
+  }
+
+  if (spawnedLane !== NoLane) {
+    markSpawnedDeferredLane(root, spawnedLane, // This render finished successfully without suspending, so we don't need
+    // to entangle the spawned task with the parent task.
+    NoLanes);
+  }
+}
+
+function markSpawnedDeferredLane(root, spawnedLane, entangledLanes) {
+  // This render spawned a deferred task. Mark it as pending.
+  root.pendingLanes |= spawnedLane;
+  root.suspendedLanes &= ~spawnedLane; // Entangle the spawned lane with the DeferredLane bit so that we know it
+  // was the result of another render. This lets us avoid a useDeferredValue
+  // waterfall — only the first level will defer.
+
+  const spawnedLaneIndex = laneToIndex(spawnedLane);
+  root.entangledLanes |= spawnedLane;
+  root.entanglements[spawnedLaneIndex] |= DeferredLane | // If the parent render task suspended, we must also entangle those lanes
+  // with the spawned task, so that the deferred task includes all the same
+  // updates that the parent task did. We can exclude any lane that is not
+  // used for updates (e.g. Offscreen).
+  entangledLanes & UpdateLanes;
+}
+
+function markRootEntangled(root, entangledLanes) {
+  // In addition to entangling each of the given lanes with each other, we also
+  // have to consider _transitive_ entanglements. For each lane that is already
+  // entangled with *any* of the given lanes, that lane is now transitively
+  // entangled with *all* the given lanes.
+  //
+  // Translated: If C is entangled with A, then entangling A with B also
+  // entangles C with B.
+  //
+  // If this is hard to grasp, it might help to intentionally break this
+  // function and look at the tests that fail in ReactTransition-test.js. Try
+  // commenting out one of the conditions below.
+  const rootEntangledLanes = root.entangledLanes |= entangledLanes;
+  const entanglements = root.entanglements;
+  let lanes = rootEntangledLanes;
+
+  while (lanes) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+
+    if ( // Is this one of the newly entangled lanes?
+    lane & entangledLanes | // Is this lane transitively entangled with the newly entangled lanes?
+    entanglements[index] & entangledLanes) {
+      entanglements[index] |= entangledLanes;
+    }
+
+    lanes &= ~lane;
+  }
+}
+function upgradePendingLaneToSync(root, lane) {
+  // Since we're upgrading the priority of the given lane, there is now pending
+  // sync work.
+  root.pendingLanes |= SyncLane; // Entangle the sync lane with the lane we're upgrading. This means SyncLane
+  // will not be allowed to finish without also finishing the given lane.
+
+  root.entangledLanes |= SyncLane;
+  root.entanglements[SyncLaneIndex] |= lane;
+}
+function upgradePendingLanesToSync(root, lanesToUpgrade) {
+  // Same as upgradePendingLaneToSync but accepts multiple lanes, so it's a
+  // bit slower.
+  root.pendingLanes |= SyncLane;
+  root.entangledLanes |= SyncLane;
+  let lanes = lanesToUpgrade;
+
+  while (lanes) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+    root.entanglements[SyncLaneIndex] |= lane;
+    lanes &= ~lane;
+  }
+}
+function markHiddenUpdate(root, update, lane) {
+  const index = laneToIndex(lane);
+  const hiddenUpdates = root.hiddenUpdates;
+  const hiddenUpdatesForLane = hiddenUpdates[index];
+
+  if (hiddenUpdatesForLane === null) {
+    hiddenUpdates[index] = [update];
+  } else {
+    hiddenUpdatesForLane.push(update);
+  }
+
+  update.lane = lane | OffscreenLane;
+}
+function getBumpedLaneForHydration(root, renderLanes) {
+  const renderLane = getHighestPriorityLane(renderLanes);
+  let lane;
+
+  if ((renderLane & SyncUpdateLanes) !== NoLane) {
+    lane = SyncHydrationLane;
+  } else {
+    switch (renderLane) {
+      case SyncLane:
+        lane = SyncHydrationLane;
+        break;
+
+      case InputContinuousLane:
+        lane = InputContinuousHydrationLane;
+        break;
+
+      case DefaultLane:
+        lane = DefaultHydrationLane;
+        break;
+
+      case TransitionLane1:
+      case TransitionLane2:
+      case TransitionLane3:
+      case TransitionLane4:
+      case TransitionLane5:
+      case TransitionLane6:
+      case TransitionLane7:
+      case TransitionLane8:
+      case TransitionLane9:
+      case TransitionLane10:
+      case TransitionLane11:
+      case TransitionLane12:
+      case TransitionLane13:
+      case TransitionLane14:
+      case TransitionLane15:
+      case RetryLane1:
+      case RetryLane2:
+      case RetryLane3:
+      case RetryLane4:
+        lane = TransitionHydrationLane;
+        break;
+
+      case IdleLane:
+        lane = IdleHydrationLane;
+        break;
+
+      default:
+        // Everything else is already either a hydration lane, or shouldn't
+        // be retried at a hydration lane.
+        lane = NoLane;
+        break;
+    }
+  } // Check if the lane we chose is suspended. If so, that indicates that we
+  // already attempted and failed to hydrate at that level. Also check if we're
+  // already rendering that lane, which is rare but could happen.
+
+
+  if ((lane & (root.suspendedLanes | renderLanes)) !== NoLane) {
+    // Give up trying to hydrate and fall back to client render.
+    return NoLane;
+  }
+
+  return lane;
+}
+function getTransitionsForLanes(root, lanes) {
+  {
+    return null;
+  }
+}
+
+const DiscreteEventPriority = SyncLane;
+const ContinuousEventPriority = InputContinuousLane;
+const DefaultEventPriority = DefaultLane;
+const IdleEventPriority = IdleLane;
+let currentUpdatePriority = NoLane;
+function getCurrentUpdatePriority() {
+  return currentUpdatePriority;
+}
+function setCurrentUpdatePriority(newPriority) {
+  currentUpdatePriority = newPriority;
+}
+function runWithPriority(priority, fn) {
+  const previousPriority = currentUpdatePriority;
+
+  try {
+    currentUpdatePriority = priority;
+    return fn();
+  } finally {
+    currentUpdatePriority = previousPriority;
+  }
+}
+function higherEventPriority(a, b) {
+  return a !== 0 && a < b ? a : b;
+}
+function lowerEventPriority(a, b) {
+  return a === 0 || a > b ? a : b;
+}
+function isHigherEventPriority(a, b) {
+  return a !== 0 && a < b;
+}
+function lanesToEventPriority(lanes) {
+  const lane = getHighestPriorityLane(lanes);
+
+  if (!isHigherEventPriority(DiscreteEventPriority, lane)) {
+    return DiscreteEventPriority;
+  }
+
+  if (!isHigherEventPriority(ContinuousEventPriority, lane)) {
+    return ContinuousEventPriority;
+  }
+
+  if (includesNonIdleWork(lane)) {
+    return DefaultEventPriority;
+  }
+
+  return IdleEventPriority;
+}
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+const FunctionComponent = 0;
+const ClassComponent = 1;
+const IndeterminateComponent = 2; // Before we know whether it is function or class
+
+const HostRoot = 3; // Root of a host tree. Could be nested inside another node.
+
+const HostPortal = 4; // A subtree. Could be an entry point to a different renderer.
+
+const HostComponent = 5;
+const HostText = 6;
+const Fragment = 7;
+const Mode = 8;
+const ContextConsumer = 9;
+const ContextProvider = 10;
+const ForwardRef = 11;
+const Profiler = 12;
+const SuspenseComponent = 13;
+const MemoComponent = 14;
+const SimpleMemoComponent = 15;
+const LazyComponent = 16;
+const IncompleteClassComponent = 17;
+const DehydratedFragment = 18;
+const SuspenseListComponent = 19;
+const ScopeComponent = 21;
+const OffscreenComponent = 22;
+const LegacyHiddenComponent = 23;
+const CacheComponent = 24;
+const TracingMarkerComponent = 25;
+const HostHoistable = 26;
+const HostSingleton = 27;
+
+const randomKey = Math.random().toString(36).slice(2);
+const internalInstanceKey = '__reactFiber$' + randomKey;
+const internalPropsKey = '__reactProps$' + randomKey;
+const internalContainerInstanceKey = '__reactContainer$' + randomKey;
+const internalEventHandlersKey = '__reactEvents$' + randomKey;
+const internalEventHandlerListenersKey = '__reactListeners$' + randomKey;
+const internalEventHandlesSetKey = '__reactHandles$' + randomKey;
+const internalRootNodeResourcesKey = '__reactResources$' + randomKey;
+const internalHoistableMarker = '__reactMarker$' + randomKey;
+function detachDeletedInstance(node) {
+  // TODO: This function is only called on host components. I don't think all of
+  // these fields are relevant.
+  delete node[internalInstanceKey];
+  delete node[internalPropsKey];
+  delete node[internalEventHandlersKey];
+  delete node[internalEventHandlerListenersKey];
+  delete node[internalEventHandlesSetKey];
+}
+function precacheFiberNode(hostInst, node) {
+  node[internalInstanceKey] = hostInst;
+}
+function markContainerAsRoot(hostRoot, node) {
+  // $FlowFixMe[prop-missing]
+  node[internalContainerInstanceKey] = hostRoot;
+}
+function unmarkContainerAsRoot(node) {
+  // $FlowFixMe[prop-missing]
+  node[internalContainerInstanceKey] = null;
+}
+function isContainerMarkedAsRoot(node) {
+  // $FlowFixMe[prop-missing]
+  return !!node[internalContainerInstanceKey];
+} // Given a DOM node, return the closest HostComponent or HostText fiber ancestor.
+// If the target node is part of a hydrated or not yet rendered subtree, then
+// this may also return a SuspenseComponent or HostRoot to indicate that.
+// Conceptually the HostRoot fiber is a child of the Container node. So if you
+// pass the Container node as the targetNode, you will not actually get the
+// HostRoot back. To get to the HostRoot, you need to pass a child of it.
+// The same thing applies to Suspense boundaries.
+
+function getClosestInstanceFromNode(targetNode) {
+  let targetInst = targetNode[internalInstanceKey];
+
+  if (targetInst) {
+    // Don't return HostRoot or SuspenseComponent here.
+    return targetInst;
+  } // If the direct event target isn't a React owned DOM node, we need to look
+  // to see if one of its parents is a React owned DOM node.
+
+
+  let parentNode = targetNode.parentNode;
+
+  while (parentNode) {
+    // We'll check if this is a container root that could include
+    // React nodes in the future. We need to check this first because
+    // if we're a child of a dehydrated container, we need to first
+    // find that inner container before moving on to finding the parent
+    // instance. Note that we don't check this field on  the targetNode
+    // itself because the fibers are conceptually between the container
+    // node and the first child. It isn't surrounding the container node.
+    // If it's not a container, we check if it's an instance.
+    targetInst = parentNode[internalContainerInstanceKey] || parentNode[internalInstanceKey];
+
+    if (targetInst) {
+      // Since this wasn't the direct target of the event, we might have
+      // stepped past dehydrated DOM nodes to get here. However they could
+      // also have been non-React nodes. We need to answer which one.
+      // If we the instance doesn't have any children, then there can't be
+      // a nested suspense boundary within it. So we can use this as a fast
+      // bailout. Most of the time, when people add non-React children to
+      // the tree, it is using a ref to a child-less DOM node.
+      // Normally we'd only need to check one of the fibers because if it
+      // has ever gone from having children to deleting them or vice versa
+      // it would have deleted the dehydrated boundary nested inside already.
+      // However, since the HostRoot starts out with an alternate it might
+      // have one on the alternate so we need to check in case this was a
+      // root.
+      const alternate = targetInst.alternate;
+
+      if (targetInst.child !== null || alternate !== null && alternate.child !== null) {
+        // Next we need to figure out if the node that skipped past is
+        // nested within a dehydrated boundary and if so, which one.
+        let suspenseInstance = getParentSuspenseInstance(targetNode);
+
+        while (suspenseInstance !== null) {
+          // We found a suspense instance. That means that we haven't
+          // hydrated it yet. Even though we leave the comments in the
+          // DOM after hydrating, and there are boundaries in the DOM
+          // that could already be hydrated, we wouldn't have found them
+          // through this pass since if the target is hydrated it would
+          // have had an internalInstanceKey on it.
+          // Let's get the fiber associated with the SuspenseComponent
+          // as the deepest instance.
+          // $FlowFixMe[prop-missing]
+          const targetSuspenseInst = suspenseInstance[internalInstanceKey];
+
+          if (targetSuspenseInst) {
+            return targetSuspenseInst;
+          } // If we don't find a Fiber on the comment, it might be because
+          // we haven't gotten to hydrate it yet. There might still be a
+          // parent boundary that hasn't above this one so we need to find
+          // the outer most that is known.
+
+
+          suspenseInstance = getParentSuspenseInstance(suspenseInstance); // If we don't find one, then that should mean that the parent
+          // host component also hasn't hydrated yet. We can return it
+          // below since it will bail out on the isMounted check later.
+        }
+      }
+
+      return targetInst;
+    }
+
+    targetNode = parentNode;
+    parentNode = targetNode.parentNode;
+  }
+
+  return null;
+}
+/**
+ * Given a DOM node, return the ReactDOMComponent or ReactDOMTextComponent
+ * instance, or null if the node was not rendered by this React.
+ */
+
+function getInstanceFromNode(node) {
+  const inst = node[internalInstanceKey] || node[internalContainerInstanceKey];
+
+  if (inst) {
+    const tag = inst.tag;
+
+    if (tag === HostComponent || tag === HostText || tag === SuspenseComponent || (tag === HostHoistable ) || (tag === HostSingleton ) || tag === HostRoot) {
+      return inst;
+    } else {
+      return null;
+    }
+  }
+
+  return null;
+}
+/**
+ * Given a ReactDOMComponent or ReactDOMTextComponent, return the corresponding
+ * DOM node.
+ */
+
+function getNodeFromInstance(inst) {
+  const tag = inst.tag;
+
+  if (tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton ) || tag === HostText) {
+    // In Fiber this, is just the state node right now. We assume it will be
+    // a host component or host text.
+    return inst.stateNode;
+  } // Without this first invariant, passing a non-DOM-component triggers the next
+  // invariant for a missing parent, which is super confusing.
+
+
+  throw Error(formatProdErrorMessage(33));
+}
+function getFiberCurrentPropsFromNode(node) {
+  return node[internalPropsKey] || null;
+}
+function updateFiberProps(node, props) {
+  node[internalPropsKey] = props;
+}
+function getEventListenerSet(node) {
+  let elementListenerSet = node[internalEventHandlersKey];
+
+  if (elementListenerSet === undefined) {
+    elementListenerSet = node[internalEventHandlersKey] = new Set();
+  }
+
+  return elementListenerSet;
+}
+function getResourcesFromRoot(root) {
+  let resources = root[internalRootNodeResourcesKey];
+
+  if (!resources) {
+    resources = root[internalRootNodeResourcesKey] = {
+      hoistableStyles: new Map(),
+      hoistableScripts: new Map()
+    };
+  }
+
+  return resources;
+}
+function isMarkedHoistable(node) {
+  return !!node[internalHoistableMarker];
+}
+function markNodeAsHoistable(node) {
+  node[internalHoistableMarker] = true;
+}
+function isOwnedInstance(node) {
+  return !!(node[internalHoistableMarker] || node[internalInstanceKey]);
+}
+
+const allNativeEvents = new Set();
+/**
+ * Mapping from registration name to event name
+ */
+
+
+const registrationNameDependencies = {};
+
+function registerTwoPhaseEvent(registrationName, dependencies) {
+  registerDirectEvent(registrationName, dependencies);
+  registerDirectEvent(registrationName + 'Capture', dependencies);
+}
+function registerDirectEvent(registrationName, dependencies) {
+
+  registrationNameDependencies[registrationName] = dependencies;
+
+  for (let i = 0; i < dependencies.length; i++) {
+    allNativeEvents.add(dependencies[i]);
+  }
+}
+
+const canUseDOM = !!(typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined');
+
+/* eslint-disable max-len */
+
+const ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
+/* eslint-enable max-len */
+
+const ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
+const VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+const illegalAttributeNameCache = {};
+const validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+  if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+    return true;
+  }
+
+  if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+    return false;
+  }
+
+  if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+    validatedAttributeNameCache[attributeName] = true;
+    return true;
+  }
+
+  illegalAttributeNameCache[attributeName] = true;
+
+  return false;
+}
+
+function setValueForAttribute(node, name, value) {
+  if (isAttributeNameSafe(name)) {
+    // If the prop isn't in the special list, treat it as a simple attribute.
+    // shouldRemoveAttribute
+    if (value === null) {
+      node.removeAttribute(name);
+      return;
+    }
+
+    switch (typeof value) {
+      case 'undefined':
+      case 'function':
+      case 'symbol':
+        // eslint-disable-line
+        node.removeAttribute(name);
+        return;
+
+      case 'boolean':
+        {
+          const prefix = name.toLowerCase().slice(0, 5);
+
+          if (prefix !== 'data-' && prefix !== 'aria-') {
+            node.removeAttribute(name);
+            return;
+          }
+        }
+    }
+
+    node.setAttribute(name, '' + value);
+  }
+}
+function setValueForKnownAttribute(node, name, value) {
+  if (value === null) {
+    node.removeAttribute(name);
+    return;
+  }
+
+  switch (typeof value) {
+    case 'undefined':
+    case 'function':
+    case 'symbol':
+    case 'boolean':
+      {
+        node.removeAttribute(name);
+        return;
+      }
+  }
+
+  node.setAttribute(name, '' + value);
+}
+function setValueForNamespacedAttribute(node, namespace, name, value) {
+  if (value === null) {
+    node.removeAttribute(name);
+    return;
+  }
+
+  switch (typeof value) {
+    case 'undefined':
+    case 'function':
+    case 'symbol':
+    case 'boolean':
+      {
+        node.removeAttribute(name);
+        return;
+      }
+  }
+
+  node.setAttributeNS(namespace, name, '' + value);
+}
+
+let prefix;
+function describeBuiltInComponentFrame(name, source, ownerFn) {
+  {
+    if (prefix === undefined) {
+      // Extract the VM specific prefix used by each line.
+      try {
+        throw Error();
+      } catch (x) {
+        const match = x.stack.trim().match(/\n( *(at )?)/);
+        prefix = match && match[1] || '';
+      }
+    } // We use the prefix to ensure our stacks line up with native stack frames.
+
+
+    return '\n' + prefix + name;
+  }
+}
+let reentry = false;
+let componentFrameCache;
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
+
+function describeNativeComponentFrame(fn, construct) {
+  // If something asked for a stack inside a fake render, it should get ignored.
+  if (!fn || reentry) {
+    return '';
+  }
+
+  reentry = true;
+  const previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
+
+  Error.prepareStackTrace = undefined;
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
+
+
+  const RunInRootFrame = {
+    DetermineComponentFrameRoot() {
+      let control;
+
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          const Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
+
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
+
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
+
+
+          const maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
+
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(() => {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
+      }
+
+      return [null, null];
+    }
+
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  const namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
+
+  try {
+    const _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+          sampleStack = _RunInRootFrame$Deter[0],
+          controlStack = _RunInRootFrame$Deter[1];
+
+    if (sampleStack && controlStack) {
+      // This extracts the first frame from the sample that isn't also in the control.
+      // Skipping one frame that we assume is the frame that calls the two.
+      const sampleLines = sampleStack.split('\n');
+      const controlLines = controlStack.split('\n');
+      let s = 0;
+      let c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
+      }
+
+      for (; s >= 1 && c >= 0; s--, c--) {
+        // Next we find the first one that isn't the same which should be the
+        // frame that called our sample function and the control.
+        if (sampleLines[s] !== controlLines[c]) {
+          // In V8, the first line is describing the message but other VMs don't.
+          // If we're about to return the first line, and the control is also on the same
+          // line, that's a pretty good indicator that our sample threw at same line as
+          // the control. I.e. before we entered the sample frame. So we ignore this result.
+          // This can happen if you passed a class to function component, or non-function.
+          if (s !== 1 || c !== 1) {
+            do {
+              s--;
+              c--; // We may still have similar intermediate frames from the construct call.
+              // The next one that isn't the same should be our match though.
+
+              if (c < 0 || sampleLines[s] !== controlLines[c]) {
+                // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
+                let frame = '\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled "<anonymous>"
+                // but we have a user-provided "displayName"
+                // splice it in to make the stack more readable.
+
+                if (fn.displayName && frame.includes('<anonymous>')) {
+                  frame = frame.replace('<anonymous>', fn.displayName);
+                }
+
+                if (false) ; // Return the line we found.
+
+
+                return frame;
+              }
+            } while (s >= 1 && c >= 0);
+          }
+
+          break;
+        }
+      }
+    }
+  } finally {
+    reentry = false;
+
+    Error.prepareStackTrace = previousPrepareStackTrace;
+  } // Fallback to just using the name if we couldn't make it throw.
+
+
+  const name = fn ? fn.displayName || fn.name : '';
+  const syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';
+
+  return syntheticFrame;
+}
+
+function describeClassComponentFrame(ctor, source, ownerFn) {
+  {
+    return describeNativeComponentFrame(ctor, true);
+  }
+}
+function describeFunctionComponentFrame(fn, source, ownerFn) {
+  {
+    return describeNativeComponentFrame(fn, false);
+  }
+}
+
+function describeFiber(fiber) {
+
+  switch (fiber.tag) {
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      return describeBuiltInComponentFrame(fiber.type);
+
+    case LazyComponent:
+      return describeBuiltInComponentFrame('Lazy');
+
+    case SuspenseComponent:
+      return describeBuiltInComponentFrame('Suspense');
+
+    case SuspenseListComponent:
+      return describeBuiltInComponentFrame('SuspenseList');
+
+    case FunctionComponent:
+    case IndeterminateComponent:
+    case SimpleMemoComponent:
+      return describeFunctionComponentFrame(fiber.type);
+
+    case ForwardRef:
+      return describeFunctionComponentFrame(fiber.type.render);
+
+    case ClassComponent:
+      return describeClassComponentFrame(fiber.type);
+
+    default:
+      return '';
+  }
+}
+
+function getStackByFiberInDevAndProd(workInProgress) {
+  try {
+    let info = '';
+    let node = workInProgress;
+
+    do {
+      info += describeFiber(node); // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+      node = node.return;
+    } while (node);
+
+    return info;
+  } catch (x) {
+    return '\nError generating stack: ' + x.message + '\n' + x.stack;
+  }
+}
+
+function getWrappedName$1(outerType, innerType, wrapperName) {
+  const displayName = outerType.displayName;
+
+  if (displayName) {
+    return displayName;
+  }
+
+  const functionName = innerType.displayName || innerType.name || '';
+  return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
+} // Keep in sync with react-reconciler/getComponentNameFromFiber
+
+
+function getContextName$1(type) {
+  return type.displayName || 'Context';
+} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+
+function getComponentNameFromType(type) {
+  if (type == null) {
+    // Host root, text node or just invalid type.
+    return null;
+  }
+
+  if (typeof type === 'function') {
+    return type.displayName || type.name || null;
+  }
+
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_FRAGMENT_TYPE:
+      return 'Fragment';
+
+    case REACT_PORTAL_TYPE:
+      return 'Portal';
+
+    case REACT_PROFILER_TYPE:
+      return 'Profiler';
+
+    case REACT_STRICT_MODE_TYPE:
+      return 'StrictMode';
+
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+
+    case REACT_CACHE_TYPE:
+      {
+        return 'Cache';
+      }
+
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        const context = type;
+        return getContextName$1(context) + '.Consumer';
+
+      case REACT_PROVIDER_TYPE:
+        const provider = type;
+        return getContextName$1(provider._context) + '.Provider';
+
+      case REACT_FORWARD_REF_TYPE:
+        return getWrappedName$1(type, type.render, 'ForwardRef');
+
+      case REACT_MEMO_TYPE:
+        const outerName = type.displayName || null;
+
+        if (outerName !== null) {
+          return outerName;
+        }
+
+        return getComponentNameFromType(type.type) || 'Memo';
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            return getComponentNameFromType(init(payload));
+          } catch (x) {
+            return null;
+          }
+        }
+
+    }
+  }
+
+  return null;
+}
+
+function getWrappedName(outerType, innerType, wrapperName) {
+  const functionName = innerType.displayName || innerType.name || '';
+  return outerType.displayName || (functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName);
+} // Keep in sync with shared/getComponentNameFromType
+
+
+function getContextName(type) {
+  return type.displayName || 'Context';
+}
+
+function getComponentNameFromFiber(fiber) {
+  const tag = fiber.tag,
+        type = fiber.type;
+
+  switch (tag) {
+    case CacheComponent:
+      return 'Cache';
+
+    case ContextConsumer:
+      const context = type;
+      return getContextName(context) + '.Consumer';
+
+    case ContextProvider:
+      const provider = type;
+      return getContextName(provider._context) + '.Provider';
+
+    case DehydratedFragment:
+      return 'DehydratedFragment';
+
+    case ForwardRef:
+      return getWrappedName(type, type.render, 'ForwardRef');
+
+    case Fragment:
+      return 'Fragment';
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      // Host component type is the display name (e.g. "div", "View")
+      return type;
+
+    case HostPortal:
+      return 'Portal';
+
+    case HostRoot:
+      return 'Root';
+
+    case HostText:
+      return 'Text';
+
+    case LazyComponent:
+      // Name comes from the type in this case; we don't have a tag.
+      return getComponentNameFromType(type);
+
+    case Mode:
+      if (type === REACT_STRICT_MODE_TYPE) {
+        // Don't be less specific than shared/getComponentNameFromType
+        return 'StrictMode';
+      }
+
+      return 'Mode';
+
+    case OffscreenComponent:
+      return 'Offscreen';
+
+    case Profiler:
+      return 'Profiler';
+
+    case ScopeComponent:
+      return 'Scope';
+
+    case SuspenseComponent:
+      return 'Suspense';
+
+    case SuspenseListComponent:
+      return 'SuspenseList';
+
+    case TracingMarkerComponent:
+      return 'TracingMarker';
+    // The display name for this tags come from the user-provided type:
+
+    case ClassComponent:
+    case FunctionComponent:
+    case IncompleteClassComponent:
+    case IndeterminateComponent:
+    case MemoComponent:
+    case SimpleMemoComponent:
+      if (typeof type === 'function') {
+        return type.displayName || type.name || null;
+      }
+
+      if (typeof type === 'string') {
+        return type;
+      }
+
+      break;
+
+  }
+
+  return null;
+}
+
+// around this limitation, we use an opaque type that can only be obtained by
+// passing the value through getToStringValue first.
+
+function toString(value) {
+  // The coercion safety check is performed in getToStringValue().
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  return '' + value;
+}
+function getToStringValue(value) {
+  switch (typeof value) {
+    case 'boolean':
+    case 'number':
+    case 'string':
+    case 'undefined':
+      return value;
+
+    case 'object':
+
+      return value;
+
+    default:
+      // function, symbol are assigned as empty strings
+      return '';
+  }
+}
+
+function isCheckable(elem) {
+  const type = elem.type;
+  const nodeName = elem.nodeName;
+  return nodeName && nodeName.toLowerCase() === 'input' && (type === 'checkbox' || type === 'radio');
+}
+
+function getTracker(node) {
+  return node._valueTracker;
+}
+
+function detachTracker(node) {
+  node._valueTracker = null;
+}
+
+function getValueFromNode(node) {
+  let value = '';
+
+  if (!node) {
+    return value;
+  }
+
+  if (isCheckable(node)) {
+    value = node.checked ? 'true' : 'false';
+  } else {
+    value = node.value;
+  }
+
+  return value;
+}
+
+function trackValueOnNode(node) {
+  const valueField = isCheckable(node) ? 'checked' : 'value';
+  const descriptor = Object.getOwnPropertyDescriptor(node.constructor.prototype, valueField);
+
+  let currentValue = '' + node[valueField]; // if someone has already defined a value or Safari, then bail
+  // and don't track value will cause over reporting of changes,
+  // but it's better then a hard failure
+  // (needed for certain tests that spyOn input values and Safari)
+
+  if (node.hasOwnProperty(valueField) || typeof descriptor === 'undefined' || typeof descriptor.get !== 'function' || typeof descriptor.set !== 'function') {
+    return;
+  }
+
+  const get = descriptor.get,
+        set = descriptor.set;
+  Object.defineProperty(node, valueField, {
+    configurable: true,
+    // $FlowFixMe[missing-this-annot]
+    get: function () {
+      return get.call(this);
+    },
+    // $FlowFixMe[missing-local-annot]
+    // $FlowFixMe[missing-this-annot]
+    set: function (value) {
+
+      currentValue = '' + value;
+      set.call(this, value);
+    }
+  }); // We could've passed this the first time
+  // but it triggers a bug in IE11 and Edge 14/15.
+  // Calling defineProperty() again should be equivalent.
+  // https://github.com/facebook/react/issues/11768
+
+  Object.defineProperty(node, valueField, {
+    enumerable: descriptor.enumerable
+  });
+  const tracker = {
+    getValue() {
+      return currentValue;
+    },
+
+    setValue(value) {
+
+      currentValue = '' + value;
+    },
+
+    stopTracking() {
+      detachTracker(node);
+      delete node[valueField];
+    }
+
+  };
+  return tracker;
+}
+
+function track(node) {
+  if (getTracker(node)) {
+    return;
+  }
+
+  node._valueTracker = trackValueOnNode(node);
+}
+function updateValueIfChanged(node) {
+  if (!node) {
+    return false;
+  }
+
+  const tracker = getTracker(node); // if there is no tracker at this point it's unlikely
+  // that trying again will succeed
+
+  if (!tracker) {
+    return true;
+  }
+
+  const lastValue = tracker.getValue();
+  const nextValue = getValueFromNode(node);
+
+  if (nextValue !== lastValue) {
+    tracker.setValue(nextValue);
+    return true;
+  }
+
+  return false;
+}
+
+function getActiveElement(doc) {
+  doc = doc || (typeof document !== 'undefined' ? document : undefined);
+
+  if (typeof doc === 'undefined') {
+    return null;
+  }
+
+  try {
+    return doc.activeElement || doc.body;
+  } catch (e) {
+    return doc.body;
+  }
+}
+
+// When passing user input into querySelector(All) the embedded string must not alter
+// the semantics of the query. This escape function is safe to use when we know the
+// provided value is going to be wrapped in double quotes as part of an attribute selector
+// Do not use it anywhere else
+// we escape double quotes and backslashes
+const escapeSelectorAttributeValueInsideDoubleQuotesRegex = /[\n\"\\]/g;
+function escapeSelectorAttributeValueInsideDoubleQuotes(value) {
+  return value.replace(escapeSelectorAttributeValueInsideDoubleQuotesRegex, ch => '\\' + ch.charCodeAt(0).toString(16) + ' ');
+}
+
+function updateInput(element, value, defaultValue, lastDefaultValue, checked, defaultChecked, type, name) {
+  const node = element; // Temporarily disconnect the input from any radio buttons.
+  // Changing the type or name as the same time as changing the checked value
+  // needs to be atomically applied. We can only ensure that by disconnecting
+  // the name while do the mutations and then reapply the name after that's done.
+
+  node.name = '';
+
+  if (type != null && typeof type !== 'function' && typeof type !== 'symbol' && typeof type !== 'boolean') {
+
+    node.type = type;
+  } else {
+    node.removeAttribute('type');
+  }
+
+  if (value != null) {
+    if (type === 'number') {
+      if ( // $FlowFixMe[incompatible-type]
+      value === 0 && node.value === '' || // We explicitly want to coerce to number here if possible.
+      // eslint-disable-next-line
+      node.value != value) {
+        node.value = toString(getToStringValue(value));
+      }
+    } else if (node.value !== toString(getToStringValue(value))) {
+      node.value = toString(getToStringValue(value));
+    }
+  } else if (type === 'submit' || type === 'reset') {
+    // Submit/reset inputs need the attribute removed completely to avoid
+    // blank-text buttons.
+    node.removeAttribute('value');
+  }
+
+  {
+    // When syncing the value attribute, the value comes from a cascade of
+    // properties:
+    //  1. The value React property
+    //  2. The defaultValue React property
+    //  3. Otherwise there should be no change
+    if (value != null) {
+      setDefaultValue(node, type, getToStringValue(value));
+    } else if (defaultValue != null) {
+      setDefaultValue(node, type, getToStringValue(defaultValue));
+    } else if (lastDefaultValue != null) {
+      node.removeAttribute('value');
+    }
+  }
+
+  {
+    // 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 (checked == null && defaultChecked != null) {
+      node.defaultChecked = !!defaultChecked;
+    }
+  }
+
+  if (checked != null) {
+    // Important to set this even if it's not a change in order to update input
+    // value tracking with radio buttons
+    // TODO: Should really update input value tracking for the whole radio
+    // button group in an effect or something (similar to #27024)
+    node.checked = checked && typeof checked !== 'function' && typeof checked !== 'symbol';
+  }
+
+  if (name != null && typeof name !== 'function' && typeof name !== 'symbol' && typeof name !== 'boolean') {
+
+    node.name = toString(getToStringValue(name));
+  } else {
+    node.removeAttribute('name');
+  }
+}
+function initInput(element, value, defaultValue, checked, defaultChecked, type, name, isHydrating) {
+  const node = element;
+
+  if (type != null && typeof type !== 'function' && typeof type !== 'symbol' && typeof type !== 'boolean') {
+
+    node.type = type;
+  }
+
+  if (value != null || defaultValue != null) {
+    const isButton = type === 'submit' || type === 'reset'; // Avoid setting value attribute on submit/reset inputs as it overrides the
+    // default value provided by the browser. See: #12872
+
+    if (isButton && (value === undefined || value === null)) {
+      return;
+    }
+
+    const defaultValueStr = defaultValue != null ? toString(getToStringValue(defaultValue)) : '';
+    const initialValue = value != null ? toString(getToStringValue(value)) : defaultValueStr; // Do not assign value if it is already set. This prevents user text input
+    // from being lost during SSR hydration.
+
+    if (!isHydrating) {
+      {
+        // When syncing the value attribute, the value property should use
+        // the wrapperState._initialValue property. This uses:
+        //
+        //   1. The value React property when present
+        //   2. The defaultValue React property when present
+        //   3. An empty string
+        if (initialValue !== node.value) {
+          node.value = initialValue;
+        }
+      }
+    }
+
+    {
+      // Otherwise, the value attribute is synchronized to the property,
+      // so we assign defaultValue to the same thing as the value property
+      // assignment step above.
+      node.defaultValue = initialValue;
+    }
+  } // Normally, we'd just do `node.checked = node.checked` upon initial mount, less this bug
+  // this is needed to work around a chrome bug where setting defaultChecked
+  // will sometimes influence the value of checked (even after detachment).
+  // Reference: https://bugs.chromium.org/p/chromium/issues/detail?id=608416
+  // We need to temporarily unset name to avoid disrupting radio button groups.
+
+
+  const checkedOrDefault = checked != null ? checked : defaultChecked; // TODO: This 'function' or 'symbol' check isn't replicated in other places
+  // so this semantic is inconsistent.
+
+  const initialChecked = typeof checkedOrDefault !== 'function' && typeof checkedOrDefault !== 'symbol' && !!checkedOrDefault;
+
+  if (isHydrating) {
+    // Detach .checked from .defaultChecked but leave user input alone
+    node.checked = node.checked;
+  } else {
+    node.checked = !!initialChecked;
+  }
+
+  {
+    // When syncing the checked attribute, both the checked property and
+    // attribute are assigned at the same time using defaultChecked. This uses:
+    //
+    //   1. The checked React property when present
+    //   2. The defaultChecked React property when present
+    //   3. Otherwise, false
+    node.defaultChecked = !node.defaultChecked;
+    node.defaultChecked = !!initialChecked;
+  } // Name needs to be set at the end so that it applies atomically to connected radio buttons.
+
+
+  if (name != null && typeof name !== 'function' && typeof name !== 'symbol' && typeof name !== 'boolean') {
+
+    node.name = name;
+  }
+}
+function restoreControlledInputState(element, props) {
+  const rootNode = element;
+  updateInput(rootNode, props.value, props.defaultValue, props.defaultValue, props.checked, props.defaultChecked, props.type, props.name);
+  const name = props.name;
+
+  if (props.type === 'radio' && name != null) {
+    let queryRoot = rootNode;
+
+    while (queryRoot.parentNode) {
+      queryRoot = queryRoot.parentNode;
+    } // If `rootNode.form` was non-null, then we could try `form.elements`,
+
+    const group = queryRoot.querySelectorAll('input[name="' + escapeSelectorAttributeValueInsideDoubleQuotes('' + name) + '"][type="radio"]');
+
+    for (let i = 0; i < group.length; i++) {
+      const otherNode = group[i];
+
+      if (otherNode === rootNode || otherNode.form !== rootNode.form) {
+        continue;
+      } // This will throw if radio buttons rendered by different copies of React
+      // and the same name are rendered into the same form (same as #1939).
+      // That's probably okay; we don't support it just as we don't support
+      // mixing React radio buttons with non-React ones.
+
+
+      const otherProps = getFiberCurrentPropsFromNode(otherNode);
+
+      if (!otherProps) {
+        throw Error(formatProdErrorMessage(90));
+      } // If this is a controlled radio button group, forcing the input that
+      // was previously checked to update will cause it to be come re-checked
+      // as appropriate.
+
+
+      updateInput(otherNode, otherProps.value, otherProps.defaultValue, otherProps.defaultValue, otherProps.checked, otherProps.defaultChecked, otherProps.type, otherProps.name);
+    } // If any updateInput() call set .checked to true, an input in this group
+    // (often, `rootNode` itself) may have become unchecked
+
+
+    for (let i = 0; i < group.length; i++) {
+      const otherNode = group[i];
+
+      if (otherNode.form !== rootNode.form) {
+        continue;
+      }
+
+      updateValueIfChanged(otherNode);
+    }
+  }
+} // In Chrome, assigning defaultValue to certain input types triggers input validation.
+// For number inputs, the display value loses trailing decimal points. For email inputs,
+// Chrome raises "The specified value <x> is not a valid email address".
+//
+// Here we check to see if the defaultValue has actually changed, avoiding these problems
+// when the user is inputting text
+//
+// https://github.com/facebook/react/issues/7253
+
+function setDefaultValue(node, type, value) {
+  if ( // Focused number inputs synchronize on blur. See ChangeEventPlugin.js
+  type !== 'number' || getActiveElement(node.ownerDocument) !== node) {
+    if (node.defaultValue !== toString(value)) {
+      node.defaultValue = toString(value);
+    }
+  }
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+// TODO: direct imports like some-package/src/* are bad. Fix me.
+
+function updateOptions(node, multiple, propValue, setDefaultSelected) {
+  const options = node.options;
+
+  if (multiple) {
+    const selectedValues = propValue;
+    const selectedValue = {};
+
+    for (let i = 0; i < selectedValues.length; i++) {
+      // Prefix to avoid chaos with special keys.
+      selectedValue['$' + selectedValues[i]] = true;
+    }
+
+    for (let i = 0; i < options.length; i++) {
+      const selected = selectedValue.hasOwnProperty('$' + options[i].value);
+
+      if (options[i].selected !== selected) {
+        options[i].selected = selected;
+      }
+
+      if (selected && setDefaultSelected) {
+        options[i].defaultSelected = true;
+      }
+    }
+  } else {
+    // Do not set `select.value` as exact behavior isn't consistent across all
+    // browsers for all cases.
+    const selectedValue = toString(getToStringValue(propValue));
+    let defaultSelected = null;
+
+    for (let i = 0; i < options.length; i++) {
+      if (options[i].value === selectedValue) {
+        options[i].selected = true;
+
+        if (setDefaultSelected) {
+          options[i].defaultSelected = true;
+        }
+
+        return;
+      }
+
+      if (defaultSelected === null && !options[i].disabled) {
+        defaultSelected = options[i];
+      }
+    }
+
+    if (defaultSelected !== null) {
+      defaultSelected.selected = true;
+    }
+  }
+}
+function initSelect(element, value, defaultValue, multiple) {
+  const node = element;
+  node.multiple = !!multiple;
+
+  if (value != null) {
+    updateOptions(node, !!multiple, value, false);
+  } else if (defaultValue != null) {
+    updateOptions(node, !!multiple, defaultValue, true);
+  }
+}
+function updateSelect(element, value, defaultValue, multiple, wasMultiple) {
+  const node = element;
+
+  if (value != null) {
+    updateOptions(node, !!multiple, value, false);
+  } else if (!!wasMultiple !== !!multiple) {
+    // For simplicity, reapply `defaultValue` if `multiple` is toggled.
+    if (defaultValue != null) {
+      updateOptions(node, !!multiple, defaultValue, true);
+    } else {
+      // Revert the select back to its default unselected state.
+      updateOptions(node, !!multiple, multiple ? [] : '', false);
+    }
+  }
+}
+function restoreControlledSelectState(element, props) {
+  const node = element;
+  const value = props.value;
+
+  if (value != null) {
+    updateOptions(node, !!props.multiple, value, false);
+  }
+}
+
+function updateTextarea(element, value, defaultValue) {
+  const node = element;
+
+  if (value != null) {
+    // Cast `value` to a string to ensure the value is set correctly. While
+    // browsers typically do this as necessary, jsdom doesn't.
+    const newValue = toString(getToStringValue(value)); // To avoid side effects (such as losing text selection), only set value if changed
+
+    if (newValue !== node.value) {
+      node.value = newValue;
+    } // TOOO: This should respect disableInputAttributeSyncing flag.
+
+
+    if (defaultValue == null) {
+      if (node.defaultValue !== newValue) {
+        node.defaultValue = newValue;
+      }
+
+      return;
+    }
+  }
+
+  if (defaultValue != null) {
+    node.defaultValue = toString(getToStringValue(defaultValue));
+  } else {
+    node.defaultValue = '';
+  }
+}
+function initTextarea(element, value, defaultValue, children) {
+  const node = element;
+  let initialValue = value; // Only bother fetching default value if we're going to use it
+
+  if (initialValue == null) {
+    if (children != null) {
+      {
+        if (defaultValue != null) {
+          throw Error(formatProdErrorMessage(92));
+        }
+
+        if (isArray(children)) {
+          if (children.length > 1) {
+            throw Error(formatProdErrorMessage(93));
+          }
+
+          children = children[0];
+        }
+
+        defaultValue = children;
+      }
+    }
+
+    if (defaultValue == null) {
+      defaultValue = '';
+    }
+
+    initialValue = defaultValue;
+  }
+
+  const stringValue = getToStringValue(initialValue);
+  node.defaultValue = stringValue; // This will be toString:ed.
+  // This is in postMount because we need access to the DOM node, which is not
+  // available until after the component has mounted.
+
+  const textContent = node.textContent; // Only set node.value if textContent is equal to the expected
+  // initial value. In IE10/IE11 there is a bug where the placeholder attribute
+  // will populate textContent as well.
+  // https://developer.microsoft.com/microsoft-edge/platform/issues/101525/
+
+  if (textContent === stringValue) {
+    if (textContent !== '' && textContent !== null) {
+      node.value = textContent;
+    }
+  }
+}
+function restoreControlledTextareaState(element, props) {
+  // DOM component is still mounted; update
+  updateTextarea(element, props.value, props.defaultValue);
+}
+
+const MATH_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
+const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
+
+/* globals MSApp */
+
+let reusableSVGContainer;
+
+function setInnerHTMLImpl(node, html) {
+  if (node.namespaceURI === SVG_NAMESPACE) {
+
+    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
+      // the target node
+      reusableSVGContainer = reusableSVGContainer || document.createElement('div');
+      reusableSVGContainer.innerHTML = '<svg>' + html.valueOf().toString() + '</svg>';
+      const svgNode = reusableSVGContainer.firstChild;
+
+      while (node.firstChild) {
+        node.removeChild(node.firstChild);
+      } // $FlowFixMe[incompatible-use]
+      // $FlowFixMe[incompatible-type]
+
+
+      while (svgNode.firstChild) {
+        node.appendChild(svgNode.firstChild);
+      }
+
+      return;
+    }
+  }
+
+  node.innerHTML = html;
+}
+
+let setInnerHTML = setInnerHTMLImpl; // $FlowFixMe[cannot-resolve-name]
+
+if (typeof MSApp !== 'undefined' && MSApp.execUnsafeLocalFunction) {
+  /**
+   * Create a function which has 'unsafe' privileges (required by windows8 apps)
+   */
+  setInnerHTML = function (node, html) {
+    // $FlowFixMe[cannot-resolve-name]
+    return MSApp.execUnsafeLocalFunction(function () {
+      return setInnerHTMLImpl(node, html);
+    });
+  };
+}
+
+var setInnerHTML$1 = setInnerHTML;
+
+/**
+ * HTML nodeType values that represent the type of the node
+ */
+const ELEMENT_NODE = 1;
+const TEXT_NODE = 3;
+const COMMENT_NODE = 8;
+const DOCUMENT_NODE = 9;
+const DOCUMENT_TYPE_NODE = 10;
+const DOCUMENT_FRAGMENT_NODE = 11;
+
+/**
+ * Set the textContent property of a node. For text updates, it's faster
+ * to set the `nodeValue` of the Text node directly instead of using
+ * `.textContent` which will remove the existing node and create a new one.
+ *
+ * @param {DOMElement} node
+ * @param {string} text
+ * @internal
+ */
+
+function setTextContent(node, text) {
+  if (text) {
+    const firstChild = node.firstChild;
+
+    if (firstChild && firstChild === node.lastChild && firstChild.nodeType === TEXT_NODE) {
+      firstChild.nodeValue = text;
+      return;
+    }
+  }
+
+  node.textContent = text;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+const unitlessNumbers = new Set(['animationIterationCount', 'aspectRatio', 'borderImageOutset', 'borderImageSlice', 'borderImageWidth', 'boxFlex', 'boxFlexGroup', 'boxOrdinalGroup', 'columnCount', 'columns', 'flex', 'flexGrow', 'flexPositive', 'flexShrink', 'flexNegative', 'flexOrder', 'gridArea', 'gridRow', 'gridRowEnd', 'gridRowSpan', 'gridRowStart', 'gridColumn', 'gridColumnEnd', 'gridColumnSpan', 'gridColumnStart', 'fontWeight', 'lineClamp', 'lineHeight', 'opacity', 'order', 'orphans', 'scale', 'tabSize', 'widows', 'zIndex', 'zoom', 'fillOpacity', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'MozBoxFlexGroup', 'MozLineClamp', 'msAnimationIterationCount', 'msFlex', 'msZoom', 'msFlexGrow', 'msFlexNegative', 'msFlexOrder', 'msFlexPositive', 'msFlexShrink', 'msGridColumn', 'msGridColumnSpan', 'msGridRow', 'msGridRowSpan', 'WebkitAnimationIterationCount', 'WebkitBoxFlex', 'WebKitBoxFlexGroup', 'WebkitBoxOrdinalGroup', 'WebkitColumnCount', 'WebkitColumns', 'WebkitFlex', 'WebkitFlexGrow', 'WebkitFlexPositive', 'WebkitFlexShrink', 'WebkitLineClamp']);
+function isUnitlessNumber (name) {
+  return unitlessNumbers.has(name);
+}
+
+function setValueForStyle(style, styleName, value) {
+  const isCustomProperty = styleName.indexOf('--') === 0;
+
+  if (value == null || typeof value === 'boolean' || value === '') {
+    if (isCustomProperty) {
+      style.setProperty(styleName, '');
+    } else if (styleName === 'float') {
+      style.cssFloat = '';
+    } else {
+      style[styleName] = '';
+    }
+  } else if (isCustomProperty) {
+    style.setProperty(styleName, value);
+  } else if (typeof value === 'number' && value !== 0 && !isUnitlessNumber(styleName)) {
+    style[styleName] = value + 'px'; // Presumes implicit 'px' suffix for unitless numbers
+  } else {
+    if (styleName === 'float') {
+      style.cssFloat = value;
+    } else {
+
+      style[styleName] = ('' + value).trim();
+    }
+  }
+}
+/**
+ * Sets the value for multiple styles on a node.  If a value is specified as
+ * '' (empty string), the corresponding style property will be unset.
+ *
+ * @param {DOMElement} node
+ * @param {object} styles
+ */
+
+
+function setValueForStyles(node, styles, prevStyles) {
+  if (styles != null && typeof styles !== 'object') {
+    throw Error(formatProdErrorMessage(62));
+  }
+
+  const style = node.style;
+
+  if (prevStyles != null) {
+
+    for (const styleName in prevStyles) {
+      if (prevStyles.hasOwnProperty(styleName) && (styles == null || !styles.hasOwnProperty(styleName))) {
+        // Clear style
+        const isCustomProperty = styleName.indexOf('--') === 0;
+
+        if (isCustomProperty) {
+          style.setProperty(styleName, '');
+        } else if (styleName === 'float') {
+          style.cssFloat = '';
+        } else {
+          style[styleName] = '';
+        }
+      }
+    }
+
+    for (const styleName in styles) {
+      const value = styles[styleName];
+
+      if (styles.hasOwnProperty(styleName) && prevStyles[styleName] !== value) {
+        setValueForStyle(style, styleName, value);
+      }
+    }
+  } else {
+    for (const styleName in styles) {
+      if (styles.hasOwnProperty(styleName)) {
+        const value = styles[styleName];
+        setValueForStyle(style, styleName, value);
+      }
+    }
+  }
+}
+
+function isCustomElement(tagName, props) {
+  if (tagName.indexOf('-') === -1) {
+    return false;
+  }
+
+  switch (tagName) {
+    // These are reserved SVG and MathML elements.
+    // We don't mind this list too much because we expect it to never grow.
+    // The alternative is to track the namespace in a few places which is convoluted.
+    // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+    case 'annotation-xml':
+    case 'color-profile':
+    case 'font-face':
+    case 'font-face-src':
+    case 'font-face-uri':
+    case 'font-face-format':
+    case 'font-face-name':
+    case 'missing-glyph':
+      return false;
+
+    default:
+      return true;
+  }
+}
+
+const aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+  return aliases.get(name) || name;
+}
+
+function sanitizeURL(url) {
+
+  return url;
+}
+
+const IS_EVENT_HANDLE_NON_MANAGED_NODE = 1;
+const IS_NON_DELEGATED = 1 << 1;
+const IS_CAPTURE_PHASE = 1 << 2;
+// 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.
+// We also don't want to defer during event replaying.
+
+const SHOULD_NOT_PROCESS_POLYFILL_EVENT_PLUGINS = IS_EVENT_HANDLE_NON_MANAGED_NODE | IS_NON_DELEGATED | IS_CAPTURE_PHASE;
+
+// This exists to avoid circular dependency between ReactDOMEventReplaying
+// and DOMPluginEventSystem.
+let currentReplayingEvent = null;
+function setReplayingEvent(event) {
+
+  currentReplayingEvent = event;
+}
+function resetReplayingEvent() {
+
+  currentReplayingEvent = null;
+}
+function isReplayingEvent(event) {
+  return event === currentReplayingEvent;
+}
+
+/**
+ * Gets the target node from a native browser event by accounting for
+ * inconsistencies in browser DOM APIs.
+ *
+ * @param {object} nativeEvent Native browser event.
+ * @return {DOMEventTarget} Target node.
+ */
+
+function getEventTarget(nativeEvent) {
+  // Fallback to nativeEvent.srcElement for IE9
+  // https://github.com/facebook/react/issues/12506
+  let target = nativeEvent.target || nativeEvent.srcElement || window; // Normalize SVG <use> element events #4963
+
+  if (target.correspondingUseElement) {
+    target = target.correspondingUseElement;
+  } // Safari may fire events on text nodes (Node.TEXT_NODE is 3).
+  // @see http://www.quirksmode.org/js/events_properties.html
+
+
+  return target.nodeType === TEXT_NODE ? target.parentNode : target;
+}
+
+let restoreTarget = null;
+let restoreQueue = null;
+
+function restoreStateOfTarget(target) {
+  // We perform this translation at the end of the event loop so that we
+  // always receive the correct fiber here
+  const internalInstance = getInstanceFromNode(target);
+
+  if (!internalInstance) {
+    // Unmounted
+    return;
+  }
+
+  const stateNode = internalInstance.stateNode; // Guard against Fiber being unmounted.
+
+  if (stateNode) {
+    const props = getFiberCurrentPropsFromNode(stateNode);
+    restoreControlledState(internalInstance.stateNode, internalInstance.type, props);
+  }
+}
+
+function enqueueStateRestore(target) {
+  if (restoreTarget) {
+    if (restoreQueue) {
+      restoreQueue.push(target);
+    } else {
+      restoreQueue = [target];
+    }
+  } else {
+    restoreTarget = target;
+  }
+}
+function needsStateRestore() {
+  return restoreTarget !== null || restoreQueue !== null;
+}
+function restoreStateIfNeeded() {
+  if (!restoreTarget) {
+    return;
+  }
+
+  const target = restoreTarget;
+  const queuedTargets = restoreQueue;
+  restoreTarget = null;
+  restoreQueue = null;
+  restoreStateOfTarget(target);
+
+  if (queuedTargets) {
+    for (let i = 0; i < queuedTargets.length; i++) {
+      restoreStateOfTarget(queuedTargets[i]);
+    }
+  }
+}
+
+/**
+ * `ReactInstanceMap` maintains a mapping from a public facing stateful
+ * instance (key) and the internal representation (value). This allows public
+ * methods to accept the user facing instance as an argument and map them back
+ * to internal methods.
+ *
+ * Note that this module is currently shared and assumed to be stateless.
+ * If this becomes an actual Map, that will break.
+ */
+function get(key) {
+  return key._reactInternals;
+}
+function has(key) {
+  return key._reactInternals !== undefined;
+}
+function set(key, value) {
+  key._reactInternals = value;
+}
+
+function getNearestMountedFiber(fiber) {
+  let node = fiber;
+  let nearestMounted = fiber;
+
+  if (!fiber.alternate) {
+    // If there is no alternate, this might be a new tree that isn't inserted
+    // yet. If it is, then it will have a pending insertion effect on it.
+    let nextNode = node;
+
+    do {
+      node = nextNode;
+
+      if ((node.flags & (Placement | Hydrating)) !== NoFlags$1) {
+        // This is an insertion or in-progress hydration. The nearest possible
+        // mounted fiber is the parent but we need to continue to figure out
+        // if that one is still mounted.
+        nearestMounted = node.return;
+      } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+      nextNode = node.return;
+    } while (nextNode);
+  } else {
+    while (node.return) {
+      node = node.return;
+    }
+  }
+
+  if (node.tag === HostRoot) {
+    // TODO: Check if this was a nested HostRoot when used with
+    // renderContainerIntoSubtree.
+    return nearestMounted;
+  } // If we didn't hit the root, that means that we're in an disconnected tree
+  // that has been unmounted.
+
+
+  return null;
+}
+function getSuspenseInstanceFromFiber(fiber) {
+  if (fiber.tag === SuspenseComponent) {
+    let suspenseState = fiber.memoizedState;
+
+    if (suspenseState === null) {
+      const current = fiber.alternate;
+
+      if (current !== null) {
+        suspenseState = current.memoizedState;
+      }
+    }
+
+    if (suspenseState !== null) {
+      return suspenseState.dehydrated;
+    }
+  }
+
+  return null;
+}
+function getContainerFromFiber(fiber) {
+  return fiber.tag === HostRoot ? fiber.stateNode.containerInfo : null;
+}
+function isFiberMounted(fiber) {
+  return getNearestMountedFiber(fiber) === fiber;
+}
+function isMounted(component) {
+
+  const fiber = get(component);
+
+  if (!fiber) {
+    return false;
+  }
+
+  return getNearestMountedFiber(fiber) === fiber;
+}
+
+function assertIsMounted(fiber) {
+  if (getNearestMountedFiber(fiber) !== fiber) {
+    throw Error(formatProdErrorMessage(188));
+  }
+}
+
+function findCurrentFiberUsingSlowPath(fiber) {
+  const alternate = fiber.alternate;
+
+  if (!alternate) {
+    // If there is no alternate, then we only need to check if it is mounted.
+    const nearestMounted = getNearestMountedFiber(fiber);
+
+    if (nearestMounted === null) {
+      throw Error(formatProdErrorMessage(188));
+    }
+
+    if (nearestMounted !== fiber) {
+      return null;
+    }
+
+    return fiber;
+  } // If we have two possible branches, we'll walk backwards up to the root
+  // to see what path the root points to. On the way we may hit one of the
+  // special cases and we'll deal with them.
+
+
+  let a = fiber;
+  let b = alternate;
+
+  while (true) {
+    const parentA = a.return;
+
+    if (parentA === null) {
+      // We're at the root.
+      break;
+    }
+
+    const parentB = parentA.alternate;
+
+    if (parentB === null) {
+      // There is no alternate. This is an unusual case. Currently, it only
+      // happens when a Suspense component is hidden. An extra fragment fiber
+      // is inserted in between the Suspense fiber and its children. Skip
+      // over this extra fragment fiber and proceed to the next parent.
+      const nextParent = parentA.return;
+
+      if (nextParent !== null) {
+        a = b = nextParent;
+        continue;
+      } // If there's no parent, we're at the root.
+
+
+      break;
+    } // If both copies of the parent fiber point to the same child, we can
+    // assume that the child is current. This happens when we bailout on low
+    // priority: the bailed out fiber's child reuses the current child.
+
+
+    if (parentA.child === parentB.child) {
+      let child = parentA.child;
+
+      while (child) {
+        if (child === a) {
+          // We've determined that A is the current branch.
+          assertIsMounted(parentA);
+          return fiber;
+        }
+
+        if (child === b) {
+          // We've determined that B is the current branch.
+          assertIsMounted(parentA);
+          return alternate;
+        }
+
+        child = child.sibling;
+      } // We should never have an alternate for any mounting node. So the only
+      // way this could possibly happen is if this was unmounted, if at all.
+
+
+      throw Error(formatProdErrorMessage(188));
+    }
+
+    if (a.return !== b.return) {
+      // The return pointer of A and the return pointer of B point to different
+      // fibers. We assume that return pointers never criss-cross, so A must
+      // belong to the child set of A.return, and B must belong to the child
+      // set of B.return.
+      a = parentA;
+      b = parentB;
+    } else {
+      // The return pointers point to the same fiber. We'll have to use the
+      // default, slow path: scan the child sets of each parent alternate to see
+      // which child belongs to which set.
+      //
+      // Search parent A's child set
+      let didFindChild = false;
+      let child = parentA.child;
+
+      while (child) {
+        if (child === a) {
+          didFindChild = true;
+          a = parentA;
+          b = parentB;
+          break;
+        }
+
+        if (child === b) {
+          didFindChild = true;
+          b = parentA;
+          a = parentB;
+          break;
+        }
+
+        child = child.sibling;
+      }
+
+      if (!didFindChild) {
+        // Search parent B's child set
+        child = parentB.child;
+
+        while (child) {
+          if (child === a) {
+            didFindChild = true;
+            a = parentB;
+            b = parentA;
+            break;
+          }
+
+          if (child === b) {
+            didFindChild = true;
+            b = parentB;
+            a = parentA;
+            break;
+          }
+
+          child = child.sibling;
+        }
+
+        if (!didFindChild) {
+          throw Error(formatProdErrorMessage(189));
+        }
+      }
+    }
+
+    if (a.alternate !== b) {
+      throw Error(formatProdErrorMessage(190));
+    }
+  } // If the root is not a host container, we're in a disconnected tree. I.e.
+  // unmounted.
+
+
+  if (a.tag !== HostRoot) {
+    throw Error(formatProdErrorMessage(188));
+  }
+
+  if (a.stateNode.current === a) {
+    // We've determined that A is the current branch.
+    return fiber;
+  } // Otherwise B has to be current branch.
+
+
+  return alternate;
+}
+function findCurrentHostFiber(parent) {
+  const currentParent = findCurrentFiberUsingSlowPath(parent);
+  return currentParent !== null ? findCurrentHostFiberImpl(currentParent) : null;
+}
+
+function findCurrentHostFiberImpl(node) {
+  // Next we'll drill down this component to find the first HostComponent/Text.
+  const tag = node.tag;
+
+  if (tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton ) || tag === HostText) {
+    return node;
+  }
+
+  let child = node.child;
+
+  while (child !== null) {
+    const match = findCurrentHostFiberImpl(child);
+
+    if (match !== null) {
+      return match;
+    }
+
+    child = child.sibling;
+  }
+
+  return null;
+}
+
+const emptyContextObject = {};
+
+
+const contextStackCursor = createCursor(emptyContextObject); // A cursor to a boolean indicating whether the context has changed.
+
+const didPerformWorkStackCursor = createCursor(false); // Keep track of the previous context object that was on the stack.
+// We use this to get access to the parent context after we have already
+// pushed the next context provider, and now need to merge their contexts.
+
+let previousContext = emptyContextObject;
+
+function getUnmaskedContext(workInProgress, Component, didPushOwnContextIfProvider) {
+  {
+    if (didPushOwnContextIfProvider && isContextProvider(Component)) {
+      // If the fiber is a context provider itself, when we read its context
+      // we may have already pushed its own child context on the stack. A context
+      // provider should not "see" its own child context. Therefore we read the
+      // previous (parent) context instead for a context provider.
+      return previousContext;
+    }
+
+    return contextStackCursor.current;
+  }
+}
+
+function cacheContext(workInProgress, unmaskedContext, maskedContext) {
+  {
+    const instance = workInProgress.stateNode;
+    instance.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext;
+    instance.__reactInternalMemoizedMaskedChildContext = maskedContext;
+  }
+}
+
+function getMaskedContext(workInProgress, unmaskedContext) {
+  {
+    const type = workInProgress.type;
+    const contextTypes = type.contextTypes;
+
+    if (!contextTypes) {
+      return emptyContextObject;
+    } // Avoid recreating masked context unless unmasked context has changed.
+    // Failing to do this will result in unnecessary calls to componentWillReceiveProps.
+    // This may trigger infinite loops if componentWillReceiveProps calls setState.
+
+
+    const instance = workInProgress.stateNode;
+
+    if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) {
+      return instance.__reactInternalMemoizedMaskedChildContext;
+    }
+
+    const context = {};
+
+    for (const key in contextTypes) {
+      context[key] = unmaskedContext[key];
+    }
+    // Context is created before the class component is instantiated so check for instance.
+
+
+    if (instance) {
+      cacheContext(workInProgress, unmaskedContext, context);
+    }
+
+    return context;
+  }
+}
+
+function hasContextChanged() {
+  {
+    return didPerformWorkStackCursor.current;
+  }
+}
+
+function isContextProvider(type) {
+  {
+    const childContextTypes = type.childContextTypes;
+    return childContextTypes !== null && childContextTypes !== undefined;
+  }
+}
+
+function popContext(fiber) {
+  {
+    pop(didPerformWorkStackCursor);
+    pop(contextStackCursor);
+  }
+}
+
+function popTopLevelContextObject(fiber) {
+  {
+    pop(didPerformWorkStackCursor);
+    pop(contextStackCursor);
+  }
+}
+
+function pushTopLevelContextObject(fiber, context, didChange) {
+  {
+    if (contextStackCursor.current !== emptyContextObject) {
+      throw Error(formatProdErrorMessage(168));
+    }
+
+    push(contextStackCursor, context);
+    push(didPerformWorkStackCursor, didChange);
+  }
+}
+
+function processChildContext(fiber, type, parentContext) {
+  {
+    const instance = fiber.stateNode;
+    const childContextTypes = type.childContextTypes; // TODO (bvaughn) Replace this behavior with an invariant() in the future.
+    // It has only been added in Fiber to match the (unintentional) behavior in Stack.
+
+    if (typeof instance.getChildContext !== 'function') {
+
+      return parentContext;
+    }
+
+    const childContext = instance.getChildContext();
+
+    for (const contextKey in childContext) {
+      if (!(contextKey in childContextTypes)) {
+        throw Error(formatProdErrorMessage(108, getComponentNameFromFiber(fiber) || 'Unknown', contextKey));
+      }
+    }
+
+    return assign({}, parentContext, childContext);
+  }
+}
+
+function pushContextProvider(workInProgress) {
+  {
+    const instance = workInProgress.stateNode; // We push the context as early as possible to ensure stack integrity.
+    // If the instance does not exist yet, we will push null at first,
+    // and replace it on the stack later when invalidating the context.
+
+    const memoizedMergedChildContext = instance && instance.__reactInternalMemoizedMergedChildContext || emptyContextObject; // Remember the parent context so we can merge with it later.
+    // Inherit the parent's did-perform-work value to avoid inadvertently blocking updates.
+
+    previousContext = contextStackCursor.current;
+    push(contextStackCursor, memoizedMergedChildContext);
+    push(didPerformWorkStackCursor, didPerformWorkStackCursor.current);
+    return true;
+  }
+}
+
+function invalidateContextProvider(workInProgress, type, didChange) {
+  {
+    const instance = workInProgress.stateNode;
+
+    if (!instance) {
+      throw Error(formatProdErrorMessage(169));
+    }
+
+    if (didChange) {
+      // Merge parent and own context.
+      // Skip this if we're not updating due to sCU.
+      // This avoids unnecessarily recomputing memoized values.
+      const mergedContext = processChildContext(workInProgress, type, previousContext);
+      instance.__reactInternalMemoizedMergedChildContext = mergedContext; // Replace the old (or empty) context with the new one.
+      // It is important to unwind the context in the reverse order.
+
+      pop(didPerformWorkStackCursor);
+      pop(contextStackCursor); // Now push the new context and mark that it has changed.
+
+      push(contextStackCursor, mergedContext);
+      push(didPerformWorkStackCursor, didChange);
+    } else {
+      pop(didPerformWorkStackCursor);
+      push(didPerformWorkStackCursor, didChange);
+    }
+  }
+}
+
+function findCurrentUnmaskedContext(fiber) {
+  {
+    // Currently this is only used with renderSubtreeIntoContainer; not sure if it
+    // makes sense elsewhere
+    if (!isFiberMounted(fiber) || fiber.tag !== ClassComponent) {
+      throw Error(formatProdErrorMessage(170));
+    }
+
+    let node = fiber;
+
+    do {
+      switch (node.tag) {
+        case HostRoot:
+          return node.stateNode.context;
+
+        case ClassComponent:
+          {
+            const Component = node.type;
+
+            if (isContextProvider(Component)) {
+              return node.stateNode.__reactInternalMemoizedMergedChildContext;
+            }
+
+            break;
+          }
+      } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+      node = node.return;
+    } while (node !== null);
+
+    throw Error(formatProdErrorMessage(171));
+  }
+}
+
+const LegacyRoot = 0;
+const ConcurrentRoot = 1;
+
+// We use the existence of the state object as an indicator that the component
+// is hidden.
+const OffscreenVisible =
+/*                     */
+0b001;
+const OffscreenDetached =
+/*                    */
+0b010;
+const OffscreenPassiveEffectsConnected =
+/*     */
+0b100;
+function isOffscreenManual(offscreenFiber) {
+  return offscreenFiber.memoizedProps !== null && offscreenFiber.memoizedProps.mode === 'manual';
+}
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+
+const objectIs = // $FlowFixMe[method-unbinding]
+typeof Object.is === 'function' ? Object.is : is;
+
+// This is imported by the event replaying implementation in React DOM. It's
+// in a separate file to break a circular dependency between the renderer and
+// the reconciler.
+function isRootDehydrated(root) {
+  const currentState = root.current.memoizedState;
+  return currentState.isDehydrated;
+}
+
+// Ids are base 32 strings whose binary representation corresponds to the
+// 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.
+
+const forkStack = [];
+let forkStackIndex = 0;
+let treeForkProvider = null;
+let treeForkCount = 0;
+const idStack = [];
+let idStackIndex = 0;
+let treeContextProvider = null;
+let treeContextId = 1;
+let treeContextOverflow = '';
+function isForkedChild(workInProgress) {
+  return (workInProgress.flags & Forked) !== NoFlags$1;
+}
+function getForksAtLevel(workInProgress) {
+  return treeForkCount;
+}
+function getTreeId() {
+  const overflow = treeContextOverflow;
+  const idWithLeadingBit = treeContextId;
+  const id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
+  return id.toString(32) + overflow;
+}
+function pushTreeFork(workInProgress, totalChildren) {
+  forkStack[forkStackIndex++] = treeForkCount;
+  forkStack[forkStackIndex++] = treeForkProvider;
+  treeForkProvider = workInProgress;
+  treeForkCount = totalChildren;
+}
+function pushTreeId(workInProgress, totalChildren, index) {
+  idStack[idStackIndex++] = treeContextId;
+  idStack[idStackIndex++] = treeContextOverflow;
+  idStack[idStackIndex++] = treeContextProvider;
+  treeContextProvider = workInProgress;
+  const baseIdWithLeadingBit = treeContextId;
+  const baseOverflow = treeContextOverflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
+  // of the id; we use it to account for leading 0s.
+
+  const baseLength = getBitLength(baseIdWithLeadingBit) - 1;
+  const baseId = baseIdWithLeadingBit & ~(1 << baseLength);
+  const slot = index + 1;
+  const length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
+  // consideration the leading 1 we use to mark the end of the sequence.
+
+  if (length > 30) {
+    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
+    // This branch assumes the length of the base id is greater than 5; it won't
+    // work for smaller ids, because you need 5 bits per character.
+    //
+    // We encode the id in multiple steps: first the base id, then the
+    // remaining digits.
+    //
+    // Each 5 bit sequence corresponds to a single base 32 character. So for
+    // example, if the current id is 23 bits long, we can convert 20 of those
+    // bits into a string of 4 characters, with 3 bits left over.
+    //
+    // First calculate how many bits in the base id represent a complete
+    // sequence of characters.
+    const numberOfOverflowBits = baseLength - baseLength % 5; // Then create a bitmask that selects only those bits.
+
+    const newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
+
+    const newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
+
+    const restOfBaseId = baseId >> numberOfOverflowBits;
+    const restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
+    // we made more room, this time it won't overflow.
+
+    const restOfLength = getBitLength(totalChildren) + restOfBaseLength;
+    const restOfNewBits = slot << restOfBaseLength;
+    const id = restOfNewBits | restOfBaseId;
+    const overflow = newOverflow + baseOverflow;
+    treeContextId = 1 << restOfLength | id;
+    treeContextOverflow = overflow;
+  } else {
+    // Normal path
+    const newBits = slot << baseLength;
+    const id = newBits | baseId;
+    const overflow = baseOverflow;
+    treeContextId = 1 << length | id;
+    treeContextOverflow = overflow;
+  }
+}
+function pushMaterializedTreeId(workInProgress) {
+  // in its children.
+
+  const returnFiber = workInProgress.return;
+
+  if (returnFiber !== null) {
+    const numberOfForks = 1;
+    const slotIndex = 0;
+    pushTreeFork(workInProgress, numberOfForks);
+    pushTreeId(workInProgress, numberOfForks, slotIndex);
+  }
+}
+
+function getBitLength(number) {
+  return 32 - clz32(number);
+}
+
+function getLeadingBit(id) {
+  return 1 << getBitLength(id) - 1;
+}
+
+function popTreeContext(workInProgress) {
+  // Restore the previous values.
+  // This is a bit more complicated than other context-like modules in Fiber
+  // because the same Fiber may appear on the stack multiple times and for
+  // different reasons. We have to keep popping until the work-in-progress is
+  // no longer at the top of the stack.
+  while (workInProgress === treeForkProvider) {
+    treeForkProvider = forkStack[--forkStackIndex];
+    forkStack[forkStackIndex] = null;
+    treeForkCount = forkStack[--forkStackIndex];
+    forkStack[forkStackIndex] = null;
+  }
+
+  while (workInProgress === treeContextProvider) {
+    treeContextProvider = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+    treeContextOverflow = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+    treeContextId = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+  }
+}
+function getSuspendedTreeContext() {
+
+  if (treeContextProvider !== null) {
+    return {
+      id: treeContextId,
+      overflow: treeContextOverflow
+    };
+  } else {
+    return null;
+  }
+}
+function restoreSuspendedTreeContext(workInProgress, suspendedContext) {
+  idStack[idStackIndex++] = treeContextId;
+  idStack[idStackIndex++] = treeContextOverflow;
+  idStack[idStackIndex++] = treeContextProvider;
+  treeContextId = suspendedContext.id;
+  treeContextOverflow = suspendedContext.overflow;
+  treeContextProvider = workInProgress;
+}
+
+// This may have been an insertion or a hydration.
+
+let hydrationParentFiber = null;
+let nextHydratableInstance = null;
+let isHydrating = false; // This flag allows for warning supression when we expect there to be mismatches
+
+let hydrationErrors = null;
+let rootOrSingletonContext = false;
+
+function enterHydrationState(fiber) {
+
+  const parentInstance = fiber.stateNode.containerInfo;
+  nextHydratableInstance = getFirstHydratableChildWithinContainer(parentInstance);
+  hydrationParentFiber = fiber;
+  isHydrating = true;
+  hydrationErrors = null;
+  rootOrSingletonContext = true;
+  return true;
+}
+
+function reenterHydrationStateFromDehydratedSuspenseInstance(fiber, suspenseInstance, treeContext) {
+
+  nextHydratableInstance = getFirstHydratableChildWithinSuspenseInstance(suspenseInstance);
+  hydrationParentFiber = fiber;
+  isHydrating = true;
+  hydrationErrors = null;
+  rootOrSingletonContext = false;
+
+  if (treeContext !== null) {
+    restoreSuspendedTreeContext(fiber, treeContext);
+  }
+
+  return true;
+}
+
+function deleteHydratableInstance(returnFiber, instance) {
+  const childToDelete = createFiberFromHostInstanceForDeletion();
+  childToDelete.stateNode = instance;
+  childToDelete.return = returnFiber;
+  const deletions = returnFiber.deletions;
+
+  if (deletions === null) {
+    returnFiber.deletions = [childToDelete];
+    returnFiber.flags |= ChildDeletion;
+  } else {
+    deletions.push(childToDelete);
+  }
+}
+
+function insertNonHydratedInstance(returnFiber, fiber) {
+  fiber.flags = fiber.flags & ~Hydrating | Placement;
+}
+
+function tryHydrateInstance(fiber, nextInstance) {
+  // fiber is a HostComponent Fiber
+  const instance = canHydrateInstance(nextInstance, fiber.type, fiber.pendingProps, rootOrSingletonContext);
+
+  if (instance !== null) {
+    fiber.stateNode = instance;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = getFirstHydratableChild(instance);
+    rootOrSingletonContext = false;
+    return true;
+  }
+
+  return false;
+}
+
+function tryHydrateText(fiber, nextInstance) {
+  // fiber is a HostText Fiber
+  const text = fiber.pendingProps;
+  const textInstance = canHydrateTextInstance(nextInstance, text, rootOrSingletonContext);
+
+  if (textInstance !== null) {
+    fiber.stateNode = textInstance;
+    hydrationParentFiber = fiber; // Text Instances don't have children so there's nothing to hydrate.
+
+    nextHydratableInstance = null;
+    return true;
+  }
+
+  return false;
+}
+
+function tryHydrateSuspense(fiber, nextInstance) {
+  // fiber is a SuspenseComponent Fiber
+  const suspenseInstance = canHydrateSuspenseInstance(nextInstance, rootOrSingletonContext);
+
+  if (suspenseInstance !== null) {
+    const suspenseState = {
+      dehydrated: suspenseInstance,
+      treeContext: getSuspendedTreeContext(),
+      retryLane: OffscreenLane
+    };
+    fiber.memoizedState = suspenseState; // Store the dehydrated fragment as a child fiber.
+    // This simplifies the code for getHostSibling and deleting nodes,
+    // since it doesn't have to consider all Suspense boundaries and
+    // check if they're dehydrated ones or not.
+
+    const dehydratedFragment = createFiberFromDehydratedFragment(suspenseInstance);
+    dehydratedFragment.return = fiber;
+    fiber.child = dehydratedFragment;
+    hydrationParentFiber = fiber; // While a Suspense Instance does have children, we won't step into
+    // it during the first pass. Instead, we'll reenter it later.
+
+    nextHydratableInstance = null;
+    return true;
+  }
+
+  return false;
+}
+
+function shouldClientRenderOnMismatch(fiber) {
+  return (fiber.mode & ConcurrentMode) !== NoMode && (fiber.flags & DidCapture) === NoFlags$1;
+}
+
+function throwOnHydrationMismatch(fiber) {
+  throw Error(formatProdErrorMessage(418));
+}
+
+function claimHydratableSingleton(fiber) {
+  {
+    if (!isHydrating) {
+      return;
+    }
+
+    const currentRootContainer = getRootHostContainer();
+    const instance = fiber.stateNode = resolveSingletonInstance(fiber.type, fiber.pendingProps, currentRootContainer);
+    hydrationParentFiber = fiber;
+    rootOrSingletonContext = true;
+    nextHydratableInstance = getFirstHydratableChild(instance);
+  }
+}
+
+function tryToClaimNextHydratableInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
+
+  const initialInstance = nextHydratableInstance;
+  const nextInstance = nextHydratableInstance;
+
+  if (!nextInstance) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
+
+
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
+    return;
+  }
+
+  const firstAttemptedInstance = nextInstance;
+
+  if (!tryHydrateInstance(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
+
+
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    const prevHydrationParentFiber = hydrationParentFiber;
+
+    if (!nextHydratableInstance || !tryHydrateInstance(fiber, nextHydratableInstance)) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
+
+
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+  }
+}
+
+function tryToClaimNextHydratableTextInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
+
+  const text = fiber.pendingProps;
+  const isHydratable = isHydratableText(text);
+  const initialInstance = nextHydratableInstance;
+  const nextInstance = nextHydratableInstance;
+
+  if (!nextInstance || !isHydratable) {
+    // We exclude non hydrabable text because we know there are no matching hydratables.
+    // We either throw or insert depending on the render mode.
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
+
+
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
+    return;
+  }
+
+  const firstAttemptedInstance = nextInstance;
+
+  if (!tryHydrateText(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
+
+
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    const prevHydrationParentFiber = hydrationParentFiber;
+
+    if (!nextHydratableInstance || !tryHydrateText(fiber, nextHydratableInstance)) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
+
+
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+  }
+}
+
+function tryToClaimNextHydratableSuspenseInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
+
+  const initialInstance = nextHydratableInstance;
+  const nextInstance = nextHydratableInstance;
+
+  if (!nextInstance) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
+
+
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
+    return;
+  }
+
+  const firstAttemptedInstance = nextInstance;
+
+  if (!tryHydrateSuspense(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
+
+
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    const prevHydrationParentFiber = hydrationParentFiber;
+
+    if (!nextHydratableInstance || !tryHydrateSuspense(fiber, nextHydratableInstance)) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
+
+
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+  }
+}
+
+function tryToClaimNextHydratableFormMarkerInstance(fiber) {
+  if (!isHydrating) {
+    return false;
+  }
+
+  if (nextHydratableInstance) {
+    const markerInstance = canHydrateFormStateMarker(nextHydratableInstance, rootOrSingletonContext);
+
+    if (markerInstance) {
+      // Found the marker instance.
+      nextHydratableInstance = getNextHydratableSibling(markerInstance); // Return true if this marker instance should use the state passed
+      // to hydrateRoot.
+      // TODO: As an optimization, Fizz should only emit these markers if form
+      // state is passed at the root.
+
+      return isFormStateMarkerMatching(markerInstance);
+    }
+  } // Should have found a marker instance. Throw an error to trigger client
+  // rendering. We don't bother to check if we're in a concurrent root because
+  // useFormState is a new API, so backwards compat is not an issue.
+
+
+  throwOnHydrationMismatch();
+  return false;
+}
+
+function prepareToHydrateHostInstance(fiber, hostContext) {
+
+  const instance = fiber.stateNode;
+  hydrateInstance(instance, fiber.type, fiber.memoizedProps, hostContext, fiber);
+}
+
+function prepareToHydrateHostTextInstance(fiber) {
+
+  const textInstance = fiber.stateNode;
+  const textContent = fiber.memoizedProps;
+  const shouldUpdate = hydrateTextInstance(textInstance, textContent, fiber);
+
+  if (shouldUpdate) {
+    // We assume that prepareToHydrateHostTextInstance is called in a context where the
+    // hydration parent is the parent host component of this host text.
+    const returnFiber = hydrationParentFiber;
+
+    if (returnFiber !== null) {
+      switch (returnFiber.tag) {
+        case HostRoot:
+          {
+            const parentContainer = returnFiber.stateNode.containerInfo;
+            const isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
+            didNotMatchHydratedContainerTextInstance(parentContainer, textInstance, textContent, // TODO: Delete this argument when we remove the legacy root API.
+            isConcurrentMode);
+
+            if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {
+              // In concurrent mode we never update the mismatched text,
+              // even if the error was ignored.
+              return false;
+            }
+
+            break;
+          }
+
+        case HostSingleton:
+        case HostComponent:
+          {
+            const parentType = returnFiber.type;
+            const parentProps = returnFiber.memoizedProps;
+            const parentInstance = returnFiber.stateNode;
+            const isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
+            didNotMatchHydratedTextInstance(parentType, parentProps, parentInstance, textInstance, textContent, // TODO: Delete this argument when we remove the legacy root API.
+            isConcurrentMode);
+
+            if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {
+              // In concurrent mode we never update the mismatched text,
+              // even if the error was ignored.
+              return false;
+            }
+
+            break;
+          }
+      }
+    }
+  }
+
+  return shouldUpdate;
+}
+
+function prepareToHydrateHostSuspenseInstance(fiber) {
+
+  const suspenseState = fiber.memoizedState;
+  const suspenseInstance = suspenseState !== null ? suspenseState.dehydrated : null;
+
+  if (!suspenseInstance) {
+    throw Error(formatProdErrorMessage(317));
+  }
+
+  hydrateSuspenseInstance(suspenseInstance, fiber);
+}
+
+function skipPastDehydratedSuspenseInstance(fiber) {
+
+  const suspenseState = fiber.memoizedState;
+  const suspenseInstance = suspenseState !== null ? suspenseState.dehydrated : null;
+
+  if (!suspenseInstance) {
+    throw Error(formatProdErrorMessage(317));
+  }
+
+  return getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance);
+}
+
+function popToNextHostParent(fiber) {
+  hydrationParentFiber = fiber.return;
+
+  while (hydrationParentFiber) {
+    switch (hydrationParentFiber.tag) {
+      case HostRoot:
+      case HostSingleton:
+        rootOrSingletonContext = true;
+        return;
+
+      case HostComponent:
+      case SuspenseComponent:
+        rootOrSingletonContext = false;
+        return;
+
+      default:
+        hydrationParentFiber = hydrationParentFiber.return;
+    }
+  }
+}
+
+function popHydrationState(fiber) {
+
+  if (fiber !== hydrationParentFiber) {
+    // We're deeper than the current hydration context, inside an inserted
+    // tree.
+    return false;
+  }
+
+  if (!isHydrating) {
+    // If we're not currently hydrating but we're in a hydration context, then
+    // we were an insertion and now need to pop up reenter hydration of our
+    // siblings.
+    popToNextHostParent(fiber);
+    isHydrating = true;
+    return false;
+  }
+
+  let shouldClear = false;
+
+  {
+    // With float we never clear the Root, or Singleton instances. We also do not clear Instances
+    // that have singleton text content
+    if (fiber.tag !== HostRoot && fiber.tag !== HostSingleton && !(fiber.tag === HostComponent && (!shouldDeleteUnhydratedTailInstances(fiber.type) || shouldSetTextContent(fiber.type, fiber.memoizedProps)))) {
+      shouldClear = true;
+    }
+  }
+
+  if (shouldClear) {
+    let nextInstance = nextHydratableInstance;
+
+    if (nextInstance) {
+      if (shouldClientRenderOnMismatch(fiber)) {
+        warnIfUnhydratedTailNodes();
+        throwOnHydrationMismatch();
+      } else {
+        while (nextInstance) {
+          deleteHydratableInstance(fiber, nextInstance);
+          nextInstance = getNextHydratableSibling(nextInstance);
+        }
+      }
+    }
+  }
+
+  popToNextHostParent(fiber);
+
+  if (fiber.tag === SuspenseComponent) {
+    nextHydratableInstance = skipPastDehydratedSuspenseInstance(fiber);
+  } else {
+    nextHydratableInstance = hydrationParentFiber ? getNextHydratableSibling(fiber.stateNode) : null;
+  }
+
+  return true;
+}
+
+function hasUnhydratedTailNodes() {
+  return isHydrating && nextHydratableInstance !== null;
+}
+
+function warnIfUnhydratedTailNodes(fiber) {
+  let nextInstance = nextHydratableInstance;
+
+  while (nextInstance) {
+    nextInstance = getNextHydratableSibling(nextInstance);
+  }
+}
+
+function resetHydrationState() {
+
+  hydrationParentFiber = null;
+  nextHydratableInstance = null;
+  isHydrating = false;
+}
+
+function upgradeHydrationErrorsToRecoverable() {
+  if (hydrationErrors !== null) {
+    // Successfully completed a forced client render. The errors that occurred
+    // during the hydration attempt are now recovered. We will log them in
+    // commit phase, once the entire tree has finished.
+    queueRecoverableErrors(hydrationErrors);
+    hydrationErrors = null;
+  }
+}
+
+function getIsHydrating() {
+  return isHydrating;
+}
+
+function queueHydrationError(error) {
+  if (hydrationErrors === null) {
+    hydrationErrors = [error];
+  } else {
+    hydrationErrors.push(error);
+  }
+}
+
+// we wait until the current render is over (either finished or interrupted)
+// before adding it to the fiber/hook queue. Push to this array so we can
+// access the queue, fiber, update, et al later.
+
+const concurrentQueues = [];
+let concurrentQueuesIndex = 0;
+let concurrentlyUpdatedLanes = NoLanes;
+function finishQueueingConcurrentUpdates() {
+  const endIndex = concurrentQueuesIndex;
+  concurrentQueuesIndex = 0;
+  concurrentlyUpdatedLanes = NoLanes;
+  let i = 0;
+
+  while (i < endIndex) {
+    const fiber = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    const queue = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    const update = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    const lane = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+
+    if (queue !== null && update !== null) {
+      const pending = queue.pending;
+
+      if (pending === null) {
+        // This is the first update. Create a circular list.
+        update.next = update;
+      } else {
+        update.next = pending.next;
+        pending.next = update;
+      }
+
+      queue.pending = update;
+    }
+
+    if (lane !== NoLane) {
+      markUpdateLaneFromFiberToRoot(fiber, update, lane);
+    }
+  }
+}
+function getConcurrentlyUpdatedLanes() {
+  return concurrentlyUpdatedLanes;
+}
+
+function enqueueUpdate$1(fiber, queue, update, lane) {
+  // Don't update the `childLanes` on the return path yet. If we already in
+  // the middle of rendering, wait until after it has completed.
+  concurrentQueues[concurrentQueuesIndex++] = fiber;
+  concurrentQueues[concurrentQueuesIndex++] = queue;
+  concurrentQueues[concurrentQueuesIndex++] = update;
+  concurrentQueues[concurrentQueuesIndex++] = lane;
+  concurrentlyUpdatedLanes = mergeLanes(concurrentlyUpdatedLanes, lane); // The fiber's `lane` field is used in some places to check if any work is
+  // scheduled, to perform an eager bailout, so we need to update it immediately.
+  // TODO: We should probably move this to the "shared" queue instead.
+
+  fiber.lanes = mergeLanes(fiber.lanes, lane);
+  const alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, lane);
+  }
+}
+
+function enqueueConcurrentHookUpdate(fiber, queue, update, lane) {
+  const concurrentQueue = queue;
+  const concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane);
+  return getRootForUpdatedFiber(fiber);
+}
+function enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update) {
+  // This function is used to queue an update that doesn't need a rerender. The
+  // only reason we queue it is in case there's a subsequent higher priority
+  // update that causes it to be rebased.
+  const lane = NoLane;
+  const concurrentQueue = queue;
+  const concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane); // Usually we can rely on the upcoming render phase to process the concurrent
+  // queue. However, since this is a bail out, we're not scheduling any work
+  // here. So the update we just queued will leak until something else happens
+  // to schedule work (if ever).
+  //
+  // Check if we're currently in the middle of rendering a tree, and if not,
+  // process the queue immediately to prevent a leak.
+
+  const isConcurrentlyRendering = getWorkInProgressRoot() !== null;
+
+  if (!isConcurrentlyRendering) {
+    finishQueueingConcurrentUpdates();
+  }
+}
+function enqueueConcurrentClassUpdate(fiber, queue, update, lane) {
+  const concurrentQueue = queue;
+  const concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane);
+  return getRootForUpdatedFiber(fiber);
+}
+function enqueueConcurrentRenderForLane(fiber, lane) {
+  enqueueUpdate$1(fiber, null, null, lane);
+  return getRootForUpdatedFiber(fiber);
+} // Calling this function outside this module should only be done for backwards
+// compatibility and should always be accompanied by a warning.
+
+function unsafe_markUpdateLaneFromFiberToRoot(sourceFiber, lane) {
+  // NOTE: For Hyrum's Law reasons, if an infinite update loop is detected, it
+  // should throw before `markUpdateLaneFromFiberToRoot` is called. But this is
+  // undefined behavior and we can change it if we need to; it just so happens
+  // that, at the time of this writing, there's an internal product test that
+  // happens to rely on this.
+  const root = getRootForUpdatedFiber(sourceFiber);
+  markUpdateLaneFromFiberToRoot(sourceFiber, null, lane);
+  return root;
+}
+
+function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
+  // Update the source fiber's lanes
+  sourceFiber.lanes = mergeLanes(sourceFiber.lanes, lane);
+  let alternate = sourceFiber.alternate;
+
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, lane);
+  } // Walk the parent path to the root and update the child lanes.
+
+
+  let isHidden = false;
+  let parent = sourceFiber.return;
+  let node = sourceFiber;
+
+  while (parent !== null) {
+    parent.childLanes = mergeLanes(parent.childLanes, lane);
+    alternate = parent.alternate;
+
+    if (alternate !== null) {
+      alternate.childLanes = mergeLanes(alternate.childLanes, lane);
+    }
+
+    if (parent.tag === OffscreenComponent) {
+      // Check if this offscreen boundary is currently hidden.
+      //
+      // The instance may be null if the Offscreen parent was unmounted. Usually
+      // the parent wouldn't be reachable in that case because we disconnect
+      // fibers from the tree when they are deleted. However, there's a weird
+      // edge case where setState is called on a fiber that was interrupted
+      // before it ever mounted. Because it never mounts, it also never gets
+      // deleted. Because it never gets deleted, its return pointer never gets
+      // disconnected. Which means it may be attached to a deleted Offscreen
+      // parent node. (This discovery suggests it may be better for memory usage
+      // if we don't attach the `return` pointer until the commit phase, though
+      // in order to do that we'd need some other way to track the return
+      // pointer during the initial render, like on the stack.)
+      //
+      // This case is always accompanied by a warning, but we still need to
+      // account for it. (There may be other cases that we haven't discovered,
+      // too.)
+      const offscreenInstance = parent.stateNode;
+
+      if (offscreenInstance !== null && !(offscreenInstance._visibility & OffscreenVisible)) {
+        isHidden = true;
+      }
+    }
+
+    node = parent;
+    parent = parent.return;
+  }
+
+  if (isHidden && update !== null && node.tag === HostRoot) {
+    const root = node.stateNode;
+    markHiddenUpdate(root, update, lane);
+  }
+}
+
+function getRootForUpdatedFiber(sourceFiber) {
+  // TODO: We will detect and infinite update loop and throw even if this fiber
+  // has already unmounted. This isn't really necessary but it happens to be the
+  // current behavior we've used for several release cycles. Consider not
+  // performing this check if the updated fiber already unmounted, since it's
+  // not possible for that to cause an infinite update loop.
+  throwIfInfiniteUpdateLoopDetected(); // When a setState happens, we must ensure the root is scheduled. Because
+  let node = sourceFiber;
+  let parent = node.return;
+
+  while (parent !== null) {
+    node = parent;
+    parent = node.return;
+  }
+
+  return node.tag === HostRoot ? node.stateNode : null;
+}
+
+const UpdateState = 0;
+const ReplaceState = 1;
+const ForceUpdate = 2;
+const CaptureUpdate = 3; // Global state that is reset at the beginning of calling `processUpdateQueue`.
+// It should only be read right after calling `processUpdateQueue`, via
+// `checkHasForceUpdateAfterProcessing`.
+
+let hasForceUpdate = false;
+
+function initializeUpdateQueue(fiber) {
+  const queue = {
+    baseState: fiber.memoizedState,
+    firstBaseUpdate: null,
+    lastBaseUpdate: null,
+    shared: {
+      pending: null,
+      lanes: NoLanes,
+      hiddenCallbacks: null
+    },
+    callbacks: null
+  };
+  fiber.updateQueue = queue;
+}
+function cloneUpdateQueue(current, workInProgress) {
+  // Clone the update queue from current. Unless it's already a clone.
+  const queue = workInProgress.updateQueue;
+  const currentQueue = current.updateQueue;
+
+  if (queue === currentQueue) {
+    const clone = {
+      baseState: currentQueue.baseState,
+      firstBaseUpdate: currentQueue.firstBaseUpdate,
+      lastBaseUpdate: currentQueue.lastBaseUpdate,
+      shared: currentQueue.shared,
+      callbacks: null
+    };
+    workInProgress.updateQueue = clone;
+  }
+}
+function createUpdate(lane) {
+  const update = {
+    lane,
+    tag: UpdateState,
+    payload: null,
+    callback: null,
+    next: null
+  };
+  return update;
+}
+function enqueueUpdate(fiber, update, lane) {
+  const updateQueue = fiber.updateQueue;
+
+  if (updateQueue === null) {
+    // Only occurs if the fiber has been unmounted.
+    return null;
+  }
+
+  const sharedQueue = updateQueue.shared;
+
+  if (isUnsafeClassRenderPhaseUpdate()) {
+    // This is an unsafe render phase update. Add directly to the update
+    // queue so we can process it immediately during the current render.
+    const pending = sharedQueue.pending;
+
+    if (pending === null) {
+      // This is the first update. Create a circular list.
+      update.next = update;
+    } else {
+      update.next = pending.next;
+      pending.next = update;
+    }
+
+    sharedQueue.pending = update; // Update the childLanes even though we're most likely already rendering
+    // this fiber. This is for backwards compatibility in the case where you
+    // update a different component during render phase than the one that is
+    // currently renderings (a pattern that is accompanied by a warning).
+
+    return unsafe_markUpdateLaneFromFiberToRoot(fiber, lane);
+  } else {
+    return enqueueConcurrentClassUpdate(fiber, sharedQueue, update, lane);
+  }
+}
+function entangleTransitions(root, fiber, lane) {
+  const updateQueue = fiber.updateQueue;
+
+  if (updateQueue === null) {
+    // Only occurs if the fiber has been unmounted.
+    return;
+  }
+
+  const sharedQueue = updateQueue.shared;
+
+  if (isTransitionLane(lane)) {
+    let queueLanes = sharedQueue.lanes; // If any entangled lanes are no longer pending on the root, then they must
+    // have finished. We can remove them from the shared queue, which represents
+    // a superset of the actually pending lanes. In some cases we may entangle
+    // more than we need to, but that's OK. In fact it's worse if we *don't*
+    // entangle when we should.
+
+    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.
+
+    const newQueueLanes = mergeLanes(queueLanes, lane);
+    sharedQueue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if
+    // the lane finished since the last time we entangled it. So we need to
+    // entangle it again, just to be sure.
+
+    markRootEntangled(root, newQueueLanes);
+  }
+}
+function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
+  // Captured updates are updates that are thrown by a child during the render
+  // phase. They should be discarded if the render is aborted. Therefore,
+  // we should only put them on the work-in-progress queue, not the current one.
+  let queue = workInProgress.updateQueue; // Check if the work-in-progress queue is a clone.
+
+  const current = workInProgress.alternate;
+
+  if (current !== null) {
+    const currentQueue = current.updateQueue;
+
+    if (queue === currentQueue) {
+      // The work-in-progress queue is the same as current. This happens when
+      // we bail out on a parent fiber that then captures an error thrown by
+      // a child. Since we want to append the update only to the work-in
+      // -progress queue, we need to clone the updates. We usually clone during
+      // processUpdateQueue, but that didn't happen in this case because we
+      // skipped over the parent when we bailed out.
+      let newFirst = null;
+      let newLast = null;
+      const firstBaseUpdate = queue.firstBaseUpdate;
+
+      if (firstBaseUpdate !== null) {
+        // Loop through the updates and clone them.
+        let update = firstBaseUpdate;
+
+        do {
+          const clone = {
+            lane: update.lane,
+            tag: update.tag,
+            payload: update.payload,
+            // When this update is rebased, we should not fire its
+            // callback again.
+            callback: null,
+            next: null
+          };
+
+          if (newLast === null) {
+            newFirst = newLast = clone;
+          } else {
+            newLast.next = clone;
+            newLast = clone;
+          } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+          update = update.next;
+        } while (update !== null); // Append the captured update the end of the cloned list.
+
+
+        if (newLast === null) {
+          newFirst = newLast = capturedUpdate;
+        } else {
+          newLast.next = capturedUpdate;
+          newLast = capturedUpdate;
+        }
+      } else {
+        // There are no base updates.
+        newFirst = newLast = capturedUpdate;
+      }
+
+      queue = {
+        baseState: currentQueue.baseState,
+        firstBaseUpdate: newFirst,
+        lastBaseUpdate: newLast,
+        shared: currentQueue.shared,
+        callbacks: currentQueue.callbacks
+      };
+      workInProgress.updateQueue = queue;
+      return;
+    }
+  } // Append the update to the end of the list.
+
+
+  const lastBaseUpdate = queue.lastBaseUpdate;
+
+  if (lastBaseUpdate === null) {
+    queue.firstBaseUpdate = capturedUpdate;
+  } else {
+    lastBaseUpdate.next = capturedUpdate;
+  }
+
+  queue.lastBaseUpdate = capturedUpdate;
+}
+
+function getStateFromUpdate(workInProgress, queue, update, prevState, nextProps, instance) {
+  switch (update.tag) {
+    case ReplaceState:
+      {
+        const payload = update.payload;
+
+        if (typeof payload === 'function') {
+
+          const nextState = payload.call(instance, prevState, nextProps);
+
+          return nextState;
+        } // State object
+
+
+        return payload;
+      }
+
+    case CaptureUpdate:
+      {
+        workInProgress.flags = workInProgress.flags & ~ShouldCapture | DidCapture;
+      }
+    // Intentional fallthrough
+
+    case UpdateState:
+      {
+        const payload = update.payload;
+        let partialState;
+
+        if (typeof payload === 'function') {
+
+          partialState = payload.call(instance, prevState, nextProps);
+        } else {
+          // Partial state object
+          partialState = payload;
+        }
+
+        if (partialState === null || partialState === undefined) {
+          // Null and undefined are treated as no-ops.
+          return prevState;
+        } // Merge the partial state and the previous state.
+
+
+        return assign({}, prevState, partialState);
+      }
+
+    case ForceUpdate:
+      {
+        hasForceUpdate = true;
+        return prevState;
+      }
+  }
+
+  return prevState;
+}
+
+function processUpdateQueue(workInProgress, props, instance, renderLanes) {
+  // This is always non-null on a ClassComponent or HostRoot
+  const queue = workInProgress.updateQueue;
+  hasForceUpdate = false;
+
+  let firstBaseUpdate = queue.firstBaseUpdate;
+  let lastBaseUpdate = queue.lastBaseUpdate; // Check if there are pending updates. If so, transfer them to the base queue.
+
+  let pendingQueue = queue.shared.pending;
+
+  if (pendingQueue !== null) {
+    queue.shared.pending = null; // The pending queue is circular. Disconnect the pointer between first
+    // and last so that it's non-circular.
+
+    const lastPendingUpdate = pendingQueue;
+    const firstPendingUpdate = lastPendingUpdate.next;
+    lastPendingUpdate.next = null; // Append pending updates to base queue
+
+    if (lastBaseUpdate === null) {
+      firstBaseUpdate = firstPendingUpdate;
+    } else {
+      lastBaseUpdate.next = firstPendingUpdate;
+    }
+
+    lastBaseUpdate = lastPendingUpdate; // If there's a current queue, and it's different from the base queue, then
+    // we need to transfer the updates to that queue, too. Because the base
+    // queue is a singly-linked list with no cycles, we can append to both
+    // lists and take advantage of structural sharing.
+    // TODO: Pass `current` as argument
+
+    const current = workInProgress.alternate;
+
+    if (current !== null) {
+      // This is always non-null on a ClassComponent or HostRoot
+      const currentQueue = current.updateQueue;
+      const currentLastBaseUpdate = currentQueue.lastBaseUpdate;
+
+      if (currentLastBaseUpdate !== lastBaseUpdate) {
+        if (currentLastBaseUpdate === null) {
+          currentQueue.firstBaseUpdate = firstPendingUpdate;
+        } else {
+          currentLastBaseUpdate.next = firstPendingUpdate;
+        }
+
+        currentQueue.lastBaseUpdate = lastPendingUpdate;
+      }
+    }
+  } // These values may change as we process the queue.
+
+
+  if (firstBaseUpdate !== null) {
+    // Iterate through the list of updates to compute the result.
+    let newState = queue.baseState; // TODO: Don't need to accumulate this. Instead, we can remove renderLanes
+    // from the original lanes.
+
+    let newLanes = NoLanes;
+    let newBaseState = null;
+    let newFirstBaseUpdate = null;
+    let newLastBaseUpdate = null;
+    let update = firstBaseUpdate;
+
+    do {
+      // An extra OffscreenLane bit is added to updates that were made to
+      // a hidden tree, so that we can distinguish them from updates that were
+      // already there when the tree was hidden.
+      const updateLane = removeLanes(update.lane, OffscreenLane);
+      const isHiddenUpdate = updateLane !== update.lane; // Check if this update was made while the tree was hidden. If so, then
+      // it's not a "base" update and we should disregard the extra base lanes
+      // that were added to renderLanes when we entered the Offscreen tree.
+
+      const shouldSkipUpdate = isHiddenUpdate ? !isSubsetOfLanes(getWorkInProgressRootRenderLanes(), updateLane) : !isSubsetOfLanes(renderLanes, updateLane);
+
+      if (shouldSkipUpdate) {
+        // Priority is insufficient. Skip this update. If this is the first
+        // skipped update, the previous update/state is the new base
+        // update/state.
+        const clone = {
+          lane: updateLane,
+          tag: update.tag,
+          payload: update.payload,
+          callback: update.callback,
+          next: null
+        };
+
+        if (newLastBaseUpdate === null) {
+          newFirstBaseUpdate = newLastBaseUpdate = clone;
+          newBaseState = newState;
+        } else {
+          newLastBaseUpdate = newLastBaseUpdate.next = clone;
+        } // Update the remaining priority in the queue.
+
+
+        newLanes = mergeLanes(newLanes, updateLane);
+      } else {
+        // This update does have sufficient priority.
+        if (newLastBaseUpdate !== null) {
+          const clone = {
+            // This update is going to be committed so we never want uncommit
+            // it. Using NoLane works because 0 is a subset of all bitmasks, so
+            // this will never be skipped by the check above.
+            lane: NoLane,
+            tag: update.tag,
+            payload: update.payload,
+            // When this update is rebased, we should not fire its
+            // callback again.
+            callback: null,
+            next: null
+          };
+          newLastBaseUpdate = newLastBaseUpdate.next = clone;
+        } // Process this update.
+
+
+        newState = getStateFromUpdate(workInProgress, queue, update, newState, props, instance);
+        const callback = update.callback;
+
+        if (callback !== null) {
+          workInProgress.flags |= Callback;
+
+          if (isHiddenUpdate) {
+            workInProgress.flags |= Visibility;
+          }
+
+          const callbacks = queue.callbacks;
+
+          if (callbacks === null) {
+            queue.callbacks = [callback];
+          } else {
+            callbacks.push(callback);
+          }
+        }
+      } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+      update = update.next;
+
+      if (update === null) {
+        pendingQueue = queue.shared.pending;
+
+        if (pendingQueue === null) {
+          break;
+        } else {
+          // An update was scheduled from inside a reducer. Add the new
+          // pending updates to the end of the list and keep processing.
+          const lastPendingUpdate = pendingQueue; // Intentionally unsound. Pending updates form a circular list, but we
+          // unravel them when transferring them to the base queue.
+
+          const firstPendingUpdate = lastPendingUpdate.next;
+          lastPendingUpdate.next = null;
+          update = firstPendingUpdate;
+          queue.lastBaseUpdate = lastPendingUpdate;
+          queue.shared.pending = null;
+        }
+      }
+    } while (true);
+
+    if (newLastBaseUpdate === null) {
+      newBaseState = newState;
+    }
+
+    queue.baseState = newBaseState;
+    queue.firstBaseUpdate = newFirstBaseUpdate;
+    queue.lastBaseUpdate = newLastBaseUpdate;
+
+    if (firstBaseUpdate === null) {
+      // `queue.lanes` is used for entangling transitions. We can set it back to
+      // zero once the queue is empty.
+      queue.shared.lanes = NoLanes;
+    } // Set the remaining expiration time to be whatever is remaining in the queue.
+    // This should be fine because the only two other things that contribute to
+    // expiration time are props and context. We're already in the middle of the
+    // begin phase by the time we start processing the queue, so we've already
+    // dealt with the props. Context in components that specify
+    // shouldComponentUpdate is tricky; but we'll have to account for
+    // that regardless.
+
+
+    markSkippedUpdateLanes(newLanes);
+    workInProgress.lanes = newLanes;
+    workInProgress.memoizedState = newState;
+  }
+}
+
+function callCallback(callback, context) {
+  if (typeof callback !== 'function') {
+    throw Error(formatProdErrorMessage(191, callback));
+  }
+
+  callback.call(context);
+}
+
+function resetHasForceUpdateBeforeProcessing() {
+  hasForceUpdate = false;
+}
+function checkHasForceUpdateAfterProcessing() {
+  return hasForceUpdate;
+}
+function deferHiddenCallbacks(updateQueue) {
+  // When an update finishes on a hidden component, its callback should not
+  // be fired until/unless the component is made visible again. Stash the
+  // callback on the shared queue object so it can be fired later.
+  const newHiddenCallbacks = updateQueue.callbacks;
+
+  if (newHiddenCallbacks !== null) {
+    const existingHiddenCallbacks = updateQueue.shared.hiddenCallbacks;
+
+    if (existingHiddenCallbacks === null) {
+      updateQueue.shared.hiddenCallbacks = newHiddenCallbacks;
+    } else {
+      updateQueue.shared.hiddenCallbacks = existingHiddenCallbacks.concat(newHiddenCallbacks);
+    }
+  }
+}
+function commitHiddenCallbacks(updateQueue, context) {
+  // This component is switching from hidden -> visible. Commit any callbacks
+  // that were previously deferred.
+  const hiddenCallbacks = updateQueue.shared.hiddenCallbacks;
+
+  if (hiddenCallbacks !== null) {
+    updateQueue.shared.hiddenCallbacks = null;
+
+    for (let i = 0; i < hiddenCallbacks.length; i++) {
+      const callback = hiddenCallbacks[i];
+      callCallback(callback, context);
+    }
+  }
+}
+function commitCallbacks(updateQueue, context) {
+  const callbacks = updateQueue.callbacks;
+
+  if (callbacks !== null) {
+    updateQueue.callbacks = null;
+
+    for (let i = 0; i < callbacks.length; i++) {
+      const callback = callbacks[i];
+      callCallback(callback, context);
+    }
+  }
+}
+
+/**
+ * Performs equality by iterating through keys on an object and returning false
+ * when any key has values which are not strictly equal between the arguments.
+ * Returns true when the values of all keys are strictly equal.
+ */
+
+function shallowEqual(objA, objB) {
+  if (objectIs(objA, objB)) {
+    return true;
+  }
+
+  if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
+    return false;
+  }
+
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+
+  if (keysA.length !== keysB.length) {
+    return false;
+  } // Test for A's keys different from B.
+
+
+  for (let i = 0; i < keysA.length; i++) {
+    const currentKey = keysA[i];
+
+    if (!hasOwnProperty.call(objB, currentKey) || // $FlowFixMe[incompatible-use] lost refinement of `objB`
+    !objectIs(objA[currentKey], objB[currentKey])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+// detect this is caught by userspace, we'll log a warning in development.
+
+const SuspenseException = Error(formatProdErrorMessage(460));
+const SuspenseyCommitException = Error(formatProdErrorMessage(474)); // This is a noop thenable that we use to trigger a fallback in throwException.
+// TODO: It would be better to refactor throwException into multiple functions
+// so we can trigger a fallback directly without having to check the type. But
+// for now this will do.
+
+const noopSuspenseyCommitThenable = {
+  then() {
+  }
+
+};
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+function isThenableResolved(thenable) {
+  const status = thenable.status;
+  return status === 'fulfilled' || status === 'rejected';
+}
+
+function noop$2() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop$2, noop$2);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        checkIfUseWrappedInAsyncCatch(rejectedError);
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          // Attach a dummy listener, to ensure that any lazy initialization can
+          // happen. Flight lazily parses JSON when the value is actually awaited.
+          thenable.then(noop$2, noop$2);
+        } else {
+          // This is an uncached thenable that we haven't seen before.
+          // Detect infinite ping loops caused by uncached promises.
+          const root = getWorkInProgressRoot();
+
+          if (root !== null && root.shellSuspendCounter > 100) {
+            // This root has suspended repeatedly in the shell without making any
+            // progress (i.e. committing something). This is highly suggestive of
+            // an infinite ping loop, often caused by an accidental Async Client
+            // Component.
+            //
+            // During a transition, we can suspend the work loop until the promise
+            // to resolve, but this is a sync render, so that's not an option. We
+            // also can't show a fallback, because none was provided. So our last
+            // resort is to throw an error.
+            //
+            // TODO: Remove this error in a future release. Other ways of handling
+            // this case include forcing a concurrent render, or putting the whole
+            // root into offscreen mode.
+            throw Error(formatProdErrorMessage(482));
+          }
+
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously.
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                const rejectedError = rejectedThenable.reason;
+                checkIfUseWrappedInAsyncCatch(rejectedError);
+                throw rejectedError;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+
+        throw SuspenseException;
+      }
+  }
+}
+function suspendCommit() {
+  // This extra indirection only exists so it can handle passing
+  // noopSuspenseyCommitThenable through to throwException.
+  // TODO: Factor the thenable check out of throwException
+  suspendedThenable = noopSuspenseyCommitThenable;
+  throw SuspenseyCommitException;
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw Error(formatProdErrorMessage(459));
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+
+  return thenable;
+}
+function checkIfUseWrappedInAsyncCatch(rejectedReason) {
+  // This check runs in prod, too, because it prevents a more confusing
+  // downstream error, where SuspenseException is caught by a promise and
+  // thrown asynchronously.
+  // TODO: Another way to prevent SuspenseException from leaking into an async
+  // execution context is to check the dispatcher every time `use` is called,
+  // or some equivalent. That might be preferable for other reasons, too, since
+  // it matches how we prevent similar mistakes for other hooks.
+  if (rejectedReason === SuspenseException) {
+    throw Error(formatProdErrorMessage(483));
+  }
+}
+
+let thenableState$1 = null;
+let thenableIndexCounter$1 = 0;
+
+function unwrapThenable(thenable) {
+  const index = thenableIndexCounter$1;
+  thenableIndexCounter$1 += 1;
+
+  if (thenableState$1 === null) {
+    thenableState$1 = createThenableState();
+  }
+
+  return trackUsedThenable(thenableState$1, thenable, index);
+}
+
+function coerceRef(returnFiber, current, element) {
+  const mixedRef = element.ref;
+
+  if (mixedRef !== null && typeof mixedRef !== 'function' && typeof mixedRef !== 'object') {
+
+    if (element._owner) {
+      const owner = element._owner;
+      let inst;
+
+      if (owner) {
+        const ownerFiber = owner;
+
+        if (ownerFiber.tag !== ClassComponent) {
+          throw Error(formatProdErrorMessage(309));
+        }
+
+        inst = ownerFiber.stateNode;
+      }
+
+      if (!inst) {
+        throw Error(formatProdErrorMessage(147, mixedRef));
+      } // Assigning this to a const so Flow knows it won't change in the closure
+
+
+      const resolvedInst = inst;
+
+      const stringRef = '' + mixedRef; // Check if previous string ref matches new string ref
+
+      if (current !== null && current.ref !== null && typeof current.ref === 'function' && current.ref._stringRef === stringRef) {
+        return current.ref;
+      }
+
+      const ref = function (value) {
+        const refs = resolvedInst.refs;
+
+        if (value === null) {
+          delete refs[stringRef];
+        } else {
+          refs[stringRef] = value;
+        }
+      };
+
+      ref._stringRef = stringRef;
+      return ref;
+    } else {
+      if (typeof mixedRef !== 'string') {
+        throw Error(formatProdErrorMessage(284));
+      }
+
+      if (!element._owner) {
+        throw Error(formatProdErrorMessage(290, mixedRef));
+      }
+    }
+  }
+
+  return mixedRef;
+}
+
+function throwOnInvalidObjectType(returnFiber, newChild) {
+  // $FlowFixMe[method-unbinding]
+  const childString = Object.prototype.toString.call(newChild);
+  throw Error(formatProdErrorMessage(31, childString === '[object Object]' ? 'object with keys {' + Object.keys(newChild).join(', ') + '}' : childString));
+}
+
+function resolveLazy(lazyType) {
+  const payload = lazyType._payload;
+  const init = lazyType._init;
+  return init(payload);
+} // This wrapper function exists because I expect to clone the code in each path
+// to be able to optimize each path individually by branching early. This needs
+// a compiler or we can do it manually. Helpers that don't need this branching
+// live outside of this function.
+
+
+function createChildReconciler(shouldTrackSideEffects) {
+  function deleteChild(returnFiber, childToDelete) {
+    if (!shouldTrackSideEffects) {
+      // Noop.
+      return;
+    }
+
+    const deletions = returnFiber.deletions;
+
+    if (deletions === null) {
+      returnFiber.deletions = [childToDelete];
+      returnFiber.flags |= ChildDeletion;
+    } else {
+      deletions.push(childToDelete);
+    }
+  }
+
+  function deleteRemainingChildren(returnFiber, currentFirstChild) {
+    if (!shouldTrackSideEffects) {
+      // Noop.
+      return null;
+    } // TODO: For the shouldClone case, this could be micro-optimized a bit by
+    // assuming that after the first child we've already added everything.
+
+
+    let childToDelete = currentFirstChild;
+
+    while (childToDelete !== null) {
+      deleteChild(returnFiber, childToDelete);
+      childToDelete = childToDelete.sibling;
+    }
+
+    return null;
+  }
+
+  function mapRemainingChildren(returnFiber, currentFirstChild) {
+    // Add the remaining children to a temporary map so that we can find them by
+    // keys quickly. Implicit (null) keys get added to this set with their index
+    // instead.
+    const existingChildren = new Map();
+    let existingChild = currentFirstChild;
+
+    while (existingChild !== null) {
+      if (existingChild.key !== null) {
+        existingChildren.set(existingChild.key, existingChild);
+      } else {
+        existingChildren.set(existingChild.index, existingChild);
+      }
+
+      existingChild = existingChild.sibling;
+    }
+
+    return existingChildren;
+  }
+
+  function useFiber(fiber, pendingProps) {
+    // We currently set sibling to null and index to 0 here because it is easy
+    // to forget to do before returning it. E.g. for the single child case.
+    const clone = createWorkInProgress(fiber, pendingProps);
+    clone.index = 0;
+    clone.sibling = null;
+    return clone;
+  }
+
+  function placeChild(newFiber, lastPlacedIndex, newIndex) {
+    newFiber.index = newIndex;
+
+    if (!shouldTrackSideEffects) {
+      // During hydration, the useId algorithm needs to know which fibers are
+      // part of a list of children (arrays, iterators).
+      newFiber.flags |= Forked;
+      return lastPlacedIndex;
+    }
+
+    const current = newFiber.alternate;
+
+    if (current !== null) {
+      const oldIndex = current.index;
+
+      if (oldIndex < lastPlacedIndex) {
+        // This is a move.
+        newFiber.flags |= Placement | PlacementDEV;
+        return lastPlacedIndex;
+      } else {
+        // This item can stay in place.
+        return oldIndex;
+      }
+    } else {
+      // This is an insertion.
+      newFiber.flags |= Placement | PlacementDEV;
+      return lastPlacedIndex;
+    }
+  }
+
+  function placeSingleChild(newFiber) {
+    // This is simpler for the single child case. We only need to do a
+    // placement for inserting new children.
+    if (shouldTrackSideEffects && newFiber.alternate === null) {
+      newFiber.flags |= Placement | PlacementDEV;
+    }
+
+    return newFiber;
+  }
+
+  function updateTextNode(returnFiber, current, textContent, lanes) {
+    if (current === null || current.tag !== HostText) {
+      // Insert
+      const created = createFiberFromText(textContent, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      const existing = useFiber(current, textContent);
+      existing.return = returnFiber;
+      return existing;
+    }
+  }
+
+  function updateElement(returnFiber, current, element, lanes) {
+    const elementType = element.type;
+
+    if (elementType === REACT_FRAGMENT_TYPE) {
+      return updateFragment(returnFiber, current, element.props.children, lanes, element.key);
+    }
+
+    if (current !== null) {
+      if (current.elementType === elementType || ( // Keep this check inline so it only runs on the false path:
+      false) || // Lazy types should reconcile their resolved type.
+      // We need to do this after the Hot Reloading check above,
+      // because hot reloading has different semantics than prod because
+      // it doesn't resuspend. So we can't let the call below suspend.
+      typeof elementType === 'object' && elementType !== null && elementType.$$typeof === REACT_LAZY_TYPE && resolveLazy(elementType) === current.type) {
+        // Move based on index
+        const existing = useFiber(current, element.props);
+        existing.ref = coerceRef(returnFiber, current, element);
+        existing.return = returnFiber;
+
+        return existing;
+      }
+    } // Insert
+
+
+    const created = createFiberFromElement(element, returnFiber.mode, lanes);
+    created.ref = coerceRef(returnFiber, current, element);
+    created.return = returnFiber;
+    return created;
+  }
+
+  function updatePortal(returnFiber, current, portal, lanes) {
+    if (current === null || current.tag !== HostPortal || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation) {
+      // Insert
+      const created = createFiberFromPortal(portal, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      const existing = useFiber(current, portal.children || []);
+      existing.return = returnFiber;
+      return existing;
+    }
+  }
+
+  function updateFragment(returnFiber, current, fragment, lanes, key) {
+    if (current === null || current.tag !== Fragment) {
+      // Insert
+      const created = createFiberFromFragment(fragment, returnFiber.mode, lanes, key);
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      const existing = useFiber(current, fragment);
+      existing.return = returnFiber;
+      return existing;
+    }
+  }
+
+  function createChild(returnFiber, newChild, lanes) {
+    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {
+      // Text nodes don't have keys. If the previous node is implicitly keyed
+      // we can continue to replace it without aborting even if it is not a text
+      // node.
+      const created = createFiberFromText('' + newChild, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    }
+
+    if (typeof newChild === 'object' && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const created = createFiberFromElement(newChild, returnFiber.mode, lanes);
+            created.ref = coerceRef(returnFiber, null, newChild);
+            created.return = returnFiber;
+            return created;
+          }
+
+        case REACT_PORTAL_TYPE:
+          {
+            const created = createFiberFromPortal(newChild, returnFiber.mode, lanes);
+            created.return = returnFiber;
+            return created;
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = newChild._payload;
+            const init = newChild._init;
+            return createChild(returnFiber, init(payload), lanes);
+          }
+      }
+
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        const created = createFiberFromFragment(newChild, returnFiber.mode, lanes, null);
+        created.return = returnFiber;
+        return created;
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
+
+
+      if (typeof newChild.then === 'function') {
+        const thenable = newChild;
+        return createChild(returnFiber, unwrapThenable(thenable), lanes);
+      }
+
+      if (newChild.$$typeof === REACT_CONTEXT_TYPE || newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+        const context = newChild;
+        return createChild(returnFiber, readContextDuringReconcilation(returnFiber, context, lanes), lanes);
+      }
+
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+
+    return null;
+  }
+
+  function updateSlot(returnFiber, oldFiber, newChild, lanes) {
+    // Update the fiber if the keys match, otherwise return null.
+    const key = oldFiber !== null ? oldFiber.key : null;
+
+    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {
+      // Text nodes don't have keys. If the previous node is implicitly keyed
+      // we can continue to replace it without aborting even if it is not a text
+      // node.
+      if (key !== null) {
+        return null;
+      }
+
+      return updateTextNode(returnFiber, oldFiber, '' + newChild, lanes);
+    }
+
+    if (typeof newChild === 'object' && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            if (newChild.key === key) {
+              return updateElement(returnFiber, oldFiber, newChild, lanes);
+            } else {
+              return null;
+            }
+          }
+
+        case REACT_PORTAL_TYPE:
+          {
+            if (newChild.key === key) {
+              return updatePortal(returnFiber, oldFiber, newChild, lanes);
+            } else {
+              return null;
+            }
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = newChild._payload;
+            const init = newChild._init;
+            return updateSlot(returnFiber, oldFiber, init(payload), lanes);
+          }
+      }
+
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        if (key !== null) {
+          return null;
+        }
+
+        return updateFragment(returnFiber, oldFiber, newChild, lanes, null);
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
+
+
+      if (typeof newChild.then === 'function') {
+        const thenable = newChild;
+        return updateSlot(returnFiber, oldFiber, unwrapThenable(thenable), lanes);
+      }
+
+      if (newChild.$$typeof === REACT_CONTEXT_TYPE || newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+        const context = newChild;
+        return updateSlot(returnFiber, oldFiber, readContextDuringReconcilation(returnFiber, context, lanes), lanes);
+      }
+
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+
+    return null;
+  }
+
+  function updateFromMap(existingChildren, returnFiber, newIdx, newChild, lanes) {
+    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {
+      // Text nodes don't have keys, so we neither have to check the old nor
+      // new node for the key. If both are text nodes, they match.
+      const matchedFiber = existingChildren.get(newIdx) || null;
+      return updateTextNode(returnFiber, matchedFiber, '' + newChild, lanes);
+    }
+
+    if (typeof newChild === 'object' && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const matchedFiber = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;
+            return updateElement(returnFiber, matchedFiber, newChild, lanes);
+          }
+
+        case REACT_PORTAL_TYPE:
+          {
+            const matchedFiber = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;
+            return updatePortal(returnFiber, matchedFiber, newChild, lanes);
+          }
+
+        case REACT_LAZY_TYPE:
+          const payload = newChild._payload;
+          const init = newChild._init;
+          return updateFromMap(existingChildren, returnFiber, newIdx, init(payload), lanes);
+      }
+
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        const matchedFiber = existingChildren.get(newIdx) || null;
+        return updateFragment(returnFiber, matchedFiber, newChild, lanes, null);
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
+
+
+      if (typeof newChild.then === 'function') {
+        const thenable = newChild;
+        return updateFromMap(existingChildren, returnFiber, newIdx, unwrapThenable(thenable), lanes);
+      }
+
+      if (newChild.$$typeof === REACT_CONTEXT_TYPE || newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+        const context = newChild;
+        return updateFromMap(existingChildren, returnFiber, newIdx, readContextDuringReconcilation(returnFiber, context, lanes), lanes);
+      }
+
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+
+    return null;
+  }
+
+  function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, lanes) {
+
+    let resultingFirstChild = null;
+    let previousNewFiber = null;
+    let oldFiber = currentFirstChild;
+    let lastPlacedIndex = 0;
+    let newIdx = 0;
+    let nextOldFiber = null;
+
+    for (; oldFiber !== null && newIdx < newChildren.length; newIdx++) {
+      if (oldFiber.index > newIdx) {
+        nextOldFiber = oldFiber;
+        oldFiber = null;
+      } else {
+        nextOldFiber = oldFiber.sibling;
+      }
+
+      const newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], lanes);
+
+      if (newFiber === null) {
+        // TODO: This breaks on empty slots like null children. That's
+        // unfortunate because it triggers the slow path all the time. We need
+        // a better way to communicate whether this was a miss or null,
+        // boolean, undefined, etc.
+        if (oldFiber === null) {
+          oldFiber = nextOldFiber;
+        }
+
+        break;
+      }
+
+      if (shouldTrackSideEffects) {
+        if (oldFiber && newFiber.alternate === null) {
+          // We matched the slot, but we didn't reuse the existing fiber, so we
+          // need to delete the existing child.
+          deleteChild(returnFiber, oldFiber);
+        }
+      }
+
+      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+      if (previousNewFiber === null) {
+        // TODO: Move out of the loop. This only happens for the first run.
+        resultingFirstChild = newFiber;
+      } else {
+        // TODO: Defer siblings if we're not at the right index for this slot.
+        // I.e. if we had null values before, then we want to defer this
+        // for each null value. However, we also don't want to call updateSlot
+        // with the previous one.
+        previousNewFiber.sibling = newFiber;
+      }
+
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
+    }
+
+    if (newIdx === newChildren.length) {
+      // We've reached the end of the new children. We can delete the rest.
+      deleteRemainingChildren(returnFiber, oldFiber);
+
+      if (getIsHydrating()) {
+        const numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
+
+      return resultingFirstChild;
+    }
+
+    if (oldFiber === null) {
+      // If we don't have any more existing children we can choose a fast path
+      // since the rest will all be insertions.
+      for (; newIdx < newChildren.length; newIdx++) {
+        const newFiber = createChild(returnFiber, newChildren[newIdx], lanes);
+
+        if (newFiber === null) {
+          continue;
+        }
+
+        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          // TODO: Move out of the loop. This only happens for the first run.
+          resultingFirstChild = newFiber;
+        } else {
+          previousNewFiber.sibling = newFiber;
+        }
+
+        previousNewFiber = newFiber;
+      }
+
+      if (getIsHydrating()) {
+        const numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
+
+      return resultingFirstChild;
+    } // Add all children to a key map for quick lookups.
+
+
+    const existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
+
+    for (; newIdx < newChildren.length; newIdx++) {
+      const newFiber = updateFromMap(existingChildren, returnFiber, newIdx, newChildren[newIdx], lanes);
+
+      if (newFiber !== null) {
+        if (shouldTrackSideEffects) {
+          if (newFiber.alternate !== null) {
+            // The new fiber is a work in progress, but if there exists a
+            // current, that means that we reused the fiber. We need to delete
+            // it from the child list so that we don't add it to the deletion
+            // list.
+            existingChildren.delete(newFiber.key === null ? newIdx : newFiber.key);
+          }
+        }
+
+        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          resultingFirstChild = newFiber;
+        } else {
+          previousNewFiber.sibling = newFiber;
+        }
+
+        previousNewFiber = newFiber;
+      }
+    }
+
+    if (shouldTrackSideEffects) {
+      // Any existing children that weren't consumed above were deleted. We need
+      // to add them to the deletion list.
+      existingChildren.forEach(child => deleteChild(returnFiber, child));
+    }
+
+    if (getIsHydrating()) {
+      const numberOfForks = newIdx;
+      pushTreeFork(returnFiber, numberOfForks);
+    }
+
+    return resultingFirstChild;
+  }
+
+  function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildrenIterable, lanes) {
+    // This is the same implementation as reconcileChildrenArray(),
+    // but using the iterator instead.
+    const iteratorFn = getIteratorFn(newChildrenIterable);
+
+    if (typeof iteratorFn !== 'function') {
+      throw Error(formatProdErrorMessage(150));
+    }
+
+    const newChildren = iteratorFn.call(newChildrenIterable);
+
+    if (newChildren == null) {
+      throw Error(formatProdErrorMessage(151));
+    }
+
+    let resultingFirstChild = null;
+    let previousNewFiber = null;
+    let oldFiber = currentFirstChild;
+    let lastPlacedIndex = 0;
+    let newIdx = 0;
+    let nextOldFiber = null;
+    let step = newChildren.next();
+
+    for (; oldFiber !== null && !step.done; newIdx++, step = newChildren.next()) {
+      if (oldFiber.index > newIdx) {
+        nextOldFiber = oldFiber;
+        oldFiber = null;
+      } else {
+        nextOldFiber = oldFiber.sibling;
+      }
+
+      const newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
+
+      if (newFiber === null) {
+        // TODO: This breaks on empty slots like null children. That's
+        // unfortunate because it triggers the slow path all the time. We need
+        // a better way to communicate whether this was a miss or null,
+        // boolean, undefined, etc.
+        if (oldFiber === null) {
+          oldFiber = nextOldFiber;
+        }
+
+        break;
+      }
+
+      if (shouldTrackSideEffects) {
+        if (oldFiber && newFiber.alternate === null) {
+          // We matched the slot, but we didn't reuse the existing fiber, so we
+          // need to delete the existing child.
+          deleteChild(returnFiber, oldFiber);
+        }
+      }
+
+      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+      if (previousNewFiber === null) {
+        // TODO: Move out of the loop. This only happens for the first run.
+        resultingFirstChild = newFiber;
+      } else {
+        // TODO: Defer siblings if we're not at the right index for this slot.
+        // I.e. if we had null values before, then we want to defer this
+        // for each null value. However, we also don't want to call updateSlot
+        // with the previous one.
+        previousNewFiber.sibling = newFiber;
+      }
+
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
+    }
+
+    if (step.done) {
+      // We've reached the end of the new children. We can delete the rest.
+      deleteRemainingChildren(returnFiber, oldFiber);
+
+      if (getIsHydrating()) {
+        const numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
+
+      return resultingFirstChild;
+    }
+
+    if (oldFiber === null) {
+      // If we don't have any more existing children we can choose a fast path
+      // since the rest will all be insertions.
+      for (; !step.done; newIdx++, step = newChildren.next()) {
+        const newFiber = createChild(returnFiber, step.value, lanes);
+
+        if (newFiber === null) {
+          continue;
+        }
+
+        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          // TODO: Move out of the loop. This only happens for the first run.
+          resultingFirstChild = newFiber;
+        } else {
+          previousNewFiber.sibling = newFiber;
+        }
+
+        previousNewFiber = newFiber;
+      }
+
+      if (getIsHydrating()) {
+        const numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
+
+      return resultingFirstChild;
+    } // Add all children to a key map for quick lookups.
+
+
+    const existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
+
+    for (; !step.done; newIdx++, step = newChildren.next()) {
+      const newFiber = updateFromMap(existingChildren, returnFiber, newIdx, step.value, lanes);
+
+      if (newFiber !== null) {
+        if (shouldTrackSideEffects) {
+          if (newFiber.alternate !== null) {
+            // The new fiber is a work in progress, but if there exists a
+            // current, that means that we reused the fiber. We need to delete
+            // it from the child list so that we don't add it to the deletion
+            // list.
+            existingChildren.delete(newFiber.key === null ? newIdx : newFiber.key);
+          }
+        }
+
+        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          resultingFirstChild = newFiber;
+        } else {
+          previousNewFiber.sibling = newFiber;
+        }
+
+        previousNewFiber = newFiber;
+      }
+    }
+
+    if (shouldTrackSideEffects) {
+      // Any existing children that weren't consumed above were deleted. We need
+      // to add them to the deletion list.
+      existingChildren.forEach(child => deleteChild(returnFiber, child));
+    }
+
+    if (getIsHydrating()) {
+      const numberOfForks = newIdx;
+      pushTreeFork(returnFiber, numberOfForks);
+    }
+
+    return resultingFirstChild;
+  }
+
+  function reconcileSingleTextNode(returnFiber, currentFirstChild, textContent, lanes) {
+    // There's no need to check for keys on text nodes since we don't have a
+    // way to define them.
+    if (currentFirstChild !== null && currentFirstChild.tag === HostText) {
+      // We already have an existing node so let's just update it and delete
+      // the rest.
+      deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+      const existing = useFiber(currentFirstChild, textContent);
+      existing.return = returnFiber;
+      return existing;
+    } // The existing first child is not a text node so we need to create one
+    // and delete the existing ones.
+
+
+    deleteRemainingChildren(returnFiber, currentFirstChild);
+    const created = createFiberFromText(textContent, returnFiber.mode, lanes);
+    created.return = returnFiber;
+    return created;
+  }
+
+  function reconcileSingleElement(returnFiber, currentFirstChild, element, lanes) {
+    const key = element.key;
+    let child = currentFirstChild;
+
+    while (child !== null) {
+      // TODO: If key === null and child.key === null, then this only applies to
+      // the first item in the list.
+      if (child.key === key) {
+        const elementType = element.type;
+
+        if (elementType === REACT_FRAGMENT_TYPE) {
+          if (child.tag === Fragment) {
+            deleteRemainingChildren(returnFiber, child.sibling);
+            const existing = useFiber(child, element.props.children);
+            existing.return = returnFiber;
+
+            return existing;
+          }
+        } else {
+          if (child.elementType === elementType || ( // Keep this check inline so it only runs on the false path:
+          false) || // Lazy types should reconcile their resolved type.
+          // We need to do this after the Hot Reloading check above,
+          // because hot reloading has different semantics than prod because
+          // it doesn't resuspend. So we can't let the call below suspend.
+          typeof elementType === 'object' && elementType !== null && elementType.$$typeof === REACT_LAZY_TYPE && resolveLazy(elementType) === child.type) {
+            deleteRemainingChildren(returnFiber, child.sibling);
+            const existing = useFiber(child, element.props);
+            existing.ref = coerceRef(returnFiber, child, element);
+            existing.return = returnFiber;
+
+            return existing;
+          }
+        } // Didn't match.
+
+
+        deleteRemainingChildren(returnFiber, child);
+        break;
+      } else {
+        deleteChild(returnFiber, child);
+      }
+
+      child = child.sibling;
+    }
+
+    if (element.type === REACT_FRAGMENT_TYPE) {
+      const created = createFiberFromFragment(element.props.children, returnFiber.mode, lanes, element.key);
+      created.return = returnFiber;
+      return created;
+    } else {
+      const created = createFiberFromElement(element, returnFiber.mode, lanes);
+      created.ref = coerceRef(returnFiber, currentFirstChild, element);
+      created.return = returnFiber;
+      return created;
+    }
+  }
+
+  function reconcileSinglePortal(returnFiber, currentFirstChild, portal, lanes) {
+    const key = portal.key;
+    let child = currentFirstChild;
+
+    while (child !== null) {
+      // TODO: If key === null and child.key === null, then this only applies to
+      // the first item in the list.
+      if (child.key === key) {
+        if (child.tag === HostPortal && child.stateNode.containerInfo === portal.containerInfo && child.stateNode.implementation === portal.implementation) {
+          deleteRemainingChildren(returnFiber, child.sibling);
+          const existing = useFiber(child, portal.children || []);
+          existing.return = returnFiber;
+          return existing;
+        } else {
+          deleteRemainingChildren(returnFiber, child);
+          break;
+        }
+      } else {
+        deleteChild(returnFiber, child);
+      }
+
+      child = child.sibling;
+    }
+
+    const created = createFiberFromPortal(portal, returnFiber.mode, lanes);
+    created.return = returnFiber;
+    return created;
+  } // This API will tag the children with the side-effect of the reconciliation
+  // itself. They will be added to the side-effect list as we pass through the
+  // children and the parent.
+
+
+  function reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes) {
+    // This function is not recursive.
+    // If the top level item is an array, we treat it as a set of children,
+    // not as a fragment. Nested arrays on the other hand will be treated as
+    // fragment nodes. Recursion happens at the normal flow.
+    // Handle top level unkeyed fragments as if they were arrays.
+    // This leads to an ambiguity between <>{[...]}</> and <>...</>.
+    // We treat the ambiguous cases above the same.
+    // TODO: Let's use recursion like we do for Usable nodes?
+    const isUnkeyedTopLevelFragment = typeof newChild === 'object' && newChild !== null && newChild.type === REACT_FRAGMENT_TYPE && newChild.key === null;
+
+    if (isUnkeyedTopLevelFragment) {
+      newChild = newChild.props.children;
+    } // Handle object types
+
+
+    if (typeof newChild === 'object' && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          return placeSingleChild(reconcileSingleElement(returnFiber, currentFirstChild, newChild, lanes));
+
+        case REACT_PORTAL_TYPE:
+          return placeSingleChild(reconcileSinglePortal(returnFiber, currentFirstChild, newChild, lanes));
+
+        case REACT_LAZY_TYPE:
+          const payload = newChild._payload;
+          const init = newChild._init; // TODO: This function is supposed to be non-recursive.
+
+          return reconcileChildFibers(returnFiber, currentFirstChild, init(payload), lanes);
+      }
+
+      if (isArray(newChild)) {
+        return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, lanes);
+      }
+
+      if (getIteratorFn(newChild)) {
+        return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, lanes);
+      } // Usables are a valid React node type. When React encounters a Usable in
+      // a child position, it unwraps it using the same algorithm as `use`. For
+      // example, for promises, React will throw an exception to unwind the
+      // stack, then replay the component once the promise resolves.
+      //
+      // A difference from `use` is that React will keep unwrapping the value
+      // until it reaches a non-Usable type.
+      //
+      // e.g. Usable<Usable<Usable<T>>> should resolve to T
+      //
+      // The structure is a bit unfortunate. Ideally, we shouldn't need to
+      // replay the entire begin phase of the parent fiber in order to reconcile
+      // the children again. This would require a somewhat significant refactor,
+      // because reconcilation happens deep within the begin phase, and
+      // depending on the type of work, not always at the end. We should
+      // consider as an future improvement.
+
+
+      if (typeof newChild.then === 'function') {
+        const thenable = newChild;
+        return reconcileChildFibersImpl(returnFiber, currentFirstChild, unwrapThenable(thenable), lanes);
+      }
+
+      if (newChild.$$typeof === REACT_CONTEXT_TYPE || newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+        const context = newChild;
+        return reconcileChildFibersImpl(returnFiber, currentFirstChild, readContextDuringReconcilation(returnFiber, context, lanes), lanes);
+      }
+
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+
+    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {
+      return placeSingleChild(reconcileSingleTextNode(returnFiber, currentFirstChild, '' + newChild, lanes));
+    }
+
+
+    return deleteRemainingChildren(returnFiber, currentFirstChild);
+  }
+
+  function reconcileChildFibers(returnFiber, currentFirstChild, newChild, lanes) {
+    // This indirection only exists so we can reset `thenableState` at the end.
+    // It should get inlined by Closure.
+    thenableIndexCounter$1 = 0;
+    const firstChildFiber = reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes);
+    thenableState$1 = null; // Don't bother to reset `thenableIndexCounter` to 0 because it always gets
+    // set at the beginning.
+
+    return firstChildFiber;
+  }
+
+  return reconcileChildFibers;
+}
+
+const reconcileChildFibers = createChildReconciler(true);
+const mountChildFibers = createChildReconciler(false);
+function resetChildReconcilerOnUnwind() {
+  // On unwind, clear any pending thenables that were used.
+  thenableState$1 = null;
+  thenableIndexCounter$1 = 0;
+}
+function cloneChildFibers(current, workInProgress) {
+  if (current !== null && workInProgress.child !== current.child) {
+    throw Error(formatProdErrorMessage(153));
+  }
+
+  if (workInProgress.child === null) {
+    return;
+  }
+
+  let currentChild = workInProgress.child;
+  let newChild = createWorkInProgress(currentChild, currentChild.pendingProps);
+  workInProgress.child = newChild;
+  newChild.return = workInProgress;
+
+  while (currentChild.sibling !== null) {
+    currentChild = currentChild.sibling;
+    newChild = newChild.sibling = createWorkInProgress(currentChild, currentChild.pendingProps);
+    newChild.return = workInProgress;
+  }
+
+  newChild.sibling = null;
+} // Reset a workInProgress child set to prepare it for a second pass.
+
+function resetChildFibers(workInProgress, lanes) {
+  let child = workInProgress.child;
+
+  while (child !== null) {
+    resetWorkInProgress(child, lanes);
+    child = child.sibling;
+  }
+}
+
+// TODO: This isn't being used yet, but it's intended to replace the
+// InvisibleParentContext that is currently managed by SuspenseContext.
+
+const currentTreeHiddenStackCursor = createCursor(null);
+const prevEntangledRenderLanesCursor = createCursor(NoLanes);
+function pushHiddenContext(fiber, context) {
+  const prevEntangledRenderLanes = getEntangledRenderLanes();
+  push(prevEntangledRenderLanesCursor, prevEntangledRenderLanes);
+  push(currentTreeHiddenStackCursor, context); // When rendering a subtree that's currently hidden, we must include all
+  // lanes that would have rendered if the hidden subtree hadn't been deferred.
+  // That is, in order to reveal content from hidden -> visible, we must commit
+  // all the updates that we skipped when we originally hid the tree.
+
+  setEntangledRenderLanes(mergeLanes(prevEntangledRenderLanes, context.baseLanes));
+}
+function reuseHiddenContextOnStack(fiber) {
+  // This subtree is not currently hidden, so we don't need to add any lanes
+  // to the render lanes. But we still need to push something to avoid a
+  // context mismatch. Reuse the existing context on the stack.
+  push(prevEntangledRenderLanesCursor, getEntangledRenderLanes());
+  push(currentTreeHiddenStackCursor, currentTreeHiddenStackCursor.current);
+}
+function popHiddenContext(fiber) {
+  // Restore the previous render lanes from the stack
+  setEntangledRenderLanes(prevEntangledRenderLanesCursor.current);
+  pop(currentTreeHiddenStackCursor);
+  pop(prevEntangledRenderLanesCursor);
+}
+function isCurrentTreeHidden() {
+  return currentTreeHiddenStackCursor.current !== null;
+}
+
+// suspends, i.e. it's the nearest `catch` block on the stack.
+
+const suspenseHandlerStackCursor = createCursor(null); // Represents the outermost boundary that is not visible in the current tree.
+// Everything above this is the "shell". When this is null, it means we're
+// rendering in the shell of the app. If it's non-null, it means we're rendering
+// deeper than the shell, inside a new tree that wasn't already visible.
+//
+// The main way we use this concept is to determine whether showing a fallback
+// would result in a desirable or undesirable loading state. Activing a fallback
+// in the shell is considered an undersirable loading state, because it would
+// mean hiding visible (albeit stale) content in the current tree — we prefer to
+// show the stale content, rather than switch to a fallback. But showing a
+// fallback in a new tree is fine, because there's no stale content to
+// prefer instead.
+
+let shellBoundary = null;
+function getShellBoundary() {
+  return shellBoundary;
+}
+function pushPrimaryTreeSuspenseHandler(handler) {
+  // TODO: Pass as argument
+  const current = handler.alternate;
+  // propagated a single level. For example, when ForceSuspenseFallback is set,
+  // it should only force the nearest Suspense boundary into fallback mode.
+
+  pushSuspenseListContext(handler, setDefaultShallowSuspenseListContext(suspenseStackCursor.current)); // Experimental feature: Some Suspense boundaries are marked as having an
+  // to push a nested Suspense handler, because it will get replaced by the
+  // outer fallback, anyway. Consider this as a future optimization.
+
+
+  push(suspenseHandlerStackCursor, handler);
+
+  if (shellBoundary === null) {
+    if (current === null || isCurrentTreeHidden()) {
+      // This boundary is not visible in the current UI.
+      shellBoundary = handler;
+    } else {
+      const prevState = current.memoizedState;
+
+      if (prevState !== null) {
+        // This boundary is showing a fallback in the current UI.
+        shellBoundary = handler;
+      }
+    }
+  }
+}
+function pushFallbackTreeSuspenseHandler(fiber) {
+  // We're about to render the fallback. If something in the fallback suspends,
+  // it's akin to throwing inside of a `catch` block. This boundary should not
+  // capture. Reuse the existing handler on the stack.
+  reuseSuspenseHandlerOnStack(fiber);
+}
+function pushOffscreenSuspenseHandler(fiber) {
+  if (fiber.tag === OffscreenComponent) {
+    // A SuspenseList context is only pushed here to avoid a push/pop mismatch.
+    // Reuse the current value on the stack.
+    // TODO: We can avoid needing to push here by by forking popSuspenseHandler
+    // into separate functions for Suspense and Offscreen.
+    pushSuspenseListContext(fiber, suspenseStackCursor.current);
+    push(suspenseHandlerStackCursor, fiber);
+
+    if (shellBoundary !== null) ; else {
+      const current = fiber.alternate;
+
+      if (current !== null) {
+        const prevState = current.memoizedState;
+
+        if (prevState !== null) {
+          // This is the first boundary in the stack that's already showing
+          // a fallback. So everything outside is considered the shell.
+          shellBoundary = fiber;
+        }
+      }
+    }
+  } else {
+    // This is a LegacyHidden component.
+    reuseSuspenseHandlerOnStack(fiber);
+  }
+}
+function reuseSuspenseHandlerOnStack(fiber) {
+  pushSuspenseListContext(fiber, suspenseStackCursor.current);
+  push(suspenseHandlerStackCursor, getSuspenseHandler());
+}
+function getSuspenseHandler() {
+  return suspenseHandlerStackCursor.current;
+}
+function popSuspenseHandler(fiber) {
+  pop(suspenseHandlerStackCursor);
+
+  if (shellBoundary === fiber) {
+    // Popping back into the shell.
+    shellBoundary = null;
+  }
+
+  popSuspenseListContext();
+} // SuspenseList context
+// TODO: Move to a separate module? We may change the SuspenseList
+// implementation to hide/show in the commit phase, anyway.
+
+const DefaultSuspenseContext = 0b00;
+const SubtreeSuspenseContextMask = 0b01; // ForceSuspenseFallback can be used by SuspenseList to force newly added
+// items into their fallback state during one of the render passes.
+
+const ForceSuspenseFallback = 0b10;
+const suspenseStackCursor = createCursor(DefaultSuspenseContext);
+function hasSuspenseListContext(parentContext, flag) {
+  return (parentContext & flag) !== 0;
+}
+function setDefaultShallowSuspenseListContext(parentContext) {
+  return parentContext & SubtreeSuspenseContextMask;
+}
+function setShallowSuspenseListContext(parentContext, shallowContext) {
+  return parentContext & SubtreeSuspenseContextMask | shallowContext;
+}
+function pushSuspenseListContext(fiber, newContext) {
+  push(suspenseStackCursor, newContext);
+}
+function popSuspenseListContext(fiber) {
+  pop(suspenseStackCursor);
+}
+
+// A non-null SuspenseState means that it is blocked for one reason or another.
+// - A non-null dehydrated field means it's blocked pending hydration.
+//   - A non-null dehydrated field can use isSuspenseInstancePending or
+//     isSuspenseInstanceFallback to query the reason for being dehydrated.
+// - A null dehydrated field means it's blocked by something suspending and
+//   we're currently showing a fallback instead.
+
+function findFirstSuspended(row) {
+  let node = row;
+
+  while (node !== null) {
+    if (node.tag === SuspenseComponent) {
+      const state = node.memoizedState;
+
+      if (state !== null) {
+        const dehydrated = state.dehydrated;
+
+        if (dehydrated === null || isSuspenseInstancePending(dehydrated) || isSuspenseInstanceFallback(dehydrated)) {
+          return node;
+        }
+      }
+    } else if (node.tag === SuspenseListComponent && // revealOrder undefined can't be trusted because it don't
+    // keep track of whether it suspended or not.
+    node.memoizedProps.revealOrder !== undefined) {
+      const didSuspend = (node.flags & DidCapture) !== NoFlags$1;
+
+      if (didSuspend) {
+        return node;
+      }
+    } else if (node.child !== null) {
+      node.child.return = node;
+      node = node.child;
+      continue;
+    }
+
+    if (node === row) {
+      return null;
+    }
+
+    while (node.sibling === null) {
+      if (node.return === null || node.return === row) {
+        return null;
+      }
+
+      node = node.return;
+    }
+
+    node.sibling.return = node.return;
+    node = node.sibling;
+  }
+
+  return null;
+}
+
+const NoFlags =
+/*   */
+0b0000; // Represents whether effect should fire.
+
+const HasEffect =
+/* */
+0b0001; // Represents the phase in which the effect (not the clean-up) fires.
+
+const Insertion =
+/* */
+0b0010;
+const Layout =
+/*    */
+0b0100;
+const Passive =
+/*   */
+0b1000;
+
+// there's only a single root, but we do support multi root apps, hence this
+// extra complexity. But this module is optimized for the single root case.
+
+let firstScheduledRoot = null;
+let lastScheduledRoot = null; // Used to prevent redundant mircotasks from being scheduled.
+
+let didScheduleMicrotask = false; // `act` "microtasks" are scheduled on the `act` queue instead of an actual
+
+let mightHavePendingSyncWork = false;
+let isFlushingWork = false;
+let currentEventTransitionLane = NoLane;
+function ensureRootIsScheduled(root) {
+  // This function is called whenever a root receives an update. It does two
+  // things 1) it ensures the root is in the root schedule, and 2) it ensures
+  // there's a pending microtask to process the root schedule.
+  //
+  // Most of the actual scheduling logic does not happen until
+  // `scheduleTaskForRootDuringMicrotask` runs.
+  // Add the root to the schedule
+  if (root === lastScheduledRoot || root.next !== null) ; else {
+    if (lastScheduledRoot === null) {
+      firstScheduledRoot = lastScheduledRoot = root;
+    } else {
+      lastScheduledRoot.next = root;
+      lastScheduledRoot = root;
+    }
+  } // Any time a root received an update, we set this to true until the next time
+  // we process the schedule. If it's false, then we can quickly exit flushSync
+  // without consulting the schedule.
+
+
+  mightHavePendingSyncWork = true; // At the end of the current event, go through each of the roots and ensure
+  // there's a task scheduled for each one at the correct priority.
+
+  {
+    if (!didScheduleMicrotask) {
+      didScheduleMicrotask = true;
+      scheduleImmediateTask(processRootScheduleInMicrotask);
+    }
+  }
+}
+function flushSyncWorkOnAllRoots() {
+  // This is allowed to be called synchronously, but the caller should check
+  // the execution context first.
+  flushSyncWorkAcrossRoots_impl(false);
+}
+function flushSyncWorkOnLegacyRootsOnly() {
+  // This is allowed to be called synchronously, but the caller should check
+  // the execution context first.
+  flushSyncWorkAcrossRoots_impl(true);
+}
+
+function flushSyncWorkAcrossRoots_impl(onlyLegacy) {
+  if (isFlushingWork) {
+    // Prevent reentrancy.
+    // TODO: Is this overly defensive? The callers must check the execution
+    // context first regardless.
+    return;
+  }
+
+  if (!mightHavePendingSyncWork) {
+    // Fast path. There's no sync work to do.
+    return;
+  } // There may or may not be synchronous work scheduled. Let's check.
+
+
+  let didPerformSomeWork;
+  let errors = null;
+  isFlushingWork = true;
+
+  do {
+    didPerformSomeWork = false;
+    let root = firstScheduledRoot;
+
+    while (root !== null) {
+      if (onlyLegacy && root.tag !== LegacyRoot) ; else {
+        const workInProgressRoot = getWorkInProgressRoot();
+        const workInProgressRootRenderLanes = getWorkInProgressRootRenderLanes();
+        const nextLanes = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes);
+
+        if (includesSyncLane(nextLanes)) {
+          // This root has pending sync work. Flush it now.
+          try {
+            didPerformSomeWork = true;
+            performSyncWorkOnRoot(root, nextLanes);
+          } catch (error) {
+            // Collect errors so we can rethrow them at the end
+            if (errors === null) {
+              errors = [error];
+            } else {
+              errors.push(error);
+            }
+          }
+        }
+      }
+
+      root = root.next;
+    }
+  } while (didPerformSomeWork);
+
+  isFlushingWork = false; // If any errors were thrown, rethrow them right before exiting.
+  // TODO: Consider returning these to the caller, to allow them to decide
+  // how/when to rethrow.
+
+  if (errors !== null) {
+    if (errors.length > 1) {
+      if (typeof AggregateError === 'function') {
+        // eslint-disable-next-line no-undef
+        throw new AggregateError(errors);
+      } else {
+        for (let i = 1; i < errors.length; i++) {
+          scheduleImmediateTask(throwError.bind(null, errors[i]));
+        }
+
+        const firstError = errors[0];
+        throw firstError;
+      }
+    } else {
+      const error = errors[0];
+      throw error;
+    }
+  }
+}
+
+function throwError(error) {
+  throw error;
+}
+
+function processRootScheduleInMicrotask() {
+  // This function is always called inside a microtask. It should never be
+  // called synchronously.
+  didScheduleMicrotask = false;
+
+
+  mightHavePendingSyncWork = false;
+  const currentTime = now();
+  let prev = null;
+  let root = firstScheduledRoot;
+
+  while (root !== null) {
+    const next = root.next;
+
+    if (currentEventTransitionLane !== NoLane && shouldAttemptEagerTransition()) {
+      // A transition was scheduled during an event, but we're going to try to
+      // render it synchronously anyway. We do this during a popstate event to
+      // preserve the scroll position of the previous page.
+      upgradePendingLaneToSync(root, currentEventTransitionLane);
+    }
+
+    const nextLanes = scheduleTaskForRootDuringMicrotask(root, currentTime);
+
+    if (nextLanes === NoLane) {
+      // This root has no more pending work. Remove it from the schedule. To
+      // guard against subtle reentrancy bugs, this microtask is the only place
+      // we do this — you can add roots to the schedule whenever, but you can
+      // only remove them here.
+      // Null this out so we know it's been removed from the schedule.
+      root.next = null;
+
+      if (prev === null) {
+        // This is the new head of the list
+        firstScheduledRoot = next;
+      } else {
+        prev.next = next;
+      }
+
+      if (next === null) {
+        // This is the new tail of the list
+        lastScheduledRoot = prev;
+      }
+    } else {
+      // This root still has work. Keep it in the list.
+      prev = root;
+
+      if (includesSyncLane(nextLanes)) {
+        mightHavePendingSyncWork = true;
+      }
+    }
+
+    root = next;
+  }
+
+  currentEventTransitionLane = NoLane; // At the end of the microtask, flush any pending synchronous work. This has
+  // to come at the end, because it does actual rendering work that might throw.
+
+  flushSyncWorkOnAllRoots();
+}
+
+function scheduleTaskForRootDuringMicrotask(root, currentTime) {
+  // This function is always called inside a microtask, or at the very end of a
+  // rendering task right before we yield to the main thread. It should never be
+  // called synchronously.
+  //
+  // TODO: Unless enableDeferRootSchedulingToMicrotask is off. We need to land
+  // that ASAP to unblock additional features we have planned.
+  //
+  // This function also never performs React work synchronously; it should
+  // only schedule work to be performed later, in a separate task or microtask.
+  // Check if any lanes are being starved by other work. If so, mark them as
+  // expired so we know to work on those next.
+  markStarvedLanesAsExpired(root, currentTime); // Determine the next lanes to work on, and their priority.
+
+  const workInProgressRoot = getWorkInProgressRoot();
+  const workInProgressRootRenderLanes = getWorkInProgressRootRenderLanes();
+  const nextLanes = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes);
+  const existingCallbackNode = root.callbackNode;
+
+  if ( // Check if there's nothing to work on
+  nextLanes === NoLanes || // If this root is currently suspended and waiting for data to resolve, don't
+  // schedule a task to render it. We'll either wait for a ping, or wait to
+  // receive an update.
+  //
+  // Suspended render phase
+  root === workInProgressRoot && isWorkLoopSuspendedOnData() || // Suspended commit phase
+  root.cancelPendingCommit !== null) {
+    // Fast path: There's nothing to work on.
+    if (existingCallbackNode !== null) {
+      cancelCallback(existingCallbackNode);
+    }
+
+    root.callbackNode = null;
+    root.callbackPriority = NoLane;
+    return NoLane;
+  } // Schedule a new callback in the host environment.
+
+
+  if (includesSyncLane(nextLanes)) {
+    // Synchronous work is always flushed at the end of the microtask, so we
+    // don't need to schedule an additional task.
+    if (existingCallbackNode !== null) {
+      cancelCallback(existingCallbackNode);
+    }
+
+    root.callbackPriority = SyncLane;
+    root.callbackNode = null;
+    return SyncLane;
+  } else {
+    // We use the highest priority lane to represent the priority of the callback.
+    const existingCallbackPriority = root.callbackPriority;
+    const newCallbackPriority = getHighestPriorityLane(nextLanes);
+
+    if (newCallbackPriority === existingCallbackPriority && // Special case related to `act`. If the currently scheduled task is a
+    // Scheduler task, rather than an `act` task, cancel it and re-schedule
+    // on the `act` queue.
+    !(false  )) {
+      // The priority hasn't changed. We can reuse the existing task.
+      return newCallbackPriority;
+    } else {
+      // Cancel the existing callback. We'll schedule a new one below.
+      cancelCallback(existingCallbackNode);
+    }
+
+    let schedulerPriorityLevel;
+
+    switch (lanesToEventPriority(nextLanes)) {
+      case DiscreteEventPriority:
+        schedulerPriorityLevel = ImmediatePriority;
+        break;
+
+      case ContinuousEventPriority:
+        schedulerPriorityLevel = UserBlockingPriority;
+        break;
+
+      case DefaultEventPriority:
+        schedulerPriorityLevel = NormalPriority$1;
+        break;
+
+      case IdleEventPriority:
+        schedulerPriorityLevel = IdlePriority;
+        break;
+
+      default:
+        schedulerPriorityLevel = NormalPriority$1;
+        break;
+    }
+
+    const newCallbackNode = scheduleCallback$2(schedulerPriorityLevel, performConcurrentWorkOnRoot.bind(null, root));
+    root.callbackPriority = newCallbackPriority;
+    root.callbackNode = newCallbackNode;
+    return newCallbackPriority;
+  }
+}
+
+function getContinuationForRoot(root, originalCallbackNode) {
+  // This is called at the end of `performConcurrentWorkOnRoot` to determine
+  // if we need to schedule a continuation task.
+  //
+  // Usually `scheduleTaskForRootDuringMicrotask` only runs inside a microtask;
+  // however, since most of the logic for determining if we need a continuation
+  // versus a new task is the same, we cheat a bit and call it here. This is
+  // only safe to do because we know we're at the end of the browser task.
+  // So although it's not an actual microtask, it might as well be.
+  scheduleTaskForRootDuringMicrotask(root, now());
+
+  if (root.callbackNode === originalCallbackNode) {
+    // The task node scheduled for this root is the same one that's
+    // currently executed. Need to return a continuation.
+    return performConcurrentWorkOnRoot.bind(null, root);
+  }
+
+  return null;
+}
+
+function scheduleCallback$2(priorityLevel, callback) {
+  {
+    return scheduleCallback$3(priorityLevel, callback);
+  }
+}
+
+function cancelCallback(callbackNode) {
+  if (callbackNode !== null) {
+    cancelCallback$1(callbackNode);
+  }
+}
+
+function scheduleImmediateTask(cb) {
+  // Alternatively, can we move this check to the host config?
+
+
+  {
+    scheduleMicrotask(() => {
+      // In Safari, appending an iframe forces microtasks to run.
+      // https://github.com/facebook/react/issues/22459
+      // We don't support running callbacks in the middle of render
+      // or commit so we need to check against that.
+      const executionContext = getExecutionContext();
+
+      if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+        // Note that this would still prematurely flush the callbacks
+        // if this happens outside render or commit phase (e.g. in an event).
+        // Intentionally using a macrotask instead of a microtask here. This is
+        // wrong semantically but it prevents an infinite loop. The bug is
+        // Safari's, not ours, so we just do our best to not crash even though
+        // the behavior isn't completely correct.
+        scheduleCallback$3(ImmediatePriority, cb);
+        return;
+      }
+
+      cb();
+    });
+  }
+}
+
+function requestTransitionLane() {
+  // The algorithm for assigning an update to a lane should be stable for all
+  // updates at the same priority within the same event. To do this, the
+  // inputs to the algorithm must be the same.
+  //
+  // The trick we use is to cache the first of each of these inputs within an
+  // event. Then reset the cached values once we can be sure the event is
+  // over. Our heuristic for that is whenever we enter a concurrent work loop.
+  if (currentEventTransitionLane === NoLane) {
+    // All transitions within the same event are assigned the same lane.
+    currentEventTransitionLane = claimNextTransitionLane();
+  }
+
+  return currentEventTransitionLane;
+}
+
+// transition updates that occur while the async action is still in progress
+// are treated as part of the action.
+//
+// The ideal behavior would be to treat each async function as an independent
+// action. However, without a mechanism like AsyncContext, we can't tell which
+// action an update corresponds to. So instead, we entangle them all into one.
+// The listeners to notify once the entangled scope completes.
+
+let currentEntangledListeners = null; // The number of pending async actions in the entangled scope.
+
+let currentEntangledPendingCount = 0; // The transition lane shared by all updates in the entangled scope.
+
+let currentEntangledLane = NoLane;
+function requestAsyncActionContext(actionReturnValue, // If this is provided, this resulting thenable resolves to this value instead
+// of the return value of the action. This is a perf trick to avoid composing
+// an extra async function.
+overrideReturnValue) {
+  // This is an async action.
+  //
+  // Return a thenable that resolves once the action scope (i.e. the async
+  // function passed to startTransition) has finished running.
+  const thenable = actionReturnValue;
+  let entangledListeners;
+
+  if (currentEntangledListeners === null) {
+    // There's no outer async action scope. Create a new one.
+    entangledListeners = currentEntangledListeners = [];
+    currentEntangledPendingCount = 0;
+    currentEntangledLane = requestTransitionLane();
+  } else {
+    entangledListeners = currentEntangledListeners;
+  }
+
+  currentEntangledPendingCount++; // Create a thenable that represents the result of this action, but doesn't
+  // resolve until the entire entangled scope has finished.
+  //
+  // Expressed using promises:
+  //   const [thisResult] = await Promise.all([thisAction, entangledAction]);
+  //   return thisResult;
+
+  const resultThenable = createResultThenable(entangledListeners);
+  let resultStatus = 'pending';
+  let resultValue;
+  let rejectedReason;
+  thenable.then(value => {
+    resultStatus = 'fulfilled';
+    resultValue = overrideReturnValue !== null ? overrideReturnValue : value;
+    pingEngtangledActionScope();
+  }, error => {
+    resultStatus = 'rejected';
+    rejectedReason = error;
+    pingEngtangledActionScope();
+  }); // Attach a listener to fill in the result.
+
+  entangledListeners.push(() => {
+    switch (resultStatus) {
+      case 'fulfilled':
+        {
+          const fulfilledThenable = resultThenable;
+          fulfilledThenable.status = 'fulfilled';
+          fulfilledThenable.value = resultValue;
+          break;
+        }
+
+      case 'rejected':
+        {
+          const rejectedThenable = resultThenable;
+          rejectedThenable.status = 'rejected';
+          rejectedThenable.reason = rejectedReason;
+          break;
+        }
+
+      case 'pending':
+      default:
+        {
+          // The listener above should have been called first, so `resultStatus`
+          // should already be set to the correct value.
+          throw Error(formatProdErrorMessage(478));
+        }
+    }
+  });
+  return resultThenable;
+}
+function requestSyncActionContext(actionReturnValue, // If this is provided, this resulting thenable resolves to this value instead
+// of the return value of the action. This is a perf trick to avoid composing
+// an extra async function.
+overrideReturnValue) {
+  const resultValue = overrideReturnValue !== null ? overrideReturnValue : actionReturnValue; // This is not an async action, but it may be part of an outer async action.
+
+  if (currentEntangledListeners === null) {
+    return resultValue;
+  } else {
+    // Return a thenable that does not resolve until the entangled actions
+    // have finished.
+    const entangledListeners = currentEntangledListeners;
+    const resultThenable = createResultThenable(entangledListeners);
+    entangledListeners.push(() => {
+      const fulfilledThenable = resultThenable;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = resultValue;
+    });
+    return resultThenable;
+  }
+}
+
+function pingEngtangledActionScope() {
+  if (currentEntangledListeners !== null && --currentEntangledPendingCount === 0) {
+    // All the actions have finished. Close the entangled async action scope
+    // and notify all the listeners.
+    const listeners = currentEntangledListeners;
+    currentEntangledListeners = null;
+    currentEntangledLane = NoLane;
+
+    for (let i = 0; i < listeners.length; i++) {
+      const listener = listeners[i];
+      listener();
+    }
+  }
+}
+
+function createResultThenable(entangledListeners) {
+  // Waits for the entangled async action to complete, then resolves to the
+  // result of an individual action.
+  const resultThenable = {
+    status: 'pending',
+    value: null,
+    reason: null,
+
+    then(resolve) {
+      // This is a bit of a cheat. `resolve` expects a value of type `S` to be
+      // passed, but because we're instrumenting the `status` field ourselves,
+      // and we know this thenable will only be used by React, we also know
+      // the value isn't actually needed. So we add the resolve function
+      // directly to the entangled listeners.
+      //
+      // This is also why we don't need to check if the thenable is still
+      // pending; the Suspense implementation already performs that check.
+      const ping = resolve;
+      entangledListeners.push(ping);
+    }
+
+  };
+  return resultThenable;
+}
+
+function peekEntangledActionLane() {
+  return currentEntangledLane;
+}
+
+const ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
+      ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig;
+// lifetime of an effect. In Rust terms, a RefCell. We use it to store the
+// "destroy" function that is returned from an effect, because that is stateful.
+// The field is `undefined` if the effect is unmounted, or if the effect ran
+// but is not stateful. We don't explicitly track whether the effect is mounted
+// or unmounted because that can be inferred by the hiddenness of the fiber in
+// the tree, i.e. whether there is a hidden Offscreen fiber above it.
+//
+// It's unfortunate that this is stored on a separate object, because it adds
+// more memory per effect instance, but it's conceptually sound. I think there's
+// likely a better data structure we could use for effects; perhaps just one
+// array of effect instances per fiber. But I think this is OK for now despite
+// the additional memory and we can follow up with performance
+// optimizations later.
+// These are set right before calling the component.
+
+
+let renderLanes = NoLanes; // The work-in-progress fiber. I've named it differently to distinguish it from
+// the work-in-progress hook.
+
+let currentlyRenderingFiber$1 = null; // Hooks are stored as a linked list on the fiber's memoizedState field. The
+// current hook list is the list that belongs to the current fiber. The
+// work-in-progress hook list is a new list that will be added to the
+// work-in-progress fiber.
+
+let currentHook = null;
+let workInProgressHook = null; // Whether an update was scheduled at any point during the render phase. This
+// does not get reset if we do another render pass; only when we're completely
+// finished evaluating this component. This is an optimization so we know
+// whether we need to clear render phase updates after a throw.
+
+let didScheduleRenderPhaseUpdate = false; // Where an update was scheduled only during the current render pass. This
+// gets reset after each attempt.
+// TODO: Maybe there's some way to consolidate this with
+// `didScheduleRenderPhaseUpdate`. Or with `numberOfReRenders`.
+
+let didScheduleRenderPhaseUpdateDuringThisPass = false;
+let shouldDoubleInvokeUserFnsInHooksDEV = false; // Counts the number of useId hooks in this component.
+
+let localIdCounter = 0; // Counts number of `use`-d thenables
+
+let thenableIndexCounter = 0;
+let thenableState = null; // Used for ids that are generated completely client-side (i.e. not during
+// hydration). This counter is global, so client ids are not stable across
+// render attempts.
+
+let globalClientIdCounter = 0;
+const RE_RENDER_LIMIT = 25; // In DEV, this is the name of the currently executing primitive hook
+
+function throwInvalidHookError() {
+  throw Error(formatProdErrorMessage(321));
+}
+
+function areHookInputsEqual(nextDeps, prevDeps) {
+
+  if (prevDeps === null) {
+
+    return false;
+  }
+
+
+  for (let i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    if (objectIs(nextDeps[i], prevDeps[i])) {
+      continue;
+    }
+
+    return false;
+  }
+
+  return true;
+}
+
+function renderWithHooks(current, workInProgress, Component, props, secondArg, nextRenderLanes) {
+  renderLanes = nextRenderLanes;
+  currentlyRenderingFiber$1 = workInProgress;
+
+  workInProgress.memoizedState = null;
+  workInProgress.updateQueue = null;
+  workInProgress.lanes = NoLanes; // The following should have already been reset
+  // currentHook = null;
+  // workInProgressHook = null;
+  // didScheduleRenderPhaseUpdate = false;
+  // localIdCounter = 0;
+  // thenableIndexCounter = 0;
+  // thenableState = null;
+  // TODO Warn if no hooks are used at all during mount, then some are used during update.
+  // Currently we will identify the update render as a mount because memoizedState === null.
+  // This is tricky because it's valid for certain types of components (e.g. React.lazy)
+  // Using memoizedState to differentiate between mount/update only works if at least one stateful hook is used.
+  // Non-stateful hooks (e.g. context) don't get added to memoizedState,
+  // so memoizedState would be null during updates and mounts.
+
+  {
+    ReactCurrentDispatcher$1.current = current === null || current.memoizedState === null ? HooksDispatcherOnMount : HooksDispatcherOnUpdate;
+  } // In Strict Mode, during development, user functions are double invoked to
+  // help detect side effects. The logic for how this is implemented for in
+  // hook components is a bit complex so let's break it down.
+  //
+  // We will invoke the entire component function twice. However, during the
+  // second invocation of the component, the hook state from the first
+  // invocation will be reused. That means things like `useMemo` functions won't
+  // run again, because the deps will match and the memoized result will
+  // be reused.
+  //
+  // We want memoized functions to run twice, too, so account for this, user
+  // functions are double invoked during the *first* invocation of the component
+  // function, and are *not* double invoked during the second incovation:
+  //
+  // - First execution of component function: user functions are double invoked
+  // - Second execution of component function (in Strict Mode, during
+  //   development): user functions are not double invoked.
+  //
+  // This is intentional for a few reasons; most importantly, it's because of
+  // how `use` works when something suspends: it reuses the promise that was
+  // passed during the first attempt. This is itself a form of memoization.
+  // We need to be able to memoize the reactive inputs to the `use` call using
+  // a hook (i.e. `useMemo`), which means, the reactive inputs to `use` must
+  // come from the same component invocation as the output.
+  //
+  // There are plenty of tests to ensure this behavior is correct.
+
+
+  const shouldDoubleRenderDEV = false  ;
+  shouldDoubleInvokeUserFnsInHooksDEV = shouldDoubleRenderDEV;
+  let children = Component(props, secondArg);
+  shouldDoubleInvokeUserFnsInHooksDEV = false; // Check if there was a render phase update
+
+  if (didScheduleRenderPhaseUpdateDuringThisPass) {
+    // Keep rendering until the component stabilizes (there are no more render
+    // phase updates).
+    children = renderWithHooksAgain(workInProgress, Component, props, secondArg);
+  }
+
+  finishRenderingHooks();
+  return children;
+}
+
+function finishRenderingHooks(current, workInProgress, Component) {
+  // at the beginning of the render phase and there's no re-entrance.
+
+
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher; // This check uses currentHook so that it works the same in DEV and prod bundles.
+  // hookTypesDev could catch more cases (e.g. context) but only in DEV bundles.
+
+  const didRenderTooFewHooks = currentHook !== null && currentHook.next !== null;
+  renderLanes = NoLanes;
+  currentlyRenderingFiber$1 = null;
+  currentHook = null;
+  workInProgressHook = null;
+
+  didScheduleRenderPhaseUpdate = false; // This is reset by checkDidRenderIdHook
+  // localIdCounter = 0;
+
+  thenableIndexCounter = 0;
+  thenableState = null;
+
+  if (didRenderTooFewHooks) {
+    throw Error(formatProdErrorMessage(300));
+  }
+}
+
+function replaySuspendedComponentWithHooks(current, workInProgress, Component, props, secondArg) {
+
+  const children = renderWithHooksAgain(workInProgress, Component, props, secondArg);
+  finishRenderingHooks();
+  return children;
+}
+
+function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
+  // This is used to perform another render pass. It's used when setState is
+  // called during render, and for double invoking components in Strict Mode
+  // during development.
+  //
+  // The state from the previous pass is reused whenever possible. So, state
+  // updates that were already processed are not processed again, and memoized
+  // functions (`useMemo`) are not invoked again.
+  //
+  // Keep rendering in a loop for as long as render phase updates continue to
+  // be scheduled. Use a counter to prevent infinite loops.
+  currentlyRenderingFiber$1 = workInProgress;
+  let numberOfReRenders = 0;
+  let children;
+
+  do {
+    if (didScheduleRenderPhaseUpdateDuringThisPass) {
+      // It's possible that a use() value depended on a state that was updated in
+      // this rerender, so we need to watch for different thenables this time.
+      thenableState = null;
+    }
+
+    thenableIndexCounter = 0;
+    didScheduleRenderPhaseUpdateDuringThisPass = false;
+
+    if (numberOfReRenders >= RE_RENDER_LIMIT) {
+      throw Error(formatProdErrorMessage(301));
+    }
+
+    numberOfReRenders += 1;
+
+
+    currentHook = null;
+    workInProgressHook = null;
+    workInProgress.updateQueue = null;
+
+    ReactCurrentDispatcher$1.current = HooksDispatcherOnRerender;
+    children = Component(props, secondArg);
+  } while (didScheduleRenderPhaseUpdateDuringThisPass);
+
+  return children;
+}
+
+function renderTransitionAwareHostComponentWithHooks(current, workInProgress, lanes) {
+
+  return renderWithHooks(current, workInProgress, TransitionAwareHostComponent, null, null, lanes);
+}
+function TransitionAwareHostComponent() {
+
+  const dispatcher = ReactCurrentDispatcher$1.current;
+
+  const _dispatcher$useState = dispatcher.useState(),
+        maybeThenable = _dispatcher$useState[0];
+
+  if (typeof maybeThenable.then === 'function') {
+    const thenable = maybeThenable;
+    return useThenable(thenable);
+  } else {
+    const status = maybeThenable;
+    return status;
+  }
+}
+function checkDidRenderIdHook() {
+  // This should be called immediately after every renderWithHooks call.
+  // Conceptually, it's part of the return value of renderWithHooks; it's only a
+  // separate function to avoid using an array tuple.
+  const didRenderIdHook = localIdCounter !== 0;
+  localIdCounter = 0;
+  return didRenderIdHook;
+}
+function bailoutHooks(current, workInProgress, lanes) {
+  workInProgress.updateQueue = current.updateQueue; // TODO: Don't need to reset the flags here, because they're reset in the
+  // complete phase (bubbleProperties).
+
+  {
+    workInProgress.flags &= ~(Passive$1 | Update);
+  }
+
+  current.lanes = removeLanes(current.lanes, lanes);
+}
+function resetHooksAfterThrow() {
+  // This is called immediaetly after a throw. It shouldn't reset the entire
+  // module state, because the work loop might decide to replay the component
+  // again without rewinding.
+  //
+  // It should only reset things like the current dispatcher, to prevent hooks
+  // from being called outside of a component.
+  currentlyRenderingFiber$1 = null; // We can assume the previous dispatcher is always this one, since we set it
+  // at the beginning of the render phase and there's no re-entrance.
+
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+}
+function resetHooksOnUnwind(workInProgress) {
+  if (didScheduleRenderPhaseUpdate) {
+    // There were render phase updates. These are only valid for this render
+    // phase, which we are now aborting. Remove the updates from the queues so
+    // they do not persist to the next render. Do not remove updates from hooks
+    // that weren't processed.
+    //
+    // Only reset the updates from the queue if it has a clone. If it does
+    // not have a clone, that means it wasn't processed, and the updates were
+    // scheduled before we entered the render phase.
+    let hook = workInProgress.memoizedState;
+
+    while (hook !== null) {
+      const queue = hook.queue;
+
+      if (queue !== null) {
+        queue.pending = null;
+      }
+
+      hook = hook.next;
+    }
+
+    didScheduleRenderPhaseUpdate = false;
+  }
+
+  renderLanes = NoLanes;
+  currentlyRenderingFiber$1 = null;
+  currentHook = null;
+  workInProgressHook = null;
+
+  didScheduleRenderPhaseUpdateDuringThisPass = false;
+  localIdCounter = 0;
+  thenableIndexCounter = 0;
+  thenableState = null;
+}
+
+function mountWorkInProgressHook() {
+  const hook = {
+    memoizedState: null,
+    baseState: null,
+    baseQueue: null,
+    queue: null,
+    next: null
+  };
+
+  if (workInProgressHook === null) {
+    // This is the first hook in the list
+    currentlyRenderingFiber$1.memoizedState = workInProgressHook = hook;
+  } else {
+    // Append to the end of the list
+    workInProgressHook = workInProgressHook.next = hook;
+  }
+
+  return workInProgressHook;
+}
+
+function updateWorkInProgressHook() {
+  // This function is used both for updates and for re-renders triggered by a
+  // render phase update. It assumes there is either a current hook we can
+  // clone, or a work-in-progress hook from a previous render pass that we can
+  // use as a base.
+  let nextCurrentHook;
+
+  if (currentHook === null) {
+    const current = currentlyRenderingFiber$1.alternate;
+
+    if (current !== null) {
+      nextCurrentHook = current.memoizedState;
+    } else {
+      nextCurrentHook = null;
+    }
+  } else {
+    nextCurrentHook = currentHook.next;
+  }
+
+  let nextWorkInProgressHook;
+
+  if (workInProgressHook === null) {
+    nextWorkInProgressHook = currentlyRenderingFiber$1.memoizedState;
+  } else {
+    nextWorkInProgressHook = workInProgressHook.next;
+  }
+
+  if (nextWorkInProgressHook !== null) {
+    // There's already a work-in-progress. Reuse it.
+    workInProgressHook = nextWorkInProgressHook;
+    nextWorkInProgressHook = workInProgressHook.next;
+    currentHook = nextCurrentHook;
+  } else {
+    // Clone from the current hook.
+    if (nextCurrentHook === null) {
+      const currentFiber = currentlyRenderingFiber$1.alternate;
+
+      if (currentFiber === null) {
+        // This is the initial render. This branch is reached when the component
+        // suspends, resumes, then renders an additional hook.
+        // Should never be reached because we should switch to the mount dispatcher first.
+        throw Error(formatProdErrorMessage(467));
+      } else {
+        // This is an update. We should always have a current hook.
+        throw Error(formatProdErrorMessage(310));
+      }
+    }
+
+    currentHook = nextCurrentHook;
+    const newHook = {
+      memoizedState: currentHook.memoizedState,
+      baseState: currentHook.baseState,
+      baseQueue: currentHook.baseQueue,
+      queue: currentHook.queue,
+      next: null
+    };
+
+    if (workInProgressHook === null) {
+      // This is the first hook in the list.
+      currentlyRenderingFiber$1.memoizedState = workInProgressHook = newHook;
+    } else {
+      // Append to the end of the list.
+      workInProgressHook = workInProgressHook.next = newHook;
+    }
+  }
+
+  return workInProgressHook;
+} // NOTE: defining two versions of this function to avoid size impact when this feature is disabled.
+// Previously this function was inlined, the additional `memoCache` property makes it not inlined.
+
+
+let createFunctionComponentUpdateQueue;
+
+{
+  createFunctionComponentUpdateQueue = () => {
+    return {
+      lastEffect: null,
+      events: null,
+      stores: null
+    };
+  };
+}
+
+function useThenable(thenable) {
+  // Track the position of the thenable within this fiber.
+  const index = thenableIndexCounter;
+  thenableIndexCounter += 1;
+
+  if (thenableState === null) {
+    thenableState = createThenableState();
+  }
+
+  const result = trackUsedThenable(thenableState, thenable, index);
+
+  if (currentlyRenderingFiber$1.alternate === null && (workInProgressHook === null ? currentlyRenderingFiber$1.memoizedState === null : workInProgressHook.next === null)) {
+    // Initial render, and either this is the first time the component is
+    // called, or there were no Hooks called after this use() the previous
+    // time (perhaps because it threw). Subsequent Hook calls should use the
+    // mount dispatcher.
+    {
+      ReactCurrentDispatcher$1.current = HooksDispatcherOnMount;
+    }
+  }
+
+  return result;
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable;
+      return useThenable(thenable);
+    } else if (usable.$$typeof === REACT_CONTEXT_TYPE || usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+  throw Error(formatProdErrorMessage(438, String(usable)));
+}
+
+function basicStateReducer(state, action) {
+  // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
+  return typeof action === 'function' ? action(state) : action;
+}
+
+function mountReducer(reducer, initialArg, init) {
+  const hook = mountWorkInProgressHook();
+  let initialState;
+
+  if (init !== undefined) {
+    initialState = init(initialArg);
+  } else {
+    initialState = initialArg;
+  }
+
+  hook.memoizedState = hook.baseState = initialState;
+  const queue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    lastRenderedReducer: reducer,
+    lastRenderedState: initialState
+  };
+  hook.queue = queue;
+  const dispatch = queue.dispatch = dispatchReducerAction.bind(null, currentlyRenderingFiber$1, queue);
+  return [hook.memoizedState, dispatch];
+}
+
+function updateReducer(reducer, initialArg, init) {
+  const hook = updateWorkInProgressHook();
+  return updateReducerImpl(hook, currentHook, reducer);
+}
+
+function updateReducerImpl(hook, current, reducer) {
+  const queue = hook.queue;
+
+  if (queue === null) {
+    throw Error(formatProdErrorMessage(311));
+  }
+
+  queue.lastRenderedReducer = reducer; // The last rebase update that is NOT part of the base state.
+
+  let baseQueue = hook.baseQueue; // The last pending update that hasn't been processed yet.
+
+  const pendingQueue = queue.pending;
+
+  if (pendingQueue !== null) {
+    // We have new updates that haven't been processed yet.
+    // We'll add them to the base queue.
+    if (baseQueue !== null) {
+      // Merge the pending queue and the base queue.
+      const baseFirst = baseQueue.next;
+      const pendingFirst = pendingQueue.next;
+      baseQueue.next = pendingFirst;
+      pendingQueue.next = baseFirst;
+    }
+
+    current.baseQueue = baseQueue = pendingQueue;
+    queue.pending = null;
+  }
+
+  if (baseQueue !== null) {
+    // We have a queue to process.
+    const first = baseQueue.next;
+    let newState = hook.baseState;
+    let newBaseState = null;
+    let newBaseQueueFirst = null;
+    let newBaseQueueLast = null;
+    let update = first;
+
+    do {
+      // An extra OffscreenLane bit is added to updates that were made to
+      // a hidden tree, so that we can distinguish them from updates that were
+      // already there when the tree was hidden.
+      const updateLane = removeLanes(update.lane, OffscreenLane);
+      const isHiddenUpdate = updateLane !== update.lane; // Check if this update was made while the tree was hidden. If so, then
+      // it's not a "base" update and we should disregard the extra base lanes
+      // that were added to renderLanes when we entered the Offscreen tree.
+
+      const shouldSkipUpdate = isHiddenUpdate ? !isSubsetOfLanes(getWorkInProgressRootRenderLanes(), updateLane) : !isSubsetOfLanes(renderLanes, updateLane);
+
+      if (shouldSkipUpdate) {
+        // Priority is insufficient. Skip this update. If this is the first
+        // skipped update, the previous update/state is the new base
+        // update/state.
+        const clone = {
+          lane: updateLane,
+          revertLane: update.revertLane,
+          action: update.action,
+          hasEagerState: update.hasEagerState,
+          eagerState: update.eagerState,
+          next: null
+        };
+
+        if (newBaseQueueLast === null) {
+          newBaseQueueFirst = newBaseQueueLast = clone;
+          newBaseState = newState;
+        } else {
+          newBaseQueueLast = newBaseQueueLast.next = clone;
+        } // Update the remaining priority in the queue.
+        // TODO: Don't need to accumulate this. Instead, we can remove
+        // renderLanes from the original lanes.
+
+
+        currentlyRenderingFiber$1.lanes = mergeLanes(currentlyRenderingFiber$1.lanes, updateLane);
+        markSkippedUpdateLanes(updateLane);
+      } else {
+        // This update does have sufficient priority.
+        // Check if this is an optimistic update.
+        const revertLane = update.revertLane;
+
+        if (revertLane === NoLane) {
+          // This is not an optimistic update, and we're going to apply it now.
+          // But, if there were earlier updates that were skipped, we need to
+          // leave this update in the queue so it can be rebased later.
+          if (newBaseQueueLast !== null) {
+            const clone = {
+              // This update is going to be committed so we never want uncommit
+              // it. Using NoLane works because 0 is a subset of all bitmasks, so
+              // this will never be skipped by the check above.
+              lane: NoLane,
+              revertLane: NoLane,
+              action: update.action,
+              hasEagerState: update.hasEagerState,
+              eagerState: update.eagerState,
+              next: null
+            };
+            newBaseQueueLast = newBaseQueueLast.next = clone;
+          }
+        } else {
+          // This is an optimistic update. If the "revert" priority is
+          // sufficient, don't apply the update. Otherwise, apply the update,
+          // but leave it in the queue so it can be either reverted or
+          // rebased in a subsequent render.
+          if (isSubsetOfLanes(renderLanes, revertLane)) {
+            // The transition that this optimistic update is associated with
+            // has finished. Pretend the update doesn't exist by skipping
+            // over it.
+            update = update.next;
+            continue;
+          } else {
+            const clone = {
+              // Once we commit an optimistic update, we shouldn't uncommit it
+              // until the transition it is associated with has finished
+              // (represented by revertLane). Using NoLane here works because 0
+              // is a subset of all bitmasks, so this will never be skipped by
+              // the check above.
+              lane: NoLane,
+              // Reuse the same revertLane so we know when the transition
+              // has finished.
+              revertLane: update.revertLane,
+              action: update.action,
+              hasEagerState: update.hasEagerState,
+              eagerState: update.eagerState,
+              next: null
+            };
+
+            if (newBaseQueueLast === null) {
+              newBaseQueueFirst = newBaseQueueLast = clone;
+              newBaseState = newState;
+            } else {
+              newBaseQueueLast = newBaseQueueLast.next = clone;
+            } // Update the remaining priority in the queue.
+            // TODO: Don't need to accumulate this. Instead, we can remove
+            // renderLanes from the original lanes.
+
+
+            currentlyRenderingFiber$1.lanes = mergeLanes(currentlyRenderingFiber$1.lanes, revertLane);
+            markSkippedUpdateLanes(revertLane);
+          }
+        } // Process this update.
+
+
+        const action = update.action;
+
+        if (shouldDoubleInvokeUserFnsInHooksDEV) {
+          reducer(newState, action);
+        }
+
+        if (update.hasEagerState) {
+          // If this update is a state update (not a reducer) and was processed eagerly,
+          // we can use the eagerly computed state
+          newState = update.eagerState;
+        } else {
+          newState = reducer(newState, action);
+        }
+      }
+
+      update = update.next;
+    } while (update !== null && update !== first);
+
+    if (newBaseQueueLast === null) {
+      newBaseState = newState;
+    } else {
+      newBaseQueueLast.next = newBaseQueueFirst;
+    } // Mark that the fiber performed work, but only if the new state is
+    // different from the current state.
+
+
+    if (!objectIs(newState, hook.memoizedState)) {
+      markWorkInProgressReceivedUpdate();
+    }
+
+    hook.memoizedState = newState;
+    hook.baseState = newBaseState;
+    hook.baseQueue = newBaseQueueLast;
+    queue.lastRenderedState = newState;
+  }
+
+  if (baseQueue === null) {
+    // `queue.lanes` is used for entangling transitions. We can set it back to
+    // zero once the queue is empty.
+    queue.lanes = NoLanes;
+  }
+
+  const dispatch = queue.dispatch;
+  return [hook.memoizedState, dispatch];
+}
+
+function rerenderReducer(reducer, initialArg, init) {
+  const hook = updateWorkInProgressHook();
+  const queue = hook.queue;
+
+  if (queue === null) {
+    throw Error(formatProdErrorMessage(311));
+  }
+
+  queue.lastRenderedReducer = reducer; // This is a re-render. Apply the new render phase updates to the previous
+  // work-in-progress hook.
+
+  const dispatch = queue.dispatch;
+  const lastRenderPhaseUpdate = queue.pending;
+  let newState = hook.memoizedState;
+
+  if (lastRenderPhaseUpdate !== null) {
+    // The queue doesn't persist past this render pass.
+    queue.pending = null;
+    const firstRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+    let update = firstRenderPhaseUpdate;
+
+    do {
+      // Process this render phase update. We don't have to check the
+      // priority because it will always be the same as the current
+      // render's.
+      const action = update.action;
+      newState = reducer(newState, action);
+      update = update.next;
+    } while (update !== firstRenderPhaseUpdate); // Mark that the fiber performed work, but only if the new state is
+    // different from the current state.
+
+
+    if (!objectIs(newState, hook.memoizedState)) {
+      markWorkInProgressReceivedUpdate();
+    }
+
+    hook.memoizedState = newState; // Don't persist the state accumulated from the render phase updates to
+    // the base state unless the queue is empty.
+    // TODO: Not sure if this is the desired semantics, but it's what we
+    // do for gDSFP. I can't remember why.
+
+    if (hook.baseQueue === null) {
+      hook.baseState = newState;
+    }
+
+    queue.lastRenderedState = newState;
+  }
+
+  return [newState, dispatch];
+}
+
+function mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  const fiber = currentlyRenderingFiber$1;
+  const hook = mountWorkInProgressHook();
+  let nextSnapshot;
+  const isHydrating = getIsHydrating();
+
+  if (isHydrating) {
+    if (getServerSnapshot === undefined) {
+      throw Error(formatProdErrorMessage(407));
+    }
+
+    nextSnapshot = getServerSnapshot();
+  } else {
+    nextSnapshot = getSnapshot();
+    // Right before committing, we will walk the tree and check if any of the
+    // stores were mutated.
+    //
+    // We won't do this if we're hydrating server-rendered content, because if
+    // the content is stale, it's already visible anyway. Instead we'll patch
+    // it up in a passive effect.
+
+
+    const root = getWorkInProgressRoot();
+
+    if (root === null) {
+      throw Error(formatProdErrorMessage(349));
+    }
+
+    const rootRenderLanes = getWorkInProgressRootRenderLanes();
+
+    if (!includesBlockingLane(root, rootRenderLanes)) {
+      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+    }
+  } // Read the current snapshot from the store on every render. This breaks the
+  // normal rules of React, and only works because store updates are
+  // always synchronous.
+
+
+  hook.memoizedState = nextSnapshot;
+  const inst = {
+    value: nextSnapshot,
+    getSnapshot
+  };
+  hook.queue = inst; // Schedule an effect to subscribe to the store.
+
+  mountEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [subscribe]); // Schedule an effect to update the mutable instance fields. We will update
+  // this whenever subscribe, getSnapshot, or value changes. Because there's no
+  // clean-up function, and we track the deps correctly, we can call pushEffect
+  // directly, without storing any additional state. For the same reason, we
+  // don't need to set a static flag, either.
+
+  fiber.flags |= Passive$1;
+  pushEffect(HasEffect | Passive, updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot), createEffectInstance(), null);
+  return nextSnapshot;
+}
+
+function updateSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  const fiber = currentlyRenderingFiber$1;
+  const hook = updateWorkInProgressHook(); // Read the current snapshot from the store on every render. This breaks the
+  // normal rules of React, and only works because store updates are
+  // always synchronous.
+
+  let nextSnapshot;
+  const isHydrating = getIsHydrating();
+
+  if (isHydrating) {
+    // Needed for strict mode double render
+    if (getServerSnapshot === undefined) {
+      throw Error(formatProdErrorMessage(407));
+    }
+
+    nextSnapshot = getServerSnapshot();
+  } else {
+    nextSnapshot = getSnapshot();
+  }
+
+  const prevSnapshot = (currentHook || hook).memoizedState;
+  const snapshotChanged = !objectIs(prevSnapshot, nextSnapshot);
+
+  if (snapshotChanged) {
+    hook.memoizedState = nextSnapshot;
+    markWorkInProgressReceivedUpdate();
+  }
+
+  const inst = hook.queue;
+  updateEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [subscribe]); // Whenever getSnapshot or subscribe changes, we need to check in the
+  // commit phase if there was an interleaved mutation. In concurrent mode
+  // this can happen all the time, but even in synchronous mode, an earlier
+  // effect may have mutated the store.
+
+  if (inst.getSnapshot !== getSnapshot || snapshotChanged || // Check if the subscribe function changed. We can save some memory by
+  // checking whether we scheduled a subscription effect above.
+  workInProgressHook !== null && workInProgressHook.memoizedState.tag & HasEffect) {
+    fiber.flags |= Passive$1;
+    pushEffect(HasEffect | Passive, updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot), createEffectInstance(), null); // Unless we're rendering a blocking lane, schedule a consistency check.
+    // Right before committing, we will walk the tree and check if any of the
+    // stores were mutated.
+
+    const root = getWorkInProgressRoot();
+
+    if (root === null) {
+      throw Error(formatProdErrorMessage(349));
+    }
+
+    if (!isHydrating && !includesBlockingLane(root, renderLanes)) {
+      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+    }
+  }
+
+  return nextSnapshot;
+}
+
+function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
+  fiber.flags |= StoreConsistency;
+  const check = {
+    getSnapshot,
+    value: renderedSnapshot
+  };
+  let componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.stores = [check];
+  } else {
+    const stores = componentUpdateQueue.stores;
+
+    if (stores === null) {
+      componentUpdateQueue.stores = [check];
+    } else {
+      stores.push(check);
+    }
+  }
+}
+
+function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
+  // These are updated in the passive phase
+  inst.value = nextSnapshot;
+  inst.getSnapshot = getSnapshot; // Something may have been mutated in between render and commit. This could
+  // have been in an event that fired before the passive effects, or it could
+  // have been in a layout effect. In that case, we would have used the old
+  // snapsho and getSnapshot values to bail out. We need to check one more time.
+
+  if (checkIfSnapshotChanged(inst)) {
+    // Force a re-render.
+    forceStoreRerender(fiber);
+  }
+}
+
+function subscribeToStore(fiber, inst, subscribe) {
+  const handleStoreChange = () => {
+    // The store changed. Check if the snapshot changed since the last time we
+    // read from the store.
+    if (checkIfSnapshotChanged(inst)) {
+      // Force a re-render.
+      forceStoreRerender(fiber);
+    }
+  }; // Subscribe to the store and return a clean-up function.
+
+
+  return subscribe(handleStoreChange);
+}
+
+function checkIfSnapshotChanged(inst) {
+  const latestGetSnapshot = inst.getSnapshot;
+  const prevValue = inst.value;
+
+  try {
+    const nextValue = latestGetSnapshot();
+    return !objectIs(prevValue, nextValue);
+  } catch (error) {
+    return true;
+  }
+}
+
+function forceStoreRerender(fiber) {
+  const root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, fiber, SyncLane);
+  }
+}
+
+function mountStateImpl(initialState) {
+  const hook = mountWorkInProgressHook();
+
+  if (typeof initialState === 'function') {
+    // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
+    initialState = initialState();
+  }
+
+  hook.memoizedState = hook.baseState = initialState;
+  const queue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    lastRenderedReducer: basicStateReducer,
+    lastRenderedState: initialState
+  };
+  hook.queue = queue;
+  return hook;
+}
+
+function mountState(initialState) {
+  const hook = mountStateImpl(initialState);
+  const queue = hook.queue;
+  const dispatch = dispatchSetState.bind(null, currentlyRenderingFiber$1, queue);
+  queue.dispatch = dispatch;
+  return [hook.memoizedState, dispatch];
+}
+
+function updateState(initialState) {
+  return updateReducer(basicStateReducer);
+}
+
+function rerenderState(initialState) {
+  return rerenderReducer(basicStateReducer);
+}
+
+function mountOptimistic(passthrough, reducer) {
+  const hook = mountWorkInProgressHook();
+  hook.memoizedState = hook.baseState = passthrough;
+  const queue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    // Optimistic state does not use the eager update optimization.
+    lastRenderedReducer: null,
+    lastRenderedState: null
+  };
+  hook.queue = queue; // This is different than the normal setState function.
+
+  const dispatch = dispatchOptimisticSetState.bind(null, currentlyRenderingFiber$1, true, queue);
+  queue.dispatch = dispatch;
+  return [passthrough, dispatch];
+}
+
+function updateOptimistic(passthrough, reducer) {
+  const hook = updateWorkInProgressHook();
+  return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
+}
+
+function updateOptimisticImpl(hook, current, passthrough, reducer) {
+  // Optimistic updates are always rebased on top of the latest value passed in
+  // as an argument. It's called a passthrough because if there are no pending
+  // updates, it will be returned as-is.
+  //
+  // Reset the base state to the passthrough. Future updates will be applied
+  // on top of this.
+  hook.baseState = passthrough; // If a reducer is not provided, default to the same one used by useState.
+
+  const resolvedReducer = typeof reducer === 'function' ? reducer : basicStateReducer;
+  return updateReducerImpl(hook, currentHook, resolvedReducer);
+}
+
+function rerenderOptimistic(passthrough, reducer) {
+  // Unlike useState, useOptimistic doesn't support render phase updates.
+  // Also unlike useState, we need to replay all pending updates again in case
+  // the passthrough value changed.
+  //
+  // So instead of a forked re-render implementation that knows how to handle
+  // render phase udpates, we can use the same implementation as during a
+  // regular mount or update.
+  const hook = updateWorkInProgressHook();
+
+  if (currentHook !== null) {
+    // This is an update. Process the update queue.
+    return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
+  } // This is a mount. No updates to process.
+  // Reset the base state to the passthrough. Future updates will be applied
+  // on top of this.
+
+
+  hook.baseState = passthrough;
+  const dispatch = hook.queue.dispatch;
+  return [passthrough, dispatch];
+} // useFormState actions run sequentially, because each action receives the
+// previous state as an argument. We store pending actions on a queue.
+
+
+function dispatchFormState(fiber, actionQueue, setState, payload) {
+  if (isRenderPhaseUpdate(fiber)) {
+    throw Error(formatProdErrorMessage(485));
+  }
+
+  const last = actionQueue.pending;
+
+  if (last === null) {
+    // There are no pending actions; this is the first one. We can run
+    // it immediately.
+    const newLast = {
+      payload,
+      next: null // circular
+
+    };
+    newLast.next = actionQueue.pending = newLast;
+    runFormStateAction(actionQueue, setState, payload);
+  } else {
+    // There's already an action running. Add to the queue.
+    const first = last.next;
+    const newLast = {
+      payload,
+      next: first
+    };
+    actionQueue.pending = last.next = newLast;
+  }
+}
+
+function runFormStateAction(actionQueue, setState, payload) {
+  const action = actionQueue.action;
+  const prevState = actionQueue.state; // This is a fork of startTransition
+
+  const prevTransition = ReactCurrentBatchConfig$3.transition;
+  ReactCurrentBatchConfig$3.transition = {};
+
+  try {
+    const returnValue = action(prevState, payload);
+
+    if (returnValue !== null && typeof returnValue === 'object' && // $FlowFixMe[method-unbinding]
+    typeof returnValue.then === 'function') {
+      const thenable = returnValue; // Attach a listener to read the return state of the action. As soon as
+      // this resolves, we can run the next action in the sequence.
+
+      thenable.then(nextState => {
+        actionQueue.state = nextState;
+        finishRunningFormStateAction(actionQueue, setState);
+      }, () => finishRunningFormStateAction(actionQueue, setState));
+      const entangledResult = requestAsyncActionContext(thenable, null);
+      setState(entangledResult);
+    } else {
+      // This is either `returnValue` or a thenable that resolves to
+      // `returnValue`, depending on whether we're inside an async action scope.
+      const entangledResult = requestSyncActionContext(returnValue, null);
+      setState(entangledResult);
+      const nextState = returnValue;
+      actionQueue.state = nextState;
+      finishRunningFormStateAction(actionQueue, setState);
+    }
+  } catch (error) {
+    // This is a trick to get the `useFormState` hook to rethrow the error.
+    // When it unwraps the thenable with the `use` algorithm, the error
+    // will be thrown.
+    const rejectedThenable = {
+      then() {},
+
+      status: 'rejected',
+      reason: error // $FlowFixMe: Not sure why this doesn't work
+
+    };
+    setState(rejectedThenable);
+    finishRunningFormStateAction(actionQueue, setState);
+  } finally {
+    ReactCurrentBatchConfig$3.transition = prevTransition;
+  }
+}
+
+function finishRunningFormStateAction(actionQueue, setState) {
+  // The action finished running. Pop it from the queue and run the next pending
+  // action, if there are any.
+  const last = actionQueue.pending;
+
+  if (last !== null) {
+    const first = last.next;
+
+    if (first === last) {
+      // This was the last action in the queue.
+      actionQueue.pending = null;
+    } else {
+      // Remove the first node from the circular queue.
+      const next = first.next;
+      last.next = next; // Run the next action.
+
+      runFormStateAction(actionQueue, setState, next.payload);
+    }
+  }
+}
+
+function formStateReducer(oldState, newState) {
+  return newState;
+}
+
+function mountFormState(action, initialStateProp, permalink) {
+  let initialState = initialStateProp;
+
+  if (getIsHydrating()) {
+    const root = getWorkInProgressRoot();
+    const ssrFormState = root.formState; // If a formState option was passed to the root, there are form state
+    // markers that we need to hydrate. These indicate whether the form state
+    // matches this hook instance.
+
+    if (ssrFormState !== null) {
+      const isMatching = tryToClaimNextHydratableFormMarkerInstance();
+
+      if (isMatching) {
+        initialState = ssrFormState[0];
+      }
+    }
+  } // State hook. The state is stored in a thenable which is then unwrapped by
+  // the `use` algorithm during render.
+
+
+  const stateHook = mountWorkInProgressHook();
+  stateHook.memoizedState = stateHook.baseState = initialState; // TODO: Typing this "correctly" results in recursion limit errors
+  // const stateQueue: UpdateQueue<S | Awaited<S>, S | Awaited<S>> = {
+
+  const stateQueue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    lastRenderedReducer: formStateReducer,
+    lastRenderedState: initialState
+  };
+  stateHook.queue = stateQueue;
+  const setState = dispatchSetState.bind(null, currentlyRenderingFiber$1, stateQueue);
+  stateQueue.dispatch = setState; // Action queue hook. This is used to queue pending actions. The queue is
+  // shared between all instances of the hook. Similar to a regular state queue,
+  // but different because the actions are run sequentially, and they run in
+  // an event instead of during render.
+
+  const actionQueueHook = mountWorkInProgressHook();
+  const actionQueue = {
+    state: initialState,
+    dispatch: null,
+    // circular
+    action,
+    pending: null
+  };
+  actionQueueHook.queue = actionQueue;
+  const dispatch = dispatchFormState.bind(null, currentlyRenderingFiber$1, actionQueue, setState);
+  actionQueue.dispatch = dispatch; // Stash the action function on the memoized state of the hook. We'll use this
+  // to detect when the action function changes so we can update it in
+  // an effect.
+
+  actionQueueHook.memoizedState = action;
+  return [initialState, dispatch];
+}
+
+function updateFormState(action, initialState, permalink) {
+  const stateHook = updateWorkInProgressHook();
+  const currentStateHook = currentHook;
+  return updateFormStateImpl(stateHook, currentStateHook, action);
+}
+
+function updateFormStateImpl(stateHook, currentStateHook, action, initialState, permalink) {
+  const _updateReducerImpl = updateReducerImpl(stateHook, currentStateHook, formStateReducer),
+        actionResult = _updateReducerImpl[0]; // This will suspend until the action finishes.
+
+
+  const state = typeof actionResult === 'object' && actionResult !== null && // $FlowFixMe[method-unbinding]
+  typeof actionResult.then === 'function' ? useThenable(actionResult) : actionResult;
+  const actionQueueHook = updateWorkInProgressHook();
+  const actionQueue = actionQueueHook.queue;
+  const dispatch = actionQueue.dispatch; // Check if a new action was passed. If so, update it in an effect.
+
+  const prevAction = actionQueueHook.memoizedState;
+
+  if (action !== prevAction) {
+    currentlyRenderingFiber$1.flags |= Passive$1;
+    pushEffect(HasEffect | Passive, formStateActionEffect.bind(null, actionQueue, action), createEffectInstance(), null);
+  }
+
+  return [state, dispatch];
+}
+
+function formStateActionEffect(actionQueue, action) {
+  actionQueue.action = action;
+}
+
+function rerenderFormState(action, initialState, permalink) {
+  // Unlike useState, useFormState doesn't support render phase updates.
+  // Also unlike useState, we need to replay all pending updates again in case
+  // the passthrough value changed.
+  //
+  // So instead of a forked re-render implementation that knows how to handle
+  // render phase udpates, we can use the same implementation as during a
+  // regular mount or update.
+  const stateHook = updateWorkInProgressHook();
+  const currentStateHook = currentHook;
+
+  if (currentStateHook !== null) {
+    // This is an update. Process the update queue.
+    return updateFormStateImpl(stateHook, currentStateHook, action);
+  } // This is a mount. No updates to process.
+
+
+  const state = stateHook.memoizedState;
+  const actionQueueHook = updateWorkInProgressHook();
+  const actionQueue = actionQueueHook.queue;
+  const dispatch = actionQueue.dispatch; // This may have changed during the rerender.
+
+  actionQueueHook.memoizedState = action;
+  return [state, dispatch];
+}
+
+function pushEffect(tag, create, inst, deps) {
+  const effect = {
+    tag,
+    create,
+    inst,
+    deps,
+    // Circular
+    next: null
+  };
+  let componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.lastEffect = effect.next = effect;
+  } else {
+    const lastEffect = componentUpdateQueue.lastEffect;
+
+    if (lastEffect === null) {
+      componentUpdateQueue.lastEffect = effect.next = effect;
+    } else {
+      const firstEffect = lastEffect.next;
+      lastEffect.next = effect;
+      effect.next = firstEffect;
+      componentUpdateQueue.lastEffect = effect;
+    }
+  }
+
+  return effect;
+}
+
+function createEffectInstance() {
+  return {
+    destroy: undefined
+  };
+}
+
+function mountRef(initialValue) {
+  const hook = mountWorkInProgressHook();
+
+  {
+    const ref = {
+      current: initialValue
+    };
+    hook.memoizedState = ref;
+    return ref;
+  }
+}
+
+function updateRef(initialValue) {
+  const hook = updateWorkInProgressHook();
+  return hook.memoizedState;
+}
+
+function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
+  const hook = mountWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(HasEffect | hookFlags, create, createEffectInstance(), nextDeps);
+}
+
+function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
+  const hook = updateWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  const effect = hook.memoizedState;
+  const inst = effect.inst; // currentHook is null on initial mount when rerendering after a render phase
+  // state update or for strict mode.
+
+  if (currentHook !== null) {
+    if (nextDeps !== null) {
+      const prevEffect = currentHook.memoizedState;
+      const prevDeps = prevEffect.deps;
+
+      if (areHookInputsEqual(nextDeps, prevDeps)) {
+        hook.memoizedState = pushEffect(hookFlags, create, inst, nextDeps);
+        return;
+      }
+    }
+  }
+
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(HasEffect | hookFlags, create, inst, nextDeps);
+}
+
+function mountEffect(create, deps) {
+  {
+    mountEffectImpl(Passive$1 | PassiveStatic, Passive, create, deps);
+  }
+}
+
+function updateEffect(create, deps) {
+  updateEffectImpl(Passive$1, Passive, create, deps);
+}
+
+function mountInsertionEffect(create, deps) {
+  mountEffectImpl(Update, Insertion, create, deps);
+}
+
+function updateInsertionEffect(create, deps) {
+  return updateEffectImpl(Update, Insertion, create, deps);
+}
+
+function mountLayoutEffect(create, deps) {
+  let fiberFlags = Update | LayoutStatic;
+
+  return mountEffectImpl(fiberFlags, Layout, create, deps);
+}
+
+function updateLayoutEffect(create, deps) {
+  return updateEffectImpl(Update, Layout, create, deps);
+}
+
+function imperativeHandleEffect(create, ref) {
+  if (typeof ref === 'function') {
+    const refCallback = ref;
+    const inst = create();
+    refCallback(inst);
+    return () => {
+      refCallback(null);
+    };
+  } else if (ref !== null && ref !== undefined) {
+    const refObject = ref;
+
+    const inst = create();
+    refObject.current = inst;
+    return () => {
+      refObject.current = null;
+    };
+  }
+}
+
+function mountImperativeHandle(ref, create, deps) {
+
+
+  const effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+  let fiberFlags = Update | LayoutStatic;
+
+  mountEffectImpl(fiberFlags, Layout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
+}
+
+function updateImperativeHandle(ref, create, deps) {
+
+
+  const effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+  updateEffectImpl(Update, Layout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
+}
+
+function mountDebugValue(value, formatterFn) {// This hook is normally a no-op.
+  // The react-debug-hooks package injects its own implementation
+  // so that e.g. DevTools can display custom hook values.
+}
+
+const updateDebugValue = mountDebugValue;
+
+function mountCallback(callback, deps) {
+  const hook = mountWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  hook.memoizedState = [callback, nextDeps];
+  return callback;
+}
+
+function updateCallback(callback, deps) {
+  const hook = updateWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  const prevState = hook.memoizedState;
+
+  if (nextDeps !== null) {
+    const prevDeps = prevState[1];
+
+    if (areHookInputsEqual(nextDeps, prevDeps)) {
+      return prevState[0];
+    }
+  }
+
+  hook.memoizedState = [callback, nextDeps];
+  return callback;
+}
+
+function mountMemo(nextCreate, deps) {
+  const hook = mountWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+
+  if (shouldDoubleInvokeUserFnsInHooksDEV) {
+    nextCreate();
+  }
+
+  const nextValue = nextCreate();
+  hook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
+
+function updateMemo(nextCreate, deps) {
+  const hook = updateWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  const prevState = hook.memoizedState; // Assume these are defined. If they're not, areHookInputsEqual will warn.
+
+  if (nextDeps !== null) {
+    const prevDeps = prevState[1];
+
+    if (areHookInputsEqual(nextDeps, prevDeps)) {
+      return prevState[0];
+    }
+  }
+
+  if (shouldDoubleInvokeUserFnsInHooksDEV) {
+    nextCreate();
+  }
+
+  const nextValue = nextCreate();
+  hook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
+
+function mountDeferredValue(value, initialValue) {
+  const hook = mountWorkInProgressHook();
+  return mountDeferredValueImpl(hook, value);
+}
+
+function updateDeferredValue(value, initialValue) {
+  const hook = updateWorkInProgressHook();
+  const resolvedCurrentHook = currentHook;
+  const prevValue = resolvedCurrentHook.memoizedState;
+  return updateDeferredValueImpl(hook, prevValue, value);
+}
+
+function rerenderDeferredValue(value, initialValue) {
+  const hook = updateWorkInProgressHook();
+
+  if (currentHook === null) {
+    // This is a rerender during a mount.
+    return mountDeferredValueImpl(hook, value);
+  } else {
+    // This is a rerender during an update.
+    const prevValue = currentHook.memoizedState;
+    return updateDeferredValueImpl(hook, prevValue, value);
+  }
+}
+
+function mountDeferredValueImpl(hook, value, initialValue) {
+  {
+    hook.memoizedState = value;
+    return value;
+  }
+}
+
+function updateDeferredValueImpl(hook, prevValue, value, initialValue) {
+  if (objectIs(value, prevValue)) {
+    // The incoming value is referentially identical to the currently rendered
+    // value, so we can bail out quickly.
+    return value;
+  } else {
+    // Received a new value that's different from the current value.
+    // Check if we're inside a hidden tree
+    if (isCurrentTreeHidden()) {
+      // Revealing a prerendered tree is considered the same as mounting new
+      // one, so we reuse the "mount" path in this case.
+      const resultValue = mountDeferredValueImpl(hook, value); // Unlike during an actual mount, we need to mark this as an update if
+      // the value changed.
+
+      if (!objectIs(resultValue, prevValue)) {
+        markWorkInProgressReceivedUpdate();
+      }
+
+      return resultValue;
+    }
+
+    const shouldDeferValue = !includesOnlyNonUrgentLanes(renderLanes);
+
+    if (shouldDeferValue) {
+      // This is an urgent update. Since the value has changed, keep using the
+      // previous value and spawn a deferred render to update it later.
+      // Schedule a deferred render
+      const deferredLane = requestDeferredLane();
+      currentlyRenderingFiber$1.lanes = mergeLanes(currentlyRenderingFiber$1.lanes, deferredLane);
+      markSkippedUpdateLanes(deferredLane); // Reuse the previous value. We do not need to mark this as an update,
+      // because we did not render a new value.
+
+      return prevValue;
+    } else {
+      // This is not an urgent update, so we can use the latest value regardless
+      // of what it is. No need to defer it.
+      // Mark this as an update to prevent the fiber from bailing out.
+      markWorkInProgressReceivedUpdate();
+      hook.memoizedState = value;
+      return value;
+    }
+  }
+}
+
+function startTransition(fiber, queue, pendingState, finishedState, callback, options) {
+  const previousPriority = getCurrentUpdatePriority();
+  setCurrentUpdatePriority(higherEventPriority(previousPriority, ContinuousEventPriority));
+  const prevTransition = ReactCurrentBatchConfig$3.transition;
+  const currentTransition = {};
+
+  {
+    // We don't really need to use an optimistic update here, because we
+    // schedule a second "revert" update below (which we use to suspend the
+    // transition until the async action scope has finished). But we'll use an
+    // optimistic update anyway to make it less likely the behavior accidentally
+    // diverges; for example, both an optimistic update and this one should
+    // share the same lane.
+    ReactCurrentBatchConfig$3.transition = currentTransition;
+    dispatchOptimisticSetState(fiber, false, queue, pendingState);
+  }
+
+  try {
+    if (enableAsyncActions) {
+      const returnValue = callback(); // Check if we're inside an async action scope. If so, we'll entangle
+      // this new action with the existing scope.
+      //
+      // If we're not already inside an async action scope, and this action is
+      // async, then we'll create a new async scope.
+      //
+      // In the async case, the resulting render will suspend until the async
+      // action scope has finished.
+
+      if (returnValue !== null && typeof returnValue === 'object' && typeof returnValue.then === 'function') {
+        const thenable = returnValue; // This is a thenable that resolves to `finishedState` once the async
+        // action scope has finished.
+
+        const entangledResult = requestAsyncActionContext(thenable, finishedState);
+        dispatchSetState(fiber, queue, entangledResult);
+      } else {
+        // This is either `finishedState` or a thenable that resolves to
+        // `finishedState`, depending on whether we're inside an async
+        // action scope.
+        const entangledResult = requestSyncActionContext(returnValue, finishedState);
+        dispatchSetState(fiber, queue, entangledResult);
+      }
+    }
+  } catch (error) {
+    {
+      // This is a trick to get the `useTransition` hook to rethrow the error.
+      // When it unwraps the thenable with the `use` algorithm, the error
+      // will be thrown.
+      const rejectedThenable = {
+        then() {},
+
+        status: 'rejected',
+        reason: error
+      };
+      dispatchSetState(fiber, queue, rejectedThenable);
+    }
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$3.transition = prevTransition;
+  }
+}
+
+function startHostTransition(formFiber, pendingState, callback, formData) {
+
+  if (formFiber.tag !== HostComponent) {
+    throw Error(formatProdErrorMessage(476));
+  }
+
+  let queue;
+
+  if (formFiber.memoizedState === null) {
+    // Upgrade this host component fiber to be stateful. We're going to pretend
+    // it was stateful all along so we can reuse most of the implementation
+    // for function components and useTransition.
+    //
+    // Create the state hook used by TransitionAwareHostComponent. This is
+    // essentially an inlined version of mountState.
+    const newQueue = {
+      pending: null,
+      lanes: NoLanes,
+      // We're going to cheat and intentionally not create a bound dispatch
+      // method, because we can call it directly in startTransition.
+      dispatch: null,
+      lastRenderedReducer: basicStateReducer,
+      lastRenderedState: NotPendingTransition
+    };
+    queue = newQueue;
+    const stateHook = {
+      memoizedState: NotPendingTransition,
+      baseState: NotPendingTransition,
+      baseQueue: null,
+      queue: newQueue,
+      next: null
+    }; // Add the state hook to both fiber alternates. The idea is that the fiber
+    // had this hook all along.
+
+    formFiber.memoizedState = stateHook;
+    const alternate = formFiber.alternate;
+
+    if (alternate !== null) {
+      alternate.memoizedState = stateHook;
+    }
+  } else {
+    // This fiber was already upgraded to be stateful.
+    const stateHook = formFiber.memoizedState;
+    queue = stateHook.queue;
+  }
+
+  startTransition(formFiber, queue, pendingState, NotPendingTransition, // TODO: We can avoid this extra wrapper, somehow. Figure out layering
+  // once more of this function is implemented.
+  () => callback(formData));
+}
+
+function mountTransition() {
+  const stateHook = mountStateImpl(false); // The `start` method never changes.
+
+  const start = startTransition.bind(null, currentlyRenderingFiber$1, stateHook.queue, true, false);
+  const hook = mountWorkInProgressHook();
+  hook.memoizedState = start;
+  return [false, start];
+}
+
+function updateTransition() {
+  const _updateState = updateState(),
+        booleanOrThenable = _updateState[0];
+
+  const hook = updateWorkInProgressHook();
+  const start = hook.memoizedState;
+  const isPending = typeof booleanOrThenable === 'boolean' ? booleanOrThenable : // This will suspend until the async action scope has finished.
+  useThenable(booleanOrThenable);
+  return [isPending, start];
+}
+
+function rerenderTransition() {
+  const _rerenderState = rerenderState(),
+        booleanOrThenable = _rerenderState[0];
+
+  const hook = updateWorkInProgressHook();
+  const start = hook.memoizedState;
+  const isPending = typeof booleanOrThenable === 'boolean' ? booleanOrThenable : // This will suspend until the async action scope has finished.
+  useThenable(booleanOrThenable);
+  return [isPending, start];
+}
+
+function useHostTransitionStatus() {
+
+  const status = readContext(HostTransitionContext);
+  return status !== null ? status : NotPendingTransition;
+}
+
+function mountId() {
+  const hook = mountWorkInProgressHook();
+  const root = getWorkInProgressRoot(); // TODO: In Fizz, id generation is specific to each server config. Maybe we
+  // should do this in Fiber, too? Deferring this decision for now because
+  // there's no other place to store the prefix except for an internal field on
+  // the public createRoot object, which the fiber tree does not currently have
+  // a reference to.
+
+  const identifierPrefix = root.identifierPrefix;
+  let id;
+
+  if (getIsHydrating()) {
+    const treeId = getTreeId(); // Use a captial R prefix for server-generated ids.
+
+    id = ':' + identifierPrefix + 'R' + treeId; // Unless this is the first id at this level, append a number at the end
+    // that represents the position of this useId hook among all the useId
+    // hooks for this fiber.
+
+    const localId = localIdCounter++;
+
+    if (localId > 0) {
+      id += 'H' + localId.toString(32);
+    }
+
+    id += ':';
+  } else {
+    // Use a lowercase r prefix for client-generated ids.
+    const globalClientId = globalClientIdCounter++;
+    id = ':' + identifierPrefix + 'r' + globalClientId.toString(32) + ':';
+  }
+
+  hook.memoizedState = id;
+  return id;
+}
+
+function updateId() {
+  const hook = updateWorkInProgressHook();
+  const id = hook.memoizedState;
+  return id;
+}
+
+function mountRefresh() {
+  const hook = mountWorkInProgressHook();
+  const refresh = hook.memoizedState = refreshCache.bind(null, currentlyRenderingFiber$1);
+  return refresh;
+}
+
+function updateRefresh() {
+  const hook = updateWorkInProgressHook();
+  return hook.memoizedState;
+}
+
+function refreshCache(fiber, seedKey, seedValue) {
+  // TODO: Consider warning if the refresh is at discrete priority, or if we
+  // otherwise suspect that it wasn't batched properly.
+
+
+  let provider = fiber.return;
+
+  while (provider !== null) {
+    switch (provider.tag) {
+      case CacheComponent:
+      case HostRoot:
+        {
+          // Schedule an update on the cache boundary to trigger a refresh.
+          const lane = requestUpdateLane(provider);
+          const refreshUpdate = createUpdate(lane);
+          const root = enqueueUpdate(provider, refreshUpdate, lane);
+
+          if (root !== null) {
+            scheduleUpdateOnFiber(root, provider, lane);
+            entangleTransitions(root, provider, lane);
+          } // TODO: If a refresh never commits, the new cache created here must be
+          // released. A simple case is start refreshing a cache boundary, but then
+          // unmount that boundary before the refresh completes.
+
+
+          const seededCache = createCache();
+
+          const payload = {
+            cache: seededCache
+          };
+          refreshUpdate.payload = payload;
+          return;
+        }
+    }
+
+    provider = provider.return;
+  } // TODO: Warn if unmounted?
+
+}
+
+function dispatchReducerAction(fiber, queue, action) {
+
+  const lane = requestUpdateLane(fiber);
+  const update = {
+    lane,
+    revertLane: NoLane,
+    action,
+    hasEagerState: false,
+    eagerState: null,
+    next: null
+  };
+
+  if (isRenderPhaseUpdate(fiber)) {
+    enqueueRenderPhaseUpdate(queue, update);
+  } else {
+    const root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitionUpdate(root, queue, lane);
+    }
+  }
+}
+
+function dispatchSetState(fiber, queue, action) {
+
+  const lane = requestUpdateLane(fiber);
+  const update = {
+    lane,
+    revertLane: NoLane,
+    action,
+    hasEagerState: false,
+    eagerState: null,
+    next: null
+  };
+
+  if (isRenderPhaseUpdate(fiber)) {
+    enqueueRenderPhaseUpdate(queue, update);
+  } else {
+    const alternate = fiber.alternate;
+
+    if (fiber.lanes === NoLanes && (alternate === null || alternate.lanes === NoLanes)) {
+      // The queue is currently empty, which means we can eagerly compute the
+      // next state before entering the render phase. If the new state is the
+      // same as the current state, we may be able to bail out entirely.
+      const lastRenderedReducer = queue.lastRenderedReducer;
+
+      if (lastRenderedReducer !== null) {
+
+        try {
+          const currentState = queue.lastRenderedState;
+          const eagerState = lastRenderedReducer(currentState, action); // Stash the eagerly computed state, and the reducer used to compute
+          // it, on the update object. If the reducer hasn't changed by the
+          // time we enter the render phase, then the eager state can be used
+          // without calling the reducer again.
+
+          update.hasEagerState = true;
+          update.eagerState = eagerState;
+
+          if (objectIs(eagerState, currentState)) {
+            // Fast path. We can bail out without scheduling React to re-render.
+            // It's still possible that we'll need to rebase this update later,
+            // if the component re-renders for a different reason and by that
+            // time the reducer has changed.
+            // TODO: Do we still need to entangle transitions in this case?
+            enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update);
+            return;
+          }
+        } catch (error) {// Suppress the error. It will throw again in the render phase.
+        } finally {
+        }
+      }
+    }
+
+    const root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitionUpdate(root, queue, lane);
+    }
+  }
+}
+
+function dispatchOptimisticSetState(fiber, throwIfDuringRender, queue, action) {
+
+  const update = {
+    // An optimistic update commits synchronously.
+    lane: SyncLane,
+    // After committing, the optimistic update is "reverted" using the same
+    // lane as the transition it's associated with.
+    revertLane: requestTransitionLane(),
+    action,
+    hasEagerState: false,
+    eagerState: null,
+    next: null
+  };
+
+  if (isRenderPhaseUpdate(fiber)) {
+    // When calling startTransition during render, this warns instead of
+    // throwing because throwing would be a breaking change. setOptimisticState
+    // is a new API so it's OK to throw.
+    if (throwIfDuringRender) {
+      throw Error(formatProdErrorMessage(479));
+    }
+  } else {
+    const root = enqueueConcurrentHookUpdate(fiber, queue, update, SyncLane);
+
+    if (root !== null) {
+      // NOTE: The optimistic update implementation assumes that the transition
+      // will never be attempted before the optimistic update. This currently
+      // holds because the optimistic update is always synchronous. If we ever
+      // change that, we'll need to account for this.
+      scheduleUpdateOnFiber(root, fiber, SyncLane); // Optimistic updates are always synchronous, so we don't need to call
+      // entangleTransitionUpdate here.
+    }
+  }
+}
+
+function isRenderPhaseUpdate(fiber) {
+  const alternate = fiber.alternate;
+  return fiber === currentlyRenderingFiber$1 || alternate !== null && alternate === currentlyRenderingFiber$1;
+}
+
+function enqueueRenderPhaseUpdate(queue, update) {
+  // This is a render phase update. Stash it in a lazily-created map of
+  // queue -> linked list of updates. After this render pass, we'll restart
+  // and apply the stashed updates on top of the work-in-progress hook.
+  didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate = true;
+  const pending = queue.pending;
+
+  if (pending === null) {
+    // This is the first update. Create a circular list.
+    update.next = update;
+  } else {
+    update.next = pending.next;
+    pending.next = update;
+  }
+
+  queue.pending = update;
+} // TODO: Move to ReactFiberConcurrentUpdates?
+
+
+function entangleTransitionUpdate(root, queue, lane) {
+  if (isTransitionLane(lane)) {
+    let queueLanes = queue.lanes; // If any entangled lanes are no longer pending on the root, then they
+    // must have finished. We can remove them from the shared queue, which
+    // represents a superset of the actually pending lanes. In some cases we
+    // may entangle more than we need to, but that's OK. In fact it's worse if
+    // we *don't* entangle when we should.
+
+    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.
+
+    const newQueueLanes = mergeLanes(queueLanes, lane);
+    queue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if
+    // the lane finished since the last time we entangled it. So we need to
+    // entangle it again, just to be sure.
+
+    markRootEntangled(root, newQueueLanes);
+  }
+}
+
+const ContextOnlyDispatcher = {
+  readContext,
+  use,
+  useCallback: throwInvalidHookError,
+  useContext: throwInvalidHookError,
+  useEffect: throwInvalidHookError,
+  useImperativeHandle: throwInvalidHookError,
+  useInsertionEffect: throwInvalidHookError,
+  useLayoutEffect: throwInvalidHookError,
+  useMemo: throwInvalidHookError,
+  useReducer: throwInvalidHookError,
+  useRef: throwInvalidHookError,
+  useState: throwInvalidHookError,
+  useDebugValue: throwInvalidHookError,
+  useDeferredValue: throwInvalidHookError,
+  useTransition: throwInvalidHookError,
+  useSyncExternalStore: throwInvalidHookError,
+  useId: throwInvalidHookError
+};
+
+{
+  ContextOnlyDispatcher.useCacheRefresh = throwInvalidHookError;
+}
+
+{
+  ContextOnlyDispatcher.useHostTransitionStatus = throwInvalidHookError;
+  ContextOnlyDispatcher.useFormState = throwInvalidHookError;
+}
+
+{
+  ContextOnlyDispatcher.useOptimistic = throwInvalidHookError;
+}
+
+const HooksDispatcherOnMount = {
+  readContext,
+  use,
+  useCallback: mountCallback,
+  useContext: readContext,
+  useEffect: mountEffect,
+  useImperativeHandle: mountImperativeHandle,
+  useLayoutEffect: mountLayoutEffect,
+  useInsertionEffect: mountInsertionEffect,
+  useMemo: mountMemo,
+  useReducer: mountReducer,
+  useRef: mountRef,
+  useState: mountState,
+  useDebugValue: mountDebugValue,
+  useDeferredValue: mountDeferredValue,
+  useTransition: mountTransition,
+  useSyncExternalStore: mountSyncExternalStore,
+  useId: mountId
+};
+
+{
+  HooksDispatcherOnMount.useCacheRefresh = mountRefresh;
+}
+
+{
+  HooksDispatcherOnMount.useHostTransitionStatus = useHostTransitionStatus;
+  HooksDispatcherOnMount.useFormState = mountFormState;
+}
+
+{
+  HooksDispatcherOnMount.useOptimistic = mountOptimistic;
+}
+
+const HooksDispatcherOnUpdate = {
+  readContext,
+  use,
+  useCallback: updateCallback,
+  useContext: readContext,
+  useEffect: updateEffect,
+  useImperativeHandle: updateImperativeHandle,
+  useInsertionEffect: updateInsertionEffect,
+  useLayoutEffect: updateLayoutEffect,
+  useMemo: updateMemo,
+  useReducer: updateReducer,
+  useRef: updateRef,
+  useState: updateState,
+  useDebugValue: updateDebugValue,
+  useDeferredValue: updateDeferredValue,
+  useTransition: updateTransition,
+  useSyncExternalStore: updateSyncExternalStore,
+  useId: updateId
+};
+
+{
+  HooksDispatcherOnUpdate.useCacheRefresh = updateRefresh;
+}
+
+{
+  HooksDispatcherOnUpdate.useHostTransitionStatus = useHostTransitionStatus;
+  HooksDispatcherOnUpdate.useFormState = updateFormState;
+}
+
+{
+  HooksDispatcherOnUpdate.useOptimistic = updateOptimistic;
+}
+
+const HooksDispatcherOnRerender = {
+  readContext,
+  use,
+  useCallback: updateCallback,
+  useContext: readContext,
+  useEffect: updateEffect,
+  useImperativeHandle: updateImperativeHandle,
+  useInsertionEffect: updateInsertionEffect,
+  useLayoutEffect: updateLayoutEffect,
+  useMemo: updateMemo,
+  useReducer: rerenderReducer,
+  useRef: updateRef,
+  useState: rerenderState,
+  useDebugValue: updateDebugValue,
+  useDeferredValue: rerenderDeferredValue,
+  useTransition: rerenderTransition,
+  useSyncExternalStore: updateSyncExternalStore,
+  useId: updateId
+};
+
+{
+  HooksDispatcherOnRerender.useCacheRefresh = updateRefresh;
+}
+
+{
+  HooksDispatcherOnRerender.useHostTransitionStatus = useHostTransitionStatus;
+  HooksDispatcherOnRerender.useFormState = rerenderFormState;
+}
+
+{
+  HooksDispatcherOnRerender.useOptimistic = rerenderOptimistic;
+}
+
+function recordLayoutEffectDuration(fiber) {
+  {
+    return;
+  }
+}
+
+function startLayoutEffectTimer() {
+  {
+    return;
+  }
+}
+
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    // Resolve default props. Taken from ReactElement
+    const props = assign({}, baseProps);
+    const defaultProps = Component.defaultProps;
+
+    for (const propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+
+    return props;
+  }
+
+  return baseProps;
+}
+
+function applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, nextProps) {
+  const prevState = workInProgress.memoizedState;
+  let partialState = getDerivedStateFromProps(nextProps, prevState);
+
+
+  const memoizedState = partialState === null || partialState === undefined ? prevState : assign({}, prevState, partialState);
+  workInProgress.memoizedState = memoizedState; // Once the update queue is empty, persist the derived state onto the
+  // base state.
+
+  if (workInProgress.lanes === NoLanes) {
+    // Queue is always non-null for classes
+    const updateQueue = workInProgress.updateQueue;
+    updateQueue.baseState = memoizedState;
+  }
+}
+
+const classComponentUpdater = {
+  isMounted,
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueSetState(inst, payload, callback) {
+    const fiber = get(inst);
+    const lane = requestUpdateLane(fiber);
+    const update = createUpdate(lane);
+    update.payload = payload;
+
+    if (callback !== undefined && callback !== null) {
+
+      update.callback = callback;
+    }
+
+    const root = enqueueUpdate(fiber, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitions(root, fiber, lane);
+    }
+  },
+
+  enqueueReplaceState(inst, payload, callback) {
+    const fiber = get(inst);
+    const lane = requestUpdateLane(fiber);
+    const update = createUpdate(lane);
+    update.tag = ReplaceState;
+    update.payload = payload;
+
+    if (callback !== undefined && callback !== null) {
+
+      update.callback = callback;
+    }
+
+    const root = enqueueUpdate(fiber, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitions(root, fiber, lane);
+    }
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueForceUpdate(inst, callback) {
+    const fiber = get(inst);
+    const lane = requestUpdateLane(fiber);
+    const update = createUpdate(lane);
+    update.tag = ForceUpdate;
+
+    if (callback !== undefined && callback !== null) {
+
+      update.callback = callback;
+    }
+
+    const root = enqueueUpdate(fiber, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitions(root, fiber, lane);
+    }
+  }
+
+};
+
+function checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {
+  const instance = workInProgress.stateNode;
+
+  if (typeof instance.shouldComponentUpdate === 'function') {
+    let shouldUpdate = instance.shouldComponentUpdate(newProps, newState, nextContext);
+
+    return shouldUpdate;
+  }
+
+  if (ctor.prototype && ctor.prototype.isPureReactComponent) {
+    return !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState);
+  }
+
+  return true;
+}
+
+function adoptClassInstance(workInProgress, instance) {
+  instance.updater = classComponentUpdater;
+  workInProgress.stateNode = instance; // The instance needs access to the fiber so that it can schedule updates
+
+  set(instance, workInProgress);
+}
+
+function constructClassInstance(workInProgress, ctor, props) {
+  let isLegacyContextConsumer = false;
+  let unmaskedContext = emptyContextObject;
+  let context = emptyContextObject;
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    context = readContext(contextType);
+  } else {
+    unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    const contextTypes = ctor.contextTypes;
+    isLegacyContextConsumer = contextTypes !== null && contextTypes !== undefined;
+    context = isLegacyContextConsumer ? getMaskedContext(workInProgress, unmaskedContext) : emptyContextObject;
+  }
+
+  let instance = new ctor(props, context); // Instantiate twice to help detect side-effects.
+
+  workInProgress.memoizedState = instance.state !== null && instance.state !== undefined ? instance.state : null;
+  adoptClassInstance(workInProgress, instance);
+  // ReactFiberContext usually updates this cache but can't for newly-created instances.
+
+
+  if (isLegacyContextConsumer) {
+    cacheContext(workInProgress, unmaskedContext, context);
+  }
+
+  return instance;
+}
+
+function callComponentWillMount(workInProgress, instance) {
+  const oldState = instance.state;
+
+  if (typeof instance.componentWillMount === 'function') {
+    instance.componentWillMount();
+  }
+
+  if (typeof instance.UNSAFE_componentWillMount === 'function') {
+    instance.UNSAFE_componentWillMount();
+  }
+
+  if (oldState !== instance.state) {
+
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+}
+
+function callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {
+  const oldState = instance.state;
+
+  if (typeof instance.componentWillReceiveProps === 'function') {
+    instance.componentWillReceiveProps(newProps, nextContext);
+  }
+
+  if (typeof instance.UNSAFE_componentWillReceiveProps === 'function') {
+    instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+  }
+
+  if (instance.state !== oldState) {
+
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+} // Invokes the mount life-cycles on a previously never rendered instance.
+
+
+function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+
+  const instance = workInProgress.stateNode;
+  instance.props = newProps;
+  instance.state = workInProgress.memoizedState;
+  instance.refs = {};
+  initializeUpdateQueue(workInProgress);
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    instance.context = readContext(contextType);
+  } else {
+    const unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    instance.context = getMaskedContext(workInProgress, unmaskedContext);
+  }
+
+  instance.state = workInProgress.memoizedState;
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+    instance.state = workInProgress.memoizedState;
+  } // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+
+  if (typeof ctor.getDerivedStateFromProps !== 'function' && typeof instance.getSnapshotBeforeUpdate !== 'function' && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
+    callComponentWillMount(workInProgress, instance); // If we had additional state updates during this life-cycle, let's
+    // process them now.
+
+    processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+    instance.state = workInProgress.memoizedState;
+  }
+
+  if (typeof instance.componentDidMount === 'function') {
+    workInProgress.flags |= Update | LayoutStatic;
+  }
+}
+
+function resumeMountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+  const instance = workInProgress.stateNode;
+  const oldProps = workInProgress.memoizedProps;
+  instance.props = oldProps;
+  const oldContext = instance.context;
+  const contextType = ctor.contextType;
+  let nextContext = emptyContextObject;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    nextContext = readContext(contextType);
+  } else {
+    const nextLegacyUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    nextContext = getMaskedContext(workInProgress, nextLegacyUnmaskedContext);
+  }
+
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+  const hasNewLifecycles = typeof getDerivedStateFromProps === 'function' || typeof instance.getSnapshotBeforeUpdate === 'function'; // Note: During these life-cycles, instance.props/instance.state are what
+  // ever the previously attempted to render - not the "current". However,
+  // during componentDidUpdate we pass the "current" props.
+  // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+  if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === 'function' || typeof instance.componentWillReceiveProps === 'function')) {
+    if (oldProps !== newProps || oldContext !== nextContext) {
+      callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
+    }
+  }
+
+  resetHasForceUpdateBeforeProcessing();
+  const oldState = workInProgress.memoizedState;
+  let newState = instance.state = oldState;
+  processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+  newState = workInProgress.memoizedState;
+
+  if (oldProps === newProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing()) {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidMount === 'function') {
+      workInProgress.flags |= Update | LayoutStatic;
+    }
+
+    return false;
+  }
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+    newState = workInProgress.memoizedState;
+  }
+
+  const shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext);
+
+  if (shouldUpdate) {
+    // In order to support react-lifecycles-compat polyfilled components,
+    // Unsafe lifecycles should not be invoked for components using the new APIs.
+    if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
+      if (typeof instance.componentWillMount === 'function') {
+        instance.componentWillMount();
+      }
+
+      if (typeof instance.UNSAFE_componentWillMount === 'function') {
+        instance.UNSAFE_componentWillMount();
+      }
+    }
+
+    if (typeof instance.componentDidMount === 'function') {
+      workInProgress.flags |= Update | LayoutStatic;
+    }
+  } else {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidMount === 'function') {
+      workInProgress.flags |= Update | LayoutStatic;
+    }
+    // memoized state to indicate that this work can be reused.
+
+
+    workInProgress.memoizedProps = newProps;
+    workInProgress.memoizedState = newState;
+  } // Update the existing instance's state, props, and context pointers even
+  // if shouldComponentUpdate returns false.
+
+
+  instance.props = newProps;
+  instance.state = newState;
+  instance.context = nextContext;
+  return shouldUpdate;
+} // Invokes the update life-cycles and returns false if it shouldn't rerender.
+
+
+function updateClassInstance(current, workInProgress, ctor, newProps, renderLanes) {
+  const instance = workInProgress.stateNode;
+  cloneUpdateQueue(current, workInProgress);
+  const unresolvedOldProps = workInProgress.memoizedProps;
+  const oldProps = workInProgress.type === workInProgress.elementType ? unresolvedOldProps : resolveDefaultProps(workInProgress.type, unresolvedOldProps);
+  instance.props = oldProps;
+  const unresolvedNewProps = workInProgress.pendingProps;
+  const oldContext = instance.context;
+  const contextType = ctor.contextType;
+  let nextContext = emptyContextObject;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    nextContext = readContext(contextType);
+  } else {
+    const nextUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    nextContext = getMaskedContext(workInProgress, nextUnmaskedContext);
+  }
+
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+  const hasNewLifecycles = typeof getDerivedStateFromProps === 'function' || typeof instance.getSnapshotBeforeUpdate === 'function'; // Note: During these life-cycles, instance.props/instance.state are what
+  // ever the previously attempted to render - not the "current". However,
+  // during componentDidUpdate we pass the "current" props.
+  // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+  if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === 'function' || typeof instance.componentWillReceiveProps === 'function')) {
+    if (unresolvedOldProps !== unresolvedNewProps || oldContext !== nextContext) {
+      callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
+    }
+  }
+
+  resetHasForceUpdateBeforeProcessing();
+  const oldState = workInProgress.memoizedState;
+  let newState = instance.state = oldState;
+  processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+  newState = workInProgress.memoizedState;
+
+  if (unresolvedOldProps === unresolvedNewProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing() && !(enableLazyContextPropagation   )) {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidUpdate === 'function') {
+      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+        workInProgress.flags |= Update;
+      }
+    }
+
+    if (typeof instance.getSnapshotBeforeUpdate === 'function') {
+      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+        workInProgress.flags |= Snapshot;
+      }
+    }
+
+    return false;
+  }
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+    newState = workInProgress.memoizedState;
+  }
+
+  const shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) || // TODO: In some cases, we'll end up checking if context has changed twice,
+  // both before and after `shouldComponentUpdate` has been called. Not ideal,
+  // but I'm loath to refactor this function. This only happens for memoized
+  // components so it's not that common.
+  enableLazyContextPropagation   ;
+
+  if (shouldUpdate) {
+    // In order to support react-lifecycles-compat polyfilled components,
+    // Unsafe lifecycles should not be invoked for components using the new APIs.
+    if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillUpdate === 'function' || typeof instance.componentWillUpdate === 'function')) {
+      if (typeof instance.componentWillUpdate === 'function') {
+        instance.componentWillUpdate(newProps, newState, nextContext);
+      }
+
+      if (typeof instance.UNSAFE_componentWillUpdate === 'function') {
+        instance.UNSAFE_componentWillUpdate(newProps, newState, nextContext);
+      }
+    }
+
+    if (typeof instance.componentDidUpdate === 'function') {
+      workInProgress.flags |= Update;
+    }
+
+    if (typeof instance.getSnapshotBeforeUpdate === 'function') {
+      workInProgress.flags |= Snapshot;
+    }
+  } else {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidUpdate === 'function') {
+      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+        workInProgress.flags |= Update;
+      }
+    }
+
+    if (typeof instance.getSnapshotBeforeUpdate === 'function') {
+      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+        workInProgress.flags |= Snapshot;
+      }
+    } // If shouldComponentUpdate returned false, we should still update the
+    // memoized props/state to indicate that this work can be reused.
+
+
+    workInProgress.memoizedProps = newProps;
+    workInProgress.memoizedState = newState;
+  } // Update the existing instance's state, props, and context pointers even
+  // if shouldComponentUpdate returns false.
+
+
+  instance.props = newProps;
+  instance.state = newState;
+  instance.context = nextContext;
+  return shouldUpdate;
+}
+
+function createCapturedValueAtFiber(value, source) {
+  // If the value is an error, call this function immediately after it is thrown
+  // so the stack is accurate.
+  return {
+    value,
+    source,
+    stack: getStackByFiberInDevAndProd(source),
+    digest: null
+  };
+}
+function createCapturedValue(value, digest, stack) {
+  return {
+    value,
+    source: null,
+    stack: stack != null ? stack : null,
+    digest: digest != null ? digest : null
+  };
+}
+
+// This module is forked in different environments.
+// By default, return `true` to log errors to the console.
+// Forks can return `false` if this isn't desirable.
+function showErrorDialog(boundary, errorInfo) {
+  return true;
+}
+
+function logCapturedError(boundary, errorInfo) {
+  try {
+    const logError = showErrorDialog(boundary, errorInfo); // Allow injected showErrorDialog() to prevent default console.error logging.
+    // This enables renderers like ReactNative to better manage redbox behavior.
+
+    if (logError === false) ;
+
+    const error = errorInfo.value;
+
+    if (false) ; else {
+      // In production, we print the error directly.
+      // This will include the message, the JS stack, and anything the browser wants to show.
+      // We pass the error object instead of custom message so that the browser displays the error natively.
+      console['error'](error); // Don't transform to our wrapper
+    }
+  } catch (e) {
+    // This method must not throw, or React internal state will get messed up.
+    // If console.error is overridden, or logCapturedError() shows a dialog that throws,
+    // we want to report this error outside of the normal stack as a last resort.
+    // https://github.com/facebook/react/issues/13188
+    setTimeout(() => {
+      throw e;
+    });
+  }
+}
+
+function createRootErrorUpdate(fiber, errorInfo, lane) {
+  const update = createUpdate(lane); // Unmount the root by rendering null.
+
+  update.tag = CaptureUpdate; // Caution: React DevTools currently depends on this property
+  // being called "element".
+
+  update.payload = {
+    element: null
+  };
+  const error = errorInfo.value;
+
+  update.callback = () => {
+    onUncaughtError(error);
+    logCapturedError(fiber, errorInfo);
+  };
+
+  return update;
+}
+
+function createClassErrorUpdate(fiber, errorInfo, lane) {
+  const update = createUpdate(lane);
+  update.tag = CaptureUpdate;
+  const getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+
+  if (typeof getDerivedStateFromError === 'function') {
+    const error = errorInfo.value;
+
+    update.payload = () => {
+      return getDerivedStateFromError(error);
+    };
+
+    update.callback = () => {
+
+      logCapturedError(fiber, errorInfo);
+    };
+  }
+
+  const inst = fiber.stateNode;
+
+  if (inst !== null && typeof inst.componentDidCatch === 'function') {
+    // $FlowFixMe[missing-this-annot]
+    update.callback = function callback() {
+
+      logCapturedError(fiber, errorInfo);
+
+      if (typeof getDerivedStateFromError !== 'function') {
+        // To preserve the preexisting retry behavior of error boundaries,
+        // we keep track of which ones already failed during this batch.
+        // This gets reset before we yield back to the browser.
+        // TODO: Warn in strict mode if getDerivedStateFromError is
+        // not defined.
+        markLegacyErrorBoundaryAsFailed(this);
+      }
+
+      const error = errorInfo.value;
+      const stack = errorInfo.stack;
+      this.componentDidCatch(error, {
+        componentStack: stack !== null ? stack : ''
+      });
+    };
+  }
+
+  return update;
+}
+
+function resetSuspendedComponent(sourceFiber, rootRenderLanes) {
+  // A legacy mode Suspense quirk, only relevant to hook components.
+
+
+  const tag = sourceFiber.tag;
+
+  if ((sourceFiber.mode & ConcurrentMode) === NoMode && (tag === FunctionComponent || tag === ForwardRef || tag === SimpleMemoComponent)) {
+    const currentSource = sourceFiber.alternate;
+
+    if (currentSource) {
+      sourceFiber.updateQueue = currentSource.updateQueue;
+      sourceFiber.memoizedState = currentSource.memoizedState;
+      sourceFiber.lanes = currentSource.lanes;
+    } else {
+      sourceFiber.updateQueue = null;
+      sourceFiber.memoizedState = null;
+    }
+  }
+}
+
+function markSuspenseBoundaryShouldCapture(suspenseBoundary, returnFiber, sourceFiber, root, rootRenderLanes) {
+  // This marks a Suspense boundary so that when we're unwinding the stack,
+  // it captures the suspended "exception" and does a second (fallback) pass.
+  if ((suspenseBoundary.mode & ConcurrentMode) === NoMode) {
+    // Legacy Mode Suspense
+    //
+    // If the boundary is in legacy mode, we should *not*
+    // suspend the commit. Pretend as if the suspended component rendered
+    // null and keep rendering. When the Suspense boundary completes,
+    // we'll do a second pass to render the fallback.
+    if (suspenseBoundary === returnFiber) {
+      // Special case where we suspended while reconciling the children of
+      // a Suspense boundary's inner Offscreen wrapper fiber. This happens
+      // when a React.lazy component is a direct child of a
+      // Suspense boundary.
+      //
+      // Suspense boundaries are implemented as multiple fibers, but they
+      // are a single conceptual unit. The legacy mode behavior where we
+      // pretend the suspended fiber committed as `null` won't work,
+      // because in this case the "suspended" fiber is the inner
+      // Offscreen wrapper.
+      //
+      // Because the contents of the boundary haven't started rendering
+      // yet (i.e. nothing in the tree has partially rendered) we can
+      // switch to the regular, concurrent mode behavior: mark the
+      // boundary with ShouldCapture and enter the unwind phase.
+      suspenseBoundary.flags |= ShouldCapture;
+    } else {
+      suspenseBoundary.flags |= DidCapture;
+      sourceFiber.flags |= ForceUpdateForLegacySuspense; // We're going to commit this fiber even though it didn't complete.
+      // But we shouldn't call any lifecycle methods or callbacks. Remove
+      // all lifecycle effect tags.
+
+      sourceFiber.flags &= ~(LifecycleEffectMask | Incomplete);
+
+      if (sourceFiber.tag === ClassComponent) {
+        const currentSourceFiber = sourceFiber.alternate;
+
+        if (currentSourceFiber === null) {
+          // This is a new mount. Change the tag so it's not mistaken for a
+          // completed class component. For example, we should not call
+          // componentWillUnmount if it is deleted.
+          sourceFiber.tag = IncompleteClassComponent;
+        } else {
+          // When we try rendering again, we should not reuse the current fiber,
+          // since it's known to be in an inconsistent state. Use a force update to
+          // prevent a bail out.
+          const update = createUpdate(SyncLane);
+          update.tag = ForceUpdate;
+          enqueueUpdate(sourceFiber, update, SyncLane);
+        }
+      } // The source fiber did not complete. Mark it with Sync priority to
+      // indicate that it still has pending work.
+
+
+      sourceFiber.lanes = mergeLanes(sourceFiber.lanes, SyncLane);
+    }
+
+    return suspenseBoundary;
+  } // Confirmed that the boundary is in a concurrent mode tree. Continue
+  // with the normal suspend path.
+  //
+  // After this we'll use a set of heuristics to determine whether this
+  // render pass will run to completion or restart or "suspend" the commit.
+  // The actual logic for this is spread out in different places.
+  //
+  // This first principle is that if we're going to suspend when we complete
+  // a root, then we should also restart if we get an update or ping that
+  // might unsuspend it, and vice versa. The only reason to suspend is
+  // because you think you might want to restart before committing. However,
+  // it doesn't make sense to restart only while in the period we're suspended.
+  //
+  // Restarting too aggressively is also not good because it starves out any
+  // intermediate loading state. So we use heuristics to determine when.
+  // Suspense Heuristics
+  //
+  // If nothing threw a Promise or all the same fallbacks are already showing,
+  // then don't suspend/restart.
+  //
+  // If this is an initial render of a new tree of Suspense boundaries and
+  // those trigger a fallback, then don't suspend/restart. We want to ensure
+  // that we can show the initial loading state as quickly as possible.
+  //
+  // If we hit a "Delayed" case, such as when we'd switch from content back into
+  // a fallback, then we should always suspend/restart. Transitions apply
+  // to this case. If none is defined, JND is used instead.
+  //
+  // If we're already showing a fallback and it gets "retried", allowing us to show
+  // another level, but there's still an inner boundary that would show a fallback,
+  // then we suspend/restart for 500ms since the last time we showed a fallback
+  // anywhere in the tree. This effectively throttles progressive loading into a
+  // consistent train of commits. This also gives us an opportunity to restart to
+  // get to the completed state slightly earlier.
+  //
+  // If there's ambiguity due to batching it's resolved in preference of:
+  // 1) "delayed", 2) "initial render", 3) "retry".
+  //
+  // We want to ensure that a "busy" state doesn't get force committed. We want to
+  // ensure that new initial loading states can commit as soon as possible.
+
+
+  suspenseBoundary.flags |= ShouldCapture; // TODO: I think we can remove this, since we now use `DidCapture` in
+  // the begin phase to prevent an early bailout.
+
+  suspenseBoundary.lanes = rootRenderLanes;
+  return suspenseBoundary;
+}
+
+function throwException(root, returnFiber, sourceFiber, value, rootRenderLanes) {
+  // The source fiber did not complete.
+  sourceFiber.flags |= Incomplete;
+
+  if (value !== null && typeof value === 'object') {
+
+    if (typeof value.then === 'function') {
+      // This is a wakeable. The component suspended.
+      const wakeable = value;
+      resetSuspendedComponent(sourceFiber);
+
+
+      const suspenseBoundary = getSuspenseHandler();
+
+      if (suspenseBoundary !== null) {
+        switch (suspenseBoundary.tag) {
+          case SuspenseComponent:
+            {
+              // If this suspense boundary is not already showing a fallback, mark
+              // the in-progress render as suspended. We try to perform this logic
+              // as soon as soon as possible during the render phase, so the work
+              // loop can know things like whether it's OK to switch to other tasks,
+              // or whether it can wait for data to resolve before continuing.
+              // TODO: Most of these checks are already performed when entering a
+              // Suspense boundary. We should track the information on the stack so
+              // we don't have to recompute it on demand. This would also allow us
+              // to unify with `use` which needs to perform this logic even sooner,
+              // before `throwException` is called.
+              if (sourceFiber.mode & ConcurrentMode) {
+                if (getShellBoundary() === null) {
+                  // Suspended in the "shell" of the app. This is an undesirable
+                  // loading state. We should avoid committing this tree.
+                  renderDidSuspendDelayIfPossible();
+                } else {
+                  // If we suspended deeper than the shell, we don't need to delay
+                  // the commmit. However, we still call renderDidSuspend if this is
+                  // a new boundary, to tell the work loop that a new fallback has
+                  // appeared during this render.
+                  // TODO: Theoretically we should be able to delete this branch.
+                  // It's currently used for two things: 1) to throttle the
+                  // appearance of successive loading states, and 2) in
+                  // SuspenseList, to determine whether the children include any
+                  // pending fallbacks. For 1, we should apply throttling to all
+                  // retries, not just ones that render an additional fallback. For
+                  // 2, we should check subtreeFlags instead. Then we can delete
+                  // this branch.
+                  const current = suspenseBoundary.alternate;
+
+                  if (current === null) {
+                    renderDidSuspend();
+                  }
+                }
+              }
+
+              suspenseBoundary.flags &= ~ForceClientRender;
+              markSuspenseBoundaryShouldCapture(suspenseBoundary, returnFiber, sourceFiber, root, rootRenderLanes); // Retry listener
+              //
+              // If the fallback does commit, we need to attach a different type of
+              // listener. This one schedules an update on the Suspense boundary to
+              // turn the fallback state off.
+              //
+              // Stash the wakeable on the boundary fiber so we can access it in the
+              // commit phase.
+              //
+              // When the wakeable resolves, we'll attempt to render the boundary
+              // again ("retry").
+              // Check if this is a Suspensey resource. We do not attach retry
+              // listeners to these, because we don't actually need them for
+              // rendering. Only for committing. Instead, if a fallback commits
+              // and the only thing that suspended was a Suspensey resource, we
+              // retry immediately.
+              // TODO: Refactor throwException so that we don't have to do this type
+              // check. The caller already knows what the cause was.
+
+              const isSuspenseyResource = wakeable === noopSuspenseyCommitThenable;
+
+              if (isSuspenseyResource) {
+                suspenseBoundary.flags |= ScheduleRetry;
+              } else {
+                const retryQueue = suspenseBoundary.updateQueue;
+
+                if (retryQueue === null) {
+                  suspenseBoundary.updateQueue = new Set([wakeable]);
+                } else {
+                  retryQueue.add(wakeable);
+                } // We only attach ping listeners in concurrent mode. Legacy
+                // Suspense always commits fallbacks synchronously, so there are
+                // no pings.
+
+
+                if (suspenseBoundary.mode & ConcurrentMode) {
+                  attachPingListener(root, wakeable, rootRenderLanes);
+                }
+              }
+
+              return;
+            }
+
+          case OffscreenComponent:
+            {
+              if (suspenseBoundary.mode & ConcurrentMode) {
+                suspenseBoundary.flags |= ShouldCapture;
+                const isSuspenseyResource = wakeable === noopSuspenseyCommitThenable;
+
+                if (isSuspenseyResource) {
+                  suspenseBoundary.flags |= ScheduleRetry;
+                } else {
+                  const offscreenQueue = suspenseBoundary.updateQueue;
+
+                  if (offscreenQueue === null) {
+                    const newOffscreenQueue = {
+                      transitions: null,
+                      markerInstances: null,
+                      retryQueue: new Set([wakeable])
+                    };
+                    suspenseBoundary.updateQueue = newOffscreenQueue;
+                  } else {
+                    const retryQueue = offscreenQueue.retryQueue;
+
+                    if (retryQueue === null) {
+                      offscreenQueue.retryQueue = new Set([wakeable]);
+                    } else {
+                      retryQueue.add(wakeable);
+                    }
+                  }
+
+                  attachPingListener(root, wakeable, rootRenderLanes);
+                }
+
+                return;
+              }
+            }
+        }
+
+        throw Error(formatProdErrorMessage(435, suspenseBoundary.tag));
+      } else {
+        // No boundary was found. Unless this is a sync update, this is OK.
+        // We can suspend and wait for more data to arrive.
+        if (root.tag === ConcurrentRoot) {
+          // In a concurrent root, suspending without a Suspense boundary is
+          // allowed. It will suspend indefinitely without committing.
+          //
+          // TODO: Should we have different behavior for discrete updates? What
+          // about flushSync? Maybe it should put the tree into an inert state,
+          // and potentially log a warning. Revisit this for a future release.
+          attachPingListener(root, wakeable, rootRenderLanes);
+          renderDidSuspendDelayIfPossible();
+          return;
+        } else {
+          // In a legacy root, suspending without a boundary is always an error.
+          const uncaughtSuspenseError = Error(formatProdErrorMessage(426));
+          value = uncaughtSuspenseError;
+        }
+      }
+    }
+  } // This is a regular error, not a Suspense wakeable.
+
+
+  if (getIsHydrating() && sourceFiber.mode & ConcurrentMode) {
+    const suspenseBoundary = getSuspenseHandler(); // If the error was thrown during hydration, we may be able to recover by
+    // discarding the dehydrated content and switching to a client render.
+    // Instead of surfacing the error, find the nearest Suspense boundary
+    // and render it again without hydration.
+
+    if (suspenseBoundary !== null) {
+      if ((suspenseBoundary.flags & ShouldCapture) === NoFlags$1) {
+        // Set a flag to indicate that we should try rendering the normal
+        // children again, not the fallback.
+        suspenseBoundary.flags |= ForceClientRender;
+      }
+
+      markSuspenseBoundaryShouldCapture(suspenseBoundary, returnFiber, sourceFiber, root, rootRenderLanes); // Even though the user may not be affected by this error, we should
+      // still log it so it can be fixed.
+
+      queueHydrationError(createCapturedValueAtFiber(value, sourceFiber));
+      return;
+    }
+  }
+
+  value = createCapturedValueAtFiber(value, sourceFiber);
+  renderDidError(value); // We didn't find a boundary that could handle this type of exception. Start
+  // over and traverse parent path again, this time treating the exception
+  // as an error.
+
+  let workInProgress = returnFiber;
+
+  do {
+    switch (workInProgress.tag) {
+      case HostRoot:
+        {
+          const errorInfo = value;
+          workInProgress.flags |= ShouldCapture;
+          const lane = pickArbitraryLane(rootRenderLanes);
+          workInProgress.lanes = mergeLanes(workInProgress.lanes, lane);
+          const update = createRootErrorUpdate(workInProgress, errorInfo, lane);
+          enqueueCapturedUpdate(workInProgress, update);
+          return;
+        }
+
+      case ClassComponent:
+        // Capture and retry
+        const errorInfo = value;
+        const ctor = workInProgress.type;
+        const instance = workInProgress.stateNode;
+
+        if ((workInProgress.flags & DidCapture) === NoFlags$1 && (typeof ctor.getDerivedStateFromError === 'function' || instance !== null && typeof instance.componentDidCatch === 'function' && !isAlreadyFailedLegacyErrorBoundary(instance))) {
+          workInProgress.flags |= ShouldCapture;
+          const lane = pickArbitraryLane(rootRenderLanes);
+          workInProgress.lanes = mergeLanes(workInProgress.lanes, lane); // Schedule the error boundary to re-render using updated state
+
+          const update = createClassErrorUpdate(workInProgress, errorInfo, lane);
+          enqueueCapturedUpdate(workInProgress, update);
+          return;
+        }
+
+        break;
+    } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+    workInProgress = workInProgress.return;
+  } while (workInProgress !== null);
+}
+
+const ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner; // A special exception that's used to unwind the stack when an update flows
+// into a dehydrated boundary.
+
+const SelectiveHydrationException = Error(formatProdErrorMessage(461));
+let didReceiveUpdate = false;
+
+function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
+  if (current === null) {
+    // If this is a fresh new component that hasn't been rendered yet, we
+    // won't update its child set by applying minimal side-effects. Instead,
+    // we will add them all to the child before it gets rendered. That means
+    // we can optimize this reconciliation pass by not tracking side-effects.
+    workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderLanes);
+  } else {
+    // If the current child is the same as the work in progress, it means that
+    // we haven't yet started any work on these children. Therefore, we use
+    // the clone algorithm to create a copy of all the current children.
+    // If we had any progressed work already, that is invalid at this point so
+    // let's throw it out.
+    workInProgress.child = reconcileChildFibers(workInProgress, current.child, nextChildren, renderLanes);
+  }
+}
+
+function forceUnmountCurrentAndReconcile(current, workInProgress, nextChildren, renderLanes) {
+  // This function is fork of reconcileChildren. It's used in cases where we
+  // want to reconcile without matching against the existing set. This has the
+  // effect of all current children being unmounted; even if the type and key
+  // are the same, the old child is unmounted and a new child is created.
+  //
+  // To do this, we're going to go through the reconcile algorithm twice. In
+  // the first pass, we schedule a deletion for all the current children by
+  // passing null.
+  workInProgress.child = reconcileChildFibers(workInProgress, current.child, null, renderLanes); // In the second pass, we mount the new children. The trick here is that we
+  // pass null in place of where we usually pass the current child set. This has
+  // the effect of remounting all children regardless of whether their
+  // identities match.
+
+  workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderLanes);
+}
+
+function updateForwardRef(current, workInProgress, Component, nextProps, renderLanes) {
+
+  const render = Component.render;
+  const ref = workInProgress.ref; // The rest is a fork of updateFunctionComponent
+
+  let nextChildren;
+  let hasId;
+  prepareToReadContext(workInProgress, renderLanes);
+
+  {
+    nextChildren = renderWithHooks(current, workInProgress, render, nextProps, ref, renderLanes);
+    hasId = checkDidRenderIdHook();
+  }
+
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateMemoComponent(current, workInProgress, Component, nextProps, renderLanes) {
+  if (current === null) {
+    const type = Component.type;
+
+    if (isSimpleFunctionComponent(type) && Component.compare === null && // SimpleMemoComponent codepath doesn't resolve outer props either.
+    Component.defaultProps === undefined) {
+      let resolvedType = type;
+      // and with only the default shallow comparison, we upgrade it
+      // to a SimpleMemoComponent to allow fast path updates.
+
+
+      workInProgress.tag = SimpleMemoComponent;
+      workInProgress.type = resolvedType;
+
+      return updateSimpleMemoComponent(current, workInProgress, resolvedType, nextProps, renderLanes);
+    }
+
+    const child = createFiberFromTypeAndProps(Component.type, null, nextProps, null, workInProgress, workInProgress.mode, renderLanes);
+    child.ref = workInProgress.ref;
+    child.return = workInProgress;
+    workInProgress.child = child;
+    return child;
+  }
+
+  const currentChild = current.child; // This is always exactly one child
+
+  const hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(current, renderLanes);
+
+  if (!hasScheduledUpdateOrContext) {
+    // This will be the props with resolved defaultProps,
+    // unlike current.memoizedProps which will be the unresolved ones.
+    const prevProps = currentChild.memoizedProps; // Default to shallow comparison
+
+    let compare = Component.compare;
+    compare = compare !== null ? compare : shallowEqual;
+
+    if (compare(prevProps, nextProps) && current.ref === workInProgress.ref) {
+      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    }
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+  const newChild = createWorkInProgress(currentChild, nextProps);
+  newChild.ref = workInProgress.ref;
+  newChild.return = workInProgress;
+  workInProgress.child = newChild;
+  return newChild;
+}
+
+function updateSimpleMemoComponent(current, workInProgress, Component, nextProps, renderLanes) {
+
+  if (current !== null) {
+    const prevProps = current.memoizedProps;
+
+    if (shallowEqual(prevProps, nextProps) && current.ref === workInProgress.ref && ( // Prevent bailout if the implementation changed due to hot reload.
+    true)) {
+      didReceiveUpdate = false; // The props are shallowly equal. Reuse the previous props object, like we
+      // would during a normal fiber bailout.
+      //
+      // We don't have strong guarantees that the props object is referentially
+      // equal during updates where we can't bail out anyway — like if the props
+      // are shallowly equal, but there's a local state or context update in the
+      // same batch.
+      //
+      // However, as a principle, we should aim to make the behavior consistent
+      // across different ways of memoizing a component. For example, React.memo
+      // has a different internal Fiber layout if you pass a normal function
+      // component (SimpleMemoComponent) versus if you pass a different type
+      // like forwardRef (MemoComponent). But this is an implementation detail.
+      // Wrapping a component in forwardRef (or React.lazy, etc) shouldn't
+      // affect whether the props object is reused during a bailout.
+
+      workInProgress.pendingProps = nextProps = prevProps;
+
+      if (!checkScheduledUpdateOrContext(current, renderLanes)) {
+        // The pending lanes were cleared at the beginning of beginWork. We're
+        // about to bail out, but there might be other lanes that weren't
+        // included in the current render. Usually, the priority level of the
+        // remaining updates is accumulated during the evaluation of the
+        // component (i.e. when processing the update queue). But since since
+        // we're bailing out early *without* evaluating the component, we need
+        // to account for it here, too. Reset to the value of the current fiber.
+        // NOTE: This only applies to SimpleMemoComponent, not MemoComponent,
+        // because a MemoComponent fiber does not have hooks or an update queue;
+        // rather, it wraps around an inner component, which may or may not
+        // contains hooks.
+        // TODO: Move the reset at in beginWork out of the common path so that
+        // this is no longer necessary.
+        workInProgress.lanes = current.lanes;
+        return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+      } else if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags$1) {
+        // This is a special case that only exists for legacy mode.
+        // See https://github.com/facebook/react/pull/19216.
+        didReceiveUpdate = true;
+      }
+    }
+  }
+
+  return updateFunctionComponent(current, workInProgress, Component, nextProps, renderLanes);
+}
+
+function updateOffscreenComponent(current, workInProgress, renderLanes) {
+  const nextProps = workInProgress.pendingProps;
+  const nextChildren = nextProps.children;
+  const nextIsDetached = (workInProgress.stateNode._pendingVisibility & OffscreenDetached) !== 0;
+  const prevState = current !== null ? current.memoizedState : null;
+  markRef$1(current, workInProgress);
+
+  if (nextProps.mode === 'hidden' || enableLegacyHidden  || nextIsDetached) {
+    // Rendering a hidden tree.
+    const didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
+
+    if (didSuspend) {
+      // Something suspended inside a hidden tree
+      // Include the base lanes from the last render
+      const nextBaseLanes = prevState !== null ? mergeLanes(prevState.baseLanes, renderLanes) : renderLanes;
+
+      if (current !== null) {
+        // Reset to the current children
+        let currentChild = workInProgress.child = current.child; // The current render suspended, but there may be other lanes with
+        // pending work. We can't read `childLanes` from the current Offscreen
+        // fiber because we reset it when it was deferred; however, we can read
+        // the pending lanes from the child fibers.
+
+        let currentChildLanes = NoLanes;
+
+        while (currentChild !== null) {
+          currentChildLanes = mergeLanes(mergeLanes(currentChildLanes, currentChild.lanes), currentChild.childLanes);
+          currentChild = currentChild.sibling;
+        }
+
+        const lanesWeJustAttempted = nextBaseLanes;
+        const remainingChildLanes = removeLanes(currentChildLanes, lanesWeJustAttempted);
+        workInProgress.childLanes = remainingChildLanes;
+      } else {
+        workInProgress.childLanes = NoLanes;
+        workInProgress.child = null;
+      }
+
+      return deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes);
+    }
+
+    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+      // In legacy sync mode, don't defer the subtree. Render it now.
+      // TODO: Consider how Offscreen should work with transitions in the future
+      const nextState = {
+        baseLanes: NoLanes,
+        cachePool: null
+      };
+      workInProgress.memoizedState = nextState;
+
+      {
+        // push the cache pool even though we're going to bail out
+        // because otherwise there'd be a context mismatch
+        if (current !== null) {
+          pushTransition(workInProgress, null);
+        }
+      }
+
+      reuseHiddenContextOnStack();
+      pushOffscreenSuspenseHandler(workInProgress);
+    } else if (!includesSomeLane(renderLanes, OffscreenLane)) {
+      // We're hidden, and we're not rendering at Offscreen. We will bail out
+      // and resume this tree later.
+      // Schedule this fiber to re-render at Offscreen priority
+      workInProgress.lanes = workInProgress.childLanes = laneToLanes(OffscreenLane); // Include the base lanes from the last render
+
+      const nextBaseLanes = prevState !== null ? mergeLanes(prevState.baseLanes, renderLanes) : renderLanes;
+      return deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes);
+    } else {
+      // This is the second render. The surrounding visible content has already
+      // committed. Now we resume rendering the hidden tree.
+      // Rendering at offscreen, so we can clear the base lanes.
+      const nextState = {
+        baseLanes: NoLanes,
+        cachePool: null
+      };
+      workInProgress.memoizedState = nextState;
+
+      if (current !== null) {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        const 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);
+      } // Push the lanes that were skipped when we bailed out.
+
+
+      if (prevState !== null) {
+        pushHiddenContext(workInProgress, prevState);
+      } else {
+        reuseHiddenContextOnStack();
+      }
+
+      pushOffscreenSuspenseHandler(workInProgress);
+    }
+  } else {
+    // Rendering a visible tree.
+    if (prevState !== null) {
+      // We're going from hidden -> visible.
+      let prevCachePool = null;
+
+      {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        prevCachePool = prevState.cachePool;
+      }
+
+      pushTransition(workInProgress, prevCachePool); // Push the lanes that were skipped when we bailed out.
+
+      pushHiddenContext(workInProgress, prevState);
+      reuseSuspenseHandlerOnStack(workInProgress); // Since we're not hidden anymore, reset the state
+
+      workInProgress.memoizedState = null;
+    } else {
+      // We weren't previously hidden, and we still aren't, so there's nothing
+      // special to do. Need to push to the stack regardless, though, to avoid
+      // a push/pop misalignment.
+      {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        if (current !== null) {
+          pushTransition(workInProgress, null);
+        }
+      } // We're about to bail out, but we need to push this to the stack anyway
+      // to avoid a push/pop misalignment.
+
+
+      reuseHiddenContextOnStack();
+      reuseSuspenseHandlerOnStack(workInProgress);
+    }
+  }
+
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes, renderLanes) {
+  const nextState = {
+    baseLanes: nextBaseLanes,
+    // Save the cache pool so we can resume later.
+    cachePool: getOffscreenDeferredCache() 
+  };
+  workInProgress.memoizedState = nextState;
+
+  {
+    // push the cache pool even though we're going to bail out
+    // because otherwise there'd be a context mismatch
+    if (current !== null) {
+      pushTransition(workInProgress, null);
+    }
+  } // We're about to bail out, but we need to push this to the stack anyway
+  // to avoid a push/pop misalignment.
+
+
+  reuseHiddenContextOnStack();
+  pushOffscreenSuspenseHandler(workInProgress);
+
+  return null;
+} // Note: These happen to have identical begin phases, for now. We shouldn't hold
+
+function updateCacheComponent(current, workInProgress, renderLanes) {
+
+  prepareToReadContext(workInProgress, renderLanes);
+  const parentCache = readContext(CacheContext);
+
+  if (current === null) {
+    // Initial mount. Request a fresh cache from the pool.
+    const freshCache = requestCacheFromPool(renderLanes);
+    const initialState = {
+      parent: parentCache,
+      cache: freshCache
+    };
+    workInProgress.memoizedState = initialState;
+    initializeUpdateQueue(workInProgress);
+    pushCacheProvider(workInProgress, freshCache);
+  } else {
+    // Check for updates
+    if (includesSomeLane(current.lanes, renderLanes)) {
+      cloneUpdateQueue(current, workInProgress);
+      processUpdateQueue(workInProgress, null, null, renderLanes);
+    }
+
+    const prevState = current.memoizedState;
+    const nextState = workInProgress.memoizedState; // Compare the new parent cache to the previous to see detect there was
+    // a refresh.
+
+    if (prevState.parent !== parentCache) {
+      // Refresh in parent. Update the parent.
+      const derivedState = {
+        parent: parentCache,
+        cache: parentCache
+      }; // Copied from getDerivedStateFromProps implementation. Once the update
+      // queue is empty, persist the derived state onto the base state.
+
+      workInProgress.memoizedState = derivedState;
+
+      if (workInProgress.lanes === NoLanes) {
+        const updateQueue = workInProgress.updateQueue;
+        workInProgress.memoizedState = updateQueue.baseState = derivedState;
+      }
+
+      pushCacheProvider(workInProgress, parentCache); // No need to propagate a context change because the refreshed parent
+      // already did.
+    } else {
+      // The parent didn't refresh. Now check if this cache did.
+      const nextCache = nextState.cache;
+      pushCacheProvider(workInProgress, nextCache);
+
+      if (nextCache !== prevState.cache) {
+        // This cache refreshed. Propagate a context change.
+        propagateContextChange(workInProgress, CacheContext, renderLanes);
+      }
+    }
+  }
+
+  const nextChildren = workInProgress.pendingProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+} // This should only be called if the name changes
+
+function updateFragment(current, workInProgress, renderLanes) {
+  const nextChildren = workInProgress.pendingProps;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateMode(current, workInProgress, renderLanes) {
+  const nextChildren = workInProgress.pendingProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateProfiler(current, workInProgress, renderLanes) {
+
+  const nextProps = workInProgress.pendingProps;
+  const nextChildren = nextProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function markRef$1(current, workInProgress) {
+  const ref = workInProgress.ref;
+
+  if (current === null && ref !== null || current !== null && current.ref !== ref) {
+    // Schedule a Ref effect
+    workInProgress.flags |= Ref;
+    workInProgress.flags |= RefStatic;
+  }
+}
+
+function updateFunctionComponent(current, workInProgress, Component, nextProps, renderLanes) {
+
+  let context;
+
+  {
+    const unmaskedContext = getUnmaskedContext(workInProgress, Component, true);
+    context = getMaskedContext(workInProgress, unmaskedContext);
+  }
+
+  let nextChildren;
+  let hasId;
+  prepareToReadContext(workInProgress, renderLanes);
+
+  {
+    nextChildren = renderWithHooks(current, workInProgress, Component, nextProps, context, renderLanes);
+    hasId = checkDidRenderIdHook();
+  }
+
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function replayFunctionComponent(current, workInProgress, nextProps, Component, secondArg, renderLanes) {
+  // This function is used to replay a component that previously suspended,
+  // after its data resolves. It's a simplified version of
+  // updateFunctionComponent that reuses the hooks from the previous attempt.
+  prepareToReadContext(workInProgress, renderLanes);
+
+  const nextChildren = replaySuspendedComponentWithHooks(current, workInProgress, Component, nextProps, secondArg);
+  const hasId = checkDidRenderIdHook();
+
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateClassComponent(current, workInProgress, Component, nextProps, renderLanes) {
+  // During mounting we don't know the child context yet as the instance doesn't exist.
+  // We will invalidate the child context in finishClassComponent() right after rendering.
+
+
+  let hasContext;
+
+  if (isContextProvider(Component)) {
+    hasContext = true;
+    pushContextProvider(workInProgress);
+  } else {
+    hasContext = false;
+  }
+
+  prepareToReadContext(workInProgress, renderLanes);
+  const instance = workInProgress.stateNode;
+  let shouldUpdate;
+
+  if (instance === null) {
+    resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress); // In the initial pass we might need to construct the instance.
+
+    constructClassInstance(workInProgress, Component, nextProps);
+    mountClassInstance(workInProgress, Component, nextProps, renderLanes);
+    shouldUpdate = true;
+  } else if (current === null) {
+    // In a resume, we'll already have an instance we can reuse.
+    shouldUpdate = resumeMountClassInstance(workInProgress, Component, nextProps, renderLanes);
+  } else {
+    shouldUpdate = updateClassInstance(current, workInProgress, Component, nextProps, renderLanes);
+  }
+
+  const nextUnitOfWork = finishClassComponent(current, workInProgress, Component, shouldUpdate, hasContext, renderLanes);
+
+  return nextUnitOfWork;
+}
+
+function finishClassComponent(current, workInProgress, Component, shouldUpdate, hasContext, renderLanes) {
+  // Refs should update even if shouldComponentUpdate returns false
+  markRef$1(current, workInProgress);
+  const didCaptureError = (workInProgress.flags & DidCapture) !== NoFlags$1;
+
+  if (!shouldUpdate && !didCaptureError) {
+    // Context providers should defer to sCU for rendering
+    if (hasContext) {
+      invalidateContextProvider(workInProgress, Component, false);
+    }
+
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+
+  const instance = workInProgress.stateNode; // Rerender
+
+  ReactCurrentOwner$1.current = workInProgress;
+  let nextChildren;
+
+  if (didCaptureError && typeof Component.getDerivedStateFromError !== 'function') {
+    // If we captured an error, but getDerivedStateFromError is not defined,
+    // unmount all the children. componentDidCatch will schedule an update to
+    // re-render a fallback. This is temporary until we migrate everyone to
+    // the new API.
+    // TODO: Warn in a future release.
+    nextChildren = null;
+  } else {
+
+    {
+      nextChildren = instance.render();
+    }
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+
+  if (current !== null && didCaptureError) {
+    // If we're recovering from an error, reconcile without reusing any of
+    // the existing children. Conceptually, the normal children and the children
+    // that are shown on error are two different sets, so we shouldn't reuse
+    // normal children even if their identities match.
+    forceUnmountCurrentAndReconcile(current, workInProgress, nextChildren, renderLanes);
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  } // Memoize state using the values we just used to render.
+  // TODO: Restructure so we never read values from the instance.
+
+
+  workInProgress.memoizedState = instance.state; // The context might have changed so we need to recalculate it.
+
+  if (hasContext) {
+    invalidateContextProvider(workInProgress, Component, true);
+  }
+
+  return workInProgress.child;
+}
+
+function pushHostRootContext(workInProgress) {
+  const root = workInProgress.stateNode;
+
+  if (root.pendingContext) {
+    pushTopLevelContextObject(workInProgress, root.pendingContext, root.pendingContext !== root.context);
+  } else if (root.context) {
+    // Should always be set
+    pushTopLevelContextObject(workInProgress, root.context, false);
+  }
+
+  pushHostContainer(workInProgress, root.containerInfo);
+}
+
+function updateHostRoot(current, workInProgress, renderLanes) {
+  pushHostRootContext(workInProgress);
+
+  if (current === null) {
+    throw Error(formatProdErrorMessage(387));
+  }
+
+  const nextProps = workInProgress.pendingProps;
+  const prevState = workInProgress.memoizedState;
+  const prevChildren = prevState.element;
+  cloneUpdateQueue(current, workInProgress);
+  processUpdateQueue(workInProgress, nextProps, null, renderLanes);
+  const nextState = workInProgress.memoizedState;
+
+  {
+    const nextCache = nextState.cache;
+    pushCacheProvider(workInProgress, nextCache);
+
+    if (nextCache !== prevState.cache) {
+      // The root cache refreshed.
+      propagateContextChange(workInProgress, CacheContext, renderLanes);
+    }
+  } // Caution: React DevTools currently depends on this property
+  // being called "element".
+
+
+  const nextChildren = nextState.element;
+
+  if (prevState.isDehydrated) {
+    // This is a hydration root whose shell has not yet hydrated. We should
+    // attempt to hydrate.
+    // Flip isDehydrated to false to indicate that when this render
+    // finishes, the root will no longer be dehydrated.
+    const overrideState = {
+      element: nextChildren,
+      isDehydrated: false,
+      cache: nextState.cache
+    };
+    const updateQueue = workInProgress.updateQueue; // `baseState` can always be the last state because the root doesn't
+    // have reducer functions so it doesn't need rebasing.
+
+    updateQueue.baseState = overrideState;
+    workInProgress.memoizedState = overrideState;
+
+    if (workInProgress.flags & ForceClientRender) {
+      // Something errored during a previous attempt to hydrate the shell, so we
+      // forced a client render.
+      const recoverableError = createCapturedValueAtFiber(Error(formatProdErrorMessage(423)), workInProgress);
+      return mountHostRootWithoutHydrating(current, workInProgress, nextChildren, renderLanes, recoverableError);
+    } else if (nextChildren !== prevChildren) {
+      const recoverableError = createCapturedValueAtFiber(Error(formatProdErrorMessage(424)), workInProgress);
+      return mountHostRootWithoutHydrating(current, workInProgress, nextChildren, renderLanes, recoverableError);
+    } else {
+      // The outermost shell has not hydrated yet. Start hydrating.
+      enterHydrationState(workInProgress);
+      const child = mountChildFibers(workInProgress, null, nextChildren, renderLanes);
+      workInProgress.child = child;
+      let node = child;
+
+      while (node) {
+        // Mark each child as hydrating. This is a fast path to know whether this
+        // tree is part of a hydrating tree. This is used to determine if a child
+        // node has fully mounted yet, and for scheduling event replaying.
+        // Conceptually this is similar to Placement in that a new subtree is
+        // inserted into the React tree here. It just happens to not need DOM
+        // mutations because it already exists.
+        node.flags = node.flags & ~Placement | Hydrating;
+        node = node.sibling;
+      }
+    }
+  } else {
+    // Root is not dehydrated. Either this is a client-only root, or it
+    // already hydrated.
+    resetHydrationState();
+
+    if (nextChildren === prevChildren) {
+      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    }
+
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  }
+
+  return workInProgress.child;
+}
+
+function mountHostRootWithoutHydrating(current, workInProgress, nextChildren, renderLanes, recoverableError) {
+  // Revert to client rendering.
+  resetHydrationState();
+  queueHydrationError(recoverableError);
+  workInProgress.flags |= ForceClientRender;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateHostComponent$1(current, workInProgress, renderLanes) {
+  pushHostContext(workInProgress);
+
+  if (current === null) {
+    tryToClaimNextHydratableInstance(workInProgress);
+  }
+
+  const type = workInProgress.type;
+  const nextProps = workInProgress.pendingProps;
+  const prevProps = current !== null ? current.memoizedProps : null;
+  let nextChildren = nextProps.children;
+  const isDirectTextChild = shouldSetTextContent(type, nextProps);
+
+  if (isDirectTextChild) {
+    // We special case a direct text child of a host node. This is a common
+    // case. We won't handle it as a reified child. We will instead handle
+    // this in the host environment that also has access to this prop. That
+    // avoids allocating another HostText fiber and traversing it.
+    nextChildren = null;
+  } else if (prevProps !== null && shouldSetTextContent(type, prevProps)) {
+    // If we're switching from a direct text child to a normal child, or to
+    // empty, we need to schedule the text content to be reset.
+    workInProgress.flags |= ContentReset;
+  }
+
+  {
+    const memoizedState = workInProgress.memoizedState;
+
+    if (memoizedState !== null) {
+      // This fiber has been upgraded to a stateful component. The only way
+      // happens currently is for form actions. We use hooks to track the
+      // pending and error state of the form.
+      //
+      // Once a fiber is upgraded to be stateful, it remains stateful for the
+      // rest of its lifetime.
+      const newState = renderTransitionAwareHostComponentWithHooks(current, workInProgress, renderLanes); // If the transition state changed, propagate the change to all the
+      // descendents. We use Context as an implementation detail for this.
+      //
+      // This is intentionally set here instead of pushHostContext because
+      // pushHostContext gets called before we process the state hook, to avoid
+      // a state mismatch in the event that something suspends.
+      //
+      // NOTE: This assumes that there cannot be nested transition providers,
+      // because the only renderer that implements this feature is React DOM,
+      // and forms cannot be nested. If we did support nested providers, then
+      // we would need to push a context value even for host fibers that
+      // haven't been upgraded yet.
+
+      {
+        HostTransitionContext._currentValue = newState;
+      }
+
+      {
+        if (didReceiveUpdate) {
+          if (current !== null) {
+            const oldStateHook = current.memoizedState;
+            const oldState = oldStateHook.memoizedState; // This uses regular equality instead of Object.is because we assume
+            // that host transition state doesn't include NaN as a valid type.
+
+            if (oldState !== newState) {
+              propagateContextChange(workInProgress, HostTransitionContext, renderLanes);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  markRef$1(current, workInProgress);
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateHostHoistable(current, workInProgress, renderLanes) {
+  markRef$1(current, workInProgress);
+  const currentProps = current === null ? null : current.memoizedProps;
+  const resource = workInProgress.memoizedState = getResource(workInProgress.type, currentProps, workInProgress.pendingProps);
+
+  if (current === null) {
+    if (!getIsHydrating() && resource === null) {
+      // This is not a Resource Hoistable and we aren't hydrating so we construct the instance.
+      workInProgress.stateNode = createHoistableInstance(workInProgress.type, workInProgress.pendingProps, getRootHostContainer(), workInProgress);
+    }
+  } // Resources never have reconciler managed children. It is possible for
+  // the host implementation of getResource to consider children in the
+  // resource construction but they will otherwise be discarded. In practice
+  // this precludes all but the simplest children and Host specific warnings
+  // should be implemented to warn when children are passsed when otherwise not
+  // expected
+
+
+  return null;
+}
+
+function updateHostSingleton(current, workInProgress, renderLanes) {
+  pushHostContext(workInProgress);
+
+  if (current === null) {
+    claimHydratableSingleton(workInProgress);
+  }
+
+  const nextChildren = workInProgress.pendingProps.children;
+
+  if (current === null && !getIsHydrating()) {
+    // Similar to Portals we append Singleton children in the commit phase. So we
+    // Track insertions even on mount.
+    // TODO: Consider unifying this with how the root works.
+    workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderLanes);
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  }
+
+  markRef$1(current, workInProgress);
+  return workInProgress.child;
+}
+
+function updateHostText$1(current, workInProgress) {
+  if (current === null) {
+    tryToClaimNextHydratableTextInstance(workInProgress);
+  } // Nothing to do here. This is terminal. We'll do the completion step
+  // immediately after.
+
+
+  return null;
+}
+
+function mountLazyComponent(_current, workInProgress, elementType, renderLanes) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);
+  const props = workInProgress.pendingProps;
+  const lazyComponent = elementType;
+  const payload = lazyComponent._payload;
+  const init = lazyComponent._init;
+  let Component = init(payload); // Store the unwrapped component in the type.
+
+  workInProgress.type = Component;
+  const resolvedTag = workInProgress.tag = resolveLazyComponentTag(Component);
+  const resolvedProps = resolveDefaultProps(Component, props);
+  let child;
+
+  switch (resolvedTag) {
+    case FunctionComponent:
+      {
+
+        child = updateFunctionComponent(null, workInProgress, Component, resolvedProps, renderLanes);
+        return child;
+      }
+
+    case ClassComponent:
+      {
+
+        child = updateClassComponent(null, workInProgress, Component, resolvedProps, renderLanes);
+        return child;
+      }
+
+    case ForwardRef:
+      {
+
+        child = updateForwardRef(null, workInProgress, Component, resolvedProps, renderLanes);
+        return child;
+      }
+
+    case MemoComponent:
+      {
+
+        child = updateMemoComponent(null, workInProgress, Component, resolveDefaultProps(Component.type, resolvedProps), // The inner type can have defaults too
+        renderLanes);
+        return child;
+      }
+  }
+
+  let hint = '';
+  // because the fact that it's a separate type of work is an
+  // implementation detail.
+
+
+  throw Error(formatProdErrorMessage(306, Component, hint));
+}
+
+function mountIncompleteClassComponent(_current, workInProgress, Component, nextProps, renderLanes) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress); // Promote the fiber to a class and try rendering again.
+
+  workInProgress.tag = ClassComponent; // The rest of this function is a fork of `updateClassComponent`
+  // Push context providers early to prevent context stack mismatches.
+  // During mounting we don't know the child context yet as the instance doesn't exist.
+  // We will invalidate the child context in finishClassComponent() right after rendering.
+
+  let hasContext;
+
+  if (isContextProvider(Component)) {
+    hasContext = true;
+    pushContextProvider(workInProgress);
+  } else {
+    hasContext = false;
+  }
+
+  prepareToReadContext(workInProgress, renderLanes);
+  constructClassInstance(workInProgress, Component, nextProps);
+  mountClassInstance(workInProgress, Component, nextProps, renderLanes);
+  return finishClassComponent(null, workInProgress, Component, true, hasContext, renderLanes);
+}
+
+function mountIndeterminateComponent(_current, workInProgress, Component, renderLanes) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);
+  const props = workInProgress.pendingProps;
+  let context;
+
+  {
+    const unmaskedContext = getUnmaskedContext(workInProgress, Component, false);
+    context = getMaskedContext(workInProgress, unmaskedContext);
+  }
+
+  prepareToReadContext(workInProgress, renderLanes);
+  let value;
+  let hasId;
+
+  {
+    value = renderWithHooks(null, workInProgress, Component, props, context, renderLanes);
+    hasId = checkDidRenderIdHook();
+  }
+
+
+  workInProgress.flags |= PerformedWork;
+
+  if ( // Run these checks in production only if the flag is off.
+  // Eventually we'll delete this branch altogether.
+  typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) {
+
+
+    workInProgress.tag = ClassComponent; // Throw out any hooks that were used.
+
+    workInProgress.memoizedState = null;
+    workInProgress.updateQueue = null; // Push context providers early to prevent context stack mismatches.
+    // During mounting we don't know the child context yet as the instance doesn't exist.
+    // We will invalidate the child context in finishClassComponent() right after rendering.
+
+    let hasContext = false;
+
+    if (isContextProvider(Component)) {
+      hasContext = true;
+      pushContextProvider(workInProgress);
+    } else {
+      hasContext = false;
+    }
+
+    workInProgress.memoizedState = value.state !== null && value.state !== undefined ? value.state : null;
+    initializeUpdateQueue(workInProgress);
+    adoptClassInstance(workInProgress, value);
+    mountClassInstance(workInProgress, Component, props, renderLanes);
+    return finishClassComponent(null, workInProgress, Component, true, hasContext, renderLanes);
+  } else {
+    // Proceed under the assumption that this is a function component
+    workInProgress.tag = FunctionComponent;
+
+    if (getIsHydrating() && hasId) {
+      pushMaterializedTreeId(workInProgress);
+    }
+
+    reconcileChildren(null, workInProgress, value, renderLanes);
+
+    return workInProgress.child;
+  }
+}
+
+const SUSPENDED_MARKER = {
+  dehydrated: null,
+  treeContext: null,
+  retryLane: NoLane
+};
+
+function mountSuspenseOffscreenState(renderLanes) {
+  return {
+    baseLanes: renderLanes,
+    cachePool: getSuspendedCache()
+  };
+}
+
+function updateSuspenseOffscreenState(prevOffscreenState, renderLanes) {
+  let cachePool = null;
+
+  {
+    const prevCachePool = prevOffscreenState.cachePool;
+
+    if (prevCachePool !== null) {
+      const parentCache = CacheContext._currentValue ;
+
+      if (prevCachePool.parent !== parentCache) {
+        // Detected a refresh in the parent. This overrides any previously
+        // suspended cache.
+        cachePool = {
+          parent: parentCache,
+          pool: parentCache
+        };
+      } else {
+        // We can reuse the cache from last time. The only thing that would have
+        // overridden it is a parent refresh, which we checked for above.
+        cachePool = prevCachePool;
+      }
+    } else {
+      // If there's no previous cache pool, grab the current one.
+      cachePool = getSuspendedCache();
+    }
+  }
+
+  return {
+    baseLanes: mergeLanes(prevOffscreenState.baseLanes, renderLanes),
+    cachePool
+  };
+} // TODO: Probably should inline this back
+
+
+function shouldRemainOnFallback(current, workInProgress, renderLanes) {
+  // If we're already showing a fallback, there are cases where we need to
+  // remain on that fallback regardless of whether the content has resolved.
+  // For example, SuspenseList coordinates when nested content appears.
+  // TODO: For compatibility with offscreen prerendering, this should also check
+  // whether the current fiber (if it exists) was visible in the previous tree.
+  if (current !== null) {
+    const suspenseState = current.memoizedState;
+
+    if (suspenseState === null) {
+      // Currently showing content. Don't hide it, even if ForceSuspenseFallback
+      // is true. More precise name might be "ForceRemainSuspenseFallback".
+      // Note: This is a factoring smell. Can't remain on a fallback if there's
+      // no fallback to remain on.
+      return false;
+    }
+  } // Not currently showing content. Consult the Suspense context.
+
+
+  const suspenseContext = suspenseStackCursor.current;
+  return hasSuspenseListContext(suspenseContext, ForceSuspenseFallback);
+}
+
+function getRemainingWorkInPrimaryTree(current, renderLanes) {
+  // TODO: Should not remove render lanes that were pinged during this render
+  return removeLanes(current.childLanes, renderLanes);
+}
+
+function updateSuspenseComponent(current, workInProgress, renderLanes) {
+  const nextProps = workInProgress.pendingProps; // This is used by DevTools to force a boundary to suspend.
+
+  let showFallback = false;
+  const didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
+
+  if (didSuspend || shouldRemainOnFallback(current)) {
+    // Something in this boundary's subtree already suspended. Switch to
+    // rendering the fallback children.
+    showFallback = true;
+    workInProgress.flags &= ~DidCapture;
+  } // OK, the next part is confusing. We're about to reconcile the Suspense
+  // boundary's children. This involves some custom reconciliation logic. Two
+  // main reasons this is so complicated.
+  //
+  // First, Legacy Mode has different semantics for backwards compatibility. The
+  // primary tree will commit in an inconsistent state, so when we do the
+  // second pass to render the fallback, we do some exceedingly, uh, clever
+  // hacks to make that not totally break. Like transferring effects and
+  // deletions from hidden tree. In Concurrent Mode, it's much simpler,
+  // because we bailout on the primary tree completely and leave it in its old
+  // state, no effects. Same as what we do for Offscreen (except that
+  // Offscreen doesn't have the first render pass).
+  //
+  // Second is hydration. During hydration, the Suspense fiber has a slightly
+  // different layout, where the child points to a dehydrated fragment, which
+  // contains the DOM rendered by the server.
+  //
+  // Third, even if you set all that aside, Suspense is like error boundaries in
+  // that we first we try to render one tree, and if that fails, we render again
+  // and switch to a different tree. Like a try/catch block. So we have to track
+  // which branch we're currently rendering. Ideally we would model this using
+  // a stack.
+
+
+  if (current === null) {
+    // Initial mount
+    // Special path for hydration
+    // If we're currently hydrating, try to hydrate this boundary.
+    if (getIsHydrating()) {
+      // We must push the suspense handler context *before* attempting to
+      // hydrate, to avoid a mismatch in case it errors.
+      if (showFallback) {
+        pushPrimaryTreeSuspenseHandler(workInProgress);
+      } else {
+        pushFallbackTreeSuspenseHandler(workInProgress);
+      }
+
+      tryToClaimNextHydratableSuspenseInstance(workInProgress); // This could've been a dehydrated suspense component.
+
+      const suspenseState = workInProgress.memoizedState;
+
+      if (suspenseState !== null) {
+        const dehydrated = suspenseState.dehydrated;
+
+        if (dehydrated !== null) {
+          return mountDehydratedSuspenseComponent(workInProgress, dehydrated);
+        }
+      } // If hydration didn't succeed, fall through to the normal Suspense path.
+      // To avoid a stack mismatch we need to pop the Suspense handler that we
+      // pushed above. This will become less awkward when move the hydration
+      // logic to its own fiber.
+
+
+      popSuspenseHandler(workInProgress);
+    }
+
+    const nextPrimaryChildren = nextProps.children;
+    const nextFallbackChildren = nextProps.fallback;
+
+    if (showFallback) {
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      const fallbackFragment = mountSuspenseFallbackChildren(workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);
+      const primaryChildFragment = workInProgress.child;
+      primaryChildFragment.memoizedState = mountSuspenseOffscreenState(renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+
+      return fallbackFragment;
+    } else {
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      return mountSuspensePrimaryChildren(workInProgress, nextPrimaryChildren);
+    }
+  } else {
+    // This is an update.
+    // Special path for hydration
+    const prevState = current.memoizedState;
+
+    if (prevState !== null) {
+      const dehydrated = prevState.dehydrated;
+
+      if (dehydrated !== null) {
+        return updateDehydratedSuspenseComponent(current, workInProgress, didSuspend, nextProps, dehydrated, prevState, renderLanes);
+      }
+    }
+
+    if (showFallback) {
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      const nextFallbackChildren = nextProps.fallback;
+      const nextPrimaryChildren = nextProps.children;
+      const fallbackChildFragment = updateSuspenseFallbackChildren(current, workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);
+      const primaryChildFragment = workInProgress.child;
+      const prevOffscreenState = current.child.memoizedState;
+      primaryChildFragment.memoizedState = prevOffscreenState === null ? mountSuspenseOffscreenState(renderLanes) : updateSuspenseOffscreenState(prevOffscreenState, renderLanes);
+
+      primaryChildFragment.childLanes = getRemainingWorkInPrimaryTree(current, renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+      return fallbackChildFragment;
+    } else {
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      const nextPrimaryChildren = nextProps.children;
+      const primaryChildFragment = updateSuspensePrimaryChildren(current, workInProgress, nextPrimaryChildren, renderLanes);
+      workInProgress.memoizedState = null;
+      return primaryChildFragment;
+    }
+  }
+}
+
+function mountSuspensePrimaryChildren(workInProgress, primaryChildren, renderLanes) {
+  const mode = workInProgress.mode;
+  const primaryChildProps = {
+    mode: 'visible',
+    children: primaryChildren
+  };
+  const primaryChildFragment = mountWorkInProgressOffscreenFiber(primaryChildProps, mode);
+  primaryChildFragment.return = workInProgress;
+  workInProgress.child = primaryChildFragment;
+  return primaryChildFragment;
+}
+
+function mountSuspenseFallbackChildren(workInProgress, primaryChildren, fallbackChildren, renderLanes) {
+  const mode = workInProgress.mode;
+  const progressedPrimaryFragment = workInProgress.child;
+  const primaryChildProps = {
+    mode: 'hidden',
+    children: primaryChildren
+  };
+  let primaryChildFragment;
+  let fallbackChildFragment;
+
+  if ((mode & ConcurrentMode) === NoMode && progressedPrimaryFragment !== null) {
+    // In legacy mode, we commit the primary tree as if it successfully
+    // completed, even though it's in an inconsistent state.
+    primaryChildFragment = progressedPrimaryFragment;
+    primaryChildFragment.childLanes = NoLanes;
+    primaryChildFragment.pendingProps = primaryChildProps;
+
+    fallbackChildFragment = createFiberFromFragment(fallbackChildren, mode, renderLanes, null);
+  } else {
+    primaryChildFragment = mountWorkInProgressOffscreenFiber(primaryChildProps, mode);
+    fallbackChildFragment = createFiberFromFragment(fallbackChildren, mode, renderLanes, null);
+  }
+
+  primaryChildFragment.return = workInProgress;
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
+  return fallbackChildFragment;
+}
+
+function mountWorkInProgressOffscreenFiber(offscreenProps, mode, renderLanes) {
+  // The props argument to `createFiberFromOffscreen` is `any` typed, so we use
+  // this wrapper function to constrain it.
+  return createFiberFromOffscreen(offscreenProps, mode, NoLanes, null);
+}
+
+function updateWorkInProgressOffscreenFiber(current, offscreenProps) {
+  // The props argument to `createWorkInProgress` is `any` typed, so we use this
+  // wrapper function to constrain it.
+  return createWorkInProgress(current, offscreenProps);
+}
+
+function updateSuspensePrimaryChildren(current, workInProgress, primaryChildren, renderLanes) {
+  const currentPrimaryChildFragment = current.child;
+  const currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
+  const primaryChildFragment = updateWorkInProgressOffscreenFiber(currentPrimaryChildFragment, {
+    mode: 'visible',
+    children: primaryChildren
+  });
+
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    primaryChildFragment.lanes = renderLanes;
+  }
+
+  primaryChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = null;
+
+  if (currentFallbackChildFragment !== null) {
+    // Delete the fallback child fragment
+    const deletions = workInProgress.deletions;
+
+    if (deletions === null) {
+      workInProgress.deletions = [currentFallbackChildFragment];
+      workInProgress.flags |= ChildDeletion;
+    } else {
+      deletions.push(currentFallbackChildFragment);
+    }
+  }
+
+  workInProgress.child = primaryChildFragment;
+  return primaryChildFragment;
+}
+
+function updateSuspenseFallbackChildren(current, workInProgress, primaryChildren, fallbackChildren, renderLanes) {
+  const mode = workInProgress.mode;
+  const currentPrimaryChildFragment = current.child;
+  const currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
+  const primaryChildProps = {
+    mode: 'hidden',
+    children: primaryChildren
+  };
+  let primaryChildFragment;
+
+  if ( // In legacy mode, we commit the primary tree as if it successfully
+  // completed, even though it's in an inconsistent state.
+  (mode & ConcurrentMode) === NoMode && // Make sure we're on the second pass, i.e. the primary child fragment was
+  // already cloned. In legacy mode, the only case where this isn't true is
+  // when DevTools forces us to display a fallback; we skip the first render
+  // pass entirely and go straight to rendering the fallback. (In Concurrent
+  // Mode, SuspenseList can also trigger this scenario, but this is a legacy-
+  // only codepath.)
+  workInProgress.child !== currentPrimaryChildFragment) {
+    const progressedPrimaryFragment = workInProgress.child;
+    primaryChildFragment = progressedPrimaryFragment;
+    primaryChildFragment.childLanes = NoLanes;
+    primaryChildFragment.pendingProps = primaryChildProps;
+    // However, since we're going to remain on the fallback, we no longer want
+    // to delete it.
+
+
+    workInProgress.deletions = null;
+  } else {
+    primaryChildFragment = updateWorkInProgressOffscreenFiber(currentPrimaryChildFragment, primaryChildProps); // Since we're reusing a current tree, we need to reuse the flags, too.
+    // (We don't do this in legacy mode, because in legacy mode we don't re-use
+    // the current tree; see previous branch.)
+
+    primaryChildFragment.subtreeFlags = currentPrimaryChildFragment.subtreeFlags & StaticMask;
+  }
+
+  let fallbackChildFragment;
+
+  if (currentFallbackChildFragment !== null) {
+    fallbackChildFragment = createWorkInProgress(currentFallbackChildFragment, fallbackChildren);
+  } else {
+    fallbackChildFragment = createFiberFromFragment(fallbackChildren, mode, renderLanes, null); // Needs a placement effect because the parent (the Suspense boundary) already
+    // mounted but this is a new fiber.
+
+    fallbackChildFragment.flags |= Placement;
+  }
+
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
+  return fallbackChildFragment;
+}
+
+function retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, recoverableError) {
+  // Falling back to client rendering. Because this has performance
+  // implications, it's considered a recoverable error, even though the user
+  // likely won't observe anything wrong with the UI.
+  //
+  // The error is passed in as an argument to enforce that every caller provide
+  // a custom message, or explicitly opt out (currently the only path that opts
+  // out is legacy mode; every concurrent path provides an error).
+  if (recoverableError !== null) {
+    queueHydrationError(recoverableError);
+  } // This will add the old fiber to the deletion list
+
+
+  reconcileChildFibers(workInProgress, current.child, null, renderLanes); // We're now not suspended nor dehydrated.
+
+  const nextProps = workInProgress.pendingProps;
+  const primaryChildren = nextProps.children;
+  const primaryChildFragment = mountSuspensePrimaryChildren(workInProgress, primaryChildren); // Needs a placement effect because the parent (the Suspense boundary) already
+  // mounted but this is a new fiber.
+
+  primaryChildFragment.flags |= Placement;
+  workInProgress.memoizedState = null;
+  return primaryChildFragment;
+}
+
+function mountSuspenseFallbackAfterRetryWithoutHydrating(current, workInProgress, primaryChildren, fallbackChildren, renderLanes) {
+  const fiberMode = workInProgress.mode;
+  const primaryChildProps = {
+    mode: 'visible',
+    children: primaryChildren
+  };
+  const primaryChildFragment = mountWorkInProgressOffscreenFiber(primaryChildProps, fiberMode);
+  const fallbackChildFragment = createFiberFromFragment(fallbackChildren, fiberMode, renderLanes, null); // Needs a placement effect because the parent (the Suspense
+  // boundary) already mounted but this is a new fiber.
+
+  fallbackChildFragment.flags |= Placement;
+  primaryChildFragment.return = workInProgress;
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
+
+  if ((workInProgress.mode & ConcurrentMode) !== NoMode) {
+    // We will have dropped the effect list which contains the
+    // deletion. We need to reconcile to delete the current child.
+    reconcileChildFibers(workInProgress, current.child, null, renderLanes);
+  }
+
+  return fallbackChildFragment;
+}
+
+function mountDehydratedSuspenseComponent(workInProgress, suspenseInstance, renderLanes) {
+  // During the first pass, we'll bail out and not drill into the children.
+  // Instead, we'll leave the content in place and try to hydrate it later.
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+
+    workInProgress.lanes = laneToLanes(SyncLane);
+  } else if (isSuspenseInstanceFallback(suspenseInstance)) {
+    // This is a client-only boundary. Since we won't get any content from the server
+    // for this, we need to schedule that at a higher priority based on when it would
+    // have timed out. In theory we could render it in this pass but it would have the
+    // wrong priority associated with it and will prevent hydration of parent path.
+    // Instead, we'll leave work left on it to render it in a separate commit.
+    // TODO This time should be the time at which the server rendered response that is
+    // a parent to this boundary was displayed. However, since we currently don't have
+    // a protocol to transfer that time, we'll just estimate it by using the current
+    // time. This will mean that Suspense timeouts are slightly shifted to later than
+    // they should be.
+    // Schedule a normal pri update to render this content.
+    workInProgress.lanes = laneToLanes(DefaultHydrationLane);
+  } else {
+    // We'll continue hydrating the rest at offscreen priority since we'll already
+    // be showing the right content coming from the server, it is no rush.
+    workInProgress.lanes = laneToLanes(OffscreenLane);
+  }
+
+  return null;
+}
+
+function updateDehydratedSuspenseComponent(current, workInProgress, didSuspend, nextProps, suspenseInstance, suspenseState, renderLanes) {
+  if (!didSuspend) {
+    // This is the first render pass. Attempt to hydrate.
+    pushPrimaryTreeSuspenseHandler(workInProgress); // We should never be hydrating at this point because it is the first pass,
+
+    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, null);
+    }
+
+    if (isSuspenseInstanceFallback(suspenseInstance)) {
+      // This boundary is in a permanent fallback state. In this case, we'll never
+      // get an update and we'll never be able to hydrate the final content. Let's just try the
+      // client side render instead.
+      let digest;
+      let stack;
+
+      {
+        var _getSuspenseInstanceF2 = getSuspenseInstanceFallbackErrorDetails(suspenseInstance);
+
+        digest = _getSuspenseInstanceF2.digest;
+      }
+
+      let capturedValue = null; // TODO: Figure out a better signal than encoding a magic digest value.
+
+      {
+        let error;
+
+        {
+          error = Error(formatProdErrorMessage(419));
+        }
+
+        error.digest = digest;
+        capturedValue = createCapturedValue(error, digest, stack);
+      }
+
+      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, capturedValue);
+    }
+    // any context has changed, we need to treat is as if the input might have changed.
+
+
+    const hasContextChanged = includesSomeLane(renderLanes, current.childLanes);
+
+    if (didReceiveUpdate || hasContextChanged) {
+      // This boundary has changed since the first render. This means that we are now unable to
+      // hydrate it. We might still be able to hydrate it using a higher priority lane.
+      const root = getWorkInProgressRoot();
+
+      if (root !== null) {
+        const attemptHydrationAtLane = getBumpedLaneForHydration(root, renderLanes);
+
+        if (attemptHydrationAtLane !== NoLane && attemptHydrationAtLane !== suspenseState.retryLane) {
+          // Intentionally mutating since this render will get interrupted. This
+          // is one of the very rare times where we mutate the current tree
+          // during the render phase.
+          suspenseState.retryLane = attemptHydrationAtLane;
+          enqueueConcurrentRenderForLane(current, attemptHydrationAtLane);
+          scheduleUpdateOnFiber(root, current, attemptHydrationAtLane); // Throw a special object that signals to the work loop that it should
+          // interrupt the current render.
+          //
+          // Because we're inside a React-only execution stack, we don't
+          // strictly need to throw here — we could instead modify some internal
+          // work loop state. But using an exception means we don't need to
+          // check for this case on every iteration of the work loop. So doing
+          // it this way moves the check out of the fast path.
+
+          throw SelectiveHydrationException;
+        }
+      } // If we did not selectively hydrate, we'll continue rendering without
+      // hydrating. Mark this tree as suspended to prevent it from committing
+      // outside a transition.
+      //
+      // This path should only happen if the hydration lane already suspended.
+      // Currently, it also happens during sync updates because there is no
+      // hydration lane for sync updates.
+      // TODO: We should ideally have a sync hydration lane that we can apply to do
+      // a pass where we hydrate this subtree in place using the previous Context and then
+      // reapply the update afterwards.
+
+
+      if (isSuspenseInstancePending(suspenseInstance)) ; else {
+        renderDidSuspendDelayIfPossible();
+      }
+
+      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, null);
+    } else if (isSuspenseInstancePending(suspenseInstance)) {
+      // This component is still pending more data from the server, so we can't hydrate its
+      // content. We treat it as if this component suspended itself. It might seem as if
+      // we could just try to render it client-side instead. However, this will perform a
+      // lot of unnecessary work and is unlikely to complete since it often will suspend
+      // on missing data anyway. Additionally, the server might be able to render more
+      // than we can on the client yet. In that case we'd end up with more fallback states
+      // on the client than if we just leave it alone. If the server times out or errors
+      // these should update this boundary to the permanent Fallback state instead.
+      // Mark it as having captured (i.e. suspended).
+      workInProgress.flags |= DidCapture; // Leave the child in place. I.e. the dehydrated fragment.
+
+      workInProgress.child = current.child; // Register a callback to retry this boundary once the server has sent the result.
+
+      const retry = retryDehydratedSuspenseBoundary.bind(null, current);
+      registerSuspenseInstanceRetry(suspenseInstance, retry);
+      return null;
+    } else {
+      // This is the first attempt.
+      reenterHydrationStateFromDehydratedSuspenseInstance(workInProgress, suspenseInstance, suspenseState.treeContext);
+      const primaryChildren = nextProps.children;
+      const primaryChildFragment = mountSuspensePrimaryChildren(workInProgress, primaryChildren); // Mark the children as hydrating. This is a fast path to know whether this
+      // tree is part of a hydrating tree. This is used to determine if a child
+      // node has fully mounted yet, and for scheduling event replaying.
+      // Conceptually this is similar to Placement in that a new subtree is
+      // inserted into the React tree here. It just happens to not need DOM
+      // mutations because it already exists.
+
+      primaryChildFragment.flags |= Hydrating;
+      return primaryChildFragment;
+    }
+  } else {
+    // This is the second render pass. We already attempted to hydrated, but
+    // something either suspended or errored.
+    if (workInProgress.flags & ForceClientRender) {
+      // Something errored during hydration. Try again without hydrating.
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      workInProgress.flags &= ~ForceClientRender;
+      const capturedValue = createCapturedValue(Error(formatProdErrorMessage(422)));
+      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, capturedValue);
+    } else if (workInProgress.memoizedState !== null) {
+      // Something suspended and we should still be in dehydrated mode.
+      // Leave the existing child in place.
+      // Push to avoid a mismatch
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      workInProgress.child = current.child; // The dehydrated completion pass expects this flag to be there
+      // but the normal suspense pass doesn't.
+
+      workInProgress.flags |= DidCapture;
+      return null;
+    } else {
+      // Suspended but we should no longer be in dehydrated mode.
+      // Therefore we now have to render the fallback.
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      const nextPrimaryChildren = nextProps.children;
+      const nextFallbackChildren = nextProps.fallback;
+      const fallbackChildFragment = mountSuspenseFallbackAfterRetryWithoutHydrating(current, workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);
+      const primaryChildFragment = workInProgress.child;
+      primaryChildFragment.memoizedState = mountSuspenseOffscreenState(renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+      return fallbackChildFragment;
+    }
+  }
+}
+
+function scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {
+  fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
+  const alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+  }
+
+  scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);
+}
+
+function propagateSuspenseContextChange(workInProgress, firstChild, renderLanes) {
+  // Mark any Suspense boundaries with fallbacks as having work to do.
+  // If they were previously forced into fallbacks, they may now be able
+  // to unblock.
+  let node = firstChild;
+
+  while (node !== null) {
+    if (node.tag === SuspenseComponent) {
+      const state = node.memoizedState;
+
+      if (state !== null) {
+        scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);
+      }
+    } else if (node.tag === SuspenseListComponent) {
+      // If the tail is hidden there might not be an Suspense boundaries
+      // to schedule work on. In this case we have to schedule it on the
+      // list itself.
+      // We don't have to traverse to the children of the list since
+      // the list will propagate the change when it rerenders.
+      scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);
+    } else if (node.child !== null) {
+      node.child.return = node;
+      node = node.child;
+      continue;
+    }
+
+    if (node === workInProgress) {
+      return;
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    while (node.sibling === null) {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      if (node.return === null || node.return === workInProgress) {
+        return;
+      }
+
+      node = node.return;
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    node.sibling.return = node.return;
+    node = node.sibling;
+  }
+}
+
+function findLastContentRow(firstChild) {
+  // This is going to find the last row among these children that is already
+  // showing content on the screen, as opposed to being in fallback state or
+  // new. If a row has multiple Suspense boundaries, any of them being in the
+  // fallback state, counts as the whole row being in a fallback state.
+  // Note that the "rows" will be workInProgress, but any nested children
+  // will still be current since we haven't rendered them yet. The mounted
+  // order may not be the same as the new order. We use the new order.
+  let row = firstChild;
+  let lastContentRow = null;
+
+  while (row !== null) {
+    const currentRow = row.alternate; // New rows can't be content rows.
+
+    if (currentRow !== null && findFirstSuspended(currentRow) === null) {
+      lastContentRow = row;
+    }
+
+    row = row.sibling;
+  }
+
+  return lastContentRow;
+}
+
+function initSuspenseListRenderState(workInProgress, isBackwards, tail, lastContentRow, tailMode) {
+  const renderState = workInProgress.memoizedState;
+
+  if (renderState === null) {
+    workInProgress.memoizedState = {
+      isBackwards: isBackwards,
+      rendering: null,
+      renderingStartTime: 0,
+      last: lastContentRow,
+      tail: tail,
+      tailMode: tailMode
+    };
+  } else {
+    // We can reuse the existing object from previous renders.
+    renderState.isBackwards = isBackwards;
+    renderState.rendering = null;
+    renderState.renderingStartTime = 0;
+    renderState.last = lastContentRow;
+    renderState.tail = tail;
+    renderState.tailMode = tailMode;
+  }
+} // This can end up rendering this component multiple passes.
+// The first pass splits the children fibers into two sets. A head and tail.
+// We first render the head. If anything is in fallback state, we do another
+// pass through beginWork to rerender all children (including the tail) with
+// the force suspend context. If the first render didn't have anything in
+// in fallback state. Then we render each row in the tail one-by-one.
+// That happens in the completeWork phase without going back to beginWork.
+
+
+function updateSuspenseListComponent(current, workInProgress, renderLanes) {
+  const nextProps = workInProgress.pendingProps;
+  const revealOrder = nextProps.revealOrder;
+  const tailMode = nextProps.tail;
+  const newChildren = nextProps.children;
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  let suspenseContext = suspenseStackCursor.current;
+  const shouldForceFallback = hasSuspenseListContext(suspenseContext, ForceSuspenseFallback);
+
+  if (shouldForceFallback) {
+    suspenseContext = setShallowSuspenseListContext(suspenseContext, ForceSuspenseFallback);
+    workInProgress.flags |= DidCapture;
+  } else {
+    const didSuspendBefore = current !== null && (current.flags & DidCapture) !== NoFlags$1;
+
+    if (didSuspendBefore) {
+      // If we previously forced a fallback, we need to schedule work
+      // on any nested boundaries to let them know to try to render
+      // again. This is the same as context updating.
+      propagateSuspenseContextChange(workInProgress, workInProgress.child, renderLanes);
+    }
+
+    suspenseContext = setDefaultShallowSuspenseListContext(suspenseContext);
+  }
+
+  pushSuspenseListContext(workInProgress, suspenseContext);
+
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    // In legacy mode, SuspenseList doesn't work so we just
+    // use make it a noop by treating it as the default revealOrder.
+    workInProgress.memoizedState = null;
+  } else {
+    switch (revealOrder) {
+      case 'forwards':
+        {
+          const lastContentRow = findLastContentRow(workInProgress.child);
+          let tail;
+
+          if (lastContentRow === null) {
+            // The whole list is part of the tail.
+            // TODO: We could fast path by just rendering the tail now.
+            tail = workInProgress.child;
+            workInProgress.child = null;
+          } else {
+            // Disconnect the tail rows after the content row.
+            // We're going to render them separately later.
+            tail = lastContentRow.sibling;
+            lastContentRow.sibling = null;
+          }
+
+          initSuspenseListRenderState(workInProgress, false, // isBackwards
+          tail, lastContentRow, tailMode);
+          break;
+        }
+
+      case 'backwards':
+        {
+          // We're going to find the first row that has existing content.
+          // At the same time we're going to reverse the list of everything
+          // we pass in the meantime. That's going to be our tail in reverse
+          // order.
+          let tail = null;
+          let row = workInProgress.child;
+          workInProgress.child = null;
+
+          while (row !== null) {
+            const currentRow = row.alternate; // New rows can't be content rows.
+
+            if (currentRow !== null && findFirstSuspended(currentRow) === null) {
+              // This is the beginning of the main content.
+              workInProgress.child = row;
+              break;
+            }
+
+            const nextRow = row.sibling;
+            row.sibling = tail;
+            tail = row;
+            row = nextRow;
+          } // TODO: If workInProgress.child is null, we can continue on the tail immediately.
+
+
+          initSuspenseListRenderState(workInProgress, true, // isBackwards
+          tail, null, // last
+          tailMode);
+          break;
+        }
+
+      case 'together':
+        {
+          initSuspenseListRenderState(workInProgress, false, // isBackwards
+          null, // tail
+          null, // last
+          undefined);
+          break;
+        }
+
+      default:
+        {
+          // The default reveal order is the same as not having
+          // a boundary.
+          workInProgress.memoizedState = null;
+        }
+    }
+  }
+
+  return workInProgress.child;
+}
+
+function updatePortalComponent(current, workInProgress, renderLanes) {
+  pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+  const nextChildren = workInProgress.pendingProps;
+
+  if (current === null) {
+    // Portals are special because we don't append the children during mount
+    // but at commit. Therefore we need to track insertions which the normal
+    // flow doesn't do during mount. This doesn't happen at the root because
+    // the root always starts with a "current" with a null child.
+    // TODO: Consider unifying this with how the root works.
+    workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderLanes);
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  }
+
+  return workInProgress.child;
+}
+
+function updateContextProvider(current, workInProgress, renderLanes) {
+  const providerType = workInProgress.type;
+  const context = providerType._context;
+  const newProps = workInProgress.pendingProps;
+  const oldProps = workInProgress.memoizedProps;
+  const newValue = newProps.value;
+
+  pushProvider(workInProgress, context, newValue);
+
+  {
+    if (oldProps !== null) {
+      const oldValue = oldProps.value;
+
+      if (objectIs(oldValue, newValue)) {
+        // No change. Bailout early if children are the same.
+        if (oldProps.children === newProps.children && !hasContextChanged()) {
+          return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+        }
+      } else {
+        // The context value changed. Search for matching consumers and schedule
+        // them to update.
+        propagateContextChange(workInProgress, context, renderLanes);
+      }
+    }
+  }
+
+  const newChildren = newProps.children;
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateContextConsumer(current, workInProgress, renderLanes) {
+  let context = workInProgress.type; // The logic below for Context differs depending on PROD or DEV mode. In
+
+  const newProps = workInProgress.pendingProps;
+  const render = newProps.children;
+
+  prepareToReadContext(workInProgress, renderLanes);
+  const newValue = readContext(context);
+
+  let newChildren;
+
+  {
+    newChildren = render(newValue);
+  }
+
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function markWorkInProgressReceivedUpdate() {
+  didReceiveUpdate = true;
+}
+
+function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    if (current !== null) {
+      // A lazy component only mounts if it suspended inside a non-
+      // concurrent tree, in an inconsistent state. We want to treat it like
+      // a new mount, even though an empty version of it already committed.
+      // Disconnect the alternate pointers.
+      current.alternate = null;
+      workInProgress.alternate = null; // Since this is conceptually a new fiber, schedule a Placement effect
+
+      workInProgress.flags |= Placement;
+    }
+  }
+}
+
+function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
+  if (current !== null) {
+    // Reuse previous dependencies
+    workInProgress.dependencies = current.dependencies;
+  }
+
+  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.
+    {
+      return null;
+    }
+  } // This fiber doesn't have work, but its subtree does. Clone the child
+  // fibers and continue.
+
+
+  cloneChildFibers(current, workInProgress);
+  return workInProgress.child;
+}
+
+function checkScheduledUpdateOrContext(current, renderLanes) {
+  // Before performing an early bailout, we must check if there are pending
+  // updates or context.
+  const updateLanes = current.lanes;
+
+  if (includesSomeLane(updateLanes, renderLanes)) {
+    return true;
+  } // No pending update, but because context is propagated lazily, we need
+
+  return false;
+}
+
+function attemptEarlyBailoutIfNoScheduledUpdate(current, workInProgress, renderLanes) {
+  // This fiber does not have any pending work. Bailout without entering
+  // the begin phase. There's still some bookkeeping we that needs to be done
+  // in this optimized path, mostly pushing stuff onto the stack.
+  switch (workInProgress.tag) {
+    case HostRoot:
+      pushHostRootContext(workInProgress);
+
+      {
+        const cache = current.memoizedState.cache;
+        pushCacheProvider(workInProgress, cache);
+      }
+
+      resetHydrationState();
+      break;
+
+    case HostSingleton:
+    case HostComponent:
+      pushHostContext(workInProgress);
+      break;
+
+    case ClassComponent:
+      {
+        const Component = workInProgress.type;
+
+        if (isContextProvider(Component)) {
+          pushContextProvider(workInProgress);
+        }
+
+        break;
+      }
+
+    case HostPortal:
+      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+      break;
+
+    case ContextProvider:
+      {
+        const newValue = workInProgress.memoizedProps.value;
+        const context = workInProgress.type._context;
+        pushProvider(workInProgress, context, newValue);
+        break;
+      }
+
+    case Profiler:
+
+      break;
+
+    case SuspenseComponent:
+      {
+        const state = workInProgress.memoizedState;
+
+        if (state !== null) {
+          if (state.dehydrated !== null) {
+            // We're not going to render the children, so this is just to maintain
+            // push/pop symmetry
+            pushPrimaryTreeSuspenseHandler(workInProgress); // We know that this component will suspend again because if it has
+            // been unsuspended it has committed as a resolved Suspense component.
+            // If it needs to be retried, it should have work scheduled on it.
+
+            workInProgress.flags |= DidCapture; // We should never render the children of a dehydrated boundary until we
+            // upgrade it. We return null instead of bailoutOnAlreadyFinishedWork.
+
+            return null;
+          } // If this boundary is currently timed out, we need to decide
+          // whether to retry the primary children, or to skip over it and
+          // go straight to the fallback. Check the priority of the primary
+          // child fragment.
+
+
+          const primaryChildFragment = workInProgress.child;
+          const primaryChildLanes = primaryChildFragment.childLanes;
+
+          if (includesSomeLane(renderLanes, primaryChildLanes)) {
+            // The primary children have pending work. Use the normal path
+            // to attempt to render the primary children again.
+            return updateSuspenseComponent(current, workInProgress, renderLanes);
+          } else {
+            // The primary child fragment does not have pending work marked
+            // on it
+            pushPrimaryTreeSuspenseHandler(workInProgress); // The primary children do not have pending work with sufficient
+            // priority. Bailout.
+
+            const child = bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+
+            if (child !== null) {
+              // The fallback children have pending work. Skip over the
+              // primary children and work on the fallback.
+              return child.sibling;
+            } else {
+              // Note: We can return `null` here because we already checked
+              // whether there were nested context consumers, via the call to
+              // `bailoutOnAlreadyFinishedWork` above.
+              return null;
+            }
+          }
+        } else {
+          pushPrimaryTreeSuspenseHandler(workInProgress);
+        }
+
+        break;
+      }
+
+    case SuspenseListComponent:
+      {
+        const didSuspendBefore = (current.flags & DidCapture) !== NoFlags$1;
+        let hasChildWork = includesSomeLane(renderLanes, workInProgress.childLanes);
+
+        if (didSuspendBefore) {
+          if (hasChildWork) {
+            // If something was in fallback state last time, and we have all the
+            // same children then we're still in progressive loading state.
+            // Something might get unblocked by state updates or retries in the
+            // tree which will affect the tail. So we need to use the normal
+            // path to compute the correct tail.
+            return updateSuspenseListComponent(current, workInProgress, renderLanes);
+          } // If none of the children had any work, that means that none of
+          // them got retried so they'll still be blocked in the same way
+          // as before. We can fast bail out.
+
+
+          workInProgress.flags |= DidCapture;
+        } // If nothing suspended before and we're rendering the same children,
+        // then the tail doesn't matter. Anything new that suspends will work
+        // in the "together" mode, so we can continue from the state we had.
+
+
+        const renderState = workInProgress.memoizedState;
+
+        if (renderState !== null) {
+          // Reset to the "together" mode in case we've started a different
+          // update in the past but didn't complete it.
+          renderState.rendering = null;
+          renderState.tail = null;
+          renderState.lastEffect = null;
+        }
+
+        pushSuspenseListContext(workInProgress, suspenseStackCursor.current);
+
+        if (hasChildWork) {
+          break;
+        } else {
+          // If none of the children had any work, that means that none of
+          // them got retried so they'll still be blocked in the same way
+          // as before. We can fast bail out.
+          return null;
+        }
+      }
+
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      {
+        // Need to check if the tree still needs to be deferred. This is
+        // almost identical to the logic used in the normal update path,
+        // so we'll just enter that. The only difference is we'll bail out
+        // at the next level instead of this one, because the child props
+        // have not changed. Which is fine.
+        // TODO: Probably should refactor `beginWork` to split the bailout
+        // path from the normal path. I'm tempted to do a labeled break here
+        // but I won't :)
+        workInProgress.lanes = NoLanes;
+        return updateOffscreenComponent(current, workInProgress, renderLanes);
+      }
+
+    case CacheComponent:
+      {
+        {
+          const cache = current.memoizedState.cache;
+          pushCacheProvider(workInProgress, cache);
+        }
+
+        break;
+      }
+  }
+
+  return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+}
+
+function beginWork$1(current, workInProgress, renderLanes) {
+
+  if (current !== null) {
+    const oldProps = current.memoizedProps;
+    const newProps = workInProgress.pendingProps;
+
+    if (oldProps !== newProps || hasContextChanged() || ( // Force a re-render if the implementation changed due to hot reload:
+    false)) {
+      // If props or context changed, mark the fiber as having performed work.
+      // This may be unset if the props are determined to be equal later (memo).
+      didReceiveUpdate = true;
+    } else {
+      // Neither props nor legacy context changes. Check if there's a pending
+      // update or context change.
+      const hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(current, renderLanes);
+
+      if (!hasScheduledUpdateOrContext && // If this is the second pass of an error or suspense boundary, there
+      // may not be work scheduled on `current`, so we check for this flag.
+      (workInProgress.flags & DidCapture) === NoFlags$1) {
+        // No pending updates or context. Bail out now.
+        didReceiveUpdate = false;
+        return attemptEarlyBailoutIfNoScheduledUpdate(current, workInProgress, renderLanes);
+      }
+
+      if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags$1) {
+        // This is a special case that only exists for legacy mode.
+        // See https://github.com/facebook/react/pull/19216.
+        didReceiveUpdate = true;
+      } else {
+        // An update was scheduled on this fiber, but there are no new props
+        // nor legacy context. Set this to false. If an update queue or context
+        // consumer produces a changed value, it will set this to true. Otherwise,
+        // the component will assume the children have not changed and bail out.
+        didReceiveUpdate = false;
+      }
+    }
+  } else {
+    didReceiveUpdate = false;
+
+    if (getIsHydrating() && isForkedChild(workInProgress)) {
+      // Check if this child belongs to a list of muliple children in
+      // its parent.
+      //
+      // In a true multi-threaded implementation, we would render children on
+      // parallel threads. This would represent the beginning of a new render
+      // thread for this subtree.
+      //
+      // We only use this for id generation during hydration, which is why the
+      // logic is located in this special branch.
+      const slotIndex = workInProgress.index;
+      const numberOfForks = getForksAtLevel();
+      pushTreeId(workInProgress, numberOfForks, slotIndex);
+    }
+  } // Before entering the begin phase, clear pending update priority.
+  // TODO: This assumes that we're about to evaluate the component and process
+  // the update queue. However, there's an exception: SimpleMemoComponent
+  // sometimes bails out later in the begin phase. This indicates that we should
+  // move this assignment out of the common path and into each branch.
+
+
+  workInProgress.lanes = NoLanes;
+
+  switch (workInProgress.tag) {
+    case IndeterminateComponent:
+      {
+        return mountIndeterminateComponent(current, workInProgress, workInProgress.type, renderLanes);
+      }
+
+    case LazyComponent:
+      {
+        const elementType = workInProgress.elementType;
+        return mountLazyComponent(current, workInProgress, elementType, renderLanes);
+      }
+
+    case FunctionComponent:
+      {
+        const Component = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps;
+        const resolvedProps = workInProgress.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        return updateFunctionComponent(current, workInProgress, Component, resolvedProps, renderLanes);
+      }
+
+    case ClassComponent:
+      {
+        const Component = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps;
+        const resolvedProps = workInProgress.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        return updateClassComponent(current, workInProgress, Component, resolvedProps, renderLanes);
+      }
+
+    case HostRoot:
+      return updateHostRoot(current, workInProgress, renderLanes);
+
+    case HostHoistable:
+      {
+        return updateHostHoistable(current, workInProgress);
+      }
+
+    // Fall through
+
+    case HostSingleton:
+      {
+        return updateHostSingleton(current, workInProgress, renderLanes);
+      }
+
+    // Fall through
+
+    case HostComponent:
+      return updateHostComponent$1(current, workInProgress, renderLanes);
+
+    case HostText:
+      return updateHostText$1(current, workInProgress);
+
+    case SuspenseComponent:
+      return updateSuspenseComponent(current, workInProgress, renderLanes);
+
+    case HostPortal:
+      return updatePortalComponent(current, workInProgress, renderLanes);
+
+    case ForwardRef:
+      {
+        const type = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps;
+        const resolvedProps = workInProgress.elementType === type ? unresolvedProps : resolveDefaultProps(type, unresolvedProps);
+        return updateForwardRef(current, workInProgress, type, resolvedProps, renderLanes);
+      }
+
+    case Fragment:
+      return updateFragment(current, workInProgress, renderLanes);
+
+    case Mode:
+      return updateMode(current, workInProgress, renderLanes);
+
+    case Profiler:
+      return updateProfiler(current, workInProgress, renderLanes);
+
+    case ContextProvider:
+      return updateContextProvider(current, workInProgress, renderLanes);
+
+    case ContextConsumer:
+      return updateContextConsumer(current, workInProgress, renderLanes);
+
+    case MemoComponent:
+      {
+        const type = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps; // Resolve outer props first, then resolve inner props.
+
+        let resolvedProps = resolveDefaultProps(type, unresolvedProps);
+
+        resolvedProps = resolveDefaultProps(type.type, resolvedProps);
+        return updateMemoComponent(current, workInProgress, type, resolvedProps, renderLanes);
+      }
+
+    case SimpleMemoComponent:
+      {
+        return updateSimpleMemoComponent(current, workInProgress, workInProgress.type, workInProgress.pendingProps, renderLanes);
+      }
+
+    case IncompleteClassComponent:
+      {
+        const Component = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps;
+        const resolvedProps = workInProgress.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        return mountIncompleteClassComponent(current, workInProgress, Component, resolvedProps, renderLanes);
+      }
+
+    case SuspenseListComponent:
+      {
+        return updateSuspenseListComponent(current, workInProgress, renderLanes);
+      }
+
+    case ScopeComponent:
+      {
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        return updateOffscreenComponent(current, workInProgress, renderLanes);
+      }
+
+    case LegacyHiddenComponent:
+      {
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        {
+          return updateCacheComponent(current, workInProgress, renderLanes);
+        }
+      }
+  }
+
+  throw Error(formatProdErrorMessage(156, workInProgress.tag));
+}
+
+const valueCursor = createCursor(null);
+
+let currentlyRenderingFiber = null;
+let lastContextDependency = null;
+let lastFullyObservedContext = null;
+function resetContextDependencies() {
+  // This is called right before React yields execution, to ensure `readContext`
+  // cannot be called outside the render phase.
+  currentlyRenderingFiber = null;
+  lastContextDependency = null;
+  lastFullyObservedContext = null;
+}
+function pushProvider(providerFiber, context, nextValue) {
+  {
+    push(valueCursor, context._currentValue);
+    context._currentValue = nextValue;
+  }
+}
+function popProvider(context, providerFiber) {
+  const currentValue = valueCursor.current;
+
+  {
+    {
+      context._currentValue = currentValue;
+    }
+  }
+
+  pop(valueCursor);
+}
+function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
+  // Update the child lanes of all the ancestors, including the alternates.
+  let node = parent;
+
+  while (node !== null) {
+    const alternate = node.alternate;
+
+    if (!isSubsetOfLanes(node.childLanes, renderLanes)) {
+      node.childLanes = mergeLanes(node.childLanes, renderLanes);
+
+      if (alternate !== null) {
+        alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
+      }
+    } else if (alternate !== null && !isSubsetOfLanes(alternate.childLanes, renderLanes)) {
+      alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
+    } else ;
+
+    if (node === propagationRoot) {
+      break;
+    }
+
+    node = node.return;
+  }
+}
+function propagateContextChange(workInProgress, context, renderLanes) {
+  {
+    propagateContextChange_eager(workInProgress, context, renderLanes);
+  }
+}
+
+function propagateContextChange_eager(workInProgress, context, renderLanes) {
+
+  let 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) {
+    let nextFiber; // Visit this fiber.
+
+    const list = fiber.dependencies;
+
+    if (list !== null) {
+      nextFiber = fiber.child;
+      let dependency = list.firstContext;
+
+      while (dependency !== null) {
+        // Check if the context matches.
+        if (dependency.context === context) {
+          // Match! Schedule an update on this fiber.
+          if (fiber.tag === ClassComponent) {
+            // Schedule a force update on the work-in-progress.
+            const lane = pickArbitraryLane(renderLanes);
+            const update = createUpdate(lane);
+            update.tag = ForceUpdate; // TODO: Because we don't have a work-in-progress, this will add the
+            // update to the current fiber, too, which means it will persist even if
+            // this render is thrown away. Since it's a race condition, not sure it's
+            // worth fixing.
+            // Inlined `enqueueUpdate` to remove interleaved update check
+
+            const updateQueue = fiber.updateQueue;
+
+            if (updateQueue === null) ; else {
+              const sharedQueue = updateQueue.shared;
+              const pending = sharedQueue.pending;
+
+              if (pending === null) {
+                // This is the first update. Create a circular list.
+                update.next = update;
+              } else {
+                update.next = pending.next;
+                pending.next = update;
+              }
+
+              sharedQueue.pending = update;
+            }
+          }
+
+          fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
+          const alternate = fiber.alternate;
+
+          if (alternate !== null) {
+            alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+          }
+
+          scheduleContextWorkOnParentPath(fiber.return, renderLanes, workInProgress); // Mark the updated lanes on the list, too.
+
+          list.lanes = mergeLanes(list.lanes, renderLanes); // Since we already found a match, we can stop traversing the
+          // dependency list.
+
+          break;
+        }
+
+        dependency = dependency.next;
+      }
+    } else if (fiber.tag === ContextProvider) {
+      // Don't scan deeper if this is a matching provider
+      nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
+    } else if (fiber.tag === DehydratedFragment) {
+      // If a dehydrated suspense boundary is in this subtree, we don't know
+      // if it will have any context consumers in it. The best we can do is
+      // mark it as having updates.
+      const parentSuspense = fiber.return;
+
+      if (parentSuspense === null) {
+        throw Error(formatProdErrorMessage(341));
+      }
+
+      parentSuspense.lanes = mergeLanes(parentSuspense.lanes, renderLanes);
+      const alternate = parentSuspense.alternate;
+
+      if (alternate !== null) {
+        alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+      } // This is intentionally passing this fiber as the parent
+      // because we want to schedule this fiber as having work
+      // on its children. We'll use the childLanes on
+      // this fiber to indicate that a context has changed.
+
+
+      scheduleContextWorkOnParentPath(parentSuspense, renderLanes, workInProgress);
+      nextFiber = fiber.sibling;
+    } else {
+      // Traverse down.
+      nextFiber = fiber.child;
+    }
+
+    if (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;
+        }
+
+        const 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 prepareToReadContext(workInProgress, renderLanes) {
+  currentlyRenderingFiber = workInProgress;
+  lastContextDependency = null;
+  lastFullyObservedContext = null;
+  const dependencies = workInProgress.dependencies;
+
+  if (dependencies !== null) {
+    {
+      const firstContext = dependencies.firstContext;
+
+      if (firstContext !== null) {
+        if (includesSomeLane(dependencies.lanes, renderLanes)) {
+          // Context list has a pending update. Mark that this fiber performed work.
+          markWorkInProgressReceivedUpdate();
+        } // Reset the work-in-progress list
+
+
+        dependencies.firstContext = null;
+      }
+    }
+  }
+}
+function readContext(context) {
+
+  return readContextForConsumer(currentlyRenderingFiber, context);
+}
+function readContextDuringReconcilation(consumer, context, renderLanes) {
+  if (currentlyRenderingFiber === null) {
+    prepareToReadContext(consumer, renderLanes);
+  }
+
+  return readContextForConsumer(consumer, context);
+}
+
+function readContextForConsumer(consumer, context) {
+  const value = context._currentValue ;
+
+  if (lastFullyObservedContext === context) ; else {
+    const contextItem = {
+      context: context,
+      memoizedValue: value,
+      next: null
+    };
+
+    if (lastContextDependency === null) {
+      if (consumer === null) {
+        throw Error(formatProdErrorMessage(308));
+      } // This is the first dependency for this component. Create a new list.
+
+
+      lastContextDependency = contextItem;
+      consumer.dependencies = {
+        lanes: NoLanes,
+        firstContext: contextItem
+      };
+    } else {
+      // Append a new context item.
+      lastContextDependency = lastContextDependency.next = contextItem;
+    }
+  }
+
+  return value;
+}
+
+// replace it with a lightweight shim that only has the features we use.
+
+const AbortControllerLocal = typeof AbortController !== 'undefined' ? AbortController : // $FlowFixMe[missing-this-annot]
+// $FlowFixMe[prop-missing]
+function AbortControllerShim() {
+  const listeners = [];
+  const signal = this.signal = {
+    aborted: false,
+    addEventListener: (type, listener) => {
+      listeners.push(listener);
+    }
+  };
+
+  this.abort = () => {
+    signal.aborted = true;
+    listeners.forEach(listener => listener());
+  };
+} ; // Intentionally not named imports because Rollup would
+// use dynamic dispatch for CommonJS interop named imports.
+
+const scheduleCallback$1 = Scheduler.unstable_scheduleCallback,
+      NormalPriority = Scheduler.unstable_NormalPriority;
+const CacheContext = {
+  $$typeof: REACT_CONTEXT_TYPE,
+  // We don't use Consumer/Provider for Cache components. So we'll cheat.
+  Consumer: null,
+  Provider: null,
+  // We'll initialize these at the root.
+  _currentValue: null,
+  _currentValue2: null,
+  _threadCount: 0,
+  _defaultValue: null,
+  _globalName: null
+} ;
+// for retaining the cache once it is in use (retainCache), and releasing the cache
+// once it is no longer needed (releaseCache).
+
+
+function createCache() {
+
+  const cache = {
+    controller: new AbortControllerLocal(),
+    data: new Map(),
+    refCount: 0
+  };
+  return cache;
+}
+function retainCache(cache) {
+
+  cache.refCount++;
+} // Cleanup a cache instance, potentially freeing it if there are no more references
+
+function releaseCache(cache) {
+
+  cache.refCount--;
+
+  if (cache.refCount === 0) {
+    scheduleCallback$1(NormalPriority, () => {
+      cache.controller.abort();
+    });
+  }
+}
+function pushCacheProvider(workInProgress, cache) {
+
+  pushProvider(workInProgress, CacheContext, cache);
+}
+function popCacheProvider(workInProgress, cache) {
+
+  popProvider(CacheContext);
+}
+
+const ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig;
+const NoTransition = null;
+function requestCurrentTransition() {
+  return ReactCurrentBatchConfig$2.transition;
+} // When retrying a Suspense/Offscreen boundary, we restore the cache that was
+// used during the previous render by placing it here, on the stack.
+
+const resumedCache = createCursor(null); // During the render/synchronous commit phase, we don't actually process the
+
+function peekCacheFromPool() {
+  // If we're rendering inside a Suspense boundary that is currently hidden,
+  // we should use the same cache that we used during the previous render, if
+  // one exists.
+
+
+  const cacheResumedFromPreviousRender = resumedCache.current;
+
+  if (cacheResumedFromPreviousRender !== null) {
+    return cacheResumedFromPreviousRender;
+  } // Otherwise, check the root's cache pool.
+
+
+  const root = getWorkInProgressRoot();
+  const cacheFromRootCachePool = root.pooledCache;
+  return cacheFromRootCachePool;
+}
+
+function requestCacheFromPool(renderLanes) {
+  // Similar to previous function, except if there's not already a cache in the
+  // pool, we allocate a new one.
+  const cacheFromPool = peekCacheFromPool();
+
+  if (cacheFromPool !== null) {
+    return cacheFromPool;
+  } // Create a fresh cache and add it to the root cache pool. A cache can have
+  // multiple owners:
+  // - A cache pool that lives on the FiberRoot. This is where all fresh caches
+  //   are originally created (TODO: except during refreshes, until we implement
+  //   this correctly). The root takes ownership immediately when the cache is
+  //   created. Conceptually, root.pooledCache is an Option<Arc<Cache>> (owned),
+  //   and the return value of this function is a &Arc<Cache> (borrowed).
+  // - One of several fiber types: host root, cache boundary, suspense
+  //   component. These retain and release in the commit phase.
+
+
+  const root = getWorkInProgressRoot();
+  const freshCache = createCache();
+  root.pooledCache = freshCache;
+  retainCache(freshCache);
+
+  if (freshCache !== null) {
+    root.pooledCacheLanes |= renderLanes;
+  }
+
+  return freshCache;
+}
+function pushTransition(offscreenWorkInProgress, prevCachePool, newTransitions) {
+  {
+    if (prevCachePool === null) {
+      push(resumedCache, resumedCache.current);
+    } else {
+      push(resumedCache, prevCachePool.pool);
+    }
+  }
+}
+function popTransition(workInProgress, current) {
+  if (current !== null) {
+
+    {
+      pop(resumedCache);
+    }
+  }
+}
+function getSuspendedCache() {
+  // cache that would have been used to render fresh data during this render,
+  // if there was any, so that we can resume rendering with the same cache when
+  // we receive more data.
+
+
+  const cacheFromPool = peekCacheFromPool();
+
+  if (cacheFromPool === null) {
+    return null;
+  }
+
+  return {
+    // We must also save the parent, so that when we resume we can detect
+    // a refresh.
+    parent: CacheContext._currentValue ,
+    pool: cacheFromPool
+  };
+}
+function getOffscreenDeferredCache() {
+
+  const cacheFromPool = peekCacheFromPool();
+
+  if (cacheFromPool === null) {
+    return null;
+  }
+
+  return {
+    // We must also store the parent, so that when we resume we can detect
+    // a refresh.
+    parent: CacheContext._currentValue ,
+    pool: cacheFromPool
+  };
+}
+
+function markUpdate(workInProgress) {
+  // Tag the fiber with an update effect. This turns a Placement into
+  // a PlacementAndUpdate.
+  workInProgress.flags |= Update;
+}
+
+function markRef(workInProgress) {
+  workInProgress.flags |= Ref | RefStatic;
+}
+
+function appendAllChildren(parent, workInProgress, needsVisibilityToggle, isHidden) {
+  {
+    // We only have the top Fiber that was created but we need recurse down its
+    // children to find all the terminal nodes.
+    let node = workInProgress.child;
+
+    while (node !== null) {
+      if (node.tag === HostComponent || node.tag === HostText) {
+        appendInitialChild(parent, node.stateNode);
+      } else if (node.tag === HostPortal || (node.tag === HostSingleton )) ; else if (node.child !== null) {
+        node.child.return = node;
+        node = node.child;
+        continue;
+      }
+
+      if (node === workInProgress) {
+        return;
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+      while (node.sibling === null) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        if (node.return === null || node.return === workInProgress) {
+          return;
+        }
+
+        node = node.return;
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+      node.sibling.return = node.return;
+      node = node.sibling;
+    }
+  }
+} // An unfortunate fork of appendAllChildren because we have two different parent types.
+
+function updateHostComponent(current, workInProgress, type, newProps, renderLanes) {
+  {
+    // If we have an alternate, that means this is an update and we need to
+    // schedule a side-effect to do the updates.
+    const oldProps = current.memoizedProps;
+
+    if (oldProps === newProps) {
+      // In mutation mode, this is sufficient for a bailout because
+      // we won't touch this node even if children changed.
+      return;
+    }
+
+    markUpdate(workInProgress);
+  }
+} // This function must be called at the very end of the complete phase, because
+// it might throw to suspend, and if the resource immediately loads, the work
+// loop will resume rendering as if the work-in-progress completed. So it must
+// fully complete.
+// TODO: This should ideally move to begin phase, but currently the instance is
+// not created until the complete phase. For our existing use cases, host nodes
+// that suspend don't have children, so it doesn't matter. But that might not
+// always be true in the future.
+
+
+function preloadInstanceAndSuspendIfNeeded(workInProgress, type, props, renderLanes) {
+  {
+    // If this flag was set previously, we can remove it. The flag
+    // represents whether this particular set of props might ever need to
+    // suspend. The safest thing to do is for maySuspendCommit to always
+    // return true, but if the renderer is reasonably confident that the
+    // underlying resource won't be evicted, it can return false as a
+    // performance optimization.
+    workInProgress.flags &= ~MaySuspendCommit;
+    return;
+  } // Mark this fiber with a flag. This gets set on all host instances
+}
+
+function preloadResourceAndSuspendIfNeeded(workInProgress, resource, type, props, renderLanes) {
+  // This is a fork of preloadInstanceAndSuspendIfNeeded, but for resources.
+  if (!mayResourceSuspendCommit(resource)) {
+    workInProgress.flags &= ~MaySuspendCommit;
+    return;
+  }
+
+  workInProgress.flags |= MaySuspendCommit;
+  const rootRenderLanes = getWorkInProgressRootRenderLanes();
+
+  if (!includesOnlyNonUrgentLanes(rootRenderLanes)) ; else {
+    const isReady = preloadResource(resource);
+
+    if (!isReady) {
+      if (shouldRemainOnPreviousScreen()) {
+        workInProgress.flags |= ShouldSuspendCommit;
+      } else {
+        suspendCommit();
+      }
+    }
+  }
+}
+
+function scheduleRetryEffect(workInProgress, retryQueue) {
+  const wakeables = retryQueue;
+
+  if (wakeables !== null) {
+    // Schedule an effect to attach a retry listener to the promise.
+    // TODO: Move to passive phase
+    workInProgress.flags |= Update;
+  } else {
+    // This boundary suspended, but no wakeables were added to the retry
+    // queue. Check if the renderer suspended commit. If so, this means
+    // that once the fallback is committed, we can immediately retry
+    // rendering again, because rendering wasn't actually blocked. Only
+    // the commit phase.
+    // TODO: Consider a model where we always schedule an immediate retry, even
+    // for normal Suspense. That way the retry can partially render up to the
+    // first thing that suspends.
+    if (workInProgress.flags & ScheduleRetry) {
+      const retryLane = // TODO: This check should probably be moved into claimNextRetryLane
+      // I also suspect that we need some further consolidation of offscreen
+      // and retry lanes.
+      workInProgress.tag !== OffscreenComponent ? claimNextRetryLane() : OffscreenLane;
+      workInProgress.lanes = mergeLanes(workInProgress.lanes, retryLane);
+    }
+  }
+}
+
+function updateHostText(current, workInProgress, oldText, newText) {
+  {
+    // If the text differs, mark it as an update. All the work in done in commitWork.
+    if (oldText !== newText) {
+      markUpdate(workInProgress);
+    }
+  }
+}
+
+function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
+  if (getIsHydrating()) {
+    // If we're hydrating, we should consume as many items as we can
+    // so we don't leave any behind.
+    return;
+  }
+
+  switch (renderState.tailMode) {
+    case 'hidden':
+      {
+        // Any insertions at the end of the tail list after this point
+        // should be invisible. If there are already mounted boundaries
+        // anything before them are not considered for collapsing.
+        // Therefore we need to go through the whole tail to find if
+        // there are any.
+        let tailNode = renderState.tail;
+        let lastTailNode = null;
+
+        while (tailNode !== null) {
+          if (tailNode.alternate !== null) {
+            lastTailNode = tailNode;
+          }
+
+          tailNode = tailNode.sibling;
+        } // Next we're simply going to delete all insertions after the
+        // last rendered item.
+
+
+        if (lastTailNode === null) {
+          // All remaining items in the tail are insertions.
+          renderState.tail = null;
+        } else {
+          // Detach the insertion after the last node that was already
+          // inserted.
+          lastTailNode.sibling = null;
+        }
+
+        break;
+      }
+
+    case 'collapsed':
+      {
+        // Any insertions at the end of the tail list after this point
+        // should be invisible. If there are already mounted boundaries
+        // anything before them are not considered for collapsing.
+        // Therefore we need to go through the whole tail to find if
+        // there are any.
+        let tailNode = renderState.tail;
+        let lastTailNode = null;
+
+        while (tailNode !== null) {
+          if (tailNode.alternate !== null) {
+            lastTailNode = tailNode;
+          }
+
+          tailNode = tailNode.sibling;
+        } // Next we're simply going to delete all insertions after the
+        // last rendered item.
+
+
+        if (lastTailNode === null) {
+          // All remaining items in the tail are insertions.
+          if (!hasRenderedATailFallback && renderState.tail !== null) {
+            // We suspended during the head. We want to show at least one
+            // row at the tail. So we'll keep on and cut off the rest.
+            renderState.tail.sibling = null;
+          } else {
+            renderState.tail = null;
+          }
+        } else {
+          // Detach the insertion after the last node that was already
+          // inserted.
+          lastTailNode.sibling = null;
+        }
+
+        break;
+      }
+  }
+}
+
+function bubbleProperties(completedWork) {
+  const didBailout = completedWork.alternate !== null && completedWork.alternate.child === completedWork.child;
+  let newChildLanes = NoLanes;
+  let subtreeFlags = NoFlags$1;
+
+  if (!didBailout) {
+    // Bubble up the earliest expiration time.
+    {
+      let child = completedWork.child;
+
+      while (child !== null) {
+        newChildLanes = mergeLanes(newChildLanes, mergeLanes(child.lanes, child.childLanes));
+        subtreeFlags |= child.subtreeFlags;
+        subtreeFlags |= child.flags; // Update the return pointer so the tree is consistent. This is a code
+        // smell because it assumes the commit phase is never concurrent with
+        // the render phase. Will address during refactor to alternate model.
+
+        child.return = completedWork;
+        child = child.sibling;
+      }
+    }
+
+    completedWork.subtreeFlags |= subtreeFlags;
+  } else {
+    // Bubble up the earliest expiration time.
+    {
+      let child = completedWork.child;
+
+      while (child !== null) {
+        newChildLanes = mergeLanes(newChildLanes, mergeLanes(child.lanes, child.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 |= child.subtreeFlags & StaticMask;
+        subtreeFlags |= child.flags & StaticMask; // Update the return pointer so the tree is consistent. This is a code
+        // smell because it assumes the commit phase is never concurrent with
+        // the render phase. Will address during refactor to alternate model.
+
+        child.return = completedWork;
+        child = child.sibling;
+      }
+    }
+
+    completedWork.subtreeFlags |= subtreeFlags;
+  }
+
+  completedWork.childLanes = newChildLanes;
+  return didBailout;
+}
+
+function completeDehydratedSuspenseBoundary(current, workInProgress, nextState) {
+  if (hasUnhydratedTailNodes() && (workInProgress.mode & ConcurrentMode) !== NoMode && (workInProgress.flags & DidCapture) === NoFlags$1) {
+    warnIfUnhydratedTailNodes();
+    resetHydrationState();
+    workInProgress.flags |= ForceClientRender | DidCapture;
+    return false;
+  }
+
+  const wasHydrated = popHydrationState(workInProgress);
+
+  if (nextState !== null && nextState.dehydrated !== null) {
+    // We might be inside a hydration state the first time we're picking up this
+    // Suspense boundary, and also after we've reentered it for further hydration.
+    if (current === null) {
+      if (!wasHydrated) {
+        throw Error(formatProdErrorMessage(318));
+      }
+
+      prepareToHydrateHostSuspenseInstance(workInProgress);
+      bubbleProperties(workInProgress);
+
+      return false;
+    } else {
+      // We might have reentered this boundary to hydrate it. If so, we need to reset the hydration
+      // state since we're now exiting out of it. popHydrationState doesn't do that for us.
+      resetHydrationState();
+
+      if ((workInProgress.flags & DidCapture) === NoFlags$1) {
+        // This boundary did not suspend so it's now hydrated and unsuspended.
+        workInProgress.memoizedState = null;
+      } // If nothing suspended, we need to schedule an effect to mark this boundary
+      // as having hydrated so events know that they're free to be invoked.
+      // It's also a signal to replay events and the suspense callback.
+      // If something suspended, schedule an effect to attach retry listeners.
+      // So we might as well always mark this.
+
+
+      workInProgress.flags |= Update;
+      bubbleProperties(workInProgress);
+
+      return false;
+    }
+  } else {
+    // Successfully completed this tree. If this was a forced client render,
+    // there may have been recoverable errors during first hydration
+    // attempt. If so, add them to a queue so we can log them in the
+    // commit phase.
+    upgradeHydrationErrorsToRecoverable(); // Fall through to normal Suspense path
+
+    return true;
+  }
+}
+
+function completeWork(current, workInProgress, renderLanes) {
+  const newProps = workInProgress.pendingProps; // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
+
+  popTreeContext(workInProgress);
+
+  switch (workInProgress.tag) {
+    case IndeterminateComponent:
+    case LazyComponent:
+    case SimpleMemoComponent:
+    case FunctionComponent:
+    case ForwardRef:
+    case Fragment:
+    case Mode:
+    case Profiler:
+    case ContextConsumer:
+    case MemoComponent:
+      bubbleProperties(workInProgress);
+      return null;
+
+    case ClassComponent:
+      {
+        const Component = workInProgress.type;
+
+        if (isContextProvider(Component)) {
+          popContext();
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
+
+    case HostRoot:
+      {
+        const fiberRoot = workInProgress.stateNode;
+
+        {
+          let previousCache = null;
+
+          if (current !== null) {
+            previousCache = current.memoizedState.cache;
+          }
+
+          const cache = workInProgress.memoizedState.cache;
+
+          if (cache !== previousCache) {
+            // Run passive effects to retain/release the cache.
+            workInProgress.flags |= Passive$1;
+          }
+
+          popCacheProvider();
+        }
+        popHostContainer();
+        popTopLevelContextObject();
+
+        if (fiberRoot.pendingContext) {
+          fiberRoot.context = fiberRoot.pendingContext;
+          fiberRoot.pendingContext = null;
+        }
+
+        if (current === null || current.child === null) {
+          // If we hydrated, pop so that we can delete any remaining children
+          // that weren't hydrated.
+          const wasHydrated = popHydrationState(workInProgress);
+
+          if (wasHydrated) {
+            // If we hydrated, then we'll need to schedule an update for
+            // the commit side-effects on the root.
+            markUpdate(workInProgress);
+          } else {
+            if (current !== null) {
+              const prevState = current.memoizedState;
+
+              if ( // Check if this is a client root
+              !prevState.isDehydrated || // Check if we reverted to client rendering (e.g. due to an error)
+              (workInProgress.flags & ForceClientRender) !== NoFlags$1) {
+                // Schedule an effect to clear this container at the start of the
+                // next commit. This handles the case of React rendering into a
+                // container with previous children. It's also safe to do for
+                // updates too, because current.child would only be null if the
+                // previous render was null (so the container would already
+                // be empty).
+                workInProgress.flags |= Snapshot; // If this was a forced client render, there may have been
+                // recoverable errors during first hydration attempt. If so, add
+                // them to a queue so we can log them in the commit phase.
+
+                upgradeHydrationErrorsToRecoverable();
+              }
+            }
+          }
+        }
+        bubbleProperties(workInProgress);
+
+        return null;
+      }
+
+    case HostHoistable:
+      {
+        {
+          const nextResource = workInProgress.memoizedState;
+
+          if (current === null) {
+            // We are mounting and must Update this Hoistable in this commit
+            // @TODO refactor this block to create the instance here in complete
+            // phase if we are not hydrating.
+            markUpdate(workInProgress);
+
+            if (workInProgress.ref !== null) {
+              markRef(workInProgress);
+            }
+
+            if (nextResource !== null) {
+              // This is a Hoistable Resource
+              // This must come at the very end of the complete phase.
+              bubbleProperties(workInProgress);
+              preloadResourceAndSuspendIfNeeded(workInProgress, nextResource);
+              return null;
+            } else {
+              // This is a Hoistable Instance
+              // This must come at the very end of the complete phase.
+              bubbleProperties(workInProgress);
+              preloadInstanceAndSuspendIfNeeded(workInProgress);
+              return null;
+            }
+          } else {
+            // We are updating.
+            const currentResource = current.memoizedState;
+
+            if (nextResource !== currentResource) {
+              // We are transitioning to, from, or between Hoistable Resources
+              // and require an update
+              markUpdate(workInProgress);
+            }
+
+            if (current.ref !== workInProgress.ref) {
+              markRef(workInProgress);
+            }
+
+            if (nextResource !== null) {
+              // This is a Hoistable Resource
+              // This must come at the very end of the complete phase.
+              bubbleProperties(workInProgress);
+
+              if (nextResource === currentResource) {
+                workInProgress.flags &= ~MaySuspendCommit;
+              } else {
+                preloadResourceAndSuspendIfNeeded(workInProgress, nextResource);
+              }
+
+              return null;
+            } else {
+              // This is a Hoistable Instance
+              // We may have props to update on the Hoistable instance.
+              {
+                const oldProps = current.memoizedProps;
+
+                if (oldProps !== newProps) {
+                  markUpdate(workInProgress);
+                }
+              } // This must come at the very end of the complete phase.
+
+
+              bubbleProperties(workInProgress);
+              preloadInstanceAndSuspendIfNeeded(workInProgress);
+              return null;
+            }
+          }
+        } // Fall through
+
+      }
+
+    case HostSingleton:
+      {
+        {
+          popHostContext(workInProgress);
+          const rootContainerInstance = getRootHostContainer();
+          const type = workInProgress.type;
+
+          if (current !== null && workInProgress.stateNode != null) {
+            {
+              const oldProps = current.memoizedProps;
+
+              if (oldProps !== newProps) {
+                markUpdate(workInProgress);
+              }
+            }
+
+            if (current.ref !== workInProgress.ref) {
+              markRef(workInProgress);
+            }
+          } else {
+            if (!newProps) {
+              if (workInProgress.stateNode === null) {
+                throw Error(formatProdErrorMessage(166));
+              } // This can happen when we abort work.
+
+
+              bubbleProperties(workInProgress);
+              return null;
+            }
+
+            const currentHostContext = getHostContext();
+            const wasHydrated = popHydrationState(workInProgress);
+            let instance;
+
+            if (wasHydrated) {
+              // We ignore the boolean indicating there is an updateQueue because
+              // it is used only to set text children and HostSingletons do not
+              // use them.
+              prepareToHydrateHostInstance(workInProgress, currentHostContext);
+              instance = workInProgress.stateNode;
+            } else {
+              instance = resolveSingletonInstance(type, newProps, rootContainerInstance);
+              workInProgress.stateNode = instance;
+              markUpdate(workInProgress);
+            }
+
+            if (workInProgress.ref !== null) {
+              // If there is a ref on a host node we need to schedule a callback
+              markRef(workInProgress);
+            }
+          }
+
+          bubbleProperties(workInProgress);
+          return null;
+        } // Fall through
+
+      }
+
+    case HostComponent:
+      {
+        popHostContext(workInProgress);
+        const type = workInProgress.type;
+
+        if (current !== null && workInProgress.stateNode != null) {
+          updateHostComponent(current, workInProgress, type, newProps);
+
+          if (current.ref !== workInProgress.ref) {
+            markRef(workInProgress);
+          }
+        } else {
+          if (!newProps) {
+            if (workInProgress.stateNode === null) {
+              throw Error(formatProdErrorMessage(166));
+            } // This can happen when we abort work.
+
+
+            bubbleProperties(workInProgress);
+            return null;
+          }
+
+          const currentHostContext = getHostContext(); // TODO: Move createInstance to beginWork and keep it on a context
+          // "stack" as the parent. Then append children as we go in beginWork
+          // or completeWork depending on whether we want to add them top->down or
+          // bottom->up. Top->down is faster in IE11.
+
+          const wasHydrated = popHydrationState(workInProgress);
+
+          if (wasHydrated) {
+            // TODO: Move this and createInstance step into the beginPhase
+            // to consolidate.
+            prepareToHydrateHostInstance(workInProgress, currentHostContext);
+          } else {
+            const rootContainerInstance = getRootHostContainer();
+            const instance = createInstance(type, newProps, rootContainerInstance, currentHostContext, workInProgress); // TODO: For persistent renderers, we should pass children as part
+            // of the initial instance creation
+
+            appendAllChildren(instance, workInProgress);
+            workInProgress.stateNode = instance; // Certain renderers require commit-time effects for initial mount.
+            // (eg DOM renderer supports auto-focus for certain elements).
+            // Make sure such renderers get scheduled for later work.
+
+            if (finalizeInitialChildren(instance, type, newProps)) {
+              markUpdate(workInProgress);
+            }
+          }
+
+          if (workInProgress.ref !== null) {
+            // If there is a ref on a host node we need to schedule a callback
+            markRef(workInProgress);
+          }
+        }
+
+        bubbleProperties(workInProgress); // This must come at the very end of the complete phase, because it might
+        // throw to suspend, and if the resource immediately loads, the work loop
+        // will resume rendering as if the work-in-progress completed. So it must
+        // fully complete.
+
+        preloadInstanceAndSuspendIfNeeded(workInProgress);
+        return null;
+      }
+
+    case HostText:
+      {
+        const newText = newProps;
+
+        if (current && workInProgress.stateNode != null) {
+          const oldText = current.memoizedProps; // If we have an alternate, that means this is an update and we need
+          // to schedule a side-effect to do the updates.
+
+          updateHostText(current, workInProgress, oldText, newText);
+        } else {
+          if (typeof newText !== 'string') {
+            if (workInProgress.stateNode === null) {
+              throw Error(formatProdErrorMessage(166));
+            } // This can happen when we abort work.
+
+          }
+
+          const rootContainerInstance = getRootHostContainer();
+          const currentHostContext = getHostContext();
+          const wasHydrated = popHydrationState(workInProgress);
+
+          if (wasHydrated) {
+            if (prepareToHydrateHostTextInstance(workInProgress)) {
+              markUpdate(workInProgress);
+            }
+          } else {
+            workInProgress.stateNode = createTextInstance(newText, rootContainerInstance, currentHostContext, workInProgress);
+          }
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
+
+    case SuspenseComponent:
+      {
+        popSuspenseHandler(workInProgress);
+        const nextState = workInProgress.memoizedState; // Special path for dehydrated boundaries. We may eventually move this
+        // to its own fiber type so that we can add other kinds of hydration
+        // boundaries that aren't associated with a Suspense tree. In anticipation
+        // of such a refactor, all the hydration logic is contained in
+        // this branch.
+
+        if (current === null || current.memoizedState !== null && current.memoizedState.dehydrated !== null) {
+          const fallthroughToNormalSuspensePath = completeDehydratedSuspenseBoundary(current, workInProgress, nextState);
+
+          if (!fallthroughToNormalSuspensePath) {
+            if (workInProgress.flags & ForceClientRender) {
+              // Special case. There were remaining unhydrated nodes. We treat
+              // this as a mismatch. Revert to client rendering.
+              return workInProgress;
+            } else {
+              // Did not finish hydrating, either because this is the initial
+              // render or because something suspended.
+              return null;
+            }
+          } // Continue with the normal Suspense path.
+
+        }
+
+        if ((workInProgress.flags & DidCapture) !== NoFlags$1) {
+          // Something suspended. Re-render with the fallback children.
+          workInProgress.lanes = renderLanes; // Do not reset the effect list.
+
+
+          return workInProgress;
+        }
+
+        const nextDidTimeout = nextState !== null;
+        const prevDidTimeout = current !== null && current.memoizedState !== null;
+
+        if (nextDidTimeout) {
+          const offscreenFiber = workInProgress.child;
+          let previousCache = null;
+
+          if (offscreenFiber.alternate !== null && offscreenFiber.alternate.memoizedState !== null && offscreenFiber.alternate.memoizedState.cachePool !== null) {
+            previousCache = offscreenFiber.alternate.memoizedState.cachePool.pool;
+          }
+
+          let cache = null;
+
+          if (offscreenFiber.memoizedState !== null && offscreenFiber.memoizedState.cachePool !== null) {
+            cache = offscreenFiber.memoizedState.cachePool.pool;
+          }
+
+          if (cache !== previousCache) {
+            // Run passive effects to retain/release the cache.
+            offscreenFiber.flags |= Passive$1;
+          }
+        } // If the suspended state of the boundary changes, we need to schedule
+        // a passive effect, which is when we process the transitions
+
+
+        if (nextDidTimeout !== prevDidTimeout) {
+          // an effect to toggle the subtree's visibility. When we switch from
+          // fallback -> primary, the inner Offscreen fiber schedules this effect
+          // as part of its normal complete phase. But when we switch from
+          // primary -> fallback, the inner Offscreen fiber does not have a complete
+          // phase. So we need to schedule its effect here.
+          //
+          // We also use this flag to connect/disconnect the effects, but the same
+          // logic applies: when re-connecting, the Offscreen fiber's complete
+          // phase will handle scheduling the effect. It's only when the fallback
+          // is active that we have to do anything special.
+
+
+          if (nextDidTimeout) {
+            const offscreenFiber = workInProgress.child;
+            offscreenFiber.flags |= Visibility;
+          }
+        }
+
+        const retryQueue = workInProgress.updateQueue;
+        scheduleRetryEffect(workInProgress, retryQueue);
+
+        bubbleProperties(workInProgress);
+
+        return null;
+      }
+
+    case HostPortal:
+      popHostContainer();
+
+      if (current === null) {
+        preparePortalMount(workInProgress.stateNode.containerInfo);
+      }
+
+      bubbleProperties(workInProgress);
+      return null;
+
+    case ContextProvider:
+      // Pop provider fiber
+      const context = workInProgress.type._context;
+      popProvider(context);
+      bubbleProperties(workInProgress);
+      return null;
+
+    case IncompleteClassComponent:
+      {
+        // Same as class component case. I put it down here so that the tags are
+        // sequential to ensure this switch is compiled to a jump table.
+        const Component = workInProgress.type;
+
+        if (isContextProvider(Component)) {
+          popContext();
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
+
+    case SuspenseListComponent:
+      {
+        popSuspenseListContext();
+        const renderState = workInProgress.memoizedState;
+
+        if (renderState === null) {
+          // We're running in the default, "independent" mode.
+          // We don't do anything in this mode.
+          bubbleProperties(workInProgress);
+          return null;
+        }
+
+        let didSuspendAlready = (workInProgress.flags & DidCapture) !== NoFlags$1;
+        const renderedTail = renderState.rendering;
+
+        if (renderedTail === null) {
+          // We just rendered the head.
+          if (!didSuspendAlready) {
+            // This is the first pass. We need to figure out if anything is still
+            // suspended in the rendered set.
+            // If new content unsuspended, but there's still some content that
+            // didn't. Then we need to do a second pass that forces everything
+            // to keep showing their fallbacks.
+            // We might be suspended if something in this render pass suspended, or
+            // something in the previous committed pass suspended. Otherwise,
+            // there's no chance so we can skip the expensive call to
+            // findFirstSuspended.
+            const cannotBeSuspended = renderHasNotSuspendedYet() && (current === null || (current.flags & DidCapture) === NoFlags$1);
+
+            if (!cannotBeSuspended) {
+              let row = workInProgress.child;
+
+              while (row !== null) {
+                const suspended = findFirstSuspended(row);
+
+                if (suspended !== null) {
+                  didSuspendAlready = true;
+                  workInProgress.flags |= DidCapture;
+                  cutOffTailIfNeeded(renderState, false); // If this is a newly suspended tree, it might not get committed as
+                  // part of the second pass. In that case nothing will subscribe to
+                  // its thenables. Instead, we'll transfer its thenables to the
+                  // SuspenseList so that it can retry if they resolve.
+                  // There might be multiple of these in the list but since we're
+                  // going to wait for all of them anyway, it doesn't really matter
+                  // which ones gets to ping. In theory we could get clever and keep
+                  // track of how many dependencies remain but it gets tricky because
+                  // in the meantime, we can add/remove/change items and dependencies.
+                  // We might bail out of the loop before finding any but that
+                  // doesn't matter since that means that the other boundaries that
+                  // we did find already has their listeners attached.
+
+                  const retryQueue = suspended.updateQueue;
+                  workInProgress.updateQueue = retryQueue;
+                  scheduleRetryEffect(workInProgress, retryQueue); // Rerender the whole list, but this time, we'll force fallbacks
+                  // to stay in place.
+                  // Reset the effect flags before doing the second pass since that's now invalid.
+                  // Reset the child fibers to their original state.
+
+                  workInProgress.subtreeFlags = NoFlags$1;
+                  resetChildFibers(workInProgress, renderLanes); // Set up the Suspense List Context to force suspense and
+                  // immediately rerender the children.
+
+                  pushSuspenseListContext(workInProgress, setShallowSuspenseListContext(suspenseStackCursor.current, ForceSuspenseFallback)); // Don't bubble properties in this case.
+
+                  return workInProgress.child;
+                }
+
+                row = row.sibling;
+              }
+            }
+
+            if (renderState.tail !== null && now() > getRenderTargetTime()) {
+              // We have already passed our CPU deadline but we still have rows
+              // left in the tail. We'll just give up further attempts to render
+              // the main content and only render fallbacks.
+              workInProgress.flags |= DidCapture;
+              didSuspendAlready = true;
+              cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
+              // to get it started back up to attempt the next item. While in terms
+              // of priority this work has the same priority as this current render,
+              // it's not part of the same transition once the transition has
+              // committed. If it's sync, we still want to yield so that it can be
+              // painted. Conceptually, this is really the same as pinging.
+              // We can use any RetryLane even if it's the one currently rendering
+              // since we're leaving it behind on this node.
+
+              workInProgress.lanes = SomeRetryLane;
+            }
+          } else {
+            cutOffTailIfNeeded(renderState, false);
+          } // Next we're going to render the tail.
+
+        } else {
+          // Append the rendered row to the child list.
+          if (!didSuspendAlready) {
+            const suspended = findFirstSuspended(renderedTail);
+
+            if (suspended !== null) {
+              workInProgress.flags |= DidCapture;
+              didSuspendAlready = true; // Ensure we transfer the update queue to the parent so that it doesn't
+              // get lost if this row ends up dropped during a second pass.
+
+              const retryQueue = suspended.updateQueue;
+              workInProgress.updateQueue = retryQueue;
+              scheduleRetryEffect(workInProgress, retryQueue);
+              cutOffTailIfNeeded(renderState, true); // This might have been modified.
+
+              if (renderState.tail === null && renderState.tailMode === 'hidden' && !renderedTail.alternate && !getIsHydrating() // We don't cut it if we're hydrating.
+              ) {
+                  // We're done.
+                  bubbleProperties(workInProgress);
+                  return null;
+                }
+            } else if ( // The time it took to render last row is greater than the remaining
+            // time we have to render. So rendering one more row would likely
+            // exceed it.
+            now() * 2 - renderState.renderingStartTime > getRenderTargetTime() && renderLanes !== OffscreenLane) {
+              // We have now passed our CPU deadline and we'll just give up further
+              // attempts to render the main content and only render fallbacks.
+              // The assumption is that this is usually faster.
+              workInProgress.flags |= DidCapture;
+              didSuspendAlready = true;
+              cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
+              // to get it started back up to attempt the next item. While in terms
+              // of priority this work has the same priority as this current render,
+              // it's not part of the same transition once the transition has
+              // committed. If it's sync, we still want to yield so that it can be
+              // painted. Conceptually, this is really the same as pinging.
+              // We can use any RetryLane even if it's the one currently rendering
+              // since we're leaving it behind on this node.
+
+              workInProgress.lanes = SomeRetryLane;
+            }
+          }
+
+          if (renderState.isBackwards) {
+            // The effect list of the backwards tail will have been added
+            // to the end. This breaks the guarantee that life-cycles fire in
+            // sibling order but that isn't a strong guarantee promised by React.
+            // Especially since these might also just pop in during future commits.
+            // Append to the beginning of the list.
+            renderedTail.sibling = workInProgress.child;
+            workInProgress.child = renderedTail;
+          } else {
+            const previousSibling = renderState.last;
+
+            if (previousSibling !== null) {
+              previousSibling.sibling = renderedTail;
+            } else {
+              workInProgress.child = renderedTail;
+            }
+
+            renderState.last = renderedTail;
+          }
+        }
+
+        if (renderState.tail !== null) {
+          // We still have tail rows to render.
+          // Pop a row.
+          const next = renderState.tail;
+          renderState.rendering = next;
+          renderState.tail = next.sibling;
+          renderState.renderingStartTime = now();
+          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.
+
+          let suspenseContext = suspenseStackCursor.current;
+
+          if (didSuspendAlready) {
+            suspenseContext = setShallowSuspenseListContext(suspenseContext, ForceSuspenseFallback);
+          } else {
+            suspenseContext = setDefaultShallowSuspenseListContext(suspenseContext);
+          }
+
+          pushSuspenseListContext(workInProgress, suspenseContext); // Do a pass over the next row.
+          // Don't bubble properties in this case.
+
+          return next;
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
+
+    case ScopeComponent:
+      {
+
+        break;
+      }
+
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      {
+        popSuspenseHandler(workInProgress);
+        popHiddenContext();
+        const nextState = workInProgress.memoizedState;
+        const nextIsHidden = nextState !== null; // Schedule a Visibility effect if the visibility has changed
+
+        {
+          if (current !== null) {
+            const prevState = current.memoizedState;
+            const prevIsHidden = prevState !== null;
+
+            if (prevIsHidden !== nextIsHidden) {
+              workInProgress.flags |= Visibility;
+            }
+          } else {
+            // On initial mount, we only need a Visibility effect if the tree
+            // is hidden.
+            if (nextIsHidden) {
+              workInProgress.flags |= Visibility;
+            }
+          }
+        }
+
+        if (!nextIsHidden || (workInProgress.mode & ConcurrentMode) === NoMode) {
+          bubbleProperties(workInProgress);
+        } else {
+          // Don't bubble properties for hidden children unless we're rendering
+          // at offscreen priority.
+          if (includesSomeLane(renderLanes, OffscreenLane) && // Also don't bubble if the tree suspended
+          (workInProgress.flags & DidCapture) === NoLanes) {
+            bubbleProperties(workInProgress); // Check if there was an insertion or update in the hidden subtree.
+            // If so, we need to hide those nodes in the commit phase, so
+            // schedule a visibility effect.
+
+            if (workInProgress.subtreeFlags & (Placement | Update)) {
+              workInProgress.flags |= Visibility;
+            }
+          }
+        }
+
+        const offscreenQueue = workInProgress.updateQueue;
+
+        if (offscreenQueue !== null) {
+          const retryQueue = offscreenQueue.retryQueue;
+          scheduleRetryEffect(workInProgress, retryQueue);
+        }
+
+        {
+          let previousCache = null;
+
+          if (current !== null && current.memoizedState !== null && current.memoizedState.cachePool !== null) {
+            previousCache = current.memoizedState.cachePool.pool;
+          }
+
+          let cache = null;
+
+          if (workInProgress.memoizedState !== null && workInProgress.memoizedState.cachePool !== null) {
+            cache = workInProgress.memoizedState.cachePool.pool;
+          }
+
+          if (cache !== previousCache) {
+            // Run passive effects to retain/release the cache.
+            workInProgress.flags |= Passive$1;
+          }
+        }
+
+        popTransition(workInProgress, current);
+        return null;
+      }
+
+    case CacheComponent:
+      {
+        {
+          let previousCache = null;
+
+          if (current !== null) {
+            previousCache = current.memoizedState.cache;
+          }
+
+          const cache = workInProgress.memoizedState.cache;
+
+          if (cache !== previousCache) {
+            // Run passive effects to retain/release the cache.
+            workInProgress.flags |= Passive$1;
+          }
+
+          popCacheProvider();
+          bubbleProperties(workInProgress);
+        }
+
+        return null;
+      }
+
+    case TracingMarkerComponent:
+      {
+
+        return null;
+      }
+  }
+
+  throw Error(formatProdErrorMessage(156, workInProgress.tag));
+}
+
+function unwindWork(current, workInProgress, renderLanes) {
+  // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
+  popTreeContext(workInProgress);
+
+  switch (workInProgress.tag) {
+    case ClassComponent:
+      {
+        const Component = workInProgress.type;
+
+        if (isContextProvider(Component)) {
+          popContext();
+        }
+
+        const flags = workInProgress.flags;
+
+        if (flags & ShouldCapture) {
+          workInProgress.flags = flags & ~ShouldCapture | DidCapture;
+
+          return workInProgress;
+        }
+
+        return null;
+      }
+
+    case HostRoot:
+      {
+
+        {
+          popCacheProvider();
+        }
+        popHostContainer();
+        popTopLevelContextObject();
+        const flags = workInProgress.flags;
+
+        if ((flags & ShouldCapture) !== NoFlags$1 && (flags & DidCapture) === NoFlags$1) {
+          // There was an error during render that wasn't captured by a suspense
+          // boundary. Do a second pass on the root to unmount the children.
+          workInProgress.flags = flags & ~ShouldCapture | DidCapture;
+          return workInProgress;
+        } // We unwound to the root without completing it. Exit.
+
+
+        return null;
+      }
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      {
+        // TODO: popHydrationState
+        popHostContext(workInProgress);
+        return null;
+      }
+
+    case SuspenseComponent:
+      {
+        popSuspenseHandler(workInProgress);
+        const suspenseState = workInProgress.memoizedState;
+
+        if (suspenseState !== null && suspenseState.dehydrated !== null) {
+          if (workInProgress.alternate === null) {
+            throw Error(formatProdErrorMessage(340));
+          }
+
+          resetHydrationState();
+        }
+
+        const flags = workInProgress.flags;
+
+        if (flags & ShouldCapture) {
+          workInProgress.flags = flags & ~ShouldCapture | DidCapture; // Captured a suspense effect. Re-render the boundary.
+
+          return workInProgress;
+        }
+
+        return null;
+      }
+
+    case SuspenseListComponent:
+      {
+        popSuspenseListContext(); // SuspenseList doesn't actually catch anything. It should've been
+        // caught by a nested boundary. If not, it should bubble through.
+
+        return null;
+      }
+
+    case HostPortal:
+      popHostContainer();
+      return null;
+
+    case ContextProvider:
+      const context = workInProgress.type._context;
+      popProvider(context);
+      return null;
+
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      {
+        popSuspenseHandler(workInProgress);
+        popHiddenContext();
+        popTransition(workInProgress, current);
+        const flags = workInProgress.flags;
+
+        if (flags & ShouldCapture) {
+          workInProgress.flags = flags & ~ShouldCapture | DidCapture; // Captured a suspense effect. Re-render the boundary.
+
+          return workInProgress;
+        }
+
+        return null;
+      }
+
+    case CacheComponent:
+      {
+        popCacheProvider();
+      }
+
+      return null;
+
+    case TracingMarkerComponent:
+
+      return null;
+
+    default:
+      return null;
+  }
+}
+
+function unwindInterruptedWork(current, interruptedWork, renderLanes) {
+  // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
+  popTreeContext(interruptedWork);
+
+  switch (interruptedWork.tag) {
+    case ClassComponent:
+      {
+        const childContextTypes = interruptedWork.type.childContextTypes;
+
+        if (childContextTypes !== null && childContextTypes !== undefined) {
+          popContext();
+        }
+
+        break;
+      }
+
+    case HostRoot:
+      {
+
+        {
+          popCacheProvider();
+        }
+        popHostContainer();
+        popTopLevelContextObject();
+        break;
+      }
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      {
+        popHostContext(interruptedWork);
+        break;
+      }
+
+    case HostPortal:
+      popHostContainer();
+      break;
+
+    case SuspenseComponent:
+      popSuspenseHandler(interruptedWork);
+      break;
+
+    case SuspenseListComponent:
+      popSuspenseListContext();
+      break;
+
+    case ContextProvider:
+      const context = interruptedWork.type._context;
+      popProvider(context);
+      break;
+
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      popSuspenseHandler(interruptedWork);
+      popHiddenContext();
+      popTransition(interruptedWork, current);
+      break;
+
+    case CacheComponent:
+      {
+        popCacheProvider();
+      }
+
+      break;
+  }
+}
+
+function invokeGuardedCallbackImpl(name, func, context) {
+  {
+    // $FlowFixMe[method-unbinding]
+    const funcArgs = Array.prototype.slice.call(arguments, 3);
+
+    try {
+      // $FlowFixMe[incompatible-call] Flow doesn't understand the arguments splicing.
+      func.apply(context, funcArgs);
+    } catch (error) {
+      this.onError(error);
+    }
+  }
+}
+
+let hasError = false;
+let caughtError = null; // Used by event system to capture/rethrow the first error.
+
+let hasRethrowError = false;
+let rethrowError = null;
+const reporter = {
+  onError(error) {
+    hasError = true;
+    caughtError = error;
+  }
+
+};
+/**
+ * Call a function while guarding against errors that happens within it.
+ * Returns an error if it throws, otherwise null.
+ *
+ * In production, this is implemented using a try-catch. The reason we don't
+ * use a try-catch directly is so that we can swap out a different
+ * implementation in DEV mode.
+ *
+ * @param {String} name of the guard to use for logging or debugging
+ * @param {Function} func The function to invoke
+ * @param {*} context The context to use when calling the function
+ * @param {...*} args Arguments for function
+ */
+
+function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+  hasError = false;
+  caughtError = null;
+  invokeGuardedCallbackImpl.apply(reporter, arguments);
+}
+/**
+ * Same as invokeGuardedCallback, but instead of returning an error, it stores
+ * it in a global so it can be rethrown by `rethrowCaughtError` later.
+ * TODO: See if caughtError and rethrowError can be unified.
+ *
+ * @param {String} name of the guard to use for logging or debugging
+ * @param {Function} func The function to invoke
+ * @param {*} context The context to use when calling the function
+ * @param {...*} args Arguments for function
+ */
+
+function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
+  invokeGuardedCallback.apply(this, arguments);
+
+  if (hasError) {
+    const error = clearCaughtError();
+
+    if (!hasRethrowError) {
+      hasRethrowError = true;
+      rethrowError = error;
+    }
+  }
+}
+/**
+ * During execution of guarded functions we will capture the first error which
+ * we will rethrow to be handled by the top level error handler.
+ */
+
+function rethrowCaughtError() {
+  if (hasRethrowError) {
+    const error = rethrowError;
+    hasRethrowError = false;
+    rethrowError = null;
+    throw error;
+  }
+}
+function clearCaughtError() {
+  if (hasError) {
+    const error = caughtError;
+    hasError = false;
+    caughtError = null;
+    return error;
+  } else {
+    throw Error(formatProdErrorMessage(198));
+  }
+}
+
+// Allows us to avoid traversing the return path to find the nearest Offscreen ancestor.
+
+
+let offscreenSubtreeIsHidden = false;
+let offscreenSubtreeWasHidden = false;
+const PossiblyWeakSet = typeof WeakSet === 'function' ? WeakSet : Set;
+let nextEffect = null; // Used for Profiling builds to track updaters.
+
+function shouldProfile(current) {
+  return enableProfilerTimer   ;
+}
+
+function callComponentWillUnmountWithTimer(current, instance) {
+  instance.props = current.memoizedProps;
+  instance.state = current.memoizedState;
+
+  {
+    instance.componentWillUnmount();
+  }
+} // Capture errors so they don't interrupt unmounting.
+
+
+function safelyCallComponentWillUnmount(current, nearestMountedAncestor, instance) {
+  try {
+    callComponentWillUnmountWithTimer(current, instance);
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+} // Capture errors so they don't interrupt mounting.
+
+
+function safelyAttachRef(current, nearestMountedAncestor) {
+  try {
+    commitAttachRef(current);
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+}
+
+function safelyDetachRef(current, nearestMountedAncestor) {
+  const ref = current.ref;
+  const refCleanup = current.refCleanup;
+
+  if (ref !== null) {
+    if (typeof refCleanup === 'function') {
+      try {
+        if (shouldProfile(current)) ; else {
+          refCleanup();
+        }
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
+      } finally {
+        // `refCleanup` has been called. Nullify all references to it to prevent double invocation.
+        current.refCleanup = null;
+        const finishedWork = current.alternate;
+
+        if (finishedWork != null) {
+          finishedWork.refCleanup = null;
+        }
+      }
+    } else if (typeof ref === 'function') {
+      let retVal;
+
+      try {
+        if (shouldProfile(current)) ; else {
+          retVal = ref(null);
+        }
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
+      }
+    } else {
+      // $FlowFixMe[incompatible-use] unable to narrow type to RefObject
+      ref.current = null;
+    }
+  }
+}
+
+function safelyCallDestroy(current, nearestMountedAncestor, destroy) {
+  try {
+    destroy();
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+}
+let shouldFireAfterActiveInstanceBlur = false;
+function commitBeforeMutationEffects(root, firstChild) {
+  prepareForCommit();
+  nextEffect = firstChild;
+  commitBeforeMutationEffects_begin(); // We no longer need to track the active instance fiber
+
+  const shouldFire = shouldFireAfterActiveInstanceBlur;
+  shouldFireAfterActiveInstanceBlur = false;
+  return shouldFire;
+}
+
+function commitBeforeMutationEffects_begin() {
+  while (nextEffect !== null) {
+    const fiber = nextEffect; // This phase is only used for beforeActiveInstanceBlur.
+
+    const child = fiber.child;
+
+    if ((fiber.subtreeFlags & BeforeMutationMask) !== NoFlags$1 && child !== null) {
+      child.return = fiber;
+      nextEffect = child;
+    } else {
+      commitBeforeMutationEffects_complete();
+    }
+  }
+}
+
+function commitBeforeMutationEffects_complete() {
+  while (nextEffect !== null) {
+    const fiber = nextEffect;
+
+    try {
+      commitBeforeMutationEffectsOnFiber(fiber);
+    } catch (error) {
+      captureCommitPhaseError(fiber, fiber.return, error);
+    }
+    const sibling = fiber.sibling;
+
+    if (sibling !== null) {
+      sibling.return = fiber.return;
+      nextEffect = sibling;
+      return;
+    }
+
+    nextEffect = fiber.return;
+  }
+}
+
+function commitBeforeMutationEffectsOnFiber(finishedWork) {
+  const current = finishedWork.alternate;
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+      {
+
+        break;
+      }
+
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        break;
+      }
+
+    case ClassComponent:
+      {
+        if ((flags & Snapshot) !== NoFlags$1) {
+          if (current !== null) {
+            const prevProps = current.memoizedProps;
+            const prevState = current.memoizedState;
+            const instance = finishedWork.stateNode; // We could update instance props and state here,
+
+            const snapshot = instance.getSnapshotBeforeUpdate(finishedWork.elementType === finishedWork.type ? prevProps : resolveDefaultProps(finishedWork.type, prevProps), prevState);
+
+            instance.__reactInternalSnapshotBeforeUpdate = snapshot;
+          }
+        }
+
+        break;
+      }
+
+    case HostRoot:
+      {
+        if ((flags & Snapshot) !== NoFlags$1) {
+          {
+            const root = finishedWork.stateNode;
+            clearContainer(root.containerInfo);
+          }
+        }
+
+        break;
+      }
+
+    case HostComponent:
+    case HostHoistable:
+    case HostSingleton:
+    case HostText:
+    case HostPortal:
+    case IncompleteClassComponent:
+      // Nothing to do for these component types
+      break;
+
+    default:
+      {
+        if ((flags & Snapshot) !== NoFlags$1) {
+          throw Error(formatProdErrorMessage(163));
+        }
+      }
+  }
+}
+
+function commitHookEffectListUnmount(flags, finishedWork, nearestMountedAncestor) {
+  const updateQueue = finishedWork.updateQueue;
+  const lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
+
+  if (lastEffect !== null) {
+    const firstEffect = lastEffect.next;
+    let effect = firstEffect;
+
+    do {
+      if ((effect.tag & flags) === flags) {
+        // Unmount
+        const inst = effect.inst;
+        const destroy = inst.destroy;
+
+        if (destroy !== undefined) {
+          inst.destroy = undefined;
+
+          safelyCallDestroy(finishedWork, nearestMountedAncestor, destroy);
+        }
+      }
+
+      effect = effect.next;
+    } while (effect !== firstEffect);
+  }
+}
+
+function commitHookEffectListMount(flags, finishedWork) {
+  const updateQueue = finishedWork.updateQueue;
+  const lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
+
+  if (lastEffect !== null) {
+    const firstEffect = lastEffect.next;
+    let effect = firstEffect;
+
+    do {
+      if ((effect.tag & flags) === flags) {
+
+
+        const create = effect.create;
+
+        const inst = effect.inst;
+        const destroy = create();
+        inst.destroy = destroy;
+      }
+
+      effect = effect.next;
+    } while (effect !== firstEffect);
+  }
+}
+
+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.
+  {
+    try {
+      commitHookEffectListMount(hookFlags, finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
+
+function commitClassLayoutLifecycles(finishedWork, current) {
+  const instance = finishedWork.stateNode;
+
+  if (current === null) {
+
+    {
+      try {
+        instance.componentDidMount();
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+  } else {
+    const prevProps = finishedWork.elementType === finishedWork.type ? current.memoizedProps : resolveDefaultProps(finishedWork.type, current.memoizedProps);
+    const prevState = current.memoizedState; // We could update instance props and state here,
+
+    {
+      try {
+        instance.componentDidUpdate(prevProps, prevState, instance.__reactInternalSnapshotBeforeUpdate);
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+  }
+}
+
+function commitClassCallbacks(finishedWork) {
+  // TODO: I think this is now always non-null by the time it reaches the
+  // commit phase. Consider removing the type check.
+  const updateQueue = finishedWork.updateQueue;
+
+  if (updateQueue !== null) {
+    const instance = finishedWork.stateNode;
+    // but instead we rely on them being set during last render.
+    // TODO: revisit this when we implement resuming.
+
+
+    try {
+      commitCallbacks(updateQueue, instance);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
+
+function commitHostComponentMount(finishedWork) {
+  const type = finishedWork.type;
+  const props = finishedWork.memoizedProps;
+  const instance = finishedWork.stateNode;
+
+  try {
+    commitMount(instance, type, props, finishedWork);
+  } catch (error) {
+    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+  }
+}
+
+function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork, committedLanes) {
+  // When updating this function, also update reappearLayoutEffects, which does
+  // most of the same things when an offscreen tree goes from hidden -> visible.
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+        if (flags & Update) {
+          commitHookLayoutEffects(finishedWork, Layout | HasEffect);
+        }
+
+        break;
+      }
+
+    case ClassComponent:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+        if (flags & Update) {
+          commitClassLayoutLifecycles(finishedWork, current);
+        }
+
+        if (flags & Callback) {
+          commitClassCallbacks(finishedWork);
+        }
+
+        if (flags & Ref) {
+          safelyAttachRef(finishedWork, finishedWork.return);
+        }
+
+        break;
+      }
+
+    case HostRoot:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+        if (flags & Callback) {
+          // TODO: I think this is now always non-null by the time it reaches the
+          // commit phase. Consider removing the type check.
+          const updateQueue = finishedWork.updateQueue;
+
+          if (updateQueue !== null) {
+            let instance = null;
+
+            if (finishedWork.child !== null) {
+              switch (finishedWork.child.tag) {
+                case HostSingleton:
+                case HostComponent:
+                  instance = getPublicInstance(finishedWork.child.stateNode);
+                  break;
+
+                case ClassComponent:
+                  instance = finishedWork.child.stateNode;
+                  break;
+              }
+            }
+
+            try {
+              commitCallbacks(updateQueue, instance);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+        }
+
+        break;
+      }
+
+    case HostHoistable:
+      {
+        {
+          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+          if (flags & Ref) {
+            safelyAttachRef(finishedWork, finishedWork.return);
+          }
+
+          break;
+        } // Fall through
+
+      }
+
+    case HostSingleton:
+    case HostComponent:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork); // Renderers may schedule work to be done after host components are mounted
+        // (eg DOM renderer may schedule auto-focus for inputs and form controls).
+        // These effects should only be committed when components are first mounted,
+        // aka when there is no current/alternate.
+
+        if (current === null && flags & Update) {
+          commitHostComponentMount(finishedWork);
+        }
+
+        if (flags & Ref) {
+          safelyAttachRef(finishedWork, finishedWork.return);
+        }
+
+        break;
+      }
+
+    case Profiler:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork); // TODO: Should this fire inside an offscreen tree? Or should it wait to
+
+        break;
+      }
+
+    case SuspenseComponent:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+        if (flags & Update) {
+          commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
+        }
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const isModernRoot = (finishedWork.mode & ConcurrentMode) !== NoMode;
+
+        if (isModernRoot) {
+          const isHidden = finishedWork.memoizedState !== null;
+          const newOffscreenSubtreeIsHidden = isHidden || offscreenSubtreeIsHidden;
+
+          if (newOffscreenSubtreeIsHidden) ; else {
+            // The Offscreen tree is visible.
+            const wasHidden = current !== null && current.memoizedState !== null;
+            const newOffscreenSubtreeWasHidden = wasHidden || offscreenSubtreeWasHidden;
+            const prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
+            const prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+            offscreenSubtreeIsHidden = newOffscreenSubtreeIsHidden;
+            offscreenSubtreeWasHidden = newOffscreenSubtreeWasHidden;
+
+            if (offscreenSubtreeWasHidden && !prevOffscreenSubtreeWasHidden) {
+              // This is the root of a reappearing boundary. As we continue
+              // traversing the layout effects, we must also re-mount layout
+              // effects that were unmounted when the Offscreen subtree was
+              // hidden. So this is a superset of the normal commitLayoutEffects.
+              const includeWorkInProgressEffects = (finishedWork.subtreeFlags & LayoutMask) !== NoFlags$1;
+              recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+            } else {
+              recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+            }
+
+            offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+            offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+          }
+        } else {
+          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        }
+
+        if (flags & Ref) {
+          const props = finishedWork.memoizedProps;
+
+          if (props.mode === 'manual') {
+            safelyAttachRef(finishedWork, finishedWork.return);
+          } else {
+            safelyDetachRef(finishedWork, finishedWork.return);
+          }
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        break;
+      }
+  }
+}
+
+function hideOrUnhideAllChildren(finishedWork, isHidden) {
+  // Only hide or unhide the top-most host nodes.
+  let hostSubtreeRoot = null;
+
+  {
+    // We only have the top Fiber that was inserted but we need to recurse down its
+    // children to find all the terminal nodes.
+    let node = finishedWork;
+
+    while (true) {
+      if (node.tag === HostComponent || (node.tag === HostHoistable ) || (node.tag === HostSingleton )) {
+        if (hostSubtreeRoot === null) {
+          hostSubtreeRoot = node;
+
+          try {
+            const instance = node.stateNode;
+
+            if (isHidden) {
+              hideInstance(instance);
+            } else {
+              unhideInstance(node.stateNode, node.memoizedProps);
+            }
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      } else if (node.tag === HostText) {
+        if (hostSubtreeRoot === null) {
+          try {
+            const instance = node.stateNode;
+
+            if (isHidden) {
+              hideTextInstance(instance);
+            } else {
+              unhideTextInstance(instance, node.memoizedProps);
+            }
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      } else if ((node.tag === OffscreenComponent || node.tag === LegacyHiddenComponent) && node.memoizedState !== null && node !== finishedWork) ; else if (node.child !== null) {
+        node.child.return = node;
+        node = node.child;
+        continue;
+      }
+
+      if (node === finishedWork) {
+        return;
+      }
+
+      while (node.sibling === null) {
+        if (node.return === null || node.return === finishedWork) {
+          return;
+        }
+
+        if (hostSubtreeRoot === node) {
+          hostSubtreeRoot = null;
+        }
+
+        node = node.return;
+      }
+
+      if (hostSubtreeRoot === node) {
+        hostSubtreeRoot = null;
+      }
+
+      node.sibling.return = node.return;
+      node = node.sibling;
+    }
+  }
+}
+
+function commitAttachRef(finishedWork) {
+  const ref = finishedWork.ref;
+
+  if (ref !== null) {
+    const instance = finishedWork.stateNode;
+    let instanceToUse;
+
+    switch (finishedWork.tag) {
+      case HostHoistable:
+      case HostSingleton:
+      case HostComponent:
+        instanceToUse = getPublicInstance(instance);
+        break;
+
+      default:
+        instanceToUse = instance;
+    } // Moved outside to ensure DCE works with this flag
+
+    if (typeof ref === 'function') {
+      {
+        finishedWork.refCleanup = ref(instanceToUse);
+      }
+    } else {
+
+
+      ref.current = instanceToUse;
+    }
+  }
+}
+
+function detachFiberMutation(fiber) {
+  // Cut off the return pointer to disconnect it from the tree.
+  // This enables us to detect and warn against state updates on an unmounted component.
+  // It also prevents events from bubbling from within disconnected components.
+  //
+  // Ideally, we should also clear the child pointer of the parent alternate to let this
+  // get GC:ed but we don't know which for sure which parent is the current
+  // one so we'll settle for GC:ing the subtree of this child.
+  // This child itself will be GC:ed when the parent updates the next time.
+  //
+  // Note that we can't clear child or sibling pointers yet.
+  // They're needed for passive effects and for findDOMNode.
+  // We defer those fields, and all other cleanup, to the passive phase (see detachFiberAfterEffects).
+  //
+  // Don't reset the alternate yet, either. We need that so we can detach the
+  // alternate's fields in the passive phase. Clearing the return pointer is
+  // sufficient for findDOMNode semantics.
+  const alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    alternate.return = null;
+  }
+
+  fiber.return = null;
+}
+
+function detachFiberAfterEffects(fiber) {
+  const alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    fiber.alternate = null;
+    detachFiberAfterEffects(alternate);
+  } // Clear cyclical Fiber fields. This level alone is designed to roughly
+  // approximate the planned Fiber refactor. In that world, `setState` will be
+  // bound to a special "instance" object instead of a Fiber. The Instance
+  // object will not have any of these fields. It will only be connected to
+  // the fiber tree via a single link at the root. So if this level alone is
+  // sufficient to fix memory issues, that bodes well for our plans.
+
+
+  fiber.child = null;
+  fiber.deletions = null;
+  fiber.sibling = null; // The `stateNode` is cyclical because on host nodes it points to the host
+  // tree, which has its own pointers to children, parents, and siblings.
+  // The other host nodes also point back to fibers, so we should detach that
+  // one, too.
+
+  if (fiber.tag === HostComponent) {
+    const hostInstance = fiber.stateNode;
+
+    if (hostInstance !== null) {
+      detachDeletedInstance(hostInstance);
+    }
+  }
+
+  fiber.stateNode = null;
+  // disconnected the fiber from the tree. So even if something leaks this
+  // particular fiber, it won't leak anything else.
+
+
+  fiber.return = null;
+  fiber.dependencies = null;
+  fiber.memoizedProps = null;
+  fiber.memoizedState = null;
+  fiber.pendingProps = null;
+  fiber.stateNode = null; // TODO: Move to `commitPassiveUnmountInsideDeletedTreeOnFiber` instead.
+
+  fiber.updateQueue = null;
+}
+
+function getHostParentFiber(fiber) {
+  let parent = fiber.return;
+
+  while (parent !== null) {
+    if (isHostParent(parent)) {
+      return parent;
+    }
+
+    parent = parent.return;
+  }
+
+  throw Error(formatProdErrorMessage(160));
+}
+
+function isHostParent(fiber) {
+  return fiber.tag === HostComponent || fiber.tag === HostRoot || (fiber.tag === HostHoistable ) || (fiber.tag === HostSingleton ) || fiber.tag === HostPortal;
+}
+
+function getHostSibling(fiber) {
+  // We're going to search forward into the tree until we find a sibling host
+  // node. Unfortunately, if multiple insertions are done in a row we have to
+  // search past them. This leads to exponential search for the next sibling.
+  // TODO: Find a more efficient way to do this.
+  let node = fiber;
+
+  siblings: while (true) {
+    // If we didn't find anything, let's try the next sibling.
+    while (node.sibling === null) {
+      if (node.return === null || isHostParent(node.return)) {
+        // If we pop out of the root or hit the parent the fiber we are the
+        // last sibling.
+        return null;
+      } // $FlowFixMe[incompatible-type] found when upgrading Flow
+
+
+      node = node.return;
+    }
+
+    node.sibling.return = node.return;
+    node = node.sibling;
+
+    while (node.tag !== HostComponent && node.tag !== HostText && (node.tag !== HostSingleton) && node.tag !== DehydratedFragment) {
+      // If it is not host node and, we might have a host node inside it.
+      // Try to search down until we find one.
+      if (node.flags & Placement) {
+        // If we don't have a child, try the siblings instead.
+        continue siblings;
+      } // If we don't have a child, try the siblings instead.
+      // We also skip portals because they are not part of this host tree.
+
+
+      if (node.child === null || node.tag === HostPortal) {
+        continue siblings;
+      } else {
+        node.child.return = node;
+        node = node.child;
+      }
+    } // Check if this host node is stable or about to be placed.
+
+
+    if (!(node.flags & Placement)) {
+      // Found it!
+      return node.stateNode;
+    }
+  }
+}
+
+function commitPlacement(finishedWork) {
+
+  {
+    if (finishedWork.tag === HostSingleton) {
+      // Singletons are already in the Host and don't need to be placed
+      // Since they operate somewhat like Portals though their children will
+      // have Placement and will get placed inside them
+      return;
+    }
+  } // Recursively insert all host nodes into the parent.
+
+
+  const parentFiber = getHostParentFiber(finishedWork);
+
+  switch (parentFiber.tag) {
+    case HostSingleton:
+      {
+        {
+          const parent = parentFiber.stateNode;
+          const before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
+          // children to find all the terminal nodes.
+
+          insertOrAppendPlacementNode(finishedWork, before, parent);
+          break;
+        } // Fall through
+
+      }
+
+    case HostComponent:
+      {
+        const parent = parentFiber.stateNode;
+
+        if (parentFiber.flags & ContentReset) {
+          // Reset the text content of the parent before doing any insertions
+          resetTextContent(parent); // Clear ContentReset from the effect tag
+
+          parentFiber.flags &= ~ContentReset;
+        }
+
+        const before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
+        // children to find all the terminal nodes.
+
+        insertOrAppendPlacementNode(finishedWork, before, parent);
+        break;
+      }
+
+    case HostRoot:
+    case HostPortal:
+      {
+        const parent = parentFiber.stateNode.containerInfo;
+        const before = getHostSibling(finishedWork);
+        insertOrAppendPlacementNodeIntoContainer(finishedWork, before, parent);
+        break;
+      }
+
+    default:
+      throw Error(formatProdErrorMessage(161));
+  }
+}
+
+function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
+  const tag = node.tag;
+  const isHost = tag === HostComponent || tag === HostText;
+
+  if (isHost) {
+    const stateNode = node.stateNode;
+
+    if (before) {
+      insertInContainerBefore(parent, stateNode, before);
+    } else {
+      appendChildToContainer(parent, stateNode);
+    }
+  } else if (tag === HostPortal || (tag === HostSingleton )) ; else {
+    const child = node.child;
+
+    if (child !== null) {
+      insertOrAppendPlacementNodeIntoContainer(child, before, parent);
+      let sibling = child.sibling;
+
+      while (sibling !== null) {
+        insertOrAppendPlacementNodeIntoContainer(sibling, before, parent);
+        sibling = sibling.sibling;
+      }
+    }
+  }
+}
+
+function insertOrAppendPlacementNode(node, before, parent) {
+  const tag = node.tag;
+  const isHost = tag === HostComponent || tag === HostText;
+
+  if (isHost) {
+    const stateNode = node.stateNode;
+
+    if (before) {
+      insertBefore(parent, stateNode, before);
+    } else {
+      appendChild(parent, stateNode);
+    }
+  } else if (tag === HostPortal || (tag === HostSingleton )) ; else {
+    const child = node.child;
+
+    if (child !== null) {
+      insertOrAppendPlacementNode(child, before, parent);
+      let sibling = child.sibling;
+
+      while (sibling !== null) {
+        insertOrAppendPlacementNode(sibling, before, parent);
+        sibling = sibling.sibling;
+      }
+    }
+  }
+} // These are tracked on the stack as we recursively traverse a
+// deleted subtree.
+// TODO: Update these during the whole mutation phase, not just during
+// a deletion.
+
+
+let hostParent = null;
+let hostParentIsContainer = false;
+
+function commitDeletionEffects(root, returnFiber, deletedFiber) {
+  {
+    // We only have the top Fiber that was deleted but we need to recurse down its
+    // children to find all the terminal nodes.
+    // Recursively delete all host nodes from the parent, detach refs, clean
+    // up mounted layout effects, and call componentWillUnmount.
+    // We only need to remove the topmost host child in each branch. But then we
+    // still need to keep traversing to unmount effects, refs, and cWU. TODO: We
+    // could split this into two separate traversals functions, where the second
+    // one doesn't include any removeChild logic. This is maybe the same
+    // function as "disappearLayoutEffects" (or whatever that turns into after
+    // the layout phase is refactored to use recursion).
+    // Before starting, find the nearest host parent on the stack so we know
+    // which instance/container to remove the children from.
+    // TODO: Instead of searching up the fiber return path on every deletion, we
+    // can track the nearest host component on the JS stack as we traverse the
+    // tree during the commit phase. This would make insertions faster, too.
+    let parent = returnFiber;
+
+    findParent: while (parent !== null) {
+      switch (parent.tag) {
+        case HostSingleton:
+        case HostComponent:
+          {
+            hostParent = parent.stateNode;
+            hostParentIsContainer = false;
+            break findParent;
+          }
+
+        case HostRoot:
+          {
+            hostParent = parent.stateNode.containerInfo;
+            hostParentIsContainer = true;
+            break findParent;
+          }
+
+        case HostPortal:
+          {
+            hostParent = parent.stateNode.containerInfo;
+            hostParentIsContainer = true;
+            break findParent;
+          }
+      }
+
+      parent = parent.return;
+    }
+
+    if (hostParent === null) {
+      throw Error(formatProdErrorMessage(160));
+    }
+
+    commitDeletionEffectsOnFiber(root, returnFiber, deletedFiber);
+    hostParent = null;
+    hostParentIsContainer = false;
+  }
+
+  detachFiberMutation(deletedFiber);
+}
+
+function recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, parent) {
+  // TODO: Use a static flag to skip trees that don't have unmount effects
+  let child = parent.child;
+
+  while (child !== null) {
+    commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, child);
+    child = child.sibling;
+  }
+}
+
+function commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, deletedFiber) {
+  onCommitUnmount(deletedFiber); // The cases in this outer switch modify the stack before they traverse
+  // into their subtree. There are simpler cases in the inner switch
+  // that don't modify the stack.
+
+  switch (deletedFiber.tag) {
+    case HostHoistable:
+      {
+        {
+          if (!offscreenSubtreeWasHidden) {
+            safelyDetachRef(deletedFiber, nearestMountedAncestor);
+          }
+
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+
+          if (deletedFiber.memoizedState) {
+            releaseResource(deletedFiber.memoizedState);
+          } else if (deletedFiber.stateNode) {
+            unmountHoistable(deletedFiber.stateNode);
+          }
+
+          return;
+        } // Fall through
+
+      }
+
+    case HostSingleton:
+      {
+        {
+          if (!offscreenSubtreeWasHidden) {
+            safelyDetachRef(deletedFiber, nearestMountedAncestor);
+          }
+
+          const prevHostParent = hostParent;
+          const prevHostParentIsContainer = hostParentIsContainer;
+          hostParent = deletedFiber.stateNode;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber); // Normally this is called in passive unmount effect phase however with
+          // HostSingleton we warn if you acquire one that is already associated to
+          // a different fiber. To increase our chances of avoiding this, specifically
+          // if you keyed a HostSingleton so there will be a delete followed by a Placement
+          // we treat detach eagerly here
+
+          releaseSingletonInstance(deletedFiber.stateNode);
+          hostParent = prevHostParent;
+          hostParentIsContainer = prevHostParentIsContainer;
+          return;
+        } // Fall through
+
+      }
+
+    case HostComponent:
+      {
+        if (!offscreenSubtreeWasHidden) {
+          safelyDetachRef(deletedFiber, nearestMountedAncestor);
+        } // Intentional fallthrough to next branch
+
+      }
+
+    case HostText:
+      {
+        // We only need to remove the nearest host child. Set the host parent
+        // to `null` on the stack to indicate that nested children don't
+        // need to be removed.
+        {
+          const prevHostParent = hostParent;
+          const prevHostParentIsContainer = hostParentIsContainer;
+          hostParent = null;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          hostParent = prevHostParent;
+          hostParentIsContainer = prevHostParentIsContainer;
+
+          if (hostParent !== null) {
+            // Now that all the child effects have unmounted, we can remove the
+            // node from the tree.
+            if (hostParentIsContainer) {
+              removeChildFromContainer(hostParent, deletedFiber.stateNode);
+            } else {
+              removeChild(hostParent, deletedFiber.stateNode);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case DehydratedFragment:
+      {
+        // Delete the dehydrated suspense boundary and all of its content.
+
+
+        {
+          if (hostParent !== null) {
+            if (hostParentIsContainer) {
+              clearSuspenseBoundaryFromContainer(hostParent, deletedFiber.stateNode);
+            } else {
+              clearSuspenseBoundary(hostParent, deletedFiber.stateNode);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case HostPortal:
+      {
+        {
+          // When we go into a portal, it becomes the parent to remove from.
+          const prevHostParent = hostParent;
+          const prevHostParentIsContainer = hostParentIsContainer;
+          hostParent = deletedFiber.stateNode.containerInfo;
+          hostParentIsContainer = true;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          hostParent = prevHostParent;
+          hostParentIsContainer = prevHostParentIsContainer;
+        }
+
+        return;
+      }
+
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent:
+      {
+        if (!offscreenSubtreeWasHidden) {
+          const updateQueue = deletedFiber.updateQueue;
+
+          if (updateQueue !== null) {
+            const lastEffect = updateQueue.lastEffect;
+
+            if (lastEffect !== null) {
+              const firstEffect = lastEffect.next;
+              let effect = firstEffect;
+
+              do {
+                const tag = effect.tag;
+                const inst = effect.inst;
+                const destroy = inst.destroy;
+
+                if (destroy !== undefined) {
+                  if ((tag & Insertion) !== NoFlags) {
+                    inst.destroy = undefined;
+                    safelyCallDestroy(deletedFiber, nearestMountedAncestor, destroy);
+                  } else if ((tag & Layout) !== NoFlags) {
+
+                    {
+                      inst.destroy = undefined;
+                      safelyCallDestroy(deletedFiber, nearestMountedAncestor, destroy);
+                    }
+                  }
+                }
+
+                effect = effect.next;
+              } while (effect !== firstEffect);
+            }
+          }
+        }
+
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        return;
+      }
+
+    case ClassComponent:
+      {
+        if (!offscreenSubtreeWasHidden) {
+          safelyDetachRef(deletedFiber, nearestMountedAncestor);
+          const instance = deletedFiber.stateNode;
+
+          if (typeof instance.componentWillUnmount === 'function') {
+            safelyCallComponentWillUnmount(deletedFiber, nearestMountedAncestor, instance);
+          }
+        }
+
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        return;
+      }
+
+    case ScopeComponent:
+      {
+
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        return;
+      }
+
+    case OffscreenComponent:
+      {
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+
+        if (deletedFiber.mode & ConcurrentMode) {
+          // If this offscreen component is hidden, we already unmounted it. Before
+          // deleting the children, track that it's already unmounted so that we
+          // don't attempt to unmount the effects again.
+          // TODO: If the tree is hidden, in most cases we should be able to skip
+          // over the nested children entirely. An exception is we haven't yet found
+          // the topmost host node to delete, which we already track on the stack.
+          // But the other case is portals, which need to be detached no matter how
+          // deeply they are nested. We should use a subtree flag to track whether a
+          // subtree includes a nested portal.
+          const prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || deletedFiber.memoizedState !== null;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+        } else {
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        return;
+      }
+  }
+}
+
+function commitSuspenseCallback(finishedWork) {
+}
+
+function commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {
+
+  const newState = finishedWork.memoizedState;
+
+  if (newState === null) {
+    const current = finishedWork.alternate;
+
+    if (current !== null) {
+      const prevState = current.memoizedState;
+
+      if (prevState !== null) {
+        const suspenseInstance = prevState.dehydrated;
+
+        if (suspenseInstance !== null) {
+          try {
+            commitHydratedSuspenseInstance(suspenseInstance);
+
+            if (enableSuspenseCallback) ;
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      }
+    }
+  }
+}
+
+function getRetryCache(finishedWork) {
+  // TODO: Unify the interface for the retry cache so we don't have to switch
+  // on the tag like this.
+  switch (finishedWork.tag) {
+    case SuspenseComponent:
+    case SuspenseListComponent:
+      {
+        let retryCache = finishedWork.stateNode;
+
+        if (retryCache === null) {
+          retryCache = finishedWork.stateNode = new PossiblyWeakSet();
+        }
+
+        return retryCache;
+      }
+
+    case OffscreenComponent:
+      {
+        const instance = finishedWork.stateNode;
+        let retryCache = instance._retryCache;
+
+        if (retryCache === null) {
+          retryCache = instance._retryCache = new PossiblyWeakSet();
+        }
+
+        return retryCache;
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(435, finishedWork.tag));
+      }
+  }
+}
+
+function detachOffscreenInstance(instance) {
+  const fiber = instance._current;
+
+  if (fiber === null) {
+    throw Error(formatProdErrorMessage(456));
+  }
+
+  if ((instance._pendingVisibility & OffscreenDetached) !== NoFlags$1) {
+    // The instance is already detached, this is a noop.
+    return;
+  } // TODO: There is an opportunity to optimise this by not entering commit phase
+  // and unmounting effects directly.
+
+
+  const root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+  if (root !== null) {
+    instance._pendingVisibility |= OffscreenDetached;
+    scheduleUpdateOnFiber(root, fiber, SyncLane);
+  }
+}
+function attachOffscreenInstance(instance) {
+  const fiber = instance._current;
+
+  if (fiber === null) {
+    throw Error(formatProdErrorMessage(456));
+  }
+
+  if ((instance._pendingVisibility & OffscreenDetached) === NoFlags$1) {
+    // The instance is already attached, this is a noop.
+    return;
+  }
+
+  const root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+  if (root !== null) {
+    instance._pendingVisibility &= ~OffscreenDetached;
+    scheduleUpdateOnFiber(root, fiber, SyncLane);
+  }
+}
+
+function attachSuspenseRetryListeners(finishedWork, wakeables) {
+  // If this boundary just timed out, then it will have a set of wakeables.
+  // For each wakeable, attach a listener so that when it resolves, React
+  // attempts to re-render the boundary in the primary (pre-timeout) state.
+  const retryCache = getRetryCache(finishedWork);
+  wakeables.forEach(wakeable => {
+    // Memoize using the boundary fiber to prevent redundant listeners.
+    const retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
+
+    if (!retryCache.has(wakeable)) {
+      retryCache.add(wakeable);
+
+      wakeable.then(retry, retry);
+    }
+  });
+} // This function detects when a Suspense boundary goes from visible to hidden.
+function commitMutationEffects(root, finishedWork, committedLanes) {
+  commitMutationEffectsOnFiber(finishedWork, root);
+}
+
+function recursivelyTraverseMutationEffects(root, parentFiber, lanes) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects hae fired.
+  const deletions = parentFiber.deletions;
+
+  if (deletions !== null) {
+    for (let i = 0; i < deletions.length; i++) {
+      const childToDelete = deletions[i];
+
+      try {
+        commitDeletionEffects(root, parentFiber, childToDelete);
+      } catch (error) {
+        captureCommitPhaseError(childToDelete, parentFiber, error);
+      }
+    }
+  }
+
+  if (parentFiber.subtreeFlags & MutationMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      commitMutationEffectsOnFiber(child, root);
+      child = child.sibling;
+    }
+  }
+}
+
+let currentHoistableRoot = null;
+
+function commitMutationEffectsOnFiber(finishedWork, root, lanes) {
+  const current = finishedWork.alternate;
+  const flags = finishedWork.flags; // The effect flag should be checked *after* we refine the type of fiber,
+  // because the fiber tag is more specific. An exception is any flag related
+  // to reconciliation, because those can be set on all fiber types.
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Update) {
+          try {
+            commitHookEffectListUnmount(Insertion | HasEffect, finishedWork, finishedWork.return);
+            commitHookEffectListMount(Insertion | HasEffect, finishedWork);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          } // Layout effects are destroyed during the mutation phase so that all
+          // destroy functions for all fibers are called before any create functions.
+          // This prevents sibling component effects from interfering with each other,
+          // e.g. a destroy function in one component should never override a ref set
+          // by a create function in another component during the same commit.
+
+
+          {
+            try {
+              commitHookEffectListUnmount(Layout | HasEffect, finishedWork, finishedWork.return);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case ClassComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Ref) {
+          if (current !== null) {
+            safelyDetachRef(current, current.return);
+          }
+        }
+
+        if (flags & Callback && offscreenSubtreeIsHidden) {
+          const updateQueue = finishedWork.updateQueue;
+
+          if (updateQueue !== null) {
+            deferHiddenCallbacks(updateQueue);
+          }
+        }
+
+        return;
+      }
+
+    case HostHoistable:
+      {
+        {
+          // We cast because we always set the root at the React root and so it cannot be
+          // null while we are processing mutation effects
+          const hoistableRoot = currentHoistableRoot;
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+
+          if (flags & Ref) {
+            if (current !== null) {
+              safelyDetachRef(current, current.return);
+            }
+          }
+
+          if (flags & Update) {
+            const currentResource = current !== null ? current.memoizedState : null;
+            const newResource = finishedWork.memoizedState;
+
+            if (current === null) {
+              // We are mounting a new HostHoistable Fiber. We fork the mount
+              // behavior based on whether this instance is a Hoistable Instance
+              // or a Hoistable Resource
+              if (newResource === null) {
+                if (finishedWork.stateNode === null) {
+                  finishedWork.stateNode = hydrateHoistable(hoistableRoot, finishedWork.type, finishedWork.memoizedProps, finishedWork);
+                } else {
+                  mountHoistable(hoistableRoot, finishedWork.type, finishedWork.stateNode);
+                }
+              } else {
+                finishedWork.stateNode = acquireResource(hoistableRoot, newResource, finishedWork.memoizedProps);
+              }
+            } else if (currentResource !== newResource) {
+              // We are moving to or from Hoistable Resource, or between different Hoistable Resources
+              if (currentResource === null) {
+                if (current.stateNode !== null) {
+                  unmountHoistable(current.stateNode);
+                }
+              } else {
+                releaseResource(currentResource);
+              }
+
+              if (newResource === null) {
+                mountHoistable(hoistableRoot, finishedWork.type, finishedWork.stateNode);
+              } else {
+                acquireResource(hoistableRoot, newResource, finishedWork.memoizedProps);
+              }
+            } else if (newResource === null && finishedWork.stateNode !== null) {
+              // We may have an update on a Hoistable element
+              const updatePayload = finishedWork.updateQueue;
+              finishedWork.updateQueue = null;
+
+              try {
+                commitUpdate(finishedWork.stateNode, updatePayload, finishedWork.type, current.memoizedProps, finishedWork.memoizedProps, finishedWork);
+              } catch (error) {
+                captureCommitPhaseError(finishedWork, finishedWork.return, error);
+              }
+            }
+          }
+
+          return;
+        } // Fall through
+
+      }
+
+    case HostSingleton:
+      {
+        {
+          if (flags & Update) {
+            const previousWork = finishedWork.alternate;
+
+            if (previousWork === null) {
+              const singleton = finishedWork.stateNode;
+              const props = finishedWork.memoizedProps; // This was a new mount, we need to clear and set initial properties
+
+              clearSingleton(singleton);
+              acquireSingletonInstance(finishedWork.type, props, singleton, finishedWork);
+            }
+          }
+        } // Fall through
+
+      }
+
+    case HostComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Ref) {
+          if (current !== null) {
+            safelyDetachRef(current, current.return);
+          }
+        }
+
+        {
+          // TODO: ContentReset gets cleared by the children during the commit
+          // phase. This is a refactor hazard because it means we must read
+          // flags the flags after `commitReconciliationEffects` has already run;
+          // the order matters. We should refactor so that ContentReset does not
+          // rely on mutating the flag during commit. Like by setting a flag
+          // during the render phase instead.
+          if (finishedWork.flags & ContentReset) {
+            const instance = finishedWork.stateNode;
+
+            try {
+              resetTextContent(instance);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+
+          if (flags & Update) {
+            const instance = finishedWork.stateNode;
+
+            if (instance != null) {
+              // Commit the work prepared earlier.
+              const newProps = finishedWork.memoizedProps; // For hydration we reuse the update path but we treat the oldProps
+              // as the newProps. The updatePayload will contain the real change in
+              // this case.
+
+              const oldProps = current !== null ? current.memoizedProps : newProps;
+              const type = finishedWork.type; // TODO: Type the updateQueue to be specific to host components.
+
+              const updatePayload = finishedWork.updateQueue;
+              finishedWork.updateQueue = null;
+
+              try {
+                commitUpdate(instance, updatePayload, type, oldProps, newProps, finishedWork);
+              } catch (error) {
+                captureCommitPhaseError(finishedWork, finishedWork.return, error);
+              }
+            }
+          }
+        }
+
+        return;
+      }
+
+    case HostText:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Update) {
+          {
+            if (finishedWork.stateNode === null) {
+              throw Error(formatProdErrorMessage(162));
+            }
+
+            const textInstance = finishedWork.stateNode;
+            const newText = finishedWork.memoizedProps; // For hydration we reuse the update path but we treat the oldProps
+            // as the newProps. The updatePayload will contain the real change in
+            // this case.
+
+            const oldText = current !== null ? current.memoizedProps : newText;
+
+            try {
+              commitTextUpdate(textInstance, oldText, newText);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case HostRoot:
+      {
+        {
+          prepareToCommitHoistables();
+          const previousHoistableRoot = currentHoistableRoot;
+          currentHoistableRoot = getHoistableRoot(root.containerInfo);
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          currentHoistableRoot = previousHoistableRoot;
+          commitReconciliationEffects(finishedWork);
+        }
+
+        if (flags & Update) {
+          {
+            if (current !== null) {
+              const prevRootState = current.memoizedState;
+
+              if (prevRootState.isDehydrated) {
+                try {
+                  commitHydratedContainer(root.containerInfo);
+                } catch (error) {
+                  captureCommitPhaseError(finishedWork, finishedWork.return, error);
+                }
+              }
+            }
+          }
+        }
+
+        return;
+      }
+
+    case HostPortal:
+      {
+        {
+          const previousHoistableRoot = currentHoistableRoot;
+          currentHoistableRoot = getHoistableRoot(finishedWork.stateNode.containerInfo);
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          currentHoistableRoot = previousHoistableRoot;
+        }
+
+        return;
+      }
+
+    case SuspenseComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork); // TODO: We should mark a flag on the Suspense fiber itself, rather than
+        // relying on the Offscreen fiber having a flag also being marked. The
+        // reason is that this offscreen fiber might not be part of the work-in-
+        // progress tree! It could have been reused from a previous render. This
+        // doesn't lead to incorrect behavior because we don't rely on the flag
+        // check alone; we also compare the states explicitly below. But for
+        // modeling purposes, we _should_ be able to rely on the flag check alone.
+        // So this is a bit fragile.
+        //
+        // Also, all this logic could/should move to the passive phase so it
+        // doesn't block paint.
+
+        const offscreenFiber = finishedWork.child;
+
+        if (offscreenFiber.flags & Visibility) {
+          // Throttle the appearance and disappearance of Suspense fallbacks.
+          const isShowingFallback = finishedWork.memoizedState !== null;
+          const wasShowingFallback = current !== null && current.memoizedState !== null;
+
+          {
+            if (isShowingFallback !== wasShowingFallback) {
+              // A fallback is either appearing or disappearing.
+              markCommitTimeOfFallback();
+            }
+          }
+        }
+
+        if (flags & Update) {
+          try {
+            commitSuspenseCallback(finishedWork);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+
+          const retryQueue = finishedWork.updateQueue;
+
+          if (retryQueue !== null) {
+            finishedWork.updateQueue = null;
+            attachSuspenseRetryListeners(finishedWork, retryQueue);
+          }
+        }
+
+        return;
+      }
+
+    case OffscreenComponent:
+      {
+        if (flags & Ref) {
+          if (current !== null) {
+            safelyDetachRef(current, current.return);
+          }
+        }
+
+        const newState = finishedWork.memoizedState;
+        const isHidden = newState !== null;
+        const wasHidden = current !== null && current.memoizedState !== null;
+
+        if (finishedWork.mode & ConcurrentMode) {
+          // Before committing the children, track on the stack whether this
+          // offscreen subtree was already hidden, so that we don't unmount the
+          // effects again.
+          const prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
+          const prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden || isHidden;
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || wasHidden;
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+        } else {
+          recursivelyTraverseMutationEffects(root, finishedWork);
+        }
+
+        commitReconciliationEffects(finishedWork);
+        const offscreenInstance = finishedWork.stateNode; // TODO: Add explicit effect flag to set _current.
+
+        offscreenInstance._current = finishedWork; // Offscreen stores pending changes to visibility in `_pendingVisibility`. This is
+        // to support batching of `attach` and `detach` calls.
+
+        offscreenInstance._visibility &= ~OffscreenDetached;
+        offscreenInstance._visibility |= offscreenInstance._pendingVisibility & OffscreenDetached;
+
+        if (flags & Visibility) {
+          // Track the current state on the Offscreen instance so we can
+          // read it during an event
+          if (isHidden) {
+            offscreenInstance._visibility &= ~OffscreenVisible;
+          } else {
+            offscreenInstance._visibility |= OffscreenVisible;
+          }
+
+          if (isHidden) {
+            const isUpdate = current !== null;
+            const wasHiddenByAncestorOffscreen = offscreenSubtreeIsHidden || offscreenSubtreeWasHidden; // Only trigger disapper layout effects if:
+            //   - This is an update, not first mount.
+            //   - This Offscreen was not hidden before.
+            //   - Ancestor Offscreen was not hidden in previous commit.
+
+            if (isUpdate && !wasHidden && !wasHiddenByAncestorOffscreen) {
+              if ((finishedWork.mode & ConcurrentMode) !== NoMode) {
+                // Disappear the layout effects of all the children
+                recursivelyTraverseDisappearLayoutEffects(finishedWork);
+              }
+            }
+          } // Offscreen with manual mode manages visibility manually.
+
+
+          if (!isOffscreenManual(finishedWork)) {
+            // TODO: This needs to run whenever there's an insertion or update
+            // inside a hidden Offscreen tree.
+            hideOrUnhideAllChildren(finishedWork, isHidden);
+          }
+        } // TODO: Move to passive phase
+
+
+        if (flags & Update) {
+          const offscreenQueue = finishedWork.updateQueue;
+
+          if (offscreenQueue !== null) {
+            const retryQueue = offscreenQueue.retryQueue;
+
+            if (retryQueue !== null) {
+              offscreenQueue.retryQueue = null;
+              attachSuspenseRetryListeners(finishedWork, retryQueue);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case SuspenseListComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Update) {
+          const retryQueue = finishedWork.updateQueue;
+
+          if (retryQueue !== null) {
+            finishedWork.updateQueue = null;
+            attachSuspenseRetryListeners(finishedWork, retryQueue);
+          }
+        }
+
+        return;
+      }
+
+    case ScopeComponent:
+      {
+
+        return;
+      }
+
+    default:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        return;
+      }
+  }
+}
+
+function commitReconciliationEffects(finishedWork) {
+  // Placement effects (insertions, reorders) can be scheduled on any fiber
+  // type. They needs to happen after the children effects have fired, but
+  // before the effects on this fiber have fired.
+  const flags = finishedWork.flags;
+
+  if (flags & Placement) {
+    try {
+      commitPlacement(finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    } // Clear the "placement" from effect tag so that we know that this is
+    // inserted, before any life-cycles like componentDidMount gets called.
+    // TODO: findDOMNode doesn't rely on this any more but isMounted does
+    // and isMounted is deprecated anyway so we should be able to kill this.
+
+
+    finishedWork.flags &= ~Placement;
+  }
+
+  if (flags & Hydrating) {
+    finishedWork.flags &= ~Hydrating;
+  }
+}
+
+function commitLayoutEffects(finishedWork, root, committedLanes) {
+  const current = finishedWork.alternate;
+  commitLayoutEffectOnFiber(root, current, finishedWork);
+}
+
+function recursivelyTraverseLayoutEffects(root, parentFiber, lanes) {
+
+  if (parentFiber.subtreeFlags & LayoutMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      const current = child.alternate;
+      commitLayoutEffectOnFiber(root, current, child);
+      child = child.sibling;
+    }
+  }
+}
+
+function disappearLayoutEffects(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent:
+      {
+        // TODO (Offscreen) Check: flags & LayoutStatic
+        {
+          commitHookEffectListUnmount(Layout, finishedWork, finishedWork.return);
+        }
+
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      }
+
+    case ClassComponent:
+      {
+        // TODO (Offscreen) Check: flags & RefStatic
+        safelyDetachRef(finishedWork, finishedWork.return);
+        const instance = finishedWork.stateNode;
+
+        if (typeof instance.componentWillUnmount === 'function') {
+          safelyCallComponentWillUnmount(finishedWork, finishedWork.return, instance);
+        }
+
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      }
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      {
+        // TODO (Offscreen) Check: flags & RefStatic
+        safelyDetachRef(finishedWork, finishedWork.return);
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        // TODO (Offscreen) Check: flags & RefStatic
+        safelyDetachRef(finishedWork, finishedWork.return);
+        const isHidden = finishedWork.memoizedState !== null;
+
+        if (isHidden) ; else {
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
+  // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+  let child = parentFiber.child;
+
+  while (child !== null) {
+    disappearLayoutEffects(child);
+    child = child.sibling;
+  }
+}
+
+function reappearLayoutEffects(finishedRoot, current, finishedWork, // This function visits both newly finished work and nodes that were re-used
+// from a previously committed tree. We cannot check non-static flags if the
+// node was reused.
+includeWorkInProgressEffects) {
+  // Turn on layout effects in a tree that previously disappeared.
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // TODO: Check flags & LayoutStatic
+
+        commitHookLayoutEffects(finishedWork, Layout);
+        break;
+      }
+
+    case ClassComponent:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // TODO: Check for LayoutStatic flag
+
+        const instance = finishedWork.stateNode;
+
+        if (typeof instance.componentDidMount === 'function') {
+          try {
+            instance.componentDidMount();
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        } // Commit any callbacks that would have fired while the component
+        // was hidden.
+
+
+        const updateQueue = finishedWork.updateQueue;
+
+        if (updateQueue !== null) {
+          commitHiddenCallbacks(updateQueue, instance);
+        } // If this is newly finished work, check for setState callbacks
+
+
+        if (includeWorkInProgressEffects && flags & Callback) {
+          commitClassCallbacks(finishedWork);
+        } // TODO: Check flags & RefStatic
+
+
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      }
+    // Unlike commitLayoutEffectsOnFiber, we don't need to handle HostRoot
+    // because this function only visits nodes that are inside an
+    // Offscreen fiber.
+    // case HostRoot: {
+    //  ...
+    // }
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // Renderers may schedule work to be done after host components are mounted
+        // (eg DOM renderer may schedule auto-focus for inputs and form controls).
+        // These effects should only be committed when components are first mounted,
+        // aka when there is no current/alternate.
+
+        if (includeWorkInProgressEffects && current === null && flags & Update) {
+          commitHostComponentMount(finishedWork);
+        } // TODO: Check flags & Ref
+
+
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      }
+
+    case Profiler:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // TODO: Figure out how Profiler updates should work with Offscreen
+
+        break;
+      }
+
+    case SuspenseComponent:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // TODO: Figure out how Suspense hydration callbacks should work
+        // with Offscreen.
+
+        if (includeWorkInProgressEffects && flags & Update) {
+          commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
+        }
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const offscreenState = finishedWork.memoizedState;
+        const isHidden = offscreenState !== null;
+
+        if (isHidden) ; else {
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+        } // TODO: Check flags & Ref
+
+
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseReappearLayoutEffects(finishedRoot, parentFiber, includeWorkInProgressEffects) {
+  // This function visits both newly finished work and nodes that were re-used
+  // from a previously committed tree. We cannot check non-static flags if the
+  // node was reused.
+  const childShouldIncludeWorkInProgressEffects = includeWorkInProgressEffects && (parentFiber.subtreeFlags & LayoutMask) !== NoFlags$1; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+  let child = parentFiber.child;
+
+  while (child !== null) {
+    const current = child.alternate;
+    reappearLayoutEffects(finishedRoot, current, child, childShouldIncludeWorkInProgressEffects);
+    child = child.sibling;
+  }
+}
+
+function commitHookPassiveMountEffects(finishedWork, hookFlags) {
+  {
+    try {
+      commitHookEffectListMount(hookFlags, finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
+
+function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
+  {
+    let previousCache = null;
+
+    if (current !== null && current.memoizedState !== null && current.memoizedState.cachePool !== null) {
+      previousCache = current.memoizedState.cachePool.pool;
+    }
+
+    let nextCache = null;
+
+    if (finishedWork.memoizedState !== null && finishedWork.memoizedState.cachePool !== null) {
+      nextCache = finishedWork.memoizedState.cachePool.pool;
+    } // Retain/release the cache used for pending (suspended) nodes.
+    // Note that this is only reached in the non-suspended/visible case:
+    // when the content is suspended/hidden, the retain/release occurs
+    // via the parent Suspense component (see case above).
+
+
+    if (nextCache !== previousCache) {
+      if (nextCache != null) {
+        retainCache(nextCache);
+      }
+
+      if (previousCache != null) {
+        releaseCache(previousCache);
+      }
+    }
+  }
+}
+
+function commitCachePassiveMountEffect(current, finishedWork) {
+  {
+    let previousCache = null;
+
+    if (finishedWork.alternate !== null) {
+      previousCache = finishedWork.alternate.memoizedState.cache;
+    }
+
+    const nextCache = finishedWork.memoizedState.cache; // Retain/release the cache. In theory the cache component
+    // could be "borrowing" a cache instance owned by some parent,
+    // in which case we could avoid retaining/releasing. But it
+    // is non-trivial to determine when that is the case, so we
+    // always retain/release.
+
+    if (nextCache !== previousCache) {
+      retainCache(nextCache);
+
+      if (previousCache != null) {
+        releaseCache(previousCache);
+      }
+    }
+  }
+}
+
+function commitPassiveMountEffects(root, finishedWork, committedLanes, committedTransitions) {
+  commitPassiveMountOnFiber(root, finishedWork, committedLanes, committedTransitions);
+}
+
+function recursivelyTraversePassiveMountEffects(root, parentFiber, committedLanes, committedTransitions) {
+
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      commitPassiveMountOnFiber(root, child, committedLanes, committedTransitions);
+      child = child.sibling;
+    }
+  }
+}
+
+function commitPassiveMountOnFiber(finishedRoot, finishedWork, committedLanes, committedTransitions) {
+  // When updating this function, also update reconnectPassiveEffects, which does
+  // most of the same things when an offscreen tree goes from hidden -> visible,
+  // or when toggling effects inside a hidden tree.
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+
+        if (flags & Passive$1) {
+          commitHookPassiveMountEffects(finishedWork, Passive | HasEffect);
+        }
+
+        break;
+      }
+
+    case HostRoot:
+      {
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+
+        if (flags & Passive$1) {
+          {
+            let previousCache = null;
+
+            if (finishedWork.alternate !== null) {
+              previousCache = finishedWork.alternate.memoizedState.cache;
+            }
+
+            const nextCache = finishedWork.memoizedState.cache; // Retain/release the root cache.
+            // Note that on initial mount, previousCache and nextCache will be the same
+            // and this retain won't occur. To counter this, we instead retain the HostRoot's
+            // initial cache when creating the root itself (see createFiberRoot() in
+            // ReactFiberRoot.js). Subsequent updates that change the cache are reflected
+            // here, such that previous/next caches are retained correctly.
+
+            if (nextCache !== previousCache) {
+              retainCache(nextCache);
+
+              if (previousCache != null) {
+                releaseCache(previousCache);
+              }
+            }
+          }
+        }
+
+        break;
+      }
+
+    case LegacyHiddenComponent:
+      {
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        // TODO: Pass `current` as argument to this function
+        const instance = finishedWork.stateNode;
+        const nextState = finishedWork.memoizedState;
+        const isHidden = nextState !== null;
+
+        if (isHidden) {
+          if (instance._visibility & OffscreenPassiveEffectsConnected) {
+            // The effects are currently connected. Update them.
+            recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          } else {
+            if (finishedWork.mode & ConcurrentMode) {
+              // The effects are currently disconnected. Since the tree is hidden,
+              // don't connect them. This also applies to the initial render.
+              {
+                // "Atomic" effects are ones that need to fire on every commit,
+                // even during pre-rendering. An example is updating the reference
+                // count on cache instances.
+                recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+              }
+            } else {
+              // Legacy Mode: Fire the effects even if the tree is hidden.
+              instance._visibility |= OffscreenPassiveEffectsConnected;
+              recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+            }
+          }
+        } else {
+          // Tree is visible
+          if (instance._visibility & OffscreenPassiveEffectsConnected) {
+            // The effects are currently connected. Update them.
+            recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          } else {
+            // The effects are currently disconnected. Reconnect them, while also
+            // firing effects inside newly mounted trees. This also applies to
+            // the initial render.
+            instance._visibility |= OffscreenPassiveEffectsConnected;
+            const includeWorkInProgressEffects = (finishedWork.subtreeFlags & PassiveMask) !== NoFlags$1;
+            recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+          }
+        }
+
+        if (flags & Passive$1) {
+          const current = finishedWork.alternate;
+          commitOffscreenPassiveMountEffects(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+
+        if (flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitCachePassiveMountEffect(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case TracingMarkerComponent:
+
+    default:
+      {
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseReconnectPassiveEffects(finishedRoot, parentFiber, committedLanes, committedTransitions, includeWorkInProgressEffects) {
+  // This function visits both newly finished work and nodes that were re-used
+  // from a previously committed tree. We cannot check non-static flags if the
+  // node was reused.
+  const childShouldIncludeWorkInProgressEffects = includeWorkInProgressEffects && (parentFiber.subtreeFlags & PassiveMask) !== NoFlags$1; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+  let child = parentFiber.child;
+
+  while (child !== null) {
+    reconnectPassiveEffects(finishedRoot, child, committedLanes, committedTransitions, childShouldIncludeWorkInProgressEffects);
+    child = child.sibling;
+  }
+}
+
+function reconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, // This function visits both newly finished work and nodes that were re-used
+// from a previously committed tree. We cannot check non-static flags if the
+// node was reused.
+includeWorkInProgressEffects) {
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects); // TODO: Check for PassiveStatic flag
+
+        commitHookPassiveMountEffects(finishedWork, Passive);
+        break;
+      }
+    // Unlike commitPassiveMountOnFiber, we don't need to handle HostRoot
+    // because this function only visits nodes that are inside an
+    // Offscreen fiber.
+    // case HostRoot: {
+    //  ...
+    // }
+
+    case LegacyHiddenComponent:
+      {
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const instance = finishedWork.stateNode;
+        const nextState = finishedWork.memoizedState;
+        const isHidden = nextState !== null;
+
+        if (isHidden) {
+          if (instance._visibility & OffscreenPassiveEffectsConnected) {
+            // The effects are currently connected. Update them.
+            recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+          } else {
+            if (finishedWork.mode & ConcurrentMode) {
+              // The effects are currently disconnected. Since the tree is hidden,
+              // don't connect them. This also applies to the initial render.
+              {
+                // "Atomic" effects are ones that need to fire on every commit,
+                // even during pre-rendering. An example is updating the reference
+                // count on cache instances.
+                recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+              }
+            } else {
+              // Legacy Mode: Fire the effects even if the tree is hidden.
+              instance._visibility |= OffscreenPassiveEffectsConnected;
+              recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+            }
+          }
+        } else {
+          // Tree is visible
+          // Since we're already inside a reconnecting tree, it doesn't matter
+          // whether the effects are currently connected. In either case, we'll
+          // continue traversing the tree and firing all the effects.
+          //
+          // We do need to set the "connected" flag on the instance, though.
+          instance._visibility |= OffscreenPassiveEffectsConnected;
+          recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+        }
+
+        if (includeWorkInProgressEffects && flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitOffscreenPassiveMountEffects(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+
+        if (includeWorkInProgressEffects && flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitCachePassiveMountEffect(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case TracingMarkerComponent:
+
+    default:
+      {
+        recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseAtomicPassiveEffects(finishedRoot, parentFiber, committedLanes, committedTransitions) {
+
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      commitAtomicPassiveEffects(finishedRoot, child);
+      child = child.sibling;
+    }
+  }
+}
+
+function commitAtomicPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions) {
+  // "Atomic" effects are ones that need to fire on every commit, even during
+  // pre-rendering. We call this function when traversing a hidden tree whose
+  // regular effects are currently disconnected.
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case OffscreenComponent:
+      {
+        recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+
+        if (flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitOffscreenPassiveMountEffects(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+
+        if (flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitCachePassiveMountEffect(current, finishedWork);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+        break;
+      }
+  }
+}
+
+function commitPassiveUnmountEffects(finishedWork) {
+  commitPassiveUnmountOnFiber(finishedWork);
+} // If we're inside a brand new tree, or a tree that was already visible, then we
+// should only suspend host components that have a ShouldSuspendCommit flag.
+// Components without it haven't changed since the last commit, so we can skip
+// over those.
+//
+// When we enter a tree that is being revealed (going from hidden -> visible),
+// we need to suspend _any_ component that _may_ suspend. Even if they're
+// already in the "current" tree. Because their visibility has changed, the
+// browser may not have prerendered them yet. So we check the MaySuspendCommit
+// flag instead.
+
+let suspenseyCommitFlag = ShouldSuspendCommit;
+function accumulateSuspenseyCommit(finishedWork) {
+  accumulateSuspenseyCommitOnFiber(finishedWork);
+}
+
+function recursivelyAccumulateSuspenseyCommit(parentFiber) {
+  if (parentFiber.subtreeFlags & suspenseyCommitFlag) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      accumulateSuspenseyCommitOnFiber(child);
+      child = child.sibling;
+    }
+  }
+}
+
+function accumulateSuspenseyCommitOnFiber(fiber) {
+  switch (fiber.tag) {
+    case HostHoistable:
+      {
+        recursivelyAccumulateSuspenseyCommit(fiber);
+
+        if (fiber.flags & suspenseyCommitFlag) {
+          if (fiber.memoizedState !== null) {
+            suspendResource( // This should always be set by visiting HostRoot first
+            currentHoistableRoot, fiber.memoizedState, fiber.memoizedProps);
+          }
+        }
+
+        break;
+      }
+
+    case HostComponent:
+      {
+        recursivelyAccumulateSuspenseyCommit(fiber);
+
+        break;
+      }
+
+    case HostRoot:
+    case HostPortal:
+      {
+        {
+          const previousHoistableRoot = currentHoistableRoot;
+          const container = fiber.stateNode.containerInfo;
+          currentHoistableRoot = getHoistableRoot(container);
+          recursivelyAccumulateSuspenseyCommit(fiber);
+          currentHoistableRoot = previousHoistableRoot;
+        }
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const isHidden = fiber.memoizedState !== null;
+
+        if (isHidden) ; else {
+          const current = fiber.alternate;
+          const wasHidden = current !== null && current.memoizedState !== null;
+
+          if (wasHidden) {
+            // This tree is being revealed. Visit all newly visible suspensey
+            // instances, even if they're in the current tree.
+            const prevFlags = suspenseyCommitFlag;
+            suspenseyCommitFlag = MaySuspendCommit;
+            recursivelyAccumulateSuspenseyCommit(fiber);
+            suspenseyCommitFlag = prevFlags;
+          } else {
+            recursivelyAccumulateSuspenseyCommit(fiber);
+          }
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyAccumulateSuspenseyCommit(fiber);
+      }
+  }
+}
+
+function detachAlternateSiblings(parentFiber) {
+  // A fiber was deleted from this parent fiber, but it's still part of the
+  // previous (alternate) parent fiber's list of children. Because children
+  // are a linked list, an earlier sibling that's still alive will be
+  // connected to the deleted fiber via its `alternate`:
+  //
+  //   live fiber --alternate--> previous live fiber --sibling--> deleted
+  //   fiber
+  //
+  // We can't disconnect `alternate` on nodes that haven't been deleted yet,
+  // but we can disconnect the `sibling` and `child` pointers.
+  const previousFiber = parentFiber.alternate;
+
+  if (previousFiber !== null) {
+    let detachedChild = previousFiber.child;
+
+    if (detachedChild !== null) {
+      previousFiber.child = null;
+
+      do {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        const detachedSibling = detachedChild.sibling; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+        detachedChild.sibling = null;
+        detachedChild = detachedSibling;
+      } while (detachedChild !== null);
+    }
+  }
+}
+
+function commitHookPassiveUnmountEffects(finishedWork, nearestMountedAncestor, hookFlags) {
+  {
+    commitHookEffectListUnmount(hookFlags, finishedWork, nearestMountedAncestor);
+  }
+}
+
+function recursivelyTraversePassiveUnmountEffects(parentFiber) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects have fired.
+  const deletions = parentFiber.deletions;
+
+  if ((parentFiber.flags & ChildDeletion) !== NoFlags$1) {
+    if (deletions !== null) {
+      for (let i = 0; i < deletions.length; i++) {
+        const childToDelete = deletions[i]; // TODO: Convert this to use recursion
+
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(childToDelete, parentFiber);
+      }
+    }
+
+    detachAlternateSiblings(parentFiber);
+  }
+
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      commitPassiveUnmountOnFiber(child);
+      child = child.sibling;
+    }
+  }
+}
+
+function commitPassiveUnmountOnFiber(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraversePassiveUnmountEffects(finishedWork);
+
+        if (finishedWork.flags & Passive$1) {
+          commitHookPassiveUnmountEffects(finishedWork, finishedWork.return, Passive | HasEffect);
+        }
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const instance = finishedWork.stateNode;
+        const nextState = finishedWork.memoizedState;
+        const isHidden = nextState !== null;
+
+        if (isHidden && instance._visibility & OffscreenPassiveEffectsConnected && ( // For backwards compatibility, don't unmount when a tree suspends. In
+        // the future we may change this to unmount after a delay.
+        finishedWork.return === null || finishedWork.return.tag !== SuspenseComponent)) {
+          // The effects are currently connected. Disconnect them.
+          // TODO: Add option or heuristic to delay before disconnecting the
+          // effects. Then if the tree reappears before the delay has elapsed, we
+          // can skip toggling the effects entirely.
+          instance._visibility &= ~OffscreenPassiveEffectsConnected;
+          recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+        } else {
+          recursivelyTraversePassiveUnmountEffects(finishedWork);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraversePassiveUnmountEffects(finishedWork);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects have fired.
+  const deletions = parentFiber.deletions;
+
+  if ((parentFiber.flags & ChildDeletion) !== NoFlags$1) {
+    if (deletions !== null) {
+      for (let i = 0; i < deletions.length; i++) {
+        const childToDelete = deletions[i]; // TODO: Convert this to use recursion
+
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(childToDelete, parentFiber);
+      }
+    }
+
+    detachAlternateSiblings(parentFiber);
+  }
+
+  let child = parentFiber.child;
+
+  while (child !== null) {
+    disconnectPassiveEffect(child);
+    child = child.sibling;
+  }
+}
+
+function disconnectPassiveEffect(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        // TODO: Check PassiveStatic flag
+        commitHookPassiveUnmountEffects(finishedWork, finishedWork.return, Passive); // When disconnecting passive effects, we fire the effects in the same
+        // order as during a deletiong: parent before child
+
+        recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const instance = finishedWork.stateNode;
+
+        if (instance._visibility & OffscreenPassiveEffectsConnected) {
+          instance._visibility &= ~OffscreenPassiveEffectsConnected;
+          recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+        break;
+      }
+  }
+}
+
+function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(deletedSubtreeRoot, nearestMountedAncestor) {
+  while (nextEffect !== null) {
+    const fiber = nextEffect; // Deletion effects fire in parent -> child order
+    commitPassiveUnmountInsideDeletedTreeOnFiber(fiber, nearestMountedAncestor);
+    const child = fiber.child; // TODO: Only traverse subtree if it has a PassiveStatic flag.
+
+    if (child !== null) {
+      child.return = fiber;
+      nextEffect = child;
+    } else {
+      commitPassiveUnmountEffectsInsideOfDeletedTree_complete(deletedSubtreeRoot);
+    }
+  }
+}
+
+function commitPassiveUnmountEffectsInsideOfDeletedTree_complete(deletedSubtreeRoot) {
+  while (nextEffect !== null) {
+    const fiber = nextEffect;
+    const sibling = fiber.sibling;
+    const returnFiber = fiber.return; // Recursively traverse the entire deleted tree and clean up fiber fields.
+    // This is more aggressive than ideal, and the long term goal is to only
+    // have to detach the deleted tree at the root.
+
+    detachFiberAfterEffects(fiber);
+
+    if (fiber === deletedSubtreeRoot) {
+      nextEffect = null;
+      return;
+    }
+
+    if (sibling !== null) {
+      sibling.return = returnFiber;
+      nextEffect = sibling;
+      return;
+    }
+
+    nextEffect = returnFiber;
+  }
+}
+
+function commitPassiveUnmountInsideDeletedTreeOnFiber(current, nearestMountedAncestor) {
+  switch (current.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        commitHookPassiveUnmountEffects(current, nearestMountedAncestor, Passive);
+        break;
+      }
+    // TODO: run passive unmount effects when unmounting a root.
+    // Because passive unmount effects are not currently run,
+    // the cache instance owned by the root will never be freed.
+    // When effects are run, the cache should be freed here:
+    // case HostRoot: {
+    //   if (enableCache) {
+    //     const cache = current.memoizedState.cache;
+    //     releaseCache(cache);
+    //   }
+    //   break;
+    // }
+
+    case LegacyHiddenComponent:
+    case OffscreenComponent:
+      {
+        {
+          if (current.memoizedState !== null && current.memoizedState.cachePool !== null) {
+            const cache = current.memoizedState.cachePool.pool; // Retain/release the cache used for pending (suspended) nodes.
+            // Note that this is only reached in the non-suspended/visible case:
+            // when the content is suspended/hidden, the retain/release occurs
+            // via the parent Suspense component (see case above).
+
+            if (cache != null) {
+              retainCache(cache);
+            }
+          }
+        }
+
+        break;
+      }
+
+    case SuspenseComponent:
+      {
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        {
+          const cache = current.memoizedState.cache;
+          releaseCache(cache);
+        }
+
+        break;
+      }
+  }
+}
+
+function getCacheSignal() {
+
+  const cache = readContext(CacheContext);
+  return cache.controller.signal;
+}
+
+function getCacheForType(resourceType) {
+
+  const cache = readContext(CacheContext);
+  let cacheForType = cache.data.get(resourceType);
+
+  if (cacheForType === undefined) {
+    cacheForType = resourceType();
+    cache.data.set(resourceType, cacheForType);
+  }
+
+  return cacheForType;
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal,
+  getCacheForType
+};
+
+const PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
+      ReactCurrentCache = ReactSharedInternals.ReactCurrentCache,
+      ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner,
+      ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig,
+      ReactCurrentActQueue = ReactSharedInternals.ReactCurrentActQueue;
+const NoContext =
+/*             */
+0b000;
+const BatchedContext =
+/*               */
+0b001;
+const RenderContext =
+/*         */
+0b010;
+const CommitContext =
+/*         */
+0b100;
+const RootInProgress = 0;
+const RootFatalErrored = 1;
+const RootErrored = 2;
+const RootSuspended = 3;
+const RootSuspendedWithDelay = 4;
+const RootCompleted = 5;
+const RootDidNotComplete = 6; // Describes where we are in the React execution stack
+
+let executionContext = NoContext; // The root we're working on
+
+let workInProgressRoot = null; // The fiber we're working on
+
+let workInProgress = null; // The lanes we're rendering
+
+let workInProgressRootRenderLanes = NoLanes;
+const NotSuspended = 0;
+const SuspendedOnError = 1;
+const SuspendedOnData = 2;
+const SuspendedOnImmediate = 3;
+const SuspendedOnInstance = 4;
+const SuspendedOnInstanceAndReadyToContinue = 5;
+const SuspendedOnDeprecatedThrowPromise = 6;
+const SuspendedAndReadyToContinue = 7;
+const SuspendedOnHydration = 8; // When this is true, the work-in-progress fiber just suspended (or errored) and
+// we've yet to unwind the stack. In some cases, we may yield to the main thread
+// after this happens. If the fiber is pinged before we resume, we can retry
+// immediately instead of unwinding the stack.
+
+let workInProgressSuspendedReason = NotSuspended;
+let workInProgressThrownValue = null; // Whether a ping listener was attached during this render. This is slightly
+// different that whether something suspended, because we don't add multiple
+// listeners to a promise we've already seen (per root and lane).
+
+let workInProgressRootDidAttachPingListener = false; // A contextual version of workInProgressRootRenderLanes. It is a superset of
+// the lanes that we started working on at the root. When we enter a subtree
+// that is currently hidden, we add the lanes that would have committed if
+// the hidden tree hadn't been deferred. This is modified by the
+// HiddenContext module.
+//
+// Most things in the work loop should deal with workInProgressRootRenderLanes.
+// Most things in begin/complete phases should deal with entangledRenderLanes.
+
+let entangledRenderLanes = NoLanes; // Whether to root completed, errored, suspended, etc.
+
+let workInProgressRootExitStatus = RootInProgress; // A fatal error, if one is thrown
+
+let workInProgressRootFatalError = null; // The work left over by components that were visited during this render. Only
+// includes unprocessed updates, not work in bailed out children.
+
+let workInProgressRootSkippedLanes = NoLanes; // Lanes that were updated (in an interleaved event) during this render.
+
+let workInProgressRootInterleavedUpdatedLanes = NoLanes; // Lanes that were updated during the render phase (*not* an interleaved event).
+
+let workInProgressRootPingedLanes = NoLanes; // If this lane scheduled deferred work, this is the lane of the deferred task.
+
+let workInProgressDeferredLane = NoLane; // Errors that are thrown during the render phase.
+
+let workInProgressRootConcurrentErrors = null; // These are errors that we recovered from without surfacing them to the UI.
+// We will log them once the tree commits.
+
+let workInProgressRootRecoverableErrors = null; // The most recent time we either committed a fallback, or when a fallback was
+// filled in with the resolved UI. This lets us throttle the appearance of new
+// content as it streams in, to minimize jank.
+// TODO: Think of a better name for this variable?
+
+let globalMostRecentFallbackTime = 0;
+const FALLBACK_THROTTLE_MS = 300; // The absolute time for when we should start giving up on rendering
+// more and prefer CPU suspense heuristics instead.
+
+let workInProgressRootRenderTargetTime = Infinity; // How long a render is supposed to take before we start following CPU
+// suspense heuristics and opt out of rendering more content.
+
+const RENDER_TIMEOUT_MS = 500;
+let workInProgressTransitions = null;
+
+function resetRenderTimer() {
+  workInProgressRootRenderTargetTime = now() + RENDER_TIMEOUT_MS;
+}
+
+function getRenderTargetTime() {
+  return workInProgressRootRenderTargetTime;
+}
+let hasUncaughtError = false;
+let firstUncaughtError = null;
+let legacyErrorBoundariesThatAlreadyFailed = null; // Only used when enableProfilerNestedUpdateScheduledHook is true;
+let rootDoesHavePassiveEffects = false;
+let rootWithPendingPassiveEffects = null;
+let pendingPassiveEffectsLanes = NoLanes;
+let pendingPassiveEffectsRemainingLanes = NoLanes;
+let pendingPassiveTransitions = null; // Use these to prevent an infinite loop of nested updates
+
+const NESTED_UPDATE_LIMIT = 50;
+let nestedUpdateCount = 0;
+let rootWithNestedUpdates = null;
+function getWorkInProgressRoot() {
+  return workInProgressRoot;
+}
+function getWorkInProgressRootRenderLanes() {
+  return workInProgressRootRenderLanes;
+}
+function isWorkLoopSuspendedOnData() {
+  return workInProgressSuspendedReason === SuspendedOnData;
+}
+function requestUpdateLane(fiber) {
+  // Special cases
+  const mode = fiber.mode;
+
+  if ((mode & ConcurrentMode) === NoMode) {
+    return SyncLane;
+  } else if ((executionContext & RenderContext) !== NoContext && workInProgressRootRenderLanes !== NoLanes) {
+    // This is a render phase update. These are not officially supported. The
+    // old behavior is to give this the same "thread" (lanes) as
+    // whatever is currently rendering. So if you call `setState` on a component
+    // that happens later in the same render, it will flush. Ideally, we want to
+    // remove the special case and treat them as if they came from an
+    // interleaved event. Regardless, this pattern is not officially supported.
+    // This behavior is only a fallback. The flag only exists until we can roll
+    // out the setState warning, since existing code might accidentally rely on
+    // the current behavior.
+    return pickArbitraryLane(workInProgressRootRenderLanes);
+  }
+
+  const isTransition = requestCurrentTransition() !== NoTransition;
+
+  if (isTransition) {
+
+    const actionScopeLane = peekEntangledActionLane();
+    return actionScopeLane !== NoLane ? // We're inside an async action scope. Reuse the same lane.
+    actionScopeLane : // We may or may not be inside an async action scope. If we are, this
+    // is the first update in that scope. Either way, we need to get a
+    // fresh transition lane.
+    requestTransitionLane();
+  } // Updates originating inside certain React methods, like flushSync, have
+  // their priority set by tracking it with a context variable.
+  //
+  // The opaque type returned by the host config is internally a lane, so we can
+  // use that directly.
+  // TODO: Move this type conversion to the event priority module.
+
+
+  const updateLane = getCurrentUpdatePriority();
+
+  if (updateLane !== NoLane) {
+    return updateLane;
+  } // This update originated outside React. Ask the host environment for an
+  // appropriate priority, based on the type of event.
+  //
+  // The opaque type returned by the host config is internally a lane, so we can
+  // use that directly.
+  // TODO: Move this type conversion to the event priority module.
+
+
+  const eventLane = getCurrentEventPriority();
+  return eventLane;
+}
+
+function requestRetryLane(fiber) {
+  // This is a fork of `requestUpdateLane` designed specifically for Suspense
+  // "retries" — a special update that attempts to flip a Suspense boundary
+  // from its placeholder state to its primary/resolved state.
+  // Special cases
+  const mode = fiber.mode;
+
+  if ((mode & ConcurrentMode) === NoMode) {
+    return SyncLane;
+  }
+
+  return claimNextRetryLane();
+}
+
+function requestDeferredLane() {
+  if (workInProgressDeferredLane === NoLane) {
+    // If there are multiple useDeferredValue hooks in the same render, the
+    // tasks that they spawn should all be batched together, so they should all
+    // receive the same lane.
+    // Check the priority of the current render to decide the priority of the
+    // deferred task.
+    // OffscreenLane is used for prerendering, but we also use OffscreenLane
+    // for incremental hydration. It's given the lowest priority because the
+    // initial HTML is the same as the final UI. But useDeferredValue during
+    // hydration is an exception — we need to upgrade the UI to the final
+    // value. So if we're currently hydrating, we treat it like a transition.
+    const isPrerendering = includesSomeLane(workInProgressRootRenderLanes, OffscreenLane) && !getIsHydrating();
+
+    if (isPrerendering) {
+      // There's only one OffscreenLane, so if it contains deferred work, we
+      // should just reschedule using the same lane.
+      workInProgressDeferredLane = OffscreenLane;
+    } else {
+      // Everything else is spawned as a transition.
+      workInProgressDeferredLane = requestTransitionLane();
+    }
+  }
+
+  return workInProgressDeferredLane;
+}
+function scheduleUpdateOnFiber(root, fiber, lane) {
+  // finish loading.
+
+
+  if ( // Suspended render phase
+  root === workInProgressRoot && workInProgressSuspendedReason === SuspendedOnData || // Suspended commit phase
+  root.cancelPendingCommit !== null) {
+    // The incoming update might unblock the current render. Interrupt the
+    // current attempt and restart from the top.
+    prepareFreshStack(root, NoLanes);
+    markRootSuspended(root, workInProgressRootRenderLanes, workInProgressDeferredLane);
+  } // Mark that the root has a pending update.
+
+
+  markRootUpdated(root, lane);
+
+  if ((executionContext & RenderContext) !== NoLanes && root === workInProgressRoot) ; else {
+
+    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.
+      if ((executionContext & RenderContext) === NoContext) {
+        workInProgressRootInterleavedUpdatedLanes = mergeLanes(workInProgressRootInterleavedUpdatedLanes, lane);
+      }
+
+      if (workInProgressRootExitStatus === RootSuspendedWithDelay) {
+        // The root already suspended with a delay, which means this render
+        // definitely won't finish. Since we have a new update, let's mark it as
+        // suspended now, right before marking the incoming update. This has the
+        // effect of interrupting the current render and switching to the update.
+        // TODO: Make sure this doesn't override pings that happen while we've
+        // already started rendering.
+        markRootSuspended(root, workInProgressRootRenderLanes, workInProgressDeferredLane);
+      }
+    }
+
+    ensureRootIsScheduled(root);
+
+    if (lane === SyncLane && executionContext === NoContext && (fiber.mode & ConcurrentMode) === NoMode) {
+      {
+        // Flush the synchronous work now, unless we're already working or inside
+        // a batch. This is intentionally inside scheduleUpdateOnFiber instead of
+        // scheduleCallbackForFiber to preserve the ability to schedule a callback
+        // without immediately flushing it. We only do this for user-initiated
+        // updates, to preserve historical behavior of legacy mode.
+        resetRenderTimer();
+        flushSyncWorkOnLegacyRootsOnly();
+      }
+    }
+  }
+}
+function scheduleInitialHydrationOnRoot(root, lane) {
+  // This is a special fork of scheduleUpdateOnFiber that is only used to
+  // schedule the initial hydration of a root that has just been created. Most
+  // of the stuff in scheduleUpdateOnFiber can be skipped.
+  //
+  // The main reason for this separate path, though, is to distinguish the
+  // initial children from subsequent updates. In fully client-rendered roots
+  // (createRoot instead of hydrateRoot), all top-level renders are modeled as
+  // updates, but hydration roots are special because the initial render must
+  // match what was rendered on the server.
+  const current = root.current;
+  current.lanes = lane;
+  markRootUpdated(root, lane);
+  ensureRootIsScheduled(root);
+}
+function isUnsafeClassRenderPhaseUpdate(fiber) {
+  // Check if this is a render phase update. Only called by class components,
+  // which special (deprecated) behavior for UNSAFE_componentWillReceive props.
+  return (executionContext & RenderContext) !== NoContext;
+} // This is the entry point for every concurrent task, i.e. anything that
+// goes through Scheduler.
+
+function performConcurrentWorkOnRoot(root, didTimeout) {
+
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw Error(formatProdErrorMessage(327));
+  } // Flush any pending passive effects before deciding which lanes to work on,
+  // in case they schedule additional work.
+
+
+  const originalCallbackNode = root.callbackNode;
+  const didFlushPassiveEffects = flushPassiveEffects();
+
+  if (didFlushPassiveEffects) {
+    // Something in the passive effect phase may have canceled the current task.
+    // Check if the task node for this root was changed.
+    if (root.callbackNode !== originalCallbackNode) {
+      // The current task was canceled. Exit. We don't need to call
+      // `ensureRootIsScheduled` because the check above implies either that
+      // there's a new task, or that there's no remaining work on this root.
+      return null;
+    }
+  } // Determine the next lanes to work on, using the fields stored
+  // on the root.
+  // TODO: This was already computed in the caller. Pass it as an argument.
+
+
+  let lanes = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes);
+
+  if (lanes === NoLanes) {
+    // Defensive coding. This is never expected to happen.
+    return null;
+  } // We disable time-slicing in some cases: if the work has been CPU-bound
+  // for too long ("expired" work, to prevent starvation), or we're in
+  // sync-updates-by-default mode.
+  // TODO: We only check `didTimeout` defensively, to account for a Scheduler
+  // bug we're still investigating. Once the bug in Scheduler is fixed,
+  // we can remove this, since we track expiration ourselves.
+
+
+  const shouldTimeSlice = !includesBlockingLane(root, lanes) && !includesExpiredLane(root, lanes) && (!didTimeout);
+  let exitStatus = shouldTimeSlice ? renderRootConcurrent(root, lanes) : renderRootSync(root, lanes);
+
+  if (exitStatus !== RootInProgress) {
+    let renderWasConcurrent = shouldTimeSlice;
+
+    do {
+      if (exitStatus === RootDidNotComplete) {
+        // The render unwound without completing the tree. This happens in special
+        // cases where need to exit the current render without producing a
+        // consistent tree or committing.
+        markRootSuspended(root, lanes, NoLane);
+      } else {
+        // The render completed.
+        // Check if this render may have yielded to a concurrent event, and if so,
+        // confirm that any newly rendered stores are consistent.
+        // TODO: It's possible that even a concurrent render may never have yielded
+        // to the main thread, if it was fast enough, or if it expired. We could
+        // skip the consistency check in that case, too.
+        const finishedWork = root.current.alternate;
+
+        if (renderWasConcurrent && !isRenderConsistentWithExternalStores(finishedWork)) {
+          // A store was mutated in an interleaved event. Render again,
+          // synchronously, to block further mutations.
+          exitStatus = renderRootSync(root, lanes); // We assume the tree is now consistent because we didn't yield to any
+          // concurrent events.
+
+          renderWasConcurrent = false; // Need to check the exit status again.
+
+          continue;
+        } // Check if something threw
+
+
+        if (exitStatus === RootErrored) {
+          const originallyAttemptedLanes = lanes;
+          const errorRetryLanes = getLanesToRetrySynchronouslyOnError(root, originallyAttemptedLanes);
+
+          if (errorRetryLanes !== NoLanes) {
+            lanes = errorRetryLanes;
+            exitStatus = recoverFromConcurrentError(root, originallyAttemptedLanes, errorRetryLanes);
+            renderWasConcurrent = false;
+          }
+        }
+
+        if (exitStatus === RootFatalErrored) {
+          const fatalError = workInProgressRootFatalError;
+          prepareFreshStack(root, NoLanes);
+          markRootSuspended(root, lanes, NoLane);
+          ensureRootIsScheduled(root);
+          throw fatalError;
+        } // We now have a consistent tree. The next step is either to commit it,
+        // or, if something suspended, wait to commit it after a timeout.
+
+
+        root.finishedWork = finishedWork;
+        root.finishedLanes = lanes;
+        finishConcurrentRender(root, exitStatus, finishedWork, lanes);
+      }
+
+      break;
+    } while (true);
+  }
+
+  ensureRootIsScheduled(root);
+  return getContinuationForRoot(root, originalCallbackNode);
+}
+
+function recoverFromConcurrentError(root, originallyAttemptedLanes, errorRetryLanes) {
+  // If an error occurred during hydration, discard server response and fall
+  // back to client side render.
+  // Before rendering again, save the errors from the previous attempt.
+  const errorsFromFirstAttempt = workInProgressRootConcurrentErrors;
+  const wasRootDehydrated = isRootDehydrated(root);
+
+  if (wasRootDehydrated) {
+    // The shell failed to hydrate. Set a flag to force a client rendering
+    // during the next attempt. To do this, we call prepareFreshStack now
+    // to create the root work-in-progress fiber. This is a bit weird in terms
+    // of factoring, because it relies on renderRootSync not calling
+    // prepareFreshStack again in the call below, which happens because the
+    // root and lanes haven't changed.
+    //
+    // TODO: I think what we should do is set ForceClientRender inside
+    // throwException, like we do for nested Suspense boundaries. The reason
+    // it's here instead is so we can switch to the synchronous work loop, too.
+    // Something to consider for a future refactor.
+    const rootWorkInProgress = prepareFreshStack(root, errorRetryLanes);
+    rootWorkInProgress.flags |= ForceClientRender;
+  }
+
+  const exitStatus = renderRootSync(root, errorRetryLanes);
+
+  if (exitStatus !== RootErrored) {
+    // Successfully finished rendering on retry
+    if (workInProgressRootDidAttachPingListener && !wasRootDehydrated) {
+      // During the synchronous render, we attached additional ping listeners.
+      // This is highly suggestive of an uncached promise (though it's not the
+      // only reason this would happen). If it was an uncached promise, then
+      // it may have masked a downstream error from ocurring without actually
+      // fixing it. Example:
+      //
+      //    use(Promise.resolve('uncached'))
+      //    throw new Error('Oops!')
+      //
+      // When this happens, there's a conflict between blocking potential
+      // concurrent data races and unwrapping uncached promise values. We
+      // have to choose one or the other. Because the data race recovery is
+      // a last ditch effort, we'll disable it.
+      root.errorRecoveryDisabledLanes = mergeLanes(root.errorRecoveryDisabledLanes, originallyAttemptedLanes); // Mark the current render as suspended and force it to restart. Once
+      // these lanes finish successfully, we'll re-enable the error recovery
+      // mechanism for subsequent updates.
+
+      workInProgressRootInterleavedUpdatedLanes |= originallyAttemptedLanes;
+      return RootSuspendedWithDelay;
+    } // The errors from the failed first attempt have been recovered. Add
+    // them to the collection of recoverable errors. We'll log them in the
+    // commit phase.
+
+
+    const errorsFromSecondAttempt = workInProgressRootRecoverableErrors;
+    workInProgressRootRecoverableErrors = errorsFromFirstAttempt; // The errors from the second attempt should be queued after the errors
+    // from the first attempt, to preserve the causal sequence.
+
+    if (errorsFromSecondAttempt !== null) {
+      queueRecoverableErrors(errorsFromSecondAttempt);
+    }
+  }
+
+  return exitStatus;
+}
+
+function queueRecoverableErrors(errors) {
+  if (workInProgressRootRecoverableErrors === null) {
+    workInProgressRootRecoverableErrors = errors;
+  } else {
+    // $FlowFixMe[method-unbinding]
+    workInProgressRootRecoverableErrors.push.apply(workInProgressRootRecoverableErrors, errors);
+  }
+}
+
+function finishConcurrentRender(root, exitStatus, finishedWork, lanes) {
+  // TODO: The fact that most of these branches are identical suggests that some
+  // of the exit statuses are not best modeled as exit statuses and should be
+  // tracked orthogonally.
+  switch (exitStatus) {
+    case RootInProgress:
+    case RootFatalErrored:
+      {
+        throw Error(formatProdErrorMessage(345));
+      }
+
+    case RootSuspendedWithDelay:
+      {
+        if (includesOnlyTransitions(lanes)) {
+          // This is a transition, so we should exit without committing a
+          // placeholder and without scheduling a timeout. Delay indefinitely
+          // until we receive more data.
+          markRootSuspended(root, lanes, workInProgressDeferredLane);
+          return;
+        } // Commit the placeholder.
+
+
+        break;
+      }
+
+    case RootErrored:
+    case RootSuspended:
+    case RootCompleted:
+      {
+        break;
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(329));
+      }
+  }
+
+  {
+    if (includesOnlyRetries(lanes) && (alwaysThrottleRetries )) {
+      // This render only included retries, no updates. Throttle committing
+      // retries so that we don't show too many loading states too quickly.
+      const msUntilTimeout = globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now(); // Don't bother with a very short suspense time.
+
+      if (msUntilTimeout > 10) {
+        markRootSuspended(root, lanes, workInProgressDeferredLane);
+        const nextLanes = getNextLanes(root, NoLanes);
+
+        if (nextLanes !== NoLanes) {
+          // There's additional work we can do on this root. We might as well
+          // attempt to work on that while we're suspended.
+          return;
+        } // The render is suspended, it hasn't timed out, and there's no
+        // lower priority work to do. Instead of committing the fallback
+        // immediately, wait for more data to arrive.
+        // TODO: Combine retry throttling with Suspensey commits. Right now they
+        // run one after the other.
+
+
+        root.timeoutHandle = scheduleTimeout(commitRootWhenReady.bind(null, root, finishedWork, workInProgressRootRecoverableErrors, workInProgressTransitions, lanes, workInProgressDeferredLane), msUntilTimeout);
+        return;
+      }
+    }
+
+    commitRootWhenReady(root, finishedWork, workInProgressRootRecoverableErrors, workInProgressTransitions, lanes, workInProgressDeferredLane);
+  }
+}
+
+function commitRootWhenReady(root, finishedWork, recoverableErrors, transitions, lanes, spawnedLane) {
+  // TODO: Combine retry throttling with Suspensey commits. Right now they run
+  // one after the other.
+  if (includesOnlyNonUrgentLanes(lanes)) {
+    // Before committing, ask the renderer whether the host tree is ready.
+    // If it's not, we'll wait until it notifies us.
+    startSuspendingCommit(); // This will walk the completed fiber tree and attach listeners to all
+    // the suspensey resources. The renderer is responsible for accumulating
+    // all the load events. This all happens in a single synchronous
+    // transaction, so it track state in its own module scope.
+
+    accumulateSuspenseyCommit(finishedWork); // At the end, ask the renderer if it's ready to commit, or if we should
+    // suspend. If it's not ready, it will return a callback to subscribe to
+    // a ready event.
+
+    const schedulePendingCommit = waitForCommitToBeReady();
+
+    if (schedulePendingCommit !== null) {
+      // NOTE: waitForCommitToBeReady returns a subscribe function so that we
+      // only allocate a function if the commit isn't ready yet. The other
+      // pattern would be to always pass a callback to waitForCommitToBeReady.
+      // Not yet ready to commit. Delay the commit until the renderer notifies
+      // us that it's ready. This will be canceled if we start work on the
+      // root again.
+      root.cancelPendingCommit = schedulePendingCommit(commitRoot.bind(null, root, recoverableErrors, transitions));
+      markRootSuspended(root, lanes, spawnedLane);
+      return;
+    }
+  } // Otherwise, commit immediately.
+
+
+  commitRoot(root, recoverableErrors, transitions, spawnedLane);
+}
+
+function isRenderConsistentWithExternalStores(finishedWork) {
+  // Search the rendered tree for external store reads, and check whether the
+  // stores were mutated in a concurrent event. Intentionally using an iterative
+  // loop instead of recursion so we can exit early.
+  let node = finishedWork;
+
+  while (true) {
+    if (node.flags & StoreConsistency) {
+      const updateQueue = node.updateQueue;
+
+      if (updateQueue !== null) {
+        const checks = updateQueue.stores;
+
+        if (checks !== null) {
+          for (let i = 0; i < checks.length; i++) {
+            const check = checks[i];
+            const getSnapshot = check.getSnapshot;
+            const renderedValue = check.value;
+
+            try {
+              if (!objectIs(getSnapshot(), renderedValue)) {
+                // Found an inconsistent store.
+                return false;
+              }
+            } catch (error) {
+              // If `getSnapshot` throws, return `false`. This will schedule
+              // a re-render, and the error will be rethrown during render.
+              return false;
+            }
+          }
+        }
+      }
+    }
+
+    const child = node.child;
+
+    if (node.subtreeFlags & StoreConsistency && child !== null) {
+      child.return = node;
+      node = child;
+      continue;
+    }
+
+    if (node === finishedWork) {
+      return true;
+    }
+
+    while (node.sibling === null) {
+      if (node.return === null || node.return === finishedWork) {
+        return true;
+      }
+
+      node = node.return;
+    }
+
+    node.sibling.return = node.return;
+    node = node.sibling;
+  } // Flow doesn't know this is unreachable, but eslint does
+  // eslint-disable-next-line no-unreachable
+
+
+  return true;
+}
+
+function markRootSuspended(root, suspendedLanes, spawnedLane) {
+  // When suspending, we should always exclude lanes that were pinged or (more
+  // rarely, since we try to avoid it) updated during the render phase.
+  // TODO: Lol maybe there's a better way to factor this besides this
+  // obnoxiously named function :)
+  suspendedLanes = removeLanes(suspendedLanes, workInProgressRootPingedLanes);
+  suspendedLanes = removeLanes(suspendedLanes, workInProgressRootInterleavedUpdatedLanes);
+  markRootSuspended$1(root, suspendedLanes, spawnedLane);
+} // This is the entry point for synchronous tasks that don't go
+// through Scheduler
+
+
+function performSyncWorkOnRoot(root, lanes) {
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw Error(formatProdErrorMessage(327));
+  }
+
+  const didFlushPassiveEffects = flushPassiveEffects();
+
+  if (didFlushPassiveEffects) {
+    // If passive effects were flushed, exit to the outer work loop in the root
+    // scheduler, so we can recompute the priority.
+    // TODO: We don't actually need this `ensureRootIsScheduled` call because
+    // this path is only reachable if the root is already part of the schedule.
+    // I'm including it only for consistency with the other exit points from
+    // this function. Can address in a subsequent refactor.
+    ensureRootIsScheduled(root);
+    return null;
+  }
+
+  let exitStatus = renderRootSync(root, lanes);
+
+  if (root.tag !== LegacyRoot && exitStatus === RootErrored) {
+    // If something threw an error, try rendering one more time. We'll render
+    // synchronously to block concurrent data mutations, and we'll includes
+    // all pending updates are included. If it still fails after the second
+    // attempt, we'll give up and commit the resulting tree.
+    const originallyAttemptedLanes = lanes;
+    const errorRetryLanes = getLanesToRetrySynchronouslyOnError(root, originallyAttemptedLanes);
+
+    if (errorRetryLanes !== NoLanes) {
+      lanes = errorRetryLanes;
+      exitStatus = recoverFromConcurrentError(root, originallyAttemptedLanes, errorRetryLanes);
+    }
+  }
+
+  if (exitStatus === RootFatalErrored) {
+    const fatalError = workInProgressRootFatalError;
+    prepareFreshStack(root, NoLanes);
+    markRootSuspended(root, lanes, NoLane);
+    ensureRootIsScheduled(root);
+    throw fatalError;
+  }
+
+  if (exitStatus === RootDidNotComplete) {
+    // The render unwound without completing the tree. This happens in special
+    // cases where need to exit the current render without producing a
+    // consistent tree or committing.
+    markRootSuspended(root, lanes, NoLane);
+    ensureRootIsScheduled(root);
+    return null;
+  } // We now have a consistent tree. Because this is a sync render, we
+  // will commit it even if something suspended.
+
+
+  const finishedWork = root.current.alternate;
+  root.finishedWork = finishedWork;
+  root.finishedLanes = lanes;
+  commitRoot(root, workInProgressRootRecoverableErrors, workInProgressTransitions, workInProgressDeferredLane); // Before exiting, make sure there's a callback scheduled for the next
+  // pending level.
+
+  ensureRootIsScheduled(root);
+  return null;
+}
+function flushRoot(root, lanes) {
+  if (lanes !== NoLanes) {
+    upgradePendingLanesToSync(root, lanes);
+    ensureRootIsScheduled(root);
+
+    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
+      resetRenderTimer(); // TODO: For historical reasons this flushes all sync work across all
+      // roots. It shouldn't really matter either way, but we could change this
+      // to only flush the given root.
+
+      flushSyncWorkOnAllRoots();
+    }
+  }
+}
+function getExecutionContext() {
+  return executionContext;
+}
+function batchedUpdates$1(fn, a) {
+  const prevExecutionContext = executionContext;
+  executionContext |= BatchedContext;
+
+  try {
+    return fn(a);
+  } finally {
+    executionContext = prevExecutionContext; // If there were legacy sync updates, flush them at the end of the outer
+    // most batchedUpdates-like method.
+
+    if (executionContext === NoContext && // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.
+    !(false )) {
+      resetRenderTimer();
+      flushSyncWorkOnLegacyRootsOnly();
+    }
+  }
+}
+// Warning, this opts-out of checking the function body.
+// eslint-disable-next-line no-unused-vars
+// eslint-disable-next-line no-redeclare
+// eslint-disable-next-line no-redeclare
+
+function flushSync$1(fn) {
+  // In legacy mode, we flush pending passive effects at the beginning of the
+  // next event, not at the end of the previous one.
+  if (rootWithPendingPassiveEffects !== null && rootWithPendingPassiveEffects.tag === LegacyRoot && (executionContext & (RenderContext | CommitContext)) === NoContext) {
+    flushPassiveEffects();
+  }
+
+  const prevExecutionContext = executionContext;
+  executionContext |= BatchedContext;
+  const prevTransition = ReactCurrentBatchConfig$1.transition;
+  const previousPriority = getCurrentUpdatePriority();
+
+  try {
+    ReactCurrentBatchConfig$1.transition = null;
+    setCurrentUpdatePriority(DiscreteEventPriority);
+
+    if (fn) {
+      return fn();
+    } else {
+      return undefined;
+    }
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+    executionContext = prevExecutionContext; // Flush the immediate callbacks that were scheduled during this batch.
+    // Note that this will happen even if batchedUpdates is higher up
+    // the stack.
+
+    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
+      flushSyncWorkOnAllRoots();
+    }
+  }
+}
+// hidden subtree. The stack logic is managed there because that's the only
+// place that ever modifies it. Which module it lives in doesn't matter for
+// performance because this function will get inlined regardless
+
+function setEntangledRenderLanes(newEntangledRenderLanes) {
+  entangledRenderLanes = newEntangledRenderLanes;
+}
+function getEntangledRenderLanes() {
+  return entangledRenderLanes;
+}
+
+function resetWorkInProgressStack() {
+  if (workInProgress === null) return;
+  let interruptedWork;
+
+  if (workInProgressSuspendedReason === NotSuspended) {
+    // Normal case. Work-in-progress hasn't started yet. Unwind all
+    // its parents.
+    interruptedWork = workInProgress.return;
+  } else {
+    // Work-in-progress is in suspended state. Reset the work loop and unwind
+    // both the suspended fiber and all its parents.
+    resetSuspendedWorkLoopOnUnwind(workInProgress);
+    interruptedWork = workInProgress;
+  }
+
+  while (interruptedWork !== null) {
+    const current = interruptedWork.alternate;
+    unwindInterruptedWork(current, interruptedWork);
+    interruptedWork = interruptedWork.return;
+  }
+
+  workInProgress = null;
+}
+
+function prepareFreshStack(root, lanes) {
+  root.finishedWork = null;
+  root.finishedLanes = NoLanes;
+  const timeoutHandle = root.timeoutHandle;
+
+  if (timeoutHandle !== noTimeout) {
+    // The root previous suspended and scheduled a timeout to commit a fallback
+    // state. Now that we have additional work, cancel the timeout.
+    root.timeoutHandle = noTimeout; // $FlowFixMe[incompatible-call] Complains noTimeout is not a TimeoutID, despite the check above
+
+    cancelTimeout(timeoutHandle);
+  }
+
+  const cancelPendingCommit = root.cancelPendingCommit;
+
+  if (cancelPendingCommit !== null) {
+    root.cancelPendingCommit = null;
+    cancelPendingCommit();
+  }
+
+  resetWorkInProgressStack();
+  workInProgressRoot = root;
+  const rootWorkInProgress = createWorkInProgress(root.current, null);
+  workInProgress = rootWorkInProgress;
+  workInProgressRootRenderLanes = lanes;
+  workInProgressSuspendedReason = NotSuspended;
+  workInProgressThrownValue = null;
+  workInProgressRootDidAttachPingListener = false;
+  workInProgressRootExitStatus = RootInProgress;
+  workInProgressRootFatalError = null;
+  workInProgressRootSkippedLanes = NoLanes;
+  workInProgressRootInterleavedUpdatedLanes = NoLanes;
+  workInProgressRootPingedLanes = NoLanes;
+  workInProgressDeferredLane = NoLane;
+  workInProgressRootConcurrentErrors = null;
+  workInProgressRootRecoverableErrors = null; // Get the lanes that are entangled with whatever we're about to render. We
+  // track these separately so we can distinguish the priority of the render
+  // task from the priority of the lanes it is entangled with. For example, a
+  // transition may not be allowed to finish unless it includes the Sync lane,
+  // which is currently suspended. We should be able to render the Transition
+  // and Sync lane in the same batch, but at Transition priority, because the
+  // Sync lane already suspended.
+
+  entangledRenderLanes = getEntangledLanes(root, lanes);
+  finishQueueingConcurrentUpdates();
+
+  return rootWorkInProgress;
+}
+
+function resetSuspendedWorkLoopOnUnwind(fiber) {
+  // Reset module-level state that was set during the render phase.
+  resetContextDependencies();
+  resetHooksOnUnwind(fiber);
+  resetChildReconcilerOnUnwind();
+}
+
+function handleThrow(root, thrownValue) {
+  // A component threw an exception. Usually this is because it suspended, but
+  // it also includes regular program errors.
+  //
+  // We're either going to unwind the stack to show a Suspense or error
+  // boundary, or we're going to replay the component again. Like after a
+  // promise resolves.
+  //
+  // Until we decide whether we're going to unwind or replay, we should preserve
+  // the current state of the work loop without resetting anything.
+  //
+  // If we do decide to unwind the stack, module-level variables will be reset
+  // in resetSuspendedWorkLoopOnUnwind.
+  // These should be reset immediately because they're only supposed to be set
+  // when React is executing user code.
+  resetHooksAfterThrow();
+  ReactCurrentOwner.current = null;
+
+  if (thrownValue === SuspenseException) {
+    // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown value
+    // to be a thenable, because before `use` existed that was the (unstable)
+    // API for suspending. This implementation detail can change later, once we
+    // deprecate the old API in favor of `use`.
+    thrownValue = getSuspendedThenable();
+    workInProgressSuspendedReason = shouldRemainOnPreviousScreen() && // Check if there are other pending updates that might possibly unblock this
+    // component from suspending. This mirrors the check in
+    // renderDidSuspendDelayIfPossible. We should attempt to unify them somehow.
+    // TODO: Consider unwinding immediately, using the
+    // SuspendedOnHydration mechanism.
+    !includesNonIdleWork(workInProgressRootSkippedLanes) && !includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes) ? // Suspend work loop until data resolves
+    SuspendedOnData : // Don't suspend work loop, except to check if the data has
+    // immediately resolved (i.e. in a microtask). Otherwise, trigger the
+    // nearest Suspense fallback.
+    SuspendedOnImmediate;
+  } else if (thrownValue === SuspenseyCommitException) {
+    thrownValue = getSuspendedThenable();
+    workInProgressSuspendedReason = SuspendedOnInstance;
+  } else if (thrownValue === SelectiveHydrationException) {
+    // An update flowed into a dehydrated boundary. Before we can apply the
+    // update, we need to finish hydrating. Interrupt the work-in-progress
+    // render so we can restart at the hydration lane.
+    //
+    // The ideal implementation would be able to switch contexts without
+    // unwinding the current stack.
+    //
+    // We could name this something more general but as of now it's the only
+    // case where we think this should happen.
+    workInProgressSuspendedReason = SuspendedOnHydration;
+  } else {
+    // This is a regular error.
+    const isWakeable = thrownValue !== null && typeof thrownValue === 'object' && typeof thrownValue.then === 'function';
+    workInProgressSuspendedReason = isWakeable ? // A wakeable object was thrown by a legacy Suspense implementation.
+    // This has slightly different behavior than suspending with `use`.
+    SuspendedOnDeprecatedThrowPromise : // This is a regular error. If something earlier in the component already
+    // suspended, we must clear the thenable state to unblock the work loop.
+    SuspendedOnError;
+  }
+
+  workInProgressThrownValue = thrownValue;
+  const erroredWork = workInProgress;
+
+  if (erroredWork === null) {
+    // This is a fatal error
+    workInProgressRootExitStatus = RootFatalErrored;
+    workInProgressRootFatalError = thrownValue;
+    return;
+  }
+}
+
+function shouldRemainOnPreviousScreen() {
+  // This is asking whether it's better to suspend the transition and remain
+  // on the previous screen, versus showing a fallback as soon as possible. It
+  // takes into account both the priority of render and also whether showing a
+  // fallback would produce a desirable user experience.
+  const handler = getSuspenseHandler();
+
+  if (handler === null) {
+    // There's no Suspense boundary that can provide a fallback. We have no
+    // choice but to remain on the previous screen.
+    // NOTE: We do this even for sync updates, for lack of any better option. In
+    // the future, we may change how we handle this, like by putting the whole
+    // root into a "detached" mode.
+    return true;
+  } // TODO: Once `use` has fully replaced the `throw promise` pattern, we should
+  // be able to remove the equivalent check in finishConcurrentRender, and rely
+  // just on this one.
+
+
+  if (includesOnlyTransitions(workInProgressRootRenderLanes)) {
+    if (getShellBoundary() === null) {
+      // We're rendering inside the "shell" of the app. Activating the nearest
+      // fallback would cause visible content to disappear. It's better to
+      // suspend the transition and remain on the previous screen.
+      return true;
+    } else {
+      // We're rendering content that wasn't part of the previous screen.
+      // Rather than block the transition, it's better to show a fallback as
+      // soon as possible. The appearance of any nested fallbacks will be
+      // throttled to avoid jank.
+      return false;
+    }
+  }
+
+  if (includesOnlyRetries(workInProgressRootRenderLanes) || // In this context, an OffscreenLane counts as a Retry
+  // TODO: It's become increasingly clear that Retries and Offscreen are
+  // deeply connected. They probably can be unified further.
+  includesSomeLane(workInProgressRootRenderLanes, OffscreenLane)) {
+    // During a retry, we can suspend rendering if the nearest Suspense boundary
+    // is the boundary of the "shell", because we're guaranteed not to block
+    // any new content from appearing.
+    //
+    // The reason we must check if this is a retry is because it guarantees
+    // that suspending the work loop won't block an actual update, because
+    // retries don't "update" anything; they fill in fallbacks that were left
+    // behind by a previous transition.
+    return handler === getShellBoundary();
+  } // For all other Lanes besides Transitions and Retries, we should not wait
+  // for the data to load.
+
+
+  return false;
+}
+
+function pushDispatcher(container) {
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = ContextOnlyDispatcher;
+
+  if (prevDispatcher === null) {
+    // The React isomorphic package does not include a default dispatcher.
+    // Instead the first renderer will lazily attach one, in order to give
+    // nicer error messages.
+    return ContextOnlyDispatcher;
+  } else {
+    return prevDispatcher;
+  }
+}
+
+function popDispatcher(prevDispatcher) {
+  ReactCurrentDispatcher.current = prevDispatcher;
+}
+
+function pushCacheDispatcher() {
+  {
+    const prevCacheDispatcher = ReactCurrentCache.current;
+    ReactCurrentCache.current = DefaultCacheDispatcher;
+    return prevCacheDispatcher;
+  }
+}
+
+function popCacheDispatcher(prevCacheDispatcher) {
+  {
+    ReactCurrentCache.current = prevCacheDispatcher;
+  }
+}
+
+function markCommitTimeOfFallback() {
+  globalMostRecentFallbackTime = now();
+}
+function markSkippedUpdateLanes(lane) {
+  workInProgressRootSkippedLanes = mergeLanes(lane, workInProgressRootSkippedLanes);
+}
+function renderDidSuspend() {
+  if (workInProgressRootExitStatus === RootInProgress) {
+    workInProgressRootExitStatus = RootSuspended;
+  }
+}
+function renderDidSuspendDelayIfPossible() {
+  workInProgressRootExitStatus = RootSuspendedWithDelay; // Check if there are updates that we skipped tree that might have unblocked
+  // this render.
+
+  if ((includesNonIdleWork(workInProgressRootSkippedLanes) || includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes)) && workInProgressRoot !== null) {
+    // Mark the current render as suspended so that we switch to working on
+    // the updates that were skipped. Usually we only suspend at the end of
+    // the render phase.
+    // TODO: We should probably always mark the root as suspended immediately
+    // (inside this function), since by suspending at the end of the render
+    // phase introduces a potential mistake where we suspend lanes that were
+    // pinged or updated while we were rendering.
+    // TODO: Consider unwinding immediately, using the
+    // SuspendedOnHydration mechanism.
+    markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes, workInProgressDeferredLane);
+  }
+}
+function renderDidError(error) {
+  if (workInProgressRootExitStatus !== RootSuspendedWithDelay) {
+    workInProgressRootExitStatus = RootErrored;
+  }
+
+  if (workInProgressRootConcurrentErrors === null) {
+    workInProgressRootConcurrentErrors = [error];
+  } else {
+    workInProgressRootConcurrentErrors.push(error);
+  }
+} // Called during render to determine if anything has suspended.
+// Returns false if we're not sure.
+
+function renderHasNotSuspendedYet() {
+  // If something errored or completed, we can't really be sure,
+  // so those are false.
+  return workInProgressRootExitStatus === RootInProgress;
+} // TODO: Over time, this function and renderRootConcurrent have become more
+// and more similar. Not sure it makes sense to maintain forked paths. Consider
+// unifying them again.
+
+function renderRootSync(root, lanes) {
+  const prevExecutionContext = executionContext;
+  executionContext |= RenderContext;
+  const prevDispatcher = pushDispatcher();
+  const prevCacheDispatcher = pushCacheDispatcher(); // If the root or lanes have changed, throw out the existing stack
+  // and prepare a fresh one. Otherwise we'll continue where we left off.
+
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
+
+    workInProgressTransitions = getTransitionsForLanes();
+    prepareFreshStack(root, lanes);
+  }
+
+  let didSuspendInShell = false;
+
+  outer: do {
+    try {
+      if (workInProgressSuspendedReason !== NotSuspended && workInProgress !== null) {
+        // The work loop is suspended. During a synchronous render, we don't
+        // yield to the main thread. Immediately unwind the stack. This will
+        // trigger either a fallback or an error boundary.
+        // TODO: For discrete and "default" updates (anything that's not
+        // flushSync), we want to wait for the microtasks the flush before
+        // unwinding. Will probably implement this using renderRootConcurrent,
+        // or merge renderRootSync and renderRootConcurrent into the same
+        // function and fork the behavior some other way.
+        const unitOfWork = workInProgress;
+        const thrownValue = workInProgressThrownValue;
+
+        switch (workInProgressSuspendedReason) {
+          case SuspendedOnHydration:
+            {
+              // Selective hydration. An update flowed into a dehydrated tree.
+              // Interrupt the current render so the work loop can switch to the
+              // hydration lane.
+              resetWorkInProgressStack();
+              workInProgressRootExitStatus = RootDidNotComplete;
+              break outer;
+            }
+
+          case SuspendedOnImmediate:
+          case SuspendedOnData:
+            {
+              if (!didSuspendInShell && getSuspenseHandler() === null) {
+                didSuspendInShell = true;
+              } // Intentional fallthrough
+
+            }
+
+          default:
+            {
+              // Unwind then continue with the normal work loop.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              break;
+            }
+        }
+      }
+
+      workLoopSync();
+      break;
+    } catch (thrownValue) {
+      handleThrow(root, thrownValue);
+    }
+  } while (true); // Check if something suspended in the shell. We use this to detect an
+  // infinite ping loop caused by an uncached promise.
+  //
+  // Only increment this counter once per synchronous render attempt across the
+  // whole tree. Even if there are many sibling components that suspend, this
+  // counter only gets incremented once.
+
+
+  if (didSuspendInShell) {
+    root.shellSuspendCounter++;
+  }
+
+  resetContextDependencies();
+  executionContext = prevExecutionContext;
+  popDispatcher(prevDispatcher);
+  popCacheDispatcher(prevCacheDispatcher);
+
+  if (workInProgress !== null) {
+    // This is a sync render, so we should have finished the whole tree.
+    throw Error(formatProdErrorMessage(261));
+  }
+
+
+  workInProgressRoot = null;
+  workInProgressRootRenderLanes = NoLanes; // It's safe to process the queue now that the render phase is complete.
+
+  finishQueueingConcurrentUpdates();
+  return workInProgressRootExitStatus;
+} // The work loop is an extremely hot path. Tell Closure not to inline it.
+
+/** @noinline */
+
+
+function workLoopSync() {
+  // Perform work without checking if we need to yield between fiber.
+  while (workInProgress !== null) {
+    performUnitOfWork(workInProgress);
+  }
+}
+
+function renderRootConcurrent(root, lanes) {
+  const prevExecutionContext = executionContext;
+  executionContext |= RenderContext;
+  const prevDispatcher = pushDispatcher();
+  const prevCacheDispatcher = pushCacheDispatcher(); // If the root or lanes have changed, throw out the existing stack
+  // and prepare a fresh one. Otherwise we'll continue where we left off.
+
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
+
+    workInProgressTransitions = getTransitionsForLanes();
+    resetRenderTimer();
+    prepareFreshStack(root, lanes);
+  }
+
+  outer: do {
+    try {
+      if (workInProgressSuspendedReason !== NotSuspended && workInProgress !== null) {
+        // The work loop is suspended. We need to either unwind the stack or
+        // replay the suspended component.
+        const unitOfWork = workInProgress;
+        const thrownValue = workInProgressThrownValue;
+
+        resumeOrUnwind: switch (workInProgressSuspendedReason) {
+          case SuspendedOnError:
+            {
+              // Unwind then continue with the normal work loop.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              break;
+            }
+
+          case SuspendedOnData:
+            {
+              const thenable = thrownValue;
+
+              if (isThenableResolved(thenable)) {
+                // The data resolved. Try rendering the component again.
+                workInProgressSuspendedReason = NotSuspended;
+                workInProgressThrownValue = null;
+                replaySuspendedUnitOfWork(unitOfWork);
+                break;
+              } // The work loop is suspended on data. We should wait for it to
+              // resolve before continuing to render.
+              // TODO: Handle the case where the promise resolves synchronously.
+              // Usually this is handled when we instrument the promise to add a
+              // `status` field, but if the promise already has a status, we won't
+              // have added a listener until right here.
+
+
+              const onResolution = () => {
+                // Check if the root is still suspended on this promise.
+                if (workInProgressSuspendedReason === SuspendedOnData && workInProgressRoot === root) {
+                  // Mark the root as ready to continue rendering.
+                  workInProgressSuspendedReason = SuspendedAndReadyToContinue;
+                } // Ensure the root is scheduled. We should do this even if we're
+                // currently working on a different root, so that we resume
+                // rendering later.
+
+
+                ensureRootIsScheduled(root);
+              };
+
+              thenable.then(onResolution, onResolution);
+              break outer;
+            }
+
+          case SuspendedOnImmediate:
+            {
+              // If this fiber just suspended, it's possible the data is already
+              // cached. Yield to the main thread to give it a chance to ping. If
+              // it does, we can retry immediately without unwinding the stack.
+              workInProgressSuspendedReason = SuspendedAndReadyToContinue;
+              break outer;
+            }
+
+          case SuspendedOnInstance:
+            {
+              workInProgressSuspendedReason = SuspendedOnInstanceAndReadyToContinue;
+              break outer;
+            }
+
+          case SuspendedAndReadyToContinue:
+            {
+              const thenable = thrownValue;
+
+              if (isThenableResolved(thenable)) {
+                // The data resolved. Try rendering the component again.
+                workInProgressSuspendedReason = NotSuspended;
+                workInProgressThrownValue = null;
+                replaySuspendedUnitOfWork(unitOfWork);
+              } else {
+                // Otherwise, unwind then continue with the normal work loop.
+                workInProgressSuspendedReason = NotSuspended;
+                workInProgressThrownValue = null;
+                throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              }
+
+              break;
+            }
+
+          case SuspendedOnInstanceAndReadyToContinue:
+            {
+              switch (workInProgress.tag) {
+                case HostComponent:
+                case HostHoistable:
+                case HostSingleton:
+                  {
+                    // Before unwinding the stack, check one more time if the
+                    // instance is ready. It may have loaded when React yielded to
+                    // the main thread.
+                    // Assigning this to a constant so Flow knows the binding won't
+                    // be mutated by `preloadInstance`.
+                    const hostFiber = workInProgress;
+                    const type = hostFiber.type;
+                    const props = hostFiber.pendingProps;
+                    const isReady = preloadInstance(type, props);
+
+                    if (isReady) {
+                      // The data resolved. Resume the work loop as if nothing
+                      // suspended. Unlike when a user component suspends, we don't
+                      // have to replay anything because the host fiber
+                      // already completed.
+                      workInProgressSuspendedReason = NotSuspended;
+                      workInProgressThrownValue = null;
+                      const sibling = hostFiber.sibling;
+
+                      if (sibling !== null) {
+                        workInProgress = sibling;
+                      } else {
+                        const returnFiber = hostFiber.return;
+
+                        if (returnFiber !== null) {
+                          workInProgress = returnFiber;
+                          completeUnitOfWork(returnFiber);
+                        } else {
+                          workInProgress = null;
+                        }
+                      }
+
+                      break resumeOrUnwind;
+                    }
+
+                    break;
+                  }
+
+                default:
+                  {
+                    // This will fail gracefully but it's not correct, so log a
+                    // warning in dev.
+                    if (false) ;
+
+                    break;
+                  }
+              } // Otherwise, unwind then continue with the normal work loop.
+
+
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              break;
+            }
+
+          case SuspendedOnDeprecatedThrowPromise:
+            {
+              // Suspended by an old implementation that uses the `throw promise`
+              // pattern. The newer replaying behavior can cause subtle issues
+              // like infinite ping loops. So we maintain the old behavior and
+              // always unwind.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              break;
+            }
+
+          case SuspendedOnHydration:
+            {
+              // Selective hydration. An update flowed into a dehydrated tree.
+              // Interrupt the current render so the work loop can switch to the
+              // hydration lane.
+              resetWorkInProgressStack();
+              workInProgressRootExitStatus = RootDidNotComplete;
+              break outer;
+            }
+
+          default:
+            {
+              throw Error(formatProdErrorMessage(462));
+            }
+        }
+      }
+
+      if (false && ReactCurrentActQueue.current !== null) ; else {
+        workLoopConcurrent();
+      }
+
+      break;
+    } catch (thrownValue) {
+      handleThrow(root, thrownValue);
+    }
+  } while (true);
+
+  resetContextDependencies();
+  popDispatcher(prevDispatcher);
+  popCacheDispatcher(prevCacheDispatcher);
+  executionContext = prevExecutionContext;
+
+
+  if (workInProgress !== null) {
+
+    return RootInProgress;
+  } else {
+
+
+    workInProgressRoot = null;
+    workInProgressRootRenderLanes = NoLanes; // It's safe to process the queue now that the render phase is complete.
+
+    finishQueueingConcurrentUpdates(); // Return the final exit status.
+
+    return workInProgressRootExitStatus;
+  }
+}
+/** @noinline */
+
+
+function workLoopConcurrent() {
+  // Perform work until Scheduler asks us to yield
+  while (workInProgress !== null && !shouldYield()) {
+    // $FlowFixMe[incompatible-call] found when upgrading Flow
+    performUnitOfWork(workInProgress);
+  }
+}
+
+function performUnitOfWork(unitOfWork) {
+  // The current, flushed, state of this fiber is the alternate. Ideally
+  // nothing should rely on this, but relying on it here means that we don't
+  // need an additional field on the work in progress.
+  const current = unitOfWork.alternate;
+  let next;
+
+  {
+    next = beginWork(current, unitOfWork, entangledRenderLanes);
+  }
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+
+  if (next === null) {
+    // If this doesn't spawn new work, complete the current work.
+    completeUnitOfWork(unitOfWork);
+  } else {
+    workInProgress = next;
+  }
+
+  ReactCurrentOwner.current = null;
+}
+
+function replaySuspendedUnitOfWork(unitOfWork) {
+  // This is a fork of performUnitOfWork specifcally for replaying a fiber that
+  // just suspended.
+  //
+  const current = unitOfWork.alternate;
+  let next;
+
+  switch (unitOfWork.tag) {
+    case IndeterminateComponent:
+      {
+        // Because it suspended with `use`, we can assume it's a
+        // function component.
+        unitOfWork.tag = FunctionComponent; // Fallthrough to the next branch.
+      }
+
+    case SimpleMemoComponent:
+    case FunctionComponent:
+      {
+        // Resolve `defaultProps`. This logic is copied from `beginWork`.
+        // TODO: Consider moving this switch statement into that module. Also,
+        // could maybe use this as an opportunity to say `use` doesn't work with
+        // `defaultProps` :)
+        const Component = unitOfWork.type;
+        const unresolvedProps = unitOfWork.pendingProps;
+        const resolvedProps = unitOfWork.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        let context;
+
+        {
+          const unmaskedContext = getUnmaskedContext(unitOfWork, Component, true);
+          context = getMaskedContext(unitOfWork, unmaskedContext);
+        }
+
+        next = replayFunctionComponent(current, unitOfWork, resolvedProps, Component, context, workInProgressRootRenderLanes);
+        break;
+      }
+
+    case ForwardRef:
+      {
+        // Resolve `defaultProps`. This logic is copied from `beginWork`.
+        // TODO: Consider moving this switch statement into that module. Also,
+        // could maybe use this as an opportunity to say `use` doesn't work with
+        // `defaultProps` :)
+        const Component = unitOfWork.type.render;
+        const unresolvedProps = unitOfWork.pendingProps;
+        const resolvedProps = unitOfWork.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        next = replayFunctionComponent(current, unitOfWork, resolvedProps, Component, unitOfWork.ref, workInProgressRootRenderLanes);
+        break;
+      }
+
+    case HostComponent:
+      {
+        // Some host components are stateful (that's how we implement form
+        // actions) but we don't bother to reuse the memoized state because it's
+        // not worth the extra code. The main reason to reuse the previous hooks
+        // is to reuse uncached promises, but we happen to know that the only
+        // promises that a host component might suspend on are definitely cached
+        // because they are controlled by us. So don't bother.
+        resetHooksOnUnwind(unitOfWork); // Fallthrough to the next branch.
+      }
+
+    default:
+      {
+        // Other types besides function components are reset completely before
+        // being replayed. Currently this only happens when a Usable type is
+        // reconciled — the reconciler will suspend.
+        //
+        // We reset the fiber back to its original state; however, this isn't
+        // a full "unwind" because we're going to reuse the promises that were
+        // reconciled previously. So it's intentional that we don't call
+        // resetSuspendedWorkLoopOnUnwind here.
+        unwindInterruptedWork(current, unitOfWork);
+        unitOfWork = workInProgress = resetWorkInProgress(unitOfWork, entangledRenderLanes);
+        next = beginWork(current, unitOfWork, entangledRenderLanes);
+        break;
+      }
+  }
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+
+  if (next === null) {
+    // If this doesn't spawn new work, complete the current work.
+    completeUnitOfWork(unitOfWork);
+  } else {
+    workInProgress = next;
+  }
+
+  ReactCurrentOwner.current = null;
+}
+
+function throwAndUnwindWorkLoop(unitOfWork, thrownValue) {
+  // This is a fork of performUnitOfWork specifcally for unwinding a fiber
+  // that threw an exception.
+  //
+  // Return to the normal work loop. This will unwind the stack, and potentially
+  // result in showing a fallback.
+  resetSuspendedWorkLoopOnUnwind(unitOfWork);
+  const returnFiber = unitOfWork.return;
+
+  if (returnFiber === null || workInProgressRoot === null) {
+    // Expected to be working on a non-root fiber. This is a fatal error
+    // because there's no ancestor that can handle it; the root is
+    // supposed to capture all errors that weren't caught by an error
+    // boundary.
+    workInProgressRootExitStatus = RootFatalErrored;
+    workInProgressRootFatalError = thrownValue; // Set `workInProgress` to null. This represents advancing to the next
+    // sibling, or the parent if there are no siblings. But since the root
+    // has no siblings nor a parent, we set it to null. Usually this is
+    // handled by `completeUnitOfWork` or `unwindWork`, but since we're
+    // intentionally not calling those, we need set it here.
+    // TODO: Consider calling `unwindWork` to pop the contexts.
+
+    workInProgress = null;
+    return;
+  }
+
+  try {
+    // Find and mark the nearest Suspense or error boundary that can handle
+    // this "exception".
+    throwException(workInProgressRoot, returnFiber, unitOfWork, thrownValue, workInProgressRootRenderLanes);
+  } catch (error) {
+    // We had trouble processing the error. An example of this happening is
+    // when accessing the `componentDidCatch` property of an error boundary
+    // throws an error. A weird edge case. There's a regression test for this.
+    // To prevent an infinite loop, bubble the error up to the next parent.
+    workInProgress = returnFiber;
+    throw error;
+  }
+
+  if (unitOfWork.flags & Incomplete) {
+    // Unwind the stack until we reach the nearest boundary.
+    unwindUnitOfWork(unitOfWork);
+  } else {
+    // Although the fiber suspended, we're intentionally going to commit it in
+    // an inconsistent state. We can do this safely in cases where we know the
+    // inconsistent tree will be hidden.
+    //
+    // This currently only applies to Legacy Suspense implementation, but we may
+    // port a version of this to concurrent roots, too, when performing a
+    // synchronous render. Because that will allow us to mutate the tree as we
+    // go instead of buffering mutations until the end. Though it's unclear if
+    // this particular path is how that would be implemented.
+    completeUnitOfWork(unitOfWork);
+  }
+}
+
+function completeUnitOfWork(unitOfWork) {
+  // Attempt to complete the current unit of work, then move to the next
+  // sibling. If there are no more siblings, return to the parent fiber.
+  let completedWork = unitOfWork;
+
+  do {
+    // nothing should rely on this, but relying on it here means that we don't
+    // need an additional field on the work in progress.
+
+
+    const current = completedWork.alternate;
+    const returnFiber = completedWork.return;
+    let next;
+
+    {
+      next = completeWork(current, completedWork, entangledRenderLanes);
+    }
+
+    if (next !== null) {
+      // Completing this fiber spawned new work. Work on that next.
+      workInProgress = next;
+      return;
+    }
+
+    const siblingFiber = completedWork.sibling;
+
+    if (siblingFiber !== null) {
+      // If there is more work to do in this returnFiber, do that next.
+      workInProgress = siblingFiber;
+      return;
+    } // Otherwise, return to the parent
+    // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+    completedWork = returnFiber; // Update the next thing we're working on in case something throws.
+
+    workInProgress = completedWork;
+  } while (completedWork !== null); // We've reached the root.
+
+
+  if (workInProgressRootExitStatus === RootInProgress) {
+    workInProgressRootExitStatus = RootCompleted;
+  }
+}
+
+function unwindUnitOfWork(unitOfWork) {
+  let incompleteWork = unitOfWork;
+
+  do {
+    // The current, flushed, state of this fiber is the alternate. Ideally
+    // nothing should rely on this, but relying on it here means that we don't
+    // need an additional field on the work in progress.
+    const current = incompleteWork.alternate; // This fiber did not complete because something threw. Pop values off
+    // the stack without entering the complete phase. If this is a boundary,
+    // capture values if possible.
+
+    const next = unwindWork(current, incompleteWork); // Because this fiber did not complete, don't reset its lanes.
+
+    if (next !== null) {
+      // Found a boundary that can handle this exception. Re-renter the
+      // begin phase. This branch will return us to the normal work loop.
+      //
+      // Since we're restarting, remove anything that is not a host effect
+      // from the effect tag.
+      next.flags &= HostEffectMask;
+      workInProgress = next;
+      return;
+    } // Keep unwinding until we reach either a boundary or the root.
+    // of the node being unwound, we should be able to reset node itself as we
+    // unwind the stack. Saves an additional null check.
+
+
+    const returnFiber = incompleteWork.return;
+
+    if (returnFiber !== null) {
+      // Mark the parent fiber as incomplete and clear its subtree flags.
+      // TODO: Once we stop prerendering siblings, we may be able to get rid of
+      // the Incomplete flag because unwinding to the nearest boundary will
+      // happen synchronously.
+      returnFiber.flags |= Incomplete;
+      returnFiber.subtreeFlags = NoFlags$1;
+      returnFiber.deletions = null;
+    } // NOTE: If we re-enable sibling prerendering in some cases, here we
+    // would switch to the normal completion path: check if a sibling
+    // exists, and if so, begin work on it.
+    // Otherwise, return to the parent
+    // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+    incompleteWork = returnFiber; // Update the next thing we're working on in case something throws.
+
+    workInProgress = incompleteWork;
+  } while (incompleteWork !== null); // We've unwound all the way to the root.
+
+
+  workInProgressRootExitStatus = RootDidNotComplete;
+  workInProgress = null;
+}
+
+function commitRoot(root, recoverableErrors, transitions, spawnedLane) {
+  // TODO: This no longer makes any sense. We already wrap the mutation and
+  // layout phases. Should be able to remove.
+  const previousUpdateLanePriority = getCurrentUpdatePriority();
+  const prevTransition = ReactCurrentBatchConfig$1.transition;
+
+  try {
+    ReactCurrentBatchConfig$1.transition = null;
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    commitRootImpl(root, recoverableErrors, transitions, previousUpdateLanePriority, spawnedLane);
+  } finally {
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+    setCurrentUpdatePriority(previousUpdateLanePriority);
+  }
+
+  return null;
+}
+
+function commitRootImpl(root, recoverableErrors, transitions, renderPriorityLevel, spawnedLane) {
+  do {
+    // `flushPassiveEffects` will call `flushSyncUpdateQueue` at the end, which
+    // means `flushPassiveEffects` will sometimes result in additional
+    // passive effects. So we need to keep flushing in a loop until there are
+    // no more pending effects.
+    // TODO: Might be better if `flushPassiveEffects` did not automatically
+    // flush synchronous work at the end, to avoid factoring hazards like this.
+    flushPassiveEffects();
+  } while (rootWithPendingPassiveEffects !== null);
+
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw Error(formatProdErrorMessage(327));
+  }
+
+  const finishedWork = root.finishedWork;
+  const lanes = root.finishedLanes;
+
+  if (finishedWork === null) {
+
+    return null;
+  }
+
+  root.finishedWork = null;
+  root.finishedLanes = NoLanes;
+
+  if (finishedWork === root.current) {
+    throw Error(formatProdErrorMessage(177));
+  } // commitRoot never returns a continuation; it always finishes synchronously.
+  // So we can clear these now to allow a new callback to be scheduled.
+
+
+  root.callbackNode = null;
+  root.callbackPriority = NoLane;
+  root.cancelPendingCommit = null; // Check which lanes no longer have any work scheduled on them, and mark
+  // those as finished.
+
+  let remainingLanes = mergeLanes(finishedWork.lanes, finishedWork.childLanes); // Make sure to account for lanes that were updated by a concurrent event
+  // during the render phase; don't mark them as finished.
+
+  const concurrentlyUpdatedLanes = getConcurrentlyUpdatedLanes();
+  remainingLanes = mergeLanes(remainingLanes, concurrentlyUpdatedLanes);
+  markRootFinished(root, remainingLanes, spawnedLane);
+
+  if (root === workInProgressRoot) {
+    // We can reset these now that they are finished.
+    workInProgressRoot = null;
+    workInProgress = null;
+    workInProgressRootRenderLanes = NoLanes;
+  } // If there are pending passive effects, schedule a callback to process them.
+  // Do this as early as possible, so it is queued before anything else that
+  // might get scheduled in the commit phase. (See #16714.)
+  // TODO: Delete all other places that schedule the passive effect callback
+  // They're redundant.
+
+
+  if ((finishedWork.subtreeFlags & PassiveMask) !== NoFlags$1 || (finishedWork.flags & PassiveMask) !== NoFlags$1) {
+    if (!rootDoesHavePassiveEffects) {
+      rootDoesHavePassiveEffects = true;
+      pendingPassiveEffectsRemainingLanes = remainingLanes; // workInProgressTransitions might be overwritten, so we want
+      // to store it in pendingPassiveTransitions until they get processed
+      // We need to pass this through as an argument to commitRoot
+      // because workInProgressTransitions might have changed between
+      // the previous render and commit if we throttle the commit
+      // with setTimeout
+
+      pendingPassiveTransitions = transitions;
+      scheduleCallback(NormalPriority$1, () => {
+        flushPassiveEffects(); // This render triggered passive effects: release the root cache pool
+        // *after* passive effects fire to avoid freeing a cache pool that may
+        // be referenced by a node in the tree (HostRoot, Cache boundary etc)
+
+        return null;
+      });
+    }
+  } // Check if there are any effects in the whole tree.
+  // TODO: This is left over from the effect list implementation, where we had
+  // to check for the existence of `firstEffect` to satisfy Flow. I think the
+  // only other reason this optimization exists is because it affects profiling.
+  // Reconsider whether this is necessary.
+
+
+  const subtreeHasEffects = (finishedWork.subtreeFlags & (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !== NoFlags$1;
+  const rootHasEffect = (finishedWork.flags & (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !== NoFlags$1;
+
+  if (subtreeHasEffects || rootHasEffect) {
+    const prevTransition = ReactCurrentBatchConfig$1.transition;
+    ReactCurrentBatchConfig$1.transition = null;
+    const previousPriority = getCurrentUpdatePriority();
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    const prevExecutionContext = executionContext;
+    executionContext |= CommitContext; // Reset this to null before calling lifecycles
+
+    ReactCurrentOwner.current = null; // The commit phase is broken into several sub-phases. We do a separate pass
+    // of the effect list for each phase: all mutation effects come before all
+    // layout effects, and so on.
+    // The first phase a "before mutation" phase. We use this phase to read the
+    // state of the host tree right before we mutate it. This is where
+    // getSnapshotBeforeUpdate is called.
+
+    commitBeforeMutationEffects(root, finishedWork);
+
+
+    commitMutationEffects(root, finishedWork);
+
+    resetAfterCommit(); // The work-in-progress tree is now the current tree. This must come after
+    // the mutation phase, so that the previous tree is still current during
+    // componentWillUnmount, but before the layout phase, so that the finished
+    // work is current during componentDidMount/Update.
+
+    root.current = finishedWork; // The next phase is the layout phase, where we call effects that read
+
+    commitLayoutEffects(finishedWork, root);
+    // opportunity to paint.
+
+
+    requestPaint();
+    executionContext = prevExecutionContext; // Reset the priority to the previous non-sync value.
+
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+  } else {
+    // No effects.
+    root.current = finishedWork; // Measure these anyway so the flamegraph explicitly shows that there were
+  }
+
+  if (rootDoesHavePassiveEffects) {
+    // This commit has passive effects. Stash a reference to them. But don't
+    // schedule a callback until after flushing layout work.
+    rootDoesHavePassiveEffects = false;
+    rootWithPendingPassiveEffects = root;
+    pendingPassiveEffectsLanes = lanes;
+  } else {
+    // There were no passive effects, so we can immediately release the cache
+    // pool for this render.
+    releaseRootPooledCache(root, remainingLanes);
+  } // Read this again, since an effect might have updated it
+
+
+  remainingLanes = root.pendingLanes; // Check if there's remaining work on this root
+  // TODO: This is part of the `componentDidCatch` implementation. Its purpose
+  // is to detect whether something might have called setState inside
+  // `componentDidCatch`. The mechanism is known to be flawed because `setState`
+  // inside `componentDidCatch` is itself flawed — that's why we recommend
+  // `getDerivedStateFromError` instead. However, it could be improved by
+  // checking if remainingLanes includes Sync work, instead of whether there's
+  // any work remaining at all (which would also include stuff like Suspense
+  // retries or transitions). It's been like this for a while, though, so fixing
+  // it probably isn't that urgent.
+
+  if (remainingLanes === NoLanes) {
+    // If there's no remaining work, we can clear the set of already failed
+    // error boundaries.
+    legacyErrorBoundariesThatAlreadyFailed = null;
+  }
+
+  onCommitRoot(finishedWork.stateNode, renderPriorityLevel);
+  // additional work on this root is scheduled.
+
+
+  ensureRootIsScheduled(root);
+
+  if (recoverableErrors !== null) {
+    // There were errors during this render, but recovered from them without
+    // needing to surface it to the UI. We log them here.
+    const onRecoverableError = root.onRecoverableError;
+
+    for (let i = 0; i < recoverableErrors.length; i++) {
+      const recoverableError = recoverableErrors[i];
+      const errorInfo = makeErrorInfo(recoverableError.digest, recoverableError.stack);
+      onRecoverableError(recoverableError.value, errorInfo);
+    }
+  }
+
+  if (hasUncaughtError) {
+    hasUncaughtError = false;
+    const error = firstUncaughtError;
+    firstUncaughtError = null;
+    throw error;
+  } // If the passive effects are the result of a discrete render, flush them
+  // synchronously at the end of the current task so that the result is
+  // immediately observable. Otherwise, we assume that they are not
+  // order-dependent and do not need to be observed by external systems, so we
+  // can wait until after paint.
+  // TODO: We can optimize this by not scheduling the callback earlier. Since we
+  // currently schedule the callback in multiple places, will wait until those
+  // are consolidated.
+
+
+  if (includesSyncLane(pendingPassiveEffectsLanes) && root.tag !== LegacyRoot) {
+    flushPassiveEffects();
+  } // Read this again, since a passive effect might have updated it
+
+
+  remainingLanes = root.pendingLanes; // Check if this render scheduled a cascading synchronous update. This is a
+  // heurstic to detect infinite update loops. We are intentionally excluding
+  // hydration lanes in this check, because render triggered by selective
+  // hydration is conceptually not an update.
+
+  if ( // Was the finished render the result of an update (not hydration)?
+  includesSomeLane(lanes, UpdateLanes) && // Did it schedule a sync update?
+  includesSomeLane(remainingLanes, SyncUpdateLanes)) {
+    // finishing. If there are too many, it indicates an infinite update loop.
+
+
+    if (root === rootWithNestedUpdates) {
+      nestedUpdateCount++;
+    } else {
+      nestedUpdateCount = 0;
+      rootWithNestedUpdates = root;
+    }
+  } else {
+    nestedUpdateCount = 0;
+  } // If layout work was scheduled, flush it now.
+
+
+  flushSyncWorkOnAllRoots();
+
+  return null;
+}
+
+function makeErrorInfo(digest, componentStack) {
+  {
+    return {
+      digest,
+      componentStack
+    };
+  }
+}
+
+function releaseRootPooledCache(root, remainingLanes) {
+  {
+    const pooledCacheLanes = root.pooledCacheLanes &= remainingLanes;
+
+    if (pooledCacheLanes === NoLanes) {
+      // None of the remaining work relies on the cache pool. Clear it so
+      // subsequent requests get a new cache
+      const pooledCache = root.pooledCache;
+
+      if (pooledCache != null) {
+        root.pooledCache = null;
+        releaseCache(pooledCache);
+      }
+    }
+  }
+}
+
+function flushPassiveEffects() {
+  // Returns whether passive effects were flushed.
+  // TODO: Combine this check with the one in flushPassiveEFfectsImpl. We should
+  // probably just combine the two functions. I believe they were only separate
+  // in the first place because we used to wrap it with
+  // `Scheduler.runWithPriority`, which accepts a function. But now we track the
+  // priority within React itself, so we can mutate the variable directly.
+  if (rootWithPendingPassiveEffects !== null) {
+    // Cache the root since rootWithPendingPassiveEffects is cleared in
+    // flushPassiveEffectsImpl
+    const root = rootWithPendingPassiveEffects; // Cache and clear the remaining lanes flag; it must be reset since this
+    // method can be called from various places, not always from commitRoot
+    // where the remaining lanes are known
+
+    const remainingLanes = pendingPassiveEffectsRemainingLanes;
+    pendingPassiveEffectsRemainingLanes = NoLanes;
+    const renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
+    const priority = lowerEventPriority(DefaultEventPriority, renderPriority);
+    const prevTransition = ReactCurrentBatchConfig$1.transition;
+    const previousPriority = getCurrentUpdatePriority();
+
+    try {
+      ReactCurrentBatchConfig$1.transition = null;
+      setCurrentUpdatePriority(priority);
+      return flushPassiveEffectsImpl();
+    } finally {
+      setCurrentUpdatePriority(previousPriority);
+      ReactCurrentBatchConfig$1.transition = prevTransition; // Once passive effects have run for the tree - giving components a
+      // chance to retain cache instances they use - release the pooled
+      // cache at the root (if there is one)
+
+      releaseRootPooledCache(root, remainingLanes);
+    }
+  }
+
+  return false;
+}
+
+function flushPassiveEffectsImpl() {
+  if (rootWithPendingPassiveEffects === null) {
+    return false;
+  } // Cache and clear the transitions flag
+
+
+  const transitions = pendingPassiveTransitions;
+  pendingPassiveTransitions = null;
+  const root = rootWithPendingPassiveEffects;
+  const lanes = pendingPassiveEffectsLanes;
+  rootWithPendingPassiveEffects = null; // TODO: This is sometimes out of sync with rootWithPendingPassiveEffects.
+  // Figure out why and fix it. It's not causing any known issues (probably
+  // because it's only used for profiling), but it's a refactor hazard.
+
+  pendingPassiveEffectsLanes = NoLanes;
+
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw Error(formatProdErrorMessage(331));
+  }
+
+  const prevExecutionContext = executionContext;
+  executionContext |= CommitContext;
+  commitPassiveUnmountEffects(root.current);
+  commitPassiveMountEffects(root, root.current, lanes, transitions); // TODO: Move to commitPassiveMountEffects
+
+  executionContext = prevExecutionContext;
+  flushSyncWorkOnAllRoots();
+
+
+  onPostCommitRoot(root);
+
+  return true;
+}
+
+function isAlreadyFailedLegacyErrorBoundary(instance) {
+  return legacyErrorBoundariesThatAlreadyFailed !== null && legacyErrorBoundariesThatAlreadyFailed.has(instance);
+}
+function markLegacyErrorBoundaryAsFailed(instance) {
+  if (legacyErrorBoundariesThatAlreadyFailed === null) {
+    legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);
+  } else {
+    legacyErrorBoundariesThatAlreadyFailed.add(instance);
+  }
+}
+
+function prepareToThrowUncaughtError(error) {
+  if (!hasUncaughtError) {
+    hasUncaughtError = true;
+    firstUncaughtError = error;
+  }
+}
+
+const onUncaughtError = prepareToThrowUncaughtError;
+
+function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
+  const errorInfo = createCapturedValueAtFiber(error, sourceFiber);
+  const update = createRootErrorUpdate(rootFiber, errorInfo, SyncLane);
+  const root = enqueueUpdate(rootFiber, update, SyncLane);
+
+  if (root !== null) {
+    markRootUpdated(root, SyncLane);
+    ensureRootIsScheduled(root);
+  }
+}
+
+function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
+
+  if (sourceFiber.tag === HostRoot) {
+    // Error was thrown at the root. There is no parent, so the root
+    // itself should capture it.
+    captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
+    return;
+  }
+
+  let fiber = nearestMountedAncestor;
+
+  while (fiber !== null) {
+    if (fiber.tag === HostRoot) {
+      captureCommitPhaseErrorOnRoot(fiber, sourceFiber, error);
+      return;
+    } else if (fiber.tag === ClassComponent) {
+      const ctor = fiber.type;
+      const instance = fiber.stateNode;
+
+      if (typeof ctor.getDerivedStateFromError === 'function' || typeof instance.componentDidCatch === 'function' && !isAlreadyFailedLegacyErrorBoundary(instance)) {
+        const errorInfo = createCapturedValueAtFiber(error, sourceFiber);
+        const update = createClassErrorUpdate(fiber, errorInfo, SyncLane);
+        const root = enqueueUpdate(fiber, update, SyncLane);
+
+        if (root !== null) {
+          markRootUpdated(root, SyncLane);
+          ensureRootIsScheduled(root);
+        }
+
+        return;
+      }
+    }
+
+    fiber = fiber.return;
+  }
+}
+function attachPingListener(root, wakeable, lanes) {
+  // Attach a ping listener
+  //
+  // The data might resolve before we have a chance to commit the fallback. Or,
+  // in the case of a refresh, we'll never commit a fallback. So we need to
+  // attach a listener now. When it resolves ("pings"), we can decide whether to
+  // try rendering the tree again.
+  //
+  // Only attach a listener if one does not already exist for the lanes
+  // we're currently rendering (which acts like a "thread ID" here).
+  //
+  // We only need to do this in concurrent mode. Legacy Suspense always
+  // commits fallbacks synchronously, so there are no pings.
+  let pingCache = root.pingCache;
+  let threadIDs;
+
+  if (pingCache === null) {
+    pingCache = root.pingCache = new PossiblyWeakMap();
+    threadIDs = new Set();
+    pingCache.set(wakeable, threadIDs);
+  } else {
+    threadIDs = pingCache.get(wakeable);
+
+    if (threadIDs === undefined) {
+      threadIDs = new Set();
+      pingCache.set(wakeable, threadIDs);
+    }
+  }
+
+  if (!threadIDs.has(lanes)) {
+    workInProgressRootDidAttachPingListener = true; // Memoize using the thread ID to prevent redundant listeners.
+
+    threadIDs.add(lanes);
+    const ping = pingSuspendedRoot.bind(null, root, wakeable, lanes);
+
+    wakeable.then(ping, ping);
+  }
+}
+
+function pingSuspendedRoot(root, wakeable, pingedLanes) {
+  const pingCache = root.pingCache;
+
+  if (pingCache !== null) {
+    // The wakeable resolved, so we no longer need to memoize, because it will
+    // never be thrown again.
+    pingCache.delete(wakeable);
+  }
+
+  markRootPinged(root, pingedLanes);
+
+  if (workInProgressRoot === root && isSubsetOfLanes(workInProgressRootRenderLanes, pingedLanes)) {
+    // Received a ping at the same priority level at which we're currently
+    // rendering. We might want to restart this render. This should mirror
+    // the logic of whether or not a root suspends once it completes.
+    // TODO: If we're rendering sync either due to Sync, Batched or expired,
+    // we should probably never restart.
+    // If we're suspended with delay, or if it's a retry, we'll always suspend
+    // so we can always restart.
+    if (workInProgressRootExitStatus === RootSuspendedWithDelay || workInProgressRootExitStatus === RootSuspended && includesOnlyRetries(workInProgressRootRenderLanes) && now() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS) {
+      // Force a restart from the root by unwinding the stack. Unless this is
+      // being called from the render phase, because that would cause a crash.
+      if ((executionContext & RenderContext) === NoContext) {
+        prepareFreshStack(root, NoLanes);
+      }
+    } else {
+      // Even though we can't restart right now, we might get an
+      // opportunity later. So we mark this render as having a ping.
+      workInProgressRootPingedLanes = mergeLanes(workInProgressRootPingedLanes, pingedLanes);
+    }
+  }
+
+  ensureRootIsScheduled(root);
+}
+
+function retryTimedOutBoundary(boundaryFiber, retryLane) {
+  // The boundary fiber (a Suspense component or SuspenseList component)
+  // previously was rendered in its fallback state. One of the promises that
+  // suspended it has resolved, which means at least part of the tree was
+  // likely unblocked. Try rendering again, at a new lanes.
+  if (retryLane === NoLane) {
+    // TODO: Assign this to `suspenseState.retryLane`? to avoid
+    // unnecessary entanglement?
+    retryLane = requestRetryLane(boundaryFiber);
+  } // TODO: Special case idle priority?
+
+
+  const root = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
+
+  if (root !== null) {
+    markRootUpdated(root, retryLane);
+    ensureRootIsScheduled(root);
+  }
+}
+
+function retryDehydratedSuspenseBoundary(boundaryFiber) {
+  const suspenseState = boundaryFiber.memoizedState;
+  let retryLane = NoLane;
+
+  if (suspenseState !== null) {
+    retryLane = suspenseState.retryLane;
+  }
+
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+}
+function resolveRetryWakeable(boundaryFiber, wakeable) {
+  let retryLane = NoLane; // Default
+
+  let retryCache;
+
+  switch (boundaryFiber.tag) {
+    case SuspenseComponent:
+      retryCache = boundaryFiber.stateNode;
+      const suspenseState = boundaryFiber.memoizedState;
+
+      if (suspenseState !== null) {
+        retryLane = suspenseState.retryLane;
+      }
+
+      break;
+
+    case SuspenseListComponent:
+      retryCache = boundaryFiber.stateNode;
+      break;
+
+    case OffscreenComponent:
+      {
+        const instance = boundaryFiber.stateNode;
+        retryCache = instance._retryCache;
+        break;
+      }
+
+    default:
+      throw Error(formatProdErrorMessage(314));
+  }
+
+  if (retryCache !== null) {
+    // The wakeable resolved, so we no longer need to memoize, because it will
+    // never be thrown again.
+    retryCache.delete(wakeable);
+  }
+
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+}
+function throwIfInfiniteUpdateLoopDetected() {
+  if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
+    nestedUpdateCount = 0;
+    rootWithNestedUpdates = null;
+    throw Error(formatProdErrorMessage(185));
+  }
+}
+let beginWork;
+
+{
+  beginWork = beginWork$1;
+}
+
+function scheduleCallback(priorityLevel, callback) {
+  {
+    // In production, always call Scheduler. This function will be stripped out.
+    return scheduleCallback$3(priorityLevel, callback);
+  }
+}
+
+function FiberNode(tag, pendingProps, key, mode) {
+  // Instance
+  this.tag = tag;
+  this.key = key;
+  this.elementType = null;
+  this.type = null;
+  this.stateNode = null; // Fiber
+
+  this.return = null;
+  this.child = null;
+  this.sibling = null;
+  this.index = 0;
+  this.ref = null;
+  this.refCleanup = null;
+  this.pendingProps = pendingProps;
+  this.memoizedProps = null;
+  this.updateQueue = null;
+  this.memoizedState = null;
+  this.dependencies = null;
+  this.mode = mode; // Effects
+
+  this.flags = NoFlags$1;
+  this.subtreeFlags = NoFlags$1;
+  this.deletions = null;
+  this.lanes = NoLanes;
+  this.childLanes = NoLanes;
+  this.alternate = null;
+} // This is a constructor function, rather than a POJO constructor, still
+// please ensure we do the following:
+// 1) Nobody should add any instance methods on this. Instance methods can be
+//    more difficult to predict when they get optimized and they are almost
+//    never inlined properly in static compilers.
+// 2) Nobody should rely on `instanceof Fiber` for type testing. We should
+//    always know when it is a fiber.
+// 3) We might want to experiment with using numeric keys since they are easier
+//    to optimize in a non-JIT environment.
+// 4) We can easily go from a constructor to a createFiber object literal if that
+//    is faster.
+// 5) It should be easy to port this to a C struct and keep a C implementation
+//    compatible.
+
+
+function createFiber(tag, pendingProps, key, mode) {
+  // $FlowFixMe[invalid-constructor]: the shapes are exact here but Flow doesn't like constructors
+  return new FiberNode(tag, pendingProps, key, mode);
+}
+
+function shouldConstruct(Component) {
+  const prototype = Component.prototype;
+  return !!(prototype && prototype.isReactComponent);
+}
+
+function isSimpleFunctionComponent(type) {
+  return typeof type === 'function' && !shouldConstruct(type) && type.defaultProps === undefined;
+}
+function resolveLazyComponentTag(Component) {
+  if (typeof Component === 'function') {
+    return shouldConstruct(Component) ? ClassComponent : FunctionComponent;
+  } else if (Component !== undefined && Component !== null) {
+    const $$typeof = Component.$$typeof;
+
+    if ($$typeof === REACT_FORWARD_REF_TYPE) {
+      return ForwardRef;
+    }
+
+    if ($$typeof === REACT_MEMO_TYPE) {
+      return MemoComponent;
+    }
+  }
+
+  return IndeterminateComponent;
+} // This is used to create an alternate fiber to do work on.
+
+function createWorkInProgress(current, pendingProps) {
+  let workInProgress = current.alternate;
+
+  if (workInProgress === null) {
+    // We use a double buffering pooling technique because we know that we'll
+    // only ever need at most two versions of a tree. We pool the "other" unused
+    // node that we're free to reuse. This is lazily created to avoid allocating
+    // extra objects for things that are never updated. It also allow us to
+    // reclaim the extra memory if needed.
+    workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode);
+    workInProgress.elementType = current.elementType;
+    workInProgress.type = current.type;
+    workInProgress.stateNode = current.stateNode;
+
+    workInProgress.alternate = current;
+    current.alternate = workInProgress;
+  } else {
+    workInProgress.pendingProps = pendingProps; // Needed because Blocks store data on type.
+
+    workInProgress.type = current.type; // We already have an alternate.
+    // Reset the effect tag.
+
+    workInProgress.flags = NoFlags$1; // The effects are no longer valid.
+
+    workInProgress.subtreeFlags = NoFlags$1;
+    workInProgress.deletions = null;
+  } // Reset all effects except static ones.
+  // Static effects are not specific to a render.
+
+
+  workInProgress.flags = current.flags & StaticMask;
+  workInProgress.childLanes = current.childLanes;
+  workInProgress.lanes = current.lanes;
+  workInProgress.child = current.child;
+  workInProgress.memoizedProps = current.memoizedProps;
+  workInProgress.memoizedState = current.memoizedState;
+  workInProgress.updateQueue = current.updateQueue; // Clone the dependencies object. This is mutated during the render phase, so
+  // it cannot be shared with the current fiber.
+
+  const currentDependencies = current.dependencies;
+  workInProgress.dependencies = currentDependencies === null ? null : {
+    lanes: currentDependencies.lanes,
+    firstContext: currentDependencies.firstContext
+  }; // These will be overridden during the parent's reconciliation
+
+  workInProgress.sibling = current.sibling;
+  workInProgress.index = current.index;
+  workInProgress.ref = current.ref;
+  workInProgress.refCleanup = current.refCleanup;
+
+  return workInProgress;
+} // Used to reuse a Fiber for a second pass.
+
+function resetWorkInProgress(workInProgress, renderLanes) {
+  // This resets the Fiber to what createFiber or createWorkInProgress would
+  // have set the values to before during the first pass. Ideally this wouldn't
+  // be necessary but unfortunately many code paths reads from the workInProgress
+  // when they should be reading from current and writing to workInProgress.
+  // We assume pendingProps, index, key, ref, return are still untouched to
+  // avoid doing another reconciliation.
+  // Reset the effect flags but keep any Placement tags, since that's something
+  // that child fiber is setting, not the reconciliation.
+  workInProgress.flags &= StaticMask | Placement; // The effects are no longer valid.
+
+  const current = workInProgress.alternate;
+
+  if (current === null) {
+    // Reset to createFiber's initial values.
+    workInProgress.childLanes = NoLanes;
+    workInProgress.lanes = renderLanes;
+    workInProgress.child = null;
+    workInProgress.subtreeFlags = NoFlags$1;
+    workInProgress.memoizedProps = null;
+    workInProgress.memoizedState = null;
+    workInProgress.updateQueue = null;
+    workInProgress.dependencies = null;
+    workInProgress.stateNode = null;
+  } else {
+    // Reset to the cloned values that createWorkInProgress would've.
+    workInProgress.childLanes = current.childLanes;
+    workInProgress.lanes = current.lanes;
+    workInProgress.child = current.child;
+    workInProgress.subtreeFlags = NoFlags$1;
+    workInProgress.deletions = null;
+    workInProgress.memoizedProps = current.memoizedProps;
+    workInProgress.memoizedState = current.memoizedState;
+    workInProgress.updateQueue = current.updateQueue; // Needed because Blocks store data on type.
+
+    workInProgress.type = current.type; // Clone the dependencies object. This is mutated during the render phase, so
+    // it cannot be shared with the current fiber.
+
+    const currentDependencies = current.dependencies;
+    workInProgress.dependencies = currentDependencies === null ? null : {
+      lanes: currentDependencies.lanes,
+      firstContext: currentDependencies.firstContext
+    };
+  }
+
+  return workInProgress;
+}
+function createHostRootFiber(tag, isStrictMode, concurrentUpdatesByDefaultOverride) {
+  let mode;
+
+  if (tag === ConcurrentRoot) {
+    mode = ConcurrentMode;
+
+    if (isStrictMode === true || createRootStrictEffectsByDefault) {
+      mode |= StrictLegacyMode | StrictEffectsMode;
+    }
+  } else {
+    mode = NoMode;
+  }
+
+  return createFiber(HostRoot, null, null, mode);
+}
+function createFiberFromTypeAndProps(type, // React$ElementType
+key, pendingProps, source, owner, mode, lanes) {
+  let fiberTag = IndeterminateComponent; // The resolved type is set if we know what the final type will be. I.e. it's not lazy.
+
+  let resolvedType = type;
+
+  if (typeof type === 'function') {
+    if (shouldConstruct(type)) {
+      fiberTag = ClassComponent;
+    }
+  } else if (typeof type === 'string') {
+    {
+      const hostContext = getHostContext();
+      fiberTag = isHostHoistableType(type, pendingProps, hostContext) ? HostHoistable : isHostSingletonType(type) ? HostSingleton : HostComponent;
+    }
+  } else {
+    getTag: switch (type) {
+      case REACT_FRAGMENT_TYPE:
+        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
+
+      case REACT_STRICT_MODE_TYPE:
+        fiberTag = Mode;
+        mode |= StrictLegacyMode;
+
+        if ((mode & ConcurrentMode) !== NoMode) {
+          // Strict effects should never run on legacy roots
+          mode |= StrictEffectsMode;
+        }
+
+        break;
+
+      case REACT_PROFILER_TYPE:
+        return createFiberFromProfiler(pendingProps, mode, lanes, key);
+
+      case REACT_SUSPENSE_TYPE:
+        return createFiberFromSuspense(pendingProps, mode, lanes, key);
+
+      case REACT_SUSPENSE_LIST_TYPE:
+        return createFiberFromSuspenseList(pendingProps, mode, lanes, key);
+
+      case REACT_OFFSCREEN_TYPE:
+        return createFiberFromOffscreen(pendingProps, mode, lanes, key);
+
+      case REACT_LEGACY_HIDDEN_TYPE:
+
+      // Fall through
+
+      case REACT_SCOPE_TYPE:
+
+      // Fall through
+
+      case REACT_CACHE_TYPE:
+        {
+          return createFiberFromCache(pendingProps, mode, lanes, key);
+        }
+
+      // Fall through
+
+      case REACT_TRACING_MARKER_TYPE:
+
+      // Fall through
+
+      case REACT_DEBUG_TRACING_MODE_TYPE:
+
+      // Fall through
+
+      default:
+        {
+          if (typeof type === 'object' && type !== null) {
+            switch (type.$$typeof) {
+              case REACT_PROVIDER_TYPE:
+                fiberTag = ContextProvider;
+                break getTag;
+
+              case REACT_CONTEXT_TYPE:
+                // This is a consumer
+                fiberTag = ContextConsumer;
+                break getTag;
+
+              case REACT_FORWARD_REF_TYPE:
+                fiberTag = ForwardRef;
+
+                break getTag;
+
+              case REACT_MEMO_TYPE:
+                fiberTag = MemoComponent;
+                break getTag;
+
+              case REACT_LAZY_TYPE:
+                fiberTag = LazyComponent;
+                resolvedType = null;
+                break getTag;
+            }
+          }
+
+          let info = '';
+
+          throw Error(formatProdErrorMessage(130, type == null ? type : typeof type, info));
+        }
+    }
+  }
+
+  const fiber = createFiber(fiberTag, pendingProps, key, mode);
+  fiber.elementType = type;
+  fiber.type = resolvedType;
+  fiber.lanes = lanes;
+
+  return fiber;
+}
+function createFiberFromElement(element, mode, lanes) {
+  let source = null;
+  let owner = null;
+
+  const type = element.type;
+  const key = element.key;
+  const pendingProps = element.props;
+  const fiber = createFiberFromTypeAndProps(type, key, pendingProps, source, owner, mode, lanes);
+
+  return fiber;
+}
+function createFiberFromFragment(elements, mode, lanes, key) {
+  const fiber = createFiber(Fragment, elements, key, mode);
+  fiber.lanes = lanes;
+  return fiber;
+}
+
+function createFiberFromProfiler(pendingProps, mode, lanes, key) {
+
+  const fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);
+  fiber.elementType = REACT_PROFILER_TYPE;
+  fiber.lanes = lanes;
+
+  return fiber;
+}
+
+function createFiberFromSuspense(pendingProps, mode, lanes, key) {
+  const fiber = createFiber(SuspenseComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_SUSPENSE_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromSuspenseList(pendingProps, mode, lanes, key) {
+  const fiber = createFiber(SuspenseListComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_SUSPENSE_LIST_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
+  const fiber = createFiber(OffscreenComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_OFFSCREEN_TYPE;
+  fiber.lanes = lanes;
+  const primaryChildInstance = {
+    _visibility: OffscreenVisible,
+    _pendingVisibility: OffscreenVisible,
+    _pendingMarkers: null,
+    _retryCache: null,
+    _transitions: null,
+    _current: null,
+    detach: () => detachOffscreenInstance(primaryChildInstance),
+    attach: () => attachOffscreenInstance(primaryChildInstance)
+  };
+  fiber.stateNode = primaryChildInstance;
+  return fiber;
+}
+function createFiberFromCache(pendingProps, mode, lanes, key) {
+  const fiber = createFiber(CacheComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_CACHE_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromText(content, mode, lanes) {
+  const fiber = createFiber(HostText, content, null, mode);
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromHostInstanceForDeletion() {
+  const fiber = createFiber(HostComponent, null, null, NoMode);
+  fiber.elementType = 'DELETED';
+  return fiber;
+}
+function createFiberFromDehydratedFragment(dehydratedNode) {
+  const fiber = createFiber(DehydratedFragment, null, null, NoMode);
+  fiber.stateNode = dehydratedNode;
+  return fiber;
+}
+function createFiberFromPortal(portal, mode, lanes) {
+  const pendingProps = portal.children !== null ? portal.children : [];
+  const fiber = createFiber(HostPortal, pendingProps, portal.key, mode);
+  fiber.lanes = lanes;
+  fiber.stateNode = {
+    containerInfo: portal.containerInfo,
+    pendingChildren: null,
+    // Used by persistent updates
+    implementation: portal.implementation
+  };
+  return fiber;
+} // Used for stashing WIP properties to replay failed work in DEV.
+
+function FiberRootNode(containerInfo, // $FlowFixMe[missing-local-annot]
+tag, hydrate, identifierPrefix, onRecoverableError, formState) {
+  this.tag = tag;
+  this.containerInfo = containerInfo;
+  this.pendingChildren = null;
+  this.current = null;
+  this.pingCache = null;
+  this.finishedWork = null;
+  this.timeoutHandle = noTimeout;
+  this.cancelPendingCommit = null;
+  this.context = null;
+  this.pendingContext = null;
+  this.next = null;
+  this.callbackNode = null;
+  this.callbackPriority = NoLane;
+  this.expirationTimes = createLaneMap(NoTimestamp);
+  this.pendingLanes = NoLanes;
+  this.suspendedLanes = NoLanes;
+  this.pingedLanes = NoLanes;
+  this.expiredLanes = NoLanes;
+  this.finishedLanes = NoLanes;
+  this.errorRecoveryDisabledLanes = NoLanes;
+  this.shellSuspendCounter = 0;
+  this.entangledLanes = NoLanes;
+  this.entanglements = createLaneMap(NoLanes);
+  this.hiddenUpdates = createLaneMap(null);
+  this.identifierPrefix = identifierPrefix;
+  this.onRecoverableError = onRecoverableError;
+
+  {
+    this.pooledCache = null;
+    this.pooledCacheLanes = NoLanes;
+  }
+
+  this.formState = formState;
+  this.incompleteTransitions = new Map();
+}
+
+function createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, // TODO: We have several of these arguments that are conceptually part of the
+// host config, but because they are passed in at runtime, we have to thread
+// them through the root constructor. Perhaps we should put them all into a
+// single type, like a DynamicHostConfig that is defined by the renderer.
+identifierPrefix, onRecoverableError, transitionCallbacks, formState) {
+  // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
+  const root = new FiberRootNode(containerInfo, tag, hydrate, identifierPrefix, onRecoverableError, formState);
+  // stateNode is any.
+
+
+  const uninitializedFiber = createHostRootFiber(tag, isStrictMode);
+  root.current = uninitializedFiber;
+  uninitializedFiber.stateNode = root;
+
+  {
+    const initialCache = createCache();
+    retainCache(initialCache); // The pooledCache is a fresh cache instance that is used temporarily
+    // for newly mounted boundaries during a render. In general, the
+    // pooledCache is always cleared from the root at the end of a render:
+    // it is either released when render commits, or moved to an Offscreen
+    // component if rendering suspends. Because the lifetime of the pooled
+    // cache is distinct from the main memoizedState.cache, it must be
+    // retained separately.
+
+    root.pooledCache = initialCache;
+    retainCache(initialCache);
+    const initialState = {
+      element: initialChildren,
+      isDehydrated: hydrate,
+      cache: initialCache
+    };
+    uninitializedFiber.memoizedState = initialState;
+  }
+
+  initializeUpdateQueue(uninitializedFiber);
+  return root;
+}
+
+var ReactVersion = '18.3.0-canary-7508dcd5c-20231108';
+
+function createPortal$1(children, containerInfo, // TODO: figure out the API for cross-renderer implementation.
+implementation) {
+  let key = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+
+  return {
+    // This tag allow us to uniquely identify this as a React Portal
+    $$typeof: REACT_PORTAL_TYPE,
+    key: key == null ? null : '' + key,
+    children,
+    containerInfo,
+    implementation
+  };
+}
+
+function getContextForSubtree(parentComponent) {
+  if (!parentComponent) {
+    return emptyContextObject;
+  }
+
+  const fiber = get(parentComponent);
+  const parentContext = findCurrentUnmaskedContext(fiber);
+
+  if (fiber.tag === ClassComponent) {
+    const Component = fiber.type;
+
+    if (isContextProvider(Component)) {
+      return processChildContext(fiber, Component, parentContext);
+    }
+  }
+
+  return parentContext;
+}
+
+function findHostInstance(component) {
+  const fiber = get(component);
+
+  if (fiber === undefined) {
+    if (typeof component.render === 'function') {
+      throw Error(formatProdErrorMessage(188));
+    } else {
+      const keys = Object.keys(component).join(',');
+      throw Error(formatProdErrorMessage(268, keys));
+    }
+  }
+
+  const hostFiber = findCurrentHostFiber(fiber);
+
+  if (hostFiber === null) {
+    return null;
+  }
+
+  return getPublicInstance(hostFiber.stateNode);
+}
+
+function createContainer(containerInfo, tag, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks) {
+  const hydrate = false;
+  const initialChildren = null;
+  return createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks, null);
+}
+function createHydrationContainer(initialChildren, // TODO: Remove `callback` when we delete legacy mode.
+callback, containerInfo, tag, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks, formState) {
+  const hydrate = true;
+  const root = createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks, formState); // TODO: Move this to FiberRoot constructor
+
+  root.context = getContextForSubtree(null); // Schedule the initial render. In a hydration root, this is different from
+  // a regular update because the initial render must match was was rendered
+  // on the server.
+  // NOTE: This update intentionally doesn't have a payload. We're only using
+  // the update to schedule work on the root fiber (and, for legacy roots, to
+  // enqueue the callback if one is provided).
+
+  const current = root.current;
+  const lane = requestUpdateLane(current);
+  const update = createUpdate(lane);
+  update.callback = callback !== undefined && callback !== null ? callback : null;
+  enqueueUpdate(current, update, lane);
+  scheduleInitialHydrationOnRoot(root, lane);
+  return root;
+}
+function updateContainer(element, container, parentComponent, callback) {
+
+  const current = container.current;
+  const lane = requestUpdateLane(current);
+
+  const context = getContextForSubtree(parentComponent);
+
+  if (container.context === null) {
+    container.context = context;
+  } else {
+    container.pendingContext = context;
+  }
+
+  const update = createUpdate(lane); // Caution: React DevTools currently depends on this property
+  // being called "element".
+
+  update.payload = {
+    element
+  };
+  callback = callback === undefined ? null : callback;
+
+  if (callback !== null) {
+
+    update.callback = callback;
+  }
+
+  const root = enqueueUpdate(current, update, lane);
+
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, current, lane);
+    entangleTransitions(root, current, lane);
+  }
+
+  return lane;
+}
+function getPublicRootInstance(container) {
+  const containerFiber = container.current;
+
+  if (!containerFiber.child) {
+    return null;
+  }
+
+  switch (containerFiber.child.tag) {
+    case HostSingleton:
+    case HostComponent:
+      return getPublicInstance(containerFiber.child.stateNode);
+
+    default:
+      return containerFiber.child.stateNode;
+  }
+}
+function attemptSynchronousHydration(fiber) {
+  switch (fiber.tag) {
+    case HostRoot:
+      {
+        const root = fiber.stateNode;
+
+        if (isRootDehydrated(root)) {
+          // Flush the first scheduled "update".
+          const lanes = getHighestPriorityPendingLanes(root);
+          flushRoot(root, lanes);
+        }
+
+        break;
+      }
+
+    case SuspenseComponent:
+      {
+        flushSync$1(() => {
+          const root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+          if (root !== null) {
+            scheduleUpdateOnFiber(root, fiber, SyncLane);
+          }
+        }); // If we're still blocked after this, we need to increase
+        // the priority of any promises resolving within this
+        // boundary so that they next attempt also has higher pri.
+
+        const retryLane = SyncLane;
+        markRetryLaneIfNotHydrated(fiber, retryLane);
+        break;
+      }
+  }
+}
+
+function markRetryLaneImpl(fiber, retryLane) {
+  const suspenseState = fiber.memoizedState;
+
+  if (suspenseState !== null && suspenseState.dehydrated !== null) {
+    suspenseState.retryLane = higherPriorityLane(suspenseState.retryLane, retryLane);
+  }
+} // Increases the priority of thenables when they resolve within this boundary.
+
+
+function markRetryLaneIfNotHydrated(fiber, retryLane) {
+  markRetryLaneImpl(fiber, retryLane);
+  const alternate = fiber.alternate;
+
+  if (alternate) {
+    markRetryLaneImpl(alternate, retryLane);
+  }
+}
+
+function attemptContinuousHydration(fiber) {
+  if (fiber.tag !== SuspenseComponent) {
+    // We ignore HostRoots here because we can't increase
+    // their priority and they should not suspend on I/O,
+    // since you have to wrap anything that might suspend in
+    // Suspense.
+    return;
+  }
+
+  const lane = SelectiveHydrationLane;
+  const root = enqueueConcurrentRenderForLane(fiber, lane);
+
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, fiber, lane);
+  }
+
+  markRetryLaneIfNotHydrated(fiber, lane);
+}
+function attemptHydrationAtCurrentPriority(fiber) {
+  if (fiber.tag !== SuspenseComponent) {
+    // We ignore HostRoots here because we can't increase
+    // their priority other than synchronously flush it.
+    return;
+  }
+
+  const lane = requestUpdateLane(fiber);
+  const root = enqueueConcurrentRenderForLane(fiber, lane);
+
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, fiber, lane);
+  }
+
+  markRetryLaneIfNotHydrated(fiber, lane);
+}
+let overrideHookState = null;
+let overrideHookStateDeletePath = null;
+let overrideHookStateRenamePath = null;
+let overrideProps = null;
+let overridePropsDeletePath = null;
+let overridePropsRenamePath = null;
+let scheduleUpdate = null;
+let setErrorHandler = null;
+let setSuspenseHandler = null;
+
+function findHostInstanceByFiber(fiber) {
+  const hostFiber = findCurrentHostFiber(fiber);
+
+  if (hostFiber === null) {
+    return null;
+  }
+
+  return hostFiber.stateNode;
+}
+
+function emptyFindFiberByHostInstance(instance) {
+  return null;
+}
+
+function injectIntoDevTools(devToolsConfig) {
+  const findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
+  const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+  return injectInternals({
+    bundleType: devToolsConfig.bundleType,
+    version: devToolsConfig.version,
+    rendererPackageName: devToolsConfig.rendererPackageName,
+    rendererConfig: devToolsConfig.rendererConfig,
+    overrideHookState,
+    overrideHookStateDeletePath,
+    overrideHookStateRenamePath,
+    overrideProps,
+    overridePropsDeletePath,
+    overridePropsRenamePath,
+    setErrorHandler,
+    setSuspenseHandler,
+    scheduleUpdate,
+    currentDispatcherRef: ReactCurrentDispatcher,
+    findHostInstanceByFiber,
+    findFiberByHostInstance: findFiberByHostInstance || emptyFindFiberByHostInstance,
+    // React Refresh
+    findHostInstancesForRefresh: null,
+    scheduleRefresh: null,
+    scheduleRoot: null,
+    setRefreshHandler: null,
+    // Enables DevTools to append owner stacks to error messages in DEV mode.
+    getCurrentFiber: null,
+    // Enables DevTools to detect reconciler version rather than renderer version
+    // which may not match for third party renderers.
+    reconcilerVersion: ReactVersion
+  });
+}
+
+// the renderer. Such as when we're dispatching events or if third party
+// libraries need to call batchedUpdates. Eventually, this API will go away when
+// everything is batched by default. We'll then have a similar API to opt-out of
+// scheduled work and instead do synchronous work.
+
+let isInsideEventHandler = false;
+
+function finishEventHandler() {
+  // Here we wait until all updates have propagated, which is important
+  // when using controlled components within layers:
+  // https://github.com/facebook/react/issues/1698
+  // Then we restore state of any controlled component.
+  const controlledComponentsHavePendingUpdates = needsStateRestore();
+
+  if (controlledComponentsHavePendingUpdates) {
+    // If a controlled event was fired, we may need to restore the state of
+    // the DOM node back to the controlled value. This is necessary when React
+    // bails out of the update without touching the DOM.
+    // TODO: Restore state in the microtask, after the discrete updates flush,
+    // instead of early flushing them here.
+    flushSync$1();
+    restoreStateIfNeeded();
+  }
+}
+
+function batchedUpdates(fn, a, b) {
+  if (isInsideEventHandler) {
+    // If we are currently inside another batch, we need to wait until it
+    // fully completes before restoring state.
+    return fn(a, b);
+  }
+
+  isInsideEventHandler = true;
+
+  try {
+    return batchedUpdates$1(fn, a, b);
+  } finally {
+    isInsideEventHandler = false;
+    finishEventHandler();
+  }
+} // TODO: Replace with flushSync
+
+function isInteractive(tag) {
+  return tag === 'button' || tag === 'input' || tag === 'select' || tag === 'textarea';
+}
+
+function shouldPreventMouseEvent(name, type, props) {
+  switch (name) {
+    case 'onClick':
+    case 'onClickCapture':
+    case 'onDoubleClick':
+    case 'onDoubleClickCapture':
+    case 'onMouseDown':
+    case 'onMouseDownCapture':
+    case 'onMouseMove':
+    case 'onMouseMoveCapture':
+    case 'onMouseUp':
+    case 'onMouseUpCapture':
+    case 'onMouseEnter':
+      return !!(props.disabled && isInteractive(type));
+
+    default:
+      return false;
+  }
+}
+/**
+ * @param {object} inst The instance, which is the source of events.
+ * @param {string} registrationName Name of listener (e.g. `onClick`).
+ * @return {?function} The stored callback.
+ */
+
+
+function getListener(inst, registrationName) {
+  const stateNode = inst.stateNode;
+
+  if (stateNode === null) {
+    // Work in progress (ex: onload events in incremental mode).
+    return null;
+  }
+
+  const props = getFiberCurrentPropsFromNode(stateNode);
+
+  if (props === null) {
+    // Work in progress.
+    return null;
+  }
+
+  const listener = props[registrationName];
+
+  if (shouldPreventMouseEvent(registrationName, inst.type, props)) {
+    return null;
+  }
+
+  if (listener && typeof listener !== 'function') {
+    throw Error(formatProdErrorMessage(231, registrationName, typeof listener));
+  }
+
+  return listener;
+}
+
+let passiveBrowserEventsSupported = false; // Check if browser support events with passive listeners
+// https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support
+
+if (canUseDOM) {
+  try {
+    const options = {};
+    Object.defineProperty(options, 'passive', {
+      get: function () {
+        passiveBrowserEventsSupported = true;
+      }
+    });
+    window.addEventListener('test', options, options);
+    window.removeEventListener('test', options, options);
+  } catch (e) {
+    passiveBrowserEventsSupported = false;
+  }
+}
+
+/**
+ * `charCode` represents the actual "character code" and is safe to use with
+ * `String.fromCharCode`. As such, only keys that correspond to printable
+ * characters produce a valid `charCode`, the only exception to this is Enter.
+ * The Tab-key is considered non-printable and does not have a `charCode`,
+ * presumably because it does not produce a tab-character in browsers.
+ *
+ * @param {object} nativeEvent Native browser event.
+ * @return {number} Normalized `charCode` property.
+ */
+function getEventCharCode(nativeEvent) {
+  let charCode;
+  const keyCode = nativeEvent.keyCode;
+
+  if ('charCode' in nativeEvent) {
+    charCode = nativeEvent.charCode; // FF does not set `charCode` for the Enter-key, check against `keyCode`.
+
+    if (charCode === 0 && keyCode === 13) {
+      charCode = 13;
+    }
+  } else {
+    // IE8 does not implement `charCode`, but `keyCode` has the correct value.
+    charCode = keyCode;
+  } // IE and Edge (on Windows) and Chrome / Safari (on Windows and Linux)
+  // report Enter as charCode 10 when ctrl is pressed.
+
+
+  if (charCode === 10) {
+    charCode = 13;
+  } // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
+  // Must not discard the (non-)printable Enter-key.
+
+
+  if (charCode >= 32 || charCode === 13) {
+    return charCode;
+  }
+
+  return 0;
+}
+
+function functionThatReturnsTrue() {
+  return true;
+}
+
+function functionThatReturnsFalse() {
+  return false;
+} // This is intentionally a factory so that we have different returned constructors.
+// If we had a single constructor, it would be megamorphic and engines would deopt.
+
+
+function createSyntheticEvent(Interface) {
+  /**
+   * Synthetic events are dispatched by event plugins, typically in response to a
+   * top-level event delegation handler.
+   *
+   * These systems should generally use pooling to reduce the frequency of garbage
+   * collection. The system should check `isPersistent` to determine whether the
+   * event should be released into the pool after being dispatched. Users that
+   * need a persisted event should invoke `persist`.
+   *
+   * Synthetic events (and subclasses) implement the DOM Level 3 Events API by
+   * normalizing browser quirks. Subclasses do not necessarily have to implement a
+   * DOM interface; custom application-specific events can also subclass this.
+   */
+  // $FlowFixMe[missing-this-annot]
+  function SyntheticBaseEvent(reactName, reactEventType, targetInst, nativeEvent, nativeEventTarget) {
+    this._reactName = reactName;
+    this._targetInst = targetInst;
+    this.type = reactEventType;
+    this.nativeEvent = nativeEvent;
+    this.target = nativeEventTarget;
+    this.currentTarget = null;
+
+    for (const propName in Interface) {
+      if (!Interface.hasOwnProperty(propName)) {
+        continue;
+      }
+
+      const normalize = Interface[propName];
+
+      if (normalize) {
+        this[propName] = normalize(nativeEvent);
+      } else {
+        this[propName] = nativeEvent[propName];
+      }
+    }
+
+    const defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
+
+    if (defaultPrevented) {
+      this.isDefaultPrevented = functionThatReturnsTrue;
+    } else {
+      this.isDefaultPrevented = functionThatReturnsFalse;
+    }
+
+    this.isPropagationStopped = functionThatReturnsFalse;
+    return this;
+  } // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+  assign(SyntheticBaseEvent.prototype, {
+    // $FlowFixMe[missing-this-annot]
+    preventDefault: function () {
+      this.defaultPrevented = true;
+      const event = this.nativeEvent;
+
+      if (!event) {
+        return;
+      }
+
+      if (event.preventDefault) {
+        event.preventDefault(); // $FlowFixMe[illegal-typeof] - flow is not aware of `unknown` in IE
+      } else if (typeof event.returnValue !== 'unknown') {
+        event.returnValue = false;
+      }
+
+      this.isDefaultPrevented = functionThatReturnsTrue;
+    },
+    // $FlowFixMe[missing-this-annot]
+    stopPropagation: function () {
+      const event = this.nativeEvent;
+
+      if (!event) {
+        return;
+      }
+
+      if (event.stopPropagation) {
+        event.stopPropagation(); // $FlowFixMe[illegal-typeof] - flow is not aware of `unknown` in IE
+      } else if (typeof event.cancelBubble !== 'unknown') {
+        // The ChangeEventPlugin registers a "propertychange" event for
+        // IE. This event does not support bubbling or cancelling, and
+        // any references to cancelBubble throw "Member not found".  A
+        // typeof check of "unknown" circumvents this issue (and is also
+        // IE specific).
+        event.cancelBubble = true;
+      }
+
+      this.isPropagationStopped = functionThatReturnsTrue;
+    },
+
+    /**
+     * We release all dispatched `SyntheticEvent`s after each event loop, adding
+     * them back into the pool. This allows a way to hold onto a reference that
+     * won't be added back into the pool.
+     */
+    persist: function () {// Modern event system doesn't use pooling.
+    },
+
+    /**
+     * Checks if this event should be released back into the pool.
+     *
+     * @return {boolean} True if this should not be released, false otherwise.
+     */
+    isPersistent: functionThatReturnsTrue
+  });
+  return SyntheticBaseEvent;
+}
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+
+const EventInterface = {
+  eventPhase: 0,
+  bubbles: 0,
+  cancelable: 0,
+  timeStamp: function (event) {
+    return event.timeStamp || Date.now();
+  },
+  defaultPrevented: 0,
+  isTrusted: 0
+};
+const SyntheticEvent = createSyntheticEvent(EventInterface);
+
+const UIEventInterface = assign({}, EventInterface, {
+  view: 0,
+  detail: 0
+});
+
+const SyntheticUIEvent = createSyntheticEvent(UIEventInterface);
+let lastMovementX;
+let lastMovementY;
+let lastMouseEvent;
+
+function updateMouseMovementPolyfillState(event) {
+  if (event !== lastMouseEvent) {
+    if (lastMouseEvent && event.type === 'mousemove') {
+      // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+      lastMovementX = event.screenX - lastMouseEvent.screenX; // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+
+      lastMovementY = event.screenY - lastMouseEvent.screenY;
+    } else {
+      lastMovementX = 0;
+      lastMovementY = 0;
+    }
+
+    lastMouseEvent = event;
+  }
+}
+/**
+ * @interface MouseEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+
+const MouseEventInterface = assign({}, UIEventInterface, {
+  screenX: 0,
+  screenY: 0,
+  clientX: 0,
+  clientY: 0,
+  pageX: 0,
+  pageY: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  altKey: 0,
+  metaKey: 0,
+  getModifierState: getEventModifierState,
+  button: 0,
+  buttons: 0,
+  relatedTarget: function (event) {
+    if (event.relatedTarget === undefined) return event.fromElement === event.srcElement ? event.toElement : event.fromElement;
+    return event.relatedTarget;
+  },
+  movementX: function (event) {
+    if ('movementX' in event) {
+      return event.movementX;
+    }
+
+    updateMouseMovementPolyfillState(event);
+    return lastMovementX;
+  },
+  movementY: function (event) {
+    if ('movementY' in event) {
+      return event.movementY;
+    } // Don't need to call updateMouseMovementPolyfillState() here
+    // because it's guaranteed to have already run when movementX
+    // was copied.
+
+
+    return lastMovementY;
+  }
+});
+
+const SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface);
+/**
+ * @interface DragEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+const DragEventInterface = assign({}, MouseEventInterface, {
+  dataTransfer: 0
+});
+
+const SyntheticDragEvent = createSyntheticEvent(DragEventInterface);
+/**
+ * @interface FocusEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+const FocusEventInterface = assign({}, UIEventInterface, {
+  relatedTarget: 0
+});
+
+const SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent
+ */
+
+const AnimationEventInterface = assign({}, EventInterface, {
+  animationName: 0,
+  elapsedTime: 0,
+  pseudoElement: 0
+});
+
+const SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/clipboard-apis/
+ */
+
+const ClipboardEventInterface = assign({}, EventInterface, {
+  clipboardData: function (event) {
+    return 'clipboardData' in event ? event.clipboardData : window.clipboardData;
+  }
+});
+
+const SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents
+ */
+
+const CompositionEventInterface = assign({}, EventInterface, {
+  data: 0
+});
+
+const SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105
+ *      /#events-inputevents
+ */
+// Happens to share the same list for now.
+
+const SyntheticInputEvent = SyntheticCompositionEvent;
+/**
+ * Normalization of deprecated HTML5 `key` values
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
+ */
+
+const normalizeKey = {
+  Esc: 'Escape',
+  Spacebar: ' ',
+  Left: 'ArrowLeft',
+  Up: 'ArrowUp',
+  Right: 'ArrowRight',
+  Down: 'ArrowDown',
+  Del: 'Delete',
+  Win: 'OS',
+  Menu: 'ContextMenu',
+  Apps: 'ContextMenu',
+  Scroll: 'ScrollLock',
+  MozPrintableKey: 'Unidentified'
+};
+/**
+ * Translation from legacy `keyCode` to HTML5 `key`
+ * Only special keys supported, all others depend on keyboard layout or browser
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
+ */
+
+const translateToKey = {
+  '8': 'Backspace',
+  '9': 'Tab',
+  '12': 'Clear',
+  '13': 'Enter',
+  '16': 'Shift',
+  '17': 'Control',
+  '18': 'Alt',
+  '19': 'Pause',
+  '20': 'CapsLock',
+  '27': 'Escape',
+  '32': ' ',
+  '33': 'PageUp',
+  '34': 'PageDown',
+  '35': 'End',
+  '36': 'Home',
+  '37': 'ArrowLeft',
+  '38': 'ArrowUp',
+  '39': 'ArrowRight',
+  '40': 'ArrowDown',
+  '45': 'Insert',
+  '46': 'Delete',
+  '112': 'F1',
+  '113': 'F2',
+  '114': 'F3',
+  '115': 'F4',
+  '116': 'F5',
+  '117': 'F6',
+  '118': 'F7',
+  '119': 'F8',
+  '120': 'F9',
+  '121': 'F10',
+  '122': 'F11',
+  '123': 'F12',
+  '144': 'NumLock',
+  '145': 'ScrollLock',
+  '224': 'Meta'
+};
+/**
+ * @param {object} nativeEvent Native browser event.
+ * @return {string} Normalized `key` property.
+ */
+
+function getEventKey(nativeEvent) {
+  if (nativeEvent.key) {
+    // Normalize inconsistent values reported by browsers due to
+    // implementations of a working draft specification.
+    // FireFox implements `key` but returns `MozPrintableKey` for all
+    // printable characters (normalized to `Unidentified`), ignore it.
+    const key = // $FlowFixMe[invalid-computed-prop] unable to index with a `mixed` value
+    normalizeKey[nativeEvent.key] || nativeEvent.key;
+
+    if (key !== 'Unidentified') {
+      return key;
+    }
+  } // Browser does not implement `key`, polyfill as much of it as we can.
+
+
+  if (nativeEvent.type === 'keypress') {
+    const charCode = getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
+    nativeEvent); // The enter-key is technically both printable and non-printable and can
+    // thus be captured by `keypress`, no other non-printable key should.
+
+    return charCode === 13 ? 'Enter' : String.fromCharCode(charCode);
+  }
+
+  if (nativeEvent.type === 'keydown' || nativeEvent.type === 'keyup') {
+    // While user keyboard layout determines the actual meaning of each
+    // `keyCode` value, almost all function keys have a universal value.
+    // $FlowFixMe[invalid-computed-prop] unable to index with a `mixed` value
+    return translateToKey[nativeEvent.keyCode] || 'Unidentified';
+  }
+
+  return '';
+}
+/**
+ * Translation from modifier key to the associated property in the event.
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers
+ */
+
+
+const modifierKeyToProp = {
+  Alt: 'altKey',
+  Control: 'ctrlKey',
+  Meta: 'metaKey',
+  Shift: 'shiftKey'
+}; // Older browsers (Safari <= 10, iOS Safari <= 10.2) do not support
+// getModifierState. If getModifierState is not supported, we map it to a set of
+// modifier keys exposed by the event. In this case, Lock-keys are not supported.
+// $FlowFixMe[missing-local-annot]
+// $FlowFixMe[missing-this-annot]
+
+function modifierStateGetter(keyArg) {
+  const syntheticEvent = this;
+  const nativeEvent = syntheticEvent.nativeEvent;
+
+  if (nativeEvent.getModifierState) {
+    return nativeEvent.getModifierState(keyArg);
+  }
+
+  const keyProp = modifierKeyToProp[keyArg];
+  return keyProp ? !!nativeEvent[keyProp] : false;
+}
+
+function getEventModifierState(nativeEvent) {
+  return modifierStateGetter;
+}
+/**
+ * @interface KeyboardEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+
+const KeyboardEventInterface = assign({}, UIEventInterface, {
+  key: getEventKey,
+  code: 0,
+  location: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  altKey: 0,
+  metaKey: 0,
+  repeat: 0,
+  locale: 0,
+  getModifierState: getEventModifierState,
+  // Legacy Interface
+  charCode: function (event) {
+    // `charCode` is the result of a KeyPress event and represents the value of
+    // the actual printable character.
+    // KeyPress is deprecated, but its replacement is not yet final and not
+    // implemented in any major browser. Only KeyPress has charCode.
+    if (event.type === 'keypress') {
+      return getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
+      event);
+    }
+
+    return 0;
+  },
+  keyCode: function (event) {
+    // `keyCode` is the result of a KeyDown/Up event and represents the value of
+    // physical keyboard key.
+    // The actual meaning of the value depends on the users' keyboard layout
+    // which cannot be detected. Assuming that it is a US keyboard layout
+    // provides a surprisingly accurate mapping for US and European users.
+    // Due to this, it is left to the user to implement at this time.
+    if (event.type === 'keydown' || event.type === 'keyup') {
+      return event.keyCode;
+    }
+
+    return 0;
+  },
+  which: function (event) {
+    // `which` is an alias for either `keyCode` or `charCode` depending on the
+    // type of the event.
+    if (event.type === 'keypress') {
+      return getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
+      event);
+    }
+
+    if (event.type === 'keydown' || event.type === 'keyup') {
+      return event.keyCode;
+    }
+
+    return 0;
+  }
+});
+
+const SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface);
+/**
+ * @interface PointerEvent
+ * @see http://www.w3.org/TR/pointerevents/
+ */
+
+const PointerEventInterface = assign({}, MouseEventInterface, {
+  pointerId: 0,
+  width: 0,
+  height: 0,
+  pressure: 0,
+  tangentialPressure: 0,
+  tiltX: 0,
+  tiltY: 0,
+  twist: 0,
+  pointerType: 0,
+  isPrimary: 0
+});
+
+const SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface);
+/**
+ * @interface TouchEvent
+ * @see http://www.w3.org/TR/touch-events/
+ */
+
+const TouchEventInterface = assign({}, UIEventInterface, {
+  touches: 0,
+  targetTouches: 0,
+  changedTouches: 0,
+  altKey: 0,
+  metaKey: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  getModifierState: getEventModifierState
+});
+
+const SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent
+ */
+
+const TransitionEventInterface = assign({}, EventInterface, {
+  propertyName: 0,
+  elapsedTime: 0,
+  pseudoElement: 0
+});
+
+const SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface);
+/**
+ * @interface WheelEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+const WheelEventInterface = assign({}, MouseEventInterface, {
+  deltaX(event) {
+    return 'deltaX' in event ? event.deltaX : // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).
+    'wheelDeltaX' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+    -event.wheelDeltaX : 0;
+  },
+
+  deltaY(event) {
+    return 'deltaY' in event ? event.deltaY : // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
+    'wheelDeltaY' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+    -event.wheelDeltaY : // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
+    'wheelDelta' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+    -event.wheelDelta : 0;
+  },
+
+  deltaZ: 0,
+  // Browsers without "deltaMode" is reporting in raw wheel delta where one
+  // notch on the scroll is always +/- 120, roughly equivalent to pixels.
+  // A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or
+  // ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.
+  deltaMode: 0
+});
+
+const SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface);
+
+/**
+ * This plugin invokes action functions on forms, inputs and buttons if
+ * the form doesn't prevent default.
+ */
+
+function extractEvents$6(dispatchQueue, domEventName, maybeTargetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  if (domEventName !== 'submit') {
+    return;
+  }
+
+  if (!maybeTargetInst || maybeTargetInst.stateNode !== nativeEventTarget) {
+    // If we're inside a parent root that itself is a parent of this root, then
+    // its deepest target won't be the actual form that's being submitted.
+    return;
+  }
+
+  const formInst = maybeTargetInst;
+  const form = nativeEventTarget;
+  let action = getFiberCurrentPropsFromNode(form).action;
+  let submitter = nativeEvent.submitter;
+  let submitterAction;
+
+  if (submitter) {
+    const submitterProps = getFiberCurrentPropsFromNode(submitter);
+    submitterAction = submitterProps ? submitterProps.formAction : submitter.getAttribute('formAction');
+
+    if (submitterAction != null) {
+      // The submitter overrides the form action.
+      action = submitterAction; // If the action is a function, we don't want to pass its name
+      // value to the FormData since it's controlled by the server.
+
+      submitter = null;
+    }
+  }
+
+  if (typeof action !== 'function') {
+    return;
+  }
+
+  const event = new SyntheticEvent('action', 'action', null, nativeEvent, nativeEventTarget);
+
+  function submitForm() {
+    if (nativeEvent.defaultPrevented) {
+      // We let earlier events to prevent the action from submitting.
+      return;
+    } // Prevent native navigation.
+
+
+    event.preventDefault();
+    let formData;
+
+    if (submitter) {
+      // The submitter's value should be included in the FormData.
+      // It should be in the document order in the form.
+      // Since the FormData constructor invokes the formdata event it also
+      // needs to be available before that happens so after construction it's too
+      // late. We use a temporary fake node for the duration of this event.
+      // TODO: FormData takes a second argument that it's the submitter but this
+      // is fairly new so not all browsers support it yet. Switch to that technique
+      // when available.
+      const temp = submitter.ownerDocument.createElement('input');
+      temp.name = submitter.name;
+      temp.value = submitter.value;
+      submitter.parentNode.insertBefore(temp, submitter);
+      formData = new FormData(form);
+      temp.parentNode.removeChild(temp);
+    } else {
+      formData = new FormData(form);
+    }
+
+    const pendingState = {
+      pending: true,
+      data: formData,
+      method: form.method,
+      action: action
+    };
+
+    startHostTransition(formInst, pendingState, action, formData);
+  }
+
+  dispatchQueue.push({
+    event,
+    listeners: [{
+      instance: null,
+      listener: submitForm,
+      currentTarget: form
+    }]
+  });
+}
+function dispatchReplayedFormAction(formInst, form, action, formData) {
+  const pendingState = {
+    pending: true,
+    data: formData,
+    method: form.method,
+    action: action
+  };
+
+  startHostTransition(formInst, pendingState, action, formData);
+}
+
+// has this definition built-in.
+
+let hasScheduledReplayAttempt = false; // The last of each continuous event type. We only need to replay the last one
+// if the last target was dehydrated.
+
+let queuedFocus = null;
+let queuedDrag = null;
+let queuedMouse = null; // For pointer events there can be one latest event per pointerId.
+
+const queuedPointers = new Map();
+const queuedPointerCaptures = new Map(); // We could consider replaying selectionchange and touchmoves too.
+
+const queuedExplicitHydrationTargets = [];
+const discreteReplayableEvents = ['mousedown', 'mouseup', 'touchcancel', 'touchend', 'touchstart', 'auxclick', 'dblclick', 'pointercancel', 'pointerdown', 'pointerup', 'dragend', 'dragstart', 'drop', 'compositionend', 'compositionstart', 'keydown', 'keypress', 'keyup', 'input', 'textInput', // Intentionally camelCase
+'copy', 'cut', 'paste', 'click', 'change', 'contextmenu', 'reset' // 'submit', // stopPropagation blocks the replay mechanism
+];
+function isDiscreteEventThatRequiresHydration(eventType) {
+  return discreteReplayableEvents.indexOf(eventType) > -1;
+}
+
+function createQueuedReplayableEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+  return {
+    blockedOn,
+    domEventName,
+    eventSystemFlags,
+    nativeEvent,
+    targetContainers: [targetContainer]
+  };
+} // Resets the replaying for this type of continuous event to no event.
+
+
+function clearIfContinuousEvent(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case 'focusin':
+    case 'focusout':
+      queuedFocus = null;
+      break;
+
+    case 'dragenter':
+    case 'dragleave':
+      queuedDrag = null;
+      break;
+
+    case 'mouseover':
+    case 'mouseout':
+      queuedMouse = null;
+      break;
+
+    case 'pointerover':
+    case 'pointerout':
+      {
+        const pointerId = nativeEvent.pointerId;
+        queuedPointers.delete(pointerId);
+        break;
+      }
+
+    case 'gotpointercapture':
+    case 'lostpointercapture':
+      {
+        const pointerId = nativeEvent.pointerId;
+        queuedPointerCaptures.delete(pointerId);
+        break;
+      }
+  }
+}
+
+function accumulateOrCreateContinuousQueuedReplayableEvent(existingQueuedEvent, blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+  if (existingQueuedEvent === null || existingQueuedEvent.nativeEvent !== nativeEvent) {
+    const queuedEvent = createQueuedReplayableEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent);
+
+    if (blockedOn !== null) {
+      const fiber = getInstanceFromNode(blockedOn);
+
+      if (fiber !== null) {
+        // Attempt to increase the priority of this target.
+        attemptContinuousHydration(fiber);
+      }
+    }
+
+    return queuedEvent;
+  } // If we have already queued this exact event, then it's because
+  // the different event systems have different DOM event listeners.
+  // We can accumulate the flags, and the targetContainers, and
+  // store a single event to be replayed.
+
+
+  existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
+  const targetContainers = existingQueuedEvent.targetContainers;
+
+  if (targetContainer !== null && targetContainers.indexOf(targetContainer) === -1) {
+    targetContainers.push(targetContainer);
+  }
+
+  return existingQueuedEvent;
+}
+
+function queueIfContinuousEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+  // These set relatedTarget to null because the replayed event will be treated as if we
+  // moved from outside the window (no target) onto the target once it hydrates.
+  // Instead of mutating we could clone the event.
+  switch (domEventName) {
+    case 'focusin':
+      {
+        const focusEvent = nativeEvent;
+        queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(queuedFocus, blockedOn, domEventName, eventSystemFlags, targetContainer, focusEvent);
+        return true;
+      }
+
+    case 'dragenter':
+      {
+        const dragEvent = nativeEvent;
+        queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(queuedDrag, blockedOn, domEventName, eventSystemFlags, targetContainer, dragEvent);
+        return true;
+      }
+
+    case 'mouseover':
+      {
+        const mouseEvent = nativeEvent;
+        queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(queuedMouse, blockedOn, domEventName, eventSystemFlags, targetContainer, mouseEvent);
+        return true;
+      }
+
+    case 'pointerover':
+      {
+        const pointerEvent = nativeEvent;
+        const pointerId = pointerEvent.pointerId;
+        queuedPointers.set(pointerId, accumulateOrCreateContinuousQueuedReplayableEvent(queuedPointers.get(pointerId) || null, blockedOn, domEventName, eventSystemFlags, targetContainer, pointerEvent));
+        return true;
+      }
+
+    case 'gotpointercapture':
+      {
+        const pointerEvent = nativeEvent;
+        const pointerId = pointerEvent.pointerId;
+        queuedPointerCaptures.set(pointerId, accumulateOrCreateContinuousQueuedReplayableEvent(queuedPointerCaptures.get(pointerId) || null, blockedOn, domEventName, eventSystemFlags, targetContainer, pointerEvent));
+        return true;
+      }
+  }
+
+  return false;
+} // Check if this target is unblocked. Returns true if it's unblocked.
+
+function attemptExplicitHydrationTarget(queuedTarget) {
+  // TODO: This function shares a lot of logic with findInstanceBlockingEvent.
+  // Try to unify them. It's a bit tricky since it would require two return
+  // values.
+  const targetInst = getClosestInstanceFromNode(queuedTarget.target);
+
+  if (targetInst !== null) {
+    const nearestMounted = getNearestMountedFiber(targetInst);
+
+    if (nearestMounted !== null) {
+      const tag = nearestMounted.tag;
+
+      if (tag === SuspenseComponent) {
+        const instance = getSuspenseInstanceFromFiber(nearestMounted);
+
+        if (instance !== null) {
+          // We're blocked on hydrating this boundary.
+          // Increase its priority.
+          queuedTarget.blockedOn = instance;
+          runWithPriority(queuedTarget.priority, () => {
+            attemptHydrationAtCurrentPriority(nearestMounted);
+          });
+          return;
+        }
+      } else if (tag === HostRoot) {
+        const root = nearestMounted.stateNode;
+
+        if (isRootDehydrated(root)) {
+          queuedTarget.blockedOn = getContainerFromFiber(nearestMounted); // We don't currently have a way to increase the priority of
+          // a root other than sync.
+
+          return;
+        }
+      }
+    }
+  }
+
+  queuedTarget.blockedOn = null;
+}
+
+function queueExplicitHydrationTarget(target) {
+  // TODO: This will read the priority if it's dispatched by the React
+  // event system but not native events. Should read window.event.type, like
+  // we do for updates (getCurrentEventPriority).
+  const updatePriority = getCurrentUpdatePriority();
+  const queuedTarget = {
+    blockedOn: null,
+    target: target,
+    priority: updatePriority
+  };
+  let i = 0;
+
+  for (; i < queuedExplicitHydrationTargets.length; i++) {
+    // Stop once we hit the first target with lower priority than
+    if (!isHigherEventPriority(updatePriority, queuedExplicitHydrationTargets[i].priority)) {
+      break;
+    }
+  }
+
+  queuedExplicitHydrationTargets.splice(i, 0, queuedTarget);
+
+  if (i === 0) {
+    attemptExplicitHydrationTarget(queuedTarget);
+  }
+}
+
+function attemptReplayContinuousQueuedEvent(queuedEvent) {
+  if (queuedEvent.blockedOn !== null) {
+    return false;
+  }
+
+  const targetContainers = queuedEvent.targetContainers;
+
+  while (targetContainers.length > 0) {
+    const nextBlockedOn = findInstanceBlockingEvent(queuedEvent.nativeEvent);
+
+    if (nextBlockedOn === null) {
+      const nativeEvent = queuedEvent.nativeEvent;
+      const nativeEventClone = new nativeEvent.constructor(nativeEvent.type, nativeEvent);
+      setReplayingEvent(nativeEventClone);
+      nativeEvent.target.dispatchEvent(nativeEventClone);
+      resetReplayingEvent();
+    } else {
+      // We're still blocked. Try again later.
+      const fiber = getInstanceFromNode(nextBlockedOn);
+
+      if (fiber !== null) {
+        attemptContinuousHydration(fiber);
+      }
+
+      queuedEvent.blockedOn = nextBlockedOn;
+      return false;
+    } // This target container was successfully dispatched. Try the next.
+
+
+    targetContainers.shift();
+  }
+
+  return true;
+}
+
+function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
+  if (attemptReplayContinuousQueuedEvent(queuedEvent)) {
+    map.delete(key);
+  }
+}
+
+function replayUnblockedEvents() {
+  hasScheduledReplayAttempt = false; // Replay any continuous events.
+
+  if (queuedFocus !== null && attemptReplayContinuousQueuedEvent(queuedFocus)) {
+    queuedFocus = null;
+  }
+
+  if (queuedDrag !== null && attemptReplayContinuousQueuedEvent(queuedDrag)) {
+    queuedDrag = null;
+  }
+
+  if (queuedMouse !== null && attemptReplayContinuousQueuedEvent(queuedMouse)) {
+    queuedMouse = null;
+  }
+
+  queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
+  queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
+}
+
+function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
+  if (queuedEvent.blockedOn === unblocked) {
+    queuedEvent.blockedOn = null;
+
+    if (!hasScheduledReplayAttempt) {
+      hasScheduledReplayAttempt = true; // Schedule a callback to attempt replaying as many events as are
+      // now unblocked. This first might not actually be unblocked yet.
+      // We could check it early to avoid scheduling an unnecessary callback.
+
+      Scheduler.unstable_scheduleCallback(Scheduler.unstable_NormalPriority, replayUnblockedEvents);
+    }
+  }
+} // [form, submitter or action, formData...]
+
+
+let lastScheduledReplayQueue = null;
+
+function replayUnblockedFormActions(formReplayingQueue) {
+  if (lastScheduledReplayQueue === formReplayingQueue) {
+    lastScheduledReplayQueue = null;
+  }
+
+  for (let i = 0; i < formReplayingQueue.length; i += 3) {
+    const form = formReplayingQueue[i];
+    const submitterOrAction = formReplayingQueue[i + 1];
+    const formData = formReplayingQueue[i + 2];
+
+    if (typeof submitterOrAction !== 'function') {
+      // This action is not hydrated yet. This might be because it's blocked on
+      // a different React instance or higher up our tree.
+      const blockedOn = findInstanceBlockingTarget(submitterOrAction || form);
+
+      if (blockedOn === null) {
+        // We're not blocked but we don't have an action. This must mean that
+        // this is in another React instance. We'll just skip past it.
+        continue;
+      } else {
+        // We're blocked on something in this React instance. We'll retry later.
+        break;
+      }
+    }
+
+    const formInst = getInstanceFromNode(form);
+
+    if (formInst !== null) {
+      // This is part of our instance.
+      // We're ready to replay this. Let's delete it from the queue.
+      formReplayingQueue.splice(i, 3);
+      i -= 3;
+      dispatchReplayedFormAction(formInst, form, submitterOrAction, formData); // Continue without incrementing the index.
+
+      continue;
+    } // This form must've been part of a different React instance.
+    // If we want to preserve ordering between React instances on the same root
+    // we'd need some way for the other instance to ping us when it's done.
+    // We'll just skip this and let the other instance execute it.
+
+  }
+}
+
+function scheduleReplayQueueIfNeeded(formReplayingQueue) {
+  // Schedule a callback to execute any unblocked form actions in.
+  // We only keep track of the last queue which means that if multiple React oscillate
+  // commits, we could schedule more callbacks than necessary but it's not a big deal
+  // and we only really except one instance.
+  if (lastScheduledReplayQueue !== formReplayingQueue) {
+    lastScheduledReplayQueue = formReplayingQueue;
+    Scheduler.unstable_scheduleCallback(Scheduler.unstable_NormalPriority, () => replayUnblockedFormActions(formReplayingQueue));
+  }
+}
+
+function retryIfBlockedOn(unblocked) {
+  if (queuedFocus !== null) {
+    scheduleCallbackIfUnblocked(queuedFocus, unblocked);
+  }
+
+  if (queuedDrag !== null) {
+    scheduleCallbackIfUnblocked(queuedDrag, unblocked);
+  }
+
+  if (queuedMouse !== null) {
+    scheduleCallbackIfUnblocked(queuedMouse, unblocked);
+  }
+
+  const unblock = queuedEvent => scheduleCallbackIfUnblocked(queuedEvent, unblocked);
+
+  queuedPointers.forEach(unblock);
+  queuedPointerCaptures.forEach(unblock);
+
+  for (let i = 0; i < queuedExplicitHydrationTargets.length; i++) {
+    const queuedTarget = queuedExplicitHydrationTargets[i];
+
+    if (queuedTarget.blockedOn === unblocked) {
+      queuedTarget.blockedOn = null;
+    }
+  }
+
+  while (queuedExplicitHydrationTargets.length > 0) {
+    const nextExplicitTarget = queuedExplicitHydrationTargets[0];
+
+    if (nextExplicitTarget.blockedOn !== null) {
+      // We're still blocked.
+      break;
+    } else {
+      attemptExplicitHydrationTarget(nextExplicitTarget);
+
+      if (nextExplicitTarget.blockedOn === null) {
+        // We're unblocked.
+        queuedExplicitHydrationTargets.shift();
+      }
+    }
+  }
+
+  {
+    // Check the document if there are any queued form actions.
+    const root = unblocked.getRootNode();
+    const formReplayingQueue = root.$$reactFormReplay;
+
+    if (formReplayingQueue != null) {
+      for (let i = 0; i < formReplayingQueue.length; i += 3) {
+        const form = formReplayingQueue[i];
+        const submitterOrAction = formReplayingQueue[i + 1];
+        const formProps = getFiberCurrentPropsFromNode(form);
+
+        if (typeof submitterOrAction === 'function') {
+          // This action has already resolved. We're just waiting to dispatch it.
+          if (!formProps) {
+            // This was not part of this React instance. It might have been recently
+            // unblocking us from dispatching our events. So let's make sure we schedule
+            // a retry.
+            scheduleReplayQueueIfNeeded(formReplayingQueue);
+          }
+
+          continue;
+        }
+
+        let target = form;
+
+        if (formProps) {
+          // This form belongs to this React instance but the submitter might
+          // not be done yet.
+          let action = null;
+          const submitter = submitterOrAction;
+
+          if (submitter && submitter.hasAttribute('formAction')) {
+            // The submitter is the one that is responsible for the action.
+            target = submitter;
+            const submitterProps = getFiberCurrentPropsFromNode(submitter);
+
+            if (submitterProps) {
+              // The submitter is part of this instance.
+              action = submitterProps.formAction;
+            } else {
+              const blockedOn = findInstanceBlockingTarget(target);
+
+              if (blockedOn !== null) {
+                // The submitter is not hydrated yet. We'll wait for it.
+                continue;
+              } // The submitter must have been a part of a different React instance.
+              // Except the form isn't. We don't dispatch actions in this scenario.
+
+            }
+          } else {
+            action = formProps.action;
+          }
+
+          if (typeof action === 'function') {
+            formReplayingQueue[i + 1] = action;
+          } else {
+            // Something went wrong so let's just delete this action.
+            formReplayingQueue.splice(i, 3);
+            i -= 3;
+          } // Schedule a replay in case this unblocked something.
+
+
+          scheduleReplayQueueIfNeeded(formReplayingQueue);
+          continue;
+        } // Something above this target is still blocked so we can't continue yet.
+        // We're not sure if this target is actually part of this React instance
+        // yet. It could be a different React as a child but at least some parent is.
+        // We must continue for any further queued actions.
+
+      }
+    }
+  }
+}
+
+const ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig; // TODO: can we stop exporting these?
+
+let _enabled = true; // This is exported in FB builds for use by legacy FB layer infra.
+// We'd like to remove this but it's not clear if this is safe.
+
+function setEnabled(enabled) {
+  _enabled = !!enabled;
+}
+function isEnabled() {
+  return _enabled;
+}
+function createEventListenerWrapperWithPriority(targetContainer, domEventName, eventSystemFlags) {
+  const eventPriority = getEventPriority(domEventName);
+  let listenerWrapper;
+
+  switch (eventPriority) {
+    case DiscreteEventPriority:
+      listenerWrapper = dispatchDiscreteEvent;
+      break;
+
+    case ContinuousEventPriority:
+      listenerWrapper = dispatchContinuousEvent;
+      break;
+
+    case DefaultEventPriority:
+    default:
+      listenerWrapper = dispatchEvent;
+      break;
+  }
+
+  return listenerWrapper.bind(null, domEventName, eventSystemFlags, targetContainer);
+}
+
+function dispatchDiscreteEvent(domEventName, eventSystemFlags, container, nativeEvent) {
+  const previousPriority = getCurrentUpdatePriority();
+  const prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
+
+  try {
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig.transition = prevTransition;
+  }
+}
+
+function dispatchContinuousEvent(domEventName, eventSystemFlags, container, nativeEvent) {
+  const previousPriority = getCurrentUpdatePriority();
+  const prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
+
+  try {
+    setCurrentUpdatePriority(ContinuousEventPriority);
+    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig.transition = prevTransition;
+  }
+}
+
+function dispatchEvent(domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+  if (!_enabled) {
+    return;
+  }
+
+  let blockedOn = findInstanceBlockingEvent(nativeEvent);
+
+  if (blockedOn === null) {
+    dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, return_targetInst, targetContainer);
+    clearIfContinuousEvent(domEventName, nativeEvent);
+    return;
+  }
+
+  if (queueIfContinuousEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent)) {
+    nativeEvent.stopPropagation();
+    return;
+  } // We need to clear only if we didn't queue because
+  // queueing is accumulative.
+
+
+  clearIfContinuousEvent(domEventName, nativeEvent);
+
+  if (eventSystemFlags & IS_CAPTURE_PHASE && isDiscreteEventThatRequiresHydration(domEventName)) {
+    while (blockedOn !== null) {
+      const fiber = getInstanceFromNode(blockedOn);
+
+      if (fiber !== null) {
+        attemptSynchronousHydration(fiber);
+      }
+
+      const nextBlockedOn = findInstanceBlockingEvent(nativeEvent);
+
+      if (nextBlockedOn === null) {
+        dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, return_targetInst, targetContainer);
+      }
+
+      if (nextBlockedOn === blockedOn) {
+        break;
+      }
+
+      blockedOn = nextBlockedOn;
+    }
+
+    if (blockedOn !== null) {
+      nativeEvent.stopPropagation();
+    }
+
+    return;
+  } // 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 findInstanceBlockingEvent(nativeEvent) {
+  const nativeEventTarget = getEventTarget(nativeEvent);
+  return findInstanceBlockingTarget(nativeEventTarget);
+}
+let return_targetInst = null; // Returns a SuspenseInstance or Container if it's blocked.
+// The return_targetInst field above is conceptually part of the return value.
+
+function findInstanceBlockingTarget(targetNode) {
+  // TODO: Warn if _enabled is false.
+  return_targetInst = null;
+  let targetInst = getClosestInstanceFromNode(targetNode);
+
+  if (targetInst !== null) {
+    const nearestMounted = getNearestMountedFiber(targetInst);
+
+    if (nearestMounted === null) {
+      // This tree has been unmounted already. Dispatch without a target.
+      targetInst = null;
+    } else {
+      const tag = nearestMounted.tag;
+
+      if (tag === SuspenseComponent) {
+        const instance = getSuspenseInstanceFromFiber(nearestMounted);
+
+        if (instance !== null) {
+          // Queue the event to be replayed later. Abort dispatching since we
+          // don't want this event dispatched twice through the event system.
+          // TODO: If this is the first discrete event in the queue. Schedule an increased
+          // priority for this boundary.
+          return instance;
+        } // This shouldn't happen, something went wrong but to avoid blocking
+        // the whole system, dispatch the event without a target.
+        // TODO: Warn.
+
+
+        targetInst = null;
+      } else if (tag === HostRoot) {
+        const root = nearestMounted.stateNode;
+
+        if (isRootDehydrated(root)) {
+          // If this happens during a replay something went wrong and it might block
+          // the whole system.
+          return getContainerFromFiber(nearestMounted);
+        }
+
+        targetInst = null;
+      } else if (nearestMounted !== targetInst) {
+        // If we get an event (ex: img onload) before committing that
+        // component's mount, ignore it for now (that is, treat it as if it was an
+        // event on a non-React tree). We might also consider queueing events and
+        // dispatching them after the mount.
+        targetInst = null;
+      }
+    }
+  }
+
+  return_targetInst = targetInst; // We're not blocked on anything.
+
+  return null;
+}
+function getEventPriority(domEventName) {
+  switch (domEventName) {
+    // Used by SimpleEventPlugin:
+    case 'cancel':
+    case 'click':
+    case 'close':
+    case 'contextmenu':
+    case 'copy':
+    case 'cut':
+    case 'auxclick':
+    case 'dblclick':
+    case 'dragend':
+    case 'dragstart':
+    case 'drop':
+    case 'focusin':
+    case 'focusout':
+    case 'input':
+    case 'invalid':
+    case 'keydown':
+    case 'keypress':
+    case 'keyup':
+    case 'mousedown':
+    case 'mouseup':
+    case 'paste':
+    case 'pause':
+    case 'play':
+    case 'pointercancel':
+    case 'pointerdown':
+    case 'pointerup':
+    case 'ratechange':
+    case 'reset':
+    case 'resize':
+    case 'seeked':
+    case 'submit':
+    case 'touchcancel':
+    case 'touchend':
+    case 'touchstart':
+    case 'volumechange': // Used by polyfills: (fall through)
+
+    case 'change':
+    case 'selectionchange':
+    case 'textInput':
+    case 'compositionstart':
+    case 'compositionend':
+    case 'compositionupdate': // Only enableCreateEventHandleAPI: (fall through)
+
+    case 'beforeblur':
+    case 'afterblur': // Not used by React but could be by user code: (fall through)
+
+    case 'beforeinput':
+    case 'blur':
+    case 'fullscreenchange':
+    case 'focus':
+    case 'hashchange':
+    case 'popstate':
+    case 'select':
+    case 'selectstart':
+      return DiscreteEventPriority;
+
+    case 'drag':
+    case 'dragenter':
+    case 'dragexit':
+    case 'dragleave':
+    case 'dragover':
+    case 'mousemove':
+    case 'mouseout':
+    case 'mouseover':
+    case 'pointermove':
+    case 'pointerout':
+    case 'pointerover':
+    case 'scroll':
+    case 'toggle':
+    case 'touchmove':
+    case 'wheel': // Not used by React but could be by user code: (fall through)
+
+    case 'mouseenter':
+    case 'mouseleave':
+    case 'pointerenter':
+    case 'pointerleave':
+      return ContinuousEventPriority;
+
+    case 'message':
+      {
+        // We might be in the Scheduler callback.
+        // Eventually this mechanism will be replaced by a check
+        // of the current priority on the native scheduler.
+        const schedulerPriority = getCurrentPriorityLevel();
+
+        switch (schedulerPriority) {
+          case ImmediatePriority:
+            return DiscreteEventPriority;
+
+          case UserBlockingPriority:
+            return ContinuousEventPriority;
+
+          case NormalPriority$1:
+          case LowPriority:
+            // TODO: Handle LowSchedulerPriority, somehow. Maybe the same lane as hydration.
+            return DefaultEventPriority;
+
+          case IdlePriority:
+            return IdleEventPriority;
+
+          default:
+            return DefaultEventPriority;
+        }
+      }
+
+    default:
+      return DefaultEventPriority;
+  }
+}
+
+function addEventBubbleListener(target, eventType, listener) {
+  target.addEventListener(eventType, listener, false);
+  return listener;
+}
+function addEventCaptureListener(target, eventType, listener) {
+  target.addEventListener(eventType, listener, true);
+  return listener;
+}
+function addEventCaptureListenerWithPassiveFlag(target, eventType, listener, passive) {
+  target.addEventListener(eventType, listener, {
+    capture: true,
+    passive
+  });
+  return listener;
+}
+function addEventBubbleListenerWithPassiveFlag(target, eventType, listener, passive) {
+  target.addEventListener(eventType, listener, {
+    passive
+  });
+  return listener;
+}
+
+/**
+ * These variables store information about text content of a target node,
+ * allowing comparison of content before and after a given event.
+ *
+ * Identify the node where selection currently begins, then observe
+ * both its text content and its current position in the DOM. Since the
+ * browser may natively replace the target node during composition, we can
+ * use its position to find its replacement.
+ *
+ *
+ */
+let root = null;
+let startText = null;
+let fallbackText = null;
+function initialize(nativeEventTarget) {
+  root = nativeEventTarget;
+  startText = getText();
+  return true;
+}
+function reset() {
+  root = null;
+  startText = null;
+  fallbackText = null;
+}
+function getData() {
+  if (fallbackText) {
+    return fallbackText;
+  }
+
+  let start;
+  const startValue = startText;
+  const startLength = startValue.length;
+  let end;
+  const endValue = getText();
+  const endLength = endValue.length;
+
+  for (start = 0; start < startLength; start++) {
+    if (startValue[start] !== endValue[start]) {
+      break;
+    }
+  }
+
+  const minEnd = startLength - start;
+
+  for (end = 1; end <= minEnd; end++) {
+    if (startValue[startLength - end] !== endValue[endLength - end]) {
+      break;
+    }
+  }
+
+  const sliceTail = end > 1 ? 1 - end : undefined;
+  fallbackText = endValue.slice(start, sliceTail);
+  return fallbackText;
+}
+function getText() {
+  if ('value' in root) {
+    return root.value;
+  }
+
+  return root.textContent;
+}
+
+const END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space
+
+const START_KEYCODE = 229;
+const canUseCompositionEvent = canUseDOM && 'CompositionEvent' in window;
+let documentMode = null;
+
+if (canUseDOM && 'documentMode' in document) {
+  documentMode = document.documentMode;
+} // Webkit offers a very useful `textInput` event that can be used to
+// directly represent `beforeInput`. The IE `textinput` event is not as
+// useful, so we don't use it.
+
+
+const canUseTextInputEvent = canUseDOM && 'TextEvent' in window && !documentMode; // In IE9+, we have access to composition events, but the data supplied
+// by the native compositionend event may be incorrect. Japanese ideographic
+// spaces, for instance (\u3000) are not recorded correctly.
+
+const useFallbackCompositionData = canUseDOM && (!canUseCompositionEvent || documentMode && documentMode > 8 && documentMode <= 11);
+const SPACEBAR_CODE = 32;
+const SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);
+
+function registerEvents$3() {
+  registerTwoPhaseEvent('onBeforeInput', ['compositionend', 'keypress', 'textInput', 'paste']);
+  registerTwoPhaseEvent('onCompositionEnd', ['compositionend', 'focusout', 'keydown', 'keypress', 'keyup', 'mousedown']);
+  registerTwoPhaseEvent('onCompositionStart', ['compositionstart', 'focusout', 'keydown', 'keypress', 'keyup', 'mousedown']);
+  registerTwoPhaseEvent('onCompositionUpdate', ['compositionupdate', 'focusout', 'keydown', 'keypress', 'keyup', 'mousedown']);
+} // Track whether we've ever handled a keypress on the space key.
+
+
+let hasSpaceKeypress = false;
+/**
+ * Return whether a native keypress event is assumed to be a command.
+ * This is required because Firefox fires `keypress` events for key commands
+ * (cut, copy, select-all, etc.) even though no character is inserted.
+ */
+
+function isKeypressCommand(nativeEvent) {
+  return (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) && // ctrlKey && altKey is equivalent to AltGr, and is not a command.
+  !(nativeEvent.ctrlKey && nativeEvent.altKey);
+}
+/**
+ * Translate native top level events into event types.
+ */
+
+
+function getCompositionEventType(domEventName) {
+  switch (domEventName) {
+    case 'compositionstart':
+      return 'onCompositionStart';
+
+    case 'compositionend':
+      return 'onCompositionEnd';
+
+    case 'compositionupdate':
+      return 'onCompositionUpdate';
+  }
+}
+/**
+ * Does our fallback best-guess model think this event signifies that
+ * composition has begun?
+ */
+
+
+function isFallbackCompositionStart(domEventName, nativeEvent) {
+  return domEventName === 'keydown' && nativeEvent.keyCode === START_KEYCODE;
+}
+/**
+ * Does our fallback mode think that this event is the end of composition?
+ */
+
+
+function isFallbackCompositionEnd(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case 'keyup':
+      // Command keys insert or clear IME input.
+      return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1;
+
+    case 'keydown':
+      // Expect IME keyCode on each keydown. If we get any other
+      // code we must have exited earlier.
+      return nativeEvent.keyCode !== START_KEYCODE;
+
+    case 'keypress':
+    case 'mousedown':
+    case 'focusout':
+      // Events are not possible without cancelling IME.
+      return true;
+
+    default:
+      return false;
+  }
+}
+/**
+ * Google Input Tools provides composition data via a CustomEvent,
+ * with the `data` property populated in the `detail` object. If this
+ * is available on the event object, use it. If not, this is a plain
+ * composition event and we have nothing special to extract.
+ *
+ * @param {object} nativeEvent
+ * @return {?string}
+ */
+
+
+function getDataFromCustomEvent(nativeEvent) {
+  const detail = nativeEvent.detail;
+
+  if (typeof detail === 'object' && 'data' in detail) {
+    return detail.data;
+  }
+
+  return null;
+}
+/**
+ * Check if a composition event was triggered by Korean IME.
+ * Our fallback mode does not work well with IE's Korean IME,
+ * so just use native composition events when Korean IME is used.
+ * Although CompositionEvent.locale property is deprecated,
+ * it is available in IE, where our fallback mode is enabled.
+ *
+ * @param {object} nativeEvent
+ * @return {boolean}
+ */
+
+
+function isUsingKoreanIME(nativeEvent) {
+  return nativeEvent.locale === 'ko';
+} // Track the current IME composition status, if any.
+
+
+let isComposing = false;
+/**
+ * @return {?object} A SyntheticCompositionEvent.
+ */
+
+function extractCompositionEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget) {
+  let eventType;
+  let fallbackData;
+
+  if (canUseCompositionEvent) {
+    eventType = getCompositionEventType(domEventName);
+  } else if (!isComposing) {
+    if (isFallbackCompositionStart(domEventName, nativeEvent)) {
+      eventType = 'onCompositionStart';
+    }
+  } else if (isFallbackCompositionEnd(domEventName, nativeEvent)) {
+    eventType = 'onCompositionEnd';
+  }
+
+  if (!eventType) {
+    return null;
+  }
+
+  if (useFallbackCompositionData && !isUsingKoreanIME(nativeEvent)) {
+    // The current composition is stored statically and must not be
+    // overwritten while composition continues.
+    if (!isComposing && eventType === 'onCompositionStart') {
+      isComposing = initialize(nativeEventTarget);
+    } else if (eventType === 'onCompositionEnd') {
+      if (isComposing) {
+        fallbackData = getData();
+      }
+    }
+  }
+
+  const listeners = accumulateTwoPhaseListeners(targetInst, eventType);
+
+  if (listeners.length > 0) {
+    const event = new SyntheticCompositionEvent(eventType, domEventName, null, nativeEvent, nativeEventTarget);
+    dispatchQueue.push({
+      event,
+      listeners
+    });
+
+    if (fallbackData) {
+      // Inject data generated from fallback path into the synthetic event.
+      // This matches the property of native CompositionEventInterface.
+      // $FlowFixMe[incompatible-use]
+      event.data = fallbackData;
+    } else {
+      const customData = getDataFromCustomEvent(nativeEvent);
+
+      if (customData !== null) {
+        // $FlowFixMe[incompatible-use]
+        event.data = customData;
+      }
+    }
+  }
+}
+
+function getNativeBeforeInputChars(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case 'compositionend':
+      return getDataFromCustomEvent(nativeEvent);
+
+    case 'keypress':
+      /**
+       * If native `textInput` events are available, our goal is to make
+       * use of them. However, there is a special case: the spacebar key.
+       * In Webkit, preventing default on a spacebar `textInput` event
+       * cancels character insertion, but it *also* causes the browser
+       * to fall back to its default spacebar behavior of scrolling the
+       * page.
+       *
+       * Tracking at:
+       * https://code.google.com/p/chromium/issues/detail?id=355103
+       *
+       * To avoid this issue, use the keypress event as if no `textInput`
+       * event is available.
+       */
+      const which = nativeEvent.which;
+
+      if (which !== SPACEBAR_CODE) {
+        return null;
+      }
+
+      hasSpaceKeypress = true;
+      return SPACEBAR_CHAR;
+
+    case 'textInput':
+      // Record the characters to be added to the DOM.
+      const chars = nativeEvent.data; // If it's a spacebar character, assume that we have already handled
+      // it at the keypress level and bail immediately. Android Chrome
+      // doesn't give us keycodes, so we need to ignore it.
+
+      if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {
+        return null;
+      }
+
+      return chars;
+
+    default:
+      // For other native event types, do nothing.
+      return null;
+  }
+}
+/**
+ * For browsers that do not provide the `textInput` event, extract the
+ * appropriate string to use for SyntheticInputEvent.
+ */
+
+
+function getFallbackBeforeInputChars(domEventName, nativeEvent) {
+  // If we are currently composing (IME) and using a fallback to do so,
+  // try to extract the composed characters from the fallback object.
+  // If composition event is available, we extract a string only at
+  // compositionevent, otherwise extract it at fallback events.
+  if (isComposing) {
+    if (domEventName === 'compositionend' || !canUseCompositionEvent && isFallbackCompositionEnd(domEventName, nativeEvent)) {
+      const chars = getData();
+      reset();
+      isComposing = false;
+      return chars;
+    }
+
+    return null;
+  }
+
+  switch (domEventName) {
+    case 'paste':
+      // If a paste event occurs after a keypress, throw out the input
+      // chars. Paste events should not lead to BeforeInput events.
+      return null;
+
+    case 'keypress':
+      /**
+       * As of v27, Firefox may fire keypress events even when no character
+       * will be inserted. A few possibilities:
+       *
+       * - `which` is `0`. Arrow keys, Esc key, etc.
+       *
+       * - `which` is the pressed key code, but no char is available.
+       *   Ex: 'AltGr + d` in Polish. There is no modified character for
+       *   this key combination and no character is inserted into the
+       *   document, but FF fires the keypress for char code `100` anyway.
+       *   No `input` event will occur.
+       *
+       * - `which` is the pressed key code, but a command combination is
+       *   being used. Ex: `Cmd+C`. No character is inserted, and no
+       *   `input` event will occur.
+       */
+      if (!isKeypressCommand(nativeEvent)) {
+        // IE fires the `keypress` event when a user types an emoji via
+        // Touch keyboard of Windows.  In such a case, the `char` property
+        // holds an emoji character like `\uD83D\uDE0A`.  Because its length
+        // is 2, the property `which` does not represent an emoji correctly.
+        // In such a case, we directly return the `char` property instead of
+        // using `which`.
+        if (nativeEvent.char && nativeEvent.char.length > 1) {
+          return nativeEvent.char;
+        } else if (nativeEvent.which) {
+          return String.fromCharCode(nativeEvent.which);
+        }
+      }
+
+      return null;
+
+    case 'compositionend':
+      return useFallbackCompositionData && !isUsingKoreanIME(nativeEvent) ? null : nativeEvent.data;
+
+    default:
+      return null;
+  }
+}
+/**
+ * Extract a SyntheticInputEvent for `beforeInput`, based on either native
+ * `textInput` or fallback behavior.
+ *
+ * @return {?object} A SyntheticInputEvent.
+ */
+
+
+function extractBeforeInputEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget) {
+  let chars;
+
+  if (canUseTextInputEvent) {
+    chars = getNativeBeforeInputChars(domEventName, nativeEvent);
+  } else {
+    chars = getFallbackBeforeInputChars(domEventName, nativeEvent);
+  } // If no characters are being inserted, no BeforeInput event should
+  // be fired.
+
+
+  if (!chars) {
+    return null;
+  }
+
+  const listeners = accumulateTwoPhaseListeners(targetInst, 'onBeforeInput');
+
+  if (listeners.length > 0) {
+    const event = new SyntheticInputEvent('onBeforeInput', 'beforeinput', null, nativeEvent, nativeEventTarget);
+    dispatchQueue.push({
+      event,
+      listeners
+    }); // $FlowFixMe[incompatible-use]
+
+    event.data = chars;
+  }
+}
+/**
+ * Create an `onBeforeInput` event to match
+ * http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.
+ *
+ * This event plugin is based on the native `textInput` event
+ * available in Chrome, Safari, Opera, and IE. This event fires after
+ * `onKeyPress` and `onCompositionEnd`, but before `onInput`.
+ *
+ * `beforeInput` is spec'd but not implemented in any browsers, and
+ * the `input` event does not provide any useful information about what has
+ * actually been added, contrary to the spec. Thus, `textInput` is the best
+ * available event to identify the characters that have actually been inserted
+ * into the target node.
+ *
+ * This plugin is also responsible for emitting `composition` events, thus
+ * allowing us to share composition fallback code for both `beforeInput` and
+ * `composition` event types.
+ */
+
+
+function extractEvents$5(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  extractCompositionEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+  extractBeforeInputEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+}
+
+/**
+ * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary
+ */
+const supportedInputTypes = {
+  color: true,
+  date: true,
+  datetime: true,
+  'datetime-local': true,
+  email: true,
+  month: true,
+  number: true,
+  password: true,
+  range: true,
+  search: true,
+  tel: true,
+  text: true,
+  time: true,
+  url: true,
+  week: true
+};
+
+function isTextInputElement(elem) {
+  const nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+
+  if (nodeName === 'input') {
+    return !!supportedInputTypes[elem.type];
+  }
+
+  if (nodeName === 'textarea') {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Checks if an event is supported in the current execution environment.
+ *
+ * NOTE: This will not work correctly for non-generic events such as `change`,
+ * `reset`, `load`, `error`, and `select`.
+ *
+ * Borrows from Modernizr.
+ *
+ * @param {string} eventNameSuffix Event name, e.g. "click".
+ * @return {boolean} True if the event is supported.
+ * @internal
+ * @license Modernizr 3.0.0pre (Custom Build) | MIT
+ */
+
+function isEventSupported(eventNameSuffix) {
+  if (!canUseDOM) {
+    return false;
+  }
+
+  const eventName = 'on' + eventNameSuffix;
+  let isSupported = (eventName in document);
+
+  if (!isSupported) {
+    const element = document.createElement('div');
+    element.setAttribute(eventName, 'return;');
+    isSupported = typeof element[eventName] === 'function';
+  }
+
+  return isSupported;
+}
+
+function registerEvents$2() {
+  registerTwoPhaseEvent('onChange', ['change', 'click', 'focusin', 'focusout', 'input', 'keydown', 'keyup', 'selectionchange']);
+}
+
+function createAndAccumulateChangeEvent(dispatchQueue, inst, nativeEvent, target) {
+  // Flag this event loop as needing state restore.
+  enqueueStateRestore(target);
+  const listeners = accumulateTwoPhaseListeners(inst, 'onChange');
+
+  if (listeners.length > 0) {
+    const event = new SyntheticEvent('onChange', 'change', null, nativeEvent, target);
+    dispatchQueue.push({
+      event,
+      listeners
+    });
+  }
+}
+/**
+ * For IE shims
+ */
+
+
+let activeElement$1 = null;
+let activeElementInst$1 = null;
+/**
+ * SECTION: handle `change` event
+ */
+
+function shouldUseChangeEvent(elem) {
+  const nodeName = elem.nodeName && elem.nodeName.toLowerCase();
+  return nodeName === 'select' || nodeName === 'input' && elem.type === 'file';
+}
+
+function manualDispatchChangeEvent(nativeEvent) {
+  const dispatchQueue = [];
+  createAndAccumulateChangeEvent(dispatchQueue, activeElementInst$1, nativeEvent, getEventTarget(nativeEvent)); // If change and propertychange bubbled, we'd just bind to it like all the
+  // other events and have it go through ReactBrowserEventEmitter. Since it
+  // doesn't, we manually listen for the events and so we have to enqueue and
+  // process the abstract event manually.
+  //
+  // Batching is necessary here in order to ensure that all event handlers run
+  // before the next rerender (including event handlers attached to ancestor
+  // elements instead of directly on the input). Without this, controlled
+  // components don't work properly in conjunction with event bubbling because
+  // the component is rerendered and the value reverted before all the event
+  // handlers can run. See https://github.com/facebook/react/issues/708.
+
+  batchedUpdates(runEventInBatch, dispatchQueue);
+}
+
+function runEventInBatch(dispatchQueue) {
+  processDispatchQueue(dispatchQueue, 0);
+}
+
+function getInstIfValueChanged(targetInst) {
+  const targetNode = getNodeFromInstance(targetInst);
+
+  if (updateValueIfChanged(targetNode)) {
+    return targetInst;
+  }
+}
+
+function getTargetInstForChangeEvent(domEventName, targetInst) {
+  if (domEventName === 'change') {
+    return targetInst;
+  }
+}
+/**
+ * SECTION: handle `input` event
+ */
+
+
+let isInputEventSupported = false;
+
+if (canUseDOM) {
+  // IE9 claims to support the input event but fails to trigger it when
+  // deleting text, so we ignore its input events.
+  isInputEventSupported = isEventSupported('input') && (!document.documentMode || document.documentMode > 9);
+}
+/**
+ * (For IE <=9) Starts tracking propertychange events on the passed-in element
+ * and override the value property so that we can distinguish user events from
+ * value changes in JS.
+ */
+
+
+function startWatchingForValueChange(target, targetInst) {
+  activeElement$1 = target;
+  activeElementInst$1 = targetInst;
+  activeElement$1.attachEvent('onpropertychange', handlePropertyChange);
+}
+/**
+ * (For IE <=9) Removes the event listeners from the currently-tracked element,
+ * if any exists.
+ */
+
+
+function stopWatchingForValueChange() {
+  if (!activeElement$1) {
+    return;
+  }
+
+  activeElement$1.detachEvent('onpropertychange', handlePropertyChange);
+  activeElement$1 = null;
+  activeElementInst$1 = null;
+}
+/**
+ * (For IE <=9) Handles a propertychange event, sending a `change` event if
+ * the value of the active element has changed.
+ */
+// $FlowFixMe[missing-local-annot]
+
+
+function handlePropertyChange(nativeEvent) {
+  if (nativeEvent.propertyName !== 'value') {
+    return;
+  }
+
+  if (getInstIfValueChanged(activeElementInst$1)) {
+    manualDispatchChangeEvent(nativeEvent);
+  }
+}
+
+function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
+  if (domEventName === 'focusin') {
+    // In IE9, propertychange fires for most input events but is buggy and
+    // doesn't fire when text is deleted, but conveniently, selectionchange
+    // appears to fire in all of the remaining cases so we catch those and
+    // forward the event if the value has changed
+    // In either case, we don't want to call the event handler if the value
+    // is changed from JS so we redefine a setter for `.value` that updates
+    // our activeElementValue variable, allowing us to ignore those changes
+    //
+    // stopWatching() should be a noop here but we call it just in case we
+    // missed a blur event somehow.
+    stopWatchingForValueChange();
+    startWatchingForValueChange(target, targetInst);
+  } else if (domEventName === 'focusout') {
+    stopWatchingForValueChange();
+  }
+} // For IE8 and IE9.
+
+
+function getTargetInstForInputEventPolyfill(domEventName, targetInst) {
+  if (domEventName === 'selectionchange' || domEventName === 'keyup' || domEventName === 'keydown') {
+    // On the selectionchange event, the target is just document which isn't
+    // helpful for us so just check activeElement instead.
+    //
+    // 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire
+    // propertychange on the first input event after setting `value` from a
+    // script and fires only keydown, keypress, keyup. Catching keyup usually
+    // gets it and catching keydown lets us fire an event for the first
+    // keystroke if user does a key repeat (it'll be a little delayed: right
+    // before the second keystroke). Other input methods (e.g., paste) seem to
+    // fire selectionchange normally.
+    return getInstIfValueChanged(activeElementInst$1);
+  }
+}
+/**
+ * SECTION: handle `click` event
+ */
+
+
+function shouldUseClickEvent(elem) {
+  // Use the `click` event to detect changes to checkbox and radio inputs.
+  // This approach works across all browsers, whereas `change` does not fire
+  // until `blur` in IE8.
+  const nodeName = elem.nodeName;
+  return nodeName && nodeName.toLowerCase() === 'input' && (elem.type === 'checkbox' || elem.type === 'radio');
+}
+
+function getTargetInstForClickEvent(domEventName, targetInst) {
+  if (domEventName === 'click') {
+    return getInstIfValueChanged(targetInst);
+  }
+}
+
+function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
+  if (domEventName === 'input' || domEventName === 'change') {
+    return getInstIfValueChanged(targetInst);
+  }
+}
+
+function handleControlledInputBlur(node, props) {
+  if (node.type !== 'number') {
+    return;
+  }
+
+  {
+    const isControlled = props.value != null;
+
+    if (isControlled) {
+      // If controlled, assign the value attribute to the current value on blur
+      setDefaultValue(node, 'number', node.value);
+    }
+  }
+}
+/**
+ * This plugin creates an `onChange` event that normalizes change events
+ * across form elements. This event fires at a time when it's possible to
+ * change the element's value without seeing a flicker.
+ *
+ * Supported elements are:
+ * - input (see `isTextInputElement`)
+ * - textarea
+ * - select
+ */
+
+
+function extractEvents$4(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  const targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
+  let getTargetInstFunc, handleEventFunc;
+
+  if (shouldUseChangeEvent(targetNode)) {
+    getTargetInstFunc = getTargetInstForChangeEvent;
+  } else if (isTextInputElement(targetNode)) {
+    if (isInputEventSupported) {
+      getTargetInstFunc = getTargetInstForInputOrChangeEvent;
+    } else {
+      getTargetInstFunc = getTargetInstForInputEventPolyfill;
+      handleEventFunc = handleEventsForInputEventPolyfill;
+    }
+  } else if (shouldUseClickEvent(targetNode)) {
+    getTargetInstFunc = getTargetInstForClickEvent;
+  } else ;
+
+  if (getTargetInstFunc) {
+    const inst = getTargetInstFunc(domEventName, targetInst);
+
+    if (inst) {
+      createAndAccumulateChangeEvent(dispatchQueue, inst, nativeEvent, nativeEventTarget);
+      return;
+    }
+  }
+
+  if (handleEventFunc) {
+    handleEventFunc(domEventName, targetNode, targetInst);
+  } // When blurring, set the value attribute for number inputs
+
+
+  if (domEventName === 'focusout' && targetInst) {
+    // These props aren't necessarily the most current but we warn for changing
+    // between controlled and uncontrolled, so it doesn't matter and the previous
+    // code was also broken for changes.
+    const props = targetInst.memoizedProps;
+    handleControlledInputBlur(targetNode, props);
+  }
+}
+
+function registerEvents$1() {
+  registerDirectEvent('onMouseEnter', ['mouseout', 'mouseover']);
+  registerDirectEvent('onMouseLeave', ['mouseout', 'mouseover']);
+  registerDirectEvent('onPointerEnter', ['pointerout', 'pointerover']);
+  registerDirectEvent('onPointerLeave', ['pointerout', 'pointerover']);
+}
+/**
+ * For almost every interaction we care about, there will be both a top-level
+ * `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that
+ * we do not extract duplicate events. However, moving the mouse into the
+ * browser from outside will not fire a `mouseout` event. In this case, we use
+ * the `mouseover` top-level event.
+ */
+
+
+function extractEvents$3(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  const isOverEvent = domEventName === 'mouseover' || domEventName === 'pointerover';
+  const isOutEvent = domEventName === 'mouseout' || domEventName === 'pointerout';
+
+  if (isOverEvent && !isReplayingEvent(nativeEvent)) {
+    // If this is an over event with a target, we might have already dispatched
+    // the event in the out event of the other target. If this is replayed,
+    // then it's because we couldn't dispatch against this target previously
+    // so we have to do it now instead.
+    const related = nativeEvent.relatedTarget || nativeEvent.fromElement;
+
+    if (related) {
+      // If the related node is managed by React, we can assume that we have
+      // already dispatched the corresponding events during its mouseout.
+      if (getClosestInstanceFromNode(related) || isContainerMarkedAsRoot(related)) {
+        return;
+      }
+    }
+  }
+
+  if (!isOutEvent && !isOverEvent) {
+    // Must not be a mouse or pointer in or out - ignoring.
+    return;
+  }
+
+  let win; // TODO: why is this nullable in the types but we read from it?
+
+  if (nativeEventTarget.window === nativeEventTarget) {
+    // `nativeEventTarget` is probably a window object.
+    win = nativeEventTarget;
+  } else {
+    // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.
+    const doc = nativeEventTarget.ownerDocument;
+
+    if (doc) {
+      win = doc.defaultView || doc.parentWindow;
+    } else {
+      win = window;
+    }
+  }
+
+  let from;
+  let to;
+
+  if (isOutEvent) {
+    const related = nativeEvent.relatedTarget || nativeEvent.toElement;
+    from = targetInst;
+    to = related ? getClosestInstanceFromNode(related) : null;
+
+    if (to !== null) {
+      const nearestMounted = getNearestMountedFiber(to);
+      const tag = to.tag;
+
+      if (to !== nearestMounted || tag !== HostComponent && (tag !== HostSingleton) && tag !== HostText) {
+        to = null;
+      }
+    }
+  } else {
+    // Moving to a node from outside the window.
+    from = null;
+    to = targetInst;
+  }
+
+  if (from === to) {
+    // Nothing pertains to our managed components.
+    return;
+  }
+
+  let SyntheticEventCtor = SyntheticMouseEvent;
+  let leaveEventType = 'onMouseLeave';
+  let enterEventType = 'onMouseEnter';
+  let eventTypePrefix = 'mouse';
+
+  if (domEventName === 'pointerout' || domEventName === 'pointerover') {
+    SyntheticEventCtor = SyntheticPointerEvent;
+    leaveEventType = 'onPointerLeave';
+    enterEventType = 'onPointerEnter';
+    eventTypePrefix = 'pointer';
+  }
+
+  const fromNode = from == null ? win : getNodeFromInstance(from);
+  const toNode = to == null ? win : getNodeFromInstance(to);
+  const leave = new SyntheticEventCtor(leaveEventType, eventTypePrefix + 'leave', from, nativeEvent, nativeEventTarget);
+  leave.target = fromNode;
+  leave.relatedTarget = toNode;
+  let enter = null; // We should only process this nativeEvent if we are processing
+  // the first ancestor. Next time, we will ignore the event.
+
+  const nativeTargetInst = getClosestInstanceFromNode(nativeEventTarget);
+
+  if (nativeTargetInst === targetInst) {
+    const enterEvent = new SyntheticEventCtor(enterEventType, eventTypePrefix + 'enter', to, nativeEvent, nativeEventTarget);
+    enterEvent.target = toNode;
+    enterEvent.relatedTarget = fromNode;
+    enter = enterEvent;
+  }
+
+  accumulateEnterLeaveTwoPhaseListeners(dispatchQueue, leave, enter, from, to);
+}
+
+/**
+ * Given any node return the first leaf node without children.
+ *
+ * @param {DOMElement|DOMTextNode} node
+ * @return {DOMElement|DOMTextNode}
+ */
+
+function getLeafNode(node) {
+  while (node && node.firstChild) {
+    node = node.firstChild;
+  }
+
+  return node;
+}
+/**
+ * Get the next sibling within a container. This will walk up the
+ * DOM if a node's siblings have been exhausted.
+ *
+ * @param {DOMElement|DOMTextNode} node
+ * @return {?DOMElement|DOMTextNode}
+ */
+
+
+function getSiblingNode(node) {
+  while (node) {
+    if (node.nextSibling) {
+      return node.nextSibling;
+    }
+
+    node = node.parentNode;
+  }
+}
+/**
+ * Get object describing the nodes which contain characters at offset.
+ *
+ * @param {DOMElement|DOMTextNode} root
+ * @param {number} offset
+ * @return {?object}
+ */
+
+
+function getNodeForCharacterOffset(root, offset) {
+  let node = getLeafNode(root);
+  let nodeStart = 0;
+  let nodeEnd = 0;
+
+  while (node) {
+    if (node.nodeType === TEXT_NODE) {
+      nodeEnd = nodeStart + node.textContent.length;
+
+      if (nodeStart <= offset && nodeEnd >= offset) {
+        return {
+          node: node,
+          offset: offset - nodeStart
+        };
+      }
+
+      nodeStart = nodeEnd;
+    }
+
+    node = getLeafNode(getSiblingNode(node));
+  }
+}
+
+/**
+ * @param {DOMElement} outerNode
+ * @return {?object}
+ */
+
+function getOffsets(outerNode) {
+  const ownerDocument = outerNode.ownerDocument;
+  const win = ownerDocument && ownerDocument.defaultView || window;
+  const selection = win.getSelection && win.getSelection();
+
+  if (!selection || selection.rangeCount === 0) {
+    return null;
+  }
+
+  const anchorNode = selection.anchorNode,
+        anchorOffset = selection.anchorOffset,
+        focusNode = selection.focusNode,
+        focusOffset = selection.focusOffset; // In Firefox, anchorNode and focusNode can be "anonymous divs", e.g. the
+  // up/down buttons on an <input type="number">. Anonymous divs do not seem to
+  // expose properties, triggering a "Permission denied error" if any of its
+  // properties are accessed. The only seemingly possible way to avoid erroring
+  // is to access a property that typically works for non-anonymous divs and
+  // catch any error that may otherwise arise. See
+  // https://bugzilla.mozilla.org/show_bug.cgi?id=208427
+
+  try {
+    /* eslint-disable ft-flow/no-unused-expressions */
+    anchorNode.nodeType;
+    focusNode.nodeType;
+    /* eslint-enable ft-flow/no-unused-expressions */
+  } catch (e) {
+    return null;
+  }
+
+  return getModernOffsetsFromPoints(outerNode, anchorNode, anchorOffset, focusNode, focusOffset);
+}
+/**
+ * Returns {start, end} where `start` is the character/codepoint index of
+ * (anchorNode, anchorOffset) within the textContent of `outerNode`, and
+ * `end` is the index of (focusNode, focusOffset).
+ *
+ * Returns null if you pass in garbage input but we should probably just crash.
+ *
+ * Exported only for testing.
+ */
+
+function getModernOffsetsFromPoints(outerNode, anchorNode, anchorOffset, focusNode, focusOffset) {
+  let length = 0;
+  let start = -1;
+  let end = -1;
+  let indexWithinAnchor = 0;
+  let indexWithinFocus = 0;
+  let node = outerNode;
+  let parentNode = null;
+
+  outer: while (true) {
+    let next = null;
+
+    while (true) {
+      if (node === anchorNode && (anchorOffset === 0 || node.nodeType === TEXT_NODE)) {
+        start = length + anchorOffset;
+      }
+
+      if (node === focusNode && (focusOffset === 0 || node.nodeType === TEXT_NODE)) {
+        end = length + focusOffset;
+      }
+
+      if (node.nodeType === TEXT_NODE) {
+        length += node.nodeValue.length;
+      }
+
+      if ((next = node.firstChild) === null) {
+        break;
+      } // Moving from `node` to its first child `next`.
+
+
+      parentNode = node;
+      node = next;
+    }
+
+    while (true) {
+      if (node === outerNode) {
+        // If `outerNode` has children, this is always the second time visiting
+        // it. If it has no children, this is still the first loop, and the only
+        // valid selection is anchorNode and focusNode both equal to this node
+        // and both offsets 0, in which case we will have handled above.
+        break outer;
+      }
+
+      if (parentNode === anchorNode && ++indexWithinAnchor === anchorOffset) {
+        start = length;
+      }
+
+      if (parentNode === focusNode && ++indexWithinFocus === focusOffset) {
+        end = length;
+      }
+
+      if ((next = node.nextSibling) !== null) {
+        break;
+      }
+
+      node = parentNode;
+      parentNode = node.parentNode;
+    } // Moving from `node` to its next sibling `next`.
+
+
+    node = next;
+  }
+
+  if (start === -1 || end === -1) {
+    // This should never happen. (Would happen if the anchor/focus nodes aren't
+    // actually inside the passed-in node.)
+    return null;
+  }
+
+  return {
+    start: start,
+    end: end
+  };
+}
+/**
+ * In modern non-IE browsers, we can support both forward and backward
+ * selections.
+ *
+ * Note: IE10+ supports the Selection object, but it does not support
+ * the `extend` method, which means that even in modern IE, it's not possible
+ * to programmatically create a backward selection. Thus, for all IE
+ * versions, we use the old IE API to create our selections.
+ *
+ * @param {DOMElement|DOMTextNode} node
+ * @param {object} offsets
+ */
+
+function setOffsets(node, offsets) {
+  const doc = node.ownerDocument || document;
+  const win = doc && doc.defaultView || window; // Edge fails with "Object expected" in some scenarios.
+  // (For instance: TinyMCE editor used in a list component that supports pasting to add more,
+  // fails when pasting 100+ items)
+
+  if (!win.getSelection) {
+    return;
+  }
+
+  const selection = win.getSelection();
+  const length = node.textContent.length;
+  let start = Math.min(offsets.start, length);
+  let end = offsets.end === undefined ? start : Math.min(offsets.end, length); // IE 11 uses modern selection, but doesn't support the extend method.
+  // Flip backward selections, so we can set with a single range.
+
+  if (!selection.extend && start > end) {
+    const temp = end;
+    end = start;
+    start = temp;
+  }
+
+  const startMarker = getNodeForCharacterOffset(node, start);
+  const endMarker = getNodeForCharacterOffset(node, end);
+
+  if (startMarker && endMarker) {
+    if (selection.rangeCount === 1 && selection.anchorNode === startMarker.node && selection.anchorOffset === startMarker.offset && selection.focusNode === endMarker.node && selection.focusOffset === endMarker.offset) {
+      return;
+    }
+
+    const range = doc.createRange();
+    range.setStart(startMarker.node, startMarker.offset);
+    selection.removeAllRanges();
+
+    if (start > end) {
+      selection.addRange(range);
+      selection.extend(endMarker.node, endMarker.offset);
+    } else {
+      range.setEnd(endMarker.node, endMarker.offset);
+      selection.addRange(range);
+    }
+  }
+}
+
+function isTextNode(node) {
+  return node && node.nodeType === TEXT_NODE;
+}
+
+function containsNode(outerNode, innerNode) {
+  if (!outerNode || !innerNode) {
+    return false;
+  } else if (outerNode === innerNode) {
+    return true;
+  } else if (isTextNode(outerNode)) {
+    return false;
+  } else if (isTextNode(innerNode)) {
+    return containsNode(outerNode, innerNode.parentNode);
+  } else if ('contains' in outerNode) {
+    return outerNode.contains(innerNode);
+  } else if (outerNode.compareDocumentPosition) {
+    return !!(outerNode.compareDocumentPosition(innerNode) & 16);
+  } else {
+    return false;
+  }
+}
+
+function isInDocument(node) {
+  return node && node.ownerDocument && containsNode(node.ownerDocument.documentElement, node);
+}
+
+function isSameOriginFrame(iframe) {
+  try {
+    // Accessing the contentDocument of a HTMLIframeElement can cause the browser
+    // to throw, e.g. if it has a cross-origin src attribute.
+    // Safari will show an error in the console when the access results in "Blocked a frame with origin". e.g:
+    // iframe.contentDocument.defaultView;
+    // A safety way is to access one of the cross origin properties: Window or Location
+    // Which might result in "SecurityError" DOM Exception and it is compatible to Safari.
+    // https://html.spec.whatwg.org/multipage/browsers.html#integration-with-idl
+    return typeof iframe.contentWindow.location.href === 'string';
+  } catch (err) {
+    return false;
+  }
+}
+
+function getActiveElementDeep() {
+  let win = window;
+  let element = getActiveElement();
+
+  while (element instanceof win.HTMLIFrameElement) {
+    if (isSameOriginFrame(element)) {
+      win = element.contentWindow;
+    } else {
+      return element;
+    }
+
+    element = getActiveElement(win.document);
+  }
+
+  return element;
+}
+/**
+ * @ReactInputSelection: React input selection module. Based on Selection.js,
+ * but modified to be suitable for react and has a couple of bug fixes (doesn't
+ * assume buttons have range selections allowed).
+ * Input selection module for React.
+ */
+
+/**
+ * @hasSelectionCapabilities: we get the element types that support selection
+ * from https://html.spec.whatwg.org/#do-not-apply, looking at `selectionStart`
+ * and `selectionEnd` rows.
+ */
+
+
+function hasSelectionCapabilities(elem) {
+  const nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+  return nodeName && (nodeName === 'input' && (elem.type === 'text' || elem.type === 'search' || elem.type === 'tel' || elem.type === 'url' || elem.type === 'password') || nodeName === 'textarea' || elem.contentEditable === 'true');
+}
+function getSelectionInformation() {
+  const focusedElem = getActiveElementDeep();
+  return {
+    focusedElem: focusedElem,
+    selectionRange: hasSelectionCapabilities(focusedElem) ? getSelection$1(focusedElem) : null
+  };
+}
+/**
+ * @restoreSelection: If any selection information was potentially lost,
+ * restore it. This is useful when performing operations that could remove dom
+ * nodes and place them back in, resulting in focus being lost.
+ */
+
+function restoreSelection(priorSelectionInformation) {
+  const curFocusedElem = getActiveElementDeep();
+  const priorFocusedElem = priorSelectionInformation.focusedElem;
+  const priorSelectionRange = priorSelectionInformation.selectionRange;
+
+  if (curFocusedElem !== priorFocusedElem && isInDocument(priorFocusedElem)) {
+    if (priorSelectionRange !== null && hasSelectionCapabilities(priorFocusedElem)) {
+      setSelection(priorFocusedElem, priorSelectionRange);
+    } // Focusing a node can change the scroll position, which is undesirable
+
+
+    const ancestors = [];
+    let ancestor = priorFocusedElem;
+
+    while (ancestor = ancestor.parentNode) {
+      if (ancestor.nodeType === ELEMENT_NODE) {
+        ancestors.push({
+          element: ancestor,
+          left: ancestor.scrollLeft,
+          top: ancestor.scrollTop
+        });
+      }
+    }
+
+    if (typeof priorFocusedElem.focus === 'function') {
+      priorFocusedElem.focus();
+    }
+
+    for (let i = 0; i < ancestors.length; i++) {
+      const info = ancestors[i];
+      info.element.scrollLeft = info.left;
+      info.element.scrollTop = info.top;
+    }
+  }
+}
+/**
+ * @getSelection: Gets the selection bounds of a focused textarea, input or
+ * contentEditable node.
+ * -@input: Look up selection bounds of this input
+ * -@return {start: selectionStart, end: selectionEnd}
+ */
+
+function getSelection$1(input) {
+  let selection;
+
+  if ('selectionStart' in input) {
+    // Modern browser with input or textarea.
+    selection = {
+      start: input.selectionStart,
+      end: input.selectionEnd
+    };
+  } else {
+    // Content editable or old IE textarea.
+    selection = getOffsets(input);
+  }
+
+  return selection || {
+    start: 0,
+    end: 0
+  };
+}
+/**
+ * @setSelection: Sets the selection bounds of a textarea or input and focuses
+ * the input.
+ * -@input     Set selection bounds of this input or textarea
+ * -@offsets   Object of same form that is returned from get*
+ */
+
+function setSelection(input, offsets) {
+  const start = offsets.start;
+  let end = offsets.end;
+
+  if (end === undefined) {
+    end = start;
+  }
+
+  if ('selectionStart' in input) {
+    input.selectionStart = start;
+    input.selectionEnd = Math.min(end, input.value.length);
+  } else {
+    setOffsets(input, offsets);
+  }
+}
+
+const skipSelectionChangeEvent = canUseDOM && 'documentMode' in document && document.documentMode <= 11;
+
+function registerEvents() {
+  registerTwoPhaseEvent('onSelect', ['focusout', 'contextmenu', 'dragend', 'focusin', 'keydown', 'keyup', 'mousedown', 'mouseup', 'selectionchange']);
+}
+
+let activeElement = null;
+let activeElementInst = null;
+let lastSelection = null;
+let mouseDown = false;
+/**
+ * Get an object which is a unique representation of the current selection.
+ *
+ * The return value will not be consistent across nodes or browsers, but
+ * two identical selections on the same node will return identical objects.
+ */
+
+function getSelection(node) {
+  if ('selectionStart' in node && hasSelectionCapabilities(node)) {
+    return {
+      start: node.selectionStart,
+      end: node.selectionEnd
+    };
+  } else {
+    const win = node.ownerDocument && node.ownerDocument.defaultView || window;
+    const selection = win.getSelection();
+    return {
+      anchorNode: selection.anchorNode,
+      anchorOffset: selection.anchorOffset,
+      focusNode: selection.focusNode,
+      focusOffset: selection.focusOffset
+    };
+  }
+}
+/**
+ * Get document associated with the event target.
+ */
+
+
+function getEventTargetDocument(eventTarget) {
+  return eventTarget.window === eventTarget ? eventTarget.document : eventTarget.nodeType === DOCUMENT_NODE ? eventTarget : eventTarget.ownerDocument;
+}
+/**
+ * Poll selection to see whether it's changed.
+ *
+ * @param {object} nativeEvent
+ * @param {object} nativeEventTarget
+ * @return {?SyntheticEvent}
+ */
+
+
+function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
+  // Ensure we have the right element, and that the user is not dragging a
+  // selection (this matches native `select` event behavior). In HTML5, select
+  // fires only on input and textarea thus if there's no focused element we
+  // won't dispatch.
+  const doc = getEventTargetDocument(nativeEventTarget);
+
+  if (mouseDown || activeElement == null || activeElement !== getActiveElement(doc)) {
+    return;
+  } // Only fire when selection has actually changed.
+
+
+  const currentSelection = getSelection(activeElement);
+
+  if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {
+    lastSelection = currentSelection;
+    const listeners = accumulateTwoPhaseListeners(activeElementInst, 'onSelect');
+
+    if (listeners.length > 0) {
+      const event = new SyntheticEvent('onSelect', 'select', null, nativeEvent, nativeEventTarget);
+      dispatchQueue.push({
+        event,
+        listeners
+      });
+      event.target = activeElement;
+    }
+  }
+}
+/**
+ * This plugin creates an `onSelect` event that normalizes select events
+ * across form elements.
+ *
+ * Supported elements are:
+ * - input (see `isTextInputElement`)
+ * - textarea
+ * - contentEditable
+ *
+ * This differs from native browser implementations in the following ways:
+ * - Fires on contentEditable fields as well as inputs.
+ * - Fires for collapsed selection.
+ * - Fires after user input.
+ */
+
+
+function extractEvents$2(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  const targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
+
+  switch (domEventName) {
+    // Track the input node that has focus.
+    case 'focusin':
+      if (isTextInputElement(targetNode) || targetNode.contentEditable === 'true') {
+        activeElement = targetNode;
+        activeElementInst = targetInst;
+        lastSelection = null;
+      }
+
+      break;
+
+    case 'focusout':
+      activeElement = null;
+      activeElementInst = null;
+      lastSelection = null;
+      break;
+    // Don't fire the event while the user is dragging. This matches the
+    // semantics of the native select event.
+
+    case 'mousedown':
+      mouseDown = true;
+      break;
+
+    case 'contextmenu':
+    case 'mouseup':
+    case 'dragend':
+      mouseDown = false;
+      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+      break;
+    // Chrome and IE fire non-standard event when selection is changed (and
+    // sometimes when it hasn't). IE's event fires out of order with respect
+    // to key and input events on deletion, so we discard it.
+    //
+    // Firefox doesn't support selectionchange, so check selection status
+    // after each key entry. The selection changes after keydown and before
+    // keyup, but we check on keydown as well in the case of holding down a
+    // key, when multiple keydown events are fired but only one keyup is.
+    // This is also our approach for IE handling, for the reason above.
+
+    case 'selectionchange':
+      if (skipSelectionChangeEvent) {
+        break;
+      }
+
+    // falls through
+
+    case 'keydown':
+    case 'keyup':
+      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+  }
+}
+
+/**
+ * Generate a mapping of standard vendor prefixes using the defined style property and event name.
+ *
+ * @param {string} styleProp
+ * @param {string} eventName
+ * @returns {object}
+ */
+
+function makePrefixMap(styleProp, eventName) {
+  const prefixes = {};
+  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
+  prefixes['Webkit' + styleProp] = 'webkit' + eventName;
+  prefixes['Moz' + styleProp] = 'moz' + eventName;
+  return prefixes;
+}
+/**
+ * A list of event names to a configurable list of vendor prefixes.
+ */
+
+
+const vendorPrefixes = {
+  animationend: makePrefixMap('Animation', 'AnimationEnd'),
+  animationiteration: makePrefixMap('Animation', 'AnimationIteration'),
+  animationstart: makePrefixMap('Animation', 'AnimationStart'),
+  transitionend: makePrefixMap('Transition', 'TransitionEnd')
+};
+/**
+ * Event names that have already been detected and prefixed (if applicable).
+ */
+
+const prefixedEventNames = {};
+/**
+ * Element to check for prefixes on.
+ */
+
+let style = {};
+/**
+ * Bootstrap if a DOM exists.
+ */
+
+if (canUseDOM) {
+  style = document.createElement('div').style; // On some platforms, in particular some releases of Android 4.x,
+  // the un-prefixed "animation" and "transition" properties are defined on the
+  // style object but the events that fire will still be prefixed, so we need
+  // to check if the un-prefixed events are usable, and if not remove them from the map.
+
+  if (!('AnimationEvent' in window)) {
+    delete vendorPrefixes.animationend.animation;
+    delete vendorPrefixes.animationiteration.animation;
+    delete vendorPrefixes.animationstart.animation;
+  } // Same as above
+
+
+  if (!('TransitionEvent' in window)) {
+    delete vendorPrefixes.transitionend.transition;
+  }
+}
+/**
+ * Attempts to determine the correct vendor prefixed event name.
+ *
+ * @param {string} eventName
+ * @returns {string}
+ */
+
+
+function getVendorPrefixedEventName(eventName) {
+  if (prefixedEventNames[eventName]) {
+    return prefixedEventNames[eventName];
+  } else if (!vendorPrefixes[eventName]) {
+    return eventName;
+  }
+
+  const prefixMap = vendorPrefixes[eventName];
+
+  for (const styleProp in prefixMap) {
+    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {
+      return prefixedEventNames[eventName] = prefixMap[styleProp];
+    }
+  }
+
+  return eventName;
+}
+
+const ANIMATION_END = getVendorPrefixedEventName('animationend');
+const ANIMATION_ITERATION = getVendorPrefixedEventName('animationiteration');
+const ANIMATION_START = getVendorPrefixedEventName('animationstart');
+const TRANSITION_END = getVendorPrefixedEventName('transitionend');
+
+const topLevelEventsToReactNames = new Map(); // NOTE: Capitalization is important in this list!
+//
+// E.g. it needs "pointerDown", not "pointerdown".
+// This is because we derive both React name ("onPointerDown")
+// and DOM name ("pointerdown") from the same list.
+//
+// Exceptions that don't match this convention are listed separately.
+//
+// prettier-ignore
+
+const simpleEventPluginEvents = ['abort', 'auxClick', 'cancel', 'canPlay', 'canPlayThrough', 'click', 'close', 'contextMenu', 'copy', 'cut', 'drag', 'dragEnd', 'dragEnter', 'dragExit', 'dragLeave', 'dragOver', 'dragStart', 'drop', 'durationChange', 'emptied', 'encrypted', 'ended', 'error', 'gotPointerCapture', 'input', 'invalid', 'keyDown', 'keyPress', 'keyUp', 'load', 'loadedData', 'loadedMetadata', 'loadStart', 'lostPointerCapture', 'mouseDown', 'mouseMove', 'mouseOut', 'mouseOver', 'mouseUp', 'paste', 'pause', 'play', 'playing', 'pointerCancel', 'pointerDown', 'pointerMove', 'pointerOut', 'pointerOver', 'pointerUp', 'progress', 'rateChange', 'reset', 'resize', 'seeked', 'seeking', 'stalled', 'submit', 'suspend', 'timeUpdate', 'touchCancel', 'touchEnd', 'touchStart', 'volumeChange', 'scroll', 'scrollEnd', 'toggle', 'touchMove', 'waiting', 'wheel'];
+
+function registerSimpleEvent(domEventName, reactName) {
+  topLevelEventsToReactNames.set(domEventName, reactName);
+  registerTwoPhaseEvent(reactName, [domEventName]);
+}
+
+function registerSimpleEvents() {
+  for (let i = 0; i < simpleEventPluginEvents.length; i++) {
+    const eventName = simpleEventPluginEvents[i];
+    const domEventName = eventName.toLowerCase();
+    const capitalizedEvent = eventName[0].toUpperCase() + eventName.slice(1);
+    registerSimpleEvent(domEventName, 'on' + capitalizedEvent);
+  } // Special cases where event names don't match.
+
+
+  registerSimpleEvent(ANIMATION_END, 'onAnimationEnd');
+  registerSimpleEvent(ANIMATION_ITERATION, 'onAnimationIteration');
+  registerSimpleEvent(ANIMATION_START, 'onAnimationStart');
+  registerSimpleEvent('dblclick', 'onDoubleClick');
+  registerSimpleEvent('focusin', 'onFocus');
+  registerSimpleEvent('focusout', 'onBlur');
+  registerSimpleEvent(TRANSITION_END, 'onTransitionEnd');
+}
+
+function extractEvents$1(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  const reactName = topLevelEventsToReactNames.get(domEventName);
+
+  if (reactName === undefined) {
+    return;
+  }
+
+  let SyntheticEventCtor = SyntheticEvent;
+  let reactEventType = domEventName;
+
+  switch (domEventName) {
+    case 'keypress':
+      // Firefox creates a keypress event for function keys too. This removes
+      // the unwanted keypress events. Enter is however both printable and
+      // non-printable. One would expect Tab to be as well (but it isn't).
+      // TODO: Fixed in https://bugzilla.mozilla.org/show_bug.cgi?id=968056. Can
+      // probably remove.
+      if (getEventCharCode(nativeEvent) === 0) {
+        return;
+      }
+
+    /* falls through */
+
+    case 'keydown':
+    case 'keyup':
+      SyntheticEventCtor = SyntheticKeyboardEvent;
+      break;
+
+    case 'focusin':
+      reactEventType = 'focus';
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
+
+    case 'focusout':
+      reactEventType = 'blur';
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
+
+    case 'beforeblur':
+    case 'afterblur':
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
+
+    case 'click':
+      // Firefox creates a click event on right mouse clicks. This removes the
+      // unwanted click events.
+      // TODO: Fixed in https://phabricator.services.mozilla.com/D26793. Can
+      // probably remove.
+      if (nativeEvent.button === 2) {
+        return;
+      }
+
+    /* falls through */
+
+    case 'auxclick':
+    case 'dblclick':
+    case 'mousedown':
+    case 'mousemove':
+    case 'mouseup': // TODO: Disabled elements should not respond to mouse events
+
+    /* falls through */
+
+    case 'mouseout':
+    case 'mouseover':
+    case 'contextmenu':
+      SyntheticEventCtor = SyntheticMouseEvent;
+      break;
+
+    case 'drag':
+    case 'dragend':
+    case 'dragenter':
+    case 'dragexit':
+    case 'dragleave':
+    case 'dragover':
+    case 'dragstart':
+    case 'drop':
+      SyntheticEventCtor = SyntheticDragEvent;
+      break;
+
+    case 'touchcancel':
+    case 'touchend':
+    case 'touchmove':
+    case 'touchstart':
+      SyntheticEventCtor = SyntheticTouchEvent;
+      break;
+
+    case ANIMATION_END:
+    case ANIMATION_ITERATION:
+    case ANIMATION_START:
+      SyntheticEventCtor = SyntheticAnimationEvent;
+      break;
+
+    case TRANSITION_END:
+      SyntheticEventCtor = SyntheticTransitionEvent;
+      break;
+
+    case 'scroll':
+    case 'scrollend':
+      SyntheticEventCtor = SyntheticUIEvent;
+      break;
+
+    case 'wheel':
+      SyntheticEventCtor = SyntheticWheelEvent;
+      break;
+
+    case 'copy':
+    case 'cut':
+    case 'paste':
+      SyntheticEventCtor = SyntheticClipboardEvent;
+      break;
+
+    case 'gotpointercapture':
+    case 'lostpointercapture':
+    case 'pointercancel':
+    case 'pointerdown':
+    case 'pointermove':
+    case 'pointerout':
+    case 'pointerover':
+    case 'pointerup':
+      SyntheticEventCtor = SyntheticPointerEvent;
+      break;
+  }
+
+  const inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
+
+  {
+    // Some events don't bubble in the browser.
+    // In the past, React has always bubbled them, but this can be surprising.
+    // We're going to try aligning closer to the browser behavior by not bubbling
+    // them in React either. We'll start by not bubbling onScroll, and then expand.
+    const accumulateTargetOnly = !inCapturePhase && ( // TODO: ideally, we'd eventually add all events from
+    // nonDelegatedEvents list in DOMPluginEventSystem.
+    // Then we can remove this special list.
+    // This is a breaking change that can wait until React 18.
+    domEventName === 'scroll' || domEventName === 'scrollend');
+    const listeners = accumulateSinglePhaseListeners(targetInst, reactName, nativeEvent.type, inCapturePhase, accumulateTargetOnly);
+
+    if (listeners.length > 0) {
+      // Intentionally create event lazily.
+      const event = new SyntheticEventCtor(reactName, reactEventType, null, nativeEvent, nativeEventTarget);
+      dispatchQueue.push({
+        event,
+        listeners
+      });
+    }
+  }
+}
+
+registerSimpleEvents();
+registerEvents$1();
+registerEvents$2();
+registerEvents();
+registerEvents$3();
+
+function extractEvents(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  // TODO: we should remove the concept of a "SimpleEventPlugin".
+  // This is the basic functionality of the event system. All
+  // the other plugins are essentially polyfills. So the plugin
+  // should probably be inlined somewhere and have its logic
+  // be core the to event system. This would potentially allow
+  // us to ship builds of React without the polyfilled plugins below.
+  extractEvents$1(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags);
+  const shouldProcessPolyfillPlugins = (eventSystemFlags & SHOULD_NOT_PROCESS_POLYFILL_EVENT_PLUGINS) === 0; // We don't process these events unless we are in the
+  // event's native "bubble" phase, which means that we're
+  // not in the capture phase. That's because we emulate
+  // the capture phase here still. This is a trade-off,
+  // because in an ideal world we would not emulate and use
+  // the phases properly, like we do with the SimpleEvent
+  // plugin. However, the plugins below either expect
+  // emulation (EnterLeave) or use state localized to that
+  // plugin (BeforeInput, Change, Select). The state in
+  // these modules complicates things, as you'll essentially
+  // get the case where the capture phase event might change
+  // state, only for the following bubble event to come in
+  // later and not trigger anything as the state now
+  // invalidates the heuristics of the event plugin. We
+  // could alter all these plugins to work in such ways, but
+  // that might cause other unknown side-effects that we
+  // can't foresee right now.
+
+  if (shouldProcessPolyfillPlugins) {
+    extractEvents$3(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+    extractEvents$4(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+    extractEvents$2(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+    extractEvents$5(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+
+    {
+      extractEvents$6(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+    }
+  }
+} // List of events that need to be individually attached to media elements.
+
+
+const mediaEventTypes = ['abort', 'canplay', 'canplaythrough', 'durationchange', 'emptied', 'encrypted', 'ended', 'error', 'loadeddata', 'loadedmetadata', 'loadstart', 'pause', 'play', 'playing', 'progress', 'ratechange', 'resize', 'seeked', 'seeking', 'stalled', 'suspend', 'timeupdate', 'volumechange', 'waiting']; // We should not delegate these events to the container, but rather
+// set them on the actual target element itself. This is primarily
+// because these events do not consistently bubble in the DOM.
+
+const nonDelegatedEvents = new Set(['cancel', 'close', 'invalid', 'load', 'scroll', 'scrollend', 'toggle'].concat(mediaEventTypes));
+
+function executeDispatch(event, listener, currentTarget) {
+  const type = event.type || 'unknown-event';
+  event.currentTarget = currentTarget;
+  invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
+  event.currentTarget = null;
+}
+
+function processDispatchQueueItemsInOrder(event, dispatchListeners, inCapturePhase) {
+  let previousInstance;
+
+  if (inCapturePhase) {
+    for (let i = dispatchListeners.length - 1; i >= 0; i--) {
+      const _dispatchListeners$i = dispatchListeners[i],
+            instance = _dispatchListeners$i.instance,
+            currentTarget = _dispatchListeners$i.currentTarget,
+            listener = _dispatchListeners$i.listener;
+
+      if (instance !== previousInstance && event.isPropagationStopped()) {
+        return;
+      }
+
+      executeDispatch(event, listener, currentTarget);
+      previousInstance = instance;
+    }
+  } else {
+    for (let i = 0; i < dispatchListeners.length; i++) {
+      const _dispatchListeners$i2 = dispatchListeners[i],
+            instance = _dispatchListeners$i2.instance,
+            currentTarget = _dispatchListeners$i2.currentTarget,
+            listener = _dispatchListeners$i2.listener;
+
+      if (instance !== previousInstance && event.isPropagationStopped()) {
+        return;
+      }
+
+      executeDispatch(event, listener, currentTarget);
+      previousInstance = instance;
+    }
+  }
+}
+
+function processDispatchQueue(dispatchQueue, eventSystemFlags) {
+  const inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
+
+  for (let i = 0; i < dispatchQueue.length; i++) {
+    const _dispatchQueue$i = dispatchQueue[i],
+          event = _dispatchQueue$i.event,
+          listeners = _dispatchQueue$i.listeners;
+    processDispatchQueueItemsInOrder(event, listeners, inCapturePhase); //  event system doesn't use pooling.
+  } // This would be a good time to rethrow if any of the event handlers threw.
+
+
+  rethrowCaughtError();
+}
+
+function dispatchEventsForPlugins(domEventName, eventSystemFlags, nativeEvent, targetInst, targetContainer) {
+  const nativeEventTarget = getEventTarget(nativeEvent);
+  const dispatchQueue = [];
+  extractEvents(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags);
+  processDispatchQueue(dispatchQueue, eventSystemFlags);
+}
+
+function listenToNonDelegatedEvent(domEventName, targetElement) {
+
+  const isCapturePhaseListener = false;
+  const listenerSet = getEventListenerSet(targetElement);
+  const listenerSetKey = getListenerSetKey(domEventName, isCapturePhaseListener);
+
+  if (!listenerSet.has(listenerSetKey)) {
+    addTrappedEventListener(targetElement, domEventName, IS_NON_DELEGATED, isCapturePhaseListener);
+    listenerSet.add(listenerSetKey);
+  }
+}
+function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
+
+  let eventSystemFlags = 0;
+
+  if (isCapturePhaseListener) {
+    eventSystemFlags |= IS_CAPTURE_PHASE;
+  }
+
+  addTrappedEventListener(target, domEventName, eventSystemFlags, isCapturePhaseListener);
+} // This is only used by createEventHandle when the
+const listeningMarker = '_reactListening' + Math.random().toString(36).slice(2);
+function listenToAllSupportedEvents(rootContainerElement) {
+  if (!rootContainerElement[listeningMarker]) {
+    rootContainerElement[listeningMarker] = true;
+    allNativeEvents.forEach(domEventName => {
+      // We handle selectionchange separately because it
+      // doesn't bubble and needs to be on the document.
+      if (domEventName !== 'selectionchange') {
+        if (!nonDelegatedEvents.has(domEventName)) {
+          listenToNativeEvent(domEventName, false, rootContainerElement);
+        }
+
+        listenToNativeEvent(domEventName, true, rootContainerElement);
+      }
+    });
+    const ownerDocument = rootContainerElement.nodeType === DOCUMENT_NODE ? rootContainerElement : rootContainerElement.ownerDocument;
+
+    if (ownerDocument !== null) {
+      // The selectionchange event also needs deduplication
+      // but it is attached to the document.
+      if (!ownerDocument[listeningMarker]) {
+        ownerDocument[listeningMarker] = true;
+        listenToNativeEvent('selectionchange', false, ownerDocument);
+      }
+    }
+  }
+}
+
+function addTrappedEventListener(targetContainer, domEventName, eventSystemFlags, isCapturePhaseListener, isDeferredListenerForLegacyFBSupport) {
+  let listener = createEventListenerWrapperWithPriority(targetContainer, domEventName, eventSystemFlags); // If passive option is not supported, then the event will be
+  // active and not passive.
+
+  let isPassiveListener = undefined;
+
+  if (passiveBrowserEventsSupported) {
+    // Browsers introduced an intervention, making these events
+    // passive by default on document. React doesn't bind them
+    // to document anymore, but changing this now would undo
+    // the performance wins from the change. So we emulate
+    // the existing behavior manually on the roots now.
+    // https://github.com/facebook/react/issues/19651
+    if (domEventName === 'touchstart' || domEventName === 'touchmove' || domEventName === 'wheel') {
+      isPassiveListener = true;
+    }
+  }
+
+  targetContainer = targetContainer;
+
+
+  if (isCapturePhaseListener) {
+    if (isPassiveListener !== undefined) {
+      addEventCaptureListenerWithPassiveFlag(targetContainer, domEventName, listener, isPassiveListener);
+    } else {
+      addEventCaptureListener(targetContainer, domEventName, listener);
+    }
+  } else {
+    if (isPassiveListener !== undefined) {
+      addEventBubbleListenerWithPassiveFlag(targetContainer, domEventName, listener, isPassiveListener);
+    } else {
+      addEventBubbleListener(targetContainer, domEventName, listener);
+    }
+  }
+}
+
+function isMatchingRootContainer(grandContainer, targetContainer) {
+  return grandContainer === targetContainer || grandContainer.nodeType === COMMENT_NODE && grandContainer.parentNode === targetContainer;
+}
+
+function dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, targetInst, targetContainer) {
+  let ancestorInst = targetInst;
+
+  if ((eventSystemFlags & IS_EVENT_HANDLE_NON_MANAGED_NODE) === 0 && (eventSystemFlags & IS_NON_DELEGATED) === 0) {
+    const targetContainerNode = targetContainer; // If we are using the legacy FB support flag, we
+
+    if (targetInst !== null) {
+      // The below logic attempts to work out if we need to change
+      // the target fiber to a different ancestor. We had similar logic
+      // in the legacy event system, except the big difference between
+      // systems is that the modern event system now has an event listener
+      // attached to each React Root and React Portal Root. Together,
+      // the DOM nodes representing these roots are the "rootContainer".
+      // To figure out which ancestor instance we should use, we traverse
+      // up the fiber tree from the target instance and attempt to find
+      // root boundaries that match that of our current "rootContainer".
+      // If we find that "rootContainer", we find the parent fiber
+      // sub-tree for that root and make that our ancestor instance.
+      let node = targetInst;
+
+      mainLoop: while (true) {
+        if (node === null) {
+          return;
+        }
+
+        const nodeTag = node.tag;
+
+        if (nodeTag === HostRoot || nodeTag === HostPortal) {
+          let container = node.stateNode.containerInfo;
+
+          if (isMatchingRootContainer(container, targetContainerNode)) {
+            break;
+          }
+
+          if (nodeTag === HostPortal) {
+            // The target is a portal, but it's not the rootContainer we're looking for.
+            // Normally portals handle their own events all the way down to the root.
+            // So we should be able to stop now. However, we don't know if this portal
+            // was part of *our* root.
+            let grandNode = node.return;
+
+            while (grandNode !== null) {
+              const grandTag = grandNode.tag;
+
+              if (grandTag === HostRoot || grandTag === HostPortal) {
+                const grandContainer = grandNode.stateNode.containerInfo;
+
+                if (isMatchingRootContainer(grandContainer, targetContainerNode)) {
+                  // This is the rootContainer we're looking for and we found it as
+                  // a parent of the Portal. That means we can ignore it because the
+                  // Portal will bubble through to us.
+                  return;
+                }
+              }
+
+              grandNode = grandNode.return;
+            }
+          } // Now we need to find it's corresponding host fiber in the other
+          // tree. To do this we can use getClosestInstanceFromNode, but we
+          // need to validate that the fiber is a host instance, otherwise
+          // we need to traverse up through the DOM till we find the correct
+          // node that is from the other tree.
+
+
+          while (container !== null) {
+            const parentNode = getClosestInstanceFromNode(container);
+
+            if (parentNode === null) {
+              return;
+            }
+
+            const parentTag = parentNode.tag;
+
+            if (parentTag === HostComponent || parentTag === HostText || (parentTag === HostHoistable ) || (parentTag === HostSingleton )) {
+              node = ancestorInst = parentNode;
+              continue mainLoop;
+            }
+
+            container = container.parentNode;
+          }
+        }
+
+        node = node.return;
+      }
+    }
+  }
+
+  batchedUpdates(() => dispatchEventsForPlugins(domEventName, eventSystemFlags, nativeEvent, ancestorInst));
+}
+
+function createDispatchListener(instance, listener, currentTarget) {
+  return {
+    instance,
+    listener,
+    currentTarget
+  };
+}
+
+function accumulateSinglePhaseListeners(targetFiber, reactName, nativeEventType, inCapturePhase, accumulateTargetOnly, nativeEvent) {
+  const captureName = reactName !== null ? reactName + 'Capture' : null;
+  const reactEventName = inCapturePhase ? captureName : reactName;
+  let listeners = [];
+  let instance = targetFiber;
+  let lastHostComponent = null; // Accumulate all instances and listeners via the target -> root path.
+
+  while (instance !== null) {
+    const _instance = instance,
+          stateNode = _instance.stateNode,
+          tag = _instance.tag; // Handle listeners that are on HostComponents (i.e. <div>)
+
+    if ((tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton )) && stateNode !== null) {
+      lastHostComponent = stateNode; // createEventHandle listeners
+
+
+      if (reactEventName !== null) {
+        const listener = getListener(instance, reactEventName);
+
+        if (listener != null) {
+          listeners.push(createDispatchListener(instance, listener, lastHostComponent));
+        }
+      }
+    } // If we are only accumulating events for the target, then we don't
+    // continue to propagate through the React fiber tree to find other
+    // listeners.
+
+
+    if (accumulateTargetOnly) {
+      break;
+    } // If we are processing the onBeforeBlur event, then we need to take
+
+    instance = instance.return;
+  }
+
+  return listeners;
+} // We should only use this function for:
+// - BeforeInputEventPlugin
+// - ChangeEventPlugin
+// - SelectEventPlugin
+// This is because we only process these plugins
+// in the bubble phase, so we need to accumulate two
+// phase event listeners (via emulation).
+
+function accumulateTwoPhaseListeners(targetFiber, reactName) {
+  const captureName = reactName + 'Capture';
+  const listeners = [];
+  let instance = targetFiber; // Accumulate all instances and listeners via the target -> root path.
+
+  while (instance !== null) {
+    const _instance2 = instance,
+          stateNode = _instance2.stateNode,
+          tag = _instance2.tag; // Handle listeners that are on HostComponents (i.e. <div>)
+
+    if ((tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton )) && stateNode !== null) {
+      const currentTarget = stateNode;
+      const captureListener = getListener(instance, captureName);
+
+      if (captureListener != null) {
+        listeners.unshift(createDispatchListener(instance, captureListener, currentTarget));
+      }
+
+      const bubbleListener = getListener(instance, reactName);
+
+      if (bubbleListener != null) {
+        listeners.push(createDispatchListener(instance, bubbleListener, currentTarget));
+      }
+    }
+
+    instance = instance.return;
+  }
+
+  return listeners;
+}
+
+function getParent(inst) {
+  if (inst === null) {
+    return null;
+  }
+
+  do {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    inst = inst.return; // TODO: If this is a HostRoot we might want to bail out.
+    // That is depending on if we want nested subtrees (layers) to bubble
+    // events to their parent. We could also go through parentNode on the
+    // host node but that wouldn't work for React Native and doesn't let us
+    // do the portal feature.
+  } while (inst && inst.tag !== HostComponent && (inst.tag !== HostSingleton));
+
+  if (inst) {
+    return inst;
+  }
+
+  return null;
+}
+/**
+ * Return the lowest common ancestor of A and B, or null if they are in
+ * different trees.
+ */
+
+
+function getLowestCommonAncestor(instA, instB) {
+  let nodeA = instA;
+  let nodeB = instB;
+  let depthA = 0;
+
+  for (let tempA = nodeA; tempA; tempA = getParent(tempA)) {
+    depthA++;
+  }
+
+  let depthB = 0;
+
+  for (let tempB = nodeB; tempB; tempB = getParent(tempB)) {
+    depthB++;
+  } // If A is deeper, crawl up.
+
+
+  while (depthA - depthB > 0) {
+    nodeA = getParent(nodeA);
+    depthA--;
+  } // If B is deeper, crawl up.
+
+
+  while (depthB - depthA > 0) {
+    nodeB = getParent(nodeB);
+    depthB--;
+  } // Walk in lockstep until we find a match.
+
+
+  let depth = depthA;
+
+  while (depth--) {
+    if (nodeA === nodeB || nodeB !== null && nodeA === nodeB.alternate) {
+      return nodeA;
+    }
+
+    nodeA = getParent(nodeA);
+    nodeB = getParent(nodeB);
+  }
+
+  return null;
+}
+
+function accumulateEnterLeaveListenersForEvent(dispatchQueue, event, target, common, inCapturePhase) {
+  const registrationName = event._reactName;
+  const listeners = [];
+  let instance = target;
+
+  while (instance !== null) {
+    if (instance === common) {
+      break;
+    }
+
+    const _instance3 = instance,
+          alternate = _instance3.alternate,
+          stateNode = _instance3.stateNode,
+          tag = _instance3.tag;
+
+    if (alternate !== null && alternate === common) {
+      break;
+    }
+
+    if ((tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton )) && stateNode !== null) {
+      const currentTarget = stateNode;
+
+      if (inCapturePhase) {
+        const captureListener = getListener(instance, registrationName);
+
+        if (captureListener != null) {
+          listeners.unshift(createDispatchListener(instance, captureListener, currentTarget));
+        }
+      } else if (!inCapturePhase) {
+        const bubbleListener = getListener(instance, registrationName);
+
+        if (bubbleListener != null) {
+          listeners.push(createDispatchListener(instance, bubbleListener, currentTarget));
+        }
+      }
+    }
+
+    instance = instance.return;
+  }
+
+  if (listeners.length !== 0) {
+    dispatchQueue.push({
+      event,
+      listeners
+    });
+  }
+} // We should only use this function for:
+// - EnterLeaveEventPlugin
+// This is because we only process this plugin
+// in the bubble phase, so we need to accumulate two
+// phase event listeners.
+
+
+function accumulateEnterLeaveTwoPhaseListeners(dispatchQueue, leaveEvent, enterEvent, from, to) {
+  const common = from && to ? getLowestCommonAncestor(from, to) : null;
+
+  if (from !== null) {
+    accumulateEnterLeaveListenersForEvent(dispatchQueue, leaveEvent, from, common, false);
+  }
+
+  if (to !== null && enterEvent !== null) {
+    accumulateEnterLeaveListenersForEvent(dispatchQueue, enterEvent, to, common, true);
+  }
+}
+function getListenerSetKey(domEventName, capture) {
+  return domEventName + "__" + (capture ? 'capture' : 'bubble');
+}
+
+// It also can turn \u0000 into \uFFFD inside attributes.
+// https://www.w3.org/TR/html5/single-page.html#preprocessing-the-input-stream
+// If we have a mismatch, it might be caused by that.
+// We will still patch up in this case but not fire the warning.
+
+
+const NORMALIZE_NEWLINES_REGEX = /\r\n?/g;
+const NORMALIZE_NULL_AND_REPLACEMENT_REGEX = /\u0000|\uFFFD/g;
+
+function normalizeMarkupForTextOrAttribute(markup) {
+
+  const markupString = typeof markup === 'string' ? markup : '' + markup;
+  return markupString.replace(NORMALIZE_NEWLINES_REGEX, '\n').replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, '');
+}
+
+function checkForUnmatchedText(serverText, clientText, isConcurrentMode, shouldWarnDev) {
+  const normalizedClientText = normalizeMarkupForTextOrAttribute(clientText);
+  const normalizedServerText = normalizeMarkupForTextOrAttribute(serverText);
+
+  if (normalizedServerText === normalizedClientText) {
+    return;
+  }
+
+  if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {
+    // In concurrent roots, we throw when there's a text mismatch and revert to
+    // client rendering, up to the nearest Suspense boundary.
+    throw Error(formatProdErrorMessage(425));
+  }
+}
+
+function noop$1() {}
+
+function trapClickOnNonInteractiveElement(node) {
+  // Mobile Safari does not fire properly bubble click events on
+  // non-interactive elements, which means delegated click listeners do not
+  // fire. The workaround for this bug involves attaching an empty click
+  // listener on the target node.
+  // https://www.quirksmode.org/blog/archives/2010/09/click_event_del.html
+  // Just set it using the onclick property so that we don't have to manage any
+  // bookkeeping for it. Not sure if we need to clear it when the listener is
+  // removed.
+  // TODO: Only do this for the relevant Safaris maybe?
+  node.onclick = noop$1;
+}
+const xlinkNamespace = 'http://www.w3.org/1999/xlink';
+const xmlNamespace = 'http://www.w3.org/XML/1998/namespace';
+
+function setProp(domElement, tag, key, value, props, prevValue) {
+  switch (key) {
+    case 'children':
+      {
+        if (typeof value === 'string') {
+          // textContent on a <textarea> will cause the placeholder to not
+          // show within the <textarea> until it has been focused and blurred again.
+          // https://github.com/facebook/react/issues/6731#issuecomment-254874553
+
+
+          const canSetTextContent = (tag !== 'body') && (tag !== 'textarea' || value !== '');
+
+          if (canSetTextContent) {
+            setTextContent(domElement, value);
+          }
+        } else if (typeof value === 'number') {
+
+          const canSetTextContent = tag !== 'body';
+
+          if (canSetTextContent) {
+            setTextContent(domElement, '' + value);
+          }
+        }
+
+        break;
+      }
+    // These are very common props and therefore are in the beginning of the switch.
+    // TODO: aria-label is a very common prop but allows booleans so is not like the others
+    // but should ideally go in this list too.
+
+    case 'className':
+      setValueForKnownAttribute(domElement, 'class', value);
+      break;
+
+    case 'tabIndex':
+      // This has to be case sensitive in SVG.
+      setValueForKnownAttribute(domElement, 'tabindex', value);
+      break;
+
+    case 'dir':
+    case 'role':
+    case 'viewBox':
+    case 'width':
+    case 'height':
+      {
+        setValueForKnownAttribute(domElement, key, value);
+        break;
+      }
+
+    case 'style':
+      {
+        setValueForStyles(domElement, value, prevValue);
+        break;
+      }
+    // These attributes accept URLs. These must not allow javascript: URLS.
+
+    case 'src':
+    case 'href':
+      {
+
+        if (value == null || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          domElement.removeAttribute(key);
+          break;
+        } // `setAttribute` with objects becomes only `[object]` in IE8/9,
+
+        const sanitizedValue = sanitizeURL('' + value);
+        domElement.setAttribute(key, sanitizedValue);
+        break;
+      }
+
+    case 'action':
+    case 'formAction':
+      {
+
+        {
+          if (typeof value === 'function') {
+            // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+            // because we'll preventDefault, but it can happen if a form is manually submitted or
+            // if someone calls stopPropagation before React gets the event.
+            // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+            // error message but the URL will be logged.
+            domElement.setAttribute(key, // eslint-disable-next-line no-script-url
+            "javascript:throw new Error('" + 'A React form was unexpectedly submitted. If you called form.submit() manually, ' + "consider using form.requestSubmit() instead. If you\\'re trying to use " + 'event.stopPropagation() in a submit event handler, consider also calling ' + 'event.preventDefault().' + "')");
+            break;
+          } else if (typeof prevValue === 'function') {
+            // When we're switching off a Server Action that was originally hydrated.
+            // The server control these fields during SSR that are now trailing.
+            // The regular diffing doesn't apply since we compare against the previous props.
+            // Instead, we need to force them to be set to whatever they should be now.
+            // This would be a lot cleaner if we did this whole fork in the per-tag approach.
+            if (key === 'formAction') {
+              if (tag !== 'input') {
+                // Setting the name here isn't completely safe for inputs if this is switching
+                // to become a radio button. In that case we let the tag based override take
+                // control.
+                setProp(domElement, tag, 'name', props.name, props, null);
+              }
+
+              setProp(domElement, tag, 'formEncType', props.formEncType, props, null);
+              setProp(domElement, tag, 'formMethod', props.formMethod, props, null);
+              setProp(domElement, tag, 'formTarget', props.formTarget, props, null);
+            } else {
+              setProp(domElement, tag, 'encType', props.encType, props, null);
+              setProp(domElement, tag, 'method', props.method, props, null);
+              setProp(domElement, tag, 'target', props.target, props, null);
+            }
+          }
+        }
+
+        if (value == null || !enableFormActions  || typeof value === 'symbol' || typeof value === 'boolean') {
+          domElement.removeAttribute(key);
+          break;
+        } // `setAttribute` with objects becomes only `[object]` in IE8/9,
+
+        const sanitizedValue = sanitizeURL('' + value);
+        domElement.setAttribute(key, sanitizedValue);
+        break;
+      }
+
+    case 'onClick':
+      {
+        // TODO: This cast may not be sound for SVG, MathML or custom elements.
+        if (value != null) {
+
+          trapClickOnNonInteractiveElement(domElement);
+        }
+
+        break;
+      }
+
+    case 'onScroll':
+      {
+        if (value != null) {
+
+          listenToNonDelegatedEvent('scroll', domElement);
+        }
+
+        break;
+      }
+
+    case 'onScrollEnd':
+      {
+        if (value != null) {
+
+          listenToNonDelegatedEvent('scrollend', domElement);
+        }
+
+        break;
+      }
+
+    case 'dangerouslySetInnerHTML':
+      {
+        if (value != null) {
+          if (typeof value !== 'object' || !('__html' in value)) {
+            throw Error(formatProdErrorMessage(61));
+          }
+
+          const nextHtml = value.__html;
+
+          if (nextHtml != null) {
+            if (props.children != null) {
+              throw Error(formatProdErrorMessage(60));
+            }
+
+            {
+              setInnerHTML$1(domElement, nextHtml);
+            }
+          }
+        }
+
+        break;
+      }
+    // Note: `option.selected` is not updated if `select.multiple` is
+    // disabled with `removeAttribute`. We have special logic for handling this.
+
+    case 'multiple':
+      {
+        domElement.multiple = value && typeof value !== 'function' && typeof value !== 'symbol';
+        break;
+      }
+
+    case 'muted':
+      {
+        domElement.muted = value && typeof value !== 'function' && typeof value !== 'symbol';
+        break;
+      }
+
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'defaultValue': // Reserved
+
+    case 'defaultChecked':
+    case 'innerHTML':
+      {
+        // Noop
+        break;
+      }
+
+    case 'autoFocus':
+      {
+        // We polyfill it separately on the client during commit.
+        // We could have excluded it in the property list instead of
+        // adding a special case here, but then it wouldn't be emitted
+        // on server rendering (but we *do* want to emit it in SSR).
+        break;
+      }
+
+    case 'xlinkHref':
+      {
+        if (value == null || typeof value === 'function' || typeof value === 'boolean' || typeof value === 'symbol') {
+          domElement.removeAttribute('xlink:href');
+          break;
+        } // `setAttribute` with objects becomes only `[object]` in IE8/9,
+
+        const sanitizedValue = sanitizeURL('' + value);
+        domElement.setAttributeNS(xlinkNamespace, 'xlink:href', sanitizedValue);
+        break;
+      }
+
+    case 'contentEditable':
+    case 'spellCheck':
+    case 'draggable':
+    case 'value':
+    case 'autoReverse':
+    case 'externalResourcesRequired':
+    case 'focusable':
+    case 'preserveAlpha':
+      {
+        // Booleanish String
+        // These are "enumerated" attributes that accept "true" and "false".
+        // In React, we let users pass `true` and `false` even though technically
+        // these aren't boolean attributes (they are coerced to strings).
+        // The SVG attributes are case-sensitive. Since the HTML attributes are
+        // insensitive they also work even though we canonically use lower case.
+        if (value != null && typeof value !== 'function' && typeof value !== 'symbol') {
+
+          domElement.setAttribute(key, '' + value);
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+    // Boolean
+
+    case 'allowFullScreen':
+    case 'async':
+    case 'autoPlay':
+    case 'controls':
+    case 'default':
+    case 'defer':
+    case 'disabled':
+    case 'disablePictureInPicture':
+    case 'disableRemotePlayback':
+    case 'formNoValidate':
+    case 'hidden':
+    case 'loop':
+    case 'noModule':
+    case 'noValidate':
+    case 'open':
+    case 'playsInline':
+    case 'readOnly':
+    case 'required':
+    case 'reversed':
+    case 'scoped':
+    case 'seamless':
+    case 'itemScope':
+      {
+        if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+          domElement.setAttribute(key, '');
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+    // Overloaded Boolean
+
+    case 'capture':
+    case 'download':
+      {
+        // An attribute that can be used as a flag as well as with a value.
+        // When true, it should be present (set either to an empty string or its name).
+        // When false, it should be omitted.
+        // For any other value, should be present with that value.
+        if (value === true) {
+          domElement.setAttribute(key, '');
+        } else if (value !== false && value != null && typeof value !== 'function' && typeof value !== 'symbol') {
+
+          domElement.setAttribute(key, value);
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+
+    case 'cols':
+    case 'rows':
+    case 'size':
+    case 'span':
+      {
+        // These are HTML attributes that must be positive numbers.
+        if (value != null && typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value) && value >= 1) {
+
+          domElement.setAttribute(key, value);
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+
+    case 'rowSpan':
+    case 'start':
+      {
+        // These are HTML attributes that must be numbers.
+        if (value != null && typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value)) {
+
+          domElement.setAttribute(key, value);
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+
+    case 'xlinkActuate':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:actuate', value);
+      break;
+
+    case 'xlinkArcrole':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:arcrole', value);
+      break;
+
+    case 'xlinkRole':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:role', value);
+      break;
+
+    case 'xlinkShow':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:show', value);
+      break;
+
+    case 'xlinkTitle':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:title', value);
+      break;
+
+    case 'xlinkType':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:type', value);
+      break;
+
+    case 'xmlBase':
+      setValueForNamespacedAttribute(domElement, xmlNamespace, 'xml:base', value);
+      break;
+
+    case 'xmlLang':
+      setValueForNamespacedAttribute(domElement, xmlNamespace, 'xml:lang', value);
+      break;
+
+    case 'xmlSpace':
+      setValueForNamespacedAttribute(domElement, xmlNamespace, 'xml:space', value);
+      break;
+    // Properties that should not be allowed on custom elements.
+
+    case 'is':
+      {
+        // passed it to createElement. We don't also need the attribute.
+        // However, our tests currently query for it so it's plausible someone
+        // else does too so it's break.
+
+
+        setValueForAttribute(domElement, 'is', value);
+        break;
+      }
+
+    case 'innerText':
+    case 'textContent':
+
+    // Fall through
+
+    default:
+      {
+        if (key.length > 2 && (key[0] === 'o' || key[0] === 'O') && (key[1] === 'n' || key[1] === 'N')) ; else {
+          const attributeName = getAttributeAlias(key);
+          setValueForAttribute(domElement, attributeName, value);
+        }
+      }
+  }
+}
+
+function setPropOnCustomElement(domElement, tag, key, value, props, prevValue) {
+  switch (key) {
+    case 'style':
+      {
+        setValueForStyles(domElement, value, prevValue);
+        break;
+      }
+
+    case 'dangerouslySetInnerHTML':
+      {
+        if (value != null) {
+          if (typeof value !== 'object' || !('__html' in value)) {
+            throw Error(formatProdErrorMessage(61));
+          }
+
+          const nextHtml = value.__html;
+
+          if (nextHtml != null) {
+            if (props.children != null) {
+              throw Error(formatProdErrorMessage(60));
+            }
+
+            {
+              setInnerHTML$1(domElement, nextHtml);
+            }
+          }
+        }
+
+        break;
+      }
+
+    case 'children':
+      {
+        if (typeof value === 'string') {
+          setTextContent(domElement, value);
+        } else if (typeof value === 'number') {
+          setTextContent(domElement, '' + value);
+        }
+
+        break;
+      }
+
+    case 'onScroll':
+      {
+        if (value != null) {
+
+          listenToNonDelegatedEvent('scroll', domElement);
+        }
+
+        break;
+      }
+
+    case 'onScrollEnd':
+      {
+        if (value != null) {
+
+          listenToNonDelegatedEvent('scrollend', domElement);
+        }
+
+        break;
+      }
+
+    case 'onClick':
+      {
+        // TODO: This cast may not be sound for SVG, MathML or custom elements.
+        if (value != null) {
+
+          trapClickOnNonInteractiveElement(domElement);
+        }
+
+        break;
+      }
+
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'innerHTML':
+      {
+        // Noop
+        break;
+      }
+
+    case 'innerText': // Properties
+
+    case 'textContent':
+
+    // Fall through
+
+    default:
+      {
+        if (registrationNameDependencies.hasOwnProperty(key)) ; else {
+          {
+            if (typeof value === 'boolean') {
+              // Special case before the new flag is on
+              value = '' + value;
+            }
+
+            setValueForAttribute(domElement, key, value);
+          }
+        }
+      }
+  }
+}
+
+function setInitialProperties(domElement, tag, props) {
+
+
+  switch (tag) {
+    case 'div':
+    case 'span':
+    case 'svg':
+    case 'path':
+    case 'a':
+    case 'g':
+    case 'p':
+    case 'li':
+      {
+        // Fast track the most common tag types
+        break;
+      }
+
+    case 'input':
+      {
+        // listeners still fire for the invalid event.
+
+
+        listenToNonDelegatedEvent('invalid', domElement);
+        let name = null;
+        let type = null;
+        let value = null;
+        let defaultValue = null;
+        let checked = null;
+        let defaultChecked = null;
+
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'name':
+              {
+                name = propValue;
+                break;
+              }
+
+            case 'type':
+              {
+                type = propValue;
+                break;
+              }
+
+            case 'checked':
+              {
+                checked = propValue;
+                break;
+              }
+
+            case 'defaultChecked':
+              {
+                defaultChecked = propValue;
+                break;
+              }
+
+            case 'value':
+              {
+                value = propValue;
+                break;
+              }
+
+            case 'defaultValue':
+              {
+                defaultValue = propValue;
+                break;
+              }
+
+            case 'children':
+            case 'dangerouslySetInnerHTML':
+              {
+                if (propValue != null) {
+                  throw Error(formatProdErrorMessage(137, tag));
+                }
+
+                break;
+              }
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        } // TODO: Make sure we check if this is still unmounted or do any clean
+        initInput(domElement, value, defaultValue, checked, defaultChecked, type, name, false);
+        track(domElement);
+        return;
+      }
+
+    case 'select':
+      {
+        // listeners still fire for the invalid event.
+
+
+        listenToNonDelegatedEvent('invalid', domElement);
+        let value = null;
+        let defaultValue = null;
+        let multiple = null;
+
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'value':
+              {
+                value = propValue; // This is handled by initSelect below.
+
+                break;
+              }
+
+            case 'defaultValue':
+              {
+                defaultValue = propValue; // This is handled by initSelect below.
+
+                break;
+              }
+
+            case 'multiple':
+              {
+                multiple = propValue; // TODO: We don't actually have to fall through here because we set it
+                // in initSelect anyway. We can remove the special case in setProp.
+              }
+            // Fallthrough
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        }
+        initSelect(domElement, value, defaultValue, multiple);
+        return;
+      }
+
+    case 'textarea':
+      {
+        // listeners still fire for the invalid event.
+
+
+        listenToNonDelegatedEvent('invalid', domElement);
+        let value = null;
+        let defaultValue = null;
+        let children = null;
+
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'value':
+              {
+                value = propValue; // This is handled by initTextarea below.
+
+                break;
+              }
+
+            case 'defaultValue':
+              {
+                defaultValue = propValue;
+                break;
+              }
+
+            case 'children':
+              {
+                children = propValue; // Handled by initTextarea above.
+
+                break;
+              }
+
+            case 'dangerouslySetInnerHTML':
+              {
+                if (propValue != null) {
+                  // TODO: Do we really need a special error message for this. It's also pretty blunt.
+                  throw Error(formatProdErrorMessage(91));
+                }
+
+                break;
+              }
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        } // TODO: Make sure we check if this is still unmounted or do any clean
+        initTextarea(domElement, value, defaultValue, children);
+        track(domElement);
+        return;
+      }
+
+    case 'option':
+      {
+
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'selected':
+              {
+                // TODO: Remove support for selected on option.
+                domElement.selected = propValue && typeof propValue !== 'function' && typeof propValue !== 'symbol';
+                break;
+              }
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        }
+
+        return;
+      }
+
+    case 'dialog':
+      {
+        listenToNonDelegatedEvent('cancel', domElement);
+        listenToNonDelegatedEvent('close', domElement);
+        break;
+      }
+
+    case 'iframe':
+    case 'object':
+      {
+        // We listen to this event in case to ensure emulated bubble
+        // listeners still fire for the load event.
+        listenToNonDelegatedEvent('load', domElement);
+        break;
+      }
+
+    case 'video':
+    case 'audio':
+      {
+        // We listen to these events in case to ensure emulated bubble
+        // listeners still fire for all the media events.
+        for (let i = 0; i < mediaEventTypes.length; i++) {
+          listenToNonDelegatedEvent(mediaEventTypes[i], domElement);
+        }
+
+        break;
+      }
+
+    case 'image':
+      {
+        // We listen to these events in case to ensure emulated bubble
+        // listeners still fire for error and load events.
+        listenToNonDelegatedEvent('error', domElement);
+        listenToNonDelegatedEvent('load', domElement);
+        break;
+      }
+
+    case 'details':
+      {
+        // We listen to this event in case to ensure emulated bubble
+        // listeners still fire for the toggle event.
+        listenToNonDelegatedEvent('toggle', domElement);
+        break;
+      }
+
+    case 'embed':
+    case 'source':
+    case 'img':
+    case 'link':
+      {
+        // These are void elements that also need delegated events.
+        listenToNonDelegatedEvent('error', domElement);
+        listenToNonDelegatedEvent('load', domElement); // We fallthrough to the return of the void elements
+      }
+
+    case 'area':
+    case 'base':
+    case 'br':
+    case 'col':
+    case 'hr':
+    case 'keygen':
+    case 'meta':
+    case 'param':
+    case 'track':
+    case 'wbr':
+    case 'menuitem':
+      {
+        // Void elements
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'children':
+            case 'dangerouslySetInnerHTML':
+              {
+                // TODO: Can we make this a DEV warning to avoid this deny list?
+                throw Error(formatProdErrorMessage(137, tag));
+              }
+            // defaultChecked and defaultValue are ignored by setProp
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        }
+
+        return;
+      }
+
+    default:
+      {
+        if (isCustomElement(tag)) {
+          for (const propKey in props) {
+            if (!props.hasOwnProperty(propKey)) {
+              continue;
+            }
+
+            const propValue = props[propKey];
+
+            if (propValue == null) {
+              continue;
+            }
+
+            setPropOnCustomElement(domElement, tag, propKey, propValue, props, null);
+          }
+
+          return;
+        }
+      }
+  }
+
+  for (const propKey in props) {
+    if (!props.hasOwnProperty(propKey)) {
+      continue;
+    }
+
+    const propValue = props[propKey];
+
+    if (propValue == null) {
+      continue;
+    }
+
+    setProp(domElement, tag, propKey, propValue, props, null);
+  }
+}
+function updateProperties(domElement, tag, lastProps, nextProps) {
+
+  switch (tag) {
+    case 'div':
+    case 'span':
+    case 'svg':
+    case 'path':
+    case 'a':
+    case 'g':
+    case 'p':
+    case 'li':
+      {
+        // Fast track the most common tag types
+        break;
+      }
+
+    case 'input':
+      {
+        let name = null;
+        let type = null;
+        let value = null;
+        let defaultValue = null;
+        let lastDefaultValue = null;
+        let checked = null;
+        let defaultChecked = null;
+
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null) {
+            switch (propKey) {
+              case 'checked':
+                {
+                  break;
+                }
+
+              case 'value':
+                {
+                  // This is handled by updateWrapper below.
+                  break;
+                }
+
+              case 'defaultValue':
+                {
+                  lastDefaultValue = lastProp;
+                }
+              // defaultChecked and defaultValue are ignored by setProp
+              // Fallthrough
+
+              default:
+                {
+                  if (!nextProps.hasOwnProperty(propKey)) setProp(domElement, tag, propKey, null, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'type':
+                {
+                  type = nextProp;
+                  break;
+                }
+
+              case 'name':
+                {
+                  name = nextProp;
+                  break;
+                }
+
+              case 'checked':
+                {
+                  checked = nextProp;
+                  break;
+                }
+
+              case 'defaultChecked':
+                {
+                  defaultChecked = nextProp;
+                  break;
+                }
+
+              case 'value':
+                {
+                  value = nextProp;
+                  break;
+                }
+
+              case 'defaultValue':
+                {
+                  defaultValue = nextProp;
+                  break;
+                }
+
+              case 'children':
+              case 'dangerouslySetInnerHTML':
+                {
+                  if (nextProp != null) {
+                    throw Error(formatProdErrorMessage(137, tag));
+                  }
+
+                  break;
+                }
+
+              default:
+                {
+                  if (nextProp !== lastProp) setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        }
+        // happen after updating the rest of props. Otherwise HTML5 input validations
+        // raise warnings and prevent the new value from being assigned.
+
+
+        updateInput(domElement, value, defaultValue, lastDefaultValue, checked, defaultChecked, type, name);
+        return;
+      }
+
+    case 'select':
+      {
+        let value = null;
+        let defaultValue = null;
+        let multiple = null;
+        let wasMultiple = null;
+
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null) {
+            switch (propKey) {
+              case 'value':
+                {
+                  // This is handled by updateWrapper below.
+                  break;
+                }
+              // defaultValue are ignored by setProp
+
+              case 'multiple':
+                {
+                  wasMultiple = lastProp; // TODO: Move special case in here from setProp.
+                }
+              // Fallthrough
+
+              default:
+                {
+                  if (!nextProps.hasOwnProperty(propKey)) setProp(domElement, tag, propKey, null, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'value':
+                {
+                  value = nextProp; // This is handled by updateSelect below.
+
+                  break;
+                }
+
+              case 'defaultValue':
+                {
+                  defaultValue = nextProp;
+                  break;
+                }
+
+              case 'multiple':
+                {
+                  multiple = nextProp; // TODO: Just move the special case in here from setProp.
+                }
+              // Fallthrough
+
+              default:
+                {
+                  if (nextProp !== lastProp) setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        } // <select> value update needs to occur after <option> children
+        // reconciliation
+
+
+        updateSelect(domElement, value, defaultValue, multiple, wasMultiple);
+        return;
+      }
+
+    case 'textarea':
+      {
+        let value = null;
+        let defaultValue = null;
+
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+            switch (propKey) {
+              case 'value':
+                {
+                  // This is handled by updateTextarea below.
+                  break;
+                }
+
+              case 'children':
+                {
+                  // TODO: This doesn't actually do anything if it updates.
+                  break;
+                }
+              // defaultValue is ignored by setProp
+
+              default:
+                {
+                  setProp(domElement, tag, propKey, null, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'value':
+                {
+                  value = nextProp; // This is handled by updateTextarea below.
+
+                  break;
+                }
+
+              case 'defaultValue':
+                {
+                  defaultValue = nextProp;
+                  break;
+                }
+
+              case 'children':
+                {
+                  // TODO: This doesn't actually do anything if it updates.
+                  break;
+                }
+
+              case 'dangerouslySetInnerHTML':
+                {
+                  if (nextProp != null) {
+                    // TODO: Do we really need a special error message for this. It's also pretty blunt.
+                    throw Error(formatProdErrorMessage(91));
+                  }
+
+                  break;
+                }
+
+              default:
+                {
+                  if (nextProp !== lastProp) setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        updateTextarea(domElement, value, defaultValue);
+        return;
+      }
+
+    case 'option':
+      {
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+            switch (propKey) {
+              case 'selected':
+                {
+                  // TODO: Remove support for selected on option.
+                  domElement.selected = false;
+                  break;
+                }
+
+              default:
+                {
+                  setProp(domElement, tag, propKey, null, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && nextProp !== lastProp && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'selected':
+                {
+                  // TODO: Remove support for selected on option.
+                  domElement.selected = nextProp && typeof nextProp !== 'function' && typeof nextProp !== 'symbol';
+                  break;
+                }
+
+              default:
+                {
+                  setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        return;
+      }
+
+    case 'img':
+    case 'link':
+    case 'area':
+    case 'base':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'keygen':
+    case 'meta':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+    case 'menuitem':
+      {
+        // Void elements
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+            setProp(domElement, tag, propKey, null, nextProps, lastProp);
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && nextProp !== lastProp && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'children':
+              case 'dangerouslySetInnerHTML':
+                {
+                  if (nextProp != null) {
+                    // TODO: Can we make this a DEV warning to avoid this deny list?
+                    throw Error(formatProdErrorMessage(137, tag));
+                  }
+
+                  break;
+                }
+              // defaultChecked and defaultValue are ignored by setProp
+
+              default:
+                {
+                  setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        return;
+      }
+
+    default:
+      {
+        if (isCustomElement(tag)) {
+          for (const propKey in lastProps) {
+            const lastProp = lastProps[propKey];
+
+            if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+              setPropOnCustomElement(domElement, tag, propKey, null, nextProps, lastProp);
+            }
+          }
+
+          for (const propKey in nextProps) {
+            const nextProp = nextProps[propKey];
+            const lastProp = lastProps[propKey];
+
+            if (nextProps.hasOwnProperty(propKey) && nextProp !== lastProp && (nextProp != null || lastProp != null)) {
+              setPropOnCustomElement(domElement, tag, propKey, nextProp, nextProps, lastProp);
+            }
+          }
+
+          return;
+        }
+      }
+  }
+
+  for (const propKey in lastProps) {
+    const lastProp = lastProps[propKey];
+
+    if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+      setProp(domElement, tag, propKey, null, nextProps, lastProp);
+    }
+  }
+
+  for (const propKey in nextProps) {
+    const nextProp = nextProps[propKey];
+    const lastProp = lastProps[propKey];
+
+    if (nextProps.hasOwnProperty(propKey) && nextProp !== lastProp && (nextProp != null || lastProp != null)) {
+      setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+    }
+  }
+}
+
+function diffHydratedProperties(domElement, tag, props, isConcurrentMode, shouldWarnDev, hostContext) {
+
+
+  switch (tag) {
+    case 'dialog':
+      listenToNonDelegatedEvent('cancel', domElement);
+      listenToNonDelegatedEvent('close', domElement);
+      break;
+
+    case 'iframe':
+    case 'object':
+    case 'embed':
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the load event.
+      listenToNonDelegatedEvent('load', domElement);
+      break;
+
+    case 'video':
+    case 'audio':
+      // We listen to these events in case to ensure emulated bubble
+      // listeners still fire for all the media events.
+      for (let i = 0; i < mediaEventTypes.length; i++) {
+        listenToNonDelegatedEvent(mediaEventTypes[i], domElement);
+      }
+
+      break;
+
+    case 'source':
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the error event.
+      listenToNonDelegatedEvent('error', domElement);
+      break;
+
+    case 'img':
+    case 'image':
+    case 'link':
+      // We listen to these events in case to ensure emulated bubble
+      // listeners still fire for error and load events.
+      listenToNonDelegatedEvent('error', domElement);
+      listenToNonDelegatedEvent('load', domElement);
+      break;
+
+    case 'details':
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the toggle event.
+      listenToNonDelegatedEvent('toggle', domElement);
+      break;
+
+    case 'input':
+      // listeners still fire for the invalid event.
+
+
+      listenToNonDelegatedEvent('invalid', domElement); // TODO: Make sure we check if this is still unmounted or do any clean
+      // post mount to force it to diverge from attributes. However, for
+      // option and select we don't quite do the same thing and select
+      // is not resilient to the DOM state changing so we don't do that here.
+      // TODO: Consider not doing this for input and textarea.
+
+      initInput(domElement, props.value, props.defaultValue, props.checked, props.defaultChecked, props.type, props.name, true);
+      track(domElement);
+      break;
+
+    case 'option':
+      break;
+
+    case 'select':
+      // listeners still fire for the invalid event.
+
+
+      listenToNonDelegatedEvent('invalid', domElement);
+      break;
+
+    case 'textarea':
+      // listeners still fire for the invalid event.
+
+
+      listenToNonDelegatedEvent('invalid', domElement); // TODO: Make sure we check if this is still unmounted or do any clean
+      initTextarea(domElement, props.value, props.defaultValue, props.children);
+      track(domElement);
+      break;
+  }
+
+  const children = props.children; // For text content children we compare against textContent. This
+  // might match additional HTML that is hidden when we read it using
+  // textContent. E.g. "foo" will match "f<span>oo</span>" but that still
+  // satisfies our requirement. Our requirement is not to produce perfect
+  // HTML and attributes. Ideally we should preserve structure but it's
+  // ok not to if the visible content is still enough to indicate what
+  // even listeners these nodes might be wired up to.
+  // TODO: Warn if there is more than a single textNode as a child.
+  // TODO: Should we use domElement.firstChild.nodeValue to compare?
+
+  if (typeof children === 'string' || typeof children === 'number') {
+    if (domElement.textContent !== '' + children) {
+      if (props.suppressHydrationWarning !== true) {
+        checkForUnmatchedText(domElement.textContent, children, isConcurrentMode);
+      }
+
+      if (!isConcurrentMode || !enableClientRenderFallbackOnTextMismatch) {
+        // We really should be patching this in the commit phase but since
+        // this only affects legacy mode hydration which is deprecated anyway
+        // we can get away with it.
+        // Host singletons get their children appended and don't use the text
+        // content mechanism.
+        if (tag !== 'body') {
+          domElement.textContent = children;
+        }
+      }
+    }
+  }
+
+  if (props.onScroll != null) {
+    listenToNonDelegatedEvent('scroll', domElement);
+  }
+
+  if (props.onScrollEnd != null) {
+    listenToNonDelegatedEvent('scrollend', domElement);
+  }
+
+  if (props.onClick != null) {
+    // TODO: This cast may not be sound for SVG, MathML or custom elements.
+    trapClickOnNonInteractiveElement(domElement);
+  }
+}
+function diffHydratedText(textNode, text, isConcurrentMode) {
+  const isDifferent = textNode.nodeValue !== text;
+  return isDifferent;
+}
+function restoreControlledState(domElement, tag, props) {
+  switch (tag) {
+    case 'input':
+      restoreControlledInputState(domElement, props);
+      return;
+
+    case 'textarea':
+      restoreControlledTextareaState(domElement, props);
+      return;
+
+    case 'select':
+      restoreControlledSelectState(domElement, props);
+      return;
+  }
+}
+
+const SUPPRESS_HYDRATION_WARNING = 'suppressHydrationWarning';
+const SUSPENSE_START_DATA = '$';
+const SUSPENSE_END_DATA = '/$';
+const SUSPENSE_PENDING_START_DATA = '$?';
+const SUSPENSE_FALLBACK_START_DATA = '$!';
+const FORM_STATE_IS_MATCHING = 'F!';
+const FORM_STATE_IS_NOT_MATCHING = 'F';
+const STYLE = 'style';
+const HostContextNamespaceNone = 0;
+const HostContextNamespaceSvg = 1;
+const HostContextNamespaceMath = 2;
+let eventsEnabled = null;
+let selectionInformation = null;
+
+function getOwnerDocumentFromRootContainer(rootContainerElement) {
+  return rootContainerElement.nodeType === DOCUMENT_NODE ? rootContainerElement : rootContainerElement.ownerDocument;
+}
+
+function getRootHostContext(rootContainerInstance) {
+  let type;
+  let context;
+  const nodeType = rootContainerInstance.nodeType;
+
+  switch (nodeType) {
+    case DOCUMENT_NODE:
+    case DOCUMENT_FRAGMENT_NODE:
+      {
+        type = nodeType === DOCUMENT_NODE ? '#document' : '#fragment';
+        const root = rootContainerInstance.documentElement;
+
+        if (root) {
+          const namespaceURI = root.namespaceURI;
+          context = namespaceURI ? getOwnHostContext(namespaceURI) : HostContextNamespaceNone;
+        } else {
+          context = HostContextNamespaceNone;
+        }
+
+        break;
+      }
+
+    default:
+      {
+        const container = nodeType === COMMENT_NODE ? rootContainerInstance.parentNode : rootContainerInstance;
+        type = container.tagName;
+        const namespaceURI = container.namespaceURI;
+
+        if (!namespaceURI) {
+          switch (type) {
+            case 'svg':
+              context = HostContextNamespaceSvg;
+              break;
+
+            case 'math':
+              context = HostContextNamespaceMath;
+              break;
+
+            default:
+              context = HostContextNamespaceNone;
+              break;
+          }
+        } else {
+          const ownContext = getOwnHostContext(namespaceURI);
+          context = getChildHostContextProd(ownContext, type);
+        }
+
+        break;
+      }
+  }
+
+  return context;
+}
+
+function getOwnHostContext(namespaceURI) {
+  switch (namespaceURI) {
+    case SVG_NAMESPACE:
+      return HostContextNamespaceSvg;
+
+    case MATH_NAMESPACE:
+      return HostContextNamespaceMath;
+
+    default:
+      return HostContextNamespaceNone;
+  }
+}
+
+function getChildHostContextProd(parentNamespace, type) {
+  if (parentNamespace === HostContextNamespaceNone) {
+    // No (or default) parent namespace: potential entry point.
+    switch (type) {
+      case 'svg':
+        return HostContextNamespaceSvg;
+
+      case 'math':
+        return HostContextNamespaceMath;
+
+      default:
+        return HostContextNamespaceNone;
+    }
+  }
+
+  if (parentNamespace === HostContextNamespaceSvg && type === 'foreignObject') {
+    // We're leaving SVG.
+    return HostContextNamespaceNone;
+  } // By default, pass namespace below.
+
+
+  return parentNamespace;
+}
+
+function getChildHostContext(parentHostContext, type) {
+
+  const parentNamespace = parentHostContext;
+  return getChildHostContextProd(parentNamespace, type);
+}
+function getPublicInstance(instance) {
+  return instance;
+}
+function prepareForCommit(containerInfo) {
+  eventsEnabled = isEnabled();
+  selectionInformation = getSelectionInformation();
+  let activeInstance = null;
+
+  setEnabled(false);
+  return activeInstance;
+}
+function resetAfterCommit(containerInfo) {
+  restoreSelection(selectionInformation);
+  setEnabled(eventsEnabled);
+  eventsEnabled = null;
+  selectionInformation = null;
+}
+function createHoistableInstance(type, props, rootContainerInstance, internalInstanceHandle) {
+  const ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
+  const domElement = ownerDocument.createElement(type);
+  precacheFiberNode(internalInstanceHandle, domElement);
+  updateFiberProps(domElement, props);
+  setInitialProperties(domElement, type, props);
+  markNodeAsHoistable(domElement);
+  return domElement;
+}
+function createInstance(type, props, rootContainerInstance, hostContext, internalInstanceHandle) {
+  let hostContextProd;
+
+  {
+    hostContextProd = hostContext;
+  }
+
+  const ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
+  let domElement;
+
+  switch (hostContextProd) {
+    case HostContextNamespaceSvg:
+      domElement = ownerDocument.createElementNS(SVG_NAMESPACE, type);
+      break;
+
+    case HostContextNamespaceMath:
+      domElement = ownerDocument.createElementNS(MATH_NAMESPACE, type);
+      break;
+
+    default:
+      switch (type) {
+        case 'svg':
+          {
+            domElement = ownerDocument.createElementNS(SVG_NAMESPACE, type);
+            break;
+          }
+
+        case 'math':
+          {
+            domElement = ownerDocument.createElementNS(MATH_NAMESPACE, type);
+            break;
+          }
+
+        case 'script':
+          {
+            // Create the script via .innerHTML so its "parser-inserted" flag is
+            // set to true and it does not execute
+            const div = ownerDocument.createElement('div');
+
+            div.innerHTML = '<script><' + '/script>'; // eslint-disable-line
+            // This is guaranteed to yield a script element.
+
+            const firstChild = div.firstChild;
+            domElement = div.removeChild(firstChild);
+            break;
+          }
+
+        case 'select':
+          {
+            if (typeof props.is === 'string') {
+              domElement = ownerDocument.createElement('select', {
+                is: props.is
+              });
+            } else {
+              // Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.
+              // See discussion in https://github.com/facebook/react/pull/6896
+              // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
+              domElement = ownerDocument.createElement('select');
+            }
+
+            if (props.multiple) {
+              domElement.multiple = true;
+            } else if (props.size) {
+              // Setting a size greater than 1 causes a select to behave like `multiple=true`, where
+              // it is possible that no option is selected.
+              //
+              // This is only necessary when a select in "single selection mode".
+              domElement.size = props.size;
+            }
+
+            break;
+          }
+
+        default:
+          {
+            if (typeof props.is === 'string') {
+              domElement = ownerDocument.createElement(type, {
+                is: props.is
+              });
+            } else {
+              // Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.
+              // See discussion in https://github.com/facebook/react/pull/6896
+              // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
+              domElement = ownerDocument.createElement(type);
+            }
+          }
+      }
+
+  }
+
+  precacheFiberNode(internalInstanceHandle, domElement);
+  updateFiberProps(domElement, props);
+  return domElement;
+}
+function appendInitialChild(parentInstance, child) {
+  parentInstance.appendChild(child);
+}
+function finalizeInitialChildren(domElement, type, props, hostContext) {
+  setInitialProperties(domElement, type, props);
+
+  switch (type) {
+    case 'button':
+    case 'input':
+    case 'select':
+    case 'textarea':
+      return !!props.autoFocus;
+
+    case 'img':
+      return true;
+
+    default:
+      return false;
+  }
+}
+function shouldSetTextContent(type, props) {
+  return type === 'textarea' || type === 'noscript' || typeof props.children === 'string' || typeof props.children === 'number' || typeof props.dangerouslySetInnerHTML === 'object' && props.dangerouslySetInnerHTML !== null && props.dangerouslySetInnerHTML.__html != null;
+}
+function createTextInstance(text, rootContainerInstance, hostContext, internalInstanceHandle) {
+
+  const textNode = getOwnerDocumentFromRootContainer(rootContainerInstance).createTextNode(text);
+  precacheFiberNode(internalInstanceHandle, textNode);
+  return textNode;
+}
+function getCurrentEventPriority() {
+  const currentEvent = window.event;
+
+  if (currentEvent === undefined) {
+    return DefaultEventPriority;
+  }
+
+  return getEventPriority(currentEvent.type);
+}
+let currentPopstateTransitionEvent = null;
+function shouldAttemptEagerTransition() {
+  const event = window.event;
+
+  if (event && event.type === 'popstate') {
+    // This is a popstate event. Attempt to render any transition during this
+    // event synchronously. Unless we already attempted during this event.
+    if (event === currentPopstateTransitionEvent) {
+      // We already attempted to render this popstate transition synchronously.
+      // Any subsequent attempts must have happened as the result of a derived
+      // update, like startTransition inside useEffect, or useDV. Switch back to
+      // the default behavior for all remaining transitions during the current
+      // popstate event.
+      return false;
+    } else {
+      // Cache the current event in case a derived transition is scheduled.
+      // (Refer to previous branch.)
+      currentPopstateTransitionEvent = event;
+      return true;
+    }
+  } // We're not inside a popstate event.
+
+
+  currentPopstateTransitionEvent = null;
+  return false;
+}
+// if a component just imports ReactDOM (e.g. for findDOMNode).
+// Some environments might not have setTimeout or clearTimeout.
+
+const scheduleTimeout = typeof setTimeout === 'function' ? setTimeout : undefined;
+const cancelTimeout = typeof clearTimeout === 'function' ? clearTimeout : undefined;
+const noTimeout = -1;
+const localPromise = typeof Promise === 'function' ? Promise : undefined;
+function preparePortalMount(portalInstance) {
+  listenToAllSupportedEvents(portalInstance);
+}
+const scheduleMicrotask = typeof queueMicrotask === 'function' ? queueMicrotask : typeof localPromise !== 'undefined' ? callback => localPromise.resolve(null).then(callback).catch(handleErrorInNextTick) : scheduleTimeout; // TODO: Determine the best fallback here.
+
+function handleErrorInNextTick(error) {
+  setTimeout(() => {
+    throw error;
+  });
+} // -------------------
+function commitMount(domElement, type, newProps, internalInstanceHandle) {
+  // Despite the naming that might imply otherwise, this method only
+  // fires if there is an `Update` effect scheduled during mounting.
+  // This happens if `finalizeInitialChildren` returns `true` (which it
+  // does to implement the `autoFocus` attribute on the client). But
+  // there are also other cases when this might happen (such as patching
+  // up text content during hydration mismatch). So we'll check this again.
+  switch (type) {
+    case 'button':
+    case 'input':
+    case 'select':
+    case 'textarea':
+      if (newProps.autoFocus) {
+        domElement.focus();
+      }
+
+      return;
+
+    case 'img':
+      {
+        if (newProps.src) {
+          domElement.src = newProps.src;
+        }
+
+        return;
+      }
+  }
+}
+function commitUpdate(domElement, updatePayload, type, oldProps, newProps, internalInstanceHandle) {
+  // Diff and update the properties.
+  updateProperties(domElement, type, oldProps, newProps); // Update the props handle so that we know which props are the ones with
+  // with current event handlers.
+
+  updateFiberProps(domElement, newProps);
+}
+function resetTextContent(domElement) {
+  setTextContent(domElement, '');
+}
+function commitTextUpdate(textInstance, oldText, newText) {
+  textInstance.nodeValue = newText;
+}
+function appendChild(parentInstance, child) {
+  parentInstance.appendChild(child);
+}
+function appendChildToContainer(container, child) {
+  let parentNode;
+
+  if (container.nodeType === COMMENT_NODE) {
+    parentNode = container.parentNode;
+    parentNode.insertBefore(child, container);
+  } else {
+    parentNode = container;
+    parentNode.appendChild(child);
+  } // This container might be used for a portal.
+  // If something inside a portal is clicked, that click should bubble
+  // through the React tree. However, on Mobile Safari the click would
+  // never bubble through the *DOM* tree unless an ancestor with onclick
+  // event exists. So we wouldn't see it and dispatch it.
+  // This is why we ensure that non React root containers have inline onclick
+  // defined.
+  // https://github.com/facebook/react/issues/11918
+
+
+  const reactRootContainer = container._reactRootContainer;
+
+  if ((reactRootContainer === null || reactRootContainer === undefined) && parentNode.onclick === null) {
+    // TODO: This cast may not be sound for SVG, MathML or custom elements.
+    trapClickOnNonInteractiveElement(parentNode);
+  }
+}
+function insertBefore(parentInstance, child, beforeChild) {
+  parentInstance.insertBefore(child, beforeChild);
+}
+function insertInContainerBefore(container, child, beforeChild) {
+  if (container.nodeType === COMMENT_NODE) {
+    container.parentNode.insertBefore(child, beforeChild);
+  } else {
+    container.insertBefore(child, beforeChild);
+  }
+}
+
+function removeChild(parentInstance, child) {
+  parentInstance.removeChild(child);
+}
+function removeChildFromContainer(container, child) {
+  if (container.nodeType === COMMENT_NODE) {
+    container.parentNode.removeChild(child);
+  } else {
+    container.removeChild(child);
+  }
+}
+function clearSuspenseBoundary(parentInstance, suspenseInstance) {
+  let node = suspenseInstance; // Delete all nodes within this suspense boundary.
+  // There might be nested nodes so we need to keep track of how
+  // deep we are and only break out when we're back on top.
+
+  let depth = 0;
+
+  do {
+    const nextNode = node.nextSibling;
+    parentInstance.removeChild(node);
+
+    if (nextNode && nextNode.nodeType === COMMENT_NODE) {
+      const data = nextNode.data;
+
+      if (data === SUSPENSE_END_DATA) {
+        if (depth === 0) {
+          parentInstance.removeChild(nextNode); // Retry if any event replaying was blocked on this.
+
+          retryIfBlockedOn(suspenseInstance);
+          return;
+        } else {
+          depth--;
+        }
+      } else if (data === SUSPENSE_START_DATA || data === SUSPENSE_PENDING_START_DATA || data === SUSPENSE_FALLBACK_START_DATA) {
+        depth++;
+      }
+    } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+    node = nextNode;
+  } while (node); // TODO: Warn, we didn't find the end comment boundary.
+  // Retry if any event replaying was blocked on this.
+
+
+  retryIfBlockedOn(suspenseInstance);
+}
+function clearSuspenseBoundaryFromContainer(container, suspenseInstance) {
+  if (container.nodeType === COMMENT_NODE) {
+    clearSuspenseBoundary(container.parentNode, suspenseInstance);
+  } else if (container.nodeType === ELEMENT_NODE) {
+    clearSuspenseBoundary(container, suspenseInstance);
+  } else ; // Retry if any event replaying was blocked on this.
+
+
+  retryIfBlockedOn(container);
+}
+function hideInstance(instance) {
+  // TODO: Does this work for all element types? What about MathML? Should we
+  // pass host context to this method?
+  instance = instance;
+  const style = instance.style; // $FlowFixMe[method-unbinding]
+
+  if (typeof style.setProperty === 'function') {
+    style.setProperty('display', 'none', 'important');
+  } else {
+    style.display = 'none';
+  }
+}
+function hideTextInstance(textInstance) {
+  textInstance.nodeValue = '';
+}
+function unhideInstance(instance, props) {
+  instance = instance;
+  const styleProp = props[STYLE];
+  const display = styleProp !== undefined && styleProp !== null && styleProp.hasOwnProperty('display') ? styleProp.display : null;
+  instance.style.display = display == null || typeof display === 'boolean' ? '' : // The value would've errored already if it wasn't safe.
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  ('' + display).trim();
+}
+function unhideTextInstance(textInstance, text) {
+  textInstance.nodeValue = text;
+}
+function clearContainer(container) {
+  {
+    const nodeType = container.nodeType;
+
+    if (nodeType === DOCUMENT_NODE) {
+      clearContainerSparingly(container);
+    } else if (nodeType === ELEMENT_NODE) {
+      switch (container.nodeName) {
+        case 'HEAD':
+        case 'HTML':
+        case 'BODY':
+          clearContainerSparingly(container);
+          return;
+
+        default:
+          {
+            container.textContent = '';
+          }
+      }
+    }
+  }
+}
+
+function clearContainerSparingly(container) {
+  let node;
+  let nextNode = container.firstChild;
+
+  if (nextNode && nextNode.nodeType === DOCUMENT_TYPE_NODE) {
+    nextNode = nextNode.nextSibling;
+  }
+
+  while (nextNode) {
+    node = nextNode;
+    nextNode = nextNode.nextSibling;
+
+    switch (node.nodeName) {
+      case 'HTML':
+      case 'HEAD':
+      case 'BODY':
+        {
+          const element = node;
+          clearContainerSparingly(element); // If these singleton instances had previously been rendered with React they
+          // may still hold on to references to the previous fiber tree. We detatch them
+          // prospectively to reset them to a baseline starting state since we cannot create
+          // new instances.
+
+          detachDeletedInstance(element);
+          continue;
+        }
+      // Script tags are retained to avoid an edge case bug. Normally scripts will execute if they
+      // are ever inserted into the DOM. However when streaming if a script tag is opened but not
+      // yet closed some browsers create and insert the script DOM Node but the script cannot execute
+      // yet until the closing tag is parsed. If something causes React to call clearContainer while
+      // this DOM node is in the document but not yet executable the DOM node will be removed from the
+      // document and when the script closing tag comes in the script will not end up running. This seems
+      // to happen in Chrome/Firefox but not Safari at the moment though this is not necessarily specified
+      // behavior so it could change in future versions of browsers. While leaving all scripts is broader
+      // than strictly necessary this is the least amount of additional code to avoid this breaking
+      // edge case.
+      //
+      // Style tags are retained because they may likely come from 3rd party scripts and extensions
+
+      case 'SCRIPT':
+      case 'STYLE':
+        {
+          continue;
+        }
+      // Stylesheet tags are retained because tehy may likely come from 3rd party scripts and extensions
+
+      case 'LINK':
+        {
+          if (node.rel.toLowerCase() === 'stylesheet') {
+            continue;
+          }
+        }
+    }
+
+    container.removeChild(node);
+  }
+
+  return;
+} // Making this so we can eventually move all of the instance caching to the commit phase.
+function isHydratableText(text) {
+  return text !== '';
+}
+function canHydrateInstance(instance, type, props, inRootOrSingleton) {
+  while (instance.nodeType === ELEMENT_NODE) {
+    const element = instance;
+    const anyProps = props;
+
+    if (element.nodeName.toLowerCase() !== type.toLowerCase()) {
+      if (!inRootOrSingleton || !enableHostSingletons) {
+        // Usually we error for mismatched tags.
+        if (element.nodeName === 'INPUT' && element.type === 'hidden') ; else {
+          return null;
+        }
+      } // In root or singleton parents we skip past mismatched instances.
+
+    } else if (!inRootOrSingleton || !enableHostSingletons) {
+      // Match
+      if (type === 'input' && element.type === 'hidden') {
+
+        const name = anyProps.name == null ? null : '' + anyProps.name;
+
+        if (anyProps.type !== 'hidden' || element.getAttribute('name') !== name) ; else {
+          return element;
+        }
+      } else {
+        return element;
+      }
+    } else if (isMarkedHoistable(element)) ; else {
+      // We have an Element with the right type.
+      // We are going to try to exclude it if we can definitely identify it as a hoisted Node or if
+      // we can guess that the node is likely hoisted or was inserted by a 3rd party script or browser extension
+      // using high entropy attributes for certain types. This technique will fail for strange insertions like
+      // extension prepending <div> in the <body> but that already breaks before and that is an edge case.
+      switch (type) {
+        // case 'title':
+        //We assume all titles are matchable. You should only have one in the Document, at least in a hoistable scope
+        // and if you are a HostComponent with type title we must either be in an <svg> context or this title must have an `itemProp` prop.
+        case 'meta':
+          {
+            // The only way to opt out of hoisting meta tags is to give it an itemprop attribute. We assume there will be
+            // not 3rd party meta tags that are prepended, accepting the cases where this isn't true because meta tags
+            // are usually only functional for SSR so even in a rare case where we did bind to an injected tag the runtime
+            // implications are minimal
+            if (!element.hasAttribute('itemprop')) {
+              // This is a Hoistable
+              break;
+            }
+
+            return element;
+          }
+
+        case 'link':
+          {
+            // Links come in many forms and we do expect 3rd parties to inject them into <head> / <body>. We exclude known resources
+            // and then use high-entroy attributes like href which are almost always used and almost always unique to filter out unlikely
+            // matches.
+            const rel = element.getAttribute('rel');
+
+            if (rel === 'stylesheet' && element.hasAttribute('data-precedence')) {
+              // This is a stylesheet resource
+              break;
+            } else if (rel !== anyProps.rel || element.getAttribute('href') !== (anyProps.href == null ? null : anyProps.href) || element.getAttribute('crossorigin') !== (anyProps.crossOrigin == null ? null : anyProps.crossOrigin) || element.getAttribute('title') !== (anyProps.title == null ? null : anyProps.title)) {
+              // rel + href should usually be enough to uniquely identify a link however crossOrigin can vary for rel preconnect
+              // and title could vary for rel alternate
+              break;
+            }
+
+            return element;
+          }
+
+        case 'style':
+          {
+            // Styles are hard to match correctly. We can exclude known resources but otherwise we accept the fact that a non-hoisted style tags
+            // in <head> or <body> are likely never going to be unmounted given their position in the document and the fact they likely hold global styles
+            if (element.hasAttribute('data-precedence')) {
+              // This is a style resource
+              break;
+            }
+
+            return element;
+          }
+
+        case 'script':
+          {
+            // Scripts are a little tricky, we exclude known resources and then similar to links try to use high-entropy attributes
+            // to reject poor matches. One challenge with scripts are inline scripts. We don't attempt to check text content which could
+            // in theory lead to a hydration error later if a 3rd party injected an inline script before the React rendered nodes.
+            // Falling back to client rendering if this happens should be seemless though so we will try this hueristic and revisit later
+            // if we learn it is problematic
+            const srcAttr = element.getAttribute('src');
+
+            if (srcAttr !== (anyProps.src == null ? null : anyProps.src) || element.getAttribute('type') !== (anyProps.type == null ? null : anyProps.type) || element.getAttribute('crossorigin') !== (anyProps.crossOrigin == null ? null : anyProps.crossOrigin)) {
+              // This script is for a different src/type/crossOrigin. It may be a script resource
+              // or it may just be a mistmatch
+              if (srcAttr && element.hasAttribute('async') && !element.hasAttribute('itemprop')) {
+                // This is an async script resource
+                break;
+              }
+            }
+
+            return element;
+          }
+
+        default:
+          {
+            // We have excluded the most likely cases of mismatch between hoistable tags, 3rd party script inserted tags,
+            // and browser extension inserted tags. While it is possible this is not the right match it is a decent hueristic
+            // that should work in the vast majority of cases.
+            return element;
+          }
+      }
+    }
+
+    const nextInstance = getNextHydratableSibling(element);
+
+    if (nextInstance === null) {
+      break;
+    }
+
+    instance = nextInstance;
+  } // This is a suspense boundary or Text node or we got the end.
+  // Suspense Boundaries are never expected to be injected by 3rd parties. If we see one it should be matched
+  // and this is a hydration error.
+  // Text Nodes are also not expected to be injected by 3rd parties. This is less of a guarantee for <body>
+  // but it seems reasonable and conservative to reject this as a hydration error as well
+
+
+  return null;
+}
+function canHydrateTextInstance(instance, text, inRootOrSingleton) {
+  // Empty strings are not parsed by HTML so there won't be a correct match here.
+  if (text === '') return null;
+
+  while (instance.nodeType !== TEXT_NODE) {
+    if (instance.nodeType === ELEMENT_NODE && instance.nodeName === 'INPUT' && instance.type === 'hidden') ; else if (!inRootOrSingleton || !enableHostSingletons) {
+      return null;
+    }
+
+    const nextInstance = getNextHydratableSibling(instance);
+
+    if (nextInstance === null) {
+      return null;
+    }
+
+    instance = nextInstance;
+  } // This has now been refined to a text node.
+
+
+  return instance;
+}
+function canHydrateSuspenseInstance(instance, inRootOrSingleton) {
+  while (instance.nodeType !== COMMENT_NODE) {
+    if (!inRootOrSingleton || !enableHostSingletons) {
+      return null;
+    }
+
+    const nextInstance = getNextHydratableSibling(instance);
+
+    if (nextInstance === null) {
+      return null;
+    }
+
+    instance = nextInstance;
+  } // This has now been refined to a suspense node.
+
+
+  return instance;
+}
+function isSuspenseInstancePending(instance) {
+  return instance.data === SUSPENSE_PENDING_START_DATA;
+}
+function isSuspenseInstanceFallback(instance) {
+  return instance.data === SUSPENSE_FALLBACK_START_DATA;
+}
+function getSuspenseInstanceFallbackErrorDetails(instance) {
+  const dataset = instance.nextSibling && instance.nextSibling.dataset;
+  let digest;
+
+  if (dataset) {
+    digest = dataset.dgst;
+  }
+
+  {
+    // Object gets DCE'd if constructed in tail position and matches callsite destructuring
+    return {
+      digest
+    };
+  }
+}
+function registerSuspenseInstanceRetry(instance, callback) {
+  instance._reactRetry = callback;
+}
+function canHydrateFormStateMarker(instance, inRootOrSingleton) {
+  while (instance.nodeType !== COMMENT_NODE) {
+    if (!inRootOrSingleton || !enableHostSingletons) {
+      return null;
+    }
+
+    const nextInstance = getNextHydratableSibling(instance);
+
+    if (nextInstance === null) {
+      return null;
+    }
+
+    instance = nextInstance;
+  }
+
+  const nodeData = instance.data;
+
+  if (nodeData === FORM_STATE_IS_MATCHING || nodeData === FORM_STATE_IS_NOT_MATCHING) {
+    const markerInstance = instance;
+    return markerInstance;
+  }
+
+  return null;
+}
+function isFormStateMarkerMatching(markerInstance) {
+  return markerInstance.data === FORM_STATE_IS_MATCHING;
+}
+
+function getNextHydratable(node) {
+  // Skip non-hydratable nodes.
+  for (; node != null; node = node.nextSibling) {
+    const nodeType = node.nodeType;
+
+    if (nodeType === ELEMENT_NODE || nodeType === TEXT_NODE) {
+      break;
+    }
+
+    if (nodeType === COMMENT_NODE) {
+      const nodeData = node.data;
+
+      if (nodeData === SUSPENSE_START_DATA || nodeData === SUSPENSE_FALLBACK_START_DATA || nodeData === SUSPENSE_PENDING_START_DATA || (nodeData === FORM_STATE_IS_MATCHING || nodeData === FORM_STATE_IS_NOT_MATCHING)) {
+        break;
+      }
+
+      if (nodeData === SUSPENSE_END_DATA) {
+        return null;
+      }
+    }
+  }
+
+  return node;
+}
+
+function getNextHydratableSibling(instance) {
+  return getNextHydratable(instance.nextSibling);
+}
+function getFirstHydratableChild(parentInstance) {
+  return getNextHydratable(parentInstance.firstChild);
+}
+function getFirstHydratableChildWithinContainer(parentContainer) {
+  return getNextHydratable(parentContainer.firstChild);
+}
+function getFirstHydratableChildWithinSuspenseInstance(parentInstance) {
+  return getNextHydratable(parentInstance.nextSibling);
+}
+function hydrateInstance(instance, type, props, hostContext, internalInstanceHandle, shouldWarnDev) {
+  precacheFiberNode(internalInstanceHandle, instance); // TODO: Possibly defer this until the commit phase where all the events
+  // get attached.
+
+  updateFiberProps(instance, props); // TODO: Temporary hack to check if we're in a concurrent root. We can delete
+  // when the legacy root API is removed.
+
+  const isConcurrentMode = (internalInstanceHandle.mode & ConcurrentMode) !== NoMode;
+  diffHydratedProperties(instance, type, props, isConcurrentMode);
+}
+function hydrateTextInstance(textInstance, text, internalInstanceHandle, shouldWarnDev) {
+  precacheFiberNode(internalInstanceHandle, textInstance); // TODO: Temporary hack to check if we're in a concurrent root. We can delete
+  return diffHydratedText(textInstance, text);
+}
+function hydrateSuspenseInstance(suspenseInstance, internalInstanceHandle) {
+  precacheFiberNode(internalInstanceHandle, suspenseInstance);
+}
+function getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance) {
+  let node = suspenseInstance.nextSibling; // Skip past all nodes within this suspense boundary.
+  // There might be nested nodes so we need to keep track of how
+  // deep we are and only break out when we're back on top.
+
+  let depth = 0;
+
+  while (node) {
+    if (node.nodeType === COMMENT_NODE) {
+      const data = node.data;
+
+      if (data === SUSPENSE_END_DATA) {
+        if (depth === 0) {
+          return getNextHydratableSibling(node);
+        } else {
+          depth--;
+        }
+      } else if (data === SUSPENSE_START_DATA || data === SUSPENSE_FALLBACK_START_DATA || data === SUSPENSE_PENDING_START_DATA) {
+        depth++;
+      }
+    }
+
+    node = node.nextSibling;
+  } // TODO: Warn, we didn't find the end comment boundary.
+
+
+  return null;
+} // Returns the SuspenseInstance if this node is a direct child of a
+// SuspenseInstance. I.e. if its previous sibling is a Comment with
+// SUSPENSE_x_START_DATA. Otherwise, null.
+
+function getParentSuspenseInstance(targetInstance) {
+  let node = targetInstance.previousSibling; // Skip past all nodes within this suspense boundary.
+  // There might be nested nodes so we need to keep track of how
+  // deep we are and only break out when we're back on top.
+
+  let depth = 0;
+
+  while (node) {
+    if (node.nodeType === COMMENT_NODE) {
+      const data = node.data;
+
+      if (data === SUSPENSE_START_DATA || data === SUSPENSE_FALLBACK_START_DATA || data === SUSPENSE_PENDING_START_DATA) {
+        if (depth === 0) {
+          return node;
+        } else {
+          depth--;
+        }
+      } else if (data === SUSPENSE_END_DATA) {
+        depth++;
+      }
+    }
+
+    node = node.previousSibling;
+  }
+
+  return null;
+}
+function commitHydratedContainer(container) {
+  // Retry if any event replaying was blocked on this.
+  retryIfBlockedOn(container);
+}
+function commitHydratedSuspenseInstance(suspenseInstance) {
+  // Retry if any event replaying was blocked on this.
+  retryIfBlockedOn(suspenseInstance);
+}
+function shouldDeleteUnhydratedTailInstances(parentType) {
+  return (parentType !== 'form' && parentType !== 'button');
+}
+function didNotMatchHydratedContainerTextInstance(parentContainer, textInstance, text, isConcurrentMode, shouldWarnDev) {
+  checkForUnmatchedText(textInstance.nodeValue, text, isConcurrentMode);
+}
+function didNotMatchHydratedTextInstance(parentType, parentProps, parentInstance, textInstance, text, isConcurrentMode, shouldWarnDev) {
+  if (parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
+    checkForUnmatchedText(textInstance.nodeValue, text, isConcurrentMode);
+  }
+}
+function isHostSingletonType(type) {
+  return type === 'html' || type === 'head' || type === 'body';
+}
+function resolveSingletonInstance(type, props, rootContainerInstance, hostContext, validateDOMNestingDev) {
+
+  const ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
+
+  switch (type) {
+    case 'html':
+      {
+        const documentElement = ownerDocument.documentElement;
+
+        if (!documentElement) {
+          throw Error(formatProdErrorMessage(452));
+        }
+
+        return documentElement;
+      }
+
+    case 'head':
+      {
+        const head = ownerDocument.head;
+
+        if (!head) {
+          throw Error(formatProdErrorMessage(453));
+        }
+
+        return head;
+      }
+
+    case 'body':
+      {
+        const body = ownerDocument.body;
+
+        if (!body) {
+          throw Error(formatProdErrorMessage(454));
+        }
+
+        return body;
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(451));
+      }
+  }
+}
+function acquireSingletonInstance(type, props, instance, internalInstanceHandle) {
+
+  const attributes = instance.attributes;
+
+  while (attributes.length) {
+    instance.removeAttributeNode(attributes[0]);
+  }
+
+  setInitialProperties(instance, type, props);
+  precacheFiberNode(internalInstanceHandle, instance);
+  updateFiberProps(instance, props);
+}
+function releaseSingletonInstance(instance) {
+  const attributes = instance.attributes;
+
+  while (attributes.length) {
+    instance.removeAttributeNode(attributes[0]);
+  }
+
+  detachDeletedInstance(instance);
+}
+function clearSingleton(instance) {
+  const element = instance;
+  let node = element.firstChild;
+
+  while (node) {
+    const nextNode = node.nextSibling;
+    const nodeName = node.nodeName;
+
+    if (isMarkedHoistable(node) || nodeName === 'HEAD' || nodeName === 'BODY' || nodeName === 'SCRIPT' || nodeName === 'STYLE' || nodeName === 'LINK' && node.rel.toLowerCase() === 'stylesheet') ; else {
+      element.removeChild(node);
+    }
+
+    node = nextNode;
+  }
+
+  return;
+} // -------------------
+const NotLoaded =
+/*       */
+0b000;
+const Loaded =
+/*          */
+0b001;
+const Errored =
+/*         */
+0b010;
+const Settled =
+/*         */
+0b011;
+const Inserted =
+/*        */
+0b100;
+function prepareToCommitHoistables() {
+  tagCaches = null;
+} // global collections of Resources
+
+const preloadPropsMap = new Map();
+const preconnectsSet = new Set(); // getRootNode is missing from IE and old jsdom versions
+
+function getHoistableRoot(container) {
+  // $FlowFixMe[method-unbinding]
+  return typeof container.getRootNode === 'function' ?
+  /* $FlowFixMe[incompatible-return] Flow types this as returning a `Node`,
+   * but it's either a `Document` or `ShadowRoot`. */
+  container.getRootNode() : container.ownerDocument;
+}
+
+function getCurrentResourceRoot() {
+  const currentContainer = getCurrentRootHostContainer();
+  return currentContainer ? getHoistableRoot(currentContainer) : null;
+}
+
+function getDocumentFromRoot(root) {
+  return root.ownerDocument || root;
+} // We want this to be the default dispatcher on ReactDOMSharedInternals but we don't want to mutate
+// internals in Module scope. Instead we export it and Internals will import it. There is already a cycle
+// from Internals -> ReactDOM -> HostConfig -> Internals so this doesn't introduce a new one.
+
+
+const ReactDOMClientDispatcher = {
+  prefetchDNS: prefetchDNS$1,
+  preconnect: preconnect$1,
+  preload: preload$1,
+  preloadModule: preloadModule$1,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+}; // We expect this to get inlined. It is a function mostly to communicate the special nature of
+// how we resolve the HoistableRoot for ReactDOM.pre*() methods. Because we support calling
+// these methods outside of render there is no way to know which Document or ShadowRoot is 'scoped'
+// and so we have to fall back to something universal. Currently we just refer to the global document.
+// This is notable because nowhere else in ReactDOM do we actually reference the global document or window
+// because we may be rendering inside an iframe.
+
+function getDocumentForImperativeFloatMethods() {
+  return document;
+}
+
+function preconnectAs(rel, href, crossOrigin) {
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (typeof href === 'string' && href) {
+    const limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+    let key = "link[rel=\"" + rel + "\"][href=\"" + limitedEscapedHref + "\"]";
+
+    if (typeof crossOrigin === 'string') {
+      key += "[crossorigin=\"" + crossOrigin + "\"]";
+    }
+
+    if (!preconnectsSet.has(key)) {
+      preconnectsSet.add(key);
+      const preconnectProps = {
+        rel,
+        crossOrigin,
+        href
+      };
+
+      if (null === ownerDocument.querySelector(key)) {
+        const instance = ownerDocument.createElement('link');
+        setInitialProperties(instance, 'link', preconnectProps);
+        markNodeAsHoistable(instance);
+        ownerDocument.head.appendChild(instance);
+      }
+    }
+  }
+}
+
+function prefetchDNS$1(href) {
+
+  preconnectAs('dns-prefetch', href, null);
+}
+
+function preconnect$1(href, crossOrigin) {
+
+  preconnectAs('preconnect', href, crossOrigin);
+}
+
+function preload$1(href, as, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (href && as && ownerDocument) {
+    let preloadSelector = "link[rel=\"preload\"][as=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(as) + "\"]";
+
+    if (as === 'image') {
+      if (options && options.imageSrcSet) {
+        preloadSelector += "[imagesrcset=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(options.imageSrcSet) + "\"]";
+
+        if (typeof options.imageSizes === 'string') {
+          preloadSelector += "[imagesizes=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(options.imageSizes) + "\"]";
+        }
+      } else {
+        preloadSelector += "[href=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(href) + "\"]";
+      }
+    } else {
+      preloadSelector += "[href=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(href) + "\"]";
+    } // Some preloads are keyed under their selector. This happens when the preload is for
+    // an arbitrary type. Other preloads are keyed under the resource key they represent a preload for.
+    // Here we figure out which key to use to determine if we have a preload already.
+
+
+    let key = preloadSelector;
+
+    switch (as) {
+      case 'style':
+        key = getStyleKey(href);
+        break;
+
+      case 'script':
+        key = getScriptKey(href);
+        break;
+    }
+
+    if (!preloadPropsMap.has(key)) {
+      const preloadProps = assign({
+        rel: 'preload',
+        // There is a bug in Safari where imageSrcSet is not respected on preload links
+        // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+        // This harms older browers that do not support imageSrcSet by making their preloads not work
+        // but this population is shrinking fast and is already small so we accept this tradeoff.
+        href: as === 'image' && options && options.imageSrcSet ? undefined : href,
+        as
+      }, options);
+
+      preloadPropsMap.set(key, preloadProps);
+
+      if (null === ownerDocument.querySelector(preloadSelector)) {
+        if (as === 'style' && ownerDocument.querySelector(getStylesheetSelectorFromKey(key))) {
+          // We already have a stylesheet for this key. We don't need to preload it.
+          return;
+        } else if (as === 'script' && ownerDocument.querySelector(getScriptSelectorFromKey(key))) {
+          // We already have a stylesheet for this key. We don't need to preload it.
+          return;
+        }
+
+        const instance = ownerDocument.createElement('link');
+        setInitialProperties(instance, 'link', preloadProps);
+        markNodeAsHoistable(instance);
+        ownerDocument.head.appendChild(instance);
+      }
+    }
+  }
+}
+
+function preloadModule$1(href, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (href) {
+    const as = options && typeof options.as === 'string' ? options.as : 'script';
+    const preloadSelector = "link[rel=\"modulepreload\"][as=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(as) + "\"][href=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(href) + "\"]"; // Some preloads are keyed under their selector. This happens when the preload is for
+    // an arbitrary type. Other preloads are keyed under the resource key they represent a preload for.
+    // Here we figure out which key to use to determine if we have a preload already.
+
+    let key = preloadSelector;
+
+    switch (as) {
+      case 'audioworklet':
+      case 'paintworklet':
+      case 'serviceworker':
+      case 'sharedworker':
+      case 'worker':
+      case 'script':
+        {
+          key = getScriptKey(href);
+          break;
+        }
+    }
+
+    if (!preloadPropsMap.has(key)) {
+      const props = assign({
+        rel: 'modulepreload',
+        href
+      }, options);
+
+      preloadPropsMap.set(key, props);
+
+      if (null === ownerDocument.querySelector(preloadSelector)) {
+        switch (as) {
+          case 'audioworklet':
+          case 'paintworklet':
+          case 'serviceworker':
+          case 'sharedworker':
+          case 'worker':
+          case 'script':
+            {
+              if (ownerDocument.querySelector(getScriptSelectorFromKey(key))) {
+                return;
+              }
+            }
+        }
+
+        const instance = ownerDocument.createElement('link');
+        setInitialProperties(instance, 'link', props);
+        markNodeAsHoistable(instance);
+        ownerDocument.head.appendChild(instance);
+      }
+    }
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (href) {
+    const styles = getResourcesFromRoot(ownerDocument).hoistableStyles;
+    const key = getStyleKey(href);
+    precedence = precedence || 'default'; // Check if this resource already exists
+
+    let resource = styles.get(key);
+
+    if (resource) {
+      // We can early return. The resource exists and there is nothing
+      // more to do
+      return;
+    }
+
+    const state = {
+      loading: NotLoaded,
+      preload: null
+    }; // Attempt to hydrate instance from DOM
+
+    let instance = ownerDocument.querySelector(getStylesheetSelectorFromKey(key));
+
+    if (instance) {
+      state.loading = Loaded | Inserted;
+    } else {
+      // Construct a new instance and insert it
+      const stylesheetProps = assign({
+        rel: 'stylesheet',
+        href,
+        'data-precedence': precedence
+      }, options);
+
+      const preloadProps = preloadPropsMap.get(key);
+
+      if (preloadProps) {
+        adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps);
+      }
+
+      const link = instance = ownerDocument.createElement('link');
+      markNodeAsHoistable(link);
+      setInitialProperties(link, 'link', stylesheetProps);
+      link._p = new Promise((resolve, reject) => {
+        link.onload = resolve;
+        link.onerror = reject;
+      });
+      link.addEventListener('load', () => {
+        state.loading |= Loaded;
+      });
+      link.addEventListener('error', () => {
+        state.loading |= Errored;
+      });
+      state.loading |= Inserted;
+      insertStylesheet(instance, precedence, ownerDocument);
+    } // Construct a Resource and cache it
+
+
+    resource = {
+      type: 'stylesheet',
+      instance,
+      count: 1,
+      state
+    };
+    styles.set(key, resource);
+    return;
+  }
+}
+
+function preinitScript(src, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (src) {
+    const scripts = getResourcesFromRoot(ownerDocument).hoistableScripts;
+    const key = getScriptKey(src); // Check if this resource already exists
+
+    let resource = scripts.get(key);
+
+    if (resource) {
+      // We can early return. The resource exists and there is nothing
+      // more to do
+      return;
+    } // Attempt to hydrate instance from DOM
+
+
+    let instance = ownerDocument.querySelector(getScriptSelectorFromKey(key));
+
+    if (!instance) {
+      // Construct a new instance and insert it
+      const scriptProps = assign({
+        src,
+        async: true
+      }, options); // Adopt certain preload props
+
+
+      const preloadProps = preloadPropsMap.get(key);
+
+      if (preloadProps) {
+        adoptPreloadPropsForScript(scriptProps, preloadProps);
+      }
+
+      instance = ownerDocument.createElement('script');
+      markNodeAsHoistable(instance);
+      setInitialProperties(instance, 'link', scriptProps);
+      ownerDocument.head.appendChild(instance);
+    } // Construct a Resource and cache it
+
+
+    resource = {
+      type: 'script',
+      instance,
+      count: 1,
+      state: null
+    };
+    scripts.set(key, resource);
+    return;
+  }
+}
+
+function preinitModuleScript(src, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (src) {
+    const scripts = getResourcesFromRoot(ownerDocument).hoistableScripts;
+    const key = getScriptKey(src); // Check if this resource already exists
+
+    let resource = scripts.get(key);
+
+    if (resource) {
+      // We can early return. The resource exists and there is nothing
+      // more to do
+      return;
+    } // Attempt to hydrate instance from DOM
+
+
+    let instance = ownerDocument.querySelector(getScriptSelectorFromKey(key));
+
+    if (!instance) {
+      // Construct a new instance and insert it
+      const scriptProps = assign({
+        src,
+        async: true,
+        type: 'module'
+      }, options); // Adopt certain preload props
+
+
+      const preloadProps = preloadPropsMap.get(key);
+
+      if (preloadProps) {
+        adoptPreloadPropsForScript(scriptProps, preloadProps);
+      }
+
+      instance = ownerDocument.createElement('script');
+      markNodeAsHoistable(instance);
+      setInitialProperties(instance, 'link', scriptProps);
+      ownerDocument.head.appendChild(instance);
+    } // Construct a Resource and cache it
+
+
+    resource = {
+      type: 'script',
+      instance,
+      count: 1,
+      state: null
+    };
+    scripts.set(key, resource);
+    return;
+  }
+} // This function is called in begin work and we should always have a currentDocument set
+
+
+function getResource(type, currentProps, pendingProps) {
+  const resourceRoot = getCurrentResourceRoot();
+
+  if (!resourceRoot) {
+    throw Error(formatProdErrorMessage(446));
+  }
+
+  switch (type) {
+    case 'meta':
+    case 'title':
+      {
+        return null;
+      }
+
+    case 'style':
+      {
+        if (typeof pendingProps.precedence === 'string' && typeof pendingProps.href === 'string') {
+          const key = getStyleKey(pendingProps.href);
+          const styles = getResourcesFromRoot(resourceRoot).hoistableStyles;
+          let resource = styles.get(key);
+
+          if (!resource) {
+            resource = {
+              type: 'style',
+              instance: null,
+              count: 0,
+              state: null
+            };
+            styles.set(key, resource);
+          }
+
+          return resource;
+        }
+
+        return {
+          type: 'void',
+          instance: null,
+          count: 0,
+          state: null
+        };
+      }
+
+    case 'link':
+      {
+        if (pendingProps.rel === 'stylesheet' && typeof pendingProps.href === 'string' && typeof pendingProps.precedence === 'string') {
+          const qualifiedProps = pendingProps;
+          const key = getStyleKey(qualifiedProps.href);
+          const styles = getResourcesFromRoot(resourceRoot).hoistableStyles;
+          let resource = styles.get(key);
+
+          if (!resource) {
+            // We asserted this above but Flow can't figure out that the type satisfies
+            const ownerDocument = getDocumentFromRoot(resourceRoot);
+            resource = {
+              type: 'stylesheet',
+              instance: null,
+              count: 0,
+              state: {
+                loading: NotLoaded,
+                preload: null
+              }
+            };
+            styles.set(key, resource);
+
+            if (!preloadPropsMap.has(key)) {
+              preloadStylesheet(ownerDocument, key, preloadPropsFromStylesheet(qualifiedProps), resource.state);
+            }
+          }
+
+          return resource;
+        }
+
+        return null;
+      }
+
+    case 'script':
+      {
+        if (typeof pendingProps.src === 'string' && pendingProps.async === true) {
+          const scriptProps = pendingProps;
+          const key = getScriptKey(scriptProps.src);
+          const scripts = getResourcesFromRoot(resourceRoot).hoistableScripts;
+          let resource = scripts.get(key);
+
+          if (!resource) {
+            resource = {
+              type: 'script',
+              instance: null,
+              count: 0,
+              state: null
+            };
+            scripts.set(key, resource);
+          }
+
+          return resource;
+        }
+
+        return {
+          type: 'void',
+          instance: null,
+          count: 0,
+          state: null
+        };
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(444, type));
+      }
+  }
+}
+
+function styleTagPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    'data-href': rawProps.href,
+    'data-precedence': rawProps.precedence,
+    href: null,
+    precedence: null
+  });
+}
+
+function getStyleKey(href) {
+  const limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+  return "href=\"" + limitedEscapedHref + "\"";
+}
+
+function getStyleTagSelector(href) {
+  const limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+  return "style[data-href~=\"" + limitedEscapedHref + "\"]";
+}
+
+function getStylesheetSelectorFromKey(key) {
+  return "link[rel=\"stylesheet\"][" + key + "]";
+}
+
+function getPreloadStylesheetSelectorFromKey(key) {
+  return "link[rel=\"preload\"][as=\"style\"][" + key + "]";
+}
+
+function stylesheetPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    'data-precedence': rawProps.precedence,
+    precedence: null
+  });
+}
+
+function preloadStylesheet(ownerDocument, key, preloadProps, state) {
+  preloadPropsMap.set(key, preloadProps);
+
+  if (!ownerDocument.querySelector(getStylesheetSelectorFromKey(key))) {
+    // There is no matching stylesheet instance in the Document.
+    // We will insert a preload now to kick off loading because
+    // we expect this stylesheet to commit
+    const preloadEl = ownerDocument.querySelector(getPreloadStylesheetSelectorFromKey(key));
+
+    if (preloadEl) {
+      // If we find a preload already it was SSR'd and we won't have an actual
+      // loading state to track. For now we will just assume it is loaded
+      state.loading = Loaded;
+    } else {
+      const instance = ownerDocument.createElement('link');
+      state.preload = instance;
+      instance.addEventListener('load', () => state.loading |= Loaded);
+      instance.addEventListener('error', () => state.loading |= Errored);
+      setInitialProperties(instance, 'link', preloadProps);
+      markNodeAsHoistable(instance);
+      ownerDocument.head.appendChild(instance);
+    }
+  }
+}
+
+function preloadPropsFromStylesheet(props) {
+  return {
+    rel: 'preload',
+    as: 'style',
+    href: props.href,
+    crossOrigin: props.crossOrigin,
+    integrity: props.integrity,
+    media: props.media,
+    hrefLang: props.hrefLang,
+    referrerPolicy: props.referrerPolicy
+  };
+}
+
+function getScriptKey(src) {
+  const limitedEscapedSrc = escapeSelectorAttributeValueInsideDoubleQuotes(src);
+  return "[src=\"" + limitedEscapedSrc + "\"]";
+}
+
+function getScriptSelectorFromKey(key) {
+  return 'script[async]' + key;
+}
+
+function acquireResource(hoistableRoot, resource, props) {
+  resource.count++;
+
+  if (resource.instance === null) {
+    switch (resource.type) {
+      case 'style':
+        {
+          const qualifiedProps = props; // Attempt to hydrate instance from DOM
+
+          let instance = hoistableRoot.querySelector(getStyleTagSelector(qualifiedProps.href));
+
+          if (instance) {
+            resource.instance = instance;
+            markNodeAsHoistable(instance);
+            return instance;
+          }
+
+          const styleProps = styleTagPropsFromRawProps(props);
+          const ownerDocument = getDocumentFromRoot(hoistableRoot);
+          instance = ownerDocument.createElement('style');
+          markNodeAsHoistable(instance);
+          setInitialProperties(instance, 'style', styleProps); // TODO: `style` does not have loading state for tracking insertions. I
+          // guess because these aren't suspensey? Not sure whether this is a
+          // factoring smell.
+          // resource.state.loading |= Inserted;
+
+          insertStylesheet(instance, qualifiedProps.precedence, hoistableRoot);
+          resource.instance = instance;
+          return instance;
+        }
+
+      case 'stylesheet':
+        {
+          // This typing is enforce by `getResource`. If we change the logic
+          // there for what qualifies as a stylesheet resource we need to ensure
+          // this cast still makes sense;
+          const qualifiedProps = props;
+          const key = getStyleKey(qualifiedProps.href); // Attempt to hydrate instance from DOM
+
+          let instance = hoistableRoot.querySelector(getStylesheetSelectorFromKey(key));
+
+          if (instance) {
+            resource.state.loading |= Inserted;
+            resource.instance = instance;
+            markNodeAsHoistable(instance);
+            return instance;
+          }
+
+          const stylesheetProps = stylesheetPropsFromRawProps(props);
+          const preloadProps = preloadPropsMap.get(key);
+
+          if (preloadProps) {
+            adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps);
+          } // Construct and insert a new instance
+
+
+          const ownerDocument = getDocumentFromRoot(hoistableRoot);
+          instance = ownerDocument.createElement('link');
+          markNodeAsHoistable(instance);
+          const linkInstance = instance;
+          linkInstance._p = new Promise((resolve, reject) => {
+            linkInstance.onload = resolve;
+            linkInstance.onerror = reject;
+          });
+          setInitialProperties(instance, 'link', stylesheetProps);
+          resource.state.loading |= Inserted;
+          insertStylesheet(instance, qualifiedProps.precedence, hoistableRoot);
+          resource.instance = instance;
+          return instance;
+        }
+
+      case 'script':
+        {
+          // This typing is enforce by `getResource`. If we change the logic
+          // there for what qualifies as a stylesheet resource we need to ensure
+          // this cast still makes sense;
+          const borrowedScriptProps = props;
+          const key = getScriptKey(borrowedScriptProps.src); // Attempt to hydrate instance from DOM
+
+          let instance = hoistableRoot.querySelector(getScriptSelectorFromKey(key));
+
+          if (instance) {
+            resource.instance = instance;
+            markNodeAsHoistable(instance);
+            return instance;
+          }
+
+          let scriptProps = borrowedScriptProps;
+          const preloadProps = preloadPropsMap.get(key);
+
+          if (preloadProps) {
+            scriptProps = assign({}, borrowedScriptProps);
+            adoptPreloadPropsForScript(scriptProps, preloadProps);
+          } // Construct and insert a new instance
+
+
+          const ownerDocument = getDocumentFromRoot(hoistableRoot);
+          instance = ownerDocument.createElement('script');
+          markNodeAsHoistable(instance);
+          setInitialProperties(instance, 'link', scriptProps);
+          ownerDocument.head.appendChild(instance);
+          resource.instance = instance;
+          return instance;
+        }
+
+      case 'void':
+        {
+          return null;
+        }
+
+      default:
+        {
+          throw Error(formatProdErrorMessage(443, resource.type));
+        }
+    }
+  } else {
+    // In the case of stylesheets, they might have already been assigned an
+    // instance during `suspendResource`. But that doesn't mean they were
+    // inserted, because the commit might have been interrupted. So we need to
+    // check now.
+    //
+    // The other resource types are unaffected because they are not
+    // yet suspensey.
+    //
+    // TODO: This is a bit of a code smell. Consider refactoring how
+    // `suspendResource` and `acquireResource` work together. The idea is that
+    // `suspendResource` does all the same stuff as `acquireResource` except
+    // for the insertion.
+    if (resource.type === 'stylesheet' && (resource.state.loading & Inserted) === NotLoaded) {
+      const qualifiedProps = props;
+      const instance = resource.instance;
+      resource.state.loading |= Inserted;
+      insertStylesheet(instance, qualifiedProps.precedence, hoistableRoot);
+    }
+  }
+
+  return resource.instance;
+}
+function releaseResource(resource) {
+  resource.count--;
+}
+
+function insertStylesheet(instance, precedence, root) {
+  const nodes = root.querySelectorAll('link[rel="stylesheet"][data-precedence],style[data-precedence]');
+  const last = nodes.length ? nodes[nodes.length - 1] : null;
+  let prior = last;
+
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const nodePrecedence = node.dataset.precedence;
+
+    if (nodePrecedence === precedence) {
+      prior = node;
+    } else if (prior !== last) {
+      break;
+    }
+  }
+
+  if (prior) {
+    // We get the prior from the document so we know it is in the tree.
+    // We also know that links can't be the topmost Node so the parentNode
+    // must exist.
+    prior.parentNode.insertBefore(instance, prior.nextSibling);
+  } else {
+    const parent = root.nodeType === DOCUMENT_NODE ? root.head : root;
+    parent.insertBefore(instance, parent.firstChild);
+  }
+}
+
+function adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps) {
+  if (stylesheetProps.crossOrigin == null) stylesheetProps.crossOrigin = preloadProps.crossOrigin;
+  if (stylesheetProps.referrerPolicy == null) stylesheetProps.referrerPolicy = preloadProps.referrerPolicy;
+  if (stylesheetProps.title == null) stylesheetProps.title = preloadProps.title;
+}
+
+function adoptPreloadPropsForScript(scriptProps, preloadProps) {
+  if (scriptProps.crossOrigin == null) scriptProps.crossOrigin = preloadProps.crossOrigin;
+  if (scriptProps.referrerPolicy == null) scriptProps.referrerPolicy = preloadProps.referrerPolicy;
+  if (scriptProps.integrity == null) scriptProps.integrity = preloadProps.integrity;
+}
+
+let tagCaches = null;
+function hydrateHoistable(hoistableRoot, type, props, internalInstanceHandle) {
+  const ownerDocument = getDocumentFromRoot(hoistableRoot);
+  let instance = null;
+
+  getInstance: switch (type) {
+    case 'title':
+      {
+        instance = ownerDocument.getElementsByTagName('title')[0];
+
+        if (!instance || isOwnedInstance(instance) || instance.namespaceURI === SVG_NAMESPACE || instance.hasAttribute('itemprop')) {
+          instance = ownerDocument.createElement(type);
+          ownerDocument.head.insertBefore(instance, ownerDocument.querySelector('head > title'));
+        }
+
+        setInitialProperties(instance, type, props);
+        precacheFiberNode(internalInstanceHandle, instance);
+        markNodeAsHoistable(instance);
+        return instance;
+      }
+
+    case 'link':
+      {
+        const cache = getHydratableHoistableCache('link', 'href', ownerDocument);
+        const key = type + (props.href || '');
+        const maybeNodes = cache.get(key);
+
+        if (maybeNodes) {
+          const nodes = maybeNodes;
+
+          for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i];
+
+            if (node.getAttribute('href') !== (props.href == null ? null : props.href) || node.getAttribute('rel') !== (props.rel == null ? null : props.rel) || node.getAttribute('title') !== (props.title == null ? null : props.title) || node.getAttribute('crossorigin') !== (props.crossOrigin == null ? null : props.crossOrigin)) {
+              // mismatch, try the next node;
+              continue;
+            }
+
+            instance = node;
+            nodes.splice(i, 1);
+            break getInstance;
+          }
+        }
+
+        instance = ownerDocument.createElement(type);
+        setInitialProperties(instance, type, props);
+        ownerDocument.head.appendChild(instance);
+        break;
+      }
+
+    case 'meta':
+      {
+        const cache = getHydratableHoistableCache('meta', 'content', ownerDocument);
+        const key = type + (props.content || '');
+        const maybeNodes = cache.get(key);
+
+        if (maybeNodes) {
+          const nodes = maybeNodes;
+
+          for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i]; // We coerce content to string because it is the most likely one to
+
+            if (node.getAttribute('content') !== (props.content == null ? null : '' + props.content) || node.getAttribute('name') !== (props.name == null ? null : props.name) || node.getAttribute('property') !== (props.property == null ? null : props.property) || node.getAttribute('http-equiv') !== (props.httpEquiv == null ? null : props.httpEquiv) || node.getAttribute('charset') !== (props.charSet == null ? null : props.charSet)) {
+              // mismatch, try the next node;
+              continue;
+            }
+
+            instance = node;
+            nodes.splice(i, 1);
+            break getInstance;
+          }
+        }
+
+        instance = ownerDocument.createElement(type);
+        setInitialProperties(instance, type, props);
+        ownerDocument.head.appendChild(instance);
+        break;
+      }
+
+    default:
+      throw Error(formatProdErrorMessage(468, type));
+  } // This node is a match
+
+
+  precacheFiberNode(internalInstanceHandle, instance);
+  markNodeAsHoistable(instance);
+  return instance;
+}
+
+function getHydratableHoistableCache(type, keyAttribute, ownerDocument) {
+  let cache;
+  let caches;
+
+  if (tagCaches === null) {
+    cache = new Map();
+    caches = tagCaches = new Map();
+    caches.set(ownerDocument, cache);
+  } else {
+    caches = tagCaches;
+    const maybeCache = caches.get(ownerDocument);
+
+    if (!maybeCache) {
+      cache = new Map();
+      caches.set(ownerDocument, cache);
+    } else {
+      cache = maybeCache;
+    }
+  }
+
+  if (cache.has(type)) {
+    // We use type as a special key that signals that this cache has been seeded for this type
+    return cache;
+  } // Mark this cache as seeded for this type
+
+
+  cache.set(type, null);
+  const nodes = ownerDocument.getElementsByTagName(type);
+
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+
+    if (!isOwnedInstance(node) && (type !== 'link' || node.getAttribute('rel') !== 'stylesheet') && node.namespaceURI !== SVG_NAMESPACE) {
+      const nodeKey = node.getAttribute(keyAttribute) || '';
+      const key = type + nodeKey;
+      const existing = cache.get(key);
+
+      if (existing) {
+        existing.push(node);
+      } else {
+        cache.set(key, [node]);
+      }
+    }
+  }
+
+  return cache;
+}
+
+function mountHoistable(hoistableRoot, type, instance) {
+  const ownerDocument = getDocumentFromRoot(hoistableRoot);
+  ownerDocument.head.insertBefore(instance, type === 'title' ? ownerDocument.querySelector('head > title') : null);
+}
+function unmountHoistable(instance) {
+  instance.parentNode.removeChild(instance);
+}
+function isHostHoistableType(type, props, hostContext) {
+  let hostContextProd;
+
+  {
+    hostContextProd = hostContext;
+  } // Global opt out of hoisting for anything in SVG Namespace or anything with an itemProp inside an itemScope
+
+
+  if (hostContextProd === HostContextNamespaceSvg || props.itemProp != null) {
+
+    return false;
+  }
+
+  switch (type) {
+    case 'meta':
+    case 'title':
+      {
+        return true;
+      }
+
+    case 'style':
+      {
+        if (typeof props.precedence !== 'string' || typeof props.href !== 'string' || props.href === '') {
+
+          return false;
+        }
+
+        return true;
+      }
+
+    case 'link':
+      {
+        if (typeof props.rel !== 'string' || typeof props.href !== 'string' || props.href === '' || props.onLoad || props.onError) {
+
+          return false;
+        }
+
+        switch (props.rel) {
+          case 'stylesheet':
+            {
+              const precedence = props.precedence,
+                    disabled = props.disabled;
+
+              return typeof precedence === 'string' && disabled == null;
+            }
+
+          default:
+            {
+              return true;
+            }
+        }
+      }
+
+    case 'script':
+      {
+        if (props.async !== true || props.onLoad || props.onError || typeof props.src !== 'string' || !props.src) {
+
+          return false;
+        }
+
+        return true;
+      }
+
+    case 'noscript':
+    case 'template':
+      {
+
+        return false;
+      }
+  }
+
+  return false;
+}
+function mayResourceSuspendCommit(resource) {
+  return resource.type === 'stylesheet' && (resource.state.loading & Inserted) === NotLoaded;
+}
+function preloadInstance(type, props) {
+  // Return true to indicate it's already loaded
+  return true;
+}
+function preloadResource(resource) {
+  if (resource.type === 'stylesheet' && (resource.state.loading & Settled) === NotLoaded) {
+    // we have not finished loading the underlying stylesheet yet.
+    return false;
+  } // Return true to indicate it's already loaded
+
+
+  return true;
+}
+let suspendedState = null; // We use a noop function when we begin suspending because if possible we want the
+// waitfor step to finish synchronously. If it doesn't we'll return a function to
+// provide the actual unsuspend function and that will get completed when the count
+// hits zero or it will get cancelled if the root starts new work.
+
+function noop() {}
+
+function startSuspendingCommit() {
+  suspendedState = {
+    stylesheets: null,
+    count: 0,
+    unsuspend: noop
+  };
+}
+function suspendResource(hoistableRoot, resource, props) {
+  if (suspendedState === null) {
+    throw Error(formatProdErrorMessage(475));
+  }
+
+  const state = suspendedState;
+
+  if (resource.type === 'stylesheet') {
+    if (typeof props.media === 'string') {
+      // If we don't currently match media we avoid suspending on this resource
+      // and let it insert on the mutation path
+      if (matchMedia(props.media).matches === false) {
+        return;
+      }
+    }
+
+    if ((resource.state.loading & Inserted) === NotLoaded) {
+      if (resource.instance === null) {
+        const qualifiedProps = props;
+        const key = getStyleKey(qualifiedProps.href); // Attempt to hydrate instance from DOM
+
+        let instance = hoistableRoot.querySelector(getStylesheetSelectorFromKey(key));
+
+        if (instance) {
+          // If this instance has a loading state it came from the Fizz runtime.
+          // If there is not loading state it is assumed to have been server rendered
+          // as part of the preamble and therefore synchronously loaded. It could have
+          // errored however which we still do not yet have a means to detect. For now
+          // we assume it is loaded.
+          const maybeLoadingState = instance._p;
+
+          if (maybeLoadingState !== null && typeof maybeLoadingState === 'object' && // $FlowFixMe[method-unbinding]
+          typeof maybeLoadingState.then === 'function') {
+            const loadingState = maybeLoadingState;
+            state.count++;
+            const ping = onUnsuspend.bind(state);
+            loadingState.then(ping, ping);
+          }
+
+          resource.state.loading |= Inserted;
+          resource.instance = instance;
+          markNodeAsHoistable(instance);
+          return;
+        }
+
+        const ownerDocument = getDocumentFromRoot(hoistableRoot);
+        const stylesheetProps = stylesheetPropsFromRawProps(props);
+        const preloadProps = preloadPropsMap.get(key);
+
+        if (preloadProps) {
+          adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps);
+        } // Construct and insert a new instance
+
+
+        instance = ownerDocument.createElement('link');
+        markNodeAsHoistable(instance);
+        const linkInstance = instance; // This Promise is a loading state used by the Fizz runtime. We need this incase there is a race
+        // between this resource being rendered on the client and being rendered with a late completed boundary.
+
+        linkInstance._p = new Promise((resolve, reject) => {
+          linkInstance.onload = resolve;
+          linkInstance.onerror = reject;
+        });
+        setInitialProperties(instance, 'link', stylesheetProps);
+        resource.instance = instance;
+      }
+
+      if (state.stylesheets === null) {
+        state.stylesheets = new Map();
+      }
+
+      state.stylesheets.set(resource, hoistableRoot);
+      const preloadEl = resource.state.preload;
+
+      if (preloadEl && (resource.state.loading & Settled) === NotLoaded) {
+        state.count++;
+        const ping = onUnsuspend.bind(state);
+        preloadEl.addEventListener('load', ping);
+        preloadEl.addEventListener('error', ping);
+      }
+    }
+  }
+}
+function waitForCommitToBeReady() {
+  if (suspendedState === null) {
+    throw Error(formatProdErrorMessage(475));
+  }
+
+  const state = suspendedState;
+
+  if (state.stylesheets && state.count === 0) {
+    // We are not currently blocked but we have not inserted all stylesheets.
+    // If this insertion happens and loads or errors synchronously then we can
+    // avoid suspending the commit. To do this we check the count again immediately after
+    insertSuspendedStylesheets(state, state.stylesheets);
+  } // We need to check the count again because the inserted stylesheets may have led to new
+  // tasks to wait on.
+
+
+  if (state.count > 0) {
+    return commit => {
+      // We almost never want to show content before its styles have loaded. But
+      // eventually we will give up and allow unstyled content. So this number is
+      // somewhat arbitrary — big enough that you'd only reach it under
+      // extreme circumstances.
+      // TODO: Figure out what the browser engines do during initial page load and
+      // consider aligning our behavior with that.
+      const stylesheetTimer = setTimeout(() => {
+        if (state.stylesheets) {
+          insertSuspendedStylesheets(state, state.stylesheets);
+        }
+
+        if (state.unsuspend) {
+          const unsuspend = state.unsuspend;
+          state.unsuspend = null;
+          unsuspend();
+        }
+      }, 60000); // one minute
+
+      state.unsuspend = commit;
+      return () => {
+        state.unsuspend = null;
+        clearTimeout(stylesheetTimer);
+      };
+    };
+  }
+
+  return null;
+}
+
+function onUnsuspend() {
+  this.count--;
+
+  if (this.count === 0) {
+    if (this.stylesheets) {
+      // If we haven't actually inserted the stylesheets yet we need to do so now before starting the commit.
+      // The reason we do this after everything else has finished is because we want to have all the stylesheets
+      // load synchronously right before mutating. Ideally the new styles will cause a single recalc only on the
+      // new tree. When we filled up stylesheets we only inlcuded stylesheets with matching media attributes so we
+      // wait for them to load before actually continuing. We expect this to increase the count above zero
+      insertSuspendedStylesheets(this, this.stylesheets);
+    } else if (this.unsuspend) {
+      const unsuspend = this.unsuspend;
+      this.unsuspend = null;
+      unsuspend();
+    }
+  }
+} // This is typecast to non-null because it will always be set before read.
+// it is important that this not be used except when the stack guarantees it exists.
+// Currentlyt his is only during insertSuspendedStylesheet.
+
+
+let precedencesByRoot = null;
+
+function insertSuspendedStylesheets(state, resources) {
+  // We need to clear this out so we don't try to reinsert after the stylesheets have loaded
+  state.stylesheets = null;
+
+  if (state.unsuspend === null) {
+    // The suspended commit was cancelled. We don't need to insert any stylesheets.
+    return;
+  } // Temporarily increment count. we don't want any synchronously loaded stylesheets to try to unsuspend
+  // before we finish inserting all stylesheets.
+
+
+  state.count++;
+  precedencesByRoot = new Map();
+  resources.forEach(insertStylesheetIntoRoot, state);
+  precedencesByRoot = null; // We can remove our temporary count and if we're still at zero we can unsuspend.
+  // If we are in the synchronous phase before deciding if the commit should suspend and this
+  // ends up hitting the unsuspend path it will just invoke the noop unsuspend.
+
+  onUnsuspend.call(state);
+}
+
+function insertStylesheetIntoRoot(root, resource, map) {
+  if (resource.state.loading & Inserted) {
+    // This resource was inserted by another root committing. we don't need to insert it again
+    return;
+  }
+
+  let last;
+  let precedences = precedencesByRoot.get(root);
+
+  if (!precedences) {
+    precedences = new Map();
+    precedencesByRoot.set(root, precedences);
+    const nodes = root.querySelectorAll('link[data-precedence],style[data-precedence]');
+
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+
+      if (node.nodeName === 'link' || // We omit style tags with media="not all" because they are not in the right position
+      // and will be hoisted by the Fizz runtime imminently.
+      node.getAttribute('media') !== 'not all') {
+        precedences.set('p' + node.dataset.precedence, node);
+        last = node;
+      }
+    }
+
+    if (last) {
+      precedences.set('last', last);
+    }
+  } else {
+    last = precedences.get('last');
+  } // We only call this after we have constructed an instance so we assume it here
+
+
+  const instance = resource.instance; // We will always have a precedence for stylesheet instances
+
+  const precedence = instance.getAttribute('data-precedence');
+  const prior = precedences.get('p' + precedence) || last;
+
+  if (prior === last) {
+    precedences.set('last', instance);
+  }
+
+  precedences.set(precedence, instance);
+  this.count++;
+  const onComplete = onUnsuspend.bind(this);
+  instance.addEventListener('load', onComplete);
+  instance.addEventListener('error', onComplete);
+
+  if (prior) {
+    prior.parentNode.insertBefore(instance, prior.nextSibling);
+  } else {
+    const parent = root.nodeType === DOCUMENT_NODE ? root.head : root;
+    parent.insertBefore(instance, parent.firstChild);
+  }
+
+  resource.state.loading |= Inserted;
+}
+
+const NotPendingTransition = NotPending;
+
+const Dispatcher$1 = Internals.Dispatcher;
+
+if (typeof document !== 'undefined') {
+  // Set the default dispatcher to the client dispatcher
+  Dispatcher$1.current = ReactDOMClientDispatcher;
+}
+/* global reportError */
+
+const defaultOnRecoverableError = typeof reportError === 'function' ? // In modern browsers, reportError will dispatch an error event,
+// emulating an uncaught JavaScript error.
+reportError : error => {
+  // In older browsers and test environments, fallback to console.error.
+  // eslint-disable-next-line react-internal/no-production-logging
+  console['error'](error);
+}; // $FlowFixMe[missing-this-annot]
+
+function ReactDOMRoot(internalRoot) {
+  this._internalRoot = internalRoot;
+} // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+ReactDOMHydrationRoot.prototype.render = ReactDOMRoot.prototype.render = // $FlowFixMe[missing-this-annot]
+function (children) {
+  const root = this._internalRoot;
+
+  if (root === null) {
+    throw Error(formatProdErrorMessage(409));
+  }
+
+  updateContainer(children, root, null, null);
+}; // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+ReactDOMHydrationRoot.prototype.unmount = ReactDOMRoot.prototype.unmount = // $FlowFixMe[missing-this-annot]
+function () {
+
+  const root = this._internalRoot;
+
+  if (root !== null) {
+    this._internalRoot = null;
+    const container = root.containerInfo;
+
+    flushSync$1(() => {
+      updateContainer(null, root, null, null);
+    });
+    unmarkContainerAsRoot(container);
+  }
+};
+
+function createRoot$1(container, options) {
+  if (!isValidContainer(container)) {
+    throw Error(formatProdErrorMessage(299));
+  }
+  let isStrictMode = false;
+  let concurrentUpdatesByDefaultOverride = false;
+  let identifierPrefix = '';
+  let onRecoverableError = defaultOnRecoverableError;
+  let transitionCallbacks = null;
+
+  if (options !== null && options !== undefined) {
+
+    if (options.unstable_strictMode === true) {
+      isStrictMode = true;
+    }
+
+    if (options.identifierPrefix !== undefined) {
+      identifierPrefix = options.identifierPrefix;
+    }
+
+    if (options.onRecoverableError !== undefined) {
+      onRecoverableError = options.onRecoverableError;
+    }
+
+    if (options.unstable_transitionCallbacks !== undefined) {
+      transitionCallbacks = options.unstable_transitionCallbacks;
+    }
+  }
+
+  const root = createContainer(container, ConcurrentRoot, null, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks);
+  markContainerAsRoot(root.current, container);
+  Dispatcher$1.current = ReactDOMClientDispatcher;
+  const rootContainerElement = container.nodeType === COMMENT_NODE ? container.parentNode : container;
+  listenToAllSupportedEvents(rootContainerElement); // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
+
+  return new ReactDOMRoot(root);
+} // $FlowFixMe[missing-this-annot]
+
+function ReactDOMHydrationRoot(internalRoot) {
+  this._internalRoot = internalRoot;
+}
+
+function scheduleHydration(target) {
+  if (target) {
+    queueExplicitHydrationTarget(target);
+  }
+} // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+ReactDOMHydrationRoot.prototype.unstable_scheduleHydration = scheduleHydration;
+function hydrateRoot$1(container, initialChildren, options) {
+  if (!isValidContainer(container)) {
+    throw Error(formatProdErrorMessage(405));
+  }
+  // the hydration callbacks.
+
+
+  const hydrationCallbacks = options != null ? options : null;
+  let isStrictMode = false;
+  let concurrentUpdatesByDefaultOverride = false;
+  let identifierPrefix = '';
+  let onRecoverableError = defaultOnRecoverableError;
+  let transitionCallbacks = null;
+  let formState = null;
+
+  if (options !== null && options !== undefined) {
+    if (options.unstable_strictMode === true) {
+      isStrictMode = true;
+    }
+
+    if (options.identifierPrefix !== undefined) {
+      identifierPrefix = options.identifierPrefix;
+    }
+
+    if (options.onRecoverableError !== undefined) {
+      onRecoverableError = options.onRecoverableError;
+    }
+
+    if (options.unstable_transitionCallbacks !== undefined) {
+      transitionCallbacks = options.unstable_transitionCallbacks;
+    }
+
+    {
+      if (options.formState !== undefined) {
+        formState = options.formState;
+      }
+    }
+  }
+
+  const root = createHydrationContainer(initialChildren, null, container, ConcurrentRoot, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks, formState);
+  markContainerAsRoot(root.current, container);
+  Dispatcher$1.current = ReactDOMClientDispatcher; // This can't be a comment node since hydration doesn't work on comment nodes anyway.
+
+  listenToAllSupportedEvents(container); // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
+
+  return new ReactDOMHydrationRoot(root);
+}
+function isValidContainer(node) {
+  return !!(node && (node.nodeType === ELEMENT_NODE || node.nodeType === DOCUMENT_NODE || node.nodeType === DOCUMENT_FRAGMENT_NODE || !disableCommentsAsDOMContainers  ));
+} // TODO: Remove this function which also includes comment nodes.
+// We only use it in places that are currently more relaxed.
+
+function isValidContainerLegacy(node) {
+  return !!(node && (node.nodeType === ELEMENT_NODE || node.nodeType === DOCUMENT_NODE || node.nodeType === DOCUMENT_FRAGMENT_NODE || node.nodeType === COMMENT_NODE && node.nodeValue === ' react-mount-point-unstable '));
+}
+
+function noopOnRecoverableError() {// This isn't reachable because onRecoverableError isn't called in the
+  // legacy API.
+}
+
+function legacyCreateRootFromDOMContainer(container, initialChildren, parentComponent, callback, isHydrationContainer) {
+  if (isHydrationContainer) {
+    if (typeof callback === 'function') {
+      const originalCallback = callback;
+
+      callback = function () {
+        const instance = getPublicRootInstance(root);
+        originalCallback.call(instance);
+      };
+    }
+
+    const root = createHydrationContainer(initialChildren, callback, container, LegacyRoot, null, // hydrationCallbacks
+    false, // isStrictMode
+    false, // concurrentUpdatesByDefaultOverride,
+    '', // identifierPrefix
+    noopOnRecoverableError, // TODO(luna) Support hydration later
+    null, null);
+    container._reactRootContainer = root;
+    markContainerAsRoot(root.current, container);
+    const rootContainerElement = container.nodeType === COMMENT_NODE ? container.parentNode : container; // $FlowFixMe[incompatible-call]
+
+    listenToAllSupportedEvents(rootContainerElement);
+    flushSync$1();
+    return root;
+  } else {
+    // First clear any existing content.
+    clearContainer(container);
+
+    if (typeof callback === 'function') {
+      const originalCallback = callback;
+
+      callback = function () {
+        const instance = getPublicRootInstance(root);
+        originalCallback.call(instance);
+      };
+    }
+
+    const root = createContainer(container, LegacyRoot, null, // hydrationCallbacks
+    false, // isStrictMode
+    false, // concurrentUpdatesByDefaultOverride,
+    '', // identifierPrefix
+    noopOnRecoverableError, // onRecoverableError
+    null // transitionCallbacks
+    );
+    container._reactRootContainer = root;
+    markContainerAsRoot(root.current, container);
+    const rootContainerElement = container.nodeType === COMMENT_NODE ? container.parentNode : container; // $FlowFixMe[incompatible-call]
+
+    listenToAllSupportedEvents(rootContainerElement); // Initial mount should not be batched.
+
+    flushSync$1(() => {
+      updateContainer(initialChildren, root, parentComponent, callback);
+    });
+    return root;
+  }
+}
+
+function legacyRenderSubtreeIntoContainer(parentComponent, children, container, forceHydrate, callback) {
+
+  const maybeRoot = container._reactRootContainer;
+  let root;
+
+  if (!maybeRoot) {
+    // Initial mount
+    root = legacyCreateRootFromDOMContainer(container, children, parentComponent, callback, forceHydrate);
+  } else {
+    root = maybeRoot;
+
+    if (typeof callback === 'function') {
+      const originalCallback = callback;
+
+      callback = function () {
+        const instance = getPublicRootInstance(root);
+        originalCallback.call(instance);
+      };
+    } // Update
+
+
+    updateContainer(children, root, parentComponent, callback);
+  }
+
+  return getPublicRootInstance(root);
+}
+
+function findDOMNode(componentOrElement) {
+
+  if (componentOrElement == null) {
+    return null;
+  }
+
+  if (componentOrElement.nodeType === ELEMENT_NODE) {
+    return componentOrElement;
+  }
+
+  return findHostInstance(componentOrElement);
+}
+function hydrate(element, container, callback) {
+
+  if (!isValidContainerLegacy(container)) {
+    throw Error(formatProdErrorMessage(200));
+  }
+
+
+  return legacyRenderSubtreeIntoContainer(null, element, container, true, callback);
+}
+function render(element, container, callback) {
+
+  if (!isValidContainerLegacy(container)) {
+    throw Error(formatProdErrorMessage(200));
+  }
+
+  return legacyRenderSubtreeIntoContainer(null, element, container, false, callback);
+}
+function unstable_renderSubtreeIntoContainer(parentComponent, element, containerNode, callback) {
+
+  if (!isValidContainerLegacy(containerNode)) {
+    throw Error(formatProdErrorMessage(200));
+  }
+
+  if (parentComponent == null || !has(parentComponent)) {
+    throw Error(formatProdErrorMessage(38));
+  }
+
+  return legacyRenderSubtreeIntoContainer(parentComponent, element, containerNode, false, callback);
+}
+function unmountComponentAtNode(container) {
+  if (!isValidContainerLegacy(container)) {
+    throw Error(formatProdErrorMessage(40));
+  }
+
+  if (container._reactRootContainer) {
+
+
+    flushSync$1(() => {
+      legacyRenderSubtreeIntoContainer(null, null, container, false, () => {
+        // $FlowFixMe[incompatible-type] This should probably use `delete container._reactRootContainer`
+        container._reactRootContainer = null;
+        unmarkContainerAsRoot(container);
+      });
+    }); // If you call unmountComponentAtNode twice in quick succession, you'll
+    // get `true` twice. That's probably fine?
+
+    return true;
+  } else {
+
+    return false;
+  }
+}
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+function getCrossOriginStringAs(as, input) {
+  if (as === 'font') {
+    return '';
+  }
+
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+const Dispatcher = Internals.Dispatcher;
+function prefetchDNS(href) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    dispatcher.prefetchDNS(href);
+  } // We don't error because preconnect needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preconnect(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    const crossOrigin = options ? getCrossOriginString(options.crossOrigin) : null;
+    dispatcher.preconnect(href, crossOrigin);
+  } // We don't error because preconnect needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preload(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string' && // We check existence because we cannot enforce this function is actually called with the stated type
+  typeof options === 'object' && options !== null && typeof options.as === 'string') {
+    const as = options.as;
+    const crossOrigin = getCrossOriginStringAs(as, options.crossOrigin);
+    dispatcher.preload(href, as, {
+      crossOrigin,
+      integrity: typeof options.integrity === 'string' ? options.integrity : undefined,
+      nonce: typeof options.nonce === 'string' ? options.nonce : undefined,
+      type: typeof options.type === 'string' ? options.type : undefined,
+      fetchPriority: typeof options.fetchPriority === 'string' ? options.fetchPriority : undefined,
+      referrerPolicy: typeof options.referrerPolicy === 'string' ? options.referrerPolicy : undefined,
+      imageSrcSet: typeof options.imageSrcSet === 'string' ? options.imageSrcSet : undefined,
+      imageSizes: typeof options.imageSizes === 'string' ? options.imageSizes : undefined
+    });
+  } // We don't error because preload needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preloadModule(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    if (options) {
+      const crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);
+      dispatcher.preloadModule(href, {
+        as: typeof options.as === 'string' && options.as !== 'script' ? options.as : undefined,
+        crossOrigin,
+        integrity: typeof options.integrity === 'string' ? options.integrity : undefined
+      });
+    } else {
+      dispatcher.preloadModule(href);
+    }
+  } // We don't error because preload needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preinit(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string' && options && typeof options.as === 'string') {
+    const as = options.as;
+    const crossOrigin = getCrossOriginStringAs(as, options.crossOrigin);
+    const integrity = typeof options.integrity === 'string' ? options.integrity : undefined;
+    const fetchPriority = typeof options.fetchPriority === 'string' ? options.fetchPriority : undefined;
+
+    if (as === 'style') {
+      dispatcher.preinitStyle(href, typeof options.precedence === 'string' ? options.precedence : undefined, {
+        crossOrigin,
+        integrity,
+        fetchPriority
+      });
+    } else if (as === 'script') {
+      dispatcher.preinitScript(href, {
+        crossOrigin,
+        integrity,
+        fetchPriority,
+        nonce: typeof options.nonce === 'string' ? options.nonce : undefined
+      });
+    }
+  } // We don't error because preinit needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preinitModule(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    if (typeof options === 'object' && options !== null) {
+      if (options.as == null || options.as === 'script') {
+        const crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);
+        dispatcher.preinitModuleScript(href, {
+          crossOrigin,
+          integrity: typeof options.integrity === 'string' ? options.integrity : undefined,
+          nonce: typeof options.nonce === 'string' ? options.nonce : undefined
+        });
+      }
+    } else if (options == null) {
+      dispatcher.preinitModuleScript(href);
+    }
+  } // We don't error because preinit needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+
+function createPortal(children, container) {
+  let key = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+
+  if (!isValidContainer(container)) {
+    throw Error(formatProdErrorMessage(200));
+  } // TODO: pass ReactDOM portal implementation as third argument
+  // $FlowFixMe[incompatible-return] The Flow type is opaque but there's no way to actually create it.
+
+
+  return createPortal$1(children, container, null, key);
+}
+
+function renderSubtreeIntoContainer(parentComponent, element, containerNode, callback) {
+  return unstable_renderSubtreeIntoContainer(parentComponent, element, containerNode, callback);
+}
+
+function createRoot(container, options) {
+
+  return createRoot$1(container, options);
+}
+
+function hydrateRoot(container, initialChildren, options) {
+
+  return hydrateRoot$1(container, initialChildren, options);
+} // Overload the definition to the two valid signatures.
+// Warning, this opts-out of checking the function body.
+// eslint-disable-next-line no-redeclare
+// eslint-disable-next-line no-redeclare
+
+
+function flushSync(fn) {
+
+  return flushSync$1(fn);
+}
+// This is an array for better minification.
+
+Internals.Events = [getInstanceFromNode, getNodeFromInstance, getFiberCurrentPropsFromNode, enqueueStateRestore, restoreStateIfNeeded, batchedUpdates$1];
+injectIntoDevTools({
+  findFiberByHostInstance: getClosestInstanceFromNode,
+  bundleType: 0,
+  version: ReactVersion,
+  rendererPackageName: 'react-dom'
+});
+
+exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = Internals;
+exports.createPortal = createPortal;
+exports.createRoot = createRoot;
+exports.findDOMNode = findDOMNode;
+exports.flushSync = flushSync;
+exports.hydrate = hydrate;
+exports.hydrateRoot = hydrateRoot;
+exports.preconnect = preconnect;
+exports.prefetchDNS = prefetchDNS;
+exports.preinit = preinit;
+exports.preinitModule = preinitModule;
+exports.preload = preload;
+exports.preloadModule = preloadModule;
+exports.render = render;
+exports.unmountComponentAtNode = unmountComponentAtNode;
+exports.unstable_batchedUpdates = batchedUpdates$1;
+exports.unstable_renderSubtreeIntoContainer = renderSubtreeIntoContainer;
+exports.useFormState = useFormState;
+exports.useFormStatus = useFormStatus;
+exports.version = ReactVersion;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom.production.min.js b/packages/next/src/compiled/react-dom/cjs/react-dom.production.min.js
index 472b79367348f..a6a3ac9bdcb9d 100644
--- a/packages/next/src/compiled/react-dom/cjs/react-dom.production.min.js
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom.production.min.js
@@ -1,37 +1,36 @@
-/**
- * @license React
- * react-dom.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
 /*
+ React
+ react-dom.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
  Modernizr 3.0.0pre (Custom Build) | MIT
 */
-'use strict';var aa=require("next/dist/compiled/react"),ba=require("next/dist/compiled/scheduler"),ca={usingClientEntryPoint:!1,Events:null,Dispatcher:{current:null}};function t(a){for(var b="https://reactjs.org/docs/error-decoder.html?invariant="+a,c=1;c<arguments.length;c++)b+="&args[]="+encodeURIComponent(arguments[c]);return"Minified React error #"+a+"; visit "+b+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}
+'use strict';var aa=require("next/dist/compiled/react"),ba=require("next/dist/compiled/scheduler"),ca={usingClientEntryPoint:!1,Events:null,Dispatcher:{current:null}};function u(a){for(var b="https://reactjs.org/docs/error-decoder.html?invariant="+a,c=1;c<arguments.length;c++)b+="&args[]="+encodeURIComponent(arguments[c]);return"Minified React error #"+a+"; visit "+b+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}
 var C=Object.assign,da=aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,ea=da.ReactCurrentDispatcher,fa={pending:!1,data:null,method:null,action:null},ia=[],ja=-1;function ka(a){return{current:a}}function D(a){0>ja||(a.current=ia[ja],ia[ja]=null,ja--)}function E(a,b){ja++;ia[ja]=a.current;a.current=b}
 var la=Symbol.for("react.element"),ma=Symbol.for("react.portal"),na=Symbol.for("react.fragment"),oa=Symbol.for("react.strict_mode"),pa=Symbol.for("react.profiler"),qa=Symbol.for("react.provider"),ra=Symbol.for("react.context"),sa=Symbol.for("react.server_context"),ta=Symbol.for("react.forward_ref"),ua=Symbol.for("react.suspense"),va=Symbol.for("react.suspense_list"),wa=Symbol.for("react.memo"),xa=Symbol.for("react.lazy"),ya=Symbol.for("react.scope");Symbol.for("react.debug_trace_mode");
 var za=Symbol.for("react.offscreen"),Aa=Symbol.for("react.legacy_hidden"),Ba=Symbol.for("react.cache");Symbol.for("react.tracing_marker");var Ca=Symbol.iterator;function Da(a){if(null===a||"object"!==typeof a)return null;a=Ca&&a[Ca]||a["@@iterator"];return"function"===typeof a?a:null}var Ea=ka(null),Fa=ka(null),Ga=ka(null),Ha=ka(null),Ia={$$typeof:ra,_currentValue:null,_currentValue2:null,_threadCount:0,Provider:null,Consumer:null,_defaultValue:null,_globalName:null};
 function Ja(a,b){E(Ga,b);E(Fa,a);E(Ea,null);a=b.nodeType;switch(a){case 9:case 11:b=(b=b.documentElement)?(b=b.namespaceURI)?Ka(b):0:0;break;default:if(a=8===a?b.parentNode:b,b=a.tagName,a=a.namespaceURI)a=Ka(a),b=La(a,b);else switch(b){case "svg":b=1;break;case "math":b=2;break;default:b=0}}D(Ea);E(Ea,b)}function Ma(){D(Ea);D(Fa);D(Ga)}function Na(a){null!==a.memoizedState&&E(Ha,a);var b=Ea.current;var c=La(b,a.type);b!==c&&(E(Fa,a),E(Ea,c))}
 function Oa(a){Fa.current===a&&(D(Ea),D(Fa));Ha.current===a&&(D(Ha),Ia._currentValue=null)}var Pa=ba.unstable_scheduleCallback,Qa=ba.unstable_cancelCallback,Ra=ba.unstable_shouldYield,Sa=ba.unstable_requestPaint,Ta=ba.unstable_now,Ua=ba.unstable_getCurrentPriorityLevel,Va=ba.unstable_ImmediatePriority,Wa=ba.unstable_UserBlockingPriority,Xa=ba.unstable_NormalPriority,Ya=ba.unstable_LowPriority,Za=ba.unstable_IdlePriority,$a=null,ab=null;
 function bb(a){if(ab&&"function"===typeof ab.onCommitFiberRoot)try{ab.onCommitFiberRoot($a,a,void 0,128===(a.current.flags&128))}catch(b){}}var db=Math.clz32?Math.clz32:cb,eb=Math.log,fb=Math.LN2;function cb(a){a>>>=0;return 0===a?32:31-(eb(a)/fb|0)|0}var gb=128,hb=4194304;
-function ib(a){switch(a&-a){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:return 64;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:return a&4194176;case 4194304:case 8388608:case 16777216:case 33554432:return a&62914560;case 67108864:return 67108864;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;
-case 1073741824:return 0;default:return a}}function jb(a,b){var c=a.pendingLanes;if(0===c)return 0;var d=0,e=a.suspendedLanes;a=a.pingedLanes;var f=c&134217727;0!==f?(c=f&~e,0!==c?d=ib(c):(a&=f,0!==a&&(d=ib(a)))):(c&=~e,0!==c?d=ib(c):0!==a&&(d=ib(a)));return 0===d?0:0!==b&&b!==d&&0===(b&e)&&(e=d&-d,a=b&-b,e>=a||32===e&&0!==(a&4194176))?b:d}
+function ib(a){var b=a&42;if(0!==b)return b;switch(a&-a){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:return 64;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:return a&4194176;case 4194304:case 8388608:case 16777216:case 33554432:return a&62914560;case 67108864:return 67108864;case 134217728:return 134217728;case 268435456:return 268435456;
+case 536870912:return 536870912;case 1073741824:return 0;default:return a}}function jb(a,b){var c=a.pendingLanes;if(0===c)return 0;var d=0,e=a.suspendedLanes;a=a.pingedLanes;var f=c&134217727;0!==f?(c=f&~e,0!==c?d=ib(c):(a&=f,0!==a&&(d=ib(a)))):(c&=~e,0!==c?d=ib(c):0!==a&&(d=ib(a)));return 0===d?0:0!==b&&b!==d&&0===(b&e)&&(e=d&-d,a=b&-b,e>=a||32===e&&0!==(a&4194176))?b:d}
 function kb(a,b){switch(a){case 1:case 2:case 4:case 8:return b+250;case 16:case 32:case 64: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:return b+5E3;case 4194304:case 8388608:case 16777216:case 33554432:return-1;case 67108864:case 134217728:case 268435456:case 536870912:case 1073741824:return-1;default:return-1}}
 function lb(a,b){if(a.errorRecoveryDisabledLanes&b)return 0;a=a.pendingLanes&-536870913;return 0!==a?a:a&536870912?536870912:0}function mb(){var a=hb;hb<<=1;0===(hb&62914560)&&(hb=4194304);return a}function nb(a){for(var b=[],c=0;31>c;c++)b.push(a);return b}function ob(a,b){a.pendingLanes|=b;268435456!==b&&(a.suspendedLanes=0,a.pingedLanes=0)}
 function pb(a,b,c){var d=a.pendingLanes&~b;a.pendingLanes=b;a.suspendedLanes=0;a.pingedLanes=0;a.expiredLanes&=b;a.entangledLanes&=b;a.errorRecoveryDisabledLanes&=b;a.shellSuspendCounter=0;b=a.entanglements;for(var e=a.expirationTimes,f=a.hiddenUpdates;0<d;){var g=31-db(d),h=1<<g;b[g]=0;e[g]=-1;var l=f[g];if(null!==l)for(f[g]=null,g=0;g<l.length;g++){var p=l[g];null!==p&&(p.lane&=-536870913)}d&=~h}0!==c&&qb(a,c,0)}
 function qb(a,b,c){a.pendingLanes|=b;a.suspendedLanes&=~b;var d=31-db(b);a.entangledLanes|=b;a.entanglements[d]=a.entanglements[d]|1073741824|c&4194218}function rb(a,b){var c=a.entangledLanes|=b;for(a=a.entanglements;c;){var d=31-db(c),e=1<<d;e&b|a[d]&b&&(a[d]|=b);c&=~e}}function sb(a,b){a.pendingLanes|=2;for(a.entangledLanes|=2;b;){var c=1<<31-db(b);a.entanglements[1]|=c;b&=~c}}var F=0;function tb(a,b){var c=F;try{return F=a,b()}finally{F=c}}
 function ub(a){a&=-a;return 2<a?8<a?0!==(a&134217727)?32:268435456:8:2}var vb=Object.prototype.hasOwnProperty,wb=Math.random().toString(36).slice(2),xb="__reactFiber$"+wb,yb="__reactProps$"+wb,zb="__reactContainer$"+wb,Ab="__reactEvents$"+wb,Bb="__reactListeners$"+wb,Cb="__reactHandles$"+wb,Db="__reactResources$"+wb,Fb="__reactMarker$"+wb;function Gb(a){delete a[xb];delete a[yb];delete a[Ab];delete a[Bb];delete a[Cb]}
-function Hb(a){var b=a[xb];if(b)return b;for(var c=a.parentNode;c;){if(b=c[zb]||c[xb]){c=b.alternate;if(null!==b.child||null!==c&&null!==c.child)for(a=Ib(a);null!==a;){if(c=a[xb])return c;a=Ib(a)}return b}a=c;c=a.parentNode}return null}function Jb(a){if(a=a[xb]||a[zb]){var b=a.tag;if(5===b||6===b||13===b||26===b||27===b||3===b)return a}return null}function Kb(a){var b=a.tag;if(5===b||26===b||27===b||6===b)return a.stateNode;throw Error(t(33));}function Lb(a){return a[yb]||null}
+function Hb(a){var b=a[xb];if(b)return b;for(var c=a.parentNode;c;){if(b=c[zb]||c[xb]){c=b.alternate;if(null!==b.child||null!==c&&null!==c.child)for(a=Ib(a);null!==a;){if(c=a[xb])return c;a=Ib(a)}return b}a=c;c=a.parentNode}return null}function Jb(a){if(a=a[xb]||a[zb]){var b=a.tag;if(5===b||6===b||13===b||26===b||27===b||3===b)return a}return null}function Kb(a){var b=a.tag;if(5===b||26===b||27===b||6===b)return a.stateNode;throw Error(u(33));}function Lb(a){return a[yb]||null}
 function Mb(a){var b=a[Db];b||(b=a[Db]={hoistableStyles:new Map,hoistableScripts:new Map});return b}function Nb(a){a[Fb]=!0}var Ob=new Set,Pb={};function Qb(a,b){Rb(a,b);Rb(a+"Capture",b)}function Rb(a,b){Pb[a]=b;for(a=0;a<b.length;a++)Ob.add(b[a])}
 var Sb=!("undefined"===typeof window||"undefined"===typeof window.document||"undefined"===typeof window.document.createElement),Tb=RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"),Ub=
 {},Vb={};function Wb(a){if(vb.call(Vb,a))return!0;if(vb.call(Ub,a))return!1;if(Tb.test(a))return Vb[a]=!0;Ub[a]=!0;return!1}function Xb(a,b,c){if(Wb(b))if(null===c)a.removeAttribute(b);else{switch(typeof c){case "undefined":case "function":case "symbol":a.removeAttribute(b);return;case "boolean":var d=b.toLowerCase().slice(0,5);if("data-"!==d&&"aria-"!==d){a.removeAttribute(b);return}}a.setAttribute(b,""+c)}}
 function Yb(a,b,c){if(null===c)a.removeAttribute(b);else{switch(typeof c){case "undefined":case "function":case "symbol":case "boolean":a.removeAttribute(b);return}a.setAttribute(b,""+c)}}function Zb(a,b,c,d){if(null===d)a.removeAttribute(c);else{switch(typeof d){case "undefined":case "function":case "symbol":case "boolean":a.removeAttribute(c);return}a.setAttributeNS(b,c,""+d)}}var $b;
 function ac(a){if(void 0===$b)try{throw Error();}catch(c){var b=c.stack.trim().match(/\n( *(at )?)/);$b=b&&b[1]||""}return"\n"+$b+a}var bc=!1;
-function cc(a,b){if(!a||bc)return"";bc=!0;var c=Error.prepareStackTrace;Error.prepareStackTrace=void 0;try{if(b)if(b=function(){throw Error();},Object.defineProperty(b.prototype,"props",{set:function(){throw Error();}}),"object"===typeof Reflect&&Reflect.construct){try{Reflect.construct(b,[])}catch(q){var d=q}Reflect.construct(a,[],b)}else{try{b.call()}catch(q){d=q}a.call(b.prototype)}else{try{throw Error();}catch(q){d=q}var e=a();e&&"function"===typeof e.catch&&e.catch(function(){})}}catch(q){if(q&&
-d&&"string"===typeof q.stack){for(var f=q.stack.split("\n"),g=d.stack.split("\n"),h=f.length-1,l=g.length-1;1<=h&&0<=l&&f[h]!==g[l];)l--;for(;1<=h&&0<=l;h--,l--)if(f[h]!==g[l]){if(1!==h||1!==l){do if(h--,l--,0>l||f[h]!==g[l]){var p="\n"+f[h].replace(" at new "," at ");a.displayName&&p.includes("<anonymous>")&&(p=p.replace("<anonymous>",a.displayName));return p}while(1<=h&&0<=l)}break}}}finally{bc=!1,Error.prepareStackTrace=c}return(a=a?a.displayName||a.name:"")?ac(a):""}
+function cc(a,b){if(!a||bc)return"";bc=!0;var c=Error.prepareStackTrace;Error.prepareStackTrace=void 0;var d={DetermineComponentFrameRoot:function(){try{if(b){var w=function(){throw Error();};Object.defineProperty(w.prototype,"props",{set:function(){throw Error();}});if("object"===typeof Reflect&&Reflect.construct){try{Reflect.construct(w,[])}catch(t){var r=t}Reflect.construct(a,[],w)}else{try{w.call()}catch(t){r=t}a.call(w.prototype)}}else{try{throw Error();}catch(t){r=t}(w=a())&&"function"===typeof w.catch&&
+w.catch(function(){})}}catch(t){if(t&&r&&"string"===typeof t.stack)return[t.stack,r.stack]}return[null,null]}};d.DetermineComponentFrameRoot.displayName="DetermineComponentFrameRoot";var e=Object.getOwnPropertyDescriptor(d.DetermineComponentFrameRoot,"name");e&&e.configurable&&Object.defineProperty(d.DetermineComponentFrameRoot,"name",{value:"DetermineComponentFrameRoot"});try{var f=d.DetermineComponentFrameRoot(),g=f[0],h=f[1];if(g&&h){var l=g.split("\n"),p=h.split("\n");for(e=d=0;d<l.length&&!l[d].includes("DetermineComponentFrameRoot");)d++;
+for(;e<p.length&&!p[e].includes("DetermineComponentFrameRoot");)e++;if(d===l.length||e===p.length)for(d=l.length-1,e=p.length-1;1<=d&&0<=e&&l[d]!==p[e];)e--;for(;1<=d&&0<=e;d--,e--)if(l[d]!==p[e]){if(1!==d||1!==e){do if(d--,e--,0>e||l[d]!==p[e]){var q="\n"+l[d].replace(" at new "," at ");a.displayName&&q.includes("<anonymous>")&&(q=q.replace("<anonymous>",a.displayName));return q}while(1<=d&&0<=e)}break}}}finally{bc=!1,Error.prepareStackTrace=c}return(c=a?a.displayName||a.name:"")?ac(c):""}
 function dc(a){switch(a.tag){case 26:case 27:case 5:return ac(a.type);case 16:return ac("Lazy");case 13:return ac("Suspense");case 19:return ac("SuspenseList");case 0:case 2:case 15:return a=cc(a.type,!1),a;case 11:return a=cc(a.type.render,!1),a;case 1:return a=cc(a.type,!0),a;default:return""}}
 function ec(a){if(null==a)return null;if("function"===typeof a)return a.displayName||a.name||null;if("string"===typeof a)return a;switch(a){case na:return"Fragment";case ma:return"Portal";case pa:return"Profiler";case oa:return"StrictMode";case ua:return"Suspense";case va:return"SuspenseList";case Ba:return"Cache"}if("object"===typeof a)switch(a.$$typeof){case ra:return(a.displayName||"Context")+".Consumer";case qa:return(a._context.displayName||"Context")+".Provider";case ta:var b=a.render;a=a.displayName;
 a||(a=b.displayName||b.name||"",a=""!==a?"ForwardRef("+a+")":"ForwardRef");return a;case wa:return b=a.displayName||null,null!==b?b:ec(a.type)||"Memo";case xa:b=a._payload;a=a._init;try{return ec(a(b))}catch(c){}}return null}
@@ -46,11 +45,11 @@ typeof e);null!=h&&"function"!==typeof h&&"symbol"!==typeof h&&"boolean"!==typeo
 function qc(a,b,c,d,e,f,g,h){null!=f&&"function"!==typeof f&&"symbol"!==typeof f&&"boolean"!==typeof f&&(a.type=f);if(null!=b||null!=c){if(!("submit"!==f&&"reset"!==f||void 0!==b&&null!==b))return;c=null!=c?""+gc(c):"";b=null!=b?""+gc(b):c;h||b===a.value||(a.value=b);a.defaultValue=b}d=null!=d?d:e;d="function"!==typeof d&&"symbol"!==typeof d&&!!d;a.checked=h?a.checked:!!d;a.defaultChecked=!!d;null!=g&&"function"!==typeof g&&"symbol"!==typeof g&&"boolean"!==typeof g&&(a.name=g)}
 function pc(a,b,c){"number"===b&&lc(a.ownerDocument)===a||a.defaultValue===""+c||(a.defaultValue=""+c)}var rc=Array.isArray;
 function sc(a,b,c,d){a=a.options;if(b){b={};for(var e=0;e<c.length;e++)b["$"+c[e]]=!0;for(c=0;c<a.length;c++)e=b.hasOwnProperty("$"+a[c].value),a[c].selected!==e&&(a[c].selected=e),e&&d&&(a[c].defaultSelected=!0)}else{c=""+gc(c);b=null;for(e=0;e<a.length;e++){if(a[e].value===c){a[e].selected=!0;d&&(a[e].defaultSelected=!0);return}null!==b||a[e].disabled||(b=a[e])}null!==b&&(b.selected=!0)}}
-function tc(a,b,c){if(null!=b&&(b=""+gc(b),b!==a.value&&(a.value=b),null==c)){a.defaultValue!==b&&(a.defaultValue=b);return}a.defaultValue=null!=c?""+gc(c):""}function uc(a,b,c,d){if(null==b){if(null!=d){if(null!=c)throw Error(t(92));if(rc(d)){if(1<d.length)throw Error(t(93));d=d[0]}c=d}null==c&&(c="");b=c}c=gc(b);a.defaultValue=c;d=a.textContent;d===c&&""!==d&&null!==d&&(a.value=d)}var vc;
+function tc(a,b,c){if(null!=b&&(b=""+gc(b),b!==a.value&&(a.value=b),null==c)){a.defaultValue!==b&&(a.defaultValue=b);return}a.defaultValue=null!=c?""+gc(c):""}function uc(a,b,c,d){if(null==b){if(null!=d){if(null!=c)throw Error(u(92));if(rc(d)){if(1<d.length)throw Error(u(93));d=d[0]}c=d}null==c&&(c="");b=c}c=gc(b);a.defaultValue=c;d=a.textContent;d===c&&""!==d&&null!==d&&(a.value=d)}var vc;
 function wc(a,b){if("http://www.w3.org/2000/svg"!==a.namespaceURI||"innerHTML"in a)a.innerHTML=b;else{vc=vc||document.createElement("div");vc.innerHTML="<svg>"+b.valueOf().toString()+"</svg>";for(b=vc.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;b.firstChild;)a.appendChild(b.firstChild)}}var xc=wc;"undefined"!==typeof MSApp&&MSApp.execUnsafeLocalFunction&&(xc=function(a,b){return MSApp.execUnsafeLocalFunction(function(){return wc(a,b)})});var yc=xc;
 function zc(a,b){if(b){var c=a.firstChild;if(c&&c===a.lastChild&&3===c.nodeType){c.nodeValue=b;return}}a.textContent=b}var Ac=new Set("animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp".split(" "));
 function Bc(a,b,c){var d=0===b.indexOf("--");null==c||"boolean"===typeof c||""===c?d?a.setProperty(b,""):"float"===b?a.cssFloat="":a[b]="":d?a.setProperty(b,c):"number"!==typeof c||0===c||Ac.has(b)?"float"===b?a.cssFloat=c:a[b]=(""+c).trim():a[b]=c+"px"}
-function Cc(a,b,c){if(null!=b&&"object"!==typeof b)throw Error(t(62));a=a.style;if(null!=c){for(var d in c)!c.hasOwnProperty(d)||null!=b&&b.hasOwnProperty(d)||(0===d.indexOf("--")?a.setProperty(d,""):"float"===d?a.cssFloat="":a[d]="");for(var e in b)d=b[e],b.hasOwnProperty(e)&&c[e]!==d&&Bc(a,e,d)}else for(var f in b)b.hasOwnProperty(f)&&Bc(a,f,b[f])}
+function Cc(a,b,c){if(null!=b&&"object"!==typeof b)throw Error(u(62));a=a.style;if(null!=c){for(var d in c)!c.hasOwnProperty(d)||null!=b&&b.hasOwnProperty(d)||(0===d.indexOf("--")?a.setProperty(d,""):"float"===d?a.cssFloat="":a[d]="");for(var e in b)d=b[e],b.hasOwnProperty(e)&&c[e]!==d&&Bc(a,e,d)}else for(var f in b)b.hasOwnProperty(f)&&Bc(a,f,b[f])}
 function Dc(a){if(-1===a.indexOf("-"))return!1;switch(a){case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph":return!1;default:return!0}}
 var Ec=new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv","http-equiv"],["crossOrigin","crossorigin"],["accentHeight","accent-height"],["alignmentBaseline","alignment-baseline"],["arabicForm","arabic-form"],["baselineShift","baseline-shift"],["capHeight","cap-height"],["clipPath","clip-path"],["clipRule","clip-rule"],["colorInterpolation","color-interpolation"],["colorInterpolationFilters","color-interpolation-filters"],["colorProfile","color-profile"],["colorRendering","color-rendering"],
 ["dominantBaseline","dominant-baseline"],["enableBackground","enable-background"],["fillOpacity","fill-opacity"],["fillRule","fill-rule"],["floodColor","flood-color"],["floodOpacity","flood-opacity"],["fontFamily","font-family"],["fontSize","font-size"],["fontSizeAdjust","font-size-adjust"],["fontStretch","font-stretch"],["fontStyle","font-style"],["fontVariant","font-variant"],["fontWeight","font-weight"],["glyphName","glyph-name"],["glyphOrientationHorizontal","glyph-orientation-horizontal"],["glyphOrientationVertical",
@@ -58,64 +57,64 @@ var Ec=new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv
 "shape-rendering"],["stopColor","stop-color"],["stopOpacity","stop-opacity"],["strikethroughPosition","strikethrough-position"],["strikethroughThickness","strikethrough-thickness"],["strokeDasharray","stroke-dasharray"],["strokeDashoffset","stroke-dashoffset"],["strokeLinecap","stroke-linecap"],["strokeLinejoin","stroke-linejoin"],["strokeMiterlimit","stroke-miterlimit"],["strokeOpacity","stroke-opacity"],["strokeWidth","stroke-width"],["textAnchor","text-anchor"],["textDecoration","text-decoration"],
 ["textRendering","text-rendering"],["transformOrigin","transform-origin"],["underlinePosition","underline-position"],["underlineThickness","underline-thickness"],["unicodeBidi","unicode-bidi"],["unicodeRange","unicode-range"],["unitsPerEm","units-per-em"],["vAlphabetic","v-alphabetic"],["vHanging","v-hanging"],["vIdeographic","v-ideographic"],["vMathematical","v-mathematical"],["vectorEffect","vector-effect"],["vertAdvY","vert-adv-y"],["vertOriginX","vert-origin-x"],["vertOriginY","vert-origin-y"],
 ["wordSpacing","word-spacing"],["writingMode","writing-mode"],["xmlnsXlink","xmlns:xlink"],["xHeight","x-height"]]),Fc=null;function Gc(a){a=a.target||a.srcElement||window;a.correspondingUseElement&&(a=a.correspondingUseElement);return 3===a.nodeType?a.parentNode:a}var Hc=null,Ic=null;
-function Jc(a){var b=Jb(a);if(b&&(a=b.stateNode)){var c=Lb(a);a:switch(a=b.stateNode,b.type){case "input":oc(a,c.value,c.defaultValue,c.defaultValue,c.checked,c.defaultChecked,c.type,c.name);b=c.name;if("radio"===c.type&&null!=b){for(c=a;c.parentNode;)c=c.parentNode;c=c.querySelectorAll('input[name="'+nc(""+b)+'"][type="radio"]');for(b=0;b<c.length;b++){var d=c[b];if(d!==a&&d.form===a.form){var e=Lb(d);if(!e)throw Error(t(90));oc(d,e.value,e.defaultValue,e.defaultValue,e.checked,e.defaultChecked,
+function Jc(a){var b=Jb(a);if(b&&(a=b.stateNode)){var c=Lb(a);a:switch(a=b.stateNode,b.type){case "input":oc(a,c.value,c.defaultValue,c.defaultValue,c.checked,c.defaultChecked,c.type,c.name);b=c.name;if("radio"===c.type&&null!=b){for(c=a;c.parentNode;)c=c.parentNode;c=c.querySelectorAll('input[name="'+nc(""+b)+'"][type="radio"]');for(b=0;b<c.length;b++){var d=c[b];if(d!==a&&d.form===a.form){var e=Lb(d);if(!e)throw Error(u(90));oc(d,e.value,e.defaultValue,e.defaultValue,e.checked,e.defaultChecked,
 e.type,e.name)}}for(b=0;b<c.length;b++)d=c[b],d.form===a.form&&kc(d)}break a;case "textarea":tc(a,c.value,c.defaultValue);break a;case "select":b=c.value,null!=b&&sc(a,!!c.multiple,b,!1)}}}function Kc(a){Hc?Ic?Ic.push(a):Ic=[a]:Hc=a}function Lc(){if(Hc){var a=Hc,b=Ic;Ic=Hc=null;Jc(a);if(b)for(a=0;a<b.length;a++)Jc(b[a])}}function Mc(a){var b=a,c=a;if(a.alternate)for(;b.return;)b=b.return;else{a=b;do b=a,0!==(b.flags&4098)&&(c=b.return),a=b.return;while(a)}return 3===b.tag?c:null}
-function Nc(a){if(13===a.tag){var b=a.memoizedState;null===b&&(a=a.alternate,null!==a&&(b=a.memoizedState));if(null!==b)return b.dehydrated}return null}function Oc(a){if(Mc(a)!==a)throw Error(t(188));}
-function Pc(a){var b=a.alternate;if(!b){b=Mc(a);if(null===b)throw Error(t(188));return b!==a?null:a}for(var c=a,d=b;;){var e=c.return;if(null===e)break;var f=e.alternate;if(null===f){d=e.return;if(null!==d){c=d;continue}break}if(e.child===f.child){for(f=e.child;f;){if(f===c)return Oc(e),a;if(f===d)return Oc(e),b;f=f.sibling}throw Error(t(188));}if(c.return!==d.return)c=e,d=f;else{for(var g=!1,h=e.child;h;){if(h===c){g=!0;c=e;d=f;break}if(h===d){g=!0;d=e;c=f;break}h=h.sibling}if(!g){for(h=f.child;h;){if(h===
-c){g=!0;c=f;d=e;break}if(h===d){g=!0;d=f;c=e;break}h=h.sibling}if(!g)throw Error(t(189));}}if(c.alternate!==d)throw Error(t(190));}if(3!==c.tag)throw Error(t(188));return c.stateNode.current===c?a:b}function Qc(a){a=Pc(a);return null!==a?Rc(a):null}function Rc(a){var b=a.tag;if(5===b||26===b||27===b||6===b)return a;for(a=a.child;null!==a;){b=Rc(a);if(null!==b)return b;a=a.sibling}return null}var Sc={},Tc=ka(Sc),Uc=ka(!1),Vc=Sc;
+function Nc(a){if(13===a.tag){var b=a.memoizedState;null===b&&(a=a.alternate,null!==a&&(b=a.memoizedState));if(null!==b)return b.dehydrated}return null}function Oc(a){if(Mc(a)!==a)throw Error(u(188));}
+function Pc(a){var b=a.alternate;if(!b){b=Mc(a);if(null===b)throw Error(u(188));return b!==a?null:a}for(var c=a,d=b;;){var e=c.return;if(null===e)break;var f=e.alternate;if(null===f){d=e.return;if(null!==d){c=d;continue}break}if(e.child===f.child){for(f=e.child;f;){if(f===c)return Oc(e),a;if(f===d)return Oc(e),b;f=f.sibling}throw Error(u(188));}if(c.return!==d.return)c=e,d=f;else{for(var g=!1,h=e.child;h;){if(h===c){g=!0;c=e;d=f;break}if(h===d){g=!0;d=e;c=f;break}h=h.sibling}if(!g){for(h=f.child;h;){if(h===
+c){g=!0;c=f;d=e;break}if(h===d){g=!0;d=f;c=e;break}h=h.sibling}if(!g)throw Error(u(189));}}if(c.alternate!==d)throw Error(u(190));}if(3!==c.tag)throw Error(u(188));return c.stateNode.current===c?a:b}function Qc(a){a=Pc(a);return null!==a?Rc(a):null}function Rc(a){var b=a.tag;if(5===b||26===b||27===b||6===b)return a;for(a=a.child;null!==a;){b=Rc(a);if(null!==b)return b;a=a.sibling}return null}var Sc={},Tc=ka(Sc),Uc=ka(!1),Vc=Sc;
 function Wc(a,b){var c=a.type.contextTypes;if(!c)return Sc;var d=a.stateNode;if(d&&d.__reactInternalMemoizedUnmaskedChildContext===b)return d.__reactInternalMemoizedMaskedChildContext;var e={},f;for(f in c)e[f]=b[f];d&&(a=a.stateNode,a.__reactInternalMemoizedUnmaskedChildContext=b,a.__reactInternalMemoizedMaskedChildContext=e);return e}function Xc(a){a=a.childContextTypes;return null!==a&&void 0!==a}function Yc(){D(Uc);D(Tc)}
-function Zc(a,b,c){if(Tc.current!==Sc)throw Error(t(168));E(Tc,b);E(Uc,c)}function $c(a,b,c){var d=a.stateNode;b=b.childContextTypes;if("function"!==typeof d.getChildContext)return c;d=d.getChildContext();for(var e in d)if(!(e in b))throw Error(t(108,fc(a)||"Unknown",e));return C({},c,d)}function ad(a){a=(a=a.stateNode)&&a.__reactInternalMemoizedMergedChildContext||Sc;Vc=Tc.current;E(Tc,a);E(Uc,Uc.current);return!0}
-function bd(a,b,c){var d=a.stateNode;if(!d)throw Error(t(169));c?(a=$c(a,b,Vc),d.__reactInternalMemoizedMergedChildContext=a,D(Uc),D(Tc),E(Tc,a)):D(Uc);E(Uc,c)}function cd(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var dd="function"===typeof Object.is?Object.is:cd,ed=[],fd=0,gd=null,hd=0,id=[],jd=0,kd=null,ld=1,md="";function nd(a,b){ed[fd++]=hd;ed[fd++]=gd;gd=a;hd=b}
+function Zc(a,b,c){if(Tc.current!==Sc)throw Error(u(168));E(Tc,b);E(Uc,c)}function $c(a,b,c){var d=a.stateNode;b=b.childContextTypes;if("function"!==typeof d.getChildContext)return c;d=d.getChildContext();for(var e in d)if(!(e in b))throw Error(u(108,fc(a)||"Unknown",e));return C({},c,d)}function ad(a){a=(a=a.stateNode)&&a.__reactInternalMemoizedMergedChildContext||Sc;Vc=Tc.current;E(Tc,a);E(Uc,Uc.current);return!0}
+function bd(a,b,c){var d=a.stateNode;if(!d)throw Error(u(169));c?(a=$c(a,b,Vc),d.__reactInternalMemoizedMergedChildContext=a,D(Uc),D(Tc),E(Tc,a)):D(Uc);E(Uc,c)}function cd(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var dd="function"===typeof Object.is?Object.is:cd,ed=[],fd=0,gd=null,hd=0,id=[],jd=0,kd=null,ld=1,md="";function nd(a,b){ed[fd++]=hd;ed[fd++]=gd;gd=a;hd=b}
 function od(a,b,c){id[jd++]=ld;id[jd++]=md;id[jd++]=kd;kd=a;var d=ld;a=md;var e=32-db(d)-1;d&=~(1<<e);c+=1;var f=32-db(b)+e;if(30<f){var g=e-e%5;f=(d&(1<<g)-1).toString(32);d>>=g;e-=g;ld=1<<32-db(b)+e|c<<e|d;md=f+a}else ld=1<<f|c<<e|d,md=a}function pd(a){null!==a.return&&(nd(a,1),od(a,1,0))}function qd(a){for(;a===gd;)gd=ed[--fd],ed[fd]=null,hd=ed[--fd],ed[fd]=null;for(;a===kd;)kd=id[--jd],id[jd]=null,md=id[--jd],id[jd]=null,ld=id[--jd],id[jd]=null}var G=null,J=null,K=!1,rd=null,sd=!1;
 function td(a,b){var c=ud(5,null,null,0);c.elementType="DELETED";c.stateNode=b;c.return=a;b=a.deletions;null===b?(a.deletions=[c],a.flags|=16):b.push(c)}function vd(a,b){b.flags=b.flags&-4097|2}function wd(a,b){b=xd(b,a.type,a.pendingProps,sd);return null!==b?(a.stateNode=b,G=a,J=yd(b.firstChild),sd=!1,!0):!1}function zd(a,b){b=Ad(b,a.pendingProps,sd);return null!==b?(a.stateNode=b,G=a,J=null,!0):!1}
-function Bd(a,b){a:{var c=b;for(b=sd;8!==c.nodeType;){if(!b){b=null;break a}c=Cd(c);if(null===c){b=null;break a}}b=c}return null!==b?(c=null!==kd?{id:ld,overflow:md}:null,a.memoizedState={dehydrated:b,treeContext:c,retryLane:536870912},c=ud(18,null,null,0),c.stateNode=b,c.return=a,a.child=c,G=a,J=null,!0):!1}function Dd(a){return 0!==(a.mode&1)&&0===(a.flags&128)}function Ed(){throw Error(t(418));}
+function Bd(a,b){a:{var c=b;for(b=sd;8!==c.nodeType;){if(!b){b=null;break a}c=Cd(c);if(null===c){b=null;break a}}b=c}return null!==b?(c=null!==kd?{id:ld,overflow:md}:null,a.memoizedState={dehydrated:b,treeContext:c,retryLane:536870912},c=ud(18,null,null,0),c.stateNode=b,c.return=a,a.child=c,G=a,J=null,!0):!1}function Dd(a){return 0!==(a.mode&1)&&0===(a.flags&128)}function Ed(){throw Error(u(418));}
 function Fd(a){for(G=a.return;G;)switch(G.tag){case 3:case 27:sd=!0;return;case 5:case 13:sd=!1;return;default:G=G.return}}
-function Gd(a){if(a!==G)return!1;if(!K)return Fd(a),K=!0,!1;var b=!1,c;if(c=3!==a.tag&&27!==a.tag){if(c=5===a.tag)c=a.type,c=!("form"!==c&&"button"!==c)||Hd(a.type,a.memoizedProps);c=!c}c&&(b=!0);if(b&&(b=J))if(Dd(a))Id(),Ed();else for(;b;)td(a,b),b=Cd(b);Fd(a);if(13===a.tag){a=a.memoizedState;a=null!==a?a.dehydrated:null;if(!a)throw Error(t(317));a:{a=a.nextSibling;for(b=0;a;){if(8===a.nodeType)if(c=a.data,"/$"===c){if(0===b){J=Cd(a);break a}b--}else"$"!==c&&"$!"!==c&&"$?"!==c||b++;a=a.nextSibling}J=
+function Gd(a){if(a!==G)return!1;if(!K)return Fd(a),K=!0,!1;var b=!1,c;if(c=3!==a.tag&&27!==a.tag){if(c=5===a.tag)c=a.type,c=!("form"!==c&&"button"!==c)||Hd(a.type,a.memoizedProps);c=!c}c&&(b=!0);if(b&&(b=J))if(Dd(a))Id(),Ed();else for(;b;)td(a,b),b=Cd(b);Fd(a);if(13===a.tag){a=a.memoizedState;a=null!==a?a.dehydrated:null;if(!a)throw Error(u(317));a:{a=a.nextSibling;for(b=0;a;){if(8===a.nodeType)if(c=a.data,"/$"===c){if(0===b){J=Cd(a);break a}b--}else"$"!==c&&"$!"!==c&&"$?"!==c||b++;a=a.nextSibling}J=
 null}}else J=G?Cd(a.stateNode):null;return!0}function Id(){for(var a=J;a;)a=Cd(a)}function Jd(){J=G=null;K=!1}function Kd(a){null===rd?rd=[a]:rd.push(a)}var Ld=[],Md=0,Nd=0;function Od(){for(var a=Md,b=Nd=Md=0;b<a;){var c=Ld[b];Ld[b++]=null;var d=Ld[b];Ld[b++]=null;var e=Ld[b];Ld[b++]=null;var f=Ld[b];Ld[b++]=null;if(null!==d&&null!==e){var g=d.pending;null===g?e.next=e:(e.next=g.next,g.next=e);d.pending=e}0!==f&&Pd(c,e,f)}}
 function Qd(a,b,c,d){Ld[Md++]=a;Ld[Md++]=b;Ld[Md++]=c;Ld[Md++]=d;Nd|=d;a.lanes|=d;a=a.alternate;null!==a&&(a.lanes|=d)}function Rd(a,b,c,d){Qd(a,b,c,d);return Sd(a)}function Td(a,b){Qd(a,null,null,b);return Sd(a)}
-function Pd(a,b,c){a.lanes|=c;var d=a.alternate;null!==d&&(d.lanes|=c);for(var e=!1,f=a.return;null!==f;)f.childLanes|=c,d=f.alternate,null!==d&&(d.childLanes|=c),22===f.tag&&(a=f.stateNode,null===a||a._visibility&1||(e=!0)),a=f,f=f.return;e&&null!==b&&3===a.tag&&(f=a.stateNode,e=31-db(c),f=f.hiddenUpdates,a=f[e],null===a?f[e]=[b]:a.push(b),b.lane=c|536870912)}function Sd(a){if(50<Ud)throw Ud=0,Vd=null,Error(t(185));for(var b=a.return;null!==b;)a=b,b=a.return;return 3===a.tag?a.stateNode:null}
+function Pd(a,b,c){a.lanes|=c;var d=a.alternate;null!==d&&(d.lanes|=c);for(var e=!1,f=a.return;null!==f;)f.childLanes|=c,d=f.alternate,null!==d&&(d.childLanes|=c),22===f.tag&&(a=f.stateNode,null===a||a._visibility&1||(e=!0)),a=f,f=f.return;e&&null!==b&&3===a.tag&&(f=a.stateNode,e=31-db(c),f=f.hiddenUpdates,a=f[e],null===a?f[e]=[b]:a.push(b),b.lane=c|536870912)}function Sd(a){if(50<Ud)throw Ud=0,Vd=null,Error(u(185));for(var b=a.return;null!==b;)a=b,b=a.return;return 3===a.tag?a.stateNode:null}
 var Wd=!1;function Xd(a){a.updateQueue={baseState:a.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,lanes:0,hiddenCallbacks:null},callbacks:null}}function Yd(a,b){a=a.updateQueue;b.updateQueue===a&&(b.updateQueue={baseState:a.baseState,firstBaseUpdate:a.firstBaseUpdate,lastBaseUpdate:a.lastBaseUpdate,shared:a.shared,callbacks:null})}function Zd(a){return{lane:a,tag:0,payload:null,callback:null,next:null}}
 function $d(a,b,c){var d=a.updateQueue;if(null===d)return null;d=d.shared;if(0!==(L&2)){var e=d.pending;null===e?b.next=b:(b.next=e.next,e.next=b);d.pending=b;b=Sd(a);Pd(a,null,c);return b}Qd(a,d,b,c);return Sd(a)}function ae(a,b,c){b=b.updateQueue;if(null!==b&&(b=b.shared,0!==(c&4194176))){var d=b.lanes;d&=a.pendingLanes;c|=d;b.lanes=c;rb(a,c)}}
 function be(a,b){var c=a.updateQueue,d=a.alternate;if(null!==d&&(d=d.updateQueue,c===d)){var e=null,f=null;c=c.firstBaseUpdate;if(null!==c){do{var g={lane:c.lane,tag:c.tag,payload:c.payload,callback:null,next:null};null===f?e=f=g:f=f.next=g;c=c.next}while(null!==c);null===f?e=f=b:f=f.next=b}else e=f=b;c={baseState:d.baseState,firstBaseUpdate:e,lastBaseUpdate:f,shared:d.shared,callbacks:d.callbacks};a.updateQueue=c;return}a=c.lastBaseUpdate;null===a?c.firstBaseUpdate=b:a.next=b;c.lastBaseUpdate=b}
-function ce(a,b,c,d){var e=a.updateQueue;Wd=!1;var f=e.firstBaseUpdate,g=e.lastBaseUpdate,h=e.shared.pending;if(null!==h){e.shared.pending=null;var l=h,p=l.next;l.next=null;null===g?f=p:g.next=p;g=l;var q=a.alternate;null!==q&&(q=q.updateQueue,h=q.lastBaseUpdate,h!==g&&(null===h?q.firstBaseUpdate=p:h.next=p,q.lastBaseUpdate=l))}if(null!==f){var w=e.baseState;g=0;q=p=l=null;h=f;do{var r=h.lane&-536870913,u=r!==h.lane;if(u?(M&r)===r:(d&r)===r){null!==q&&(q=q.next={lane:0,tag:h.tag,payload:h.payload,
-callback:null,next:null});a:{var z=a,B=h;r=b;var U=c;switch(B.tag){case 1:z=B.payload;if("function"===typeof z){w=z.call(U,w,r);break a}w=z;break a;case 3:z.flags=z.flags&-65537|128;case 0:z=B.payload;r="function"===typeof z?z.call(U,w,r):z;if(null===r||void 0===r)break a;w=C({},w,r);break a;case 2:Wd=!0}}r=h.callback;null!==r&&(a.flags|=64,u&&(a.flags|=8192),u=e.callbacks,null===u?e.callbacks=[r]:u.push(r))}else u={lane:r,tag:h.tag,payload:h.payload,callback:h.callback,next:null},null===q?(p=q=u,
-l=w):q=q.next=u,g|=r;h=h.next;if(null===h)if(h=e.shared.pending,null===h)break;else u=h,h=u.next,u.next=null,e.lastBaseUpdate=u,e.shared.pending=null}while(1);null===q&&(l=w);e.baseState=l;e.firstBaseUpdate=p;e.lastBaseUpdate=q;null===f&&(e.shared.lanes=0);de|=g;a.lanes=g;a.memoizedState=w}}function ee(a,b){if("function"!==typeof a)throw Error(t(191,a));a.call(b)}function fe(a,b){var c=a.callbacks;if(null!==c)for(a.callbacks=null,a=0;a<c.length;a++)ee(c[a],b)}
-function ge(a,b){if(dd(a,b))return!0;if("object"!==typeof a||null===a||"object"!==typeof b||null===b)return!1;var c=Object.keys(a),d=Object.keys(b);if(c.length!==d.length)return!1;for(d=0;d<c.length;d++){var e=c[d];if(!vb.call(b,e)||!dd(a[e],b[e]))return!1}return!0}var he=Error(t(460)),ie=Error(t(474)),je={then:function(){}};function ke(a){a=a.status;return"fulfilled"===a||"rejected"===a}function le(){}
-function me(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(le,le),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":a=b.reason;if(a===he)throw Error(t(483));throw a;default:if("string"===typeof b.status)b.then(le,le);else{a=N;if(null!==a&&100<a.shellSuspendCounter)throw Error(t(482));a=b;a.status="pending";a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}});switch(b.status){case "fulfilled":return b.value;
-case "rejected":a=b.reason;if(a===he)throw Error(t(483));throw a;}}ne=b;throw he;}}var ne=null;function oe(){if(null===ne)throw Error(t(459));var a=ne;ne=null;return a}var pe=null,qe=0;function re(a){var b=qe;qe+=1;null===pe&&(pe=[]);return me(pe,a,b)}
-function se(a,b,c){a=c.ref;if(null!==a&&"function"!==typeof a&&"object"!==typeof a){if(c._owner){c=c._owner;if(c){if(1!==c.tag)throw Error(t(309));var d=c.stateNode}if(!d)throw Error(t(147,a));var e=d,f=""+a;if(null!==b&&null!==b.ref&&"function"===typeof b.ref&&b.ref._stringRef===f)return b.ref;b=function(g){var h=e.refs;null===g?delete h[f]:h[f]=g};b._stringRef=f;return b}if("string"!==typeof a)throw Error(t(284));if(!c._owner)throw Error(t(290,a));}return a}
-function te(a,b){a=Object.prototype.toString.call(b);throw Error(t(31,"[object Object]"===a?"object with keys {"+Object.keys(b).join(", ")+"}":a));}function ue(a){var b=a._init;return b(a._payload)}
+function ce(a,b,c,d){var e=a.updateQueue;Wd=!1;var f=e.firstBaseUpdate,g=e.lastBaseUpdate,h=e.shared.pending;if(null!==h){e.shared.pending=null;var l=h,p=l.next;l.next=null;null===g?f=p:g.next=p;g=l;var q=a.alternate;null!==q&&(q=q.updateQueue,h=q.lastBaseUpdate,h!==g&&(null===h?q.firstBaseUpdate=p:h.next=p,q.lastBaseUpdate=l))}if(null!==f){var w=e.baseState;g=0;q=p=l=null;h=f;do{var r=h.lane&-536870913,t=r!==h.lane;if(t?(M&r)===r:(d&r)===r){null!==q&&(q=q.next={lane:0,tag:h.tag,payload:h.payload,
+callback:null,next:null});a:{var z=a,B=h;r=b;var U=c;switch(B.tag){case 1:z=B.payload;if("function"===typeof z){w=z.call(U,w,r);break a}w=z;break a;case 3:z.flags=z.flags&-65537|128;case 0:z=B.payload;r="function"===typeof z?z.call(U,w,r):z;if(null===r||void 0===r)break a;w=C({},w,r);break a;case 2:Wd=!0}}r=h.callback;null!==r&&(a.flags|=64,t&&(a.flags|=8192),t=e.callbacks,null===t?e.callbacks=[r]:t.push(r))}else t={lane:r,tag:h.tag,payload:h.payload,callback:h.callback,next:null},null===q?(p=q=t,
+l=w):q=q.next=t,g|=r;h=h.next;if(null===h)if(h=e.shared.pending,null===h)break;else t=h,h=t.next,t.next=null,e.lastBaseUpdate=t,e.shared.pending=null}while(1);null===q&&(l=w);e.baseState=l;e.firstBaseUpdate=p;e.lastBaseUpdate=q;null===f&&(e.shared.lanes=0);de|=g;a.lanes=g;a.memoizedState=w}}function ee(a,b){if("function"!==typeof a)throw Error(u(191,a));a.call(b)}function fe(a,b){var c=a.callbacks;if(null!==c)for(a.callbacks=null,a=0;a<c.length;a++)ee(c[a],b)}
+function ge(a,b){if(dd(a,b))return!0;if("object"!==typeof a||null===a||"object"!==typeof b||null===b)return!1;var c=Object.keys(a),d=Object.keys(b);if(c.length!==d.length)return!1;for(d=0;d<c.length;d++){var e=c[d];if(!vb.call(b,e)||!dd(a[e],b[e]))return!1}return!0}var he=Error(u(460)),ie=Error(u(474)),je={then:function(){}};function ke(a){a=a.status;return"fulfilled"===a||"rejected"===a}function le(){}
+function me(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(le,le),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":a=b.reason;if(a===he)throw Error(u(483));throw a;default:if("string"===typeof b.status)b.then(le,le);else{a=N;if(null!==a&&100<a.shellSuspendCounter)throw Error(u(482));a=b;a.status="pending";a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}});switch(b.status){case "fulfilled":return b.value;
+case "rejected":a=b.reason;if(a===he)throw Error(u(483));throw a;}}ne=b;throw he;}}var ne=null;function oe(){if(null===ne)throw Error(u(459));var a=ne;ne=null;return a}var pe=null,qe=0;function re(a){var b=qe;qe+=1;null===pe&&(pe=[]);return me(pe,a,b)}
+function se(a,b,c){a=c.ref;if(null!==a&&"function"!==typeof a&&"object"!==typeof a){if(c._owner){c=c._owner;if(c){if(1!==c.tag)throw Error(u(309));var d=c.stateNode}if(!d)throw Error(u(147,a));var e=d,f=""+a;if(null!==b&&null!==b.ref&&"function"===typeof b.ref&&b.ref._stringRef===f)return b.ref;b=function(g){var h=e.refs;null===g?delete h[f]:h[f]=g};b._stringRef=f;return b}if("string"!==typeof a)throw Error(u(284));if(!c._owner)throw Error(u(290,a));}return a}
+function te(a,b){a=Object.prototype.toString.call(b);throw Error(u(31,"[object Object]"===a?"object with keys {"+Object.keys(b).join(", ")+"}":a));}function ue(a){var b=a._init;return b(a._payload)}
 function ve(a){function b(m,k){if(a){var n=m.deletions;null===n?(m.deletions=[k],m.flags|=16):n.push(k)}}function c(m,k){if(!a)return null;for(;null!==k;)b(m,k),k=k.sibling;return null}function d(m,k){for(m=new Map;null!==k;)null!==k.key?m.set(k.key,k):m.set(k.index,k),k=k.sibling;return m}function e(m,k){m=we(m,k);m.index=0;m.sibling=null;return m}function f(m,k,n){m.index=n;if(!a)return m.flags|=1048576,k;n=m.alternate;if(null!==n)return n=n.index,n<k?(m.flags|=33554434,k):n;m.flags|=33554434;return k}
 function g(m){a&&null===m.alternate&&(m.flags|=33554434);return m}function h(m,k,n,v){if(null===k||6!==k.tag)return k=xe(n,m.mode,v),k.return=m,k;k=e(k,n);k.return=m;return k}function l(m,k,n,v){var x=n.type;if(x===na)return q(m,k,n.props.children,v,n.key);if(null!==k&&(k.elementType===x||"object"===typeof x&&null!==x&&x.$$typeof===xa&&ue(x)===k.type))return v=e(k,n.props),v.ref=se(m,k,n),v.return=m,v;v=ye(n.type,n.key,n.props,null,null,m.mode,v);v.ref=se(m,k,n);v.return=m;return v}function p(m,k,
 n,v){if(null===k||4!==k.tag||k.stateNode.containerInfo!==n.containerInfo||k.stateNode.implementation!==n.implementation)return k=ze(n,m.mode,v),k.return=m,k;k=e(k,n.children||[]);k.return=m;return k}function q(m,k,n,v,x){if(null===k||7!==k.tag)return k=Ae(n,m.mode,v,x),k.return=m,k;k=e(k,n);k.return=m;return k}function w(m,k,n){if("string"===typeof k&&""!==k||"number"===typeof k)return k=xe(""+k,m.mode,n),k.return=m,k;if("object"===typeof k&&null!==k){switch(k.$$typeof){case la:return n=ye(k.type,
 k.key,k.props,null,null,m.mode,n),n.ref=se(m,null,k),n.return=m,n;case ma:return k=ze(k,m.mode,n),k.return=m,k;case xa:var v=k._init;return w(m,v(k._payload),n)}if(rc(k)||Da(k))return k=Ae(k,m.mode,n,null),k.return=m,k;if("function"===typeof k.then)return w(m,re(k),n);if(k.$$typeof===ra||k.$$typeof===sa)return w(m,Be(m,k,n),n);te(m,k)}return null}function r(m,k,n,v){var x=null!==k?k.key:null;if("string"===typeof n&&""!==n||"number"===typeof n)return null!==x?null:h(m,k,""+n,v);if("object"===typeof n&&
-null!==n){switch(n.$$typeof){case la:return n.key===x?l(m,k,n,v):null;case ma:return n.key===x?p(m,k,n,v):null;case xa:return x=n._init,r(m,k,x(n._payload),v)}if(rc(n)||Da(n))return null!==x?null:q(m,k,n,v,null);if("function"===typeof n.then)return r(m,k,re(n),v);if(n.$$typeof===ra||n.$$typeof===sa)return r(m,k,Be(m,n,v),v);te(m,n)}return null}function u(m,k,n,v,x){if("string"===typeof v&&""!==v||"number"===typeof v)return m=m.get(n)||null,h(k,m,""+v,x);if("object"===typeof v&&null!==v){switch(v.$$typeof){case la:return m=
-m.get(null===v.key?n:v.key)||null,l(k,m,v,x);case ma:return m=m.get(null===v.key?n:v.key)||null,p(k,m,v,x);case xa:var A=v._init;return u(m,k,n,A(v._payload),x)}if(rc(v)||Da(v))return m=m.get(n)||null,q(k,m,v,x,null);if("function"===typeof v.then)return u(m,k,n,re(v),x);if(v.$$typeof===ra||v.$$typeof===sa)return u(m,k,n,Be(k,v,x),x);te(k,v)}return null}function z(m,k,n,v){for(var x=null,A=null,y=k,H=k=0,ha=null;null!==y&&H<n.length;H++){y.index>H?(ha=y,y=null):ha=y.sibling;var I=r(m,y,n[H],v);if(null===
-I){null===y&&(y=ha);break}a&&y&&null===I.alternate&&b(m,y);k=f(I,k,H);null===A?x=I:A.sibling=I;A=I;y=ha}if(H===n.length)return c(m,y),K&&nd(m,H),x;if(null===y){for(;H<n.length;H++)y=w(m,n[H],v),null!==y&&(k=f(y,k,H),null===A?x=y:A.sibling=y,A=y);K&&nd(m,H);return x}for(y=d(m,y);H<n.length;H++)ha=u(y,m,H,n[H],v),null!==ha&&(a&&null!==ha.alternate&&y.delete(null===ha.key?H:ha.key),k=f(ha,k,H),null===A?x=ha:A.sibling=ha,A=ha);a&&y.forEach(function(Eb){return b(m,Eb)});K&&nd(m,H);return x}function B(m,
-k,n,v){var x=Da(n);if("function"!==typeof x)throw Error(t(150));n=x.call(n);if(null==n)throw Error(t(151));for(var A=x=null,y=k,H=k=0,ha=null,I=n.next();null!==y&&!I.done;H++,I=n.next()){y.index>H?(ha=y,y=null):ha=y.sibling;var Eb=r(m,y,I.value,v);if(null===Eb){null===y&&(y=ha);break}a&&y&&null===Eb.alternate&&b(m,y);k=f(Eb,k,H);null===A?x=Eb:A.sibling=Eb;A=Eb;y=ha}if(I.done)return c(m,y),K&&nd(m,H),x;if(null===y){for(;!I.done;H++,I=n.next())I=w(m,I.value,v),null!==I&&(k=f(I,k,H),null===A?x=I:A.sibling=
-I,A=I);K&&nd(m,H);return x}for(y=d(m,y);!I.done;H++,I=n.next())I=u(y,m,H,I.value,v),null!==I&&(a&&null!==I.alternate&&y.delete(null===I.key?H:I.key),k=f(I,k,H),null===A?x=I:A.sibling=I,A=I);a&&y.forEach(function(Jm){return b(m,Jm)});K&&nd(m,H);return x}function U(m,k,n,v){"object"===typeof n&&null!==n&&n.type===na&&null===n.key&&(n=n.props.children);if("object"===typeof n&&null!==n){switch(n.$$typeof){case la:a:{for(var x=n.key,A=k;null!==A;){if(A.key===x){x=n.type;if(x===na){if(7===A.tag){c(m,A.sibling);
+null!==n){switch(n.$$typeof){case la:return n.key===x?l(m,k,n,v):null;case ma:return n.key===x?p(m,k,n,v):null;case xa:return x=n._init,r(m,k,x(n._payload),v)}if(rc(n)||Da(n))return null!==x?null:q(m,k,n,v,null);if("function"===typeof n.then)return r(m,k,re(n),v);if(n.$$typeof===ra||n.$$typeof===sa)return r(m,k,Be(m,n,v),v);te(m,n)}return null}function t(m,k,n,v,x){if("string"===typeof v&&""!==v||"number"===typeof v)return m=m.get(n)||null,h(k,m,""+v,x);if("object"===typeof v&&null!==v){switch(v.$$typeof){case la:return m=
+m.get(null===v.key?n:v.key)||null,l(k,m,v,x);case ma:return m=m.get(null===v.key?n:v.key)||null,p(k,m,v,x);case xa:var A=v._init;return t(m,k,n,A(v._payload),x)}if(rc(v)||Da(v))return m=m.get(n)||null,q(k,m,v,x,null);if("function"===typeof v.then)return t(m,k,n,re(v),x);if(v.$$typeof===ra||v.$$typeof===sa)return t(m,k,n,Be(k,v,x),x);te(k,v)}return null}function z(m,k,n,v){for(var x=null,A=null,y=k,H=k=0,ha=null;null!==y&&H<n.length;H++){y.index>H?(ha=y,y=null):ha=y.sibling;var I=r(m,y,n[H],v);if(null===
+I){null===y&&(y=ha);break}a&&y&&null===I.alternate&&b(m,y);k=f(I,k,H);null===A?x=I:A.sibling=I;A=I;y=ha}if(H===n.length)return c(m,y),K&&nd(m,H),x;if(null===y){for(;H<n.length;H++)y=w(m,n[H],v),null!==y&&(k=f(y,k,H),null===A?x=y:A.sibling=y,A=y);K&&nd(m,H);return x}for(y=d(m,y);H<n.length;H++)ha=t(y,m,H,n[H],v),null!==ha&&(a&&null!==ha.alternate&&y.delete(null===ha.key?H:ha.key),k=f(ha,k,H),null===A?x=ha:A.sibling=ha,A=ha);a&&y.forEach(function(Eb){return b(m,Eb)});K&&nd(m,H);return x}function B(m,
+k,n,v){var x=Da(n);if("function"!==typeof x)throw Error(u(150));n=x.call(n);if(null==n)throw Error(u(151));for(var A=x=null,y=k,H=k=0,ha=null,I=n.next();null!==y&&!I.done;H++,I=n.next()){y.index>H?(ha=y,y=null):ha=y.sibling;var Eb=r(m,y,I.value,v);if(null===Eb){null===y&&(y=ha);break}a&&y&&null===Eb.alternate&&b(m,y);k=f(Eb,k,H);null===A?x=Eb:A.sibling=Eb;A=Eb;y=ha}if(I.done)return c(m,y),K&&nd(m,H),x;if(null===y){for(;!I.done;H++,I=n.next())I=w(m,I.value,v),null!==I&&(k=f(I,k,H),null===A?x=I:A.sibling=
+I,A=I);K&&nd(m,H);return x}for(y=d(m,y);!I.done;H++,I=n.next())I=t(y,m,H,I.value,v),null!==I&&(a&&null!==I.alternate&&y.delete(null===I.key?H:I.key),k=f(I,k,H),null===A?x=I:A.sibling=I,A=I);a&&y.forEach(function(Jm){return b(m,Jm)});K&&nd(m,H);return x}function U(m,k,n,v){"object"===typeof n&&null!==n&&n.type===na&&null===n.key&&(n=n.props.children);if("object"===typeof n&&null!==n){switch(n.$$typeof){case la:a:{for(var x=n.key,A=k;null!==A;){if(A.key===x){x=n.type;if(x===na){if(7===A.tag){c(m,A.sibling);
 k=e(A,n.props.children);k.return=m;m=k;break a}}else if(A.elementType===x||"object"===typeof x&&null!==x&&x.$$typeof===xa&&ue(x)===A.type){c(m,A.sibling);k=e(A,n.props);k.ref=se(m,A,n);k.return=m;m=k;break a}c(m,A);break}else b(m,A);A=A.sibling}n.type===na?(k=Ae(n.props.children,m.mode,v,n.key),k.return=m,m=k):(v=ye(n.type,n.key,n.props,null,null,m.mode,v),v.ref=se(m,k,n),v.return=m,m=v)}return g(m);case ma:a:{for(A=n.key;null!==k;){if(k.key===A)if(4===k.tag&&k.stateNode.containerInfo===n.containerInfo&&
 k.stateNode.implementation===n.implementation){c(m,k.sibling);k=e(k,n.children||[]);k.return=m;m=k;break a}else{c(m,k);break}else b(m,k);k=k.sibling}k=ze(n,m.mode,v);k.return=m;m=k}return g(m);case xa:return A=n._init,V(m,k,A(n._payload),v)}if(rc(n))return z(m,k,n,v);if(Da(n))return B(m,k,n,v);if("function"===typeof n.then)return U(m,k,re(n),v);if(n.$$typeof===ra||n.$$typeof===sa)return U(m,k,Be(m,n,v),v);te(m,n)}return"string"===typeof n&&""!==n||"number"===typeof n?(n=""+n,null!==k&&6===k.tag?(c(m,
 k.sibling),k=e(k,n),k.return=m,m=k):(c(m,k),k=xe(n,m.mode,v),k.return=m,m=k),g(m)):c(m,k)}function V(m,k,n,v){qe=0;m=U(m,k,n,v);pe=null;return m}return V}var Ce=ve(!0),De=ve(!1),Ee=ka(null),Fe=ka(0);function Ge(a,b){a=He;E(Fe,a);E(Ee,b);He=a|b.baseLanes}function Ie(){E(Fe,He);E(Ee,Ee.current)}function Je(){He=Fe.current;D(Ee);D(Fe)}var Ke=ka(null),Le=null;function Me(a){var b=a.alternate;E(Ne,Ne.current&1);E(Ke,a);null===Le&&(null===b||null!==Ee.current?Le=a:null!==b.memoizedState&&(Le=a))}
 function Oe(a){if(22===a.tag){if(E(Ne,Ne.current),E(Ke,a),null===Le){var b=a.alternate;null!==b&&null!==b.memoizedState&&(Le=a)}}else Pe(a)}function Pe(){E(Ne,Ne.current);E(Ke,Ke.current)}function Qe(a){D(Ke);Le===a&&(Le=null);D(Ne)}var Ne=ka(0);
 function Re(a){for(var b=a;null!==b;){if(13===b.tag){var c=b.memoizedState;if(null!==c&&(c=c.dehydrated,null===c||"$?"===c.data||"$!"===c.data))return b}else if(19===b.tag&&void 0!==b.memoizedProps.revealOrder){if(0!==(b.flags&128))return b}else if(null!==b.child){b.child.return=b;b=b.child;continue}if(b===a)break;for(;null===b.sibling;){if(null===b.return||b.return===a)return null;b=b.return}b.sibling.return=b.return;b=b.sibling}return null}var Se=null,Te=null,Ue=!1,Ve=!1,We=!1,Xe=0;
 function Ye(a){a!==Te&&null===a.next&&(null===Te?Se=Te=a:Te=Te.next=a);Ve=!0;Ue||(Ue=!0,Ze($e))}
-function af(a){if(!We&&Ve){var b=null;We=!0;do{var c=!1;for(var d=Se;null!==d;){if(!a||0===d.tag){var e=M,f=jb(d,d===N?e:0);if(0!==(f&3))try{c=!0;e=d;if(0!==(L&6))throw Error(t(327));if(!bf()){var g=cf(e,f);if(0!==e.tag&&2===g){var h=f,l=lb(e,h);0!==l&&(f=l,g=df(e,h,l))}if(1===g)throw h=ef,ff(e,0),gf(e,f,0),Ye(e),h;6===g?gf(e,f,0):(e.finishedWork=e.current.alternate,e.finishedLanes=f,hf(e,jf,kf,lf))}Ye(e)}catch(p){null===b?b=[p]:b.push(p)}}d=d.next}}while(c);We=!1;if(null!==b){if(1<b.length){if("function"===
+function af(a){if(!We&&Ve){var b=null;We=!0;do{var c=!1;for(var d=Se;null!==d;){if(!a||0===d.tag){var e=M,f=jb(d,d===N?e:0);if(0!==(f&3))try{c=!0;e=d;if(0!==(L&6))throw Error(u(327));if(!bf()){var g=cf(e,f);if(0!==e.tag&&2===g){var h=f,l=lb(e,h);0!==l&&(f=l,g=df(e,h,l))}if(1===g)throw h=ef,ff(e,0),gf(e,f,0),Ye(e),h;6===g?gf(e,f,0):(e.finishedWork=e.current.alternate,e.finishedLanes=f,hf(e,jf,kf,lf))}Ye(e)}catch(p){null===b?b=[p]:b.push(p)}}d=d.next}}while(c);We=!1;if(null!==b){if(1<b.length){if("function"===
 typeof AggregateError)throw new AggregateError(b);for(a=1;a<b.length;a++)Ze(mf.bind(null,b[a]))}throw b[0];}}}function mf(a){throw a;}function $e(){Ve=Ue=!1;for(var a=Ta(),b=null,c=Se;null!==c;){var d=c.next;if(0!==Xe&&nf()){var e=c,f=Xe;e.pendingLanes|=2;e.entangledLanes|=2;e.entanglements[1]|=f}e=of(c,a);0===e?(c.next=null,null===b?Se=d:b.next=d,null===d&&(Te=b)):(b=c,0!==(e&3)&&(Ve=!0));c=d}Xe=0;af(!1)}
 function of(a,b){for(var c=a.suspendedLanes,d=a.pingedLanes,e=a.expirationTimes,f=a.pendingLanes&-62914561;0<f;){var g=31-db(f),h=1<<g,l=e[g];if(-1===l){if(0===(h&c)||0!==(h&d))e[g]=kb(h,b)}else l<=b&&(a.expiredLanes|=h);f&=~h}b=N;c=M;c=jb(a,a===b?c:0);d=a.callbackNode;if(0===c||a===b&&2===O||null!==a.cancelPendingCommit)return null!==d&&null!==d&&Qa(d),a.callbackNode=null,a.callbackPriority=0;if(0!==(c&3))return null!==d&&null!==d&&Qa(d),a.callbackPriority=2,a.callbackNode=null,2;b=c&-c;if(b===a.callbackPriority)return b;
 null!==d&&Qa(d);switch(ub(c)){case 2:c=Va;break;case 8:c=Wa;break;case 32:c=Xa;break;case 268435456:c=Za;break;default:c=Xa}d=pf.bind(null,a);c=Pa(c,d);a.callbackPriority=b;a.callbackNode=c;return b}function Ze(a){qf(function(){0!==(L&6)?Pa(Va,a):a()})}function rf(){if(0===Xe){var a=gb;gb<<=1;0===(gb&4194176)&&(gb=128);Xe=a}return Xe}var sf=null,tf=0,uf=0;
-function vf(a,b){if(null===sf){var c=sf=[];tf=0;uf=rf()}else c=sf;tf++;var d=wf(c),e="pending",f,g;a.then(function(h){e="fulfilled";f=null!==b?b:h;xf()},function(h){e="rejected";g=h;xf()});c.push(function(){switch(e){case "fulfilled":d.status="fulfilled";d.value=f;break;case "rejected":d.status="rejected";d.reason=g;break;default:throw Error(t(478));}});return d}function yf(a,b){var c=null!==b?b:a;if(null===sf)return c;a=sf;var d=wf(a);a.push(function(){d.status="fulfilled";d.value=c});return d}
-function xf(){if(null!==sf&&0===--tf){var a=sf;sf=null;for(var b=uf=0;b<a.length;b++)(0,a[b])()}}function wf(a){return{status:"pending",value:null,reason:null,then:function(b){a.push(b)}}}var zf=da.ReactCurrentDispatcher,Af=da.ReactCurrentBatchConfig,Bf=0,P=null,Q=null,R=null,Cf=!1,Df=!1,Ef=!1,Ff=0,Gf=0,Hf=null,If=0;function Jf(){throw Error(t(321));}function Kf(a,b){if(null===b)return!1;for(var c=0;c<b.length&&c<a.length;c++)if(!dd(a[c],b[c]))return!1;return!0}
-function Lf(a,b,c,d,e,f){Bf=f;P=b;b.memoizedState=null;b.updateQueue=null;b.lanes=0;zf.current=null===a||null===a.memoizedState?Mf:Nf;Ef=!1;a=c(d,e);Ef=!1;Df&&(a=Of(b,c,d,e));Pf();return a}function Pf(){zf.current=Qf;var a=null!==Q&&null!==Q.next;Bf=0;R=Q=P=null;Cf=!1;Gf=0;Hf=null;if(a)throw Error(t(300));}function Of(a,b,c,d){P=a;var e=0;do{Df&&(Hf=null);Gf=0;Df=!1;if(25<=e)throw Error(t(301));e+=1;R=Q=null;a.updateQueue=null;zf.current=Rf;var f=b(c,d)}while(Df);return f}
+function vf(a,b){if(null===sf){var c=sf=[];tf=0;uf=rf()}else c=sf;tf++;var d=wf(c),e="pending",f,g;a.then(function(h){e="fulfilled";f=null!==b?b:h;xf()},function(h){e="rejected";g=h;xf()});c.push(function(){switch(e){case "fulfilled":d.status="fulfilled";d.value=f;break;case "rejected":d.status="rejected";d.reason=g;break;default:throw Error(u(478));}});return d}function yf(a,b){var c=null!==b?b:a;if(null===sf)return c;a=sf;var d=wf(a);a.push(function(){d.status="fulfilled";d.value=c});return d}
+function xf(){if(null!==sf&&0===--tf){var a=sf;sf=null;for(var b=uf=0;b<a.length;b++)(0,a[b])()}}function wf(a){return{status:"pending",value:null,reason:null,then:function(b){a.push(b)}}}var zf=da.ReactCurrentDispatcher,Af=da.ReactCurrentBatchConfig,Bf=0,P=null,Q=null,R=null,Cf=!1,Df=!1,Ef=!1,Ff=0,Gf=0,Hf=null,If=0;function Jf(){throw Error(u(321));}function Kf(a,b){if(null===b)return!1;for(var c=0;c<b.length&&c<a.length;c++)if(!dd(a[c],b[c]))return!1;return!0}
+function Lf(a,b,c,d,e,f){Bf=f;P=b;b.memoizedState=null;b.updateQueue=null;b.lanes=0;zf.current=null===a||null===a.memoizedState?Mf:Nf;Ef=!1;a=c(d,e);Ef=!1;Df&&(a=Of(b,c,d,e));Pf();return a}function Pf(){zf.current=Qf;var a=null!==Q&&null!==Q.next;Bf=0;R=Q=P=null;Cf=!1;Gf=0;Hf=null;if(a)throw Error(u(300));}function Of(a,b,c,d){P=a;var e=0;do{Df&&(Hf=null);Gf=0;Df=!1;if(25<=e)throw Error(u(301));e+=1;R=Q=null;a.updateQueue=null;zf.current=Rf;var f=b(c,d)}while(Df);return f}
 function Sf(){var a=zf.current.useState()[0];return"function"===typeof a.then?Tf(a):a}function Uf(){var a=0!==Ff;Ff=0;return a}function Vf(a,b,c){b.updateQueue=a.updateQueue;b.flags&=-2053;a.lanes&=~c}function Wf(a){if(Cf){for(a=a.memoizedState;null!==a;){var b=a.queue;null!==b&&(b.pending=null);a=a.next}Cf=!1}Bf=0;R=Q=P=null;Df=!1;Gf=Ff=0;Hf=null}function Xf(){var a={memoizedState:null,baseState:null,baseQueue:null,queue:null,next:null};null===R?P.memoizedState=R=a:R=R.next=a;return R}
-function Yf(){if(null===Q){var a=P.alternate;a=null!==a?a.memoizedState:null}else a=Q.next;var b=null===R?P.memoizedState:R.next;if(null!==b)R=b,Q=a;else{if(null===a){if(null===P.alternate)throw Error(t(467));throw Error(t(310));}Q=a;a={memoizedState:Q.memoizedState,baseState:Q.baseState,baseQueue:Q.baseQueue,queue:Q.queue,next:null};null===R?P.memoizedState=R=a:R=R.next=a}return R}var Zf;Zf=function(){return{lastEffect:null,events:null,stores:null}};
-function Tf(a){var b=Gf;Gf+=1;null===Hf&&(Hf=[]);a=me(Hf,a,b);null===P.alternate&&(null===R?null===P.memoizedState:null===R.next)&&(zf.current=Mf);return a}function $f(a){if(null!==a&&"object"===typeof a){if("function"===typeof a.then)return Tf(a);if(a.$$typeof===ra||a.$$typeof===sa)return ag(a)}throw Error(t(438,String(a)));}function bg(a,b){return"function"===typeof b?b(a):b}function cg(a){var b=Yf();return dg(b,Q,a)}
-function dg(a,b,c){var d=a.queue;if(null===d)throw Error(t(311));d.lastRenderedReducer=c;var e=a.baseQueue,f=d.pending;if(null!==f){if(null!==e){var g=e.next;e.next=f.next;f.next=g}b.baseQueue=e=f;d.pending=null}if(null!==e){b=e.next;f=a.baseState;var h=g=null,l=null,p=b;do{var q=p.lane&-536870913;if(q!==p.lane?(M&q)===q:(Bf&q)===q){q=p.revertLane;if(0===q)null!==l&&(l=l.next={lane:0,revertLane:0,action:p.action,hasEagerState:p.hasEagerState,eagerState:p.eagerState,next:null});else if((Bf&q)===q){p=
+function Yf(){if(null===Q){var a=P.alternate;a=null!==a?a.memoizedState:null}else a=Q.next;var b=null===R?P.memoizedState:R.next;if(null!==b)R=b,Q=a;else{if(null===a){if(null===P.alternate)throw Error(u(467));throw Error(u(310));}Q=a;a={memoizedState:Q.memoizedState,baseState:Q.baseState,baseQueue:Q.baseQueue,queue:Q.queue,next:null};null===R?P.memoizedState=R=a:R=R.next=a}return R}var Zf;Zf=function(){return{lastEffect:null,events:null,stores:null}};
+function Tf(a){var b=Gf;Gf+=1;null===Hf&&(Hf=[]);a=me(Hf,a,b);null===P.alternate&&(null===R?null===P.memoizedState:null===R.next)&&(zf.current=Mf);return a}function $f(a){if(null!==a&&"object"===typeof a){if("function"===typeof a.then)return Tf(a);if(a.$$typeof===ra||a.$$typeof===sa)return ag(a)}throw Error(u(438,String(a)));}function bg(a,b){return"function"===typeof b?b(a):b}function cg(a){var b=Yf();return dg(b,Q,a)}
+function dg(a,b,c){var d=a.queue;if(null===d)throw Error(u(311));d.lastRenderedReducer=c;var e=a.baseQueue,f=d.pending;if(null!==f){if(null!==e){var g=e.next;e.next=f.next;f.next=g}b.baseQueue=e=f;d.pending=null}if(null!==e){b=e.next;f=a.baseState;var h=g=null,l=null,p=b;do{var q=p.lane&-536870913;if(q!==p.lane?(M&q)===q:(Bf&q)===q){q=p.revertLane;if(0===q)null!==l&&(l=l.next={lane:0,revertLane:0,action:p.action,hasEagerState:p.hasEagerState,eagerState:p.eagerState,next:null});else if((Bf&q)===q){p=
 p.next;continue}else{var w={lane:0,revertLane:p.revertLane,action:p.action,hasEagerState:p.hasEagerState,eagerState:p.eagerState,next:null};null===l?(h=l=w,g=f):l=l.next=w;P.lanes|=q;de|=q}q=p.action;Ef&&c(f,q);f=p.hasEagerState?p.eagerState:c(f,q)}else w={lane:q,revertLane:p.revertLane,action:p.action,hasEagerState:p.hasEagerState,eagerState:p.eagerState,next:null},null===l?(h=l=w,g=f):l=l.next=w,P.lanes|=q,de|=q;p=p.next}while(null!==p&&p!==b);null===l?g=f:l.next=h;dd(f,a.memoizedState)||(eg=!0);
-a.memoizedState=f;a.baseState=g;a.baseQueue=l;d.lastRenderedState=f}null===e&&(d.lanes=0);return[a.memoizedState,d.dispatch]}function fg(a){var b=Yf(),c=b.queue;if(null===c)throw Error(t(311));c.lastRenderedReducer=a;var d=c.dispatch,e=c.pending,f=b.memoizedState;if(null!==e){c.pending=null;var g=e=e.next;do f=a(f,g.action),g=g.next;while(g!==e);dd(f,b.memoizedState)||(eg=!0);b.memoizedState=f;null===b.baseQueue&&(b.baseState=f);c.lastRenderedState=f}return[f,d]}
-function gg(a,b,c){var d=P,e=Yf(),f=K;if(f){if(void 0===c)throw Error(t(407));c=c()}else c=b();var g=!dd((Q||e).memoizedState,c);g&&(e.memoizedState=c,eg=!0);e=e.queue;hg(ig.bind(null,d,e,a),[a]);if(e.getSnapshot!==b||g||null!==R&&R.memoizedState.tag&1){d.flags|=2048;jg(9,kg.bind(null,d,e,c,b),{destroy:void 0},null);if(null===N)throw Error(t(349));f||0!==(Bf&60)||lg(d,b,c)}return c}
+a.memoizedState=f;a.baseState=g;a.baseQueue=l;d.lastRenderedState=f}null===e&&(d.lanes=0);return[a.memoizedState,d.dispatch]}function fg(a){var b=Yf(),c=b.queue;if(null===c)throw Error(u(311));c.lastRenderedReducer=a;var d=c.dispatch,e=c.pending,f=b.memoizedState;if(null!==e){c.pending=null;var g=e=e.next;do f=a(f,g.action),g=g.next;while(g!==e);dd(f,b.memoizedState)||(eg=!0);b.memoizedState=f;null===b.baseQueue&&(b.baseState=f);c.lastRenderedState=f}return[f,d]}
+function gg(a,b,c){var d=P,e=Yf(),f=K;if(f){if(void 0===c)throw Error(u(407));c=c()}else c=b();var g=!dd((Q||e).memoizedState,c);g&&(e.memoizedState=c,eg=!0);e=e.queue;hg(ig.bind(null,d,e,a),[a]);if(e.getSnapshot!==b||g||null!==R&&R.memoizedState.tag&1){d.flags|=2048;jg(9,kg.bind(null,d,e,c,b),{destroy:void 0},null);if(null===N)throw Error(u(349));f||0!==(Bf&60)||lg(d,b,c)}return c}
 function lg(a,b,c){a.flags|=16384;a={getSnapshot:b,value:c};b=P.updateQueue;null===b?(b=Zf(),P.updateQueue=b,b.stores=[a]):(c=b.stores,null===c?b.stores=[a]:c.push(a))}function kg(a,b,c,d){b.value=c;b.getSnapshot=d;mg(b)&&ng(a)}function ig(a,b,c){return c(function(){mg(b)&&ng(a)})}function mg(a){var b=a.getSnapshot;a=a.value;try{var c=b();return!dd(a,c)}catch(d){return!0}}function ng(a){var b=Td(a,2);null!==b&&og(b,a,2)}
-function pg(a){var b=Xf();"function"===typeof a&&(a=a());b.memoizedState=b.baseState=a;b.queue={pending:null,lanes:0,dispatch:null,lastRenderedReducer:bg,lastRenderedState:a};return b}function qg(a,b,c,d){a.baseState=c;return dg(a,Q,"function"===typeof d?d:bg)}function rg(a,b,c,d){if(sg(a))throw Error(t(485));a=b.pending;null===a?(a={payload:d,next:null},a.next=b.pending=a,tg(b,c,d)):b.pending=a.next={payload:d,next:a.next}}
+function pg(a){var b=Xf();"function"===typeof a&&(a=a());b.memoizedState=b.baseState=a;b.queue={pending:null,lanes:0,dispatch:null,lastRenderedReducer:bg,lastRenderedState:a};return b}function qg(a,b,c,d){a.baseState=c;return dg(a,Q,"function"===typeof d?d:bg)}function rg(a,b,c,d){if(sg(a))throw Error(u(485));a=b.pending;null===a?(a={payload:d,next:null},a.next=b.pending=a,tg(b,c,d)):b.pending=a.next={payload:d,next:a.next}}
 function tg(a,b,c){var d=a.action,e=a.state,f=Af.transition;Af.transition={};try{var g=d(e,c);if(null!==g&&"object"===typeof g&&"function"===typeof g.then){g.then(function(p){a.state=p;ug(a,b)},function(){return ug(a,b)});var h=vf(g,null);b(h)}else{var l=yf(g,null);b(l);a.state=g;ug(a,b)}}catch(p){b({then:function(){},status:"rejected",reason:p}),ug(a,b)}finally{Af.transition=f}}
 function ug(a,b){var c=a.pending;if(null!==c){var d=c.next;d===c?a.pending=null:(d=d.next,c.next=d,tg(a,b,d.payload))}}function vg(a,b){return b}function wg(a,b,c){a=dg(a,b,vg)[0];a="object"===typeof a&&null!==a&&"function"===typeof a.then?Tf(a):a;b=Yf();var d=b.queue,e=d.dispatch;c!==b.memoizedState&&(P.flags|=2048,jg(9,xg.bind(null,d,c),{destroy:void 0},null));return[a,e]}function xg(a,b){a.action=b}
 function jg(a,b,c,d){a={tag:a,create:b,inst:c,deps:d,next:null};b=P.updateQueue;null===b?(b=Zf(),P.updateQueue=b,b.lastEffect=a.next=a):(c=b.lastEffect,null===c?b.lastEffect=a.next=a:(d=c.next,c.next=a,a.next=d,b.lastEffect=a));return a}function yg(){return Yf().memoizedState}function zg(a,b,c,d){var e=Xf();P.flags|=a;e.memoizedState=jg(1|b,c,{destroy:void 0},void 0===d?null:d)}
@@ -123,14 +122,14 @@ function Ag(a,b,c,d){var e=Yf();d=void 0===d?null:d;var f=e.memoizedState.inst;n
 function Fg(a,b,c){c=null!==c&&void 0!==c?c.concat([a]):null;Ag(4,4,Eg.bind(null,b,a),c)}function Gg(){}function Hg(a,b){var c=Yf();b=void 0===b?null:b;var d=c.memoizedState;if(null!==b&&Kf(b,d[1]))return d[0];c.memoizedState=[a,b];return a}function Ig(a,b){var c=Yf();b=void 0===b?null:b;var d=c.memoizedState;if(null!==b&&Kf(b,d[1]))return d[0];Ef&&a();a=a();c.memoizedState=[a,b];return a}
 function Jg(a,b,c){if(dd(c,b))return c;if(null!==Ee.current)return a.memoizedState=c,dd(c,b)||(eg=!0),c;if(0===(Bf&42))return eg=!0,a.memoizedState=c;0===lf&&(lf=0===(M&536870912)||K?rf():536870912);a=lf;P.lanes|=a;de|=a;return b}
 function Kg(a,b,c,d,e){var f=F;F=0!==f&&8>f?f:8;var g=Af.transition;Af.transition={};Lg(a,!1,b,c);try{var h=e();if(null!==h&&"object"===typeof h&&"function"===typeof h.then){var l=vf(h,d);Mg(a,b,l)}else{var p=yf(h,d);Mg(a,b,p)}}catch(q){Mg(a,b,{then:function(){},status:"rejected",reason:q})}finally{F=f,Af.transition=g}}
-function Ng(a,b,c,d){if(5!==a.tag)throw Error(t(476));if(null===a.memoizedState){var e={pending:null,lanes:0,dispatch:null,lastRenderedReducer:bg,lastRenderedState:fa};var f=e;e={memoizedState:fa,baseState:fa,baseQueue:null,queue:e,next:null};a.memoizedState=e;var g=a.alternate;null!==g&&(g.memoizedState=e)}else f=a.memoizedState.queue;Kg(a,f,b,fa,function(){return c(d)})}function Og(){var a=ag(Ia);return null!==a?a:fa}function Pg(){return Yf().memoizedState}
+function Ng(a,b,c,d){if(5!==a.tag)throw Error(u(476));if(null===a.memoizedState){var e={pending:null,lanes:0,dispatch:null,lastRenderedReducer:bg,lastRenderedState:fa};var f=e;e={memoizedState:fa,baseState:fa,baseQueue:null,queue:e,next:null};a.memoizedState=e;var g=a.alternate;null!==g&&(g.memoizedState=e)}else f=a.memoizedState.queue;Kg(a,f,b,fa,function(){return c(d)})}function Og(){var a=ag(Ia);return null!==a?a:fa}function Pg(){return Yf().memoizedState}
 function Qg(){return Yf().memoizedState}function Rg(a){for(var b=a.return;null!==b;){switch(b.tag){case 24:case 3:var c=Sg(b);a=Zd(c);var d=$d(b,a,c);null!==d&&(og(d,b,c),ae(d,b,c));b={cache:Tg()};a.payload=b;return}b=b.return}}function Ug(a,b,c){var d=Sg(a);c={lane:d,revertLane:0,action:c,hasEagerState:!1,eagerState:null,next:null};sg(a)?Vg(b,c):(c=Rd(a,b,c,d),null!==c&&(og(c,a,d),Wg(c,b,d)))}
 function Mg(a,b,c){var d=Sg(a),e={lane:d,revertLane:0,action:c,hasEagerState:!1,eagerState:null,next:null};if(sg(a))Vg(b,e);else{var f=a.alternate;if(0===a.lanes&&(null===f||0===f.lanes)&&(f=b.lastRenderedReducer,null!==f))try{var g=b.lastRenderedState,h=f(g,c);e.hasEagerState=!0;e.eagerState=h;if(dd(h,g)){Qd(a,b,e,0);null===N&&Od();return}}catch(l){}finally{}c=Rd(a,b,e,d);null!==c&&(og(c,a,d),Wg(c,b,d))}}
-function Lg(a,b,c,d){d={lane:2,revertLane:rf(),action:d,hasEagerState:!1,eagerState:null,next:null};if(sg(a)){if(b)throw Error(t(479));}else b=Rd(a,c,d,2),null!==b&&og(b,a,2)}function sg(a){var b=a.alternate;return a===P||null!==b&&b===P}function Vg(a,b){Df=Cf=!0;var c=a.pending;null===c?b.next=b:(b.next=c.next,c.next=b);a.pending=b}function Wg(a,b,c){if(0!==(c&4194176)){var d=b.lanes;d&=a.pendingLanes;c|=d;b.lanes=c;rb(a,c)}}
+function Lg(a,b,c,d){d={lane:2,revertLane:rf(),action:d,hasEagerState:!1,eagerState:null,next:null};if(sg(a)){if(b)throw Error(u(479));}else b=Rd(a,c,d,2),null!==b&&og(b,a,2)}function sg(a){var b=a.alternate;return a===P||null!==b&&b===P}function Vg(a,b){Df=Cf=!0;var c=a.pending;null===c?b.next=b:(b.next=c.next,c.next=b);a.pending=b}function Wg(a,b,c){if(0!==(c&4194176)){var d=b.lanes;d&=a.pendingLanes;c|=d;b.lanes=c;rb(a,c)}}
 var Qf={readContext:ag,use:$f,useCallback:Jf,useContext:Jf,useEffect:Jf,useImperativeHandle:Jf,useInsertionEffect:Jf,useLayoutEffect:Jf,useMemo:Jf,useReducer:Jf,useRef:Jf,useState:Jf,useDebugValue:Jf,useDeferredValue:Jf,useTransition:Jf,useSyncExternalStore:Jf,useId:Jf};Qf.useCacheRefresh=Jf;Qf.useHostTransitionStatus=Jf;Qf.useFormState=Jf;Qf.useOptimistic=Jf;
 var Mf={readContext:ag,use:$f,useCallback:function(a,b){Xf().memoizedState=[a,void 0===b?null:b];return a},useContext:ag,useEffect:Bg,useImperativeHandle:function(a,b,c){c=null!==c&&void 0!==c?c.concat([a]):null;zg(4194308,4,Eg.bind(null,b,a),c)},useLayoutEffect:function(a,b){return zg(4194308,4,a,b)},useInsertionEffect:function(a,b){zg(4,2,a,b)},useMemo:function(a,b){var c=Xf();b=void 0===b?null:b;Ef&&a();a=a();c.memoizedState=[a,b];return a},useReducer:function(a,b,c){var d=Xf();b=void 0!==c?c(b):
 b;d.memoizedState=d.baseState=b;a={pending:null,lanes:0,dispatch:null,lastRenderedReducer:a,lastRenderedState:b};d.queue=a;a=a.dispatch=Ug.bind(null,P,a);return[d.memoizedState,a]},useRef:function(a){var b=Xf();a={current:a};return b.memoizedState=a},useState:function(a){a=pg(a);var b=a.queue,c=Mg.bind(null,P,b);b.dispatch=c;return[a.memoizedState,c]},useDebugValue:Gg,useDeferredValue:function(a){Xf().memoizedState=a;return a},useTransition:function(){var a=pg(!1);a=Kg.bind(null,P,a.queue,!0,!1);
-Xf().memoizedState=a;return[!1,a]},useSyncExternalStore:function(a,b,c){var d=P,e=Xf();if(K){if(void 0===c)throw Error(t(407));c=c()}else{c=b();if(null===N)throw Error(t(349));0!==(M&60)||lg(d,b,c)}e.memoizedState=c;var f={value:c,getSnapshot:b};e.queue=f;Bg(ig.bind(null,d,f,a),[a]);d.flags|=2048;jg(9,kg.bind(null,d,f,c,b),{destroy:void 0},null);return c},useId:function(){var a=Xf(),b=N.identifierPrefix;if(K){var c=md;var d=ld;c=(d&~(1<<32-db(d)-1)).toString(32)+c;b=":"+b+"R"+c;c=Ff++;0<c&&(b+="H"+
+Xf().memoizedState=a;return[!1,a]},useSyncExternalStore:function(a,b,c){var d=P,e=Xf();if(K){if(void 0===c)throw Error(u(407));c=c()}else{c=b();if(null===N)throw Error(u(349));0!==(M&60)||lg(d,b,c)}e.memoizedState=c;var f={value:c,getSnapshot:b};e.queue=f;Bg(ig.bind(null,d,f,a),[a]);d.flags|=2048;jg(9,kg.bind(null,d,f,c,b),{destroy:void 0},null);return c},useId:function(){var a=Xf(),b=N.identifierPrefix;if(K){var c=md;var d=ld;c=(d&~(1<<32-db(d)-1)).toString(32)+c;b=":"+b+"R"+c;c=Ff++;0<c&&(b+="H"+
 c.toString(32));b+=":"}else c=If++,b=":"+b+"r"+c.toString(32)+":";return a.memoizedState=b},useCacheRefresh:function(){return Xf().memoizedState=Rg.bind(null,P)}};Mf.useHostTransitionStatus=Og;
 Mf.useFormState=function(a,b){if(K){var c=N.formState;if(null!==c){a:{if(K){if(J){b:{var d=J;for(var e=sd;8!==d.nodeType;){if(!e){d=null;break b}d=Cd(d);if(null===d){d=null;break b}}e=d.data;d="F!"===e||"F"===e?d:null}if(d){J=Cd(d);d="F!"===d.data;break a}}Ed()}d=!1}d&&(b=c[0])}}c=Xf();c.memoizedState=c.baseState=b;d={pending:null,lanes:0,dispatch:null,lastRenderedReducer:vg,lastRenderedState:b};c.queue=d;c=Mg.bind(null,P,d);d.dispatch=c;d=Xf();e={state:b,dispatch:null,action:a,pending:null};d.queue=
 e;c=rg.bind(null,P,e,c);e.dispatch=c;d.memoizedState=a;return[b,c]};Mf.useOptimistic=function(a){var b=Xf();b.memoizedState=b.baseState=a;var c={pending:null,lanes:0,dispatch:null,lastRenderedReducer:null,lastRenderedState:null};b.queue=c;b=Lg.bind(null,P,!0,c);c.dispatch=b;return[a,b]};
@@ -149,8 +148,8 @@ function eh(a,b,c){return{value:a,source:null,stack:null!=c?c:null,digest:null!=
 function jh(a,b,c){c=Zd(c);c.tag=3;var d=a.type.getDerivedStateFromError;if("function"===typeof d){var e=b.value;c.payload=function(){return d(e)};c.callback=function(){fh(a,b)}}var f=a.stateNode;null!==f&&"function"===typeof f.componentDidCatch&&(c.callback=function(){fh(a,b);"function"!==typeof d&&(null===kh?kh=new Set([this]):kh.add(this));var g=b.stack;this.componentDidCatch(b.value,{componentStack:null!==g?g:""})});return c}
 function lh(a,b,c,d,e){if(0===(a.mode&1))return a===b?a.flags|=65536:(a.flags|=128,c.flags|=131072,c.flags&=-52805,1===c.tag&&(null===c.alternate?c.tag=17:(b=Zd(2),b.tag=2,$d(c,b,2))),c.lanes|=2),a;a.flags|=65536;a.lanes=e;return a}
 function mh(a,b,c,d,e){c.flags|=32768;if(null!==d&&"object"===typeof d&&"function"===typeof d.then){var f=c.tag;0!==(c.mode&1)||0!==f&&11!==f&&15!==f||((f=c.alternate)?(c.updateQueue=f.updateQueue,c.memoizedState=f.memoizedState,c.lanes=f.lanes):(c.updateQueue=null,c.memoizedState=null));f=Ke.current;if(null!==f){switch(f.tag){case 13:c.mode&1&&(null===Le?nh():null===f.alternate&&0===oh&&(oh=3));f.flags&=-257;lh(f,b,c,a,e);d===je?f.flags|=16384:(b=f.updateQueue,null===b?f.updateQueue=new Set([d]):
-b.add(d),f.mode&1&&ph(a,d,e));return;case 22:if(f.mode&1){f.flags|=65536;d===je?f.flags|=16384:(b=f.updateQueue,null===b?(b={transitions:null,markerInstances:null,retryQueue:new Set([d])},f.updateQueue=b):(c=b.retryQueue,null===c?b.retryQueue=new Set([d]):c.add(d)),ph(a,d,e));return}}throw Error(t(435,f.tag));}if(1===a.tag){ph(a,d,e);nh();return}d=Error(t(426))}if(K&&c.mode&1&&(f=Ke.current,null!==f)){0===(f.flags&65536)&&(f.flags|=256);lh(f,b,c,a,e);Kd(dh(d,c));return}a=d=dh(d,c);4!==oh&&(oh=2);
-null===qh?qh=[a]:qh.push(a);a=b;do{switch(a.tag){case 3:a.flags|=65536;e&=-e;a.lanes|=e;e=gh(a,d,e);be(a,e);return;case 1:if(b=d,c=a.type,f=a.stateNode,0===(a.flags&128)&&("function"===typeof c.getDerivedStateFromError||null!==f&&"function"===typeof f.componentDidCatch&&(null===kh||!kh.has(f)))){a.flags|=65536;e&=-e;a.lanes|=e;e=jh(a,b,e);be(a,e);return}}a=a.return}while(null!==a)}var rh=da.ReactCurrentOwner,sh=Error(t(461)),eg=!1;
+b.add(d),f.mode&1&&ph(a,d,e));return;case 22:if(f.mode&1){f.flags|=65536;d===je?f.flags|=16384:(b=f.updateQueue,null===b?(b={transitions:null,markerInstances:null,retryQueue:new Set([d])},f.updateQueue=b):(c=b.retryQueue,null===c?b.retryQueue=new Set([d]):c.add(d)),ph(a,d,e));return}}throw Error(u(435,f.tag));}if(1===a.tag){ph(a,d,e);nh();return}d=Error(u(426))}if(K&&c.mode&1&&(f=Ke.current,null!==f)){0===(f.flags&65536)&&(f.flags|=256);lh(f,b,c,a,e);Kd(dh(d,c));return}a=d=dh(d,c);4!==oh&&(oh=2);
+null===qh?qh=[a]:qh.push(a);a=b;do{switch(a.tag){case 3:a.flags|=65536;e&=-e;a.lanes|=e;e=gh(a,d,e);be(a,e);return;case 1:if(b=d,c=a.type,f=a.stateNode,0===(a.flags&128)&&("function"===typeof c.getDerivedStateFromError||null!==f&&"function"===typeof f.componentDidCatch&&(null===kh||!kh.has(f)))){a.flags|=65536;e&=-e;a.lanes|=e;e=jh(a,b,e);be(a,e);return}}a=a.return}while(null!==a)}var rh=da.ReactCurrentOwner,sh=Error(u(461)),eg=!1;
 function th(a,b,c,d){b.child=null===a?De(b,null,c,d):Ce(b,a.child,c,d)}function uh(a,b,c,d,e){c=c.render;var f=b.ref;vh(b,e);d=Lf(a,b,c,d,f,e);c=Uf();if(null!==a&&!eg)return Vf(a,b,e),wh(a,b,e);K&&c&&pd(b);b.flags|=1;th(a,b,d,e);return b.child}
 function xh(a,b,c,d,e){if(null===a){var f=c.type;if("function"===typeof f&&!yh(f)&&void 0===f.defaultProps&&null===c.compare&&void 0===c.defaultProps)return b.tag=15,b.type=f,zh(a,b,f,d,e);a=ye(c.type,null,d,null,b,b.mode,e);a.ref=b.ref;a.return=b;return b.child=a}f=a.child;if(0===(a.lanes&e)){var g=f.memoizedProps;c=c.compare;c=null!==c?c:ge;if(c(g,d)&&a.ref===b.ref)return wh(a,b,e)}b.flags|=1;a=we(f,d);a.ref=b.ref;a.return=b;return b.child=a}
 function zh(a,b,c,d,e){if(null!==a){var f=a.memoizedProps;if(ge(f,d)&&a.ref===b.ref)if(eg=!1,b.pendingProps=d=f,0!==(a.lanes&e))0!==(a.flags&131072)&&(eg=!0);else return b.lanes=a.lanes,wh(a,b,e)}return Ah(a,b,c,d,e)}
@@ -159,8 +158,8 @@ cachePool:null},null!==a&&Eh(b,null!==g?g.cachePool:null),null!==g?Ge(b,g):Ie(),
 function Ch(a,b){var c=b.ref;if(null===a&&null!==c||null!==a&&a.ref!==c)b.flags|=512,b.flags|=2097152}function Ah(a,b,c,d,e){var f=Xc(c)?Vc:Tc.current;f=Wc(b,f);vh(b,e);c=Lf(a,b,c,d,f,e);d=Uf();if(null!==a&&!eg)return Vf(a,b,e),wh(a,b,e);K&&d&&pd(b);b.flags|=1;th(a,b,c,e);return b.child}function Gh(a,b,c,d,e,f){vh(b,f);c=Of(b,d,c,e);Pf();d=Uf();if(null!==a&&!eg)return Vf(a,b,f),wh(a,b,f);K&&d&&pd(b);b.flags|=1;th(a,b,c,f);return b.child}
 function Hh(a,b,c,d,e){if(Xc(c)){var f=!0;ad(b)}else f=!1;vh(b,e);if(null===b.stateNode)Ih(a,b),ah(b,c,d),ch(b,c,d,e),d=!0;else if(null===a){var g=b.stateNode,h=b.memoizedProps;g.props=h;var l=g.context,p=c.contextType;"object"===typeof p&&null!==p?p=ag(p):(p=Xc(c)?Vc:Tc.current,p=Wc(b,p));var q=c.getDerivedStateFromProps,w="function"===typeof q||"function"===typeof g.getSnapshotBeforeUpdate;w||"function"!==typeof g.UNSAFE_componentWillReceiveProps&&"function"!==typeof g.componentWillReceiveProps||
 (h!==d||l!==p)&&bh(b,g,d,p);Wd=!1;var r=b.memoizedState;g.state=r;ce(b,d,g,e);l=b.memoizedState;h!==d||r!==l||Uc.current||Wd?("function"===typeof q&&(Yg(b,c,q,d),l=b.memoizedState),(h=Wd||$g(b,c,h,d,r,l,p))?(w||"function"!==typeof g.UNSAFE_componentWillMount&&"function"!==typeof g.componentWillMount||("function"===typeof g.componentWillMount&&g.componentWillMount(),"function"===typeof g.UNSAFE_componentWillMount&&g.UNSAFE_componentWillMount()),"function"===typeof g.componentDidMount&&(b.flags|=4194308)):
-("function"===typeof g.componentDidMount&&(b.flags|=4194308),b.memoizedProps=d,b.memoizedState=l),g.props=d,g.state=l,g.context=p,d=h):("function"===typeof g.componentDidMount&&(b.flags|=4194308),d=!1)}else{g=b.stateNode;Yd(a,b);h=b.memoizedProps;p=b.type===b.elementType?h:Xg(b.type,h);g.props=p;w=b.pendingProps;r=g.context;l=c.contextType;"object"===typeof l&&null!==l?l=ag(l):(l=Xc(c)?Vc:Tc.current,l=Wc(b,l));var u=c.getDerivedStateFromProps;(q="function"===typeof u||"function"===typeof g.getSnapshotBeforeUpdate)||
-"function"!==typeof g.UNSAFE_componentWillReceiveProps&&"function"!==typeof g.componentWillReceiveProps||(h!==w||r!==l)&&bh(b,g,d,l);Wd=!1;r=b.memoizedState;g.state=r;ce(b,d,g,e);var z=b.memoizedState;h!==w||r!==z||Uc.current||Wd?("function"===typeof u&&(Yg(b,c,u,d),z=b.memoizedState),(p=Wd||$g(b,c,p,d,r,z,l)||!1)?(q||"function"!==typeof g.UNSAFE_componentWillUpdate&&"function"!==typeof g.componentWillUpdate||("function"===typeof g.componentWillUpdate&&g.componentWillUpdate(d,z,l),"function"===typeof g.UNSAFE_componentWillUpdate&&
+("function"===typeof g.componentDidMount&&(b.flags|=4194308),b.memoizedProps=d,b.memoizedState=l),g.props=d,g.state=l,g.context=p,d=h):("function"===typeof g.componentDidMount&&(b.flags|=4194308),d=!1)}else{g=b.stateNode;Yd(a,b);h=b.memoizedProps;p=b.type===b.elementType?h:Xg(b.type,h);g.props=p;w=b.pendingProps;r=g.context;l=c.contextType;"object"===typeof l&&null!==l?l=ag(l):(l=Xc(c)?Vc:Tc.current,l=Wc(b,l));var t=c.getDerivedStateFromProps;(q="function"===typeof t||"function"===typeof g.getSnapshotBeforeUpdate)||
+"function"!==typeof g.UNSAFE_componentWillReceiveProps&&"function"!==typeof g.componentWillReceiveProps||(h!==w||r!==l)&&bh(b,g,d,l);Wd=!1;r=b.memoizedState;g.state=r;ce(b,d,g,e);var z=b.memoizedState;h!==w||r!==z||Uc.current||Wd?("function"===typeof t&&(Yg(b,c,t,d),z=b.memoizedState),(p=Wd||$g(b,c,p,d,r,z,l)||!1)?(q||"function"!==typeof g.UNSAFE_componentWillUpdate&&"function"!==typeof g.componentWillUpdate||("function"===typeof g.componentWillUpdate&&g.componentWillUpdate(d,z,l),"function"===typeof g.UNSAFE_componentWillUpdate&&
 g.UNSAFE_componentWillUpdate(d,z,l)),"function"===typeof g.componentDidUpdate&&(b.flags|=4),"function"===typeof g.getSnapshotBeforeUpdate&&(b.flags|=1024)):("function"!==typeof g.componentDidUpdate||h===a.memoizedProps&&r===a.memoizedState||(b.flags|=4),"function"!==typeof g.getSnapshotBeforeUpdate||h===a.memoizedProps&&r===a.memoizedState||(b.flags|=1024),b.memoizedProps=d,b.memoizedState=z),g.props=d,g.state=z,g.context=l,d=p):("function"!==typeof g.componentDidUpdate||h===a.memoizedProps&&r===
 a.memoizedState||(b.flags|=4),"function"!==typeof g.getSnapshotBeforeUpdate||h===a.memoizedProps&&r===a.memoizedState||(b.flags|=1024),d=!1)}return Jh(a,b,c,d,f,e)}
 function Jh(a,b,c,d,e,f){Ch(a,b);var g=0!==(b.flags&128);if(!d&&!g)return e&&bd(b,c,!1),wh(a,b,f);d=b.stateNode;rh.current=b;var h=g&&"function"!==typeof c.getDerivedStateFromError?null:d.render();b.flags|=1;null!==a&&g?(b.child=Ce(b,a.child,null,f),b.child=Ce(b,null,h,f)):th(a,b,h,f);b.memoizedState=d.state;e&&bd(b,c,!0);return b.child}function Kh(a){var b=a.stateNode;b.pendingContext?Zc(a,b.pendingContext,b.pendingContext!==b.context):b.context&&Zc(a,b.context,!1);Ja(a,b.containerInfo)}
@@ -169,45 +168,45 @@ function Ph(a,b,c){var d=b.pendingProps,e=!1,f=0!==(b.flags&128),g;(g=f)||(g=nul
 d=b.mode,e=b.child,f={mode:"hidden",children:f},0===(d&1)&&null!==e?(e.childLanes=0,e.pendingProps=f):e=Qh(f,d,0,null),a=Ae(a,d,c,null),e.return=b,a.return=b,e.sibling=a,b.child=e,b.child.memoizedState=Nh(c),b.memoizedState=Mh,a;Me(b);return Rh(b,f)}g=a.memoizedState;if(null!==g){var h=g.dehydrated;if(null!==h)return Sh(a,b,f,d,h,g,c)}if(e){Pe(b);e=d.fallback;f=b.mode;g=a.child;h=g.sibling;var l={mode:"hidden",children:d.children};0===(f&1)&&b.child!==g?(d=b.child,d.childLanes=0,d.pendingProps=l,
 b.deletions=null):(d=we(g,l),d.subtreeFlags=g.subtreeFlags&31457280);null!==h?e=we(h,e):(e=Ae(e,f,c,null),e.flags|=2);e.return=b;d.return=b;d.sibling=e;b.child=d;d=e;e=b.child;f=a.child.memoizedState;null===f?f=Nh(c):(g=f.cachePool,null!==g?(h=S._currentValue,g=g.parent!==h?{parent:h,pool:h}:g):g=Oh(),f={baseLanes:f.baseLanes|c,cachePool:g});e.memoizedState=f;e.childLanes=a.childLanes&~c;b.memoizedState=Mh;return d}Me(b);e=a.child;a=e.sibling;d=we(e,{mode:"visible",children:d.children});0===(b.mode&
 1)&&(d.lanes=c);d.return=b;d.sibling=null;null!==a&&(c=b.deletions,null===c?(b.deletions=[a],b.flags|=16):c.push(a));b.child=d;b.memoizedState=null;return d}function Rh(a,b){b=Qh({mode:"visible",children:b},a.mode,0,null);b.return=a;return a.child=b}function Th(a,b,c,d){null!==d&&Kd(d);Ce(b,a.child,null,c);a=Rh(b,b.pendingProps.children);a.flags|=2;b.memoizedState=null;return a}
-function Sh(a,b,c,d,e,f,g){if(c){if(b.flags&256)return Me(b),b.flags&=-257,e=eh(Error(t(422))),Th(a,b,g,e);if(null!==b.memoizedState)return Pe(b),b.child=a.child,b.flags|=128,null;Pe(b);e=d.fallback;f=b.mode;d=Qh({mode:"visible",children:d.children},f,0,null);e=Ae(e,f,g,null);e.flags|=2;d.return=b;e.return=b;d.sibling=e;b.child=d;0!==(b.mode&1)&&Ce(b,a.child,null,g);b.child.memoizedState=Nh(g);b.memoizedState=Mh;return e}Me(b);if(0===(b.mode&1))return Th(a,b,g,null);if("$!"===e.data){e=e.nextSibling&&
-e.nextSibling.dataset;if(e)var h=e.dgst;e=h;d=Error(t(419));d.digest=e;e=eh(d,e,void 0);return Th(a,b,g,e)}h=0!==(g&a.childLanes);if(eg||h){d=N;if(null!==d){switch(g&-g){case 2:h=1;break;case 8:h=4;break;case 32:h=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:h=64;break;case 268435456:h=134217728;break;default:h=0}h=0!==
-(h&(d.suspendedLanes|g))?0:h;if(0!==h&&h!==f.retryLane)throw f.retryLane=h,Td(a,h),og(d,a,h),sh;}"$?"!==e.data&&nh();return Th(a,b,g,null)}if("$?"===e.data)return b.flags|=128,b.child=a.child,b=Uh.bind(null,a),e._reactRetry=b,null;a=f.treeContext;J=yd(e.nextSibling);G=b;K=!0;rd=null;sd=!1;null!==a&&(id[jd++]=ld,id[jd++]=md,id[jd++]=kd,ld=a.id,md=a.overflow,kd=b);b=Rh(b,d.children);b.flags|=4096;return b}function Vh(a,b,c){a.lanes|=b;var d=a.alternate;null!==d&&(d.lanes|=b);Wh(a.return,b,c)}
-function Xh(a,b,c,d,e){var f=a.memoizedState;null===f?a.memoizedState={isBackwards:b,rendering:null,renderingStartTime:0,last:d,tail:c,tailMode:e}:(f.isBackwards=b,f.rendering=null,f.renderingStartTime=0,f.last=d,f.tail=c,f.tailMode=e)}
+function Sh(a,b,c,d,e,f,g){if(c){if(b.flags&256)return Me(b),b.flags&=-257,e=eh(Error(u(422))),Th(a,b,g,e);if(null!==b.memoizedState)return Pe(b),b.child=a.child,b.flags|=128,null;Pe(b);e=d.fallback;f=b.mode;d=Qh({mode:"visible",children:d.children},f,0,null);e=Ae(e,f,g,null);e.flags|=2;d.return=b;e.return=b;d.sibling=e;b.child=d;0!==(b.mode&1)&&Ce(b,a.child,null,g);b.child.memoizedState=Nh(g);b.memoizedState=Mh;return e}Me(b);if(0===(b.mode&1))return Th(a,b,g,null);if("$!"===e.data){e=e.nextSibling&&
+e.nextSibling.dataset;if(e)var h=e.dgst;e=h;f=Error(u(419));f.digest=e;e=eh(f,e,void 0);return Th(a,b,g,e)}h=0!==(g&a.childLanes);if(eg||h){d=N;if(null!==d){h=g&-g;if(0!==(h&42))h=1;else switch(h){case 2:h=1;break;case 8:h=4;break;case 32:h=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:h=64;break;case 268435456:h=134217728;
+break;default:h=0}h=0!==(h&(d.suspendedLanes|g))?0:h;if(0!==h&&h!==f.retryLane)throw f.retryLane=h,Td(a,h),og(d,a,h),sh;}"$?"!==e.data&&nh();return Th(a,b,g,null)}if("$?"===e.data)return b.flags|=128,b.child=a.child,b=Uh.bind(null,a),e._reactRetry=b,null;a=f.treeContext;J=yd(e.nextSibling);G=b;K=!0;rd=null;sd=!1;null!==a&&(id[jd++]=ld,id[jd++]=md,id[jd++]=kd,ld=a.id,md=a.overflow,kd=b);b=Rh(b,d.children);b.flags|=4096;return b}
+function Vh(a,b,c){a.lanes|=b;var d=a.alternate;null!==d&&(d.lanes|=b);Wh(a.return,b,c)}function Xh(a,b,c,d,e){var f=a.memoizedState;null===f?a.memoizedState={isBackwards:b,rendering:null,renderingStartTime:0,last:d,tail:c,tailMode:e}:(f.isBackwards=b,f.rendering=null,f.renderingStartTime=0,f.last=d,f.tail=c,f.tailMode=e)}
 function Yh(a,b,c){var d=b.pendingProps,e=d.revealOrder,f=d.tail;th(a,b,d.children,c);d=Ne.current;if(0!==(d&2))d=d&1|2,b.flags|=128;else{if(null!==a&&0!==(a.flags&128))a:for(a=b.child;null!==a;){if(13===a.tag)null!==a.memoizedState&&Vh(a,c,b);else if(19===a.tag)Vh(a,c,b);else if(null!==a.child){a.child.return=a;a=a.child;continue}if(a===b)break a;for(;null===a.sibling;){if(null===a.return||a.return===b)break a;a=a.return}a.sibling.return=a.return;a=a.sibling}d&=1}E(Ne,d);if(0===(b.mode&1))b.memoizedState=
 null;else switch(e){case "forwards":c=b.child;for(e=null;null!==c;)a=c.alternate,null!==a&&null===Re(a)&&(e=c),c=c.sibling;c=e;null===c?(e=b.child,b.child=null):(e=c.sibling,c.sibling=null);Xh(b,!1,e,c,f);break;case "backwards":c=null;e=b.child;for(b.child=null;null!==e;){a=e.alternate;if(null!==a&&null===Re(a)){b.child=e;break}a=e.sibling;e.sibling=c;c=e;e=a}Xh(b,!0,c,null,f);break;case "together":Xh(b,!1,null,null,void 0);break;default:b.memoizedState=null}return b.child}
-function Ih(a,b){0===(b.mode&1)&&null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2)}function wh(a,b,c){null!==a&&(b.dependencies=a.dependencies);de|=b.lanes;if(0===(c&b.childLanes))return null;if(null!==a&&b.child!==a.child)throw Error(t(153));if(null!==b.child){a=b.child;c=we(a,a.pendingProps);b.child=c;for(c.return=b;null!==a.sibling;)a=a.sibling,c=c.sibling=we(a,a.pendingProps),c.return=b;c.sibling=null}return b.child}
+function Ih(a,b){0===(b.mode&1)&&null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2)}function wh(a,b,c){null!==a&&(b.dependencies=a.dependencies);de|=b.lanes;if(0===(c&b.childLanes))return null;if(null!==a&&b.child!==a.child)throw Error(u(153));if(null!==b.child){a=b.child;c=we(a,a.pendingProps);b.child=c;for(c.return=b;null!==a.sibling;)a=a.sibling,c=c.sibling=we(a,a.pendingProps),c.return=b;c.sibling=null}return b.child}
 function Zh(a,b,c){switch(b.tag){case 3:Kh(b);$h(b,S,a.memoizedState.cache);Jd();break;case 27:case 5:Na(b);break;case 1:Xc(b.type)&&ad(b);break;case 4:Ja(b,b.stateNode.containerInfo);break;case 10:$h(b,b.type._context,b.memoizedProps.value);break;case 13:var d=b.memoizedState;if(null!==d){if(null!==d.dehydrated)return Me(b),b.flags|=128,null;if(0!==(c&b.child.childLanes))return Ph(a,b,c);Me(b);a=wh(a,b,c);return null!==a?a.sibling:null}Me(b);break;case 19:d=0!==(c&b.childLanes);if(0!==(a.flags&128)){if(d)return Yh(a,
 b,c);b.flags|=128}var e=b.memoizedState;null!==e&&(e.rendering=null,e.tail=null,e.lastEffect=null);E(Ne,Ne.current);if(d)break;else return null;case 22:case 23:return b.lanes=0,Bh(a,b,c);case 24:$h(b,S,a.memoizedState.cache)}return wh(a,b,c)}var ai=ka(null),bi=null,ci=null,di=null;function ei(){di=ci=bi=null}function $h(a,b,c){E(ai,b._currentValue);b._currentValue=c}function fi(a){a._currentValue=ai.current;D(ai)}
 function Wh(a,b,c){for(;null!==a;){var d=a.alternate;(a.childLanes&b)!==b?(a.childLanes|=b,null!==d&&(d.childLanes|=b)):null!==d&&(d.childLanes&b)!==b&&(d.childLanes|=b);if(a===c)break;a=a.return}}
 function gi(a,b,c){var d=a.child;null!==d&&(d.return=a);for(;null!==d;){var e=d.dependencies;if(null!==e){var f=d.child;for(var g=e.firstContext;null!==g;){if(g.context===b){if(1===d.tag){g=Zd(c&-c);g.tag=2;var h=d.updateQueue;if(null!==h){h=h.shared;var l=h.pending;null===l?g.next=g:(g.next=l.next,l.next=g);h.pending=g}}d.lanes|=c;g=d.alternate;null!==g&&(g.lanes|=c);Wh(d.return,c,a);e.lanes|=c;break}g=g.next}}else if(10===d.tag)f=d.type===a.type?null:d.child;else if(18===d.tag){f=d.return;if(null===
-f)throw Error(t(341));f.lanes|=c;e=f.alternate;null!==e&&(e.lanes|=c);Wh(f,c,a);f=d.sibling}else f=d.child;if(null!==f)f.return=d;else for(f=d;null!==f;){if(f===a){f=null;break}d=f.sibling;if(null!==d){d.return=f.return;f=d;break}f=f.return}d=f}}function vh(a,b){bi=a;di=ci=null;a=a.dependencies;null!==a&&null!==a.firstContext&&(0!==(a.lanes&b)&&(eg=!0),a.firstContext=null)}function ag(a){return hi(bi,a)}function Be(a,b,c){null===bi&&vh(a,c);return hi(a,b)}
-function hi(a,b){var c=b._currentValue;if(di!==b)if(b={context:b,memoizedValue:c,next:null},null===ci){if(null===a)throw Error(t(308));ci=b;a.dependencies={lanes:0,firstContext:b}}else ci=ci.next=b;return c}
+f)throw Error(u(341));f.lanes|=c;e=f.alternate;null!==e&&(e.lanes|=c);Wh(f,c,a);f=d.sibling}else f=d.child;if(null!==f)f.return=d;else for(f=d;null!==f;){if(f===a){f=null;break}d=f.sibling;if(null!==d){d.return=f.return;f=d;break}f=f.return}d=f}}function vh(a,b){bi=a;di=ci=null;a=a.dependencies;null!==a&&null!==a.firstContext&&(0!==(a.lanes&b)&&(eg=!0),a.firstContext=null)}function ag(a){return hi(bi,a)}function Be(a,b,c){null===bi&&vh(a,c);return hi(a,b)}
+function hi(a,b){var c=b._currentValue;if(di!==b)if(b={context:b,memoizedValue:c,next:null},null===ci){if(null===a)throw Error(u(308));ci=b;a.dependencies={lanes:0,firstContext:b}}else ci=ci.next=b;return c}
 var ii="undefined"!==typeof AbortController?AbortController:function(){var a=[],b=this.signal={aborted:!1,addEventListener:function(c,d){a.push(d)}};this.abort=function(){b.aborted=!0;a.forEach(function(c){return c()})}},ji=ba.unstable_scheduleCallback,ki=ba.unstable_NormalPriority,S={$$typeof:ra,Consumer:null,Provider:null,_currentValue:null,_currentValue2:null,_threadCount:0,_defaultValue:null,_globalName:null};function Tg(){return{controller:new ii,data:new Map,refCount:0}}
 function li(a){a.refCount--;0===a.refCount&&ji(ki,function(){a.controller.abort()})}var mi=da.ReactCurrentBatchConfig,ni=ka(null);function Fh(){var a=ni.current;return null!==a?a:N.pooledCache}function Eh(a,b){null===b?E(ni,ni.current):E(ni,b.pool)}function Oh(){var a=Fh();return null===a?null:{parent:S._currentValue,pool:a}}function oi(a){a.flags|=4}function pi(a){a.flags|=2097664}
 function qi(a,b){if("stylesheet"!==b.type||0!==(b.state.loading&4))a.flags&=-16777217;else if(a.flags|=16777216,0===(M&42)&&(b="stylesheet"===b.type&&0===(b.state.loading&3)?!1:!0,!b))if(ri())a.flags|=8192;else throw ne=je,ie;}function si(a,b){null!==b?a.flags|=4:a.flags&16384&&(b=22!==a.tag?mb():536870912,a.lanes|=b)}
 function ti(a,b){if(!K)switch(a.tailMode){case "hidden":b=a.tail;for(var c=null;null!==b;)null!==b.alternate&&(c=b),b=b.sibling;null===c?a.tail=null:c.sibling=null;break;case "collapsed":c=a.tail;for(var d=null;null!==c;)null!==c.alternate&&(d=c),c=c.sibling;null===d?b||null===a.tail?a.tail=null:a.tail.sibling=null:d.sibling=null}}
 function T(a){var b=null!==a.alternate&&a.alternate.child===a.child,c=0,d=0;if(b)for(var e=a.child;null!==e;)c|=e.lanes|e.childLanes,d|=e.subtreeFlags&31457280,d|=e.flags&31457280,e.return=a,e=e.sibling;else for(e=a.child;null!==e;)c|=e.lanes|e.childLanes,d|=e.subtreeFlags,d|=e.flags,e.return=a,e=e.sibling;a.subtreeFlags|=d;a.childLanes=c;return b}
 function ui(a,b,c){var d=b.pendingProps;qd(b);switch(b.tag){case 2:case 16:case 15:case 0:case 11:case 7:case 8:case 12:case 9:case 14:return T(b),null;case 1:return Xc(b.type)&&Yc(),T(b),null;case 3:c=b.stateNode;d=null;null!==a&&(d=a.memoizedState.cache);b.memoizedState.cache!==d&&(b.flags|=2048);fi(S);Ma();D(Uc);D(Tc);c.pendingContext&&(c.context=c.pendingContext,c.pendingContext=null);if(null===a||null===a.child)Gd(b)?oi(b):null===a||a.memoizedState.isDehydrated&&0===(b.flags&256)||(b.flags|=
-1024,null!==rd&&(vi(rd),rd=null));T(b);return null;case 26:c=b.memoizedState;if(null===a)oi(b),null!==b.ref&&pi(b),null!==c?(T(b),qi(b,c)):(T(b),b.flags&=-16777217);else{var e=a.memoizedState;c!==e&&oi(b);a.ref!==b.ref&&pi(b);null!==c?(T(b),c===e?b.flags&=-16777217:qi(b,c)):(a.memoizedProps!==d&&oi(b),T(b),b.flags&=-16777217)}return null;case 27:Oa(b);c=Ga.current;e=b.type;if(null!==a&&null!=b.stateNode)a.memoizedProps!==d&&oi(b),a.ref!==b.ref&&pi(b);else{if(!d){if(null===b.stateNode)throw Error(t(166));
-T(b);return null}a=Ea.current;Gd(b)?wi(b.stateNode,b.type,b.memoizedProps,a,b):(a=xi(e,d,c),b.stateNode=a,oi(b));null!==b.ref&&pi(b)}T(b);return null;case 5:Oa(b);c=b.type;if(null!==a&&null!=b.stateNode)a.memoizedProps!==d&&oi(b),a.ref!==b.ref&&pi(b);else{if(!d){if(null===b.stateNode)throw Error(t(166));T(b);return null}a=Ea.current;if(Gd(b))wi(b.stateNode,b.type,b.memoizedProps,a,b);else{e=yi(Ga.current);switch(a){case 1:a=e.createElementNS("http://www.w3.org/2000/svg",c);break;case 2:a=e.createElementNS("http://www.w3.org/1998/Math/MathML",
+1024,null!==rd&&(vi(rd),rd=null));T(b);return null;case 26:c=b.memoizedState;if(null===a)oi(b),null!==b.ref&&pi(b),null!==c?(T(b),qi(b,c)):(T(b),b.flags&=-16777217);else{var e=a.memoizedState;c!==e&&oi(b);a.ref!==b.ref&&pi(b);null!==c?(T(b),c===e?b.flags&=-16777217:qi(b,c)):(a.memoizedProps!==d&&oi(b),T(b),b.flags&=-16777217)}return null;case 27:Oa(b);c=Ga.current;e=b.type;if(null!==a&&null!=b.stateNode)a.memoizedProps!==d&&oi(b),a.ref!==b.ref&&pi(b);else{if(!d){if(null===b.stateNode)throw Error(u(166));
+T(b);return null}a=Ea.current;Gd(b)?wi(b.stateNode,b.type,b.memoizedProps,a,b):(a=xi(e,d,c),b.stateNode=a,oi(b));null!==b.ref&&pi(b)}T(b);return null;case 5:Oa(b);c=b.type;if(null!==a&&null!=b.stateNode)a.memoizedProps!==d&&oi(b),a.ref!==b.ref&&pi(b);else{if(!d){if(null===b.stateNode)throw Error(u(166));T(b);return null}a=Ea.current;if(Gd(b))wi(b.stateNode,b.type,b.memoizedProps,a,b);else{e=yi(Ga.current);switch(a){case 1:a=e.createElementNS("http://www.w3.org/2000/svg",c);break;case 2:a=e.createElementNS("http://www.w3.org/1998/Math/MathML",
 c);break;default:switch(c){case "svg":a=e.createElementNS("http://www.w3.org/2000/svg",c);break;case "math":a=e.createElementNS("http://www.w3.org/1998/Math/MathML",c);break;case "script":a=e.createElement("div");a.innerHTML="<script>\x3c/script>";a=a.removeChild(a.firstChild);break;case "select":a="string"===typeof d.is?e.createElement("select",{is:d.is}):e.createElement("select");d.multiple?a.multiple=!0:d.size&&(a.size=d.size);break;default:a="string"===typeof d.is?e.createElement(c,{is:d.is}):
 e.createElement(c)}}a[xb]=b;a[yb]=d;a:for(e=b.child;null!==e;){if(5===e.tag||6===e.tag)a.appendChild(e.stateNode);else if(4!==e.tag&&27!==e.tag&&null!==e.child){e.child.return=e;e=e.child;continue}if(e===b)break a;for(;null===e.sibling;){if(null===e.return||e.return===b)break a;e=e.return}e.sibling.return=e.return;e=e.sibling}b.stateNode=a;a:switch(zi(a,c,d),c){case "button":case "input":case "select":case "textarea":a=!!d.autoFocus;break a;case "img":a=!0;break a;default:a=!1}a&&oi(b)}null!==b.ref&&
-pi(b)}T(b);b.flags&=-16777217;return null;case 6:if(a&&null!=b.stateNode)a.memoizedProps!==d&&oi(b);else{if("string"!==typeof d&&null===b.stateNode)throw Error(t(166));a=Ga.current;if(Gd(b)){a:{a=b.stateNode;c=b.memoizedProps;a[xb]=b;if(d=a.nodeValue!==c)if(e=G,null!==e)switch(e.tag){case 3:e=0!==(e.mode&1);Ai(a.nodeValue,c,e);if(e){a=!1;break a}break;case 27:case 5:var f=0!==(e.mode&1);!0!==e.memoizedProps.suppressHydrationWarning&&Ai(a.nodeValue,c,f);if(f){a=!1;break a}}a=d}a&&oi(b)}else a=yi(a).createTextNode(d),
-a[xb]=b,b.stateNode=a}T(b);return null;case 13:Qe(b);d=b.memoizedState;if(null===a||null!==a.memoizedState&&null!==a.memoizedState.dehydrated){if(K&&null!==J&&0!==(b.mode&1)&&0===(b.flags&128))Id(),Jd(),b.flags|=384,e=!1;else if(e=Gd(b),null!==d&&null!==d.dehydrated){if(null===a){if(!e)throw Error(t(318));e=b.memoizedState;e=null!==e?e.dehydrated:null;if(!e)throw Error(t(317));e[xb]=b}else Jd(),0===(b.flags&128)&&(b.memoizedState=null),b.flags|=4;T(b);e=!1}else null!==rd&&(vi(rd),rd=null),e=!0;if(!e)return b.flags&
+pi(b)}T(b);b.flags&=-16777217;return null;case 6:if(a&&null!=b.stateNode)a.memoizedProps!==d&&oi(b);else{if("string"!==typeof d&&null===b.stateNode)throw Error(u(166));a=Ga.current;if(Gd(b)){a:{a=b.stateNode;c=b.memoizedProps;a[xb]=b;if(d=a.nodeValue!==c)if(e=G,null!==e)switch(e.tag){case 3:e=0!==(e.mode&1);Ai(a.nodeValue,c,e);if(e){a=!1;break a}break;case 27:case 5:var f=0!==(e.mode&1);!0!==e.memoizedProps.suppressHydrationWarning&&Ai(a.nodeValue,c,f);if(f){a=!1;break a}}a=d}a&&oi(b)}else a=yi(a).createTextNode(d),
+a[xb]=b,b.stateNode=a}T(b);return null;case 13:Qe(b);d=b.memoizedState;if(null===a||null!==a.memoizedState&&null!==a.memoizedState.dehydrated){if(K&&null!==J&&0!==(b.mode&1)&&0===(b.flags&128))Id(),Jd(),b.flags|=384,e=!1;else if(e=Gd(b),null!==d&&null!==d.dehydrated){if(null===a){if(!e)throw Error(u(318));e=b.memoizedState;e=null!==e?e.dehydrated:null;if(!e)throw Error(u(317));e[xb]=b}else Jd(),0===(b.flags&128)&&(b.memoizedState=null),b.flags|=4;T(b);e=!1}else null!==rd&&(vi(rd),rd=null),e=!0;if(!e)return b.flags&
 256?b:null}if(0!==(b.flags&128))return b.lanes=c,b;c=null!==d;a=null!==a&&null!==a.memoizedState;c&&(d=b.child,e=null,null!==d.alternate&&null!==d.alternate.memoizedState&&null!==d.alternate.memoizedState.cachePool&&(e=d.alternate.memoizedState.cachePool.pool),f=null,null!==d.memoizedState&&null!==d.memoizedState.cachePool&&(f=d.memoizedState.cachePool.pool),f!==e&&(d.flags|=2048));c!==a&&c&&(b.child.flags|=8192);si(b,b.updateQueue);T(b);return null;case 4:return Ma(),null===a&&Bi(b.stateNode.containerInfo),
 T(b),null;case 10:return fi(b.type._context),T(b),null;case 17:return Xc(b.type)&&Yc(),T(b),null;case 19:D(Ne);e=b.memoizedState;if(null===e)return T(b),null;d=0!==(b.flags&128);f=e.rendering;if(null===f)if(d)ti(e,!1);else{if(0!==oh||null!==a&&0!==(a.flags&128))for(a=b.child;null!==a;){f=Re(a);if(null!==f){b.flags|=128;ti(e,!1);a=f.updateQueue;b.updateQueue=a;si(b,a);b.subtreeFlags=0;a=c;for(c=b.child;null!==c;)Ci(c,a),c=c.sibling;E(Ne,Ne.current&1|2);return b.child}a=a.sibling}null!==e.tail&&Ta()>
 Di&&(b.flags|=128,d=!0,ti(e,!1),b.lanes=4194304)}else{if(!d)if(a=Re(f),null!==a){if(b.flags|=128,d=!0,a=a.updateQueue,b.updateQueue=a,si(b,a),ti(e,!0),null===e.tail&&"hidden"===e.tailMode&&!f.alternate&&!K)return T(b),null}else 2*Ta()-e.renderingStartTime>Di&&536870912!==c&&(b.flags|=128,d=!0,ti(e,!1),b.lanes=4194304);e.isBackwards?(f.sibling=b.child,b.child=f):(a=e.last,null!==a?a.sibling=f:b.child=f,e.last=f)}if(null!==e.tail)return b=e.tail,e.rendering=b,e.tail=b.sibling,e.renderingStartTime=Ta(),
 b.sibling=null,a=Ne.current,E(Ne,d?a&1|2:a&1),b;T(b);return null;case 22:case 23:return Qe(b),Je(),d=null!==b.memoizedState,null!==a?null!==a.memoizedState!==d&&(b.flags|=8192):d&&(b.flags|=8192),d&&0!==(b.mode&1)?0!==(c&536870912)&&0===(b.flags&128)&&(T(b),b.subtreeFlags&6&&(b.flags|=8192)):T(b),c=b.updateQueue,null!==c&&si(b,c.retryQueue),c=null,null!==a&&null!==a.memoizedState&&null!==a.memoizedState.cachePool&&(c=a.memoizedState.cachePool.pool),d=null,null!==b.memoizedState&&null!==b.memoizedState.cachePool&&
-(d=b.memoizedState.cachePool.pool),d!==c&&(b.flags|=2048),null!==a&&D(ni),null;case 24:return c=null,null!==a&&(c=a.memoizedState.cache),b.memoizedState.cache!==c&&(b.flags|=2048),fi(S),T(b),null;case 25:return null}throw Error(t(156,b.tag));}
-function Ei(a,b){qd(b);switch(b.tag){case 1:return Xc(b.type)&&Yc(),a=b.flags,a&65536?(b.flags=a&-65537|128,b):null;case 3:return fi(S),Ma(),D(Uc),D(Tc),a=b.flags,0!==(a&65536)&&0===(a&128)?(b.flags=a&-65537|128,b):null;case 26:case 27:case 5:return Oa(b),null;case 13:Qe(b);a=b.memoizedState;if(null!==a&&null!==a.dehydrated){if(null===b.alternate)throw Error(t(340));Jd()}a=b.flags;return a&65536?(b.flags=a&-65537|128,b):null;case 19:return D(Ne),null;case 4:return Ma(),null;case 10:return fi(b.type._context),
+(d=b.memoizedState.cachePool.pool),d!==c&&(b.flags|=2048),null!==a&&D(ni),null;case 24:return c=null,null!==a&&(c=a.memoizedState.cache),b.memoizedState.cache!==c&&(b.flags|=2048),fi(S),T(b),null;case 25:return null}throw Error(u(156,b.tag));}
+function Ei(a,b){qd(b);switch(b.tag){case 1:return Xc(b.type)&&Yc(),a=b.flags,a&65536?(b.flags=a&-65537|128,b):null;case 3:return fi(S),Ma(),D(Uc),D(Tc),a=b.flags,0!==(a&65536)&&0===(a&128)?(b.flags=a&-65537|128,b):null;case 26:case 27:case 5:return Oa(b),null;case 13:Qe(b);a=b.memoizedState;if(null!==a&&null!==a.dehydrated){if(null===b.alternate)throw Error(u(340));Jd()}a=b.flags;return a&65536?(b.flags=a&-65537|128,b):null;case 19:return D(Ne),null;case 4:return Ma(),null;case 10:return fi(b.type._context),
 null;case 22:case 23:return Qe(b),Je(),null!==a&&D(ni),a=b.flags,a&65536?(b.flags=a&-65537|128,b):null;case 24:return fi(S),null;case 25:return null;default:return null}}
 function Fi(a,b){qd(b);switch(b.tag){case 1:a=b.type.childContextTypes;null!==a&&void 0!==a&&Yc();break;case 3:fi(S);Ma();D(Uc);D(Tc);break;case 26:case 27:case 5:Oa(b);break;case 4:Ma();break;case 13:Qe(b);break;case 19:D(Ne);break;case 10:fi(b.type._context);break;case 22:case 23:Qe(b);Je();null!==a&&D(ni);break;case 24:fi(S)}}function Gi(a,b,c){var d=Array.prototype.slice.call(arguments,3);try{b.apply(c,d)}catch(e){this.onError(e)}}
-var Hi=!1,Ii=null,Ji=!1,Ki=null,Li={onError:function(a){Hi=!0;Ii=a}};function Mi(a,b,c,d,e,f,g,h,l){Hi=!1;Ii=null;Gi.apply(Li,arguments)}function Ni(a,b,c,d,e,f,g,h,l){Mi.apply(this,arguments);if(Hi){if(Hi){var p=Ii;Hi=!1;Ii=null}else throw Error(t(198));Ji||(Ji=!0,Ki=p)}}var Oi=!1,Pi=!1,Qi="function"===typeof WeakSet?WeakSet:Set,Ri=null;
+var Hi=!1,Ii=null,Ji=!1,Ki=null,Li={onError:function(a){Hi=!0;Ii=a}};function Mi(a,b,c,d,e,f,g,h,l){Hi=!1;Ii=null;Gi.apply(Li,arguments)}function Ni(a,b,c,d,e,f,g,h,l){Mi.apply(this,arguments);if(Hi){if(Hi){var p=Ii;Hi=!1;Ii=null}else throw Error(u(198));Ji||(Ji=!0,Ki=p)}}var Oi=!1,Pi=!1,Qi="function"===typeof WeakSet?WeakSet:Set,Ri=null;
 function Si(a,b){try{var c=a.ref;if(null!==c){var d=a.stateNode;switch(a.tag){case 26:case 27:case 5:var e=d;break;default:e=d}"function"===typeof c?a.refCleanup=c(e):c.current=e}}catch(f){W(a,b,f)}}function Ti(a,b){var c=a.ref,d=a.refCleanup;if(null!==c)if("function"===typeof d)try{d()}catch(e){W(a,b,e)}finally{a.refCleanup=null,a=a.alternate,null!=a&&(a.refCleanup=null)}else if("function"===typeof c)try{c(null)}catch(e){W(a,b,e)}else c.current=null}
 function Ui(a,b,c){try{c()}catch(d){W(a,b,d)}}var Vi=!1;
-function Wi(a,b){Xi=Yi;a=Zi();if($i(a)){if("selectionStart"in a)var c={start:a.selectionStart,end:a.selectionEnd};else a:{c=(c=a.ownerDocument)&&c.defaultView||window;var d=c.getSelection&&c.getSelection();if(d&&0!==d.rangeCount){c=d.anchorNode;var e=d.anchorOffset,f=d.focusNode;d=d.focusOffset;try{c.nodeType,f.nodeType}catch(n){c=null;break a}var g=0,h=-1,l=-1,p=0,q=0,w=a,r=null;b:for(;;){for(var u;;){w!==c||0!==e&&3!==w.nodeType||(h=g+e);w!==f||0!==d&&3!==w.nodeType||(l=g+d);3===w.nodeType&&(g+=
-w.nodeValue.length);if(null===(u=w.firstChild))break;r=w;w=u}for(;;){if(w===a)break b;r===c&&++p===e&&(h=g);r===f&&++q===d&&(l=g);if(null!==(u=w.nextSibling))break;w=r;r=w.parentNode}w=u}c=-1===h||-1===l?null:{start:h,end:l}}else c=null}c=c||{start:0,end:0}}else c=null;aj={focusedElem:a,selectionRange:c};Yi=!1;for(Ri=b;null!==Ri;)if(b=Ri,a=b.child,0!==(b.subtreeFlags&1028)&&null!==a)a.return=b,Ri=a;else for(;null!==Ri;){b=Ri;try{var z=b.alternate,B=b.flags;switch(b.tag){case 0:break;case 11:case 15:break;
-case 1:if(0!==(B&1024)&&null!==z){var U=z.memoizedProps,V=z.memoizedState,m=b.stateNode,k=m.getSnapshotBeforeUpdate(b.elementType===b.type?U:Xg(b.type,U),V);m.__reactInternalSnapshotBeforeUpdate=k}break;case 3:0!==(B&1024)&&bj(b.stateNode.containerInfo);break;case 5:case 26:case 27:case 6:case 4:case 17:break;default:if(0!==(B&1024))throw Error(t(163));}}catch(n){W(b,b.return,n)}a=b.sibling;if(null!==a){a.return=b.return;Ri=a;break}Ri=b.return}z=Vi;Vi=!1;return z}
+function Wi(a,b){Xi=Yi;a=Zi();if($i(a)){if("selectionStart"in a)var c={start:a.selectionStart,end:a.selectionEnd};else a:{c=(c=a.ownerDocument)&&c.defaultView||window;var d=c.getSelection&&c.getSelection();if(d&&0!==d.rangeCount){c=d.anchorNode;var e=d.anchorOffset,f=d.focusNode;d=d.focusOffset;try{c.nodeType,f.nodeType}catch(n){c=null;break a}var g=0,h=-1,l=-1,p=0,q=0,w=a,r=null;b:for(;;){for(var t;;){w!==c||0!==e&&3!==w.nodeType||(h=g+e);w!==f||0!==d&&3!==w.nodeType||(l=g+d);3===w.nodeType&&(g+=
+w.nodeValue.length);if(null===(t=w.firstChild))break;r=w;w=t}for(;;){if(w===a)break b;r===c&&++p===e&&(h=g);r===f&&++q===d&&(l=g);if(null!==(t=w.nextSibling))break;w=r;r=w.parentNode}w=t}c=-1===h||-1===l?null:{start:h,end:l}}else c=null}c=c||{start:0,end:0}}else c=null;aj={focusedElem:a,selectionRange:c};Yi=!1;for(Ri=b;null!==Ri;)if(b=Ri,a=b.child,0!==(b.subtreeFlags&1028)&&null!==a)a.return=b,Ri=a;else for(;null!==Ri;){b=Ri;try{var z=b.alternate,B=b.flags;switch(b.tag){case 0:break;case 11:case 15:break;
+case 1:if(0!==(B&1024)&&null!==z){var U=z.memoizedProps,V=z.memoizedState,m=b.stateNode,k=m.getSnapshotBeforeUpdate(b.elementType===b.type?U:Xg(b.type,U),V);m.__reactInternalSnapshotBeforeUpdate=k}break;case 3:0!==(B&1024)&&bj(b.stateNode.containerInfo);break;case 5:case 26:case 27:case 6:case 4:case 17:break;default:if(0!==(B&1024))throw Error(u(163));}}catch(n){W(b,b.return,n)}a=b.sibling;if(null!==a){a.return=b.return;Ri=a;break}Ri=b.return}z=Vi;Vi=!1;return z}
 function cj(a,b,c){var d=b.updateQueue;d=null!==d?d.lastEffect:null;if(null!==d){var e=d=d.next;do{if((e.tag&a)===a){var f=e.inst,g=f.destroy;void 0!==g&&(f.destroy=void 0,Ui(b,c,g))}e=e.next}while(e!==d)}}function dj(a,b){b=b.updateQueue;b=null!==b?b.lastEffect:null;if(null!==b){var c=b=b.next;do{if((c.tag&a)===a){var d=c.create,e=c.inst;d=d();e.destroy=d}c=c.next}while(c!==b)}}function ej(a,b){try{dj(b,a)}catch(c){W(a,a.return,c)}}
 function fj(a){var b=a.updateQueue;if(null!==b){var c=a.stateNode;try{fe(b,c)}catch(d){W(a,a.return,d)}}}function gj(a){var b=a.type,c=a.memoizedProps,d=a.stateNode;try{a:switch(b){case "button":case "input":case "select":case "textarea":c.autoFocus&&d.focus();break a;case "img":c.src&&(d.src=c.src)}}catch(e){W(a,a.return,e)}}
 function hj(a,b,c){var d=c.flags;switch(c.tag){case 0:case 11:case 15:ij(a,c);d&4&&ej(c,5);break;case 1:ij(a,c);if(d&4)if(a=c.stateNode,null===b)try{a.componentDidMount()}catch(h){W(c,c.return,h)}else{var e=c.elementType===c.type?b.memoizedProps:Xg(c.type,b.memoizedProps);b=b.memoizedState;try{a.componentDidUpdate(e,b,a.__reactInternalSnapshotBeforeUpdate)}catch(h){W(c,c.return,h)}}d&64&&fj(c);d&512&&Si(c,c.return);break;case 3:ij(a,c);if(d&64&&(d=c.updateQueue,null!==d)){a=null;if(null!==c.child)switch(c.child.tag){case 27:case 5:a=
@@ -219,20 +218,20 @@ function qj(a,b,c){var d=a.tag;if(5===d||6===d)a=a.stateNode,b?c.insertBefore(a,
 function uj(a,b,c){if(ab&&"function"===typeof ab.onCommitFiberUnmount)try{ab.onCommitFiberUnmount($a,c)}catch(l){}switch(c.tag){case 26:Pi||Ti(c,b);tj(a,b,c);c.memoizedState?c.memoizedState.count--:c.stateNode&&(c=c.stateNode,c.parentNode.removeChild(c));break;case 27:Pi||Ti(c,b);var d=rj,e=sj;rj=c.stateNode;tj(a,b,c);c=c.stateNode;for(a=c.attributes;a.length;)c.removeAttributeNode(a[0]);Gb(c);rj=d;sj=e;break;case 5:Pi||Ti(c,b);case 6:d=rj;e=sj;rj=null;tj(a,b,c);rj=d;sj=e;null!==rj&&(sj?(a=rj,c=c.stateNode,
 8===a.nodeType?a.parentNode.removeChild(c):a.removeChild(c)):rj.removeChild(c.stateNode));break;case 18:null!==rj&&(sj?(a=rj,c=c.stateNode,8===a.nodeType?vj(a.parentNode,c):1===a.nodeType&&vj(a,c),wj(a)):vj(rj,c.stateNode));break;case 4:d=rj;e=sj;rj=c.stateNode.containerInfo;sj=!0;tj(a,b,c);rj=d;sj=e;break;case 0:case 11:case 14:case 15:if(!Pi&&(d=c.updateQueue,null!==d&&(d=d.lastEffect,null!==d))){e=d=d.next;do{var f=e.tag,g=e.inst,h=g.destroy;void 0!==h&&(0!==(f&2)?(g.destroy=void 0,Ui(c,b,h)):
 0!==(f&4)&&(g.destroy=void 0,Ui(c,b,h)));e=e.next}while(e!==d)}tj(a,b,c);break;case 1:if(!Pi&&(Ti(c,b),d=c.stateNode,"function"===typeof d.componentWillUnmount))try{d.props=c.memoizedProps,d.state=c.memoizedState,d.componentWillUnmount()}catch(l){W(c,b,l)}tj(a,b,c);break;case 21:tj(a,b,c);break;case 22:Ti(c,b);c.mode&1?(Pi=(d=Pi)||null!==c.memoizedState,tj(a,b,c),Pi=d):tj(a,b,c);break;default:tj(a,b,c)}}
-function jj(a,b){if(null===b.memoizedState&&(a=b.alternate,null!==a&&(a=a.memoizedState,null!==a&&(a=a.dehydrated,null!==a))))try{wj(a)}catch(c){W(b,b.return,c)}}function xj(a){switch(a.tag){case 13:case 19:var b=a.stateNode;null===b&&(b=a.stateNode=new Qi);return b;case 22:return a=a.stateNode,b=a._retryCache,null===b&&(b=a._retryCache=new Qi),b;default:throw Error(t(435,a.tag));}}function yj(a,b){var c=xj(a);b.forEach(function(d){var e=zj.bind(null,a,d);c.has(d)||(c.add(d),d.then(e,e))})}
-function Aj(a,b){var c=b.deletions;if(null!==c)for(var d=0;d<c.length;d++){var e=c[d];try{var f=a,g=b,h=g;a:for(;null!==h;){switch(h.tag){case 27:case 5:rj=h.stateNode;sj=!1;break a;case 3:rj=h.stateNode.containerInfo;sj=!0;break a;case 4:rj=h.stateNode.containerInfo;sj=!0;break a}h=h.return}if(null===rj)throw Error(t(160));uj(f,g,e);rj=null;sj=!1;var l=e.alternate;null!==l&&(l.return=null);e.return=null}catch(p){W(e,b,p)}}if(b.subtreeFlags&12854)for(b=b.child;null!==b;)Bj(b,a),b=b.sibling}
+function jj(a,b){if(null===b.memoizedState&&(a=b.alternate,null!==a&&(a=a.memoizedState,null!==a&&(a=a.dehydrated,null!==a))))try{wj(a)}catch(c){W(b,b.return,c)}}function xj(a){switch(a.tag){case 13:case 19:var b=a.stateNode;null===b&&(b=a.stateNode=new Qi);return b;case 22:return a=a.stateNode,b=a._retryCache,null===b&&(b=a._retryCache=new Qi),b;default:throw Error(u(435,a.tag));}}function yj(a,b){var c=xj(a);b.forEach(function(d){var e=zj.bind(null,a,d);c.has(d)||(c.add(d),d.then(e,e))})}
+function Aj(a,b){var c=b.deletions;if(null!==c)for(var d=0;d<c.length;d++){var e=c[d];try{var f=a,g=b,h=g;a:for(;null!==h;){switch(h.tag){case 27:case 5:rj=h.stateNode;sj=!1;break a;case 3:rj=h.stateNode.containerInfo;sj=!0;break a;case 4:rj=h.stateNode.containerInfo;sj=!0;break a}h=h.return}if(null===rj)throw Error(u(160));uj(f,g,e);rj=null;sj=!1;var l=e.alternate;null!==l&&(l.return=null);e.return=null}catch(p){W(e,b,p)}}if(b.subtreeFlags&12854)for(b=b.child;null!==b;)Bj(b,a),b=b.sibling}
 var Cj=null;
-function Bj(a,b){var c=a.alternate,d=a.flags;switch(a.tag){case 0:case 11:case 14:case 15:Aj(b,a);Dj(a);if(d&4){try{cj(3,a,a.return),dj(3,a)}catch(u){W(a,a.return,u)}try{cj(5,a,a.return)}catch(u){W(a,a.return,u)}}break;case 1:Aj(b,a);Dj(a);d&512&&null!==c&&Ti(c,c.return);d&64&&Oi&&(a=a.updateQueue,null!==a&&(c=a.callbacks,null!==c&&(d=a.shared.hiddenCallbacks,a.shared.hiddenCallbacks=null===d?c:d.concat(c))));break;case 26:var e=Cj;Aj(b,a);Dj(a);d&512&&null!==c&&Ti(c,c.return);if(d&4)if(b=null!==
+function Bj(a,b){var c=a.alternate,d=a.flags;switch(a.tag){case 0:case 11:case 14:case 15:Aj(b,a);Dj(a);if(d&4){try{cj(3,a,a.return),dj(3,a)}catch(t){W(a,a.return,t)}try{cj(5,a,a.return)}catch(t){W(a,a.return,t)}}break;case 1:Aj(b,a);Dj(a);d&512&&null!==c&&Ti(c,c.return);d&64&&Oi&&(a=a.updateQueue,null!==a&&(c=a.callbacks,null!==c&&(d=a.shared.hiddenCallbacks,a.shared.hiddenCallbacks=null===d?c:d.concat(c))));break;case 26:var e=Cj;Aj(b,a);Dj(a);d&512&&null!==c&&Ti(c,c.return);if(d&4)if(b=null!==
 c?c.memoizedState:null,d=a.memoizedState,null===c)if(null===d)if(null===a.stateNode){a:{c=a.type;d=a.memoizedProps;b=e.ownerDocument||e;b:switch(c){case "title":e=b.getElementsByTagName("title")[0];if(!e||e[Fb]||e[xb]||"http://www.w3.org/2000/svg"===e.namespaceURI||e.hasAttribute("itemprop"))e=b.createElement(c),b.head.insertBefore(e,b.querySelector("head > title"));zi(e,c,d);e[xb]=a;Nb(e);c=e;break a;case "link":var f=Ej("link","href",b).get(c+(d.href||""));if(f)for(var g=0;g<f.length;g++)if(e=f[g],
 e.getAttribute("href")===(null==d.href?null:d.href)&&e.getAttribute("rel")===(null==d.rel?null:d.rel)&&e.getAttribute("title")===(null==d.title?null:d.title)&&e.getAttribute("crossorigin")===(null==d.crossOrigin?null:d.crossOrigin)){f.splice(g,1);break b}e=b.createElement(c);zi(e,c,d);b.head.appendChild(e);break;case "meta":if(f=Ej("meta","content",b).get(c+(d.content||"")))for(g=0;g<f.length;g++)if(e=f[g],e.getAttribute("content")===(null==d.content?null:""+d.content)&&e.getAttribute("name")===(null==
-d.name?null:d.name)&&e.getAttribute("property")===(null==d.property?null:d.property)&&e.getAttribute("http-equiv")===(null==d.httpEquiv?null:d.httpEquiv)&&e.getAttribute("charset")===(null==d.charSet?null:d.charSet)){f.splice(g,1);break b}e=b.createElement(c);zi(e,c,d);b.head.appendChild(e);break;default:throw Error(t(468,c));}e[xb]=a;Nb(e);c=e}a.stateNode=c}else Fj(e,a.type,a.stateNode);else a.stateNode=Gj(e,d,a.memoizedProps);else if(b!==d)null===b?null!==c.stateNode&&(c=c.stateNode,c.parentNode.removeChild(c)):
-b.count--,null===d?Fj(e,a.type,a.stateNode):Gj(e,d,a.memoizedProps);else if(null===d&&null!==a.stateNode){a.updateQueue=null;try{var h=a.stateNode,l=a.memoizedProps;Hj(h,a.type,c.memoizedProps,l);h[yb]=l}catch(u){W(a,a.return,u)}}break;case 27:if(d&4&&null===a.alternate){e=a.stateNode;f=a.memoizedProps;for(g=e.firstChild;g;){var p=g.nextSibling,q=g.nodeName;g[Fb]||"HEAD"===q||"BODY"===q||"SCRIPT"===q||"STYLE"===q||"LINK"===q&&"stylesheet"===g.rel.toLowerCase()||e.removeChild(g);g=p}g=a.type;for(p=
-e.attributes;p.length;)e.removeAttributeNode(p[0]);zi(e,g,f);e[xb]=a;e[yb]=f}case 5:Aj(b,a);Dj(a);d&512&&null!==c&&Ti(c,c.return);if(a.flags&32){b=a.stateNode;try{zc(b,"")}catch(u){W(a,a.return,u)}}if(d&4&&(d=a.stateNode,null!=d)){b=a.memoizedProps;c=null!==c?c.memoizedProps:b;e=a.type;a.updateQueue=null;try{Hj(d,e,c,b),d[yb]=b}catch(u){W(a,a.return,u)}}break;case 6:Aj(b,a);Dj(a);if(d&4){if(null===a.stateNode)throw Error(t(162));c=a.stateNode;d=a.memoizedProps;try{c.nodeValue=d}catch(u){W(a,a.return,
-u)}}break;case 3:Ij=null;e=Cj;Cj=Jj(b.containerInfo);Aj(b,a);Cj=e;Dj(a);if(d&4&&null!==c&&c.memoizedState.isDehydrated)try{wj(b.containerInfo)}catch(u){W(a,a.return,u)}break;case 4:c=Cj;Cj=Jj(a.stateNode.containerInfo);Aj(b,a);Dj(a);Cj=c;break;case 13:Aj(b,a);Dj(a);a.child.flags&8192&&null!==a.memoizedState!==(null!==c&&null!==c.memoizedState)&&(Kj=Ta());d&4&&(c=a.updateQueue,null!==c&&(a.updateQueue=null,yj(a,c)));break;case 22:d&512&&null!==c&&Ti(c,c.return);h=null!==a.memoizedState;l=null!==c&&
+d.name?null:d.name)&&e.getAttribute("property")===(null==d.property?null:d.property)&&e.getAttribute("http-equiv")===(null==d.httpEquiv?null:d.httpEquiv)&&e.getAttribute("charset")===(null==d.charSet?null:d.charSet)){f.splice(g,1);break b}e=b.createElement(c);zi(e,c,d);b.head.appendChild(e);break;default:throw Error(u(468,c));}e[xb]=a;Nb(e);c=e}a.stateNode=c}else Fj(e,a.type,a.stateNode);else a.stateNode=Gj(e,d,a.memoizedProps);else if(b!==d)null===b?null!==c.stateNode&&(c=c.stateNode,c.parentNode.removeChild(c)):
+b.count--,null===d?Fj(e,a.type,a.stateNode):Gj(e,d,a.memoizedProps);else if(null===d&&null!==a.stateNode){a.updateQueue=null;try{var h=a.stateNode,l=a.memoizedProps;Hj(h,a.type,c.memoizedProps,l);h[yb]=l}catch(t){W(a,a.return,t)}}break;case 27:if(d&4&&null===a.alternate){e=a.stateNode;f=a.memoizedProps;for(g=e.firstChild;g;){var p=g.nextSibling,q=g.nodeName;g[Fb]||"HEAD"===q||"BODY"===q||"SCRIPT"===q||"STYLE"===q||"LINK"===q&&"stylesheet"===g.rel.toLowerCase()||e.removeChild(g);g=p}g=a.type;for(p=
+e.attributes;p.length;)e.removeAttributeNode(p[0]);zi(e,g,f);e[xb]=a;e[yb]=f}case 5:Aj(b,a);Dj(a);d&512&&null!==c&&Ti(c,c.return);if(a.flags&32){b=a.stateNode;try{zc(b,"")}catch(t){W(a,a.return,t)}}if(d&4&&(d=a.stateNode,null!=d)){b=a.memoizedProps;c=null!==c?c.memoizedProps:b;e=a.type;a.updateQueue=null;try{Hj(d,e,c,b),d[yb]=b}catch(t){W(a,a.return,t)}}break;case 6:Aj(b,a);Dj(a);if(d&4){if(null===a.stateNode)throw Error(u(162));c=a.stateNode;d=a.memoizedProps;try{c.nodeValue=d}catch(t){W(a,a.return,
+t)}}break;case 3:Ij=null;e=Cj;Cj=Jj(b.containerInfo);Aj(b,a);Cj=e;Dj(a);if(d&4&&null!==c&&c.memoizedState.isDehydrated)try{wj(b.containerInfo)}catch(t){W(a,a.return,t)}break;case 4:c=Cj;Cj=Jj(a.stateNode.containerInfo);Aj(b,a);Dj(a);Cj=c;break;case 13:Aj(b,a);Dj(a);a.child.flags&8192&&null!==a.memoizedState!==(null!==c&&null!==c.memoizedState)&&(Kj=Ta());d&4&&(c=a.updateQueue,null!==c&&(a.updateQueue=null,yj(a,c)));break;case 22:d&512&&null!==c&&Ti(c,c.return);h=null!==a.memoizedState;l=null!==c&&
 null!==c.memoizedState;if(a.mode&1){var w=Oi,r=Pi;Oi=w||h;Pi=r||l;Aj(b,a);Pi=r;Oi=w}else Aj(b,a);Dj(a);b=a.stateNode;b._current=a;b._visibility&=-3;b._visibility|=b._pendingVisibility&2;if(d&8192&&(b._visibility=h?b._visibility&-2:b._visibility|1,h&&(b=Oi||Pi,null===c||l||b||0!==(a.mode&1)&&Lj(a)),null===a.memoizedProps||"manual"!==a.memoizedProps.mode))a:for(c=null,b=a;;){if(5===b.tag||26===b.tag||27===b.tag){if(null===c){c=b;try{e=b.stateNode,h?(f=e.style,"function"===typeof f.setProperty?f.setProperty("display",
-"none","important"):f.display="none"):(g=b.stateNode,p=b.memoizedProps.style,q=void 0!==p&&null!==p&&p.hasOwnProperty("display")?p.display:null,g.style.display=null==q||"boolean"===typeof q?"":(""+q).trim())}catch(u){W(a,a.return,u)}}}else if(6===b.tag){if(null===c)try{b.stateNode.nodeValue=h?"":b.memoizedProps}catch(u){W(a,a.return,u)}}else if((22!==b.tag&&23!==b.tag||null===b.memoizedState||b===a)&&null!==b.child){b.child.return=b;b=b.child;continue}if(b===a)break a;for(;null===b.sibling;){if(null===
+"none","important"):f.display="none"):(g=b.stateNode,p=b.memoizedProps.style,q=void 0!==p&&null!==p&&p.hasOwnProperty("display")?p.display:null,g.style.display=null==q||"boolean"===typeof q?"":(""+q).trim())}catch(t){W(a,a.return,t)}}}else if(6===b.tag){if(null===c)try{b.stateNode.nodeValue=h?"":b.memoizedProps}catch(t){W(a,a.return,t)}}else if((22!==b.tag&&23!==b.tag||null===b.memoizedState||b===a)&&null!==b.child){b.child.return=b;b=b.child;continue}if(b===a)break a;for(;null===b.sibling;){if(null===
 b.return||b.return===a)break a;c===b&&(c=null);b=b.return}c===b&&(c=null);b.sibling.return=b.return;b=b.sibling}d&4&&(c=a.updateQueue,null!==c&&(d=c.retryQueue,null!==d&&(c.retryQueue=null,yj(a,d))));break;case 19:Aj(b,a);Dj(a);d&4&&(c=a.updateQueue,null!==c&&(a.updateQueue=null,yj(a,c)));break;case 21:break;default:Aj(b,a),Dj(a)}}
-function Dj(a){var b=a.flags;if(b&2){try{if(27!==a.tag){b:{for(var c=a.return;null!==c;){if(mj(c)){var d=c;break b}c=c.return}throw Error(t(160));}switch(d.tag){case 27:var e=d.stateNode,f=nj(a);qj(a,f,e);break;case 5:var g=d.stateNode;d.flags&32&&(zc(g,""),d.flags&=-33);var h=nj(a);qj(a,h,g);break;case 3:case 4:var l=d.stateNode.containerInfo,p=nj(a);oj(a,p,l);break;default:throw Error(t(161));}}}catch(q){W(a,a.return,q)}a.flags&=-3}b&4096&&(a.flags&=-4097)}
+function Dj(a){var b=a.flags;if(b&2){try{if(27!==a.tag){b:{for(var c=a.return;null!==c;){if(mj(c)){var d=c;break b}c=c.return}throw Error(u(160));}switch(d.tag){case 27:var e=d.stateNode,f=nj(a);qj(a,f,e);break;case 5:var g=d.stateNode;d.flags&32&&(zc(g,""),d.flags&=-33);var h=nj(a);qj(a,h,g);break;case 3:case 4:var l=d.stateNode.containerInfo,p=nj(a);oj(a,p,l);break;default:throw Error(u(161));}}}catch(q){W(a,a.return,q)}a.flags&=-3}b&4096&&(a.flags&=-4097)}
 function ij(a,b){if(b.subtreeFlags&8772)for(b=b.child;null!==b;)hj(a,b.alternate,b),b=b.sibling}
 function Lj(a){for(a=a.child;null!==a;){var b=a;switch(b.tag){case 0:case 11:case 14:case 15:cj(4,b,b.return);Lj(b);break;case 1:Ti(b,b.return);var c=b.stateNode;if("function"===typeof c.componentWillUnmount){var d=b,e=b.return;try{var f=d;c.props=f.memoizedProps;c.state=f.memoizedState;c.componentWillUnmount()}catch(g){W(d,e,g)}}Lj(b);break;case 26:case 27:case 5:Ti(b,b.return);Lj(b);break;case 22:Ti(b,b.return);null===b.memoizedState&&Lj(b);break;default:Lj(b)}a=a.sibling}}
 function kj(a,b,c){c=c&&0!==(b.subtreeFlags&8772);for(b=b.child;null!==b;){var d=b.alternate,e=a,f=b,g=f.flags;switch(f.tag){case 0:case 11:case 15:kj(e,f,c);ej(f,4);break;case 1:kj(e,f,c);e=f.stateNode;if("function"===typeof e.componentDidMount)try{e.componentDidMount()}catch(l){W(f,f.return,l)}d=f.updateQueue;if(null!==d){var h=d.shared.hiddenCallbacks;if(null!==h)for(d.shared.hiddenCallbacks=null,d=0;d<h.length;d++)ee(h[d],e)}c&&g&64&&fj(f);Si(f,f.return);break;case 26:case 27:case 5:kj(e,f,c);
@@ -249,37 +248,37 @@ function bk(a){var b=a.deletions;if(0!==(a.flags&16)){if(null!==b)for(var c=0;c<
 function Zj(a,b){for(;null!==Ri;){var c=Ri;switch(c.tag){case 0:case 11:case 15:cj(8,c,b);break;case 23:case 22:if(null!==c.memoizedState&&null!==c.memoizedState.cachePool){var d=c.memoizedState.cachePool.pool;null!=d&&d.refCount++}break;case 24:li(c.memoizedState.cache)}d=c.child;if(null!==d)d.return=c,Ri=d;else a:for(c=a;null!==Ri;){d=Ri;var e=d.sibling,f=d.return;lj(d);if(d===c){Ri=null;break a}if(null!==e){e.return=f;Ri=e;break a}Ri=f}}}
 var ck={getCacheSignal:function(){return ag(S).controller.signal},getCacheForType:function(a){var b=ag(S),c=b.data.get(a);void 0===c&&(c=a(),b.data.set(a,c));return c}},dk="function"===typeof WeakMap?WeakMap:Map,ek=da.ReactCurrentDispatcher,fk=da.ReactCurrentCache,gk=da.ReactCurrentOwner,hk=da.ReactCurrentBatchConfig,L=0,N=null,X=null,M=0,O=0,ik=null,jk=!1,He=0,oh=0,ef=null,de=0,kk=0,lk=0,lf=0,qh=null,jf=null,Kj=0,Di=Infinity,kf=null,hh=!1,ih=null,kh=null,mk=!1,nk=null,ok=0,pk=0,qk=null,Ud=0,Vd=null;
 function Sg(a){if(0===(a.mode&1))return 2;if(0!==(L&2)&&0!==M)return M&-M;if(null!==mi.transition)return a=uf,0!==a?a:rf();a=F;if(0!==a)return a;a=window.event;a=void 0===a?32:rk(a.type);return a}function og(a,b,c){if(a===N&&2===O||null!==a.cancelPendingCommit)ff(a,0),gf(a,M,lf);ob(a,c);if(0===(L&2)||a!==N)a===N&&(0===(L&2)&&(kk|=c),4===oh&&gf(a,M,lf)),Ye(a),2===c&&0===L&&0===(b.mode&1)&&(Di=Ta()+500,af(!0))}
-function pf(a,b){if(0!==(L&6))throw Error(t(327));var c=a.callbackNode;if(bf()&&a.callbackNode!==c)return null;var d=jb(a,a===N?M:0);if(0===d)return null;var e=0===(d&60)&&0===(d&a.expiredLanes)&&!b;b=e?sk(a,d):cf(a,d);if(0!==b){var f=e;do{if(6===b)gf(a,d,0);else{e=a.current.alternate;if(f&&!tk(e)){b=cf(a,d);f=!1;continue}if(2===b){f=d;var g=lb(a,f);0!==g&&(d=g,b=df(a,f,g))}if(1===b)throw c=ef,ff(a,0),gf(a,d,0),Ye(a),c;a.finishedWork=e;a.finishedLanes=d;a:{f=a;switch(b){case 0:case 1:throw Error(t(345));
-case 4:if((d&4194176)===d){gf(f,d,lf);break a}break;case 2:case 3:case 5:break;default:throw Error(t(329));}if((d&62914560)===d&&(b=Kj+300-Ta(),10<b)){gf(f,d,lf);if(0!==jb(f,0))break a;f.timeoutHandle=uk(vk.bind(null,f,e,jf,kf,d,lf),b);break a}vk(f,e,jf,kf,d,lf)}}break}while(1)}Ye(a);of(a,Ta());a=a.callbackNode===c?pf.bind(null,a):null;return a}
+function pf(a,b){if(0!==(L&6))throw Error(u(327));var c=a.callbackNode;if(bf()&&a.callbackNode!==c)return null;var d=jb(a,a===N?M:0);if(0===d)return null;var e=0===(d&60)&&0===(d&a.expiredLanes)&&!b;b=e?sk(a,d):cf(a,d);if(0!==b){var f=e;do{if(6===b)gf(a,d,0);else{e=a.current.alternate;if(f&&!tk(e)){b=cf(a,d);f=!1;continue}if(2===b){f=d;var g=lb(a,f);0!==g&&(d=g,b=df(a,f,g))}if(1===b)throw c=ef,ff(a,0),gf(a,d,0),Ye(a),c;a.finishedWork=e;a.finishedLanes=d;a:{f=a;switch(b){case 0:case 1:throw Error(u(345));
+case 4:if((d&4194176)===d){gf(f,d,lf);break a}break;case 2:case 3:case 5:break;default:throw Error(u(329));}if((d&62914560)===d&&(b=Kj+300-Ta(),10<b)){gf(f,d,lf);if(0!==jb(f,0))break a;f.timeoutHandle=uk(vk.bind(null,f,e,jf,kf,d,lf),b);break a}vk(f,e,jf,kf,d,lf)}}break}while(1)}Ye(a);of(a,Ta());a=a.callbackNode===c?pf.bind(null,a):null;return a}
 function df(a,b,c){var d=qh,e=a.current.memoizedState.isDehydrated;e&&(ff(a,c).flags|=256);c=cf(a,c);if(2!==c){if(jk&&!e)return a.errorRecoveryDisabledLanes|=b,kk|=b,4;a=jf;jf=d;null!==a&&vi(a)}return c}function vi(a){null===jf?jf=a:jf.push.apply(jf,a)}function vk(a,b,c,d,e,f){if(0===(e&42)&&(wk={stylesheets:null,count:0,unsuspend:xk},Vj(b),b=yk(),null!==b)){a.cancelPendingCommit=b(hf.bind(null,a,c,d));gf(a,e,f);return}hf(a,c,d,f)}
 function tk(a){for(var b=a;;){if(b.flags&16384){var c=b.updateQueue;if(null!==c&&(c=c.stores,null!==c))for(var d=0;d<c.length;d++){var e=c[d],f=e.getSnapshot;e=e.value;try{if(!dd(f(),e))return!1}catch(g){return!1}}}c=b.child;if(b.subtreeFlags&16384&&null!==c)c.return=b,b=c;else{if(b===a)break;for(;null===b.sibling;){if(null===b.return||b.return===a)return!0;b=b.return}b.sibling.return=b.return;b=b.sibling}}return!0}
 function gf(a,b,c){b&=~lk;b&=~kk;a.suspendedLanes|=b;a.pingedLanes&=~b;for(var d=a.expirationTimes,e=b;0<e;){var f=31-db(e),g=1<<f;d[f]=-1;e&=~g}0!==c&&qb(a,c,b)}function zk(a,b){var c=L;L|=1;try{return a(b)}finally{L=c,0===L&&(Di=Ta()+500,af(!0))}}function Ak(a){null!==nk&&0===nk.tag&&0===(L&6)&&bf();var b=L;L|=1;var c=hk.transition,d=F;try{if(hk.transition=null,F=2,a)return a()}finally{F=d,hk.transition=c,L=b,0===(L&6)&&af(!1)}}
 function Bk(){if(null!==X){if(0===O)var a=X.return;else a=X,ei(),Wf(a),pe=null,qe=0,a=X;for(;null!==a;)Fi(a.alternate,a),a=a.return;X=null}}
 function ff(a,b){a.finishedWork=null;a.finishedLanes=0;var c=a.timeoutHandle;-1!==c&&(a.timeoutHandle=-1,Ck(c));c=a.cancelPendingCommit;null!==c&&(a.cancelPendingCommit=null,c());Bk();N=a;X=c=we(a.current,null);M=b;O=0;ik=null;jk=!1;oh=0;ef=null;lf=lk=kk=de=0;jf=qh=null;0!==(b&8)&&(b|=b&32);var d=a.entangledLanes;if(0!==d)for(a=a.entanglements,d&=b;0<d;){var e=31-db(d),f=1<<e;b|=a[e];d&=~f}He=b;Od();return c}
 function Dk(a,b){P=null;zf.current=Qf;gk.current=null;b===he?(b=oe(),O=ri()&&0===(de&134217727)&&0===(kk&134217727)?2:3):b===ie?(b=oe(),O=4):O=b===sh?8:null!==b&&"object"===typeof b&&"function"===typeof b.then?6:1;ik=b;null===X&&(oh=1,ef=b)}function ri(){var a=Ke.current;return null===a?!0:(M&4194176)===M?null===Le?!0:!1:(M&62914560)===M||0!==(M&536870912)?a===Le:!1}function Ek(){var a=ek.current;ek.current=Qf;return null===a?Qf:a}function Fk(){var a=fk.current;fk.current=ck;return a}
-function nh(){oh=4;0===(de&134217727)&&0===(kk&134217727)||null===N||gf(N,M,lf)}function cf(a,b){var c=L;L|=2;var d=Ek(),e=Fk();if(N!==a||M!==b)kf=null,ff(a,b);b=!1;a:do try{if(0!==O&&null!==X){var f=X,g=ik;switch(O){case 8:Bk();oh=6;break a;case 3:case 2:b||null!==Ke.current||(b=!0);default:O=0,ik=null,Gk(f,g)}}Hk();break}catch(h){Dk(a,h)}while(1);b&&a.shellSuspendCounter++;ei();L=c;ek.current=d;fk.current=e;if(null!==X)throw Error(t(261));N=null;M=0;Od();return oh}
+function nh(){oh=4;0===(de&134217727)&&0===(kk&134217727)||null===N||gf(N,M,lf)}function cf(a,b){var c=L;L|=2;var d=Ek(),e=Fk();if(N!==a||M!==b)kf=null,ff(a,b);b=!1;a:do try{if(0!==O&&null!==X){var f=X,g=ik;switch(O){case 8:Bk();oh=6;break a;case 3:case 2:b||null!==Ke.current||(b=!0);default:O=0,ik=null,Gk(f,g)}}Hk();break}catch(h){Dk(a,h)}while(1);b&&a.shellSuspendCounter++;ei();L=c;ek.current=d;fk.current=e;if(null!==X)throw Error(u(261));N=null;M=0;Od();return oh}
 function Hk(){for(;null!==X;)Ik(X)}
 function sk(a,b){var c=L;L|=2;var d=Ek(),e=Fk();if(N!==a||M!==b)kf=null,Di=Ta()+500,ff(a,b);a:do try{if(0!==O&&null!==X){b=X;var f=ik;b:switch(O){case 1:O=0;ik=null;Gk(b,f);break;case 2:if(ke(f)){O=0;ik=null;Jk(b);break}b=function(){2===O&&N===a&&(O=7);Ye(a)};f.then(b,b);break a;case 3:O=7;break a;case 4:O=5;break a;case 7:ke(f)?(O=0,ik=null,Jk(b)):(O=0,ik=null,Gk(b,f));break;case 5:switch(X.tag){case 5:case 26:case 27:b=X;O=0;ik=null;var g=b.sibling;if(null!==g)X=g;else{var h=b.return;null!==h?(X=
-h,Kk(h)):X=null}break b}O=0;ik=null;Gk(b,f);break;case 6:O=0;ik=null;Gk(b,f);break;case 8:Bk();oh=6;break a;default:throw Error(t(462));}}Lk();break}catch(l){Dk(a,l)}while(1);ei();ek.current=d;fk.current=e;L=c;if(null!==X)return 0;N=null;M=0;Od();return oh}function Lk(){for(;null!==X&&!Ra();)Ik(X)}function Ik(a){var b=Mk(a.alternate,a,He);a.memoizedProps=a.pendingProps;null===b?Kk(a):X=b;gk.current=null}
+h,Kk(h)):X=null}break b}O=0;ik=null;Gk(b,f);break;case 6:O=0;ik=null;Gk(b,f);break;case 8:Bk();oh=6;break a;default:throw Error(u(462));}}Lk();break}catch(l){Dk(a,l)}while(1);ei();ek.current=d;fk.current=e;L=c;if(null!==X)return 0;N=null;M=0;Od();return oh}function Lk(){for(;null!==X&&!Ra();)Ik(X)}function Ik(a){var b=Mk(a.alternate,a,He);a.memoizedProps=a.pendingProps;null===b?Kk(a):X=b;gk.current=null}
 function Jk(a){var b=a.alternate;switch(a.tag){case 2:a.tag=0;case 15:case 0:var c=a.type,d=a.pendingProps;d=a.elementType===c?d:Xg(c,d);var e=Xc(c)?Vc:Tc.current;e=Wc(a,e);b=Gh(b,a,d,c,e,M);break;case 11:c=a.type.render;d=a.pendingProps;d=a.elementType===c?d:Xg(c,d);b=Gh(b,a,d,c,a.ref,M);break;case 5:Wf(a);default:Fi(b,a),a=X=Ci(a,He),b=Mk(b,a,He)}a.memoizedProps=a.pendingProps;null===b?Kk(a):X=b;gk.current=null}
 function Gk(a,b){ei();Wf(a);pe=null;qe=0;var c=a.return;if(null===c||null===N)oh=1,ef=b,X=null;else{try{mh(N,c,a,b,M)}catch(d){throw X=c,d;}if(a.flags&32768)a:{do{b=Ei(a.alternate,a);if(null!==b){b.flags&=32767;X=b;break a}a=a.return;null!==a&&(a.flags|=32768,a.subtreeFlags=0,a.deletions=null);X=a}while(null!==a);oh=6;X=null}else Kk(a)}}function Kk(a){var b=a;do{a=b.return;var c=ui(b.alternate,b,He);if(null!==c){X=c;return}b=b.sibling;if(null!==b){X=b;return}X=b=a}while(null!==b);0===oh&&(oh=5)}
 function hf(a,b,c,d){var e=F,f=hk.transition;try{hk.transition=null,F=2,Nk(a,b,c,e,d)}finally{hk.transition=f,F=e}return null}
-function Nk(a,b,c,d,e){do bf();while(null!==nk);if(0!==(L&6))throw Error(t(327));var f=a.finishedWork,g=a.finishedLanes;if(null===f)return null;a.finishedWork=null;a.finishedLanes=0;if(f===a.current)throw Error(t(177));a.callbackNode=null;a.callbackPriority=0;a.cancelPendingCommit=null;var h=f.lanes|f.childLanes;h|=Nd;pb(a,h,e);a===N&&(X=N=null,M=0);0===(f.subtreeFlags&10256)&&0===(f.flags&10256)||mk||(mk=!0,pk=h,qk=c,Ok(Xa,function(){bf();return null}));c=0!==(f.flags&15990);if(0!==(f.subtreeFlags&
+function Nk(a,b,c,d,e){do bf();while(null!==nk);if(0!==(L&6))throw Error(u(327));var f=a.finishedWork,g=a.finishedLanes;if(null===f)return null;a.finishedWork=null;a.finishedLanes=0;if(f===a.current)throw Error(u(177));a.callbackNode=null;a.callbackPriority=0;a.cancelPendingCommit=null;var h=f.lanes|f.childLanes;h|=Nd;pb(a,h,e);a===N&&(X=N=null,M=0);0===(f.subtreeFlags&10256)&&0===(f.flags&10256)||mk||(mk=!0,pk=h,qk=c,Ok(Xa,function(){bf();return null}));c=0!==(f.flags&15990);if(0!==(f.subtreeFlags&
 15990)||c){c=hk.transition;hk.transition=null;e=F;F=2;var l=L;L|=4;gk.current=null;Wi(a,f);Bj(f,a);Pk(aj);Yi=!!Xi;aj=Xi=null;a.current=f;hj(a,f.alternate,f);Sa();L=l;F=e;hk.transition=c}else a.current=f;mk?(mk=!1,nk=a,ok=g):Qk(a,h);h=a.pendingLanes;0===h&&(kh=null);bb(f.stateNode,d);Ye(a);if(null!==b)for(d=a.onRecoverableError,f=0;f<b.length;f++)h=b[f],c={digest:h.digest,componentStack:h.stack},d(h.value,c);if(hh)throw hh=!1,a=ih,ih=null,a;0!==(ok&3)&&0!==a.tag&&bf();h=a.pendingLanes;0!==(g&4194218)&&
-0!==(h&2)?a===Vd?Ud++:(Ud=0,Vd=a):Ud=0;af(!1);return null}function Qk(a,b){0===(a.pooledCacheLanes&=b)&&(b=a.pooledCache,null!=b&&(a.pooledCache=null,li(b)))}
-function bf(){if(null!==nk){var a=nk,b=pk;pk=0;var c=ub(ok),d=32>c?32:c;c=hk.transition;var e=F;try{hk.transition=null;F=d;if(null===nk)var f=!1;else{d=qk;qk=null;var g=nk,h=ok;nk=null;ok=0;if(0!==(L&6))throw Error(t(331));var l=L;L|=4;ak(g.current);Qj(g,g.current,h,d);L=l;af(!1);if(ab&&"function"===typeof ab.onPostCommitFiberRoot)try{ab.onPostCommitFiberRoot($a,g)}catch(p){}f=!0}return f}finally{F=e,hk.transition=c,Qk(a,b)}}return!1}
+0!==(h&42)?a===Vd?Ud++:(Ud=0,Vd=a):Ud=0;af(!1);return null}function Qk(a,b){0===(a.pooledCacheLanes&=b)&&(b=a.pooledCache,null!=b&&(a.pooledCache=null,li(b)))}
+function bf(){if(null!==nk){var a=nk,b=pk;pk=0;var c=ub(ok),d=32>c?32:c;c=hk.transition;var e=F;try{hk.transition=null;F=d;if(null===nk)var f=!1;else{d=qk;qk=null;var g=nk,h=ok;nk=null;ok=0;if(0!==(L&6))throw Error(u(331));var l=L;L|=4;ak(g.current);Qj(g,g.current,h,d);L=l;af(!1);if(ab&&"function"===typeof ab.onPostCommitFiberRoot)try{ab.onPostCommitFiberRoot($a,g)}catch(p){}f=!0}return f}finally{F=e,hk.transition=c,Qk(a,b)}}return!1}
 function Rk(a,b,c){b=dh(c,b);b=gh(a,b,2);a=$d(a,b,2);null!==a&&(ob(a,2),Ye(a))}function W(a,b,c){if(3===a.tag)Rk(a,a,c);else for(;null!==b;){if(3===b.tag){Rk(b,a,c);break}else if(1===b.tag){var d=b.stateNode;if("function"===typeof b.type.getDerivedStateFromError||"function"===typeof d.componentDidCatch&&(null===kh||!kh.has(d))){a=dh(c,a);a=jh(b,a,2);b=$d(b,a,2);null!==b&&(ob(b,2),Ye(b));break}}b=b.return}}
 function ph(a,b,c){var d=a.pingCache;if(null===d){d=a.pingCache=new dk;var e=new Set;d.set(b,e)}else e=d.get(b),void 0===e&&(e=new Set,d.set(b,e));e.has(c)||(jk=!0,e.add(c),a=Sk.bind(null,a,b,c),b.then(a,a))}function Sk(a,b,c){var d=a.pingCache;null!==d&&d.delete(b);a.pingedLanes|=a.suspendedLanes&c;N===a&&(M&c)===c&&(4===oh||3===oh&&(M&62914560)===M&&300>Ta()-Kj?0===(L&2)&&ff(a,0):lk|=c);Ye(a)}function Tk(a,b){0===b&&(b=0===(a.mode&1)?2:mb());a=Td(a,b);null!==a&&(ob(a,b),Ye(a))}
-function Uh(a){var b=a.memoizedState,c=0;null!==b&&(c=b.retryLane);Tk(a,c)}function zj(a,b){var c=0;switch(a.tag){case 13:var d=a.stateNode;var e=a.memoizedState;null!==e&&(c=e.retryLane);break;case 19:d=a.stateNode;break;case 22:d=a.stateNode._retryCache;break;default:throw Error(t(314));}null!==d&&d.delete(b);Tk(a,c)}var Mk;
+function Uh(a){var b=a.memoizedState,c=0;null!==b&&(c=b.retryLane);Tk(a,c)}function zj(a,b){var c=0;switch(a.tag){case 13:var d=a.stateNode;var e=a.memoizedState;null!==e&&(c=e.retryLane);break;case 19:d=a.stateNode;break;case 22:d=a.stateNode._retryCache;break;default:throw Error(u(314));}null!==d&&d.delete(b);Tk(a,c)}var Mk;
 Mk=function(a,b,c){if(null!==a)if(a.memoizedProps!==b.pendingProps||Uc.current)eg=!0;else{if(0===(a.lanes&c)&&0===(b.flags&128))return eg=!1,Zh(a,b,c);eg=0!==(a.flags&131072)?!0:!1}else eg=!1,K&&0!==(b.flags&1048576)&&od(b,hd,b.index);b.lanes=0;switch(b.tag){case 2:var d=b.type;Ih(a,b);a=b.pendingProps;var e=Wc(b,Tc.current);vh(b,c);e=Lf(null,b,d,a,e,c);var f=Uf();b.flags|=1;"object"===typeof e&&null!==e&&"function"===typeof e.render&&void 0===e.$$typeof?(b.tag=1,b.memoizedState=null,b.updateQueue=
-null,Xc(d)?(f=!0,ad(b)):f=!1,b.memoizedState=null!==e.state&&void 0!==e.state?e.state:null,Xd(b),e.updater=Zg,b.stateNode=e,e._reactInternals=b,ch(b,d,a,c),b=Jh(null,b,d,!0,f,c)):(b.tag=0,K&&f&&pd(b),th(null,b,e,c),b=b.child);return b;case 16:d=b.elementType;a:{Ih(a,b);a=b.pendingProps;e=d._init;d=e(d._payload);b.type=d;e=b.tag=Uk(d);a=Xg(d,a);switch(e){case 0:b=Ah(null,b,d,a,c);break a;case 1:b=Hh(null,b,d,a,c);break a;case 11:b=uh(null,b,d,a,c);break a;case 14:b=xh(null,b,d,Xg(d.type,a),c);break a}throw Error(t(306,
-d,""));}return b;case 0:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Xg(d,e),Ah(a,b,d,e,c);case 1:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Xg(d,e),Hh(a,b,d,e,c);case 3:a:{Kh(b);if(null===a)throw Error(t(387));e=b.pendingProps;f=b.memoizedState;d=f.element;Yd(a,b);ce(b,e,null,c);var g=b.memoizedState;e=g.cache;$h(b,S,e);e!==f.cache&&gi(b,S,c);e=g.element;if(f.isDehydrated)if(f={element:e,isDehydrated:!1,cache:g.cache},b.updateQueue.baseState=f,b.memoizedState=f,b.flags&256){d=
-dh(Error(t(423)),b);b=Lh(a,b,e,c,d);break a}else if(e!==d){d=dh(Error(t(424)),b);b=Lh(a,b,e,c,d);break a}else for(J=yd(b.stateNode.containerInfo.firstChild),G=b,K=!0,rd=null,sd=!0,c=De(b,null,e,c),b.child=c;c;)c.flags=c.flags&-3|4096,c=c.sibling;else{Jd();if(e===d){b=wh(a,b,c);break a}th(a,b,e,c)}b=b.child}return b;case 26:return Ch(a,b),c=b.memoizedState=Vk(b.type,null===a?null:a.memoizedProps,b.pendingProps),null!==a||K||null!==c||(c=b.type,a=b.pendingProps,d=yi(Ga.current).createElement(c),d[xb]=
+null,Xc(d)?(f=!0,ad(b)):f=!1,b.memoizedState=null!==e.state&&void 0!==e.state?e.state:null,Xd(b),e.updater=Zg,b.stateNode=e,e._reactInternals=b,ch(b,d,a,c),b=Jh(null,b,d,!0,f,c)):(b.tag=0,K&&f&&pd(b),th(null,b,e,c),b=b.child);return b;case 16:d=b.elementType;a:{Ih(a,b);a=b.pendingProps;e=d._init;d=e(d._payload);b.type=d;e=b.tag=Uk(d);a=Xg(d,a);switch(e){case 0:b=Ah(null,b,d,a,c);break a;case 1:b=Hh(null,b,d,a,c);break a;case 11:b=uh(null,b,d,a,c);break a;case 14:b=xh(null,b,d,Xg(d.type,a),c);break a}throw Error(u(306,
+d,""));}return b;case 0:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Xg(d,e),Ah(a,b,d,e,c);case 1:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Xg(d,e),Hh(a,b,d,e,c);case 3:a:{Kh(b);if(null===a)throw Error(u(387));e=b.pendingProps;f=b.memoizedState;d=f.element;Yd(a,b);ce(b,e,null,c);var g=b.memoizedState;e=g.cache;$h(b,S,e);e!==f.cache&&gi(b,S,c);e=g.element;if(f.isDehydrated)if(f={element:e,isDehydrated:!1,cache:g.cache},b.updateQueue.baseState=f,b.memoizedState=f,b.flags&256){d=
+dh(Error(u(423)),b);b=Lh(a,b,e,c,d);break a}else if(e!==d){d=dh(Error(u(424)),b);b=Lh(a,b,e,c,d);break a}else for(J=yd(b.stateNode.containerInfo.firstChild),G=b,K=!0,rd=null,sd=!0,c=De(b,null,e,c),b.child=c;c;)c.flags=c.flags&-3|4096,c=c.sibling;else{Jd();if(e===d){b=wh(a,b,c);break a}th(a,b,e,c)}b=b.child}return b;case 26:return Ch(a,b),c=b.memoizedState=Vk(b.type,null===a?null:a.memoizedProps,b.pendingProps),null!==a||K||null!==c||(c=b.type,a=b.pendingProps,d=yi(Ga.current).createElement(c),d[xb]=
 b,d[yb]=a,zi(d,c,a),Nb(d),b.stateNode=d),null;case 27:return Na(b),null===a&&K&&(d=b.stateNode=xi(b.type,b.pendingProps,Ga.current),G=b,sd=!0,J=yd(d.firstChild)),d=b.pendingProps.children,null!==a||K?th(a,b,d,c):b.child=Ce(b,null,d,c),Ch(a,b),b.child;case 5:return Na(b),null===a&&K&&((e=d=J,e)?wd(b,e)||(Dd(b)&&Ed(),J=Cd(e),f=G,J&&wd(b,J)?td(f,e):(vd(G,b),K=!1,G=b,J=d)):(Dd(b)&&Ed(),vd(G,b),K=!1,G=b,J=d)),e=b.type,f=b.pendingProps,g=null!==a?a.memoizedProps:null,d=f.children,Hd(e,f)?d=null:null!==
 g&&Hd(e,g)&&(b.flags|=32),null!==b.memoizedState&&(e=Lf(a,b,Sf,null,null,c),Ia._currentValue=e,eg&&null!==a&&a.memoizedState.memoizedState!==e&&gi(b,Ia,c)),Ch(a,b),th(a,b,d,c),b.child;case 6:return null===a&&K&&((d=""!==b.pendingProps,a=c=J,a&&d)?zd(b,a)||(Dd(b)&&Ed(),J=Cd(a),d=G,J&&zd(b,J)?td(d,a):(vd(G,b),K=!1,G=b,J=c)):(Dd(b)&&Ed(),vd(G,b),K=!1,G=b,J=c)),null;case 13:return Ph(a,b,c);case 4:return Ja(b,b.stateNode.containerInfo),d=b.pendingProps,null===a?b.child=Ce(b,null,d,c):th(a,b,d,c),b.child;
 case 11:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Xg(d,e),uh(a,b,d,e,c);case 7:return th(a,b,b.pendingProps,c),b.child;case 8:return th(a,b,b.pendingProps.children,c),b.child;case 12:return th(a,b,b.pendingProps.children,c),b.child;case 10:a:{d=b.type._context;e=b.pendingProps;f=b.memoizedProps;g=e.value;$h(b,d,g);if(null!==f)if(dd(f.value,g)){if(f.children===e.children&&!Uc.current){b=wh(a,b,c);break a}}else gi(b,d,c);th(a,b,e.children,c);b=b.child}return b;case 9:return e=b.type,d=
 b.pendingProps.children,vh(b,c),e=ag(e),d=d(e),b.flags|=1,th(a,b,d,c),b.child;case 14:return d=b.type,e=Xg(d,b.pendingProps),e=Xg(d.type,e),xh(a,b,d,e,c);case 15:return zh(a,b,b.type,b.pendingProps,c);case 17:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Xg(d,e),Ih(a,b),b.tag=1,Xc(d)?(a=!0,ad(b)):a=!1,vh(b,c),ah(b,d,e),ch(b,d,e,c),Jh(null,b,d,!0,a,c);case 19:return Yh(a,b,c);case 22:return Bh(a,b,c);case 24:return vh(b,c),d=ag(S),null===a?(e=Fh(),null===e&&(e=N,f=Tg(),e.pooledCache=f,f.refCount++,
-null!==f&&(e.pooledCacheLanes|=c),e=f),b.memoizedState={parent:d,cache:e},Xd(b),$h(b,S,e)):(0!==(a.lanes&c)&&(Yd(a,b),ce(b,null,null,c)),e=a.memoizedState,f=b.memoizedState,e.parent!==d?(e={parent:d,cache:d},b.memoizedState=e,0===b.lanes&&(b.memoizedState=b.updateQueue.baseState=e),$h(b,S,d)):(d=f.cache,$h(b,S,d),d!==e.cache&&gi(b,S,c))),th(a,b,b.pendingProps.children,c),b.child}throw Error(t(156,b.tag));};function Ok(a,b){return Pa(a,b)}
+null!==f&&(e.pooledCacheLanes|=c),e=f),b.memoizedState={parent:d,cache:e},Xd(b),$h(b,S,e)):(0!==(a.lanes&c)&&(Yd(a,b),ce(b,null,null,c)),e=a.memoizedState,f=b.memoizedState,e.parent!==d?(e={parent:d,cache:d},b.memoizedState=e,0===b.lanes&&(b.memoizedState=b.updateQueue.baseState=e),$h(b,S,d)):(d=f.cache,$h(b,S,d),d!==e.cache&&gi(b,S,c))),th(a,b,b.pendingProps.children,c),b.child}throw Error(u(156,b.tag));};function Ok(a,b){return Pa(a,b)}
 function Wk(a,b,c,d){this.tag=a;this.key=c;this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null;this.index=0;this.refCleanup=this.ref=null;this.pendingProps=b;this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null;this.mode=d;this.subtreeFlags=this.flags=0;this.deletions=null;this.childLanes=this.lanes=0;this.alternate=null}function ud(a,b,c,d){return new Wk(a,b,c,d)}function yh(a){a=a.prototype;return!(!a||!a.isReactComponent)}
 function Uk(a){if("function"===typeof a)return yh(a)?1:0;if(void 0!==a&&null!==a){a=a.$$typeof;if(a===ta)return 11;if(a===wa)return 14}return 2}
 function we(a,b){var c=a.alternate;null===c?(c=ud(a.tag,b,a.key,a.mode),c.elementType=a.elementType,c.type=a.type,c.stateNode=a.stateNode,c.alternate=a,a.alternate=c):(c.pendingProps=b,c.type=a.type,c.flags=0,c.subtreeFlags=0,c.deletions=null);c.flags=a.flags&31457280;c.childLanes=a.childLanes;c.lanes=a.lanes;c.child=a.child;c.memoizedProps=a.memoizedProps;c.memoizedState=a.memoizedState;c.updateQueue=a.updateQueue;b=a.dependencies;c.dependencies=null===b?null:{lanes:b.lanes,firstContext:b.firstContext};
@@ -287,18 +286,18 @@ c.sibling=a.sibling;c.index=a.index;c.ref=a.ref;c.refCleanup=a.refCleanup;return
 function Ci(a,b){a.flags&=31457282;var c=a.alternate;null===c?(a.childLanes=0,a.lanes=b,a.child=null,a.subtreeFlags=0,a.memoizedProps=null,a.memoizedState=null,a.updateQueue=null,a.dependencies=null,a.stateNode=null):(a.childLanes=c.childLanes,a.lanes=c.lanes,a.child=c.child,a.subtreeFlags=0,a.deletions=null,a.memoizedProps=c.memoizedProps,a.memoizedState=c.memoizedState,a.updateQueue=c.updateQueue,a.type=c.type,b=c.dependencies,a.dependencies=null===b?null:{lanes:b.lanes,firstContext:b.firstContext});
 return a}
 function ye(a,b,c,d,e,f,g){e=2;d=a;if("function"===typeof a)yh(a)&&(e=1);else if("string"===typeof a)e=Xk(a,c,Ea.current)?26:"html"===a||"head"===a||"body"===a?27:5;else a:switch(a){case na:return Ae(c.children,f,g,b);case oa:e=8;f|=8;0!==(f&1)&&(f|=16);break;case pa:return a=ud(12,c,b,f|2),a.elementType=pa,a.lanes=g,a;case ua:return a=ud(13,c,b,f),a.elementType=ua,a.lanes=g,a;case va:return a=ud(19,c,b,f),a.elementType=va,a.lanes=g,a;case za:return Qh(c,f,g,b);case Aa:case ya:case Ba:return a=ud(24,
-c,b,f),a.elementType=Ba,a.lanes=g,a;default:if("object"===typeof a&&null!==a)switch(a.$$typeof){case qa:e=10;break a;case ra:e=9;break a;case ta:e=11;break a;case wa:e=14;break a;case xa:e=16;d=null;break a}throw Error(t(130,null==a?a:typeof a,""));}b=ud(e,c,b,f);b.elementType=a;b.type=d;b.lanes=g;return b}function Ae(a,b,c,d){a=ud(7,a,d,b);a.lanes=c;return a}
-function Qh(a,b,c,d){a=ud(22,a,d,b);a.elementType=za;a.lanes=c;var e={_visibility:1,_pendingVisibility:1,_pendingMarkers:null,_retryCache:null,_transitions:null,_current:null,detach:function(){var f=e._current;if(null===f)throw Error(t(456));if(0===(e._pendingVisibility&2)){var g=Td(f,2);null!==g&&(e._pendingVisibility|=2,og(g,f,2))}},attach:function(){var f=e._current;if(null===f)throw Error(t(456));if(0!==(e._pendingVisibility&2)){var g=Td(f,2);null!==g&&(e._pendingVisibility&=-3,og(g,f,2))}}};
+c,b,f),a.elementType=Ba,a.lanes=g,a;default:if("object"===typeof a&&null!==a)switch(a.$$typeof){case qa:e=10;break a;case ra:e=9;break a;case ta:e=11;break a;case wa:e=14;break a;case xa:e=16;d=null;break a}throw Error(u(130,null==a?a:typeof a,""));}b=ud(e,c,b,f);b.elementType=a;b.type=d;b.lanes=g;return b}function Ae(a,b,c,d){a=ud(7,a,d,b);a.lanes=c;return a}
+function Qh(a,b,c,d){a=ud(22,a,d,b);a.elementType=za;a.lanes=c;var e={_visibility:1,_pendingVisibility:1,_pendingMarkers:null,_retryCache:null,_transitions:null,_current:null,detach:function(){var f=e._current;if(null===f)throw Error(u(456));if(0===(e._pendingVisibility&2)){var g=Td(f,2);null!==g&&(e._pendingVisibility|=2,og(g,f,2))}},attach:function(){var f=e._current;if(null===f)throw Error(u(456));if(0!==(e._pendingVisibility&2)){var g=Td(f,2);null!==g&&(e._pendingVisibility&=-3,og(g,f,2))}}};
 a.stateNode=e;return a}function xe(a,b,c){a=ud(6,a,null,b);a.lanes=c;return a}function ze(a,b,c){b=ud(4,null!==a.children?a.children:[],a.key,b);b.lanes=c;b.stateNode={containerInfo:a.containerInfo,pendingChildren:null,implementation:a.implementation};return b}
 function Yk(a,b,c,d,e,f){this.tag=b;this.containerInfo=a;this.finishedWork=this.pingCache=this.current=this.pendingChildren=null;this.timeoutHandle=-1;this.callbackNode=this.next=this.pendingContext=this.context=this.cancelPendingCommit=null;this.callbackPriority=0;this.expirationTimes=nb(-1);this.entangledLanes=this.shellSuspendCounter=this.errorRecoveryDisabledLanes=this.finishedLanes=this.expiredLanes=this.pingedLanes=this.suspendedLanes=this.pendingLanes=0;this.entanglements=nb(0);this.hiddenUpdates=
 nb(null);this.identifierPrefix=d;this.onRecoverableError=e;this.pooledCache=null;this.pooledCacheLanes=0;this.formState=f;this.incompleteTransitions=new Map}function Zk(a,b,c,d,e,f,g,h,l,p,q){a=new Yk(a,b,c,h,l,q);1===b?(b=1,!0===f&&(b|=24)):b=0;f=ud(3,null,null,b);a.current=f;f.stateNode=a;b=Tg();b.refCount++;a.pooledCache=b;b.refCount++;f.memoizedState={element:d,isDehydrated:c,cache:b};Xd(f);return a}
 function $k(a,b,c){var d=3<arguments.length&&void 0!==arguments[3]?arguments[3]:null;return{$$typeof:ma,key:null==d?null:""+d,children:a,containerInfo:b,implementation:c}}
-function al(a){if(!a)return Sc;a=a._reactInternals;a:{if(Mc(a)!==a||1!==a.tag)throw Error(t(170));var b=a;do{switch(b.tag){case 3:b=b.stateNode.context;break a;case 1:if(Xc(b.type)){b=b.stateNode.__reactInternalMemoizedMergedChildContext;break a}}b=b.return}while(null!==b);throw Error(t(171));}if(1===a.tag){var c=a.type;if(Xc(c))return $c(a,c,b)}return b}
+function al(a){if(!a)return Sc;a=a._reactInternals;a:{if(Mc(a)!==a||1!==a.tag)throw Error(u(170));var b=a;do{switch(b.tag){case 3:b=b.stateNode.context;break a;case 1:if(Xc(b.type)){b=b.stateNode.__reactInternalMemoizedMergedChildContext;break a}}b=b.return}while(null!==b);throw Error(u(171));}if(1===a.tag){var c=a.type;if(Xc(c))return $c(a,c,b)}return b}
 function bl(a,b,c,d,e,f,g,h,l,p,q){a=Zk(c,d,!0,a,e,f,g,h,l,p,q);a.context=al(null);c=a.current;d=Sg(c);e=Zd(d);e.callback=void 0!==b&&null!==b?b:null;$d(c,e,d);a.current.lanes=d;ob(a,d);Ye(a);return a}function cl(a,b,c,d){var e=b.current,f=Sg(e);c=al(c);null===b.context?b.context=c:b.pendingContext=c;b=Zd(f);b.payload={element:a};d=void 0===d?null:d;null!==d&&(b.callback=d);a=$d(e,b,f);null!==a&&(og(a,e,f),ae(a,e,f));return f}
 function dl(a){a=a.current;if(!a.child)return null;switch(a.child.tag){case 27:case 5:return a.child.stateNode;default:return a.child.stateNode}}function el(a){switch(a.tag){case 3:var b=a.stateNode;if(b.current.memoizedState.isDehydrated){var c=ib(b.pendingLanes);0!==c&&(sb(b,c),Ye(b),0===(L&6)&&(Di=Ta()+500,af(!1)))}break;case 13:Ak(function(){var d=Td(a,2);null!==d&&og(d,a,2)}),fl(a,2)}}
 function gl(a,b){a=a.memoizedState;if(null!==a&&null!==a.dehydrated){var c=a.retryLane;a.retryLane=0!==c&&c<b?c:b}}function fl(a,b){gl(a,b);(a=a.alternate)&&gl(a,b)}function hl(a){if(13===a.tag){var b=Td(a,67108864);null!==b&&og(b,a,67108864);fl(a,67108864)}}function il(){return null}var jl=!1;function kl(a,b,c){if(jl)return a(b,c);jl=!0;try{return zk(a,b,c)}finally{if(jl=!1,null!==Hc||null!==Ic)Ak(),Lc()}}
 function ll(a,b){var c=a.stateNode;if(null===c)return null;var d=Lb(c);if(null===d)return null;c=d[b];a:switch(b){case "onClick":case "onClickCapture":case "onDoubleClick":case "onDoubleClickCapture":case "onMouseDown":case "onMouseDownCapture":case "onMouseMove":case "onMouseMoveCapture":case "onMouseUp":case "onMouseUpCapture":case "onMouseEnter":(d=!d.disabled)||(a=a.type,d=!("button"===a||"input"===a||"select"===a||"textarea"===a));a=!d;break a;default:a=!1}if(a)return null;if(c&&"function"!==
-typeof c)throw Error(t(231,b,typeof c));return c}var ml=!1;if(Sb)try{var nl={};Object.defineProperty(nl,"passive",{get:function(){ml=!0}});window.addEventListener("test",nl,nl);window.removeEventListener("test",nl,nl)}catch(a){ml=!1}function ol(a){var b=a.keyCode;"charCode"in a?(a=a.charCode,0===a&&13===b&&(a=13)):a=b;10===a&&(a=13);return 32<=a||13===a?a:0}function pl(){return!0}function ql(){return!1}
+typeof c)throw Error(u(231,b,typeof c));return c}var ml=!1;if(Sb)try{var nl={};Object.defineProperty(nl,"passive",{get:function(){ml=!0}});window.addEventListener("test",nl,nl);window.removeEventListener("test",nl,nl)}catch(a){ml=!1}function ol(a){var b=a.keyCode;"charCode"in a?(a=a.charCode,0===a&&13===b&&(a=13)):a=b;10===a&&(a=13);return 32<=a||13===a?a:0}function pl(){return!0}function ql(){return!1}
 function rl(a){function b(c,d,e,f,g){this._reactName=c;this._targetInst=e;this.type=d;this.nativeEvent=f;this.target=g;this.currentTarget=null;for(var h in a)a.hasOwnProperty(h)&&(c=a[h],this[h]=c?c(f):f[h]);this.isDefaultPrevented=(null!=f.defaultPrevented?f.defaultPrevented:!1===f.returnValue)?pl:ql;this.isPropagationStopped=ql;return this}C(b.prototype,{preventDefault:function(){this.defaultPrevented=!0;var c=this.nativeEvent;c&&(c.preventDefault?c.preventDefault():"unknown"!==typeof c.returnValue&&
 (c.returnValue=!1),this.isDefaultPrevented=pl)},stopPropagation:function(){var c=this.nativeEvent;c&&(c.stopPropagation?c.stopPropagation():"unknown"!==typeof c.cancelBubble&&(c.cancelBubble=!0),this.isPropagationStopped=pl)},persist:function(){},isPersistent:pl});return b}
 var sl={eventPhase:0,bubbles:0,cancelable:0,timeStamp:function(a){return a.timeStamp||Date.now()},defaultPrevented:0,isTrusted:0},tl=rl(sl),ul=C({},sl,{view:0,detail:0}),vl=rl(ul),wl,xl,yl,Al=C({},ul,{screenX:0,screenY:0,clientX:0,clientY:0,pageX:0,pageY:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,getModifierState:zl,button:0,buttons:0,relatedTarget:function(a){return void 0===a.relatedTarget?a.fromElement===a.srcElement?a.toElement:a.fromElement:a.relatedTarget},movementX:function(a){if("movementX"in
@@ -344,37 +343,37 @@ function Ym(a,b){b=0!==(b&4);for(var c=0;c<a.length;c++){var d=a[c],e=d.event;d=
 function Y(a,b){var c=b[Ab];void 0===c&&(c=b[Ab]=new Set);var d=a+"__bubble";c.has(d)||(Nn(b,a,2,!1),c.add(d))}function On(a,b,c){var d=0;b&&(d|=4);Nn(c,a,d,b)}var Pn="_reactListening"+Math.random().toString(36).slice(2);function Bi(a){if(!a[Pn]){a[Pn]=!0;Ob.forEach(function(c){"selectionchange"!==c&&(Ln.has(c)||On(c,!1,a),On(c,!0,a))});var b=9===a.nodeType?a:a.ownerDocument;null===b||b[Pn]||(b[Pn]=!0,On("selectionchange",!1,b))}}
 function Nn(a,b,c,d){switch(rk(b)){case 2:var e=vm;break;case 8:e=xm;break;default:e=wm}c=e.bind(null,b,c,a);e=void 0;!ml||"touchstart"!==b&&"touchmove"!==b&&"wheel"!==b||(e=!0);d?void 0!==e?a.addEventListener(b,c,{capture:!0,passive:e}):a.addEventListener(b,c,!0):void 0!==e?a.addEventListener(b,c,{passive:e}):a.addEventListener(b,c,!1)}
 function ym(a,b,c,d,e){var f=d;if(0===(b&1)&&0===(b&2)&&null!==d)a:for(;;){if(null===d)return;var g=d.tag;if(3===g||4===g){var h=d.stateNode.containerInfo;if(h===e||8===h.nodeType&&h.parentNode===e)break;if(4===g)for(g=d.return;null!==g;){var l=g.tag;if(3===l||4===l)if(l=g.stateNode.containerInfo,l===e||8===l.nodeType&&l.parentNode===e)return;g=g.return}for(;null!==h;){g=Hb(h);if(null===g)return;l=g.tag;if(5===l||6===l||26===l||27===l){d=f=g;continue a}h=h.parentNode}}d=d.return}kl(function(){var p=
-f,q=Gc(c),w=[];a:{var r=Dn.get(a);if(void 0!==r){var u=tl,z=a;switch(a){case "keypress":if(0===ol(c))break a;case "keydown":case "keyup":u=Rl;break;case "focusin":z="focus";u=Fl;break;case "focusout":z="blur";u=Fl;break;case "beforeblur":case "afterblur":u=Fl;break;case "click":if(2===c.button)break a;case "auxclick":case "dblclick":case "mousedown":case "mousemove":case "mouseup":case "mouseout":case "mouseover":case "contextmenu":u=Bl;break;case "drag":case "dragend":case "dragenter":case "dragexit":case "dragleave":case "dragover":case "dragstart":case "drop":u=
-Dl;break;case "touchcancel":case "touchend":case "touchmove":case "touchstart":u=Vl;break;case zn:case An:case Bn:u=Hl;break;case Cn:u=Xl;break;case "scroll":case "scrollend":u=vl;break;case "wheel":u=Zl;break;case "copy":case "cut":case "paste":u=Jl;break;case "gotpointercapture":case "lostpointercapture":case "pointercancel":case "pointerdown":case "pointermove":case "pointerout":case "pointerover":case "pointerup":u=Tl}var B=0!==(b&4),U=!B&&("scroll"===a||"scrollend"===a),V=B?null!==r?r+"Capture":
-null:r;B=[];for(var m=p,k;null!==m;){var n=m;k=n.stateNode;n=n.tag;5!==n&&26!==n&&27!==n||null===k||null===V||(n=ll(m,V),null!=n&&B.push(Qn(m,n,k)));if(U)break;m=m.return}0<B.length&&(r=new u(r,z,null,c,q),w.push({event:r,listeners:B}))}}if(0===(b&7)){a:{r="mouseover"===a||"pointerover"===a;u="mouseout"===a||"pointerout"===a;if(r&&c!==Fc&&(z=c.relatedTarget||c.fromElement)&&(Hb(z)||z[zb]))break a;if(u||r){r=q.window===q?q:(r=q.ownerDocument)?r.defaultView||r.parentWindow:window;if(u){if(z=c.relatedTarget||
-c.toElement,u=p,z=z?Hb(z):null,null!==z&&(U=Mc(z),B=z.tag,z!==U||5!==B&&27!==B&&6!==B))z=null}else u=null,z=p;if(u!==z){B=Bl;n="onMouseLeave";V="onMouseEnter";m="mouse";if("pointerout"===a||"pointerover"===a)B=Tl,n="onPointerLeave",V="onPointerEnter",m="pointer";U=null==u?r:Kb(u);k=null==z?r:Kb(z);r=new B(n,m+"leave",u,c,q);r.target=U;r.relatedTarget=k;n=null;Hb(q)===p&&(B=new B(V,m+"enter",z,c,q),B.target=k,B.relatedTarget=U,n=B);U=n;if(u&&z)b:{B=u;V=z;m=0;for(k=B;k;k=Rn(k))m++;k=0;for(n=V;n;n=Rn(n))k++;
-for(;0<m-k;)B=Rn(B),m--;for(;0<k-m;)V=Rn(V),k--;for(;m--;){if(B===V||null!==V&&B===V.alternate)break b;B=Rn(B);V=Rn(V)}B=null}else B=null;null!==u&&Sn(w,r,u,B,!1);null!==z&&null!==U&&Sn(w,U,z,B,!0)}}}a:{r=p?Kb(p):window;u=r.nodeName&&r.nodeName.toLowerCase();if("select"===u||"input"===u&&"file"===r.type)var v=$m;else if(Sm(r))if(an)v=kn;else{v=hn;var x=gn}else(u=r.nodeName)&&"input"===u.toLowerCase()&&("checkbox"===r.type||"radio"===r.type)&&(v=jn);if(v&&(v=v(a,p))){Tm(w,v,c,q);break a}x&&x(a,r,p);
+f,q=Gc(c),w=[];a:{var r=Dn.get(a);if(void 0!==r){var t=tl,z=a;switch(a){case "keypress":if(0===ol(c))break a;case "keydown":case "keyup":t=Rl;break;case "focusin":z="focus";t=Fl;break;case "focusout":z="blur";t=Fl;break;case "beforeblur":case "afterblur":t=Fl;break;case "click":if(2===c.button)break a;case "auxclick":case "dblclick":case "mousedown":case "mousemove":case "mouseup":case "mouseout":case "mouseover":case "contextmenu":t=Bl;break;case "drag":case "dragend":case "dragenter":case "dragexit":case "dragleave":case "dragover":case "dragstart":case "drop":t=
+Dl;break;case "touchcancel":case "touchend":case "touchmove":case "touchstart":t=Vl;break;case zn:case An:case Bn:t=Hl;break;case Cn:t=Xl;break;case "scroll":case "scrollend":t=vl;break;case "wheel":t=Zl;break;case "copy":case "cut":case "paste":t=Jl;break;case "gotpointercapture":case "lostpointercapture":case "pointercancel":case "pointerdown":case "pointermove":case "pointerout":case "pointerover":case "pointerup":t=Tl}var B=0!==(b&4),U=!B&&("scroll"===a||"scrollend"===a),V=B?null!==r?r+"Capture":
+null:r;B=[];for(var m=p,k;null!==m;){var n=m;k=n.stateNode;n=n.tag;5!==n&&26!==n&&27!==n||null===k||null===V||(n=ll(m,V),null!=n&&B.push(Qn(m,n,k)));if(U)break;m=m.return}0<B.length&&(r=new t(r,z,null,c,q),w.push({event:r,listeners:B}))}}if(0===(b&7)){a:{r="mouseover"===a||"pointerover"===a;t="mouseout"===a||"pointerout"===a;if(r&&c!==Fc&&(z=c.relatedTarget||c.fromElement)&&(Hb(z)||z[zb]))break a;if(t||r){r=q.window===q?q:(r=q.ownerDocument)?r.defaultView||r.parentWindow:window;if(t){if(z=c.relatedTarget||
+c.toElement,t=p,z=z?Hb(z):null,null!==z&&(U=Mc(z),B=z.tag,z!==U||5!==B&&27!==B&&6!==B))z=null}else t=null,z=p;if(t!==z){B=Bl;n="onMouseLeave";V="onMouseEnter";m="mouse";if("pointerout"===a||"pointerover"===a)B=Tl,n="onPointerLeave",V="onPointerEnter",m="pointer";U=null==t?r:Kb(t);k=null==z?r:Kb(z);r=new B(n,m+"leave",t,c,q);r.target=U;r.relatedTarget=k;n=null;Hb(q)===p&&(B=new B(V,m+"enter",z,c,q),B.target=k,B.relatedTarget=U,n=B);U=n;if(t&&z)b:{B=t;V=z;m=0;for(k=B;k;k=Rn(k))m++;k=0;for(n=V;n;n=Rn(n))k++;
+for(;0<m-k;)B=Rn(B),m--;for(;0<k-m;)V=Rn(V),k--;for(;m--;){if(B===V||null!==V&&B===V.alternate)break b;B=Rn(B);V=Rn(V)}B=null}else B=null;null!==t&&Sn(w,r,t,B,!1);null!==z&&null!==U&&Sn(w,U,z,B,!0)}}}a:{r=p?Kb(p):window;t=r.nodeName&&r.nodeName.toLowerCase();if("select"===t||"input"===t&&"file"===r.type)var v=$m;else if(Sm(r))if(an)v=kn;else{v=hn;var x=gn}else(t=r.nodeName)&&"input"===t.toLowerCase()&&("checkbox"===r.type||"radio"===r.type)&&(v=jn);if(v&&(v=v(a,p))){Tm(w,v,c,q);break a}x&&x(a,r,p);
 "focusout"===a&&p&&"number"===r.type&&null!=p.memoizedProps.value&&pc(r,"number",r.value)}x=p?Kb(p):window;switch(a){case "focusin":if(Sm(x)||"true"===x.contentEditable)pn=x,qn=p,rn=null;break;case "focusout":rn=qn=pn=null;break;case "mousedown":sn=!0;break;case "contextmenu":case "mouseup":case "dragend":sn=!1;tn(w,c,q);break;case "selectionchange":if(on)break;case "keydown":case "keyup":tn(w,c,q)}var A;if(Fm)b:{switch(a){case "compositionstart":var y="onCompositionStart";break b;case "compositionend":y=
 "onCompositionEnd";break b;case "compositionupdate":y="onCompositionUpdate";break b}y=void 0}else Om?Mm(a,c)&&(y="onCompositionEnd"):"keydown"===a&&229===c.keyCode&&(y="onCompositionStart");y&&(Im&&"ko"!==c.locale&&(Om||"onCompositionStart"!==y?"onCompositionEnd"===y&&Om&&(A=Dm()):(Am=q,Bm="value"in Am?Am.value:Am.textContent,Om=!0)),x=Um(p,y),0<x.length&&(y=new Ll(y,a,null,c,q),w.push({event:y,listeners:x}),A?y.data=A:(A=Nm(c),null!==A&&(y.data=A))));if(A=Hm?Pm(a,c):Qm(a,c))y=Um(p,"onBeforeInput"),
 0<y.length&&(x=new Ll("onBeforeInput","beforeinput",null,c,q),w.push({event:x,listeners:y}),x.data=A);$l(w,a,p,c,q)}Ym(w,b)})}function Qn(a,b,c){return{instance:a,listener:b,currentTarget:c}}function Um(a,b){for(var c=b+"Capture",d=[];null!==a;){var e=a,f=e.stateNode;e=e.tag;5!==e&&26!==e&&27!==e||null===f||(e=ll(a,c),null!=e&&d.unshift(Qn(a,e,f)),e=ll(a,b),null!=e&&d.push(Qn(a,e,f)));a=a.return}return d}
 function Rn(a){if(null===a)return null;do a=a.return;while(a&&5!==a.tag&&27!==a.tag);return a?a:null}function Sn(a,b,c,d,e){for(var f=b._reactName,g=[];null!==c&&c!==d;){var h=c,l=h.alternate,p=h.stateNode;h=h.tag;if(null!==l&&l===d)break;5!==h&&26!==h&&27!==h||null===p||(l=p,e?(p=ll(c,f),null!=p&&g.unshift(Qn(c,p,l))):e||(p=ll(c,f),null!=p&&g.push(Qn(c,p,l))));c=c.return}0!==g.length&&a.push({event:b,listeners:g})}var Tn=/\r\n?/g,Un=/\u0000|\uFFFD/g;
-function Vn(a){return("string"===typeof a?a:""+a).replace(Tn,"\n").replace(Un,"")}function Ai(a,b,c){b=Vn(b);if(Vn(a)!==b&&c)throw Error(t(425));}function pj(){}
+function Vn(a){return("string"===typeof a?a:""+a).replace(Tn,"\n").replace(Un,"")}function Ai(a,b,c){b=Vn(b);if(Vn(a)!==b&&c)throw Error(u(425));}function pj(){}
 function Z(a,b,c,d,e,f){switch(c){case "children":"string"===typeof d?"body"===b||"textarea"===b&&""===d||zc(a,d):"number"===typeof d&&"body"!==b&&zc(a,""+d);break;case "className":Yb(a,"class",d);break;case "tabIndex":Yb(a,"tabindex",d);break;case "dir":case "role":case "viewBox":case "width":case "height":Yb(a,c,d);break;case "style":Cc(a,d,f);break;case "src":case "href":if(null==d||"function"===typeof d||"symbol"===typeof d||"boolean"===typeof d){a.removeAttribute(c);break}a.setAttribute(c,""+
 d);break;case "action":case "formAction":if("function"===typeof d){a.setAttribute(c,"javascript:throw new Error('A React form was unexpectedly submitted. If you called form.submit() manually, consider using form.requestSubmit() instead. If you\\'re trying to use event.stopPropagation() in a submit event handler, consider also calling event.preventDefault().')");break}else"function"===typeof f&&("formAction"===c?("input"!==b&&Z(a,b,"name",e.name,e,null),Z(a,b,"formEncType",e.formEncType,e,null),Z(a,
 b,"formMethod",e.formMethod,e,null),Z(a,b,"formTarget",e.formTarget,e,null)):(Z(a,b,"encType",e.encType,e,null),Z(a,b,"method",e.method,e,null),Z(a,b,"target",e.target,e,null)));if(null==d||"symbol"===typeof d||"boolean"===typeof d){a.removeAttribute(c);break}a.setAttribute(c,""+d);break;case "onClick":null!=d&&(a.onclick=pj);break;case "onScroll":null!=d&&Y("scroll",a);break;case "onScrollEnd":null!=d&&Y("scrollend",a);break;case "dangerouslySetInnerHTML":if(null!=d){if("object"!==typeof d||!("__html"in
-d))throw Error(t(61));d=d.__html;if(null!=d){if(null!=e.children)throw Error(t(60));yc(a,d)}}break;case "multiple":a.multiple=d&&"function"!==typeof d&&"symbol"!==typeof d;break;case "muted":a.muted=d&&"function"!==typeof d&&"symbol"!==typeof d;break;case "suppressContentEditableWarning":case "suppressHydrationWarning":case "defaultValue":case "defaultChecked":case "innerHTML":break;case "autoFocus":break;case "xlinkHref":if(null==d||"function"===typeof d||"boolean"===typeof d||"symbol"===typeof d){a.removeAttribute("xlink:href");
+d))throw Error(u(61));d=d.__html;if(null!=d){if(null!=e.children)throw Error(u(60));yc(a,d)}}break;case "multiple":a.multiple=d&&"function"!==typeof d&&"symbol"!==typeof d;break;case "muted":a.muted=d&&"function"!==typeof d&&"symbol"!==typeof d;break;case "suppressContentEditableWarning":case "suppressHydrationWarning":case "defaultValue":case "defaultChecked":case "innerHTML":break;case "autoFocus":break;case "xlinkHref":if(null==d||"function"===typeof d||"boolean"===typeof d||"symbol"===typeof d){a.removeAttribute("xlink:href");
 break}a.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",""+d);break;case "contentEditable":case "spellCheck":case "draggable":case "value":case "autoReverse":case "externalResourcesRequired":case "focusable":case "preserveAlpha":null!=d&&"function"!==typeof d&&"symbol"!==typeof d?a.setAttribute(c,""+d):a.removeAttribute(c);break;case "allowFullScreen":case "async":case "autoPlay":case "controls":case "default":case "defer":case "disabled":case "disablePictureInPicture":case "disableRemotePlayback":case "formNoValidate":case "hidden":case "loop":case "noModule":case "noValidate":case "open":case "playsInline":case "readOnly":case "required":case "reversed":case "scoped":case "seamless":case "itemScope":d&&
 "function"!==typeof d&&"symbol"!==typeof d?a.setAttribute(c,""):a.removeAttribute(c);break;case "capture":case "download":!0===d?a.setAttribute(c,""):!1!==d&&null!=d&&"function"!==typeof d&&"symbol"!==typeof d?a.setAttribute(c,d):a.removeAttribute(c);break;case "cols":case "rows":case "size":case "span":null!=d&&"function"!==typeof d&&"symbol"!==typeof d&&!isNaN(d)&&1<=d?a.setAttribute(c,d):a.removeAttribute(c);break;case "rowSpan":case "start":null==d||"function"===typeof d||"symbol"===typeof d||
 isNaN(d)?a.removeAttribute(c):a.setAttribute(c,d);break;case "xlinkActuate":Zb(a,"http://www.w3.org/1999/xlink","xlink:actuate",d);break;case "xlinkArcrole":Zb(a,"http://www.w3.org/1999/xlink","xlink:arcrole",d);break;case "xlinkRole":Zb(a,"http://www.w3.org/1999/xlink","xlink:role",d);break;case "xlinkShow":Zb(a,"http://www.w3.org/1999/xlink","xlink:show",d);break;case "xlinkTitle":Zb(a,"http://www.w3.org/1999/xlink","xlink:title",d);break;case "xlinkType":Zb(a,"http://www.w3.org/1999/xlink","xlink:type",
 d);break;case "xmlBase":Zb(a,"http://www.w3.org/XML/1998/namespace","xml:base",d);break;case "xmlLang":Zb(a,"http://www.w3.org/XML/1998/namespace","xml:lang",d);break;case "xmlSpace":Zb(a,"http://www.w3.org/XML/1998/namespace","xml:space",d);break;case "is":Xb(a,"is",d);break;default:if(!(2<c.length)||"o"!==c[0]&&"O"!==c[0]||"n"!==c[1]&&"N"!==c[1])e=Ec.get(c)||c,Xb(a,e,d)}}
-function Wn(a,b,c,d,e,f){switch(c){case "style":Cc(a,d,f);break;case "dangerouslySetInnerHTML":if(null!=d){if("object"!==typeof d||!("__html"in d))throw Error(t(61));b=d.__html;if(null!=b){if(null!=e.children)throw Error(t(60));yc(a,b)}}break;case "children":"string"===typeof d?zc(a,d):"number"===typeof d&&zc(a,""+d);break;case "onScroll":null!=d&&Y("scroll",a);break;case "onScrollEnd":null!=d&&Y("scrollend",a);break;case "onClick":null!=d&&(a.onclick=pj);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":case "innerHTML":break;
+function Wn(a,b,c,d,e,f){switch(c){case "style":Cc(a,d,f);break;case "dangerouslySetInnerHTML":if(null!=d){if("object"!==typeof d||!("__html"in d))throw Error(u(61));b=d.__html;if(null!=b){if(null!=e.children)throw Error(u(60));yc(a,b)}}break;case "children":"string"===typeof d?zc(a,d):"number"===typeof d&&zc(a,""+d);break;case "onScroll":null!=d&&Y("scroll",a);break;case "onScrollEnd":null!=d&&Y("scrollend",a);break;case "onClick":null!=d&&(a.onclick=pj);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":case "innerHTML":break;
 default:Pb.hasOwnProperty(c)||("boolean"===typeof d&&(d=""+d),Xb(a,c,d))}}
-function zi(a,b,c){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "input":Y("invalid",a);var d=null,e=null,f=null,g=null,h=null,l=null;for(q in c)if(c.hasOwnProperty(q)){var p=c[q];if(null!=p)switch(q){case "name":d=p;break;case "type":e=p;break;case "checked":h=p;break;case "defaultChecked":l=p;break;case "value":f=p;break;case "defaultValue":g=p;break;case "children":case "dangerouslySetInnerHTML":if(null!=p)throw Error(t(137,b));break;default:Z(a,
+function zi(a,b,c){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "input":Y("invalid",a);var d=null,e=null,f=null,g=null,h=null,l=null;for(q in c)if(c.hasOwnProperty(q)){var p=c[q];if(null!=p)switch(q){case "name":d=p;break;case "type":e=p;break;case "checked":h=p;break;case "defaultChecked":l=p;break;case "value":f=p;break;case "defaultValue":g=p;break;case "children":case "dangerouslySetInnerHTML":if(null!=p)throw Error(u(137,b));break;default:Z(a,
 b,q,p,c,null)}}qc(a,f,g,h,l,e,d,!1);jc(a);return;case "select":Y("invalid",a);var q=e=f=null;for(d in c)if(c.hasOwnProperty(d)&&(g=c[d],null!=g))switch(d){case "value":f=g;break;case "defaultValue":e=g;break;case "multiple":q=g;default:Z(a,b,d,g,c,null)}b=f;c=e;a.multiple=!!q;null!=b?sc(a,!!q,b,!1):null!=c&&sc(a,!!q,c,!0);return;case "textarea":Y("invalid",a);f=d=q=null;for(e in c)if(c.hasOwnProperty(e)&&(g=c[e],null!=g))switch(e){case "value":q=g;break;case "defaultValue":d=g;break;case "children":f=
-g;break;case "dangerouslySetInnerHTML":if(null!=g)throw Error(t(91));break;default:Z(a,b,e,g,c,null)}uc(a,q,d,f);jc(a);return;case "option":for(g in c)if(c.hasOwnProperty(g)&&(q=c[g],null!=q))switch(g){case "selected":a.selected=q&&"function"!==typeof q&&"symbol"!==typeof q;break;default:Z(a,b,g,q,c,null)}return;case "dialog":Y("cancel",a);Y("close",a);break;case "iframe":case "object":Y("load",a);break;case "video":case "audio":for(q=0;q<Kn.length;q++)Y(Kn[q],a);break;case "image":Y("error",a);Y("load",
-a);break;case "details":Y("toggle",a);break;case "embed":case "source":case "img":case "link":Y("error",a),Y("load",a);case "area":case "base":case "br":case "col":case "hr":case "keygen":case "meta":case "param":case "track":case "wbr":case "menuitem":for(h in c)if(c.hasOwnProperty(h)&&(q=c[h],null!=q))switch(h){case "children":case "dangerouslySetInnerHTML":throw Error(t(137,b));default:Z(a,b,h,q,c,null)}return;default:if(Dc(b)){for(l in c)c.hasOwnProperty(l)&&(q=c[l],null!=q&&Wn(a,b,l,q,c,null));
+g;break;case "dangerouslySetInnerHTML":if(null!=g)throw Error(u(91));break;default:Z(a,b,e,g,c,null)}uc(a,q,d,f);jc(a);return;case "option":for(g in c)if(c.hasOwnProperty(g)&&(q=c[g],null!=q))switch(g){case "selected":a.selected=q&&"function"!==typeof q&&"symbol"!==typeof q;break;default:Z(a,b,g,q,c,null)}return;case "dialog":Y("cancel",a);Y("close",a);break;case "iframe":case "object":Y("load",a);break;case "video":case "audio":for(q=0;q<Kn.length;q++)Y(Kn[q],a);break;case "image":Y("error",a);Y("load",
+a);break;case "details":Y("toggle",a);break;case "embed":case "source":case "img":case "link":Y("error",a),Y("load",a);case "area":case "base":case "br":case "col":case "hr":case "keygen":case "meta":case "param":case "track":case "wbr":case "menuitem":for(h in c)if(c.hasOwnProperty(h)&&(q=c[h],null!=q))switch(h){case "children":case "dangerouslySetInnerHTML":throw Error(u(137,b));default:Z(a,b,h,q,c,null)}return;default:if(Dc(b)){for(l in c)c.hasOwnProperty(l)&&(q=c[l],null!=q&&Wn(a,b,l,q,c,null));
 return}}for(f in c)c.hasOwnProperty(f)&&(q=c[f],null!=q&&Z(a,b,f,q,c,null))}
-function Hj(a,b,c,d){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "input":var e=null,f=null,g=null,h=null,l=null,p=null,q=null;for(u in c){var w=c[u];if(c.hasOwnProperty(u)&&null!=w)switch(u){case "checked":break;case "value":break;case "defaultValue":l=w;default:d.hasOwnProperty(u)||Z(a,b,u,null,d,w)}}for(var r in d){var u=d[r];w=c[r];if(d.hasOwnProperty(r)&&(null!=u||null!=w))switch(r){case "type":f=u;break;case "name":e=u;break;case "checked":p=
-u;break;case "defaultChecked":q=u;break;case "value":g=u;break;case "defaultValue":h=u;break;case "children":case "dangerouslySetInnerHTML":if(null!=u)throw Error(t(137,b));break;default:u!==w&&Z(a,b,r,u,d,w)}}oc(a,g,h,l,p,q,f,e);return;case "select":u=g=h=r=null;for(f in c)if(l=c[f],c.hasOwnProperty(f)&&null!=l)switch(f){case "value":break;case "multiple":u=l;default:d.hasOwnProperty(f)||Z(a,b,f,null,d,l)}for(e in d)if(f=d[e],l=c[e],d.hasOwnProperty(e)&&(null!=f||null!=l))switch(e){case "value":r=
-f;break;case "defaultValue":h=f;break;case "multiple":g=f;default:f!==l&&Z(a,b,e,f,d,l)}b=h;c=g;d=u;null!=r?sc(a,!!c,r,!1):!!d!==!!c&&(null!=b?sc(a,!!c,b,!0):sc(a,!!c,c?[]:"",!1));return;case "textarea":u=r=null;for(h in c)if(e=c[h],c.hasOwnProperty(h)&&null!=e&&!d.hasOwnProperty(h))switch(h){case "value":break;case "children":break;default:Z(a,b,h,null,d,e)}for(g in d)if(e=d[g],f=c[g],d.hasOwnProperty(g)&&(null!=e||null!=f))switch(g){case "value":r=e;break;case "defaultValue":u=e;break;case "children":break;
-case "dangerouslySetInnerHTML":if(null!=e)throw Error(t(91));break;default:e!==f&&Z(a,b,g,e,d,f)}tc(a,r,u);return;case "option":for(var z in c)if(r=c[z],c.hasOwnProperty(z)&&null!=r&&!d.hasOwnProperty(z))switch(z){case "selected":a.selected=!1;break;default:Z(a,b,z,null,d,r)}for(l in d)if(r=d[l],u=c[l],d.hasOwnProperty(l)&&r!==u&&(null!=r||null!=u))switch(l){case "selected":a.selected=r&&"function"!==typeof r&&"symbol"!==typeof r;break;default:Z(a,b,l,r,d,u)}return;case "img":case "link":case "area":case "base":case "br":case "col":case "embed":case "hr":case "keygen":case "meta":case "param":case "source":case "track":case "wbr":case "menuitem":for(var B in c)r=
-c[B],c.hasOwnProperty(B)&&null!=r&&!d.hasOwnProperty(B)&&Z(a,b,B,null,d,r);for(p in d)if(r=d[p],u=c[p],d.hasOwnProperty(p)&&r!==u&&(null!=r||null!=u))switch(p){case "children":case "dangerouslySetInnerHTML":if(null!=r)throw Error(t(137,b));break;default:Z(a,b,p,r,d,u)}return;default:if(Dc(b)){for(var U in c)r=c[U],c.hasOwnProperty(U)&&null!=r&&!d.hasOwnProperty(U)&&Wn(a,b,U,null,d,r);for(q in d)r=d[q],u=c[q],!d.hasOwnProperty(q)||r===u||null==r&&null==u||Wn(a,b,q,r,d,u);return}}for(var V in c)r=c[V],
-c.hasOwnProperty(V)&&null!=r&&!d.hasOwnProperty(V)&&Z(a,b,V,null,d,r);for(w in d)r=d[w],u=c[w],!d.hasOwnProperty(w)||r===u||null==r&&null==u||Z(a,b,w,r,d,u)}var Xi=null,aj=null;function yi(a){return 9===a.nodeType?a:a.ownerDocument}function Ka(a){switch(a){case "http://www.w3.org/2000/svg":return 1;case "http://www.w3.org/1998/Math/MathML":return 2;default:return 0}}
+function Hj(a,b,c,d){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "input":var e=null,f=null,g=null,h=null,l=null,p=null,q=null;for(t in c){var w=c[t];if(c.hasOwnProperty(t)&&null!=w)switch(t){case "checked":break;case "value":break;case "defaultValue":l=w;default:d.hasOwnProperty(t)||Z(a,b,t,null,d,w)}}for(var r in d){var t=d[r];w=c[r];if(d.hasOwnProperty(r)&&(null!=t||null!=w))switch(r){case "type":f=t;break;case "name":e=t;break;case "checked":p=
+t;break;case "defaultChecked":q=t;break;case "value":g=t;break;case "defaultValue":h=t;break;case "children":case "dangerouslySetInnerHTML":if(null!=t)throw Error(u(137,b));break;default:t!==w&&Z(a,b,r,t,d,w)}}oc(a,g,h,l,p,q,f,e);return;case "select":t=g=h=r=null;for(f in c)if(l=c[f],c.hasOwnProperty(f)&&null!=l)switch(f){case "value":break;case "multiple":t=l;default:d.hasOwnProperty(f)||Z(a,b,f,null,d,l)}for(e in d)if(f=d[e],l=c[e],d.hasOwnProperty(e)&&(null!=f||null!=l))switch(e){case "value":r=
+f;break;case "defaultValue":h=f;break;case "multiple":g=f;default:f!==l&&Z(a,b,e,f,d,l)}b=h;c=g;d=t;null!=r?sc(a,!!c,r,!1):!!d!==!!c&&(null!=b?sc(a,!!c,b,!0):sc(a,!!c,c?[]:"",!1));return;case "textarea":t=r=null;for(h in c)if(e=c[h],c.hasOwnProperty(h)&&null!=e&&!d.hasOwnProperty(h))switch(h){case "value":break;case "children":break;default:Z(a,b,h,null,d,e)}for(g in d)if(e=d[g],f=c[g],d.hasOwnProperty(g)&&(null!=e||null!=f))switch(g){case "value":r=e;break;case "defaultValue":t=e;break;case "children":break;
+case "dangerouslySetInnerHTML":if(null!=e)throw Error(u(91));break;default:e!==f&&Z(a,b,g,e,d,f)}tc(a,r,t);return;case "option":for(var z in c)if(r=c[z],c.hasOwnProperty(z)&&null!=r&&!d.hasOwnProperty(z))switch(z){case "selected":a.selected=!1;break;default:Z(a,b,z,null,d,r)}for(l in d)if(r=d[l],t=c[l],d.hasOwnProperty(l)&&r!==t&&(null!=r||null!=t))switch(l){case "selected":a.selected=r&&"function"!==typeof r&&"symbol"!==typeof r;break;default:Z(a,b,l,r,d,t)}return;case "img":case "link":case "area":case "base":case "br":case "col":case "embed":case "hr":case "keygen":case "meta":case "param":case "source":case "track":case "wbr":case "menuitem":for(var B in c)r=
+c[B],c.hasOwnProperty(B)&&null!=r&&!d.hasOwnProperty(B)&&Z(a,b,B,null,d,r);for(p in d)if(r=d[p],t=c[p],d.hasOwnProperty(p)&&r!==t&&(null!=r||null!=t))switch(p){case "children":case "dangerouslySetInnerHTML":if(null!=r)throw Error(u(137,b));break;default:Z(a,b,p,r,d,t)}return;default:if(Dc(b)){for(var U in c)r=c[U],c.hasOwnProperty(U)&&null!=r&&!d.hasOwnProperty(U)&&Wn(a,b,U,null,d,r);for(q in d)r=d[q],t=c[q],!d.hasOwnProperty(q)||r===t||null==r&&null==t||Wn(a,b,q,r,d,t);return}}for(var V in c)r=c[V],
+c.hasOwnProperty(V)&&null!=r&&!d.hasOwnProperty(V)&&Z(a,b,V,null,d,r);for(w in d)r=d[w],t=c[w],!d.hasOwnProperty(w)||r===t||null==r&&null==t||Z(a,b,w,r,d,t)}var Xi=null,aj=null;function yi(a){return 9===a.nodeType?a:a.ownerDocument}function Ka(a){switch(a){case "http://www.w3.org/2000/svg":return 1;case "http://www.w3.org/1998/Math/MathML":return 2;default:return 0}}
 function La(a,b){if(0===a)switch(b){case "svg":return 1;case "math":return 2;default:return 0}return 1===a&&"foreignObject"===b?0:a}function Hd(a,b){return"textarea"===a||"noscript"===a||"string"===typeof b.children||"number"===typeof b.children||"object"===typeof b.dangerouslySetInnerHTML&&null!==b.dangerouslySetInnerHTML&&null!=b.dangerouslySetInnerHTML.__html}var Xn=null;function nf(){var a=window.event;if(a&&"popstate"===a.type){if(a===Xn)return!1;Xn=a;return!0}Xn=null;return!1}
 var uk="function"===typeof setTimeout?setTimeout:void 0,Ck="function"===typeof clearTimeout?clearTimeout:void 0,Yn="function"===typeof Promise?Promise:void 0,qf="function"===typeof queueMicrotask?queueMicrotask:"undefined"!==typeof Yn?function(a){return Yn.resolve(null).then(a).catch(Zn)}:uk;function Zn(a){setTimeout(function(){throw a;})}
 function vj(a,b){var c=b,d=0;do{var e=c.nextSibling;a.removeChild(c);if(e&&8===e.nodeType)if(c=e.data,"/$"===c){if(0===d){a.removeChild(e);wj(b);return}d--}else"$"!==c&&"$?"!==c&&"$!"!==c||d++;c=e}while(c);wj(b)}function bj(a){var b=a.nodeType;if(9===b)$n(a);else if(1===b)switch(a.nodeName){case "HEAD":case "HTML":case "BODY":$n(a);break;default:a.textContent=""}}
@@ -384,7 +383,7 @@ a.getAttribute("href")!==(null==e.href?null:e.href)||a.getAttribute("crossorigin
 return a;default:return a}a=Cd(a);if(null===a)break}return null}function Ad(a,b,c){if(""===b)return null;for(;3!==a.nodeType;){if((1!==a.nodeType||"INPUT"!==a.nodeName||"hidden"!==a.type)&&!c)return null;a=Cd(a);if(null===a)return null}return a}function yd(a){for(;null!=a;a=a.nextSibling){var b=a.nodeType;if(1===b||3===b)break;if(8===b){b=a.data;if("$"===b||"$!"===b||"$?"===b||"F!"===b||"F"===b)break;if("/$"===b)return null}}return a}function Cd(a){return yd(a.nextSibling)}
 function wi(a,b,c,d,e){a[xb]=e;a[yb]=c;d=0!==(e.mode&1);switch(b){case "dialog":Y("cancel",a);Y("close",a);break;case "iframe":case "object":case "embed":Y("load",a);break;case "video":case "audio":for(e=0;e<Kn.length;e++)Y(Kn[e],a);break;case "source":Y("error",a);break;case "img":case "image":case "link":Y("error",a);Y("load",a);break;case "details":Y("toggle",a);break;case "input":Y("invalid",a);qc(a,c.value,c.defaultValue,c.checked,c.defaultChecked,c.type,c.name,!0);jc(a);break;case "select":Y("invalid",
 a);break;case "textarea":Y("invalid",a),uc(a,c.value,c.defaultValue,c.children),jc(a)}e=c.children;"string"!==typeof e&&"number"!==typeof e||a.textContent===""+e||(!0!==c.suppressHydrationWarning&&Ai(a.textContent,e,d),d||"body"===b||(a.textContent=e));null!=c.onScroll&&Y("scroll",a);null!=c.onScrollEnd&&Y("scrollend",a);null!=c.onClick&&(a.onclick=pj)}
-function Ib(a){a=a.previousSibling;for(var b=0;a;){if(8===a.nodeType){var c=a.data;if("$"===c||"$!"===c||"$?"===c){if(0===b)return a;b--}else"/$"===c&&b++}a=a.previousSibling}return null}function xi(a,b,c){b=yi(c);switch(a){case "html":a=b.documentElement;if(!a)throw Error(t(452));return a;case "head":a=b.head;if(!a)throw Error(t(453));return a;case "body":a=b.body;if(!a)throw Error(t(454));return a;default:throw Error(t(451));}}var ao=new Map,bo=new Set;
+function Ib(a){a=a.previousSibling;for(var b=0;a;){if(8===a.nodeType){var c=a.data;if("$"===c||"$!"===c||"$?"===c){if(0===b)return a;b--}else"/$"===c&&b++}a=a.previousSibling}return null}function xi(a,b,c){b=yi(c);switch(a){case "html":a=b.documentElement;if(!a)throw Error(u(452));return a;case "head":a=b.head;if(!a)throw Error(u(453));return a;case "body":a=b.body;if(!a)throw Error(u(454));return a;default:throw Error(u(451));}}var ao=new Map,bo=new Set;
 function Jj(a){return"function"===typeof a.getRootNode?a.getRootNode():a.ownerDocument}var ko={prefetchDNS:co,preconnect:eo,preload:fo,preloadModule:go,preinitStyle:ho,preinitScript:io,preinitModuleScript:jo};
 function lo(a,b,c){var d=document;if("string"===typeof b&&b){var e=nc(b);e='link[rel="'+a+'"][href="'+e+'"]';"string"===typeof c&&(e+='[crossorigin="'+c+'"]');bo.has(e)||(bo.add(e),a={rel:a,crossOrigin:c,href:b},null===d.querySelector(e)&&(b=d.createElement("link"),zi(b,"link",a),Nb(b),d.head.appendChild(b)))}}function co(a){lo("dns-prefetch",a,null)}function eo(a,b){lo("preconnect",a,b)}
 function fo(a,b,c){var d=document;if(a&&b&&d){var e='link[rel="preload"][as="'+nc(b)+'"]';"image"===b?c&&c.imageSrcSet?(e+='[imagesrcset="'+nc(c.imageSrcSet)+'"]',"string"===typeof c.imageSizes&&(e+='[imagesizes="'+nc(c.imageSizes)+'"]')):e+='[href="'+nc(a)+'"]':e+='[href="'+nc(a)+'"]';var f=e;switch(b){case "style":f=mo(a);break;case "script":f=no(a)}ao.has(f)||(a=C({rel:"preload",href:"image"===b&&c&&c.imageSrcSet?void 0:a,as:b},c),ao.set(f,a),null!==d.querySelector(e)||"style"===b&&d.querySelector(oo(f))||
@@ -394,38 +393,40 @@ zi(d,"link",a);Nb(d);c.head.appendChild(d)}}}
 function ho(a,b,c){var d=document;if(a){var e=Mb(d).hoistableStyles,f=mo(a);b=b||"default";var g=e.get(f);if(!g){var h={loading:0,preload:null};if(g=d.querySelector(oo(f)))h.loading=5;else{a=C({rel:"stylesheet",href:a,"data-precedence":b},c);(c=ao.get(f))&&qo(a,c);var l=g=d.createElement("link");Nb(l);zi(l,"link",a);l._p=new Promise(function(p,q){l.onload=p;l.onerror=q});l.addEventListener("load",function(){h.loading|=1});l.addEventListener("error",function(){h.loading|=2});h.loading|=4;ro(g,b,d)}g=
 {type:"stylesheet",instance:g,count:1,state:h};e.set(f,g)}}}function io(a,b){var c=document;if(a){var d=Mb(c).hoistableScripts,e=no(a),f=d.get(e);f||(f=c.querySelector(po(e)),f||(a=C({src:a,async:!0},b),(b=ao.get(e))&&so(a,b),f=c.createElement("script"),Nb(f),zi(f,"link",a),c.head.appendChild(f)),f={type:"script",instance:f,count:1,state:null},d.set(e,f))}}
 function jo(a,b){var c=document;if(a){var d=Mb(c).hoistableScripts,e=no(a),f=d.get(e);f||(f=c.querySelector(po(e)),f||(a=C({src:a,async:!0,type:"module"},b),(b=ao.get(e))&&so(a,b),f=c.createElement("script"),Nb(f),zi(f,"link",a),c.head.appendChild(f)),f={type:"script",instance:f,count:1,state:null},d.set(e,f))}}
-function Vk(a,b,c){b=(b=Ga.current)?Jj(b):null;if(!b)throw Error(t(446));switch(a){case "meta":case "title":return null;case "style":return"string"===typeof c.precedence&&"string"===typeof c.href?(c=mo(c.href),b=Mb(b).hoistableStyles,a=b.get(c),a||(a={type:"style",instance:null,count:0,state:null},b.set(c,a)),a):{type:"void",instance:null,count:0,state:null};case "link":if("stylesheet"===c.rel&&"string"===typeof c.href&&"string"===typeof c.precedence){a=mo(c.href);var d=Mb(b).hoistableStyles,e=d.get(a);
+function Vk(a,b,c){b=(b=Ga.current)?Jj(b):null;if(!b)throw Error(u(446));switch(a){case "meta":case "title":return null;case "style":return"string"===typeof c.precedence&&"string"===typeof c.href?(c=mo(c.href),b=Mb(b).hoistableStyles,a=b.get(c),a||(a={type:"style",instance:null,count:0,state:null},b.set(c,a)),a):{type:"void",instance:null,count:0,state:null};case "link":if("stylesheet"===c.rel&&"string"===typeof c.href&&"string"===typeof c.precedence){a=mo(c.href);var d=Mb(b).hoistableStyles,e=d.get(a);
 e||(b=b.ownerDocument||b,e={type:"stylesheet",instance:null,count:0,state:{loading:0,preload:null}},d.set(a,e),ao.has(a)||to(b,a,{rel:"preload",as:"style",href:c.href,crossOrigin:c.crossOrigin,integrity:c.integrity,media:c.media,hrefLang:c.hrefLang,referrerPolicy:c.referrerPolicy},e.state));return e}return null;case "script":return"string"===typeof c.src&&!0===c.async?(c=no(c.src),b=Mb(b).hoistableScripts,a=b.get(c),a||(a={type:"script",instance:null,count:0,state:null},b.set(c,a)),a):{type:"void",
-instance:null,count:0,state:null};default:throw Error(t(444,a));}}function mo(a){return'href="'+nc(a)+'"'}function oo(a){return'link[rel="stylesheet"]['+a+"]"}function uo(a){return C({},a,{"data-precedence":a.precedence,precedence:null})}
+instance:null,count:0,state:null};default:throw Error(u(444,a));}}function mo(a){return'href="'+nc(a)+'"'}function oo(a){return'link[rel="stylesheet"]['+a+"]"}function uo(a){return C({},a,{"data-precedence":a.precedence,precedence:null})}
 function to(a,b,c,d){ao.set(b,c);a.querySelector(oo(b))||(a.querySelector('link[rel="preload"][as="style"]['+b+"]")?d.loading=1:(b=a.createElement("link"),d.preload=b,b.addEventListener("load",function(){return d.loading|=1}),b.addEventListener("error",function(){return d.loading|=2}),zi(b,"link",c),Nb(b),a.head.appendChild(b)))}function no(a){return'[src="'+nc(a)+'"]'}function po(a){return"script[async]"+a}
 function Gj(a,b,c){b.count++;if(null===b.instance)switch(b.type){case "style":var d=a.querySelector('style[data-href~="'+nc(c.href)+'"]');if(d)return b.instance=d,Nb(d),d;var e=C({},c,{"data-href":c.href,"data-precedence":c.precedence,href:null,precedence:null});d=(a.ownerDocument||a).createElement("style");Nb(d);zi(d,"style",e);ro(d,c.precedence,a);return b.instance=d;case "stylesheet":e=mo(c.href);var f=a.querySelector(oo(e));if(f)return b.state.loading|=4,b.instance=f,Nb(f),f;d=uo(c);(e=ao.get(e))&&
-qo(d,e);f=(a.ownerDocument||a).createElement("link");Nb(f);var g=f;g._p=new Promise(function(h,l){g.onload=h;g.onerror=l});zi(f,"link",d);b.state.loading|=4;ro(f,c.precedence,a);return b.instance=f;case "script":f=no(c.src);if(e=a.querySelector(po(f)))return b.instance=e,Nb(e),e;d=c;if(e=ao.get(f))d=C({},c),so(d,e);a=a.ownerDocument||a;e=a.createElement("script");Nb(e);zi(e,"link",d);a.head.appendChild(e);return b.instance=e;case "void":return null;default:throw Error(t(443,b.type));}else"stylesheet"===
+qo(d,e);f=(a.ownerDocument||a).createElement("link");Nb(f);var g=f;g._p=new Promise(function(h,l){g.onload=h;g.onerror=l});zi(f,"link",d);b.state.loading|=4;ro(f,c.precedence,a);return b.instance=f;case "script":f=no(c.src);if(e=a.querySelector(po(f)))return b.instance=e,Nb(e),e;d=c;if(e=ao.get(f))d=C({},c),so(d,e);a=a.ownerDocument||a;e=a.createElement("script");Nb(e);zi(e,"link",d);a.head.appendChild(e);return b.instance=e;case "void":return null;default:throw Error(u(443,b.type));}else"stylesheet"===
 b.type&&0===(b.state.loading&4)&&(d=b.instance,b.state.loading|=4,ro(d,c.precedence,a));return b.instance}function ro(a,b,c){for(var d=c.querySelectorAll('link[rel="stylesheet"][data-precedence],style[data-precedence]'),e=d.length?d[d.length-1]:null,f=e,g=0;g<d.length;g++){var h=d[g];if(h.dataset.precedence===b)f=h;else if(f!==e)break}f?f.parentNode.insertBefore(a,f.nextSibling):(b=9===c.nodeType?c.head:c,b.insertBefore(a,b.firstChild))}
 function qo(a,b){null==a.crossOrigin&&(a.crossOrigin=b.crossOrigin);null==a.referrerPolicy&&(a.referrerPolicy=b.referrerPolicy);null==a.title&&(a.title=b.title)}function so(a,b){null==a.crossOrigin&&(a.crossOrigin=b.crossOrigin);null==a.referrerPolicy&&(a.referrerPolicy=b.referrerPolicy);null==a.integrity&&(a.integrity=b.integrity)}var Ij=null;
 function Ej(a,b,c){if(null===Ij){var d=new Map;var e=Ij=new Map;e.set(c,d)}else e=Ij,d=e.get(c),d||(d=new Map,e.set(c,d));if(d.has(a))return d;d.set(a,null);c=c.getElementsByTagName(a);for(e=0;e<c.length;e++){var f=c[e];if(!(f[Fb]||f[xb]||"link"===a&&"stylesheet"===f.getAttribute("rel"))&&"http://www.w3.org/2000/svg"!==f.namespaceURI){var g=f.getAttribute(b)||"";g=a+g;var h=d.get(g);h?h.push(f):d.set(g,[f])}}return d}
 function Fj(a,b,c){a=a.ownerDocument||a;a.head.insertBefore(c,"title"===b?a.querySelector("head > title"):null)}
 function Xk(a,b,c){if(1===c||null!=b.itemProp)return!1;switch(a){case "meta":case "title":return!0;case "style":if("string"!==typeof b.precedence||"string"!==typeof b.href||""===b.href)break;return!0;case "link":if("string"!==typeof b.rel||"string"!==typeof b.href||""===b.href||b.onLoad||b.onError)break;switch(b.rel){case "stylesheet":return a=b.disabled,"string"===typeof b.precedence&&null==a;default:return!0}case "script":if(!0===b.async&&!b.onLoad&&!b.onError&&"string"===typeof b.src&&b.src)return!0}return!1}
 var wk=null;function xk(){}
-function Wj(a,b,c){if(null===wk)throw Error(t(475));var d=wk;if("stylesheet"===b.type&&("string"!==typeof c.media||!1!==matchMedia(c.media).matches)&&0===(b.state.loading&4)){if(null===b.instance){var e=mo(c.href),f=a.querySelector(oo(e));if(f){a=f._p;null!==a&&"object"===typeof a&&"function"===typeof a.then&&(d.count++,d=vo.bind(d),a.then(d,d));b.state.loading|=4;b.instance=f;Nb(f);return}f=a.ownerDocument||a;c=uo(c);(e=ao.get(e))&&qo(c,e);f=f.createElement("link");Nb(f);var g=f;g._p=new Promise(function(h,
+function Wj(a,b,c){if(null===wk)throw Error(u(475));var d=wk;if("stylesheet"===b.type&&("string"!==typeof c.media||!1!==matchMedia(c.media).matches)&&0===(b.state.loading&4)){if(null===b.instance){var e=mo(c.href),f=a.querySelector(oo(e));if(f){a=f._p;null!==a&&"object"===typeof a&&"function"===typeof a.then&&(d.count++,d=vo.bind(d),a.then(d,d));b.state.loading|=4;b.instance=f;Nb(f);return}f=a.ownerDocument||a;c=uo(c);(e=ao.get(e))&&qo(c,e);f=f.createElement("link");Nb(f);var g=f;g._p=new Promise(function(h,
 l){g.onload=h;g.onerror=l});zi(f,"link",c);b.instance=f}null===d.stylesheets&&(d.stylesheets=new Map);d.stylesheets.set(b,a);(a=b.state.preload)&&0===(b.state.loading&3)&&(d.count++,b=vo.bind(d),a.addEventListener("load",b),a.addEventListener("error",b))}}
-function yk(){if(null===wk)throw Error(t(475));var a=wk;a.stylesheets&&0===a.count&&wo(a,a.stylesheets);return 0<a.count?function(b){var c=setTimeout(function(){a.stylesheets&&wo(a,a.stylesheets);if(a.unsuspend){var d=a.unsuspend;a.unsuspend=null;d()}},6E4);a.unsuspend=b;return function(){a.unsuspend=null;clearTimeout(c)}}:null}function vo(){this.count--;if(0===this.count)if(this.stylesheets)wo(this,this.stylesheets);else if(this.unsuspend){var a=this.unsuspend;this.unsuspend=null;a()}}var xo=null;
+function yk(){if(null===wk)throw Error(u(475));var a=wk;a.stylesheets&&0===a.count&&wo(a,a.stylesheets);return 0<a.count?function(b){var c=setTimeout(function(){a.stylesheets&&wo(a,a.stylesheets);if(a.unsuspend){var d=a.unsuspend;a.unsuspend=null;d()}},6E4);a.unsuspend=b;return function(){a.unsuspend=null;clearTimeout(c)}}:null}function vo(){this.count--;if(0===this.count)if(this.stylesheets)wo(this,this.stylesheets);else if(this.unsuspend){var a=this.unsuspend;this.unsuspend=null;a()}}var xo=null;
 function wo(a,b){a.stylesheets=null;null!==a.unsuspend&&(a.count++,xo=new Map,b.forEach(yo,a),xo=null,vo.call(a))}
 function yo(a,b){if(!(b.state.loading&4)){var c=xo.get(a);if(c)var d=c.get("last");else{c=new Map;xo.set(a,c);for(var e=a.querySelectorAll("link[data-precedence],style[data-precedence]"),f=0;f<e.length;f++){var g=e[f];if("link"===g.nodeName||"not all"!==g.getAttribute("media"))c.set("p"+g.dataset.precedence,g),d=g}d&&c.set("last",d)}e=b.instance;g=e.getAttribute("data-precedence");f=c.get("p"+g)||d;f===d&&c.set("last",e);c.set(g,e);this.count++;d=vo.bind(this);e.addEventListener("load",d);e.addEventListener("error",
-d);f?f.parentNode.insertBefore(e,f.nextSibling):(a=9===a.nodeType?a.head:a,a.insertBefore(e,a.firstChild));b.state.loading|=4}}var zo=ca.Dispatcher;"undefined"!==typeof document&&(zo.current=ko);var Ao="function"===typeof reportError?reportError:function(a){console.error(a)};function Bo(a){this._internalRoot=a}Co.prototype.render=Bo.prototype.render=function(a){var b=this._internalRoot;if(null===b)throw Error(t(409));cl(a,b,null,null)};
+d);f?f.parentNode.insertBefore(e,f.nextSibling):(a=9===a.nodeType?a.head:a,a.insertBefore(e,a.firstChild));b.state.loading|=4}}var zo=ca.Dispatcher;"undefined"!==typeof document&&(zo.current=ko);var Ao="function"===typeof reportError?reportError:function(a){console.error(a)};function Bo(a){this._internalRoot=a}Co.prototype.render=Bo.prototype.render=function(a){var b=this._internalRoot;if(null===b)throw Error(u(409));cl(a,b,null,null)};
 Co.prototype.unmount=Bo.prototype.unmount=function(){var a=this._internalRoot;if(null!==a){this._internalRoot=null;var b=a.containerInfo;Ak(function(){cl(null,a,null,null)});b[zb]=null}};function Co(a){this._internalRoot=a}Co.prototype.unstable_scheduleHydration=function(a){if(a){var b=F;a={blockedOn:null,target:a,priority:b};for(var c=0;c<gm.length&&0!==b&&b<gm[c].priority;c++);gm.splice(c,0,a);0===c&&lm(a)}};function Do(a){return!(!a||1!==a.nodeType&&9!==a.nodeType&&11!==a.nodeType)}
 function Eo(a){return!(!a||1!==a.nodeType&&9!==a.nodeType&&11!==a.nodeType&&(8!==a.nodeType||" react-mount-point-unstable "!==a.nodeValue))}function Fo(){}
 function Go(a,b,c,d,e){if(e){if("function"===typeof d){var f=d;d=function(){var p=dl(g);f.call(p)}}var g=bl(b,d,a,0,null,!1,!1,"",Fo,null,null);a._reactRootContainer=g;a[zb]=g.current;Bi(8===a.nodeType?a.parentNode:a);Ak();return g}bj(a);if("function"===typeof d){var h=d;d=function(){var p=dl(l);h.call(p)}}var l=Zk(a,0,!1,null,null,!1,!1,"",Fo,null,null);a._reactRootContainer=l;a[zb]=l.current;Bi(8===a.nodeType?a.parentNode:a);Ak(function(){cl(b,l,c,d)});return l}
-function Ho(a,b,c,d,e){var f=c._reactRootContainer;if(f){var g=f;if("function"===typeof e){var h=e;e=function(){var l=dl(g);h.call(l)}}cl(b,g,a,e)}else g=Go(c,b,a,e,d);return dl(g)}function Io(a,b){if("font"===a)return"";if("string"===typeof b)return"use-credentials"===b?b:""}var Jo=ca.Dispatcher;ca.Events=[Jb,Kb,Lb,Kc,Lc,zk];var Ko={findFiberByHostInstance:Hb,bundleType:0,version:"18.3.0-canary-2983249dd-20231107",rendererPackageName:"react-dom"};
+function Ho(a,b,c,d,e){var f=c._reactRootContainer;if(f){var g=f;if("function"===typeof e){var h=e;e=function(){var l=dl(g);h.call(l)}}cl(b,g,a,e)}else g=Go(c,b,a,e,d);return dl(g)}function Io(a,b){if("font"===a)return"";if("string"===typeof b)return"use-credentials"===b?b:""}var Jo=ca.Dispatcher;ca.Events=[Jb,Kb,Lb,Kc,Lc,zk];var Ko={findFiberByHostInstance:Hb,bundleType:0,version:"18.3.0-canary-7508dcd5c-20231108",rendererPackageName:"react-dom"};
 var Lo={bundleType:Ko.bundleType,version:Ko.version,rendererPackageName:Ko.rendererPackageName,rendererConfig:Ko.rendererConfig,overrideHookState:null,overrideHookStateDeletePath:null,overrideHookStateRenamePath:null,overrideProps:null,overridePropsDeletePath:null,overridePropsRenamePath:null,setErrorHandler:null,setSuspenseHandler:null,scheduleUpdate:null,currentDispatcherRef:da.ReactCurrentDispatcher,findHostInstanceByFiber:function(a){a=Qc(a);return null===a?null:a.stateNode},findFiberByHostInstance:Ko.findFiberByHostInstance||
-il,findHostInstancesForRefresh:null,scheduleRefresh:null,scheduleRoot:null,setRefreshHandler:null,getCurrentFiber:null,reconcilerVersion:"18.3.0-canary-2983249dd-20231107"};if("undefined"!==typeof __REACT_DEVTOOLS_GLOBAL_HOOK__){var Mo=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(!Mo.isDisabled&&Mo.supportsFiber)try{$a=Mo.inject(Lo),ab=Mo}catch(a){}}exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=ca;
-exports.createPortal=function(a,b){var c=2<arguments.length&&void 0!==arguments[2]?arguments[2]:null;if(!Do(b))throw Error(t(200));return $k(a,b,null,c)};
-exports.createRoot=function(a,b){if(!Do(a))throw Error(t(299));var c=!1,d="",e=Ao,f=null;null!==b&&void 0!==b&&(!0===b.unstable_strictMode&&(c=!0),void 0!==b.identifierPrefix&&(d=b.identifierPrefix),void 0!==b.onRecoverableError&&(e=b.onRecoverableError),void 0!==b.unstable_transitionCallbacks&&(f=b.unstable_transitionCallbacks));b=Zk(a,1,!1,null,null,c,!1,d,e,f,null);a[zb]=b.current;zo.current=ko;Bi(8===a.nodeType?a.parentNode:a);return new Bo(b)};
-exports.findDOMNode=function(a){if(null==a)return null;if(1===a.nodeType)return a;var b=a._reactInternals;if(void 0===b){if("function"===typeof a.render)throw Error(t(188));a=Object.keys(a).join(",");throw Error(t(268,a));}a=Qc(b);a=null===a?null:a.stateNode;return a};exports.flushSync=function(a){return Ak(a)};exports.hydrate=function(a,b,c){if(!Eo(b))throw Error(t(200));return Ho(null,a,b,!0,c)};
-exports.hydrateRoot=function(a,b,c){if(!Do(a))throw Error(t(405));var d=!1,e="",f=Ao,g=null,h=null;null!==c&&void 0!==c&&(!0===c.unstable_strictMode&&(d=!0),void 0!==c.identifierPrefix&&(e=c.identifierPrefix),void 0!==c.onRecoverableError&&(f=c.onRecoverableError),void 0!==c.unstable_transitionCallbacks&&(g=c.unstable_transitionCallbacks),void 0!==c.formState&&(h=c.formState));b=bl(b,null,a,1,null!=c?c:null,d,!1,e,f,g,h);a[zb]=b.current;zo.current=ko;Bi(a);return new Co(b)};
+il,findHostInstancesForRefresh:null,scheduleRefresh:null,scheduleRoot:null,setRefreshHandler:null,getCurrentFiber:null,reconcilerVersion:"18.3.0-canary-7508dcd5c-20231108"};if("undefined"!==typeof __REACT_DEVTOOLS_GLOBAL_HOOK__){var Mo=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(!Mo.isDisabled&&Mo.supportsFiber)try{$a=Mo.inject(Lo),ab=Mo}catch(a){}}exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=ca;
+exports.createPortal=function(a,b){var c=2<arguments.length&&void 0!==arguments[2]?arguments[2]:null;if(!Do(b))throw Error(u(200));return $k(a,b,null,c)};
+exports.createRoot=function(a,b){if(!Do(a))throw Error(u(299));var c=!1,d="",e=Ao,f=null;null!==b&&void 0!==b&&(!0===b.unstable_strictMode&&(c=!0),void 0!==b.identifierPrefix&&(d=b.identifierPrefix),void 0!==b.onRecoverableError&&(e=b.onRecoverableError),void 0!==b.unstable_transitionCallbacks&&(f=b.unstable_transitionCallbacks));b=Zk(a,1,!1,null,null,c,!1,d,e,f,null);a[zb]=b.current;zo.current=ko;Bi(8===a.nodeType?a.parentNode:a);return new Bo(b)};
+exports.findDOMNode=function(a){if(null==a)return null;if(1===a.nodeType)return a;var b=a._reactInternals;if(void 0===b){if("function"===typeof a.render)throw Error(u(188));a=Object.keys(a).join(",");throw Error(u(268,a));}a=Qc(b);a=null===a?null:a.stateNode;return a};exports.flushSync=function(a){return Ak(a)};exports.hydrate=function(a,b,c){if(!Eo(b))throw Error(u(200));return Ho(null,a,b,!0,c)};
+exports.hydrateRoot=function(a,b,c){if(!Do(a))throw Error(u(405));var d=!1,e="",f=Ao,g=null,h=null;null!==c&&void 0!==c&&(!0===c.unstable_strictMode&&(d=!0),void 0!==c.identifierPrefix&&(e=c.identifierPrefix),void 0!==c.onRecoverableError&&(f=c.onRecoverableError),void 0!==c.unstable_transitionCallbacks&&(g=c.unstable_transitionCallbacks),void 0!==c.formState&&(h=c.formState));b=bl(b,null,a,1,null!=c?c:null,d,!1,e,f,g,h);a[zb]=b.current;zo.current=ko;Bi(a);return new Co(b)};
 exports.preconnect=function(a,b){var c=Jo.current;c&&"string"===typeof a&&(b?(b=b.crossOrigin,b="string"===typeof b?"use-credentials"===b?b:"":void 0):b=null,c.preconnect(a,b))};exports.prefetchDNS=function(a){var b=Jo.current;b&&"string"===typeof a&&b.prefetchDNS(a)};
 exports.preinit=function(a,b){var c=Jo.current;if(c&&"string"===typeof a&&b&&"string"===typeof b.as){var d=b.as,e=Io(d,b.crossOrigin),f="string"===typeof b.integrity?b.integrity:void 0,g="string"===typeof b.fetchPriority?b.fetchPriority:void 0;"style"===d?c.preinitStyle(a,"string"===typeof b.precedence?b.precedence:void 0,{crossOrigin:e,integrity:f,fetchPriority:g}):"script"===d&&c.preinitScript(a,{crossOrigin:e,integrity:f,fetchPriority:g,nonce:"string"===typeof b.nonce?b.nonce:void 0})}};
 exports.preinitModule=function(a,b){var c=Jo.current;if(c&&"string"===typeof a)if("object"===typeof b&&null!==b){if(null==b.as||"script"===b.as){var d=Io(b.as,b.crossOrigin);c.preinitModuleScript(a,{crossOrigin:d,integrity:"string"===typeof b.integrity?b.integrity:void 0,nonce:"string"===typeof b.nonce?b.nonce:void 0})}}else null==b&&c.preinitModuleScript(a)};
 exports.preload=function(a,b){var c=Jo.current;if(c&&"string"===typeof a&&"object"===typeof b&&null!==b&&"string"===typeof b.as){var d=b.as,e=Io(d,b.crossOrigin);c.preload(a,d,{crossOrigin:e,integrity:"string"===typeof b.integrity?b.integrity:void 0,nonce:"string"===typeof b.nonce?b.nonce:void 0,type:"string"===typeof b.type?b.type:void 0,fetchPriority:"string"===typeof b.fetchPriority?b.fetchPriority:void 0,referrerPolicy:"string"===typeof b.referrerPolicy?b.referrerPolicy:void 0,imageSrcSet:"string"===
-typeof b.imageSrcSet?b.imageSrcSet:void 0,imageSizes:"string"===typeof b.imageSizes?b.imageSizes:void 0})}};exports.preloadModule=function(a,b){var c=Jo.current;if(c&&"string"===typeof a)if(b){var d=Io(b.as,b.crossOrigin);c.preloadModule(a,{as:"string"===typeof b.as&&"script"!==b.as?b.as:void 0,crossOrigin:d,integrity:"string"===typeof b.integrity?b.integrity:void 0})}else c.preloadModule(a)};exports.render=function(a,b,c){if(!Eo(b))throw Error(t(200));return Ho(null,a,b,!1,c)};
-exports.unmountComponentAtNode=function(a){if(!Eo(a))throw Error(t(40));return a._reactRootContainer?(Ak(function(){Ho(null,null,a,!1,function(){a._reactRootContainer=null;a[zb]=null})}),!0):!1};exports.unstable_batchedUpdates=zk;exports.unstable_renderSubtreeIntoContainer=function(a,b,c,d){if(!Eo(c))throw Error(t(200));if(null==a||void 0===a._reactInternals)throw Error(t(38));return Ho(a,b,c,!1,d)};exports.useFormState=function(a,b,c){return ea.current.useFormState(a,b,c)};
-exports.useFormStatus=function(){return ea.current.useHostTransitionStatus()};exports.version="18.3.0-canary-2983249dd-20231107";
+typeof b.imageSrcSet?b.imageSrcSet:void 0,imageSizes:"string"===typeof b.imageSizes?b.imageSizes:void 0})}};exports.preloadModule=function(a,b){var c=Jo.current;if(c&&"string"===typeof a)if(b){var d=Io(b.as,b.crossOrigin);c.preloadModule(a,{as:"string"===typeof b.as&&"script"!==b.as?b.as:void 0,crossOrigin:d,integrity:"string"===typeof b.integrity?b.integrity:void 0})}else c.preloadModule(a)};exports.render=function(a,b,c){if(!Eo(b))throw Error(u(200));return Ho(null,a,b,!1,c)};
+exports.unmountComponentAtNode=function(a){if(!Eo(a))throw Error(u(40));return a._reactRootContainer?(Ak(function(){Ho(null,null,a,!1,function(){a._reactRootContainer=null;a[zb]=null})}),!0):!1};exports.unstable_batchedUpdates=zk;exports.unstable_renderSubtreeIntoContainer=function(a,b,c,d){if(!Eo(c))throw Error(u(200));if(null==a||void 0===a._reactInternals)throw Error(u(38));return Ho(a,b,c,!1,d)};exports.useFormState=function(a,b,c){return ea.current.useFormState(a,b,c)};
+exports.useFormStatus=function(){return ea.current.useHostTransitionStatus()};exports.version="18.3.0-canary-7508dcd5c-20231108";
+
+//# sourceMappingURL=react-dom.production.min.js.map
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom.profiling.js b/packages/next/src/compiled/react-dom/cjs/react-dom.profiling.js
new file mode 100644
index 0000000000000..ee8b79e17f147
--- /dev/null
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom.profiling.js
@@ -0,0 +1,28900 @@
+/**
+ * @license React
+ * react-dom.profiling.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+          'use strict';
+
+/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+if (
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===
+    'function'
+) {
+  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+}
+          var React = require("next/dist/compiled/react");
+var Scheduler = require("next/dist/compiled/scheduler");
+
+const Internals = {
+  usingClientEntryPoint: false,
+  Events: null,
+  Dispatcher: {
+    current: null
+  }
+};
+
+// Do not require this module directly! Use normal `invariant` calls with
+// template literal strings. The messages will be replaced with error codes
+// during build.
+function formatProdErrorMessage(code) {
+  let url = 'https://reactjs.org/docs/error-decoder.html?invariant=' + code;
+
+  for (let i = 1; i < arguments.length; i++) {
+    url += '&args[]=' + encodeURIComponent(arguments[i]);
+  }
+
+  return "Minified React error #" + code + "; visit " + url + " for the full message or " + 'use the non-minified dev environment for full errors and additional ' + 'helpful warnings.';
+}
+
+const assign = Object.assign;
+
+// -----------------------------------------------------------------------------
+// Killswitch
+//
+// Flags that exist solely to turn off a change in case it causes a regression
+// when it rolls out to prod. We should remove these as soon as possible.
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+// Land or remove (moderate effort)
+//
+// Flags that can be probably deleted or landed, but might require extra effort
+// like migrating internal callers or performance testing.
+// -----------------------------------------------------------------------------
+// TODO: Finish rolling out in www
+
+const enableClientRenderFallbackOnTextMismatch = true;
+const enableFormActions = true;
+const enableAsyncActions = true; // Not sure if www still uses this. We don't have a replacement but whatever we
+// Slated for removal in the future (significant effort)
+//
+// These are experiments that didn't work out, and never shipped, but we can't
+// delete from the codebase until we migrate internal callers.
+// -----------------------------------------------------------------------------
+// Add a callback property to suspense to notify which promises are currently
+// in the update queue. This allows reporting and tracing of what is causing
+// the user to see a loading state.
+//
+// Also allows hydration callbacks to fire when a dehydrated boundary gets
+// hydrated or deleted.
+//
+// This will eventually be replaced by the Transition Tracing proposal.
+
+const enableSuspenseCallback = false; // Experimental Scope support.
+
+const enableLazyContextPropagation = false; // FB-only usage. The new API has different semantics.
+
+const enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber
+const enableHostSingletons = true;
+const alwaysThrottleRetries = true;
+// Chopping Block
+//
+// Planned feature deprecations and breaking changes. Sorted roughly in order of
+// when we plan to enable them.
+// -----------------------------------------------------------------------------
+// This flag enables Strict Effects by default. We're not turning this on until
+// after 18 because it requires migration work. Recommendation is to use
+// <StrictMode /> to gradually upgrade components.
+// If TRUE, trees rendered with createRoot will be StrictEffectsMode.
+// If FALSE, these trees will be StrictLegacyMode.
+
+const createRootStrictEffectsByDefault = false;
+// React DOM Chopping Block
+//
+// Similar to main Chopping Block but only flags related to React DOM. These are
+// grouped because we will likely batch all of them into a single major release.
+// -----------------------------------------------------------------------------
+// Disable support for comment nodes as React DOM containers. Already disabled
+// in open source, but www codebase still relies on it. Need to remove.
+
+const disableCommentsAsDOMContainers = true; // Disable javascript: URL strings in href for XSS protection.
+// Debugging and DevTools
+// -----------------------------------------------------------------------------
+// Adds user timing marks for e.g. state updates, suspense, and work loop stuff,
+// for an experimental timeline tool.
+
+const enableSchedulingProfiler = true; // Helps identify side effects in render-phase lifecycle hooks and setState
+
+const enableProfilerTimer = true; // Record durations for commit and passive effects phases.
+
+const enableProfilerCommitHooks = true; // Phase param passed to onRender callback differentiates between an "update" and a "cascading-update".
+
+const enableProfilerNestedUpdatePhase = true; // Adds verbose console logging for e.g. state updates, suspense, and work loop
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactCurrentDispatcher$2 = ReactSharedInternals.ReactCurrentDispatcher; // Since the "not pending" value is always the same, we can reuse the
+// same object across all transitions.
+
+const sharedNotPendingObject = {
+  pending: false,
+  data: null,
+  method: null,
+  action: null
+};
+const NotPending = sharedNotPendingObject;
+
+function resolveDispatcher() {
+  // Copied from react/src/ReactHooks.js. It's the same thing but in a
+  // different package.
+  const dispatcher = ReactCurrentDispatcher$2.current;
+  // intentionally don't throw our own error because this is in a hot path.
+  // Also helps ensure this is inlined.
+
+
+  return dispatcher;
+}
+
+function useFormStatus() {
+  {
+    const dispatcher = resolveDispatcher(); // $FlowFixMe[not-a-function] We know this exists because of the feature check above.
+
+    return dispatcher.useHostTransitionStatus();
+  }
+}
+function useFormState(action, initialState, permalink) {
+  {
+    const dispatcher = resolveDispatcher(); // $FlowFixMe[not-a-function] This is unstable, thus optional
+
+    return dispatcher.useFormState(action, initialState, permalink);
+  }
+}
+
+const valueStack = [];
+
+let index = -1;
+
+function createCursor(defaultValue) {
+  return {
+    current: defaultValue
+  };
+}
+
+function pop(cursor, fiber) {
+  if (index < 0) {
+
+    return;
+  }
+
+  cursor.current = valueStack[index];
+  valueStack[index] = null;
+
+  index--;
+}
+
+function push(cursor, value, fiber) {
+  index++;
+  valueStack[index] = cursor.current;
+
+  cursor.current = value;
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+const REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_CONTEXT_TYPE = Symbol.for('react.context');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SCOPE_TYPE = Symbol.for('react.scope');
+const REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');
+const REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+const REACT_LEGACY_HIDDEN_TYPE = Symbol.for('react.legacy_hidden');
+const REACT_CACHE_TYPE = Symbol.for('react.cache');
+const REACT_TRACING_MARKER_TYPE = Symbol.for('react.tracing_marker');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+const contextStackCursor$1 = createCursor(null);
+const contextFiberStackCursor = createCursor(null);
+const rootInstanceStackCursor = createCursor(null); // Represents the nearest host transition provider (in React DOM, a <form />)
+// NOTE: Since forms cannot be nested, and this feature is only implemented by
+// React DOM, we don't technically need this to be a stack. It could be a single
+// module variable instead.
+
+const hostTransitionProviderCursor = createCursor(null); // TODO: This should initialize to NotPendingTransition, a constant
+// imported from the fiber config. However, because of a cycle in the module
+// graph, that value isn't defined during this module's initialization. I can't
+// think of a way to work around this without moving that value out of the
+// fiber config. For now, the "no provider" case is handled when reading,
+// inside useHostTransitionStatus.
+
+const HostTransitionContext = {
+  $$typeof: REACT_CONTEXT_TYPE,
+  _currentValue: null,
+  _currentValue2: null,
+  _threadCount: 0,
+  Provider: null,
+  Consumer: null,
+  _defaultValue: null,
+  _globalName: null
+};
+
+function requiredContext(c) {
+
+  return c;
+}
+
+function getCurrentRootHostContainer() {
+  return rootInstanceStackCursor.current;
+}
+
+function getRootHostContainer() {
+  const rootInstance = requiredContext(rootInstanceStackCursor.current);
+  return rootInstance;
+}
+
+function pushHostContainer(fiber, nextRootInstance) {
+  // Push current root instance onto the stack;
+  // This allows us to reset root when portals are popped.
+  push(rootInstanceStackCursor, nextRootInstance); // Track the context and the Fiber that provided it.
+  // This enables us to pop only Fibers that provide unique contexts.
+
+  push(contextFiberStackCursor, fiber); // Finally, we need to push the host context to the stack.
+  // However, we can't just call getRootHostContext() and push it because
+  // we'd have a different number of entries on the stack depending on
+  // whether getRootHostContext() throws somewhere in renderer code or not.
+  // So we push an empty value first. This lets us safely unwind on errors.
+
+  push(contextStackCursor$1, null);
+  const nextRootContext = getRootHostContext(nextRootInstance); // Now that we know this function doesn't throw, replace it.
+
+  pop(contextStackCursor$1);
+  push(contextStackCursor$1, nextRootContext);
+}
+
+function popHostContainer(fiber) {
+  pop(contextStackCursor$1);
+  pop(contextFiberStackCursor);
+  pop(rootInstanceStackCursor);
+}
+
+function getHostContext() {
+  const context = requiredContext(contextStackCursor$1.current);
+  return context;
+}
+
+function pushHostContext(fiber) {
+  {
+    const stateHook = fiber.memoizedState;
+
+    if (stateHook !== null) {
+      // Only provide context if this fiber has been upgraded by a host
+      // transition. We use the same optimization for regular host context below.
+      push(hostTransitionProviderCursor, fiber);
+    }
+  }
+
+  const context = requiredContext(contextStackCursor$1.current);
+  const nextContext = getChildHostContext(context, fiber.type); // Don't push this Fiber's context unless it's unique.
+
+  if (context !== nextContext) {
+    // Track the context and the Fiber that provided it.
+    // This enables us to pop only Fibers that provide unique contexts.
+    push(contextFiberStackCursor, fiber);
+    push(contextStackCursor$1, nextContext);
+  }
+}
+
+function popHostContext(fiber) {
+  if (contextFiberStackCursor.current === fiber) {
+    // Do not pop unless this Fiber provided the current context.
+    // pushHostContext() only pushes Fibers that provide unique contexts.
+    pop(contextStackCursor$1);
+    pop(contextFiberStackCursor);
+  }
+
+  {
+    if (hostTransitionProviderCursor.current === fiber) {
+      // Do not pop unless this Fiber provided the current context. This is mostly
+      // a performance optimization, but conveniently it also prevents a potential
+      // data race where a host provider is upgraded (i.e. memoizedState becomes
+      // non-null) during a concurrent event. This is a bit of a flaw in the way
+      // we upgrade host components, but because we're accounting for it here, it
+      // should be fine.
+      pop(hostTransitionProviderCursor); // When popping the transition provider, we reset the context value back
+      // to `null`. We can do this because you're not allowd to nest forms. If
+      // we allowed for multiple nested host transition providers, then we'd
+      // need to reset this to the parent provider's status.
+
+      {
+        HostTransitionContext._currentValue = null;
+      }
+    }
+  }
+}
+
+const NoFlags$1 =
+/*                      */
+0b0000000000000000000000000000;
+const PerformedWork =
+/*                */
+0b0000000000000000000000000001;
+const Placement =
+/*                    */
+0b0000000000000000000000000010;
+const DidCapture =
+/*                   */
+0b0000000000000000000010000000;
+const Hydrating =
+/*                    */
+0b0000000000000001000000000000; // You can change the rest (and add more).
+
+const Update =
+/*                       */
+0b0000000000000000000000000100;
+/* Skipped value:                                 0b0000000000000000000000001000; */
+
+const ChildDeletion =
+/*                */
+0b0000000000000000000000010000;
+const ContentReset =
+/*                 */
+0b0000000000000000000000100000;
+const Callback =
+/*                     */
+0b0000000000000000000001000000;
+/* Used by DidCapture:                            0b0000000000000000000010000000; */
+
+const ForceClientRender =
+/*            */
+0b0000000000000000000100000000;
+const Ref =
+/*                          */
+0b0000000000000000001000000000;
+const Snapshot =
+/*                     */
+0b0000000000000000010000000000;
+const Passive$1 =
+/*                      */
+0b0000000000000000100000000000;
+/* Used by Hydrating:                             0b0000000000000001000000000000; */
+
+const Visibility =
+/*                   */
+0b0000000000000010000000000000;
+const StoreConsistency =
+/*             */
+0b0000000000000100000000000000; // It's OK to reuse these bits because these flags are mutually exclusive for
+// different fiber types. We should really be doing this for as many flags as
+// possible, because we're about to run out of bits.
+
+const ScheduleRetry = StoreConsistency;
+const ShouldSuspendCommit = Visibility;
+const LifecycleEffectMask = Passive$1 | Update | Callback | Ref | Snapshot | StoreConsistency; // Union of all commit flags (flags with the lifetime of a particular commit)
+
+const HostEffectMask =
+/*               */
+0b0000000000000111111111111111; // These are not really side effects, but we still reuse this field.
+
+const Incomplete =
+/*                   */
+0b0000000000001000000000000000;
+const ShouldCapture =
+/*                */
+0b0000000000010000000000000000;
+const ForceUpdateForLegacySuspense =
+/* */
+0b0000000000100000000000000000;
+const Forked =
+/*                       */
+0b0000000100000000000000000000; // Static tags describe aspects of a fiber that are not specific to a render,
+// e.g. a fiber uses a passive effect (even if there are no updates on this particular render).
+// This enables us to defer more work in the unmount case,
+// since we can defer traversing the tree during layout to look for Passive effects,
+// and instead rely on the static flag as a signal that there may be cleanup work.
+
+const RefStatic =
+/*                    */
+0b0000001000000000000000000000;
+const LayoutStatic =
+/*                 */
+0b0000010000000000000000000000;
+const PassiveStatic =
+/*                */
+0b0000100000000000000000000000;
+const MaySuspendCommit =
+/*             */
+0b0001000000000000000000000000; // Flag used to identify newly inserted fibers. It isn't reset after commit unlike `Placement`.
+
+const PlacementDEV =
+/*                 */
+0b0010000000000000000000000000;
+// don't contain effects, by checking subtreeFlags.
+
+const BeforeMutationMask = // TODO: Remove Update flag from before mutation phase by re-landing Visibility
+// flag logic (see #20043)
+Update | Snapshot | (0);
+const MutationMask = Placement | Update | ChildDeletion | ContentReset | Ref | Hydrating | Visibility;
+const LayoutMask = Update | Callback | Ref | Visibility; // TODO: Split into PassiveMountMask and PassiveUnmountMask
+
+const PassiveMask = Passive$1 | Visibility | ChildDeletion; // Union of tags that don't get reset on clones.
+// This allows certain concepts to persist without recalculating them,
+// e.g. whether a subtree contains passive effects or portals.
+
+const StaticMask = LayoutStatic | PassiveStatic | RefStatic | MaySuspendCommit;
+
+// This module only exists as an ESM wrapper around the external CommonJS
+const scheduleCallback$3 = Scheduler.unstable_scheduleCallback;
+const cancelCallback$1 = Scheduler.unstable_cancelCallback;
+const shouldYield = Scheduler.unstable_shouldYield;
+const requestPaint = Scheduler.unstable_requestPaint;
+const now$1 = Scheduler.unstable_now;
+const getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel;
+const ImmediatePriority = Scheduler.unstable_ImmediatePriority;
+const UserBlockingPriority = Scheduler.unstable_UserBlockingPriority;
+const NormalPriority$1 = Scheduler.unstable_NormalPriority;
+const LowPriority = Scheduler.unstable_LowPriority;
+const IdlePriority = Scheduler.unstable_IdlePriority; // this doesn't actually exist on the scheduler, but it *does*
+
+let rendererID = null;
+let injectedHook = null;
+let injectedProfilingHooks = null;
+const isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined';
+function injectInternals(internals) {
+  if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {
+    // No DevTools
+    return false;
+  }
+
+  const hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+
+  if (hook.isDisabled) {
+    // This isn't a real property on the hook, but it can be set to opt out
+    // of DevTools integration and associated warnings and logs.
+    // https://github.com/facebook/react/issues/3877
+    return true;
+  }
+
+  if (!hook.supportsFiber) {
+
+
+    return true;
+  }
+
+  try {
+    if (enableSchedulingProfiler) {
+      // Conditionally inject these hooks only if Timeline profiler is supported by this build.
+      // This gives DevTools a way to feature detect that isn't tied to version number
+      // (since profiling and timeline are controlled by different feature flags).
+      internals = assign({}, internals, {
+        getLaneLabelMap,
+        injectProfilingHooks
+      });
+    }
+
+    rendererID = hook.inject(internals); // We have successfully injected, so now it is safe to set up hooks.
+
+    injectedHook = hook;
+  } catch (err) {
+  }
+
+  if (hook.checkDCE) {
+    // This is the real DevTools.
+    return true;
+  } else {
+    // This is likely a hook installed by Fast Refresh runtime.
+    return false;
+  }
+}
+function onCommitRoot(root, eventPriority) {
+  if (injectedHook && typeof injectedHook.onCommitFiberRoot === 'function') {
+    try {
+      const didError = (root.current.flags & DidCapture) === DidCapture;
+
+      if (enableProfilerTimer) {
+        let 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) {
+    }
+  }
+}
+function onPostCommitRoot(root) {
+  if (injectedHook && typeof injectedHook.onPostCommitFiberRoot === 'function') {
+    try {
+      injectedHook.onPostCommitFiberRoot(rendererID, root);
+    } catch (err) {
+    }
+  }
+}
+function onCommitUnmount(fiber) {
+  if (injectedHook && typeof injectedHook.onCommitFiberUnmount === 'function') {
+    try {
+      injectedHook.onCommitFiberUnmount(rendererID, fiber);
+    } catch (err) {
+    }
+  }
+}
+
+function injectProfilingHooks(profilingHooks) {
+  injectedProfilingHooks = profilingHooks;
+}
+
+function getLaneLabelMap() {
+  {
+    const map = new Map();
+    let lane = 1;
+
+    for (let index = 0; index < TotalLanes; index++) {
+      const label = getLabelForLane(lane);
+      map.set(lane, label);
+      lane *= 2;
+    }
+
+    return map;
+  }
+}
+
+function markCommitStarted(lanes) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markCommitStarted === 'function') {
+      injectedProfilingHooks.markCommitStarted(lanes);
+    }
+  }
+}
+function markCommitStopped() {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markCommitStopped === 'function') {
+      injectedProfilingHooks.markCommitStopped();
+    }
+  }
+}
+function markComponentRenderStarted(fiber) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentRenderStarted === 'function') {
+      injectedProfilingHooks.markComponentRenderStarted(fiber);
+    }
+  }
+}
+function markComponentRenderStopped() {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentRenderStopped === 'function') {
+      injectedProfilingHooks.markComponentRenderStopped();
+    }
+  }
+}
+function markComponentPassiveEffectMountStarted(fiber) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentPassiveEffectMountStarted === 'function') {
+      injectedProfilingHooks.markComponentPassiveEffectMountStarted(fiber);
+    }
+  }
+}
+function markComponentPassiveEffectMountStopped() {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentPassiveEffectMountStopped === 'function') {
+      injectedProfilingHooks.markComponentPassiveEffectMountStopped();
+    }
+  }
+}
+function markComponentPassiveEffectUnmountStarted(fiber) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentPassiveEffectUnmountStarted === 'function') {
+      injectedProfilingHooks.markComponentPassiveEffectUnmountStarted(fiber);
+    }
+  }
+}
+function markComponentPassiveEffectUnmountStopped() {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentPassiveEffectUnmountStopped === 'function') {
+      injectedProfilingHooks.markComponentPassiveEffectUnmountStopped();
+    }
+  }
+}
+function markComponentLayoutEffectMountStarted(fiber) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentLayoutEffectMountStarted === 'function') {
+      injectedProfilingHooks.markComponentLayoutEffectMountStarted(fiber);
+    }
+  }
+}
+function markComponentLayoutEffectMountStopped() {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentLayoutEffectMountStopped === 'function') {
+      injectedProfilingHooks.markComponentLayoutEffectMountStopped();
+    }
+  }
+}
+function markComponentLayoutEffectUnmountStarted(fiber) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStarted === 'function') {
+      injectedProfilingHooks.markComponentLayoutEffectUnmountStarted(fiber);
+    }
+  }
+}
+function markComponentLayoutEffectUnmountStopped() {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStopped === 'function') {
+      injectedProfilingHooks.markComponentLayoutEffectUnmountStopped();
+    }
+  }
+}
+function markComponentErrored(fiber, thrownValue, lanes) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentErrored === 'function') {
+      injectedProfilingHooks.markComponentErrored(fiber, thrownValue, lanes);
+    }
+  }
+}
+function markComponentSuspended(fiber, wakeable, lanes) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentSuspended === 'function') {
+      injectedProfilingHooks.markComponentSuspended(fiber, wakeable, lanes);
+    }
+  }
+}
+function markLayoutEffectsStarted(lanes) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markLayoutEffectsStarted === 'function') {
+      injectedProfilingHooks.markLayoutEffectsStarted(lanes);
+    }
+  }
+}
+function markLayoutEffectsStopped() {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markLayoutEffectsStopped === 'function') {
+      injectedProfilingHooks.markLayoutEffectsStopped();
+    }
+  }
+}
+function markPassiveEffectsStarted(lanes) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markPassiveEffectsStarted === 'function') {
+      injectedProfilingHooks.markPassiveEffectsStarted(lanes);
+    }
+  }
+}
+function markPassiveEffectsStopped() {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markPassiveEffectsStopped === 'function') {
+      injectedProfilingHooks.markPassiveEffectsStopped();
+    }
+  }
+}
+function markRenderStarted(lanes) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markRenderStarted === 'function') {
+      injectedProfilingHooks.markRenderStarted(lanes);
+    }
+  }
+}
+function markRenderYielded() {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markRenderYielded === 'function') {
+      injectedProfilingHooks.markRenderYielded();
+    }
+  }
+}
+function markRenderStopped() {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markRenderStopped === 'function') {
+      injectedProfilingHooks.markRenderStopped();
+    }
+  }
+}
+function markRenderScheduled(lane) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markRenderScheduled === 'function') {
+      injectedProfilingHooks.markRenderScheduled(lane);
+    }
+  }
+}
+function markForceUpdateScheduled(fiber, lane) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markForceUpdateScheduled === 'function') {
+      injectedProfilingHooks.markForceUpdateScheduled(fiber, lane);
+    }
+  }
+}
+function markStateUpdateScheduled(fiber, lane) {
+  {
+    if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markStateUpdateScheduled === 'function') {
+      injectedProfilingHooks.markStateUpdateScheduled(fiber, lane);
+    }
+  }
+}
+
+const NoMode =
+/*                         */
+0b0000000; // TODO: Remove ConcurrentMode by reading from the root tag instead
+
+const ConcurrentMode =
+/*                 */
+0b0000001;
+const ProfileMode =
+/*                    */
+0b0000010;
+const StrictLegacyMode =
+/*               */
+0b0001000;
+const StrictEffectsMode =
+/*              */
+0b0010000;
+
+// TODO: This is pretty well supported by browsers. Maybe we can drop it.
+const 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
+
+const log = Math.log;
+const LN2 = Math.LN2;
+
+function clz32Fallback(x) {
+  const asUint = x >>> 0;
+
+  if (asUint === 0) {
+    return 32;
+  }
+
+  return 31 - (log(asUint) / LN2 | 0) | 0;
+}
+
+// TODO: Ideally these types would be opaque but that doesn't work well with
+// If those values are changed that package should be rebuilt and redeployed.
+
+const TotalLanes = 31;
+const NoLanes =
+/*                        */
+0b0000000000000000000000000000000;
+const NoLane =
+/*                          */
+0b0000000000000000000000000000000;
+const SyncHydrationLane =
+/*               */
+0b0000000000000000000000000000001;
+const SyncLane =
+/*                        */
+0b0000000000000000000000000000010;
+const SyncLaneIndex = 1;
+const InputContinuousHydrationLane =
+/*    */
+0b0000000000000000000000000000100;
+const InputContinuousLane =
+/*             */
+0b0000000000000000000000000001000;
+const DefaultHydrationLane =
+/*            */
+0b0000000000000000000000000010000;
+const DefaultLane =
+/*                     */
+0b0000000000000000000000000100000;
+const SyncUpdateLanes = SyncLane | InputContinuousLane | DefaultLane ;
+const TransitionHydrationLane =
+/*                */
+0b0000000000000000000000001000000;
+const TransitionLanes =
+/*                       */
+0b0000000001111111111111110000000;
+const TransitionLane1 =
+/*                        */
+0b0000000000000000000000010000000;
+const TransitionLane2 =
+/*                        */
+0b0000000000000000000000100000000;
+const TransitionLane3 =
+/*                        */
+0b0000000000000000000001000000000;
+const TransitionLane4 =
+/*                        */
+0b0000000000000000000010000000000;
+const TransitionLane5 =
+/*                        */
+0b0000000000000000000100000000000;
+const TransitionLane6 =
+/*                        */
+0b0000000000000000001000000000000;
+const TransitionLane7 =
+/*                        */
+0b0000000000000000010000000000000;
+const TransitionLane8 =
+/*                        */
+0b0000000000000000100000000000000;
+const TransitionLane9 =
+/*                        */
+0b0000000000000001000000000000000;
+const TransitionLane10 =
+/*                       */
+0b0000000000000010000000000000000;
+const TransitionLane11 =
+/*                       */
+0b0000000000000100000000000000000;
+const TransitionLane12 =
+/*                       */
+0b0000000000001000000000000000000;
+const TransitionLane13 =
+/*                       */
+0b0000000000010000000000000000000;
+const TransitionLane14 =
+/*                       */
+0b0000000000100000000000000000000;
+const TransitionLane15 =
+/*                       */
+0b0000000001000000000000000000000;
+const RetryLanes =
+/*                            */
+0b0000011110000000000000000000000;
+const RetryLane1 =
+/*                             */
+0b0000000010000000000000000000000;
+const RetryLane2 =
+/*                             */
+0b0000000100000000000000000000000;
+const RetryLane3 =
+/*                             */
+0b0000001000000000000000000000000;
+const RetryLane4 =
+/*                             */
+0b0000010000000000000000000000000;
+const SomeRetryLane = RetryLane1;
+const SelectiveHydrationLane =
+/*          */
+0b0000100000000000000000000000000;
+const NonIdleLanes =
+/*                          */
+0b0000111111111111111111111111111;
+const IdleHydrationLane =
+/*               */
+0b0001000000000000000000000000000;
+const IdleLane =
+/*                        */
+0b0010000000000000000000000000000;
+const OffscreenLane =
+/*                   */
+0b0100000000000000000000000000000;
+const DeferredLane =
+/*                    */
+0b1000000000000000000000000000000; // Any lane that might schedule an update. This is used to detect infinite
+// update loops, so it doesn't include hydration lanes or retries.
+
+const UpdateLanes = SyncLane | InputContinuousLane | DefaultLane | TransitionLanes; // 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 (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';
+    }
+
+    if (lane & DeferredLane) {
+      return 'Deferred';
+    }
+  }
+}
+const NoTimestamp = -1;
+let nextTransitionLane = TransitionLane1;
+let nextRetryLane = RetryLane1;
+
+function getHighestPriorityLanes(lanes) {
+  {
+    const pendingSyncLanes = lanes & SyncUpdateLanes;
+
+    if (pendingSyncLanes !== 0) {
+      return pendingSyncLanes;
+    }
+  }
+
+  switch (getHighestPriorityLane(lanes)) {
+    case SyncHydrationLane:
+      return SyncHydrationLane;
+
+    case SyncLane:
+      return SyncLane;
+
+    case InputContinuousHydrationLane:
+      return InputContinuousHydrationLane;
+
+    case InputContinuousLane:
+      return InputContinuousLane;
+
+    case DefaultHydrationLane:
+      return DefaultHydrationLane;
+
+    case DefaultLane:
+      return DefaultLane;
+
+    case TransitionHydrationLane:
+      return TransitionHydrationLane;
+
+    case TransitionLane1:
+    case TransitionLane2:
+    case TransitionLane3:
+    case TransitionLane4:
+    case TransitionLane5:
+    case TransitionLane6:
+    case TransitionLane7:
+    case TransitionLane8:
+    case TransitionLane9:
+    case TransitionLane10:
+    case TransitionLane11:
+    case TransitionLane12:
+    case TransitionLane13:
+    case TransitionLane14:
+    case TransitionLane15:
+      return lanes & TransitionLanes;
+
+    case RetryLane1:
+    case RetryLane2:
+    case RetryLane3:
+    case RetryLane4:
+      return lanes & RetryLanes;
+
+    case SelectiveHydrationLane:
+      return SelectiveHydrationLane;
+
+    case IdleHydrationLane:
+      return IdleHydrationLane;
+
+    case IdleLane:
+      return IdleLane;
+
+    case OffscreenLane:
+      return OffscreenLane;
+
+    case DeferredLane:
+      // This shouldn't be reachable because deferred work is always entangled
+      // with something else.
+      return NoLanes;
+
+    default:
+
+
+      return lanes;
+  }
+}
+
+function getNextLanes(root, wipLanes) {
+  // Early bailout if there's no pending work left.
+  const pendingLanes = root.pendingLanes;
+
+  if (pendingLanes === NoLanes) {
+    return NoLanes;
+  }
+
+  let nextLanes = NoLanes;
+  const suspendedLanes = root.suspendedLanes;
+  const pingedLanes = root.pingedLanes; // Do not work on any idle work until all the non-idle work has finished,
+  // even if the work is suspended.
+
+  const nonIdlePendingLanes = pendingLanes & NonIdleLanes;
+
+  if (nonIdlePendingLanes !== NoLanes) {
+    const nonIdleUnblockedLanes = nonIdlePendingLanes & ~suspendedLanes;
+
+    if (nonIdleUnblockedLanes !== NoLanes) {
+      nextLanes = getHighestPriorityLanes(nonIdleUnblockedLanes);
+    } else {
+      const nonIdlePingedLanes = nonIdlePendingLanes & pingedLanes;
+
+      if (nonIdlePingedLanes !== NoLanes) {
+        nextLanes = getHighestPriorityLanes(nonIdlePingedLanes);
+      }
+    }
+  } else {
+    // The only remaining work is Idle.
+    const unblockedLanes = pendingLanes & ~suspendedLanes;
+
+    if (unblockedLanes !== NoLanes) {
+      nextLanes = getHighestPriorityLanes(unblockedLanes);
+    } else {
+      if (pingedLanes !== NoLanes) {
+        nextLanes = getHighestPriorityLanes(pingedLanes);
+      }
+    }
+  }
+
+  if (nextLanes === NoLanes) {
+    // This should only be reachable if we're suspended
+    // TODO: Consider warning in this path if a fallback timer is not scheduled.
+    return NoLanes;
+  } // If we're already in the middle of a render, switching lanes will interrupt
+  // it and we'll lose our progress. We should only do this if the new lanes are
+  // higher priority.
+
+
+  if (wipLanes !== NoLanes && wipLanes !== nextLanes && // If we already suspended with a delay, then interrupting is fine. Don't
+  // bother waiting until the root is complete.
+  (wipLanes & suspendedLanes) === NoLanes) {
+    const nextLane = getHighestPriorityLane(nextLanes);
+    const wipLane = getHighestPriorityLane(wipLanes);
+
+    if ( // Tests whether the next lane is equal or lower priority than the wip
+    // one. This works because the bits decrease in priority as you go left.
+    nextLane >= wipLane || // Default priority updates should not interrupt transition updates. The
+    // only difference between default updates and transition updates is that
+    // default updates do not support refresh transitions.
+    nextLane === DefaultLane && (wipLane & TransitionLanes) !== NoLanes) {
+      // Keep working on the existing in-progress tree. Do not interrupt.
+      return wipLanes;
+    }
+  }
+
+  return nextLanes;
+}
+function getEntangledLanes(root, renderLanes) {
+  let entangledLanes = renderLanes;
+
+  if ((entangledLanes & InputContinuousLane) !== NoLanes) {
+    // When updates are sync by default, we entangle continuous priority updates
+    // and default updates, so they render in the same batch. The only reason
+    // they use separate lanes is because continuous updates should interrupt
+    // transitions, but default updates should not.
+    entangledLanes |= entangledLanes & DefaultLane;
+  } // Check for entangled lanes and add them to the batch.
+  //
+  // A lane is said to be entangled with another when it's not allowed to render
+  // in a batch that does not also include the other lane. Typically we do this
+  // when multiple updates have the same source, and we only want to respond to
+  // the most recent event from that source.
+  //
+  // Note that we apply entanglements *after* checking for partial work above.
+  // This means that if a lane is entangled during an interleaved event while
+  // it's already rendering, we won't interrupt it. This is intentional, since
+  // entanglement is usually "best effort": we'll try our best to render the
+  // lanes in the same batch, but it's not worth throwing out partially
+  // completed work in order to do it.
+  // TODO: Reconsider this. The counter-argument is that the partial work
+  // represents an intermediate state, which we don't want to show to the user.
+  // And by spending extra time finishing it, we're increasing the amount of
+  // time it takes to show the final state, which is what they are actually
+  // waiting for.
+  //
+  // For those exceptions where entanglement is semantically important,
+  // we should ensure that there is no partial work at the
+  // time we apply the entanglement.
+
+
+  const allEntangledLanes = root.entangledLanes;
+
+  if (allEntangledLanes !== NoLanes) {
+    const entanglements = root.entanglements;
+    let lanes = entangledLanes & allEntangledLanes;
+
+    while (lanes > 0) {
+      const index = pickArbitraryLaneIndex(lanes);
+      const lane = 1 << index;
+      entangledLanes |= entanglements[index];
+      lanes &= ~lane;
+    }
+  }
+
+  return entangledLanes;
+}
+
+function computeExpirationTime(lane, currentTime) {
+  switch (lane) {
+    case SyncHydrationLane:
+    case SyncLane:
+    case InputContinuousHydrationLane:
+    case InputContinuousLane:
+      // User interactions should expire slightly more quickly.
+      //
+      // NOTE: This is set to the corresponding constant as in Scheduler.js.
+      // When we made it larger, a product metric in www regressed, suggesting
+      // there's a user interaction that's being starved by a series of
+      // synchronous updates. If that theory is correct, the proper solution is
+      // to fix the starvation. However, this scenario supports the idea that
+      // expiration times are an important safeguard when starvation
+      // does happen.
+      return currentTime + 250;
+
+    case DefaultHydrationLane:
+    case DefaultLane:
+    case TransitionHydrationLane:
+    case TransitionLane1:
+    case TransitionLane2:
+    case TransitionLane3:
+    case TransitionLane4:
+    case TransitionLane5:
+    case TransitionLane6:
+    case TransitionLane7:
+    case TransitionLane8:
+    case TransitionLane9:
+    case TransitionLane10:
+    case TransitionLane11:
+    case TransitionLane12:
+    case TransitionLane13:
+    case TransitionLane14:
+    case TransitionLane15:
+      return currentTime + 5000;
+
+    case RetryLane1:
+    case RetryLane2:
+    case RetryLane3:
+    case RetryLane4:
+      // TODO: Retries should be allowed to expire if they are CPU bound for
+      // too long, but when I made this change it caused a spike in browser
+      // crashes. There must be some other underlying bug; not super urgent but
+      // ideally should figure out why and fix it. Unfortunately we don't have
+      // a repro for the crashes, only detected via production metrics.
+      return NoTimestamp;
+
+    case SelectiveHydrationLane:
+    case IdleHydrationLane:
+    case IdleLane:
+    case OffscreenLane:
+    case DeferredLane:
+      // Anything idle priority or lower should never expire.
+      return NoTimestamp;
+
+    default:
+
+      return NoTimestamp;
+  }
+}
+
+function markStarvedLanesAsExpired(root, currentTime) {
+  // TODO: This gets called every time we yield. We can optimize by storing
+  // the earliest expiration time on the root. Then use that to quickly bail out
+  // of this function.
+  const pendingLanes = root.pendingLanes;
+  const suspendedLanes = root.suspendedLanes;
+  const pingedLanes = root.pingedLanes;
+  const expirationTimes = root.expirationTimes; // Iterate through the pending lanes and check if we've reached their
+  // expiration time. If so, we'll assume the update is being starved and mark
+  // it as expired to force it to finish.
+  // TODO: We should be able to replace this with upgradePendingLanesToSync
+  //
+  // We exclude retry lanes because those must always be time sliced, in order
+  // to unwrap uncached promises.
+  // TODO: Write a test for this
+
+  let lanes = pendingLanes & ~RetryLanes;
+
+  while (lanes > 0) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+    const expirationTime = expirationTimes[index];
+
+    if (expirationTime === NoTimestamp) {
+      // Found a pending lane with no expiration time. If it's not suspended, or
+      // if it's pinged, assume it's CPU-bound. Compute a new expiration time
+      // using the current time.
+      if ((lane & suspendedLanes) === NoLanes || (lane & pingedLanes) !== NoLanes) {
+        // Assumes timestamps are monotonically increasing.
+        expirationTimes[index] = computeExpirationTime(lane, currentTime);
+      }
+    } else if (expirationTime <= currentTime) {
+      // This lane expired
+      root.expiredLanes |= lane;
+    }
+
+    lanes &= ~lane;
+  }
+} // This returns the highest priority pending lanes regardless of whether they
+// are suspended.
+
+function getHighestPriorityPendingLanes(root) {
+  return getHighestPriorityLanes(root.pendingLanes);
+}
+function getLanesToRetrySynchronouslyOnError(root, originallyAttemptedLanes) {
+  if (root.errorRecoveryDisabledLanes & originallyAttemptedLanes) {
+    // The error recovery mechanism is disabled until these lanes are cleared.
+    return NoLanes;
+  }
+
+  const everythingButOffscreen = root.pendingLanes & ~OffscreenLane;
+
+  if (everythingButOffscreen !== NoLanes) {
+    return everythingButOffscreen;
+  }
+
+  if (everythingButOffscreen & OffscreenLane) {
+    return OffscreenLane;
+  }
+
+  return NoLanes;
+}
+function includesSyncLane(lanes) {
+  return (lanes & (SyncLane | SyncHydrationLane)) !== NoLanes;
+}
+function includesNonIdleWork(lanes) {
+  return (lanes & NonIdleLanes) !== NoLanes;
+}
+function includesOnlyRetries(lanes) {
+  return (lanes & RetryLanes) === lanes;
+}
+function includesOnlyNonUrgentLanes(lanes) {
+  // TODO: Should hydration lanes be included here? This function is only
+  // used in `updateDeferredValueImpl`.
+  const UrgentLanes = SyncLane | InputContinuousLane | DefaultLane;
+  return (lanes & UrgentLanes) === NoLanes;
+}
+function includesOnlyTransitions(lanes) {
+  return (lanes & TransitionLanes) === lanes;
+}
+function includesBlockingLane(root, lanes) {
+
+  const SyncDefaultLanes = InputContinuousHydrationLane | InputContinuousLane | DefaultHydrationLane | DefaultLane;
+  return (lanes & SyncDefaultLanes) !== NoLanes;
+}
+function includesExpiredLane(root, lanes) {
+  // This is a separate check from includesBlockingLane because a lane can
+  // expire after a render has already started.
+  return (lanes & root.expiredLanes) !== NoLanes;
+}
+function isTransitionLane(lane) {
+  return (lane & TransitionLanes) !== NoLanes;
+}
+function claimNextTransitionLane() {
+  // Cycle through the lanes, assigning each new transition to the next lane.
+  // In most cases, this means every transition gets its own lane, until we
+  // run out of lanes and cycle back to the beginning.
+  const lane = nextTransitionLane;
+  nextTransitionLane <<= 1;
+
+  if ((nextTransitionLane & TransitionLanes) === NoLanes) {
+    nextTransitionLane = TransitionLane1;
+  }
+
+  return lane;
+}
+function claimNextRetryLane() {
+  const lane = nextRetryLane;
+  nextRetryLane <<= 1;
+
+  if ((nextRetryLane & RetryLanes) === NoLanes) {
+    nextRetryLane = RetryLane1;
+  }
+
+  return lane;
+}
+function getHighestPriorityLane(lanes) {
+  return lanes & -lanes;
+}
+function pickArbitraryLane(lanes) {
+  // This wrapper function gets inlined. Only exists so to communicate that it
+  // doesn't matter which bit is selected; you can pick any bit without
+  // affecting the algorithms where its used. Here I'm using
+  // getHighestPriorityLane because it requires the fewest operations.
+  return getHighestPriorityLane(lanes);
+}
+
+function pickArbitraryLaneIndex(lanes) {
+  return 31 - clz32(lanes);
+}
+
+function laneToIndex(lane) {
+  return pickArbitraryLaneIndex(lane);
+}
+
+function includesSomeLane(a, b) {
+  return (a & b) !== NoLanes;
+}
+function isSubsetOfLanes(set, subset) {
+  return (set & subset) === subset;
+}
+function mergeLanes(a, b) {
+  return a | b;
+}
+function removeLanes(set, subset) {
+  return set & ~subset;
+}
+function intersectLanes(a, b) {
+  return a & b;
+} // Seems redundant, but it changes the type from a single lane (used for
+// updates) to a group of lanes (used for flushing work).
+
+function laneToLanes(lane) {
+  return lane;
+}
+function higherPriorityLane(a, b) {
+  // This works because the bit ranges decrease in priority as you go left.
+  return a !== NoLane && a < b ? a : b;
+}
+function createLaneMap(initial) {
+  // Intentionally pushing one by one.
+  // https://v8.dev/blog/elements-kinds#avoid-creating-holes
+  const laneMap = [];
+
+  for (let i = 0; i < TotalLanes; i++) {
+    laneMap.push(initial);
+  }
+
+  return laneMap;
+}
+function markRootUpdated(root, updateLane) {
+  root.pendingLanes |= updateLane; // If there are any suspended transitions, it's possible this new update
+  // could unblock them. Clear the suspended lanes so that we can try rendering
+  // them again.
+  //
+  // TODO: We really only need to unsuspend only lanes that are in the
+  // `subtreeLanes` of the updated fiber, or the update lanes of the return
+  // path. This would exclude suspended updates in an unrelated sibling tree,
+  // since there's no way for this update to unblock it.
+  //
+  // We don't do this if the incoming update is idle, because we never process
+  // idle updates until after all the regular updates have finished; there's no
+  // way it could unblock a transition.
+
+  if (updateLane !== IdleLane) {
+    root.suspendedLanes = NoLanes;
+    root.pingedLanes = NoLanes;
+  }
+}
+function markRootSuspended$1(root, suspendedLanes, spawnedLane) {
+  root.suspendedLanes |= suspendedLanes;
+  root.pingedLanes &= ~suspendedLanes; // The suspended lanes are no longer CPU-bound. Clear their expiration times.
+
+  const expirationTimes = root.expirationTimes;
+  let lanes = suspendedLanes;
+
+  while (lanes > 0) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+    expirationTimes[index] = NoTimestamp;
+    lanes &= ~lane;
+  }
+
+  if (spawnedLane !== NoLane) {
+    markSpawnedDeferredLane(root, spawnedLane, suspendedLanes);
+  }
+}
+function markRootPinged(root, pingedLanes) {
+  root.pingedLanes |= root.suspendedLanes & pingedLanes;
+}
+function markRootFinished(root, remainingLanes, spawnedLane) {
+  const noLongerPendingLanes = root.pendingLanes & ~remainingLanes;
+  root.pendingLanes = remainingLanes; // Let's try everything again
+
+  root.suspendedLanes = NoLanes;
+  root.pingedLanes = NoLanes;
+  root.expiredLanes &= remainingLanes;
+  root.entangledLanes &= remainingLanes;
+  root.errorRecoveryDisabledLanes &= remainingLanes;
+  root.shellSuspendCounter = 0;
+  const entanglements = root.entanglements;
+  const expirationTimes = root.expirationTimes;
+  const hiddenUpdates = root.hiddenUpdates; // Clear the lanes that no longer have pending work
+
+  let lanes = noLongerPendingLanes;
+
+  while (lanes > 0) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+    entanglements[index] = NoLanes;
+    expirationTimes[index] = NoTimestamp;
+    const hiddenUpdatesForLane = hiddenUpdates[index];
+
+    if (hiddenUpdatesForLane !== null) {
+      hiddenUpdates[index] = null; // "Hidden" updates are updates that were made to a hidden component. They
+      // have special logic associated with them because they may be entangled
+      // with updates that occur outside that tree. But once the outer tree
+      // commits, they behave like regular updates.
+
+      for (let i = 0; i < hiddenUpdatesForLane.length; i++) {
+        const update = hiddenUpdatesForLane[i];
+
+        if (update !== null) {
+          update.lane &= ~OffscreenLane;
+        }
+      }
+    }
+
+    lanes &= ~lane;
+  }
+
+  if (spawnedLane !== NoLane) {
+    markSpawnedDeferredLane(root, spawnedLane, // This render finished successfully without suspending, so we don't need
+    // to entangle the spawned task with the parent task.
+    NoLanes);
+  }
+}
+
+function markSpawnedDeferredLane(root, spawnedLane, entangledLanes) {
+  // This render spawned a deferred task. Mark it as pending.
+  root.pendingLanes |= spawnedLane;
+  root.suspendedLanes &= ~spawnedLane; // Entangle the spawned lane with the DeferredLane bit so that we know it
+  // was the result of another render. This lets us avoid a useDeferredValue
+  // waterfall — only the first level will defer.
+
+  const spawnedLaneIndex = laneToIndex(spawnedLane);
+  root.entangledLanes |= spawnedLane;
+  root.entanglements[spawnedLaneIndex] |= DeferredLane | // If the parent render task suspended, we must also entangle those lanes
+  // with the spawned task, so that the deferred task includes all the same
+  // updates that the parent task did. We can exclude any lane that is not
+  // used for updates (e.g. Offscreen).
+  entangledLanes & UpdateLanes;
+}
+
+function markRootEntangled(root, entangledLanes) {
+  // In addition to entangling each of the given lanes with each other, we also
+  // have to consider _transitive_ entanglements. For each lane that is already
+  // entangled with *any* of the given lanes, that lane is now transitively
+  // entangled with *all* the given lanes.
+  //
+  // Translated: If C is entangled with A, then entangling A with B also
+  // entangles C with B.
+  //
+  // If this is hard to grasp, it might help to intentionally break this
+  // function and look at the tests that fail in ReactTransition-test.js. Try
+  // commenting out one of the conditions below.
+  const rootEntangledLanes = root.entangledLanes |= entangledLanes;
+  const entanglements = root.entanglements;
+  let lanes = rootEntangledLanes;
+
+  while (lanes) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+
+    if ( // Is this one of the newly entangled lanes?
+    lane & entangledLanes | // Is this lane transitively entangled with the newly entangled lanes?
+    entanglements[index] & entangledLanes) {
+      entanglements[index] |= entangledLanes;
+    }
+
+    lanes &= ~lane;
+  }
+}
+function upgradePendingLaneToSync(root, lane) {
+  // Since we're upgrading the priority of the given lane, there is now pending
+  // sync work.
+  root.pendingLanes |= SyncLane; // Entangle the sync lane with the lane we're upgrading. This means SyncLane
+  // will not be allowed to finish without also finishing the given lane.
+
+  root.entangledLanes |= SyncLane;
+  root.entanglements[SyncLaneIndex] |= lane;
+}
+function upgradePendingLanesToSync(root, lanesToUpgrade) {
+  // Same as upgradePendingLaneToSync but accepts multiple lanes, so it's a
+  // bit slower.
+  root.pendingLanes |= SyncLane;
+  root.entangledLanes |= SyncLane;
+  let lanes = lanesToUpgrade;
+
+  while (lanes) {
+    const index = pickArbitraryLaneIndex(lanes);
+    const lane = 1 << index;
+    root.entanglements[SyncLaneIndex] |= lane;
+    lanes &= ~lane;
+  }
+}
+function markHiddenUpdate(root, update, lane) {
+  const index = laneToIndex(lane);
+  const hiddenUpdates = root.hiddenUpdates;
+  const hiddenUpdatesForLane = hiddenUpdates[index];
+
+  if (hiddenUpdatesForLane === null) {
+    hiddenUpdates[index] = [update];
+  } else {
+    hiddenUpdatesForLane.push(update);
+  }
+
+  update.lane = lane | OffscreenLane;
+}
+function getBumpedLaneForHydration(root, renderLanes) {
+  const renderLane = getHighestPriorityLane(renderLanes);
+  let lane;
+
+  if ((renderLane & SyncUpdateLanes) !== NoLane) {
+    lane = SyncHydrationLane;
+  } else {
+    switch (renderLane) {
+      case SyncLane:
+        lane = SyncHydrationLane;
+        break;
+
+      case InputContinuousLane:
+        lane = InputContinuousHydrationLane;
+        break;
+
+      case DefaultLane:
+        lane = DefaultHydrationLane;
+        break;
+
+      case TransitionLane1:
+      case TransitionLane2:
+      case TransitionLane3:
+      case TransitionLane4:
+      case TransitionLane5:
+      case TransitionLane6:
+      case TransitionLane7:
+      case TransitionLane8:
+      case TransitionLane9:
+      case TransitionLane10:
+      case TransitionLane11:
+      case TransitionLane12:
+      case TransitionLane13:
+      case TransitionLane14:
+      case TransitionLane15:
+      case RetryLane1:
+      case RetryLane2:
+      case RetryLane3:
+      case RetryLane4:
+        lane = TransitionHydrationLane;
+        break;
+
+      case IdleLane:
+        lane = IdleHydrationLane;
+        break;
+
+      default:
+        // Everything else is already either a hydration lane, or shouldn't
+        // be retried at a hydration lane.
+        lane = NoLane;
+        break;
+    }
+  } // Check if the lane we chose is suspended. If so, that indicates that we
+  // already attempted and failed to hydrate at that level. Also check if we're
+  // already rendering that lane, which is rare but could happen.
+
+
+  if ((lane & (root.suspendedLanes | renderLanes)) !== NoLane) {
+    // Give up trying to hydrate and fall back to client render.
+    return NoLane;
+  }
+
+  return lane;
+}
+function addFiberToLanesMap(root, fiber, lanes) {
+
+  if (!isDevToolsPresent) {
+    return;
+  }
+
+  const pendingUpdatersLaneMap = root.pendingUpdatersLaneMap;
+
+  while (lanes > 0) {
+    const index = laneToIndex(lanes);
+    const lane = 1 << index;
+    const updaters = pendingUpdatersLaneMap[index];
+    updaters.add(fiber);
+    lanes &= ~lane;
+  }
+}
+function movePendingFibersToMemoized(root, lanes) {
+
+  if (!isDevToolsPresent) {
+    return;
+  }
+
+  const pendingUpdatersLaneMap = root.pendingUpdatersLaneMap;
+  const memoizedUpdaters = root.memoizedUpdaters;
+
+  while (lanes > 0) {
+    const index = laneToIndex(lanes);
+    const lane = 1 << index;
+    const updaters = pendingUpdatersLaneMap[index];
+
+    if (updaters.size > 0) {
+      updaters.forEach(fiber => {
+        const alternate = fiber.alternate;
+
+        if (alternate === null || !memoizedUpdaters.has(alternate)) {
+          memoizedUpdaters.add(fiber);
+        }
+      });
+      updaters.clear();
+    }
+
+    lanes &= ~lane;
+  }
+}
+function getTransitionsForLanes(root, lanes) {
+  {
+    return null;
+  }
+}
+
+const DiscreteEventPriority = SyncLane;
+const ContinuousEventPriority = InputContinuousLane;
+const DefaultEventPriority = DefaultLane;
+const IdleEventPriority = IdleLane;
+let currentUpdatePriority = NoLane;
+function getCurrentUpdatePriority() {
+  return currentUpdatePriority;
+}
+function setCurrentUpdatePriority(newPriority) {
+  currentUpdatePriority = newPriority;
+}
+function runWithPriority(priority, fn) {
+  const previousPriority = currentUpdatePriority;
+
+  try {
+    currentUpdatePriority = priority;
+    return fn();
+  } finally {
+    currentUpdatePriority = previousPriority;
+  }
+}
+function higherEventPriority(a, b) {
+  return a !== 0 && a < b ? a : b;
+}
+function lowerEventPriority(a, b) {
+  return a === 0 || a > b ? a : b;
+}
+function isHigherEventPriority(a, b) {
+  return a !== 0 && a < b;
+}
+function lanesToEventPriority(lanes) {
+  const lane = getHighestPriorityLane(lanes);
+
+  if (!isHigherEventPriority(DiscreteEventPriority, lane)) {
+    return DiscreteEventPriority;
+  }
+
+  if (!isHigherEventPriority(ContinuousEventPriority, lane)) {
+    return ContinuousEventPriority;
+  }
+
+  if (includesNonIdleWork(lane)) {
+    return DefaultEventPriority;
+  }
+
+  return IdleEventPriority;
+}
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+const FunctionComponent = 0;
+const ClassComponent = 1;
+const IndeterminateComponent = 2; // Before we know whether it is function or class
+
+const HostRoot = 3; // Root of a host tree. Could be nested inside another node.
+
+const HostPortal = 4; // A subtree. Could be an entry point to a different renderer.
+
+const HostComponent = 5;
+const HostText = 6;
+const Fragment = 7;
+const Mode = 8;
+const ContextConsumer = 9;
+const ContextProvider = 10;
+const ForwardRef = 11;
+const Profiler = 12;
+const SuspenseComponent = 13;
+const MemoComponent = 14;
+const SimpleMemoComponent = 15;
+const LazyComponent = 16;
+const IncompleteClassComponent = 17;
+const DehydratedFragment = 18;
+const SuspenseListComponent = 19;
+const ScopeComponent = 21;
+const OffscreenComponent = 22;
+const LegacyHiddenComponent = 23;
+const CacheComponent = 24;
+const TracingMarkerComponent = 25;
+const HostHoistable = 26;
+const HostSingleton = 27;
+
+const randomKey = Math.random().toString(36).slice(2);
+const internalInstanceKey = '__reactFiber$' + randomKey;
+const internalPropsKey = '__reactProps$' + randomKey;
+const internalContainerInstanceKey = '__reactContainer$' + randomKey;
+const internalEventHandlersKey = '__reactEvents$' + randomKey;
+const internalEventHandlerListenersKey = '__reactListeners$' + randomKey;
+const internalEventHandlesSetKey = '__reactHandles$' + randomKey;
+const internalRootNodeResourcesKey = '__reactResources$' + randomKey;
+const internalHoistableMarker = '__reactMarker$' + randomKey;
+function detachDeletedInstance(node) {
+  // TODO: This function is only called on host components. I don't think all of
+  // these fields are relevant.
+  delete node[internalInstanceKey];
+  delete node[internalPropsKey];
+  delete node[internalEventHandlersKey];
+  delete node[internalEventHandlerListenersKey];
+  delete node[internalEventHandlesSetKey];
+}
+function precacheFiberNode(hostInst, node) {
+  node[internalInstanceKey] = hostInst;
+}
+function markContainerAsRoot(hostRoot, node) {
+  // $FlowFixMe[prop-missing]
+  node[internalContainerInstanceKey] = hostRoot;
+}
+function unmarkContainerAsRoot(node) {
+  // $FlowFixMe[prop-missing]
+  node[internalContainerInstanceKey] = null;
+}
+function isContainerMarkedAsRoot(node) {
+  // $FlowFixMe[prop-missing]
+  return !!node[internalContainerInstanceKey];
+} // Given a DOM node, return the closest HostComponent or HostText fiber ancestor.
+// If the target node is part of a hydrated or not yet rendered subtree, then
+// this may also return a SuspenseComponent or HostRoot to indicate that.
+// Conceptually the HostRoot fiber is a child of the Container node. So if you
+// pass the Container node as the targetNode, you will not actually get the
+// HostRoot back. To get to the HostRoot, you need to pass a child of it.
+// The same thing applies to Suspense boundaries.
+
+function getClosestInstanceFromNode(targetNode) {
+  let targetInst = targetNode[internalInstanceKey];
+
+  if (targetInst) {
+    // Don't return HostRoot or SuspenseComponent here.
+    return targetInst;
+  } // If the direct event target isn't a React owned DOM node, we need to look
+  // to see if one of its parents is a React owned DOM node.
+
+
+  let parentNode = targetNode.parentNode;
+
+  while (parentNode) {
+    // We'll check if this is a container root that could include
+    // React nodes in the future. We need to check this first because
+    // if we're a child of a dehydrated container, we need to first
+    // find that inner container before moving on to finding the parent
+    // instance. Note that we don't check this field on  the targetNode
+    // itself because the fibers are conceptually between the container
+    // node and the first child. It isn't surrounding the container node.
+    // If it's not a container, we check if it's an instance.
+    targetInst = parentNode[internalContainerInstanceKey] || parentNode[internalInstanceKey];
+
+    if (targetInst) {
+      // Since this wasn't the direct target of the event, we might have
+      // stepped past dehydrated DOM nodes to get here. However they could
+      // also have been non-React nodes. We need to answer which one.
+      // If we the instance doesn't have any children, then there can't be
+      // a nested suspense boundary within it. So we can use this as a fast
+      // bailout. Most of the time, when people add non-React children to
+      // the tree, it is using a ref to a child-less DOM node.
+      // Normally we'd only need to check one of the fibers because if it
+      // has ever gone from having children to deleting them or vice versa
+      // it would have deleted the dehydrated boundary nested inside already.
+      // However, since the HostRoot starts out with an alternate it might
+      // have one on the alternate so we need to check in case this was a
+      // root.
+      const alternate = targetInst.alternate;
+
+      if (targetInst.child !== null || alternate !== null && alternate.child !== null) {
+        // Next we need to figure out if the node that skipped past is
+        // nested within a dehydrated boundary and if so, which one.
+        let suspenseInstance = getParentSuspenseInstance(targetNode);
+
+        while (suspenseInstance !== null) {
+          // We found a suspense instance. That means that we haven't
+          // hydrated it yet. Even though we leave the comments in the
+          // DOM after hydrating, and there are boundaries in the DOM
+          // that could already be hydrated, we wouldn't have found them
+          // through this pass since if the target is hydrated it would
+          // have had an internalInstanceKey on it.
+          // Let's get the fiber associated with the SuspenseComponent
+          // as the deepest instance.
+          // $FlowFixMe[prop-missing]
+          const targetSuspenseInst = suspenseInstance[internalInstanceKey];
+
+          if (targetSuspenseInst) {
+            return targetSuspenseInst;
+          } // If we don't find a Fiber on the comment, it might be because
+          // we haven't gotten to hydrate it yet. There might still be a
+          // parent boundary that hasn't above this one so we need to find
+          // the outer most that is known.
+
+
+          suspenseInstance = getParentSuspenseInstance(suspenseInstance); // If we don't find one, then that should mean that the parent
+          // host component also hasn't hydrated yet. We can return it
+          // below since it will bail out on the isMounted check later.
+        }
+      }
+
+      return targetInst;
+    }
+
+    targetNode = parentNode;
+    parentNode = targetNode.parentNode;
+  }
+
+  return null;
+}
+/**
+ * Given a DOM node, return the ReactDOMComponent or ReactDOMTextComponent
+ * instance, or null if the node was not rendered by this React.
+ */
+
+function getInstanceFromNode(node) {
+  const inst = node[internalInstanceKey] || node[internalContainerInstanceKey];
+
+  if (inst) {
+    const tag = inst.tag;
+
+    if (tag === HostComponent || tag === HostText || tag === SuspenseComponent || (tag === HostHoistable ) || (tag === HostSingleton ) || tag === HostRoot) {
+      return inst;
+    } else {
+      return null;
+    }
+  }
+
+  return null;
+}
+/**
+ * Given a ReactDOMComponent or ReactDOMTextComponent, return the corresponding
+ * DOM node.
+ */
+
+function getNodeFromInstance(inst) {
+  const tag = inst.tag;
+
+  if (tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton ) || tag === HostText) {
+    // In Fiber this, is just the state node right now. We assume it will be
+    // a host component or host text.
+    return inst.stateNode;
+  } // Without this first invariant, passing a non-DOM-component triggers the next
+  // invariant for a missing parent, which is super confusing.
+
+
+  throw Error(formatProdErrorMessage(33));
+}
+function getFiberCurrentPropsFromNode(node) {
+  return node[internalPropsKey] || null;
+}
+function updateFiberProps(node, props) {
+  node[internalPropsKey] = props;
+}
+function getEventListenerSet(node) {
+  let elementListenerSet = node[internalEventHandlersKey];
+
+  if (elementListenerSet === undefined) {
+    elementListenerSet = node[internalEventHandlersKey] = new Set();
+  }
+
+  return elementListenerSet;
+}
+function getResourcesFromRoot(root) {
+  let resources = root[internalRootNodeResourcesKey];
+
+  if (!resources) {
+    resources = root[internalRootNodeResourcesKey] = {
+      hoistableStyles: new Map(),
+      hoistableScripts: new Map()
+    };
+  }
+
+  return resources;
+}
+function isMarkedHoistable(node) {
+  return !!node[internalHoistableMarker];
+}
+function markNodeAsHoistable(node) {
+  node[internalHoistableMarker] = true;
+}
+function isOwnedInstance(node) {
+  return !!(node[internalHoistableMarker] || node[internalInstanceKey]);
+}
+
+const allNativeEvents = new Set();
+/**
+ * Mapping from registration name to event name
+ */
+
+
+const registrationNameDependencies = {};
+
+function registerTwoPhaseEvent(registrationName, dependencies) {
+  registerDirectEvent(registrationName, dependencies);
+  registerDirectEvent(registrationName + 'Capture', dependencies);
+}
+function registerDirectEvent(registrationName, dependencies) {
+
+  registrationNameDependencies[registrationName] = dependencies;
+
+  for (let i = 0; i < dependencies.length; i++) {
+    allNativeEvents.add(dependencies[i]);
+  }
+}
+
+const canUseDOM = !!(typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined');
+
+/* eslint-disable max-len */
+
+const ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
+/* eslint-enable max-len */
+
+const ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
+const VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+const illegalAttributeNameCache = {};
+const validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+  if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+    return true;
+  }
+
+  if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+    return false;
+  }
+
+  if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+    validatedAttributeNameCache[attributeName] = true;
+    return true;
+  }
+
+  illegalAttributeNameCache[attributeName] = true;
+
+  return false;
+}
+
+function setValueForAttribute(node, name, value) {
+  if (isAttributeNameSafe(name)) {
+    // If the prop isn't in the special list, treat it as a simple attribute.
+    // shouldRemoveAttribute
+    if (value === null) {
+      node.removeAttribute(name);
+      return;
+    }
+
+    switch (typeof value) {
+      case 'undefined':
+      case 'function':
+      case 'symbol':
+        // eslint-disable-line
+        node.removeAttribute(name);
+        return;
+
+      case 'boolean':
+        {
+          const prefix = name.toLowerCase().slice(0, 5);
+
+          if (prefix !== 'data-' && prefix !== 'aria-') {
+            node.removeAttribute(name);
+            return;
+          }
+        }
+    }
+
+    node.setAttribute(name, '' + value);
+  }
+}
+function setValueForKnownAttribute(node, name, value) {
+  if (value === null) {
+    node.removeAttribute(name);
+    return;
+  }
+
+  switch (typeof value) {
+    case 'undefined':
+    case 'function':
+    case 'symbol':
+    case 'boolean':
+      {
+        node.removeAttribute(name);
+        return;
+      }
+  }
+
+  node.setAttribute(name, '' + value);
+}
+function setValueForNamespacedAttribute(node, namespace, name, value) {
+  if (value === null) {
+    node.removeAttribute(name);
+    return;
+  }
+
+  switch (typeof value) {
+    case 'undefined':
+    case 'function':
+    case 'symbol':
+    case 'boolean':
+      {
+        node.removeAttribute(name);
+        return;
+      }
+  }
+
+  node.setAttributeNS(namespace, name, '' + value);
+}
+
+let prefix;
+function describeBuiltInComponentFrame(name, source, ownerFn) {
+  {
+    if (prefix === undefined) {
+      // Extract the VM specific prefix used by each line.
+      try {
+        throw Error();
+      } catch (x) {
+        const match = x.stack.trim().match(/\n( *(at )?)/);
+        prefix = match && match[1] || '';
+      }
+    } // We use the prefix to ensure our stacks line up with native stack frames.
+
+
+    return '\n' + prefix + name;
+  }
+}
+let reentry = false;
+let componentFrameCache;
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
+
+function describeNativeComponentFrame(fn, construct) {
+  // If something asked for a stack inside a fake render, it should get ignored.
+  if (!fn || reentry) {
+    return '';
+  }
+
+  reentry = true;
+  const previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
+
+  Error.prepareStackTrace = undefined;
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
+
+
+  const RunInRootFrame = {
+    DetermineComponentFrameRoot() {
+      let control;
+
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          const Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
+
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
+
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
+
+
+          const maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
+
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(() => {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
+      }
+
+      return [null, null];
+    }
+
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  const namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
+
+  try {
+    const _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+          sampleStack = _RunInRootFrame$Deter[0],
+          controlStack = _RunInRootFrame$Deter[1];
+
+    if (sampleStack && controlStack) {
+      // This extracts the first frame from the sample that isn't also in the control.
+      // Skipping one frame that we assume is the frame that calls the two.
+      const sampleLines = sampleStack.split('\n');
+      const controlLines = controlStack.split('\n');
+      let s = 0;
+      let c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
+      }
+
+      for (; s >= 1 && c >= 0; s--, c--) {
+        // Next we find the first one that isn't the same which should be the
+        // frame that called our sample function and the control.
+        if (sampleLines[s] !== controlLines[c]) {
+          // In V8, the first line is describing the message but other VMs don't.
+          // If we're about to return the first line, and the control is also on the same
+          // line, that's a pretty good indicator that our sample threw at same line as
+          // the control. I.e. before we entered the sample frame. So we ignore this result.
+          // This can happen if you passed a class to function component, or non-function.
+          if (s !== 1 || c !== 1) {
+            do {
+              s--;
+              c--; // We may still have similar intermediate frames from the construct call.
+              // The next one that isn't the same should be our match though.
+
+              if (c < 0 || sampleLines[s] !== controlLines[c]) {
+                // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
+                let frame = '\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled "<anonymous>"
+                // but we have a user-provided "displayName"
+                // splice it in to make the stack more readable.
+
+                if (fn.displayName && frame.includes('<anonymous>')) {
+                  frame = frame.replace('<anonymous>', fn.displayName);
+                }
+
+                if (false) ; // Return the line we found.
+
+
+                return frame;
+              }
+            } while (s >= 1 && c >= 0);
+          }
+
+          break;
+        }
+      }
+    }
+  } finally {
+    reentry = false;
+
+    Error.prepareStackTrace = previousPrepareStackTrace;
+  } // Fallback to just using the name if we couldn't make it throw.
+
+
+  const name = fn ? fn.displayName || fn.name : '';
+  const syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';
+
+  return syntheticFrame;
+}
+
+function describeClassComponentFrame(ctor, source, ownerFn) {
+  {
+    return describeNativeComponentFrame(ctor, true);
+  }
+}
+function describeFunctionComponentFrame(fn, source, ownerFn) {
+  {
+    return describeNativeComponentFrame(fn, false);
+  }
+}
+
+function describeFiber(fiber) {
+
+  switch (fiber.tag) {
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      return describeBuiltInComponentFrame(fiber.type);
+
+    case LazyComponent:
+      return describeBuiltInComponentFrame('Lazy');
+
+    case SuspenseComponent:
+      return describeBuiltInComponentFrame('Suspense');
+
+    case SuspenseListComponent:
+      return describeBuiltInComponentFrame('SuspenseList');
+
+    case FunctionComponent:
+    case IndeterminateComponent:
+    case SimpleMemoComponent:
+      return describeFunctionComponentFrame(fiber.type);
+
+    case ForwardRef:
+      return describeFunctionComponentFrame(fiber.type.render);
+
+    case ClassComponent:
+      return describeClassComponentFrame(fiber.type);
+
+    default:
+      return '';
+  }
+}
+
+function getStackByFiberInDevAndProd(workInProgress) {
+  try {
+    let info = '';
+    let node = workInProgress;
+
+    do {
+      info += describeFiber(node); // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+      node = node.return;
+    } while (node);
+
+    return info;
+  } catch (x) {
+    return '\nError generating stack: ' + x.message + '\n' + x.stack;
+  }
+}
+
+function getWrappedName$1(outerType, innerType, wrapperName) {
+  const displayName = outerType.displayName;
+
+  if (displayName) {
+    return displayName;
+  }
+
+  const functionName = innerType.displayName || innerType.name || '';
+  return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
+} // Keep in sync with react-reconciler/getComponentNameFromFiber
+
+
+function getContextName$1(type) {
+  return type.displayName || 'Context';
+} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+
+function getComponentNameFromType(type) {
+  if (type == null) {
+    // Host root, text node or just invalid type.
+    return null;
+  }
+
+  if (typeof type === 'function') {
+    return type.displayName || type.name || null;
+  }
+
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_FRAGMENT_TYPE:
+      return 'Fragment';
+
+    case REACT_PORTAL_TYPE:
+      return 'Portal';
+
+    case REACT_PROFILER_TYPE:
+      return 'Profiler';
+
+    case REACT_STRICT_MODE_TYPE:
+      return 'StrictMode';
+
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+
+    case REACT_CACHE_TYPE:
+      {
+        return 'Cache';
+      }
+
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        const context = type;
+        return getContextName$1(context) + '.Consumer';
+
+      case REACT_PROVIDER_TYPE:
+        const provider = type;
+        return getContextName$1(provider._context) + '.Provider';
+
+      case REACT_FORWARD_REF_TYPE:
+        return getWrappedName$1(type, type.render, 'ForwardRef');
+
+      case REACT_MEMO_TYPE:
+        const outerName = type.displayName || null;
+
+        if (outerName !== null) {
+          return outerName;
+        }
+
+        return getComponentNameFromType(type.type) || 'Memo';
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            return getComponentNameFromType(init(payload));
+          } catch (x) {
+            return null;
+          }
+        }
+
+    }
+  }
+
+  return null;
+}
+
+function getWrappedName(outerType, innerType, wrapperName) {
+  const functionName = innerType.displayName || innerType.name || '';
+  return outerType.displayName || (functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName);
+} // Keep in sync with shared/getComponentNameFromType
+
+
+function getContextName(type) {
+  return type.displayName || 'Context';
+}
+
+function getComponentNameFromFiber(fiber) {
+  const tag = fiber.tag,
+        type = fiber.type;
+
+  switch (tag) {
+    case CacheComponent:
+      return 'Cache';
+
+    case ContextConsumer:
+      const context = type;
+      return getContextName(context) + '.Consumer';
+
+    case ContextProvider:
+      const provider = type;
+      return getContextName(provider._context) + '.Provider';
+
+    case DehydratedFragment:
+      return 'DehydratedFragment';
+
+    case ForwardRef:
+      return getWrappedName(type, type.render, 'ForwardRef');
+
+    case Fragment:
+      return 'Fragment';
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      // Host component type is the display name (e.g. "div", "View")
+      return type;
+
+    case HostPortal:
+      return 'Portal';
+
+    case HostRoot:
+      return 'Root';
+
+    case HostText:
+      return 'Text';
+
+    case LazyComponent:
+      // Name comes from the type in this case; we don't have a tag.
+      return getComponentNameFromType(type);
+
+    case Mode:
+      if (type === REACT_STRICT_MODE_TYPE) {
+        // Don't be less specific than shared/getComponentNameFromType
+        return 'StrictMode';
+      }
+
+      return 'Mode';
+
+    case OffscreenComponent:
+      return 'Offscreen';
+
+    case Profiler:
+      return 'Profiler';
+
+    case ScopeComponent:
+      return 'Scope';
+
+    case SuspenseComponent:
+      return 'Suspense';
+
+    case SuspenseListComponent:
+      return 'SuspenseList';
+
+    case TracingMarkerComponent:
+      return 'TracingMarker';
+    // The display name for this tags come from the user-provided type:
+
+    case ClassComponent:
+    case FunctionComponent:
+    case IncompleteClassComponent:
+    case IndeterminateComponent:
+    case MemoComponent:
+    case SimpleMemoComponent:
+      if (typeof type === 'function') {
+        return type.displayName || type.name || null;
+      }
+
+      if (typeof type === 'string') {
+        return type;
+      }
+
+      break;
+
+  }
+
+  return null;
+}
+
+// around this limitation, we use an opaque type that can only be obtained by
+// passing the value through getToStringValue first.
+
+function toString(value) {
+  // The coercion safety check is performed in getToStringValue().
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  return '' + value;
+}
+function getToStringValue(value) {
+  switch (typeof value) {
+    case 'boolean':
+    case 'number':
+    case 'string':
+    case 'undefined':
+      return value;
+
+    case 'object':
+
+      return value;
+
+    default:
+      // function, symbol are assigned as empty strings
+      return '';
+  }
+}
+
+function isCheckable(elem) {
+  const type = elem.type;
+  const nodeName = elem.nodeName;
+  return nodeName && nodeName.toLowerCase() === 'input' && (type === 'checkbox' || type === 'radio');
+}
+
+function getTracker(node) {
+  return node._valueTracker;
+}
+
+function detachTracker(node) {
+  node._valueTracker = null;
+}
+
+function getValueFromNode(node) {
+  let value = '';
+
+  if (!node) {
+    return value;
+  }
+
+  if (isCheckable(node)) {
+    value = node.checked ? 'true' : 'false';
+  } else {
+    value = node.value;
+  }
+
+  return value;
+}
+
+function trackValueOnNode(node) {
+  const valueField = isCheckable(node) ? 'checked' : 'value';
+  const descriptor = Object.getOwnPropertyDescriptor(node.constructor.prototype, valueField);
+
+  let currentValue = '' + node[valueField]; // if someone has already defined a value or Safari, then bail
+  // and don't track value will cause over reporting of changes,
+  // but it's better then a hard failure
+  // (needed for certain tests that spyOn input values and Safari)
+
+  if (node.hasOwnProperty(valueField) || typeof descriptor === 'undefined' || typeof descriptor.get !== 'function' || typeof descriptor.set !== 'function') {
+    return;
+  }
+
+  const get = descriptor.get,
+        set = descriptor.set;
+  Object.defineProperty(node, valueField, {
+    configurable: true,
+    // $FlowFixMe[missing-this-annot]
+    get: function () {
+      return get.call(this);
+    },
+    // $FlowFixMe[missing-local-annot]
+    // $FlowFixMe[missing-this-annot]
+    set: function (value) {
+
+      currentValue = '' + value;
+      set.call(this, value);
+    }
+  }); // We could've passed this the first time
+  // but it triggers a bug in IE11 and Edge 14/15.
+  // Calling defineProperty() again should be equivalent.
+  // https://github.com/facebook/react/issues/11768
+
+  Object.defineProperty(node, valueField, {
+    enumerable: descriptor.enumerable
+  });
+  const tracker = {
+    getValue() {
+      return currentValue;
+    },
+
+    setValue(value) {
+
+      currentValue = '' + value;
+    },
+
+    stopTracking() {
+      detachTracker(node);
+      delete node[valueField];
+    }
+
+  };
+  return tracker;
+}
+
+function track(node) {
+  if (getTracker(node)) {
+    return;
+  }
+
+  node._valueTracker = trackValueOnNode(node);
+}
+function updateValueIfChanged(node) {
+  if (!node) {
+    return false;
+  }
+
+  const tracker = getTracker(node); // if there is no tracker at this point it's unlikely
+  // that trying again will succeed
+
+  if (!tracker) {
+    return true;
+  }
+
+  const lastValue = tracker.getValue();
+  const nextValue = getValueFromNode(node);
+
+  if (nextValue !== lastValue) {
+    tracker.setValue(nextValue);
+    return true;
+  }
+
+  return false;
+}
+
+function getActiveElement(doc) {
+  doc = doc || (typeof document !== 'undefined' ? document : undefined);
+
+  if (typeof doc === 'undefined') {
+    return null;
+  }
+
+  try {
+    return doc.activeElement || doc.body;
+  } catch (e) {
+    return doc.body;
+  }
+}
+
+// When passing user input into querySelector(All) the embedded string must not alter
+// the semantics of the query. This escape function is safe to use when we know the
+// provided value is going to be wrapped in double quotes as part of an attribute selector
+// Do not use it anywhere else
+// we escape double quotes and backslashes
+const escapeSelectorAttributeValueInsideDoubleQuotesRegex = /[\n\"\\]/g;
+function escapeSelectorAttributeValueInsideDoubleQuotes(value) {
+  return value.replace(escapeSelectorAttributeValueInsideDoubleQuotesRegex, ch => '\\' + ch.charCodeAt(0).toString(16) + ' ');
+}
+
+function updateInput(element, value, defaultValue, lastDefaultValue, checked, defaultChecked, type, name) {
+  const node = element; // Temporarily disconnect the input from any radio buttons.
+  // Changing the type or name as the same time as changing the checked value
+  // needs to be atomically applied. We can only ensure that by disconnecting
+  // the name while do the mutations and then reapply the name after that's done.
+
+  node.name = '';
+
+  if (type != null && typeof type !== 'function' && typeof type !== 'symbol' && typeof type !== 'boolean') {
+
+    node.type = type;
+  } else {
+    node.removeAttribute('type');
+  }
+
+  if (value != null) {
+    if (type === 'number') {
+      if ( // $FlowFixMe[incompatible-type]
+      value === 0 && node.value === '' || // We explicitly want to coerce to number here if possible.
+      // eslint-disable-next-line
+      node.value != value) {
+        node.value = toString(getToStringValue(value));
+      }
+    } else if (node.value !== toString(getToStringValue(value))) {
+      node.value = toString(getToStringValue(value));
+    }
+  } else if (type === 'submit' || type === 'reset') {
+    // Submit/reset inputs need the attribute removed completely to avoid
+    // blank-text buttons.
+    node.removeAttribute('value');
+  }
+
+  {
+    // When syncing the value attribute, the value comes from a cascade of
+    // properties:
+    //  1. The value React property
+    //  2. The defaultValue React property
+    //  3. Otherwise there should be no change
+    if (value != null) {
+      setDefaultValue(node, type, getToStringValue(value));
+    } else if (defaultValue != null) {
+      setDefaultValue(node, type, getToStringValue(defaultValue));
+    } else if (lastDefaultValue != null) {
+      node.removeAttribute('value');
+    }
+  }
+
+  {
+    // 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 (checked == null && defaultChecked != null) {
+      node.defaultChecked = !!defaultChecked;
+    }
+  }
+
+  if (checked != null) {
+    // Important to set this even if it's not a change in order to update input
+    // value tracking with radio buttons
+    // TODO: Should really update input value tracking for the whole radio
+    // button group in an effect or something (similar to #27024)
+    node.checked = checked && typeof checked !== 'function' && typeof checked !== 'symbol';
+  }
+
+  if (name != null && typeof name !== 'function' && typeof name !== 'symbol' && typeof name !== 'boolean') {
+
+    node.name = toString(getToStringValue(name));
+  } else {
+    node.removeAttribute('name');
+  }
+}
+function initInput(element, value, defaultValue, checked, defaultChecked, type, name, isHydrating) {
+  const node = element;
+
+  if (type != null && typeof type !== 'function' && typeof type !== 'symbol' && typeof type !== 'boolean') {
+
+    node.type = type;
+  }
+
+  if (value != null || defaultValue != null) {
+    const isButton = type === 'submit' || type === 'reset'; // Avoid setting value attribute on submit/reset inputs as it overrides the
+    // default value provided by the browser. See: #12872
+
+    if (isButton && (value === undefined || value === null)) {
+      return;
+    }
+
+    const defaultValueStr = defaultValue != null ? toString(getToStringValue(defaultValue)) : '';
+    const initialValue = value != null ? toString(getToStringValue(value)) : defaultValueStr; // Do not assign value if it is already set. This prevents user text input
+    // from being lost during SSR hydration.
+
+    if (!isHydrating) {
+      {
+        // When syncing the value attribute, the value property should use
+        // the wrapperState._initialValue property. This uses:
+        //
+        //   1. The value React property when present
+        //   2. The defaultValue React property when present
+        //   3. An empty string
+        if (initialValue !== node.value) {
+          node.value = initialValue;
+        }
+      }
+    }
+
+    {
+      // Otherwise, the value attribute is synchronized to the property,
+      // so we assign defaultValue to the same thing as the value property
+      // assignment step above.
+      node.defaultValue = initialValue;
+    }
+  } // Normally, we'd just do `node.checked = node.checked` upon initial mount, less this bug
+  // this is needed to work around a chrome bug where setting defaultChecked
+  // will sometimes influence the value of checked (even after detachment).
+  // Reference: https://bugs.chromium.org/p/chromium/issues/detail?id=608416
+  // We need to temporarily unset name to avoid disrupting radio button groups.
+
+
+  const checkedOrDefault = checked != null ? checked : defaultChecked; // TODO: This 'function' or 'symbol' check isn't replicated in other places
+  // so this semantic is inconsistent.
+
+  const initialChecked = typeof checkedOrDefault !== 'function' && typeof checkedOrDefault !== 'symbol' && !!checkedOrDefault;
+
+  if (isHydrating) {
+    // Detach .checked from .defaultChecked but leave user input alone
+    node.checked = node.checked;
+  } else {
+    node.checked = !!initialChecked;
+  }
+
+  {
+    // When syncing the checked attribute, both the checked property and
+    // attribute are assigned at the same time using defaultChecked. This uses:
+    //
+    //   1. The checked React property when present
+    //   2. The defaultChecked React property when present
+    //   3. Otherwise, false
+    node.defaultChecked = !node.defaultChecked;
+    node.defaultChecked = !!initialChecked;
+  } // Name needs to be set at the end so that it applies atomically to connected radio buttons.
+
+
+  if (name != null && typeof name !== 'function' && typeof name !== 'symbol' && typeof name !== 'boolean') {
+
+    node.name = name;
+  }
+}
+function restoreControlledInputState(element, props) {
+  const rootNode = element;
+  updateInput(rootNode, props.value, props.defaultValue, props.defaultValue, props.checked, props.defaultChecked, props.type, props.name);
+  const name = props.name;
+
+  if (props.type === 'radio' && name != null) {
+    let queryRoot = rootNode;
+
+    while (queryRoot.parentNode) {
+      queryRoot = queryRoot.parentNode;
+    } // If `rootNode.form` was non-null, then we could try `form.elements`,
+
+    const group = queryRoot.querySelectorAll('input[name="' + escapeSelectorAttributeValueInsideDoubleQuotes('' + name) + '"][type="radio"]');
+
+    for (let i = 0; i < group.length; i++) {
+      const otherNode = group[i];
+
+      if (otherNode === rootNode || otherNode.form !== rootNode.form) {
+        continue;
+      } // This will throw if radio buttons rendered by different copies of React
+      // and the same name are rendered into the same form (same as #1939).
+      // That's probably okay; we don't support it just as we don't support
+      // mixing React radio buttons with non-React ones.
+
+
+      const otherProps = getFiberCurrentPropsFromNode(otherNode);
+
+      if (!otherProps) {
+        throw Error(formatProdErrorMessage(90));
+      } // If this is a controlled radio button group, forcing the input that
+      // was previously checked to update will cause it to be come re-checked
+      // as appropriate.
+
+
+      updateInput(otherNode, otherProps.value, otherProps.defaultValue, otherProps.defaultValue, otherProps.checked, otherProps.defaultChecked, otherProps.type, otherProps.name);
+    } // If any updateInput() call set .checked to true, an input in this group
+    // (often, `rootNode` itself) may have become unchecked
+
+
+    for (let i = 0; i < group.length; i++) {
+      const otherNode = group[i];
+
+      if (otherNode.form !== rootNode.form) {
+        continue;
+      }
+
+      updateValueIfChanged(otherNode);
+    }
+  }
+} // In Chrome, assigning defaultValue to certain input types triggers input validation.
+// For number inputs, the display value loses trailing decimal points. For email inputs,
+// Chrome raises "The specified value <x> is not a valid email address".
+//
+// Here we check to see if the defaultValue has actually changed, avoiding these problems
+// when the user is inputting text
+//
+// https://github.com/facebook/react/issues/7253
+
+function setDefaultValue(node, type, value) {
+  if ( // Focused number inputs synchronize on blur. See ChangeEventPlugin.js
+  type !== 'number' || getActiveElement(node.ownerDocument) !== node) {
+    if (node.defaultValue !== toString(value)) {
+      node.defaultValue = toString(value);
+    }
+  }
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+// TODO: direct imports like some-package/src/* are bad. Fix me.
+
+function updateOptions(node, multiple, propValue, setDefaultSelected) {
+  const options = node.options;
+
+  if (multiple) {
+    const selectedValues = propValue;
+    const selectedValue = {};
+
+    for (let i = 0; i < selectedValues.length; i++) {
+      // Prefix to avoid chaos with special keys.
+      selectedValue['$' + selectedValues[i]] = true;
+    }
+
+    for (let i = 0; i < options.length; i++) {
+      const selected = selectedValue.hasOwnProperty('$' + options[i].value);
+
+      if (options[i].selected !== selected) {
+        options[i].selected = selected;
+      }
+
+      if (selected && setDefaultSelected) {
+        options[i].defaultSelected = true;
+      }
+    }
+  } else {
+    // Do not set `select.value` as exact behavior isn't consistent across all
+    // browsers for all cases.
+    const selectedValue = toString(getToStringValue(propValue));
+    let defaultSelected = null;
+
+    for (let i = 0; i < options.length; i++) {
+      if (options[i].value === selectedValue) {
+        options[i].selected = true;
+
+        if (setDefaultSelected) {
+          options[i].defaultSelected = true;
+        }
+
+        return;
+      }
+
+      if (defaultSelected === null && !options[i].disabled) {
+        defaultSelected = options[i];
+      }
+    }
+
+    if (defaultSelected !== null) {
+      defaultSelected.selected = true;
+    }
+  }
+}
+function initSelect(element, value, defaultValue, multiple) {
+  const node = element;
+  node.multiple = !!multiple;
+
+  if (value != null) {
+    updateOptions(node, !!multiple, value, false);
+  } else if (defaultValue != null) {
+    updateOptions(node, !!multiple, defaultValue, true);
+  }
+}
+function updateSelect(element, value, defaultValue, multiple, wasMultiple) {
+  const node = element;
+
+  if (value != null) {
+    updateOptions(node, !!multiple, value, false);
+  } else if (!!wasMultiple !== !!multiple) {
+    // For simplicity, reapply `defaultValue` if `multiple` is toggled.
+    if (defaultValue != null) {
+      updateOptions(node, !!multiple, defaultValue, true);
+    } else {
+      // Revert the select back to its default unselected state.
+      updateOptions(node, !!multiple, multiple ? [] : '', false);
+    }
+  }
+}
+function restoreControlledSelectState(element, props) {
+  const node = element;
+  const value = props.value;
+
+  if (value != null) {
+    updateOptions(node, !!props.multiple, value, false);
+  }
+}
+
+function updateTextarea(element, value, defaultValue) {
+  const node = element;
+
+  if (value != null) {
+    // Cast `value` to a string to ensure the value is set correctly. While
+    // browsers typically do this as necessary, jsdom doesn't.
+    const newValue = toString(getToStringValue(value)); // To avoid side effects (such as losing text selection), only set value if changed
+
+    if (newValue !== node.value) {
+      node.value = newValue;
+    } // TOOO: This should respect disableInputAttributeSyncing flag.
+
+
+    if (defaultValue == null) {
+      if (node.defaultValue !== newValue) {
+        node.defaultValue = newValue;
+      }
+
+      return;
+    }
+  }
+
+  if (defaultValue != null) {
+    node.defaultValue = toString(getToStringValue(defaultValue));
+  } else {
+    node.defaultValue = '';
+  }
+}
+function initTextarea(element, value, defaultValue, children) {
+  const node = element;
+  let initialValue = value; // Only bother fetching default value if we're going to use it
+
+  if (initialValue == null) {
+    if (children != null) {
+      {
+        if (defaultValue != null) {
+          throw Error(formatProdErrorMessage(92));
+        }
+
+        if (isArray(children)) {
+          if (children.length > 1) {
+            throw Error(formatProdErrorMessage(93));
+          }
+
+          children = children[0];
+        }
+
+        defaultValue = children;
+      }
+    }
+
+    if (defaultValue == null) {
+      defaultValue = '';
+    }
+
+    initialValue = defaultValue;
+  }
+
+  const stringValue = getToStringValue(initialValue);
+  node.defaultValue = stringValue; // This will be toString:ed.
+  // This is in postMount because we need access to the DOM node, which is not
+  // available until after the component has mounted.
+
+  const textContent = node.textContent; // Only set node.value if textContent is equal to the expected
+  // initial value. In IE10/IE11 there is a bug where the placeholder attribute
+  // will populate textContent as well.
+  // https://developer.microsoft.com/microsoft-edge/platform/issues/101525/
+
+  if (textContent === stringValue) {
+    if (textContent !== '' && textContent !== null) {
+      node.value = textContent;
+    }
+  }
+}
+function restoreControlledTextareaState(element, props) {
+  // DOM component is still mounted; update
+  updateTextarea(element, props.value, props.defaultValue);
+}
+
+const MATH_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
+const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
+
+/* globals MSApp */
+
+let reusableSVGContainer;
+
+function setInnerHTMLImpl(node, html) {
+  if (node.namespaceURI === SVG_NAMESPACE) {
+
+    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
+      // the target node
+      reusableSVGContainer = reusableSVGContainer || document.createElement('div');
+      reusableSVGContainer.innerHTML = '<svg>' + html.valueOf().toString() + '</svg>';
+      const svgNode = reusableSVGContainer.firstChild;
+
+      while (node.firstChild) {
+        node.removeChild(node.firstChild);
+      } // $FlowFixMe[incompatible-use]
+      // $FlowFixMe[incompatible-type]
+
+
+      while (svgNode.firstChild) {
+        node.appendChild(svgNode.firstChild);
+      }
+
+      return;
+    }
+  }
+
+  node.innerHTML = html;
+}
+
+let setInnerHTML = setInnerHTMLImpl; // $FlowFixMe[cannot-resolve-name]
+
+if (typeof MSApp !== 'undefined' && MSApp.execUnsafeLocalFunction) {
+  /**
+   * Create a function which has 'unsafe' privileges (required by windows8 apps)
+   */
+  setInnerHTML = function (node, html) {
+    // $FlowFixMe[cannot-resolve-name]
+    return MSApp.execUnsafeLocalFunction(function () {
+      return setInnerHTMLImpl(node, html);
+    });
+  };
+}
+
+var setInnerHTML$1 = setInnerHTML;
+
+/**
+ * HTML nodeType values that represent the type of the node
+ */
+const ELEMENT_NODE = 1;
+const TEXT_NODE = 3;
+const COMMENT_NODE = 8;
+const DOCUMENT_NODE = 9;
+const DOCUMENT_TYPE_NODE = 10;
+const DOCUMENT_FRAGMENT_NODE = 11;
+
+/**
+ * Set the textContent property of a node. For text updates, it's faster
+ * to set the `nodeValue` of the Text node directly instead of using
+ * `.textContent` which will remove the existing node and create a new one.
+ *
+ * @param {DOMElement} node
+ * @param {string} text
+ * @internal
+ */
+
+function setTextContent(node, text) {
+  if (text) {
+    const firstChild = node.firstChild;
+
+    if (firstChild && firstChild === node.lastChild && firstChild.nodeType === TEXT_NODE) {
+      firstChild.nodeValue = text;
+      return;
+    }
+  }
+
+  node.textContent = text;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+const unitlessNumbers = new Set(['animationIterationCount', 'aspectRatio', 'borderImageOutset', 'borderImageSlice', 'borderImageWidth', 'boxFlex', 'boxFlexGroup', 'boxOrdinalGroup', 'columnCount', 'columns', 'flex', 'flexGrow', 'flexPositive', 'flexShrink', 'flexNegative', 'flexOrder', 'gridArea', 'gridRow', 'gridRowEnd', 'gridRowSpan', 'gridRowStart', 'gridColumn', 'gridColumnEnd', 'gridColumnSpan', 'gridColumnStart', 'fontWeight', 'lineClamp', 'lineHeight', 'opacity', 'order', 'orphans', 'scale', 'tabSize', 'widows', 'zIndex', 'zoom', 'fillOpacity', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'MozBoxFlexGroup', 'MozLineClamp', 'msAnimationIterationCount', 'msFlex', 'msZoom', 'msFlexGrow', 'msFlexNegative', 'msFlexOrder', 'msFlexPositive', 'msFlexShrink', 'msGridColumn', 'msGridColumnSpan', 'msGridRow', 'msGridRowSpan', 'WebkitAnimationIterationCount', 'WebkitBoxFlex', 'WebKitBoxFlexGroup', 'WebkitBoxOrdinalGroup', 'WebkitColumnCount', 'WebkitColumns', 'WebkitFlex', 'WebkitFlexGrow', 'WebkitFlexPositive', 'WebkitFlexShrink', 'WebkitLineClamp']);
+function isUnitlessNumber (name) {
+  return unitlessNumbers.has(name);
+}
+
+function setValueForStyle(style, styleName, value) {
+  const isCustomProperty = styleName.indexOf('--') === 0;
+
+  if (value == null || typeof value === 'boolean' || value === '') {
+    if (isCustomProperty) {
+      style.setProperty(styleName, '');
+    } else if (styleName === 'float') {
+      style.cssFloat = '';
+    } else {
+      style[styleName] = '';
+    }
+  } else if (isCustomProperty) {
+    style.setProperty(styleName, value);
+  } else if (typeof value === 'number' && value !== 0 && !isUnitlessNumber(styleName)) {
+    style[styleName] = value + 'px'; // Presumes implicit 'px' suffix for unitless numbers
+  } else {
+    if (styleName === 'float') {
+      style.cssFloat = value;
+    } else {
+
+      style[styleName] = ('' + value).trim();
+    }
+  }
+}
+/**
+ * Sets the value for multiple styles on a node.  If a value is specified as
+ * '' (empty string), the corresponding style property will be unset.
+ *
+ * @param {DOMElement} node
+ * @param {object} styles
+ */
+
+
+function setValueForStyles(node, styles, prevStyles) {
+  if (styles != null && typeof styles !== 'object') {
+    throw Error(formatProdErrorMessage(62));
+  }
+
+  const style = node.style;
+
+  if (prevStyles != null) {
+
+    for (const styleName in prevStyles) {
+      if (prevStyles.hasOwnProperty(styleName) && (styles == null || !styles.hasOwnProperty(styleName))) {
+        // Clear style
+        const isCustomProperty = styleName.indexOf('--') === 0;
+
+        if (isCustomProperty) {
+          style.setProperty(styleName, '');
+        } else if (styleName === 'float') {
+          style.cssFloat = '';
+        } else {
+          style[styleName] = '';
+        }
+      }
+    }
+
+    for (const styleName in styles) {
+      const value = styles[styleName];
+
+      if (styles.hasOwnProperty(styleName) && prevStyles[styleName] !== value) {
+        setValueForStyle(style, styleName, value);
+      }
+    }
+  } else {
+    for (const styleName in styles) {
+      if (styles.hasOwnProperty(styleName)) {
+        const value = styles[styleName];
+        setValueForStyle(style, styleName, value);
+      }
+    }
+  }
+}
+
+function isCustomElement(tagName, props) {
+  if (tagName.indexOf('-') === -1) {
+    return false;
+  }
+
+  switch (tagName) {
+    // These are reserved SVG and MathML elements.
+    // We don't mind this list too much because we expect it to never grow.
+    // The alternative is to track the namespace in a few places which is convoluted.
+    // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+    case 'annotation-xml':
+    case 'color-profile':
+    case 'font-face':
+    case 'font-face-src':
+    case 'font-face-uri':
+    case 'font-face-format':
+    case 'font-face-name':
+    case 'missing-glyph':
+      return false;
+
+    default:
+      return true;
+  }
+}
+
+const aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+  return aliases.get(name) || name;
+}
+
+function sanitizeURL(url) {
+
+  return url;
+}
+
+const IS_EVENT_HANDLE_NON_MANAGED_NODE = 1;
+const IS_NON_DELEGATED = 1 << 1;
+const IS_CAPTURE_PHASE = 1 << 2;
+// 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.
+// We also don't want to defer during event replaying.
+
+const SHOULD_NOT_PROCESS_POLYFILL_EVENT_PLUGINS = IS_EVENT_HANDLE_NON_MANAGED_NODE | IS_NON_DELEGATED | IS_CAPTURE_PHASE;
+
+// This exists to avoid circular dependency between ReactDOMEventReplaying
+// and DOMPluginEventSystem.
+let currentReplayingEvent = null;
+function setReplayingEvent(event) {
+
+  currentReplayingEvent = event;
+}
+function resetReplayingEvent() {
+
+  currentReplayingEvent = null;
+}
+function isReplayingEvent(event) {
+  return event === currentReplayingEvent;
+}
+
+/**
+ * Gets the target node from a native browser event by accounting for
+ * inconsistencies in browser DOM APIs.
+ *
+ * @param {object} nativeEvent Native browser event.
+ * @return {DOMEventTarget} Target node.
+ */
+
+function getEventTarget(nativeEvent) {
+  // Fallback to nativeEvent.srcElement for IE9
+  // https://github.com/facebook/react/issues/12506
+  let target = nativeEvent.target || nativeEvent.srcElement || window; // Normalize SVG <use> element events #4963
+
+  if (target.correspondingUseElement) {
+    target = target.correspondingUseElement;
+  } // Safari may fire events on text nodes (Node.TEXT_NODE is 3).
+  // @see http://www.quirksmode.org/js/events_properties.html
+
+
+  return target.nodeType === TEXT_NODE ? target.parentNode : target;
+}
+
+let restoreTarget = null;
+let restoreQueue = null;
+
+function restoreStateOfTarget(target) {
+  // We perform this translation at the end of the event loop so that we
+  // always receive the correct fiber here
+  const internalInstance = getInstanceFromNode(target);
+
+  if (!internalInstance) {
+    // Unmounted
+    return;
+  }
+
+  const stateNode = internalInstance.stateNode; // Guard against Fiber being unmounted.
+
+  if (stateNode) {
+    const props = getFiberCurrentPropsFromNode(stateNode);
+    restoreControlledState(internalInstance.stateNode, internalInstance.type, props);
+  }
+}
+
+function enqueueStateRestore(target) {
+  if (restoreTarget) {
+    if (restoreQueue) {
+      restoreQueue.push(target);
+    } else {
+      restoreQueue = [target];
+    }
+  } else {
+    restoreTarget = target;
+  }
+}
+function needsStateRestore() {
+  return restoreTarget !== null || restoreQueue !== null;
+}
+function restoreStateIfNeeded() {
+  if (!restoreTarget) {
+    return;
+  }
+
+  const target = restoreTarget;
+  const queuedTargets = restoreQueue;
+  restoreTarget = null;
+  restoreQueue = null;
+  restoreStateOfTarget(target);
+
+  if (queuedTargets) {
+    for (let i = 0; i < queuedTargets.length; i++) {
+      restoreStateOfTarget(queuedTargets[i]);
+    }
+  }
+}
+
+/**
+ * `ReactInstanceMap` maintains a mapping from a public facing stateful
+ * instance (key) and the internal representation (value). This allows public
+ * methods to accept the user facing instance as an argument and map them back
+ * to internal methods.
+ *
+ * Note that this module is currently shared and assumed to be stateless.
+ * If this becomes an actual Map, that will break.
+ */
+function get(key) {
+  return key._reactInternals;
+}
+function has(key) {
+  return key._reactInternals !== undefined;
+}
+function set(key, value) {
+  key._reactInternals = value;
+}
+
+function getNearestMountedFiber(fiber) {
+  let node = fiber;
+  let nearestMounted = fiber;
+
+  if (!fiber.alternate) {
+    // If there is no alternate, this might be a new tree that isn't inserted
+    // yet. If it is, then it will have a pending insertion effect on it.
+    let nextNode = node;
+
+    do {
+      node = nextNode;
+
+      if ((node.flags & (Placement | Hydrating)) !== NoFlags$1) {
+        // This is an insertion or in-progress hydration. The nearest possible
+        // mounted fiber is the parent but we need to continue to figure out
+        // if that one is still mounted.
+        nearestMounted = node.return;
+      } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+      nextNode = node.return;
+    } while (nextNode);
+  } else {
+    while (node.return) {
+      node = node.return;
+    }
+  }
+
+  if (node.tag === HostRoot) {
+    // TODO: Check if this was a nested HostRoot when used with
+    // renderContainerIntoSubtree.
+    return nearestMounted;
+  } // If we didn't hit the root, that means that we're in an disconnected tree
+  // that has been unmounted.
+
+
+  return null;
+}
+function getSuspenseInstanceFromFiber(fiber) {
+  if (fiber.tag === SuspenseComponent) {
+    let suspenseState = fiber.memoizedState;
+
+    if (suspenseState === null) {
+      const current = fiber.alternate;
+
+      if (current !== null) {
+        suspenseState = current.memoizedState;
+      }
+    }
+
+    if (suspenseState !== null) {
+      return suspenseState.dehydrated;
+    }
+  }
+
+  return null;
+}
+function getContainerFromFiber(fiber) {
+  return fiber.tag === HostRoot ? fiber.stateNode.containerInfo : null;
+}
+function isFiberMounted(fiber) {
+  return getNearestMountedFiber(fiber) === fiber;
+}
+function isMounted(component) {
+
+  const fiber = get(component);
+
+  if (!fiber) {
+    return false;
+  }
+
+  return getNearestMountedFiber(fiber) === fiber;
+}
+
+function assertIsMounted(fiber) {
+  if (getNearestMountedFiber(fiber) !== fiber) {
+    throw Error(formatProdErrorMessage(188));
+  }
+}
+
+function findCurrentFiberUsingSlowPath(fiber) {
+  const alternate = fiber.alternate;
+
+  if (!alternate) {
+    // If there is no alternate, then we only need to check if it is mounted.
+    const nearestMounted = getNearestMountedFiber(fiber);
+
+    if (nearestMounted === null) {
+      throw Error(formatProdErrorMessage(188));
+    }
+
+    if (nearestMounted !== fiber) {
+      return null;
+    }
+
+    return fiber;
+  } // If we have two possible branches, we'll walk backwards up to the root
+  // to see what path the root points to. On the way we may hit one of the
+  // special cases and we'll deal with them.
+
+
+  let a = fiber;
+  let b = alternate;
+
+  while (true) {
+    const parentA = a.return;
+
+    if (parentA === null) {
+      // We're at the root.
+      break;
+    }
+
+    const parentB = parentA.alternate;
+
+    if (parentB === null) {
+      // There is no alternate. This is an unusual case. Currently, it only
+      // happens when a Suspense component is hidden. An extra fragment fiber
+      // is inserted in between the Suspense fiber and its children. Skip
+      // over this extra fragment fiber and proceed to the next parent.
+      const nextParent = parentA.return;
+
+      if (nextParent !== null) {
+        a = b = nextParent;
+        continue;
+      } // If there's no parent, we're at the root.
+
+
+      break;
+    } // If both copies of the parent fiber point to the same child, we can
+    // assume that the child is current. This happens when we bailout on low
+    // priority: the bailed out fiber's child reuses the current child.
+
+
+    if (parentA.child === parentB.child) {
+      let child = parentA.child;
+
+      while (child) {
+        if (child === a) {
+          // We've determined that A is the current branch.
+          assertIsMounted(parentA);
+          return fiber;
+        }
+
+        if (child === b) {
+          // We've determined that B is the current branch.
+          assertIsMounted(parentA);
+          return alternate;
+        }
+
+        child = child.sibling;
+      } // We should never have an alternate for any mounting node. So the only
+      // way this could possibly happen is if this was unmounted, if at all.
+
+
+      throw Error(formatProdErrorMessage(188));
+    }
+
+    if (a.return !== b.return) {
+      // The return pointer of A and the return pointer of B point to different
+      // fibers. We assume that return pointers never criss-cross, so A must
+      // belong to the child set of A.return, and B must belong to the child
+      // set of B.return.
+      a = parentA;
+      b = parentB;
+    } else {
+      // The return pointers point to the same fiber. We'll have to use the
+      // default, slow path: scan the child sets of each parent alternate to see
+      // which child belongs to which set.
+      //
+      // Search parent A's child set
+      let didFindChild = false;
+      let child = parentA.child;
+
+      while (child) {
+        if (child === a) {
+          didFindChild = true;
+          a = parentA;
+          b = parentB;
+          break;
+        }
+
+        if (child === b) {
+          didFindChild = true;
+          b = parentA;
+          a = parentB;
+          break;
+        }
+
+        child = child.sibling;
+      }
+
+      if (!didFindChild) {
+        // Search parent B's child set
+        child = parentB.child;
+
+        while (child) {
+          if (child === a) {
+            didFindChild = true;
+            a = parentB;
+            b = parentA;
+            break;
+          }
+
+          if (child === b) {
+            didFindChild = true;
+            b = parentB;
+            a = parentA;
+            break;
+          }
+
+          child = child.sibling;
+        }
+
+        if (!didFindChild) {
+          throw Error(formatProdErrorMessage(189));
+        }
+      }
+    }
+
+    if (a.alternate !== b) {
+      throw Error(formatProdErrorMessage(190));
+    }
+  } // If the root is not a host container, we're in a disconnected tree. I.e.
+  // unmounted.
+
+
+  if (a.tag !== HostRoot) {
+    throw Error(formatProdErrorMessage(188));
+  }
+
+  if (a.stateNode.current === a) {
+    // We've determined that A is the current branch.
+    return fiber;
+  } // Otherwise B has to be current branch.
+
+
+  return alternate;
+}
+function findCurrentHostFiber(parent) {
+  const currentParent = findCurrentFiberUsingSlowPath(parent);
+  return currentParent !== null ? findCurrentHostFiberImpl(currentParent) : null;
+}
+
+function findCurrentHostFiberImpl(node) {
+  // Next we'll drill down this component to find the first HostComponent/Text.
+  const tag = node.tag;
+
+  if (tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton ) || tag === HostText) {
+    return node;
+  }
+
+  let child = node.child;
+
+  while (child !== null) {
+    const match = findCurrentHostFiberImpl(child);
+
+    if (match !== null) {
+      return match;
+    }
+
+    child = child.sibling;
+  }
+
+  return null;
+}
+
+const emptyContextObject = {};
+
+
+const contextStackCursor = createCursor(emptyContextObject); // A cursor to a boolean indicating whether the context has changed.
+
+const didPerformWorkStackCursor = createCursor(false); // Keep track of the previous context object that was on the stack.
+// We use this to get access to the parent context after we have already
+// pushed the next context provider, and now need to merge their contexts.
+
+let previousContext = emptyContextObject;
+
+function getUnmaskedContext(workInProgress, Component, didPushOwnContextIfProvider) {
+  {
+    if (didPushOwnContextIfProvider && isContextProvider(Component)) {
+      // If the fiber is a context provider itself, when we read its context
+      // we may have already pushed its own child context on the stack. A context
+      // provider should not "see" its own child context. Therefore we read the
+      // previous (parent) context instead for a context provider.
+      return previousContext;
+    }
+
+    return contextStackCursor.current;
+  }
+}
+
+function cacheContext(workInProgress, unmaskedContext, maskedContext) {
+  {
+    const instance = workInProgress.stateNode;
+    instance.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext;
+    instance.__reactInternalMemoizedMaskedChildContext = maskedContext;
+  }
+}
+
+function getMaskedContext(workInProgress, unmaskedContext) {
+  {
+    const type = workInProgress.type;
+    const contextTypes = type.contextTypes;
+
+    if (!contextTypes) {
+      return emptyContextObject;
+    } // Avoid recreating masked context unless unmasked context has changed.
+    // Failing to do this will result in unnecessary calls to componentWillReceiveProps.
+    // This may trigger infinite loops if componentWillReceiveProps calls setState.
+
+
+    const instance = workInProgress.stateNode;
+
+    if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) {
+      return instance.__reactInternalMemoizedMaskedChildContext;
+    }
+
+    const context = {};
+
+    for (const key in contextTypes) {
+      context[key] = unmaskedContext[key];
+    }
+    // Context is created before the class component is instantiated so check for instance.
+
+
+    if (instance) {
+      cacheContext(workInProgress, unmaskedContext, context);
+    }
+
+    return context;
+  }
+}
+
+function hasContextChanged() {
+  {
+    return didPerformWorkStackCursor.current;
+  }
+}
+
+function isContextProvider(type) {
+  {
+    const childContextTypes = type.childContextTypes;
+    return childContextTypes !== null && childContextTypes !== undefined;
+  }
+}
+
+function popContext(fiber) {
+  {
+    pop(didPerformWorkStackCursor);
+    pop(contextStackCursor);
+  }
+}
+
+function popTopLevelContextObject(fiber) {
+  {
+    pop(didPerformWorkStackCursor);
+    pop(contextStackCursor);
+  }
+}
+
+function pushTopLevelContextObject(fiber, context, didChange) {
+  {
+    if (contextStackCursor.current !== emptyContextObject) {
+      throw Error(formatProdErrorMessage(168));
+    }
+
+    push(contextStackCursor, context);
+    push(didPerformWorkStackCursor, didChange);
+  }
+}
+
+function processChildContext(fiber, type, parentContext) {
+  {
+    const instance = fiber.stateNode;
+    const childContextTypes = type.childContextTypes; // TODO (bvaughn) Replace this behavior with an invariant() in the future.
+    // It has only been added in Fiber to match the (unintentional) behavior in Stack.
+
+    if (typeof instance.getChildContext !== 'function') {
+
+      return parentContext;
+    }
+
+    const childContext = instance.getChildContext();
+
+    for (const contextKey in childContext) {
+      if (!(contextKey in childContextTypes)) {
+        throw Error(formatProdErrorMessage(108, getComponentNameFromFiber(fiber) || 'Unknown', contextKey));
+      }
+    }
+
+    return assign({}, parentContext, childContext);
+  }
+}
+
+function pushContextProvider(workInProgress) {
+  {
+    const instance = workInProgress.stateNode; // We push the context as early as possible to ensure stack integrity.
+    // If the instance does not exist yet, we will push null at first,
+    // and replace it on the stack later when invalidating the context.
+
+    const memoizedMergedChildContext = instance && instance.__reactInternalMemoizedMergedChildContext || emptyContextObject; // Remember the parent context so we can merge with it later.
+    // Inherit the parent's did-perform-work value to avoid inadvertently blocking updates.
+
+    previousContext = contextStackCursor.current;
+    push(contextStackCursor, memoizedMergedChildContext);
+    push(didPerformWorkStackCursor, didPerformWorkStackCursor.current);
+    return true;
+  }
+}
+
+function invalidateContextProvider(workInProgress, type, didChange) {
+  {
+    const instance = workInProgress.stateNode;
+
+    if (!instance) {
+      throw Error(formatProdErrorMessage(169));
+    }
+
+    if (didChange) {
+      // Merge parent and own context.
+      // Skip this if we're not updating due to sCU.
+      // This avoids unnecessarily recomputing memoized values.
+      const mergedContext = processChildContext(workInProgress, type, previousContext);
+      instance.__reactInternalMemoizedMergedChildContext = mergedContext; // Replace the old (or empty) context with the new one.
+      // It is important to unwind the context in the reverse order.
+
+      pop(didPerformWorkStackCursor);
+      pop(contextStackCursor); // Now push the new context and mark that it has changed.
+
+      push(contextStackCursor, mergedContext);
+      push(didPerformWorkStackCursor, didChange);
+    } else {
+      pop(didPerformWorkStackCursor);
+      push(didPerformWorkStackCursor, didChange);
+    }
+  }
+}
+
+function findCurrentUnmaskedContext(fiber) {
+  {
+    // Currently this is only used with renderSubtreeIntoContainer; not sure if it
+    // makes sense elsewhere
+    if (!isFiberMounted(fiber) || fiber.tag !== ClassComponent) {
+      throw Error(formatProdErrorMessage(170));
+    }
+
+    let node = fiber;
+
+    do {
+      switch (node.tag) {
+        case HostRoot:
+          return node.stateNode.context;
+
+        case ClassComponent:
+          {
+            const Component = node.type;
+
+            if (isContextProvider(Component)) {
+              return node.stateNode.__reactInternalMemoizedMergedChildContext;
+            }
+
+            break;
+          }
+      } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+      node = node.return;
+    } while (node !== null);
+
+    throw Error(formatProdErrorMessage(171));
+  }
+}
+
+const LegacyRoot = 0;
+const ConcurrentRoot = 1;
+
+// We use the existence of the state object as an indicator that the component
+// is hidden.
+const OffscreenVisible =
+/*                     */
+0b001;
+const OffscreenDetached =
+/*                    */
+0b010;
+const OffscreenPassiveEffectsConnected =
+/*     */
+0b100;
+function isOffscreenManual(offscreenFiber) {
+  return offscreenFiber.memoizedProps !== null && offscreenFiber.memoizedProps.mode === 'manual';
+}
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+
+const objectIs = // $FlowFixMe[method-unbinding]
+typeof Object.is === 'function' ? Object.is : is;
+
+// This is imported by the event replaying implementation in React DOM. It's
+// in a separate file to break a circular dependency between the renderer and
+// the reconciler.
+function isRootDehydrated(root) {
+  const currentState = root.current.memoizedState;
+  return currentState.isDehydrated;
+}
+
+// Ids are base 32 strings whose binary representation corresponds to the
+// 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.
+
+const forkStack = [];
+let forkStackIndex = 0;
+let treeForkProvider = null;
+let treeForkCount = 0;
+const idStack = [];
+let idStackIndex = 0;
+let treeContextProvider = null;
+let treeContextId = 1;
+let treeContextOverflow = '';
+function isForkedChild(workInProgress) {
+  return (workInProgress.flags & Forked) !== NoFlags$1;
+}
+function getForksAtLevel(workInProgress) {
+  return treeForkCount;
+}
+function getTreeId() {
+  const overflow = treeContextOverflow;
+  const idWithLeadingBit = treeContextId;
+  const id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
+  return id.toString(32) + overflow;
+}
+function pushTreeFork(workInProgress, totalChildren) {
+  forkStack[forkStackIndex++] = treeForkCount;
+  forkStack[forkStackIndex++] = treeForkProvider;
+  treeForkProvider = workInProgress;
+  treeForkCount = totalChildren;
+}
+function pushTreeId(workInProgress, totalChildren, index) {
+  idStack[idStackIndex++] = treeContextId;
+  idStack[idStackIndex++] = treeContextOverflow;
+  idStack[idStackIndex++] = treeContextProvider;
+  treeContextProvider = workInProgress;
+  const baseIdWithLeadingBit = treeContextId;
+  const baseOverflow = treeContextOverflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
+  // of the id; we use it to account for leading 0s.
+
+  const baseLength = getBitLength(baseIdWithLeadingBit) - 1;
+  const baseId = baseIdWithLeadingBit & ~(1 << baseLength);
+  const slot = index + 1;
+  const length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
+  // consideration the leading 1 we use to mark the end of the sequence.
+
+  if (length > 30) {
+    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
+    // This branch assumes the length of the base id is greater than 5; it won't
+    // work for smaller ids, because you need 5 bits per character.
+    //
+    // We encode the id in multiple steps: first the base id, then the
+    // remaining digits.
+    //
+    // Each 5 bit sequence corresponds to a single base 32 character. So for
+    // example, if the current id is 23 bits long, we can convert 20 of those
+    // bits into a string of 4 characters, with 3 bits left over.
+    //
+    // First calculate how many bits in the base id represent a complete
+    // sequence of characters.
+    const numberOfOverflowBits = baseLength - baseLength % 5; // Then create a bitmask that selects only those bits.
+
+    const newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
+
+    const newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
+
+    const restOfBaseId = baseId >> numberOfOverflowBits;
+    const restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
+    // we made more room, this time it won't overflow.
+
+    const restOfLength = getBitLength(totalChildren) + restOfBaseLength;
+    const restOfNewBits = slot << restOfBaseLength;
+    const id = restOfNewBits | restOfBaseId;
+    const overflow = newOverflow + baseOverflow;
+    treeContextId = 1 << restOfLength | id;
+    treeContextOverflow = overflow;
+  } else {
+    // Normal path
+    const newBits = slot << baseLength;
+    const id = newBits | baseId;
+    const overflow = baseOverflow;
+    treeContextId = 1 << length | id;
+    treeContextOverflow = overflow;
+  }
+}
+function pushMaterializedTreeId(workInProgress) {
+  // in its children.
+
+  const returnFiber = workInProgress.return;
+
+  if (returnFiber !== null) {
+    const numberOfForks = 1;
+    const slotIndex = 0;
+    pushTreeFork(workInProgress, numberOfForks);
+    pushTreeId(workInProgress, numberOfForks, slotIndex);
+  }
+}
+
+function getBitLength(number) {
+  return 32 - clz32(number);
+}
+
+function getLeadingBit(id) {
+  return 1 << getBitLength(id) - 1;
+}
+
+function popTreeContext(workInProgress) {
+  // Restore the previous values.
+  // This is a bit more complicated than other context-like modules in Fiber
+  // because the same Fiber may appear on the stack multiple times and for
+  // different reasons. We have to keep popping until the work-in-progress is
+  // no longer at the top of the stack.
+  while (workInProgress === treeForkProvider) {
+    treeForkProvider = forkStack[--forkStackIndex];
+    forkStack[forkStackIndex] = null;
+    treeForkCount = forkStack[--forkStackIndex];
+    forkStack[forkStackIndex] = null;
+  }
+
+  while (workInProgress === treeContextProvider) {
+    treeContextProvider = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+    treeContextOverflow = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+    treeContextId = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+  }
+}
+function getSuspendedTreeContext() {
+
+  if (treeContextProvider !== null) {
+    return {
+      id: treeContextId,
+      overflow: treeContextOverflow
+    };
+  } else {
+    return null;
+  }
+}
+function restoreSuspendedTreeContext(workInProgress, suspendedContext) {
+  idStack[idStackIndex++] = treeContextId;
+  idStack[idStackIndex++] = treeContextOverflow;
+  idStack[idStackIndex++] = treeContextProvider;
+  treeContextId = suspendedContext.id;
+  treeContextOverflow = suspendedContext.overflow;
+  treeContextProvider = workInProgress;
+}
+
+// This may have been an insertion or a hydration.
+
+let hydrationParentFiber = null;
+let nextHydratableInstance = null;
+let isHydrating = false; // This flag allows for warning supression when we expect there to be mismatches
+
+let hydrationErrors = null;
+let rootOrSingletonContext = false;
+
+function enterHydrationState(fiber) {
+
+  const parentInstance = fiber.stateNode.containerInfo;
+  nextHydratableInstance = getFirstHydratableChildWithinContainer(parentInstance);
+  hydrationParentFiber = fiber;
+  isHydrating = true;
+  hydrationErrors = null;
+  rootOrSingletonContext = true;
+  return true;
+}
+
+function reenterHydrationStateFromDehydratedSuspenseInstance(fiber, suspenseInstance, treeContext) {
+
+  nextHydratableInstance = getFirstHydratableChildWithinSuspenseInstance(suspenseInstance);
+  hydrationParentFiber = fiber;
+  isHydrating = true;
+  hydrationErrors = null;
+  rootOrSingletonContext = false;
+
+  if (treeContext !== null) {
+    restoreSuspendedTreeContext(fiber, treeContext);
+  }
+
+  return true;
+}
+
+function deleteHydratableInstance(returnFiber, instance) {
+  const childToDelete = createFiberFromHostInstanceForDeletion();
+  childToDelete.stateNode = instance;
+  childToDelete.return = returnFiber;
+  const deletions = returnFiber.deletions;
+
+  if (deletions === null) {
+    returnFiber.deletions = [childToDelete];
+    returnFiber.flags |= ChildDeletion;
+  } else {
+    deletions.push(childToDelete);
+  }
+}
+
+function insertNonHydratedInstance(returnFiber, fiber) {
+  fiber.flags = fiber.flags & ~Hydrating | Placement;
+}
+
+function tryHydrateInstance(fiber, nextInstance) {
+  // fiber is a HostComponent Fiber
+  const instance = canHydrateInstance(nextInstance, fiber.type, fiber.pendingProps, rootOrSingletonContext);
+
+  if (instance !== null) {
+    fiber.stateNode = instance;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = getFirstHydratableChild(instance);
+    rootOrSingletonContext = false;
+    return true;
+  }
+
+  return false;
+}
+
+function tryHydrateText(fiber, nextInstance) {
+  // fiber is a HostText Fiber
+  const text = fiber.pendingProps;
+  const textInstance = canHydrateTextInstance(nextInstance, text, rootOrSingletonContext);
+
+  if (textInstance !== null) {
+    fiber.stateNode = textInstance;
+    hydrationParentFiber = fiber; // Text Instances don't have children so there's nothing to hydrate.
+
+    nextHydratableInstance = null;
+    return true;
+  }
+
+  return false;
+}
+
+function tryHydrateSuspense(fiber, nextInstance) {
+  // fiber is a SuspenseComponent Fiber
+  const suspenseInstance = canHydrateSuspenseInstance(nextInstance, rootOrSingletonContext);
+
+  if (suspenseInstance !== null) {
+    const suspenseState = {
+      dehydrated: suspenseInstance,
+      treeContext: getSuspendedTreeContext(),
+      retryLane: OffscreenLane
+    };
+    fiber.memoizedState = suspenseState; // Store the dehydrated fragment as a child fiber.
+    // This simplifies the code for getHostSibling and deleting nodes,
+    // since it doesn't have to consider all Suspense boundaries and
+    // check if they're dehydrated ones or not.
+
+    const dehydratedFragment = createFiberFromDehydratedFragment(suspenseInstance);
+    dehydratedFragment.return = fiber;
+    fiber.child = dehydratedFragment;
+    hydrationParentFiber = fiber; // While a Suspense Instance does have children, we won't step into
+    // it during the first pass. Instead, we'll reenter it later.
+
+    nextHydratableInstance = null;
+    return true;
+  }
+
+  return false;
+}
+
+function shouldClientRenderOnMismatch(fiber) {
+  return (fiber.mode & ConcurrentMode) !== NoMode && (fiber.flags & DidCapture) === NoFlags$1;
+}
+
+function throwOnHydrationMismatch(fiber) {
+  throw Error(formatProdErrorMessage(418));
+}
+
+function claimHydratableSingleton(fiber) {
+  {
+    if (!isHydrating) {
+      return;
+    }
+
+    const currentRootContainer = getRootHostContainer();
+    const instance = fiber.stateNode = resolveSingletonInstance(fiber.type, fiber.pendingProps, currentRootContainer);
+    hydrationParentFiber = fiber;
+    rootOrSingletonContext = true;
+    nextHydratableInstance = getFirstHydratableChild(instance);
+  }
+}
+
+function tryToClaimNextHydratableInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
+
+  const initialInstance = nextHydratableInstance;
+  const nextInstance = nextHydratableInstance;
+
+  if (!nextInstance) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
+
+
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
+    return;
+  }
+
+  const firstAttemptedInstance = nextInstance;
+
+  if (!tryHydrateInstance(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
+
+
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    const prevHydrationParentFiber = hydrationParentFiber;
+
+    if (!nextHydratableInstance || !tryHydrateInstance(fiber, nextHydratableInstance)) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
+
+
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+  }
+}
+
+function tryToClaimNextHydratableTextInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
+
+  const text = fiber.pendingProps;
+  const isHydratable = isHydratableText(text);
+  const initialInstance = nextHydratableInstance;
+  const nextInstance = nextHydratableInstance;
+
+  if (!nextInstance || !isHydratable) {
+    // We exclude non hydrabable text because we know there are no matching hydratables.
+    // We either throw or insert depending on the render mode.
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
+
+
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
+    return;
+  }
+
+  const firstAttemptedInstance = nextInstance;
+
+  if (!tryHydrateText(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
+
+
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    const prevHydrationParentFiber = hydrationParentFiber;
+
+    if (!nextHydratableInstance || !tryHydrateText(fiber, nextHydratableInstance)) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
+
+
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+  }
+}
+
+function tryToClaimNextHydratableSuspenseInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
+
+  const initialInstance = nextHydratableInstance;
+  const nextInstance = nextHydratableInstance;
+
+  if (!nextInstance) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
+
+
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
+    return;
+  }
+
+  const firstAttemptedInstance = nextInstance;
+
+  if (!tryHydrateSuspense(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
+
+
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    const prevHydrationParentFiber = hydrationParentFiber;
+
+    if (!nextHydratableInstance || !tryHydrateSuspense(fiber, nextHydratableInstance)) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
+
+
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+  }
+}
+
+function tryToClaimNextHydratableFormMarkerInstance(fiber) {
+  if (!isHydrating) {
+    return false;
+  }
+
+  if (nextHydratableInstance) {
+    const markerInstance = canHydrateFormStateMarker(nextHydratableInstance, rootOrSingletonContext);
+
+    if (markerInstance) {
+      // Found the marker instance.
+      nextHydratableInstance = getNextHydratableSibling(markerInstance); // Return true if this marker instance should use the state passed
+      // to hydrateRoot.
+      // TODO: As an optimization, Fizz should only emit these markers if form
+      // state is passed at the root.
+
+      return isFormStateMarkerMatching(markerInstance);
+    }
+  } // Should have found a marker instance. Throw an error to trigger client
+  // rendering. We don't bother to check if we're in a concurrent root because
+  // useFormState is a new API, so backwards compat is not an issue.
+
+
+  throwOnHydrationMismatch();
+  return false;
+}
+
+function prepareToHydrateHostInstance(fiber, hostContext) {
+
+  const instance = fiber.stateNode;
+  hydrateInstance(instance, fiber.type, fiber.memoizedProps, hostContext, fiber);
+}
+
+function prepareToHydrateHostTextInstance(fiber) {
+
+  const textInstance = fiber.stateNode;
+  const textContent = fiber.memoizedProps;
+  const shouldUpdate = hydrateTextInstance(textInstance, textContent, fiber);
+
+  if (shouldUpdate) {
+    // We assume that prepareToHydrateHostTextInstance is called in a context where the
+    // hydration parent is the parent host component of this host text.
+    const returnFiber = hydrationParentFiber;
+
+    if (returnFiber !== null) {
+      switch (returnFiber.tag) {
+        case HostRoot:
+          {
+            const parentContainer = returnFiber.stateNode.containerInfo;
+            const isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
+            didNotMatchHydratedContainerTextInstance(parentContainer, textInstance, textContent, // TODO: Delete this argument when we remove the legacy root API.
+            isConcurrentMode);
+
+            if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {
+              // In concurrent mode we never update the mismatched text,
+              // even if the error was ignored.
+              return false;
+            }
+
+            break;
+          }
+
+        case HostSingleton:
+        case HostComponent:
+          {
+            const parentType = returnFiber.type;
+            const parentProps = returnFiber.memoizedProps;
+            const parentInstance = returnFiber.stateNode;
+            const isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
+            didNotMatchHydratedTextInstance(parentType, parentProps, parentInstance, textInstance, textContent, // TODO: Delete this argument when we remove the legacy root API.
+            isConcurrentMode);
+
+            if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {
+              // In concurrent mode we never update the mismatched text,
+              // even if the error was ignored.
+              return false;
+            }
+
+            break;
+          }
+      }
+    }
+  }
+
+  return shouldUpdate;
+}
+
+function prepareToHydrateHostSuspenseInstance(fiber) {
+
+  const suspenseState = fiber.memoizedState;
+  const suspenseInstance = suspenseState !== null ? suspenseState.dehydrated : null;
+
+  if (!suspenseInstance) {
+    throw Error(formatProdErrorMessage(317));
+  }
+
+  hydrateSuspenseInstance(suspenseInstance, fiber);
+}
+
+function skipPastDehydratedSuspenseInstance(fiber) {
+
+  const suspenseState = fiber.memoizedState;
+  const suspenseInstance = suspenseState !== null ? suspenseState.dehydrated : null;
+
+  if (!suspenseInstance) {
+    throw Error(formatProdErrorMessage(317));
+  }
+
+  return getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance);
+}
+
+function popToNextHostParent(fiber) {
+  hydrationParentFiber = fiber.return;
+
+  while (hydrationParentFiber) {
+    switch (hydrationParentFiber.tag) {
+      case HostRoot:
+      case HostSingleton:
+        rootOrSingletonContext = true;
+        return;
+
+      case HostComponent:
+      case SuspenseComponent:
+        rootOrSingletonContext = false;
+        return;
+
+      default:
+        hydrationParentFiber = hydrationParentFiber.return;
+    }
+  }
+}
+
+function popHydrationState(fiber) {
+
+  if (fiber !== hydrationParentFiber) {
+    // We're deeper than the current hydration context, inside an inserted
+    // tree.
+    return false;
+  }
+
+  if (!isHydrating) {
+    // If we're not currently hydrating but we're in a hydration context, then
+    // we were an insertion and now need to pop up reenter hydration of our
+    // siblings.
+    popToNextHostParent(fiber);
+    isHydrating = true;
+    return false;
+  }
+
+  let shouldClear = false;
+
+  {
+    // With float we never clear the Root, or Singleton instances. We also do not clear Instances
+    // that have singleton text content
+    if (fiber.tag !== HostRoot && fiber.tag !== HostSingleton && !(fiber.tag === HostComponent && (!shouldDeleteUnhydratedTailInstances(fiber.type) || shouldSetTextContent(fiber.type, fiber.memoizedProps)))) {
+      shouldClear = true;
+    }
+  }
+
+  if (shouldClear) {
+    let nextInstance = nextHydratableInstance;
+
+    if (nextInstance) {
+      if (shouldClientRenderOnMismatch(fiber)) {
+        warnIfUnhydratedTailNodes();
+        throwOnHydrationMismatch();
+      } else {
+        while (nextInstance) {
+          deleteHydratableInstance(fiber, nextInstance);
+          nextInstance = getNextHydratableSibling(nextInstance);
+        }
+      }
+    }
+  }
+
+  popToNextHostParent(fiber);
+
+  if (fiber.tag === SuspenseComponent) {
+    nextHydratableInstance = skipPastDehydratedSuspenseInstance(fiber);
+  } else {
+    nextHydratableInstance = hydrationParentFiber ? getNextHydratableSibling(fiber.stateNode) : null;
+  }
+
+  return true;
+}
+
+function hasUnhydratedTailNodes() {
+  return isHydrating && nextHydratableInstance !== null;
+}
+
+function warnIfUnhydratedTailNodes(fiber) {
+  let nextInstance = nextHydratableInstance;
+
+  while (nextInstance) {
+    nextInstance = getNextHydratableSibling(nextInstance);
+  }
+}
+
+function resetHydrationState() {
+
+  hydrationParentFiber = null;
+  nextHydratableInstance = null;
+  isHydrating = false;
+}
+
+function upgradeHydrationErrorsToRecoverable() {
+  if (hydrationErrors !== null) {
+    // Successfully completed a forced client render. The errors that occurred
+    // during the hydration attempt are now recovered. We will log them in
+    // commit phase, once the entire tree has finished.
+    queueRecoverableErrors(hydrationErrors);
+    hydrationErrors = null;
+  }
+}
+
+function getIsHydrating() {
+  return isHydrating;
+}
+
+function queueHydrationError(error) {
+  if (hydrationErrors === null) {
+    hydrationErrors = [error];
+  } else {
+    hydrationErrors.push(error);
+  }
+}
+
+// we wait until the current render is over (either finished or interrupted)
+// before adding it to the fiber/hook queue. Push to this array so we can
+// access the queue, fiber, update, et al later.
+
+const concurrentQueues = [];
+let concurrentQueuesIndex = 0;
+let concurrentlyUpdatedLanes = NoLanes;
+function finishQueueingConcurrentUpdates() {
+  const endIndex = concurrentQueuesIndex;
+  concurrentQueuesIndex = 0;
+  concurrentlyUpdatedLanes = NoLanes;
+  let i = 0;
+
+  while (i < endIndex) {
+    const fiber = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    const queue = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    const update = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    const lane = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+
+    if (queue !== null && update !== null) {
+      const pending = queue.pending;
+
+      if (pending === null) {
+        // This is the first update. Create a circular list.
+        update.next = update;
+      } else {
+        update.next = pending.next;
+        pending.next = update;
+      }
+
+      queue.pending = update;
+    }
+
+    if (lane !== NoLane) {
+      markUpdateLaneFromFiberToRoot(fiber, update, lane);
+    }
+  }
+}
+function getConcurrentlyUpdatedLanes() {
+  return concurrentlyUpdatedLanes;
+}
+
+function enqueueUpdate$1(fiber, queue, update, lane) {
+  // Don't update the `childLanes` on the return path yet. If we already in
+  // the middle of rendering, wait until after it has completed.
+  concurrentQueues[concurrentQueuesIndex++] = fiber;
+  concurrentQueues[concurrentQueuesIndex++] = queue;
+  concurrentQueues[concurrentQueuesIndex++] = update;
+  concurrentQueues[concurrentQueuesIndex++] = lane;
+  concurrentlyUpdatedLanes = mergeLanes(concurrentlyUpdatedLanes, lane); // The fiber's `lane` field is used in some places to check if any work is
+  // scheduled, to perform an eager bailout, so we need to update it immediately.
+  // TODO: We should probably move this to the "shared" queue instead.
+
+  fiber.lanes = mergeLanes(fiber.lanes, lane);
+  const alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, lane);
+  }
+}
+
+function enqueueConcurrentHookUpdate(fiber, queue, update, lane) {
+  const concurrentQueue = queue;
+  const concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane);
+  return getRootForUpdatedFiber(fiber);
+}
+function enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update) {
+  // This function is used to queue an update that doesn't need a rerender. The
+  // only reason we queue it is in case there's a subsequent higher priority
+  // update that causes it to be rebased.
+  const lane = NoLane;
+  const concurrentQueue = queue;
+  const concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane); // Usually we can rely on the upcoming render phase to process the concurrent
+  // queue. However, since this is a bail out, we're not scheduling any work
+  // here. So the update we just queued will leak until something else happens
+  // to schedule work (if ever).
+  //
+  // Check if we're currently in the middle of rendering a tree, and if not,
+  // process the queue immediately to prevent a leak.
+
+  const isConcurrentlyRendering = getWorkInProgressRoot() !== null;
+
+  if (!isConcurrentlyRendering) {
+    finishQueueingConcurrentUpdates();
+  }
+}
+function enqueueConcurrentClassUpdate(fiber, queue, update, lane) {
+  const concurrentQueue = queue;
+  const concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane);
+  return getRootForUpdatedFiber(fiber);
+}
+function enqueueConcurrentRenderForLane(fiber, lane) {
+  enqueueUpdate$1(fiber, null, null, lane);
+  return getRootForUpdatedFiber(fiber);
+} // Calling this function outside this module should only be done for backwards
+// compatibility and should always be accompanied by a warning.
+
+function unsafe_markUpdateLaneFromFiberToRoot(sourceFiber, lane) {
+  // NOTE: For Hyrum's Law reasons, if an infinite update loop is detected, it
+  // should throw before `markUpdateLaneFromFiberToRoot` is called. But this is
+  // undefined behavior and we can change it if we need to; it just so happens
+  // that, at the time of this writing, there's an internal product test that
+  // happens to rely on this.
+  const root = getRootForUpdatedFiber(sourceFiber);
+  markUpdateLaneFromFiberToRoot(sourceFiber, null, lane);
+  return root;
+}
+
+function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
+  // Update the source fiber's lanes
+  sourceFiber.lanes = mergeLanes(sourceFiber.lanes, lane);
+  let alternate = sourceFiber.alternate;
+
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, lane);
+  } // Walk the parent path to the root and update the child lanes.
+
+
+  let isHidden = false;
+  let parent = sourceFiber.return;
+  let node = sourceFiber;
+
+  while (parent !== null) {
+    parent.childLanes = mergeLanes(parent.childLanes, lane);
+    alternate = parent.alternate;
+
+    if (alternate !== null) {
+      alternate.childLanes = mergeLanes(alternate.childLanes, lane);
+    }
+
+    if (parent.tag === OffscreenComponent) {
+      // Check if this offscreen boundary is currently hidden.
+      //
+      // The instance may be null if the Offscreen parent was unmounted. Usually
+      // the parent wouldn't be reachable in that case because we disconnect
+      // fibers from the tree when they are deleted. However, there's a weird
+      // edge case where setState is called on a fiber that was interrupted
+      // before it ever mounted. Because it never mounts, it also never gets
+      // deleted. Because it never gets deleted, its return pointer never gets
+      // disconnected. Which means it may be attached to a deleted Offscreen
+      // parent node. (This discovery suggests it may be better for memory usage
+      // if we don't attach the `return` pointer until the commit phase, though
+      // in order to do that we'd need some other way to track the return
+      // pointer during the initial render, like on the stack.)
+      //
+      // This case is always accompanied by a warning, but we still need to
+      // account for it. (There may be other cases that we haven't discovered,
+      // too.)
+      const offscreenInstance = parent.stateNode;
+
+      if (offscreenInstance !== null && !(offscreenInstance._visibility & OffscreenVisible)) {
+        isHidden = true;
+      }
+    }
+
+    node = parent;
+    parent = parent.return;
+  }
+
+  if (isHidden && update !== null && node.tag === HostRoot) {
+    const root = node.stateNode;
+    markHiddenUpdate(root, update, lane);
+  }
+}
+
+function getRootForUpdatedFiber(sourceFiber) {
+  // TODO: We will detect and infinite update loop and throw even if this fiber
+  // has already unmounted. This isn't really necessary but it happens to be the
+  // current behavior we've used for several release cycles. Consider not
+  // performing this check if the updated fiber already unmounted, since it's
+  // not possible for that to cause an infinite update loop.
+  throwIfInfiniteUpdateLoopDetected(); // When a setState happens, we must ensure the root is scheduled. Because
+  let node = sourceFiber;
+  let parent = node.return;
+
+  while (parent !== null) {
+    node = parent;
+    parent = node.return;
+  }
+
+  return node.tag === HostRoot ? node.stateNode : null;
+}
+
+const UpdateState = 0;
+const ReplaceState = 1;
+const ForceUpdate = 2;
+const CaptureUpdate = 3; // Global state that is reset at the beginning of calling `processUpdateQueue`.
+// It should only be read right after calling `processUpdateQueue`, via
+// `checkHasForceUpdateAfterProcessing`.
+
+let hasForceUpdate = false;
+
+function initializeUpdateQueue(fiber) {
+  const queue = {
+    baseState: fiber.memoizedState,
+    firstBaseUpdate: null,
+    lastBaseUpdate: null,
+    shared: {
+      pending: null,
+      lanes: NoLanes,
+      hiddenCallbacks: null
+    },
+    callbacks: null
+  };
+  fiber.updateQueue = queue;
+}
+function cloneUpdateQueue(current, workInProgress) {
+  // Clone the update queue from current. Unless it's already a clone.
+  const queue = workInProgress.updateQueue;
+  const currentQueue = current.updateQueue;
+
+  if (queue === currentQueue) {
+    const clone = {
+      baseState: currentQueue.baseState,
+      firstBaseUpdate: currentQueue.firstBaseUpdate,
+      lastBaseUpdate: currentQueue.lastBaseUpdate,
+      shared: currentQueue.shared,
+      callbacks: null
+    };
+    workInProgress.updateQueue = clone;
+  }
+}
+function createUpdate(lane) {
+  const update = {
+    lane,
+    tag: UpdateState,
+    payload: null,
+    callback: null,
+    next: null
+  };
+  return update;
+}
+function enqueueUpdate(fiber, update, lane) {
+  const updateQueue = fiber.updateQueue;
+
+  if (updateQueue === null) {
+    // Only occurs if the fiber has been unmounted.
+    return null;
+  }
+
+  const sharedQueue = updateQueue.shared;
+
+  if (isUnsafeClassRenderPhaseUpdate()) {
+    // This is an unsafe render phase update. Add directly to the update
+    // queue so we can process it immediately during the current render.
+    const pending = sharedQueue.pending;
+
+    if (pending === null) {
+      // This is the first update. Create a circular list.
+      update.next = update;
+    } else {
+      update.next = pending.next;
+      pending.next = update;
+    }
+
+    sharedQueue.pending = update; // Update the childLanes even though we're most likely already rendering
+    // this fiber. This is for backwards compatibility in the case where you
+    // update a different component during render phase than the one that is
+    // currently renderings (a pattern that is accompanied by a warning).
+
+    return unsafe_markUpdateLaneFromFiberToRoot(fiber, lane);
+  } else {
+    return enqueueConcurrentClassUpdate(fiber, sharedQueue, update, lane);
+  }
+}
+function entangleTransitions(root, fiber, lane) {
+  const updateQueue = fiber.updateQueue;
+
+  if (updateQueue === null) {
+    // Only occurs if the fiber has been unmounted.
+    return;
+  }
+
+  const sharedQueue = updateQueue.shared;
+
+  if (isTransitionLane(lane)) {
+    let queueLanes = sharedQueue.lanes; // If any entangled lanes are no longer pending on the root, then they must
+    // have finished. We can remove them from the shared queue, which represents
+    // a superset of the actually pending lanes. In some cases we may entangle
+    // more than we need to, but that's OK. In fact it's worse if we *don't*
+    // entangle when we should.
+
+    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.
+
+    const newQueueLanes = mergeLanes(queueLanes, lane);
+    sharedQueue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if
+    // the lane finished since the last time we entangled it. So we need to
+    // entangle it again, just to be sure.
+
+    markRootEntangled(root, newQueueLanes);
+  }
+}
+function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
+  // Captured updates are updates that are thrown by a child during the render
+  // phase. They should be discarded if the render is aborted. Therefore,
+  // we should only put them on the work-in-progress queue, not the current one.
+  let queue = workInProgress.updateQueue; // Check if the work-in-progress queue is a clone.
+
+  const current = workInProgress.alternate;
+
+  if (current !== null) {
+    const currentQueue = current.updateQueue;
+
+    if (queue === currentQueue) {
+      // The work-in-progress queue is the same as current. This happens when
+      // we bail out on a parent fiber that then captures an error thrown by
+      // a child. Since we want to append the update only to the work-in
+      // -progress queue, we need to clone the updates. We usually clone during
+      // processUpdateQueue, but that didn't happen in this case because we
+      // skipped over the parent when we bailed out.
+      let newFirst = null;
+      let newLast = null;
+      const firstBaseUpdate = queue.firstBaseUpdate;
+
+      if (firstBaseUpdate !== null) {
+        // Loop through the updates and clone them.
+        let update = firstBaseUpdate;
+
+        do {
+          const clone = {
+            lane: update.lane,
+            tag: update.tag,
+            payload: update.payload,
+            // When this update is rebased, we should not fire its
+            // callback again.
+            callback: null,
+            next: null
+          };
+
+          if (newLast === null) {
+            newFirst = newLast = clone;
+          } else {
+            newLast.next = clone;
+            newLast = clone;
+          } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+          update = update.next;
+        } while (update !== null); // Append the captured update the end of the cloned list.
+
+
+        if (newLast === null) {
+          newFirst = newLast = capturedUpdate;
+        } else {
+          newLast.next = capturedUpdate;
+          newLast = capturedUpdate;
+        }
+      } else {
+        // There are no base updates.
+        newFirst = newLast = capturedUpdate;
+      }
+
+      queue = {
+        baseState: currentQueue.baseState,
+        firstBaseUpdate: newFirst,
+        lastBaseUpdate: newLast,
+        shared: currentQueue.shared,
+        callbacks: currentQueue.callbacks
+      };
+      workInProgress.updateQueue = queue;
+      return;
+    }
+  } // Append the update to the end of the list.
+
+
+  const lastBaseUpdate = queue.lastBaseUpdate;
+
+  if (lastBaseUpdate === null) {
+    queue.firstBaseUpdate = capturedUpdate;
+  } else {
+    lastBaseUpdate.next = capturedUpdate;
+  }
+
+  queue.lastBaseUpdate = capturedUpdate;
+}
+
+function getStateFromUpdate(workInProgress, queue, update, prevState, nextProps, instance) {
+  switch (update.tag) {
+    case ReplaceState:
+      {
+        const payload = update.payload;
+
+        if (typeof payload === 'function') {
+
+          const nextState = payload.call(instance, prevState, nextProps);
+
+          return nextState;
+        } // State object
+
+
+        return payload;
+      }
+
+    case CaptureUpdate:
+      {
+        workInProgress.flags = workInProgress.flags & ~ShouldCapture | DidCapture;
+      }
+    // Intentional fallthrough
+
+    case UpdateState:
+      {
+        const payload = update.payload;
+        let partialState;
+
+        if (typeof payload === 'function') {
+
+          partialState = payload.call(instance, prevState, nextProps);
+        } else {
+          // Partial state object
+          partialState = payload;
+        }
+
+        if (partialState === null || partialState === undefined) {
+          // Null and undefined are treated as no-ops.
+          return prevState;
+        } // Merge the partial state and the previous state.
+
+
+        return assign({}, prevState, partialState);
+      }
+
+    case ForceUpdate:
+      {
+        hasForceUpdate = true;
+        return prevState;
+      }
+  }
+
+  return prevState;
+}
+
+function processUpdateQueue(workInProgress, props, instance, renderLanes) {
+  // This is always non-null on a ClassComponent or HostRoot
+  const queue = workInProgress.updateQueue;
+  hasForceUpdate = false;
+
+  let firstBaseUpdate = queue.firstBaseUpdate;
+  let lastBaseUpdate = queue.lastBaseUpdate; // Check if there are pending updates. If so, transfer them to the base queue.
+
+  let pendingQueue = queue.shared.pending;
+
+  if (pendingQueue !== null) {
+    queue.shared.pending = null; // The pending queue is circular. Disconnect the pointer between first
+    // and last so that it's non-circular.
+
+    const lastPendingUpdate = pendingQueue;
+    const firstPendingUpdate = lastPendingUpdate.next;
+    lastPendingUpdate.next = null; // Append pending updates to base queue
+
+    if (lastBaseUpdate === null) {
+      firstBaseUpdate = firstPendingUpdate;
+    } else {
+      lastBaseUpdate.next = firstPendingUpdate;
+    }
+
+    lastBaseUpdate = lastPendingUpdate; // If there's a current queue, and it's different from the base queue, then
+    // we need to transfer the updates to that queue, too. Because the base
+    // queue is a singly-linked list with no cycles, we can append to both
+    // lists and take advantage of structural sharing.
+    // TODO: Pass `current` as argument
+
+    const current = workInProgress.alternate;
+
+    if (current !== null) {
+      // This is always non-null on a ClassComponent or HostRoot
+      const currentQueue = current.updateQueue;
+      const currentLastBaseUpdate = currentQueue.lastBaseUpdate;
+
+      if (currentLastBaseUpdate !== lastBaseUpdate) {
+        if (currentLastBaseUpdate === null) {
+          currentQueue.firstBaseUpdate = firstPendingUpdate;
+        } else {
+          currentLastBaseUpdate.next = firstPendingUpdate;
+        }
+
+        currentQueue.lastBaseUpdate = lastPendingUpdate;
+      }
+    }
+  } // These values may change as we process the queue.
+
+
+  if (firstBaseUpdate !== null) {
+    // Iterate through the list of updates to compute the result.
+    let newState = queue.baseState; // TODO: Don't need to accumulate this. Instead, we can remove renderLanes
+    // from the original lanes.
+
+    let newLanes = NoLanes;
+    let newBaseState = null;
+    let newFirstBaseUpdate = null;
+    let newLastBaseUpdate = null;
+    let update = firstBaseUpdate;
+
+    do {
+      // An extra OffscreenLane bit is added to updates that were made to
+      // a hidden tree, so that we can distinguish them from updates that were
+      // already there when the tree was hidden.
+      const updateLane = removeLanes(update.lane, OffscreenLane);
+      const isHiddenUpdate = updateLane !== update.lane; // Check if this update was made while the tree was hidden. If so, then
+      // it's not a "base" update and we should disregard the extra base lanes
+      // that were added to renderLanes when we entered the Offscreen tree.
+
+      const shouldSkipUpdate = isHiddenUpdate ? !isSubsetOfLanes(getWorkInProgressRootRenderLanes(), updateLane) : !isSubsetOfLanes(renderLanes, updateLane);
+
+      if (shouldSkipUpdate) {
+        // Priority is insufficient. Skip this update. If this is the first
+        // skipped update, the previous update/state is the new base
+        // update/state.
+        const clone = {
+          lane: updateLane,
+          tag: update.tag,
+          payload: update.payload,
+          callback: update.callback,
+          next: null
+        };
+
+        if (newLastBaseUpdate === null) {
+          newFirstBaseUpdate = newLastBaseUpdate = clone;
+          newBaseState = newState;
+        } else {
+          newLastBaseUpdate = newLastBaseUpdate.next = clone;
+        } // Update the remaining priority in the queue.
+
+
+        newLanes = mergeLanes(newLanes, updateLane);
+      } else {
+        // This update does have sufficient priority.
+        if (newLastBaseUpdate !== null) {
+          const clone = {
+            // This update is going to be committed so we never want uncommit
+            // it. Using NoLane works because 0 is a subset of all bitmasks, so
+            // this will never be skipped by the check above.
+            lane: NoLane,
+            tag: update.tag,
+            payload: update.payload,
+            // When this update is rebased, we should not fire its
+            // callback again.
+            callback: null,
+            next: null
+          };
+          newLastBaseUpdate = newLastBaseUpdate.next = clone;
+        } // Process this update.
+
+
+        newState = getStateFromUpdate(workInProgress, queue, update, newState, props, instance);
+        const callback = update.callback;
+
+        if (callback !== null) {
+          workInProgress.flags |= Callback;
+
+          if (isHiddenUpdate) {
+            workInProgress.flags |= Visibility;
+          }
+
+          const callbacks = queue.callbacks;
+
+          if (callbacks === null) {
+            queue.callbacks = [callback];
+          } else {
+            callbacks.push(callback);
+          }
+        }
+      } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+      update = update.next;
+
+      if (update === null) {
+        pendingQueue = queue.shared.pending;
+
+        if (pendingQueue === null) {
+          break;
+        } else {
+          // An update was scheduled from inside a reducer. Add the new
+          // pending updates to the end of the list and keep processing.
+          const lastPendingUpdate = pendingQueue; // Intentionally unsound. Pending updates form a circular list, but we
+          // unravel them when transferring them to the base queue.
+
+          const firstPendingUpdate = lastPendingUpdate.next;
+          lastPendingUpdate.next = null;
+          update = firstPendingUpdate;
+          queue.lastBaseUpdate = lastPendingUpdate;
+          queue.shared.pending = null;
+        }
+      }
+    } while (true);
+
+    if (newLastBaseUpdate === null) {
+      newBaseState = newState;
+    }
+
+    queue.baseState = newBaseState;
+    queue.firstBaseUpdate = newFirstBaseUpdate;
+    queue.lastBaseUpdate = newLastBaseUpdate;
+
+    if (firstBaseUpdate === null) {
+      // `queue.lanes` is used for entangling transitions. We can set it back to
+      // zero once the queue is empty.
+      queue.shared.lanes = NoLanes;
+    } // Set the remaining expiration time to be whatever is remaining in the queue.
+    // This should be fine because the only two other things that contribute to
+    // expiration time are props and context. We're already in the middle of the
+    // begin phase by the time we start processing the queue, so we've already
+    // dealt with the props. Context in components that specify
+    // shouldComponentUpdate is tricky; but we'll have to account for
+    // that regardless.
+
+
+    markSkippedUpdateLanes(newLanes);
+    workInProgress.lanes = newLanes;
+    workInProgress.memoizedState = newState;
+  }
+}
+
+function callCallback(callback, context) {
+  if (typeof callback !== 'function') {
+    throw Error(formatProdErrorMessage(191, callback));
+  }
+
+  callback.call(context);
+}
+
+function resetHasForceUpdateBeforeProcessing() {
+  hasForceUpdate = false;
+}
+function checkHasForceUpdateAfterProcessing() {
+  return hasForceUpdate;
+}
+function deferHiddenCallbacks(updateQueue) {
+  // When an update finishes on a hidden component, its callback should not
+  // be fired until/unless the component is made visible again. Stash the
+  // callback on the shared queue object so it can be fired later.
+  const newHiddenCallbacks = updateQueue.callbacks;
+
+  if (newHiddenCallbacks !== null) {
+    const existingHiddenCallbacks = updateQueue.shared.hiddenCallbacks;
+
+    if (existingHiddenCallbacks === null) {
+      updateQueue.shared.hiddenCallbacks = newHiddenCallbacks;
+    } else {
+      updateQueue.shared.hiddenCallbacks = existingHiddenCallbacks.concat(newHiddenCallbacks);
+    }
+  }
+}
+function commitHiddenCallbacks(updateQueue, context) {
+  // This component is switching from hidden -> visible. Commit any callbacks
+  // that were previously deferred.
+  const hiddenCallbacks = updateQueue.shared.hiddenCallbacks;
+
+  if (hiddenCallbacks !== null) {
+    updateQueue.shared.hiddenCallbacks = null;
+
+    for (let i = 0; i < hiddenCallbacks.length; i++) {
+      const callback = hiddenCallbacks[i];
+      callCallback(callback, context);
+    }
+  }
+}
+function commitCallbacks(updateQueue, context) {
+  const callbacks = updateQueue.callbacks;
+
+  if (callbacks !== null) {
+    updateQueue.callbacks = null;
+
+    for (let i = 0; i < callbacks.length; i++) {
+      const callback = callbacks[i];
+      callCallback(callback, context);
+    }
+  }
+}
+
+/**
+ * Performs equality by iterating through keys on an object and returning false
+ * when any key has values which are not strictly equal between the arguments.
+ * Returns true when the values of all keys are strictly equal.
+ */
+
+function shallowEqual(objA, objB) {
+  if (objectIs(objA, objB)) {
+    return true;
+  }
+
+  if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
+    return false;
+  }
+
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+
+  if (keysA.length !== keysB.length) {
+    return false;
+  } // Test for A's keys different from B.
+
+
+  for (let i = 0; i < keysA.length; i++) {
+    const currentKey = keysA[i];
+
+    if (!hasOwnProperty.call(objB, currentKey) || // $FlowFixMe[incompatible-use] lost refinement of `objB`
+    !objectIs(objA[currentKey], objB[currentKey])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+// detect this is caught by userspace, we'll log a warning in development.
+
+const SuspenseException = Error(formatProdErrorMessage(460));
+const SuspenseyCommitException = Error(formatProdErrorMessage(474)); // This is a noop thenable that we use to trigger a fallback in throwException.
+// TODO: It would be better to refactor throwException into multiple functions
+// so we can trigger a fallback directly without having to check the type. But
+// for now this will do.
+
+const noopSuspenseyCommitThenable = {
+  then() {
+  }
+
+};
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+function isThenableResolved(thenable) {
+  const status = thenable.status;
+  return status === 'fulfilled' || status === 'rejected';
+}
+
+function noop$2() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop$2, noop$2);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        checkIfUseWrappedInAsyncCatch(rejectedError);
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          // Attach a dummy listener, to ensure that any lazy initialization can
+          // happen. Flight lazily parses JSON when the value is actually awaited.
+          thenable.then(noop$2, noop$2);
+        } else {
+          // This is an uncached thenable that we haven't seen before.
+          // Detect infinite ping loops caused by uncached promises.
+          const root = getWorkInProgressRoot();
+
+          if (root !== null && root.shellSuspendCounter > 100) {
+            // This root has suspended repeatedly in the shell without making any
+            // progress (i.e. committing something). This is highly suggestive of
+            // an infinite ping loop, often caused by an accidental Async Client
+            // Component.
+            //
+            // During a transition, we can suspend the work loop until the promise
+            // to resolve, but this is a sync render, so that's not an option. We
+            // also can't show a fallback, because none was provided. So our last
+            // resort is to throw an error.
+            //
+            // TODO: Remove this error in a future release. Other ways of handling
+            // this case include forcing a concurrent render, or putting the whole
+            // root into offscreen mode.
+            throw Error(formatProdErrorMessage(482));
+          }
+
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously.
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                const rejectedError = rejectedThenable.reason;
+                checkIfUseWrappedInAsyncCatch(rejectedError);
+                throw rejectedError;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+
+        throw SuspenseException;
+      }
+  }
+}
+function suspendCommit() {
+  // This extra indirection only exists so it can handle passing
+  // noopSuspenseyCommitThenable through to throwException.
+  // TODO: Factor the thenable check out of throwException
+  suspendedThenable = noopSuspenseyCommitThenable;
+  throw SuspenseyCommitException;
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw Error(formatProdErrorMessage(459));
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+
+  return thenable;
+}
+function checkIfUseWrappedInAsyncCatch(rejectedReason) {
+  // This check runs in prod, too, because it prevents a more confusing
+  // downstream error, where SuspenseException is caught by a promise and
+  // thrown asynchronously.
+  // TODO: Another way to prevent SuspenseException from leaking into an async
+  // execution context is to check the dispatcher every time `use` is called,
+  // or some equivalent. That might be preferable for other reasons, too, since
+  // it matches how we prevent similar mistakes for other hooks.
+  if (rejectedReason === SuspenseException) {
+    throw Error(formatProdErrorMessage(483));
+  }
+}
+
+let thenableState$1 = null;
+let thenableIndexCounter$1 = 0;
+
+function unwrapThenable(thenable) {
+  const index = thenableIndexCounter$1;
+  thenableIndexCounter$1 += 1;
+
+  if (thenableState$1 === null) {
+    thenableState$1 = createThenableState();
+  }
+
+  return trackUsedThenable(thenableState$1, thenable, index);
+}
+
+function coerceRef(returnFiber, current, element) {
+  const mixedRef = element.ref;
+
+  if (mixedRef !== null && typeof mixedRef !== 'function' && typeof mixedRef !== 'object') {
+
+    if (element._owner) {
+      const owner = element._owner;
+      let inst;
+
+      if (owner) {
+        const ownerFiber = owner;
+
+        if (ownerFiber.tag !== ClassComponent) {
+          throw Error(formatProdErrorMessage(309));
+        }
+
+        inst = ownerFiber.stateNode;
+      }
+
+      if (!inst) {
+        throw Error(formatProdErrorMessage(147, mixedRef));
+      } // Assigning this to a const so Flow knows it won't change in the closure
+
+
+      const resolvedInst = inst;
+
+      const stringRef = '' + mixedRef; // Check if previous string ref matches new string ref
+
+      if (current !== null && current.ref !== null && typeof current.ref === 'function' && current.ref._stringRef === stringRef) {
+        return current.ref;
+      }
+
+      const ref = function (value) {
+        const refs = resolvedInst.refs;
+
+        if (value === null) {
+          delete refs[stringRef];
+        } else {
+          refs[stringRef] = value;
+        }
+      };
+
+      ref._stringRef = stringRef;
+      return ref;
+    } else {
+      if (typeof mixedRef !== 'string') {
+        throw Error(formatProdErrorMessage(284));
+      }
+
+      if (!element._owner) {
+        throw Error(formatProdErrorMessage(290, mixedRef));
+      }
+    }
+  }
+
+  return mixedRef;
+}
+
+function throwOnInvalidObjectType(returnFiber, newChild) {
+  // $FlowFixMe[method-unbinding]
+  const childString = Object.prototype.toString.call(newChild);
+  throw Error(formatProdErrorMessage(31, childString === '[object Object]' ? 'object with keys {' + Object.keys(newChild).join(', ') + '}' : childString));
+}
+
+function resolveLazy(lazyType) {
+  const payload = lazyType._payload;
+  const init = lazyType._init;
+  return init(payload);
+} // This wrapper function exists because I expect to clone the code in each path
+// to be able to optimize each path individually by branching early. This needs
+// a compiler or we can do it manually. Helpers that don't need this branching
+// live outside of this function.
+
+
+function createChildReconciler(shouldTrackSideEffects) {
+  function deleteChild(returnFiber, childToDelete) {
+    if (!shouldTrackSideEffects) {
+      // Noop.
+      return;
+    }
+
+    const deletions = returnFiber.deletions;
+
+    if (deletions === null) {
+      returnFiber.deletions = [childToDelete];
+      returnFiber.flags |= ChildDeletion;
+    } else {
+      deletions.push(childToDelete);
+    }
+  }
+
+  function deleteRemainingChildren(returnFiber, currentFirstChild) {
+    if (!shouldTrackSideEffects) {
+      // Noop.
+      return null;
+    } // TODO: For the shouldClone case, this could be micro-optimized a bit by
+    // assuming that after the first child we've already added everything.
+
+
+    let childToDelete = currentFirstChild;
+
+    while (childToDelete !== null) {
+      deleteChild(returnFiber, childToDelete);
+      childToDelete = childToDelete.sibling;
+    }
+
+    return null;
+  }
+
+  function mapRemainingChildren(returnFiber, currentFirstChild) {
+    // Add the remaining children to a temporary map so that we can find them by
+    // keys quickly. Implicit (null) keys get added to this set with their index
+    // instead.
+    const existingChildren = new Map();
+    let existingChild = currentFirstChild;
+
+    while (existingChild !== null) {
+      if (existingChild.key !== null) {
+        existingChildren.set(existingChild.key, existingChild);
+      } else {
+        existingChildren.set(existingChild.index, existingChild);
+      }
+
+      existingChild = existingChild.sibling;
+    }
+
+    return existingChildren;
+  }
+
+  function useFiber(fiber, pendingProps) {
+    // We currently set sibling to null and index to 0 here because it is easy
+    // to forget to do before returning it. E.g. for the single child case.
+    const clone = createWorkInProgress(fiber, pendingProps);
+    clone.index = 0;
+    clone.sibling = null;
+    return clone;
+  }
+
+  function placeChild(newFiber, lastPlacedIndex, newIndex) {
+    newFiber.index = newIndex;
+
+    if (!shouldTrackSideEffects) {
+      // During hydration, the useId algorithm needs to know which fibers are
+      // part of a list of children (arrays, iterators).
+      newFiber.flags |= Forked;
+      return lastPlacedIndex;
+    }
+
+    const current = newFiber.alternate;
+
+    if (current !== null) {
+      const oldIndex = current.index;
+
+      if (oldIndex < lastPlacedIndex) {
+        // This is a move.
+        newFiber.flags |= Placement | PlacementDEV;
+        return lastPlacedIndex;
+      } else {
+        // This item can stay in place.
+        return oldIndex;
+      }
+    } else {
+      // This is an insertion.
+      newFiber.flags |= Placement | PlacementDEV;
+      return lastPlacedIndex;
+    }
+  }
+
+  function placeSingleChild(newFiber) {
+    // This is simpler for the single child case. We only need to do a
+    // placement for inserting new children.
+    if (shouldTrackSideEffects && newFiber.alternate === null) {
+      newFiber.flags |= Placement | PlacementDEV;
+    }
+
+    return newFiber;
+  }
+
+  function updateTextNode(returnFiber, current, textContent, lanes) {
+    if (current === null || current.tag !== HostText) {
+      // Insert
+      const created = createFiberFromText(textContent, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      const existing = useFiber(current, textContent);
+      existing.return = returnFiber;
+      return existing;
+    }
+  }
+
+  function updateElement(returnFiber, current, element, lanes) {
+    const elementType = element.type;
+
+    if (elementType === REACT_FRAGMENT_TYPE) {
+      return updateFragment(returnFiber, current, element.props.children, lanes, element.key);
+    }
+
+    if (current !== null) {
+      if (current.elementType === elementType || ( // Keep this check inline so it only runs on the false path:
+      false) || // Lazy types should reconcile their resolved type.
+      // We need to do this after the Hot Reloading check above,
+      // because hot reloading has different semantics than prod because
+      // it doesn't resuspend. So we can't let the call below suspend.
+      typeof elementType === 'object' && elementType !== null && elementType.$$typeof === REACT_LAZY_TYPE && resolveLazy(elementType) === current.type) {
+        // Move based on index
+        const existing = useFiber(current, element.props);
+        existing.ref = coerceRef(returnFiber, current, element);
+        existing.return = returnFiber;
+
+        return existing;
+      }
+    } // Insert
+
+
+    const created = createFiberFromElement(element, returnFiber.mode, lanes);
+    created.ref = coerceRef(returnFiber, current, element);
+    created.return = returnFiber;
+    return created;
+  }
+
+  function updatePortal(returnFiber, current, portal, lanes) {
+    if (current === null || current.tag !== HostPortal || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation) {
+      // Insert
+      const created = createFiberFromPortal(portal, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      const existing = useFiber(current, portal.children || []);
+      existing.return = returnFiber;
+      return existing;
+    }
+  }
+
+  function updateFragment(returnFiber, current, fragment, lanes, key) {
+    if (current === null || current.tag !== Fragment) {
+      // Insert
+      const created = createFiberFromFragment(fragment, returnFiber.mode, lanes, key);
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      const existing = useFiber(current, fragment);
+      existing.return = returnFiber;
+      return existing;
+    }
+  }
+
+  function createChild(returnFiber, newChild, lanes) {
+    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {
+      // Text nodes don't have keys. If the previous node is implicitly keyed
+      // we can continue to replace it without aborting even if it is not a text
+      // node.
+      const created = createFiberFromText('' + newChild, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    }
+
+    if (typeof newChild === 'object' && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const created = createFiberFromElement(newChild, returnFiber.mode, lanes);
+            created.ref = coerceRef(returnFiber, null, newChild);
+            created.return = returnFiber;
+            return created;
+          }
+
+        case REACT_PORTAL_TYPE:
+          {
+            const created = createFiberFromPortal(newChild, returnFiber.mode, lanes);
+            created.return = returnFiber;
+            return created;
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = newChild._payload;
+            const init = newChild._init;
+            return createChild(returnFiber, init(payload), lanes);
+          }
+      }
+
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        const created = createFiberFromFragment(newChild, returnFiber.mode, lanes, null);
+        created.return = returnFiber;
+        return created;
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
+
+
+      if (typeof newChild.then === 'function') {
+        const thenable = newChild;
+        return createChild(returnFiber, unwrapThenable(thenable), lanes);
+      }
+
+      if (newChild.$$typeof === REACT_CONTEXT_TYPE || newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+        const context = newChild;
+        return createChild(returnFiber, readContextDuringReconcilation(returnFiber, context, lanes), lanes);
+      }
+
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+
+    return null;
+  }
+
+  function updateSlot(returnFiber, oldFiber, newChild, lanes) {
+    // Update the fiber if the keys match, otherwise return null.
+    const key = oldFiber !== null ? oldFiber.key : null;
+
+    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {
+      // Text nodes don't have keys. If the previous node is implicitly keyed
+      // we can continue to replace it without aborting even if it is not a text
+      // node.
+      if (key !== null) {
+        return null;
+      }
+
+      return updateTextNode(returnFiber, oldFiber, '' + newChild, lanes);
+    }
+
+    if (typeof newChild === 'object' && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            if (newChild.key === key) {
+              return updateElement(returnFiber, oldFiber, newChild, lanes);
+            } else {
+              return null;
+            }
+          }
+
+        case REACT_PORTAL_TYPE:
+          {
+            if (newChild.key === key) {
+              return updatePortal(returnFiber, oldFiber, newChild, lanes);
+            } else {
+              return null;
+            }
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = newChild._payload;
+            const init = newChild._init;
+            return updateSlot(returnFiber, oldFiber, init(payload), lanes);
+          }
+      }
+
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        if (key !== null) {
+          return null;
+        }
+
+        return updateFragment(returnFiber, oldFiber, newChild, lanes, null);
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
+
+
+      if (typeof newChild.then === 'function') {
+        const thenable = newChild;
+        return updateSlot(returnFiber, oldFiber, unwrapThenable(thenable), lanes);
+      }
+
+      if (newChild.$$typeof === REACT_CONTEXT_TYPE || newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+        const context = newChild;
+        return updateSlot(returnFiber, oldFiber, readContextDuringReconcilation(returnFiber, context, lanes), lanes);
+      }
+
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+
+    return null;
+  }
+
+  function updateFromMap(existingChildren, returnFiber, newIdx, newChild, lanes) {
+    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {
+      // Text nodes don't have keys, so we neither have to check the old nor
+      // new node for the key. If both are text nodes, they match.
+      const matchedFiber = existingChildren.get(newIdx) || null;
+      return updateTextNode(returnFiber, matchedFiber, '' + newChild, lanes);
+    }
+
+    if (typeof newChild === 'object' && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const matchedFiber = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;
+            return updateElement(returnFiber, matchedFiber, newChild, lanes);
+          }
+
+        case REACT_PORTAL_TYPE:
+          {
+            const matchedFiber = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;
+            return updatePortal(returnFiber, matchedFiber, newChild, lanes);
+          }
+
+        case REACT_LAZY_TYPE:
+          const payload = newChild._payload;
+          const init = newChild._init;
+          return updateFromMap(existingChildren, returnFiber, newIdx, init(payload), lanes);
+      }
+
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        const matchedFiber = existingChildren.get(newIdx) || null;
+        return updateFragment(returnFiber, matchedFiber, newChild, lanes, null);
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
+
+
+      if (typeof newChild.then === 'function') {
+        const thenable = newChild;
+        return updateFromMap(existingChildren, returnFiber, newIdx, unwrapThenable(thenable), lanes);
+      }
+
+      if (newChild.$$typeof === REACT_CONTEXT_TYPE || newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+        const context = newChild;
+        return updateFromMap(existingChildren, returnFiber, newIdx, readContextDuringReconcilation(returnFiber, context, lanes), lanes);
+      }
+
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+
+    return null;
+  }
+
+  function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, lanes) {
+
+    let resultingFirstChild = null;
+    let previousNewFiber = null;
+    let oldFiber = currentFirstChild;
+    let lastPlacedIndex = 0;
+    let newIdx = 0;
+    let nextOldFiber = null;
+
+    for (; oldFiber !== null && newIdx < newChildren.length; newIdx++) {
+      if (oldFiber.index > newIdx) {
+        nextOldFiber = oldFiber;
+        oldFiber = null;
+      } else {
+        nextOldFiber = oldFiber.sibling;
+      }
+
+      const newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], lanes);
+
+      if (newFiber === null) {
+        // TODO: This breaks on empty slots like null children. That's
+        // unfortunate because it triggers the slow path all the time. We need
+        // a better way to communicate whether this was a miss or null,
+        // boolean, undefined, etc.
+        if (oldFiber === null) {
+          oldFiber = nextOldFiber;
+        }
+
+        break;
+      }
+
+      if (shouldTrackSideEffects) {
+        if (oldFiber && newFiber.alternate === null) {
+          // We matched the slot, but we didn't reuse the existing fiber, so we
+          // need to delete the existing child.
+          deleteChild(returnFiber, oldFiber);
+        }
+      }
+
+      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+      if (previousNewFiber === null) {
+        // TODO: Move out of the loop. This only happens for the first run.
+        resultingFirstChild = newFiber;
+      } else {
+        // TODO: Defer siblings if we're not at the right index for this slot.
+        // I.e. if we had null values before, then we want to defer this
+        // for each null value. However, we also don't want to call updateSlot
+        // with the previous one.
+        previousNewFiber.sibling = newFiber;
+      }
+
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
+    }
+
+    if (newIdx === newChildren.length) {
+      // We've reached the end of the new children. We can delete the rest.
+      deleteRemainingChildren(returnFiber, oldFiber);
+
+      if (getIsHydrating()) {
+        const numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
+
+      return resultingFirstChild;
+    }
+
+    if (oldFiber === null) {
+      // If we don't have any more existing children we can choose a fast path
+      // since the rest will all be insertions.
+      for (; newIdx < newChildren.length; newIdx++) {
+        const newFiber = createChild(returnFiber, newChildren[newIdx], lanes);
+
+        if (newFiber === null) {
+          continue;
+        }
+
+        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          // TODO: Move out of the loop. This only happens for the first run.
+          resultingFirstChild = newFiber;
+        } else {
+          previousNewFiber.sibling = newFiber;
+        }
+
+        previousNewFiber = newFiber;
+      }
+
+      if (getIsHydrating()) {
+        const numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
+
+      return resultingFirstChild;
+    } // Add all children to a key map for quick lookups.
+
+
+    const existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
+
+    for (; newIdx < newChildren.length; newIdx++) {
+      const newFiber = updateFromMap(existingChildren, returnFiber, newIdx, newChildren[newIdx], lanes);
+
+      if (newFiber !== null) {
+        if (shouldTrackSideEffects) {
+          if (newFiber.alternate !== null) {
+            // The new fiber is a work in progress, but if there exists a
+            // current, that means that we reused the fiber. We need to delete
+            // it from the child list so that we don't add it to the deletion
+            // list.
+            existingChildren.delete(newFiber.key === null ? newIdx : newFiber.key);
+          }
+        }
+
+        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          resultingFirstChild = newFiber;
+        } else {
+          previousNewFiber.sibling = newFiber;
+        }
+
+        previousNewFiber = newFiber;
+      }
+    }
+
+    if (shouldTrackSideEffects) {
+      // Any existing children that weren't consumed above were deleted. We need
+      // to add them to the deletion list.
+      existingChildren.forEach(child => deleteChild(returnFiber, child));
+    }
+
+    if (getIsHydrating()) {
+      const numberOfForks = newIdx;
+      pushTreeFork(returnFiber, numberOfForks);
+    }
+
+    return resultingFirstChild;
+  }
+
+  function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildrenIterable, lanes) {
+    // This is the same implementation as reconcileChildrenArray(),
+    // but using the iterator instead.
+    const iteratorFn = getIteratorFn(newChildrenIterable);
+
+    if (typeof iteratorFn !== 'function') {
+      throw Error(formatProdErrorMessage(150));
+    }
+
+    const newChildren = iteratorFn.call(newChildrenIterable);
+
+    if (newChildren == null) {
+      throw Error(formatProdErrorMessage(151));
+    }
+
+    let resultingFirstChild = null;
+    let previousNewFiber = null;
+    let oldFiber = currentFirstChild;
+    let lastPlacedIndex = 0;
+    let newIdx = 0;
+    let nextOldFiber = null;
+    let step = newChildren.next();
+
+    for (; oldFiber !== null && !step.done; newIdx++, step = newChildren.next()) {
+      if (oldFiber.index > newIdx) {
+        nextOldFiber = oldFiber;
+        oldFiber = null;
+      } else {
+        nextOldFiber = oldFiber.sibling;
+      }
+
+      const newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
+
+      if (newFiber === null) {
+        // TODO: This breaks on empty slots like null children. That's
+        // unfortunate because it triggers the slow path all the time. We need
+        // a better way to communicate whether this was a miss or null,
+        // boolean, undefined, etc.
+        if (oldFiber === null) {
+          oldFiber = nextOldFiber;
+        }
+
+        break;
+      }
+
+      if (shouldTrackSideEffects) {
+        if (oldFiber && newFiber.alternate === null) {
+          // We matched the slot, but we didn't reuse the existing fiber, so we
+          // need to delete the existing child.
+          deleteChild(returnFiber, oldFiber);
+        }
+      }
+
+      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+      if (previousNewFiber === null) {
+        // TODO: Move out of the loop. This only happens for the first run.
+        resultingFirstChild = newFiber;
+      } else {
+        // TODO: Defer siblings if we're not at the right index for this slot.
+        // I.e. if we had null values before, then we want to defer this
+        // for each null value. However, we also don't want to call updateSlot
+        // with the previous one.
+        previousNewFiber.sibling = newFiber;
+      }
+
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
+    }
+
+    if (step.done) {
+      // We've reached the end of the new children. We can delete the rest.
+      deleteRemainingChildren(returnFiber, oldFiber);
+
+      if (getIsHydrating()) {
+        const numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
+
+      return resultingFirstChild;
+    }
+
+    if (oldFiber === null) {
+      // If we don't have any more existing children we can choose a fast path
+      // since the rest will all be insertions.
+      for (; !step.done; newIdx++, step = newChildren.next()) {
+        const newFiber = createChild(returnFiber, step.value, lanes);
+
+        if (newFiber === null) {
+          continue;
+        }
+
+        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          // TODO: Move out of the loop. This only happens for the first run.
+          resultingFirstChild = newFiber;
+        } else {
+          previousNewFiber.sibling = newFiber;
+        }
+
+        previousNewFiber = newFiber;
+      }
+
+      if (getIsHydrating()) {
+        const numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
+
+      return resultingFirstChild;
+    } // Add all children to a key map for quick lookups.
+
+
+    const existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
+
+    for (; !step.done; newIdx++, step = newChildren.next()) {
+      const newFiber = updateFromMap(existingChildren, returnFiber, newIdx, step.value, lanes);
+
+      if (newFiber !== null) {
+        if (shouldTrackSideEffects) {
+          if (newFiber.alternate !== null) {
+            // The new fiber is a work in progress, but if there exists a
+            // current, that means that we reused the fiber. We need to delete
+            // it from the child list so that we don't add it to the deletion
+            // list.
+            existingChildren.delete(newFiber.key === null ? newIdx : newFiber.key);
+          }
+        }
+
+        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          resultingFirstChild = newFiber;
+        } else {
+          previousNewFiber.sibling = newFiber;
+        }
+
+        previousNewFiber = newFiber;
+      }
+    }
+
+    if (shouldTrackSideEffects) {
+      // Any existing children that weren't consumed above were deleted. We need
+      // to add them to the deletion list.
+      existingChildren.forEach(child => deleteChild(returnFiber, child));
+    }
+
+    if (getIsHydrating()) {
+      const numberOfForks = newIdx;
+      pushTreeFork(returnFiber, numberOfForks);
+    }
+
+    return resultingFirstChild;
+  }
+
+  function reconcileSingleTextNode(returnFiber, currentFirstChild, textContent, lanes) {
+    // There's no need to check for keys on text nodes since we don't have a
+    // way to define them.
+    if (currentFirstChild !== null && currentFirstChild.tag === HostText) {
+      // We already have an existing node so let's just update it and delete
+      // the rest.
+      deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+      const existing = useFiber(currentFirstChild, textContent);
+      existing.return = returnFiber;
+      return existing;
+    } // The existing first child is not a text node so we need to create one
+    // and delete the existing ones.
+
+
+    deleteRemainingChildren(returnFiber, currentFirstChild);
+    const created = createFiberFromText(textContent, returnFiber.mode, lanes);
+    created.return = returnFiber;
+    return created;
+  }
+
+  function reconcileSingleElement(returnFiber, currentFirstChild, element, lanes) {
+    const key = element.key;
+    let child = currentFirstChild;
+
+    while (child !== null) {
+      // TODO: If key === null and child.key === null, then this only applies to
+      // the first item in the list.
+      if (child.key === key) {
+        const elementType = element.type;
+
+        if (elementType === REACT_FRAGMENT_TYPE) {
+          if (child.tag === Fragment) {
+            deleteRemainingChildren(returnFiber, child.sibling);
+            const existing = useFiber(child, element.props.children);
+            existing.return = returnFiber;
+
+            return existing;
+          }
+        } else {
+          if (child.elementType === elementType || ( // Keep this check inline so it only runs on the false path:
+          false) || // Lazy types should reconcile their resolved type.
+          // We need to do this after the Hot Reloading check above,
+          // because hot reloading has different semantics than prod because
+          // it doesn't resuspend. So we can't let the call below suspend.
+          typeof elementType === 'object' && elementType !== null && elementType.$$typeof === REACT_LAZY_TYPE && resolveLazy(elementType) === child.type) {
+            deleteRemainingChildren(returnFiber, child.sibling);
+            const existing = useFiber(child, element.props);
+            existing.ref = coerceRef(returnFiber, child, element);
+            existing.return = returnFiber;
+
+            return existing;
+          }
+        } // Didn't match.
+
+
+        deleteRemainingChildren(returnFiber, child);
+        break;
+      } else {
+        deleteChild(returnFiber, child);
+      }
+
+      child = child.sibling;
+    }
+
+    if (element.type === REACT_FRAGMENT_TYPE) {
+      const created = createFiberFromFragment(element.props.children, returnFiber.mode, lanes, element.key);
+      created.return = returnFiber;
+      return created;
+    } else {
+      const created = createFiberFromElement(element, returnFiber.mode, lanes);
+      created.ref = coerceRef(returnFiber, currentFirstChild, element);
+      created.return = returnFiber;
+      return created;
+    }
+  }
+
+  function reconcileSinglePortal(returnFiber, currentFirstChild, portal, lanes) {
+    const key = portal.key;
+    let child = currentFirstChild;
+
+    while (child !== null) {
+      // TODO: If key === null and child.key === null, then this only applies to
+      // the first item in the list.
+      if (child.key === key) {
+        if (child.tag === HostPortal && child.stateNode.containerInfo === portal.containerInfo && child.stateNode.implementation === portal.implementation) {
+          deleteRemainingChildren(returnFiber, child.sibling);
+          const existing = useFiber(child, portal.children || []);
+          existing.return = returnFiber;
+          return existing;
+        } else {
+          deleteRemainingChildren(returnFiber, child);
+          break;
+        }
+      } else {
+        deleteChild(returnFiber, child);
+      }
+
+      child = child.sibling;
+    }
+
+    const created = createFiberFromPortal(portal, returnFiber.mode, lanes);
+    created.return = returnFiber;
+    return created;
+  } // This API will tag the children with the side-effect of the reconciliation
+  // itself. They will be added to the side-effect list as we pass through the
+  // children and the parent.
+
+
+  function reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes) {
+    // This function is not recursive.
+    // If the top level item is an array, we treat it as a set of children,
+    // not as a fragment. Nested arrays on the other hand will be treated as
+    // fragment nodes. Recursion happens at the normal flow.
+    // Handle top level unkeyed fragments as if they were arrays.
+    // This leads to an ambiguity between <>{[...]}</> and <>...</>.
+    // We treat the ambiguous cases above the same.
+    // TODO: Let's use recursion like we do for Usable nodes?
+    const isUnkeyedTopLevelFragment = typeof newChild === 'object' && newChild !== null && newChild.type === REACT_FRAGMENT_TYPE && newChild.key === null;
+
+    if (isUnkeyedTopLevelFragment) {
+      newChild = newChild.props.children;
+    } // Handle object types
+
+
+    if (typeof newChild === 'object' && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          return placeSingleChild(reconcileSingleElement(returnFiber, currentFirstChild, newChild, lanes));
+
+        case REACT_PORTAL_TYPE:
+          return placeSingleChild(reconcileSinglePortal(returnFiber, currentFirstChild, newChild, lanes));
+
+        case REACT_LAZY_TYPE:
+          const payload = newChild._payload;
+          const init = newChild._init; // TODO: This function is supposed to be non-recursive.
+
+          return reconcileChildFibers(returnFiber, currentFirstChild, init(payload), lanes);
+      }
+
+      if (isArray(newChild)) {
+        return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, lanes);
+      }
+
+      if (getIteratorFn(newChild)) {
+        return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, lanes);
+      } // Usables are a valid React node type. When React encounters a Usable in
+      // a child position, it unwraps it using the same algorithm as `use`. For
+      // example, for promises, React will throw an exception to unwind the
+      // stack, then replay the component once the promise resolves.
+      //
+      // A difference from `use` is that React will keep unwrapping the value
+      // until it reaches a non-Usable type.
+      //
+      // e.g. Usable<Usable<Usable<T>>> should resolve to T
+      //
+      // The structure is a bit unfortunate. Ideally, we shouldn't need to
+      // replay the entire begin phase of the parent fiber in order to reconcile
+      // the children again. This would require a somewhat significant refactor,
+      // because reconcilation happens deep within the begin phase, and
+      // depending on the type of work, not always at the end. We should
+      // consider as an future improvement.
+
+
+      if (typeof newChild.then === 'function') {
+        const thenable = newChild;
+        return reconcileChildFibersImpl(returnFiber, currentFirstChild, unwrapThenable(thenable), lanes);
+      }
+
+      if (newChild.$$typeof === REACT_CONTEXT_TYPE || newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+        const context = newChild;
+        return reconcileChildFibersImpl(returnFiber, currentFirstChild, readContextDuringReconcilation(returnFiber, context, lanes), lanes);
+      }
+
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+
+    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {
+      return placeSingleChild(reconcileSingleTextNode(returnFiber, currentFirstChild, '' + newChild, lanes));
+    }
+
+
+    return deleteRemainingChildren(returnFiber, currentFirstChild);
+  }
+
+  function reconcileChildFibers(returnFiber, currentFirstChild, newChild, lanes) {
+    // This indirection only exists so we can reset `thenableState` at the end.
+    // It should get inlined by Closure.
+    thenableIndexCounter$1 = 0;
+    const firstChildFiber = reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes);
+    thenableState$1 = null; // Don't bother to reset `thenableIndexCounter` to 0 because it always gets
+    // set at the beginning.
+
+    return firstChildFiber;
+  }
+
+  return reconcileChildFibers;
+}
+
+const reconcileChildFibers = createChildReconciler(true);
+const mountChildFibers = createChildReconciler(false);
+function resetChildReconcilerOnUnwind() {
+  // On unwind, clear any pending thenables that were used.
+  thenableState$1 = null;
+  thenableIndexCounter$1 = 0;
+}
+function cloneChildFibers(current, workInProgress) {
+  if (current !== null && workInProgress.child !== current.child) {
+    throw Error(formatProdErrorMessage(153));
+  }
+
+  if (workInProgress.child === null) {
+    return;
+  }
+
+  let currentChild = workInProgress.child;
+  let newChild = createWorkInProgress(currentChild, currentChild.pendingProps);
+  workInProgress.child = newChild;
+  newChild.return = workInProgress;
+
+  while (currentChild.sibling !== null) {
+    currentChild = currentChild.sibling;
+    newChild = newChild.sibling = createWorkInProgress(currentChild, currentChild.pendingProps);
+    newChild.return = workInProgress;
+  }
+
+  newChild.sibling = null;
+} // Reset a workInProgress child set to prepare it for a second pass.
+
+function resetChildFibers(workInProgress, lanes) {
+  let child = workInProgress.child;
+
+  while (child !== null) {
+    resetWorkInProgress(child, lanes);
+    child = child.sibling;
+  }
+}
+
+// TODO: This isn't being used yet, but it's intended to replace the
+// InvisibleParentContext that is currently managed by SuspenseContext.
+
+const currentTreeHiddenStackCursor = createCursor(null);
+const prevEntangledRenderLanesCursor = createCursor(NoLanes);
+function pushHiddenContext(fiber, context) {
+  const prevEntangledRenderLanes = getEntangledRenderLanes();
+  push(prevEntangledRenderLanesCursor, prevEntangledRenderLanes);
+  push(currentTreeHiddenStackCursor, context); // When rendering a subtree that's currently hidden, we must include all
+  // lanes that would have rendered if the hidden subtree hadn't been deferred.
+  // That is, in order to reveal content from hidden -> visible, we must commit
+  // all the updates that we skipped when we originally hid the tree.
+
+  setEntangledRenderLanes(mergeLanes(prevEntangledRenderLanes, context.baseLanes));
+}
+function reuseHiddenContextOnStack(fiber) {
+  // This subtree is not currently hidden, so we don't need to add any lanes
+  // to the render lanes. But we still need to push something to avoid a
+  // context mismatch. Reuse the existing context on the stack.
+  push(prevEntangledRenderLanesCursor, getEntangledRenderLanes());
+  push(currentTreeHiddenStackCursor, currentTreeHiddenStackCursor.current);
+}
+function popHiddenContext(fiber) {
+  // Restore the previous render lanes from the stack
+  setEntangledRenderLanes(prevEntangledRenderLanesCursor.current);
+  pop(currentTreeHiddenStackCursor);
+  pop(prevEntangledRenderLanesCursor);
+}
+function isCurrentTreeHidden() {
+  return currentTreeHiddenStackCursor.current !== null;
+}
+
+// suspends, i.e. it's the nearest `catch` block on the stack.
+
+const suspenseHandlerStackCursor = createCursor(null); // Represents the outermost boundary that is not visible in the current tree.
+// Everything above this is the "shell". When this is null, it means we're
+// rendering in the shell of the app. If it's non-null, it means we're rendering
+// deeper than the shell, inside a new tree that wasn't already visible.
+//
+// The main way we use this concept is to determine whether showing a fallback
+// would result in a desirable or undesirable loading state. Activing a fallback
+// in the shell is considered an undersirable loading state, because it would
+// mean hiding visible (albeit stale) content in the current tree — we prefer to
+// show the stale content, rather than switch to a fallback. But showing a
+// fallback in a new tree is fine, because there's no stale content to
+// prefer instead.
+
+let shellBoundary = null;
+function getShellBoundary() {
+  return shellBoundary;
+}
+function pushPrimaryTreeSuspenseHandler(handler) {
+  // TODO: Pass as argument
+  const current = handler.alternate;
+  // propagated a single level. For example, when ForceSuspenseFallback is set,
+  // it should only force the nearest Suspense boundary into fallback mode.
+
+  pushSuspenseListContext(handler, setDefaultShallowSuspenseListContext(suspenseStackCursor.current)); // Experimental feature: Some Suspense boundaries are marked as having an
+  // to push a nested Suspense handler, because it will get replaced by the
+  // outer fallback, anyway. Consider this as a future optimization.
+
+
+  push(suspenseHandlerStackCursor, handler);
+
+  if (shellBoundary === null) {
+    if (current === null || isCurrentTreeHidden()) {
+      // This boundary is not visible in the current UI.
+      shellBoundary = handler;
+    } else {
+      const prevState = current.memoizedState;
+
+      if (prevState !== null) {
+        // This boundary is showing a fallback in the current UI.
+        shellBoundary = handler;
+      }
+    }
+  }
+}
+function pushFallbackTreeSuspenseHandler(fiber) {
+  // We're about to render the fallback. If something in the fallback suspends,
+  // it's akin to throwing inside of a `catch` block. This boundary should not
+  // capture. Reuse the existing handler on the stack.
+  reuseSuspenseHandlerOnStack(fiber);
+}
+function pushOffscreenSuspenseHandler(fiber) {
+  if (fiber.tag === OffscreenComponent) {
+    // A SuspenseList context is only pushed here to avoid a push/pop mismatch.
+    // Reuse the current value on the stack.
+    // TODO: We can avoid needing to push here by by forking popSuspenseHandler
+    // into separate functions for Suspense and Offscreen.
+    pushSuspenseListContext(fiber, suspenseStackCursor.current);
+    push(suspenseHandlerStackCursor, fiber);
+
+    if (shellBoundary !== null) ; else {
+      const current = fiber.alternate;
+
+      if (current !== null) {
+        const prevState = current.memoizedState;
+
+        if (prevState !== null) {
+          // This is the first boundary in the stack that's already showing
+          // a fallback. So everything outside is considered the shell.
+          shellBoundary = fiber;
+        }
+      }
+    }
+  } else {
+    // This is a LegacyHidden component.
+    reuseSuspenseHandlerOnStack(fiber);
+  }
+}
+function reuseSuspenseHandlerOnStack(fiber) {
+  pushSuspenseListContext(fiber, suspenseStackCursor.current);
+  push(suspenseHandlerStackCursor, getSuspenseHandler());
+}
+function getSuspenseHandler() {
+  return suspenseHandlerStackCursor.current;
+}
+function popSuspenseHandler(fiber) {
+  pop(suspenseHandlerStackCursor);
+
+  if (shellBoundary === fiber) {
+    // Popping back into the shell.
+    shellBoundary = null;
+  }
+
+  popSuspenseListContext();
+} // SuspenseList context
+// TODO: Move to a separate module? We may change the SuspenseList
+// implementation to hide/show in the commit phase, anyway.
+
+const DefaultSuspenseContext = 0b00;
+const SubtreeSuspenseContextMask = 0b01; // ForceSuspenseFallback can be used by SuspenseList to force newly added
+// items into their fallback state during one of the render passes.
+
+const ForceSuspenseFallback = 0b10;
+const suspenseStackCursor = createCursor(DefaultSuspenseContext);
+function hasSuspenseListContext(parentContext, flag) {
+  return (parentContext & flag) !== 0;
+}
+function setDefaultShallowSuspenseListContext(parentContext) {
+  return parentContext & SubtreeSuspenseContextMask;
+}
+function setShallowSuspenseListContext(parentContext, shallowContext) {
+  return parentContext & SubtreeSuspenseContextMask | shallowContext;
+}
+function pushSuspenseListContext(fiber, newContext) {
+  push(suspenseStackCursor, newContext);
+}
+function popSuspenseListContext(fiber) {
+  pop(suspenseStackCursor);
+}
+
+// A non-null SuspenseState means that it is blocked for one reason or another.
+// - A non-null dehydrated field means it's blocked pending hydration.
+//   - A non-null dehydrated field can use isSuspenseInstancePending or
+//     isSuspenseInstanceFallback to query the reason for being dehydrated.
+// - A null dehydrated field means it's blocked by something suspending and
+//   we're currently showing a fallback instead.
+
+function findFirstSuspended(row) {
+  let node = row;
+
+  while (node !== null) {
+    if (node.tag === SuspenseComponent) {
+      const state = node.memoizedState;
+
+      if (state !== null) {
+        const dehydrated = state.dehydrated;
+
+        if (dehydrated === null || isSuspenseInstancePending(dehydrated) || isSuspenseInstanceFallback(dehydrated)) {
+          return node;
+        }
+      }
+    } else if (node.tag === SuspenseListComponent && // revealOrder undefined can't be trusted because it don't
+    // keep track of whether it suspended or not.
+    node.memoizedProps.revealOrder !== undefined) {
+      const didSuspend = (node.flags & DidCapture) !== NoFlags$1;
+
+      if (didSuspend) {
+        return node;
+      }
+    } else if (node.child !== null) {
+      node.child.return = node;
+      node = node.child;
+      continue;
+    }
+
+    if (node === row) {
+      return null;
+    }
+
+    while (node.sibling === null) {
+      if (node.return === null || node.return === row) {
+        return null;
+      }
+
+      node = node.return;
+    }
+
+    node.sibling.return = node.return;
+    node = node.sibling;
+  }
+
+  return null;
+}
+
+const NoFlags =
+/*   */
+0b0000; // Represents whether effect should fire.
+
+const HasEffect =
+/* */
+0b0001; // Represents the phase in which the effect (not the clean-up) fires.
+
+const Insertion =
+/* */
+0b0010;
+const Layout =
+/*    */
+0b0100;
+const Passive =
+/*   */
+0b1000;
+
+// there's only a single root, but we do support multi root apps, hence this
+// extra complexity. But this module is optimized for the single root case.
+
+let firstScheduledRoot = null;
+let lastScheduledRoot = null; // Used to prevent redundant mircotasks from being scheduled.
+
+let didScheduleMicrotask = false; // `act` "microtasks" are scheduled on the `act` queue instead of an actual
+
+let mightHavePendingSyncWork = false;
+let isFlushingWork = false;
+let currentEventTransitionLane = NoLane;
+function ensureRootIsScheduled(root) {
+  // This function is called whenever a root receives an update. It does two
+  // things 1) it ensures the root is in the root schedule, and 2) it ensures
+  // there's a pending microtask to process the root schedule.
+  //
+  // Most of the actual scheduling logic does not happen until
+  // `scheduleTaskForRootDuringMicrotask` runs.
+  // Add the root to the schedule
+  if (root === lastScheduledRoot || root.next !== null) ; else {
+    if (lastScheduledRoot === null) {
+      firstScheduledRoot = lastScheduledRoot = root;
+    } else {
+      lastScheduledRoot.next = root;
+      lastScheduledRoot = root;
+    }
+  } // Any time a root received an update, we set this to true until the next time
+  // we process the schedule. If it's false, then we can quickly exit flushSync
+  // without consulting the schedule.
+
+
+  mightHavePendingSyncWork = true; // At the end of the current event, go through each of the roots and ensure
+  // there's a task scheduled for each one at the correct priority.
+
+  {
+    if (!didScheduleMicrotask) {
+      didScheduleMicrotask = true;
+      scheduleImmediateTask(processRootScheduleInMicrotask);
+    }
+  }
+}
+function flushSyncWorkOnAllRoots() {
+  // This is allowed to be called synchronously, but the caller should check
+  // the execution context first.
+  flushSyncWorkAcrossRoots_impl(false);
+}
+function flushSyncWorkOnLegacyRootsOnly() {
+  // This is allowed to be called synchronously, but the caller should check
+  // the execution context first.
+  flushSyncWorkAcrossRoots_impl(true);
+}
+
+function flushSyncWorkAcrossRoots_impl(onlyLegacy) {
+  if (isFlushingWork) {
+    // Prevent reentrancy.
+    // TODO: Is this overly defensive? The callers must check the execution
+    // context first regardless.
+    return;
+  }
+
+  if (!mightHavePendingSyncWork) {
+    // Fast path. There's no sync work to do.
+    return;
+  } // There may or may not be synchronous work scheduled. Let's check.
+
+
+  let didPerformSomeWork;
+  let errors = null;
+  isFlushingWork = true;
+
+  do {
+    didPerformSomeWork = false;
+    let root = firstScheduledRoot;
+
+    while (root !== null) {
+      if (onlyLegacy && root.tag !== LegacyRoot) ; else {
+        const workInProgressRoot = getWorkInProgressRoot();
+        const workInProgressRootRenderLanes = getWorkInProgressRootRenderLanes();
+        const nextLanes = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes);
+
+        if (includesSyncLane(nextLanes)) {
+          // This root has pending sync work. Flush it now.
+          try {
+            didPerformSomeWork = true;
+            performSyncWorkOnRoot(root, nextLanes);
+          } catch (error) {
+            // Collect errors so we can rethrow them at the end
+            if (errors === null) {
+              errors = [error];
+            } else {
+              errors.push(error);
+            }
+          }
+        }
+      }
+
+      root = root.next;
+    }
+  } while (didPerformSomeWork);
+
+  isFlushingWork = false; // If any errors were thrown, rethrow them right before exiting.
+  // TODO: Consider returning these to the caller, to allow them to decide
+  // how/when to rethrow.
+
+  if (errors !== null) {
+    if (errors.length > 1) {
+      if (typeof AggregateError === 'function') {
+        // eslint-disable-next-line no-undef
+        throw new AggregateError(errors);
+      } else {
+        for (let i = 1; i < errors.length; i++) {
+          scheduleImmediateTask(throwError.bind(null, errors[i]));
+        }
+
+        const firstError = errors[0];
+        throw firstError;
+      }
+    } else {
+      const error = errors[0];
+      throw error;
+    }
+  }
+}
+
+function throwError(error) {
+  throw error;
+}
+
+function processRootScheduleInMicrotask() {
+  // This function is always called inside a microtask. It should never be
+  // called synchronously.
+  didScheduleMicrotask = false;
+
+
+  mightHavePendingSyncWork = false;
+  const currentTime = now$1();
+  let prev = null;
+  let root = firstScheduledRoot;
+
+  while (root !== null) {
+    const next = root.next;
+
+    if (currentEventTransitionLane !== NoLane && shouldAttemptEagerTransition()) {
+      // A transition was scheduled during an event, but we're going to try to
+      // render it synchronously anyway. We do this during a popstate event to
+      // preserve the scroll position of the previous page.
+      upgradePendingLaneToSync(root, currentEventTransitionLane);
+    }
+
+    const nextLanes = scheduleTaskForRootDuringMicrotask(root, currentTime);
+
+    if (nextLanes === NoLane) {
+      // This root has no more pending work. Remove it from the schedule. To
+      // guard against subtle reentrancy bugs, this microtask is the only place
+      // we do this — you can add roots to the schedule whenever, but you can
+      // only remove them here.
+      // Null this out so we know it's been removed from the schedule.
+      root.next = null;
+
+      if (prev === null) {
+        // This is the new head of the list
+        firstScheduledRoot = next;
+      } else {
+        prev.next = next;
+      }
+
+      if (next === null) {
+        // This is the new tail of the list
+        lastScheduledRoot = prev;
+      }
+    } else {
+      // This root still has work. Keep it in the list.
+      prev = root;
+
+      if (includesSyncLane(nextLanes)) {
+        mightHavePendingSyncWork = true;
+      }
+    }
+
+    root = next;
+  }
+
+  currentEventTransitionLane = NoLane; // At the end of the microtask, flush any pending synchronous work. This has
+  // to come at the end, because it does actual rendering work that might throw.
+
+  flushSyncWorkOnAllRoots();
+}
+
+function scheduleTaskForRootDuringMicrotask(root, currentTime) {
+  // This function is always called inside a microtask, or at the very end of a
+  // rendering task right before we yield to the main thread. It should never be
+  // called synchronously.
+  //
+  // TODO: Unless enableDeferRootSchedulingToMicrotask is off. We need to land
+  // that ASAP to unblock additional features we have planned.
+  //
+  // This function also never performs React work synchronously; it should
+  // only schedule work to be performed later, in a separate task or microtask.
+  // Check if any lanes are being starved by other work. If so, mark them as
+  // expired so we know to work on those next.
+  markStarvedLanesAsExpired(root, currentTime); // Determine the next lanes to work on, and their priority.
+
+  const workInProgressRoot = getWorkInProgressRoot();
+  const workInProgressRootRenderLanes = getWorkInProgressRootRenderLanes();
+  const nextLanes = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes);
+  const existingCallbackNode = root.callbackNode;
+
+  if ( // Check if there's nothing to work on
+  nextLanes === NoLanes || // If this root is currently suspended and waiting for data to resolve, don't
+  // schedule a task to render it. We'll either wait for a ping, or wait to
+  // receive an update.
+  //
+  // Suspended render phase
+  root === workInProgressRoot && isWorkLoopSuspendedOnData() || // Suspended commit phase
+  root.cancelPendingCommit !== null) {
+    // Fast path: There's nothing to work on.
+    if (existingCallbackNode !== null) {
+      cancelCallback(existingCallbackNode);
+    }
+
+    root.callbackNode = null;
+    root.callbackPriority = NoLane;
+    return NoLane;
+  } // Schedule a new callback in the host environment.
+
+
+  if (includesSyncLane(nextLanes)) {
+    // Synchronous work is always flushed at the end of the microtask, so we
+    // don't need to schedule an additional task.
+    if (existingCallbackNode !== null) {
+      cancelCallback(existingCallbackNode);
+    }
+
+    root.callbackPriority = SyncLane;
+    root.callbackNode = null;
+    return SyncLane;
+  } else {
+    // We use the highest priority lane to represent the priority of the callback.
+    const existingCallbackPriority = root.callbackPriority;
+    const newCallbackPriority = getHighestPriorityLane(nextLanes);
+
+    if (newCallbackPriority === existingCallbackPriority && // Special case related to `act`. If the currently scheduled task is a
+    // Scheduler task, rather than an `act` task, cancel it and re-schedule
+    // on the `act` queue.
+    !(false  )) {
+      // The priority hasn't changed. We can reuse the existing task.
+      return newCallbackPriority;
+    } else {
+      // Cancel the existing callback. We'll schedule a new one below.
+      cancelCallback(existingCallbackNode);
+    }
+
+    let schedulerPriorityLevel;
+
+    switch (lanesToEventPriority(nextLanes)) {
+      case DiscreteEventPriority:
+        schedulerPriorityLevel = ImmediatePriority;
+        break;
+
+      case ContinuousEventPriority:
+        schedulerPriorityLevel = UserBlockingPriority;
+        break;
+
+      case DefaultEventPriority:
+        schedulerPriorityLevel = NormalPriority$1;
+        break;
+
+      case IdleEventPriority:
+        schedulerPriorityLevel = IdlePriority;
+        break;
+
+      default:
+        schedulerPriorityLevel = NormalPriority$1;
+        break;
+    }
+
+    const newCallbackNode = scheduleCallback$2(schedulerPriorityLevel, performConcurrentWorkOnRoot.bind(null, root));
+    root.callbackPriority = newCallbackPriority;
+    root.callbackNode = newCallbackNode;
+    return newCallbackPriority;
+  }
+}
+
+function getContinuationForRoot(root, originalCallbackNode) {
+  // This is called at the end of `performConcurrentWorkOnRoot` to determine
+  // if we need to schedule a continuation task.
+  //
+  // Usually `scheduleTaskForRootDuringMicrotask` only runs inside a microtask;
+  // however, since most of the logic for determining if we need a continuation
+  // versus a new task is the same, we cheat a bit and call it here. This is
+  // only safe to do because we know we're at the end of the browser task.
+  // So although it's not an actual microtask, it might as well be.
+  scheduleTaskForRootDuringMicrotask(root, now$1());
+
+  if (root.callbackNode === originalCallbackNode) {
+    // The task node scheduled for this root is the same one that's
+    // currently executed. Need to return a continuation.
+    return performConcurrentWorkOnRoot.bind(null, root);
+  }
+
+  return null;
+}
+
+function scheduleCallback$2(priorityLevel, callback) {
+  {
+    return scheduleCallback$3(priorityLevel, callback);
+  }
+}
+
+function cancelCallback(callbackNode) {
+  if (callbackNode !== null) {
+    cancelCallback$1(callbackNode);
+  }
+}
+
+function scheduleImmediateTask(cb) {
+  // Alternatively, can we move this check to the host config?
+
+
+  {
+    scheduleMicrotask(() => {
+      // In Safari, appending an iframe forces microtasks to run.
+      // https://github.com/facebook/react/issues/22459
+      // We don't support running callbacks in the middle of render
+      // or commit so we need to check against that.
+      const executionContext = getExecutionContext();
+
+      if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+        // Note that this would still prematurely flush the callbacks
+        // if this happens outside render or commit phase (e.g. in an event).
+        // Intentionally using a macrotask instead of a microtask here. This is
+        // wrong semantically but it prevents an infinite loop. The bug is
+        // Safari's, not ours, so we just do our best to not crash even though
+        // the behavior isn't completely correct.
+        scheduleCallback$3(ImmediatePriority, cb);
+        return;
+      }
+
+      cb();
+    });
+  }
+}
+
+function requestTransitionLane() {
+  // The algorithm for assigning an update to a lane should be stable for all
+  // updates at the same priority within the same event. To do this, the
+  // inputs to the algorithm must be the same.
+  //
+  // The trick we use is to cache the first of each of these inputs within an
+  // event. Then reset the cached values once we can be sure the event is
+  // over. Our heuristic for that is whenever we enter a concurrent work loop.
+  if (currentEventTransitionLane === NoLane) {
+    // All transitions within the same event are assigned the same lane.
+    currentEventTransitionLane = claimNextTransitionLane();
+  }
+
+  return currentEventTransitionLane;
+}
+
+// transition updates that occur while the async action is still in progress
+// are treated as part of the action.
+//
+// The ideal behavior would be to treat each async function as an independent
+// action. However, without a mechanism like AsyncContext, we can't tell which
+// action an update corresponds to. So instead, we entangle them all into one.
+// The listeners to notify once the entangled scope completes.
+
+let currentEntangledListeners = null; // The number of pending async actions in the entangled scope.
+
+let currentEntangledPendingCount = 0; // The transition lane shared by all updates in the entangled scope.
+
+let currentEntangledLane = NoLane;
+function requestAsyncActionContext(actionReturnValue, // If this is provided, this resulting thenable resolves to this value instead
+// of the return value of the action. This is a perf trick to avoid composing
+// an extra async function.
+overrideReturnValue) {
+  // This is an async action.
+  //
+  // Return a thenable that resolves once the action scope (i.e. the async
+  // function passed to startTransition) has finished running.
+  const thenable = actionReturnValue;
+  let entangledListeners;
+
+  if (currentEntangledListeners === null) {
+    // There's no outer async action scope. Create a new one.
+    entangledListeners = currentEntangledListeners = [];
+    currentEntangledPendingCount = 0;
+    currentEntangledLane = requestTransitionLane();
+  } else {
+    entangledListeners = currentEntangledListeners;
+  }
+
+  currentEntangledPendingCount++; // Create a thenable that represents the result of this action, but doesn't
+  // resolve until the entire entangled scope has finished.
+  //
+  // Expressed using promises:
+  //   const [thisResult] = await Promise.all([thisAction, entangledAction]);
+  //   return thisResult;
+
+  const resultThenable = createResultThenable(entangledListeners);
+  let resultStatus = 'pending';
+  let resultValue;
+  let rejectedReason;
+  thenable.then(value => {
+    resultStatus = 'fulfilled';
+    resultValue = overrideReturnValue !== null ? overrideReturnValue : value;
+    pingEngtangledActionScope();
+  }, error => {
+    resultStatus = 'rejected';
+    rejectedReason = error;
+    pingEngtangledActionScope();
+  }); // Attach a listener to fill in the result.
+
+  entangledListeners.push(() => {
+    switch (resultStatus) {
+      case 'fulfilled':
+        {
+          const fulfilledThenable = resultThenable;
+          fulfilledThenable.status = 'fulfilled';
+          fulfilledThenable.value = resultValue;
+          break;
+        }
+
+      case 'rejected':
+        {
+          const rejectedThenable = resultThenable;
+          rejectedThenable.status = 'rejected';
+          rejectedThenable.reason = rejectedReason;
+          break;
+        }
+
+      case 'pending':
+      default:
+        {
+          // The listener above should have been called first, so `resultStatus`
+          // should already be set to the correct value.
+          throw Error(formatProdErrorMessage(478));
+        }
+    }
+  });
+  return resultThenable;
+}
+function requestSyncActionContext(actionReturnValue, // If this is provided, this resulting thenable resolves to this value instead
+// of the return value of the action. This is a perf trick to avoid composing
+// an extra async function.
+overrideReturnValue) {
+  const resultValue = overrideReturnValue !== null ? overrideReturnValue : actionReturnValue; // This is not an async action, but it may be part of an outer async action.
+
+  if (currentEntangledListeners === null) {
+    return resultValue;
+  } else {
+    // Return a thenable that does not resolve until the entangled actions
+    // have finished.
+    const entangledListeners = currentEntangledListeners;
+    const resultThenable = createResultThenable(entangledListeners);
+    entangledListeners.push(() => {
+      const fulfilledThenable = resultThenable;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = resultValue;
+    });
+    return resultThenable;
+  }
+}
+
+function pingEngtangledActionScope() {
+  if (currentEntangledListeners !== null && --currentEntangledPendingCount === 0) {
+    // All the actions have finished. Close the entangled async action scope
+    // and notify all the listeners.
+    const listeners = currentEntangledListeners;
+    currentEntangledListeners = null;
+    currentEntangledLane = NoLane;
+
+    for (let i = 0; i < listeners.length; i++) {
+      const listener = listeners[i];
+      listener();
+    }
+  }
+}
+
+function createResultThenable(entangledListeners) {
+  // Waits for the entangled async action to complete, then resolves to the
+  // result of an individual action.
+  const resultThenable = {
+    status: 'pending',
+    value: null,
+    reason: null,
+
+    then(resolve) {
+      // This is a bit of a cheat. `resolve` expects a value of type `S` to be
+      // passed, but because we're instrumenting the `status` field ourselves,
+      // and we know this thenable will only be used by React, we also know
+      // the value isn't actually needed. So we add the resolve function
+      // directly to the entangled listeners.
+      //
+      // This is also why we don't need to check if the thenable is still
+      // pending; the Suspense implementation already performs that check.
+      const ping = resolve;
+      entangledListeners.push(ping);
+    }
+
+  };
+  return resultThenable;
+}
+
+function peekEntangledActionLane() {
+  return currentEntangledLane;
+}
+
+const ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
+      ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig;
+// lifetime of an effect. In Rust terms, a RefCell. We use it to store the
+// "destroy" function that is returned from an effect, because that is stateful.
+// The field is `undefined` if the effect is unmounted, or if the effect ran
+// but is not stateful. We don't explicitly track whether the effect is mounted
+// or unmounted because that can be inferred by the hiddenness of the fiber in
+// the tree, i.e. whether there is a hidden Offscreen fiber above it.
+//
+// It's unfortunate that this is stored on a separate object, because it adds
+// more memory per effect instance, but it's conceptually sound. I think there's
+// likely a better data structure we could use for effects; perhaps just one
+// array of effect instances per fiber. But I think this is OK for now despite
+// the additional memory and we can follow up with performance
+// optimizations later.
+// These are set right before calling the component.
+
+
+let renderLanes = NoLanes; // The work-in-progress fiber. I've named it differently to distinguish it from
+// the work-in-progress hook.
+
+let currentlyRenderingFiber$1 = null; // Hooks are stored as a linked list on the fiber's memoizedState field. The
+// current hook list is the list that belongs to the current fiber. The
+// work-in-progress hook list is a new list that will be added to the
+// work-in-progress fiber.
+
+let currentHook = null;
+let workInProgressHook = null; // Whether an update was scheduled at any point during the render phase. This
+// does not get reset if we do another render pass; only when we're completely
+// finished evaluating this component. This is an optimization so we know
+// whether we need to clear render phase updates after a throw.
+
+let didScheduleRenderPhaseUpdate = false; // Where an update was scheduled only during the current render pass. This
+// gets reset after each attempt.
+// TODO: Maybe there's some way to consolidate this with
+// `didScheduleRenderPhaseUpdate`. Or with `numberOfReRenders`.
+
+let didScheduleRenderPhaseUpdateDuringThisPass = false;
+let shouldDoubleInvokeUserFnsInHooksDEV = false; // Counts the number of useId hooks in this component.
+
+let localIdCounter = 0; // Counts number of `use`-d thenables
+
+let thenableIndexCounter = 0;
+let thenableState = null; // Used for ids that are generated completely client-side (i.e. not during
+// hydration). This counter is global, so client ids are not stable across
+// render attempts.
+
+let globalClientIdCounter = 0;
+const RE_RENDER_LIMIT = 25; // In DEV, this is the name of the currently executing primitive hook
+
+function throwInvalidHookError() {
+  throw Error(formatProdErrorMessage(321));
+}
+
+function areHookInputsEqual(nextDeps, prevDeps) {
+
+  if (prevDeps === null) {
+
+    return false;
+  }
+
+
+  for (let i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    if (objectIs(nextDeps[i], prevDeps[i])) {
+      continue;
+    }
+
+    return false;
+  }
+
+  return true;
+}
+
+function renderWithHooks(current, workInProgress, Component, props, secondArg, nextRenderLanes) {
+  renderLanes = nextRenderLanes;
+  currentlyRenderingFiber$1 = workInProgress;
+
+  workInProgress.memoizedState = null;
+  workInProgress.updateQueue = null;
+  workInProgress.lanes = NoLanes; // The following should have already been reset
+  // currentHook = null;
+  // workInProgressHook = null;
+  // didScheduleRenderPhaseUpdate = false;
+  // localIdCounter = 0;
+  // thenableIndexCounter = 0;
+  // thenableState = null;
+  // TODO Warn if no hooks are used at all during mount, then some are used during update.
+  // Currently we will identify the update render as a mount because memoizedState === null.
+  // This is tricky because it's valid for certain types of components (e.g. React.lazy)
+  // Using memoizedState to differentiate between mount/update only works if at least one stateful hook is used.
+  // Non-stateful hooks (e.g. context) don't get added to memoizedState,
+  // so memoizedState would be null during updates and mounts.
+
+  {
+    ReactCurrentDispatcher$1.current = current === null || current.memoizedState === null ? HooksDispatcherOnMount : HooksDispatcherOnUpdate;
+  } // In Strict Mode, during development, user functions are double invoked to
+  // help detect side effects. The logic for how this is implemented for in
+  // hook components is a bit complex so let's break it down.
+  //
+  // We will invoke the entire component function twice. However, during the
+  // second invocation of the component, the hook state from the first
+  // invocation will be reused. That means things like `useMemo` functions won't
+  // run again, because the deps will match and the memoized result will
+  // be reused.
+  //
+  // We want memoized functions to run twice, too, so account for this, user
+  // functions are double invoked during the *first* invocation of the component
+  // function, and are *not* double invoked during the second incovation:
+  //
+  // - First execution of component function: user functions are double invoked
+  // - Second execution of component function (in Strict Mode, during
+  //   development): user functions are not double invoked.
+  //
+  // This is intentional for a few reasons; most importantly, it's because of
+  // how `use` works when something suspends: it reuses the promise that was
+  // passed during the first attempt. This is itself a form of memoization.
+  // We need to be able to memoize the reactive inputs to the `use` call using
+  // a hook (i.e. `useMemo`), which means, the reactive inputs to `use` must
+  // come from the same component invocation as the output.
+  //
+  // There are plenty of tests to ensure this behavior is correct.
+
+
+  const shouldDoubleRenderDEV = false  ;
+  shouldDoubleInvokeUserFnsInHooksDEV = shouldDoubleRenderDEV;
+  let children = Component(props, secondArg);
+  shouldDoubleInvokeUserFnsInHooksDEV = false; // Check if there was a render phase update
+
+  if (didScheduleRenderPhaseUpdateDuringThisPass) {
+    // Keep rendering until the component stabilizes (there are no more render
+    // phase updates).
+    children = renderWithHooksAgain(workInProgress, Component, props, secondArg);
+  }
+
+  finishRenderingHooks();
+  return children;
+}
+
+function finishRenderingHooks(current, workInProgress, Component) {
+  // at the beginning of the render phase and there's no re-entrance.
+
+
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher; // This check uses currentHook so that it works the same in DEV and prod bundles.
+  // hookTypesDev could catch more cases (e.g. context) but only in DEV bundles.
+
+  const didRenderTooFewHooks = currentHook !== null && currentHook.next !== null;
+  renderLanes = NoLanes;
+  currentlyRenderingFiber$1 = null;
+  currentHook = null;
+  workInProgressHook = null;
+
+  didScheduleRenderPhaseUpdate = false; // This is reset by checkDidRenderIdHook
+  // localIdCounter = 0;
+
+  thenableIndexCounter = 0;
+  thenableState = null;
+
+  if (didRenderTooFewHooks) {
+    throw Error(formatProdErrorMessage(300));
+  }
+}
+
+function replaySuspendedComponentWithHooks(current, workInProgress, Component, props, secondArg) {
+
+  const children = renderWithHooksAgain(workInProgress, Component, props, secondArg);
+  finishRenderingHooks();
+  return children;
+}
+
+function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
+  // This is used to perform another render pass. It's used when setState is
+  // called during render, and for double invoking components in Strict Mode
+  // during development.
+  //
+  // The state from the previous pass is reused whenever possible. So, state
+  // updates that were already processed are not processed again, and memoized
+  // functions (`useMemo`) are not invoked again.
+  //
+  // Keep rendering in a loop for as long as render phase updates continue to
+  // be scheduled. Use a counter to prevent infinite loops.
+  currentlyRenderingFiber$1 = workInProgress;
+  let numberOfReRenders = 0;
+  let children;
+
+  do {
+    if (didScheduleRenderPhaseUpdateDuringThisPass) {
+      // It's possible that a use() value depended on a state that was updated in
+      // this rerender, so we need to watch for different thenables this time.
+      thenableState = null;
+    }
+
+    thenableIndexCounter = 0;
+    didScheduleRenderPhaseUpdateDuringThisPass = false;
+
+    if (numberOfReRenders >= RE_RENDER_LIMIT) {
+      throw Error(formatProdErrorMessage(301));
+    }
+
+    numberOfReRenders += 1;
+
+
+    currentHook = null;
+    workInProgressHook = null;
+    workInProgress.updateQueue = null;
+
+    ReactCurrentDispatcher$1.current = HooksDispatcherOnRerender;
+    children = Component(props, secondArg);
+  } while (didScheduleRenderPhaseUpdateDuringThisPass);
+
+  return children;
+}
+
+function renderTransitionAwareHostComponentWithHooks(current, workInProgress, lanes) {
+
+  return renderWithHooks(current, workInProgress, TransitionAwareHostComponent, null, null, lanes);
+}
+function TransitionAwareHostComponent() {
+
+  const dispatcher = ReactCurrentDispatcher$1.current;
+
+  const _dispatcher$useState = dispatcher.useState(),
+        maybeThenable = _dispatcher$useState[0];
+
+  if (typeof maybeThenable.then === 'function') {
+    const thenable = maybeThenable;
+    return useThenable(thenable);
+  } else {
+    const status = maybeThenable;
+    return status;
+  }
+}
+function checkDidRenderIdHook() {
+  // This should be called immediately after every renderWithHooks call.
+  // Conceptually, it's part of the return value of renderWithHooks; it's only a
+  // separate function to avoid using an array tuple.
+  const didRenderIdHook = localIdCounter !== 0;
+  localIdCounter = 0;
+  return didRenderIdHook;
+}
+function bailoutHooks(current, workInProgress, lanes) {
+  workInProgress.updateQueue = current.updateQueue; // TODO: Don't need to reset the flags here, because they're reset in the
+  // complete phase (bubbleProperties).
+
+  {
+    workInProgress.flags &= ~(Passive$1 | Update);
+  }
+
+  current.lanes = removeLanes(current.lanes, lanes);
+}
+function resetHooksAfterThrow() {
+  // This is called immediaetly after a throw. It shouldn't reset the entire
+  // module state, because the work loop might decide to replay the component
+  // again without rewinding.
+  //
+  // It should only reset things like the current dispatcher, to prevent hooks
+  // from being called outside of a component.
+  currentlyRenderingFiber$1 = null; // We can assume the previous dispatcher is always this one, since we set it
+  // at the beginning of the render phase and there's no re-entrance.
+
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+}
+function resetHooksOnUnwind(workInProgress) {
+  if (didScheduleRenderPhaseUpdate) {
+    // There were render phase updates. These are only valid for this render
+    // phase, which we are now aborting. Remove the updates from the queues so
+    // they do not persist to the next render. Do not remove updates from hooks
+    // that weren't processed.
+    //
+    // Only reset the updates from the queue if it has a clone. If it does
+    // not have a clone, that means it wasn't processed, and the updates were
+    // scheduled before we entered the render phase.
+    let hook = workInProgress.memoizedState;
+
+    while (hook !== null) {
+      const queue = hook.queue;
+
+      if (queue !== null) {
+        queue.pending = null;
+      }
+
+      hook = hook.next;
+    }
+
+    didScheduleRenderPhaseUpdate = false;
+  }
+
+  renderLanes = NoLanes;
+  currentlyRenderingFiber$1 = null;
+  currentHook = null;
+  workInProgressHook = null;
+
+  didScheduleRenderPhaseUpdateDuringThisPass = false;
+  localIdCounter = 0;
+  thenableIndexCounter = 0;
+  thenableState = null;
+}
+
+function mountWorkInProgressHook() {
+  const hook = {
+    memoizedState: null,
+    baseState: null,
+    baseQueue: null,
+    queue: null,
+    next: null
+  };
+
+  if (workInProgressHook === null) {
+    // This is the first hook in the list
+    currentlyRenderingFiber$1.memoizedState = workInProgressHook = hook;
+  } else {
+    // Append to the end of the list
+    workInProgressHook = workInProgressHook.next = hook;
+  }
+
+  return workInProgressHook;
+}
+
+function updateWorkInProgressHook() {
+  // This function is used both for updates and for re-renders triggered by a
+  // render phase update. It assumes there is either a current hook we can
+  // clone, or a work-in-progress hook from a previous render pass that we can
+  // use as a base.
+  let nextCurrentHook;
+
+  if (currentHook === null) {
+    const current = currentlyRenderingFiber$1.alternate;
+
+    if (current !== null) {
+      nextCurrentHook = current.memoizedState;
+    } else {
+      nextCurrentHook = null;
+    }
+  } else {
+    nextCurrentHook = currentHook.next;
+  }
+
+  let nextWorkInProgressHook;
+
+  if (workInProgressHook === null) {
+    nextWorkInProgressHook = currentlyRenderingFiber$1.memoizedState;
+  } else {
+    nextWorkInProgressHook = workInProgressHook.next;
+  }
+
+  if (nextWorkInProgressHook !== null) {
+    // There's already a work-in-progress. Reuse it.
+    workInProgressHook = nextWorkInProgressHook;
+    nextWorkInProgressHook = workInProgressHook.next;
+    currentHook = nextCurrentHook;
+  } else {
+    // Clone from the current hook.
+    if (nextCurrentHook === null) {
+      const currentFiber = currentlyRenderingFiber$1.alternate;
+
+      if (currentFiber === null) {
+        // This is the initial render. This branch is reached when the component
+        // suspends, resumes, then renders an additional hook.
+        // Should never be reached because we should switch to the mount dispatcher first.
+        throw Error(formatProdErrorMessage(467));
+      } else {
+        // This is an update. We should always have a current hook.
+        throw Error(formatProdErrorMessage(310));
+      }
+    }
+
+    currentHook = nextCurrentHook;
+    const newHook = {
+      memoizedState: currentHook.memoizedState,
+      baseState: currentHook.baseState,
+      baseQueue: currentHook.baseQueue,
+      queue: currentHook.queue,
+      next: null
+    };
+
+    if (workInProgressHook === null) {
+      // This is the first hook in the list.
+      currentlyRenderingFiber$1.memoizedState = workInProgressHook = newHook;
+    } else {
+      // Append to the end of the list.
+      workInProgressHook = workInProgressHook.next = newHook;
+    }
+  }
+
+  return workInProgressHook;
+} // NOTE: defining two versions of this function to avoid size impact when this feature is disabled.
+// Previously this function was inlined, the additional `memoCache` property makes it not inlined.
+
+
+let createFunctionComponentUpdateQueue;
+
+{
+  createFunctionComponentUpdateQueue = () => {
+    return {
+      lastEffect: null,
+      events: null,
+      stores: null
+    };
+  };
+}
+
+function useThenable(thenable) {
+  // Track the position of the thenable within this fiber.
+  const index = thenableIndexCounter;
+  thenableIndexCounter += 1;
+
+  if (thenableState === null) {
+    thenableState = createThenableState();
+  }
+
+  const result = trackUsedThenable(thenableState, thenable, index);
+
+  if (currentlyRenderingFiber$1.alternate === null && (workInProgressHook === null ? currentlyRenderingFiber$1.memoizedState === null : workInProgressHook.next === null)) {
+    // Initial render, and either this is the first time the component is
+    // called, or there were no Hooks called after this use() the previous
+    // time (perhaps because it threw). Subsequent Hook calls should use the
+    // mount dispatcher.
+    {
+      ReactCurrentDispatcher$1.current = HooksDispatcherOnMount;
+    }
+  }
+
+  return result;
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable;
+      return useThenable(thenable);
+    } else if (usable.$$typeof === REACT_CONTEXT_TYPE || usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+  throw Error(formatProdErrorMessage(438, String(usable)));
+}
+
+function basicStateReducer(state, action) {
+  // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
+  return typeof action === 'function' ? action(state) : action;
+}
+
+function mountReducer(reducer, initialArg, init) {
+  const hook = mountWorkInProgressHook();
+  let initialState;
+
+  if (init !== undefined) {
+    initialState = init(initialArg);
+  } else {
+    initialState = initialArg;
+  }
+
+  hook.memoizedState = hook.baseState = initialState;
+  const queue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    lastRenderedReducer: reducer,
+    lastRenderedState: initialState
+  };
+  hook.queue = queue;
+  const dispatch = queue.dispatch = dispatchReducerAction.bind(null, currentlyRenderingFiber$1, queue);
+  return [hook.memoizedState, dispatch];
+}
+
+function updateReducer(reducer, initialArg, init) {
+  const hook = updateWorkInProgressHook();
+  return updateReducerImpl(hook, currentHook, reducer);
+}
+
+function updateReducerImpl(hook, current, reducer) {
+  const queue = hook.queue;
+
+  if (queue === null) {
+    throw Error(formatProdErrorMessage(311));
+  }
+
+  queue.lastRenderedReducer = reducer; // The last rebase update that is NOT part of the base state.
+
+  let baseQueue = hook.baseQueue; // The last pending update that hasn't been processed yet.
+
+  const pendingQueue = queue.pending;
+
+  if (pendingQueue !== null) {
+    // We have new updates that haven't been processed yet.
+    // We'll add them to the base queue.
+    if (baseQueue !== null) {
+      // Merge the pending queue and the base queue.
+      const baseFirst = baseQueue.next;
+      const pendingFirst = pendingQueue.next;
+      baseQueue.next = pendingFirst;
+      pendingQueue.next = baseFirst;
+    }
+
+    current.baseQueue = baseQueue = pendingQueue;
+    queue.pending = null;
+  }
+
+  if (baseQueue !== null) {
+    // We have a queue to process.
+    const first = baseQueue.next;
+    let newState = hook.baseState;
+    let newBaseState = null;
+    let newBaseQueueFirst = null;
+    let newBaseQueueLast = null;
+    let update = first;
+
+    do {
+      // An extra OffscreenLane bit is added to updates that were made to
+      // a hidden tree, so that we can distinguish them from updates that were
+      // already there when the tree was hidden.
+      const updateLane = removeLanes(update.lane, OffscreenLane);
+      const isHiddenUpdate = updateLane !== update.lane; // Check if this update was made while the tree was hidden. If so, then
+      // it's not a "base" update and we should disregard the extra base lanes
+      // that were added to renderLanes when we entered the Offscreen tree.
+
+      const shouldSkipUpdate = isHiddenUpdate ? !isSubsetOfLanes(getWorkInProgressRootRenderLanes(), updateLane) : !isSubsetOfLanes(renderLanes, updateLane);
+
+      if (shouldSkipUpdate) {
+        // Priority is insufficient. Skip this update. If this is the first
+        // skipped update, the previous update/state is the new base
+        // update/state.
+        const clone = {
+          lane: updateLane,
+          revertLane: update.revertLane,
+          action: update.action,
+          hasEagerState: update.hasEagerState,
+          eagerState: update.eagerState,
+          next: null
+        };
+
+        if (newBaseQueueLast === null) {
+          newBaseQueueFirst = newBaseQueueLast = clone;
+          newBaseState = newState;
+        } else {
+          newBaseQueueLast = newBaseQueueLast.next = clone;
+        } // Update the remaining priority in the queue.
+        // TODO: Don't need to accumulate this. Instead, we can remove
+        // renderLanes from the original lanes.
+
+
+        currentlyRenderingFiber$1.lanes = mergeLanes(currentlyRenderingFiber$1.lanes, updateLane);
+        markSkippedUpdateLanes(updateLane);
+      } else {
+        // This update does have sufficient priority.
+        // Check if this is an optimistic update.
+        const revertLane = update.revertLane;
+
+        if (revertLane === NoLane) {
+          // This is not an optimistic update, and we're going to apply it now.
+          // But, if there were earlier updates that were skipped, we need to
+          // leave this update in the queue so it can be rebased later.
+          if (newBaseQueueLast !== null) {
+            const clone = {
+              // This update is going to be committed so we never want uncommit
+              // it. Using NoLane works because 0 is a subset of all bitmasks, so
+              // this will never be skipped by the check above.
+              lane: NoLane,
+              revertLane: NoLane,
+              action: update.action,
+              hasEagerState: update.hasEagerState,
+              eagerState: update.eagerState,
+              next: null
+            };
+            newBaseQueueLast = newBaseQueueLast.next = clone;
+          }
+        } else {
+          // This is an optimistic update. If the "revert" priority is
+          // sufficient, don't apply the update. Otherwise, apply the update,
+          // but leave it in the queue so it can be either reverted or
+          // rebased in a subsequent render.
+          if (isSubsetOfLanes(renderLanes, revertLane)) {
+            // The transition that this optimistic update is associated with
+            // has finished. Pretend the update doesn't exist by skipping
+            // over it.
+            update = update.next;
+            continue;
+          } else {
+            const clone = {
+              // Once we commit an optimistic update, we shouldn't uncommit it
+              // until the transition it is associated with has finished
+              // (represented by revertLane). Using NoLane here works because 0
+              // is a subset of all bitmasks, so this will never be skipped by
+              // the check above.
+              lane: NoLane,
+              // Reuse the same revertLane so we know when the transition
+              // has finished.
+              revertLane: update.revertLane,
+              action: update.action,
+              hasEagerState: update.hasEagerState,
+              eagerState: update.eagerState,
+              next: null
+            };
+
+            if (newBaseQueueLast === null) {
+              newBaseQueueFirst = newBaseQueueLast = clone;
+              newBaseState = newState;
+            } else {
+              newBaseQueueLast = newBaseQueueLast.next = clone;
+            } // Update the remaining priority in the queue.
+            // TODO: Don't need to accumulate this. Instead, we can remove
+            // renderLanes from the original lanes.
+
+
+            currentlyRenderingFiber$1.lanes = mergeLanes(currentlyRenderingFiber$1.lanes, revertLane);
+            markSkippedUpdateLanes(revertLane);
+          }
+        } // Process this update.
+
+
+        const action = update.action;
+
+        if (shouldDoubleInvokeUserFnsInHooksDEV) {
+          reducer(newState, action);
+        }
+
+        if (update.hasEagerState) {
+          // If this update is a state update (not a reducer) and was processed eagerly,
+          // we can use the eagerly computed state
+          newState = update.eagerState;
+        } else {
+          newState = reducer(newState, action);
+        }
+      }
+
+      update = update.next;
+    } while (update !== null && update !== first);
+
+    if (newBaseQueueLast === null) {
+      newBaseState = newState;
+    } else {
+      newBaseQueueLast.next = newBaseQueueFirst;
+    } // Mark that the fiber performed work, but only if the new state is
+    // different from the current state.
+
+
+    if (!objectIs(newState, hook.memoizedState)) {
+      markWorkInProgressReceivedUpdate();
+    }
+
+    hook.memoizedState = newState;
+    hook.baseState = newBaseState;
+    hook.baseQueue = newBaseQueueLast;
+    queue.lastRenderedState = newState;
+  }
+
+  if (baseQueue === null) {
+    // `queue.lanes` is used for entangling transitions. We can set it back to
+    // zero once the queue is empty.
+    queue.lanes = NoLanes;
+  }
+
+  const dispatch = queue.dispatch;
+  return [hook.memoizedState, dispatch];
+}
+
+function rerenderReducer(reducer, initialArg, init) {
+  const hook = updateWorkInProgressHook();
+  const queue = hook.queue;
+
+  if (queue === null) {
+    throw Error(formatProdErrorMessage(311));
+  }
+
+  queue.lastRenderedReducer = reducer; // This is a re-render. Apply the new render phase updates to the previous
+  // work-in-progress hook.
+
+  const dispatch = queue.dispatch;
+  const lastRenderPhaseUpdate = queue.pending;
+  let newState = hook.memoizedState;
+
+  if (lastRenderPhaseUpdate !== null) {
+    // The queue doesn't persist past this render pass.
+    queue.pending = null;
+    const firstRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+    let update = firstRenderPhaseUpdate;
+
+    do {
+      // Process this render phase update. We don't have to check the
+      // priority because it will always be the same as the current
+      // render's.
+      const action = update.action;
+      newState = reducer(newState, action);
+      update = update.next;
+    } while (update !== firstRenderPhaseUpdate); // Mark that the fiber performed work, but only if the new state is
+    // different from the current state.
+
+
+    if (!objectIs(newState, hook.memoizedState)) {
+      markWorkInProgressReceivedUpdate();
+    }
+
+    hook.memoizedState = newState; // Don't persist the state accumulated from the render phase updates to
+    // the base state unless the queue is empty.
+    // TODO: Not sure if this is the desired semantics, but it's what we
+    // do for gDSFP. I can't remember why.
+
+    if (hook.baseQueue === null) {
+      hook.baseState = newState;
+    }
+
+    queue.lastRenderedState = newState;
+  }
+
+  return [newState, dispatch];
+}
+
+function mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  const fiber = currentlyRenderingFiber$1;
+  const hook = mountWorkInProgressHook();
+  let nextSnapshot;
+  const isHydrating = getIsHydrating();
+
+  if (isHydrating) {
+    if (getServerSnapshot === undefined) {
+      throw Error(formatProdErrorMessage(407));
+    }
+
+    nextSnapshot = getServerSnapshot();
+  } else {
+    nextSnapshot = getSnapshot();
+    // Right before committing, we will walk the tree and check if any of the
+    // stores were mutated.
+    //
+    // We won't do this if we're hydrating server-rendered content, because if
+    // the content is stale, it's already visible anyway. Instead we'll patch
+    // it up in a passive effect.
+
+
+    const root = getWorkInProgressRoot();
+
+    if (root === null) {
+      throw Error(formatProdErrorMessage(349));
+    }
+
+    const rootRenderLanes = getWorkInProgressRootRenderLanes();
+
+    if (!includesBlockingLane(root, rootRenderLanes)) {
+      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+    }
+  } // Read the current snapshot from the store on every render. This breaks the
+  // normal rules of React, and only works because store updates are
+  // always synchronous.
+
+
+  hook.memoizedState = nextSnapshot;
+  const inst = {
+    value: nextSnapshot,
+    getSnapshot
+  };
+  hook.queue = inst; // Schedule an effect to subscribe to the store.
+
+  mountEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [subscribe]); // Schedule an effect to update the mutable instance fields. We will update
+  // this whenever subscribe, getSnapshot, or value changes. Because there's no
+  // clean-up function, and we track the deps correctly, we can call pushEffect
+  // directly, without storing any additional state. For the same reason, we
+  // don't need to set a static flag, either.
+
+  fiber.flags |= Passive$1;
+  pushEffect(HasEffect | Passive, updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot), createEffectInstance(), null);
+  return nextSnapshot;
+}
+
+function updateSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  const fiber = currentlyRenderingFiber$1;
+  const hook = updateWorkInProgressHook(); // Read the current snapshot from the store on every render. This breaks the
+  // normal rules of React, and only works because store updates are
+  // always synchronous.
+
+  let nextSnapshot;
+  const isHydrating = getIsHydrating();
+
+  if (isHydrating) {
+    // Needed for strict mode double render
+    if (getServerSnapshot === undefined) {
+      throw Error(formatProdErrorMessage(407));
+    }
+
+    nextSnapshot = getServerSnapshot();
+  } else {
+    nextSnapshot = getSnapshot();
+  }
+
+  const prevSnapshot = (currentHook || hook).memoizedState;
+  const snapshotChanged = !objectIs(prevSnapshot, nextSnapshot);
+
+  if (snapshotChanged) {
+    hook.memoizedState = nextSnapshot;
+    markWorkInProgressReceivedUpdate();
+  }
+
+  const inst = hook.queue;
+  updateEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [subscribe]); // Whenever getSnapshot or subscribe changes, we need to check in the
+  // commit phase if there was an interleaved mutation. In concurrent mode
+  // this can happen all the time, but even in synchronous mode, an earlier
+  // effect may have mutated the store.
+
+  if (inst.getSnapshot !== getSnapshot || snapshotChanged || // Check if the subscribe function changed. We can save some memory by
+  // checking whether we scheduled a subscription effect above.
+  workInProgressHook !== null && workInProgressHook.memoizedState.tag & HasEffect) {
+    fiber.flags |= Passive$1;
+    pushEffect(HasEffect | Passive, updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot), createEffectInstance(), null); // Unless we're rendering a blocking lane, schedule a consistency check.
+    // Right before committing, we will walk the tree and check if any of the
+    // stores were mutated.
+
+    const root = getWorkInProgressRoot();
+
+    if (root === null) {
+      throw Error(formatProdErrorMessage(349));
+    }
+
+    if (!isHydrating && !includesBlockingLane(root, renderLanes)) {
+      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+    }
+  }
+
+  return nextSnapshot;
+}
+
+function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
+  fiber.flags |= StoreConsistency;
+  const check = {
+    getSnapshot,
+    value: renderedSnapshot
+  };
+  let componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.stores = [check];
+  } else {
+    const stores = componentUpdateQueue.stores;
+
+    if (stores === null) {
+      componentUpdateQueue.stores = [check];
+    } else {
+      stores.push(check);
+    }
+  }
+}
+
+function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
+  // These are updated in the passive phase
+  inst.value = nextSnapshot;
+  inst.getSnapshot = getSnapshot; // Something may have been mutated in between render and commit. This could
+  // have been in an event that fired before the passive effects, or it could
+  // have been in a layout effect. In that case, we would have used the old
+  // snapsho and getSnapshot values to bail out. We need to check one more time.
+
+  if (checkIfSnapshotChanged(inst)) {
+    // Force a re-render.
+    forceStoreRerender(fiber);
+  }
+}
+
+function subscribeToStore(fiber, inst, subscribe) {
+  const handleStoreChange = () => {
+    // The store changed. Check if the snapshot changed since the last time we
+    // read from the store.
+    if (checkIfSnapshotChanged(inst)) {
+      // Force a re-render.
+      forceStoreRerender(fiber);
+    }
+  }; // Subscribe to the store and return a clean-up function.
+
+
+  return subscribe(handleStoreChange);
+}
+
+function checkIfSnapshotChanged(inst) {
+  const latestGetSnapshot = inst.getSnapshot;
+  const prevValue = inst.value;
+
+  try {
+    const nextValue = latestGetSnapshot();
+    return !objectIs(prevValue, nextValue);
+  } catch (error) {
+    return true;
+  }
+}
+
+function forceStoreRerender(fiber) {
+  const root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, fiber, SyncLane);
+  }
+}
+
+function mountStateImpl(initialState) {
+  const hook = mountWorkInProgressHook();
+
+  if (typeof initialState === 'function') {
+    // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
+    initialState = initialState();
+  }
+
+  hook.memoizedState = hook.baseState = initialState;
+  const queue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    lastRenderedReducer: basicStateReducer,
+    lastRenderedState: initialState
+  };
+  hook.queue = queue;
+  return hook;
+}
+
+function mountState(initialState) {
+  const hook = mountStateImpl(initialState);
+  const queue = hook.queue;
+  const dispatch = dispatchSetState.bind(null, currentlyRenderingFiber$1, queue);
+  queue.dispatch = dispatch;
+  return [hook.memoizedState, dispatch];
+}
+
+function updateState(initialState) {
+  return updateReducer(basicStateReducer);
+}
+
+function rerenderState(initialState) {
+  return rerenderReducer(basicStateReducer);
+}
+
+function mountOptimistic(passthrough, reducer) {
+  const hook = mountWorkInProgressHook();
+  hook.memoizedState = hook.baseState = passthrough;
+  const queue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    // Optimistic state does not use the eager update optimization.
+    lastRenderedReducer: null,
+    lastRenderedState: null
+  };
+  hook.queue = queue; // This is different than the normal setState function.
+
+  const dispatch = dispatchOptimisticSetState.bind(null, currentlyRenderingFiber$1, true, queue);
+  queue.dispatch = dispatch;
+  return [passthrough, dispatch];
+}
+
+function updateOptimistic(passthrough, reducer) {
+  const hook = updateWorkInProgressHook();
+  return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
+}
+
+function updateOptimisticImpl(hook, current, passthrough, reducer) {
+  // Optimistic updates are always rebased on top of the latest value passed in
+  // as an argument. It's called a passthrough because if there are no pending
+  // updates, it will be returned as-is.
+  //
+  // Reset the base state to the passthrough. Future updates will be applied
+  // on top of this.
+  hook.baseState = passthrough; // If a reducer is not provided, default to the same one used by useState.
+
+  const resolvedReducer = typeof reducer === 'function' ? reducer : basicStateReducer;
+  return updateReducerImpl(hook, currentHook, resolvedReducer);
+}
+
+function rerenderOptimistic(passthrough, reducer) {
+  // Unlike useState, useOptimistic doesn't support render phase updates.
+  // Also unlike useState, we need to replay all pending updates again in case
+  // the passthrough value changed.
+  //
+  // So instead of a forked re-render implementation that knows how to handle
+  // render phase udpates, we can use the same implementation as during a
+  // regular mount or update.
+  const hook = updateWorkInProgressHook();
+
+  if (currentHook !== null) {
+    // This is an update. Process the update queue.
+    return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
+  } // This is a mount. No updates to process.
+  // Reset the base state to the passthrough. Future updates will be applied
+  // on top of this.
+
+
+  hook.baseState = passthrough;
+  const dispatch = hook.queue.dispatch;
+  return [passthrough, dispatch];
+} // useFormState actions run sequentially, because each action receives the
+// previous state as an argument. We store pending actions on a queue.
+
+
+function dispatchFormState(fiber, actionQueue, setState, payload) {
+  if (isRenderPhaseUpdate(fiber)) {
+    throw Error(formatProdErrorMessage(485));
+  }
+
+  const last = actionQueue.pending;
+
+  if (last === null) {
+    // There are no pending actions; this is the first one. We can run
+    // it immediately.
+    const newLast = {
+      payload,
+      next: null // circular
+
+    };
+    newLast.next = actionQueue.pending = newLast;
+    runFormStateAction(actionQueue, setState, payload);
+  } else {
+    // There's already an action running. Add to the queue.
+    const first = last.next;
+    const newLast = {
+      payload,
+      next: first
+    };
+    actionQueue.pending = last.next = newLast;
+  }
+}
+
+function runFormStateAction(actionQueue, setState, payload) {
+  const action = actionQueue.action;
+  const prevState = actionQueue.state; // This is a fork of startTransition
+
+  const prevTransition = ReactCurrentBatchConfig$3.transition;
+  ReactCurrentBatchConfig$3.transition = {};
+
+  try {
+    const returnValue = action(prevState, payload);
+
+    if (returnValue !== null && typeof returnValue === 'object' && // $FlowFixMe[method-unbinding]
+    typeof returnValue.then === 'function') {
+      const thenable = returnValue; // Attach a listener to read the return state of the action. As soon as
+      // this resolves, we can run the next action in the sequence.
+
+      thenable.then(nextState => {
+        actionQueue.state = nextState;
+        finishRunningFormStateAction(actionQueue, setState);
+      }, () => finishRunningFormStateAction(actionQueue, setState));
+      const entangledResult = requestAsyncActionContext(thenable, null);
+      setState(entangledResult);
+    } else {
+      // This is either `returnValue` or a thenable that resolves to
+      // `returnValue`, depending on whether we're inside an async action scope.
+      const entangledResult = requestSyncActionContext(returnValue, null);
+      setState(entangledResult);
+      const nextState = returnValue;
+      actionQueue.state = nextState;
+      finishRunningFormStateAction(actionQueue, setState);
+    }
+  } catch (error) {
+    // This is a trick to get the `useFormState` hook to rethrow the error.
+    // When it unwraps the thenable with the `use` algorithm, the error
+    // will be thrown.
+    const rejectedThenable = {
+      then() {},
+
+      status: 'rejected',
+      reason: error // $FlowFixMe: Not sure why this doesn't work
+
+    };
+    setState(rejectedThenable);
+    finishRunningFormStateAction(actionQueue, setState);
+  } finally {
+    ReactCurrentBatchConfig$3.transition = prevTransition;
+  }
+}
+
+function finishRunningFormStateAction(actionQueue, setState) {
+  // The action finished running. Pop it from the queue and run the next pending
+  // action, if there are any.
+  const last = actionQueue.pending;
+
+  if (last !== null) {
+    const first = last.next;
+
+    if (first === last) {
+      // This was the last action in the queue.
+      actionQueue.pending = null;
+    } else {
+      // Remove the first node from the circular queue.
+      const next = first.next;
+      last.next = next; // Run the next action.
+
+      runFormStateAction(actionQueue, setState, next.payload);
+    }
+  }
+}
+
+function formStateReducer(oldState, newState) {
+  return newState;
+}
+
+function mountFormState(action, initialStateProp, permalink) {
+  let initialState = initialStateProp;
+
+  if (getIsHydrating()) {
+    const root = getWorkInProgressRoot();
+    const ssrFormState = root.formState; // If a formState option was passed to the root, there are form state
+    // markers that we need to hydrate. These indicate whether the form state
+    // matches this hook instance.
+
+    if (ssrFormState !== null) {
+      const isMatching = tryToClaimNextHydratableFormMarkerInstance();
+
+      if (isMatching) {
+        initialState = ssrFormState[0];
+      }
+    }
+  } // State hook. The state is stored in a thenable which is then unwrapped by
+  // the `use` algorithm during render.
+
+
+  const stateHook = mountWorkInProgressHook();
+  stateHook.memoizedState = stateHook.baseState = initialState; // TODO: Typing this "correctly" results in recursion limit errors
+  // const stateQueue: UpdateQueue<S | Awaited<S>, S | Awaited<S>> = {
+
+  const stateQueue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    lastRenderedReducer: formStateReducer,
+    lastRenderedState: initialState
+  };
+  stateHook.queue = stateQueue;
+  const setState = dispatchSetState.bind(null, currentlyRenderingFiber$1, stateQueue);
+  stateQueue.dispatch = setState; // Action queue hook. This is used to queue pending actions. The queue is
+  // shared between all instances of the hook. Similar to a regular state queue,
+  // but different because the actions are run sequentially, and they run in
+  // an event instead of during render.
+
+  const actionQueueHook = mountWorkInProgressHook();
+  const actionQueue = {
+    state: initialState,
+    dispatch: null,
+    // circular
+    action,
+    pending: null
+  };
+  actionQueueHook.queue = actionQueue;
+  const dispatch = dispatchFormState.bind(null, currentlyRenderingFiber$1, actionQueue, setState);
+  actionQueue.dispatch = dispatch; // Stash the action function on the memoized state of the hook. We'll use this
+  // to detect when the action function changes so we can update it in
+  // an effect.
+
+  actionQueueHook.memoizedState = action;
+  return [initialState, dispatch];
+}
+
+function updateFormState(action, initialState, permalink) {
+  const stateHook = updateWorkInProgressHook();
+  const currentStateHook = currentHook;
+  return updateFormStateImpl(stateHook, currentStateHook, action);
+}
+
+function updateFormStateImpl(stateHook, currentStateHook, action, initialState, permalink) {
+  const _updateReducerImpl = updateReducerImpl(stateHook, currentStateHook, formStateReducer),
+        actionResult = _updateReducerImpl[0]; // This will suspend until the action finishes.
+
+
+  const state = typeof actionResult === 'object' && actionResult !== null && // $FlowFixMe[method-unbinding]
+  typeof actionResult.then === 'function' ? useThenable(actionResult) : actionResult;
+  const actionQueueHook = updateWorkInProgressHook();
+  const actionQueue = actionQueueHook.queue;
+  const dispatch = actionQueue.dispatch; // Check if a new action was passed. If so, update it in an effect.
+
+  const prevAction = actionQueueHook.memoizedState;
+
+  if (action !== prevAction) {
+    currentlyRenderingFiber$1.flags |= Passive$1;
+    pushEffect(HasEffect | Passive, formStateActionEffect.bind(null, actionQueue, action), createEffectInstance(), null);
+  }
+
+  return [state, dispatch];
+}
+
+function formStateActionEffect(actionQueue, action) {
+  actionQueue.action = action;
+}
+
+function rerenderFormState(action, initialState, permalink) {
+  // Unlike useState, useFormState doesn't support render phase updates.
+  // Also unlike useState, we need to replay all pending updates again in case
+  // the passthrough value changed.
+  //
+  // So instead of a forked re-render implementation that knows how to handle
+  // render phase udpates, we can use the same implementation as during a
+  // regular mount or update.
+  const stateHook = updateWorkInProgressHook();
+  const currentStateHook = currentHook;
+
+  if (currentStateHook !== null) {
+    // This is an update. Process the update queue.
+    return updateFormStateImpl(stateHook, currentStateHook, action);
+  } // This is a mount. No updates to process.
+
+
+  const state = stateHook.memoizedState;
+  const actionQueueHook = updateWorkInProgressHook();
+  const actionQueue = actionQueueHook.queue;
+  const dispatch = actionQueue.dispatch; // This may have changed during the rerender.
+
+  actionQueueHook.memoizedState = action;
+  return [state, dispatch];
+}
+
+function pushEffect(tag, create, inst, deps) {
+  const effect = {
+    tag,
+    create,
+    inst,
+    deps,
+    // Circular
+    next: null
+  };
+  let componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.lastEffect = effect.next = effect;
+  } else {
+    const lastEffect = componentUpdateQueue.lastEffect;
+
+    if (lastEffect === null) {
+      componentUpdateQueue.lastEffect = effect.next = effect;
+    } else {
+      const firstEffect = lastEffect.next;
+      lastEffect.next = effect;
+      effect.next = firstEffect;
+      componentUpdateQueue.lastEffect = effect;
+    }
+  }
+
+  return effect;
+}
+
+function createEffectInstance() {
+  return {
+    destroy: undefined
+  };
+}
+
+function mountRef(initialValue) {
+  const hook = mountWorkInProgressHook();
+
+  {
+    const ref = {
+      current: initialValue
+    };
+    hook.memoizedState = ref;
+    return ref;
+  }
+}
+
+function updateRef(initialValue) {
+  const hook = updateWorkInProgressHook();
+  return hook.memoizedState;
+}
+
+function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
+  const hook = mountWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(HasEffect | hookFlags, create, createEffectInstance(), nextDeps);
+}
+
+function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
+  const hook = updateWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  const effect = hook.memoizedState;
+  const inst = effect.inst; // currentHook is null on initial mount when rerendering after a render phase
+  // state update or for strict mode.
+
+  if (currentHook !== null) {
+    if (nextDeps !== null) {
+      const prevEffect = currentHook.memoizedState;
+      const prevDeps = prevEffect.deps;
+
+      if (areHookInputsEqual(nextDeps, prevDeps)) {
+        hook.memoizedState = pushEffect(hookFlags, create, inst, nextDeps);
+        return;
+      }
+    }
+  }
+
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(HasEffect | hookFlags, create, inst, nextDeps);
+}
+
+function mountEffect(create, deps) {
+  {
+    mountEffectImpl(Passive$1 | PassiveStatic, Passive, create, deps);
+  }
+}
+
+function updateEffect(create, deps) {
+  updateEffectImpl(Passive$1, Passive, create, deps);
+}
+
+function mountInsertionEffect(create, deps) {
+  mountEffectImpl(Update, Insertion, create, deps);
+}
+
+function updateInsertionEffect(create, deps) {
+  return updateEffectImpl(Update, Insertion, create, deps);
+}
+
+function mountLayoutEffect(create, deps) {
+  let fiberFlags = Update | LayoutStatic;
+
+  return mountEffectImpl(fiberFlags, Layout, create, deps);
+}
+
+function updateLayoutEffect(create, deps) {
+  return updateEffectImpl(Update, Layout, create, deps);
+}
+
+function imperativeHandleEffect(create, ref) {
+  if (typeof ref === 'function') {
+    const refCallback = ref;
+    const inst = create();
+    refCallback(inst);
+    return () => {
+      refCallback(null);
+    };
+  } else if (ref !== null && ref !== undefined) {
+    const refObject = ref;
+
+    const inst = create();
+    refObject.current = inst;
+    return () => {
+      refObject.current = null;
+    };
+  }
+}
+
+function mountImperativeHandle(ref, create, deps) {
+
+
+  const effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+  let fiberFlags = Update | LayoutStatic;
+
+  mountEffectImpl(fiberFlags, Layout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
+}
+
+function updateImperativeHandle(ref, create, deps) {
+
+
+  const effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+  updateEffectImpl(Update, Layout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
+}
+
+function mountDebugValue(value, formatterFn) {// This hook is normally a no-op.
+  // The react-debug-hooks package injects its own implementation
+  // so that e.g. DevTools can display custom hook values.
+}
+
+const updateDebugValue = mountDebugValue;
+
+function mountCallback(callback, deps) {
+  const hook = mountWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  hook.memoizedState = [callback, nextDeps];
+  return callback;
+}
+
+function updateCallback(callback, deps) {
+  const hook = updateWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  const prevState = hook.memoizedState;
+
+  if (nextDeps !== null) {
+    const prevDeps = prevState[1];
+
+    if (areHookInputsEqual(nextDeps, prevDeps)) {
+      return prevState[0];
+    }
+  }
+
+  hook.memoizedState = [callback, nextDeps];
+  return callback;
+}
+
+function mountMemo(nextCreate, deps) {
+  const hook = mountWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+
+  if (shouldDoubleInvokeUserFnsInHooksDEV) {
+    nextCreate();
+  }
+
+  const nextValue = nextCreate();
+  hook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
+
+function updateMemo(nextCreate, deps) {
+  const hook = updateWorkInProgressHook();
+  const nextDeps = deps === undefined ? null : deps;
+  const prevState = hook.memoizedState; // Assume these are defined. If they're not, areHookInputsEqual will warn.
+
+  if (nextDeps !== null) {
+    const prevDeps = prevState[1];
+
+    if (areHookInputsEqual(nextDeps, prevDeps)) {
+      return prevState[0];
+    }
+  }
+
+  if (shouldDoubleInvokeUserFnsInHooksDEV) {
+    nextCreate();
+  }
+
+  const nextValue = nextCreate();
+  hook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
+
+function mountDeferredValue(value, initialValue) {
+  const hook = mountWorkInProgressHook();
+  return mountDeferredValueImpl(hook, value);
+}
+
+function updateDeferredValue(value, initialValue) {
+  const hook = updateWorkInProgressHook();
+  const resolvedCurrentHook = currentHook;
+  const prevValue = resolvedCurrentHook.memoizedState;
+  return updateDeferredValueImpl(hook, prevValue, value);
+}
+
+function rerenderDeferredValue(value, initialValue) {
+  const hook = updateWorkInProgressHook();
+
+  if (currentHook === null) {
+    // This is a rerender during a mount.
+    return mountDeferredValueImpl(hook, value);
+  } else {
+    // This is a rerender during an update.
+    const prevValue = currentHook.memoizedState;
+    return updateDeferredValueImpl(hook, prevValue, value);
+  }
+}
+
+function mountDeferredValueImpl(hook, value, initialValue) {
+  {
+    hook.memoizedState = value;
+    return value;
+  }
+}
+
+function updateDeferredValueImpl(hook, prevValue, value, initialValue) {
+  if (objectIs(value, prevValue)) {
+    // The incoming value is referentially identical to the currently rendered
+    // value, so we can bail out quickly.
+    return value;
+  } else {
+    // Received a new value that's different from the current value.
+    // Check if we're inside a hidden tree
+    if (isCurrentTreeHidden()) {
+      // Revealing a prerendered tree is considered the same as mounting new
+      // one, so we reuse the "mount" path in this case.
+      const resultValue = mountDeferredValueImpl(hook, value); // Unlike during an actual mount, we need to mark this as an update if
+      // the value changed.
+
+      if (!objectIs(resultValue, prevValue)) {
+        markWorkInProgressReceivedUpdate();
+      }
+
+      return resultValue;
+    }
+
+    const shouldDeferValue = !includesOnlyNonUrgentLanes(renderLanes);
+
+    if (shouldDeferValue) {
+      // This is an urgent update. Since the value has changed, keep using the
+      // previous value and spawn a deferred render to update it later.
+      // Schedule a deferred render
+      const deferredLane = requestDeferredLane();
+      currentlyRenderingFiber$1.lanes = mergeLanes(currentlyRenderingFiber$1.lanes, deferredLane);
+      markSkippedUpdateLanes(deferredLane); // Reuse the previous value. We do not need to mark this as an update,
+      // because we did not render a new value.
+
+      return prevValue;
+    } else {
+      // This is not an urgent update, so we can use the latest value regardless
+      // of what it is. No need to defer it.
+      // Mark this as an update to prevent the fiber from bailing out.
+      markWorkInProgressReceivedUpdate();
+      hook.memoizedState = value;
+      return value;
+    }
+  }
+}
+
+function startTransition(fiber, queue, pendingState, finishedState, callback, options) {
+  const previousPriority = getCurrentUpdatePriority();
+  setCurrentUpdatePriority(higherEventPriority(previousPriority, ContinuousEventPriority));
+  const prevTransition = ReactCurrentBatchConfig$3.transition;
+  const currentTransition = {};
+
+  {
+    // We don't really need to use an optimistic update here, because we
+    // schedule a second "revert" update below (which we use to suspend the
+    // transition until the async action scope has finished). But we'll use an
+    // optimistic update anyway to make it less likely the behavior accidentally
+    // diverges; for example, both an optimistic update and this one should
+    // share the same lane.
+    ReactCurrentBatchConfig$3.transition = currentTransition;
+    dispatchOptimisticSetState(fiber, false, queue, pendingState);
+  }
+
+  try {
+    if (enableAsyncActions) {
+      const returnValue = callback(); // Check if we're inside an async action scope. If so, we'll entangle
+      // this new action with the existing scope.
+      //
+      // If we're not already inside an async action scope, and this action is
+      // async, then we'll create a new async scope.
+      //
+      // In the async case, the resulting render will suspend until the async
+      // action scope has finished.
+
+      if (returnValue !== null && typeof returnValue === 'object' && typeof returnValue.then === 'function') {
+        const thenable = returnValue; // This is a thenable that resolves to `finishedState` once the async
+        // action scope has finished.
+
+        const entangledResult = requestAsyncActionContext(thenable, finishedState);
+        dispatchSetState(fiber, queue, entangledResult);
+      } else {
+        // This is either `finishedState` or a thenable that resolves to
+        // `finishedState`, depending on whether we're inside an async
+        // action scope.
+        const entangledResult = requestSyncActionContext(returnValue, finishedState);
+        dispatchSetState(fiber, queue, entangledResult);
+      }
+    }
+  } catch (error) {
+    {
+      // This is a trick to get the `useTransition` hook to rethrow the error.
+      // When it unwraps the thenable with the `use` algorithm, the error
+      // will be thrown.
+      const rejectedThenable = {
+        then() {},
+
+        status: 'rejected',
+        reason: error
+      };
+      dispatchSetState(fiber, queue, rejectedThenable);
+    }
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$3.transition = prevTransition;
+  }
+}
+
+function startHostTransition(formFiber, pendingState, callback, formData) {
+
+  if (formFiber.tag !== HostComponent) {
+    throw Error(formatProdErrorMessage(476));
+  }
+
+  let queue;
+
+  if (formFiber.memoizedState === null) {
+    // Upgrade this host component fiber to be stateful. We're going to pretend
+    // it was stateful all along so we can reuse most of the implementation
+    // for function components and useTransition.
+    //
+    // Create the state hook used by TransitionAwareHostComponent. This is
+    // essentially an inlined version of mountState.
+    const newQueue = {
+      pending: null,
+      lanes: NoLanes,
+      // We're going to cheat and intentionally not create a bound dispatch
+      // method, because we can call it directly in startTransition.
+      dispatch: null,
+      lastRenderedReducer: basicStateReducer,
+      lastRenderedState: NotPendingTransition
+    };
+    queue = newQueue;
+    const stateHook = {
+      memoizedState: NotPendingTransition,
+      baseState: NotPendingTransition,
+      baseQueue: null,
+      queue: newQueue,
+      next: null
+    }; // Add the state hook to both fiber alternates. The idea is that the fiber
+    // had this hook all along.
+
+    formFiber.memoizedState = stateHook;
+    const alternate = formFiber.alternate;
+
+    if (alternate !== null) {
+      alternate.memoizedState = stateHook;
+    }
+  } else {
+    // This fiber was already upgraded to be stateful.
+    const stateHook = formFiber.memoizedState;
+    queue = stateHook.queue;
+  }
+
+  startTransition(formFiber, queue, pendingState, NotPendingTransition, // TODO: We can avoid this extra wrapper, somehow. Figure out layering
+  // once more of this function is implemented.
+  () => callback(formData));
+}
+
+function mountTransition() {
+  const stateHook = mountStateImpl(false); // The `start` method never changes.
+
+  const start = startTransition.bind(null, currentlyRenderingFiber$1, stateHook.queue, true, false);
+  const hook = mountWorkInProgressHook();
+  hook.memoizedState = start;
+  return [false, start];
+}
+
+function updateTransition() {
+  const _updateState = updateState(),
+        booleanOrThenable = _updateState[0];
+
+  const hook = updateWorkInProgressHook();
+  const start = hook.memoizedState;
+  const isPending = typeof booleanOrThenable === 'boolean' ? booleanOrThenable : // This will suspend until the async action scope has finished.
+  useThenable(booleanOrThenable);
+  return [isPending, start];
+}
+
+function rerenderTransition() {
+  const _rerenderState = rerenderState(),
+        booleanOrThenable = _rerenderState[0];
+
+  const hook = updateWorkInProgressHook();
+  const start = hook.memoizedState;
+  const isPending = typeof booleanOrThenable === 'boolean' ? booleanOrThenable : // This will suspend until the async action scope has finished.
+  useThenable(booleanOrThenable);
+  return [isPending, start];
+}
+
+function useHostTransitionStatus() {
+
+  const status = readContext(HostTransitionContext);
+  return status !== null ? status : NotPendingTransition;
+}
+
+function mountId() {
+  const hook = mountWorkInProgressHook();
+  const root = getWorkInProgressRoot(); // TODO: In Fizz, id generation is specific to each server config. Maybe we
+  // should do this in Fiber, too? Deferring this decision for now because
+  // there's no other place to store the prefix except for an internal field on
+  // the public createRoot object, which the fiber tree does not currently have
+  // a reference to.
+
+  const identifierPrefix = root.identifierPrefix;
+  let id;
+
+  if (getIsHydrating()) {
+    const treeId = getTreeId(); // Use a captial R prefix for server-generated ids.
+
+    id = ':' + identifierPrefix + 'R' + treeId; // Unless this is the first id at this level, append a number at the end
+    // that represents the position of this useId hook among all the useId
+    // hooks for this fiber.
+
+    const localId = localIdCounter++;
+
+    if (localId > 0) {
+      id += 'H' + localId.toString(32);
+    }
+
+    id += ':';
+  } else {
+    // Use a lowercase r prefix for client-generated ids.
+    const globalClientId = globalClientIdCounter++;
+    id = ':' + identifierPrefix + 'r' + globalClientId.toString(32) + ':';
+  }
+
+  hook.memoizedState = id;
+  return id;
+}
+
+function updateId() {
+  const hook = updateWorkInProgressHook();
+  const id = hook.memoizedState;
+  return id;
+}
+
+function mountRefresh() {
+  const hook = mountWorkInProgressHook();
+  const refresh = hook.memoizedState = refreshCache.bind(null, currentlyRenderingFiber$1);
+  return refresh;
+}
+
+function updateRefresh() {
+  const hook = updateWorkInProgressHook();
+  return hook.memoizedState;
+}
+
+function refreshCache(fiber, seedKey, seedValue) {
+  // TODO: Consider warning if the refresh is at discrete priority, or if we
+  // otherwise suspect that it wasn't batched properly.
+
+
+  let provider = fiber.return;
+
+  while (provider !== null) {
+    switch (provider.tag) {
+      case CacheComponent:
+      case HostRoot:
+        {
+          // Schedule an update on the cache boundary to trigger a refresh.
+          const lane = requestUpdateLane(provider);
+          const refreshUpdate = createUpdate(lane);
+          const root = enqueueUpdate(provider, refreshUpdate, lane);
+
+          if (root !== null) {
+            scheduleUpdateOnFiber(root, provider, lane);
+            entangleTransitions(root, provider, lane);
+          } // TODO: If a refresh never commits, the new cache created here must be
+          // released. A simple case is start refreshing a cache boundary, but then
+          // unmount that boundary before the refresh completes.
+
+
+          const seededCache = createCache();
+
+          const payload = {
+            cache: seededCache
+          };
+          refreshUpdate.payload = payload;
+          return;
+        }
+    }
+
+    provider = provider.return;
+  } // TODO: Warn if unmounted?
+
+}
+
+function dispatchReducerAction(fiber, queue, action) {
+
+  const lane = requestUpdateLane(fiber);
+  const update = {
+    lane,
+    revertLane: NoLane,
+    action,
+    hasEagerState: false,
+    eagerState: null,
+    next: null
+  };
+
+  if (isRenderPhaseUpdate(fiber)) {
+    enqueueRenderPhaseUpdate(queue, update);
+  } else {
+    const root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitionUpdate(root, queue, lane);
+    }
+  }
+
+  markUpdateInDevTools(fiber, lane);
+}
+
+function dispatchSetState(fiber, queue, action) {
+
+  const lane = requestUpdateLane(fiber);
+  const update = {
+    lane,
+    revertLane: NoLane,
+    action,
+    hasEagerState: false,
+    eagerState: null,
+    next: null
+  };
+
+  if (isRenderPhaseUpdate(fiber)) {
+    enqueueRenderPhaseUpdate(queue, update);
+  } else {
+    const alternate = fiber.alternate;
+
+    if (fiber.lanes === NoLanes && (alternate === null || alternate.lanes === NoLanes)) {
+      // The queue is currently empty, which means we can eagerly compute the
+      // next state before entering the render phase. If the new state is the
+      // same as the current state, we may be able to bail out entirely.
+      const lastRenderedReducer = queue.lastRenderedReducer;
+
+      if (lastRenderedReducer !== null) {
+
+        try {
+          const currentState = queue.lastRenderedState;
+          const eagerState = lastRenderedReducer(currentState, action); // Stash the eagerly computed state, and the reducer used to compute
+          // it, on the update object. If the reducer hasn't changed by the
+          // time we enter the render phase, then the eager state can be used
+          // without calling the reducer again.
+
+          update.hasEagerState = true;
+          update.eagerState = eagerState;
+
+          if (objectIs(eagerState, currentState)) {
+            // Fast path. We can bail out without scheduling React to re-render.
+            // It's still possible that we'll need to rebase this update later,
+            // if the component re-renders for a different reason and by that
+            // time the reducer has changed.
+            // TODO: Do we still need to entangle transitions in this case?
+            enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update);
+            return;
+          }
+        } catch (error) {// Suppress the error. It will throw again in the render phase.
+        } finally {
+        }
+      }
+    }
+
+    const root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitionUpdate(root, queue, lane);
+    }
+  }
+
+  markUpdateInDevTools(fiber, lane);
+}
+
+function dispatchOptimisticSetState(fiber, throwIfDuringRender, queue, action) {
+
+  const update = {
+    // An optimistic update commits synchronously.
+    lane: SyncLane,
+    // After committing, the optimistic update is "reverted" using the same
+    // lane as the transition it's associated with.
+    revertLane: requestTransitionLane(),
+    action,
+    hasEagerState: false,
+    eagerState: null,
+    next: null
+  };
+
+  if (isRenderPhaseUpdate(fiber)) {
+    // When calling startTransition during render, this warns instead of
+    // throwing because throwing would be a breaking change. setOptimisticState
+    // is a new API so it's OK to throw.
+    if (throwIfDuringRender) {
+      throw Error(formatProdErrorMessage(479));
+    }
+  } else {
+    const root = enqueueConcurrentHookUpdate(fiber, queue, update, SyncLane);
+
+    if (root !== null) {
+      // NOTE: The optimistic update implementation assumes that the transition
+      // will never be attempted before the optimistic update. This currently
+      // holds because the optimistic update is always synchronous. If we ever
+      // change that, we'll need to account for this.
+      scheduleUpdateOnFiber(root, fiber, SyncLane); // Optimistic updates are always synchronous, so we don't need to call
+      // entangleTransitionUpdate here.
+    }
+  }
+
+  markUpdateInDevTools(fiber, SyncLane);
+}
+
+function isRenderPhaseUpdate(fiber) {
+  const alternate = fiber.alternate;
+  return fiber === currentlyRenderingFiber$1 || alternate !== null && alternate === currentlyRenderingFiber$1;
+}
+
+function enqueueRenderPhaseUpdate(queue, update) {
+  // This is a render phase update. Stash it in a lazily-created map of
+  // queue -> linked list of updates. After this render pass, we'll restart
+  // and apply the stashed updates on top of the work-in-progress hook.
+  didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate = true;
+  const pending = queue.pending;
+
+  if (pending === null) {
+    // This is the first update. Create a circular list.
+    update.next = update;
+  } else {
+    update.next = pending.next;
+    pending.next = update;
+  }
+
+  queue.pending = update;
+} // TODO: Move to ReactFiberConcurrentUpdates?
+
+
+function entangleTransitionUpdate(root, queue, lane) {
+  if (isTransitionLane(lane)) {
+    let queueLanes = queue.lanes; // If any entangled lanes are no longer pending on the root, then they
+    // must have finished. We can remove them from the shared queue, which
+    // represents a superset of the actually pending lanes. In some cases we
+    // may entangle more than we need to, but that's OK. In fact it's worse if
+    // we *don't* entangle when we should.
+
+    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.
+
+    const newQueueLanes = mergeLanes(queueLanes, lane);
+    queue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if
+    // the lane finished since the last time we entangled it. So we need to
+    // entangle it again, just to be sure.
+
+    markRootEntangled(root, newQueueLanes);
+  }
+}
+
+function markUpdateInDevTools(fiber, lane, action) {
+
+  {
+    markStateUpdateScheduled(fiber, lane);
+  }
+}
+
+const ContextOnlyDispatcher = {
+  readContext,
+  use,
+  useCallback: throwInvalidHookError,
+  useContext: throwInvalidHookError,
+  useEffect: throwInvalidHookError,
+  useImperativeHandle: throwInvalidHookError,
+  useInsertionEffect: throwInvalidHookError,
+  useLayoutEffect: throwInvalidHookError,
+  useMemo: throwInvalidHookError,
+  useReducer: throwInvalidHookError,
+  useRef: throwInvalidHookError,
+  useState: throwInvalidHookError,
+  useDebugValue: throwInvalidHookError,
+  useDeferredValue: throwInvalidHookError,
+  useTransition: throwInvalidHookError,
+  useSyncExternalStore: throwInvalidHookError,
+  useId: throwInvalidHookError
+};
+
+{
+  ContextOnlyDispatcher.useCacheRefresh = throwInvalidHookError;
+}
+
+{
+  ContextOnlyDispatcher.useHostTransitionStatus = throwInvalidHookError;
+  ContextOnlyDispatcher.useFormState = throwInvalidHookError;
+}
+
+{
+  ContextOnlyDispatcher.useOptimistic = throwInvalidHookError;
+}
+
+const HooksDispatcherOnMount = {
+  readContext,
+  use,
+  useCallback: mountCallback,
+  useContext: readContext,
+  useEffect: mountEffect,
+  useImperativeHandle: mountImperativeHandle,
+  useLayoutEffect: mountLayoutEffect,
+  useInsertionEffect: mountInsertionEffect,
+  useMemo: mountMemo,
+  useReducer: mountReducer,
+  useRef: mountRef,
+  useState: mountState,
+  useDebugValue: mountDebugValue,
+  useDeferredValue: mountDeferredValue,
+  useTransition: mountTransition,
+  useSyncExternalStore: mountSyncExternalStore,
+  useId: mountId
+};
+
+{
+  HooksDispatcherOnMount.useCacheRefresh = mountRefresh;
+}
+
+{
+  HooksDispatcherOnMount.useHostTransitionStatus = useHostTransitionStatus;
+  HooksDispatcherOnMount.useFormState = mountFormState;
+}
+
+{
+  HooksDispatcherOnMount.useOptimistic = mountOptimistic;
+}
+
+const HooksDispatcherOnUpdate = {
+  readContext,
+  use,
+  useCallback: updateCallback,
+  useContext: readContext,
+  useEffect: updateEffect,
+  useImperativeHandle: updateImperativeHandle,
+  useInsertionEffect: updateInsertionEffect,
+  useLayoutEffect: updateLayoutEffect,
+  useMemo: updateMemo,
+  useReducer: updateReducer,
+  useRef: updateRef,
+  useState: updateState,
+  useDebugValue: updateDebugValue,
+  useDeferredValue: updateDeferredValue,
+  useTransition: updateTransition,
+  useSyncExternalStore: updateSyncExternalStore,
+  useId: updateId
+};
+
+{
+  HooksDispatcherOnUpdate.useCacheRefresh = updateRefresh;
+}
+
+{
+  HooksDispatcherOnUpdate.useHostTransitionStatus = useHostTransitionStatus;
+  HooksDispatcherOnUpdate.useFormState = updateFormState;
+}
+
+{
+  HooksDispatcherOnUpdate.useOptimistic = updateOptimistic;
+}
+
+const HooksDispatcherOnRerender = {
+  readContext,
+  use,
+  useCallback: updateCallback,
+  useContext: readContext,
+  useEffect: updateEffect,
+  useImperativeHandle: updateImperativeHandle,
+  useInsertionEffect: updateInsertionEffect,
+  useLayoutEffect: updateLayoutEffect,
+  useMemo: updateMemo,
+  useReducer: rerenderReducer,
+  useRef: updateRef,
+  useState: rerenderState,
+  useDebugValue: updateDebugValue,
+  useDeferredValue: rerenderDeferredValue,
+  useTransition: rerenderTransition,
+  useSyncExternalStore: updateSyncExternalStore,
+  useId: updateId
+};
+
+{
+  HooksDispatcherOnRerender.useCacheRefresh = updateRefresh;
+}
+
+{
+  HooksDispatcherOnRerender.useHostTransitionStatus = useHostTransitionStatus;
+  HooksDispatcherOnRerender.useFormState = rerenderFormState;
+}
+
+{
+  HooksDispatcherOnRerender.useOptimistic = rerenderOptimistic;
+}
+
+const now = Scheduler.unstable_now;
+let commitTime = 0;
+let layoutEffectStartTime = -1;
+let profilerStartTime = -1;
+let 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.
+ */
+
+let currentUpdateIsNested = false;
+let nestedUpdateScheduled = false;
+
+function isCurrentUpdateNested() {
+  return currentUpdateIsNested;
+}
+
+function markNestedUpdateScheduled() {
+  {
+    nestedUpdateScheduled = true;
+  }
+}
+
+function resetNestedUpdateFlag() {
+  {
+    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) {
+    const elapsedTime = now() - profilerStartTime;
+    fiber.actualDuration += elapsedTime;
+
+    if (overrideBaseTime) {
+      fiber.selfBaseDuration = elapsedTime;
+    }
+
+    profilerStartTime = -1;
+  }
+}
+
+function recordLayoutEffectDuration(fiber) {
+
+  if (layoutEffectStartTime >= 0) {
+    const elapsedTime = now() - layoutEffectStartTime;
+    layoutEffectStartTime = -1; // Store duration on the next nearest Profiler ancestor
+    // Or the root (for the DevTools Profiler to read)
+
+    let parentFiber = fiber.return;
+
+    while (parentFiber !== null) {
+      switch (parentFiber.tag) {
+        case HostRoot:
+          const root = parentFiber.stateNode;
+          root.effectDuration += elapsedTime;
+          return;
+
+        case Profiler:
+          const parentStateNode = parentFiber.stateNode;
+          parentStateNode.effectDuration += elapsedTime;
+          return;
+      }
+
+      parentFiber = parentFiber.return;
+    }
+  }
+}
+
+function recordPassiveEffectDuration(fiber) {
+
+  if (passiveEffectStartTime >= 0) {
+    const elapsedTime = now() - passiveEffectStartTime;
+    passiveEffectStartTime = -1; // Store duration on the next nearest Profiler ancestor
+    // Or the root (for the DevTools Profiler to read)
+
+    let parentFiber = fiber.return;
+
+    while (parentFiber !== null) {
+      switch (parentFiber.tag) {
+        case HostRoot:
+          const root = parentFiber.stateNode;
+
+          if (root !== null) {
+            root.passiveEffectDuration += elapsedTime;
+          }
+
+          return;
+
+        case Profiler:
+          const 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.
+  let child = fiber.child;
+
+  while (child) {
+    // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+    fiber.actualDuration += child.actualDuration;
+    child = child.sibling;
+  }
+}
+
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    // Resolve default props. Taken from ReactElement
+    const props = assign({}, baseProps);
+    const defaultProps = Component.defaultProps;
+
+    for (const propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+
+    return props;
+  }
+
+  return baseProps;
+}
+
+function applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, nextProps) {
+  const prevState = workInProgress.memoizedState;
+  let partialState = getDerivedStateFromProps(nextProps, prevState);
+
+
+  const memoizedState = partialState === null || partialState === undefined ? prevState : assign({}, prevState, partialState);
+  workInProgress.memoizedState = memoizedState; // Once the update queue is empty, persist the derived state onto the
+  // base state.
+
+  if (workInProgress.lanes === NoLanes) {
+    // Queue is always non-null for classes
+    const updateQueue = workInProgress.updateQueue;
+    updateQueue.baseState = memoizedState;
+  }
+}
+
+const classComponentUpdater = {
+  isMounted,
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueSetState(inst, payload, callback) {
+    const fiber = get(inst);
+    const lane = requestUpdateLane(fiber);
+    const update = createUpdate(lane);
+    update.payload = payload;
+
+    if (callback !== undefined && callback !== null) {
+
+      update.callback = callback;
+    }
+
+    const root = enqueueUpdate(fiber, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitions(root, fiber, lane);
+    }
+
+    {
+      markStateUpdateScheduled(fiber, lane);
+    }
+  },
+
+  enqueueReplaceState(inst, payload, callback) {
+    const fiber = get(inst);
+    const lane = requestUpdateLane(fiber);
+    const update = createUpdate(lane);
+    update.tag = ReplaceState;
+    update.payload = payload;
+
+    if (callback !== undefined && callback !== null) {
+
+      update.callback = callback;
+    }
+
+    const root = enqueueUpdate(fiber, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitions(root, fiber, lane);
+    }
+
+    {
+      markStateUpdateScheduled(fiber, lane);
+    }
+  },
+
+  // $FlowFixMe[missing-local-annot]
+  enqueueForceUpdate(inst, callback) {
+    const fiber = get(inst);
+    const lane = requestUpdateLane(fiber);
+    const update = createUpdate(lane);
+    update.tag = ForceUpdate;
+
+    if (callback !== undefined && callback !== null) {
+
+      update.callback = callback;
+    }
+
+    const root = enqueueUpdate(fiber, update, lane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, lane);
+      entangleTransitions(root, fiber, lane);
+    }
+
+    {
+      markForceUpdateScheduled(fiber, lane);
+    }
+  }
+
+};
+
+function checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {
+  const instance = workInProgress.stateNode;
+
+  if (typeof instance.shouldComponentUpdate === 'function') {
+    let shouldUpdate = instance.shouldComponentUpdate(newProps, newState, nextContext);
+
+    return shouldUpdate;
+  }
+
+  if (ctor.prototype && ctor.prototype.isPureReactComponent) {
+    return !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState);
+  }
+
+  return true;
+}
+
+function adoptClassInstance(workInProgress, instance) {
+  instance.updater = classComponentUpdater;
+  workInProgress.stateNode = instance; // The instance needs access to the fiber so that it can schedule updates
+
+  set(instance, workInProgress);
+}
+
+function constructClassInstance(workInProgress, ctor, props) {
+  let isLegacyContextConsumer = false;
+  let unmaskedContext = emptyContextObject;
+  let context = emptyContextObject;
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    context = readContext(contextType);
+  } else {
+    unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    const contextTypes = ctor.contextTypes;
+    isLegacyContextConsumer = contextTypes !== null && contextTypes !== undefined;
+    context = isLegacyContextConsumer ? getMaskedContext(workInProgress, unmaskedContext) : emptyContextObject;
+  }
+
+  let instance = new ctor(props, context); // Instantiate twice to help detect side-effects.
+
+  workInProgress.memoizedState = instance.state !== null && instance.state !== undefined ? instance.state : null;
+  adoptClassInstance(workInProgress, instance);
+  // ReactFiberContext usually updates this cache but can't for newly-created instances.
+
+
+  if (isLegacyContextConsumer) {
+    cacheContext(workInProgress, unmaskedContext, context);
+  }
+
+  return instance;
+}
+
+function callComponentWillMount(workInProgress, instance) {
+  const oldState = instance.state;
+
+  if (typeof instance.componentWillMount === 'function') {
+    instance.componentWillMount();
+  }
+
+  if (typeof instance.UNSAFE_componentWillMount === 'function') {
+    instance.UNSAFE_componentWillMount();
+  }
+
+  if (oldState !== instance.state) {
+
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+}
+
+function callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {
+  const oldState = instance.state;
+
+  if (typeof instance.componentWillReceiveProps === 'function') {
+    instance.componentWillReceiveProps(newProps, nextContext);
+  }
+
+  if (typeof instance.UNSAFE_componentWillReceiveProps === 'function') {
+    instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+  }
+
+  if (instance.state !== oldState) {
+
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+} // Invokes the mount life-cycles on a previously never rendered instance.
+
+
+function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+
+  const instance = workInProgress.stateNode;
+  instance.props = newProps;
+  instance.state = workInProgress.memoizedState;
+  instance.refs = {};
+  initializeUpdateQueue(workInProgress);
+  const contextType = ctor.contextType;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    instance.context = readContext(contextType);
+  } else {
+    const unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    instance.context = getMaskedContext(workInProgress, unmaskedContext);
+  }
+
+  instance.state = workInProgress.memoizedState;
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+    instance.state = workInProgress.memoizedState;
+  } // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+
+  if (typeof ctor.getDerivedStateFromProps !== 'function' && typeof instance.getSnapshotBeforeUpdate !== 'function' && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
+    callComponentWillMount(workInProgress, instance); // If we had additional state updates during this life-cycle, let's
+    // process them now.
+
+    processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+    instance.state = workInProgress.memoizedState;
+  }
+
+  if (typeof instance.componentDidMount === 'function') {
+    workInProgress.flags |= Update | LayoutStatic;
+  }
+}
+
+function resumeMountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+  const instance = workInProgress.stateNode;
+  const oldProps = workInProgress.memoizedProps;
+  instance.props = oldProps;
+  const oldContext = instance.context;
+  const contextType = ctor.contextType;
+  let nextContext = emptyContextObject;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    nextContext = readContext(contextType);
+  } else {
+    const nextLegacyUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    nextContext = getMaskedContext(workInProgress, nextLegacyUnmaskedContext);
+  }
+
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+  const hasNewLifecycles = typeof getDerivedStateFromProps === 'function' || typeof instance.getSnapshotBeforeUpdate === 'function'; // Note: During these life-cycles, instance.props/instance.state are what
+  // ever the previously attempted to render - not the "current". However,
+  // during componentDidUpdate we pass the "current" props.
+  // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+  if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === 'function' || typeof instance.componentWillReceiveProps === 'function')) {
+    if (oldProps !== newProps || oldContext !== nextContext) {
+      callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
+    }
+  }
+
+  resetHasForceUpdateBeforeProcessing();
+  const oldState = workInProgress.memoizedState;
+  let newState = instance.state = oldState;
+  processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+  newState = workInProgress.memoizedState;
+
+  if (oldProps === newProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing()) {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidMount === 'function') {
+      workInProgress.flags |= Update | LayoutStatic;
+    }
+
+    return false;
+  }
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+    newState = workInProgress.memoizedState;
+  }
+
+  const shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext);
+
+  if (shouldUpdate) {
+    // In order to support react-lifecycles-compat polyfilled components,
+    // Unsafe lifecycles should not be invoked for components using the new APIs.
+    if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
+      if (typeof instance.componentWillMount === 'function') {
+        instance.componentWillMount();
+      }
+
+      if (typeof instance.UNSAFE_componentWillMount === 'function') {
+        instance.UNSAFE_componentWillMount();
+      }
+    }
+
+    if (typeof instance.componentDidMount === 'function') {
+      workInProgress.flags |= Update | LayoutStatic;
+    }
+  } else {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidMount === 'function') {
+      workInProgress.flags |= Update | LayoutStatic;
+    }
+    // memoized state to indicate that this work can be reused.
+
+
+    workInProgress.memoizedProps = newProps;
+    workInProgress.memoizedState = newState;
+  } // Update the existing instance's state, props, and context pointers even
+  // if shouldComponentUpdate returns false.
+
+
+  instance.props = newProps;
+  instance.state = newState;
+  instance.context = nextContext;
+  return shouldUpdate;
+} // Invokes the update life-cycles and returns false if it shouldn't rerender.
+
+
+function updateClassInstance(current, workInProgress, ctor, newProps, renderLanes) {
+  const instance = workInProgress.stateNode;
+  cloneUpdateQueue(current, workInProgress);
+  const unresolvedOldProps = workInProgress.memoizedProps;
+  const oldProps = workInProgress.type === workInProgress.elementType ? unresolvedOldProps : resolveDefaultProps(workInProgress.type, unresolvedOldProps);
+  instance.props = oldProps;
+  const unresolvedNewProps = workInProgress.pendingProps;
+  const oldContext = instance.context;
+  const contextType = ctor.contextType;
+  let nextContext = emptyContextObject;
+
+  if (typeof contextType === 'object' && contextType !== null) {
+    nextContext = readContext(contextType);
+  } else {
+    const nextUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    nextContext = getMaskedContext(workInProgress, nextUnmaskedContext);
+  }
+
+  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+  const hasNewLifecycles = typeof getDerivedStateFromProps === 'function' || typeof instance.getSnapshotBeforeUpdate === 'function'; // Note: During these life-cycles, instance.props/instance.state are what
+  // ever the previously attempted to render - not the "current". However,
+  // during componentDidUpdate we pass the "current" props.
+  // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+  if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === 'function' || typeof instance.componentWillReceiveProps === 'function')) {
+    if (unresolvedOldProps !== unresolvedNewProps || oldContext !== nextContext) {
+      callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
+    }
+  }
+
+  resetHasForceUpdateBeforeProcessing();
+  const oldState = workInProgress.memoizedState;
+  let newState = instance.state = oldState;
+  processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+  newState = workInProgress.memoizedState;
+
+  if (unresolvedOldProps === unresolvedNewProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing() && !(enableLazyContextPropagation   )) {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidUpdate === 'function') {
+      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+        workInProgress.flags |= Update;
+      }
+    }
+
+    if (typeof instance.getSnapshotBeforeUpdate === 'function') {
+      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+        workInProgress.flags |= Snapshot;
+      }
+    }
+
+    return false;
+  }
+
+  if (typeof getDerivedStateFromProps === 'function') {
+    applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+    newState = workInProgress.memoizedState;
+  }
+
+  const shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) || // TODO: In some cases, we'll end up checking if context has changed twice,
+  // both before and after `shouldComponentUpdate` has been called. Not ideal,
+  // but I'm loath to refactor this function. This only happens for memoized
+  // components so it's not that common.
+  enableLazyContextPropagation   ;
+
+  if (shouldUpdate) {
+    // In order to support react-lifecycles-compat polyfilled components,
+    // Unsafe lifecycles should not be invoked for components using the new APIs.
+    if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillUpdate === 'function' || typeof instance.componentWillUpdate === 'function')) {
+      if (typeof instance.componentWillUpdate === 'function') {
+        instance.componentWillUpdate(newProps, newState, nextContext);
+      }
+
+      if (typeof instance.UNSAFE_componentWillUpdate === 'function') {
+        instance.UNSAFE_componentWillUpdate(newProps, newState, nextContext);
+      }
+    }
+
+    if (typeof instance.componentDidUpdate === 'function') {
+      workInProgress.flags |= Update;
+    }
+
+    if (typeof instance.getSnapshotBeforeUpdate === 'function') {
+      workInProgress.flags |= Snapshot;
+    }
+  } else {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidUpdate === 'function') {
+      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+        workInProgress.flags |= Update;
+      }
+    }
+
+    if (typeof instance.getSnapshotBeforeUpdate === 'function') {
+      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+        workInProgress.flags |= Snapshot;
+      }
+    } // If shouldComponentUpdate returned false, we should still update the
+    // memoized props/state to indicate that this work can be reused.
+
+
+    workInProgress.memoizedProps = newProps;
+    workInProgress.memoizedState = newState;
+  } // Update the existing instance's state, props, and context pointers even
+  // if shouldComponentUpdate returns false.
+
+
+  instance.props = newProps;
+  instance.state = newState;
+  instance.context = nextContext;
+  return shouldUpdate;
+}
+
+function createCapturedValueAtFiber(value, source) {
+  // If the value is an error, call this function immediately after it is thrown
+  // so the stack is accurate.
+  return {
+    value,
+    source,
+    stack: getStackByFiberInDevAndProd(source),
+    digest: null
+  };
+}
+function createCapturedValue(value, digest, stack) {
+  return {
+    value,
+    source: null,
+    stack: stack != null ? stack : null,
+    digest: digest != null ? digest : null
+  };
+}
+
+// This module is forked in different environments.
+// By default, return `true` to log errors to the console.
+// Forks can return `false` if this isn't desirable.
+function showErrorDialog(boundary, errorInfo) {
+  return true;
+}
+
+function logCapturedError(boundary, errorInfo) {
+  try {
+    const logError = showErrorDialog(boundary, errorInfo); // Allow injected showErrorDialog() to prevent default console.error logging.
+    // This enables renderers like ReactNative to better manage redbox behavior.
+
+    if (logError === false) ;
+
+    const error = errorInfo.value;
+
+    if (false) ; else {
+      // In production, we print the error directly.
+      // This will include the message, the JS stack, and anything the browser wants to show.
+      // We pass the error object instead of custom message so that the browser displays the error natively.
+      console['error'](error); // Don't transform to our wrapper
+    }
+  } catch (e) {
+    // This method must not throw, or React internal state will get messed up.
+    // If console.error is overridden, or logCapturedError() shows a dialog that throws,
+    // we want to report this error outside of the normal stack as a last resort.
+    // https://github.com/facebook/react/issues/13188
+    setTimeout(() => {
+      throw e;
+    });
+  }
+}
+
+function createRootErrorUpdate(fiber, errorInfo, lane) {
+  const update = createUpdate(lane); // Unmount the root by rendering null.
+
+  update.tag = CaptureUpdate; // Caution: React DevTools currently depends on this property
+  // being called "element".
+
+  update.payload = {
+    element: null
+  };
+  const error = errorInfo.value;
+
+  update.callback = () => {
+    onUncaughtError(error);
+    logCapturedError(fiber, errorInfo);
+  };
+
+  return update;
+}
+
+function createClassErrorUpdate(fiber, errorInfo, lane) {
+  const update = createUpdate(lane);
+  update.tag = CaptureUpdate;
+  const getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+
+  if (typeof getDerivedStateFromError === 'function') {
+    const error = errorInfo.value;
+
+    update.payload = () => {
+      return getDerivedStateFromError(error);
+    };
+
+    update.callback = () => {
+
+      logCapturedError(fiber, errorInfo);
+    };
+  }
+
+  const inst = fiber.stateNode;
+
+  if (inst !== null && typeof inst.componentDidCatch === 'function') {
+    // $FlowFixMe[missing-this-annot]
+    update.callback = function callback() {
+
+      logCapturedError(fiber, errorInfo);
+
+      if (typeof getDerivedStateFromError !== 'function') {
+        // To preserve the preexisting retry behavior of error boundaries,
+        // we keep track of which ones already failed during this batch.
+        // This gets reset before we yield back to the browser.
+        // TODO: Warn in strict mode if getDerivedStateFromError is
+        // not defined.
+        markLegacyErrorBoundaryAsFailed(this);
+      }
+
+      const error = errorInfo.value;
+      const stack = errorInfo.stack;
+      this.componentDidCatch(error, {
+        componentStack: stack !== null ? stack : ''
+      });
+    };
+  }
+
+  return update;
+}
+
+function resetSuspendedComponent(sourceFiber, rootRenderLanes) {
+  // A legacy mode Suspense quirk, only relevant to hook components.
+
+
+  const tag = sourceFiber.tag;
+
+  if ((sourceFiber.mode & ConcurrentMode) === NoMode && (tag === FunctionComponent || tag === ForwardRef || tag === SimpleMemoComponent)) {
+    const currentSource = sourceFiber.alternate;
+
+    if (currentSource) {
+      sourceFiber.updateQueue = currentSource.updateQueue;
+      sourceFiber.memoizedState = currentSource.memoizedState;
+      sourceFiber.lanes = currentSource.lanes;
+    } else {
+      sourceFiber.updateQueue = null;
+      sourceFiber.memoizedState = null;
+    }
+  }
+}
+
+function markSuspenseBoundaryShouldCapture(suspenseBoundary, returnFiber, sourceFiber, root, rootRenderLanes) {
+  // This marks a Suspense boundary so that when we're unwinding the stack,
+  // it captures the suspended "exception" and does a second (fallback) pass.
+  if ((suspenseBoundary.mode & ConcurrentMode) === NoMode) {
+    // Legacy Mode Suspense
+    //
+    // If the boundary is in legacy mode, we should *not*
+    // suspend the commit. Pretend as if the suspended component rendered
+    // null and keep rendering. When the Suspense boundary completes,
+    // we'll do a second pass to render the fallback.
+    if (suspenseBoundary === returnFiber) {
+      // Special case where we suspended while reconciling the children of
+      // a Suspense boundary's inner Offscreen wrapper fiber. This happens
+      // when a React.lazy component is a direct child of a
+      // Suspense boundary.
+      //
+      // Suspense boundaries are implemented as multiple fibers, but they
+      // are a single conceptual unit. The legacy mode behavior where we
+      // pretend the suspended fiber committed as `null` won't work,
+      // because in this case the "suspended" fiber is the inner
+      // Offscreen wrapper.
+      //
+      // Because the contents of the boundary haven't started rendering
+      // yet (i.e. nothing in the tree has partially rendered) we can
+      // switch to the regular, concurrent mode behavior: mark the
+      // boundary with ShouldCapture and enter the unwind phase.
+      suspenseBoundary.flags |= ShouldCapture;
+    } else {
+      suspenseBoundary.flags |= DidCapture;
+      sourceFiber.flags |= ForceUpdateForLegacySuspense; // We're going to commit this fiber even though it didn't complete.
+      // But we shouldn't call any lifecycle methods or callbacks. Remove
+      // all lifecycle effect tags.
+
+      sourceFiber.flags &= ~(LifecycleEffectMask | Incomplete);
+
+      if (sourceFiber.tag === ClassComponent) {
+        const currentSourceFiber = sourceFiber.alternate;
+
+        if (currentSourceFiber === null) {
+          // This is a new mount. Change the tag so it's not mistaken for a
+          // completed class component. For example, we should not call
+          // componentWillUnmount if it is deleted.
+          sourceFiber.tag = IncompleteClassComponent;
+        } else {
+          // When we try rendering again, we should not reuse the current fiber,
+          // since it's known to be in an inconsistent state. Use a force update to
+          // prevent a bail out.
+          const update = createUpdate(SyncLane);
+          update.tag = ForceUpdate;
+          enqueueUpdate(sourceFiber, update, SyncLane);
+        }
+      } // The source fiber did not complete. Mark it with Sync priority to
+      // indicate that it still has pending work.
+
+
+      sourceFiber.lanes = mergeLanes(sourceFiber.lanes, SyncLane);
+    }
+
+    return suspenseBoundary;
+  } // Confirmed that the boundary is in a concurrent mode tree. Continue
+  // with the normal suspend path.
+  //
+  // After this we'll use a set of heuristics to determine whether this
+  // render pass will run to completion or restart or "suspend" the commit.
+  // The actual logic for this is spread out in different places.
+  //
+  // This first principle is that if we're going to suspend when we complete
+  // a root, then we should also restart if we get an update or ping that
+  // might unsuspend it, and vice versa. The only reason to suspend is
+  // because you think you might want to restart before committing. However,
+  // it doesn't make sense to restart only while in the period we're suspended.
+  //
+  // Restarting too aggressively is also not good because it starves out any
+  // intermediate loading state. So we use heuristics to determine when.
+  // Suspense Heuristics
+  //
+  // If nothing threw a Promise or all the same fallbacks are already showing,
+  // then don't suspend/restart.
+  //
+  // If this is an initial render of a new tree of Suspense boundaries and
+  // those trigger a fallback, then don't suspend/restart. We want to ensure
+  // that we can show the initial loading state as quickly as possible.
+  //
+  // If we hit a "Delayed" case, such as when we'd switch from content back into
+  // a fallback, then we should always suspend/restart. Transitions apply
+  // to this case. If none is defined, JND is used instead.
+  //
+  // If we're already showing a fallback and it gets "retried", allowing us to show
+  // another level, but there's still an inner boundary that would show a fallback,
+  // then we suspend/restart for 500ms since the last time we showed a fallback
+  // anywhere in the tree. This effectively throttles progressive loading into a
+  // consistent train of commits. This also gives us an opportunity to restart to
+  // get to the completed state slightly earlier.
+  //
+  // If there's ambiguity due to batching it's resolved in preference of:
+  // 1) "delayed", 2) "initial render", 3) "retry".
+  //
+  // We want to ensure that a "busy" state doesn't get force committed. We want to
+  // ensure that new initial loading states can commit as soon as possible.
+
+
+  suspenseBoundary.flags |= ShouldCapture; // TODO: I think we can remove this, since we now use `DidCapture` in
+  // the begin phase to prevent an early bailout.
+
+  suspenseBoundary.lanes = rootRenderLanes;
+  return suspenseBoundary;
+}
+
+function throwException(root, returnFiber, sourceFiber, value, rootRenderLanes) {
+  // The source fiber did not complete.
+  sourceFiber.flags |= Incomplete;
+
+  {
+    if (isDevToolsPresent) {
+      // If we have pending work still, restore the original updaters
+      restorePendingUpdaters(root, rootRenderLanes);
+    }
+  }
+
+  if (value !== null && typeof value === 'object') {
+
+    if (typeof value.then === 'function') {
+      // This is a wakeable. The component suspended.
+      const wakeable = value;
+      resetSuspendedComponent(sourceFiber);
+
+
+      const suspenseBoundary = getSuspenseHandler();
+
+      if (suspenseBoundary !== null) {
+        switch (suspenseBoundary.tag) {
+          case SuspenseComponent:
+            {
+              // If this suspense boundary is not already showing a fallback, mark
+              // the in-progress render as suspended. We try to perform this logic
+              // as soon as soon as possible during the render phase, so the work
+              // loop can know things like whether it's OK to switch to other tasks,
+              // or whether it can wait for data to resolve before continuing.
+              // TODO: Most of these checks are already performed when entering a
+              // Suspense boundary. We should track the information on the stack so
+              // we don't have to recompute it on demand. This would also allow us
+              // to unify with `use` which needs to perform this logic even sooner,
+              // before `throwException` is called.
+              if (sourceFiber.mode & ConcurrentMode) {
+                if (getShellBoundary() === null) {
+                  // Suspended in the "shell" of the app. This is an undesirable
+                  // loading state. We should avoid committing this tree.
+                  renderDidSuspendDelayIfPossible();
+                } else {
+                  // If we suspended deeper than the shell, we don't need to delay
+                  // the commmit. However, we still call renderDidSuspend if this is
+                  // a new boundary, to tell the work loop that a new fallback has
+                  // appeared during this render.
+                  // TODO: Theoretically we should be able to delete this branch.
+                  // It's currently used for two things: 1) to throttle the
+                  // appearance of successive loading states, and 2) in
+                  // SuspenseList, to determine whether the children include any
+                  // pending fallbacks. For 1, we should apply throttling to all
+                  // retries, not just ones that render an additional fallback. For
+                  // 2, we should check subtreeFlags instead. Then we can delete
+                  // this branch.
+                  const current = suspenseBoundary.alternate;
+
+                  if (current === null) {
+                    renderDidSuspend();
+                  }
+                }
+              }
+
+              suspenseBoundary.flags &= ~ForceClientRender;
+              markSuspenseBoundaryShouldCapture(suspenseBoundary, returnFiber, sourceFiber, root, rootRenderLanes); // Retry listener
+              //
+              // If the fallback does commit, we need to attach a different type of
+              // listener. This one schedules an update on the Suspense boundary to
+              // turn the fallback state off.
+              //
+              // Stash the wakeable on the boundary fiber so we can access it in the
+              // commit phase.
+              //
+              // When the wakeable resolves, we'll attempt to render the boundary
+              // again ("retry").
+              // Check if this is a Suspensey resource. We do not attach retry
+              // listeners to these, because we don't actually need them for
+              // rendering. Only for committing. Instead, if a fallback commits
+              // and the only thing that suspended was a Suspensey resource, we
+              // retry immediately.
+              // TODO: Refactor throwException so that we don't have to do this type
+              // check. The caller already knows what the cause was.
+
+              const isSuspenseyResource = wakeable === noopSuspenseyCommitThenable;
+
+              if (isSuspenseyResource) {
+                suspenseBoundary.flags |= ScheduleRetry;
+              } else {
+                const retryQueue = suspenseBoundary.updateQueue;
+
+                if (retryQueue === null) {
+                  suspenseBoundary.updateQueue = new Set([wakeable]);
+                } else {
+                  retryQueue.add(wakeable);
+                } // We only attach ping listeners in concurrent mode. Legacy
+                // Suspense always commits fallbacks synchronously, so there are
+                // no pings.
+
+
+                if (suspenseBoundary.mode & ConcurrentMode) {
+                  attachPingListener(root, wakeable, rootRenderLanes);
+                }
+              }
+
+              return;
+            }
+
+          case OffscreenComponent:
+            {
+              if (suspenseBoundary.mode & ConcurrentMode) {
+                suspenseBoundary.flags |= ShouldCapture;
+                const isSuspenseyResource = wakeable === noopSuspenseyCommitThenable;
+
+                if (isSuspenseyResource) {
+                  suspenseBoundary.flags |= ScheduleRetry;
+                } else {
+                  const offscreenQueue = suspenseBoundary.updateQueue;
+
+                  if (offscreenQueue === null) {
+                    const newOffscreenQueue = {
+                      transitions: null,
+                      markerInstances: null,
+                      retryQueue: new Set([wakeable])
+                    };
+                    suspenseBoundary.updateQueue = newOffscreenQueue;
+                  } else {
+                    const retryQueue = offscreenQueue.retryQueue;
+
+                    if (retryQueue === null) {
+                      offscreenQueue.retryQueue = new Set([wakeable]);
+                    } else {
+                      retryQueue.add(wakeable);
+                    }
+                  }
+
+                  attachPingListener(root, wakeable, rootRenderLanes);
+                }
+
+                return;
+              }
+            }
+        }
+
+        throw Error(formatProdErrorMessage(435, suspenseBoundary.tag));
+      } else {
+        // No boundary was found. Unless this is a sync update, this is OK.
+        // We can suspend and wait for more data to arrive.
+        if (root.tag === ConcurrentRoot) {
+          // In a concurrent root, suspending without a Suspense boundary is
+          // allowed. It will suspend indefinitely without committing.
+          //
+          // TODO: Should we have different behavior for discrete updates? What
+          // about flushSync? Maybe it should put the tree into an inert state,
+          // and potentially log a warning. Revisit this for a future release.
+          attachPingListener(root, wakeable, rootRenderLanes);
+          renderDidSuspendDelayIfPossible();
+          return;
+        } else {
+          // In a legacy root, suspending without a boundary is always an error.
+          const uncaughtSuspenseError = Error(formatProdErrorMessage(426));
+          value = uncaughtSuspenseError;
+        }
+      }
+    }
+  } // This is a regular error, not a Suspense wakeable.
+
+
+  if (getIsHydrating() && sourceFiber.mode & ConcurrentMode) {
+    const suspenseBoundary = getSuspenseHandler(); // If the error was thrown during hydration, we may be able to recover by
+    // discarding the dehydrated content and switching to a client render.
+    // Instead of surfacing the error, find the nearest Suspense boundary
+    // and render it again without hydration.
+
+    if (suspenseBoundary !== null) {
+      if ((suspenseBoundary.flags & ShouldCapture) === NoFlags$1) {
+        // Set a flag to indicate that we should try rendering the normal
+        // children again, not the fallback.
+        suspenseBoundary.flags |= ForceClientRender;
+      }
+
+      markSuspenseBoundaryShouldCapture(suspenseBoundary, returnFiber, sourceFiber, root, rootRenderLanes); // Even though the user may not be affected by this error, we should
+      // still log it so it can be fixed.
+
+      queueHydrationError(createCapturedValueAtFiber(value, sourceFiber));
+      return;
+    }
+  }
+
+  value = createCapturedValueAtFiber(value, sourceFiber);
+  renderDidError(value); // We didn't find a boundary that could handle this type of exception. Start
+  // over and traverse parent path again, this time treating the exception
+  // as an error.
+
+  let workInProgress = returnFiber;
+
+  do {
+    switch (workInProgress.tag) {
+      case HostRoot:
+        {
+          const errorInfo = value;
+          workInProgress.flags |= ShouldCapture;
+          const lane = pickArbitraryLane(rootRenderLanes);
+          workInProgress.lanes = mergeLanes(workInProgress.lanes, lane);
+          const update = createRootErrorUpdate(workInProgress, errorInfo, lane);
+          enqueueCapturedUpdate(workInProgress, update);
+          return;
+        }
+
+      case ClassComponent:
+        // Capture and retry
+        const errorInfo = value;
+        const ctor = workInProgress.type;
+        const instance = workInProgress.stateNode;
+
+        if ((workInProgress.flags & DidCapture) === NoFlags$1 && (typeof ctor.getDerivedStateFromError === 'function' || instance !== null && typeof instance.componentDidCatch === 'function' && !isAlreadyFailedLegacyErrorBoundary(instance))) {
+          workInProgress.flags |= ShouldCapture;
+          const lane = pickArbitraryLane(rootRenderLanes);
+          workInProgress.lanes = mergeLanes(workInProgress.lanes, lane); // Schedule the error boundary to re-render using updated state
+
+          const update = createClassErrorUpdate(workInProgress, errorInfo, lane);
+          enqueueCapturedUpdate(workInProgress, update);
+          return;
+        }
+
+        break;
+    } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+    workInProgress = workInProgress.return;
+  } while (workInProgress !== null);
+}
+
+const ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner; // A special exception that's used to unwind the stack when an update flows
+// into a dehydrated boundary.
+
+const SelectiveHydrationException = Error(formatProdErrorMessage(461));
+let didReceiveUpdate = false;
+
+function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
+  if (current === null) {
+    // If this is a fresh new component that hasn't been rendered yet, we
+    // won't update its child set by applying minimal side-effects. Instead,
+    // we will add them all to the child before it gets rendered. That means
+    // we can optimize this reconciliation pass by not tracking side-effects.
+    workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderLanes);
+  } else {
+    // If the current child is the same as the work in progress, it means that
+    // we haven't yet started any work on these children. Therefore, we use
+    // the clone algorithm to create a copy of all the current children.
+    // If we had any progressed work already, that is invalid at this point so
+    // let's throw it out.
+    workInProgress.child = reconcileChildFibers(workInProgress, current.child, nextChildren, renderLanes);
+  }
+}
+
+function forceUnmountCurrentAndReconcile(current, workInProgress, nextChildren, renderLanes) {
+  // This function is fork of reconcileChildren. It's used in cases where we
+  // want to reconcile without matching against the existing set. This has the
+  // effect of all current children being unmounted; even if the type and key
+  // are the same, the old child is unmounted and a new child is created.
+  //
+  // To do this, we're going to go through the reconcile algorithm twice. In
+  // the first pass, we schedule a deletion for all the current children by
+  // passing null.
+  workInProgress.child = reconcileChildFibers(workInProgress, current.child, null, renderLanes); // In the second pass, we mount the new children. The trick here is that we
+  // pass null in place of where we usually pass the current child set. This has
+  // the effect of remounting all children regardless of whether their
+  // identities match.
+
+  workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderLanes);
+}
+
+function updateForwardRef(current, workInProgress, Component, nextProps, renderLanes) {
+
+  const render = Component.render;
+  const ref = workInProgress.ref; // The rest is a fork of updateFunctionComponent
+
+  let nextChildren;
+  let hasId;
+  prepareToReadContext(workInProgress, renderLanes);
+
+  {
+    markComponentRenderStarted(workInProgress);
+  }
+
+  {
+    nextChildren = renderWithHooks(current, workInProgress, render, nextProps, ref, renderLanes);
+    hasId = checkDidRenderIdHook();
+  }
+
+  {
+    markComponentRenderStopped();
+  }
+
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateMemoComponent(current, workInProgress, Component, nextProps, renderLanes) {
+  if (current === null) {
+    const type = Component.type;
+
+    if (isSimpleFunctionComponent(type) && Component.compare === null && // SimpleMemoComponent codepath doesn't resolve outer props either.
+    Component.defaultProps === undefined) {
+      let resolvedType = type;
+      // and with only the default shallow comparison, we upgrade it
+      // to a SimpleMemoComponent to allow fast path updates.
+
+
+      workInProgress.tag = SimpleMemoComponent;
+      workInProgress.type = resolvedType;
+
+      return updateSimpleMemoComponent(current, workInProgress, resolvedType, nextProps, renderLanes);
+    }
+
+    const child = createFiberFromTypeAndProps(Component.type, null, nextProps, null, workInProgress, workInProgress.mode, renderLanes);
+    child.ref = workInProgress.ref;
+    child.return = workInProgress;
+    workInProgress.child = child;
+    return child;
+  }
+
+  const currentChild = current.child; // This is always exactly one child
+
+  const hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(current, renderLanes);
+
+  if (!hasScheduledUpdateOrContext) {
+    // This will be the props with resolved defaultProps,
+    // unlike current.memoizedProps which will be the unresolved ones.
+    const prevProps = currentChild.memoizedProps; // Default to shallow comparison
+
+    let compare = Component.compare;
+    compare = compare !== null ? compare : shallowEqual;
+
+    if (compare(prevProps, nextProps) && current.ref === workInProgress.ref) {
+      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    }
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+  const newChild = createWorkInProgress(currentChild, nextProps);
+  newChild.ref = workInProgress.ref;
+  newChild.return = workInProgress;
+  workInProgress.child = newChild;
+  return newChild;
+}
+
+function updateSimpleMemoComponent(current, workInProgress, Component, nextProps, renderLanes) {
+
+  if (current !== null) {
+    const prevProps = current.memoizedProps;
+
+    if (shallowEqual(prevProps, nextProps) && current.ref === workInProgress.ref && ( // Prevent bailout if the implementation changed due to hot reload.
+    true)) {
+      didReceiveUpdate = false; // The props are shallowly equal. Reuse the previous props object, like we
+      // would during a normal fiber bailout.
+      //
+      // We don't have strong guarantees that the props object is referentially
+      // equal during updates where we can't bail out anyway — like if the props
+      // are shallowly equal, but there's a local state or context update in the
+      // same batch.
+      //
+      // However, as a principle, we should aim to make the behavior consistent
+      // across different ways of memoizing a component. For example, React.memo
+      // has a different internal Fiber layout if you pass a normal function
+      // component (SimpleMemoComponent) versus if you pass a different type
+      // like forwardRef (MemoComponent). But this is an implementation detail.
+      // Wrapping a component in forwardRef (or React.lazy, etc) shouldn't
+      // affect whether the props object is reused during a bailout.
+
+      workInProgress.pendingProps = nextProps = prevProps;
+
+      if (!checkScheduledUpdateOrContext(current, renderLanes)) {
+        // The pending lanes were cleared at the beginning of beginWork. We're
+        // about to bail out, but there might be other lanes that weren't
+        // included in the current render. Usually, the priority level of the
+        // remaining updates is accumulated during the evaluation of the
+        // component (i.e. when processing the update queue). But since since
+        // we're bailing out early *without* evaluating the component, we need
+        // to account for it here, too. Reset to the value of the current fiber.
+        // NOTE: This only applies to SimpleMemoComponent, not MemoComponent,
+        // because a MemoComponent fiber does not have hooks or an update queue;
+        // rather, it wraps around an inner component, which may or may not
+        // contains hooks.
+        // TODO: Move the reset at in beginWork out of the common path so that
+        // this is no longer necessary.
+        workInProgress.lanes = current.lanes;
+        return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+      } else if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags$1) {
+        // This is a special case that only exists for legacy mode.
+        // See https://github.com/facebook/react/pull/19216.
+        didReceiveUpdate = true;
+      }
+    }
+  }
+
+  return updateFunctionComponent(current, workInProgress, Component, nextProps, renderLanes);
+}
+
+function updateOffscreenComponent(current, workInProgress, renderLanes) {
+  const nextProps = workInProgress.pendingProps;
+  const nextChildren = nextProps.children;
+  const nextIsDetached = (workInProgress.stateNode._pendingVisibility & OffscreenDetached) !== 0;
+  const prevState = current !== null ? current.memoizedState : null;
+  markRef$1(current, workInProgress);
+
+  if (nextProps.mode === 'hidden' || enableLegacyHidden  || nextIsDetached) {
+    // Rendering a hidden tree.
+    const didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
+
+    if (didSuspend) {
+      // Something suspended inside a hidden tree
+      // Include the base lanes from the last render
+      const nextBaseLanes = prevState !== null ? mergeLanes(prevState.baseLanes, renderLanes) : renderLanes;
+
+      if (current !== null) {
+        // Reset to the current children
+        let currentChild = workInProgress.child = current.child; // The current render suspended, but there may be other lanes with
+        // pending work. We can't read `childLanes` from the current Offscreen
+        // fiber because we reset it when it was deferred; however, we can read
+        // the pending lanes from the child fibers.
+
+        let currentChildLanes = NoLanes;
+
+        while (currentChild !== null) {
+          currentChildLanes = mergeLanes(mergeLanes(currentChildLanes, currentChild.lanes), currentChild.childLanes);
+          currentChild = currentChild.sibling;
+        }
+
+        const lanesWeJustAttempted = nextBaseLanes;
+        const remainingChildLanes = removeLanes(currentChildLanes, lanesWeJustAttempted);
+        workInProgress.childLanes = remainingChildLanes;
+      } else {
+        workInProgress.childLanes = NoLanes;
+        workInProgress.child = null;
+      }
+
+      return deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes);
+    }
+
+    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+      // In legacy sync mode, don't defer the subtree. Render it now.
+      // TODO: Consider how Offscreen should work with transitions in the future
+      const nextState = {
+        baseLanes: NoLanes,
+        cachePool: null
+      };
+      workInProgress.memoizedState = nextState;
+
+      {
+        // push the cache pool even though we're going to bail out
+        // because otherwise there'd be a context mismatch
+        if (current !== null) {
+          pushTransition(workInProgress, null);
+        }
+      }
+
+      reuseHiddenContextOnStack();
+      pushOffscreenSuspenseHandler(workInProgress);
+    } else if (!includesSomeLane(renderLanes, OffscreenLane)) {
+      // We're hidden, and we're not rendering at Offscreen. We will bail out
+      // and resume this tree later.
+      // Schedule this fiber to re-render at Offscreen priority
+      workInProgress.lanes = workInProgress.childLanes = laneToLanes(OffscreenLane); // Include the base lanes from the last render
+
+      const nextBaseLanes = prevState !== null ? mergeLanes(prevState.baseLanes, renderLanes) : renderLanes;
+      return deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes);
+    } else {
+      // This is the second render. The surrounding visible content has already
+      // committed. Now we resume rendering the hidden tree.
+      // Rendering at offscreen, so we can clear the base lanes.
+      const nextState = {
+        baseLanes: NoLanes,
+        cachePool: null
+      };
+      workInProgress.memoizedState = nextState;
+
+      if (current !== null) {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        const 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);
+      } // Push the lanes that were skipped when we bailed out.
+
+
+      if (prevState !== null) {
+        pushHiddenContext(workInProgress, prevState);
+      } else {
+        reuseHiddenContextOnStack();
+      }
+
+      pushOffscreenSuspenseHandler(workInProgress);
+    }
+  } else {
+    // Rendering a visible tree.
+    if (prevState !== null) {
+      // We're going from hidden -> visible.
+      let prevCachePool = null;
+
+      {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        prevCachePool = prevState.cachePool;
+      }
+
+      pushTransition(workInProgress, prevCachePool); // Push the lanes that were skipped when we bailed out.
+
+      pushHiddenContext(workInProgress, prevState);
+      reuseSuspenseHandlerOnStack(workInProgress); // Since we're not hidden anymore, reset the state
+
+      workInProgress.memoizedState = null;
+    } else {
+      // We weren't previously hidden, and we still aren't, so there's nothing
+      // special to do. Need to push to the stack regardless, though, to avoid
+      // a push/pop misalignment.
+      {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        if (current !== null) {
+          pushTransition(workInProgress, null);
+        }
+      } // We're about to bail out, but we need to push this to the stack anyway
+      // to avoid a push/pop misalignment.
+
+
+      reuseHiddenContextOnStack();
+      reuseSuspenseHandlerOnStack(workInProgress);
+    }
+  }
+
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes, renderLanes) {
+  const nextState = {
+    baseLanes: nextBaseLanes,
+    // Save the cache pool so we can resume later.
+    cachePool: getOffscreenDeferredCache() 
+  };
+  workInProgress.memoizedState = nextState;
+
+  {
+    // push the cache pool even though we're going to bail out
+    // because otherwise there'd be a context mismatch
+    if (current !== null) {
+      pushTransition(workInProgress, null);
+    }
+  } // We're about to bail out, but we need to push this to the stack anyway
+  // to avoid a push/pop misalignment.
+
+
+  reuseHiddenContextOnStack();
+  pushOffscreenSuspenseHandler(workInProgress);
+
+  return null;
+} // Note: These happen to have identical begin phases, for now. We shouldn't hold
+
+function updateCacheComponent(current, workInProgress, renderLanes) {
+
+  prepareToReadContext(workInProgress, renderLanes);
+  const parentCache = readContext(CacheContext);
+
+  if (current === null) {
+    // Initial mount. Request a fresh cache from the pool.
+    const freshCache = requestCacheFromPool(renderLanes);
+    const initialState = {
+      parent: parentCache,
+      cache: freshCache
+    };
+    workInProgress.memoizedState = initialState;
+    initializeUpdateQueue(workInProgress);
+    pushCacheProvider(workInProgress, freshCache);
+  } else {
+    // Check for updates
+    if (includesSomeLane(current.lanes, renderLanes)) {
+      cloneUpdateQueue(current, workInProgress);
+      processUpdateQueue(workInProgress, null, null, renderLanes);
+    }
+
+    const prevState = current.memoizedState;
+    const nextState = workInProgress.memoizedState; // Compare the new parent cache to the previous to see detect there was
+    // a refresh.
+
+    if (prevState.parent !== parentCache) {
+      // Refresh in parent. Update the parent.
+      const derivedState = {
+        parent: parentCache,
+        cache: parentCache
+      }; // Copied from getDerivedStateFromProps implementation. Once the update
+      // queue is empty, persist the derived state onto the base state.
+
+      workInProgress.memoizedState = derivedState;
+
+      if (workInProgress.lanes === NoLanes) {
+        const updateQueue = workInProgress.updateQueue;
+        workInProgress.memoizedState = updateQueue.baseState = derivedState;
+      }
+
+      pushCacheProvider(workInProgress, parentCache); // No need to propagate a context change because the refreshed parent
+      // already did.
+    } else {
+      // The parent didn't refresh. Now check if this cache did.
+      const nextCache = nextState.cache;
+      pushCacheProvider(workInProgress, nextCache);
+
+      if (nextCache !== prevState.cache) {
+        // This cache refreshed. Propagate a context change.
+        propagateContextChange(workInProgress, CacheContext, renderLanes);
+      }
+    }
+  }
+
+  const nextChildren = workInProgress.pendingProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+} // This should only be called if the name changes
+
+function updateFragment(current, workInProgress, renderLanes) {
+  const nextChildren = workInProgress.pendingProps;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateMode(current, workInProgress, renderLanes) {
+  const nextChildren = workInProgress.pendingProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+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,
+      const stateNode = workInProgress.stateNode;
+      stateNode.effectDuration = 0;
+      stateNode.passiveEffectDuration = 0;
+    }
+  }
+
+  const nextProps = workInProgress.pendingProps;
+  const nextChildren = nextProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function markRef$1(current, workInProgress) {
+  const ref = workInProgress.ref;
+
+  if (current === null && ref !== null || current !== null && current.ref !== ref) {
+    // Schedule a Ref effect
+    workInProgress.flags |= Ref;
+    workInProgress.flags |= RefStatic;
+  }
+}
+
+function updateFunctionComponent(current, workInProgress, Component, nextProps, renderLanes) {
+
+  let context;
+
+  {
+    const unmaskedContext = getUnmaskedContext(workInProgress, Component, true);
+    context = getMaskedContext(workInProgress, unmaskedContext);
+  }
+
+  let nextChildren;
+  let hasId;
+  prepareToReadContext(workInProgress, renderLanes);
+
+  {
+    markComponentRenderStarted(workInProgress);
+  }
+
+  {
+    nextChildren = renderWithHooks(current, workInProgress, Component, nextProps, context, renderLanes);
+    hasId = checkDidRenderIdHook();
+  }
+
+  {
+    markComponentRenderStopped();
+  }
+
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function replayFunctionComponent(current, workInProgress, nextProps, Component, secondArg, renderLanes) {
+  // This function is used to replay a component that previously suspended,
+  // after its data resolves. It's a simplified version of
+  // updateFunctionComponent that reuses the hooks from the previous attempt.
+  prepareToReadContext(workInProgress, renderLanes);
+
+  {
+    markComponentRenderStarted(workInProgress);
+  }
+
+  const nextChildren = replaySuspendedComponentWithHooks(current, workInProgress, Component, nextProps, secondArg);
+  const hasId = checkDidRenderIdHook();
+
+  {
+    markComponentRenderStopped();
+  }
+
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateClassComponent(current, workInProgress, Component, nextProps, renderLanes) {
+  // During mounting we don't know the child context yet as the instance doesn't exist.
+  // We will invalidate the child context in finishClassComponent() right after rendering.
+
+
+  let hasContext;
+
+  if (isContextProvider(Component)) {
+    hasContext = true;
+    pushContextProvider(workInProgress);
+  } else {
+    hasContext = false;
+  }
+
+  prepareToReadContext(workInProgress, renderLanes);
+  const instance = workInProgress.stateNode;
+  let shouldUpdate;
+
+  if (instance === null) {
+    resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress); // In the initial pass we might need to construct the instance.
+
+    constructClassInstance(workInProgress, Component, nextProps);
+    mountClassInstance(workInProgress, Component, nextProps, renderLanes);
+    shouldUpdate = true;
+  } else if (current === null) {
+    // In a resume, we'll already have an instance we can reuse.
+    shouldUpdate = resumeMountClassInstance(workInProgress, Component, nextProps, renderLanes);
+  } else {
+    shouldUpdate = updateClassInstance(current, workInProgress, Component, nextProps, renderLanes);
+  }
+
+  const nextUnitOfWork = finishClassComponent(current, workInProgress, Component, shouldUpdate, hasContext, renderLanes);
+
+  return nextUnitOfWork;
+}
+
+function finishClassComponent(current, workInProgress, Component, shouldUpdate, hasContext, renderLanes) {
+  // Refs should update even if shouldComponentUpdate returns false
+  markRef$1(current, workInProgress);
+  const didCaptureError = (workInProgress.flags & DidCapture) !== NoFlags$1;
+
+  if (!shouldUpdate && !didCaptureError) {
+    // Context providers should defer to sCU for rendering
+    if (hasContext) {
+      invalidateContextProvider(workInProgress, Component, false);
+    }
+
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+
+  const instance = workInProgress.stateNode; // Rerender
+
+  ReactCurrentOwner$1.current = workInProgress;
+  let nextChildren;
+
+  if (didCaptureError && typeof Component.getDerivedStateFromError !== 'function') {
+    // If we captured an error, but getDerivedStateFromError is not defined,
+    // unmount all the children. componentDidCatch will schedule an update to
+    // re-render a fallback. This is temporary until we migrate everyone to
+    // the new API.
+    // TODO: Warn in a future release.
+    nextChildren = null;
+
+    {
+      stopProfilerTimerIfRunning();
+    }
+  } else {
+    {
+      markComponentRenderStarted(workInProgress);
+    }
+
+    {
+      nextChildren = instance.render();
+    }
+
+    {
+      markComponentRenderStopped();
+    }
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+
+  if (current !== null && didCaptureError) {
+    // If we're recovering from an error, reconcile without reusing any of
+    // the existing children. Conceptually, the normal children and the children
+    // that are shown on error are two different sets, so we shouldn't reuse
+    // normal children even if their identities match.
+    forceUnmountCurrentAndReconcile(current, workInProgress, nextChildren, renderLanes);
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  } // Memoize state using the values we just used to render.
+  // TODO: Restructure so we never read values from the instance.
+
+
+  workInProgress.memoizedState = instance.state; // The context might have changed so we need to recalculate it.
+
+  if (hasContext) {
+    invalidateContextProvider(workInProgress, Component, true);
+  }
+
+  return workInProgress.child;
+}
+
+function pushHostRootContext(workInProgress) {
+  const root = workInProgress.stateNode;
+
+  if (root.pendingContext) {
+    pushTopLevelContextObject(workInProgress, root.pendingContext, root.pendingContext !== root.context);
+  } else if (root.context) {
+    // Should always be set
+    pushTopLevelContextObject(workInProgress, root.context, false);
+  }
+
+  pushHostContainer(workInProgress, root.containerInfo);
+}
+
+function updateHostRoot(current, workInProgress, renderLanes) {
+  pushHostRootContext(workInProgress);
+
+  if (current === null) {
+    throw Error(formatProdErrorMessage(387));
+  }
+
+  const nextProps = workInProgress.pendingProps;
+  const prevState = workInProgress.memoizedState;
+  const prevChildren = prevState.element;
+  cloneUpdateQueue(current, workInProgress);
+  processUpdateQueue(workInProgress, nextProps, null, renderLanes);
+  const nextState = workInProgress.memoizedState;
+
+  {
+    const nextCache = nextState.cache;
+    pushCacheProvider(workInProgress, nextCache);
+
+    if (nextCache !== prevState.cache) {
+      // The root cache refreshed.
+      propagateContextChange(workInProgress, CacheContext, renderLanes);
+    }
+  } // Caution: React DevTools currently depends on this property
+  // being called "element".
+
+
+  const nextChildren = nextState.element;
+
+  if (prevState.isDehydrated) {
+    // This is a hydration root whose shell has not yet hydrated. We should
+    // attempt to hydrate.
+    // Flip isDehydrated to false to indicate that when this render
+    // finishes, the root will no longer be dehydrated.
+    const overrideState = {
+      element: nextChildren,
+      isDehydrated: false,
+      cache: nextState.cache
+    };
+    const updateQueue = workInProgress.updateQueue; // `baseState` can always be the last state because the root doesn't
+    // have reducer functions so it doesn't need rebasing.
+
+    updateQueue.baseState = overrideState;
+    workInProgress.memoizedState = overrideState;
+
+    if (workInProgress.flags & ForceClientRender) {
+      // Something errored during a previous attempt to hydrate the shell, so we
+      // forced a client render.
+      const recoverableError = createCapturedValueAtFiber(Error(formatProdErrorMessage(423)), workInProgress);
+      return mountHostRootWithoutHydrating(current, workInProgress, nextChildren, renderLanes, recoverableError);
+    } else if (nextChildren !== prevChildren) {
+      const recoverableError = createCapturedValueAtFiber(Error(formatProdErrorMessage(424)), workInProgress);
+      return mountHostRootWithoutHydrating(current, workInProgress, nextChildren, renderLanes, recoverableError);
+    } else {
+      // The outermost shell has not hydrated yet. Start hydrating.
+      enterHydrationState(workInProgress);
+      const child = mountChildFibers(workInProgress, null, nextChildren, renderLanes);
+      workInProgress.child = child;
+      let node = child;
+
+      while (node) {
+        // Mark each child as hydrating. This is a fast path to know whether this
+        // tree is part of a hydrating tree. This is used to determine if a child
+        // node has fully mounted yet, and for scheduling event replaying.
+        // Conceptually this is similar to Placement in that a new subtree is
+        // inserted into the React tree here. It just happens to not need DOM
+        // mutations because it already exists.
+        node.flags = node.flags & ~Placement | Hydrating;
+        node = node.sibling;
+      }
+    }
+  } else {
+    // Root is not dehydrated. Either this is a client-only root, or it
+    // already hydrated.
+    resetHydrationState();
+
+    if (nextChildren === prevChildren) {
+      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    }
+
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  }
+
+  return workInProgress.child;
+}
+
+function mountHostRootWithoutHydrating(current, workInProgress, nextChildren, renderLanes, recoverableError) {
+  // Revert to client rendering.
+  resetHydrationState();
+  queueHydrationError(recoverableError);
+  workInProgress.flags |= ForceClientRender;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateHostComponent$1(current, workInProgress, renderLanes) {
+  pushHostContext(workInProgress);
+
+  if (current === null) {
+    tryToClaimNextHydratableInstance(workInProgress);
+  }
+
+  const type = workInProgress.type;
+  const nextProps = workInProgress.pendingProps;
+  const prevProps = current !== null ? current.memoizedProps : null;
+  let nextChildren = nextProps.children;
+  const isDirectTextChild = shouldSetTextContent(type, nextProps);
+
+  if (isDirectTextChild) {
+    // We special case a direct text child of a host node. This is a common
+    // case. We won't handle it as a reified child. We will instead handle
+    // this in the host environment that also has access to this prop. That
+    // avoids allocating another HostText fiber and traversing it.
+    nextChildren = null;
+  } else if (prevProps !== null && shouldSetTextContent(type, prevProps)) {
+    // If we're switching from a direct text child to a normal child, or to
+    // empty, we need to schedule the text content to be reset.
+    workInProgress.flags |= ContentReset;
+  }
+
+  {
+    const memoizedState = workInProgress.memoizedState;
+
+    if (memoizedState !== null) {
+      // This fiber has been upgraded to a stateful component. The only way
+      // happens currently is for form actions. We use hooks to track the
+      // pending and error state of the form.
+      //
+      // Once a fiber is upgraded to be stateful, it remains stateful for the
+      // rest of its lifetime.
+      const newState = renderTransitionAwareHostComponentWithHooks(current, workInProgress, renderLanes); // If the transition state changed, propagate the change to all the
+      // descendents. We use Context as an implementation detail for this.
+      //
+      // This is intentionally set here instead of pushHostContext because
+      // pushHostContext gets called before we process the state hook, to avoid
+      // a state mismatch in the event that something suspends.
+      //
+      // NOTE: This assumes that there cannot be nested transition providers,
+      // because the only renderer that implements this feature is React DOM,
+      // and forms cannot be nested. If we did support nested providers, then
+      // we would need to push a context value even for host fibers that
+      // haven't been upgraded yet.
+
+      {
+        HostTransitionContext._currentValue = newState;
+      }
+
+      {
+        if (didReceiveUpdate) {
+          if (current !== null) {
+            const oldStateHook = current.memoizedState;
+            const oldState = oldStateHook.memoizedState; // This uses regular equality instead of Object.is because we assume
+            // that host transition state doesn't include NaN as a valid type.
+
+            if (oldState !== newState) {
+              propagateContextChange(workInProgress, HostTransitionContext, renderLanes);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  markRef$1(current, workInProgress);
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateHostHoistable(current, workInProgress, renderLanes) {
+  markRef$1(current, workInProgress);
+  const currentProps = current === null ? null : current.memoizedProps;
+  const resource = workInProgress.memoizedState = getResource(workInProgress.type, currentProps, workInProgress.pendingProps);
+
+  if (current === null) {
+    if (!getIsHydrating() && resource === null) {
+      // This is not a Resource Hoistable and we aren't hydrating so we construct the instance.
+      workInProgress.stateNode = createHoistableInstance(workInProgress.type, workInProgress.pendingProps, getRootHostContainer(), workInProgress);
+    }
+  } // Resources never have reconciler managed children. It is possible for
+  // the host implementation of getResource to consider children in the
+  // resource construction but they will otherwise be discarded. In practice
+  // this precludes all but the simplest children and Host specific warnings
+  // should be implemented to warn when children are passsed when otherwise not
+  // expected
+
+
+  return null;
+}
+
+function updateHostSingleton(current, workInProgress, renderLanes) {
+  pushHostContext(workInProgress);
+
+  if (current === null) {
+    claimHydratableSingleton(workInProgress);
+  }
+
+  const nextChildren = workInProgress.pendingProps.children;
+
+  if (current === null && !getIsHydrating()) {
+    // Similar to Portals we append Singleton children in the commit phase. So we
+    // Track insertions even on mount.
+    // TODO: Consider unifying this with how the root works.
+    workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderLanes);
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  }
+
+  markRef$1(current, workInProgress);
+  return workInProgress.child;
+}
+
+function updateHostText$1(current, workInProgress) {
+  if (current === null) {
+    tryToClaimNextHydratableTextInstance(workInProgress);
+  } // Nothing to do here. This is terminal. We'll do the completion step
+  // immediately after.
+
+
+  return null;
+}
+
+function mountLazyComponent(_current, workInProgress, elementType, renderLanes) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);
+  const props = workInProgress.pendingProps;
+  const lazyComponent = elementType;
+  const payload = lazyComponent._payload;
+  const init = lazyComponent._init;
+  let Component = init(payload); // Store the unwrapped component in the type.
+
+  workInProgress.type = Component;
+  const resolvedTag = workInProgress.tag = resolveLazyComponentTag(Component);
+  const resolvedProps = resolveDefaultProps(Component, props);
+  let child;
+
+  switch (resolvedTag) {
+    case FunctionComponent:
+      {
+
+        child = updateFunctionComponent(null, workInProgress, Component, resolvedProps, renderLanes);
+        return child;
+      }
+
+    case ClassComponent:
+      {
+
+        child = updateClassComponent(null, workInProgress, Component, resolvedProps, renderLanes);
+        return child;
+      }
+
+    case ForwardRef:
+      {
+
+        child = updateForwardRef(null, workInProgress, Component, resolvedProps, renderLanes);
+        return child;
+      }
+
+    case MemoComponent:
+      {
+
+        child = updateMemoComponent(null, workInProgress, Component, resolveDefaultProps(Component.type, resolvedProps), // The inner type can have defaults too
+        renderLanes);
+        return child;
+      }
+  }
+
+  let hint = '';
+  // because the fact that it's a separate type of work is an
+  // implementation detail.
+
+
+  throw Error(formatProdErrorMessage(306, Component, hint));
+}
+
+function mountIncompleteClassComponent(_current, workInProgress, Component, nextProps, renderLanes) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress); // Promote the fiber to a class and try rendering again.
+
+  workInProgress.tag = ClassComponent; // The rest of this function is a fork of `updateClassComponent`
+  // Push context providers early to prevent context stack mismatches.
+  // During mounting we don't know the child context yet as the instance doesn't exist.
+  // We will invalidate the child context in finishClassComponent() right after rendering.
+
+  let hasContext;
+
+  if (isContextProvider(Component)) {
+    hasContext = true;
+    pushContextProvider(workInProgress);
+  } else {
+    hasContext = false;
+  }
+
+  prepareToReadContext(workInProgress, renderLanes);
+  constructClassInstance(workInProgress, Component, nextProps);
+  mountClassInstance(workInProgress, Component, nextProps, renderLanes);
+  return finishClassComponent(null, workInProgress, Component, true, hasContext, renderLanes);
+}
+
+function mountIndeterminateComponent(_current, workInProgress, Component, renderLanes) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);
+  const props = workInProgress.pendingProps;
+  let context;
+
+  {
+    const unmaskedContext = getUnmaskedContext(workInProgress, Component, false);
+    context = getMaskedContext(workInProgress, unmaskedContext);
+  }
+
+  prepareToReadContext(workInProgress, renderLanes);
+  let value;
+  let hasId;
+
+  {
+    markComponentRenderStarted(workInProgress);
+  }
+
+  {
+    value = renderWithHooks(null, workInProgress, Component, props, context, renderLanes);
+    hasId = checkDidRenderIdHook();
+  }
+
+  {
+    markComponentRenderStopped();
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+
+  if ( // Run these checks in production only if the flag is off.
+  // Eventually we'll delete this branch altogether.
+  typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) {
+
+
+    workInProgress.tag = ClassComponent; // Throw out any hooks that were used.
+
+    workInProgress.memoizedState = null;
+    workInProgress.updateQueue = null; // Push context providers early to prevent context stack mismatches.
+    // During mounting we don't know the child context yet as the instance doesn't exist.
+    // We will invalidate the child context in finishClassComponent() right after rendering.
+
+    let hasContext = false;
+
+    if (isContextProvider(Component)) {
+      hasContext = true;
+      pushContextProvider(workInProgress);
+    } else {
+      hasContext = false;
+    }
+
+    workInProgress.memoizedState = value.state !== null && value.state !== undefined ? value.state : null;
+    initializeUpdateQueue(workInProgress);
+    adoptClassInstance(workInProgress, value);
+    mountClassInstance(workInProgress, Component, props, renderLanes);
+    return finishClassComponent(null, workInProgress, Component, true, hasContext, renderLanes);
+  } else {
+    // Proceed under the assumption that this is a function component
+    workInProgress.tag = FunctionComponent;
+
+    if (getIsHydrating() && hasId) {
+      pushMaterializedTreeId(workInProgress);
+    }
+
+    reconcileChildren(null, workInProgress, value, renderLanes);
+
+    return workInProgress.child;
+  }
+}
+
+const SUSPENDED_MARKER = {
+  dehydrated: null,
+  treeContext: null,
+  retryLane: NoLane
+};
+
+function mountSuspenseOffscreenState(renderLanes) {
+  return {
+    baseLanes: renderLanes,
+    cachePool: getSuspendedCache()
+  };
+}
+
+function updateSuspenseOffscreenState(prevOffscreenState, renderLanes) {
+  let cachePool = null;
+
+  {
+    const prevCachePool = prevOffscreenState.cachePool;
+
+    if (prevCachePool !== null) {
+      const parentCache = CacheContext._currentValue ;
+
+      if (prevCachePool.parent !== parentCache) {
+        // Detected a refresh in the parent. This overrides any previously
+        // suspended cache.
+        cachePool = {
+          parent: parentCache,
+          pool: parentCache
+        };
+      } else {
+        // We can reuse the cache from last time. The only thing that would have
+        // overridden it is a parent refresh, which we checked for above.
+        cachePool = prevCachePool;
+      }
+    } else {
+      // If there's no previous cache pool, grab the current one.
+      cachePool = getSuspendedCache();
+    }
+  }
+
+  return {
+    baseLanes: mergeLanes(prevOffscreenState.baseLanes, renderLanes),
+    cachePool
+  };
+} // TODO: Probably should inline this back
+
+
+function shouldRemainOnFallback(current, workInProgress, renderLanes) {
+  // If we're already showing a fallback, there are cases where we need to
+  // remain on that fallback regardless of whether the content has resolved.
+  // For example, SuspenseList coordinates when nested content appears.
+  // TODO: For compatibility with offscreen prerendering, this should also check
+  // whether the current fiber (if it exists) was visible in the previous tree.
+  if (current !== null) {
+    const suspenseState = current.memoizedState;
+
+    if (suspenseState === null) {
+      // Currently showing content. Don't hide it, even if ForceSuspenseFallback
+      // is true. More precise name might be "ForceRemainSuspenseFallback".
+      // Note: This is a factoring smell. Can't remain on a fallback if there's
+      // no fallback to remain on.
+      return false;
+    }
+  } // Not currently showing content. Consult the Suspense context.
+
+
+  const suspenseContext = suspenseStackCursor.current;
+  return hasSuspenseListContext(suspenseContext, ForceSuspenseFallback);
+}
+
+function getRemainingWorkInPrimaryTree(current, renderLanes) {
+  // TODO: Should not remove render lanes that were pinged during this render
+  return removeLanes(current.childLanes, renderLanes);
+}
+
+function updateSuspenseComponent(current, workInProgress, renderLanes) {
+  const nextProps = workInProgress.pendingProps; // This is used by DevTools to force a boundary to suspend.
+
+  let showFallback = false;
+  const didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
+
+  if (didSuspend || shouldRemainOnFallback(current)) {
+    // Something in this boundary's subtree already suspended. Switch to
+    // rendering the fallback children.
+    showFallback = true;
+    workInProgress.flags &= ~DidCapture;
+  } // OK, the next part is confusing. We're about to reconcile the Suspense
+  // boundary's children. This involves some custom reconciliation logic. Two
+  // main reasons this is so complicated.
+  //
+  // First, Legacy Mode has different semantics for backwards compatibility. The
+  // primary tree will commit in an inconsistent state, so when we do the
+  // second pass to render the fallback, we do some exceedingly, uh, clever
+  // hacks to make that not totally break. Like transferring effects and
+  // deletions from hidden tree. In Concurrent Mode, it's much simpler,
+  // because we bailout on the primary tree completely and leave it in its old
+  // state, no effects. Same as what we do for Offscreen (except that
+  // Offscreen doesn't have the first render pass).
+  //
+  // Second is hydration. During hydration, the Suspense fiber has a slightly
+  // different layout, where the child points to a dehydrated fragment, which
+  // contains the DOM rendered by the server.
+  //
+  // Third, even if you set all that aside, Suspense is like error boundaries in
+  // that we first we try to render one tree, and if that fails, we render again
+  // and switch to a different tree. Like a try/catch block. So we have to track
+  // which branch we're currently rendering. Ideally we would model this using
+  // a stack.
+
+
+  if (current === null) {
+    // Initial mount
+    // Special path for hydration
+    // If we're currently hydrating, try to hydrate this boundary.
+    if (getIsHydrating()) {
+      // We must push the suspense handler context *before* attempting to
+      // hydrate, to avoid a mismatch in case it errors.
+      if (showFallback) {
+        pushPrimaryTreeSuspenseHandler(workInProgress);
+      } else {
+        pushFallbackTreeSuspenseHandler(workInProgress);
+      }
+
+      tryToClaimNextHydratableSuspenseInstance(workInProgress); // This could've been a dehydrated suspense component.
+
+      const suspenseState = workInProgress.memoizedState;
+
+      if (suspenseState !== null) {
+        const dehydrated = suspenseState.dehydrated;
+
+        if (dehydrated !== null) {
+          return mountDehydratedSuspenseComponent(workInProgress, dehydrated);
+        }
+      } // If hydration didn't succeed, fall through to the normal Suspense path.
+      // To avoid a stack mismatch we need to pop the Suspense handler that we
+      // pushed above. This will become less awkward when move the hydration
+      // logic to its own fiber.
+
+
+      popSuspenseHandler(workInProgress);
+    }
+
+    const nextPrimaryChildren = nextProps.children;
+    const nextFallbackChildren = nextProps.fallback;
+
+    if (showFallback) {
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      const fallbackFragment = mountSuspenseFallbackChildren(workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);
+      const primaryChildFragment = workInProgress.child;
+      primaryChildFragment.memoizedState = mountSuspenseOffscreenState(renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+
+      return fallbackFragment;
+    } else {
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      return mountSuspensePrimaryChildren(workInProgress, nextPrimaryChildren);
+    }
+  } else {
+    // This is an update.
+    // Special path for hydration
+    const prevState = current.memoizedState;
+
+    if (prevState !== null) {
+      const dehydrated = prevState.dehydrated;
+
+      if (dehydrated !== null) {
+        return updateDehydratedSuspenseComponent(current, workInProgress, didSuspend, nextProps, dehydrated, prevState, renderLanes);
+      }
+    }
+
+    if (showFallback) {
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      const nextFallbackChildren = nextProps.fallback;
+      const nextPrimaryChildren = nextProps.children;
+      const fallbackChildFragment = updateSuspenseFallbackChildren(current, workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);
+      const primaryChildFragment = workInProgress.child;
+      const prevOffscreenState = current.child.memoizedState;
+      primaryChildFragment.memoizedState = prevOffscreenState === null ? mountSuspenseOffscreenState(renderLanes) : updateSuspenseOffscreenState(prevOffscreenState, renderLanes);
+
+      primaryChildFragment.childLanes = getRemainingWorkInPrimaryTree(current, renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+      return fallbackChildFragment;
+    } else {
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      const nextPrimaryChildren = nextProps.children;
+      const primaryChildFragment = updateSuspensePrimaryChildren(current, workInProgress, nextPrimaryChildren, renderLanes);
+      workInProgress.memoizedState = null;
+      return primaryChildFragment;
+    }
+  }
+}
+
+function mountSuspensePrimaryChildren(workInProgress, primaryChildren, renderLanes) {
+  const mode = workInProgress.mode;
+  const primaryChildProps = {
+    mode: 'visible',
+    children: primaryChildren
+  };
+  const primaryChildFragment = mountWorkInProgressOffscreenFiber(primaryChildProps, mode);
+  primaryChildFragment.return = workInProgress;
+  workInProgress.child = primaryChildFragment;
+  return primaryChildFragment;
+}
+
+function mountSuspenseFallbackChildren(workInProgress, primaryChildren, fallbackChildren, renderLanes) {
+  const mode = workInProgress.mode;
+  const progressedPrimaryFragment = workInProgress.child;
+  const primaryChildProps = {
+    mode: 'hidden',
+    children: primaryChildren
+  };
+  let primaryChildFragment;
+  let fallbackChildFragment;
+
+  if ((mode & ConcurrentMode) === NoMode && progressedPrimaryFragment !== null) {
+    // In legacy mode, we commit the primary tree as if it successfully
+    // completed, even though it's in an inconsistent state.
+    primaryChildFragment = progressedPrimaryFragment;
+    primaryChildFragment.childLanes = NoLanes;
+    primaryChildFragment.pendingProps = primaryChildProps;
+
+    if (workInProgress.mode & ProfileMode) {
+      // Reset the durations from the first pass so they aren't included in the
+      // final amounts. This seems counterintuitive, since we're intentionally
+      // not measuring part of the render phase, but this makes it match what we
+      // do in Concurrent Mode.
+      primaryChildFragment.actualDuration = 0;
+      primaryChildFragment.actualStartTime = -1;
+      primaryChildFragment.selfBaseDuration = 0;
+      primaryChildFragment.treeBaseDuration = 0;
+    }
+
+    fallbackChildFragment = createFiberFromFragment(fallbackChildren, mode, renderLanes, null);
+  } else {
+    primaryChildFragment = mountWorkInProgressOffscreenFiber(primaryChildProps, mode);
+    fallbackChildFragment = createFiberFromFragment(fallbackChildren, mode, renderLanes, null);
+  }
+
+  primaryChildFragment.return = workInProgress;
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
+  return fallbackChildFragment;
+}
+
+function mountWorkInProgressOffscreenFiber(offscreenProps, mode, renderLanes) {
+  // The props argument to `createFiberFromOffscreen` is `any` typed, so we use
+  // this wrapper function to constrain it.
+  return createFiberFromOffscreen(offscreenProps, mode, NoLanes, null);
+}
+
+function updateWorkInProgressOffscreenFiber(current, offscreenProps) {
+  // The props argument to `createWorkInProgress` is `any` typed, so we use this
+  // wrapper function to constrain it.
+  return createWorkInProgress(current, offscreenProps);
+}
+
+function updateSuspensePrimaryChildren(current, workInProgress, primaryChildren, renderLanes) {
+  const currentPrimaryChildFragment = current.child;
+  const currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
+  const primaryChildFragment = updateWorkInProgressOffscreenFiber(currentPrimaryChildFragment, {
+    mode: 'visible',
+    children: primaryChildren
+  });
+
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    primaryChildFragment.lanes = renderLanes;
+  }
+
+  primaryChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = null;
+
+  if (currentFallbackChildFragment !== null) {
+    // Delete the fallback child fragment
+    const deletions = workInProgress.deletions;
+
+    if (deletions === null) {
+      workInProgress.deletions = [currentFallbackChildFragment];
+      workInProgress.flags |= ChildDeletion;
+    } else {
+      deletions.push(currentFallbackChildFragment);
+    }
+  }
+
+  workInProgress.child = primaryChildFragment;
+  return primaryChildFragment;
+}
+
+function updateSuspenseFallbackChildren(current, workInProgress, primaryChildren, fallbackChildren, renderLanes) {
+  const mode = workInProgress.mode;
+  const currentPrimaryChildFragment = current.child;
+  const currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
+  const primaryChildProps = {
+    mode: 'hidden',
+    children: primaryChildren
+  };
+  let primaryChildFragment;
+
+  if ( // In legacy mode, we commit the primary tree as if it successfully
+  // completed, even though it's in an inconsistent state.
+  (mode & ConcurrentMode) === NoMode && // Make sure we're on the second pass, i.e. the primary child fragment was
+  // already cloned. In legacy mode, the only case where this isn't true is
+  // when DevTools forces us to display a fallback; we skip the first render
+  // pass entirely and go straight to rendering the fallback. (In Concurrent
+  // Mode, SuspenseList can also trigger this scenario, but this is a legacy-
+  // only codepath.)
+  workInProgress.child !== currentPrimaryChildFragment) {
+    const progressedPrimaryFragment = workInProgress.child;
+    primaryChildFragment = progressedPrimaryFragment;
+    primaryChildFragment.childLanes = NoLanes;
+    primaryChildFragment.pendingProps = primaryChildProps;
+
+    if (workInProgress.mode & ProfileMode) {
+      // Reset the durations from the first pass so they aren't included in the
+      // final amounts. This seems counterintuitive, since we're intentionally
+      // not measuring part of the render phase, but this makes it match what we
+      // do in Concurrent Mode.
+      primaryChildFragment.actualDuration = 0;
+      primaryChildFragment.actualStartTime = -1;
+      primaryChildFragment.selfBaseDuration = currentPrimaryChildFragment.selfBaseDuration;
+      primaryChildFragment.treeBaseDuration = currentPrimaryChildFragment.treeBaseDuration;
+    } // The fallback fiber was added as a deletion during the first pass.
+    // However, since we're going to remain on the fallback, we no longer want
+    // to delete it.
+
+
+    workInProgress.deletions = null;
+  } else {
+    primaryChildFragment = updateWorkInProgressOffscreenFiber(currentPrimaryChildFragment, primaryChildProps); // Since we're reusing a current tree, we need to reuse the flags, too.
+    // (We don't do this in legacy mode, because in legacy mode we don't re-use
+    // the current tree; see previous branch.)
+
+    primaryChildFragment.subtreeFlags = currentPrimaryChildFragment.subtreeFlags & StaticMask;
+  }
+
+  let fallbackChildFragment;
+
+  if (currentFallbackChildFragment !== null) {
+    fallbackChildFragment = createWorkInProgress(currentFallbackChildFragment, fallbackChildren);
+  } else {
+    fallbackChildFragment = createFiberFromFragment(fallbackChildren, mode, renderLanes, null); // Needs a placement effect because the parent (the Suspense boundary) already
+    // mounted but this is a new fiber.
+
+    fallbackChildFragment.flags |= Placement;
+  }
+
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
+  return fallbackChildFragment;
+}
+
+function retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, recoverableError) {
+  // Falling back to client rendering. Because this has performance
+  // implications, it's considered a recoverable error, even though the user
+  // likely won't observe anything wrong with the UI.
+  //
+  // The error is passed in as an argument to enforce that every caller provide
+  // a custom message, or explicitly opt out (currently the only path that opts
+  // out is legacy mode; every concurrent path provides an error).
+  if (recoverableError !== null) {
+    queueHydrationError(recoverableError);
+  } // This will add the old fiber to the deletion list
+
+
+  reconcileChildFibers(workInProgress, current.child, null, renderLanes); // We're now not suspended nor dehydrated.
+
+  const nextProps = workInProgress.pendingProps;
+  const primaryChildren = nextProps.children;
+  const primaryChildFragment = mountSuspensePrimaryChildren(workInProgress, primaryChildren); // Needs a placement effect because the parent (the Suspense boundary) already
+  // mounted but this is a new fiber.
+
+  primaryChildFragment.flags |= Placement;
+  workInProgress.memoizedState = null;
+  return primaryChildFragment;
+}
+
+function mountSuspenseFallbackAfterRetryWithoutHydrating(current, workInProgress, primaryChildren, fallbackChildren, renderLanes) {
+  const fiberMode = workInProgress.mode;
+  const primaryChildProps = {
+    mode: 'visible',
+    children: primaryChildren
+  };
+  const primaryChildFragment = mountWorkInProgressOffscreenFiber(primaryChildProps, fiberMode);
+  const fallbackChildFragment = createFiberFromFragment(fallbackChildren, fiberMode, renderLanes, null); // Needs a placement effect because the parent (the Suspense
+  // boundary) already mounted but this is a new fiber.
+
+  fallbackChildFragment.flags |= Placement;
+  primaryChildFragment.return = workInProgress;
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
+
+  if ((workInProgress.mode & ConcurrentMode) !== NoMode) {
+    // We will have dropped the effect list which contains the
+    // deletion. We need to reconcile to delete the current child.
+    reconcileChildFibers(workInProgress, current.child, null, renderLanes);
+  }
+
+  return fallbackChildFragment;
+}
+
+function mountDehydratedSuspenseComponent(workInProgress, suspenseInstance, renderLanes) {
+  // During the first pass, we'll bail out and not drill into the children.
+  // Instead, we'll leave the content in place and try to hydrate it later.
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+
+    workInProgress.lanes = laneToLanes(SyncLane);
+  } else if (isSuspenseInstanceFallback(suspenseInstance)) {
+    // This is a client-only boundary. Since we won't get any content from the server
+    // for this, we need to schedule that at a higher priority based on when it would
+    // have timed out. In theory we could render it in this pass but it would have the
+    // wrong priority associated with it and will prevent hydration of parent path.
+    // Instead, we'll leave work left on it to render it in a separate commit.
+    // TODO This time should be the time at which the server rendered response that is
+    // a parent to this boundary was displayed. However, since we currently don't have
+    // a protocol to transfer that time, we'll just estimate it by using the current
+    // time. This will mean that Suspense timeouts are slightly shifted to later than
+    // they should be.
+    // Schedule a normal pri update to render this content.
+    workInProgress.lanes = laneToLanes(DefaultHydrationLane);
+  } else {
+    // We'll continue hydrating the rest at offscreen priority since we'll already
+    // be showing the right content coming from the server, it is no rush.
+    workInProgress.lanes = laneToLanes(OffscreenLane);
+  }
+
+  return null;
+}
+
+function updateDehydratedSuspenseComponent(current, workInProgress, didSuspend, nextProps, suspenseInstance, suspenseState, renderLanes) {
+  if (!didSuspend) {
+    // This is the first render pass. Attempt to hydrate.
+    pushPrimaryTreeSuspenseHandler(workInProgress); // We should never be hydrating at this point because it is the first pass,
+
+    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, null);
+    }
+
+    if (isSuspenseInstanceFallback(suspenseInstance)) {
+      // This boundary is in a permanent fallback state. In this case, we'll never
+      // get an update and we'll never be able to hydrate the final content. Let's just try the
+      // client side render instead.
+      let digest;
+      let stack;
+
+      {
+        var _getSuspenseInstanceF2 = getSuspenseInstanceFallbackErrorDetails(suspenseInstance);
+
+        digest = _getSuspenseInstanceF2.digest;
+      }
+
+      let capturedValue = null; // TODO: Figure out a better signal than encoding a magic digest value.
+
+      {
+        let error;
+
+        {
+          error = Error(formatProdErrorMessage(419));
+        }
+
+        error.digest = digest;
+        capturedValue = createCapturedValue(error, digest, stack);
+      }
+
+      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, capturedValue);
+    }
+    // any context has changed, we need to treat is as if the input might have changed.
+
+
+    const hasContextChanged = includesSomeLane(renderLanes, current.childLanes);
+
+    if (didReceiveUpdate || hasContextChanged) {
+      // This boundary has changed since the first render. This means that we are now unable to
+      // hydrate it. We might still be able to hydrate it using a higher priority lane.
+      const root = getWorkInProgressRoot();
+
+      if (root !== null) {
+        const attemptHydrationAtLane = getBumpedLaneForHydration(root, renderLanes);
+
+        if (attemptHydrationAtLane !== NoLane && attemptHydrationAtLane !== suspenseState.retryLane) {
+          // Intentionally mutating since this render will get interrupted. This
+          // is one of the very rare times where we mutate the current tree
+          // during the render phase.
+          suspenseState.retryLane = attemptHydrationAtLane;
+          enqueueConcurrentRenderForLane(current, attemptHydrationAtLane);
+          scheduleUpdateOnFiber(root, current, attemptHydrationAtLane); // Throw a special object that signals to the work loop that it should
+          // interrupt the current render.
+          //
+          // Because we're inside a React-only execution stack, we don't
+          // strictly need to throw here — we could instead modify some internal
+          // work loop state. But using an exception means we don't need to
+          // check for this case on every iteration of the work loop. So doing
+          // it this way moves the check out of the fast path.
+
+          throw SelectiveHydrationException;
+        }
+      } // If we did not selectively hydrate, we'll continue rendering without
+      // hydrating. Mark this tree as suspended to prevent it from committing
+      // outside a transition.
+      //
+      // This path should only happen if the hydration lane already suspended.
+      // Currently, it also happens during sync updates because there is no
+      // hydration lane for sync updates.
+      // TODO: We should ideally have a sync hydration lane that we can apply to do
+      // a pass where we hydrate this subtree in place using the previous Context and then
+      // reapply the update afterwards.
+
+
+      if (isSuspenseInstancePending(suspenseInstance)) ; else {
+        renderDidSuspendDelayIfPossible();
+      }
+
+      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, null);
+    } else if (isSuspenseInstancePending(suspenseInstance)) {
+      // This component is still pending more data from the server, so we can't hydrate its
+      // content. We treat it as if this component suspended itself. It might seem as if
+      // we could just try to render it client-side instead. However, this will perform a
+      // lot of unnecessary work and is unlikely to complete since it often will suspend
+      // on missing data anyway. Additionally, the server might be able to render more
+      // than we can on the client yet. In that case we'd end up with more fallback states
+      // on the client than if we just leave it alone. If the server times out or errors
+      // these should update this boundary to the permanent Fallback state instead.
+      // Mark it as having captured (i.e. suspended).
+      workInProgress.flags |= DidCapture; // Leave the child in place. I.e. the dehydrated fragment.
+
+      workInProgress.child = current.child; // Register a callback to retry this boundary once the server has sent the result.
+
+      const retry = retryDehydratedSuspenseBoundary.bind(null, current);
+      registerSuspenseInstanceRetry(suspenseInstance, retry);
+      return null;
+    } else {
+      // This is the first attempt.
+      reenterHydrationStateFromDehydratedSuspenseInstance(workInProgress, suspenseInstance, suspenseState.treeContext);
+      const primaryChildren = nextProps.children;
+      const primaryChildFragment = mountSuspensePrimaryChildren(workInProgress, primaryChildren); // Mark the children as hydrating. This is a fast path to know whether this
+      // tree is part of a hydrating tree. This is used to determine if a child
+      // node has fully mounted yet, and for scheduling event replaying.
+      // Conceptually this is similar to Placement in that a new subtree is
+      // inserted into the React tree here. It just happens to not need DOM
+      // mutations because it already exists.
+
+      primaryChildFragment.flags |= Hydrating;
+      return primaryChildFragment;
+    }
+  } else {
+    // This is the second render pass. We already attempted to hydrated, but
+    // something either suspended or errored.
+    if (workInProgress.flags & ForceClientRender) {
+      // Something errored during hydration. Try again without hydrating.
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      workInProgress.flags &= ~ForceClientRender;
+      const capturedValue = createCapturedValue(Error(formatProdErrorMessage(422)));
+      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, capturedValue);
+    } else if (workInProgress.memoizedState !== null) {
+      // Something suspended and we should still be in dehydrated mode.
+      // Leave the existing child in place.
+      // Push to avoid a mismatch
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      workInProgress.child = current.child; // The dehydrated completion pass expects this flag to be there
+      // but the normal suspense pass doesn't.
+
+      workInProgress.flags |= DidCapture;
+      return null;
+    } else {
+      // Suspended but we should no longer be in dehydrated mode.
+      // Therefore we now have to render the fallback.
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      const nextPrimaryChildren = nextProps.children;
+      const nextFallbackChildren = nextProps.fallback;
+      const fallbackChildFragment = mountSuspenseFallbackAfterRetryWithoutHydrating(current, workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);
+      const primaryChildFragment = workInProgress.child;
+      primaryChildFragment.memoizedState = mountSuspenseOffscreenState(renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+      return fallbackChildFragment;
+    }
+  }
+}
+
+function scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {
+  fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
+  const alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+  }
+
+  scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);
+}
+
+function propagateSuspenseContextChange(workInProgress, firstChild, renderLanes) {
+  // Mark any Suspense boundaries with fallbacks as having work to do.
+  // If they were previously forced into fallbacks, they may now be able
+  // to unblock.
+  let node = firstChild;
+
+  while (node !== null) {
+    if (node.tag === SuspenseComponent) {
+      const state = node.memoizedState;
+
+      if (state !== null) {
+        scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);
+      }
+    } else if (node.tag === SuspenseListComponent) {
+      // If the tail is hidden there might not be an Suspense boundaries
+      // to schedule work on. In this case we have to schedule it on the
+      // list itself.
+      // We don't have to traverse to the children of the list since
+      // the list will propagate the change when it rerenders.
+      scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);
+    } else if (node.child !== null) {
+      node.child.return = node;
+      node = node.child;
+      continue;
+    }
+
+    if (node === workInProgress) {
+      return;
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    while (node.sibling === null) {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      if (node.return === null || node.return === workInProgress) {
+        return;
+      }
+
+      node = node.return;
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    node.sibling.return = node.return;
+    node = node.sibling;
+  }
+}
+
+function findLastContentRow(firstChild) {
+  // This is going to find the last row among these children that is already
+  // showing content on the screen, as opposed to being in fallback state or
+  // new. If a row has multiple Suspense boundaries, any of them being in the
+  // fallback state, counts as the whole row being in a fallback state.
+  // Note that the "rows" will be workInProgress, but any nested children
+  // will still be current since we haven't rendered them yet. The mounted
+  // order may not be the same as the new order. We use the new order.
+  let row = firstChild;
+  let lastContentRow = null;
+
+  while (row !== null) {
+    const currentRow = row.alternate; // New rows can't be content rows.
+
+    if (currentRow !== null && findFirstSuspended(currentRow) === null) {
+      lastContentRow = row;
+    }
+
+    row = row.sibling;
+  }
+
+  return lastContentRow;
+}
+
+function initSuspenseListRenderState(workInProgress, isBackwards, tail, lastContentRow, tailMode) {
+  const renderState = workInProgress.memoizedState;
+
+  if (renderState === null) {
+    workInProgress.memoizedState = {
+      isBackwards: isBackwards,
+      rendering: null,
+      renderingStartTime: 0,
+      last: lastContentRow,
+      tail: tail,
+      tailMode: tailMode
+    };
+  } else {
+    // We can reuse the existing object from previous renders.
+    renderState.isBackwards = isBackwards;
+    renderState.rendering = null;
+    renderState.renderingStartTime = 0;
+    renderState.last = lastContentRow;
+    renderState.tail = tail;
+    renderState.tailMode = tailMode;
+  }
+} // This can end up rendering this component multiple passes.
+// The first pass splits the children fibers into two sets. A head and tail.
+// We first render the head. If anything is in fallback state, we do another
+// pass through beginWork to rerender all children (including the tail) with
+// the force suspend context. If the first render didn't have anything in
+// in fallback state. Then we render each row in the tail one-by-one.
+// That happens in the completeWork phase without going back to beginWork.
+
+
+function updateSuspenseListComponent(current, workInProgress, renderLanes) {
+  const nextProps = workInProgress.pendingProps;
+  const revealOrder = nextProps.revealOrder;
+  const tailMode = nextProps.tail;
+  const newChildren = nextProps.children;
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  let suspenseContext = suspenseStackCursor.current;
+  const shouldForceFallback = hasSuspenseListContext(suspenseContext, ForceSuspenseFallback);
+
+  if (shouldForceFallback) {
+    suspenseContext = setShallowSuspenseListContext(suspenseContext, ForceSuspenseFallback);
+    workInProgress.flags |= DidCapture;
+  } else {
+    const didSuspendBefore = current !== null && (current.flags & DidCapture) !== NoFlags$1;
+
+    if (didSuspendBefore) {
+      // If we previously forced a fallback, we need to schedule work
+      // on any nested boundaries to let them know to try to render
+      // again. This is the same as context updating.
+      propagateSuspenseContextChange(workInProgress, workInProgress.child, renderLanes);
+    }
+
+    suspenseContext = setDefaultShallowSuspenseListContext(suspenseContext);
+  }
+
+  pushSuspenseListContext(workInProgress, suspenseContext);
+
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    // In legacy mode, SuspenseList doesn't work so we just
+    // use make it a noop by treating it as the default revealOrder.
+    workInProgress.memoizedState = null;
+  } else {
+    switch (revealOrder) {
+      case 'forwards':
+        {
+          const lastContentRow = findLastContentRow(workInProgress.child);
+          let tail;
+
+          if (lastContentRow === null) {
+            // The whole list is part of the tail.
+            // TODO: We could fast path by just rendering the tail now.
+            tail = workInProgress.child;
+            workInProgress.child = null;
+          } else {
+            // Disconnect the tail rows after the content row.
+            // We're going to render them separately later.
+            tail = lastContentRow.sibling;
+            lastContentRow.sibling = null;
+          }
+
+          initSuspenseListRenderState(workInProgress, false, // isBackwards
+          tail, lastContentRow, tailMode);
+          break;
+        }
+
+      case 'backwards':
+        {
+          // We're going to find the first row that has existing content.
+          // At the same time we're going to reverse the list of everything
+          // we pass in the meantime. That's going to be our tail in reverse
+          // order.
+          let tail = null;
+          let row = workInProgress.child;
+          workInProgress.child = null;
+
+          while (row !== null) {
+            const currentRow = row.alternate; // New rows can't be content rows.
+
+            if (currentRow !== null && findFirstSuspended(currentRow) === null) {
+              // This is the beginning of the main content.
+              workInProgress.child = row;
+              break;
+            }
+
+            const nextRow = row.sibling;
+            row.sibling = tail;
+            tail = row;
+            row = nextRow;
+          } // TODO: If workInProgress.child is null, we can continue on the tail immediately.
+
+
+          initSuspenseListRenderState(workInProgress, true, // isBackwards
+          tail, null, // last
+          tailMode);
+          break;
+        }
+
+      case 'together':
+        {
+          initSuspenseListRenderState(workInProgress, false, // isBackwards
+          null, // tail
+          null, // last
+          undefined);
+          break;
+        }
+
+      default:
+        {
+          // The default reveal order is the same as not having
+          // a boundary.
+          workInProgress.memoizedState = null;
+        }
+    }
+  }
+
+  return workInProgress.child;
+}
+
+function updatePortalComponent(current, workInProgress, renderLanes) {
+  pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+  const nextChildren = workInProgress.pendingProps;
+
+  if (current === null) {
+    // Portals are special because we don't append the children during mount
+    // but at commit. Therefore we need to track insertions which the normal
+    // flow doesn't do during mount. This doesn't happen at the root because
+    // the root always starts with a "current" with a null child.
+    // TODO: Consider unifying this with how the root works.
+    workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderLanes);
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  }
+
+  return workInProgress.child;
+}
+
+function updateContextProvider(current, workInProgress, renderLanes) {
+  const providerType = workInProgress.type;
+  const context = providerType._context;
+  const newProps = workInProgress.pendingProps;
+  const oldProps = workInProgress.memoizedProps;
+  const newValue = newProps.value;
+
+  pushProvider(workInProgress, context, newValue);
+
+  {
+    if (oldProps !== null) {
+      const oldValue = oldProps.value;
+
+      if (objectIs(oldValue, newValue)) {
+        // No change. Bailout early if children are the same.
+        if (oldProps.children === newProps.children && !hasContextChanged()) {
+          return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+        }
+      } else {
+        // The context value changed. Search for matching consumers and schedule
+        // them to update.
+        propagateContextChange(workInProgress, context, renderLanes);
+      }
+    }
+  }
+
+  const newChildren = newProps.children;
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateContextConsumer(current, workInProgress, renderLanes) {
+  let context = workInProgress.type; // The logic below for Context differs depending on PROD or DEV mode. In
+
+  const newProps = workInProgress.pendingProps;
+  const render = newProps.children;
+
+  prepareToReadContext(workInProgress, renderLanes);
+  const newValue = readContext(context);
+
+  {
+    markComponentRenderStarted(workInProgress);
+  }
+
+  let newChildren;
+
+  {
+    newChildren = render(newValue);
+  }
+
+  {
+    markComponentRenderStopped();
+  } // React DevTools reads this flag.
+
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function markWorkInProgressReceivedUpdate() {
+  didReceiveUpdate = true;
+}
+
+function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    if (current !== null) {
+      // A lazy component only mounts if it suspended inside a non-
+      // concurrent tree, in an inconsistent state. We want to treat it like
+      // a new mount, even though an empty version of it already committed.
+      // Disconnect the alternate pointers.
+      current.alternate = null;
+      workInProgress.alternate = null; // Since this is conceptually a new fiber, schedule a Placement effect
+
+      workInProgress.flags |= Placement;
+    }
+  }
+}
+
+function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
+  if (current !== null) {
+    // Reuse previous dependencies
+    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.
+    {
+      return null;
+    }
+  } // This fiber doesn't have work, but its subtree does. Clone the child
+  // fibers and continue.
+
+
+  cloneChildFibers(current, workInProgress);
+  return workInProgress.child;
+}
+
+function checkScheduledUpdateOrContext(current, renderLanes) {
+  // Before performing an early bailout, we must check if there are pending
+  // updates or context.
+  const updateLanes = current.lanes;
+
+  if (includesSomeLane(updateLanes, renderLanes)) {
+    return true;
+  } // No pending update, but because context is propagated lazily, we need
+
+  return false;
+}
+
+function attemptEarlyBailoutIfNoScheduledUpdate(current, workInProgress, renderLanes) {
+  // This fiber does not have any pending work. Bailout without entering
+  // the begin phase. There's still some bookkeeping we that needs to be done
+  // in this optimized path, mostly pushing stuff onto the stack.
+  switch (workInProgress.tag) {
+    case HostRoot:
+      pushHostRootContext(workInProgress);
+
+      {
+        const cache = current.memoizedState.cache;
+        pushCacheProvider(workInProgress, cache);
+      }
+
+      resetHydrationState();
+      break;
+
+    case HostSingleton:
+    case HostComponent:
+      pushHostContext(workInProgress);
+      break;
+
+    case ClassComponent:
+      {
+        const Component = workInProgress.type;
+
+        if (isContextProvider(Component)) {
+          pushContextProvider(workInProgress);
+        }
+
+        break;
+      }
+
+    case HostPortal:
+      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+      break;
+
+    case ContextProvider:
+      {
+        const newValue = workInProgress.memoizedProps.value;
+        const context = workInProgress.type._context;
+        pushProvider(workInProgress, context, newValue);
+        break;
+      }
+
+    case Profiler:
+      {
+        // Profiler should only call onRender when one of its descendants actually rendered.
+        const 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,
+          const stateNode = workInProgress.stateNode;
+          stateNode.effectDuration = 0;
+          stateNode.passiveEffectDuration = 0;
+        }
+      }
+
+      break;
+
+    case SuspenseComponent:
+      {
+        const state = workInProgress.memoizedState;
+
+        if (state !== null) {
+          if (state.dehydrated !== null) {
+            // We're not going to render the children, so this is just to maintain
+            // push/pop symmetry
+            pushPrimaryTreeSuspenseHandler(workInProgress); // We know that this component will suspend again because if it has
+            // been unsuspended it has committed as a resolved Suspense component.
+            // If it needs to be retried, it should have work scheduled on it.
+
+            workInProgress.flags |= DidCapture; // We should never render the children of a dehydrated boundary until we
+            // upgrade it. We return null instead of bailoutOnAlreadyFinishedWork.
+
+            return null;
+          } // If this boundary is currently timed out, we need to decide
+          // whether to retry the primary children, or to skip over it and
+          // go straight to the fallback. Check the priority of the primary
+          // child fragment.
+
+
+          const primaryChildFragment = workInProgress.child;
+          const primaryChildLanes = primaryChildFragment.childLanes;
+
+          if (includesSomeLane(renderLanes, primaryChildLanes)) {
+            // The primary children have pending work. Use the normal path
+            // to attempt to render the primary children again.
+            return updateSuspenseComponent(current, workInProgress, renderLanes);
+          } else {
+            // The primary child fragment does not have pending work marked
+            // on it
+            pushPrimaryTreeSuspenseHandler(workInProgress); // The primary children do not have pending work with sufficient
+            // priority. Bailout.
+
+            const child = bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+
+            if (child !== null) {
+              // The fallback children have pending work. Skip over the
+              // primary children and work on the fallback.
+              return child.sibling;
+            } else {
+              // Note: We can return `null` here because we already checked
+              // whether there were nested context consumers, via the call to
+              // `bailoutOnAlreadyFinishedWork` above.
+              return null;
+            }
+          }
+        } else {
+          pushPrimaryTreeSuspenseHandler(workInProgress);
+        }
+
+        break;
+      }
+
+    case SuspenseListComponent:
+      {
+        const didSuspendBefore = (current.flags & DidCapture) !== NoFlags$1;
+        let hasChildWork = includesSomeLane(renderLanes, workInProgress.childLanes);
+
+        if (didSuspendBefore) {
+          if (hasChildWork) {
+            // If something was in fallback state last time, and we have all the
+            // same children then we're still in progressive loading state.
+            // Something might get unblocked by state updates or retries in the
+            // tree which will affect the tail. So we need to use the normal
+            // path to compute the correct tail.
+            return updateSuspenseListComponent(current, workInProgress, renderLanes);
+          } // If none of the children had any work, that means that none of
+          // them got retried so they'll still be blocked in the same way
+          // as before. We can fast bail out.
+
+
+          workInProgress.flags |= DidCapture;
+        } // If nothing suspended before and we're rendering the same children,
+        // then the tail doesn't matter. Anything new that suspends will work
+        // in the "together" mode, so we can continue from the state we had.
+
+
+        const renderState = workInProgress.memoizedState;
+
+        if (renderState !== null) {
+          // Reset to the "together" mode in case we've started a different
+          // update in the past but didn't complete it.
+          renderState.rendering = null;
+          renderState.tail = null;
+          renderState.lastEffect = null;
+        }
+
+        pushSuspenseListContext(workInProgress, suspenseStackCursor.current);
+
+        if (hasChildWork) {
+          break;
+        } else {
+          // If none of the children had any work, that means that none of
+          // them got retried so they'll still be blocked in the same way
+          // as before. We can fast bail out.
+          return null;
+        }
+      }
+
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      {
+        // Need to check if the tree still needs to be deferred. This is
+        // almost identical to the logic used in the normal update path,
+        // so we'll just enter that. The only difference is we'll bail out
+        // at the next level instead of this one, because the child props
+        // have not changed. Which is fine.
+        // TODO: Probably should refactor `beginWork` to split the bailout
+        // path from the normal path. I'm tempted to do a labeled break here
+        // but I won't :)
+        workInProgress.lanes = NoLanes;
+        return updateOffscreenComponent(current, workInProgress, renderLanes);
+      }
+
+    case CacheComponent:
+      {
+        {
+          const cache = current.memoizedState.cache;
+          pushCacheProvider(workInProgress, cache);
+        }
+
+        break;
+      }
+  }
+
+  return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+}
+
+function beginWork$1(current, workInProgress, renderLanes) {
+
+  if (current !== null) {
+    const oldProps = current.memoizedProps;
+    const newProps = workInProgress.pendingProps;
+
+    if (oldProps !== newProps || hasContextChanged() || ( // Force a re-render if the implementation changed due to hot reload:
+    false)) {
+      // If props or context changed, mark the fiber as having performed work.
+      // This may be unset if the props are determined to be equal later (memo).
+      didReceiveUpdate = true;
+    } else {
+      // Neither props nor legacy context changes. Check if there's a pending
+      // update or context change.
+      const hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(current, renderLanes);
+
+      if (!hasScheduledUpdateOrContext && // If this is the second pass of an error or suspense boundary, there
+      // may not be work scheduled on `current`, so we check for this flag.
+      (workInProgress.flags & DidCapture) === NoFlags$1) {
+        // No pending updates or context. Bail out now.
+        didReceiveUpdate = false;
+        return attemptEarlyBailoutIfNoScheduledUpdate(current, workInProgress, renderLanes);
+      }
+
+      if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags$1) {
+        // This is a special case that only exists for legacy mode.
+        // See https://github.com/facebook/react/pull/19216.
+        didReceiveUpdate = true;
+      } else {
+        // An update was scheduled on this fiber, but there are no new props
+        // nor legacy context. Set this to false. If an update queue or context
+        // consumer produces a changed value, it will set this to true. Otherwise,
+        // the component will assume the children have not changed and bail out.
+        didReceiveUpdate = false;
+      }
+    }
+  } else {
+    didReceiveUpdate = false;
+
+    if (getIsHydrating() && isForkedChild(workInProgress)) {
+      // Check if this child belongs to a list of muliple children in
+      // its parent.
+      //
+      // In a true multi-threaded implementation, we would render children on
+      // parallel threads. This would represent the beginning of a new render
+      // thread for this subtree.
+      //
+      // We only use this for id generation during hydration, which is why the
+      // logic is located in this special branch.
+      const slotIndex = workInProgress.index;
+      const numberOfForks = getForksAtLevel();
+      pushTreeId(workInProgress, numberOfForks, slotIndex);
+    }
+  } // Before entering the begin phase, clear pending update priority.
+  // TODO: This assumes that we're about to evaluate the component and process
+  // the update queue. However, there's an exception: SimpleMemoComponent
+  // sometimes bails out later in the begin phase. This indicates that we should
+  // move this assignment out of the common path and into each branch.
+
+
+  workInProgress.lanes = NoLanes;
+
+  switch (workInProgress.tag) {
+    case IndeterminateComponent:
+      {
+        return mountIndeterminateComponent(current, workInProgress, workInProgress.type, renderLanes);
+      }
+
+    case LazyComponent:
+      {
+        const elementType = workInProgress.elementType;
+        return mountLazyComponent(current, workInProgress, elementType, renderLanes);
+      }
+
+    case FunctionComponent:
+      {
+        const Component = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps;
+        const resolvedProps = workInProgress.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        return updateFunctionComponent(current, workInProgress, Component, resolvedProps, renderLanes);
+      }
+
+    case ClassComponent:
+      {
+        const Component = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps;
+        const resolvedProps = workInProgress.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        return updateClassComponent(current, workInProgress, Component, resolvedProps, renderLanes);
+      }
+
+    case HostRoot:
+      return updateHostRoot(current, workInProgress, renderLanes);
+
+    case HostHoistable:
+      {
+        return updateHostHoistable(current, workInProgress);
+      }
+
+    // Fall through
+
+    case HostSingleton:
+      {
+        return updateHostSingleton(current, workInProgress, renderLanes);
+      }
+
+    // Fall through
+
+    case HostComponent:
+      return updateHostComponent$1(current, workInProgress, renderLanes);
+
+    case HostText:
+      return updateHostText$1(current, workInProgress);
+
+    case SuspenseComponent:
+      return updateSuspenseComponent(current, workInProgress, renderLanes);
+
+    case HostPortal:
+      return updatePortalComponent(current, workInProgress, renderLanes);
+
+    case ForwardRef:
+      {
+        const type = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps;
+        const resolvedProps = workInProgress.elementType === type ? unresolvedProps : resolveDefaultProps(type, unresolvedProps);
+        return updateForwardRef(current, workInProgress, type, resolvedProps, renderLanes);
+      }
+
+    case Fragment:
+      return updateFragment(current, workInProgress, renderLanes);
+
+    case Mode:
+      return updateMode(current, workInProgress, renderLanes);
+
+    case Profiler:
+      return updateProfiler(current, workInProgress, renderLanes);
+
+    case ContextProvider:
+      return updateContextProvider(current, workInProgress, renderLanes);
+
+    case ContextConsumer:
+      return updateContextConsumer(current, workInProgress, renderLanes);
+
+    case MemoComponent:
+      {
+        const type = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps; // Resolve outer props first, then resolve inner props.
+
+        let resolvedProps = resolveDefaultProps(type, unresolvedProps);
+
+        resolvedProps = resolveDefaultProps(type.type, resolvedProps);
+        return updateMemoComponent(current, workInProgress, type, resolvedProps, renderLanes);
+      }
+
+    case SimpleMemoComponent:
+      {
+        return updateSimpleMemoComponent(current, workInProgress, workInProgress.type, workInProgress.pendingProps, renderLanes);
+      }
+
+    case IncompleteClassComponent:
+      {
+        const Component = workInProgress.type;
+        const unresolvedProps = workInProgress.pendingProps;
+        const resolvedProps = workInProgress.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        return mountIncompleteClassComponent(current, workInProgress, Component, resolvedProps, renderLanes);
+      }
+
+    case SuspenseListComponent:
+      {
+        return updateSuspenseListComponent(current, workInProgress, renderLanes);
+      }
+
+    case ScopeComponent:
+      {
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        return updateOffscreenComponent(current, workInProgress, renderLanes);
+      }
+
+    case LegacyHiddenComponent:
+      {
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        {
+          return updateCacheComponent(current, workInProgress, renderLanes);
+        }
+      }
+  }
+
+  throw Error(formatProdErrorMessage(156, workInProgress.tag));
+}
+
+const valueCursor = createCursor(null);
+
+let currentlyRenderingFiber = null;
+let lastContextDependency = null;
+let lastFullyObservedContext = null;
+function resetContextDependencies() {
+  // This is called right before React yields execution, to ensure `readContext`
+  // cannot be called outside the render phase.
+  currentlyRenderingFiber = null;
+  lastContextDependency = null;
+  lastFullyObservedContext = null;
+}
+function pushProvider(providerFiber, context, nextValue) {
+  {
+    push(valueCursor, context._currentValue);
+    context._currentValue = nextValue;
+  }
+}
+function popProvider(context, providerFiber) {
+  const currentValue = valueCursor.current;
+
+  {
+    {
+      context._currentValue = currentValue;
+    }
+  }
+
+  pop(valueCursor);
+}
+function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
+  // Update the child lanes of all the ancestors, including the alternates.
+  let node = parent;
+
+  while (node !== null) {
+    const alternate = node.alternate;
+
+    if (!isSubsetOfLanes(node.childLanes, renderLanes)) {
+      node.childLanes = mergeLanes(node.childLanes, renderLanes);
+
+      if (alternate !== null) {
+        alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
+      }
+    } else if (alternate !== null && !isSubsetOfLanes(alternate.childLanes, renderLanes)) {
+      alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
+    } else ;
+
+    if (node === propagationRoot) {
+      break;
+    }
+
+    node = node.return;
+  }
+}
+function propagateContextChange(workInProgress, context, renderLanes) {
+  {
+    propagateContextChange_eager(workInProgress, context, renderLanes);
+  }
+}
+
+function propagateContextChange_eager(workInProgress, context, renderLanes) {
+
+  let 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) {
+    let nextFiber; // Visit this fiber.
+
+    const list = fiber.dependencies;
+
+    if (list !== null) {
+      nextFiber = fiber.child;
+      let dependency = list.firstContext;
+
+      while (dependency !== null) {
+        // Check if the context matches.
+        if (dependency.context === context) {
+          // Match! Schedule an update on this fiber.
+          if (fiber.tag === ClassComponent) {
+            // Schedule a force update on the work-in-progress.
+            const lane = pickArbitraryLane(renderLanes);
+            const update = createUpdate(lane);
+            update.tag = ForceUpdate; // TODO: Because we don't have a work-in-progress, this will add the
+            // update to the current fiber, too, which means it will persist even if
+            // this render is thrown away. Since it's a race condition, not sure it's
+            // worth fixing.
+            // Inlined `enqueueUpdate` to remove interleaved update check
+
+            const updateQueue = fiber.updateQueue;
+
+            if (updateQueue === null) ; else {
+              const sharedQueue = updateQueue.shared;
+              const pending = sharedQueue.pending;
+
+              if (pending === null) {
+                // This is the first update. Create a circular list.
+                update.next = update;
+              } else {
+                update.next = pending.next;
+                pending.next = update;
+              }
+
+              sharedQueue.pending = update;
+            }
+          }
+
+          fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
+          const alternate = fiber.alternate;
+
+          if (alternate !== null) {
+            alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+          }
+
+          scheduleContextWorkOnParentPath(fiber.return, renderLanes, workInProgress); // Mark the updated lanes on the list, too.
+
+          list.lanes = mergeLanes(list.lanes, renderLanes); // Since we already found a match, we can stop traversing the
+          // dependency list.
+
+          break;
+        }
+
+        dependency = dependency.next;
+      }
+    } else if (fiber.tag === ContextProvider) {
+      // Don't scan deeper if this is a matching provider
+      nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
+    } else if (fiber.tag === DehydratedFragment) {
+      // If a dehydrated suspense boundary is in this subtree, we don't know
+      // if it will have any context consumers in it. The best we can do is
+      // mark it as having updates.
+      const parentSuspense = fiber.return;
+
+      if (parentSuspense === null) {
+        throw Error(formatProdErrorMessage(341));
+      }
+
+      parentSuspense.lanes = mergeLanes(parentSuspense.lanes, renderLanes);
+      const alternate = parentSuspense.alternate;
+
+      if (alternate !== null) {
+        alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+      } // This is intentionally passing this fiber as the parent
+      // because we want to schedule this fiber as having work
+      // on its children. We'll use the childLanes on
+      // this fiber to indicate that a context has changed.
+
+
+      scheduleContextWorkOnParentPath(parentSuspense, renderLanes, workInProgress);
+      nextFiber = fiber.sibling;
+    } else {
+      // Traverse down.
+      nextFiber = fiber.child;
+    }
+
+    if (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;
+        }
+
+        const 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 prepareToReadContext(workInProgress, renderLanes) {
+  currentlyRenderingFiber = workInProgress;
+  lastContextDependency = null;
+  lastFullyObservedContext = null;
+  const dependencies = workInProgress.dependencies;
+
+  if (dependencies !== null) {
+    {
+      const firstContext = dependencies.firstContext;
+
+      if (firstContext !== null) {
+        if (includesSomeLane(dependencies.lanes, renderLanes)) {
+          // Context list has a pending update. Mark that this fiber performed work.
+          markWorkInProgressReceivedUpdate();
+        } // Reset the work-in-progress list
+
+
+        dependencies.firstContext = null;
+      }
+    }
+  }
+}
+function readContext(context) {
+
+  return readContextForConsumer(currentlyRenderingFiber, context);
+}
+function readContextDuringReconcilation(consumer, context, renderLanes) {
+  if (currentlyRenderingFiber === null) {
+    prepareToReadContext(consumer, renderLanes);
+  }
+
+  return readContextForConsumer(consumer, context);
+}
+
+function readContextForConsumer(consumer, context) {
+  const value = context._currentValue ;
+
+  if (lastFullyObservedContext === context) ; else {
+    const contextItem = {
+      context: context,
+      memoizedValue: value,
+      next: null
+    };
+
+    if (lastContextDependency === null) {
+      if (consumer === null) {
+        throw Error(formatProdErrorMessage(308));
+      } // This is the first dependency for this component. Create a new list.
+
+
+      lastContextDependency = contextItem;
+      consumer.dependencies = {
+        lanes: NoLanes,
+        firstContext: contextItem
+      };
+    } else {
+      // Append a new context item.
+      lastContextDependency = lastContextDependency.next = contextItem;
+    }
+  }
+
+  return value;
+}
+
+// replace it with a lightweight shim that only has the features we use.
+
+const AbortControllerLocal = typeof AbortController !== 'undefined' ? AbortController : // $FlowFixMe[missing-this-annot]
+// $FlowFixMe[prop-missing]
+function AbortControllerShim() {
+  const listeners = [];
+  const signal = this.signal = {
+    aborted: false,
+    addEventListener: (type, listener) => {
+      listeners.push(listener);
+    }
+  };
+
+  this.abort = () => {
+    signal.aborted = true;
+    listeners.forEach(listener => listener());
+  };
+} ; // Intentionally not named imports because Rollup would
+// use dynamic dispatch for CommonJS interop named imports.
+
+const scheduleCallback$1 = Scheduler.unstable_scheduleCallback,
+      NormalPriority = Scheduler.unstable_NormalPriority;
+const CacheContext = {
+  $$typeof: REACT_CONTEXT_TYPE,
+  // We don't use Consumer/Provider for Cache components. So we'll cheat.
+  Consumer: null,
+  Provider: null,
+  // We'll initialize these at the root.
+  _currentValue: null,
+  _currentValue2: null,
+  _threadCount: 0,
+  _defaultValue: null,
+  _globalName: null
+} ;
+// for retaining the cache once it is in use (retainCache), and releasing the cache
+// once it is no longer needed (releaseCache).
+
+
+function createCache() {
+
+  const cache = {
+    controller: new AbortControllerLocal(),
+    data: new Map(),
+    refCount: 0
+  };
+  return cache;
+}
+function retainCache(cache) {
+
+  cache.refCount++;
+} // Cleanup a cache instance, potentially freeing it if there are no more references
+
+function releaseCache(cache) {
+
+  cache.refCount--;
+
+  if (cache.refCount === 0) {
+    scheduleCallback$1(NormalPriority, () => {
+      cache.controller.abort();
+    });
+  }
+}
+function pushCacheProvider(workInProgress, cache) {
+
+  pushProvider(workInProgress, CacheContext, cache);
+}
+function popCacheProvider(workInProgress, cache) {
+
+  popProvider(CacheContext);
+}
+
+const ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig;
+const NoTransition = null;
+function requestCurrentTransition() {
+  return ReactCurrentBatchConfig$2.transition;
+} // When retrying a Suspense/Offscreen boundary, we restore the cache that was
+// used during the previous render by placing it here, on the stack.
+
+const resumedCache = createCursor(null); // During the render/synchronous commit phase, we don't actually process the
+
+function peekCacheFromPool() {
+  // If we're rendering inside a Suspense boundary that is currently hidden,
+  // we should use the same cache that we used during the previous render, if
+  // one exists.
+
+
+  const cacheResumedFromPreviousRender = resumedCache.current;
+
+  if (cacheResumedFromPreviousRender !== null) {
+    return cacheResumedFromPreviousRender;
+  } // Otherwise, check the root's cache pool.
+
+
+  const root = getWorkInProgressRoot();
+  const cacheFromRootCachePool = root.pooledCache;
+  return cacheFromRootCachePool;
+}
+
+function requestCacheFromPool(renderLanes) {
+  // Similar to previous function, except if there's not already a cache in the
+  // pool, we allocate a new one.
+  const cacheFromPool = peekCacheFromPool();
+
+  if (cacheFromPool !== null) {
+    return cacheFromPool;
+  } // Create a fresh cache and add it to the root cache pool. A cache can have
+  // multiple owners:
+  // - A cache pool that lives on the FiberRoot. This is where all fresh caches
+  //   are originally created (TODO: except during refreshes, until we implement
+  //   this correctly). The root takes ownership immediately when the cache is
+  //   created. Conceptually, root.pooledCache is an Option<Arc<Cache>> (owned),
+  //   and the return value of this function is a &Arc<Cache> (borrowed).
+  // - One of several fiber types: host root, cache boundary, suspense
+  //   component. These retain and release in the commit phase.
+
+
+  const root = getWorkInProgressRoot();
+  const freshCache = createCache();
+  root.pooledCache = freshCache;
+  retainCache(freshCache);
+
+  if (freshCache !== null) {
+    root.pooledCacheLanes |= renderLanes;
+  }
+
+  return freshCache;
+}
+function pushTransition(offscreenWorkInProgress, prevCachePool, newTransitions) {
+  {
+    if (prevCachePool === null) {
+      push(resumedCache, resumedCache.current);
+    } else {
+      push(resumedCache, prevCachePool.pool);
+    }
+  }
+}
+function popTransition(workInProgress, current) {
+  if (current !== null) {
+
+    {
+      pop(resumedCache);
+    }
+  }
+}
+function getSuspendedCache() {
+  // cache that would have been used to render fresh data during this render,
+  // if there was any, so that we can resume rendering with the same cache when
+  // we receive more data.
+
+
+  const cacheFromPool = peekCacheFromPool();
+
+  if (cacheFromPool === null) {
+    return null;
+  }
+
+  return {
+    // We must also save the parent, so that when we resume we can detect
+    // a refresh.
+    parent: CacheContext._currentValue ,
+    pool: cacheFromPool
+  };
+}
+function getOffscreenDeferredCache() {
+
+  const cacheFromPool = peekCacheFromPool();
+
+  if (cacheFromPool === null) {
+    return null;
+  }
+
+  return {
+    // We must also store the parent, so that when we resume we can detect
+    // a refresh.
+    parent: CacheContext._currentValue ,
+    pool: cacheFromPool
+  };
+}
+
+function markUpdate(workInProgress) {
+  // Tag the fiber with an update effect. This turns a Placement into
+  // a PlacementAndUpdate.
+  workInProgress.flags |= Update;
+}
+
+function markRef(workInProgress) {
+  workInProgress.flags |= Ref | RefStatic;
+}
+
+function appendAllChildren(parent, workInProgress, needsVisibilityToggle, isHidden) {
+  {
+    // We only have the top Fiber that was created but we need recurse down its
+    // children to find all the terminal nodes.
+    let node = workInProgress.child;
+
+    while (node !== null) {
+      if (node.tag === HostComponent || node.tag === HostText) {
+        appendInitialChild(parent, node.stateNode);
+      } else if (node.tag === HostPortal || (node.tag === HostSingleton )) ; else if (node.child !== null) {
+        node.child.return = node;
+        node = node.child;
+        continue;
+      }
+
+      if (node === workInProgress) {
+        return;
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+      while (node.sibling === null) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        if (node.return === null || node.return === workInProgress) {
+          return;
+        }
+
+        node = node.return;
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+      node.sibling.return = node.return;
+      node = node.sibling;
+    }
+  }
+} // An unfortunate fork of appendAllChildren because we have two different parent types.
+
+function updateHostComponent(current, workInProgress, type, newProps, renderLanes) {
+  {
+    // If we have an alternate, that means this is an update and we need to
+    // schedule a side-effect to do the updates.
+    const oldProps = current.memoizedProps;
+
+    if (oldProps === newProps) {
+      // In mutation mode, this is sufficient for a bailout because
+      // we won't touch this node even if children changed.
+      return;
+    }
+
+    markUpdate(workInProgress);
+  }
+} // This function must be called at the very end of the complete phase, because
+// it might throw to suspend, and if the resource immediately loads, the work
+// loop will resume rendering as if the work-in-progress completed. So it must
+// fully complete.
+// TODO: This should ideally move to begin phase, but currently the instance is
+// not created until the complete phase. For our existing use cases, host nodes
+// that suspend don't have children, so it doesn't matter. But that might not
+// always be true in the future.
+
+
+function preloadInstanceAndSuspendIfNeeded(workInProgress, type, props, renderLanes) {
+  {
+    // If this flag was set previously, we can remove it. The flag
+    // represents whether this particular set of props might ever need to
+    // suspend. The safest thing to do is for maySuspendCommit to always
+    // return true, but if the renderer is reasonably confident that the
+    // underlying resource won't be evicted, it can return false as a
+    // performance optimization.
+    workInProgress.flags &= ~MaySuspendCommit;
+    return;
+  } // Mark this fiber with a flag. This gets set on all host instances
+}
+
+function preloadResourceAndSuspendIfNeeded(workInProgress, resource, type, props, renderLanes) {
+  // This is a fork of preloadInstanceAndSuspendIfNeeded, but for resources.
+  if (!mayResourceSuspendCommit(resource)) {
+    workInProgress.flags &= ~MaySuspendCommit;
+    return;
+  }
+
+  workInProgress.flags |= MaySuspendCommit;
+  const rootRenderLanes = getWorkInProgressRootRenderLanes();
+
+  if (!includesOnlyNonUrgentLanes(rootRenderLanes)) ; else {
+    const isReady = preloadResource(resource);
+
+    if (!isReady) {
+      if (shouldRemainOnPreviousScreen()) {
+        workInProgress.flags |= ShouldSuspendCommit;
+      } else {
+        suspendCommit();
+      }
+    }
+  }
+}
+
+function scheduleRetryEffect(workInProgress, retryQueue) {
+  const wakeables = retryQueue;
+
+  if (wakeables !== null) {
+    // Schedule an effect to attach a retry listener to the promise.
+    // TODO: Move to passive phase
+    workInProgress.flags |= Update;
+  } else {
+    // This boundary suspended, but no wakeables were added to the retry
+    // queue. Check if the renderer suspended commit. If so, this means
+    // that once the fallback is committed, we can immediately retry
+    // rendering again, because rendering wasn't actually blocked. Only
+    // the commit phase.
+    // TODO: Consider a model where we always schedule an immediate retry, even
+    // for normal Suspense. That way the retry can partially render up to the
+    // first thing that suspends.
+    if (workInProgress.flags & ScheduleRetry) {
+      const retryLane = // TODO: This check should probably be moved into claimNextRetryLane
+      // I also suspect that we need some further consolidation of offscreen
+      // and retry lanes.
+      workInProgress.tag !== OffscreenComponent ? claimNextRetryLane() : OffscreenLane;
+      workInProgress.lanes = mergeLanes(workInProgress.lanes, retryLane);
+    }
+  }
+}
+
+function updateHostText(current, workInProgress, oldText, newText) {
+  {
+    // If the text differs, mark it as an update. All the work in done in commitWork.
+    if (oldText !== newText) {
+      markUpdate(workInProgress);
+    }
+  }
+}
+
+function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
+  if (getIsHydrating()) {
+    // If we're hydrating, we should consume as many items as we can
+    // so we don't leave any behind.
+    return;
+  }
+
+  switch (renderState.tailMode) {
+    case 'hidden':
+      {
+        // Any insertions at the end of the tail list after this point
+        // should be invisible. If there are already mounted boundaries
+        // anything before them are not considered for collapsing.
+        // Therefore we need to go through the whole tail to find if
+        // there are any.
+        let tailNode = renderState.tail;
+        let lastTailNode = null;
+
+        while (tailNode !== null) {
+          if (tailNode.alternate !== null) {
+            lastTailNode = tailNode;
+          }
+
+          tailNode = tailNode.sibling;
+        } // Next we're simply going to delete all insertions after the
+        // last rendered item.
+
+
+        if (lastTailNode === null) {
+          // All remaining items in the tail are insertions.
+          renderState.tail = null;
+        } else {
+          // Detach the insertion after the last node that was already
+          // inserted.
+          lastTailNode.sibling = null;
+        }
+
+        break;
+      }
+
+    case 'collapsed':
+      {
+        // Any insertions at the end of the tail list after this point
+        // should be invisible. If there are already mounted boundaries
+        // anything before them are not considered for collapsing.
+        // Therefore we need to go through the whole tail to find if
+        // there are any.
+        let tailNode = renderState.tail;
+        let lastTailNode = null;
+
+        while (tailNode !== null) {
+          if (tailNode.alternate !== null) {
+            lastTailNode = tailNode;
+          }
+
+          tailNode = tailNode.sibling;
+        } // Next we're simply going to delete all insertions after the
+        // last rendered item.
+
+
+        if (lastTailNode === null) {
+          // All remaining items in the tail are insertions.
+          if (!hasRenderedATailFallback && renderState.tail !== null) {
+            // We suspended during the head. We want to show at least one
+            // row at the tail. So we'll keep on and cut off the rest.
+            renderState.tail.sibling = null;
+          } else {
+            renderState.tail = null;
+          }
+        } else {
+          // Detach the insertion after the last node that was already
+          // inserted.
+          lastTailNode.sibling = null;
+        }
+
+        break;
+      }
+  }
+}
+
+function bubbleProperties(completedWork) {
+  const didBailout = completedWork.alternate !== null && completedWork.alternate.child === completedWork.child;
+  let newChildLanes = NoLanes;
+  let subtreeFlags = NoFlags$1;
+
+  if (!didBailout) {
+    // Bubble up the earliest expiration time.
+    if ((completedWork.mode & ProfileMode) !== NoMode) {
+      // In profiling mode, resetChildExpirationTime is also used to reset
+      // profiler durations.
+      let actualDuration = completedWork.actualDuration;
+      let treeBaseDuration = completedWork.selfBaseDuration;
+      let 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 {
+      let child = completedWork.child;
+
+      while (child !== null) {
+        newChildLanes = mergeLanes(newChildLanes, mergeLanes(child.lanes, child.childLanes));
+        subtreeFlags |= child.subtreeFlags;
+        subtreeFlags |= child.flags; // Update the return pointer so the tree is consistent. This is a code
+        // smell because it assumes the commit phase is never concurrent with
+        // the render phase. Will address during refactor to alternate model.
+
+        child.return = completedWork;
+        child = child.sibling;
+      }
+    }
+
+    completedWork.subtreeFlags |= subtreeFlags;
+  } else {
+    // Bubble up the earliest expiration time.
+    if ((completedWork.mode & ProfileMode) !== NoMode) {
+      // In profiling mode, resetChildExpirationTime is also used to reset
+      // profiler durations.
+      let treeBaseDuration = completedWork.selfBaseDuration;
+      let child = completedWork.child;
+
+      while (child !== null) {
+        newChildLanes = mergeLanes(newChildLanes, mergeLanes(child.lanes, child.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 |= child.subtreeFlags & StaticMask;
+        subtreeFlags |= child.flags & StaticMask; // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+
+        treeBaseDuration += child.treeBaseDuration;
+        child = child.sibling;
+      }
+
+      completedWork.treeBaseDuration = treeBaseDuration;
+    } else {
+      let child = completedWork.child;
+
+      while (child !== null) {
+        newChildLanes = mergeLanes(newChildLanes, mergeLanes(child.lanes, child.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 |= child.subtreeFlags & StaticMask;
+        subtreeFlags |= child.flags & StaticMask; // Update the return pointer so the tree is consistent. This is a code
+        // smell because it assumes the commit phase is never concurrent with
+        // the render phase. Will address during refactor to alternate model.
+
+        child.return = completedWork;
+        child = child.sibling;
+      }
+    }
+
+    completedWork.subtreeFlags |= subtreeFlags;
+  }
+
+  completedWork.childLanes = newChildLanes;
+  return didBailout;
+}
+
+function completeDehydratedSuspenseBoundary(current, workInProgress, nextState) {
+  if (hasUnhydratedTailNodes() && (workInProgress.mode & ConcurrentMode) !== NoMode && (workInProgress.flags & DidCapture) === NoFlags$1) {
+    warnIfUnhydratedTailNodes();
+    resetHydrationState();
+    workInProgress.flags |= ForceClientRender | DidCapture;
+    return false;
+  }
+
+  const wasHydrated = popHydrationState(workInProgress);
+
+  if (nextState !== null && nextState.dehydrated !== null) {
+    // We might be inside a hydration state the first time we're picking up this
+    // Suspense boundary, and also after we've reentered it for further hydration.
+    if (current === null) {
+      if (!wasHydrated) {
+        throw Error(formatProdErrorMessage(318));
+      }
+
+      prepareToHydrateHostSuspenseInstance(workInProgress);
+      bubbleProperties(workInProgress);
+
+      {
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          const isTimedOutSuspense = nextState !== null;
+
+          if (isTimedOutSuspense) {
+            // Don't count time spent in a timed out Suspense subtree as part of the base duration.
+            const primaryChildFragment = workInProgress.child;
+
+            if (primaryChildFragment !== null) {
+              // $FlowFixMe[unsafe-arithmetic] Flow doesn't support type casting in combination with the -= operator
+              workInProgress.treeBaseDuration -= primaryChildFragment.treeBaseDuration;
+            }
+          }
+        }
+      }
+
+      return false;
+    } else {
+      // We might have reentered this boundary to hydrate it. If so, we need to reset the hydration
+      // state since we're now exiting out of it. popHydrationState doesn't do that for us.
+      resetHydrationState();
+
+      if ((workInProgress.flags & DidCapture) === NoFlags$1) {
+        // This boundary did not suspend so it's now hydrated and unsuspended.
+        workInProgress.memoizedState = null;
+      } // If nothing suspended, we need to schedule an effect to mark this boundary
+      // as having hydrated so events know that they're free to be invoked.
+      // It's also a signal to replay events and the suspense callback.
+      // If something suspended, schedule an effect to attach retry listeners.
+      // So we might as well always mark this.
+
+
+      workInProgress.flags |= Update;
+      bubbleProperties(workInProgress);
+
+      {
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          const isTimedOutSuspense = nextState !== null;
+
+          if (isTimedOutSuspense) {
+            // Don't count time spent in a timed out Suspense subtree as part of the base duration.
+            const primaryChildFragment = workInProgress.child;
+
+            if (primaryChildFragment !== null) {
+              // $FlowFixMe[unsafe-arithmetic] Flow doesn't support type casting in combination with the -= operator
+              workInProgress.treeBaseDuration -= primaryChildFragment.treeBaseDuration;
+            }
+          }
+        }
+      }
+
+      return false;
+    }
+  } else {
+    // Successfully completed this tree. If this was a forced client render,
+    // there may have been recoverable errors during first hydration
+    // attempt. If so, add them to a queue so we can log them in the
+    // commit phase.
+    upgradeHydrationErrorsToRecoverable(); // Fall through to normal Suspense path
+
+    return true;
+  }
+}
+
+function completeWork(current, workInProgress, renderLanes) {
+  const newProps = workInProgress.pendingProps; // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
+
+  popTreeContext(workInProgress);
+
+  switch (workInProgress.tag) {
+    case IndeterminateComponent:
+    case LazyComponent:
+    case SimpleMemoComponent:
+    case FunctionComponent:
+    case ForwardRef:
+    case Fragment:
+    case Mode:
+    case Profiler:
+    case ContextConsumer:
+    case MemoComponent:
+      bubbleProperties(workInProgress);
+      return null;
+
+    case ClassComponent:
+      {
+        const Component = workInProgress.type;
+
+        if (isContextProvider(Component)) {
+          popContext();
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
+
+    case HostRoot:
+      {
+        const fiberRoot = workInProgress.stateNode;
+
+        {
+          let previousCache = null;
+
+          if (current !== null) {
+            previousCache = current.memoizedState.cache;
+          }
+
+          const cache = workInProgress.memoizedState.cache;
+
+          if (cache !== previousCache) {
+            // Run passive effects to retain/release the cache.
+            workInProgress.flags |= Passive$1;
+          }
+
+          popCacheProvider();
+        }
+        popHostContainer();
+        popTopLevelContextObject();
+
+        if (fiberRoot.pendingContext) {
+          fiberRoot.context = fiberRoot.pendingContext;
+          fiberRoot.pendingContext = null;
+        }
+
+        if (current === null || current.child === null) {
+          // If we hydrated, pop so that we can delete any remaining children
+          // that weren't hydrated.
+          const wasHydrated = popHydrationState(workInProgress);
+
+          if (wasHydrated) {
+            // If we hydrated, then we'll need to schedule an update for
+            // the commit side-effects on the root.
+            markUpdate(workInProgress);
+          } else {
+            if (current !== null) {
+              const prevState = current.memoizedState;
+
+              if ( // Check if this is a client root
+              !prevState.isDehydrated || // Check if we reverted to client rendering (e.g. due to an error)
+              (workInProgress.flags & ForceClientRender) !== NoFlags$1) {
+                // Schedule an effect to clear this container at the start of the
+                // next commit. This handles the case of React rendering into a
+                // container with previous children. It's also safe to do for
+                // updates too, because current.child would only be null if the
+                // previous render was null (so the container would already
+                // be empty).
+                workInProgress.flags |= Snapshot; // If this was a forced client render, there may have been
+                // recoverable errors during first hydration attempt. If so, add
+                // them to a queue so we can log them in the commit phase.
+
+                upgradeHydrationErrorsToRecoverable();
+              }
+            }
+          }
+        }
+        bubbleProperties(workInProgress);
+
+        return null;
+      }
+
+    case HostHoistable:
+      {
+        {
+          const nextResource = workInProgress.memoizedState;
+
+          if (current === null) {
+            // We are mounting and must Update this Hoistable in this commit
+            // @TODO refactor this block to create the instance here in complete
+            // phase if we are not hydrating.
+            markUpdate(workInProgress);
+
+            if (workInProgress.ref !== null) {
+              markRef(workInProgress);
+            }
+
+            if (nextResource !== null) {
+              // This is a Hoistable Resource
+              // This must come at the very end of the complete phase.
+              bubbleProperties(workInProgress);
+              preloadResourceAndSuspendIfNeeded(workInProgress, nextResource);
+              return null;
+            } else {
+              // This is a Hoistable Instance
+              // This must come at the very end of the complete phase.
+              bubbleProperties(workInProgress);
+              preloadInstanceAndSuspendIfNeeded(workInProgress);
+              return null;
+            }
+          } else {
+            // We are updating.
+            const currentResource = current.memoizedState;
+
+            if (nextResource !== currentResource) {
+              // We are transitioning to, from, or between Hoistable Resources
+              // and require an update
+              markUpdate(workInProgress);
+            }
+
+            if (current.ref !== workInProgress.ref) {
+              markRef(workInProgress);
+            }
+
+            if (nextResource !== null) {
+              // This is a Hoistable Resource
+              // This must come at the very end of the complete phase.
+              bubbleProperties(workInProgress);
+
+              if (nextResource === currentResource) {
+                workInProgress.flags &= ~MaySuspendCommit;
+              } else {
+                preloadResourceAndSuspendIfNeeded(workInProgress, nextResource);
+              }
+
+              return null;
+            } else {
+              // This is a Hoistable Instance
+              // We may have props to update on the Hoistable instance.
+              {
+                const oldProps = current.memoizedProps;
+
+                if (oldProps !== newProps) {
+                  markUpdate(workInProgress);
+                }
+              } // This must come at the very end of the complete phase.
+
+
+              bubbleProperties(workInProgress);
+              preloadInstanceAndSuspendIfNeeded(workInProgress);
+              return null;
+            }
+          }
+        } // Fall through
+
+      }
+
+    case HostSingleton:
+      {
+        {
+          popHostContext(workInProgress);
+          const rootContainerInstance = getRootHostContainer();
+          const type = workInProgress.type;
+
+          if (current !== null && workInProgress.stateNode != null) {
+            {
+              const oldProps = current.memoizedProps;
+
+              if (oldProps !== newProps) {
+                markUpdate(workInProgress);
+              }
+            }
+
+            if (current.ref !== workInProgress.ref) {
+              markRef(workInProgress);
+            }
+          } else {
+            if (!newProps) {
+              if (workInProgress.stateNode === null) {
+                throw Error(formatProdErrorMessage(166));
+              } // This can happen when we abort work.
+
+
+              bubbleProperties(workInProgress);
+              return null;
+            }
+
+            const currentHostContext = getHostContext();
+            const wasHydrated = popHydrationState(workInProgress);
+            let instance;
+
+            if (wasHydrated) {
+              // We ignore the boolean indicating there is an updateQueue because
+              // it is used only to set text children and HostSingletons do not
+              // use them.
+              prepareToHydrateHostInstance(workInProgress, currentHostContext);
+              instance = workInProgress.stateNode;
+            } else {
+              instance = resolveSingletonInstance(type, newProps, rootContainerInstance);
+              workInProgress.stateNode = instance;
+              markUpdate(workInProgress);
+            }
+
+            if (workInProgress.ref !== null) {
+              // If there is a ref on a host node we need to schedule a callback
+              markRef(workInProgress);
+            }
+          }
+
+          bubbleProperties(workInProgress);
+          return null;
+        } // Fall through
+
+      }
+
+    case HostComponent:
+      {
+        popHostContext(workInProgress);
+        const type = workInProgress.type;
+
+        if (current !== null && workInProgress.stateNode != null) {
+          updateHostComponent(current, workInProgress, type, newProps);
+
+          if (current.ref !== workInProgress.ref) {
+            markRef(workInProgress);
+          }
+        } else {
+          if (!newProps) {
+            if (workInProgress.stateNode === null) {
+              throw Error(formatProdErrorMessage(166));
+            } // This can happen when we abort work.
+
+
+            bubbleProperties(workInProgress);
+            return null;
+          }
+
+          const currentHostContext = getHostContext(); // TODO: Move createInstance to beginWork and keep it on a context
+          // "stack" as the parent. Then append children as we go in beginWork
+          // or completeWork depending on whether we want to add them top->down or
+          // bottom->up. Top->down is faster in IE11.
+
+          const wasHydrated = popHydrationState(workInProgress);
+
+          if (wasHydrated) {
+            // TODO: Move this and createInstance step into the beginPhase
+            // to consolidate.
+            prepareToHydrateHostInstance(workInProgress, currentHostContext);
+          } else {
+            const rootContainerInstance = getRootHostContainer();
+            const instance = createInstance(type, newProps, rootContainerInstance, currentHostContext, workInProgress); // TODO: For persistent renderers, we should pass children as part
+            // of the initial instance creation
+
+            appendAllChildren(instance, workInProgress);
+            workInProgress.stateNode = instance; // Certain renderers require commit-time effects for initial mount.
+            // (eg DOM renderer supports auto-focus for certain elements).
+            // Make sure such renderers get scheduled for later work.
+
+            if (finalizeInitialChildren(instance, type, newProps)) {
+              markUpdate(workInProgress);
+            }
+          }
+
+          if (workInProgress.ref !== null) {
+            // If there is a ref on a host node we need to schedule a callback
+            markRef(workInProgress);
+          }
+        }
+
+        bubbleProperties(workInProgress); // This must come at the very end of the complete phase, because it might
+        // throw to suspend, and if the resource immediately loads, the work loop
+        // will resume rendering as if the work-in-progress completed. So it must
+        // fully complete.
+
+        preloadInstanceAndSuspendIfNeeded(workInProgress);
+        return null;
+      }
+
+    case HostText:
+      {
+        const newText = newProps;
+
+        if (current && workInProgress.stateNode != null) {
+          const oldText = current.memoizedProps; // If we have an alternate, that means this is an update and we need
+          // to schedule a side-effect to do the updates.
+
+          updateHostText(current, workInProgress, oldText, newText);
+        } else {
+          if (typeof newText !== 'string') {
+            if (workInProgress.stateNode === null) {
+              throw Error(formatProdErrorMessage(166));
+            } // This can happen when we abort work.
+
+          }
+
+          const rootContainerInstance = getRootHostContainer();
+          const currentHostContext = getHostContext();
+          const wasHydrated = popHydrationState(workInProgress);
+
+          if (wasHydrated) {
+            if (prepareToHydrateHostTextInstance(workInProgress)) {
+              markUpdate(workInProgress);
+            }
+          } else {
+            workInProgress.stateNode = createTextInstance(newText, rootContainerInstance, currentHostContext, workInProgress);
+          }
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
+
+    case SuspenseComponent:
+      {
+        popSuspenseHandler(workInProgress);
+        const nextState = workInProgress.memoizedState; // Special path for dehydrated boundaries. We may eventually move this
+        // to its own fiber type so that we can add other kinds of hydration
+        // boundaries that aren't associated with a Suspense tree. In anticipation
+        // of such a refactor, all the hydration logic is contained in
+        // this branch.
+
+        if (current === null || current.memoizedState !== null && current.memoizedState.dehydrated !== null) {
+          const fallthroughToNormalSuspensePath = completeDehydratedSuspenseBoundary(current, workInProgress, nextState);
+
+          if (!fallthroughToNormalSuspensePath) {
+            if (workInProgress.flags & ForceClientRender) {
+              // Special case. There were remaining unhydrated nodes. We treat
+              // this as a mismatch. Revert to client rendering.
+              return workInProgress;
+            } else {
+              // Did not finish hydrating, either because this is the initial
+              // render or because something suspended.
+              return null;
+            }
+          } // Continue with the normal Suspense path.
+
+        }
+
+        if ((workInProgress.flags & DidCapture) !== NoFlags$1) {
+          // Something suspended. Re-render with the fallback children.
+          workInProgress.lanes = renderLanes; // Do not reset the effect list.
+
+          if ((workInProgress.mode & ProfileMode) !== NoMode) {
+            transferActualDuration(workInProgress);
+          } // Don't bubble properties in this case.
+
+
+          return workInProgress;
+        }
+
+        const nextDidTimeout = nextState !== null;
+        const prevDidTimeout = current !== null && current.memoizedState !== null;
+
+        if (nextDidTimeout) {
+          const offscreenFiber = workInProgress.child;
+          let previousCache = null;
+
+          if (offscreenFiber.alternate !== null && offscreenFiber.alternate.memoizedState !== null && offscreenFiber.alternate.memoizedState.cachePool !== null) {
+            previousCache = offscreenFiber.alternate.memoizedState.cachePool.pool;
+          }
+
+          let cache = null;
+
+          if (offscreenFiber.memoizedState !== null && offscreenFiber.memoizedState.cachePool !== null) {
+            cache = offscreenFiber.memoizedState.cachePool.pool;
+          }
+
+          if (cache !== previousCache) {
+            // Run passive effects to retain/release the cache.
+            offscreenFiber.flags |= Passive$1;
+          }
+        } // If the suspended state of the boundary changes, we need to schedule
+        // a passive effect, which is when we process the transitions
+
+
+        if (nextDidTimeout !== prevDidTimeout) {
+          // an effect to toggle the subtree's visibility. When we switch from
+          // fallback -> primary, the inner Offscreen fiber schedules this effect
+          // as part of its normal complete phase. But when we switch from
+          // primary -> fallback, the inner Offscreen fiber does not have a complete
+          // phase. So we need to schedule its effect here.
+          //
+          // We also use this flag to connect/disconnect the effects, but the same
+          // logic applies: when re-connecting, the Offscreen fiber's complete
+          // phase will handle scheduling the effect. It's only when the fallback
+          // is active that we have to do anything special.
+
+
+          if (nextDidTimeout) {
+            const offscreenFiber = workInProgress.child;
+            offscreenFiber.flags |= Visibility;
+          }
+        }
+
+        const retryQueue = workInProgress.updateQueue;
+        scheduleRetryEffect(workInProgress, retryQueue);
+
+        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.
+              const primaryChildFragment = workInProgress.child;
+
+              if (primaryChildFragment !== null) {
+                // $FlowFixMe[unsafe-arithmetic] Flow doesn't support type casting in combination with the -= operator
+                workInProgress.treeBaseDuration -= primaryChildFragment.treeBaseDuration;
+              }
+            }
+          }
+        }
+
+        return null;
+      }
+
+    case HostPortal:
+      popHostContainer();
+
+      if (current === null) {
+        preparePortalMount(workInProgress.stateNode.containerInfo);
+      }
+
+      bubbleProperties(workInProgress);
+      return null;
+
+    case ContextProvider:
+      // Pop provider fiber
+      const context = workInProgress.type._context;
+      popProvider(context);
+      bubbleProperties(workInProgress);
+      return null;
+
+    case IncompleteClassComponent:
+      {
+        // Same as class component case. I put it down here so that the tags are
+        // sequential to ensure this switch is compiled to a jump table.
+        const Component = workInProgress.type;
+
+        if (isContextProvider(Component)) {
+          popContext();
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
+
+    case SuspenseListComponent:
+      {
+        popSuspenseListContext();
+        const renderState = workInProgress.memoizedState;
+
+        if (renderState === null) {
+          // We're running in the default, "independent" mode.
+          // We don't do anything in this mode.
+          bubbleProperties(workInProgress);
+          return null;
+        }
+
+        let didSuspendAlready = (workInProgress.flags & DidCapture) !== NoFlags$1;
+        const renderedTail = renderState.rendering;
+
+        if (renderedTail === null) {
+          // We just rendered the head.
+          if (!didSuspendAlready) {
+            // This is the first pass. We need to figure out if anything is still
+            // suspended in the rendered set.
+            // If new content unsuspended, but there's still some content that
+            // didn't. Then we need to do a second pass that forces everything
+            // to keep showing their fallbacks.
+            // We might be suspended if something in this render pass suspended, or
+            // something in the previous committed pass suspended. Otherwise,
+            // there's no chance so we can skip the expensive call to
+            // findFirstSuspended.
+            const cannotBeSuspended = renderHasNotSuspendedYet() && (current === null || (current.flags & DidCapture) === NoFlags$1);
+
+            if (!cannotBeSuspended) {
+              let row = workInProgress.child;
+
+              while (row !== null) {
+                const suspended = findFirstSuspended(row);
+
+                if (suspended !== null) {
+                  didSuspendAlready = true;
+                  workInProgress.flags |= DidCapture;
+                  cutOffTailIfNeeded(renderState, false); // If this is a newly suspended tree, it might not get committed as
+                  // part of the second pass. In that case nothing will subscribe to
+                  // its thenables. Instead, we'll transfer its thenables to the
+                  // SuspenseList so that it can retry if they resolve.
+                  // There might be multiple of these in the list but since we're
+                  // going to wait for all of them anyway, it doesn't really matter
+                  // which ones gets to ping. In theory we could get clever and keep
+                  // track of how many dependencies remain but it gets tricky because
+                  // in the meantime, we can add/remove/change items and dependencies.
+                  // We might bail out of the loop before finding any but that
+                  // doesn't matter since that means that the other boundaries that
+                  // we did find already has their listeners attached.
+
+                  const retryQueue = suspended.updateQueue;
+                  workInProgress.updateQueue = retryQueue;
+                  scheduleRetryEffect(workInProgress, retryQueue); // Rerender the whole list, but this time, we'll force fallbacks
+                  // to stay in place.
+                  // Reset the effect flags before doing the second pass since that's now invalid.
+                  // Reset the child fibers to their original state.
+
+                  workInProgress.subtreeFlags = NoFlags$1;
+                  resetChildFibers(workInProgress, renderLanes); // Set up the Suspense List Context to force suspense and
+                  // immediately rerender the children.
+
+                  pushSuspenseListContext(workInProgress, setShallowSuspenseListContext(suspenseStackCursor.current, ForceSuspenseFallback)); // Don't bubble properties in this case.
+
+                  return workInProgress.child;
+                }
+
+                row = row.sibling;
+              }
+            }
+
+            if (renderState.tail !== null && now$1() > getRenderTargetTime()) {
+              // We have already passed our CPU deadline but we still have rows
+              // left in the tail. We'll just give up further attempts to render
+              // the main content and only render fallbacks.
+              workInProgress.flags |= DidCapture;
+              didSuspendAlready = true;
+              cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
+              // to get it started back up to attempt the next item. While in terms
+              // of priority this work has the same priority as this current render,
+              // it's not part of the same transition once the transition has
+              // committed. If it's sync, we still want to yield so that it can be
+              // painted. Conceptually, this is really the same as pinging.
+              // We can use any RetryLane even if it's the one currently rendering
+              // since we're leaving it behind on this node.
+
+              workInProgress.lanes = SomeRetryLane;
+            }
+          } else {
+            cutOffTailIfNeeded(renderState, false);
+          } // Next we're going to render the tail.
+
+        } else {
+          // Append the rendered row to the child list.
+          if (!didSuspendAlready) {
+            const suspended = findFirstSuspended(renderedTail);
+
+            if (suspended !== null) {
+              workInProgress.flags |= DidCapture;
+              didSuspendAlready = true; // Ensure we transfer the update queue to the parent so that it doesn't
+              // get lost if this row ends up dropped during a second pass.
+
+              const retryQueue = suspended.updateQueue;
+              workInProgress.updateQueue = retryQueue;
+              scheduleRetryEffect(workInProgress, retryQueue);
+              cutOffTailIfNeeded(renderState, true); // This might have been modified.
+
+              if (renderState.tail === null && renderState.tailMode === 'hidden' && !renderedTail.alternate && !getIsHydrating() // We don't cut it if we're hydrating.
+              ) {
+                  // We're done.
+                  bubbleProperties(workInProgress);
+                  return null;
+                }
+            } else if ( // The time it took to render last row is greater than the remaining
+            // time we have to render. So rendering one more row would likely
+            // exceed it.
+            now$1() * 2 - renderState.renderingStartTime > getRenderTargetTime() && renderLanes !== OffscreenLane) {
+              // We have now passed our CPU deadline and we'll just give up further
+              // attempts to render the main content and only render fallbacks.
+              // The assumption is that this is usually faster.
+              workInProgress.flags |= DidCapture;
+              didSuspendAlready = true;
+              cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
+              // to get it started back up to attempt the next item. While in terms
+              // of priority this work has the same priority as this current render,
+              // it's not part of the same transition once the transition has
+              // committed. If it's sync, we still want to yield so that it can be
+              // painted. Conceptually, this is really the same as pinging.
+              // We can use any RetryLane even if it's the one currently rendering
+              // since we're leaving it behind on this node.
+
+              workInProgress.lanes = SomeRetryLane;
+            }
+          }
+
+          if (renderState.isBackwards) {
+            // The effect list of the backwards tail will have been added
+            // to the end. This breaks the guarantee that life-cycles fire in
+            // sibling order but that isn't a strong guarantee promised by React.
+            // Especially since these might also just pop in during future commits.
+            // Append to the beginning of the list.
+            renderedTail.sibling = workInProgress.child;
+            workInProgress.child = renderedTail;
+          } else {
+            const previousSibling = renderState.last;
+
+            if (previousSibling !== null) {
+              previousSibling.sibling = renderedTail;
+            } else {
+              workInProgress.child = renderedTail;
+            }
+
+            renderState.last = renderedTail;
+          }
+        }
+
+        if (renderState.tail !== null) {
+          // We still have tail rows to render.
+          // Pop a row.
+          const next = renderState.tail;
+          renderState.rendering = next;
+          renderState.tail = next.sibling;
+          renderState.renderingStartTime = now$1();
+          next.sibling = null; // Restore the context.
+          // TODO: We can probably just avoid popping it instead and only
+          // setting it the first time we go from not suspended to suspended.
+
+          let suspenseContext = suspenseStackCursor.current;
+
+          if (didSuspendAlready) {
+            suspenseContext = setShallowSuspenseListContext(suspenseContext, ForceSuspenseFallback);
+          } else {
+            suspenseContext = setDefaultShallowSuspenseListContext(suspenseContext);
+          }
+
+          pushSuspenseListContext(workInProgress, suspenseContext); // Do a pass over the next row.
+          // Don't bubble properties in this case.
+
+          return next;
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
+
+    case ScopeComponent:
+      {
+
+        break;
+      }
+
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      {
+        popSuspenseHandler(workInProgress);
+        popHiddenContext();
+        const nextState = workInProgress.memoizedState;
+        const nextIsHidden = nextState !== null; // Schedule a Visibility effect if the visibility has changed
+
+        {
+          if (current !== null) {
+            const prevState = current.memoizedState;
+            const prevIsHidden = prevState !== null;
+
+            if (prevIsHidden !== nextIsHidden) {
+              workInProgress.flags |= Visibility;
+            }
+          } else {
+            // On initial mount, we only need a Visibility effect if the tree
+            // is hidden.
+            if (nextIsHidden) {
+              workInProgress.flags |= Visibility;
+            }
+          }
+        }
+
+        if (!nextIsHidden || (workInProgress.mode & ConcurrentMode) === NoMode) {
+          bubbleProperties(workInProgress);
+        } else {
+          // Don't bubble properties for hidden children unless we're rendering
+          // at offscreen priority.
+          if (includesSomeLane(renderLanes, OffscreenLane) && // Also don't bubble if the tree suspended
+          (workInProgress.flags & DidCapture) === NoLanes) {
+            bubbleProperties(workInProgress); // Check if there was an insertion or update in the hidden subtree.
+            // If so, we need to hide those nodes in the commit phase, so
+            // schedule a visibility effect.
+
+            if (workInProgress.subtreeFlags & (Placement | Update)) {
+              workInProgress.flags |= Visibility;
+            }
+          }
+        }
+
+        const offscreenQueue = workInProgress.updateQueue;
+
+        if (offscreenQueue !== null) {
+          const retryQueue = offscreenQueue.retryQueue;
+          scheduleRetryEffect(workInProgress, retryQueue);
+        }
+
+        {
+          let previousCache = null;
+
+          if (current !== null && current.memoizedState !== null && current.memoizedState.cachePool !== null) {
+            previousCache = current.memoizedState.cachePool.pool;
+          }
+
+          let cache = null;
+
+          if (workInProgress.memoizedState !== null && workInProgress.memoizedState.cachePool !== null) {
+            cache = workInProgress.memoizedState.cachePool.pool;
+          }
+
+          if (cache !== previousCache) {
+            // Run passive effects to retain/release the cache.
+            workInProgress.flags |= Passive$1;
+          }
+        }
+
+        popTransition(workInProgress, current);
+        return null;
+      }
+
+    case CacheComponent:
+      {
+        {
+          let previousCache = null;
+
+          if (current !== null) {
+            previousCache = current.memoizedState.cache;
+          }
+
+          const cache = workInProgress.memoizedState.cache;
+
+          if (cache !== previousCache) {
+            // Run passive effects to retain/release the cache.
+            workInProgress.flags |= Passive$1;
+          }
+
+          popCacheProvider();
+          bubbleProperties(workInProgress);
+        }
+
+        return null;
+      }
+
+    case TracingMarkerComponent:
+      {
+
+        return null;
+      }
+  }
+
+  throw Error(formatProdErrorMessage(156, workInProgress.tag));
+}
+
+function unwindWork(current, workInProgress, renderLanes) {
+  // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
+  popTreeContext(workInProgress);
+
+  switch (workInProgress.tag) {
+    case ClassComponent:
+      {
+        const Component = workInProgress.type;
+
+        if (isContextProvider(Component)) {
+          popContext();
+        }
+
+        const flags = workInProgress.flags;
+
+        if (flags & ShouldCapture) {
+          workInProgress.flags = flags & ~ShouldCapture | DidCapture;
+
+          if ((workInProgress.mode & ProfileMode) !== NoMode) {
+            transferActualDuration(workInProgress);
+          }
+
+          return workInProgress;
+        }
+
+        return null;
+      }
+
+    case HostRoot:
+      {
+
+        {
+          popCacheProvider();
+        }
+        popHostContainer();
+        popTopLevelContextObject();
+        const flags = workInProgress.flags;
+
+        if ((flags & ShouldCapture) !== NoFlags$1 && (flags & DidCapture) === NoFlags$1) {
+          // There was an error during render that wasn't captured by a suspense
+          // boundary. Do a second pass on the root to unmount the children.
+          workInProgress.flags = flags & ~ShouldCapture | DidCapture;
+          return workInProgress;
+        } // We unwound to the root without completing it. Exit.
+
+
+        return null;
+      }
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      {
+        // TODO: popHydrationState
+        popHostContext(workInProgress);
+        return null;
+      }
+
+    case SuspenseComponent:
+      {
+        popSuspenseHandler(workInProgress);
+        const suspenseState = workInProgress.memoizedState;
+
+        if (suspenseState !== null && suspenseState.dehydrated !== null) {
+          if (workInProgress.alternate === null) {
+            throw Error(formatProdErrorMessage(340));
+          }
+
+          resetHydrationState();
+        }
+
+        const flags = workInProgress.flags;
+
+        if (flags & ShouldCapture) {
+          workInProgress.flags = flags & ~ShouldCapture | DidCapture; // Captured a suspense effect. Re-render the boundary.
+
+          if ((workInProgress.mode & ProfileMode) !== NoMode) {
+            transferActualDuration(workInProgress);
+          }
+
+          return workInProgress;
+        }
+
+        return null;
+      }
+
+    case SuspenseListComponent:
+      {
+        popSuspenseListContext(); // SuspenseList doesn't actually catch anything. It should've been
+        // caught by a nested boundary. If not, it should bubble through.
+
+        return null;
+      }
+
+    case HostPortal:
+      popHostContainer();
+      return null;
+
+    case ContextProvider:
+      const context = workInProgress.type._context;
+      popProvider(context);
+      return null;
+
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      {
+        popSuspenseHandler(workInProgress);
+        popHiddenContext();
+        popTransition(workInProgress, current);
+        const flags = workInProgress.flags;
+
+        if (flags & ShouldCapture) {
+          workInProgress.flags = flags & ~ShouldCapture | DidCapture; // Captured a suspense effect. Re-render the boundary.
+
+          if ((workInProgress.mode & ProfileMode) !== NoMode) {
+            transferActualDuration(workInProgress);
+          }
+
+          return workInProgress;
+        }
+
+        return null;
+      }
+
+    case CacheComponent:
+      {
+        popCacheProvider();
+      }
+
+      return null;
+
+    case TracingMarkerComponent:
+
+      return null;
+
+    default:
+      return null;
+  }
+}
+
+function unwindInterruptedWork(current, interruptedWork, renderLanes) {
+  // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
+  popTreeContext(interruptedWork);
+
+  switch (interruptedWork.tag) {
+    case ClassComponent:
+      {
+        const childContextTypes = interruptedWork.type.childContextTypes;
+
+        if (childContextTypes !== null && childContextTypes !== undefined) {
+          popContext();
+        }
+
+        break;
+      }
+
+    case HostRoot:
+      {
+
+        {
+          popCacheProvider();
+        }
+        popHostContainer();
+        popTopLevelContextObject();
+        break;
+      }
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      {
+        popHostContext(interruptedWork);
+        break;
+      }
+
+    case HostPortal:
+      popHostContainer();
+      break;
+
+    case SuspenseComponent:
+      popSuspenseHandler(interruptedWork);
+      break;
+
+    case SuspenseListComponent:
+      popSuspenseListContext();
+      break;
+
+    case ContextProvider:
+      const context = interruptedWork.type._context;
+      popProvider(context);
+      break;
+
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      popSuspenseHandler(interruptedWork);
+      popHiddenContext();
+      popTransition(interruptedWork, current);
+      break;
+
+    case CacheComponent:
+      {
+        popCacheProvider();
+      }
+
+      break;
+  }
+}
+
+function invokeGuardedCallbackImpl(name, func, context) {
+  {
+    // $FlowFixMe[method-unbinding]
+    const funcArgs = Array.prototype.slice.call(arguments, 3);
+
+    try {
+      // $FlowFixMe[incompatible-call] Flow doesn't understand the arguments splicing.
+      func.apply(context, funcArgs);
+    } catch (error) {
+      this.onError(error);
+    }
+  }
+}
+
+let hasError = false;
+let caughtError = null; // Used by event system to capture/rethrow the first error.
+
+let hasRethrowError = false;
+let rethrowError = null;
+const reporter = {
+  onError(error) {
+    hasError = true;
+    caughtError = error;
+  }
+
+};
+/**
+ * Call a function while guarding against errors that happens within it.
+ * Returns an error if it throws, otherwise null.
+ *
+ * In production, this is implemented using a try-catch. The reason we don't
+ * use a try-catch directly is so that we can swap out a different
+ * implementation in DEV mode.
+ *
+ * @param {String} name of the guard to use for logging or debugging
+ * @param {Function} func The function to invoke
+ * @param {*} context The context to use when calling the function
+ * @param {...*} args Arguments for function
+ */
+
+function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+  hasError = false;
+  caughtError = null;
+  invokeGuardedCallbackImpl.apply(reporter, arguments);
+}
+/**
+ * Same as invokeGuardedCallback, but instead of returning an error, it stores
+ * it in a global so it can be rethrown by `rethrowCaughtError` later.
+ * TODO: See if caughtError and rethrowError can be unified.
+ *
+ * @param {String} name of the guard to use for logging or debugging
+ * @param {Function} func The function to invoke
+ * @param {*} context The context to use when calling the function
+ * @param {...*} args Arguments for function
+ */
+
+function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
+  invokeGuardedCallback.apply(this, arguments);
+
+  if (hasError) {
+    const error = clearCaughtError();
+
+    if (!hasRethrowError) {
+      hasRethrowError = true;
+      rethrowError = error;
+    }
+  }
+}
+/**
+ * During execution of guarded functions we will capture the first error which
+ * we will rethrow to be handled by the top level error handler.
+ */
+
+function rethrowCaughtError() {
+  if (hasRethrowError) {
+    const error = rethrowError;
+    hasRethrowError = false;
+    rethrowError = null;
+    throw error;
+  }
+}
+function clearCaughtError() {
+  if (hasError) {
+    const error = caughtError;
+    hasError = false;
+    caughtError = null;
+    return error;
+  } else {
+    throw Error(formatProdErrorMessage(198));
+  }
+}
+
+// Allows us to avoid traversing the return path to find the nearest Offscreen ancestor.
+
+
+let offscreenSubtreeIsHidden = false;
+let offscreenSubtreeWasHidden = false;
+const PossiblyWeakSet = typeof WeakSet === 'function' ? WeakSet : Set;
+let nextEffect = null; // Used for Profiling builds to track updaters.
+
+let inProgressLanes = null;
+let inProgressRoot = null;
+
+function shouldProfile(current) {
+  return (current.mode & ProfileMode) !== NoMode && (getExecutionContext() & CommitContext) !== NoContext;
+}
+
+function callComponentWillUnmountWithTimer(current, instance) {
+  instance.props = current.memoizedProps;
+  instance.state = current.memoizedState;
+
+  if (shouldProfile(current)) {
+    try {
+      startLayoutEffectTimer();
+      instance.componentWillUnmount();
+    } finally {
+      recordLayoutEffectDuration(current);
+    }
+  } else {
+    instance.componentWillUnmount();
+  }
+} // Capture errors so they don't interrupt unmounting.
+
+
+function safelyCallComponentWillUnmount(current, nearestMountedAncestor, instance) {
+  try {
+    callComponentWillUnmountWithTimer(current, instance);
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+} // Capture errors so they don't interrupt mounting.
+
+
+function safelyAttachRef(current, nearestMountedAncestor) {
+  try {
+    commitAttachRef(current);
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+}
+
+function safelyDetachRef(current, nearestMountedAncestor) {
+  const ref = current.ref;
+  const refCleanup = current.refCleanup;
+
+  if (ref !== null) {
+    if (typeof refCleanup === 'function') {
+      try {
+        if (shouldProfile(current)) {
+          try {
+            startLayoutEffectTimer();
+            refCleanup();
+          } finally {
+            recordLayoutEffectDuration(current);
+          }
+        } else {
+          refCleanup();
+        }
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
+      } finally {
+        // `refCleanup` has been called. Nullify all references to it to prevent double invocation.
+        current.refCleanup = null;
+        const finishedWork = current.alternate;
+
+        if (finishedWork != null) {
+          finishedWork.refCleanup = null;
+        }
+      }
+    } else if (typeof ref === 'function') {
+      let retVal;
+
+      try {
+        if (shouldProfile(current)) {
+          try {
+            startLayoutEffectTimer();
+            retVal = ref(null);
+          } finally {
+            recordLayoutEffectDuration(current);
+          }
+        } else {
+          retVal = ref(null);
+        }
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
+      }
+    } else {
+      // $FlowFixMe[incompatible-use] unable to narrow type to RefObject
+      ref.current = null;
+    }
+  }
+}
+
+function safelyCallDestroy(current, nearestMountedAncestor, destroy) {
+  try {
+    destroy();
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+}
+let shouldFireAfterActiveInstanceBlur = false;
+function commitBeforeMutationEffects(root, firstChild) {
+  prepareForCommit();
+  nextEffect = firstChild;
+  commitBeforeMutationEffects_begin(); // We no longer need to track the active instance fiber
+
+  const shouldFire = shouldFireAfterActiveInstanceBlur;
+  shouldFireAfterActiveInstanceBlur = false;
+  return shouldFire;
+}
+
+function commitBeforeMutationEffects_begin() {
+  while (nextEffect !== null) {
+    const fiber = nextEffect; // This phase is only used for beforeActiveInstanceBlur.
+
+    const child = fiber.child;
+
+    if ((fiber.subtreeFlags & BeforeMutationMask) !== NoFlags$1 && child !== null) {
+      child.return = fiber;
+      nextEffect = child;
+    } else {
+      commitBeforeMutationEffects_complete();
+    }
+  }
+}
+
+function commitBeforeMutationEffects_complete() {
+  while (nextEffect !== null) {
+    const fiber = nextEffect;
+
+    try {
+      commitBeforeMutationEffectsOnFiber(fiber);
+    } catch (error) {
+      captureCommitPhaseError(fiber, fiber.return, error);
+    }
+    const sibling = fiber.sibling;
+
+    if (sibling !== null) {
+      sibling.return = fiber.return;
+      nextEffect = sibling;
+      return;
+    }
+
+    nextEffect = fiber.return;
+  }
+}
+
+function commitBeforeMutationEffectsOnFiber(finishedWork) {
+  const current = finishedWork.alternate;
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+      {
+
+        break;
+      }
+
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        break;
+      }
+
+    case ClassComponent:
+      {
+        if ((flags & Snapshot) !== NoFlags$1) {
+          if (current !== null) {
+            const prevProps = current.memoizedProps;
+            const prevState = current.memoizedState;
+            const instance = finishedWork.stateNode; // We could update instance props and state here,
+
+            const snapshot = instance.getSnapshotBeforeUpdate(finishedWork.elementType === finishedWork.type ? prevProps : resolveDefaultProps(finishedWork.type, prevProps), prevState);
+
+            instance.__reactInternalSnapshotBeforeUpdate = snapshot;
+          }
+        }
+
+        break;
+      }
+
+    case HostRoot:
+      {
+        if ((flags & Snapshot) !== NoFlags$1) {
+          {
+            const root = finishedWork.stateNode;
+            clearContainer(root.containerInfo);
+          }
+        }
+
+        break;
+      }
+
+    case HostComponent:
+    case HostHoistable:
+    case HostSingleton:
+    case HostText:
+    case HostPortal:
+    case IncompleteClassComponent:
+      // Nothing to do for these component types
+      break;
+
+    default:
+      {
+        if ((flags & Snapshot) !== NoFlags$1) {
+          throw Error(formatProdErrorMessage(163));
+        }
+      }
+  }
+}
+
+function commitHookEffectListUnmount(flags, finishedWork, nearestMountedAncestor) {
+  const updateQueue = finishedWork.updateQueue;
+  const lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
+
+  if (lastEffect !== null) {
+    const firstEffect = lastEffect.next;
+    let effect = firstEffect;
+
+    do {
+      if ((effect.tag & flags) === flags) {
+        // Unmount
+        const inst = effect.inst;
+        const destroy = inst.destroy;
+
+        if (destroy !== undefined) {
+          inst.destroy = undefined;
+
+          {
+            if ((flags & Passive) !== NoFlags) {
+              markComponentPassiveEffectUnmountStarted(finishedWork);
+            } else if ((flags & Layout) !== NoFlags) {
+              markComponentLayoutEffectUnmountStarted(finishedWork);
+            }
+          }
+
+          safelyCallDestroy(finishedWork, nearestMountedAncestor, destroy);
+
+          {
+            if ((flags & Passive) !== NoFlags) {
+              markComponentPassiveEffectUnmountStopped();
+            } else if ((flags & Layout) !== NoFlags) {
+              markComponentLayoutEffectUnmountStopped();
+            }
+          }
+        }
+      }
+
+      effect = effect.next;
+    } while (effect !== firstEffect);
+  }
+}
+
+function commitHookEffectListMount(flags, finishedWork) {
+  const updateQueue = finishedWork.updateQueue;
+  const lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
+
+  if (lastEffect !== null) {
+    const firstEffect = lastEffect.next;
+    let effect = firstEffect;
+
+    do {
+      if ((effect.tag & flags) === flags) {
+        {
+          if ((flags & Passive) !== NoFlags) {
+            markComponentPassiveEffectMountStarted(finishedWork);
+          } else if ((flags & Layout) !== NoFlags) {
+            markComponentLayoutEffectMountStarted(finishedWork);
+          }
+        } // Mount
+
+
+        const create = effect.create;
+
+        const inst = effect.inst;
+        const destroy = create();
+        inst.destroy = destroy;
+
+        {
+          if ((flags & Passive) !== NoFlags) {
+            markComponentPassiveEffectMountStopped();
+          } else if ((flags & Layout) !== NoFlags) {
+            markComponentLayoutEffectMountStopped();
+          }
+        }
+      }
+
+      effect = effect.next;
+    } while (effect !== firstEffect);
+  }
+}
+
+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:
+          {
+            const passiveEffectDuration = finishedWork.stateNode.passiveEffectDuration;
+            const _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.
+
+            const commitTime = getCommitTime();
+            let 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.
+
+
+            let parentFiber = finishedWork.return;
+
+            outer: while (parentFiber !== null) {
+              switch (parentFiber.tag) {
+                case HostRoot:
+                  const root = parentFiber.stateNode;
+                  root.passiveEffectDuration += passiveEffectDuration;
+                  break outer;
+
+                case Profiler:
+                  const 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) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
+
+function commitClassLayoutLifecycles(finishedWork, current) {
+  const instance = finishedWork.stateNode;
+
+  if (current === null) {
+
+    if (shouldProfile(finishedWork)) {
+      try {
+        startLayoutEffectTimer();
+        instance.componentDidMount();
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+
+      recordLayoutEffectDuration(finishedWork);
+    } else {
+      try {
+        instance.componentDidMount();
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+  } else {
+    const prevProps = finishedWork.elementType === finishedWork.type ? current.memoizedProps : resolveDefaultProps(finishedWork.type, current.memoizedProps);
+    const prevState = current.memoizedState; // We could update instance props and state here,
+
+    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, prevState, instance.__reactInternalSnapshotBeforeUpdate);
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+  }
+}
+
+function commitClassCallbacks(finishedWork) {
+  // TODO: I think this is now always non-null by the time it reaches the
+  // commit phase. Consider removing the type check.
+  const updateQueue = finishedWork.updateQueue;
+
+  if (updateQueue !== null) {
+    const instance = finishedWork.stateNode;
+    // but instead we rely on them being set during last render.
+    // TODO: revisit this when we implement resuming.
+
+
+    try {
+      commitCallbacks(updateQueue, instance);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
+
+function commitHostComponentMount(finishedWork) {
+  const type = finishedWork.type;
+  const props = finishedWork.memoizedProps;
+  const instance = finishedWork.stateNode;
+
+  try {
+    commitMount(instance, type, props, finishedWork);
+  } catch (error) {
+    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+  }
+}
+
+function commitProfilerUpdate(finishedWork, current) {
+  if (getExecutionContext() & CommitContext) {
+    try {
+      const _finishedWork$memoize2 = finishedWork.memoizedProps,
+            onCommit = _finishedWork$memoize2.onCommit,
+            onRender = _finishedWork$memoize2.onRender;
+      const effectDuration = finishedWork.stateNode.effectDuration;
+      const commitTime = getCommitTime();
+      let 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.
+
+        let parentFiber = finishedWork.return;
+
+        outer: while (parentFiber !== null) {
+          switch (parentFiber.tag) {
+            case HostRoot:
+              const root = parentFiber.stateNode;
+              root.effectDuration += effectDuration;
+              break outer;
+
+            case Profiler:
+              const parentStateNode = parentFiber.stateNode;
+              parentStateNode.effectDuration += effectDuration;
+              break outer;
+          }
+
+          parentFiber = parentFiber.return;
+        }
+      }
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
+
+function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork, committedLanes) {
+  // When updating this function, also update reappearLayoutEffects, which does
+  // most of the same things when an offscreen tree goes from hidden -> visible.
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+        if (flags & Update) {
+          commitHookLayoutEffects(finishedWork, Layout | HasEffect);
+        }
+
+        break;
+      }
+
+    case ClassComponent:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+        if (flags & Update) {
+          commitClassLayoutLifecycles(finishedWork, current);
+        }
+
+        if (flags & Callback) {
+          commitClassCallbacks(finishedWork);
+        }
+
+        if (flags & Ref) {
+          safelyAttachRef(finishedWork, finishedWork.return);
+        }
+
+        break;
+      }
+
+    case HostRoot:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+        if (flags & Callback) {
+          // TODO: I think this is now always non-null by the time it reaches the
+          // commit phase. Consider removing the type check.
+          const updateQueue = finishedWork.updateQueue;
+
+          if (updateQueue !== null) {
+            let instance = null;
+
+            if (finishedWork.child !== null) {
+              switch (finishedWork.child.tag) {
+                case HostSingleton:
+                case HostComponent:
+                  instance = getPublicInstance(finishedWork.child.stateNode);
+                  break;
+
+                case ClassComponent:
+                  instance = finishedWork.child.stateNode;
+                  break;
+              }
+            }
+
+            try {
+              commitCallbacks(updateQueue, instance);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+        }
+
+        break;
+      }
+
+    case HostHoistable:
+      {
+        {
+          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+          if (flags & Ref) {
+            safelyAttachRef(finishedWork, finishedWork.return);
+          }
+
+          break;
+        } // Fall through
+
+      }
+
+    case HostSingleton:
+    case HostComponent:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork); // Renderers may schedule work to be done after host components are mounted
+        // (eg DOM renderer may schedule auto-focus for inputs and form controls).
+        // These effects should only be committed when components are first mounted,
+        // aka when there is no current/alternate.
+
+        if (current === null && flags & Update) {
+          commitHostComponentMount(finishedWork);
+        }
+
+        if (flags & Ref) {
+          safelyAttachRef(finishedWork, finishedWork.return);
+        }
+
+        break;
+      }
+
+    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;
+      }
+
+    case SuspenseComponent:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+        if (flags & Update) {
+          commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
+        }
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const isModernRoot = (finishedWork.mode & ConcurrentMode) !== NoMode;
+
+        if (isModernRoot) {
+          const isHidden = finishedWork.memoizedState !== null;
+          const newOffscreenSubtreeIsHidden = isHidden || offscreenSubtreeIsHidden;
+
+          if (newOffscreenSubtreeIsHidden) ; else {
+            // The Offscreen tree is visible.
+            const wasHidden = current !== null && current.memoizedState !== null;
+            const newOffscreenSubtreeWasHidden = wasHidden || offscreenSubtreeWasHidden;
+            const prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
+            const prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+            offscreenSubtreeIsHidden = newOffscreenSubtreeIsHidden;
+            offscreenSubtreeWasHidden = newOffscreenSubtreeWasHidden;
+
+            if (offscreenSubtreeWasHidden && !prevOffscreenSubtreeWasHidden) {
+              // This is the root of a reappearing boundary. As we continue
+              // traversing the layout effects, we must also re-mount layout
+              // effects that were unmounted when the Offscreen subtree was
+              // hidden. So this is a superset of the normal commitLayoutEffects.
+              const includeWorkInProgressEffects = (finishedWork.subtreeFlags & LayoutMask) !== NoFlags$1;
+              recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+            } else {
+              recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+            }
+
+            offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+            offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+          }
+        } else {
+          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        }
+
+        if (flags & Ref) {
+          const props = finishedWork.memoizedProps;
+
+          if (props.mode === 'manual') {
+            safelyAttachRef(finishedWork, finishedWork.return);
+          } else {
+            safelyDetachRef(finishedWork, finishedWork.return);
+          }
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        break;
+      }
+  }
+}
+
+function hideOrUnhideAllChildren(finishedWork, isHidden) {
+  // Only hide or unhide the top-most host nodes.
+  let hostSubtreeRoot = null;
+
+  {
+    // We only have the top Fiber that was inserted but we need to recurse down its
+    // children to find all the terminal nodes.
+    let node = finishedWork;
+
+    while (true) {
+      if (node.tag === HostComponent || (node.tag === HostHoistable ) || (node.tag === HostSingleton )) {
+        if (hostSubtreeRoot === null) {
+          hostSubtreeRoot = node;
+
+          try {
+            const instance = node.stateNode;
+
+            if (isHidden) {
+              hideInstance(instance);
+            } else {
+              unhideInstance(node.stateNode, node.memoizedProps);
+            }
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      } else if (node.tag === HostText) {
+        if (hostSubtreeRoot === null) {
+          try {
+            const instance = node.stateNode;
+
+            if (isHidden) {
+              hideTextInstance(instance);
+            } else {
+              unhideTextInstance(instance, node.memoizedProps);
+            }
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      } else if ((node.tag === OffscreenComponent || node.tag === LegacyHiddenComponent) && node.memoizedState !== null && node !== finishedWork) ; else if (node.child !== null) {
+        node.child.return = node;
+        node = node.child;
+        continue;
+      }
+
+      if (node === finishedWork) {
+        return;
+      }
+
+      while (node.sibling === null) {
+        if (node.return === null || node.return === finishedWork) {
+          return;
+        }
+
+        if (hostSubtreeRoot === node) {
+          hostSubtreeRoot = null;
+        }
+
+        node = node.return;
+      }
+
+      if (hostSubtreeRoot === node) {
+        hostSubtreeRoot = null;
+      }
+
+      node.sibling.return = node.return;
+      node = node.sibling;
+    }
+  }
+}
+
+function commitAttachRef(finishedWork) {
+  const ref = finishedWork.ref;
+
+  if (ref !== null) {
+    const instance = finishedWork.stateNode;
+    let instanceToUse;
+
+    switch (finishedWork.tag) {
+      case HostHoistable:
+      case HostSingleton:
+      case HostComponent:
+        instanceToUse = getPublicInstance(instance);
+        break;
+
+      default:
+        instanceToUse = instance;
+    } // Moved outside to ensure DCE works with this flag
+
+    if (typeof ref === 'function') {
+      if (shouldProfile(finishedWork)) {
+        try {
+          startLayoutEffectTimer();
+          finishedWork.refCleanup = ref(instanceToUse);
+        } finally {
+          recordLayoutEffectDuration(finishedWork);
+        }
+      } else {
+        finishedWork.refCleanup = ref(instanceToUse);
+      }
+    } else {
+
+
+      ref.current = instanceToUse;
+    }
+  }
+}
+
+function detachFiberMutation(fiber) {
+  // Cut off the return pointer to disconnect it from the tree.
+  // This enables us to detect and warn against state updates on an unmounted component.
+  // It also prevents events from bubbling from within disconnected components.
+  //
+  // Ideally, we should also clear the child pointer of the parent alternate to let this
+  // get GC:ed but we don't know which for sure which parent is the current
+  // one so we'll settle for GC:ing the subtree of this child.
+  // This child itself will be GC:ed when the parent updates the next time.
+  //
+  // Note that we can't clear child or sibling pointers yet.
+  // They're needed for passive effects and for findDOMNode.
+  // We defer those fields, and all other cleanup, to the passive phase (see detachFiberAfterEffects).
+  //
+  // Don't reset the alternate yet, either. We need that so we can detach the
+  // alternate's fields in the passive phase. Clearing the return pointer is
+  // sufficient for findDOMNode semantics.
+  const alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    alternate.return = null;
+  }
+
+  fiber.return = null;
+}
+
+function detachFiberAfterEffects(fiber) {
+  const alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    fiber.alternate = null;
+    detachFiberAfterEffects(alternate);
+  } // Clear cyclical Fiber fields. This level alone is designed to roughly
+  // approximate the planned Fiber refactor. In that world, `setState` will be
+  // bound to a special "instance" object instead of a Fiber. The Instance
+  // object will not have any of these fields. It will only be connected to
+  // the fiber tree via a single link at the root. So if this level alone is
+  // sufficient to fix memory issues, that bodes well for our plans.
+
+
+  fiber.child = null;
+  fiber.deletions = null;
+  fiber.sibling = null; // The `stateNode` is cyclical because on host nodes it points to the host
+  // tree, which has its own pointers to children, parents, and siblings.
+  // The other host nodes also point back to fibers, so we should detach that
+  // one, too.
+
+  if (fiber.tag === HostComponent) {
+    const hostInstance = fiber.stateNode;
+
+    if (hostInstance !== null) {
+      detachDeletedInstance(hostInstance);
+    }
+  }
+
+  fiber.stateNode = null;
+  // disconnected the fiber from the tree. So even if something leaks this
+  // particular fiber, it won't leak anything else.
+
+
+  fiber.return = null;
+  fiber.dependencies = null;
+  fiber.memoizedProps = null;
+  fiber.memoizedState = null;
+  fiber.pendingProps = null;
+  fiber.stateNode = null; // TODO: Move to `commitPassiveUnmountInsideDeletedTreeOnFiber` instead.
+
+  fiber.updateQueue = null;
+}
+
+function getHostParentFiber(fiber) {
+  let parent = fiber.return;
+
+  while (parent !== null) {
+    if (isHostParent(parent)) {
+      return parent;
+    }
+
+    parent = parent.return;
+  }
+
+  throw Error(formatProdErrorMessage(160));
+}
+
+function isHostParent(fiber) {
+  return fiber.tag === HostComponent || fiber.tag === HostRoot || (fiber.tag === HostHoistable ) || (fiber.tag === HostSingleton ) || fiber.tag === HostPortal;
+}
+
+function getHostSibling(fiber) {
+  // We're going to search forward into the tree until we find a sibling host
+  // node. Unfortunately, if multiple insertions are done in a row we have to
+  // search past them. This leads to exponential search for the next sibling.
+  // TODO: Find a more efficient way to do this.
+  let node = fiber;
+
+  siblings: while (true) {
+    // If we didn't find anything, let's try the next sibling.
+    while (node.sibling === null) {
+      if (node.return === null || isHostParent(node.return)) {
+        // If we pop out of the root or hit the parent the fiber we are the
+        // last sibling.
+        return null;
+      } // $FlowFixMe[incompatible-type] found when upgrading Flow
+
+
+      node = node.return;
+    }
+
+    node.sibling.return = node.return;
+    node = node.sibling;
+
+    while (node.tag !== HostComponent && node.tag !== HostText && (node.tag !== HostSingleton) && node.tag !== DehydratedFragment) {
+      // If it is not host node and, we might have a host node inside it.
+      // Try to search down until we find one.
+      if (node.flags & Placement) {
+        // If we don't have a child, try the siblings instead.
+        continue siblings;
+      } // If we don't have a child, try the siblings instead.
+      // We also skip portals because they are not part of this host tree.
+
+
+      if (node.child === null || node.tag === HostPortal) {
+        continue siblings;
+      } else {
+        node.child.return = node;
+        node = node.child;
+      }
+    } // Check if this host node is stable or about to be placed.
+
+
+    if (!(node.flags & Placement)) {
+      // Found it!
+      return node.stateNode;
+    }
+  }
+}
+
+function commitPlacement(finishedWork) {
+
+  {
+    if (finishedWork.tag === HostSingleton) {
+      // Singletons are already in the Host and don't need to be placed
+      // Since they operate somewhat like Portals though their children will
+      // have Placement and will get placed inside them
+      return;
+    }
+  } // Recursively insert all host nodes into the parent.
+
+
+  const parentFiber = getHostParentFiber(finishedWork);
+
+  switch (parentFiber.tag) {
+    case HostSingleton:
+      {
+        {
+          const parent = parentFiber.stateNode;
+          const before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
+          // children to find all the terminal nodes.
+
+          insertOrAppendPlacementNode(finishedWork, before, parent);
+          break;
+        } // Fall through
+
+      }
+
+    case HostComponent:
+      {
+        const parent = parentFiber.stateNode;
+
+        if (parentFiber.flags & ContentReset) {
+          // Reset the text content of the parent before doing any insertions
+          resetTextContent(parent); // Clear ContentReset from the effect tag
+
+          parentFiber.flags &= ~ContentReset;
+        }
+
+        const before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
+        // children to find all the terminal nodes.
+
+        insertOrAppendPlacementNode(finishedWork, before, parent);
+        break;
+      }
+
+    case HostRoot:
+    case HostPortal:
+      {
+        const parent = parentFiber.stateNode.containerInfo;
+        const before = getHostSibling(finishedWork);
+        insertOrAppendPlacementNodeIntoContainer(finishedWork, before, parent);
+        break;
+      }
+
+    default:
+      throw Error(formatProdErrorMessage(161));
+  }
+}
+
+function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
+  const tag = node.tag;
+  const isHost = tag === HostComponent || tag === HostText;
+
+  if (isHost) {
+    const stateNode = node.stateNode;
+
+    if (before) {
+      insertInContainerBefore(parent, stateNode, before);
+    } else {
+      appendChildToContainer(parent, stateNode);
+    }
+  } else if (tag === HostPortal || (tag === HostSingleton )) ; else {
+    const child = node.child;
+
+    if (child !== null) {
+      insertOrAppendPlacementNodeIntoContainer(child, before, parent);
+      let sibling = child.sibling;
+
+      while (sibling !== null) {
+        insertOrAppendPlacementNodeIntoContainer(sibling, before, parent);
+        sibling = sibling.sibling;
+      }
+    }
+  }
+}
+
+function insertOrAppendPlacementNode(node, before, parent) {
+  const tag = node.tag;
+  const isHost = tag === HostComponent || tag === HostText;
+
+  if (isHost) {
+    const stateNode = node.stateNode;
+
+    if (before) {
+      insertBefore(parent, stateNode, before);
+    } else {
+      appendChild(parent, stateNode);
+    }
+  } else if (tag === HostPortal || (tag === HostSingleton )) ; else {
+    const child = node.child;
+
+    if (child !== null) {
+      insertOrAppendPlacementNode(child, before, parent);
+      let sibling = child.sibling;
+
+      while (sibling !== null) {
+        insertOrAppendPlacementNode(sibling, before, parent);
+        sibling = sibling.sibling;
+      }
+    }
+  }
+} // These are tracked on the stack as we recursively traverse a
+// deleted subtree.
+// TODO: Update these during the whole mutation phase, not just during
+// a deletion.
+
+
+let hostParent = null;
+let hostParentIsContainer = false;
+
+function commitDeletionEffects(root, returnFiber, deletedFiber) {
+  {
+    // We only have the top Fiber that was deleted but we need to recurse down its
+    // children to find all the terminal nodes.
+    // Recursively delete all host nodes from the parent, detach refs, clean
+    // up mounted layout effects, and call componentWillUnmount.
+    // We only need to remove the topmost host child in each branch. But then we
+    // still need to keep traversing to unmount effects, refs, and cWU. TODO: We
+    // could split this into two separate traversals functions, where the second
+    // one doesn't include any removeChild logic. This is maybe the same
+    // function as "disappearLayoutEffects" (or whatever that turns into after
+    // the layout phase is refactored to use recursion).
+    // Before starting, find the nearest host parent on the stack so we know
+    // which instance/container to remove the children from.
+    // TODO: Instead of searching up the fiber return path on every deletion, we
+    // can track the nearest host component on the JS stack as we traverse the
+    // tree during the commit phase. This would make insertions faster, too.
+    let parent = returnFiber;
+
+    findParent: while (parent !== null) {
+      switch (parent.tag) {
+        case HostSingleton:
+        case HostComponent:
+          {
+            hostParent = parent.stateNode;
+            hostParentIsContainer = false;
+            break findParent;
+          }
+
+        case HostRoot:
+          {
+            hostParent = parent.stateNode.containerInfo;
+            hostParentIsContainer = true;
+            break findParent;
+          }
+
+        case HostPortal:
+          {
+            hostParent = parent.stateNode.containerInfo;
+            hostParentIsContainer = true;
+            break findParent;
+          }
+      }
+
+      parent = parent.return;
+    }
+
+    if (hostParent === null) {
+      throw Error(formatProdErrorMessage(160));
+    }
+
+    commitDeletionEffectsOnFiber(root, returnFiber, deletedFiber);
+    hostParent = null;
+    hostParentIsContainer = false;
+  }
+
+  detachFiberMutation(deletedFiber);
+}
+
+function recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, parent) {
+  // TODO: Use a static flag to skip trees that don't have unmount effects
+  let child = parent.child;
+
+  while (child !== null) {
+    commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, child);
+    child = child.sibling;
+  }
+}
+
+function commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, deletedFiber) {
+  onCommitUnmount(deletedFiber); // The cases in this outer switch modify the stack before they traverse
+  // into their subtree. There are simpler cases in the inner switch
+  // that don't modify the stack.
+
+  switch (deletedFiber.tag) {
+    case HostHoistable:
+      {
+        {
+          if (!offscreenSubtreeWasHidden) {
+            safelyDetachRef(deletedFiber, nearestMountedAncestor);
+          }
+
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+
+          if (deletedFiber.memoizedState) {
+            releaseResource(deletedFiber.memoizedState);
+          } else if (deletedFiber.stateNode) {
+            unmountHoistable(deletedFiber.stateNode);
+          }
+
+          return;
+        } // Fall through
+
+      }
+
+    case HostSingleton:
+      {
+        {
+          if (!offscreenSubtreeWasHidden) {
+            safelyDetachRef(deletedFiber, nearestMountedAncestor);
+          }
+
+          const prevHostParent = hostParent;
+          const prevHostParentIsContainer = hostParentIsContainer;
+          hostParent = deletedFiber.stateNode;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber); // Normally this is called in passive unmount effect phase however with
+          // HostSingleton we warn if you acquire one that is already associated to
+          // a different fiber. To increase our chances of avoiding this, specifically
+          // if you keyed a HostSingleton so there will be a delete followed by a Placement
+          // we treat detach eagerly here
+
+          releaseSingletonInstance(deletedFiber.stateNode);
+          hostParent = prevHostParent;
+          hostParentIsContainer = prevHostParentIsContainer;
+          return;
+        } // Fall through
+
+      }
+
+    case HostComponent:
+      {
+        if (!offscreenSubtreeWasHidden) {
+          safelyDetachRef(deletedFiber, nearestMountedAncestor);
+        } // Intentional fallthrough to next branch
+
+      }
+
+    case HostText:
+      {
+        // We only need to remove the nearest host child. Set the host parent
+        // to `null` on the stack to indicate that nested children don't
+        // need to be removed.
+        {
+          const prevHostParent = hostParent;
+          const prevHostParentIsContainer = hostParentIsContainer;
+          hostParent = null;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          hostParent = prevHostParent;
+          hostParentIsContainer = prevHostParentIsContainer;
+
+          if (hostParent !== null) {
+            // Now that all the child effects have unmounted, we can remove the
+            // node from the tree.
+            if (hostParentIsContainer) {
+              removeChildFromContainer(hostParent, deletedFiber.stateNode);
+            } else {
+              removeChild(hostParent, deletedFiber.stateNode);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case DehydratedFragment:
+      {
+        // Delete the dehydrated suspense boundary and all of its content.
+
+
+        {
+          if (hostParent !== null) {
+            if (hostParentIsContainer) {
+              clearSuspenseBoundaryFromContainer(hostParent, deletedFiber.stateNode);
+            } else {
+              clearSuspenseBoundary(hostParent, deletedFiber.stateNode);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case HostPortal:
+      {
+        {
+          // When we go into a portal, it becomes the parent to remove from.
+          const prevHostParent = hostParent;
+          const prevHostParentIsContainer = hostParentIsContainer;
+          hostParent = deletedFiber.stateNode.containerInfo;
+          hostParentIsContainer = true;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          hostParent = prevHostParent;
+          hostParentIsContainer = prevHostParentIsContainer;
+        }
+
+        return;
+      }
+
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent:
+      {
+        if (!offscreenSubtreeWasHidden) {
+          const updateQueue = deletedFiber.updateQueue;
+
+          if (updateQueue !== null) {
+            const lastEffect = updateQueue.lastEffect;
+
+            if (lastEffect !== null) {
+              const firstEffect = lastEffect.next;
+              let effect = firstEffect;
+
+              do {
+                const tag = effect.tag;
+                const inst = effect.inst;
+                const destroy = inst.destroy;
+
+                if (destroy !== undefined) {
+                  if ((tag & Insertion) !== NoFlags) {
+                    inst.destroy = undefined;
+                    safelyCallDestroy(deletedFiber, nearestMountedAncestor, destroy);
+                  } else if ((tag & Layout) !== NoFlags) {
+                    {
+                      markComponentLayoutEffectUnmountStarted(deletedFiber);
+                    }
+
+                    if (shouldProfile(deletedFiber)) {
+                      startLayoutEffectTimer();
+                      inst.destroy = undefined;
+                      safelyCallDestroy(deletedFiber, nearestMountedAncestor, destroy);
+                      recordLayoutEffectDuration(deletedFiber);
+                    } else {
+                      inst.destroy = undefined;
+                      safelyCallDestroy(deletedFiber, nearestMountedAncestor, destroy);
+                    }
+
+                    {
+                      markComponentLayoutEffectUnmountStopped();
+                    }
+                  }
+                }
+
+                effect = effect.next;
+              } while (effect !== firstEffect);
+            }
+          }
+        }
+
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        return;
+      }
+
+    case ClassComponent:
+      {
+        if (!offscreenSubtreeWasHidden) {
+          safelyDetachRef(deletedFiber, nearestMountedAncestor);
+          const instance = deletedFiber.stateNode;
+
+          if (typeof instance.componentWillUnmount === 'function') {
+            safelyCallComponentWillUnmount(deletedFiber, nearestMountedAncestor, instance);
+          }
+        }
+
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        return;
+      }
+
+    case ScopeComponent:
+      {
+
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        return;
+      }
+
+    case OffscreenComponent:
+      {
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+
+        if (deletedFiber.mode & ConcurrentMode) {
+          // If this offscreen component is hidden, we already unmounted it. Before
+          // deleting the children, track that it's already unmounted so that we
+          // don't attempt to unmount the effects again.
+          // TODO: If the tree is hidden, in most cases we should be able to skip
+          // over the nested children entirely. An exception is we haven't yet found
+          // the topmost host node to delete, which we already track on the stack.
+          // But the other case is portals, which need to be detached no matter how
+          // deeply they are nested. We should use a subtree flag to track whether a
+          // subtree includes a nested portal.
+          const prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || deletedFiber.memoizedState !== null;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+        } else {
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        return;
+      }
+  }
+}
+
+function commitSuspenseCallback(finishedWork) {
+}
+
+function commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {
+
+  const newState = finishedWork.memoizedState;
+
+  if (newState === null) {
+    const current = finishedWork.alternate;
+
+    if (current !== null) {
+      const prevState = current.memoizedState;
+
+      if (prevState !== null) {
+        const suspenseInstance = prevState.dehydrated;
+
+        if (suspenseInstance !== null) {
+          try {
+            commitHydratedSuspenseInstance(suspenseInstance);
+
+            if (enableSuspenseCallback) ;
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      }
+    }
+  }
+}
+
+function getRetryCache(finishedWork) {
+  // TODO: Unify the interface for the retry cache so we don't have to switch
+  // on the tag like this.
+  switch (finishedWork.tag) {
+    case SuspenseComponent:
+    case SuspenseListComponent:
+      {
+        let retryCache = finishedWork.stateNode;
+
+        if (retryCache === null) {
+          retryCache = finishedWork.stateNode = new PossiblyWeakSet();
+        }
+
+        return retryCache;
+      }
+
+    case OffscreenComponent:
+      {
+        const instance = finishedWork.stateNode;
+        let retryCache = instance._retryCache;
+
+        if (retryCache === null) {
+          retryCache = instance._retryCache = new PossiblyWeakSet();
+        }
+
+        return retryCache;
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(435, finishedWork.tag));
+      }
+  }
+}
+
+function detachOffscreenInstance(instance) {
+  const fiber = instance._current;
+
+  if (fiber === null) {
+    throw Error(formatProdErrorMessage(456));
+  }
+
+  if ((instance._pendingVisibility & OffscreenDetached) !== NoFlags$1) {
+    // The instance is already detached, this is a noop.
+    return;
+  } // TODO: There is an opportunity to optimise this by not entering commit phase
+  // and unmounting effects directly.
+
+
+  const root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+  if (root !== null) {
+    instance._pendingVisibility |= OffscreenDetached;
+    scheduleUpdateOnFiber(root, fiber, SyncLane);
+  }
+}
+function attachOffscreenInstance(instance) {
+  const fiber = instance._current;
+
+  if (fiber === null) {
+    throw Error(formatProdErrorMessage(456));
+  }
+
+  if ((instance._pendingVisibility & OffscreenDetached) === NoFlags$1) {
+    // The instance is already attached, this is a noop.
+    return;
+  }
+
+  const root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+  if (root !== null) {
+    instance._pendingVisibility &= ~OffscreenDetached;
+    scheduleUpdateOnFiber(root, fiber, SyncLane);
+  }
+}
+
+function attachSuspenseRetryListeners(finishedWork, wakeables) {
+  // If this boundary just timed out, then it will have a set of wakeables.
+  // For each wakeable, attach a listener so that when it resolves, React
+  // attempts to re-render the boundary in the primary (pre-timeout) state.
+  const retryCache = getRetryCache(finishedWork);
+  wakeables.forEach(wakeable => {
+    // Memoize using the boundary fiber to prevent redundant listeners.
+    const retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
+
+    if (!retryCache.has(wakeable)) {
+      retryCache.add(wakeable);
+
+      {
+        if (isDevToolsPresent) {
+          if (inProgressLanes !== null && inProgressRoot !== null) {
+            // If we have pending work still, associate the original updaters with it.
+            restorePendingUpdaters(inProgressRoot, inProgressLanes);
+          } else {
+            throw Error(formatProdErrorMessage(413));
+          }
+        }
+      }
+
+      wakeable.then(retry, retry);
+    }
+  });
+} // This function detects when a Suspense boundary goes from visible to hidden.
+function commitMutationEffects(root, finishedWork, committedLanes) {
+  inProgressLanes = committedLanes;
+  inProgressRoot = root;
+  commitMutationEffectsOnFiber(finishedWork, root);
+  inProgressLanes = null;
+  inProgressRoot = null;
+}
+
+function recursivelyTraverseMutationEffects(root, parentFiber, lanes) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects hae fired.
+  const deletions = parentFiber.deletions;
+
+  if (deletions !== null) {
+    for (let i = 0; i < deletions.length; i++) {
+      const childToDelete = deletions[i];
+
+      try {
+        commitDeletionEffects(root, parentFiber, childToDelete);
+      } catch (error) {
+        captureCommitPhaseError(childToDelete, parentFiber, error);
+      }
+    }
+  }
+
+  if (parentFiber.subtreeFlags & MutationMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      commitMutationEffectsOnFiber(child, root);
+      child = child.sibling;
+    }
+  }
+}
+
+let currentHoistableRoot = null;
+
+function commitMutationEffectsOnFiber(finishedWork, root, lanes) {
+  const current = finishedWork.alternate;
+  const flags = finishedWork.flags; // The effect flag should be checked *after* we refine the type of fiber,
+  // because the fiber tag is more specific. An exception is any flag related
+  // to reconciliation, because those can be set on all fiber types.
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Update) {
+          try {
+            commitHookEffectListUnmount(Insertion | HasEffect, finishedWork, finishedWork.return);
+            commitHookEffectListMount(Insertion | HasEffect, finishedWork);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          } // Layout effects are destroyed during the mutation phase so that all
+          // destroy functions for all fibers are called before any create functions.
+          // This prevents sibling component effects from interfering with each other,
+          // e.g. a destroy function in one component should never override a ref set
+          // by a create function in another component during the same commit.
+
+
+          if (shouldProfile(finishedWork)) {
+            try {
+              startLayoutEffectTimer();
+              commitHookEffectListUnmount(Layout | HasEffect, finishedWork, finishedWork.return);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+
+            recordLayoutEffectDuration(finishedWork);
+          } else {
+            try {
+              commitHookEffectListUnmount(Layout | HasEffect, finishedWork, finishedWork.return);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case ClassComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Ref) {
+          if (current !== null) {
+            safelyDetachRef(current, current.return);
+          }
+        }
+
+        if (flags & Callback && offscreenSubtreeIsHidden) {
+          const updateQueue = finishedWork.updateQueue;
+
+          if (updateQueue !== null) {
+            deferHiddenCallbacks(updateQueue);
+          }
+        }
+
+        return;
+      }
+
+    case HostHoistable:
+      {
+        {
+          // We cast because we always set the root at the React root and so it cannot be
+          // null while we are processing mutation effects
+          const hoistableRoot = currentHoistableRoot;
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+
+          if (flags & Ref) {
+            if (current !== null) {
+              safelyDetachRef(current, current.return);
+            }
+          }
+
+          if (flags & Update) {
+            const currentResource = current !== null ? current.memoizedState : null;
+            const newResource = finishedWork.memoizedState;
+
+            if (current === null) {
+              // We are mounting a new HostHoistable Fiber. We fork the mount
+              // behavior based on whether this instance is a Hoistable Instance
+              // or a Hoistable Resource
+              if (newResource === null) {
+                if (finishedWork.stateNode === null) {
+                  finishedWork.stateNode = hydrateHoistable(hoistableRoot, finishedWork.type, finishedWork.memoizedProps, finishedWork);
+                } else {
+                  mountHoistable(hoistableRoot, finishedWork.type, finishedWork.stateNode);
+                }
+              } else {
+                finishedWork.stateNode = acquireResource(hoistableRoot, newResource, finishedWork.memoizedProps);
+              }
+            } else if (currentResource !== newResource) {
+              // We are moving to or from Hoistable Resource, or between different Hoistable Resources
+              if (currentResource === null) {
+                if (current.stateNode !== null) {
+                  unmountHoistable(current.stateNode);
+                }
+              } else {
+                releaseResource(currentResource);
+              }
+
+              if (newResource === null) {
+                mountHoistable(hoistableRoot, finishedWork.type, finishedWork.stateNode);
+              } else {
+                acquireResource(hoistableRoot, newResource, finishedWork.memoizedProps);
+              }
+            } else if (newResource === null && finishedWork.stateNode !== null) {
+              // We may have an update on a Hoistable element
+              const updatePayload = finishedWork.updateQueue;
+              finishedWork.updateQueue = null;
+
+              try {
+                commitUpdate(finishedWork.stateNode, updatePayload, finishedWork.type, current.memoizedProps, finishedWork.memoizedProps, finishedWork);
+              } catch (error) {
+                captureCommitPhaseError(finishedWork, finishedWork.return, error);
+              }
+            }
+          }
+
+          return;
+        } // Fall through
+
+      }
+
+    case HostSingleton:
+      {
+        {
+          if (flags & Update) {
+            const previousWork = finishedWork.alternate;
+
+            if (previousWork === null) {
+              const singleton = finishedWork.stateNode;
+              const props = finishedWork.memoizedProps; // This was a new mount, we need to clear and set initial properties
+
+              clearSingleton(singleton);
+              acquireSingletonInstance(finishedWork.type, props, singleton, finishedWork);
+            }
+          }
+        } // Fall through
+
+      }
+
+    case HostComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Ref) {
+          if (current !== null) {
+            safelyDetachRef(current, current.return);
+          }
+        }
+
+        {
+          // TODO: ContentReset gets cleared by the children during the commit
+          // phase. This is a refactor hazard because it means we must read
+          // flags the flags after `commitReconciliationEffects` has already run;
+          // the order matters. We should refactor so that ContentReset does not
+          // rely on mutating the flag during commit. Like by setting a flag
+          // during the render phase instead.
+          if (finishedWork.flags & ContentReset) {
+            const instance = finishedWork.stateNode;
+
+            try {
+              resetTextContent(instance);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+
+          if (flags & Update) {
+            const instance = finishedWork.stateNode;
+
+            if (instance != null) {
+              // Commit the work prepared earlier.
+              const newProps = finishedWork.memoizedProps; // For hydration we reuse the update path but we treat the oldProps
+              // as the newProps. The updatePayload will contain the real change in
+              // this case.
+
+              const oldProps = current !== null ? current.memoizedProps : newProps;
+              const type = finishedWork.type; // TODO: Type the updateQueue to be specific to host components.
+
+              const updatePayload = finishedWork.updateQueue;
+              finishedWork.updateQueue = null;
+
+              try {
+                commitUpdate(instance, updatePayload, type, oldProps, newProps, finishedWork);
+              } catch (error) {
+                captureCommitPhaseError(finishedWork, finishedWork.return, error);
+              }
+            }
+          }
+        }
+
+        return;
+      }
+
+    case HostText:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Update) {
+          {
+            if (finishedWork.stateNode === null) {
+              throw Error(formatProdErrorMessage(162));
+            }
+
+            const textInstance = finishedWork.stateNode;
+            const newText = finishedWork.memoizedProps; // For hydration we reuse the update path but we treat the oldProps
+            // as the newProps. The updatePayload will contain the real change in
+            // this case.
+
+            const oldText = current !== null ? current.memoizedProps : newText;
+
+            try {
+              commitTextUpdate(textInstance, oldText, newText);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case HostRoot:
+      {
+        {
+          prepareToCommitHoistables();
+          const previousHoistableRoot = currentHoistableRoot;
+          currentHoistableRoot = getHoistableRoot(root.containerInfo);
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          currentHoistableRoot = previousHoistableRoot;
+          commitReconciliationEffects(finishedWork);
+        }
+
+        if (flags & Update) {
+          {
+            if (current !== null) {
+              const prevRootState = current.memoizedState;
+
+              if (prevRootState.isDehydrated) {
+                try {
+                  commitHydratedContainer(root.containerInfo);
+                } catch (error) {
+                  captureCommitPhaseError(finishedWork, finishedWork.return, error);
+                }
+              }
+            }
+          }
+        }
+
+        return;
+      }
+
+    case HostPortal:
+      {
+        {
+          const previousHoistableRoot = currentHoistableRoot;
+          currentHoistableRoot = getHoistableRoot(finishedWork.stateNode.containerInfo);
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          currentHoistableRoot = previousHoistableRoot;
+        }
+
+        return;
+      }
+
+    case SuspenseComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork); // TODO: We should mark a flag on the Suspense fiber itself, rather than
+        // relying on the Offscreen fiber having a flag also being marked. The
+        // reason is that this offscreen fiber might not be part of the work-in-
+        // progress tree! It could have been reused from a previous render. This
+        // doesn't lead to incorrect behavior because we don't rely on the flag
+        // check alone; we also compare the states explicitly below. But for
+        // modeling purposes, we _should_ be able to rely on the flag check alone.
+        // So this is a bit fragile.
+        //
+        // Also, all this logic could/should move to the passive phase so it
+        // doesn't block paint.
+
+        const offscreenFiber = finishedWork.child;
+
+        if (offscreenFiber.flags & Visibility) {
+          // Throttle the appearance and disappearance of Suspense fallbacks.
+          const isShowingFallback = finishedWork.memoizedState !== null;
+          const wasShowingFallback = current !== null && current.memoizedState !== null;
+
+          {
+            if (isShowingFallback !== wasShowingFallback) {
+              // A fallback is either appearing or disappearing.
+              markCommitTimeOfFallback();
+            }
+          }
+        }
+
+        if (flags & Update) {
+          try {
+            commitSuspenseCallback(finishedWork);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+
+          const retryQueue = finishedWork.updateQueue;
+
+          if (retryQueue !== null) {
+            finishedWork.updateQueue = null;
+            attachSuspenseRetryListeners(finishedWork, retryQueue);
+          }
+        }
+
+        return;
+      }
+
+    case OffscreenComponent:
+      {
+        if (flags & Ref) {
+          if (current !== null) {
+            safelyDetachRef(current, current.return);
+          }
+        }
+
+        const newState = finishedWork.memoizedState;
+        const isHidden = newState !== null;
+        const wasHidden = current !== null && current.memoizedState !== null;
+
+        if (finishedWork.mode & ConcurrentMode) {
+          // Before committing the children, track on the stack whether this
+          // offscreen subtree was already hidden, so that we don't unmount the
+          // effects again.
+          const prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
+          const prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden || isHidden;
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || wasHidden;
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+        } else {
+          recursivelyTraverseMutationEffects(root, finishedWork);
+        }
+
+        commitReconciliationEffects(finishedWork);
+        const offscreenInstance = finishedWork.stateNode; // TODO: Add explicit effect flag to set _current.
+
+        offscreenInstance._current = finishedWork; // Offscreen stores pending changes to visibility in `_pendingVisibility`. This is
+        // to support batching of `attach` and `detach` calls.
+
+        offscreenInstance._visibility &= ~OffscreenDetached;
+        offscreenInstance._visibility |= offscreenInstance._pendingVisibility & OffscreenDetached;
+
+        if (flags & Visibility) {
+          // Track the current state on the Offscreen instance so we can
+          // read it during an event
+          if (isHidden) {
+            offscreenInstance._visibility &= ~OffscreenVisible;
+          } else {
+            offscreenInstance._visibility |= OffscreenVisible;
+          }
+
+          if (isHidden) {
+            const isUpdate = current !== null;
+            const wasHiddenByAncestorOffscreen = offscreenSubtreeIsHidden || offscreenSubtreeWasHidden; // Only trigger disapper layout effects if:
+            //   - This is an update, not first mount.
+            //   - This Offscreen was not hidden before.
+            //   - Ancestor Offscreen was not hidden in previous commit.
+
+            if (isUpdate && !wasHidden && !wasHiddenByAncestorOffscreen) {
+              if ((finishedWork.mode & ConcurrentMode) !== NoMode) {
+                // Disappear the layout effects of all the children
+                recursivelyTraverseDisappearLayoutEffects(finishedWork);
+              }
+            }
+          } // Offscreen with manual mode manages visibility manually.
+
+
+          if (!isOffscreenManual(finishedWork)) {
+            // TODO: This needs to run whenever there's an insertion or update
+            // inside a hidden Offscreen tree.
+            hideOrUnhideAllChildren(finishedWork, isHidden);
+          }
+        } // TODO: Move to passive phase
+
+
+        if (flags & Update) {
+          const offscreenQueue = finishedWork.updateQueue;
+
+          if (offscreenQueue !== null) {
+            const retryQueue = offscreenQueue.retryQueue;
+
+            if (retryQueue !== null) {
+              offscreenQueue.retryQueue = null;
+              attachSuspenseRetryListeners(finishedWork, retryQueue);
+            }
+          }
+        }
+
+        return;
+      }
+
+    case SuspenseListComponent:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+
+        if (flags & Update) {
+          const retryQueue = finishedWork.updateQueue;
+
+          if (retryQueue !== null) {
+            finishedWork.updateQueue = null;
+            attachSuspenseRetryListeners(finishedWork, retryQueue);
+          }
+        }
+
+        return;
+      }
+
+    case ScopeComponent:
+      {
+
+        return;
+      }
+
+    default:
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        return;
+      }
+  }
+}
+
+function commitReconciliationEffects(finishedWork) {
+  // Placement effects (insertions, reorders) can be scheduled on any fiber
+  // type. They needs to happen after the children effects have fired, but
+  // before the effects on this fiber have fired.
+  const flags = finishedWork.flags;
+
+  if (flags & Placement) {
+    try {
+      commitPlacement(finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    } // Clear the "placement" from effect tag so that we know that this is
+    // inserted, before any life-cycles like componentDidMount gets called.
+    // TODO: findDOMNode doesn't rely on this any more but isMounted does
+    // and isMounted is deprecated anyway so we should be able to kill this.
+
+
+    finishedWork.flags &= ~Placement;
+  }
+
+  if (flags & Hydrating) {
+    finishedWork.flags &= ~Hydrating;
+  }
+}
+
+function commitLayoutEffects(finishedWork, root, committedLanes) {
+  inProgressLanes = committedLanes;
+  inProgressRoot = root;
+  const current = finishedWork.alternate;
+  commitLayoutEffectOnFiber(root, current, finishedWork);
+  inProgressLanes = null;
+  inProgressRoot = null;
+}
+
+function recursivelyTraverseLayoutEffects(root, parentFiber, lanes) {
+
+  if (parentFiber.subtreeFlags & LayoutMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      const current = child.alternate;
+      commitLayoutEffectOnFiber(root, current, child);
+      child = child.sibling;
+    }
+  }
+}
+
+function disappearLayoutEffects(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent:
+      {
+        // TODO (Offscreen) Check: flags & LayoutStatic
+        if (shouldProfile(finishedWork)) {
+          try {
+            startLayoutEffectTimer();
+            commitHookEffectListUnmount(Layout, finishedWork, finishedWork.return);
+          } finally {
+            recordLayoutEffectDuration(finishedWork);
+          }
+        } else {
+          commitHookEffectListUnmount(Layout, finishedWork, finishedWork.return);
+        }
+
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      }
+
+    case ClassComponent:
+      {
+        // TODO (Offscreen) Check: flags & RefStatic
+        safelyDetachRef(finishedWork, finishedWork.return);
+        const instance = finishedWork.stateNode;
+
+        if (typeof instance.componentWillUnmount === 'function') {
+          safelyCallComponentWillUnmount(finishedWork, finishedWork.return, instance);
+        }
+
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      }
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      {
+        // TODO (Offscreen) Check: flags & RefStatic
+        safelyDetachRef(finishedWork, finishedWork.return);
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        // TODO (Offscreen) Check: flags & RefStatic
+        safelyDetachRef(finishedWork, finishedWork.return);
+        const isHidden = finishedWork.memoizedState !== null;
+
+        if (isHidden) ; else {
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
+  // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+  let child = parentFiber.child;
+
+  while (child !== null) {
+    disappearLayoutEffects(child);
+    child = child.sibling;
+  }
+}
+
+function reappearLayoutEffects(finishedRoot, current, finishedWork, // This function visits both newly finished work and nodes that were re-used
+// from a previously committed tree. We cannot check non-static flags if the
+// node was reused.
+includeWorkInProgressEffects) {
+  // Turn on layout effects in a tree that previously disappeared.
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // TODO: Check flags & LayoutStatic
+
+        commitHookLayoutEffects(finishedWork, Layout);
+        break;
+      }
+
+    case ClassComponent:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // TODO: Check for LayoutStatic flag
+
+        const instance = finishedWork.stateNode;
+
+        if (typeof instance.componentDidMount === 'function') {
+          try {
+            instance.componentDidMount();
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        } // Commit any callbacks that would have fired while the component
+        // was hidden.
+
+
+        const updateQueue = finishedWork.updateQueue;
+
+        if (updateQueue !== null) {
+          commitHiddenCallbacks(updateQueue, instance);
+        } // If this is newly finished work, check for setState callbacks
+
+
+        if (includeWorkInProgressEffects && flags & Callback) {
+          commitClassCallbacks(finishedWork);
+        } // TODO: Check flags & RefStatic
+
+
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      }
+    // Unlike commitLayoutEffectsOnFiber, we don't need to handle HostRoot
+    // because this function only visits nodes that are inside an
+    // Offscreen fiber.
+    // case HostRoot: {
+    //  ...
+    // }
+
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // Renderers may schedule work to be done after host components are mounted
+        // (eg DOM renderer may schedule auto-focus for inputs and form controls).
+        // These effects should only be committed when components are first mounted,
+        // aka when there is no current/alternate.
+
+        if (includeWorkInProgressEffects && current === null && flags & Update) {
+          commitHostComponentMount(finishedWork);
+        } // TODO: Check flags & Ref
+
+
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      }
+
+    case Profiler:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // TODO: Figure out how Profiler updates should work with Offscreen
+
+        if (includeWorkInProgressEffects && flags & Update) {
+          commitProfilerUpdate(finishedWork, current);
+        }
+
+        break;
+      }
+
+    case SuspenseComponent:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects); // TODO: Figure out how Suspense hydration callbacks should work
+        // with Offscreen.
+
+        if (includeWorkInProgressEffects && flags & Update) {
+          commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
+        }
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const offscreenState = finishedWork.memoizedState;
+        const isHidden = offscreenState !== null;
+
+        if (isHidden) ; else {
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+        } // TODO: Check flags & Ref
+
+
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseReappearLayoutEffects(finishedRoot, parentFiber, includeWorkInProgressEffects) {
+  // This function visits both newly finished work and nodes that were re-used
+  // from a previously committed tree. We cannot check non-static flags if the
+  // node was reused.
+  const childShouldIncludeWorkInProgressEffects = includeWorkInProgressEffects && (parentFiber.subtreeFlags & LayoutMask) !== NoFlags$1; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+  let child = parentFiber.child;
+
+  while (child !== null) {
+    const current = child.alternate;
+    reappearLayoutEffects(finishedRoot, current, child, childShouldIncludeWorkInProgressEffects);
+    child = child.sibling;
+  }
+}
+
+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) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
+
+function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
+  {
+    let previousCache = null;
+
+    if (current !== null && current.memoizedState !== null && current.memoizedState.cachePool !== null) {
+      previousCache = current.memoizedState.cachePool.pool;
+    }
+
+    let nextCache = null;
+
+    if (finishedWork.memoizedState !== null && finishedWork.memoizedState.cachePool !== null) {
+      nextCache = finishedWork.memoizedState.cachePool.pool;
+    } // Retain/release the cache used for pending (suspended) nodes.
+    // Note that this is only reached in the non-suspended/visible case:
+    // when the content is suspended/hidden, the retain/release occurs
+    // via the parent Suspense component (see case above).
+
+
+    if (nextCache !== previousCache) {
+      if (nextCache != null) {
+        retainCache(nextCache);
+      }
+
+      if (previousCache != null) {
+        releaseCache(previousCache);
+      }
+    }
+  }
+}
+
+function commitCachePassiveMountEffect(current, finishedWork) {
+  {
+    let previousCache = null;
+
+    if (finishedWork.alternate !== null) {
+      previousCache = finishedWork.alternate.memoizedState.cache;
+    }
+
+    const nextCache = finishedWork.memoizedState.cache; // Retain/release the cache. In theory the cache component
+    // could be "borrowing" a cache instance owned by some parent,
+    // in which case we could avoid retaining/releasing. But it
+    // is non-trivial to determine when that is the case, so we
+    // always retain/release.
+
+    if (nextCache !== previousCache) {
+      retainCache(nextCache);
+
+      if (previousCache != null) {
+        releaseCache(previousCache);
+      }
+    }
+  }
+}
+
+function commitPassiveMountEffects(root, finishedWork, committedLanes, committedTransitions) {
+  commitPassiveMountOnFiber(root, finishedWork, committedLanes, committedTransitions);
+}
+
+function recursivelyTraversePassiveMountEffects(root, parentFiber, committedLanes, committedTransitions) {
+
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      commitPassiveMountOnFiber(root, child, committedLanes, committedTransitions);
+      child = child.sibling;
+    }
+  }
+}
+
+function commitPassiveMountOnFiber(finishedRoot, finishedWork, committedLanes, committedTransitions) {
+  // When updating this function, also update reconnectPassiveEffects, which does
+  // most of the same things when an offscreen tree goes from hidden -> visible,
+  // or when toggling effects inside a hidden tree.
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+
+        if (flags & Passive$1) {
+          commitHookPassiveMountEffects(finishedWork, Passive | HasEffect);
+        }
+
+        break;
+      }
+
+    case HostRoot:
+      {
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+
+        if (flags & Passive$1) {
+          {
+            let previousCache = null;
+
+            if (finishedWork.alternate !== null) {
+              previousCache = finishedWork.alternate.memoizedState.cache;
+            }
+
+            const nextCache = finishedWork.memoizedState.cache; // Retain/release the root cache.
+            // Note that on initial mount, previousCache and nextCache will be the same
+            // and this retain won't occur. To counter this, we instead retain the HostRoot's
+            // initial cache when creating the root itself (see createFiberRoot() in
+            // ReactFiberRoot.js). Subsequent updates that change the cache are reflected
+            // here, such that previous/next caches are retained correctly.
+
+            if (nextCache !== previousCache) {
+              retainCache(nextCache);
+
+              if (previousCache != null) {
+                releaseCache(previousCache);
+              }
+            }
+          }
+        }
+
+        break;
+      }
+
+    case LegacyHiddenComponent:
+      {
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        // TODO: Pass `current` as argument to this function
+        const instance = finishedWork.stateNode;
+        const nextState = finishedWork.memoizedState;
+        const isHidden = nextState !== null;
+
+        if (isHidden) {
+          if (instance._visibility & OffscreenPassiveEffectsConnected) {
+            // The effects are currently connected. Update them.
+            recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          } else {
+            if (finishedWork.mode & ConcurrentMode) {
+              // The effects are currently disconnected. Since the tree is hidden,
+              // don't connect them. This also applies to the initial render.
+              {
+                // "Atomic" effects are ones that need to fire on every commit,
+                // even during pre-rendering. An example is updating the reference
+                // count on cache instances.
+                recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+              }
+            } else {
+              // Legacy Mode: Fire the effects even if the tree is hidden.
+              instance._visibility |= OffscreenPassiveEffectsConnected;
+              recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+            }
+          }
+        } else {
+          // Tree is visible
+          if (instance._visibility & OffscreenPassiveEffectsConnected) {
+            // The effects are currently connected. Update them.
+            recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          } else {
+            // The effects are currently disconnected. Reconnect them, while also
+            // firing effects inside newly mounted trees. This also applies to
+            // the initial render.
+            instance._visibility |= OffscreenPassiveEffectsConnected;
+            const includeWorkInProgressEffects = (finishedWork.subtreeFlags & PassiveMask) !== NoFlags$1;
+            recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+          }
+        }
+
+        if (flags & Passive$1) {
+          const current = finishedWork.alternate;
+          commitOffscreenPassiveMountEffects(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+
+        if (flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitCachePassiveMountEffect(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case TracingMarkerComponent:
+
+    default:
+      {
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseReconnectPassiveEffects(finishedRoot, parentFiber, committedLanes, committedTransitions, includeWorkInProgressEffects) {
+  // This function visits both newly finished work and nodes that were re-used
+  // from a previously committed tree. We cannot check non-static flags if the
+  // node was reused.
+  const childShouldIncludeWorkInProgressEffects = includeWorkInProgressEffects && (parentFiber.subtreeFlags & PassiveMask) !== NoFlags$1; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+  let child = parentFiber.child;
+
+  while (child !== null) {
+    reconnectPassiveEffects(finishedRoot, child, committedLanes, committedTransitions, childShouldIncludeWorkInProgressEffects);
+    child = child.sibling;
+  }
+}
+
+function reconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, // This function visits both newly finished work and nodes that were re-used
+// from a previously committed tree. We cannot check non-static flags if the
+// node was reused.
+includeWorkInProgressEffects) {
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects); // TODO: Check for PassiveStatic flag
+
+        commitHookPassiveMountEffects(finishedWork, Passive);
+        break;
+      }
+    // Unlike commitPassiveMountOnFiber, we don't need to handle HostRoot
+    // because this function only visits nodes that are inside an
+    // Offscreen fiber.
+    // case HostRoot: {
+    //  ...
+    // }
+
+    case LegacyHiddenComponent:
+      {
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const instance = finishedWork.stateNode;
+        const nextState = finishedWork.memoizedState;
+        const isHidden = nextState !== null;
+
+        if (isHidden) {
+          if (instance._visibility & OffscreenPassiveEffectsConnected) {
+            // The effects are currently connected. Update them.
+            recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+          } else {
+            if (finishedWork.mode & ConcurrentMode) {
+              // The effects are currently disconnected. Since the tree is hidden,
+              // don't connect them. This also applies to the initial render.
+              {
+                // "Atomic" effects are ones that need to fire on every commit,
+                // even during pre-rendering. An example is updating the reference
+                // count on cache instances.
+                recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+              }
+            } else {
+              // Legacy Mode: Fire the effects even if the tree is hidden.
+              instance._visibility |= OffscreenPassiveEffectsConnected;
+              recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+            }
+          }
+        } else {
+          // Tree is visible
+          // Since we're already inside a reconnecting tree, it doesn't matter
+          // whether the effects are currently connected. In either case, we'll
+          // continue traversing the tree and firing all the effects.
+          //
+          // We do need to set the "connected" flag on the instance, though.
+          instance._visibility |= OffscreenPassiveEffectsConnected;
+          recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+        }
+
+        if (includeWorkInProgressEffects && flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitOffscreenPassiveMountEffects(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+
+        if (includeWorkInProgressEffects && flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitCachePassiveMountEffect(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case TracingMarkerComponent:
+
+    default:
+      {
+        recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseAtomicPassiveEffects(finishedRoot, parentFiber, committedLanes, committedTransitions) {
+
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      commitAtomicPassiveEffects(finishedRoot, child);
+      child = child.sibling;
+    }
+  }
+}
+
+function commitAtomicPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions) {
+  // "Atomic" effects are ones that need to fire on every commit, even during
+  // pre-rendering. We call this function when traversing a hidden tree whose
+  // regular effects are currently disconnected.
+  const flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case OffscreenComponent:
+      {
+        recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+
+        if (flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitOffscreenPassiveMountEffects(current, finishedWork);
+        }
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+
+        if (flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          const current = finishedWork.alternate;
+          commitCachePassiveMountEffect(current, finishedWork);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+        break;
+      }
+  }
+}
+
+function commitPassiveUnmountEffects(finishedWork) {
+  commitPassiveUnmountOnFiber(finishedWork);
+} // If we're inside a brand new tree, or a tree that was already visible, then we
+// should only suspend host components that have a ShouldSuspendCommit flag.
+// Components without it haven't changed since the last commit, so we can skip
+// over those.
+//
+// When we enter a tree that is being revealed (going from hidden -> visible),
+// we need to suspend _any_ component that _may_ suspend. Even if they're
+// already in the "current" tree. Because their visibility has changed, the
+// browser may not have prerendered them yet. So we check the MaySuspendCommit
+// flag instead.
+
+let suspenseyCommitFlag = ShouldSuspendCommit;
+function accumulateSuspenseyCommit(finishedWork) {
+  accumulateSuspenseyCommitOnFiber(finishedWork);
+}
+
+function recursivelyAccumulateSuspenseyCommit(parentFiber) {
+  if (parentFiber.subtreeFlags & suspenseyCommitFlag) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      accumulateSuspenseyCommitOnFiber(child);
+      child = child.sibling;
+    }
+  }
+}
+
+function accumulateSuspenseyCommitOnFiber(fiber) {
+  switch (fiber.tag) {
+    case HostHoistable:
+      {
+        recursivelyAccumulateSuspenseyCommit(fiber);
+
+        if (fiber.flags & suspenseyCommitFlag) {
+          if (fiber.memoizedState !== null) {
+            suspendResource( // This should always be set by visiting HostRoot first
+            currentHoistableRoot, fiber.memoizedState, fiber.memoizedProps);
+          }
+        }
+
+        break;
+      }
+
+    case HostComponent:
+      {
+        recursivelyAccumulateSuspenseyCommit(fiber);
+
+        break;
+      }
+
+    case HostRoot:
+    case HostPortal:
+      {
+        {
+          const previousHoistableRoot = currentHoistableRoot;
+          const container = fiber.stateNode.containerInfo;
+          currentHoistableRoot = getHoistableRoot(container);
+          recursivelyAccumulateSuspenseyCommit(fiber);
+          currentHoistableRoot = previousHoistableRoot;
+        }
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const isHidden = fiber.memoizedState !== null;
+
+        if (isHidden) ; else {
+          const current = fiber.alternate;
+          const wasHidden = current !== null && current.memoizedState !== null;
+
+          if (wasHidden) {
+            // This tree is being revealed. Visit all newly visible suspensey
+            // instances, even if they're in the current tree.
+            const prevFlags = suspenseyCommitFlag;
+            suspenseyCommitFlag = MaySuspendCommit;
+            recursivelyAccumulateSuspenseyCommit(fiber);
+            suspenseyCommitFlag = prevFlags;
+          } else {
+            recursivelyAccumulateSuspenseyCommit(fiber);
+          }
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyAccumulateSuspenseyCommit(fiber);
+      }
+  }
+}
+
+function detachAlternateSiblings(parentFiber) {
+  // A fiber was deleted from this parent fiber, but it's still part of the
+  // previous (alternate) parent fiber's list of children. Because children
+  // are a linked list, an earlier sibling that's still alive will be
+  // connected to the deleted fiber via its `alternate`:
+  //
+  //   live fiber --alternate--> previous live fiber --sibling--> deleted
+  //   fiber
+  //
+  // We can't disconnect `alternate` on nodes that haven't been deleted yet,
+  // but we can disconnect the `sibling` and `child` pointers.
+  const previousFiber = parentFiber.alternate;
+
+  if (previousFiber !== null) {
+    let detachedChild = previousFiber.child;
+
+    if (detachedChild !== null) {
+      previousFiber.child = null;
+
+      do {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        const detachedSibling = detachedChild.sibling; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+        detachedChild.sibling = null;
+        detachedChild = detachedSibling;
+      } while (detachedChild !== null);
+    }
+  }
+}
+
+function commitHookPassiveUnmountEffects(finishedWork, nearestMountedAncestor, hookFlags) {
+  if (shouldProfile(finishedWork)) {
+    startPassiveEffectTimer();
+    commitHookEffectListUnmount(hookFlags, finishedWork, nearestMountedAncestor);
+    recordPassiveEffectDuration(finishedWork);
+  } else {
+    commitHookEffectListUnmount(hookFlags, finishedWork, nearestMountedAncestor);
+  }
+}
+
+function recursivelyTraversePassiveUnmountEffects(parentFiber) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects have fired.
+  const deletions = parentFiber.deletions;
+
+  if ((parentFiber.flags & ChildDeletion) !== NoFlags$1) {
+    if (deletions !== null) {
+      for (let i = 0; i < deletions.length; i++) {
+        const childToDelete = deletions[i]; // TODO: Convert this to use recursion
+
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(childToDelete, parentFiber);
+      }
+    }
+
+    detachAlternateSiblings(parentFiber);
+  }
+
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    let child = parentFiber.child;
+
+    while (child !== null) {
+      commitPassiveUnmountOnFiber(child);
+      child = child.sibling;
+    }
+  }
+}
+
+function commitPassiveUnmountOnFiber(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        recursivelyTraversePassiveUnmountEffects(finishedWork);
+
+        if (finishedWork.flags & Passive$1) {
+          commitHookPassiveUnmountEffects(finishedWork, finishedWork.return, Passive | HasEffect);
+        }
+
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const instance = finishedWork.stateNode;
+        const nextState = finishedWork.memoizedState;
+        const isHidden = nextState !== null;
+
+        if (isHidden && instance._visibility & OffscreenPassiveEffectsConnected && ( // For backwards compatibility, don't unmount when a tree suspends. In
+        // the future we may change this to unmount after a delay.
+        finishedWork.return === null || finishedWork.return.tag !== SuspenseComponent)) {
+          // The effects are currently connected. Disconnect them.
+          // TODO: Add option or heuristic to delay before disconnecting the
+          // effects. Then if the tree reappears before the delay has elapsed, we
+          // can skip toggling the effects entirely.
+          instance._visibility &= ~OffscreenPassiveEffectsConnected;
+          recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+        } else {
+          recursivelyTraversePassiveUnmountEffects(finishedWork);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraversePassiveUnmountEffects(finishedWork);
+        break;
+      }
+  }
+}
+
+function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects have fired.
+  const deletions = parentFiber.deletions;
+
+  if ((parentFiber.flags & ChildDeletion) !== NoFlags$1) {
+    if (deletions !== null) {
+      for (let i = 0; i < deletions.length; i++) {
+        const childToDelete = deletions[i]; // TODO: Convert this to use recursion
+
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(childToDelete, parentFiber);
+      }
+    }
+
+    detachAlternateSiblings(parentFiber);
+  }
+
+  let child = parentFiber.child;
+
+  while (child !== null) {
+    disconnectPassiveEffect(child);
+    child = child.sibling;
+  }
+}
+
+function disconnectPassiveEffect(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        // TODO: Check PassiveStatic flag
+        commitHookPassiveUnmountEffects(finishedWork, finishedWork.return, Passive); // When disconnecting passive effects, we fire the effects in the same
+        // order as during a deletiong: parent before child
+
+        recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+        break;
+      }
+
+    case OffscreenComponent:
+      {
+        const instance = finishedWork.stateNode;
+
+        if (instance._visibility & OffscreenPassiveEffectsConnected) {
+          instance._visibility &= ~OffscreenPassiveEffectsConnected;
+          recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+        }
+
+        break;
+      }
+
+    default:
+      {
+        recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+        break;
+      }
+  }
+}
+
+function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(deletedSubtreeRoot, nearestMountedAncestor) {
+  while (nextEffect !== null) {
+    const fiber = nextEffect; // Deletion effects fire in parent -> child order
+    commitPassiveUnmountInsideDeletedTreeOnFiber(fiber, nearestMountedAncestor);
+    const child = fiber.child; // TODO: Only traverse subtree if it has a PassiveStatic flag.
+
+    if (child !== null) {
+      child.return = fiber;
+      nextEffect = child;
+    } else {
+      commitPassiveUnmountEffectsInsideOfDeletedTree_complete(deletedSubtreeRoot);
+    }
+  }
+}
+
+function commitPassiveUnmountEffectsInsideOfDeletedTree_complete(deletedSubtreeRoot) {
+  while (nextEffect !== null) {
+    const fiber = nextEffect;
+    const sibling = fiber.sibling;
+    const returnFiber = fiber.return; // Recursively traverse the entire deleted tree and clean up fiber fields.
+    // This is more aggressive than ideal, and the long term goal is to only
+    // have to detach the deleted tree at the root.
+
+    detachFiberAfterEffects(fiber);
+
+    if (fiber === deletedSubtreeRoot) {
+      nextEffect = null;
+      return;
+    }
+
+    if (sibling !== null) {
+      sibling.return = returnFiber;
+      nextEffect = sibling;
+      return;
+    }
+
+    nextEffect = returnFiber;
+  }
+}
+
+function commitPassiveUnmountInsideDeletedTreeOnFiber(current, nearestMountedAncestor) {
+  switch (current.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        commitHookPassiveUnmountEffects(current, nearestMountedAncestor, Passive);
+        break;
+      }
+    // TODO: run passive unmount effects when unmounting a root.
+    // Because passive unmount effects are not currently run,
+    // the cache instance owned by the root will never be freed.
+    // When effects are run, the cache should be freed here:
+    // case HostRoot: {
+    //   if (enableCache) {
+    //     const cache = current.memoizedState.cache;
+    //     releaseCache(cache);
+    //   }
+    //   break;
+    // }
+
+    case LegacyHiddenComponent:
+    case OffscreenComponent:
+      {
+        {
+          if (current.memoizedState !== null && current.memoizedState.cachePool !== null) {
+            const cache = current.memoizedState.cachePool.pool; // Retain/release the cache used for pending (suspended) nodes.
+            // Note that this is only reached in the non-suspended/visible case:
+            // when the content is suspended/hidden, the retain/release occurs
+            // via the parent Suspense component (see case above).
+
+            if (cache != null) {
+              retainCache(cache);
+            }
+          }
+        }
+
+        break;
+      }
+
+    case SuspenseComponent:
+      {
+
+        break;
+      }
+
+    case CacheComponent:
+      {
+        {
+          const cache = current.memoizedState.cache;
+          releaseCache(cache);
+        }
+
+        break;
+      }
+  }
+}
+
+function getCacheSignal() {
+
+  const cache = readContext(CacheContext);
+  return cache.controller.signal;
+}
+
+function getCacheForType(resourceType) {
+
+  const cache = readContext(CacheContext);
+  let cacheForType = cache.data.get(resourceType);
+
+  if (cacheForType === undefined) {
+    cacheForType = resourceType();
+    cache.data.set(resourceType, cacheForType);
+  }
+
+  return cacheForType;
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal,
+  getCacheForType
+};
+
+const PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
+      ReactCurrentCache = ReactSharedInternals.ReactCurrentCache,
+      ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner,
+      ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig,
+      ReactCurrentActQueue = ReactSharedInternals.ReactCurrentActQueue;
+const NoContext =
+/*             */
+0b000;
+const BatchedContext =
+/*               */
+0b001;
+const RenderContext =
+/*         */
+0b010;
+const CommitContext =
+/*         */
+0b100;
+const RootInProgress = 0;
+const RootFatalErrored = 1;
+const RootErrored = 2;
+const RootSuspended = 3;
+const RootSuspendedWithDelay = 4;
+const RootCompleted = 5;
+const RootDidNotComplete = 6; // Describes where we are in the React execution stack
+
+let executionContext = NoContext; // The root we're working on
+
+let workInProgressRoot = null; // The fiber we're working on
+
+let workInProgress = null; // The lanes we're rendering
+
+let workInProgressRootRenderLanes = NoLanes;
+const NotSuspended = 0;
+const SuspendedOnError = 1;
+const SuspendedOnData = 2;
+const SuspendedOnImmediate = 3;
+const SuspendedOnInstance = 4;
+const SuspendedOnInstanceAndReadyToContinue = 5;
+const SuspendedOnDeprecatedThrowPromise = 6;
+const SuspendedAndReadyToContinue = 7;
+const SuspendedOnHydration = 8; // When this is true, the work-in-progress fiber just suspended (or errored) and
+// we've yet to unwind the stack. In some cases, we may yield to the main thread
+// after this happens. If the fiber is pinged before we resume, we can retry
+// immediately instead of unwinding the stack.
+
+let workInProgressSuspendedReason = NotSuspended;
+let workInProgressThrownValue = null; // Whether a ping listener was attached during this render. This is slightly
+// different that whether something suspended, because we don't add multiple
+// listeners to a promise we've already seen (per root and lane).
+
+let workInProgressRootDidAttachPingListener = false; // A contextual version of workInProgressRootRenderLanes. It is a superset of
+// the lanes that we started working on at the root. When we enter a subtree
+// that is currently hidden, we add the lanes that would have committed if
+// the hidden tree hadn't been deferred. This is modified by the
+// HiddenContext module.
+//
+// Most things in the work loop should deal with workInProgressRootRenderLanes.
+// Most things in begin/complete phases should deal with entangledRenderLanes.
+
+let entangledRenderLanes = NoLanes; // Whether to root completed, errored, suspended, etc.
+
+let workInProgressRootExitStatus = RootInProgress; // A fatal error, if one is thrown
+
+let workInProgressRootFatalError = null; // The work left over by components that were visited during this render. Only
+// includes unprocessed updates, not work in bailed out children.
+
+let workInProgressRootSkippedLanes = NoLanes; // Lanes that were updated (in an interleaved event) during this render.
+
+let workInProgressRootInterleavedUpdatedLanes = NoLanes; // Lanes that were updated during the render phase (*not* an interleaved event).
+
+let workInProgressRootPingedLanes = NoLanes; // If this lane scheduled deferred work, this is the lane of the deferred task.
+
+let workInProgressDeferredLane = NoLane; // Errors that are thrown during the render phase.
+
+let workInProgressRootConcurrentErrors = null; // These are errors that we recovered from without surfacing them to the UI.
+// We will log them once the tree commits.
+
+let workInProgressRootRecoverableErrors = null; // The most recent time we either committed a fallback, or when a fallback was
+// filled in with the resolved UI. This lets us throttle the appearance of new
+// content as it streams in, to minimize jank.
+// TODO: Think of a better name for this variable?
+
+let globalMostRecentFallbackTime = 0;
+const FALLBACK_THROTTLE_MS = 300; // The absolute time for when we should start giving up on rendering
+// more and prefer CPU suspense heuristics instead.
+
+let workInProgressRootRenderTargetTime = Infinity; // How long a render is supposed to take before we start following CPU
+// suspense heuristics and opt out of rendering more content.
+
+const RENDER_TIMEOUT_MS = 500;
+let workInProgressTransitions = null;
+
+function resetRenderTimer() {
+  workInProgressRootRenderTargetTime = now$1() + RENDER_TIMEOUT_MS;
+}
+
+function getRenderTargetTime() {
+  return workInProgressRootRenderTargetTime;
+}
+let hasUncaughtError = false;
+let firstUncaughtError = null;
+let legacyErrorBoundariesThatAlreadyFailed = null; // Only used when enableProfilerNestedUpdateScheduledHook is true;
+let rootDoesHavePassiveEffects = false;
+let rootWithPendingPassiveEffects = null;
+let pendingPassiveEffectsLanes = NoLanes;
+let pendingPassiveProfilerEffects = [];
+let pendingPassiveEffectsRemainingLanes = NoLanes;
+let pendingPassiveTransitions = null; // Use these to prevent an infinite loop of nested updates
+
+const NESTED_UPDATE_LIMIT = 50;
+let nestedUpdateCount = 0;
+let rootWithNestedUpdates = null;
+function getWorkInProgressRoot() {
+  return workInProgressRoot;
+}
+function getWorkInProgressRootRenderLanes() {
+  return workInProgressRootRenderLanes;
+}
+function isWorkLoopSuspendedOnData() {
+  return workInProgressSuspendedReason === SuspendedOnData;
+}
+function requestUpdateLane(fiber) {
+  // Special cases
+  const mode = fiber.mode;
+
+  if ((mode & ConcurrentMode) === NoMode) {
+    return SyncLane;
+  } else if ((executionContext & RenderContext) !== NoContext && workInProgressRootRenderLanes !== NoLanes) {
+    // This is a render phase update. These are not officially supported. The
+    // old behavior is to give this the same "thread" (lanes) as
+    // whatever is currently rendering. So if you call `setState` on a component
+    // that happens later in the same render, it will flush. Ideally, we want to
+    // remove the special case and treat them as if they came from an
+    // interleaved event. Regardless, this pattern is not officially supported.
+    // This behavior is only a fallback. The flag only exists until we can roll
+    // out the setState warning, since existing code might accidentally rely on
+    // the current behavior.
+    return pickArbitraryLane(workInProgressRootRenderLanes);
+  }
+
+  const isTransition = requestCurrentTransition() !== NoTransition;
+
+  if (isTransition) {
+
+    const actionScopeLane = peekEntangledActionLane();
+    return actionScopeLane !== NoLane ? // We're inside an async action scope. Reuse the same lane.
+    actionScopeLane : // We may or may not be inside an async action scope. If we are, this
+    // is the first update in that scope. Either way, we need to get a
+    // fresh transition lane.
+    requestTransitionLane();
+  } // Updates originating inside certain React methods, like flushSync, have
+  // their priority set by tracking it with a context variable.
+  //
+  // The opaque type returned by the host config is internally a lane, so we can
+  // use that directly.
+  // TODO: Move this type conversion to the event priority module.
+
+
+  const updateLane = getCurrentUpdatePriority();
+
+  if (updateLane !== NoLane) {
+    return updateLane;
+  } // This update originated outside React. Ask the host environment for an
+  // appropriate priority, based on the type of event.
+  //
+  // The opaque type returned by the host config is internally a lane, so we can
+  // use that directly.
+  // TODO: Move this type conversion to the event priority module.
+
+
+  const eventLane = getCurrentEventPriority();
+  return eventLane;
+}
+
+function requestRetryLane(fiber) {
+  // This is a fork of `requestUpdateLane` designed specifically for Suspense
+  // "retries" — a special update that attempts to flip a Suspense boundary
+  // from its placeholder state to its primary/resolved state.
+  // Special cases
+  const mode = fiber.mode;
+
+  if ((mode & ConcurrentMode) === NoMode) {
+    return SyncLane;
+  }
+
+  return claimNextRetryLane();
+}
+
+function requestDeferredLane() {
+  if (workInProgressDeferredLane === NoLane) {
+    // If there are multiple useDeferredValue hooks in the same render, the
+    // tasks that they spawn should all be batched together, so they should all
+    // receive the same lane.
+    // Check the priority of the current render to decide the priority of the
+    // deferred task.
+    // OffscreenLane is used for prerendering, but we also use OffscreenLane
+    // for incremental hydration. It's given the lowest priority because the
+    // initial HTML is the same as the final UI. But useDeferredValue during
+    // hydration is an exception — we need to upgrade the UI to the final
+    // value. So if we're currently hydrating, we treat it like a transition.
+    const isPrerendering = includesSomeLane(workInProgressRootRenderLanes, OffscreenLane) && !getIsHydrating();
+
+    if (isPrerendering) {
+      // There's only one OffscreenLane, so if it contains deferred work, we
+      // should just reschedule using the same lane.
+      workInProgressDeferredLane = OffscreenLane;
+    } else {
+      // Everything else is spawned as a transition.
+      workInProgressDeferredLane = requestTransitionLane();
+    }
+  }
+
+  return workInProgressDeferredLane;
+}
+function scheduleUpdateOnFiber(root, fiber, lane) {
+  // finish loading.
+
+
+  if ( // Suspended render phase
+  root === workInProgressRoot && workInProgressSuspendedReason === SuspendedOnData || // Suspended commit phase
+  root.cancelPendingCommit !== null) {
+    // The incoming update might unblock the current render. Interrupt the
+    // current attempt and restart from the top.
+    prepareFreshStack(root, NoLanes);
+    markRootSuspended(root, workInProgressRootRenderLanes, workInProgressDeferredLane);
+  } // Mark that the root has a pending update.
+
+
+  markRootUpdated(root, lane);
+
+  if ((executionContext & RenderContext) !== NoLanes && root === workInProgressRoot) ; else {
+    // This is a normal update, scheduled from outside the render phase. For
+    // example, during an input event.
+    {
+      if (isDevToolsPresent) {
+        addFiberToLanesMap(root, fiber, lane);
+      }
+    }
+
+    if (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.
+      if ((executionContext & RenderContext) === NoContext) {
+        workInProgressRootInterleavedUpdatedLanes = mergeLanes(workInProgressRootInterleavedUpdatedLanes, lane);
+      }
+
+      if (workInProgressRootExitStatus === RootSuspendedWithDelay) {
+        // The root already suspended with a delay, which means this render
+        // definitely won't finish. Since we have a new update, let's mark it as
+        // suspended now, right before marking the incoming update. This has the
+        // effect of interrupting the current render and switching to the update.
+        // TODO: Make sure this doesn't override pings that happen while we've
+        // already started rendering.
+        markRootSuspended(root, workInProgressRootRenderLanes, workInProgressDeferredLane);
+      }
+    }
+
+    ensureRootIsScheduled(root);
+
+    if (lane === SyncLane && executionContext === NoContext && (fiber.mode & ConcurrentMode) === NoMode) {
+      {
+        // Flush the synchronous work now, unless we're already working or inside
+        // a batch. This is intentionally inside scheduleUpdateOnFiber instead of
+        // scheduleCallbackForFiber to preserve the ability to schedule a callback
+        // without immediately flushing it. We only do this for user-initiated
+        // updates, to preserve historical behavior of legacy mode.
+        resetRenderTimer();
+        flushSyncWorkOnLegacyRootsOnly();
+      }
+    }
+  }
+}
+function scheduleInitialHydrationOnRoot(root, lane) {
+  // This is a special fork of scheduleUpdateOnFiber that is only used to
+  // schedule the initial hydration of a root that has just been created. Most
+  // of the stuff in scheduleUpdateOnFiber can be skipped.
+  //
+  // The main reason for this separate path, though, is to distinguish the
+  // initial children from subsequent updates. In fully client-rendered roots
+  // (createRoot instead of hydrateRoot), all top-level renders are modeled as
+  // updates, but hydration roots are special because the initial render must
+  // match what was rendered on the server.
+  const current = root.current;
+  current.lanes = lane;
+  markRootUpdated(root, lane);
+  ensureRootIsScheduled(root);
+}
+function isUnsafeClassRenderPhaseUpdate(fiber) {
+  // Check if this is a render phase update. Only called by class components,
+  // which special (deprecated) behavior for UNSAFE_componentWillReceive props.
+  return (executionContext & RenderContext) !== NoContext;
+} // This is the entry point for every concurrent task, i.e. anything that
+// goes through Scheduler.
+
+function performConcurrentWorkOnRoot(root, didTimeout) {
+  {
+    resetNestedUpdateFlag();
+  }
+
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw Error(formatProdErrorMessage(327));
+  } // Flush any pending passive effects before deciding which lanes to work on,
+  // in case they schedule additional work.
+
+
+  const originalCallbackNode = root.callbackNode;
+  const didFlushPassiveEffects = flushPassiveEffects();
+
+  if (didFlushPassiveEffects) {
+    // Something in the passive effect phase may have canceled the current task.
+    // Check if the task node for this root was changed.
+    if (root.callbackNode !== originalCallbackNode) {
+      // The current task was canceled. Exit. We don't need to call
+      // `ensureRootIsScheduled` because the check above implies either that
+      // there's a new task, or that there's no remaining work on this root.
+      return null;
+    }
+  } // Determine the next lanes to work on, using the fields stored
+  // on the root.
+  // TODO: This was already computed in the caller. Pass it as an argument.
+
+
+  let lanes = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes);
+
+  if (lanes === NoLanes) {
+    // Defensive coding. This is never expected to happen.
+    return null;
+  } // We disable time-slicing in some cases: if the work has been CPU-bound
+  // for too long ("expired" work, to prevent starvation), or we're in
+  // sync-updates-by-default mode.
+  // TODO: We only check `didTimeout` defensively, to account for a Scheduler
+  // bug we're still investigating. Once the bug in Scheduler is fixed,
+  // we can remove this, since we track expiration ourselves.
+
+
+  const shouldTimeSlice = !includesBlockingLane(root, lanes) && !includesExpiredLane(root, lanes) && (!didTimeout);
+  let exitStatus = shouldTimeSlice ? renderRootConcurrent(root, lanes) : renderRootSync(root, lanes);
+
+  if (exitStatus !== RootInProgress) {
+    let renderWasConcurrent = shouldTimeSlice;
+
+    do {
+      if (exitStatus === RootDidNotComplete) {
+        // The render unwound without completing the tree. This happens in special
+        // cases where need to exit the current render without producing a
+        // consistent tree or committing.
+        markRootSuspended(root, lanes, NoLane);
+      } else {
+        // The render completed.
+        // Check if this render may have yielded to a concurrent event, and if so,
+        // confirm that any newly rendered stores are consistent.
+        // TODO: It's possible that even a concurrent render may never have yielded
+        // to the main thread, if it was fast enough, or if it expired. We could
+        // skip the consistency check in that case, too.
+        const finishedWork = root.current.alternate;
+
+        if (renderWasConcurrent && !isRenderConsistentWithExternalStores(finishedWork)) {
+          // A store was mutated in an interleaved event. Render again,
+          // synchronously, to block further mutations.
+          exitStatus = renderRootSync(root, lanes); // We assume the tree is now consistent because we didn't yield to any
+          // concurrent events.
+
+          renderWasConcurrent = false; // Need to check the exit status again.
+
+          continue;
+        } // Check if something threw
+
+
+        if (exitStatus === RootErrored) {
+          const originallyAttemptedLanes = lanes;
+          const errorRetryLanes = getLanesToRetrySynchronouslyOnError(root, originallyAttemptedLanes);
+
+          if (errorRetryLanes !== NoLanes) {
+            lanes = errorRetryLanes;
+            exitStatus = recoverFromConcurrentError(root, originallyAttemptedLanes, errorRetryLanes);
+            renderWasConcurrent = false;
+          }
+        }
+
+        if (exitStatus === RootFatalErrored) {
+          const fatalError = workInProgressRootFatalError;
+          prepareFreshStack(root, NoLanes);
+          markRootSuspended(root, lanes, NoLane);
+          ensureRootIsScheduled(root);
+          throw fatalError;
+        } // We now have a consistent tree. The next step is either to commit it,
+        // or, if something suspended, wait to commit it after a timeout.
+
+
+        root.finishedWork = finishedWork;
+        root.finishedLanes = lanes;
+        finishConcurrentRender(root, exitStatus, finishedWork, lanes);
+      }
+
+      break;
+    } while (true);
+  }
+
+  ensureRootIsScheduled(root);
+  return getContinuationForRoot(root, originalCallbackNode);
+}
+
+function recoverFromConcurrentError(root, originallyAttemptedLanes, errorRetryLanes) {
+  // If an error occurred during hydration, discard server response and fall
+  // back to client side render.
+  // Before rendering again, save the errors from the previous attempt.
+  const errorsFromFirstAttempt = workInProgressRootConcurrentErrors;
+  const wasRootDehydrated = isRootDehydrated(root);
+
+  if (wasRootDehydrated) {
+    // The shell failed to hydrate. Set a flag to force a client rendering
+    // during the next attempt. To do this, we call prepareFreshStack now
+    // to create the root work-in-progress fiber. This is a bit weird in terms
+    // of factoring, because it relies on renderRootSync not calling
+    // prepareFreshStack again in the call below, which happens because the
+    // root and lanes haven't changed.
+    //
+    // TODO: I think what we should do is set ForceClientRender inside
+    // throwException, like we do for nested Suspense boundaries. The reason
+    // it's here instead is so we can switch to the synchronous work loop, too.
+    // Something to consider for a future refactor.
+    const rootWorkInProgress = prepareFreshStack(root, errorRetryLanes);
+    rootWorkInProgress.flags |= ForceClientRender;
+  }
+
+  const exitStatus = renderRootSync(root, errorRetryLanes);
+
+  if (exitStatus !== RootErrored) {
+    // Successfully finished rendering on retry
+    if (workInProgressRootDidAttachPingListener && !wasRootDehydrated) {
+      // During the synchronous render, we attached additional ping listeners.
+      // This is highly suggestive of an uncached promise (though it's not the
+      // only reason this would happen). If it was an uncached promise, then
+      // it may have masked a downstream error from ocurring without actually
+      // fixing it. Example:
+      //
+      //    use(Promise.resolve('uncached'))
+      //    throw new Error('Oops!')
+      //
+      // When this happens, there's a conflict between blocking potential
+      // concurrent data races and unwrapping uncached promise values. We
+      // have to choose one or the other. Because the data race recovery is
+      // a last ditch effort, we'll disable it.
+      root.errorRecoveryDisabledLanes = mergeLanes(root.errorRecoveryDisabledLanes, originallyAttemptedLanes); // Mark the current render as suspended and force it to restart. Once
+      // these lanes finish successfully, we'll re-enable the error recovery
+      // mechanism for subsequent updates.
+
+      workInProgressRootInterleavedUpdatedLanes |= originallyAttemptedLanes;
+      return RootSuspendedWithDelay;
+    } // The errors from the failed first attempt have been recovered. Add
+    // them to the collection of recoverable errors. We'll log them in the
+    // commit phase.
+
+
+    const errorsFromSecondAttempt = workInProgressRootRecoverableErrors;
+    workInProgressRootRecoverableErrors = errorsFromFirstAttempt; // The errors from the second attempt should be queued after the errors
+    // from the first attempt, to preserve the causal sequence.
+
+    if (errorsFromSecondAttempt !== null) {
+      queueRecoverableErrors(errorsFromSecondAttempt);
+    }
+  }
+
+  return exitStatus;
+}
+
+function queueRecoverableErrors(errors) {
+  if (workInProgressRootRecoverableErrors === null) {
+    workInProgressRootRecoverableErrors = errors;
+  } else {
+    // $FlowFixMe[method-unbinding]
+    workInProgressRootRecoverableErrors.push.apply(workInProgressRootRecoverableErrors, errors);
+  }
+}
+
+function finishConcurrentRender(root, exitStatus, finishedWork, lanes) {
+  // TODO: The fact that most of these branches are identical suggests that some
+  // of the exit statuses are not best modeled as exit statuses and should be
+  // tracked orthogonally.
+  switch (exitStatus) {
+    case RootInProgress:
+    case RootFatalErrored:
+      {
+        throw Error(formatProdErrorMessage(345));
+      }
+
+    case RootSuspendedWithDelay:
+      {
+        if (includesOnlyTransitions(lanes)) {
+          // This is a transition, so we should exit without committing a
+          // placeholder and without scheduling a timeout. Delay indefinitely
+          // until we receive more data.
+          markRootSuspended(root, lanes, workInProgressDeferredLane);
+          return;
+        } // Commit the placeholder.
+
+
+        break;
+      }
+
+    case RootErrored:
+    case RootSuspended:
+    case RootCompleted:
+      {
+        break;
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(329));
+      }
+  }
+
+  {
+    if (includesOnlyRetries(lanes) && (alwaysThrottleRetries )) {
+      // This render only included retries, no updates. Throttle committing
+      // retries so that we don't show too many loading states too quickly.
+      const msUntilTimeout = globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now$1(); // Don't bother with a very short suspense time.
+
+      if (msUntilTimeout > 10) {
+        markRootSuspended(root, lanes, workInProgressDeferredLane);
+        const nextLanes = getNextLanes(root, NoLanes);
+
+        if (nextLanes !== NoLanes) {
+          // There's additional work we can do on this root. We might as well
+          // attempt to work on that while we're suspended.
+          return;
+        } // The render is suspended, it hasn't timed out, and there's no
+        // lower priority work to do. Instead of committing the fallback
+        // immediately, wait for more data to arrive.
+        // TODO: Combine retry throttling with Suspensey commits. Right now they
+        // run one after the other.
+
+
+        root.timeoutHandle = scheduleTimeout(commitRootWhenReady.bind(null, root, finishedWork, workInProgressRootRecoverableErrors, workInProgressTransitions, lanes, workInProgressDeferredLane), msUntilTimeout);
+        return;
+      }
+    }
+
+    commitRootWhenReady(root, finishedWork, workInProgressRootRecoverableErrors, workInProgressTransitions, lanes, workInProgressDeferredLane);
+  }
+}
+
+function commitRootWhenReady(root, finishedWork, recoverableErrors, transitions, lanes, spawnedLane) {
+  // TODO: Combine retry throttling with Suspensey commits. Right now they run
+  // one after the other.
+  if (includesOnlyNonUrgentLanes(lanes)) {
+    // Before committing, ask the renderer whether the host tree is ready.
+    // If it's not, we'll wait until it notifies us.
+    startSuspendingCommit(); // This will walk the completed fiber tree and attach listeners to all
+    // the suspensey resources. The renderer is responsible for accumulating
+    // all the load events. This all happens in a single synchronous
+    // transaction, so it track state in its own module scope.
+
+    accumulateSuspenseyCommit(finishedWork); // At the end, ask the renderer if it's ready to commit, or if we should
+    // suspend. If it's not ready, it will return a callback to subscribe to
+    // a ready event.
+
+    const schedulePendingCommit = waitForCommitToBeReady();
+
+    if (schedulePendingCommit !== null) {
+      // NOTE: waitForCommitToBeReady returns a subscribe function so that we
+      // only allocate a function if the commit isn't ready yet. The other
+      // pattern would be to always pass a callback to waitForCommitToBeReady.
+      // Not yet ready to commit. Delay the commit until the renderer notifies
+      // us that it's ready. This will be canceled if we start work on the
+      // root again.
+      root.cancelPendingCommit = schedulePendingCommit(commitRoot.bind(null, root, recoverableErrors, transitions));
+      markRootSuspended(root, lanes, spawnedLane);
+      return;
+    }
+  } // Otherwise, commit immediately.
+
+
+  commitRoot(root, recoverableErrors, transitions, spawnedLane);
+}
+
+function isRenderConsistentWithExternalStores(finishedWork) {
+  // Search the rendered tree for external store reads, and check whether the
+  // stores were mutated in a concurrent event. Intentionally using an iterative
+  // loop instead of recursion so we can exit early.
+  let node = finishedWork;
+
+  while (true) {
+    if (node.flags & StoreConsistency) {
+      const updateQueue = node.updateQueue;
+
+      if (updateQueue !== null) {
+        const checks = updateQueue.stores;
+
+        if (checks !== null) {
+          for (let i = 0; i < checks.length; i++) {
+            const check = checks[i];
+            const getSnapshot = check.getSnapshot;
+            const renderedValue = check.value;
+
+            try {
+              if (!objectIs(getSnapshot(), renderedValue)) {
+                // Found an inconsistent store.
+                return false;
+              }
+            } catch (error) {
+              // If `getSnapshot` throws, return `false`. This will schedule
+              // a re-render, and the error will be rethrown during render.
+              return false;
+            }
+          }
+        }
+      }
+    }
+
+    const child = node.child;
+
+    if (node.subtreeFlags & StoreConsistency && child !== null) {
+      child.return = node;
+      node = child;
+      continue;
+    }
+
+    if (node === finishedWork) {
+      return true;
+    }
+
+    while (node.sibling === null) {
+      if (node.return === null || node.return === finishedWork) {
+        return true;
+      }
+
+      node = node.return;
+    }
+
+    node.sibling.return = node.return;
+    node = node.sibling;
+  } // Flow doesn't know this is unreachable, but eslint does
+  // eslint-disable-next-line no-unreachable
+
+
+  return true;
+}
+
+function markRootSuspended(root, suspendedLanes, spawnedLane) {
+  // When suspending, we should always exclude lanes that were pinged or (more
+  // rarely, since we try to avoid it) updated during the render phase.
+  // TODO: Lol maybe there's a better way to factor this besides this
+  // obnoxiously named function :)
+  suspendedLanes = removeLanes(suspendedLanes, workInProgressRootPingedLanes);
+  suspendedLanes = removeLanes(suspendedLanes, workInProgressRootInterleavedUpdatedLanes);
+  markRootSuspended$1(root, suspendedLanes, spawnedLane);
+} // This is the entry point for synchronous tasks that don't go
+// through Scheduler
+
+
+function performSyncWorkOnRoot(root, lanes) {
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw Error(formatProdErrorMessage(327));
+  }
+
+  const didFlushPassiveEffects = flushPassiveEffects();
+
+  if (didFlushPassiveEffects) {
+    // If passive effects were flushed, exit to the outer work loop in the root
+    // scheduler, so we can recompute the priority.
+    // TODO: We don't actually need this `ensureRootIsScheduled` call because
+    // this path is only reachable if the root is already part of the schedule.
+    // I'm including it only for consistency with the other exit points from
+    // this function. Can address in a subsequent refactor.
+    ensureRootIsScheduled(root);
+    return null;
+  }
+
+  {
+    syncNestedUpdateFlag();
+  }
+
+  let exitStatus = renderRootSync(root, lanes);
+
+  if (root.tag !== LegacyRoot && exitStatus === RootErrored) {
+    // If something threw an error, try rendering one more time. We'll render
+    // synchronously to block concurrent data mutations, and we'll includes
+    // all pending updates are included. If it still fails after the second
+    // attempt, we'll give up and commit the resulting tree.
+    const originallyAttemptedLanes = lanes;
+    const errorRetryLanes = getLanesToRetrySynchronouslyOnError(root, originallyAttemptedLanes);
+
+    if (errorRetryLanes !== NoLanes) {
+      lanes = errorRetryLanes;
+      exitStatus = recoverFromConcurrentError(root, originallyAttemptedLanes, errorRetryLanes);
+    }
+  }
+
+  if (exitStatus === RootFatalErrored) {
+    const fatalError = workInProgressRootFatalError;
+    prepareFreshStack(root, NoLanes);
+    markRootSuspended(root, lanes, NoLane);
+    ensureRootIsScheduled(root);
+    throw fatalError;
+  }
+
+  if (exitStatus === RootDidNotComplete) {
+    // The render unwound without completing the tree. This happens in special
+    // cases where need to exit the current render without producing a
+    // consistent tree or committing.
+    markRootSuspended(root, lanes, NoLane);
+    ensureRootIsScheduled(root);
+    return null;
+  } // We now have a consistent tree. Because this is a sync render, we
+  // will commit it even if something suspended.
+
+
+  const finishedWork = root.current.alternate;
+  root.finishedWork = finishedWork;
+  root.finishedLanes = lanes;
+  commitRoot(root, workInProgressRootRecoverableErrors, workInProgressTransitions, workInProgressDeferredLane); // Before exiting, make sure there's a callback scheduled for the next
+  // pending level.
+
+  ensureRootIsScheduled(root);
+  return null;
+}
+function flushRoot(root, lanes) {
+  if (lanes !== NoLanes) {
+    upgradePendingLanesToSync(root, lanes);
+    ensureRootIsScheduled(root);
+
+    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
+      resetRenderTimer(); // TODO: For historical reasons this flushes all sync work across all
+      // roots. It shouldn't really matter either way, but we could change this
+      // to only flush the given root.
+
+      flushSyncWorkOnAllRoots();
+    }
+  }
+}
+function getExecutionContext() {
+  return executionContext;
+}
+function batchedUpdates$1(fn, a) {
+  const prevExecutionContext = executionContext;
+  executionContext |= BatchedContext;
+
+  try {
+    return fn(a);
+  } finally {
+    executionContext = prevExecutionContext; // If there were legacy sync updates, flush them at the end of the outer
+    // most batchedUpdates-like method.
+
+    if (executionContext === NoContext && // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.
+    !(false )) {
+      resetRenderTimer();
+      flushSyncWorkOnLegacyRootsOnly();
+    }
+  }
+}
+// Warning, this opts-out of checking the function body.
+// eslint-disable-next-line no-unused-vars
+// eslint-disable-next-line no-redeclare
+// eslint-disable-next-line no-redeclare
+
+function flushSync$1(fn) {
+  // In legacy mode, we flush pending passive effects at the beginning of the
+  // next event, not at the end of the previous one.
+  if (rootWithPendingPassiveEffects !== null && rootWithPendingPassiveEffects.tag === LegacyRoot && (executionContext & (RenderContext | CommitContext)) === NoContext) {
+    flushPassiveEffects();
+  }
+
+  const prevExecutionContext = executionContext;
+  executionContext |= BatchedContext;
+  const prevTransition = ReactCurrentBatchConfig$1.transition;
+  const previousPriority = getCurrentUpdatePriority();
+
+  try {
+    ReactCurrentBatchConfig$1.transition = null;
+    setCurrentUpdatePriority(DiscreteEventPriority);
+
+    if (fn) {
+      return fn();
+    } else {
+      return undefined;
+    }
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+    executionContext = prevExecutionContext; // Flush the immediate callbacks that were scheduled during this batch.
+    // Note that this will happen even if batchedUpdates is higher up
+    // the stack.
+
+    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
+      flushSyncWorkOnAllRoots();
+    }
+  }
+}
+// hidden subtree. The stack logic is managed there because that's the only
+// place that ever modifies it. Which module it lives in doesn't matter for
+// performance because this function will get inlined regardless
+
+function setEntangledRenderLanes(newEntangledRenderLanes) {
+  entangledRenderLanes = newEntangledRenderLanes;
+}
+function getEntangledRenderLanes() {
+  return entangledRenderLanes;
+}
+
+function resetWorkInProgressStack() {
+  if (workInProgress === null) return;
+  let interruptedWork;
+
+  if (workInProgressSuspendedReason === NotSuspended) {
+    // Normal case. Work-in-progress hasn't started yet. Unwind all
+    // its parents.
+    interruptedWork = workInProgress.return;
+  } else {
+    // Work-in-progress is in suspended state. Reset the work loop and unwind
+    // both the suspended fiber and all its parents.
+    resetSuspendedWorkLoopOnUnwind(workInProgress);
+    interruptedWork = workInProgress;
+  }
+
+  while (interruptedWork !== null) {
+    const current = interruptedWork.alternate;
+    unwindInterruptedWork(current, interruptedWork);
+    interruptedWork = interruptedWork.return;
+  }
+
+  workInProgress = null;
+}
+
+function prepareFreshStack(root, lanes) {
+  root.finishedWork = null;
+  root.finishedLanes = NoLanes;
+  const timeoutHandle = root.timeoutHandle;
+
+  if (timeoutHandle !== noTimeout) {
+    // The root previous suspended and scheduled a timeout to commit a fallback
+    // state. Now that we have additional work, cancel the timeout.
+    root.timeoutHandle = noTimeout; // $FlowFixMe[incompatible-call] Complains noTimeout is not a TimeoutID, despite the check above
+
+    cancelTimeout(timeoutHandle);
+  }
+
+  const cancelPendingCommit = root.cancelPendingCommit;
+
+  if (cancelPendingCommit !== null) {
+    root.cancelPendingCommit = null;
+    cancelPendingCommit();
+  }
+
+  resetWorkInProgressStack();
+  workInProgressRoot = root;
+  const rootWorkInProgress = createWorkInProgress(root.current, null);
+  workInProgress = rootWorkInProgress;
+  workInProgressRootRenderLanes = lanes;
+  workInProgressSuspendedReason = NotSuspended;
+  workInProgressThrownValue = null;
+  workInProgressRootDidAttachPingListener = false;
+  workInProgressRootExitStatus = RootInProgress;
+  workInProgressRootFatalError = null;
+  workInProgressRootSkippedLanes = NoLanes;
+  workInProgressRootInterleavedUpdatedLanes = NoLanes;
+  workInProgressRootPingedLanes = NoLanes;
+  workInProgressDeferredLane = NoLane;
+  workInProgressRootConcurrentErrors = null;
+  workInProgressRootRecoverableErrors = null; // Get the lanes that are entangled with whatever we're about to render. We
+  // track these separately so we can distinguish the priority of the render
+  // task from the priority of the lanes it is entangled with. For example, a
+  // transition may not be allowed to finish unless it includes the Sync lane,
+  // which is currently suspended. We should be able to render the Transition
+  // and Sync lane in the same batch, but at Transition priority, because the
+  // Sync lane already suspended.
+
+  entangledRenderLanes = getEntangledLanes(root, lanes);
+  finishQueueingConcurrentUpdates();
+
+  return rootWorkInProgress;
+}
+
+function resetSuspendedWorkLoopOnUnwind(fiber) {
+  // Reset module-level state that was set during the render phase.
+  resetContextDependencies();
+  resetHooksOnUnwind(fiber);
+  resetChildReconcilerOnUnwind();
+}
+
+function handleThrow(root, thrownValue) {
+  // A component threw an exception. Usually this is because it suspended, but
+  // it also includes regular program errors.
+  //
+  // We're either going to unwind the stack to show a Suspense or error
+  // boundary, or we're going to replay the component again. Like after a
+  // promise resolves.
+  //
+  // Until we decide whether we're going to unwind or replay, we should preserve
+  // the current state of the work loop without resetting anything.
+  //
+  // If we do decide to unwind the stack, module-level variables will be reset
+  // in resetSuspendedWorkLoopOnUnwind.
+  // These should be reset immediately because they're only supposed to be set
+  // when React is executing user code.
+  resetHooksAfterThrow();
+  ReactCurrentOwner.current = null;
+
+  if (thrownValue === SuspenseException) {
+    // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown value
+    // to be a thenable, because before `use` existed that was the (unstable)
+    // API for suspending. This implementation detail can change later, once we
+    // deprecate the old API in favor of `use`.
+    thrownValue = getSuspendedThenable();
+    workInProgressSuspendedReason = shouldRemainOnPreviousScreen() && // Check if there are other pending updates that might possibly unblock this
+    // component from suspending. This mirrors the check in
+    // renderDidSuspendDelayIfPossible. We should attempt to unify them somehow.
+    // TODO: Consider unwinding immediately, using the
+    // SuspendedOnHydration mechanism.
+    !includesNonIdleWork(workInProgressRootSkippedLanes) && !includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes) ? // Suspend work loop until data resolves
+    SuspendedOnData : // Don't suspend work loop, except to check if the data has
+    // immediately resolved (i.e. in a microtask). Otherwise, trigger the
+    // nearest Suspense fallback.
+    SuspendedOnImmediate;
+  } else if (thrownValue === SuspenseyCommitException) {
+    thrownValue = getSuspendedThenable();
+    workInProgressSuspendedReason = SuspendedOnInstance;
+  } else if (thrownValue === SelectiveHydrationException) {
+    // An update flowed into a dehydrated boundary. Before we can apply the
+    // update, we need to finish hydrating. Interrupt the work-in-progress
+    // render so we can restart at the hydration lane.
+    //
+    // The ideal implementation would be able to switch contexts without
+    // unwinding the current stack.
+    //
+    // We could name this something more general but as of now it's the only
+    // case where we think this should happen.
+    workInProgressSuspendedReason = SuspendedOnHydration;
+  } else {
+    // This is a regular error.
+    const isWakeable = thrownValue !== null && typeof thrownValue === 'object' && typeof thrownValue.then === 'function';
+    workInProgressSuspendedReason = isWakeable ? // A wakeable object was thrown by a legacy Suspense implementation.
+    // This has slightly different behavior than suspending with `use`.
+    SuspendedOnDeprecatedThrowPromise : // This is a regular error. If something earlier in the component already
+    // suspended, we must clear the thenable state to unblock the work loop.
+    SuspendedOnError;
+  }
+
+  workInProgressThrownValue = thrownValue;
+  const erroredWork = workInProgress;
+
+  if (erroredWork === null) {
+    // This is a fatal error
+    workInProgressRootExitStatus = RootFatalErrored;
+    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);
+  }
+
+  {
+    markComponentRenderStopped();
+
+    switch (workInProgressSuspendedReason) {
+      case SuspendedOnError:
+        {
+          markComponentErrored(erroredWork, thrownValue, workInProgressRootRenderLanes);
+          break;
+        }
+
+      case SuspendedOnData:
+      case SuspendedOnImmediate:
+      case SuspendedOnDeprecatedThrowPromise:
+      case SuspendedAndReadyToContinue:
+        {
+          const wakeable = thrownValue;
+          markComponentSuspended(erroredWork, wakeable, workInProgressRootRenderLanes);
+          break;
+        }
+    }
+  }
+}
+
+function shouldRemainOnPreviousScreen() {
+  // This is asking whether it's better to suspend the transition and remain
+  // on the previous screen, versus showing a fallback as soon as possible. It
+  // takes into account both the priority of render and also whether showing a
+  // fallback would produce a desirable user experience.
+  const handler = getSuspenseHandler();
+
+  if (handler === null) {
+    // There's no Suspense boundary that can provide a fallback. We have no
+    // choice but to remain on the previous screen.
+    // NOTE: We do this even for sync updates, for lack of any better option. In
+    // the future, we may change how we handle this, like by putting the whole
+    // root into a "detached" mode.
+    return true;
+  } // TODO: Once `use` has fully replaced the `throw promise` pattern, we should
+  // be able to remove the equivalent check in finishConcurrentRender, and rely
+  // just on this one.
+
+
+  if (includesOnlyTransitions(workInProgressRootRenderLanes)) {
+    if (getShellBoundary() === null) {
+      // We're rendering inside the "shell" of the app. Activating the nearest
+      // fallback would cause visible content to disappear. It's better to
+      // suspend the transition and remain on the previous screen.
+      return true;
+    } else {
+      // We're rendering content that wasn't part of the previous screen.
+      // Rather than block the transition, it's better to show a fallback as
+      // soon as possible. The appearance of any nested fallbacks will be
+      // throttled to avoid jank.
+      return false;
+    }
+  }
+
+  if (includesOnlyRetries(workInProgressRootRenderLanes) || // In this context, an OffscreenLane counts as a Retry
+  // TODO: It's become increasingly clear that Retries and Offscreen are
+  // deeply connected. They probably can be unified further.
+  includesSomeLane(workInProgressRootRenderLanes, OffscreenLane)) {
+    // During a retry, we can suspend rendering if the nearest Suspense boundary
+    // is the boundary of the "shell", because we're guaranteed not to block
+    // any new content from appearing.
+    //
+    // The reason we must check if this is a retry is because it guarantees
+    // that suspending the work loop won't block an actual update, because
+    // retries don't "update" anything; they fill in fallbacks that were left
+    // behind by a previous transition.
+    return handler === getShellBoundary();
+  } // For all other Lanes besides Transitions and Retries, we should not wait
+  // for the data to load.
+
+
+  return false;
+}
+
+function pushDispatcher(container) {
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = ContextOnlyDispatcher;
+
+  if (prevDispatcher === null) {
+    // The React isomorphic package does not include a default dispatcher.
+    // Instead the first renderer will lazily attach one, in order to give
+    // nicer error messages.
+    return ContextOnlyDispatcher;
+  } else {
+    return prevDispatcher;
+  }
+}
+
+function popDispatcher(prevDispatcher) {
+  ReactCurrentDispatcher.current = prevDispatcher;
+}
+
+function pushCacheDispatcher() {
+  {
+    const prevCacheDispatcher = ReactCurrentCache.current;
+    ReactCurrentCache.current = DefaultCacheDispatcher;
+    return prevCacheDispatcher;
+  }
+}
+
+function popCacheDispatcher(prevCacheDispatcher) {
+  {
+    ReactCurrentCache.current = prevCacheDispatcher;
+  }
+}
+
+function markCommitTimeOfFallback() {
+  globalMostRecentFallbackTime = now$1();
+}
+function markSkippedUpdateLanes(lane) {
+  workInProgressRootSkippedLanes = mergeLanes(lane, workInProgressRootSkippedLanes);
+}
+function renderDidSuspend() {
+  if (workInProgressRootExitStatus === RootInProgress) {
+    workInProgressRootExitStatus = RootSuspended;
+  }
+}
+function renderDidSuspendDelayIfPossible() {
+  workInProgressRootExitStatus = RootSuspendedWithDelay; // Check if there are updates that we skipped tree that might have unblocked
+  // this render.
+
+  if ((includesNonIdleWork(workInProgressRootSkippedLanes) || includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes)) && workInProgressRoot !== null) {
+    // Mark the current render as suspended so that we switch to working on
+    // the updates that were skipped. Usually we only suspend at the end of
+    // the render phase.
+    // TODO: We should probably always mark the root as suspended immediately
+    // (inside this function), since by suspending at the end of the render
+    // phase introduces a potential mistake where we suspend lanes that were
+    // pinged or updated while we were rendering.
+    // TODO: Consider unwinding immediately, using the
+    // SuspendedOnHydration mechanism.
+    markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes, workInProgressDeferredLane);
+  }
+}
+function renderDidError(error) {
+  if (workInProgressRootExitStatus !== RootSuspendedWithDelay) {
+    workInProgressRootExitStatus = RootErrored;
+  }
+
+  if (workInProgressRootConcurrentErrors === null) {
+    workInProgressRootConcurrentErrors = [error];
+  } else {
+    workInProgressRootConcurrentErrors.push(error);
+  }
+} // Called during render to determine if anything has suspended.
+// Returns false if we're not sure.
+
+function renderHasNotSuspendedYet() {
+  // If something errored or completed, we can't really be sure,
+  // so those are false.
+  return workInProgressRootExitStatus === RootInProgress;
+} // TODO: Over time, this function and renderRootConcurrent have become more
+// and more similar. Not sure it makes sense to maintain forked paths. Consider
+// unifying them again.
+
+function renderRootSync(root, lanes) {
+  const prevExecutionContext = executionContext;
+  executionContext |= RenderContext;
+  const prevDispatcher = pushDispatcher();
+  const prevCacheDispatcher = pushCacheDispatcher(); // If the root or lanes have changed, throw out the existing stack
+  // and prepare a fresh one. Otherwise we'll continue where we left off.
+
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
+    {
+      if (isDevToolsPresent) {
+        const 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();
+    prepareFreshStack(root, lanes);
+  }
+
+  {
+    markRenderStarted(lanes);
+  }
+
+  let didSuspendInShell = false;
+
+  outer: do {
+    try {
+      if (workInProgressSuspendedReason !== NotSuspended && workInProgress !== null) {
+        // The work loop is suspended. During a synchronous render, we don't
+        // yield to the main thread. Immediately unwind the stack. This will
+        // trigger either a fallback or an error boundary.
+        // TODO: For discrete and "default" updates (anything that's not
+        // flushSync), we want to wait for the microtasks the flush before
+        // unwinding. Will probably implement this using renderRootConcurrent,
+        // or merge renderRootSync and renderRootConcurrent into the same
+        // function and fork the behavior some other way.
+        const unitOfWork = workInProgress;
+        const thrownValue = workInProgressThrownValue;
+
+        switch (workInProgressSuspendedReason) {
+          case SuspendedOnHydration:
+            {
+              // Selective hydration. An update flowed into a dehydrated tree.
+              // Interrupt the current render so the work loop can switch to the
+              // hydration lane.
+              resetWorkInProgressStack();
+              workInProgressRootExitStatus = RootDidNotComplete;
+              break outer;
+            }
+
+          case SuspendedOnImmediate:
+          case SuspendedOnData:
+            {
+              if (!didSuspendInShell && getSuspenseHandler() === null) {
+                didSuspendInShell = true;
+              } // Intentional fallthrough
+
+            }
+
+          default:
+            {
+              // Unwind then continue with the normal work loop.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              break;
+            }
+        }
+      }
+
+      workLoopSync();
+      break;
+    } catch (thrownValue) {
+      handleThrow(root, thrownValue);
+    }
+  } while (true); // Check if something suspended in the shell. We use this to detect an
+  // infinite ping loop caused by an uncached promise.
+  //
+  // Only increment this counter once per synchronous render attempt across the
+  // whole tree. Even if there are many sibling components that suspend, this
+  // counter only gets incremented once.
+
+
+  if (didSuspendInShell) {
+    root.shellSuspendCounter++;
+  }
+
+  resetContextDependencies();
+  executionContext = prevExecutionContext;
+  popDispatcher(prevDispatcher);
+  popCacheDispatcher(prevCacheDispatcher);
+
+  if (workInProgress !== null) {
+    // This is a sync render, so we should have finished the whole tree.
+    throw Error(formatProdErrorMessage(261));
+  }
+
+  {
+    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.
+
+  finishQueueingConcurrentUpdates();
+  return workInProgressRootExitStatus;
+} // The work loop is an extremely hot path. Tell Closure not to inline it.
+
+/** @noinline */
+
+
+function workLoopSync() {
+  // Perform work without checking if we need to yield between fiber.
+  while (workInProgress !== null) {
+    performUnitOfWork(workInProgress);
+  }
+}
+
+function renderRootConcurrent(root, lanes) {
+  const prevExecutionContext = executionContext;
+  executionContext |= RenderContext;
+  const prevDispatcher = pushDispatcher();
+  const prevCacheDispatcher = pushCacheDispatcher(); // If the root or lanes have changed, throw out the existing stack
+  // and prepare a fresh one. Otherwise we'll continue where we left off.
+
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
+    {
+      if (isDevToolsPresent) {
+        const 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();
+    resetRenderTimer();
+    prepareFreshStack(root, lanes);
+  }
+
+  {
+    markRenderStarted(lanes);
+  }
+
+  outer: do {
+    try {
+      if (workInProgressSuspendedReason !== NotSuspended && workInProgress !== null) {
+        // The work loop is suspended. We need to either unwind the stack or
+        // replay the suspended component.
+        const unitOfWork = workInProgress;
+        const thrownValue = workInProgressThrownValue;
+
+        resumeOrUnwind: switch (workInProgressSuspendedReason) {
+          case SuspendedOnError:
+            {
+              // Unwind then continue with the normal work loop.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              break;
+            }
+
+          case SuspendedOnData:
+            {
+              const thenable = thrownValue;
+
+              if (isThenableResolved(thenable)) {
+                // The data resolved. Try rendering the component again.
+                workInProgressSuspendedReason = NotSuspended;
+                workInProgressThrownValue = null;
+                replaySuspendedUnitOfWork(unitOfWork);
+                break;
+              } // The work loop is suspended on data. We should wait for it to
+              // resolve before continuing to render.
+              // TODO: Handle the case where the promise resolves synchronously.
+              // Usually this is handled when we instrument the promise to add a
+              // `status` field, but if the promise already has a status, we won't
+              // have added a listener until right here.
+
+
+              const onResolution = () => {
+                // Check if the root is still suspended on this promise.
+                if (workInProgressSuspendedReason === SuspendedOnData && workInProgressRoot === root) {
+                  // Mark the root as ready to continue rendering.
+                  workInProgressSuspendedReason = SuspendedAndReadyToContinue;
+                } // Ensure the root is scheduled. We should do this even if we're
+                // currently working on a different root, so that we resume
+                // rendering later.
+
+
+                ensureRootIsScheduled(root);
+              };
+
+              thenable.then(onResolution, onResolution);
+              break outer;
+            }
+
+          case SuspendedOnImmediate:
+            {
+              // If this fiber just suspended, it's possible the data is already
+              // cached. Yield to the main thread to give it a chance to ping. If
+              // it does, we can retry immediately without unwinding the stack.
+              workInProgressSuspendedReason = SuspendedAndReadyToContinue;
+              break outer;
+            }
+
+          case SuspendedOnInstance:
+            {
+              workInProgressSuspendedReason = SuspendedOnInstanceAndReadyToContinue;
+              break outer;
+            }
+
+          case SuspendedAndReadyToContinue:
+            {
+              const thenable = thrownValue;
+
+              if (isThenableResolved(thenable)) {
+                // The data resolved. Try rendering the component again.
+                workInProgressSuspendedReason = NotSuspended;
+                workInProgressThrownValue = null;
+                replaySuspendedUnitOfWork(unitOfWork);
+              } else {
+                // Otherwise, unwind then continue with the normal work loop.
+                workInProgressSuspendedReason = NotSuspended;
+                workInProgressThrownValue = null;
+                throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              }
+
+              break;
+            }
+
+          case SuspendedOnInstanceAndReadyToContinue:
+            {
+              switch (workInProgress.tag) {
+                case HostComponent:
+                case HostHoistable:
+                case HostSingleton:
+                  {
+                    // Before unwinding the stack, check one more time if the
+                    // instance is ready. It may have loaded when React yielded to
+                    // the main thread.
+                    // Assigning this to a constant so Flow knows the binding won't
+                    // be mutated by `preloadInstance`.
+                    const hostFiber = workInProgress;
+                    const type = hostFiber.type;
+                    const props = hostFiber.pendingProps;
+                    const isReady = preloadInstance(type, props);
+
+                    if (isReady) {
+                      // The data resolved. Resume the work loop as if nothing
+                      // suspended. Unlike when a user component suspends, we don't
+                      // have to replay anything because the host fiber
+                      // already completed.
+                      workInProgressSuspendedReason = NotSuspended;
+                      workInProgressThrownValue = null;
+                      const sibling = hostFiber.sibling;
+
+                      if (sibling !== null) {
+                        workInProgress = sibling;
+                      } else {
+                        const returnFiber = hostFiber.return;
+
+                        if (returnFiber !== null) {
+                          workInProgress = returnFiber;
+                          completeUnitOfWork(returnFiber);
+                        } else {
+                          workInProgress = null;
+                        }
+                      }
+
+                      break resumeOrUnwind;
+                    }
+
+                    break;
+                  }
+
+                default:
+                  {
+                    // This will fail gracefully but it's not correct, so log a
+                    // warning in dev.
+                    if (false) ;
+
+                    break;
+                  }
+              } // Otherwise, unwind then continue with the normal work loop.
+
+
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              break;
+            }
+
+          case SuspendedOnDeprecatedThrowPromise:
+            {
+              // Suspended by an old implementation that uses the `throw promise`
+              // pattern. The newer replaying behavior can cause subtle issues
+              // like infinite ping loops. So we maintain the old behavior and
+              // always unwind.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              throwAndUnwindWorkLoop(unitOfWork, thrownValue);
+              break;
+            }
+
+          case SuspendedOnHydration:
+            {
+              // Selective hydration. An update flowed into a dehydrated tree.
+              // Interrupt the current render so the work loop can switch to the
+              // hydration lane.
+              resetWorkInProgressStack();
+              workInProgressRootExitStatus = RootDidNotComplete;
+              break outer;
+            }
+
+          default:
+            {
+              throw Error(formatProdErrorMessage(462));
+            }
+        }
+      }
+
+      if (false && ReactCurrentActQueue.current !== null) ; else {
+        workLoopConcurrent();
+      }
+
+      break;
+    } catch (thrownValue) {
+      handleThrow(root, thrownValue);
+    }
+  } while (true);
+
+  resetContextDependencies();
+  popDispatcher(prevDispatcher);
+  popCacheDispatcher(prevCacheDispatcher);
+  executionContext = prevExecutionContext;
+
+
+  if (workInProgress !== null) {
+    // Still work remaining.
+    {
+      markRenderYielded();
+    }
+
+    return RootInProgress;
+  } else {
+    // Completed the tree.
+    {
+      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.
+
+    finishQueueingConcurrentUpdates(); // Return the final exit status.
+
+    return workInProgressRootExitStatus;
+  }
+}
+/** @noinline */
+
+
+function workLoopConcurrent() {
+  // Perform work until Scheduler asks us to yield
+  while (workInProgress !== null && !shouldYield()) {
+    // $FlowFixMe[incompatible-call] found when upgrading Flow
+    performUnitOfWork(workInProgress);
+  }
+}
+
+function performUnitOfWork(unitOfWork) {
+  // The current, flushed, state of this fiber is the alternate. Ideally
+  // nothing should rely on this, but relying on it here means that we don't
+  // need an additional field on the work in progress.
+  const current = unitOfWork.alternate;
+  let next;
+
+  if ((unitOfWork.mode & ProfileMode) !== NoMode) {
+    startProfilerTimer(unitOfWork);
+    next = beginWork(current, unitOfWork, entangledRenderLanes);
+    stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
+  } else {
+    next = beginWork(current, unitOfWork, entangledRenderLanes);
+  }
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+
+  if (next === null) {
+    // If this doesn't spawn new work, complete the current work.
+    completeUnitOfWork(unitOfWork);
+  } else {
+    workInProgress = next;
+  }
+
+  ReactCurrentOwner.current = null;
+}
+
+function replaySuspendedUnitOfWork(unitOfWork) {
+  // This is a fork of performUnitOfWork specifcally for replaying a fiber that
+  // just suspended.
+  //
+  const current = unitOfWork.alternate;
+  let next;
+  const isProfilingMode = (unitOfWork.mode & ProfileMode) !== NoMode;
+
+  if (isProfilingMode) {
+    startProfilerTimer(unitOfWork);
+  }
+
+  switch (unitOfWork.tag) {
+    case IndeterminateComponent:
+      {
+        // Because it suspended with `use`, we can assume it's a
+        // function component.
+        unitOfWork.tag = FunctionComponent; // Fallthrough to the next branch.
+      }
+
+    case SimpleMemoComponent:
+    case FunctionComponent:
+      {
+        // Resolve `defaultProps`. This logic is copied from `beginWork`.
+        // TODO: Consider moving this switch statement into that module. Also,
+        // could maybe use this as an opportunity to say `use` doesn't work with
+        // `defaultProps` :)
+        const Component = unitOfWork.type;
+        const unresolvedProps = unitOfWork.pendingProps;
+        const resolvedProps = unitOfWork.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        let context;
+
+        {
+          const unmaskedContext = getUnmaskedContext(unitOfWork, Component, true);
+          context = getMaskedContext(unitOfWork, unmaskedContext);
+        }
+
+        next = replayFunctionComponent(current, unitOfWork, resolvedProps, Component, context, workInProgressRootRenderLanes);
+        break;
+      }
+
+    case ForwardRef:
+      {
+        // Resolve `defaultProps`. This logic is copied from `beginWork`.
+        // TODO: Consider moving this switch statement into that module. Also,
+        // could maybe use this as an opportunity to say `use` doesn't work with
+        // `defaultProps` :)
+        const Component = unitOfWork.type.render;
+        const unresolvedProps = unitOfWork.pendingProps;
+        const resolvedProps = unitOfWork.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);
+        next = replayFunctionComponent(current, unitOfWork, resolvedProps, Component, unitOfWork.ref, workInProgressRootRenderLanes);
+        break;
+      }
+
+    case HostComponent:
+      {
+        // Some host components are stateful (that's how we implement form
+        // actions) but we don't bother to reuse the memoized state because it's
+        // not worth the extra code. The main reason to reuse the previous hooks
+        // is to reuse uncached promises, but we happen to know that the only
+        // promises that a host component might suspend on are definitely cached
+        // because they are controlled by us. So don't bother.
+        resetHooksOnUnwind(unitOfWork); // Fallthrough to the next branch.
+      }
+
+    default:
+      {
+        // Other types besides function components are reset completely before
+        // being replayed. Currently this only happens when a Usable type is
+        // reconciled — the reconciler will suspend.
+        //
+        // We reset the fiber back to its original state; however, this isn't
+        // a full "unwind" because we're going to reuse the promises that were
+        // reconciled previously. So it's intentional that we don't call
+        // resetSuspendedWorkLoopOnUnwind here.
+        unwindInterruptedWork(current, unitOfWork);
+        unitOfWork = workInProgress = resetWorkInProgress(unitOfWork, entangledRenderLanes);
+        next = beginWork(current, unitOfWork, entangledRenderLanes);
+        break;
+      }
+  }
+
+  if (isProfilingMode) {
+    stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
+  } // The begin phase finished successfully without suspending. Return to the
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+
+  if (next === null) {
+    // If this doesn't spawn new work, complete the current work.
+    completeUnitOfWork(unitOfWork);
+  } else {
+    workInProgress = next;
+  }
+
+  ReactCurrentOwner.current = null;
+}
+
+function throwAndUnwindWorkLoop(unitOfWork, thrownValue) {
+  // This is a fork of performUnitOfWork specifcally for unwinding a fiber
+  // that threw an exception.
+  //
+  // Return to the normal work loop. This will unwind the stack, and potentially
+  // result in showing a fallback.
+  resetSuspendedWorkLoopOnUnwind(unitOfWork);
+  const returnFiber = unitOfWork.return;
+
+  if (returnFiber === null || workInProgressRoot === null) {
+    // Expected to be working on a non-root fiber. This is a fatal error
+    // because there's no ancestor that can handle it; the root is
+    // supposed to capture all errors that weren't caught by an error
+    // boundary.
+    workInProgressRootExitStatus = RootFatalErrored;
+    workInProgressRootFatalError = thrownValue; // Set `workInProgress` to null. This represents advancing to the next
+    // sibling, or the parent if there are no siblings. But since the root
+    // has no siblings nor a parent, we set it to null. Usually this is
+    // handled by `completeUnitOfWork` or `unwindWork`, but since we're
+    // intentionally not calling those, we need set it here.
+    // TODO: Consider calling `unwindWork` to pop the contexts.
+
+    workInProgress = null;
+    return;
+  }
+
+  try {
+    // Find and mark the nearest Suspense or error boundary that can handle
+    // this "exception".
+    throwException(workInProgressRoot, returnFiber, unitOfWork, thrownValue, workInProgressRootRenderLanes);
+  } catch (error) {
+    // We had trouble processing the error. An example of this happening is
+    // when accessing the `componentDidCatch` property of an error boundary
+    // throws an error. A weird edge case. There's a regression test for this.
+    // To prevent an infinite loop, bubble the error up to the next parent.
+    workInProgress = returnFiber;
+    throw error;
+  }
+
+  if (unitOfWork.flags & Incomplete) {
+    // Unwind the stack until we reach the nearest boundary.
+    unwindUnitOfWork(unitOfWork);
+  } else {
+    // Although the fiber suspended, we're intentionally going to commit it in
+    // an inconsistent state. We can do this safely in cases where we know the
+    // inconsistent tree will be hidden.
+    //
+    // This currently only applies to Legacy Suspense implementation, but we may
+    // port a version of this to concurrent roots, too, when performing a
+    // synchronous render. Because that will allow us to mutate the tree as we
+    // go instead of buffering mutations until the end. Though it's unclear if
+    // this particular path is how that would be implemented.
+    completeUnitOfWork(unitOfWork);
+  }
+}
+
+function completeUnitOfWork(unitOfWork) {
+  // Attempt to complete the current unit of work, then move to the next
+  // sibling. If there are no more siblings, return to the parent fiber.
+  let completedWork = unitOfWork;
+
+  do {
+    // nothing should rely on this, but relying on it here means that we don't
+    // need an additional field on the work in progress.
+
+
+    const current = completedWork.alternate;
+    const returnFiber = completedWork.return;
+    let next;
+
+    if ((completedWork.mode & ProfileMode) === NoMode) {
+      next = completeWork(current, completedWork, entangledRenderLanes);
+    } else {
+      startProfilerTimer(completedWork);
+      next = completeWork(current, completedWork, entangledRenderLanes); // Update render duration assuming we didn't error.
+
+      stopProfilerTimerIfRunningAndRecordDelta(completedWork, false);
+    }
+
+    if (next !== null) {
+      // Completing this fiber spawned new work. Work on that next.
+      workInProgress = next;
+      return;
+    }
+
+    const siblingFiber = completedWork.sibling;
+
+    if (siblingFiber !== null) {
+      // If there is more work to do in this returnFiber, do that next.
+      workInProgress = siblingFiber;
+      return;
+    } // Otherwise, return to the parent
+    // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+    completedWork = returnFiber; // Update the next thing we're working on in case something throws.
+
+    workInProgress = completedWork;
+  } while (completedWork !== null); // We've reached the root.
+
+
+  if (workInProgressRootExitStatus === RootInProgress) {
+    workInProgressRootExitStatus = RootCompleted;
+  }
+}
+
+function unwindUnitOfWork(unitOfWork) {
+  let incompleteWork = unitOfWork;
+
+  do {
+    // The current, flushed, state of this fiber is the alternate. Ideally
+    // nothing should rely on this, but relying on it here means that we don't
+    // need an additional field on the work in progress.
+    const current = incompleteWork.alternate; // This fiber did not complete because something threw. Pop values off
+    // the stack without entering the complete phase. If this is a boundary,
+    // capture values if possible.
+
+    const next = unwindWork(current, incompleteWork); // Because this fiber did not complete, don't reset its lanes.
+
+    if (next !== null) {
+      // Found a boundary that can handle this exception. Re-renter the
+      // begin phase. This branch will return us to the normal work loop.
+      //
+      // Since we're restarting, remove anything that is not a host effect
+      // from the effect tag.
+      next.flags &= HostEffectMask;
+      workInProgress = next;
+      return;
+    } // Keep unwinding until we reach either a boundary or the root.
+
+
+    if ((incompleteWork.mode & ProfileMode) !== NoMode) {
+      // Record the render duration for the fiber that errored.
+      stopProfilerTimerIfRunningAndRecordDelta(incompleteWork, false); // Include the time spent working on failed children before continuing.
+
+      let actualDuration = incompleteWork.actualDuration;
+      let child = incompleteWork.child;
+
+      while (child !== null) {
+        // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+        actualDuration += child.actualDuration;
+        child = child.sibling;
+      }
+
+      incompleteWork.actualDuration = actualDuration;
+    } // TODO: Once we stop prerendering siblings, instead of resetting the parent
+    // of the node being unwound, we should be able to reset node itself as we
+    // unwind the stack. Saves an additional null check.
+
+
+    const returnFiber = incompleteWork.return;
+
+    if (returnFiber !== null) {
+      // Mark the parent fiber as incomplete and clear its subtree flags.
+      // TODO: Once we stop prerendering siblings, we may be able to get rid of
+      // the Incomplete flag because unwinding to the nearest boundary will
+      // happen synchronously.
+      returnFiber.flags |= Incomplete;
+      returnFiber.subtreeFlags = NoFlags$1;
+      returnFiber.deletions = null;
+    } // NOTE: If we re-enable sibling prerendering in some cases, here we
+    // would switch to the normal completion path: check if a sibling
+    // exists, and if so, begin work on it.
+    // Otherwise, return to the parent
+    // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+    incompleteWork = returnFiber; // Update the next thing we're working on in case something throws.
+
+    workInProgress = incompleteWork;
+  } while (incompleteWork !== null); // We've unwound all the way to the root.
+
+
+  workInProgressRootExitStatus = RootDidNotComplete;
+  workInProgress = null;
+}
+
+function commitRoot(root, recoverableErrors, transitions, spawnedLane) {
+  // TODO: This no longer makes any sense. We already wrap the mutation and
+  // layout phases. Should be able to remove.
+  const previousUpdateLanePriority = getCurrentUpdatePriority();
+  const prevTransition = ReactCurrentBatchConfig$1.transition;
+
+  try {
+    ReactCurrentBatchConfig$1.transition = null;
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    commitRootImpl(root, recoverableErrors, transitions, previousUpdateLanePriority, spawnedLane);
+  } finally {
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+    setCurrentUpdatePriority(previousUpdateLanePriority);
+  }
+
+  return null;
+}
+
+function commitRootImpl(root, recoverableErrors, transitions, renderPriorityLevel, spawnedLane) {
+  do {
+    // `flushPassiveEffects` will call `flushSyncUpdateQueue` at the end, which
+    // means `flushPassiveEffects` will sometimes result in additional
+    // passive effects. So we need to keep flushing in a loop until there are
+    // no more pending effects.
+    // TODO: Might be better if `flushPassiveEffects` did not automatically
+    // flush synchronous work at the end, to avoid factoring hazards like this.
+    flushPassiveEffects();
+  } while (rootWithPendingPassiveEffects !== null);
+
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw Error(formatProdErrorMessage(327));
+  }
+
+  const finishedWork = root.finishedWork;
+  const lanes = root.finishedLanes;
+
+  {
+    markCommitStarted(lanes);
+  }
+
+  if (finishedWork === null) {
+
+    {
+      markCommitStopped();
+    }
+
+    return null;
+  }
+
+  root.finishedWork = null;
+  root.finishedLanes = NoLanes;
+
+  if (finishedWork === root.current) {
+    throw Error(formatProdErrorMessage(177));
+  } // commitRoot never returns a continuation; it always finishes synchronously.
+  // So we can clear these now to allow a new callback to be scheduled.
+
+
+  root.callbackNode = null;
+  root.callbackPriority = NoLane;
+  root.cancelPendingCommit = null; // Check which lanes no longer have any work scheduled on them, and mark
+  // those as finished.
+
+  let remainingLanes = mergeLanes(finishedWork.lanes, finishedWork.childLanes); // Make sure to account for lanes that were updated by a concurrent event
+  // during the render phase; don't mark them as finished.
+
+  const concurrentlyUpdatedLanes = getConcurrentlyUpdatedLanes();
+  remainingLanes = mergeLanes(remainingLanes, concurrentlyUpdatedLanes);
+  markRootFinished(root, remainingLanes, spawnedLane);
+
+  if (root === workInProgressRoot) {
+    // We can reset these now that they are finished.
+    workInProgressRoot = null;
+    workInProgress = null;
+    workInProgressRootRenderLanes = NoLanes;
+  } // If there are pending passive effects, schedule a callback to process them.
+  // Do this as early as possible, so it is queued before anything else that
+  // might get scheduled in the commit phase. (See #16714.)
+  // TODO: Delete all other places that schedule the passive effect callback
+  // They're redundant.
+
+
+  if ((finishedWork.subtreeFlags & PassiveMask) !== NoFlags$1 || (finishedWork.flags & PassiveMask) !== NoFlags$1) {
+    if (!rootDoesHavePassiveEffects) {
+      rootDoesHavePassiveEffects = true;
+      pendingPassiveEffectsRemainingLanes = remainingLanes; // workInProgressTransitions might be overwritten, so we want
+      // to store it in pendingPassiveTransitions until they get processed
+      // We need to pass this through as an argument to commitRoot
+      // because workInProgressTransitions might have changed between
+      // the previous render and commit if we throttle the commit
+      // with setTimeout
+
+      pendingPassiveTransitions = transitions;
+      scheduleCallback(NormalPriority$1, () => {
+        flushPassiveEffects(); // This render triggered passive effects: release the root cache pool
+        // *after* passive effects fire to avoid freeing a cache pool that may
+        // be referenced by a node in the tree (HostRoot, Cache boundary etc)
+
+        return null;
+      });
+    }
+  } // Check if there are any effects in the whole tree.
+  // TODO: This is left over from the effect list implementation, where we had
+  // to check for the existence of `firstEffect` to satisfy Flow. I think the
+  // only other reason this optimization exists is because it affects profiling.
+  // Reconsider whether this is necessary.
+
+
+  const subtreeHasEffects = (finishedWork.subtreeFlags & (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !== NoFlags$1;
+  const rootHasEffect = (finishedWork.flags & (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !== NoFlags$1;
+
+  if (subtreeHasEffects || rootHasEffect) {
+    const prevTransition = ReactCurrentBatchConfig$1.transition;
+    ReactCurrentBatchConfig$1.transition = null;
+    const previousPriority = getCurrentUpdatePriority();
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    const prevExecutionContext = executionContext;
+    executionContext |= CommitContext; // Reset this to null before calling lifecycles
+
+    ReactCurrentOwner.current = null; // The commit phase is broken into several sub-phases. We do a separate pass
+    // of the effect list for each phase: all mutation effects come before all
+    // layout effects, and so on.
+    // The first phase a "before mutation" phase. We use this phase to read the
+    // state of the host tree right before we mutate it. This is where
+    // getSnapshotBeforeUpdate is called.
+
+    commitBeforeMutationEffects(root, finishedWork);
+
+    {
+      // Mark the current commit time to be shared by all Profilers in this
+      // batch. This enables them to be grouped later.
+      recordCommitTime();
+    }
+
+
+    commitMutationEffects(root, finishedWork, lanes);
+
+    resetAfterCommit(); // The work-in-progress tree is now the current tree. This must come after
+    // the mutation phase, so that the previous tree is still current during
+    // componentWillUnmount, but before the layout phase, so that the finished
+    // work is current during componentDidMount/Update.
+
+    root.current = finishedWork; // The next phase is the layout phase, where we call effects that read
+
+    {
+      markLayoutEffectsStarted(lanes);
+    }
+
+    commitLayoutEffects(finishedWork, root, lanes);
+
+    {
+      markLayoutEffectsStopped();
+    }
+    // opportunity to paint.
+
+
+    requestPaint();
+    executionContext = prevExecutionContext; // Reset the priority to the previous non-sync value.
+
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+  } else {
+    // No effects.
+    root.current = finishedWork; // Measure these anyway so the flamegraph explicitly shows that there were
+    // no effects.
+    // TODO: Maybe there's a better way to report this.
+
+    {
+      recordCommitTime();
+    }
+  }
+
+  if (rootDoesHavePassiveEffects) {
+    // This commit has passive effects. Stash a reference to them. But don't
+    // schedule a callback until after flushing layout work.
+    rootDoesHavePassiveEffects = false;
+    rootWithPendingPassiveEffects = root;
+    pendingPassiveEffectsLanes = lanes;
+  } else {
+    // There were no passive effects, so we can immediately release the cache
+    // pool for this render.
+    releaseRootPooledCache(root, remainingLanes);
+  } // Read this again, since an effect might have updated it
+
+
+  remainingLanes = root.pendingLanes; // Check if there's remaining work on this root
+  // TODO: This is part of the `componentDidCatch` implementation. Its purpose
+  // is to detect whether something might have called setState inside
+  // `componentDidCatch`. The mechanism is known to be flawed because `setState`
+  // inside `componentDidCatch` is itself flawed — that's why we recommend
+  // `getDerivedStateFromError` instead. However, it could be improved by
+  // checking if remainingLanes includes Sync work, instead of whether there's
+  // any work remaining at all (which would also include stuff like Suspense
+  // retries or transitions). It's been like this for a while, though, so fixing
+  // it probably isn't that urgent.
+
+  if (remainingLanes === NoLanes) {
+    // If there's no remaining work, we can clear the set of already failed
+    // error boundaries.
+    legacyErrorBoundariesThatAlreadyFailed = null;
+  }
+
+  onCommitRoot(finishedWork.stateNode, renderPriorityLevel);
+
+  {
+    if (isDevToolsPresent) {
+      root.memoizedUpdaters.clear();
+    }
+  }
+  // additional work on this root is scheduled.
+
+
+  ensureRootIsScheduled(root);
+
+  if (recoverableErrors !== null) {
+    // There were errors during this render, but recovered from them without
+    // needing to surface it to the UI. We log them here.
+    const onRecoverableError = root.onRecoverableError;
+
+    for (let i = 0; i < recoverableErrors.length; i++) {
+      const recoverableError = recoverableErrors[i];
+      const errorInfo = makeErrorInfo(recoverableError.digest, recoverableError.stack);
+      onRecoverableError(recoverableError.value, errorInfo);
+    }
+  }
+
+  if (hasUncaughtError) {
+    hasUncaughtError = false;
+    const error = firstUncaughtError;
+    firstUncaughtError = null;
+    throw error;
+  } // If the passive effects are the result of a discrete render, flush them
+  // synchronously at the end of the current task so that the result is
+  // immediately observable. Otherwise, we assume that they are not
+  // order-dependent and do not need to be observed by external systems, so we
+  // can wait until after paint.
+  // TODO: We can optimize this by not scheduling the callback earlier. Since we
+  // currently schedule the callback in multiple places, will wait until those
+  // are consolidated.
+
+
+  if (includesSyncLane(pendingPassiveEffectsLanes) && root.tag !== LegacyRoot) {
+    flushPassiveEffects();
+  } // Read this again, since a passive effect might have updated it
+
+
+  remainingLanes = root.pendingLanes; // Check if this render scheduled a cascading synchronous update. This is a
+  // heurstic to detect infinite update loops. We are intentionally excluding
+  // hydration lanes in this check, because render triggered by selective
+  // hydration is conceptually not an update.
+
+  if ( // Was the finished render the result of an update (not hydration)?
+  includesSomeLane(lanes, UpdateLanes) && // Did it schedule a sync update?
+  includesSomeLane(remainingLanes, SyncUpdateLanes)) {
+    {
+      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) {
+      nestedUpdateCount++;
+    } else {
+      nestedUpdateCount = 0;
+      rootWithNestedUpdates = root;
+    }
+  } else {
+    nestedUpdateCount = 0;
+  } // If layout work was scheduled, flush it now.
+
+
+  flushSyncWorkOnAllRoots();
+
+  {
+    markCommitStopped();
+  }
+
+  return null;
+}
+
+function makeErrorInfo(digest, componentStack) {
+  {
+    return {
+      digest,
+      componentStack
+    };
+  }
+}
+
+function releaseRootPooledCache(root, remainingLanes) {
+  {
+    const pooledCacheLanes = root.pooledCacheLanes &= remainingLanes;
+
+    if (pooledCacheLanes === NoLanes) {
+      // None of the remaining work relies on the cache pool. Clear it so
+      // subsequent requests get a new cache
+      const pooledCache = root.pooledCache;
+
+      if (pooledCache != null) {
+        root.pooledCache = null;
+        releaseCache(pooledCache);
+      }
+    }
+  }
+}
+
+function flushPassiveEffects() {
+  // Returns whether passive effects were flushed.
+  // TODO: Combine this check with the one in flushPassiveEFfectsImpl. We should
+  // probably just combine the two functions. I believe they were only separate
+  // in the first place because we used to wrap it with
+  // `Scheduler.runWithPriority`, which accepts a function. But now we track the
+  // priority within React itself, so we can mutate the variable directly.
+  if (rootWithPendingPassiveEffects !== null) {
+    // Cache the root since rootWithPendingPassiveEffects is cleared in
+    // flushPassiveEffectsImpl
+    const root = rootWithPendingPassiveEffects; // Cache and clear the remaining lanes flag; it must be reset since this
+    // method can be called from various places, not always from commitRoot
+    // where the remaining lanes are known
+
+    const remainingLanes = pendingPassiveEffectsRemainingLanes;
+    pendingPassiveEffectsRemainingLanes = NoLanes;
+    const renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
+    const priority = lowerEventPriority(DefaultEventPriority, renderPriority);
+    const prevTransition = ReactCurrentBatchConfig$1.transition;
+    const previousPriority = getCurrentUpdatePriority();
+
+    try {
+      ReactCurrentBatchConfig$1.transition = null;
+      setCurrentUpdatePriority(priority);
+      return flushPassiveEffectsImpl();
+    } finally {
+      setCurrentUpdatePriority(previousPriority);
+      ReactCurrentBatchConfig$1.transition = prevTransition; // Once passive effects have run for the tree - giving components a
+      // chance to retain cache instances they use - release the pooled
+      // cache at the root (if there is one)
+
+      releaseRootPooledCache(root, remainingLanes);
+    }
+  }
+
+  return false;
+}
+function enqueuePendingPassiveProfilerEffect(fiber) {
+  {
+    pendingPassiveProfilerEffects.push(fiber);
+
+    if (!rootDoesHavePassiveEffects) {
+      rootDoesHavePassiveEffects = true;
+      scheduleCallback(NormalPriority$1, () => {
+        flushPassiveEffects();
+        return null;
+      });
+    }
+  }
+}
+
+function flushPassiveEffectsImpl() {
+  if (rootWithPendingPassiveEffects === null) {
+    return false;
+  } // Cache and clear the transitions flag
+
+
+  const transitions = pendingPassiveTransitions;
+  pendingPassiveTransitions = null;
+  const root = rootWithPendingPassiveEffects;
+  const lanes = pendingPassiveEffectsLanes;
+  rootWithPendingPassiveEffects = null; // TODO: This is sometimes out of sync with rootWithPendingPassiveEffects.
+  // Figure out why and fix it. It's not causing any known issues (probably
+  // because it's only used for profiling), but it's a refactor hazard.
+
+  pendingPassiveEffectsLanes = NoLanes;
+
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw Error(formatProdErrorMessage(331));
+  }
+
+  {
+    markPassiveEffectsStarted(lanes);
+  }
+
+  const prevExecutionContext = executionContext;
+  executionContext |= CommitContext;
+  commitPassiveUnmountEffects(root.current);
+  commitPassiveMountEffects(root, root.current, lanes, transitions); // TODO: Move to commitPassiveMountEffects
+
+  {
+    const profilerEffects = pendingPassiveProfilerEffects;
+    pendingPassiveProfilerEffects = [];
+
+    for (let i = 0; i < profilerEffects.length; i++) {
+      const fiber = profilerEffects[i];
+      commitPassiveEffectDurations(root, fiber);
+    }
+  }
+
+  {
+    markPassiveEffectsStopped();
+  }
+
+  executionContext = prevExecutionContext;
+  flushSyncWorkOnAllRoots();
+
+
+  onPostCommitRoot(root);
+
+  {
+    const stateNode = root.current.stateNode;
+    stateNode.effectDuration = 0;
+    stateNode.passiveEffectDuration = 0;
+  }
+
+  return true;
+}
+
+function isAlreadyFailedLegacyErrorBoundary(instance) {
+  return legacyErrorBoundariesThatAlreadyFailed !== null && legacyErrorBoundariesThatAlreadyFailed.has(instance);
+}
+function markLegacyErrorBoundaryAsFailed(instance) {
+  if (legacyErrorBoundariesThatAlreadyFailed === null) {
+    legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);
+  } else {
+    legacyErrorBoundariesThatAlreadyFailed.add(instance);
+  }
+}
+
+function prepareToThrowUncaughtError(error) {
+  if (!hasUncaughtError) {
+    hasUncaughtError = true;
+    firstUncaughtError = error;
+  }
+}
+
+const onUncaughtError = prepareToThrowUncaughtError;
+
+function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
+  const errorInfo = createCapturedValueAtFiber(error, sourceFiber);
+  const update = createRootErrorUpdate(rootFiber, errorInfo, SyncLane);
+  const root = enqueueUpdate(rootFiber, update, SyncLane);
+
+  if (root !== null) {
+    markRootUpdated(root, SyncLane);
+    ensureRootIsScheduled(root);
+  }
+}
+
+function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
+
+  if (sourceFiber.tag === HostRoot) {
+    // Error was thrown at the root. There is no parent, so the root
+    // itself should capture it.
+    captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
+    return;
+  }
+
+  let fiber = nearestMountedAncestor;
+
+  while (fiber !== null) {
+    if (fiber.tag === HostRoot) {
+      captureCommitPhaseErrorOnRoot(fiber, sourceFiber, error);
+      return;
+    } else if (fiber.tag === ClassComponent) {
+      const ctor = fiber.type;
+      const instance = fiber.stateNode;
+
+      if (typeof ctor.getDerivedStateFromError === 'function' || typeof instance.componentDidCatch === 'function' && !isAlreadyFailedLegacyErrorBoundary(instance)) {
+        const errorInfo = createCapturedValueAtFiber(error, sourceFiber);
+        const update = createClassErrorUpdate(fiber, errorInfo, SyncLane);
+        const root = enqueueUpdate(fiber, update, SyncLane);
+
+        if (root !== null) {
+          markRootUpdated(root, SyncLane);
+          ensureRootIsScheduled(root);
+        }
+
+        return;
+      }
+    }
+
+    fiber = fiber.return;
+  }
+}
+function attachPingListener(root, wakeable, lanes) {
+  // Attach a ping listener
+  //
+  // The data might resolve before we have a chance to commit the fallback. Or,
+  // in the case of a refresh, we'll never commit a fallback. So we need to
+  // attach a listener now. When it resolves ("pings"), we can decide whether to
+  // try rendering the tree again.
+  //
+  // Only attach a listener if one does not already exist for the lanes
+  // we're currently rendering (which acts like a "thread ID" here).
+  //
+  // We only need to do this in concurrent mode. Legacy Suspense always
+  // commits fallbacks synchronously, so there are no pings.
+  let pingCache = root.pingCache;
+  let threadIDs;
+
+  if (pingCache === null) {
+    pingCache = root.pingCache = new PossiblyWeakMap();
+    threadIDs = new Set();
+    pingCache.set(wakeable, threadIDs);
+  } else {
+    threadIDs = pingCache.get(wakeable);
+
+    if (threadIDs === undefined) {
+      threadIDs = new Set();
+      pingCache.set(wakeable, threadIDs);
+    }
+  }
+
+  if (!threadIDs.has(lanes)) {
+    workInProgressRootDidAttachPingListener = true; // Memoize using the thread ID to prevent redundant listeners.
+
+    threadIDs.add(lanes);
+    const 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);
+  }
+}
+
+function pingSuspendedRoot(root, wakeable, pingedLanes) {
+  const pingCache = root.pingCache;
+
+  if (pingCache !== null) {
+    // The wakeable resolved, so we no longer need to memoize, because it will
+    // never be thrown again.
+    pingCache.delete(wakeable);
+  }
+
+  markRootPinged(root, pingedLanes);
+
+  if (workInProgressRoot === root && isSubsetOfLanes(workInProgressRootRenderLanes, pingedLanes)) {
+    // Received a ping at the same priority level at which we're currently
+    // rendering. We might want to restart this render. This should mirror
+    // the logic of whether or not a root suspends once it completes.
+    // TODO: If we're rendering sync either due to Sync, Batched or expired,
+    // we should probably never restart.
+    // If we're suspended with delay, or if it's a retry, we'll always suspend
+    // so we can always restart.
+    if (workInProgressRootExitStatus === RootSuspendedWithDelay || workInProgressRootExitStatus === RootSuspended && includesOnlyRetries(workInProgressRootRenderLanes) && now$1() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS) {
+      // Force a restart from the root by unwinding the stack. Unless this is
+      // being called from the render phase, because that would cause a crash.
+      if ((executionContext & RenderContext) === NoContext) {
+        prepareFreshStack(root, NoLanes);
+      }
+    } else {
+      // Even though we can't restart right now, we might get an
+      // opportunity later. So we mark this render as having a ping.
+      workInProgressRootPingedLanes = mergeLanes(workInProgressRootPingedLanes, pingedLanes);
+    }
+  }
+
+  ensureRootIsScheduled(root);
+}
+
+function retryTimedOutBoundary(boundaryFiber, retryLane) {
+  // The boundary fiber (a Suspense component or SuspenseList component)
+  // previously was rendered in its fallback state. One of the promises that
+  // suspended it has resolved, which means at least part of the tree was
+  // likely unblocked. Try rendering again, at a new lanes.
+  if (retryLane === NoLane) {
+    // TODO: Assign this to `suspenseState.retryLane`? to avoid
+    // unnecessary entanglement?
+    retryLane = requestRetryLane(boundaryFiber);
+  } // TODO: Special case idle priority?
+
+
+  const root = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
+
+  if (root !== null) {
+    markRootUpdated(root, retryLane);
+    ensureRootIsScheduled(root);
+  }
+}
+
+function retryDehydratedSuspenseBoundary(boundaryFiber) {
+  const suspenseState = boundaryFiber.memoizedState;
+  let retryLane = NoLane;
+
+  if (suspenseState !== null) {
+    retryLane = suspenseState.retryLane;
+  }
+
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+}
+function resolveRetryWakeable(boundaryFiber, wakeable) {
+  let retryLane = NoLane; // Default
+
+  let retryCache;
+
+  switch (boundaryFiber.tag) {
+    case SuspenseComponent:
+      retryCache = boundaryFiber.stateNode;
+      const suspenseState = boundaryFiber.memoizedState;
+
+      if (suspenseState !== null) {
+        retryLane = suspenseState.retryLane;
+      }
+
+      break;
+
+    case SuspenseListComponent:
+      retryCache = boundaryFiber.stateNode;
+      break;
+
+    case OffscreenComponent:
+      {
+        const instance = boundaryFiber.stateNode;
+        retryCache = instance._retryCache;
+        break;
+      }
+
+    default:
+      throw Error(formatProdErrorMessage(314));
+  }
+
+  if (retryCache !== null) {
+    // The wakeable resolved, so we no longer need to memoize, because it will
+    // never be thrown again.
+    retryCache.delete(wakeable);
+  }
+
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+}
+function throwIfInfiniteUpdateLoopDetected() {
+  if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
+    nestedUpdateCount = 0;
+    rootWithNestedUpdates = null;
+    throw Error(formatProdErrorMessage(185));
+  }
+}
+let beginWork;
+
+{
+  beginWork = beginWork$1;
+}
+
+function restorePendingUpdaters(root, lanes) {
+  {
+    if (isDevToolsPresent) {
+      const memoizedUpdaters = root.memoizedUpdaters;
+      memoizedUpdaters.forEach(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).
+    }
+  }
+}
+
+function scheduleCallback(priorityLevel, callback) {
+  {
+    // In production, always call Scheduler. This function will be stripped out.
+    return scheduleCallback$3(priorityLevel, callback);
+  }
+}
+
+function FiberNode(tag, pendingProps, key, mode) {
+  // Instance
+  this.tag = tag;
+  this.key = key;
+  this.elementType = null;
+  this.type = null;
+  this.stateNode = null; // Fiber
+
+  this.return = null;
+  this.child = null;
+  this.sibling = null;
+  this.index = 0;
+  this.ref = null;
+  this.refCleanup = null;
+  this.pendingProps = pendingProps;
+  this.memoizedProps = null;
+  this.updateQueue = null;
+  this.memoizedState = null;
+  this.dependencies = null;
+  this.mode = mode; // Effects
+
+  this.flags = NoFlags$1;
+  this.subtreeFlags = NoFlags$1;
+  this.deletions = null;
+  this.lanes = NoLanes;
+  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 is a constructor function, rather than a POJO constructor, still
+// please ensure we do the following:
+// 1) Nobody should add any instance methods on this. Instance methods can be
+//    more difficult to predict when they get optimized and they are almost
+//    never inlined properly in static compilers.
+// 2) Nobody should rely on `instanceof Fiber` for type testing. We should
+//    always know when it is a fiber.
+// 3) We might want to experiment with using numeric keys since they are easier
+//    to optimize in a non-JIT environment.
+// 4) We can easily go from a constructor to a createFiber object literal if that
+//    is faster.
+// 5) It should be easy to port this to a C struct and keep a C implementation
+//    compatible.
+
+
+function createFiber(tag, pendingProps, key, mode) {
+  // $FlowFixMe[invalid-constructor]: the shapes are exact here but Flow doesn't like constructors
+  return new FiberNode(tag, pendingProps, key, mode);
+}
+
+function shouldConstruct(Component) {
+  const prototype = Component.prototype;
+  return !!(prototype && prototype.isReactComponent);
+}
+
+function isSimpleFunctionComponent(type) {
+  return typeof type === 'function' && !shouldConstruct(type) && type.defaultProps === undefined;
+}
+function resolveLazyComponentTag(Component) {
+  if (typeof Component === 'function') {
+    return shouldConstruct(Component) ? ClassComponent : FunctionComponent;
+  } else if (Component !== undefined && Component !== null) {
+    const $$typeof = Component.$$typeof;
+
+    if ($$typeof === REACT_FORWARD_REF_TYPE) {
+      return ForwardRef;
+    }
+
+    if ($$typeof === REACT_MEMO_TYPE) {
+      return MemoComponent;
+    }
+  }
+
+  return IndeterminateComponent;
+} // This is used to create an alternate fiber to do work on.
+
+function createWorkInProgress(current, pendingProps) {
+  let workInProgress = current.alternate;
+
+  if (workInProgress === null) {
+    // We use a double buffering pooling technique because we know that we'll
+    // only ever need at most two versions of a tree. We pool the "other" unused
+    // node that we're free to reuse. This is lazily created to avoid allocating
+    // extra objects for things that are never updated. It also allow us to
+    // reclaim the extra memory if needed.
+    workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode);
+    workInProgress.elementType = current.elementType;
+    workInProgress.type = current.type;
+    workInProgress.stateNode = current.stateNode;
+
+    workInProgress.alternate = current;
+    current.alternate = workInProgress;
+  } else {
+    workInProgress.pendingProps = pendingProps; // Needed because Blocks store data on type.
+
+    workInProgress.type = current.type; // We already have an alternate.
+    // Reset the effect tag.
+
+    workInProgress.flags = NoFlags$1; // The effects are no longer valid.
+
+    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.
+
+
+  workInProgress.flags = current.flags & StaticMask;
+  workInProgress.childLanes = current.childLanes;
+  workInProgress.lanes = current.lanes;
+  workInProgress.child = current.child;
+  workInProgress.memoizedProps = current.memoizedProps;
+  workInProgress.memoizedState = current.memoizedState;
+  workInProgress.updateQueue = current.updateQueue; // Clone the dependencies object. This is mutated during the render phase, so
+  // it cannot be shared with the current fiber.
+
+  const currentDependencies = current.dependencies;
+  workInProgress.dependencies = currentDependencies === null ? null : {
+    lanes: currentDependencies.lanes,
+    firstContext: currentDependencies.firstContext
+  }; // These will be overridden during the parent's reconciliation
+
+  workInProgress.sibling = current.sibling;
+  workInProgress.index = current.index;
+  workInProgress.ref = current.ref;
+  workInProgress.refCleanup = current.refCleanup;
+
+  {
+    workInProgress.selfBaseDuration = current.selfBaseDuration;
+    workInProgress.treeBaseDuration = current.treeBaseDuration;
+  }
+
+  return workInProgress;
+} // Used to reuse a Fiber for a second pass.
+
+function resetWorkInProgress(workInProgress, renderLanes) {
+  // This resets the Fiber to what createFiber or createWorkInProgress would
+  // have set the values to before during the first pass. Ideally this wouldn't
+  // be necessary but unfortunately many code paths reads from the workInProgress
+  // when they should be reading from current and writing to workInProgress.
+  // We assume pendingProps, index, key, ref, return are still untouched to
+  // avoid doing another reconciliation.
+  // Reset the effect flags but keep any Placement tags, since that's something
+  // that child fiber is setting, not the reconciliation.
+  workInProgress.flags &= StaticMask | Placement; // The effects are no longer valid.
+
+  const current = workInProgress.alternate;
+
+  if (current === null) {
+    // Reset to createFiber's initial values.
+    workInProgress.childLanes = NoLanes;
+    workInProgress.lanes = renderLanes;
+    workInProgress.child = null;
+    workInProgress.subtreeFlags = NoFlags$1;
+    workInProgress.memoizedProps = null;
+    workInProgress.memoizedState = null;
+    workInProgress.updateQueue = null;
+    workInProgress.dependencies = null;
+    workInProgress.stateNode = null;
+
+    {
+      // Note: We don't reset the actualTime counts. It's useful to accumulate
+      // actual time across multiple render passes.
+      workInProgress.selfBaseDuration = 0;
+      workInProgress.treeBaseDuration = 0;
+    }
+  } else {
+    // Reset to the cloned values that createWorkInProgress would've.
+    workInProgress.childLanes = current.childLanes;
+    workInProgress.lanes = current.lanes;
+    workInProgress.child = current.child;
+    workInProgress.subtreeFlags = NoFlags$1;
+    workInProgress.deletions = null;
+    workInProgress.memoizedProps = current.memoizedProps;
+    workInProgress.memoizedState = current.memoizedState;
+    workInProgress.updateQueue = current.updateQueue; // Needed because Blocks store data on type.
+
+    workInProgress.type = current.type; // Clone the dependencies object. This is mutated during the render phase, so
+    // it cannot be shared with the current fiber.
+
+    const currentDependencies = current.dependencies;
+    workInProgress.dependencies = currentDependencies === null ? null : {
+      lanes: currentDependencies.lanes,
+      firstContext: currentDependencies.firstContext
+    };
+
+    {
+      // Note: We don't reset the actualTime counts. It's useful to accumulate
+      // actual time across multiple render passes.
+      workInProgress.selfBaseDuration = current.selfBaseDuration;
+      workInProgress.treeBaseDuration = current.treeBaseDuration;
+    }
+  }
+
+  return workInProgress;
+}
+function createHostRootFiber(tag, isStrictMode, concurrentUpdatesByDefaultOverride) {
+  let mode;
+
+  if (tag === ConcurrentRoot) {
+    mode = ConcurrentMode;
+
+    if (isStrictMode === true || createRootStrictEffectsByDefault) {
+      mode |= StrictLegacyMode | StrictEffectsMode;
+    }
+  } else {
+    mode = NoMode;
+  }
+
+  if (isDevToolsPresent) {
+    // Always collect profile timings when DevTools are present.
+    // This enables DevTools to start capturing timing at any point–
+    // Without some nodes in the tree having empty base times.
+    mode |= ProfileMode;
+  }
+
+  return createFiber(HostRoot, null, null, mode);
+}
+function createFiberFromTypeAndProps(type, // React$ElementType
+key, pendingProps, source, owner, mode, lanes) {
+  let fiberTag = IndeterminateComponent; // The resolved type is set if we know what the final type will be. I.e. it's not lazy.
+
+  let resolvedType = type;
+
+  if (typeof type === 'function') {
+    if (shouldConstruct(type)) {
+      fiberTag = ClassComponent;
+    }
+  } else if (typeof type === 'string') {
+    {
+      const hostContext = getHostContext();
+      fiberTag = isHostHoistableType(type, pendingProps, hostContext) ? HostHoistable : isHostSingletonType(type) ? HostSingleton : HostComponent;
+    }
+  } else {
+    getTag: switch (type) {
+      case REACT_FRAGMENT_TYPE:
+        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
+
+      case REACT_STRICT_MODE_TYPE:
+        fiberTag = Mode;
+        mode |= StrictLegacyMode;
+
+        if ((mode & ConcurrentMode) !== NoMode) {
+          // Strict effects should never run on legacy roots
+          mode |= StrictEffectsMode;
+        }
+
+        break;
+
+      case REACT_PROFILER_TYPE:
+        return createFiberFromProfiler(pendingProps, mode, lanes, key);
+
+      case REACT_SUSPENSE_TYPE:
+        return createFiberFromSuspense(pendingProps, mode, lanes, key);
+
+      case REACT_SUSPENSE_LIST_TYPE:
+        return createFiberFromSuspenseList(pendingProps, mode, lanes, key);
+
+      case REACT_OFFSCREEN_TYPE:
+        return createFiberFromOffscreen(pendingProps, mode, lanes, key);
+
+      case REACT_LEGACY_HIDDEN_TYPE:
+
+      // Fall through
+
+      case REACT_SCOPE_TYPE:
+
+      // Fall through
+
+      case REACT_CACHE_TYPE:
+        {
+          return createFiberFromCache(pendingProps, mode, lanes, key);
+        }
+
+      // Fall through
+
+      case REACT_TRACING_MARKER_TYPE:
+
+      // Fall through
+
+      case REACT_DEBUG_TRACING_MODE_TYPE:
+
+      // Fall through
+
+      default:
+        {
+          if (typeof type === 'object' && type !== null) {
+            switch (type.$$typeof) {
+              case REACT_PROVIDER_TYPE:
+                fiberTag = ContextProvider;
+                break getTag;
+
+              case REACT_CONTEXT_TYPE:
+                // This is a consumer
+                fiberTag = ContextConsumer;
+                break getTag;
+
+              case REACT_FORWARD_REF_TYPE:
+                fiberTag = ForwardRef;
+
+                break getTag;
+
+              case REACT_MEMO_TYPE:
+                fiberTag = MemoComponent;
+                break getTag;
+
+              case REACT_LAZY_TYPE:
+                fiberTag = LazyComponent;
+                resolvedType = null;
+                break getTag;
+            }
+          }
+
+          let info = '';
+
+          throw Error(formatProdErrorMessage(130, type == null ? type : typeof type, info));
+        }
+    }
+  }
+
+  const fiber = createFiber(fiberTag, pendingProps, key, mode);
+  fiber.elementType = type;
+  fiber.type = resolvedType;
+  fiber.lanes = lanes;
+
+  return fiber;
+}
+function createFiberFromElement(element, mode, lanes) {
+  let source = null;
+  let owner = null;
+
+  const type = element.type;
+  const key = element.key;
+  const pendingProps = element.props;
+  const fiber = createFiberFromTypeAndProps(type, key, pendingProps, source, owner, mode, lanes);
+
+  return fiber;
+}
+function createFiberFromFragment(elements, mode, lanes, key) {
+  const fiber = createFiber(Fragment, elements, key, mode);
+  fiber.lanes = lanes;
+  return fiber;
+}
+
+function createFiberFromProfiler(pendingProps, mode, lanes, key) {
+
+  const fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);
+  fiber.elementType = REACT_PROFILER_TYPE;
+  fiber.lanes = lanes;
+
+  {
+    fiber.stateNode = {
+      effectDuration: 0,
+      passiveEffectDuration: 0
+    };
+  }
+
+  return fiber;
+}
+
+function createFiberFromSuspense(pendingProps, mode, lanes, key) {
+  const fiber = createFiber(SuspenseComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_SUSPENSE_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromSuspenseList(pendingProps, mode, lanes, key) {
+  const fiber = createFiber(SuspenseListComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_SUSPENSE_LIST_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
+  const fiber = createFiber(OffscreenComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_OFFSCREEN_TYPE;
+  fiber.lanes = lanes;
+  const primaryChildInstance = {
+    _visibility: OffscreenVisible,
+    _pendingVisibility: OffscreenVisible,
+    _pendingMarkers: null,
+    _retryCache: null,
+    _transitions: null,
+    _current: null,
+    detach: () => detachOffscreenInstance(primaryChildInstance),
+    attach: () => attachOffscreenInstance(primaryChildInstance)
+  };
+  fiber.stateNode = primaryChildInstance;
+  return fiber;
+}
+function createFiberFromCache(pendingProps, mode, lanes, key) {
+  const fiber = createFiber(CacheComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_CACHE_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromText(content, mode, lanes) {
+  const fiber = createFiber(HostText, content, null, mode);
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromHostInstanceForDeletion() {
+  const fiber = createFiber(HostComponent, null, null, NoMode);
+  fiber.elementType = 'DELETED';
+  return fiber;
+}
+function createFiberFromDehydratedFragment(dehydratedNode) {
+  const fiber = createFiber(DehydratedFragment, null, null, NoMode);
+  fiber.stateNode = dehydratedNode;
+  return fiber;
+}
+function createFiberFromPortal(portal, mode, lanes) {
+  const pendingProps = portal.children !== null ? portal.children : [];
+  const fiber = createFiber(HostPortal, pendingProps, portal.key, mode);
+  fiber.lanes = lanes;
+  fiber.stateNode = {
+    containerInfo: portal.containerInfo,
+    pendingChildren: null,
+    // Used by persistent updates
+    implementation: portal.implementation
+  };
+  return fiber;
+} // Used for stashing WIP properties to replay failed work in DEV.
+
+function FiberRootNode(containerInfo, // $FlowFixMe[missing-local-annot]
+tag, hydrate, identifierPrefix, onRecoverableError, formState) {
+  this.tag = tag;
+  this.containerInfo = containerInfo;
+  this.pendingChildren = null;
+  this.current = null;
+  this.pingCache = null;
+  this.finishedWork = null;
+  this.timeoutHandle = noTimeout;
+  this.cancelPendingCommit = null;
+  this.context = null;
+  this.pendingContext = null;
+  this.next = null;
+  this.callbackNode = null;
+  this.callbackPriority = NoLane;
+  this.expirationTimes = createLaneMap(NoTimestamp);
+  this.pendingLanes = NoLanes;
+  this.suspendedLanes = NoLanes;
+  this.pingedLanes = NoLanes;
+  this.expiredLanes = NoLanes;
+  this.finishedLanes = NoLanes;
+  this.errorRecoveryDisabledLanes = NoLanes;
+  this.shellSuspendCounter = 0;
+  this.entangledLanes = NoLanes;
+  this.entanglements = createLaneMap(NoLanes);
+  this.hiddenUpdates = createLaneMap(null);
+  this.identifierPrefix = identifierPrefix;
+  this.onRecoverableError = onRecoverableError;
+
+  {
+    this.pooledCache = null;
+    this.pooledCacheLanes = NoLanes;
+  }
+
+  this.formState = formState;
+  this.incompleteTransitions = new Map();
+
+  {
+    this.effectDuration = 0;
+    this.passiveEffectDuration = 0;
+  }
+
+  {
+    this.memoizedUpdaters = new Set();
+    const pendingUpdatersLaneMap = this.pendingUpdatersLaneMap = [];
+
+    for (let i = 0; i < TotalLanes; i++) {
+      pendingUpdatersLaneMap.push(new Set());
+    }
+  }
+}
+
+function createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, // TODO: We have several of these arguments that are conceptually part of the
+// host config, but because they are passed in at runtime, we have to thread
+// them through the root constructor. Perhaps we should put them all into a
+// single type, like a DynamicHostConfig that is defined by the renderer.
+identifierPrefix, onRecoverableError, transitionCallbacks, formState) {
+  // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
+  const root = new FiberRootNode(containerInfo, tag, hydrate, identifierPrefix, onRecoverableError, formState);
+  // stateNode is any.
+
+
+  const uninitializedFiber = createHostRootFiber(tag, isStrictMode);
+  root.current = uninitializedFiber;
+  uninitializedFiber.stateNode = root;
+
+  {
+    const initialCache = createCache();
+    retainCache(initialCache); // The pooledCache is a fresh cache instance that is used temporarily
+    // for newly mounted boundaries during a render. In general, the
+    // pooledCache is always cleared from the root at the end of a render:
+    // it is either released when render commits, or moved to an Offscreen
+    // component if rendering suspends. Because the lifetime of the pooled
+    // cache is distinct from the main memoizedState.cache, it must be
+    // retained separately.
+
+    root.pooledCache = initialCache;
+    retainCache(initialCache);
+    const initialState = {
+      element: initialChildren,
+      isDehydrated: hydrate,
+      cache: initialCache
+    };
+    uninitializedFiber.memoizedState = initialState;
+  }
+
+  initializeUpdateQueue(uninitializedFiber);
+  return root;
+}
+
+var ReactVersion = '18.3.0-canary-7508dcd5c-20231108';
+
+function createPortal$1(children, containerInfo, // TODO: figure out the API for cross-renderer implementation.
+implementation) {
+  let key = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+
+  return {
+    // This tag allow us to uniquely identify this as a React Portal
+    $$typeof: REACT_PORTAL_TYPE,
+    key: key == null ? null : '' + key,
+    children,
+    containerInfo,
+    implementation
+  };
+}
+
+function getContextForSubtree(parentComponent) {
+  if (!parentComponent) {
+    return emptyContextObject;
+  }
+
+  const fiber = get(parentComponent);
+  const parentContext = findCurrentUnmaskedContext(fiber);
+
+  if (fiber.tag === ClassComponent) {
+    const Component = fiber.type;
+
+    if (isContextProvider(Component)) {
+      return processChildContext(fiber, Component, parentContext);
+    }
+  }
+
+  return parentContext;
+}
+
+function findHostInstance(component) {
+  const fiber = get(component);
+
+  if (fiber === undefined) {
+    if (typeof component.render === 'function') {
+      throw Error(formatProdErrorMessage(188));
+    } else {
+      const keys = Object.keys(component).join(',');
+      throw Error(formatProdErrorMessage(268, keys));
+    }
+  }
+
+  const hostFiber = findCurrentHostFiber(fiber);
+
+  if (hostFiber === null) {
+    return null;
+  }
+
+  return getPublicInstance(hostFiber.stateNode);
+}
+
+function createContainer(containerInfo, tag, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks) {
+  const hydrate = false;
+  const initialChildren = null;
+  return createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks, null);
+}
+function createHydrationContainer(initialChildren, // TODO: Remove `callback` when we delete legacy mode.
+callback, containerInfo, tag, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks, formState) {
+  const hydrate = true;
+  const root = createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks, formState); // TODO: Move this to FiberRoot constructor
+
+  root.context = getContextForSubtree(null); // Schedule the initial render. In a hydration root, this is different from
+  // a regular update because the initial render must match was was rendered
+  // on the server.
+  // NOTE: This update intentionally doesn't have a payload. We're only using
+  // the update to schedule work on the root fiber (and, for legacy roots, to
+  // enqueue the callback if one is provided).
+
+  const current = root.current;
+  const lane = requestUpdateLane(current);
+  const update = createUpdate(lane);
+  update.callback = callback !== undefined && callback !== null ? callback : null;
+  enqueueUpdate(current, update, lane);
+  scheduleInitialHydrationOnRoot(root, lane);
+  return root;
+}
+function updateContainer(element, container, parentComponent, callback) {
+
+  const current = container.current;
+  const lane = requestUpdateLane(current);
+
+  {
+    markRenderScheduled(lane);
+  }
+
+  const context = getContextForSubtree(parentComponent);
+
+  if (container.context === null) {
+    container.context = context;
+  } else {
+    container.pendingContext = context;
+  }
+
+  const update = createUpdate(lane); // Caution: React DevTools currently depends on this property
+  // being called "element".
+
+  update.payload = {
+    element
+  };
+  callback = callback === undefined ? null : callback;
+
+  if (callback !== null) {
+
+    update.callback = callback;
+  }
+
+  const root = enqueueUpdate(current, update, lane);
+
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, current, lane);
+    entangleTransitions(root, current, lane);
+  }
+
+  return lane;
+}
+function getPublicRootInstance(container) {
+  const containerFiber = container.current;
+
+  if (!containerFiber.child) {
+    return null;
+  }
+
+  switch (containerFiber.child.tag) {
+    case HostSingleton:
+    case HostComponent:
+      return getPublicInstance(containerFiber.child.stateNode);
+
+    default:
+      return containerFiber.child.stateNode;
+  }
+}
+function attemptSynchronousHydration(fiber) {
+  switch (fiber.tag) {
+    case HostRoot:
+      {
+        const root = fiber.stateNode;
+
+        if (isRootDehydrated(root)) {
+          // Flush the first scheduled "update".
+          const lanes = getHighestPriorityPendingLanes(root);
+          flushRoot(root, lanes);
+        }
+
+        break;
+      }
+
+    case SuspenseComponent:
+      {
+        flushSync$1(() => {
+          const root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+          if (root !== null) {
+            scheduleUpdateOnFiber(root, fiber, SyncLane);
+          }
+        }); // If we're still blocked after this, we need to increase
+        // the priority of any promises resolving within this
+        // boundary so that they next attempt also has higher pri.
+
+        const retryLane = SyncLane;
+        markRetryLaneIfNotHydrated(fiber, retryLane);
+        break;
+      }
+  }
+}
+
+function markRetryLaneImpl(fiber, retryLane) {
+  const suspenseState = fiber.memoizedState;
+
+  if (suspenseState !== null && suspenseState.dehydrated !== null) {
+    suspenseState.retryLane = higherPriorityLane(suspenseState.retryLane, retryLane);
+  }
+} // Increases the priority of thenables when they resolve within this boundary.
+
+
+function markRetryLaneIfNotHydrated(fiber, retryLane) {
+  markRetryLaneImpl(fiber, retryLane);
+  const alternate = fiber.alternate;
+
+  if (alternate) {
+    markRetryLaneImpl(alternate, retryLane);
+  }
+}
+
+function attemptContinuousHydration(fiber) {
+  if (fiber.tag !== SuspenseComponent) {
+    // We ignore HostRoots here because we can't increase
+    // their priority and they should not suspend on I/O,
+    // since you have to wrap anything that might suspend in
+    // Suspense.
+    return;
+  }
+
+  const lane = SelectiveHydrationLane;
+  const root = enqueueConcurrentRenderForLane(fiber, lane);
+
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, fiber, lane);
+  }
+
+  markRetryLaneIfNotHydrated(fiber, lane);
+}
+function attemptHydrationAtCurrentPriority(fiber) {
+  if (fiber.tag !== SuspenseComponent) {
+    // We ignore HostRoots here because we can't increase
+    // their priority other than synchronously flush it.
+    return;
+  }
+
+  const lane = requestUpdateLane(fiber);
+  const root = enqueueConcurrentRenderForLane(fiber, lane);
+
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, fiber, lane);
+  }
+
+  markRetryLaneIfNotHydrated(fiber, lane);
+}
+let overrideHookState = null;
+let overrideHookStateDeletePath = null;
+let overrideHookStateRenamePath = null;
+let overrideProps = null;
+let overridePropsDeletePath = null;
+let overridePropsRenamePath = null;
+let scheduleUpdate = null;
+let setErrorHandler = null;
+let setSuspenseHandler = null;
+
+function findHostInstanceByFiber(fiber) {
+  const hostFiber = findCurrentHostFiber(fiber);
+
+  if (hostFiber === null) {
+    return null;
+  }
+
+  return hostFiber.stateNode;
+}
+
+function emptyFindFiberByHostInstance(instance) {
+  return null;
+}
+
+function injectIntoDevTools(devToolsConfig) {
+  const findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
+  const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+  return injectInternals({
+    bundleType: devToolsConfig.bundleType,
+    version: devToolsConfig.version,
+    rendererPackageName: devToolsConfig.rendererPackageName,
+    rendererConfig: devToolsConfig.rendererConfig,
+    overrideHookState,
+    overrideHookStateDeletePath,
+    overrideHookStateRenamePath,
+    overrideProps,
+    overridePropsDeletePath,
+    overridePropsRenamePath,
+    setErrorHandler,
+    setSuspenseHandler,
+    scheduleUpdate,
+    currentDispatcherRef: ReactCurrentDispatcher,
+    findHostInstanceByFiber,
+    findFiberByHostInstance: findFiberByHostInstance || emptyFindFiberByHostInstance,
+    // React Refresh
+    findHostInstancesForRefresh: null,
+    scheduleRefresh: null,
+    scheduleRoot: null,
+    setRefreshHandler: null,
+    // Enables DevTools to append owner stacks to error messages in DEV mode.
+    getCurrentFiber: null,
+    // Enables DevTools to detect reconciler version rather than renderer version
+    // which may not match for third party renderers.
+    reconcilerVersion: ReactVersion
+  });
+}
+
+// the renderer. Such as when we're dispatching events or if third party
+// libraries need to call batchedUpdates. Eventually, this API will go away when
+// everything is batched by default. We'll then have a similar API to opt-out of
+// scheduled work and instead do synchronous work.
+
+let isInsideEventHandler = false;
+
+function finishEventHandler() {
+  // Here we wait until all updates have propagated, which is important
+  // when using controlled components within layers:
+  // https://github.com/facebook/react/issues/1698
+  // Then we restore state of any controlled component.
+  const controlledComponentsHavePendingUpdates = needsStateRestore();
+
+  if (controlledComponentsHavePendingUpdates) {
+    // If a controlled event was fired, we may need to restore the state of
+    // the DOM node back to the controlled value. This is necessary when React
+    // bails out of the update without touching the DOM.
+    // TODO: Restore state in the microtask, after the discrete updates flush,
+    // instead of early flushing them here.
+    flushSync$1();
+    restoreStateIfNeeded();
+  }
+}
+
+function batchedUpdates(fn, a, b) {
+  if (isInsideEventHandler) {
+    // If we are currently inside another batch, we need to wait until it
+    // fully completes before restoring state.
+    return fn(a, b);
+  }
+
+  isInsideEventHandler = true;
+
+  try {
+    return batchedUpdates$1(fn, a, b);
+  } finally {
+    isInsideEventHandler = false;
+    finishEventHandler();
+  }
+} // TODO: Replace with flushSync
+
+function isInteractive(tag) {
+  return tag === 'button' || tag === 'input' || tag === 'select' || tag === 'textarea';
+}
+
+function shouldPreventMouseEvent(name, type, props) {
+  switch (name) {
+    case 'onClick':
+    case 'onClickCapture':
+    case 'onDoubleClick':
+    case 'onDoubleClickCapture':
+    case 'onMouseDown':
+    case 'onMouseDownCapture':
+    case 'onMouseMove':
+    case 'onMouseMoveCapture':
+    case 'onMouseUp':
+    case 'onMouseUpCapture':
+    case 'onMouseEnter':
+      return !!(props.disabled && isInteractive(type));
+
+    default:
+      return false;
+  }
+}
+/**
+ * @param {object} inst The instance, which is the source of events.
+ * @param {string} registrationName Name of listener (e.g. `onClick`).
+ * @return {?function} The stored callback.
+ */
+
+
+function getListener(inst, registrationName) {
+  const stateNode = inst.stateNode;
+
+  if (stateNode === null) {
+    // Work in progress (ex: onload events in incremental mode).
+    return null;
+  }
+
+  const props = getFiberCurrentPropsFromNode(stateNode);
+
+  if (props === null) {
+    // Work in progress.
+    return null;
+  }
+
+  const listener = props[registrationName];
+
+  if (shouldPreventMouseEvent(registrationName, inst.type, props)) {
+    return null;
+  }
+
+  if (listener && typeof listener !== 'function') {
+    throw Error(formatProdErrorMessage(231, registrationName, typeof listener));
+  }
+
+  return listener;
+}
+
+let passiveBrowserEventsSupported = false; // Check if browser support events with passive listeners
+// https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support
+
+if (canUseDOM) {
+  try {
+    const options = {};
+    Object.defineProperty(options, 'passive', {
+      get: function () {
+        passiveBrowserEventsSupported = true;
+      }
+    });
+    window.addEventListener('test', options, options);
+    window.removeEventListener('test', options, options);
+  } catch (e) {
+    passiveBrowserEventsSupported = false;
+  }
+}
+
+/**
+ * `charCode` represents the actual "character code" and is safe to use with
+ * `String.fromCharCode`. As such, only keys that correspond to printable
+ * characters produce a valid `charCode`, the only exception to this is Enter.
+ * The Tab-key is considered non-printable and does not have a `charCode`,
+ * presumably because it does not produce a tab-character in browsers.
+ *
+ * @param {object} nativeEvent Native browser event.
+ * @return {number} Normalized `charCode` property.
+ */
+function getEventCharCode(nativeEvent) {
+  let charCode;
+  const keyCode = nativeEvent.keyCode;
+
+  if ('charCode' in nativeEvent) {
+    charCode = nativeEvent.charCode; // FF does not set `charCode` for the Enter-key, check against `keyCode`.
+
+    if (charCode === 0 && keyCode === 13) {
+      charCode = 13;
+    }
+  } else {
+    // IE8 does not implement `charCode`, but `keyCode` has the correct value.
+    charCode = keyCode;
+  } // IE and Edge (on Windows) and Chrome / Safari (on Windows and Linux)
+  // report Enter as charCode 10 when ctrl is pressed.
+
+
+  if (charCode === 10) {
+    charCode = 13;
+  } // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
+  // Must not discard the (non-)printable Enter-key.
+
+
+  if (charCode >= 32 || charCode === 13) {
+    return charCode;
+  }
+
+  return 0;
+}
+
+function functionThatReturnsTrue() {
+  return true;
+}
+
+function functionThatReturnsFalse() {
+  return false;
+} // This is intentionally a factory so that we have different returned constructors.
+// If we had a single constructor, it would be megamorphic and engines would deopt.
+
+
+function createSyntheticEvent(Interface) {
+  /**
+   * Synthetic events are dispatched by event plugins, typically in response to a
+   * top-level event delegation handler.
+   *
+   * These systems should generally use pooling to reduce the frequency of garbage
+   * collection. The system should check `isPersistent` to determine whether the
+   * event should be released into the pool after being dispatched. Users that
+   * need a persisted event should invoke `persist`.
+   *
+   * Synthetic events (and subclasses) implement the DOM Level 3 Events API by
+   * normalizing browser quirks. Subclasses do not necessarily have to implement a
+   * DOM interface; custom application-specific events can also subclass this.
+   */
+  // $FlowFixMe[missing-this-annot]
+  function SyntheticBaseEvent(reactName, reactEventType, targetInst, nativeEvent, nativeEventTarget) {
+    this._reactName = reactName;
+    this._targetInst = targetInst;
+    this.type = reactEventType;
+    this.nativeEvent = nativeEvent;
+    this.target = nativeEventTarget;
+    this.currentTarget = null;
+
+    for (const propName in Interface) {
+      if (!Interface.hasOwnProperty(propName)) {
+        continue;
+      }
+
+      const normalize = Interface[propName];
+
+      if (normalize) {
+        this[propName] = normalize(nativeEvent);
+      } else {
+        this[propName] = nativeEvent[propName];
+      }
+    }
+
+    const defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
+
+    if (defaultPrevented) {
+      this.isDefaultPrevented = functionThatReturnsTrue;
+    } else {
+      this.isDefaultPrevented = functionThatReturnsFalse;
+    }
+
+    this.isPropagationStopped = functionThatReturnsFalse;
+    return this;
+  } // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+  assign(SyntheticBaseEvent.prototype, {
+    // $FlowFixMe[missing-this-annot]
+    preventDefault: function () {
+      this.defaultPrevented = true;
+      const event = this.nativeEvent;
+
+      if (!event) {
+        return;
+      }
+
+      if (event.preventDefault) {
+        event.preventDefault(); // $FlowFixMe[illegal-typeof] - flow is not aware of `unknown` in IE
+      } else if (typeof event.returnValue !== 'unknown') {
+        event.returnValue = false;
+      }
+
+      this.isDefaultPrevented = functionThatReturnsTrue;
+    },
+    // $FlowFixMe[missing-this-annot]
+    stopPropagation: function () {
+      const event = this.nativeEvent;
+
+      if (!event) {
+        return;
+      }
+
+      if (event.stopPropagation) {
+        event.stopPropagation(); // $FlowFixMe[illegal-typeof] - flow is not aware of `unknown` in IE
+      } else if (typeof event.cancelBubble !== 'unknown') {
+        // The ChangeEventPlugin registers a "propertychange" event for
+        // IE. This event does not support bubbling or cancelling, and
+        // any references to cancelBubble throw "Member not found".  A
+        // typeof check of "unknown" circumvents this issue (and is also
+        // IE specific).
+        event.cancelBubble = true;
+      }
+
+      this.isPropagationStopped = functionThatReturnsTrue;
+    },
+
+    /**
+     * We release all dispatched `SyntheticEvent`s after each event loop, adding
+     * them back into the pool. This allows a way to hold onto a reference that
+     * won't be added back into the pool.
+     */
+    persist: function () {// Modern event system doesn't use pooling.
+    },
+
+    /**
+     * Checks if this event should be released back into the pool.
+     *
+     * @return {boolean} True if this should not be released, false otherwise.
+     */
+    isPersistent: functionThatReturnsTrue
+  });
+  return SyntheticBaseEvent;
+}
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+
+const EventInterface = {
+  eventPhase: 0,
+  bubbles: 0,
+  cancelable: 0,
+  timeStamp: function (event) {
+    return event.timeStamp || Date.now();
+  },
+  defaultPrevented: 0,
+  isTrusted: 0
+};
+const SyntheticEvent = createSyntheticEvent(EventInterface);
+
+const UIEventInterface = assign({}, EventInterface, {
+  view: 0,
+  detail: 0
+});
+
+const SyntheticUIEvent = createSyntheticEvent(UIEventInterface);
+let lastMovementX;
+let lastMovementY;
+let lastMouseEvent;
+
+function updateMouseMovementPolyfillState(event) {
+  if (event !== lastMouseEvent) {
+    if (lastMouseEvent && event.type === 'mousemove') {
+      // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+      lastMovementX = event.screenX - lastMouseEvent.screenX; // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+
+      lastMovementY = event.screenY - lastMouseEvent.screenY;
+    } else {
+      lastMovementX = 0;
+      lastMovementY = 0;
+    }
+
+    lastMouseEvent = event;
+  }
+}
+/**
+ * @interface MouseEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+
+const MouseEventInterface = assign({}, UIEventInterface, {
+  screenX: 0,
+  screenY: 0,
+  clientX: 0,
+  clientY: 0,
+  pageX: 0,
+  pageY: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  altKey: 0,
+  metaKey: 0,
+  getModifierState: getEventModifierState,
+  button: 0,
+  buttons: 0,
+  relatedTarget: function (event) {
+    if (event.relatedTarget === undefined) return event.fromElement === event.srcElement ? event.toElement : event.fromElement;
+    return event.relatedTarget;
+  },
+  movementX: function (event) {
+    if ('movementX' in event) {
+      return event.movementX;
+    }
+
+    updateMouseMovementPolyfillState(event);
+    return lastMovementX;
+  },
+  movementY: function (event) {
+    if ('movementY' in event) {
+      return event.movementY;
+    } // Don't need to call updateMouseMovementPolyfillState() here
+    // because it's guaranteed to have already run when movementX
+    // was copied.
+
+
+    return lastMovementY;
+  }
+});
+
+const SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface);
+/**
+ * @interface DragEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+const DragEventInterface = assign({}, MouseEventInterface, {
+  dataTransfer: 0
+});
+
+const SyntheticDragEvent = createSyntheticEvent(DragEventInterface);
+/**
+ * @interface FocusEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+const FocusEventInterface = assign({}, UIEventInterface, {
+  relatedTarget: 0
+});
+
+const SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent
+ */
+
+const AnimationEventInterface = assign({}, EventInterface, {
+  animationName: 0,
+  elapsedTime: 0,
+  pseudoElement: 0
+});
+
+const SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/clipboard-apis/
+ */
+
+const ClipboardEventInterface = assign({}, EventInterface, {
+  clipboardData: function (event) {
+    return 'clipboardData' in event ? event.clipboardData : window.clipboardData;
+  }
+});
+
+const SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents
+ */
+
+const CompositionEventInterface = assign({}, EventInterface, {
+  data: 0
+});
+
+const SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105
+ *      /#events-inputevents
+ */
+// Happens to share the same list for now.
+
+const SyntheticInputEvent = SyntheticCompositionEvent;
+/**
+ * Normalization of deprecated HTML5 `key` values
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
+ */
+
+const normalizeKey = {
+  Esc: 'Escape',
+  Spacebar: ' ',
+  Left: 'ArrowLeft',
+  Up: 'ArrowUp',
+  Right: 'ArrowRight',
+  Down: 'ArrowDown',
+  Del: 'Delete',
+  Win: 'OS',
+  Menu: 'ContextMenu',
+  Apps: 'ContextMenu',
+  Scroll: 'ScrollLock',
+  MozPrintableKey: 'Unidentified'
+};
+/**
+ * Translation from legacy `keyCode` to HTML5 `key`
+ * Only special keys supported, all others depend on keyboard layout or browser
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
+ */
+
+const translateToKey = {
+  '8': 'Backspace',
+  '9': 'Tab',
+  '12': 'Clear',
+  '13': 'Enter',
+  '16': 'Shift',
+  '17': 'Control',
+  '18': 'Alt',
+  '19': 'Pause',
+  '20': 'CapsLock',
+  '27': 'Escape',
+  '32': ' ',
+  '33': 'PageUp',
+  '34': 'PageDown',
+  '35': 'End',
+  '36': 'Home',
+  '37': 'ArrowLeft',
+  '38': 'ArrowUp',
+  '39': 'ArrowRight',
+  '40': 'ArrowDown',
+  '45': 'Insert',
+  '46': 'Delete',
+  '112': 'F1',
+  '113': 'F2',
+  '114': 'F3',
+  '115': 'F4',
+  '116': 'F5',
+  '117': 'F6',
+  '118': 'F7',
+  '119': 'F8',
+  '120': 'F9',
+  '121': 'F10',
+  '122': 'F11',
+  '123': 'F12',
+  '144': 'NumLock',
+  '145': 'ScrollLock',
+  '224': 'Meta'
+};
+/**
+ * @param {object} nativeEvent Native browser event.
+ * @return {string} Normalized `key` property.
+ */
+
+function getEventKey(nativeEvent) {
+  if (nativeEvent.key) {
+    // Normalize inconsistent values reported by browsers due to
+    // implementations of a working draft specification.
+    // FireFox implements `key` but returns `MozPrintableKey` for all
+    // printable characters (normalized to `Unidentified`), ignore it.
+    const key = // $FlowFixMe[invalid-computed-prop] unable to index with a `mixed` value
+    normalizeKey[nativeEvent.key] || nativeEvent.key;
+
+    if (key !== 'Unidentified') {
+      return key;
+    }
+  } // Browser does not implement `key`, polyfill as much of it as we can.
+
+
+  if (nativeEvent.type === 'keypress') {
+    const charCode = getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
+    nativeEvent); // The enter-key is technically both printable and non-printable and can
+    // thus be captured by `keypress`, no other non-printable key should.
+
+    return charCode === 13 ? 'Enter' : String.fromCharCode(charCode);
+  }
+
+  if (nativeEvent.type === 'keydown' || nativeEvent.type === 'keyup') {
+    // While user keyboard layout determines the actual meaning of each
+    // `keyCode` value, almost all function keys have a universal value.
+    // $FlowFixMe[invalid-computed-prop] unable to index with a `mixed` value
+    return translateToKey[nativeEvent.keyCode] || 'Unidentified';
+  }
+
+  return '';
+}
+/**
+ * Translation from modifier key to the associated property in the event.
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers
+ */
+
+
+const modifierKeyToProp = {
+  Alt: 'altKey',
+  Control: 'ctrlKey',
+  Meta: 'metaKey',
+  Shift: 'shiftKey'
+}; // Older browsers (Safari <= 10, iOS Safari <= 10.2) do not support
+// getModifierState. If getModifierState is not supported, we map it to a set of
+// modifier keys exposed by the event. In this case, Lock-keys are not supported.
+// $FlowFixMe[missing-local-annot]
+// $FlowFixMe[missing-this-annot]
+
+function modifierStateGetter(keyArg) {
+  const syntheticEvent = this;
+  const nativeEvent = syntheticEvent.nativeEvent;
+
+  if (nativeEvent.getModifierState) {
+    return nativeEvent.getModifierState(keyArg);
+  }
+
+  const keyProp = modifierKeyToProp[keyArg];
+  return keyProp ? !!nativeEvent[keyProp] : false;
+}
+
+function getEventModifierState(nativeEvent) {
+  return modifierStateGetter;
+}
+/**
+ * @interface KeyboardEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+
+const KeyboardEventInterface = assign({}, UIEventInterface, {
+  key: getEventKey,
+  code: 0,
+  location: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  altKey: 0,
+  metaKey: 0,
+  repeat: 0,
+  locale: 0,
+  getModifierState: getEventModifierState,
+  // Legacy Interface
+  charCode: function (event) {
+    // `charCode` is the result of a KeyPress event and represents the value of
+    // the actual printable character.
+    // KeyPress is deprecated, but its replacement is not yet final and not
+    // implemented in any major browser. Only KeyPress has charCode.
+    if (event.type === 'keypress') {
+      return getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
+      event);
+    }
+
+    return 0;
+  },
+  keyCode: function (event) {
+    // `keyCode` is the result of a KeyDown/Up event and represents the value of
+    // physical keyboard key.
+    // The actual meaning of the value depends on the users' keyboard layout
+    // which cannot be detected. Assuming that it is a US keyboard layout
+    // provides a surprisingly accurate mapping for US and European users.
+    // Due to this, it is left to the user to implement at this time.
+    if (event.type === 'keydown' || event.type === 'keyup') {
+      return event.keyCode;
+    }
+
+    return 0;
+  },
+  which: function (event) {
+    // `which` is an alias for either `keyCode` or `charCode` depending on the
+    // type of the event.
+    if (event.type === 'keypress') {
+      return getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
+      event);
+    }
+
+    if (event.type === 'keydown' || event.type === 'keyup') {
+      return event.keyCode;
+    }
+
+    return 0;
+  }
+});
+
+const SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface);
+/**
+ * @interface PointerEvent
+ * @see http://www.w3.org/TR/pointerevents/
+ */
+
+const PointerEventInterface = assign({}, MouseEventInterface, {
+  pointerId: 0,
+  width: 0,
+  height: 0,
+  pressure: 0,
+  tangentialPressure: 0,
+  tiltX: 0,
+  tiltY: 0,
+  twist: 0,
+  pointerType: 0,
+  isPrimary: 0
+});
+
+const SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface);
+/**
+ * @interface TouchEvent
+ * @see http://www.w3.org/TR/touch-events/
+ */
+
+const TouchEventInterface = assign({}, UIEventInterface, {
+  touches: 0,
+  targetTouches: 0,
+  changedTouches: 0,
+  altKey: 0,
+  metaKey: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  getModifierState: getEventModifierState
+});
+
+const SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent
+ */
+
+const TransitionEventInterface = assign({}, EventInterface, {
+  propertyName: 0,
+  elapsedTime: 0,
+  pseudoElement: 0
+});
+
+const SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface);
+/**
+ * @interface WheelEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+const WheelEventInterface = assign({}, MouseEventInterface, {
+  deltaX(event) {
+    return 'deltaX' in event ? event.deltaX : // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).
+    'wheelDeltaX' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+    -event.wheelDeltaX : 0;
+  },
+
+  deltaY(event) {
+    return 'deltaY' in event ? event.deltaY : // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
+    'wheelDeltaY' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+    -event.wheelDeltaY : // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
+    'wheelDelta' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
+    -event.wheelDelta : 0;
+  },
+
+  deltaZ: 0,
+  // Browsers without "deltaMode" is reporting in raw wheel delta where one
+  // notch on the scroll is always +/- 120, roughly equivalent to pixels.
+  // A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or
+  // ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.
+  deltaMode: 0
+});
+
+const SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface);
+
+/**
+ * This plugin invokes action functions on forms, inputs and buttons if
+ * the form doesn't prevent default.
+ */
+
+function extractEvents$6(dispatchQueue, domEventName, maybeTargetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  if (domEventName !== 'submit') {
+    return;
+  }
+
+  if (!maybeTargetInst || maybeTargetInst.stateNode !== nativeEventTarget) {
+    // If we're inside a parent root that itself is a parent of this root, then
+    // its deepest target won't be the actual form that's being submitted.
+    return;
+  }
+
+  const formInst = maybeTargetInst;
+  const form = nativeEventTarget;
+  let action = getFiberCurrentPropsFromNode(form).action;
+  let submitter = nativeEvent.submitter;
+  let submitterAction;
+
+  if (submitter) {
+    const submitterProps = getFiberCurrentPropsFromNode(submitter);
+    submitterAction = submitterProps ? submitterProps.formAction : submitter.getAttribute('formAction');
+
+    if (submitterAction != null) {
+      // The submitter overrides the form action.
+      action = submitterAction; // If the action is a function, we don't want to pass its name
+      // value to the FormData since it's controlled by the server.
+
+      submitter = null;
+    }
+  }
+
+  if (typeof action !== 'function') {
+    return;
+  }
+
+  const event = new SyntheticEvent('action', 'action', null, nativeEvent, nativeEventTarget);
+
+  function submitForm() {
+    if (nativeEvent.defaultPrevented) {
+      // We let earlier events to prevent the action from submitting.
+      return;
+    } // Prevent native navigation.
+
+
+    event.preventDefault();
+    let formData;
+
+    if (submitter) {
+      // The submitter's value should be included in the FormData.
+      // It should be in the document order in the form.
+      // Since the FormData constructor invokes the formdata event it also
+      // needs to be available before that happens so after construction it's too
+      // late. We use a temporary fake node for the duration of this event.
+      // TODO: FormData takes a second argument that it's the submitter but this
+      // is fairly new so not all browsers support it yet. Switch to that technique
+      // when available.
+      const temp = submitter.ownerDocument.createElement('input');
+      temp.name = submitter.name;
+      temp.value = submitter.value;
+      submitter.parentNode.insertBefore(temp, submitter);
+      formData = new FormData(form);
+      temp.parentNode.removeChild(temp);
+    } else {
+      formData = new FormData(form);
+    }
+
+    const pendingState = {
+      pending: true,
+      data: formData,
+      method: form.method,
+      action: action
+    };
+
+    startHostTransition(formInst, pendingState, action, formData);
+  }
+
+  dispatchQueue.push({
+    event,
+    listeners: [{
+      instance: null,
+      listener: submitForm,
+      currentTarget: form
+    }]
+  });
+}
+function dispatchReplayedFormAction(formInst, form, action, formData) {
+  const pendingState = {
+    pending: true,
+    data: formData,
+    method: form.method,
+    action: action
+  };
+
+  startHostTransition(formInst, pendingState, action, formData);
+}
+
+// has this definition built-in.
+
+let hasScheduledReplayAttempt = false; // The last of each continuous event type. We only need to replay the last one
+// if the last target was dehydrated.
+
+let queuedFocus = null;
+let queuedDrag = null;
+let queuedMouse = null; // For pointer events there can be one latest event per pointerId.
+
+const queuedPointers = new Map();
+const queuedPointerCaptures = new Map(); // We could consider replaying selectionchange and touchmoves too.
+
+const queuedExplicitHydrationTargets = [];
+const discreteReplayableEvents = ['mousedown', 'mouseup', 'touchcancel', 'touchend', 'touchstart', 'auxclick', 'dblclick', 'pointercancel', 'pointerdown', 'pointerup', 'dragend', 'dragstart', 'drop', 'compositionend', 'compositionstart', 'keydown', 'keypress', 'keyup', 'input', 'textInput', // Intentionally camelCase
+'copy', 'cut', 'paste', 'click', 'change', 'contextmenu', 'reset' // 'submit', // stopPropagation blocks the replay mechanism
+];
+function isDiscreteEventThatRequiresHydration(eventType) {
+  return discreteReplayableEvents.indexOf(eventType) > -1;
+}
+
+function createQueuedReplayableEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+  return {
+    blockedOn,
+    domEventName,
+    eventSystemFlags,
+    nativeEvent,
+    targetContainers: [targetContainer]
+  };
+} // Resets the replaying for this type of continuous event to no event.
+
+
+function clearIfContinuousEvent(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case 'focusin':
+    case 'focusout':
+      queuedFocus = null;
+      break;
+
+    case 'dragenter':
+    case 'dragleave':
+      queuedDrag = null;
+      break;
+
+    case 'mouseover':
+    case 'mouseout':
+      queuedMouse = null;
+      break;
+
+    case 'pointerover':
+    case 'pointerout':
+      {
+        const pointerId = nativeEvent.pointerId;
+        queuedPointers.delete(pointerId);
+        break;
+      }
+
+    case 'gotpointercapture':
+    case 'lostpointercapture':
+      {
+        const pointerId = nativeEvent.pointerId;
+        queuedPointerCaptures.delete(pointerId);
+        break;
+      }
+  }
+}
+
+function accumulateOrCreateContinuousQueuedReplayableEvent(existingQueuedEvent, blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+  if (existingQueuedEvent === null || existingQueuedEvent.nativeEvent !== nativeEvent) {
+    const queuedEvent = createQueuedReplayableEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent);
+
+    if (blockedOn !== null) {
+      const fiber = getInstanceFromNode(blockedOn);
+
+      if (fiber !== null) {
+        // Attempt to increase the priority of this target.
+        attemptContinuousHydration(fiber);
+      }
+    }
+
+    return queuedEvent;
+  } // If we have already queued this exact event, then it's because
+  // the different event systems have different DOM event listeners.
+  // We can accumulate the flags, and the targetContainers, and
+  // store a single event to be replayed.
+
+
+  existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
+  const targetContainers = existingQueuedEvent.targetContainers;
+
+  if (targetContainer !== null && targetContainers.indexOf(targetContainer) === -1) {
+    targetContainers.push(targetContainer);
+  }
+
+  return existingQueuedEvent;
+}
+
+function queueIfContinuousEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+  // These set relatedTarget to null because the replayed event will be treated as if we
+  // moved from outside the window (no target) onto the target once it hydrates.
+  // Instead of mutating we could clone the event.
+  switch (domEventName) {
+    case 'focusin':
+      {
+        const focusEvent = nativeEvent;
+        queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(queuedFocus, blockedOn, domEventName, eventSystemFlags, targetContainer, focusEvent);
+        return true;
+      }
+
+    case 'dragenter':
+      {
+        const dragEvent = nativeEvent;
+        queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(queuedDrag, blockedOn, domEventName, eventSystemFlags, targetContainer, dragEvent);
+        return true;
+      }
+
+    case 'mouseover':
+      {
+        const mouseEvent = nativeEvent;
+        queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(queuedMouse, blockedOn, domEventName, eventSystemFlags, targetContainer, mouseEvent);
+        return true;
+      }
+
+    case 'pointerover':
+      {
+        const pointerEvent = nativeEvent;
+        const pointerId = pointerEvent.pointerId;
+        queuedPointers.set(pointerId, accumulateOrCreateContinuousQueuedReplayableEvent(queuedPointers.get(pointerId) || null, blockedOn, domEventName, eventSystemFlags, targetContainer, pointerEvent));
+        return true;
+      }
+
+    case 'gotpointercapture':
+      {
+        const pointerEvent = nativeEvent;
+        const pointerId = pointerEvent.pointerId;
+        queuedPointerCaptures.set(pointerId, accumulateOrCreateContinuousQueuedReplayableEvent(queuedPointerCaptures.get(pointerId) || null, blockedOn, domEventName, eventSystemFlags, targetContainer, pointerEvent));
+        return true;
+      }
+  }
+
+  return false;
+} // Check if this target is unblocked. Returns true if it's unblocked.
+
+function attemptExplicitHydrationTarget(queuedTarget) {
+  // TODO: This function shares a lot of logic with findInstanceBlockingEvent.
+  // Try to unify them. It's a bit tricky since it would require two return
+  // values.
+  const targetInst = getClosestInstanceFromNode(queuedTarget.target);
+
+  if (targetInst !== null) {
+    const nearestMounted = getNearestMountedFiber(targetInst);
+
+    if (nearestMounted !== null) {
+      const tag = nearestMounted.tag;
+
+      if (tag === SuspenseComponent) {
+        const instance = getSuspenseInstanceFromFiber(nearestMounted);
+
+        if (instance !== null) {
+          // We're blocked on hydrating this boundary.
+          // Increase its priority.
+          queuedTarget.blockedOn = instance;
+          runWithPriority(queuedTarget.priority, () => {
+            attemptHydrationAtCurrentPriority(nearestMounted);
+          });
+          return;
+        }
+      } else if (tag === HostRoot) {
+        const root = nearestMounted.stateNode;
+
+        if (isRootDehydrated(root)) {
+          queuedTarget.blockedOn = getContainerFromFiber(nearestMounted); // We don't currently have a way to increase the priority of
+          // a root other than sync.
+
+          return;
+        }
+      }
+    }
+  }
+
+  queuedTarget.blockedOn = null;
+}
+
+function queueExplicitHydrationTarget(target) {
+  // TODO: This will read the priority if it's dispatched by the React
+  // event system but not native events. Should read window.event.type, like
+  // we do for updates (getCurrentEventPriority).
+  const updatePriority = getCurrentUpdatePriority();
+  const queuedTarget = {
+    blockedOn: null,
+    target: target,
+    priority: updatePriority
+  };
+  let i = 0;
+
+  for (; i < queuedExplicitHydrationTargets.length; i++) {
+    // Stop once we hit the first target with lower priority than
+    if (!isHigherEventPriority(updatePriority, queuedExplicitHydrationTargets[i].priority)) {
+      break;
+    }
+  }
+
+  queuedExplicitHydrationTargets.splice(i, 0, queuedTarget);
+
+  if (i === 0) {
+    attemptExplicitHydrationTarget(queuedTarget);
+  }
+}
+
+function attemptReplayContinuousQueuedEvent(queuedEvent) {
+  if (queuedEvent.blockedOn !== null) {
+    return false;
+  }
+
+  const targetContainers = queuedEvent.targetContainers;
+
+  while (targetContainers.length > 0) {
+    const nextBlockedOn = findInstanceBlockingEvent(queuedEvent.nativeEvent);
+
+    if (nextBlockedOn === null) {
+      const nativeEvent = queuedEvent.nativeEvent;
+      const nativeEventClone = new nativeEvent.constructor(nativeEvent.type, nativeEvent);
+      setReplayingEvent(nativeEventClone);
+      nativeEvent.target.dispatchEvent(nativeEventClone);
+      resetReplayingEvent();
+    } else {
+      // We're still blocked. Try again later.
+      const fiber = getInstanceFromNode(nextBlockedOn);
+
+      if (fiber !== null) {
+        attemptContinuousHydration(fiber);
+      }
+
+      queuedEvent.blockedOn = nextBlockedOn;
+      return false;
+    } // This target container was successfully dispatched. Try the next.
+
+
+    targetContainers.shift();
+  }
+
+  return true;
+}
+
+function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
+  if (attemptReplayContinuousQueuedEvent(queuedEvent)) {
+    map.delete(key);
+  }
+}
+
+function replayUnblockedEvents() {
+  hasScheduledReplayAttempt = false; // Replay any continuous events.
+
+  if (queuedFocus !== null && attemptReplayContinuousQueuedEvent(queuedFocus)) {
+    queuedFocus = null;
+  }
+
+  if (queuedDrag !== null && attemptReplayContinuousQueuedEvent(queuedDrag)) {
+    queuedDrag = null;
+  }
+
+  if (queuedMouse !== null && attemptReplayContinuousQueuedEvent(queuedMouse)) {
+    queuedMouse = null;
+  }
+
+  queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
+  queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
+}
+
+function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
+  if (queuedEvent.blockedOn === unblocked) {
+    queuedEvent.blockedOn = null;
+
+    if (!hasScheduledReplayAttempt) {
+      hasScheduledReplayAttempt = true; // Schedule a callback to attempt replaying as many events as are
+      // now unblocked. This first might not actually be unblocked yet.
+      // We could check it early to avoid scheduling an unnecessary callback.
+
+      Scheduler.unstable_scheduleCallback(Scheduler.unstable_NormalPriority, replayUnblockedEvents);
+    }
+  }
+} // [form, submitter or action, formData...]
+
+
+let lastScheduledReplayQueue = null;
+
+function replayUnblockedFormActions(formReplayingQueue) {
+  if (lastScheduledReplayQueue === formReplayingQueue) {
+    lastScheduledReplayQueue = null;
+  }
+
+  for (let i = 0; i < formReplayingQueue.length; i += 3) {
+    const form = formReplayingQueue[i];
+    const submitterOrAction = formReplayingQueue[i + 1];
+    const formData = formReplayingQueue[i + 2];
+
+    if (typeof submitterOrAction !== 'function') {
+      // This action is not hydrated yet. This might be because it's blocked on
+      // a different React instance or higher up our tree.
+      const blockedOn = findInstanceBlockingTarget(submitterOrAction || form);
+
+      if (blockedOn === null) {
+        // We're not blocked but we don't have an action. This must mean that
+        // this is in another React instance. We'll just skip past it.
+        continue;
+      } else {
+        // We're blocked on something in this React instance. We'll retry later.
+        break;
+      }
+    }
+
+    const formInst = getInstanceFromNode(form);
+
+    if (formInst !== null) {
+      // This is part of our instance.
+      // We're ready to replay this. Let's delete it from the queue.
+      formReplayingQueue.splice(i, 3);
+      i -= 3;
+      dispatchReplayedFormAction(formInst, form, submitterOrAction, formData); // Continue without incrementing the index.
+
+      continue;
+    } // This form must've been part of a different React instance.
+    // If we want to preserve ordering between React instances on the same root
+    // we'd need some way for the other instance to ping us when it's done.
+    // We'll just skip this and let the other instance execute it.
+
+  }
+}
+
+function scheduleReplayQueueIfNeeded(formReplayingQueue) {
+  // Schedule a callback to execute any unblocked form actions in.
+  // We only keep track of the last queue which means that if multiple React oscillate
+  // commits, we could schedule more callbacks than necessary but it's not a big deal
+  // and we only really except one instance.
+  if (lastScheduledReplayQueue !== formReplayingQueue) {
+    lastScheduledReplayQueue = formReplayingQueue;
+    Scheduler.unstable_scheduleCallback(Scheduler.unstable_NormalPriority, () => replayUnblockedFormActions(formReplayingQueue));
+  }
+}
+
+function retryIfBlockedOn(unblocked) {
+  if (queuedFocus !== null) {
+    scheduleCallbackIfUnblocked(queuedFocus, unblocked);
+  }
+
+  if (queuedDrag !== null) {
+    scheduleCallbackIfUnblocked(queuedDrag, unblocked);
+  }
+
+  if (queuedMouse !== null) {
+    scheduleCallbackIfUnblocked(queuedMouse, unblocked);
+  }
+
+  const unblock = queuedEvent => scheduleCallbackIfUnblocked(queuedEvent, unblocked);
+
+  queuedPointers.forEach(unblock);
+  queuedPointerCaptures.forEach(unblock);
+
+  for (let i = 0; i < queuedExplicitHydrationTargets.length; i++) {
+    const queuedTarget = queuedExplicitHydrationTargets[i];
+
+    if (queuedTarget.blockedOn === unblocked) {
+      queuedTarget.blockedOn = null;
+    }
+  }
+
+  while (queuedExplicitHydrationTargets.length > 0) {
+    const nextExplicitTarget = queuedExplicitHydrationTargets[0];
+
+    if (nextExplicitTarget.blockedOn !== null) {
+      // We're still blocked.
+      break;
+    } else {
+      attemptExplicitHydrationTarget(nextExplicitTarget);
+
+      if (nextExplicitTarget.blockedOn === null) {
+        // We're unblocked.
+        queuedExplicitHydrationTargets.shift();
+      }
+    }
+  }
+
+  {
+    // Check the document if there are any queued form actions.
+    const root = unblocked.getRootNode();
+    const formReplayingQueue = root.$$reactFormReplay;
+
+    if (formReplayingQueue != null) {
+      for (let i = 0; i < formReplayingQueue.length; i += 3) {
+        const form = formReplayingQueue[i];
+        const submitterOrAction = formReplayingQueue[i + 1];
+        const formProps = getFiberCurrentPropsFromNode(form);
+
+        if (typeof submitterOrAction === 'function') {
+          // This action has already resolved. We're just waiting to dispatch it.
+          if (!formProps) {
+            // This was not part of this React instance. It might have been recently
+            // unblocking us from dispatching our events. So let's make sure we schedule
+            // a retry.
+            scheduleReplayQueueIfNeeded(formReplayingQueue);
+          }
+
+          continue;
+        }
+
+        let target = form;
+
+        if (formProps) {
+          // This form belongs to this React instance but the submitter might
+          // not be done yet.
+          let action = null;
+          const submitter = submitterOrAction;
+
+          if (submitter && submitter.hasAttribute('formAction')) {
+            // The submitter is the one that is responsible for the action.
+            target = submitter;
+            const submitterProps = getFiberCurrentPropsFromNode(submitter);
+
+            if (submitterProps) {
+              // The submitter is part of this instance.
+              action = submitterProps.formAction;
+            } else {
+              const blockedOn = findInstanceBlockingTarget(target);
+
+              if (blockedOn !== null) {
+                // The submitter is not hydrated yet. We'll wait for it.
+                continue;
+              } // The submitter must have been a part of a different React instance.
+              // Except the form isn't. We don't dispatch actions in this scenario.
+
+            }
+          } else {
+            action = formProps.action;
+          }
+
+          if (typeof action === 'function') {
+            formReplayingQueue[i + 1] = action;
+          } else {
+            // Something went wrong so let's just delete this action.
+            formReplayingQueue.splice(i, 3);
+            i -= 3;
+          } // Schedule a replay in case this unblocked something.
+
+
+          scheduleReplayQueueIfNeeded(formReplayingQueue);
+          continue;
+        } // Something above this target is still blocked so we can't continue yet.
+        // We're not sure if this target is actually part of this React instance
+        // yet. It could be a different React as a child but at least some parent is.
+        // We must continue for any further queued actions.
+
+      }
+    }
+  }
+}
+
+const ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig; // TODO: can we stop exporting these?
+
+let _enabled = true; // This is exported in FB builds for use by legacy FB layer infra.
+// We'd like to remove this but it's not clear if this is safe.
+
+function setEnabled(enabled) {
+  _enabled = !!enabled;
+}
+function isEnabled() {
+  return _enabled;
+}
+function createEventListenerWrapperWithPriority(targetContainer, domEventName, eventSystemFlags) {
+  const eventPriority = getEventPriority(domEventName);
+  let listenerWrapper;
+
+  switch (eventPriority) {
+    case DiscreteEventPriority:
+      listenerWrapper = dispatchDiscreteEvent;
+      break;
+
+    case ContinuousEventPriority:
+      listenerWrapper = dispatchContinuousEvent;
+      break;
+
+    case DefaultEventPriority:
+    default:
+      listenerWrapper = dispatchEvent;
+      break;
+  }
+
+  return listenerWrapper.bind(null, domEventName, eventSystemFlags, targetContainer);
+}
+
+function dispatchDiscreteEvent(domEventName, eventSystemFlags, container, nativeEvent) {
+  const previousPriority = getCurrentUpdatePriority();
+  const prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
+
+  try {
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig.transition = prevTransition;
+  }
+}
+
+function dispatchContinuousEvent(domEventName, eventSystemFlags, container, nativeEvent) {
+  const previousPriority = getCurrentUpdatePriority();
+  const prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
+
+  try {
+    setCurrentUpdatePriority(ContinuousEventPriority);
+    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig.transition = prevTransition;
+  }
+}
+
+function dispatchEvent(domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+  if (!_enabled) {
+    return;
+  }
+
+  let blockedOn = findInstanceBlockingEvent(nativeEvent);
+
+  if (blockedOn === null) {
+    dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, return_targetInst, targetContainer);
+    clearIfContinuousEvent(domEventName, nativeEvent);
+    return;
+  }
+
+  if (queueIfContinuousEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent)) {
+    nativeEvent.stopPropagation();
+    return;
+  } // We need to clear only if we didn't queue because
+  // queueing is accumulative.
+
+
+  clearIfContinuousEvent(domEventName, nativeEvent);
+
+  if (eventSystemFlags & IS_CAPTURE_PHASE && isDiscreteEventThatRequiresHydration(domEventName)) {
+    while (blockedOn !== null) {
+      const fiber = getInstanceFromNode(blockedOn);
+
+      if (fiber !== null) {
+        attemptSynchronousHydration(fiber);
+      }
+
+      const nextBlockedOn = findInstanceBlockingEvent(nativeEvent);
+
+      if (nextBlockedOn === null) {
+        dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, return_targetInst, targetContainer);
+      }
+
+      if (nextBlockedOn === blockedOn) {
+        break;
+      }
+
+      blockedOn = nextBlockedOn;
+    }
+
+    if (blockedOn !== null) {
+      nativeEvent.stopPropagation();
+    }
+
+    return;
+  } // 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 findInstanceBlockingEvent(nativeEvent) {
+  const nativeEventTarget = getEventTarget(nativeEvent);
+  return findInstanceBlockingTarget(nativeEventTarget);
+}
+let return_targetInst = null; // Returns a SuspenseInstance or Container if it's blocked.
+// The return_targetInst field above is conceptually part of the return value.
+
+function findInstanceBlockingTarget(targetNode) {
+  // TODO: Warn if _enabled is false.
+  return_targetInst = null;
+  let targetInst = getClosestInstanceFromNode(targetNode);
+
+  if (targetInst !== null) {
+    const nearestMounted = getNearestMountedFiber(targetInst);
+
+    if (nearestMounted === null) {
+      // This tree has been unmounted already. Dispatch without a target.
+      targetInst = null;
+    } else {
+      const tag = nearestMounted.tag;
+
+      if (tag === SuspenseComponent) {
+        const instance = getSuspenseInstanceFromFiber(nearestMounted);
+
+        if (instance !== null) {
+          // Queue the event to be replayed later. Abort dispatching since we
+          // don't want this event dispatched twice through the event system.
+          // TODO: If this is the first discrete event in the queue. Schedule an increased
+          // priority for this boundary.
+          return instance;
+        } // This shouldn't happen, something went wrong but to avoid blocking
+        // the whole system, dispatch the event without a target.
+        // TODO: Warn.
+
+
+        targetInst = null;
+      } else if (tag === HostRoot) {
+        const root = nearestMounted.stateNode;
+
+        if (isRootDehydrated(root)) {
+          // If this happens during a replay something went wrong and it might block
+          // the whole system.
+          return getContainerFromFiber(nearestMounted);
+        }
+
+        targetInst = null;
+      } else if (nearestMounted !== targetInst) {
+        // If we get an event (ex: img onload) before committing that
+        // component's mount, ignore it for now (that is, treat it as if it was an
+        // event on a non-React tree). We might also consider queueing events and
+        // dispatching them after the mount.
+        targetInst = null;
+      }
+    }
+  }
+
+  return_targetInst = targetInst; // We're not blocked on anything.
+
+  return null;
+}
+function getEventPriority(domEventName) {
+  switch (domEventName) {
+    // Used by SimpleEventPlugin:
+    case 'cancel':
+    case 'click':
+    case 'close':
+    case 'contextmenu':
+    case 'copy':
+    case 'cut':
+    case 'auxclick':
+    case 'dblclick':
+    case 'dragend':
+    case 'dragstart':
+    case 'drop':
+    case 'focusin':
+    case 'focusout':
+    case 'input':
+    case 'invalid':
+    case 'keydown':
+    case 'keypress':
+    case 'keyup':
+    case 'mousedown':
+    case 'mouseup':
+    case 'paste':
+    case 'pause':
+    case 'play':
+    case 'pointercancel':
+    case 'pointerdown':
+    case 'pointerup':
+    case 'ratechange':
+    case 'reset':
+    case 'resize':
+    case 'seeked':
+    case 'submit':
+    case 'touchcancel':
+    case 'touchend':
+    case 'touchstart':
+    case 'volumechange': // Used by polyfills: (fall through)
+
+    case 'change':
+    case 'selectionchange':
+    case 'textInput':
+    case 'compositionstart':
+    case 'compositionend':
+    case 'compositionupdate': // Only enableCreateEventHandleAPI: (fall through)
+
+    case 'beforeblur':
+    case 'afterblur': // Not used by React but could be by user code: (fall through)
+
+    case 'beforeinput':
+    case 'blur':
+    case 'fullscreenchange':
+    case 'focus':
+    case 'hashchange':
+    case 'popstate':
+    case 'select':
+    case 'selectstart':
+      return DiscreteEventPriority;
+
+    case 'drag':
+    case 'dragenter':
+    case 'dragexit':
+    case 'dragleave':
+    case 'dragover':
+    case 'mousemove':
+    case 'mouseout':
+    case 'mouseover':
+    case 'pointermove':
+    case 'pointerout':
+    case 'pointerover':
+    case 'scroll':
+    case 'toggle':
+    case 'touchmove':
+    case 'wheel': // Not used by React but could be by user code: (fall through)
+
+    case 'mouseenter':
+    case 'mouseleave':
+    case 'pointerenter':
+    case 'pointerleave':
+      return ContinuousEventPriority;
+
+    case 'message':
+      {
+        // We might be in the Scheduler callback.
+        // Eventually this mechanism will be replaced by a check
+        // of the current priority on the native scheduler.
+        const schedulerPriority = getCurrentPriorityLevel();
+
+        switch (schedulerPriority) {
+          case ImmediatePriority:
+            return DiscreteEventPriority;
+
+          case UserBlockingPriority:
+            return ContinuousEventPriority;
+
+          case NormalPriority$1:
+          case LowPriority:
+            // TODO: Handle LowSchedulerPriority, somehow. Maybe the same lane as hydration.
+            return DefaultEventPriority;
+
+          case IdlePriority:
+            return IdleEventPriority;
+
+          default:
+            return DefaultEventPriority;
+        }
+      }
+
+    default:
+      return DefaultEventPriority;
+  }
+}
+
+function addEventBubbleListener(target, eventType, listener) {
+  target.addEventListener(eventType, listener, false);
+  return listener;
+}
+function addEventCaptureListener(target, eventType, listener) {
+  target.addEventListener(eventType, listener, true);
+  return listener;
+}
+function addEventCaptureListenerWithPassiveFlag(target, eventType, listener, passive) {
+  target.addEventListener(eventType, listener, {
+    capture: true,
+    passive
+  });
+  return listener;
+}
+function addEventBubbleListenerWithPassiveFlag(target, eventType, listener, passive) {
+  target.addEventListener(eventType, listener, {
+    passive
+  });
+  return listener;
+}
+
+/**
+ * These variables store information about text content of a target node,
+ * allowing comparison of content before and after a given event.
+ *
+ * Identify the node where selection currently begins, then observe
+ * both its text content and its current position in the DOM. Since the
+ * browser may natively replace the target node during composition, we can
+ * use its position to find its replacement.
+ *
+ *
+ */
+let root = null;
+let startText = null;
+let fallbackText = null;
+function initialize(nativeEventTarget) {
+  root = nativeEventTarget;
+  startText = getText();
+  return true;
+}
+function reset() {
+  root = null;
+  startText = null;
+  fallbackText = null;
+}
+function getData() {
+  if (fallbackText) {
+    return fallbackText;
+  }
+
+  let start;
+  const startValue = startText;
+  const startLength = startValue.length;
+  let end;
+  const endValue = getText();
+  const endLength = endValue.length;
+
+  for (start = 0; start < startLength; start++) {
+    if (startValue[start] !== endValue[start]) {
+      break;
+    }
+  }
+
+  const minEnd = startLength - start;
+
+  for (end = 1; end <= minEnd; end++) {
+    if (startValue[startLength - end] !== endValue[endLength - end]) {
+      break;
+    }
+  }
+
+  const sliceTail = end > 1 ? 1 - end : undefined;
+  fallbackText = endValue.slice(start, sliceTail);
+  return fallbackText;
+}
+function getText() {
+  if ('value' in root) {
+    return root.value;
+  }
+
+  return root.textContent;
+}
+
+const END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space
+
+const START_KEYCODE = 229;
+const canUseCompositionEvent = canUseDOM && 'CompositionEvent' in window;
+let documentMode = null;
+
+if (canUseDOM && 'documentMode' in document) {
+  documentMode = document.documentMode;
+} // Webkit offers a very useful `textInput` event that can be used to
+// directly represent `beforeInput`. The IE `textinput` event is not as
+// useful, so we don't use it.
+
+
+const canUseTextInputEvent = canUseDOM && 'TextEvent' in window && !documentMode; // In IE9+, we have access to composition events, but the data supplied
+// by the native compositionend event may be incorrect. Japanese ideographic
+// spaces, for instance (\u3000) are not recorded correctly.
+
+const useFallbackCompositionData = canUseDOM && (!canUseCompositionEvent || documentMode && documentMode > 8 && documentMode <= 11);
+const SPACEBAR_CODE = 32;
+const SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);
+
+function registerEvents$3() {
+  registerTwoPhaseEvent('onBeforeInput', ['compositionend', 'keypress', 'textInput', 'paste']);
+  registerTwoPhaseEvent('onCompositionEnd', ['compositionend', 'focusout', 'keydown', 'keypress', 'keyup', 'mousedown']);
+  registerTwoPhaseEvent('onCompositionStart', ['compositionstart', 'focusout', 'keydown', 'keypress', 'keyup', 'mousedown']);
+  registerTwoPhaseEvent('onCompositionUpdate', ['compositionupdate', 'focusout', 'keydown', 'keypress', 'keyup', 'mousedown']);
+} // Track whether we've ever handled a keypress on the space key.
+
+
+let hasSpaceKeypress = false;
+/**
+ * Return whether a native keypress event is assumed to be a command.
+ * This is required because Firefox fires `keypress` events for key commands
+ * (cut, copy, select-all, etc.) even though no character is inserted.
+ */
+
+function isKeypressCommand(nativeEvent) {
+  return (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) && // ctrlKey && altKey is equivalent to AltGr, and is not a command.
+  !(nativeEvent.ctrlKey && nativeEvent.altKey);
+}
+/**
+ * Translate native top level events into event types.
+ */
+
+
+function getCompositionEventType(domEventName) {
+  switch (domEventName) {
+    case 'compositionstart':
+      return 'onCompositionStart';
+
+    case 'compositionend':
+      return 'onCompositionEnd';
+
+    case 'compositionupdate':
+      return 'onCompositionUpdate';
+  }
+}
+/**
+ * Does our fallback best-guess model think this event signifies that
+ * composition has begun?
+ */
+
+
+function isFallbackCompositionStart(domEventName, nativeEvent) {
+  return domEventName === 'keydown' && nativeEvent.keyCode === START_KEYCODE;
+}
+/**
+ * Does our fallback mode think that this event is the end of composition?
+ */
+
+
+function isFallbackCompositionEnd(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case 'keyup':
+      // Command keys insert or clear IME input.
+      return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1;
+
+    case 'keydown':
+      // Expect IME keyCode on each keydown. If we get any other
+      // code we must have exited earlier.
+      return nativeEvent.keyCode !== START_KEYCODE;
+
+    case 'keypress':
+    case 'mousedown':
+    case 'focusout':
+      // Events are not possible without cancelling IME.
+      return true;
+
+    default:
+      return false;
+  }
+}
+/**
+ * Google Input Tools provides composition data via a CustomEvent,
+ * with the `data` property populated in the `detail` object. If this
+ * is available on the event object, use it. If not, this is a plain
+ * composition event and we have nothing special to extract.
+ *
+ * @param {object} nativeEvent
+ * @return {?string}
+ */
+
+
+function getDataFromCustomEvent(nativeEvent) {
+  const detail = nativeEvent.detail;
+
+  if (typeof detail === 'object' && 'data' in detail) {
+    return detail.data;
+  }
+
+  return null;
+}
+/**
+ * Check if a composition event was triggered by Korean IME.
+ * Our fallback mode does not work well with IE's Korean IME,
+ * so just use native composition events when Korean IME is used.
+ * Although CompositionEvent.locale property is deprecated,
+ * it is available in IE, where our fallback mode is enabled.
+ *
+ * @param {object} nativeEvent
+ * @return {boolean}
+ */
+
+
+function isUsingKoreanIME(nativeEvent) {
+  return nativeEvent.locale === 'ko';
+} // Track the current IME composition status, if any.
+
+
+let isComposing = false;
+/**
+ * @return {?object} A SyntheticCompositionEvent.
+ */
+
+function extractCompositionEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget) {
+  let eventType;
+  let fallbackData;
+
+  if (canUseCompositionEvent) {
+    eventType = getCompositionEventType(domEventName);
+  } else if (!isComposing) {
+    if (isFallbackCompositionStart(domEventName, nativeEvent)) {
+      eventType = 'onCompositionStart';
+    }
+  } else if (isFallbackCompositionEnd(domEventName, nativeEvent)) {
+    eventType = 'onCompositionEnd';
+  }
+
+  if (!eventType) {
+    return null;
+  }
+
+  if (useFallbackCompositionData && !isUsingKoreanIME(nativeEvent)) {
+    // The current composition is stored statically and must not be
+    // overwritten while composition continues.
+    if (!isComposing && eventType === 'onCompositionStart') {
+      isComposing = initialize(nativeEventTarget);
+    } else if (eventType === 'onCompositionEnd') {
+      if (isComposing) {
+        fallbackData = getData();
+      }
+    }
+  }
+
+  const listeners = accumulateTwoPhaseListeners(targetInst, eventType);
+
+  if (listeners.length > 0) {
+    const event = new SyntheticCompositionEvent(eventType, domEventName, null, nativeEvent, nativeEventTarget);
+    dispatchQueue.push({
+      event,
+      listeners
+    });
+
+    if (fallbackData) {
+      // Inject data generated from fallback path into the synthetic event.
+      // This matches the property of native CompositionEventInterface.
+      // $FlowFixMe[incompatible-use]
+      event.data = fallbackData;
+    } else {
+      const customData = getDataFromCustomEvent(nativeEvent);
+
+      if (customData !== null) {
+        // $FlowFixMe[incompatible-use]
+        event.data = customData;
+      }
+    }
+  }
+}
+
+function getNativeBeforeInputChars(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case 'compositionend':
+      return getDataFromCustomEvent(nativeEvent);
+
+    case 'keypress':
+      /**
+       * If native `textInput` events are available, our goal is to make
+       * use of them. However, there is a special case: the spacebar key.
+       * In Webkit, preventing default on a spacebar `textInput` event
+       * cancels character insertion, but it *also* causes the browser
+       * to fall back to its default spacebar behavior of scrolling the
+       * page.
+       *
+       * Tracking at:
+       * https://code.google.com/p/chromium/issues/detail?id=355103
+       *
+       * To avoid this issue, use the keypress event as if no `textInput`
+       * event is available.
+       */
+      const which = nativeEvent.which;
+
+      if (which !== SPACEBAR_CODE) {
+        return null;
+      }
+
+      hasSpaceKeypress = true;
+      return SPACEBAR_CHAR;
+
+    case 'textInput':
+      // Record the characters to be added to the DOM.
+      const chars = nativeEvent.data; // If it's a spacebar character, assume that we have already handled
+      // it at the keypress level and bail immediately. Android Chrome
+      // doesn't give us keycodes, so we need to ignore it.
+
+      if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {
+        return null;
+      }
+
+      return chars;
+
+    default:
+      // For other native event types, do nothing.
+      return null;
+  }
+}
+/**
+ * For browsers that do not provide the `textInput` event, extract the
+ * appropriate string to use for SyntheticInputEvent.
+ */
+
+
+function getFallbackBeforeInputChars(domEventName, nativeEvent) {
+  // If we are currently composing (IME) and using a fallback to do so,
+  // try to extract the composed characters from the fallback object.
+  // If composition event is available, we extract a string only at
+  // compositionevent, otherwise extract it at fallback events.
+  if (isComposing) {
+    if (domEventName === 'compositionend' || !canUseCompositionEvent && isFallbackCompositionEnd(domEventName, nativeEvent)) {
+      const chars = getData();
+      reset();
+      isComposing = false;
+      return chars;
+    }
+
+    return null;
+  }
+
+  switch (domEventName) {
+    case 'paste':
+      // If a paste event occurs after a keypress, throw out the input
+      // chars. Paste events should not lead to BeforeInput events.
+      return null;
+
+    case 'keypress':
+      /**
+       * As of v27, Firefox may fire keypress events even when no character
+       * will be inserted. A few possibilities:
+       *
+       * - `which` is `0`. Arrow keys, Esc key, etc.
+       *
+       * - `which` is the pressed key code, but no char is available.
+       *   Ex: 'AltGr + d` in Polish. There is no modified character for
+       *   this key combination and no character is inserted into the
+       *   document, but FF fires the keypress for char code `100` anyway.
+       *   No `input` event will occur.
+       *
+       * - `which` is the pressed key code, but a command combination is
+       *   being used. Ex: `Cmd+C`. No character is inserted, and no
+       *   `input` event will occur.
+       */
+      if (!isKeypressCommand(nativeEvent)) {
+        // IE fires the `keypress` event when a user types an emoji via
+        // Touch keyboard of Windows.  In such a case, the `char` property
+        // holds an emoji character like `\uD83D\uDE0A`.  Because its length
+        // is 2, the property `which` does not represent an emoji correctly.
+        // In such a case, we directly return the `char` property instead of
+        // using `which`.
+        if (nativeEvent.char && nativeEvent.char.length > 1) {
+          return nativeEvent.char;
+        } else if (nativeEvent.which) {
+          return String.fromCharCode(nativeEvent.which);
+        }
+      }
+
+      return null;
+
+    case 'compositionend':
+      return useFallbackCompositionData && !isUsingKoreanIME(nativeEvent) ? null : nativeEvent.data;
+
+    default:
+      return null;
+  }
+}
+/**
+ * Extract a SyntheticInputEvent for `beforeInput`, based on either native
+ * `textInput` or fallback behavior.
+ *
+ * @return {?object} A SyntheticInputEvent.
+ */
+
+
+function extractBeforeInputEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget) {
+  let chars;
+
+  if (canUseTextInputEvent) {
+    chars = getNativeBeforeInputChars(domEventName, nativeEvent);
+  } else {
+    chars = getFallbackBeforeInputChars(domEventName, nativeEvent);
+  } // If no characters are being inserted, no BeforeInput event should
+  // be fired.
+
+
+  if (!chars) {
+    return null;
+  }
+
+  const listeners = accumulateTwoPhaseListeners(targetInst, 'onBeforeInput');
+
+  if (listeners.length > 0) {
+    const event = new SyntheticInputEvent('onBeforeInput', 'beforeinput', null, nativeEvent, nativeEventTarget);
+    dispatchQueue.push({
+      event,
+      listeners
+    }); // $FlowFixMe[incompatible-use]
+
+    event.data = chars;
+  }
+}
+/**
+ * Create an `onBeforeInput` event to match
+ * http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.
+ *
+ * This event plugin is based on the native `textInput` event
+ * available in Chrome, Safari, Opera, and IE. This event fires after
+ * `onKeyPress` and `onCompositionEnd`, but before `onInput`.
+ *
+ * `beforeInput` is spec'd but not implemented in any browsers, and
+ * the `input` event does not provide any useful information about what has
+ * actually been added, contrary to the spec. Thus, `textInput` is the best
+ * available event to identify the characters that have actually been inserted
+ * into the target node.
+ *
+ * This plugin is also responsible for emitting `composition` events, thus
+ * allowing us to share composition fallback code for both `beforeInput` and
+ * `composition` event types.
+ */
+
+
+function extractEvents$5(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  extractCompositionEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+  extractBeforeInputEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+}
+
+/**
+ * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary
+ */
+const supportedInputTypes = {
+  color: true,
+  date: true,
+  datetime: true,
+  'datetime-local': true,
+  email: true,
+  month: true,
+  number: true,
+  password: true,
+  range: true,
+  search: true,
+  tel: true,
+  text: true,
+  time: true,
+  url: true,
+  week: true
+};
+
+function isTextInputElement(elem) {
+  const nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+
+  if (nodeName === 'input') {
+    return !!supportedInputTypes[elem.type];
+  }
+
+  if (nodeName === 'textarea') {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Checks if an event is supported in the current execution environment.
+ *
+ * NOTE: This will not work correctly for non-generic events such as `change`,
+ * `reset`, `load`, `error`, and `select`.
+ *
+ * Borrows from Modernizr.
+ *
+ * @param {string} eventNameSuffix Event name, e.g. "click".
+ * @return {boolean} True if the event is supported.
+ * @internal
+ * @license Modernizr 3.0.0pre (Custom Build) | MIT
+ */
+
+function isEventSupported(eventNameSuffix) {
+  if (!canUseDOM) {
+    return false;
+  }
+
+  const eventName = 'on' + eventNameSuffix;
+  let isSupported = (eventName in document);
+
+  if (!isSupported) {
+    const element = document.createElement('div');
+    element.setAttribute(eventName, 'return;');
+    isSupported = typeof element[eventName] === 'function';
+  }
+
+  return isSupported;
+}
+
+function registerEvents$2() {
+  registerTwoPhaseEvent('onChange', ['change', 'click', 'focusin', 'focusout', 'input', 'keydown', 'keyup', 'selectionchange']);
+}
+
+function createAndAccumulateChangeEvent(dispatchQueue, inst, nativeEvent, target) {
+  // Flag this event loop as needing state restore.
+  enqueueStateRestore(target);
+  const listeners = accumulateTwoPhaseListeners(inst, 'onChange');
+
+  if (listeners.length > 0) {
+    const event = new SyntheticEvent('onChange', 'change', null, nativeEvent, target);
+    dispatchQueue.push({
+      event,
+      listeners
+    });
+  }
+}
+/**
+ * For IE shims
+ */
+
+
+let activeElement$1 = null;
+let activeElementInst$1 = null;
+/**
+ * SECTION: handle `change` event
+ */
+
+function shouldUseChangeEvent(elem) {
+  const nodeName = elem.nodeName && elem.nodeName.toLowerCase();
+  return nodeName === 'select' || nodeName === 'input' && elem.type === 'file';
+}
+
+function manualDispatchChangeEvent(nativeEvent) {
+  const dispatchQueue = [];
+  createAndAccumulateChangeEvent(dispatchQueue, activeElementInst$1, nativeEvent, getEventTarget(nativeEvent)); // If change and propertychange bubbled, we'd just bind to it like all the
+  // other events and have it go through ReactBrowserEventEmitter. Since it
+  // doesn't, we manually listen for the events and so we have to enqueue and
+  // process the abstract event manually.
+  //
+  // Batching is necessary here in order to ensure that all event handlers run
+  // before the next rerender (including event handlers attached to ancestor
+  // elements instead of directly on the input). Without this, controlled
+  // components don't work properly in conjunction with event bubbling because
+  // the component is rerendered and the value reverted before all the event
+  // handlers can run. See https://github.com/facebook/react/issues/708.
+
+  batchedUpdates(runEventInBatch, dispatchQueue);
+}
+
+function runEventInBatch(dispatchQueue) {
+  processDispatchQueue(dispatchQueue, 0);
+}
+
+function getInstIfValueChanged(targetInst) {
+  const targetNode = getNodeFromInstance(targetInst);
+
+  if (updateValueIfChanged(targetNode)) {
+    return targetInst;
+  }
+}
+
+function getTargetInstForChangeEvent(domEventName, targetInst) {
+  if (domEventName === 'change') {
+    return targetInst;
+  }
+}
+/**
+ * SECTION: handle `input` event
+ */
+
+
+let isInputEventSupported = false;
+
+if (canUseDOM) {
+  // IE9 claims to support the input event but fails to trigger it when
+  // deleting text, so we ignore its input events.
+  isInputEventSupported = isEventSupported('input') && (!document.documentMode || document.documentMode > 9);
+}
+/**
+ * (For IE <=9) Starts tracking propertychange events on the passed-in element
+ * and override the value property so that we can distinguish user events from
+ * value changes in JS.
+ */
+
+
+function startWatchingForValueChange(target, targetInst) {
+  activeElement$1 = target;
+  activeElementInst$1 = targetInst;
+  activeElement$1.attachEvent('onpropertychange', handlePropertyChange);
+}
+/**
+ * (For IE <=9) Removes the event listeners from the currently-tracked element,
+ * if any exists.
+ */
+
+
+function stopWatchingForValueChange() {
+  if (!activeElement$1) {
+    return;
+  }
+
+  activeElement$1.detachEvent('onpropertychange', handlePropertyChange);
+  activeElement$1 = null;
+  activeElementInst$1 = null;
+}
+/**
+ * (For IE <=9) Handles a propertychange event, sending a `change` event if
+ * the value of the active element has changed.
+ */
+// $FlowFixMe[missing-local-annot]
+
+
+function handlePropertyChange(nativeEvent) {
+  if (nativeEvent.propertyName !== 'value') {
+    return;
+  }
+
+  if (getInstIfValueChanged(activeElementInst$1)) {
+    manualDispatchChangeEvent(nativeEvent);
+  }
+}
+
+function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
+  if (domEventName === 'focusin') {
+    // In IE9, propertychange fires for most input events but is buggy and
+    // doesn't fire when text is deleted, but conveniently, selectionchange
+    // appears to fire in all of the remaining cases so we catch those and
+    // forward the event if the value has changed
+    // In either case, we don't want to call the event handler if the value
+    // is changed from JS so we redefine a setter for `.value` that updates
+    // our activeElementValue variable, allowing us to ignore those changes
+    //
+    // stopWatching() should be a noop here but we call it just in case we
+    // missed a blur event somehow.
+    stopWatchingForValueChange();
+    startWatchingForValueChange(target, targetInst);
+  } else if (domEventName === 'focusout') {
+    stopWatchingForValueChange();
+  }
+} // For IE8 and IE9.
+
+
+function getTargetInstForInputEventPolyfill(domEventName, targetInst) {
+  if (domEventName === 'selectionchange' || domEventName === 'keyup' || domEventName === 'keydown') {
+    // On the selectionchange event, the target is just document which isn't
+    // helpful for us so just check activeElement instead.
+    //
+    // 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire
+    // propertychange on the first input event after setting `value` from a
+    // script and fires only keydown, keypress, keyup. Catching keyup usually
+    // gets it and catching keydown lets us fire an event for the first
+    // keystroke if user does a key repeat (it'll be a little delayed: right
+    // before the second keystroke). Other input methods (e.g., paste) seem to
+    // fire selectionchange normally.
+    return getInstIfValueChanged(activeElementInst$1);
+  }
+}
+/**
+ * SECTION: handle `click` event
+ */
+
+
+function shouldUseClickEvent(elem) {
+  // Use the `click` event to detect changes to checkbox and radio inputs.
+  // This approach works across all browsers, whereas `change` does not fire
+  // until `blur` in IE8.
+  const nodeName = elem.nodeName;
+  return nodeName && nodeName.toLowerCase() === 'input' && (elem.type === 'checkbox' || elem.type === 'radio');
+}
+
+function getTargetInstForClickEvent(domEventName, targetInst) {
+  if (domEventName === 'click') {
+    return getInstIfValueChanged(targetInst);
+  }
+}
+
+function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
+  if (domEventName === 'input' || domEventName === 'change') {
+    return getInstIfValueChanged(targetInst);
+  }
+}
+
+function handleControlledInputBlur(node, props) {
+  if (node.type !== 'number') {
+    return;
+  }
+
+  {
+    const isControlled = props.value != null;
+
+    if (isControlled) {
+      // If controlled, assign the value attribute to the current value on blur
+      setDefaultValue(node, 'number', node.value);
+    }
+  }
+}
+/**
+ * This plugin creates an `onChange` event that normalizes change events
+ * across form elements. This event fires at a time when it's possible to
+ * change the element's value without seeing a flicker.
+ *
+ * Supported elements are:
+ * - input (see `isTextInputElement`)
+ * - textarea
+ * - select
+ */
+
+
+function extractEvents$4(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  const targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
+  let getTargetInstFunc, handleEventFunc;
+
+  if (shouldUseChangeEvent(targetNode)) {
+    getTargetInstFunc = getTargetInstForChangeEvent;
+  } else if (isTextInputElement(targetNode)) {
+    if (isInputEventSupported) {
+      getTargetInstFunc = getTargetInstForInputOrChangeEvent;
+    } else {
+      getTargetInstFunc = getTargetInstForInputEventPolyfill;
+      handleEventFunc = handleEventsForInputEventPolyfill;
+    }
+  } else if (shouldUseClickEvent(targetNode)) {
+    getTargetInstFunc = getTargetInstForClickEvent;
+  } else ;
+
+  if (getTargetInstFunc) {
+    const inst = getTargetInstFunc(domEventName, targetInst);
+
+    if (inst) {
+      createAndAccumulateChangeEvent(dispatchQueue, inst, nativeEvent, nativeEventTarget);
+      return;
+    }
+  }
+
+  if (handleEventFunc) {
+    handleEventFunc(domEventName, targetNode, targetInst);
+  } // When blurring, set the value attribute for number inputs
+
+
+  if (domEventName === 'focusout' && targetInst) {
+    // These props aren't necessarily the most current but we warn for changing
+    // between controlled and uncontrolled, so it doesn't matter and the previous
+    // code was also broken for changes.
+    const props = targetInst.memoizedProps;
+    handleControlledInputBlur(targetNode, props);
+  }
+}
+
+function registerEvents$1() {
+  registerDirectEvent('onMouseEnter', ['mouseout', 'mouseover']);
+  registerDirectEvent('onMouseLeave', ['mouseout', 'mouseover']);
+  registerDirectEvent('onPointerEnter', ['pointerout', 'pointerover']);
+  registerDirectEvent('onPointerLeave', ['pointerout', 'pointerover']);
+}
+/**
+ * For almost every interaction we care about, there will be both a top-level
+ * `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that
+ * we do not extract duplicate events. However, moving the mouse into the
+ * browser from outside will not fire a `mouseout` event. In this case, we use
+ * the `mouseover` top-level event.
+ */
+
+
+function extractEvents$3(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  const isOverEvent = domEventName === 'mouseover' || domEventName === 'pointerover';
+  const isOutEvent = domEventName === 'mouseout' || domEventName === 'pointerout';
+
+  if (isOverEvent && !isReplayingEvent(nativeEvent)) {
+    // If this is an over event with a target, we might have already dispatched
+    // the event in the out event of the other target. If this is replayed,
+    // then it's because we couldn't dispatch against this target previously
+    // so we have to do it now instead.
+    const related = nativeEvent.relatedTarget || nativeEvent.fromElement;
+
+    if (related) {
+      // If the related node is managed by React, we can assume that we have
+      // already dispatched the corresponding events during its mouseout.
+      if (getClosestInstanceFromNode(related) || isContainerMarkedAsRoot(related)) {
+        return;
+      }
+    }
+  }
+
+  if (!isOutEvent && !isOverEvent) {
+    // Must not be a mouse or pointer in or out - ignoring.
+    return;
+  }
+
+  let win; // TODO: why is this nullable in the types but we read from it?
+
+  if (nativeEventTarget.window === nativeEventTarget) {
+    // `nativeEventTarget` is probably a window object.
+    win = nativeEventTarget;
+  } else {
+    // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.
+    const doc = nativeEventTarget.ownerDocument;
+
+    if (doc) {
+      win = doc.defaultView || doc.parentWindow;
+    } else {
+      win = window;
+    }
+  }
+
+  let from;
+  let to;
+
+  if (isOutEvent) {
+    const related = nativeEvent.relatedTarget || nativeEvent.toElement;
+    from = targetInst;
+    to = related ? getClosestInstanceFromNode(related) : null;
+
+    if (to !== null) {
+      const nearestMounted = getNearestMountedFiber(to);
+      const tag = to.tag;
+
+      if (to !== nearestMounted || tag !== HostComponent && (tag !== HostSingleton) && tag !== HostText) {
+        to = null;
+      }
+    }
+  } else {
+    // Moving to a node from outside the window.
+    from = null;
+    to = targetInst;
+  }
+
+  if (from === to) {
+    // Nothing pertains to our managed components.
+    return;
+  }
+
+  let SyntheticEventCtor = SyntheticMouseEvent;
+  let leaveEventType = 'onMouseLeave';
+  let enterEventType = 'onMouseEnter';
+  let eventTypePrefix = 'mouse';
+
+  if (domEventName === 'pointerout' || domEventName === 'pointerover') {
+    SyntheticEventCtor = SyntheticPointerEvent;
+    leaveEventType = 'onPointerLeave';
+    enterEventType = 'onPointerEnter';
+    eventTypePrefix = 'pointer';
+  }
+
+  const fromNode = from == null ? win : getNodeFromInstance(from);
+  const toNode = to == null ? win : getNodeFromInstance(to);
+  const leave = new SyntheticEventCtor(leaveEventType, eventTypePrefix + 'leave', from, nativeEvent, nativeEventTarget);
+  leave.target = fromNode;
+  leave.relatedTarget = toNode;
+  let enter = null; // We should only process this nativeEvent if we are processing
+  // the first ancestor. Next time, we will ignore the event.
+
+  const nativeTargetInst = getClosestInstanceFromNode(nativeEventTarget);
+
+  if (nativeTargetInst === targetInst) {
+    const enterEvent = new SyntheticEventCtor(enterEventType, eventTypePrefix + 'enter', to, nativeEvent, nativeEventTarget);
+    enterEvent.target = toNode;
+    enterEvent.relatedTarget = fromNode;
+    enter = enterEvent;
+  }
+
+  accumulateEnterLeaveTwoPhaseListeners(dispatchQueue, leave, enter, from, to);
+}
+
+/**
+ * Given any node return the first leaf node without children.
+ *
+ * @param {DOMElement|DOMTextNode} node
+ * @return {DOMElement|DOMTextNode}
+ */
+
+function getLeafNode(node) {
+  while (node && node.firstChild) {
+    node = node.firstChild;
+  }
+
+  return node;
+}
+/**
+ * Get the next sibling within a container. This will walk up the
+ * DOM if a node's siblings have been exhausted.
+ *
+ * @param {DOMElement|DOMTextNode} node
+ * @return {?DOMElement|DOMTextNode}
+ */
+
+
+function getSiblingNode(node) {
+  while (node) {
+    if (node.nextSibling) {
+      return node.nextSibling;
+    }
+
+    node = node.parentNode;
+  }
+}
+/**
+ * Get object describing the nodes which contain characters at offset.
+ *
+ * @param {DOMElement|DOMTextNode} root
+ * @param {number} offset
+ * @return {?object}
+ */
+
+
+function getNodeForCharacterOffset(root, offset) {
+  let node = getLeafNode(root);
+  let nodeStart = 0;
+  let nodeEnd = 0;
+
+  while (node) {
+    if (node.nodeType === TEXT_NODE) {
+      nodeEnd = nodeStart + node.textContent.length;
+
+      if (nodeStart <= offset && nodeEnd >= offset) {
+        return {
+          node: node,
+          offset: offset - nodeStart
+        };
+      }
+
+      nodeStart = nodeEnd;
+    }
+
+    node = getLeafNode(getSiblingNode(node));
+  }
+}
+
+/**
+ * @param {DOMElement} outerNode
+ * @return {?object}
+ */
+
+function getOffsets(outerNode) {
+  const ownerDocument = outerNode.ownerDocument;
+  const win = ownerDocument && ownerDocument.defaultView || window;
+  const selection = win.getSelection && win.getSelection();
+
+  if (!selection || selection.rangeCount === 0) {
+    return null;
+  }
+
+  const anchorNode = selection.anchorNode,
+        anchorOffset = selection.anchorOffset,
+        focusNode = selection.focusNode,
+        focusOffset = selection.focusOffset; // In Firefox, anchorNode and focusNode can be "anonymous divs", e.g. the
+  // up/down buttons on an <input type="number">. Anonymous divs do not seem to
+  // expose properties, triggering a "Permission denied error" if any of its
+  // properties are accessed. The only seemingly possible way to avoid erroring
+  // is to access a property that typically works for non-anonymous divs and
+  // catch any error that may otherwise arise. See
+  // https://bugzilla.mozilla.org/show_bug.cgi?id=208427
+
+  try {
+    /* eslint-disable ft-flow/no-unused-expressions */
+    anchorNode.nodeType;
+    focusNode.nodeType;
+    /* eslint-enable ft-flow/no-unused-expressions */
+  } catch (e) {
+    return null;
+  }
+
+  return getModernOffsetsFromPoints(outerNode, anchorNode, anchorOffset, focusNode, focusOffset);
+}
+/**
+ * Returns {start, end} where `start` is the character/codepoint index of
+ * (anchorNode, anchorOffset) within the textContent of `outerNode`, and
+ * `end` is the index of (focusNode, focusOffset).
+ *
+ * Returns null if you pass in garbage input but we should probably just crash.
+ *
+ * Exported only for testing.
+ */
+
+function getModernOffsetsFromPoints(outerNode, anchorNode, anchorOffset, focusNode, focusOffset) {
+  let length = 0;
+  let start = -1;
+  let end = -1;
+  let indexWithinAnchor = 0;
+  let indexWithinFocus = 0;
+  let node = outerNode;
+  let parentNode = null;
+
+  outer: while (true) {
+    let next = null;
+
+    while (true) {
+      if (node === anchorNode && (anchorOffset === 0 || node.nodeType === TEXT_NODE)) {
+        start = length + anchorOffset;
+      }
+
+      if (node === focusNode && (focusOffset === 0 || node.nodeType === TEXT_NODE)) {
+        end = length + focusOffset;
+      }
+
+      if (node.nodeType === TEXT_NODE) {
+        length += node.nodeValue.length;
+      }
+
+      if ((next = node.firstChild) === null) {
+        break;
+      } // Moving from `node` to its first child `next`.
+
+
+      parentNode = node;
+      node = next;
+    }
+
+    while (true) {
+      if (node === outerNode) {
+        // If `outerNode` has children, this is always the second time visiting
+        // it. If it has no children, this is still the first loop, and the only
+        // valid selection is anchorNode and focusNode both equal to this node
+        // and both offsets 0, in which case we will have handled above.
+        break outer;
+      }
+
+      if (parentNode === anchorNode && ++indexWithinAnchor === anchorOffset) {
+        start = length;
+      }
+
+      if (parentNode === focusNode && ++indexWithinFocus === focusOffset) {
+        end = length;
+      }
+
+      if ((next = node.nextSibling) !== null) {
+        break;
+      }
+
+      node = parentNode;
+      parentNode = node.parentNode;
+    } // Moving from `node` to its next sibling `next`.
+
+
+    node = next;
+  }
+
+  if (start === -1 || end === -1) {
+    // This should never happen. (Would happen if the anchor/focus nodes aren't
+    // actually inside the passed-in node.)
+    return null;
+  }
+
+  return {
+    start: start,
+    end: end
+  };
+}
+/**
+ * In modern non-IE browsers, we can support both forward and backward
+ * selections.
+ *
+ * Note: IE10+ supports the Selection object, but it does not support
+ * the `extend` method, which means that even in modern IE, it's not possible
+ * to programmatically create a backward selection. Thus, for all IE
+ * versions, we use the old IE API to create our selections.
+ *
+ * @param {DOMElement|DOMTextNode} node
+ * @param {object} offsets
+ */
+
+function setOffsets(node, offsets) {
+  const doc = node.ownerDocument || document;
+  const win = doc && doc.defaultView || window; // Edge fails with "Object expected" in some scenarios.
+  // (For instance: TinyMCE editor used in a list component that supports pasting to add more,
+  // fails when pasting 100+ items)
+
+  if (!win.getSelection) {
+    return;
+  }
+
+  const selection = win.getSelection();
+  const length = node.textContent.length;
+  let start = Math.min(offsets.start, length);
+  let end = offsets.end === undefined ? start : Math.min(offsets.end, length); // IE 11 uses modern selection, but doesn't support the extend method.
+  // Flip backward selections, so we can set with a single range.
+
+  if (!selection.extend && start > end) {
+    const temp = end;
+    end = start;
+    start = temp;
+  }
+
+  const startMarker = getNodeForCharacterOffset(node, start);
+  const endMarker = getNodeForCharacterOffset(node, end);
+
+  if (startMarker && endMarker) {
+    if (selection.rangeCount === 1 && selection.anchorNode === startMarker.node && selection.anchorOffset === startMarker.offset && selection.focusNode === endMarker.node && selection.focusOffset === endMarker.offset) {
+      return;
+    }
+
+    const range = doc.createRange();
+    range.setStart(startMarker.node, startMarker.offset);
+    selection.removeAllRanges();
+
+    if (start > end) {
+      selection.addRange(range);
+      selection.extend(endMarker.node, endMarker.offset);
+    } else {
+      range.setEnd(endMarker.node, endMarker.offset);
+      selection.addRange(range);
+    }
+  }
+}
+
+function isTextNode(node) {
+  return node && node.nodeType === TEXT_NODE;
+}
+
+function containsNode(outerNode, innerNode) {
+  if (!outerNode || !innerNode) {
+    return false;
+  } else if (outerNode === innerNode) {
+    return true;
+  } else if (isTextNode(outerNode)) {
+    return false;
+  } else if (isTextNode(innerNode)) {
+    return containsNode(outerNode, innerNode.parentNode);
+  } else if ('contains' in outerNode) {
+    return outerNode.contains(innerNode);
+  } else if (outerNode.compareDocumentPosition) {
+    return !!(outerNode.compareDocumentPosition(innerNode) & 16);
+  } else {
+    return false;
+  }
+}
+
+function isInDocument(node) {
+  return node && node.ownerDocument && containsNode(node.ownerDocument.documentElement, node);
+}
+
+function isSameOriginFrame(iframe) {
+  try {
+    // Accessing the contentDocument of a HTMLIframeElement can cause the browser
+    // to throw, e.g. if it has a cross-origin src attribute.
+    // Safari will show an error in the console when the access results in "Blocked a frame with origin". e.g:
+    // iframe.contentDocument.defaultView;
+    // A safety way is to access one of the cross origin properties: Window or Location
+    // Which might result in "SecurityError" DOM Exception and it is compatible to Safari.
+    // https://html.spec.whatwg.org/multipage/browsers.html#integration-with-idl
+    return typeof iframe.contentWindow.location.href === 'string';
+  } catch (err) {
+    return false;
+  }
+}
+
+function getActiveElementDeep() {
+  let win = window;
+  let element = getActiveElement();
+
+  while (element instanceof win.HTMLIFrameElement) {
+    if (isSameOriginFrame(element)) {
+      win = element.contentWindow;
+    } else {
+      return element;
+    }
+
+    element = getActiveElement(win.document);
+  }
+
+  return element;
+}
+/**
+ * @ReactInputSelection: React input selection module. Based on Selection.js,
+ * but modified to be suitable for react and has a couple of bug fixes (doesn't
+ * assume buttons have range selections allowed).
+ * Input selection module for React.
+ */
+
+/**
+ * @hasSelectionCapabilities: we get the element types that support selection
+ * from https://html.spec.whatwg.org/#do-not-apply, looking at `selectionStart`
+ * and `selectionEnd` rows.
+ */
+
+
+function hasSelectionCapabilities(elem) {
+  const nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+  return nodeName && (nodeName === 'input' && (elem.type === 'text' || elem.type === 'search' || elem.type === 'tel' || elem.type === 'url' || elem.type === 'password') || nodeName === 'textarea' || elem.contentEditable === 'true');
+}
+function getSelectionInformation() {
+  const focusedElem = getActiveElementDeep();
+  return {
+    focusedElem: focusedElem,
+    selectionRange: hasSelectionCapabilities(focusedElem) ? getSelection$1(focusedElem) : null
+  };
+}
+/**
+ * @restoreSelection: If any selection information was potentially lost,
+ * restore it. This is useful when performing operations that could remove dom
+ * nodes and place them back in, resulting in focus being lost.
+ */
+
+function restoreSelection(priorSelectionInformation) {
+  const curFocusedElem = getActiveElementDeep();
+  const priorFocusedElem = priorSelectionInformation.focusedElem;
+  const priorSelectionRange = priorSelectionInformation.selectionRange;
+
+  if (curFocusedElem !== priorFocusedElem && isInDocument(priorFocusedElem)) {
+    if (priorSelectionRange !== null && hasSelectionCapabilities(priorFocusedElem)) {
+      setSelection(priorFocusedElem, priorSelectionRange);
+    } // Focusing a node can change the scroll position, which is undesirable
+
+
+    const ancestors = [];
+    let ancestor = priorFocusedElem;
+
+    while (ancestor = ancestor.parentNode) {
+      if (ancestor.nodeType === ELEMENT_NODE) {
+        ancestors.push({
+          element: ancestor,
+          left: ancestor.scrollLeft,
+          top: ancestor.scrollTop
+        });
+      }
+    }
+
+    if (typeof priorFocusedElem.focus === 'function') {
+      priorFocusedElem.focus();
+    }
+
+    for (let i = 0; i < ancestors.length; i++) {
+      const info = ancestors[i];
+      info.element.scrollLeft = info.left;
+      info.element.scrollTop = info.top;
+    }
+  }
+}
+/**
+ * @getSelection: Gets the selection bounds of a focused textarea, input or
+ * contentEditable node.
+ * -@input: Look up selection bounds of this input
+ * -@return {start: selectionStart, end: selectionEnd}
+ */
+
+function getSelection$1(input) {
+  let selection;
+
+  if ('selectionStart' in input) {
+    // Modern browser with input or textarea.
+    selection = {
+      start: input.selectionStart,
+      end: input.selectionEnd
+    };
+  } else {
+    // Content editable or old IE textarea.
+    selection = getOffsets(input);
+  }
+
+  return selection || {
+    start: 0,
+    end: 0
+  };
+}
+/**
+ * @setSelection: Sets the selection bounds of a textarea or input and focuses
+ * the input.
+ * -@input     Set selection bounds of this input or textarea
+ * -@offsets   Object of same form that is returned from get*
+ */
+
+function setSelection(input, offsets) {
+  const start = offsets.start;
+  let end = offsets.end;
+
+  if (end === undefined) {
+    end = start;
+  }
+
+  if ('selectionStart' in input) {
+    input.selectionStart = start;
+    input.selectionEnd = Math.min(end, input.value.length);
+  } else {
+    setOffsets(input, offsets);
+  }
+}
+
+const skipSelectionChangeEvent = canUseDOM && 'documentMode' in document && document.documentMode <= 11;
+
+function registerEvents() {
+  registerTwoPhaseEvent('onSelect', ['focusout', 'contextmenu', 'dragend', 'focusin', 'keydown', 'keyup', 'mousedown', 'mouseup', 'selectionchange']);
+}
+
+let activeElement = null;
+let activeElementInst = null;
+let lastSelection = null;
+let mouseDown = false;
+/**
+ * Get an object which is a unique representation of the current selection.
+ *
+ * The return value will not be consistent across nodes or browsers, but
+ * two identical selections on the same node will return identical objects.
+ */
+
+function getSelection(node) {
+  if ('selectionStart' in node && hasSelectionCapabilities(node)) {
+    return {
+      start: node.selectionStart,
+      end: node.selectionEnd
+    };
+  } else {
+    const win = node.ownerDocument && node.ownerDocument.defaultView || window;
+    const selection = win.getSelection();
+    return {
+      anchorNode: selection.anchorNode,
+      anchorOffset: selection.anchorOffset,
+      focusNode: selection.focusNode,
+      focusOffset: selection.focusOffset
+    };
+  }
+}
+/**
+ * Get document associated with the event target.
+ */
+
+
+function getEventTargetDocument(eventTarget) {
+  return eventTarget.window === eventTarget ? eventTarget.document : eventTarget.nodeType === DOCUMENT_NODE ? eventTarget : eventTarget.ownerDocument;
+}
+/**
+ * Poll selection to see whether it's changed.
+ *
+ * @param {object} nativeEvent
+ * @param {object} nativeEventTarget
+ * @return {?SyntheticEvent}
+ */
+
+
+function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
+  // Ensure we have the right element, and that the user is not dragging a
+  // selection (this matches native `select` event behavior). In HTML5, select
+  // fires only on input and textarea thus if there's no focused element we
+  // won't dispatch.
+  const doc = getEventTargetDocument(nativeEventTarget);
+
+  if (mouseDown || activeElement == null || activeElement !== getActiveElement(doc)) {
+    return;
+  } // Only fire when selection has actually changed.
+
+
+  const currentSelection = getSelection(activeElement);
+
+  if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {
+    lastSelection = currentSelection;
+    const listeners = accumulateTwoPhaseListeners(activeElementInst, 'onSelect');
+
+    if (listeners.length > 0) {
+      const event = new SyntheticEvent('onSelect', 'select', null, nativeEvent, nativeEventTarget);
+      dispatchQueue.push({
+        event,
+        listeners
+      });
+      event.target = activeElement;
+    }
+  }
+}
+/**
+ * This plugin creates an `onSelect` event that normalizes select events
+ * across form elements.
+ *
+ * Supported elements are:
+ * - input (see `isTextInputElement`)
+ * - textarea
+ * - contentEditable
+ *
+ * This differs from native browser implementations in the following ways:
+ * - Fires on contentEditable fields as well as inputs.
+ * - Fires for collapsed selection.
+ * - Fires after user input.
+ */
+
+
+function extractEvents$2(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  const targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
+
+  switch (domEventName) {
+    // Track the input node that has focus.
+    case 'focusin':
+      if (isTextInputElement(targetNode) || targetNode.contentEditable === 'true') {
+        activeElement = targetNode;
+        activeElementInst = targetInst;
+        lastSelection = null;
+      }
+
+      break;
+
+    case 'focusout':
+      activeElement = null;
+      activeElementInst = null;
+      lastSelection = null;
+      break;
+    // Don't fire the event while the user is dragging. This matches the
+    // semantics of the native select event.
+
+    case 'mousedown':
+      mouseDown = true;
+      break;
+
+    case 'contextmenu':
+    case 'mouseup':
+    case 'dragend':
+      mouseDown = false;
+      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+      break;
+    // Chrome and IE fire non-standard event when selection is changed (and
+    // sometimes when it hasn't). IE's event fires out of order with respect
+    // to key and input events on deletion, so we discard it.
+    //
+    // Firefox doesn't support selectionchange, so check selection status
+    // after each key entry. The selection changes after keydown and before
+    // keyup, but we check on keydown as well in the case of holding down a
+    // key, when multiple keydown events are fired but only one keyup is.
+    // This is also our approach for IE handling, for the reason above.
+
+    case 'selectionchange':
+      if (skipSelectionChangeEvent) {
+        break;
+      }
+
+    // falls through
+
+    case 'keydown':
+    case 'keyup':
+      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+  }
+}
+
+/**
+ * Generate a mapping of standard vendor prefixes using the defined style property and event name.
+ *
+ * @param {string} styleProp
+ * @param {string} eventName
+ * @returns {object}
+ */
+
+function makePrefixMap(styleProp, eventName) {
+  const prefixes = {};
+  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
+  prefixes['Webkit' + styleProp] = 'webkit' + eventName;
+  prefixes['Moz' + styleProp] = 'moz' + eventName;
+  return prefixes;
+}
+/**
+ * A list of event names to a configurable list of vendor prefixes.
+ */
+
+
+const vendorPrefixes = {
+  animationend: makePrefixMap('Animation', 'AnimationEnd'),
+  animationiteration: makePrefixMap('Animation', 'AnimationIteration'),
+  animationstart: makePrefixMap('Animation', 'AnimationStart'),
+  transitionend: makePrefixMap('Transition', 'TransitionEnd')
+};
+/**
+ * Event names that have already been detected and prefixed (if applicable).
+ */
+
+const prefixedEventNames = {};
+/**
+ * Element to check for prefixes on.
+ */
+
+let style = {};
+/**
+ * Bootstrap if a DOM exists.
+ */
+
+if (canUseDOM) {
+  style = document.createElement('div').style; // On some platforms, in particular some releases of Android 4.x,
+  // the un-prefixed "animation" and "transition" properties are defined on the
+  // style object but the events that fire will still be prefixed, so we need
+  // to check if the un-prefixed events are usable, and if not remove them from the map.
+
+  if (!('AnimationEvent' in window)) {
+    delete vendorPrefixes.animationend.animation;
+    delete vendorPrefixes.animationiteration.animation;
+    delete vendorPrefixes.animationstart.animation;
+  } // Same as above
+
+
+  if (!('TransitionEvent' in window)) {
+    delete vendorPrefixes.transitionend.transition;
+  }
+}
+/**
+ * Attempts to determine the correct vendor prefixed event name.
+ *
+ * @param {string} eventName
+ * @returns {string}
+ */
+
+
+function getVendorPrefixedEventName(eventName) {
+  if (prefixedEventNames[eventName]) {
+    return prefixedEventNames[eventName];
+  } else if (!vendorPrefixes[eventName]) {
+    return eventName;
+  }
+
+  const prefixMap = vendorPrefixes[eventName];
+
+  for (const styleProp in prefixMap) {
+    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {
+      return prefixedEventNames[eventName] = prefixMap[styleProp];
+    }
+  }
+
+  return eventName;
+}
+
+const ANIMATION_END = getVendorPrefixedEventName('animationend');
+const ANIMATION_ITERATION = getVendorPrefixedEventName('animationiteration');
+const ANIMATION_START = getVendorPrefixedEventName('animationstart');
+const TRANSITION_END = getVendorPrefixedEventName('transitionend');
+
+const topLevelEventsToReactNames = new Map(); // NOTE: Capitalization is important in this list!
+//
+// E.g. it needs "pointerDown", not "pointerdown".
+// This is because we derive both React name ("onPointerDown")
+// and DOM name ("pointerdown") from the same list.
+//
+// Exceptions that don't match this convention are listed separately.
+//
+// prettier-ignore
+
+const simpleEventPluginEvents = ['abort', 'auxClick', 'cancel', 'canPlay', 'canPlayThrough', 'click', 'close', 'contextMenu', 'copy', 'cut', 'drag', 'dragEnd', 'dragEnter', 'dragExit', 'dragLeave', 'dragOver', 'dragStart', 'drop', 'durationChange', 'emptied', 'encrypted', 'ended', 'error', 'gotPointerCapture', 'input', 'invalid', 'keyDown', 'keyPress', 'keyUp', 'load', 'loadedData', 'loadedMetadata', 'loadStart', 'lostPointerCapture', 'mouseDown', 'mouseMove', 'mouseOut', 'mouseOver', 'mouseUp', 'paste', 'pause', 'play', 'playing', 'pointerCancel', 'pointerDown', 'pointerMove', 'pointerOut', 'pointerOver', 'pointerUp', 'progress', 'rateChange', 'reset', 'resize', 'seeked', 'seeking', 'stalled', 'submit', 'suspend', 'timeUpdate', 'touchCancel', 'touchEnd', 'touchStart', 'volumeChange', 'scroll', 'scrollEnd', 'toggle', 'touchMove', 'waiting', 'wheel'];
+
+function registerSimpleEvent(domEventName, reactName) {
+  topLevelEventsToReactNames.set(domEventName, reactName);
+  registerTwoPhaseEvent(reactName, [domEventName]);
+}
+
+function registerSimpleEvents() {
+  for (let i = 0; i < simpleEventPluginEvents.length; i++) {
+    const eventName = simpleEventPluginEvents[i];
+    const domEventName = eventName.toLowerCase();
+    const capitalizedEvent = eventName[0].toUpperCase() + eventName.slice(1);
+    registerSimpleEvent(domEventName, 'on' + capitalizedEvent);
+  } // Special cases where event names don't match.
+
+
+  registerSimpleEvent(ANIMATION_END, 'onAnimationEnd');
+  registerSimpleEvent(ANIMATION_ITERATION, 'onAnimationIteration');
+  registerSimpleEvent(ANIMATION_START, 'onAnimationStart');
+  registerSimpleEvent('dblclick', 'onDoubleClick');
+  registerSimpleEvent('focusin', 'onFocus');
+  registerSimpleEvent('focusout', 'onBlur');
+  registerSimpleEvent(TRANSITION_END, 'onTransitionEnd');
+}
+
+function extractEvents$1(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  const reactName = topLevelEventsToReactNames.get(domEventName);
+
+  if (reactName === undefined) {
+    return;
+  }
+
+  let SyntheticEventCtor = SyntheticEvent;
+  let reactEventType = domEventName;
+
+  switch (domEventName) {
+    case 'keypress':
+      // Firefox creates a keypress event for function keys too. This removes
+      // the unwanted keypress events. Enter is however both printable and
+      // non-printable. One would expect Tab to be as well (but it isn't).
+      // TODO: Fixed in https://bugzilla.mozilla.org/show_bug.cgi?id=968056. Can
+      // probably remove.
+      if (getEventCharCode(nativeEvent) === 0) {
+        return;
+      }
+
+    /* falls through */
+
+    case 'keydown':
+    case 'keyup':
+      SyntheticEventCtor = SyntheticKeyboardEvent;
+      break;
+
+    case 'focusin':
+      reactEventType = 'focus';
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
+
+    case 'focusout':
+      reactEventType = 'blur';
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
+
+    case 'beforeblur':
+    case 'afterblur':
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
+
+    case 'click':
+      // Firefox creates a click event on right mouse clicks. This removes the
+      // unwanted click events.
+      // TODO: Fixed in https://phabricator.services.mozilla.com/D26793. Can
+      // probably remove.
+      if (nativeEvent.button === 2) {
+        return;
+      }
+
+    /* falls through */
+
+    case 'auxclick':
+    case 'dblclick':
+    case 'mousedown':
+    case 'mousemove':
+    case 'mouseup': // TODO: Disabled elements should not respond to mouse events
+
+    /* falls through */
+
+    case 'mouseout':
+    case 'mouseover':
+    case 'contextmenu':
+      SyntheticEventCtor = SyntheticMouseEvent;
+      break;
+
+    case 'drag':
+    case 'dragend':
+    case 'dragenter':
+    case 'dragexit':
+    case 'dragleave':
+    case 'dragover':
+    case 'dragstart':
+    case 'drop':
+      SyntheticEventCtor = SyntheticDragEvent;
+      break;
+
+    case 'touchcancel':
+    case 'touchend':
+    case 'touchmove':
+    case 'touchstart':
+      SyntheticEventCtor = SyntheticTouchEvent;
+      break;
+
+    case ANIMATION_END:
+    case ANIMATION_ITERATION:
+    case ANIMATION_START:
+      SyntheticEventCtor = SyntheticAnimationEvent;
+      break;
+
+    case TRANSITION_END:
+      SyntheticEventCtor = SyntheticTransitionEvent;
+      break;
+
+    case 'scroll':
+    case 'scrollend':
+      SyntheticEventCtor = SyntheticUIEvent;
+      break;
+
+    case 'wheel':
+      SyntheticEventCtor = SyntheticWheelEvent;
+      break;
+
+    case 'copy':
+    case 'cut':
+    case 'paste':
+      SyntheticEventCtor = SyntheticClipboardEvent;
+      break;
+
+    case 'gotpointercapture':
+    case 'lostpointercapture':
+    case 'pointercancel':
+    case 'pointerdown':
+    case 'pointermove':
+    case 'pointerout':
+    case 'pointerover':
+    case 'pointerup':
+      SyntheticEventCtor = SyntheticPointerEvent;
+      break;
+  }
+
+  const inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
+
+  {
+    // Some events don't bubble in the browser.
+    // In the past, React has always bubbled them, but this can be surprising.
+    // We're going to try aligning closer to the browser behavior by not bubbling
+    // them in React either. We'll start by not bubbling onScroll, and then expand.
+    const accumulateTargetOnly = !inCapturePhase && ( // TODO: ideally, we'd eventually add all events from
+    // nonDelegatedEvents list in DOMPluginEventSystem.
+    // Then we can remove this special list.
+    // This is a breaking change that can wait until React 18.
+    domEventName === 'scroll' || domEventName === 'scrollend');
+    const listeners = accumulateSinglePhaseListeners(targetInst, reactName, nativeEvent.type, inCapturePhase, accumulateTargetOnly);
+
+    if (listeners.length > 0) {
+      // Intentionally create event lazily.
+      const event = new SyntheticEventCtor(reactName, reactEventType, null, nativeEvent, nativeEventTarget);
+      dispatchQueue.push({
+        event,
+        listeners
+      });
+    }
+  }
+}
+
+registerSimpleEvents();
+registerEvents$1();
+registerEvents$2();
+registerEvents();
+registerEvents$3();
+
+function extractEvents(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
+  // TODO: we should remove the concept of a "SimpleEventPlugin".
+  // This is the basic functionality of the event system. All
+  // the other plugins are essentially polyfills. So the plugin
+  // should probably be inlined somewhere and have its logic
+  // be core the to event system. This would potentially allow
+  // us to ship builds of React without the polyfilled plugins below.
+  extractEvents$1(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags);
+  const shouldProcessPolyfillPlugins = (eventSystemFlags & SHOULD_NOT_PROCESS_POLYFILL_EVENT_PLUGINS) === 0; // We don't process these events unless we are in the
+  // event's native "bubble" phase, which means that we're
+  // not in the capture phase. That's because we emulate
+  // the capture phase here still. This is a trade-off,
+  // because in an ideal world we would not emulate and use
+  // the phases properly, like we do with the SimpleEvent
+  // plugin. However, the plugins below either expect
+  // emulation (EnterLeave) or use state localized to that
+  // plugin (BeforeInput, Change, Select). The state in
+  // these modules complicates things, as you'll essentially
+  // get the case where the capture phase event might change
+  // state, only for the following bubble event to come in
+  // later and not trigger anything as the state now
+  // invalidates the heuristics of the event plugin. We
+  // could alter all these plugins to work in such ways, but
+  // that might cause other unknown side-effects that we
+  // can't foresee right now.
+
+  if (shouldProcessPolyfillPlugins) {
+    extractEvents$3(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+    extractEvents$4(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+    extractEvents$2(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+    extractEvents$5(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+
+    {
+      extractEvents$6(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
+    }
+  }
+} // List of events that need to be individually attached to media elements.
+
+
+const mediaEventTypes = ['abort', 'canplay', 'canplaythrough', 'durationchange', 'emptied', 'encrypted', 'ended', 'error', 'loadeddata', 'loadedmetadata', 'loadstart', 'pause', 'play', 'playing', 'progress', 'ratechange', 'resize', 'seeked', 'seeking', 'stalled', 'suspend', 'timeupdate', 'volumechange', 'waiting']; // We should not delegate these events to the container, but rather
+// set them on the actual target element itself. This is primarily
+// because these events do not consistently bubble in the DOM.
+
+const nonDelegatedEvents = new Set(['cancel', 'close', 'invalid', 'load', 'scroll', 'scrollend', 'toggle'].concat(mediaEventTypes));
+
+function executeDispatch(event, listener, currentTarget) {
+  const type = event.type || 'unknown-event';
+  event.currentTarget = currentTarget;
+  invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
+  event.currentTarget = null;
+}
+
+function processDispatchQueueItemsInOrder(event, dispatchListeners, inCapturePhase) {
+  let previousInstance;
+
+  if (inCapturePhase) {
+    for (let i = dispatchListeners.length - 1; i >= 0; i--) {
+      const _dispatchListeners$i = dispatchListeners[i],
+            instance = _dispatchListeners$i.instance,
+            currentTarget = _dispatchListeners$i.currentTarget,
+            listener = _dispatchListeners$i.listener;
+
+      if (instance !== previousInstance && event.isPropagationStopped()) {
+        return;
+      }
+
+      executeDispatch(event, listener, currentTarget);
+      previousInstance = instance;
+    }
+  } else {
+    for (let i = 0; i < dispatchListeners.length; i++) {
+      const _dispatchListeners$i2 = dispatchListeners[i],
+            instance = _dispatchListeners$i2.instance,
+            currentTarget = _dispatchListeners$i2.currentTarget,
+            listener = _dispatchListeners$i2.listener;
+
+      if (instance !== previousInstance && event.isPropagationStopped()) {
+        return;
+      }
+
+      executeDispatch(event, listener, currentTarget);
+      previousInstance = instance;
+    }
+  }
+}
+
+function processDispatchQueue(dispatchQueue, eventSystemFlags) {
+  const inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
+
+  for (let i = 0; i < dispatchQueue.length; i++) {
+    const _dispatchQueue$i = dispatchQueue[i],
+          event = _dispatchQueue$i.event,
+          listeners = _dispatchQueue$i.listeners;
+    processDispatchQueueItemsInOrder(event, listeners, inCapturePhase); //  event system doesn't use pooling.
+  } // This would be a good time to rethrow if any of the event handlers threw.
+
+
+  rethrowCaughtError();
+}
+
+function dispatchEventsForPlugins(domEventName, eventSystemFlags, nativeEvent, targetInst, targetContainer) {
+  const nativeEventTarget = getEventTarget(nativeEvent);
+  const dispatchQueue = [];
+  extractEvents(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags);
+  processDispatchQueue(dispatchQueue, eventSystemFlags);
+}
+
+function listenToNonDelegatedEvent(domEventName, targetElement) {
+
+  const isCapturePhaseListener = false;
+  const listenerSet = getEventListenerSet(targetElement);
+  const listenerSetKey = getListenerSetKey(domEventName, isCapturePhaseListener);
+
+  if (!listenerSet.has(listenerSetKey)) {
+    addTrappedEventListener(targetElement, domEventName, IS_NON_DELEGATED, isCapturePhaseListener);
+    listenerSet.add(listenerSetKey);
+  }
+}
+function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
+
+  let eventSystemFlags = 0;
+
+  if (isCapturePhaseListener) {
+    eventSystemFlags |= IS_CAPTURE_PHASE;
+  }
+
+  addTrappedEventListener(target, domEventName, eventSystemFlags, isCapturePhaseListener);
+} // This is only used by createEventHandle when the
+const listeningMarker = '_reactListening' + Math.random().toString(36).slice(2);
+function listenToAllSupportedEvents(rootContainerElement) {
+  if (!rootContainerElement[listeningMarker]) {
+    rootContainerElement[listeningMarker] = true;
+    allNativeEvents.forEach(domEventName => {
+      // We handle selectionchange separately because it
+      // doesn't bubble and needs to be on the document.
+      if (domEventName !== 'selectionchange') {
+        if (!nonDelegatedEvents.has(domEventName)) {
+          listenToNativeEvent(domEventName, false, rootContainerElement);
+        }
+
+        listenToNativeEvent(domEventName, true, rootContainerElement);
+      }
+    });
+    const ownerDocument = rootContainerElement.nodeType === DOCUMENT_NODE ? rootContainerElement : rootContainerElement.ownerDocument;
+
+    if (ownerDocument !== null) {
+      // The selectionchange event also needs deduplication
+      // but it is attached to the document.
+      if (!ownerDocument[listeningMarker]) {
+        ownerDocument[listeningMarker] = true;
+        listenToNativeEvent('selectionchange', false, ownerDocument);
+      }
+    }
+  }
+}
+
+function addTrappedEventListener(targetContainer, domEventName, eventSystemFlags, isCapturePhaseListener, isDeferredListenerForLegacyFBSupport) {
+  let listener = createEventListenerWrapperWithPriority(targetContainer, domEventName, eventSystemFlags); // If passive option is not supported, then the event will be
+  // active and not passive.
+
+  let isPassiveListener = undefined;
+
+  if (passiveBrowserEventsSupported) {
+    // Browsers introduced an intervention, making these events
+    // passive by default on document. React doesn't bind them
+    // to document anymore, but changing this now would undo
+    // the performance wins from the change. So we emulate
+    // the existing behavior manually on the roots now.
+    // https://github.com/facebook/react/issues/19651
+    if (domEventName === 'touchstart' || domEventName === 'touchmove' || domEventName === 'wheel') {
+      isPassiveListener = true;
+    }
+  }
+
+  targetContainer = targetContainer;
+
+
+  if (isCapturePhaseListener) {
+    if (isPassiveListener !== undefined) {
+      addEventCaptureListenerWithPassiveFlag(targetContainer, domEventName, listener, isPassiveListener);
+    } else {
+      addEventCaptureListener(targetContainer, domEventName, listener);
+    }
+  } else {
+    if (isPassiveListener !== undefined) {
+      addEventBubbleListenerWithPassiveFlag(targetContainer, domEventName, listener, isPassiveListener);
+    } else {
+      addEventBubbleListener(targetContainer, domEventName, listener);
+    }
+  }
+}
+
+function isMatchingRootContainer(grandContainer, targetContainer) {
+  return grandContainer === targetContainer || grandContainer.nodeType === COMMENT_NODE && grandContainer.parentNode === targetContainer;
+}
+
+function dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, targetInst, targetContainer) {
+  let ancestorInst = targetInst;
+
+  if ((eventSystemFlags & IS_EVENT_HANDLE_NON_MANAGED_NODE) === 0 && (eventSystemFlags & IS_NON_DELEGATED) === 0) {
+    const targetContainerNode = targetContainer; // If we are using the legacy FB support flag, we
+
+    if (targetInst !== null) {
+      // The below logic attempts to work out if we need to change
+      // the target fiber to a different ancestor. We had similar logic
+      // in the legacy event system, except the big difference between
+      // systems is that the modern event system now has an event listener
+      // attached to each React Root and React Portal Root. Together,
+      // the DOM nodes representing these roots are the "rootContainer".
+      // To figure out which ancestor instance we should use, we traverse
+      // up the fiber tree from the target instance and attempt to find
+      // root boundaries that match that of our current "rootContainer".
+      // If we find that "rootContainer", we find the parent fiber
+      // sub-tree for that root and make that our ancestor instance.
+      let node = targetInst;
+
+      mainLoop: while (true) {
+        if (node === null) {
+          return;
+        }
+
+        const nodeTag = node.tag;
+
+        if (nodeTag === HostRoot || nodeTag === HostPortal) {
+          let container = node.stateNode.containerInfo;
+
+          if (isMatchingRootContainer(container, targetContainerNode)) {
+            break;
+          }
+
+          if (nodeTag === HostPortal) {
+            // The target is a portal, but it's not the rootContainer we're looking for.
+            // Normally portals handle their own events all the way down to the root.
+            // So we should be able to stop now. However, we don't know if this portal
+            // was part of *our* root.
+            let grandNode = node.return;
+
+            while (grandNode !== null) {
+              const grandTag = grandNode.tag;
+
+              if (grandTag === HostRoot || grandTag === HostPortal) {
+                const grandContainer = grandNode.stateNode.containerInfo;
+
+                if (isMatchingRootContainer(grandContainer, targetContainerNode)) {
+                  // This is the rootContainer we're looking for and we found it as
+                  // a parent of the Portal. That means we can ignore it because the
+                  // Portal will bubble through to us.
+                  return;
+                }
+              }
+
+              grandNode = grandNode.return;
+            }
+          } // Now we need to find it's corresponding host fiber in the other
+          // tree. To do this we can use getClosestInstanceFromNode, but we
+          // need to validate that the fiber is a host instance, otherwise
+          // we need to traverse up through the DOM till we find the correct
+          // node that is from the other tree.
+
+
+          while (container !== null) {
+            const parentNode = getClosestInstanceFromNode(container);
+
+            if (parentNode === null) {
+              return;
+            }
+
+            const parentTag = parentNode.tag;
+
+            if (parentTag === HostComponent || parentTag === HostText || (parentTag === HostHoistable ) || (parentTag === HostSingleton )) {
+              node = ancestorInst = parentNode;
+              continue mainLoop;
+            }
+
+            container = container.parentNode;
+          }
+        }
+
+        node = node.return;
+      }
+    }
+  }
+
+  batchedUpdates(() => dispatchEventsForPlugins(domEventName, eventSystemFlags, nativeEvent, ancestorInst));
+}
+
+function createDispatchListener(instance, listener, currentTarget) {
+  return {
+    instance,
+    listener,
+    currentTarget
+  };
+}
+
+function accumulateSinglePhaseListeners(targetFiber, reactName, nativeEventType, inCapturePhase, accumulateTargetOnly, nativeEvent) {
+  const captureName = reactName !== null ? reactName + 'Capture' : null;
+  const reactEventName = inCapturePhase ? captureName : reactName;
+  let listeners = [];
+  let instance = targetFiber;
+  let lastHostComponent = null; // Accumulate all instances and listeners via the target -> root path.
+
+  while (instance !== null) {
+    const _instance = instance,
+          stateNode = _instance.stateNode,
+          tag = _instance.tag; // Handle listeners that are on HostComponents (i.e. <div>)
+
+    if ((tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton )) && stateNode !== null) {
+      lastHostComponent = stateNode; // createEventHandle listeners
+
+
+      if (reactEventName !== null) {
+        const listener = getListener(instance, reactEventName);
+
+        if (listener != null) {
+          listeners.push(createDispatchListener(instance, listener, lastHostComponent));
+        }
+      }
+    } // If we are only accumulating events for the target, then we don't
+    // continue to propagate through the React fiber tree to find other
+    // listeners.
+
+
+    if (accumulateTargetOnly) {
+      break;
+    } // If we are processing the onBeforeBlur event, then we need to take
+
+    instance = instance.return;
+  }
+
+  return listeners;
+} // We should only use this function for:
+// - BeforeInputEventPlugin
+// - ChangeEventPlugin
+// - SelectEventPlugin
+// This is because we only process these plugins
+// in the bubble phase, so we need to accumulate two
+// phase event listeners (via emulation).
+
+function accumulateTwoPhaseListeners(targetFiber, reactName) {
+  const captureName = reactName + 'Capture';
+  const listeners = [];
+  let instance = targetFiber; // Accumulate all instances and listeners via the target -> root path.
+
+  while (instance !== null) {
+    const _instance2 = instance,
+          stateNode = _instance2.stateNode,
+          tag = _instance2.tag; // Handle listeners that are on HostComponents (i.e. <div>)
+
+    if ((tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton )) && stateNode !== null) {
+      const currentTarget = stateNode;
+      const captureListener = getListener(instance, captureName);
+
+      if (captureListener != null) {
+        listeners.unshift(createDispatchListener(instance, captureListener, currentTarget));
+      }
+
+      const bubbleListener = getListener(instance, reactName);
+
+      if (bubbleListener != null) {
+        listeners.push(createDispatchListener(instance, bubbleListener, currentTarget));
+      }
+    }
+
+    instance = instance.return;
+  }
+
+  return listeners;
+}
+
+function getParent(inst) {
+  if (inst === null) {
+    return null;
+  }
+
+  do {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    inst = inst.return; // TODO: If this is a HostRoot we might want to bail out.
+    // That is depending on if we want nested subtrees (layers) to bubble
+    // events to their parent. We could also go through parentNode on the
+    // host node but that wouldn't work for React Native and doesn't let us
+    // do the portal feature.
+  } while (inst && inst.tag !== HostComponent && (inst.tag !== HostSingleton));
+
+  if (inst) {
+    return inst;
+  }
+
+  return null;
+}
+/**
+ * Return the lowest common ancestor of A and B, or null if they are in
+ * different trees.
+ */
+
+
+function getLowestCommonAncestor(instA, instB) {
+  let nodeA = instA;
+  let nodeB = instB;
+  let depthA = 0;
+
+  for (let tempA = nodeA; tempA; tempA = getParent(tempA)) {
+    depthA++;
+  }
+
+  let depthB = 0;
+
+  for (let tempB = nodeB; tempB; tempB = getParent(tempB)) {
+    depthB++;
+  } // If A is deeper, crawl up.
+
+
+  while (depthA - depthB > 0) {
+    nodeA = getParent(nodeA);
+    depthA--;
+  } // If B is deeper, crawl up.
+
+
+  while (depthB - depthA > 0) {
+    nodeB = getParent(nodeB);
+    depthB--;
+  } // Walk in lockstep until we find a match.
+
+
+  let depth = depthA;
+
+  while (depth--) {
+    if (nodeA === nodeB || nodeB !== null && nodeA === nodeB.alternate) {
+      return nodeA;
+    }
+
+    nodeA = getParent(nodeA);
+    nodeB = getParent(nodeB);
+  }
+
+  return null;
+}
+
+function accumulateEnterLeaveListenersForEvent(dispatchQueue, event, target, common, inCapturePhase) {
+  const registrationName = event._reactName;
+  const listeners = [];
+  let instance = target;
+
+  while (instance !== null) {
+    if (instance === common) {
+      break;
+    }
+
+    const _instance3 = instance,
+          alternate = _instance3.alternate,
+          stateNode = _instance3.stateNode,
+          tag = _instance3.tag;
+
+    if (alternate !== null && alternate === common) {
+      break;
+    }
+
+    if ((tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton )) && stateNode !== null) {
+      const currentTarget = stateNode;
+
+      if (inCapturePhase) {
+        const captureListener = getListener(instance, registrationName);
+
+        if (captureListener != null) {
+          listeners.unshift(createDispatchListener(instance, captureListener, currentTarget));
+        }
+      } else if (!inCapturePhase) {
+        const bubbleListener = getListener(instance, registrationName);
+
+        if (bubbleListener != null) {
+          listeners.push(createDispatchListener(instance, bubbleListener, currentTarget));
+        }
+      }
+    }
+
+    instance = instance.return;
+  }
+
+  if (listeners.length !== 0) {
+    dispatchQueue.push({
+      event,
+      listeners
+    });
+  }
+} // We should only use this function for:
+// - EnterLeaveEventPlugin
+// This is because we only process this plugin
+// in the bubble phase, so we need to accumulate two
+// phase event listeners.
+
+
+function accumulateEnterLeaveTwoPhaseListeners(dispatchQueue, leaveEvent, enterEvent, from, to) {
+  const common = from && to ? getLowestCommonAncestor(from, to) : null;
+
+  if (from !== null) {
+    accumulateEnterLeaveListenersForEvent(dispatchQueue, leaveEvent, from, common, false);
+  }
+
+  if (to !== null && enterEvent !== null) {
+    accumulateEnterLeaveListenersForEvent(dispatchQueue, enterEvent, to, common, true);
+  }
+}
+function getListenerSetKey(domEventName, capture) {
+  return domEventName + "__" + (capture ? 'capture' : 'bubble');
+}
+
+// It also can turn \u0000 into \uFFFD inside attributes.
+// https://www.w3.org/TR/html5/single-page.html#preprocessing-the-input-stream
+// If we have a mismatch, it might be caused by that.
+// We will still patch up in this case but not fire the warning.
+
+
+const NORMALIZE_NEWLINES_REGEX = /\r\n?/g;
+const NORMALIZE_NULL_AND_REPLACEMENT_REGEX = /\u0000|\uFFFD/g;
+
+function normalizeMarkupForTextOrAttribute(markup) {
+
+  const markupString = typeof markup === 'string' ? markup : '' + markup;
+  return markupString.replace(NORMALIZE_NEWLINES_REGEX, '\n').replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, '');
+}
+
+function checkForUnmatchedText(serverText, clientText, isConcurrentMode, shouldWarnDev) {
+  const normalizedClientText = normalizeMarkupForTextOrAttribute(clientText);
+  const normalizedServerText = normalizeMarkupForTextOrAttribute(serverText);
+
+  if (normalizedServerText === normalizedClientText) {
+    return;
+  }
+
+  if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {
+    // In concurrent roots, we throw when there's a text mismatch and revert to
+    // client rendering, up to the nearest Suspense boundary.
+    throw Error(formatProdErrorMessage(425));
+  }
+}
+
+function noop$1() {}
+
+function trapClickOnNonInteractiveElement(node) {
+  // Mobile Safari does not fire properly bubble click events on
+  // non-interactive elements, which means delegated click listeners do not
+  // fire. The workaround for this bug involves attaching an empty click
+  // listener on the target node.
+  // https://www.quirksmode.org/blog/archives/2010/09/click_event_del.html
+  // Just set it using the onclick property so that we don't have to manage any
+  // bookkeeping for it. Not sure if we need to clear it when the listener is
+  // removed.
+  // TODO: Only do this for the relevant Safaris maybe?
+  node.onclick = noop$1;
+}
+const xlinkNamespace = 'http://www.w3.org/1999/xlink';
+const xmlNamespace = 'http://www.w3.org/XML/1998/namespace';
+
+function setProp(domElement, tag, key, value, props, prevValue) {
+  switch (key) {
+    case 'children':
+      {
+        if (typeof value === 'string') {
+          // textContent on a <textarea> will cause the placeholder to not
+          // show within the <textarea> until it has been focused and blurred again.
+          // https://github.com/facebook/react/issues/6731#issuecomment-254874553
+
+
+          const canSetTextContent = (tag !== 'body') && (tag !== 'textarea' || value !== '');
+
+          if (canSetTextContent) {
+            setTextContent(domElement, value);
+          }
+        } else if (typeof value === 'number') {
+
+          const canSetTextContent = tag !== 'body';
+
+          if (canSetTextContent) {
+            setTextContent(domElement, '' + value);
+          }
+        }
+
+        break;
+      }
+    // These are very common props and therefore are in the beginning of the switch.
+    // TODO: aria-label is a very common prop but allows booleans so is not like the others
+    // but should ideally go in this list too.
+
+    case 'className':
+      setValueForKnownAttribute(domElement, 'class', value);
+      break;
+
+    case 'tabIndex':
+      // This has to be case sensitive in SVG.
+      setValueForKnownAttribute(domElement, 'tabindex', value);
+      break;
+
+    case 'dir':
+    case 'role':
+    case 'viewBox':
+    case 'width':
+    case 'height':
+      {
+        setValueForKnownAttribute(domElement, key, value);
+        break;
+      }
+
+    case 'style':
+      {
+        setValueForStyles(domElement, value, prevValue);
+        break;
+      }
+    // These attributes accept URLs. These must not allow javascript: URLS.
+
+    case 'src':
+    case 'href':
+      {
+
+        if (value == null || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'boolean') {
+          domElement.removeAttribute(key);
+          break;
+        } // `setAttribute` with objects becomes only `[object]` in IE8/9,
+
+        const sanitizedValue = sanitizeURL('' + value);
+        domElement.setAttribute(key, sanitizedValue);
+        break;
+      }
+
+    case 'action':
+    case 'formAction':
+      {
+
+        {
+          if (typeof value === 'function') {
+            // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+            // because we'll preventDefault, but it can happen if a form is manually submitted or
+            // if someone calls stopPropagation before React gets the event.
+            // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+            // error message but the URL will be logged.
+            domElement.setAttribute(key, // eslint-disable-next-line no-script-url
+            "javascript:throw new Error('" + 'A React form was unexpectedly submitted. If you called form.submit() manually, ' + "consider using form.requestSubmit() instead. If you\\'re trying to use " + 'event.stopPropagation() in a submit event handler, consider also calling ' + 'event.preventDefault().' + "')");
+            break;
+          } else if (typeof prevValue === 'function') {
+            // When we're switching off a Server Action that was originally hydrated.
+            // The server control these fields during SSR that are now trailing.
+            // The regular diffing doesn't apply since we compare against the previous props.
+            // Instead, we need to force them to be set to whatever they should be now.
+            // This would be a lot cleaner if we did this whole fork in the per-tag approach.
+            if (key === 'formAction') {
+              if (tag !== 'input') {
+                // Setting the name here isn't completely safe for inputs if this is switching
+                // to become a radio button. In that case we let the tag based override take
+                // control.
+                setProp(domElement, tag, 'name', props.name, props, null);
+              }
+
+              setProp(domElement, tag, 'formEncType', props.formEncType, props, null);
+              setProp(domElement, tag, 'formMethod', props.formMethod, props, null);
+              setProp(domElement, tag, 'formTarget', props.formTarget, props, null);
+            } else {
+              setProp(domElement, tag, 'encType', props.encType, props, null);
+              setProp(domElement, tag, 'method', props.method, props, null);
+              setProp(domElement, tag, 'target', props.target, props, null);
+            }
+          }
+        }
+
+        if (value == null || !enableFormActions  || typeof value === 'symbol' || typeof value === 'boolean') {
+          domElement.removeAttribute(key);
+          break;
+        } // `setAttribute` with objects becomes only `[object]` in IE8/9,
+
+        const sanitizedValue = sanitizeURL('' + value);
+        domElement.setAttribute(key, sanitizedValue);
+        break;
+      }
+
+    case 'onClick':
+      {
+        // TODO: This cast may not be sound for SVG, MathML or custom elements.
+        if (value != null) {
+
+          trapClickOnNonInteractiveElement(domElement);
+        }
+
+        break;
+      }
+
+    case 'onScroll':
+      {
+        if (value != null) {
+
+          listenToNonDelegatedEvent('scroll', domElement);
+        }
+
+        break;
+      }
+
+    case 'onScrollEnd':
+      {
+        if (value != null) {
+
+          listenToNonDelegatedEvent('scrollend', domElement);
+        }
+
+        break;
+      }
+
+    case 'dangerouslySetInnerHTML':
+      {
+        if (value != null) {
+          if (typeof value !== 'object' || !('__html' in value)) {
+            throw Error(formatProdErrorMessage(61));
+          }
+
+          const nextHtml = value.__html;
+
+          if (nextHtml != null) {
+            if (props.children != null) {
+              throw Error(formatProdErrorMessage(60));
+            }
+
+            {
+              setInnerHTML$1(domElement, nextHtml);
+            }
+          }
+        }
+
+        break;
+      }
+    // Note: `option.selected` is not updated if `select.multiple` is
+    // disabled with `removeAttribute`. We have special logic for handling this.
+
+    case 'multiple':
+      {
+        domElement.multiple = value && typeof value !== 'function' && typeof value !== 'symbol';
+        break;
+      }
+
+    case 'muted':
+      {
+        domElement.muted = value && typeof value !== 'function' && typeof value !== 'symbol';
+        break;
+      }
+
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'defaultValue': // Reserved
+
+    case 'defaultChecked':
+    case 'innerHTML':
+      {
+        // Noop
+        break;
+      }
+
+    case 'autoFocus':
+      {
+        // We polyfill it separately on the client during commit.
+        // We could have excluded it in the property list instead of
+        // adding a special case here, but then it wouldn't be emitted
+        // on server rendering (but we *do* want to emit it in SSR).
+        break;
+      }
+
+    case 'xlinkHref':
+      {
+        if (value == null || typeof value === 'function' || typeof value === 'boolean' || typeof value === 'symbol') {
+          domElement.removeAttribute('xlink:href');
+          break;
+        } // `setAttribute` with objects becomes only `[object]` in IE8/9,
+
+        const sanitizedValue = sanitizeURL('' + value);
+        domElement.setAttributeNS(xlinkNamespace, 'xlink:href', sanitizedValue);
+        break;
+      }
+
+    case 'contentEditable':
+    case 'spellCheck':
+    case 'draggable':
+    case 'value':
+    case 'autoReverse':
+    case 'externalResourcesRequired':
+    case 'focusable':
+    case 'preserveAlpha':
+      {
+        // Booleanish String
+        // These are "enumerated" attributes that accept "true" and "false".
+        // In React, we let users pass `true` and `false` even though technically
+        // these aren't boolean attributes (they are coerced to strings).
+        // The SVG attributes are case-sensitive. Since the HTML attributes are
+        // insensitive they also work even though we canonically use lower case.
+        if (value != null && typeof value !== 'function' && typeof value !== 'symbol') {
+
+          domElement.setAttribute(key, '' + value);
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+    // Boolean
+
+    case 'allowFullScreen':
+    case 'async':
+    case 'autoPlay':
+    case 'controls':
+    case 'default':
+    case 'defer':
+    case 'disabled':
+    case 'disablePictureInPicture':
+    case 'disableRemotePlayback':
+    case 'formNoValidate':
+    case 'hidden':
+    case 'loop':
+    case 'noModule':
+    case 'noValidate':
+    case 'open':
+    case 'playsInline':
+    case 'readOnly':
+    case 'required':
+    case 'reversed':
+    case 'scoped':
+    case 'seamless':
+    case 'itemScope':
+      {
+        if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+          domElement.setAttribute(key, '');
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+    // Overloaded Boolean
+
+    case 'capture':
+    case 'download':
+      {
+        // An attribute that can be used as a flag as well as with a value.
+        // When true, it should be present (set either to an empty string or its name).
+        // When false, it should be omitted.
+        // For any other value, should be present with that value.
+        if (value === true) {
+          domElement.setAttribute(key, '');
+        } else if (value !== false && value != null && typeof value !== 'function' && typeof value !== 'symbol') {
+
+          domElement.setAttribute(key, value);
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+
+    case 'cols':
+    case 'rows':
+    case 'size':
+    case 'span':
+      {
+        // These are HTML attributes that must be positive numbers.
+        if (value != null && typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value) && value >= 1) {
+
+          domElement.setAttribute(key, value);
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+
+    case 'rowSpan':
+    case 'start':
+      {
+        // These are HTML attributes that must be numbers.
+        if (value != null && typeof value !== 'function' && typeof value !== 'symbol' && !isNaN(value)) {
+
+          domElement.setAttribute(key, value);
+        } else {
+          domElement.removeAttribute(key);
+        }
+
+        break;
+      }
+
+    case 'xlinkActuate':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:actuate', value);
+      break;
+
+    case 'xlinkArcrole':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:arcrole', value);
+      break;
+
+    case 'xlinkRole':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:role', value);
+      break;
+
+    case 'xlinkShow':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:show', value);
+      break;
+
+    case 'xlinkTitle':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:title', value);
+      break;
+
+    case 'xlinkType':
+      setValueForNamespacedAttribute(domElement, xlinkNamespace, 'xlink:type', value);
+      break;
+
+    case 'xmlBase':
+      setValueForNamespacedAttribute(domElement, xmlNamespace, 'xml:base', value);
+      break;
+
+    case 'xmlLang':
+      setValueForNamespacedAttribute(domElement, xmlNamespace, 'xml:lang', value);
+      break;
+
+    case 'xmlSpace':
+      setValueForNamespacedAttribute(domElement, xmlNamespace, 'xml:space', value);
+      break;
+    // Properties that should not be allowed on custom elements.
+
+    case 'is':
+      {
+        // passed it to createElement. We don't also need the attribute.
+        // However, our tests currently query for it so it's plausible someone
+        // else does too so it's break.
+
+
+        setValueForAttribute(domElement, 'is', value);
+        break;
+      }
+
+    case 'innerText':
+    case 'textContent':
+
+    // Fall through
+
+    default:
+      {
+        if (key.length > 2 && (key[0] === 'o' || key[0] === 'O') && (key[1] === 'n' || key[1] === 'N')) ; else {
+          const attributeName = getAttributeAlias(key);
+          setValueForAttribute(domElement, attributeName, value);
+        }
+      }
+  }
+}
+
+function setPropOnCustomElement(domElement, tag, key, value, props, prevValue) {
+  switch (key) {
+    case 'style':
+      {
+        setValueForStyles(domElement, value, prevValue);
+        break;
+      }
+
+    case 'dangerouslySetInnerHTML':
+      {
+        if (value != null) {
+          if (typeof value !== 'object' || !('__html' in value)) {
+            throw Error(formatProdErrorMessage(61));
+          }
+
+          const nextHtml = value.__html;
+
+          if (nextHtml != null) {
+            if (props.children != null) {
+              throw Error(formatProdErrorMessage(60));
+            }
+
+            {
+              setInnerHTML$1(domElement, nextHtml);
+            }
+          }
+        }
+
+        break;
+      }
+
+    case 'children':
+      {
+        if (typeof value === 'string') {
+          setTextContent(domElement, value);
+        } else if (typeof value === 'number') {
+          setTextContent(domElement, '' + value);
+        }
+
+        break;
+      }
+
+    case 'onScroll':
+      {
+        if (value != null) {
+
+          listenToNonDelegatedEvent('scroll', domElement);
+        }
+
+        break;
+      }
+
+    case 'onScrollEnd':
+      {
+        if (value != null) {
+
+          listenToNonDelegatedEvent('scrollend', domElement);
+        }
+
+        break;
+      }
+
+    case 'onClick':
+      {
+        // TODO: This cast may not be sound for SVG, MathML or custom elements.
+        if (value != null) {
+
+          trapClickOnNonInteractiveElement(domElement);
+        }
+
+        break;
+      }
+
+    case 'suppressContentEditableWarning':
+    case 'suppressHydrationWarning':
+    case 'innerHTML':
+      {
+        // Noop
+        break;
+      }
+
+    case 'innerText': // Properties
+
+    case 'textContent':
+
+    // Fall through
+
+    default:
+      {
+        if (registrationNameDependencies.hasOwnProperty(key)) ; else {
+          {
+            if (typeof value === 'boolean') {
+              // Special case before the new flag is on
+              value = '' + value;
+            }
+
+            setValueForAttribute(domElement, key, value);
+          }
+        }
+      }
+  }
+}
+
+function setInitialProperties(domElement, tag, props) {
+
+
+  switch (tag) {
+    case 'div':
+    case 'span':
+    case 'svg':
+    case 'path':
+    case 'a':
+    case 'g':
+    case 'p':
+    case 'li':
+      {
+        // Fast track the most common tag types
+        break;
+      }
+
+    case 'input':
+      {
+        // listeners still fire for the invalid event.
+
+
+        listenToNonDelegatedEvent('invalid', domElement);
+        let name = null;
+        let type = null;
+        let value = null;
+        let defaultValue = null;
+        let checked = null;
+        let defaultChecked = null;
+
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'name':
+              {
+                name = propValue;
+                break;
+              }
+
+            case 'type':
+              {
+                type = propValue;
+                break;
+              }
+
+            case 'checked':
+              {
+                checked = propValue;
+                break;
+              }
+
+            case 'defaultChecked':
+              {
+                defaultChecked = propValue;
+                break;
+              }
+
+            case 'value':
+              {
+                value = propValue;
+                break;
+              }
+
+            case 'defaultValue':
+              {
+                defaultValue = propValue;
+                break;
+              }
+
+            case 'children':
+            case 'dangerouslySetInnerHTML':
+              {
+                if (propValue != null) {
+                  throw Error(formatProdErrorMessage(137, tag));
+                }
+
+                break;
+              }
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        } // TODO: Make sure we check if this is still unmounted or do any clean
+        initInput(domElement, value, defaultValue, checked, defaultChecked, type, name, false);
+        track(domElement);
+        return;
+      }
+
+    case 'select':
+      {
+        // listeners still fire for the invalid event.
+
+
+        listenToNonDelegatedEvent('invalid', domElement);
+        let value = null;
+        let defaultValue = null;
+        let multiple = null;
+
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'value':
+              {
+                value = propValue; // This is handled by initSelect below.
+
+                break;
+              }
+
+            case 'defaultValue':
+              {
+                defaultValue = propValue; // This is handled by initSelect below.
+
+                break;
+              }
+
+            case 'multiple':
+              {
+                multiple = propValue; // TODO: We don't actually have to fall through here because we set it
+                // in initSelect anyway. We can remove the special case in setProp.
+              }
+            // Fallthrough
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        }
+        initSelect(domElement, value, defaultValue, multiple);
+        return;
+      }
+
+    case 'textarea':
+      {
+        // listeners still fire for the invalid event.
+
+
+        listenToNonDelegatedEvent('invalid', domElement);
+        let value = null;
+        let defaultValue = null;
+        let children = null;
+
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'value':
+              {
+                value = propValue; // This is handled by initTextarea below.
+
+                break;
+              }
+
+            case 'defaultValue':
+              {
+                defaultValue = propValue;
+                break;
+              }
+
+            case 'children':
+              {
+                children = propValue; // Handled by initTextarea above.
+
+                break;
+              }
+
+            case 'dangerouslySetInnerHTML':
+              {
+                if (propValue != null) {
+                  // TODO: Do we really need a special error message for this. It's also pretty blunt.
+                  throw Error(formatProdErrorMessage(91));
+                }
+
+                break;
+              }
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        } // TODO: Make sure we check if this is still unmounted or do any clean
+        initTextarea(domElement, value, defaultValue, children);
+        track(domElement);
+        return;
+      }
+
+    case 'option':
+      {
+
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'selected':
+              {
+                // TODO: Remove support for selected on option.
+                domElement.selected = propValue && typeof propValue !== 'function' && typeof propValue !== 'symbol';
+                break;
+              }
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        }
+
+        return;
+      }
+
+    case 'dialog':
+      {
+        listenToNonDelegatedEvent('cancel', domElement);
+        listenToNonDelegatedEvent('close', domElement);
+        break;
+      }
+
+    case 'iframe':
+    case 'object':
+      {
+        // We listen to this event in case to ensure emulated bubble
+        // listeners still fire for the load event.
+        listenToNonDelegatedEvent('load', domElement);
+        break;
+      }
+
+    case 'video':
+    case 'audio':
+      {
+        // We listen to these events in case to ensure emulated bubble
+        // listeners still fire for all the media events.
+        for (let i = 0; i < mediaEventTypes.length; i++) {
+          listenToNonDelegatedEvent(mediaEventTypes[i], domElement);
+        }
+
+        break;
+      }
+
+    case 'image':
+      {
+        // We listen to these events in case to ensure emulated bubble
+        // listeners still fire for error and load events.
+        listenToNonDelegatedEvent('error', domElement);
+        listenToNonDelegatedEvent('load', domElement);
+        break;
+      }
+
+    case 'details':
+      {
+        // We listen to this event in case to ensure emulated bubble
+        // listeners still fire for the toggle event.
+        listenToNonDelegatedEvent('toggle', domElement);
+        break;
+      }
+
+    case 'embed':
+    case 'source':
+    case 'img':
+    case 'link':
+      {
+        // These are void elements that also need delegated events.
+        listenToNonDelegatedEvent('error', domElement);
+        listenToNonDelegatedEvent('load', domElement); // We fallthrough to the return of the void elements
+      }
+
+    case 'area':
+    case 'base':
+    case 'br':
+    case 'col':
+    case 'hr':
+    case 'keygen':
+    case 'meta':
+    case 'param':
+    case 'track':
+    case 'wbr':
+    case 'menuitem':
+      {
+        // Void elements
+        for (const propKey in props) {
+          if (!props.hasOwnProperty(propKey)) {
+            continue;
+          }
+
+          const propValue = props[propKey];
+
+          if (propValue == null) {
+            continue;
+          }
+
+          switch (propKey) {
+            case 'children':
+            case 'dangerouslySetInnerHTML':
+              {
+                // TODO: Can we make this a DEV warning to avoid this deny list?
+                throw Error(formatProdErrorMessage(137, tag));
+              }
+            // defaultChecked and defaultValue are ignored by setProp
+
+            default:
+              {
+                setProp(domElement, tag, propKey, propValue, props, null);
+              }
+          }
+        }
+
+        return;
+      }
+
+    default:
+      {
+        if (isCustomElement(tag)) {
+          for (const propKey in props) {
+            if (!props.hasOwnProperty(propKey)) {
+              continue;
+            }
+
+            const propValue = props[propKey];
+
+            if (propValue == null) {
+              continue;
+            }
+
+            setPropOnCustomElement(domElement, tag, propKey, propValue, props, null);
+          }
+
+          return;
+        }
+      }
+  }
+
+  for (const propKey in props) {
+    if (!props.hasOwnProperty(propKey)) {
+      continue;
+    }
+
+    const propValue = props[propKey];
+
+    if (propValue == null) {
+      continue;
+    }
+
+    setProp(domElement, tag, propKey, propValue, props, null);
+  }
+}
+function updateProperties(domElement, tag, lastProps, nextProps) {
+
+  switch (tag) {
+    case 'div':
+    case 'span':
+    case 'svg':
+    case 'path':
+    case 'a':
+    case 'g':
+    case 'p':
+    case 'li':
+      {
+        // Fast track the most common tag types
+        break;
+      }
+
+    case 'input':
+      {
+        let name = null;
+        let type = null;
+        let value = null;
+        let defaultValue = null;
+        let lastDefaultValue = null;
+        let checked = null;
+        let defaultChecked = null;
+
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null) {
+            switch (propKey) {
+              case 'checked':
+                {
+                  break;
+                }
+
+              case 'value':
+                {
+                  // This is handled by updateWrapper below.
+                  break;
+                }
+
+              case 'defaultValue':
+                {
+                  lastDefaultValue = lastProp;
+                }
+              // defaultChecked and defaultValue are ignored by setProp
+              // Fallthrough
+
+              default:
+                {
+                  if (!nextProps.hasOwnProperty(propKey)) setProp(domElement, tag, propKey, null, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'type':
+                {
+                  type = nextProp;
+                  break;
+                }
+
+              case 'name':
+                {
+                  name = nextProp;
+                  break;
+                }
+
+              case 'checked':
+                {
+                  checked = nextProp;
+                  break;
+                }
+
+              case 'defaultChecked':
+                {
+                  defaultChecked = nextProp;
+                  break;
+                }
+
+              case 'value':
+                {
+                  value = nextProp;
+                  break;
+                }
+
+              case 'defaultValue':
+                {
+                  defaultValue = nextProp;
+                  break;
+                }
+
+              case 'children':
+              case 'dangerouslySetInnerHTML':
+                {
+                  if (nextProp != null) {
+                    throw Error(formatProdErrorMessage(137, tag));
+                  }
+
+                  break;
+                }
+
+              default:
+                {
+                  if (nextProp !== lastProp) setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        }
+        // happen after updating the rest of props. Otherwise HTML5 input validations
+        // raise warnings and prevent the new value from being assigned.
+
+
+        updateInput(domElement, value, defaultValue, lastDefaultValue, checked, defaultChecked, type, name);
+        return;
+      }
+
+    case 'select':
+      {
+        let value = null;
+        let defaultValue = null;
+        let multiple = null;
+        let wasMultiple = null;
+
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null) {
+            switch (propKey) {
+              case 'value':
+                {
+                  // This is handled by updateWrapper below.
+                  break;
+                }
+              // defaultValue are ignored by setProp
+
+              case 'multiple':
+                {
+                  wasMultiple = lastProp; // TODO: Move special case in here from setProp.
+                }
+              // Fallthrough
+
+              default:
+                {
+                  if (!nextProps.hasOwnProperty(propKey)) setProp(domElement, tag, propKey, null, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'value':
+                {
+                  value = nextProp; // This is handled by updateSelect below.
+
+                  break;
+                }
+
+              case 'defaultValue':
+                {
+                  defaultValue = nextProp;
+                  break;
+                }
+
+              case 'multiple':
+                {
+                  multiple = nextProp; // TODO: Just move the special case in here from setProp.
+                }
+              // Fallthrough
+
+              default:
+                {
+                  if (nextProp !== lastProp) setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        } // <select> value update needs to occur after <option> children
+        // reconciliation
+
+
+        updateSelect(domElement, value, defaultValue, multiple, wasMultiple);
+        return;
+      }
+
+    case 'textarea':
+      {
+        let value = null;
+        let defaultValue = null;
+
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+            switch (propKey) {
+              case 'value':
+                {
+                  // This is handled by updateTextarea below.
+                  break;
+                }
+
+              case 'children':
+                {
+                  // TODO: This doesn't actually do anything if it updates.
+                  break;
+                }
+              // defaultValue is ignored by setProp
+
+              default:
+                {
+                  setProp(domElement, tag, propKey, null, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'value':
+                {
+                  value = nextProp; // This is handled by updateTextarea below.
+
+                  break;
+                }
+
+              case 'defaultValue':
+                {
+                  defaultValue = nextProp;
+                  break;
+                }
+
+              case 'children':
+                {
+                  // TODO: This doesn't actually do anything if it updates.
+                  break;
+                }
+
+              case 'dangerouslySetInnerHTML':
+                {
+                  if (nextProp != null) {
+                    // TODO: Do we really need a special error message for this. It's also pretty blunt.
+                    throw Error(formatProdErrorMessage(91));
+                  }
+
+                  break;
+                }
+
+              default:
+                {
+                  if (nextProp !== lastProp) setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        updateTextarea(domElement, value, defaultValue);
+        return;
+      }
+
+    case 'option':
+      {
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+            switch (propKey) {
+              case 'selected':
+                {
+                  // TODO: Remove support for selected on option.
+                  domElement.selected = false;
+                  break;
+                }
+
+              default:
+                {
+                  setProp(domElement, tag, propKey, null, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && nextProp !== lastProp && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'selected':
+                {
+                  // TODO: Remove support for selected on option.
+                  domElement.selected = nextProp && typeof nextProp !== 'function' && typeof nextProp !== 'symbol';
+                  break;
+                }
+
+              default:
+                {
+                  setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        return;
+      }
+
+    case 'img':
+    case 'link':
+    case 'area':
+    case 'base':
+    case 'br':
+    case 'col':
+    case 'embed':
+    case 'hr':
+    case 'keygen':
+    case 'meta':
+    case 'param':
+    case 'source':
+    case 'track':
+    case 'wbr':
+    case 'menuitem':
+      {
+        // Void elements
+        for (const propKey in lastProps) {
+          const lastProp = lastProps[propKey];
+
+          if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+            setProp(domElement, tag, propKey, null, nextProps, lastProp);
+          }
+        }
+
+        for (const propKey in nextProps) {
+          const nextProp = nextProps[propKey];
+          const lastProp = lastProps[propKey];
+
+          if (nextProps.hasOwnProperty(propKey) && nextProp !== lastProp && (nextProp != null || lastProp != null)) {
+            switch (propKey) {
+              case 'children':
+              case 'dangerouslySetInnerHTML':
+                {
+                  if (nextProp != null) {
+                    // TODO: Can we make this a DEV warning to avoid this deny list?
+                    throw Error(formatProdErrorMessage(137, tag));
+                  }
+
+                  break;
+                }
+              // defaultChecked and defaultValue are ignored by setProp
+
+              default:
+                {
+                  setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+                }
+            }
+          }
+        }
+
+        return;
+      }
+
+    default:
+      {
+        if (isCustomElement(tag)) {
+          for (const propKey in lastProps) {
+            const lastProp = lastProps[propKey];
+
+            if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+              setPropOnCustomElement(domElement, tag, propKey, null, nextProps, lastProp);
+            }
+          }
+
+          for (const propKey in nextProps) {
+            const nextProp = nextProps[propKey];
+            const lastProp = lastProps[propKey];
+
+            if (nextProps.hasOwnProperty(propKey) && nextProp !== lastProp && (nextProp != null || lastProp != null)) {
+              setPropOnCustomElement(domElement, tag, propKey, nextProp, nextProps, lastProp);
+            }
+          }
+
+          return;
+        }
+      }
+  }
+
+  for (const propKey in lastProps) {
+    const lastProp = lastProps[propKey];
+
+    if (lastProps.hasOwnProperty(propKey) && lastProp != null && !nextProps.hasOwnProperty(propKey)) {
+      setProp(domElement, tag, propKey, null, nextProps, lastProp);
+    }
+  }
+
+  for (const propKey in nextProps) {
+    const nextProp = nextProps[propKey];
+    const lastProp = lastProps[propKey];
+
+    if (nextProps.hasOwnProperty(propKey) && nextProp !== lastProp && (nextProp != null || lastProp != null)) {
+      setProp(domElement, tag, propKey, nextProp, nextProps, lastProp);
+    }
+  }
+}
+
+function diffHydratedProperties(domElement, tag, props, isConcurrentMode, shouldWarnDev, hostContext) {
+
+
+  switch (tag) {
+    case 'dialog':
+      listenToNonDelegatedEvent('cancel', domElement);
+      listenToNonDelegatedEvent('close', domElement);
+      break;
+
+    case 'iframe':
+    case 'object':
+    case 'embed':
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the load event.
+      listenToNonDelegatedEvent('load', domElement);
+      break;
+
+    case 'video':
+    case 'audio':
+      // We listen to these events in case to ensure emulated bubble
+      // listeners still fire for all the media events.
+      for (let i = 0; i < mediaEventTypes.length; i++) {
+        listenToNonDelegatedEvent(mediaEventTypes[i], domElement);
+      }
+
+      break;
+
+    case 'source':
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the error event.
+      listenToNonDelegatedEvent('error', domElement);
+      break;
+
+    case 'img':
+    case 'image':
+    case 'link':
+      // We listen to these events in case to ensure emulated bubble
+      // listeners still fire for error and load events.
+      listenToNonDelegatedEvent('error', domElement);
+      listenToNonDelegatedEvent('load', domElement);
+      break;
+
+    case 'details':
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the toggle event.
+      listenToNonDelegatedEvent('toggle', domElement);
+      break;
+
+    case 'input':
+      // listeners still fire for the invalid event.
+
+
+      listenToNonDelegatedEvent('invalid', domElement); // TODO: Make sure we check if this is still unmounted or do any clean
+      // post mount to force it to diverge from attributes. However, for
+      // option and select we don't quite do the same thing and select
+      // is not resilient to the DOM state changing so we don't do that here.
+      // TODO: Consider not doing this for input and textarea.
+
+      initInput(domElement, props.value, props.defaultValue, props.checked, props.defaultChecked, props.type, props.name, true);
+      track(domElement);
+      break;
+
+    case 'option':
+      break;
+
+    case 'select':
+      // listeners still fire for the invalid event.
+
+
+      listenToNonDelegatedEvent('invalid', domElement);
+      break;
+
+    case 'textarea':
+      // listeners still fire for the invalid event.
+
+
+      listenToNonDelegatedEvent('invalid', domElement); // TODO: Make sure we check if this is still unmounted or do any clean
+      initTextarea(domElement, props.value, props.defaultValue, props.children);
+      track(domElement);
+      break;
+  }
+
+  const children = props.children; // For text content children we compare against textContent. This
+  // might match additional HTML that is hidden when we read it using
+  // textContent. E.g. "foo" will match "f<span>oo</span>" but that still
+  // satisfies our requirement. Our requirement is not to produce perfect
+  // HTML and attributes. Ideally we should preserve structure but it's
+  // ok not to if the visible content is still enough to indicate what
+  // even listeners these nodes might be wired up to.
+  // TODO: Warn if there is more than a single textNode as a child.
+  // TODO: Should we use domElement.firstChild.nodeValue to compare?
+
+  if (typeof children === 'string' || typeof children === 'number') {
+    if (domElement.textContent !== '' + children) {
+      if (props.suppressHydrationWarning !== true) {
+        checkForUnmatchedText(domElement.textContent, children, isConcurrentMode);
+      }
+
+      if (!isConcurrentMode || !enableClientRenderFallbackOnTextMismatch) {
+        // We really should be patching this in the commit phase but since
+        // this only affects legacy mode hydration which is deprecated anyway
+        // we can get away with it.
+        // Host singletons get their children appended and don't use the text
+        // content mechanism.
+        if (tag !== 'body') {
+          domElement.textContent = children;
+        }
+      }
+    }
+  }
+
+  if (props.onScroll != null) {
+    listenToNonDelegatedEvent('scroll', domElement);
+  }
+
+  if (props.onScrollEnd != null) {
+    listenToNonDelegatedEvent('scrollend', domElement);
+  }
+
+  if (props.onClick != null) {
+    // TODO: This cast may not be sound for SVG, MathML or custom elements.
+    trapClickOnNonInteractiveElement(domElement);
+  }
+}
+function diffHydratedText(textNode, text, isConcurrentMode) {
+  const isDifferent = textNode.nodeValue !== text;
+  return isDifferent;
+}
+function restoreControlledState(domElement, tag, props) {
+  switch (tag) {
+    case 'input':
+      restoreControlledInputState(domElement, props);
+      return;
+
+    case 'textarea':
+      restoreControlledTextareaState(domElement, props);
+      return;
+
+    case 'select':
+      restoreControlledSelectState(domElement, props);
+      return;
+  }
+}
+
+const SUPPRESS_HYDRATION_WARNING = 'suppressHydrationWarning';
+const SUSPENSE_START_DATA = '$';
+const SUSPENSE_END_DATA = '/$';
+const SUSPENSE_PENDING_START_DATA = '$?';
+const SUSPENSE_FALLBACK_START_DATA = '$!';
+const FORM_STATE_IS_MATCHING = 'F!';
+const FORM_STATE_IS_NOT_MATCHING = 'F';
+const STYLE = 'style';
+const HostContextNamespaceNone = 0;
+const HostContextNamespaceSvg = 1;
+const HostContextNamespaceMath = 2;
+let eventsEnabled = null;
+let selectionInformation = null;
+
+function getOwnerDocumentFromRootContainer(rootContainerElement) {
+  return rootContainerElement.nodeType === DOCUMENT_NODE ? rootContainerElement : rootContainerElement.ownerDocument;
+}
+
+function getRootHostContext(rootContainerInstance) {
+  let type;
+  let context;
+  const nodeType = rootContainerInstance.nodeType;
+
+  switch (nodeType) {
+    case DOCUMENT_NODE:
+    case DOCUMENT_FRAGMENT_NODE:
+      {
+        type = nodeType === DOCUMENT_NODE ? '#document' : '#fragment';
+        const root = rootContainerInstance.documentElement;
+
+        if (root) {
+          const namespaceURI = root.namespaceURI;
+          context = namespaceURI ? getOwnHostContext(namespaceURI) : HostContextNamespaceNone;
+        } else {
+          context = HostContextNamespaceNone;
+        }
+
+        break;
+      }
+
+    default:
+      {
+        const container = nodeType === COMMENT_NODE ? rootContainerInstance.parentNode : rootContainerInstance;
+        type = container.tagName;
+        const namespaceURI = container.namespaceURI;
+
+        if (!namespaceURI) {
+          switch (type) {
+            case 'svg':
+              context = HostContextNamespaceSvg;
+              break;
+
+            case 'math':
+              context = HostContextNamespaceMath;
+              break;
+
+            default:
+              context = HostContextNamespaceNone;
+              break;
+          }
+        } else {
+          const ownContext = getOwnHostContext(namespaceURI);
+          context = getChildHostContextProd(ownContext, type);
+        }
+
+        break;
+      }
+  }
+
+  return context;
+}
+
+function getOwnHostContext(namespaceURI) {
+  switch (namespaceURI) {
+    case SVG_NAMESPACE:
+      return HostContextNamespaceSvg;
+
+    case MATH_NAMESPACE:
+      return HostContextNamespaceMath;
+
+    default:
+      return HostContextNamespaceNone;
+  }
+}
+
+function getChildHostContextProd(parentNamespace, type) {
+  if (parentNamespace === HostContextNamespaceNone) {
+    // No (or default) parent namespace: potential entry point.
+    switch (type) {
+      case 'svg':
+        return HostContextNamespaceSvg;
+
+      case 'math':
+        return HostContextNamespaceMath;
+
+      default:
+        return HostContextNamespaceNone;
+    }
+  }
+
+  if (parentNamespace === HostContextNamespaceSvg && type === 'foreignObject') {
+    // We're leaving SVG.
+    return HostContextNamespaceNone;
+  } // By default, pass namespace below.
+
+
+  return parentNamespace;
+}
+
+function getChildHostContext(parentHostContext, type) {
+
+  const parentNamespace = parentHostContext;
+  return getChildHostContextProd(parentNamespace, type);
+}
+function getPublicInstance(instance) {
+  return instance;
+}
+function prepareForCommit(containerInfo) {
+  eventsEnabled = isEnabled();
+  selectionInformation = getSelectionInformation();
+  let activeInstance = null;
+
+  setEnabled(false);
+  return activeInstance;
+}
+function resetAfterCommit(containerInfo) {
+  restoreSelection(selectionInformation);
+  setEnabled(eventsEnabled);
+  eventsEnabled = null;
+  selectionInformation = null;
+}
+function createHoistableInstance(type, props, rootContainerInstance, internalInstanceHandle) {
+  const ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
+  const domElement = ownerDocument.createElement(type);
+  precacheFiberNode(internalInstanceHandle, domElement);
+  updateFiberProps(domElement, props);
+  setInitialProperties(domElement, type, props);
+  markNodeAsHoistable(domElement);
+  return domElement;
+}
+function createInstance(type, props, rootContainerInstance, hostContext, internalInstanceHandle) {
+  let hostContextProd;
+
+  {
+    hostContextProd = hostContext;
+  }
+
+  const ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
+  let domElement;
+
+  switch (hostContextProd) {
+    case HostContextNamespaceSvg:
+      domElement = ownerDocument.createElementNS(SVG_NAMESPACE, type);
+      break;
+
+    case HostContextNamespaceMath:
+      domElement = ownerDocument.createElementNS(MATH_NAMESPACE, type);
+      break;
+
+    default:
+      switch (type) {
+        case 'svg':
+          {
+            domElement = ownerDocument.createElementNS(SVG_NAMESPACE, type);
+            break;
+          }
+
+        case 'math':
+          {
+            domElement = ownerDocument.createElementNS(MATH_NAMESPACE, type);
+            break;
+          }
+
+        case 'script':
+          {
+            // Create the script via .innerHTML so its "parser-inserted" flag is
+            // set to true and it does not execute
+            const div = ownerDocument.createElement('div');
+
+            div.innerHTML = '<script><' + '/script>'; // eslint-disable-line
+            // This is guaranteed to yield a script element.
+
+            const firstChild = div.firstChild;
+            domElement = div.removeChild(firstChild);
+            break;
+          }
+
+        case 'select':
+          {
+            if (typeof props.is === 'string') {
+              domElement = ownerDocument.createElement('select', {
+                is: props.is
+              });
+            } else {
+              // Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.
+              // See discussion in https://github.com/facebook/react/pull/6896
+              // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
+              domElement = ownerDocument.createElement('select');
+            }
+
+            if (props.multiple) {
+              domElement.multiple = true;
+            } else if (props.size) {
+              // Setting a size greater than 1 causes a select to behave like `multiple=true`, where
+              // it is possible that no option is selected.
+              //
+              // This is only necessary when a select in "single selection mode".
+              domElement.size = props.size;
+            }
+
+            break;
+          }
+
+        default:
+          {
+            if (typeof props.is === 'string') {
+              domElement = ownerDocument.createElement(type, {
+                is: props.is
+              });
+            } else {
+              // Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.
+              // See discussion in https://github.com/facebook/react/pull/6896
+              // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
+              domElement = ownerDocument.createElement(type);
+            }
+          }
+      }
+
+  }
+
+  precacheFiberNode(internalInstanceHandle, domElement);
+  updateFiberProps(domElement, props);
+  return domElement;
+}
+function appendInitialChild(parentInstance, child) {
+  parentInstance.appendChild(child);
+}
+function finalizeInitialChildren(domElement, type, props, hostContext) {
+  setInitialProperties(domElement, type, props);
+
+  switch (type) {
+    case 'button':
+    case 'input':
+    case 'select':
+    case 'textarea':
+      return !!props.autoFocus;
+
+    case 'img':
+      return true;
+
+    default:
+      return false;
+  }
+}
+function shouldSetTextContent(type, props) {
+  return type === 'textarea' || type === 'noscript' || typeof props.children === 'string' || typeof props.children === 'number' || typeof props.dangerouslySetInnerHTML === 'object' && props.dangerouslySetInnerHTML !== null && props.dangerouslySetInnerHTML.__html != null;
+}
+function createTextInstance(text, rootContainerInstance, hostContext, internalInstanceHandle) {
+
+  const textNode = getOwnerDocumentFromRootContainer(rootContainerInstance).createTextNode(text);
+  precacheFiberNode(internalInstanceHandle, textNode);
+  return textNode;
+}
+function getCurrentEventPriority() {
+  const currentEvent = window.event;
+
+  if (currentEvent === undefined) {
+    return DefaultEventPriority;
+  }
+
+  return getEventPriority(currentEvent.type);
+}
+let currentPopstateTransitionEvent = null;
+function shouldAttemptEagerTransition() {
+  const event = window.event;
+
+  if (event && event.type === 'popstate') {
+    // This is a popstate event. Attempt to render any transition during this
+    // event synchronously. Unless we already attempted during this event.
+    if (event === currentPopstateTransitionEvent) {
+      // We already attempted to render this popstate transition synchronously.
+      // Any subsequent attempts must have happened as the result of a derived
+      // update, like startTransition inside useEffect, or useDV. Switch back to
+      // the default behavior for all remaining transitions during the current
+      // popstate event.
+      return false;
+    } else {
+      // Cache the current event in case a derived transition is scheduled.
+      // (Refer to previous branch.)
+      currentPopstateTransitionEvent = event;
+      return true;
+    }
+  } // We're not inside a popstate event.
+
+
+  currentPopstateTransitionEvent = null;
+  return false;
+}
+// if a component just imports ReactDOM (e.g. for findDOMNode).
+// Some environments might not have setTimeout or clearTimeout.
+
+const scheduleTimeout = typeof setTimeout === 'function' ? setTimeout : undefined;
+const cancelTimeout = typeof clearTimeout === 'function' ? clearTimeout : undefined;
+const noTimeout = -1;
+const localPromise = typeof Promise === 'function' ? Promise : undefined;
+function preparePortalMount(portalInstance) {
+  listenToAllSupportedEvents(portalInstance);
+}
+const scheduleMicrotask = typeof queueMicrotask === 'function' ? queueMicrotask : typeof localPromise !== 'undefined' ? callback => localPromise.resolve(null).then(callback).catch(handleErrorInNextTick) : scheduleTimeout; // TODO: Determine the best fallback here.
+
+function handleErrorInNextTick(error) {
+  setTimeout(() => {
+    throw error;
+  });
+} // -------------------
+function commitMount(domElement, type, newProps, internalInstanceHandle) {
+  // Despite the naming that might imply otherwise, this method only
+  // fires if there is an `Update` effect scheduled during mounting.
+  // This happens if `finalizeInitialChildren` returns `true` (which it
+  // does to implement the `autoFocus` attribute on the client). But
+  // there are also other cases when this might happen (such as patching
+  // up text content during hydration mismatch). So we'll check this again.
+  switch (type) {
+    case 'button':
+    case 'input':
+    case 'select':
+    case 'textarea':
+      if (newProps.autoFocus) {
+        domElement.focus();
+      }
+
+      return;
+
+    case 'img':
+      {
+        if (newProps.src) {
+          domElement.src = newProps.src;
+        }
+
+        return;
+      }
+  }
+}
+function commitUpdate(domElement, updatePayload, type, oldProps, newProps, internalInstanceHandle) {
+  // Diff and update the properties.
+  updateProperties(domElement, type, oldProps, newProps); // Update the props handle so that we know which props are the ones with
+  // with current event handlers.
+
+  updateFiberProps(domElement, newProps);
+}
+function resetTextContent(domElement) {
+  setTextContent(domElement, '');
+}
+function commitTextUpdate(textInstance, oldText, newText) {
+  textInstance.nodeValue = newText;
+}
+function appendChild(parentInstance, child) {
+  parentInstance.appendChild(child);
+}
+function appendChildToContainer(container, child) {
+  let parentNode;
+
+  if (container.nodeType === COMMENT_NODE) {
+    parentNode = container.parentNode;
+    parentNode.insertBefore(child, container);
+  } else {
+    parentNode = container;
+    parentNode.appendChild(child);
+  } // This container might be used for a portal.
+  // If something inside a portal is clicked, that click should bubble
+  // through the React tree. However, on Mobile Safari the click would
+  // never bubble through the *DOM* tree unless an ancestor with onclick
+  // event exists. So we wouldn't see it and dispatch it.
+  // This is why we ensure that non React root containers have inline onclick
+  // defined.
+  // https://github.com/facebook/react/issues/11918
+
+
+  const reactRootContainer = container._reactRootContainer;
+
+  if ((reactRootContainer === null || reactRootContainer === undefined) && parentNode.onclick === null) {
+    // TODO: This cast may not be sound for SVG, MathML or custom elements.
+    trapClickOnNonInteractiveElement(parentNode);
+  }
+}
+function insertBefore(parentInstance, child, beforeChild) {
+  parentInstance.insertBefore(child, beforeChild);
+}
+function insertInContainerBefore(container, child, beforeChild) {
+  if (container.nodeType === COMMENT_NODE) {
+    container.parentNode.insertBefore(child, beforeChild);
+  } else {
+    container.insertBefore(child, beforeChild);
+  }
+}
+
+function removeChild(parentInstance, child) {
+  parentInstance.removeChild(child);
+}
+function removeChildFromContainer(container, child) {
+  if (container.nodeType === COMMENT_NODE) {
+    container.parentNode.removeChild(child);
+  } else {
+    container.removeChild(child);
+  }
+}
+function clearSuspenseBoundary(parentInstance, suspenseInstance) {
+  let node = suspenseInstance; // Delete all nodes within this suspense boundary.
+  // There might be nested nodes so we need to keep track of how
+  // deep we are and only break out when we're back on top.
+
+  let depth = 0;
+
+  do {
+    const nextNode = node.nextSibling;
+    parentInstance.removeChild(node);
+
+    if (nextNode && nextNode.nodeType === COMMENT_NODE) {
+      const data = nextNode.data;
+
+      if (data === SUSPENSE_END_DATA) {
+        if (depth === 0) {
+          parentInstance.removeChild(nextNode); // Retry if any event replaying was blocked on this.
+
+          retryIfBlockedOn(suspenseInstance);
+          return;
+        } else {
+          depth--;
+        }
+      } else if (data === SUSPENSE_START_DATA || data === SUSPENSE_PENDING_START_DATA || data === SUSPENSE_FALLBACK_START_DATA) {
+        depth++;
+      }
+    } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+
+    node = nextNode;
+  } while (node); // TODO: Warn, we didn't find the end comment boundary.
+  // Retry if any event replaying was blocked on this.
+
+
+  retryIfBlockedOn(suspenseInstance);
+}
+function clearSuspenseBoundaryFromContainer(container, suspenseInstance) {
+  if (container.nodeType === COMMENT_NODE) {
+    clearSuspenseBoundary(container.parentNode, suspenseInstance);
+  } else if (container.nodeType === ELEMENT_NODE) {
+    clearSuspenseBoundary(container, suspenseInstance);
+  } else ; // Retry if any event replaying was blocked on this.
+
+
+  retryIfBlockedOn(container);
+}
+function hideInstance(instance) {
+  // TODO: Does this work for all element types? What about MathML? Should we
+  // pass host context to this method?
+  instance = instance;
+  const style = instance.style; // $FlowFixMe[method-unbinding]
+
+  if (typeof style.setProperty === 'function') {
+    style.setProperty('display', 'none', 'important');
+  } else {
+    style.display = 'none';
+  }
+}
+function hideTextInstance(textInstance) {
+  textInstance.nodeValue = '';
+}
+function unhideInstance(instance, props) {
+  instance = instance;
+  const styleProp = props[STYLE];
+  const display = styleProp !== undefined && styleProp !== null && styleProp.hasOwnProperty('display') ? styleProp.display : null;
+  instance.style.display = display == null || typeof display === 'boolean' ? '' : // The value would've errored already if it wasn't safe.
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  ('' + display).trim();
+}
+function unhideTextInstance(textInstance, text) {
+  textInstance.nodeValue = text;
+}
+function clearContainer(container) {
+  {
+    const nodeType = container.nodeType;
+
+    if (nodeType === DOCUMENT_NODE) {
+      clearContainerSparingly(container);
+    } else if (nodeType === ELEMENT_NODE) {
+      switch (container.nodeName) {
+        case 'HEAD':
+        case 'HTML':
+        case 'BODY':
+          clearContainerSparingly(container);
+          return;
+
+        default:
+          {
+            container.textContent = '';
+          }
+      }
+    }
+  }
+}
+
+function clearContainerSparingly(container) {
+  let node;
+  let nextNode = container.firstChild;
+
+  if (nextNode && nextNode.nodeType === DOCUMENT_TYPE_NODE) {
+    nextNode = nextNode.nextSibling;
+  }
+
+  while (nextNode) {
+    node = nextNode;
+    nextNode = nextNode.nextSibling;
+
+    switch (node.nodeName) {
+      case 'HTML':
+      case 'HEAD':
+      case 'BODY':
+        {
+          const element = node;
+          clearContainerSparingly(element); // If these singleton instances had previously been rendered with React they
+          // may still hold on to references to the previous fiber tree. We detatch them
+          // prospectively to reset them to a baseline starting state since we cannot create
+          // new instances.
+
+          detachDeletedInstance(element);
+          continue;
+        }
+      // Script tags are retained to avoid an edge case bug. Normally scripts will execute if they
+      // are ever inserted into the DOM. However when streaming if a script tag is opened but not
+      // yet closed some browsers create and insert the script DOM Node but the script cannot execute
+      // yet until the closing tag is parsed. If something causes React to call clearContainer while
+      // this DOM node is in the document but not yet executable the DOM node will be removed from the
+      // document and when the script closing tag comes in the script will not end up running. This seems
+      // to happen in Chrome/Firefox but not Safari at the moment though this is not necessarily specified
+      // behavior so it could change in future versions of browsers. While leaving all scripts is broader
+      // than strictly necessary this is the least amount of additional code to avoid this breaking
+      // edge case.
+      //
+      // Style tags are retained because they may likely come from 3rd party scripts and extensions
+
+      case 'SCRIPT':
+      case 'STYLE':
+        {
+          continue;
+        }
+      // Stylesheet tags are retained because tehy may likely come from 3rd party scripts and extensions
+
+      case 'LINK':
+        {
+          if (node.rel.toLowerCase() === 'stylesheet') {
+            continue;
+          }
+        }
+    }
+
+    container.removeChild(node);
+  }
+
+  return;
+} // Making this so we can eventually move all of the instance caching to the commit phase.
+function isHydratableText(text) {
+  return text !== '';
+}
+function canHydrateInstance(instance, type, props, inRootOrSingleton) {
+  while (instance.nodeType === ELEMENT_NODE) {
+    const element = instance;
+    const anyProps = props;
+
+    if (element.nodeName.toLowerCase() !== type.toLowerCase()) {
+      if (!inRootOrSingleton || !enableHostSingletons) {
+        // Usually we error for mismatched tags.
+        if (element.nodeName === 'INPUT' && element.type === 'hidden') ; else {
+          return null;
+        }
+      } // In root or singleton parents we skip past mismatched instances.
+
+    } else if (!inRootOrSingleton || !enableHostSingletons) {
+      // Match
+      if (type === 'input' && element.type === 'hidden') {
+
+        const name = anyProps.name == null ? null : '' + anyProps.name;
+
+        if (anyProps.type !== 'hidden' || element.getAttribute('name') !== name) ; else {
+          return element;
+        }
+      } else {
+        return element;
+      }
+    } else if (isMarkedHoistable(element)) ; else {
+      // We have an Element with the right type.
+      // We are going to try to exclude it if we can definitely identify it as a hoisted Node or if
+      // we can guess that the node is likely hoisted or was inserted by a 3rd party script or browser extension
+      // using high entropy attributes for certain types. This technique will fail for strange insertions like
+      // extension prepending <div> in the <body> but that already breaks before and that is an edge case.
+      switch (type) {
+        // case 'title':
+        //We assume all titles are matchable. You should only have one in the Document, at least in a hoistable scope
+        // and if you are a HostComponent with type title we must either be in an <svg> context or this title must have an `itemProp` prop.
+        case 'meta':
+          {
+            // The only way to opt out of hoisting meta tags is to give it an itemprop attribute. We assume there will be
+            // not 3rd party meta tags that are prepended, accepting the cases where this isn't true because meta tags
+            // are usually only functional for SSR so even in a rare case where we did bind to an injected tag the runtime
+            // implications are minimal
+            if (!element.hasAttribute('itemprop')) {
+              // This is a Hoistable
+              break;
+            }
+
+            return element;
+          }
+
+        case 'link':
+          {
+            // Links come in many forms and we do expect 3rd parties to inject them into <head> / <body>. We exclude known resources
+            // and then use high-entroy attributes like href which are almost always used and almost always unique to filter out unlikely
+            // matches.
+            const rel = element.getAttribute('rel');
+
+            if (rel === 'stylesheet' && element.hasAttribute('data-precedence')) {
+              // This is a stylesheet resource
+              break;
+            } else if (rel !== anyProps.rel || element.getAttribute('href') !== (anyProps.href == null ? null : anyProps.href) || element.getAttribute('crossorigin') !== (anyProps.crossOrigin == null ? null : anyProps.crossOrigin) || element.getAttribute('title') !== (anyProps.title == null ? null : anyProps.title)) {
+              // rel + href should usually be enough to uniquely identify a link however crossOrigin can vary for rel preconnect
+              // and title could vary for rel alternate
+              break;
+            }
+
+            return element;
+          }
+
+        case 'style':
+          {
+            // Styles are hard to match correctly. We can exclude known resources but otherwise we accept the fact that a non-hoisted style tags
+            // in <head> or <body> are likely never going to be unmounted given their position in the document and the fact they likely hold global styles
+            if (element.hasAttribute('data-precedence')) {
+              // This is a style resource
+              break;
+            }
+
+            return element;
+          }
+
+        case 'script':
+          {
+            // Scripts are a little tricky, we exclude known resources and then similar to links try to use high-entropy attributes
+            // to reject poor matches. One challenge with scripts are inline scripts. We don't attempt to check text content which could
+            // in theory lead to a hydration error later if a 3rd party injected an inline script before the React rendered nodes.
+            // Falling back to client rendering if this happens should be seemless though so we will try this hueristic and revisit later
+            // if we learn it is problematic
+            const srcAttr = element.getAttribute('src');
+
+            if (srcAttr !== (anyProps.src == null ? null : anyProps.src) || element.getAttribute('type') !== (anyProps.type == null ? null : anyProps.type) || element.getAttribute('crossorigin') !== (anyProps.crossOrigin == null ? null : anyProps.crossOrigin)) {
+              // This script is for a different src/type/crossOrigin. It may be a script resource
+              // or it may just be a mistmatch
+              if (srcAttr && element.hasAttribute('async') && !element.hasAttribute('itemprop')) {
+                // This is an async script resource
+                break;
+              }
+            }
+
+            return element;
+          }
+
+        default:
+          {
+            // We have excluded the most likely cases of mismatch between hoistable tags, 3rd party script inserted tags,
+            // and browser extension inserted tags. While it is possible this is not the right match it is a decent hueristic
+            // that should work in the vast majority of cases.
+            return element;
+          }
+      }
+    }
+
+    const nextInstance = getNextHydratableSibling(element);
+
+    if (nextInstance === null) {
+      break;
+    }
+
+    instance = nextInstance;
+  } // This is a suspense boundary or Text node or we got the end.
+  // Suspense Boundaries are never expected to be injected by 3rd parties. If we see one it should be matched
+  // and this is a hydration error.
+  // Text Nodes are also not expected to be injected by 3rd parties. This is less of a guarantee for <body>
+  // but it seems reasonable and conservative to reject this as a hydration error as well
+
+
+  return null;
+}
+function canHydrateTextInstance(instance, text, inRootOrSingleton) {
+  // Empty strings are not parsed by HTML so there won't be a correct match here.
+  if (text === '') return null;
+
+  while (instance.nodeType !== TEXT_NODE) {
+    if (instance.nodeType === ELEMENT_NODE && instance.nodeName === 'INPUT' && instance.type === 'hidden') ; else if (!inRootOrSingleton || !enableHostSingletons) {
+      return null;
+    }
+
+    const nextInstance = getNextHydratableSibling(instance);
+
+    if (nextInstance === null) {
+      return null;
+    }
+
+    instance = nextInstance;
+  } // This has now been refined to a text node.
+
+
+  return instance;
+}
+function canHydrateSuspenseInstance(instance, inRootOrSingleton) {
+  while (instance.nodeType !== COMMENT_NODE) {
+    if (!inRootOrSingleton || !enableHostSingletons) {
+      return null;
+    }
+
+    const nextInstance = getNextHydratableSibling(instance);
+
+    if (nextInstance === null) {
+      return null;
+    }
+
+    instance = nextInstance;
+  } // This has now been refined to a suspense node.
+
+
+  return instance;
+}
+function isSuspenseInstancePending(instance) {
+  return instance.data === SUSPENSE_PENDING_START_DATA;
+}
+function isSuspenseInstanceFallback(instance) {
+  return instance.data === SUSPENSE_FALLBACK_START_DATA;
+}
+function getSuspenseInstanceFallbackErrorDetails(instance) {
+  const dataset = instance.nextSibling && instance.nextSibling.dataset;
+  let digest;
+
+  if (dataset) {
+    digest = dataset.dgst;
+  }
+
+  {
+    // Object gets DCE'd if constructed in tail position and matches callsite destructuring
+    return {
+      digest
+    };
+  }
+}
+function registerSuspenseInstanceRetry(instance, callback) {
+  instance._reactRetry = callback;
+}
+function canHydrateFormStateMarker(instance, inRootOrSingleton) {
+  while (instance.nodeType !== COMMENT_NODE) {
+    if (!inRootOrSingleton || !enableHostSingletons) {
+      return null;
+    }
+
+    const nextInstance = getNextHydratableSibling(instance);
+
+    if (nextInstance === null) {
+      return null;
+    }
+
+    instance = nextInstance;
+  }
+
+  const nodeData = instance.data;
+
+  if (nodeData === FORM_STATE_IS_MATCHING || nodeData === FORM_STATE_IS_NOT_MATCHING) {
+    const markerInstance = instance;
+    return markerInstance;
+  }
+
+  return null;
+}
+function isFormStateMarkerMatching(markerInstance) {
+  return markerInstance.data === FORM_STATE_IS_MATCHING;
+}
+
+function getNextHydratable(node) {
+  // Skip non-hydratable nodes.
+  for (; node != null; node = node.nextSibling) {
+    const nodeType = node.nodeType;
+
+    if (nodeType === ELEMENT_NODE || nodeType === TEXT_NODE) {
+      break;
+    }
+
+    if (nodeType === COMMENT_NODE) {
+      const nodeData = node.data;
+
+      if (nodeData === SUSPENSE_START_DATA || nodeData === SUSPENSE_FALLBACK_START_DATA || nodeData === SUSPENSE_PENDING_START_DATA || (nodeData === FORM_STATE_IS_MATCHING || nodeData === FORM_STATE_IS_NOT_MATCHING)) {
+        break;
+      }
+
+      if (nodeData === SUSPENSE_END_DATA) {
+        return null;
+      }
+    }
+  }
+
+  return node;
+}
+
+function getNextHydratableSibling(instance) {
+  return getNextHydratable(instance.nextSibling);
+}
+function getFirstHydratableChild(parentInstance) {
+  return getNextHydratable(parentInstance.firstChild);
+}
+function getFirstHydratableChildWithinContainer(parentContainer) {
+  return getNextHydratable(parentContainer.firstChild);
+}
+function getFirstHydratableChildWithinSuspenseInstance(parentInstance) {
+  return getNextHydratable(parentInstance.nextSibling);
+}
+function hydrateInstance(instance, type, props, hostContext, internalInstanceHandle, shouldWarnDev) {
+  precacheFiberNode(internalInstanceHandle, instance); // TODO: Possibly defer this until the commit phase where all the events
+  // get attached.
+
+  updateFiberProps(instance, props); // TODO: Temporary hack to check if we're in a concurrent root. We can delete
+  // when the legacy root API is removed.
+
+  const isConcurrentMode = (internalInstanceHandle.mode & ConcurrentMode) !== NoMode;
+  diffHydratedProperties(instance, type, props, isConcurrentMode);
+}
+function hydrateTextInstance(textInstance, text, internalInstanceHandle, shouldWarnDev) {
+  precacheFiberNode(internalInstanceHandle, textInstance); // TODO: Temporary hack to check if we're in a concurrent root. We can delete
+  return diffHydratedText(textInstance, text);
+}
+function hydrateSuspenseInstance(suspenseInstance, internalInstanceHandle) {
+  precacheFiberNode(internalInstanceHandle, suspenseInstance);
+}
+function getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance) {
+  let node = suspenseInstance.nextSibling; // Skip past all nodes within this suspense boundary.
+  // There might be nested nodes so we need to keep track of how
+  // deep we are and only break out when we're back on top.
+
+  let depth = 0;
+
+  while (node) {
+    if (node.nodeType === COMMENT_NODE) {
+      const data = node.data;
+
+      if (data === SUSPENSE_END_DATA) {
+        if (depth === 0) {
+          return getNextHydratableSibling(node);
+        } else {
+          depth--;
+        }
+      } else if (data === SUSPENSE_START_DATA || data === SUSPENSE_FALLBACK_START_DATA || data === SUSPENSE_PENDING_START_DATA) {
+        depth++;
+      }
+    }
+
+    node = node.nextSibling;
+  } // TODO: Warn, we didn't find the end comment boundary.
+
+
+  return null;
+} // Returns the SuspenseInstance if this node is a direct child of a
+// SuspenseInstance. I.e. if its previous sibling is a Comment with
+// SUSPENSE_x_START_DATA. Otherwise, null.
+
+function getParentSuspenseInstance(targetInstance) {
+  let node = targetInstance.previousSibling; // Skip past all nodes within this suspense boundary.
+  // There might be nested nodes so we need to keep track of how
+  // deep we are and only break out when we're back on top.
+
+  let depth = 0;
+
+  while (node) {
+    if (node.nodeType === COMMENT_NODE) {
+      const data = node.data;
+
+      if (data === SUSPENSE_START_DATA || data === SUSPENSE_FALLBACK_START_DATA || data === SUSPENSE_PENDING_START_DATA) {
+        if (depth === 0) {
+          return node;
+        } else {
+          depth--;
+        }
+      } else if (data === SUSPENSE_END_DATA) {
+        depth++;
+      }
+    }
+
+    node = node.previousSibling;
+  }
+
+  return null;
+}
+function commitHydratedContainer(container) {
+  // Retry if any event replaying was blocked on this.
+  retryIfBlockedOn(container);
+}
+function commitHydratedSuspenseInstance(suspenseInstance) {
+  // Retry if any event replaying was blocked on this.
+  retryIfBlockedOn(suspenseInstance);
+}
+function shouldDeleteUnhydratedTailInstances(parentType) {
+  return (parentType !== 'form' && parentType !== 'button');
+}
+function didNotMatchHydratedContainerTextInstance(parentContainer, textInstance, text, isConcurrentMode, shouldWarnDev) {
+  checkForUnmatchedText(textInstance.nodeValue, text, isConcurrentMode);
+}
+function didNotMatchHydratedTextInstance(parentType, parentProps, parentInstance, textInstance, text, isConcurrentMode, shouldWarnDev) {
+  if (parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
+    checkForUnmatchedText(textInstance.nodeValue, text, isConcurrentMode);
+  }
+}
+function isHostSingletonType(type) {
+  return type === 'html' || type === 'head' || type === 'body';
+}
+function resolveSingletonInstance(type, props, rootContainerInstance, hostContext, validateDOMNestingDev) {
+
+  const ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
+
+  switch (type) {
+    case 'html':
+      {
+        const documentElement = ownerDocument.documentElement;
+
+        if (!documentElement) {
+          throw Error(formatProdErrorMessage(452));
+        }
+
+        return documentElement;
+      }
+
+    case 'head':
+      {
+        const head = ownerDocument.head;
+
+        if (!head) {
+          throw Error(formatProdErrorMessage(453));
+        }
+
+        return head;
+      }
+
+    case 'body':
+      {
+        const body = ownerDocument.body;
+
+        if (!body) {
+          throw Error(formatProdErrorMessage(454));
+        }
+
+        return body;
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(451));
+      }
+  }
+}
+function acquireSingletonInstance(type, props, instance, internalInstanceHandle) {
+
+  const attributes = instance.attributes;
+
+  while (attributes.length) {
+    instance.removeAttributeNode(attributes[0]);
+  }
+
+  setInitialProperties(instance, type, props);
+  precacheFiberNode(internalInstanceHandle, instance);
+  updateFiberProps(instance, props);
+}
+function releaseSingletonInstance(instance) {
+  const attributes = instance.attributes;
+
+  while (attributes.length) {
+    instance.removeAttributeNode(attributes[0]);
+  }
+
+  detachDeletedInstance(instance);
+}
+function clearSingleton(instance) {
+  const element = instance;
+  let node = element.firstChild;
+
+  while (node) {
+    const nextNode = node.nextSibling;
+    const nodeName = node.nodeName;
+
+    if (isMarkedHoistable(node) || nodeName === 'HEAD' || nodeName === 'BODY' || nodeName === 'SCRIPT' || nodeName === 'STYLE' || nodeName === 'LINK' && node.rel.toLowerCase() === 'stylesheet') ; else {
+      element.removeChild(node);
+    }
+
+    node = nextNode;
+  }
+
+  return;
+} // -------------------
+const NotLoaded =
+/*       */
+0b000;
+const Loaded =
+/*          */
+0b001;
+const Errored =
+/*         */
+0b010;
+const Settled =
+/*         */
+0b011;
+const Inserted =
+/*        */
+0b100;
+function prepareToCommitHoistables() {
+  tagCaches = null;
+} // global collections of Resources
+
+const preloadPropsMap = new Map();
+const preconnectsSet = new Set(); // getRootNode is missing from IE and old jsdom versions
+
+function getHoistableRoot(container) {
+  // $FlowFixMe[method-unbinding]
+  return typeof container.getRootNode === 'function' ?
+  /* $FlowFixMe[incompatible-return] Flow types this as returning a `Node`,
+   * but it's either a `Document` or `ShadowRoot`. */
+  container.getRootNode() : container.ownerDocument;
+}
+
+function getCurrentResourceRoot() {
+  const currentContainer = getCurrentRootHostContainer();
+  return currentContainer ? getHoistableRoot(currentContainer) : null;
+}
+
+function getDocumentFromRoot(root) {
+  return root.ownerDocument || root;
+} // We want this to be the default dispatcher on ReactDOMSharedInternals but we don't want to mutate
+// internals in Module scope. Instead we export it and Internals will import it. There is already a cycle
+// from Internals -> ReactDOM -> HostConfig -> Internals so this doesn't introduce a new one.
+
+
+const ReactDOMClientDispatcher = {
+  prefetchDNS: prefetchDNS$1,
+  preconnect: preconnect$1,
+  preload: preload$1,
+  preloadModule: preloadModule$1,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+}; // We expect this to get inlined. It is a function mostly to communicate the special nature of
+// how we resolve the HoistableRoot for ReactDOM.pre*() methods. Because we support calling
+// these methods outside of render there is no way to know which Document or ShadowRoot is 'scoped'
+// and so we have to fall back to something universal. Currently we just refer to the global document.
+// This is notable because nowhere else in ReactDOM do we actually reference the global document or window
+// because we may be rendering inside an iframe.
+
+function getDocumentForImperativeFloatMethods() {
+  return document;
+}
+
+function preconnectAs(rel, href, crossOrigin) {
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (typeof href === 'string' && href) {
+    const limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+    let key = "link[rel=\"" + rel + "\"][href=\"" + limitedEscapedHref + "\"]";
+
+    if (typeof crossOrigin === 'string') {
+      key += "[crossorigin=\"" + crossOrigin + "\"]";
+    }
+
+    if (!preconnectsSet.has(key)) {
+      preconnectsSet.add(key);
+      const preconnectProps = {
+        rel,
+        crossOrigin,
+        href
+      };
+
+      if (null === ownerDocument.querySelector(key)) {
+        const instance = ownerDocument.createElement('link');
+        setInitialProperties(instance, 'link', preconnectProps);
+        markNodeAsHoistable(instance);
+        ownerDocument.head.appendChild(instance);
+      }
+    }
+  }
+}
+
+function prefetchDNS$1(href) {
+
+  preconnectAs('dns-prefetch', href, null);
+}
+
+function preconnect$1(href, crossOrigin) {
+
+  preconnectAs('preconnect', href, crossOrigin);
+}
+
+function preload$1(href, as, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (href && as && ownerDocument) {
+    let preloadSelector = "link[rel=\"preload\"][as=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(as) + "\"]";
+
+    if (as === 'image') {
+      if (options && options.imageSrcSet) {
+        preloadSelector += "[imagesrcset=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(options.imageSrcSet) + "\"]";
+
+        if (typeof options.imageSizes === 'string') {
+          preloadSelector += "[imagesizes=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(options.imageSizes) + "\"]";
+        }
+      } else {
+        preloadSelector += "[href=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(href) + "\"]";
+      }
+    } else {
+      preloadSelector += "[href=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(href) + "\"]";
+    } // Some preloads are keyed under their selector. This happens when the preload is for
+    // an arbitrary type. Other preloads are keyed under the resource key they represent a preload for.
+    // Here we figure out which key to use to determine if we have a preload already.
+
+
+    let key = preloadSelector;
+
+    switch (as) {
+      case 'style':
+        key = getStyleKey(href);
+        break;
+
+      case 'script':
+        key = getScriptKey(href);
+        break;
+    }
+
+    if (!preloadPropsMap.has(key)) {
+      const preloadProps = assign({
+        rel: 'preload',
+        // There is a bug in Safari where imageSrcSet is not respected on preload links
+        // so we omit the href here if we have imageSrcSet b/c safari will load the wrong image.
+        // This harms older browers that do not support imageSrcSet by making their preloads not work
+        // but this population is shrinking fast and is already small so we accept this tradeoff.
+        href: as === 'image' && options && options.imageSrcSet ? undefined : href,
+        as
+      }, options);
+
+      preloadPropsMap.set(key, preloadProps);
+
+      if (null === ownerDocument.querySelector(preloadSelector)) {
+        if (as === 'style' && ownerDocument.querySelector(getStylesheetSelectorFromKey(key))) {
+          // We already have a stylesheet for this key. We don't need to preload it.
+          return;
+        } else if (as === 'script' && ownerDocument.querySelector(getScriptSelectorFromKey(key))) {
+          // We already have a stylesheet for this key. We don't need to preload it.
+          return;
+        }
+
+        const instance = ownerDocument.createElement('link');
+        setInitialProperties(instance, 'link', preloadProps);
+        markNodeAsHoistable(instance);
+        ownerDocument.head.appendChild(instance);
+      }
+    }
+  }
+}
+
+function preloadModule$1(href, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (href) {
+    const as = options && typeof options.as === 'string' ? options.as : 'script';
+    const preloadSelector = "link[rel=\"modulepreload\"][as=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(as) + "\"][href=\"" + escapeSelectorAttributeValueInsideDoubleQuotes(href) + "\"]"; // Some preloads are keyed under their selector. This happens when the preload is for
+    // an arbitrary type. Other preloads are keyed under the resource key they represent a preload for.
+    // Here we figure out which key to use to determine if we have a preload already.
+
+    let key = preloadSelector;
+
+    switch (as) {
+      case 'audioworklet':
+      case 'paintworklet':
+      case 'serviceworker':
+      case 'sharedworker':
+      case 'worker':
+      case 'script':
+        {
+          key = getScriptKey(href);
+          break;
+        }
+    }
+
+    if (!preloadPropsMap.has(key)) {
+      const props = assign({
+        rel: 'modulepreload',
+        href
+      }, options);
+
+      preloadPropsMap.set(key, props);
+
+      if (null === ownerDocument.querySelector(preloadSelector)) {
+        switch (as) {
+          case 'audioworklet':
+          case 'paintworklet':
+          case 'serviceworker':
+          case 'sharedworker':
+          case 'worker':
+          case 'script':
+            {
+              if (ownerDocument.querySelector(getScriptSelectorFromKey(key))) {
+                return;
+              }
+            }
+        }
+
+        const instance = ownerDocument.createElement('link');
+        setInitialProperties(instance, 'link', props);
+        markNodeAsHoistable(instance);
+        ownerDocument.head.appendChild(instance);
+      }
+    }
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (href) {
+    const styles = getResourcesFromRoot(ownerDocument).hoistableStyles;
+    const key = getStyleKey(href);
+    precedence = precedence || 'default'; // Check if this resource already exists
+
+    let resource = styles.get(key);
+
+    if (resource) {
+      // We can early return. The resource exists and there is nothing
+      // more to do
+      return;
+    }
+
+    const state = {
+      loading: NotLoaded,
+      preload: null
+    }; // Attempt to hydrate instance from DOM
+
+    let instance = ownerDocument.querySelector(getStylesheetSelectorFromKey(key));
+
+    if (instance) {
+      state.loading = Loaded | Inserted;
+    } else {
+      // Construct a new instance and insert it
+      const stylesheetProps = assign({
+        rel: 'stylesheet',
+        href,
+        'data-precedence': precedence
+      }, options);
+
+      const preloadProps = preloadPropsMap.get(key);
+
+      if (preloadProps) {
+        adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps);
+      }
+
+      const link = instance = ownerDocument.createElement('link');
+      markNodeAsHoistable(link);
+      setInitialProperties(link, 'link', stylesheetProps);
+      link._p = new Promise((resolve, reject) => {
+        link.onload = resolve;
+        link.onerror = reject;
+      });
+      link.addEventListener('load', () => {
+        state.loading |= Loaded;
+      });
+      link.addEventListener('error', () => {
+        state.loading |= Errored;
+      });
+      state.loading |= Inserted;
+      insertStylesheet(instance, precedence, ownerDocument);
+    } // Construct a Resource and cache it
+
+
+    resource = {
+      type: 'stylesheet',
+      instance,
+      count: 1,
+      state
+    };
+    styles.set(key, resource);
+    return;
+  }
+}
+
+function preinitScript(src, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (src) {
+    const scripts = getResourcesFromRoot(ownerDocument).hoistableScripts;
+    const key = getScriptKey(src); // Check if this resource already exists
+
+    let resource = scripts.get(key);
+
+    if (resource) {
+      // We can early return. The resource exists and there is nothing
+      // more to do
+      return;
+    } // Attempt to hydrate instance from DOM
+
+
+    let instance = ownerDocument.querySelector(getScriptSelectorFromKey(key));
+
+    if (!instance) {
+      // Construct a new instance and insert it
+      const scriptProps = assign({
+        src,
+        async: true
+      }, options); // Adopt certain preload props
+
+
+      const preloadProps = preloadPropsMap.get(key);
+
+      if (preloadProps) {
+        adoptPreloadPropsForScript(scriptProps, preloadProps);
+      }
+
+      instance = ownerDocument.createElement('script');
+      markNodeAsHoistable(instance);
+      setInitialProperties(instance, 'link', scriptProps);
+      ownerDocument.head.appendChild(instance);
+    } // Construct a Resource and cache it
+
+
+    resource = {
+      type: 'script',
+      instance,
+      count: 1,
+      state: null
+    };
+    scripts.set(key, resource);
+    return;
+  }
+}
+
+function preinitModuleScript(src, options) {
+
+  const ownerDocument = getDocumentForImperativeFloatMethods();
+
+  if (src) {
+    const scripts = getResourcesFromRoot(ownerDocument).hoistableScripts;
+    const key = getScriptKey(src); // Check if this resource already exists
+
+    let resource = scripts.get(key);
+
+    if (resource) {
+      // We can early return. The resource exists and there is nothing
+      // more to do
+      return;
+    } // Attempt to hydrate instance from DOM
+
+
+    let instance = ownerDocument.querySelector(getScriptSelectorFromKey(key));
+
+    if (!instance) {
+      // Construct a new instance and insert it
+      const scriptProps = assign({
+        src,
+        async: true,
+        type: 'module'
+      }, options); // Adopt certain preload props
+
+
+      const preloadProps = preloadPropsMap.get(key);
+
+      if (preloadProps) {
+        adoptPreloadPropsForScript(scriptProps, preloadProps);
+      }
+
+      instance = ownerDocument.createElement('script');
+      markNodeAsHoistable(instance);
+      setInitialProperties(instance, 'link', scriptProps);
+      ownerDocument.head.appendChild(instance);
+    } // Construct a Resource and cache it
+
+
+    resource = {
+      type: 'script',
+      instance,
+      count: 1,
+      state: null
+    };
+    scripts.set(key, resource);
+    return;
+  }
+} // This function is called in begin work and we should always have a currentDocument set
+
+
+function getResource(type, currentProps, pendingProps) {
+  const resourceRoot = getCurrentResourceRoot();
+
+  if (!resourceRoot) {
+    throw Error(formatProdErrorMessage(446));
+  }
+
+  switch (type) {
+    case 'meta':
+    case 'title':
+      {
+        return null;
+      }
+
+    case 'style':
+      {
+        if (typeof pendingProps.precedence === 'string' && typeof pendingProps.href === 'string') {
+          const key = getStyleKey(pendingProps.href);
+          const styles = getResourcesFromRoot(resourceRoot).hoistableStyles;
+          let resource = styles.get(key);
+
+          if (!resource) {
+            resource = {
+              type: 'style',
+              instance: null,
+              count: 0,
+              state: null
+            };
+            styles.set(key, resource);
+          }
+
+          return resource;
+        }
+
+        return {
+          type: 'void',
+          instance: null,
+          count: 0,
+          state: null
+        };
+      }
+
+    case 'link':
+      {
+        if (pendingProps.rel === 'stylesheet' && typeof pendingProps.href === 'string' && typeof pendingProps.precedence === 'string') {
+          const qualifiedProps = pendingProps;
+          const key = getStyleKey(qualifiedProps.href);
+          const styles = getResourcesFromRoot(resourceRoot).hoistableStyles;
+          let resource = styles.get(key);
+
+          if (!resource) {
+            // We asserted this above but Flow can't figure out that the type satisfies
+            const ownerDocument = getDocumentFromRoot(resourceRoot);
+            resource = {
+              type: 'stylesheet',
+              instance: null,
+              count: 0,
+              state: {
+                loading: NotLoaded,
+                preload: null
+              }
+            };
+            styles.set(key, resource);
+
+            if (!preloadPropsMap.has(key)) {
+              preloadStylesheet(ownerDocument, key, preloadPropsFromStylesheet(qualifiedProps), resource.state);
+            }
+          }
+
+          return resource;
+        }
+
+        return null;
+      }
+
+    case 'script':
+      {
+        if (typeof pendingProps.src === 'string' && pendingProps.async === true) {
+          const scriptProps = pendingProps;
+          const key = getScriptKey(scriptProps.src);
+          const scripts = getResourcesFromRoot(resourceRoot).hoistableScripts;
+          let resource = scripts.get(key);
+
+          if (!resource) {
+            resource = {
+              type: 'script',
+              instance: null,
+              count: 0,
+              state: null
+            };
+            scripts.set(key, resource);
+          }
+
+          return resource;
+        }
+
+        return {
+          type: 'void',
+          instance: null,
+          count: 0,
+          state: null
+        };
+      }
+
+    default:
+      {
+        throw Error(formatProdErrorMessage(444, type));
+      }
+  }
+}
+
+function styleTagPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    'data-href': rawProps.href,
+    'data-precedence': rawProps.precedence,
+    href: null,
+    precedence: null
+  });
+}
+
+function getStyleKey(href) {
+  const limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+  return "href=\"" + limitedEscapedHref + "\"";
+}
+
+function getStyleTagSelector(href) {
+  const limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+  return "style[data-href~=\"" + limitedEscapedHref + "\"]";
+}
+
+function getStylesheetSelectorFromKey(key) {
+  return "link[rel=\"stylesheet\"][" + key + "]";
+}
+
+function getPreloadStylesheetSelectorFromKey(key) {
+  return "link[rel=\"preload\"][as=\"style\"][" + key + "]";
+}
+
+function stylesheetPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    'data-precedence': rawProps.precedence,
+    precedence: null
+  });
+}
+
+function preloadStylesheet(ownerDocument, key, preloadProps, state) {
+  preloadPropsMap.set(key, preloadProps);
+
+  if (!ownerDocument.querySelector(getStylesheetSelectorFromKey(key))) {
+    // There is no matching stylesheet instance in the Document.
+    // We will insert a preload now to kick off loading because
+    // we expect this stylesheet to commit
+    const preloadEl = ownerDocument.querySelector(getPreloadStylesheetSelectorFromKey(key));
+
+    if (preloadEl) {
+      // If we find a preload already it was SSR'd and we won't have an actual
+      // loading state to track. For now we will just assume it is loaded
+      state.loading = Loaded;
+    } else {
+      const instance = ownerDocument.createElement('link');
+      state.preload = instance;
+      instance.addEventListener('load', () => state.loading |= Loaded);
+      instance.addEventListener('error', () => state.loading |= Errored);
+      setInitialProperties(instance, 'link', preloadProps);
+      markNodeAsHoistable(instance);
+      ownerDocument.head.appendChild(instance);
+    }
+  }
+}
+
+function preloadPropsFromStylesheet(props) {
+  return {
+    rel: 'preload',
+    as: 'style',
+    href: props.href,
+    crossOrigin: props.crossOrigin,
+    integrity: props.integrity,
+    media: props.media,
+    hrefLang: props.hrefLang,
+    referrerPolicy: props.referrerPolicy
+  };
+}
+
+function getScriptKey(src) {
+  const limitedEscapedSrc = escapeSelectorAttributeValueInsideDoubleQuotes(src);
+  return "[src=\"" + limitedEscapedSrc + "\"]";
+}
+
+function getScriptSelectorFromKey(key) {
+  return 'script[async]' + key;
+}
+
+function acquireResource(hoistableRoot, resource, props) {
+  resource.count++;
+
+  if (resource.instance === null) {
+    switch (resource.type) {
+      case 'style':
+        {
+          const qualifiedProps = props; // Attempt to hydrate instance from DOM
+
+          let instance = hoistableRoot.querySelector(getStyleTagSelector(qualifiedProps.href));
+
+          if (instance) {
+            resource.instance = instance;
+            markNodeAsHoistable(instance);
+            return instance;
+          }
+
+          const styleProps = styleTagPropsFromRawProps(props);
+          const ownerDocument = getDocumentFromRoot(hoistableRoot);
+          instance = ownerDocument.createElement('style');
+          markNodeAsHoistable(instance);
+          setInitialProperties(instance, 'style', styleProps); // TODO: `style` does not have loading state for tracking insertions. I
+          // guess because these aren't suspensey? Not sure whether this is a
+          // factoring smell.
+          // resource.state.loading |= Inserted;
+
+          insertStylesheet(instance, qualifiedProps.precedence, hoistableRoot);
+          resource.instance = instance;
+          return instance;
+        }
+
+      case 'stylesheet':
+        {
+          // This typing is enforce by `getResource`. If we change the logic
+          // there for what qualifies as a stylesheet resource we need to ensure
+          // this cast still makes sense;
+          const qualifiedProps = props;
+          const key = getStyleKey(qualifiedProps.href); // Attempt to hydrate instance from DOM
+
+          let instance = hoistableRoot.querySelector(getStylesheetSelectorFromKey(key));
+
+          if (instance) {
+            resource.state.loading |= Inserted;
+            resource.instance = instance;
+            markNodeAsHoistable(instance);
+            return instance;
+          }
+
+          const stylesheetProps = stylesheetPropsFromRawProps(props);
+          const preloadProps = preloadPropsMap.get(key);
+
+          if (preloadProps) {
+            adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps);
+          } // Construct and insert a new instance
+
+
+          const ownerDocument = getDocumentFromRoot(hoistableRoot);
+          instance = ownerDocument.createElement('link');
+          markNodeAsHoistable(instance);
+          const linkInstance = instance;
+          linkInstance._p = new Promise((resolve, reject) => {
+            linkInstance.onload = resolve;
+            linkInstance.onerror = reject;
+          });
+          setInitialProperties(instance, 'link', stylesheetProps);
+          resource.state.loading |= Inserted;
+          insertStylesheet(instance, qualifiedProps.precedence, hoistableRoot);
+          resource.instance = instance;
+          return instance;
+        }
+
+      case 'script':
+        {
+          // This typing is enforce by `getResource`. If we change the logic
+          // there for what qualifies as a stylesheet resource we need to ensure
+          // this cast still makes sense;
+          const borrowedScriptProps = props;
+          const key = getScriptKey(borrowedScriptProps.src); // Attempt to hydrate instance from DOM
+
+          let instance = hoistableRoot.querySelector(getScriptSelectorFromKey(key));
+
+          if (instance) {
+            resource.instance = instance;
+            markNodeAsHoistable(instance);
+            return instance;
+          }
+
+          let scriptProps = borrowedScriptProps;
+          const preloadProps = preloadPropsMap.get(key);
+
+          if (preloadProps) {
+            scriptProps = assign({}, borrowedScriptProps);
+            adoptPreloadPropsForScript(scriptProps, preloadProps);
+          } // Construct and insert a new instance
+
+
+          const ownerDocument = getDocumentFromRoot(hoistableRoot);
+          instance = ownerDocument.createElement('script');
+          markNodeAsHoistable(instance);
+          setInitialProperties(instance, 'link', scriptProps);
+          ownerDocument.head.appendChild(instance);
+          resource.instance = instance;
+          return instance;
+        }
+
+      case 'void':
+        {
+          return null;
+        }
+
+      default:
+        {
+          throw Error(formatProdErrorMessage(443, resource.type));
+        }
+    }
+  } else {
+    // In the case of stylesheets, they might have already been assigned an
+    // instance during `suspendResource`. But that doesn't mean they were
+    // inserted, because the commit might have been interrupted. So we need to
+    // check now.
+    //
+    // The other resource types are unaffected because they are not
+    // yet suspensey.
+    //
+    // TODO: This is a bit of a code smell. Consider refactoring how
+    // `suspendResource` and `acquireResource` work together. The idea is that
+    // `suspendResource` does all the same stuff as `acquireResource` except
+    // for the insertion.
+    if (resource.type === 'stylesheet' && (resource.state.loading & Inserted) === NotLoaded) {
+      const qualifiedProps = props;
+      const instance = resource.instance;
+      resource.state.loading |= Inserted;
+      insertStylesheet(instance, qualifiedProps.precedence, hoistableRoot);
+    }
+  }
+
+  return resource.instance;
+}
+function releaseResource(resource) {
+  resource.count--;
+}
+
+function insertStylesheet(instance, precedence, root) {
+  const nodes = root.querySelectorAll('link[rel="stylesheet"][data-precedence],style[data-precedence]');
+  const last = nodes.length ? nodes[nodes.length - 1] : null;
+  let prior = last;
+
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const nodePrecedence = node.dataset.precedence;
+
+    if (nodePrecedence === precedence) {
+      prior = node;
+    } else if (prior !== last) {
+      break;
+    }
+  }
+
+  if (prior) {
+    // We get the prior from the document so we know it is in the tree.
+    // We also know that links can't be the topmost Node so the parentNode
+    // must exist.
+    prior.parentNode.insertBefore(instance, prior.nextSibling);
+  } else {
+    const parent = root.nodeType === DOCUMENT_NODE ? root.head : root;
+    parent.insertBefore(instance, parent.firstChild);
+  }
+}
+
+function adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps) {
+  if (stylesheetProps.crossOrigin == null) stylesheetProps.crossOrigin = preloadProps.crossOrigin;
+  if (stylesheetProps.referrerPolicy == null) stylesheetProps.referrerPolicy = preloadProps.referrerPolicy;
+  if (stylesheetProps.title == null) stylesheetProps.title = preloadProps.title;
+}
+
+function adoptPreloadPropsForScript(scriptProps, preloadProps) {
+  if (scriptProps.crossOrigin == null) scriptProps.crossOrigin = preloadProps.crossOrigin;
+  if (scriptProps.referrerPolicy == null) scriptProps.referrerPolicy = preloadProps.referrerPolicy;
+  if (scriptProps.integrity == null) scriptProps.integrity = preloadProps.integrity;
+}
+
+let tagCaches = null;
+function hydrateHoistable(hoistableRoot, type, props, internalInstanceHandle) {
+  const ownerDocument = getDocumentFromRoot(hoistableRoot);
+  let instance = null;
+
+  getInstance: switch (type) {
+    case 'title':
+      {
+        instance = ownerDocument.getElementsByTagName('title')[0];
+
+        if (!instance || isOwnedInstance(instance) || instance.namespaceURI === SVG_NAMESPACE || instance.hasAttribute('itemprop')) {
+          instance = ownerDocument.createElement(type);
+          ownerDocument.head.insertBefore(instance, ownerDocument.querySelector('head > title'));
+        }
+
+        setInitialProperties(instance, type, props);
+        precacheFiberNode(internalInstanceHandle, instance);
+        markNodeAsHoistable(instance);
+        return instance;
+      }
+
+    case 'link':
+      {
+        const cache = getHydratableHoistableCache('link', 'href', ownerDocument);
+        const key = type + (props.href || '');
+        const maybeNodes = cache.get(key);
+
+        if (maybeNodes) {
+          const nodes = maybeNodes;
+
+          for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i];
+
+            if (node.getAttribute('href') !== (props.href == null ? null : props.href) || node.getAttribute('rel') !== (props.rel == null ? null : props.rel) || node.getAttribute('title') !== (props.title == null ? null : props.title) || node.getAttribute('crossorigin') !== (props.crossOrigin == null ? null : props.crossOrigin)) {
+              // mismatch, try the next node;
+              continue;
+            }
+
+            instance = node;
+            nodes.splice(i, 1);
+            break getInstance;
+          }
+        }
+
+        instance = ownerDocument.createElement(type);
+        setInitialProperties(instance, type, props);
+        ownerDocument.head.appendChild(instance);
+        break;
+      }
+
+    case 'meta':
+      {
+        const cache = getHydratableHoistableCache('meta', 'content', ownerDocument);
+        const key = type + (props.content || '');
+        const maybeNodes = cache.get(key);
+
+        if (maybeNodes) {
+          const nodes = maybeNodes;
+
+          for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i]; // We coerce content to string because it is the most likely one to
+
+            if (node.getAttribute('content') !== (props.content == null ? null : '' + props.content) || node.getAttribute('name') !== (props.name == null ? null : props.name) || node.getAttribute('property') !== (props.property == null ? null : props.property) || node.getAttribute('http-equiv') !== (props.httpEquiv == null ? null : props.httpEquiv) || node.getAttribute('charset') !== (props.charSet == null ? null : props.charSet)) {
+              // mismatch, try the next node;
+              continue;
+            }
+
+            instance = node;
+            nodes.splice(i, 1);
+            break getInstance;
+          }
+        }
+
+        instance = ownerDocument.createElement(type);
+        setInitialProperties(instance, type, props);
+        ownerDocument.head.appendChild(instance);
+        break;
+      }
+
+    default:
+      throw Error(formatProdErrorMessage(468, type));
+  } // This node is a match
+
+
+  precacheFiberNode(internalInstanceHandle, instance);
+  markNodeAsHoistable(instance);
+  return instance;
+}
+
+function getHydratableHoistableCache(type, keyAttribute, ownerDocument) {
+  let cache;
+  let caches;
+
+  if (tagCaches === null) {
+    cache = new Map();
+    caches = tagCaches = new Map();
+    caches.set(ownerDocument, cache);
+  } else {
+    caches = tagCaches;
+    const maybeCache = caches.get(ownerDocument);
+
+    if (!maybeCache) {
+      cache = new Map();
+      caches.set(ownerDocument, cache);
+    } else {
+      cache = maybeCache;
+    }
+  }
+
+  if (cache.has(type)) {
+    // We use type as a special key that signals that this cache has been seeded for this type
+    return cache;
+  } // Mark this cache as seeded for this type
+
+
+  cache.set(type, null);
+  const nodes = ownerDocument.getElementsByTagName(type);
+
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+
+    if (!isOwnedInstance(node) && (type !== 'link' || node.getAttribute('rel') !== 'stylesheet') && node.namespaceURI !== SVG_NAMESPACE) {
+      const nodeKey = node.getAttribute(keyAttribute) || '';
+      const key = type + nodeKey;
+      const existing = cache.get(key);
+
+      if (existing) {
+        existing.push(node);
+      } else {
+        cache.set(key, [node]);
+      }
+    }
+  }
+
+  return cache;
+}
+
+function mountHoistable(hoistableRoot, type, instance) {
+  const ownerDocument = getDocumentFromRoot(hoistableRoot);
+  ownerDocument.head.insertBefore(instance, type === 'title' ? ownerDocument.querySelector('head > title') : null);
+}
+function unmountHoistable(instance) {
+  instance.parentNode.removeChild(instance);
+}
+function isHostHoistableType(type, props, hostContext) {
+  let hostContextProd;
+
+  {
+    hostContextProd = hostContext;
+  } // Global opt out of hoisting for anything in SVG Namespace or anything with an itemProp inside an itemScope
+
+
+  if (hostContextProd === HostContextNamespaceSvg || props.itemProp != null) {
+
+    return false;
+  }
+
+  switch (type) {
+    case 'meta':
+    case 'title':
+      {
+        return true;
+      }
+
+    case 'style':
+      {
+        if (typeof props.precedence !== 'string' || typeof props.href !== 'string' || props.href === '') {
+
+          return false;
+        }
+
+        return true;
+      }
+
+    case 'link':
+      {
+        if (typeof props.rel !== 'string' || typeof props.href !== 'string' || props.href === '' || props.onLoad || props.onError) {
+
+          return false;
+        }
+
+        switch (props.rel) {
+          case 'stylesheet':
+            {
+              const precedence = props.precedence,
+                    disabled = props.disabled;
+
+              return typeof precedence === 'string' && disabled == null;
+            }
+
+          default:
+            {
+              return true;
+            }
+        }
+      }
+
+    case 'script':
+      {
+        if (props.async !== true || props.onLoad || props.onError || typeof props.src !== 'string' || !props.src) {
+
+          return false;
+        }
+
+        return true;
+      }
+
+    case 'noscript':
+    case 'template':
+      {
+
+        return false;
+      }
+  }
+
+  return false;
+}
+function mayResourceSuspendCommit(resource) {
+  return resource.type === 'stylesheet' && (resource.state.loading & Inserted) === NotLoaded;
+}
+function preloadInstance(type, props) {
+  // Return true to indicate it's already loaded
+  return true;
+}
+function preloadResource(resource) {
+  if (resource.type === 'stylesheet' && (resource.state.loading & Settled) === NotLoaded) {
+    // we have not finished loading the underlying stylesheet yet.
+    return false;
+  } // Return true to indicate it's already loaded
+
+
+  return true;
+}
+let suspendedState = null; // We use a noop function when we begin suspending because if possible we want the
+// waitfor step to finish synchronously. If it doesn't we'll return a function to
+// provide the actual unsuspend function and that will get completed when the count
+// hits zero or it will get cancelled if the root starts new work.
+
+function noop() {}
+
+function startSuspendingCommit() {
+  suspendedState = {
+    stylesheets: null,
+    count: 0,
+    unsuspend: noop
+  };
+}
+function suspendResource(hoistableRoot, resource, props) {
+  if (suspendedState === null) {
+    throw Error(formatProdErrorMessage(475));
+  }
+
+  const state = suspendedState;
+
+  if (resource.type === 'stylesheet') {
+    if (typeof props.media === 'string') {
+      // If we don't currently match media we avoid suspending on this resource
+      // and let it insert on the mutation path
+      if (matchMedia(props.media).matches === false) {
+        return;
+      }
+    }
+
+    if ((resource.state.loading & Inserted) === NotLoaded) {
+      if (resource.instance === null) {
+        const qualifiedProps = props;
+        const key = getStyleKey(qualifiedProps.href); // Attempt to hydrate instance from DOM
+
+        let instance = hoistableRoot.querySelector(getStylesheetSelectorFromKey(key));
+
+        if (instance) {
+          // If this instance has a loading state it came from the Fizz runtime.
+          // If there is not loading state it is assumed to have been server rendered
+          // as part of the preamble and therefore synchronously loaded. It could have
+          // errored however which we still do not yet have a means to detect. For now
+          // we assume it is loaded.
+          const maybeLoadingState = instance._p;
+
+          if (maybeLoadingState !== null && typeof maybeLoadingState === 'object' && // $FlowFixMe[method-unbinding]
+          typeof maybeLoadingState.then === 'function') {
+            const loadingState = maybeLoadingState;
+            state.count++;
+            const ping = onUnsuspend.bind(state);
+            loadingState.then(ping, ping);
+          }
+
+          resource.state.loading |= Inserted;
+          resource.instance = instance;
+          markNodeAsHoistable(instance);
+          return;
+        }
+
+        const ownerDocument = getDocumentFromRoot(hoistableRoot);
+        const stylesheetProps = stylesheetPropsFromRawProps(props);
+        const preloadProps = preloadPropsMap.get(key);
+
+        if (preloadProps) {
+          adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps);
+        } // Construct and insert a new instance
+
+
+        instance = ownerDocument.createElement('link');
+        markNodeAsHoistable(instance);
+        const linkInstance = instance; // This Promise is a loading state used by the Fizz runtime. We need this incase there is a race
+        // between this resource being rendered on the client and being rendered with a late completed boundary.
+
+        linkInstance._p = new Promise((resolve, reject) => {
+          linkInstance.onload = resolve;
+          linkInstance.onerror = reject;
+        });
+        setInitialProperties(instance, 'link', stylesheetProps);
+        resource.instance = instance;
+      }
+
+      if (state.stylesheets === null) {
+        state.stylesheets = new Map();
+      }
+
+      state.stylesheets.set(resource, hoistableRoot);
+      const preloadEl = resource.state.preload;
+
+      if (preloadEl && (resource.state.loading & Settled) === NotLoaded) {
+        state.count++;
+        const ping = onUnsuspend.bind(state);
+        preloadEl.addEventListener('load', ping);
+        preloadEl.addEventListener('error', ping);
+      }
+    }
+  }
+}
+function waitForCommitToBeReady() {
+  if (suspendedState === null) {
+    throw Error(formatProdErrorMessage(475));
+  }
+
+  const state = suspendedState;
+
+  if (state.stylesheets && state.count === 0) {
+    // We are not currently blocked but we have not inserted all stylesheets.
+    // If this insertion happens and loads or errors synchronously then we can
+    // avoid suspending the commit. To do this we check the count again immediately after
+    insertSuspendedStylesheets(state, state.stylesheets);
+  } // We need to check the count again because the inserted stylesheets may have led to new
+  // tasks to wait on.
+
+
+  if (state.count > 0) {
+    return commit => {
+      // We almost never want to show content before its styles have loaded. But
+      // eventually we will give up and allow unstyled content. So this number is
+      // somewhat arbitrary — big enough that you'd only reach it under
+      // extreme circumstances.
+      // TODO: Figure out what the browser engines do during initial page load and
+      // consider aligning our behavior with that.
+      const stylesheetTimer = setTimeout(() => {
+        if (state.stylesheets) {
+          insertSuspendedStylesheets(state, state.stylesheets);
+        }
+
+        if (state.unsuspend) {
+          const unsuspend = state.unsuspend;
+          state.unsuspend = null;
+          unsuspend();
+        }
+      }, 60000); // one minute
+
+      state.unsuspend = commit;
+      return () => {
+        state.unsuspend = null;
+        clearTimeout(stylesheetTimer);
+      };
+    };
+  }
+
+  return null;
+}
+
+function onUnsuspend() {
+  this.count--;
+
+  if (this.count === 0) {
+    if (this.stylesheets) {
+      // If we haven't actually inserted the stylesheets yet we need to do so now before starting the commit.
+      // The reason we do this after everything else has finished is because we want to have all the stylesheets
+      // load synchronously right before mutating. Ideally the new styles will cause a single recalc only on the
+      // new tree. When we filled up stylesheets we only inlcuded stylesheets with matching media attributes so we
+      // wait for them to load before actually continuing. We expect this to increase the count above zero
+      insertSuspendedStylesheets(this, this.stylesheets);
+    } else if (this.unsuspend) {
+      const unsuspend = this.unsuspend;
+      this.unsuspend = null;
+      unsuspend();
+    }
+  }
+} // This is typecast to non-null because it will always be set before read.
+// it is important that this not be used except when the stack guarantees it exists.
+// Currentlyt his is only during insertSuspendedStylesheet.
+
+
+let precedencesByRoot = null;
+
+function insertSuspendedStylesheets(state, resources) {
+  // We need to clear this out so we don't try to reinsert after the stylesheets have loaded
+  state.stylesheets = null;
+
+  if (state.unsuspend === null) {
+    // The suspended commit was cancelled. We don't need to insert any stylesheets.
+    return;
+  } // Temporarily increment count. we don't want any synchronously loaded stylesheets to try to unsuspend
+  // before we finish inserting all stylesheets.
+
+
+  state.count++;
+  precedencesByRoot = new Map();
+  resources.forEach(insertStylesheetIntoRoot, state);
+  precedencesByRoot = null; // We can remove our temporary count and if we're still at zero we can unsuspend.
+  // If we are in the synchronous phase before deciding if the commit should suspend and this
+  // ends up hitting the unsuspend path it will just invoke the noop unsuspend.
+
+  onUnsuspend.call(state);
+}
+
+function insertStylesheetIntoRoot(root, resource, map) {
+  if (resource.state.loading & Inserted) {
+    // This resource was inserted by another root committing. we don't need to insert it again
+    return;
+  }
+
+  let last;
+  let precedences = precedencesByRoot.get(root);
+
+  if (!precedences) {
+    precedences = new Map();
+    precedencesByRoot.set(root, precedences);
+    const nodes = root.querySelectorAll('link[data-precedence],style[data-precedence]');
+
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+
+      if (node.nodeName === 'link' || // We omit style tags with media="not all" because they are not in the right position
+      // and will be hoisted by the Fizz runtime imminently.
+      node.getAttribute('media') !== 'not all') {
+        precedences.set('p' + node.dataset.precedence, node);
+        last = node;
+      }
+    }
+
+    if (last) {
+      precedences.set('last', last);
+    }
+  } else {
+    last = precedences.get('last');
+  } // We only call this after we have constructed an instance so we assume it here
+
+
+  const instance = resource.instance; // We will always have a precedence for stylesheet instances
+
+  const precedence = instance.getAttribute('data-precedence');
+  const prior = precedences.get('p' + precedence) || last;
+
+  if (prior === last) {
+    precedences.set('last', instance);
+  }
+
+  precedences.set(precedence, instance);
+  this.count++;
+  const onComplete = onUnsuspend.bind(this);
+  instance.addEventListener('load', onComplete);
+  instance.addEventListener('error', onComplete);
+
+  if (prior) {
+    prior.parentNode.insertBefore(instance, prior.nextSibling);
+  } else {
+    const parent = root.nodeType === DOCUMENT_NODE ? root.head : root;
+    parent.insertBefore(instance, parent.firstChild);
+  }
+
+  resource.state.loading |= Inserted;
+}
+
+const NotPendingTransition = NotPending;
+
+const Dispatcher$1 = Internals.Dispatcher;
+
+if (typeof document !== 'undefined') {
+  // Set the default dispatcher to the client dispatcher
+  Dispatcher$1.current = ReactDOMClientDispatcher;
+}
+/* global reportError */
+
+const defaultOnRecoverableError = typeof reportError === 'function' ? // In modern browsers, reportError will dispatch an error event,
+// emulating an uncaught JavaScript error.
+reportError : error => {
+  // In older browsers and test environments, fallback to console.error.
+  // eslint-disable-next-line react-internal/no-production-logging
+  console['error'](error);
+}; // $FlowFixMe[missing-this-annot]
+
+function ReactDOMRoot(internalRoot) {
+  this._internalRoot = internalRoot;
+} // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+ReactDOMHydrationRoot.prototype.render = ReactDOMRoot.prototype.render = // $FlowFixMe[missing-this-annot]
+function (children) {
+  const root = this._internalRoot;
+
+  if (root === null) {
+    throw Error(formatProdErrorMessage(409));
+  }
+
+  updateContainer(children, root, null, null);
+}; // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+ReactDOMHydrationRoot.prototype.unmount = ReactDOMRoot.prototype.unmount = // $FlowFixMe[missing-this-annot]
+function () {
+
+  const root = this._internalRoot;
+
+  if (root !== null) {
+    this._internalRoot = null;
+    const container = root.containerInfo;
+
+    flushSync$1(() => {
+      updateContainer(null, root, null, null);
+    });
+    unmarkContainerAsRoot(container);
+  }
+};
+
+function createRoot$1(container, options) {
+  if (!isValidContainer(container)) {
+    throw Error(formatProdErrorMessage(299));
+  }
+  let isStrictMode = false;
+  let concurrentUpdatesByDefaultOverride = false;
+  let identifierPrefix = '';
+  let onRecoverableError = defaultOnRecoverableError;
+  let transitionCallbacks = null;
+
+  if (options !== null && options !== undefined) {
+
+    if (options.unstable_strictMode === true) {
+      isStrictMode = true;
+    }
+
+    if (options.identifierPrefix !== undefined) {
+      identifierPrefix = options.identifierPrefix;
+    }
+
+    if (options.onRecoverableError !== undefined) {
+      onRecoverableError = options.onRecoverableError;
+    }
+
+    if (options.unstable_transitionCallbacks !== undefined) {
+      transitionCallbacks = options.unstable_transitionCallbacks;
+    }
+  }
+
+  const root = createContainer(container, ConcurrentRoot, null, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks);
+  markContainerAsRoot(root.current, container);
+  Dispatcher$1.current = ReactDOMClientDispatcher;
+  const rootContainerElement = container.nodeType === COMMENT_NODE ? container.parentNode : container;
+  listenToAllSupportedEvents(rootContainerElement); // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
+
+  return new ReactDOMRoot(root);
+} // $FlowFixMe[missing-this-annot]
+
+function ReactDOMHydrationRoot(internalRoot) {
+  this._internalRoot = internalRoot;
+}
+
+function scheduleHydration(target) {
+  if (target) {
+    queueExplicitHydrationTarget(target);
+  }
+} // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+ReactDOMHydrationRoot.prototype.unstable_scheduleHydration = scheduleHydration;
+function hydrateRoot$1(container, initialChildren, options) {
+  if (!isValidContainer(container)) {
+    throw Error(formatProdErrorMessage(405));
+  }
+  // the hydration callbacks.
+
+
+  const hydrationCallbacks = options != null ? options : null;
+  let isStrictMode = false;
+  let concurrentUpdatesByDefaultOverride = false;
+  let identifierPrefix = '';
+  let onRecoverableError = defaultOnRecoverableError;
+  let transitionCallbacks = null;
+  let formState = null;
+
+  if (options !== null && options !== undefined) {
+    if (options.unstable_strictMode === true) {
+      isStrictMode = true;
+    }
+
+    if (options.identifierPrefix !== undefined) {
+      identifierPrefix = options.identifierPrefix;
+    }
+
+    if (options.onRecoverableError !== undefined) {
+      onRecoverableError = options.onRecoverableError;
+    }
+
+    if (options.unstable_transitionCallbacks !== undefined) {
+      transitionCallbacks = options.unstable_transitionCallbacks;
+    }
+
+    {
+      if (options.formState !== undefined) {
+        formState = options.formState;
+      }
+    }
+  }
+
+  const root = createHydrationContainer(initialChildren, null, container, ConcurrentRoot, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks, formState);
+  markContainerAsRoot(root.current, container);
+  Dispatcher$1.current = ReactDOMClientDispatcher; // This can't be a comment node since hydration doesn't work on comment nodes anyway.
+
+  listenToAllSupportedEvents(container); // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
+
+  return new ReactDOMHydrationRoot(root);
+}
+function isValidContainer(node) {
+  return !!(node && (node.nodeType === ELEMENT_NODE || node.nodeType === DOCUMENT_NODE || node.nodeType === DOCUMENT_FRAGMENT_NODE || !disableCommentsAsDOMContainers  ));
+} // TODO: Remove this function which also includes comment nodes.
+// We only use it in places that are currently more relaxed.
+
+function isValidContainerLegacy(node) {
+  return !!(node && (node.nodeType === ELEMENT_NODE || node.nodeType === DOCUMENT_NODE || node.nodeType === DOCUMENT_FRAGMENT_NODE || node.nodeType === COMMENT_NODE && node.nodeValue === ' react-mount-point-unstable '));
+}
+
+function noopOnRecoverableError() {// This isn't reachable because onRecoverableError isn't called in the
+  // legacy API.
+}
+
+function legacyCreateRootFromDOMContainer(container, initialChildren, parentComponent, callback, isHydrationContainer) {
+  if (isHydrationContainer) {
+    if (typeof callback === 'function') {
+      const originalCallback = callback;
+
+      callback = function () {
+        const instance = getPublicRootInstance(root);
+        originalCallback.call(instance);
+      };
+    }
+
+    const root = createHydrationContainer(initialChildren, callback, container, LegacyRoot, null, // hydrationCallbacks
+    false, // isStrictMode
+    false, // concurrentUpdatesByDefaultOverride,
+    '', // identifierPrefix
+    noopOnRecoverableError, // TODO(luna) Support hydration later
+    null, null);
+    container._reactRootContainer = root;
+    markContainerAsRoot(root.current, container);
+    const rootContainerElement = container.nodeType === COMMENT_NODE ? container.parentNode : container; // $FlowFixMe[incompatible-call]
+
+    listenToAllSupportedEvents(rootContainerElement);
+    flushSync$1();
+    return root;
+  } else {
+    // First clear any existing content.
+    clearContainer(container);
+
+    if (typeof callback === 'function') {
+      const originalCallback = callback;
+
+      callback = function () {
+        const instance = getPublicRootInstance(root);
+        originalCallback.call(instance);
+      };
+    }
+
+    const root = createContainer(container, LegacyRoot, null, // hydrationCallbacks
+    false, // isStrictMode
+    false, // concurrentUpdatesByDefaultOverride,
+    '', // identifierPrefix
+    noopOnRecoverableError, // onRecoverableError
+    null // transitionCallbacks
+    );
+    container._reactRootContainer = root;
+    markContainerAsRoot(root.current, container);
+    const rootContainerElement = container.nodeType === COMMENT_NODE ? container.parentNode : container; // $FlowFixMe[incompatible-call]
+
+    listenToAllSupportedEvents(rootContainerElement); // Initial mount should not be batched.
+
+    flushSync$1(() => {
+      updateContainer(initialChildren, root, parentComponent, callback);
+    });
+    return root;
+  }
+}
+
+function legacyRenderSubtreeIntoContainer(parentComponent, children, container, forceHydrate, callback) {
+
+  const maybeRoot = container._reactRootContainer;
+  let root;
+
+  if (!maybeRoot) {
+    // Initial mount
+    root = legacyCreateRootFromDOMContainer(container, children, parentComponent, callback, forceHydrate);
+  } else {
+    root = maybeRoot;
+
+    if (typeof callback === 'function') {
+      const originalCallback = callback;
+
+      callback = function () {
+        const instance = getPublicRootInstance(root);
+        originalCallback.call(instance);
+      };
+    } // Update
+
+
+    updateContainer(children, root, parentComponent, callback);
+  }
+
+  return getPublicRootInstance(root);
+}
+
+function findDOMNode(componentOrElement) {
+
+  if (componentOrElement == null) {
+    return null;
+  }
+
+  if (componentOrElement.nodeType === ELEMENT_NODE) {
+    return componentOrElement;
+  }
+
+  return findHostInstance(componentOrElement);
+}
+function hydrate(element, container, callback) {
+
+  if (!isValidContainerLegacy(container)) {
+    throw Error(formatProdErrorMessage(200));
+  }
+
+
+  return legacyRenderSubtreeIntoContainer(null, element, container, true, callback);
+}
+function render(element, container, callback) {
+
+  if (!isValidContainerLegacy(container)) {
+    throw Error(formatProdErrorMessage(200));
+  }
+
+  return legacyRenderSubtreeIntoContainer(null, element, container, false, callback);
+}
+function unstable_renderSubtreeIntoContainer(parentComponent, element, containerNode, callback) {
+
+  if (!isValidContainerLegacy(containerNode)) {
+    throw Error(formatProdErrorMessage(200));
+  }
+
+  if (parentComponent == null || !has(parentComponent)) {
+    throw Error(formatProdErrorMessage(38));
+  }
+
+  return legacyRenderSubtreeIntoContainer(parentComponent, element, containerNode, false, callback);
+}
+function unmountComponentAtNode(container) {
+  if (!isValidContainerLegacy(container)) {
+    throw Error(formatProdErrorMessage(40));
+  }
+
+  if (container._reactRootContainer) {
+
+
+    flushSync$1(() => {
+      legacyRenderSubtreeIntoContainer(null, null, container, false, () => {
+        // $FlowFixMe[incompatible-type] This should probably use `delete container._reactRootContainer`
+        container._reactRootContainer = null;
+        unmarkContainerAsRoot(container);
+      });
+    }); // If you call unmountComponentAtNode twice in quick succession, you'll
+    // get `true` twice. That's probably fine?
+
+    return true;
+  } else {
+
+    return false;
+  }
+}
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+function getCrossOriginStringAs(as, input) {
+  if (as === 'font') {
+    return '';
+  }
+
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+const Dispatcher = Internals.Dispatcher;
+function prefetchDNS(href) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    dispatcher.prefetchDNS(href);
+  } // We don't error because preconnect needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preconnect(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    const crossOrigin = options ? getCrossOriginString(options.crossOrigin) : null;
+    dispatcher.preconnect(href, crossOrigin);
+  } // We don't error because preconnect needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preload(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string' && // We check existence because we cannot enforce this function is actually called with the stated type
+  typeof options === 'object' && options !== null && typeof options.as === 'string') {
+    const as = options.as;
+    const crossOrigin = getCrossOriginStringAs(as, options.crossOrigin);
+    dispatcher.preload(href, as, {
+      crossOrigin,
+      integrity: typeof options.integrity === 'string' ? options.integrity : undefined,
+      nonce: typeof options.nonce === 'string' ? options.nonce : undefined,
+      type: typeof options.type === 'string' ? options.type : undefined,
+      fetchPriority: typeof options.fetchPriority === 'string' ? options.fetchPriority : undefined,
+      referrerPolicy: typeof options.referrerPolicy === 'string' ? options.referrerPolicy : undefined,
+      imageSrcSet: typeof options.imageSrcSet === 'string' ? options.imageSrcSet : undefined,
+      imageSizes: typeof options.imageSizes === 'string' ? options.imageSizes : undefined
+    });
+  } // We don't error because preload needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preloadModule(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    if (options) {
+      const crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);
+      dispatcher.preloadModule(href, {
+        as: typeof options.as === 'string' && options.as !== 'script' ? options.as : undefined,
+        crossOrigin,
+        integrity: typeof options.integrity === 'string' ? options.integrity : undefined
+      });
+    } else {
+      dispatcher.preloadModule(href);
+    }
+  } // We don't error because preload needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preinit(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string' && options && typeof options.as === 'string') {
+    const as = options.as;
+    const crossOrigin = getCrossOriginStringAs(as, options.crossOrigin);
+    const integrity = typeof options.integrity === 'string' ? options.integrity : undefined;
+    const fetchPriority = typeof options.fetchPriority === 'string' ? options.fetchPriority : undefined;
+
+    if (as === 'style') {
+      dispatcher.preinitStyle(href, typeof options.precedence === 'string' ? options.precedence : undefined, {
+        crossOrigin,
+        integrity,
+        fetchPriority
+      });
+    } else if (as === 'script') {
+      dispatcher.preinitScript(href, {
+        crossOrigin,
+        integrity,
+        fetchPriority,
+        nonce: typeof options.nonce === 'string' ? options.nonce : undefined
+      });
+    }
+  } // We don't error because preinit needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preinitModule(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    if (typeof options === 'object' && options !== null) {
+      if (options.as == null || options.as === 'script') {
+        const crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);
+        dispatcher.preinitModuleScript(href, {
+          crossOrigin,
+          integrity: typeof options.integrity === 'string' ? options.integrity : undefined,
+          nonce: typeof options.nonce === 'string' ? options.nonce : undefined
+        });
+      }
+    } else if (options == null) {
+      dispatcher.preinitModuleScript(href);
+    }
+  } // We don't error because preinit needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+
+function createPortal(children, container) {
+  let key = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+
+  if (!isValidContainer(container)) {
+    throw Error(formatProdErrorMessage(200));
+  } // TODO: pass ReactDOM portal implementation as third argument
+  // $FlowFixMe[incompatible-return] The Flow type is opaque but there's no way to actually create it.
+
+
+  return createPortal$1(children, container, null, key);
+}
+
+function renderSubtreeIntoContainer(parentComponent, element, containerNode, callback) {
+  return unstable_renderSubtreeIntoContainer(parentComponent, element, containerNode, callback);
+}
+
+function createRoot(container, options) {
+
+  return createRoot$1(container, options);
+}
+
+function hydrateRoot(container, initialChildren, options) {
+
+  return hydrateRoot$1(container, initialChildren, options);
+} // Overload the definition to the two valid signatures.
+// Warning, this opts-out of checking the function body.
+// eslint-disable-next-line no-redeclare
+// eslint-disable-next-line no-redeclare
+
+
+function flushSync(fn) {
+
+  return flushSync$1(fn);
+}
+// This is an array for better minification.
+
+Internals.Events = [getInstanceFromNode, getNodeFromInstance, getFiberCurrentPropsFromNode, enqueueStateRestore, restoreStateIfNeeded, batchedUpdates$1];
+injectIntoDevTools({
+  findFiberByHostInstance: getClosestInstanceFromNode,
+  bundleType: 0,
+  version: ReactVersion,
+  rendererPackageName: 'react-dom'
+});
+
+exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = Internals;
+exports.createPortal = createPortal;
+exports.createRoot = createRoot;
+exports.findDOMNode = findDOMNode;
+exports.flushSync = flushSync;
+exports.hydrate = hydrate;
+exports.hydrateRoot = hydrateRoot;
+exports.preconnect = preconnect;
+exports.prefetchDNS = prefetchDNS;
+exports.preinit = preinit;
+exports.preinitModule = preinitModule;
+exports.preload = preload;
+exports.preloadModule = preloadModule;
+exports.render = render;
+exports.unmountComponentAtNode = unmountComponentAtNode;
+exports.unstable_batchedUpdates = batchedUpdates$1;
+exports.unstable_renderSubtreeIntoContainer = renderSubtreeIntoContainer;
+exports.useFormState = useFormState;
+exports.useFormStatus = useFormStatus;
+exports.version = ReactVersion;
+          /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+if (
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
+    'function'
+) {
+  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+}
+        
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom.profiling.min.js b/packages/next/src/compiled/react-dom/cjs/react-dom.profiling.min.js
index 8bcdd49f073b3..f64c117cebd42 100644
--- a/packages/next/src/compiled/react-dom/cjs/react-dom.profiling.min.js
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom.profiling.min.js
@@ -1,28 +1,16 @@
-/**
- * @license React
- * react-dom.profiling.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-dom.profiling.min.js
 
-          'use strict';
+ Copyright (c) Meta Platforms, Inc. and affiliates.
 
-/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
-if (
-  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
-  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===
-    'function'
-) {
-  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
-}
-          /*
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
  Modernizr 3.0.0pre (Custom Build) | MIT
 */
-'use strict';var aa=require("next/dist/compiled/react"),ba=require("next/dist/compiled/scheduler"),ca={usingClientEntryPoint:!1,Events:null,Dispatcher:{current:null}};function t(a){for(var b="https://reactjs.org/docs/error-decoder.html?invariant="+a,c=1;c<arguments.length;c++)b+="&args[]="+encodeURIComponent(arguments[c]);return"Minified React error #"+a+"; visit "+b+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}
-var w=Object.assign,da=aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,ea=da.ReactCurrentDispatcher,fa={pending:!1,data:null,method:null,action:null},ha=[],ia=-1;function ka(a){return{current:a}}function D(a){0>ia||(a.current=ha[ia],ha[ia]=null,ia--)}function E(a,b){ia++;ha[ia]=a.current;a.current=b}
+'use strict';"undefined"!==typeof __REACT_DEVTOOLS_GLOBAL_HOOK__&&"function"===typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart&&__REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());var aa=require("next/dist/compiled/react"),ba=require("next/dist/compiled/scheduler"),ca={usingClientEntryPoint:!1,Events:null,Dispatcher:{current:null}};
+function u(a){for(var b="https://reactjs.org/docs/error-decoder.html?invariant="+a,c=1;c<arguments.length;c++)b+="&args[]="+encodeURIComponent(arguments[c]);return"Minified React error #"+a+"; visit "+b+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}var x=Object.assign,da=aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,ea=da.ReactCurrentDispatcher,fa={pending:!1,data:null,method:null,action:null},ha=[],ia=-1;
+function ka(a){return{current:a}}function D(a){0>ia||(a.current=ha[ia],ha[ia]=null,ia--)}function E(a,b){ia++;ha[ia]=a.current;a.current=b}
 var la=Symbol.for("react.element"),ma=Symbol.for("react.portal"),na=Symbol.for("react.fragment"),oa=Symbol.for("react.strict_mode"),pa=Symbol.for("react.profiler"),qa=Symbol.for("react.provider"),ra=Symbol.for("react.context"),sa=Symbol.for("react.server_context"),ta=Symbol.for("react.forward_ref"),ua=Symbol.for("react.suspense"),va=Symbol.for("react.suspense_list"),wa=Symbol.for("react.memo"),xa=Symbol.for("react.lazy"),ya=Symbol.for("react.scope");Symbol.for("react.debug_trace_mode");
 var za=Symbol.for("react.offscreen"),Aa=Symbol.for("react.legacy_hidden"),Ba=Symbol.for("react.cache");Symbol.for("react.tracing_marker");var Ca=Symbol.iterator;function Da(a){if(null===a||"object"!==typeof a)return null;a=Ca&&a[Ca]||a["@@iterator"];return"function"===typeof a?a:null}var Ea=ka(null),Fa=ka(null),Ga=ka(null),Ha=ka(null),Ia={$$typeof:ra,_currentValue:null,_currentValue2:null,_threadCount:0,Provider:null,Consumer:null,_defaultValue:null,_globalName:null};
 function Ja(a,b){E(Ga,b);E(Fa,a);E(Ea,null);a=b.nodeType;switch(a){case 9:case 11:b=(b=b.documentElement)?(b=b.namespaceURI)?Ka(b):0:0;break;default:if(a=8===a?b.parentNode:b,b=a.tagName,a=a.namespaceURI)a=Ka(a),b=La(a,b);else switch(b){case "svg":b=1;break;case "math":b=2;break;default:b=0}}D(Ea);E(Ea,b)}function Ma(){D(Ea);D(Fa);D(Ga)}function Na(a){null!==a.memoizedState&&E(Ha,a);var b=Ea.current;var c=La(b,a.type);b!==c&&(E(Fa,a),E(Ea,c))}
@@ -31,22 +19,23 @@ function cb(a,b){if(ab&&"function"===typeof ab.onCommitFiberRoot)try{var c=128==
 function hb(a){null!==F&&"function"===typeof F.markComponentRenderStarted&&F.markComponentRenderStarted(a)}function ib(){null!==F&&"function"===typeof F.markComponentRenderStopped&&F.markComponentRenderStopped()}function jb(a){null!==F&&"function"===typeof F.markComponentLayoutEffectUnmountStarted&&F.markComponentLayoutEffectUnmountStarted(a)}function kb(){null!==F&&"function"===typeof F.markComponentLayoutEffectUnmountStopped&&F.markComponentLayoutEffectUnmountStopped()}
 function lb(a){null!==F&&"function"===typeof F.markRenderStarted&&F.markRenderStarted(a)}function mb(){null!==F&&"function"===typeof F.markRenderStopped&&F.markRenderStopped()}function nb(a,b){null!==F&&"function"===typeof F.markStateUpdateScheduled&&F.markStateUpdateScheduled(a,b)}var pb=Math.clz32?Math.clz32:ob,qb=Math.log,rb=Math.LN2;function ob(a){a>>>=0;return 0===a?32:31-(qb(a)/rb|0)|0}
 function fb(a){if(a&1)return"SyncHydrationLane";if(a&2)return"Sync";if(a&4)return"InputContinuousHydration";if(a&8)return"InputContinuous";if(a&16)return"DefaultHydration";if(a&32)return"Default";if(a&64)return"TransitionHydration";if(a&4194176)return"Transition";if(a&62914560)return"Retry";if(a&67108864)return"SelectiveHydration";if(a&134217728)return"IdleHydration";if(a&268435456)return"Idle";if(a&536870912)return"Offscreen";if(a&1073741824)return"Deferred"}var sb=128,tb=4194304;
-function ub(a){switch(a&-a){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:return 64;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:return a&4194176;case 4194304:case 8388608:case 16777216:case 33554432:return a&62914560;case 67108864:return 67108864;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;
-case 1073741824:return 0;default:return a}}function vb(a,b){var c=a.pendingLanes;if(0===c)return 0;var d=0,e=a.suspendedLanes;a=a.pingedLanes;var f=c&134217727;0!==f?(c=f&~e,0!==c?d=ub(c):(a&=f,0!==a&&(d=ub(a)))):(c&=~e,0!==c?d=ub(c):0!==a&&(d=ub(a)));return 0===d?0:0!==b&&b!==d&&0===(b&e)&&(e=d&-d,a=b&-b,e>=a||32===e&&0!==(a&4194176))?b:d}
+function ub(a){var b=a&42;if(0!==b)return b;switch(a&-a){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:return 64;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:return a&4194176;case 4194304:case 8388608:case 16777216:case 33554432:return a&62914560;case 67108864:return 67108864;case 134217728:return 134217728;case 268435456:return 268435456;
+case 536870912:return 536870912;case 1073741824:return 0;default:return a}}function vb(a,b){var c=a.pendingLanes;if(0===c)return 0;var d=0,e=a.suspendedLanes;a=a.pingedLanes;var f=c&134217727;0!==f?(c=f&~e,0!==c?d=ub(c):(a&=f,0!==a&&(d=ub(a)))):(c&=~e,0!==c?d=ub(c):0!==a&&(d=ub(a)));return 0===d?0:0!==b&&b!==d&&0===(b&e)&&(e=d&-d,a=b&-b,e>=a||32===e&&0!==(a&4194176))?b:d}
 function wb(a,b){switch(a){case 1:case 2:case 4:case 8:return b+250;case 16:case 32:case 64: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:return b+5E3;case 4194304:case 8388608:case 16777216:case 33554432:return-1;case 67108864:case 134217728:case 268435456:case 536870912:case 1073741824:return-1;default:return-1}}
 function xb(a,b){if(a.errorRecoveryDisabledLanes&b)return 0;a=a.pendingLanes&-536870913;return 0!==a?a:a&536870912?536870912:0}function yb(){var a=tb;tb<<=1;0===(tb&62914560)&&(tb=4194304);return a}function zb(a){for(var b=[],c=0;31>c;c++)b.push(a);return b}function Ab(a,b){a.pendingLanes|=b;268435456!==b&&(a.suspendedLanes=0,a.pingedLanes=0)}
 function Bb(a,b,c){var d=a.pendingLanes&~b;a.pendingLanes=b;a.suspendedLanes=0;a.pingedLanes=0;a.expiredLanes&=b;a.entangledLanes&=b;a.errorRecoveryDisabledLanes&=b;a.shellSuspendCounter=0;b=a.entanglements;for(var e=a.expirationTimes,f=a.hiddenUpdates;0<d;){var g=31-pb(d),h=1<<g;b[g]=0;e[g]=-1;var l=f[g];if(null!==l)for(f[g]=null,g=0;g<l.length;g++){var p=l[g];null!==p&&(p.lane&=-536870913)}d&=~h}0!==c&&Cb(a,c,0)}
 function Cb(a,b,c){a.pendingLanes|=b;a.suspendedLanes&=~b;var d=31-pb(b);a.entangledLanes|=b;a.entanglements[d]=a.entanglements[d]|1073741824|c&4194218}function Db(a,b){var c=a.entangledLanes|=b;for(a=a.entanglements;c;){var d=31-pb(c),e=1<<d;e&b|a[d]&b&&(a[d]|=b);c&=~e}}function Eb(a,b){a.pendingLanes|=2;for(a.entangledLanes|=2;b;){var c=1<<31-pb(b);a.entanglements[1]|=c;b&=~c}}function Fb(a,b,c){if(bb)for(a=a.pendingUpdatersLaneMap;0<c;){var d=31-pb(c),e=1<<d;a[d].add(b);c&=~e}}
 function Gb(a,b){if(bb)for(var c=a.pendingUpdatersLaneMap,d=a.memoizedUpdaters;0<b;){var e=31-pb(b);a=1<<e;e=c[e];0<e.size&&(e.forEach(function(f){var g=f.alternate;null!==g&&d.has(g)||d.add(f)}),e.clear());b&=~a}}var G=0;function Hb(a,b){var c=G;try{return G=a,b()}finally{G=c}}function Ib(a){a&=-a;return 2<a?8<a?0!==(a&134217727)?32:268435456:8:2}
 var Jb=Object.prototype.hasOwnProperty,Lb=Math.random().toString(36).slice(2),Mb="__reactFiber$"+Lb,Nb="__reactProps$"+Lb,Ob="__reactContainer$"+Lb,Pb="__reactEvents$"+Lb,Qb="__reactListeners$"+Lb,Rb="__reactHandles$"+Lb,Sb="__reactResources$"+Lb,Tb="__reactMarker$"+Lb;function Ub(a){delete a[Mb];delete a[Nb];delete a[Pb];delete a[Qb];delete a[Rb]}
-function Vb(a){var b=a[Mb];if(b)return b;for(var c=a.parentNode;c;){if(b=c[Ob]||c[Mb]){c=b.alternate;if(null!==b.child||null!==c&&null!==c.child)for(a=Wb(a);null!==a;){if(c=a[Mb])return c;a=Wb(a)}return b}a=c;c=a.parentNode}return null}function Xb(a){if(a=a[Mb]||a[Ob]){var b=a.tag;if(5===b||6===b||13===b||26===b||27===b||3===b)return a}return null}function Yb(a){var b=a.tag;if(5===b||26===b||27===b||6===b)return a.stateNode;throw Error(t(33));}function Zb(a){return a[Nb]||null}
+function Vb(a){var b=a[Mb];if(b)return b;for(var c=a.parentNode;c;){if(b=c[Ob]||c[Mb]){c=b.alternate;if(null!==b.child||null!==c&&null!==c.child)for(a=Wb(a);null!==a;){if(c=a[Mb])return c;a=Wb(a)}return b}a=c;c=a.parentNode}return null}function Xb(a){if(a=a[Mb]||a[Ob]){var b=a.tag;if(5===b||6===b||13===b||26===b||27===b||3===b)return a}return null}function Yb(a){var b=a.tag;if(5===b||26===b||27===b||6===b)return a.stateNode;throw Error(u(33));}function Zb(a){return a[Nb]||null}
 function $b(a){var b=a[Sb];b||(b=a[Sb]={hoistableStyles:new Map,hoistableScripts:new Map});return b}function ac(a){a[Tb]=!0}var bc=new Set,cc={};function dc(a,b){ec(a,b);ec(a+"Capture",b)}function ec(a,b){cc[a]=b;for(a=0;a<b.length;a++)bc.add(b[a])}
 var fc=!("undefined"===typeof window||"undefined"===typeof window.document||"undefined"===typeof window.document.createElement),gc=RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"),hc=
 {},ic={};function jc(a){if(Jb.call(ic,a))return!0;if(Jb.call(hc,a))return!1;if(gc.test(a))return ic[a]=!0;hc[a]=!0;return!1}function kc(a,b,c){if(jc(b))if(null===c)a.removeAttribute(b);else{switch(typeof c){case "undefined":case "function":case "symbol":a.removeAttribute(b);return;case "boolean":var d=b.toLowerCase().slice(0,5);if("data-"!==d&&"aria-"!==d){a.removeAttribute(b);return}}a.setAttribute(b,""+c)}}
 function lc(a,b,c){if(null===c)a.removeAttribute(b);else{switch(typeof c){case "undefined":case "function":case "symbol":case "boolean":a.removeAttribute(b);return}a.setAttribute(b,""+c)}}function mc(a,b,c,d){if(null===d)a.removeAttribute(c);else{switch(typeof d){case "undefined":case "function":case "symbol":case "boolean":a.removeAttribute(c);return}a.setAttributeNS(b,c,""+d)}}var nc;
 function oc(a){if(void 0===nc)try{throw Error();}catch(c){var b=c.stack.trim().match(/\n( *(at )?)/);nc=b&&b[1]||""}return"\n"+nc+a}var pc=!1;
-function qc(a,b){if(!a||pc)return"";pc=!0;var c=Error.prepareStackTrace;Error.prepareStackTrace=void 0;try{if(b)if(b=function(){throw Error();},Object.defineProperty(b.prototype,"props",{set:function(){throw Error();}}),"object"===typeof Reflect&&Reflect.construct){try{Reflect.construct(b,[])}catch(q){var d=q}Reflect.construct(a,[],b)}else{try{b.call()}catch(q){d=q}a.call(b.prototype)}else{try{throw Error();}catch(q){d=q}var e=a();e&&"function"===typeof e.catch&&e.catch(function(){})}}catch(q){if(q&&
-d&&"string"===typeof q.stack){for(var f=q.stack.split("\n"),g=d.stack.split("\n"),h=f.length-1,l=g.length-1;1<=h&&0<=l&&f[h]!==g[l];)l--;for(;1<=h&&0<=l;h--,l--)if(f[h]!==g[l]){if(1!==h||1!==l){do if(h--,l--,0>l||f[h]!==g[l]){var p="\n"+f[h].replace(" at new "," at ");a.displayName&&p.includes("<anonymous>")&&(p=p.replace("<anonymous>",a.displayName));return p}while(1<=h&&0<=l)}break}}}finally{pc=!1,Error.prepareStackTrace=c}return(a=a?a.displayName||a.name:"")?oc(a):""}
+function qc(a,b){if(!a||pc)return"";pc=!0;var c=Error.prepareStackTrace;Error.prepareStackTrace=void 0;var d={DetermineComponentFrameRoot:function(){try{if(b){var w=function(){throw Error();};Object.defineProperty(w.prototype,"props",{set:function(){throw Error();}});if("object"===typeof Reflect&&Reflect.construct){try{Reflect.construct(w,[])}catch(t){var r=t}Reflect.construct(a,[],w)}else{try{w.call()}catch(t){r=t}a.call(w.prototype)}}else{try{throw Error();}catch(t){r=t}(w=a())&&"function"===typeof w.catch&&
+w.catch(function(){})}}catch(t){if(t&&r&&"string"===typeof t.stack)return[t.stack,r.stack]}return[null,null]}};d.DetermineComponentFrameRoot.displayName="DetermineComponentFrameRoot";var e=Object.getOwnPropertyDescriptor(d.DetermineComponentFrameRoot,"name");e&&e.configurable&&Object.defineProperty(d.DetermineComponentFrameRoot,"name",{value:"DetermineComponentFrameRoot"});try{var f=d.DetermineComponentFrameRoot(),g=f[0],h=f[1];if(g&&h){var l=g.split("\n"),p=h.split("\n");for(e=d=0;d<l.length&&!l[d].includes("DetermineComponentFrameRoot");)d++;
+for(;e<p.length&&!p[e].includes("DetermineComponentFrameRoot");)e++;if(d===l.length||e===p.length)for(d=l.length-1,e=p.length-1;1<=d&&0<=e&&l[d]!==p[e];)e--;for(;1<=d&&0<=e;d--,e--)if(l[d]!==p[e]){if(1!==d||1!==e){do if(d--,e--,0>e||l[d]!==p[e]){var q="\n"+l[d].replace(" at new "," at ");a.displayName&&q.includes("<anonymous>")&&(q=q.replace("<anonymous>",a.displayName));return q}while(1<=d&&0<=e)}break}}}finally{pc=!1,Error.prepareStackTrace=c}return(c=a?a.displayName||a.name:"")?oc(c):""}
 function rc(a){switch(a.tag){case 26:case 27:case 5:return oc(a.type);case 16:return oc("Lazy");case 13:return oc("Suspense");case 19:return oc("SuspenseList");case 0:case 2:case 15:return a=qc(a.type,!1),a;case 11:return a=qc(a.type.render,!1),a;case 1:return a=qc(a.type,!0),a;default:return""}}
 function sc(a){if(null==a)return null;if("function"===typeof a)return a.displayName||a.name||null;if("string"===typeof a)return a;switch(a){case na:return"Fragment";case ma:return"Portal";case pa:return"Profiler";case oa:return"StrictMode";case ua:return"Suspense";case va:return"SuspenseList";case Ba:return"Cache"}if("object"===typeof a)switch(a.$$typeof){case ra:return(a.displayName||"Context")+".Consumer";case qa:return(a._context.displayName||"Context")+".Provider";case ta:var b=a.render;a=a.displayName;
 a||(a=b.displayName||b.name||"",a=""!==a?"ForwardRef("+a+")":"ForwardRef");return a;case wa:return b=a.displayName||null,null!==b?b:sc(a.type)||"Memo";case xa:b=a._payload;a=a._init;try{return sc(a(b))}catch(c){}}return null}
@@ -61,11 +50,11 @@ typeof e);null!=h&&"function"!==typeof h&&"symbol"!==typeof h&&"boolean"!==typeo
 function Ec(a,b,c,d,e,f,g,h){null!=f&&"function"!==typeof f&&"symbol"!==typeof f&&"boolean"!==typeof f&&(a.type=f);if(null!=b||null!=c){if(!("submit"!==f&&"reset"!==f||void 0!==b&&null!==b))return;c=null!=c?""+uc(c):"";b=null!=b?""+uc(b):c;h||b===a.value||(a.value=b);a.defaultValue=b}d=null!=d?d:e;d="function"!==typeof d&&"symbol"!==typeof d&&!!d;a.checked=h?a.checked:!!d;a.defaultChecked=!!d;null!=g&&"function"!==typeof g&&"symbol"!==typeof g&&"boolean"!==typeof g&&(a.name=g)}
 function Dc(a,b,c){"number"===b&&zc(a.ownerDocument)===a||a.defaultValue===""+c||(a.defaultValue=""+c)}var Fc=Array.isArray;
 function Gc(a,b,c,d){a=a.options;if(b){b={};for(var e=0;e<c.length;e++)b["$"+c[e]]=!0;for(c=0;c<a.length;c++)e=b.hasOwnProperty("$"+a[c].value),a[c].selected!==e&&(a[c].selected=e),e&&d&&(a[c].defaultSelected=!0)}else{c=""+uc(c);b=null;for(e=0;e<a.length;e++){if(a[e].value===c){a[e].selected=!0;d&&(a[e].defaultSelected=!0);return}null!==b||a[e].disabled||(b=a[e])}null!==b&&(b.selected=!0)}}
-function Hc(a,b,c){if(null!=b&&(b=""+uc(b),b!==a.value&&(a.value=b),null==c)){a.defaultValue!==b&&(a.defaultValue=b);return}a.defaultValue=null!=c?""+uc(c):""}function Ic(a,b,c,d){if(null==b){if(null!=d){if(null!=c)throw Error(t(92));if(Fc(d)){if(1<d.length)throw Error(t(93));d=d[0]}c=d}null==c&&(c="");b=c}c=uc(b);a.defaultValue=c;d=a.textContent;d===c&&""!==d&&null!==d&&(a.value=d)}var Jc;
+function Hc(a,b,c){if(null!=b&&(b=""+uc(b),b!==a.value&&(a.value=b),null==c)){a.defaultValue!==b&&(a.defaultValue=b);return}a.defaultValue=null!=c?""+uc(c):""}function Ic(a,b,c,d){if(null==b){if(null!=d){if(null!=c)throw Error(u(92));if(Fc(d)){if(1<d.length)throw Error(u(93));d=d[0]}c=d}null==c&&(c="");b=c}c=uc(b);a.defaultValue=c;d=a.textContent;d===c&&""!==d&&null!==d&&(a.value=d)}var Jc;
 function Kc(a,b){if("http://www.w3.org/2000/svg"!==a.namespaceURI||"innerHTML"in a)a.innerHTML=b;else{Jc=Jc||document.createElement("div");Jc.innerHTML="<svg>"+b.valueOf().toString()+"</svg>";for(b=Jc.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;b.firstChild;)a.appendChild(b.firstChild)}}var Lc=Kc;"undefined"!==typeof MSApp&&MSApp.execUnsafeLocalFunction&&(Lc=function(a,b){return MSApp.execUnsafeLocalFunction(function(){return Kc(a,b)})});var Mc=Lc;
 function Nc(a,b){if(b){var c=a.firstChild;if(c&&c===a.lastChild&&3===c.nodeType){c.nodeValue=b;return}}a.textContent=b}var Oc=new Set("animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp".split(" "));
 function Pc(a,b,c){var d=0===b.indexOf("--");null==c||"boolean"===typeof c||""===c?d?a.setProperty(b,""):"float"===b?a.cssFloat="":a[b]="":d?a.setProperty(b,c):"number"!==typeof c||0===c||Oc.has(b)?"float"===b?a.cssFloat=c:a[b]=(""+c).trim():a[b]=c+"px"}
-function Qc(a,b,c){if(null!=b&&"object"!==typeof b)throw Error(t(62));a=a.style;if(null!=c){for(var d in c)!c.hasOwnProperty(d)||null!=b&&b.hasOwnProperty(d)||(0===d.indexOf("--")?a.setProperty(d,""):"float"===d?a.cssFloat="":a[d]="");for(var e in b)d=b[e],b.hasOwnProperty(e)&&c[e]!==d&&Pc(a,e,d)}else for(var f in b)b.hasOwnProperty(f)&&Pc(a,f,b[f])}
+function Qc(a,b,c){if(null!=b&&"object"!==typeof b)throw Error(u(62));a=a.style;if(null!=c){for(var d in c)!c.hasOwnProperty(d)||null!=b&&b.hasOwnProperty(d)||(0===d.indexOf("--")?a.setProperty(d,""):"float"===d?a.cssFloat="":a[d]="");for(var e in b)d=b[e],b.hasOwnProperty(e)&&c[e]!==d&&Pc(a,e,d)}else for(var f in b)b.hasOwnProperty(f)&&Pc(a,f,b[f])}
 function Rc(a){if(-1===a.indexOf("-"))return!1;switch(a){case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph":return!1;default:return!0}}
 var Sc=new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv","http-equiv"],["crossOrigin","crossorigin"],["accentHeight","accent-height"],["alignmentBaseline","alignment-baseline"],["arabicForm","arabic-form"],["baselineShift","baseline-shift"],["capHeight","cap-height"],["clipPath","clip-path"],["clipRule","clip-rule"],["colorInterpolation","color-interpolation"],["colorInterpolationFilters","color-interpolation-filters"],["colorProfile","color-profile"],["colorRendering","color-rendering"],
 ["dominantBaseline","dominant-baseline"],["enableBackground","enable-background"],["fillOpacity","fill-opacity"],["fillRule","fill-rule"],["floodColor","flood-color"],["floodOpacity","flood-opacity"],["fontFamily","font-family"],["fontSize","font-size"],["fontSizeAdjust","font-size-adjust"],["fontStretch","font-stretch"],["fontStyle","font-style"],["fontVariant","font-variant"],["fontWeight","font-weight"],["glyphName","glyph-name"],["glyphOrientationHorizontal","glyph-orientation-horizontal"],["glyphOrientationVertical",
@@ -73,64 +62,64 @@ var Sc=new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv
 "shape-rendering"],["stopColor","stop-color"],["stopOpacity","stop-opacity"],["strikethroughPosition","strikethrough-position"],["strikethroughThickness","strikethrough-thickness"],["strokeDasharray","stroke-dasharray"],["strokeDashoffset","stroke-dashoffset"],["strokeLinecap","stroke-linecap"],["strokeLinejoin","stroke-linejoin"],["strokeMiterlimit","stroke-miterlimit"],["strokeOpacity","stroke-opacity"],["strokeWidth","stroke-width"],["textAnchor","text-anchor"],["textDecoration","text-decoration"],
 ["textRendering","text-rendering"],["transformOrigin","transform-origin"],["underlinePosition","underline-position"],["underlineThickness","underline-thickness"],["unicodeBidi","unicode-bidi"],["unicodeRange","unicode-range"],["unitsPerEm","units-per-em"],["vAlphabetic","v-alphabetic"],["vHanging","v-hanging"],["vIdeographic","v-ideographic"],["vMathematical","v-mathematical"],["vectorEffect","vector-effect"],["vertAdvY","vert-adv-y"],["vertOriginX","vert-origin-x"],["vertOriginY","vert-origin-y"],
 ["wordSpacing","word-spacing"],["writingMode","writing-mode"],["xmlnsXlink","xmlns:xlink"],["xHeight","x-height"]]),Tc=null;function Uc(a){a=a.target||a.srcElement||window;a.correspondingUseElement&&(a=a.correspondingUseElement);return 3===a.nodeType?a.parentNode:a}var Vc=null,Wc=null;
-function Xc(a){var b=Xb(a);if(b&&(a=b.stateNode)){var c=Zb(a);a:switch(a=b.stateNode,b.type){case "input":Cc(a,c.value,c.defaultValue,c.defaultValue,c.checked,c.defaultChecked,c.type,c.name);b=c.name;if("radio"===c.type&&null!=b){for(c=a;c.parentNode;)c=c.parentNode;c=c.querySelectorAll('input[name="'+Bc(""+b)+'"][type="radio"]');for(b=0;b<c.length;b++){var d=c[b];if(d!==a&&d.form===a.form){var e=Zb(d);if(!e)throw Error(t(90));Cc(d,e.value,e.defaultValue,e.defaultValue,e.checked,e.defaultChecked,
+function Xc(a){var b=Xb(a);if(b&&(a=b.stateNode)){var c=Zb(a);a:switch(a=b.stateNode,b.type){case "input":Cc(a,c.value,c.defaultValue,c.defaultValue,c.checked,c.defaultChecked,c.type,c.name);b=c.name;if("radio"===c.type&&null!=b){for(c=a;c.parentNode;)c=c.parentNode;c=c.querySelectorAll('input[name="'+Bc(""+b)+'"][type="radio"]');for(b=0;b<c.length;b++){var d=c[b];if(d!==a&&d.form===a.form){var e=Zb(d);if(!e)throw Error(u(90));Cc(d,e.value,e.defaultValue,e.defaultValue,e.checked,e.defaultChecked,
 e.type,e.name)}}for(b=0;b<c.length;b++)d=c[b],d.form===a.form&&yc(d)}break a;case "textarea":Hc(a,c.value,c.defaultValue);break a;case "select":b=c.value,null!=b&&Gc(a,!!c.multiple,b,!1)}}}function Yc(a){Vc?Wc?Wc.push(a):Wc=[a]:Vc=a}function Zc(){if(Vc){var a=Vc,b=Wc;Wc=Vc=null;Xc(a);if(b)for(a=0;a<b.length;a++)Xc(b[a])}}function $c(a){var b=a,c=a;if(a.alternate)for(;b.return;)b=b.return;else{a=b;do b=a,0!==(b.flags&4098)&&(c=b.return),a=b.return;while(a)}return 3===b.tag?c:null}
-function ad(a){if(13===a.tag){var b=a.memoizedState;null===b&&(a=a.alternate,null!==a&&(b=a.memoizedState));if(null!==b)return b.dehydrated}return null}function bd(a){if($c(a)!==a)throw Error(t(188));}
-function cd(a){var b=a.alternate;if(!b){b=$c(a);if(null===b)throw Error(t(188));return b!==a?null:a}for(var c=a,d=b;;){var e=c.return;if(null===e)break;var f=e.alternate;if(null===f){d=e.return;if(null!==d){c=d;continue}break}if(e.child===f.child){for(f=e.child;f;){if(f===c)return bd(e),a;if(f===d)return bd(e),b;f=f.sibling}throw Error(t(188));}if(c.return!==d.return)c=e,d=f;else{for(var g=!1,h=e.child;h;){if(h===c){g=!0;c=e;d=f;break}if(h===d){g=!0;d=e;c=f;break}h=h.sibling}if(!g){for(h=f.child;h;){if(h===
-c){g=!0;c=f;d=e;break}if(h===d){g=!0;d=f;c=e;break}h=h.sibling}if(!g)throw Error(t(189));}}if(c.alternate!==d)throw Error(t(190));}if(3!==c.tag)throw Error(t(188));return c.stateNode.current===c?a:b}function dd(a){a=cd(a);return null!==a?ed(a):null}function ed(a){var b=a.tag;if(5===b||26===b||27===b||6===b)return a;for(a=a.child;null!==a;){b=ed(a);if(null!==b)return b;a=a.sibling}return null}var fd={},gd=ka(fd),hd=ka(!1),id=fd;
+function ad(a){if(13===a.tag){var b=a.memoizedState;null===b&&(a=a.alternate,null!==a&&(b=a.memoizedState));if(null!==b)return b.dehydrated}return null}function bd(a){if($c(a)!==a)throw Error(u(188));}
+function cd(a){var b=a.alternate;if(!b){b=$c(a);if(null===b)throw Error(u(188));return b!==a?null:a}for(var c=a,d=b;;){var e=c.return;if(null===e)break;var f=e.alternate;if(null===f){d=e.return;if(null!==d){c=d;continue}break}if(e.child===f.child){for(f=e.child;f;){if(f===c)return bd(e),a;if(f===d)return bd(e),b;f=f.sibling}throw Error(u(188));}if(c.return!==d.return)c=e,d=f;else{for(var g=!1,h=e.child;h;){if(h===c){g=!0;c=e;d=f;break}if(h===d){g=!0;d=e;c=f;break}h=h.sibling}if(!g){for(h=f.child;h;){if(h===
+c){g=!0;c=f;d=e;break}if(h===d){g=!0;d=f;c=e;break}h=h.sibling}if(!g)throw Error(u(189));}}if(c.alternate!==d)throw Error(u(190));}if(3!==c.tag)throw Error(u(188));return c.stateNode.current===c?a:b}function dd(a){a=cd(a);return null!==a?ed(a):null}function ed(a){var b=a.tag;if(5===b||26===b||27===b||6===b)return a;for(a=a.child;null!==a;){b=ed(a);if(null!==b)return b;a=a.sibling}return null}var fd={},gd=ka(fd),hd=ka(!1),id=fd;
 function jd(a,b){var c=a.type.contextTypes;if(!c)return fd;var d=a.stateNode;if(d&&d.__reactInternalMemoizedUnmaskedChildContext===b)return d.__reactInternalMemoizedMaskedChildContext;var e={},f;for(f in c)e[f]=b[f];d&&(a=a.stateNode,a.__reactInternalMemoizedUnmaskedChildContext=b,a.__reactInternalMemoizedMaskedChildContext=e);return e}function kd(a){a=a.childContextTypes;return null!==a&&void 0!==a}function ld(){D(hd);D(gd)}
-function md(a,b,c){if(gd.current!==fd)throw Error(t(168));E(gd,b);E(hd,c)}function nd(a,b,c){var d=a.stateNode;b=b.childContextTypes;if("function"!==typeof d.getChildContext)return c;d=d.getChildContext();for(var e in d)if(!(e in b))throw Error(t(108,tc(a)||"Unknown",e));return w({},c,d)}function od(a){a=(a=a.stateNode)&&a.__reactInternalMemoizedMergedChildContext||fd;id=gd.current;E(gd,a);E(hd,hd.current);return!0}
-function pd(a,b,c){var d=a.stateNode;if(!d)throw Error(t(169));c?(a=nd(a,b,id),d.__reactInternalMemoizedMergedChildContext=a,D(hd),D(gd),E(gd,a)):D(hd);E(hd,c)}function qd(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var rd="function"===typeof Object.is?Object.is:qd,sd=[],td=0,ud=null,vd=0,wd=[],xd=0,yd=null,zd=1,Ad="";function Bd(a,b){sd[td++]=vd;sd[td++]=ud;ud=a;vd=b}
+function md(a,b,c){if(gd.current!==fd)throw Error(u(168));E(gd,b);E(hd,c)}function nd(a,b,c){var d=a.stateNode;b=b.childContextTypes;if("function"!==typeof d.getChildContext)return c;d=d.getChildContext();for(var e in d)if(!(e in b))throw Error(u(108,tc(a)||"Unknown",e));return x({},c,d)}function od(a){a=(a=a.stateNode)&&a.__reactInternalMemoizedMergedChildContext||fd;id=gd.current;E(gd,a);E(hd,hd.current);return!0}
+function pd(a,b,c){var d=a.stateNode;if(!d)throw Error(u(169));c?(a=nd(a,b,id),d.__reactInternalMemoizedMergedChildContext=a,D(hd),D(gd),E(gd,a)):D(hd);E(hd,c)}function qd(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var rd="function"===typeof Object.is?Object.is:qd,sd=[],td=0,ud=null,vd=0,wd=[],xd=0,yd=null,zd=1,Ad="";function Bd(a,b){sd[td++]=vd;sd[td++]=ud;ud=a;vd=b}
 function Cd(a,b,c){wd[xd++]=zd;wd[xd++]=Ad;wd[xd++]=yd;yd=a;var d=zd;a=Ad;var e=32-pb(d)-1;d&=~(1<<e);c+=1;var f=32-pb(b)+e;if(30<f){var g=e-e%5;f=(d&(1<<g)-1).toString(32);d>>=g;e-=g;zd=1<<32-pb(b)+e|c<<e|d;Ad=f+a}else zd=1<<f|c<<e|d,Ad=a}function Dd(a){null!==a.return&&(Bd(a,1),Cd(a,1,0))}function Ed(a){for(;a===ud;)ud=sd[--td],sd[td]=null,vd=sd[--td],sd[td]=null;for(;a===yd;)yd=wd[--xd],wd[xd]=null,Ad=wd[--xd],wd[xd]=null,zd=wd[--xd],wd[xd]=null}var H=null,I=null,K=!1,Fd=null,Gd=!1;
 function Hd(a,b){var c=Id(5,null,null,0);c.elementType="DELETED";c.stateNode=b;c.return=a;b=a.deletions;null===b?(a.deletions=[c],a.flags|=16):b.push(c)}function Jd(a,b){b.flags=b.flags&-4097|2}function Kd(a,b){b=Ld(b,a.type,a.pendingProps,Gd);return null!==b?(a.stateNode=b,H=a,I=Md(b.firstChild),Gd=!1,!0):!1}function Nd(a,b){b=Od(b,a.pendingProps,Gd);return null!==b?(a.stateNode=b,H=a,I=null,!0):!1}
-function Pd(a,b){a:{var c=b;for(b=Gd;8!==c.nodeType;){if(!b){b=null;break a}c=Qd(c);if(null===c){b=null;break a}}b=c}return null!==b?(c=null!==yd?{id:zd,overflow:Ad}:null,a.memoizedState={dehydrated:b,treeContext:c,retryLane:536870912},c=Id(18,null,null,0),c.stateNode=b,c.return=a,a.child=c,H=a,I=null,!0):!1}function Rd(a){return 0!==(a.mode&1)&&0===(a.flags&128)}function Sd(){throw Error(t(418));}
+function Pd(a,b){a:{var c=b;for(b=Gd;8!==c.nodeType;){if(!b){b=null;break a}c=Qd(c);if(null===c){b=null;break a}}b=c}return null!==b?(c=null!==yd?{id:zd,overflow:Ad}:null,a.memoizedState={dehydrated:b,treeContext:c,retryLane:536870912},c=Id(18,null,null,0),c.stateNode=b,c.return=a,a.child=c,H=a,I=null,!0):!1}function Rd(a){return 0!==(a.mode&1)&&0===(a.flags&128)}function Sd(){throw Error(u(418));}
 function Td(a){for(H=a.return;H;)switch(H.tag){case 3:case 27:Gd=!0;return;case 5:case 13:Gd=!1;return;default:H=H.return}}
-function Ud(a){if(a!==H)return!1;if(!K)return Td(a),K=!0,!1;var b=!1,c;if(c=3!==a.tag&&27!==a.tag){if(c=5===a.tag)c=a.type,c=!("form"!==c&&"button"!==c)||Vd(a.type,a.memoizedProps);c=!c}c&&(b=!0);if(b&&(b=I))if(Rd(a))Wd(),Sd();else for(;b;)Hd(a,b),b=Qd(b);Td(a);if(13===a.tag){a=a.memoizedState;a=null!==a?a.dehydrated:null;if(!a)throw Error(t(317));a:{a=a.nextSibling;for(b=0;a;){if(8===a.nodeType)if(c=a.data,"/$"===c){if(0===b){I=Qd(a);break a}b--}else"$"!==c&&"$!"!==c&&"$?"!==c||b++;a=a.nextSibling}I=
+function Ud(a){if(a!==H)return!1;if(!K)return Td(a),K=!0,!1;var b=!1,c;if(c=3!==a.tag&&27!==a.tag){if(c=5===a.tag)c=a.type,c=!("form"!==c&&"button"!==c)||Vd(a.type,a.memoizedProps);c=!c}c&&(b=!0);if(b&&(b=I))if(Rd(a))Wd(),Sd();else for(;b;)Hd(a,b),b=Qd(b);Td(a);if(13===a.tag){a=a.memoizedState;a=null!==a?a.dehydrated:null;if(!a)throw Error(u(317));a:{a=a.nextSibling;for(b=0;a;){if(8===a.nodeType)if(c=a.data,"/$"===c){if(0===b){I=Qd(a);break a}b--}else"$"!==c&&"$!"!==c&&"$?"!==c||b++;a=a.nextSibling}I=
 null}}else I=H?Qd(a.stateNode):null;return!0}function Wd(){for(var a=I;a;)a=Qd(a)}function Xd(){I=H=null;K=!1}function Yd(a){null===Fd?Fd=[a]:Fd.push(a)}var Zd=[],$d=0,ae=0;function be(){for(var a=$d,b=ae=$d=0;b<a;){var c=Zd[b];Zd[b++]=null;var d=Zd[b];Zd[b++]=null;var e=Zd[b];Zd[b++]=null;var f=Zd[b];Zd[b++]=null;if(null!==d&&null!==e){var g=d.pending;null===g?e.next=e:(e.next=g.next,g.next=e);d.pending=e}0!==f&&ce(c,e,f)}}
 function de(a,b,c,d){Zd[$d++]=a;Zd[$d++]=b;Zd[$d++]=c;Zd[$d++]=d;ae|=d;a.lanes|=d;a=a.alternate;null!==a&&(a.lanes|=d)}function ee(a,b,c,d){de(a,b,c,d);return fe(a)}function ge(a,b){de(a,null,null,b);return fe(a)}
-function ce(a,b,c){a.lanes|=c;var d=a.alternate;null!==d&&(d.lanes|=c);for(var e=!1,f=a.return;null!==f;)f.childLanes|=c,d=f.alternate,null!==d&&(d.childLanes|=c),22===f.tag&&(a=f.stateNode,null===a||a._visibility&1||(e=!0)),a=f,f=f.return;e&&null!==b&&3===a.tag&&(f=a.stateNode,e=31-pb(c),f=f.hiddenUpdates,a=f[e],null===a?f[e]=[b]:a.push(b),b.lane=c|536870912)}function fe(a){if(50<he)throw he=0,ie=null,Error(t(185));for(var b=a.return;null!==b;)a=b,b=a.return;return 3===a.tag?a.stateNode:null}
+function ce(a,b,c){a.lanes|=c;var d=a.alternate;null!==d&&(d.lanes|=c);for(var e=!1,f=a.return;null!==f;)f.childLanes|=c,d=f.alternate,null!==d&&(d.childLanes|=c),22===f.tag&&(a=f.stateNode,null===a||a._visibility&1||(e=!0)),a=f,f=f.return;e&&null!==b&&3===a.tag&&(f=a.stateNode,e=31-pb(c),f=f.hiddenUpdates,a=f[e],null===a?f[e]=[b]:a.push(b),b.lane=c|536870912)}function fe(a){if(50<he)throw he=0,ie=null,Error(u(185));for(var b=a.return;null!==b;)a=b,b=a.return;return 3===a.tag?a.stateNode:null}
 var je=!1;function ke(a){a.updateQueue={baseState:a.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,lanes:0,hiddenCallbacks:null},callbacks:null}}function le(a,b){a=a.updateQueue;b.updateQueue===a&&(b.updateQueue={baseState:a.baseState,firstBaseUpdate:a.firstBaseUpdate,lastBaseUpdate:a.lastBaseUpdate,shared:a.shared,callbacks:null})}function me(a){return{lane:a,tag:0,payload:null,callback:null,next:null}}
 function ne(a,b,c){var d=a.updateQueue;if(null===d)return null;d=d.shared;if(0!==(N&2)){var e=d.pending;null===e?b.next=b:(b.next=e.next,e.next=b);d.pending=b;b=fe(a);ce(a,null,c);return b}de(a,d,b,c);return fe(a)}function oe(a,b,c){b=b.updateQueue;if(null!==b&&(b=b.shared,0!==(c&4194176))){var d=b.lanes;d&=a.pendingLanes;c|=d;b.lanes=c;Db(a,c)}}
 function pe(a,b){var c=a.updateQueue,d=a.alternate;if(null!==d&&(d=d.updateQueue,c===d)){var e=null,f=null;c=c.firstBaseUpdate;if(null!==c){do{var g={lane:c.lane,tag:c.tag,payload:c.payload,callback:null,next:null};null===f?e=f=g:f=f.next=g;c=c.next}while(null!==c);null===f?e=f=b:f=f.next=b}else e=f=b;c={baseState:d.baseState,firstBaseUpdate:e,lastBaseUpdate:f,shared:d.shared,callbacks:d.callbacks};a.updateQueue=c;return}a=c.lastBaseUpdate;null===a?c.firstBaseUpdate=b:a.next=b;c.lastBaseUpdate=b}
-function qe(a,b,c,d){var e=a.updateQueue;je=!1;var f=e.firstBaseUpdate,g=e.lastBaseUpdate,h=e.shared.pending;if(null!==h){e.shared.pending=null;var l=h,p=l.next;l.next=null;null===g?f=p:g.next=p;g=l;var q=a.alternate;null!==q&&(q=q.updateQueue,h=q.lastBaseUpdate,h!==g&&(null===h?q.firstBaseUpdate=p:h.next=p,q.lastBaseUpdate=l))}if(null!==f){var x=e.baseState;g=0;q=p=l=null;h=f;do{var r=h.lane&-536870913,u=r!==h.lane;if(u?(O&r)===r:(d&r)===r){null!==q&&(q=q.next={lane:0,tag:h.tag,payload:h.payload,
-callback:null,next:null});a:{var A=a,C=h;r=b;var J=c;switch(C.tag){case 1:A=C.payload;if("function"===typeof A){x=A.call(J,x,r);break a}x=A;break a;case 3:A.flags=A.flags&-65537|128;case 0:A=C.payload;r="function"===typeof A?A.call(J,x,r):A;if(null===r||void 0===r)break a;x=w({},x,r);break a;case 2:je=!0}}r=h.callback;null!==r&&(a.flags|=64,u&&(a.flags|=8192),u=e.callbacks,null===u?e.callbacks=[r]:u.push(r))}else u={lane:r,tag:h.tag,payload:h.payload,callback:h.callback,next:null},null===q?(p=q=u,
-l=x):q=q.next=u,g|=r;h=h.next;if(null===h)if(h=e.shared.pending,null===h)break;else u=h,h=u.next,u.next=null,e.lastBaseUpdate=u,e.shared.pending=null}while(1);null===q&&(l=x);e.baseState=l;e.firstBaseUpdate=p;e.lastBaseUpdate=q;null===f&&(e.shared.lanes=0);re|=g;a.lanes=g;a.memoizedState=x}}function se(a,b){if("function"!==typeof a)throw Error(t(191,a));a.call(b)}function te(a,b){var c=a.callbacks;if(null!==c)for(a.callbacks=null,a=0;a<c.length;a++)se(c[a],b)}
-function ue(a,b){if(rd(a,b))return!0;if("object"!==typeof a||null===a||"object"!==typeof b||null===b)return!1;var c=Object.keys(a),d=Object.keys(b);if(c.length!==d.length)return!1;for(d=0;d<c.length;d++){var e=c[d];if(!Jb.call(b,e)||!rd(a[e],b[e]))return!1}return!0}var ve=Error(t(460)),we=Error(t(474)),xe={then:function(){}};function ye(a){a=a.status;return"fulfilled"===a||"rejected"===a}function ze(){}
-function Ae(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(ze,ze),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":a=b.reason;if(a===ve)throw Error(t(483));throw a;default:if("string"===typeof b.status)b.then(ze,ze);else{a=P;if(null!==a&&100<a.shellSuspendCounter)throw Error(t(482));a=b;a.status="pending";a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}});switch(b.status){case "fulfilled":return b.value;
-case "rejected":a=b.reason;if(a===ve)throw Error(t(483));throw a;}}Be=b;throw ve;}}var Be=null;function Ce(){if(null===Be)throw Error(t(459));var a=Be;Be=null;return a}var De=null,Ee=0;function Fe(a){var b=Ee;Ee+=1;null===De&&(De=[]);return Ae(De,a,b)}
-function Ge(a,b,c){a=c.ref;if(null!==a&&"function"!==typeof a&&"object"!==typeof a){if(c._owner){c=c._owner;if(c){if(1!==c.tag)throw Error(t(309));var d=c.stateNode}if(!d)throw Error(t(147,a));var e=d,f=""+a;if(null!==b&&null!==b.ref&&"function"===typeof b.ref&&b.ref._stringRef===f)return b.ref;b=function(g){var h=e.refs;null===g?delete h[f]:h[f]=g};b._stringRef=f;return b}if("string"!==typeof a)throw Error(t(284));if(!c._owner)throw Error(t(290,a));}return a}
-function He(a,b){a=Object.prototype.toString.call(b);throw Error(t(31,"[object Object]"===a?"object with keys {"+Object.keys(b).join(", ")+"}":a));}function Ie(a){var b=a._init;return b(a._payload)}
+function qe(a,b,c,d){var e=a.updateQueue;je=!1;var f=e.firstBaseUpdate,g=e.lastBaseUpdate,h=e.shared.pending;if(null!==h){e.shared.pending=null;var l=h,p=l.next;l.next=null;null===g?f=p:g.next=p;g=l;var q=a.alternate;null!==q&&(q=q.updateQueue,h=q.lastBaseUpdate,h!==g&&(null===h?q.firstBaseUpdate=p:h.next=p,q.lastBaseUpdate=l))}if(null!==f){var w=e.baseState;g=0;q=p=l=null;h=f;do{var r=h.lane&-536870913,t=r!==h.lane;if(t?(O&r)===r:(d&r)===r){null!==q&&(q=q.next={lane:0,tag:h.tag,payload:h.payload,
+callback:null,next:null});a:{var A=a,C=h;r=b;var J=c;switch(C.tag){case 1:A=C.payload;if("function"===typeof A){w=A.call(J,w,r);break a}w=A;break a;case 3:A.flags=A.flags&-65537|128;case 0:A=C.payload;r="function"===typeof A?A.call(J,w,r):A;if(null===r||void 0===r)break a;w=x({},w,r);break a;case 2:je=!0}}r=h.callback;null!==r&&(a.flags|=64,t&&(a.flags|=8192),t=e.callbacks,null===t?e.callbacks=[r]:t.push(r))}else t={lane:r,tag:h.tag,payload:h.payload,callback:h.callback,next:null},null===q?(p=q=t,
+l=w):q=q.next=t,g|=r;h=h.next;if(null===h)if(h=e.shared.pending,null===h)break;else t=h,h=t.next,t.next=null,e.lastBaseUpdate=t,e.shared.pending=null}while(1);null===q&&(l=w);e.baseState=l;e.firstBaseUpdate=p;e.lastBaseUpdate=q;null===f&&(e.shared.lanes=0);re|=g;a.lanes=g;a.memoizedState=w}}function se(a,b){if("function"!==typeof a)throw Error(u(191,a));a.call(b)}function te(a,b){var c=a.callbacks;if(null!==c)for(a.callbacks=null,a=0;a<c.length;a++)se(c[a],b)}
+function ue(a,b){if(rd(a,b))return!0;if("object"!==typeof a||null===a||"object"!==typeof b||null===b)return!1;var c=Object.keys(a),d=Object.keys(b);if(c.length!==d.length)return!1;for(d=0;d<c.length;d++){var e=c[d];if(!Jb.call(b,e)||!rd(a[e],b[e]))return!1}return!0}var ve=Error(u(460)),we=Error(u(474)),xe={then:function(){}};function ye(a){a=a.status;return"fulfilled"===a||"rejected"===a}function ze(){}
+function Ae(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(ze,ze),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":a=b.reason;if(a===ve)throw Error(u(483));throw a;default:if("string"===typeof b.status)b.then(ze,ze);else{a=P;if(null!==a&&100<a.shellSuspendCounter)throw Error(u(482));a=b;a.status="pending";a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}});switch(b.status){case "fulfilled":return b.value;
+case "rejected":a=b.reason;if(a===ve)throw Error(u(483));throw a;}}Be=b;throw ve;}}var Be=null;function Ce(){if(null===Be)throw Error(u(459));var a=Be;Be=null;return a}var De=null,Ee=0;function Fe(a){var b=Ee;Ee+=1;null===De&&(De=[]);return Ae(De,a,b)}
+function Ge(a,b,c){a=c.ref;if(null!==a&&"function"!==typeof a&&"object"!==typeof a){if(c._owner){c=c._owner;if(c){if(1!==c.tag)throw Error(u(309));var d=c.stateNode}if(!d)throw Error(u(147,a));var e=d,f=""+a;if(null!==b&&null!==b.ref&&"function"===typeof b.ref&&b.ref._stringRef===f)return b.ref;b=function(g){var h=e.refs;null===g?delete h[f]:h[f]=g};b._stringRef=f;return b}if("string"!==typeof a)throw Error(u(284));if(!c._owner)throw Error(u(290,a));}return a}
+function He(a,b){a=Object.prototype.toString.call(b);throw Error(u(31,"[object Object]"===a?"object with keys {"+Object.keys(b).join(", ")+"}":a));}function Ie(a){var b=a._init;return b(a._payload)}
 function Je(a){function b(m,k){if(a){var n=m.deletions;null===n?(m.deletions=[k],m.flags|=16):n.push(k)}}function c(m,k){if(!a)return null;for(;null!==k;)b(m,k),k=k.sibling;return null}function d(m,k){for(m=new Map;null!==k;)null!==k.key?m.set(k.key,k):m.set(k.index,k),k=k.sibling;return m}function e(m,k){m=Ke(m,k);m.index=0;m.sibling=null;return m}function f(m,k,n){m.index=n;if(!a)return m.flags|=1048576,k;n=m.alternate;if(null!==n)return n=n.index,n<k?(m.flags|=33554434,k):n;m.flags|=33554434;return k}
 function g(m){a&&null===m.alternate&&(m.flags|=33554434);return m}function h(m,k,n,v){if(null===k||6!==k.tag)return k=Le(n,m.mode,v),k.return=m,k;k=e(k,n);k.return=m;return k}function l(m,k,n,v){var y=n.type;if(y===na)return q(m,k,n.props.children,v,n.key);if(null!==k&&(k.elementType===y||"object"===typeof y&&null!==y&&y.$$typeof===xa&&Ie(y)===k.type))return v=e(k,n.props),v.ref=Ge(m,k,n),v.return=m,v;v=Me(n.type,n.key,n.props,null,null,m.mode,v);v.ref=Ge(m,k,n);v.return=m;return v}function p(m,k,
-n,v){if(null===k||4!==k.tag||k.stateNode.containerInfo!==n.containerInfo||k.stateNode.implementation!==n.implementation)return k=Ne(n,m.mode,v),k.return=m,k;k=e(k,n.children||[]);k.return=m;return k}function q(m,k,n,v,y){if(null===k||7!==k.tag)return k=Oe(n,m.mode,v,y),k.return=m,k;k=e(k,n);k.return=m;return k}function x(m,k,n){if("string"===typeof k&&""!==k||"number"===typeof k)return k=Le(""+k,m.mode,n),k.return=m,k;if("object"===typeof k&&null!==k){switch(k.$$typeof){case la:return n=Me(k.type,
-k.key,k.props,null,null,m.mode,n),n.ref=Ge(m,null,k),n.return=m,n;case ma:return k=Ne(k,m.mode,n),k.return=m,k;case xa:var v=k._init;return x(m,v(k._payload),n)}if(Fc(k)||Da(k))return k=Oe(k,m.mode,n,null),k.return=m,k;if("function"===typeof k.then)return x(m,Fe(k),n);if(k.$$typeof===ra||k.$$typeof===sa)return x(m,Pe(m,k,n),n);He(m,k)}return null}function r(m,k,n,v){var y=null!==k?k.key:null;if("string"===typeof n&&""!==n||"number"===typeof n)return null!==y?null:h(m,k,""+n,v);if("object"===typeof n&&
-null!==n){switch(n.$$typeof){case la:return n.key===y?l(m,k,n,v):null;case ma:return n.key===y?p(m,k,n,v):null;case xa:return y=n._init,r(m,k,y(n._payload),v)}if(Fc(n)||Da(n))return null!==y?null:q(m,k,n,v,null);if("function"===typeof n.then)return r(m,k,Fe(n),v);if(n.$$typeof===ra||n.$$typeof===sa)return r(m,k,Pe(m,n,v),v);He(m,n)}return null}function u(m,k,n,v,y){if("string"===typeof v&&""!==v||"number"===typeof v)return m=m.get(n)||null,h(k,m,""+v,y);if("object"===typeof v&&null!==v){switch(v.$$typeof){case la:return m=
-m.get(null===v.key?n:v.key)||null,l(k,m,v,y);case ma:return m=m.get(null===v.key?n:v.key)||null,p(k,m,v,y);case xa:var B=v._init;return u(m,k,n,B(v._payload),y)}if(Fc(v)||Da(v))return m=m.get(n)||null,q(k,m,v,y,null);if("function"===typeof v.then)return u(m,k,n,Fe(v),y);if(v.$$typeof===ra||v.$$typeof===sa)return u(m,k,n,Pe(k,v,y),y);He(k,v)}return null}function A(m,k,n,v){for(var y=null,B=null,z=k,L=k=0,ja=null;null!==z&&L<n.length;L++){z.index>L?(ja=z,z=null):ja=z.sibling;var M=r(m,z,n[L],v);if(null===
-M){null===z&&(z=ja);break}a&&z&&null===M.alternate&&b(m,z);k=f(M,k,L);null===B?y=M:B.sibling=M;B=M;z=ja}if(L===n.length)return c(m,z),K&&Bd(m,L),y;if(null===z){for(;L<n.length;L++)z=x(m,n[L],v),null!==z&&(k=f(z,k,L),null===B?y=z:B.sibling=z,B=z);K&&Bd(m,L);return y}for(z=d(m,z);L<n.length;L++)ja=u(z,m,L,n[L],v),null!==ja&&(a&&null!==ja.alternate&&z.delete(null===ja.key?L:ja.key),k=f(ja,k,L),null===B?y=ja:B.sibling=ja,B=ja);a&&z.forEach(function(Kb){return b(m,Kb)});K&&Bd(m,L);return y}function C(m,
-k,n,v){var y=Da(n);if("function"!==typeof y)throw Error(t(150));n=y.call(n);if(null==n)throw Error(t(151));for(var B=y=null,z=k,L=k=0,ja=null,M=n.next();null!==z&&!M.done;L++,M=n.next()){z.index>L?(ja=z,z=null):ja=z.sibling;var Kb=r(m,z,M.value,v);if(null===Kb){null===z&&(z=ja);break}a&&z&&null===Kb.alternate&&b(m,z);k=f(Kb,k,L);null===B?y=Kb:B.sibling=Kb;B=Kb;z=ja}if(M.done)return c(m,z),K&&Bd(m,L),y;if(null===z){for(;!M.done;L++,M=n.next())M=x(m,M.value,v),null!==M&&(k=f(M,k,L),null===B?y=M:B.sibling=
-M,B=M);K&&Bd(m,L);return y}for(z=d(m,z);!M.done;L++,M=n.next())M=u(z,m,L,M.value,v),null!==M&&(a&&null!==M.alternate&&z.delete(null===M.key?L:M.key),k=f(M,k,L),null===B?y=M:B.sibling=M,B=M);a&&z.forEach(function(un){return b(m,un)});K&&Bd(m,L);return y}function J(m,k,n,v){"object"===typeof n&&null!==n&&n.type===na&&null===n.key&&(n=n.props.children);if("object"===typeof n&&null!==n){switch(n.$$typeof){case la:a:{for(var y=n.key,B=k;null!==B;){if(B.key===y){y=n.type;if(y===na){if(7===B.tag){c(m,B.sibling);
+n,v){if(null===k||4!==k.tag||k.stateNode.containerInfo!==n.containerInfo||k.stateNode.implementation!==n.implementation)return k=Ne(n,m.mode,v),k.return=m,k;k=e(k,n.children||[]);k.return=m;return k}function q(m,k,n,v,y){if(null===k||7!==k.tag)return k=Oe(n,m.mode,v,y),k.return=m,k;k=e(k,n);k.return=m;return k}function w(m,k,n){if("string"===typeof k&&""!==k||"number"===typeof k)return k=Le(""+k,m.mode,n),k.return=m,k;if("object"===typeof k&&null!==k){switch(k.$$typeof){case la:return n=Me(k.type,
+k.key,k.props,null,null,m.mode,n),n.ref=Ge(m,null,k),n.return=m,n;case ma:return k=Ne(k,m.mode,n),k.return=m,k;case xa:var v=k._init;return w(m,v(k._payload),n)}if(Fc(k)||Da(k))return k=Oe(k,m.mode,n,null),k.return=m,k;if("function"===typeof k.then)return w(m,Fe(k),n);if(k.$$typeof===ra||k.$$typeof===sa)return w(m,Pe(m,k,n),n);He(m,k)}return null}function r(m,k,n,v){var y=null!==k?k.key:null;if("string"===typeof n&&""!==n||"number"===typeof n)return null!==y?null:h(m,k,""+n,v);if("object"===typeof n&&
+null!==n){switch(n.$$typeof){case la:return n.key===y?l(m,k,n,v):null;case ma:return n.key===y?p(m,k,n,v):null;case xa:return y=n._init,r(m,k,y(n._payload),v)}if(Fc(n)||Da(n))return null!==y?null:q(m,k,n,v,null);if("function"===typeof n.then)return r(m,k,Fe(n),v);if(n.$$typeof===ra||n.$$typeof===sa)return r(m,k,Pe(m,n,v),v);He(m,n)}return null}function t(m,k,n,v,y){if("string"===typeof v&&""!==v||"number"===typeof v)return m=m.get(n)||null,h(k,m,""+v,y);if("object"===typeof v&&null!==v){switch(v.$$typeof){case la:return m=
+m.get(null===v.key?n:v.key)||null,l(k,m,v,y);case ma:return m=m.get(null===v.key?n:v.key)||null,p(k,m,v,y);case xa:var B=v._init;return t(m,k,n,B(v._payload),y)}if(Fc(v)||Da(v))return m=m.get(n)||null,q(k,m,v,y,null);if("function"===typeof v.then)return t(m,k,n,Fe(v),y);if(v.$$typeof===ra||v.$$typeof===sa)return t(m,k,n,Pe(k,v,y),y);He(k,v)}return null}function A(m,k,n,v){for(var y=null,B=null,z=k,L=k=0,ja=null;null!==z&&L<n.length;L++){z.index>L?(ja=z,z=null):ja=z.sibling;var M=r(m,z,n[L],v);if(null===
+M){null===z&&(z=ja);break}a&&z&&null===M.alternate&&b(m,z);k=f(M,k,L);null===B?y=M:B.sibling=M;B=M;z=ja}if(L===n.length)return c(m,z),K&&Bd(m,L),y;if(null===z){for(;L<n.length;L++)z=w(m,n[L],v),null!==z&&(k=f(z,k,L),null===B?y=z:B.sibling=z,B=z);K&&Bd(m,L);return y}for(z=d(m,z);L<n.length;L++)ja=t(z,m,L,n[L],v),null!==ja&&(a&&null!==ja.alternate&&z.delete(null===ja.key?L:ja.key),k=f(ja,k,L),null===B?y=ja:B.sibling=ja,B=ja);a&&z.forEach(function(Kb){return b(m,Kb)});K&&Bd(m,L);return y}function C(m,
+k,n,v){var y=Da(n);if("function"!==typeof y)throw Error(u(150));n=y.call(n);if(null==n)throw Error(u(151));for(var B=y=null,z=k,L=k=0,ja=null,M=n.next();null!==z&&!M.done;L++,M=n.next()){z.index>L?(ja=z,z=null):ja=z.sibling;var Kb=r(m,z,M.value,v);if(null===Kb){null===z&&(z=ja);break}a&&z&&null===Kb.alternate&&b(m,z);k=f(Kb,k,L);null===B?y=Kb:B.sibling=Kb;B=Kb;z=ja}if(M.done)return c(m,z),K&&Bd(m,L),y;if(null===z){for(;!M.done;L++,M=n.next())M=w(m,M.value,v),null!==M&&(k=f(M,k,L),null===B?y=M:B.sibling=
+M,B=M);K&&Bd(m,L);return y}for(z=d(m,z);!M.done;L++,M=n.next())M=t(z,m,L,M.value,v),null!==M&&(a&&null!==M.alternate&&z.delete(null===M.key?L:M.key),k=f(M,k,L),null===B?y=M:B.sibling=M,B=M);a&&z.forEach(function(un){return b(m,un)});K&&Bd(m,L);return y}function J(m,k,n,v){"object"===typeof n&&null!==n&&n.type===na&&null===n.key&&(n=n.props.children);if("object"===typeof n&&null!==n){switch(n.$$typeof){case la:a:{for(var y=n.key,B=k;null!==B;){if(B.key===y){y=n.type;if(y===na){if(7===B.tag){c(m,B.sibling);
 k=e(B,n.props.children);k.return=m;m=k;break a}}else if(B.elementType===y||"object"===typeof y&&null!==y&&y.$$typeof===xa&&Ie(y)===B.type){c(m,B.sibling);k=e(B,n.props);k.ref=Ge(m,B,n);k.return=m;m=k;break a}c(m,B);break}else b(m,B);B=B.sibling}n.type===na?(k=Oe(n.props.children,m.mode,v,n.key),k.return=m,m=k):(v=Me(n.type,n.key,n.props,null,null,m.mode,v),v.ref=Ge(m,k,n),v.return=m,m=v)}return g(m);case ma:a:{for(B=n.key;null!==k;){if(k.key===B)if(4===k.tag&&k.stateNode.containerInfo===n.containerInfo&&
 k.stateNode.implementation===n.implementation){c(m,k.sibling);k=e(k,n.children||[]);k.return=m;m=k;break a}else{c(m,k);break}else b(m,k);k=k.sibling}k=Ne(n,m.mode,v);k.return=m;m=k}return g(m);case xa:return B=n._init,S(m,k,B(n._payload),v)}if(Fc(n))return A(m,k,n,v);if(Da(n))return C(m,k,n,v);if("function"===typeof n.then)return J(m,k,Fe(n),v);if(n.$$typeof===ra||n.$$typeof===sa)return J(m,k,Pe(m,n,v),v);He(m,n)}return"string"===typeof n&&""!==n||"number"===typeof n?(n=""+n,null!==k&&6===k.tag?(c(m,
 k.sibling),k=e(k,n),k.return=m,m=k):(c(m,k),k=Le(n,m.mode,v),k.return=m,m=k),g(m)):c(m,k)}function S(m,k,n,v){Ee=0;m=J(m,k,n,v);De=null;return m}return S}var Qe=Je(!0),Re=Je(!1),Se=ka(null),Te=ka(0);function Ue(a,b){a=Ve;E(Te,a);E(Se,b);Ve=a|b.baseLanes}function We(){E(Te,Ve);E(Se,Se.current)}function Xe(){Ve=Te.current;D(Se);D(Te)}var Ye=ka(null),Ze=null;function $e(a){var b=a.alternate;E(af,af.current&1);E(Ye,a);null===Ze&&(null===b||null!==Se.current?Ze=a:null!==b.memoizedState&&(Ze=a))}
 function bf(a){if(22===a.tag){if(E(af,af.current),E(Ye,a),null===Ze){var b=a.alternate;null!==b&&null!==b.memoizedState&&(Ze=a)}}else cf(a)}function cf(){E(af,af.current);E(Ye,Ye.current)}function df(a){D(Ye);Ze===a&&(Ze=null);D(af)}var af=ka(0);
 function ef(a){for(var b=a;null!==b;){if(13===b.tag){var c=b.memoizedState;if(null!==c&&(c=c.dehydrated,null===c||"$?"===c.data||"$!"===c.data))return b}else if(19===b.tag&&void 0!==b.memoizedProps.revealOrder){if(0!==(b.flags&128))return b}else if(null!==b.child){b.child.return=b;b=b.child;continue}if(b===a)break;for(;null===b.sibling;){if(null===b.return||b.return===a)return null;b=b.return}b.sibling.return=b.return;b=b.sibling}return null}var ff=null,gf=null,hf=!1,jf=!1,kf=!1,lf=0;
 function mf(a){a!==gf&&null===a.next&&(null===gf?ff=gf=a:gf=gf.next=a);jf=!0;hf||(hf=!0,nf(of))}
-function pf(a){if(!kf&&jf){var b=null;kf=!0;do{var c=!1;for(var d=ff;null!==d;){if(!a||0===d.tag){var e=O,f=vb(d,d===P?e:0);if(0!==(f&3))try{c=!0;e=d;if(0!==(N&6))throw Error(t(327));if(!qf()){rf=sf;sf=!1;var g=tf(e,f);if(0!==e.tag&&2===g){var h=f,l=xb(e,h);0!==l&&(f=l,g=uf(e,h,l))}if(1===g)throw h=vf,wf(e,0),xf(e,f,0),mf(e),h;6===g?xf(e,f,0):(e.finishedWork=e.current.alternate,e.finishedLanes=f,yf(e,zf,Af,Bf))}mf(e)}catch(p){null===b?b=[p]:b.push(p)}}d=d.next}}while(c);kf=!1;if(null!==b){if(1<b.length){if("function"===
+function pf(a){if(!kf&&jf){var b=null;kf=!0;do{var c=!1;for(var d=ff;null!==d;){if(!a||0===d.tag){var e=O,f=vb(d,d===P?e:0);if(0!==(f&3))try{c=!0;e=d;if(0!==(N&6))throw Error(u(327));if(!qf()){rf=sf;sf=!1;var g=tf(e,f);if(0!==e.tag&&2===g){var h=f,l=xb(e,h);0!==l&&(f=l,g=uf(e,h,l))}if(1===g)throw h=vf,wf(e,0),xf(e,f,0),mf(e),h;6===g?xf(e,f,0):(e.finishedWork=e.current.alternate,e.finishedLanes=f,yf(e,zf,Af,Bf))}mf(e)}catch(p){null===b?b=[p]:b.push(p)}}d=d.next}}while(c);kf=!1;if(null!==b){if(1<b.length){if("function"===
 typeof AggregateError)throw new AggregateError(b);for(a=1;a<b.length;a++)nf(Cf.bind(null,b[a]))}throw b[0];}}}function Cf(a){throw a;}function of(){jf=hf=!1;for(var a=Ta(),b=null,c=ff;null!==c;){var d=c.next;if(0!==lf&&Df()){var e=c,f=lf;e.pendingLanes|=2;e.entangledLanes|=2;e.entanglements[1]|=f}e=Ef(c,a);0===e?(c.next=null,null===b?ff=d:b.next=d,null===d&&(gf=b)):(b=c,0!==(e&3)&&(jf=!0));c=d}lf=0;pf(!1)}
 function Ef(a,b){for(var c=a.suspendedLanes,d=a.pingedLanes,e=a.expirationTimes,f=a.pendingLanes&-62914561;0<f;){var g=31-pb(f),h=1<<g,l=e[g];if(-1===l){if(0===(h&c)||0!==(h&d))e[g]=wb(h,b)}else l<=b&&(a.expiredLanes|=h);f&=~h}b=P;c=O;c=vb(a,a===b?c:0);d=a.callbackNode;if(0===c||a===b&&2===Q||null!==a.cancelPendingCommit)return null!==d&&null!==d&&Qa(d),a.callbackNode=null,a.callbackPriority=0;if(0!==(c&3))return null!==d&&null!==d&&Qa(d),a.callbackPriority=2,a.callbackNode=null,2;b=c&-c;if(b===a.callbackPriority)return b;
 null!==d&&Qa(d);switch(Ib(c)){case 2:c=Va;break;case 8:c=Wa;break;case 32:c=Xa;break;case 268435456:c=Za;break;default:c=Xa}d=Ff.bind(null,a);c=Pa(c,d);a.callbackPriority=b;a.callbackNode=c;return b}function nf(a){Gf(function(){0!==(N&6)?Pa(Va,a):a()})}function Hf(){if(0===lf){var a=sb;sb<<=1;0===(sb&4194176)&&(sb=128);lf=a}return lf}var If=null,Jf=0,Kf=0;
-function Lf(a,b){if(null===If){var c=If=[];Jf=0;Kf=Hf()}else c=If;Jf++;var d=Mf(c),e="pending",f,g;a.then(function(h){e="fulfilled";f=null!==b?b:h;Nf()},function(h){e="rejected";g=h;Nf()});c.push(function(){switch(e){case "fulfilled":d.status="fulfilled";d.value=f;break;case "rejected":d.status="rejected";d.reason=g;break;default:throw Error(t(478));}});return d}function Of(a,b){var c=null!==b?b:a;if(null===If)return c;a=If;var d=Mf(a);a.push(function(){d.status="fulfilled";d.value=c});return d}
-function Nf(){if(null!==If&&0===--Jf){var a=If;If=null;for(var b=Kf=0;b<a.length;b++)(0,a[b])()}}function Mf(a){return{status:"pending",value:null,reason:null,then:function(b){a.push(b)}}}var Pf=da.ReactCurrentDispatcher,Qf=da.ReactCurrentBatchConfig,Rf=0,R=null,T=null,U=null,Sf=!1,Tf=!1,Uf=!1,Vf=0,Wf=0,Xf=null,Yf=0;function Zf(){throw Error(t(321));}function $f(a,b){if(null===b)return!1;for(var c=0;c<b.length&&c<a.length;c++)if(!rd(a[c],b[c]))return!1;return!0}
-function ag(a,b,c,d,e,f){Rf=f;R=b;b.memoizedState=null;b.updateQueue=null;b.lanes=0;Pf.current=null===a||null===a.memoizedState?bg:cg;Uf=!1;a=c(d,e);Uf=!1;Tf&&(a=dg(b,c,d,e));eg();return a}function eg(){Pf.current=fg;var a=null!==T&&null!==T.next;Rf=0;U=T=R=null;Sf=!1;Wf=0;Xf=null;if(a)throw Error(t(300));}function dg(a,b,c,d){R=a;var e=0;do{Tf&&(Xf=null);Wf=0;Tf=!1;if(25<=e)throw Error(t(301));e+=1;U=T=null;a.updateQueue=null;Pf.current=gg;var f=b(c,d)}while(Tf);return f}
+function Lf(a,b){if(null===If){var c=If=[];Jf=0;Kf=Hf()}else c=If;Jf++;var d=Mf(c),e="pending",f,g;a.then(function(h){e="fulfilled";f=null!==b?b:h;Nf()},function(h){e="rejected";g=h;Nf()});c.push(function(){switch(e){case "fulfilled":d.status="fulfilled";d.value=f;break;case "rejected":d.status="rejected";d.reason=g;break;default:throw Error(u(478));}});return d}function Of(a,b){var c=null!==b?b:a;if(null===If)return c;a=If;var d=Mf(a);a.push(function(){d.status="fulfilled";d.value=c});return d}
+function Nf(){if(null!==If&&0===--Jf){var a=If;If=null;for(var b=Kf=0;b<a.length;b++)(0,a[b])()}}function Mf(a){return{status:"pending",value:null,reason:null,then:function(b){a.push(b)}}}var Pf=da.ReactCurrentDispatcher,Qf=da.ReactCurrentBatchConfig,Rf=0,R=null,T=null,U=null,Sf=!1,Tf=!1,Uf=!1,Vf=0,Wf=0,Xf=null,Yf=0;function Zf(){throw Error(u(321));}function $f(a,b){if(null===b)return!1;for(var c=0;c<b.length&&c<a.length;c++)if(!rd(a[c],b[c]))return!1;return!0}
+function ag(a,b,c,d,e,f){Rf=f;R=b;b.memoizedState=null;b.updateQueue=null;b.lanes=0;Pf.current=null===a||null===a.memoizedState?bg:cg;Uf=!1;a=c(d,e);Uf=!1;Tf&&(a=dg(b,c,d,e));eg();return a}function eg(){Pf.current=fg;var a=null!==T&&null!==T.next;Rf=0;U=T=R=null;Sf=!1;Wf=0;Xf=null;if(a)throw Error(u(300));}function dg(a,b,c,d){R=a;var e=0;do{Tf&&(Xf=null);Wf=0;Tf=!1;if(25<=e)throw Error(u(301));e+=1;U=T=null;a.updateQueue=null;Pf.current=gg;var f=b(c,d)}while(Tf);return f}
 function hg(){var a=Pf.current.useState()[0];return"function"===typeof a.then?ig(a):a}function jg(){var a=0!==Vf;Vf=0;return a}function kg(a,b,c){b.updateQueue=a.updateQueue;b.flags&=-2053;a.lanes&=~c}function lg(a){if(Sf){for(a=a.memoizedState;null!==a;){var b=a.queue;null!==b&&(b.pending=null);a=a.next}Sf=!1}Rf=0;U=T=R=null;Tf=!1;Wf=Vf=0;Xf=null}function mg(){var a={memoizedState:null,baseState:null,baseQueue:null,queue:null,next:null};null===U?R.memoizedState=U=a:U=U.next=a;return U}
-function ng(){if(null===T){var a=R.alternate;a=null!==a?a.memoizedState:null}else a=T.next;var b=null===U?R.memoizedState:U.next;if(null!==b)U=b,T=a;else{if(null===a){if(null===R.alternate)throw Error(t(467));throw Error(t(310));}T=a;a={memoizedState:T.memoizedState,baseState:T.baseState,baseQueue:T.baseQueue,queue:T.queue,next:null};null===U?R.memoizedState=U=a:U=U.next=a}return U}var og;og=function(){return{lastEffect:null,events:null,stores:null}};
-function ig(a){var b=Wf;Wf+=1;null===Xf&&(Xf=[]);a=Ae(Xf,a,b);null===R.alternate&&(null===U?null===R.memoizedState:null===U.next)&&(Pf.current=bg);return a}function pg(a){if(null!==a&&"object"===typeof a){if("function"===typeof a.then)return ig(a);if(a.$$typeof===ra||a.$$typeof===sa)return qg(a)}throw Error(t(438,String(a)));}function rg(a,b){return"function"===typeof b?b(a):b}function sg(a){var b=ng();return tg(b,T,a)}
-function tg(a,b,c){var d=a.queue;if(null===d)throw Error(t(311));d.lastRenderedReducer=c;var e=a.baseQueue,f=d.pending;if(null!==f){if(null!==e){var g=e.next;e.next=f.next;f.next=g}b.baseQueue=e=f;d.pending=null}if(null!==e){b=e.next;f=a.baseState;var h=g=null,l=null,p=b;do{var q=p.lane&-536870913;if(q!==p.lane?(O&q)===q:(Rf&q)===q){q=p.revertLane;if(0===q)null!==l&&(l=l.next={lane:0,revertLane:0,action:p.action,hasEagerState:p.hasEagerState,eagerState:p.eagerState,next:null});else if((Rf&q)===q){p=
-p.next;continue}else{var x={lane:0,revertLane:p.revertLane,action:p.action,hasEagerState:p.hasEagerState,eagerState:p.eagerState,next:null};null===l?(h=l=x,g=f):l=l.next=x;R.lanes|=q;re|=q}q=p.action;Uf&&c(f,q);f=p.hasEagerState?p.eagerState:c(f,q)}else x={lane:q,revertLane:p.revertLane,action:p.action,hasEagerState:p.hasEagerState,eagerState:p.eagerState,next:null},null===l?(h=l=x,g=f):l=l.next=x,R.lanes|=q,re|=q;p=p.next}while(null!==p&&p!==b);null===l?g=f:l.next=h;rd(f,a.memoizedState)||(ug=!0);
-a.memoizedState=f;a.baseState=g;a.baseQueue=l;d.lastRenderedState=f}null===e&&(d.lanes=0);return[a.memoizedState,d.dispatch]}function vg(a){var b=ng(),c=b.queue;if(null===c)throw Error(t(311));c.lastRenderedReducer=a;var d=c.dispatch,e=c.pending,f=b.memoizedState;if(null!==e){c.pending=null;var g=e=e.next;do f=a(f,g.action),g=g.next;while(g!==e);rd(f,b.memoizedState)||(ug=!0);b.memoizedState=f;null===b.baseQueue&&(b.baseState=f);c.lastRenderedState=f}return[f,d]}
-function wg(a,b,c){var d=R,e=ng(),f=K;if(f){if(void 0===c)throw Error(t(407));c=c()}else c=b();var g=!rd((T||e).memoizedState,c);g&&(e.memoizedState=c,ug=!0);e=e.queue;xg(yg.bind(null,d,e,a),[a]);if(e.getSnapshot!==b||g||null!==U&&U.memoizedState.tag&1){d.flags|=2048;zg(9,Ag.bind(null,d,e,c,b),{destroy:void 0},null);if(null===P)throw Error(t(349));f||0!==(Rf&60)||Bg(d,b,c)}return c}
+function ng(){if(null===T){var a=R.alternate;a=null!==a?a.memoizedState:null}else a=T.next;var b=null===U?R.memoizedState:U.next;if(null!==b)U=b,T=a;else{if(null===a){if(null===R.alternate)throw Error(u(467));throw Error(u(310));}T=a;a={memoizedState:T.memoizedState,baseState:T.baseState,baseQueue:T.baseQueue,queue:T.queue,next:null};null===U?R.memoizedState=U=a:U=U.next=a}return U}var og;og=function(){return{lastEffect:null,events:null,stores:null}};
+function ig(a){var b=Wf;Wf+=1;null===Xf&&(Xf=[]);a=Ae(Xf,a,b);null===R.alternate&&(null===U?null===R.memoizedState:null===U.next)&&(Pf.current=bg);return a}function pg(a){if(null!==a&&"object"===typeof a){if("function"===typeof a.then)return ig(a);if(a.$$typeof===ra||a.$$typeof===sa)return qg(a)}throw Error(u(438,String(a)));}function rg(a,b){return"function"===typeof b?b(a):b}function sg(a){var b=ng();return tg(b,T,a)}
+function tg(a,b,c){var d=a.queue;if(null===d)throw Error(u(311));d.lastRenderedReducer=c;var e=a.baseQueue,f=d.pending;if(null!==f){if(null!==e){var g=e.next;e.next=f.next;f.next=g}b.baseQueue=e=f;d.pending=null}if(null!==e){b=e.next;f=a.baseState;var h=g=null,l=null,p=b;do{var q=p.lane&-536870913;if(q!==p.lane?(O&q)===q:(Rf&q)===q){q=p.revertLane;if(0===q)null!==l&&(l=l.next={lane:0,revertLane:0,action:p.action,hasEagerState:p.hasEagerState,eagerState:p.eagerState,next:null});else if((Rf&q)===q){p=
+p.next;continue}else{var w={lane:0,revertLane:p.revertLane,action:p.action,hasEagerState:p.hasEagerState,eagerState:p.eagerState,next:null};null===l?(h=l=w,g=f):l=l.next=w;R.lanes|=q;re|=q}q=p.action;Uf&&c(f,q);f=p.hasEagerState?p.eagerState:c(f,q)}else w={lane:q,revertLane:p.revertLane,action:p.action,hasEagerState:p.hasEagerState,eagerState:p.eagerState,next:null},null===l?(h=l=w,g=f):l=l.next=w,R.lanes|=q,re|=q;p=p.next}while(null!==p&&p!==b);null===l?g=f:l.next=h;rd(f,a.memoizedState)||(ug=!0);
+a.memoizedState=f;a.baseState=g;a.baseQueue=l;d.lastRenderedState=f}null===e&&(d.lanes=0);return[a.memoizedState,d.dispatch]}function vg(a){var b=ng(),c=b.queue;if(null===c)throw Error(u(311));c.lastRenderedReducer=a;var d=c.dispatch,e=c.pending,f=b.memoizedState;if(null!==e){c.pending=null;var g=e=e.next;do f=a(f,g.action),g=g.next;while(g!==e);rd(f,b.memoizedState)||(ug=!0);b.memoizedState=f;null===b.baseQueue&&(b.baseState=f);c.lastRenderedState=f}return[f,d]}
+function wg(a,b,c){var d=R,e=ng(),f=K;if(f){if(void 0===c)throw Error(u(407));c=c()}else c=b();var g=!rd((T||e).memoizedState,c);g&&(e.memoizedState=c,ug=!0);e=e.queue;xg(yg.bind(null,d,e,a),[a]);if(e.getSnapshot!==b||g||null!==U&&U.memoizedState.tag&1){d.flags|=2048;zg(9,Ag.bind(null,d,e,c,b),{destroy:void 0},null);if(null===P)throw Error(u(349));f||0!==(Rf&60)||Bg(d,b,c)}return c}
 function Bg(a,b,c){a.flags|=16384;a={getSnapshot:b,value:c};b=R.updateQueue;null===b?(b=og(),R.updateQueue=b,b.stores=[a]):(c=b.stores,null===c?b.stores=[a]:c.push(a))}function Ag(a,b,c,d){b.value=c;b.getSnapshot=d;Cg(b)&&Dg(a)}function yg(a,b,c){return c(function(){Cg(b)&&Dg(a)})}function Cg(a){var b=a.getSnapshot;a=a.value;try{var c=b();return!rd(a,c)}catch(d){return!0}}function Dg(a){var b=ge(a,2);null!==b&&Eg(b,a,2)}
-function Fg(a){var b=mg();"function"===typeof a&&(a=a());b.memoizedState=b.baseState=a;b.queue={pending:null,lanes:0,dispatch:null,lastRenderedReducer:rg,lastRenderedState:a};return b}function Gg(a,b,c,d){a.baseState=c;return tg(a,T,"function"===typeof d?d:rg)}function Hg(a,b,c,d){if(Ig(a))throw Error(t(485));a=b.pending;null===a?(a={payload:d,next:null},a.next=b.pending=a,Jg(b,c,d)):b.pending=a.next={payload:d,next:a.next}}
+function Fg(a){var b=mg();"function"===typeof a&&(a=a());b.memoizedState=b.baseState=a;b.queue={pending:null,lanes:0,dispatch:null,lastRenderedReducer:rg,lastRenderedState:a};return b}function Gg(a,b,c,d){a.baseState=c;return tg(a,T,"function"===typeof d?d:rg)}function Hg(a,b,c,d){if(Ig(a))throw Error(u(485));a=b.pending;null===a?(a={payload:d,next:null},a.next=b.pending=a,Jg(b,c,d)):b.pending=a.next={payload:d,next:a.next}}
 function Jg(a,b,c){var d=a.action,e=a.state,f=Qf.transition;Qf.transition={};try{var g=d(e,c);if(null!==g&&"object"===typeof g&&"function"===typeof g.then){g.then(function(p){a.state=p;Kg(a,b)},function(){return Kg(a,b)});var h=Lf(g,null);b(h)}else{var l=Of(g,null);b(l);a.state=g;Kg(a,b)}}catch(p){b({then:function(){},status:"rejected",reason:p}),Kg(a,b)}finally{Qf.transition=f}}
 function Kg(a,b){var c=a.pending;if(null!==c){var d=c.next;d===c?a.pending=null:(d=d.next,c.next=d,Jg(a,b,d.payload))}}function Lg(a,b){return b}function Mg(a,b,c){a=tg(a,b,Lg)[0];a="object"===typeof a&&null!==a&&"function"===typeof a.then?ig(a):a;b=ng();var d=b.queue,e=d.dispatch;c!==b.memoizedState&&(R.flags|=2048,zg(9,Ng.bind(null,d,c),{destroy:void 0},null));return[a,e]}function Ng(a,b){a.action=b}
 function zg(a,b,c,d){a={tag:a,create:b,inst:c,deps:d,next:null};b=R.updateQueue;null===b?(b=og(),R.updateQueue=b,b.lastEffect=a.next=a):(c=b.lastEffect,null===c?b.lastEffect=a.next=a:(d=c.next,c.next=a,a.next=d,b.lastEffect=a));return a}function Og(){return ng().memoizedState}function Pg(a,b,c,d){var e=mg();R.flags|=a;e.memoizedState=zg(1|b,c,{destroy:void 0},void 0===d?null:d)}
@@ -138,14 +127,14 @@ function Qg(a,b,c,d){var e=ng();d=void 0===d?null:d;var f=e.memoizedState.inst;n
 function Vg(a,b,c){c=null!==c&&void 0!==c?c.concat([a]):null;Qg(4,4,Ug.bind(null,b,a),c)}function Wg(){}function Xg(a,b){var c=ng();b=void 0===b?null:b;var d=c.memoizedState;if(null!==b&&$f(b,d[1]))return d[0];c.memoizedState=[a,b];return a}function Yg(a,b){var c=ng();b=void 0===b?null:b;var d=c.memoizedState;if(null!==b&&$f(b,d[1]))return d[0];Uf&&a();a=a();c.memoizedState=[a,b];return a}
 function Zg(a,b,c){if(rd(c,b))return c;if(null!==Se.current)return a.memoizedState=c,rd(c,b)||(ug=!0),c;if(0===(Rf&42))return ug=!0,a.memoizedState=c;0===Bf&&(Bf=0===(O&536870912)||K?Hf():536870912);a=Bf;R.lanes|=a;re|=a;return b}
 function $g(a,b,c,d,e){var f=G;G=0!==f&&8>f?f:8;var g=Qf.transition;Qf.transition={};ah(a,!1,b,c);try{var h=e();if(null!==h&&"object"===typeof h&&"function"===typeof h.then){var l=Lf(h,d);bh(a,b,l)}else{var p=Of(h,d);bh(a,b,p)}}catch(q){bh(a,b,{then:function(){},status:"rejected",reason:q})}finally{G=f,Qf.transition=g}}
-function ch(a,b,c,d){if(5!==a.tag)throw Error(t(476));if(null===a.memoizedState){var e={pending:null,lanes:0,dispatch:null,lastRenderedReducer:rg,lastRenderedState:fa};var f=e;e={memoizedState:fa,baseState:fa,baseQueue:null,queue:e,next:null};a.memoizedState=e;var g=a.alternate;null!==g&&(g.memoizedState=e)}else f=a.memoizedState.queue;$g(a,f,b,fa,function(){return c(d)})}function dh(){var a=qg(Ia);return null!==a?a:fa}function eh(){return ng().memoizedState}
+function ch(a,b,c,d){if(5!==a.tag)throw Error(u(476));if(null===a.memoizedState){var e={pending:null,lanes:0,dispatch:null,lastRenderedReducer:rg,lastRenderedState:fa};var f=e;e={memoizedState:fa,baseState:fa,baseQueue:null,queue:e,next:null};a.memoizedState=e;var g=a.alternate;null!==g&&(g.memoizedState=e)}else f=a.memoizedState.queue;$g(a,f,b,fa,function(){return c(d)})}function dh(){var a=qg(Ia);return null!==a?a:fa}function eh(){return ng().memoizedState}
 function fh(){return ng().memoizedState}function gh(a){for(var b=a.return;null!==b;){switch(b.tag){case 24:case 3:var c=hh(b);a=me(c);var d=ne(b,a,c);null!==d&&(Eg(d,b,c),oe(d,b,c));b={cache:ih()};a.payload=b;return}b=b.return}}function jh(a,b,c){var d=hh(a);c={lane:d,revertLane:0,action:c,hasEagerState:!1,eagerState:null,next:null};Ig(a)?kh(b,c):(c=ee(a,b,c,d),null!==c&&(Eg(c,a,d),lh(c,b,d)));nb(a,d)}
 function bh(a,b,c){var d=hh(a),e={lane:d,revertLane:0,action:c,hasEagerState:!1,eagerState:null,next:null};if(Ig(a))kh(b,e);else{var f=a.alternate;if(0===a.lanes&&(null===f||0===f.lanes)&&(f=b.lastRenderedReducer,null!==f))try{var g=b.lastRenderedState,h=f(g,c);e.hasEagerState=!0;e.eagerState=h;if(rd(h,g)){de(a,b,e,0);null===P&&be();return}}catch(l){}finally{}c=ee(a,b,e,d);null!==c&&(Eg(c,a,d),lh(c,b,d))}nb(a,d)}
-function ah(a,b,c,d){d={lane:2,revertLane:Hf(),action:d,hasEagerState:!1,eagerState:null,next:null};if(Ig(a)){if(b)throw Error(t(479));}else b=ee(a,c,d,2),null!==b&&Eg(b,a,2);nb(a,2)}function Ig(a){var b=a.alternate;return a===R||null!==b&&b===R}function kh(a,b){Tf=Sf=!0;var c=a.pending;null===c?b.next=b:(b.next=c.next,c.next=b);a.pending=b}function lh(a,b,c){if(0!==(c&4194176)){var d=b.lanes;d&=a.pendingLanes;c|=d;b.lanes=c;Db(a,c)}}
+function ah(a,b,c,d){d={lane:2,revertLane:Hf(),action:d,hasEagerState:!1,eagerState:null,next:null};if(Ig(a)){if(b)throw Error(u(479));}else b=ee(a,c,d,2),null!==b&&Eg(b,a,2);nb(a,2)}function Ig(a){var b=a.alternate;return a===R||null!==b&&b===R}function kh(a,b){Tf=Sf=!0;var c=a.pending;null===c?b.next=b:(b.next=c.next,c.next=b);a.pending=b}function lh(a,b,c){if(0!==(c&4194176)){var d=b.lanes;d&=a.pendingLanes;c|=d;b.lanes=c;Db(a,c)}}
 var fg={readContext:qg,use:pg,useCallback:Zf,useContext:Zf,useEffect:Zf,useImperativeHandle:Zf,useInsertionEffect:Zf,useLayoutEffect:Zf,useMemo:Zf,useReducer:Zf,useRef:Zf,useState:Zf,useDebugValue:Zf,useDeferredValue:Zf,useTransition:Zf,useSyncExternalStore:Zf,useId:Zf};fg.useCacheRefresh=Zf;fg.useHostTransitionStatus=Zf;fg.useFormState=Zf;fg.useOptimistic=Zf;
 var bg={readContext:qg,use:pg,useCallback:function(a,b){mg().memoizedState=[a,void 0===b?null:b];return a},useContext:qg,useEffect:Rg,useImperativeHandle:function(a,b,c){c=null!==c&&void 0!==c?c.concat([a]):null;Pg(4194308,4,Ug.bind(null,b,a),c)},useLayoutEffect:function(a,b){return Pg(4194308,4,a,b)},useInsertionEffect:function(a,b){Pg(4,2,a,b)},useMemo:function(a,b){var c=mg();b=void 0===b?null:b;Uf&&a();a=a();c.memoizedState=[a,b];return a},useReducer:function(a,b,c){var d=mg();b=void 0!==c?c(b):
 b;d.memoizedState=d.baseState=b;a={pending:null,lanes:0,dispatch:null,lastRenderedReducer:a,lastRenderedState:b};d.queue=a;a=a.dispatch=jh.bind(null,R,a);return[d.memoizedState,a]},useRef:function(a){var b=mg();a={current:a};return b.memoizedState=a},useState:function(a){a=Fg(a);var b=a.queue,c=bh.bind(null,R,b);b.dispatch=c;return[a.memoizedState,c]},useDebugValue:Wg,useDeferredValue:function(a){mg().memoizedState=a;return a},useTransition:function(){var a=Fg(!1);a=$g.bind(null,R,a.queue,!0,!1);
-mg().memoizedState=a;return[!1,a]},useSyncExternalStore:function(a,b,c){var d=R,e=mg();if(K){if(void 0===c)throw Error(t(407));c=c()}else{c=b();if(null===P)throw Error(t(349));0!==(O&60)||Bg(d,b,c)}e.memoizedState=c;var f={value:c,getSnapshot:b};e.queue=f;Rg(yg.bind(null,d,f,a),[a]);d.flags|=2048;zg(9,Ag.bind(null,d,f,c,b),{destroy:void 0},null);return c},useId:function(){var a=mg(),b=P.identifierPrefix;if(K){var c=Ad;var d=zd;c=(d&~(1<<32-pb(d)-1)).toString(32)+c;b=":"+b+"R"+c;c=Vf++;0<c&&(b+="H"+
+mg().memoizedState=a;return[!1,a]},useSyncExternalStore:function(a,b,c){var d=R,e=mg();if(K){if(void 0===c)throw Error(u(407));c=c()}else{c=b();if(null===P)throw Error(u(349));0!==(O&60)||Bg(d,b,c)}e.memoizedState=c;var f={value:c,getSnapshot:b};e.queue=f;Rg(yg.bind(null,d,f,a),[a]);d.flags|=2048;zg(9,Ag.bind(null,d,f,c,b),{destroy:void 0},null);return c},useId:function(){var a=mg(),b=P.identifierPrefix;if(K){var c=Ad;var d=zd;c=(d&~(1<<32-pb(d)-1)).toString(32)+c;b=":"+b+"R"+c;c=Vf++;0<c&&(b+="H"+
 c.toString(32));b+=":"}else c=Yf++,b=":"+b+"r"+c.toString(32)+":";return a.memoizedState=b},useCacheRefresh:function(){return mg().memoizedState=gh.bind(null,R)}};bg.useHostTransitionStatus=dh;
 bg.useFormState=function(a,b){if(K){var c=P.formState;if(null!==c){a:{if(K){if(I){b:{var d=I;for(var e=Gd;8!==d.nodeType;){if(!e){d=null;break b}d=Qd(d);if(null===d){d=null;break b}}e=d.data;d="F!"===e||"F"===e?d:null}if(d){I=Qd(d);d="F!"===d.data;break a}}Sd()}d=!1}d&&(b=c[0])}}c=mg();c.memoizedState=c.baseState=b;d={pending:null,lanes:0,dispatch:null,lastRenderedReducer:Lg,lastRenderedState:b};c.queue=d;c=bh.bind(null,R,d);d.dispatch=c;d=mg();e={state:b,dispatch:null,action:a,pending:null};d.queue=
 e;c=Hg.bind(null,R,e,c);e.dispatch=c;d.memoizedState=a;return[b,c]};bg.useOptimistic=function(a){var b=mg();b.memoizedState=b.baseState=a;var c={pending:null,lanes:0,dispatch:null,lastRenderedReducer:null,lastRenderedState:null};b.queue=c;b=ah.bind(null,R,!0,c);c.dispatch=b;return[a,b]};
@@ -154,8 +143,8 @@ cg.useFormState=function(a){var b=ng();return Mg(b,T,a)};cg.useOptimistic=functi
 var gg={readContext:qg,use:pg,useCallback:Xg,useContext:qg,useEffect:xg,useImperativeHandle:Vg,useInsertionEffect:Sg,useLayoutEffect:Tg,useMemo:Yg,useReducer:vg,useRef:Og,useState:function(){return vg(rg)},useDebugValue:Wg,useDeferredValue:function(a){var b=ng();return null===T?(b.memoizedState=a,a):Zg(b,T.memoizedState,a)},useTransition:function(){var a=vg(rg)[0],b=ng().memoizedState;return["boolean"===typeof a?a:ig(a),b]},useSyncExternalStore:wg,useId:eh};gg.useCacheRefresh=fh;
 gg.useHostTransitionStatus=dh;gg.useFormState=function(a){var b=ng(),c=T;if(null!==c)return Mg(b,c,a);b=b.memoizedState;c=ng();var d=c.queue.dispatch;c.memoizedState=a;return[b,d]};gg.useOptimistic=function(a,b){var c=ng();if(null!==T)return Gg(c,T,a,b);c.baseState=a;return[a,c.queue.dispatch]};var mh=ba.unstable_now,nh=0,oh=-1,ph=-1,qh=-1,rf=!1,sf=!1;function rh(a){ph=mh();0>a.actualStartTime&&(a.actualStartTime=mh())}
 function sh(a,b){if(0<=ph){var c=mh()-ph;a.actualDuration+=c;b&&(a.selfBaseDuration=c);ph=-1}}function th(a){if(0<=oh){var b=mh()-oh;oh=-1;for(a=a.return;null!==a;){switch(a.tag){case 3:a.stateNode.effectDuration+=b;return;case 12:a.stateNode.effectDuration+=b;return}a=a.return}}}
-function uh(a){if(0<=qh){var b=mh()-qh;qh=-1;for(a=a.return;null!==a;){switch(a.tag){case 3:a=a.stateNode;null!==a&&(a.passiveEffectDuration+=b);return;case 12:a=a.stateNode;null!==a&&(a.passiveEffectDuration+=b);return}a=a.return}}}function vh(){oh=mh()}function wh(a){for(var b=a.child;b;)a.actualDuration+=b.actualDuration,b=b.sibling}function xh(a,b){if(a&&a.defaultProps){b=w({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}
-function yh(a,b,c,d){b=a.memoizedState;c=c(d,b);c=null===c||void 0===c?b:w({},b,c);a.memoizedState=c;0===a.lanes&&(a.updateQueue.baseState=c)}
+function uh(a){if(0<=qh){var b=mh()-qh;qh=-1;for(a=a.return;null!==a;){switch(a.tag){case 3:a=a.stateNode;null!==a&&(a.passiveEffectDuration+=b);return;case 12:a=a.stateNode;null!==a&&(a.passiveEffectDuration+=b);return}a=a.return}}}function vh(){oh=mh()}function wh(a){for(var b=a.child;b;)a.actualDuration+=b.actualDuration,b=b.sibling}function xh(a,b){if(a&&a.defaultProps){b=x({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}
+function yh(a,b,c,d){b=a.memoizedState;c=c(d,b);c=null===c||void 0===c?b:x({},b,c);a.memoizedState=c;0===a.lanes&&(a.updateQueue.baseState=c)}
 var zh={isMounted:function(a){return(a=a._reactInternals)?$c(a)===a:!1},enqueueSetState:function(a,b,c){a=a._reactInternals;var d=hh(a),e=me(d);e.payload=b;void 0!==c&&null!==c&&(e.callback=c);b=ne(a,e,d);null!==b&&(Eg(b,a,d),oe(b,a,d));nb(a,d)},enqueueReplaceState:function(a,b,c){a=a._reactInternals;var d=hh(a),e=me(d);e.tag=1;e.payload=b;void 0!==c&&null!==c&&(e.callback=c);b=ne(a,e,d);null!==b&&(Eg(b,a,d),oe(b,a,d));nb(a,d)},enqueueForceUpdate:function(a,b){a=a._reactInternals;var c=hh(a),d=me(c);
 d.tag=2;void 0!==b&&null!==b&&(d.callback=b);b=ne(a,d,c);null!==b&&(Eg(b,a,c),oe(b,a,c));null!==F&&"function"===typeof F.markForceUpdateScheduled&&F.markForceUpdateScheduled(a,c)}};function Ah(a,b,c,d,e,f,g){a=a.stateNode;return"function"===typeof a.shouldComponentUpdate?a.shouldComponentUpdate(d,f,g):b.prototype&&b.prototype.isPureReactComponent?!ue(c,d)||!ue(e,f):!0}
 function Bh(a,b,c){var d=!1,e=fd;var f=b.contextType;"object"===typeof f&&null!==f?f=qg(f):(e=kd(b)?id:gd.current,d=b.contextTypes,f=(d=null!==d&&void 0!==d)?jd(a,e):fd);b=new b(c,f);a.memoizedState=null!==b.state&&void 0!==b.state?b.state:null;b.updater=zh;a.stateNode=b;b._reactInternals=a;d&&(a=a.stateNode,a.__reactInternalMemoizedUnmaskedChildContext=e,a.__reactInternalMemoizedMaskedChildContext=f);return b}
@@ -166,18 +155,18 @@ function Fh(a,b,c){return{value:a,source:null,stack:null!=c?c:null,digest:null!=
 function Kh(a,b,c){c=me(c);c.tag=3;var d=a.type.getDerivedStateFromError;if("function"===typeof d){var e=b.value;c.payload=function(){return d(e)};c.callback=function(){Gh(a,b)}}var f=a.stateNode;null!==f&&"function"===typeof f.componentDidCatch&&(c.callback=function(){Gh(a,b);"function"!==typeof d&&(null===Lh?Lh=new Set([this]):Lh.add(this));var g=b.stack;this.componentDidCatch(b.value,{componentStack:null!==g?g:""})});return c}
 function Mh(a,b,c,d,e){if(0===(a.mode&1))return a===b?a.flags|=65536:(a.flags|=128,c.flags|=131072,c.flags&=-52805,1===c.tag&&(null===c.alternate?c.tag=17:(b=me(2),b.tag=2,ne(c,b,2))),c.lanes|=2),a;a.flags|=65536;a.lanes=e;return a}
 function Nh(a,b,c,d,e){c.flags|=32768;bb&&Oh(a,e);if(null!==d&&"object"===typeof d&&"function"===typeof d.then){var f=c.tag;0!==(c.mode&1)||0!==f&&11!==f&&15!==f||((f=c.alternate)?(c.updateQueue=f.updateQueue,c.memoizedState=f.memoizedState,c.lanes=f.lanes):(c.updateQueue=null,c.memoizedState=null));f=Ye.current;if(null!==f){switch(f.tag){case 13:c.mode&1&&(null===Ze?Ph():null===f.alternate&&0===Qh&&(Qh=3));f.flags&=-257;Mh(f,b,c,a,e);d===xe?f.flags|=16384:(b=f.updateQueue,null===b?f.updateQueue=
-new Set([d]):b.add(d),f.mode&1&&Rh(a,d,e));return;case 22:if(f.mode&1){f.flags|=65536;d===xe?f.flags|=16384:(b=f.updateQueue,null===b?(b={transitions:null,markerInstances:null,retryQueue:new Set([d])},f.updateQueue=b):(c=b.retryQueue,null===c?b.retryQueue=new Set([d]):c.add(d)),Rh(a,d,e));return}}throw Error(t(435,f.tag));}if(1===a.tag){Rh(a,d,e);Ph();return}d=Error(t(426))}if(K&&c.mode&1&&(f=Ye.current,null!==f)){0===(f.flags&65536)&&(f.flags|=256);Mh(f,b,c,a,e);Yd(Eh(d,c));return}a=d=Eh(d,c);4!==
-Qh&&(Qh=2);null===Sh?Sh=[a]:Sh.push(a);a=b;do{switch(a.tag){case 3:a.flags|=65536;e&=-e;a.lanes|=e;e=Hh(a,d,e);pe(a,e);return;case 1:if(b=d,c=a.type,f=a.stateNode,0===(a.flags&128)&&("function"===typeof c.getDerivedStateFromError||null!==f&&"function"===typeof f.componentDidCatch&&(null===Lh||!Lh.has(f)))){a.flags|=65536;e&=-e;a.lanes|=e;e=Kh(a,b,e);pe(a,e);return}}a=a.return}while(null!==a)}var Th=da.ReactCurrentOwner,Uh=Error(t(461)),ug=!1;
+new Set([d]):b.add(d),f.mode&1&&Rh(a,d,e));return;case 22:if(f.mode&1){f.flags|=65536;d===xe?f.flags|=16384:(b=f.updateQueue,null===b?(b={transitions:null,markerInstances:null,retryQueue:new Set([d])},f.updateQueue=b):(c=b.retryQueue,null===c?b.retryQueue=new Set([d]):c.add(d)),Rh(a,d,e));return}}throw Error(u(435,f.tag));}if(1===a.tag){Rh(a,d,e);Ph();return}d=Error(u(426))}if(K&&c.mode&1&&(f=Ye.current,null!==f)){0===(f.flags&65536)&&(f.flags|=256);Mh(f,b,c,a,e);Yd(Eh(d,c));return}a=d=Eh(d,c);4!==
+Qh&&(Qh=2);null===Sh?Sh=[a]:Sh.push(a);a=b;do{switch(a.tag){case 3:a.flags|=65536;e&=-e;a.lanes|=e;e=Hh(a,d,e);pe(a,e);return;case 1:if(b=d,c=a.type,f=a.stateNode,0===(a.flags&128)&&("function"===typeof c.getDerivedStateFromError||null!==f&&"function"===typeof f.componentDidCatch&&(null===Lh||!Lh.has(f)))){a.flags|=65536;e&=-e;a.lanes|=e;e=Kh(a,b,e);pe(a,e);return}}a=a.return}while(null!==a)}var Th=da.ReactCurrentOwner,Uh=Error(u(461)),ug=!1;
 function Vh(a,b,c,d){b.child=null===a?Re(b,null,c,d):Qe(b,a.child,c,d)}function Wh(a,b,c,d,e){c=c.render;var f=b.ref;Xh(b,e);hb(b);d=ag(a,b,c,d,f,e);c=jg();ib();if(null!==a&&!ug)return kg(a,b,e),Yh(a,b,e);K&&c&&Dd(b);b.flags|=1;Vh(a,b,d,e);return b.child}
 function Zh(a,b,c,d,e){if(null===a){var f=c.type;if("function"===typeof f&&!$h(f)&&void 0===f.defaultProps&&null===c.compare&&void 0===c.defaultProps)return b.tag=15,b.type=f,ai(a,b,f,d,e);a=Me(c.type,null,d,null,b,b.mode,e);a.ref=b.ref;a.return=b;return b.child=a}f=a.child;if(0===(a.lanes&e)){var g=f.memoizedProps;c=c.compare;c=null!==c?c:ue;if(c(g,d)&&a.ref===b.ref)return Yh(a,b,e)}b.flags|=1;a=Ke(f,d);a.ref=b.ref;a.return=b;return b.child=a}
 function ai(a,b,c,d,e){if(null!==a){var f=a.memoizedProps;if(ue(f,d)&&a.ref===b.ref)if(ug=!1,b.pendingProps=d=f,0!==(a.lanes&e))0!==(a.flags&131072)&&(ug=!0);else return b.lanes=a.lanes,Yh(a,b,e)}return bi(a,b,c,d,e)}
 function ci(a,b,c){var d=b.pendingProps,e=d.children,f=0!==(b.stateNode._pendingVisibility&2),g=null!==a?a.memoizedState:null;di(a,b);if("hidden"===d.mode||f){if(0!==(b.flags&128)){c=null!==g?g.baseLanes|c:c;if(null!==a){d=b.child=a.child;for(e=0;null!==d;)e=e|d.lanes|d.childLanes,d=d.sibling;b.childLanes=e&~c}else b.childLanes=0,b.child=null;return ei(a,b,c)}if(0===(b.mode&1))b.memoizedState={baseLanes:0,cachePool:null},null!==a&&fi(b,null),We(),bf(b);else if(0!==(c&536870912))b.memoizedState={baseLanes:0,
 cachePool:null},null!==a&&fi(b,null!==g?g.cachePool:null),null!==g?Ue(b,g):We(),bf(b);else return b.lanes=b.childLanes=536870912,ei(a,b,null!==g?g.baseLanes|c:c)}else null!==g?(fi(b,g.cachePool),Ue(b,g),cf(b),b.memoizedState=null):(null!==a&&fi(b,null),We(),cf(b));Vh(a,b,e,c);return b.child}function ei(a,b,c){var d=gi();d=null===d?null:{parent:hi._currentValue,pool:d};b.memoizedState={baseLanes:c,cachePool:d};null!==a&&fi(b,null);We();bf(b);return null}
 function di(a,b){var c=b.ref;if(null===a&&null!==c||null!==a&&a.ref!==c)b.flags|=512,b.flags|=2097152}function bi(a,b,c,d,e){var f=kd(c)?id:gd.current;f=jd(b,f);Xh(b,e);hb(b);c=ag(a,b,c,d,f,e);d=jg();ib();if(null!==a&&!ug)return kg(a,b,e),Yh(a,b,e);K&&d&&Dd(b);b.flags|=1;Vh(a,b,c,e);return b.child}function ii(a,b,c,d,e,f){Xh(b,f);hb(b);c=dg(b,d,c,e);eg();d=jg();ib();if(null!==a&&!ug)return kg(a,b,f),Yh(a,b,f);K&&d&&Dd(b);b.flags|=1;Vh(a,b,c,f);return b.child}
-function ji(a,b,c,d,e){if(kd(c)){var f=!0;od(b)}else f=!1;Xh(b,e);if(null===b.stateNode)ki(a,b),Bh(b,c,d),Dh(b,c,d,e),d=!0;else if(null===a){var g=b.stateNode,h=b.memoizedProps;g.props=h;var l=g.context,p=c.contextType;"object"===typeof p&&null!==p?p=qg(p):(p=kd(c)?id:gd.current,p=jd(b,p));var q=c.getDerivedStateFromProps,x="function"===typeof q||"function"===typeof g.getSnapshotBeforeUpdate;x||"function"!==typeof g.UNSAFE_componentWillReceiveProps&&"function"!==typeof g.componentWillReceiveProps||
-(h!==d||l!==p)&&Ch(b,g,d,p);je=!1;var r=b.memoizedState;g.state=r;qe(b,d,g,e);l=b.memoizedState;h!==d||r!==l||hd.current||je?("function"===typeof q&&(yh(b,c,q,d),l=b.memoizedState),(h=je||Ah(b,c,h,d,r,l,p))?(x||"function"!==typeof g.UNSAFE_componentWillMount&&"function"!==typeof g.componentWillMount||("function"===typeof g.componentWillMount&&g.componentWillMount(),"function"===typeof g.UNSAFE_componentWillMount&&g.UNSAFE_componentWillMount()),"function"===typeof g.componentDidMount&&(b.flags|=4194308)):
-("function"===typeof g.componentDidMount&&(b.flags|=4194308),b.memoizedProps=d,b.memoizedState=l),g.props=d,g.state=l,g.context=p,d=h):("function"===typeof g.componentDidMount&&(b.flags|=4194308),d=!1)}else{g=b.stateNode;le(a,b);h=b.memoizedProps;p=b.type===b.elementType?h:xh(b.type,h);g.props=p;x=b.pendingProps;r=g.context;l=c.contextType;"object"===typeof l&&null!==l?l=qg(l):(l=kd(c)?id:gd.current,l=jd(b,l));var u=c.getDerivedStateFromProps;(q="function"===typeof u||"function"===typeof g.getSnapshotBeforeUpdate)||
-"function"!==typeof g.UNSAFE_componentWillReceiveProps&&"function"!==typeof g.componentWillReceiveProps||(h!==x||r!==l)&&Ch(b,g,d,l);je=!1;r=b.memoizedState;g.state=r;qe(b,d,g,e);var A=b.memoizedState;h!==x||r!==A||hd.current||je?("function"===typeof u&&(yh(b,c,u,d),A=b.memoizedState),(p=je||Ah(b,c,p,d,r,A,l)||!1)?(q||"function"!==typeof g.UNSAFE_componentWillUpdate&&"function"!==typeof g.componentWillUpdate||("function"===typeof g.componentWillUpdate&&g.componentWillUpdate(d,A,l),"function"===typeof g.UNSAFE_componentWillUpdate&&
+function ji(a,b,c,d,e){if(kd(c)){var f=!0;od(b)}else f=!1;Xh(b,e);if(null===b.stateNode)ki(a,b),Bh(b,c,d),Dh(b,c,d,e),d=!0;else if(null===a){var g=b.stateNode,h=b.memoizedProps;g.props=h;var l=g.context,p=c.contextType;"object"===typeof p&&null!==p?p=qg(p):(p=kd(c)?id:gd.current,p=jd(b,p));var q=c.getDerivedStateFromProps,w="function"===typeof q||"function"===typeof g.getSnapshotBeforeUpdate;w||"function"!==typeof g.UNSAFE_componentWillReceiveProps&&"function"!==typeof g.componentWillReceiveProps||
+(h!==d||l!==p)&&Ch(b,g,d,p);je=!1;var r=b.memoizedState;g.state=r;qe(b,d,g,e);l=b.memoizedState;h!==d||r!==l||hd.current||je?("function"===typeof q&&(yh(b,c,q,d),l=b.memoizedState),(h=je||Ah(b,c,h,d,r,l,p))?(w||"function"!==typeof g.UNSAFE_componentWillMount&&"function"!==typeof g.componentWillMount||("function"===typeof g.componentWillMount&&g.componentWillMount(),"function"===typeof g.UNSAFE_componentWillMount&&g.UNSAFE_componentWillMount()),"function"===typeof g.componentDidMount&&(b.flags|=4194308)):
+("function"===typeof g.componentDidMount&&(b.flags|=4194308),b.memoizedProps=d,b.memoizedState=l),g.props=d,g.state=l,g.context=p,d=h):("function"===typeof g.componentDidMount&&(b.flags|=4194308),d=!1)}else{g=b.stateNode;le(a,b);h=b.memoizedProps;p=b.type===b.elementType?h:xh(b.type,h);g.props=p;w=b.pendingProps;r=g.context;l=c.contextType;"object"===typeof l&&null!==l?l=qg(l):(l=kd(c)?id:gd.current,l=jd(b,l));var t=c.getDerivedStateFromProps;(q="function"===typeof t||"function"===typeof g.getSnapshotBeforeUpdate)||
+"function"!==typeof g.UNSAFE_componentWillReceiveProps&&"function"!==typeof g.componentWillReceiveProps||(h!==w||r!==l)&&Ch(b,g,d,l);je=!1;r=b.memoizedState;g.state=r;qe(b,d,g,e);var A=b.memoizedState;h!==w||r!==A||hd.current||je?("function"===typeof t&&(yh(b,c,t,d),A=b.memoizedState),(p=je||Ah(b,c,p,d,r,A,l)||!1)?(q||"function"!==typeof g.UNSAFE_componentWillUpdate&&"function"!==typeof g.componentWillUpdate||("function"===typeof g.componentWillUpdate&&g.componentWillUpdate(d,A,l),"function"===typeof g.UNSAFE_componentWillUpdate&&
 g.UNSAFE_componentWillUpdate(d,A,l)),"function"===typeof g.componentDidUpdate&&(b.flags|=4),"function"===typeof g.getSnapshotBeforeUpdate&&(b.flags|=1024)):("function"!==typeof g.componentDidUpdate||h===a.memoizedProps&&r===a.memoizedState||(b.flags|=4),"function"!==typeof g.getSnapshotBeforeUpdate||h===a.memoizedProps&&r===a.memoizedState||(b.flags|=1024),b.memoizedProps=d,b.memoizedState=A),g.props=d,g.state=A,g.context=l,d=p):("function"!==typeof g.componentDidUpdate||h===a.memoizedProps&&r===
 a.memoizedState||(b.flags|=4),"function"!==typeof g.getSnapshotBeforeUpdate||h===a.memoizedProps&&r===a.memoizedState||(b.flags|=1024),d=!1)}return li(a,b,c,d,f,e)}
 function li(a,b,c,d,e,f){di(a,b);var g=0!==(b.flags&128);if(!d&&!g)return e&&pd(b,c,!1),Yh(a,b,f);d=b.stateNode;Th.current=b;if(g&&"function"!==typeof c.getDerivedStateFromError){var h=null;ph=-1}else hb(b),h=d.render(),ib();b.flags|=1;null!==a&&g?(g=h,b.child=Qe(b,a.child,null,f),b.child=Qe(b,null,g,f)):Vh(a,b,h,f);b.memoizedState=d.state;e&&pd(b,c,!0);return b.child}
@@ -187,19 +176,19 @@ d=b.mode,e=b.child,f={mode:"hidden",children:f},0===(d&1)&&null!==e?(e.childLane
 children:d.children};0===(f&1)&&b.child!==g?(d=b.child,d.childLanes=0,d.pendingProps=l,b.mode&2&&(d.actualDuration=0,d.actualStartTime=-1,d.selfBaseDuration=g.selfBaseDuration,d.treeBaseDuration=g.treeBaseDuration),b.deletions=null):(d=Ke(g,l),d.subtreeFlags=g.subtreeFlags&31457280);null!==h?e=Ke(h,e):(e=Oe(e,f,c,null),e.flags|=2);e.return=b;d.return=b;d.sibling=e;b.child=d;d=e;e=b.child;f=a.child.memoizedState;null===f?f=pi(c):(g=f.cachePool,null!==g?(h=hi._currentValue,g=g.parent!==h?{parent:h,
 pool:h}:g):g=qi(),f={baseLanes:f.baseLanes|c,cachePool:g});e.memoizedState=f;e.childLanes=a.childLanes&~c;b.memoizedState=oi;return d}$e(b);e=a.child;a=e.sibling;d=Ke(e,{mode:"visible",children:d.children});0===(b.mode&1)&&(d.lanes=c);d.return=b;d.sibling=null;null!==a&&(c=b.deletions,null===c?(b.deletions=[a],b.flags|=16):c.push(a));b.child=d;b.memoizedState=null;return d}function ti(a,b){b=si({mode:"visible",children:b},a.mode,0,null);b.return=a;return a.child=b}
 function vi(a,b,c,d){null!==d&&Yd(d);Qe(b,a.child,null,c);a=ti(b,b.pendingProps.children);a.flags|=2;b.memoizedState=null;return a}
-function ui(a,b,c,d,e,f,g){if(c){if(b.flags&256)return $e(b),b.flags&=-257,e=Fh(Error(t(422))),vi(a,b,g,e);if(null!==b.memoizedState)return cf(b),b.child=a.child,b.flags|=128,null;cf(b);e=d.fallback;f=b.mode;d=si({mode:"visible",children:d.children},f,0,null);e=Oe(e,f,g,null);e.flags|=2;d.return=b;e.return=b;d.sibling=e;b.child=d;0!==(b.mode&1)&&Qe(b,a.child,null,g);b.child.memoizedState=pi(g);b.memoizedState=oi;return e}$e(b);if(0===(b.mode&1))return vi(a,b,g,null);if("$!"===e.data){e=e.nextSibling&&
-e.nextSibling.dataset;if(e)var h=e.dgst;e=h;d=Error(t(419));d.digest=e;e=Fh(d,e,void 0);return vi(a,b,g,e)}h=0!==(g&a.childLanes);if(ug||h){d=P;if(null!==d){switch(g&-g){case 2:h=1;break;case 8:h=4;break;case 32:h=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:h=64;break;case 268435456:h=134217728;break;default:h=0}h=0!==
-(h&(d.suspendedLanes|g))?0:h;if(0!==h&&h!==f.retryLane)throw f.retryLane=h,ge(a,h),Eg(d,a,h),Uh;}"$?"!==e.data&&Ph();return vi(a,b,g,null)}if("$?"===e.data)return b.flags|=128,b.child=a.child,b=wi.bind(null,a),e._reactRetry=b,null;a=f.treeContext;I=Md(e.nextSibling);H=b;K=!0;Fd=null;Gd=!1;null!==a&&(wd[xd++]=zd,wd[xd++]=Ad,wd[xd++]=yd,zd=a.id,Ad=a.overflow,yd=b);b=ti(b,d.children);b.flags|=4096;return b}function xi(a,b,c){a.lanes|=b;var d=a.alternate;null!==d&&(d.lanes|=b);yi(a.return,b,c)}
-function zi(a,b,c,d,e){var f=a.memoizedState;null===f?a.memoizedState={isBackwards:b,rendering:null,renderingStartTime:0,last:d,tail:c,tailMode:e}:(f.isBackwards=b,f.rendering=null,f.renderingStartTime=0,f.last=d,f.tail=c,f.tailMode=e)}
+function ui(a,b,c,d,e,f,g){if(c){if(b.flags&256)return $e(b),b.flags&=-257,e=Fh(Error(u(422))),vi(a,b,g,e);if(null!==b.memoizedState)return cf(b),b.child=a.child,b.flags|=128,null;cf(b);e=d.fallback;f=b.mode;d=si({mode:"visible",children:d.children},f,0,null);e=Oe(e,f,g,null);e.flags|=2;d.return=b;e.return=b;d.sibling=e;b.child=d;0!==(b.mode&1)&&Qe(b,a.child,null,g);b.child.memoizedState=pi(g);b.memoizedState=oi;return e}$e(b);if(0===(b.mode&1))return vi(a,b,g,null);if("$!"===e.data){e=e.nextSibling&&
+e.nextSibling.dataset;if(e)var h=e.dgst;e=h;f=Error(u(419));f.digest=e;e=Fh(f,e,void 0);return vi(a,b,g,e)}h=0!==(g&a.childLanes);if(ug||h){d=P;if(null!==d){h=g&-g;if(0!==(h&42))h=1;else switch(h){case 2:h=1;break;case 8:h=4;break;case 32:h=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:h=64;break;case 268435456:h=134217728;
+break;default:h=0}h=0!==(h&(d.suspendedLanes|g))?0:h;if(0!==h&&h!==f.retryLane)throw f.retryLane=h,ge(a,h),Eg(d,a,h),Uh;}"$?"!==e.data&&Ph();return vi(a,b,g,null)}if("$?"===e.data)return b.flags|=128,b.child=a.child,b=wi.bind(null,a),e._reactRetry=b,null;a=f.treeContext;I=Md(e.nextSibling);H=b;K=!0;Fd=null;Gd=!1;null!==a&&(wd[xd++]=zd,wd[xd++]=Ad,wd[xd++]=yd,zd=a.id,Ad=a.overflow,yd=b);b=ti(b,d.children);b.flags|=4096;return b}
+function xi(a,b,c){a.lanes|=b;var d=a.alternate;null!==d&&(d.lanes|=b);yi(a.return,b,c)}function zi(a,b,c,d,e){var f=a.memoizedState;null===f?a.memoizedState={isBackwards:b,rendering:null,renderingStartTime:0,last:d,tail:c,tailMode:e}:(f.isBackwards=b,f.rendering=null,f.renderingStartTime=0,f.last=d,f.tail=c,f.tailMode=e)}
 function Ai(a,b,c){var d=b.pendingProps,e=d.revealOrder,f=d.tail;Vh(a,b,d.children,c);d=af.current;if(0!==(d&2))d=d&1|2,b.flags|=128;else{if(null!==a&&0!==(a.flags&128))a:for(a=b.child;null!==a;){if(13===a.tag)null!==a.memoizedState&&xi(a,c,b);else if(19===a.tag)xi(a,c,b);else if(null!==a.child){a.child.return=a;a=a.child;continue}if(a===b)break a;for(;null===a.sibling;){if(null===a.return||a.return===b)break a;a=a.return}a.sibling.return=a.return;a=a.sibling}d&=1}E(af,d);if(0===(b.mode&1))b.memoizedState=
 null;else switch(e){case "forwards":c=b.child;for(e=null;null!==c;)a=c.alternate,null!==a&&null===ef(a)&&(e=c),c=c.sibling;c=e;null===c?(e=b.child,b.child=null):(e=c.sibling,c.sibling=null);zi(b,!1,e,c,f);break;case "backwards":c=null;e=b.child;for(b.child=null;null!==e;){a=e.alternate;if(null!==a&&null===ef(a)){b.child=e;break}a=e.sibling;e.sibling=c;c=e;e=a}zi(b,!0,c,null,f);break;case "together":zi(b,!1,null,null,void 0);break;default:b.memoizedState=null}return b.child}
-function ki(a,b){0===(b.mode&1)&&null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2)}function Yh(a,b,c){null!==a&&(b.dependencies=a.dependencies);ph=-1;re|=b.lanes;if(0===(c&b.childLanes))return null;if(null!==a&&b.child!==a.child)throw Error(t(153));if(null!==b.child){a=b.child;c=Ke(a,a.pendingProps);b.child=c;for(c.return=b;null!==a.sibling;)a=a.sibling,c=c.sibling=Ke(a,a.pendingProps),c.return=b;c.sibling=null}return b.child}
+function ki(a,b){0===(b.mode&1)&&null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2)}function Yh(a,b,c){null!==a&&(b.dependencies=a.dependencies);ph=-1;re|=b.lanes;if(0===(c&b.childLanes))return null;if(null!==a&&b.child!==a.child)throw Error(u(153));if(null!==b.child){a=b.child;c=Ke(a,a.pendingProps);b.child=c;for(c.return=b;null!==a.sibling;)a=a.sibling,c=c.sibling=Ke(a,a.pendingProps),c.return=b;c.sibling=null}return b.child}
 function Bi(a,b,c){switch(b.tag){case 3:mi(b);Ci(b,hi,a.memoizedState.cache);Xd();break;case 27:case 5:Na(b);break;case 1:kd(b.type)&&od(b);break;case 4:Ja(b,b.stateNode.containerInfo);break;case 10:Ci(b,b.type._context,b.memoizedProps.value);break;case 12:0!==(c&b.childLanes)&&(b.flags|=4);var d=b.stateNode;d.effectDuration=0;d.passiveEffectDuration=0;break;case 13:d=b.memoizedState;if(null!==d){if(null!==d.dehydrated)return $e(b),b.flags|=128,null;if(0!==(c&b.child.childLanes))return ri(a,b,c);
 $e(b);a=Yh(a,b,c);return null!==a?a.sibling:null}$e(b);break;case 19:d=0!==(c&b.childLanes);if(0!==(a.flags&128)){if(d)return Ai(a,b,c);b.flags|=128}var e=b.memoizedState;null!==e&&(e.rendering=null,e.tail=null,e.lastEffect=null);E(af,af.current);if(d)break;else return null;case 22:case 23:return b.lanes=0,ci(a,b,c);case 24:Ci(b,hi,a.memoizedState.cache)}return Yh(a,b,c)}var Di=ka(null),Ei=null,Fi=null,Gi=null;function Hi(){Gi=Fi=Ei=null}
 function Ci(a,b,c){E(Di,b._currentValue);b._currentValue=c}function Ii(a){a._currentValue=Di.current;D(Di)}function yi(a,b,c){for(;null!==a;){var d=a.alternate;(a.childLanes&b)!==b?(a.childLanes|=b,null!==d&&(d.childLanes|=b)):null!==d&&(d.childLanes&b)!==b&&(d.childLanes|=b);if(a===c)break;a=a.return}}
 function Ji(a,b,c){var d=a.child;null!==d&&(d.return=a);for(;null!==d;){var e=d.dependencies;if(null!==e){var f=d.child;for(var g=e.firstContext;null!==g;){if(g.context===b){if(1===d.tag){g=me(c&-c);g.tag=2;var h=d.updateQueue;if(null!==h){h=h.shared;var l=h.pending;null===l?g.next=g:(g.next=l.next,l.next=g);h.pending=g}}d.lanes|=c;g=d.alternate;null!==g&&(g.lanes|=c);yi(d.return,c,a);e.lanes|=c;break}g=g.next}}else if(10===d.tag)f=d.type===a.type?null:d.child;else if(18===d.tag){f=d.return;if(null===
-f)throw Error(t(341));f.lanes|=c;e=f.alternate;null!==e&&(e.lanes|=c);yi(f,c,a);f=d.sibling}else f=d.child;if(null!==f)f.return=d;else for(f=d;null!==f;){if(f===a){f=null;break}d=f.sibling;if(null!==d){d.return=f.return;f=d;break}f=f.return}d=f}}function Xh(a,b){Ei=a;Gi=Fi=null;a=a.dependencies;null!==a&&null!==a.firstContext&&(0!==(a.lanes&b)&&(ug=!0),a.firstContext=null)}function qg(a){return Ki(Ei,a)}function Pe(a,b,c){null===Ei&&Xh(a,c);return Ki(a,b)}
-function Ki(a,b){var c=b._currentValue;if(Gi!==b)if(b={context:b,memoizedValue:c,next:null},null===Fi){if(null===a)throw Error(t(308));Fi=b;a.dependencies={lanes:0,firstContext:b}}else Fi=Fi.next=b;return c}
+f)throw Error(u(341));f.lanes|=c;e=f.alternate;null!==e&&(e.lanes|=c);yi(f,c,a);f=d.sibling}else f=d.child;if(null!==f)f.return=d;else for(f=d;null!==f;){if(f===a){f=null;break}d=f.sibling;if(null!==d){d.return=f.return;f=d;break}f=f.return}d=f}}function Xh(a,b){Ei=a;Gi=Fi=null;a=a.dependencies;null!==a&&null!==a.firstContext&&(0!==(a.lanes&b)&&(ug=!0),a.firstContext=null)}function qg(a){return Ki(Ei,a)}function Pe(a,b,c){null===Ei&&Xh(a,c);return Ki(a,b)}
+function Ki(a,b){var c=b._currentValue;if(Gi!==b)if(b={context:b,memoizedValue:c,next:null},null===Fi){if(null===a)throw Error(u(308));Fi=b;a.dependencies={lanes:0,firstContext:b}}else Fi=Fi.next=b;return c}
 var Li="undefined"!==typeof AbortController?AbortController:function(){var a=[],b=this.signal={aborted:!1,addEventListener:function(c,d){a.push(d)}};this.abort=function(){b.aborted=!0;a.forEach(function(c){return c()})}},Mi=ba.unstable_scheduleCallback,Ni=ba.unstable_NormalPriority,hi={$$typeof:ra,Consumer:null,Provider:null,_currentValue:null,_currentValue2:null,_threadCount:0,_defaultValue:null,_globalName:null};function ih(){return{controller:new Li,data:new Map,refCount:0}}
 function Oi(a){a.refCount--;0===a.refCount&&Mi(Ni,function(){a.controller.abort()})}var Pi=da.ReactCurrentBatchConfig,Qi=ka(null);function gi(){var a=Qi.current;return null!==a?a:P.pooledCache}function fi(a,b){null===b?E(Qi,Qi.current):E(Qi,b.pool)}function qi(){var a=gi();return null===a?null:{parent:hi._currentValue,pool:a}}function Ri(a){a.flags|=4}function Si(a){a.flags|=2097664}
 function Ti(a,b){if("stylesheet"!==b.type||0!==(b.state.loading&4))a.flags&=-16777217;else if(a.flags|=16777216,0===(O&42)&&(b="stylesheet"===b.type&&0===(b.state.loading&3)?!1:!0,!b))if(Ui())a.flags|=8192;else throw Be=xe,we;}function Vi(a,b){null!==b?a.flags|=4:a.flags&16384&&(b=22!==a.tag?yb():536870912,a.lanes|=b)}
@@ -207,27 +196,27 @@ function Wi(a,b){if(!K)switch(a.tailMode){case "hidden":b=a.tail;for(var c=null;
 function V(a){var b=null!==a.alternate&&a.alternate.child===a.child,c=0,d=0;if(b)if(0!==(a.mode&2)){for(var e=a.selfBaseDuration,f=a.child;null!==f;)c|=f.lanes|f.childLanes,d|=f.subtreeFlags&31457280,d|=f.flags&31457280,e+=f.treeBaseDuration,f=f.sibling;a.treeBaseDuration=e}else for(e=a.child;null!==e;)c|=e.lanes|e.childLanes,d|=e.subtreeFlags&31457280,d|=e.flags&31457280,e.return=a,e=e.sibling;else if(0!==(a.mode&2)){e=a.actualDuration;f=a.selfBaseDuration;for(var g=a.child;null!==g;)c|=g.lanes|
 g.childLanes,d|=g.subtreeFlags,d|=g.flags,e+=g.actualDuration,f+=g.treeBaseDuration,g=g.sibling;a.actualDuration=e;a.treeBaseDuration=f}else for(e=a.child;null!==e;)c|=e.lanes|e.childLanes,d|=e.subtreeFlags,d|=e.flags,e.return=a,e=e.sibling;a.subtreeFlags|=d;a.childLanes=c;return b}
 function Xi(a,b,c){var d=b.pendingProps;Ed(b);switch(b.tag){case 2:case 16:case 15:case 0:case 11:case 7:case 8:case 12:case 9:case 14:return V(b),null;case 1:return kd(b.type)&&ld(),V(b),null;case 3:c=b.stateNode;d=null;null!==a&&(d=a.memoizedState.cache);b.memoizedState.cache!==d&&(b.flags|=2048);Ii(hi);Ma();D(hd);D(gd);c.pendingContext&&(c.context=c.pendingContext,c.pendingContext=null);if(null===a||null===a.child)Ud(b)?Ri(b):null===a||a.memoizedState.isDehydrated&&0===(b.flags&256)||(b.flags|=
-1024,null!==Fd&&(Yi(Fd),Fd=null));V(b);return null;case 26:c=b.memoizedState;if(null===a)Ri(b),null!==b.ref&&Si(b),null!==c?(V(b),Ti(b,c)):(V(b),b.flags&=-16777217);else{var e=a.memoizedState;c!==e&&Ri(b);a.ref!==b.ref&&Si(b);null!==c?(V(b),c===e?b.flags&=-16777217:Ti(b,c)):(a.memoizedProps!==d&&Ri(b),V(b),b.flags&=-16777217)}return null;case 27:Oa(b);c=Ga.current;e=b.type;if(null!==a&&null!=b.stateNode)a.memoizedProps!==d&&Ri(b),a.ref!==b.ref&&Si(b);else{if(!d){if(null===b.stateNode)throw Error(t(166));
-V(b);return null}a=Ea.current;Ud(b)?Zi(b.stateNode,b.type,b.memoizedProps,a,b):(a=$i(e,d,c),b.stateNode=a,Ri(b));null!==b.ref&&Si(b)}V(b);return null;case 5:Oa(b);c=b.type;if(null!==a&&null!=b.stateNode)a.memoizedProps!==d&&Ri(b),a.ref!==b.ref&&Si(b);else{if(!d){if(null===b.stateNode)throw Error(t(166));V(b);return null}a=Ea.current;if(Ud(b))Zi(b.stateNode,b.type,b.memoizedProps,a,b);else{e=aj(Ga.current);switch(a){case 1:a=e.createElementNS("http://www.w3.org/2000/svg",c);break;case 2:a=e.createElementNS("http://www.w3.org/1998/Math/MathML",
+1024,null!==Fd&&(Yi(Fd),Fd=null));V(b);return null;case 26:c=b.memoizedState;if(null===a)Ri(b),null!==b.ref&&Si(b),null!==c?(V(b),Ti(b,c)):(V(b),b.flags&=-16777217);else{var e=a.memoizedState;c!==e&&Ri(b);a.ref!==b.ref&&Si(b);null!==c?(V(b),c===e?b.flags&=-16777217:Ti(b,c)):(a.memoizedProps!==d&&Ri(b),V(b),b.flags&=-16777217)}return null;case 27:Oa(b);c=Ga.current;e=b.type;if(null!==a&&null!=b.stateNode)a.memoizedProps!==d&&Ri(b),a.ref!==b.ref&&Si(b);else{if(!d){if(null===b.stateNode)throw Error(u(166));
+V(b);return null}a=Ea.current;Ud(b)?Zi(b.stateNode,b.type,b.memoizedProps,a,b):(a=$i(e,d,c),b.stateNode=a,Ri(b));null!==b.ref&&Si(b)}V(b);return null;case 5:Oa(b);c=b.type;if(null!==a&&null!=b.stateNode)a.memoizedProps!==d&&Ri(b),a.ref!==b.ref&&Si(b);else{if(!d){if(null===b.stateNode)throw Error(u(166));V(b);return null}a=Ea.current;if(Ud(b))Zi(b.stateNode,b.type,b.memoizedProps,a,b);else{e=aj(Ga.current);switch(a){case 1:a=e.createElementNS("http://www.w3.org/2000/svg",c);break;case 2:a=e.createElementNS("http://www.w3.org/1998/Math/MathML",
 c);break;default:switch(c){case "svg":a=e.createElementNS("http://www.w3.org/2000/svg",c);break;case "math":a=e.createElementNS("http://www.w3.org/1998/Math/MathML",c);break;case "script":a=e.createElement("div");a.innerHTML="<script>\x3c/script>";a=a.removeChild(a.firstChild);break;case "select":a="string"===typeof d.is?e.createElement("select",{is:d.is}):e.createElement("select");d.multiple?a.multiple=!0:d.size&&(a.size=d.size);break;default:a="string"===typeof d.is?e.createElement(c,{is:d.is}):
 e.createElement(c)}}a[Mb]=b;a[Nb]=d;a:for(e=b.child;null!==e;){if(5===e.tag||6===e.tag)a.appendChild(e.stateNode);else if(4!==e.tag&&27!==e.tag&&null!==e.child){e.child.return=e;e=e.child;continue}if(e===b)break a;for(;null===e.sibling;){if(null===e.return||e.return===b)break a;e=e.return}e.sibling.return=e.return;e=e.sibling}b.stateNode=a;a:switch(bj(a,c,d),c){case "button":case "input":case "select":case "textarea":a=!!d.autoFocus;break a;case "img":a=!0;break a;default:a=!1}a&&Ri(b)}null!==b.ref&&
-Si(b)}V(b);b.flags&=-16777217;return null;case 6:if(a&&null!=b.stateNode)a.memoizedProps!==d&&Ri(b);else{if("string"!==typeof d&&null===b.stateNode)throw Error(t(166));a=Ga.current;if(Ud(b)){a:{a=b.stateNode;c=b.memoizedProps;a[Mb]=b;if(d=a.nodeValue!==c)if(e=H,null!==e)switch(e.tag){case 3:e=0!==(e.mode&1);cj(a.nodeValue,c,e);if(e){a=!1;break a}break;case 27:case 5:var f=0!==(e.mode&1);!0!==e.memoizedProps.suppressHydrationWarning&&cj(a.nodeValue,c,f);if(f){a=!1;break a}}a=d}a&&Ri(b)}else a=aj(a).createTextNode(d),
-a[Mb]=b,b.stateNode=a}V(b);return null;case 13:df(b);d=b.memoizedState;if(null===a||null!==a.memoizedState&&null!==a.memoizedState.dehydrated){if(K&&null!==I&&0!==(b.mode&1)&&0===(b.flags&128))Wd(),Xd(),b.flags|=384,e=!1;else if(e=Ud(b),null!==d&&null!==d.dehydrated){if(null===a){if(!e)throw Error(t(318));e=b.memoizedState;e=null!==e?e.dehydrated:null;if(!e)throw Error(t(317));e[Mb]=b;V(b);0!==(b.mode&2)&&null!==d&&(e=b.child,null!==e&&(b.treeBaseDuration-=e.treeBaseDuration))}else Xd(),0===(b.flags&
+Si(b)}V(b);b.flags&=-16777217;return null;case 6:if(a&&null!=b.stateNode)a.memoizedProps!==d&&Ri(b);else{if("string"!==typeof d&&null===b.stateNode)throw Error(u(166));a=Ga.current;if(Ud(b)){a:{a=b.stateNode;c=b.memoizedProps;a[Mb]=b;if(d=a.nodeValue!==c)if(e=H,null!==e)switch(e.tag){case 3:e=0!==(e.mode&1);cj(a.nodeValue,c,e);if(e){a=!1;break a}break;case 27:case 5:var f=0!==(e.mode&1);!0!==e.memoizedProps.suppressHydrationWarning&&cj(a.nodeValue,c,f);if(f){a=!1;break a}}a=d}a&&Ri(b)}else a=aj(a).createTextNode(d),
+a[Mb]=b,b.stateNode=a}V(b);return null;case 13:df(b);d=b.memoizedState;if(null===a||null!==a.memoizedState&&null!==a.memoizedState.dehydrated){if(K&&null!==I&&0!==(b.mode&1)&&0===(b.flags&128))Wd(),Xd(),b.flags|=384,e=!1;else if(e=Ud(b),null!==d&&null!==d.dehydrated){if(null===a){if(!e)throw Error(u(318));e=b.memoizedState;e=null!==e?e.dehydrated:null;if(!e)throw Error(u(317));e[Mb]=b;V(b);0!==(b.mode&2)&&null!==d&&(e=b.child,null!==e&&(b.treeBaseDuration-=e.treeBaseDuration))}else Xd(),0===(b.flags&
 128)&&(b.memoizedState=null),b.flags|=4,V(b),0!==(b.mode&2)&&null!==d&&(e=b.child,null!==e&&(b.treeBaseDuration-=e.treeBaseDuration));e=!1}else null!==Fd&&(Yi(Fd),Fd=null),e=!0;if(!e)return b.flags&256?b:null}if(0!==(b.flags&128))return b.lanes=c,0!==(b.mode&2)&&wh(b),b;c=null!==d;a=null!==a&&null!==a.memoizedState;c&&(d=b.child,e=null,null!==d.alternate&&null!==d.alternate.memoizedState&&null!==d.alternate.memoizedState.cachePool&&(e=d.alternate.memoizedState.cachePool.pool),f=null,null!==d.memoizedState&&
 null!==d.memoizedState.cachePool&&(f=d.memoizedState.cachePool.pool),f!==e&&(d.flags|=2048));c!==a&&c&&(b.child.flags|=8192);Vi(b,b.updateQueue);V(b);0!==(b.mode&2)&&c&&(a=b.child,null!==a&&(b.treeBaseDuration-=a.treeBaseDuration));return null;case 4:return Ma(),null===a&&dj(b.stateNode.containerInfo),V(b),null;case 10:return Ii(b.type._context),V(b),null;case 17:return kd(b.type)&&ld(),V(b),null;case 19:D(af);e=b.memoizedState;if(null===e)return V(b),null;d=0!==(b.flags&128);f=e.rendering;if(null===
 f)if(d)Wi(e,!1);else{if(0!==Qh||null!==a&&0!==(a.flags&128))for(a=b.child;null!==a;){f=ef(a);if(null!==f){b.flags|=128;Wi(e,!1);a=f.updateQueue;b.updateQueue=a;Vi(b,a);b.subtreeFlags=0;a=c;for(c=b.child;null!==c;)ej(c,a),c=c.sibling;E(af,af.current&1|2);return b.child}a=a.sibling}null!==e.tail&&Ta()>fj&&(b.flags|=128,d=!0,Wi(e,!1),b.lanes=4194304)}else{if(!d)if(a=ef(f),null!==a){if(b.flags|=128,d=!0,a=a.updateQueue,b.updateQueue=a,Vi(b,a),Wi(e,!0),null===e.tail&&"hidden"===e.tailMode&&!f.alternate&&
 !K)return V(b),null}else 2*Ta()-e.renderingStartTime>fj&&536870912!==c&&(b.flags|=128,d=!0,Wi(e,!1),b.lanes=4194304);e.isBackwards?(f.sibling=b.child,b.child=f):(a=e.last,null!==a?a.sibling=f:b.child=f,e.last=f)}if(null!==e.tail)return b=e.tail,e.rendering=b,e.tail=b.sibling,e.renderingStartTime=Ta(),b.sibling=null,a=af.current,E(af,d?a&1|2:a&1),b;V(b);return null;case 22:case 23:return df(b),Xe(),d=null!==b.memoizedState,null!==a?null!==a.memoizedState!==d&&(b.flags|=8192):d&&(b.flags|=8192),d&&
 0!==(b.mode&1)?0!==(c&536870912)&&0===(b.flags&128)&&(V(b),b.subtreeFlags&6&&(b.flags|=8192)):V(b),c=b.updateQueue,null!==c&&Vi(b,c.retryQueue),c=null,null!==a&&null!==a.memoizedState&&null!==a.memoizedState.cachePool&&(c=a.memoizedState.cachePool.pool),d=null,null!==b.memoizedState&&null!==b.memoizedState.cachePool&&(d=b.memoizedState.cachePool.pool),d!==c&&(b.flags|=2048),null!==a&&D(Qi),null;case 24:return c=null,null!==a&&(c=a.memoizedState.cache),b.memoizedState.cache!==c&&(b.flags|=2048),Ii(hi),
-V(b),null;case 25:return null}throw Error(t(156,b.tag));}
-function gj(a,b){Ed(b);switch(b.tag){case 1:return kd(b.type)&&ld(),a=b.flags,a&65536?(b.flags=a&-65537|128,0!==(b.mode&2)&&wh(b),b):null;case 3:return Ii(hi),Ma(),D(hd),D(gd),a=b.flags,0!==(a&65536)&&0===(a&128)?(b.flags=a&-65537|128,b):null;case 26:case 27:case 5:return Oa(b),null;case 13:df(b);a=b.memoizedState;if(null!==a&&null!==a.dehydrated){if(null===b.alternate)throw Error(t(340));Xd()}a=b.flags;return a&65536?(b.flags=a&-65537|128,0!==(b.mode&2)&&wh(b),b):null;case 19:return D(af),null;case 4:return Ma(),
+V(b),null;case 25:return null}throw Error(u(156,b.tag));}
+function gj(a,b){Ed(b);switch(b.tag){case 1:return kd(b.type)&&ld(),a=b.flags,a&65536?(b.flags=a&-65537|128,0!==(b.mode&2)&&wh(b),b):null;case 3:return Ii(hi),Ma(),D(hd),D(gd),a=b.flags,0!==(a&65536)&&0===(a&128)?(b.flags=a&-65537|128,b):null;case 26:case 27:case 5:return Oa(b),null;case 13:df(b);a=b.memoizedState;if(null!==a&&null!==a.dehydrated){if(null===b.alternate)throw Error(u(340));Xd()}a=b.flags;return a&65536?(b.flags=a&-65537|128,0!==(b.mode&2)&&wh(b),b):null;case 19:return D(af),null;case 4:return Ma(),
 null;case 10:return Ii(b.type._context),null;case 22:case 23:return df(b),Xe(),null!==a&&D(Qi),a=b.flags,a&65536?(b.flags=a&-65537|128,0!==(b.mode&2)&&wh(b),b):null;case 24:return Ii(hi),null;case 25:return null;default:return null}}
 function hj(a,b){Ed(b);switch(b.tag){case 1:a=b.type.childContextTypes;null!==a&&void 0!==a&&ld();break;case 3:Ii(hi);Ma();D(hd);D(gd);break;case 26:case 27:case 5:Oa(b);break;case 4:Ma();break;case 13:df(b);break;case 19:D(af);break;case 10:Ii(b.type._context);break;case 22:case 23:df(b);Xe();null!==a&&D(Qi);break;case 24:Ii(hi)}}function ij(a,b,c){var d=Array.prototype.slice.call(arguments,3);try{b.apply(c,d)}catch(e){this.onError(e)}}
-var jj=!1,kj=null,lj=!1,mj=null,nj={onError:function(a){jj=!0;kj=a}};function oj(a,b,c,d,e,f,g,h,l){jj=!1;kj=null;ij.apply(nj,arguments)}function pj(a,b,c,d,e,f,g,h,l){oj.apply(this,arguments);if(jj){if(jj){var p=kj;jj=!1;kj=null}else throw Error(t(198));lj||(lj=!0,mj=p)}}var qj=!1,rj=!1,sj="function"===typeof WeakSet?WeakSet:Set,tj=null,uj=null,vj=null;function wj(a){return 0!==(a.mode&2)&&0!==(N&4)}
+var jj=!1,kj=null,lj=!1,mj=null,nj={onError:function(a){jj=!0;kj=a}};function oj(a,b,c,d,e,f,g,h,l){jj=!1;kj=null;ij.apply(nj,arguments)}function pj(a,b,c,d,e,f,g,h,l){oj.apply(this,arguments);if(jj){if(jj){var p=kj;jj=!1;kj=null}else throw Error(u(198));lj||(lj=!0,mj=p)}}var qj=!1,rj=!1,sj="function"===typeof WeakSet?WeakSet:Set,tj=null,uj=null,vj=null;function wj(a){return 0!==(a.mode&2)&&0!==(N&4)}
 function xj(a,b){b.props=a.memoizedProps;b.state=a.memoizedState;if(wj(a))try{vh(),b.componentWillUnmount()}finally{th(a)}else b.componentWillUnmount()}function yj(a,b){try{var c=a.ref;if(null!==c){var d=a.stateNode;switch(a.tag){case 26:case 27:case 5:var e=d;break;default:e=d}if("function"===typeof c)if(wj(a))try{vh(),a.refCleanup=c(e)}finally{th(a)}else a.refCleanup=c(e);else c.current=e}}catch(f){W(a,b,f)}}
 function zj(a,b){var c=a.ref,d=a.refCleanup;if(null!==c)if("function"===typeof d)try{if(wj(a))try{vh(),d()}finally{th(a)}else d()}catch(e){W(a,b,e)}finally{a.refCleanup=null,a=a.alternate,null!=a&&(a.refCleanup=null)}else if("function"===typeof c)try{if(wj(a))try{vh(),c(null)}finally{th(a)}else c(null)}catch(e){W(a,b,e)}else c.current=null}function Aj(a,b,c){try{c()}catch(d){W(a,b,d)}}var Bj=!1;
-function Cj(a,b){Dj=Ej;a=Fj();if(Gj(a)){if("selectionStart"in a)var c={start:a.selectionStart,end:a.selectionEnd};else a:{c=(c=a.ownerDocument)&&c.defaultView||window;var d=c.getSelection&&c.getSelection();if(d&&0!==d.rangeCount){c=d.anchorNode;var e=d.anchorOffset,f=d.focusNode;d=d.focusOffset;try{c.nodeType,f.nodeType}catch(n){c=null;break a}var g=0,h=-1,l=-1,p=0,q=0,x=a,r=null;b:for(;;){for(var u;;){x!==c||0!==e&&3!==x.nodeType||(h=g+e);x!==f||0!==d&&3!==x.nodeType||(l=g+d);3===x.nodeType&&(g+=
-x.nodeValue.length);if(null===(u=x.firstChild))break;r=x;x=u}for(;;){if(x===a)break b;r===c&&++p===e&&(h=g);r===f&&++q===d&&(l=g);if(null!==(u=x.nextSibling))break;x=r;r=x.parentNode}x=u}c=-1===h||-1===l?null:{start:h,end:l}}else c=null}c=c||{start:0,end:0}}else c=null;Hj={focusedElem:a,selectionRange:c};Ej=!1;for(tj=b;null!==tj;)if(b=tj,a=b.child,0!==(b.subtreeFlags&1028)&&null!==a)a.return=b,tj=a;else for(;null!==tj;){b=tj;try{var A=b.alternate,C=b.flags;switch(b.tag){case 0:break;case 11:case 15:break;
-case 1:if(0!==(C&1024)&&null!==A){var J=A.memoizedProps,S=A.memoizedState,m=b.stateNode,k=m.getSnapshotBeforeUpdate(b.elementType===b.type?J:xh(b.type,J),S);m.__reactInternalSnapshotBeforeUpdate=k}break;case 3:0!==(C&1024)&&Ij(b.stateNode.containerInfo);break;case 5:case 26:case 27:case 6:case 4:case 17:break;default:if(0!==(C&1024))throw Error(t(163));}}catch(n){W(b,b.return,n)}a=b.sibling;if(null!==a){a.return=b.return;tj=a;break}tj=b.return}A=Bj;Bj=!1;return A}
+function Cj(a,b){Dj=Ej;a=Fj();if(Gj(a)){if("selectionStart"in a)var c={start:a.selectionStart,end:a.selectionEnd};else a:{c=(c=a.ownerDocument)&&c.defaultView||window;var d=c.getSelection&&c.getSelection();if(d&&0!==d.rangeCount){c=d.anchorNode;var e=d.anchorOffset,f=d.focusNode;d=d.focusOffset;try{c.nodeType,f.nodeType}catch(n){c=null;break a}var g=0,h=-1,l=-1,p=0,q=0,w=a,r=null;b:for(;;){for(var t;;){w!==c||0!==e&&3!==w.nodeType||(h=g+e);w!==f||0!==d&&3!==w.nodeType||(l=g+d);3===w.nodeType&&(g+=
+w.nodeValue.length);if(null===(t=w.firstChild))break;r=w;w=t}for(;;){if(w===a)break b;r===c&&++p===e&&(h=g);r===f&&++q===d&&(l=g);if(null!==(t=w.nextSibling))break;w=r;r=w.parentNode}w=t}c=-1===h||-1===l?null:{start:h,end:l}}else c=null}c=c||{start:0,end:0}}else c=null;Hj={focusedElem:a,selectionRange:c};Ej=!1;for(tj=b;null!==tj;)if(b=tj,a=b.child,0!==(b.subtreeFlags&1028)&&null!==a)a.return=b,tj=a;else for(;null!==tj;){b=tj;try{var A=b.alternate,C=b.flags;switch(b.tag){case 0:break;case 11:case 15:break;
+case 1:if(0!==(C&1024)&&null!==A){var J=A.memoizedProps,S=A.memoizedState,m=b.stateNode,k=m.getSnapshotBeforeUpdate(b.elementType===b.type?J:xh(b.type,J),S);m.__reactInternalSnapshotBeforeUpdate=k}break;case 3:0!==(C&1024)&&Ij(b.stateNode.containerInfo);break;case 5:case 26:case 27:case 6:case 4:case 17:break;default:if(0!==(C&1024))throw Error(u(163));}}catch(n){W(b,b.return,n)}a=b.sibling;if(null!==a){a.return=b.return;tj=a;break}tj=b.return}A=Bj;Bj=!1;return A}
 function Jj(a,b,c){var d=b.updateQueue;d=null!==d?d.lastEffect:null;if(null!==d){var e=d=d.next;do{if((e.tag&a)===a){var f=e.inst,g=f.destroy;void 0!==g&&(f.destroy=void 0,0!==(a&8)?null!==F&&"function"===typeof F.markComponentPassiveEffectUnmountStarted&&F.markComponentPassiveEffectUnmountStarted(b):0!==(a&4)&&jb(b),Aj(b,c,g),0!==(a&8)?null!==F&&"function"===typeof F.markComponentPassiveEffectUnmountStopped&&F.markComponentPassiveEffectUnmountStopped():0!==(a&4)&&kb())}e=e.next}while(e!==d)}}
 function Kj(a,b){var c=b.updateQueue;c=null!==c?c.lastEffect:null;if(null!==c){var d=c=c.next;do{if((d.tag&a)===a){0!==(a&8)?null!==F&&"function"===typeof F.markComponentPassiveEffectMountStarted&&F.markComponentPassiveEffectMountStarted(b):0!==(a&4)&&null!==F&&"function"===typeof F.markComponentLayoutEffectMountStarted&&F.markComponentLayoutEffectMountStarted(b);var e=d.create,f=d.inst;e=e();f.destroy=e;0!==(a&8)?null!==F&&"function"===typeof F.markComponentPassiveEffectMountStopped&&F.markComponentPassiveEffectMountStopped():
 0!==(a&4)&&null!==F&&"function"===typeof F.markComponentLayoutEffectMountStopped&&F.markComponentLayoutEffectMountStopped()}d=d.next}while(d!==c)}}function Lj(a,b){if(wj(a)){try{vh(),Kj(b,a)}catch(c){W(a,a.return,c)}th(a)}else try{Kj(b,a)}catch(c){W(a,a.return,c)}}function Mj(a){var b=a.updateQueue;if(null!==b){var c=a.stateNode;try{te(b,c)}catch(d){W(a,a.return,d)}}}
@@ -243,21 +232,21 @@ function Zj(a,b,c){var d=a.tag;if(5===d||6===d)a=a.stateNode,b?c.insertBefore(a,
 function dk(a,b,c){if(ab&&"function"===typeof ab.onCommitFiberUnmount)try{ab.onCommitFiberUnmount($a,c)}catch(l){}switch(c.tag){case 26:rj||zj(c,b);ck(a,b,c);c.memoizedState?c.memoizedState.count--:c.stateNode&&(c=c.stateNode,c.parentNode.removeChild(c));break;case 27:rj||zj(c,b);var d=ak,e=bk;ak=c.stateNode;ck(a,b,c);c=c.stateNode;for(a=c.attributes;a.length;)c.removeAttributeNode(a[0]);Ub(c);ak=d;bk=e;break;case 5:rj||zj(c,b);case 6:d=ak;e=bk;ak=null;ck(a,b,c);ak=d;bk=e;null!==ak&&(bk?(a=ak,c=c.stateNode,
 8===a.nodeType?a.parentNode.removeChild(c):a.removeChild(c)):ak.removeChild(c.stateNode));break;case 18:null!==ak&&(bk?(a=ak,c=c.stateNode,8===a.nodeType?ek(a.parentNode,c):1===a.nodeType&&ek(a,c),fk(a)):ek(ak,c.stateNode));break;case 4:d=ak;e=bk;ak=c.stateNode.containerInfo;bk=!0;ck(a,b,c);ak=d;bk=e;break;case 0:case 11:case 14:case 15:if(!rj&&(d=c.updateQueue,null!==d&&(d=d.lastEffect,null!==d))){e=d=d.next;do{var f=e.tag,g=e.inst,h=g.destroy;void 0!==h&&(0!==(f&2)?(g.destroy=void 0,Aj(c,b,h)):
 0!==(f&4)&&(jb(c),wj(c)?(vh(),g.destroy=void 0,Aj(c,b,h),th(c)):(g.destroy=void 0,Aj(c,b,h)),kb()));e=e.next}while(e!==d)}ck(a,b,c);break;case 1:if(!rj&&(zj(c,b),d=c.stateNode,"function"===typeof d.componentWillUnmount))try{xj(c,d)}catch(l){W(c,b,l)}ck(a,b,c);break;case 21:ck(a,b,c);break;case 22:zj(c,b);c.mode&1?(rj=(d=rj)||null!==c.memoizedState,ck(a,b,c),rj=d):ck(a,b,c);break;default:ck(a,b,c)}}
-function Sj(a,b){if(null===b.memoizedState&&(a=b.alternate,null!==a&&(a=a.memoizedState,null!==a&&(a=a.dehydrated,null!==a))))try{fk(a)}catch(c){W(b,b.return,c)}}function gk(a){switch(a.tag){case 13:case 19:var b=a.stateNode;null===b&&(b=a.stateNode=new sj);return b;case 22:return a=a.stateNode,b=a._retryCache,null===b&&(b=a._retryCache=new sj),b;default:throw Error(t(435,a.tag));}}
-function hk(a,b){var c=gk(a);b.forEach(function(d){var e=ik.bind(null,a,d);if(!c.has(d)){c.add(d);if(bb)if(null!==uj&&null!==vj)Oh(vj,uj);else throw Error(t(413));d.then(e,e)}})}function jk(a,b,c){uj=c;vj=a;kk(b,a);vj=uj=null}
-function lk(a,b){var c=b.deletions;if(null!==c)for(var d=0;d<c.length;d++){var e=c[d];try{var f=a,g=b,h=g;a:for(;null!==h;){switch(h.tag){case 27:case 5:ak=h.stateNode;bk=!1;break a;case 3:ak=h.stateNode.containerInfo;bk=!0;break a;case 4:ak=h.stateNode.containerInfo;bk=!0;break a}h=h.return}if(null===ak)throw Error(t(160));dk(f,g,e);ak=null;bk=!1;var l=e.alternate;null!==l&&(l.return=null);e.return=null}catch(p){W(e,b,p)}}if(b.subtreeFlags&12854)for(b=b.child;null!==b;)kk(b,a),b=b.sibling}
+function Sj(a,b){if(null===b.memoizedState&&(a=b.alternate,null!==a&&(a=a.memoizedState,null!==a&&(a=a.dehydrated,null!==a))))try{fk(a)}catch(c){W(b,b.return,c)}}function gk(a){switch(a.tag){case 13:case 19:var b=a.stateNode;null===b&&(b=a.stateNode=new sj);return b;case 22:return a=a.stateNode,b=a._retryCache,null===b&&(b=a._retryCache=new sj),b;default:throw Error(u(435,a.tag));}}
+function hk(a,b){var c=gk(a);b.forEach(function(d){var e=ik.bind(null,a,d);if(!c.has(d)){c.add(d);if(bb)if(null!==uj&&null!==vj)Oh(vj,uj);else throw Error(u(413));d.then(e,e)}})}function jk(a,b,c){uj=c;vj=a;kk(b,a);vj=uj=null}
+function lk(a,b){var c=b.deletions;if(null!==c)for(var d=0;d<c.length;d++){var e=c[d];try{var f=a,g=b,h=g;a:for(;null!==h;){switch(h.tag){case 27:case 5:ak=h.stateNode;bk=!1;break a;case 3:ak=h.stateNode.containerInfo;bk=!0;break a;case 4:ak=h.stateNode.containerInfo;bk=!0;break a}h=h.return}if(null===ak)throw Error(u(160));dk(f,g,e);ak=null;bk=!1;var l=e.alternate;null!==l&&(l.return=null);e.return=null}catch(p){W(e,b,p)}}if(b.subtreeFlags&12854)for(b=b.child;null!==b;)kk(b,a),b=b.sibling}
 var mk=null;
-function kk(a,b){var c=a.alternate,d=a.flags;switch(a.tag){case 0:case 11:case 14:case 15:lk(b,a);nk(a);if(d&4){try{Jj(3,a,a.return),Kj(3,a)}catch(u){W(a,a.return,u)}if(wj(a)){try{vh(),Jj(5,a,a.return)}catch(u){W(a,a.return,u)}th(a)}else try{Jj(5,a,a.return)}catch(u){W(a,a.return,u)}}break;case 1:lk(b,a);nk(a);d&512&&null!==c&&zj(c,c.return);d&64&&qj&&(a=a.updateQueue,null!==a&&(c=a.callbacks,null!==c&&(d=a.shared.hiddenCallbacks,a.shared.hiddenCallbacks=null===d?c:d.concat(c))));break;case 26:var e=
+function kk(a,b){var c=a.alternate,d=a.flags;switch(a.tag){case 0:case 11:case 14:case 15:lk(b,a);nk(a);if(d&4){try{Jj(3,a,a.return),Kj(3,a)}catch(t){W(a,a.return,t)}if(wj(a)){try{vh(),Jj(5,a,a.return)}catch(t){W(a,a.return,t)}th(a)}else try{Jj(5,a,a.return)}catch(t){W(a,a.return,t)}}break;case 1:lk(b,a);nk(a);d&512&&null!==c&&zj(c,c.return);d&64&&qj&&(a=a.updateQueue,null!==a&&(c=a.callbacks,null!==c&&(d=a.shared.hiddenCallbacks,a.shared.hiddenCallbacks=null===d?c:d.concat(c))));break;case 26:var e=
 mk;lk(b,a);nk(a);d&512&&null!==c&&zj(c,c.return);if(d&4)if(b=null!==c?c.memoizedState:null,d=a.memoizedState,null===c)if(null===d)if(null===a.stateNode){a:{c=a.type;d=a.memoizedProps;b=e.ownerDocument||e;b:switch(c){case "title":e=b.getElementsByTagName("title")[0];if(!e||e[Tb]||e[Mb]||"http://www.w3.org/2000/svg"===e.namespaceURI||e.hasAttribute("itemprop"))e=b.createElement(c),b.head.insertBefore(e,b.querySelector("head > title"));bj(e,c,d);e[Mb]=a;ac(e);c=e;break a;case "link":var f=ok("link",
 "href",b).get(c+(d.href||""));if(f)for(var g=0;g<f.length;g++)if(e=f[g],e.getAttribute("href")===(null==d.href?null:d.href)&&e.getAttribute("rel")===(null==d.rel?null:d.rel)&&e.getAttribute("title")===(null==d.title?null:d.title)&&e.getAttribute("crossorigin")===(null==d.crossOrigin?null:d.crossOrigin)){f.splice(g,1);break b}e=b.createElement(c);bj(e,c,d);b.head.appendChild(e);break;case "meta":if(f=ok("meta","content",b).get(c+(d.content||"")))for(g=0;g<f.length;g++)if(e=f[g],e.getAttribute("content")===
-(null==d.content?null:""+d.content)&&e.getAttribute("name")===(null==d.name?null:d.name)&&e.getAttribute("property")===(null==d.property?null:d.property)&&e.getAttribute("http-equiv")===(null==d.httpEquiv?null:d.httpEquiv)&&e.getAttribute("charset")===(null==d.charSet?null:d.charSet)){f.splice(g,1);break b}e=b.createElement(c);bj(e,c,d);b.head.appendChild(e);break;default:throw Error(t(468,c));}e[Mb]=a;ac(e);c=e}a.stateNode=c}else pk(e,a.type,a.stateNode);else a.stateNode=qk(e,d,a.memoizedProps);
-else if(b!==d)null===b?null!==c.stateNode&&(c=c.stateNode,c.parentNode.removeChild(c)):b.count--,null===d?pk(e,a.type,a.stateNode):qk(e,d,a.memoizedProps);else if(null===d&&null!==a.stateNode){a.updateQueue=null;try{var h=a.stateNode,l=a.memoizedProps;rk(h,a.type,c.memoizedProps,l);h[Nb]=l}catch(u){W(a,a.return,u)}}break;case 27:if(d&4&&null===a.alternate){e=a.stateNode;f=a.memoizedProps;for(g=e.firstChild;g;){var p=g.nextSibling,q=g.nodeName;g[Tb]||"HEAD"===q||"BODY"===q||"SCRIPT"===q||"STYLE"===
-q||"LINK"===q&&"stylesheet"===g.rel.toLowerCase()||e.removeChild(g);g=p}g=a.type;for(p=e.attributes;p.length;)e.removeAttributeNode(p[0]);bj(e,g,f);e[Mb]=a;e[Nb]=f}case 5:lk(b,a);nk(a);d&512&&null!==c&&zj(c,c.return);if(a.flags&32){b=a.stateNode;try{Nc(b,"")}catch(u){W(a,a.return,u)}}if(d&4&&(d=a.stateNode,null!=d)){b=a.memoizedProps;c=null!==c?c.memoizedProps:b;e=a.type;a.updateQueue=null;try{rk(d,e,c,b),d[Nb]=b}catch(u){W(a,a.return,u)}}break;case 6:lk(b,a);nk(a);if(d&4){if(null===a.stateNode)throw Error(t(162));
-c=a.stateNode;d=a.memoizedProps;try{c.nodeValue=d}catch(u){W(a,a.return,u)}}break;case 3:sk=null;e=mk;mk=tk(b.containerInfo);lk(b,a);mk=e;nk(a);if(d&4&&null!==c&&c.memoizedState.isDehydrated)try{fk(b.containerInfo)}catch(u){W(a,a.return,u)}break;case 4:c=mk;mk=tk(a.stateNode.containerInfo);lk(b,a);nk(a);mk=c;break;case 13:lk(b,a);nk(a);a.child.flags&8192&&null!==a.memoizedState!==(null!==c&&null!==c.memoizedState)&&(uk=Ta());d&4&&(c=a.updateQueue,null!==c&&(a.updateQueue=null,hk(a,c)));break;case 22:d&
-512&&null!==c&&zj(c,c.return);h=null!==a.memoizedState;l=null!==c&&null!==c.memoizedState;if(a.mode&1){var x=qj,r=rj;qj=x||h;rj=r||l;lk(b,a);rj=r;qj=x}else lk(b,a);nk(a);b=a.stateNode;b._current=a;b._visibility&=-3;b._visibility|=b._pendingVisibility&2;if(d&8192&&(b._visibility=h?b._visibility&-2:b._visibility|1,h&&(b=qj||rj,null===c||l||b||0!==(a.mode&1)&&vk(a)),null===a.memoizedProps||"manual"!==a.memoizedProps.mode))a:for(c=null,b=a;;){if(5===b.tag||26===b.tag||27===b.tag){if(null===c){c=b;try{e=
-b.stateNode,h?(f=e.style,"function"===typeof f.setProperty?f.setProperty("display","none","important"):f.display="none"):(g=b.stateNode,p=b.memoizedProps.style,q=void 0!==p&&null!==p&&p.hasOwnProperty("display")?p.display:null,g.style.display=null==q||"boolean"===typeof q?"":(""+q).trim())}catch(u){W(a,a.return,u)}}}else if(6===b.tag){if(null===c)try{b.stateNode.nodeValue=h?"":b.memoizedProps}catch(u){W(a,a.return,u)}}else if((22!==b.tag&&23!==b.tag||null===b.memoizedState||b===a)&&null!==b.child){b.child.return=
+(null==d.content?null:""+d.content)&&e.getAttribute("name")===(null==d.name?null:d.name)&&e.getAttribute("property")===(null==d.property?null:d.property)&&e.getAttribute("http-equiv")===(null==d.httpEquiv?null:d.httpEquiv)&&e.getAttribute("charset")===(null==d.charSet?null:d.charSet)){f.splice(g,1);break b}e=b.createElement(c);bj(e,c,d);b.head.appendChild(e);break;default:throw Error(u(468,c));}e[Mb]=a;ac(e);c=e}a.stateNode=c}else pk(e,a.type,a.stateNode);else a.stateNode=qk(e,d,a.memoizedProps);
+else if(b!==d)null===b?null!==c.stateNode&&(c=c.stateNode,c.parentNode.removeChild(c)):b.count--,null===d?pk(e,a.type,a.stateNode):qk(e,d,a.memoizedProps);else if(null===d&&null!==a.stateNode){a.updateQueue=null;try{var h=a.stateNode,l=a.memoizedProps;rk(h,a.type,c.memoizedProps,l);h[Nb]=l}catch(t){W(a,a.return,t)}}break;case 27:if(d&4&&null===a.alternate){e=a.stateNode;f=a.memoizedProps;for(g=e.firstChild;g;){var p=g.nextSibling,q=g.nodeName;g[Tb]||"HEAD"===q||"BODY"===q||"SCRIPT"===q||"STYLE"===
+q||"LINK"===q&&"stylesheet"===g.rel.toLowerCase()||e.removeChild(g);g=p}g=a.type;for(p=e.attributes;p.length;)e.removeAttributeNode(p[0]);bj(e,g,f);e[Mb]=a;e[Nb]=f}case 5:lk(b,a);nk(a);d&512&&null!==c&&zj(c,c.return);if(a.flags&32){b=a.stateNode;try{Nc(b,"")}catch(t){W(a,a.return,t)}}if(d&4&&(d=a.stateNode,null!=d)){b=a.memoizedProps;c=null!==c?c.memoizedProps:b;e=a.type;a.updateQueue=null;try{rk(d,e,c,b),d[Nb]=b}catch(t){W(a,a.return,t)}}break;case 6:lk(b,a);nk(a);if(d&4){if(null===a.stateNode)throw Error(u(162));
+c=a.stateNode;d=a.memoizedProps;try{c.nodeValue=d}catch(t){W(a,a.return,t)}}break;case 3:sk=null;e=mk;mk=tk(b.containerInfo);lk(b,a);mk=e;nk(a);if(d&4&&null!==c&&c.memoizedState.isDehydrated)try{fk(b.containerInfo)}catch(t){W(a,a.return,t)}break;case 4:c=mk;mk=tk(a.stateNode.containerInfo);lk(b,a);nk(a);mk=c;break;case 13:lk(b,a);nk(a);a.child.flags&8192&&null!==a.memoizedState!==(null!==c&&null!==c.memoizedState)&&(uk=Ta());d&4&&(c=a.updateQueue,null!==c&&(a.updateQueue=null,hk(a,c)));break;case 22:d&
+512&&null!==c&&zj(c,c.return);h=null!==a.memoizedState;l=null!==c&&null!==c.memoizedState;if(a.mode&1){var w=qj,r=rj;qj=w||h;rj=r||l;lk(b,a);rj=r;qj=w}else lk(b,a);nk(a);b=a.stateNode;b._current=a;b._visibility&=-3;b._visibility|=b._pendingVisibility&2;if(d&8192&&(b._visibility=h?b._visibility&-2:b._visibility|1,h&&(b=qj||rj,null===c||l||b||0!==(a.mode&1)&&vk(a)),null===a.memoizedProps||"manual"!==a.memoizedProps.mode))a:for(c=null,b=a;;){if(5===b.tag||26===b.tag||27===b.tag){if(null===c){c=b;try{e=
+b.stateNode,h?(f=e.style,"function"===typeof f.setProperty?f.setProperty("display","none","important"):f.display="none"):(g=b.stateNode,p=b.memoizedProps.style,q=void 0!==p&&null!==p&&p.hasOwnProperty("display")?p.display:null,g.style.display=null==q||"boolean"===typeof q?"":(""+q).trim())}catch(t){W(a,a.return,t)}}}else if(6===b.tag){if(null===c)try{b.stateNode.nodeValue=h?"":b.memoizedProps}catch(t){W(a,a.return,t)}}else if((22!==b.tag&&23!==b.tag||null===b.memoizedState||b===a)&&null!==b.child){b.child.return=
 b;b=b.child;continue}if(b===a)break a;for(;null===b.sibling;){if(null===b.return||b.return===a)break a;c===b&&(c=null);b=b.return}c===b&&(c=null);b.sibling.return=b.return;b=b.sibling}d&4&&(c=a.updateQueue,null!==c&&(d=c.retryQueue,null!==d&&(c.retryQueue=null,hk(a,d))));break;case 19:lk(b,a);nk(a);d&4&&(c=a.updateQueue,null!==c&&(a.updateQueue=null,hk(a,c)));break;case 21:break;default:lk(b,a),nk(a)}}
-function nk(a){var b=a.flags;if(b&2){try{if(27!==a.tag){b:{for(var c=a.return;null!==c;){if(Vj(c)){var d=c;break b}c=c.return}throw Error(t(160));}switch(d.tag){case 27:var e=d.stateNode,f=Wj(a);Zj(a,f,e);break;case 5:var g=d.stateNode;d.flags&32&&(Nc(g,""),d.flags&=-33);var h=Wj(a);Zj(a,h,g);break;case 3:case 4:var l=d.stateNode.containerInfo,p=Wj(a);Xj(a,p,l);break;default:throw Error(t(161));}}}catch(q){W(a,a.return,q)}a.flags&=-3}b&4096&&(a.flags&=-4097)}
+function nk(a){var b=a.flags;if(b&2){try{if(27!==a.tag){b:{for(var c=a.return;null!==c;){if(Vj(c)){var d=c;break b}c=c.return}throw Error(u(160));}switch(d.tag){case 27:var e=d.stateNode,f=Wj(a);Zj(a,f,e);break;case 5:var g=d.stateNode;d.flags&32&&(Nc(g,""),d.flags&=-33);var h=Wj(a);Zj(a,h,g);break;case 3:case 4:var l=d.stateNode.containerInfo,p=Wj(a);Xj(a,p,l);break;default:throw Error(u(161));}}}catch(q){W(a,a.return,q)}a.flags&=-3}b&4096&&(a.flags&=-4097)}
 function wk(a,b,c){uj=c;vj=b;Qj(b,a.alternate,a);vj=uj=null}function Rj(a,b){if(b.subtreeFlags&8772)for(b=b.child;null!==b;)Qj(a,b.alternate,b),b=b.sibling}
 function vk(a){for(a=a.child;null!==a;){var b=a;switch(b.tag){case 0:case 11:case 14:case 15:if(wj(b))try{vh(),Jj(4,b,b.return)}finally{th(b)}else Jj(4,b,b.return);vk(b);break;case 1:zj(b,b.return);var c=b.stateNode;if("function"===typeof c.componentWillUnmount){var d=b,e=b.return;try{xj(d,c)}catch(f){W(d,e,f)}}vk(b);break;case 26:case 27:case 5:zj(b,b.return);vk(b);break;case 22:zj(b,b.return);null===b.memoizedState&&vk(b);break;default:vk(b)}a=a.sibling}}
 function Tj(a,b,c){c=c&&0!==(b.subtreeFlags&8772);for(b=b.child;null!==b;){var d=b.alternate,e=a,f=b,g=f.flags;switch(f.tag){case 0:case 11:case 15:Tj(e,f,c);Lj(f,4);break;case 1:Tj(e,f,c);e=f.stateNode;if("function"===typeof e.componentDidMount)try{e.componentDidMount()}catch(l){W(f,f.return,l)}d=f.updateQueue;if(null!==d){var h=d.shared.hiddenCallbacks;if(null!==h)for(d.shared.hiddenCallbacks=null,d=0;d<h.length;d++)se(h[d],e)}c&&g&64&&Mj(f);yj(f,f.return);break;case 26:case 27:case 5:Tj(e,f,c);
@@ -275,8 +264,8 @@ function Nk(a){var b=a.deletions;if(0!==(a.flags&16)){if(null!==b)for(var c=0;c<
 function Lk(a,b){for(;null!==tj;){var c=tj;switch(c.tag){case 0:case 11:case 15:Jk(c,b,8);break;case 23:case 22:if(null!==c.memoizedState&&null!==c.memoizedState.cachePool){var d=c.memoizedState.cachePool.pool;null!=d&&d.refCount++}break;case 24:Oi(c.memoizedState.cache)}d=c.child;if(null!==d)d.return=c,tj=d;else a:for(c=a;null!==tj;){d=tj;var e=d.sibling,f=d.return;Uj(d);if(d===c){tj=null;break a}if(null!==e){e.return=f;tj=e;break a}tj=f}}}
 var Ok={getCacheSignal:function(){return qg(hi).controller.signal},getCacheForType:function(a){var b=qg(hi),c=b.data.get(a);void 0===c&&(c=a(),b.data.set(a,c));return c}},Pk="function"===typeof WeakMap?WeakMap:Map,Qk=da.ReactCurrentDispatcher,Rk=da.ReactCurrentCache,Sk=da.ReactCurrentOwner,Tk=da.ReactCurrentBatchConfig,N=0,P=null,X=null,O=0,Q=0,Uk=null,Vk=!1,Ve=0,Qh=0,vf=null,re=0,Wk=0,Xk=0,Bf=0,Sh=null,zf=null,uk=0,fj=Infinity,Af=null,Ih=!1,Jh=null,Lh=null,Yk=!1,Zk=null,$k=0,al=[],bl=0,cl=null,he=
 0,ie=null;function hh(a){if(0===(a.mode&1))return 2;if(0!==(N&2)&&0!==O)return O&-O;if(null!==Pi.transition)return a=Kf,0!==a?a:Hf();a=G;if(0!==a)return a;a=window.event;a=void 0===a?32:dl(a.type);return a}function Eg(a,b,c){if(a===P&&2===Q||null!==a.cancelPendingCommit)wf(a,0),xf(a,O,Bf);Ab(a,c);if(0===(N&2)||a!==P)bb&&Fb(a,b,c),a===P&&(0===(N&2)&&(Wk|=c),4===Qh&&xf(a,O,Bf)),mf(a),2===c&&0===N&&0===(b.mode&1)&&(fj=Ta()+500,pf(!0))}
-function Ff(a,b){sf=rf=!1;if(0!==(N&6))throw Error(t(327));var c=a.callbackNode;if(qf()&&a.callbackNode!==c)return null;var d=vb(a,a===P?O:0);if(0===d)return null;var e=0===(d&60)&&0===(d&a.expiredLanes)&&!b;b=e?el(a,d):tf(a,d);if(0!==b){var f=e;do{if(6===b)xf(a,d,0);else{e=a.current.alternate;if(f&&!fl(e)){b=tf(a,d);f=!1;continue}if(2===b){f=d;var g=xb(a,f);0!==g&&(d=g,b=uf(a,f,g))}if(1===b)throw c=vf,wf(a,0),xf(a,d,0),mf(a),c;a.finishedWork=e;a.finishedLanes=d;a:{f=a;switch(b){case 0:case 1:throw Error(t(345));
-case 4:if((d&4194176)===d){xf(f,d,Bf);break a}break;case 2:case 3:case 5:break;default:throw Error(t(329));}if((d&62914560)===d&&(b=uk+300-Ta(),10<b)){xf(f,d,Bf);if(0!==vb(f,0))break a;f.timeoutHandle=gl(hl.bind(null,f,e,zf,Af,d,Bf),b);break a}hl(f,e,zf,Af,d,Bf)}}break}while(1)}mf(a);Ef(a,Ta());a=a.callbackNode===c?Ff.bind(null,a):null;return a}
+function Ff(a,b){sf=rf=!1;if(0!==(N&6))throw Error(u(327));var c=a.callbackNode;if(qf()&&a.callbackNode!==c)return null;var d=vb(a,a===P?O:0);if(0===d)return null;var e=0===(d&60)&&0===(d&a.expiredLanes)&&!b;b=e?el(a,d):tf(a,d);if(0!==b){var f=e;do{if(6===b)xf(a,d,0);else{e=a.current.alternate;if(f&&!fl(e)){b=tf(a,d);f=!1;continue}if(2===b){f=d;var g=xb(a,f);0!==g&&(d=g,b=uf(a,f,g))}if(1===b)throw c=vf,wf(a,0),xf(a,d,0),mf(a),c;a.finishedWork=e;a.finishedLanes=d;a:{f=a;switch(b){case 0:case 1:throw Error(u(345));
+case 4:if((d&4194176)===d){xf(f,d,Bf);break a}break;case 2:case 3:case 5:break;default:throw Error(u(329));}if((d&62914560)===d&&(b=uk+300-Ta(),10<b)){xf(f,d,Bf);if(0!==vb(f,0))break a;f.timeoutHandle=gl(hl.bind(null,f,e,zf,Af,d,Bf),b);break a}hl(f,e,zf,Af,d,Bf)}}break}while(1)}mf(a);Ef(a,Ta());a=a.callbackNode===c?Ff.bind(null,a):null;return a}
 function uf(a,b,c){var d=Sh,e=a.current.memoizedState.isDehydrated;e&&(wf(a,c).flags|=256);c=tf(a,c);if(2!==c){if(Vk&&!e)return a.errorRecoveryDisabledLanes|=b,Wk|=b,4;a=zf;zf=d;null!==a&&Yi(a)}return c}function Yi(a){null===zf?zf=a:zf.push.apply(zf,a)}function hl(a,b,c,d,e,f){if(0===(e&42)&&(il={stylesheets:null,count:0,unsuspend:jl},Gk(b),b=kl(),null!==b)){a.cancelPendingCommit=b(yf.bind(null,a,c,d));xf(a,e,f);return}yf(a,c,d,f)}
 function fl(a){for(var b=a;;){if(b.flags&16384){var c=b.updateQueue;if(null!==c&&(c=c.stores,null!==c))for(var d=0;d<c.length;d++){var e=c[d],f=e.getSnapshot;e=e.value;try{if(!rd(f(),e))return!1}catch(g){return!1}}}c=b.child;if(b.subtreeFlags&16384&&null!==c)c.return=b,b=c;else{if(b===a)break;for(;null===b.sibling;){if(null===b.return||b.return===a)return!0;b=b.return}b.sibling.return=b.return;b=b.sibling}}return!0}
 function xf(a,b,c){b&=~Xk;b&=~Wk;a.suspendedLanes|=b;a.pingedLanes&=~b;for(var d=a.expirationTimes,e=b;0<e;){var f=31-pb(e),g=1<<f;d[f]=-1;e&=~g}0!==c&&Cb(a,c,b)}function ll(a,b){var c=N;N|=1;try{return a(b)}finally{N=c,0===N&&(fj=Ta()+500,pf(!0))}}function ml(a){null!==Zk&&0===Zk.tag&&0===(N&6)&&qf();var b=N;N|=1;var c=Tk.transition,d=G;try{if(Tk.transition=null,G=2,a)return a()}finally{G=d,Tk.transition=c,N=b,0===(N&6)&&pf(!1)}}
@@ -284,32 +273,32 @@ function nl(){if(null!==X){if(0===Q)var a=X.return;else a=X,Hi(),lg(a),De=null,E
 function wf(a,b){a.finishedWork=null;a.finishedLanes=0;var c=a.timeoutHandle;-1!==c&&(a.timeoutHandle=-1,ol(c));c=a.cancelPendingCommit;null!==c&&(a.cancelPendingCommit=null,c());nl();P=a;X=c=Ke(a.current,null);O=b;Q=0;Uk=null;Vk=!1;Qh=0;vf=null;Bf=Xk=Wk=re=0;zf=Sh=null;0!==(b&8)&&(b|=b&32);var d=a.entangledLanes;if(0!==d)for(a=a.entanglements,d&=b;0<d;){var e=31-pb(d),f=1<<e;b|=a[e];d&=~f}Ve=b;be();return c}
 function pl(a,b){R=null;Pf.current=fg;Sk.current=null;b===ve?(b=Ce(),Q=Ui()&&0===(re&134217727)&&0===(Wk&134217727)?2:3):b===we?(b=Ce(),Q=4):Q=b===Uh?8:null!==b&&"object"===typeof b&&"function"===typeof b.then?6:1;Uk=b;a=X;if(null===a)Qh=1,vf=b;else switch(a.mode&2&&sh(a,!0),ib(),Q){case 1:null!==F&&"function"===typeof F.markComponentErrored&&F.markComponentErrored(a,b,O);break;case 2:case 3:case 6:case 7:null!==F&&"function"===typeof F.markComponentSuspended&&F.markComponentSuspended(a,b,O)}}
 function Ui(){var a=Ye.current;return null===a?!0:(O&4194176)===O?null===Ze?!0:!1:(O&62914560)===O||0!==(O&536870912)?a===Ze:!1}function ql(){var a=Qk.current;Qk.current=fg;return null===a?fg:a}function rl(){var a=Rk.current;Rk.current=Ok;return a}function Ph(){Qh=4;0===(re&134217727)&&0===(Wk&134217727)||null===P||xf(P,O,Bf)}
-function tf(a,b){var c=N;N|=2;var d=ql(),e=rl();if(P!==a||O!==b){if(bb){var f=a.memoizedUpdaters;0<f.size&&(Oh(a,O),f.clear());Gb(a,b)}Af=null;wf(a,b)}lb(b);b=!1;a:do try{if(0!==Q&&null!==X){f=X;var g=Uk;switch(Q){case 8:nl();Qh=6;break a;case 3:case 2:b||null!==Ye.current||(b=!0);default:Q=0,Uk=null,sl(f,g)}}tl();break}catch(h){pl(a,h)}while(1);b&&a.shellSuspendCounter++;Hi();N=c;Qk.current=d;Rk.current=e;if(null!==X)throw Error(t(261));mb();P=null;O=0;be();return Qh}
+function tf(a,b){var c=N;N|=2;var d=ql(),e=rl();if(P!==a||O!==b){if(bb){var f=a.memoizedUpdaters;0<f.size&&(Oh(a,O),f.clear());Gb(a,b)}Af=null;wf(a,b)}lb(b);b=!1;a:do try{if(0!==Q&&null!==X){f=X;var g=Uk;switch(Q){case 8:nl();Qh=6;break a;case 3:case 2:b||null!==Ye.current||(b=!0);default:Q=0,Uk=null,sl(f,g)}}tl();break}catch(h){pl(a,h)}while(1);b&&a.shellSuspendCounter++;Hi();N=c;Qk.current=d;Rk.current=e;if(null!==X)throw Error(u(261));mb();P=null;O=0;be();return Qh}
 function tl(){for(;null!==X;)ul(X)}
 function el(a,b){var c=N;N|=2;var d=ql(),e=rl();if(P!==a||O!==b){if(bb){var f=a.memoizedUpdaters;0<f.size&&(Oh(a,O),f.clear());Gb(a,b)}Af=null;fj=Ta()+500;wf(a,b)}lb(b);a:do try{if(0!==Q&&null!==X)b:switch(b=X,f=Uk,Q){case 1:Q=0;Uk=null;sl(b,f);break;case 2:if(ye(f)){Q=0;Uk=null;vl(b);break}b=function(){2===Q&&P===a&&(Q=7);mf(a)};f.then(b,b);break a;case 3:Q=7;break a;case 4:Q=5;break a;case 7:ye(f)?(Q=0,Uk=null,vl(b)):(Q=0,Uk=null,sl(b,f));break;case 5:switch(X.tag){case 5:case 26:case 27:b=X;Q=
-0;Uk=null;var g=b.sibling;if(null!==g)X=g;else{var h=b.return;null!==h?(X=h,wl(h)):X=null}break b}Q=0;Uk=null;sl(b,f);break;case 6:Q=0;Uk=null;sl(b,f);break;case 8:nl();Qh=6;break a;default:throw Error(t(462));}xl();break}catch(l){pl(a,l)}while(1);Hi();Qk.current=d;Rk.current=e;N=c;if(null!==X)return null!==F&&"function"===typeof F.markRenderYielded&&F.markRenderYielded(),0;mb();P=null;O=0;be();return Qh}function xl(){for(;null!==X&&!Ra();)ul(X)}
+0;Uk=null;var g=b.sibling;if(null!==g)X=g;else{var h=b.return;null!==h?(X=h,wl(h)):X=null}break b}Q=0;Uk=null;sl(b,f);break;case 6:Q=0;Uk=null;sl(b,f);break;case 8:nl();Qh=6;break a;default:throw Error(u(462));}xl();break}catch(l){pl(a,l)}while(1);Hi();Qk.current=d;Rk.current=e;N=c;if(null!==X)return null!==F&&"function"===typeof F.markRenderYielded&&F.markRenderYielded(),0;mb();P=null;O=0;be();return Qh}function xl(){for(;null!==X&&!Ra();)ul(X)}
 function ul(a){var b=a.alternate;0!==(a.mode&2)?(rh(a),b=yl(b,a,Ve),sh(a,!0)):b=yl(b,a,Ve);a.memoizedProps=a.pendingProps;null===b?wl(a):X=b;Sk.current=null}
 function vl(a){var b=a.alternate,c=0!==(a.mode&2);c&&rh(a);switch(a.tag){case 2:a.tag=0;case 15:case 0:var d=a.type,e=a.pendingProps;e=a.elementType===d?e:xh(d,e);var f=kd(d)?id:gd.current;f=jd(a,f);b=ii(b,a,e,d,f,O);break;case 11:d=a.type.render;e=a.pendingProps;e=a.elementType===d?e:xh(d,e);b=ii(b,a,e,d,a.ref,O);break;case 5:lg(a);default:hj(b,a),a=X=ej(a,Ve),b=yl(b,a,Ve)}c&&sh(a,!0);a.memoizedProps=a.pendingProps;null===b?wl(a):X=b;Sk.current=null}
 function sl(a,b){Hi();lg(a);De=null;Ee=0;var c=a.return;if(null===c||null===P)Qh=1,vf=b,X=null;else{try{Nh(P,c,a,b,O)}catch(d){throw X=c,d;}if(a.flags&32768)a:{do{b=gj(a.alternate,a);if(null!==b){b.flags&=32767;X=b;break a}if(0!==(a.mode&2)){sh(a,!1);b=a.actualDuration;for(c=a.child;null!==c;)b+=c.actualDuration,c=c.sibling;a.actualDuration=b}a=a.return;null!==a&&(a.flags|=32768,a.subtreeFlags=0,a.deletions=null);X=a}while(null!==a);Qh=6;X=null}else wl(a)}}
 function wl(a){var b=a;do{var c=b.alternate;a=b.return;0===(b.mode&2)?c=Xi(c,b,Ve):(rh(b),c=Xi(c,b,Ve),sh(b,!1));if(null!==c){X=c;return}b=b.sibling;if(null!==b){X=b;return}X=b=a}while(null!==b);0===Qh&&(Qh=5)}function yf(a,b,c,d){var e=G,f=Tk.transition;try{Tk.transition=null,G=2,zl(a,b,c,e,d)}finally{Tk.transition=f,G=e}return null}
-function zl(a,b,c,d,e){do qf();while(null!==Zk);if(0!==(N&6))throw Error(t(327));var f=a.finishedWork,g=a.finishedLanes;null!==F&&"function"===typeof F.markCommitStarted&&F.markCommitStarted(g);if(null===f)return gb(),null;a.finishedWork=null;a.finishedLanes=0;if(f===a.current)throw Error(t(177));a.callbackNode=null;a.callbackPriority=0;a.cancelPendingCommit=null;var h=f.lanes|f.childLanes;h|=ae;Bb(a,h,e);a===P&&(X=P=null,O=0);0===(f.subtreeFlags&10256)&&0===(f.flags&10256)||Yk||(Yk=!0,bl=h,cl=c,
+function zl(a,b,c,d,e){do qf();while(null!==Zk);if(0!==(N&6))throw Error(u(327));var f=a.finishedWork,g=a.finishedLanes;null!==F&&"function"===typeof F.markCommitStarted&&F.markCommitStarted(g);if(null===f)return gb(),null;a.finishedWork=null;a.finishedLanes=0;if(f===a.current)throw Error(u(177));a.callbackNode=null;a.callbackPriority=0;a.cancelPendingCommit=null;var h=f.lanes|f.childLanes;h|=ae;Bb(a,h,e);a===P&&(X=P=null,O=0);0===(f.subtreeFlags&10256)&&0===(f.flags&10256)||Yk||(Yk=!0,bl=h,cl=c,
 Al(Xa,function(){qf();return null}));c=0!==(f.flags&15990);if(0!==(f.subtreeFlags&15990)||c){c=Tk.transition;Tk.transition=null;e=G;G=2;var l=N;N|=4;Sk.current=null;Cj(a,f);nh=mh();jk(a,f,g);Bl(Hj);Ej=!!Dj;Hj=Dj=null;a.current=f;null!==F&&"function"===typeof F.markLayoutEffectsStarted&&F.markLayoutEffectsStarted(g);wk(f,a,g);null!==F&&"function"===typeof F.markLayoutEffectsStopped&&F.markLayoutEffectsStopped();Sa();N=l;G=e;Tk.transition=c}else a.current=f,nh=mh();Yk?(Yk=!1,Zk=a,$k=g):Cl(a,h);h=a.pendingLanes;
-0===h&&(Lh=null);cb(f.stateNode,d);bb&&a.memoizedUpdaters.clear();mf(a);if(null!==b)for(d=a.onRecoverableError,f=0;f<b.length;f++)h=b[f],c={digest:h.digest,componentStack:h.stack},d(h.value,c);if(Ih)throw Ih=!1,a=Jh,Jh=null,a;0!==($k&3)&&0!==a.tag&&qf();h=a.pendingLanes;0!==(g&4194218)&&0!==(h&2)?(sf=!0,a===ie?he++:(he=0,ie=a)):he=0;pf(!1);gb();return null}function Cl(a,b){0===(a.pooledCacheLanes&=b)&&(b=a.pooledCache,null!=b&&(a.pooledCache=null,Oi(b)))}
-function qf(){if(null!==Zk){var a=Zk,b=bl;bl=0;var c=Ib($k),d=32>c?32:c;c=Tk.transition;var e=G;try{Tk.transition=null;G=d;if(null===Zk)var f=!1;else{var g=cl;cl=null;d=Zk;var h=$k;Zk=null;$k=0;if(0!==(N&6))throw Error(t(331));null!==F&&"function"===typeof F.markPassiveEffectsStarted&&F.markPassiveEffectsStarted(h);var l=N;N|=4;Mk(d.current);Bk(d,d.current,h,g);g=al;al=[];for(h=0;h<g.length;h++){var p=g[h];if(N&4&&0!==(p.flags&4))switch(p.tag){case 12:var q=p.stateNode.passiveEffectDuration,x=p.memoizedProps,
-r=x.id,u=x.onPostCommit,A=nh,C=null===p.alternate?"mount":"update";rf&&(C="nested-update");"function"===typeof u&&u(r,C,q,A);var J=p.return;b:for(;null!==J;){switch(J.tag){case 3:J.stateNode.passiveEffectDuration+=q;break b;case 12:J.stateNode.passiveEffectDuration+=q;break b}J=J.return}}}null!==F&&"function"===typeof F.markPassiveEffectsStopped&&F.markPassiveEffectsStopped();N=l;pf(!1);if(ab&&"function"===typeof ab.onPostCommitFiberRoot)try{ab.onPostCommitFiberRoot($a,d)}catch(m){}var S=d.current.stateNode;
+0===h&&(Lh=null);cb(f.stateNode,d);bb&&a.memoizedUpdaters.clear();mf(a);if(null!==b)for(d=a.onRecoverableError,f=0;f<b.length;f++)h=b[f],c={digest:h.digest,componentStack:h.stack},d(h.value,c);if(Ih)throw Ih=!1,a=Jh,Jh=null,a;0!==($k&3)&&0!==a.tag&&qf();h=a.pendingLanes;0!==(g&4194218)&&0!==(h&42)?(sf=!0,a===ie?he++:(he=0,ie=a)):he=0;pf(!1);gb();return null}function Cl(a,b){0===(a.pooledCacheLanes&=b)&&(b=a.pooledCache,null!=b&&(a.pooledCache=null,Oi(b)))}
+function qf(){if(null!==Zk){var a=Zk,b=bl;bl=0;var c=Ib($k),d=32>c?32:c;c=Tk.transition;var e=G;try{Tk.transition=null;G=d;if(null===Zk)var f=!1;else{var g=cl;cl=null;d=Zk;var h=$k;Zk=null;$k=0;if(0!==(N&6))throw Error(u(331));null!==F&&"function"===typeof F.markPassiveEffectsStarted&&F.markPassiveEffectsStarted(h);var l=N;N|=4;Mk(d.current);Bk(d,d.current,h,g);g=al;al=[];for(h=0;h<g.length;h++){var p=g[h];if(N&4&&0!==(p.flags&4))switch(p.tag){case 12:var q=p.stateNode.passiveEffectDuration,w=p.memoizedProps,
+r=w.id,t=w.onPostCommit,A=nh,C=null===p.alternate?"mount":"update";rf&&(C="nested-update");"function"===typeof t&&t(r,C,q,A);var J=p.return;b:for(;null!==J;){switch(J.tag){case 3:J.stateNode.passiveEffectDuration+=q;break b;case 12:J.stateNode.passiveEffectDuration+=q;break b}J=J.return}}}null!==F&&"function"===typeof F.markPassiveEffectsStopped&&F.markPassiveEffectsStopped();N=l;pf(!1);if(ab&&"function"===typeof ab.onPostCommitFiberRoot)try{ab.onPostCommitFiberRoot($a,d)}catch(m){}var S=d.current.stateNode;
 S.effectDuration=0;S.passiveEffectDuration=0;f=!0}return f}finally{G=e,Tk.transition=c,Cl(a,b)}}return!1}function Pj(a){al.push(a);Yk||(Yk=!0,Al(Xa,function(){qf();return null}))}function Dl(a,b,c){b=Eh(c,b);b=Hh(a,b,2);a=ne(a,b,2);null!==a&&(Ab(a,2),mf(a))}
 function W(a,b,c){if(3===a.tag)Dl(a,a,c);else for(;null!==b;){if(3===b.tag){Dl(b,a,c);break}else if(1===b.tag){var d=b.stateNode;if("function"===typeof b.type.getDerivedStateFromError||"function"===typeof d.componentDidCatch&&(null===Lh||!Lh.has(d))){a=Eh(c,a);a=Kh(b,a,2);b=ne(b,a,2);null!==b&&(Ab(b,2),mf(b));break}}b=b.return}}
 function Rh(a,b,c){var d=a.pingCache;if(null===d){d=a.pingCache=new Pk;var e=new Set;d.set(b,e)}else e=d.get(b),void 0===e&&(e=new Set,d.set(b,e));e.has(c)||(Vk=!0,e.add(c),d=El.bind(null,a,b,c),bb&&Oh(a,c),b.then(d,d))}function El(a,b,c){var d=a.pingCache;null!==d&&d.delete(b);a.pingedLanes|=a.suspendedLanes&c;P===a&&(O&c)===c&&(4===Qh||3===Qh&&(O&62914560)===O&&300>Ta()-uk?0===(N&2)&&wf(a,0):Xk|=c);mf(a)}function Fl(a,b){0===b&&(b=0===(a.mode&1)?2:yb());a=ge(a,b);null!==a&&(Ab(a,b),mf(a))}
-function wi(a){var b=a.memoizedState,c=0;null!==b&&(c=b.retryLane);Fl(a,c)}function ik(a,b){var c=0;switch(a.tag){case 13:var d=a.stateNode;var e=a.memoizedState;null!==e&&(c=e.retryLane);break;case 19:d=a.stateNode;break;case 22:d=a.stateNode._retryCache;break;default:throw Error(t(314));}null!==d&&d.delete(b);Fl(a,c)}var yl;
+function wi(a){var b=a.memoizedState,c=0;null!==b&&(c=b.retryLane);Fl(a,c)}function ik(a,b){var c=0;switch(a.tag){case 13:var d=a.stateNode;var e=a.memoizedState;null!==e&&(c=e.retryLane);break;case 19:d=a.stateNode;break;case 22:d=a.stateNode._retryCache;break;default:throw Error(u(314));}null!==d&&d.delete(b);Fl(a,c)}var yl;
 yl=function(a,b,c){if(null!==a)if(a.memoizedProps!==b.pendingProps||hd.current)ug=!0;else{if(0===(a.lanes&c)&&0===(b.flags&128))return ug=!1,Bi(a,b,c);ug=0!==(a.flags&131072)?!0:!1}else ug=!1,K&&0!==(b.flags&1048576)&&Cd(b,vd,b.index);b.lanes=0;switch(b.tag){case 2:var d=b.type;ki(a,b);a=b.pendingProps;var e=jd(b,gd.current);Xh(b,c);hb(b);e=ag(null,b,d,a,e,c);var f=jg();ib();b.flags|=1;"object"===typeof e&&null!==e&&"function"===typeof e.render&&void 0===e.$$typeof?(b.tag=1,b.memoizedState=null,b.updateQueue=
-null,kd(d)?(f=!0,od(b)):f=!1,b.memoizedState=null!==e.state&&void 0!==e.state?e.state:null,ke(b),e.updater=zh,b.stateNode=e,e._reactInternals=b,Dh(b,d,a,c),b=li(null,b,d,!0,f,c)):(b.tag=0,K&&f&&Dd(b),Vh(null,b,e,c),b=b.child);return b;case 16:d=b.elementType;a:{ki(a,b);a=b.pendingProps;e=d._init;d=e(d._payload);b.type=d;e=b.tag=Gl(d);a=xh(d,a);switch(e){case 0:b=bi(null,b,d,a,c);break a;case 1:b=ji(null,b,d,a,c);break a;case 11:b=Wh(null,b,d,a,c);break a;case 14:b=Zh(null,b,d,xh(d.type,a),c);break a}throw Error(t(306,
-d,""));}return b;case 0:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:xh(d,e),bi(a,b,d,e,c);case 1:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:xh(d,e),ji(a,b,d,e,c);case 3:a:{mi(b);if(null===a)throw Error(t(387));e=b.pendingProps;f=b.memoizedState;d=f.element;le(a,b);qe(b,e,null,c);var g=b.memoizedState;e=g.cache;Ci(b,hi,e);e!==f.cache&&Ji(b,hi,c);e=g.element;if(f.isDehydrated)if(f={element:e,isDehydrated:!1,cache:g.cache},b.updateQueue.baseState=f,b.memoizedState=f,b.flags&256){d=
-Eh(Error(t(423)),b);b=ni(a,b,e,c,d);break a}else if(e!==d){d=Eh(Error(t(424)),b);b=ni(a,b,e,c,d);break a}else for(I=Md(b.stateNode.containerInfo.firstChild),H=b,K=!0,Fd=null,Gd=!0,c=Re(b,null,e,c),b.child=c;c;)c.flags=c.flags&-3|4096,c=c.sibling;else{Xd();if(e===d){b=Yh(a,b,c);break a}Vh(a,b,e,c)}b=b.child}return b;case 26:return di(a,b),c=b.memoizedState=Hl(b.type,null===a?null:a.memoizedProps,b.pendingProps),null!==a||K||null!==c||(c=b.type,a=b.pendingProps,d=aj(Ga.current).createElement(c),d[Mb]=
+null,kd(d)?(f=!0,od(b)):f=!1,b.memoizedState=null!==e.state&&void 0!==e.state?e.state:null,ke(b),e.updater=zh,b.stateNode=e,e._reactInternals=b,Dh(b,d,a,c),b=li(null,b,d,!0,f,c)):(b.tag=0,K&&f&&Dd(b),Vh(null,b,e,c),b=b.child);return b;case 16:d=b.elementType;a:{ki(a,b);a=b.pendingProps;e=d._init;d=e(d._payload);b.type=d;e=b.tag=Gl(d);a=xh(d,a);switch(e){case 0:b=bi(null,b,d,a,c);break a;case 1:b=ji(null,b,d,a,c);break a;case 11:b=Wh(null,b,d,a,c);break a;case 14:b=Zh(null,b,d,xh(d.type,a),c);break a}throw Error(u(306,
+d,""));}return b;case 0:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:xh(d,e),bi(a,b,d,e,c);case 1:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:xh(d,e),ji(a,b,d,e,c);case 3:a:{mi(b);if(null===a)throw Error(u(387));e=b.pendingProps;f=b.memoizedState;d=f.element;le(a,b);qe(b,e,null,c);var g=b.memoizedState;e=g.cache;Ci(b,hi,e);e!==f.cache&&Ji(b,hi,c);e=g.element;if(f.isDehydrated)if(f={element:e,isDehydrated:!1,cache:g.cache},b.updateQueue.baseState=f,b.memoizedState=f,b.flags&256){d=
+Eh(Error(u(423)),b);b=ni(a,b,e,c,d);break a}else if(e!==d){d=Eh(Error(u(424)),b);b=ni(a,b,e,c,d);break a}else for(I=Md(b.stateNode.containerInfo.firstChild),H=b,K=!0,Fd=null,Gd=!0,c=Re(b,null,e,c),b.child=c;c;)c.flags=c.flags&-3|4096,c=c.sibling;else{Xd();if(e===d){b=Yh(a,b,c);break a}Vh(a,b,e,c)}b=b.child}return b;case 26:return di(a,b),c=b.memoizedState=Hl(b.type,null===a?null:a.memoizedProps,b.pendingProps),null!==a||K||null!==c||(c=b.type,a=b.pendingProps,d=aj(Ga.current).createElement(c),d[Mb]=
 b,d[Nb]=a,bj(d,c,a),ac(d),b.stateNode=d),null;case 27:return Na(b),null===a&&K&&(d=b.stateNode=$i(b.type,b.pendingProps,Ga.current),H=b,Gd=!0,I=Md(d.firstChild)),d=b.pendingProps.children,null!==a||K?Vh(a,b,d,c):b.child=Qe(b,null,d,c),di(a,b),b.child;case 5:return Na(b),null===a&&K&&((e=d=I,e)?Kd(b,e)||(Rd(b)&&Sd(),I=Qd(e),f=H,I&&Kd(b,I)?Hd(f,e):(Jd(H,b),K=!1,H=b,I=d)):(Rd(b)&&Sd(),Jd(H,b),K=!1,H=b,I=d)),e=b.type,f=b.pendingProps,g=null!==a?a.memoizedProps:null,d=f.children,Vd(e,f)?d=null:null!==
 g&&Vd(e,g)&&(b.flags|=32),null!==b.memoizedState&&(e=ag(a,b,hg,null,null,c),Ia._currentValue=e,ug&&null!==a&&a.memoizedState.memoizedState!==e&&Ji(b,Ia,c)),di(a,b),Vh(a,b,d,c),b.child;case 6:return null===a&&K&&((d=""!==b.pendingProps,a=c=I,a&&d)?Nd(b,a)||(Rd(b)&&Sd(),I=Qd(a),d=H,I&&Nd(b,I)?Hd(d,a):(Jd(H,b),K=!1,H=b,I=c)):(Rd(b)&&Sd(),Jd(H,b),K=!1,H=b,I=c)),null;case 13:return ri(a,b,c);case 4:return Ja(b,b.stateNode.containerInfo),d=b.pendingProps,null===a?b.child=Qe(b,null,d,c):Vh(a,b,d,c),b.child;
 case 11:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:xh(d,e),Wh(a,b,d,e,c);case 7:return Vh(a,b,b.pendingProps,c),b.child;case 8:return Vh(a,b,b.pendingProps.children,c),b.child;case 12:return b.flags|=4,d=b.stateNode,d.effectDuration=0,d.passiveEffectDuration=0,Vh(a,b,b.pendingProps.children,c),b.child;case 10:a:{d=b.type._context;e=b.pendingProps;f=b.memoizedProps;g=e.value;Ci(b,d,g);if(null!==f)if(rd(f.value,g)){if(f.children===e.children&&!hd.current){b=Yh(a,b,c);break a}}else Ji(b,
 d,c);Vh(a,b,e.children,c);b=b.child}return b;case 9:return e=b.type,d=b.pendingProps.children,Xh(b,c),e=qg(e),hb(b),d=d(e),ib(),b.flags|=1,Vh(a,b,d,c),b.child;case 14:return d=b.type,e=xh(d,b.pendingProps),e=xh(d.type,e),Zh(a,b,d,e,c);case 15:return ai(a,b,b.type,b.pendingProps,c);case 17:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:xh(d,e),ki(a,b),b.tag=1,kd(d)?(a=!0,od(b)):a=!1,Xh(b,c),Bh(b,d,e),Dh(b,d,e,c),li(null,b,d,!0,a,c);case 19:return Ai(a,b,c);case 22:return ci(a,b,c);case 24:return Xh(b,
-c),d=qg(hi),null===a?(e=gi(),null===e&&(e=P,f=ih(),e.pooledCache=f,f.refCount++,null!==f&&(e.pooledCacheLanes|=c),e=f),b.memoizedState={parent:d,cache:e},ke(b),Ci(b,hi,e)):(0!==(a.lanes&c)&&(le(a,b),qe(b,null,null,c)),e=a.memoizedState,f=b.memoizedState,e.parent!==d?(e={parent:d,cache:d},b.memoizedState=e,0===b.lanes&&(b.memoizedState=b.updateQueue.baseState=e),Ci(b,hi,d)):(d=f.cache,Ci(b,hi,d),d!==e.cache&&Ji(b,hi,c))),Vh(a,b,b.pendingProps.children,c),b.child}throw Error(t(156,b.tag));};
+c),d=qg(hi),null===a?(e=gi(),null===e&&(e=P,f=ih(),e.pooledCache=f,f.refCount++,null!==f&&(e.pooledCacheLanes|=c),e=f),b.memoizedState={parent:d,cache:e},ke(b),Ci(b,hi,e)):(0!==(a.lanes&c)&&(le(a,b),qe(b,null,null,c)),e=a.memoizedState,f=b.memoizedState,e.parent!==d?(e={parent:d,cache:d},b.memoizedState=e,0===b.lanes&&(b.memoizedState=b.updateQueue.baseState=e),Ci(b,hi,d)):(d=f.cache,Ci(b,hi,d),d!==e.cache&&Ji(b,hi,c))),Vh(a,b,b.pendingProps.children,c),b.child}throw Error(u(156,b.tag));};
 function Oh(a,b){bb&&a.memoizedUpdaters.forEach(function(c){Fb(a,c,b)})}function Al(a,b){return Pa(a,b)}
 function Il(a,b,c,d){this.tag=a;this.key=c;this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null;this.index=0;this.refCleanup=this.ref=null;this.pendingProps=b;this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null;this.mode=d;this.subtreeFlags=this.flags=0;this.deletions=null;this.childLanes=this.lanes=0;this.alternate=null;this.actualDuration=0;this.actualStartTime=-1;this.treeBaseDuration=this.selfBaseDuration=0}
 function Id(a,b,c,d){return new Il(a,b,c,d)}function $h(a){a=a.prototype;return!(!a||!a.isReactComponent)}function Gl(a){if("function"===typeof a)return $h(a)?1:0;if(void 0!==a&&null!==a){a=a.$$typeof;if(a===ta)return 11;if(a===wa)return 14}return 2}
@@ -318,27 +307,27 @@ function Ke(a,b){var c=a.alternate;null===c?(c=Id(a.tag,b,a.key,a.mode),c.elemen
 function ej(a,b){a.flags&=31457282;var c=a.alternate;null===c?(a.childLanes=0,a.lanes=b,a.child=null,a.subtreeFlags=0,a.memoizedProps=null,a.memoizedState=null,a.updateQueue=null,a.dependencies=null,a.stateNode=null,a.selfBaseDuration=0,a.treeBaseDuration=0):(a.childLanes=c.childLanes,a.lanes=c.lanes,a.child=c.child,a.subtreeFlags=0,a.deletions=null,a.memoizedProps=c.memoizedProps,a.memoizedState=c.memoizedState,a.updateQueue=c.updateQueue,a.type=c.type,b=c.dependencies,a.dependencies=null===b?null:
 {lanes:b.lanes,firstContext:b.firstContext},a.selfBaseDuration=c.selfBaseDuration,a.treeBaseDuration=c.treeBaseDuration);return a}
 function Me(a,b,c,d,e,f,g){e=2;d=a;if("function"===typeof a)$h(a)&&(e=1);else if("string"===typeof a)e=Jl(a,c,Ea.current)?26:"html"===a||"head"===a||"body"===a?27:5;else a:switch(a){case na:return Oe(c.children,f,g,b);case oa:e=8;f|=8;0!==(f&1)&&(f|=16);break;case pa:return a=Id(12,c,b,f|2),a.elementType=pa,a.lanes=g,a.stateNode={effectDuration:0,passiveEffectDuration:0},a;case ua:return a=Id(13,c,b,f),a.elementType=ua,a.lanes=g,a;case va:return a=Id(19,c,b,f),a.elementType=va,a.lanes=g,a;case za:return si(c,
-f,g,b);case Aa:case ya:case Ba:return a=Id(24,c,b,f),a.elementType=Ba,a.lanes=g,a;default:if("object"===typeof a&&null!==a)switch(a.$$typeof){case qa:e=10;break a;case ra:e=9;break a;case ta:e=11;break a;case wa:e=14;break a;case xa:e=16;d=null;break a}throw Error(t(130,null==a?a:typeof a,""));}b=Id(e,c,b,f);b.elementType=a;b.type=d;b.lanes=g;return b}function Oe(a,b,c,d){a=Id(7,a,d,b);a.lanes=c;return a}
-function si(a,b,c,d){a=Id(22,a,d,b);a.elementType=za;a.lanes=c;var e={_visibility:1,_pendingVisibility:1,_pendingMarkers:null,_retryCache:null,_transitions:null,_current:null,detach:function(){var f=e._current;if(null===f)throw Error(t(456));if(0===(e._pendingVisibility&2)){var g=ge(f,2);null!==g&&(e._pendingVisibility|=2,Eg(g,f,2))}},attach:function(){var f=e._current;if(null===f)throw Error(t(456));if(0!==(e._pendingVisibility&2)){var g=ge(f,2);null!==g&&(e._pendingVisibility&=-3,Eg(g,f,2))}}};
+f,g,b);case Aa:case ya:case Ba:return a=Id(24,c,b,f),a.elementType=Ba,a.lanes=g,a;default:if("object"===typeof a&&null!==a)switch(a.$$typeof){case qa:e=10;break a;case ra:e=9;break a;case ta:e=11;break a;case wa:e=14;break a;case xa:e=16;d=null;break a}throw Error(u(130,null==a?a:typeof a,""));}b=Id(e,c,b,f);b.elementType=a;b.type=d;b.lanes=g;return b}function Oe(a,b,c,d){a=Id(7,a,d,b);a.lanes=c;return a}
+function si(a,b,c,d){a=Id(22,a,d,b);a.elementType=za;a.lanes=c;var e={_visibility:1,_pendingVisibility:1,_pendingMarkers:null,_retryCache:null,_transitions:null,_current:null,detach:function(){var f=e._current;if(null===f)throw Error(u(456));if(0===(e._pendingVisibility&2)){var g=ge(f,2);null!==g&&(e._pendingVisibility|=2,Eg(g,f,2))}},attach:function(){var f=e._current;if(null===f)throw Error(u(456));if(0!==(e._pendingVisibility&2)){var g=ge(f,2);null!==g&&(e._pendingVisibility&=-3,Eg(g,f,2))}}};
 a.stateNode=e;return a}function Le(a,b,c){a=Id(6,a,null,b);a.lanes=c;return a}function Ne(a,b,c){b=Id(4,null!==a.children?a.children:[],a.key,b);b.lanes=c;b.stateNode={containerInfo:a.containerInfo,pendingChildren:null,implementation:a.implementation};return b}
 function Kl(a,b,c,d,e,f){this.tag=b;this.containerInfo=a;this.finishedWork=this.pingCache=this.current=this.pendingChildren=null;this.timeoutHandle=-1;this.callbackNode=this.next=this.pendingContext=this.context=this.cancelPendingCommit=null;this.callbackPriority=0;this.expirationTimes=zb(-1);this.entangledLanes=this.shellSuspendCounter=this.errorRecoveryDisabledLanes=this.finishedLanes=this.expiredLanes=this.pingedLanes=this.suspendedLanes=this.pendingLanes=0;this.entanglements=zb(0);this.hiddenUpdates=
 zb(null);this.identifierPrefix=d;this.onRecoverableError=e;this.pooledCache=null;this.pooledCacheLanes=0;this.formState=f;this.incompleteTransitions=new Map;this.passiveEffectDuration=this.effectDuration=0;this.memoizedUpdaters=new Set;a=this.pendingUpdatersLaneMap=[];for(b=0;31>b;b++)a.push(new Set)}
 function Ll(a,b,c,d,e,f,g,h,l,p,q){a=new Kl(a,b,c,h,l,q);1===b?(b=1,!0===f&&(b|=24)):b=0;bb&&(b|=2);f=Id(3,null,null,b);a.current=f;f.stateNode=a;b=ih();b.refCount++;a.pooledCache=b;b.refCount++;f.memoizedState={element:d,isDehydrated:c,cache:b};ke(f);return a}function Ml(a,b,c){var d=3<arguments.length&&void 0!==arguments[3]?arguments[3]:null;return{$$typeof:ma,key:null==d?null:""+d,children:a,containerInfo:b,implementation:c}}
-function Nl(a){if(!a)return fd;a=a._reactInternals;a:{if($c(a)!==a||1!==a.tag)throw Error(t(170));var b=a;do{switch(b.tag){case 3:b=b.stateNode.context;break a;case 1:if(kd(b.type)){b=b.stateNode.__reactInternalMemoizedMergedChildContext;break a}}b=b.return}while(null!==b);throw Error(t(171));}if(1===a.tag){var c=a.type;if(kd(c))return nd(a,c,b)}return b}
+function Nl(a){if(!a)return fd;a=a._reactInternals;a:{if($c(a)!==a||1!==a.tag)throw Error(u(170));var b=a;do{switch(b.tag){case 3:b=b.stateNode.context;break a;case 1:if(kd(b.type)){b=b.stateNode.__reactInternalMemoizedMergedChildContext;break a}}b=b.return}while(null!==b);throw Error(u(171));}if(1===a.tag){var c=a.type;if(kd(c))return nd(a,c,b)}return b}
 function Ol(a,b,c,d,e,f,g,h,l,p,q){a=Ll(c,d,!0,a,e,f,g,h,l,p,q);a.context=Nl(null);c=a.current;d=hh(c);e=me(d);e.callback=void 0!==b&&null!==b?b:null;ne(c,e,d);a.current.lanes=d;Ab(a,d);mf(a);return a}
 function Pl(a,b,c,d){var e=b.current,f=hh(e);null!==F&&"function"===typeof F.markRenderScheduled&&F.markRenderScheduled(f);c=Nl(c);null===b.context?b.context=c:b.pendingContext=c;b=me(f);b.payload={element:a};d=void 0===d?null:d;null!==d&&(b.callback=d);a=ne(e,b,f);null!==a&&(Eg(a,e,f),oe(a,e,f));return f}function Ql(a){a=a.current;if(!a.child)return null;switch(a.child.tag){case 27:case 5:return a.child.stateNode;default:return a.child.stateNode}}
 function Rl(a){switch(a.tag){case 3:var b=a.stateNode;if(b.current.memoizedState.isDehydrated){var c=ub(b.pendingLanes);0!==c&&(Eb(b,c),mf(b),0===(N&6)&&(fj=Ta()+500,pf(!1)))}break;case 13:ml(function(){var d=ge(a,2);null!==d&&Eg(d,a,2)}),Sl(a,2)}}function Tl(a,b){a=a.memoizedState;if(null!==a&&null!==a.dehydrated){var c=a.retryLane;a.retryLane=0!==c&&c<b?c:b}}function Sl(a,b){Tl(a,b);(a=a.alternate)&&Tl(a,b)}
 function Ul(a){if(13===a.tag){var b=ge(a,67108864);null!==b&&Eg(b,a,67108864);Sl(a,67108864)}}function Vl(){return null}var Wl=!1;function Xl(a,b,c){if(Wl)return a(b,c);Wl=!0;try{return ll(a,b,c)}finally{if(Wl=!1,null!==Vc||null!==Wc)ml(),Zc()}}
 function Yl(a,b){var c=a.stateNode;if(null===c)return null;var d=Zb(c);if(null===d)return null;c=d[b];a:switch(b){case "onClick":case "onClickCapture":case "onDoubleClick":case "onDoubleClickCapture":case "onMouseDown":case "onMouseDownCapture":case "onMouseMove":case "onMouseMoveCapture":case "onMouseUp":case "onMouseUpCapture":case "onMouseEnter":(d=!d.disabled)||(a=a.type,d=!("button"===a||"input"===a||"select"===a||"textarea"===a));a=!d;break a;default:a=!1}if(a)return null;if(c&&"function"!==
-typeof c)throw Error(t(231,b,typeof c));return c}var Zl=!1;if(fc)try{var $l={};Object.defineProperty($l,"passive",{get:function(){Zl=!0}});window.addEventListener("test",$l,$l);window.removeEventListener("test",$l,$l)}catch(a){Zl=!1}function am(a){var b=a.keyCode;"charCode"in a?(a=a.charCode,0===a&&13===b&&(a=13)):a=b;10===a&&(a=13);return 32<=a||13===a?a:0}function bm(){return!0}function cm(){return!1}
-function dm(a){function b(c,d,e,f,g){this._reactName=c;this._targetInst=e;this.type=d;this.nativeEvent=f;this.target=g;this.currentTarget=null;for(var h in a)a.hasOwnProperty(h)&&(c=a[h],this[h]=c?c(f):f[h]);this.isDefaultPrevented=(null!=f.defaultPrevented?f.defaultPrevented:!1===f.returnValue)?bm:cm;this.isPropagationStopped=cm;return this}w(b.prototype,{preventDefault:function(){this.defaultPrevented=!0;var c=this.nativeEvent;c&&(c.preventDefault?c.preventDefault():"unknown"!==typeof c.returnValue&&
+typeof c)throw Error(u(231,b,typeof c));return c}var Zl=!1;if(fc)try{var $l={};Object.defineProperty($l,"passive",{get:function(){Zl=!0}});window.addEventListener("test",$l,$l);window.removeEventListener("test",$l,$l)}catch(a){Zl=!1}function am(a){var b=a.keyCode;"charCode"in a?(a=a.charCode,0===a&&13===b&&(a=13)):a=b;10===a&&(a=13);return 32<=a||13===a?a:0}function bm(){return!0}function cm(){return!1}
+function dm(a){function b(c,d,e,f,g){this._reactName=c;this._targetInst=e;this.type=d;this.nativeEvent=f;this.target=g;this.currentTarget=null;for(var h in a)a.hasOwnProperty(h)&&(c=a[h],this[h]=c?c(f):f[h]);this.isDefaultPrevented=(null!=f.defaultPrevented?f.defaultPrevented:!1===f.returnValue)?bm:cm;this.isPropagationStopped=cm;return this}x(b.prototype,{preventDefault:function(){this.defaultPrevented=!0;var c=this.nativeEvent;c&&(c.preventDefault?c.preventDefault():"unknown"!==typeof c.returnValue&&
 (c.returnValue=!1),this.isDefaultPrevented=bm)},stopPropagation:function(){var c=this.nativeEvent;c&&(c.stopPropagation?c.stopPropagation():"unknown"!==typeof c.cancelBubble&&(c.cancelBubble=!0),this.isPropagationStopped=bm)},persist:function(){},isPersistent:bm});return b}
-var em={eventPhase:0,bubbles:0,cancelable:0,timeStamp:function(a){return a.timeStamp||Date.now()},defaultPrevented:0,isTrusted:0},fm=dm(em),gm=w({},em,{view:0,detail:0}),hm=dm(gm),im,jm,km,mm=w({},gm,{screenX:0,screenY:0,clientX:0,clientY:0,pageX:0,pageY:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,getModifierState:lm,button:0,buttons:0,relatedTarget:function(a){return void 0===a.relatedTarget?a.fromElement===a.srcElement?a.toElement:a.fromElement:a.relatedTarget},movementX:function(a){if("movementX"in
-a)return a.movementX;a!==km&&(km&&"mousemove"===a.type?(im=a.screenX-km.screenX,jm=a.screenY-km.screenY):jm=im=0,km=a);return im},movementY:function(a){return"movementY"in a?a.movementY:jm}}),nm=dm(mm),om=w({},mm,{dataTransfer:0}),pm=dm(om),qm=w({},gm,{relatedTarget:0}),rm=dm(qm),sm=w({},em,{animationName:0,elapsedTime:0,pseudoElement:0}),tm=dm(sm),um=w({},em,{clipboardData:function(a){return"clipboardData"in a?a.clipboardData:window.clipboardData}}),vm=dm(um),wm=w({},em,{data:0}),xm=dm(wm),ym={Esc:"Escape",
+var em={eventPhase:0,bubbles:0,cancelable:0,timeStamp:function(a){return a.timeStamp||Date.now()},defaultPrevented:0,isTrusted:0},fm=dm(em),gm=x({},em,{view:0,detail:0}),hm=dm(gm),im,jm,km,mm=x({},gm,{screenX:0,screenY:0,clientX:0,clientY:0,pageX:0,pageY:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,getModifierState:lm,button:0,buttons:0,relatedTarget:function(a){return void 0===a.relatedTarget?a.fromElement===a.srcElement?a.toElement:a.fromElement:a.relatedTarget},movementX:function(a){if("movementX"in
+a)return a.movementX;a!==km&&(km&&"mousemove"===a.type?(im=a.screenX-km.screenX,jm=a.screenY-km.screenY):jm=im=0,km=a);return im},movementY:function(a){return"movementY"in a?a.movementY:jm}}),nm=dm(mm),om=x({},mm,{dataTransfer:0}),pm=dm(om),qm=x({},gm,{relatedTarget:0}),rm=dm(qm),sm=x({},em,{animationName:0,elapsedTime:0,pseudoElement:0}),tm=dm(sm),um=x({},em,{clipboardData:function(a){return"clipboardData"in a?a.clipboardData:window.clipboardData}}),vm=dm(um),wm=x({},em,{data:0}),xm=dm(wm),ym={Esc:"Escape",
 Spacebar:" ",Left:"ArrowLeft",Up:"ArrowUp",Right:"ArrowRight",Down:"ArrowDown",Del:"Delete",Win:"OS",Menu:"ContextMenu",Apps:"ContextMenu",Scroll:"ScrollLock",MozPrintableKey:"Unidentified"},zm={8:"Backspace",9:"Tab",12:"Clear",13:"Enter",16:"Shift",17:"Control",18:"Alt",19:"Pause",20:"CapsLock",27:"Escape",32:" ",33:"PageUp",34:"PageDown",35:"End",36:"Home",37:"ArrowLeft",38:"ArrowUp",39:"ArrowRight",40:"ArrowDown",45:"Insert",46:"Delete",112:"F1",113:"F2",114:"F3",115:"F4",116:"F5",117:"F6",118:"F7",
 119:"F8",120:"F9",121:"F10",122:"F11",123:"F12",144:"NumLock",145:"ScrollLock",224:"Meta"},Am={Alt:"altKey",Control:"ctrlKey",Meta:"metaKey",Shift:"shiftKey"};function Bm(a){var b=this.nativeEvent;return b.getModifierState?b.getModifierState(a):(a=Am[a])?!!b[a]:!1}function lm(){return Bm}
-var Cm=w({},gm,{key:function(a){if(a.key){var b=ym[a.key]||a.key;if("Unidentified"!==b)return b}return"keypress"===a.type?(a=am(a),13===a?"Enter":String.fromCharCode(a)):"keydown"===a.type||"keyup"===a.type?zm[a.keyCode]||"Unidentified":""},code:0,location:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,repeat:0,locale:0,getModifierState:lm,charCode:function(a){return"keypress"===a.type?am(a):0},keyCode:function(a){return"keydown"===a.type||"keyup"===a.type?a.keyCode:0},which:function(a){return"keypress"===
-a.type?am(a):"keydown"===a.type||"keyup"===a.type?a.keyCode:0}}),Dm=dm(Cm),Em=w({},mm,{pointerId:0,width:0,height:0,pressure:0,tangentialPressure:0,tiltX:0,tiltY:0,twist:0,pointerType:0,isPrimary:0}),Fm=dm(Em),Gm=w({},gm,{touches:0,targetTouches:0,changedTouches:0,altKey:0,metaKey:0,ctrlKey:0,shiftKey:0,getModifierState:lm}),Hm=dm(Gm),Im=w({},em,{propertyName:0,elapsedTime:0,pseudoElement:0}),Jm=dm(Im),Km=w({},mm,{deltaX:function(a){return"deltaX"in a?a.deltaX:"wheelDeltaX"in a?-a.wheelDeltaX:0},
+var Cm=x({},gm,{key:function(a){if(a.key){var b=ym[a.key]||a.key;if("Unidentified"!==b)return b}return"keypress"===a.type?(a=am(a),13===a?"Enter":String.fromCharCode(a)):"keydown"===a.type||"keyup"===a.type?zm[a.keyCode]||"Unidentified":""},code:0,location:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,repeat:0,locale:0,getModifierState:lm,charCode:function(a){return"keypress"===a.type?am(a):0},keyCode:function(a){return"keydown"===a.type||"keyup"===a.type?a.keyCode:0},which:function(a){return"keypress"===
+a.type?am(a):"keydown"===a.type||"keyup"===a.type?a.keyCode:0}}),Dm=dm(Cm),Em=x({},mm,{pointerId:0,width:0,height:0,pressure:0,tangentialPressure:0,tiltX:0,tiltY:0,twist:0,pointerType:0,isPrimary:0}),Fm=dm(Em),Gm=x({},gm,{touches:0,targetTouches:0,changedTouches:0,altKey:0,metaKey:0,ctrlKey:0,shiftKey:0,getModifierState:lm}),Hm=dm(Gm),Im=x({},em,{propertyName:0,elapsedTime:0,pseudoElement:0}),Jm=dm(Im),Km=x({},mm,{deltaX:function(a){return"deltaX"in a?a.deltaX:"wheelDeltaX"in a?-a.wheelDeltaX:0},
 deltaY:function(a){return"deltaY"in a?a.deltaY:"wheelDeltaY"in a?-a.wheelDeltaY:"wheelDelta"in a?-a.wheelDelta:0},deltaZ:0,deltaMode:0}),Lm=dm(Km);
 function Mm(a,b,c,d,e){if("submit"===b&&c&&c.stateNode===e){var f=Zb(e).action,g=d.submitter;g&&(b=(b=Zb(g))?b.formAction:g.getAttribute("formAction"),null!=b&&(f=b,g=null));if("function"===typeof f){var h=new fm("action","action",null,d,e);a.push({event:h,listeners:[{instance:null,listener:function(){if(!d.defaultPrevented){h.preventDefault();if(g){var l=g.ownerDocument.createElement("input");l.name=g.name;l.value=g.value;g.parentNode.insertBefore(l,g);var p=new FormData(e);l.parentNode.removeChild(l)}else p=
 new FormData(e);ch(c,{pending:!0,data:p,method:e.method,action:f},f,p)}},currentTarget:e}]})}}}var Nm=!1,Om=null,Pm=null,Qm=null,Rm=new Map,Sm=new Map,Tm=[],Um="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".split(" ");
@@ -376,37 +365,37 @@ function Ln(a,b){b=0!==(b&4);for(var c=0;c<a.length;c++){var d=a[c],e=d.event;d=
 function Y(a,b){var c=b[Pb];void 0===c&&(c=b[Pb]=new Set);var d=a+"__bubble";c.has(d)||(Ao(b,a,2,!1),c.add(d))}function Bo(a,b,c){var d=0;b&&(d|=4);Ao(c,a,d,b)}var Co="_reactListening"+Math.random().toString(36).slice(2);function dj(a){if(!a[Co]){a[Co]=!0;bc.forEach(function(c){"selectionchange"!==c&&(yo.has(c)||Bo(c,!1,a),Bo(c,!0,a))});var b=9===a.nodeType?a:a.ownerDocument;null===b||b[Co]||(b[Co]=!0,Bo("selectionchange",!1,b))}}
 function Ao(a,b,c,d){switch(dl(b)){case 2:var e=hn;break;case 8:e=kn;break;default:e=jn}c=e.bind(null,b,c,a);e=void 0;!Zl||"touchstart"!==b&&"touchmove"!==b&&"wheel"!==b||(e=!0);d?void 0!==e?a.addEventListener(b,c,{capture:!0,passive:e}):a.addEventListener(b,c,!0):void 0!==e?a.addEventListener(b,c,{passive:e}):a.addEventListener(b,c,!1)}
 function ln(a,b,c,d,e){var f=d;if(0===(b&1)&&0===(b&2)&&null!==d)a:for(;;){if(null===d)return;var g=d.tag;if(3===g||4===g){var h=d.stateNode.containerInfo;if(h===e||8===h.nodeType&&h.parentNode===e)break;if(4===g)for(g=d.return;null!==g;){var l=g.tag;if(3===l||4===l)if(l=g.stateNode.containerInfo,l===e||8===l.nodeType&&l.parentNode===e)return;g=g.return}for(;null!==h;){g=Vb(h);if(null===g)return;l=g.tag;if(5===l||6===l||26===l||27===l){d=f=g;continue a}h=h.parentNode}}d=d.return}Xl(function(){var p=
-f,q=Uc(c),x=[];a:{var r=qo.get(a);if(void 0!==r){var u=fm,A=a;switch(a){case "keypress":if(0===am(c))break a;case "keydown":case "keyup":u=Dm;break;case "focusin":A="focus";u=rm;break;case "focusout":A="blur";u=rm;break;case "beforeblur":case "afterblur":u=rm;break;case "click":if(2===c.button)break a;case "auxclick":case "dblclick":case "mousedown":case "mousemove":case "mouseup":case "mouseout":case "mouseover":case "contextmenu":u=nm;break;case "drag":case "dragend":case "dragenter":case "dragexit":case "dragleave":case "dragover":case "dragstart":case "drop":u=
-pm;break;case "touchcancel":case "touchend":case "touchmove":case "touchstart":u=Hm;break;case mo:case no:case oo:u=tm;break;case po:u=Jm;break;case "scroll":case "scrollend":u=hm;break;case "wheel":u=Lm;break;case "copy":case "cut":case "paste":u=vm;break;case "gotpointercapture":case "lostpointercapture":case "pointercancel":case "pointerdown":case "pointermove":case "pointerout":case "pointerover":case "pointerup":u=Fm}var C=0!==(b&4),J=!C&&("scroll"===a||"scrollend"===a),S=C?null!==r?r+"Capture":
-null:r;C=[];for(var m=p,k;null!==m;){var n=m;k=n.stateNode;n=n.tag;5!==n&&26!==n&&27!==n||null===k||null===S||(n=Yl(m,S),null!=n&&C.push(Do(m,n,k)));if(J)break;m=m.return}0<C.length&&(r=new u(r,A,null,c,q),x.push({event:r,listeners:C}))}}if(0===(b&7)){a:{r="mouseover"===a||"pointerover"===a;u="mouseout"===a||"pointerout"===a;if(r&&c!==Tc&&(A=c.relatedTarget||c.fromElement)&&(Vb(A)||A[Ob]))break a;if(u||r){r=q.window===q?q:(r=q.ownerDocument)?r.defaultView||r.parentWindow:window;if(u){if(A=c.relatedTarget||
-c.toElement,u=p,A=A?Vb(A):null,null!==A&&(J=$c(A),C=A.tag,A!==J||5!==C&&27!==C&&6!==C))A=null}else u=null,A=p;if(u!==A){C=nm;n="onMouseLeave";S="onMouseEnter";m="mouse";if("pointerout"===a||"pointerover"===a)C=Fm,n="onPointerLeave",S="onPointerEnter",m="pointer";J=null==u?r:Yb(u);k=null==A?r:Yb(A);r=new C(n,m+"leave",u,c,q);r.target=J;r.relatedTarget=k;n=null;Vb(q)===p&&(C=new C(S,m+"enter",A,c,q),C.target=k,C.relatedTarget=J,n=C);J=n;if(u&&A)b:{C=u;S=A;m=0;for(k=C;k;k=Eo(k))m++;k=0;for(n=S;n;n=Eo(n))k++;
-for(;0<m-k;)C=Eo(C),m--;for(;0<k-m;)S=Eo(S),k--;for(;m--;){if(C===S||null!==S&&C===S.alternate)break b;C=Eo(C);S=Eo(S)}C=null}else C=null;null!==u&&Fo(x,r,u,C,!1);null!==A&&null!==J&&Fo(x,J,A,C,!0)}}}a:{r=p?Yb(p):window;u=r.nodeName&&r.nodeName.toLowerCase();if("select"===u||"input"===u&&"file"===r.type)var v=Nn;else if(Fn(r))if(On)v=Xn;else{v=Vn;var y=Un}else(u=r.nodeName)&&"input"===u.toLowerCase()&&("checkbox"===r.type||"radio"===r.type)&&(v=Wn);if(v&&(v=v(a,p))){Gn(x,v,c,q);break a}y&&y(a,r,p);
-"focusout"===a&&p&&"number"===r.type&&null!=p.memoizedProps.value&&Dc(r,"number",r.value)}y=p?Yb(p):window;switch(a){case "focusin":if(Fn(y)||"true"===y.contentEditable)bo=y,co=p,eo=null;break;case "focusout":eo=co=bo=null;break;case "mousedown":fo=!0;break;case "contextmenu":case "mouseup":case "dragend":fo=!1;go(x,c,q);break;case "selectionchange":if(ao)break;case "keydown":case "keyup":go(x,c,q)}var B;if(sn)b:{switch(a){case "compositionstart":var z="onCompositionStart";break b;case "compositionend":z=
-"onCompositionEnd";break b;case "compositionupdate":z="onCompositionUpdate";break b}z=void 0}else Bn?zn(a,c)&&(z="onCompositionEnd"):"keydown"===a&&229===c.keyCode&&(z="onCompositionStart");z&&(wn&&"ko"!==c.locale&&(Bn||"onCompositionStart"!==z?"onCompositionEnd"===z&&Bn&&(B=qn()):(nn=q,on="value"in nn?nn.value:nn.textContent,Bn=!0)),y=Hn(p,z),0<y.length&&(z=new xm(z,a,null,c,q),x.push({event:z,listeners:y}),B?z.data=B:(B=An(c),null!==B&&(z.data=B))));if(B=vn?Cn(a,c):Dn(a,c))z=Hn(p,"onBeforeInput"),
-0<z.length&&(y=new xm("onBeforeInput","beforeinput",null,c,q),x.push({event:y,listeners:z}),y.data=B);Mm(x,a,p,c,q)}Ln(x,b)})}function Do(a,b,c){return{instance:a,listener:b,currentTarget:c}}function Hn(a,b){for(var c=b+"Capture",d=[];null!==a;){var e=a,f=e.stateNode;e=e.tag;5!==e&&26!==e&&27!==e||null===f||(e=Yl(a,c),null!=e&&d.unshift(Do(a,e,f)),e=Yl(a,b),null!=e&&d.push(Do(a,e,f)));a=a.return}return d}
+f,q=Uc(c),w=[];a:{var r=qo.get(a);if(void 0!==r){var t=fm,A=a;switch(a){case "keypress":if(0===am(c))break a;case "keydown":case "keyup":t=Dm;break;case "focusin":A="focus";t=rm;break;case "focusout":A="blur";t=rm;break;case "beforeblur":case "afterblur":t=rm;break;case "click":if(2===c.button)break a;case "auxclick":case "dblclick":case "mousedown":case "mousemove":case "mouseup":case "mouseout":case "mouseover":case "contextmenu":t=nm;break;case "drag":case "dragend":case "dragenter":case "dragexit":case "dragleave":case "dragover":case "dragstart":case "drop":t=
+pm;break;case "touchcancel":case "touchend":case "touchmove":case "touchstart":t=Hm;break;case mo:case no:case oo:t=tm;break;case po:t=Jm;break;case "scroll":case "scrollend":t=hm;break;case "wheel":t=Lm;break;case "copy":case "cut":case "paste":t=vm;break;case "gotpointercapture":case "lostpointercapture":case "pointercancel":case "pointerdown":case "pointermove":case "pointerout":case "pointerover":case "pointerup":t=Fm}var C=0!==(b&4),J=!C&&("scroll"===a||"scrollend"===a),S=C?null!==r?r+"Capture":
+null:r;C=[];for(var m=p,k;null!==m;){var n=m;k=n.stateNode;n=n.tag;5!==n&&26!==n&&27!==n||null===k||null===S||(n=Yl(m,S),null!=n&&C.push(Do(m,n,k)));if(J)break;m=m.return}0<C.length&&(r=new t(r,A,null,c,q),w.push({event:r,listeners:C}))}}if(0===(b&7)){a:{r="mouseover"===a||"pointerover"===a;t="mouseout"===a||"pointerout"===a;if(r&&c!==Tc&&(A=c.relatedTarget||c.fromElement)&&(Vb(A)||A[Ob]))break a;if(t||r){r=q.window===q?q:(r=q.ownerDocument)?r.defaultView||r.parentWindow:window;if(t){if(A=c.relatedTarget||
+c.toElement,t=p,A=A?Vb(A):null,null!==A&&(J=$c(A),C=A.tag,A!==J||5!==C&&27!==C&&6!==C))A=null}else t=null,A=p;if(t!==A){C=nm;n="onMouseLeave";S="onMouseEnter";m="mouse";if("pointerout"===a||"pointerover"===a)C=Fm,n="onPointerLeave",S="onPointerEnter",m="pointer";J=null==t?r:Yb(t);k=null==A?r:Yb(A);r=new C(n,m+"leave",t,c,q);r.target=J;r.relatedTarget=k;n=null;Vb(q)===p&&(C=new C(S,m+"enter",A,c,q),C.target=k,C.relatedTarget=J,n=C);J=n;if(t&&A)b:{C=t;S=A;m=0;for(k=C;k;k=Eo(k))m++;k=0;for(n=S;n;n=Eo(n))k++;
+for(;0<m-k;)C=Eo(C),m--;for(;0<k-m;)S=Eo(S),k--;for(;m--;){if(C===S||null!==S&&C===S.alternate)break b;C=Eo(C);S=Eo(S)}C=null}else C=null;null!==t&&Fo(w,r,t,C,!1);null!==A&&null!==J&&Fo(w,J,A,C,!0)}}}a:{r=p?Yb(p):window;t=r.nodeName&&r.nodeName.toLowerCase();if("select"===t||"input"===t&&"file"===r.type)var v=Nn;else if(Fn(r))if(On)v=Xn;else{v=Vn;var y=Un}else(t=r.nodeName)&&"input"===t.toLowerCase()&&("checkbox"===r.type||"radio"===r.type)&&(v=Wn);if(v&&(v=v(a,p))){Gn(w,v,c,q);break a}y&&y(a,r,p);
+"focusout"===a&&p&&"number"===r.type&&null!=p.memoizedProps.value&&Dc(r,"number",r.value)}y=p?Yb(p):window;switch(a){case "focusin":if(Fn(y)||"true"===y.contentEditable)bo=y,co=p,eo=null;break;case "focusout":eo=co=bo=null;break;case "mousedown":fo=!0;break;case "contextmenu":case "mouseup":case "dragend":fo=!1;go(w,c,q);break;case "selectionchange":if(ao)break;case "keydown":case "keyup":go(w,c,q)}var B;if(sn)b:{switch(a){case "compositionstart":var z="onCompositionStart";break b;case "compositionend":z=
+"onCompositionEnd";break b;case "compositionupdate":z="onCompositionUpdate";break b}z=void 0}else Bn?zn(a,c)&&(z="onCompositionEnd"):"keydown"===a&&229===c.keyCode&&(z="onCompositionStart");z&&(wn&&"ko"!==c.locale&&(Bn||"onCompositionStart"!==z?"onCompositionEnd"===z&&Bn&&(B=qn()):(nn=q,on="value"in nn?nn.value:nn.textContent,Bn=!0)),y=Hn(p,z),0<y.length&&(z=new xm(z,a,null,c,q),w.push({event:z,listeners:y}),B?z.data=B:(B=An(c),null!==B&&(z.data=B))));if(B=vn?Cn(a,c):Dn(a,c))z=Hn(p,"onBeforeInput"),
+0<z.length&&(y=new xm("onBeforeInput","beforeinput",null,c,q),w.push({event:y,listeners:z}),y.data=B);Mm(w,a,p,c,q)}Ln(w,b)})}function Do(a,b,c){return{instance:a,listener:b,currentTarget:c}}function Hn(a,b){for(var c=b+"Capture",d=[];null!==a;){var e=a,f=e.stateNode;e=e.tag;5!==e&&26!==e&&27!==e||null===f||(e=Yl(a,c),null!=e&&d.unshift(Do(a,e,f)),e=Yl(a,b),null!=e&&d.push(Do(a,e,f)));a=a.return}return d}
 function Eo(a){if(null===a)return null;do a=a.return;while(a&&5!==a.tag&&27!==a.tag);return a?a:null}function Fo(a,b,c,d,e){for(var f=b._reactName,g=[];null!==c&&c!==d;){var h=c,l=h.alternate,p=h.stateNode;h=h.tag;if(null!==l&&l===d)break;5!==h&&26!==h&&27!==h||null===p||(l=p,e?(p=Yl(c,f),null!=p&&g.unshift(Do(c,p,l))):e||(p=Yl(c,f),null!=p&&g.push(Do(c,p,l))));c=c.return}0!==g.length&&a.push({event:b,listeners:g})}var Go=/\r\n?/g,Ho=/\u0000|\uFFFD/g;
-function Io(a){return("string"===typeof a?a:""+a).replace(Go,"\n").replace(Ho,"")}function cj(a,b,c){b=Io(b);if(Io(a)!==b&&c)throw Error(t(425));}function Yj(){}
+function Io(a){return("string"===typeof a?a:""+a).replace(Go,"\n").replace(Ho,"")}function cj(a,b,c){b=Io(b);if(Io(a)!==b&&c)throw Error(u(425));}function Yj(){}
 function Z(a,b,c,d,e,f){switch(c){case "children":"string"===typeof d?"body"===b||"textarea"===b&&""===d||Nc(a,d):"number"===typeof d&&"body"!==b&&Nc(a,""+d);break;case "className":lc(a,"class",d);break;case "tabIndex":lc(a,"tabindex",d);break;case "dir":case "role":case "viewBox":case "width":case "height":lc(a,c,d);break;case "style":Qc(a,d,f);break;case "src":case "href":if(null==d||"function"===typeof d||"symbol"===typeof d||"boolean"===typeof d){a.removeAttribute(c);break}a.setAttribute(c,""+
 d);break;case "action":case "formAction":if("function"===typeof d){a.setAttribute(c,"javascript:throw new Error('A React form was unexpectedly submitted. If you called form.submit() manually, consider using form.requestSubmit() instead. If you\\'re trying to use event.stopPropagation() in a submit event handler, consider also calling event.preventDefault().')");break}else"function"===typeof f&&("formAction"===c?("input"!==b&&Z(a,b,"name",e.name,e,null),Z(a,b,"formEncType",e.formEncType,e,null),Z(a,
 b,"formMethod",e.formMethod,e,null),Z(a,b,"formTarget",e.formTarget,e,null)):(Z(a,b,"encType",e.encType,e,null),Z(a,b,"method",e.method,e,null),Z(a,b,"target",e.target,e,null)));if(null==d||"symbol"===typeof d||"boolean"===typeof d){a.removeAttribute(c);break}a.setAttribute(c,""+d);break;case "onClick":null!=d&&(a.onclick=Yj);break;case "onScroll":null!=d&&Y("scroll",a);break;case "onScrollEnd":null!=d&&Y("scrollend",a);break;case "dangerouslySetInnerHTML":if(null!=d){if("object"!==typeof d||!("__html"in
-d))throw Error(t(61));d=d.__html;if(null!=d){if(null!=e.children)throw Error(t(60));Mc(a,d)}}break;case "multiple":a.multiple=d&&"function"!==typeof d&&"symbol"!==typeof d;break;case "muted":a.muted=d&&"function"!==typeof d&&"symbol"!==typeof d;break;case "suppressContentEditableWarning":case "suppressHydrationWarning":case "defaultValue":case "defaultChecked":case "innerHTML":break;case "autoFocus":break;case "xlinkHref":if(null==d||"function"===typeof d||"boolean"===typeof d||"symbol"===typeof d){a.removeAttribute("xlink:href");
+d))throw Error(u(61));d=d.__html;if(null!=d){if(null!=e.children)throw Error(u(60));Mc(a,d)}}break;case "multiple":a.multiple=d&&"function"!==typeof d&&"symbol"!==typeof d;break;case "muted":a.muted=d&&"function"!==typeof d&&"symbol"!==typeof d;break;case "suppressContentEditableWarning":case "suppressHydrationWarning":case "defaultValue":case "defaultChecked":case "innerHTML":break;case "autoFocus":break;case "xlinkHref":if(null==d||"function"===typeof d||"boolean"===typeof d||"symbol"===typeof d){a.removeAttribute("xlink:href");
 break}a.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",""+d);break;case "contentEditable":case "spellCheck":case "draggable":case "value":case "autoReverse":case "externalResourcesRequired":case "focusable":case "preserveAlpha":null!=d&&"function"!==typeof d&&"symbol"!==typeof d?a.setAttribute(c,""+d):a.removeAttribute(c);break;case "allowFullScreen":case "async":case "autoPlay":case "controls":case "default":case "defer":case "disabled":case "disablePictureInPicture":case "disableRemotePlayback":case "formNoValidate":case "hidden":case "loop":case "noModule":case "noValidate":case "open":case "playsInline":case "readOnly":case "required":case "reversed":case "scoped":case "seamless":case "itemScope":d&&
 "function"!==typeof d&&"symbol"!==typeof d?a.setAttribute(c,""):a.removeAttribute(c);break;case "capture":case "download":!0===d?a.setAttribute(c,""):!1!==d&&null!=d&&"function"!==typeof d&&"symbol"!==typeof d?a.setAttribute(c,d):a.removeAttribute(c);break;case "cols":case "rows":case "size":case "span":null!=d&&"function"!==typeof d&&"symbol"!==typeof d&&!isNaN(d)&&1<=d?a.setAttribute(c,d):a.removeAttribute(c);break;case "rowSpan":case "start":null==d||"function"===typeof d||"symbol"===typeof d||
 isNaN(d)?a.removeAttribute(c):a.setAttribute(c,d);break;case "xlinkActuate":mc(a,"http://www.w3.org/1999/xlink","xlink:actuate",d);break;case "xlinkArcrole":mc(a,"http://www.w3.org/1999/xlink","xlink:arcrole",d);break;case "xlinkRole":mc(a,"http://www.w3.org/1999/xlink","xlink:role",d);break;case "xlinkShow":mc(a,"http://www.w3.org/1999/xlink","xlink:show",d);break;case "xlinkTitle":mc(a,"http://www.w3.org/1999/xlink","xlink:title",d);break;case "xlinkType":mc(a,"http://www.w3.org/1999/xlink","xlink:type",
 d);break;case "xmlBase":mc(a,"http://www.w3.org/XML/1998/namespace","xml:base",d);break;case "xmlLang":mc(a,"http://www.w3.org/XML/1998/namespace","xml:lang",d);break;case "xmlSpace":mc(a,"http://www.w3.org/XML/1998/namespace","xml:space",d);break;case "is":kc(a,"is",d);break;default:if(!(2<c.length)||"o"!==c[0]&&"O"!==c[0]||"n"!==c[1]&&"N"!==c[1])e=Sc.get(c)||c,kc(a,e,d)}}
-function Jo(a,b,c,d,e,f){switch(c){case "style":Qc(a,d,f);break;case "dangerouslySetInnerHTML":if(null!=d){if("object"!==typeof d||!("__html"in d))throw Error(t(61));b=d.__html;if(null!=b){if(null!=e.children)throw Error(t(60));Mc(a,b)}}break;case "children":"string"===typeof d?Nc(a,d):"number"===typeof d&&Nc(a,""+d);break;case "onScroll":null!=d&&Y("scroll",a);break;case "onScrollEnd":null!=d&&Y("scrollend",a);break;case "onClick":null!=d&&(a.onclick=Yj);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":case "innerHTML":break;
+function Jo(a,b,c,d,e,f){switch(c){case "style":Qc(a,d,f);break;case "dangerouslySetInnerHTML":if(null!=d){if("object"!==typeof d||!("__html"in d))throw Error(u(61));b=d.__html;if(null!=b){if(null!=e.children)throw Error(u(60));Mc(a,b)}}break;case "children":"string"===typeof d?Nc(a,d):"number"===typeof d&&Nc(a,""+d);break;case "onScroll":null!=d&&Y("scroll",a);break;case "onScrollEnd":null!=d&&Y("scrollend",a);break;case "onClick":null!=d&&(a.onclick=Yj);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":case "innerHTML":break;
 default:cc.hasOwnProperty(c)||("boolean"===typeof d&&(d=""+d),kc(a,c,d))}}
-function bj(a,b,c){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "input":Y("invalid",a);var d=null,e=null,f=null,g=null,h=null,l=null;for(q in c)if(c.hasOwnProperty(q)){var p=c[q];if(null!=p)switch(q){case "name":d=p;break;case "type":e=p;break;case "checked":h=p;break;case "defaultChecked":l=p;break;case "value":f=p;break;case "defaultValue":g=p;break;case "children":case "dangerouslySetInnerHTML":if(null!=p)throw Error(t(137,b));break;default:Z(a,
+function bj(a,b,c){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "input":Y("invalid",a);var d=null,e=null,f=null,g=null,h=null,l=null;for(q in c)if(c.hasOwnProperty(q)){var p=c[q];if(null!=p)switch(q){case "name":d=p;break;case "type":e=p;break;case "checked":h=p;break;case "defaultChecked":l=p;break;case "value":f=p;break;case "defaultValue":g=p;break;case "children":case "dangerouslySetInnerHTML":if(null!=p)throw Error(u(137,b));break;default:Z(a,
 b,q,p,c,null)}}Ec(a,f,g,h,l,e,d,!1);xc(a);return;case "select":Y("invalid",a);var q=e=f=null;for(d in c)if(c.hasOwnProperty(d)&&(g=c[d],null!=g))switch(d){case "value":f=g;break;case "defaultValue":e=g;break;case "multiple":q=g;default:Z(a,b,d,g,c,null)}b=f;c=e;a.multiple=!!q;null!=b?Gc(a,!!q,b,!1):null!=c&&Gc(a,!!q,c,!0);return;case "textarea":Y("invalid",a);f=d=q=null;for(e in c)if(c.hasOwnProperty(e)&&(g=c[e],null!=g))switch(e){case "value":q=g;break;case "defaultValue":d=g;break;case "children":f=
-g;break;case "dangerouslySetInnerHTML":if(null!=g)throw Error(t(91));break;default:Z(a,b,e,g,c,null)}Ic(a,q,d,f);xc(a);return;case "option":for(g in c)if(c.hasOwnProperty(g)&&(q=c[g],null!=q))switch(g){case "selected":a.selected=q&&"function"!==typeof q&&"symbol"!==typeof q;break;default:Z(a,b,g,q,c,null)}return;case "dialog":Y("cancel",a);Y("close",a);break;case "iframe":case "object":Y("load",a);break;case "video":case "audio":for(q=0;q<xo.length;q++)Y(xo[q],a);break;case "image":Y("error",a);Y("load",
-a);break;case "details":Y("toggle",a);break;case "embed":case "source":case "img":case "link":Y("error",a),Y("load",a);case "area":case "base":case "br":case "col":case "hr":case "keygen":case "meta":case "param":case "track":case "wbr":case "menuitem":for(h in c)if(c.hasOwnProperty(h)&&(q=c[h],null!=q))switch(h){case "children":case "dangerouslySetInnerHTML":throw Error(t(137,b));default:Z(a,b,h,q,c,null)}return;default:if(Rc(b)){for(l in c)c.hasOwnProperty(l)&&(q=c[l],null!=q&&Jo(a,b,l,q,c,null));
+g;break;case "dangerouslySetInnerHTML":if(null!=g)throw Error(u(91));break;default:Z(a,b,e,g,c,null)}Ic(a,q,d,f);xc(a);return;case "option":for(g in c)if(c.hasOwnProperty(g)&&(q=c[g],null!=q))switch(g){case "selected":a.selected=q&&"function"!==typeof q&&"symbol"!==typeof q;break;default:Z(a,b,g,q,c,null)}return;case "dialog":Y("cancel",a);Y("close",a);break;case "iframe":case "object":Y("load",a);break;case "video":case "audio":for(q=0;q<xo.length;q++)Y(xo[q],a);break;case "image":Y("error",a);Y("load",
+a);break;case "details":Y("toggle",a);break;case "embed":case "source":case "img":case "link":Y("error",a),Y("load",a);case "area":case "base":case "br":case "col":case "hr":case "keygen":case "meta":case "param":case "track":case "wbr":case "menuitem":for(h in c)if(c.hasOwnProperty(h)&&(q=c[h],null!=q))switch(h){case "children":case "dangerouslySetInnerHTML":throw Error(u(137,b));default:Z(a,b,h,q,c,null)}return;default:if(Rc(b)){for(l in c)c.hasOwnProperty(l)&&(q=c[l],null!=q&&Jo(a,b,l,q,c,null));
 return}}for(f in c)c.hasOwnProperty(f)&&(q=c[f],null!=q&&Z(a,b,f,q,c,null))}
-function rk(a,b,c,d){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "input":var e=null,f=null,g=null,h=null,l=null,p=null,q=null;for(u in c){var x=c[u];if(c.hasOwnProperty(u)&&null!=x)switch(u){case "checked":break;case "value":break;case "defaultValue":l=x;default:d.hasOwnProperty(u)||Z(a,b,u,null,d,x)}}for(var r in d){var u=d[r];x=c[r];if(d.hasOwnProperty(r)&&(null!=u||null!=x))switch(r){case "type":f=u;break;case "name":e=u;break;case "checked":p=
-u;break;case "defaultChecked":q=u;break;case "value":g=u;break;case "defaultValue":h=u;break;case "children":case "dangerouslySetInnerHTML":if(null!=u)throw Error(t(137,b));break;default:u!==x&&Z(a,b,r,u,d,x)}}Cc(a,g,h,l,p,q,f,e);return;case "select":u=g=h=r=null;for(f in c)if(l=c[f],c.hasOwnProperty(f)&&null!=l)switch(f){case "value":break;case "multiple":u=l;default:d.hasOwnProperty(f)||Z(a,b,f,null,d,l)}for(e in d)if(f=d[e],l=c[e],d.hasOwnProperty(e)&&(null!=f||null!=l))switch(e){case "value":r=
-f;break;case "defaultValue":h=f;break;case "multiple":g=f;default:f!==l&&Z(a,b,e,f,d,l)}b=h;c=g;d=u;null!=r?Gc(a,!!c,r,!1):!!d!==!!c&&(null!=b?Gc(a,!!c,b,!0):Gc(a,!!c,c?[]:"",!1));return;case "textarea":u=r=null;for(h in c)if(e=c[h],c.hasOwnProperty(h)&&null!=e&&!d.hasOwnProperty(h))switch(h){case "value":break;case "children":break;default:Z(a,b,h,null,d,e)}for(g in d)if(e=d[g],f=c[g],d.hasOwnProperty(g)&&(null!=e||null!=f))switch(g){case "value":r=e;break;case "defaultValue":u=e;break;case "children":break;
-case "dangerouslySetInnerHTML":if(null!=e)throw Error(t(91));break;default:e!==f&&Z(a,b,g,e,d,f)}Hc(a,r,u);return;case "option":for(var A in c)if(r=c[A],c.hasOwnProperty(A)&&null!=r&&!d.hasOwnProperty(A))switch(A){case "selected":a.selected=!1;break;default:Z(a,b,A,null,d,r)}for(l in d)if(r=d[l],u=c[l],d.hasOwnProperty(l)&&r!==u&&(null!=r||null!=u))switch(l){case "selected":a.selected=r&&"function"!==typeof r&&"symbol"!==typeof r;break;default:Z(a,b,l,r,d,u)}return;case "img":case "link":case "area":case "base":case "br":case "col":case "embed":case "hr":case "keygen":case "meta":case "param":case "source":case "track":case "wbr":case "menuitem":for(var C in c)r=
-c[C],c.hasOwnProperty(C)&&null!=r&&!d.hasOwnProperty(C)&&Z(a,b,C,null,d,r);for(p in d)if(r=d[p],u=c[p],d.hasOwnProperty(p)&&r!==u&&(null!=r||null!=u))switch(p){case "children":case "dangerouslySetInnerHTML":if(null!=r)throw Error(t(137,b));break;default:Z(a,b,p,r,d,u)}return;default:if(Rc(b)){for(var J in c)r=c[J],c.hasOwnProperty(J)&&null!=r&&!d.hasOwnProperty(J)&&Jo(a,b,J,null,d,r);for(q in d)r=d[q],u=c[q],!d.hasOwnProperty(q)||r===u||null==r&&null==u||Jo(a,b,q,r,d,u);return}}for(var S in c)r=c[S],
-c.hasOwnProperty(S)&&null!=r&&!d.hasOwnProperty(S)&&Z(a,b,S,null,d,r);for(x in d)r=d[x],u=c[x],!d.hasOwnProperty(x)||r===u||null==r&&null==u||Z(a,b,x,r,d,u)}var Dj=null,Hj=null;function aj(a){return 9===a.nodeType?a:a.ownerDocument}function Ka(a){switch(a){case "http://www.w3.org/2000/svg":return 1;case "http://www.w3.org/1998/Math/MathML":return 2;default:return 0}}
+function rk(a,b,c,d){switch(b){case "div":case "span":case "svg":case "path":case "a":case "g":case "p":case "li":break;case "input":var e=null,f=null,g=null,h=null,l=null,p=null,q=null;for(t in c){var w=c[t];if(c.hasOwnProperty(t)&&null!=w)switch(t){case "checked":break;case "value":break;case "defaultValue":l=w;default:d.hasOwnProperty(t)||Z(a,b,t,null,d,w)}}for(var r in d){var t=d[r];w=c[r];if(d.hasOwnProperty(r)&&(null!=t||null!=w))switch(r){case "type":f=t;break;case "name":e=t;break;case "checked":p=
+t;break;case "defaultChecked":q=t;break;case "value":g=t;break;case "defaultValue":h=t;break;case "children":case "dangerouslySetInnerHTML":if(null!=t)throw Error(u(137,b));break;default:t!==w&&Z(a,b,r,t,d,w)}}Cc(a,g,h,l,p,q,f,e);return;case "select":t=g=h=r=null;for(f in c)if(l=c[f],c.hasOwnProperty(f)&&null!=l)switch(f){case "value":break;case "multiple":t=l;default:d.hasOwnProperty(f)||Z(a,b,f,null,d,l)}for(e in d)if(f=d[e],l=c[e],d.hasOwnProperty(e)&&(null!=f||null!=l))switch(e){case "value":r=
+f;break;case "defaultValue":h=f;break;case "multiple":g=f;default:f!==l&&Z(a,b,e,f,d,l)}b=h;c=g;d=t;null!=r?Gc(a,!!c,r,!1):!!d!==!!c&&(null!=b?Gc(a,!!c,b,!0):Gc(a,!!c,c?[]:"",!1));return;case "textarea":t=r=null;for(h in c)if(e=c[h],c.hasOwnProperty(h)&&null!=e&&!d.hasOwnProperty(h))switch(h){case "value":break;case "children":break;default:Z(a,b,h,null,d,e)}for(g in d)if(e=d[g],f=c[g],d.hasOwnProperty(g)&&(null!=e||null!=f))switch(g){case "value":r=e;break;case "defaultValue":t=e;break;case "children":break;
+case "dangerouslySetInnerHTML":if(null!=e)throw Error(u(91));break;default:e!==f&&Z(a,b,g,e,d,f)}Hc(a,r,t);return;case "option":for(var A in c)if(r=c[A],c.hasOwnProperty(A)&&null!=r&&!d.hasOwnProperty(A))switch(A){case "selected":a.selected=!1;break;default:Z(a,b,A,null,d,r)}for(l in d)if(r=d[l],t=c[l],d.hasOwnProperty(l)&&r!==t&&(null!=r||null!=t))switch(l){case "selected":a.selected=r&&"function"!==typeof r&&"symbol"!==typeof r;break;default:Z(a,b,l,r,d,t)}return;case "img":case "link":case "area":case "base":case "br":case "col":case "embed":case "hr":case "keygen":case "meta":case "param":case "source":case "track":case "wbr":case "menuitem":for(var C in c)r=
+c[C],c.hasOwnProperty(C)&&null!=r&&!d.hasOwnProperty(C)&&Z(a,b,C,null,d,r);for(p in d)if(r=d[p],t=c[p],d.hasOwnProperty(p)&&r!==t&&(null!=r||null!=t))switch(p){case "children":case "dangerouslySetInnerHTML":if(null!=r)throw Error(u(137,b));break;default:Z(a,b,p,r,d,t)}return;default:if(Rc(b)){for(var J in c)r=c[J],c.hasOwnProperty(J)&&null!=r&&!d.hasOwnProperty(J)&&Jo(a,b,J,null,d,r);for(q in d)r=d[q],t=c[q],!d.hasOwnProperty(q)||r===t||null==r&&null==t||Jo(a,b,q,r,d,t);return}}for(var S in c)r=c[S],
+c.hasOwnProperty(S)&&null!=r&&!d.hasOwnProperty(S)&&Z(a,b,S,null,d,r);for(w in d)r=d[w],t=c[w],!d.hasOwnProperty(w)||r===t||null==r&&null==t||Z(a,b,w,r,d,t)}var Dj=null,Hj=null;function aj(a){return 9===a.nodeType?a:a.ownerDocument}function Ka(a){switch(a){case "http://www.w3.org/2000/svg":return 1;case "http://www.w3.org/1998/Math/MathML":return 2;default:return 0}}
 function La(a,b){if(0===a)switch(b){case "svg":return 1;case "math":return 2;default:return 0}return 1===a&&"foreignObject"===b?0:a}function Vd(a,b){return"textarea"===a||"noscript"===a||"string"===typeof b.children||"number"===typeof b.children||"object"===typeof b.dangerouslySetInnerHTML&&null!==b.dangerouslySetInnerHTML&&null!=b.dangerouslySetInnerHTML.__html}var Ko=null;function Df(){var a=window.event;if(a&&"popstate"===a.type){if(a===Ko)return!1;Ko=a;return!0}Ko=null;return!1}
 var gl="function"===typeof setTimeout?setTimeout:void 0,ol="function"===typeof clearTimeout?clearTimeout:void 0,Lo="function"===typeof Promise?Promise:void 0,Gf="function"===typeof queueMicrotask?queueMicrotask:"undefined"!==typeof Lo?function(a){return Lo.resolve(null).then(a).catch(Mo)}:gl;function Mo(a){setTimeout(function(){throw a;})}
 function ek(a,b){var c=b,d=0;do{var e=c.nextSibling;a.removeChild(c);if(e&&8===e.nodeType)if(c=e.data,"/$"===c){if(0===d){a.removeChild(e);fk(b);return}d--}else"$"!==c&&"$?"!==c&&"$!"!==c||d++;c=e}while(c);fk(b)}function Ij(a){var b=a.nodeType;if(9===b)No(a);else if(1===b)switch(a.nodeName){case "HEAD":case "HTML":case "BODY":No(a);break;default:a.textContent=""}}
@@ -416,58 +405,50 @@ a.getAttribute("href")!==(null==e.href?null:e.href)||a.getAttribute("crossorigin
 return a;default:return a}a=Qd(a);if(null===a)break}return null}function Od(a,b,c){if(""===b)return null;for(;3!==a.nodeType;){if((1!==a.nodeType||"INPUT"!==a.nodeName||"hidden"!==a.type)&&!c)return null;a=Qd(a);if(null===a)return null}return a}function Md(a){for(;null!=a;a=a.nextSibling){var b=a.nodeType;if(1===b||3===b)break;if(8===b){b=a.data;if("$"===b||"$!"===b||"$?"===b||"F!"===b||"F"===b)break;if("/$"===b)return null}}return a}function Qd(a){return Md(a.nextSibling)}
 function Zi(a,b,c,d,e){a[Mb]=e;a[Nb]=c;d=0!==(e.mode&1);switch(b){case "dialog":Y("cancel",a);Y("close",a);break;case "iframe":case "object":case "embed":Y("load",a);break;case "video":case "audio":for(e=0;e<xo.length;e++)Y(xo[e],a);break;case "source":Y("error",a);break;case "img":case "image":case "link":Y("error",a);Y("load",a);break;case "details":Y("toggle",a);break;case "input":Y("invalid",a);Ec(a,c.value,c.defaultValue,c.checked,c.defaultChecked,c.type,c.name,!0);xc(a);break;case "select":Y("invalid",
 a);break;case "textarea":Y("invalid",a),Ic(a,c.value,c.defaultValue,c.children),xc(a)}e=c.children;"string"!==typeof e&&"number"!==typeof e||a.textContent===""+e||(!0!==c.suppressHydrationWarning&&cj(a.textContent,e,d),d||"body"===b||(a.textContent=e));null!=c.onScroll&&Y("scroll",a);null!=c.onScrollEnd&&Y("scrollend",a);null!=c.onClick&&(a.onclick=Yj)}
-function Wb(a){a=a.previousSibling;for(var b=0;a;){if(8===a.nodeType){var c=a.data;if("$"===c||"$!"===c||"$?"===c){if(0===b)return a;b--}else"/$"===c&&b++}a=a.previousSibling}return null}function $i(a,b,c){b=aj(c);switch(a){case "html":a=b.documentElement;if(!a)throw Error(t(452));return a;case "head":a=b.head;if(!a)throw Error(t(453));return a;case "body":a=b.body;if(!a)throw Error(t(454));return a;default:throw Error(t(451));}}var Oo=new Map,Po=new Set;
+function Wb(a){a=a.previousSibling;for(var b=0;a;){if(8===a.nodeType){var c=a.data;if("$"===c||"$!"===c||"$?"===c){if(0===b)return a;b--}else"/$"===c&&b++}a=a.previousSibling}return null}function $i(a,b,c){b=aj(c);switch(a){case "html":a=b.documentElement;if(!a)throw Error(u(452));return a;case "head":a=b.head;if(!a)throw Error(u(453));return a;case "body":a=b.body;if(!a)throw Error(u(454));return a;default:throw Error(u(451));}}var Oo=new Map,Po=new Set;
 function tk(a){return"function"===typeof a.getRootNode?a.getRootNode():a.ownerDocument}var Xo={prefetchDNS:Qo,preconnect:Ro,preload:So,preloadModule:To,preinitStyle:Uo,preinitScript:Vo,preinitModuleScript:Wo};
 function Yo(a,b,c){var d=document;if("string"===typeof b&&b){var e=Bc(b);e='link[rel="'+a+'"][href="'+e+'"]';"string"===typeof c&&(e+='[crossorigin="'+c+'"]');Po.has(e)||(Po.add(e),a={rel:a,crossOrigin:c,href:b},null===d.querySelector(e)&&(b=d.createElement("link"),bj(b,"link",a),ac(b),d.head.appendChild(b)))}}function Qo(a){Yo("dns-prefetch",a,null)}function Ro(a,b){Yo("preconnect",a,b)}
-function So(a,b,c){var d=document;if(a&&b&&d){var e='link[rel="preload"][as="'+Bc(b)+'"]';"image"===b?c&&c.imageSrcSet?(e+='[imagesrcset="'+Bc(c.imageSrcSet)+'"]',"string"===typeof c.imageSizes&&(e+='[imagesizes="'+Bc(c.imageSizes)+'"]')):e+='[href="'+Bc(a)+'"]':e+='[href="'+Bc(a)+'"]';var f=e;switch(b){case "style":f=Zo(a);break;case "script":f=$o(a)}Oo.has(f)||(a=w({rel:"preload",href:"image"===b&&c&&c.imageSrcSet?void 0:a,as:b},c),Oo.set(f,a),null!==d.querySelector(e)||"style"===b&&d.querySelector(ap(f))||
+function So(a,b,c){var d=document;if(a&&b&&d){var e='link[rel="preload"][as="'+Bc(b)+'"]';"image"===b?c&&c.imageSrcSet?(e+='[imagesrcset="'+Bc(c.imageSrcSet)+'"]',"string"===typeof c.imageSizes&&(e+='[imagesizes="'+Bc(c.imageSizes)+'"]')):e+='[href="'+Bc(a)+'"]':e+='[href="'+Bc(a)+'"]';var f=e;switch(b){case "style":f=Zo(a);break;case "script":f=$o(a)}Oo.has(f)||(a=x({rel:"preload",href:"image"===b&&c&&c.imageSrcSet?void 0:a,as:b},c),Oo.set(f,a),null!==d.querySelector(e)||"style"===b&&d.querySelector(ap(f))||
 "script"===b&&d.querySelector(bp(f))||(b=d.createElement("link"),bj(b,"link",a),ac(b),d.head.appendChild(b)))}}
-function To(a,b){var c=document;if(a){var d=b&&"string"===typeof b.as?b.as:"script",e='link[rel="modulepreload"][as="'+Bc(d)+'"][href="'+Bc(a)+'"]',f=e;switch(d){case "audioworklet":case "paintworklet":case "serviceworker":case "sharedworker":case "worker":case "script":f=$o(a)}if(!Oo.has(f)&&(a=w({rel:"modulepreload",href:a},b),Oo.set(f,a),null===c.querySelector(e))){switch(d){case "audioworklet":case "paintworklet":case "serviceworker":case "sharedworker":case "worker":case "script":if(c.querySelector(bp(f)))return}d=c.createElement("link");
+function To(a,b){var c=document;if(a){var d=b&&"string"===typeof b.as?b.as:"script",e='link[rel="modulepreload"][as="'+Bc(d)+'"][href="'+Bc(a)+'"]',f=e;switch(d){case "audioworklet":case "paintworklet":case "serviceworker":case "sharedworker":case "worker":case "script":f=$o(a)}if(!Oo.has(f)&&(a=x({rel:"modulepreload",href:a},b),Oo.set(f,a),null===c.querySelector(e))){switch(d){case "audioworklet":case "paintworklet":case "serviceworker":case "sharedworker":case "worker":case "script":if(c.querySelector(bp(f)))return}d=c.createElement("link");
 bj(d,"link",a);ac(d);c.head.appendChild(d)}}}
-function Uo(a,b,c){var d=document;if(a){var e=$b(d).hoistableStyles,f=Zo(a);b=b||"default";var g=e.get(f);if(!g){var h={loading:0,preload:null};if(g=d.querySelector(ap(f)))h.loading=5;else{a=w({rel:"stylesheet",href:a,"data-precedence":b},c);(c=Oo.get(f))&&cp(a,c);var l=g=d.createElement("link");ac(l);bj(l,"link",a);l._p=new Promise(function(p,q){l.onload=p;l.onerror=q});l.addEventListener("load",function(){h.loading|=1});l.addEventListener("error",function(){h.loading|=2});h.loading|=4;dp(g,b,d)}g=
-{type:"stylesheet",instance:g,count:1,state:h};e.set(f,g)}}}function Vo(a,b){var c=document;if(a){var d=$b(c).hoistableScripts,e=$o(a),f=d.get(e);f||(f=c.querySelector(bp(e)),f||(a=w({src:a,async:!0},b),(b=Oo.get(e))&&ep(a,b),f=c.createElement("script"),ac(f),bj(f,"link",a),c.head.appendChild(f)),f={type:"script",instance:f,count:1,state:null},d.set(e,f))}}
-function Wo(a,b){var c=document;if(a){var d=$b(c).hoistableScripts,e=$o(a),f=d.get(e);f||(f=c.querySelector(bp(e)),f||(a=w({src:a,async:!0,type:"module"},b),(b=Oo.get(e))&&ep(a,b),f=c.createElement("script"),ac(f),bj(f,"link",a),c.head.appendChild(f)),f={type:"script",instance:f,count:1,state:null},d.set(e,f))}}
-function Hl(a,b,c){b=(b=Ga.current)?tk(b):null;if(!b)throw Error(t(446));switch(a){case "meta":case "title":return null;case "style":return"string"===typeof c.precedence&&"string"===typeof c.href?(c=Zo(c.href),b=$b(b).hoistableStyles,a=b.get(c),a||(a={type:"style",instance:null,count:0,state:null},b.set(c,a)),a):{type:"void",instance:null,count:0,state:null};case "link":if("stylesheet"===c.rel&&"string"===typeof c.href&&"string"===typeof c.precedence){a=Zo(c.href);var d=$b(b).hoistableStyles,e=d.get(a);
+function Uo(a,b,c){var d=document;if(a){var e=$b(d).hoistableStyles,f=Zo(a);b=b||"default";var g=e.get(f);if(!g){var h={loading:0,preload:null};if(g=d.querySelector(ap(f)))h.loading=5;else{a=x({rel:"stylesheet",href:a,"data-precedence":b},c);(c=Oo.get(f))&&cp(a,c);var l=g=d.createElement("link");ac(l);bj(l,"link",a);l._p=new Promise(function(p,q){l.onload=p;l.onerror=q});l.addEventListener("load",function(){h.loading|=1});l.addEventListener("error",function(){h.loading|=2});h.loading|=4;dp(g,b,d)}g=
+{type:"stylesheet",instance:g,count:1,state:h};e.set(f,g)}}}function Vo(a,b){var c=document;if(a){var d=$b(c).hoistableScripts,e=$o(a),f=d.get(e);f||(f=c.querySelector(bp(e)),f||(a=x({src:a,async:!0},b),(b=Oo.get(e))&&ep(a,b),f=c.createElement("script"),ac(f),bj(f,"link",a),c.head.appendChild(f)),f={type:"script",instance:f,count:1,state:null},d.set(e,f))}}
+function Wo(a,b){var c=document;if(a){var d=$b(c).hoistableScripts,e=$o(a),f=d.get(e);f||(f=c.querySelector(bp(e)),f||(a=x({src:a,async:!0,type:"module"},b),(b=Oo.get(e))&&ep(a,b),f=c.createElement("script"),ac(f),bj(f,"link",a),c.head.appendChild(f)),f={type:"script",instance:f,count:1,state:null},d.set(e,f))}}
+function Hl(a,b,c){b=(b=Ga.current)?tk(b):null;if(!b)throw Error(u(446));switch(a){case "meta":case "title":return null;case "style":return"string"===typeof c.precedence&&"string"===typeof c.href?(c=Zo(c.href),b=$b(b).hoistableStyles,a=b.get(c),a||(a={type:"style",instance:null,count:0,state:null},b.set(c,a)),a):{type:"void",instance:null,count:0,state:null};case "link":if("stylesheet"===c.rel&&"string"===typeof c.href&&"string"===typeof c.precedence){a=Zo(c.href);var d=$b(b).hoistableStyles,e=d.get(a);
 e||(b=b.ownerDocument||b,e={type:"stylesheet",instance:null,count:0,state:{loading:0,preload:null}},d.set(a,e),Oo.has(a)||fp(b,a,{rel:"preload",as:"style",href:c.href,crossOrigin:c.crossOrigin,integrity:c.integrity,media:c.media,hrefLang:c.hrefLang,referrerPolicy:c.referrerPolicy},e.state));return e}return null;case "script":return"string"===typeof c.src&&!0===c.async?(c=$o(c.src),b=$b(b).hoistableScripts,a=b.get(c),a||(a={type:"script",instance:null,count:0,state:null},b.set(c,a)),a):{type:"void",
-instance:null,count:0,state:null};default:throw Error(t(444,a));}}function Zo(a){return'href="'+Bc(a)+'"'}function ap(a){return'link[rel="stylesheet"]['+a+"]"}function gp(a){return w({},a,{"data-precedence":a.precedence,precedence:null})}
+instance:null,count:0,state:null};default:throw Error(u(444,a));}}function Zo(a){return'href="'+Bc(a)+'"'}function ap(a){return'link[rel="stylesheet"]['+a+"]"}function gp(a){return x({},a,{"data-precedence":a.precedence,precedence:null})}
 function fp(a,b,c,d){Oo.set(b,c);a.querySelector(ap(b))||(a.querySelector('link[rel="preload"][as="style"]['+b+"]")?d.loading=1:(b=a.createElement("link"),d.preload=b,b.addEventListener("load",function(){return d.loading|=1}),b.addEventListener("error",function(){return d.loading|=2}),bj(b,"link",c),ac(b),a.head.appendChild(b)))}function $o(a){return'[src="'+Bc(a)+'"]'}function bp(a){return"script[async]"+a}
-function qk(a,b,c){b.count++;if(null===b.instance)switch(b.type){case "style":var d=a.querySelector('style[data-href~="'+Bc(c.href)+'"]');if(d)return b.instance=d,ac(d),d;var e=w({},c,{"data-href":c.href,"data-precedence":c.precedence,href:null,precedence:null});d=(a.ownerDocument||a).createElement("style");ac(d);bj(d,"style",e);dp(d,c.precedence,a);return b.instance=d;case "stylesheet":e=Zo(c.href);var f=a.querySelector(ap(e));if(f)return b.state.loading|=4,b.instance=f,ac(f),f;d=gp(c);(e=Oo.get(e))&&
-cp(d,e);f=(a.ownerDocument||a).createElement("link");ac(f);var g=f;g._p=new Promise(function(h,l){g.onload=h;g.onerror=l});bj(f,"link",d);b.state.loading|=4;dp(f,c.precedence,a);return b.instance=f;case "script":f=$o(c.src);if(e=a.querySelector(bp(f)))return b.instance=e,ac(e),e;d=c;if(e=Oo.get(f))d=w({},c),ep(d,e);a=a.ownerDocument||a;e=a.createElement("script");ac(e);bj(e,"link",d);a.head.appendChild(e);return b.instance=e;case "void":return null;default:throw Error(t(443,b.type));}else"stylesheet"===
+function qk(a,b,c){b.count++;if(null===b.instance)switch(b.type){case "style":var d=a.querySelector('style[data-href~="'+Bc(c.href)+'"]');if(d)return b.instance=d,ac(d),d;var e=x({},c,{"data-href":c.href,"data-precedence":c.precedence,href:null,precedence:null});d=(a.ownerDocument||a).createElement("style");ac(d);bj(d,"style",e);dp(d,c.precedence,a);return b.instance=d;case "stylesheet":e=Zo(c.href);var f=a.querySelector(ap(e));if(f)return b.state.loading|=4,b.instance=f,ac(f),f;d=gp(c);(e=Oo.get(e))&&
+cp(d,e);f=(a.ownerDocument||a).createElement("link");ac(f);var g=f;g._p=new Promise(function(h,l){g.onload=h;g.onerror=l});bj(f,"link",d);b.state.loading|=4;dp(f,c.precedence,a);return b.instance=f;case "script":f=$o(c.src);if(e=a.querySelector(bp(f)))return b.instance=e,ac(e),e;d=c;if(e=Oo.get(f))d=x({},c),ep(d,e);a=a.ownerDocument||a;e=a.createElement("script");ac(e);bj(e,"link",d);a.head.appendChild(e);return b.instance=e;case "void":return null;default:throw Error(u(443,b.type));}else"stylesheet"===
 b.type&&0===(b.state.loading&4)&&(d=b.instance,b.state.loading|=4,dp(d,c.precedence,a));return b.instance}function dp(a,b,c){for(var d=c.querySelectorAll('link[rel="stylesheet"][data-precedence],style[data-precedence]'),e=d.length?d[d.length-1]:null,f=e,g=0;g<d.length;g++){var h=d[g];if(h.dataset.precedence===b)f=h;else if(f!==e)break}f?f.parentNode.insertBefore(a,f.nextSibling):(b=9===c.nodeType?c.head:c,b.insertBefore(a,b.firstChild))}
 function cp(a,b){null==a.crossOrigin&&(a.crossOrigin=b.crossOrigin);null==a.referrerPolicy&&(a.referrerPolicy=b.referrerPolicy);null==a.title&&(a.title=b.title)}function ep(a,b){null==a.crossOrigin&&(a.crossOrigin=b.crossOrigin);null==a.referrerPolicy&&(a.referrerPolicy=b.referrerPolicy);null==a.integrity&&(a.integrity=b.integrity)}var sk=null;
 function ok(a,b,c){if(null===sk){var d=new Map;var e=sk=new Map;e.set(c,d)}else e=sk,d=e.get(c),d||(d=new Map,e.set(c,d));if(d.has(a))return d;d.set(a,null);c=c.getElementsByTagName(a);for(e=0;e<c.length;e++){var f=c[e];if(!(f[Tb]||f[Mb]||"link"===a&&"stylesheet"===f.getAttribute("rel"))&&"http://www.w3.org/2000/svg"!==f.namespaceURI){var g=f.getAttribute(b)||"";g=a+g;var h=d.get(g);h?h.push(f):d.set(g,[f])}}return d}
 function pk(a,b,c){a=a.ownerDocument||a;a.head.insertBefore(c,"title"===b?a.querySelector("head > title"):null)}
 function Jl(a,b,c){if(1===c||null!=b.itemProp)return!1;switch(a){case "meta":case "title":return!0;case "style":if("string"!==typeof b.precedence||"string"!==typeof b.href||""===b.href)break;return!0;case "link":if("string"!==typeof b.rel||"string"!==typeof b.href||""===b.href||b.onLoad||b.onError)break;switch(b.rel){case "stylesheet":return a=b.disabled,"string"===typeof b.precedence&&null==a;default:return!0}case "script":if(!0===b.async&&!b.onLoad&&!b.onError&&"string"===typeof b.src&&b.src)return!0}return!1}
 var il=null;function jl(){}
-function Hk(a,b,c){if(null===il)throw Error(t(475));var d=il;if("stylesheet"===b.type&&("string"!==typeof c.media||!1!==matchMedia(c.media).matches)&&0===(b.state.loading&4)){if(null===b.instance){var e=Zo(c.href),f=a.querySelector(ap(e));if(f){a=f._p;null!==a&&"object"===typeof a&&"function"===typeof a.then&&(d.count++,d=hp.bind(d),a.then(d,d));b.state.loading|=4;b.instance=f;ac(f);return}f=a.ownerDocument||a;c=gp(c);(e=Oo.get(e))&&cp(c,e);f=f.createElement("link");ac(f);var g=f;g._p=new Promise(function(h,
+function Hk(a,b,c){if(null===il)throw Error(u(475));var d=il;if("stylesheet"===b.type&&("string"!==typeof c.media||!1!==matchMedia(c.media).matches)&&0===(b.state.loading&4)){if(null===b.instance){var e=Zo(c.href),f=a.querySelector(ap(e));if(f){a=f._p;null!==a&&"object"===typeof a&&"function"===typeof a.then&&(d.count++,d=hp.bind(d),a.then(d,d));b.state.loading|=4;b.instance=f;ac(f);return}f=a.ownerDocument||a;c=gp(c);(e=Oo.get(e))&&cp(c,e);f=f.createElement("link");ac(f);var g=f;g._p=new Promise(function(h,
 l){g.onload=h;g.onerror=l});bj(f,"link",c);b.instance=f}null===d.stylesheets&&(d.stylesheets=new Map);d.stylesheets.set(b,a);(a=b.state.preload)&&0===(b.state.loading&3)&&(d.count++,b=hp.bind(d),a.addEventListener("load",b),a.addEventListener("error",b))}}
-function kl(){if(null===il)throw Error(t(475));var a=il;a.stylesheets&&0===a.count&&ip(a,a.stylesheets);return 0<a.count?function(b){var c=setTimeout(function(){a.stylesheets&&ip(a,a.stylesheets);if(a.unsuspend){var d=a.unsuspend;a.unsuspend=null;d()}},6E4);a.unsuspend=b;return function(){a.unsuspend=null;clearTimeout(c)}}:null}function hp(){this.count--;if(0===this.count)if(this.stylesheets)ip(this,this.stylesheets);else if(this.unsuspend){var a=this.unsuspend;this.unsuspend=null;a()}}var jp=null;
+function kl(){if(null===il)throw Error(u(475));var a=il;a.stylesheets&&0===a.count&&ip(a,a.stylesheets);return 0<a.count?function(b){var c=setTimeout(function(){a.stylesheets&&ip(a,a.stylesheets);if(a.unsuspend){var d=a.unsuspend;a.unsuspend=null;d()}},6E4);a.unsuspend=b;return function(){a.unsuspend=null;clearTimeout(c)}}:null}function hp(){this.count--;if(0===this.count)if(this.stylesheets)ip(this,this.stylesheets);else if(this.unsuspend){var a=this.unsuspend;this.unsuspend=null;a()}}var jp=null;
 function ip(a,b){a.stylesheets=null;null!==a.unsuspend&&(a.count++,jp=new Map,b.forEach(kp,a),jp=null,hp.call(a))}
 function kp(a,b){if(!(b.state.loading&4)){var c=jp.get(a);if(c)var d=c.get("last");else{c=new Map;jp.set(a,c);for(var e=a.querySelectorAll("link[data-precedence],style[data-precedence]"),f=0;f<e.length;f++){var g=e[f];if("link"===g.nodeName||"not all"!==g.getAttribute("media"))c.set("p"+g.dataset.precedence,g),d=g}d&&c.set("last",d)}e=b.instance;g=e.getAttribute("data-precedence");f=c.get("p"+g)||d;f===d&&c.set("last",e);c.set(g,e);this.count++;d=hp.bind(this);e.addEventListener("load",d);e.addEventListener("error",
-d);f?f.parentNode.insertBefore(e,f.nextSibling):(a=9===a.nodeType?a.head:a,a.insertBefore(e,a.firstChild));b.state.loading|=4}}var lp=ca.Dispatcher;"undefined"!==typeof document&&(lp.current=Xo);var mp="function"===typeof reportError?reportError:function(a){console.error(a)};function np(a){this._internalRoot=a}op.prototype.render=np.prototype.render=function(a){var b=this._internalRoot;if(null===b)throw Error(t(409));Pl(a,b,null,null)};
+d);f?f.parentNode.insertBefore(e,f.nextSibling):(a=9===a.nodeType?a.head:a,a.insertBefore(e,a.firstChild));b.state.loading|=4}}var lp=ca.Dispatcher;"undefined"!==typeof document&&(lp.current=Xo);var mp="function"===typeof reportError?reportError:function(a){console.error(a)};function np(a){this._internalRoot=a}op.prototype.render=np.prototype.render=function(a){var b=this._internalRoot;if(null===b)throw Error(u(409));Pl(a,b,null,null)};
 op.prototype.unmount=np.prototype.unmount=function(){var a=this._internalRoot;if(null!==a){this._internalRoot=null;var b=a.containerInfo;ml(function(){Pl(null,a,null,null)});b[Ob]=null}};function op(a){this._internalRoot=a}op.prototype.unstable_scheduleHydration=function(a){if(a){var b=G;a={blockedOn:null,target:a,priority:b};for(var c=0;c<Tm.length&&0!==b&&b<Tm[c].priority;c++);Tm.splice(c,0,a);0===c&&Ym(a)}};function pp(a){return!(!a||1!==a.nodeType&&9!==a.nodeType&&11!==a.nodeType)}
 function qp(a){return!(!a||1!==a.nodeType&&9!==a.nodeType&&11!==a.nodeType&&(8!==a.nodeType||" react-mount-point-unstable "!==a.nodeValue))}function rp(){}
 function sp(a,b,c,d,e){if(e){if("function"===typeof d){var f=d;d=function(){var p=Ql(g);f.call(p)}}var g=Ol(b,d,a,0,null,!1,!1,"",rp,null,null);a._reactRootContainer=g;a[Ob]=g.current;dj(8===a.nodeType?a.parentNode:a);ml();return g}Ij(a);if("function"===typeof d){var h=d;d=function(){var p=Ql(l);h.call(p)}}var l=Ll(a,0,!1,null,null,!1,!1,"",rp,null,null);a._reactRootContainer=l;a[Ob]=l.current;dj(8===a.nodeType?a.parentNode:a);ml(function(){Pl(b,l,c,d)});return l}
-function tp(a,b,c,d,e){var f=c._reactRootContainer;if(f){var g=f;if("function"===typeof e){var h=e;e=function(){var l=Ql(g);h.call(l)}}Pl(b,g,a,e)}else g=sp(c,b,a,e,d);return Ql(g)}function up(a,b){if("font"===a)return"";if("string"===typeof b)return"use-credentials"===b?b:""}var vp=ca.Dispatcher;ca.Events=[Xb,Yb,Zb,Yc,Zc,ll];var wp={findFiberByHostInstance:Vb,bundleType:0,version:"18.3.0-canary-2983249dd-20231107",rendererPackageName:"react-dom"};
-(function(a){if("undefined"===typeof __REACT_DEVTOOLS_GLOBAL_HOOK__)return!1;var b=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(b.isDisabled||!b.supportsFiber)return!0;try{a=w({},a,{getLaneLabelMap:eb,injectProfilingHooks:db}),$a=b.inject(a),ab=b}catch(c){}return b.checkDCE?!0:!1})({bundleType:wp.bundleType,version:wp.version,rendererPackageName:wp.rendererPackageName,rendererConfig:wp.rendererConfig,overrideHookState:null,overrideHookStateDeletePath:null,overrideHookStateRenamePath:null,overrideProps:null,
-overridePropsDeletePath:null,overridePropsRenamePath:null,setErrorHandler:null,setSuspenseHandler:null,scheduleUpdate:null,currentDispatcherRef:da.ReactCurrentDispatcher,findHostInstanceByFiber:function(a){a=dd(a);return null===a?null:a.stateNode},findFiberByHostInstance:wp.findFiberByHostInstance||Vl,findHostInstancesForRefresh:null,scheduleRefresh:null,scheduleRoot:null,setRefreshHandler:null,getCurrentFiber:null,reconcilerVersion:"18.3.0-canary-2983249dd-20231107"});
-exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=ca;exports.createPortal=function(a,b){var c=2<arguments.length&&void 0!==arguments[2]?arguments[2]:null;if(!pp(b))throw Error(t(200));return Ml(a,b,null,c)};
-exports.createRoot=function(a,b){if(!pp(a))throw Error(t(299));var c=!1,d="",e=mp,f=null;null!==b&&void 0!==b&&(!0===b.unstable_strictMode&&(c=!0),void 0!==b.identifierPrefix&&(d=b.identifierPrefix),void 0!==b.onRecoverableError&&(e=b.onRecoverableError),void 0!==b.unstable_transitionCallbacks&&(f=b.unstable_transitionCallbacks));b=Ll(a,1,!1,null,null,c,!1,d,e,f,null);a[Ob]=b.current;lp.current=Xo;dj(8===a.nodeType?a.parentNode:a);return new np(b)};
-exports.findDOMNode=function(a){if(null==a)return null;if(1===a.nodeType)return a;var b=a._reactInternals;if(void 0===b){if("function"===typeof a.render)throw Error(t(188));a=Object.keys(a).join(",");throw Error(t(268,a));}a=dd(b);a=null===a?null:a.stateNode;return a};exports.flushSync=function(a){return ml(a)};exports.hydrate=function(a,b,c){if(!qp(b))throw Error(t(200));return tp(null,a,b,!0,c)};
-exports.hydrateRoot=function(a,b,c){if(!pp(a))throw Error(t(405));var d=!1,e="",f=mp,g=null,h=null;null!==c&&void 0!==c&&(!0===c.unstable_strictMode&&(d=!0),void 0!==c.identifierPrefix&&(e=c.identifierPrefix),void 0!==c.onRecoverableError&&(f=c.onRecoverableError),void 0!==c.unstable_transitionCallbacks&&(g=c.unstable_transitionCallbacks),void 0!==c.formState&&(h=c.formState));b=Ol(b,null,a,1,null!=c?c:null,d,!1,e,f,g,h);a[Ob]=b.current;lp.current=Xo;dj(a);return new op(b)};
+function tp(a,b,c,d,e){var f=c._reactRootContainer;if(f){var g=f;if("function"===typeof e){var h=e;e=function(){var l=Ql(g);h.call(l)}}Pl(b,g,a,e)}else g=sp(c,b,a,e,d);return Ql(g)}function up(a,b){if("font"===a)return"";if("string"===typeof b)return"use-credentials"===b?b:""}var vp=ca.Dispatcher;ca.Events=[Xb,Yb,Zb,Yc,Zc,ll];var wp={findFiberByHostInstance:Vb,bundleType:0,version:"18.3.0-canary-7508dcd5c-20231108",rendererPackageName:"react-dom"};
+(function(a){if("undefined"===typeof __REACT_DEVTOOLS_GLOBAL_HOOK__)return!1;var b=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(b.isDisabled||!b.supportsFiber)return!0;try{a=x({},a,{getLaneLabelMap:eb,injectProfilingHooks:db}),$a=b.inject(a),ab=b}catch(c){}return b.checkDCE?!0:!1})({bundleType:wp.bundleType,version:wp.version,rendererPackageName:wp.rendererPackageName,rendererConfig:wp.rendererConfig,overrideHookState:null,overrideHookStateDeletePath:null,overrideHookStateRenamePath:null,overrideProps:null,
+overridePropsDeletePath:null,overridePropsRenamePath:null,setErrorHandler:null,setSuspenseHandler:null,scheduleUpdate:null,currentDispatcherRef:da.ReactCurrentDispatcher,findHostInstanceByFiber:function(a){a=dd(a);return null===a?null:a.stateNode},findFiberByHostInstance:wp.findFiberByHostInstance||Vl,findHostInstancesForRefresh:null,scheduleRefresh:null,scheduleRoot:null,setRefreshHandler:null,getCurrentFiber:null,reconcilerVersion:"18.3.0-canary-7508dcd5c-20231108"});
+exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=ca;exports.createPortal=function(a,b){var c=2<arguments.length&&void 0!==arguments[2]?arguments[2]:null;if(!pp(b))throw Error(u(200));return Ml(a,b,null,c)};
+exports.createRoot=function(a,b){if(!pp(a))throw Error(u(299));var c=!1,d="",e=mp,f=null;null!==b&&void 0!==b&&(!0===b.unstable_strictMode&&(c=!0),void 0!==b.identifierPrefix&&(d=b.identifierPrefix),void 0!==b.onRecoverableError&&(e=b.onRecoverableError),void 0!==b.unstable_transitionCallbacks&&(f=b.unstable_transitionCallbacks));b=Ll(a,1,!1,null,null,c,!1,d,e,f,null);a[Ob]=b.current;lp.current=Xo;dj(8===a.nodeType?a.parentNode:a);return new np(b)};
+exports.findDOMNode=function(a){if(null==a)return null;if(1===a.nodeType)return a;var b=a._reactInternals;if(void 0===b){if("function"===typeof a.render)throw Error(u(188));a=Object.keys(a).join(",");throw Error(u(268,a));}a=dd(b);a=null===a?null:a.stateNode;return a};exports.flushSync=function(a){return ml(a)};exports.hydrate=function(a,b,c){if(!qp(b))throw Error(u(200));return tp(null,a,b,!0,c)};
+exports.hydrateRoot=function(a,b,c){if(!pp(a))throw Error(u(405));var d=!1,e="",f=mp,g=null,h=null;null!==c&&void 0!==c&&(!0===c.unstable_strictMode&&(d=!0),void 0!==c.identifierPrefix&&(e=c.identifierPrefix),void 0!==c.onRecoverableError&&(f=c.onRecoverableError),void 0!==c.unstable_transitionCallbacks&&(g=c.unstable_transitionCallbacks),void 0!==c.formState&&(h=c.formState));b=Ol(b,null,a,1,null!=c?c:null,d,!1,e,f,g,h);a[Ob]=b.current;lp.current=Xo;dj(a);return new op(b)};
 exports.preconnect=function(a,b){var c=vp.current;c&&"string"===typeof a&&(b?(b=b.crossOrigin,b="string"===typeof b?"use-credentials"===b?b:"":void 0):b=null,c.preconnect(a,b))};exports.prefetchDNS=function(a){var b=vp.current;b&&"string"===typeof a&&b.prefetchDNS(a)};
 exports.preinit=function(a,b){var c=vp.current;if(c&&"string"===typeof a&&b&&"string"===typeof b.as){var d=b.as,e=up(d,b.crossOrigin),f="string"===typeof b.integrity?b.integrity:void 0,g="string"===typeof b.fetchPriority?b.fetchPriority:void 0;"style"===d?c.preinitStyle(a,"string"===typeof b.precedence?b.precedence:void 0,{crossOrigin:e,integrity:f,fetchPriority:g}):"script"===d&&c.preinitScript(a,{crossOrigin:e,integrity:f,fetchPriority:g,nonce:"string"===typeof b.nonce?b.nonce:void 0})}};
 exports.preinitModule=function(a,b){var c=vp.current;if(c&&"string"===typeof a)if("object"===typeof b&&null!==b){if(null==b.as||"script"===b.as){var d=up(b.as,b.crossOrigin);c.preinitModuleScript(a,{crossOrigin:d,integrity:"string"===typeof b.integrity?b.integrity:void 0,nonce:"string"===typeof b.nonce?b.nonce:void 0})}}else null==b&&c.preinitModuleScript(a)};
 exports.preload=function(a,b){var c=vp.current;if(c&&"string"===typeof a&&"object"===typeof b&&null!==b&&"string"===typeof b.as){var d=b.as,e=up(d,b.crossOrigin);c.preload(a,d,{crossOrigin:e,integrity:"string"===typeof b.integrity?b.integrity:void 0,nonce:"string"===typeof b.nonce?b.nonce:void 0,type:"string"===typeof b.type?b.type:void 0,fetchPriority:"string"===typeof b.fetchPriority?b.fetchPriority:void 0,referrerPolicy:"string"===typeof b.referrerPolicy?b.referrerPolicy:void 0,imageSrcSet:"string"===
-typeof b.imageSrcSet?b.imageSrcSet:void 0,imageSizes:"string"===typeof b.imageSizes?b.imageSizes:void 0})}};exports.preloadModule=function(a,b){var c=vp.current;if(c&&"string"===typeof a)if(b){var d=up(b.as,b.crossOrigin);c.preloadModule(a,{as:"string"===typeof b.as&&"script"!==b.as?b.as:void 0,crossOrigin:d,integrity:"string"===typeof b.integrity?b.integrity:void 0})}else c.preloadModule(a)};exports.render=function(a,b,c){if(!qp(b))throw Error(t(200));return tp(null,a,b,!1,c)};
-exports.unmountComponentAtNode=function(a){if(!qp(a))throw Error(t(40));return a._reactRootContainer?(ml(function(){tp(null,null,a,!1,function(){a._reactRootContainer=null;a[Ob]=null})}),!0):!1};exports.unstable_batchedUpdates=ll;exports.unstable_renderSubtreeIntoContainer=function(a,b,c,d){if(!qp(c))throw Error(t(200));if(null==a||void 0===a._reactInternals)throw Error(t(38));return tp(a,b,c,!1,d)};exports.useFormState=function(a,b,c){return ea.current.useFormState(a,b,c)};
-exports.useFormStatus=function(){return ea.current.useHostTransitionStatus()};exports.version="18.3.0-canary-2983249dd-20231107";
+typeof b.imageSrcSet?b.imageSrcSet:void 0,imageSizes:"string"===typeof b.imageSizes?b.imageSizes:void 0})}};exports.preloadModule=function(a,b){var c=vp.current;if(c&&"string"===typeof a)if(b){var d=up(b.as,b.crossOrigin);c.preloadModule(a,{as:"string"===typeof b.as&&"script"!==b.as?b.as:void 0,crossOrigin:d,integrity:"string"===typeof b.integrity?b.integrity:void 0})}else c.preloadModule(a)};exports.render=function(a,b,c){if(!qp(b))throw Error(u(200));return tp(null,a,b,!1,c)};
+exports.unmountComponentAtNode=function(a){if(!qp(a))throw Error(u(40));return a._reactRootContainer?(ml(function(){tp(null,null,a,!1,function(){a._reactRootContainer=null;a[Ob]=null})}),!0):!1};exports.unstable_batchedUpdates=ll;exports.unstable_renderSubtreeIntoContainer=function(a,b,c,d){if(!qp(c))throw Error(u(200));if(null==a||void 0===a._reactInternals)throw Error(u(38));return tp(a,b,c,!1,d)};exports.useFormState=function(a,b,c){return ea.current.useFormState(a,b,c)};
+exports.useFormStatus=function(){return ea.current.useHostTransitionStatus()};exports.version="18.3.0-canary-7508dcd5c-20231108";"undefined"!==typeof __REACT_DEVTOOLS_GLOBAL_HOOK__&&"function"===typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop&&__REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
 
-          /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
-if (
-  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
-  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
-    'function'
-) {
-  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
-}
-        
+//# sourceMappingURL=react-dom.profiling.min.js.map
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom.shared-subset.production.js b/packages/next/src/compiled/react-dom/cjs/react-dom.shared-subset.production.js
new file mode 100644
index 0000000000000..1b81aca57e482
--- /dev/null
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom.shared-subset.production.js
@@ -0,0 +1,164 @@
+/**
+ * @license React
+ * react-dom.shared-subset.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+const Internals = {
+  usingClientEntryPoint: false,
+  Events: null,
+  Dispatcher: {
+    current: null
+  }
+};
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+function getCrossOriginStringAs(as, input) {
+  if (as === 'font') {
+    return '';
+  }
+
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+const Dispatcher = Internals.Dispatcher;
+function prefetchDNS(href) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    dispatcher.prefetchDNS(href);
+  } // We don't error because preconnect needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preconnect(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    const crossOrigin = options ? getCrossOriginString(options.crossOrigin) : null;
+    dispatcher.preconnect(href, crossOrigin);
+  } // We don't error because preconnect needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preload(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string' && // We check existence because we cannot enforce this function is actually called with the stated type
+  typeof options === 'object' && options !== null && typeof options.as === 'string') {
+    const as = options.as;
+    const crossOrigin = getCrossOriginStringAs(as, options.crossOrigin);
+    dispatcher.preload(href, as, {
+      crossOrigin,
+      integrity: typeof options.integrity === 'string' ? options.integrity : undefined,
+      nonce: typeof options.nonce === 'string' ? options.nonce : undefined,
+      type: typeof options.type === 'string' ? options.type : undefined,
+      fetchPriority: typeof options.fetchPriority === 'string' ? options.fetchPriority : undefined,
+      referrerPolicy: typeof options.referrerPolicy === 'string' ? options.referrerPolicy : undefined,
+      imageSrcSet: typeof options.imageSrcSet === 'string' ? options.imageSrcSet : undefined,
+      imageSizes: typeof options.imageSizes === 'string' ? options.imageSizes : undefined
+    });
+  } // We don't error because preload needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preloadModule(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    if (options) {
+      const crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);
+      dispatcher.preloadModule(href, {
+        as: typeof options.as === 'string' && options.as !== 'script' ? options.as : undefined,
+        crossOrigin,
+        integrity: typeof options.integrity === 'string' ? options.integrity : undefined
+      });
+    } else {
+      dispatcher.preloadModule(href);
+    }
+  } // We don't error because preload needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preinit(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string' && options && typeof options.as === 'string') {
+    const as = options.as;
+    const crossOrigin = getCrossOriginStringAs(as, options.crossOrigin);
+    const integrity = typeof options.integrity === 'string' ? options.integrity : undefined;
+    const fetchPriority = typeof options.fetchPriority === 'string' ? options.fetchPriority : undefined;
+
+    if (as === 'style') {
+      dispatcher.preinitStyle(href, typeof options.precedence === 'string' ? options.precedence : undefined, {
+        crossOrigin,
+        integrity,
+        fetchPriority
+      });
+    } else if (as === 'script') {
+      dispatcher.preinitScript(href, {
+        crossOrigin,
+        integrity,
+        fetchPriority,
+        nonce: typeof options.nonce === 'string' ? options.nonce : undefined
+      });
+    }
+  } // We don't error because preinit needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+function preinitModule(href, options) {
+
+  const dispatcher = Dispatcher.current;
+
+  if (dispatcher && typeof href === 'string') {
+    if (typeof options === 'object' && options !== null) {
+      if (options.as == null || options.as === 'script') {
+        const crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);
+        dispatcher.preinitModuleScript(href, {
+          crossOrigin,
+          integrity: typeof options.integrity === 'string' ? options.integrity : undefined,
+          nonce: typeof options.nonce === 'string' ? options.nonce : undefined
+        });
+      }
+    } else if (options == null) {
+      dispatcher.preinitModuleScript(href);
+    }
+  } // We don't error because preinit needs to be resilient to being called in a variety of scopes
+  // and the runtime may not be capable of responding. The function is optimistic and not critical
+  // so we favor silent bailout over warning or erroring.
+
+}
+
+exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = Internals;
+exports.preconnect = preconnect;
+exports.prefetchDNS = prefetchDNS;
+exports.preinit = preinit;
+exports.preinitModule = preinitModule;
+exports.preload = preload;
+exports.preloadModule = preloadModule;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-dom/cjs/react-dom.shared-subset.production.min.js b/packages/next/src/compiled/react-dom/cjs/react-dom.shared-subset.production.min.js
index c784b4f423903..5000c6fc89faf 100644
--- a/packages/next/src/compiled/react-dom/cjs/react-dom.shared-subset.production.min.js
+++ b/packages/next/src/compiled/react-dom/cjs/react-dom.shared-subset.production.min.js
@@ -1,15 +1,17 @@
-/**
- * @license React
- * react-dom.shared-subset.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-dom.shared-subset.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var e={usingClientEntryPoint:!1,Events:null,Dispatcher:{current:null}};function f(b,a){if("font"===b)return"";if("string"===typeof a)return"use-credentials"===a?a:""}var h=e.Dispatcher;exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=e;exports.preconnect=function(b,a){var c=h.current;c&&"string"===typeof b&&(a?(a=a.crossOrigin,a="string"===typeof a?"use-credentials"===a?a:"":void 0):a=null,c.preconnect(b,a))};
 exports.prefetchDNS=function(b){var a=h.current;a&&"string"===typeof b&&a.prefetchDNS(b)};
 exports.preinit=function(b,a){var c=h.current;if(c&&"string"===typeof b&&a&&"string"===typeof a.as){var d=a.as,g=f(d,a.crossOrigin),k="string"===typeof a.integrity?a.integrity:void 0,l="string"===typeof a.fetchPriority?a.fetchPriority:void 0;"style"===d?c.preinitStyle(b,"string"===typeof a.precedence?a.precedence:void 0,{crossOrigin:g,integrity:k,fetchPriority:l}):"script"===d&&c.preinitScript(b,{crossOrigin:g,integrity:k,fetchPriority:l,nonce:"string"===typeof a.nonce?a.nonce:void 0})}};
 exports.preinitModule=function(b,a){var c=h.current;if(c&&"string"===typeof b)if("object"===typeof a&&null!==a){if(null==a.as||"script"===a.as){var d=f(a.as,a.crossOrigin);c.preinitModuleScript(b,{crossOrigin:d,integrity:"string"===typeof a.integrity?a.integrity:void 0,nonce:"string"===typeof a.nonce?a.nonce:void 0})}}else null==a&&c.preinitModuleScript(b)};
 exports.preload=function(b,a){var c=h.current;if(c&&"string"===typeof b&&"object"===typeof a&&null!==a&&"string"===typeof a.as){var d=a.as,g=f(d,a.crossOrigin);c.preload(b,d,{crossOrigin:g,integrity:"string"===typeof a.integrity?a.integrity:void 0,nonce:"string"===typeof a.nonce?a.nonce:void 0,type:"string"===typeof a.type?a.type:void 0,fetchPriority:"string"===typeof a.fetchPriority?a.fetchPriority:void 0,referrerPolicy:"string"===typeof a.referrerPolicy?a.referrerPolicy:void 0,imageSrcSet:"string"===
 typeof a.imageSrcSet?a.imageSrcSet:void 0,imageSizes:"string"===typeof a.imageSizes?a.imageSizes:void 0})}};exports.preloadModule=function(b,a){var c=h.current;if(c&&"string"===typeof b)if(a){var d=f(a.as,a.crossOrigin);c.preloadModule(b,{as:"string"===typeof a.as&&"script"!==a.as?a.as:void 0,crossOrigin:d,integrity:"string"===typeof a.integrity?a.integrity:void 0})}else c.preloadModule(b)};
+
+//# sourceMappingURL=react-dom.shared-subset.production.min.js.map
diff --git a/packages/next/src/compiled/react-dom/package.json b/packages/next/src/compiled/react-dom/package.json
index 01a94f1a9b8aa..a0a8792cf0bef 100644
--- a/packages/next/src/compiled/react-dom/package.json
+++ b/packages/next/src/compiled/react-dom/package.json
@@ -41,10 +41,10 @@
   },
   "dependencies": {
     "loose-envify": "^1.1.0",
-    "scheduler": "0.24.0-canary-2983249dd-20231107"
+    "scheduler": "0.24.0-canary-7508dcd5c-20231108"
   },
   "peerDependencies": {
-    "react": "18.3.0-canary-2983249dd-20231107"
+    "react": "18.3.0-canary-7508dcd5c-20231108"
   },
   "browser": {
     "./server.js": "./server.browser.js",
diff --git a/packages/next/src/compiled/react-experimental/cjs/react-jsx-dev-runtime.development.js b/packages/next/src/compiled/react-experimental/cjs/react-jsx-dev-runtime.development.js
index 137ed097fe752..bb07b153308f4 100644
--- a/packages/next/src/compiled/react-experimental/cjs/react-jsx-dev-runtime.development.js
+++ b/packages/next/src/compiled/react-experimental/cjs/react-jsx-dev-runtime.development.js
@@ -356,6 +356,18 @@ var componentFrameCache;
   var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
   componentFrameCache = new PossiblyWeakMap();
 }
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
@@ -371,7 +383,6 @@ function describeNativeComponentFrame(fn, construct) {
     }
   }
 
-  var control;
   reentry = true;
   var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
 
@@ -385,81 +396,140 @@ function describeNativeComponentFrame(fn, construct) {
     ReactCurrentDispatcher.current = null;
     disableLogs();
   }
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
+
+
+  var RunInRootFrame = {
+    DetermineComponentFrameRoot: function () {
+      var control;
 
-  try {
-    // This should throw.
-    if (construct) {
-      // Something should be setting the props in the constructor.
-      var Fake = function () {
-        throw Error();
-      }; // $FlowFixMe[prop-missing]
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          var Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
+
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
 
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
 
-      Object.defineProperty(Fake.prototype, 'props', {
-        set: function () {
-          // We use a throwing setter instead of frozen or non-writable props
-          // because that won't throw in a non-strict mode function.
-          throw Error();
-        }
-      });
 
-      if (typeof Reflect === 'object' && Reflect.construct) {
-        // We construct a different control for this case to include any extra
-        // frames added by the construct call.
-        try {
-          Reflect.construct(Fake, []);
-        } catch (x) {
-          control = x;
-        }
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
 
-        Reflect.construct(fn, [], Fake);
-      } else {
-        try {
-          Fake.call();
-        } catch (x) {
-          control = x;
-        } // $FlowFixMe[prop-missing] found when upgrading Flow
 
+          var maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
 
-        fn.call(Fake.prototype);
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(function () {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
       }
-    } else {
-      try {
-        throw Error();
-      } catch (x) {
-        control = x;
-      } // TODO(luna): This will currently only throw if the function component
-      // tries to access React/ReactDOM/props. We should probably make this throw
-      // in simple components too
 
+      return [null, null];
+    }
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
 
-      var maybePromise = fn(); // If the function component returns a promise, it's likely an async
-      // component, which we don't yet support. Attach a noop catch handler to
-      // silence the error.
-      // TODO: Implement component stacks for async client components?
+  try {
+    var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
 
-      if (maybePromise && typeof maybePromise.catch === 'function') {
-        maybePromise.catch(function () {});
-      }
-    }
-  } catch (sample) {
-    // This is inlined manually because closure doesn't do it for us.
-    if (sample && control && typeof sample.stack === 'string') {
+    if (sampleStack && controlStack) {
       // This extracts the first frame from the sample that isn't also in the control.
       // Skipping one frame that we assume is the frame that calls the two.
-      var sampleLines = sample.stack.split('\n');
-      var controlLines = control.stack.split('\n');
-      var s = sampleLines.length - 1;
-      var c = controlLines.length - 1;
-
-      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
-        // We expect at least one stack frame to be shared.
-        // Typically this will be the root most one. However, stack frames may be
-        // cut off due to maximum stack limits. In this case, one maybe cut off
-        // earlier than the other. We assume that the sample is longer or the same
-        // and there for cut off earlier. So we should find the root most frame in
-        // the sample somewhere in the control.
-        c--;
+      var sampleLines = sampleStack.split('\n');
+      var controlLines = controlStack.split('\n');
+      var s = 0;
+      var c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
       }
 
       for (; s >= 1 && c >= 0; s--, c--) {
@@ -488,7 +558,7 @@ function describeNativeComponentFrame(fn, construct) {
                   _frame = _frame.replace('<anonymous>', fn.displayName);
                 }
 
-                {
+                if (true) {
                   if (typeof fn === 'function') {
                     componentFrameCache.set(fn, _frame);
                   }
diff --git a/packages/next/src/compiled/react-experimental/cjs/react-jsx-dev-runtime.production.js b/packages/next/src/compiled/react-experimental/cjs/react-jsx-dev-runtime.production.js
new file mode 100644
index 0000000000000..ac19aaf473d40
--- /dev/null
+++ b/packages/next/src/compiled/react-experimental/cjs/react-jsx-dev-runtime.production.js
@@ -0,0 +1,18 @@
+/**
+ * @license React
+ * react-jsx-dev-runtime.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+// ATTENTION
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+
+const jsxDEV = undefined;
+
+exports.Fragment = REACT_FRAGMENT_TYPE;
+exports.jsxDEV = jsxDEV;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-experimental/cjs/react-jsx-dev-runtime.production.min.js b/packages/next/src/compiled/react-experimental/cjs/react-jsx-dev-runtime.production.min.js
index c242817c5c8dc..c2da84bbaa687 100644
--- a/packages/next/src/compiled/react-experimental/cjs/react-jsx-dev-runtime.production.min.js
+++ b/packages/next/src/compiled/react-experimental/cjs/react-jsx-dev-runtime.production.min.js
@@ -1,10 +1,12 @@
-/**
- * @license React
- * react-jsx-dev-runtime.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-jsx-dev-runtime.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var a=Symbol.for("react.fragment");exports.Fragment=a;exports.jsxDEV=void 0;
+
+//# sourceMappingURL=react-jsx-dev-runtime.production.min.js.map
diff --git a/packages/next/src/compiled/react-experimental/cjs/react-jsx-dev-runtime.profiling.js b/packages/next/src/compiled/react-experimental/cjs/react-jsx-dev-runtime.profiling.js
new file mode 100644
index 0000000000000..d26abc62ad2cb
--- /dev/null
+++ b/packages/next/src/compiled/react-experimental/cjs/react-jsx-dev-runtime.profiling.js
@@ -0,0 +1,18 @@
+/**
+ * @license React
+ * react-jsx-dev-runtime.profiling.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+// ATTENTION
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+
+const jsxDEV = undefined;
+
+exports.Fragment = REACT_FRAGMENT_TYPE;
+exports.jsxDEV = jsxDEV;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-experimental/cjs/react-jsx-dev-runtime.profiling.min.js b/packages/next/src/compiled/react-experimental/cjs/react-jsx-dev-runtime.profiling.min.js
index aad106163bd89..2029bbb579bd7 100644
--- a/packages/next/src/compiled/react-experimental/cjs/react-jsx-dev-runtime.profiling.min.js
+++ b/packages/next/src/compiled/react-experimental/cjs/react-jsx-dev-runtime.profiling.min.js
@@ -1,10 +1,12 @@
-/**
- * @license React
- * react-jsx-dev-runtime.profiling.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-jsx-dev-runtime.profiling.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var a=Symbol.for("react.fragment");exports.Fragment=a;exports.jsxDEV=void 0;
+
+//# sourceMappingURL=react-jsx-dev-runtime.profiling.min.js.map
diff --git a/packages/next/src/compiled/react-experimental/cjs/react-jsx-runtime.development.js b/packages/next/src/compiled/react-experimental/cjs/react-jsx-runtime.development.js
index a6fb0c6a7d768..d9af434e37f88 100644
--- a/packages/next/src/compiled/react-experimental/cjs/react-jsx-runtime.development.js
+++ b/packages/next/src/compiled/react-experimental/cjs/react-jsx-runtime.development.js
@@ -356,6 +356,18 @@ var componentFrameCache;
   var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
   componentFrameCache = new PossiblyWeakMap();
 }
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
@@ -371,7 +383,6 @@ function describeNativeComponentFrame(fn, construct) {
     }
   }
 
-  var control;
   reentry = true;
   var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
 
@@ -385,81 +396,140 @@ function describeNativeComponentFrame(fn, construct) {
     ReactCurrentDispatcher.current = null;
     disableLogs();
   }
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
+
+
+  var RunInRootFrame = {
+    DetermineComponentFrameRoot: function () {
+      var control;
 
-  try {
-    // This should throw.
-    if (construct) {
-      // Something should be setting the props in the constructor.
-      var Fake = function () {
-        throw Error();
-      }; // $FlowFixMe[prop-missing]
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          var Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
+
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
 
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
 
-      Object.defineProperty(Fake.prototype, 'props', {
-        set: function () {
-          // We use a throwing setter instead of frozen or non-writable props
-          // because that won't throw in a non-strict mode function.
-          throw Error();
-        }
-      });
 
-      if (typeof Reflect === 'object' && Reflect.construct) {
-        // We construct a different control for this case to include any extra
-        // frames added by the construct call.
-        try {
-          Reflect.construct(Fake, []);
-        } catch (x) {
-          control = x;
-        }
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
 
-        Reflect.construct(fn, [], Fake);
-      } else {
-        try {
-          Fake.call();
-        } catch (x) {
-          control = x;
-        } // $FlowFixMe[prop-missing] found when upgrading Flow
 
+          var maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
 
-        fn.call(Fake.prototype);
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(function () {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
       }
-    } else {
-      try {
-        throw Error();
-      } catch (x) {
-        control = x;
-      } // TODO(luna): This will currently only throw if the function component
-      // tries to access React/ReactDOM/props. We should probably make this throw
-      // in simple components too
 
+      return [null, null];
+    }
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
 
-      var maybePromise = fn(); // If the function component returns a promise, it's likely an async
-      // component, which we don't yet support. Attach a noop catch handler to
-      // silence the error.
-      // TODO: Implement component stacks for async client components?
+  try {
+    var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
 
-      if (maybePromise && typeof maybePromise.catch === 'function') {
-        maybePromise.catch(function () {});
-      }
-    }
-  } catch (sample) {
-    // This is inlined manually because closure doesn't do it for us.
-    if (sample && control && typeof sample.stack === 'string') {
+    if (sampleStack && controlStack) {
       // This extracts the first frame from the sample that isn't also in the control.
       // Skipping one frame that we assume is the frame that calls the two.
-      var sampleLines = sample.stack.split('\n');
-      var controlLines = control.stack.split('\n');
-      var s = sampleLines.length - 1;
-      var c = controlLines.length - 1;
-
-      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
-        // We expect at least one stack frame to be shared.
-        // Typically this will be the root most one. However, stack frames may be
-        // cut off due to maximum stack limits. In this case, one maybe cut off
-        // earlier than the other. We assume that the sample is longer or the same
-        // and there for cut off earlier. So we should find the root most frame in
-        // the sample somewhere in the control.
-        c--;
+      var sampleLines = sampleStack.split('\n');
+      var controlLines = controlStack.split('\n');
+      var s = 0;
+      var c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
       }
 
       for (; s >= 1 && c >= 0; s--, c--) {
@@ -488,7 +558,7 @@ function describeNativeComponentFrame(fn, construct) {
                   _frame = _frame.replace('<anonymous>', fn.displayName);
                 }
 
-                {
+                if (true) {
                   if (typeof fn === 'function') {
                     componentFrameCache.set(fn, _frame);
                   }
diff --git a/packages/next/src/compiled/react-experimental/cjs/react-jsx-runtime.production.js b/packages/next/src/compiled/react-experimental/cjs/react-jsx-runtime.production.js
new file mode 100644
index 0000000000000..7ca5a0efd814b
--- /dev/null
+++ b/packages/next/src/compiled/react-experimental/cjs/react-jsx-runtime.production.js
@@ -0,0 +1,142 @@
+/**
+ * @license React
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require("next/dist/compiled/react-experimental");
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+const ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
+const RESERVED_PROPS = {
+  key: true,
+  ref: true,
+  __self: true,
+  __source: true
+};
+
+function hasValidRef(config) {
+
+  return config.ref !== undefined;
+}
+
+function hasValidKey(config) {
+
+  return config.key !== undefined;
+}
+/**
+ * Factory method to create a new React element. This no longer adheres to
+ * the class pattern, so do not use new to call it. Also, instanceof check
+ * will not work. Instead test $$typeof field against Symbol.for('react.element') to check
+ * if something is a React Element.
+ *
+ * @param {*} type
+ * @param {*} props
+ * @param {*} key
+ * @param {string|object} ref
+ * @param {*} owner
+ * @param {*} self A *temporary* helper to detect places where `this` is
+ * different from the `owner` when React.createElement is called, so that we
+ * can warn. We want to get rid of owner and replace string `ref`s with arrow
+ * functions, and as long as `this` and owner are the same, there will be no
+ * change in behavior.
+ * @param {*} source An annotation object (added by a transpiler or otherwise)
+ * indicating filename, line number, and/or other information.
+ * @internal
+ */
+
+
+function ReactElement(type, key, ref, self, source, owner, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type,
+    key,
+    ref,
+    props,
+    // Record the component responsible for creating this element.
+    _owner: owner
+  };
+
+  return element;
+}
+/**
+ * https://github.com/reactjs/rfcs/pull/107
+ * @param {*} type
+ * @param {object} props
+ * @param {string} key
+ */
+
+
+function jsx$1(type, config, maybeKey) {
+  let propName; // Reserved names are extracted
+
+  const props = {};
+  let key = null;
+  let ref = null; // Currently, key can be spread in as a prop. This causes a potential
+  // issue if key is also explicitly declared (ie. <div {...props} key="Hi" />
+  // or <div key="Hi" {...props} /> ). We want to deprecate key spread,
+  // but as an intermediary step, we will use jsxDEV for everything except
+  // <div {...props} key="Hi" />, because we aren't currently able to tell if
+  // key is explicitly declared to be undefined or not.
+
+  if (maybeKey !== undefined) {
+
+    key = '' + maybeKey;
+  }
+
+  if (hasValidKey(config)) {
+
+    key = '' + config.key;
+  }
+
+  if (hasValidRef(config)) {
+    ref = config.ref;
+  } // Remaining properties are added to a new props object
+
+
+  for (propName in config) {
+    if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+      props[propName] = config[propName];
+    }
+  } // Resolve default props
+
+
+  if (type && type.defaultProps) {
+    const defaultProps = type.defaultProps;
+
+    for (propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+  }
+
+  return ReactElement(type, key, ref, undefined, undefined, ReactCurrentOwner.current, props);
+}
+
+const jsx = jsx$1; // we may want to special case jsxs internally to take advantage of static children.
+// for now we can ship identical prod functions
+
+const jsxs = jsx$1;
+
+exports.Fragment = REACT_FRAGMENT_TYPE;
+exports.jsx = jsx;
+exports.jsxs = jsxs;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-experimental/cjs/react-jsx-runtime.production.min.js b/packages/next/src/compiled/react-experimental/cjs/react-jsx-runtime.production.min.js
index 789512436d200..0ccc38036d44b 100644
--- a/packages/next/src/compiled/react-experimental/cjs/react-jsx-runtime.production.min.js
+++ b/packages/next/src/compiled/react-experimental/cjs/react-jsx-runtime.production.min.js
@@ -1,11 +1,13 @@
-/**
- * @license React
- * react-jsx-runtime.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-jsx-runtime.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var f=require("next/dist/compiled/react-experimental"),k=Symbol.for("react.element"),l=Symbol.for("react.fragment"),m=Object.prototype.hasOwnProperty,n=f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,p={key:!0,ref:!0,__self:!0,__source:!0};
 function q(c,a,g){var b,d={},e=null,h=null;void 0!==g&&(e=""+g);void 0!==a.key&&(e=""+a.key);void 0!==a.ref&&(h=a.ref);for(b in a)m.call(a,b)&&!p.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return{$$typeof:k,type:c,key:e,ref:h,props:d,_owner:n.current}}exports.Fragment=l;exports.jsx=q;exports.jsxs=q;
+
+//# sourceMappingURL=react-jsx-runtime.production.min.js.map
diff --git a/packages/next/src/compiled/react-experimental/cjs/react-jsx-runtime.profiling.js b/packages/next/src/compiled/react-experimental/cjs/react-jsx-runtime.profiling.js
new file mode 100644
index 0000000000000..286785dc290ee
--- /dev/null
+++ b/packages/next/src/compiled/react-experimental/cjs/react-jsx-runtime.profiling.js
@@ -0,0 +1,142 @@
+/**
+ * @license React
+ * react-jsx-runtime.profiling.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require("next/dist/compiled/react-experimental");
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+const ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
+const RESERVED_PROPS = {
+  key: true,
+  ref: true,
+  __self: true,
+  __source: true
+};
+
+function hasValidRef(config) {
+
+  return config.ref !== undefined;
+}
+
+function hasValidKey(config) {
+
+  return config.key !== undefined;
+}
+/**
+ * Factory method to create a new React element. This no longer adheres to
+ * the class pattern, so do not use new to call it. Also, instanceof check
+ * will not work. Instead test $$typeof field against Symbol.for('react.element') to check
+ * if something is a React Element.
+ *
+ * @param {*} type
+ * @param {*} props
+ * @param {*} key
+ * @param {string|object} ref
+ * @param {*} owner
+ * @param {*} self A *temporary* helper to detect places where `this` is
+ * different from the `owner` when React.createElement is called, so that we
+ * can warn. We want to get rid of owner and replace string `ref`s with arrow
+ * functions, and as long as `this` and owner are the same, there will be no
+ * change in behavior.
+ * @param {*} source An annotation object (added by a transpiler or otherwise)
+ * indicating filename, line number, and/or other information.
+ * @internal
+ */
+
+
+function ReactElement(type, key, ref, self, source, owner, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type,
+    key,
+    ref,
+    props,
+    // Record the component responsible for creating this element.
+    _owner: owner
+  };
+
+  return element;
+}
+/**
+ * https://github.com/reactjs/rfcs/pull/107
+ * @param {*} type
+ * @param {object} props
+ * @param {string} key
+ */
+
+
+function jsx$1(type, config, maybeKey) {
+  let propName; // Reserved names are extracted
+
+  const props = {};
+  let key = null;
+  let ref = null; // Currently, key can be spread in as a prop. This causes a potential
+  // issue if key is also explicitly declared (ie. <div {...props} key="Hi" />
+  // or <div key="Hi" {...props} /> ). We want to deprecate key spread,
+  // but as an intermediary step, we will use jsxDEV for everything except
+  // <div {...props} key="Hi" />, because we aren't currently able to tell if
+  // key is explicitly declared to be undefined or not.
+
+  if (maybeKey !== undefined) {
+
+    key = '' + maybeKey;
+  }
+
+  if (hasValidKey(config)) {
+
+    key = '' + config.key;
+  }
+
+  if (hasValidRef(config)) {
+    ref = config.ref;
+  } // Remaining properties are added to a new props object
+
+
+  for (propName in config) {
+    if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+      props[propName] = config[propName];
+    }
+  } // Resolve default props
+
+
+  if (type && type.defaultProps) {
+    const defaultProps = type.defaultProps;
+
+    for (propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+  }
+
+  return ReactElement(type, key, ref, undefined, undefined, ReactCurrentOwner.current, props);
+}
+
+const jsx = jsx$1; // we may want to special case jsxs internally to take advantage of static children.
+// for now we can ship identical prod functions
+
+const jsxs = jsx$1;
+
+exports.Fragment = REACT_FRAGMENT_TYPE;
+exports.jsx = jsx;
+exports.jsxs = jsxs;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-experimental/cjs/react-jsx-runtime.profiling.min.js b/packages/next/src/compiled/react-experimental/cjs/react-jsx-runtime.profiling.min.js
index 5aeb73baa6743..c7fbee5ae8237 100644
--- a/packages/next/src/compiled/react-experimental/cjs/react-jsx-runtime.profiling.min.js
+++ b/packages/next/src/compiled/react-experimental/cjs/react-jsx-runtime.profiling.min.js
@@ -1,11 +1,13 @@
-/**
- * @license React
- * react-jsx-runtime.profiling.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-jsx-runtime.profiling.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var f=require("next/dist/compiled/react-experimental"),k=Symbol.for("react.element"),l=Symbol.for("react.fragment"),m=Object.prototype.hasOwnProperty,n=f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,p={key:!0,ref:!0,__self:!0,__source:!0};
 function q(c,a,g){var b,d={},e=null,h=null;void 0!==g&&(e=""+g);void 0!==a.key&&(e=""+a.key);void 0!==a.ref&&(h=a.ref);for(b in a)m.call(a,b)&&!p.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return{$$typeof:k,type:c,key:e,ref:h,props:d,_owner:n.current}}exports.Fragment=l;exports.jsx=q;exports.jsxs=q;
+
+//# sourceMappingURL=react-jsx-runtime.profiling.min.js.map
diff --git a/packages/next/src/compiled/react-experimental/cjs/react.development.js b/packages/next/src/compiled/react-experimental/cjs/react.development.js
index bd835b915815d..a964e65c0e535 100644
--- a/packages/next/src/compiled/react-experimental/cjs/react.development.js
+++ b/packages/next/src/compiled/react-experimental/cjs/react.development.js
@@ -188,7 +188,7 @@ function printWarning(level, format, args) {
   }
 }
 
-var ReactVersion = '18.3.0-experimental-2983249dd-20231107';
+var ReactVersion = '18.3.0-experimental-7508dcd5c-20231108';
 
 // ATTENTION
 // When adding new symbols to this file,
@@ -1990,6 +1990,18 @@ var componentFrameCache;
   var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
   componentFrameCache = new PossiblyWeakMap();
 }
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
@@ -2005,7 +2017,6 @@ function describeNativeComponentFrame(fn, construct) {
     }
   }
 
-  var control;
   reentry = true;
   var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
 
@@ -2019,81 +2030,140 @@ function describeNativeComponentFrame(fn, construct) {
     ReactCurrentDispatcher.current = null;
     disableLogs();
   }
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
 
-  try {
-    // This should throw.
-    if (construct) {
-      // Something should be setting the props in the constructor.
-      var Fake = function () {
-        throw Error();
-      }; // $FlowFixMe[prop-missing]
 
+  var RunInRootFrame = {
+    DetermineComponentFrameRoot: function () {
+      var control;
 
-      Object.defineProperty(Fake.prototype, 'props', {
-        set: function () {
-          // We use a throwing setter instead of frozen or non-writable props
-          // because that won't throw in a non-strict mode function.
-          throw Error();
-        }
-      });
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          var Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
 
-      if (typeof Reflect === 'object' && Reflect.construct) {
-        // We construct a different control for this case to include any extra
-        // frames added by the construct call.
-        try {
-          Reflect.construct(Fake, []);
-        } catch (x) {
-          control = x;
-        }
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
 
-        Reflect.construct(fn, [], Fake);
-      } else {
-        try {
-          Fake.call();
-        } catch (x) {
-          control = x;
-        } // $FlowFixMe[prop-missing] found when upgrading Flow
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
 
 
-        fn.call(Fake.prototype);
-      }
-    } else {
-      try {
-        throw Error();
-      } catch (x) {
-        control = x;
-      } // TODO(luna): This will currently only throw if the function component
-      // tries to access React/ReactDOM/props. We should probably make this throw
-      // in simple components too
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
 
 
-      var maybePromise = fn(); // If the function component returns a promise, it's likely an async
-      // component, which we don't yet support. Attach a noop catch handler to
-      // silence the error.
-      // TODO: Implement component stacks for async client components?
+          var maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
 
-      if (maybePromise && typeof maybePromise.catch === 'function') {
-        maybePromise.catch(function () {});
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(function () {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
       }
+
+      return [null, null];
     }
-  } catch (sample) {
-    // This is inlined manually because closure doesn't do it for us.
-    if (sample && control && typeof sample.stack === 'string') {
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
+
+  try {
+    var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
+
+    if (sampleStack && controlStack) {
       // This extracts the first frame from the sample that isn't also in the control.
       // Skipping one frame that we assume is the frame that calls the two.
-      var sampleLines = sample.stack.split('\n');
-      var controlLines = control.stack.split('\n');
-      var s = sampleLines.length - 1;
-      var c = controlLines.length - 1;
-
-      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
-        // We expect at least one stack frame to be shared.
-        // Typically this will be the root most one. However, stack frames may be
-        // cut off due to maximum stack limits. In this case, one maybe cut off
-        // earlier than the other. We assume that the sample is longer or the same
-        // and there for cut off earlier. So we should find the root most frame in
-        // the sample somewhere in the control.
-        c--;
+      var sampleLines = sampleStack.split('\n');
+      var controlLines = controlStack.split('\n');
+      var s = 0;
+      var c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
       }
 
       for (; s >= 1 && c >= 0; s--, c--) {
@@ -2122,7 +2192,7 @@ function describeNativeComponentFrame(fn, construct) {
                   _frame = _frame.replace('<anonymous>', fn.displayName);
                 }
 
-                {
+                if (true) {
                   if (typeof fn === 'function') {
                     componentFrameCache.set(fn, _frame);
                   }
diff --git a/packages/next/src/compiled/react-experimental/cjs/react.production.js b/packages/next/src/compiled/react-experimental/cjs/react.production.js
new file mode 100644
index 0000000000000..3eba1018bfb6b
--- /dev/null
+++ b/packages/next/src/compiled/react-experimental/cjs/react.production.js
@@ -0,0 +1,1227 @@
+/**
+ * @license React
+ * react.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var ReactVersion = '18.3.0-experimental-7508dcd5c-20231108';
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+const REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_CONTEXT_TYPE = Symbol.for('react.context');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');
+const REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+const REACT_CACHE_TYPE = Symbol.for('react.cache');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+/**
+ * This is the abstract API for an update queue.
+ */
+
+
+const ReactNoopUpdateQueue = {
+  /**
+   * Checks whether or not this composite component is mounted.
+   * @param {ReactClass} publicInstance The instance we want to test.
+   * @return {boolean} True if mounted, false otherwise.
+   * @protected
+   * @final
+   */
+  isMounted: function (publicInstance) {
+    return false;
+  },
+
+  /**
+   * Forces an update. This should only be invoked when it is known with
+   * certainty that we are **not** in a DOM transaction.
+   *
+   * You may want to call this when you know that some deeper aspect of the
+   * component's state has changed but `setState` was not called.
+   *
+   * This will not invoke `shouldComponentUpdate`, but it will invoke
+   * `componentWillUpdate` and `componentDidUpdate`.
+   *
+   * @param {ReactClass} publicInstance The instance that should rerender.
+   * @param {?function} callback Called after component is updated.
+   * @param {?string} callerName name of the calling function in the public API.
+   * @internal
+   */
+  enqueueForceUpdate: function (publicInstance, callback, callerName) {
+  },
+
+  /**
+   * Replaces all of the state. Always use this or `setState` to mutate state.
+   * You should treat `this.state` as immutable.
+   *
+   * There is no guarantee that `this.state` will be immediately updated, so
+   * accessing `this.state` after calling this method may return the old value.
+   *
+   * @param {ReactClass} publicInstance The instance that should rerender.
+   * @param {object} completeState Next state.
+   * @param {?function} callback Called after component is updated.
+   * @param {?string} callerName name of the calling function in the public API.
+   * @internal
+   */
+  enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {
+  },
+
+  /**
+   * Sets a subset of the state. This only exists because _pendingState is
+   * internal. This provides a merging strategy that is not available to deep
+   * properties which is confusing. TODO: Expose pendingState or don't use it
+   * during the merge.
+   *
+   * @param {ReactClass} publicInstance The instance that should rerender.
+   * @param {object} partialState Next partial state to be merged with state.
+   * @param {?function} callback Called after component is updated.
+   * @param {?string} Name of the calling function in the public API.
+   * @internal
+   */
+  enqueueSetState: function (publicInstance, partialState, callback, callerName) {
+  }
+};
+
+const assign = Object.assign;
+
+const emptyObject = {};
+/**
+ * Base class helpers for the updating state of a component.
+ */
+
+
+function Component(props, context, updater) {
+  this.props = props;
+  this.context = context; // If a component has string refs, we will assign a different object later.
+
+  this.refs = emptyObject; // We initialize the default updater but the real one gets injected by the
+  // renderer.
+
+  this.updater = updater || ReactNoopUpdateQueue;
+}
+
+Component.prototype.isReactComponent = {};
+/**
+ * Sets a subset of the state. Always use this to mutate
+ * state. You should treat `this.state` as immutable.
+ *
+ * There is no guarantee that `this.state` will be immediately updated, so
+ * accessing `this.state` after calling this method may return the old value.
+ *
+ * There is no guarantee that calls to `setState` will run synchronously,
+ * as they may eventually be batched together.  You can provide an optional
+ * callback that will be executed when the call to setState is actually
+ * completed.
+ *
+ * When a function is provided to setState, it will be called at some point in
+ * the future (not synchronously). It will be called with the up to date
+ * component arguments (state, props, context). These values can be different
+ * from this.* because your function may be called after receiveProps but before
+ * shouldComponentUpdate, and this new state, props, and context will not yet be
+ * assigned to this.
+ *
+ * @param {object|function} partialState Next partial state or function to
+ *        produce next partial state to be merged with current state.
+ * @param {?function} callback Called after state is updated.
+ * @final
+ * @protected
+ */
+
+Component.prototype.setState = function (partialState, callback) {
+  if (typeof partialState !== 'object' && typeof partialState !== 'function' && partialState != null) {
+    throw new Error('setState(...): takes an object of state variables to update or a ' + 'function which returns an object of state variables.');
+  }
+
+  this.updater.enqueueSetState(this, partialState, callback, 'setState');
+};
+/**
+ * Forces an update. This should only be invoked when it is known with
+ * certainty that we are **not** in a DOM transaction.
+ *
+ * You may want to call this when you know that some deeper aspect of the
+ * component's state has changed but `setState` was not called.
+ *
+ * This will not invoke `shouldComponentUpdate`, but it will invoke
+ * `componentWillUpdate` and `componentDidUpdate`.
+ *
+ * @param {?function} callback Called after update is complete.
+ * @final
+ * @protected
+ */
+
+
+Component.prototype.forceUpdate = function (callback) {
+  this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');
+};
+
+function ComponentDummy() {}
+
+ComponentDummy.prototype = Component.prototype;
+/**
+ * Convenience component with default shallow equality check for sCU.
+ */
+
+function PureComponent(props, context, updater) {
+  this.props = props;
+  this.context = context; // If a component has string refs, we will assign a different object later.
+
+  this.refs = emptyObject;
+  this.updater = updater || ReactNoopUpdateQueue;
+}
+
+const pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
+pureComponentPrototype.constructor = PureComponent; // Avoid an extra prototype jump for these methods.
+
+assign(pureComponentPrototype, Component.prototype);
+pureComponentPrototype.isPureReactComponent = true;
+
+// an immutable object with a single mutable value
+function createRef() {
+  const refObject = {
+    current: null
+  };
+
+  return refObject;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/**
+ * Keeps track of the current owner.
+ *
+ * The current owner is the component who should own any components that are
+ * currently being constructed.
+ */
+const ReactCurrentOwner = {
+  /**
+   * @internal
+   * @type {ReactComponent}
+   */
+  current: null
+};
+
+const RESERVED_PROPS = {
+  key: true,
+  ref: true,
+  __self: true,
+  __source: true
+};
+
+function hasValidRef(config) {
+
+  return config.ref !== undefined;
+}
+
+function hasValidKey(config) {
+
+  return config.key !== undefined;
+}
+/**
+ * Factory method to create a new React element. This no longer adheres to
+ * the class pattern, so do not use new to call it. Also, instanceof check
+ * will not work. Instead test $$typeof field against Symbol.for('react.element') to check
+ * if something is a React Element.
+ *
+ * @param {*} type
+ * @param {*} props
+ * @param {*} key
+ * @param {string|object} ref
+ * @param {*} owner
+ * @param {*} self A *temporary* helper to detect places where `this` is
+ * different from the `owner` when React.createElement is called, so that we
+ * can warn. We want to get rid of owner and replace string `ref`s with arrow
+ * functions, and as long as `this` and owner are the same, there will be no
+ * change in behavior.
+ * @param {*} source An annotation object (added by a transpiler or otherwise)
+ * indicating filename, line number, and/or other information.
+ * @internal
+ */
+
+
+function ReactElement(type, key, ref, self, source, owner, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: ref,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: owner
+  };
+
+  return element;
+}
+/**
+ * Create and return a new ReactElement of the given type.
+ * See https://reactjs.org/docs/react-api.html#createelement
+ */
+
+function createElement$1(type, config, children) {
+  let propName; // Reserved names are extracted
+
+  const props = {};
+  let key = null;
+  let ref = null;
+  let self = null;
+  let source = null;
+
+  if (config != null) {
+    if (hasValidRef(config)) {
+      ref = config.ref;
+    }
+
+    if (hasValidKey(config)) {
+
+      key = '' + config.key;
+    }
+
+    self = config.__self === undefined ? null : config.__self;
+    source = config.__source === undefined ? null : config.__source; // Remaining properties are added to a new props object
+
+    for (propName in config) {
+      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+        props[propName] = config[propName];
+      }
+    }
+  } // Children can be more than one argument, and those are transferred onto
+  // the newly allocated props object.
+
+
+  const childrenLength = arguments.length - 2;
+
+  if (childrenLength === 1) {
+    props.children = children;
+  } else if (childrenLength > 1) {
+    const childArray = Array(childrenLength);
+
+    for (let i = 0; i < childrenLength; i++) {
+      childArray[i] = arguments[i + 2];
+    }
+
+    props.children = childArray;
+  } // Resolve default props
+
+
+  if (type && type.defaultProps) {
+    const defaultProps = type.defaultProps;
+
+    for (propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+  }
+
+  return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
+}
+/**
+ * Return a function that produces ReactElements of a given type.
+ * See https://reactjs.org/docs/react-api.html#createfactory
+ */
+
+function createFactory$1(type) {
+  const factory = createElement$1.bind(null, type); // Expose the type on the factory and the prototype so that it can be
+  // easily accessed on elements. E.g. `<Foo />.type === Foo`.
+  // This should not be named `constructor` since this may not be the function
+  // that created the element, and it may not even be a constructor.
+  // Legacy hook: remove it
+
+  factory.type = type;
+  return factory;
+}
+function cloneAndReplaceKey(oldElement, newKey) {
+  const newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
+  return newElement;
+}
+/**
+ * Clone and return a new ReactElement using element as the starting point.
+ * See https://reactjs.org/docs/react-api.html#cloneelement
+ */
+
+function cloneElement$1(element, config, children) {
+  if (element === null || element === undefined) {
+    throw new Error("React.cloneElement(...): The argument must be a React element, but you passed " + element + ".");
+  }
+
+  let propName; // Original props are copied
+
+  const props = assign({}, element.props); // Reserved names are extracted
+
+  let key = element.key;
+  let ref = element.ref; // Self is preserved since the owner is preserved.
+
+  const self = element._self; // Source is preserved since cloneElement is unlikely to be targeted by a
+  // transpiler, and the original source is probably a better indicator of the
+  // true owner.
+
+  const source = element._source; // Owner will be preserved, unless ref is overridden
+
+  let owner = element._owner;
+
+  if (config != null) {
+    if (hasValidRef(config)) {
+      // Silently steal the ref from the parent.
+      ref = config.ref;
+      owner = ReactCurrentOwner.current;
+    }
+
+    if (hasValidKey(config)) {
+
+      key = '' + config.key;
+    } // Remaining properties override existing props
+
+
+    let defaultProps;
+
+    if (element.type && element.type.defaultProps) {
+      defaultProps = element.type.defaultProps;
+    }
+
+    for (propName in config) {
+      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+        if (config[propName] === undefined && defaultProps !== undefined) {
+          // Resolve default props
+          props[propName] = defaultProps[propName];
+        } else {
+          props[propName] = config[propName];
+        }
+      }
+    }
+  } // Children can be more than one argument, and those are transferred onto
+  // the newly allocated props object.
+
+
+  const childrenLength = arguments.length - 2;
+
+  if (childrenLength === 1) {
+    props.children = children;
+  } else if (childrenLength > 1) {
+    const childArray = Array(childrenLength);
+
+    for (let i = 0; i < childrenLength; i++) {
+      childArray[i] = arguments[i + 2];
+    }
+
+    props.children = childArray;
+  }
+
+  return ReactElement(element.type, key, ref, self, source, owner, props);
+}
+/**
+ * Verifies the object is a ReactElement.
+ * See https://reactjs.org/docs/react-api.html#isvalidelement
+ * @param {?object} object
+ * @return {boolean} True if `object` is a ReactElement.
+ * @final
+ */
+
+function isValidElement(object) {
+  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+}
+
+const SEPARATOR = '.';
+const SUBSEPARATOR = ':';
+/**
+ * Escape and wrap key so it is safe to use as a reactid
+ *
+ * @param {string} key to be escaped.
+ * @return {string} the escaped key.
+ */
+
+function escape(key) {
+  const escapeRegex = /[=:]/g;
+  const escaperLookup = {
+    '=': '=0',
+    ':': '=2'
+  };
+  const escapedString = key.replace(escapeRegex, function (match) {
+    return escaperLookup[match];
+  });
+  return '$' + escapedString;
+}
+const userProvidedKeyEscapeRegex = /\/+/g;
+
+function escapeUserProvidedKey(text) {
+  return text.replace(userProvidedKeyEscapeRegex, '$&/');
+}
+/**
+ * Generate a key string that identifies a element within a set.
+ *
+ * @param {*} element A element that could contain a manual key.
+ * @param {number} index Index that is used if a manual key is not provided.
+ * @return {string}
+ */
+
+
+function getElementKey(element, index) {
+  // Do some typechecking here since we call this blindly. We want to ensure
+  // that we don't block potential future ES APIs.
+  if (typeof element === 'object' && element !== null && element.key != null) {
+
+    return escape('' + element.key);
+  } // Implicit key determined by the index in the set
+
+
+  return index.toString(36);
+}
+
+function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
+  const type = typeof children;
+
+  if (type === 'undefined' || type === 'boolean') {
+    // All of the above are perceived as null.
+    children = null;
+  }
+
+  let invokeCallback = false;
+
+  if (children === null) {
+    invokeCallback = true;
+  } else {
+    switch (type) {
+      case 'string':
+      case 'number':
+        invokeCallback = true;
+        break;
+
+      case 'object':
+        switch (children.$$typeof) {
+          case REACT_ELEMENT_TYPE:
+          case REACT_PORTAL_TYPE:
+            invokeCallback = true;
+        }
+
+    }
+  }
+
+  if (invokeCallback) {
+    const child = children;
+    let mappedChild = callback(child); // If it's the only child, treat the name as if it was wrapped in an array
+    // so that it's consistent if the number of children grows:
+
+    const childKey = nameSoFar === '' ? SEPARATOR + getElementKey(child, 0) : nameSoFar;
+
+    if (isArray(mappedChild)) {
+      let escapedChildKey = '';
+
+      if (childKey != null) {
+        escapedChildKey = escapeUserProvidedKey(childKey) + '/';
+      }
+
+      mapIntoArray(mappedChild, array, escapedChildKey, '', c => c);
+    } else if (mappedChild != null) {
+      if (isValidElement(mappedChild)) {
+
+        mappedChild = cloneAndReplaceKey(mappedChild, // Keep both the (mapped) and old keys if they differ, just as
+        // traverseAllChildren used to do for objects as children
+        escapedPrefix + ( // $FlowFixMe[incompatible-type] Flow incorrectly thinks React.Portal doesn't have a key
+        mappedChild.key && (!child || child.key !== mappedChild.key) ? escapeUserProvidedKey( // $FlowFixMe[unsafe-addition]
+        '' + mappedChild.key // eslint-disable-line react-internal/safe-string-coercion
+        ) + '/' : '') + childKey);
+      }
+
+      array.push(mappedChild);
+    }
+
+    return 1;
+  }
+
+  let child;
+  let nextName;
+  let subtreeCount = 0; // Count of children found in the current subtree.
+
+  const nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;
+
+  if (isArray(children)) {
+    for (let i = 0; i < children.length; i++) {
+      child = children[i];
+      nextName = nextNamePrefix + getElementKey(child, i);
+      subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
+    }
+  } else {
+    const iteratorFn = getIteratorFn(children);
+
+    if (typeof iteratorFn === 'function') {
+      const iterableChildren = children;
+
+      const iterator = iteratorFn.call(iterableChildren);
+      let step;
+      let ii = 0; // $FlowFixMe[incompatible-use] `iteratorFn` might return null according to typing.
+
+      while (!(step = iterator.next()).done) {
+        child = step.value;
+        nextName = nextNamePrefix + getElementKey(child, ii++);
+        subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
+      }
+    } else if (type === 'object') {
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      const childrenString = String(children);
+      throw new Error("Objects are not valid as a React child (found: " + (childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString) + "). " + 'If you meant to render a collection of children, use an array ' + 'instead.');
+    }
+  }
+
+  return subtreeCount;
+}
+/**
+ * Maps children that are typically specified as `props.children`.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrenmap
+ *
+ * The provided mapFunction(child, index) will be called for each
+ * leaf child.
+ *
+ * @param {?*} children Children tree container.
+ * @param {function(*, int)} func The map function.
+ * @param {*} context Context for mapFunction.
+ * @return {object} Object containing the ordered map of results.
+ */
+
+
+function mapChildren(children, func, context) {
+  if (children == null) {
+    return children;
+  }
+
+  const result = [];
+  let count = 0;
+  mapIntoArray(children, result, '', '', function (child) {
+    return func.call(context, child, count++);
+  });
+  return result;
+}
+/**
+ * Count the number of children that are typically specified as
+ * `props.children`.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrencount
+ *
+ * @param {?*} children Children tree container.
+ * @return {number} The number of children.
+ */
+
+
+function countChildren(children) {
+  let n = 0;
+  mapChildren(children, () => {
+    n++; // Don't return anything
+  });
+  return n;
+}
+/**
+ * Iterates through children that are typically specified as `props.children`.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrenforeach
+ *
+ * The provided forEachFunc(child, index) will be called for each
+ * leaf child.
+ *
+ * @param {?*} children Children tree container.
+ * @param {function(*, int)} forEachFunc
+ * @param {*} forEachContext Context for forEachContext.
+ */
+
+
+function forEachChildren(children, forEachFunc, forEachContext) {
+  mapChildren(children, // $FlowFixMe[missing-this-annot]
+  function () {
+    forEachFunc.apply(this, arguments); // Don't return anything.
+  }, forEachContext);
+}
+/**
+ * Flatten a children object (typically specified as `props.children`) and
+ * return an array with appropriately re-keyed children.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrentoarray
+ */
+
+
+function toArray(children) {
+  return mapChildren(children, child => child) || [];
+}
+/**
+ * Returns the first child in a collection of children and verifies that there
+ * is only one child in the collection.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrenonly
+ *
+ * The current implementation of this function assumes that a single child gets
+ * passed without a wrapper, but the purpose of this helper function is to
+ * abstract away the particular structure of children.
+ *
+ * @param {?object} children Child collection structure.
+ * @return {ReactElement} The first and only `ReactElement` contained in the
+ * structure.
+ */
+
+
+function onlyChild(children) {
+  if (!isValidElement(children)) {
+    throw new Error('React.Children.only expected to receive a single React element child.');
+  }
+
+  return children;
+}
+
+function createContext(defaultValue) {
+  // TODO: Second argument used to be an optional `calculateChangedBits`
+  // function. Warn to reserve for future use?
+  const context = {
+    $$typeof: REACT_CONTEXT_TYPE,
+    // As a workaround to support multiple concurrent renderers, we categorize
+    // some renderers as primary and others as secondary. We only expect
+    // there to be two concurrent renderers at most: React Native (primary) and
+    // Fabric (secondary); React DOM (primary) and React ART (secondary).
+    // Secondary renderers store their context values on separate fields.
+    _currentValue: defaultValue,
+    _currentValue2: defaultValue,
+    // Used to track how many concurrent renderers this context currently
+    // supports within in a single renderer. Such as parallel server rendering.
+    _threadCount: 0,
+    // These are circular
+    Provider: null,
+    Consumer: null,
+    // Add these to use same hidden class in VM as ServerContext
+    _defaultValue: null,
+    _globalName: null
+  };
+  context.Provider = {
+    $$typeof: REACT_PROVIDER_TYPE,
+    _context: context
+  };
+
+  {
+    context.Consumer = context;
+  }
+
+  return context;
+}
+
+const Uninitialized = -1;
+const Pending = 0;
+const Resolved = 1;
+const Rejected = 2;
+
+function lazyInitializer(payload) {
+  if (payload._status === Uninitialized) {
+    const ctor = payload._result;
+    const thenable = ctor(); // Transition to the next state.
+    // This might throw either because it's missing or throws. If so, we treat it
+    // as still uninitialized and try again next time. Which is the same as what
+    // happens if the ctor or any wrappers processing the ctor throws. This might
+    // end up fixing it if the resolution was a concurrency bug.
+
+    thenable.then(moduleObject => {
+      if (payload._status === Pending || payload._status === Uninitialized) {
+        // Transition to the next state.
+        const resolved = payload;
+        resolved._status = Resolved;
+        resolved._result = moduleObject;
+      }
+    }, error => {
+      if (payload._status === Pending || payload._status === Uninitialized) {
+        // Transition to the next state.
+        const rejected = payload;
+        rejected._status = Rejected;
+        rejected._result = error;
+      }
+    });
+
+    if (payload._status === Uninitialized) {
+      // In case, we're still uninitialized, then we're waiting for the thenable
+      // to resolve. Set it as pending in the meantime.
+      const pending = payload;
+      pending._status = Pending;
+      pending._result = thenable;
+    }
+  }
+
+  if (payload._status === Resolved) {
+    const moduleObject = payload._result;
+
+    return moduleObject.default;
+  } else {
+    throw payload._result;
+  }
+}
+
+function lazy(ctor) {
+  const payload = {
+    // We use these fields to store the result.
+    _status: Uninitialized,
+    _result: ctor
+  };
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: payload,
+    _init: lazyInitializer
+  };
+
+  return lazyType;
+}
+
+function forwardRef(render) {
+
+  const elementType = {
+    $$typeof: REACT_FORWARD_REF_TYPE,
+    render
+  };
+
+  return elementType;
+}
+
+function memo(type, compare) {
+
+  const elementType = {
+    $$typeof: REACT_MEMO_TYPE,
+    type,
+    compare: compare === undefined ? null : compare
+  };
+
+  return elementType;
+}
+
+/**
+ * Keeps track of the current Cache dispatcher.
+ */
+const ReactCurrentCache = {
+  current: null
+};
+
+const UNTERMINATED = 0;
+const TERMINATED = 1;
+const ERRORED = 2;
+
+function createCacheRoot() {
+  return new WeakMap();
+}
+
+function createCacheNode() {
+  return {
+    s: UNTERMINATED,
+    // status, represents whether the cached computation returned a value or threw an error
+    v: undefined,
+    // value, either the cached result or an error, depending on s
+    o: null,
+    // object cache, a WeakMap where non-primitive arguments are stored
+    p: null // primitive cache, a regular Map where primitive arguments are stored.
+
+  };
+}
+
+function cache(fn) {
+  return function () {
+    const dispatcher = ReactCurrentCache.current;
+
+    if (!dispatcher) {
+      // If there is no dispatcher, then we treat this as not being cached.
+      // $FlowFixMe[incompatible-call]: We don't want to use rest arguments since we transpile the code.
+      return fn.apply(null, arguments);
+    }
+
+    const fnMap = dispatcher.getCacheForType(createCacheRoot);
+    const fnNode = fnMap.get(fn);
+    let cacheNode;
+
+    if (fnNode === undefined) {
+      cacheNode = createCacheNode();
+      fnMap.set(fn, cacheNode);
+    } else {
+      cacheNode = fnNode;
+    }
+
+    for (let i = 0, l = arguments.length; i < l; i++) {
+      const arg = arguments[i];
+
+      if (typeof arg === 'function' || typeof arg === 'object' && arg !== null) {
+        // Objects go into a WeakMap
+        let objectCache = cacheNode.o;
+
+        if (objectCache === null) {
+          cacheNode.o = objectCache = new WeakMap();
+        }
+
+        const objectNode = objectCache.get(arg);
+
+        if (objectNode === undefined) {
+          cacheNode = createCacheNode();
+          objectCache.set(arg, cacheNode);
+        } else {
+          cacheNode = objectNode;
+        }
+      } else {
+        // Primitives go into a regular Map
+        let primitiveCache = cacheNode.p;
+
+        if (primitiveCache === null) {
+          cacheNode.p = primitiveCache = new Map();
+        }
+
+        const primitiveNode = primitiveCache.get(arg);
+
+        if (primitiveNode === undefined) {
+          cacheNode = createCacheNode();
+          primitiveCache.set(arg, cacheNode);
+        } else {
+          cacheNode = primitiveNode;
+        }
+      }
+    }
+
+    if (cacheNode.s === TERMINATED) {
+      return cacheNode.v;
+    }
+
+    if (cacheNode.s === ERRORED) {
+      throw cacheNode.v;
+    }
+
+    try {
+      // $FlowFixMe[incompatible-call]: We don't want to use rest arguments since we transpile the code.
+      const result = fn.apply(null, arguments);
+      const terminatedNode = cacheNode;
+      terminatedNode.s = TERMINATED;
+      terminatedNode.v = result;
+      return result;
+    } catch (error) {
+      // We store the first error that's thrown and rethrow it.
+      const erroredNode = cacheNode;
+      erroredNode.s = ERRORED;
+      erroredNode.v = error;
+      throw error;
+    }
+  };
+}
+
+function postpone(reason) {
+  // eslint-disable-next-line react-internal/prod-error-codes
+  const postponeInstance = new Error(reason);
+  postponeInstance.$$typeof = REACT_POSTPONE_TYPE;
+  throw postponeInstance;
+}
+
+/**
+ * Keeps track of the current dispatcher.
+ */
+const ReactCurrentDispatcher = {
+  current: null
+};
+
+function resolveDispatcher() {
+  const dispatcher = ReactCurrentDispatcher.current;
+  // intentionally don't throw our own error because this is in a hot path.
+  // Also helps ensure this is inlined.
+
+
+  return dispatcher;
+}
+
+function getCacheSignal() {
+  const dispatcher = ReactCurrentCache.current;
+
+  if (!dispatcher) {
+    // If we have no cache to associate with this call, then we don't know
+    // its lifetime. We abort early since that's safer than letting it live
+    // for ever. Unlike just caching which can be a functional noop outside
+    // of React, these should generally always be associated with some React
+    // render but we're not limiting quite as much as making it a Hook.
+    // It's safer than erroring early at runtime.
+    const controller = new AbortController();
+    const reason = new Error('This CacheSignal was requested outside React which means that it is ' + 'immediately aborted.');
+    controller.abort(reason);
+    return controller.signal;
+  }
+
+  return dispatcher.getCacheSignal();
+}
+function getCacheForType(resourceType) {
+  const dispatcher = ReactCurrentCache.current;
+
+  if (!dispatcher) {
+    // If there is no dispatcher, then we treat this as not being cached.
+    return resourceType();
+  }
+
+  return dispatcher.getCacheForType(resourceType);
+}
+function useContext(Context) {
+  const dispatcher = resolveDispatcher();
+
+  return dispatcher.useContext(Context);
+}
+function useState(initialState) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useState(initialState);
+}
+function useReducer(reducer, initialArg, init) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useReducer(reducer, initialArg, init);
+}
+function useRef(initialValue) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useRef(initialValue);
+}
+function useEffect(create, deps) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useEffect(create, deps);
+}
+function useInsertionEffect(create, deps) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useInsertionEffect(create, deps);
+}
+function useLayoutEffect(create, deps) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useLayoutEffect(create, deps);
+}
+function useCallback(callback, deps) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useCallback(callback, deps);
+}
+function useMemo(create, deps) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useMemo(create, deps);
+}
+function useImperativeHandle(ref, create, deps) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useImperativeHandle(ref, create, deps);
+}
+function useDebugValue(value, formatterFn) {
+}
+function useTransition() {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useTransition();
+}
+function useDeferredValue(value, initialValue) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useDeferredValue(value, initialValue);
+}
+function useId() {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useId();
+}
+function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+}
+function useCacheRefresh() {
+  const dispatcher = resolveDispatcher(); // $FlowFixMe[not-a-function] This is unstable, thus optional
+
+  return dispatcher.useCacheRefresh();
+}
+function use(usable) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.use(usable);
+}
+function useMemoCache(size) {
+  const dispatcher = resolveDispatcher(); // $FlowFixMe[not-a-function] This is unstable, thus optional
+
+  return dispatcher.useMemoCache(size);
+}
+function useEffectEvent(callback) {
+  const dispatcher = resolveDispatcher(); // $FlowFixMe[not-a-function] This is unstable, thus optional
+
+  return dispatcher.useEffectEvent(callback);
+}
+function useOptimistic(passthrough, reducer) {
+  const dispatcher = resolveDispatcher(); // $FlowFixMe[not-a-function] This is unstable, thus optional
+
+  return dispatcher.useOptimistic(passthrough, reducer);
+}
+
+/**
+ * Keeps track of the current batch's configuration such as how long an update
+ * should suspend for if it needs to.
+ */
+const ReactCurrentBatchConfig = {
+  transition: null
+};
+
+const ContextRegistry = {};
+
+const ReactSharedInternals = {
+  ReactCurrentDispatcher,
+  ReactCurrentCache,
+  ReactCurrentBatchConfig,
+  ReactCurrentOwner
+};
+
+{
+  ReactSharedInternals.ContextRegistry = ContextRegistry;
+}
+
+function createServerContext(globalName, defaultValue) {
+
+  let wasDefined = true;
+
+  if (!ContextRegistry[globalName]) {
+    wasDefined = false;
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: defaultValue,
+      _currentValue2: defaultValue,
+      _defaultValue: defaultValue,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  const context = ContextRegistry[globalName];
+
+  if (context._defaultValue === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+    context._defaultValue = defaultValue;
+
+    if (context._currentValue === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      context._currentValue = defaultValue;
+    }
+
+    if (context._currentValue2 === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      context._currentValue2 = defaultValue;
+    }
+  } else if (wasDefined) {
+    throw new Error("ServerContext: " + globalName + " already defined");
+  }
+
+  return context;
+}
+
+function startTransition(scope, options) {
+  const prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = {};
+
+  try {
+    scope();
+  } finally {
+    ReactCurrentBatchConfig.transition = prevTransition;
+  }
+}
+
+function act(callback) {
+  {
+    throw new Error('act(...) is not supported in production builds of React.');
+  }
+}
+
+const createElement = createElement$1;
+const cloneElement = cloneElement$1;
+const createFactory = createFactory$1;
+const Children = {
+  map: mapChildren,
+  forEach: forEachChildren,
+  count: countChildren,
+  toArray,
+  only: onlyChild
+};
+
+function experimental_useOptimistic(passthrough, reducer) {
+
+  return useOptimistic(passthrough, reducer);
+}
+
+exports.Children = Children;
+exports.Component = Component;
+exports.Fragment = REACT_FRAGMENT_TYPE;
+exports.Profiler = REACT_PROFILER_TYPE;
+exports.PureComponent = PureComponent;
+exports.StrictMode = REACT_STRICT_MODE_TYPE;
+exports.Suspense = REACT_SUSPENSE_TYPE;
+exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternals;
+exports.cache = cache;
+exports.cloneElement = cloneElement;
+exports.createContext = createContext;
+exports.createElement = createElement;
+exports.createFactory = createFactory;
+exports.createRef = createRef;
+exports.createServerContext = createServerContext;
+exports.experimental_useEffectEvent = useEffectEvent;
+exports.experimental_useOptimistic = experimental_useOptimistic;
+exports.forwardRef = forwardRef;
+exports.isValidElement = isValidElement;
+exports.lazy = lazy;
+exports.memo = memo;
+exports.startTransition = startTransition;
+exports.unstable_Activity = REACT_OFFSCREEN_TYPE;
+exports.unstable_Cache = REACT_CACHE_TYPE;
+exports.unstable_DebugTracingMode = REACT_DEBUG_TRACING_MODE_TYPE;
+exports.unstable_SuspenseList = REACT_SUSPENSE_LIST_TYPE;
+exports.unstable_act = act;
+exports.unstable_getCacheForType = getCacheForType;
+exports.unstable_getCacheSignal = getCacheSignal;
+exports.unstable_postpone = postpone;
+exports.unstable_useCacheRefresh = useCacheRefresh;
+exports.unstable_useMemoCache = useMemoCache;
+exports.use = use;
+exports.useCallback = useCallback;
+exports.useContext = useContext;
+exports.useDebugValue = useDebugValue;
+exports.useDeferredValue = useDeferredValue;
+exports.useEffect = useEffect;
+exports.useId = useId;
+exports.useImperativeHandle = useImperativeHandle;
+exports.useInsertionEffect = useInsertionEffect;
+exports.useLayoutEffect = useLayoutEffect;
+exports.useMemo = useMemo;
+exports.useOptimistic = useOptimistic;
+exports.useReducer = useReducer;
+exports.useRef = useRef;
+exports.useState = useState;
+exports.useSyncExternalStore = useSyncExternalStore;
+exports.useTransition = useTransition;
+exports.version = ReactVersion;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-experimental/cjs/react.production.min.js b/packages/next/src/compiled/react-experimental/cjs/react.production.min.js
index e41076a3bbf85..feb25b1f432c0 100644
--- a/packages/next/src/compiled/react-experimental/cjs/react.production.min.js
+++ b/packages/next/src/compiled/react-experimental/cjs/react.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var l=Symbol.for("react.element"),n=Symbol.for("react.portal"),p=Symbol.for("react.fragment"),q=Symbol.for("react.strict_mode"),r=Symbol.for("react.profiler"),t=Symbol.for("react.provider"),u=Symbol.for("react.context"),v=Symbol.for("react.server_context"),w=Symbol.for("react.forward_ref"),x=Symbol.for("react.suspense"),y=Symbol.for("react.suspense_list"),z=Symbol.for("react.memo"),A=Symbol.for("react.lazy"),aa=Symbol.for("react.debug_trace_mode"),ba=Symbol.for("react.offscreen"),ca=
 Symbol.for("react.cache"),B=Symbol.for("react.default_value"),da=Symbol.for("react.postpone"),C=Symbol.iterator;function ea(a){if(null===a||"object"!==typeof a)return null;a=C&&a[C]||a["@@iterator"];return"function"===typeof a?a:null}var D={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},E=Object.assign,F={};function G(a,b,c){this.props=a;this.context=b;this.refs=F;this.updater=c||D}G.prototype.isReactComponent={};
 G.prototype.setState=function(a,b){if("object"!==typeof a&&"function"!==typeof a&&null!=a)throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");this.updater.enqueueSetState(this,a,b,"setState")};G.prototype.forceUpdate=function(a){this.updater.enqueueForceUpdate(this,a,"forceUpdate")};function H(){}H.prototype=G.prototype;function I(a,b,c){this.props=a;this.context=b;this.refs=F;this.updater=c||D}var J=I.prototype=new H;
@@ -28,4 +28,6 @@ exports.experimental_useOptimistic=function(a,b){return X(a,b)};exports.forwardR
 exports.unstable_DebugTracingMode=aa;exports.unstable_SuspenseList=y;exports.unstable_act=function(){throw Error("act(...) is not supported in production builds of React.");};exports.unstable_getCacheForType=function(a){var b=U.current;return b?b.getCacheForType(a):a()};exports.unstable_getCacheSignal=function(){var a=U.current;return a?a.getCacheSignal():(a=new AbortController,a.abort(Error("This CacheSignal was requested outside React which means that it is immediately aborted.")),a.signal)};
 exports.unstable_postpone=function(a){a=Error(a);a.$$typeof=da;throw a;};exports.unstable_useCacheRefresh=function(){return W.current.useCacheRefresh()};exports.unstable_useMemoCache=function(a){return W.current.useMemoCache(a)};exports.use=function(a){return W.current.use(a)};exports.useCallback=function(a,b){return W.current.useCallback(a,b)};exports.useContext=function(a){return W.current.useContext(a)};exports.useDebugValue=function(){};
 exports.useDeferredValue=function(a,b){return W.current.useDeferredValue(a,b)};exports.useEffect=function(a,b){return W.current.useEffect(a,b)};exports.useId=function(){return W.current.useId()};exports.useImperativeHandle=function(a,b,c){return W.current.useImperativeHandle(a,b,c)};exports.useInsertionEffect=function(a,b){return W.current.useInsertionEffect(a,b)};exports.useLayoutEffect=function(a,b){return W.current.useLayoutEffect(a,b)};
-exports.useMemo=function(a,b){return W.current.useMemo(a,b)};exports.useOptimistic=X;exports.useReducer=function(a,b,c){return W.current.useReducer(a,b,c)};exports.useRef=function(a){return W.current.useRef(a)};exports.useState=function(a){return W.current.useState(a)};exports.useSyncExternalStore=function(a,b,c){return W.current.useSyncExternalStore(a,b,c)};exports.useTransition=function(){return W.current.useTransition()};exports.version="18.3.0-experimental-2983249dd-20231107";
+exports.useMemo=function(a,b){return W.current.useMemo(a,b)};exports.useOptimistic=X;exports.useReducer=function(a,b,c){return W.current.useReducer(a,b,c)};exports.useRef=function(a){return W.current.useRef(a)};exports.useState=function(a){return W.current.useState(a)};exports.useSyncExternalStore=function(a,b,c){return W.current.useSyncExternalStore(a,b,c)};exports.useTransition=function(){return W.current.useTransition()};exports.version="18.3.0-experimental-7508dcd5c-20231108";
+
+//# sourceMappingURL=react.production.min.js.map
diff --git a/packages/next/src/compiled/react-experimental/cjs/react.shared-subset.development.js b/packages/next/src/compiled/react-experimental/cjs/react.shared-subset.development.js
index cff892a6f25a7..eee9ad20c5f65 100644
--- a/packages/next/src/compiled/react-experimental/cjs/react.shared-subset.development.js
+++ b/packages/next/src/compiled/react-experimental/cjs/react.shared-subset.development.js
@@ -401,7 +401,7 @@ function taintObjectReference(message, object) {
   TaintRegistryObjects.set(object, message);
 }
 
-var ReactVersion = '18.3.0-experimental-2983249dd-20231107';
+var ReactVersion = '18.3.0-experimental-7508dcd5c-20231108';
 
 // ATTENTION
 // When adding new symbols to this file,
@@ -2027,6 +2027,18 @@ var componentFrameCache;
   var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
   componentFrameCache = new PossiblyWeakMap();
 }
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
@@ -2042,7 +2054,6 @@ function describeNativeComponentFrame(fn, construct) {
     }
   }
 
-  var control;
   reentry = true;
   var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
 
@@ -2056,81 +2067,140 @@ function describeNativeComponentFrame(fn, construct) {
     ReactCurrentDispatcher.current = null;
     disableLogs();
   }
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
 
-  try {
-    // This should throw.
-    if (construct) {
-      // Something should be setting the props in the constructor.
-      var Fake = function () {
-        throw Error();
-      }; // $FlowFixMe[prop-missing]
 
+  var RunInRootFrame = {
+    DetermineComponentFrameRoot: function () {
+      var control;
 
-      Object.defineProperty(Fake.prototype, 'props', {
-        set: function () {
-          // We use a throwing setter instead of frozen or non-writable props
-          // because that won't throw in a non-strict mode function.
-          throw Error();
-        }
-      });
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          var Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
 
-      if (typeof Reflect === 'object' && Reflect.construct) {
-        // We construct a different control for this case to include any extra
-        // frames added by the construct call.
-        try {
-          Reflect.construct(Fake, []);
-        } catch (x) {
-          control = x;
-        }
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
 
-        Reflect.construct(fn, [], Fake);
-      } else {
-        try {
-          Fake.call();
-        } catch (x) {
-          control = x;
-        } // $FlowFixMe[prop-missing] found when upgrading Flow
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
 
 
-        fn.call(Fake.prototype);
-      }
-    } else {
-      try {
-        throw Error();
-      } catch (x) {
-        control = x;
-      } // TODO(luna): This will currently only throw if the function component
-      // tries to access React/ReactDOM/props. We should probably make this throw
-      // in simple components too
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
 
 
-      var maybePromise = fn(); // If the function component returns a promise, it's likely an async
-      // component, which we don't yet support. Attach a noop catch handler to
-      // silence the error.
-      // TODO: Implement component stacks for async client components?
+          var maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
 
-      if (maybePromise && typeof maybePromise.catch === 'function') {
-        maybePromise.catch(function () {});
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(function () {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
       }
+
+      return [null, null];
     }
-  } catch (sample) {
-    // This is inlined manually because closure doesn't do it for us.
-    if (sample && control && typeof sample.stack === 'string') {
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
+
+  try {
+    var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
+
+    if (sampleStack && controlStack) {
       // This extracts the first frame from the sample that isn't also in the control.
       // Skipping one frame that we assume is the frame that calls the two.
-      var sampleLines = sample.stack.split('\n');
-      var controlLines = control.stack.split('\n');
-      var s = sampleLines.length - 1;
-      var c = controlLines.length - 1;
-
-      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
-        // We expect at least one stack frame to be shared.
-        // Typically this will be the root most one. However, stack frames may be
-        // cut off due to maximum stack limits. In this case, one maybe cut off
-        // earlier than the other. We assume that the sample is longer or the same
-        // and there for cut off earlier. So we should find the root most frame in
-        // the sample somewhere in the control.
-        c--;
+      var sampleLines = sampleStack.split('\n');
+      var controlLines = controlStack.split('\n');
+      var s = 0;
+      var c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
       }
 
       for (; s >= 1 && c >= 0; s--, c--) {
@@ -2159,7 +2229,7 @@ function describeNativeComponentFrame(fn, construct) {
                   _frame = _frame.replace('<anonymous>', fn.displayName);
                 }
 
-                {
+                if (true) {
                   if (typeof fn === 'function') {
                     componentFrameCache.set(fn, _frame);
                   }
diff --git a/packages/next/src/compiled/react-experimental/cjs/react.shared-subset.production.js b/packages/next/src/compiled/react-experimental/cjs/react.shared-subset.production.js
new file mode 100644
index 0000000000000..e6487d2e1417b
--- /dev/null
+++ b/packages/next/src/compiled/react-experimental/cjs/react.shared-subset.production.js
@@ -0,0 +1,1322 @@
+/**
+ * @license React
+ * react.shared-subset.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+const assign = Object.assign;
+
+/**
+ * Keeps track of the current Cache dispatcher.
+ */
+const ReactCurrentCache = {
+  current: null
+};
+
+function createFetchCache() {
+  return new Map();
+}
+
+const simpleCacheKey = '["GET",[],null,"follow",null,null,null,null]'; // generateCacheKey(new Request('https://blank'));
+
+function generateCacheKey(request) {
+  // We pick the fields that goes into the key used to dedupe requests.
+  // We don't include the `cache` field, because we end up using whatever
+  // caching resulted from the first request.
+  // Notably we currently don't consider non-standard (or future) options.
+  // This might not be safe. TODO: warn for non-standard extensions differing.
+  // IF YOU CHANGE THIS UPDATE THE simpleCacheKey ABOVE.
+  return JSON.stringify([request.method, Array.from(request.headers.entries()), request.mode, request.redirect, request.credentials, request.referrer, request.referrerPolicy, request.integrity]);
+}
+
+{
+  if (typeof fetch === 'function') {
+    const originalFetch = fetch;
+
+    const cachedFetch = function fetch(resource, options) {
+      const dispatcher = ReactCurrentCache.current;
+
+      if (!dispatcher) {
+        // We're outside a cached scope.
+        return originalFetch(resource, options);
+      }
+
+      if (options && options.signal && options.signal !== dispatcher.getCacheSignal()) {
+        // If we're passed a signal that is not ours, then we assume that
+        // someone else controls the lifetime of this object and opts out of
+        // caching. It's effectively the opt-out mechanism.
+        // Ideally we should be able to check this on the Request but
+        // it always gets initialized with its own signal so we don't
+        // know if it's supposed to override - unless we also override the
+        // Request constructor.
+        return originalFetch(resource, options);
+      } // Normalize the Request
+
+
+      let url;
+      let cacheKey;
+
+      if (typeof resource === 'string' && !options) {
+        // Fast path.
+        cacheKey = simpleCacheKey;
+        url = resource;
+      } else {
+        // Normalize the request.
+        // if resource is not a string or a URL (its an instance of Request)
+        // then do not instantiate a new Request but instead
+        // reuse the request as to not disturb the body in the event it's a ReadableStream.
+        const request = typeof resource === 'string' || resource instanceof URL ? new Request(resource, options) : resource;
+
+        if (request.method !== 'GET' && request.method !== 'HEAD' || // $FlowFixMe[prop-missing]: keepalive is real
+        request.keepalive) {
+          // We currently don't dedupe requests that might have side-effects. Those
+          // have to be explicitly cached. We assume that the request doesn't have a
+          // body if it's GET or HEAD.
+          // keepalive gets treated the same as if you passed a custom cache signal.
+          return originalFetch(resource, options);
+        }
+
+        cacheKey = generateCacheKey(request);
+        url = request.url;
+      }
+
+      const cache = dispatcher.getCacheForType(createFetchCache);
+      const cacheEntries = cache.get(url);
+      let match;
+
+      if (cacheEntries === undefined) {
+        // We pass the original arguments here in case normalizing the Request
+        // doesn't include all the options in this environment.
+        match = originalFetch(resource, options);
+        cache.set(url, [cacheKey, match]);
+      } else {
+        // We use an array as the inner data structure since it's lighter and
+        // we typically only expect to see one or two entries here.
+        for (let i = 0, l = cacheEntries.length; i < l; i += 2) {
+          const key = cacheEntries[i];
+          const value = cacheEntries[i + 1];
+
+          if (key === cacheKey) {
+            match = value; // I would've preferred a labelled break but lint says no.
+
+            return match.then(response => response.clone());
+          }
+        }
+
+        match = originalFetch(resource, options);
+        cacheEntries.push(cacheKey, match);
+      } // We clone the response so that each time you call this you get a new read
+      // of the body so that it can be read multiple times.
+
+
+      return match.then(response => response.clone());
+    }; // We don't expect to see any extra properties on fetch but if there are any,
+    // copy them over. Useful for extended fetch environments or mocks.
+
+
+    assign(cachedFetch, originalFetch);
+
+    try {
+      // eslint-disable-next-line no-native-reassign
+      fetch = cachedFetch;
+    } catch (error1) {
+      try {
+        // In case assigning it globally fails, try globalThis instead just in case it exists.
+        globalThis.fetch = cachedFetch;
+      } catch (error2) {
+        // Log even in production just to make sure this is seen if only prod is frozen.
+        // eslint-disable-next-line react-internal/no-production-logging
+        console.warn('React was unable to patch the fetch() function in this environment. ' + 'Suspensey APIs might not work correctly as a result.');
+      }
+    }
+  }
+}
+
+/**
+ * Keeps track of the current dispatcher.
+ */
+const ReactCurrentDispatcher = {
+  current: null
+};
+
+/**
+ * Keeps track of the current owner.
+ *
+ * The current owner is the component who should own any components that are
+ * currently being constructed.
+ */
+const ReactCurrentOwner = {
+  /**
+   * @internal
+   * @type {ReactComponent}
+   */
+  current: null
+};
+
+const ContextRegistry = {};
+
+const ReactSharedInternals = {
+  ReactCurrentDispatcher,
+  ReactCurrentOwner
+};
+
+{
+  ReactSharedInternals.ContextRegistry = ContextRegistry;
+}
+
+const TaintRegistryObjects$1 = new WeakMap();
+const TaintRegistryValues$1 = new Map(); // Byte lengths of all binary values we've ever seen. We don't both refcounting this.
+// We expect to see only a few lengths here such as the length of token.
+
+const TaintRegistryByteLengths$1 = new Set(); // When a value is finalized, it means that it has been removed from any global caches.
+// No future requests can get a handle on it but any ongoing requests can still have
+// a handle on it. It's still tainted until that happens.
+
+const TaintRegistryPendingRequests$1 = new Set();
+
+const ReactServerSharedInternals = {
+  ReactCurrentCache
+};
+
+{
+  ReactServerSharedInternals.TaintRegistryObjects = TaintRegistryObjects$1;
+  ReactServerSharedInternals.TaintRegistryValues = TaintRegistryValues$1;
+  ReactServerSharedInternals.TaintRegistryByteLengths = TaintRegistryByteLengths$1;
+  ReactServerSharedInternals.TaintRegistryPendingRequests = TaintRegistryPendingRequests$1;
+}
+
+// Do not require this module directly! Use normal `invariant` calls with
+// template literal strings. The messages will be replaced with error codes
+// during build.
+function formatProdErrorMessage(code) {
+  let url = 'https://reactjs.org/docs/error-decoder.html?invariant=' + code;
+
+  for (let i = 1; i < arguments.length; i++) {
+    url += '&args[]=' + encodeURIComponent(arguments[i]);
+  }
+
+  return "Minified React error #" + code + "; visit " + url + " for the full message or " + 'use the non-minified dev environment for full errors and additional ' + 'helpful warnings.';
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+// Turns a TypedArray or ArrayBuffer into a string that can be used for comparison
+// in a Map to see if the bytes are the same.
+function binaryToComparableString(view) {
+  return String.fromCharCode.apply(String, new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+}
+
+const TaintRegistryObjects = ReactServerSharedInternals.TaintRegistryObjects,
+      TaintRegistryValues = ReactServerSharedInternals.TaintRegistryValues,
+      TaintRegistryByteLengths = ReactServerSharedInternals.TaintRegistryByteLengths,
+      TaintRegistryPendingRequests = ReactServerSharedInternals.TaintRegistryPendingRequests; // This is the shared constructor of all typed arrays.
+
+const TypedArrayConstructor = getPrototypeOf(Uint32Array.prototype).constructor;
+const defaultMessage = 'A tainted value was attempted to be serialized to a Client Component or Action closure. ' + 'This would leak it to the client.';
+
+function cleanup(entryValue) {
+  const entry = TaintRegistryValues.get(entryValue);
+
+  if (entry !== undefined) {
+    TaintRegistryPendingRequests.forEach(function (requestQueue) {
+      requestQueue.push(entryValue);
+      entry.count++;
+    });
+
+    if (entry.count === 1) {
+      TaintRegistryValues.delete(entryValue);
+    } else {
+      entry.count--;
+    }
+  }
+} // If FinalizationRegistry doesn't exist, we assume that objects life forever.
+// E.g. the whole VM is just the lifetime of a request.
+
+
+const finalizationRegistry = typeof FinalizationRegistry === 'function' ? new FinalizationRegistry(cleanup) : null;
+function taintUniqueValue(message, lifetime, value) {
+
+
+  message = '' + (message || defaultMessage);
+
+  if (lifetime === null || typeof lifetime !== 'object' && typeof lifetime !== 'function') {
+    throw Error(formatProdErrorMessage(493));
+  }
+
+  let entryValue;
+
+  if (typeof value === 'string' || typeof value === 'bigint') {
+    // Use as is.
+    entryValue = value;
+  } else if ((value instanceof TypedArrayConstructor || value instanceof DataView)) {
+    // For now, we just convert binary data to a string so that we can just use the native
+    // hashing in the Map implementation. It doesn't really matter what form the string
+    // take as long as it's the same when we look it up.
+    // We're not too worried about collisions since this should be a high entropy value.
+    TaintRegistryByteLengths.add(value.byteLength);
+    entryValue = binaryToComparableString(value);
+  } else {
+    const kind = value === null ? 'null' : typeof value;
+
+    if (kind === 'object' || kind === 'function') {
+      throw Error(formatProdErrorMessage(494));
+    }
+
+    throw Error(formatProdErrorMessage(495, kind));
+  }
+
+  const existingEntry = TaintRegistryValues.get(entryValue);
+
+  if (existingEntry === undefined) {
+    TaintRegistryValues.set(entryValue, {
+      message,
+      count: 1
+    });
+  } else {
+    existingEntry.count++;
+  }
+
+  if (finalizationRegistry !== null) {
+    finalizationRegistry.register(lifetime, entryValue);
+  }
+}
+function taintObjectReference(message, object) {
+
+
+  message = '' + (message || defaultMessage);
+
+  if (typeof object === 'string' || typeof object === 'bigint') {
+    throw Error(formatProdErrorMessage(496));
+  }
+
+  if (object === null || typeof object !== 'object' && typeof object !== 'function') {
+    throw Error(formatProdErrorMessage(497));
+  }
+
+  TaintRegistryObjects.set(object, message);
+}
+
+var ReactVersion = '18.3.0-experimental-7508dcd5c-20231108';
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+const REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+/**
+ * This is the abstract API for an update queue.
+ */
+
+
+const ReactNoopUpdateQueue = {
+  /**
+   * Checks whether or not this composite component is mounted.
+   * @param {ReactClass} publicInstance The instance we want to test.
+   * @return {boolean} True if mounted, false otherwise.
+   * @protected
+   * @final
+   */
+  isMounted: function (publicInstance) {
+    return false;
+  },
+
+  /**
+   * Forces an update. This should only be invoked when it is known with
+   * certainty that we are **not** in a DOM transaction.
+   *
+   * You may want to call this when you know that some deeper aspect of the
+   * component's state has changed but `setState` was not called.
+   *
+   * This will not invoke `shouldComponentUpdate`, but it will invoke
+   * `componentWillUpdate` and `componentDidUpdate`.
+   *
+   * @param {ReactClass} publicInstance The instance that should rerender.
+   * @param {?function} callback Called after component is updated.
+   * @param {?string} callerName name of the calling function in the public API.
+   * @internal
+   */
+  enqueueForceUpdate: function (publicInstance, callback, callerName) {
+  },
+
+  /**
+   * Replaces all of the state. Always use this or `setState` to mutate state.
+   * You should treat `this.state` as immutable.
+   *
+   * There is no guarantee that `this.state` will be immediately updated, so
+   * accessing `this.state` after calling this method may return the old value.
+   *
+   * @param {ReactClass} publicInstance The instance that should rerender.
+   * @param {object} completeState Next state.
+   * @param {?function} callback Called after component is updated.
+   * @param {?string} callerName name of the calling function in the public API.
+   * @internal
+   */
+  enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {
+  },
+
+  /**
+   * Sets a subset of the state. This only exists because _pendingState is
+   * internal. This provides a merging strategy that is not available to deep
+   * properties which is confusing. TODO: Expose pendingState or don't use it
+   * during the merge.
+   *
+   * @param {ReactClass} publicInstance The instance that should rerender.
+   * @param {object} partialState Next partial state to be merged with state.
+   * @param {?function} callback Called after component is updated.
+   * @param {?string} Name of the calling function in the public API.
+   * @internal
+   */
+  enqueueSetState: function (publicInstance, partialState, callback, callerName) {
+  }
+};
+
+const emptyObject = {};
+/**
+ * Base class helpers for the updating state of a component.
+ */
+
+
+function Component(props, context, updater) {
+  this.props = props;
+  this.context = context; // If a component has string refs, we will assign a different object later.
+
+  this.refs = emptyObject; // We initialize the default updater but the real one gets injected by the
+  // renderer.
+
+  this.updater = updater || ReactNoopUpdateQueue;
+}
+
+Component.prototype.isReactComponent = {};
+/**
+ * Sets a subset of the state. Always use this to mutate
+ * state. You should treat `this.state` as immutable.
+ *
+ * There is no guarantee that `this.state` will be immediately updated, so
+ * accessing `this.state` after calling this method may return the old value.
+ *
+ * There is no guarantee that calls to `setState` will run synchronously,
+ * as they may eventually be batched together.  You can provide an optional
+ * callback that will be executed when the call to setState is actually
+ * completed.
+ *
+ * When a function is provided to setState, it will be called at some point in
+ * the future (not synchronously). It will be called with the up to date
+ * component arguments (state, props, context). These values can be different
+ * from this.* because your function may be called after receiveProps but before
+ * shouldComponentUpdate, and this new state, props, and context will not yet be
+ * assigned to this.
+ *
+ * @param {object|function} partialState Next partial state or function to
+ *        produce next partial state to be merged with current state.
+ * @param {?function} callback Called after state is updated.
+ * @final
+ * @protected
+ */
+
+Component.prototype.setState = function (partialState, callback) {
+  if (typeof partialState !== 'object' && typeof partialState !== 'function' && partialState != null) {
+    throw Error(formatProdErrorMessage(85));
+  }
+
+  this.updater.enqueueSetState(this, partialState, callback, 'setState');
+};
+/**
+ * Forces an update. This should only be invoked when it is known with
+ * certainty that we are **not** in a DOM transaction.
+ *
+ * You may want to call this when you know that some deeper aspect of the
+ * component's state has changed but `setState` was not called.
+ *
+ * This will not invoke `shouldComponentUpdate`, but it will invoke
+ * `componentWillUpdate` and `componentDidUpdate`.
+ *
+ * @param {?function} callback Called after update is complete.
+ * @final
+ * @protected
+ */
+
+
+Component.prototype.forceUpdate = function (callback) {
+  this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');
+};
+
+function ComponentDummy() {}
+
+ComponentDummy.prototype = Component.prototype;
+/**
+ * Convenience component with default shallow equality check for sCU.
+ */
+
+function PureComponent(props, context, updater) {
+  this.props = props;
+  this.context = context; // If a component has string refs, we will assign a different object later.
+
+  this.refs = emptyObject;
+  this.updater = updater || ReactNoopUpdateQueue;
+}
+
+const pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
+pureComponentPrototype.constructor = PureComponent; // Avoid an extra prototype jump for these methods.
+
+assign(pureComponentPrototype, Component.prototype);
+pureComponentPrototype.isPureReactComponent = true;
+
+// an immutable object with a single mutable value
+function createRef() {
+  const refObject = {
+    current: null
+  };
+
+  return refObject;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+const RESERVED_PROPS = {
+  key: true,
+  ref: true,
+  __self: true,
+  __source: true
+};
+
+function hasValidRef(config) {
+
+  return config.ref !== undefined;
+}
+
+function hasValidKey(config) {
+
+  return config.key !== undefined;
+}
+/**
+ * Factory method to create a new React element. This no longer adheres to
+ * the class pattern, so do not use new to call it. Also, instanceof check
+ * will not work. Instead test $$typeof field against Symbol.for('react.element') to check
+ * if something is a React Element.
+ *
+ * @param {*} type
+ * @param {*} props
+ * @param {*} key
+ * @param {string|object} ref
+ * @param {*} owner
+ * @param {*} self A *temporary* helper to detect places where `this` is
+ * different from the `owner` when React.createElement is called, so that we
+ * can warn. We want to get rid of owner and replace string `ref`s with arrow
+ * functions, and as long as `this` and owner are the same, there will be no
+ * change in behavior.
+ * @param {*} source An annotation object (added by a transpiler or otherwise)
+ * indicating filename, line number, and/or other information.
+ * @internal
+ */
+
+
+function ReactElement(type, key, ref, self, source, owner, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: ref,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: owner
+  };
+
+  return element;
+}
+/**
+ * Create and return a new ReactElement of the given type.
+ * See https://reactjs.org/docs/react-api.html#createelement
+ */
+
+function createElement$1(type, config, children) {
+  let propName; // Reserved names are extracted
+
+  const props = {};
+  let key = null;
+  let ref = null;
+  let self = null;
+  let source = null;
+
+  if (config != null) {
+    if (hasValidRef(config)) {
+      ref = config.ref;
+    }
+
+    if (hasValidKey(config)) {
+
+      key = '' + config.key;
+    }
+
+    self = config.__self === undefined ? null : config.__self;
+    source = config.__source === undefined ? null : config.__source; // Remaining properties are added to a new props object
+
+    for (propName in config) {
+      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+        props[propName] = config[propName];
+      }
+    }
+  } // Children can be more than one argument, and those are transferred onto
+  // the newly allocated props object.
+
+
+  const childrenLength = arguments.length - 2;
+
+  if (childrenLength === 1) {
+    props.children = children;
+  } else if (childrenLength > 1) {
+    const childArray = Array(childrenLength);
+
+    for (let i = 0; i < childrenLength; i++) {
+      childArray[i] = arguments[i + 2];
+    }
+
+    props.children = childArray;
+  } // Resolve default props
+
+
+  if (type && type.defaultProps) {
+    const defaultProps = type.defaultProps;
+
+    for (propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+  }
+
+  return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
+}
+function cloneAndReplaceKey(oldElement, newKey) {
+  const newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
+  return newElement;
+}
+/**
+ * Clone and return a new ReactElement using element as the starting point.
+ * See https://reactjs.org/docs/react-api.html#cloneelement
+ */
+
+function cloneElement$1(element, config, children) {
+  if (element === null || element === undefined) {
+    throw Error(formatProdErrorMessage(267, element));
+  }
+
+  let propName; // Original props are copied
+
+  const props = assign({}, element.props); // Reserved names are extracted
+
+  let key = element.key;
+  let ref = element.ref; // Self is preserved since the owner is preserved.
+
+  const self = element._self; // Source is preserved since cloneElement is unlikely to be targeted by a
+  // transpiler, and the original source is probably a better indicator of the
+  // true owner.
+
+  const source = element._source; // Owner will be preserved, unless ref is overridden
+
+  let owner = element._owner;
+
+  if (config != null) {
+    if (hasValidRef(config)) {
+      // Silently steal the ref from the parent.
+      ref = config.ref;
+      owner = ReactCurrentOwner.current;
+    }
+
+    if (hasValidKey(config)) {
+
+      key = '' + config.key;
+    } // Remaining properties override existing props
+
+
+    let defaultProps;
+
+    if (element.type && element.type.defaultProps) {
+      defaultProps = element.type.defaultProps;
+    }
+
+    for (propName in config) {
+      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+        if (config[propName] === undefined && defaultProps !== undefined) {
+          // Resolve default props
+          props[propName] = defaultProps[propName];
+        } else {
+          props[propName] = config[propName];
+        }
+      }
+    }
+  } // Children can be more than one argument, and those are transferred onto
+  // the newly allocated props object.
+
+
+  const childrenLength = arguments.length - 2;
+
+  if (childrenLength === 1) {
+    props.children = children;
+  } else if (childrenLength > 1) {
+    const childArray = Array(childrenLength);
+
+    for (let i = 0; i < childrenLength; i++) {
+      childArray[i] = arguments[i + 2];
+    }
+
+    props.children = childArray;
+  }
+
+  return ReactElement(element.type, key, ref, self, source, owner, props);
+}
+/**
+ * Verifies the object is a ReactElement.
+ * See https://reactjs.org/docs/react-api.html#isvalidelement
+ * @param {?object} object
+ * @return {boolean} True if `object` is a ReactElement.
+ * @final
+ */
+
+function isValidElement(object) {
+  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+}
+
+const SEPARATOR = '.';
+const SUBSEPARATOR = ':';
+/**
+ * Escape and wrap key so it is safe to use as a reactid
+ *
+ * @param {string} key to be escaped.
+ * @return {string} the escaped key.
+ */
+
+function escape(key) {
+  const escapeRegex = /[=:]/g;
+  const escaperLookup = {
+    '=': '=0',
+    ':': '=2'
+  };
+  const escapedString = key.replace(escapeRegex, function (match) {
+    return escaperLookup[match];
+  });
+  return '$' + escapedString;
+}
+const userProvidedKeyEscapeRegex = /\/+/g;
+
+function escapeUserProvidedKey(text) {
+  return text.replace(userProvidedKeyEscapeRegex, '$&/');
+}
+/**
+ * Generate a key string that identifies a element within a set.
+ *
+ * @param {*} element A element that could contain a manual key.
+ * @param {number} index Index that is used if a manual key is not provided.
+ * @return {string}
+ */
+
+
+function getElementKey(element, index) {
+  // Do some typechecking here since we call this blindly. We want to ensure
+  // that we don't block potential future ES APIs.
+  if (typeof element === 'object' && element !== null && element.key != null) {
+
+    return escape('' + element.key);
+  } // Implicit key determined by the index in the set
+
+
+  return index.toString(36);
+}
+
+function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
+  const type = typeof children;
+
+  if (type === 'undefined' || type === 'boolean') {
+    // All of the above are perceived as null.
+    children = null;
+  }
+
+  let invokeCallback = false;
+
+  if (children === null) {
+    invokeCallback = true;
+  } else {
+    switch (type) {
+      case 'string':
+      case 'number':
+        invokeCallback = true;
+        break;
+
+      case 'object':
+        switch (children.$$typeof) {
+          case REACT_ELEMENT_TYPE:
+          case REACT_PORTAL_TYPE:
+            invokeCallback = true;
+        }
+
+    }
+  }
+
+  if (invokeCallback) {
+    const child = children;
+    let mappedChild = callback(child); // If it's the only child, treat the name as if it was wrapped in an array
+    // so that it's consistent if the number of children grows:
+
+    const childKey = nameSoFar === '' ? SEPARATOR + getElementKey(child, 0) : nameSoFar;
+
+    if (isArray(mappedChild)) {
+      let escapedChildKey = '';
+
+      if (childKey != null) {
+        escapedChildKey = escapeUserProvidedKey(childKey) + '/';
+      }
+
+      mapIntoArray(mappedChild, array, escapedChildKey, '', c => c);
+    } else if (mappedChild != null) {
+      if (isValidElement(mappedChild)) {
+
+        mappedChild = cloneAndReplaceKey(mappedChild, // Keep both the (mapped) and old keys if they differ, just as
+        // traverseAllChildren used to do for objects as children
+        escapedPrefix + ( // $FlowFixMe[incompatible-type] Flow incorrectly thinks React.Portal doesn't have a key
+        mappedChild.key && (!child || child.key !== mappedChild.key) ? escapeUserProvidedKey( // $FlowFixMe[unsafe-addition]
+        '' + mappedChild.key // eslint-disable-line react-internal/safe-string-coercion
+        ) + '/' : '') + childKey);
+      }
+
+      array.push(mappedChild);
+    }
+
+    return 1;
+  }
+
+  let child;
+  let nextName;
+  let subtreeCount = 0; // Count of children found in the current subtree.
+
+  const nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;
+
+  if (isArray(children)) {
+    for (let i = 0; i < children.length; i++) {
+      child = children[i];
+      nextName = nextNamePrefix + getElementKey(child, i);
+      subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
+    }
+  } else {
+    const iteratorFn = getIteratorFn(children);
+
+    if (typeof iteratorFn === 'function') {
+      const iterableChildren = children;
+
+      const iterator = iteratorFn.call(iterableChildren);
+      let step;
+      let ii = 0; // $FlowFixMe[incompatible-use] `iteratorFn` might return null according to typing.
+
+      while (!(step = iterator.next()).done) {
+        child = step.value;
+        nextName = nextNamePrefix + getElementKey(child, ii++);
+        subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
+      }
+    } else if (type === 'object') {
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      const childrenString = String(children);
+      throw Error(formatProdErrorMessage(31, childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString));
+    }
+  }
+
+  return subtreeCount;
+}
+/**
+ * Maps children that are typically specified as `props.children`.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrenmap
+ *
+ * The provided mapFunction(child, index) will be called for each
+ * leaf child.
+ *
+ * @param {?*} children Children tree container.
+ * @param {function(*, int)} func The map function.
+ * @param {*} context Context for mapFunction.
+ * @return {object} Object containing the ordered map of results.
+ */
+
+
+function mapChildren(children, func, context) {
+  if (children == null) {
+    return children;
+  }
+
+  const result = [];
+  let count = 0;
+  mapIntoArray(children, result, '', '', function (child) {
+    return func.call(context, child, count++);
+  });
+  return result;
+}
+/**
+ * Count the number of children that are typically specified as
+ * `props.children`.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrencount
+ *
+ * @param {?*} children Children tree container.
+ * @return {number} The number of children.
+ */
+
+
+function countChildren(children) {
+  let n = 0;
+  mapChildren(children, () => {
+    n++; // Don't return anything
+  });
+  return n;
+}
+/**
+ * Iterates through children that are typically specified as `props.children`.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrenforeach
+ *
+ * The provided forEachFunc(child, index) will be called for each
+ * leaf child.
+ *
+ * @param {?*} children Children tree container.
+ * @param {function(*, int)} forEachFunc
+ * @param {*} forEachContext Context for forEachContext.
+ */
+
+
+function forEachChildren(children, forEachFunc, forEachContext) {
+  mapChildren(children, // $FlowFixMe[missing-this-annot]
+  function () {
+    forEachFunc.apply(this, arguments); // Don't return anything.
+  }, forEachContext);
+}
+/**
+ * Flatten a children object (typically specified as `props.children`) and
+ * return an array with appropriately re-keyed children.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrentoarray
+ */
+
+
+function toArray(children) {
+  return mapChildren(children, child => child) || [];
+}
+/**
+ * Returns the first child in a collection of children and verifies that there
+ * is only one child in the collection.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrenonly
+ *
+ * The current implementation of this function assumes that a single child gets
+ * passed without a wrapper, but the purpose of this helper function is to
+ * abstract away the particular structure of children.
+ *
+ * @param {?object} children Child collection structure.
+ * @return {ReactElement} The first and only `ReactElement` contained in the
+ * structure.
+ */
+
+
+function onlyChild(children) {
+  if (!isValidElement(children)) {
+    throw Error(formatProdErrorMessage(143));
+  }
+
+  return children;
+}
+
+const Uninitialized = -1;
+const Pending = 0;
+const Resolved = 1;
+const Rejected = 2;
+
+function lazyInitializer(payload) {
+  if (payload._status === Uninitialized) {
+    const ctor = payload._result;
+    const thenable = ctor(); // Transition to the next state.
+    // This might throw either because it's missing or throws. If so, we treat it
+    // as still uninitialized and try again next time. Which is the same as what
+    // happens if the ctor or any wrappers processing the ctor throws. This might
+    // end up fixing it if the resolution was a concurrency bug.
+
+    thenable.then(moduleObject => {
+      if (payload._status === Pending || payload._status === Uninitialized) {
+        // Transition to the next state.
+        const resolved = payload;
+        resolved._status = Resolved;
+        resolved._result = moduleObject;
+      }
+    }, error => {
+      if (payload._status === Pending || payload._status === Uninitialized) {
+        // Transition to the next state.
+        const rejected = payload;
+        rejected._status = Rejected;
+        rejected._result = error;
+      }
+    });
+
+    if (payload._status === Uninitialized) {
+      // In case, we're still uninitialized, then we're waiting for the thenable
+      // to resolve. Set it as pending in the meantime.
+      const pending = payload;
+      pending._status = Pending;
+      pending._result = thenable;
+    }
+  }
+
+  if (payload._status === Resolved) {
+    const moduleObject = payload._result;
+
+    return moduleObject.default;
+  } else {
+    throw payload._result;
+  }
+}
+
+function lazy(ctor) {
+  const payload = {
+    // We use these fields to store the result.
+    _status: Uninitialized,
+    _result: ctor
+  };
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: payload,
+    _init: lazyInitializer
+  };
+
+  return lazyType;
+}
+
+function forwardRef(render) {
+
+  const elementType = {
+    $$typeof: REACT_FORWARD_REF_TYPE,
+    render
+  };
+
+  return elementType;
+}
+
+function memo(type, compare) {
+
+  const elementType = {
+    $$typeof: REACT_MEMO_TYPE,
+    type,
+    compare: compare === undefined ? null : compare
+  };
+
+  return elementType;
+}
+
+const UNTERMINATED = 0;
+const TERMINATED = 1;
+const ERRORED = 2;
+
+function createCacheRoot() {
+  return new WeakMap();
+}
+
+function createCacheNode() {
+  return {
+    s: UNTERMINATED,
+    // status, represents whether the cached computation returned a value or threw an error
+    v: undefined,
+    // value, either the cached result or an error, depending on s
+    o: null,
+    // object cache, a WeakMap where non-primitive arguments are stored
+    p: null // primitive cache, a regular Map where primitive arguments are stored.
+
+  };
+}
+
+function cache(fn) {
+  return function () {
+    const dispatcher = ReactCurrentCache.current;
+
+    if (!dispatcher) {
+      // If there is no dispatcher, then we treat this as not being cached.
+      // $FlowFixMe[incompatible-call]: We don't want to use rest arguments since we transpile the code.
+      return fn.apply(null, arguments);
+    }
+
+    const fnMap = dispatcher.getCacheForType(createCacheRoot);
+    const fnNode = fnMap.get(fn);
+    let cacheNode;
+
+    if (fnNode === undefined) {
+      cacheNode = createCacheNode();
+      fnMap.set(fn, cacheNode);
+    } else {
+      cacheNode = fnNode;
+    }
+
+    for (let i = 0, l = arguments.length; i < l; i++) {
+      const arg = arguments[i];
+
+      if (typeof arg === 'function' || typeof arg === 'object' && arg !== null) {
+        // Objects go into a WeakMap
+        let objectCache = cacheNode.o;
+
+        if (objectCache === null) {
+          cacheNode.o = objectCache = new WeakMap();
+        }
+
+        const objectNode = objectCache.get(arg);
+
+        if (objectNode === undefined) {
+          cacheNode = createCacheNode();
+          objectCache.set(arg, cacheNode);
+        } else {
+          cacheNode = objectNode;
+        }
+      } else {
+        // Primitives go into a regular Map
+        let primitiveCache = cacheNode.p;
+
+        if (primitiveCache === null) {
+          cacheNode.p = primitiveCache = new Map();
+        }
+
+        const primitiveNode = primitiveCache.get(arg);
+
+        if (primitiveNode === undefined) {
+          cacheNode = createCacheNode();
+          primitiveCache.set(arg, cacheNode);
+        } else {
+          cacheNode = primitiveNode;
+        }
+      }
+    }
+
+    if (cacheNode.s === TERMINATED) {
+      return cacheNode.v;
+    }
+
+    if (cacheNode.s === ERRORED) {
+      throw cacheNode.v;
+    }
+
+    try {
+      // $FlowFixMe[incompatible-call]: We don't want to use rest arguments since we transpile the code.
+      const result = fn.apply(null, arguments);
+      const terminatedNode = cacheNode;
+      terminatedNode.s = TERMINATED;
+      terminatedNode.v = result;
+      return result;
+    } catch (error) {
+      // We store the first error that's thrown and rethrow it.
+      const erroredNode = cacheNode;
+      erroredNode.s = ERRORED;
+      erroredNode.v = error;
+      throw error;
+    }
+  };
+}
+
+function postpone(reason) {
+  // eslint-disable-next-line react-internal/prod-error-codes
+  const postponeInstance = new Error(reason);
+  postponeInstance.$$typeof = REACT_POSTPONE_TYPE;
+  throw postponeInstance;
+}
+
+function resolveDispatcher() {
+  const dispatcher = ReactCurrentDispatcher.current;
+  // intentionally don't throw our own error because this is in a hot path.
+  // Also helps ensure this is inlined.
+
+
+  return dispatcher;
+}
+
+function getCacheSignal() {
+  const dispatcher = ReactCurrentCache.current;
+
+  if (!dispatcher) {
+    // If we have no cache to associate with this call, then we don't know
+    // its lifetime. We abort early since that's safer than letting it live
+    // for ever. Unlike just caching which can be a functional noop outside
+    // of React, these should generally always be associated with some React
+    // render but we're not limiting quite as much as making it a Hook.
+    // It's safer than erroring early at runtime.
+    const controller = new AbortController();
+    const reason = Error(formatProdErrorMessage(455));
+    controller.abort(reason);
+    return controller.signal;
+  }
+
+  return dispatcher.getCacheSignal();
+}
+function getCacheForType(resourceType) {
+  const dispatcher = ReactCurrentCache.current;
+
+  if (!dispatcher) {
+    // If there is no dispatcher, then we treat this as not being cached.
+    return resourceType();
+  }
+
+  return dispatcher.getCacheForType(resourceType);
+}
+function useContext(Context) {
+  const dispatcher = resolveDispatcher();
+
+  return dispatcher.useContext(Context);
+}
+function useCallback(callback, deps) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useCallback(callback, deps);
+}
+function useMemo(create, deps) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useMemo(create, deps);
+}
+function useDebugValue(value, formatterFn) {
+}
+function useId() {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useId();
+}
+function use(usable) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.use(usable);
+}
+
+function createServerContext(globalName, defaultValue) {
+
+  let wasDefined = true;
+
+  if (!ContextRegistry[globalName]) {
+    wasDefined = false;
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: defaultValue,
+      _currentValue2: defaultValue,
+      _defaultValue: defaultValue,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  const context = ContextRegistry[globalName];
+
+  if (context._defaultValue === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+    context._defaultValue = defaultValue;
+
+    if (context._currentValue === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      context._currentValue = defaultValue;
+    }
+
+    if (context._currentValue2 === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      context._currentValue2 = defaultValue;
+    }
+  } else if (wasDefined) {
+    throw Error(formatProdErrorMessage(429, globalName));
+  }
+
+  return context;
+}
+
+function startTransition(scope, options) {
+
+  try {
+    scope();
+  } finally {
+  }
+}
+
+const createElement = createElement$1;
+const cloneElement = cloneElement$1;
+const Children = {
+  map: mapChildren,
+  forEach: forEachChildren,
+  count: countChildren,
+  toArray,
+  only: onlyChild
+};
+
+exports.Children = Children;
+exports.Fragment = REACT_FRAGMENT_TYPE;
+exports.Profiler = REACT_PROFILER_TYPE;
+exports.StrictMode = REACT_STRICT_MODE_TYPE;
+exports.Suspense = REACT_SUSPENSE_TYPE;
+exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternals;
+exports.__SECRET_SERVER_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactServerSharedInternals;
+exports.cache = cache;
+exports.cloneElement = cloneElement;
+exports.createElement = createElement;
+exports.createRef = createRef;
+exports.createServerContext = createServerContext;
+exports.experimental_taintObjectReference = taintObjectReference;
+exports.experimental_taintUniqueValue = taintUniqueValue;
+exports.forwardRef = forwardRef;
+exports.isValidElement = isValidElement;
+exports.lazy = lazy;
+exports.memo = memo;
+exports.startTransition = startTransition;
+exports.unstable_DebugTracingMode = REACT_DEBUG_TRACING_MODE_TYPE;
+exports.unstable_SuspenseList = REACT_SUSPENSE_LIST_TYPE;
+exports.unstable_getCacheForType = getCacheForType;
+exports.unstable_getCacheSignal = getCacheSignal;
+exports.unstable_postpone = postpone;
+exports.use = use;
+exports.useCallback = useCallback;
+exports.useContext = useContext;
+exports.useDebugValue = useDebugValue;
+exports.useId = useId;
+exports.useMemo = useMemo;
+exports.version = ReactVersion;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-experimental/cjs/react.shared-subset.production.min.js b/packages/next/src/compiled/react-experimental/cjs/react.shared-subset.production.min.js
index 3549ce426f715..aa4d917a87744 100644
--- a/packages/next/src/compiled/react-experimental/cjs/react.shared-subset.production.min.js
+++ b/packages/next/src/compiled/react-experimental/cjs/react.shared-subset.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react.shared-subset.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react.shared-subset.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var l=Object.assign,n={current:null};function p(){return new Map}
 if("function"===typeof fetch){var q=fetch,r=function(a,b){var c=n.current;if(!c||b&&b.signal&&b.signal!==c.getCacheSignal())return q(a,b);if("string"!==typeof a||b){var d="string"===typeof a||a instanceof URL?new Request(a,b):a;if("GET"!==d.method&&"HEAD"!==d.method||d.keepalive)return q(a,b);var e=JSON.stringify([d.method,Array.from(d.headers.entries()),d.mode,d.redirect,d.credentials,d.referrer,d.referrerPolicy,d.integrity]);d=d.url}else e='["GET",[],null,"follow",null,null,null,null]',d=a;var f=
 c.getCacheForType(p);c=f.get(d);if(void 0===c)a=q(a,b),f.set(d,[e,a]);else{d=0;for(f=c.length;d<f;d+=2){var h=c[d+1];if(c[d]===e)return a=h,a.then(function(g){return g.clone()})}a=q(a,b);c.push(e,a)}return a.then(function(g){return g.clone()})};l(r,q);try{fetch=r}catch(a){try{globalThis.fetch=r}catch(b){console.warn("React was unable to patch the fetch() function in this environment. Suspensey APIs might not work correctly as a result.")}}}
@@ -30,4 +30,6 @@ exports.experimental_taintObjectReference=function(a,b){a=""+(a||"A tainted valu
 exports.experimental_taintUniqueValue=function(a,b,c){a=""+(a||"A tainted value was attempted to be serialized to a Client Component or Action closure. This would leak it to the client.");if(null===b||"object"!==typeof b&&"function"!==typeof b)throw Error(C(493));if("string"!==typeof c&&"bigint"!==typeof c)if(c instanceof ba||c instanceof DataView)G.add(c.byteLength),c=String.fromCharCode.apply(String,new Uint8Array(c.buffer,c.byteOffset,c.byteLength));else{a=null===c?"null":typeof c;if("object"===
 a||"function"===a)throw Error(C(494));throw Error(C(495,a));}var d=F.get(c);void 0===d?F.set(c,{message:a,count:1}):d.count++;null!==H&&H.register(b,c)};exports.forwardRef=function(a){return{$$typeof:ka,render:a}};exports.isValidElement=U;exports.lazy=function(a){return{$$typeof:oa,_payload:{_status:-1,_result:a},_init:ta}};exports.memo=function(a,b){return{$$typeof:na,type:a,compare:void 0===b?null:b}};exports.startTransition=function(a){a()};exports.unstable_DebugTracingMode=pa;
 exports.unstable_SuspenseList=ma;exports.unstable_getCacheForType=function(a){var b=n.current;return b?b.getCacheForType(a):a()};exports.unstable_getCacheSignal=function(){var a=n.current;if(!a){a=new AbortController;var b=Error(C(455));a.abort(b);return a.signal}return a.getCacheSignal()};exports.unstable_postpone=function(a){a=Error(a);a.$$typeof=qa;throw a;};exports.use=function(a){return t.current.use(a)};exports.useCallback=function(a,b){return t.current.useCallback(a,b)};
-exports.useContext=function(a){return t.current.useContext(a)};exports.useDebugValue=function(){};exports.useId=function(){return t.current.useId()};exports.useMemo=function(a,b){return t.current.useMemo(a,b)};exports.version="18.3.0-experimental-2983249dd-20231107";
+exports.useContext=function(a){return t.current.useContext(a)};exports.useDebugValue=function(){};exports.useId=function(){return t.current.useId()};exports.useMemo=function(a,b){return t.current.useMemo(a,b)};exports.version="18.3.0-experimental-7508dcd5c-20231108";
+
+//# sourceMappingURL=react.shared-subset.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.browser.production.js b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.browser.production.js
new file mode 100644
index 0000000000000..192a94fff128c
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.browser.production.js
@@ -0,0 +1,1795 @@
+/**
+ * @license React
+ * react-server-dom-turbopack-client.browser.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var ReactDOM = require('react-dom');
+var React = require('react');
+
+function createStringDecoder() {
+  return new TextDecoder();
+}
+const decoderOptions = {
+  stream: true
+};
+function readPartialStringChunk(decoder, buffer) {
+  return decoder.decode(buffer, decoderOptions);
+}
+function readFinalStringChunk(decoder, buffer) {
+  return decoder.decode(buffer);
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+function resolveClientReference(bundlerConfig, metadata) {
+  if (bundlerConfig) {
+    const moduleExports = bundlerConfig[metadata[ID]];
+    let resolvedModuleData = moduleExports[metadata[NAME]];
+    let name;
+
+    if (resolvedModuleData) {
+      // The potentially aliased name.
+      name = resolvedModuleData.name;
+    } else {
+      // If we don't have this specific name, we might have the full module.
+      resolvedModuleData = moduleExports['*'];
+
+      if (!resolvedModuleData) {
+        throw new Error('Could not find the module "' + metadata[ID] + '" in the React SSR Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+      }
+
+      name = metadata[NAME];
+    }
+
+    if (isAsyncImport(metadata)) {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1
+      /* async */
+      ];
+    } else {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+    }
+  }
+
+  return metadata;
+}
+// If they're still pending they're a thenable. This map also exists
+// in Turbopack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = __turbopack_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+
+  for (let i = 0; i < chunks.length; i++) {
+    const chunkFilename = chunks[i];
+    const entry = chunkCache.get(chunkFilename);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkFilename);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkFilename, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkFilename, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = __turbopack_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+function loadChunk(filename) {
+  return __turbopack_load__(filename);
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+// This client file is in the shared folder because it applies to both SSR and browser contexts.
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function dispatchHint(code, model) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    switch (code) {
+      case 'D':
+        {
+          const refined = refineModel(code, model);
+          const href = refined;
+          dispatcher.prefetchDNS(href);
+          return;
+        }
+
+      case 'C':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preconnect(href);
+          } else {
+            const href = refined[0];
+            const crossOrigin = refined[1];
+            dispatcher.preconnect(href, crossOrigin);
+          }
+
+          return;
+        }
+
+      case 'L':
+        {
+          const refined = refineModel(code, model);
+          const href = refined[0];
+          const as = refined[1];
+
+          if (refined.length === 3) {
+            const options = refined[2];
+            dispatcher.preload(href, as, options);
+          } else {
+            dispatcher.preload(href, as);
+          }
+
+          return;
+        }
+
+      case 'm':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preloadModule(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preloadModule(href, options);
+          }
+
+          return;
+        }
+
+      case 'S':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitStyle(href);
+          } else {
+            const href = refined[0];
+            const precedence = refined[1] === 0 ? undefined : refined[1];
+            const options = refined.length === 3 ? refined[2] : undefined;
+            dispatcher.preinitStyle(href, precedence, options);
+          }
+
+          return;
+        }
+
+      case 'X':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitScript(href, options);
+          }
+
+          return;
+        }
+
+      case 'M':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitModuleScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitModuleScript(href, options);
+          }
+
+          return;
+        }
+    }
+  }
+} // Flow is having troulbe refining the HintModels so we help it a bit.
+// This should be compiled out in the production build.
+
+function refineModel(code, model) {
+  return model;
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+const ObjectPrototype = Object.prototype;
+const knownServerReferences = new WeakMap(); // Serializable values
+// Thenable<ReactServerValue>
+// function serializeByValueID(id: number): string {
+//   return '$' + id.toString(16);
+// }
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeFormDataReference(id) {
+  // Why K? F is "Function". D is "Date". What else?
+  return '$K' + id.toString(16);
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeMapID(id) {
+  return '$Q' + id.toString(16);
+}
+
+function serializeSetID(id) {
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+
+function processReply(root, formFieldPrefix, resolve, reject) {
+  let nextPartId = 1;
+  let pendingParts = 0;
+  let formData = null;
+
+  function resolveToJSON(key, value) {
+    const parent = this; // Make sure that `parent[key]` wasn't JSONified before `value` was passed to us
+
+    if (value === null) {
+      return null;
+    }
+
+    if (typeof value === 'object') {
+      // $FlowFixMe[method-unbinding]
+      if (typeof value.then === 'function') {
+        // We assume that any object with a .then property is a "Thenable" type,
+        // or a Promise type. Either of which can be represented by a Promise.
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        }
+
+        pendingParts++;
+        const promiseId = nextPartId++;
+        const thenable = value;
+        thenable.then(partValue => {
+          const partJSON = JSON.stringify(partValue, resolveToJSON); // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
+
+          const data = formData; // eslint-disable-next-line react-internal/safe-string-coercion
+
+          data.append(formFieldPrefix + promiseId, partJSON);
+          pendingParts--;
+
+          if (pendingParts === 0) {
+            resolve(data);
+          }
+        }, reason => {
+          // In the future we could consider serializing this as an error
+          // that throws on the server instead.
+          reject(reason);
+        });
+        return serializePromiseID(promiseId);
+      }
+
+      if (isArray(value)) {
+        // $FlowFixMe[incompatible-return]
+        return value;
+      } // TODO: Should we the Object.prototype.toString.call() to test for cross-realm objects?
+
+
+      if (value instanceof FormData) {
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to use rich objects as its values.
+          formData = new FormData();
+        }
+
+        const data = formData;
+        const refId = nextPartId++; // Copy all the form fields with a prefix for this reference.
+        // These must come first in the form order because we assume that all the
+        // fields are available before this is referenced.
+
+        const prefix = formFieldPrefix + refId + '_'; // $FlowFixMe[prop-missing]: FormData has forEach.
+
+        value.forEach((originalValue, originalKey) => {
+          data.append(prefix + originalKey, originalValue);
+        });
+        return serializeFormDataReference(refId);
+      }
+
+      if (value instanceof Map) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const mapId = nextPartId++;
+        formData.append(formFieldPrefix + mapId, partJSON);
+        return serializeMapID(mapId);
+      }
+
+      if (value instanceof Set) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const setId = nextPartId++;
+        formData.append(formFieldPrefix + setId, partJSON);
+        return serializeSetID(setId);
+      }
+
+      const iteratorFn = getIteratorFn(value);
+
+      if (iteratorFn) {
+        return Array.from(value);
+      } // Verify that this is a simple plain object.
+
+
+      const proto = getPrototypeOf(value);
+
+      if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+        throw new Error('Only plain objects, and a few built-ins, can be passed to Server Actions. ' + 'Classes or null prototypes are not supported.');
+      }
+
+
+      return value;
+    }
+
+    if (typeof value === 'string') {
+      // TODO: Maybe too clever. If we support URL there's no similar trick.
+      if (value[value.length - 1] === 'Z') {
+        // Possibly a Date, whose toJSON automatically calls toISOString
+        // $FlowFixMe[incompatible-use]
+        const originalValue = parent[key];
+
+        if (originalValue instanceof Date) {
+          return serializeDateFromDateJSON(value);
+        }
+      }
+
+      return escapeStringValue(value);
+    }
+
+    if (typeof value === 'boolean') {
+      return value;
+    }
+
+    if (typeof value === 'number') {
+      return serializeNumber(value);
+    }
+
+    if (typeof value === 'undefined') {
+      return serializeUndefined();
+    }
+
+    if (typeof value === 'function') {
+      const metaData = knownServerReferences.get(value);
+
+      if (metaData !== undefined) {
+        const metaDataJSON = JSON.stringify(metaData, resolveToJSON);
+
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        } // The reference to this function came from the same client so we can pass it back.
+
+
+        const refId = nextPartId++; // eslint-disable-next-line react-internal/safe-string-coercion
+
+        formData.set(formFieldPrefix + refId, metaDataJSON);
+        return serializeServerReferenceID(refId);
+      }
+
+      throw new Error('Client Functions cannot be passed directly to Server Functions. ' + 'Only Functions passed from the Server can be passed back again.');
+    }
+
+    if (typeof value === 'symbol') {
+      // $FlowFixMe[incompatible-type] `description` might be undefined
+      const name = value.description;
+
+      if (Symbol.for(name) !== value) {
+        throw new Error('Only global symbols received from Symbol.for(...) can be passed to Server Functions. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+        value.description + ") cannot be found among global symbols."));
+      }
+
+      return serializeSymbolReference(name);
+    }
+
+    if (typeof value === 'bigint') {
+      return serializeBigInt(value);
+    }
+
+    throw new Error("Type " + typeof value + " is not supported as an argument to a Server Function.");
+  } // $FlowFixMe[incompatible-type] it's not going to be undefined because we'll encode it.
+
+
+  const json = JSON.stringify(root, resolveToJSON);
+
+  if (formData === null) {
+    // If it's a simple data structure, we just use plain JSON.
+    resolve(json);
+  } else {
+    // Otherwise, we use FormData to let us stream in the result.
+    formData.set(formFieldPrefix + '0', json);
+
+    if (pendingParts === 0) {
+      // $FlowFixMe[incompatible-call] this has already been refined.
+      resolve(formData);
+    }
+  }
+}
+
+function registerServerReference(proxy, reference) {
+
+  knownServerReferences.set(proxy, reference);
+} // $FlowFixMe[method-unbinding]
+
+function createServerReference(id, callServer) {
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    return callServer(id, args);
+  };
+
+  registerServerReference(proxy, {
+    id,
+    bound: null
+  });
+  return proxy;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ROW_ID = 0;
+const ROW_TAG = 1;
+const ROW_LENGTH = 2;
+const ROW_CHUNK_BY_NEWLINE = 3;
+const ROW_CHUNK_BY_LENGTH = 4;
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const CYCLIC = 'cyclic';
+const RESOLVED_MODEL = 'resolved_model';
+const RESOLVED_MODULE = 'resolved_module';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function readChunk(chunk) {
+  // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      return chunk.value;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      // eslint-disable-next-line no-throw-literal
+      throw chunk;
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function createBlockedChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(BLOCKED, null, null, response);
+}
+
+function createErrorChunk(response, error) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(ERRORED, null, error, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function createResolvedModuleChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODULE, value, null, response);
+}
+
+function createInitializedTextChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function createInitializedBufferChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function resolveModuleChunk(chunk, value) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODULE;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    initializeModuleChunk(resolvedChunk);
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+  const resolvedModel = chunk.value; // We go to the CYCLIC state until we've fully resolved this.
+  // We do this before parsing in case we try to initialize the same chunk
+  // while parsing the model. Such as in a cyclic reference.
+
+  const cyclicChunk = chunk;
+  cyclicChunk.status = CYCLIC;
+  cyclicChunk.value = null;
+  cyclicChunk.reason = null;
+
+  try {
+    const value = parseModel(chunk._response, resolvedModel);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const resolveListeners = cyclicChunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, value);
+      }
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+}
+
+function initializeModuleChunk(chunk) {
+  try {
+    const value = requireModule(chunk.value);
+    const initializedChunk = chunk;
+    initializedChunk.status = INITIALIZED;
+    initializedChunk.value = value;
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function createElement(type, key, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: null,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: null
+  };
+
+  return element;
+}
+
+function createLazyChunkWrapper(chunk) {
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: chunk,
+    _init: readChunk
+  };
+  return lazyType;
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunk = createPendingChunk(response);
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key, cyclic) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+
+    if (!cyclic) {
+      blocked.deps++;
+    }
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: cyclic ? 0 : 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function createServerReferenceProxy(response, metaData) {
+  const callServer = response._callServer;
+
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    const p = metaData.bound;
+
+    if (!p) {
+      return callServer(metaData.id, args);
+    }
+
+    if (p.status === INITIALIZED) {
+      const bound = p.value;
+      return callServer(metaData.id, bound.concat(args));
+    } // Since this is a fake Promise whose .then doesn't chain, we have to wrap it.
+    // TODO: Remove the wrapper once that's fixed.
+
+
+    return Promise.resolve(p).then(function (bound) {
+      return callServer(metaData.id, bound.concat(args));
+    });
+  };
+
+  registerServerReference(proxy, metaData);
+  return proxy;
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      {
+        return chunk.value;
+      }
+    // We always encode it first in the stream so it won't be pending.
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    if (value === '$') {
+      // A very common symbol.
+      return REACT_ELEMENT_TYPE;
+    }
+
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case 'L':
+        {
+          // Lazy node
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id); // We create a React.lazy wrapper around any lazy values.
+          // When passed into React, we'll know how to suspend on this.
+
+          return createLazyChunkWrapper(chunk);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'P':
+        {
+          // Server Context Provider
+          return getOrCreateServerContext(value.slice(2)).Provider;
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16);
+          const metadata = getOutlinedModel(response, id);
+          return createServerReferenceProxy(response, metadata);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+
+            case RESOLVED_MODULE:
+              initializeModuleChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+            case CYCLIC:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key, chunk.status === CYCLIC), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function parseModelTuple(response, value) {
+  const tuple = value;
+
+  if (tuple[0] === REACT_ELEMENT_TYPE) {
+    // TODO: Consider having React just directly accept these arrays as elements.
+    // Or even change the ReactElement type to be an array.
+    return createElement(tuple[1], tuple[2], tuple[3]);
+  }
+
+  return value;
+}
+
+function missingCall() {
+  throw new Error('Trying to call a function from "use server" but the callServer option ' + 'was not implemented in your router runtime.');
+}
+
+function createResponse(bundlerConfig, moduleLoading, callServer, nonce) {
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _moduleLoading: moduleLoading,
+    _callServer: callServer !== undefined ? callServer : missingCall,
+    _nonce: nonce,
+    _chunks: chunks,
+    _stringDecoder: createStringDecoder(),
+    _fromJSON: null,
+    _rowState: 0,
+    _rowID: 0,
+    _rowTag: 0,
+    _rowLength: 0,
+    _buffer: []
+  }; // Don't inline this call because it causes closure to outline the call above.
+
+  response._fromJSON = createFromJSONCallback(response);
+  return response;
+}
+
+function resolveModel(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createResolvedModelChunk(response, model));
+  } else {
+    resolveModelChunk(chunk, model);
+  }
+}
+
+function resolveText(response, id, text) {
+  const chunks = response._chunks; // We assume that we always reference large strings after they've been
+  // emitted.
+
+  chunks.set(id, createInitializedTextChunk(response, text));
+}
+
+function resolveBuffer(response, id, buffer) {
+  const chunks = response._chunks; // We assume that we always reference buffers after they've been emitted.
+
+  chunks.set(id, createInitializedBufferChunk(response, buffer));
+}
+
+function resolveModule(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+  const clientReferenceMetadata = parseModel(response, model);
+  const clientReference = resolveClientReference(response._bundlerConfig, clientReferenceMetadata);
+  // For now we preload all modules as early as possible since it's likely
+  // that we'll need them.
+
+  const promise = preloadModule(clientReference);
+
+  if (promise) {
+    let blockedChunk;
+
+    if (!chunk) {
+      // Technically, we should just treat promise as the chunk in this
+      // case. Because it'll just behave as any other promise.
+      blockedChunk = createBlockedChunk(response);
+      chunks.set(id, blockedChunk);
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+    }
+
+    promise.then(() => resolveModuleChunk(blockedChunk, clientReference), error => triggerErrorOnChunk(blockedChunk, error));
+  } else {
+    if (!chunk) {
+      chunks.set(id, createResolvedModuleChunk(response, clientReference));
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      resolveModuleChunk(chunk, clientReference);
+    }
+  }
+}
+
+function resolveErrorProd(response, id, digest) {
+
+  const error = new Error('An error occurred in the Server Components render. The specific message is omitted in production' + ' builds to avoid leaking sensitive details. A digest property is included on this error instance which' + ' may provide additional details about the nature of the error.');
+  error.stack = 'Error: ' + error.message;
+  error.digest = digest;
+  const errorWithDigest = error;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, errorWithDigest));
+  } else {
+    triggerErrorOnChunk(chunk, errorWithDigest);
+  }
+}
+
+function resolvePostponeProd(response, id) {
+
+  const error = new Error('A Server Component was postponed. The reason is omitted in production' + ' builds to avoid leaking sensitive details.');
+  const postponeInstance = error;
+  postponeInstance.$$typeof = REACT_POSTPONE_TYPE;
+  postponeInstance.stack = 'Error: ' + error.message;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, postponeInstance));
+  } else {
+    triggerErrorOnChunk(chunk, postponeInstance);
+  }
+}
+
+function resolveHint(response, code, model) {
+  const hintModel = parseModel(response, model);
+  dispatchHint(code, hintModel);
+}
+
+function mergeBuffer(buffer, lastChunk) {
+  const l = buffer.length; // Count the bytes we'll need
+
+  let byteLength = lastChunk.length;
+
+  for (let i = 0; i < l; i++) {
+    byteLength += buffer[i].byteLength;
+  } // Allocate enough contiguous space
+
+
+  const result = new Uint8Array(byteLength);
+  let offset = 0; // Copy all the buffers into it.
+
+  for (let i = 0; i < l; i++) {
+    const chunk = buffer[i];
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+
+  result.set(lastChunk, offset);
+  return result;
+}
+
+function resolveTypedArray(response, id, buffer, lastChunk, constructor, bytesPerElement) {
+  // If the view fits into one original buffer, we just reuse that buffer instead of
+  // copying it out to a separate copy. This means that it's not always possible to
+  // transfer these values to other threads without copying first since they may
+  // share array buffer. For this to work, it must also have bytes aligned to a
+  // multiple of a size of the type.
+  const chunk = buffer.length === 0 && lastChunk.byteOffset % bytesPerElement === 0 ? lastChunk : mergeBuffer(buffer, lastChunk); // TODO: The transfer protocol of RSC is little-endian. If the client isn't little-endian
+  // we should convert it instead. In practice big endian isn't really Web compatible so it's
+  // somewhat safe to assume that browsers aren't going to run it, but maybe there's some SSR
+  // server that's affected.
+
+  const view = new constructor(chunk.buffer, chunk.byteOffset, chunk.byteLength / bytesPerElement);
+  resolveBuffer(response, id, view);
+}
+
+function processFullRow(response, id, tag, buffer, chunk) {
+  {
+    switch (tag) {
+      case 65
+      /* "A" */
+      :
+        // We must always clone to extract it into a separate buffer instead of just a view.
+        resolveBuffer(response, id, mergeBuffer(buffer, chunk).buffer);
+        return;
+
+      case 67
+      /* "C" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int8Array, 1);
+        return;
+
+      case 99
+      /* "c" */
+      :
+        resolveBuffer(response, id, buffer.length === 0 ? chunk : mergeBuffer(buffer, chunk));
+        return;
+
+      case 85
+      /* "U" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint8ClampedArray, 1);
+        return;
+
+      case 83
+      /* "S" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int16Array, 2);
+        return;
+
+      case 115
+      /* "s" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint16Array, 2);
+        return;
+
+      case 76
+      /* "L" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int32Array, 4);
+        return;
+
+      case 108
+      /* "l" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint32Array, 4);
+        return;
+
+      case 70
+      /* "F" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Float32Array, 4);
+        return;
+
+      case 68
+      /* "D" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Float64Array, 8);
+        return;
+
+      case 78
+      /* "N" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, BigInt64Array, 8);
+        return;
+
+      case 109
+      /* "m" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, BigUint64Array, 8);
+        return;
+
+      case 86
+      /* "V" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, DataView, 1);
+        return;
+    }
+  }
+
+  const stringDecoder = response._stringDecoder;
+  let row = '';
+
+  for (let i = 0; i < buffer.length; i++) {
+    row += readPartialStringChunk(stringDecoder, buffer[i]);
+  }
+
+  row += readFinalStringChunk(stringDecoder, chunk);
+
+  switch (tag) {
+    case 73
+    /* "I" */
+    :
+      {
+        resolveModule(response, id, row);
+        return;
+      }
+
+    case 72
+    /* "H" */
+    :
+      {
+        const code = row[0];
+        resolveHint(response, code, row.slice(1));
+        return;
+      }
+
+    case 69
+    /* "E" */
+    :
+      {
+        const errorInfo = JSON.parse(row);
+
+        {
+          resolveErrorProd(response, id, errorInfo.digest);
+        }
+
+        return;
+      }
+
+    case 84
+    /* "T" */
+    :
+      {
+        resolveText(response, id, row);
+        return;
+      }
+
+    case 80
+    /* "P" */
+    :
+      {
+        {
+          {
+            resolvePostponeProd(response, id);
+          }
+
+          return;
+        }
+      }
+    // Fallthrough
+
+    default:
+      /* """ "{" "[" "t" "f" "n" "0" - "9" */
+      {
+        // We assume anything else is JSON.
+        resolveModel(response, id, row);
+        return;
+      }
+  }
+}
+
+function processBinaryChunk(response, chunk) {
+  let i = 0;
+  let rowState = response._rowState;
+  let rowID = response._rowID;
+  let rowTag = response._rowTag;
+  let rowLength = response._rowLength;
+  const buffer = response._buffer;
+  const chunkLength = chunk.length;
+
+  while (i < chunkLength) {
+    let lastIdx = -1;
+
+    switch (rowState) {
+      case ROW_ID:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 58
+          /* ":" */
+          ) {
+              // Finished the rowID, next we'll parse the tag.
+              rowState = ROW_TAG;
+            } else {
+            rowID = rowID << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_TAG:
+        {
+          const resolvedRowTag = chunk[i];
+
+          if (resolvedRowTag === 84
+          /* "T" */
+          || (resolvedRowTag === 65
+          /* "A" */
+          || resolvedRowTag === 67
+          /* "C" */
+          || resolvedRowTag === 99
+          /* "c" */
+          || resolvedRowTag === 85
+          /* "U" */
+          || resolvedRowTag === 83
+          /* "S" */
+          || resolvedRowTag === 115
+          /* "s" */
+          || resolvedRowTag === 76
+          /* "L" */
+          || resolvedRowTag === 108
+          /* "l" */
+          || resolvedRowTag === 70
+          /* "F" */
+          || resolvedRowTag === 68
+          /* "D" */
+          || resolvedRowTag === 78
+          /* "N" */
+          || resolvedRowTag === 109
+          /* "m" */
+          || resolvedRowTag === 86)
+          /* "V" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_LENGTH;
+              i++;
+            } else if (resolvedRowTag > 64 && resolvedRowTag < 91
+          /* "A"-"Z" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_CHUNK_BY_NEWLINE;
+              i++;
+            } else {
+            rowTag = 0;
+            rowState = ROW_CHUNK_BY_NEWLINE; // This was an unknown tag so it was probably part of the data.
+          }
+
+          continue;
+        }
+
+      case ROW_LENGTH:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 44
+          /* "," */
+          ) {
+              // Finished the rowLength, next we'll buffer up to that length.
+              rowState = ROW_CHUNK_BY_LENGTH;
+            } else {
+            rowLength = rowLength << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_CHUNK_BY_NEWLINE:
+        {
+          // We're looking for a newline
+          lastIdx = chunk.indexOf(10
+          /* "\n" */
+          , i);
+          break;
+        }
+
+      case ROW_CHUNK_BY_LENGTH:
+        {
+          // We're looking for the remaining byte length
+          lastIdx = i + rowLength;
+
+          if (lastIdx > chunk.length) {
+            lastIdx = -1;
+          }
+
+          break;
+        }
+    }
+
+    const offset = chunk.byteOffset + i;
+
+    if (lastIdx > -1) {
+      // We found the last chunk of the row
+      const length = lastIdx - i;
+      const lastChunk = new Uint8Array(chunk.buffer, offset, length);
+      processFullRow(response, rowID, rowTag, buffer, lastChunk); // Reset state machine for a new row
+
+      i = lastIdx;
+
+      if (rowState === ROW_CHUNK_BY_NEWLINE) {
+        // If we're trailing by a newline we need to skip it.
+        i++;
+      }
+
+      rowState = ROW_ID;
+      rowTag = 0;
+      rowID = 0;
+      rowLength = 0;
+      buffer.length = 0;
+    } else {
+      // The rest of this row is in a future chunk. We stash the rest of the
+      // current chunk until we can process the full row.
+      const length = chunk.byteLength - i;
+      const remainingSlice = new Uint8Array(chunk.buffer, offset, length);
+      buffer.push(remainingSlice); // Update how many bytes we're still waiting for. If we're looking for
+      // a newline, this doesn't hurt since we'll just ignore it.
+
+      rowLength -= remainingSlice.byteLength;
+      break;
+    }
+  }
+
+  response._rowState = rowState;
+  response._rowID = rowID;
+  response._rowTag = rowTag;
+  response._rowLength = rowLength;
+}
+
+function parseModel(response, json) {
+  return JSON.parse(json, response._fromJSON);
+}
+
+function createFromJSONCallback(response) {
+  // $FlowFixMe[missing-this-annot]
+  return function (key, value) {
+    if (typeof value === 'string') {
+      // We can't use .bind here because we need the "this" value.
+      return parseModelString(response, this, key, value);
+    }
+
+    if (typeof value === 'object' && value !== null) {
+      return parseModelTuple(response, value);
+    }
+
+    return value;
+  };
+}
+
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function createResponseFromOptions(options) {
+  return createResponse(null, null, options && options.callServer ? options.callServer : undefined, undefined // nonce
+  );
+}
+
+function startReadingFromStream(response, stream) {
+  const reader = stream.getReader();
+
+  function progress(_ref) {
+    let done = _ref.done,
+        value = _ref.value;
+
+    if (done) {
+      close(response);
+      return;
+    }
+
+    const buffer = value;
+    processBinaryChunk(response, buffer);
+    return reader.read().then(progress).catch(error);
+  }
+
+  function error(e) {
+    reportGlobalError(response, e);
+  }
+
+  reader.read().then(progress).catch(error);
+}
+
+function createFromReadableStream(stream, options) {
+  const response = createResponseFromOptions(options);
+  startReadingFromStream(response, stream);
+  return getRoot(response);
+}
+
+function createFromFetch(promiseForResponse, options) {
+  const response = createResponseFromOptions(options);
+  promiseForResponse.then(function (r) {
+    startReadingFromStream(response, r.body);
+  }, function (e) {
+    reportGlobalError(response, e);
+  });
+  return getRoot(response);
+}
+
+function encodeReply(value)
+/* We don't use URLSearchParams yet but maybe */
+{
+  return new Promise((resolve, reject) => {
+    processReply(value, '', resolve, reject);
+  });
+}
+
+exports.createFromFetch = createFromFetch;
+exports.createFromReadableStream = createFromReadableStream;
+exports.createServerReference = createServerReference;
+exports.encodeReply = encodeReply;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.browser.production.min.js b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.browser.production.min.js
index c0a64b99b0f9e..3a4874dc3eefe 100644
--- a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.browser.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.browser.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-turbopack-client.browser.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-turbopack-client.browser.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var p=require("react-dom"),q=require("react"),r={stream:!0};function u(a,b){if(a){var c=a[b[0]];if(a=c[b[2]])c=a.name;else{a=c["*"];if(!a)throw Error('Could not find the module "'+b[0]+'" in the React SSR Manifest. This is probably a bug in the React Server Components bundler.');c=b[2]}return 4===b.length?[a.id,a.chunks,c,1]:[a.id,a.chunks,c]}return b}var w=new Map;
 function x(a){var b=__turbopack_require__(a);if("function"!==typeof b.then||"fulfilled"===b.status)return null;b.then(function(c){b.status="fulfilled";b.value=c},function(c){b.status="rejected";b.reason=c});return b}function y(){}
 function z(a){for(var b=a[1],c=[],d=0;d<b.length;d++){var f=b[d],h=w.get(f);if(void 0===h){h=__turbopack_load__(f);c.push(h);var e=w.set.bind(w,f,null);h.then(e,y);w.set(f,h)}else null!==h&&c.push(h)}return 4===a.length?0===c.length?x(a[0]):Promise.all(c).then(function(){return x(a[0])}):0<c.length?Promise.all(c):null}
@@ -38,3 +38,5 @@ function Z(a,b){function c(h){var e=h.value;if(h.done)S(a,Error("Connection clos
 48);continue;case 3:m=e.indexOf(10,l);break;case 4:m=l+n,m>e.length&&(m=-1)}var t=e.byteOffset+l;if(-1<m)n=new Uint8Array(e.buffer,t,m-l),sa(a,h,g,v,n),l=m,3===k&&l++,n=h=g=k=0,v.length=0;else{e=new Uint8Array(e.buffer,t,e.byteLength-l);v.push(e);n-=e.byteLength;break}}a._rowState=k;a._rowID=h;a._rowTag=g;a._rowLength=n;return f.read().then(c).catch(d)}}function d(h){S(a,h)}var f=b.getReader();f.read().then(c).catch(d)}
 exports.createFromFetch=function(a,b){var c=V(null,null,b&&b.callServer?b.callServer:void 0,void 0);a.then(function(d){Z(c,d.body)},function(d){S(c,d)});return T(c,0)};exports.createFromReadableStream=function(a,b){b=V(null,null,b&&b.callServer?b.callServer:void 0,void 0);Z(b,a);return T(b,0)};exports.createServerReference=function(a,b){function c(){var d=Array.prototype.slice.call(arguments);return b(a,d)}H(c,{id:a,bound:null});return c};
 exports.encodeReply=function(a){return new Promise(function(b,c){ja(a,"",b,c)})};
+
+//# sourceMappingURL=react-server-dom-turbopack-client.browser.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.edge.production.js b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.edge.production.js
new file mode 100644
index 0000000000000..ae79646528dff
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.edge.production.js
@@ -0,0 +1,2024 @@
+/**
+ * @license React
+ * react-server-dom-turbopack-client.edge.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var ReactDOM = require('react-dom');
+var React = require('react');
+
+function createStringDecoder() {
+  return new TextDecoder();
+}
+const decoderOptions = {
+  stream: true
+};
+function readPartialStringChunk(decoder, buffer) {
+  return decoder.decode(buffer, decoderOptions);
+}
+function readFinalStringChunk(decoder, buffer) {
+  return decoder.decode(buffer);
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+// The reason this function needs to defined here in this file instead of just
+// being exported directly from the TurbopackDestination... file is because the
+// ClientReferenceMetadata is opaque and we can't unwrap it there.
+// This should get inlined and we could also just implement an unwrapping function
+// though that risks it getting used in places it shouldn't be. This is unfortunate
+// but currently it seems to be the best option we have.
+
+function prepareDestinationForModule(moduleLoading, nonce, metadata) {
+  prepareDestinationWithChunks(moduleLoading, metadata[CHUNKS], nonce);
+}
+function resolveClientReference(bundlerConfig, metadata) {
+  if (bundlerConfig) {
+    const moduleExports = bundlerConfig[metadata[ID]];
+    let resolvedModuleData = moduleExports[metadata[NAME]];
+    let name;
+
+    if (resolvedModuleData) {
+      // The potentially aliased name.
+      name = resolvedModuleData.name;
+    } else {
+      // If we don't have this specific name, we might have the full module.
+      resolvedModuleData = moduleExports['*'];
+
+      if (!resolvedModuleData) {
+        throw new Error('Could not find the module "' + metadata[ID] + '" in the React SSR Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+      }
+
+      name = metadata[NAME];
+    }
+
+    if (isAsyncImport(metadata)) {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1
+      /* async */
+      ];
+    } else {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+    }
+  }
+
+  return metadata;
+}
+// If they're still pending they're a thenable. This map also exists
+// in Turbopack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = globalThis.__next_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+
+  for (let i = 0; i < chunks.length; i++) {
+    const chunkFilename = chunks[i];
+    const entry = chunkCache.get(chunkFilename);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkFilename);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkFilename, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkFilename, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = globalThis.__next_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+function loadChunk(filename) {
+  return globalThis.__next_chunk_load__(filename);
+}
+
+function prepareDestinationWithChunks(moduleLoading, // Chunks are single-indexed filenames
+chunks, nonce) {
+  if (moduleLoading !== null) {
+    for (let i = 0; i < chunks.length; i++) {
+      preinitScriptForSSR(moduleLoading.prefix + chunks[i], nonce, moduleLoading.crossOrigin);
+    }
+  }
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// This client file is in the shared folder because it applies to both SSR and browser contexts.
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function dispatchHint(code, model) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    switch (code) {
+      case 'D':
+        {
+          const refined = refineModel(code, model);
+          const href = refined;
+          dispatcher.prefetchDNS(href);
+          return;
+        }
+
+      case 'C':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preconnect(href);
+          } else {
+            const href = refined[0];
+            const crossOrigin = refined[1];
+            dispatcher.preconnect(href, crossOrigin);
+          }
+
+          return;
+        }
+
+      case 'L':
+        {
+          const refined = refineModel(code, model);
+          const href = refined[0];
+          const as = refined[1];
+
+          if (refined.length === 3) {
+            const options = refined[2];
+            dispatcher.preload(href, as, options);
+          } else {
+            dispatcher.preload(href, as);
+          }
+
+          return;
+        }
+
+      case 'm':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preloadModule(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preloadModule(href, options);
+          }
+
+          return;
+        }
+
+      case 'S':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitStyle(href);
+          } else {
+            const href = refined[0];
+            const precedence = refined[1] === 0 ? undefined : refined[1];
+            const options = refined.length === 3 ? refined[2] : undefined;
+            dispatcher.preinitStyle(href, precedence, options);
+          }
+
+          return;
+        }
+
+      case 'X':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitScript(href, options);
+          }
+
+          return;
+        }
+
+      case 'M':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitModuleScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitModuleScript(href, options);
+          }
+
+          return;
+        }
+    }
+  }
+} // Flow is having troulbe refining the HintModels so we help it a bit.
+// This should be compiled out in the production build.
+
+function refineModel(code, model) {
+  return model;
+}
+function preinitScriptForSSR(href, nonce, crossOrigin) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    dispatcher.preinitScript(href, {
+      crossOrigin: getCrossOriginString(crossOrigin),
+      nonce
+    });
+  }
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+const ObjectPrototype = Object.prototype;
+const knownServerReferences = new WeakMap(); // Serializable values
+// Thenable<ReactServerValue>
+// function serializeByValueID(id: number): string {
+//   return '$' + id.toString(16);
+// }
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeFormDataReference(id) {
+  // Why K? F is "Function". D is "Date". What else?
+  return '$K' + id.toString(16);
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeMapID(id) {
+  return '$Q' + id.toString(16);
+}
+
+function serializeSetID(id) {
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+
+function processReply(root, formFieldPrefix, resolve, reject) {
+  let nextPartId = 1;
+  let pendingParts = 0;
+  let formData = null;
+
+  function resolveToJSON(key, value) {
+    const parent = this; // Make sure that `parent[key]` wasn't JSONified before `value` was passed to us
+
+    if (value === null) {
+      return null;
+    }
+
+    if (typeof value === 'object') {
+      // $FlowFixMe[method-unbinding]
+      if (typeof value.then === 'function') {
+        // We assume that any object with a .then property is a "Thenable" type,
+        // or a Promise type. Either of which can be represented by a Promise.
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        }
+
+        pendingParts++;
+        const promiseId = nextPartId++;
+        const thenable = value;
+        thenable.then(partValue => {
+          const partJSON = JSON.stringify(partValue, resolveToJSON); // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
+
+          const data = formData; // eslint-disable-next-line react-internal/safe-string-coercion
+
+          data.append(formFieldPrefix + promiseId, partJSON);
+          pendingParts--;
+
+          if (pendingParts === 0) {
+            resolve(data);
+          }
+        }, reason => {
+          // In the future we could consider serializing this as an error
+          // that throws on the server instead.
+          reject(reason);
+        });
+        return serializePromiseID(promiseId);
+      }
+
+      if (isArray(value)) {
+        // $FlowFixMe[incompatible-return]
+        return value;
+      } // TODO: Should we the Object.prototype.toString.call() to test for cross-realm objects?
+
+
+      if (value instanceof FormData) {
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to use rich objects as its values.
+          formData = new FormData();
+        }
+
+        const data = formData;
+        const refId = nextPartId++; // Copy all the form fields with a prefix for this reference.
+        // These must come first in the form order because we assume that all the
+        // fields are available before this is referenced.
+
+        const prefix = formFieldPrefix + refId + '_'; // $FlowFixMe[prop-missing]: FormData has forEach.
+
+        value.forEach((originalValue, originalKey) => {
+          data.append(prefix + originalKey, originalValue);
+        });
+        return serializeFormDataReference(refId);
+      }
+
+      if (value instanceof Map) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const mapId = nextPartId++;
+        formData.append(formFieldPrefix + mapId, partJSON);
+        return serializeMapID(mapId);
+      }
+
+      if (value instanceof Set) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const setId = nextPartId++;
+        formData.append(formFieldPrefix + setId, partJSON);
+        return serializeSetID(setId);
+      }
+
+      const iteratorFn = getIteratorFn(value);
+
+      if (iteratorFn) {
+        return Array.from(value);
+      } // Verify that this is a simple plain object.
+
+
+      const proto = getPrototypeOf(value);
+
+      if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+        throw new Error('Only plain objects, and a few built-ins, can be passed to Server Actions. ' + 'Classes or null prototypes are not supported.');
+      }
+
+
+      return value;
+    }
+
+    if (typeof value === 'string') {
+      // TODO: Maybe too clever. If we support URL there's no similar trick.
+      if (value[value.length - 1] === 'Z') {
+        // Possibly a Date, whose toJSON automatically calls toISOString
+        // $FlowFixMe[incompatible-use]
+        const originalValue = parent[key];
+
+        if (originalValue instanceof Date) {
+          return serializeDateFromDateJSON(value);
+        }
+      }
+
+      return escapeStringValue(value);
+    }
+
+    if (typeof value === 'boolean') {
+      return value;
+    }
+
+    if (typeof value === 'number') {
+      return serializeNumber(value);
+    }
+
+    if (typeof value === 'undefined') {
+      return serializeUndefined();
+    }
+
+    if (typeof value === 'function') {
+      const metaData = knownServerReferences.get(value);
+
+      if (metaData !== undefined) {
+        const metaDataJSON = JSON.stringify(metaData, resolveToJSON);
+
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        } // The reference to this function came from the same client so we can pass it back.
+
+
+        const refId = nextPartId++; // eslint-disable-next-line react-internal/safe-string-coercion
+
+        formData.set(formFieldPrefix + refId, metaDataJSON);
+        return serializeServerReferenceID(refId);
+      }
+
+      throw new Error('Client Functions cannot be passed directly to Server Functions. ' + 'Only Functions passed from the Server can be passed back again.');
+    }
+
+    if (typeof value === 'symbol') {
+      // $FlowFixMe[incompatible-type] `description` might be undefined
+      const name = value.description;
+
+      if (Symbol.for(name) !== value) {
+        throw new Error('Only global symbols received from Symbol.for(...) can be passed to Server Functions. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+        value.description + ") cannot be found among global symbols."));
+      }
+
+      return serializeSymbolReference(name);
+    }
+
+    if (typeof value === 'bigint') {
+      return serializeBigInt(value);
+    }
+
+    throw new Error("Type " + typeof value + " is not supported as an argument to a Server Function.");
+  } // $FlowFixMe[incompatible-type] it's not going to be undefined because we'll encode it.
+
+
+  const json = JSON.stringify(root, resolveToJSON);
+
+  if (formData === null) {
+    // If it's a simple data structure, we just use plain JSON.
+    resolve(json);
+  } else {
+    // Otherwise, we use FormData to let us stream in the result.
+    formData.set(formFieldPrefix + '0', json);
+
+    if (pendingParts === 0) {
+      // $FlowFixMe[incompatible-call] this has already been refined.
+      resolve(formData);
+    }
+  }
+}
+const boundCache = new WeakMap();
+
+function encodeFormData(reference) {
+  let resolve, reject; // We need to have a handle on the thenable so that we can synchronously set
+  // its status from processReply, when it can complete synchronously.
+
+  const thenable = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  processReply(reference, '', body => {
+    if (typeof body === 'string') {
+      const data = new FormData();
+      data.append('0', body);
+      body = data;
+    }
+
+    const fulfilled = thenable;
+    fulfilled.status = 'fulfilled';
+    fulfilled.value = body;
+    resolve(body);
+  }, e => {
+    const rejected = thenable;
+    rejected.status = 'rejected';
+    rejected.reason = e;
+    reject(e);
+  });
+  return thenable;
+}
+
+function encodeFormAction(identifierPrefix) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  let data = null;
+  let name;
+  const boundPromise = reference.bound;
+
+  if (boundPromise !== null) {
+    let thenable = boundCache.get(reference);
+
+    if (!thenable) {
+      thenable = encodeFormData(reference);
+      boundCache.set(reference, thenable);
+    }
+
+    if (thenable.status === 'rejected') {
+      throw thenable.reason;
+    } else if (thenable.status !== 'fulfilled') {
+      throw thenable;
+    }
+
+    const encodedFormData = thenable.value; // This is hacky but we need the identifier prefix to be added to
+    // all fields but the suspense cache would break since we might get
+    // a new identifier each time. So we just append it at the end instead.
+
+    const prefixedData = new FormData(); // $FlowFixMe[prop-missing]
+
+    encodedFormData.forEach((value, key) => {
+      prefixedData.append('$ACTION_' + identifierPrefix + ':' + key, value);
+    });
+    data = prefixedData; // We encode the name of the prefix containing the data.
+
+    name = '$ACTION_REF_' + identifierPrefix;
+  } else {
+    // This is the simple case so we can just encode the ID.
+    name = '$ACTION_ID_' + reference.id;
+  }
+
+  return {
+    name: name,
+    method: 'POST',
+    encType: 'multipart/form-data',
+    data: data
+  };
+}
+
+function isSignatureEqual(referenceId, numberOfBoundArgs) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  if (reference.id !== referenceId) {
+    // These are different functions.
+    return false;
+  } // Now check if the number of bound arguments is the same.
+
+
+  const boundPromise = reference.bound;
+
+  if (boundPromise === null) {
+    // No bound arguments.
+    return numberOfBoundArgs === 0;
+  } // Unwrap the bound arguments array by suspending, if necessary. As with
+  // encodeFormData, this means isSignatureEqual can only be called while React
+  // is rendering.
+
+
+  switch (boundPromise.status) {
+    case 'fulfilled':
+      {
+        const boundArgs = boundPromise.value;
+        return boundArgs.length === numberOfBoundArgs;
+      }
+
+    case 'pending':
+      {
+        throw boundPromise;
+      }
+
+    case 'rejected':
+      {
+        throw boundPromise.reason;
+      }
+
+    default:
+      {
+        if (typeof boundPromise.status === 'string') ; else {
+          const pendingThenable = boundPromise;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(boundArgs => {
+            const fulfilledThenable = boundPromise;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = boundArgs;
+          }, error => {
+            const rejectedThenable = boundPromise;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          });
+        }
+
+        throw boundPromise;
+      }
+  }
+}
+
+function registerServerReference(proxy, reference) {
+  // Expose encoder for use by SSR, as well as a special bind that can be used to
+  // keep server capabilities.
+  {
+    // Only expose this in builds that would actually use it. Not needed on the client.
+    Object.defineProperties(proxy, {
+      $$FORM_ACTION: {
+        value: encodeFormAction
+      },
+      $$IS_SIGNATURE_EQUAL: {
+        value: isSignatureEqual
+      },
+      bind: {
+        value: bind
+      }
+    });
+  }
+
+  knownServerReferences.set(proxy, reference);
+} // $FlowFixMe[method-unbinding]
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+  const reference = knownServerReferences.get(this);
+
+  if (reference) {
+    const args = ArraySlice.call(arguments, 1);
+    let boundPromise = null;
+
+    if (reference.bound !== null) {
+      boundPromise = Promise.resolve(reference.bound).then(boundArgs => boundArgs.concat(args));
+    } else {
+      boundPromise = Promise.resolve(args);
+    }
+
+    registerServerReference(newFn, {
+      id: reference.id,
+      bound: boundPromise
+    });
+  }
+
+  return newFn;
+}
+
+function createServerReference$1(id, callServer) {
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    return callServer(id, args);
+  };
+
+  registerServerReference(proxy, {
+    id,
+    bound: null
+  });
+  return proxy;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ROW_ID = 0;
+const ROW_TAG = 1;
+const ROW_LENGTH = 2;
+const ROW_CHUNK_BY_NEWLINE = 3;
+const ROW_CHUNK_BY_LENGTH = 4;
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const CYCLIC = 'cyclic';
+const RESOLVED_MODEL = 'resolved_model';
+const RESOLVED_MODULE = 'resolved_module';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function readChunk(chunk) {
+  // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      return chunk.value;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      // eslint-disable-next-line no-throw-literal
+      throw chunk;
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function createBlockedChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(BLOCKED, null, null, response);
+}
+
+function createErrorChunk(response, error) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(ERRORED, null, error, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function createResolvedModuleChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODULE, value, null, response);
+}
+
+function createInitializedTextChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function createInitializedBufferChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function resolveModuleChunk(chunk, value) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODULE;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    initializeModuleChunk(resolvedChunk);
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+  const resolvedModel = chunk.value; // We go to the CYCLIC state until we've fully resolved this.
+  // We do this before parsing in case we try to initialize the same chunk
+  // while parsing the model. Such as in a cyclic reference.
+
+  const cyclicChunk = chunk;
+  cyclicChunk.status = CYCLIC;
+  cyclicChunk.value = null;
+  cyclicChunk.reason = null;
+
+  try {
+    const value = parseModel(chunk._response, resolvedModel);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const resolveListeners = cyclicChunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, value);
+      }
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+}
+
+function initializeModuleChunk(chunk) {
+  try {
+    const value = requireModule(chunk.value);
+    const initializedChunk = chunk;
+    initializedChunk.status = INITIALIZED;
+    initializedChunk.value = value;
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function createElement(type, key, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: null,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: null
+  };
+
+  return element;
+}
+
+function createLazyChunkWrapper(chunk) {
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: chunk,
+    _init: readChunk
+  };
+  return lazyType;
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunk = createPendingChunk(response);
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key, cyclic) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+
+    if (!cyclic) {
+      blocked.deps++;
+    }
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: cyclic ? 0 : 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function createServerReferenceProxy(response, metaData) {
+  const callServer = response._callServer;
+
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    const p = metaData.bound;
+
+    if (!p) {
+      return callServer(metaData.id, args);
+    }
+
+    if (p.status === INITIALIZED) {
+      const bound = p.value;
+      return callServer(metaData.id, bound.concat(args));
+    } // Since this is a fake Promise whose .then doesn't chain, we have to wrap it.
+    // TODO: Remove the wrapper once that's fixed.
+
+
+    return Promise.resolve(p).then(function (bound) {
+      return callServer(metaData.id, bound.concat(args));
+    });
+  };
+
+  registerServerReference(proxy, metaData);
+  return proxy;
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      {
+        return chunk.value;
+      }
+    // We always encode it first in the stream so it won't be pending.
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    if (value === '$') {
+      // A very common symbol.
+      return REACT_ELEMENT_TYPE;
+    }
+
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case 'L':
+        {
+          // Lazy node
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id); // We create a React.lazy wrapper around any lazy values.
+          // When passed into React, we'll know how to suspend on this.
+
+          return createLazyChunkWrapper(chunk);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'P':
+        {
+          // Server Context Provider
+          return getOrCreateServerContext(value.slice(2)).Provider;
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16);
+          const metadata = getOutlinedModel(response, id);
+          return createServerReferenceProxy(response, metadata);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+
+            case RESOLVED_MODULE:
+              initializeModuleChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+            case CYCLIC:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key, chunk.status === CYCLIC), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function parseModelTuple(response, value) {
+  const tuple = value;
+
+  if (tuple[0] === REACT_ELEMENT_TYPE) {
+    // TODO: Consider having React just directly accept these arrays as elements.
+    // Or even change the ReactElement type to be an array.
+    return createElement(tuple[1], tuple[2], tuple[3]);
+  }
+
+  return value;
+}
+
+function missingCall() {
+  throw new Error('Trying to call a function from "use server" but the callServer option ' + 'was not implemented in your router runtime.');
+}
+
+function createResponse(bundlerConfig, moduleLoading, callServer, nonce) {
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _moduleLoading: moduleLoading,
+    _callServer: callServer !== undefined ? callServer : missingCall,
+    _nonce: nonce,
+    _chunks: chunks,
+    _stringDecoder: createStringDecoder(),
+    _fromJSON: null,
+    _rowState: 0,
+    _rowID: 0,
+    _rowTag: 0,
+    _rowLength: 0,
+    _buffer: []
+  }; // Don't inline this call because it causes closure to outline the call above.
+
+  response._fromJSON = createFromJSONCallback(response);
+  return response;
+}
+
+function resolveModel(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createResolvedModelChunk(response, model));
+  } else {
+    resolveModelChunk(chunk, model);
+  }
+}
+
+function resolveText(response, id, text) {
+  const chunks = response._chunks; // We assume that we always reference large strings after they've been
+  // emitted.
+
+  chunks.set(id, createInitializedTextChunk(response, text));
+}
+
+function resolveBuffer(response, id, buffer) {
+  const chunks = response._chunks; // We assume that we always reference buffers after they've been emitted.
+
+  chunks.set(id, createInitializedBufferChunk(response, buffer));
+}
+
+function resolveModule(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+  const clientReferenceMetadata = parseModel(response, model);
+  const clientReference = resolveClientReference(response._bundlerConfig, clientReferenceMetadata);
+  prepareDestinationForModule(response._moduleLoading, response._nonce, clientReferenceMetadata); // TODO: Add an option to encode modules that are lazy loaded.
+  // For now we preload all modules as early as possible since it's likely
+  // that we'll need them.
+
+  const promise = preloadModule(clientReference);
+
+  if (promise) {
+    let blockedChunk;
+
+    if (!chunk) {
+      // Technically, we should just treat promise as the chunk in this
+      // case. Because it'll just behave as any other promise.
+      blockedChunk = createBlockedChunk(response);
+      chunks.set(id, blockedChunk);
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+    }
+
+    promise.then(() => resolveModuleChunk(blockedChunk, clientReference), error => triggerErrorOnChunk(blockedChunk, error));
+  } else {
+    if (!chunk) {
+      chunks.set(id, createResolvedModuleChunk(response, clientReference));
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      resolveModuleChunk(chunk, clientReference);
+    }
+  }
+}
+
+function resolveErrorProd(response, id, digest) {
+
+  const error = new Error('An error occurred in the Server Components render. The specific message is omitted in production' + ' builds to avoid leaking sensitive details. A digest property is included on this error instance which' + ' may provide additional details about the nature of the error.');
+  error.stack = 'Error: ' + error.message;
+  error.digest = digest;
+  const errorWithDigest = error;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, errorWithDigest));
+  } else {
+    triggerErrorOnChunk(chunk, errorWithDigest);
+  }
+}
+
+function resolvePostponeProd(response, id) {
+
+  const error = new Error('A Server Component was postponed. The reason is omitted in production' + ' builds to avoid leaking sensitive details.');
+  const postponeInstance = error;
+  postponeInstance.$$typeof = REACT_POSTPONE_TYPE;
+  postponeInstance.stack = 'Error: ' + error.message;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, postponeInstance));
+  } else {
+    triggerErrorOnChunk(chunk, postponeInstance);
+  }
+}
+
+function resolveHint(response, code, model) {
+  const hintModel = parseModel(response, model);
+  dispatchHint(code, hintModel);
+}
+
+function mergeBuffer(buffer, lastChunk) {
+  const l = buffer.length; // Count the bytes we'll need
+
+  let byteLength = lastChunk.length;
+
+  for (let i = 0; i < l; i++) {
+    byteLength += buffer[i].byteLength;
+  } // Allocate enough contiguous space
+
+
+  const result = new Uint8Array(byteLength);
+  let offset = 0; // Copy all the buffers into it.
+
+  for (let i = 0; i < l; i++) {
+    const chunk = buffer[i];
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+
+  result.set(lastChunk, offset);
+  return result;
+}
+
+function resolveTypedArray(response, id, buffer, lastChunk, constructor, bytesPerElement) {
+  // If the view fits into one original buffer, we just reuse that buffer instead of
+  // copying it out to a separate copy. This means that it's not always possible to
+  // transfer these values to other threads without copying first since they may
+  // share array buffer. For this to work, it must also have bytes aligned to a
+  // multiple of a size of the type.
+  const chunk = buffer.length === 0 && lastChunk.byteOffset % bytesPerElement === 0 ? lastChunk : mergeBuffer(buffer, lastChunk); // TODO: The transfer protocol of RSC is little-endian. If the client isn't little-endian
+  // we should convert it instead. In practice big endian isn't really Web compatible so it's
+  // somewhat safe to assume that browsers aren't going to run it, but maybe there's some SSR
+  // server that's affected.
+
+  const view = new constructor(chunk.buffer, chunk.byteOffset, chunk.byteLength / bytesPerElement);
+  resolveBuffer(response, id, view);
+}
+
+function processFullRow(response, id, tag, buffer, chunk) {
+  {
+    switch (tag) {
+      case 65
+      /* "A" */
+      :
+        // We must always clone to extract it into a separate buffer instead of just a view.
+        resolveBuffer(response, id, mergeBuffer(buffer, chunk).buffer);
+        return;
+
+      case 67
+      /* "C" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int8Array, 1);
+        return;
+
+      case 99
+      /* "c" */
+      :
+        resolveBuffer(response, id, buffer.length === 0 ? chunk : mergeBuffer(buffer, chunk));
+        return;
+
+      case 85
+      /* "U" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint8ClampedArray, 1);
+        return;
+
+      case 83
+      /* "S" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int16Array, 2);
+        return;
+
+      case 115
+      /* "s" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint16Array, 2);
+        return;
+
+      case 76
+      /* "L" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int32Array, 4);
+        return;
+
+      case 108
+      /* "l" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint32Array, 4);
+        return;
+
+      case 70
+      /* "F" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Float32Array, 4);
+        return;
+
+      case 68
+      /* "D" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Float64Array, 8);
+        return;
+
+      case 78
+      /* "N" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, BigInt64Array, 8);
+        return;
+
+      case 109
+      /* "m" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, BigUint64Array, 8);
+        return;
+
+      case 86
+      /* "V" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, DataView, 1);
+        return;
+    }
+  }
+
+  const stringDecoder = response._stringDecoder;
+  let row = '';
+
+  for (let i = 0; i < buffer.length; i++) {
+    row += readPartialStringChunk(stringDecoder, buffer[i]);
+  }
+
+  row += readFinalStringChunk(stringDecoder, chunk);
+
+  switch (tag) {
+    case 73
+    /* "I" */
+    :
+      {
+        resolveModule(response, id, row);
+        return;
+      }
+
+    case 72
+    /* "H" */
+    :
+      {
+        const code = row[0];
+        resolveHint(response, code, row.slice(1));
+        return;
+      }
+
+    case 69
+    /* "E" */
+    :
+      {
+        const errorInfo = JSON.parse(row);
+
+        {
+          resolveErrorProd(response, id, errorInfo.digest);
+        }
+
+        return;
+      }
+
+    case 84
+    /* "T" */
+    :
+      {
+        resolveText(response, id, row);
+        return;
+      }
+
+    case 80
+    /* "P" */
+    :
+      {
+        {
+          {
+            resolvePostponeProd(response, id);
+          }
+
+          return;
+        }
+      }
+    // Fallthrough
+
+    default:
+      /* """ "{" "[" "t" "f" "n" "0" - "9" */
+      {
+        // We assume anything else is JSON.
+        resolveModel(response, id, row);
+        return;
+      }
+  }
+}
+
+function processBinaryChunk(response, chunk) {
+  let i = 0;
+  let rowState = response._rowState;
+  let rowID = response._rowID;
+  let rowTag = response._rowTag;
+  let rowLength = response._rowLength;
+  const buffer = response._buffer;
+  const chunkLength = chunk.length;
+
+  while (i < chunkLength) {
+    let lastIdx = -1;
+
+    switch (rowState) {
+      case ROW_ID:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 58
+          /* ":" */
+          ) {
+              // Finished the rowID, next we'll parse the tag.
+              rowState = ROW_TAG;
+            } else {
+            rowID = rowID << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_TAG:
+        {
+          const resolvedRowTag = chunk[i];
+
+          if (resolvedRowTag === 84
+          /* "T" */
+          || (resolvedRowTag === 65
+          /* "A" */
+          || resolvedRowTag === 67
+          /* "C" */
+          || resolvedRowTag === 99
+          /* "c" */
+          || resolvedRowTag === 85
+          /* "U" */
+          || resolvedRowTag === 83
+          /* "S" */
+          || resolvedRowTag === 115
+          /* "s" */
+          || resolvedRowTag === 76
+          /* "L" */
+          || resolvedRowTag === 108
+          /* "l" */
+          || resolvedRowTag === 70
+          /* "F" */
+          || resolvedRowTag === 68
+          /* "D" */
+          || resolvedRowTag === 78
+          /* "N" */
+          || resolvedRowTag === 109
+          /* "m" */
+          || resolvedRowTag === 86)
+          /* "V" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_LENGTH;
+              i++;
+            } else if (resolvedRowTag > 64 && resolvedRowTag < 91
+          /* "A"-"Z" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_CHUNK_BY_NEWLINE;
+              i++;
+            } else {
+            rowTag = 0;
+            rowState = ROW_CHUNK_BY_NEWLINE; // This was an unknown tag so it was probably part of the data.
+          }
+
+          continue;
+        }
+
+      case ROW_LENGTH:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 44
+          /* "," */
+          ) {
+              // Finished the rowLength, next we'll buffer up to that length.
+              rowState = ROW_CHUNK_BY_LENGTH;
+            } else {
+            rowLength = rowLength << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_CHUNK_BY_NEWLINE:
+        {
+          // We're looking for a newline
+          lastIdx = chunk.indexOf(10
+          /* "\n" */
+          , i);
+          break;
+        }
+
+      case ROW_CHUNK_BY_LENGTH:
+        {
+          // We're looking for the remaining byte length
+          lastIdx = i + rowLength;
+
+          if (lastIdx > chunk.length) {
+            lastIdx = -1;
+          }
+
+          break;
+        }
+    }
+
+    const offset = chunk.byteOffset + i;
+
+    if (lastIdx > -1) {
+      // We found the last chunk of the row
+      const length = lastIdx - i;
+      const lastChunk = new Uint8Array(chunk.buffer, offset, length);
+      processFullRow(response, rowID, rowTag, buffer, lastChunk); // Reset state machine for a new row
+
+      i = lastIdx;
+
+      if (rowState === ROW_CHUNK_BY_NEWLINE) {
+        // If we're trailing by a newline we need to skip it.
+        i++;
+      }
+
+      rowState = ROW_ID;
+      rowTag = 0;
+      rowID = 0;
+      rowLength = 0;
+      buffer.length = 0;
+    } else {
+      // The rest of this row is in a future chunk. We stash the rest of the
+      // current chunk until we can process the full row.
+      const length = chunk.byteLength - i;
+      const remainingSlice = new Uint8Array(chunk.buffer, offset, length);
+      buffer.push(remainingSlice); // Update how many bytes we're still waiting for. If we're looking for
+      // a newline, this doesn't hurt since we'll just ignore it.
+
+      rowLength -= remainingSlice.byteLength;
+      break;
+    }
+  }
+
+  response._rowState = rowState;
+  response._rowID = rowID;
+  response._rowTag = rowTag;
+  response._rowLength = rowLength;
+}
+
+function parseModel(response, json) {
+  return JSON.parse(json, response._fromJSON);
+}
+
+function createFromJSONCallback(response) {
+  // $FlowFixMe[missing-this-annot]
+  return function (key, value) {
+    if (typeof value === 'string') {
+      // We can't use .bind here because we need the "this" value.
+      return parseModelString(response, this, key, value);
+    }
+
+    if (typeof value === 'object' && value !== null) {
+      return parseModelTuple(response, value);
+    }
+
+    return value;
+  };
+}
+
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function noServerCall() {
+  throw new Error('Server Functions cannot be called during initial render. ' + 'This would create a fetch waterfall. Try to use a Server Component ' + 'to pass data to Client Components instead.');
+}
+
+function createServerReference(id, callServer) {
+  return createServerReference$1(id, noServerCall);
+}
+
+function createResponseFromOptions(options) {
+  return createResponse(options.ssrManifest.moduleMap, options.ssrManifest.moduleLoading, noServerCall, typeof options.nonce === 'string' ? options.nonce : undefined);
+}
+
+function startReadingFromStream(response, stream) {
+  const reader = stream.getReader();
+
+  function progress(_ref) {
+    let done = _ref.done,
+        value = _ref.value;
+
+    if (done) {
+      close(response);
+      return;
+    }
+
+    const buffer = value;
+    processBinaryChunk(response, buffer);
+    return reader.read().then(progress).catch(error);
+  }
+
+  function error(e) {
+    reportGlobalError(response, e);
+  }
+
+  reader.read().then(progress).catch(error);
+}
+
+function createFromReadableStream(stream, options) {
+  const response = createResponseFromOptions(options);
+  startReadingFromStream(response, stream);
+  return getRoot(response);
+}
+
+function createFromFetch(promiseForResponse, options) {
+  const response = createResponseFromOptions(options);
+  promiseForResponse.then(function (r) {
+    startReadingFromStream(response, r.body);
+  }, function (e) {
+    reportGlobalError(response, e);
+  });
+  return getRoot(response);
+}
+
+function encodeReply(value)
+/* We don't use URLSearchParams yet but maybe */
+{
+  return new Promise((resolve, reject) => {
+    processReply(value, '', resolve, reject);
+  });
+}
+
+exports.createFromFetch = createFromFetch;
+exports.createFromReadableStream = createFromReadableStream;
+exports.createServerReference = createServerReference;
+exports.encodeReply = encodeReply;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.edge.production.min.js b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.edge.production.min.js
index a27a9fc10e818..4670620dc2858 100644
--- a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.edge.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.edge.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-turbopack-client.edge.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-turbopack-client.edge.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var p=require("react-dom"),q=require("react"),r={stream:!0};function aa(a,b){if(a){var c=a[b[0]];if(a=c[b[2]])c=a.name;else{a=c["*"];if(!a)throw Error('Could not find the module "'+b[0]+'" in the React SSR Manifest. This is probably a bug in the React Server Components bundler.');c=b[2]}return 4===b.length?[a.id,a.chunks,c,1]:[a.id,a.chunks,c]}return b}var u=new Map;
 function v(a){var b=globalThis.__next_require__(a);if("function"!==typeof b.then||"fulfilled"===b.status)return null;b.then(function(c){b.status="fulfilled";b.value=c},function(c){b.status="rejected";b.reason=c});return b}function ba(){}
 function ca(a){for(var b=a[1],c=[],d=0;d<b.length;d++){var e=b[d],g=u.get(e);if(void 0===g){g=globalThis.__next_chunk_load__(e);c.push(g);var f=u.set.bind(u,e,null);g.then(f,ba);u.set(e,g)}else null!==g&&c.push(g)}return 4===a.length?0===c.length?v(a[0]):Promise.all(c).then(function(){return v(a[0])}):0<c.length?Promise.all(c):null}
@@ -43,3 +43,5 @@ function Y(a){var b=a.ssrManifest.moduleMap,c=a.ssrManifest.moduleLoading;a="str
 function Z(a,b){function c(g){var f=g.value;if(g.done)R(a,Error("Connection closed."));else{var l=0,h=a._rowState;g=a._rowID;for(var k=a._rowTag,n=a._rowLength,w=a._buffer,F=f.length;l<F;){var m=-1;switch(h){case 0:m=f[l++];58===m?h=1:g=g<<4|(96<m?m-87:m-48);continue;case 1:h=f[l];84===h||65===h||67===h||99===h||85===h||83===h||115===h||76===h||108===h||70===h||68===h||78===h||109===h||86===h?(k=h,h=2,l++):64<h&&91>h?(k=h,h=3,l++):(k=0,h=3);continue;case 2:m=f[l++];44===m?h=4:n=n<<4|(96<m?m-87:m-
 48);continue;case 3:m=f.indexOf(10,l);break;case 4:m=l+n,m>f.length&&(m=-1)}var t=f.byteOffset+l;if(-1<m)n=new Uint8Array(f.buffer,t,m-l),Ba(a,g,k,w,n),l=m,3===h&&l++,n=g=k=h=0,w.length=0;else{f=new Uint8Array(f.buffer,t,f.byteLength-l);w.push(f);n-=f.byteLength;break}}a._rowState=h;a._rowID=g;a._rowTag=k;a._rowLength=n;return e.read().then(c).catch(d)}}function d(g){R(a,g)}var e=b.getReader();e.read().then(c).catch(d)}
 exports.createFromFetch=function(a,b){var c=Y(b);a.then(function(d){Z(c,d.body)},function(d){R(c,d)});return S(c,0)};exports.createFromReadableStream=function(a,b){b=Y(b);Z(b,a);return S(b,0)};exports.createServerReference=function(a){return ta(a,X)};exports.encodeReply=function(a){return new Promise(function(b,c){D(a,"",b,c)})};
+
+//# sourceMappingURL=react-server-dom-turbopack-client.edge.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.node.production.js b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.node.production.js
new file mode 100644
index 0000000000000..3923aedb3b23c
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.node.production.js
@@ -0,0 +1,1983 @@
+/**
+ * @license React
+ * react-server-dom-turbopack-client.node.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var util = require('util');
+var ReactDOM = require('react-dom');
+var React = require('react');
+
+function createStringDecoder() {
+  return new util.TextDecoder();
+}
+const decoderOptions = {
+  stream: true
+};
+function readPartialStringChunk(decoder, buffer) {
+  return decoder.decode(buffer, decoderOptions);
+}
+function readFinalStringChunk(decoder, buffer) {
+  return decoder.decode(buffer);
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+// The reason this function needs to defined here in this file instead of just
+// being exported directly from the TurbopackDestination... file is because the
+// ClientReferenceMetadata is opaque and we can't unwrap it there.
+// This should get inlined and we could also just implement an unwrapping function
+// though that risks it getting used in places it shouldn't be. This is unfortunate
+// but currently it seems to be the best option we have.
+
+function prepareDestinationForModule(moduleLoading, nonce, metadata) {
+  prepareDestinationWithChunks(moduleLoading, metadata[CHUNKS], nonce);
+}
+function resolveClientReference(bundlerConfig, metadata) {
+  if (bundlerConfig) {
+    const moduleExports = bundlerConfig[metadata[ID]];
+    let resolvedModuleData = moduleExports[metadata[NAME]];
+    let name;
+
+    if (resolvedModuleData) {
+      // The potentially aliased name.
+      name = resolvedModuleData.name;
+    } else {
+      // If we don't have this specific name, we might have the full module.
+      resolvedModuleData = moduleExports['*'];
+
+      if (!resolvedModuleData) {
+        throw new Error('Could not find the module "' + metadata[ID] + '" in the React SSR Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+      }
+
+      name = metadata[NAME];
+    }
+
+    if (isAsyncImport(metadata)) {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1
+      /* async */
+      ];
+    } else {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+    }
+  }
+
+  return metadata;
+}
+// If they're still pending they're a thenable. This map also exists
+// in Turbopack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = globalThis.__next_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+
+  for (let i = 0; i < chunks.length; i++) {
+    const chunkFilename = chunks[i];
+    const entry = chunkCache.get(chunkFilename);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkFilename);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkFilename, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkFilename, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = globalThis.__next_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+function loadChunk(filename) {
+  return globalThis.__next_chunk_load__(filename);
+}
+
+function prepareDestinationWithChunks(moduleLoading, // Chunks are single-indexed filenames
+chunks, nonce) {
+  if (moduleLoading !== null) {
+    for (let i = 0; i < chunks.length; i++) {
+      preinitScriptForSSR(moduleLoading.prefix + chunks[i], nonce, moduleLoading.crossOrigin);
+    }
+  }
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// This client file is in the shared folder because it applies to both SSR and browser contexts.
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function dispatchHint(code, model) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    switch (code) {
+      case 'D':
+        {
+          const refined = refineModel(code, model);
+          const href = refined;
+          dispatcher.prefetchDNS(href);
+          return;
+        }
+
+      case 'C':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preconnect(href);
+          } else {
+            const href = refined[0];
+            const crossOrigin = refined[1];
+            dispatcher.preconnect(href, crossOrigin);
+          }
+
+          return;
+        }
+
+      case 'L':
+        {
+          const refined = refineModel(code, model);
+          const href = refined[0];
+          const as = refined[1];
+
+          if (refined.length === 3) {
+            const options = refined[2];
+            dispatcher.preload(href, as, options);
+          } else {
+            dispatcher.preload(href, as);
+          }
+
+          return;
+        }
+
+      case 'm':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preloadModule(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preloadModule(href, options);
+          }
+
+          return;
+        }
+
+      case 'S':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitStyle(href);
+          } else {
+            const href = refined[0];
+            const precedence = refined[1] === 0 ? undefined : refined[1];
+            const options = refined.length === 3 ? refined[2] : undefined;
+            dispatcher.preinitStyle(href, precedence, options);
+          }
+
+          return;
+        }
+
+      case 'X':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitScript(href, options);
+          }
+
+          return;
+        }
+
+      case 'M':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitModuleScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitModuleScript(href, options);
+          }
+
+          return;
+        }
+    }
+  }
+} // Flow is having troulbe refining the HintModels so we help it a bit.
+// This should be compiled out in the production build.
+
+function refineModel(code, model) {
+  return model;
+}
+function preinitScriptForSSR(href, nonce, crossOrigin) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    dispatcher.preinitScript(href, {
+      crossOrigin: getCrossOriginString(crossOrigin),
+      nonce
+    });
+  }
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+const ObjectPrototype = Object.prototype;
+const knownServerReferences = new WeakMap(); // Serializable values
+// Thenable<ReactServerValue>
+// function serializeByValueID(id: number): string {
+//   return '$' + id.toString(16);
+// }
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeFormDataReference(id) {
+  // Why K? F is "Function". D is "Date". What else?
+  return '$K' + id.toString(16);
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeMapID(id) {
+  return '$Q' + id.toString(16);
+}
+
+function serializeSetID(id) {
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+
+function processReply(root, formFieldPrefix, resolve, reject) {
+  let nextPartId = 1;
+  let pendingParts = 0;
+  let formData = null;
+
+  function resolveToJSON(key, value) {
+    const parent = this; // Make sure that `parent[key]` wasn't JSONified before `value` was passed to us
+
+    if (value === null) {
+      return null;
+    }
+
+    if (typeof value === 'object') {
+      // $FlowFixMe[method-unbinding]
+      if (typeof value.then === 'function') {
+        // We assume that any object with a .then property is a "Thenable" type,
+        // or a Promise type. Either of which can be represented by a Promise.
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        }
+
+        pendingParts++;
+        const promiseId = nextPartId++;
+        const thenable = value;
+        thenable.then(partValue => {
+          const partJSON = JSON.stringify(partValue, resolveToJSON); // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
+
+          const data = formData; // eslint-disable-next-line react-internal/safe-string-coercion
+
+          data.append(formFieldPrefix + promiseId, partJSON);
+          pendingParts--;
+
+          if (pendingParts === 0) {
+            resolve(data);
+          }
+        }, reason => {
+          // In the future we could consider serializing this as an error
+          // that throws on the server instead.
+          reject(reason);
+        });
+        return serializePromiseID(promiseId);
+      }
+
+      if (isArray(value)) {
+        // $FlowFixMe[incompatible-return]
+        return value;
+      } // TODO: Should we the Object.prototype.toString.call() to test for cross-realm objects?
+
+
+      if (value instanceof FormData) {
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to use rich objects as its values.
+          formData = new FormData();
+        }
+
+        const data = formData;
+        const refId = nextPartId++; // Copy all the form fields with a prefix for this reference.
+        // These must come first in the form order because we assume that all the
+        // fields are available before this is referenced.
+
+        const prefix = formFieldPrefix + refId + '_'; // $FlowFixMe[prop-missing]: FormData has forEach.
+
+        value.forEach((originalValue, originalKey) => {
+          data.append(prefix + originalKey, originalValue);
+        });
+        return serializeFormDataReference(refId);
+      }
+
+      if (value instanceof Map) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const mapId = nextPartId++;
+        formData.append(formFieldPrefix + mapId, partJSON);
+        return serializeMapID(mapId);
+      }
+
+      if (value instanceof Set) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const setId = nextPartId++;
+        formData.append(formFieldPrefix + setId, partJSON);
+        return serializeSetID(setId);
+      }
+
+      const iteratorFn = getIteratorFn(value);
+
+      if (iteratorFn) {
+        return Array.from(value);
+      } // Verify that this is a simple plain object.
+
+
+      const proto = getPrototypeOf(value);
+
+      if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+        throw new Error('Only plain objects, and a few built-ins, can be passed to Server Actions. ' + 'Classes or null prototypes are not supported.');
+      }
+
+
+      return value;
+    }
+
+    if (typeof value === 'string') {
+      // TODO: Maybe too clever. If we support URL there's no similar trick.
+      if (value[value.length - 1] === 'Z') {
+        // Possibly a Date, whose toJSON automatically calls toISOString
+        // $FlowFixMe[incompatible-use]
+        const originalValue = parent[key];
+
+        if (originalValue instanceof Date) {
+          return serializeDateFromDateJSON(value);
+        }
+      }
+
+      return escapeStringValue(value);
+    }
+
+    if (typeof value === 'boolean') {
+      return value;
+    }
+
+    if (typeof value === 'number') {
+      return serializeNumber(value);
+    }
+
+    if (typeof value === 'undefined') {
+      return serializeUndefined();
+    }
+
+    if (typeof value === 'function') {
+      const metaData = knownServerReferences.get(value);
+
+      if (metaData !== undefined) {
+        const metaDataJSON = JSON.stringify(metaData, resolveToJSON);
+
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        } // The reference to this function came from the same client so we can pass it back.
+
+
+        const refId = nextPartId++; // eslint-disable-next-line react-internal/safe-string-coercion
+
+        formData.set(formFieldPrefix + refId, metaDataJSON);
+        return serializeServerReferenceID(refId);
+      }
+
+      throw new Error('Client Functions cannot be passed directly to Server Functions. ' + 'Only Functions passed from the Server can be passed back again.');
+    }
+
+    if (typeof value === 'symbol') {
+      // $FlowFixMe[incompatible-type] `description` might be undefined
+      const name = value.description;
+
+      if (Symbol.for(name) !== value) {
+        throw new Error('Only global symbols received from Symbol.for(...) can be passed to Server Functions. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+        value.description + ") cannot be found among global symbols."));
+      }
+
+      return serializeSymbolReference(name);
+    }
+
+    if (typeof value === 'bigint') {
+      return serializeBigInt(value);
+    }
+
+    throw new Error("Type " + typeof value + " is not supported as an argument to a Server Function.");
+  } // $FlowFixMe[incompatible-type] it's not going to be undefined because we'll encode it.
+
+
+  const json = JSON.stringify(root, resolveToJSON);
+
+  if (formData === null) {
+    // If it's a simple data structure, we just use plain JSON.
+    resolve(json);
+  } else {
+    // Otherwise, we use FormData to let us stream in the result.
+    formData.set(formFieldPrefix + '0', json);
+
+    if (pendingParts === 0) {
+      // $FlowFixMe[incompatible-call] this has already been refined.
+      resolve(formData);
+    }
+  }
+}
+const boundCache = new WeakMap();
+
+function encodeFormData(reference) {
+  let resolve, reject; // We need to have a handle on the thenable so that we can synchronously set
+  // its status from processReply, when it can complete synchronously.
+
+  const thenable = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  processReply(reference, '', body => {
+    if (typeof body === 'string') {
+      const data = new FormData();
+      data.append('0', body);
+      body = data;
+    }
+
+    const fulfilled = thenable;
+    fulfilled.status = 'fulfilled';
+    fulfilled.value = body;
+    resolve(body);
+  }, e => {
+    const rejected = thenable;
+    rejected.status = 'rejected';
+    rejected.reason = e;
+    reject(e);
+  });
+  return thenable;
+}
+
+function encodeFormAction(identifierPrefix) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  let data = null;
+  let name;
+  const boundPromise = reference.bound;
+
+  if (boundPromise !== null) {
+    let thenable = boundCache.get(reference);
+
+    if (!thenable) {
+      thenable = encodeFormData(reference);
+      boundCache.set(reference, thenable);
+    }
+
+    if (thenable.status === 'rejected') {
+      throw thenable.reason;
+    } else if (thenable.status !== 'fulfilled') {
+      throw thenable;
+    }
+
+    const encodedFormData = thenable.value; // This is hacky but we need the identifier prefix to be added to
+    // all fields but the suspense cache would break since we might get
+    // a new identifier each time. So we just append it at the end instead.
+
+    const prefixedData = new FormData(); // $FlowFixMe[prop-missing]
+
+    encodedFormData.forEach((value, key) => {
+      prefixedData.append('$ACTION_' + identifierPrefix + ':' + key, value);
+    });
+    data = prefixedData; // We encode the name of the prefix containing the data.
+
+    name = '$ACTION_REF_' + identifierPrefix;
+  } else {
+    // This is the simple case so we can just encode the ID.
+    name = '$ACTION_ID_' + reference.id;
+  }
+
+  return {
+    name: name,
+    method: 'POST',
+    encType: 'multipart/form-data',
+    data: data
+  };
+}
+
+function isSignatureEqual(referenceId, numberOfBoundArgs) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  if (reference.id !== referenceId) {
+    // These are different functions.
+    return false;
+  } // Now check if the number of bound arguments is the same.
+
+
+  const boundPromise = reference.bound;
+
+  if (boundPromise === null) {
+    // No bound arguments.
+    return numberOfBoundArgs === 0;
+  } // Unwrap the bound arguments array by suspending, if necessary. As with
+  // encodeFormData, this means isSignatureEqual can only be called while React
+  // is rendering.
+
+
+  switch (boundPromise.status) {
+    case 'fulfilled':
+      {
+        const boundArgs = boundPromise.value;
+        return boundArgs.length === numberOfBoundArgs;
+      }
+
+    case 'pending':
+      {
+        throw boundPromise;
+      }
+
+    case 'rejected':
+      {
+        throw boundPromise.reason;
+      }
+
+    default:
+      {
+        if (typeof boundPromise.status === 'string') ; else {
+          const pendingThenable = boundPromise;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(boundArgs => {
+            const fulfilledThenable = boundPromise;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = boundArgs;
+          }, error => {
+            const rejectedThenable = boundPromise;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          });
+        }
+
+        throw boundPromise;
+      }
+  }
+}
+
+function registerServerReference(proxy, reference) {
+  // Expose encoder for use by SSR, as well as a special bind that can be used to
+  // keep server capabilities.
+  {
+    // Only expose this in builds that would actually use it. Not needed on the client.
+    Object.defineProperties(proxy, {
+      $$FORM_ACTION: {
+        value: encodeFormAction
+      },
+      $$IS_SIGNATURE_EQUAL: {
+        value: isSignatureEqual
+      },
+      bind: {
+        value: bind
+      }
+    });
+  }
+
+  knownServerReferences.set(proxy, reference);
+} // $FlowFixMe[method-unbinding]
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+  const reference = knownServerReferences.get(this);
+
+  if (reference) {
+    const args = ArraySlice.call(arguments, 1);
+    let boundPromise = null;
+
+    if (reference.bound !== null) {
+      boundPromise = Promise.resolve(reference.bound).then(boundArgs => boundArgs.concat(args));
+    } else {
+      boundPromise = Promise.resolve(args);
+    }
+
+    registerServerReference(newFn, {
+      id: reference.id,
+      bound: boundPromise
+    });
+  }
+
+  return newFn;
+}
+
+function createServerReference$1(id, callServer) {
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    return callServer(id, args);
+  };
+
+  registerServerReference(proxy, {
+    id,
+    bound: null
+  });
+  return proxy;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ROW_ID = 0;
+const ROW_TAG = 1;
+const ROW_LENGTH = 2;
+const ROW_CHUNK_BY_NEWLINE = 3;
+const ROW_CHUNK_BY_LENGTH = 4;
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const CYCLIC = 'cyclic';
+const RESOLVED_MODEL = 'resolved_model';
+const RESOLVED_MODULE = 'resolved_module';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function readChunk(chunk) {
+  // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      return chunk.value;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      // eslint-disable-next-line no-throw-literal
+      throw chunk;
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function createBlockedChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(BLOCKED, null, null, response);
+}
+
+function createErrorChunk(response, error) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(ERRORED, null, error, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function createResolvedModuleChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODULE, value, null, response);
+}
+
+function createInitializedTextChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function createInitializedBufferChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function resolveModuleChunk(chunk, value) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODULE;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    initializeModuleChunk(resolvedChunk);
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+  const resolvedModel = chunk.value; // We go to the CYCLIC state until we've fully resolved this.
+  // We do this before parsing in case we try to initialize the same chunk
+  // while parsing the model. Such as in a cyclic reference.
+
+  const cyclicChunk = chunk;
+  cyclicChunk.status = CYCLIC;
+  cyclicChunk.value = null;
+  cyclicChunk.reason = null;
+
+  try {
+    const value = parseModel(chunk._response, resolvedModel);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const resolveListeners = cyclicChunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, value);
+      }
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+}
+
+function initializeModuleChunk(chunk) {
+  try {
+    const value = requireModule(chunk.value);
+    const initializedChunk = chunk;
+    initializedChunk.status = INITIALIZED;
+    initializedChunk.value = value;
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function createElement(type, key, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: null,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: null
+  };
+
+  return element;
+}
+
+function createLazyChunkWrapper(chunk) {
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: chunk,
+    _init: readChunk
+  };
+  return lazyType;
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunk = createPendingChunk(response);
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key, cyclic) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+
+    if (!cyclic) {
+      blocked.deps++;
+    }
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: cyclic ? 0 : 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function createServerReferenceProxy(response, metaData) {
+  const callServer = response._callServer;
+
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    const p = metaData.bound;
+
+    if (!p) {
+      return callServer(metaData.id, args);
+    }
+
+    if (p.status === INITIALIZED) {
+      const bound = p.value;
+      return callServer(metaData.id, bound.concat(args));
+    } // Since this is a fake Promise whose .then doesn't chain, we have to wrap it.
+    // TODO: Remove the wrapper once that's fixed.
+
+
+    return Promise.resolve(p).then(function (bound) {
+      return callServer(metaData.id, bound.concat(args));
+    });
+  };
+
+  registerServerReference(proxy, metaData);
+  return proxy;
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      {
+        return chunk.value;
+      }
+    // We always encode it first in the stream so it won't be pending.
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    if (value === '$') {
+      // A very common symbol.
+      return REACT_ELEMENT_TYPE;
+    }
+
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case 'L':
+        {
+          // Lazy node
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id); // We create a React.lazy wrapper around any lazy values.
+          // When passed into React, we'll know how to suspend on this.
+
+          return createLazyChunkWrapper(chunk);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'P':
+        {
+          // Server Context Provider
+          return getOrCreateServerContext(value.slice(2)).Provider;
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16);
+          const metadata = getOutlinedModel(response, id);
+          return createServerReferenceProxy(response, metadata);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+
+            case RESOLVED_MODULE:
+              initializeModuleChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+            case CYCLIC:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key, chunk.status === CYCLIC), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function parseModelTuple(response, value) {
+  const tuple = value;
+
+  if (tuple[0] === REACT_ELEMENT_TYPE) {
+    // TODO: Consider having React just directly accept these arrays as elements.
+    // Or even change the ReactElement type to be an array.
+    return createElement(tuple[1], tuple[2], tuple[3]);
+  }
+
+  return value;
+}
+
+function missingCall() {
+  throw new Error('Trying to call a function from "use server" but the callServer option ' + 'was not implemented in your router runtime.');
+}
+
+function createResponse(bundlerConfig, moduleLoading, callServer, nonce) {
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _moduleLoading: moduleLoading,
+    _callServer: callServer !== undefined ? callServer : missingCall,
+    _nonce: nonce,
+    _chunks: chunks,
+    _stringDecoder: createStringDecoder(),
+    _fromJSON: null,
+    _rowState: 0,
+    _rowID: 0,
+    _rowTag: 0,
+    _rowLength: 0,
+    _buffer: []
+  }; // Don't inline this call because it causes closure to outline the call above.
+
+  response._fromJSON = createFromJSONCallback(response);
+  return response;
+}
+
+function resolveModel(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createResolvedModelChunk(response, model));
+  } else {
+    resolveModelChunk(chunk, model);
+  }
+}
+
+function resolveText(response, id, text) {
+  const chunks = response._chunks; // We assume that we always reference large strings after they've been
+  // emitted.
+
+  chunks.set(id, createInitializedTextChunk(response, text));
+}
+
+function resolveBuffer(response, id, buffer) {
+  const chunks = response._chunks; // We assume that we always reference buffers after they've been emitted.
+
+  chunks.set(id, createInitializedBufferChunk(response, buffer));
+}
+
+function resolveModule(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+  const clientReferenceMetadata = parseModel(response, model);
+  const clientReference = resolveClientReference(response._bundlerConfig, clientReferenceMetadata);
+  prepareDestinationForModule(response._moduleLoading, response._nonce, clientReferenceMetadata); // TODO: Add an option to encode modules that are lazy loaded.
+  // For now we preload all modules as early as possible since it's likely
+  // that we'll need them.
+
+  const promise = preloadModule(clientReference);
+
+  if (promise) {
+    let blockedChunk;
+
+    if (!chunk) {
+      // Technically, we should just treat promise as the chunk in this
+      // case. Because it'll just behave as any other promise.
+      blockedChunk = createBlockedChunk(response);
+      chunks.set(id, blockedChunk);
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+    }
+
+    promise.then(() => resolveModuleChunk(blockedChunk, clientReference), error => triggerErrorOnChunk(blockedChunk, error));
+  } else {
+    if (!chunk) {
+      chunks.set(id, createResolvedModuleChunk(response, clientReference));
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      resolveModuleChunk(chunk, clientReference);
+    }
+  }
+}
+
+function resolveErrorProd(response, id, digest) {
+
+  const error = new Error('An error occurred in the Server Components render. The specific message is omitted in production' + ' builds to avoid leaking sensitive details. A digest property is included on this error instance which' + ' may provide additional details about the nature of the error.');
+  error.stack = 'Error: ' + error.message;
+  error.digest = digest;
+  const errorWithDigest = error;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, errorWithDigest));
+  } else {
+    triggerErrorOnChunk(chunk, errorWithDigest);
+  }
+}
+
+function resolvePostponeProd(response, id) {
+
+  const error = new Error('A Server Component was postponed. The reason is omitted in production' + ' builds to avoid leaking sensitive details.');
+  const postponeInstance = error;
+  postponeInstance.$$typeof = REACT_POSTPONE_TYPE;
+  postponeInstance.stack = 'Error: ' + error.message;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, postponeInstance));
+  } else {
+    triggerErrorOnChunk(chunk, postponeInstance);
+  }
+}
+
+function resolveHint(response, code, model) {
+  const hintModel = parseModel(response, model);
+  dispatchHint(code, hintModel);
+}
+
+function mergeBuffer(buffer, lastChunk) {
+  const l = buffer.length; // Count the bytes we'll need
+
+  let byteLength = lastChunk.length;
+
+  for (let i = 0; i < l; i++) {
+    byteLength += buffer[i].byteLength;
+  } // Allocate enough contiguous space
+
+
+  const result = new Uint8Array(byteLength);
+  let offset = 0; // Copy all the buffers into it.
+
+  for (let i = 0; i < l; i++) {
+    const chunk = buffer[i];
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+
+  result.set(lastChunk, offset);
+  return result;
+}
+
+function resolveTypedArray(response, id, buffer, lastChunk, constructor, bytesPerElement) {
+  // If the view fits into one original buffer, we just reuse that buffer instead of
+  // copying it out to a separate copy. This means that it's not always possible to
+  // transfer these values to other threads without copying first since they may
+  // share array buffer. For this to work, it must also have bytes aligned to a
+  // multiple of a size of the type.
+  const chunk = buffer.length === 0 && lastChunk.byteOffset % bytesPerElement === 0 ? lastChunk : mergeBuffer(buffer, lastChunk); // TODO: The transfer protocol of RSC is little-endian. If the client isn't little-endian
+  // we should convert it instead. In practice big endian isn't really Web compatible so it's
+  // somewhat safe to assume that browsers aren't going to run it, but maybe there's some SSR
+  // server that's affected.
+
+  const view = new constructor(chunk.buffer, chunk.byteOffset, chunk.byteLength / bytesPerElement);
+  resolveBuffer(response, id, view);
+}
+
+function processFullRow(response, id, tag, buffer, chunk) {
+  {
+    switch (tag) {
+      case 65
+      /* "A" */
+      :
+        // We must always clone to extract it into a separate buffer instead of just a view.
+        resolveBuffer(response, id, mergeBuffer(buffer, chunk).buffer);
+        return;
+
+      case 67
+      /* "C" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int8Array, 1);
+        return;
+
+      case 99
+      /* "c" */
+      :
+        resolveBuffer(response, id, buffer.length === 0 ? chunk : mergeBuffer(buffer, chunk));
+        return;
+
+      case 85
+      /* "U" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint8ClampedArray, 1);
+        return;
+
+      case 83
+      /* "S" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int16Array, 2);
+        return;
+
+      case 115
+      /* "s" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint16Array, 2);
+        return;
+
+      case 76
+      /* "L" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int32Array, 4);
+        return;
+
+      case 108
+      /* "l" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint32Array, 4);
+        return;
+
+      case 70
+      /* "F" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Float32Array, 4);
+        return;
+
+      case 68
+      /* "D" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Float64Array, 8);
+        return;
+
+      case 78
+      /* "N" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, BigInt64Array, 8);
+        return;
+
+      case 109
+      /* "m" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, BigUint64Array, 8);
+        return;
+
+      case 86
+      /* "V" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, DataView, 1);
+        return;
+    }
+  }
+
+  const stringDecoder = response._stringDecoder;
+  let row = '';
+
+  for (let i = 0; i < buffer.length; i++) {
+    row += readPartialStringChunk(stringDecoder, buffer[i]);
+  }
+
+  row += readFinalStringChunk(stringDecoder, chunk);
+
+  switch (tag) {
+    case 73
+    /* "I" */
+    :
+      {
+        resolveModule(response, id, row);
+        return;
+      }
+
+    case 72
+    /* "H" */
+    :
+      {
+        const code = row[0];
+        resolveHint(response, code, row.slice(1));
+        return;
+      }
+
+    case 69
+    /* "E" */
+    :
+      {
+        const errorInfo = JSON.parse(row);
+
+        {
+          resolveErrorProd(response, id, errorInfo.digest);
+        }
+
+        return;
+      }
+
+    case 84
+    /* "T" */
+    :
+      {
+        resolveText(response, id, row);
+        return;
+      }
+
+    case 80
+    /* "P" */
+    :
+      {
+        {
+          {
+            resolvePostponeProd(response, id);
+          }
+
+          return;
+        }
+      }
+    // Fallthrough
+
+    default:
+      /* """ "{" "[" "t" "f" "n" "0" - "9" */
+      {
+        // We assume anything else is JSON.
+        resolveModel(response, id, row);
+        return;
+      }
+  }
+}
+
+function processBinaryChunk(response, chunk) {
+  let i = 0;
+  let rowState = response._rowState;
+  let rowID = response._rowID;
+  let rowTag = response._rowTag;
+  let rowLength = response._rowLength;
+  const buffer = response._buffer;
+  const chunkLength = chunk.length;
+
+  while (i < chunkLength) {
+    let lastIdx = -1;
+
+    switch (rowState) {
+      case ROW_ID:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 58
+          /* ":" */
+          ) {
+              // Finished the rowID, next we'll parse the tag.
+              rowState = ROW_TAG;
+            } else {
+            rowID = rowID << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_TAG:
+        {
+          const resolvedRowTag = chunk[i];
+
+          if (resolvedRowTag === 84
+          /* "T" */
+          || (resolvedRowTag === 65
+          /* "A" */
+          || resolvedRowTag === 67
+          /* "C" */
+          || resolvedRowTag === 99
+          /* "c" */
+          || resolvedRowTag === 85
+          /* "U" */
+          || resolvedRowTag === 83
+          /* "S" */
+          || resolvedRowTag === 115
+          /* "s" */
+          || resolvedRowTag === 76
+          /* "L" */
+          || resolvedRowTag === 108
+          /* "l" */
+          || resolvedRowTag === 70
+          /* "F" */
+          || resolvedRowTag === 68
+          /* "D" */
+          || resolvedRowTag === 78
+          /* "N" */
+          || resolvedRowTag === 109
+          /* "m" */
+          || resolvedRowTag === 86)
+          /* "V" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_LENGTH;
+              i++;
+            } else if (resolvedRowTag > 64 && resolvedRowTag < 91
+          /* "A"-"Z" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_CHUNK_BY_NEWLINE;
+              i++;
+            } else {
+            rowTag = 0;
+            rowState = ROW_CHUNK_BY_NEWLINE; // This was an unknown tag so it was probably part of the data.
+          }
+
+          continue;
+        }
+
+      case ROW_LENGTH:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 44
+          /* "," */
+          ) {
+              // Finished the rowLength, next we'll buffer up to that length.
+              rowState = ROW_CHUNK_BY_LENGTH;
+            } else {
+            rowLength = rowLength << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_CHUNK_BY_NEWLINE:
+        {
+          // We're looking for a newline
+          lastIdx = chunk.indexOf(10
+          /* "\n" */
+          , i);
+          break;
+        }
+
+      case ROW_CHUNK_BY_LENGTH:
+        {
+          // We're looking for the remaining byte length
+          lastIdx = i + rowLength;
+
+          if (lastIdx > chunk.length) {
+            lastIdx = -1;
+          }
+
+          break;
+        }
+    }
+
+    const offset = chunk.byteOffset + i;
+
+    if (lastIdx > -1) {
+      // We found the last chunk of the row
+      const length = lastIdx - i;
+      const lastChunk = new Uint8Array(chunk.buffer, offset, length);
+      processFullRow(response, rowID, rowTag, buffer, lastChunk); // Reset state machine for a new row
+
+      i = lastIdx;
+
+      if (rowState === ROW_CHUNK_BY_NEWLINE) {
+        // If we're trailing by a newline we need to skip it.
+        i++;
+      }
+
+      rowState = ROW_ID;
+      rowTag = 0;
+      rowID = 0;
+      rowLength = 0;
+      buffer.length = 0;
+    } else {
+      // The rest of this row is in a future chunk. We stash the rest of the
+      // current chunk until we can process the full row.
+      const length = chunk.byteLength - i;
+      const remainingSlice = new Uint8Array(chunk.buffer, offset, length);
+      buffer.push(remainingSlice); // Update how many bytes we're still waiting for. If we're looking for
+      // a newline, this doesn't hurt since we'll just ignore it.
+
+      rowLength -= remainingSlice.byteLength;
+      break;
+    }
+  }
+
+  response._rowState = rowState;
+  response._rowID = rowID;
+  response._rowTag = rowTag;
+  response._rowLength = rowLength;
+}
+
+function parseModel(response, json) {
+  return JSON.parse(json, response._fromJSON);
+}
+
+function createFromJSONCallback(response) {
+  // $FlowFixMe[missing-this-annot]
+  return function (key, value) {
+    if (typeof value === 'string') {
+      // We can't use .bind here because we need the "this" value.
+      return parseModelString(response, this, key, value);
+    }
+
+    if (typeof value === 'object' && value !== null) {
+      return parseModelTuple(response, value);
+    }
+
+    return value;
+  };
+}
+
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function noServerCall() {
+  throw new Error('Server Functions cannot be called during initial render. ' + 'This would create a fetch waterfall. Try to use a Server Component ' + 'to pass data to Client Components instead.');
+}
+
+function createServerReference(id, callServer) {
+  return createServerReference$1(id, noServerCall);
+}
+
+function createFromNodeStream(stream, ssrManifest, options) {
+  const response = createResponse(ssrManifest.moduleMap, ssrManifest.moduleLoading, noServerCall, options && typeof options.nonce === 'string' ? options.nonce : undefined);
+  stream.on('data', chunk => {
+    processBinaryChunk(response, chunk);
+  });
+  stream.on('error', error => {
+    reportGlobalError(response, error);
+  });
+  stream.on('end', () => close(response));
+  return getRoot(response);
+}
+
+exports.createFromNodeStream = createFromNodeStream;
+exports.createServerReference = createServerReference;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.node.production.min.js b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.node.production.min.js
index 67ab0ad0631bc..e19fc3b8cb968 100644
--- a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.node.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.node.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-turbopack-client.node.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-turbopack-client.node.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var n=require("util"),q=require("react-dom"),r=require("react"),u={stream:!0};function v(a,b){if(a){var c=a[b[0]];if(a=c[b[2]])c=a.name;else{a=c["*"];if(!a)throw Error('Could not find the module "'+b[0]+'" in the React SSR Manifest. This is probably a bug in the React Server Components bundler.');c=b[2]}return 4===b.length?[a.id,a.chunks,c,1]:[a.id,a.chunks,c]}return b}var w=new Map;
 function x(a){var b=globalThis.__next_require__(a);if("function"!==typeof b.then||"fulfilled"===b.status)return null;b.then(function(c){b.status="fulfilled";b.value=c},function(c){b.status="rejected";b.reason=c});return b}function y(){}
 function aa(a){for(var b=a[1],c=[],d=0;d<b.length;d++){var e=b[d],g=w.get(e);if(void 0===g){g=globalThis.__next_chunk_load__(e);c.push(g);var f=w.set.bind(w,e,null);g.then(f,y);w.set(e,g)}else null!==g&&c.push(g)}return 4===a.length?0===c.length?x(a[0]):Promise.all(c).then(function(){return x(a[0])}):0<c.length?Promise.all(c):null}
@@ -43,3 +43,5 @@ f.stack="Error: "+f.message;f.digest=c;c=a._chunks;(d=c.get(b))?P(d,f):c.set(b,n
 exports.createFromNodeStream=function(a,b,c){var d=za(b.moduleMap,b.moduleLoading,Z,c&&"string"===typeof c.nonce?c.nonce:void 0);a.on("data",function(e){for(var g=0,f=d._rowState,l=d._rowID,k=d._rowTag,h=d._rowLength,t=d._buffer,F=e.length;g<F;){var m=-1;switch(f){case 0:m=e[g++];58===m?f=1:l=l<<4|(96<m?m-87:m-48);continue;case 1:f=e[g];84===f||65===f||67===f||99===f||85===f||83===f||115===f||76===f||108===f||70===f||68===f||78===f||109===f||86===f?(k=f,f=2,g++):64<f&&91>f?(k=f,f=3,g++):(k=0,f=3);
 continue;case 2:m=e[g++];44===m?f=4:h=h<<4|(96<m?m-87:m-48);continue;case 3:m=e.indexOf(10,g);break;case 4:m=g+h,m>e.length&&(m=-1)}var p=e.byteOffset+g;if(-1<m)h=new Uint8Array(e.buffer,p,m-g),Ca(d,l,k,t,h),g=m,3===f&&g++,h=l=k=f=0,t.length=0;else{e=new Uint8Array(e.buffer,p,e.byteLength-g);t.push(e);h-=e.byteLength;break}}d._rowState=f;d._rowID=l;d._rowTag=k;d._rowLength=h});a.on("error",function(e){T(d,e)});a.on("end",function(){T(d,Error("Connection closed."))});return U(d,0)};
 exports.createServerReference=function(a){return sa(a,Z)};
+
+//# sourceMappingURL=react-server-dom-turbopack-client.node.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.node.unbundled.production.js b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.node.unbundled.production.js
new file mode 100644
index 0000000000000..61c6de112470b
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.node.unbundled.production.js
@@ -0,0 +1,1938 @@
+/**
+ * @license React
+ * react-server-dom-turbopack-client.node.unbundled.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var util = require('util');
+var ReactDOM = require('react-dom');
+var React = require('react');
+
+function createStringDecoder() {
+  return new util.TextDecoder();
+}
+const decoderOptions = {
+  stream: true
+};
+function readPartialStringChunk(decoder, buffer) {
+  return decoder.decode(buffer, decoderOptions);
+}
+function readFinalStringChunk(decoder, buffer) {
+  return decoder.decode(buffer);
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+// The reason this function needs to defined here in this file instead of just
+// being exported directly from the WebpackDestination... file is because the
+// ClientReferenceMetadata is opaque and we can't unwrap it there.
+// This should get inlined and we could also just implement an unwrapping function
+// though that risks it getting used in places it shouldn't be. This is unfortunate
+// but currently it seems to be the best option we have.
+
+function prepareDestinationForModule(moduleLoading, nonce, metadata) {
+  prepareDestinationWithChunks(moduleLoading, metadata[CHUNKS], nonce);
+}
+function resolveClientReference(bundlerConfig, metadata) {
+  const moduleExports = bundlerConfig[metadata[ID]];
+  let resolvedModuleData = moduleExports[metadata[NAME]];
+  let name;
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // If we don't have this specific name, we might have the full module.
+    resolvedModuleData = moduleExports['*'];
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + metadata[ID] + '" in the React SSR Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+
+    name = metadata[NAME];
+  }
+
+  return {
+    specifier: resolvedModuleData.specifier,
+    name: name,
+    async: isAsyncImport(metadata)
+  };
+}
+const asyncModuleCache = new Map();
+function preloadModule(metadata) {
+  const existingPromise = asyncModuleCache.get(metadata.specifier);
+
+  if (existingPromise) {
+    if (existingPromise.status === 'fulfilled') {
+      return null;
+    }
+
+    return existingPromise;
+  } else {
+    // $FlowFixMe[unsupported-syntax]
+    let modulePromise = import(metadata.specifier);
+
+    if (metadata.async) {
+      // If the module is async, it must have been a CJS module.
+      // CJS modules are accessed through the default export in
+      // Node.js so we have to get the default export to get the
+      // full module exports.
+      modulePromise = modulePromise.then(function (value) {
+        return value.default;
+      });
+    }
+
+    modulePromise.then(value => {
+      const fulfilledThenable = modulePromise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = modulePromise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    asyncModuleCache.set(metadata.specifier, modulePromise);
+    return modulePromise;
+  }
+}
+function requireModule(metadata) {
+  let moduleExports; // We assume that preloadModule has been called before, which
+  // should have added something to the module cache.
+
+  const promise = asyncModuleCache.get(metadata.specifier);
+
+  if (promise.status === 'fulfilled') {
+    moduleExports = promise.value;
+  } else {
+    throw promise.reason;
+  }
+
+  if (metadata.name === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata.name === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.default;
+  }
+
+  return moduleExports[metadata.name];
+}
+
+function prepareDestinationWithChunks(moduleLoading, // Chunks are single-indexed filenames
+chunks, nonce) {
+  if (moduleLoading !== null) {
+    for (let i = 0; i < chunks.length; i++) {
+      preinitScriptForSSR(moduleLoading.prefix + chunks[i], nonce, moduleLoading.crossOrigin);
+    }
+  }
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// This client file is in the shared folder because it applies to both SSR and browser contexts.
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function dispatchHint(code, model) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    switch (code) {
+      case 'D':
+        {
+          const refined = refineModel(code, model);
+          const href = refined;
+          dispatcher.prefetchDNS(href);
+          return;
+        }
+
+      case 'C':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preconnect(href);
+          } else {
+            const href = refined[0];
+            const crossOrigin = refined[1];
+            dispatcher.preconnect(href, crossOrigin);
+          }
+
+          return;
+        }
+
+      case 'L':
+        {
+          const refined = refineModel(code, model);
+          const href = refined[0];
+          const as = refined[1];
+
+          if (refined.length === 3) {
+            const options = refined[2];
+            dispatcher.preload(href, as, options);
+          } else {
+            dispatcher.preload(href, as);
+          }
+
+          return;
+        }
+
+      case 'm':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preloadModule(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preloadModule(href, options);
+          }
+
+          return;
+        }
+
+      case 'S':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitStyle(href);
+          } else {
+            const href = refined[0];
+            const precedence = refined[1] === 0 ? undefined : refined[1];
+            const options = refined.length === 3 ? refined[2] : undefined;
+            dispatcher.preinitStyle(href, precedence, options);
+          }
+
+          return;
+        }
+
+      case 'X':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitScript(href, options);
+          }
+
+          return;
+        }
+
+      case 'M':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitModuleScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitModuleScript(href, options);
+          }
+
+          return;
+        }
+    }
+  }
+} // Flow is having troulbe refining the HintModels so we help it a bit.
+// This should be compiled out in the production build.
+
+function refineModel(code, model) {
+  return model;
+}
+function preinitScriptForSSR(href, nonce, crossOrigin) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    dispatcher.preinitScript(href, {
+      crossOrigin: getCrossOriginString(crossOrigin),
+      nonce
+    });
+  }
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+const ObjectPrototype = Object.prototype;
+const knownServerReferences = new WeakMap(); // Serializable values
+// Thenable<ReactServerValue>
+// function serializeByValueID(id: number): string {
+//   return '$' + id.toString(16);
+// }
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeFormDataReference(id) {
+  // Why K? F is "Function". D is "Date". What else?
+  return '$K' + id.toString(16);
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeMapID(id) {
+  return '$Q' + id.toString(16);
+}
+
+function serializeSetID(id) {
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+
+function processReply(root, formFieldPrefix, resolve, reject) {
+  let nextPartId = 1;
+  let pendingParts = 0;
+  let formData = null;
+
+  function resolveToJSON(key, value) {
+    const parent = this; // Make sure that `parent[key]` wasn't JSONified before `value` was passed to us
+
+    if (value === null) {
+      return null;
+    }
+
+    if (typeof value === 'object') {
+      // $FlowFixMe[method-unbinding]
+      if (typeof value.then === 'function') {
+        // We assume that any object with a .then property is a "Thenable" type,
+        // or a Promise type. Either of which can be represented by a Promise.
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        }
+
+        pendingParts++;
+        const promiseId = nextPartId++;
+        const thenable = value;
+        thenable.then(partValue => {
+          const partJSON = JSON.stringify(partValue, resolveToJSON); // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
+
+          const data = formData; // eslint-disable-next-line react-internal/safe-string-coercion
+
+          data.append(formFieldPrefix + promiseId, partJSON);
+          pendingParts--;
+
+          if (pendingParts === 0) {
+            resolve(data);
+          }
+        }, reason => {
+          // In the future we could consider serializing this as an error
+          // that throws on the server instead.
+          reject(reason);
+        });
+        return serializePromiseID(promiseId);
+      }
+
+      if (isArray(value)) {
+        // $FlowFixMe[incompatible-return]
+        return value;
+      } // TODO: Should we the Object.prototype.toString.call() to test for cross-realm objects?
+
+
+      if (value instanceof FormData) {
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to use rich objects as its values.
+          formData = new FormData();
+        }
+
+        const data = formData;
+        const refId = nextPartId++; // Copy all the form fields with a prefix for this reference.
+        // These must come first in the form order because we assume that all the
+        // fields are available before this is referenced.
+
+        const prefix = formFieldPrefix + refId + '_'; // $FlowFixMe[prop-missing]: FormData has forEach.
+
+        value.forEach((originalValue, originalKey) => {
+          data.append(prefix + originalKey, originalValue);
+        });
+        return serializeFormDataReference(refId);
+      }
+
+      if (value instanceof Map) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const mapId = nextPartId++;
+        formData.append(formFieldPrefix + mapId, partJSON);
+        return serializeMapID(mapId);
+      }
+
+      if (value instanceof Set) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const setId = nextPartId++;
+        formData.append(formFieldPrefix + setId, partJSON);
+        return serializeSetID(setId);
+      }
+
+      const iteratorFn = getIteratorFn(value);
+
+      if (iteratorFn) {
+        return Array.from(value);
+      } // Verify that this is a simple plain object.
+
+
+      const proto = getPrototypeOf(value);
+
+      if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+        throw new Error('Only plain objects, and a few built-ins, can be passed to Server Actions. ' + 'Classes or null prototypes are not supported.');
+      }
+
+
+      return value;
+    }
+
+    if (typeof value === 'string') {
+      // TODO: Maybe too clever. If we support URL there's no similar trick.
+      if (value[value.length - 1] === 'Z') {
+        // Possibly a Date, whose toJSON automatically calls toISOString
+        // $FlowFixMe[incompatible-use]
+        const originalValue = parent[key];
+
+        if (originalValue instanceof Date) {
+          return serializeDateFromDateJSON(value);
+        }
+      }
+
+      return escapeStringValue(value);
+    }
+
+    if (typeof value === 'boolean') {
+      return value;
+    }
+
+    if (typeof value === 'number') {
+      return serializeNumber(value);
+    }
+
+    if (typeof value === 'undefined') {
+      return serializeUndefined();
+    }
+
+    if (typeof value === 'function') {
+      const metaData = knownServerReferences.get(value);
+
+      if (metaData !== undefined) {
+        const metaDataJSON = JSON.stringify(metaData, resolveToJSON);
+
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        } // The reference to this function came from the same client so we can pass it back.
+
+
+        const refId = nextPartId++; // eslint-disable-next-line react-internal/safe-string-coercion
+
+        formData.set(formFieldPrefix + refId, metaDataJSON);
+        return serializeServerReferenceID(refId);
+      }
+
+      throw new Error('Client Functions cannot be passed directly to Server Functions. ' + 'Only Functions passed from the Server can be passed back again.');
+    }
+
+    if (typeof value === 'symbol') {
+      // $FlowFixMe[incompatible-type] `description` might be undefined
+      const name = value.description;
+
+      if (Symbol.for(name) !== value) {
+        throw new Error('Only global symbols received from Symbol.for(...) can be passed to Server Functions. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+        value.description + ") cannot be found among global symbols."));
+      }
+
+      return serializeSymbolReference(name);
+    }
+
+    if (typeof value === 'bigint') {
+      return serializeBigInt(value);
+    }
+
+    throw new Error("Type " + typeof value + " is not supported as an argument to a Server Function.");
+  } // $FlowFixMe[incompatible-type] it's not going to be undefined because we'll encode it.
+
+
+  const json = JSON.stringify(root, resolveToJSON);
+
+  if (formData === null) {
+    // If it's a simple data structure, we just use plain JSON.
+    resolve(json);
+  } else {
+    // Otherwise, we use FormData to let us stream in the result.
+    formData.set(formFieldPrefix + '0', json);
+
+    if (pendingParts === 0) {
+      // $FlowFixMe[incompatible-call] this has already been refined.
+      resolve(formData);
+    }
+  }
+}
+const boundCache = new WeakMap();
+
+function encodeFormData(reference) {
+  let resolve, reject; // We need to have a handle on the thenable so that we can synchronously set
+  // its status from processReply, when it can complete synchronously.
+
+  const thenable = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  processReply(reference, '', body => {
+    if (typeof body === 'string') {
+      const data = new FormData();
+      data.append('0', body);
+      body = data;
+    }
+
+    const fulfilled = thenable;
+    fulfilled.status = 'fulfilled';
+    fulfilled.value = body;
+    resolve(body);
+  }, e => {
+    const rejected = thenable;
+    rejected.status = 'rejected';
+    rejected.reason = e;
+    reject(e);
+  });
+  return thenable;
+}
+
+function encodeFormAction(identifierPrefix) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  let data = null;
+  let name;
+  const boundPromise = reference.bound;
+
+  if (boundPromise !== null) {
+    let thenable = boundCache.get(reference);
+
+    if (!thenable) {
+      thenable = encodeFormData(reference);
+      boundCache.set(reference, thenable);
+    }
+
+    if (thenable.status === 'rejected') {
+      throw thenable.reason;
+    } else if (thenable.status !== 'fulfilled') {
+      throw thenable;
+    }
+
+    const encodedFormData = thenable.value; // This is hacky but we need the identifier prefix to be added to
+    // all fields but the suspense cache would break since we might get
+    // a new identifier each time. So we just append it at the end instead.
+
+    const prefixedData = new FormData(); // $FlowFixMe[prop-missing]
+
+    encodedFormData.forEach((value, key) => {
+      prefixedData.append('$ACTION_' + identifierPrefix + ':' + key, value);
+    });
+    data = prefixedData; // We encode the name of the prefix containing the data.
+
+    name = '$ACTION_REF_' + identifierPrefix;
+  } else {
+    // This is the simple case so we can just encode the ID.
+    name = '$ACTION_ID_' + reference.id;
+  }
+
+  return {
+    name: name,
+    method: 'POST',
+    encType: 'multipart/form-data',
+    data: data
+  };
+}
+
+function isSignatureEqual(referenceId, numberOfBoundArgs) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  if (reference.id !== referenceId) {
+    // These are different functions.
+    return false;
+  } // Now check if the number of bound arguments is the same.
+
+
+  const boundPromise = reference.bound;
+
+  if (boundPromise === null) {
+    // No bound arguments.
+    return numberOfBoundArgs === 0;
+  } // Unwrap the bound arguments array by suspending, if necessary. As with
+  // encodeFormData, this means isSignatureEqual can only be called while React
+  // is rendering.
+
+
+  switch (boundPromise.status) {
+    case 'fulfilled':
+      {
+        const boundArgs = boundPromise.value;
+        return boundArgs.length === numberOfBoundArgs;
+      }
+
+    case 'pending':
+      {
+        throw boundPromise;
+      }
+
+    case 'rejected':
+      {
+        throw boundPromise.reason;
+      }
+
+    default:
+      {
+        if (typeof boundPromise.status === 'string') ; else {
+          const pendingThenable = boundPromise;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(boundArgs => {
+            const fulfilledThenable = boundPromise;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = boundArgs;
+          }, error => {
+            const rejectedThenable = boundPromise;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          });
+        }
+
+        throw boundPromise;
+      }
+  }
+}
+
+function registerServerReference(proxy, reference) {
+  // Expose encoder for use by SSR, as well as a special bind that can be used to
+  // keep server capabilities.
+  {
+    // Only expose this in builds that would actually use it. Not needed on the client.
+    Object.defineProperties(proxy, {
+      $$FORM_ACTION: {
+        value: encodeFormAction
+      },
+      $$IS_SIGNATURE_EQUAL: {
+        value: isSignatureEqual
+      },
+      bind: {
+        value: bind
+      }
+    });
+  }
+
+  knownServerReferences.set(proxy, reference);
+} // $FlowFixMe[method-unbinding]
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+  const reference = knownServerReferences.get(this);
+
+  if (reference) {
+    const args = ArraySlice.call(arguments, 1);
+    let boundPromise = null;
+
+    if (reference.bound !== null) {
+      boundPromise = Promise.resolve(reference.bound).then(boundArgs => boundArgs.concat(args));
+    } else {
+      boundPromise = Promise.resolve(args);
+    }
+
+    registerServerReference(newFn, {
+      id: reference.id,
+      bound: boundPromise
+    });
+  }
+
+  return newFn;
+}
+
+function createServerReference$1(id, callServer) {
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    return callServer(id, args);
+  };
+
+  registerServerReference(proxy, {
+    id,
+    bound: null
+  });
+  return proxy;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ROW_ID = 0;
+const ROW_TAG = 1;
+const ROW_LENGTH = 2;
+const ROW_CHUNK_BY_NEWLINE = 3;
+const ROW_CHUNK_BY_LENGTH = 4;
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const CYCLIC = 'cyclic';
+const RESOLVED_MODEL = 'resolved_model';
+const RESOLVED_MODULE = 'resolved_module';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function readChunk(chunk) {
+  // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      return chunk.value;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      // eslint-disable-next-line no-throw-literal
+      throw chunk;
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function createBlockedChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(BLOCKED, null, null, response);
+}
+
+function createErrorChunk(response, error) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(ERRORED, null, error, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function createResolvedModuleChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODULE, value, null, response);
+}
+
+function createInitializedTextChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function createInitializedBufferChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function resolveModuleChunk(chunk, value) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODULE;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    initializeModuleChunk(resolvedChunk);
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+  const resolvedModel = chunk.value; // We go to the CYCLIC state until we've fully resolved this.
+  // We do this before parsing in case we try to initialize the same chunk
+  // while parsing the model. Such as in a cyclic reference.
+
+  const cyclicChunk = chunk;
+  cyclicChunk.status = CYCLIC;
+  cyclicChunk.value = null;
+  cyclicChunk.reason = null;
+
+  try {
+    const value = parseModel(chunk._response, resolvedModel);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const resolveListeners = cyclicChunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, value);
+      }
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+}
+
+function initializeModuleChunk(chunk) {
+  try {
+    const value = requireModule(chunk.value);
+    const initializedChunk = chunk;
+    initializedChunk.status = INITIALIZED;
+    initializedChunk.value = value;
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function createElement(type, key, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: null,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: null
+  };
+
+  return element;
+}
+
+function createLazyChunkWrapper(chunk) {
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: chunk,
+    _init: readChunk
+  };
+  return lazyType;
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunk = createPendingChunk(response);
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key, cyclic) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+
+    if (!cyclic) {
+      blocked.deps++;
+    }
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: cyclic ? 0 : 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function createServerReferenceProxy(response, metaData) {
+  const callServer = response._callServer;
+
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    const p = metaData.bound;
+
+    if (!p) {
+      return callServer(metaData.id, args);
+    }
+
+    if (p.status === INITIALIZED) {
+      const bound = p.value;
+      return callServer(metaData.id, bound.concat(args));
+    } // Since this is a fake Promise whose .then doesn't chain, we have to wrap it.
+    // TODO: Remove the wrapper once that's fixed.
+
+
+    return Promise.resolve(p).then(function (bound) {
+      return callServer(metaData.id, bound.concat(args));
+    });
+  };
+
+  registerServerReference(proxy, metaData);
+  return proxy;
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      {
+        return chunk.value;
+      }
+    // We always encode it first in the stream so it won't be pending.
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    if (value === '$') {
+      // A very common symbol.
+      return REACT_ELEMENT_TYPE;
+    }
+
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case 'L':
+        {
+          // Lazy node
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id); // We create a React.lazy wrapper around any lazy values.
+          // When passed into React, we'll know how to suspend on this.
+
+          return createLazyChunkWrapper(chunk);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'P':
+        {
+          // Server Context Provider
+          return getOrCreateServerContext(value.slice(2)).Provider;
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16);
+          const metadata = getOutlinedModel(response, id);
+          return createServerReferenceProxy(response, metadata);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+
+            case RESOLVED_MODULE:
+              initializeModuleChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+            case CYCLIC:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key, chunk.status === CYCLIC), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function parseModelTuple(response, value) {
+  const tuple = value;
+
+  if (tuple[0] === REACT_ELEMENT_TYPE) {
+    // TODO: Consider having React just directly accept these arrays as elements.
+    // Or even change the ReactElement type to be an array.
+    return createElement(tuple[1], tuple[2], tuple[3]);
+  }
+
+  return value;
+}
+
+function missingCall() {
+  throw new Error('Trying to call a function from "use server" but the callServer option ' + 'was not implemented in your router runtime.');
+}
+
+function createResponse(bundlerConfig, moduleLoading, callServer, nonce) {
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _moduleLoading: moduleLoading,
+    _callServer: callServer !== undefined ? callServer : missingCall,
+    _nonce: nonce,
+    _chunks: chunks,
+    _stringDecoder: createStringDecoder(),
+    _fromJSON: null,
+    _rowState: 0,
+    _rowID: 0,
+    _rowTag: 0,
+    _rowLength: 0,
+    _buffer: []
+  }; // Don't inline this call because it causes closure to outline the call above.
+
+  response._fromJSON = createFromJSONCallback(response);
+  return response;
+}
+
+function resolveModel(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createResolvedModelChunk(response, model));
+  } else {
+    resolveModelChunk(chunk, model);
+  }
+}
+
+function resolveText(response, id, text) {
+  const chunks = response._chunks; // We assume that we always reference large strings after they've been
+  // emitted.
+
+  chunks.set(id, createInitializedTextChunk(response, text));
+}
+
+function resolveBuffer(response, id, buffer) {
+  const chunks = response._chunks; // We assume that we always reference buffers after they've been emitted.
+
+  chunks.set(id, createInitializedBufferChunk(response, buffer));
+}
+
+function resolveModule(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+  const clientReferenceMetadata = parseModel(response, model);
+  const clientReference = resolveClientReference(response._bundlerConfig, clientReferenceMetadata);
+  prepareDestinationForModule(response._moduleLoading, response._nonce, clientReferenceMetadata); // TODO: Add an option to encode modules that are lazy loaded.
+  // For now we preload all modules as early as possible since it's likely
+  // that we'll need them.
+
+  const promise = preloadModule(clientReference);
+
+  if (promise) {
+    let blockedChunk;
+
+    if (!chunk) {
+      // Technically, we should just treat promise as the chunk in this
+      // case. Because it'll just behave as any other promise.
+      blockedChunk = createBlockedChunk(response);
+      chunks.set(id, blockedChunk);
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+    }
+
+    promise.then(() => resolveModuleChunk(blockedChunk, clientReference), error => triggerErrorOnChunk(blockedChunk, error));
+  } else {
+    if (!chunk) {
+      chunks.set(id, createResolvedModuleChunk(response, clientReference));
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      resolveModuleChunk(chunk, clientReference);
+    }
+  }
+}
+
+function resolveErrorProd(response, id, digest) {
+
+  const error = new Error('An error occurred in the Server Components render. The specific message is omitted in production' + ' builds to avoid leaking sensitive details. A digest property is included on this error instance which' + ' may provide additional details about the nature of the error.');
+  error.stack = 'Error: ' + error.message;
+  error.digest = digest;
+  const errorWithDigest = error;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, errorWithDigest));
+  } else {
+    triggerErrorOnChunk(chunk, errorWithDigest);
+  }
+}
+
+function resolvePostponeProd(response, id) {
+
+  const error = new Error('A Server Component was postponed. The reason is omitted in production' + ' builds to avoid leaking sensitive details.');
+  const postponeInstance = error;
+  postponeInstance.$$typeof = REACT_POSTPONE_TYPE;
+  postponeInstance.stack = 'Error: ' + error.message;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, postponeInstance));
+  } else {
+    triggerErrorOnChunk(chunk, postponeInstance);
+  }
+}
+
+function resolveHint(response, code, model) {
+  const hintModel = parseModel(response, model);
+  dispatchHint(code, hintModel);
+}
+
+function mergeBuffer(buffer, lastChunk) {
+  const l = buffer.length; // Count the bytes we'll need
+
+  let byteLength = lastChunk.length;
+
+  for (let i = 0; i < l; i++) {
+    byteLength += buffer[i].byteLength;
+  } // Allocate enough contiguous space
+
+
+  const result = new Uint8Array(byteLength);
+  let offset = 0; // Copy all the buffers into it.
+
+  for (let i = 0; i < l; i++) {
+    const chunk = buffer[i];
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+
+  result.set(lastChunk, offset);
+  return result;
+}
+
+function resolveTypedArray(response, id, buffer, lastChunk, constructor, bytesPerElement) {
+  // If the view fits into one original buffer, we just reuse that buffer instead of
+  // copying it out to a separate copy. This means that it's not always possible to
+  // transfer these values to other threads without copying first since they may
+  // share array buffer. For this to work, it must also have bytes aligned to a
+  // multiple of a size of the type.
+  const chunk = buffer.length === 0 && lastChunk.byteOffset % bytesPerElement === 0 ? lastChunk : mergeBuffer(buffer, lastChunk); // TODO: The transfer protocol of RSC is little-endian. If the client isn't little-endian
+  // we should convert it instead. In practice big endian isn't really Web compatible so it's
+  // somewhat safe to assume that browsers aren't going to run it, but maybe there's some SSR
+  // server that's affected.
+
+  const view = new constructor(chunk.buffer, chunk.byteOffset, chunk.byteLength / bytesPerElement);
+  resolveBuffer(response, id, view);
+}
+
+function processFullRow(response, id, tag, buffer, chunk) {
+  {
+    switch (tag) {
+      case 65
+      /* "A" */
+      :
+        // We must always clone to extract it into a separate buffer instead of just a view.
+        resolveBuffer(response, id, mergeBuffer(buffer, chunk).buffer);
+        return;
+
+      case 67
+      /* "C" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int8Array, 1);
+        return;
+
+      case 99
+      /* "c" */
+      :
+        resolveBuffer(response, id, buffer.length === 0 ? chunk : mergeBuffer(buffer, chunk));
+        return;
+
+      case 85
+      /* "U" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint8ClampedArray, 1);
+        return;
+
+      case 83
+      /* "S" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int16Array, 2);
+        return;
+
+      case 115
+      /* "s" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint16Array, 2);
+        return;
+
+      case 76
+      /* "L" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int32Array, 4);
+        return;
+
+      case 108
+      /* "l" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint32Array, 4);
+        return;
+
+      case 70
+      /* "F" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Float32Array, 4);
+        return;
+
+      case 68
+      /* "D" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Float64Array, 8);
+        return;
+
+      case 78
+      /* "N" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, BigInt64Array, 8);
+        return;
+
+      case 109
+      /* "m" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, BigUint64Array, 8);
+        return;
+
+      case 86
+      /* "V" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, DataView, 1);
+        return;
+    }
+  }
+
+  const stringDecoder = response._stringDecoder;
+  let row = '';
+
+  for (let i = 0; i < buffer.length; i++) {
+    row += readPartialStringChunk(stringDecoder, buffer[i]);
+  }
+
+  row += readFinalStringChunk(stringDecoder, chunk);
+
+  switch (tag) {
+    case 73
+    /* "I" */
+    :
+      {
+        resolveModule(response, id, row);
+        return;
+      }
+
+    case 72
+    /* "H" */
+    :
+      {
+        const code = row[0];
+        resolveHint(response, code, row.slice(1));
+        return;
+      }
+
+    case 69
+    /* "E" */
+    :
+      {
+        const errorInfo = JSON.parse(row);
+
+        {
+          resolveErrorProd(response, id, errorInfo.digest);
+        }
+
+        return;
+      }
+
+    case 84
+    /* "T" */
+    :
+      {
+        resolveText(response, id, row);
+        return;
+      }
+
+    case 80
+    /* "P" */
+    :
+      {
+        {
+          {
+            resolvePostponeProd(response, id);
+          }
+
+          return;
+        }
+      }
+    // Fallthrough
+
+    default:
+      /* """ "{" "[" "t" "f" "n" "0" - "9" */
+      {
+        // We assume anything else is JSON.
+        resolveModel(response, id, row);
+        return;
+      }
+  }
+}
+
+function processBinaryChunk(response, chunk) {
+  let i = 0;
+  let rowState = response._rowState;
+  let rowID = response._rowID;
+  let rowTag = response._rowTag;
+  let rowLength = response._rowLength;
+  const buffer = response._buffer;
+  const chunkLength = chunk.length;
+
+  while (i < chunkLength) {
+    let lastIdx = -1;
+
+    switch (rowState) {
+      case ROW_ID:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 58
+          /* ":" */
+          ) {
+              // Finished the rowID, next we'll parse the tag.
+              rowState = ROW_TAG;
+            } else {
+            rowID = rowID << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_TAG:
+        {
+          const resolvedRowTag = chunk[i];
+
+          if (resolvedRowTag === 84
+          /* "T" */
+          || (resolvedRowTag === 65
+          /* "A" */
+          || resolvedRowTag === 67
+          /* "C" */
+          || resolvedRowTag === 99
+          /* "c" */
+          || resolvedRowTag === 85
+          /* "U" */
+          || resolvedRowTag === 83
+          /* "S" */
+          || resolvedRowTag === 115
+          /* "s" */
+          || resolvedRowTag === 76
+          /* "L" */
+          || resolvedRowTag === 108
+          /* "l" */
+          || resolvedRowTag === 70
+          /* "F" */
+          || resolvedRowTag === 68
+          /* "D" */
+          || resolvedRowTag === 78
+          /* "N" */
+          || resolvedRowTag === 109
+          /* "m" */
+          || resolvedRowTag === 86)
+          /* "V" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_LENGTH;
+              i++;
+            } else if (resolvedRowTag > 64 && resolvedRowTag < 91
+          /* "A"-"Z" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_CHUNK_BY_NEWLINE;
+              i++;
+            } else {
+            rowTag = 0;
+            rowState = ROW_CHUNK_BY_NEWLINE; // This was an unknown tag so it was probably part of the data.
+          }
+
+          continue;
+        }
+
+      case ROW_LENGTH:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 44
+          /* "," */
+          ) {
+              // Finished the rowLength, next we'll buffer up to that length.
+              rowState = ROW_CHUNK_BY_LENGTH;
+            } else {
+            rowLength = rowLength << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_CHUNK_BY_NEWLINE:
+        {
+          // We're looking for a newline
+          lastIdx = chunk.indexOf(10
+          /* "\n" */
+          , i);
+          break;
+        }
+
+      case ROW_CHUNK_BY_LENGTH:
+        {
+          // We're looking for the remaining byte length
+          lastIdx = i + rowLength;
+
+          if (lastIdx > chunk.length) {
+            lastIdx = -1;
+          }
+
+          break;
+        }
+    }
+
+    const offset = chunk.byteOffset + i;
+
+    if (lastIdx > -1) {
+      // We found the last chunk of the row
+      const length = lastIdx - i;
+      const lastChunk = new Uint8Array(chunk.buffer, offset, length);
+      processFullRow(response, rowID, rowTag, buffer, lastChunk); // Reset state machine for a new row
+
+      i = lastIdx;
+
+      if (rowState === ROW_CHUNK_BY_NEWLINE) {
+        // If we're trailing by a newline we need to skip it.
+        i++;
+      }
+
+      rowState = ROW_ID;
+      rowTag = 0;
+      rowID = 0;
+      rowLength = 0;
+      buffer.length = 0;
+    } else {
+      // The rest of this row is in a future chunk. We stash the rest of the
+      // current chunk until we can process the full row.
+      const length = chunk.byteLength - i;
+      const remainingSlice = new Uint8Array(chunk.buffer, offset, length);
+      buffer.push(remainingSlice); // Update how many bytes we're still waiting for. If we're looking for
+      // a newline, this doesn't hurt since we'll just ignore it.
+
+      rowLength -= remainingSlice.byteLength;
+      break;
+    }
+  }
+
+  response._rowState = rowState;
+  response._rowID = rowID;
+  response._rowTag = rowTag;
+  response._rowLength = rowLength;
+}
+
+function parseModel(response, json) {
+  return JSON.parse(json, response._fromJSON);
+}
+
+function createFromJSONCallback(response) {
+  // $FlowFixMe[missing-this-annot]
+  return function (key, value) {
+    if (typeof value === 'string') {
+      // We can't use .bind here because we need the "this" value.
+      return parseModelString(response, this, key, value);
+    }
+
+    if (typeof value === 'object' && value !== null) {
+      return parseModelTuple(response, value);
+    }
+
+    return value;
+  };
+}
+
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function noServerCall() {
+  throw new Error('Server Functions cannot be called during initial render. ' + 'This would create a fetch waterfall. Try to use a Server Component ' + 'to pass data to Client Components instead.');
+}
+
+function createServerReference(id, callServer) {
+  return createServerReference$1(id, noServerCall);
+}
+
+function createFromNodeStream(stream, ssrManifest, options) {
+  const response = createResponse(ssrManifest.moduleMap, ssrManifest.moduleLoading, noServerCall, options && typeof options.nonce === 'string' ? options.nonce : undefined);
+  stream.on('data', chunk => {
+    processBinaryChunk(response, chunk);
+  });
+  stream.on('error', error => {
+    reportGlobalError(response, error);
+  });
+  stream.on('end', () => close(response));
+  return getRoot(response);
+}
+
+exports.createFromNodeStream = createFromNodeStream;
+exports.createServerReference = createServerReference;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.node.unbundled.production.min.js b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.node.unbundled.production.min.js
index d2680f749e1ad..ab805e8306ab0 100644
--- a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.node.unbundled.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.node.unbundled.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-turbopack-client.node.unbundled.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-turbopack-client.node.unbundled.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var n=require("util"),q=require("react-dom"),r=require("react"),u={stream:!0};function v(a,b){var c=a[b[0]];if(a=c[b[2]])c=a.name;else{a=c["*"];if(!a)throw Error('Could not find the module "'+b[0]+'" in the React SSR Manifest. This is probably a bug in the React Server Components bundler.');c=b[2]}return{specifier:a.specifier,name:c,async:4===b.length}}var w=new Map;
 function x(a){var b=w.get(a.specifier);if(b)return"fulfilled"===b.status?null:b;var c=import(a.specifier);a.async&&(c=c.then(function(d){return d.default}));c.then(function(d){var e=c;e.status="fulfilled";e.value=d},function(d){var e=c;e.status="rejected";e.reason=d});w.set(a.specifier,c);return c}
 function y(a,b,c){if(null!==a)for(var d=0;d<b.length;d++){var e=c,g=A.current;if(g){var f=g.preinitScript,l=a.prefix+b[d];var k=a.crossOrigin;k="string"===typeof k?"use-credentials"===k?k:"":void 0;f.call(g,l,{crossOrigin:k,nonce:e})}}}
@@ -42,3 +42,5 @@ f.stack="Error: "+f.message;f.digest=c;c=a._chunks;(d=c.get(b))?P(d,f):c.set(b,n
 exports.createFromNodeStream=function(a,b,c){var d=xa(b.moduleMap,b.moduleLoading,Z,c&&"string"===typeof c.nonce?c.nonce:void 0);a.on("data",function(e){for(var g=0,f=d._rowState,l=d._rowID,k=d._rowTag,h=d._rowLength,t=d._buffer,F=e.length;g<F;){var m=-1;switch(f){case 0:m=e[g++];58===m?f=1:l=l<<4|(96<m?m-87:m-48);continue;case 1:f=e[g];84===f||65===f||67===f||99===f||85===f||83===f||115===f||76===f||108===f||70===f||68===f||78===f||109===f||86===f?(k=f,f=2,g++):64<f&&91>f?(k=f,f=3,g++):(k=0,f=3);
 continue;case 2:m=e[g++];44===m?f=4:h=h<<4|(96<m?m-87:m-48);continue;case 3:m=e.indexOf(10,g);break;case 4:m=g+h,m>e.length&&(m=-1)}var p=e.byteOffset+g;if(-1<m)h=new Uint8Array(e.buffer,p,m-g),Aa(d,l,k,t,h),g=m,3===f&&g++,h=l=k=f=0,t.length=0;else{e=new Uint8Array(e.buffer,p,e.byteLength-g);t.push(e);h-=e.byteLength;break}}d._rowState=f;d._rowID=l;d._rowTag=k;d._rowLength=h});a.on("error",function(e){T(d,e)});a.on("end",function(){T(d,Error("Connection closed."))});return U(d,0)};
 exports.createServerReference=function(a){return qa(a,Z)};
+
+//# sourceMappingURL=react-server-dom-turbopack-client.node.unbundled.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-node-register.js b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-node-register.js
index e8df62f078ec0..dd060d358236a 100644
--- a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-node-register.js
+++ b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-node-register.js
@@ -1,15 +1,14 @@
-/**
- * @license React
- * react-server-dom-turbopack-node-register.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-turbopack-node-register.js
 
-'use strict';
+ Copyright (c) Meta Platforms, Inc. and affiliates.
 
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';const h=require("acorn-loose"),l=require("url"),q=require("module");
 module.exports=function(){const m=require("react-server-dom-turbopack/server"),n=m.registerServerReference,r=m.createClientModuleProxy,f=q.prototype._compile;q.prototype._compile=function(k,p){if(-1===k.indexOf("use client")&&-1===k.indexOf("use server"))return f.apply(this,arguments);try{var a=h.parse(k,{ecmaVersion:"2024",sourceType:"source"}).body}catch(g){return console.error("Error parsing %s %s",l,g.message),f.apply(this,arguments)}var b=!1,d=!1;for(var c=0;c<a.length;c++){var e=a[c];if("ExpressionStatement"!==
 e.type||!e.directive)break;"use client"===e.directive&&(b=!0);"use server"===e.directive&&(d=!0)}if(!b&&!d)return f.apply(this,arguments);if(b&&d)throw Error('Cannot have both "use client" and "use server" directives in the same file.');b&&(a=l.pathToFileURL(p).href,this.exports=r(a));if(d)if(f.apply(this,arguments),d=l.pathToFileURL(p).href,a=this.exports,"function"===typeof a)n(a,d,null);else for(b=Object.keys(a),c=0;c<b.length;c++){e=b[c];const g=a[b[c]];"function"===typeof g&&n(g,d,e)}}};
+
+//# sourceMappingURL=react-server-dom-turbopack-node-register.js.map
diff --git a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.browser.production.js b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.browser.production.js
new file mode 100644
index 0000000000000..a57bd5d03797f
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.browser.production.js
@@ -0,0 +1,3387 @@
+/**
+ * @license React
+ * react-server-dom-turbopack-server.browser.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var ReactDOM = require('react-dom');
+var React = require('react');
+
+// -----------------------------------------------------------------------------
+const enablePostpone = true;
+
+function scheduleWork(callback) {
+  callback();
+}
+const VIEW_SIZE = 512;
+let currentView = null;
+let writtenBytes = 0;
+function beginWriting(destination) {
+  currentView = new Uint8Array(VIEW_SIZE);
+  writtenBytes = 0;
+}
+function writeChunk(destination, chunk) {
+  if (chunk.byteLength === 0) {
+    return;
+  }
+
+  if (chunk.byteLength > VIEW_SIZE) {
+    // one that is cached by the streaming renderer. We will enqueu
+    // it directly and expect it is not re-used
+
+
+    if (writtenBytes > 0) {
+      destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    destination.enqueue(chunk);
+    return;
+  }
+
+  let bytesToWrite = chunk;
+  const allowableBytes = currentView.length - writtenBytes;
+
+  if (allowableBytes < bytesToWrite.byteLength) {
+    // this chunk would overflow the current view. We enqueue a full view
+    // and start a new view with the remaining chunk
+    if (allowableBytes === 0) {
+      // the current view is already full, send it
+      destination.enqueue(currentView);
+    } else {
+      // fill up the current view and apply the remaining chunk bytes
+      // to a new view.
+      currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes); // writtenBytes += allowableBytes; // this can be skipped because we are going to immediately reset the view
+
+      destination.enqueue(currentView);
+      bytesToWrite = bytesToWrite.subarray(allowableBytes);
+    }
+
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+
+  currentView.set(bytesToWrite, writtenBytes);
+  writtenBytes += bytesToWrite.byteLength;
+}
+function writeChunkAndReturn(destination, chunk) {
+  writeChunk(destination, chunk); // in web streams there is no backpressure so we can alwas write more
+
+  return true;
+}
+function completeWriting(destination) {
+  if (currentView && writtenBytes > 0) {
+    destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+    currentView = null;
+    writtenBytes = 0;
+  }
+}
+function close$1(destination) {
+  destination.close();
+}
+const textEncoder = new TextEncoder();
+function stringToChunk(content) {
+  return textEncoder.encode(content);
+}
+function typedArrayToBinaryChunk(content) {
+  // Convert any non-Uint8Array array to Uint8Array. We could avoid this for Uint8Arrays.
+  // If we passed through this straight to enqueue we wouldn't have to convert it but since
+  // we need to copy the buffer in that case, we need to convert it to copy it.
+  // When we copy it into another array using set() it needs to be a Uint8Array.
+  const buffer = new Uint8Array(content.buffer, content.byteOffset, content.byteLength); // We clone large chunks so that we can transfer them when we write them.
+  // Others get copied into the target buffer.
+
+  return content.byteLength > VIEW_SIZE ? buffer.slice() : buffer;
+}
+function byteLengthOfChunk(chunk) {
+  return chunk.byteLength;
+}
+function byteLengthOfBinaryChunk(chunk) {
+  return chunk.byteLength;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[method-unbinding]
+  if (typeof destination.error === 'function') {
+    // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+    destination.error(error);
+  } else {
+    // Earlier implementations doesn't support this method. In that environment you're
+    // supposed to throw from a promise returned but we don't return a promise in our
+    // approach. We could fork this implementation but this is environment is an edge
+    // case to begin with. It's even less common to run this in an older environment.
+    // Even then, this is not where errors are supposed to happen and they get reported
+    // to a global callback in addition to this anyway. So it's fine just to close this.
+    destination.close();
+  }
+}
+
+// eslint-disable-next-line no-unused-vars
+const CLIENT_REFERENCE_TAG = Symbol.for('react.client.reference');
+const SERVER_REFERENCE_TAG = Symbol.for('react.server.reference');
+function isClientReference(reference) {
+  return reference.$$typeof === CLIENT_REFERENCE_TAG;
+}
+function isServerReference(reference) {
+  return reference.$$typeof === SERVER_REFERENCE_TAG;
+}
+function registerClientReference(proxyImplementation, id, exportName) {
+  return registerClientReferenceImpl(proxyImplementation, id + '#' + exportName, false);
+}
+
+function registerClientReferenceImpl(proxyImplementation, id, async) {
+  return Object.defineProperties(proxyImplementation, {
+    $$typeof: {
+      value: CLIENT_REFERENCE_TAG
+    },
+    $$id: {
+      value: id
+    },
+    $$async: {
+      value: async
+    }
+  });
+} // $FlowFixMe[method-unbinding]
+
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+
+  if (this.$$typeof === SERVER_REFERENCE_TAG) {
+    const args = ArraySlice.call(arguments, 1);
+    newFn.$$typeof = SERVER_REFERENCE_TAG;
+    newFn.$$id = this.$$id;
+    newFn.$$bound = this.$$bound ? this.$$bound.concat(args) : args;
+  }
+
+  return newFn;
+}
+
+function registerServerReference(reference, id, exportName) {
+  return Object.defineProperties(reference, {
+    $$typeof: {
+      value: SERVER_REFERENCE_TAG
+    },
+    $$id: {
+      value: exportName === null ? id : id + '#' + exportName
+    },
+    $$bound: {
+      value: null
+    },
+    bind: {
+      value: bind
+    }
+  });
+}
+const PROMISE_PROTOTYPE = Promise.prototype;
+const deepProxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        // These names are a little too common. We should probably have a way to
+        // have the Flight runtime extract the inner target instead.
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+
+      case 'displayName':
+        return undefined;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case 'Provider':
+        throw new Error("Cannot render a Client Context Provider on the Server. " + "Instead, you can export a Client Component wrapper " + "that itself renders a Client Context Provider.");
+    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+    const expression = String(target.name) + '.' + String(name);
+    throw new Error("Cannot access " + expression + " on the server. " + 'You cannot dot into a client module from a server component. ' + 'You can only pass the imported name through.');
+  },
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+const proxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case '__esModule':
+        // Something is conditionally checking which export to use. We'll pretend to be
+        // an ESM compat module but then we'll check again on the client.
+        const moduleId = target.$$id;
+        target.default = registerClientReferenceImpl(function () {
+          throw new Error("Attempted to call the default export of " + moduleId + " from the server " + "but it's on the client. It's not possible to invoke a client function from " + "the server, it can only be rendered as a Component or passed to props of a " + "Client Component.");
+        }, target.$$id + '#', target.$$async);
+        return true;
+
+      case 'then':
+        if (target.then) {
+          // Use a cached value
+          return target.then;
+        }
+
+        if (!target.$$async) {
+          // If this module is expected to return a Promise (such as an AsyncModule) then
+          // we should resolve that with a client reference that unwraps the Promise on
+          // the client.
+          const clientReference = registerClientReferenceImpl({}, target.$$id, true);
+          const proxy = new Proxy(clientReference, proxyHandlers); // Treat this as a resolved Promise for React's use()
+
+          target.status = 'fulfilled';
+          target.value = proxy;
+          const then = target.then = registerClientReferenceImpl(function then(resolve, reject) {
+            // Expose to React.
+            return Promise.resolve(resolve(proxy));
+          }, // If this is not used as a Promise but is treated as a reference to a `.then`
+          // export then we should treat it as a reference to that name.
+          target.$$id + '#then', false);
+          return then;
+        } else {
+          // Since typeof .then === 'function' is a feature test we'd continue recursing
+          // indefinitely if we return a function. Instead, we return an object reference
+          // if we check further.
+          return undefined;
+        }
+
+    }
+
+    let cachedReference = target[name];
+
+    if (!cachedReference) {
+      const reference = registerClientReferenceImpl(function () {
+        throw new Error( // eslint-disable-next-line react-internal/safe-string-coercion
+        "Attempted to call " + String(name) + "() from the server but " + String(name) + " is on the client. " + "It's not possible to invoke a client function from the server, it can " + "only be rendered as a Component or passed to props of a Client Component.");
+      }, target.$$id + '#' + name, target.$$async);
+      Object.defineProperty(reference, 'name', {
+        value: name
+      });
+      cachedReference = target[name] = new Proxy(reference, deepProxyHandlers);
+    }
+
+    return cachedReference;
+  },
+
+  getPrototypeOf(target) {
+    // Pretend to be a Promise in case anyone asks.
+    return PROMISE_PROTOTYPE;
+  },
+
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+function createClientModuleProxy(moduleId) {
+  const clientReference = registerClientReferenceImpl({}, // Represents the whole Module object instead of a particular import.
+  moduleId, false);
+  return new Proxy(clientReference, proxyHandlers);
+}
+
+function getClientReferenceKey(reference) {
+  return reference.$$async ? reference.$$id + '#async' : reference.$$id;
+}
+function resolveClientReferenceMetadata(config, clientReference) {
+  const modulePath = clientReference.$$id;
+  let name = '';
+  let resolvedModuleData = config[modulePath];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = modulePath.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = modulePath.slice(idx + 1);
+      resolvedModuleData = config[modulePath.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + modulePath + '" in the React Client Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  }
+
+  if (clientReference.$$async === true) {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1];
+  } else {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+  }
+}
+function getServerReferenceId(config, serverReference) {
+  return serverReference.$$id;
+}
+function getServerReferenceBoundArguments(config, serverReference) {
+  return serverReference.$$bound;
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMFlightServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule: preloadModule$1,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+
+function prefetchDNS(href) {
+  {
+    if (typeof href === 'string' && href) {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'D|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        emitHint(request, 'D', href);
+      }
+    }
+  }
+}
+
+function preconnect(href, crossOrigin) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = "C|" + (crossOrigin == null ? 'null' : crossOrigin) + "|" + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+
+        if (typeof crossOrigin === 'string') {
+          emitHint(request, 'C', [href, crossOrigin]);
+        } else {
+          emitHint(request, 'C', href);
+        }
+      }
+    }
+  }
+}
+
+function preload(href, as, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        let key = 'L';
+
+        if (as === 'image' && options) {
+          key += getImagePreloadKey(href, options.imageSrcSet, options.imageSizes);
+        } else {
+          key += "[" + as + "]" + href;
+        }
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          emitHint(request, 'L', [href, as, trimmed]);
+        } else {
+          emitHint(request, 'L', [href, as]);
+        }
+      }
+    }
+  }
+}
+
+function preloadModule$1(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'm|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'm', [href, trimmed]);
+        } else {
+          return emitHint(request, 'm', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'S|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'S', [href, typeof precedence === 'string' ? precedence : 0, trimmed]);
+        } else if (typeof precedence === 'string') {
+          return emitHint(request, 'S', [href, precedence]);
+        } else {
+          return emitHint(request, 'S', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'X|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'X', [href, trimmed]);
+        } else {
+          return emitHint(request, 'X', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitModuleScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'M|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'M', [href, trimmed]);
+        } else {
+          return emitHint(request, 'M', href);
+        }
+      }
+    }
+  }
+} // Flight normally encodes undefined as a special character however for directive option
+// arguments we don't want to send unnecessary keys and bloat the payload so we create a
+// trimmed object which omits any keys with null or undefined values.
+// This is only typesafe because these option objects have entirely optional fields where
+// null and undefined represent the same thing as no property.
+
+
+function trimOptions(options) {
+  if (options == null) return null;
+  let hasProperties = false;
+  const trimmed = {};
+
+  for (const key in options) {
+    if (options[key] != null) {
+      hasProperties = true;
+      trimmed[key] = options[key];
+    }
+  }
+
+  return hasProperties ? trimmed : null;
+}
+
+function getImagePreloadKey(href, imageSrcSet, imageSizes) {
+  let uniquePart = '';
+
+  if (typeof imageSrcSet === 'string' && imageSrcSet !== '') {
+    uniquePart += '[' + imageSrcSet + ']';
+
+    if (typeof imageSizes === 'string') {
+      uniquePart += '[' + imageSizes + ']';
+    }
+  } else {
+    uniquePart += '[][]' + href;
+  }
+
+  return "[image]" + uniquePart;
+}
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMFlightServerDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+// small, smaller than how we encode undefined, and is unambiguous. We could use
+// a different tuple structure to encode this instead but this makes the runtime
+// cost cheaper by eliminating a type checks in more positions.
+// prettier-ignore
+
+function createHints() {
+  return new Set();
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext); // On the way back, we push the new ones that weren't common.
+
+      pushNode(next);
+    }
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function pushProvider(context, nextValue) {
+  let prevValue;
+
+  {
+    prevValue = context._currentValue;
+    context._currentValue = nextValue;
+  }
+
+  const prevNode = currentActiveSnapshot;
+  const newNode = {
+    parent: prevNode,
+    depth: prevNode === null ? 0 : prevNode.depth + 1,
+    context: context,
+    parentValue: prevValue,
+    value: nextValue
+  };
+  currentActiveSnapshot = newNode;
+  return newNode;
+}
+function popProvider() {
+  const prevSnapshot = currentActiveSnapshot;
+
+  if (prevSnapshot === null) {
+    throw new Error('Tried to pop a Context at the root of the app. This is a bug in React.');
+  }
+
+  {
+    const value = prevSnapshot.parentValue;
+
+    if (value === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      prevSnapshot.context._currentValue = prevSnapshot.context._defaultValue;
+    } else {
+      prevSnapshot.context._currentValue = value;
+    }
+  }
+
+  return currentActiveSnapshot = prevSnapshot.parent;
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFizzWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop, noop);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+let currentRequest$1 = null;
+let thenableIndexCounter = 0;
+let thenableState = null;
+function prepareToUseHooksForRequest(request) {
+  currentRequest$1 = request;
+}
+function resetHooksForRequest() {
+  currentRequest$1 = null;
+}
+function prepareToUseHooksForComponent(prevThenableState) {
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+const HooksDispatcher = {
+  useMemo(nextCreate) {
+    return nextCreate();
+  },
+
+  useCallback(callback) {
+    return callback;
+  },
+
+  useDebugValue() {},
+
+  useDeferredValue: unsupportedHook,
+  useTransition: unsupportedHook,
+  readContext,
+  useContext: readContext,
+  useReducer: unsupportedHook,
+  useRef: unsupportedHook,
+  useState: unsupportedHook,
+  useInsertionEffect: unsupportedHook,
+  useLayoutEffect: unsupportedHook,
+  useImperativeHandle: unsupportedHook,
+  useEffect: unsupportedHook,
+  useId,
+  useSyncExternalStore: unsupportedHook,
+
+  useCacheRefresh() {
+    return unsupportedRefresh;
+  },
+
+  useMemoCache(size) {
+    const data = new Array(size);
+
+    for (let i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL;
+    }
+
+    return data;
+  },
+
+  use
+};
+
+function unsupportedHook() {
+  throw new Error('This Hook is not supported in Server Components.');
+}
+
+function unsupportedRefresh() {
+  throw new Error('Refreshing the cache is not supported in Server Components.');
+}
+
+function useId() {
+  if (currentRequest$1 === null) {
+    throw new Error('useId can only be used while React is rendering');
+  }
+
+  const id = currentRequest$1.identifierCount++; // use 'S' for Flight components to distinguish from 'R' and 'r' in Fizz/Client
+
+  return ':' + currentRequest$1.identifierPrefix + 'S' + id.toString(32) + ':';
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object' || typeof usable === 'function') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable; // Track the position of the thenable within this fiber.
+
+      const index = thenableIndexCounter;
+      thenableIndexCounter += 1;
+
+      if (thenableState === null) {
+        thenableState = createThenableState();
+      }
+
+      return trackUsedThenable(thenableState, thenable, index);
+    } else if (usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  }
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function createSignal() {
+  return new AbortController().signal;
+}
+
+function resolveCache() {
+  const request = resolveRequest();
+
+  if (request) {
+    return getCache(request);
+  }
+
+  return new Map();
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal() {
+    const cache = resolveCache();
+    let entry = cache.get(createSignal);
+
+    if (entry === undefined) {
+      entry = createSignal();
+      cache.set(createSignal, entry);
+    }
+
+    return entry;
+  },
+
+  getCacheForType(resourceType) {
+    const cache = resolveCache();
+    let entry = cache.get(resourceType);
+
+    if (entry === undefined) {
+      entry = resourceType(); // TODO: Warn if undefined?
+
+      cache.set(resourceType, entry);
+    }
+
+    return entry;
+  }
+
+};
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+function objectName(object) {
+  // $FlowFixMe[method-unbinding]
+  const name = Object.prototype.toString.call(object);
+  return name.replace(/^\[object (.*)\]$/, function (m, p0) {
+    return p0;
+  });
+}
+
+function describeKeyForErrorMessage(key) {
+  const encodedKey = JSON.stringify(key);
+  return '"' + key + '"' === encodedKey ? key : encodedKey;
+}
+
+function describeValueForErrorMessage(value) {
+  switch (typeof value) {
+    case 'string':
+      {
+        return JSON.stringify(value.length <= 10 ? value : value.slice(0, 10) + '...');
+      }
+
+    case 'object':
+      {
+        if (isArray(value)) {
+          return '[...]';
+        }
+
+        const name = objectName(value);
+
+        if (name === 'Object') {
+          return '{...}';
+        }
+
+        return name;
+      }
+
+    case 'function':
+      return 'function';
+
+    default:
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      return String(value);
+  }
+}
+
+function describeElementType(type) {
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        return describeElementType(type.render);
+
+      case REACT_MEMO_TYPE:
+        return describeElementType(type.type);
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            // Lazy may contain any component type so we recursively resolve it.
+            return describeElementType(init(payload));
+          } catch (x) {}
+        }
+    }
+  }
+
+  return '';
+}
+
+function describeObjectForErrorMessage(objectOrArray, expandedName) {
+  const objKind = objectName(objectOrArray);
+
+  if (objKind !== 'Object' && objKind !== 'Array') {
+    return objKind;
+  }
+
+  let str = '';
+  let start = -1;
+  let length = 0;
+
+  if (isArray(objectOrArray)) {
+    {
+      // Print Array
+      str = '[';
+      const array = objectOrArray;
+
+      for (let i = 0; i < array.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const value = array[i];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if ('' + i === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += ']';
+    }
+  } else {
+    if (objectOrArray.$$typeof === REACT_ELEMENT_TYPE) {
+      str = '<' + describeElementType(objectOrArray.type) + '/>';
+    } else {
+      // Print Object
+      str = '{';
+      const object = objectOrArray;
+      const names = Object.keys(object);
+
+      for (let i = 0; i < names.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const name = names[i];
+        str += describeKeyForErrorMessage(name) + ': ';
+        const value = object[name];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if (name === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += '}';
+    }
+  }
+
+  if (expandedName === undefined) {
+    return str;
+  }
+
+  if (start > -1 && length > 0) {
+    const highlight = ' '.repeat(start) + '^'.repeat(length);
+    return '\n  ' + str + '\n  ' + highlight;
+  }
+
+  return '\n  ' + str;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ReactSharedServerInternals = // $FlowFixMe: It's defined in the one we resolve to.
+React.__SECRET_SERVER_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+if (!ReactSharedServerInternals) {
+  throw new Error('The "react" package in this environment is not configured correctly. ' + 'The "react-server" condition must be enabled in any environment that ' + 'runs React Server Components.');
+}
+
+// Turns a TypedArray or ArrayBuffer into a string that can be used for comparison
+// in a Map to see if the bytes are the same.
+function binaryToComparableString(view) {
+  return String.fromCharCode.apply(String, new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+}
+
+const ObjectPrototype = Object.prototype;
+const stringify = JSON.stringify; // Serializable values
+// Thenable<ReactClientValue>
+
+const PENDING$1 = 0;
+const COMPLETED = 1;
+const ABORTED = 3;
+const ERRORED$1 = 4;
+const TaintRegistryObjects = ReactSharedServerInternals.TaintRegistryObjects,
+      TaintRegistryValues = ReactSharedServerInternals.TaintRegistryValues,
+      TaintRegistryByteLengths = ReactSharedServerInternals.TaintRegistryByteLengths,
+      TaintRegistryPendingRequests = ReactSharedServerInternals.TaintRegistryPendingRequests,
+      ReactCurrentCache = ReactSharedServerInternals.ReactCurrentCache;
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+
+function throwTaintViolation(message) {
+  // eslint-disable-next-line react-internal/prod-error-codes
+  throw new Error(message);
+}
+
+function cleanupTaintQueue(request) {
+  const cleanupQueue = request.taintCleanupQueue;
+  TaintRegistryPendingRequests.delete(cleanupQueue);
+
+  for (let i = 0; i < cleanupQueue.length; i++) {
+    const entryValue = cleanupQueue[i];
+    const entry = TaintRegistryValues.get(entryValue);
+
+    if (entry !== undefined) {
+      if (entry.count === 1) {
+        TaintRegistryValues.delete(entryValue);
+      } else {
+        entry.count--;
+      }
+    }
+  }
+
+  cleanupQueue.length = 0;
+}
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+}
+
+function defaultPostponeHandler(reason) {// Noop
+}
+
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2;
+function createRequest(model, bundlerConfig, onError, context, identifierPrefix, onPostpone) {
+  if (ReactCurrentCache.current !== null && ReactCurrentCache.current !== DefaultCacheDispatcher) {
+    throw new Error('Currently React only supports one RSC renderer at a time.');
+  }
+
+  prepareHostDispatcher();
+  ReactCurrentCache.current = DefaultCacheDispatcher;
+  const abortSet = new Set();
+  const pingedTasks = [];
+  const cleanupQueue = [];
+
+  {
+    TaintRegistryPendingRequests.add(cleanupQueue);
+  }
+
+  const hints = createHints();
+  const request = {
+    status: OPEN,
+    flushScheduled: false,
+    fatalError: null,
+    destination: null,
+    bundlerConfig,
+    cache: new Map(),
+    nextChunkId: 0,
+    pendingChunks: 0,
+    hints,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    completedImportChunks: [],
+    completedHintChunks: [],
+    completedRegularChunks: [],
+    completedErrorChunks: [],
+    writtenSymbols: new Map(),
+    writtenClientReferences: new Map(),
+    writtenServerReferences: new Map(),
+    writtenProviders: new Map(),
+    writtenObjects: new WeakMap(),
+    identifierPrefix: identifierPrefix || '',
+    identifierCount: 1,
+    taintCleanupQueue: cleanupQueue,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? defaultPostponeHandler : onPostpone,
+    // $FlowFixMe[missing-this-annot]
+    toJSON: function (key, value) {
+      return resolveModelToJSON(request, this, key, value);
+    }
+  };
+  request.pendingChunks++;
+  const rootContext = createRootContext(context);
+  const rootTask = createTask(request, model, rootContext, abortSet);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  return null;
+}
+
+function createRootContext(reqContext) {
+  return importServerContexts(reqContext);
+}
+
+const POP = {};
+
+function serializeThenable(request, thenable) {
+  request.pendingChunks++;
+  const newTask = createTask(request, null, getActiveContext(), request.abortableTasks);
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        // We have the resolved value, we can go ahead and schedule it for serialization.
+        newTask.model = thenable.value;
+        pingTask(request, newTask);
+        return newTask.id;
+      }
+
+    case 'rejected':
+      {
+        const x = thenable.reason;
+
+        if (typeof x === 'object' && x !== null && x.$$typeof === REACT_POSTPONE_TYPE) {
+          const postponeInstance = x;
+          logPostpone(request, postponeInstance.message);
+          emitPostponeChunk(request, newTask.id);
+        } else {
+          const digest = logRecoverableError(request, x);
+          emitErrorChunk(request, newTask.id, digest);
+        }
+
+        return newTask.id;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  thenable.then(value => {
+    newTask.model = value;
+    pingTask(request, newTask);
+  }, reason => {
+    newTask.status = ERRORED$1;
+    request.abortableTasks.delete(newTask); // TODO: We should ideally do this inside performWork so it's scheduled
+
+    const digest = logRecoverableError(request, reason);
+    emitErrorChunk(request, newTask.id, digest);
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  });
+  return newTask.id;
+}
+
+function emitHint(request, code, model) {
+  emitHintChunk(request, code, model);
+  enqueueFlush(request);
+}
+function getHints(request) {
+  return request.hints;
+}
+function getCache(request) {
+  return request.cache;
+}
+
+function readThenable(thenable) {
+  if (thenable.status === 'fulfilled') {
+    return thenable.value;
+  } else if (thenable.status === 'rejected') {
+    throw thenable.reason;
+  }
+
+  throw thenable;
+}
+
+function createLazyWrapperAroundWakeable(wakeable) {
+  // This is a temporary fork of the `use` implementation until we accept
+  // promises everywhere.
+  const thenable = wakeable;
+
+  switch (thenable.status) {
+    case 'fulfilled':
+    case 'rejected':
+      break;
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: thenable,
+    _init: readThenable
+  };
+  return lazyType;
+}
+
+function attemptResolveElement(request, type, key, ref, props, prevThenableState) {
+  if (ref !== null && ref !== undefined) {
+    // When the ref moves to the regular props object this will implicitly
+    // throw for functions. We could probably relax it to a DEV warning for other
+    // cases.
+    throw new Error('Refs cannot be used in Server Components, nor passed to Client Components.');
+  }
+
+  if (typeof type === 'function') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    } // This is a server-side component.
+
+
+    prepareToUseHooksForComponent(prevThenableState);
+    const result = type(props);
+
+    if (typeof result === 'object' && result !== null && typeof result.then === 'function') {
+      // When the return value is in children position we can resolve it immediately,
+      // to its value without a wrapper if it's synchronously available.
+      const thenable = result;
+
+      if (thenable.status === 'fulfilled') {
+        return thenable.value;
+      } // TODO: Once we accept Promises as children on the client, we can just return
+      // the thenable here.
+
+
+      return createLazyWrapperAroundWakeable(result);
+    }
+
+    return result;
+  } else if (typeof type === 'string') {
+    // This is a host element. E.g. HTML.
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (typeof type === 'symbol') {
+    if (type === REACT_FRAGMENT_TYPE) {
+      // For key-less fragments, we add a small optimization to avoid serializing
+      // it as a wrapper.
+      // TODO: If a key is specified, we should propagate its key to any children.
+      // Same as if a Server Component has a key.
+      return props.children;
+    } // This might be a built-in React component. We'll let the client decide.
+    // Any built-in works as long as its props are serializable.
+
+
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (type != null && typeof type === 'object') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    }
+
+    switch (type.$$typeof) {
+      case REACT_LAZY_TYPE:
+        {
+          const payload = type._payload;
+          const init = type._init;
+          const wrappedType = init(payload);
+          return attemptResolveElement(request, wrappedType, key, ref, props, prevThenableState);
+        }
+
+      case REACT_FORWARD_REF_TYPE:
+        {
+          const render = type.render;
+          prepareToUseHooksForComponent(prevThenableState);
+          return render(props, undefined);
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          return attemptResolveElement(request, type.type, key, ref, props, prevThenableState);
+        }
+
+      case REACT_PROVIDER_TYPE:
+        {
+          {
+            pushProvider(type._context, props.value);
+
+            return [REACT_ELEMENT_TYPE, type, key, // Rely on __popProvider being serialized last to pop the provider.
+            {
+              value: props.value,
+              children: props.children,
+              __pop: POP
+            }];
+          } // Fallthrough
+
+        }
+    }
+  }
+
+  throw new Error("Unsupported Server Component type: " + describeValueForErrorMessage(type));
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createTask(request, model, context, abortSet) {
+  const id = request.nextChunkId++;
+  const task = {
+    id,
+    status: PENDING$1,
+    model,
+    context,
+    ping: () => pingTask(request, task),
+    thenableState: null
+  };
+  abortSet.add(task);
+  return task;
+}
+
+function serializeByValueID(id) {
+  return '$' + id.toString(16);
+}
+
+function serializeLazyID(id) {
+  return '$L' + id.toString(16);
+}
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeProviderReference(name) {
+  return '$P' + name;
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeRowHeader(tag, id) {
+  return id.toString(16) + ':' + tag;
+}
+
+function encodeReferenceChunk(request, id, reference) {
+  const json = stringify(reference);
+  const row = id.toString(16) + ':' + json + '\n';
+  return stringToChunk(row);
+}
+
+function serializeClientReference(request, parent, key, clientReference) {
+  const clientReferenceKey = getClientReferenceKey(clientReference);
+  const writtenClientReferences = request.writtenClientReferences;
+  const existingId = writtenClientReferences.get(clientReferenceKey);
+
+  if (existingId !== undefined) {
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(existingId);
+    }
+
+    return serializeByValueID(existingId);
+  }
+
+  try {
+    const clientReferenceMetadata = resolveClientReferenceMetadata(request.bundlerConfig, clientReference);
+    request.pendingChunks++;
+    const importId = request.nextChunkId++;
+    emitImportChunk(request, importId, clientReferenceMetadata);
+    writtenClientReferences.set(clientReferenceKey, importId);
+
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(importId);
+    }
+
+    return serializeByValueID(importId);
+  } catch (x) {
+    request.pendingChunks++;
+    const errorId = request.nextChunkId++;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, errorId, digest);
+    return serializeByValueID(errorId);
+  }
+}
+
+function outlineModel(request, value) {
+  request.pendingChunks++;
+  const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+  retryTask(request, newTask);
+  return newTask.id;
+}
+
+function serializeServerReference(request, parent, key, serverReference) {
+  const writtenServerReferences = request.writtenServerReferences;
+  const existingId = writtenServerReferences.get(serverReference);
+
+  if (existingId !== undefined) {
+    return serializeServerReferenceID(existingId);
+  }
+
+  const bound = getServerReferenceBoundArguments(request.bundlerConfig, serverReference);
+  const serverReferenceMetadata = {
+    id: getServerReferenceId(request.bundlerConfig, serverReference),
+    bound: bound ? Promise.resolve(bound) : null
+  };
+  const metadataId = outlineModel(request, serverReferenceMetadata);
+  writtenServerReferences.set(serverReference, metadataId);
+  return serializeServerReferenceID(metadataId);
+}
+
+function serializeLargeTextString(request, text) {
+  request.pendingChunks += 2;
+  const textId = request.nextChunkId++;
+  const textChunk = stringToChunk(text);
+  const binaryLength = byteLengthOfChunk(textChunk);
+  const row = textId.toString(16) + ':T' + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, textChunk);
+  return serializeByValueID(textId);
+}
+
+function serializeMap(request, map) {
+  const entries = Array.from(map);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i][0];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$Q' + id.toString(16);
+}
+
+function serializeSet(request, set) {
+  const entries = Array.from(set);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$W' + id.toString(16);
+}
+
+function serializeTypedArray(request, tag, typedArray) {
+  {
+    if (TaintRegistryByteLengths.has(typedArray.byteLength)) {
+      // If we have had any tainted values of this length, we check
+      // to see if these bytes matches any entries in the registry.
+      const tainted = TaintRegistryValues.get(binaryToComparableString(typedArray));
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    }
+  }
+
+  request.pendingChunks += 2;
+  const bufferId = request.nextChunkId++; // TODO: Convert to little endian if that's not the server default.
+
+  const binaryChunk = typedArrayToBinaryChunk(typedArray);
+  const binaryLength = byteLengthOfBinaryChunk(binaryChunk);
+  const row = bufferId.toString(16) + ':' + tag + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, binaryChunk);
+  return serializeByValueID(bufferId);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+let modelRoot = false;
+
+function resolveModelToJSON(request, parent, key, value) {
+
+
+  switch (value) {
+    case REACT_ELEMENT_TYPE:
+      return '$';
+  }
+
+
+  while (typeof value === 'object' && value !== null && (value.$$typeof === REACT_ELEMENT_TYPE || value.$$typeof === REACT_LAZY_TYPE)) {
+
+    try {
+      switch (value.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const writtenObjects = request.writtenObjects;
+            const existingId = writtenObjects.get(value);
+
+            if (existingId !== undefined) {
+              if (existingId === -1) {
+                // Seen but not yet outlined.
+                const newId = outlineModel(request, value);
+                return serializeByValueID(newId);
+              } else if (modelRoot === value) {
+                // This is the ID we're currently emitting so we need to write it
+                // once but if we discover it again, we refer to it by id.
+                modelRoot = null;
+              } else {
+                // We've already emitted this as an outlined object, so we can
+                // just refer to that by its existing ID.
+                return serializeByValueID(existingId);
+              }
+            } else {
+              // This is the first time we've seen this object. We may never see it again
+              // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+              writtenObjects.set(value, -1);
+            } // TODO: Concatenate keys of parents onto children.
+
+
+            const element = value; // Attempt to render the Server Component.
+
+            value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, null);
+            break;
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = value._payload;
+            const init = value._init;
+            value = init(payload);
+            break;
+          }
+      }
+    } catch (thrownValue) {
+      const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          // Something suspended, we'll need to create a new task and resolve it later.
+          request.pendingChunks++;
+          const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+          const ping = newTask.ping;
+          x.then(ping, ping);
+          newTask.thenableState = getThenableStateAfterSuspending();
+          return serializeLazyID(newTask.id);
+        } else if (x.$$typeof === REACT_POSTPONE_TYPE) {
+          // Something postponed. We'll still send everything we have up until this point.
+          // We'll replace this element with a lazy reference that postpones on the client.
+          const postponeInstance = x;
+          request.pendingChunks++;
+          const postponeId = request.nextChunkId++;
+          logPostpone(request, postponeInstance.message);
+          emitPostponeChunk(request, postponeId);
+          return serializeLazyID(postponeId);
+        }
+      } // Something errored. We'll still send everything we have up until this point.
+      // We'll replace this element with a lazy reference that throws on the client
+      // once it gets rendered.
+
+
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+      const digest = logRecoverableError(request, x);
+      emitErrorChunk(request, errorId, digest);
+      return serializeLazyID(errorId);
+    }
+  }
+
+  if (value === null) {
+    return null;
+  }
+
+  if (typeof value === 'object') {
+    {
+      const tainted = TaintRegistryObjects.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted);
+      }
+    }
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    const writtenObjects = request.writtenObjects;
+    const existingId = writtenObjects.get(value); // $FlowFixMe[method-unbinding]
+
+    if (typeof value.then === 'function') {
+      if (existingId !== undefined) {
+        if (modelRoot === value) {
+          // This is the ID we're currently emitting so we need to write it
+          // once but if we discover it again, we refer to it by id.
+          modelRoot = null;
+        } else {
+          // We've seen this promise before, so we can just refer to the same result.
+          return serializePromiseID(existingId);
+        }
+      } // We assume that any object with a .then property is a "Thenable" type,
+      // or a Promise type. Either of which can be represented by a Promise.
+
+
+      const promiseId = serializeThenable(request, value);
+      writtenObjects.set(value, promiseId);
+      return serializePromiseID(promiseId);
+    }
+
+    {
+      if (value.$$typeof === REACT_PROVIDER_TYPE) {
+        const providerKey = value._context._globalName;
+        const writtenProviders = request.writtenProviders;
+        let providerId = writtenProviders.get(key);
+
+        if (providerId === undefined) {
+          request.pendingChunks++;
+          providerId = request.nextChunkId++;
+          writtenProviders.set(providerKey, providerId);
+          emitProviderChunk(request, providerId, providerKey);
+        }
+
+        return serializeByValueID(providerId);
+      } else if (value === POP) {
+        popProvider();
+
+        return undefined;
+      }
+    }
+
+    if (existingId !== undefined) {
+      if (existingId === -1) {
+        // Seen but not yet outlined.
+        const newId = outlineModel(request, value);
+        return serializeByValueID(newId);
+      } else if (modelRoot === value) {
+        // This is the ID we're currently emitting so we need to write it
+        // once but if we discover it again, we refer to it by id.
+        modelRoot = null;
+      } else {
+        // We've already emitted this as an outlined object, so we can
+        // just refer to that by its existing ID.
+        return serializeByValueID(existingId);
+      }
+    } else {
+      // This is the first time we've seen this object. We may never see it again
+      // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+      writtenObjects.set(value, -1);
+    }
+
+    if (isArray(value)) {
+      // $FlowFixMe[incompatible-return]
+      return value;
+    }
+
+    if (value instanceof Map) {
+      return serializeMap(request, value);
+    }
+
+    if (value instanceof Set) {
+      return serializeSet(request, value);
+    }
+
+    {
+      if (value instanceof ArrayBuffer) {
+        return serializeTypedArray(request, 'A', new Uint8Array(value));
+      }
+
+      if (value instanceof Int8Array) {
+        // char
+        return serializeTypedArray(request, 'C', value);
+      }
+
+      if (value instanceof Uint8Array) {
+        // unsigned char
+        return serializeTypedArray(request, 'c', value);
+      }
+
+      if (value instanceof Uint8ClampedArray) {
+        // unsigned clamped char
+        return serializeTypedArray(request, 'U', value);
+      }
+
+      if (value instanceof Int16Array) {
+        // sort
+        return serializeTypedArray(request, 'S', value);
+      }
+
+      if (value instanceof Uint16Array) {
+        // unsigned short
+        return serializeTypedArray(request, 's', value);
+      }
+
+      if (value instanceof Int32Array) {
+        // long
+        return serializeTypedArray(request, 'L', value);
+      }
+
+      if (value instanceof Uint32Array) {
+        // unsigned long
+        return serializeTypedArray(request, 'l', value);
+      }
+
+      if (value instanceof Float32Array) {
+        // float
+        return serializeTypedArray(request, 'F', value);
+      }
+
+      if (value instanceof Float64Array) {
+        // double
+        return serializeTypedArray(request, 'D', value);
+      }
+
+      if (value instanceof BigInt64Array) {
+        // number
+        return serializeTypedArray(request, 'N', value);
+      }
+
+      if (value instanceof BigUint64Array) {
+        // unsigned number
+        // We use "m" instead of "n" since JSON can start with "null"
+        return serializeTypedArray(request, 'm', value);
+      }
+
+      if (value instanceof DataView) {
+        return serializeTypedArray(request, 'V', value);
+      }
+    }
+
+    const iteratorFn = getIteratorFn(value);
+
+    if (iteratorFn) {
+      return Array.from(value);
+    } // Verify that this is a simple plain object.
+
+
+    const proto = getPrototypeOf(value);
+
+    if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+      throw new Error('Only plain objects, and a few built-ins, can be passed to Client Components ' + 'from Server Components. Classes or null prototypes are not supported.');
+    }
+
+
+    return value;
+  }
+
+  if (typeof value === 'string') {
+    {
+      const tainted = TaintRegistryValues.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    } // TODO: Maybe too clever. If we support URL there's no similar trick.
+
+
+    if (value[value.length - 1] === 'Z') {
+      // Possibly a Date, whose toJSON automatically calls toISOString
+      // $FlowFixMe[incompatible-use]
+      const originalValue = parent[key];
+
+      if (originalValue instanceof Date) {
+        return serializeDateFromDateJSON(value);
+      }
+    }
+
+    if (value.length >= 1024) {
+      // For large strings, we encode them outside the JSON payload so that we
+      // don't have to double encode and double parse the strings. This can also
+      // be more compact in case the string has a lot of escaped characters.
+      return serializeLargeTextString(request, value);
+    }
+
+    return escapeStringValue(value);
+  }
+
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  if (typeof value === 'number') {
+    return serializeNumber(value);
+  }
+
+  if (typeof value === 'undefined') {
+    return serializeUndefined();
+  }
+
+  if (typeof value === 'function') {
+    {
+      const tainted = TaintRegistryObjects.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted);
+      }
+    }
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    if (isServerReference(value)) {
+      return serializeServerReference(request, parent, key, value);
+    }
+
+    if (/^on[A-Z]/.test(key)) {
+      throw new Error('Event handlers cannot be passed to Client Component props.' + describeObjectForErrorMessage(parent, key) + '\nIf you need interactivity, consider converting part of this to a Client Component.');
+    } else {
+      throw new Error('Functions cannot be passed directly to Client Components ' + 'unless you explicitly expose it by marking it with "use server".' + describeObjectForErrorMessage(parent, key));
+    }
+  }
+
+  if (typeof value === 'symbol') {
+    const writtenSymbols = request.writtenSymbols;
+    const existingId = writtenSymbols.get(value);
+
+    if (existingId !== undefined) {
+      return serializeByValueID(existingId);
+    } // $FlowFixMe[incompatible-type] `description` might be undefined
+
+
+    const name = value.description;
+
+    if (Symbol.for(name) !== value) {
+      throw new Error('Only global symbols received from Symbol.for(...) can be passed to Client Components. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+      value.description + ") cannot be found among global symbols.") + describeObjectForErrorMessage(parent, key));
+    }
+
+    request.pendingChunks++;
+    const symbolId = request.nextChunkId++;
+    emitSymbolChunk(request, symbolId, name);
+    writtenSymbols.set(value, symbolId);
+    return serializeByValueID(symbolId);
+  }
+
+  if (typeof value === 'bigint') {
+    {
+      const tainted = TaintRegistryValues.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    }
+
+    return serializeBigInt(value);
+  }
+
+  throw new Error("Type " + typeof value + " is not supported in Client Component props." + describeObjectForErrorMessage(parent, key));
+}
+
+function logPostpone(request, reason) {
+  const onPostpone = request.onPostpone;
+  onPostpone(reason);
+}
+
+function logRecoverableError(request, error) {
+  const onError = request.onError;
+  const errorDigest = onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest || '';
+}
+
+function fatalError(request, error) {
+  {
+    cleanupTaintQueue(request);
+  } // This is called outside error handling code such as if an error happens in React internals.
+
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function emitPostponeChunk(request, id, postponeInstance) {
+  let row;
+
+  {
+    // No reason included in prod.
+    row = serializeRowHeader('P', id) + '\n';
+  }
+
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitErrorChunk(request, id, digest, error) {
+  let errorInfo;
+
+  {
+    errorInfo = {
+      digest
+    };
+  }
+
+  const row = serializeRowHeader('E', id) + stringify(errorInfo) + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitImportChunk(request, id, clientReferenceMetadata) {
+  // $FlowFixMe[incompatible-type] stringify can return null
+  const json = stringify(clientReferenceMetadata);
+  const row = serializeRowHeader('I', id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitHintChunk(request, code, model) {
+  const json = stringify(model);
+  const id = request.nextChunkId++;
+  const row = serializeRowHeader('H' + code, id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedHintChunks.push(processedChunk);
+}
+
+function emitSymbolChunk(request, id, name) {
+  const symbolReference = serializeSymbolReference(name);
+  const processedChunk = encodeReferenceChunk(request, id, symbolReference);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitProviderChunk(request, id, contextName) {
+  const contextReference = serializeProviderReference(contextName);
+  const processedChunk = encodeReferenceChunk(request, id, contextReference);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function emitModelChunk(request, id, model) {
+  // Track the root so we know that we have to emit this object even though it
+  // already has an ID. This is needed because we might see this object twice
+  // in the same toJSON if it is cyclic.
+  modelRoot = model; // $FlowFixMe[incompatible-type] stringify can return null
+
+  const json = stringify(model, request.toJSON);
+  const row = id.toString(16) + ':' + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function retryTask(request, task) {
+  if (task.status !== PENDING$1) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  }
+
+  switchContext(task.context);
+
+  try {
+    let value = task.model;
+
+    if (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+      request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+      const element = value; // When retrying a component, reuse the thenableState from the
+      // previous attempt.
+
+      const prevThenableState = task.thenableState; // Attempt to render the Server Component.
+      // Doing this here lets us reuse this same task if the next component
+      // also suspends.
+
+      task.model = value;
+      value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, prevThenableState); // Successfully finished this component. We're going to keep rendering
+      // using the same task, but we reset its thenable state before continuing.
+
+      task.thenableState = null; // Keep rendering and reuse the same task. This inner loop is separate
+      // from the render above because we don't need to reset the thenable state
+      // until the next time something suspends and retries.
+
+      while (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+        request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+        const nextElement = value;
+        task.model = value;
+        value = attemptResolveElement(request, nextElement.type, nextElement.key, nextElement.ref, nextElement.props, null);
+      }
+    } // Track that this object is outlined and has an id.
+
+
+    if (typeof value === 'object' && value !== null) {
+      request.writtenObjects.set(value, task.id);
+    }
+
+    emitModelChunk(request, task.id, value);
+    request.abortableTasks.delete(task);
+    task.status = COMPLETED;
+  } catch (thrownValue) {
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      } else if (x.$$typeof === REACT_POSTPONE_TYPE) {
+        request.abortableTasks.delete(task);
+        task.status = ERRORED$1;
+        const postponeInstance = x;
+        logPostpone(request, postponeInstance.message);
+        emitPostponeChunk(request, task.id);
+        return;
+      }
+    }
+
+    request.abortableTasks.delete(task);
+    task.status = ERRORED$1;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, task.id, digest);
+  }
+}
+
+function performWork(request) {
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  const prevRequest = currentRequest;
+  currentRequest = request;
+  prepareToUseHooksForRequest(request);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    request.pingedTasks = [];
+
+    for (let i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    ReactCurrentDispatcher.current = prevDispatcher;
+    resetHooksForRequest();
+    currentRequest = prevRequest;
+  }
+}
+
+function abortTask(task, request, errorId) {
+  task.status = ABORTED; // Instead of emitting an error per task.id, we emit a model that only
+  // has a single value referencing the error.
+
+  const ref = serializeByValueID(errorId);
+  const processedChunk = encodeReferenceChunk(request, task.id, ref);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function flushCompletedChunks(request, destination) {
+  beginWriting();
+
+  try {
+    // We emit module chunks first in the stream so that
+    // they can be preloaded as early as possible.
+    const importsChunks = request.completedImportChunks;
+    let i = 0;
+
+    for (; i < importsChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = importsChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    importsChunks.splice(0, i); // Next comes hints.
+
+    const hintChunks = request.completedHintChunks;
+    i = 0;
+
+    for (; i < hintChunks.length; i++) {
+      const chunk = hintChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    hintChunks.splice(0, i); // Next comes model data.
+
+    const regularChunks = request.completedRegularChunks;
+    i = 0;
+
+    for (; i < regularChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = regularChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    regularChunks.splice(0, i); // Finally, errors are sent. The idea is that it's ok to delay
+    // any error messages and prioritize display of other parts of
+    // the page.
+
+    const errorChunks = request.completedErrorChunks;
+    i = 0;
+
+    for (; i < errorChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = errorChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    errorChunks.splice(0, i);
+  } finally {
+    request.flushScheduled = false;
+    completeWriting(destination);
+  }
+
+  if (request.pendingChunks === 0) {
+    // We're done.
+    {
+      cleanupTaintQueue(request);
+    }
+
+    close$1(destination);
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  {
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    const destination = request.destination;
+    request.flushScheduled = true;
+    scheduleWork(() => flushCompletedChunks(request, destination));
+  }
+}
+
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedChunks(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      // We have tasks to abort. We'll emit one error row and then emit a reference
+      // to that row from every row that's still remaining.
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+
+      if (enablePostpone && typeof reason === 'object' && reason !== null && reason.$$typeof === REACT_POSTPONE_TYPE) {
+        const postponeInstance = reason;
+        logPostpone(request, postponeInstance.message);
+        emitPostponeChunk(request, errorId, postponeInstance);
+      } else {
+        const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+        const digest = logRecoverableError(request, error);
+        emitErrorChunk(request, errorId, digest, error);
+      }
+
+      abortableTasks.forEach(task => abortTask(task, request, errorId));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function importServerContexts(contexts) {
+  if (contexts) {
+    const prevContext = getActiveContext();
+    switchContext(rootContextSnapshot);
+
+    for (let i = 0; i < contexts.length; i++) {
+      const _contexts$i = contexts[i],
+            name = _contexts$i[0],
+            value = _contexts$i[1];
+      const context = getOrCreateServerContext(name);
+      pushProvider(context, value);
+    }
+
+    const importedContext = getActiveContext();
+    switchContext(prevContext);
+    return importedContext;
+  }
+
+  return rootContextSnapshot;
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+function resolveServerReference(bundlerConfig, id) {
+  let name = '';
+  let resolvedModuleData = bundlerConfig[id];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = id.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = id.slice(idx + 1);
+      resolvedModuleData = bundlerConfig[id.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + id + '" in the React Server Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  } // TODO: This needs to return async: true if it's an async module.
+
+
+  return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+} // The chunk cache contains all the chunks we've preloaded so far.
+// If they're still pending they're a thenable. This map also exists
+// in Turbopack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = __turbopack_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+
+  for (let i = 0; i < chunks.length; i++) {
+    const chunkFilename = chunks[i];
+    const entry = chunkCache.get(chunkFilename);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkFilename);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkFilename, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkFilename, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = __turbopack_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+function loadChunk(filename) {
+  return __turbopack_load__(filename);
+}
+
+// The server acts as a Client of itself when resolving Server References.
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const RESOLVED_MODEL = 'resolved_model';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function bindArgs$1(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference$1(response, id, bound, parentChunk, parentObject, key) {
+  const serverReference = resolveServerReference(response._bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+  let promise;
+
+  if (bound) {
+    promise = Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs$1(requireModule(serverReference), args);
+    });
+  } else {
+    if (preloadPromise) {
+      promise = Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+    } else {
+      // Synchronously available
+      return requireModule(serverReference);
+    }
+  }
+
+  promise.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk)); // We need a placeholder value that will be replaced later.
+
+  return null;
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+
+  try {
+    const value = JSON.parse(chunk.value, chunk._response._fromJSON);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    const prefix = response._prefix;
+    const key = prefix + id; // Check if we have this field in the backing store already.
+
+    const backingEntry = response._formData.get(key);
+
+    if (backingEntry != null) {
+      // We assume that this is a string entry for now.
+      chunk = createResolvedModelChunk(response, backingEntry);
+    } else {
+      // We're still waiting on this entry to stream in.
+      chunk = createPendingChunk(response);
+    }
+
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+    blocked.deps++;
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  if (chunk.status === RESOLVED_MODEL) {
+    initializeModelChunk(chunk);
+  }
+
+  if (chunk.status !== INITIALIZED) {
+    // We know that this is emitted earlier so otherwise it's an error.
+    throw chunk.reason;
+  }
+
+  return chunk.value;
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16); // TODO: Just encode this in the reference inline instead of as a model.
+
+          const metaData = getOutlinedModel(response, id);
+          return loadServerReference$1(response, metaData.id, metaData.bound, initializingChunk, parentObject, key);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'K':
+        {
+          // FormData
+          const stringId = value.slice(2);
+          const formPrefix = response._prefix + stringId + '_';
+          const data = new FormData();
+          const backingFormData = response._formData; // We assume that the reference to FormData always comes after each
+          // entry that it references so we can assume they all exist in the
+          // backing store already.
+          // $FlowFixMe[prop-missing] FormData has forEach on it.
+
+          backingFormData.forEach((entry, entryKey) => {
+            if (entryKey.startsWith(formPrefix)) {
+              data.append(entryKey.slice(formPrefix.length), entry);
+            }
+          });
+          return data;
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function createResponse(bundlerConfig, formFieldPrefix) {
+  let backingFormData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new FormData();
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _prefix: formFieldPrefix,
+    _formData: backingFormData,
+    _chunks: chunks,
+    _fromJSON: function (key, value) {
+      if (typeof value === 'string') {
+        // We can't use .bind here because we need the "this" value.
+        return parseModelString(response, this, key, value);
+      }
+
+      return value;
+    }
+  };
+  return response;
+}
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function bindArgs(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference(bundlerConfig, id, bound) {
+  const serverReference = resolveServerReference(bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+
+  if (bound) {
+    return Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs(requireModule(serverReference), args);
+    });
+  } else if (preloadPromise) {
+    return Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+  } else {
+    // Synchronously available
+    return Promise.resolve(requireModule(serverReference));
+  }
+}
+
+function decodeBoundActionMetaData(body, serverManifest, formFieldPrefix) {
+  // The data for this reference is encoded in multiple fields under this prefix.
+  const actionResponse = createResponse(serverManifest, formFieldPrefix, body);
+  close(actionResponse);
+  const refPromise = getRoot(actionResponse); // Force it to initialize
+  // $FlowFixMe
+
+  refPromise.then(() => {});
+
+  if (refPromise.status !== 'fulfilled') {
+    // $FlowFixMe
+    throw refPromise.reason;
+  }
+
+  return refPromise.value;
+}
+
+function decodeAction(body, serverManifest) {
+  // We're going to create a new formData object that holds all the fields except
+  // the implementation details of the action data.
+  const formData = new FormData();
+  let action = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (!key.startsWith('$ACTION_')) {
+      formData.append(key, value);
+      return;
+    } // Later actions may override earlier actions if a button is used to override the default
+    // form action.
+
+
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      const metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+      action = loadServerReference(serverManifest, metaData.id, metaData.bound);
+      return;
+    }
+
+    if (key.startsWith('$ACTION_ID_')) {
+      const id = key.slice(11);
+      action = loadServerReference(serverManifest, id, null);
+      return;
+    }
+  });
+
+  if (action === null) {
+    return null;
+  } // Return the action with the remaining FormData bound to the first argument.
+
+
+  return action.then(fn => fn.bind(null, formData));
+}
+
+function renderToReadableStream(model, turbopackMap, options) {
+  const request = createRequest(model, turbopackMap, options ? options.onError : undefined, options ? options.context : undefined, options ? options.identifierPrefix : undefined, options ? options.onPostpone : undefined);
+
+  if (options && options.signal) {
+    const signal = options.signal;
+
+    if (signal.aborted) {
+      abort(request, signal.reason);
+    } else {
+      const listener = () => {
+        abort(request, signal.reason);
+        signal.removeEventListener('abort', listener);
+      };
+
+      signal.addEventListener('abort', listener);
+    }
+  }
+
+  const stream = new ReadableStream({
+    type: 'bytes',
+    start: controller => {
+      startWork(request);
+    },
+    pull: controller => {
+      startFlowing(request, controller);
+    },
+    cancel: reason => {}
+  }, // $FlowFixMe[prop-missing] size() methods are not allowed on byte streams.
+  {
+    highWaterMark: 0
+  });
+  return stream;
+}
+
+function decodeReply(body, turbopackMap) {
+  if (typeof body === 'string') {
+    const form = new FormData();
+    form.append('0', body);
+    body = form;
+  }
+
+  const response = createResponse(turbopackMap, '', body);
+  const root = getRoot(response);
+  close(response);
+  return root;
+}
+
+exports.createClientModuleProxy = createClientModuleProxy;
+exports.decodeAction = decodeAction;
+exports.decodeReply = decodeReply;
+exports.registerClientReference = registerClientReference;
+exports.registerServerReference = registerServerReference;
+exports.renderToReadableStream = renderToReadableStream;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.browser.production.min.js b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.browser.production.min.js
index 7e55a5a5e6e99..6fdebedc0f804 100644
--- a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.browser.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.browser.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-turbopack-server.browser.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-turbopack-server.browser.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var aa=require("react-dom"),ba=require("react"),l=null,n=0;function p(a,b){if(0!==b.byteLength)if(512<b.byteLength)0<n&&(a.enqueue(new Uint8Array(l.buffer,0,n)),l=new Uint8Array(512),n=0),a.enqueue(b);else{var d=l.length-n;d<b.byteLength&&(0===d?a.enqueue(l):(l.set(b.subarray(0,d),n),a.enqueue(l),b=b.subarray(d)),l=new Uint8Array(512),n=0);l.set(b,n);n+=b.byteLength}return!0}var q=new TextEncoder;function ca(a,b){"function"===typeof a.error?a.error(b):a.close()}
 var r=Symbol.for("react.client.reference"),t=Symbol.for("react.server.reference");function u(a,b,d){return Object.defineProperties(a,{$$typeof:{value:r},$$id:{value:b},$$async:{value:d}})}var da=Function.prototype.bind,ea=Array.prototype.slice;function fa(){var a=da.apply(this,arguments);if(this.$$typeof===t){var b=ea.call(arguments,1);a.$$typeof=t;a.$$id=this.$$id;a.$$bound=this.$$bound?this.$$bound.concat(b):b}return a}
 var ha=Promise.prototype,ia={get:function(a,b){switch(b){case "$$typeof":return a.$$typeof;case "$$id":return a.$$id;case "$$async":return a.$$async;case "name":return a.name;case "displayName":return;case "defaultProps":return;case "toJSON":return;case Symbol.toPrimitive:return Object.prototype[Symbol.toPrimitive];case "Provider":throw Error("Cannot render a Client Context Provider on the Server. Instead, you can export a Client Component wrapper that itself renders a Client Context Provider.");
@@ -78,3 +78,5 @@ exports.decodeAction=function(a,b){var d=new FormData,c=null;a.forEach(function(
 exports.registerClientReference=function(a,b,d){return u(a,b+"#"+d,!1)};exports.registerServerReference=function(a,b,d){return Object.defineProperties(a,{$$typeof:{value:t},$$id:{value:null===d?b:b+"#"+d},$$bound:{value:null},bind:{value:fa}})};
 exports.renderToReadableStream=function(a,b,d){var c=nb(a,b,d?d.onError:void 0,d?d.context:void 0,d?d.identifierPrefix:void 0,d?d.onPostpone:void 0);if(d&&d.signal){var e=d.signal;if(e.aborted)Db(c,e.reason);else{var f=function(){Db(c,e.reason);e.removeEventListener("abort",f)};e.addEventListener("abort",f)}}return new ReadableStream({type:"bytes",start:function(){c.flushScheduled=null!==c.destination;yb(c)},pull:function(g){if(1===c.status)c.status=2,ca(g,c.fatalError);else if(2!==c.status&&null===
 c.destination){c.destination=g;try{Q(c,g)}catch(k){O(c,k),Cb(c,k)}}},cancel:function(){}},{highWaterMark:0})};
+
+//# sourceMappingURL=react-server-dom-turbopack-server.browser.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.edge.production.js b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.edge.production.js
new file mode 100644
index 0000000000000..2d4195e6dc881
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.edge.production.js
@@ -0,0 +1,3397 @@
+/**
+ * @license React
+ * react-server-dom-turbopack-server.edge.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require('react');
+var ReactDOM = require('react-dom');
+
+// -----------------------------------------------------------------------------
+const enablePostpone = true;
+
+function scheduleWork(callback) {
+  setTimeout(callback, 0);
+}
+const VIEW_SIZE = 512;
+let currentView = null;
+let writtenBytes = 0;
+function beginWriting(destination) {
+  currentView = new Uint8Array(VIEW_SIZE);
+  writtenBytes = 0;
+}
+function writeChunk(destination, chunk) {
+  if (chunk.byteLength === 0) {
+    return;
+  }
+
+  if (chunk.byteLength > VIEW_SIZE) {
+    // one that is cached by the streaming renderer. We will enqueu
+    // it directly and expect it is not re-used
+
+
+    if (writtenBytes > 0) {
+      destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    destination.enqueue(chunk);
+    return;
+  }
+
+  let bytesToWrite = chunk;
+  const allowableBytes = currentView.length - writtenBytes;
+
+  if (allowableBytes < bytesToWrite.byteLength) {
+    // this chunk would overflow the current view. We enqueue a full view
+    // and start a new view with the remaining chunk
+    if (allowableBytes === 0) {
+      // the current view is already full, send it
+      destination.enqueue(currentView);
+    } else {
+      // fill up the current view and apply the remaining chunk bytes
+      // to a new view.
+      currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes); // writtenBytes += allowableBytes; // this can be skipped because we are going to immediately reset the view
+
+      destination.enqueue(currentView);
+      bytesToWrite = bytesToWrite.subarray(allowableBytes);
+    }
+
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+
+  currentView.set(bytesToWrite, writtenBytes);
+  writtenBytes += bytesToWrite.byteLength;
+}
+function writeChunkAndReturn(destination, chunk) {
+  writeChunk(destination, chunk); // in web streams there is no backpressure so we can alwas write more
+
+  return true;
+}
+function completeWriting(destination) {
+  if (currentView && writtenBytes > 0) {
+    destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+    currentView = null;
+    writtenBytes = 0;
+  }
+}
+function close$1(destination) {
+  destination.close();
+}
+const textEncoder = new TextEncoder();
+function stringToChunk(content) {
+  return textEncoder.encode(content);
+}
+function typedArrayToBinaryChunk(content) {
+  // Convert any non-Uint8Array array to Uint8Array. We could avoid this for Uint8Arrays.
+  // If we passed through this straight to enqueue we wouldn't have to convert it but since
+  // we need to copy the buffer in that case, we need to convert it to copy it.
+  // When we copy it into another array using set() it needs to be a Uint8Array.
+  const buffer = new Uint8Array(content.buffer, content.byteOffset, content.byteLength); // We clone large chunks so that we can transfer them when we write them.
+  // Others get copied into the target buffer.
+
+  return content.byteLength > VIEW_SIZE ? buffer.slice() : buffer;
+}
+function byteLengthOfChunk(chunk) {
+  return chunk.byteLength;
+}
+function byteLengthOfBinaryChunk(chunk) {
+  return chunk.byteLength;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[method-unbinding]
+  if (typeof destination.error === 'function') {
+    // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+    destination.error(error);
+  } else {
+    // Earlier implementations doesn't support this method. In that environment you're
+    // supposed to throw from a promise returned but we don't return a promise in our
+    // approach. We could fork this implementation but this is environment is an edge
+    // case to begin with. It's even less common to run this in an older environment.
+    // Even then, this is not where errors are supposed to happen and they get reported
+    // to a global callback in addition to this anyway. So it's fine just to close this.
+    destination.close();
+  }
+}
+
+// eslint-disable-next-line no-unused-vars
+const CLIENT_REFERENCE_TAG = Symbol.for('react.client.reference');
+const SERVER_REFERENCE_TAG = Symbol.for('react.server.reference');
+function isClientReference(reference) {
+  return reference.$$typeof === CLIENT_REFERENCE_TAG;
+}
+function isServerReference(reference) {
+  return reference.$$typeof === SERVER_REFERENCE_TAG;
+}
+function registerClientReference(proxyImplementation, id, exportName) {
+  return registerClientReferenceImpl(proxyImplementation, id + '#' + exportName, false);
+}
+
+function registerClientReferenceImpl(proxyImplementation, id, async) {
+  return Object.defineProperties(proxyImplementation, {
+    $$typeof: {
+      value: CLIENT_REFERENCE_TAG
+    },
+    $$id: {
+      value: id
+    },
+    $$async: {
+      value: async
+    }
+  });
+} // $FlowFixMe[method-unbinding]
+
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+
+  if (this.$$typeof === SERVER_REFERENCE_TAG) {
+    const args = ArraySlice.call(arguments, 1);
+    newFn.$$typeof = SERVER_REFERENCE_TAG;
+    newFn.$$id = this.$$id;
+    newFn.$$bound = this.$$bound ? this.$$bound.concat(args) : args;
+  }
+
+  return newFn;
+}
+
+function registerServerReference(reference, id, exportName) {
+  return Object.defineProperties(reference, {
+    $$typeof: {
+      value: SERVER_REFERENCE_TAG
+    },
+    $$id: {
+      value: exportName === null ? id : id + '#' + exportName
+    },
+    $$bound: {
+      value: null
+    },
+    bind: {
+      value: bind
+    }
+  });
+}
+const PROMISE_PROTOTYPE = Promise.prototype;
+const deepProxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        // These names are a little too common. We should probably have a way to
+        // have the Flight runtime extract the inner target instead.
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+
+      case 'displayName':
+        return undefined;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case 'Provider':
+        throw new Error("Cannot render a Client Context Provider on the Server. " + "Instead, you can export a Client Component wrapper " + "that itself renders a Client Context Provider.");
+    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+    const expression = String(target.name) + '.' + String(name);
+    throw new Error("Cannot access " + expression + " on the server. " + 'You cannot dot into a client module from a server component. ' + 'You can only pass the imported name through.');
+  },
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+const proxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case '__esModule':
+        // Something is conditionally checking which export to use. We'll pretend to be
+        // an ESM compat module but then we'll check again on the client.
+        const moduleId = target.$$id;
+        target.default = registerClientReferenceImpl(function () {
+          throw new Error("Attempted to call the default export of " + moduleId + " from the server " + "but it's on the client. It's not possible to invoke a client function from " + "the server, it can only be rendered as a Component or passed to props of a " + "Client Component.");
+        }, target.$$id + '#', target.$$async);
+        return true;
+
+      case 'then':
+        if (target.then) {
+          // Use a cached value
+          return target.then;
+        }
+
+        if (!target.$$async) {
+          // If this module is expected to return a Promise (such as an AsyncModule) then
+          // we should resolve that with a client reference that unwraps the Promise on
+          // the client.
+          const clientReference = registerClientReferenceImpl({}, target.$$id, true);
+          const proxy = new Proxy(clientReference, proxyHandlers); // Treat this as a resolved Promise for React's use()
+
+          target.status = 'fulfilled';
+          target.value = proxy;
+          const then = target.then = registerClientReferenceImpl(function then(resolve, reject) {
+            // Expose to React.
+            return Promise.resolve(resolve(proxy));
+          }, // If this is not used as a Promise but is treated as a reference to a `.then`
+          // export then we should treat it as a reference to that name.
+          target.$$id + '#then', false);
+          return then;
+        } else {
+          // Since typeof .then === 'function' is a feature test we'd continue recursing
+          // indefinitely if we return a function. Instead, we return an object reference
+          // if we check further.
+          return undefined;
+        }
+
+    }
+
+    let cachedReference = target[name];
+
+    if (!cachedReference) {
+      const reference = registerClientReferenceImpl(function () {
+        throw new Error( // eslint-disable-next-line react-internal/safe-string-coercion
+        "Attempted to call " + String(name) + "() from the server but " + String(name) + " is on the client. " + "It's not possible to invoke a client function from the server, it can " + "only be rendered as a Component or passed to props of a Client Component.");
+      }, target.$$id + '#' + name, target.$$async);
+      Object.defineProperty(reference, 'name', {
+        value: name
+      });
+      cachedReference = target[name] = new Proxy(reference, deepProxyHandlers);
+    }
+
+    return cachedReference;
+  },
+
+  getPrototypeOf(target) {
+    // Pretend to be a Promise in case anyone asks.
+    return PROMISE_PROTOTYPE;
+  },
+
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+function createClientModuleProxy(moduleId) {
+  const clientReference = registerClientReferenceImpl({}, // Represents the whole Module object instead of a particular import.
+  moduleId, false);
+  return new Proxy(clientReference, proxyHandlers);
+}
+
+function getClientReferenceKey(reference) {
+  return reference.$$async ? reference.$$id + '#async' : reference.$$id;
+}
+function resolveClientReferenceMetadata(config, clientReference) {
+  const modulePath = clientReference.$$id;
+  let name = '';
+  let resolvedModuleData = config[modulePath];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = modulePath.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = modulePath.slice(idx + 1);
+      resolvedModuleData = config[modulePath.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + modulePath + '" in the React Client Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  }
+
+  if (clientReference.$$async === true) {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1];
+  } else {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+  }
+}
+function getServerReferenceId(config, serverReference) {
+  return serverReference.$$id;
+}
+function getServerReferenceBoundArguments(config, serverReference) {
+  return serverReference.$$bound;
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMFlightServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule: preloadModule$1,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+
+function prefetchDNS(href) {
+  {
+    if (typeof href === 'string' && href) {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'D|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        emitHint(request, 'D', href);
+      }
+    }
+  }
+}
+
+function preconnect(href, crossOrigin) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = "C|" + (crossOrigin == null ? 'null' : crossOrigin) + "|" + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+
+        if (typeof crossOrigin === 'string') {
+          emitHint(request, 'C', [href, crossOrigin]);
+        } else {
+          emitHint(request, 'C', href);
+        }
+      }
+    }
+  }
+}
+
+function preload(href, as, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        let key = 'L';
+
+        if (as === 'image' && options) {
+          key += getImagePreloadKey(href, options.imageSrcSet, options.imageSizes);
+        } else {
+          key += "[" + as + "]" + href;
+        }
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          emitHint(request, 'L', [href, as, trimmed]);
+        } else {
+          emitHint(request, 'L', [href, as]);
+        }
+      }
+    }
+  }
+}
+
+function preloadModule$1(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'm|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'm', [href, trimmed]);
+        } else {
+          return emitHint(request, 'm', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'S|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'S', [href, typeof precedence === 'string' ? precedence : 0, trimmed]);
+        } else if (typeof precedence === 'string') {
+          return emitHint(request, 'S', [href, precedence]);
+        } else {
+          return emitHint(request, 'S', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'X|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'X', [href, trimmed]);
+        } else {
+          return emitHint(request, 'X', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitModuleScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'M|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'M', [href, trimmed]);
+        } else {
+          return emitHint(request, 'M', href);
+        }
+      }
+    }
+  }
+} // Flight normally encodes undefined as a special character however for directive option
+// arguments we don't want to send unnecessary keys and bloat the payload so we create a
+// trimmed object which omits any keys with null or undefined values.
+// This is only typesafe because these option objects have entirely optional fields where
+// null and undefined represent the same thing as no property.
+
+
+function trimOptions(options) {
+  if (options == null) return null;
+  let hasProperties = false;
+  const trimmed = {};
+
+  for (const key in options) {
+    if (options[key] != null) {
+      hasProperties = true;
+      trimmed[key] = options[key];
+    }
+  }
+
+  return hasProperties ? trimmed : null;
+}
+
+function getImagePreloadKey(href, imageSrcSet, imageSizes) {
+  let uniquePart = '';
+
+  if (typeof imageSrcSet === 'string' && imageSrcSet !== '') {
+    uniquePart += '[' + imageSrcSet + ']';
+
+    if (typeof imageSizes === 'string') {
+      uniquePart += '[' + imageSizes + ']';
+    }
+  } else {
+    uniquePart += '[][]' + href;
+  }
+
+  return "[image]" + uniquePart;
+}
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMFlightServerDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+// small, smaller than how we encode undefined, and is unambiguous. We could use
+// a different tuple structure to encode this instead but this makes the runtime
+// cost cheaper by eliminating a type checks in more positions.
+// prettier-ignore
+
+function createHints() {
+  return new Set();
+}
+
+const supportsRequestStorage = typeof AsyncLocalStorage === 'function';
+const requestStorage = supportsRequestStorage ? new AsyncLocalStorage() : null;
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext); // On the way back, we push the new ones that weren't common.
+
+      pushNode(next);
+    }
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function pushProvider(context, nextValue) {
+  let prevValue;
+
+  {
+    prevValue = context._currentValue;
+    context._currentValue = nextValue;
+  }
+
+  const prevNode = currentActiveSnapshot;
+  const newNode = {
+    parent: prevNode,
+    depth: prevNode === null ? 0 : prevNode.depth + 1,
+    context: context,
+    parentValue: prevValue,
+    value: nextValue
+  };
+  currentActiveSnapshot = newNode;
+  return newNode;
+}
+function popProvider() {
+  const prevSnapshot = currentActiveSnapshot;
+
+  if (prevSnapshot === null) {
+    throw new Error('Tried to pop a Context at the root of the app. This is a bug in React.');
+  }
+
+  {
+    const value = prevSnapshot.parentValue;
+
+    if (value === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      prevSnapshot.context._currentValue = prevSnapshot.context._defaultValue;
+    } else {
+      prevSnapshot.context._currentValue = value;
+    }
+  }
+
+  return currentActiveSnapshot = prevSnapshot.parent;
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFizzWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop, noop);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+let currentRequest$1 = null;
+let thenableIndexCounter = 0;
+let thenableState = null;
+function prepareToUseHooksForRequest(request) {
+  currentRequest$1 = request;
+}
+function resetHooksForRequest() {
+  currentRequest$1 = null;
+}
+function prepareToUseHooksForComponent(prevThenableState) {
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+const HooksDispatcher = {
+  useMemo(nextCreate) {
+    return nextCreate();
+  },
+
+  useCallback(callback) {
+    return callback;
+  },
+
+  useDebugValue() {},
+
+  useDeferredValue: unsupportedHook,
+  useTransition: unsupportedHook,
+  readContext,
+  useContext: readContext,
+  useReducer: unsupportedHook,
+  useRef: unsupportedHook,
+  useState: unsupportedHook,
+  useInsertionEffect: unsupportedHook,
+  useLayoutEffect: unsupportedHook,
+  useImperativeHandle: unsupportedHook,
+  useEffect: unsupportedHook,
+  useId,
+  useSyncExternalStore: unsupportedHook,
+
+  useCacheRefresh() {
+    return unsupportedRefresh;
+  },
+
+  useMemoCache(size) {
+    const data = new Array(size);
+
+    for (let i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL;
+    }
+
+    return data;
+  },
+
+  use
+};
+
+function unsupportedHook() {
+  throw new Error('This Hook is not supported in Server Components.');
+}
+
+function unsupportedRefresh() {
+  throw new Error('Refreshing the cache is not supported in Server Components.');
+}
+
+function useId() {
+  if (currentRequest$1 === null) {
+    throw new Error('useId can only be used while React is rendering');
+  }
+
+  const id = currentRequest$1.identifierCount++; // use 'S' for Flight components to distinguish from 'R' and 'r' in Fizz/Client
+
+  return ':' + currentRequest$1.identifierPrefix + 'S' + id.toString(32) + ':';
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object' || typeof usable === 'function') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable; // Track the position of the thenable within this fiber.
+
+      const index = thenableIndexCounter;
+      thenableIndexCounter += 1;
+
+      if (thenableState === null) {
+        thenableState = createThenableState();
+      }
+
+      return trackUsedThenable(thenableState, thenable, index);
+    } else if (usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  }
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function createSignal() {
+  return new AbortController().signal;
+}
+
+function resolveCache() {
+  const request = resolveRequest();
+
+  if (request) {
+    return getCache(request);
+  }
+
+  return new Map();
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal() {
+    const cache = resolveCache();
+    let entry = cache.get(createSignal);
+
+    if (entry === undefined) {
+      entry = createSignal();
+      cache.set(createSignal, entry);
+    }
+
+    return entry;
+  },
+
+  getCacheForType(resourceType) {
+    const cache = resolveCache();
+    let entry = cache.get(resourceType);
+
+    if (entry === undefined) {
+      entry = resourceType(); // TODO: Warn if undefined?
+
+      cache.set(resourceType, entry);
+    }
+
+    return entry;
+  }
+
+};
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+function objectName(object) {
+  // $FlowFixMe[method-unbinding]
+  const name = Object.prototype.toString.call(object);
+  return name.replace(/^\[object (.*)\]$/, function (m, p0) {
+    return p0;
+  });
+}
+
+function describeKeyForErrorMessage(key) {
+  const encodedKey = JSON.stringify(key);
+  return '"' + key + '"' === encodedKey ? key : encodedKey;
+}
+
+function describeValueForErrorMessage(value) {
+  switch (typeof value) {
+    case 'string':
+      {
+        return JSON.stringify(value.length <= 10 ? value : value.slice(0, 10) + '...');
+      }
+
+    case 'object':
+      {
+        if (isArray(value)) {
+          return '[...]';
+        }
+
+        const name = objectName(value);
+
+        if (name === 'Object') {
+          return '{...}';
+        }
+
+        return name;
+      }
+
+    case 'function':
+      return 'function';
+
+    default:
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      return String(value);
+  }
+}
+
+function describeElementType(type) {
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        return describeElementType(type.render);
+
+      case REACT_MEMO_TYPE:
+        return describeElementType(type.type);
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            // Lazy may contain any component type so we recursively resolve it.
+            return describeElementType(init(payload));
+          } catch (x) {}
+        }
+    }
+  }
+
+  return '';
+}
+
+function describeObjectForErrorMessage(objectOrArray, expandedName) {
+  const objKind = objectName(objectOrArray);
+
+  if (objKind !== 'Object' && objKind !== 'Array') {
+    return objKind;
+  }
+
+  let str = '';
+  let start = -1;
+  let length = 0;
+
+  if (isArray(objectOrArray)) {
+    {
+      // Print Array
+      str = '[';
+      const array = objectOrArray;
+
+      for (let i = 0; i < array.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const value = array[i];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if ('' + i === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += ']';
+    }
+  } else {
+    if (objectOrArray.$$typeof === REACT_ELEMENT_TYPE) {
+      str = '<' + describeElementType(objectOrArray.type) + '/>';
+    } else {
+      // Print Object
+      str = '{';
+      const object = objectOrArray;
+      const names = Object.keys(object);
+
+      for (let i = 0; i < names.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const name = names[i];
+        str += describeKeyForErrorMessage(name) + ': ';
+        const value = object[name];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if (name === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += '}';
+    }
+  }
+
+  if (expandedName === undefined) {
+    return str;
+  }
+
+  if (start > -1 && length > 0) {
+    const highlight = ' '.repeat(start) + '^'.repeat(length);
+    return '\n  ' + str + '\n  ' + highlight;
+  }
+
+  return '\n  ' + str;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ReactSharedServerInternals = // $FlowFixMe: It's defined in the one we resolve to.
+React.__SECRET_SERVER_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+if (!ReactSharedServerInternals) {
+  throw new Error('The "react" package in this environment is not configured correctly. ' + 'The "react-server" condition must be enabled in any environment that ' + 'runs React Server Components.');
+}
+
+// Turns a TypedArray or ArrayBuffer into a string that can be used for comparison
+// in a Map to see if the bytes are the same.
+function binaryToComparableString(view) {
+  return String.fromCharCode.apply(String, new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+}
+
+const ObjectPrototype = Object.prototype;
+const stringify = JSON.stringify; // Serializable values
+// Thenable<ReactClientValue>
+
+const PENDING$1 = 0;
+const COMPLETED = 1;
+const ABORTED = 3;
+const ERRORED$1 = 4;
+const TaintRegistryObjects = ReactSharedServerInternals.TaintRegistryObjects,
+      TaintRegistryValues = ReactSharedServerInternals.TaintRegistryValues,
+      TaintRegistryByteLengths = ReactSharedServerInternals.TaintRegistryByteLengths,
+      TaintRegistryPendingRequests = ReactSharedServerInternals.TaintRegistryPendingRequests,
+      ReactCurrentCache = ReactSharedServerInternals.ReactCurrentCache;
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+
+function throwTaintViolation(message) {
+  // eslint-disable-next-line react-internal/prod-error-codes
+  throw new Error(message);
+}
+
+function cleanupTaintQueue(request) {
+  const cleanupQueue = request.taintCleanupQueue;
+  TaintRegistryPendingRequests.delete(cleanupQueue);
+
+  for (let i = 0; i < cleanupQueue.length; i++) {
+    const entryValue = cleanupQueue[i];
+    const entry = TaintRegistryValues.get(entryValue);
+
+    if (entry !== undefined) {
+      if (entry.count === 1) {
+        TaintRegistryValues.delete(entryValue);
+      } else {
+        entry.count--;
+      }
+    }
+  }
+
+  cleanupQueue.length = 0;
+}
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+}
+
+function defaultPostponeHandler(reason) {// Noop
+}
+
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2;
+function createRequest(model, bundlerConfig, onError, context, identifierPrefix, onPostpone) {
+  if (ReactCurrentCache.current !== null && ReactCurrentCache.current !== DefaultCacheDispatcher) {
+    throw new Error('Currently React only supports one RSC renderer at a time.');
+  }
+
+  prepareHostDispatcher();
+  ReactCurrentCache.current = DefaultCacheDispatcher;
+  const abortSet = new Set();
+  const pingedTasks = [];
+  const cleanupQueue = [];
+
+  {
+    TaintRegistryPendingRequests.add(cleanupQueue);
+  }
+
+  const hints = createHints();
+  const request = {
+    status: OPEN,
+    flushScheduled: false,
+    fatalError: null,
+    destination: null,
+    bundlerConfig,
+    cache: new Map(),
+    nextChunkId: 0,
+    pendingChunks: 0,
+    hints,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    completedImportChunks: [],
+    completedHintChunks: [],
+    completedRegularChunks: [],
+    completedErrorChunks: [],
+    writtenSymbols: new Map(),
+    writtenClientReferences: new Map(),
+    writtenServerReferences: new Map(),
+    writtenProviders: new Map(),
+    writtenObjects: new WeakMap(),
+    identifierPrefix: identifierPrefix || '',
+    identifierCount: 1,
+    taintCleanupQueue: cleanupQueue,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? defaultPostponeHandler : onPostpone,
+    // $FlowFixMe[missing-this-annot]
+    toJSON: function (key, value) {
+      return resolveModelToJSON(request, this, key, value);
+    }
+  };
+  request.pendingChunks++;
+  const rootContext = createRootContext(context);
+  const rootTask = createTask(request, model, rootContext, abortSet);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  if (supportsRequestStorage) {
+    const store = requestStorage.getStore();
+    if (store) return store;
+  }
+
+  return null;
+}
+
+function createRootContext(reqContext) {
+  return importServerContexts(reqContext);
+}
+
+const POP = {};
+
+function serializeThenable(request, thenable) {
+  request.pendingChunks++;
+  const newTask = createTask(request, null, getActiveContext(), request.abortableTasks);
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        // We have the resolved value, we can go ahead and schedule it for serialization.
+        newTask.model = thenable.value;
+        pingTask(request, newTask);
+        return newTask.id;
+      }
+
+    case 'rejected':
+      {
+        const x = thenable.reason;
+
+        if (typeof x === 'object' && x !== null && x.$$typeof === REACT_POSTPONE_TYPE) {
+          const postponeInstance = x;
+          logPostpone(request, postponeInstance.message);
+          emitPostponeChunk(request, newTask.id);
+        } else {
+          const digest = logRecoverableError(request, x);
+          emitErrorChunk(request, newTask.id, digest);
+        }
+
+        return newTask.id;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  thenable.then(value => {
+    newTask.model = value;
+    pingTask(request, newTask);
+  }, reason => {
+    newTask.status = ERRORED$1;
+    request.abortableTasks.delete(newTask); // TODO: We should ideally do this inside performWork so it's scheduled
+
+    const digest = logRecoverableError(request, reason);
+    emitErrorChunk(request, newTask.id, digest);
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  });
+  return newTask.id;
+}
+
+function emitHint(request, code, model) {
+  emitHintChunk(request, code, model);
+  enqueueFlush(request);
+}
+function getHints(request) {
+  return request.hints;
+}
+function getCache(request) {
+  return request.cache;
+}
+
+function readThenable(thenable) {
+  if (thenable.status === 'fulfilled') {
+    return thenable.value;
+  } else if (thenable.status === 'rejected') {
+    throw thenable.reason;
+  }
+
+  throw thenable;
+}
+
+function createLazyWrapperAroundWakeable(wakeable) {
+  // This is a temporary fork of the `use` implementation until we accept
+  // promises everywhere.
+  const thenable = wakeable;
+
+  switch (thenable.status) {
+    case 'fulfilled':
+    case 'rejected':
+      break;
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: thenable,
+    _init: readThenable
+  };
+  return lazyType;
+}
+
+function attemptResolveElement(request, type, key, ref, props, prevThenableState) {
+  if (ref !== null && ref !== undefined) {
+    // When the ref moves to the regular props object this will implicitly
+    // throw for functions. We could probably relax it to a DEV warning for other
+    // cases.
+    throw new Error('Refs cannot be used in Server Components, nor passed to Client Components.');
+  }
+
+  if (typeof type === 'function') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    } // This is a server-side component.
+
+
+    prepareToUseHooksForComponent(prevThenableState);
+    const result = type(props);
+
+    if (typeof result === 'object' && result !== null && typeof result.then === 'function') {
+      // When the return value is in children position we can resolve it immediately,
+      // to its value without a wrapper if it's synchronously available.
+      const thenable = result;
+
+      if (thenable.status === 'fulfilled') {
+        return thenable.value;
+      } // TODO: Once we accept Promises as children on the client, we can just return
+      // the thenable here.
+
+
+      return createLazyWrapperAroundWakeable(result);
+    }
+
+    return result;
+  } else if (typeof type === 'string') {
+    // This is a host element. E.g. HTML.
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (typeof type === 'symbol') {
+    if (type === REACT_FRAGMENT_TYPE) {
+      // For key-less fragments, we add a small optimization to avoid serializing
+      // it as a wrapper.
+      // TODO: If a key is specified, we should propagate its key to any children.
+      // Same as if a Server Component has a key.
+      return props.children;
+    } // This might be a built-in React component. We'll let the client decide.
+    // Any built-in works as long as its props are serializable.
+
+
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (type != null && typeof type === 'object') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    }
+
+    switch (type.$$typeof) {
+      case REACT_LAZY_TYPE:
+        {
+          const payload = type._payload;
+          const init = type._init;
+          const wrappedType = init(payload);
+          return attemptResolveElement(request, wrappedType, key, ref, props, prevThenableState);
+        }
+
+      case REACT_FORWARD_REF_TYPE:
+        {
+          const render = type.render;
+          prepareToUseHooksForComponent(prevThenableState);
+          return render(props, undefined);
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          return attemptResolveElement(request, type.type, key, ref, props, prevThenableState);
+        }
+
+      case REACT_PROVIDER_TYPE:
+        {
+          {
+            pushProvider(type._context, props.value);
+
+            return [REACT_ELEMENT_TYPE, type, key, // Rely on __popProvider being serialized last to pop the provider.
+            {
+              value: props.value,
+              children: props.children,
+              __pop: POP
+            }];
+          } // Fallthrough
+
+        }
+    }
+  }
+
+  throw new Error("Unsupported Server Component type: " + describeValueForErrorMessage(type));
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createTask(request, model, context, abortSet) {
+  const id = request.nextChunkId++;
+  const task = {
+    id,
+    status: PENDING$1,
+    model,
+    context,
+    ping: () => pingTask(request, task),
+    thenableState: null
+  };
+  abortSet.add(task);
+  return task;
+}
+
+function serializeByValueID(id) {
+  return '$' + id.toString(16);
+}
+
+function serializeLazyID(id) {
+  return '$L' + id.toString(16);
+}
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeProviderReference(name) {
+  return '$P' + name;
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeRowHeader(tag, id) {
+  return id.toString(16) + ':' + tag;
+}
+
+function encodeReferenceChunk(request, id, reference) {
+  const json = stringify(reference);
+  const row = id.toString(16) + ':' + json + '\n';
+  return stringToChunk(row);
+}
+
+function serializeClientReference(request, parent, key, clientReference) {
+  const clientReferenceKey = getClientReferenceKey(clientReference);
+  const writtenClientReferences = request.writtenClientReferences;
+  const existingId = writtenClientReferences.get(clientReferenceKey);
+
+  if (existingId !== undefined) {
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(existingId);
+    }
+
+    return serializeByValueID(existingId);
+  }
+
+  try {
+    const clientReferenceMetadata = resolveClientReferenceMetadata(request.bundlerConfig, clientReference);
+    request.pendingChunks++;
+    const importId = request.nextChunkId++;
+    emitImportChunk(request, importId, clientReferenceMetadata);
+    writtenClientReferences.set(clientReferenceKey, importId);
+
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(importId);
+    }
+
+    return serializeByValueID(importId);
+  } catch (x) {
+    request.pendingChunks++;
+    const errorId = request.nextChunkId++;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, errorId, digest);
+    return serializeByValueID(errorId);
+  }
+}
+
+function outlineModel(request, value) {
+  request.pendingChunks++;
+  const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+  retryTask(request, newTask);
+  return newTask.id;
+}
+
+function serializeServerReference(request, parent, key, serverReference) {
+  const writtenServerReferences = request.writtenServerReferences;
+  const existingId = writtenServerReferences.get(serverReference);
+
+  if (existingId !== undefined) {
+    return serializeServerReferenceID(existingId);
+  }
+
+  const bound = getServerReferenceBoundArguments(request.bundlerConfig, serverReference);
+  const serverReferenceMetadata = {
+    id: getServerReferenceId(request.bundlerConfig, serverReference),
+    bound: bound ? Promise.resolve(bound) : null
+  };
+  const metadataId = outlineModel(request, serverReferenceMetadata);
+  writtenServerReferences.set(serverReference, metadataId);
+  return serializeServerReferenceID(metadataId);
+}
+
+function serializeLargeTextString(request, text) {
+  request.pendingChunks += 2;
+  const textId = request.nextChunkId++;
+  const textChunk = stringToChunk(text);
+  const binaryLength = byteLengthOfChunk(textChunk);
+  const row = textId.toString(16) + ':T' + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, textChunk);
+  return serializeByValueID(textId);
+}
+
+function serializeMap(request, map) {
+  const entries = Array.from(map);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i][0];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$Q' + id.toString(16);
+}
+
+function serializeSet(request, set) {
+  const entries = Array.from(set);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$W' + id.toString(16);
+}
+
+function serializeTypedArray(request, tag, typedArray) {
+  {
+    if (TaintRegistryByteLengths.has(typedArray.byteLength)) {
+      // If we have had any tainted values of this length, we check
+      // to see if these bytes matches any entries in the registry.
+      const tainted = TaintRegistryValues.get(binaryToComparableString(typedArray));
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    }
+  }
+
+  request.pendingChunks += 2;
+  const bufferId = request.nextChunkId++; // TODO: Convert to little endian if that's not the server default.
+
+  const binaryChunk = typedArrayToBinaryChunk(typedArray);
+  const binaryLength = byteLengthOfBinaryChunk(binaryChunk);
+  const row = bufferId.toString(16) + ':' + tag + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, binaryChunk);
+  return serializeByValueID(bufferId);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+let modelRoot = false;
+
+function resolveModelToJSON(request, parent, key, value) {
+
+
+  switch (value) {
+    case REACT_ELEMENT_TYPE:
+      return '$';
+  }
+
+
+  while (typeof value === 'object' && value !== null && (value.$$typeof === REACT_ELEMENT_TYPE || value.$$typeof === REACT_LAZY_TYPE)) {
+
+    try {
+      switch (value.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const writtenObjects = request.writtenObjects;
+            const existingId = writtenObjects.get(value);
+
+            if (existingId !== undefined) {
+              if (existingId === -1) {
+                // Seen but not yet outlined.
+                const newId = outlineModel(request, value);
+                return serializeByValueID(newId);
+              } else if (modelRoot === value) {
+                // This is the ID we're currently emitting so we need to write it
+                // once but if we discover it again, we refer to it by id.
+                modelRoot = null;
+              } else {
+                // We've already emitted this as an outlined object, so we can
+                // just refer to that by its existing ID.
+                return serializeByValueID(existingId);
+              }
+            } else {
+              // This is the first time we've seen this object. We may never see it again
+              // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+              writtenObjects.set(value, -1);
+            } // TODO: Concatenate keys of parents onto children.
+
+
+            const element = value; // Attempt to render the Server Component.
+
+            value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, null);
+            break;
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = value._payload;
+            const init = value._init;
+            value = init(payload);
+            break;
+          }
+      }
+    } catch (thrownValue) {
+      const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          // Something suspended, we'll need to create a new task and resolve it later.
+          request.pendingChunks++;
+          const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+          const ping = newTask.ping;
+          x.then(ping, ping);
+          newTask.thenableState = getThenableStateAfterSuspending();
+          return serializeLazyID(newTask.id);
+        } else if (x.$$typeof === REACT_POSTPONE_TYPE) {
+          // Something postponed. We'll still send everything we have up until this point.
+          // We'll replace this element with a lazy reference that postpones on the client.
+          const postponeInstance = x;
+          request.pendingChunks++;
+          const postponeId = request.nextChunkId++;
+          logPostpone(request, postponeInstance.message);
+          emitPostponeChunk(request, postponeId);
+          return serializeLazyID(postponeId);
+        }
+      } // Something errored. We'll still send everything we have up until this point.
+      // We'll replace this element with a lazy reference that throws on the client
+      // once it gets rendered.
+
+
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+      const digest = logRecoverableError(request, x);
+      emitErrorChunk(request, errorId, digest);
+      return serializeLazyID(errorId);
+    }
+  }
+
+  if (value === null) {
+    return null;
+  }
+
+  if (typeof value === 'object') {
+    {
+      const tainted = TaintRegistryObjects.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted);
+      }
+    }
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    const writtenObjects = request.writtenObjects;
+    const existingId = writtenObjects.get(value); // $FlowFixMe[method-unbinding]
+
+    if (typeof value.then === 'function') {
+      if (existingId !== undefined) {
+        if (modelRoot === value) {
+          // This is the ID we're currently emitting so we need to write it
+          // once but if we discover it again, we refer to it by id.
+          modelRoot = null;
+        } else {
+          // We've seen this promise before, so we can just refer to the same result.
+          return serializePromiseID(existingId);
+        }
+      } // We assume that any object with a .then property is a "Thenable" type,
+      // or a Promise type. Either of which can be represented by a Promise.
+
+
+      const promiseId = serializeThenable(request, value);
+      writtenObjects.set(value, promiseId);
+      return serializePromiseID(promiseId);
+    }
+
+    {
+      if (value.$$typeof === REACT_PROVIDER_TYPE) {
+        const providerKey = value._context._globalName;
+        const writtenProviders = request.writtenProviders;
+        let providerId = writtenProviders.get(key);
+
+        if (providerId === undefined) {
+          request.pendingChunks++;
+          providerId = request.nextChunkId++;
+          writtenProviders.set(providerKey, providerId);
+          emitProviderChunk(request, providerId, providerKey);
+        }
+
+        return serializeByValueID(providerId);
+      } else if (value === POP) {
+        popProvider();
+
+        return undefined;
+      }
+    }
+
+    if (existingId !== undefined) {
+      if (existingId === -1) {
+        // Seen but not yet outlined.
+        const newId = outlineModel(request, value);
+        return serializeByValueID(newId);
+      } else if (modelRoot === value) {
+        // This is the ID we're currently emitting so we need to write it
+        // once but if we discover it again, we refer to it by id.
+        modelRoot = null;
+      } else {
+        // We've already emitted this as an outlined object, so we can
+        // just refer to that by its existing ID.
+        return serializeByValueID(existingId);
+      }
+    } else {
+      // This is the first time we've seen this object. We may never see it again
+      // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+      writtenObjects.set(value, -1);
+    }
+
+    if (isArray(value)) {
+      // $FlowFixMe[incompatible-return]
+      return value;
+    }
+
+    if (value instanceof Map) {
+      return serializeMap(request, value);
+    }
+
+    if (value instanceof Set) {
+      return serializeSet(request, value);
+    }
+
+    {
+      if (value instanceof ArrayBuffer) {
+        return serializeTypedArray(request, 'A', new Uint8Array(value));
+      }
+
+      if (value instanceof Int8Array) {
+        // char
+        return serializeTypedArray(request, 'C', value);
+      }
+
+      if (value instanceof Uint8Array) {
+        // unsigned char
+        return serializeTypedArray(request, 'c', value);
+      }
+
+      if (value instanceof Uint8ClampedArray) {
+        // unsigned clamped char
+        return serializeTypedArray(request, 'U', value);
+      }
+
+      if (value instanceof Int16Array) {
+        // sort
+        return serializeTypedArray(request, 'S', value);
+      }
+
+      if (value instanceof Uint16Array) {
+        // unsigned short
+        return serializeTypedArray(request, 's', value);
+      }
+
+      if (value instanceof Int32Array) {
+        // long
+        return serializeTypedArray(request, 'L', value);
+      }
+
+      if (value instanceof Uint32Array) {
+        // unsigned long
+        return serializeTypedArray(request, 'l', value);
+      }
+
+      if (value instanceof Float32Array) {
+        // float
+        return serializeTypedArray(request, 'F', value);
+      }
+
+      if (value instanceof Float64Array) {
+        // double
+        return serializeTypedArray(request, 'D', value);
+      }
+
+      if (value instanceof BigInt64Array) {
+        // number
+        return serializeTypedArray(request, 'N', value);
+      }
+
+      if (value instanceof BigUint64Array) {
+        // unsigned number
+        // We use "m" instead of "n" since JSON can start with "null"
+        return serializeTypedArray(request, 'm', value);
+      }
+
+      if (value instanceof DataView) {
+        return serializeTypedArray(request, 'V', value);
+      }
+    }
+
+    const iteratorFn = getIteratorFn(value);
+
+    if (iteratorFn) {
+      return Array.from(value);
+    } // Verify that this is a simple plain object.
+
+
+    const proto = getPrototypeOf(value);
+
+    if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+      throw new Error('Only plain objects, and a few built-ins, can be passed to Client Components ' + 'from Server Components. Classes or null prototypes are not supported.');
+    }
+
+
+    return value;
+  }
+
+  if (typeof value === 'string') {
+    {
+      const tainted = TaintRegistryValues.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    } // TODO: Maybe too clever. If we support URL there's no similar trick.
+
+
+    if (value[value.length - 1] === 'Z') {
+      // Possibly a Date, whose toJSON automatically calls toISOString
+      // $FlowFixMe[incompatible-use]
+      const originalValue = parent[key];
+
+      if (originalValue instanceof Date) {
+        return serializeDateFromDateJSON(value);
+      }
+    }
+
+    if (value.length >= 1024) {
+      // For large strings, we encode them outside the JSON payload so that we
+      // don't have to double encode and double parse the strings. This can also
+      // be more compact in case the string has a lot of escaped characters.
+      return serializeLargeTextString(request, value);
+    }
+
+    return escapeStringValue(value);
+  }
+
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  if (typeof value === 'number') {
+    return serializeNumber(value);
+  }
+
+  if (typeof value === 'undefined') {
+    return serializeUndefined();
+  }
+
+  if (typeof value === 'function') {
+    {
+      const tainted = TaintRegistryObjects.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted);
+      }
+    }
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    if (isServerReference(value)) {
+      return serializeServerReference(request, parent, key, value);
+    }
+
+    if (/^on[A-Z]/.test(key)) {
+      throw new Error('Event handlers cannot be passed to Client Component props.' + describeObjectForErrorMessage(parent, key) + '\nIf you need interactivity, consider converting part of this to a Client Component.');
+    } else {
+      throw new Error('Functions cannot be passed directly to Client Components ' + 'unless you explicitly expose it by marking it with "use server".' + describeObjectForErrorMessage(parent, key));
+    }
+  }
+
+  if (typeof value === 'symbol') {
+    const writtenSymbols = request.writtenSymbols;
+    const existingId = writtenSymbols.get(value);
+
+    if (existingId !== undefined) {
+      return serializeByValueID(existingId);
+    } // $FlowFixMe[incompatible-type] `description` might be undefined
+
+
+    const name = value.description;
+
+    if (Symbol.for(name) !== value) {
+      throw new Error('Only global symbols received from Symbol.for(...) can be passed to Client Components. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+      value.description + ") cannot be found among global symbols.") + describeObjectForErrorMessage(parent, key));
+    }
+
+    request.pendingChunks++;
+    const symbolId = request.nextChunkId++;
+    emitSymbolChunk(request, symbolId, name);
+    writtenSymbols.set(value, symbolId);
+    return serializeByValueID(symbolId);
+  }
+
+  if (typeof value === 'bigint') {
+    {
+      const tainted = TaintRegistryValues.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    }
+
+    return serializeBigInt(value);
+  }
+
+  throw new Error("Type " + typeof value + " is not supported in Client Component props." + describeObjectForErrorMessage(parent, key));
+}
+
+function logPostpone(request, reason) {
+  const onPostpone = request.onPostpone;
+  onPostpone(reason);
+}
+
+function logRecoverableError(request, error) {
+  const onError = request.onError;
+  const errorDigest = onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest || '';
+}
+
+function fatalError(request, error) {
+  {
+    cleanupTaintQueue(request);
+  } // This is called outside error handling code such as if an error happens in React internals.
+
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function emitPostponeChunk(request, id, postponeInstance) {
+  let row;
+
+  {
+    // No reason included in prod.
+    row = serializeRowHeader('P', id) + '\n';
+  }
+
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitErrorChunk(request, id, digest, error) {
+  let errorInfo;
+
+  {
+    errorInfo = {
+      digest
+    };
+  }
+
+  const row = serializeRowHeader('E', id) + stringify(errorInfo) + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitImportChunk(request, id, clientReferenceMetadata) {
+  // $FlowFixMe[incompatible-type] stringify can return null
+  const json = stringify(clientReferenceMetadata);
+  const row = serializeRowHeader('I', id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitHintChunk(request, code, model) {
+  const json = stringify(model);
+  const id = request.nextChunkId++;
+  const row = serializeRowHeader('H' + code, id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedHintChunks.push(processedChunk);
+}
+
+function emitSymbolChunk(request, id, name) {
+  const symbolReference = serializeSymbolReference(name);
+  const processedChunk = encodeReferenceChunk(request, id, symbolReference);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitProviderChunk(request, id, contextName) {
+  const contextReference = serializeProviderReference(contextName);
+  const processedChunk = encodeReferenceChunk(request, id, contextReference);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function emitModelChunk(request, id, model) {
+  // Track the root so we know that we have to emit this object even though it
+  // already has an ID. This is needed because we might see this object twice
+  // in the same toJSON if it is cyclic.
+  modelRoot = model; // $FlowFixMe[incompatible-type] stringify can return null
+
+  const json = stringify(model, request.toJSON);
+  const row = id.toString(16) + ':' + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function retryTask(request, task) {
+  if (task.status !== PENDING$1) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  }
+
+  switchContext(task.context);
+
+  try {
+    let value = task.model;
+
+    if (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+      request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+      const element = value; // When retrying a component, reuse the thenableState from the
+      // previous attempt.
+
+      const prevThenableState = task.thenableState; // Attempt to render the Server Component.
+      // Doing this here lets us reuse this same task if the next component
+      // also suspends.
+
+      task.model = value;
+      value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, prevThenableState); // Successfully finished this component. We're going to keep rendering
+      // using the same task, but we reset its thenable state before continuing.
+
+      task.thenableState = null; // Keep rendering and reuse the same task. This inner loop is separate
+      // from the render above because we don't need to reset the thenable state
+      // until the next time something suspends and retries.
+
+      while (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+        request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+        const nextElement = value;
+        task.model = value;
+        value = attemptResolveElement(request, nextElement.type, nextElement.key, nextElement.ref, nextElement.props, null);
+      }
+    } // Track that this object is outlined and has an id.
+
+
+    if (typeof value === 'object' && value !== null) {
+      request.writtenObjects.set(value, task.id);
+    }
+
+    emitModelChunk(request, task.id, value);
+    request.abortableTasks.delete(task);
+    task.status = COMPLETED;
+  } catch (thrownValue) {
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      } else if (x.$$typeof === REACT_POSTPONE_TYPE) {
+        request.abortableTasks.delete(task);
+        task.status = ERRORED$1;
+        const postponeInstance = x;
+        logPostpone(request, postponeInstance.message);
+        emitPostponeChunk(request, task.id);
+        return;
+      }
+    }
+
+    request.abortableTasks.delete(task);
+    task.status = ERRORED$1;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, task.id, digest);
+  }
+}
+
+function performWork(request) {
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  const prevRequest = currentRequest;
+  currentRequest = request;
+  prepareToUseHooksForRequest(request);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    request.pingedTasks = [];
+
+    for (let i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    ReactCurrentDispatcher.current = prevDispatcher;
+    resetHooksForRequest();
+    currentRequest = prevRequest;
+  }
+}
+
+function abortTask(task, request, errorId) {
+  task.status = ABORTED; // Instead of emitting an error per task.id, we emit a model that only
+  // has a single value referencing the error.
+
+  const ref = serializeByValueID(errorId);
+  const processedChunk = encodeReferenceChunk(request, task.id, ref);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function flushCompletedChunks(request, destination) {
+  beginWriting();
+
+  try {
+    // We emit module chunks first in the stream so that
+    // they can be preloaded as early as possible.
+    const importsChunks = request.completedImportChunks;
+    let i = 0;
+
+    for (; i < importsChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = importsChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    importsChunks.splice(0, i); // Next comes hints.
+
+    const hintChunks = request.completedHintChunks;
+    i = 0;
+
+    for (; i < hintChunks.length; i++) {
+      const chunk = hintChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    hintChunks.splice(0, i); // Next comes model data.
+
+    const regularChunks = request.completedRegularChunks;
+    i = 0;
+
+    for (; i < regularChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = regularChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    regularChunks.splice(0, i); // Finally, errors are sent. The idea is that it's ok to delay
+    // any error messages and prioritize display of other parts of
+    // the page.
+
+    const errorChunks = request.completedErrorChunks;
+    i = 0;
+
+    for (; i < errorChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = errorChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    errorChunks.splice(0, i);
+  } finally {
+    request.flushScheduled = false;
+    completeWriting(destination);
+  }
+
+  if (request.pendingChunks === 0) {
+    // We're done.
+    {
+      cleanupTaintQueue(request);
+    }
+
+    close$1(destination);
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  if (supportsRequestStorage) {
+    scheduleWork(() => requestStorage.run(request, performWork, request));
+  } else {
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    const destination = request.destination;
+    request.flushScheduled = true;
+    scheduleWork(() => flushCompletedChunks(request, destination));
+  }
+}
+
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedChunks(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      // We have tasks to abort. We'll emit one error row and then emit a reference
+      // to that row from every row that's still remaining.
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+
+      if (enablePostpone && typeof reason === 'object' && reason !== null && reason.$$typeof === REACT_POSTPONE_TYPE) {
+        const postponeInstance = reason;
+        logPostpone(request, postponeInstance.message);
+        emitPostponeChunk(request, errorId, postponeInstance);
+      } else {
+        const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+        const digest = logRecoverableError(request, error);
+        emitErrorChunk(request, errorId, digest, error);
+      }
+
+      abortableTasks.forEach(task => abortTask(task, request, errorId));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function importServerContexts(contexts) {
+  if (contexts) {
+    const prevContext = getActiveContext();
+    switchContext(rootContextSnapshot);
+
+    for (let i = 0; i < contexts.length; i++) {
+      const _contexts$i = contexts[i],
+            name = _contexts$i[0],
+            value = _contexts$i[1];
+      const context = getOrCreateServerContext(name);
+      pushProvider(context, value);
+    }
+
+    const importedContext = getActiveContext();
+    switchContext(prevContext);
+    return importedContext;
+  }
+
+  return rootContextSnapshot;
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+function resolveServerReference(bundlerConfig, id) {
+  let name = '';
+  let resolvedModuleData = bundlerConfig[id];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = id.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = id.slice(idx + 1);
+      resolvedModuleData = bundlerConfig[id.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + id + '" in the React Server Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  } // TODO: This needs to return async: true if it's an async module.
+
+
+  return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+} // The chunk cache contains all the chunks we've preloaded so far.
+// If they're still pending they're a thenable. This map also exists
+// in Turbopack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = globalThis.__next_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+
+  for (let i = 0; i < chunks.length; i++) {
+    const chunkFilename = chunks[i];
+    const entry = chunkCache.get(chunkFilename);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkFilename);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkFilename, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkFilename, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = globalThis.__next_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+function loadChunk(filename) {
+  return globalThis.__next_chunk_load__(filename);
+}
+
+// The server acts as a Client of itself when resolving Server References.
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const RESOLVED_MODEL = 'resolved_model';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function bindArgs$1(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference$1(response, id, bound, parentChunk, parentObject, key) {
+  const serverReference = resolveServerReference(response._bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+  let promise;
+
+  if (bound) {
+    promise = Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs$1(requireModule(serverReference), args);
+    });
+  } else {
+    if (preloadPromise) {
+      promise = Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+    } else {
+      // Synchronously available
+      return requireModule(serverReference);
+    }
+  }
+
+  promise.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk)); // We need a placeholder value that will be replaced later.
+
+  return null;
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+
+  try {
+    const value = JSON.parse(chunk.value, chunk._response._fromJSON);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    const prefix = response._prefix;
+    const key = prefix + id; // Check if we have this field in the backing store already.
+
+    const backingEntry = response._formData.get(key);
+
+    if (backingEntry != null) {
+      // We assume that this is a string entry for now.
+      chunk = createResolvedModelChunk(response, backingEntry);
+    } else {
+      // We're still waiting on this entry to stream in.
+      chunk = createPendingChunk(response);
+    }
+
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+    blocked.deps++;
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  if (chunk.status === RESOLVED_MODEL) {
+    initializeModelChunk(chunk);
+  }
+
+  if (chunk.status !== INITIALIZED) {
+    // We know that this is emitted earlier so otherwise it's an error.
+    throw chunk.reason;
+  }
+
+  return chunk.value;
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16); // TODO: Just encode this in the reference inline instead of as a model.
+
+          const metaData = getOutlinedModel(response, id);
+          return loadServerReference$1(response, metaData.id, metaData.bound, initializingChunk, parentObject, key);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'K':
+        {
+          // FormData
+          const stringId = value.slice(2);
+          const formPrefix = response._prefix + stringId + '_';
+          const data = new FormData();
+          const backingFormData = response._formData; // We assume that the reference to FormData always comes after each
+          // entry that it references so we can assume they all exist in the
+          // backing store already.
+          // $FlowFixMe[prop-missing] FormData has forEach on it.
+
+          backingFormData.forEach((entry, entryKey) => {
+            if (entryKey.startsWith(formPrefix)) {
+              data.append(entryKey.slice(formPrefix.length), entry);
+            }
+          });
+          return data;
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function createResponse(bundlerConfig, formFieldPrefix) {
+  let backingFormData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new FormData();
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _prefix: formFieldPrefix,
+    _formData: backingFormData,
+    _chunks: chunks,
+    _fromJSON: function (key, value) {
+      if (typeof value === 'string') {
+        // We can't use .bind here because we need the "this" value.
+        return parseModelString(response, this, key, value);
+      }
+
+      return value;
+    }
+  };
+  return response;
+}
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function bindArgs(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference(bundlerConfig, id, bound) {
+  const serverReference = resolveServerReference(bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+
+  if (bound) {
+    return Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs(requireModule(serverReference), args);
+    });
+  } else if (preloadPromise) {
+    return Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+  } else {
+    // Synchronously available
+    return Promise.resolve(requireModule(serverReference));
+  }
+}
+
+function decodeBoundActionMetaData(body, serverManifest, formFieldPrefix) {
+  // The data for this reference is encoded in multiple fields under this prefix.
+  const actionResponse = createResponse(serverManifest, formFieldPrefix, body);
+  close(actionResponse);
+  const refPromise = getRoot(actionResponse); // Force it to initialize
+  // $FlowFixMe
+
+  refPromise.then(() => {});
+
+  if (refPromise.status !== 'fulfilled') {
+    // $FlowFixMe
+    throw refPromise.reason;
+  }
+
+  return refPromise.value;
+}
+
+function decodeAction(body, serverManifest) {
+  // We're going to create a new formData object that holds all the fields except
+  // the implementation details of the action data.
+  const formData = new FormData();
+  let action = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (!key.startsWith('$ACTION_')) {
+      formData.append(key, value);
+      return;
+    } // Later actions may override earlier actions if a button is used to override the default
+    // form action.
+
+
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      const metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+      action = loadServerReference(serverManifest, metaData.id, metaData.bound);
+      return;
+    }
+
+    if (key.startsWith('$ACTION_ID_')) {
+      const id = key.slice(11);
+      action = loadServerReference(serverManifest, id, null);
+      return;
+    }
+  });
+
+  if (action === null) {
+    return null;
+  } // Return the action with the remaining FormData bound to the first argument.
+
+
+  return action.then(fn => fn.bind(null, formData));
+}
+
+function renderToReadableStream(model, turbopackMap, options) {
+  const request = createRequest(model, turbopackMap, options ? options.onError : undefined, options ? options.context : undefined, options ? options.identifierPrefix : undefined, options ? options.onPostpone : undefined);
+
+  if (options && options.signal) {
+    const signal = options.signal;
+
+    if (signal.aborted) {
+      abort(request, signal.reason);
+    } else {
+      const listener = () => {
+        abort(request, signal.reason);
+        signal.removeEventListener('abort', listener);
+      };
+
+      signal.addEventListener('abort', listener);
+    }
+  }
+
+  const stream = new ReadableStream({
+    type: 'bytes',
+    start: controller => {
+      startWork(request);
+    },
+    pull: controller => {
+      startFlowing(request, controller);
+    },
+    cancel: reason => {}
+  }, // $FlowFixMe[prop-missing] size() methods are not allowed on byte streams.
+  {
+    highWaterMark: 0
+  });
+  return stream;
+}
+
+function decodeReply(body, turbopackMap) {
+  if (typeof body === 'string') {
+    const form = new FormData();
+    form.append('0', body);
+    body = form;
+  }
+
+  const response = createResponse(turbopackMap, '', body);
+  const root = getRoot(response);
+  close(response);
+  return root;
+}
+
+exports.createClientModuleProxy = createClientModuleProxy;
+exports.decodeAction = decodeAction;
+exports.decodeReply = decodeReply;
+exports.registerClientReference = registerClientReference;
+exports.registerServerReference = registerServerReference;
+exports.renderToReadableStream = renderToReadableStream;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.edge.production.min.js b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.edge.production.min.js
index 544c31c673d79..7a8fe394a0e29 100644
--- a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.edge.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.edge.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-turbopack-server.edge.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-turbopack-server.edge.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var aa=require("react"),ba=require("react-dom"),m=null,n=0;function p(a,b){if(0!==b.byteLength)if(512<b.byteLength)0<n&&(a.enqueue(new Uint8Array(m.buffer,0,n)),m=new Uint8Array(512),n=0),a.enqueue(b);else{var d=m.length-n;d<b.byteLength&&(0===d?a.enqueue(m):(m.set(b.subarray(0,d),n),a.enqueue(m),b=b.subarray(d)),m=new Uint8Array(512),n=0);m.set(b,n);n+=b.byteLength}return!0}var q=new TextEncoder;function ca(a,b){"function"===typeof a.error?a.error(b):a.close()}
 var r=Symbol.for("react.client.reference"),t=Symbol.for("react.server.reference");function u(a,b,d){return Object.defineProperties(a,{$$typeof:{value:r},$$id:{value:b},$$async:{value:d}})}var da=Function.prototype.bind,ea=Array.prototype.slice;function fa(){var a=da.apply(this,arguments);if(this.$$typeof===t){var b=ea.call(arguments,1);a.$$typeof=t;a.$$id=this.$$id;a.$$bound=this.$$bound?this.$$bound.concat(b):b}return a}
 var ha=Promise.prototype,ia={get:function(a,b){switch(b){case "$$typeof":return a.$$typeof;case "$$id":return a.$$id;case "$$async":return a.$$async;case "name":return a.name;case "displayName":return;case "defaultProps":return;case "toJSON":return;case Symbol.toPrimitive:return Object.prototype[Symbol.toPrimitive];case "Provider":throw Error("Cannot render a Client Context Provider on the Server. Instead, you can export a Client Component wrapper that itself renders a Client Context Provider.");
@@ -79,3 +79,5 @@ exports.decodeAction=function(a,b){var d=new FormData,c=null;a.forEach(function(
 exports.registerClientReference=function(a,b,d){return u(a,b+"#"+d,!1)};exports.registerServerReference=function(a,b,d){return Object.defineProperties(a,{$$typeof:{value:t},$$id:{value:null===d?b:b+"#"+d},$$bound:{value:null},bind:{value:fa}})};
 exports.renderToReadableStream=function(a,b,d){var c=qb(a,b,d?d.onError:void 0,d?d.context:void 0,d?d.identifierPrefix:void 0,d?d.onPostpone:void 0);if(d&&d.signal){var e=d.signal;if(e.aborted)Ib(c,e.reason);else{var f=function(){Ib(c,e.reason);e.removeEventListener("abort",f)};e.addEventListener("abort",f)}}return new ReadableStream({type:"bytes",start:function(){Hb(c)},pull:function(g){if(1===c.status)c.status=2,ca(g,c.fatalError);else if(2!==c.status&&null===c.destination){c.destination=g;try{Q(c,
 g)}catch(k){O(c,k),Gb(c,k)}}},cancel:function(){}},{highWaterMark:0})};
+
+//# sourceMappingURL=react-server-dom-turbopack-server.edge.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.node.production.js b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.node.production.js
new file mode 100644
index 0000000000000..7eef8bf1fbdd1
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.node.production.js
@@ -0,0 +1,3600 @@
+/**
+ * @license React
+ * react-server-dom-turbopack-server.node.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var util = require('util');
+require('crypto');
+var async_hooks = require('async_hooks');
+var React = require('react');
+var ReactDOM = require('react-dom');
+
+// -----------------------------------------------------------------------------
+const enablePostpone = true;
+
+function scheduleWork(callback) {
+  setImmediate(callback);
+}
+function flushBuffered(destination) {
+  // If we don't have any more data to send right now.
+  // Flush whatever is in the buffer to the wire.
+  if (typeof destination.flush === 'function') {
+    // By convention the Zlib streams provide a flush function for this purpose.
+    // For Express, compression middleware adds this method.
+    destination.flush();
+  }
+}
+const VIEW_SIZE = 2048;
+let currentView = null;
+let writtenBytes = 0;
+let destinationHasCapacity = true;
+function beginWriting(destination) {
+  currentView = new Uint8Array(VIEW_SIZE);
+  writtenBytes = 0;
+  destinationHasCapacity = true;
+}
+
+function writeStringChunk(destination, stringChunk) {
+  if (stringChunk.length === 0) {
+    return;
+  } // maximum possible view needed to encode entire string
+
+
+  if (stringChunk.length * 3 > VIEW_SIZE) {
+    if (writtenBytes > 0) {
+      writeToDestination(destination, currentView.subarray(0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    writeToDestination(destination, textEncoder.encode(stringChunk));
+    return;
+  }
+
+  let target = currentView;
+
+  if (writtenBytes > 0) {
+    target = currentView.subarray(writtenBytes);
+  }
+
+  const _textEncoder$encodeIn = textEncoder.encodeInto(stringChunk, target),
+        read = _textEncoder$encodeIn.read,
+        written = _textEncoder$encodeIn.written;
+
+  writtenBytes += written;
+
+  if (read < stringChunk.length) {
+    writeToDestination(destination, currentView.subarray(0, writtenBytes));
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = textEncoder.encodeInto(stringChunk.slice(read), currentView).written;
+  }
+
+  if (writtenBytes === VIEW_SIZE) {
+    writeToDestination(destination, currentView);
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+}
+
+function writeViewChunk(destination, chunk) {
+  if (chunk.byteLength === 0) {
+    return;
+  }
+
+  if (chunk.byteLength > VIEW_SIZE) {
+    // one that is cached by the streaming renderer. We will enqueu
+    // it directly and expect it is not re-used
+
+
+    if (writtenBytes > 0) {
+      writeToDestination(destination, currentView.subarray(0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    writeToDestination(destination, chunk);
+    return;
+  }
+
+  let bytesToWrite = chunk;
+  const allowableBytes = currentView.length - writtenBytes;
+
+  if (allowableBytes < bytesToWrite.byteLength) {
+    // this chunk would overflow the current view. We enqueue a full view
+    // and start a new view with the remaining chunk
+    if (allowableBytes === 0) {
+      // the current view is already full, send it
+      writeToDestination(destination, currentView);
+    } else {
+      // fill up the current view and apply the remaining chunk bytes
+      // to a new view.
+      currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes);
+      writtenBytes += allowableBytes;
+      writeToDestination(destination, currentView);
+      bytesToWrite = bytesToWrite.subarray(allowableBytes);
+    }
+
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+
+  currentView.set(bytesToWrite, writtenBytes);
+  writtenBytes += bytesToWrite.byteLength;
+
+  if (writtenBytes === VIEW_SIZE) {
+    writeToDestination(destination, currentView);
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+}
+
+function writeChunk(destination, chunk) {
+  if (typeof chunk === 'string') {
+    writeStringChunk(destination, chunk);
+  } else {
+    writeViewChunk(destination, chunk);
+  }
+}
+
+function writeToDestination(destination, view) {
+  const currentHasCapacity = destination.write(view);
+  destinationHasCapacity = destinationHasCapacity && currentHasCapacity;
+}
+
+function writeChunkAndReturn(destination, chunk) {
+  writeChunk(destination, chunk);
+  return destinationHasCapacity;
+}
+function completeWriting(destination) {
+  if (currentView && writtenBytes > 0) {
+    destination.write(currentView.subarray(0, writtenBytes));
+  }
+
+  currentView = null;
+  writtenBytes = 0;
+  destinationHasCapacity = true;
+}
+function close$1(destination) {
+  destination.end();
+}
+const textEncoder = new util.TextEncoder();
+function stringToChunk(content) {
+  return content;
+}
+function typedArrayToBinaryChunk(content) {
+  // Convert any non-Uint8Array array to Uint8Array. We could avoid this for Uint8Arrays.
+  return new Uint8Array(content.buffer, content.byteOffset, content.byteLength);
+}
+function byteLengthOfChunk(chunk) {
+  return typeof chunk === 'string' ? Buffer.byteLength(chunk, 'utf8') : chunk.byteLength;
+}
+function byteLengthOfBinaryChunk(chunk) {
+  return chunk.byteLength;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+  destination.destroy(error);
+}
+
+// eslint-disable-next-line no-unused-vars
+const CLIENT_REFERENCE_TAG = Symbol.for('react.client.reference');
+const SERVER_REFERENCE_TAG = Symbol.for('react.server.reference');
+function isClientReference(reference) {
+  return reference.$$typeof === CLIENT_REFERENCE_TAG;
+}
+function isServerReference(reference) {
+  return reference.$$typeof === SERVER_REFERENCE_TAG;
+}
+function registerClientReference(proxyImplementation, id, exportName) {
+  return registerClientReferenceImpl(proxyImplementation, id + '#' + exportName, false);
+}
+
+function registerClientReferenceImpl(proxyImplementation, id, async) {
+  return Object.defineProperties(proxyImplementation, {
+    $$typeof: {
+      value: CLIENT_REFERENCE_TAG
+    },
+    $$id: {
+      value: id
+    },
+    $$async: {
+      value: async
+    }
+  });
+} // $FlowFixMe[method-unbinding]
+
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+
+  if (this.$$typeof === SERVER_REFERENCE_TAG) {
+    const args = ArraySlice.call(arguments, 1);
+    newFn.$$typeof = SERVER_REFERENCE_TAG;
+    newFn.$$id = this.$$id;
+    newFn.$$bound = this.$$bound ? this.$$bound.concat(args) : args;
+  }
+
+  return newFn;
+}
+
+function registerServerReference(reference, id, exportName) {
+  return Object.defineProperties(reference, {
+    $$typeof: {
+      value: SERVER_REFERENCE_TAG
+    },
+    $$id: {
+      value: exportName === null ? id : id + '#' + exportName
+    },
+    $$bound: {
+      value: null
+    },
+    bind: {
+      value: bind
+    }
+  });
+}
+const PROMISE_PROTOTYPE = Promise.prototype;
+const deepProxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        // These names are a little too common. We should probably have a way to
+        // have the Flight runtime extract the inner target instead.
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+
+      case 'displayName':
+        return undefined;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case 'Provider':
+        throw new Error("Cannot render a Client Context Provider on the Server. " + "Instead, you can export a Client Component wrapper " + "that itself renders a Client Context Provider.");
+    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+    const expression = String(target.name) + '.' + String(name);
+    throw new Error("Cannot access " + expression + " on the server. " + 'You cannot dot into a client module from a server component. ' + 'You can only pass the imported name through.');
+  },
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+const proxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case '__esModule':
+        // Something is conditionally checking which export to use. We'll pretend to be
+        // an ESM compat module but then we'll check again on the client.
+        const moduleId = target.$$id;
+        target.default = registerClientReferenceImpl(function () {
+          throw new Error("Attempted to call the default export of " + moduleId + " from the server " + "but it's on the client. It's not possible to invoke a client function from " + "the server, it can only be rendered as a Component or passed to props of a " + "Client Component.");
+        }, target.$$id + '#', target.$$async);
+        return true;
+
+      case 'then':
+        if (target.then) {
+          // Use a cached value
+          return target.then;
+        }
+
+        if (!target.$$async) {
+          // If this module is expected to return a Promise (such as an AsyncModule) then
+          // we should resolve that with a client reference that unwraps the Promise on
+          // the client.
+          const clientReference = registerClientReferenceImpl({}, target.$$id, true);
+          const proxy = new Proxy(clientReference, proxyHandlers); // Treat this as a resolved Promise for React's use()
+
+          target.status = 'fulfilled';
+          target.value = proxy;
+          const then = target.then = registerClientReferenceImpl(function then(resolve, reject) {
+            // Expose to React.
+            return Promise.resolve(resolve(proxy));
+          }, // If this is not used as a Promise but is treated as a reference to a `.then`
+          // export then we should treat it as a reference to that name.
+          target.$$id + '#then', false);
+          return then;
+        } else {
+          // Since typeof .then === 'function' is a feature test we'd continue recursing
+          // indefinitely if we return a function. Instead, we return an object reference
+          // if we check further.
+          return undefined;
+        }
+
+    }
+
+    let cachedReference = target[name];
+
+    if (!cachedReference) {
+      const reference = registerClientReferenceImpl(function () {
+        throw new Error( // eslint-disable-next-line react-internal/safe-string-coercion
+        "Attempted to call " + String(name) + "() from the server but " + String(name) + " is on the client. " + "It's not possible to invoke a client function from the server, it can " + "only be rendered as a Component or passed to props of a Client Component.");
+      }, target.$$id + '#' + name, target.$$async);
+      Object.defineProperty(reference, 'name', {
+        value: name
+      });
+      cachedReference = target[name] = new Proxy(reference, deepProxyHandlers);
+    }
+
+    return cachedReference;
+  },
+
+  getPrototypeOf(target) {
+    // Pretend to be a Promise in case anyone asks.
+    return PROMISE_PROTOTYPE;
+  },
+
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+function createClientModuleProxy(moduleId) {
+  const clientReference = registerClientReferenceImpl({}, // Represents the whole Module object instead of a particular import.
+  moduleId, false);
+  return new Proxy(clientReference, proxyHandlers);
+}
+
+function getClientReferenceKey(reference) {
+  return reference.$$async ? reference.$$id + '#async' : reference.$$id;
+}
+function resolveClientReferenceMetadata(config, clientReference) {
+  const modulePath = clientReference.$$id;
+  let name = '';
+  let resolvedModuleData = config[modulePath];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = modulePath.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = modulePath.slice(idx + 1);
+      resolvedModuleData = config[modulePath.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + modulePath + '" in the React Client Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  }
+
+  if (clientReference.$$async === true) {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1];
+  } else {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+  }
+}
+function getServerReferenceId(config, serverReference) {
+  return serverReference.$$id;
+}
+function getServerReferenceBoundArguments(config, serverReference) {
+  return serverReference.$$bound;
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMFlightServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule: preloadModule$1,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+
+function prefetchDNS(href) {
+  {
+    if (typeof href === 'string' && href) {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'D|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        emitHint(request, 'D', href);
+      }
+    }
+  }
+}
+
+function preconnect(href, crossOrigin) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = "C|" + (crossOrigin == null ? 'null' : crossOrigin) + "|" + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+
+        if (typeof crossOrigin === 'string') {
+          emitHint(request, 'C', [href, crossOrigin]);
+        } else {
+          emitHint(request, 'C', href);
+        }
+      }
+    }
+  }
+}
+
+function preload(href, as, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        let key = 'L';
+
+        if (as === 'image' && options) {
+          key += getImagePreloadKey(href, options.imageSrcSet, options.imageSizes);
+        } else {
+          key += "[" + as + "]" + href;
+        }
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          emitHint(request, 'L', [href, as, trimmed]);
+        } else {
+          emitHint(request, 'L', [href, as]);
+        }
+      }
+    }
+  }
+}
+
+function preloadModule$1(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'm|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'm', [href, trimmed]);
+        } else {
+          return emitHint(request, 'm', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'S|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'S', [href, typeof precedence === 'string' ? precedence : 0, trimmed]);
+        } else if (typeof precedence === 'string') {
+          return emitHint(request, 'S', [href, precedence]);
+        } else {
+          return emitHint(request, 'S', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'X|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'X', [href, trimmed]);
+        } else {
+          return emitHint(request, 'X', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitModuleScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'M|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'M', [href, trimmed]);
+        } else {
+          return emitHint(request, 'M', href);
+        }
+      }
+    }
+  }
+} // Flight normally encodes undefined as a special character however for directive option
+// arguments we don't want to send unnecessary keys and bloat the payload so we create a
+// trimmed object which omits any keys with null or undefined values.
+// This is only typesafe because these option objects have entirely optional fields where
+// null and undefined represent the same thing as no property.
+
+
+function trimOptions(options) {
+  if (options == null) return null;
+  let hasProperties = false;
+  const trimmed = {};
+
+  for (const key in options) {
+    if (options[key] != null) {
+      hasProperties = true;
+      trimmed[key] = options[key];
+    }
+  }
+
+  return hasProperties ? trimmed : null;
+}
+
+function getImagePreloadKey(href, imageSrcSet, imageSizes) {
+  let uniquePart = '';
+
+  if (typeof imageSrcSet === 'string' && imageSrcSet !== '') {
+    uniquePart += '[' + imageSrcSet + ']';
+
+    if (typeof imageSizes === 'string') {
+      uniquePart += '[' + imageSizes + ']';
+    }
+  } else {
+    uniquePart += '[][]' + href;
+  }
+
+  return "[image]" + uniquePart;
+}
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMFlightServerDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+// small, smaller than how we encode undefined, and is unambiguous. We could use
+// a different tuple structure to encode this instead but this makes the runtime
+// cost cheaper by eliminating a type checks in more positions.
+// prettier-ignore
+
+function createHints() {
+  return new Set();
+}
+
+const requestStorage = new async_hooks.AsyncLocalStorage();
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext); // On the way back, we push the new ones that weren't common.
+
+      pushNode(next);
+    }
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function pushProvider(context, nextValue) {
+  let prevValue;
+
+  {
+    prevValue = context._currentValue;
+    context._currentValue = nextValue;
+  }
+
+  const prevNode = currentActiveSnapshot;
+  const newNode = {
+    parent: prevNode,
+    depth: prevNode === null ? 0 : prevNode.depth + 1,
+    context: context,
+    parentValue: prevValue,
+    value: nextValue
+  };
+  currentActiveSnapshot = newNode;
+  return newNode;
+}
+function popProvider() {
+  const prevSnapshot = currentActiveSnapshot;
+
+  if (prevSnapshot === null) {
+    throw new Error('Tried to pop a Context at the root of the app. This is a bug in React.');
+  }
+
+  {
+    const value = prevSnapshot.parentValue;
+
+    if (value === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      prevSnapshot.context._currentValue = prevSnapshot.context._defaultValue;
+    } else {
+      prevSnapshot.context._currentValue = value;
+    }
+  }
+
+  return currentActiveSnapshot = prevSnapshot.parent;
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFizzWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop, noop);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+let currentRequest$1 = null;
+let thenableIndexCounter = 0;
+let thenableState = null;
+function prepareToUseHooksForRequest(request) {
+  currentRequest$1 = request;
+}
+function resetHooksForRequest() {
+  currentRequest$1 = null;
+}
+function prepareToUseHooksForComponent(prevThenableState) {
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+const HooksDispatcher = {
+  useMemo(nextCreate) {
+    return nextCreate();
+  },
+
+  useCallback(callback) {
+    return callback;
+  },
+
+  useDebugValue() {},
+
+  useDeferredValue: unsupportedHook,
+  useTransition: unsupportedHook,
+  readContext,
+  useContext: readContext,
+  useReducer: unsupportedHook,
+  useRef: unsupportedHook,
+  useState: unsupportedHook,
+  useInsertionEffect: unsupportedHook,
+  useLayoutEffect: unsupportedHook,
+  useImperativeHandle: unsupportedHook,
+  useEffect: unsupportedHook,
+  useId,
+  useSyncExternalStore: unsupportedHook,
+
+  useCacheRefresh() {
+    return unsupportedRefresh;
+  },
+
+  useMemoCache(size) {
+    const data = new Array(size);
+
+    for (let i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL;
+    }
+
+    return data;
+  },
+
+  use
+};
+
+function unsupportedHook() {
+  throw new Error('This Hook is not supported in Server Components.');
+}
+
+function unsupportedRefresh() {
+  throw new Error('Refreshing the cache is not supported in Server Components.');
+}
+
+function useId() {
+  if (currentRequest$1 === null) {
+    throw new Error('useId can only be used while React is rendering');
+  }
+
+  const id = currentRequest$1.identifierCount++; // use 'S' for Flight components to distinguish from 'R' and 'r' in Fizz/Client
+
+  return ':' + currentRequest$1.identifierPrefix + 'S' + id.toString(32) + ':';
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object' || typeof usable === 'function') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable; // Track the position of the thenable within this fiber.
+
+      const index = thenableIndexCounter;
+      thenableIndexCounter += 1;
+
+      if (thenableState === null) {
+        thenableState = createThenableState();
+      }
+
+      return trackUsedThenable(thenableState, thenable, index);
+    } else if (usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  }
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function createSignal() {
+  return new AbortController().signal;
+}
+
+function resolveCache() {
+  const request = resolveRequest();
+
+  if (request) {
+    return getCache(request);
+  }
+
+  return new Map();
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal() {
+    const cache = resolveCache();
+    let entry = cache.get(createSignal);
+
+    if (entry === undefined) {
+      entry = createSignal();
+      cache.set(createSignal, entry);
+    }
+
+    return entry;
+  },
+
+  getCacheForType(resourceType) {
+    const cache = resolveCache();
+    let entry = cache.get(resourceType);
+
+    if (entry === undefined) {
+      entry = resourceType(); // TODO: Warn if undefined?
+
+      cache.set(resourceType, entry);
+    }
+
+    return entry;
+  }
+
+};
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+function objectName(object) {
+  // $FlowFixMe[method-unbinding]
+  const name = Object.prototype.toString.call(object);
+  return name.replace(/^\[object (.*)\]$/, function (m, p0) {
+    return p0;
+  });
+}
+
+function describeKeyForErrorMessage(key) {
+  const encodedKey = JSON.stringify(key);
+  return '"' + key + '"' === encodedKey ? key : encodedKey;
+}
+
+function describeValueForErrorMessage(value) {
+  switch (typeof value) {
+    case 'string':
+      {
+        return JSON.stringify(value.length <= 10 ? value : value.slice(0, 10) + '...');
+      }
+
+    case 'object':
+      {
+        if (isArray(value)) {
+          return '[...]';
+        }
+
+        const name = objectName(value);
+
+        if (name === 'Object') {
+          return '{...}';
+        }
+
+        return name;
+      }
+
+    case 'function':
+      return 'function';
+
+    default:
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      return String(value);
+  }
+}
+
+function describeElementType(type) {
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        return describeElementType(type.render);
+
+      case REACT_MEMO_TYPE:
+        return describeElementType(type.type);
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            // Lazy may contain any component type so we recursively resolve it.
+            return describeElementType(init(payload));
+          } catch (x) {}
+        }
+    }
+  }
+
+  return '';
+}
+
+function describeObjectForErrorMessage(objectOrArray, expandedName) {
+  const objKind = objectName(objectOrArray);
+
+  if (objKind !== 'Object' && objKind !== 'Array') {
+    return objKind;
+  }
+
+  let str = '';
+  let start = -1;
+  let length = 0;
+
+  if (isArray(objectOrArray)) {
+    {
+      // Print Array
+      str = '[';
+      const array = objectOrArray;
+
+      for (let i = 0; i < array.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const value = array[i];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if ('' + i === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += ']';
+    }
+  } else {
+    if (objectOrArray.$$typeof === REACT_ELEMENT_TYPE) {
+      str = '<' + describeElementType(objectOrArray.type) + '/>';
+    } else {
+      // Print Object
+      str = '{';
+      const object = objectOrArray;
+      const names = Object.keys(object);
+
+      for (let i = 0; i < names.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const name = names[i];
+        str += describeKeyForErrorMessage(name) + ': ';
+        const value = object[name];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if (name === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += '}';
+    }
+  }
+
+  if (expandedName === undefined) {
+    return str;
+  }
+
+  if (start > -1 && length > 0) {
+    const highlight = ' '.repeat(start) + '^'.repeat(length);
+    return '\n  ' + str + '\n  ' + highlight;
+  }
+
+  return '\n  ' + str;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ReactSharedServerInternals = // $FlowFixMe: It's defined in the one we resolve to.
+React.__SECRET_SERVER_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+if (!ReactSharedServerInternals) {
+  throw new Error('The "react" package in this environment is not configured correctly. ' + 'The "react-server" condition must be enabled in any environment that ' + 'runs React Server Components.');
+}
+
+// Turns a TypedArray or ArrayBuffer into a string that can be used for comparison
+// in a Map to see if the bytes are the same.
+function binaryToComparableString(view) {
+  return String.fromCharCode.apply(String, new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+}
+
+const ObjectPrototype = Object.prototype;
+const stringify = JSON.stringify; // Serializable values
+// Thenable<ReactClientValue>
+
+const PENDING$1 = 0;
+const COMPLETED = 1;
+const ABORTED = 3;
+const ERRORED$1 = 4;
+const TaintRegistryObjects = ReactSharedServerInternals.TaintRegistryObjects,
+      TaintRegistryValues = ReactSharedServerInternals.TaintRegistryValues,
+      TaintRegistryByteLengths = ReactSharedServerInternals.TaintRegistryByteLengths,
+      TaintRegistryPendingRequests = ReactSharedServerInternals.TaintRegistryPendingRequests,
+      ReactCurrentCache = ReactSharedServerInternals.ReactCurrentCache;
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+
+function throwTaintViolation(message) {
+  // eslint-disable-next-line react-internal/prod-error-codes
+  throw new Error(message);
+}
+
+function cleanupTaintQueue(request) {
+  const cleanupQueue = request.taintCleanupQueue;
+  TaintRegistryPendingRequests.delete(cleanupQueue);
+
+  for (let i = 0; i < cleanupQueue.length; i++) {
+    const entryValue = cleanupQueue[i];
+    const entry = TaintRegistryValues.get(entryValue);
+
+    if (entry !== undefined) {
+      if (entry.count === 1) {
+        TaintRegistryValues.delete(entryValue);
+      } else {
+        entry.count--;
+      }
+    }
+  }
+
+  cleanupQueue.length = 0;
+}
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+}
+
+function defaultPostponeHandler(reason) {// Noop
+}
+
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2;
+function createRequest(model, bundlerConfig, onError, context, identifierPrefix, onPostpone) {
+  if (ReactCurrentCache.current !== null && ReactCurrentCache.current !== DefaultCacheDispatcher) {
+    throw new Error('Currently React only supports one RSC renderer at a time.');
+  }
+
+  prepareHostDispatcher();
+  ReactCurrentCache.current = DefaultCacheDispatcher;
+  const abortSet = new Set();
+  const pingedTasks = [];
+  const cleanupQueue = [];
+
+  {
+    TaintRegistryPendingRequests.add(cleanupQueue);
+  }
+
+  const hints = createHints();
+  const request = {
+    status: OPEN,
+    flushScheduled: false,
+    fatalError: null,
+    destination: null,
+    bundlerConfig,
+    cache: new Map(),
+    nextChunkId: 0,
+    pendingChunks: 0,
+    hints,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    completedImportChunks: [],
+    completedHintChunks: [],
+    completedRegularChunks: [],
+    completedErrorChunks: [],
+    writtenSymbols: new Map(),
+    writtenClientReferences: new Map(),
+    writtenServerReferences: new Map(),
+    writtenProviders: new Map(),
+    writtenObjects: new WeakMap(),
+    identifierPrefix: identifierPrefix || '',
+    identifierCount: 1,
+    taintCleanupQueue: cleanupQueue,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? defaultPostponeHandler : onPostpone,
+    // $FlowFixMe[missing-this-annot]
+    toJSON: function (key, value) {
+      return resolveModelToJSON(request, this, key, value);
+    }
+  };
+  request.pendingChunks++;
+  const rootContext = createRootContext(context);
+  const rootTask = createTask(request, model, rootContext, abortSet);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  {
+    const store = requestStorage.getStore();
+    if (store) return store;
+  }
+
+  return null;
+}
+
+function createRootContext(reqContext) {
+  return importServerContexts(reqContext);
+}
+
+const POP = {};
+
+function serializeThenable(request, thenable) {
+  request.pendingChunks++;
+  const newTask = createTask(request, null, getActiveContext(), request.abortableTasks);
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        // We have the resolved value, we can go ahead and schedule it for serialization.
+        newTask.model = thenable.value;
+        pingTask(request, newTask);
+        return newTask.id;
+      }
+
+    case 'rejected':
+      {
+        const x = thenable.reason;
+
+        if (typeof x === 'object' && x !== null && x.$$typeof === REACT_POSTPONE_TYPE) {
+          const postponeInstance = x;
+          logPostpone(request, postponeInstance.message);
+          emitPostponeChunk(request, newTask.id);
+        } else {
+          const digest = logRecoverableError(request, x);
+          emitErrorChunk(request, newTask.id, digest);
+        }
+
+        return newTask.id;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  thenable.then(value => {
+    newTask.model = value;
+    pingTask(request, newTask);
+  }, reason => {
+    newTask.status = ERRORED$1;
+    request.abortableTasks.delete(newTask); // TODO: We should ideally do this inside performWork so it's scheduled
+
+    const digest = logRecoverableError(request, reason);
+    emitErrorChunk(request, newTask.id, digest);
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  });
+  return newTask.id;
+}
+
+function emitHint(request, code, model) {
+  emitHintChunk(request, code, model);
+  enqueueFlush(request);
+}
+function getHints(request) {
+  return request.hints;
+}
+function getCache(request) {
+  return request.cache;
+}
+
+function readThenable(thenable) {
+  if (thenable.status === 'fulfilled') {
+    return thenable.value;
+  } else if (thenable.status === 'rejected') {
+    throw thenable.reason;
+  }
+
+  throw thenable;
+}
+
+function createLazyWrapperAroundWakeable(wakeable) {
+  // This is a temporary fork of the `use` implementation until we accept
+  // promises everywhere.
+  const thenable = wakeable;
+
+  switch (thenable.status) {
+    case 'fulfilled':
+    case 'rejected':
+      break;
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: thenable,
+    _init: readThenable
+  };
+  return lazyType;
+}
+
+function attemptResolveElement(request, type, key, ref, props, prevThenableState) {
+  if (ref !== null && ref !== undefined) {
+    // When the ref moves to the regular props object this will implicitly
+    // throw for functions. We could probably relax it to a DEV warning for other
+    // cases.
+    throw new Error('Refs cannot be used in Server Components, nor passed to Client Components.');
+  }
+
+  if (typeof type === 'function') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    } // This is a server-side component.
+
+
+    prepareToUseHooksForComponent(prevThenableState);
+    const result = type(props);
+
+    if (typeof result === 'object' && result !== null && typeof result.then === 'function') {
+      // When the return value is in children position we can resolve it immediately,
+      // to its value without a wrapper if it's synchronously available.
+      const thenable = result;
+
+      if (thenable.status === 'fulfilled') {
+        return thenable.value;
+      } // TODO: Once we accept Promises as children on the client, we can just return
+      // the thenable here.
+
+
+      return createLazyWrapperAroundWakeable(result);
+    }
+
+    return result;
+  } else if (typeof type === 'string') {
+    // This is a host element. E.g. HTML.
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (typeof type === 'symbol') {
+    if (type === REACT_FRAGMENT_TYPE) {
+      // For key-less fragments, we add a small optimization to avoid serializing
+      // it as a wrapper.
+      // TODO: If a key is specified, we should propagate its key to any children.
+      // Same as if a Server Component has a key.
+      return props.children;
+    } // This might be a built-in React component. We'll let the client decide.
+    // Any built-in works as long as its props are serializable.
+
+
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (type != null && typeof type === 'object') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    }
+
+    switch (type.$$typeof) {
+      case REACT_LAZY_TYPE:
+        {
+          const payload = type._payload;
+          const init = type._init;
+          const wrappedType = init(payload);
+          return attemptResolveElement(request, wrappedType, key, ref, props, prevThenableState);
+        }
+
+      case REACT_FORWARD_REF_TYPE:
+        {
+          const render = type.render;
+          prepareToUseHooksForComponent(prevThenableState);
+          return render(props, undefined);
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          return attemptResolveElement(request, type.type, key, ref, props, prevThenableState);
+        }
+
+      case REACT_PROVIDER_TYPE:
+        {
+          {
+            pushProvider(type._context, props.value);
+
+            return [REACT_ELEMENT_TYPE, type, key, // Rely on __popProvider being serialized last to pop the provider.
+            {
+              value: props.value,
+              children: props.children,
+              __pop: POP
+            }];
+          } // Fallthrough
+
+        }
+    }
+  }
+
+  throw new Error("Unsupported Server Component type: " + describeValueForErrorMessage(type));
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createTask(request, model, context, abortSet) {
+  const id = request.nextChunkId++;
+  const task = {
+    id,
+    status: PENDING$1,
+    model,
+    context,
+    ping: () => pingTask(request, task),
+    thenableState: null
+  };
+  abortSet.add(task);
+  return task;
+}
+
+function serializeByValueID(id) {
+  return '$' + id.toString(16);
+}
+
+function serializeLazyID(id) {
+  return '$L' + id.toString(16);
+}
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeProviderReference(name) {
+  return '$P' + name;
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeRowHeader(tag, id) {
+  return id.toString(16) + ':' + tag;
+}
+
+function encodeReferenceChunk(request, id, reference) {
+  const json = stringify(reference);
+  const row = id.toString(16) + ':' + json + '\n';
+  return stringToChunk(row);
+}
+
+function serializeClientReference(request, parent, key, clientReference) {
+  const clientReferenceKey = getClientReferenceKey(clientReference);
+  const writtenClientReferences = request.writtenClientReferences;
+  const existingId = writtenClientReferences.get(clientReferenceKey);
+
+  if (existingId !== undefined) {
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(existingId);
+    }
+
+    return serializeByValueID(existingId);
+  }
+
+  try {
+    const clientReferenceMetadata = resolveClientReferenceMetadata(request.bundlerConfig, clientReference);
+    request.pendingChunks++;
+    const importId = request.nextChunkId++;
+    emitImportChunk(request, importId, clientReferenceMetadata);
+    writtenClientReferences.set(clientReferenceKey, importId);
+
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(importId);
+    }
+
+    return serializeByValueID(importId);
+  } catch (x) {
+    request.pendingChunks++;
+    const errorId = request.nextChunkId++;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, errorId, digest);
+    return serializeByValueID(errorId);
+  }
+}
+
+function outlineModel(request, value) {
+  request.pendingChunks++;
+  const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+  retryTask(request, newTask);
+  return newTask.id;
+}
+
+function serializeServerReference(request, parent, key, serverReference) {
+  const writtenServerReferences = request.writtenServerReferences;
+  const existingId = writtenServerReferences.get(serverReference);
+
+  if (existingId !== undefined) {
+    return serializeServerReferenceID(existingId);
+  }
+
+  const bound = getServerReferenceBoundArguments(request.bundlerConfig, serverReference);
+  const serverReferenceMetadata = {
+    id: getServerReferenceId(request.bundlerConfig, serverReference),
+    bound: bound ? Promise.resolve(bound) : null
+  };
+  const metadataId = outlineModel(request, serverReferenceMetadata);
+  writtenServerReferences.set(serverReference, metadataId);
+  return serializeServerReferenceID(metadataId);
+}
+
+function serializeLargeTextString(request, text) {
+  request.pendingChunks += 2;
+  const textId = request.nextChunkId++;
+  const textChunk = stringToChunk(text);
+  const binaryLength = byteLengthOfChunk(textChunk);
+  const row = textId.toString(16) + ':T' + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, textChunk);
+  return serializeByValueID(textId);
+}
+
+function serializeMap(request, map) {
+  const entries = Array.from(map);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i][0];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$Q' + id.toString(16);
+}
+
+function serializeSet(request, set) {
+  const entries = Array.from(set);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$W' + id.toString(16);
+}
+
+function serializeTypedArray(request, tag, typedArray) {
+  {
+    if (TaintRegistryByteLengths.has(typedArray.byteLength)) {
+      // If we have had any tainted values of this length, we check
+      // to see if these bytes matches any entries in the registry.
+      const tainted = TaintRegistryValues.get(binaryToComparableString(typedArray));
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    }
+  }
+
+  request.pendingChunks += 2;
+  const bufferId = request.nextChunkId++; // TODO: Convert to little endian if that's not the server default.
+
+  const binaryChunk = typedArrayToBinaryChunk(typedArray);
+  const binaryLength = byteLengthOfBinaryChunk(binaryChunk);
+  const row = bufferId.toString(16) + ':' + tag + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, binaryChunk);
+  return serializeByValueID(bufferId);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+let modelRoot = false;
+
+function resolveModelToJSON(request, parent, key, value) {
+
+
+  switch (value) {
+    case REACT_ELEMENT_TYPE:
+      return '$';
+  }
+
+
+  while (typeof value === 'object' && value !== null && (value.$$typeof === REACT_ELEMENT_TYPE || value.$$typeof === REACT_LAZY_TYPE)) {
+
+    try {
+      switch (value.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const writtenObjects = request.writtenObjects;
+            const existingId = writtenObjects.get(value);
+
+            if (existingId !== undefined) {
+              if (existingId === -1) {
+                // Seen but not yet outlined.
+                const newId = outlineModel(request, value);
+                return serializeByValueID(newId);
+              } else if (modelRoot === value) {
+                // This is the ID we're currently emitting so we need to write it
+                // once but if we discover it again, we refer to it by id.
+                modelRoot = null;
+              } else {
+                // We've already emitted this as an outlined object, so we can
+                // just refer to that by its existing ID.
+                return serializeByValueID(existingId);
+              }
+            } else {
+              // This is the first time we've seen this object. We may never see it again
+              // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+              writtenObjects.set(value, -1);
+            } // TODO: Concatenate keys of parents onto children.
+
+
+            const element = value; // Attempt to render the Server Component.
+
+            value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, null);
+            break;
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = value._payload;
+            const init = value._init;
+            value = init(payload);
+            break;
+          }
+      }
+    } catch (thrownValue) {
+      const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          // Something suspended, we'll need to create a new task and resolve it later.
+          request.pendingChunks++;
+          const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+          const ping = newTask.ping;
+          x.then(ping, ping);
+          newTask.thenableState = getThenableStateAfterSuspending();
+          return serializeLazyID(newTask.id);
+        } else if (x.$$typeof === REACT_POSTPONE_TYPE) {
+          // Something postponed. We'll still send everything we have up until this point.
+          // We'll replace this element with a lazy reference that postpones on the client.
+          const postponeInstance = x;
+          request.pendingChunks++;
+          const postponeId = request.nextChunkId++;
+          logPostpone(request, postponeInstance.message);
+          emitPostponeChunk(request, postponeId);
+          return serializeLazyID(postponeId);
+        }
+      } // Something errored. We'll still send everything we have up until this point.
+      // We'll replace this element with a lazy reference that throws on the client
+      // once it gets rendered.
+
+
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+      const digest = logRecoverableError(request, x);
+      emitErrorChunk(request, errorId, digest);
+      return serializeLazyID(errorId);
+    }
+  }
+
+  if (value === null) {
+    return null;
+  }
+
+  if (typeof value === 'object') {
+    {
+      const tainted = TaintRegistryObjects.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted);
+      }
+    }
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    const writtenObjects = request.writtenObjects;
+    const existingId = writtenObjects.get(value); // $FlowFixMe[method-unbinding]
+
+    if (typeof value.then === 'function') {
+      if (existingId !== undefined) {
+        if (modelRoot === value) {
+          // This is the ID we're currently emitting so we need to write it
+          // once but if we discover it again, we refer to it by id.
+          modelRoot = null;
+        } else {
+          // We've seen this promise before, so we can just refer to the same result.
+          return serializePromiseID(existingId);
+        }
+      } // We assume that any object with a .then property is a "Thenable" type,
+      // or a Promise type. Either of which can be represented by a Promise.
+
+
+      const promiseId = serializeThenable(request, value);
+      writtenObjects.set(value, promiseId);
+      return serializePromiseID(promiseId);
+    }
+
+    {
+      if (value.$$typeof === REACT_PROVIDER_TYPE) {
+        const providerKey = value._context._globalName;
+        const writtenProviders = request.writtenProviders;
+        let providerId = writtenProviders.get(key);
+
+        if (providerId === undefined) {
+          request.pendingChunks++;
+          providerId = request.nextChunkId++;
+          writtenProviders.set(providerKey, providerId);
+          emitProviderChunk(request, providerId, providerKey);
+        }
+
+        return serializeByValueID(providerId);
+      } else if (value === POP) {
+        popProvider();
+
+        return undefined;
+      }
+    }
+
+    if (existingId !== undefined) {
+      if (existingId === -1) {
+        // Seen but not yet outlined.
+        const newId = outlineModel(request, value);
+        return serializeByValueID(newId);
+      } else if (modelRoot === value) {
+        // This is the ID we're currently emitting so we need to write it
+        // once but if we discover it again, we refer to it by id.
+        modelRoot = null;
+      } else {
+        // We've already emitted this as an outlined object, so we can
+        // just refer to that by its existing ID.
+        return serializeByValueID(existingId);
+      }
+    } else {
+      // This is the first time we've seen this object. We may never see it again
+      // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+      writtenObjects.set(value, -1);
+    }
+
+    if (isArray(value)) {
+      // $FlowFixMe[incompatible-return]
+      return value;
+    }
+
+    if (value instanceof Map) {
+      return serializeMap(request, value);
+    }
+
+    if (value instanceof Set) {
+      return serializeSet(request, value);
+    }
+
+    {
+      if (value instanceof ArrayBuffer) {
+        return serializeTypedArray(request, 'A', new Uint8Array(value));
+      }
+
+      if (value instanceof Int8Array) {
+        // char
+        return serializeTypedArray(request, 'C', value);
+      }
+
+      if (value instanceof Uint8Array) {
+        // unsigned char
+        return serializeTypedArray(request, 'c', value);
+      }
+
+      if (value instanceof Uint8ClampedArray) {
+        // unsigned clamped char
+        return serializeTypedArray(request, 'U', value);
+      }
+
+      if (value instanceof Int16Array) {
+        // sort
+        return serializeTypedArray(request, 'S', value);
+      }
+
+      if (value instanceof Uint16Array) {
+        // unsigned short
+        return serializeTypedArray(request, 's', value);
+      }
+
+      if (value instanceof Int32Array) {
+        // long
+        return serializeTypedArray(request, 'L', value);
+      }
+
+      if (value instanceof Uint32Array) {
+        // unsigned long
+        return serializeTypedArray(request, 'l', value);
+      }
+
+      if (value instanceof Float32Array) {
+        // float
+        return serializeTypedArray(request, 'F', value);
+      }
+
+      if (value instanceof Float64Array) {
+        // double
+        return serializeTypedArray(request, 'D', value);
+      }
+
+      if (value instanceof BigInt64Array) {
+        // number
+        return serializeTypedArray(request, 'N', value);
+      }
+
+      if (value instanceof BigUint64Array) {
+        // unsigned number
+        // We use "m" instead of "n" since JSON can start with "null"
+        return serializeTypedArray(request, 'm', value);
+      }
+
+      if (value instanceof DataView) {
+        return serializeTypedArray(request, 'V', value);
+      }
+    }
+
+    const iteratorFn = getIteratorFn(value);
+
+    if (iteratorFn) {
+      return Array.from(value);
+    } // Verify that this is a simple plain object.
+
+
+    const proto = getPrototypeOf(value);
+
+    if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+      throw new Error('Only plain objects, and a few built-ins, can be passed to Client Components ' + 'from Server Components. Classes or null prototypes are not supported.');
+    }
+
+
+    return value;
+  }
+
+  if (typeof value === 'string') {
+    {
+      const tainted = TaintRegistryValues.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    } // TODO: Maybe too clever. If we support URL there's no similar trick.
+
+
+    if (value[value.length - 1] === 'Z') {
+      // Possibly a Date, whose toJSON automatically calls toISOString
+      // $FlowFixMe[incompatible-use]
+      const originalValue = parent[key];
+
+      if (originalValue instanceof Date) {
+        return serializeDateFromDateJSON(value);
+      }
+    }
+
+    if (value.length >= 1024) {
+      // For large strings, we encode them outside the JSON payload so that we
+      // don't have to double encode and double parse the strings. This can also
+      // be more compact in case the string has a lot of escaped characters.
+      return serializeLargeTextString(request, value);
+    }
+
+    return escapeStringValue(value);
+  }
+
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  if (typeof value === 'number') {
+    return serializeNumber(value);
+  }
+
+  if (typeof value === 'undefined') {
+    return serializeUndefined();
+  }
+
+  if (typeof value === 'function') {
+    {
+      const tainted = TaintRegistryObjects.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted);
+      }
+    }
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    if (isServerReference(value)) {
+      return serializeServerReference(request, parent, key, value);
+    }
+
+    if (/^on[A-Z]/.test(key)) {
+      throw new Error('Event handlers cannot be passed to Client Component props.' + describeObjectForErrorMessage(parent, key) + '\nIf you need interactivity, consider converting part of this to a Client Component.');
+    } else {
+      throw new Error('Functions cannot be passed directly to Client Components ' + 'unless you explicitly expose it by marking it with "use server".' + describeObjectForErrorMessage(parent, key));
+    }
+  }
+
+  if (typeof value === 'symbol') {
+    const writtenSymbols = request.writtenSymbols;
+    const existingId = writtenSymbols.get(value);
+
+    if (existingId !== undefined) {
+      return serializeByValueID(existingId);
+    } // $FlowFixMe[incompatible-type] `description` might be undefined
+
+
+    const name = value.description;
+
+    if (Symbol.for(name) !== value) {
+      throw new Error('Only global symbols received from Symbol.for(...) can be passed to Client Components. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+      value.description + ") cannot be found among global symbols.") + describeObjectForErrorMessage(parent, key));
+    }
+
+    request.pendingChunks++;
+    const symbolId = request.nextChunkId++;
+    emitSymbolChunk(request, symbolId, name);
+    writtenSymbols.set(value, symbolId);
+    return serializeByValueID(symbolId);
+  }
+
+  if (typeof value === 'bigint') {
+    {
+      const tainted = TaintRegistryValues.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    }
+
+    return serializeBigInt(value);
+  }
+
+  throw new Error("Type " + typeof value + " is not supported in Client Component props." + describeObjectForErrorMessage(parent, key));
+}
+
+function logPostpone(request, reason) {
+  const onPostpone = request.onPostpone;
+  onPostpone(reason);
+}
+
+function logRecoverableError(request, error) {
+  const onError = request.onError;
+  const errorDigest = onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest || '';
+}
+
+function fatalError(request, error) {
+  {
+    cleanupTaintQueue(request);
+  } // This is called outside error handling code such as if an error happens in React internals.
+
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function emitPostponeChunk(request, id, postponeInstance) {
+  let row;
+
+  {
+    // No reason included in prod.
+    row = serializeRowHeader('P', id) + '\n';
+  }
+
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitErrorChunk(request, id, digest, error) {
+  let errorInfo;
+
+  {
+    errorInfo = {
+      digest
+    };
+  }
+
+  const row = serializeRowHeader('E', id) + stringify(errorInfo) + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitImportChunk(request, id, clientReferenceMetadata) {
+  // $FlowFixMe[incompatible-type] stringify can return null
+  const json = stringify(clientReferenceMetadata);
+  const row = serializeRowHeader('I', id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitHintChunk(request, code, model) {
+  const json = stringify(model);
+  const id = request.nextChunkId++;
+  const row = serializeRowHeader('H' + code, id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedHintChunks.push(processedChunk);
+}
+
+function emitSymbolChunk(request, id, name) {
+  const symbolReference = serializeSymbolReference(name);
+  const processedChunk = encodeReferenceChunk(request, id, symbolReference);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitProviderChunk(request, id, contextName) {
+  const contextReference = serializeProviderReference(contextName);
+  const processedChunk = encodeReferenceChunk(request, id, contextReference);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function emitModelChunk(request, id, model) {
+  // Track the root so we know that we have to emit this object even though it
+  // already has an ID. This is needed because we might see this object twice
+  // in the same toJSON if it is cyclic.
+  modelRoot = model; // $FlowFixMe[incompatible-type] stringify can return null
+
+  const json = stringify(model, request.toJSON);
+  const row = id.toString(16) + ':' + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function retryTask(request, task) {
+  if (task.status !== PENDING$1) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  }
+
+  switchContext(task.context);
+
+  try {
+    let value = task.model;
+
+    if (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+      request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+      const element = value; // When retrying a component, reuse the thenableState from the
+      // previous attempt.
+
+      const prevThenableState = task.thenableState; // Attempt to render the Server Component.
+      // Doing this here lets us reuse this same task if the next component
+      // also suspends.
+
+      task.model = value;
+      value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, prevThenableState); // Successfully finished this component. We're going to keep rendering
+      // using the same task, but we reset its thenable state before continuing.
+
+      task.thenableState = null; // Keep rendering and reuse the same task. This inner loop is separate
+      // from the render above because we don't need to reset the thenable state
+      // until the next time something suspends and retries.
+
+      while (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+        request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+        const nextElement = value;
+        task.model = value;
+        value = attemptResolveElement(request, nextElement.type, nextElement.key, nextElement.ref, nextElement.props, null);
+      }
+    } // Track that this object is outlined and has an id.
+
+
+    if (typeof value === 'object' && value !== null) {
+      request.writtenObjects.set(value, task.id);
+    }
+
+    emitModelChunk(request, task.id, value);
+    request.abortableTasks.delete(task);
+    task.status = COMPLETED;
+  } catch (thrownValue) {
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      } else if (x.$$typeof === REACT_POSTPONE_TYPE) {
+        request.abortableTasks.delete(task);
+        task.status = ERRORED$1;
+        const postponeInstance = x;
+        logPostpone(request, postponeInstance.message);
+        emitPostponeChunk(request, task.id);
+        return;
+      }
+    }
+
+    request.abortableTasks.delete(task);
+    task.status = ERRORED$1;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, task.id, digest);
+  }
+}
+
+function performWork(request) {
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  const prevRequest = currentRequest;
+  currentRequest = request;
+  prepareToUseHooksForRequest(request);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    request.pingedTasks = [];
+
+    for (let i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    ReactCurrentDispatcher.current = prevDispatcher;
+    resetHooksForRequest();
+    currentRequest = prevRequest;
+  }
+}
+
+function abortTask(task, request, errorId) {
+  task.status = ABORTED; // Instead of emitting an error per task.id, we emit a model that only
+  // has a single value referencing the error.
+
+  const ref = serializeByValueID(errorId);
+  const processedChunk = encodeReferenceChunk(request, task.id, ref);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function flushCompletedChunks(request, destination) {
+  beginWriting();
+
+  try {
+    // We emit module chunks first in the stream so that
+    // they can be preloaded as early as possible.
+    const importsChunks = request.completedImportChunks;
+    let i = 0;
+
+    for (; i < importsChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = importsChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    importsChunks.splice(0, i); // Next comes hints.
+
+    const hintChunks = request.completedHintChunks;
+    i = 0;
+
+    for (; i < hintChunks.length; i++) {
+      const chunk = hintChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    hintChunks.splice(0, i); // Next comes model data.
+
+    const regularChunks = request.completedRegularChunks;
+    i = 0;
+
+    for (; i < regularChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = regularChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    regularChunks.splice(0, i); // Finally, errors are sent. The idea is that it's ok to delay
+    // any error messages and prioritize display of other parts of
+    // the page.
+
+    const errorChunks = request.completedErrorChunks;
+    i = 0;
+
+    for (; i < errorChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = errorChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    errorChunks.splice(0, i);
+  } finally {
+    request.flushScheduled = false;
+    completeWriting(destination);
+  }
+
+  flushBuffered(destination);
+
+  if (request.pendingChunks === 0) {
+    // We're done.
+    {
+      cleanupTaintQueue(request);
+    }
+
+    close$1(destination);
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  {
+    scheduleWork(() => requestStorage.run(request, performWork, request));
+  }
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    const destination = request.destination;
+    request.flushScheduled = true;
+    scheduleWork(() => flushCompletedChunks(request, destination));
+  }
+}
+
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedChunks(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      // We have tasks to abort. We'll emit one error row and then emit a reference
+      // to that row from every row that's still remaining.
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+
+      if (enablePostpone && typeof reason === 'object' && reason !== null && reason.$$typeof === REACT_POSTPONE_TYPE) {
+        const postponeInstance = reason;
+        logPostpone(request, postponeInstance.message);
+        emitPostponeChunk(request, errorId, postponeInstance);
+      } else {
+        const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+        const digest = logRecoverableError(request, error);
+        emitErrorChunk(request, errorId, digest, error);
+      }
+
+      abortableTasks.forEach(task => abortTask(task, request, errorId));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function importServerContexts(contexts) {
+  if (contexts) {
+    const prevContext = getActiveContext();
+    switchContext(rootContextSnapshot);
+
+    for (let i = 0; i < contexts.length; i++) {
+      const _contexts$i = contexts[i],
+            name = _contexts$i[0],
+            value = _contexts$i[1];
+      const context = getOrCreateServerContext(name);
+      pushProvider(context, value);
+    }
+
+    const importedContext = getActiveContext();
+    switchContext(prevContext);
+    return importedContext;
+  }
+
+  return rootContextSnapshot;
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+function resolveServerReference(bundlerConfig, id) {
+  let name = '';
+  let resolvedModuleData = bundlerConfig[id];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = id.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = id.slice(idx + 1);
+      resolvedModuleData = bundlerConfig[id.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + id + '" in the React Server Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  } // TODO: This needs to return async: true if it's an async module.
+
+
+  return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+} // The chunk cache contains all the chunks we've preloaded so far.
+// If they're still pending they're a thenable. This map also exists
+// in Turbopack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = globalThis.__next_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+
+  for (let i = 0; i < chunks.length; i++) {
+    const chunkFilename = chunks[i];
+    const entry = chunkCache.get(chunkFilename);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkFilename);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkFilename, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkFilename, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = globalThis.__next_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+function loadChunk(filename) {
+  return globalThis.__next_chunk_load__(filename);
+}
+
+// The server acts as a Client of itself when resolving Server References.
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const RESOLVED_MODEL = 'resolved_model';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function bindArgs$1(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference$1(response, id, bound, parentChunk, parentObject, key) {
+  const serverReference = resolveServerReference(response._bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+  let promise;
+
+  if (bound) {
+    promise = Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs$1(requireModule(serverReference), args);
+    });
+  } else {
+    if (preloadPromise) {
+      promise = Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+    } else {
+      // Synchronously available
+      return requireModule(serverReference);
+    }
+  }
+
+  promise.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk)); // We need a placeholder value that will be replaced later.
+
+  return null;
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+
+  try {
+    const value = JSON.parse(chunk.value, chunk._response._fromJSON);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    const prefix = response._prefix;
+    const key = prefix + id; // Check if we have this field in the backing store already.
+
+    const backingEntry = response._formData.get(key);
+
+    if (backingEntry != null) {
+      // We assume that this is a string entry for now.
+      chunk = createResolvedModelChunk(response, backingEntry);
+    } else {
+      // We're still waiting on this entry to stream in.
+      chunk = createPendingChunk(response);
+    }
+
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+    blocked.deps++;
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  if (chunk.status === RESOLVED_MODEL) {
+    initializeModelChunk(chunk);
+  }
+
+  if (chunk.status !== INITIALIZED) {
+    // We know that this is emitted earlier so otherwise it's an error.
+    throw chunk.reason;
+  }
+
+  return chunk.value;
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16); // TODO: Just encode this in the reference inline instead of as a model.
+
+          const metaData = getOutlinedModel(response, id);
+          return loadServerReference$1(response, metaData.id, metaData.bound, initializingChunk, parentObject, key);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'K':
+        {
+          // FormData
+          const stringId = value.slice(2);
+          const formPrefix = response._prefix + stringId + '_';
+          const data = new FormData();
+          const backingFormData = response._formData; // We assume that the reference to FormData always comes after each
+          // entry that it references so we can assume they all exist in the
+          // backing store already.
+          // $FlowFixMe[prop-missing] FormData has forEach on it.
+
+          backingFormData.forEach((entry, entryKey) => {
+            if (entryKey.startsWith(formPrefix)) {
+              data.append(entryKey.slice(formPrefix.length), entry);
+            }
+          });
+          return data;
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function createResponse(bundlerConfig, formFieldPrefix) {
+  let backingFormData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new FormData();
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _prefix: formFieldPrefix,
+    _formData: backingFormData,
+    _chunks: chunks,
+    _fromJSON: function (key, value) {
+      if (typeof value === 'string') {
+        // We can't use .bind here because we need the "this" value.
+        return parseModelString(response, this, key, value);
+      }
+
+      return value;
+    }
+  };
+  return response;
+}
+function resolveField(response, key, value) {
+  // Add this field to the backing store.
+  response._formData.append(key, value);
+
+  const prefix = response._prefix;
+
+  if (key.startsWith(prefix)) {
+    const chunks = response._chunks;
+    const id = +key.slice(prefix.length);
+    const chunk = chunks.get(id);
+
+    if (chunk) {
+      // We were waiting on this key so now we can resolve it.
+      resolveModelChunk(chunk, value);
+    }
+  }
+}
+function resolveFileInfo(response, key, filename, mime) {
+  return {
+    chunks: [],
+    filename,
+    mime
+  };
+}
+function resolveFileChunk(response, handle, chunk) {
+  handle.chunks.push(chunk);
+}
+function resolveFileComplete(response, key, handle) {
+  // Add this file to the backing store.
+  // Node.js doesn't expose a global File constructor so we need to use
+  // the append() form that takes the file name as the third argument,
+  // to create a File object.
+  const blob = new Blob(handle.chunks, {
+    type: handle.mime
+  });
+
+  response._formData.append(key, blob, handle.filename);
+}
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function bindArgs(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference(bundlerConfig, id, bound) {
+  const serverReference = resolveServerReference(bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+
+  if (bound) {
+    return Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs(requireModule(serverReference), args);
+    });
+  } else if (preloadPromise) {
+    return Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+  } else {
+    // Synchronously available
+    return Promise.resolve(requireModule(serverReference));
+  }
+}
+
+function decodeBoundActionMetaData(body, serverManifest, formFieldPrefix) {
+  // The data for this reference is encoded in multiple fields under this prefix.
+  const actionResponse = createResponse(serverManifest, formFieldPrefix, body);
+  close(actionResponse);
+  const refPromise = getRoot(actionResponse); // Force it to initialize
+  // $FlowFixMe
+
+  refPromise.then(() => {});
+
+  if (refPromise.status !== 'fulfilled') {
+    // $FlowFixMe
+    throw refPromise.reason;
+  }
+
+  return refPromise.value;
+}
+
+function decodeAction(body, serverManifest) {
+  // We're going to create a new formData object that holds all the fields except
+  // the implementation details of the action data.
+  const formData = new FormData();
+  let action = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (!key.startsWith('$ACTION_')) {
+      formData.append(key, value);
+      return;
+    } // Later actions may override earlier actions if a button is used to override the default
+    // form action.
+
+
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      const metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+      action = loadServerReference(serverManifest, metaData.id, metaData.bound);
+      return;
+    }
+
+    if (key.startsWith('$ACTION_ID_')) {
+      const id = key.slice(11);
+      action = loadServerReference(serverManifest, id, null);
+      return;
+    }
+  });
+
+  if (action === null) {
+    return null;
+  } // Return the action with the remaining FormData bound to the first argument.
+
+
+  return action.then(fn => fn.bind(null, formData));
+}
+
+function createDrainHandler(destination, request) {
+  return () => startFlowing(request, destination);
+}
+
+function renderToPipeableStream(model, turbopackMap, options) {
+  const request = createRequest(model, turbopackMap, options ? options.onError : undefined, options ? options.context : undefined, options ? options.identifierPrefix : undefined, options ? options.onPostpone : undefined);
+  let hasStartedFlowing = false;
+  startWork(request);
+  return {
+    pipe(destination) {
+      if (hasStartedFlowing) {
+        throw new Error('React currently only supports piping to one writable stream.');
+      }
+
+      hasStartedFlowing = true;
+      startFlowing(request, destination);
+      destination.on('drain', createDrainHandler(destination, request));
+      return destination;
+    },
+
+    abort(reason) {
+      abort(request, reason);
+    }
+
+  };
+}
+
+function decodeReplyFromBusboy(busboyStream, turbopackMap) {
+  const response = createResponse(turbopackMap, '');
+  let pendingFiles = 0;
+  const queuedFields = [];
+  busboyStream.on('field', (name, value) => {
+    if (pendingFiles > 0) {
+      // Because the 'end' event fires two microtasks after the next 'field'
+      // we would resolve files and fields out of order. To handle this properly
+      // we queue any fields we receive until the previous file is done.
+      queuedFields.push(name, value);
+    } else {
+      resolveField(response, name, value);
+    }
+  });
+  busboyStream.on('file', (name, value, _ref) => {
+    let filename = _ref.filename,
+        encoding = _ref.encoding,
+        mimeType = _ref.mimeType;
+
+    if (encoding.toLowerCase() === 'base64') {
+      throw new Error("React doesn't accept base64 encoded file uploads because we don't expect " + "form data passed from a browser to ever encode data that way. If that's " + 'the wrong assumption, we can easily fix it.');
+    }
+
+    pendingFiles++;
+    const file = resolveFileInfo(response, name, filename, mimeType);
+    value.on('data', chunk => {
+      resolveFileChunk(response, file, chunk);
+    });
+    value.on('end', () => {
+      resolveFileComplete(response, name, file);
+      pendingFiles--;
+
+      if (pendingFiles === 0) {
+        // Release any queued fields
+        for (let i = 0; i < queuedFields.length; i += 2) {
+          resolveField(response, queuedFields[i], queuedFields[i + 1]);
+        }
+
+        queuedFields.length = 0;
+      }
+    });
+  });
+  busboyStream.on('finish', () => {
+    close(response);
+  });
+  busboyStream.on('error', err => {
+    reportGlobalError(response, // $FlowFixMe[incompatible-call] types Error and mixed are incompatible
+    err);
+  });
+  return getRoot(response);
+}
+
+function decodeReply(body, turbopackMap) {
+  if (typeof body === 'string') {
+    const form = new FormData();
+    form.append('0', body);
+    body = form;
+  }
+
+  const response = createResponse(turbopackMap, '', body);
+  const root = getRoot(response);
+  close(response);
+  return root;
+}
+
+exports.createClientModuleProxy = createClientModuleProxy;
+exports.decodeAction = decodeAction;
+exports.decodeReply = decodeReply;
+exports.decodeReplyFromBusboy = decodeReplyFromBusboy;
+exports.registerClientReference = registerClientReference;
+exports.registerServerReference = registerServerReference;
+exports.renderToPipeableStream = renderToPipeableStream;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.node.production.min.js b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.node.production.min.js
index 8b8bd02748daa..7503335ec5a75 100644
--- a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.node.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.node.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-turbopack-server.node.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-turbopack-server.node.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var aa=require("util");require("crypto");var ba=require("async_hooks"),ca=require("react"),da=require("react-dom"),l=null,m=0,p=!0;function q(a,b){a=a.write(b);p=p&&a}
 function r(a,b){if("string"===typeof b){if(0!==b.length)if(2048<3*b.length)0<m&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=0),q(a,ea.encode(b));else{var d=l;0<m&&(d=l.subarray(m));d=ea.encodeInto(b,d);var c=d.read;m+=d.written;c<b.length&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=ea.encodeInto(b.slice(c),l).written);2048===m&&(q(a,l),l=new Uint8Array(2048),m=0)}}else 0!==b.byteLength&&(2048<b.byteLength?(0<m&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=0),q(a,b)):(d=l.length-m,d<b.byteLength&&
 (0===d?q(a,l):(l.set(b.subarray(0,d),m),m+=d,q(a,l),b=b.subarray(d)),l=new Uint8Array(2048),m=0),l.set(b,m),m+=b.byteLength,2048===m&&(q(a,l),l=new Uint8Array(2048),m=0)));return p}var ea=new aa.TextEncoder,t=Symbol.for("react.client.reference"),v=Symbol.for("react.server.reference");function x(a,b,d){return Object.defineProperties(a,{$$typeof:{value:t},$$id:{value:b},$$async:{value:d}})}var fa=Function.prototype.bind,ha=Array.prototype.slice;
@@ -83,3 +83,5 @@ exports.decodeAction=function(a,b){var d=new FormData,c=null;a.forEach(function(
 exports.decodeReplyFromBusboy=function(a,b){var d=dc(b,""),c=0,e=[];a.on("field",function(f,g){0<c?e.push(f,g):ec(d,f,g)});a.on("file",function(f,g,k){var h=k.filename,n=k.mimeType;if("base64"===k.encoding.toLowerCase())throw Error("React doesn't accept base64 encoded file uploads because we don't expect form data passed from a browser to ever encode data that way. If that's the wrong assumption, we can easily fix it.");c++;var w=[];g.on("data",function(u){w.push(u)});g.on("end",function(){var u=
 new Blob(w,{type:n});d._formData.append(f,u,h);c--;if(0===c){for(u=0;u<e.length;u+=2)ec(d,e[u],e[u+1]);e.length=0}})});a.on("finish",function(){fc(d)});a.on("error",function(f){Yb(d,f)});return Z(d,0)};exports.registerClientReference=function(a,b,d){return x(a,b+"#"+d,!1)};exports.registerServerReference=function(a,b,d){return Object.defineProperties(a,{$$typeof:{value:v},$$id:{value:null===d?b:b+"#"+d},$$bound:{value:null},bind:{value:ia}})};
 exports.renderToPipeableStream=function(a,b,d){var c=sb(a,b,d?d.onError:void 0,d?d.context:void 0,d?d.identifierPrefix:void 0,d?d.onPostpone:void 0),e=!1;Jb(c);return{pipe:function(f){if(e)throw Error("React currently only supports piping to one writable stream.");e=!0;Kb(c,f);f.on("drain",ic(f,c));return f},abort:function(f){Lb(c,f)}}};
+
+//# sourceMappingURL=react-server-dom-turbopack-server.node.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.node.unbundled.production.js b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.node.unbundled.production.js
new file mode 100644
index 0000000000000..ccf0db5db3c12
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.node.unbundled.production.js
@@ -0,0 +1,3529 @@
+/**
+ * @license React
+ * react-server-dom-turbopack-server.node.unbundled.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var util = require('util');
+require('crypto');
+var async_hooks = require('async_hooks');
+var React = require('react');
+var ReactDOM = require('react-dom');
+
+// -----------------------------------------------------------------------------
+const enablePostpone = true;
+
+function scheduleWork(callback) {
+  setImmediate(callback);
+}
+function flushBuffered(destination) {
+  // If we don't have any more data to send right now.
+  // Flush whatever is in the buffer to the wire.
+  if (typeof destination.flush === 'function') {
+    // By convention the Zlib streams provide a flush function for this purpose.
+    // For Express, compression middleware adds this method.
+    destination.flush();
+  }
+}
+const VIEW_SIZE = 2048;
+let currentView = null;
+let writtenBytes = 0;
+let destinationHasCapacity = true;
+function beginWriting(destination) {
+  currentView = new Uint8Array(VIEW_SIZE);
+  writtenBytes = 0;
+  destinationHasCapacity = true;
+}
+
+function writeStringChunk(destination, stringChunk) {
+  if (stringChunk.length === 0) {
+    return;
+  } // maximum possible view needed to encode entire string
+
+
+  if (stringChunk.length * 3 > VIEW_SIZE) {
+    if (writtenBytes > 0) {
+      writeToDestination(destination, currentView.subarray(0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    writeToDestination(destination, textEncoder.encode(stringChunk));
+    return;
+  }
+
+  let target = currentView;
+
+  if (writtenBytes > 0) {
+    target = currentView.subarray(writtenBytes);
+  }
+
+  const _textEncoder$encodeIn = textEncoder.encodeInto(stringChunk, target),
+        read = _textEncoder$encodeIn.read,
+        written = _textEncoder$encodeIn.written;
+
+  writtenBytes += written;
+
+  if (read < stringChunk.length) {
+    writeToDestination(destination, currentView.subarray(0, writtenBytes));
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = textEncoder.encodeInto(stringChunk.slice(read), currentView).written;
+  }
+
+  if (writtenBytes === VIEW_SIZE) {
+    writeToDestination(destination, currentView);
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+}
+
+function writeViewChunk(destination, chunk) {
+  if (chunk.byteLength === 0) {
+    return;
+  }
+
+  if (chunk.byteLength > VIEW_SIZE) {
+    // one that is cached by the streaming renderer. We will enqueu
+    // it directly and expect it is not re-used
+
+
+    if (writtenBytes > 0) {
+      writeToDestination(destination, currentView.subarray(0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    writeToDestination(destination, chunk);
+    return;
+  }
+
+  let bytesToWrite = chunk;
+  const allowableBytes = currentView.length - writtenBytes;
+
+  if (allowableBytes < bytesToWrite.byteLength) {
+    // this chunk would overflow the current view. We enqueue a full view
+    // and start a new view with the remaining chunk
+    if (allowableBytes === 0) {
+      // the current view is already full, send it
+      writeToDestination(destination, currentView);
+    } else {
+      // fill up the current view and apply the remaining chunk bytes
+      // to a new view.
+      currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes);
+      writtenBytes += allowableBytes;
+      writeToDestination(destination, currentView);
+      bytesToWrite = bytesToWrite.subarray(allowableBytes);
+    }
+
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+
+  currentView.set(bytesToWrite, writtenBytes);
+  writtenBytes += bytesToWrite.byteLength;
+
+  if (writtenBytes === VIEW_SIZE) {
+    writeToDestination(destination, currentView);
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+}
+
+function writeChunk(destination, chunk) {
+  if (typeof chunk === 'string') {
+    writeStringChunk(destination, chunk);
+  } else {
+    writeViewChunk(destination, chunk);
+  }
+}
+
+function writeToDestination(destination, view) {
+  const currentHasCapacity = destination.write(view);
+  destinationHasCapacity = destinationHasCapacity && currentHasCapacity;
+}
+
+function writeChunkAndReturn(destination, chunk) {
+  writeChunk(destination, chunk);
+  return destinationHasCapacity;
+}
+function completeWriting(destination) {
+  if (currentView && writtenBytes > 0) {
+    destination.write(currentView.subarray(0, writtenBytes));
+  }
+
+  currentView = null;
+  writtenBytes = 0;
+  destinationHasCapacity = true;
+}
+function close$1(destination) {
+  destination.end();
+}
+const textEncoder = new util.TextEncoder();
+function stringToChunk(content) {
+  return content;
+}
+function typedArrayToBinaryChunk(content) {
+  // Convert any non-Uint8Array array to Uint8Array. We could avoid this for Uint8Arrays.
+  return new Uint8Array(content.buffer, content.byteOffset, content.byteLength);
+}
+function byteLengthOfChunk(chunk) {
+  return typeof chunk === 'string' ? Buffer.byteLength(chunk, 'utf8') : chunk.byteLength;
+}
+function byteLengthOfBinaryChunk(chunk) {
+  return chunk.byteLength;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+  destination.destroy(error);
+}
+
+// eslint-disable-next-line no-unused-vars
+const CLIENT_REFERENCE_TAG = Symbol.for('react.client.reference');
+const SERVER_REFERENCE_TAG = Symbol.for('react.server.reference');
+function isClientReference(reference) {
+  return reference.$$typeof === CLIENT_REFERENCE_TAG;
+}
+function isServerReference(reference) {
+  return reference.$$typeof === SERVER_REFERENCE_TAG;
+}
+function registerClientReference(proxyImplementation, id, exportName) {
+  return registerClientReferenceImpl(proxyImplementation, id + '#' + exportName, false);
+}
+
+function registerClientReferenceImpl(proxyImplementation, id, async) {
+  return Object.defineProperties(proxyImplementation, {
+    $$typeof: {
+      value: CLIENT_REFERENCE_TAG
+    },
+    $$id: {
+      value: id
+    },
+    $$async: {
+      value: async
+    }
+  });
+} // $FlowFixMe[method-unbinding]
+
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+
+  if (this.$$typeof === SERVER_REFERENCE_TAG) {
+    const args = ArraySlice.call(arguments, 1);
+    newFn.$$typeof = SERVER_REFERENCE_TAG;
+    newFn.$$id = this.$$id;
+    newFn.$$bound = this.$$bound ? this.$$bound.concat(args) : args;
+  }
+
+  return newFn;
+}
+
+function registerServerReference(reference, id, exportName) {
+  return Object.defineProperties(reference, {
+    $$typeof: {
+      value: SERVER_REFERENCE_TAG
+    },
+    $$id: {
+      value: exportName === null ? id : id + '#' + exportName
+    },
+    $$bound: {
+      value: null
+    },
+    bind: {
+      value: bind
+    }
+  });
+}
+const PROMISE_PROTOTYPE = Promise.prototype;
+const deepProxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        // These names are a little too common. We should probably have a way to
+        // have the Flight runtime extract the inner target instead.
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+
+      case 'displayName':
+        return undefined;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case 'Provider':
+        throw new Error("Cannot render a Client Context Provider on the Server. " + "Instead, you can export a Client Component wrapper " + "that itself renders a Client Context Provider.");
+    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+    const expression = String(target.name) + '.' + String(name);
+    throw new Error("Cannot access " + expression + " on the server. " + 'You cannot dot into a client module from a server component. ' + 'You can only pass the imported name through.');
+  },
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+const proxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case '__esModule':
+        // Something is conditionally checking which export to use. We'll pretend to be
+        // an ESM compat module but then we'll check again on the client.
+        const moduleId = target.$$id;
+        target.default = registerClientReferenceImpl(function () {
+          throw new Error("Attempted to call the default export of " + moduleId + " from the server " + "but it's on the client. It's not possible to invoke a client function from " + "the server, it can only be rendered as a Component or passed to props of a " + "Client Component.");
+        }, target.$$id + '#', target.$$async);
+        return true;
+
+      case 'then':
+        if (target.then) {
+          // Use a cached value
+          return target.then;
+        }
+
+        if (!target.$$async) {
+          // If this module is expected to return a Promise (such as an AsyncModule) then
+          // we should resolve that with a client reference that unwraps the Promise on
+          // the client.
+          const clientReference = registerClientReferenceImpl({}, target.$$id, true);
+          const proxy = new Proxy(clientReference, proxyHandlers); // Treat this as a resolved Promise for React's use()
+
+          target.status = 'fulfilled';
+          target.value = proxy;
+          const then = target.then = registerClientReferenceImpl(function then(resolve, reject) {
+            // Expose to React.
+            return Promise.resolve(resolve(proxy));
+          }, // If this is not used as a Promise but is treated as a reference to a `.then`
+          // export then we should treat it as a reference to that name.
+          target.$$id + '#then', false);
+          return then;
+        } else {
+          // Since typeof .then === 'function' is a feature test we'd continue recursing
+          // indefinitely if we return a function. Instead, we return an object reference
+          // if we check further.
+          return undefined;
+        }
+
+    }
+
+    let cachedReference = target[name];
+
+    if (!cachedReference) {
+      const reference = registerClientReferenceImpl(function () {
+        throw new Error( // eslint-disable-next-line react-internal/safe-string-coercion
+        "Attempted to call " + String(name) + "() from the server but " + String(name) + " is on the client. " + "It's not possible to invoke a client function from the server, it can " + "only be rendered as a Component or passed to props of a Client Component.");
+      }, target.$$id + '#' + name, target.$$async);
+      Object.defineProperty(reference, 'name', {
+        value: name
+      });
+      cachedReference = target[name] = new Proxy(reference, deepProxyHandlers);
+    }
+
+    return cachedReference;
+  },
+
+  getPrototypeOf(target) {
+    // Pretend to be a Promise in case anyone asks.
+    return PROMISE_PROTOTYPE;
+  },
+
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+function createClientModuleProxy(moduleId) {
+  const clientReference = registerClientReferenceImpl({}, // Represents the whole Module object instead of a particular import.
+  moduleId, false);
+  return new Proxy(clientReference, proxyHandlers);
+}
+
+function getClientReferenceKey(reference) {
+  return reference.$$async ? reference.$$id + '#async' : reference.$$id;
+}
+function resolveClientReferenceMetadata(config, clientReference) {
+  const modulePath = clientReference.$$id;
+  let name = '';
+  let resolvedModuleData = config[modulePath];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = modulePath.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = modulePath.slice(idx + 1);
+      resolvedModuleData = config[modulePath.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + modulePath + '" in the React Client Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  }
+
+  if (clientReference.$$async === true) {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1];
+  } else {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+  }
+}
+function getServerReferenceId(config, serverReference) {
+  return serverReference.$$id;
+}
+function getServerReferenceBoundArguments(config, serverReference) {
+  return serverReference.$$bound;
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMFlightServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule: preloadModule$1,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+
+function prefetchDNS(href) {
+  {
+    if (typeof href === 'string' && href) {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'D|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        emitHint(request, 'D', href);
+      }
+    }
+  }
+}
+
+function preconnect(href, crossOrigin) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = "C|" + (crossOrigin == null ? 'null' : crossOrigin) + "|" + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+
+        if (typeof crossOrigin === 'string') {
+          emitHint(request, 'C', [href, crossOrigin]);
+        } else {
+          emitHint(request, 'C', href);
+        }
+      }
+    }
+  }
+}
+
+function preload(href, as, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        let key = 'L';
+
+        if (as === 'image' && options) {
+          key += getImagePreloadKey(href, options.imageSrcSet, options.imageSizes);
+        } else {
+          key += "[" + as + "]" + href;
+        }
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          emitHint(request, 'L', [href, as, trimmed]);
+        } else {
+          emitHint(request, 'L', [href, as]);
+        }
+      }
+    }
+  }
+}
+
+function preloadModule$1(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'm|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'm', [href, trimmed]);
+        } else {
+          return emitHint(request, 'm', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'S|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'S', [href, typeof precedence === 'string' ? precedence : 0, trimmed]);
+        } else if (typeof precedence === 'string') {
+          return emitHint(request, 'S', [href, precedence]);
+        } else {
+          return emitHint(request, 'S', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'X|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'X', [href, trimmed]);
+        } else {
+          return emitHint(request, 'X', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitModuleScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'M|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'M', [href, trimmed]);
+        } else {
+          return emitHint(request, 'M', href);
+        }
+      }
+    }
+  }
+} // Flight normally encodes undefined as a special character however for directive option
+// arguments we don't want to send unnecessary keys and bloat the payload so we create a
+// trimmed object which omits any keys with null or undefined values.
+// This is only typesafe because these option objects have entirely optional fields where
+// null and undefined represent the same thing as no property.
+
+
+function trimOptions(options) {
+  if (options == null) return null;
+  let hasProperties = false;
+  const trimmed = {};
+
+  for (const key in options) {
+    if (options[key] != null) {
+      hasProperties = true;
+      trimmed[key] = options[key];
+    }
+  }
+
+  return hasProperties ? trimmed : null;
+}
+
+function getImagePreloadKey(href, imageSrcSet, imageSizes) {
+  let uniquePart = '';
+
+  if (typeof imageSrcSet === 'string' && imageSrcSet !== '') {
+    uniquePart += '[' + imageSrcSet + ']';
+
+    if (typeof imageSizes === 'string') {
+      uniquePart += '[' + imageSizes + ']';
+    }
+  } else {
+    uniquePart += '[][]' + href;
+  }
+
+  return "[image]" + uniquePart;
+}
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMFlightServerDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+// small, smaller than how we encode undefined, and is unambiguous. We could use
+// a different tuple structure to encode this instead but this makes the runtime
+// cost cheaper by eliminating a type checks in more positions.
+// prettier-ignore
+
+function createHints() {
+  return new Set();
+}
+
+const requestStorage = new async_hooks.AsyncLocalStorage();
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext); // On the way back, we push the new ones that weren't common.
+
+      pushNode(next);
+    }
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function pushProvider(context, nextValue) {
+  let prevValue;
+
+  {
+    prevValue = context._currentValue;
+    context._currentValue = nextValue;
+  }
+
+  const prevNode = currentActiveSnapshot;
+  const newNode = {
+    parent: prevNode,
+    depth: prevNode === null ? 0 : prevNode.depth + 1,
+    context: context,
+    parentValue: prevValue,
+    value: nextValue
+  };
+  currentActiveSnapshot = newNode;
+  return newNode;
+}
+function popProvider() {
+  const prevSnapshot = currentActiveSnapshot;
+
+  if (prevSnapshot === null) {
+    throw new Error('Tried to pop a Context at the root of the app. This is a bug in React.');
+  }
+
+  {
+    const value = prevSnapshot.parentValue;
+
+    if (value === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      prevSnapshot.context._currentValue = prevSnapshot.context._defaultValue;
+    } else {
+      prevSnapshot.context._currentValue = value;
+    }
+  }
+
+  return currentActiveSnapshot = prevSnapshot.parent;
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFizzWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop, noop);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+let currentRequest$1 = null;
+let thenableIndexCounter = 0;
+let thenableState = null;
+function prepareToUseHooksForRequest(request) {
+  currentRequest$1 = request;
+}
+function resetHooksForRequest() {
+  currentRequest$1 = null;
+}
+function prepareToUseHooksForComponent(prevThenableState) {
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+const HooksDispatcher = {
+  useMemo(nextCreate) {
+    return nextCreate();
+  },
+
+  useCallback(callback) {
+    return callback;
+  },
+
+  useDebugValue() {},
+
+  useDeferredValue: unsupportedHook,
+  useTransition: unsupportedHook,
+  readContext,
+  useContext: readContext,
+  useReducer: unsupportedHook,
+  useRef: unsupportedHook,
+  useState: unsupportedHook,
+  useInsertionEffect: unsupportedHook,
+  useLayoutEffect: unsupportedHook,
+  useImperativeHandle: unsupportedHook,
+  useEffect: unsupportedHook,
+  useId,
+  useSyncExternalStore: unsupportedHook,
+
+  useCacheRefresh() {
+    return unsupportedRefresh;
+  },
+
+  useMemoCache(size) {
+    const data = new Array(size);
+
+    for (let i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL;
+    }
+
+    return data;
+  },
+
+  use
+};
+
+function unsupportedHook() {
+  throw new Error('This Hook is not supported in Server Components.');
+}
+
+function unsupportedRefresh() {
+  throw new Error('Refreshing the cache is not supported in Server Components.');
+}
+
+function useId() {
+  if (currentRequest$1 === null) {
+    throw new Error('useId can only be used while React is rendering');
+  }
+
+  const id = currentRequest$1.identifierCount++; // use 'S' for Flight components to distinguish from 'R' and 'r' in Fizz/Client
+
+  return ':' + currentRequest$1.identifierPrefix + 'S' + id.toString(32) + ':';
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object' || typeof usable === 'function') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable; // Track the position of the thenable within this fiber.
+
+      const index = thenableIndexCounter;
+      thenableIndexCounter += 1;
+
+      if (thenableState === null) {
+        thenableState = createThenableState();
+      }
+
+      return trackUsedThenable(thenableState, thenable, index);
+    } else if (usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  }
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function createSignal() {
+  return new AbortController().signal;
+}
+
+function resolveCache() {
+  const request = resolveRequest();
+
+  if (request) {
+    return getCache(request);
+  }
+
+  return new Map();
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal() {
+    const cache = resolveCache();
+    let entry = cache.get(createSignal);
+
+    if (entry === undefined) {
+      entry = createSignal();
+      cache.set(createSignal, entry);
+    }
+
+    return entry;
+  },
+
+  getCacheForType(resourceType) {
+    const cache = resolveCache();
+    let entry = cache.get(resourceType);
+
+    if (entry === undefined) {
+      entry = resourceType(); // TODO: Warn if undefined?
+
+      cache.set(resourceType, entry);
+    }
+
+    return entry;
+  }
+
+};
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+function objectName(object) {
+  // $FlowFixMe[method-unbinding]
+  const name = Object.prototype.toString.call(object);
+  return name.replace(/^\[object (.*)\]$/, function (m, p0) {
+    return p0;
+  });
+}
+
+function describeKeyForErrorMessage(key) {
+  const encodedKey = JSON.stringify(key);
+  return '"' + key + '"' === encodedKey ? key : encodedKey;
+}
+
+function describeValueForErrorMessage(value) {
+  switch (typeof value) {
+    case 'string':
+      {
+        return JSON.stringify(value.length <= 10 ? value : value.slice(0, 10) + '...');
+      }
+
+    case 'object':
+      {
+        if (isArray(value)) {
+          return '[...]';
+        }
+
+        const name = objectName(value);
+
+        if (name === 'Object') {
+          return '{...}';
+        }
+
+        return name;
+      }
+
+    case 'function':
+      return 'function';
+
+    default:
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      return String(value);
+  }
+}
+
+function describeElementType(type) {
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        return describeElementType(type.render);
+
+      case REACT_MEMO_TYPE:
+        return describeElementType(type.type);
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            // Lazy may contain any component type so we recursively resolve it.
+            return describeElementType(init(payload));
+          } catch (x) {}
+        }
+    }
+  }
+
+  return '';
+}
+
+function describeObjectForErrorMessage(objectOrArray, expandedName) {
+  const objKind = objectName(objectOrArray);
+
+  if (objKind !== 'Object' && objKind !== 'Array') {
+    return objKind;
+  }
+
+  let str = '';
+  let start = -1;
+  let length = 0;
+
+  if (isArray(objectOrArray)) {
+    {
+      // Print Array
+      str = '[';
+      const array = objectOrArray;
+
+      for (let i = 0; i < array.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const value = array[i];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if ('' + i === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += ']';
+    }
+  } else {
+    if (objectOrArray.$$typeof === REACT_ELEMENT_TYPE) {
+      str = '<' + describeElementType(objectOrArray.type) + '/>';
+    } else {
+      // Print Object
+      str = '{';
+      const object = objectOrArray;
+      const names = Object.keys(object);
+
+      for (let i = 0; i < names.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const name = names[i];
+        str += describeKeyForErrorMessage(name) + ': ';
+        const value = object[name];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if (name === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += '}';
+    }
+  }
+
+  if (expandedName === undefined) {
+    return str;
+  }
+
+  if (start > -1 && length > 0) {
+    const highlight = ' '.repeat(start) + '^'.repeat(length);
+    return '\n  ' + str + '\n  ' + highlight;
+  }
+
+  return '\n  ' + str;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ReactSharedServerInternals = // $FlowFixMe: It's defined in the one we resolve to.
+React.__SECRET_SERVER_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+if (!ReactSharedServerInternals) {
+  throw new Error('The "react" package in this environment is not configured correctly. ' + 'The "react-server" condition must be enabled in any environment that ' + 'runs React Server Components.');
+}
+
+// Turns a TypedArray or ArrayBuffer into a string that can be used for comparison
+// in a Map to see if the bytes are the same.
+function binaryToComparableString(view) {
+  return String.fromCharCode.apply(String, new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+}
+
+const ObjectPrototype = Object.prototype;
+const stringify = JSON.stringify; // Serializable values
+// Thenable<ReactClientValue>
+
+const PENDING$1 = 0;
+const COMPLETED = 1;
+const ABORTED = 3;
+const ERRORED$1 = 4;
+const TaintRegistryObjects = ReactSharedServerInternals.TaintRegistryObjects,
+      TaintRegistryValues = ReactSharedServerInternals.TaintRegistryValues,
+      TaintRegistryByteLengths = ReactSharedServerInternals.TaintRegistryByteLengths,
+      TaintRegistryPendingRequests = ReactSharedServerInternals.TaintRegistryPendingRequests,
+      ReactCurrentCache = ReactSharedServerInternals.ReactCurrentCache;
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+
+function throwTaintViolation(message) {
+  // eslint-disable-next-line react-internal/prod-error-codes
+  throw new Error(message);
+}
+
+function cleanupTaintQueue(request) {
+  const cleanupQueue = request.taintCleanupQueue;
+  TaintRegistryPendingRequests.delete(cleanupQueue);
+
+  for (let i = 0; i < cleanupQueue.length; i++) {
+    const entryValue = cleanupQueue[i];
+    const entry = TaintRegistryValues.get(entryValue);
+
+    if (entry !== undefined) {
+      if (entry.count === 1) {
+        TaintRegistryValues.delete(entryValue);
+      } else {
+        entry.count--;
+      }
+    }
+  }
+
+  cleanupQueue.length = 0;
+}
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+}
+
+function defaultPostponeHandler(reason) {// Noop
+}
+
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2;
+function createRequest(model, bundlerConfig, onError, context, identifierPrefix, onPostpone) {
+  if (ReactCurrentCache.current !== null && ReactCurrentCache.current !== DefaultCacheDispatcher) {
+    throw new Error('Currently React only supports one RSC renderer at a time.');
+  }
+
+  prepareHostDispatcher();
+  ReactCurrentCache.current = DefaultCacheDispatcher;
+  const abortSet = new Set();
+  const pingedTasks = [];
+  const cleanupQueue = [];
+
+  {
+    TaintRegistryPendingRequests.add(cleanupQueue);
+  }
+
+  const hints = createHints();
+  const request = {
+    status: OPEN,
+    flushScheduled: false,
+    fatalError: null,
+    destination: null,
+    bundlerConfig,
+    cache: new Map(),
+    nextChunkId: 0,
+    pendingChunks: 0,
+    hints,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    completedImportChunks: [],
+    completedHintChunks: [],
+    completedRegularChunks: [],
+    completedErrorChunks: [],
+    writtenSymbols: new Map(),
+    writtenClientReferences: new Map(),
+    writtenServerReferences: new Map(),
+    writtenProviders: new Map(),
+    writtenObjects: new WeakMap(),
+    identifierPrefix: identifierPrefix || '',
+    identifierCount: 1,
+    taintCleanupQueue: cleanupQueue,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? defaultPostponeHandler : onPostpone,
+    // $FlowFixMe[missing-this-annot]
+    toJSON: function (key, value) {
+      return resolveModelToJSON(request, this, key, value);
+    }
+  };
+  request.pendingChunks++;
+  const rootContext = createRootContext(context);
+  const rootTask = createTask(request, model, rootContext, abortSet);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  {
+    const store = requestStorage.getStore();
+    if (store) return store;
+  }
+
+  return null;
+}
+
+function createRootContext(reqContext) {
+  return importServerContexts(reqContext);
+}
+
+const POP = {};
+
+function serializeThenable(request, thenable) {
+  request.pendingChunks++;
+  const newTask = createTask(request, null, getActiveContext(), request.abortableTasks);
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        // We have the resolved value, we can go ahead and schedule it for serialization.
+        newTask.model = thenable.value;
+        pingTask(request, newTask);
+        return newTask.id;
+      }
+
+    case 'rejected':
+      {
+        const x = thenable.reason;
+
+        if (typeof x === 'object' && x !== null && x.$$typeof === REACT_POSTPONE_TYPE) {
+          const postponeInstance = x;
+          logPostpone(request, postponeInstance.message);
+          emitPostponeChunk(request, newTask.id);
+        } else {
+          const digest = logRecoverableError(request, x);
+          emitErrorChunk(request, newTask.id, digest);
+        }
+
+        return newTask.id;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  thenable.then(value => {
+    newTask.model = value;
+    pingTask(request, newTask);
+  }, reason => {
+    newTask.status = ERRORED$1;
+    request.abortableTasks.delete(newTask); // TODO: We should ideally do this inside performWork so it's scheduled
+
+    const digest = logRecoverableError(request, reason);
+    emitErrorChunk(request, newTask.id, digest);
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  });
+  return newTask.id;
+}
+
+function emitHint(request, code, model) {
+  emitHintChunk(request, code, model);
+  enqueueFlush(request);
+}
+function getHints(request) {
+  return request.hints;
+}
+function getCache(request) {
+  return request.cache;
+}
+
+function readThenable(thenable) {
+  if (thenable.status === 'fulfilled') {
+    return thenable.value;
+  } else if (thenable.status === 'rejected') {
+    throw thenable.reason;
+  }
+
+  throw thenable;
+}
+
+function createLazyWrapperAroundWakeable(wakeable) {
+  // This is a temporary fork of the `use` implementation until we accept
+  // promises everywhere.
+  const thenable = wakeable;
+
+  switch (thenable.status) {
+    case 'fulfilled':
+    case 'rejected':
+      break;
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: thenable,
+    _init: readThenable
+  };
+  return lazyType;
+}
+
+function attemptResolveElement(request, type, key, ref, props, prevThenableState) {
+  if (ref !== null && ref !== undefined) {
+    // When the ref moves to the regular props object this will implicitly
+    // throw for functions. We could probably relax it to a DEV warning for other
+    // cases.
+    throw new Error('Refs cannot be used in Server Components, nor passed to Client Components.');
+  }
+
+  if (typeof type === 'function') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    } // This is a server-side component.
+
+
+    prepareToUseHooksForComponent(prevThenableState);
+    const result = type(props);
+
+    if (typeof result === 'object' && result !== null && typeof result.then === 'function') {
+      // When the return value is in children position we can resolve it immediately,
+      // to its value without a wrapper if it's synchronously available.
+      const thenable = result;
+
+      if (thenable.status === 'fulfilled') {
+        return thenable.value;
+      } // TODO: Once we accept Promises as children on the client, we can just return
+      // the thenable here.
+
+
+      return createLazyWrapperAroundWakeable(result);
+    }
+
+    return result;
+  } else if (typeof type === 'string') {
+    // This is a host element. E.g. HTML.
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (typeof type === 'symbol') {
+    if (type === REACT_FRAGMENT_TYPE) {
+      // For key-less fragments, we add a small optimization to avoid serializing
+      // it as a wrapper.
+      // TODO: If a key is specified, we should propagate its key to any children.
+      // Same as if a Server Component has a key.
+      return props.children;
+    } // This might be a built-in React component. We'll let the client decide.
+    // Any built-in works as long as its props are serializable.
+
+
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (type != null && typeof type === 'object') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    }
+
+    switch (type.$$typeof) {
+      case REACT_LAZY_TYPE:
+        {
+          const payload = type._payload;
+          const init = type._init;
+          const wrappedType = init(payload);
+          return attemptResolveElement(request, wrappedType, key, ref, props, prevThenableState);
+        }
+
+      case REACT_FORWARD_REF_TYPE:
+        {
+          const render = type.render;
+          prepareToUseHooksForComponent(prevThenableState);
+          return render(props, undefined);
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          return attemptResolveElement(request, type.type, key, ref, props, prevThenableState);
+        }
+
+      case REACT_PROVIDER_TYPE:
+        {
+          {
+            pushProvider(type._context, props.value);
+
+            return [REACT_ELEMENT_TYPE, type, key, // Rely on __popProvider being serialized last to pop the provider.
+            {
+              value: props.value,
+              children: props.children,
+              __pop: POP
+            }];
+          } // Fallthrough
+
+        }
+    }
+  }
+
+  throw new Error("Unsupported Server Component type: " + describeValueForErrorMessage(type));
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createTask(request, model, context, abortSet) {
+  const id = request.nextChunkId++;
+  const task = {
+    id,
+    status: PENDING$1,
+    model,
+    context,
+    ping: () => pingTask(request, task),
+    thenableState: null
+  };
+  abortSet.add(task);
+  return task;
+}
+
+function serializeByValueID(id) {
+  return '$' + id.toString(16);
+}
+
+function serializeLazyID(id) {
+  return '$L' + id.toString(16);
+}
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeProviderReference(name) {
+  return '$P' + name;
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeRowHeader(tag, id) {
+  return id.toString(16) + ':' + tag;
+}
+
+function encodeReferenceChunk(request, id, reference) {
+  const json = stringify(reference);
+  const row = id.toString(16) + ':' + json + '\n';
+  return stringToChunk(row);
+}
+
+function serializeClientReference(request, parent, key, clientReference) {
+  const clientReferenceKey = getClientReferenceKey(clientReference);
+  const writtenClientReferences = request.writtenClientReferences;
+  const existingId = writtenClientReferences.get(clientReferenceKey);
+
+  if (existingId !== undefined) {
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(existingId);
+    }
+
+    return serializeByValueID(existingId);
+  }
+
+  try {
+    const clientReferenceMetadata = resolveClientReferenceMetadata(request.bundlerConfig, clientReference);
+    request.pendingChunks++;
+    const importId = request.nextChunkId++;
+    emitImportChunk(request, importId, clientReferenceMetadata);
+    writtenClientReferences.set(clientReferenceKey, importId);
+
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(importId);
+    }
+
+    return serializeByValueID(importId);
+  } catch (x) {
+    request.pendingChunks++;
+    const errorId = request.nextChunkId++;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, errorId, digest);
+    return serializeByValueID(errorId);
+  }
+}
+
+function outlineModel(request, value) {
+  request.pendingChunks++;
+  const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+  retryTask(request, newTask);
+  return newTask.id;
+}
+
+function serializeServerReference(request, parent, key, serverReference) {
+  const writtenServerReferences = request.writtenServerReferences;
+  const existingId = writtenServerReferences.get(serverReference);
+
+  if (existingId !== undefined) {
+    return serializeServerReferenceID(existingId);
+  }
+
+  const bound = getServerReferenceBoundArguments(request.bundlerConfig, serverReference);
+  const serverReferenceMetadata = {
+    id: getServerReferenceId(request.bundlerConfig, serverReference),
+    bound: bound ? Promise.resolve(bound) : null
+  };
+  const metadataId = outlineModel(request, serverReferenceMetadata);
+  writtenServerReferences.set(serverReference, metadataId);
+  return serializeServerReferenceID(metadataId);
+}
+
+function serializeLargeTextString(request, text) {
+  request.pendingChunks += 2;
+  const textId = request.nextChunkId++;
+  const textChunk = stringToChunk(text);
+  const binaryLength = byteLengthOfChunk(textChunk);
+  const row = textId.toString(16) + ':T' + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, textChunk);
+  return serializeByValueID(textId);
+}
+
+function serializeMap(request, map) {
+  const entries = Array.from(map);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i][0];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$Q' + id.toString(16);
+}
+
+function serializeSet(request, set) {
+  const entries = Array.from(set);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$W' + id.toString(16);
+}
+
+function serializeTypedArray(request, tag, typedArray) {
+  {
+    if (TaintRegistryByteLengths.has(typedArray.byteLength)) {
+      // If we have had any tainted values of this length, we check
+      // to see if these bytes matches any entries in the registry.
+      const tainted = TaintRegistryValues.get(binaryToComparableString(typedArray));
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    }
+  }
+
+  request.pendingChunks += 2;
+  const bufferId = request.nextChunkId++; // TODO: Convert to little endian if that's not the server default.
+
+  const binaryChunk = typedArrayToBinaryChunk(typedArray);
+  const binaryLength = byteLengthOfBinaryChunk(binaryChunk);
+  const row = bufferId.toString(16) + ':' + tag + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, binaryChunk);
+  return serializeByValueID(bufferId);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+let modelRoot = false;
+
+function resolveModelToJSON(request, parent, key, value) {
+
+
+  switch (value) {
+    case REACT_ELEMENT_TYPE:
+      return '$';
+  }
+
+
+  while (typeof value === 'object' && value !== null && (value.$$typeof === REACT_ELEMENT_TYPE || value.$$typeof === REACT_LAZY_TYPE)) {
+
+    try {
+      switch (value.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const writtenObjects = request.writtenObjects;
+            const existingId = writtenObjects.get(value);
+
+            if (existingId !== undefined) {
+              if (existingId === -1) {
+                // Seen but not yet outlined.
+                const newId = outlineModel(request, value);
+                return serializeByValueID(newId);
+              } else if (modelRoot === value) {
+                // This is the ID we're currently emitting so we need to write it
+                // once but if we discover it again, we refer to it by id.
+                modelRoot = null;
+              } else {
+                // We've already emitted this as an outlined object, so we can
+                // just refer to that by its existing ID.
+                return serializeByValueID(existingId);
+              }
+            } else {
+              // This is the first time we've seen this object. We may never see it again
+              // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+              writtenObjects.set(value, -1);
+            } // TODO: Concatenate keys of parents onto children.
+
+
+            const element = value; // Attempt to render the Server Component.
+
+            value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, null);
+            break;
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = value._payload;
+            const init = value._init;
+            value = init(payload);
+            break;
+          }
+      }
+    } catch (thrownValue) {
+      const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          // Something suspended, we'll need to create a new task and resolve it later.
+          request.pendingChunks++;
+          const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+          const ping = newTask.ping;
+          x.then(ping, ping);
+          newTask.thenableState = getThenableStateAfterSuspending();
+          return serializeLazyID(newTask.id);
+        } else if (x.$$typeof === REACT_POSTPONE_TYPE) {
+          // Something postponed. We'll still send everything we have up until this point.
+          // We'll replace this element with a lazy reference that postpones on the client.
+          const postponeInstance = x;
+          request.pendingChunks++;
+          const postponeId = request.nextChunkId++;
+          logPostpone(request, postponeInstance.message);
+          emitPostponeChunk(request, postponeId);
+          return serializeLazyID(postponeId);
+        }
+      } // Something errored. We'll still send everything we have up until this point.
+      // We'll replace this element with a lazy reference that throws on the client
+      // once it gets rendered.
+
+
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+      const digest = logRecoverableError(request, x);
+      emitErrorChunk(request, errorId, digest);
+      return serializeLazyID(errorId);
+    }
+  }
+
+  if (value === null) {
+    return null;
+  }
+
+  if (typeof value === 'object') {
+    {
+      const tainted = TaintRegistryObjects.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted);
+      }
+    }
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    const writtenObjects = request.writtenObjects;
+    const existingId = writtenObjects.get(value); // $FlowFixMe[method-unbinding]
+
+    if (typeof value.then === 'function') {
+      if (existingId !== undefined) {
+        if (modelRoot === value) {
+          // This is the ID we're currently emitting so we need to write it
+          // once but if we discover it again, we refer to it by id.
+          modelRoot = null;
+        } else {
+          // We've seen this promise before, so we can just refer to the same result.
+          return serializePromiseID(existingId);
+        }
+      } // We assume that any object with a .then property is a "Thenable" type,
+      // or a Promise type. Either of which can be represented by a Promise.
+
+
+      const promiseId = serializeThenable(request, value);
+      writtenObjects.set(value, promiseId);
+      return serializePromiseID(promiseId);
+    }
+
+    {
+      if (value.$$typeof === REACT_PROVIDER_TYPE) {
+        const providerKey = value._context._globalName;
+        const writtenProviders = request.writtenProviders;
+        let providerId = writtenProviders.get(key);
+
+        if (providerId === undefined) {
+          request.pendingChunks++;
+          providerId = request.nextChunkId++;
+          writtenProviders.set(providerKey, providerId);
+          emitProviderChunk(request, providerId, providerKey);
+        }
+
+        return serializeByValueID(providerId);
+      } else if (value === POP) {
+        popProvider();
+
+        return undefined;
+      }
+    }
+
+    if (existingId !== undefined) {
+      if (existingId === -1) {
+        // Seen but not yet outlined.
+        const newId = outlineModel(request, value);
+        return serializeByValueID(newId);
+      } else if (modelRoot === value) {
+        // This is the ID we're currently emitting so we need to write it
+        // once but if we discover it again, we refer to it by id.
+        modelRoot = null;
+      } else {
+        // We've already emitted this as an outlined object, so we can
+        // just refer to that by its existing ID.
+        return serializeByValueID(existingId);
+      }
+    } else {
+      // This is the first time we've seen this object. We may never see it again
+      // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+      writtenObjects.set(value, -1);
+    }
+
+    if (isArray(value)) {
+      // $FlowFixMe[incompatible-return]
+      return value;
+    }
+
+    if (value instanceof Map) {
+      return serializeMap(request, value);
+    }
+
+    if (value instanceof Set) {
+      return serializeSet(request, value);
+    }
+
+    {
+      if (value instanceof ArrayBuffer) {
+        return serializeTypedArray(request, 'A', new Uint8Array(value));
+      }
+
+      if (value instanceof Int8Array) {
+        // char
+        return serializeTypedArray(request, 'C', value);
+      }
+
+      if (value instanceof Uint8Array) {
+        // unsigned char
+        return serializeTypedArray(request, 'c', value);
+      }
+
+      if (value instanceof Uint8ClampedArray) {
+        // unsigned clamped char
+        return serializeTypedArray(request, 'U', value);
+      }
+
+      if (value instanceof Int16Array) {
+        // sort
+        return serializeTypedArray(request, 'S', value);
+      }
+
+      if (value instanceof Uint16Array) {
+        // unsigned short
+        return serializeTypedArray(request, 's', value);
+      }
+
+      if (value instanceof Int32Array) {
+        // long
+        return serializeTypedArray(request, 'L', value);
+      }
+
+      if (value instanceof Uint32Array) {
+        // unsigned long
+        return serializeTypedArray(request, 'l', value);
+      }
+
+      if (value instanceof Float32Array) {
+        // float
+        return serializeTypedArray(request, 'F', value);
+      }
+
+      if (value instanceof Float64Array) {
+        // double
+        return serializeTypedArray(request, 'D', value);
+      }
+
+      if (value instanceof BigInt64Array) {
+        // number
+        return serializeTypedArray(request, 'N', value);
+      }
+
+      if (value instanceof BigUint64Array) {
+        // unsigned number
+        // We use "m" instead of "n" since JSON can start with "null"
+        return serializeTypedArray(request, 'm', value);
+      }
+
+      if (value instanceof DataView) {
+        return serializeTypedArray(request, 'V', value);
+      }
+    }
+
+    const iteratorFn = getIteratorFn(value);
+
+    if (iteratorFn) {
+      return Array.from(value);
+    } // Verify that this is a simple plain object.
+
+
+    const proto = getPrototypeOf(value);
+
+    if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+      throw new Error('Only plain objects, and a few built-ins, can be passed to Client Components ' + 'from Server Components. Classes or null prototypes are not supported.');
+    }
+
+
+    return value;
+  }
+
+  if (typeof value === 'string') {
+    {
+      const tainted = TaintRegistryValues.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    } // TODO: Maybe too clever. If we support URL there's no similar trick.
+
+
+    if (value[value.length - 1] === 'Z') {
+      // Possibly a Date, whose toJSON automatically calls toISOString
+      // $FlowFixMe[incompatible-use]
+      const originalValue = parent[key];
+
+      if (originalValue instanceof Date) {
+        return serializeDateFromDateJSON(value);
+      }
+    }
+
+    if (value.length >= 1024) {
+      // For large strings, we encode them outside the JSON payload so that we
+      // don't have to double encode and double parse the strings. This can also
+      // be more compact in case the string has a lot of escaped characters.
+      return serializeLargeTextString(request, value);
+    }
+
+    return escapeStringValue(value);
+  }
+
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  if (typeof value === 'number') {
+    return serializeNumber(value);
+  }
+
+  if (typeof value === 'undefined') {
+    return serializeUndefined();
+  }
+
+  if (typeof value === 'function') {
+    {
+      const tainted = TaintRegistryObjects.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted);
+      }
+    }
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    if (isServerReference(value)) {
+      return serializeServerReference(request, parent, key, value);
+    }
+
+    if (/^on[A-Z]/.test(key)) {
+      throw new Error('Event handlers cannot be passed to Client Component props.' + describeObjectForErrorMessage(parent, key) + '\nIf you need interactivity, consider converting part of this to a Client Component.');
+    } else {
+      throw new Error('Functions cannot be passed directly to Client Components ' + 'unless you explicitly expose it by marking it with "use server".' + describeObjectForErrorMessage(parent, key));
+    }
+  }
+
+  if (typeof value === 'symbol') {
+    const writtenSymbols = request.writtenSymbols;
+    const existingId = writtenSymbols.get(value);
+
+    if (existingId !== undefined) {
+      return serializeByValueID(existingId);
+    } // $FlowFixMe[incompatible-type] `description` might be undefined
+
+
+    const name = value.description;
+
+    if (Symbol.for(name) !== value) {
+      throw new Error('Only global symbols received from Symbol.for(...) can be passed to Client Components. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+      value.description + ") cannot be found among global symbols.") + describeObjectForErrorMessage(parent, key));
+    }
+
+    request.pendingChunks++;
+    const symbolId = request.nextChunkId++;
+    emitSymbolChunk(request, symbolId, name);
+    writtenSymbols.set(value, symbolId);
+    return serializeByValueID(symbolId);
+  }
+
+  if (typeof value === 'bigint') {
+    {
+      const tainted = TaintRegistryValues.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    }
+
+    return serializeBigInt(value);
+  }
+
+  throw new Error("Type " + typeof value + " is not supported in Client Component props." + describeObjectForErrorMessage(parent, key));
+}
+
+function logPostpone(request, reason) {
+  const onPostpone = request.onPostpone;
+  onPostpone(reason);
+}
+
+function logRecoverableError(request, error) {
+  const onError = request.onError;
+  const errorDigest = onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest || '';
+}
+
+function fatalError(request, error) {
+  {
+    cleanupTaintQueue(request);
+  } // This is called outside error handling code such as if an error happens in React internals.
+
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function emitPostponeChunk(request, id, postponeInstance) {
+  let row;
+
+  {
+    // No reason included in prod.
+    row = serializeRowHeader('P', id) + '\n';
+  }
+
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitErrorChunk(request, id, digest, error) {
+  let errorInfo;
+
+  {
+    errorInfo = {
+      digest
+    };
+  }
+
+  const row = serializeRowHeader('E', id) + stringify(errorInfo) + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitImportChunk(request, id, clientReferenceMetadata) {
+  // $FlowFixMe[incompatible-type] stringify can return null
+  const json = stringify(clientReferenceMetadata);
+  const row = serializeRowHeader('I', id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitHintChunk(request, code, model) {
+  const json = stringify(model);
+  const id = request.nextChunkId++;
+  const row = serializeRowHeader('H' + code, id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedHintChunks.push(processedChunk);
+}
+
+function emitSymbolChunk(request, id, name) {
+  const symbolReference = serializeSymbolReference(name);
+  const processedChunk = encodeReferenceChunk(request, id, symbolReference);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitProviderChunk(request, id, contextName) {
+  const contextReference = serializeProviderReference(contextName);
+  const processedChunk = encodeReferenceChunk(request, id, contextReference);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function emitModelChunk(request, id, model) {
+  // Track the root so we know that we have to emit this object even though it
+  // already has an ID. This is needed because we might see this object twice
+  // in the same toJSON if it is cyclic.
+  modelRoot = model; // $FlowFixMe[incompatible-type] stringify can return null
+
+  const json = stringify(model, request.toJSON);
+  const row = id.toString(16) + ':' + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function retryTask(request, task) {
+  if (task.status !== PENDING$1) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  }
+
+  switchContext(task.context);
+
+  try {
+    let value = task.model;
+
+    if (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+      request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+      const element = value; // When retrying a component, reuse the thenableState from the
+      // previous attempt.
+
+      const prevThenableState = task.thenableState; // Attempt to render the Server Component.
+      // Doing this here lets us reuse this same task if the next component
+      // also suspends.
+
+      task.model = value;
+      value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, prevThenableState); // Successfully finished this component. We're going to keep rendering
+      // using the same task, but we reset its thenable state before continuing.
+
+      task.thenableState = null; // Keep rendering and reuse the same task. This inner loop is separate
+      // from the render above because we don't need to reset the thenable state
+      // until the next time something suspends and retries.
+
+      while (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+        request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+        const nextElement = value;
+        task.model = value;
+        value = attemptResolveElement(request, nextElement.type, nextElement.key, nextElement.ref, nextElement.props, null);
+      }
+    } // Track that this object is outlined and has an id.
+
+
+    if (typeof value === 'object' && value !== null) {
+      request.writtenObjects.set(value, task.id);
+    }
+
+    emitModelChunk(request, task.id, value);
+    request.abortableTasks.delete(task);
+    task.status = COMPLETED;
+  } catch (thrownValue) {
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      } else if (x.$$typeof === REACT_POSTPONE_TYPE) {
+        request.abortableTasks.delete(task);
+        task.status = ERRORED$1;
+        const postponeInstance = x;
+        logPostpone(request, postponeInstance.message);
+        emitPostponeChunk(request, task.id);
+        return;
+      }
+    }
+
+    request.abortableTasks.delete(task);
+    task.status = ERRORED$1;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, task.id, digest);
+  }
+}
+
+function performWork(request) {
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  const prevRequest = currentRequest;
+  currentRequest = request;
+  prepareToUseHooksForRequest(request);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    request.pingedTasks = [];
+
+    for (let i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    ReactCurrentDispatcher.current = prevDispatcher;
+    resetHooksForRequest();
+    currentRequest = prevRequest;
+  }
+}
+
+function abortTask(task, request, errorId) {
+  task.status = ABORTED; // Instead of emitting an error per task.id, we emit a model that only
+  // has a single value referencing the error.
+
+  const ref = serializeByValueID(errorId);
+  const processedChunk = encodeReferenceChunk(request, task.id, ref);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function flushCompletedChunks(request, destination) {
+  beginWriting();
+
+  try {
+    // We emit module chunks first in the stream so that
+    // they can be preloaded as early as possible.
+    const importsChunks = request.completedImportChunks;
+    let i = 0;
+
+    for (; i < importsChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = importsChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    importsChunks.splice(0, i); // Next comes hints.
+
+    const hintChunks = request.completedHintChunks;
+    i = 0;
+
+    for (; i < hintChunks.length; i++) {
+      const chunk = hintChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    hintChunks.splice(0, i); // Next comes model data.
+
+    const regularChunks = request.completedRegularChunks;
+    i = 0;
+
+    for (; i < regularChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = regularChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    regularChunks.splice(0, i); // Finally, errors are sent. The idea is that it's ok to delay
+    // any error messages and prioritize display of other parts of
+    // the page.
+
+    const errorChunks = request.completedErrorChunks;
+    i = 0;
+
+    for (; i < errorChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = errorChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    errorChunks.splice(0, i);
+  } finally {
+    request.flushScheduled = false;
+    completeWriting(destination);
+  }
+
+  flushBuffered(destination);
+
+  if (request.pendingChunks === 0) {
+    // We're done.
+    {
+      cleanupTaintQueue(request);
+    }
+
+    close$1(destination);
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  {
+    scheduleWork(() => requestStorage.run(request, performWork, request));
+  }
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    const destination = request.destination;
+    request.flushScheduled = true;
+    scheduleWork(() => flushCompletedChunks(request, destination));
+  }
+}
+
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedChunks(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      // We have tasks to abort. We'll emit one error row and then emit a reference
+      // to that row from every row that's still remaining.
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+
+      if (enablePostpone && typeof reason === 'object' && reason !== null && reason.$$typeof === REACT_POSTPONE_TYPE) {
+        const postponeInstance = reason;
+        logPostpone(request, postponeInstance.message);
+        emitPostponeChunk(request, errorId, postponeInstance);
+      } else {
+        const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+        const digest = logRecoverableError(request, error);
+        emitErrorChunk(request, errorId, digest, error);
+      }
+
+      abortableTasks.forEach(task => abortTask(task, request, errorId));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function importServerContexts(contexts) {
+  if (contexts) {
+    const prevContext = getActiveContext();
+    switchContext(rootContextSnapshot);
+
+    for (let i = 0; i < contexts.length; i++) {
+      const _contexts$i = contexts[i],
+            name = _contexts$i[0],
+            value = _contexts$i[1];
+      const context = getOrCreateServerContext(name);
+      pushProvider(context, value);
+    }
+
+    const importedContext = getActiveContext();
+    switchContext(prevContext);
+    return importedContext;
+  }
+
+  return rootContextSnapshot;
+}
+
+function resolveServerReference(bundlerConfig, id) {
+  const idx = id.lastIndexOf('#');
+  const specifier = id.slice(0, idx);
+  const name = id.slice(idx + 1);
+  return {
+    specifier,
+    name
+  };
+}
+const asyncModuleCache = new Map();
+function preloadModule(metadata) {
+  const existingPromise = asyncModuleCache.get(metadata.specifier);
+
+  if (existingPromise) {
+    if (existingPromise.status === 'fulfilled') {
+      return null;
+    }
+
+    return existingPromise;
+  } else {
+    // $FlowFixMe[unsupported-syntax]
+    let modulePromise = import(metadata.specifier);
+
+    if (metadata.async) {
+      // If the module is async, it must have been a CJS module.
+      // CJS modules are accessed through the default export in
+      // Node.js so we have to get the default export to get the
+      // full module exports.
+      modulePromise = modulePromise.then(function (value) {
+        return value.default;
+      });
+    }
+
+    modulePromise.then(value => {
+      const fulfilledThenable = modulePromise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = modulePromise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    asyncModuleCache.set(metadata.specifier, modulePromise);
+    return modulePromise;
+  }
+}
+function requireModule(metadata) {
+  let moduleExports; // We assume that preloadModule has been called before, which
+  // should have added something to the module cache.
+
+  const promise = asyncModuleCache.get(metadata.specifier);
+
+  if (promise.status === 'fulfilled') {
+    moduleExports = promise.value;
+  } else {
+    throw promise.reason;
+  }
+
+  if (metadata.name === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata.name === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.default;
+  }
+
+  return moduleExports[metadata.name];
+}
+
+// The server acts as a Client of itself when resolving Server References.
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const RESOLVED_MODEL = 'resolved_model';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function bindArgs$1(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference$1(response, id, bound, parentChunk, parentObject, key) {
+  const serverReference = resolveServerReference(response._bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+  let promise;
+
+  if (bound) {
+    promise = Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs$1(requireModule(serverReference), args);
+    });
+  } else {
+    if (preloadPromise) {
+      promise = Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+    } else {
+      // Synchronously available
+      return requireModule(serverReference);
+    }
+  }
+
+  promise.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk)); // We need a placeholder value that will be replaced later.
+
+  return null;
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+
+  try {
+    const value = JSON.parse(chunk.value, chunk._response._fromJSON);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    const prefix = response._prefix;
+    const key = prefix + id; // Check if we have this field in the backing store already.
+
+    const backingEntry = response._formData.get(key);
+
+    if (backingEntry != null) {
+      // We assume that this is a string entry for now.
+      chunk = createResolvedModelChunk(response, backingEntry);
+    } else {
+      // We're still waiting on this entry to stream in.
+      chunk = createPendingChunk(response);
+    }
+
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+    blocked.deps++;
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  if (chunk.status === RESOLVED_MODEL) {
+    initializeModelChunk(chunk);
+  }
+
+  if (chunk.status !== INITIALIZED) {
+    // We know that this is emitted earlier so otherwise it's an error.
+    throw chunk.reason;
+  }
+
+  return chunk.value;
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16); // TODO: Just encode this in the reference inline instead of as a model.
+
+          const metaData = getOutlinedModel(response, id);
+          return loadServerReference$1(response, metaData.id, metaData.bound, initializingChunk, parentObject, key);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'K':
+        {
+          // FormData
+          const stringId = value.slice(2);
+          const formPrefix = response._prefix + stringId + '_';
+          const data = new FormData();
+          const backingFormData = response._formData; // We assume that the reference to FormData always comes after each
+          // entry that it references so we can assume they all exist in the
+          // backing store already.
+          // $FlowFixMe[prop-missing] FormData has forEach on it.
+
+          backingFormData.forEach((entry, entryKey) => {
+            if (entryKey.startsWith(formPrefix)) {
+              data.append(entryKey.slice(formPrefix.length), entry);
+            }
+          });
+          return data;
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function createResponse(bundlerConfig, formFieldPrefix) {
+  let backingFormData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new FormData();
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _prefix: formFieldPrefix,
+    _formData: backingFormData,
+    _chunks: chunks,
+    _fromJSON: function (key, value) {
+      if (typeof value === 'string') {
+        // We can't use .bind here because we need the "this" value.
+        return parseModelString(response, this, key, value);
+      }
+
+      return value;
+    }
+  };
+  return response;
+}
+function resolveField(response, key, value) {
+  // Add this field to the backing store.
+  response._formData.append(key, value);
+
+  const prefix = response._prefix;
+
+  if (key.startsWith(prefix)) {
+    const chunks = response._chunks;
+    const id = +key.slice(prefix.length);
+    const chunk = chunks.get(id);
+
+    if (chunk) {
+      // We were waiting on this key so now we can resolve it.
+      resolveModelChunk(chunk, value);
+    }
+  }
+}
+function resolveFileInfo(response, key, filename, mime) {
+  return {
+    chunks: [],
+    filename,
+    mime
+  };
+}
+function resolveFileChunk(response, handle, chunk) {
+  handle.chunks.push(chunk);
+}
+function resolveFileComplete(response, key, handle) {
+  // Add this file to the backing store.
+  // Node.js doesn't expose a global File constructor so we need to use
+  // the append() form that takes the file name as the third argument,
+  // to create a File object.
+  const blob = new Blob(handle.chunks, {
+    type: handle.mime
+  });
+
+  response._formData.append(key, blob, handle.filename);
+}
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function bindArgs(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference(bundlerConfig, id, bound) {
+  const serverReference = resolveServerReference(bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+
+  if (bound) {
+    return Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs(requireModule(serverReference), args);
+    });
+  } else if (preloadPromise) {
+    return Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+  } else {
+    // Synchronously available
+    return Promise.resolve(requireModule(serverReference));
+  }
+}
+
+function decodeBoundActionMetaData(body, serverManifest, formFieldPrefix) {
+  // The data for this reference is encoded in multiple fields under this prefix.
+  const actionResponse = createResponse(serverManifest, formFieldPrefix, body);
+  close(actionResponse);
+  const refPromise = getRoot(actionResponse); // Force it to initialize
+  // $FlowFixMe
+
+  refPromise.then(() => {});
+
+  if (refPromise.status !== 'fulfilled') {
+    // $FlowFixMe
+    throw refPromise.reason;
+  }
+
+  return refPromise.value;
+}
+
+function decodeAction(body, serverManifest) {
+  // We're going to create a new formData object that holds all the fields except
+  // the implementation details of the action data.
+  const formData = new FormData();
+  let action = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (!key.startsWith('$ACTION_')) {
+      formData.append(key, value);
+      return;
+    } // Later actions may override earlier actions if a button is used to override the default
+    // form action.
+
+
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      const metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+      action = loadServerReference(serverManifest, metaData.id, metaData.bound);
+      return;
+    }
+
+    if (key.startsWith('$ACTION_ID_')) {
+      const id = key.slice(11);
+      action = loadServerReference(serverManifest, id, null);
+      return;
+    }
+  });
+
+  if (action === null) {
+    return null;
+  } // Return the action with the remaining FormData bound to the first argument.
+
+
+  return action.then(fn => fn.bind(null, formData));
+}
+
+function createDrainHandler(destination, request) {
+  return () => startFlowing(request, destination);
+}
+
+function renderToPipeableStream(model, turbopackMap, options) {
+  const request = createRequest(model, turbopackMap, options ? options.onError : undefined, options ? options.context : undefined, options ? options.identifierPrefix : undefined, options ? options.onPostpone : undefined);
+  let hasStartedFlowing = false;
+  startWork(request);
+  return {
+    pipe(destination) {
+      if (hasStartedFlowing) {
+        throw new Error('React currently only supports piping to one writable stream.');
+      }
+
+      hasStartedFlowing = true;
+      startFlowing(request, destination);
+      destination.on('drain', createDrainHandler(destination, request));
+      return destination;
+    },
+
+    abort(reason) {
+      abort(request, reason);
+    }
+
+  };
+}
+
+function decodeReplyFromBusboy(busboyStream, turbopackMap) {
+  const response = createResponse(turbopackMap, '');
+  let pendingFiles = 0;
+  const queuedFields = [];
+  busboyStream.on('field', (name, value) => {
+    if (pendingFiles > 0) {
+      // Because the 'end' event fires two microtasks after the next 'field'
+      // we would resolve files and fields out of order. To handle this properly
+      // we queue any fields we receive until the previous file is done.
+      queuedFields.push(name, value);
+    } else {
+      resolveField(response, name, value);
+    }
+  });
+  busboyStream.on('file', (name, value, _ref) => {
+    let filename = _ref.filename,
+        encoding = _ref.encoding,
+        mimeType = _ref.mimeType;
+
+    if (encoding.toLowerCase() === 'base64') {
+      throw new Error("React doesn't accept base64 encoded file uploads because we don't expect " + "form data passed from a browser to ever encode data that way. If that's " + 'the wrong assumption, we can easily fix it.');
+    }
+
+    pendingFiles++;
+    const file = resolveFileInfo(response, name, filename, mimeType);
+    value.on('data', chunk => {
+      resolveFileChunk(response, file, chunk);
+    });
+    value.on('end', () => {
+      resolveFileComplete(response, name, file);
+      pendingFiles--;
+
+      if (pendingFiles === 0) {
+        // Release any queued fields
+        for (let i = 0; i < queuedFields.length; i += 2) {
+          resolveField(response, queuedFields[i], queuedFields[i + 1]);
+        }
+
+        queuedFields.length = 0;
+      }
+    });
+  });
+  busboyStream.on('finish', () => {
+    close(response);
+  });
+  busboyStream.on('error', err => {
+    reportGlobalError(response, // $FlowFixMe[incompatible-call] types Error and mixed are incompatible
+    err);
+  });
+  return getRoot(response);
+}
+
+function decodeReply(body, turbopackMap) {
+  if (typeof body === 'string') {
+    const form = new FormData();
+    form.append('0', body);
+    body = form;
+  }
+
+  const response = createResponse(turbopackMap, '', body);
+  const root = getRoot(response);
+  close(response);
+  return root;
+}
+
+exports.createClientModuleProxy = createClientModuleProxy;
+exports.decodeAction = decodeAction;
+exports.decodeReply = decodeReply;
+exports.decodeReplyFromBusboy = decodeReplyFromBusboy;
+exports.registerClientReference = registerClientReference;
+exports.registerServerReference = registerServerReference;
+exports.renderToPipeableStream = renderToPipeableStream;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.node.unbundled.production.min.js b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.node.unbundled.production.min.js
index 722993b9d88dc..d5450ec5a65b4 100644
--- a/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.node.unbundled.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-server.node.unbundled.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-turbopack-server.node.unbundled.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-turbopack-server.node.unbundled.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var aa=require("util");require("crypto");var ba=require("async_hooks"),ca=require("react"),da=require("react-dom"),l=null,m=0,p=!0;function q(a,b){a=a.write(b);p=p&&a}
 function r(a,b){if("string"===typeof b){if(0!==b.length)if(2048<3*b.length)0<m&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=0),q(a,ea.encode(b));else{var d=l;0<m&&(d=l.subarray(m));d=ea.encodeInto(b,d);var c=d.read;m+=d.written;c<b.length&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=ea.encodeInto(b.slice(c),l).written);2048===m&&(q(a,l),l=new Uint8Array(2048),m=0)}}else 0!==b.byteLength&&(2048<b.byteLength?(0<m&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=0),q(a,b)):(d=l.length-m,d<b.byteLength&&
 (0===d?q(a,l):(l.set(b.subarray(0,d),m),m+=d,q(a,l),b=b.subarray(d)),l=new Uint8Array(2048),m=0),l.set(b,m),m+=b.byteLength,2048===m&&(q(a,l),l=new Uint8Array(2048),m=0)));return p}var ea=new aa.TextEncoder,t=Symbol.for("react.client.reference"),v=Symbol.for("react.server.reference");function x(a,b,d){return Object.defineProperties(a,{$$typeof:{value:t},$$id:{value:b},$$async:{value:d}})}var fa=Function.prototype.bind,ha=Array.prototype.slice;
@@ -80,3 +80,5 @@ exports.decodeAction=function(a,b){var d=new FormData,c=null;a.forEach(function(
 exports.decodeReplyFromBusboy=function(a,b){var d=bc(b,""),c=0,e=[];a.on("field",function(f,g){0<c?e.push(f,g):cc(d,f,g)});a.on("file",function(f,g,k){var h=k.filename,n=k.mimeType;if("base64"===k.encoding.toLowerCase())throw Error("React doesn't accept base64 encoded file uploads because we don't expect form data passed from a browser to ever encode data that way. If that's the wrong assumption, we can easily fix it.");c++;var w=[];g.on("data",function(u){w.push(u)});g.on("end",function(){var u=
 new Blob(w,{type:n});d._formData.append(f,u,h);c--;if(0===c){for(u=0;u<e.length;u+=2)cc(d,e[u],e[u+1]);e.length=0}})});a.on("finish",function(){dc(d)});a.on("error",function(f){Wb(d,f)});return Z(d,0)};exports.registerClientReference=function(a,b,d){return x(a,b+"#"+d,!1)};exports.registerServerReference=function(a,b,d){return Object.defineProperties(a,{$$typeof:{value:v},$$id:{value:null===d?b:b+"#"+d},$$bound:{value:null},bind:{value:ia}})};
 exports.renderToPipeableStream=function(a,b,d){var c=sb(a,b,d?d.onError:void 0,d?d.context:void 0,d?d.identifierPrefix:void 0,d?d.onPostpone:void 0),e=!1;Jb(c);return{pipe:function(f){if(e)throw Error("React currently only supports piping to one writable stream.");e=!0;Kb(c,f);f.on("drain",gc(f,c));return f},abort:function(f){Lb(c,f)}}};
+
+//# sourceMappingURL=react-server-dom-turbopack-server.node.unbundled.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-turbopack-experimental/package.json b/packages/next/src/compiled/react-server-dom-turbopack-experimental/package.json
index 5504e0c750032..680f60c3d85b3 100644
--- a/packages/next/src/compiled/react-server-dom-turbopack-experimental/package.json
+++ b/packages/next/src/compiled/react-server-dom-turbopack-experimental/package.json
@@ -48,7 +48,7 @@
     "loose-envify": "^1.1.0"
   },
   "peerDependencies": {
-    "react": "0.0.0-experimental-2983249dd-20231107",
-    "react-dom": "0.0.0-experimental-2983249dd-20231107"
+    "react": "0.0.0-experimental-7508dcd5c-20231108",
+    "react-dom": "0.0.0-experimental-7508dcd5c-20231108"
   }
 }
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.browser.production.js b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.browser.production.js
new file mode 100644
index 0000000000000..ec93f86e88f7b
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.browser.production.js
@@ -0,0 +1,1617 @@
+/**
+ * @license React
+ * react-server-dom-turbopack-client.browser.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var ReactDOM = require('react-dom');
+var React = require('react');
+
+// -----------------------------------------------------------------------------
+const enableBinaryFlight = false;
+
+function createStringDecoder() {
+  return new TextDecoder();
+}
+const decoderOptions = {
+  stream: true
+};
+function readPartialStringChunk(decoder, buffer) {
+  return decoder.decode(buffer, decoderOptions);
+}
+function readFinalStringChunk(decoder, buffer) {
+  return decoder.decode(buffer);
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+function resolveClientReference(bundlerConfig, metadata) {
+  if (bundlerConfig) {
+    const moduleExports = bundlerConfig[metadata[ID]];
+    let resolvedModuleData = moduleExports[metadata[NAME]];
+    let name;
+
+    if (resolvedModuleData) {
+      // The potentially aliased name.
+      name = resolvedModuleData.name;
+    } else {
+      // If we don't have this specific name, we might have the full module.
+      resolvedModuleData = moduleExports['*'];
+
+      if (!resolvedModuleData) {
+        throw new Error('Could not find the module "' + metadata[ID] + '" in the React SSR Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+      }
+
+      name = metadata[NAME];
+    }
+
+    if (isAsyncImport(metadata)) {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1
+      /* async */
+      ];
+    } else {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+    }
+  }
+
+  return metadata;
+}
+// If they're still pending they're a thenable. This map also exists
+// in Turbopack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = __turbopack_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+
+  for (let i = 0; i < chunks.length; i++) {
+    const chunkFilename = chunks[i];
+    const entry = chunkCache.get(chunkFilename);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkFilename);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkFilename, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkFilename, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = __turbopack_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+function loadChunk(filename) {
+  return __turbopack_load__(filename);
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+// This client file is in the shared folder because it applies to both SSR and browser contexts.
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function dispatchHint(code, model) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    switch (code) {
+      case 'D':
+        {
+          const refined = refineModel(code, model);
+          const href = refined;
+          dispatcher.prefetchDNS(href);
+          return;
+        }
+
+      case 'C':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preconnect(href);
+          } else {
+            const href = refined[0];
+            const crossOrigin = refined[1];
+            dispatcher.preconnect(href, crossOrigin);
+          }
+
+          return;
+        }
+
+      case 'L':
+        {
+          const refined = refineModel(code, model);
+          const href = refined[0];
+          const as = refined[1];
+
+          if (refined.length === 3) {
+            const options = refined[2];
+            dispatcher.preload(href, as, options);
+          } else {
+            dispatcher.preload(href, as);
+          }
+
+          return;
+        }
+
+      case 'm':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preloadModule(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preloadModule(href, options);
+          }
+
+          return;
+        }
+
+      case 'S':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitStyle(href);
+          } else {
+            const href = refined[0];
+            const precedence = refined[1] === 0 ? undefined : refined[1];
+            const options = refined.length === 3 ? refined[2] : undefined;
+            dispatcher.preinitStyle(href, precedence, options);
+          }
+
+          return;
+        }
+
+      case 'X':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitScript(href, options);
+          }
+
+          return;
+        }
+
+      case 'M':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitModuleScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitModuleScript(href, options);
+          }
+
+          return;
+        }
+    }
+  }
+} // Flow is having troulbe refining the HintModels so we help it a bit.
+// This should be compiled out in the production build.
+
+function refineModel(code, model) {
+  return model;
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+const ObjectPrototype = Object.prototype;
+const knownServerReferences = new WeakMap(); // Serializable values
+// Thenable<ReactServerValue>
+// function serializeByValueID(id: number): string {
+//   return '$' + id.toString(16);
+// }
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeFormDataReference(id) {
+  // Why K? F is "Function". D is "Date". What else?
+  return '$K' + id.toString(16);
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeMapID(id) {
+  return '$Q' + id.toString(16);
+}
+
+function serializeSetID(id) {
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+
+function processReply(root, formFieldPrefix, resolve, reject) {
+  let nextPartId = 1;
+  let pendingParts = 0;
+  let formData = null;
+
+  function resolveToJSON(key, value) {
+    const parent = this; // Make sure that `parent[key]` wasn't JSONified before `value` was passed to us
+
+    if (value === null) {
+      return null;
+    }
+
+    if (typeof value === 'object') {
+      // $FlowFixMe[method-unbinding]
+      if (typeof value.then === 'function') {
+        // We assume that any object with a .then property is a "Thenable" type,
+        // or a Promise type. Either of which can be represented by a Promise.
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        }
+
+        pendingParts++;
+        const promiseId = nextPartId++;
+        const thenable = value;
+        thenable.then(partValue => {
+          const partJSON = JSON.stringify(partValue, resolveToJSON); // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
+
+          const data = formData; // eslint-disable-next-line react-internal/safe-string-coercion
+
+          data.append(formFieldPrefix + promiseId, partJSON);
+          pendingParts--;
+
+          if (pendingParts === 0) {
+            resolve(data);
+          }
+        }, reason => {
+          // In the future we could consider serializing this as an error
+          // that throws on the server instead.
+          reject(reason);
+        });
+        return serializePromiseID(promiseId);
+      }
+
+      if (isArray(value)) {
+        // $FlowFixMe[incompatible-return]
+        return value;
+      } // TODO: Should we the Object.prototype.toString.call() to test for cross-realm objects?
+
+
+      if (value instanceof FormData) {
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to use rich objects as its values.
+          formData = new FormData();
+        }
+
+        const data = formData;
+        const refId = nextPartId++; // Copy all the form fields with a prefix for this reference.
+        // These must come first in the form order because we assume that all the
+        // fields are available before this is referenced.
+
+        const prefix = formFieldPrefix + refId + '_'; // $FlowFixMe[prop-missing]: FormData has forEach.
+
+        value.forEach((originalValue, originalKey) => {
+          data.append(prefix + originalKey, originalValue);
+        });
+        return serializeFormDataReference(refId);
+      }
+
+      if (value instanceof Map) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const mapId = nextPartId++;
+        formData.append(formFieldPrefix + mapId, partJSON);
+        return serializeMapID(mapId);
+      }
+
+      if (value instanceof Set) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const setId = nextPartId++;
+        formData.append(formFieldPrefix + setId, partJSON);
+        return serializeSetID(setId);
+      }
+
+      const iteratorFn = getIteratorFn(value);
+
+      if (iteratorFn) {
+        return Array.from(value);
+      } // Verify that this is a simple plain object.
+
+
+      const proto = getPrototypeOf(value);
+
+      if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+        throw new Error('Only plain objects, and a few built-ins, can be passed to Server Actions. ' + 'Classes or null prototypes are not supported.');
+      }
+
+
+      return value;
+    }
+
+    if (typeof value === 'string') {
+      // TODO: Maybe too clever. If we support URL there's no similar trick.
+      if (value[value.length - 1] === 'Z') {
+        // Possibly a Date, whose toJSON automatically calls toISOString
+        // $FlowFixMe[incompatible-use]
+        const originalValue = parent[key];
+
+        if (originalValue instanceof Date) {
+          return serializeDateFromDateJSON(value);
+        }
+      }
+
+      return escapeStringValue(value);
+    }
+
+    if (typeof value === 'boolean') {
+      return value;
+    }
+
+    if (typeof value === 'number') {
+      return serializeNumber(value);
+    }
+
+    if (typeof value === 'undefined') {
+      return serializeUndefined();
+    }
+
+    if (typeof value === 'function') {
+      const metaData = knownServerReferences.get(value);
+
+      if (metaData !== undefined) {
+        const metaDataJSON = JSON.stringify(metaData, resolveToJSON);
+
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        } // The reference to this function came from the same client so we can pass it back.
+
+
+        const refId = nextPartId++; // eslint-disable-next-line react-internal/safe-string-coercion
+
+        formData.set(formFieldPrefix + refId, metaDataJSON);
+        return serializeServerReferenceID(refId);
+      }
+
+      throw new Error('Client Functions cannot be passed directly to Server Functions. ' + 'Only Functions passed from the Server can be passed back again.');
+    }
+
+    if (typeof value === 'symbol') {
+      // $FlowFixMe[incompatible-type] `description` might be undefined
+      const name = value.description;
+
+      if (Symbol.for(name) !== value) {
+        throw new Error('Only global symbols received from Symbol.for(...) can be passed to Server Functions. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+        value.description + ") cannot be found among global symbols."));
+      }
+
+      return serializeSymbolReference(name);
+    }
+
+    if (typeof value === 'bigint') {
+      return serializeBigInt(value);
+    }
+
+    throw new Error("Type " + typeof value + " is not supported as an argument to a Server Function.");
+  } // $FlowFixMe[incompatible-type] it's not going to be undefined because we'll encode it.
+
+
+  const json = JSON.stringify(root, resolveToJSON);
+
+  if (formData === null) {
+    // If it's a simple data structure, we just use plain JSON.
+    resolve(json);
+  } else {
+    // Otherwise, we use FormData to let us stream in the result.
+    formData.set(formFieldPrefix + '0', json);
+
+    if (pendingParts === 0) {
+      // $FlowFixMe[incompatible-call] this has already been refined.
+      resolve(formData);
+    }
+  }
+}
+
+function registerServerReference(proxy, reference) {
+
+  knownServerReferences.set(proxy, reference);
+} // $FlowFixMe[method-unbinding]
+
+function createServerReference(id, callServer) {
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    return callServer(id, args);
+  };
+
+  registerServerReference(proxy, {
+    id,
+    bound: null
+  });
+  return proxy;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ROW_ID = 0;
+const ROW_TAG = 1;
+const ROW_LENGTH = 2;
+const ROW_CHUNK_BY_NEWLINE = 3;
+const ROW_CHUNK_BY_LENGTH = 4;
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const CYCLIC = 'cyclic';
+const RESOLVED_MODEL = 'resolved_model';
+const RESOLVED_MODULE = 'resolved_module';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function readChunk(chunk) {
+  // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      return chunk.value;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      // eslint-disable-next-line no-throw-literal
+      throw chunk;
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function createBlockedChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(BLOCKED, null, null, response);
+}
+
+function createErrorChunk(response, error) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(ERRORED, null, error, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function createResolvedModuleChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODULE, value, null, response);
+}
+
+function createInitializedTextChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function resolveModuleChunk(chunk, value) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODULE;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    initializeModuleChunk(resolvedChunk);
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+  const resolvedModel = chunk.value; // We go to the CYCLIC state until we've fully resolved this.
+  // We do this before parsing in case we try to initialize the same chunk
+  // while parsing the model. Such as in a cyclic reference.
+
+  const cyclicChunk = chunk;
+  cyclicChunk.status = CYCLIC;
+  cyclicChunk.value = null;
+  cyclicChunk.reason = null;
+
+  try {
+    const value = parseModel(chunk._response, resolvedModel);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const resolveListeners = cyclicChunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, value);
+      }
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+}
+
+function initializeModuleChunk(chunk) {
+  try {
+    const value = requireModule(chunk.value);
+    const initializedChunk = chunk;
+    initializedChunk.status = INITIALIZED;
+    initializedChunk.value = value;
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function createElement(type, key, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: null,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: null
+  };
+
+  return element;
+}
+
+function createLazyChunkWrapper(chunk) {
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: chunk,
+    _init: readChunk
+  };
+  return lazyType;
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunk = createPendingChunk(response);
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key, cyclic) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+
+    if (!cyclic) {
+      blocked.deps++;
+    }
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: cyclic ? 0 : 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function createServerReferenceProxy(response, metaData) {
+  const callServer = response._callServer;
+
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    const p = metaData.bound;
+
+    if (!p) {
+      return callServer(metaData.id, args);
+    }
+
+    if (p.status === INITIALIZED) {
+      const bound = p.value;
+      return callServer(metaData.id, bound.concat(args));
+    } // Since this is a fake Promise whose .then doesn't chain, we have to wrap it.
+    // TODO: Remove the wrapper once that's fixed.
+
+
+    return Promise.resolve(p).then(function (bound) {
+      return callServer(metaData.id, bound.concat(args));
+    });
+  };
+
+  registerServerReference(proxy, metaData);
+  return proxy;
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      {
+        return chunk.value;
+      }
+    // We always encode it first in the stream so it won't be pending.
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    if (value === '$') {
+      // A very common symbol.
+      return REACT_ELEMENT_TYPE;
+    }
+
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case 'L':
+        {
+          // Lazy node
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id); // We create a React.lazy wrapper around any lazy values.
+          // When passed into React, we'll know how to suspend on this.
+
+          return createLazyChunkWrapper(chunk);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'P':
+        {
+          // Server Context Provider
+          return getOrCreateServerContext(value.slice(2)).Provider;
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16);
+          const metadata = getOutlinedModel(response, id);
+          return createServerReferenceProxy(response, metadata);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+
+            case RESOLVED_MODULE:
+              initializeModuleChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+            case CYCLIC:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key, chunk.status === CYCLIC), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function parseModelTuple(response, value) {
+  const tuple = value;
+
+  if (tuple[0] === REACT_ELEMENT_TYPE) {
+    // TODO: Consider having React just directly accept these arrays as elements.
+    // Or even change the ReactElement type to be an array.
+    return createElement(tuple[1], tuple[2], tuple[3]);
+  }
+
+  return value;
+}
+
+function missingCall() {
+  throw new Error('Trying to call a function from "use server" but the callServer option ' + 'was not implemented in your router runtime.');
+}
+
+function createResponse(bundlerConfig, moduleLoading, callServer, nonce) {
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _moduleLoading: moduleLoading,
+    _callServer: callServer !== undefined ? callServer : missingCall,
+    _nonce: nonce,
+    _chunks: chunks,
+    _stringDecoder: createStringDecoder(),
+    _fromJSON: null,
+    _rowState: 0,
+    _rowID: 0,
+    _rowTag: 0,
+    _rowLength: 0,
+    _buffer: []
+  }; // Don't inline this call because it causes closure to outline the call above.
+
+  response._fromJSON = createFromJSONCallback(response);
+  return response;
+}
+
+function resolveModel(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createResolvedModelChunk(response, model));
+  } else {
+    resolveModelChunk(chunk, model);
+  }
+}
+
+function resolveText(response, id, text) {
+  const chunks = response._chunks; // We assume that we always reference large strings after they've been
+  // emitted.
+
+  chunks.set(id, createInitializedTextChunk(response, text));
+}
+
+function resolveModule(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+  const clientReferenceMetadata = parseModel(response, model);
+  const clientReference = resolveClientReference(response._bundlerConfig, clientReferenceMetadata);
+  // For now we preload all modules as early as possible since it's likely
+  // that we'll need them.
+
+  const promise = preloadModule(clientReference);
+
+  if (promise) {
+    let blockedChunk;
+
+    if (!chunk) {
+      // Technically, we should just treat promise as the chunk in this
+      // case. Because it'll just behave as any other promise.
+      blockedChunk = createBlockedChunk(response);
+      chunks.set(id, blockedChunk);
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+    }
+
+    promise.then(() => resolveModuleChunk(blockedChunk, clientReference), error => triggerErrorOnChunk(blockedChunk, error));
+  } else {
+    if (!chunk) {
+      chunks.set(id, createResolvedModuleChunk(response, clientReference));
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      resolveModuleChunk(chunk, clientReference);
+    }
+  }
+}
+
+function resolveErrorProd(response, id, digest) {
+
+  const error = new Error('An error occurred in the Server Components render. The specific message is omitted in production' + ' builds to avoid leaking sensitive details. A digest property is included on this error instance which' + ' may provide additional details about the nature of the error.');
+  error.stack = 'Error: ' + error.message;
+  error.digest = digest;
+  const errorWithDigest = error;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, errorWithDigest));
+  } else {
+    triggerErrorOnChunk(chunk, errorWithDigest);
+  }
+}
+
+function resolveHint(response, code, model) {
+  const hintModel = parseModel(response, model);
+  dispatchHint(code, hintModel);
+}
+
+function processFullRow(response, id, tag, buffer, chunk) {
+
+  const stringDecoder = response._stringDecoder;
+  let row = '';
+
+  for (let i = 0; i < buffer.length; i++) {
+    row += readPartialStringChunk(stringDecoder, buffer[i]);
+  }
+
+  row += readFinalStringChunk(stringDecoder, chunk);
+
+  switch (tag) {
+    case 73
+    /* "I" */
+    :
+      {
+        resolveModule(response, id, row);
+        return;
+      }
+
+    case 72
+    /* "H" */
+    :
+      {
+        const code = row[0];
+        resolveHint(response, code, row.slice(1));
+        return;
+      }
+
+    case 69
+    /* "E" */
+    :
+      {
+        const errorInfo = JSON.parse(row);
+
+        {
+          resolveErrorProd(response, id, errorInfo.digest);
+        }
+
+        return;
+      }
+
+    case 84
+    /* "T" */
+    :
+      {
+        resolveText(response, id, row);
+        return;
+      }
+
+    case 80
+    /* "P" */
+    :
+    // Fallthrough
+
+    default:
+      /* """ "{" "[" "t" "f" "n" "0" - "9" */
+      {
+        // We assume anything else is JSON.
+        resolveModel(response, id, row);
+        return;
+      }
+  }
+}
+
+function processBinaryChunk(response, chunk) {
+  let i = 0;
+  let rowState = response._rowState;
+  let rowID = response._rowID;
+  let rowTag = response._rowTag;
+  let rowLength = response._rowLength;
+  const buffer = response._buffer;
+  const chunkLength = chunk.length;
+
+  while (i < chunkLength) {
+    let lastIdx = -1;
+
+    switch (rowState) {
+      case ROW_ID:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 58
+          /* ":" */
+          ) {
+              // Finished the rowID, next we'll parse the tag.
+              rowState = ROW_TAG;
+            } else {
+            rowID = rowID << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_TAG:
+        {
+          const resolvedRowTag = chunk[i];
+
+          if (resolvedRowTag === 84
+          /* "T" */
+          || enableBinaryFlight 
+          /* "V" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_LENGTH;
+              i++;
+            } else if (resolvedRowTag > 64 && resolvedRowTag < 91
+          /* "A"-"Z" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_CHUNK_BY_NEWLINE;
+              i++;
+            } else {
+            rowTag = 0;
+            rowState = ROW_CHUNK_BY_NEWLINE; // This was an unknown tag so it was probably part of the data.
+          }
+
+          continue;
+        }
+
+      case ROW_LENGTH:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 44
+          /* "," */
+          ) {
+              // Finished the rowLength, next we'll buffer up to that length.
+              rowState = ROW_CHUNK_BY_LENGTH;
+            } else {
+            rowLength = rowLength << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_CHUNK_BY_NEWLINE:
+        {
+          // We're looking for a newline
+          lastIdx = chunk.indexOf(10
+          /* "\n" */
+          , i);
+          break;
+        }
+
+      case ROW_CHUNK_BY_LENGTH:
+        {
+          // We're looking for the remaining byte length
+          lastIdx = i + rowLength;
+
+          if (lastIdx > chunk.length) {
+            lastIdx = -1;
+          }
+
+          break;
+        }
+    }
+
+    const offset = chunk.byteOffset + i;
+
+    if (lastIdx > -1) {
+      // We found the last chunk of the row
+      const length = lastIdx - i;
+      const lastChunk = new Uint8Array(chunk.buffer, offset, length);
+      processFullRow(response, rowID, rowTag, buffer, lastChunk); // Reset state machine for a new row
+
+      i = lastIdx;
+
+      if (rowState === ROW_CHUNK_BY_NEWLINE) {
+        // If we're trailing by a newline we need to skip it.
+        i++;
+      }
+
+      rowState = ROW_ID;
+      rowTag = 0;
+      rowID = 0;
+      rowLength = 0;
+      buffer.length = 0;
+    } else {
+      // The rest of this row is in a future chunk. We stash the rest of the
+      // current chunk until we can process the full row.
+      const length = chunk.byteLength - i;
+      const remainingSlice = new Uint8Array(chunk.buffer, offset, length);
+      buffer.push(remainingSlice); // Update how many bytes we're still waiting for. If we're looking for
+      // a newline, this doesn't hurt since we'll just ignore it.
+
+      rowLength -= remainingSlice.byteLength;
+      break;
+    }
+  }
+
+  response._rowState = rowState;
+  response._rowID = rowID;
+  response._rowTag = rowTag;
+  response._rowLength = rowLength;
+}
+
+function parseModel(response, json) {
+  return JSON.parse(json, response._fromJSON);
+}
+
+function createFromJSONCallback(response) {
+  // $FlowFixMe[missing-this-annot]
+  return function (key, value) {
+    if (typeof value === 'string') {
+      // We can't use .bind here because we need the "this" value.
+      return parseModelString(response, this, key, value);
+    }
+
+    if (typeof value === 'object' && value !== null) {
+      return parseModelTuple(response, value);
+    }
+
+    return value;
+  };
+}
+
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function createResponseFromOptions(options) {
+  return createResponse(null, null, options && options.callServer ? options.callServer : undefined, undefined // nonce
+  );
+}
+
+function startReadingFromStream(response, stream) {
+  const reader = stream.getReader();
+
+  function progress(_ref) {
+    let done = _ref.done,
+        value = _ref.value;
+
+    if (done) {
+      close(response);
+      return;
+    }
+
+    const buffer = value;
+    processBinaryChunk(response, buffer);
+    return reader.read().then(progress).catch(error);
+  }
+
+  function error(e) {
+    reportGlobalError(response, e);
+  }
+
+  reader.read().then(progress).catch(error);
+}
+
+function createFromReadableStream(stream, options) {
+  const response = createResponseFromOptions(options);
+  startReadingFromStream(response, stream);
+  return getRoot(response);
+}
+
+function createFromFetch(promiseForResponse, options) {
+  const response = createResponseFromOptions(options);
+  promiseForResponse.then(function (r) {
+    startReadingFromStream(response, r.body);
+  }, function (e) {
+    reportGlobalError(response, e);
+  });
+  return getRoot(response);
+}
+
+function encodeReply(value)
+/* We don't use URLSearchParams yet but maybe */
+{
+  return new Promise((resolve, reject) => {
+    processReply(value, '', resolve, reject);
+  });
+}
+
+exports.createFromFetch = createFromFetch;
+exports.createFromReadableStream = createFromReadableStream;
+exports.createServerReference = createServerReference;
+exports.encodeReply = encodeReply;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.browser.production.min.js b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.browser.production.min.js
index 6b34aa4d15ef8..3a9fea181c8e8 100644
--- a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.browser.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.browser.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-turbopack-client.browser.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-turbopack-client.browser.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var r=require("react-dom"),t=require("react"),u={stream:!0};function v(a,b){if(a){var c=a[b[0]];if(a=c[b[2]])c=a.name;else{a=c["*"];if(!a)throw Error('Could not find the module "'+b[0]+'" in the React SSR Manifest. This is probably a bug in the React Server Components bundler.');c=b[2]}return 4===b.length?[a.id,a.chunks,c,1]:[a.id,a.chunks,c]}return b}var w=new Map;
 function x(a){var b=__turbopack_require__(a);if("function"!==typeof b.then||"fulfilled"===b.status)return null;b.then(function(c){b.status="fulfilled";b.value=c},function(c){b.status="rejected";b.reason=c});return b}function y(){}
 function z(a){for(var b=a[1],c=[],e=0;e<b.length;e++){var l=b[e],k=w.get(l);if(void 0===k){k=__turbopack_load__(l);c.push(k);var n=w.set.bind(w,l,null);k.then(n,y);w.set(l,k)}else null!==k&&c.push(k)}return 4===a.length?0===c.length?x(a[0]):Promise.all(c).then(function(){return x(a[0])}):0<c.length?Promise.all(c):null}
@@ -35,3 +35,5 @@ break;case "S":"string"===typeof f?h.preinitStyle(f):h.preinitStyle(f[0],0===f[1
 h.stack="Error: "+h.message;h.digest=g;g=f._chunks;(q=g.get(d))?Q(q,h):g.set(d,new L("rejected",null,h,f));break;case 84:f._chunks.set(d,new L("fulfilled",h,null,f));break;default:g=f._chunks,(q=g.get(d))?(f=q,d=h,"pending"===f.status&&(h=f.value,g=f.reason,f.status="resolved_model",f.value=d,null!==h&&(M(f),P(f,h,g)))):g.set(d,new L("resolved_model",h,null,f))}g=p;3===m&&g++;f=d=h=m=0;k.length=0}else{n=new Uint8Array(n.buffer,q,n.byteLength-g);k.push(n);f-=n.byteLength;break}}a._rowState=m;a._rowID=
 d;a._rowTag=h;a._rowLength=f;return l.read().then(c).catch(e)}}function e(k){V(a,k)}var l=b.getReader();l.read().then(c).catch(e)}exports.createFromFetch=function(a,b){var c=Y(null,null,b&&b.callServer?b.callServer:void 0,void 0);a.then(function(e){Z(c,e.body)},function(e){V(c,e)});return W(c,0)};exports.createFromReadableStream=function(a,b){b=Y(null,null,b&&b.callServer?b.callServer:void 0,void 0);Z(b,a);return W(b,0)};
 exports.createServerReference=function(a,b){function c(){var e=Array.prototype.slice.call(arguments);return b(a,e)}J(c,{id:a,bound:null});return c};exports.encodeReply=function(a){return new Promise(function(b,c){ha(a,"",b,c)})};
+
+//# sourceMappingURL=react-server-dom-turbopack-client.browser.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.edge.production.js b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.edge.production.js
new file mode 100644
index 0000000000000..9ec08f0063bdb
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.edge.production.js
@@ -0,0 +1,1846 @@
+/**
+ * @license React
+ * react-server-dom-turbopack-client.edge.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var ReactDOM = require('react-dom');
+var React = require('react');
+
+// -----------------------------------------------------------------------------
+const enableBinaryFlight = false;
+
+function createStringDecoder() {
+  return new TextDecoder();
+}
+const decoderOptions = {
+  stream: true
+};
+function readPartialStringChunk(decoder, buffer) {
+  return decoder.decode(buffer, decoderOptions);
+}
+function readFinalStringChunk(decoder, buffer) {
+  return decoder.decode(buffer);
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+// The reason this function needs to defined here in this file instead of just
+// being exported directly from the TurbopackDestination... file is because the
+// ClientReferenceMetadata is opaque and we can't unwrap it there.
+// This should get inlined and we could also just implement an unwrapping function
+// though that risks it getting used in places it shouldn't be. This is unfortunate
+// but currently it seems to be the best option we have.
+
+function prepareDestinationForModule(moduleLoading, nonce, metadata) {
+  prepareDestinationWithChunks(moduleLoading, metadata[CHUNKS], nonce);
+}
+function resolveClientReference(bundlerConfig, metadata) {
+  if (bundlerConfig) {
+    const moduleExports = bundlerConfig[metadata[ID]];
+    let resolvedModuleData = moduleExports[metadata[NAME]];
+    let name;
+
+    if (resolvedModuleData) {
+      // The potentially aliased name.
+      name = resolvedModuleData.name;
+    } else {
+      // If we don't have this specific name, we might have the full module.
+      resolvedModuleData = moduleExports['*'];
+
+      if (!resolvedModuleData) {
+        throw new Error('Could not find the module "' + metadata[ID] + '" in the React SSR Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+      }
+
+      name = metadata[NAME];
+    }
+
+    if (isAsyncImport(metadata)) {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1
+      /* async */
+      ];
+    } else {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+    }
+  }
+
+  return metadata;
+}
+// If they're still pending they're a thenable. This map also exists
+// in Turbopack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = globalThis.__next_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+
+  for (let i = 0; i < chunks.length; i++) {
+    const chunkFilename = chunks[i];
+    const entry = chunkCache.get(chunkFilename);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkFilename);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkFilename, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkFilename, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = globalThis.__next_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+function loadChunk(filename) {
+  return globalThis.__next_chunk_load__(filename);
+}
+
+function prepareDestinationWithChunks(moduleLoading, // Chunks are single-indexed filenames
+chunks, nonce) {
+  if (moduleLoading !== null) {
+    for (let i = 0; i < chunks.length; i++) {
+      preinitScriptForSSR(moduleLoading.prefix + chunks[i], nonce, moduleLoading.crossOrigin);
+    }
+  }
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// This client file is in the shared folder because it applies to both SSR and browser contexts.
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function dispatchHint(code, model) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    switch (code) {
+      case 'D':
+        {
+          const refined = refineModel(code, model);
+          const href = refined;
+          dispatcher.prefetchDNS(href);
+          return;
+        }
+
+      case 'C':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preconnect(href);
+          } else {
+            const href = refined[0];
+            const crossOrigin = refined[1];
+            dispatcher.preconnect(href, crossOrigin);
+          }
+
+          return;
+        }
+
+      case 'L':
+        {
+          const refined = refineModel(code, model);
+          const href = refined[0];
+          const as = refined[1];
+
+          if (refined.length === 3) {
+            const options = refined[2];
+            dispatcher.preload(href, as, options);
+          } else {
+            dispatcher.preload(href, as);
+          }
+
+          return;
+        }
+
+      case 'm':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preloadModule(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preloadModule(href, options);
+          }
+
+          return;
+        }
+
+      case 'S':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitStyle(href);
+          } else {
+            const href = refined[0];
+            const precedence = refined[1] === 0 ? undefined : refined[1];
+            const options = refined.length === 3 ? refined[2] : undefined;
+            dispatcher.preinitStyle(href, precedence, options);
+          }
+
+          return;
+        }
+
+      case 'X':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitScript(href, options);
+          }
+
+          return;
+        }
+
+      case 'M':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitModuleScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitModuleScript(href, options);
+          }
+
+          return;
+        }
+    }
+  }
+} // Flow is having troulbe refining the HintModels so we help it a bit.
+// This should be compiled out in the production build.
+
+function refineModel(code, model) {
+  return model;
+}
+function preinitScriptForSSR(href, nonce, crossOrigin) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    dispatcher.preinitScript(href, {
+      crossOrigin: getCrossOriginString(crossOrigin),
+      nonce
+    });
+  }
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+const ObjectPrototype = Object.prototype;
+const knownServerReferences = new WeakMap(); // Serializable values
+// Thenable<ReactServerValue>
+// function serializeByValueID(id: number): string {
+//   return '$' + id.toString(16);
+// }
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeFormDataReference(id) {
+  // Why K? F is "Function". D is "Date". What else?
+  return '$K' + id.toString(16);
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeMapID(id) {
+  return '$Q' + id.toString(16);
+}
+
+function serializeSetID(id) {
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+
+function processReply(root, formFieldPrefix, resolve, reject) {
+  let nextPartId = 1;
+  let pendingParts = 0;
+  let formData = null;
+
+  function resolveToJSON(key, value) {
+    const parent = this; // Make sure that `parent[key]` wasn't JSONified before `value` was passed to us
+
+    if (value === null) {
+      return null;
+    }
+
+    if (typeof value === 'object') {
+      // $FlowFixMe[method-unbinding]
+      if (typeof value.then === 'function') {
+        // We assume that any object with a .then property is a "Thenable" type,
+        // or a Promise type. Either of which can be represented by a Promise.
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        }
+
+        pendingParts++;
+        const promiseId = nextPartId++;
+        const thenable = value;
+        thenable.then(partValue => {
+          const partJSON = JSON.stringify(partValue, resolveToJSON); // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
+
+          const data = formData; // eslint-disable-next-line react-internal/safe-string-coercion
+
+          data.append(formFieldPrefix + promiseId, partJSON);
+          pendingParts--;
+
+          if (pendingParts === 0) {
+            resolve(data);
+          }
+        }, reason => {
+          // In the future we could consider serializing this as an error
+          // that throws on the server instead.
+          reject(reason);
+        });
+        return serializePromiseID(promiseId);
+      }
+
+      if (isArray(value)) {
+        // $FlowFixMe[incompatible-return]
+        return value;
+      } // TODO: Should we the Object.prototype.toString.call() to test for cross-realm objects?
+
+
+      if (value instanceof FormData) {
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to use rich objects as its values.
+          formData = new FormData();
+        }
+
+        const data = formData;
+        const refId = nextPartId++; // Copy all the form fields with a prefix for this reference.
+        // These must come first in the form order because we assume that all the
+        // fields are available before this is referenced.
+
+        const prefix = formFieldPrefix + refId + '_'; // $FlowFixMe[prop-missing]: FormData has forEach.
+
+        value.forEach((originalValue, originalKey) => {
+          data.append(prefix + originalKey, originalValue);
+        });
+        return serializeFormDataReference(refId);
+      }
+
+      if (value instanceof Map) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const mapId = nextPartId++;
+        formData.append(formFieldPrefix + mapId, partJSON);
+        return serializeMapID(mapId);
+      }
+
+      if (value instanceof Set) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const setId = nextPartId++;
+        formData.append(formFieldPrefix + setId, partJSON);
+        return serializeSetID(setId);
+      }
+
+      const iteratorFn = getIteratorFn(value);
+
+      if (iteratorFn) {
+        return Array.from(value);
+      } // Verify that this is a simple plain object.
+
+
+      const proto = getPrototypeOf(value);
+
+      if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+        throw new Error('Only plain objects, and a few built-ins, can be passed to Server Actions. ' + 'Classes or null prototypes are not supported.');
+      }
+
+
+      return value;
+    }
+
+    if (typeof value === 'string') {
+      // TODO: Maybe too clever. If we support URL there's no similar trick.
+      if (value[value.length - 1] === 'Z') {
+        // Possibly a Date, whose toJSON automatically calls toISOString
+        // $FlowFixMe[incompatible-use]
+        const originalValue = parent[key];
+
+        if (originalValue instanceof Date) {
+          return serializeDateFromDateJSON(value);
+        }
+      }
+
+      return escapeStringValue(value);
+    }
+
+    if (typeof value === 'boolean') {
+      return value;
+    }
+
+    if (typeof value === 'number') {
+      return serializeNumber(value);
+    }
+
+    if (typeof value === 'undefined') {
+      return serializeUndefined();
+    }
+
+    if (typeof value === 'function') {
+      const metaData = knownServerReferences.get(value);
+
+      if (metaData !== undefined) {
+        const metaDataJSON = JSON.stringify(metaData, resolveToJSON);
+
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        } // The reference to this function came from the same client so we can pass it back.
+
+
+        const refId = nextPartId++; // eslint-disable-next-line react-internal/safe-string-coercion
+
+        formData.set(formFieldPrefix + refId, metaDataJSON);
+        return serializeServerReferenceID(refId);
+      }
+
+      throw new Error('Client Functions cannot be passed directly to Server Functions. ' + 'Only Functions passed from the Server can be passed back again.');
+    }
+
+    if (typeof value === 'symbol') {
+      // $FlowFixMe[incompatible-type] `description` might be undefined
+      const name = value.description;
+
+      if (Symbol.for(name) !== value) {
+        throw new Error('Only global symbols received from Symbol.for(...) can be passed to Server Functions. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+        value.description + ") cannot be found among global symbols."));
+      }
+
+      return serializeSymbolReference(name);
+    }
+
+    if (typeof value === 'bigint') {
+      return serializeBigInt(value);
+    }
+
+    throw new Error("Type " + typeof value + " is not supported as an argument to a Server Function.");
+  } // $FlowFixMe[incompatible-type] it's not going to be undefined because we'll encode it.
+
+
+  const json = JSON.stringify(root, resolveToJSON);
+
+  if (formData === null) {
+    // If it's a simple data structure, we just use plain JSON.
+    resolve(json);
+  } else {
+    // Otherwise, we use FormData to let us stream in the result.
+    formData.set(formFieldPrefix + '0', json);
+
+    if (pendingParts === 0) {
+      // $FlowFixMe[incompatible-call] this has already been refined.
+      resolve(formData);
+    }
+  }
+}
+const boundCache = new WeakMap();
+
+function encodeFormData(reference) {
+  let resolve, reject; // We need to have a handle on the thenable so that we can synchronously set
+  // its status from processReply, when it can complete synchronously.
+
+  const thenable = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  processReply(reference, '', body => {
+    if (typeof body === 'string') {
+      const data = new FormData();
+      data.append('0', body);
+      body = data;
+    }
+
+    const fulfilled = thenable;
+    fulfilled.status = 'fulfilled';
+    fulfilled.value = body;
+    resolve(body);
+  }, e => {
+    const rejected = thenable;
+    rejected.status = 'rejected';
+    rejected.reason = e;
+    reject(e);
+  });
+  return thenable;
+}
+
+function encodeFormAction(identifierPrefix) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  let data = null;
+  let name;
+  const boundPromise = reference.bound;
+
+  if (boundPromise !== null) {
+    let thenable = boundCache.get(reference);
+
+    if (!thenable) {
+      thenable = encodeFormData(reference);
+      boundCache.set(reference, thenable);
+    }
+
+    if (thenable.status === 'rejected') {
+      throw thenable.reason;
+    } else if (thenable.status !== 'fulfilled') {
+      throw thenable;
+    }
+
+    const encodedFormData = thenable.value; // This is hacky but we need the identifier prefix to be added to
+    // all fields but the suspense cache would break since we might get
+    // a new identifier each time. So we just append it at the end instead.
+
+    const prefixedData = new FormData(); // $FlowFixMe[prop-missing]
+
+    encodedFormData.forEach((value, key) => {
+      prefixedData.append('$ACTION_' + identifierPrefix + ':' + key, value);
+    });
+    data = prefixedData; // We encode the name of the prefix containing the data.
+
+    name = '$ACTION_REF_' + identifierPrefix;
+  } else {
+    // This is the simple case so we can just encode the ID.
+    name = '$ACTION_ID_' + reference.id;
+  }
+
+  return {
+    name: name,
+    method: 'POST',
+    encType: 'multipart/form-data',
+    data: data
+  };
+}
+
+function isSignatureEqual(referenceId, numberOfBoundArgs) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  if (reference.id !== referenceId) {
+    // These are different functions.
+    return false;
+  } // Now check if the number of bound arguments is the same.
+
+
+  const boundPromise = reference.bound;
+
+  if (boundPromise === null) {
+    // No bound arguments.
+    return numberOfBoundArgs === 0;
+  } // Unwrap the bound arguments array by suspending, if necessary. As with
+  // encodeFormData, this means isSignatureEqual can only be called while React
+  // is rendering.
+
+
+  switch (boundPromise.status) {
+    case 'fulfilled':
+      {
+        const boundArgs = boundPromise.value;
+        return boundArgs.length === numberOfBoundArgs;
+      }
+
+    case 'pending':
+      {
+        throw boundPromise;
+      }
+
+    case 'rejected':
+      {
+        throw boundPromise.reason;
+      }
+
+    default:
+      {
+        if (typeof boundPromise.status === 'string') ; else {
+          const pendingThenable = boundPromise;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(boundArgs => {
+            const fulfilledThenable = boundPromise;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = boundArgs;
+          }, error => {
+            const rejectedThenable = boundPromise;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          });
+        }
+
+        throw boundPromise;
+      }
+  }
+}
+
+function registerServerReference(proxy, reference) {
+  // Expose encoder for use by SSR, as well as a special bind that can be used to
+  // keep server capabilities.
+  {
+    // Only expose this in builds that would actually use it. Not needed on the client.
+    Object.defineProperties(proxy, {
+      $$FORM_ACTION: {
+        value: encodeFormAction
+      },
+      $$IS_SIGNATURE_EQUAL: {
+        value: isSignatureEqual
+      },
+      bind: {
+        value: bind
+      }
+    });
+  }
+
+  knownServerReferences.set(proxy, reference);
+} // $FlowFixMe[method-unbinding]
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+  const reference = knownServerReferences.get(this);
+
+  if (reference) {
+    const args = ArraySlice.call(arguments, 1);
+    let boundPromise = null;
+
+    if (reference.bound !== null) {
+      boundPromise = Promise.resolve(reference.bound).then(boundArgs => boundArgs.concat(args));
+    } else {
+      boundPromise = Promise.resolve(args);
+    }
+
+    registerServerReference(newFn, {
+      id: reference.id,
+      bound: boundPromise
+    });
+  }
+
+  return newFn;
+}
+
+function createServerReference$1(id, callServer) {
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    return callServer(id, args);
+  };
+
+  registerServerReference(proxy, {
+    id,
+    bound: null
+  });
+  return proxy;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ROW_ID = 0;
+const ROW_TAG = 1;
+const ROW_LENGTH = 2;
+const ROW_CHUNK_BY_NEWLINE = 3;
+const ROW_CHUNK_BY_LENGTH = 4;
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const CYCLIC = 'cyclic';
+const RESOLVED_MODEL = 'resolved_model';
+const RESOLVED_MODULE = 'resolved_module';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function readChunk(chunk) {
+  // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      return chunk.value;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      // eslint-disable-next-line no-throw-literal
+      throw chunk;
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function createBlockedChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(BLOCKED, null, null, response);
+}
+
+function createErrorChunk(response, error) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(ERRORED, null, error, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function createResolvedModuleChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODULE, value, null, response);
+}
+
+function createInitializedTextChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function resolveModuleChunk(chunk, value) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODULE;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    initializeModuleChunk(resolvedChunk);
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+  const resolvedModel = chunk.value; // We go to the CYCLIC state until we've fully resolved this.
+  // We do this before parsing in case we try to initialize the same chunk
+  // while parsing the model. Such as in a cyclic reference.
+
+  const cyclicChunk = chunk;
+  cyclicChunk.status = CYCLIC;
+  cyclicChunk.value = null;
+  cyclicChunk.reason = null;
+
+  try {
+    const value = parseModel(chunk._response, resolvedModel);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const resolveListeners = cyclicChunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, value);
+      }
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+}
+
+function initializeModuleChunk(chunk) {
+  try {
+    const value = requireModule(chunk.value);
+    const initializedChunk = chunk;
+    initializedChunk.status = INITIALIZED;
+    initializedChunk.value = value;
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function createElement(type, key, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: null,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: null
+  };
+
+  return element;
+}
+
+function createLazyChunkWrapper(chunk) {
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: chunk,
+    _init: readChunk
+  };
+  return lazyType;
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunk = createPendingChunk(response);
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key, cyclic) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+
+    if (!cyclic) {
+      blocked.deps++;
+    }
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: cyclic ? 0 : 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function createServerReferenceProxy(response, metaData) {
+  const callServer = response._callServer;
+
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    const p = metaData.bound;
+
+    if (!p) {
+      return callServer(metaData.id, args);
+    }
+
+    if (p.status === INITIALIZED) {
+      const bound = p.value;
+      return callServer(metaData.id, bound.concat(args));
+    } // Since this is a fake Promise whose .then doesn't chain, we have to wrap it.
+    // TODO: Remove the wrapper once that's fixed.
+
+
+    return Promise.resolve(p).then(function (bound) {
+      return callServer(metaData.id, bound.concat(args));
+    });
+  };
+
+  registerServerReference(proxy, metaData);
+  return proxy;
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      {
+        return chunk.value;
+      }
+    // We always encode it first in the stream so it won't be pending.
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    if (value === '$') {
+      // A very common symbol.
+      return REACT_ELEMENT_TYPE;
+    }
+
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case 'L':
+        {
+          // Lazy node
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id); // We create a React.lazy wrapper around any lazy values.
+          // When passed into React, we'll know how to suspend on this.
+
+          return createLazyChunkWrapper(chunk);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'P':
+        {
+          // Server Context Provider
+          return getOrCreateServerContext(value.slice(2)).Provider;
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16);
+          const metadata = getOutlinedModel(response, id);
+          return createServerReferenceProxy(response, metadata);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+
+            case RESOLVED_MODULE:
+              initializeModuleChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+            case CYCLIC:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key, chunk.status === CYCLIC), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function parseModelTuple(response, value) {
+  const tuple = value;
+
+  if (tuple[0] === REACT_ELEMENT_TYPE) {
+    // TODO: Consider having React just directly accept these arrays as elements.
+    // Or even change the ReactElement type to be an array.
+    return createElement(tuple[1], tuple[2], tuple[3]);
+  }
+
+  return value;
+}
+
+function missingCall() {
+  throw new Error('Trying to call a function from "use server" but the callServer option ' + 'was not implemented in your router runtime.');
+}
+
+function createResponse(bundlerConfig, moduleLoading, callServer, nonce) {
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _moduleLoading: moduleLoading,
+    _callServer: callServer !== undefined ? callServer : missingCall,
+    _nonce: nonce,
+    _chunks: chunks,
+    _stringDecoder: createStringDecoder(),
+    _fromJSON: null,
+    _rowState: 0,
+    _rowID: 0,
+    _rowTag: 0,
+    _rowLength: 0,
+    _buffer: []
+  }; // Don't inline this call because it causes closure to outline the call above.
+
+  response._fromJSON = createFromJSONCallback(response);
+  return response;
+}
+
+function resolveModel(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createResolvedModelChunk(response, model));
+  } else {
+    resolveModelChunk(chunk, model);
+  }
+}
+
+function resolveText(response, id, text) {
+  const chunks = response._chunks; // We assume that we always reference large strings after they've been
+  // emitted.
+
+  chunks.set(id, createInitializedTextChunk(response, text));
+}
+
+function resolveModule(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+  const clientReferenceMetadata = parseModel(response, model);
+  const clientReference = resolveClientReference(response._bundlerConfig, clientReferenceMetadata);
+  prepareDestinationForModule(response._moduleLoading, response._nonce, clientReferenceMetadata); // TODO: Add an option to encode modules that are lazy loaded.
+  // For now we preload all modules as early as possible since it's likely
+  // that we'll need them.
+
+  const promise = preloadModule(clientReference);
+
+  if (promise) {
+    let blockedChunk;
+
+    if (!chunk) {
+      // Technically, we should just treat promise as the chunk in this
+      // case. Because it'll just behave as any other promise.
+      blockedChunk = createBlockedChunk(response);
+      chunks.set(id, blockedChunk);
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+    }
+
+    promise.then(() => resolveModuleChunk(blockedChunk, clientReference), error => triggerErrorOnChunk(blockedChunk, error));
+  } else {
+    if (!chunk) {
+      chunks.set(id, createResolvedModuleChunk(response, clientReference));
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      resolveModuleChunk(chunk, clientReference);
+    }
+  }
+}
+
+function resolveErrorProd(response, id, digest) {
+
+  const error = new Error('An error occurred in the Server Components render. The specific message is omitted in production' + ' builds to avoid leaking sensitive details. A digest property is included on this error instance which' + ' may provide additional details about the nature of the error.');
+  error.stack = 'Error: ' + error.message;
+  error.digest = digest;
+  const errorWithDigest = error;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, errorWithDigest));
+  } else {
+    triggerErrorOnChunk(chunk, errorWithDigest);
+  }
+}
+
+function resolveHint(response, code, model) {
+  const hintModel = parseModel(response, model);
+  dispatchHint(code, hintModel);
+}
+
+function processFullRow(response, id, tag, buffer, chunk) {
+
+  const stringDecoder = response._stringDecoder;
+  let row = '';
+
+  for (let i = 0; i < buffer.length; i++) {
+    row += readPartialStringChunk(stringDecoder, buffer[i]);
+  }
+
+  row += readFinalStringChunk(stringDecoder, chunk);
+
+  switch (tag) {
+    case 73
+    /* "I" */
+    :
+      {
+        resolveModule(response, id, row);
+        return;
+      }
+
+    case 72
+    /* "H" */
+    :
+      {
+        const code = row[0];
+        resolveHint(response, code, row.slice(1));
+        return;
+      }
+
+    case 69
+    /* "E" */
+    :
+      {
+        const errorInfo = JSON.parse(row);
+
+        {
+          resolveErrorProd(response, id, errorInfo.digest);
+        }
+
+        return;
+      }
+
+    case 84
+    /* "T" */
+    :
+      {
+        resolveText(response, id, row);
+        return;
+      }
+
+    case 80
+    /* "P" */
+    :
+    // Fallthrough
+
+    default:
+      /* """ "{" "[" "t" "f" "n" "0" - "9" */
+      {
+        // We assume anything else is JSON.
+        resolveModel(response, id, row);
+        return;
+      }
+  }
+}
+
+function processBinaryChunk(response, chunk) {
+  let i = 0;
+  let rowState = response._rowState;
+  let rowID = response._rowID;
+  let rowTag = response._rowTag;
+  let rowLength = response._rowLength;
+  const buffer = response._buffer;
+  const chunkLength = chunk.length;
+
+  while (i < chunkLength) {
+    let lastIdx = -1;
+
+    switch (rowState) {
+      case ROW_ID:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 58
+          /* ":" */
+          ) {
+              // Finished the rowID, next we'll parse the tag.
+              rowState = ROW_TAG;
+            } else {
+            rowID = rowID << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_TAG:
+        {
+          const resolvedRowTag = chunk[i];
+
+          if (resolvedRowTag === 84
+          /* "T" */
+          || enableBinaryFlight 
+          /* "V" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_LENGTH;
+              i++;
+            } else if (resolvedRowTag > 64 && resolvedRowTag < 91
+          /* "A"-"Z" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_CHUNK_BY_NEWLINE;
+              i++;
+            } else {
+            rowTag = 0;
+            rowState = ROW_CHUNK_BY_NEWLINE; // This was an unknown tag so it was probably part of the data.
+          }
+
+          continue;
+        }
+
+      case ROW_LENGTH:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 44
+          /* "," */
+          ) {
+              // Finished the rowLength, next we'll buffer up to that length.
+              rowState = ROW_CHUNK_BY_LENGTH;
+            } else {
+            rowLength = rowLength << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_CHUNK_BY_NEWLINE:
+        {
+          // We're looking for a newline
+          lastIdx = chunk.indexOf(10
+          /* "\n" */
+          , i);
+          break;
+        }
+
+      case ROW_CHUNK_BY_LENGTH:
+        {
+          // We're looking for the remaining byte length
+          lastIdx = i + rowLength;
+
+          if (lastIdx > chunk.length) {
+            lastIdx = -1;
+          }
+
+          break;
+        }
+    }
+
+    const offset = chunk.byteOffset + i;
+
+    if (lastIdx > -1) {
+      // We found the last chunk of the row
+      const length = lastIdx - i;
+      const lastChunk = new Uint8Array(chunk.buffer, offset, length);
+      processFullRow(response, rowID, rowTag, buffer, lastChunk); // Reset state machine for a new row
+
+      i = lastIdx;
+
+      if (rowState === ROW_CHUNK_BY_NEWLINE) {
+        // If we're trailing by a newline we need to skip it.
+        i++;
+      }
+
+      rowState = ROW_ID;
+      rowTag = 0;
+      rowID = 0;
+      rowLength = 0;
+      buffer.length = 0;
+    } else {
+      // The rest of this row is in a future chunk. We stash the rest of the
+      // current chunk until we can process the full row.
+      const length = chunk.byteLength - i;
+      const remainingSlice = new Uint8Array(chunk.buffer, offset, length);
+      buffer.push(remainingSlice); // Update how many bytes we're still waiting for. If we're looking for
+      // a newline, this doesn't hurt since we'll just ignore it.
+
+      rowLength -= remainingSlice.byteLength;
+      break;
+    }
+  }
+
+  response._rowState = rowState;
+  response._rowID = rowID;
+  response._rowTag = rowTag;
+  response._rowLength = rowLength;
+}
+
+function parseModel(response, json) {
+  return JSON.parse(json, response._fromJSON);
+}
+
+function createFromJSONCallback(response) {
+  // $FlowFixMe[missing-this-annot]
+  return function (key, value) {
+    if (typeof value === 'string') {
+      // We can't use .bind here because we need the "this" value.
+      return parseModelString(response, this, key, value);
+    }
+
+    if (typeof value === 'object' && value !== null) {
+      return parseModelTuple(response, value);
+    }
+
+    return value;
+  };
+}
+
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function noServerCall() {
+  throw new Error('Server Functions cannot be called during initial render. ' + 'This would create a fetch waterfall. Try to use a Server Component ' + 'to pass data to Client Components instead.');
+}
+
+function createServerReference(id, callServer) {
+  return createServerReference$1(id, noServerCall);
+}
+
+function createResponseFromOptions(options) {
+  return createResponse(options.ssrManifest.moduleMap, options.ssrManifest.moduleLoading, noServerCall, typeof options.nonce === 'string' ? options.nonce : undefined);
+}
+
+function startReadingFromStream(response, stream) {
+  const reader = stream.getReader();
+
+  function progress(_ref) {
+    let done = _ref.done,
+        value = _ref.value;
+
+    if (done) {
+      close(response);
+      return;
+    }
+
+    const buffer = value;
+    processBinaryChunk(response, buffer);
+    return reader.read().then(progress).catch(error);
+  }
+
+  function error(e) {
+    reportGlobalError(response, e);
+  }
+
+  reader.read().then(progress).catch(error);
+}
+
+function createFromReadableStream(stream, options) {
+  const response = createResponseFromOptions(options);
+  startReadingFromStream(response, stream);
+  return getRoot(response);
+}
+
+function createFromFetch(promiseForResponse, options) {
+  const response = createResponseFromOptions(options);
+  promiseForResponse.then(function (r) {
+    startReadingFromStream(response, r.body);
+  }, function (e) {
+    reportGlobalError(response, e);
+  });
+  return getRoot(response);
+}
+
+function encodeReply(value)
+/* We don't use URLSearchParams yet but maybe */
+{
+  return new Promise((resolve, reject) => {
+    processReply(value, '', resolve, reject);
+  });
+}
+
+exports.createFromFetch = createFromFetch;
+exports.createFromReadableStream = createFromReadableStream;
+exports.createServerReference = createServerReference;
+exports.encodeReply = encodeReply;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.edge.production.min.js b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.edge.production.min.js
index 9a00f298bb518..13a51ce60889a 100644
--- a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.edge.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.edge.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-turbopack-client.edge.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-turbopack-client.edge.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var r=require("react-dom"),t=require("react"),u={stream:!0};function v(a,b){if(a){var c=a[b[0]];if(a=c[b[2]])c=a.name;else{a=c["*"];if(!a)throw Error('Could not find the module "'+b[0]+'" in the React SSR Manifest. This is probably a bug in the React Server Components bundler.');c=b[2]}return 4===b.length?[a.id,a.chunks,c,1]:[a.id,a.chunks,c]}return b}var w=new Map;
 function x(a){var b=globalThis.__next_require__(a);if("function"!==typeof b.then||"fulfilled"===b.status)return null;b.then(function(c){b.status="fulfilled";b.value=c},function(c){b.status="rejected";b.reason=c});return b}function aa(){}
 function ba(a){for(var b=a[1],c=[],d=0;d<b.length;d++){var f=b[d],h=w.get(f);if(void 0===h){h=globalThis.__next_chunk_load__(f);c.push(h);var n=w.set.bind(w,f,null);h.then(n,aa);w.set(f,h)}else null!==h&&c.push(h)}return 4===a.length?0===c.length?x(a[0]):Promise.all(c).then(function(){return x(a[0])}):0<c.length?Promise.all(c):null}
@@ -39,3 +39,5 @@ new Uint8Array(n.buffer,q,p-k);g=a;q=l;var V=g._stringDecoder;l="";for(var K=0;K
 break;case "S":"string"===typeof g?l.preinitStyle(g):l.preinitStyle(g[0],0===g[1]?void 0:g[1],3===g.length?g[2]:void 0);break;case "X":"string"===typeof g?l.preinitScript(g):l.preinitScript(g[0],g[1]);break;case "M":"string"===typeof g?l.preinitModuleScript(g):l.preinitModuleScript(g[0],g[1])}break;case 69:l=JSON.parse(l);k=l.digest;l=Error("An error occurred in the Server Components render. The specific message is omitted in production builds to avoid leaking sensitive details. A digest property is included on this error instance which may provide additional details about the nature of the error.");
 l.stack="Error: "+l.message;l.digest=k;k=g._chunks;(q=k.get(e))?P(q,l):k.set(e,new J("rejected",null,l,g));break;case 84:g._chunks.set(e,new J("fulfilled",l,null,g));break;default:k=g._chunks,(q=k.get(e))?(g=q,e=l,"pending"===g.status&&(l=g.value,k=g.reason,g.status="resolved_model",g.value=e,null!==l&&(L(g),O(g,l,k)))):k.set(e,new J("resolved_model",l,null,g))}k=p;3===m&&k++;g=e=l=m=0;h.length=0}else{n=new Uint8Array(n.buffer,q,n.byteLength-k);h.push(n);g-=n.byteLength;break}}a._rowState=m;a._rowID=
 e;a._rowTag=l;a._rowLength=g;return f.read().then(c).catch(d)}}function d(h){T(a,h)}var f=b.getReader();f.read().then(c).catch(d)}exports.createFromFetch=function(a,b){var c=Y(b);a.then(function(d){Z(c,d.body)},function(d){T(c,d)});return U(c,0)};exports.createFromReadableStream=function(a,b){b=Y(b);Z(b,a);return U(b,0)};exports.createServerReference=function(a){return ra(a,X)};exports.encodeReply=function(a){return new Promise(function(b,c){F(a,"",b,c)})};
+
+//# sourceMappingURL=react-server-dom-turbopack-client.edge.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.node.production.js b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.node.production.js
new file mode 100644
index 0000000000000..89f41bb3c14db
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.node.production.js
@@ -0,0 +1,1805 @@
+/**
+ * @license React
+ * react-server-dom-turbopack-client.node.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var util = require('util');
+var ReactDOM = require('react-dom');
+var React = require('react');
+
+// -----------------------------------------------------------------------------
+const enableBinaryFlight = false;
+
+function createStringDecoder() {
+  return new util.TextDecoder();
+}
+const decoderOptions = {
+  stream: true
+};
+function readPartialStringChunk(decoder, buffer) {
+  return decoder.decode(buffer, decoderOptions);
+}
+function readFinalStringChunk(decoder, buffer) {
+  return decoder.decode(buffer);
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+// The reason this function needs to defined here in this file instead of just
+// being exported directly from the TurbopackDestination... file is because the
+// ClientReferenceMetadata is opaque and we can't unwrap it there.
+// This should get inlined and we could also just implement an unwrapping function
+// though that risks it getting used in places it shouldn't be. This is unfortunate
+// but currently it seems to be the best option we have.
+
+function prepareDestinationForModule(moduleLoading, nonce, metadata) {
+  prepareDestinationWithChunks(moduleLoading, metadata[CHUNKS], nonce);
+}
+function resolveClientReference(bundlerConfig, metadata) {
+  if (bundlerConfig) {
+    const moduleExports = bundlerConfig[metadata[ID]];
+    let resolvedModuleData = moduleExports[metadata[NAME]];
+    let name;
+
+    if (resolvedModuleData) {
+      // The potentially aliased name.
+      name = resolvedModuleData.name;
+    } else {
+      // If we don't have this specific name, we might have the full module.
+      resolvedModuleData = moduleExports['*'];
+
+      if (!resolvedModuleData) {
+        throw new Error('Could not find the module "' + metadata[ID] + '" in the React SSR Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+      }
+
+      name = metadata[NAME];
+    }
+
+    if (isAsyncImport(metadata)) {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1
+      /* async */
+      ];
+    } else {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+    }
+  }
+
+  return metadata;
+}
+// If they're still pending they're a thenable. This map also exists
+// in Turbopack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = globalThis.__next_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+
+  for (let i = 0; i < chunks.length; i++) {
+    const chunkFilename = chunks[i];
+    const entry = chunkCache.get(chunkFilename);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkFilename);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkFilename, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkFilename, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = globalThis.__next_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+function loadChunk(filename) {
+  return globalThis.__next_chunk_load__(filename);
+}
+
+function prepareDestinationWithChunks(moduleLoading, // Chunks are single-indexed filenames
+chunks, nonce) {
+  if (moduleLoading !== null) {
+    for (let i = 0; i < chunks.length; i++) {
+      preinitScriptForSSR(moduleLoading.prefix + chunks[i], nonce, moduleLoading.crossOrigin);
+    }
+  }
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// This client file is in the shared folder because it applies to both SSR and browser contexts.
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function dispatchHint(code, model) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    switch (code) {
+      case 'D':
+        {
+          const refined = refineModel(code, model);
+          const href = refined;
+          dispatcher.prefetchDNS(href);
+          return;
+        }
+
+      case 'C':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preconnect(href);
+          } else {
+            const href = refined[0];
+            const crossOrigin = refined[1];
+            dispatcher.preconnect(href, crossOrigin);
+          }
+
+          return;
+        }
+
+      case 'L':
+        {
+          const refined = refineModel(code, model);
+          const href = refined[0];
+          const as = refined[1];
+
+          if (refined.length === 3) {
+            const options = refined[2];
+            dispatcher.preload(href, as, options);
+          } else {
+            dispatcher.preload(href, as);
+          }
+
+          return;
+        }
+
+      case 'm':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preloadModule(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preloadModule(href, options);
+          }
+
+          return;
+        }
+
+      case 'S':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitStyle(href);
+          } else {
+            const href = refined[0];
+            const precedence = refined[1] === 0 ? undefined : refined[1];
+            const options = refined.length === 3 ? refined[2] : undefined;
+            dispatcher.preinitStyle(href, precedence, options);
+          }
+
+          return;
+        }
+
+      case 'X':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitScript(href, options);
+          }
+
+          return;
+        }
+
+      case 'M':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitModuleScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitModuleScript(href, options);
+          }
+
+          return;
+        }
+    }
+  }
+} // Flow is having troulbe refining the HintModels so we help it a bit.
+// This should be compiled out in the production build.
+
+function refineModel(code, model) {
+  return model;
+}
+function preinitScriptForSSR(href, nonce, crossOrigin) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    dispatcher.preinitScript(href, {
+      crossOrigin: getCrossOriginString(crossOrigin),
+      nonce
+    });
+  }
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+const ObjectPrototype = Object.prototype;
+const knownServerReferences = new WeakMap(); // Serializable values
+// Thenable<ReactServerValue>
+// function serializeByValueID(id: number): string {
+//   return '$' + id.toString(16);
+// }
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeFormDataReference(id) {
+  // Why K? F is "Function". D is "Date". What else?
+  return '$K' + id.toString(16);
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeMapID(id) {
+  return '$Q' + id.toString(16);
+}
+
+function serializeSetID(id) {
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+
+function processReply(root, formFieldPrefix, resolve, reject) {
+  let nextPartId = 1;
+  let pendingParts = 0;
+  let formData = null;
+
+  function resolveToJSON(key, value) {
+    const parent = this; // Make sure that `parent[key]` wasn't JSONified before `value` was passed to us
+
+    if (value === null) {
+      return null;
+    }
+
+    if (typeof value === 'object') {
+      // $FlowFixMe[method-unbinding]
+      if (typeof value.then === 'function') {
+        // We assume that any object with a .then property is a "Thenable" type,
+        // or a Promise type. Either of which can be represented by a Promise.
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        }
+
+        pendingParts++;
+        const promiseId = nextPartId++;
+        const thenable = value;
+        thenable.then(partValue => {
+          const partJSON = JSON.stringify(partValue, resolveToJSON); // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
+
+          const data = formData; // eslint-disable-next-line react-internal/safe-string-coercion
+
+          data.append(formFieldPrefix + promiseId, partJSON);
+          pendingParts--;
+
+          if (pendingParts === 0) {
+            resolve(data);
+          }
+        }, reason => {
+          // In the future we could consider serializing this as an error
+          // that throws on the server instead.
+          reject(reason);
+        });
+        return serializePromiseID(promiseId);
+      }
+
+      if (isArray(value)) {
+        // $FlowFixMe[incompatible-return]
+        return value;
+      } // TODO: Should we the Object.prototype.toString.call() to test for cross-realm objects?
+
+
+      if (value instanceof FormData) {
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to use rich objects as its values.
+          formData = new FormData();
+        }
+
+        const data = formData;
+        const refId = nextPartId++; // Copy all the form fields with a prefix for this reference.
+        // These must come first in the form order because we assume that all the
+        // fields are available before this is referenced.
+
+        const prefix = formFieldPrefix + refId + '_'; // $FlowFixMe[prop-missing]: FormData has forEach.
+
+        value.forEach((originalValue, originalKey) => {
+          data.append(prefix + originalKey, originalValue);
+        });
+        return serializeFormDataReference(refId);
+      }
+
+      if (value instanceof Map) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const mapId = nextPartId++;
+        formData.append(formFieldPrefix + mapId, partJSON);
+        return serializeMapID(mapId);
+      }
+
+      if (value instanceof Set) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const setId = nextPartId++;
+        formData.append(formFieldPrefix + setId, partJSON);
+        return serializeSetID(setId);
+      }
+
+      const iteratorFn = getIteratorFn(value);
+
+      if (iteratorFn) {
+        return Array.from(value);
+      } // Verify that this is a simple plain object.
+
+
+      const proto = getPrototypeOf(value);
+
+      if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+        throw new Error('Only plain objects, and a few built-ins, can be passed to Server Actions. ' + 'Classes or null prototypes are not supported.');
+      }
+
+
+      return value;
+    }
+
+    if (typeof value === 'string') {
+      // TODO: Maybe too clever. If we support URL there's no similar trick.
+      if (value[value.length - 1] === 'Z') {
+        // Possibly a Date, whose toJSON automatically calls toISOString
+        // $FlowFixMe[incompatible-use]
+        const originalValue = parent[key];
+
+        if (originalValue instanceof Date) {
+          return serializeDateFromDateJSON(value);
+        }
+      }
+
+      return escapeStringValue(value);
+    }
+
+    if (typeof value === 'boolean') {
+      return value;
+    }
+
+    if (typeof value === 'number') {
+      return serializeNumber(value);
+    }
+
+    if (typeof value === 'undefined') {
+      return serializeUndefined();
+    }
+
+    if (typeof value === 'function') {
+      const metaData = knownServerReferences.get(value);
+
+      if (metaData !== undefined) {
+        const metaDataJSON = JSON.stringify(metaData, resolveToJSON);
+
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        } // The reference to this function came from the same client so we can pass it back.
+
+
+        const refId = nextPartId++; // eslint-disable-next-line react-internal/safe-string-coercion
+
+        formData.set(formFieldPrefix + refId, metaDataJSON);
+        return serializeServerReferenceID(refId);
+      }
+
+      throw new Error('Client Functions cannot be passed directly to Server Functions. ' + 'Only Functions passed from the Server can be passed back again.');
+    }
+
+    if (typeof value === 'symbol') {
+      // $FlowFixMe[incompatible-type] `description` might be undefined
+      const name = value.description;
+
+      if (Symbol.for(name) !== value) {
+        throw new Error('Only global symbols received from Symbol.for(...) can be passed to Server Functions. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+        value.description + ") cannot be found among global symbols."));
+      }
+
+      return serializeSymbolReference(name);
+    }
+
+    if (typeof value === 'bigint') {
+      return serializeBigInt(value);
+    }
+
+    throw new Error("Type " + typeof value + " is not supported as an argument to a Server Function.");
+  } // $FlowFixMe[incompatible-type] it's not going to be undefined because we'll encode it.
+
+
+  const json = JSON.stringify(root, resolveToJSON);
+
+  if (formData === null) {
+    // If it's a simple data structure, we just use plain JSON.
+    resolve(json);
+  } else {
+    // Otherwise, we use FormData to let us stream in the result.
+    formData.set(formFieldPrefix + '0', json);
+
+    if (pendingParts === 0) {
+      // $FlowFixMe[incompatible-call] this has already been refined.
+      resolve(formData);
+    }
+  }
+}
+const boundCache = new WeakMap();
+
+function encodeFormData(reference) {
+  let resolve, reject; // We need to have a handle on the thenable so that we can synchronously set
+  // its status from processReply, when it can complete synchronously.
+
+  const thenable = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  processReply(reference, '', body => {
+    if (typeof body === 'string') {
+      const data = new FormData();
+      data.append('0', body);
+      body = data;
+    }
+
+    const fulfilled = thenable;
+    fulfilled.status = 'fulfilled';
+    fulfilled.value = body;
+    resolve(body);
+  }, e => {
+    const rejected = thenable;
+    rejected.status = 'rejected';
+    rejected.reason = e;
+    reject(e);
+  });
+  return thenable;
+}
+
+function encodeFormAction(identifierPrefix) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  let data = null;
+  let name;
+  const boundPromise = reference.bound;
+
+  if (boundPromise !== null) {
+    let thenable = boundCache.get(reference);
+
+    if (!thenable) {
+      thenable = encodeFormData(reference);
+      boundCache.set(reference, thenable);
+    }
+
+    if (thenable.status === 'rejected') {
+      throw thenable.reason;
+    } else if (thenable.status !== 'fulfilled') {
+      throw thenable;
+    }
+
+    const encodedFormData = thenable.value; // This is hacky but we need the identifier prefix to be added to
+    // all fields but the suspense cache would break since we might get
+    // a new identifier each time. So we just append it at the end instead.
+
+    const prefixedData = new FormData(); // $FlowFixMe[prop-missing]
+
+    encodedFormData.forEach((value, key) => {
+      prefixedData.append('$ACTION_' + identifierPrefix + ':' + key, value);
+    });
+    data = prefixedData; // We encode the name of the prefix containing the data.
+
+    name = '$ACTION_REF_' + identifierPrefix;
+  } else {
+    // This is the simple case so we can just encode the ID.
+    name = '$ACTION_ID_' + reference.id;
+  }
+
+  return {
+    name: name,
+    method: 'POST',
+    encType: 'multipart/form-data',
+    data: data
+  };
+}
+
+function isSignatureEqual(referenceId, numberOfBoundArgs) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  if (reference.id !== referenceId) {
+    // These are different functions.
+    return false;
+  } // Now check if the number of bound arguments is the same.
+
+
+  const boundPromise = reference.bound;
+
+  if (boundPromise === null) {
+    // No bound arguments.
+    return numberOfBoundArgs === 0;
+  } // Unwrap the bound arguments array by suspending, if necessary. As with
+  // encodeFormData, this means isSignatureEqual can only be called while React
+  // is rendering.
+
+
+  switch (boundPromise.status) {
+    case 'fulfilled':
+      {
+        const boundArgs = boundPromise.value;
+        return boundArgs.length === numberOfBoundArgs;
+      }
+
+    case 'pending':
+      {
+        throw boundPromise;
+      }
+
+    case 'rejected':
+      {
+        throw boundPromise.reason;
+      }
+
+    default:
+      {
+        if (typeof boundPromise.status === 'string') ; else {
+          const pendingThenable = boundPromise;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(boundArgs => {
+            const fulfilledThenable = boundPromise;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = boundArgs;
+          }, error => {
+            const rejectedThenable = boundPromise;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          });
+        }
+
+        throw boundPromise;
+      }
+  }
+}
+
+function registerServerReference(proxy, reference) {
+  // Expose encoder for use by SSR, as well as a special bind that can be used to
+  // keep server capabilities.
+  {
+    // Only expose this in builds that would actually use it. Not needed on the client.
+    Object.defineProperties(proxy, {
+      $$FORM_ACTION: {
+        value: encodeFormAction
+      },
+      $$IS_SIGNATURE_EQUAL: {
+        value: isSignatureEqual
+      },
+      bind: {
+        value: bind
+      }
+    });
+  }
+
+  knownServerReferences.set(proxy, reference);
+} // $FlowFixMe[method-unbinding]
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+  const reference = knownServerReferences.get(this);
+
+  if (reference) {
+    const args = ArraySlice.call(arguments, 1);
+    let boundPromise = null;
+
+    if (reference.bound !== null) {
+      boundPromise = Promise.resolve(reference.bound).then(boundArgs => boundArgs.concat(args));
+    } else {
+      boundPromise = Promise.resolve(args);
+    }
+
+    registerServerReference(newFn, {
+      id: reference.id,
+      bound: boundPromise
+    });
+  }
+
+  return newFn;
+}
+
+function createServerReference$1(id, callServer) {
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    return callServer(id, args);
+  };
+
+  registerServerReference(proxy, {
+    id,
+    bound: null
+  });
+  return proxy;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ROW_ID = 0;
+const ROW_TAG = 1;
+const ROW_LENGTH = 2;
+const ROW_CHUNK_BY_NEWLINE = 3;
+const ROW_CHUNK_BY_LENGTH = 4;
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const CYCLIC = 'cyclic';
+const RESOLVED_MODEL = 'resolved_model';
+const RESOLVED_MODULE = 'resolved_module';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function readChunk(chunk) {
+  // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      return chunk.value;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      // eslint-disable-next-line no-throw-literal
+      throw chunk;
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function createBlockedChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(BLOCKED, null, null, response);
+}
+
+function createErrorChunk(response, error) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(ERRORED, null, error, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function createResolvedModuleChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODULE, value, null, response);
+}
+
+function createInitializedTextChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function resolveModuleChunk(chunk, value) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODULE;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    initializeModuleChunk(resolvedChunk);
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+  const resolvedModel = chunk.value; // We go to the CYCLIC state until we've fully resolved this.
+  // We do this before parsing in case we try to initialize the same chunk
+  // while parsing the model. Such as in a cyclic reference.
+
+  const cyclicChunk = chunk;
+  cyclicChunk.status = CYCLIC;
+  cyclicChunk.value = null;
+  cyclicChunk.reason = null;
+
+  try {
+    const value = parseModel(chunk._response, resolvedModel);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const resolveListeners = cyclicChunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, value);
+      }
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+}
+
+function initializeModuleChunk(chunk) {
+  try {
+    const value = requireModule(chunk.value);
+    const initializedChunk = chunk;
+    initializedChunk.status = INITIALIZED;
+    initializedChunk.value = value;
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function createElement(type, key, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: null,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: null
+  };
+
+  return element;
+}
+
+function createLazyChunkWrapper(chunk) {
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: chunk,
+    _init: readChunk
+  };
+  return lazyType;
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunk = createPendingChunk(response);
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key, cyclic) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+
+    if (!cyclic) {
+      blocked.deps++;
+    }
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: cyclic ? 0 : 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function createServerReferenceProxy(response, metaData) {
+  const callServer = response._callServer;
+
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    const p = metaData.bound;
+
+    if (!p) {
+      return callServer(metaData.id, args);
+    }
+
+    if (p.status === INITIALIZED) {
+      const bound = p.value;
+      return callServer(metaData.id, bound.concat(args));
+    } // Since this is a fake Promise whose .then doesn't chain, we have to wrap it.
+    // TODO: Remove the wrapper once that's fixed.
+
+
+    return Promise.resolve(p).then(function (bound) {
+      return callServer(metaData.id, bound.concat(args));
+    });
+  };
+
+  registerServerReference(proxy, metaData);
+  return proxy;
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      {
+        return chunk.value;
+      }
+    // We always encode it first in the stream so it won't be pending.
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    if (value === '$') {
+      // A very common symbol.
+      return REACT_ELEMENT_TYPE;
+    }
+
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case 'L':
+        {
+          // Lazy node
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id); // We create a React.lazy wrapper around any lazy values.
+          // When passed into React, we'll know how to suspend on this.
+
+          return createLazyChunkWrapper(chunk);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'P':
+        {
+          // Server Context Provider
+          return getOrCreateServerContext(value.slice(2)).Provider;
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16);
+          const metadata = getOutlinedModel(response, id);
+          return createServerReferenceProxy(response, metadata);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+
+            case RESOLVED_MODULE:
+              initializeModuleChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+            case CYCLIC:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key, chunk.status === CYCLIC), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function parseModelTuple(response, value) {
+  const tuple = value;
+
+  if (tuple[0] === REACT_ELEMENT_TYPE) {
+    // TODO: Consider having React just directly accept these arrays as elements.
+    // Or even change the ReactElement type to be an array.
+    return createElement(tuple[1], tuple[2], tuple[3]);
+  }
+
+  return value;
+}
+
+function missingCall() {
+  throw new Error('Trying to call a function from "use server" but the callServer option ' + 'was not implemented in your router runtime.');
+}
+
+function createResponse(bundlerConfig, moduleLoading, callServer, nonce) {
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _moduleLoading: moduleLoading,
+    _callServer: callServer !== undefined ? callServer : missingCall,
+    _nonce: nonce,
+    _chunks: chunks,
+    _stringDecoder: createStringDecoder(),
+    _fromJSON: null,
+    _rowState: 0,
+    _rowID: 0,
+    _rowTag: 0,
+    _rowLength: 0,
+    _buffer: []
+  }; // Don't inline this call because it causes closure to outline the call above.
+
+  response._fromJSON = createFromJSONCallback(response);
+  return response;
+}
+
+function resolveModel(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createResolvedModelChunk(response, model));
+  } else {
+    resolveModelChunk(chunk, model);
+  }
+}
+
+function resolveText(response, id, text) {
+  const chunks = response._chunks; // We assume that we always reference large strings after they've been
+  // emitted.
+
+  chunks.set(id, createInitializedTextChunk(response, text));
+}
+
+function resolveModule(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+  const clientReferenceMetadata = parseModel(response, model);
+  const clientReference = resolveClientReference(response._bundlerConfig, clientReferenceMetadata);
+  prepareDestinationForModule(response._moduleLoading, response._nonce, clientReferenceMetadata); // TODO: Add an option to encode modules that are lazy loaded.
+  // For now we preload all modules as early as possible since it's likely
+  // that we'll need them.
+
+  const promise = preloadModule(clientReference);
+
+  if (promise) {
+    let blockedChunk;
+
+    if (!chunk) {
+      // Technically, we should just treat promise as the chunk in this
+      // case. Because it'll just behave as any other promise.
+      blockedChunk = createBlockedChunk(response);
+      chunks.set(id, blockedChunk);
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+    }
+
+    promise.then(() => resolveModuleChunk(blockedChunk, clientReference), error => triggerErrorOnChunk(blockedChunk, error));
+  } else {
+    if (!chunk) {
+      chunks.set(id, createResolvedModuleChunk(response, clientReference));
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      resolveModuleChunk(chunk, clientReference);
+    }
+  }
+}
+
+function resolveErrorProd(response, id, digest) {
+
+  const error = new Error('An error occurred in the Server Components render. The specific message is omitted in production' + ' builds to avoid leaking sensitive details. A digest property is included on this error instance which' + ' may provide additional details about the nature of the error.');
+  error.stack = 'Error: ' + error.message;
+  error.digest = digest;
+  const errorWithDigest = error;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, errorWithDigest));
+  } else {
+    triggerErrorOnChunk(chunk, errorWithDigest);
+  }
+}
+
+function resolveHint(response, code, model) {
+  const hintModel = parseModel(response, model);
+  dispatchHint(code, hintModel);
+}
+
+function processFullRow(response, id, tag, buffer, chunk) {
+
+  const stringDecoder = response._stringDecoder;
+  let row = '';
+
+  for (let i = 0; i < buffer.length; i++) {
+    row += readPartialStringChunk(stringDecoder, buffer[i]);
+  }
+
+  row += readFinalStringChunk(stringDecoder, chunk);
+
+  switch (tag) {
+    case 73
+    /* "I" */
+    :
+      {
+        resolveModule(response, id, row);
+        return;
+      }
+
+    case 72
+    /* "H" */
+    :
+      {
+        const code = row[0];
+        resolveHint(response, code, row.slice(1));
+        return;
+      }
+
+    case 69
+    /* "E" */
+    :
+      {
+        const errorInfo = JSON.parse(row);
+
+        {
+          resolveErrorProd(response, id, errorInfo.digest);
+        }
+
+        return;
+      }
+
+    case 84
+    /* "T" */
+    :
+      {
+        resolveText(response, id, row);
+        return;
+      }
+
+    case 80
+    /* "P" */
+    :
+    // Fallthrough
+
+    default:
+      /* """ "{" "[" "t" "f" "n" "0" - "9" */
+      {
+        // We assume anything else is JSON.
+        resolveModel(response, id, row);
+        return;
+      }
+  }
+}
+
+function processBinaryChunk(response, chunk) {
+  let i = 0;
+  let rowState = response._rowState;
+  let rowID = response._rowID;
+  let rowTag = response._rowTag;
+  let rowLength = response._rowLength;
+  const buffer = response._buffer;
+  const chunkLength = chunk.length;
+
+  while (i < chunkLength) {
+    let lastIdx = -1;
+
+    switch (rowState) {
+      case ROW_ID:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 58
+          /* ":" */
+          ) {
+              // Finished the rowID, next we'll parse the tag.
+              rowState = ROW_TAG;
+            } else {
+            rowID = rowID << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_TAG:
+        {
+          const resolvedRowTag = chunk[i];
+
+          if (resolvedRowTag === 84
+          /* "T" */
+          || enableBinaryFlight 
+          /* "V" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_LENGTH;
+              i++;
+            } else if (resolvedRowTag > 64 && resolvedRowTag < 91
+          /* "A"-"Z" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_CHUNK_BY_NEWLINE;
+              i++;
+            } else {
+            rowTag = 0;
+            rowState = ROW_CHUNK_BY_NEWLINE; // This was an unknown tag so it was probably part of the data.
+          }
+
+          continue;
+        }
+
+      case ROW_LENGTH:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 44
+          /* "," */
+          ) {
+              // Finished the rowLength, next we'll buffer up to that length.
+              rowState = ROW_CHUNK_BY_LENGTH;
+            } else {
+            rowLength = rowLength << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_CHUNK_BY_NEWLINE:
+        {
+          // We're looking for a newline
+          lastIdx = chunk.indexOf(10
+          /* "\n" */
+          , i);
+          break;
+        }
+
+      case ROW_CHUNK_BY_LENGTH:
+        {
+          // We're looking for the remaining byte length
+          lastIdx = i + rowLength;
+
+          if (lastIdx > chunk.length) {
+            lastIdx = -1;
+          }
+
+          break;
+        }
+    }
+
+    const offset = chunk.byteOffset + i;
+
+    if (lastIdx > -1) {
+      // We found the last chunk of the row
+      const length = lastIdx - i;
+      const lastChunk = new Uint8Array(chunk.buffer, offset, length);
+      processFullRow(response, rowID, rowTag, buffer, lastChunk); // Reset state machine for a new row
+
+      i = lastIdx;
+
+      if (rowState === ROW_CHUNK_BY_NEWLINE) {
+        // If we're trailing by a newline we need to skip it.
+        i++;
+      }
+
+      rowState = ROW_ID;
+      rowTag = 0;
+      rowID = 0;
+      rowLength = 0;
+      buffer.length = 0;
+    } else {
+      // The rest of this row is in a future chunk. We stash the rest of the
+      // current chunk until we can process the full row.
+      const length = chunk.byteLength - i;
+      const remainingSlice = new Uint8Array(chunk.buffer, offset, length);
+      buffer.push(remainingSlice); // Update how many bytes we're still waiting for. If we're looking for
+      // a newline, this doesn't hurt since we'll just ignore it.
+
+      rowLength -= remainingSlice.byteLength;
+      break;
+    }
+  }
+
+  response._rowState = rowState;
+  response._rowID = rowID;
+  response._rowTag = rowTag;
+  response._rowLength = rowLength;
+}
+
+function parseModel(response, json) {
+  return JSON.parse(json, response._fromJSON);
+}
+
+function createFromJSONCallback(response) {
+  // $FlowFixMe[missing-this-annot]
+  return function (key, value) {
+    if (typeof value === 'string') {
+      // We can't use .bind here because we need the "this" value.
+      return parseModelString(response, this, key, value);
+    }
+
+    if (typeof value === 'object' && value !== null) {
+      return parseModelTuple(response, value);
+    }
+
+    return value;
+  };
+}
+
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function noServerCall() {
+  throw new Error('Server Functions cannot be called during initial render. ' + 'This would create a fetch waterfall. Try to use a Server Component ' + 'to pass data to Client Components instead.');
+}
+
+function createServerReference(id, callServer) {
+  return createServerReference$1(id, noServerCall);
+}
+
+function createFromNodeStream(stream, ssrManifest, options) {
+  const response = createResponse(ssrManifest.moduleMap, ssrManifest.moduleLoading, noServerCall, options && typeof options.nonce === 'string' ? options.nonce : undefined);
+  stream.on('data', chunk => {
+    processBinaryChunk(response, chunk);
+  });
+  stream.on('error', error => {
+    reportGlobalError(response, error);
+  });
+  stream.on('end', () => close(response));
+  return getRoot(response);
+}
+
+exports.createFromNodeStream = createFromNodeStream;
+exports.createServerReference = createServerReference;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.node.production.min.js b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.node.production.min.js
index cbb80231af4c2..dd45eecd41e67 100644
--- a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.node.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.node.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-turbopack-client.node.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-turbopack-client.node.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var p=require("util"),r=require("react-dom"),u=require("react"),v={stream:!0};function w(a,b){if(a){var c=a[b[0]];if(a=c[b[2]])c=a.name;else{a=c["*"];if(!a)throw Error('Could not find the module "'+b[0]+'" in the React SSR Manifest. This is probably a bug in the React Server Components bundler.');c=b[2]}return 4===b.length?[a.id,a.chunks,c,1]:[a.id,a.chunks,c]}return b}var x=new Map;
 function y(a){var b=globalThis.__next_require__(a);if("function"!==typeof b.then||"fulfilled"===b.status)return null;b.then(function(c){b.status="fulfilled";b.value=c},function(c){b.status="rejected";b.reason=c});return b}function z(){}
 function A(a){for(var b=a[1],c=[],d=0;d<b.length;d++){var g=b[d],h=x.get(g);if(void 0===h){h=globalThis.__next_chunk_load__(g);c.push(h);var l=x.set.bind(x,g,null);h.then(l,z);x.set(g,h)}else null!==h&&c.push(h)}return 4===a.length?0===c.length?y(a[0]):Promise.all(c).then(function(){return y(a[0])}):0<c.length?Promise.all(c):null}
@@ -39,3 +39,5 @@ h+f,m>g.length&&(m=-1)}var n=g.byteOffset+h;if(-1<m){f=new Uint8Array(g.buffer,n
 f.preloadModule(e):f.preloadModule(e[0],e[1]);break;case "S":"string"===typeof e?f.preinitStyle(e):f.preinitStyle(e[0],0===e[1]?void 0:e[1],3===e.length?e[2]:void 0);break;case "X":"string"===typeof e?f.preinitScript(e):f.preinitScript(e[0],e[1]);break;case "M":"string"===typeof e?f.preinitModuleScript(e):f.preinitModuleScript(e[0],e[1])}break;case 69:e=JSON.parse(e);f=e.digest;e=Error("An error occurred in the Server Components render. The specific message is omitted in production builds to avoid leaking sensitive details. A digest property is included on this error instance which may provide additional details about the nature of the error.");
 e.stack="Error: "+e.message;e.digest=f;f=d._chunks;(h=f.get(k))?S(h,e):f.set(k,new N("rejected",null,e,d));break;case 84:d._chunks.set(k,new N("fulfilled",e,null,d));break;default:f=d._chunks,(h=f.get(k))?(k=h,"pending"===k.status&&(f=k.value,h=k.reason,k.status="resolved_model",k.value=e,null!==f&&(O(k),R(k,f,h)))):f.set(k,new N("resolved_model",e,null,d))}h=m;3===l&&h++;f=k=e=l=0;t.length=0}else{g=new Uint8Array(g.buffer,n,g.byteLength-h);t.push(g);f-=g.byteLength;break}}d._rowState=l;d._rowID=
 k;d._rowTag=e;d._rowLength=f});a.on("error",function(g){W(d,g)});a.on("end",function(){W(d,Error("Connection closed."))});return X(d,0)};exports.createServerReference=function(a){return oa(a,Z)};
+
+//# sourceMappingURL=react-server-dom-turbopack-client.node.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.node.unbundled.production.js b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.node.unbundled.production.js
new file mode 100644
index 0000000000000..9c5235e2eac0d
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.node.unbundled.production.js
@@ -0,0 +1,1760 @@
+/**
+ * @license React
+ * react-server-dom-turbopack-client.node.unbundled.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var util = require('util');
+var ReactDOM = require('react-dom');
+var React = require('react');
+
+// -----------------------------------------------------------------------------
+const enableBinaryFlight = false;
+
+function createStringDecoder() {
+  return new util.TextDecoder();
+}
+const decoderOptions = {
+  stream: true
+};
+function readPartialStringChunk(decoder, buffer) {
+  return decoder.decode(buffer, decoderOptions);
+}
+function readFinalStringChunk(decoder, buffer) {
+  return decoder.decode(buffer);
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+// The reason this function needs to defined here in this file instead of just
+// being exported directly from the WebpackDestination... file is because the
+// ClientReferenceMetadata is opaque and we can't unwrap it there.
+// This should get inlined and we could also just implement an unwrapping function
+// though that risks it getting used in places it shouldn't be. This is unfortunate
+// but currently it seems to be the best option we have.
+
+function prepareDestinationForModule(moduleLoading, nonce, metadata) {
+  prepareDestinationWithChunks(moduleLoading, metadata[CHUNKS], nonce);
+}
+function resolveClientReference(bundlerConfig, metadata) {
+  const moduleExports = bundlerConfig[metadata[ID]];
+  let resolvedModuleData = moduleExports[metadata[NAME]];
+  let name;
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // If we don't have this specific name, we might have the full module.
+    resolvedModuleData = moduleExports['*'];
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + metadata[ID] + '" in the React SSR Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+
+    name = metadata[NAME];
+  }
+
+  return {
+    specifier: resolvedModuleData.specifier,
+    name: name,
+    async: isAsyncImport(metadata)
+  };
+}
+const asyncModuleCache = new Map();
+function preloadModule(metadata) {
+  const existingPromise = asyncModuleCache.get(metadata.specifier);
+
+  if (existingPromise) {
+    if (existingPromise.status === 'fulfilled') {
+      return null;
+    }
+
+    return existingPromise;
+  } else {
+    // $FlowFixMe[unsupported-syntax]
+    let modulePromise = import(metadata.specifier);
+
+    if (metadata.async) {
+      // If the module is async, it must have been a CJS module.
+      // CJS modules are accessed through the default export in
+      // Node.js so we have to get the default export to get the
+      // full module exports.
+      modulePromise = modulePromise.then(function (value) {
+        return value.default;
+      });
+    }
+
+    modulePromise.then(value => {
+      const fulfilledThenable = modulePromise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = modulePromise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    asyncModuleCache.set(metadata.specifier, modulePromise);
+    return modulePromise;
+  }
+}
+function requireModule(metadata) {
+  let moduleExports; // We assume that preloadModule has been called before, which
+  // should have added something to the module cache.
+
+  const promise = asyncModuleCache.get(metadata.specifier);
+
+  if (promise.status === 'fulfilled') {
+    moduleExports = promise.value;
+  } else {
+    throw promise.reason;
+  }
+
+  if (metadata.name === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata.name === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.default;
+  }
+
+  return moduleExports[metadata.name];
+}
+
+function prepareDestinationWithChunks(moduleLoading, // Chunks are single-indexed filenames
+chunks, nonce) {
+  if (moduleLoading !== null) {
+    for (let i = 0; i < chunks.length; i++) {
+      preinitScriptForSSR(moduleLoading.prefix + chunks[i], nonce, moduleLoading.crossOrigin);
+    }
+  }
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// This client file is in the shared folder because it applies to both SSR and browser contexts.
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function dispatchHint(code, model) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    switch (code) {
+      case 'D':
+        {
+          const refined = refineModel(code, model);
+          const href = refined;
+          dispatcher.prefetchDNS(href);
+          return;
+        }
+
+      case 'C':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preconnect(href);
+          } else {
+            const href = refined[0];
+            const crossOrigin = refined[1];
+            dispatcher.preconnect(href, crossOrigin);
+          }
+
+          return;
+        }
+
+      case 'L':
+        {
+          const refined = refineModel(code, model);
+          const href = refined[0];
+          const as = refined[1];
+
+          if (refined.length === 3) {
+            const options = refined[2];
+            dispatcher.preload(href, as, options);
+          } else {
+            dispatcher.preload(href, as);
+          }
+
+          return;
+        }
+
+      case 'm':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preloadModule(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preloadModule(href, options);
+          }
+
+          return;
+        }
+
+      case 'S':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitStyle(href);
+          } else {
+            const href = refined[0];
+            const precedence = refined[1] === 0 ? undefined : refined[1];
+            const options = refined.length === 3 ? refined[2] : undefined;
+            dispatcher.preinitStyle(href, precedence, options);
+          }
+
+          return;
+        }
+
+      case 'X':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitScript(href, options);
+          }
+
+          return;
+        }
+
+      case 'M':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitModuleScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitModuleScript(href, options);
+          }
+
+          return;
+        }
+    }
+  }
+} // Flow is having troulbe refining the HintModels so we help it a bit.
+// This should be compiled out in the production build.
+
+function refineModel(code, model) {
+  return model;
+}
+function preinitScriptForSSR(href, nonce, crossOrigin) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    dispatcher.preinitScript(href, {
+      crossOrigin: getCrossOriginString(crossOrigin),
+      nonce
+    });
+  }
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+const ObjectPrototype = Object.prototype;
+const knownServerReferences = new WeakMap(); // Serializable values
+// Thenable<ReactServerValue>
+// function serializeByValueID(id: number): string {
+//   return '$' + id.toString(16);
+// }
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeFormDataReference(id) {
+  // Why K? F is "Function". D is "Date". What else?
+  return '$K' + id.toString(16);
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeMapID(id) {
+  return '$Q' + id.toString(16);
+}
+
+function serializeSetID(id) {
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+
+function processReply(root, formFieldPrefix, resolve, reject) {
+  let nextPartId = 1;
+  let pendingParts = 0;
+  let formData = null;
+
+  function resolveToJSON(key, value) {
+    const parent = this; // Make sure that `parent[key]` wasn't JSONified before `value` was passed to us
+
+    if (value === null) {
+      return null;
+    }
+
+    if (typeof value === 'object') {
+      // $FlowFixMe[method-unbinding]
+      if (typeof value.then === 'function') {
+        // We assume that any object with a .then property is a "Thenable" type,
+        // or a Promise type. Either of which can be represented by a Promise.
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        }
+
+        pendingParts++;
+        const promiseId = nextPartId++;
+        const thenable = value;
+        thenable.then(partValue => {
+          const partJSON = JSON.stringify(partValue, resolveToJSON); // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
+
+          const data = formData; // eslint-disable-next-line react-internal/safe-string-coercion
+
+          data.append(formFieldPrefix + promiseId, partJSON);
+          pendingParts--;
+
+          if (pendingParts === 0) {
+            resolve(data);
+          }
+        }, reason => {
+          // In the future we could consider serializing this as an error
+          // that throws on the server instead.
+          reject(reason);
+        });
+        return serializePromiseID(promiseId);
+      }
+
+      if (isArray(value)) {
+        // $FlowFixMe[incompatible-return]
+        return value;
+      } // TODO: Should we the Object.prototype.toString.call() to test for cross-realm objects?
+
+
+      if (value instanceof FormData) {
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to use rich objects as its values.
+          formData = new FormData();
+        }
+
+        const data = formData;
+        const refId = nextPartId++; // Copy all the form fields with a prefix for this reference.
+        // These must come first in the form order because we assume that all the
+        // fields are available before this is referenced.
+
+        const prefix = formFieldPrefix + refId + '_'; // $FlowFixMe[prop-missing]: FormData has forEach.
+
+        value.forEach((originalValue, originalKey) => {
+          data.append(prefix + originalKey, originalValue);
+        });
+        return serializeFormDataReference(refId);
+      }
+
+      if (value instanceof Map) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const mapId = nextPartId++;
+        formData.append(formFieldPrefix + mapId, partJSON);
+        return serializeMapID(mapId);
+      }
+
+      if (value instanceof Set) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const setId = nextPartId++;
+        formData.append(formFieldPrefix + setId, partJSON);
+        return serializeSetID(setId);
+      }
+
+      const iteratorFn = getIteratorFn(value);
+
+      if (iteratorFn) {
+        return Array.from(value);
+      } // Verify that this is a simple plain object.
+
+
+      const proto = getPrototypeOf(value);
+
+      if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+        throw new Error('Only plain objects, and a few built-ins, can be passed to Server Actions. ' + 'Classes or null prototypes are not supported.');
+      }
+
+
+      return value;
+    }
+
+    if (typeof value === 'string') {
+      // TODO: Maybe too clever. If we support URL there's no similar trick.
+      if (value[value.length - 1] === 'Z') {
+        // Possibly a Date, whose toJSON automatically calls toISOString
+        // $FlowFixMe[incompatible-use]
+        const originalValue = parent[key];
+
+        if (originalValue instanceof Date) {
+          return serializeDateFromDateJSON(value);
+        }
+      }
+
+      return escapeStringValue(value);
+    }
+
+    if (typeof value === 'boolean') {
+      return value;
+    }
+
+    if (typeof value === 'number') {
+      return serializeNumber(value);
+    }
+
+    if (typeof value === 'undefined') {
+      return serializeUndefined();
+    }
+
+    if (typeof value === 'function') {
+      const metaData = knownServerReferences.get(value);
+
+      if (metaData !== undefined) {
+        const metaDataJSON = JSON.stringify(metaData, resolveToJSON);
+
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        } // The reference to this function came from the same client so we can pass it back.
+
+
+        const refId = nextPartId++; // eslint-disable-next-line react-internal/safe-string-coercion
+
+        formData.set(formFieldPrefix + refId, metaDataJSON);
+        return serializeServerReferenceID(refId);
+      }
+
+      throw new Error('Client Functions cannot be passed directly to Server Functions. ' + 'Only Functions passed from the Server can be passed back again.');
+    }
+
+    if (typeof value === 'symbol') {
+      // $FlowFixMe[incompatible-type] `description` might be undefined
+      const name = value.description;
+
+      if (Symbol.for(name) !== value) {
+        throw new Error('Only global symbols received from Symbol.for(...) can be passed to Server Functions. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+        value.description + ") cannot be found among global symbols."));
+      }
+
+      return serializeSymbolReference(name);
+    }
+
+    if (typeof value === 'bigint') {
+      return serializeBigInt(value);
+    }
+
+    throw new Error("Type " + typeof value + " is not supported as an argument to a Server Function.");
+  } // $FlowFixMe[incompatible-type] it's not going to be undefined because we'll encode it.
+
+
+  const json = JSON.stringify(root, resolveToJSON);
+
+  if (formData === null) {
+    // If it's a simple data structure, we just use plain JSON.
+    resolve(json);
+  } else {
+    // Otherwise, we use FormData to let us stream in the result.
+    formData.set(formFieldPrefix + '0', json);
+
+    if (pendingParts === 0) {
+      // $FlowFixMe[incompatible-call] this has already been refined.
+      resolve(formData);
+    }
+  }
+}
+const boundCache = new WeakMap();
+
+function encodeFormData(reference) {
+  let resolve, reject; // We need to have a handle on the thenable so that we can synchronously set
+  // its status from processReply, when it can complete synchronously.
+
+  const thenable = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  processReply(reference, '', body => {
+    if (typeof body === 'string') {
+      const data = new FormData();
+      data.append('0', body);
+      body = data;
+    }
+
+    const fulfilled = thenable;
+    fulfilled.status = 'fulfilled';
+    fulfilled.value = body;
+    resolve(body);
+  }, e => {
+    const rejected = thenable;
+    rejected.status = 'rejected';
+    rejected.reason = e;
+    reject(e);
+  });
+  return thenable;
+}
+
+function encodeFormAction(identifierPrefix) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  let data = null;
+  let name;
+  const boundPromise = reference.bound;
+
+  if (boundPromise !== null) {
+    let thenable = boundCache.get(reference);
+
+    if (!thenable) {
+      thenable = encodeFormData(reference);
+      boundCache.set(reference, thenable);
+    }
+
+    if (thenable.status === 'rejected') {
+      throw thenable.reason;
+    } else if (thenable.status !== 'fulfilled') {
+      throw thenable;
+    }
+
+    const encodedFormData = thenable.value; // This is hacky but we need the identifier prefix to be added to
+    // all fields but the suspense cache would break since we might get
+    // a new identifier each time. So we just append it at the end instead.
+
+    const prefixedData = new FormData(); // $FlowFixMe[prop-missing]
+
+    encodedFormData.forEach((value, key) => {
+      prefixedData.append('$ACTION_' + identifierPrefix + ':' + key, value);
+    });
+    data = prefixedData; // We encode the name of the prefix containing the data.
+
+    name = '$ACTION_REF_' + identifierPrefix;
+  } else {
+    // This is the simple case so we can just encode the ID.
+    name = '$ACTION_ID_' + reference.id;
+  }
+
+  return {
+    name: name,
+    method: 'POST',
+    encType: 'multipart/form-data',
+    data: data
+  };
+}
+
+function isSignatureEqual(referenceId, numberOfBoundArgs) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  if (reference.id !== referenceId) {
+    // These are different functions.
+    return false;
+  } // Now check if the number of bound arguments is the same.
+
+
+  const boundPromise = reference.bound;
+
+  if (boundPromise === null) {
+    // No bound arguments.
+    return numberOfBoundArgs === 0;
+  } // Unwrap the bound arguments array by suspending, if necessary. As with
+  // encodeFormData, this means isSignatureEqual can only be called while React
+  // is rendering.
+
+
+  switch (boundPromise.status) {
+    case 'fulfilled':
+      {
+        const boundArgs = boundPromise.value;
+        return boundArgs.length === numberOfBoundArgs;
+      }
+
+    case 'pending':
+      {
+        throw boundPromise;
+      }
+
+    case 'rejected':
+      {
+        throw boundPromise.reason;
+      }
+
+    default:
+      {
+        if (typeof boundPromise.status === 'string') ; else {
+          const pendingThenable = boundPromise;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(boundArgs => {
+            const fulfilledThenable = boundPromise;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = boundArgs;
+          }, error => {
+            const rejectedThenable = boundPromise;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          });
+        }
+
+        throw boundPromise;
+      }
+  }
+}
+
+function registerServerReference(proxy, reference) {
+  // Expose encoder for use by SSR, as well as a special bind that can be used to
+  // keep server capabilities.
+  {
+    // Only expose this in builds that would actually use it. Not needed on the client.
+    Object.defineProperties(proxy, {
+      $$FORM_ACTION: {
+        value: encodeFormAction
+      },
+      $$IS_SIGNATURE_EQUAL: {
+        value: isSignatureEqual
+      },
+      bind: {
+        value: bind
+      }
+    });
+  }
+
+  knownServerReferences.set(proxy, reference);
+} // $FlowFixMe[method-unbinding]
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+  const reference = knownServerReferences.get(this);
+
+  if (reference) {
+    const args = ArraySlice.call(arguments, 1);
+    let boundPromise = null;
+
+    if (reference.bound !== null) {
+      boundPromise = Promise.resolve(reference.bound).then(boundArgs => boundArgs.concat(args));
+    } else {
+      boundPromise = Promise.resolve(args);
+    }
+
+    registerServerReference(newFn, {
+      id: reference.id,
+      bound: boundPromise
+    });
+  }
+
+  return newFn;
+}
+
+function createServerReference$1(id, callServer) {
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    return callServer(id, args);
+  };
+
+  registerServerReference(proxy, {
+    id,
+    bound: null
+  });
+  return proxy;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ROW_ID = 0;
+const ROW_TAG = 1;
+const ROW_LENGTH = 2;
+const ROW_CHUNK_BY_NEWLINE = 3;
+const ROW_CHUNK_BY_LENGTH = 4;
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const CYCLIC = 'cyclic';
+const RESOLVED_MODEL = 'resolved_model';
+const RESOLVED_MODULE = 'resolved_module';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function readChunk(chunk) {
+  // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      return chunk.value;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      // eslint-disable-next-line no-throw-literal
+      throw chunk;
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function createBlockedChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(BLOCKED, null, null, response);
+}
+
+function createErrorChunk(response, error) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(ERRORED, null, error, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function createResolvedModuleChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODULE, value, null, response);
+}
+
+function createInitializedTextChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function resolveModuleChunk(chunk, value) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODULE;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    initializeModuleChunk(resolvedChunk);
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+  const resolvedModel = chunk.value; // We go to the CYCLIC state until we've fully resolved this.
+  // We do this before parsing in case we try to initialize the same chunk
+  // while parsing the model. Such as in a cyclic reference.
+
+  const cyclicChunk = chunk;
+  cyclicChunk.status = CYCLIC;
+  cyclicChunk.value = null;
+  cyclicChunk.reason = null;
+
+  try {
+    const value = parseModel(chunk._response, resolvedModel);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const resolveListeners = cyclicChunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, value);
+      }
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+}
+
+function initializeModuleChunk(chunk) {
+  try {
+    const value = requireModule(chunk.value);
+    const initializedChunk = chunk;
+    initializedChunk.status = INITIALIZED;
+    initializedChunk.value = value;
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function createElement(type, key, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: null,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: null
+  };
+
+  return element;
+}
+
+function createLazyChunkWrapper(chunk) {
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: chunk,
+    _init: readChunk
+  };
+  return lazyType;
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunk = createPendingChunk(response);
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key, cyclic) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+
+    if (!cyclic) {
+      blocked.deps++;
+    }
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: cyclic ? 0 : 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function createServerReferenceProxy(response, metaData) {
+  const callServer = response._callServer;
+
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    const p = metaData.bound;
+
+    if (!p) {
+      return callServer(metaData.id, args);
+    }
+
+    if (p.status === INITIALIZED) {
+      const bound = p.value;
+      return callServer(metaData.id, bound.concat(args));
+    } // Since this is a fake Promise whose .then doesn't chain, we have to wrap it.
+    // TODO: Remove the wrapper once that's fixed.
+
+
+    return Promise.resolve(p).then(function (bound) {
+      return callServer(metaData.id, bound.concat(args));
+    });
+  };
+
+  registerServerReference(proxy, metaData);
+  return proxy;
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      {
+        return chunk.value;
+      }
+    // We always encode it first in the stream so it won't be pending.
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    if (value === '$') {
+      // A very common symbol.
+      return REACT_ELEMENT_TYPE;
+    }
+
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case 'L':
+        {
+          // Lazy node
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id); // We create a React.lazy wrapper around any lazy values.
+          // When passed into React, we'll know how to suspend on this.
+
+          return createLazyChunkWrapper(chunk);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'P':
+        {
+          // Server Context Provider
+          return getOrCreateServerContext(value.slice(2)).Provider;
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16);
+          const metadata = getOutlinedModel(response, id);
+          return createServerReferenceProxy(response, metadata);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+
+            case RESOLVED_MODULE:
+              initializeModuleChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+            case CYCLIC:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key, chunk.status === CYCLIC), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function parseModelTuple(response, value) {
+  const tuple = value;
+
+  if (tuple[0] === REACT_ELEMENT_TYPE) {
+    // TODO: Consider having React just directly accept these arrays as elements.
+    // Or even change the ReactElement type to be an array.
+    return createElement(tuple[1], tuple[2], tuple[3]);
+  }
+
+  return value;
+}
+
+function missingCall() {
+  throw new Error('Trying to call a function from "use server" but the callServer option ' + 'was not implemented in your router runtime.');
+}
+
+function createResponse(bundlerConfig, moduleLoading, callServer, nonce) {
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _moduleLoading: moduleLoading,
+    _callServer: callServer !== undefined ? callServer : missingCall,
+    _nonce: nonce,
+    _chunks: chunks,
+    _stringDecoder: createStringDecoder(),
+    _fromJSON: null,
+    _rowState: 0,
+    _rowID: 0,
+    _rowTag: 0,
+    _rowLength: 0,
+    _buffer: []
+  }; // Don't inline this call because it causes closure to outline the call above.
+
+  response._fromJSON = createFromJSONCallback(response);
+  return response;
+}
+
+function resolveModel(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createResolvedModelChunk(response, model));
+  } else {
+    resolveModelChunk(chunk, model);
+  }
+}
+
+function resolveText(response, id, text) {
+  const chunks = response._chunks; // We assume that we always reference large strings after they've been
+  // emitted.
+
+  chunks.set(id, createInitializedTextChunk(response, text));
+}
+
+function resolveModule(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+  const clientReferenceMetadata = parseModel(response, model);
+  const clientReference = resolveClientReference(response._bundlerConfig, clientReferenceMetadata);
+  prepareDestinationForModule(response._moduleLoading, response._nonce, clientReferenceMetadata); // TODO: Add an option to encode modules that are lazy loaded.
+  // For now we preload all modules as early as possible since it's likely
+  // that we'll need them.
+
+  const promise = preloadModule(clientReference);
+
+  if (promise) {
+    let blockedChunk;
+
+    if (!chunk) {
+      // Technically, we should just treat promise as the chunk in this
+      // case. Because it'll just behave as any other promise.
+      blockedChunk = createBlockedChunk(response);
+      chunks.set(id, blockedChunk);
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+    }
+
+    promise.then(() => resolveModuleChunk(blockedChunk, clientReference), error => triggerErrorOnChunk(blockedChunk, error));
+  } else {
+    if (!chunk) {
+      chunks.set(id, createResolvedModuleChunk(response, clientReference));
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      resolveModuleChunk(chunk, clientReference);
+    }
+  }
+}
+
+function resolveErrorProd(response, id, digest) {
+
+  const error = new Error('An error occurred in the Server Components render. The specific message is omitted in production' + ' builds to avoid leaking sensitive details. A digest property is included on this error instance which' + ' may provide additional details about the nature of the error.');
+  error.stack = 'Error: ' + error.message;
+  error.digest = digest;
+  const errorWithDigest = error;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, errorWithDigest));
+  } else {
+    triggerErrorOnChunk(chunk, errorWithDigest);
+  }
+}
+
+function resolveHint(response, code, model) {
+  const hintModel = parseModel(response, model);
+  dispatchHint(code, hintModel);
+}
+
+function processFullRow(response, id, tag, buffer, chunk) {
+
+  const stringDecoder = response._stringDecoder;
+  let row = '';
+
+  for (let i = 0; i < buffer.length; i++) {
+    row += readPartialStringChunk(stringDecoder, buffer[i]);
+  }
+
+  row += readFinalStringChunk(stringDecoder, chunk);
+
+  switch (tag) {
+    case 73
+    /* "I" */
+    :
+      {
+        resolveModule(response, id, row);
+        return;
+      }
+
+    case 72
+    /* "H" */
+    :
+      {
+        const code = row[0];
+        resolveHint(response, code, row.slice(1));
+        return;
+      }
+
+    case 69
+    /* "E" */
+    :
+      {
+        const errorInfo = JSON.parse(row);
+
+        {
+          resolveErrorProd(response, id, errorInfo.digest);
+        }
+
+        return;
+      }
+
+    case 84
+    /* "T" */
+    :
+      {
+        resolveText(response, id, row);
+        return;
+      }
+
+    case 80
+    /* "P" */
+    :
+    // Fallthrough
+
+    default:
+      /* """ "{" "[" "t" "f" "n" "0" - "9" */
+      {
+        // We assume anything else is JSON.
+        resolveModel(response, id, row);
+        return;
+      }
+  }
+}
+
+function processBinaryChunk(response, chunk) {
+  let i = 0;
+  let rowState = response._rowState;
+  let rowID = response._rowID;
+  let rowTag = response._rowTag;
+  let rowLength = response._rowLength;
+  const buffer = response._buffer;
+  const chunkLength = chunk.length;
+
+  while (i < chunkLength) {
+    let lastIdx = -1;
+
+    switch (rowState) {
+      case ROW_ID:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 58
+          /* ":" */
+          ) {
+              // Finished the rowID, next we'll parse the tag.
+              rowState = ROW_TAG;
+            } else {
+            rowID = rowID << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_TAG:
+        {
+          const resolvedRowTag = chunk[i];
+
+          if (resolvedRowTag === 84
+          /* "T" */
+          || enableBinaryFlight 
+          /* "V" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_LENGTH;
+              i++;
+            } else if (resolvedRowTag > 64 && resolvedRowTag < 91
+          /* "A"-"Z" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_CHUNK_BY_NEWLINE;
+              i++;
+            } else {
+            rowTag = 0;
+            rowState = ROW_CHUNK_BY_NEWLINE; // This was an unknown tag so it was probably part of the data.
+          }
+
+          continue;
+        }
+
+      case ROW_LENGTH:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 44
+          /* "," */
+          ) {
+              // Finished the rowLength, next we'll buffer up to that length.
+              rowState = ROW_CHUNK_BY_LENGTH;
+            } else {
+            rowLength = rowLength << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_CHUNK_BY_NEWLINE:
+        {
+          // We're looking for a newline
+          lastIdx = chunk.indexOf(10
+          /* "\n" */
+          , i);
+          break;
+        }
+
+      case ROW_CHUNK_BY_LENGTH:
+        {
+          // We're looking for the remaining byte length
+          lastIdx = i + rowLength;
+
+          if (lastIdx > chunk.length) {
+            lastIdx = -1;
+          }
+
+          break;
+        }
+    }
+
+    const offset = chunk.byteOffset + i;
+
+    if (lastIdx > -1) {
+      // We found the last chunk of the row
+      const length = lastIdx - i;
+      const lastChunk = new Uint8Array(chunk.buffer, offset, length);
+      processFullRow(response, rowID, rowTag, buffer, lastChunk); // Reset state machine for a new row
+
+      i = lastIdx;
+
+      if (rowState === ROW_CHUNK_BY_NEWLINE) {
+        // If we're trailing by a newline we need to skip it.
+        i++;
+      }
+
+      rowState = ROW_ID;
+      rowTag = 0;
+      rowID = 0;
+      rowLength = 0;
+      buffer.length = 0;
+    } else {
+      // The rest of this row is in a future chunk. We stash the rest of the
+      // current chunk until we can process the full row.
+      const length = chunk.byteLength - i;
+      const remainingSlice = new Uint8Array(chunk.buffer, offset, length);
+      buffer.push(remainingSlice); // Update how many bytes we're still waiting for. If we're looking for
+      // a newline, this doesn't hurt since we'll just ignore it.
+
+      rowLength -= remainingSlice.byteLength;
+      break;
+    }
+  }
+
+  response._rowState = rowState;
+  response._rowID = rowID;
+  response._rowTag = rowTag;
+  response._rowLength = rowLength;
+}
+
+function parseModel(response, json) {
+  return JSON.parse(json, response._fromJSON);
+}
+
+function createFromJSONCallback(response) {
+  // $FlowFixMe[missing-this-annot]
+  return function (key, value) {
+    if (typeof value === 'string') {
+      // We can't use .bind here because we need the "this" value.
+      return parseModelString(response, this, key, value);
+    }
+
+    if (typeof value === 'object' && value !== null) {
+      return parseModelTuple(response, value);
+    }
+
+    return value;
+  };
+}
+
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function noServerCall() {
+  throw new Error('Server Functions cannot be called during initial render. ' + 'This would create a fetch waterfall. Try to use a Server Component ' + 'to pass data to Client Components instead.');
+}
+
+function createServerReference(id, callServer) {
+  return createServerReference$1(id, noServerCall);
+}
+
+function createFromNodeStream(stream, ssrManifest, options) {
+  const response = createResponse(ssrManifest.moduleMap, ssrManifest.moduleLoading, noServerCall, options && typeof options.nonce === 'string' ? options.nonce : undefined);
+  stream.on('data', chunk => {
+    processBinaryChunk(response, chunk);
+  });
+  stream.on('error', error => {
+    reportGlobalError(response, error);
+  });
+  stream.on('end', () => close(response));
+  return getRoot(response);
+}
+
+exports.createFromNodeStream = createFromNodeStream;
+exports.createServerReference = createServerReference;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.node.unbundled.production.min.js b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.node.unbundled.production.min.js
index 62c10abc50e76..3af4f3f4c31fe 100644
--- a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.node.unbundled.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-client.node.unbundled.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-turbopack-client.node.unbundled.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-turbopack-client.node.unbundled.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var p=require("util"),r=require("react-dom"),u=require("react"),v={stream:!0};function w(a,b){var d=a[b[0]];if(a=d[b[2]])d=a.name;else{a=d["*"];if(!a)throw Error('Could not find the module "'+b[0]+'" in the React SSR Manifest. This is probably a bug in the React Server Components bundler.');d=b[2]}return{specifier:a.specifier,name:d,async:4===b.length}}var x=new Map;
 function y(a){var b=x.get(a.specifier);if(b)return"fulfilled"===b.status?null:b;var d=import(a.specifier);a.async&&(d=d.then(function(c){return c.default}));d.then(function(c){var g=d;g.status="fulfilled";g.value=c},function(c){var g=d;g.status="rejected";g.reason=c});x.set(a.specifier,d);return d}
 function z(a,b,d){if(null!==a)for(var c=0;c<b.length;c++){var g=d,h=A.current;if(h){var l=h.preinitScript,k=a.prefix+b[c];var e=a.crossOrigin;e="string"===typeof e?"use-credentials"===e?e:"":void 0;l.call(h,k,{crossOrigin:e,nonce:g})}}}var A=r.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Dispatcher,B=Symbol.for("react.element"),C=Symbol.for("react.provider"),D=Symbol.for("react.server_context"),F=Symbol.for("react.lazy"),G=Symbol.for("react.default_value"),H=Symbol.iterator;
@@ -37,3 +37,5 @@ h+f,m>g.length&&(m=-1)}var n=g.byteOffset+h;if(-1<m){f=new Uint8Array(g.buffer,n
 f.preloadModule(e):f.preloadModule(e[0],e[1]);break;case "S":"string"===typeof e?f.preinitStyle(e):f.preinitStyle(e[0],0===e[1]?void 0:e[1],3===e.length?e[2]:void 0);break;case "X":"string"===typeof e?f.preinitScript(e):f.preinitScript(e[0],e[1]);break;case "M":"string"===typeof e?f.preinitModuleScript(e):f.preinitModuleScript(e[0],e[1])}break;case 69:e=JSON.parse(e);f=e.digest;e=Error("An error occurred in the Server Components render. The specific message is omitted in production builds to avoid leaking sensitive details. A digest property is included on this error instance which may provide additional details about the nature of the error.");
 e.stack="Error: "+e.message;e.digest=f;f=c._chunks;(h=f.get(k))?S(h,e):f.set(k,new N("rejected",null,e,c));break;case 84:c._chunks.set(k,new N("fulfilled",e,null,c));break;default:f=c._chunks,(h=f.get(k))?(k=h,"pending"===k.status&&(f=k.value,h=k.reason,k.status="resolved_model",k.value=e,null!==f&&(O(k),R(k,f,h)))):f.set(k,new N("resolved_model",e,null,c))}h=m;3===l&&h++;f=k=e=l=0;t.length=0}else{g=new Uint8Array(g.buffer,n,g.byteLength-h);t.push(g);f-=g.byteLength;break}}c._rowState=l;c._rowID=
 k;c._rowTag=e;c._rowLength=f});a.on("error",function(g){W(c,g)});a.on("end",function(){W(c,Error("Connection closed."))});return X(c,0)};exports.createServerReference=function(a){return ma(a,Z)};
+
+//# sourceMappingURL=react-server-dom-turbopack-client.node.unbundled.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-node-register.js b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-node-register.js
index e8df62f078ec0..dd060d358236a 100644
--- a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-node-register.js
+++ b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-node-register.js
@@ -1,15 +1,14 @@
-/**
- * @license React
- * react-server-dom-turbopack-node-register.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-turbopack-node-register.js
 
-'use strict';
+ Copyright (c) Meta Platforms, Inc. and affiliates.
 
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';const h=require("acorn-loose"),l=require("url"),q=require("module");
 module.exports=function(){const m=require("react-server-dom-turbopack/server"),n=m.registerServerReference,r=m.createClientModuleProxy,f=q.prototype._compile;q.prototype._compile=function(k,p){if(-1===k.indexOf("use client")&&-1===k.indexOf("use server"))return f.apply(this,arguments);try{var a=h.parse(k,{ecmaVersion:"2024",sourceType:"source"}).body}catch(g){return console.error("Error parsing %s %s",l,g.message),f.apply(this,arguments)}var b=!1,d=!1;for(var c=0;c<a.length;c++){var e=a[c];if("ExpressionStatement"!==
 e.type||!e.directive)break;"use client"===e.directive&&(b=!0);"use server"===e.directive&&(d=!0)}if(!b&&!d)return f.apply(this,arguments);if(b&&d)throw Error('Cannot have both "use client" and "use server" directives in the same file.');b&&(a=l.pathToFileURL(p).href,this.exports=r(a));if(d)if(f.apply(this,arguments),d=l.pathToFileURL(p).href,a=this.exports,"function"===typeof a)n(a,d,null);else for(b=Object.keys(a),c=0;c<b.length;c++){e=b[c];const g=a[b[c]];"function"===typeof g&&n(g,d,e)}}};
+
+//# sourceMappingURL=react-server-dom-turbopack-node-register.js.map
diff --git a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.browser.production.js b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.browser.production.js
new file mode 100644
index 0000000000000..60b10df23344c
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.browser.production.js
@@ -0,0 +1,3050 @@
+/**
+ * @license React
+ * react-server-dom-turbopack-server.browser.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var ReactDOM = require('react-dom');
+var React = require('react');
+
+// -----------------------------------------------------------------------------
+const enablePostpone = false;
+
+function scheduleWork(callback) {
+  callback();
+}
+const VIEW_SIZE = 512;
+let currentView = null;
+let writtenBytes = 0;
+function beginWriting(destination) {
+  currentView = new Uint8Array(VIEW_SIZE);
+  writtenBytes = 0;
+}
+function writeChunk(destination, chunk) {
+  if (chunk.byteLength === 0) {
+    return;
+  }
+
+  if (chunk.byteLength > VIEW_SIZE) {
+    // one that is cached by the streaming renderer. We will enqueu
+    // it directly and expect it is not re-used
+
+
+    if (writtenBytes > 0) {
+      destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    destination.enqueue(chunk);
+    return;
+  }
+
+  let bytesToWrite = chunk;
+  const allowableBytes = currentView.length - writtenBytes;
+
+  if (allowableBytes < bytesToWrite.byteLength) {
+    // this chunk would overflow the current view. We enqueue a full view
+    // and start a new view with the remaining chunk
+    if (allowableBytes === 0) {
+      // the current view is already full, send it
+      destination.enqueue(currentView);
+    } else {
+      // fill up the current view and apply the remaining chunk bytes
+      // to a new view.
+      currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes); // writtenBytes += allowableBytes; // this can be skipped because we are going to immediately reset the view
+
+      destination.enqueue(currentView);
+      bytesToWrite = bytesToWrite.subarray(allowableBytes);
+    }
+
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+
+  currentView.set(bytesToWrite, writtenBytes);
+  writtenBytes += bytesToWrite.byteLength;
+}
+function writeChunkAndReturn(destination, chunk) {
+  writeChunk(destination, chunk); // in web streams there is no backpressure so we can alwas write more
+
+  return true;
+}
+function completeWriting(destination) {
+  if (currentView && writtenBytes > 0) {
+    destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+    currentView = null;
+    writtenBytes = 0;
+  }
+}
+function close$1(destination) {
+  destination.close();
+}
+const textEncoder = new TextEncoder();
+function stringToChunk(content) {
+  return textEncoder.encode(content);
+}
+function byteLengthOfChunk(chunk) {
+  return chunk.byteLength;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[method-unbinding]
+  if (typeof destination.error === 'function') {
+    // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+    destination.error(error);
+  } else {
+    // Earlier implementations doesn't support this method. In that environment you're
+    // supposed to throw from a promise returned but we don't return a promise in our
+    // approach. We could fork this implementation but this is environment is an edge
+    // case to begin with. It's even less common to run this in an older environment.
+    // Even then, this is not where errors are supposed to happen and they get reported
+    // to a global callback in addition to this anyway. So it's fine just to close this.
+    destination.close();
+  }
+}
+
+// eslint-disable-next-line no-unused-vars
+const CLIENT_REFERENCE_TAG = Symbol.for('react.client.reference');
+const SERVER_REFERENCE_TAG = Symbol.for('react.server.reference');
+function isClientReference(reference) {
+  return reference.$$typeof === CLIENT_REFERENCE_TAG;
+}
+function isServerReference(reference) {
+  return reference.$$typeof === SERVER_REFERENCE_TAG;
+}
+function registerClientReference(proxyImplementation, id, exportName) {
+  return registerClientReferenceImpl(proxyImplementation, id + '#' + exportName, false);
+}
+
+function registerClientReferenceImpl(proxyImplementation, id, async) {
+  return Object.defineProperties(proxyImplementation, {
+    $$typeof: {
+      value: CLIENT_REFERENCE_TAG
+    },
+    $$id: {
+      value: id
+    },
+    $$async: {
+      value: async
+    }
+  });
+} // $FlowFixMe[method-unbinding]
+
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+
+  if (this.$$typeof === SERVER_REFERENCE_TAG) {
+    const args = ArraySlice.call(arguments, 1);
+    newFn.$$typeof = SERVER_REFERENCE_TAG;
+    newFn.$$id = this.$$id;
+    newFn.$$bound = this.$$bound ? this.$$bound.concat(args) : args;
+  }
+
+  return newFn;
+}
+
+function registerServerReference(reference, id, exportName) {
+  return Object.defineProperties(reference, {
+    $$typeof: {
+      value: SERVER_REFERENCE_TAG
+    },
+    $$id: {
+      value: exportName === null ? id : id + '#' + exportName
+    },
+    $$bound: {
+      value: null
+    },
+    bind: {
+      value: bind
+    }
+  });
+}
+const PROMISE_PROTOTYPE = Promise.prototype;
+const deepProxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        // These names are a little too common. We should probably have a way to
+        // have the Flight runtime extract the inner target instead.
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+
+      case 'displayName':
+        return undefined;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case 'Provider':
+        throw new Error("Cannot render a Client Context Provider on the Server. " + "Instead, you can export a Client Component wrapper " + "that itself renders a Client Context Provider.");
+    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+    const expression = String(target.name) + '.' + String(name);
+    throw new Error("Cannot access " + expression + " on the server. " + 'You cannot dot into a client module from a server component. ' + 'You can only pass the imported name through.');
+  },
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+const proxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case '__esModule':
+        // Something is conditionally checking which export to use. We'll pretend to be
+        // an ESM compat module but then we'll check again on the client.
+        const moduleId = target.$$id;
+        target.default = registerClientReferenceImpl(function () {
+          throw new Error("Attempted to call the default export of " + moduleId + " from the server " + "but it's on the client. It's not possible to invoke a client function from " + "the server, it can only be rendered as a Component or passed to props of a " + "Client Component.");
+        }, target.$$id + '#', target.$$async);
+        return true;
+
+      case 'then':
+        if (target.then) {
+          // Use a cached value
+          return target.then;
+        }
+
+        if (!target.$$async) {
+          // If this module is expected to return a Promise (such as an AsyncModule) then
+          // we should resolve that with a client reference that unwraps the Promise on
+          // the client.
+          const clientReference = registerClientReferenceImpl({}, target.$$id, true);
+          const proxy = new Proxy(clientReference, proxyHandlers); // Treat this as a resolved Promise for React's use()
+
+          target.status = 'fulfilled';
+          target.value = proxy;
+          const then = target.then = registerClientReferenceImpl(function then(resolve, reject) {
+            // Expose to React.
+            return Promise.resolve(resolve(proxy));
+          }, // If this is not used as a Promise but is treated as a reference to a `.then`
+          // export then we should treat it as a reference to that name.
+          target.$$id + '#then', false);
+          return then;
+        } else {
+          // Since typeof .then === 'function' is a feature test we'd continue recursing
+          // indefinitely if we return a function. Instead, we return an object reference
+          // if we check further.
+          return undefined;
+        }
+
+    }
+
+    let cachedReference = target[name];
+
+    if (!cachedReference) {
+      const reference = registerClientReferenceImpl(function () {
+        throw new Error( // eslint-disable-next-line react-internal/safe-string-coercion
+        "Attempted to call " + String(name) + "() from the server but " + String(name) + " is on the client. " + "It's not possible to invoke a client function from the server, it can " + "only be rendered as a Component or passed to props of a Client Component.");
+      }, target.$$id + '#' + name, target.$$async);
+      Object.defineProperty(reference, 'name', {
+        value: name
+      });
+      cachedReference = target[name] = new Proxy(reference, deepProxyHandlers);
+    }
+
+    return cachedReference;
+  },
+
+  getPrototypeOf(target) {
+    // Pretend to be a Promise in case anyone asks.
+    return PROMISE_PROTOTYPE;
+  },
+
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+function createClientModuleProxy(moduleId) {
+  const clientReference = registerClientReferenceImpl({}, // Represents the whole Module object instead of a particular import.
+  moduleId, false);
+  return new Proxy(clientReference, proxyHandlers);
+}
+
+function getClientReferenceKey(reference) {
+  return reference.$$async ? reference.$$id + '#async' : reference.$$id;
+}
+function resolveClientReferenceMetadata(config, clientReference) {
+  const modulePath = clientReference.$$id;
+  let name = '';
+  let resolvedModuleData = config[modulePath];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = modulePath.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = modulePath.slice(idx + 1);
+      resolvedModuleData = config[modulePath.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + modulePath + '" in the React Client Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  }
+
+  if (clientReference.$$async === true) {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1];
+  } else {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+  }
+}
+function getServerReferenceId(config, serverReference) {
+  return serverReference.$$id;
+}
+function getServerReferenceBoundArguments(config, serverReference) {
+  return serverReference.$$bound;
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMFlightServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule: preloadModule$1,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+
+function prefetchDNS(href) {
+  {
+    if (typeof href === 'string' && href) {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'D|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        emitHint(request, 'D', href);
+      }
+    }
+  }
+}
+
+function preconnect(href, crossOrigin) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = "C|" + (crossOrigin == null ? 'null' : crossOrigin) + "|" + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+
+        if (typeof crossOrigin === 'string') {
+          emitHint(request, 'C', [href, crossOrigin]);
+        } else {
+          emitHint(request, 'C', href);
+        }
+      }
+    }
+  }
+}
+
+function preload(href, as, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        let key = 'L';
+
+        if (as === 'image' && options) {
+          key += getImagePreloadKey(href, options.imageSrcSet, options.imageSizes);
+        } else {
+          key += "[" + as + "]" + href;
+        }
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          emitHint(request, 'L', [href, as, trimmed]);
+        } else {
+          emitHint(request, 'L', [href, as]);
+        }
+      }
+    }
+  }
+}
+
+function preloadModule$1(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'm|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'm', [href, trimmed]);
+        } else {
+          return emitHint(request, 'm', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'S|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'S', [href, typeof precedence === 'string' ? precedence : 0, trimmed]);
+        } else if (typeof precedence === 'string') {
+          return emitHint(request, 'S', [href, precedence]);
+        } else {
+          return emitHint(request, 'S', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'X|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'X', [href, trimmed]);
+        } else {
+          return emitHint(request, 'X', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitModuleScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'M|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'M', [href, trimmed]);
+        } else {
+          return emitHint(request, 'M', href);
+        }
+      }
+    }
+  }
+} // Flight normally encodes undefined as a special character however for directive option
+// arguments we don't want to send unnecessary keys and bloat the payload so we create a
+// trimmed object which omits any keys with null or undefined values.
+// This is only typesafe because these option objects have entirely optional fields where
+// null and undefined represent the same thing as no property.
+
+
+function trimOptions(options) {
+  if (options == null) return null;
+  let hasProperties = false;
+  const trimmed = {};
+
+  for (const key in options) {
+    if (options[key] != null) {
+      hasProperties = true;
+      trimmed[key] = options[key];
+    }
+  }
+
+  return hasProperties ? trimmed : null;
+}
+
+function getImagePreloadKey(href, imageSrcSet, imageSizes) {
+  let uniquePart = '';
+
+  if (typeof imageSrcSet === 'string' && imageSrcSet !== '') {
+    uniquePart += '[' + imageSrcSet + ']';
+
+    if (typeof imageSizes === 'string') {
+      uniquePart += '[' + imageSizes + ']';
+    }
+  } else {
+    uniquePart += '[][]' + href;
+  }
+
+  return "[image]" + uniquePart;
+}
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMFlightServerDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+// small, smaller than how we encode undefined, and is unambiguous. We could use
+// a different tuple structure to encode this instead but this makes the runtime
+// cost cheaper by eliminating a type checks in more positions.
+// prettier-ignore
+
+function createHints() {
+  return new Set();
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext); // On the way back, we push the new ones that weren't common.
+
+      pushNode(next);
+    }
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFizzWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop, noop);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+let currentRequest$1 = null;
+let thenableIndexCounter = 0;
+let thenableState = null;
+function prepareToUseHooksForRequest(request) {
+  currentRequest$1 = request;
+}
+function resetHooksForRequest() {
+  currentRequest$1 = null;
+}
+function prepareToUseHooksForComponent(prevThenableState) {
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+const HooksDispatcher = {
+  useMemo(nextCreate) {
+    return nextCreate();
+  },
+
+  useCallback(callback) {
+    return callback;
+  },
+
+  useDebugValue() {},
+
+  useDeferredValue: unsupportedHook,
+  useTransition: unsupportedHook,
+  readContext,
+  useContext: readContext,
+  useReducer: unsupportedHook,
+  useRef: unsupportedHook,
+  useState: unsupportedHook,
+  useInsertionEffect: unsupportedHook,
+  useLayoutEffect: unsupportedHook,
+  useImperativeHandle: unsupportedHook,
+  useEffect: unsupportedHook,
+  useId,
+  useSyncExternalStore: unsupportedHook,
+
+  useCacheRefresh() {
+    return unsupportedRefresh;
+  },
+
+  useMemoCache(size) {
+    const data = new Array(size);
+
+    for (let i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL;
+    }
+
+    return data;
+  },
+
+  use
+};
+
+function unsupportedHook() {
+  throw new Error('This Hook is not supported in Server Components.');
+}
+
+function unsupportedRefresh() {
+  throw new Error('Refreshing the cache is not supported in Server Components.');
+}
+
+function useId() {
+  if (currentRequest$1 === null) {
+    throw new Error('useId can only be used while React is rendering');
+  }
+
+  const id = currentRequest$1.identifierCount++; // use 'S' for Flight components to distinguish from 'R' and 'r' in Fizz/Client
+
+  return ':' + currentRequest$1.identifierPrefix + 'S' + id.toString(32) + ':';
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object' || typeof usable === 'function') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable; // Track the position of the thenable within this fiber.
+
+      const index = thenableIndexCounter;
+      thenableIndexCounter += 1;
+
+      if (thenableState === null) {
+        thenableState = createThenableState();
+      }
+
+      return trackUsedThenable(thenableState, thenable, index);
+    } else if (usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  }
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function createSignal() {
+  return new AbortController().signal;
+}
+
+function resolveCache() {
+  const request = resolveRequest();
+
+  if (request) {
+    return getCache(request);
+  }
+
+  return new Map();
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal() {
+    const cache = resolveCache();
+    let entry = cache.get(createSignal);
+
+    if (entry === undefined) {
+      entry = createSignal();
+      cache.set(createSignal, entry);
+    }
+
+    return entry;
+  },
+
+  getCacheForType(resourceType) {
+    const cache = resolveCache();
+    let entry = cache.get(resourceType);
+
+    if (entry === undefined) {
+      entry = resourceType(); // TODO: Warn if undefined?
+
+      cache.set(resourceType, entry);
+    }
+
+    return entry;
+  }
+
+};
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+function objectName(object) {
+  // $FlowFixMe[method-unbinding]
+  const name = Object.prototype.toString.call(object);
+  return name.replace(/^\[object (.*)\]$/, function (m, p0) {
+    return p0;
+  });
+}
+
+function describeKeyForErrorMessage(key) {
+  const encodedKey = JSON.stringify(key);
+  return '"' + key + '"' === encodedKey ? key : encodedKey;
+}
+
+function describeValueForErrorMessage(value) {
+  switch (typeof value) {
+    case 'string':
+      {
+        return JSON.stringify(value.length <= 10 ? value : value.slice(0, 10) + '...');
+      }
+
+    case 'object':
+      {
+        if (isArray(value)) {
+          return '[...]';
+        }
+
+        const name = objectName(value);
+
+        if (name === 'Object') {
+          return '{...}';
+        }
+
+        return name;
+      }
+
+    case 'function':
+      return 'function';
+
+    default:
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      return String(value);
+  }
+}
+
+function describeElementType(type) {
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        return describeElementType(type.render);
+
+      case REACT_MEMO_TYPE:
+        return describeElementType(type.type);
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            // Lazy may contain any component type so we recursively resolve it.
+            return describeElementType(init(payload));
+          } catch (x) {}
+        }
+    }
+  }
+
+  return '';
+}
+
+function describeObjectForErrorMessage(objectOrArray, expandedName) {
+  const objKind = objectName(objectOrArray);
+
+  if (objKind !== 'Object' && objKind !== 'Array') {
+    return objKind;
+  }
+
+  let str = '';
+  let start = -1;
+  let length = 0;
+
+  if (isArray(objectOrArray)) {
+    {
+      // Print Array
+      str = '[';
+      const array = objectOrArray;
+
+      for (let i = 0; i < array.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const value = array[i];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if ('' + i === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += ']';
+    }
+  } else {
+    if (objectOrArray.$$typeof === REACT_ELEMENT_TYPE) {
+      str = '<' + describeElementType(objectOrArray.type) + '/>';
+    } else {
+      // Print Object
+      str = '{';
+      const object = objectOrArray;
+      const names = Object.keys(object);
+
+      for (let i = 0; i < names.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const name = names[i];
+        str += describeKeyForErrorMessage(name) + ': ';
+        const value = object[name];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if (name === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += '}';
+    }
+  }
+
+  if (expandedName === undefined) {
+    return str;
+  }
+
+  if (start > -1 && length > 0) {
+    const highlight = ' '.repeat(start) + '^'.repeat(length);
+    return '\n  ' + str + '\n  ' + highlight;
+  }
+
+  return '\n  ' + str;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactSharedServerInternals = // $FlowFixMe: It's defined in the one we resolve to.
+React.__SECRET_SERVER_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+if (!ReactSharedServerInternals) {
+  throw new Error('The "react" package in this environment is not configured correctly. ' + 'The "react-server" condition must be enabled in any environment that ' + 'runs React Server Components.');
+}
+
+const ObjectPrototype = Object.prototype;
+const stringify = JSON.stringify; // Serializable values
+// Thenable<ReactClientValue>
+
+const PENDING$1 = 0;
+const COMPLETED = 1;
+const ABORTED = 3;
+const ERRORED$1 = 4;
+const ReactCurrentCache = ReactSharedServerInternals.ReactCurrentCache;
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+}
+
+function defaultPostponeHandler(reason) {// Noop
+}
+
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2;
+function createRequest(model, bundlerConfig, onError, context, identifierPrefix, onPostpone) {
+  if (ReactCurrentCache.current !== null && ReactCurrentCache.current !== DefaultCacheDispatcher) {
+    throw new Error('Currently React only supports one RSC renderer at a time.');
+  }
+
+  prepareHostDispatcher();
+  ReactCurrentCache.current = DefaultCacheDispatcher;
+  const abortSet = new Set();
+  const pingedTasks = [];
+  const cleanupQueue = [];
+
+  const hints = createHints();
+  const request = {
+    status: OPEN,
+    flushScheduled: false,
+    fatalError: null,
+    destination: null,
+    bundlerConfig,
+    cache: new Map(),
+    nextChunkId: 0,
+    pendingChunks: 0,
+    hints,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    completedImportChunks: [],
+    completedHintChunks: [],
+    completedRegularChunks: [],
+    completedErrorChunks: [],
+    writtenSymbols: new Map(),
+    writtenClientReferences: new Map(),
+    writtenServerReferences: new Map(),
+    writtenProviders: new Map(),
+    writtenObjects: new WeakMap(),
+    identifierPrefix: identifierPrefix || '',
+    identifierCount: 1,
+    taintCleanupQueue: cleanupQueue,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? defaultPostponeHandler : onPostpone,
+    // $FlowFixMe[missing-this-annot]
+    toJSON: function (key, value) {
+      return resolveModelToJSON(request, this, key, value);
+    }
+  };
+  request.pendingChunks++;
+  const rootContext = createRootContext();
+  const rootTask = createTask(request, model, rootContext, abortSet);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  return null;
+}
+
+function createRootContext(reqContext) {
+  return importServerContexts();
+}
+
+function serializeThenable(request, thenable) {
+  request.pendingChunks++;
+  const newTask = createTask(request, null, getActiveContext(), request.abortableTasks);
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        // We have the resolved value, we can go ahead and schedule it for serialization.
+        newTask.model = thenable.value;
+        pingTask(request, newTask);
+        return newTask.id;
+      }
+
+    case 'rejected':
+      {
+        const x = thenable.reason;
+
+        {
+          const digest = logRecoverableError(request, x);
+          emitErrorChunk(request, newTask.id, digest);
+        }
+
+        return newTask.id;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  thenable.then(value => {
+    newTask.model = value;
+    pingTask(request, newTask);
+  }, reason => {
+    newTask.status = ERRORED$1;
+    request.abortableTasks.delete(newTask); // TODO: We should ideally do this inside performWork so it's scheduled
+
+    const digest = logRecoverableError(request, reason);
+    emitErrorChunk(request, newTask.id, digest);
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  });
+  return newTask.id;
+}
+
+function emitHint(request, code, model) {
+  emitHintChunk(request, code, model);
+  enqueueFlush(request);
+}
+function getHints(request) {
+  return request.hints;
+}
+function getCache(request) {
+  return request.cache;
+}
+
+function readThenable(thenable) {
+  if (thenable.status === 'fulfilled') {
+    return thenable.value;
+  } else if (thenable.status === 'rejected') {
+    throw thenable.reason;
+  }
+
+  throw thenable;
+}
+
+function createLazyWrapperAroundWakeable(wakeable) {
+  // This is a temporary fork of the `use` implementation until we accept
+  // promises everywhere.
+  const thenable = wakeable;
+
+  switch (thenable.status) {
+    case 'fulfilled':
+    case 'rejected':
+      break;
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: thenable,
+    _init: readThenable
+  };
+  return lazyType;
+}
+
+function attemptResolveElement(request, type, key, ref, props, prevThenableState) {
+  if (ref !== null && ref !== undefined) {
+    // When the ref moves to the regular props object this will implicitly
+    // throw for functions. We could probably relax it to a DEV warning for other
+    // cases.
+    throw new Error('Refs cannot be used in Server Components, nor passed to Client Components.');
+  }
+
+  if (typeof type === 'function') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    } // This is a server-side component.
+
+
+    prepareToUseHooksForComponent(prevThenableState);
+    const result = type(props);
+
+    if (typeof result === 'object' && result !== null && typeof result.then === 'function') {
+      // When the return value is in children position we can resolve it immediately,
+      // to its value without a wrapper if it's synchronously available.
+      const thenable = result;
+
+      if (thenable.status === 'fulfilled') {
+        return thenable.value;
+      } // TODO: Once we accept Promises as children on the client, we can just return
+      // the thenable here.
+
+
+      return createLazyWrapperAroundWakeable(result);
+    }
+
+    return result;
+  } else if (typeof type === 'string') {
+    // This is a host element. E.g. HTML.
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (typeof type === 'symbol') {
+    if (type === REACT_FRAGMENT_TYPE) {
+      // For key-less fragments, we add a small optimization to avoid serializing
+      // it as a wrapper.
+      // TODO: If a key is specified, we should propagate its key to any children.
+      // Same as if a Server Component has a key.
+      return props.children;
+    } // This might be a built-in React component. We'll let the client decide.
+    // Any built-in works as long as its props are serializable.
+
+
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (type != null && typeof type === 'object') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    }
+
+    switch (type.$$typeof) {
+      case REACT_LAZY_TYPE:
+        {
+          const payload = type._payload;
+          const init = type._init;
+          const wrappedType = init(payload);
+          return attemptResolveElement(request, wrappedType, key, ref, props, prevThenableState);
+        }
+
+      case REACT_FORWARD_REF_TYPE:
+        {
+          const render = type.render;
+          prepareToUseHooksForComponent(prevThenableState);
+          return render(props, undefined);
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          return attemptResolveElement(request, type.type, key, ref, props, prevThenableState);
+        }
+    }
+  }
+
+  throw new Error("Unsupported Server Component type: " + describeValueForErrorMessage(type));
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createTask(request, model, context, abortSet) {
+  const id = request.nextChunkId++;
+  const task = {
+    id,
+    status: PENDING$1,
+    model,
+    context,
+    ping: () => pingTask(request, task),
+    thenableState: null
+  };
+  abortSet.add(task);
+  return task;
+}
+
+function serializeByValueID(id) {
+  return '$' + id.toString(16);
+}
+
+function serializeLazyID(id) {
+  return '$L' + id.toString(16);
+}
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeRowHeader(tag, id) {
+  return id.toString(16) + ':' + tag;
+}
+
+function encodeReferenceChunk(request, id, reference) {
+  const json = stringify(reference);
+  const row = id.toString(16) + ':' + json + '\n';
+  return stringToChunk(row);
+}
+
+function serializeClientReference(request, parent, key, clientReference) {
+  const clientReferenceKey = getClientReferenceKey(clientReference);
+  const writtenClientReferences = request.writtenClientReferences;
+  const existingId = writtenClientReferences.get(clientReferenceKey);
+
+  if (existingId !== undefined) {
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(existingId);
+    }
+
+    return serializeByValueID(existingId);
+  }
+
+  try {
+    const clientReferenceMetadata = resolveClientReferenceMetadata(request.bundlerConfig, clientReference);
+    request.pendingChunks++;
+    const importId = request.nextChunkId++;
+    emitImportChunk(request, importId, clientReferenceMetadata);
+    writtenClientReferences.set(clientReferenceKey, importId);
+
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(importId);
+    }
+
+    return serializeByValueID(importId);
+  } catch (x) {
+    request.pendingChunks++;
+    const errorId = request.nextChunkId++;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, errorId, digest);
+    return serializeByValueID(errorId);
+  }
+}
+
+function outlineModel(request, value) {
+  request.pendingChunks++;
+  const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+  retryTask(request, newTask);
+  return newTask.id;
+}
+
+function serializeServerReference(request, parent, key, serverReference) {
+  const writtenServerReferences = request.writtenServerReferences;
+  const existingId = writtenServerReferences.get(serverReference);
+
+  if (existingId !== undefined) {
+    return serializeServerReferenceID(existingId);
+  }
+
+  const bound = getServerReferenceBoundArguments(request.bundlerConfig, serverReference);
+  const serverReferenceMetadata = {
+    id: getServerReferenceId(request.bundlerConfig, serverReference),
+    bound: bound ? Promise.resolve(bound) : null
+  };
+  const metadataId = outlineModel(request, serverReferenceMetadata);
+  writtenServerReferences.set(serverReference, metadataId);
+  return serializeServerReferenceID(metadataId);
+}
+
+function serializeLargeTextString(request, text) {
+  request.pendingChunks += 2;
+  const textId = request.nextChunkId++;
+  const textChunk = stringToChunk(text);
+  const binaryLength = byteLengthOfChunk(textChunk);
+  const row = textId.toString(16) + ':T' + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, textChunk);
+  return serializeByValueID(textId);
+}
+
+function serializeMap(request, map) {
+  const entries = Array.from(map);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i][0];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$Q' + id.toString(16);
+}
+
+function serializeSet(request, set) {
+  const entries = Array.from(set);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+let modelRoot = false;
+
+function resolveModelToJSON(request, parent, key, value) {
+
+
+  switch (value) {
+    case REACT_ELEMENT_TYPE:
+      return '$';
+  }
+
+
+  while (typeof value === 'object' && value !== null && (value.$$typeof === REACT_ELEMENT_TYPE || value.$$typeof === REACT_LAZY_TYPE)) {
+
+    try {
+      switch (value.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const writtenObjects = request.writtenObjects;
+            const existingId = writtenObjects.get(value);
+
+            if (existingId !== undefined) {
+              if (existingId === -1) {
+                // Seen but not yet outlined.
+                const newId = outlineModel(request, value);
+                return serializeByValueID(newId);
+              } else if (modelRoot === value) {
+                // This is the ID we're currently emitting so we need to write it
+                // once but if we discover it again, we refer to it by id.
+                modelRoot = null;
+              } else {
+                // We've already emitted this as an outlined object, so we can
+                // just refer to that by its existing ID.
+                return serializeByValueID(existingId);
+              }
+            } else {
+              // This is the first time we've seen this object. We may never see it again
+              // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+              writtenObjects.set(value, -1);
+            } // TODO: Concatenate keys of parents onto children.
+
+
+            const element = value; // Attempt to render the Server Component.
+
+            value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, null);
+            break;
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = value._payload;
+            const init = value._init;
+            value = init(payload);
+            break;
+          }
+      }
+    } catch (thrownValue) {
+      const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          // Something suspended, we'll need to create a new task and resolve it later.
+          request.pendingChunks++;
+          const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+          const ping = newTask.ping;
+          x.then(ping, ping);
+          newTask.thenableState = getThenableStateAfterSuspending();
+          return serializeLazyID(newTask.id);
+        }
+      } // Something errored. We'll still send everything we have up until this point.
+      // We'll replace this element with a lazy reference that throws on the client
+      // once it gets rendered.
+
+
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+      const digest = logRecoverableError(request, x);
+      emitErrorChunk(request, errorId, digest);
+      return serializeLazyID(errorId);
+    }
+  }
+
+  if (value === null) {
+    return null;
+  }
+
+  if (typeof value === 'object') {
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    const writtenObjects = request.writtenObjects;
+    const existingId = writtenObjects.get(value); // $FlowFixMe[method-unbinding]
+
+    if (typeof value.then === 'function') {
+      if (existingId !== undefined) {
+        if (modelRoot === value) {
+          // This is the ID we're currently emitting so we need to write it
+          // once but if we discover it again, we refer to it by id.
+          modelRoot = null;
+        } else {
+          // We've seen this promise before, so we can just refer to the same result.
+          return serializePromiseID(existingId);
+        }
+      } // We assume that any object with a .then property is a "Thenable" type,
+      // or a Promise type. Either of which can be represented by a Promise.
+
+
+      const promiseId = serializeThenable(request, value);
+      writtenObjects.set(value, promiseId);
+      return serializePromiseID(promiseId);
+    }
+
+    if (existingId !== undefined) {
+      if (existingId === -1) {
+        // Seen but not yet outlined.
+        const newId = outlineModel(request, value);
+        return serializeByValueID(newId);
+      } else if (modelRoot === value) {
+        // This is the ID we're currently emitting so we need to write it
+        // once but if we discover it again, we refer to it by id.
+        modelRoot = null;
+      } else {
+        // We've already emitted this as an outlined object, so we can
+        // just refer to that by its existing ID.
+        return serializeByValueID(existingId);
+      }
+    } else {
+      // This is the first time we've seen this object. We may never see it again
+      // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+      writtenObjects.set(value, -1);
+    }
+
+    if (isArray(value)) {
+      // $FlowFixMe[incompatible-return]
+      return value;
+    }
+
+    if (value instanceof Map) {
+      return serializeMap(request, value);
+    }
+
+    if (value instanceof Set) {
+      return serializeSet(request, value);
+    }
+
+    const iteratorFn = getIteratorFn(value);
+
+    if (iteratorFn) {
+      return Array.from(value);
+    } // Verify that this is a simple plain object.
+
+
+    const proto = getPrototypeOf(value);
+
+    if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+      throw new Error('Only plain objects, and a few built-ins, can be passed to Client Components ' + 'from Server Components. Classes or null prototypes are not supported.');
+    }
+
+
+    return value;
+  }
+
+  if (typeof value === 'string') {
+
+
+    if (value[value.length - 1] === 'Z') {
+      // Possibly a Date, whose toJSON automatically calls toISOString
+      // $FlowFixMe[incompatible-use]
+      const originalValue = parent[key];
+
+      if (originalValue instanceof Date) {
+        return serializeDateFromDateJSON(value);
+      }
+    }
+
+    if (value.length >= 1024) {
+      // For large strings, we encode them outside the JSON payload so that we
+      // don't have to double encode and double parse the strings. This can also
+      // be more compact in case the string has a lot of escaped characters.
+      return serializeLargeTextString(request, value);
+    }
+
+    return escapeStringValue(value);
+  }
+
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  if (typeof value === 'number') {
+    return serializeNumber(value);
+  }
+
+  if (typeof value === 'undefined') {
+    return serializeUndefined();
+  }
+
+  if (typeof value === 'function') {
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    if (isServerReference(value)) {
+      return serializeServerReference(request, parent, key, value);
+    }
+
+    if (/^on[A-Z]/.test(key)) {
+      throw new Error('Event handlers cannot be passed to Client Component props.' + describeObjectForErrorMessage(parent, key) + '\nIf you need interactivity, consider converting part of this to a Client Component.');
+    } else {
+      throw new Error('Functions cannot be passed directly to Client Components ' + 'unless you explicitly expose it by marking it with "use server".' + describeObjectForErrorMessage(parent, key));
+    }
+  }
+
+  if (typeof value === 'symbol') {
+    const writtenSymbols = request.writtenSymbols;
+    const existingId = writtenSymbols.get(value);
+
+    if (existingId !== undefined) {
+      return serializeByValueID(existingId);
+    } // $FlowFixMe[incompatible-type] `description` might be undefined
+
+
+    const name = value.description;
+
+    if (Symbol.for(name) !== value) {
+      throw new Error('Only global symbols received from Symbol.for(...) can be passed to Client Components. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+      value.description + ") cannot be found among global symbols.") + describeObjectForErrorMessage(parent, key));
+    }
+
+    request.pendingChunks++;
+    const symbolId = request.nextChunkId++;
+    emitSymbolChunk(request, symbolId, name);
+    writtenSymbols.set(value, symbolId);
+    return serializeByValueID(symbolId);
+  }
+
+  if (typeof value === 'bigint') {
+
+    return serializeBigInt(value);
+  }
+
+  throw new Error("Type " + typeof value + " is not supported in Client Component props." + describeObjectForErrorMessage(parent, key));
+}
+
+function logPostpone(request, reason) {
+  const onPostpone = request.onPostpone;
+  onPostpone(reason);
+}
+
+function logRecoverableError(request, error) {
+  const onError = request.onError;
+  const errorDigest = onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest || '';
+}
+
+function fatalError(request, error) {
+
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function emitPostponeChunk(request, id, postponeInstance) {
+  let row;
+
+  {
+    // No reason included in prod.
+    row = serializeRowHeader('P', id) + '\n';
+  }
+
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitErrorChunk(request, id, digest, error) {
+  let errorInfo;
+
+  {
+    errorInfo = {
+      digest
+    };
+  }
+
+  const row = serializeRowHeader('E', id) + stringify(errorInfo) + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitImportChunk(request, id, clientReferenceMetadata) {
+  // $FlowFixMe[incompatible-type] stringify can return null
+  const json = stringify(clientReferenceMetadata);
+  const row = serializeRowHeader('I', id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitHintChunk(request, code, model) {
+  const json = stringify(model);
+  const id = request.nextChunkId++;
+  const row = serializeRowHeader('H' + code, id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedHintChunks.push(processedChunk);
+}
+
+function emitSymbolChunk(request, id, name) {
+  const symbolReference = serializeSymbolReference(name);
+  const processedChunk = encodeReferenceChunk(request, id, symbolReference);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitModelChunk(request, id, model) {
+  // Track the root so we know that we have to emit this object even though it
+  // already has an ID. This is needed because we might see this object twice
+  // in the same toJSON if it is cyclic.
+  modelRoot = model; // $FlowFixMe[incompatible-type] stringify can return null
+
+  const json = stringify(model, request.toJSON);
+  const row = id.toString(16) + ':' + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function retryTask(request, task) {
+  if (task.status !== PENDING$1) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  }
+
+  switchContext(task.context);
+
+  try {
+    let value = task.model;
+
+    if (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+      request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+      const element = value; // When retrying a component, reuse the thenableState from the
+      // previous attempt.
+
+      const prevThenableState = task.thenableState; // Attempt to render the Server Component.
+      // Doing this here lets us reuse this same task if the next component
+      // also suspends.
+
+      task.model = value;
+      value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, prevThenableState); // Successfully finished this component. We're going to keep rendering
+      // using the same task, but we reset its thenable state before continuing.
+
+      task.thenableState = null; // Keep rendering and reuse the same task. This inner loop is separate
+      // from the render above because we don't need to reset the thenable state
+      // until the next time something suspends and retries.
+
+      while (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+        request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+        const nextElement = value;
+        task.model = value;
+        value = attemptResolveElement(request, nextElement.type, nextElement.key, nextElement.ref, nextElement.props, null);
+      }
+    } // Track that this object is outlined and has an id.
+
+
+    if (typeof value === 'object' && value !== null) {
+      request.writtenObjects.set(value, task.id);
+    }
+
+    emitModelChunk(request, task.id, value);
+    request.abortableTasks.delete(task);
+    task.status = COMPLETED;
+  } catch (thrownValue) {
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    request.abortableTasks.delete(task);
+    task.status = ERRORED$1;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, task.id, digest);
+  }
+}
+
+function performWork(request) {
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  const prevRequest = currentRequest;
+  currentRequest = request;
+  prepareToUseHooksForRequest(request);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    request.pingedTasks = [];
+
+    for (let i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    ReactCurrentDispatcher.current = prevDispatcher;
+    resetHooksForRequest();
+    currentRequest = prevRequest;
+  }
+}
+
+function abortTask(task, request, errorId) {
+  task.status = ABORTED; // Instead of emitting an error per task.id, we emit a model that only
+  // has a single value referencing the error.
+
+  const ref = serializeByValueID(errorId);
+  const processedChunk = encodeReferenceChunk(request, task.id, ref);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function flushCompletedChunks(request, destination) {
+  beginWriting();
+
+  try {
+    // We emit module chunks first in the stream so that
+    // they can be preloaded as early as possible.
+    const importsChunks = request.completedImportChunks;
+    let i = 0;
+
+    for (; i < importsChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = importsChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    importsChunks.splice(0, i); // Next comes hints.
+
+    const hintChunks = request.completedHintChunks;
+    i = 0;
+
+    for (; i < hintChunks.length; i++) {
+      const chunk = hintChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    hintChunks.splice(0, i); // Next comes model data.
+
+    const regularChunks = request.completedRegularChunks;
+    i = 0;
+
+    for (; i < regularChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = regularChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    regularChunks.splice(0, i); // Finally, errors are sent. The idea is that it's ok to delay
+    // any error messages and prioritize display of other parts of
+    // the page.
+
+    const errorChunks = request.completedErrorChunks;
+    i = 0;
+
+    for (; i < errorChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = errorChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    errorChunks.splice(0, i);
+  } finally {
+    request.flushScheduled = false;
+    completeWriting(destination);
+  }
+
+  if (request.pendingChunks === 0) {
+
+    close$1(destination);
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  {
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    const destination = request.destination;
+    request.flushScheduled = true;
+    scheduleWork(() => flushCompletedChunks(request, destination));
+  }
+}
+
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedChunks(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      // We have tasks to abort. We'll emit one error row and then emit a reference
+      // to that row from every row that's still remaining.
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+
+      if (enablePostpone && typeof reason === 'object' && reason !== null && reason.$$typeof === REACT_POSTPONE_TYPE) ; else {
+        const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+        const digest = logRecoverableError(request, error);
+        emitErrorChunk(request, errorId, digest, error);
+      }
+
+      abortableTasks.forEach(task => abortTask(task, request, errorId));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function importServerContexts(contexts) {
+
+  return rootContextSnapshot;
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+function resolveServerReference(bundlerConfig, id) {
+  let name = '';
+  let resolvedModuleData = bundlerConfig[id];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = id.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = id.slice(idx + 1);
+      resolvedModuleData = bundlerConfig[id.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + id + '" in the React Server Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  } // TODO: This needs to return async: true if it's an async module.
+
+
+  return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+} // The chunk cache contains all the chunks we've preloaded so far.
+// If they're still pending they're a thenable. This map also exists
+// in Turbopack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = __turbopack_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+
+  for (let i = 0; i < chunks.length; i++) {
+    const chunkFilename = chunks[i];
+    const entry = chunkCache.get(chunkFilename);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkFilename);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkFilename, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkFilename, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = __turbopack_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+function loadChunk(filename) {
+  return __turbopack_load__(filename);
+}
+
+// The server acts as a Client of itself when resolving Server References.
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const RESOLVED_MODEL = 'resolved_model';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function bindArgs$1(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference$1(response, id, bound, parentChunk, parentObject, key) {
+  const serverReference = resolveServerReference(response._bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+  let promise;
+
+  if (bound) {
+    promise = Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs$1(requireModule(serverReference), args);
+    });
+  } else {
+    if (preloadPromise) {
+      promise = Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+    } else {
+      // Synchronously available
+      return requireModule(serverReference);
+    }
+  }
+
+  promise.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk)); // We need a placeholder value that will be replaced later.
+
+  return null;
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+
+  try {
+    const value = JSON.parse(chunk.value, chunk._response._fromJSON);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    const prefix = response._prefix;
+    const key = prefix + id; // Check if we have this field in the backing store already.
+
+    const backingEntry = response._formData.get(key);
+
+    if (backingEntry != null) {
+      // We assume that this is a string entry for now.
+      chunk = createResolvedModelChunk(response, backingEntry);
+    } else {
+      // We're still waiting on this entry to stream in.
+      chunk = createPendingChunk(response);
+    }
+
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+    blocked.deps++;
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  if (chunk.status === RESOLVED_MODEL) {
+    initializeModelChunk(chunk);
+  }
+
+  if (chunk.status !== INITIALIZED) {
+    // We know that this is emitted earlier so otherwise it's an error.
+    throw chunk.reason;
+  }
+
+  return chunk.value;
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16); // TODO: Just encode this in the reference inline instead of as a model.
+
+          const metaData = getOutlinedModel(response, id);
+          return loadServerReference$1(response, metaData.id, metaData.bound, initializingChunk, parentObject, key);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'K':
+        {
+          // FormData
+          const stringId = value.slice(2);
+          const formPrefix = response._prefix + stringId + '_';
+          const data = new FormData();
+          const backingFormData = response._formData; // We assume that the reference to FormData always comes after each
+          // entry that it references so we can assume they all exist in the
+          // backing store already.
+          // $FlowFixMe[prop-missing] FormData has forEach on it.
+
+          backingFormData.forEach((entry, entryKey) => {
+            if (entryKey.startsWith(formPrefix)) {
+              data.append(entryKey.slice(formPrefix.length), entry);
+            }
+          });
+          return data;
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function createResponse(bundlerConfig, formFieldPrefix) {
+  let backingFormData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new FormData();
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _prefix: formFieldPrefix,
+    _formData: backingFormData,
+    _chunks: chunks,
+    _fromJSON: function (key, value) {
+      if (typeof value === 'string') {
+        // We can't use .bind here because we need the "this" value.
+        return parseModelString(response, this, key, value);
+      }
+
+      return value;
+    }
+  };
+  return response;
+}
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function bindArgs(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference(bundlerConfig, id, bound) {
+  const serverReference = resolveServerReference(bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+
+  if (bound) {
+    return Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs(requireModule(serverReference), args);
+    });
+  } else if (preloadPromise) {
+    return Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+  } else {
+    // Synchronously available
+    return Promise.resolve(requireModule(serverReference));
+  }
+}
+
+function decodeBoundActionMetaData(body, serverManifest, formFieldPrefix) {
+  // The data for this reference is encoded in multiple fields under this prefix.
+  const actionResponse = createResponse(serverManifest, formFieldPrefix, body);
+  close(actionResponse);
+  const refPromise = getRoot(actionResponse); // Force it to initialize
+  // $FlowFixMe
+
+  refPromise.then(() => {});
+
+  if (refPromise.status !== 'fulfilled') {
+    // $FlowFixMe
+    throw refPromise.reason;
+  }
+
+  return refPromise.value;
+}
+
+function decodeAction(body, serverManifest) {
+  // We're going to create a new formData object that holds all the fields except
+  // the implementation details of the action data.
+  const formData = new FormData();
+  let action = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (!key.startsWith('$ACTION_')) {
+      formData.append(key, value);
+      return;
+    } // Later actions may override earlier actions if a button is used to override the default
+    // form action.
+
+
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      const metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+      action = loadServerReference(serverManifest, metaData.id, metaData.bound);
+      return;
+    }
+
+    if (key.startsWith('$ACTION_ID_')) {
+      const id = key.slice(11);
+      action = loadServerReference(serverManifest, id, null);
+      return;
+    }
+  });
+
+  if (action === null) {
+    return null;
+  } // Return the action with the remaining FormData bound to the first argument.
+
+
+  return action.then(fn => fn.bind(null, formData));
+}
+
+function renderToReadableStream(model, turbopackMap, options) {
+  const request = createRequest(model, turbopackMap, options ? options.onError : undefined, options ? options.context : undefined, options ? options.identifierPrefix : undefined, options ? options.onPostpone : undefined);
+
+  if (options && options.signal) {
+    const signal = options.signal;
+
+    if (signal.aborted) {
+      abort(request, signal.reason);
+    } else {
+      const listener = () => {
+        abort(request, signal.reason);
+        signal.removeEventListener('abort', listener);
+      };
+
+      signal.addEventListener('abort', listener);
+    }
+  }
+
+  const stream = new ReadableStream({
+    type: 'bytes',
+    start: controller => {
+      startWork(request);
+    },
+    pull: controller => {
+      startFlowing(request, controller);
+    },
+    cancel: reason => {}
+  }, // $FlowFixMe[prop-missing] size() methods are not allowed on byte streams.
+  {
+    highWaterMark: 0
+  });
+  return stream;
+}
+
+function decodeReply(body, turbopackMap) {
+  if (typeof body === 'string') {
+    const form = new FormData();
+    form.append('0', body);
+    body = form;
+  }
+
+  const response = createResponse(turbopackMap, '', body);
+  const root = getRoot(response);
+  close(response);
+  return root;
+}
+
+exports.createClientModuleProxy = createClientModuleProxy;
+exports.decodeAction = decodeAction;
+exports.decodeReply = decodeReply;
+exports.registerClientReference = registerClientReference;
+exports.registerServerReference = registerServerReference;
+exports.renderToReadableStream = renderToReadableStream;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.browser.production.min.js b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.browser.production.min.js
index b3d218a14a609..405992b820a7c 100644
--- a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.browser.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.browser.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-turbopack-server.browser.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-turbopack-server.browser.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var aa=require("react-dom"),ba=require("react"),l=null,n=0;function p(a,b){if(0!==b.byteLength)if(512<b.byteLength)0<n&&(a.enqueue(new Uint8Array(l.buffer,0,n)),l=new Uint8Array(512),n=0),a.enqueue(b);else{var d=l.length-n;d<b.byteLength&&(0===d?a.enqueue(l):(l.set(b.subarray(0,d),n),a.enqueue(l),b=b.subarray(d)),l=new Uint8Array(512),n=0);l.set(b,n);n+=b.byteLength}return!0}var q=new TextEncoder;function ca(a,b){"function"===typeof a.error?a.error(b):a.close()}
 var r=Symbol.for("react.client.reference"),t=Symbol.for("react.server.reference");function u(a,b,d){return Object.defineProperties(a,{$$typeof:{value:r},$$id:{value:b},$$async:{value:d}})}var da=Function.prototype.bind,ea=Array.prototype.slice;function fa(){var a=da.apply(this,arguments);if(this.$$typeof===t){var b=ea.call(arguments,1);a.$$typeof=t;a.$$id=this.$$id;a.$$bound=this.$$bound?this.$$bound.concat(b):b}return a}
 var ha=Promise.prototype,ia={get:function(a,b){switch(b){case "$$typeof":return a.$$typeof;case "$$id":return a.$$id;case "$$async":return a.$$async;case "name":return a.name;case "displayName":return;case "defaultProps":return;case "toJSON":return;case Symbol.toPrimitive:return Object.prototype[Symbol.toPrimitive];case "Provider":throw Error("Cannot render a Client Context Provider on the Server. Instead, you can export a Client Component wrapper that itself renders a Client Context Provider.");
@@ -73,3 +73,5 @@ exports.decodeAction=function(a,b){var d=new FormData,c=null;a.forEach(function(
 exports.registerClientReference=function(a,b,d){return u(a,b+"#"+d,!1)};exports.registerServerReference=function(a,b,d){return Object.defineProperties(a,{$$typeof:{value:t},$$id:{value:null===d?b:b+"#"+d},$$bound:{value:null},bind:{value:fa}})};
 exports.renderToReadableStream=function(a,b,d){var c=cb(a,b,d?d.onError:void 0,d?d.context:void 0,d?d.identifierPrefix:void 0,d?d.onPostpone:void 0);if(d&&d.signal){var e=d.signal;if(e.aborted)nb(c,e.reason);else{var f=function(){nb(c,e.reason);e.removeEventListener("abort",f)};e.addEventListener("abort",f)}}return new ReadableStream({type:"bytes",start:function(){c.flushScheduled=null!==c.destination;ib(c)},pull:function(g){if(1===c.status)c.status=2,ca(g,c.fatalError);else if(2!==c.status&&null===
 c.destination){c.destination=g;try{O(c,g)}catch(k){M(c,k),mb(c,k)}}},cancel:function(){}},{highWaterMark:0})};
+
+//# sourceMappingURL=react-server-dom-turbopack-server.browser.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.edge.production.js b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.edge.production.js
new file mode 100644
index 0000000000000..e374204878946
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.edge.production.js
@@ -0,0 +1,3060 @@
+/**
+ * @license React
+ * react-server-dom-turbopack-server.edge.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require('react');
+var ReactDOM = require('react-dom');
+
+// -----------------------------------------------------------------------------
+const enablePostpone = false;
+
+function scheduleWork(callback) {
+  setTimeout(callback, 0);
+}
+const VIEW_SIZE = 512;
+let currentView = null;
+let writtenBytes = 0;
+function beginWriting(destination) {
+  currentView = new Uint8Array(VIEW_SIZE);
+  writtenBytes = 0;
+}
+function writeChunk(destination, chunk) {
+  if (chunk.byteLength === 0) {
+    return;
+  }
+
+  if (chunk.byteLength > VIEW_SIZE) {
+    // one that is cached by the streaming renderer. We will enqueu
+    // it directly and expect it is not re-used
+
+
+    if (writtenBytes > 0) {
+      destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    destination.enqueue(chunk);
+    return;
+  }
+
+  let bytesToWrite = chunk;
+  const allowableBytes = currentView.length - writtenBytes;
+
+  if (allowableBytes < bytesToWrite.byteLength) {
+    // this chunk would overflow the current view. We enqueue a full view
+    // and start a new view with the remaining chunk
+    if (allowableBytes === 0) {
+      // the current view is already full, send it
+      destination.enqueue(currentView);
+    } else {
+      // fill up the current view and apply the remaining chunk bytes
+      // to a new view.
+      currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes); // writtenBytes += allowableBytes; // this can be skipped because we are going to immediately reset the view
+
+      destination.enqueue(currentView);
+      bytesToWrite = bytesToWrite.subarray(allowableBytes);
+    }
+
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+
+  currentView.set(bytesToWrite, writtenBytes);
+  writtenBytes += bytesToWrite.byteLength;
+}
+function writeChunkAndReturn(destination, chunk) {
+  writeChunk(destination, chunk); // in web streams there is no backpressure so we can alwas write more
+
+  return true;
+}
+function completeWriting(destination) {
+  if (currentView && writtenBytes > 0) {
+    destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+    currentView = null;
+    writtenBytes = 0;
+  }
+}
+function close$1(destination) {
+  destination.close();
+}
+const textEncoder = new TextEncoder();
+function stringToChunk(content) {
+  return textEncoder.encode(content);
+}
+function byteLengthOfChunk(chunk) {
+  return chunk.byteLength;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[method-unbinding]
+  if (typeof destination.error === 'function') {
+    // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+    destination.error(error);
+  } else {
+    // Earlier implementations doesn't support this method. In that environment you're
+    // supposed to throw from a promise returned but we don't return a promise in our
+    // approach. We could fork this implementation but this is environment is an edge
+    // case to begin with. It's even less common to run this in an older environment.
+    // Even then, this is not where errors are supposed to happen and they get reported
+    // to a global callback in addition to this anyway. So it's fine just to close this.
+    destination.close();
+  }
+}
+
+// eslint-disable-next-line no-unused-vars
+const CLIENT_REFERENCE_TAG = Symbol.for('react.client.reference');
+const SERVER_REFERENCE_TAG = Symbol.for('react.server.reference');
+function isClientReference(reference) {
+  return reference.$$typeof === CLIENT_REFERENCE_TAG;
+}
+function isServerReference(reference) {
+  return reference.$$typeof === SERVER_REFERENCE_TAG;
+}
+function registerClientReference(proxyImplementation, id, exportName) {
+  return registerClientReferenceImpl(proxyImplementation, id + '#' + exportName, false);
+}
+
+function registerClientReferenceImpl(proxyImplementation, id, async) {
+  return Object.defineProperties(proxyImplementation, {
+    $$typeof: {
+      value: CLIENT_REFERENCE_TAG
+    },
+    $$id: {
+      value: id
+    },
+    $$async: {
+      value: async
+    }
+  });
+} // $FlowFixMe[method-unbinding]
+
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+
+  if (this.$$typeof === SERVER_REFERENCE_TAG) {
+    const args = ArraySlice.call(arguments, 1);
+    newFn.$$typeof = SERVER_REFERENCE_TAG;
+    newFn.$$id = this.$$id;
+    newFn.$$bound = this.$$bound ? this.$$bound.concat(args) : args;
+  }
+
+  return newFn;
+}
+
+function registerServerReference(reference, id, exportName) {
+  return Object.defineProperties(reference, {
+    $$typeof: {
+      value: SERVER_REFERENCE_TAG
+    },
+    $$id: {
+      value: exportName === null ? id : id + '#' + exportName
+    },
+    $$bound: {
+      value: null
+    },
+    bind: {
+      value: bind
+    }
+  });
+}
+const PROMISE_PROTOTYPE = Promise.prototype;
+const deepProxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        // These names are a little too common. We should probably have a way to
+        // have the Flight runtime extract the inner target instead.
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+
+      case 'displayName':
+        return undefined;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case 'Provider':
+        throw new Error("Cannot render a Client Context Provider on the Server. " + "Instead, you can export a Client Component wrapper " + "that itself renders a Client Context Provider.");
+    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+    const expression = String(target.name) + '.' + String(name);
+    throw new Error("Cannot access " + expression + " on the server. " + 'You cannot dot into a client module from a server component. ' + 'You can only pass the imported name through.');
+  },
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+const proxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case '__esModule':
+        // Something is conditionally checking which export to use. We'll pretend to be
+        // an ESM compat module but then we'll check again on the client.
+        const moduleId = target.$$id;
+        target.default = registerClientReferenceImpl(function () {
+          throw new Error("Attempted to call the default export of " + moduleId + " from the server " + "but it's on the client. It's not possible to invoke a client function from " + "the server, it can only be rendered as a Component or passed to props of a " + "Client Component.");
+        }, target.$$id + '#', target.$$async);
+        return true;
+
+      case 'then':
+        if (target.then) {
+          // Use a cached value
+          return target.then;
+        }
+
+        if (!target.$$async) {
+          // If this module is expected to return a Promise (such as an AsyncModule) then
+          // we should resolve that with a client reference that unwraps the Promise on
+          // the client.
+          const clientReference = registerClientReferenceImpl({}, target.$$id, true);
+          const proxy = new Proxy(clientReference, proxyHandlers); // Treat this as a resolved Promise for React's use()
+
+          target.status = 'fulfilled';
+          target.value = proxy;
+          const then = target.then = registerClientReferenceImpl(function then(resolve, reject) {
+            // Expose to React.
+            return Promise.resolve(resolve(proxy));
+          }, // If this is not used as a Promise but is treated as a reference to a `.then`
+          // export then we should treat it as a reference to that name.
+          target.$$id + '#then', false);
+          return then;
+        } else {
+          // Since typeof .then === 'function' is a feature test we'd continue recursing
+          // indefinitely if we return a function. Instead, we return an object reference
+          // if we check further.
+          return undefined;
+        }
+
+    }
+
+    let cachedReference = target[name];
+
+    if (!cachedReference) {
+      const reference = registerClientReferenceImpl(function () {
+        throw new Error( // eslint-disable-next-line react-internal/safe-string-coercion
+        "Attempted to call " + String(name) + "() from the server but " + String(name) + " is on the client. " + "It's not possible to invoke a client function from the server, it can " + "only be rendered as a Component or passed to props of a Client Component.");
+      }, target.$$id + '#' + name, target.$$async);
+      Object.defineProperty(reference, 'name', {
+        value: name
+      });
+      cachedReference = target[name] = new Proxy(reference, deepProxyHandlers);
+    }
+
+    return cachedReference;
+  },
+
+  getPrototypeOf(target) {
+    // Pretend to be a Promise in case anyone asks.
+    return PROMISE_PROTOTYPE;
+  },
+
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+function createClientModuleProxy(moduleId) {
+  const clientReference = registerClientReferenceImpl({}, // Represents the whole Module object instead of a particular import.
+  moduleId, false);
+  return new Proxy(clientReference, proxyHandlers);
+}
+
+function getClientReferenceKey(reference) {
+  return reference.$$async ? reference.$$id + '#async' : reference.$$id;
+}
+function resolveClientReferenceMetadata(config, clientReference) {
+  const modulePath = clientReference.$$id;
+  let name = '';
+  let resolvedModuleData = config[modulePath];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = modulePath.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = modulePath.slice(idx + 1);
+      resolvedModuleData = config[modulePath.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + modulePath + '" in the React Client Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  }
+
+  if (clientReference.$$async === true) {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1];
+  } else {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+  }
+}
+function getServerReferenceId(config, serverReference) {
+  return serverReference.$$id;
+}
+function getServerReferenceBoundArguments(config, serverReference) {
+  return serverReference.$$bound;
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMFlightServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule: preloadModule$1,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+
+function prefetchDNS(href) {
+  {
+    if (typeof href === 'string' && href) {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'D|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        emitHint(request, 'D', href);
+      }
+    }
+  }
+}
+
+function preconnect(href, crossOrigin) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = "C|" + (crossOrigin == null ? 'null' : crossOrigin) + "|" + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+
+        if (typeof crossOrigin === 'string') {
+          emitHint(request, 'C', [href, crossOrigin]);
+        } else {
+          emitHint(request, 'C', href);
+        }
+      }
+    }
+  }
+}
+
+function preload(href, as, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        let key = 'L';
+
+        if (as === 'image' && options) {
+          key += getImagePreloadKey(href, options.imageSrcSet, options.imageSizes);
+        } else {
+          key += "[" + as + "]" + href;
+        }
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          emitHint(request, 'L', [href, as, trimmed]);
+        } else {
+          emitHint(request, 'L', [href, as]);
+        }
+      }
+    }
+  }
+}
+
+function preloadModule$1(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'm|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'm', [href, trimmed]);
+        } else {
+          return emitHint(request, 'm', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'S|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'S', [href, typeof precedence === 'string' ? precedence : 0, trimmed]);
+        } else if (typeof precedence === 'string') {
+          return emitHint(request, 'S', [href, precedence]);
+        } else {
+          return emitHint(request, 'S', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'X|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'X', [href, trimmed]);
+        } else {
+          return emitHint(request, 'X', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitModuleScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'M|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'M', [href, trimmed]);
+        } else {
+          return emitHint(request, 'M', href);
+        }
+      }
+    }
+  }
+} // Flight normally encodes undefined as a special character however for directive option
+// arguments we don't want to send unnecessary keys and bloat the payload so we create a
+// trimmed object which omits any keys with null or undefined values.
+// This is only typesafe because these option objects have entirely optional fields where
+// null and undefined represent the same thing as no property.
+
+
+function trimOptions(options) {
+  if (options == null) return null;
+  let hasProperties = false;
+  const trimmed = {};
+
+  for (const key in options) {
+    if (options[key] != null) {
+      hasProperties = true;
+      trimmed[key] = options[key];
+    }
+  }
+
+  return hasProperties ? trimmed : null;
+}
+
+function getImagePreloadKey(href, imageSrcSet, imageSizes) {
+  let uniquePart = '';
+
+  if (typeof imageSrcSet === 'string' && imageSrcSet !== '') {
+    uniquePart += '[' + imageSrcSet + ']';
+
+    if (typeof imageSizes === 'string') {
+      uniquePart += '[' + imageSizes + ']';
+    }
+  } else {
+    uniquePart += '[][]' + href;
+  }
+
+  return "[image]" + uniquePart;
+}
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMFlightServerDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+// small, smaller than how we encode undefined, and is unambiguous. We could use
+// a different tuple structure to encode this instead but this makes the runtime
+// cost cheaper by eliminating a type checks in more positions.
+// prettier-ignore
+
+function createHints() {
+  return new Set();
+}
+
+const supportsRequestStorage = typeof AsyncLocalStorage === 'function';
+const requestStorage = supportsRequestStorage ? new AsyncLocalStorage() : null;
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext); // On the way back, we push the new ones that weren't common.
+
+      pushNode(next);
+    }
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFizzWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop, noop);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+let currentRequest$1 = null;
+let thenableIndexCounter = 0;
+let thenableState = null;
+function prepareToUseHooksForRequest(request) {
+  currentRequest$1 = request;
+}
+function resetHooksForRequest() {
+  currentRequest$1 = null;
+}
+function prepareToUseHooksForComponent(prevThenableState) {
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+const HooksDispatcher = {
+  useMemo(nextCreate) {
+    return nextCreate();
+  },
+
+  useCallback(callback) {
+    return callback;
+  },
+
+  useDebugValue() {},
+
+  useDeferredValue: unsupportedHook,
+  useTransition: unsupportedHook,
+  readContext,
+  useContext: readContext,
+  useReducer: unsupportedHook,
+  useRef: unsupportedHook,
+  useState: unsupportedHook,
+  useInsertionEffect: unsupportedHook,
+  useLayoutEffect: unsupportedHook,
+  useImperativeHandle: unsupportedHook,
+  useEffect: unsupportedHook,
+  useId,
+  useSyncExternalStore: unsupportedHook,
+
+  useCacheRefresh() {
+    return unsupportedRefresh;
+  },
+
+  useMemoCache(size) {
+    const data = new Array(size);
+
+    for (let i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL;
+    }
+
+    return data;
+  },
+
+  use
+};
+
+function unsupportedHook() {
+  throw new Error('This Hook is not supported in Server Components.');
+}
+
+function unsupportedRefresh() {
+  throw new Error('Refreshing the cache is not supported in Server Components.');
+}
+
+function useId() {
+  if (currentRequest$1 === null) {
+    throw new Error('useId can only be used while React is rendering');
+  }
+
+  const id = currentRequest$1.identifierCount++; // use 'S' for Flight components to distinguish from 'R' and 'r' in Fizz/Client
+
+  return ':' + currentRequest$1.identifierPrefix + 'S' + id.toString(32) + ':';
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object' || typeof usable === 'function') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable; // Track the position of the thenable within this fiber.
+
+      const index = thenableIndexCounter;
+      thenableIndexCounter += 1;
+
+      if (thenableState === null) {
+        thenableState = createThenableState();
+      }
+
+      return trackUsedThenable(thenableState, thenable, index);
+    } else if (usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  }
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function createSignal() {
+  return new AbortController().signal;
+}
+
+function resolveCache() {
+  const request = resolveRequest();
+
+  if (request) {
+    return getCache(request);
+  }
+
+  return new Map();
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal() {
+    const cache = resolveCache();
+    let entry = cache.get(createSignal);
+
+    if (entry === undefined) {
+      entry = createSignal();
+      cache.set(createSignal, entry);
+    }
+
+    return entry;
+  },
+
+  getCacheForType(resourceType) {
+    const cache = resolveCache();
+    let entry = cache.get(resourceType);
+
+    if (entry === undefined) {
+      entry = resourceType(); // TODO: Warn if undefined?
+
+      cache.set(resourceType, entry);
+    }
+
+    return entry;
+  }
+
+};
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+function objectName(object) {
+  // $FlowFixMe[method-unbinding]
+  const name = Object.prototype.toString.call(object);
+  return name.replace(/^\[object (.*)\]$/, function (m, p0) {
+    return p0;
+  });
+}
+
+function describeKeyForErrorMessage(key) {
+  const encodedKey = JSON.stringify(key);
+  return '"' + key + '"' === encodedKey ? key : encodedKey;
+}
+
+function describeValueForErrorMessage(value) {
+  switch (typeof value) {
+    case 'string':
+      {
+        return JSON.stringify(value.length <= 10 ? value : value.slice(0, 10) + '...');
+      }
+
+    case 'object':
+      {
+        if (isArray(value)) {
+          return '[...]';
+        }
+
+        const name = objectName(value);
+
+        if (name === 'Object') {
+          return '{...}';
+        }
+
+        return name;
+      }
+
+    case 'function':
+      return 'function';
+
+    default:
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      return String(value);
+  }
+}
+
+function describeElementType(type) {
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        return describeElementType(type.render);
+
+      case REACT_MEMO_TYPE:
+        return describeElementType(type.type);
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            // Lazy may contain any component type so we recursively resolve it.
+            return describeElementType(init(payload));
+          } catch (x) {}
+        }
+    }
+  }
+
+  return '';
+}
+
+function describeObjectForErrorMessage(objectOrArray, expandedName) {
+  const objKind = objectName(objectOrArray);
+
+  if (objKind !== 'Object' && objKind !== 'Array') {
+    return objKind;
+  }
+
+  let str = '';
+  let start = -1;
+  let length = 0;
+
+  if (isArray(objectOrArray)) {
+    {
+      // Print Array
+      str = '[';
+      const array = objectOrArray;
+
+      for (let i = 0; i < array.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const value = array[i];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if ('' + i === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += ']';
+    }
+  } else {
+    if (objectOrArray.$$typeof === REACT_ELEMENT_TYPE) {
+      str = '<' + describeElementType(objectOrArray.type) + '/>';
+    } else {
+      // Print Object
+      str = '{';
+      const object = objectOrArray;
+      const names = Object.keys(object);
+
+      for (let i = 0; i < names.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const name = names[i];
+        str += describeKeyForErrorMessage(name) + ': ';
+        const value = object[name];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if (name === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += '}';
+    }
+  }
+
+  if (expandedName === undefined) {
+    return str;
+  }
+
+  if (start > -1 && length > 0) {
+    const highlight = ' '.repeat(start) + '^'.repeat(length);
+    return '\n  ' + str + '\n  ' + highlight;
+  }
+
+  return '\n  ' + str;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactSharedServerInternals = // $FlowFixMe: It's defined in the one we resolve to.
+React.__SECRET_SERVER_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+if (!ReactSharedServerInternals) {
+  throw new Error('The "react" package in this environment is not configured correctly. ' + 'The "react-server" condition must be enabled in any environment that ' + 'runs React Server Components.');
+}
+
+const ObjectPrototype = Object.prototype;
+const stringify = JSON.stringify; // Serializable values
+// Thenable<ReactClientValue>
+
+const PENDING$1 = 0;
+const COMPLETED = 1;
+const ABORTED = 3;
+const ERRORED$1 = 4;
+const ReactCurrentCache = ReactSharedServerInternals.ReactCurrentCache;
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+}
+
+function defaultPostponeHandler(reason) {// Noop
+}
+
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2;
+function createRequest(model, bundlerConfig, onError, context, identifierPrefix, onPostpone) {
+  if (ReactCurrentCache.current !== null && ReactCurrentCache.current !== DefaultCacheDispatcher) {
+    throw new Error('Currently React only supports one RSC renderer at a time.');
+  }
+
+  prepareHostDispatcher();
+  ReactCurrentCache.current = DefaultCacheDispatcher;
+  const abortSet = new Set();
+  const pingedTasks = [];
+  const cleanupQueue = [];
+
+  const hints = createHints();
+  const request = {
+    status: OPEN,
+    flushScheduled: false,
+    fatalError: null,
+    destination: null,
+    bundlerConfig,
+    cache: new Map(),
+    nextChunkId: 0,
+    pendingChunks: 0,
+    hints,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    completedImportChunks: [],
+    completedHintChunks: [],
+    completedRegularChunks: [],
+    completedErrorChunks: [],
+    writtenSymbols: new Map(),
+    writtenClientReferences: new Map(),
+    writtenServerReferences: new Map(),
+    writtenProviders: new Map(),
+    writtenObjects: new WeakMap(),
+    identifierPrefix: identifierPrefix || '',
+    identifierCount: 1,
+    taintCleanupQueue: cleanupQueue,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? defaultPostponeHandler : onPostpone,
+    // $FlowFixMe[missing-this-annot]
+    toJSON: function (key, value) {
+      return resolveModelToJSON(request, this, key, value);
+    }
+  };
+  request.pendingChunks++;
+  const rootContext = createRootContext();
+  const rootTask = createTask(request, model, rootContext, abortSet);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  if (supportsRequestStorage) {
+    const store = requestStorage.getStore();
+    if (store) return store;
+  }
+
+  return null;
+}
+
+function createRootContext(reqContext) {
+  return importServerContexts();
+}
+
+function serializeThenable(request, thenable) {
+  request.pendingChunks++;
+  const newTask = createTask(request, null, getActiveContext(), request.abortableTasks);
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        // We have the resolved value, we can go ahead and schedule it for serialization.
+        newTask.model = thenable.value;
+        pingTask(request, newTask);
+        return newTask.id;
+      }
+
+    case 'rejected':
+      {
+        const x = thenable.reason;
+
+        {
+          const digest = logRecoverableError(request, x);
+          emitErrorChunk(request, newTask.id, digest);
+        }
+
+        return newTask.id;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  thenable.then(value => {
+    newTask.model = value;
+    pingTask(request, newTask);
+  }, reason => {
+    newTask.status = ERRORED$1;
+    request.abortableTasks.delete(newTask); // TODO: We should ideally do this inside performWork so it's scheduled
+
+    const digest = logRecoverableError(request, reason);
+    emitErrorChunk(request, newTask.id, digest);
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  });
+  return newTask.id;
+}
+
+function emitHint(request, code, model) {
+  emitHintChunk(request, code, model);
+  enqueueFlush(request);
+}
+function getHints(request) {
+  return request.hints;
+}
+function getCache(request) {
+  return request.cache;
+}
+
+function readThenable(thenable) {
+  if (thenable.status === 'fulfilled') {
+    return thenable.value;
+  } else if (thenable.status === 'rejected') {
+    throw thenable.reason;
+  }
+
+  throw thenable;
+}
+
+function createLazyWrapperAroundWakeable(wakeable) {
+  // This is a temporary fork of the `use` implementation until we accept
+  // promises everywhere.
+  const thenable = wakeable;
+
+  switch (thenable.status) {
+    case 'fulfilled':
+    case 'rejected':
+      break;
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: thenable,
+    _init: readThenable
+  };
+  return lazyType;
+}
+
+function attemptResolveElement(request, type, key, ref, props, prevThenableState) {
+  if (ref !== null && ref !== undefined) {
+    // When the ref moves to the regular props object this will implicitly
+    // throw for functions. We could probably relax it to a DEV warning for other
+    // cases.
+    throw new Error('Refs cannot be used in Server Components, nor passed to Client Components.');
+  }
+
+  if (typeof type === 'function') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    } // This is a server-side component.
+
+
+    prepareToUseHooksForComponent(prevThenableState);
+    const result = type(props);
+
+    if (typeof result === 'object' && result !== null && typeof result.then === 'function') {
+      // When the return value is in children position we can resolve it immediately,
+      // to its value without a wrapper if it's synchronously available.
+      const thenable = result;
+
+      if (thenable.status === 'fulfilled') {
+        return thenable.value;
+      } // TODO: Once we accept Promises as children on the client, we can just return
+      // the thenable here.
+
+
+      return createLazyWrapperAroundWakeable(result);
+    }
+
+    return result;
+  } else if (typeof type === 'string') {
+    // This is a host element. E.g. HTML.
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (typeof type === 'symbol') {
+    if (type === REACT_FRAGMENT_TYPE) {
+      // For key-less fragments, we add a small optimization to avoid serializing
+      // it as a wrapper.
+      // TODO: If a key is specified, we should propagate its key to any children.
+      // Same as if a Server Component has a key.
+      return props.children;
+    } // This might be a built-in React component. We'll let the client decide.
+    // Any built-in works as long as its props are serializable.
+
+
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (type != null && typeof type === 'object') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    }
+
+    switch (type.$$typeof) {
+      case REACT_LAZY_TYPE:
+        {
+          const payload = type._payload;
+          const init = type._init;
+          const wrappedType = init(payload);
+          return attemptResolveElement(request, wrappedType, key, ref, props, prevThenableState);
+        }
+
+      case REACT_FORWARD_REF_TYPE:
+        {
+          const render = type.render;
+          prepareToUseHooksForComponent(prevThenableState);
+          return render(props, undefined);
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          return attemptResolveElement(request, type.type, key, ref, props, prevThenableState);
+        }
+    }
+  }
+
+  throw new Error("Unsupported Server Component type: " + describeValueForErrorMessage(type));
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createTask(request, model, context, abortSet) {
+  const id = request.nextChunkId++;
+  const task = {
+    id,
+    status: PENDING$1,
+    model,
+    context,
+    ping: () => pingTask(request, task),
+    thenableState: null
+  };
+  abortSet.add(task);
+  return task;
+}
+
+function serializeByValueID(id) {
+  return '$' + id.toString(16);
+}
+
+function serializeLazyID(id) {
+  return '$L' + id.toString(16);
+}
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeRowHeader(tag, id) {
+  return id.toString(16) + ':' + tag;
+}
+
+function encodeReferenceChunk(request, id, reference) {
+  const json = stringify(reference);
+  const row = id.toString(16) + ':' + json + '\n';
+  return stringToChunk(row);
+}
+
+function serializeClientReference(request, parent, key, clientReference) {
+  const clientReferenceKey = getClientReferenceKey(clientReference);
+  const writtenClientReferences = request.writtenClientReferences;
+  const existingId = writtenClientReferences.get(clientReferenceKey);
+
+  if (existingId !== undefined) {
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(existingId);
+    }
+
+    return serializeByValueID(existingId);
+  }
+
+  try {
+    const clientReferenceMetadata = resolveClientReferenceMetadata(request.bundlerConfig, clientReference);
+    request.pendingChunks++;
+    const importId = request.nextChunkId++;
+    emitImportChunk(request, importId, clientReferenceMetadata);
+    writtenClientReferences.set(clientReferenceKey, importId);
+
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(importId);
+    }
+
+    return serializeByValueID(importId);
+  } catch (x) {
+    request.pendingChunks++;
+    const errorId = request.nextChunkId++;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, errorId, digest);
+    return serializeByValueID(errorId);
+  }
+}
+
+function outlineModel(request, value) {
+  request.pendingChunks++;
+  const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+  retryTask(request, newTask);
+  return newTask.id;
+}
+
+function serializeServerReference(request, parent, key, serverReference) {
+  const writtenServerReferences = request.writtenServerReferences;
+  const existingId = writtenServerReferences.get(serverReference);
+
+  if (existingId !== undefined) {
+    return serializeServerReferenceID(existingId);
+  }
+
+  const bound = getServerReferenceBoundArguments(request.bundlerConfig, serverReference);
+  const serverReferenceMetadata = {
+    id: getServerReferenceId(request.bundlerConfig, serverReference),
+    bound: bound ? Promise.resolve(bound) : null
+  };
+  const metadataId = outlineModel(request, serverReferenceMetadata);
+  writtenServerReferences.set(serverReference, metadataId);
+  return serializeServerReferenceID(metadataId);
+}
+
+function serializeLargeTextString(request, text) {
+  request.pendingChunks += 2;
+  const textId = request.nextChunkId++;
+  const textChunk = stringToChunk(text);
+  const binaryLength = byteLengthOfChunk(textChunk);
+  const row = textId.toString(16) + ':T' + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, textChunk);
+  return serializeByValueID(textId);
+}
+
+function serializeMap(request, map) {
+  const entries = Array.from(map);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i][0];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$Q' + id.toString(16);
+}
+
+function serializeSet(request, set) {
+  const entries = Array.from(set);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+let modelRoot = false;
+
+function resolveModelToJSON(request, parent, key, value) {
+
+
+  switch (value) {
+    case REACT_ELEMENT_TYPE:
+      return '$';
+  }
+
+
+  while (typeof value === 'object' && value !== null && (value.$$typeof === REACT_ELEMENT_TYPE || value.$$typeof === REACT_LAZY_TYPE)) {
+
+    try {
+      switch (value.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const writtenObjects = request.writtenObjects;
+            const existingId = writtenObjects.get(value);
+
+            if (existingId !== undefined) {
+              if (existingId === -1) {
+                // Seen but not yet outlined.
+                const newId = outlineModel(request, value);
+                return serializeByValueID(newId);
+              } else if (modelRoot === value) {
+                // This is the ID we're currently emitting so we need to write it
+                // once but if we discover it again, we refer to it by id.
+                modelRoot = null;
+              } else {
+                // We've already emitted this as an outlined object, so we can
+                // just refer to that by its existing ID.
+                return serializeByValueID(existingId);
+              }
+            } else {
+              // This is the first time we've seen this object. We may never see it again
+              // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+              writtenObjects.set(value, -1);
+            } // TODO: Concatenate keys of parents onto children.
+
+
+            const element = value; // Attempt to render the Server Component.
+
+            value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, null);
+            break;
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = value._payload;
+            const init = value._init;
+            value = init(payload);
+            break;
+          }
+      }
+    } catch (thrownValue) {
+      const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          // Something suspended, we'll need to create a new task and resolve it later.
+          request.pendingChunks++;
+          const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+          const ping = newTask.ping;
+          x.then(ping, ping);
+          newTask.thenableState = getThenableStateAfterSuspending();
+          return serializeLazyID(newTask.id);
+        }
+      } // Something errored. We'll still send everything we have up until this point.
+      // We'll replace this element with a lazy reference that throws on the client
+      // once it gets rendered.
+
+
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+      const digest = logRecoverableError(request, x);
+      emitErrorChunk(request, errorId, digest);
+      return serializeLazyID(errorId);
+    }
+  }
+
+  if (value === null) {
+    return null;
+  }
+
+  if (typeof value === 'object') {
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    const writtenObjects = request.writtenObjects;
+    const existingId = writtenObjects.get(value); // $FlowFixMe[method-unbinding]
+
+    if (typeof value.then === 'function') {
+      if (existingId !== undefined) {
+        if (modelRoot === value) {
+          // This is the ID we're currently emitting so we need to write it
+          // once but if we discover it again, we refer to it by id.
+          modelRoot = null;
+        } else {
+          // We've seen this promise before, so we can just refer to the same result.
+          return serializePromiseID(existingId);
+        }
+      } // We assume that any object with a .then property is a "Thenable" type,
+      // or a Promise type. Either of which can be represented by a Promise.
+
+
+      const promiseId = serializeThenable(request, value);
+      writtenObjects.set(value, promiseId);
+      return serializePromiseID(promiseId);
+    }
+
+    if (existingId !== undefined) {
+      if (existingId === -1) {
+        // Seen but not yet outlined.
+        const newId = outlineModel(request, value);
+        return serializeByValueID(newId);
+      } else if (modelRoot === value) {
+        // This is the ID we're currently emitting so we need to write it
+        // once but if we discover it again, we refer to it by id.
+        modelRoot = null;
+      } else {
+        // We've already emitted this as an outlined object, so we can
+        // just refer to that by its existing ID.
+        return serializeByValueID(existingId);
+      }
+    } else {
+      // This is the first time we've seen this object. We may never see it again
+      // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+      writtenObjects.set(value, -1);
+    }
+
+    if (isArray(value)) {
+      // $FlowFixMe[incompatible-return]
+      return value;
+    }
+
+    if (value instanceof Map) {
+      return serializeMap(request, value);
+    }
+
+    if (value instanceof Set) {
+      return serializeSet(request, value);
+    }
+
+    const iteratorFn = getIteratorFn(value);
+
+    if (iteratorFn) {
+      return Array.from(value);
+    } // Verify that this is a simple plain object.
+
+
+    const proto = getPrototypeOf(value);
+
+    if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+      throw new Error('Only plain objects, and a few built-ins, can be passed to Client Components ' + 'from Server Components. Classes or null prototypes are not supported.');
+    }
+
+
+    return value;
+  }
+
+  if (typeof value === 'string') {
+
+
+    if (value[value.length - 1] === 'Z') {
+      // Possibly a Date, whose toJSON automatically calls toISOString
+      // $FlowFixMe[incompatible-use]
+      const originalValue = parent[key];
+
+      if (originalValue instanceof Date) {
+        return serializeDateFromDateJSON(value);
+      }
+    }
+
+    if (value.length >= 1024) {
+      // For large strings, we encode them outside the JSON payload so that we
+      // don't have to double encode and double parse the strings. This can also
+      // be more compact in case the string has a lot of escaped characters.
+      return serializeLargeTextString(request, value);
+    }
+
+    return escapeStringValue(value);
+  }
+
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  if (typeof value === 'number') {
+    return serializeNumber(value);
+  }
+
+  if (typeof value === 'undefined') {
+    return serializeUndefined();
+  }
+
+  if (typeof value === 'function') {
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    if (isServerReference(value)) {
+      return serializeServerReference(request, parent, key, value);
+    }
+
+    if (/^on[A-Z]/.test(key)) {
+      throw new Error('Event handlers cannot be passed to Client Component props.' + describeObjectForErrorMessage(parent, key) + '\nIf you need interactivity, consider converting part of this to a Client Component.');
+    } else {
+      throw new Error('Functions cannot be passed directly to Client Components ' + 'unless you explicitly expose it by marking it with "use server".' + describeObjectForErrorMessage(parent, key));
+    }
+  }
+
+  if (typeof value === 'symbol') {
+    const writtenSymbols = request.writtenSymbols;
+    const existingId = writtenSymbols.get(value);
+
+    if (existingId !== undefined) {
+      return serializeByValueID(existingId);
+    } // $FlowFixMe[incompatible-type] `description` might be undefined
+
+
+    const name = value.description;
+
+    if (Symbol.for(name) !== value) {
+      throw new Error('Only global symbols received from Symbol.for(...) can be passed to Client Components. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+      value.description + ") cannot be found among global symbols.") + describeObjectForErrorMessage(parent, key));
+    }
+
+    request.pendingChunks++;
+    const symbolId = request.nextChunkId++;
+    emitSymbolChunk(request, symbolId, name);
+    writtenSymbols.set(value, symbolId);
+    return serializeByValueID(symbolId);
+  }
+
+  if (typeof value === 'bigint') {
+
+    return serializeBigInt(value);
+  }
+
+  throw new Error("Type " + typeof value + " is not supported in Client Component props." + describeObjectForErrorMessage(parent, key));
+}
+
+function logPostpone(request, reason) {
+  const onPostpone = request.onPostpone;
+  onPostpone(reason);
+}
+
+function logRecoverableError(request, error) {
+  const onError = request.onError;
+  const errorDigest = onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest || '';
+}
+
+function fatalError(request, error) {
+
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function emitPostponeChunk(request, id, postponeInstance) {
+  let row;
+
+  {
+    // No reason included in prod.
+    row = serializeRowHeader('P', id) + '\n';
+  }
+
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitErrorChunk(request, id, digest, error) {
+  let errorInfo;
+
+  {
+    errorInfo = {
+      digest
+    };
+  }
+
+  const row = serializeRowHeader('E', id) + stringify(errorInfo) + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitImportChunk(request, id, clientReferenceMetadata) {
+  // $FlowFixMe[incompatible-type] stringify can return null
+  const json = stringify(clientReferenceMetadata);
+  const row = serializeRowHeader('I', id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitHintChunk(request, code, model) {
+  const json = stringify(model);
+  const id = request.nextChunkId++;
+  const row = serializeRowHeader('H' + code, id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedHintChunks.push(processedChunk);
+}
+
+function emitSymbolChunk(request, id, name) {
+  const symbolReference = serializeSymbolReference(name);
+  const processedChunk = encodeReferenceChunk(request, id, symbolReference);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitModelChunk(request, id, model) {
+  // Track the root so we know that we have to emit this object even though it
+  // already has an ID. This is needed because we might see this object twice
+  // in the same toJSON if it is cyclic.
+  modelRoot = model; // $FlowFixMe[incompatible-type] stringify can return null
+
+  const json = stringify(model, request.toJSON);
+  const row = id.toString(16) + ':' + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function retryTask(request, task) {
+  if (task.status !== PENDING$1) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  }
+
+  switchContext(task.context);
+
+  try {
+    let value = task.model;
+
+    if (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+      request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+      const element = value; // When retrying a component, reuse the thenableState from the
+      // previous attempt.
+
+      const prevThenableState = task.thenableState; // Attempt to render the Server Component.
+      // Doing this here lets us reuse this same task if the next component
+      // also suspends.
+
+      task.model = value;
+      value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, prevThenableState); // Successfully finished this component. We're going to keep rendering
+      // using the same task, but we reset its thenable state before continuing.
+
+      task.thenableState = null; // Keep rendering and reuse the same task. This inner loop is separate
+      // from the render above because we don't need to reset the thenable state
+      // until the next time something suspends and retries.
+
+      while (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+        request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+        const nextElement = value;
+        task.model = value;
+        value = attemptResolveElement(request, nextElement.type, nextElement.key, nextElement.ref, nextElement.props, null);
+      }
+    } // Track that this object is outlined and has an id.
+
+
+    if (typeof value === 'object' && value !== null) {
+      request.writtenObjects.set(value, task.id);
+    }
+
+    emitModelChunk(request, task.id, value);
+    request.abortableTasks.delete(task);
+    task.status = COMPLETED;
+  } catch (thrownValue) {
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    request.abortableTasks.delete(task);
+    task.status = ERRORED$1;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, task.id, digest);
+  }
+}
+
+function performWork(request) {
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  const prevRequest = currentRequest;
+  currentRequest = request;
+  prepareToUseHooksForRequest(request);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    request.pingedTasks = [];
+
+    for (let i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    ReactCurrentDispatcher.current = prevDispatcher;
+    resetHooksForRequest();
+    currentRequest = prevRequest;
+  }
+}
+
+function abortTask(task, request, errorId) {
+  task.status = ABORTED; // Instead of emitting an error per task.id, we emit a model that only
+  // has a single value referencing the error.
+
+  const ref = serializeByValueID(errorId);
+  const processedChunk = encodeReferenceChunk(request, task.id, ref);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function flushCompletedChunks(request, destination) {
+  beginWriting();
+
+  try {
+    // We emit module chunks first in the stream so that
+    // they can be preloaded as early as possible.
+    const importsChunks = request.completedImportChunks;
+    let i = 0;
+
+    for (; i < importsChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = importsChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    importsChunks.splice(0, i); // Next comes hints.
+
+    const hintChunks = request.completedHintChunks;
+    i = 0;
+
+    for (; i < hintChunks.length; i++) {
+      const chunk = hintChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    hintChunks.splice(0, i); // Next comes model data.
+
+    const regularChunks = request.completedRegularChunks;
+    i = 0;
+
+    for (; i < regularChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = regularChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    regularChunks.splice(0, i); // Finally, errors are sent. The idea is that it's ok to delay
+    // any error messages and prioritize display of other parts of
+    // the page.
+
+    const errorChunks = request.completedErrorChunks;
+    i = 0;
+
+    for (; i < errorChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = errorChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    errorChunks.splice(0, i);
+  } finally {
+    request.flushScheduled = false;
+    completeWriting(destination);
+  }
+
+  if (request.pendingChunks === 0) {
+
+    close$1(destination);
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  if (supportsRequestStorage) {
+    scheduleWork(() => requestStorage.run(request, performWork, request));
+  } else {
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    const destination = request.destination;
+    request.flushScheduled = true;
+    scheduleWork(() => flushCompletedChunks(request, destination));
+  }
+}
+
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedChunks(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      // We have tasks to abort. We'll emit one error row and then emit a reference
+      // to that row from every row that's still remaining.
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+
+      if (enablePostpone && typeof reason === 'object' && reason !== null && reason.$$typeof === REACT_POSTPONE_TYPE) ; else {
+        const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+        const digest = logRecoverableError(request, error);
+        emitErrorChunk(request, errorId, digest, error);
+      }
+
+      abortableTasks.forEach(task => abortTask(task, request, errorId));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function importServerContexts(contexts) {
+
+  return rootContextSnapshot;
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+function resolveServerReference(bundlerConfig, id) {
+  let name = '';
+  let resolvedModuleData = bundlerConfig[id];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = id.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = id.slice(idx + 1);
+      resolvedModuleData = bundlerConfig[id.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + id + '" in the React Server Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  } // TODO: This needs to return async: true if it's an async module.
+
+
+  return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+} // The chunk cache contains all the chunks we've preloaded so far.
+// If they're still pending they're a thenable. This map also exists
+// in Turbopack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = globalThis.__next_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+
+  for (let i = 0; i < chunks.length; i++) {
+    const chunkFilename = chunks[i];
+    const entry = chunkCache.get(chunkFilename);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkFilename);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkFilename, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkFilename, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = globalThis.__next_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+function loadChunk(filename) {
+  return globalThis.__next_chunk_load__(filename);
+}
+
+// The server acts as a Client of itself when resolving Server References.
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const RESOLVED_MODEL = 'resolved_model';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function bindArgs$1(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference$1(response, id, bound, parentChunk, parentObject, key) {
+  const serverReference = resolveServerReference(response._bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+  let promise;
+
+  if (bound) {
+    promise = Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs$1(requireModule(serverReference), args);
+    });
+  } else {
+    if (preloadPromise) {
+      promise = Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+    } else {
+      // Synchronously available
+      return requireModule(serverReference);
+    }
+  }
+
+  promise.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk)); // We need a placeholder value that will be replaced later.
+
+  return null;
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+
+  try {
+    const value = JSON.parse(chunk.value, chunk._response._fromJSON);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    const prefix = response._prefix;
+    const key = prefix + id; // Check if we have this field in the backing store already.
+
+    const backingEntry = response._formData.get(key);
+
+    if (backingEntry != null) {
+      // We assume that this is a string entry for now.
+      chunk = createResolvedModelChunk(response, backingEntry);
+    } else {
+      // We're still waiting on this entry to stream in.
+      chunk = createPendingChunk(response);
+    }
+
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+    blocked.deps++;
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  if (chunk.status === RESOLVED_MODEL) {
+    initializeModelChunk(chunk);
+  }
+
+  if (chunk.status !== INITIALIZED) {
+    // We know that this is emitted earlier so otherwise it's an error.
+    throw chunk.reason;
+  }
+
+  return chunk.value;
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16); // TODO: Just encode this in the reference inline instead of as a model.
+
+          const metaData = getOutlinedModel(response, id);
+          return loadServerReference$1(response, metaData.id, metaData.bound, initializingChunk, parentObject, key);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'K':
+        {
+          // FormData
+          const stringId = value.slice(2);
+          const formPrefix = response._prefix + stringId + '_';
+          const data = new FormData();
+          const backingFormData = response._formData; // We assume that the reference to FormData always comes after each
+          // entry that it references so we can assume they all exist in the
+          // backing store already.
+          // $FlowFixMe[prop-missing] FormData has forEach on it.
+
+          backingFormData.forEach((entry, entryKey) => {
+            if (entryKey.startsWith(formPrefix)) {
+              data.append(entryKey.slice(formPrefix.length), entry);
+            }
+          });
+          return data;
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function createResponse(bundlerConfig, formFieldPrefix) {
+  let backingFormData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new FormData();
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _prefix: formFieldPrefix,
+    _formData: backingFormData,
+    _chunks: chunks,
+    _fromJSON: function (key, value) {
+      if (typeof value === 'string') {
+        // We can't use .bind here because we need the "this" value.
+        return parseModelString(response, this, key, value);
+      }
+
+      return value;
+    }
+  };
+  return response;
+}
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function bindArgs(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference(bundlerConfig, id, bound) {
+  const serverReference = resolveServerReference(bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+
+  if (bound) {
+    return Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs(requireModule(serverReference), args);
+    });
+  } else if (preloadPromise) {
+    return Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+  } else {
+    // Synchronously available
+    return Promise.resolve(requireModule(serverReference));
+  }
+}
+
+function decodeBoundActionMetaData(body, serverManifest, formFieldPrefix) {
+  // The data for this reference is encoded in multiple fields under this prefix.
+  const actionResponse = createResponse(serverManifest, formFieldPrefix, body);
+  close(actionResponse);
+  const refPromise = getRoot(actionResponse); // Force it to initialize
+  // $FlowFixMe
+
+  refPromise.then(() => {});
+
+  if (refPromise.status !== 'fulfilled') {
+    // $FlowFixMe
+    throw refPromise.reason;
+  }
+
+  return refPromise.value;
+}
+
+function decodeAction(body, serverManifest) {
+  // We're going to create a new formData object that holds all the fields except
+  // the implementation details of the action data.
+  const formData = new FormData();
+  let action = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (!key.startsWith('$ACTION_')) {
+      formData.append(key, value);
+      return;
+    } // Later actions may override earlier actions if a button is used to override the default
+    // form action.
+
+
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      const metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+      action = loadServerReference(serverManifest, metaData.id, metaData.bound);
+      return;
+    }
+
+    if (key.startsWith('$ACTION_ID_')) {
+      const id = key.slice(11);
+      action = loadServerReference(serverManifest, id, null);
+      return;
+    }
+  });
+
+  if (action === null) {
+    return null;
+  } // Return the action with the remaining FormData bound to the first argument.
+
+
+  return action.then(fn => fn.bind(null, formData));
+}
+
+function renderToReadableStream(model, turbopackMap, options) {
+  const request = createRequest(model, turbopackMap, options ? options.onError : undefined, options ? options.context : undefined, options ? options.identifierPrefix : undefined, options ? options.onPostpone : undefined);
+
+  if (options && options.signal) {
+    const signal = options.signal;
+
+    if (signal.aborted) {
+      abort(request, signal.reason);
+    } else {
+      const listener = () => {
+        abort(request, signal.reason);
+        signal.removeEventListener('abort', listener);
+      };
+
+      signal.addEventListener('abort', listener);
+    }
+  }
+
+  const stream = new ReadableStream({
+    type: 'bytes',
+    start: controller => {
+      startWork(request);
+    },
+    pull: controller => {
+      startFlowing(request, controller);
+    },
+    cancel: reason => {}
+  }, // $FlowFixMe[prop-missing] size() methods are not allowed on byte streams.
+  {
+    highWaterMark: 0
+  });
+  return stream;
+}
+
+function decodeReply(body, turbopackMap) {
+  if (typeof body === 'string') {
+    const form = new FormData();
+    form.append('0', body);
+    body = form;
+  }
+
+  const response = createResponse(turbopackMap, '', body);
+  const root = getRoot(response);
+  close(response);
+  return root;
+}
+
+exports.createClientModuleProxy = createClientModuleProxy;
+exports.decodeAction = decodeAction;
+exports.decodeReply = decodeReply;
+exports.registerClientReference = registerClientReference;
+exports.registerServerReference = registerServerReference;
+exports.renderToReadableStream = renderToReadableStream;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.edge.production.min.js b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.edge.production.min.js
index 911e85a3948ff..ff649fe3d51a1 100644
--- a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.edge.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.edge.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-turbopack-server.edge.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-turbopack-server.edge.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var aa=require("react"),ba=require("react-dom"),m=null,n=0;function p(a,b){if(0!==b.byteLength)if(512<b.byteLength)0<n&&(a.enqueue(new Uint8Array(m.buffer,0,n)),m=new Uint8Array(512),n=0),a.enqueue(b);else{var d=m.length-n;d<b.byteLength&&(0===d?a.enqueue(m):(m.set(b.subarray(0,d),n),a.enqueue(m),b=b.subarray(d)),m=new Uint8Array(512),n=0);m.set(b,n);n+=b.byteLength}return!0}var q=new TextEncoder;function ca(a,b){"function"===typeof a.error?a.error(b):a.close()}
 var r=Symbol.for("react.client.reference"),t=Symbol.for("react.server.reference");function u(a,b,d){return Object.defineProperties(a,{$$typeof:{value:r},$$id:{value:b},$$async:{value:d}})}var da=Function.prototype.bind,ea=Array.prototype.slice;function fa(){var a=da.apply(this,arguments);if(this.$$typeof===t){var b=ea.call(arguments,1);a.$$typeof=t;a.$$id=this.$$id;a.$$bound=this.$$bound?this.$$bound.concat(b):b}return a}
 var ha=Promise.prototype,ia={get:function(a,b){switch(b){case "$$typeof":return a.$$typeof;case "$$id":return a.$$id;case "$$async":return a.$$async;case "name":return a.name;case "displayName":return;case "defaultProps":return;case "toJSON":return;case Symbol.toPrimitive:return Object.prototype[Symbol.toPrimitive];case "Provider":throw Error("Cannot render a Client Context Provider on the Server. Instead, you can export a Client Component wrapper that itself renders a Client Context Provider.");
@@ -74,3 +74,5 @@ exports.decodeAction=function(a,b){var d=new FormData,c=null;a.forEach(function(
 exports.registerClientReference=function(a,b,d){return u(a,b+"#"+d,!1)};exports.registerServerReference=function(a,b,d){return Object.defineProperties(a,{$$typeof:{value:t},$$id:{value:null===d?b:b+"#"+d},$$bound:{value:null},bind:{value:fa}})};
 exports.renderToReadableStream=function(a,b,d){var c=eb(a,b,d?d.onError:void 0,d?d.context:void 0,d?d.identifierPrefix:void 0,d?d.onPostpone:void 0);if(d&&d.signal){var e=d.signal;if(e.aborted)rb(c,e.reason);else{var f=function(){rb(c,e.reason);e.removeEventListener("abort",f)};e.addEventListener("abort",f)}}return new ReadableStream({type:"bytes",start:function(){qb(c)},pull:function(g){if(1===c.status)c.status=2,ca(g,c.fatalError);else if(2!==c.status&&null===c.destination){c.destination=g;try{P(c,
 g)}catch(k){N(c,k),pb(c,k)}}},cancel:function(){}},{highWaterMark:0})};
+
+//# sourceMappingURL=react-server-dom-turbopack-server.edge.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.node.production.js b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.node.production.js
new file mode 100644
index 0000000000000..74f179918c10d
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.node.production.js
@@ -0,0 +1,3269 @@
+/**
+ * @license React
+ * react-server-dom-turbopack-server.node.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var util = require('util');
+require('crypto');
+var async_hooks = require('async_hooks');
+var React = require('react');
+var ReactDOM = require('react-dom');
+
+// -----------------------------------------------------------------------------
+const enablePostpone = false;
+
+function scheduleWork(callback) {
+  setImmediate(callback);
+}
+function flushBuffered(destination) {
+  // If we don't have any more data to send right now.
+  // Flush whatever is in the buffer to the wire.
+  if (typeof destination.flush === 'function') {
+    // By convention the Zlib streams provide a flush function for this purpose.
+    // For Express, compression middleware adds this method.
+    destination.flush();
+  }
+}
+const VIEW_SIZE = 2048;
+let currentView = null;
+let writtenBytes = 0;
+let destinationHasCapacity = true;
+function beginWriting(destination) {
+  currentView = new Uint8Array(VIEW_SIZE);
+  writtenBytes = 0;
+  destinationHasCapacity = true;
+}
+
+function writeStringChunk(destination, stringChunk) {
+  if (stringChunk.length === 0) {
+    return;
+  } // maximum possible view needed to encode entire string
+
+
+  if (stringChunk.length * 3 > VIEW_SIZE) {
+    if (writtenBytes > 0) {
+      writeToDestination(destination, currentView.subarray(0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    writeToDestination(destination, textEncoder.encode(stringChunk));
+    return;
+  }
+
+  let target = currentView;
+
+  if (writtenBytes > 0) {
+    target = currentView.subarray(writtenBytes);
+  }
+
+  const _textEncoder$encodeIn = textEncoder.encodeInto(stringChunk, target),
+        read = _textEncoder$encodeIn.read,
+        written = _textEncoder$encodeIn.written;
+
+  writtenBytes += written;
+
+  if (read < stringChunk.length) {
+    writeToDestination(destination, currentView.subarray(0, writtenBytes));
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = textEncoder.encodeInto(stringChunk.slice(read), currentView).written;
+  }
+
+  if (writtenBytes === VIEW_SIZE) {
+    writeToDestination(destination, currentView);
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+}
+
+function writeViewChunk(destination, chunk) {
+  if (chunk.byteLength === 0) {
+    return;
+  }
+
+  if (chunk.byteLength > VIEW_SIZE) {
+    // one that is cached by the streaming renderer. We will enqueu
+    // it directly and expect it is not re-used
+
+
+    if (writtenBytes > 0) {
+      writeToDestination(destination, currentView.subarray(0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    writeToDestination(destination, chunk);
+    return;
+  }
+
+  let bytesToWrite = chunk;
+  const allowableBytes = currentView.length - writtenBytes;
+
+  if (allowableBytes < bytesToWrite.byteLength) {
+    // this chunk would overflow the current view. We enqueue a full view
+    // and start a new view with the remaining chunk
+    if (allowableBytes === 0) {
+      // the current view is already full, send it
+      writeToDestination(destination, currentView);
+    } else {
+      // fill up the current view and apply the remaining chunk bytes
+      // to a new view.
+      currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes);
+      writtenBytes += allowableBytes;
+      writeToDestination(destination, currentView);
+      bytesToWrite = bytesToWrite.subarray(allowableBytes);
+    }
+
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+
+  currentView.set(bytesToWrite, writtenBytes);
+  writtenBytes += bytesToWrite.byteLength;
+
+  if (writtenBytes === VIEW_SIZE) {
+    writeToDestination(destination, currentView);
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+}
+
+function writeChunk(destination, chunk) {
+  if (typeof chunk === 'string') {
+    writeStringChunk(destination, chunk);
+  } else {
+    writeViewChunk(destination, chunk);
+  }
+}
+
+function writeToDestination(destination, view) {
+  const currentHasCapacity = destination.write(view);
+  destinationHasCapacity = destinationHasCapacity && currentHasCapacity;
+}
+
+function writeChunkAndReturn(destination, chunk) {
+  writeChunk(destination, chunk);
+  return destinationHasCapacity;
+}
+function completeWriting(destination) {
+  if (currentView && writtenBytes > 0) {
+    destination.write(currentView.subarray(0, writtenBytes));
+  }
+
+  currentView = null;
+  writtenBytes = 0;
+  destinationHasCapacity = true;
+}
+function close$1(destination) {
+  destination.end();
+}
+const textEncoder = new util.TextEncoder();
+function stringToChunk(content) {
+  return content;
+}
+function byteLengthOfChunk(chunk) {
+  return typeof chunk === 'string' ? Buffer.byteLength(chunk, 'utf8') : chunk.byteLength;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+  destination.destroy(error);
+}
+
+// eslint-disable-next-line no-unused-vars
+const CLIENT_REFERENCE_TAG = Symbol.for('react.client.reference');
+const SERVER_REFERENCE_TAG = Symbol.for('react.server.reference');
+function isClientReference(reference) {
+  return reference.$$typeof === CLIENT_REFERENCE_TAG;
+}
+function isServerReference(reference) {
+  return reference.$$typeof === SERVER_REFERENCE_TAG;
+}
+function registerClientReference(proxyImplementation, id, exportName) {
+  return registerClientReferenceImpl(proxyImplementation, id + '#' + exportName, false);
+}
+
+function registerClientReferenceImpl(proxyImplementation, id, async) {
+  return Object.defineProperties(proxyImplementation, {
+    $$typeof: {
+      value: CLIENT_REFERENCE_TAG
+    },
+    $$id: {
+      value: id
+    },
+    $$async: {
+      value: async
+    }
+  });
+} // $FlowFixMe[method-unbinding]
+
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+
+  if (this.$$typeof === SERVER_REFERENCE_TAG) {
+    const args = ArraySlice.call(arguments, 1);
+    newFn.$$typeof = SERVER_REFERENCE_TAG;
+    newFn.$$id = this.$$id;
+    newFn.$$bound = this.$$bound ? this.$$bound.concat(args) : args;
+  }
+
+  return newFn;
+}
+
+function registerServerReference(reference, id, exportName) {
+  return Object.defineProperties(reference, {
+    $$typeof: {
+      value: SERVER_REFERENCE_TAG
+    },
+    $$id: {
+      value: exportName === null ? id : id + '#' + exportName
+    },
+    $$bound: {
+      value: null
+    },
+    bind: {
+      value: bind
+    }
+  });
+}
+const PROMISE_PROTOTYPE = Promise.prototype;
+const deepProxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        // These names are a little too common. We should probably have a way to
+        // have the Flight runtime extract the inner target instead.
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+
+      case 'displayName':
+        return undefined;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case 'Provider':
+        throw new Error("Cannot render a Client Context Provider on the Server. " + "Instead, you can export a Client Component wrapper " + "that itself renders a Client Context Provider.");
+    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+    const expression = String(target.name) + '.' + String(name);
+    throw new Error("Cannot access " + expression + " on the server. " + 'You cannot dot into a client module from a server component. ' + 'You can only pass the imported name through.');
+  },
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+const proxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case '__esModule':
+        // Something is conditionally checking which export to use. We'll pretend to be
+        // an ESM compat module but then we'll check again on the client.
+        const moduleId = target.$$id;
+        target.default = registerClientReferenceImpl(function () {
+          throw new Error("Attempted to call the default export of " + moduleId + " from the server " + "but it's on the client. It's not possible to invoke a client function from " + "the server, it can only be rendered as a Component or passed to props of a " + "Client Component.");
+        }, target.$$id + '#', target.$$async);
+        return true;
+
+      case 'then':
+        if (target.then) {
+          // Use a cached value
+          return target.then;
+        }
+
+        if (!target.$$async) {
+          // If this module is expected to return a Promise (such as an AsyncModule) then
+          // we should resolve that with a client reference that unwraps the Promise on
+          // the client.
+          const clientReference = registerClientReferenceImpl({}, target.$$id, true);
+          const proxy = new Proxy(clientReference, proxyHandlers); // Treat this as a resolved Promise for React's use()
+
+          target.status = 'fulfilled';
+          target.value = proxy;
+          const then = target.then = registerClientReferenceImpl(function then(resolve, reject) {
+            // Expose to React.
+            return Promise.resolve(resolve(proxy));
+          }, // If this is not used as a Promise but is treated as a reference to a `.then`
+          // export then we should treat it as a reference to that name.
+          target.$$id + '#then', false);
+          return then;
+        } else {
+          // Since typeof .then === 'function' is a feature test we'd continue recursing
+          // indefinitely if we return a function. Instead, we return an object reference
+          // if we check further.
+          return undefined;
+        }
+
+    }
+
+    let cachedReference = target[name];
+
+    if (!cachedReference) {
+      const reference = registerClientReferenceImpl(function () {
+        throw new Error( // eslint-disable-next-line react-internal/safe-string-coercion
+        "Attempted to call " + String(name) + "() from the server but " + String(name) + " is on the client. " + "It's not possible to invoke a client function from the server, it can " + "only be rendered as a Component or passed to props of a Client Component.");
+      }, target.$$id + '#' + name, target.$$async);
+      Object.defineProperty(reference, 'name', {
+        value: name
+      });
+      cachedReference = target[name] = new Proxy(reference, deepProxyHandlers);
+    }
+
+    return cachedReference;
+  },
+
+  getPrototypeOf(target) {
+    // Pretend to be a Promise in case anyone asks.
+    return PROMISE_PROTOTYPE;
+  },
+
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+function createClientModuleProxy(moduleId) {
+  const clientReference = registerClientReferenceImpl({}, // Represents the whole Module object instead of a particular import.
+  moduleId, false);
+  return new Proxy(clientReference, proxyHandlers);
+}
+
+function getClientReferenceKey(reference) {
+  return reference.$$async ? reference.$$id + '#async' : reference.$$id;
+}
+function resolveClientReferenceMetadata(config, clientReference) {
+  const modulePath = clientReference.$$id;
+  let name = '';
+  let resolvedModuleData = config[modulePath];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = modulePath.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = modulePath.slice(idx + 1);
+      resolvedModuleData = config[modulePath.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + modulePath + '" in the React Client Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  }
+
+  if (clientReference.$$async === true) {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1];
+  } else {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+  }
+}
+function getServerReferenceId(config, serverReference) {
+  return serverReference.$$id;
+}
+function getServerReferenceBoundArguments(config, serverReference) {
+  return serverReference.$$bound;
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMFlightServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule: preloadModule$1,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+
+function prefetchDNS(href) {
+  {
+    if (typeof href === 'string' && href) {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'D|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        emitHint(request, 'D', href);
+      }
+    }
+  }
+}
+
+function preconnect(href, crossOrigin) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = "C|" + (crossOrigin == null ? 'null' : crossOrigin) + "|" + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+
+        if (typeof crossOrigin === 'string') {
+          emitHint(request, 'C', [href, crossOrigin]);
+        } else {
+          emitHint(request, 'C', href);
+        }
+      }
+    }
+  }
+}
+
+function preload(href, as, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        let key = 'L';
+
+        if (as === 'image' && options) {
+          key += getImagePreloadKey(href, options.imageSrcSet, options.imageSizes);
+        } else {
+          key += "[" + as + "]" + href;
+        }
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          emitHint(request, 'L', [href, as, trimmed]);
+        } else {
+          emitHint(request, 'L', [href, as]);
+        }
+      }
+    }
+  }
+}
+
+function preloadModule$1(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'm|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'm', [href, trimmed]);
+        } else {
+          return emitHint(request, 'm', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'S|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'S', [href, typeof precedence === 'string' ? precedence : 0, trimmed]);
+        } else if (typeof precedence === 'string') {
+          return emitHint(request, 'S', [href, precedence]);
+        } else {
+          return emitHint(request, 'S', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'X|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'X', [href, trimmed]);
+        } else {
+          return emitHint(request, 'X', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitModuleScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'M|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'M', [href, trimmed]);
+        } else {
+          return emitHint(request, 'M', href);
+        }
+      }
+    }
+  }
+} // Flight normally encodes undefined as a special character however for directive option
+// arguments we don't want to send unnecessary keys and bloat the payload so we create a
+// trimmed object which omits any keys with null or undefined values.
+// This is only typesafe because these option objects have entirely optional fields where
+// null and undefined represent the same thing as no property.
+
+
+function trimOptions(options) {
+  if (options == null) return null;
+  let hasProperties = false;
+  const trimmed = {};
+
+  for (const key in options) {
+    if (options[key] != null) {
+      hasProperties = true;
+      trimmed[key] = options[key];
+    }
+  }
+
+  return hasProperties ? trimmed : null;
+}
+
+function getImagePreloadKey(href, imageSrcSet, imageSizes) {
+  let uniquePart = '';
+
+  if (typeof imageSrcSet === 'string' && imageSrcSet !== '') {
+    uniquePart += '[' + imageSrcSet + ']';
+
+    if (typeof imageSizes === 'string') {
+      uniquePart += '[' + imageSizes + ']';
+    }
+  } else {
+    uniquePart += '[][]' + href;
+  }
+
+  return "[image]" + uniquePart;
+}
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMFlightServerDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+// small, smaller than how we encode undefined, and is unambiguous. We could use
+// a different tuple structure to encode this instead but this makes the runtime
+// cost cheaper by eliminating a type checks in more positions.
+// prettier-ignore
+
+function createHints() {
+  return new Set();
+}
+
+const requestStorage = new async_hooks.AsyncLocalStorage();
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext); // On the way back, we push the new ones that weren't common.
+
+      pushNode(next);
+    }
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFizzWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop, noop);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+let currentRequest$1 = null;
+let thenableIndexCounter = 0;
+let thenableState = null;
+function prepareToUseHooksForRequest(request) {
+  currentRequest$1 = request;
+}
+function resetHooksForRequest() {
+  currentRequest$1 = null;
+}
+function prepareToUseHooksForComponent(prevThenableState) {
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+const HooksDispatcher = {
+  useMemo(nextCreate) {
+    return nextCreate();
+  },
+
+  useCallback(callback) {
+    return callback;
+  },
+
+  useDebugValue() {},
+
+  useDeferredValue: unsupportedHook,
+  useTransition: unsupportedHook,
+  readContext,
+  useContext: readContext,
+  useReducer: unsupportedHook,
+  useRef: unsupportedHook,
+  useState: unsupportedHook,
+  useInsertionEffect: unsupportedHook,
+  useLayoutEffect: unsupportedHook,
+  useImperativeHandle: unsupportedHook,
+  useEffect: unsupportedHook,
+  useId,
+  useSyncExternalStore: unsupportedHook,
+
+  useCacheRefresh() {
+    return unsupportedRefresh;
+  },
+
+  useMemoCache(size) {
+    const data = new Array(size);
+
+    for (let i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL;
+    }
+
+    return data;
+  },
+
+  use
+};
+
+function unsupportedHook() {
+  throw new Error('This Hook is not supported in Server Components.');
+}
+
+function unsupportedRefresh() {
+  throw new Error('Refreshing the cache is not supported in Server Components.');
+}
+
+function useId() {
+  if (currentRequest$1 === null) {
+    throw new Error('useId can only be used while React is rendering');
+  }
+
+  const id = currentRequest$1.identifierCount++; // use 'S' for Flight components to distinguish from 'R' and 'r' in Fizz/Client
+
+  return ':' + currentRequest$1.identifierPrefix + 'S' + id.toString(32) + ':';
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object' || typeof usable === 'function') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable; // Track the position of the thenable within this fiber.
+
+      const index = thenableIndexCounter;
+      thenableIndexCounter += 1;
+
+      if (thenableState === null) {
+        thenableState = createThenableState();
+      }
+
+      return trackUsedThenable(thenableState, thenable, index);
+    } else if (usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  }
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function createSignal() {
+  return new AbortController().signal;
+}
+
+function resolveCache() {
+  const request = resolveRequest();
+
+  if (request) {
+    return getCache(request);
+  }
+
+  return new Map();
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal() {
+    const cache = resolveCache();
+    let entry = cache.get(createSignal);
+
+    if (entry === undefined) {
+      entry = createSignal();
+      cache.set(createSignal, entry);
+    }
+
+    return entry;
+  },
+
+  getCacheForType(resourceType) {
+    const cache = resolveCache();
+    let entry = cache.get(resourceType);
+
+    if (entry === undefined) {
+      entry = resourceType(); // TODO: Warn if undefined?
+
+      cache.set(resourceType, entry);
+    }
+
+    return entry;
+  }
+
+};
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+function objectName(object) {
+  // $FlowFixMe[method-unbinding]
+  const name = Object.prototype.toString.call(object);
+  return name.replace(/^\[object (.*)\]$/, function (m, p0) {
+    return p0;
+  });
+}
+
+function describeKeyForErrorMessage(key) {
+  const encodedKey = JSON.stringify(key);
+  return '"' + key + '"' === encodedKey ? key : encodedKey;
+}
+
+function describeValueForErrorMessage(value) {
+  switch (typeof value) {
+    case 'string':
+      {
+        return JSON.stringify(value.length <= 10 ? value : value.slice(0, 10) + '...');
+      }
+
+    case 'object':
+      {
+        if (isArray(value)) {
+          return '[...]';
+        }
+
+        const name = objectName(value);
+
+        if (name === 'Object') {
+          return '{...}';
+        }
+
+        return name;
+      }
+
+    case 'function':
+      return 'function';
+
+    default:
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      return String(value);
+  }
+}
+
+function describeElementType(type) {
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        return describeElementType(type.render);
+
+      case REACT_MEMO_TYPE:
+        return describeElementType(type.type);
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            // Lazy may contain any component type so we recursively resolve it.
+            return describeElementType(init(payload));
+          } catch (x) {}
+        }
+    }
+  }
+
+  return '';
+}
+
+function describeObjectForErrorMessage(objectOrArray, expandedName) {
+  const objKind = objectName(objectOrArray);
+
+  if (objKind !== 'Object' && objKind !== 'Array') {
+    return objKind;
+  }
+
+  let str = '';
+  let start = -1;
+  let length = 0;
+
+  if (isArray(objectOrArray)) {
+    {
+      // Print Array
+      str = '[';
+      const array = objectOrArray;
+
+      for (let i = 0; i < array.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const value = array[i];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if ('' + i === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += ']';
+    }
+  } else {
+    if (objectOrArray.$$typeof === REACT_ELEMENT_TYPE) {
+      str = '<' + describeElementType(objectOrArray.type) + '/>';
+    } else {
+      // Print Object
+      str = '{';
+      const object = objectOrArray;
+      const names = Object.keys(object);
+
+      for (let i = 0; i < names.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const name = names[i];
+        str += describeKeyForErrorMessage(name) + ': ';
+        const value = object[name];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if (name === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += '}';
+    }
+  }
+
+  if (expandedName === undefined) {
+    return str;
+  }
+
+  if (start > -1 && length > 0) {
+    const highlight = ' '.repeat(start) + '^'.repeat(length);
+    return '\n  ' + str + '\n  ' + highlight;
+  }
+
+  return '\n  ' + str;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactSharedServerInternals = // $FlowFixMe: It's defined in the one we resolve to.
+React.__SECRET_SERVER_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+if (!ReactSharedServerInternals) {
+  throw new Error('The "react" package in this environment is not configured correctly. ' + 'The "react-server" condition must be enabled in any environment that ' + 'runs React Server Components.');
+}
+
+const ObjectPrototype = Object.prototype;
+const stringify = JSON.stringify; // Serializable values
+// Thenable<ReactClientValue>
+
+const PENDING$1 = 0;
+const COMPLETED = 1;
+const ABORTED = 3;
+const ERRORED$1 = 4;
+const ReactCurrentCache = ReactSharedServerInternals.ReactCurrentCache;
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+}
+
+function defaultPostponeHandler(reason) {// Noop
+}
+
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2;
+function createRequest(model, bundlerConfig, onError, context, identifierPrefix, onPostpone) {
+  if (ReactCurrentCache.current !== null && ReactCurrentCache.current !== DefaultCacheDispatcher) {
+    throw new Error('Currently React only supports one RSC renderer at a time.');
+  }
+
+  prepareHostDispatcher();
+  ReactCurrentCache.current = DefaultCacheDispatcher;
+  const abortSet = new Set();
+  const pingedTasks = [];
+  const cleanupQueue = [];
+
+  const hints = createHints();
+  const request = {
+    status: OPEN,
+    flushScheduled: false,
+    fatalError: null,
+    destination: null,
+    bundlerConfig,
+    cache: new Map(),
+    nextChunkId: 0,
+    pendingChunks: 0,
+    hints,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    completedImportChunks: [],
+    completedHintChunks: [],
+    completedRegularChunks: [],
+    completedErrorChunks: [],
+    writtenSymbols: new Map(),
+    writtenClientReferences: new Map(),
+    writtenServerReferences: new Map(),
+    writtenProviders: new Map(),
+    writtenObjects: new WeakMap(),
+    identifierPrefix: identifierPrefix || '',
+    identifierCount: 1,
+    taintCleanupQueue: cleanupQueue,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? defaultPostponeHandler : onPostpone,
+    // $FlowFixMe[missing-this-annot]
+    toJSON: function (key, value) {
+      return resolveModelToJSON(request, this, key, value);
+    }
+  };
+  request.pendingChunks++;
+  const rootContext = createRootContext();
+  const rootTask = createTask(request, model, rootContext, abortSet);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  {
+    const store = requestStorage.getStore();
+    if (store) return store;
+  }
+
+  return null;
+}
+
+function createRootContext(reqContext) {
+  return importServerContexts();
+}
+
+function serializeThenable(request, thenable) {
+  request.pendingChunks++;
+  const newTask = createTask(request, null, getActiveContext(), request.abortableTasks);
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        // We have the resolved value, we can go ahead and schedule it for serialization.
+        newTask.model = thenable.value;
+        pingTask(request, newTask);
+        return newTask.id;
+      }
+
+    case 'rejected':
+      {
+        const x = thenable.reason;
+
+        {
+          const digest = logRecoverableError(request, x);
+          emitErrorChunk(request, newTask.id, digest);
+        }
+
+        return newTask.id;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  thenable.then(value => {
+    newTask.model = value;
+    pingTask(request, newTask);
+  }, reason => {
+    newTask.status = ERRORED$1;
+    request.abortableTasks.delete(newTask); // TODO: We should ideally do this inside performWork so it's scheduled
+
+    const digest = logRecoverableError(request, reason);
+    emitErrorChunk(request, newTask.id, digest);
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  });
+  return newTask.id;
+}
+
+function emitHint(request, code, model) {
+  emitHintChunk(request, code, model);
+  enqueueFlush(request);
+}
+function getHints(request) {
+  return request.hints;
+}
+function getCache(request) {
+  return request.cache;
+}
+
+function readThenable(thenable) {
+  if (thenable.status === 'fulfilled') {
+    return thenable.value;
+  } else if (thenable.status === 'rejected') {
+    throw thenable.reason;
+  }
+
+  throw thenable;
+}
+
+function createLazyWrapperAroundWakeable(wakeable) {
+  // This is a temporary fork of the `use` implementation until we accept
+  // promises everywhere.
+  const thenable = wakeable;
+
+  switch (thenable.status) {
+    case 'fulfilled':
+    case 'rejected':
+      break;
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: thenable,
+    _init: readThenable
+  };
+  return lazyType;
+}
+
+function attemptResolveElement(request, type, key, ref, props, prevThenableState) {
+  if (ref !== null && ref !== undefined) {
+    // When the ref moves to the regular props object this will implicitly
+    // throw for functions. We could probably relax it to a DEV warning for other
+    // cases.
+    throw new Error('Refs cannot be used in Server Components, nor passed to Client Components.');
+  }
+
+  if (typeof type === 'function') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    } // This is a server-side component.
+
+
+    prepareToUseHooksForComponent(prevThenableState);
+    const result = type(props);
+
+    if (typeof result === 'object' && result !== null && typeof result.then === 'function') {
+      // When the return value is in children position we can resolve it immediately,
+      // to its value without a wrapper if it's synchronously available.
+      const thenable = result;
+
+      if (thenable.status === 'fulfilled') {
+        return thenable.value;
+      } // TODO: Once we accept Promises as children on the client, we can just return
+      // the thenable here.
+
+
+      return createLazyWrapperAroundWakeable(result);
+    }
+
+    return result;
+  } else if (typeof type === 'string') {
+    // This is a host element. E.g. HTML.
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (typeof type === 'symbol') {
+    if (type === REACT_FRAGMENT_TYPE) {
+      // For key-less fragments, we add a small optimization to avoid serializing
+      // it as a wrapper.
+      // TODO: If a key is specified, we should propagate its key to any children.
+      // Same as if a Server Component has a key.
+      return props.children;
+    } // This might be a built-in React component. We'll let the client decide.
+    // Any built-in works as long as its props are serializable.
+
+
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (type != null && typeof type === 'object') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    }
+
+    switch (type.$$typeof) {
+      case REACT_LAZY_TYPE:
+        {
+          const payload = type._payload;
+          const init = type._init;
+          const wrappedType = init(payload);
+          return attemptResolveElement(request, wrappedType, key, ref, props, prevThenableState);
+        }
+
+      case REACT_FORWARD_REF_TYPE:
+        {
+          const render = type.render;
+          prepareToUseHooksForComponent(prevThenableState);
+          return render(props, undefined);
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          return attemptResolveElement(request, type.type, key, ref, props, prevThenableState);
+        }
+    }
+  }
+
+  throw new Error("Unsupported Server Component type: " + describeValueForErrorMessage(type));
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createTask(request, model, context, abortSet) {
+  const id = request.nextChunkId++;
+  const task = {
+    id,
+    status: PENDING$1,
+    model,
+    context,
+    ping: () => pingTask(request, task),
+    thenableState: null
+  };
+  abortSet.add(task);
+  return task;
+}
+
+function serializeByValueID(id) {
+  return '$' + id.toString(16);
+}
+
+function serializeLazyID(id) {
+  return '$L' + id.toString(16);
+}
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeRowHeader(tag, id) {
+  return id.toString(16) + ':' + tag;
+}
+
+function encodeReferenceChunk(request, id, reference) {
+  const json = stringify(reference);
+  const row = id.toString(16) + ':' + json + '\n';
+  return stringToChunk(row);
+}
+
+function serializeClientReference(request, parent, key, clientReference) {
+  const clientReferenceKey = getClientReferenceKey(clientReference);
+  const writtenClientReferences = request.writtenClientReferences;
+  const existingId = writtenClientReferences.get(clientReferenceKey);
+
+  if (existingId !== undefined) {
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(existingId);
+    }
+
+    return serializeByValueID(existingId);
+  }
+
+  try {
+    const clientReferenceMetadata = resolveClientReferenceMetadata(request.bundlerConfig, clientReference);
+    request.pendingChunks++;
+    const importId = request.nextChunkId++;
+    emitImportChunk(request, importId, clientReferenceMetadata);
+    writtenClientReferences.set(clientReferenceKey, importId);
+
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(importId);
+    }
+
+    return serializeByValueID(importId);
+  } catch (x) {
+    request.pendingChunks++;
+    const errorId = request.nextChunkId++;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, errorId, digest);
+    return serializeByValueID(errorId);
+  }
+}
+
+function outlineModel(request, value) {
+  request.pendingChunks++;
+  const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+  retryTask(request, newTask);
+  return newTask.id;
+}
+
+function serializeServerReference(request, parent, key, serverReference) {
+  const writtenServerReferences = request.writtenServerReferences;
+  const existingId = writtenServerReferences.get(serverReference);
+
+  if (existingId !== undefined) {
+    return serializeServerReferenceID(existingId);
+  }
+
+  const bound = getServerReferenceBoundArguments(request.bundlerConfig, serverReference);
+  const serverReferenceMetadata = {
+    id: getServerReferenceId(request.bundlerConfig, serverReference),
+    bound: bound ? Promise.resolve(bound) : null
+  };
+  const metadataId = outlineModel(request, serverReferenceMetadata);
+  writtenServerReferences.set(serverReference, metadataId);
+  return serializeServerReferenceID(metadataId);
+}
+
+function serializeLargeTextString(request, text) {
+  request.pendingChunks += 2;
+  const textId = request.nextChunkId++;
+  const textChunk = stringToChunk(text);
+  const binaryLength = byteLengthOfChunk(textChunk);
+  const row = textId.toString(16) + ':T' + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, textChunk);
+  return serializeByValueID(textId);
+}
+
+function serializeMap(request, map) {
+  const entries = Array.from(map);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i][0];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$Q' + id.toString(16);
+}
+
+function serializeSet(request, set) {
+  const entries = Array.from(set);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+let modelRoot = false;
+
+function resolveModelToJSON(request, parent, key, value) {
+
+
+  switch (value) {
+    case REACT_ELEMENT_TYPE:
+      return '$';
+  }
+
+
+  while (typeof value === 'object' && value !== null && (value.$$typeof === REACT_ELEMENT_TYPE || value.$$typeof === REACT_LAZY_TYPE)) {
+
+    try {
+      switch (value.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const writtenObjects = request.writtenObjects;
+            const existingId = writtenObjects.get(value);
+
+            if (existingId !== undefined) {
+              if (existingId === -1) {
+                // Seen but not yet outlined.
+                const newId = outlineModel(request, value);
+                return serializeByValueID(newId);
+              } else if (modelRoot === value) {
+                // This is the ID we're currently emitting so we need to write it
+                // once but if we discover it again, we refer to it by id.
+                modelRoot = null;
+              } else {
+                // We've already emitted this as an outlined object, so we can
+                // just refer to that by its existing ID.
+                return serializeByValueID(existingId);
+              }
+            } else {
+              // This is the first time we've seen this object. We may never see it again
+              // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+              writtenObjects.set(value, -1);
+            } // TODO: Concatenate keys of parents onto children.
+
+
+            const element = value; // Attempt to render the Server Component.
+
+            value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, null);
+            break;
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = value._payload;
+            const init = value._init;
+            value = init(payload);
+            break;
+          }
+      }
+    } catch (thrownValue) {
+      const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          // Something suspended, we'll need to create a new task and resolve it later.
+          request.pendingChunks++;
+          const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+          const ping = newTask.ping;
+          x.then(ping, ping);
+          newTask.thenableState = getThenableStateAfterSuspending();
+          return serializeLazyID(newTask.id);
+        }
+      } // Something errored. We'll still send everything we have up until this point.
+      // We'll replace this element with a lazy reference that throws on the client
+      // once it gets rendered.
+
+
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+      const digest = logRecoverableError(request, x);
+      emitErrorChunk(request, errorId, digest);
+      return serializeLazyID(errorId);
+    }
+  }
+
+  if (value === null) {
+    return null;
+  }
+
+  if (typeof value === 'object') {
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    const writtenObjects = request.writtenObjects;
+    const existingId = writtenObjects.get(value); // $FlowFixMe[method-unbinding]
+
+    if (typeof value.then === 'function') {
+      if (existingId !== undefined) {
+        if (modelRoot === value) {
+          // This is the ID we're currently emitting so we need to write it
+          // once but if we discover it again, we refer to it by id.
+          modelRoot = null;
+        } else {
+          // We've seen this promise before, so we can just refer to the same result.
+          return serializePromiseID(existingId);
+        }
+      } // We assume that any object with a .then property is a "Thenable" type,
+      // or a Promise type. Either of which can be represented by a Promise.
+
+
+      const promiseId = serializeThenable(request, value);
+      writtenObjects.set(value, promiseId);
+      return serializePromiseID(promiseId);
+    }
+
+    if (existingId !== undefined) {
+      if (existingId === -1) {
+        // Seen but not yet outlined.
+        const newId = outlineModel(request, value);
+        return serializeByValueID(newId);
+      } else if (modelRoot === value) {
+        // This is the ID we're currently emitting so we need to write it
+        // once but if we discover it again, we refer to it by id.
+        modelRoot = null;
+      } else {
+        // We've already emitted this as an outlined object, so we can
+        // just refer to that by its existing ID.
+        return serializeByValueID(existingId);
+      }
+    } else {
+      // This is the first time we've seen this object. We may never see it again
+      // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+      writtenObjects.set(value, -1);
+    }
+
+    if (isArray(value)) {
+      // $FlowFixMe[incompatible-return]
+      return value;
+    }
+
+    if (value instanceof Map) {
+      return serializeMap(request, value);
+    }
+
+    if (value instanceof Set) {
+      return serializeSet(request, value);
+    }
+
+    const iteratorFn = getIteratorFn(value);
+
+    if (iteratorFn) {
+      return Array.from(value);
+    } // Verify that this is a simple plain object.
+
+
+    const proto = getPrototypeOf(value);
+
+    if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+      throw new Error('Only plain objects, and a few built-ins, can be passed to Client Components ' + 'from Server Components. Classes or null prototypes are not supported.');
+    }
+
+
+    return value;
+  }
+
+  if (typeof value === 'string') {
+
+
+    if (value[value.length - 1] === 'Z') {
+      // Possibly a Date, whose toJSON automatically calls toISOString
+      // $FlowFixMe[incompatible-use]
+      const originalValue = parent[key];
+
+      if (originalValue instanceof Date) {
+        return serializeDateFromDateJSON(value);
+      }
+    }
+
+    if (value.length >= 1024) {
+      // For large strings, we encode them outside the JSON payload so that we
+      // don't have to double encode and double parse the strings. This can also
+      // be more compact in case the string has a lot of escaped characters.
+      return serializeLargeTextString(request, value);
+    }
+
+    return escapeStringValue(value);
+  }
+
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  if (typeof value === 'number') {
+    return serializeNumber(value);
+  }
+
+  if (typeof value === 'undefined') {
+    return serializeUndefined();
+  }
+
+  if (typeof value === 'function') {
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    if (isServerReference(value)) {
+      return serializeServerReference(request, parent, key, value);
+    }
+
+    if (/^on[A-Z]/.test(key)) {
+      throw new Error('Event handlers cannot be passed to Client Component props.' + describeObjectForErrorMessage(parent, key) + '\nIf you need interactivity, consider converting part of this to a Client Component.');
+    } else {
+      throw new Error('Functions cannot be passed directly to Client Components ' + 'unless you explicitly expose it by marking it with "use server".' + describeObjectForErrorMessage(parent, key));
+    }
+  }
+
+  if (typeof value === 'symbol') {
+    const writtenSymbols = request.writtenSymbols;
+    const existingId = writtenSymbols.get(value);
+
+    if (existingId !== undefined) {
+      return serializeByValueID(existingId);
+    } // $FlowFixMe[incompatible-type] `description` might be undefined
+
+
+    const name = value.description;
+
+    if (Symbol.for(name) !== value) {
+      throw new Error('Only global symbols received from Symbol.for(...) can be passed to Client Components. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+      value.description + ") cannot be found among global symbols.") + describeObjectForErrorMessage(parent, key));
+    }
+
+    request.pendingChunks++;
+    const symbolId = request.nextChunkId++;
+    emitSymbolChunk(request, symbolId, name);
+    writtenSymbols.set(value, symbolId);
+    return serializeByValueID(symbolId);
+  }
+
+  if (typeof value === 'bigint') {
+
+    return serializeBigInt(value);
+  }
+
+  throw new Error("Type " + typeof value + " is not supported in Client Component props." + describeObjectForErrorMessage(parent, key));
+}
+
+function logPostpone(request, reason) {
+  const onPostpone = request.onPostpone;
+  onPostpone(reason);
+}
+
+function logRecoverableError(request, error) {
+  const onError = request.onError;
+  const errorDigest = onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest || '';
+}
+
+function fatalError(request, error) {
+
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function emitPostponeChunk(request, id, postponeInstance) {
+  let row;
+
+  {
+    // No reason included in prod.
+    row = serializeRowHeader('P', id) + '\n';
+  }
+
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitErrorChunk(request, id, digest, error) {
+  let errorInfo;
+
+  {
+    errorInfo = {
+      digest
+    };
+  }
+
+  const row = serializeRowHeader('E', id) + stringify(errorInfo) + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitImportChunk(request, id, clientReferenceMetadata) {
+  // $FlowFixMe[incompatible-type] stringify can return null
+  const json = stringify(clientReferenceMetadata);
+  const row = serializeRowHeader('I', id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitHintChunk(request, code, model) {
+  const json = stringify(model);
+  const id = request.nextChunkId++;
+  const row = serializeRowHeader('H' + code, id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedHintChunks.push(processedChunk);
+}
+
+function emitSymbolChunk(request, id, name) {
+  const symbolReference = serializeSymbolReference(name);
+  const processedChunk = encodeReferenceChunk(request, id, symbolReference);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitModelChunk(request, id, model) {
+  // Track the root so we know that we have to emit this object even though it
+  // already has an ID. This is needed because we might see this object twice
+  // in the same toJSON if it is cyclic.
+  modelRoot = model; // $FlowFixMe[incompatible-type] stringify can return null
+
+  const json = stringify(model, request.toJSON);
+  const row = id.toString(16) + ':' + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function retryTask(request, task) {
+  if (task.status !== PENDING$1) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  }
+
+  switchContext(task.context);
+
+  try {
+    let value = task.model;
+
+    if (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+      request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+      const element = value; // When retrying a component, reuse the thenableState from the
+      // previous attempt.
+
+      const prevThenableState = task.thenableState; // Attempt to render the Server Component.
+      // Doing this here lets us reuse this same task if the next component
+      // also suspends.
+
+      task.model = value;
+      value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, prevThenableState); // Successfully finished this component. We're going to keep rendering
+      // using the same task, but we reset its thenable state before continuing.
+
+      task.thenableState = null; // Keep rendering and reuse the same task. This inner loop is separate
+      // from the render above because we don't need to reset the thenable state
+      // until the next time something suspends and retries.
+
+      while (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+        request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+        const nextElement = value;
+        task.model = value;
+        value = attemptResolveElement(request, nextElement.type, nextElement.key, nextElement.ref, nextElement.props, null);
+      }
+    } // Track that this object is outlined and has an id.
+
+
+    if (typeof value === 'object' && value !== null) {
+      request.writtenObjects.set(value, task.id);
+    }
+
+    emitModelChunk(request, task.id, value);
+    request.abortableTasks.delete(task);
+    task.status = COMPLETED;
+  } catch (thrownValue) {
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    request.abortableTasks.delete(task);
+    task.status = ERRORED$1;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, task.id, digest);
+  }
+}
+
+function performWork(request) {
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  const prevRequest = currentRequest;
+  currentRequest = request;
+  prepareToUseHooksForRequest(request);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    request.pingedTasks = [];
+
+    for (let i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    ReactCurrentDispatcher.current = prevDispatcher;
+    resetHooksForRequest();
+    currentRequest = prevRequest;
+  }
+}
+
+function abortTask(task, request, errorId) {
+  task.status = ABORTED; // Instead of emitting an error per task.id, we emit a model that only
+  // has a single value referencing the error.
+
+  const ref = serializeByValueID(errorId);
+  const processedChunk = encodeReferenceChunk(request, task.id, ref);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function flushCompletedChunks(request, destination) {
+  beginWriting();
+
+  try {
+    // We emit module chunks first in the stream so that
+    // they can be preloaded as early as possible.
+    const importsChunks = request.completedImportChunks;
+    let i = 0;
+
+    for (; i < importsChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = importsChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    importsChunks.splice(0, i); // Next comes hints.
+
+    const hintChunks = request.completedHintChunks;
+    i = 0;
+
+    for (; i < hintChunks.length; i++) {
+      const chunk = hintChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    hintChunks.splice(0, i); // Next comes model data.
+
+    const regularChunks = request.completedRegularChunks;
+    i = 0;
+
+    for (; i < regularChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = regularChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    regularChunks.splice(0, i); // Finally, errors are sent. The idea is that it's ok to delay
+    // any error messages and prioritize display of other parts of
+    // the page.
+
+    const errorChunks = request.completedErrorChunks;
+    i = 0;
+
+    for (; i < errorChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = errorChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    errorChunks.splice(0, i);
+  } finally {
+    request.flushScheduled = false;
+    completeWriting(destination);
+  }
+
+  flushBuffered(destination);
+
+  if (request.pendingChunks === 0) {
+
+    close$1(destination);
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  {
+    scheduleWork(() => requestStorage.run(request, performWork, request));
+  }
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    const destination = request.destination;
+    request.flushScheduled = true;
+    scheduleWork(() => flushCompletedChunks(request, destination));
+  }
+}
+
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedChunks(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      // We have tasks to abort. We'll emit one error row and then emit a reference
+      // to that row from every row that's still remaining.
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+
+      if (enablePostpone && typeof reason === 'object' && reason !== null && reason.$$typeof === REACT_POSTPONE_TYPE) ; else {
+        const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+        const digest = logRecoverableError(request, error);
+        emitErrorChunk(request, errorId, digest, error);
+      }
+
+      abortableTasks.forEach(task => abortTask(task, request, errorId));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function importServerContexts(contexts) {
+
+  return rootContextSnapshot;
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+function resolveServerReference(bundlerConfig, id) {
+  let name = '';
+  let resolvedModuleData = bundlerConfig[id];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = id.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = id.slice(idx + 1);
+      resolvedModuleData = bundlerConfig[id.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + id + '" in the React Server Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  } // TODO: This needs to return async: true if it's an async module.
+
+
+  return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+} // The chunk cache contains all the chunks we've preloaded so far.
+// If they're still pending they're a thenable. This map also exists
+// in Turbopack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = globalThis.__next_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+
+  for (let i = 0; i < chunks.length; i++) {
+    const chunkFilename = chunks[i];
+    const entry = chunkCache.get(chunkFilename);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkFilename);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkFilename, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkFilename, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = globalThis.__next_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+function loadChunk(filename) {
+  return globalThis.__next_chunk_load__(filename);
+}
+
+// The server acts as a Client of itself when resolving Server References.
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const RESOLVED_MODEL = 'resolved_model';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function bindArgs$1(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference$1(response, id, bound, parentChunk, parentObject, key) {
+  const serverReference = resolveServerReference(response._bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+  let promise;
+
+  if (bound) {
+    promise = Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs$1(requireModule(serverReference), args);
+    });
+  } else {
+    if (preloadPromise) {
+      promise = Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+    } else {
+      // Synchronously available
+      return requireModule(serverReference);
+    }
+  }
+
+  promise.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk)); // We need a placeholder value that will be replaced later.
+
+  return null;
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+
+  try {
+    const value = JSON.parse(chunk.value, chunk._response._fromJSON);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    const prefix = response._prefix;
+    const key = prefix + id; // Check if we have this field in the backing store already.
+
+    const backingEntry = response._formData.get(key);
+
+    if (backingEntry != null) {
+      // We assume that this is a string entry for now.
+      chunk = createResolvedModelChunk(response, backingEntry);
+    } else {
+      // We're still waiting on this entry to stream in.
+      chunk = createPendingChunk(response);
+    }
+
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+    blocked.deps++;
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  if (chunk.status === RESOLVED_MODEL) {
+    initializeModelChunk(chunk);
+  }
+
+  if (chunk.status !== INITIALIZED) {
+    // We know that this is emitted earlier so otherwise it's an error.
+    throw chunk.reason;
+  }
+
+  return chunk.value;
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16); // TODO: Just encode this in the reference inline instead of as a model.
+
+          const metaData = getOutlinedModel(response, id);
+          return loadServerReference$1(response, metaData.id, metaData.bound, initializingChunk, parentObject, key);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'K':
+        {
+          // FormData
+          const stringId = value.slice(2);
+          const formPrefix = response._prefix + stringId + '_';
+          const data = new FormData();
+          const backingFormData = response._formData; // We assume that the reference to FormData always comes after each
+          // entry that it references so we can assume they all exist in the
+          // backing store already.
+          // $FlowFixMe[prop-missing] FormData has forEach on it.
+
+          backingFormData.forEach((entry, entryKey) => {
+            if (entryKey.startsWith(formPrefix)) {
+              data.append(entryKey.slice(formPrefix.length), entry);
+            }
+          });
+          return data;
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function createResponse(bundlerConfig, formFieldPrefix) {
+  let backingFormData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new FormData();
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _prefix: formFieldPrefix,
+    _formData: backingFormData,
+    _chunks: chunks,
+    _fromJSON: function (key, value) {
+      if (typeof value === 'string') {
+        // We can't use .bind here because we need the "this" value.
+        return parseModelString(response, this, key, value);
+      }
+
+      return value;
+    }
+  };
+  return response;
+}
+function resolveField(response, key, value) {
+  // Add this field to the backing store.
+  response._formData.append(key, value);
+
+  const prefix = response._prefix;
+
+  if (key.startsWith(prefix)) {
+    const chunks = response._chunks;
+    const id = +key.slice(prefix.length);
+    const chunk = chunks.get(id);
+
+    if (chunk) {
+      // We were waiting on this key so now we can resolve it.
+      resolveModelChunk(chunk, value);
+    }
+  }
+}
+function resolveFileInfo(response, key, filename, mime) {
+  return {
+    chunks: [],
+    filename,
+    mime
+  };
+}
+function resolveFileChunk(response, handle, chunk) {
+  handle.chunks.push(chunk);
+}
+function resolveFileComplete(response, key, handle) {
+  // Add this file to the backing store.
+  // Node.js doesn't expose a global File constructor so we need to use
+  // the append() form that takes the file name as the third argument,
+  // to create a File object.
+  const blob = new Blob(handle.chunks, {
+    type: handle.mime
+  });
+
+  response._formData.append(key, blob, handle.filename);
+}
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function bindArgs(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference(bundlerConfig, id, bound) {
+  const serverReference = resolveServerReference(bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+
+  if (bound) {
+    return Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs(requireModule(serverReference), args);
+    });
+  } else if (preloadPromise) {
+    return Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+  } else {
+    // Synchronously available
+    return Promise.resolve(requireModule(serverReference));
+  }
+}
+
+function decodeBoundActionMetaData(body, serverManifest, formFieldPrefix) {
+  // The data for this reference is encoded in multiple fields under this prefix.
+  const actionResponse = createResponse(serverManifest, formFieldPrefix, body);
+  close(actionResponse);
+  const refPromise = getRoot(actionResponse); // Force it to initialize
+  // $FlowFixMe
+
+  refPromise.then(() => {});
+
+  if (refPromise.status !== 'fulfilled') {
+    // $FlowFixMe
+    throw refPromise.reason;
+  }
+
+  return refPromise.value;
+}
+
+function decodeAction(body, serverManifest) {
+  // We're going to create a new formData object that holds all the fields except
+  // the implementation details of the action data.
+  const formData = new FormData();
+  let action = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (!key.startsWith('$ACTION_')) {
+      formData.append(key, value);
+      return;
+    } // Later actions may override earlier actions if a button is used to override the default
+    // form action.
+
+
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      const metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+      action = loadServerReference(serverManifest, metaData.id, metaData.bound);
+      return;
+    }
+
+    if (key.startsWith('$ACTION_ID_')) {
+      const id = key.slice(11);
+      action = loadServerReference(serverManifest, id, null);
+      return;
+    }
+  });
+
+  if (action === null) {
+    return null;
+  } // Return the action with the remaining FormData bound to the first argument.
+
+
+  return action.then(fn => fn.bind(null, formData));
+}
+
+function createDrainHandler(destination, request) {
+  return () => startFlowing(request, destination);
+}
+
+function renderToPipeableStream(model, turbopackMap, options) {
+  const request = createRequest(model, turbopackMap, options ? options.onError : undefined, options ? options.context : undefined, options ? options.identifierPrefix : undefined, options ? options.onPostpone : undefined);
+  let hasStartedFlowing = false;
+  startWork(request);
+  return {
+    pipe(destination) {
+      if (hasStartedFlowing) {
+        throw new Error('React currently only supports piping to one writable stream.');
+      }
+
+      hasStartedFlowing = true;
+      startFlowing(request, destination);
+      destination.on('drain', createDrainHandler(destination, request));
+      return destination;
+    },
+
+    abort(reason) {
+      abort(request, reason);
+    }
+
+  };
+}
+
+function decodeReplyFromBusboy(busboyStream, turbopackMap) {
+  const response = createResponse(turbopackMap, '');
+  let pendingFiles = 0;
+  const queuedFields = [];
+  busboyStream.on('field', (name, value) => {
+    if (pendingFiles > 0) {
+      // Because the 'end' event fires two microtasks after the next 'field'
+      // we would resolve files and fields out of order. To handle this properly
+      // we queue any fields we receive until the previous file is done.
+      queuedFields.push(name, value);
+    } else {
+      resolveField(response, name, value);
+    }
+  });
+  busboyStream.on('file', (name, value, _ref) => {
+    let filename = _ref.filename,
+        encoding = _ref.encoding,
+        mimeType = _ref.mimeType;
+
+    if (encoding.toLowerCase() === 'base64') {
+      throw new Error("React doesn't accept base64 encoded file uploads because we don't expect " + "form data passed from a browser to ever encode data that way. If that's " + 'the wrong assumption, we can easily fix it.');
+    }
+
+    pendingFiles++;
+    const file = resolveFileInfo(response, name, filename, mimeType);
+    value.on('data', chunk => {
+      resolveFileChunk(response, file, chunk);
+    });
+    value.on('end', () => {
+      resolveFileComplete(response, name, file);
+      pendingFiles--;
+
+      if (pendingFiles === 0) {
+        // Release any queued fields
+        for (let i = 0; i < queuedFields.length; i += 2) {
+          resolveField(response, queuedFields[i], queuedFields[i + 1]);
+        }
+
+        queuedFields.length = 0;
+      }
+    });
+  });
+  busboyStream.on('finish', () => {
+    close(response);
+  });
+  busboyStream.on('error', err => {
+    reportGlobalError(response, // $FlowFixMe[incompatible-call] types Error and mixed are incompatible
+    err);
+  });
+  return getRoot(response);
+}
+
+function decodeReply(body, turbopackMap) {
+  if (typeof body === 'string') {
+    const form = new FormData();
+    form.append('0', body);
+    body = form;
+  }
+
+  const response = createResponse(turbopackMap, '', body);
+  const root = getRoot(response);
+  close(response);
+  return root;
+}
+
+exports.createClientModuleProxy = createClientModuleProxy;
+exports.decodeAction = decodeAction;
+exports.decodeReply = decodeReply;
+exports.decodeReplyFromBusboy = decodeReplyFromBusboy;
+exports.registerClientReference = registerClientReference;
+exports.registerServerReference = registerServerReference;
+exports.renderToPipeableStream = renderToPipeableStream;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.node.production.min.js b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.node.production.min.js
index 2325ec39b6382..1c49cf57cbe84 100644
--- a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.node.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.node.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-turbopack-server.node.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-turbopack-server.node.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var ba=require("util");require("crypto");var ca=require("async_hooks"),da=require("react"),ea=require("react-dom"),l=null,m=0,p=!0;function q(a,b){a=a.write(b);p=p&&a}
 function r(a,b){if("string"===typeof b){if(0!==b.length)if(2048<3*b.length)0<m&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=0),q(a,fa.encode(b));else{var d=l;0<m&&(d=l.subarray(m));d=fa.encodeInto(b,d);var c=d.read;m+=d.written;c<b.length&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=fa.encodeInto(b.slice(c),l).written);2048===m&&(q(a,l),l=new Uint8Array(2048),m=0)}}else 0!==b.byteLength&&(2048<b.byteLength?(0<m&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=0),q(a,b)):(d=l.length-m,d<b.byteLength&&
 (0===d?q(a,l):(l.set(b.subarray(0,d),m),m+=d,q(a,l),b=b.subarray(d)),l=new Uint8Array(2048),m=0),l.set(b,m),m+=b.byteLength,2048===m&&(q(a,l),l=new Uint8Array(2048),m=0)));return p}var fa=new ba.TextEncoder,t=Symbol.for("react.client.reference"),v=Symbol.for("react.server.reference");function w(a,b,d){return Object.defineProperties(a,{$$typeof:{value:t},$$id:{value:b},$$async:{value:d}})}var ha=Function.prototype.bind,ia=Array.prototype.slice;
@@ -77,3 +77,5 @@ exports.decodeAction=function(a,b){var d=new FormData,c=null;a.forEach(function(
 exports.decodeReplyFromBusboy=function(a,b){var d=Nb(b,""),c=0,e=[];a.on("field",function(f,g){0<c?e.push(f,g):Ob(d,f,g)});a.on("file",function(f,g,k){var h=k.filename,n=k.mimeType;if("base64"===k.encoding.toLowerCase())throw Error("React doesn't accept base64 encoded file uploads because we don't expect form data passed from a browser to ever encode data that way. If that's the wrong assumption, we can easily fix it.");c++;var z=[];g.on("data",function(u){z.push(u)});g.on("end",function(){var u=
 new Blob(z,{type:n});d._formData.append(f,u,h);c--;if(0===c){for(u=0;u<e.length;u+=2)Ob(d,e[u],e[u+1]);e.length=0}})});a.on("finish",function(){Pb(d)});a.on("error",function(f){Hb(d,f)});return Z(d,0)};exports.registerClientReference=function(a,b,d){return w(a,b+"#"+d,!1)};exports.registerServerReference=function(a,b,d){return Object.defineProperties(a,{$$typeof:{value:v},$$id:{value:null===d?b:b+"#"+d},$$bound:{value:null},bind:{value:ja}})};
 exports.renderToPipeableStream=function(a,b,d){var c=gb(a,b,d?d.onError:void 0,d?d.context:void 0,d?d.identifierPrefix:void 0,d?d.onPostpone:void 0),e=!1;sb(c);return{pipe:function(f){if(e)throw Error("React currently only supports piping to one writable stream.");e=!0;tb(c,f);f.on("drain",Sb(f,c));return f},abort:function(f){ub(c,f)}}};
+
+//# sourceMappingURL=react-server-dom-turbopack-server.node.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.node.unbundled.production.js b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.node.unbundled.production.js
new file mode 100644
index 0000000000000..778d894b8782e
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.node.unbundled.production.js
@@ -0,0 +1,3198 @@
+/**
+ * @license React
+ * react-server-dom-turbopack-server.node.unbundled.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var util = require('util');
+require('crypto');
+var async_hooks = require('async_hooks');
+var React = require('react');
+var ReactDOM = require('react-dom');
+
+// -----------------------------------------------------------------------------
+const enablePostpone = false;
+
+function scheduleWork(callback) {
+  setImmediate(callback);
+}
+function flushBuffered(destination) {
+  // If we don't have any more data to send right now.
+  // Flush whatever is in the buffer to the wire.
+  if (typeof destination.flush === 'function') {
+    // By convention the Zlib streams provide a flush function for this purpose.
+    // For Express, compression middleware adds this method.
+    destination.flush();
+  }
+}
+const VIEW_SIZE = 2048;
+let currentView = null;
+let writtenBytes = 0;
+let destinationHasCapacity = true;
+function beginWriting(destination) {
+  currentView = new Uint8Array(VIEW_SIZE);
+  writtenBytes = 0;
+  destinationHasCapacity = true;
+}
+
+function writeStringChunk(destination, stringChunk) {
+  if (stringChunk.length === 0) {
+    return;
+  } // maximum possible view needed to encode entire string
+
+
+  if (stringChunk.length * 3 > VIEW_SIZE) {
+    if (writtenBytes > 0) {
+      writeToDestination(destination, currentView.subarray(0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    writeToDestination(destination, textEncoder.encode(stringChunk));
+    return;
+  }
+
+  let target = currentView;
+
+  if (writtenBytes > 0) {
+    target = currentView.subarray(writtenBytes);
+  }
+
+  const _textEncoder$encodeIn = textEncoder.encodeInto(stringChunk, target),
+        read = _textEncoder$encodeIn.read,
+        written = _textEncoder$encodeIn.written;
+
+  writtenBytes += written;
+
+  if (read < stringChunk.length) {
+    writeToDestination(destination, currentView.subarray(0, writtenBytes));
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = textEncoder.encodeInto(stringChunk.slice(read), currentView).written;
+  }
+
+  if (writtenBytes === VIEW_SIZE) {
+    writeToDestination(destination, currentView);
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+}
+
+function writeViewChunk(destination, chunk) {
+  if (chunk.byteLength === 0) {
+    return;
+  }
+
+  if (chunk.byteLength > VIEW_SIZE) {
+    // one that is cached by the streaming renderer. We will enqueu
+    // it directly and expect it is not re-used
+
+
+    if (writtenBytes > 0) {
+      writeToDestination(destination, currentView.subarray(0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    writeToDestination(destination, chunk);
+    return;
+  }
+
+  let bytesToWrite = chunk;
+  const allowableBytes = currentView.length - writtenBytes;
+
+  if (allowableBytes < bytesToWrite.byteLength) {
+    // this chunk would overflow the current view. We enqueue a full view
+    // and start a new view with the remaining chunk
+    if (allowableBytes === 0) {
+      // the current view is already full, send it
+      writeToDestination(destination, currentView);
+    } else {
+      // fill up the current view and apply the remaining chunk bytes
+      // to a new view.
+      currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes);
+      writtenBytes += allowableBytes;
+      writeToDestination(destination, currentView);
+      bytesToWrite = bytesToWrite.subarray(allowableBytes);
+    }
+
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+
+  currentView.set(bytesToWrite, writtenBytes);
+  writtenBytes += bytesToWrite.byteLength;
+
+  if (writtenBytes === VIEW_SIZE) {
+    writeToDestination(destination, currentView);
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+}
+
+function writeChunk(destination, chunk) {
+  if (typeof chunk === 'string') {
+    writeStringChunk(destination, chunk);
+  } else {
+    writeViewChunk(destination, chunk);
+  }
+}
+
+function writeToDestination(destination, view) {
+  const currentHasCapacity = destination.write(view);
+  destinationHasCapacity = destinationHasCapacity && currentHasCapacity;
+}
+
+function writeChunkAndReturn(destination, chunk) {
+  writeChunk(destination, chunk);
+  return destinationHasCapacity;
+}
+function completeWriting(destination) {
+  if (currentView && writtenBytes > 0) {
+    destination.write(currentView.subarray(0, writtenBytes));
+  }
+
+  currentView = null;
+  writtenBytes = 0;
+  destinationHasCapacity = true;
+}
+function close$1(destination) {
+  destination.end();
+}
+const textEncoder = new util.TextEncoder();
+function stringToChunk(content) {
+  return content;
+}
+function byteLengthOfChunk(chunk) {
+  return typeof chunk === 'string' ? Buffer.byteLength(chunk, 'utf8') : chunk.byteLength;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+  destination.destroy(error);
+}
+
+// eslint-disable-next-line no-unused-vars
+const CLIENT_REFERENCE_TAG = Symbol.for('react.client.reference');
+const SERVER_REFERENCE_TAG = Symbol.for('react.server.reference');
+function isClientReference(reference) {
+  return reference.$$typeof === CLIENT_REFERENCE_TAG;
+}
+function isServerReference(reference) {
+  return reference.$$typeof === SERVER_REFERENCE_TAG;
+}
+function registerClientReference(proxyImplementation, id, exportName) {
+  return registerClientReferenceImpl(proxyImplementation, id + '#' + exportName, false);
+}
+
+function registerClientReferenceImpl(proxyImplementation, id, async) {
+  return Object.defineProperties(proxyImplementation, {
+    $$typeof: {
+      value: CLIENT_REFERENCE_TAG
+    },
+    $$id: {
+      value: id
+    },
+    $$async: {
+      value: async
+    }
+  });
+} // $FlowFixMe[method-unbinding]
+
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+
+  if (this.$$typeof === SERVER_REFERENCE_TAG) {
+    const args = ArraySlice.call(arguments, 1);
+    newFn.$$typeof = SERVER_REFERENCE_TAG;
+    newFn.$$id = this.$$id;
+    newFn.$$bound = this.$$bound ? this.$$bound.concat(args) : args;
+  }
+
+  return newFn;
+}
+
+function registerServerReference(reference, id, exportName) {
+  return Object.defineProperties(reference, {
+    $$typeof: {
+      value: SERVER_REFERENCE_TAG
+    },
+    $$id: {
+      value: exportName === null ? id : id + '#' + exportName
+    },
+    $$bound: {
+      value: null
+    },
+    bind: {
+      value: bind
+    }
+  });
+}
+const PROMISE_PROTOTYPE = Promise.prototype;
+const deepProxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        // These names are a little too common. We should probably have a way to
+        // have the Flight runtime extract the inner target instead.
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+
+      case 'displayName':
+        return undefined;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case 'Provider':
+        throw new Error("Cannot render a Client Context Provider on the Server. " + "Instead, you can export a Client Component wrapper " + "that itself renders a Client Context Provider.");
+    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+    const expression = String(target.name) + '.' + String(name);
+    throw new Error("Cannot access " + expression + " on the server. " + 'You cannot dot into a client module from a server component. ' + 'You can only pass the imported name through.');
+  },
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+const proxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case '__esModule':
+        // Something is conditionally checking which export to use. We'll pretend to be
+        // an ESM compat module but then we'll check again on the client.
+        const moduleId = target.$$id;
+        target.default = registerClientReferenceImpl(function () {
+          throw new Error("Attempted to call the default export of " + moduleId + " from the server " + "but it's on the client. It's not possible to invoke a client function from " + "the server, it can only be rendered as a Component or passed to props of a " + "Client Component.");
+        }, target.$$id + '#', target.$$async);
+        return true;
+
+      case 'then':
+        if (target.then) {
+          // Use a cached value
+          return target.then;
+        }
+
+        if (!target.$$async) {
+          // If this module is expected to return a Promise (such as an AsyncModule) then
+          // we should resolve that with a client reference that unwraps the Promise on
+          // the client.
+          const clientReference = registerClientReferenceImpl({}, target.$$id, true);
+          const proxy = new Proxy(clientReference, proxyHandlers); // Treat this as a resolved Promise for React's use()
+
+          target.status = 'fulfilled';
+          target.value = proxy;
+          const then = target.then = registerClientReferenceImpl(function then(resolve, reject) {
+            // Expose to React.
+            return Promise.resolve(resolve(proxy));
+          }, // If this is not used as a Promise but is treated as a reference to a `.then`
+          // export then we should treat it as a reference to that name.
+          target.$$id + '#then', false);
+          return then;
+        } else {
+          // Since typeof .then === 'function' is a feature test we'd continue recursing
+          // indefinitely if we return a function. Instead, we return an object reference
+          // if we check further.
+          return undefined;
+        }
+
+    }
+
+    let cachedReference = target[name];
+
+    if (!cachedReference) {
+      const reference = registerClientReferenceImpl(function () {
+        throw new Error( // eslint-disable-next-line react-internal/safe-string-coercion
+        "Attempted to call " + String(name) + "() from the server but " + String(name) + " is on the client. " + "It's not possible to invoke a client function from the server, it can " + "only be rendered as a Component or passed to props of a Client Component.");
+      }, target.$$id + '#' + name, target.$$async);
+      Object.defineProperty(reference, 'name', {
+        value: name
+      });
+      cachedReference = target[name] = new Proxy(reference, deepProxyHandlers);
+    }
+
+    return cachedReference;
+  },
+
+  getPrototypeOf(target) {
+    // Pretend to be a Promise in case anyone asks.
+    return PROMISE_PROTOTYPE;
+  },
+
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+function createClientModuleProxy(moduleId) {
+  const clientReference = registerClientReferenceImpl({}, // Represents the whole Module object instead of a particular import.
+  moduleId, false);
+  return new Proxy(clientReference, proxyHandlers);
+}
+
+function getClientReferenceKey(reference) {
+  return reference.$$async ? reference.$$id + '#async' : reference.$$id;
+}
+function resolveClientReferenceMetadata(config, clientReference) {
+  const modulePath = clientReference.$$id;
+  let name = '';
+  let resolvedModuleData = config[modulePath];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = modulePath.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = modulePath.slice(idx + 1);
+      resolvedModuleData = config[modulePath.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + modulePath + '" in the React Client Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  }
+
+  if (clientReference.$$async === true) {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1];
+  } else {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+  }
+}
+function getServerReferenceId(config, serverReference) {
+  return serverReference.$$id;
+}
+function getServerReferenceBoundArguments(config, serverReference) {
+  return serverReference.$$bound;
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMFlightServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule: preloadModule$1,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+
+function prefetchDNS(href) {
+  {
+    if (typeof href === 'string' && href) {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'D|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        emitHint(request, 'D', href);
+      }
+    }
+  }
+}
+
+function preconnect(href, crossOrigin) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = "C|" + (crossOrigin == null ? 'null' : crossOrigin) + "|" + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+
+        if (typeof crossOrigin === 'string') {
+          emitHint(request, 'C', [href, crossOrigin]);
+        } else {
+          emitHint(request, 'C', href);
+        }
+      }
+    }
+  }
+}
+
+function preload(href, as, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        let key = 'L';
+
+        if (as === 'image' && options) {
+          key += getImagePreloadKey(href, options.imageSrcSet, options.imageSizes);
+        } else {
+          key += "[" + as + "]" + href;
+        }
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          emitHint(request, 'L', [href, as, trimmed]);
+        } else {
+          emitHint(request, 'L', [href, as]);
+        }
+      }
+    }
+  }
+}
+
+function preloadModule$1(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'm|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'm', [href, trimmed]);
+        } else {
+          return emitHint(request, 'm', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'S|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'S', [href, typeof precedence === 'string' ? precedence : 0, trimmed]);
+        } else if (typeof precedence === 'string') {
+          return emitHint(request, 'S', [href, precedence]);
+        } else {
+          return emitHint(request, 'S', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'X|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'X', [href, trimmed]);
+        } else {
+          return emitHint(request, 'X', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitModuleScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'M|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'M', [href, trimmed]);
+        } else {
+          return emitHint(request, 'M', href);
+        }
+      }
+    }
+  }
+} // Flight normally encodes undefined as a special character however for directive option
+// arguments we don't want to send unnecessary keys and bloat the payload so we create a
+// trimmed object which omits any keys with null or undefined values.
+// This is only typesafe because these option objects have entirely optional fields where
+// null and undefined represent the same thing as no property.
+
+
+function trimOptions(options) {
+  if (options == null) return null;
+  let hasProperties = false;
+  const trimmed = {};
+
+  for (const key in options) {
+    if (options[key] != null) {
+      hasProperties = true;
+      trimmed[key] = options[key];
+    }
+  }
+
+  return hasProperties ? trimmed : null;
+}
+
+function getImagePreloadKey(href, imageSrcSet, imageSizes) {
+  let uniquePart = '';
+
+  if (typeof imageSrcSet === 'string' && imageSrcSet !== '') {
+    uniquePart += '[' + imageSrcSet + ']';
+
+    if (typeof imageSizes === 'string') {
+      uniquePart += '[' + imageSizes + ']';
+    }
+  } else {
+    uniquePart += '[][]' + href;
+  }
+
+  return "[image]" + uniquePart;
+}
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMFlightServerDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+// small, smaller than how we encode undefined, and is unambiguous. We could use
+// a different tuple structure to encode this instead but this makes the runtime
+// cost cheaper by eliminating a type checks in more positions.
+// prettier-ignore
+
+function createHints() {
+  return new Set();
+}
+
+const requestStorage = new async_hooks.AsyncLocalStorage();
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext); // On the way back, we push the new ones that weren't common.
+
+      pushNode(next);
+    }
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFizzWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop, noop);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+let currentRequest$1 = null;
+let thenableIndexCounter = 0;
+let thenableState = null;
+function prepareToUseHooksForRequest(request) {
+  currentRequest$1 = request;
+}
+function resetHooksForRequest() {
+  currentRequest$1 = null;
+}
+function prepareToUseHooksForComponent(prevThenableState) {
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+const HooksDispatcher = {
+  useMemo(nextCreate) {
+    return nextCreate();
+  },
+
+  useCallback(callback) {
+    return callback;
+  },
+
+  useDebugValue() {},
+
+  useDeferredValue: unsupportedHook,
+  useTransition: unsupportedHook,
+  readContext,
+  useContext: readContext,
+  useReducer: unsupportedHook,
+  useRef: unsupportedHook,
+  useState: unsupportedHook,
+  useInsertionEffect: unsupportedHook,
+  useLayoutEffect: unsupportedHook,
+  useImperativeHandle: unsupportedHook,
+  useEffect: unsupportedHook,
+  useId,
+  useSyncExternalStore: unsupportedHook,
+
+  useCacheRefresh() {
+    return unsupportedRefresh;
+  },
+
+  useMemoCache(size) {
+    const data = new Array(size);
+
+    for (let i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL;
+    }
+
+    return data;
+  },
+
+  use
+};
+
+function unsupportedHook() {
+  throw new Error('This Hook is not supported in Server Components.');
+}
+
+function unsupportedRefresh() {
+  throw new Error('Refreshing the cache is not supported in Server Components.');
+}
+
+function useId() {
+  if (currentRequest$1 === null) {
+    throw new Error('useId can only be used while React is rendering');
+  }
+
+  const id = currentRequest$1.identifierCount++; // use 'S' for Flight components to distinguish from 'R' and 'r' in Fizz/Client
+
+  return ':' + currentRequest$1.identifierPrefix + 'S' + id.toString(32) + ':';
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object' || typeof usable === 'function') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable; // Track the position of the thenable within this fiber.
+
+      const index = thenableIndexCounter;
+      thenableIndexCounter += 1;
+
+      if (thenableState === null) {
+        thenableState = createThenableState();
+      }
+
+      return trackUsedThenable(thenableState, thenable, index);
+    } else if (usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  }
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function createSignal() {
+  return new AbortController().signal;
+}
+
+function resolveCache() {
+  const request = resolveRequest();
+
+  if (request) {
+    return getCache(request);
+  }
+
+  return new Map();
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal() {
+    const cache = resolveCache();
+    let entry = cache.get(createSignal);
+
+    if (entry === undefined) {
+      entry = createSignal();
+      cache.set(createSignal, entry);
+    }
+
+    return entry;
+  },
+
+  getCacheForType(resourceType) {
+    const cache = resolveCache();
+    let entry = cache.get(resourceType);
+
+    if (entry === undefined) {
+      entry = resourceType(); // TODO: Warn if undefined?
+
+      cache.set(resourceType, entry);
+    }
+
+    return entry;
+  }
+
+};
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+function objectName(object) {
+  // $FlowFixMe[method-unbinding]
+  const name = Object.prototype.toString.call(object);
+  return name.replace(/^\[object (.*)\]$/, function (m, p0) {
+    return p0;
+  });
+}
+
+function describeKeyForErrorMessage(key) {
+  const encodedKey = JSON.stringify(key);
+  return '"' + key + '"' === encodedKey ? key : encodedKey;
+}
+
+function describeValueForErrorMessage(value) {
+  switch (typeof value) {
+    case 'string':
+      {
+        return JSON.stringify(value.length <= 10 ? value : value.slice(0, 10) + '...');
+      }
+
+    case 'object':
+      {
+        if (isArray(value)) {
+          return '[...]';
+        }
+
+        const name = objectName(value);
+
+        if (name === 'Object') {
+          return '{...}';
+        }
+
+        return name;
+      }
+
+    case 'function':
+      return 'function';
+
+    default:
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      return String(value);
+  }
+}
+
+function describeElementType(type) {
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        return describeElementType(type.render);
+
+      case REACT_MEMO_TYPE:
+        return describeElementType(type.type);
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            // Lazy may contain any component type so we recursively resolve it.
+            return describeElementType(init(payload));
+          } catch (x) {}
+        }
+    }
+  }
+
+  return '';
+}
+
+function describeObjectForErrorMessage(objectOrArray, expandedName) {
+  const objKind = objectName(objectOrArray);
+
+  if (objKind !== 'Object' && objKind !== 'Array') {
+    return objKind;
+  }
+
+  let str = '';
+  let start = -1;
+  let length = 0;
+
+  if (isArray(objectOrArray)) {
+    {
+      // Print Array
+      str = '[';
+      const array = objectOrArray;
+
+      for (let i = 0; i < array.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const value = array[i];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if ('' + i === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += ']';
+    }
+  } else {
+    if (objectOrArray.$$typeof === REACT_ELEMENT_TYPE) {
+      str = '<' + describeElementType(objectOrArray.type) + '/>';
+    } else {
+      // Print Object
+      str = '{';
+      const object = objectOrArray;
+      const names = Object.keys(object);
+
+      for (let i = 0; i < names.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const name = names[i];
+        str += describeKeyForErrorMessage(name) + ': ';
+        const value = object[name];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if (name === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += '}';
+    }
+  }
+
+  if (expandedName === undefined) {
+    return str;
+  }
+
+  if (start > -1 && length > 0) {
+    const highlight = ' '.repeat(start) + '^'.repeat(length);
+    return '\n  ' + str + '\n  ' + highlight;
+  }
+
+  return '\n  ' + str;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactSharedServerInternals = // $FlowFixMe: It's defined in the one we resolve to.
+React.__SECRET_SERVER_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+if (!ReactSharedServerInternals) {
+  throw new Error('The "react" package in this environment is not configured correctly. ' + 'The "react-server" condition must be enabled in any environment that ' + 'runs React Server Components.');
+}
+
+const ObjectPrototype = Object.prototype;
+const stringify = JSON.stringify; // Serializable values
+// Thenable<ReactClientValue>
+
+const PENDING$1 = 0;
+const COMPLETED = 1;
+const ABORTED = 3;
+const ERRORED$1 = 4;
+const ReactCurrentCache = ReactSharedServerInternals.ReactCurrentCache;
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+}
+
+function defaultPostponeHandler(reason) {// Noop
+}
+
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2;
+function createRequest(model, bundlerConfig, onError, context, identifierPrefix, onPostpone) {
+  if (ReactCurrentCache.current !== null && ReactCurrentCache.current !== DefaultCacheDispatcher) {
+    throw new Error('Currently React only supports one RSC renderer at a time.');
+  }
+
+  prepareHostDispatcher();
+  ReactCurrentCache.current = DefaultCacheDispatcher;
+  const abortSet = new Set();
+  const pingedTasks = [];
+  const cleanupQueue = [];
+
+  const hints = createHints();
+  const request = {
+    status: OPEN,
+    flushScheduled: false,
+    fatalError: null,
+    destination: null,
+    bundlerConfig,
+    cache: new Map(),
+    nextChunkId: 0,
+    pendingChunks: 0,
+    hints,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    completedImportChunks: [],
+    completedHintChunks: [],
+    completedRegularChunks: [],
+    completedErrorChunks: [],
+    writtenSymbols: new Map(),
+    writtenClientReferences: new Map(),
+    writtenServerReferences: new Map(),
+    writtenProviders: new Map(),
+    writtenObjects: new WeakMap(),
+    identifierPrefix: identifierPrefix || '',
+    identifierCount: 1,
+    taintCleanupQueue: cleanupQueue,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? defaultPostponeHandler : onPostpone,
+    // $FlowFixMe[missing-this-annot]
+    toJSON: function (key, value) {
+      return resolveModelToJSON(request, this, key, value);
+    }
+  };
+  request.pendingChunks++;
+  const rootContext = createRootContext();
+  const rootTask = createTask(request, model, rootContext, abortSet);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  {
+    const store = requestStorage.getStore();
+    if (store) return store;
+  }
+
+  return null;
+}
+
+function createRootContext(reqContext) {
+  return importServerContexts();
+}
+
+function serializeThenable(request, thenable) {
+  request.pendingChunks++;
+  const newTask = createTask(request, null, getActiveContext(), request.abortableTasks);
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        // We have the resolved value, we can go ahead and schedule it for serialization.
+        newTask.model = thenable.value;
+        pingTask(request, newTask);
+        return newTask.id;
+      }
+
+    case 'rejected':
+      {
+        const x = thenable.reason;
+
+        {
+          const digest = logRecoverableError(request, x);
+          emitErrorChunk(request, newTask.id, digest);
+        }
+
+        return newTask.id;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  thenable.then(value => {
+    newTask.model = value;
+    pingTask(request, newTask);
+  }, reason => {
+    newTask.status = ERRORED$1;
+    request.abortableTasks.delete(newTask); // TODO: We should ideally do this inside performWork so it's scheduled
+
+    const digest = logRecoverableError(request, reason);
+    emitErrorChunk(request, newTask.id, digest);
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  });
+  return newTask.id;
+}
+
+function emitHint(request, code, model) {
+  emitHintChunk(request, code, model);
+  enqueueFlush(request);
+}
+function getHints(request) {
+  return request.hints;
+}
+function getCache(request) {
+  return request.cache;
+}
+
+function readThenable(thenable) {
+  if (thenable.status === 'fulfilled') {
+    return thenable.value;
+  } else if (thenable.status === 'rejected') {
+    throw thenable.reason;
+  }
+
+  throw thenable;
+}
+
+function createLazyWrapperAroundWakeable(wakeable) {
+  // This is a temporary fork of the `use` implementation until we accept
+  // promises everywhere.
+  const thenable = wakeable;
+
+  switch (thenable.status) {
+    case 'fulfilled':
+    case 'rejected':
+      break;
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: thenable,
+    _init: readThenable
+  };
+  return lazyType;
+}
+
+function attemptResolveElement(request, type, key, ref, props, prevThenableState) {
+  if (ref !== null && ref !== undefined) {
+    // When the ref moves to the regular props object this will implicitly
+    // throw for functions. We could probably relax it to a DEV warning for other
+    // cases.
+    throw new Error('Refs cannot be used in Server Components, nor passed to Client Components.');
+  }
+
+  if (typeof type === 'function') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    } // This is a server-side component.
+
+
+    prepareToUseHooksForComponent(prevThenableState);
+    const result = type(props);
+
+    if (typeof result === 'object' && result !== null && typeof result.then === 'function') {
+      // When the return value is in children position we can resolve it immediately,
+      // to its value without a wrapper if it's synchronously available.
+      const thenable = result;
+
+      if (thenable.status === 'fulfilled') {
+        return thenable.value;
+      } // TODO: Once we accept Promises as children on the client, we can just return
+      // the thenable here.
+
+
+      return createLazyWrapperAroundWakeable(result);
+    }
+
+    return result;
+  } else if (typeof type === 'string') {
+    // This is a host element. E.g. HTML.
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (typeof type === 'symbol') {
+    if (type === REACT_FRAGMENT_TYPE) {
+      // For key-less fragments, we add a small optimization to avoid serializing
+      // it as a wrapper.
+      // TODO: If a key is specified, we should propagate its key to any children.
+      // Same as if a Server Component has a key.
+      return props.children;
+    } // This might be a built-in React component. We'll let the client decide.
+    // Any built-in works as long as its props are serializable.
+
+
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (type != null && typeof type === 'object') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    }
+
+    switch (type.$$typeof) {
+      case REACT_LAZY_TYPE:
+        {
+          const payload = type._payload;
+          const init = type._init;
+          const wrappedType = init(payload);
+          return attemptResolveElement(request, wrappedType, key, ref, props, prevThenableState);
+        }
+
+      case REACT_FORWARD_REF_TYPE:
+        {
+          const render = type.render;
+          prepareToUseHooksForComponent(prevThenableState);
+          return render(props, undefined);
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          return attemptResolveElement(request, type.type, key, ref, props, prevThenableState);
+        }
+    }
+  }
+
+  throw new Error("Unsupported Server Component type: " + describeValueForErrorMessage(type));
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createTask(request, model, context, abortSet) {
+  const id = request.nextChunkId++;
+  const task = {
+    id,
+    status: PENDING$1,
+    model,
+    context,
+    ping: () => pingTask(request, task),
+    thenableState: null
+  };
+  abortSet.add(task);
+  return task;
+}
+
+function serializeByValueID(id) {
+  return '$' + id.toString(16);
+}
+
+function serializeLazyID(id) {
+  return '$L' + id.toString(16);
+}
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeRowHeader(tag, id) {
+  return id.toString(16) + ':' + tag;
+}
+
+function encodeReferenceChunk(request, id, reference) {
+  const json = stringify(reference);
+  const row = id.toString(16) + ':' + json + '\n';
+  return stringToChunk(row);
+}
+
+function serializeClientReference(request, parent, key, clientReference) {
+  const clientReferenceKey = getClientReferenceKey(clientReference);
+  const writtenClientReferences = request.writtenClientReferences;
+  const existingId = writtenClientReferences.get(clientReferenceKey);
+
+  if (existingId !== undefined) {
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(existingId);
+    }
+
+    return serializeByValueID(existingId);
+  }
+
+  try {
+    const clientReferenceMetadata = resolveClientReferenceMetadata(request.bundlerConfig, clientReference);
+    request.pendingChunks++;
+    const importId = request.nextChunkId++;
+    emitImportChunk(request, importId, clientReferenceMetadata);
+    writtenClientReferences.set(clientReferenceKey, importId);
+
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(importId);
+    }
+
+    return serializeByValueID(importId);
+  } catch (x) {
+    request.pendingChunks++;
+    const errorId = request.nextChunkId++;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, errorId, digest);
+    return serializeByValueID(errorId);
+  }
+}
+
+function outlineModel(request, value) {
+  request.pendingChunks++;
+  const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+  retryTask(request, newTask);
+  return newTask.id;
+}
+
+function serializeServerReference(request, parent, key, serverReference) {
+  const writtenServerReferences = request.writtenServerReferences;
+  const existingId = writtenServerReferences.get(serverReference);
+
+  if (existingId !== undefined) {
+    return serializeServerReferenceID(existingId);
+  }
+
+  const bound = getServerReferenceBoundArguments(request.bundlerConfig, serverReference);
+  const serverReferenceMetadata = {
+    id: getServerReferenceId(request.bundlerConfig, serverReference),
+    bound: bound ? Promise.resolve(bound) : null
+  };
+  const metadataId = outlineModel(request, serverReferenceMetadata);
+  writtenServerReferences.set(serverReference, metadataId);
+  return serializeServerReferenceID(metadataId);
+}
+
+function serializeLargeTextString(request, text) {
+  request.pendingChunks += 2;
+  const textId = request.nextChunkId++;
+  const textChunk = stringToChunk(text);
+  const binaryLength = byteLengthOfChunk(textChunk);
+  const row = textId.toString(16) + ':T' + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, textChunk);
+  return serializeByValueID(textId);
+}
+
+function serializeMap(request, map) {
+  const entries = Array.from(map);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i][0];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$Q' + id.toString(16);
+}
+
+function serializeSet(request, set) {
+  const entries = Array.from(set);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+let modelRoot = false;
+
+function resolveModelToJSON(request, parent, key, value) {
+
+
+  switch (value) {
+    case REACT_ELEMENT_TYPE:
+      return '$';
+  }
+
+
+  while (typeof value === 'object' && value !== null && (value.$$typeof === REACT_ELEMENT_TYPE || value.$$typeof === REACT_LAZY_TYPE)) {
+
+    try {
+      switch (value.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const writtenObjects = request.writtenObjects;
+            const existingId = writtenObjects.get(value);
+
+            if (existingId !== undefined) {
+              if (existingId === -1) {
+                // Seen but not yet outlined.
+                const newId = outlineModel(request, value);
+                return serializeByValueID(newId);
+              } else if (modelRoot === value) {
+                // This is the ID we're currently emitting so we need to write it
+                // once but if we discover it again, we refer to it by id.
+                modelRoot = null;
+              } else {
+                // We've already emitted this as an outlined object, so we can
+                // just refer to that by its existing ID.
+                return serializeByValueID(existingId);
+              }
+            } else {
+              // This is the first time we've seen this object. We may never see it again
+              // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+              writtenObjects.set(value, -1);
+            } // TODO: Concatenate keys of parents onto children.
+
+
+            const element = value; // Attempt to render the Server Component.
+
+            value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, null);
+            break;
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = value._payload;
+            const init = value._init;
+            value = init(payload);
+            break;
+          }
+      }
+    } catch (thrownValue) {
+      const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          // Something suspended, we'll need to create a new task and resolve it later.
+          request.pendingChunks++;
+          const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+          const ping = newTask.ping;
+          x.then(ping, ping);
+          newTask.thenableState = getThenableStateAfterSuspending();
+          return serializeLazyID(newTask.id);
+        }
+      } // Something errored. We'll still send everything we have up until this point.
+      // We'll replace this element with a lazy reference that throws on the client
+      // once it gets rendered.
+
+
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+      const digest = logRecoverableError(request, x);
+      emitErrorChunk(request, errorId, digest);
+      return serializeLazyID(errorId);
+    }
+  }
+
+  if (value === null) {
+    return null;
+  }
+
+  if (typeof value === 'object') {
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    const writtenObjects = request.writtenObjects;
+    const existingId = writtenObjects.get(value); // $FlowFixMe[method-unbinding]
+
+    if (typeof value.then === 'function') {
+      if (existingId !== undefined) {
+        if (modelRoot === value) {
+          // This is the ID we're currently emitting so we need to write it
+          // once but if we discover it again, we refer to it by id.
+          modelRoot = null;
+        } else {
+          // We've seen this promise before, so we can just refer to the same result.
+          return serializePromiseID(existingId);
+        }
+      } // We assume that any object with a .then property is a "Thenable" type,
+      // or a Promise type. Either of which can be represented by a Promise.
+
+
+      const promiseId = serializeThenable(request, value);
+      writtenObjects.set(value, promiseId);
+      return serializePromiseID(promiseId);
+    }
+
+    if (existingId !== undefined) {
+      if (existingId === -1) {
+        // Seen but not yet outlined.
+        const newId = outlineModel(request, value);
+        return serializeByValueID(newId);
+      } else if (modelRoot === value) {
+        // This is the ID we're currently emitting so we need to write it
+        // once but if we discover it again, we refer to it by id.
+        modelRoot = null;
+      } else {
+        // We've already emitted this as an outlined object, so we can
+        // just refer to that by its existing ID.
+        return serializeByValueID(existingId);
+      }
+    } else {
+      // This is the first time we've seen this object. We may never see it again
+      // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+      writtenObjects.set(value, -1);
+    }
+
+    if (isArray(value)) {
+      // $FlowFixMe[incompatible-return]
+      return value;
+    }
+
+    if (value instanceof Map) {
+      return serializeMap(request, value);
+    }
+
+    if (value instanceof Set) {
+      return serializeSet(request, value);
+    }
+
+    const iteratorFn = getIteratorFn(value);
+
+    if (iteratorFn) {
+      return Array.from(value);
+    } // Verify that this is a simple plain object.
+
+
+    const proto = getPrototypeOf(value);
+
+    if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+      throw new Error('Only plain objects, and a few built-ins, can be passed to Client Components ' + 'from Server Components. Classes or null prototypes are not supported.');
+    }
+
+
+    return value;
+  }
+
+  if (typeof value === 'string') {
+
+
+    if (value[value.length - 1] === 'Z') {
+      // Possibly a Date, whose toJSON automatically calls toISOString
+      // $FlowFixMe[incompatible-use]
+      const originalValue = parent[key];
+
+      if (originalValue instanceof Date) {
+        return serializeDateFromDateJSON(value);
+      }
+    }
+
+    if (value.length >= 1024) {
+      // For large strings, we encode them outside the JSON payload so that we
+      // don't have to double encode and double parse the strings. This can also
+      // be more compact in case the string has a lot of escaped characters.
+      return serializeLargeTextString(request, value);
+    }
+
+    return escapeStringValue(value);
+  }
+
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  if (typeof value === 'number') {
+    return serializeNumber(value);
+  }
+
+  if (typeof value === 'undefined') {
+    return serializeUndefined();
+  }
+
+  if (typeof value === 'function') {
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    if (isServerReference(value)) {
+      return serializeServerReference(request, parent, key, value);
+    }
+
+    if (/^on[A-Z]/.test(key)) {
+      throw new Error('Event handlers cannot be passed to Client Component props.' + describeObjectForErrorMessage(parent, key) + '\nIf you need interactivity, consider converting part of this to a Client Component.');
+    } else {
+      throw new Error('Functions cannot be passed directly to Client Components ' + 'unless you explicitly expose it by marking it with "use server".' + describeObjectForErrorMessage(parent, key));
+    }
+  }
+
+  if (typeof value === 'symbol') {
+    const writtenSymbols = request.writtenSymbols;
+    const existingId = writtenSymbols.get(value);
+
+    if (existingId !== undefined) {
+      return serializeByValueID(existingId);
+    } // $FlowFixMe[incompatible-type] `description` might be undefined
+
+
+    const name = value.description;
+
+    if (Symbol.for(name) !== value) {
+      throw new Error('Only global symbols received from Symbol.for(...) can be passed to Client Components. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+      value.description + ") cannot be found among global symbols.") + describeObjectForErrorMessage(parent, key));
+    }
+
+    request.pendingChunks++;
+    const symbolId = request.nextChunkId++;
+    emitSymbolChunk(request, symbolId, name);
+    writtenSymbols.set(value, symbolId);
+    return serializeByValueID(symbolId);
+  }
+
+  if (typeof value === 'bigint') {
+
+    return serializeBigInt(value);
+  }
+
+  throw new Error("Type " + typeof value + " is not supported in Client Component props." + describeObjectForErrorMessage(parent, key));
+}
+
+function logPostpone(request, reason) {
+  const onPostpone = request.onPostpone;
+  onPostpone(reason);
+}
+
+function logRecoverableError(request, error) {
+  const onError = request.onError;
+  const errorDigest = onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest || '';
+}
+
+function fatalError(request, error) {
+
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function emitPostponeChunk(request, id, postponeInstance) {
+  let row;
+
+  {
+    // No reason included in prod.
+    row = serializeRowHeader('P', id) + '\n';
+  }
+
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitErrorChunk(request, id, digest, error) {
+  let errorInfo;
+
+  {
+    errorInfo = {
+      digest
+    };
+  }
+
+  const row = serializeRowHeader('E', id) + stringify(errorInfo) + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitImportChunk(request, id, clientReferenceMetadata) {
+  // $FlowFixMe[incompatible-type] stringify can return null
+  const json = stringify(clientReferenceMetadata);
+  const row = serializeRowHeader('I', id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitHintChunk(request, code, model) {
+  const json = stringify(model);
+  const id = request.nextChunkId++;
+  const row = serializeRowHeader('H' + code, id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedHintChunks.push(processedChunk);
+}
+
+function emitSymbolChunk(request, id, name) {
+  const symbolReference = serializeSymbolReference(name);
+  const processedChunk = encodeReferenceChunk(request, id, symbolReference);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitModelChunk(request, id, model) {
+  // Track the root so we know that we have to emit this object even though it
+  // already has an ID. This is needed because we might see this object twice
+  // in the same toJSON if it is cyclic.
+  modelRoot = model; // $FlowFixMe[incompatible-type] stringify can return null
+
+  const json = stringify(model, request.toJSON);
+  const row = id.toString(16) + ':' + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function retryTask(request, task) {
+  if (task.status !== PENDING$1) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  }
+
+  switchContext(task.context);
+
+  try {
+    let value = task.model;
+
+    if (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+      request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+      const element = value; // When retrying a component, reuse the thenableState from the
+      // previous attempt.
+
+      const prevThenableState = task.thenableState; // Attempt to render the Server Component.
+      // Doing this here lets us reuse this same task if the next component
+      // also suspends.
+
+      task.model = value;
+      value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, prevThenableState); // Successfully finished this component. We're going to keep rendering
+      // using the same task, but we reset its thenable state before continuing.
+
+      task.thenableState = null; // Keep rendering and reuse the same task. This inner loop is separate
+      // from the render above because we don't need to reset the thenable state
+      // until the next time something suspends and retries.
+
+      while (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+        request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+        const nextElement = value;
+        task.model = value;
+        value = attemptResolveElement(request, nextElement.type, nextElement.key, nextElement.ref, nextElement.props, null);
+      }
+    } // Track that this object is outlined and has an id.
+
+
+    if (typeof value === 'object' && value !== null) {
+      request.writtenObjects.set(value, task.id);
+    }
+
+    emitModelChunk(request, task.id, value);
+    request.abortableTasks.delete(task);
+    task.status = COMPLETED;
+  } catch (thrownValue) {
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    request.abortableTasks.delete(task);
+    task.status = ERRORED$1;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, task.id, digest);
+  }
+}
+
+function performWork(request) {
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  const prevRequest = currentRequest;
+  currentRequest = request;
+  prepareToUseHooksForRequest(request);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    request.pingedTasks = [];
+
+    for (let i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    ReactCurrentDispatcher.current = prevDispatcher;
+    resetHooksForRequest();
+    currentRequest = prevRequest;
+  }
+}
+
+function abortTask(task, request, errorId) {
+  task.status = ABORTED; // Instead of emitting an error per task.id, we emit a model that only
+  // has a single value referencing the error.
+
+  const ref = serializeByValueID(errorId);
+  const processedChunk = encodeReferenceChunk(request, task.id, ref);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function flushCompletedChunks(request, destination) {
+  beginWriting();
+
+  try {
+    // We emit module chunks first in the stream so that
+    // they can be preloaded as early as possible.
+    const importsChunks = request.completedImportChunks;
+    let i = 0;
+
+    for (; i < importsChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = importsChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    importsChunks.splice(0, i); // Next comes hints.
+
+    const hintChunks = request.completedHintChunks;
+    i = 0;
+
+    for (; i < hintChunks.length; i++) {
+      const chunk = hintChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    hintChunks.splice(0, i); // Next comes model data.
+
+    const regularChunks = request.completedRegularChunks;
+    i = 0;
+
+    for (; i < regularChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = regularChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    regularChunks.splice(0, i); // Finally, errors are sent. The idea is that it's ok to delay
+    // any error messages and prioritize display of other parts of
+    // the page.
+
+    const errorChunks = request.completedErrorChunks;
+    i = 0;
+
+    for (; i < errorChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = errorChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    errorChunks.splice(0, i);
+  } finally {
+    request.flushScheduled = false;
+    completeWriting(destination);
+  }
+
+  flushBuffered(destination);
+
+  if (request.pendingChunks === 0) {
+
+    close$1(destination);
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  {
+    scheduleWork(() => requestStorage.run(request, performWork, request));
+  }
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    const destination = request.destination;
+    request.flushScheduled = true;
+    scheduleWork(() => flushCompletedChunks(request, destination));
+  }
+}
+
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedChunks(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      // We have tasks to abort. We'll emit one error row and then emit a reference
+      // to that row from every row that's still remaining.
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+
+      if (enablePostpone && typeof reason === 'object' && reason !== null && reason.$$typeof === REACT_POSTPONE_TYPE) ; else {
+        const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+        const digest = logRecoverableError(request, error);
+        emitErrorChunk(request, errorId, digest, error);
+      }
+
+      abortableTasks.forEach(task => abortTask(task, request, errorId));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function importServerContexts(contexts) {
+
+  return rootContextSnapshot;
+}
+
+function resolveServerReference(bundlerConfig, id) {
+  const idx = id.lastIndexOf('#');
+  const specifier = id.slice(0, idx);
+  const name = id.slice(idx + 1);
+  return {
+    specifier,
+    name
+  };
+}
+const asyncModuleCache = new Map();
+function preloadModule(metadata) {
+  const existingPromise = asyncModuleCache.get(metadata.specifier);
+
+  if (existingPromise) {
+    if (existingPromise.status === 'fulfilled') {
+      return null;
+    }
+
+    return existingPromise;
+  } else {
+    // $FlowFixMe[unsupported-syntax]
+    let modulePromise = import(metadata.specifier);
+
+    if (metadata.async) {
+      // If the module is async, it must have been a CJS module.
+      // CJS modules are accessed through the default export in
+      // Node.js so we have to get the default export to get the
+      // full module exports.
+      modulePromise = modulePromise.then(function (value) {
+        return value.default;
+      });
+    }
+
+    modulePromise.then(value => {
+      const fulfilledThenable = modulePromise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = modulePromise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    asyncModuleCache.set(metadata.specifier, modulePromise);
+    return modulePromise;
+  }
+}
+function requireModule(metadata) {
+  let moduleExports; // We assume that preloadModule has been called before, which
+  // should have added something to the module cache.
+
+  const promise = asyncModuleCache.get(metadata.specifier);
+
+  if (promise.status === 'fulfilled') {
+    moduleExports = promise.value;
+  } else {
+    throw promise.reason;
+  }
+
+  if (metadata.name === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata.name === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.default;
+  }
+
+  return moduleExports[metadata.name];
+}
+
+// The server acts as a Client of itself when resolving Server References.
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const RESOLVED_MODEL = 'resolved_model';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function bindArgs$1(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference$1(response, id, bound, parentChunk, parentObject, key) {
+  const serverReference = resolveServerReference(response._bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+  let promise;
+
+  if (bound) {
+    promise = Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs$1(requireModule(serverReference), args);
+    });
+  } else {
+    if (preloadPromise) {
+      promise = Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+    } else {
+      // Synchronously available
+      return requireModule(serverReference);
+    }
+  }
+
+  promise.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk)); // We need a placeholder value that will be replaced later.
+
+  return null;
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+
+  try {
+    const value = JSON.parse(chunk.value, chunk._response._fromJSON);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    const prefix = response._prefix;
+    const key = prefix + id; // Check if we have this field in the backing store already.
+
+    const backingEntry = response._formData.get(key);
+
+    if (backingEntry != null) {
+      // We assume that this is a string entry for now.
+      chunk = createResolvedModelChunk(response, backingEntry);
+    } else {
+      // We're still waiting on this entry to stream in.
+      chunk = createPendingChunk(response);
+    }
+
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+    blocked.deps++;
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  if (chunk.status === RESOLVED_MODEL) {
+    initializeModelChunk(chunk);
+  }
+
+  if (chunk.status !== INITIALIZED) {
+    // We know that this is emitted earlier so otherwise it's an error.
+    throw chunk.reason;
+  }
+
+  return chunk.value;
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16); // TODO: Just encode this in the reference inline instead of as a model.
+
+          const metaData = getOutlinedModel(response, id);
+          return loadServerReference$1(response, metaData.id, metaData.bound, initializingChunk, parentObject, key);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'K':
+        {
+          // FormData
+          const stringId = value.slice(2);
+          const formPrefix = response._prefix + stringId + '_';
+          const data = new FormData();
+          const backingFormData = response._formData; // We assume that the reference to FormData always comes after each
+          // entry that it references so we can assume they all exist in the
+          // backing store already.
+          // $FlowFixMe[prop-missing] FormData has forEach on it.
+
+          backingFormData.forEach((entry, entryKey) => {
+            if (entryKey.startsWith(formPrefix)) {
+              data.append(entryKey.slice(formPrefix.length), entry);
+            }
+          });
+          return data;
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function createResponse(bundlerConfig, formFieldPrefix) {
+  let backingFormData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new FormData();
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _prefix: formFieldPrefix,
+    _formData: backingFormData,
+    _chunks: chunks,
+    _fromJSON: function (key, value) {
+      if (typeof value === 'string') {
+        // We can't use .bind here because we need the "this" value.
+        return parseModelString(response, this, key, value);
+      }
+
+      return value;
+    }
+  };
+  return response;
+}
+function resolveField(response, key, value) {
+  // Add this field to the backing store.
+  response._formData.append(key, value);
+
+  const prefix = response._prefix;
+
+  if (key.startsWith(prefix)) {
+    const chunks = response._chunks;
+    const id = +key.slice(prefix.length);
+    const chunk = chunks.get(id);
+
+    if (chunk) {
+      // We were waiting on this key so now we can resolve it.
+      resolveModelChunk(chunk, value);
+    }
+  }
+}
+function resolveFileInfo(response, key, filename, mime) {
+  return {
+    chunks: [],
+    filename,
+    mime
+  };
+}
+function resolveFileChunk(response, handle, chunk) {
+  handle.chunks.push(chunk);
+}
+function resolveFileComplete(response, key, handle) {
+  // Add this file to the backing store.
+  // Node.js doesn't expose a global File constructor so we need to use
+  // the append() form that takes the file name as the third argument,
+  // to create a File object.
+  const blob = new Blob(handle.chunks, {
+    type: handle.mime
+  });
+
+  response._formData.append(key, blob, handle.filename);
+}
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function bindArgs(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference(bundlerConfig, id, bound) {
+  const serverReference = resolveServerReference(bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+
+  if (bound) {
+    return Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs(requireModule(serverReference), args);
+    });
+  } else if (preloadPromise) {
+    return Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+  } else {
+    // Synchronously available
+    return Promise.resolve(requireModule(serverReference));
+  }
+}
+
+function decodeBoundActionMetaData(body, serverManifest, formFieldPrefix) {
+  // The data for this reference is encoded in multiple fields under this prefix.
+  const actionResponse = createResponse(serverManifest, formFieldPrefix, body);
+  close(actionResponse);
+  const refPromise = getRoot(actionResponse); // Force it to initialize
+  // $FlowFixMe
+
+  refPromise.then(() => {});
+
+  if (refPromise.status !== 'fulfilled') {
+    // $FlowFixMe
+    throw refPromise.reason;
+  }
+
+  return refPromise.value;
+}
+
+function decodeAction(body, serverManifest) {
+  // We're going to create a new formData object that holds all the fields except
+  // the implementation details of the action data.
+  const formData = new FormData();
+  let action = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (!key.startsWith('$ACTION_')) {
+      formData.append(key, value);
+      return;
+    } // Later actions may override earlier actions if a button is used to override the default
+    // form action.
+
+
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      const metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+      action = loadServerReference(serverManifest, metaData.id, metaData.bound);
+      return;
+    }
+
+    if (key.startsWith('$ACTION_ID_')) {
+      const id = key.slice(11);
+      action = loadServerReference(serverManifest, id, null);
+      return;
+    }
+  });
+
+  if (action === null) {
+    return null;
+  } // Return the action with the remaining FormData bound to the first argument.
+
+
+  return action.then(fn => fn.bind(null, formData));
+}
+
+function createDrainHandler(destination, request) {
+  return () => startFlowing(request, destination);
+}
+
+function renderToPipeableStream(model, turbopackMap, options) {
+  const request = createRequest(model, turbopackMap, options ? options.onError : undefined, options ? options.context : undefined, options ? options.identifierPrefix : undefined, options ? options.onPostpone : undefined);
+  let hasStartedFlowing = false;
+  startWork(request);
+  return {
+    pipe(destination) {
+      if (hasStartedFlowing) {
+        throw new Error('React currently only supports piping to one writable stream.');
+      }
+
+      hasStartedFlowing = true;
+      startFlowing(request, destination);
+      destination.on('drain', createDrainHandler(destination, request));
+      return destination;
+    },
+
+    abort(reason) {
+      abort(request, reason);
+    }
+
+  };
+}
+
+function decodeReplyFromBusboy(busboyStream, turbopackMap) {
+  const response = createResponse(turbopackMap, '');
+  let pendingFiles = 0;
+  const queuedFields = [];
+  busboyStream.on('field', (name, value) => {
+    if (pendingFiles > 0) {
+      // Because the 'end' event fires two microtasks after the next 'field'
+      // we would resolve files and fields out of order. To handle this properly
+      // we queue any fields we receive until the previous file is done.
+      queuedFields.push(name, value);
+    } else {
+      resolveField(response, name, value);
+    }
+  });
+  busboyStream.on('file', (name, value, _ref) => {
+    let filename = _ref.filename,
+        encoding = _ref.encoding,
+        mimeType = _ref.mimeType;
+
+    if (encoding.toLowerCase() === 'base64') {
+      throw new Error("React doesn't accept base64 encoded file uploads because we don't expect " + "form data passed from a browser to ever encode data that way. If that's " + 'the wrong assumption, we can easily fix it.');
+    }
+
+    pendingFiles++;
+    const file = resolveFileInfo(response, name, filename, mimeType);
+    value.on('data', chunk => {
+      resolveFileChunk(response, file, chunk);
+    });
+    value.on('end', () => {
+      resolveFileComplete(response, name, file);
+      pendingFiles--;
+
+      if (pendingFiles === 0) {
+        // Release any queued fields
+        for (let i = 0; i < queuedFields.length; i += 2) {
+          resolveField(response, queuedFields[i], queuedFields[i + 1]);
+        }
+
+        queuedFields.length = 0;
+      }
+    });
+  });
+  busboyStream.on('finish', () => {
+    close(response);
+  });
+  busboyStream.on('error', err => {
+    reportGlobalError(response, // $FlowFixMe[incompatible-call] types Error and mixed are incompatible
+    err);
+  });
+  return getRoot(response);
+}
+
+function decodeReply(body, turbopackMap) {
+  if (typeof body === 'string') {
+    const form = new FormData();
+    form.append('0', body);
+    body = form;
+  }
+
+  const response = createResponse(turbopackMap, '', body);
+  const root = getRoot(response);
+  close(response);
+  return root;
+}
+
+exports.createClientModuleProxy = createClientModuleProxy;
+exports.decodeAction = decodeAction;
+exports.decodeReply = decodeReply;
+exports.decodeReplyFromBusboy = decodeReplyFromBusboy;
+exports.registerClientReference = registerClientReference;
+exports.registerServerReference = registerServerReference;
+exports.renderToPipeableStream = renderToPipeableStream;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.node.unbundled.production.min.js b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.node.unbundled.production.min.js
index 17b100a43bd09..cea3656eb064a 100644
--- a/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.node.unbundled.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-turbopack/cjs/react-server-dom-turbopack-server.node.unbundled.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-turbopack-server.node.unbundled.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-turbopack-server.node.unbundled.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var ba=require("util");require("crypto");var ca=require("async_hooks"),da=require("react"),ea=require("react-dom"),l=null,m=0,p=!0;function q(a,b){a=a.write(b);p=p&&a}
 function r(a,b){if("string"===typeof b){if(0!==b.length)if(2048<3*b.length)0<m&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=0),q(a,fa.encode(b));else{var d=l;0<m&&(d=l.subarray(m));d=fa.encodeInto(b,d);var c=d.read;m+=d.written;c<b.length&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=fa.encodeInto(b.slice(c),l).written);2048===m&&(q(a,l),l=new Uint8Array(2048),m=0)}}else 0!==b.byteLength&&(2048<b.byteLength?(0<m&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=0),q(a,b)):(d=l.length-m,d<b.byteLength&&
 (0===d?q(a,l):(l.set(b.subarray(0,d),m),m+=d,q(a,l),b=b.subarray(d)),l=new Uint8Array(2048),m=0),l.set(b,m),m+=b.byteLength,2048===m&&(q(a,l),l=new Uint8Array(2048),m=0)));return p}var fa=new ba.TextEncoder,t=Symbol.for("react.client.reference"),v=Symbol.for("react.server.reference");function w(a,b,d){return Object.defineProperties(a,{$$typeof:{value:t},$$id:{value:b},$$async:{value:d}})}var ha=Function.prototype.bind,ia=Array.prototype.slice;
@@ -74,3 +74,5 @@ exports.decodeAction=function(a,b){var d=new FormData,c=null;a.forEach(function(
 exports.decodeReplyFromBusboy=function(a,b){var d=Lb(b,""),c=0,e=[];a.on("field",function(f,g){0<c?e.push(f,g):Mb(d,f,g)});a.on("file",function(f,g,k){var h=k.filename,n=k.mimeType;if("base64"===k.encoding.toLowerCase())throw Error("React doesn't accept base64 encoded file uploads because we don't expect form data passed from a browser to ever encode data that way. If that's the wrong assumption, we can easily fix it.");c++;var z=[];g.on("data",function(u){z.push(u)});g.on("end",function(){var u=
 new Blob(z,{type:n});d._formData.append(f,u,h);c--;if(0===c){for(u=0;u<e.length;u+=2)Mb(d,e[u],e[u+1]);e.length=0}})});a.on("finish",function(){Nb(d)});a.on("error",function(f){Fb(d,f)});return Z(d,0)};exports.registerClientReference=function(a,b,d){return w(a,b+"#"+d,!1)};exports.registerServerReference=function(a,b,d){return Object.defineProperties(a,{$$typeof:{value:v},$$id:{value:null===d?b:b+"#"+d},$$bound:{value:null},bind:{value:ja}})};
 exports.renderToPipeableStream=function(a,b,d){var c=gb(a,b,d?d.onError:void 0,d?d.context:void 0,d?d.identifierPrefix:void 0,d?d.onPostpone:void 0),e=!1;sb(c);return{pipe:function(f){if(e)throw Error("React currently only supports piping to one writable stream.");e=!0;tb(c,f);f.on("drain",Qb(f,c));return f},abort:function(f){ub(c,f)}}};
+
+//# sourceMappingURL=react-server-dom-turbopack-server.node.unbundled.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-turbopack/package.json b/packages/next/src/compiled/react-server-dom-turbopack/package.json
index 498682bb7694f..003fc1da5ebc1 100644
--- a/packages/next/src/compiled/react-server-dom-turbopack/package.json
+++ b/packages/next/src/compiled/react-server-dom-turbopack/package.json
@@ -48,7 +48,7 @@
     "loose-envify": "^1.1.0"
   },
   "peerDependencies": {
-    "react": "18.3.0-canary-2983249dd-20231107",
-    "react-dom": "18.3.0-canary-2983249dd-20231107"
+    "react": "18.3.0-canary-7508dcd5c-20231108",
+    "react-dom": "18.3.0-canary-7508dcd5c-20231108"
   }
 }
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.browser.production.js b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.browser.production.js
new file mode 100644
index 0000000000000..97073db451cf5
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.browser.production.js
@@ -0,0 +1,1816 @@
+/**
+ * @license React
+ * react-server-dom-webpack-client.browser.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var ReactDOM = require('react-dom');
+var React = require('react');
+
+function createStringDecoder() {
+  return new TextDecoder();
+}
+const decoderOptions = {
+  stream: true
+};
+function readPartialStringChunk(decoder, buffer) {
+  return decoder.decode(buffer, decoderOptions);
+}
+function readFinalStringChunk(decoder, buffer) {
+  return decoder.decode(buffer);
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+function resolveClientReference(bundlerConfig, metadata) {
+  if (bundlerConfig) {
+    const moduleExports = bundlerConfig[metadata[ID]];
+    let resolvedModuleData = moduleExports[metadata[NAME]];
+    let name;
+
+    if (resolvedModuleData) {
+      // The potentially aliased name.
+      name = resolvedModuleData.name;
+    } else {
+      // If we don't have this specific name, we might have the full module.
+      resolvedModuleData = moduleExports['*'];
+
+      if (!resolvedModuleData) {
+        throw new Error('Could not find the module "' + metadata[ID] + '" in the React SSR Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+      }
+
+      name = metadata[NAME];
+    }
+
+    if (isAsyncImport(metadata)) {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1
+      /* async */
+      ];
+    } else {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+    }
+  }
+
+  return metadata;
+}
+// If they're still pending they're a thenable. This map also exists
+// in Webpack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = __webpack_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+  let i = 0;
+
+  while (i < chunks.length) {
+    const chunkId = chunks[i++];
+    const chunkFilename = chunks[i++];
+    const entry = chunkCache.get(chunkId);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkId, chunkFilename);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkId, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkId, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = __webpack_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+const chunkMap = new Map();
+/**
+ * We patch the chunk filename function in webpack to insert our own resolution
+ * of chunks that come from Flight and may not be known to the webpack runtime
+ */
+
+const webpackGetChunkFilename = __webpack_require__.u;
+
+__webpack_require__.u = function (chunkId) {
+  const flightChunk = chunkMap.get(chunkId);
+
+  if (flightChunk !== undefined) {
+    return flightChunk;
+  }
+
+  return webpackGetChunkFilename(chunkId);
+};
+
+function loadChunk(chunkId, filename) {
+  chunkMap.set(chunkId, filename);
+  return __webpack_chunk_load__(chunkId);
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+// This client file is in the shared folder because it applies to both SSR and browser contexts.
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function dispatchHint(code, model) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    switch (code) {
+      case 'D':
+        {
+          const refined = refineModel(code, model);
+          const href = refined;
+          dispatcher.prefetchDNS(href);
+          return;
+        }
+
+      case 'C':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preconnect(href);
+          } else {
+            const href = refined[0];
+            const crossOrigin = refined[1];
+            dispatcher.preconnect(href, crossOrigin);
+          }
+
+          return;
+        }
+
+      case 'L':
+        {
+          const refined = refineModel(code, model);
+          const href = refined[0];
+          const as = refined[1];
+
+          if (refined.length === 3) {
+            const options = refined[2];
+            dispatcher.preload(href, as, options);
+          } else {
+            dispatcher.preload(href, as);
+          }
+
+          return;
+        }
+
+      case 'm':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preloadModule(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preloadModule(href, options);
+          }
+
+          return;
+        }
+
+      case 'S':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitStyle(href);
+          } else {
+            const href = refined[0];
+            const precedence = refined[1] === 0 ? undefined : refined[1];
+            const options = refined.length === 3 ? refined[2] : undefined;
+            dispatcher.preinitStyle(href, precedence, options);
+          }
+
+          return;
+        }
+
+      case 'X':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitScript(href, options);
+          }
+
+          return;
+        }
+
+      case 'M':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitModuleScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitModuleScript(href, options);
+          }
+
+          return;
+        }
+    }
+  }
+} // Flow is having troulbe refining the HintModels so we help it a bit.
+// This should be compiled out in the production build.
+
+function refineModel(code, model) {
+  return model;
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+const ObjectPrototype = Object.prototype;
+const knownServerReferences = new WeakMap(); // Serializable values
+// Thenable<ReactServerValue>
+// function serializeByValueID(id: number): string {
+//   return '$' + id.toString(16);
+// }
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeFormDataReference(id) {
+  // Why K? F is "Function". D is "Date". What else?
+  return '$K' + id.toString(16);
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeMapID(id) {
+  return '$Q' + id.toString(16);
+}
+
+function serializeSetID(id) {
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+
+function processReply(root, formFieldPrefix, resolve, reject) {
+  let nextPartId = 1;
+  let pendingParts = 0;
+  let formData = null;
+
+  function resolveToJSON(key, value) {
+    const parent = this; // Make sure that `parent[key]` wasn't JSONified before `value` was passed to us
+
+    if (value === null) {
+      return null;
+    }
+
+    if (typeof value === 'object') {
+      // $FlowFixMe[method-unbinding]
+      if (typeof value.then === 'function') {
+        // We assume that any object with a .then property is a "Thenable" type,
+        // or a Promise type. Either of which can be represented by a Promise.
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        }
+
+        pendingParts++;
+        const promiseId = nextPartId++;
+        const thenable = value;
+        thenable.then(partValue => {
+          const partJSON = JSON.stringify(partValue, resolveToJSON); // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
+
+          const data = formData; // eslint-disable-next-line react-internal/safe-string-coercion
+
+          data.append(formFieldPrefix + promiseId, partJSON);
+          pendingParts--;
+
+          if (pendingParts === 0) {
+            resolve(data);
+          }
+        }, reason => {
+          // In the future we could consider serializing this as an error
+          // that throws on the server instead.
+          reject(reason);
+        });
+        return serializePromiseID(promiseId);
+      }
+
+      if (isArray(value)) {
+        // $FlowFixMe[incompatible-return]
+        return value;
+      } // TODO: Should we the Object.prototype.toString.call() to test for cross-realm objects?
+
+
+      if (value instanceof FormData) {
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to use rich objects as its values.
+          formData = new FormData();
+        }
+
+        const data = formData;
+        const refId = nextPartId++; // Copy all the form fields with a prefix for this reference.
+        // These must come first in the form order because we assume that all the
+        // fields are available before this is referenced.
+
+        const prefix = formFieldPrefix + refId + '_'; // $FlowFixMe[prop-missing]: FormData has forEach.
+
+        value.forEach((originalValue, originalKey) => {
+          data.append(prefix + originalKey, originalValue);
+        });
+        return serializeFormDataReference(refId);
+      }
+
+      if (value instanceof Map) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const mapId = nextPartId++;
+        formData.append(formFieldPrefix + mapId, partJSON);
+        return serializeMapID(mapId);
+      }
+
+      if (value instanceof Set) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const setId = nextPartId++;
+        formData.append(formFieldPrefix + setId, partJSON);
+        return serializeSetID(setId);
+      }
+
+      const iteratorFn = getIteratorFn(value);
+
+      if (iteratorFn) {
+        return Array.from(value);
+      } // Verify that this is a simple plain object.
+
+
+      const proto = getPrototypeOf(value);
+
+      if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+        throw new Error('Only plain objects, and a few built-ins, can be passed to Server Actions. ' + 'Classes or null prototypes are not supported.');
+      }
+
+
+      return value;
+    }
+
+    if (typeof value === 'string') {
+      // TODO: Maybe too clever. If we support URL there's no similar trick.
+      if (value[value.length - 1] === 'Z') {
+        // Possibly a Date, whose toJSON automatically calls toISOString
+        // $FlowFixMe[incompatible-use]
+        const originalValue = parent[key];
+
+        if (originalValue instanceof Date) {
+          return serializeDateFromDateJSON(value);
+        }
+      }
+
+      return escapeStringValue(value);
+    }
+
+    if (typeof value === 'boolean') {
+      return value;
+    }
+
+    if (typeof value === 'number') {
+      return serializeNumber(value);
+    }
+
+    if (typeof value === 'undefined') {
+      return serializeUndefined();
+    }
+
+    if (typeof value === 'function') {
+      const metaData = knownServerReferences.get(value);
+
+      if (metaData !== undefined) {
+        const metaDataJSON = JSON.stringify(metaData, resolveToJSON);
+
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        } // The reference to this function came from the same client so we can pass it back.
+
+
+        const refId = nextPartId++; // eslint-disable-next-line react-internal/safe-string-coercion
+
+        formData.set(formFieldPrefix + refId, metaDataJSON);
+        return serializeServerReferenceID(refId);
+      }
+
+      throw new Error('Client Functions cannot be passed directly to Server Functions. ' + 'Only Functions passed from the Server can be passed back again.');
+    }
+
+    if (typeof value === 'symbol') {
+      // $FlowFixMe[incompatible-type] `description` might be undefined
+      const name = value.description;
+
+      if (Symbol.for(name) !== value) {
+        throw new Error('Only global symbols received from Symbol.for(...) can be passed to Server Functions. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+        value.description + ") cannot be found among global symbols."));
+      }
+
+      return serializeSymbolReference(name);
+    }
+
+    if (typeof value === 'bigint') {
+      return serializeBigInt(value);
+    }
+
+    throw new Error("Type " + typeof value + " is not supported as an argument to a Server Function.");
+  } // $FlowFixMe[incompatible-type] it's not going to be undefined because we'll encode it.
+
+
+  const json = JSON.stringify(root, resolveToJSON);
+
+  if (formData === null) {
+    // If it's a simple data structure, we just use plain JSON.
+    resolve(json);
+  } else {
+    // Otherwise, we use FormData to let us stream in the result.
+    formData.set(formFieldPrefix + '0', json);
+
+    if (pendingParts === 0) {
+      // $FlowFixMe[incompatible-call] this has already been refined.
+      resolve(formData);
+    }
+  }
+}
+
+function registerServerReference(proxy, reference) {
+
+  knownServerReferences.set(proxy, reference);
+} // $FlowFixMe[method-unbinding]
+
+function createServerReference(id, callServer) {
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    return callServer(id, args);
+  };
+
+  registerServerReference(proxy, {
+    id,
+    bound: null
+  });
+  return proxy;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ROW_ID = 0;
+const ROW_TAG = 1;
+const ROW_LENGTH = 2;
+const ROW_CHUNK_BY_NEWLINE = 3;
+const ROW_CHUNK_BY_LENGTH = 4;
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const CYCLIC = 'cyclic';
+const RESOLVED_MODEL = 'resolved_model';
+const RESOLVED_MODULE = 'resolved_module';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function readChunk(chunk) {
+  // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      return chunk.value;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      // eslint-disable-next-line no-throw-literal
+      throw chunk;
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function createBlockedChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(BLOCKED, null, null, response);
+}
+
+function createErrorChunk(response, error) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(ERRORED, null, error, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function createResolvedModuleChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODULE, value, null, response);
+}
+
+function createInitializedTextChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function createInitializedBufferChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function resolveModuleChunk(chunk, value) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODULE;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    initializeModuleChunk(resolvedChunk);
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+  const resolvedModel = chunk.value; // We go to the CYCLIC state until we've fully resolved this.
+  // We do this before parsing in case we try to initialize the same chunk
+  // while parsing the model. Such as in a cyclic reference.
+
+  const cyclicChunk = chunk;
+  cyclicChunk.status = CYCLIC;
+  cyclicChunk.value = null;
+  cyclicChunk.reason = null;
+
+  try {
+    const value = parseModel(chunk._response, resolvedModel);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const resolveListeners = cyclicChunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, value);
+      }
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+}
+
+function initializeModuleChunk(chunk) {
+  try {
+    const value = requireModule(chunk.value);
+    const initializedChunk = chunk;
+    initializedChunk.status = INITIALIZED;
+    initializedChunk.value = value;
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function createElement(type, key, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: null,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: null
+  };
+
+  return element;
+}
+
+function createLazyChunkWrapper(chunk) {
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: chunk,
+    _init: readChunk
+  };
+  return lazyType;
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunk = createPendingChunk(response);
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key, cyclic) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+
+    if (!cyclic) {
+      blocked.deps++;
+    }
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: cyclic ? 0 : 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function createServerReferenceProxy(response, metaData) {
+  const callServer = response._callServer;
+
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    const p = metaData.bound;
+
+    if (!p) {
+      return callServer(metaData.id, args);
+    }
+
+    if (p.status === INITIALIZED) {
+      const bound = p.value;
+      return callServer(metaData.id, bound.concat(args));
+    } // Since this is a fake Promise whose .then doesn't chain, we have to wrap it.
+    // TODO: Remove the wrapper once that's fixed.
+
+
+    return Promise.resolve(p).then(function (bound) {
+      return callServer(metaData.id, bound.concat(args));
+    });
+  };
+
+  registerServerReference(proxy, metaData);
+  return proxy;
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      {
+        return chunk.value;
+      }
+    // We always encode it first in the stream so it won't be pending.
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    if (value === '$') {
+      // A very common symbol.
+      return REACT_ELEMENT_TYPE;
+    }
+
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case 'L':
+        {
+          // Lazy node
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id); // We create a React.lazy wrapper around any lazy values.
+          // When passed into React, we'll know how to suspend on this.
+
+          return createLazyChunkWrapper(chunk);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'P':
+        {
+          // Server Context Provider
+          return getOrCreateServerContext(value.slice(2)).Provider;
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16);
+          const metadata = getOutlinedModel(response, id);
+          return createServerReferenceProxy(response, metadata);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+
+            case RESOLVED_MODULE:
+              initializeModuleChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+            case CYCLIC:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key, chunk.status === CYCLIC), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function parseModelTuple(response, value) {
+  const tuple = value;
+
+  if (tuple[0] === REACT_ELEMENT_TYPE) {
+    // TODO: Consider having React just directly accept these arrays as elements.
+    // Or even change the ReactElement type to be an array.
+    return createElement(tuple[1], tuple[2], tuple[3]);
+  }
+
+  return value;
+}
+
+function missingCall() {
+  throw new Error('Trying to call a function from "use server" but the callServer option ' + 'was not implemented in your router runtime.');
+}
+
+function createResponse(bundlerConfig, moduleLoading, callServer, nonce) {
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _moduleLoading: moduleLoading,
+    _callServer: callServer !== undefined ? callServer : missingCall,
+    _nonce: nonce,
+    _chunks: chunks,
+    _stringDecoder: createStringDecoder(),
+    _fromJSON: null,
+    _rowState: 0,
+    _rowID: 0,
+    _rowTag: 0,
+    _rowLength: 0,
+    _buffer: []
+  }; // Don't inline this call because it causes closure to outline the call above.
+
+  response._fromJSON = createFromJSONCallback(response);
+  return response;
+}
+
+function resolveModel(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createResolvedModelChunk(response, model));
+  } else {
+    resolveModelChunk(chunk, model);
+  }
+}
+
+function resolveText(response, id, text) {
+  const chunks = response._chunks; // We assume that we always reference large strings after they've been
+  // emitted.
+
+  chunks.set(id, createInitializedTextChunk(response, text));
+}
+
+function resolveBuffer(response, id, buffer) {
+  const chunks = response._chunks; // We assume that we always reference buffers after they've been emitted.
+
+  chunks.set(id, createInitializedBufferChunk(response, buffer));
+}
+
+function resolveModule(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+  const clientReferenceMetadata = parseModel(response, model);
+  const clientReference = resolveClientReference(response._bundlerConfig, clientReferenceMetadata);
+  // For now we preload all modules as early as possible since it's likely
+  // that we'll need them.
+
+  const promise = preloadModule(clientReference);
+
+  if (promise) {
+    let blockedChunk;
+
+    if (!chunk) {
+      // Technically, we should just treat promise as the chunk in this
+      // case. Because it'll just behave as any other promise.
+      blockedChunk = createBlockedChunk(response);
+      chunks.set(id, blockedChunk);
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+    }
+
+    promise.then(() => resolveModuleChunk(blockedChunk, clientReference), error => triggerErrorOnChunk(blockedChunk, error));
+  } else {
+    if (!chunk) {
+      chunks.set(id, createResolvedModuleChunk(response, clientReference));
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      resolveModuleChunk(chunk, clientReference);
+    }
+  }
+}
+
+function resolveErrorProd(response, id, digest) {
+
+  const error = new Error('An error occurred in the Server Components render. The specific message is omitted in production' + ' builds to avoid leaking sensitive details. A digest property is included on this error instance which' + ' may provide additional details about the nature of the error.');
+  error.stack = 'Error: ' + error.message;
+  error.digest = digest;
+  const errorWithDigest = error;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, errorWithDigest));
+  } else {
+    triggerErrorOnChunk(chunk, errorWithDigest);
+  }
+}
+
+function resolvePostponeProd(response, id) {
+
+  const error = new Error('A Server Component was postponed. The reason is omitted in production' + ' builds to avoid leaking sensitive details.');
+  const postponeInstance = error;
+  postponeInstance.$$typeof = REACT_POSTPONE_TYPE;
+  postponeInstance.stack = 'Error: ' + error.message;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, postponeInstance));
+  } else {
+    triggerErrorOnChunk(chunk, postponeInstance);
+  }
+}
+
+function resolveHint(response, code, model) {
+  const hintModel = parseModel(response, model);
+  dispatchHint(code, hintModel);
+}
+
+function mergeBuffer(buffer, lastChunk) {
+  const l = buffer.length; // Count the bytes we'll need
+
+  let byteLength = lastChunk.length;
+
+  for (let i = 0; i < l; i++) {
+    byteLength += buffer[i].byteLength;
+  } // Allocate enough contiguous space
+
+
+  const result = new Uint8Array(byteLength);
+  let offset = 0; // Copy all the buffers into it.
+
+  for (let i = 0; i < l; i++) {
+    const chunk = buffer[i];
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+
+  result.set(lastChunk, offset);
+  return result;
+}
+
+function resolveTypedArray(response, id, buffer, lastChunk, constructor, bytesPerElement) {
+  // If the view fits into one original buffer, we just reuse that buffer instead of
+  // copying it out to a separate copy. This means that it's not always possible to
+  // transfer these values to other threads without copying first since they may
+  // share array buffer. For this to work, it must also have bytes aligned to a
+  // multiple of a size of the type.
+  const chunk = buffer.length === 0 && lastChunk.byteOffset % bytesPerElement === 0 ? lastChunk : mergeBuffer(buffer, lastChunk); // TODO: The transfer protocol of RSC is little-endian. If the client isn't little-endian
+  // we should convert it instead. In practice big endian isn't really Web compatible so it's
+  // somewhat safe to assume that browsers aren't going to run it, but maybe there's some SSR
+  // server that's affected.
+
+  const view = new constructor(chunk.buffer, chunk.byteOffset, chunk.byteLength / bytesPerElement);
+  resolveBuffer(response, id, view);
+}
+
+function processFullRow(response, id, tag, buffer, chunk) {
+  {
+    switch (tag) {
+      case 65
+      /* "A" */
+      :
+        // We must always clone to extract it into a separate buffer instead of just a view.
+        resolveBuffer(response, id, mergeBuffer(buffer, chunk).buffer);
+        return;
+
+      case 67
+      /* "C" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int8Array, 1);
+        return;
+
+      case 99
+      /* "c" */
+      :
+        resolveBuffer(response, id, buffer.length === 0 ? chunk : mergeBuffer(buffer, chunk));
+        return;
+
+      case 85
+      /* "U" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint8ClampedArray, 1);
+        return;
+
+      case 83
+      /* "S" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int16Array, 2);
+        return;
+
+      case 115
+      /* "s" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint16Array, 2);
+        return;
+
+      case 76
+      /* "L" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int32Array, 4);
+        return;
+
+      case 108
+      /* "l" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint32Array, 4);
+        return;
+
+      case 70
+      /* "F" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Float32Array, 4);
+        return;
+
+      case 68
+      /* "D" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Float64Array, 8);
+        return;
+
+      case 78
+      /* "N" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, BigInt64Array, 8);
+        return;
+
+      case 109
+      /* "m" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, BigUint64Array, 8);
+        return;
+
+      case 86
+      /* "V" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, DataView, 1);
+        return;
+    }
+  }
+
+  const stringDecoder = response._stringDecoder;
+  let row = '';
+
+  for (let i = 0; i < buffer.length; i++) {
+    row += readPartialStringChunk(stringDecoder, buffer[i]);
+  }
+
+  row += readFinalStringChunk(stringDecoder, chunk);
+
+  switch (tag) {
+    case 73
+    /* "I" */
+    :
+      {
+        resolveModule(response, id, row);
+        return;
+      }
+
+    case 72
+    /* "H" */
+    :
+      {
+        const code = row[0];
+        resolveHint(response, code, row.slice(1));
+        return;
+      }
+
+    case 69
+    /* "E" */
+    :
+      {
+        const errorInfo = JSON.parse(row);
+
+        {
+          resolveErrorProd(response, id, errorInfo.digest);
+        }
+
+        return;
+      }
+
+    case 84
+    /* "T" */
+    :
+      {
+        resolveText(response, id, row);
+        return;
+      }
+
+    case 80
+    /* "P" */
+    :
+      {
+        {
+          {
+            resolvePostponeProd(response, id);
+          }
+
+          return;
+        }
+      }
+    // Fallthrough
+
+    default:
+      /* """ "{" "[" "t" "f" "n" "0" - "9" */
+      {
+        // We assume anything else is JSON.
+        resolveModel(response, id, row);
+        return;
+      }
+  }
+}
+
+function processBinaryChunk(response, chunk) {
+  let i = 0;
+  let rowState = response._rowState;
+  let rowID = response._rowID;
+  let rowTag = response._rowTag;
+  let rowLength = response._rowLength;
+  const buffer = response._buffer;
+  const chunkLength = chunk.length;
+
+  while (i < chunkLength) {
+    let lastIdx = -1;
+
+    switch (rowState) {
+      case ROW_ID:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 58
+          /* ":" */
+          ) {
+              // Finished the rowID, next we'll parse the tag.
+              rowState = ROW_TAG;
+            } else {
+            rowID = rowID << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_TAG:
+        {
+          const resolvedRowTag = chunk[i];
+
+          if (resolvedRowTag === 84
+          /* "T" */
+          || (resolvedRowTag === 65
+          /* "A" */
+          || resolvedRowTag === 67
+          /* "C" */
+          || resolvedRowTag === 99
+          /* "c" */
+          || resolvedRowTag === 85
+          /* "U" */
+          || resolvedRowTag === 83
+          /* "S" */
+          || resolvedRowTag === 115
+          /* "s" */
+          || resolvedRowTag === 76
+          /* "L" */
+          || resolvedRowTag === 108
+          /* "l" */
+          || resolvedRowTag === 70
+          /* "F" */
+          || resolvedRowTag === 68
+          /* "D" */
+          || resolvedRowTag === 78
+          /* "N" */
+          || resolvedRowTag === 109
+          /* "m" */
+          || resolvedRowTag === 86)
+          /* "V" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_LENGTH;
+              i++;
+            } else if (resolvedRowTag > 64 && resolvedRowTag < 91
+          /* "A"-"Z" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_CHUNK_BY_NEWLINE;
+              i++;
+            } else {
+            rowTag = 0;
+            rowState = ROW_CHUNK_BY_NEWLINE; // This was an unknown tag so it was probably part of the data.
+          }
+
+          continue;
+        }
+
+      case ROW_LENGTH:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 44
+          /* "," */
+          ) {
+              // Finished the rowLength, next we'll buffer up to that length.
+              rowState = ROW_CHUNK_BY_LENGTH;
+            } else {
+            rowLength = rowLength << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_CHUNK_BY_NEWLINE:
+        {
+          // We're looking for a newline
+          lastIdx = chunk.indexOf(10
+          /* "\n" */
+          , i);
+          break;
+        }
+
+      case ROW_CHUNK_BY_LENGTH:
+        {
+          // We're looking for the remaining byte length
+          lastIdx = i + rowLength;
+
+          if (lastIdx > chunk.length) {
+            lastIdx = -1;
+          }
+
+          break;
+        }
+    }
+
+    const offset = chunk.byteOffset + i;
+
+    if (lastIdx > -1) {
+      // We found the last chunk of the row
+      const length = lastIdx - i;
+      const lastChunk = new Uint8Array(chunk.buffer, offset, length);
+      processFullRow(response, rowID, rowTag, buffer, lastChunk); // Reset state machine for a new row
+
+      i = lastIdx;
+
+      if (rowState === ROW_CHUNK_BY_NEWLINE) {
+        // If we're trailing by a newline we need to skip it.
+        i++;
+      }
+
+      rowState = ROW_ID;
+      rowTag = 0;
+      rowID = 0;
+      rowLength = 0;
+      buffer.length = 0;
+    } else {
+      // The rest of this row is in a future chunk. We stash the rest of the
+      // current chunk until we can process the full row.
+      const length = chunk.byteLength - i;
+      const remainingSlice = new Uint8Array(chunk.buffer, offset, length);
+      buffer.push(remainingSlice); // Update how many bytes we're still waiting for. If we're looking for
+      // a newline, this doesn't hurt since we'll just ignore it.
+
+      rowLength -= remainingSlice.byteLength;
+      break;
+    }
+  }
+
+  response._rowState = rowState;
+  response._rowID = rowID;
+  response._rowTag = rowTag;
+  response._rowLength = rowLength;
+}
+
+function parseModel(response, json) {
+  return JSON.parse(json, response._fromJSON);
+}
+
+function createFromJSONCallback(response) {
+  // $FlowFixMe[missing-this-annot]
+  return function (key, value) {
+    if (typeof value === 'string') {
+      // We can't use .bind here because we need the "this" value.
+      return parseModelString(response, this, key, value);
+    }
+
+    if (typeof value === 'object' && value !== null) {
+      return parseModelTuple(response, value);
+    }
+
+    return value;
+  };
+}
+
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function createResponseFromOptions(options) {
+  return createResponse(null, null, options && options.callServer ? options.callServer : undefined, undefined // nonce
+  );
+}
+
+function startReadingFromStream(response, stream) {
+  const reader = stream.getReader();
+
+  function progress(_ref) {
+    let done = _ref.done,
+        value = _ref.value;
+
+    if (done) {
+      close(response);
+      return;
+    }
+
+    const buffer = value;
+    processBinaryChunk(response, buffer);
+    return reader.read().then(progress).catch(error);
+  }
+
+  function error(e) {
+    reportGlobalError(response, e);
+  }
+
+  reader.read().then(progress).catch(error);
+}
+
+function createFromReadableStream(stream, options) {
+  const response = createResponseFromOptions(options);
+  startReadingFromStream(response, stream);
+  return getRoot(response);
+}
+
+function createFromFetch(promiseForResponse, options) {
+  const response = createResponseFromOptions(options);
+  promiseForResponse.then(function (r) {
+    startReadingFromStream(response, r.body);
+  }, function (e) {
+    reportGlobalError(response, e);
+  });
+  return getRoot(response);
+}
+
+function encodeReply(value)
+/* We don't use URLSearchParams yet but maybe */
+{
+  return new Promise((resolve, reject) => {
+    processReply(value, '', resolve, reject);
+  });
+}
+
+exports.createFromFetch = createFromFetch;
+exports.createFromReadableStream = createFromReadableStream;
+exports.createServerReference = createServerReference;
+exports.encodeReply = encodeReply;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.browser.production.min.js b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.browser.production.min.js
index 2677a9b21f24a..508b747ea4bd9 100644
--- a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.browser.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.browser.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-webpack-client.browser.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-webpack-client.browser.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var p=require("react-dom"),q=require("react"),r={stream:!0};function u(a,b){if(a){var c=a[b[0]];if(a=c[b[2]])c=a.name;else{a=c["*"];if(!a)throw Error('Could not find the module "'+b[0]+'" in the React SSR Manifest. This is probably a bug in the React Server Components bundler.');c=b[2]}return 4===b.length?[a.id,a.chunks,c,1]:[a.id,a.chunks,c]}return b}var w=new Map;
 function x(a){var b=__webpack_require__(a);if("function"!==typeof b.then||"fulfilled"===b.status)return null;b.then(function(c){b.status="fulfilled";b.value=c},function(c){b.status="rejected";b.reason=c});return b}function y(){}
 function z(a){for(var b=a[1],c=[],d=0;d<b.length;){var f=b[d++],h=b[d++],e=w.get(f);void 0===e?(A.set(f,h),h=__webpack_chunk_load__(f),c.push(h),e=w.set.bind(w,f,null),h.then(e,y),w.set(f,h)):null!==e&&c.push(e)}return 4===a.length?0===c.length?x(a[0]):Promise.all(c).then(function(){return x(a[0])}):0<c.length?Promise.all(c):null}var A=new Map,aa=__webpack_require__.u;__webpack_require__.u=function(a){var b=A.get(a);return void 0!==b?b:aa(a)};
@@ -38,3 +38,5 @@ function Z(a,b){function c(h){var e=h.value;if(h.done)S(a,Error("Connection clos
 48);continue;case 3:m=e.indexOf(10,l);break;case 4:m=l+n,m>e.length&&(m=-1)}var t=e.byteOffset+l;if(-1<m)n=new Uint8Array(e.buffer,t,m-l),ua(a,h,g,v,n),l=m,3===k&&l++,n=h=g=k=0,v.length=0;else{e=new Uint8Array(e.buffer,t,e.byteLength-l);v.push(e);n-=e.byteLength;break}}a._rowState=k;a._rowID=h;a._rowTag=g;a._rowLength=n;return f.read().then(c).catch(d)}}function d(h){S(a,h)}var f=b.getReader();f.read().then(c).catch(d)}
 exports.createFromFetch=function(a,b){var c=V(null,null,b&&b.callServer?b.callServer:void 0,void 0);a.then(function(d){Z(c,d.body)},function(d){S(c,d)});return T(c,0)};exports.createFromReadableStream=function(a,b){b=V(null,null,b&&b.callServer?b.callServer:void 0,void 0);Z(b,a);return T(b,0)};exports.createServerReference=function(a,b){function c(){var d=Array.prototype.slice.call(arguments);return b(a,d)}H(c,{id:a,bound:null});return c};
 exports.encodeReply=function(a){return new Promise(function(b,c){la(a,"",b,c)})};
+
+//# sourceMappingURL=react-server-dom-webpack-client.browser.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.edge.production.js b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.edge.production.js
new file mode 100644
index 0000000000000..659e32a29b4f0
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.edge.production.js
@@ -0,0 +1,2026 @@
+/**
+ * @license React
+ * react-server-dom-webpack-client.edge.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var ReactDOM = require('react-dom');
+var React = require('react');
+
+function createStringDecoder() {
+  return new TextDecoder();
+}
+const decoderOptions = {
+  stream: true
+};
+function readPartialStringChunk(decoder, buffer) {
+  return decoder.decode(buffer, decoderOptions);
+}
+function readFinalStringChunk(decoder, buffer) {
+  return decoder.decode(buffer);
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+// The reason this function needs to defined here in this file instead of just
+// being exported directly from the WebpackDestination... file is because the
+// ClientReferenceMetadata is opaque and we can't unwrap it there.
+// This should get inlined and we could also just implement an unwrapping function
+// though that risks it getting used in places it shouldn't be. This is unfortunate
+// but currently it seems to be the best option we have.
+
+function prepareDestinationForModule(moduleLoading, nonce, metadata) {
+  prepareDestinationWithChunks(moduleLoading, metadata[CHUNKS], nonce);
+}
+function resolveClientReference(bundlerConfig, metadata) {
+  if (bundlerConfig) {
+    const moduleExports = bundlerConfig[metadata[ID]];
+    let resolvedModuleData = moduleExports[metadata[NAME]];
+    let name;
+
+    if (resolvedModuleData) {
+      // The potentially aliased name.
+      name = resolvedModuleData.name;
+    } else {
+      // If we don't have this specific name, we might have the full module.
+      resolvedModuleData = moduleExports['*'];
+
+      if (!resolvedModuleData) {
+        throw new Error('Could not find the module "' + metadata[ID] + '" in the React SSR Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+      }
+
+      name = metadata[NAME];
+    }
+
+    if (isAsyncImport(metadata)) {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1
+      /* async */
+      ];
+    } else {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+    }
+  }
+
+  return metadata;
+}
+// If they're still pending they're a thenable. This map also exists
+// in Webpack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = globalThis.__next_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+  let i = 0;
+
+  while (i < chunks.length) {
+    const chunkId = chunks[i++];
+    chunks[i++];
+    const entry = chunkCache.get(chunkId);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkId);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkId, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkId, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = globalThis.__next_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+function loadChunk(chunkId, filename) {
+  return __webpack_chunk_load__(chunkId);
+}
+
+function prepareDestinationWithChunks(moduleLoading, // Chunks are double-indexed [..., idx, filenamex, idy, filenamey, ...]
+chunks, nonce) {
+  if (moduleLoading !== null) {
+    for (let i = 1; i < chunks.length; i += 2) {
+      preinitScriptForSSR(moduleLoading.prefix + chunks[i], nonce, moduleLoading.crossOrigin);
+    }
+  }
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// This client file is in the shared folder because it applies to both SSR and browser contexts.
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function dispatchHint(code, model) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    switch (code) {
+      case 'D':
+        {
+          const refined = refineModel(code, model);
+          const href = refined;
+          dispatcher.prefetchDNS(href);
+          return;
+        }
+
+      case 'C':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preconnect(href);
+          } else {
+            const href = refined[0];
+            const crossOrigin = refined[1];
+            dispatcher.preconnect(href, crossOrigin);
+          }
+
+          return;
+        }
+
+      case 'L':
+        {
+          const refined = refineModel(code, model);
+          const href = refined[0];
+          const as = refined[1];
+
+          if (refined.length === 3) {
+            const options = refined[2];
+            dispatcher.preload(href, as, options);
+          } else {
+            dispatcher.preload(href, as);
+          }
+
+          return;
+        }
+
+      case 'm':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preloadModule(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preloadModule(href, options);
+          }
+
+          return;
+        }
+
+      case 'S':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitStyle(href);
+          } else {
+            const href = refined[0];
+            const precedence = refined[1] === 0 ? undefined : refined[1];
+            const options = refined.length === 3 ? refined[2] : undefined;
+            dispatcher.preinitStyle(href, precedence, options);
+          }
+
+          return;
+        }
+
+      case 'X':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitScript(href, options);
+          }
+
+          return;
+        }
+
+      case 'M':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitModuleScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitModuleScript(href, options);
+          }
+
+          return;
+        }
+    }
+  }
+} // Flow is having troulbe refining the HintModels so we help it a bit.
+// This should be compiled out in the production build.
+
+function refineModel(code, model) {
+  return model;
+}
+function preinitScriptForSSR(href, nonce, crossOrigin) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    dispatcher.preinitScript(href, {
+      crossOrigin: getCrossOriginString(crossOrigin),
+      nonce
+    });
+  }
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+const ObjectPrototype = Object.prototype;
+const knownServerReferences = new WeakMap(); // Serializable values
+// Thenable<ReactServerValue>
+// function serializeByValueID(id: number): string {
+//   return '$' + id.toString(16);
+// }
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeFormDataReference(id) {
+  // Why K? F is "Function". D is "Date". What else?
+  return '$K' + id.toString(16);
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeMapID(id) {
+  return '$Q' + id.toString(16);
+}
+
+function serializeSetID(id) {
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+
+function processReply(root, formFieldPrefix, resolve, reject) {
+  let nextPartId = 1;
+  let pendingParts = 0;
+  let formData = null;
+
+  function resolveToJSON(key, value) {
+    const parent = this; // Make sure that `parent[key]` wasn't JSONified before `value` was passed to us
+
+    if (value === null) {
+      return null;
+    }
+
+    if (typeof value === 'object') {
+      // $FlowFixMe[method-unbinding]
+      if (typeof value.then === 'function') {
+        // We assume that any object with a .then property is a "Thenable" type,
+        // or a Promise type. Either of which can be represented by a Promise.
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        }
+
+        pendingParts++;
+        const promiseId = nextPartId++;
+        const thenable = value;
+        thenable.then(partValue => {
+          const partJSON = JSON.stringify(partValue, resolveToJSON); // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
+
+          const data = formData; // eslint-disable-next-line react-internal/safe-string-coercion
+
+          data.append(formFieldPrefix + promiseId, partJSON);
+          pendingParts--;
+
+          if (pendingParts === 0) {
+            resolve(data);
+          }
+        }, reason => {
+          // In the future we could consider serializing this as an error
+          // that throws on the server instead.
+          reject(reason);
+        });
+        return serializePromiseID(promiseId);
+      }
+
+      if (isArray(value)) {
+        // $FlowFixMe[incompatible-return]
+        return value;
+      } // TODO: Should we the Object.prototype.toString.call() to test for cross-realm objects?
+
+
+      if (value instanceof FormData) {
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to use rich objects as its values.
+          formData = new FormData();
+        }
+
+        const data = formData;
+        const refId = nextPartId++; // Copy all the form fields with a prefix for this reference.
+        // These must come first in the form order because we assume that all the
+        // fields are available before this is referenced.
+
+        const prefix = formFieldPrefix + refId + '_'; // $FlowFixMe[prop-missing]: FormData has forEach.
+
+        value.forEach((originalValue, originalKey) => {
+          data.append(prefix + originalKey, originalValue);
+        });
+        return serializeFormDataReference(refId);
+      }
+
+      if (value instanceof Map) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const mapId = nextPartId++;
+        formData.append(formFieldPrefix + mapId, partJSON);
+        return serializeMapID(mapId);
+      }
+
+      if (value instanceof Set) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const setId = nextPartId++;
+        formData.append(formFieldPrefix + setId, partJSON);
+        return serializeSetID(setId);
+      }
+
+      const iteratorFn = getIteratorFn(value);
+
+      if (iteratorFn) {
+        return Array.from(value);
+      } // Verify that this is a simple plain object.
+
+
+      const proto = getPrototypeOf(value);
+
+      if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+        throw new Error('Only plain objects, and a few built-ins, can be passed to Server Actions. ' + 'Classes or null prototypes are not supported.');
+      }
+
+
+      return value;
+    }
+
+    if (typeof value === 'string') {
+      // TODO: Maybe too clever. If we support URL there's no similar trick.
+      if (value[value.length - 1] === 'Z') {
+        // Possibly a Date, whose toJSON automatically calls toISOString
+        // $FlowFixMe[incompatible-use]
+        const originalValue = parent[key];
+
+        if (originalValue instanceof Date) {
+          return serializeDateFromDateJSON(value);
+        }
+      }
+
+      return escapeStringValue(value);
+    }
+
+    if (typeof value === 'boolean') {
+      return value;
+    }
+
+    if (typeof value === 'number') {
+      return serializeNumber(value);
+    }
+
+    if (typeof value === 'undefined') {
+      return serializeUndefined();
+    }
+
+    if (typeof value === 'function') {
+      const metaData = knownServerReferences.get(value);
+
+      if (metaData !== undefined) {
+        const metaDataJSON = JSON.stringify(metaData, resolveToJSON);
+
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        } // The reference to this function came from the same client so we can pass it back.
+
+
+        const refId = nextPartId++; // eslint-disable-next-line react-internal/safe-string-coercion
+
+        formData.set(formFieldPrefix + refId, metaDataJSON);
+        return serializeServerReferenceID(refId);
+      }
+
+      throw new Error('Client Functions cannot be passed directly to Server Functions. ' + 'Only Functions passed from the Server can be passed back again.');
+    }
+
+    if (typeof value === 'symbol') {
+      // $FlowFixMe[incompatible-type] `description` might be undefined
+      const name = value.description;
+
+      if (Symbol.for(name) !== value) {
+        throw new Error('Only global symbols received from Symbol.for(...) can be passed to Server Functions. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+        value.description + ") cannot be found among global symbols."));
+      }
+
+      return serializeSymbolReference(name);
+    }
+
+    if (typeof value === 'bigint') {
+      return serializeBigInt(value);
+    }
+
+    throw new Error("Type " + typeof value + " is not supported as an argument to a Server Function.");
+  } // $FlowFixMe[incompatible-type] it's not going to be undefined because we'll encode it.
+
+
+  const json = JSON.stringify(root, resolveToJSON);
+
+  if (formData === null) {
+    // If it's a simple data structure, we just use plain JSON.
+    resolve(json);
+  } else {
+    // Otherwise, we use FormData to let us stream in the result.
+    formData.set(formFieldPrefix + '0', json);
+
+    if (pendingParts === 0) {
+      // $FlowFixMe[incompatible-call] this has already been refined.
+      resolve(formData);
+    }
+  }
+}
+const boundCache = new WeakMap();
+
+function encodeFormData(reference) {
+  let resolve, reject; // We need to have a handle on the thenable so that we can synchronously set
+  // its status from processReply, when it can complete synchronously.
+
+  const thenable = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  processReply(reference, '', body => {
+    if (typeof body === 'string') {
+      const data = new FormData();
+      data.append('0', body);
+      body = data;
+    }
+
+    const fulfilled = thenable;
+    fulfilled.status = 'fulfilled';
+    fulfilled.value = body;
+    resolve(body);
+  }, e => {
+    const rejected = thenable;
+    rejected.status = 'rejected';
+    rejected.reason = e;
+    reject(e);
+  });
+  return thenable;
+}
+
+function encodeFormAction(identifierPrefix) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  let data = null;
+  let name;
+  const boundPromise = reference.bound;
+
+  if (boundPromise !== null) {
+    let thenable = boundCache.get(reference);
+
+    if (!thenable) {
+      thenable = encodeFormData(reference);
+      boundCache.set(reference, thenable);
+    }
+
+    if (thenable.status === 'rejected') {
+      throw thenable.reason;
+    } else if (thenable.status !== 'fulfilled') {
+      throw thenable;
+    }
+
+    const encodedFormData = thenable.value; // This is hacky but we need the identifier prefix to be added to
+    // all fields but the suspense cache would break since we might get
+    // a new identifier each time. So we just append it at the end instead.
+
+    const prefixedData = new FormData(); // $FlowFixMe[prop-missing]
+
+    encodedFormData.forEach((value, key) => {
+      prefixedData.append('$ACTION_' + identifierPrefix + ':' + key, value);
+    });
+    data = prefixedData; // We encode the name of the prefix containing the data.
+
+    name = '$ACTION_REF_' + identifierPrefix;
+  } else {
+    // This is the simple case so we can just encode the ID.
+    name = '$ACTION_ID_' + reference.id;
+  }
+
+  return {
+    name: name,
+    method: 'POST',
+    encType: 'multipart/form-data',
+    data: data
+  };
+}
+
+function isSignatureEqual(referenceId, numberOfBoundArgs) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  if (reference.id !== referenceId) {
+    // These are different functions.
+    return false;
+  } // Now check if the number of bound arguments is the same.
+
+
+  const boundPromise = reference.bound;
+
+  if (boundPromise === null) {
+    // No bound arguments.
+    return numberOfBoundArgs === 0;
+  } // Unwrap the bound arguments array by suspending, if necessary. As with
+  // encodeFormData, this means isSignatureEqual can only be called while React
+  // is rendering.
+
+
+  switch (boundPromise.status) {
+    case 'fulfilled':
+      {
+        const boundArgs = boundPromise.value;
+        return boundArgs.length === numberOfBoundArgs;
+      }
+
+    case 'pending':
+      {
+        throw boundPromise;
+      }
+
+    case 'rejected':
+      {
+        throw boundPromise.reason;
+      }
+
+    default:
+      {
+        if (typeof boundPromise.status === 'string') ; else {
+          const pendingThenable = boundPromise;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(boundArgs => {
+            const fulfilledThenable = boundPromise;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = boundArgs;
+          }, error => {
+            const rejectedThenable = boundPromise;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          });
+        }
+
+        throw boundPromise;
+      }
+  }
+}
+
+function registerServerReference(proxy, reference) {
+  // Expose encoder for use by SSR, as well as a special bind that can be used to
+  // keep server capabilities.
+  {
+    // Only expose this in builds that would actually use it. Not needed on the client.
+    Object.defineProperties(proxy, {
+      $$FORM_ACTION: {
+        value: encodeFormAction
+      },
+      $$IS_SIGNATURE_EQUAL: {
+        value: isSignatureEqual
+      },
+      bind: {
+        value: bind
+      }
+    });
+  }
+
+  knownServerReferences.set(proxy, reference);
+} // $FlowFixMe[method-unbinding]
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+  const reference = knownServerReferences.get(this);
+
+  if (reference) {
+    const args = ArraySlice.call(arguments, 1);
+    let boundPromise = null;
+
+    if (reference.bound !== null) {
+      boundPromise = Promise.resolve(reference.bound).then(boundArgs => boundArgs.concat(args));
+    } else {
+      boundPromise = Promise.resolve(args);
+    }
+
+    registerServerReference(newFn, {
+      id: reference.id,
+      bound: boundPromise
+    });
+  }
+
+  return newFn;
+}
+
+function createServerReference$1(id, callServer) {
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    return callServer(id, args);
+  };
+
+  registerServerReference(proxy, {
+    id,
+    bound: null
+  });
+  return proxy;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ROW_ID = 0;
+const ROW_TAG = 1;
+const ROW_LENGTH = 2;
+const ROW_CHUNK_BY_NEWLINE = 3;
+const ROW_CHUNK_BY_LENGTH = 4;
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const CYCLIC = 'cyclic';
+const RESOLVED_MODEL = 'resolved_model';
+const RESOLVED_MODULE = 'resolved_module';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function readChunk(chunk) {
+  // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      return chunk.value;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      // eslint-disable-next-line no-throw-literal
+      throw chunk;
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function createBlockedChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(BLOCKED, null, null, response);
+}
+
+function createErrorChunk(response, error) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(ERRORED, null, error, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function createResolvedModuleChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODULE, value, null, response);
+}
+
+function createInitializedTextChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function createInitializedBufferChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function resolveModuleChunk(chunk, value) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODULE;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    initializeModuleChunk(resolvedChunk);
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+  const resolvedModel = chunk.value; // We go to the CYCLIC state until we've fully resolved this.
+  // We do this before parsing in case we try to initialize the same chunk
+  // while parsing the model. Such as in a cyclic reference.
+
+  const cyclicChunk = chunk;
+  cyclicChunk.status = CYCLIC;
+  cyclicChunk.value = null;
+  cyclicChunk.reason = null;
+
+  try {
+    const value = parseModel(chunk._response, resolvedModel);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const resolveListeners = cyclicChunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, value);
+      }
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+}
+
+function initializeModuleChunk(chunk) {
+  try {
+    const value = requireModule(chunk.value);
+    const initializedChunk = chunk;
+    initializedChunk.status = INITIALIZED;
+    initializedChunk.value = value;
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function createElement(type, key, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: null,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: null
+  };
+
+  return element;
+}
+
+function createLazyChunkWrapper(chunk) {
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: chunk,
+    _init: readChunk
+  };
+  return lazyType;
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunk = createPendingChunk(response);
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key, cyclic) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+
+    if (!cyclic) {
+      blocked.deps++;
+    }
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: cyclic ? 0 : 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function createServerReferenceProxy(response, metaData) {
+  const callServer = response._callServer;
+
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    const p = metaData.bound;
+
+    if (!p) {
+      return callServer(metaData.id, args);
+    }
+
+    if (p.status === INITIALIZED) {
+      const bound = p.value;
+      return callServer(metaData.id, bound.concat(args));
+    } // Since this is a fake Promise whose .then doesn't chain, we have to wrap it.
+    // TODO: Remove the wrapper once that's fixed.
+
+
+    return Promise.resolve(p).then(function (bound) {
+      return callServer(metaData.id, bound.concat(args));
+    });
+  };
+
+  registerServerReference(proxy, metaData);
+  return proxy;
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      {
+        return chunk.value;
+      }
+    // We always encode it first in the stream so it won't be pending.
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    if (value === '$') {
+      // A very common symbol.
+      return REACT_ELEMENT_TYPE;
+    }
+
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case 'L':
+        {
+          // Lazy node
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id); // We create a React.lazy wrapper around any lazy values.
+          // When passed into React, we'll know how to suspend on this.
+
+          return createLazyChunkWrapper(chunk);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'P':
+        {
+          // Server Context Provider
+          return getOrCreateServerContext(value.slice(2)).Provider;
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16);
+          const metadata = getOutlinedModel(response, id);
+          return createServerReferenceProxy(response, metadata);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+
+            case RESOLVED_MODULE:
+              initializeModuleChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+            case CYCLIC:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key, chunk.status === CYCLIC), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function parseModelTuple(response, value) {
+  const tuple = value;
+
+  if (tuple[0] === REACT_ELEMENT_TYPE) {
+    // TODO: Consider having React just directly accept these arrays as elements.
+    // Or even change the ReactElement type to be an array.
+    return createElement(tuple[1], tuple[2], tuple[3]);
+  }
+
+  return value;
+}
+
+function missingCall() {
+  throw new Error('Trying to call a function from "use server" but the callServer option ' + 'was not implemented in your router runtime.');
+}
+
+function createResponse(bundlerConfig, moduleLoading, callServer, nonce) {
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _moduleLoading: moduleLoading,
+    _callServer: callServer !== undefined ? callServer : missingCall,
+    _nonce: nonce,
+    _chunks: chunks,
+    _stringDecoder: createStringDecoder(),
+    _fromJSON: null,
+    _rowState: 0,
+    _rowID: 0,
+    _rowTag: 0,
+    _rowLength: 0,
+    _buffer: []
+  }; // Don't inline this call because it causes closure to outline the call above.
+
+  response._fromJSON = createFromJSONCallback(response);
+  return response;
+}
+
+function resolveModel(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createResolvedModelChunk(response, model));
+  } else {
+    resolveModelChunk(chunk, model);
+  }
+}
+
+function resolveText(response, id, text) {
+  const chunks = response._chunks; // We assume that we always reference large strings after they've been
+  // emitted.
+
+  chunks.set(id, createInitializedTextChunk(response, text));
+}
+
+function resolveBuffer(response, id, buffer) {
+  const chunks = response._chunks; // We assume that we always reference buffers after they've been emitted.
+
+  chunks.set(id, createInitializedBufferChunk(response, buffer));
+}
+
+function resolveModule(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+  const clientReferenceMetadata = parseModel(response, model);
+  const clientReference = resolveClientReference(response._bundlerConfig, clientReferenceMetadata);
+  prepareDestinationForModule(response._moduleLoading, response._nonce, clientReferenceMetadata); // TODO: Add an option to encode modules that are lazy loaded.
+  // For now we preload all modules as early as possible since it's likely
+  // that we'll need them.
+
+  const promise = preloadModule(clientReference);
+
+  if (promise) {
+    let blockedChunk;
+
+    if (!chunk) {
+      // Technically, we should just treat promise as the chunk in this
+      // case. Because it'll just behave as any other promise.
+      blockedChunk = createBlockedChunk(response);
+      chunks.set(id, blockedChunk);
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+    }
+
+    promise.then(() => resolveModuleChunk(blockedChunk, clientReference), error => triggerErrorOnChunk(blockedChunk, error));
+  } else {
+    if (!chunk) {
+      chunks.set(id, createResolvedModuleChunk(response, clientReference));
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      resolveModuleChunk(chunk, clientReference);
+    }
+  }
+}
+
+function resolveErrorProd(response, id, digest) {
+
+  const error = new Error('An error occurred in the Server Components render. The specific message is omitted in production' + ' builds to avoid leaking sensitive details. A digest property is included on this error instance which' + ' may provide additional details about the nature of the error.');
+  error.stack = 'Error: ' + error.message;
+  error.digest = digest;
+  const errorWithDigest = error;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, errorWithDigest));
+  } else {
+    triggerErrorOnChunk(chunk, errorWithDigest);
+  }
+}
+
+function resolvePostponeProd(response, id) {
+
+  const error = new Error('A Server Component was postponed. The reason is omitted in production' + ' builds to avoid leaking sensitive details.');
+  const postponeInstance = error;
+  postponeInstance.$$typeof = REACT_POSTPONE_TYPE;
+  postponeInstance.stack = 'Error: ' + error.message;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, postponeInstance));
+  } else {
+    triggerErrorOnChunk(chunk, postponeInstance);
+  }
+}
+
+function resolveHint(response, code, model) {
+  const hintModel = parseModel(response, model);
+  dispatchHint(code, hintModel);
+}
+
+function mergeBuffer(buffer, lastChunk) {
+  const l = buffer.length; // Count the bytes we'll need
+
+  let byteLength = lastChunk.length;
+
+  for (let i = 0; i < l; i++) {
+    byteLength += buffer[i].byteLength;
+  } // Allocate enough contiguous space
+
+
+  const result = new Uint8Array(byteLength);
+  let offset = 0; // Copy all the buffers into it.
+
+  for (let i = 0; i < l; i++) {
+    const chunk = buffer[i];
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+
+  result.set(lastChunk, offset);
+  return result;
+}
+
+function resolveTypedArray(response, id, buffer, lastChunk, constructor, bytesPerElement) {
+  // If the view fits into one original buffer, we just reuse that buffer instead of
+  // copying it out to a separate copy. This means that it's not always possible to
+  // transfer these values to other threads without copying first since they may
+  // share array buffer. For this to work, it must also have bytes aligned to a
+  // multiple of a size of the type.
+  const chunk = buffer.length === 0 && lastChunk.byteOffset % bytesPerElement === 0 ? lastChunk : mergeBuffer(buffer, lastChunk); // TODO: The transfer protocol of RSC is little-endian. If the client isn't little-endian
+  // we should convert it instead. In practice big endian isn't really Web compatible so it's
+  // somewhat safe to assume that browsers aren't going to run it, but maybe there's some SSR
+  // server that's affected.
+
+  const view = new constructor(chunk.buffer, chunk.byteOffset, chunk.byteLength / bytesPerElement);
+  resolveBuffer(response, id, view);
+}
+
+function processFullRow(response, id, tag, buffer, chunk) {
+  {
+    switch (tag) {
+      case 65
+      /* "A" */
+      :
+        // We must always clone to extract it into a separate buffer instead of just a view.
+        resolveBuffer(response, id, mergeBuffer(buffer, chunk).buffer);
+        return;
+
+      case 67
+      /* "C" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int8Array, 1);
+        return;
+
+      case 99
+      /* "c" */
+      :
+        resolveBuffer(response, id, buffer.length === 0 ? chunk : mergeBuffer(buffer, chunk));
+        return;
+
+      case 85
+      /* "U" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint8ClampedArray, 1);
+        return;
+
+      case 83
+      /* "S" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int16Array, 2);
+        return;
+
+      case 115
+      /* "s" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint16Array, 2);
+        return;
+
+      case 76
+      /* "L" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int32Array, 4);
+        return;
+
+      case 108
+      /* "l" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint32Array, 4);
+        return;
+
+      case 70
+      /* "F" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Float32Array, 4);
+        return;
+
+      case 68
+      /* "D" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Float64Array, 8);
+        return;
+
+      case 78
+      /* "N" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, BigInt64Array, 8);
+        return;
+
+      case 109
+      /* "m" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, BigUint64Array, 8);
+        return;
+
+      case 86
+      /* "V" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, DataView, 1);
+        return;
+    }
+  }
+
+  const stringDecoder = response._stringDecoder;
+  let row = '';
+
+  for (let i = 0; i < buffer.length; i++) {
+    row += readPartialStringChunk(stringDecoder, buffer[i]);
+  }
+
+  row += readFinalStringChunk(stringDecoder, chunk);
+
+  switch (tag) {
+    case 73
+    /* "I" */
+    :
+      {
+        resolveModule(response, id, row);
+        return;
+      }
+
+    case 72
+    /* "H" */
+    :
+      {
+        const code = row[0];
+        resolveHint(response, code, row.slice(1));
+        return;
+      }
+
+    case 69
+    /* "E" */
+    :
+      {
+        const errorInfo = JSON.parse(row);
+
+        {
+          resolveErrorProd(response, id, errorInfo.digest);
+        }
+
+        return;
+      }
+
+    case 84
+    /* "T" */
+    :
+      {
+        resolveText(response, id, row);
+        return;
+      }
+
+    case 80
+    /* "P" */
+    :
+      {
+        {
+          {
+            resolvePostponeProd(response, id);
+          }
+
+          return;
+        }
+      }
+    // Fallthrough
+
+    default:
+      /* """ "{" "[" "t" "f" "n" "0" - "9" */
+      {
+        // We assume anything else is JSON.
+        resolveModel(response, id, row);
+        return;
+      }
+  }
+}
+
+function processBinaryChunk(response, chunk) {
+  let i = 0;
+  let rowState = response._rowState;
+  let rowID = response._rowID;
+  let rowTag = response._rowTag;
+  let rowLength = response._rowLength;
+  const buffer = response._buffer;
+  const chunkLength = chunk.length;
+
+  while (i < chunkLength) {
+    let lastIdx = -1;
+
+    switch (rowState) {
+      case ROW_ID:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 58
+          /* ":" */
+          ) {
+              // Finished the rowID, next we'll parse the tag.
+              rowState = ROW_TAG;
+            } else {
+            rowID = rowID << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_TAG:
+        {
+          const resolvedRowTag = chunk[i];
+
+          if (resolvedRowTag === 84
+          /* "T" */
+          || (resolvedRowTag === 65
+          /* "A" */
+          || resolvedRowTag === 67
+          /* "C" */
+          || resolvedRowTag === 99
+          /* "c" */
+          || resolvedRowTag === 85
+          /* "U" */
+          || resolvedRowTag === 83
+          /* "S" */
+          || resolvedRowTag === 115
+          /* "s" */
+          || resolvedRowTag === 76
+          /* "L" */
+          || resolvedRowTag === 108
+          /* "l" */
+          || resolvedRowTag === 70
+          /* "F" */
+          || resolvedRowTag === 68
+          /* "D" */
+          || resolvedRowTag === 78
+          /* "N" */
+          || resolvedRowTag === 109
+          /* "m" */
+          || resolvedRowTag === 86)
+          /* "V" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_LENGTH;
+              i++;
+            } else if (resolvedRowTag > 64 && resolvedRowTag < 91
+          /* "A"-"Z" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_CHUNK_BY_NEWLINE;
+              i++;
+            } else {
+            rowTag = 0;
+            rowState = ROW_CHUNK_BY_NEWLINE; // This was an unknown tag so it was probably part of the data.
+          }
+
+          continue;
+        }
+
+      case ROW_LENGTH:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 44
+          /* "," */
+          ) {
+              // Finished the rowLength, next we'll buffer up to that length.
+              rowState = ROW_CHUNK_BY_LENGTH;
+            } else {
+            rowLength = rowLength << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_CHUNK_BY_NEWLINE:
+        {
+          // We're looking for a newline
+          lastIdx = chunk.indexOf(10
+          /* "\n" */
+          , i);
+          break;
+        }
+
+      case ROW_CHUNK_BY_LENGTH:
+        {
+          // We're looking for the remaining byte length
+          lastIdx = i + rowLength;
+
+          if (lastIdx > chunk.length) {
+            lastIdx = -1;
+          }
+
+          break;
+        }
+    }
+
+    const offset = chunk.byteOffset + i;
+
+    if (lastIdx > -1) {
+      // We found the last chunk of the row
+      const length = lastIdx - i;
+      const lastChunk = new Uint8Array(chunk.buffer, offset, length);
+      processFullRow(response, rowID, rowTag, buffer, lastChunk); // Reset state machine for a new row
+
+      i = lastIdx;
+
+      if (rowState === ROW_CHUNK_BY_NEWLINE) {
+        // If we're trailing by a newline we need to skip it.
+        i++;
+      }
+
+      rowState = ROW_ID;
+      rowTag = 0;
+      rowID = 0;
+      rowLength = 0;
+      buffer.length = 0;
+    } else {
+      // The rest of this row is in a future chunk. We stash the rest of the
+      // current chunk until we can process the full row.
+      const length = chunk.byteLength - i;
+      const remainingSlice = new Uint8Array(chunk.buffer, offset, length);
+      buffer.push(remainingSlice); // Update how many bytes we're still waiting for. If we're looking for
+      // a newline, this doesn't hurt since we'll just ignore it.
+
+      rowLength -= remainingSlice.byteLength;
+      break;
+    }
+  }
+
+  response._rowState = rowState;
+  response._rowID = rowID;
+  response._rowTag = rowTag;
+  response._rowLength = rowLength;
+}
+
+function parseModel(response, json) {
+  return JSON.parse(json, response._fromJSON);
+}
+
+function createFromJSONCallback(response) {
+  // $FlowFixMe[missing-this-annot]
+  return function (key, value) {
+    if (typeof value === 'string') {
+      // We can't use .bind here because we need the "this" value.
+      return parseModelString(response, this, key, value);
+    }
+
+    if (typeof value === 'object' && value !== null) {
+      return parseModelTuple(response, value);
+    }
+
+    return value;
+  };
+}
+
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function noServerCall() {
+  throw new Error('Server Functions cannot be called during initial render. ' + 'This would create a fetch waterfall. Try to use a Server Component ' + 'to pass data to Client Components instead.');
+}
+
+function createServerReference(id, callServer) {
+  return createServerReference$1(id, noServerCall);
+}
+
+function createResponseFromOptions(options) {
+  return createResponse(options.ssrManifest.moduleMap, options.ssrManifest.moduleLoading, noServerCall, typeof options.nonce === 'string' ? options.nonce : undefined);
+}
+
+function startReadingFromStream(response, stream) {
+  const reader = stream.getReader();
+
+  function progress(_ref) {
+    let done = _ref.done,
+        value = _ref.value;
+
+    if (done) {
+      close(response);
+      return;
+    }
+
+    const buffer = value;
+    processBinaryChunk(response, buffer);
+    return reader.read().then(progress).catch(error);
+  }
+
+  function error(e) {
+    reportGlobalError(response, e);
+  }
+
+  reader.read().then(progress).catch(error);
+}
+
+function createFromReadableStream(stream, options) {
+  const response = createResponseFromOptions(options);
+  startReadingFromStream(response, stream);
+  return getRoot(response);
+}
+
+function createFromFetch(promiseForResponse, options) {
+  const response = createResponseFromOptions(options);
+  promiseForResponse.then(function (r) {
+    startReadingFromStream(response, r.body);
+  }, function (e) {
+    reportGlobalError(response, e);
+  });
+  return getRoot(response);
+}
+
+function encodeReply(value)
+/* We don't use URLSearchParams yet but maybe */
+{
+  return new Promise((resolve, reject) => {
+    processReply(value, '', resolve, reject);
+  });
+}
+
+exports.createFromFetch = createFromFetch;
+exports.createFromReadableStream = createFromReadableStream;
+exports.createServerReference = createServerReference;
+exports.encodeReply = encodeReply;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.edge.production.min.js b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.edge.production.min.js
index 8f4cfce467109..0903415e97b27 100644
--- a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.edge.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.edge.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-webpack-client.edge.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-webpack-client.edge.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var p=require("react-dom"),q=require("react"),r={stream:!0};function aa(a,b){if(a){var c=a[b[0]];if(a=c[b[2]])c=a.name;else{a=c["*"];if(!a)throw Error('Could not find the module "'+b[0]+'" in the React SSR Manifest. This is probably a bug in the React Server Components bundler.');c=b[2]}return 4===b.length?[a.id,a.chunks,c,1]:[a.id,a.chunks,c]}return b}var u=new Map;
 function v(a){var b=globalThis.__next_require__(a);if("function"!==typeof b.then||"fulfilled"===b.status)return null;b.then(function(c){b.status="fulfilled";b.value=c},function(c){b.status="rejected";b.reason=c});return b}function ba(){}
 function ca(a){for(var b=a[1],c=[],d=0;d<b.length;){var e=b[d++];b[d++];var g=u.get(e);if(void 0===g){g=__webpack_chunk_load__(e);c.push(g);var f=u.set.bind(u,e,null);g.then(f,ba);u.set(e,g)}else null!==g&&c.push(g)}return 4===a.length?0===c.length?v(a[0]):Promise.all(c).then(function(){return v(a[0])}):0<c.length?Promise.all(c):null}
@@ -43,3 +43,5 @@ function Y(a){var b=a.ssrManifest.moduleMap,c=a.ssrManifest.moduleLoading;a="str
 function Z(a,b){function c(g){var f=g.value;if(g.done)R(a,Error("Connection closed."));else{var l=0,h=a._rowState;g=a._rowID;for(var k=a._rowTag,n=a._rowLength,w=a._buffer,F=f.length;l<F;){var m=-1;switch(h){case 0:m=f[l++];58===m?h=1:g=g<<4|(96<m?m-87:m-48);continue;case 1:h=f[l];84===h||65===h||67===h||99===h||85===h||83===h||115===h||76===h||108===h||70===h||68===h||78===h||109===h||86===h?(k=h,h=2,l++):64<h&&91>h?(k=h,h=3,l++):(k=0,h=3);continue;case 2:m=f[l++];44===m?h=4:n=n<<4|(96<m?m-87:m-
 48);continue;case 3:m=f.indexOf(10,l);break;case 4:m=l+n,m>f.length&&(m=-1)}var t=f.byteOffset+l;if(-1<m)n=new Uint8Array(f.buffer,t,m-l),Ba(a,g,k,w,n),l=m,3===h&&l++,n=g=k=h=0,w.length=0;else{f=new Uint8Array(f.buffer,t,f.byteLength-l);w.push(f);n-=f.byteLength;break}}a._rowState=h;a._rowID=g;a._rowTag=k;a._rowLength=n;return e.read().then(c).catch(d)}}function d(g){R(a,g)}var e=b.getReader();e.read().then(c).catch(d)}
 exports.createFromFetch=function(a,b){var c=Y(b);a.then(function(d){Z(c,d.body)},function(d){R(c,d)});return S(c,0)};exports.createFromReadableStream=function(a,b){b=Y(b);Z(b,a);return S(b,0)};exports.createServerReference=function(a){return ta(a,X)};exports.encodeReply=function(a){return new Promise(function(b,c){D(a,"",b,c)})};
+
+//# sourceMappingURL=react-server-dom-webpack-client.edge.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.node.production.js b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.node.production.js
new file mode 100644
index 0000000000000..9c5f4defe9171
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.node.production.js
@@ -0,0 +1,1985 @@
+/**
+ * @license React
+ * react-server-dom-webpack-client.node.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var util = require('util');
+var ReactDOM = require('react-dom');
+var React = require('react');
+
+function createStringDecoder() {
+  return new util.TextDecoder();
+}
+const decoderOptions = {
+  stream: true
+};
+function readPartialStringChunk(decoder, buffer) {
+  return decoder.decode(buffer, decoderOptions);
+}
+function readFinalStringChunk(decoder, buffer) {
+  return decoder.decode(buffer);
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+// The reason this function needs to defined here in this file instead of just
+// being exported directly from the WebpackDestination... file is because the
+// ClientReferenceMetadata is opaque and we can't unwrap it there.
+// This should get inlined and we could also just implement an unwrapping function
+// though that risks it getting used in places it shouldn't be. This is unfortunate
+// but currently it seems to be the best option we have.
+
+function prepareDestinationForModule(moduleLoading, nonce, metadata) {
+  prepareDestinationWithChunks(moduleLoading, metadata[CHUNKS], nonce);
+}
+function resolveClientReference(bundlerConfig, metadata) {
+  if (bundlerConfig) {
+    const moduleExports = bundlerConfig[metadata[ID]];
+    let resolvedModuleData = moduleExports[metadata[NAME]];
+    let name;
+
+    if (resolvedModuleData) {
+      // The potentially aliased name.
+      name = resolvedModuleData.name;
+    } else {
+      // If we don't have this specific name, we might have the full module.
+      resolvedModuleData = moduleExports['*'];
+
+      if (!resolvedModuleData) {
+        throw new Error('Could not find the module "' + metadata[ID] + '" in the React SSR Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+      }
+
+      name = metadata[NAME];
+    }
+
+    if (isAsyncImport(metadata)) {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1
+      /* async */
+      ];
+    } else {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+    }
+  }
+
+  return metadata;
+}
+// If they're still pending they're a thenable. This map also exists
+// in Webpack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = globalThis.__next_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+  let i = 0;
+
+  while (i < chunks.length) {
+    const chunkId = chunks[i++];
+    chunks[i++];
+    const entry = chunkCache.get(chunkId);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkId);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkId, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkId, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = globalThis.__next_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+function loadChunk(chunkId, filename) {
+  return __webpack_chunk_load__(chunkId);
+}
+
+function prepareDestinationWithChunks(moduleLoading, // Chunks are double-indexed [..., idx, filenamex, idy, filenamey, ...]
+chunks, nonce) {
+  if (moduleLoading !== null) {
+    for (let i = 1; i < chunks.length; i += 2) {
+      preinitScriptForSSR(moduleLoading.prefix + chunks[i], nonce, moduleLoading.crossOrigin);
+    }
+  }
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// This client file is in the shared folder because it applies to both SSR and browser contexts.
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function dispatchHint(code, model) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    switch (code) {
+      case 'D':
+        {
+          const refined = refineModel(code, model);
+          const href = refined;
+          dispatcher.prefetchDNS(href);
+          return;
+        }
+
+      case 'C':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preconnect(href);
+          } else {
+            const href = refined[0];
+            const crossOrigin = refined[1];
+            dispatcher.preconnect(href, crossOrigin);
+          }
+
+          return;
+        }
+
+      case 'L':
+        {
+          const refined = refineModel(code, model);
+          const href = refined[0];
+          const as = refined[1];
+
+          if (refined.length === 3) {
+            const options = refined[2];
+            dispatcher.preload(href, as, options);
+          } else {
+            dispatcher.preload(href, as);
+          }
+
+          return;
+        }
+
+      case 'm':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preloadModule(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preloadModule(href, options);
+          }
+
+          return;
+        }
+
+      case 'S':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitStyle(href);
+          } else {
+            const href = refined[0];
+            const precedence = refined[1] === 0 ? undefined : refined[1];
+            const options = refined.length === 3 ? refined[2] : undefined;
+            dispatcher.preinitStyle(href, precedence, options);
+          }
+
+          return;
+        }
+
+      case 'X':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitScript(href, options);
+          }
+
+          return;
+        }
+
+      case 'M':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitModuleScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitModuleScript(href, options);
+          }
+
+          return;
+        }
+    }
+  }
+} // Flow is having troulbe refining the HintModels so we help it a bit.
+// This should be compiled out in the production build.
+
+function refineModel(code, model) {
+  return model;
+}
+function preinitScriptForSSR(href, nonce, crossOrigin) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    dispatcher.preinitScript(href, {
+      crossOrigin: getCrossOriginString(crossOrigin),
+      nonce
+    });
+  }
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+const ObjectPrototype = Object.prototype;
+const knownServerReferences = new WeakMap(); // Serializable values
+// Thenable<ReactServerValue>
+// function serializeByValueID(id: number): string {
+//   return '$' + id.toString(16);
+// }
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeFormDataReference(id) {
+  // Why K? F is "Function". D is "Date". What else?
+  return '$K' + id.toString(16);
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeMapID(id) {
+  return '$Q' + id.toString(16);
+}
+
+function serializeSetID(id) {
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+
+function processReply(root, formFieldPrefix, resolve, reject) {
+  let nextPartId = 1;
+  let pendingParts = 0;
+  let formData = null;
+
+  function resolveToJSON(key, value) {
+    const parent = this; // Make sure that `parent[key]` wasn't JSONified before `value` was passed to us
+
+    if (value === null) {
+      return null;
+    }
+
+    if (typeof value === 'object') {
+      // $FlowFixMe[method-unbinding]
+      if (typeof value.then === 'function') {
+        // We assume that any object with a .then property is a "Thenable" type,
+        // or a Promise type. Either of which can be represented by a Promise.
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        }
+
+        pendingParts++;
+        const promiseId = nextPartId++;
+        const thenable = value;
+        thenable.then(partValue => {
+          const partJSON = JSON.stringify(partValue, resolveToJSON); // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
+
+          const data = formData; // eslint-disable-next-line react-internal/safe-string-coercion
+
+          data.append(formFieldPrefix + promiseId, partJSON);
+          pendingParts--;
+
+          if (pendingParts === 0) {
+            resolve(data);
+          }
+        }, reason => {
+          // In the future we could consider serializing this as an error
+          // that throws on the server instead.
+          reject(reason);
+        });
+        return serializePromiseID(promiseId);
+      }
+
+      if (isArray(value)) {
+        // $FlowFixMe[incompatible-return]
+        return value;
+      } // TODO: Should we the Object.prototype.toString.call() to test for cross-realm objects?
+
+
+      if (value instanceof FormData) {
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to use rich objects as its values.
+          formData = new FormData();
+        }
+
+        const data = formData;
+        const refId = nextPartId++; // Copy all the form fields with a prefix for this reference.
+        // These must come first in the form order because we assume that all the
+        // fields are available before this is referenced.
+
+        const prefix = formFieldPrefix + refId + '_'; // $FlowFixMe[prop-missing]: FormData has forEach.
+
+        value.forEach((originalValue, originalKey) => {
+          data.append(prefix + originalKey, originalValue);
+        });
+        return serializeFormDataReference(refId);
+      }
+
+      if (value instanceof Map) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const mapId = nextPartId++;
+        formData.append(formFieldPrefix + mapId, partJSON);
+        return serializeMapID(mapId);
+      }
+
+      if (value instanceof Set) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const setId = nextPartId++;
+        formData.append(formFieldPrefix + setId, partJSON);
+        return serializeSetID(setId);
+      }
+
+      const iteratorFn = getIteratorFn(value);
+
+      if (iteratorFn) {
+        return Array.from(value);
+      } // Verify that this is a simple plain object.
+
+
+      const proto = getPrototypeOf(value);
+
+      if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+        throw new Error('Only plain objects, and a few built-ins, can be passed to Server Actions. ' + 'Classes or null prototypes are not supported.');
+      }
+
+
+      return value;
+    }
+
+    if (typeof value === 'string') {
+      // TODO: Maybe too clever. If we support URL there's no similar trick.
+      if (value[value.length - 1] === 'Z') {
+        // Possibly a Date, whose toJSON automatically calls toISOString
+        // $FlowFixMe[incompatible-use]
+        const originalValue = parent[key];
+
+        if (originalValue instanceof Date) {
+          return serializeDateFromDateJSON(value);
+        }
+      }
+
+      return escapeStringValue(value);
+    }
+
+    if (typeof value === 'boolean') {
+      return value;
+    }
+
+    if (typeof value === 'number') {
+      return serializeNumber(value);
+    }
+
+    if (typeof value === 'undefined') {
+      return serializeUndefined();
+    }
+
+    if (typeof value === 'function') {
+      const metaData = knownServerReferences.get(value);
+
+      if (metaData !== undefined) {
+        const metaDataJSON = JSON.stringify(metaData, resolveToJSON);
+
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        } // The reference to this function came from the same client so we can pass it back.
+
+
+        const refId = nextPartId++; // eslint-disable-next-line react-internal/safe-string-coercion
+
+        formData.set(formFieldPrefix + refId, metaDataJSON);
+        return serializeServerReferenceID(refId);
+      }
+
+      throw new Error('Client Functions cannot be passed directly to Server Functions. ' + 'Only Functions passed from the Server can be passed back again.');
+    }
+
+    if (typeof value === 'symbol') {
+      // $FlowFixMe[incompatible-type] `description` might be undefined
+      const name = value.description;
+
+      if (Symbol.for(name) !== value) {
+        throw new Error('Only global symbols received from Symbol.for(...) can be passed to Server Functions. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+        value.description + ") cannot be found among global symbols."));
+      }
+
+      return serializeSymbolReference(name);
+    }
+
+    if (typeof value === 'bigint') {
+      return serializeBigInt(value);
+    }
+
+    throw new Error("Type " + typeof value + " is not supported as an argument to a Server Function.");
+  } // $FlowFixMe[incompatible-type] it's not going to be undefined because we'll encode it.
+
+
+  const json = JSON.stringify(root, resolveToJSON);
+
+  if (formData === null) {
+    // If it's a simple data structure, we just use plain JSON.
+    resolve(json);
+  } else {
+    // Otherwise, we use FormData to let us stream in the result.
+    formData.set(formFieldPrefix + '0', json);
+
+    if (pendingParts === 0) {
+      // $FlowFixMe[incompatible-call] this has already been refined.
+      resolve(formData);
+    }
+  }
+}
+const boundCache = new WeakMap();
+
+function encodeFormData(reference) {
+  let resolve, reject; // We need to have a handle on the thenable so that we can synchronously set
+  // its status from processReply, when it can complete synchronously.
+
+  const thenable = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  processReply(reference, '', body => {
+    if (typeof body === 'string') {
+      const data = new FormData();
+      data.append('0', body);
+      body = data;
+    }
+
+    const fulfilled = thenable;
+    fulfilled.status = 'fulfilled';
+    fulfilled.value = body;
+    resolve(body);
+  }, e => {
+    const rejected = thenable;
+    rejected.status = 'rejected';
+    rejected.reason = e;
+    reject(e);
+  });
+  return thenable;
+}
+
+function encodeFormAction(identifierPrefix) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  let data = null;
+  let name;
+  const boundPromise = reference.bound;
+
+  if (boundPromise !== null) {
+    let thenable = boundCache.get(reference);
+
+    if (!thenable) {
+      thenable = encodeFormData(reference);
+      boundCache.set(reference, thenable);
+    }
+
+    if (thenable.status === 'rejected') {
+      throw thenable.reason;
+    } else if (thenable.status !== 'fulfilled') {
+      throw thenable;
+    }
+
+    const encodedFormData = thenable.value; // This is hacky but we need the identifier prefix to be added to
+    // all fields but the suspense cache would break since we might get
+    // a new identifier each time. So we just append it at the end instead.
+
+    const prefixedData = new FormData(); // $FlowFixMe[prop-missing]
+
+    encodedFormData.forEach((value, key) => {
+      prefixedData.append('$ACTION_' + identifierPrefix + ':' + key, value);
+    });
+    data = prefixedData; // We encode the name of the prefix containing the data.
+
+    name = '$ACTION_REF_' + identifierPrefix;
+  } else {
+    // This is the simple case so we can just encode the ID.
+    name = '$ACTION_ID_' + reference.id;
+  }
+
+  return {
+    name: name,
+    method: 'POST',
+    encType: 'multipart/form-data',
+    data: data
+  };
+}
+
+function isSignatureEqual(referenceId, numberOfBoundArgs) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  if (reference.id !== referenceId) {
+    // These are different functions.
+    return false;
+  } // Now check if the number of bound arguments is the same.
+
+
+  const boundPromise = reference.bound;
+
+  if (boundPromise === null) {
+    // No bound arguments.
+    return numberOfBoundArgs === 0;
+  } // Unwrap the bound arguments array by suspending, if necessary. As with
+  // encodeFormData, this means isSignatureEqual can only be called while React
+  // is rendering.
+
+
+  switch (boundPromise.status) {
+    case 'fulfilled':
+      {
+        const boundArgs = boundPromise.value;
+        return boundArgs.length === numberOfBoundArgs;
+      }
+
+    case 'pending':
+      {
+        throw boundPromise;
+      }
+
+    case 'rejected':
+      {
+        throw boundPromise.reason;
+      }
+
+    default:
+      {
+        if (typeof boundPromise.status === 'string') ; else {
+          const pendingThenable = boundPromise;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(boundArgs => {
+            const fulfilledThenable = boundPromise;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = boundArgs;
+          }, error => {
+            const rejectedThenable = boundPromise;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          });
+        }
+
+        throw boundPromise;
+      }
+  }
+}
+
+function registerServerReference(proxy, reference) {
+  // Expose encoder for use by SSR, as well as a special bind that can be used to
+  // keep server capabilities.
+  {
+    // Only expose this in builds that would actually use it. Not needed on the client.
+    Object.defineProperties(proxy, {
+      $$FORM_ACTION: {
+        value: encodeFormAction
+      },
+      $$IS_SIGNATURE_EQUAL: {
+        value: isSignatureEqual
+      },
+      bind: {
+        value: bind
+      }
+    });
+  }
+
+  knownServerReferences.set(proxy, reference);
+} // $FlowFixMe[method-unbinding]
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+  const reference = knownServerReferences.get(this);
+
+  if (reference) {
+    const args = ArraySlice.call(arguments, 1);
+    let boundPromise = null;
+
+    if (reference.bound !== null) {
+      boundPromise = Promise.resolve(reference.bound).then(boundArgs => boundArgs.concat(args));
+    } else {
+      boundPromise = Promise.resolve(args);
+    }
+
+    registerServerReference(newFn, {
+      id: reference.id,
+      bound: boundPromise
+    });
+  }
+
+  return newFn;
+}
+
+function createServerReference$1(id, callServer) {
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    return callServer(id, args);
+  };
+
+  registerServerReference(proxy, {
+    id,
+    bound: null
+  });
+  return proxy;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ROW_ID = 0;
+const ROW_TAG = 1;
+const ROW_LENGTH = 2;
+const ROW_CHUNK_BY_NEWLINE = 3;
+const ROW_CHUNK_BY_LENGTH = 4;
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const CYCLIC = 'cyclic';
+const RESOLVED_MODEL = 'resolved_model';
+const RESOLVED_MODULE = 'resolved_module';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function readChunk(chunk) {
+  // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      return chunk.value;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      // eslint-disable-next-line no-throw-literal
+      throw chunk;
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function createBlockedChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(BLOCKED, null, null, response);
+}
+
+function createErrorChunk(response, error) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(ERRORED, null, error, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function createResolvedModuleChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODULE, value, null, response);
+}
+
+function createInitializedTextChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function createInitializedBufferChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function resolveModuleChunk(chunk, value) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODULE;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    initializeModuleChunk(resolvedChunk);
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+  const resolvedModel = chunk.value; // We go to the CYCLIC state until we've fully resolved this.
+  // We do this before parsing in case we try to initialize the same chunk
+  // while parsing the model. Such as in a cyclic reference.
+
+  const cyclicChunk = chunk;
+  cyclicChunk.status = CYCLIC;
+  cyclicChunk.value = null;
+  cyclicChunk.reason = null;
+
+  try {
+    const value = parseModel(chunk._response, resolvedModel);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const resolveListeners = cyclicChunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, value);
+      }
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+}
+
+function initializeModuleChunk(chunk) {
+  try {
+    const value = requireModule(chunk.value);
+    const initializedChunk = chunk;
+    initializedChunk.status = INITIALIZED;
+    initializedChunk.value = value;
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function createElement(type, key, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: null,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: null
+  };
+
+  return element;
+}
+
+function createLazyChunkWrapper(chunk) {
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: chunk,
+    _init: readChunk
+  };
+  return lazyType;
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunk = createPendingChunk(response);
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key, cyclic) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+
+    if (!cyclic) {
+      blocked.deps++;
+    }
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: cyclic ? 0 : 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function createServerReferenceProxy(response, metaData) {
+  const callServer = response._callServer;
+
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    const p = metaData.bound;
+
+    if (!p) {
+      return callServer(metaData.id, args);
+    }
+
+    if (p.status === INITIALIZED) {
+      const bound = p.value;
+      return callServer(metaData.id, bound.concat(args));
+    } // Since this is a fake Promise whose .then doesn't chain, we have to wrap it.
+    // TODO: Remove the wrapper once that's fixed.
+
+
+    return Promise.resolve(p).then(function (bound) {
+      return callServer(metaData.id, bound.concat(args));
+    });
+  };
+
+  registerServerReference(proxy, metaData);
+  return proxy;
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      {
+        return chunk.value;
+      }
+    // We always encode it first in the stream so it won't be pending.
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    if (value === '$') {
+      // A very common symbol.
+      return REACT_ELEMENT_TYPE;
+    }
+
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case 'L':
+        {
+          // Lazy node
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id); // We create a React.lazy wrapper around any lazy values.
+          // When passed into React, we'll know how to suspend on this.
+
+          return createLazyChunkWrapper(chunk);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'P':
+        {
+          // Server Context Provider
+          return getOrCreateServerContext(value.slice(2)).Provider;
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16);
+          const metadata = getOutlinedModel(response, id);
+          return createServerReferenceProxy(response, metadata);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+
+            case RESOLVED_MODULE:
+              initializeModuleChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+            case CYCLIC:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key, chunk.status === CYCLIC), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function parseModelTuple(response, value) {
+  const tuple = value;
+
+  if (tuple[0] === REACT_ELEMENT_TYPE) {
+    // TODO: Consider having React just directly accept these arrays as elements.
+    // Or even change the ReactElement type to be an array.
+    return createElement(tuple[1], tuple[2], tuple[3]);
+  }
+
+  return value;
+}
+
+function missingCall() {
+  throw new Error('Trying to call a function from "use server" but the callServer option ' + 'was not implemented in your router runtime.');
+}
+
+function createResponse(bundlerConfig, moduleLoading, callServer, nonce) {
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _moduleLoading: moduleLoading,
+    _callServer: callServer !== undefined ? callServer : missingCall,
+    _nonce: nonce,
+    _chunks: chunks,
+    _stringDecoder: createStringDecoder(),
+    _fromJSON: null,
+    _rowState: 0,
+    _rowID: 0,
+    _rowTag: 0,
+    _rowLength: 0,
+    _buffer: []
+  }; // Don't inline this call because it causes closure to outline the call above.
+
+  response._fromJSON = createFromJSONCallback(response);
+  return response;
+}
+
+function resolveModel(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createResolvedModelChunk(response, model));
+  } else {
+    resolveModelChunk(chunk, model);
+  }
+}
+
+function resolveText(response, id, text) {
+  const chunks = response._chunks; // We assume that we always reference large strings after they've been
+  // emitted.
+
+  chunks.set(id, createInitializedTextChunk(response, text));
+}
+
+function resolveBuffer(response, id, buffer) {
+  const chunks = response._chunks; // We assume that we always reference buffers after they've been emitted.
+
+  chunks.set(id, createInitializedBufferChunk(response, buffer));
+}
+
+function resolveModule(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+  const clientReferenceMetadata = parseModel(response, model);
+  const clientReference = resolveClientReference(response._bundlerConfig, clientReferenceMetadata);
+  prepareDestinationForModule(response._moduleLoading, response._nonce, clientReferenceMetadata); // TODO: Add an option to encode modules that are lazy loaded.
+  // For now we preload all modules as early as possible since it's likely
+  // that we'll need them.
+
+  const promise = preloadModule(clientReference);
+
+  if (promise) {
+    let blockedChunk;
+
+    if (!chunk) {
+      // Technically, we should just treat promise as the chunk in this
+      // case. Because it'll just behave as any other promise.
+      blockedChunk = createBlockedChunk(response);
+      chunks.set(id, blockedChunk);
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+    }
+
+    promise.then(() => resolveModuleChunk(blockedChunk, clientReference), error => triggerErrorOnChunk(blockedChunk, error));
+  } else {
+    if (!chunk) {
+      chunks.set(id, createResolvedModuleChunk(response, clientReference));
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      resolveModuleChunk(chunk, clientReference);
+    }
+  }
+}
+
+function resolveErrorProd(response, id, digest) {
+
+  const error = new Error('An error occurred in the Server Components render. The specific message is omitted in production' + ' builds to avoid leaking sensitive details. A digest property is included on this error instance which' + ' may provide additional details about the nature of the error.');
+  error.stack = 'Error: ' + error.message;
+  error.digest = digest;
+  const errorWithDigest = error;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, errorWithDigest));
+  } else {
+    triggerErrorOnChunk(chunk, errorWithDigest);
+  }
+}
+
+function resolvePostponeProd(response, id) {
+
+  const error = new Error('A Server Component was postponed. The reason is omitted in production' + ' builds to avoid leaking sensitive details.');
+  const postponeInstance = error;
+  postponeInstance.$$typeof = REACT_POSTPONE_TYPE;
+  postponeInstance.stack = 'Error: ' + error.message;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, postponeInstance));
+  } else {
+    triggerErrorOnChunk(chunk, postponeInstance);
+  }
+}
+
+function resolveHint(response, code, model) {
+  const hintModel = parseModel(response, model);
+  dispatchHint(code, hintModel);
+}
+
+function mergeBuffer(buffer, lastChunk) {
+  const l = buffer.length; // Count the bytes we'll need
+
+  let byteLength = lastChunk.length;
+
+  for (let i = 0; i < l; i++) {
+    byteLength += buffer[i].byteLength;
+  } // Allocate enough contiguous space
+
+
+  const result = new Uint8Array(byteLength);
+  let offset = 0; // Copy all the buffers into it.
+
+  for (let i = 0; i < l; i++) {
+    const chunk = buffer[i];
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+
+  result.set(lastChunk, offset);
+  return result;
+}
+
+function resolveTypedArray(response, id, buffer, lastChunk, constructor, bytesPerElement) {
+  // If the view fits into one original buffer, we just reuse that buffer instead of
+  // copying it out to a separate copy. This means that it's not always possible to
+  // transfer these values to other threads without copying first since they may
+  // share array buffer. For this to work, it must also have bytes aligned to a
+  // multiple of a size of the type.
+  const chunk = buffer.length === 0 && lastChunk.byteOffset % bytesPerElement === 0 ? lastChunk : mergeBuffer(buffer, lastChunk); // TODO: The transfer protocol of RSC is little-endian. If the client isn't little-endian
+  // we should convert it instead. In practice big endian isn't really Web compatible so it's
+  // somewhat safe to assume that browsers aren't going to run it, but maybe there's some SSR
+  // server that's affected.
+
+  const view = new constructor(chunk.buffer, chunk.byteOffset, chunk.byteLength / bytesPerElement);
+  resolveBuffer(response, id, view);
+}
+
+function processFullRow(response, id, tag, buffer, chunk) {
+  {
+    switch (tag) {
+      case 65
+      /* "A" */
+      :
+        // We must always clone to extract it into a separate buffer instead of just a view.
+        resolveBuffer(response, id, mergeBuffer(buffer, chunk).buffer);
+        return;
+
+      case 67
+      /* "C" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int8Array, 1);
+        return;
+
+      case 99
+      /* "c" */
+      :
+        resolveBuffer(response, id, buffer.length === 0 ? chunk : mergeBuffer(buffer, chunk));
+        return;
+
+      case 85
+      /* "U" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint8ClampedArray, 1);
+        return;
+
+      case 83
+      /* "S" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int16Array, 2);
+        return;
+
+      case 115
+      /* "s" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint16Array, 2);
+        return;
+
+      case 76
+      /* "L" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int32Array, 4);
+        return;
+
+      case 108
+      /* "l" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint32Array, 4);
+        return;
+
+      case 70
+      /* "F" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Float32Array, 4);
+        return;
+
+      case 68
+      /* "D" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Float64Array, 8);
+        return;
+
+      case 78
+      /* "N" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, BigInt64Array, 8);
+        return;
+
+      case 109
+      /* "m" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, BigUint64Array, 8);
+        return;
+
+      case 86
+      /* "V" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, DataView, 1);
+        return;
+    }
+  }
+
+  const stringDecoder = response._stringDecoder;
+  let row = '';
+
+  for (let i = 0; i < buffer.length; i++) {
+    row += readPartialStringChunk(stringDecoder, buffer[i]);
+  }
+
+  row += readFinalStringChunk(stringDecoder, chunk);
+
+  switch (tag) {
+    case 73
+    /* "I" */
+    :
+      {
+        resolveModule(response, id, row);
+        return;
+      }
+
+    case 72
+    /* "H" */
+    :
+      {
+        const code = row[0];
+        resolveHint(response, code, row.slice(1));
+        return;
+      }
+
+    case 69
+    /* "E" */
+    :
+      {
+        const errorInfo = JSON.parse(row);
+
+        {
+          resolveErrorProd(response, id, errorInfo.digest);
+        }
+
+        return;
+      }
+
+    case 84
+    /* "T" */
+    :
+      {
+        resolveText(response, id, row);
+        return;
+      }
+
+    case 80
+    /* "P" */
+    :
+      {
+        {
+          {
+            resolvePostponeProd(response, id);
+          }
+
+          return;
+        }
+      }
+    // Fallthrough
+
+    default:
+      /* """ "{" "[" "t" "f" "n" "0" - "9" */
+      {
+        // We assume anything else is JSON.
+        resolveModel(response, id, row);
+        return;
+      }
+  }
+}
+
+function processBinaryChunk(response, chunk) {
+  let i = 0;
+  let rowState = response._rowState;
+  let rowID = response._rowID;
+  let rowTag = response._rowTag;
+  let rowLength = response._rowLength;
+  const buffer = response._buffer;
+  const chunkLength = chunk.length;
+
+  while (i < chunkLength) {
+    let lastIdx = -1;
+
+    switch (rowState) {
+      case ROW_ID:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 58
+          /* ":" */
+          ) {
+              // Finished the rowID, next we'll parse the tag.
+              rowState = ROW_TAG;
+            } else {
+            rowID = rowID << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_TAG:
+        {
+          const resolvedRowTag = chunk[i];
+
+          if (resolvedRowTag === 84
+          /* "T" */
+          || (resolvedRowTag === 65
+          /* "A" */
+          || resolvedRowTag === 67
+          /* "C" */
+          || resolvedRowTag === 99
+          /* "c" */
+          || resolvedRowTag === 85
+          /* "U" */
+          || resolvedRowTag === 83
+          /* "S" */
+          || resolvedRowTag === 115
+          /* "s" */
+          || resolvedRowTag === 76
+          /* "L" */
+          || resolvedRowTag === 108
+          /* "l" */
+          || resolvedRowTag === 70
+          /* "F" */
+          || resolvedRowTag === 68
+          /* "D" */
+          || resolvedRowTag === 78
+          /* "N" */
+          || resolvedRowTag === 109
+          /* "m" */
+          || resolvedRowTag === 86)
+          /* "V" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_LENGTH;
+              i++;
+            } else if (resolvedRowTag > 64 && resolvedRowTag < 91
+          /* "A"-"Z" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_CHUNK_BY_NEWLINE;
+              i++;
+            } else {
+            rowTag = 0;
+            rowState = ROW_CHUNK_BY_NEWLINE; // This was an unknown tag so it was probably part of the data.
+          }
+
+          continue;
+        }
+
+      case ROW_LENGTH:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 44
+          /* "," */
+          ) {
+              // Finished the rowLength, next we'll buffer up to that length.
+              rowState = ROW_CHUNK_BY_LENGTH;
+            } else {
+            rowLength = rowLength << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_CHUNK_BY_NEWLINE:
+        {
+          // We're looking for a newline
+          lastIdx = chunk.indexOf(10
+          /* "\n" */
+          , i);
+          break;
+        }
+
+      case ROW_CHUNK_BY_LENGTH:
+        {
+          // We're looking for the remaining byte length
+          lastIdx = i + rowLength;
+
+          if (lastIdx > chunk.length) {
+            lastIdx = -1;
+          }
+
+          break;
+        }
+    }
+
+    const offset = chunk.byteOffset + i;
+
+    if (lastIdx > -1) {
+      // We found the last chunk of the row
+      const length = lastIdx - i;
+      const lastChunk = new Uint8Array(chunk.buffer, offset, length);
+      processFullRow(response, rowID, rowTag, buffer, lastChunk); // Reset state machine for a new row
+
+      i = lastIdx;
+
+      if (rowState === ROW_CHUNK_BY_NEWLINE) {
+        // If we're trailing by a newline we need to skip it.
+        i++;
+      }
+
+      rowState = ROW_ID;
+      rowTag = 0;
+      rowID = 0;
+      rowLength = 0;
+      buffer.length = 0;
+    } else {
+      // The rest of this row is in a future chunk. We stash the rest of the
+      // current chunk until we can process the full row.
+      const length = chunk.byteLength - i;
+      const remainingSlice = new Uint8Array(chunk.buffer, offset, length);
+      buffer.push(remainingSlice); // Update how many bytes we're still waiting for. If we're looking for
+      // a newline, this doesn't hurt since we'll just ignore it.
+
+      rowLength -= remainingSlice.byteLength;
+      break;
+    }
+  }
+
+  response._rowState = rowState;
+  response._rowID = rowID;
+  response._rowTag = rowTag;
+  response._rowLength = rowLength;
+}
+
+function parseModel(response, json) {
+  return JSON.parse(json, response._fromJSON);
+}
+
+function createFromJSONCallback(response) {
+  // $FlowFixMe[missing-this-annot]
+  return function (key, value) {
+    if (typeof value === 'string') {
+      // We can't use .bind here because we need the "this" value.
+      return parseModelString(response, this, key, value);
+    }
+
+    if (typeof value === 'object' && value !== null) {
+      return parseModelTuple(response, value);
+    }
+
+    return value;
+  };
+}
+
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function noServerCall() {
+  throw new Error('Server Functions cannot be called during initial render. ' + 'This would create a fetch waterfall. Try to use a Server Component ' + 'to pass data to Client Components instead.');
+}
+
+function createServerReference(id, callServer) {
+  return createServerReference$1(id, noServerCall);
+}
+
+function createFromNodeStream(stream, ssrManifest, options) {
+  const response = createResponse(ssrManifest.moduleMap, ssrManifest.moduleLoading, noServerCall, options && typeof options.nonce === 'string' ? options.nonce : undefined);
+  stream.on('data', chunk => {
+    processBinaryChunk(response, chunk);
+  });
+  stream.on('error', error => {
+    reportGlobalError(response, error);
+  });
+  stream.on('end', () => close(response));
+  return getRoot(response);
+}
+
+exports.createFromNodeStream = createFromNodeStream;
+exports.createServerReference = createServerReference;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.node.production.min.js b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.node.production.min.js
index e8be4a860a64c..8312592dfd98f 100644
--- a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.node.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.node.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-webpack-client.node.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-webpack-client.node.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var n=require("util"),q=require("react-dom"),r=require("react"),u={stream:!0};function v(a,b){if(a){var c=a[b[0]];if(a=c[b[2]])c=a.name;else{a=c["*"];if(!a)throw Error('Could not find the module "'+b[0]+'" in the React SSR Manifest. This is probably a bug in the React Server Components bundler.');c=b[2]}return 4===b.length?[a.id,a.chunks,c,1]:[a.id,a.chunks,c]}return b}var w=new Map;
 function x(a){var b=globalThis.__next_require__(a);if("function"!==typeof b.then||"fulfilled"===b.status)return null;b.then(function(c){b.status="fulfilled";b.value=c},function(c){b.status="rejected";b.reason=c});return b}function y(){}
 function aa(a){for(var b=a[1],c=[],d=0;d<b.length;){var e=b[d++];b[d++];var g=w.get(e);if(void 0===g){g=__webpack_chunk_load__(e);c.push(g);var f=w.set.bind(w,e,null);g.then(f,y);w.set(e,g)}else null!==g&&c.push(g)}return 4===a.length?0===c.length?x(a[0]):Promise.all(c).then(function(){return x(a[0])}):0<c.length?Promise.all(c):null}
@@ -43,3 +43,5 @@ f.stack="Error: "+f.message;f.digest=c;c=a._chunks;(d=c.get(b))?P(d,f):c.set(b,n
 exports.createFromNodeStream=function(a,b,c){var d=za(b.moduleMap,b.moduleLoading,Z,c&&"string"===typeof c.nonce?c.nonce:void 0);a.on("data",function(e){for(var g=0,f=d._rowState,l=d._rowID,k=d._rowTag,h=d._rowLength,t=d._buffer,F=e.length;g<F;){var m=-1;switch(f){case 0:m=e[g++];58===m?f=1:l=l<<4|(96<m?m-87:m-48);continue;case 1:f=e[g];84===f||65===f||67===f||99===f||85===f||83===f||115===f||76===f||108===f||70===f||68===f||78===f||109===f||86===f?(k=f,f=2,g++):64<f&&91>f?(k=f,f=3,g++):(k=0,f=3);
 continue;case 2:m=e[g++];44===m?f=4:h=h<<4|(96<m?m-87:m-48);continue;case 3:m=e.indexOf(10,g);break;case 4:m=g+h,m>e.length&&(m=-1)}var p=e.byteOffset+g;if(-1<m)h=new Uint8Array(e.buffer,p,m-g),Ca(d,l,k,t,h),g=m,3===f&&g++,h=l=k=f=0,t.length=0;else{e=new Uint8Array(e.buffer,p,e.byteLength-g);t.push(e);h-=e.byteLength;break}}d._rowState=f;d._rowID=l;d._rowTag=k;d._rowLength=h});a.on("error",function(e){T(d,e)});a.on("end",function(){T(d,Error("Connection closed."))});return U(d,0)};
 exports.createServerReference=function(a){return sa(a,Z)};
+
+//# sourceMappingURL=react-server-dom-webpack-client.node.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.node.unbundled.production.js b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.node.unbundled.production.js
new file mode 100644
index 0000000000000..529563cdbf3ea
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.node.unbundled.production.js
@@ -0,0 +1,1938 @@
+/**
+ * @license React
+ * react-server-dom-webpack-client.node.unbundled.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var util = require('util');
+var ReactDOM = require('react-dom');
+var React = require('react');
+
+function createStringDecoder() {
+  return new util.TextDecoder();
+}
+const decoderOptions = {
+  stream: true
+};
+function readPartialStringChunk(decoder, buffer) {
+  return decoder.decode(buffer, decoderOptions);
+}
+function readFinalStringChunk(decoder, buffer) {
+  return decoder.decode(buffer);
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+// The reason this function needs to defined here in this file instead of just
+// being exported directly from the WebpackDestination... file is because the
+// ClientReferenceMetadata is opaque and we can't unwrap it there.
+// This should get inlined and we could also just implement an unwrapping function
+// though that risks it getting used in places it shouldn't be. This is unfortunate
+// but currently it seems to be the best option we have.
+
+function prepareDestinationForModule(moduleLoading, nonce, metadata) {
+  prepareDestinationWithChunks(moduleLoading, metadata[CHUNKS], nonce);
+}
+function resolveClientReference(bundlerConfig, metadata) {
+  const moduleExports = bundlerConfig[metadata[ID]];
+  let resolvedModuleData = moduleExports[metadata[NAME]];
+  let name;
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // If we don't have this specific name, we might have the full module.
+    resolvedModuleData = moduleExports['*'];
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + metadata[ID] + '" in the React SSR Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+
+    name = metadata[NAME];
+  }
+
+  return {
+    specifier: resolvedModuleData.specifier,
+    name: name,
+    async: isAsyncImport(metadata)
+  };
+}
+const asyncModuleCache = new Map();
+function preloadModule(metadata) {
+  const existingPromise = asyncModuleCache.get(metadata.specifier);
+
+  if (existingPromise) {
+    if (existingPromise.status === 'fulfilled') {
+      return null;
+    }
+
+    return existingPromise;
+  } else {
+    // $FlowFixMe[unsupported-syntax]
+    let modulePromise = import(metadata.specifier);
+
+    if (metadata.async) {
+      // If the module is async, it must have been a CJS module.
+      // CJS modules are accessed through the default export in
+      // Node.js so we have to get the default export to get the
+      // full module exports.
+      modulePromise = modulePromise.then(function (value) {
+        return value.default;
+      });
+    }
+
+    modulePromise.then(value => {
+      const fulfilledThenable = modulePromise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = modulePromise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    asyncModuleCache.set(metadata.specifier, modulePromise);
+    return modulePromise;
+  }
+}
+function requireModule(metadata) {
+  let moduleExports; // We assume that preloadModule has been called before, which
+  // should have added something to the module cache.
+
+  const promise = asyncModuleCache.get(metadata.specifier);
+
+  if (promise.status === 'fulfilled') {
+    moduleExports = promise.value;
+  } else {
+    throw promise.reason;
+  }
+
+  if (metadata.name === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata.name === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.default;
+  }
+
+  return moduleExports[metadata.name];
+}
+
+function prepareDestinationWithChunks(moduleLoading, // Chunks are double-indexed [..., idx, filenamex, idy, filenamey, ...]
+chunks, nonce) {
+  if (moduleLoading !== null) {
+    for (let i = 1; i < chunks.length; i += 2) {
+      preinitScriptForSSR(moduleLoading.prefix + chunks[i], nonce, moduleLoading.crossOrigin);
+    }
+  }
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// This client file is in the shared folder because it applies to both SSR and browser contexts.
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function dispatchHint(code, model) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    switch (code) {
+      case 'D':
+        {
+          const refined = refineModel(code, model);
+          const href = refined;
+          dispatcher.prefetchDNS(href);
+          return;
+        }
+
+      case 'C':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preconnect(href);
+          } else {
+            const href = refined[0];
+            const crossOrigin = refined[1];
+            dispatcher.preconnect(href, crossOrigin);
+          }
+
+          return;
+        }
+
+      case 'L':
+        {
+          const refined = refineModel(code, model);
+          const href = refined[0];
+          const as = refined[1];
+
+          if (refined.length === 3) {
+            const options = refined[2];
+            dispatcher.preload(href, as, options);
+          } else {
+            dispatcher.preload(href, as);
+          }
+
+          return;
+        }
+
+      case 'm':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preloadModule(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preloadModule(href, options);
+          }
+
+          return;
+        }
+
+      case 'S':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitStyle(href);
+          } else {
+            const href = refined[0];
+            const precedence = refined[1] === 0 ? undefined : refined[1];
+            const options = refined.length === 3 ? refined[2] : undefined;
+            dispatcher.preinitStyle(href, precedence, options);
+          }
+
+          return;
+        }
+
+      case 'X':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitScript(href, options);
+          }
+
+          return;
+        }
+
+      case 'M':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitModuleScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitModuleScript(href, options);
+          }
+
+          return;
+        }
+    }
+  }
+} // Flow is having troulbe refining the HintModels so we help it a bit.
+// This should be compiled out in the production build.
+
+function refineModel(code, model) {
+  return model;
+}
+function preinitScriptForSSR(href, nonce, crossOrigin) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    dispatcher.preinitScript(href, {
+      crossOrigin: getCrossOriginString(crossOrigin),
+      nonce
+    });
+  }
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+const ObjectPrototype = Object.prototype;
+const knownServerReferences = new WeakMap(); // Serializable values
+// Thenable<ReactServerValue>
+// function serializeByValueID(id: number): string {
+//   return '$' + id.toString(16);
+// }
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeFormDataReference(id) {
+  // Why K? F is "Function". D is "Date". What else?
+  return '$K' + id.toString(16);
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeMapID(id) {
+  return '$Q' + id.toString(16);
+}
+
+function serializeSetID(id) {
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+
+function processReply(root, formFieldPrefix, resolve, reject) {
+  let nextPartId = 1;
+  let pendingParts = 0;
+  let formData = null;
+
+  function resolveToJSON(key, value) {
+    const parent = this; // Make sure that `parent[key]` wasn't JSONified before `value` was passed to us
+
+    if (value === null) {
+      return null;
+    }
+
+    if (typeof value === 'object') {
+      // $FlowFixMe[method-unbinding]
+      if (typeof value.then === 'function') {
+        // We assume that any object with a .then property is a "Thenable" type,
+        // or a Promise type. Either of which can be represented by a Promise.
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        }
+
+        pendingParts++;
+        const promiseId = nextPartId++;
+        const thenable = value;
+        thenable.then(partValue => {
+          const partJSON = JSON.stringify(partValue, resolveToJSON); // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
+
+          const data = formData; // eslint-disable-next-line react-internal/safe-string-coercion
+
+          data.append(formFieldPrefix + promiseId, partJSON);
+          pendingParts--;
+
+          if (pendingParts === 0) {
+            resolve(data);
+          }
+        }, reason => {
+          // In the future we could consider serializing this as an error
+          // that throws on the server instead.
+          reject(reason);
+        });
+        return serializePromiseID(promiseId);
+      }
+
+      if (isArray(value)) {
+        // $FlowFixMe[incompatible-return]
+        return value;
+      } // TODO: Should we the Object.prototype.toString.call() to test for cross-realm objects?
+
+
+      if (value instanceof FormData) {
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to use rich objects as its values.
+          formData = new FormData();
+        }
+
+        const data = formData;
+        const refId = nextPartId++; // Copy all the form fields with a prefix for this reference.
+        // These must come first in the form order because we assume that all the
+        // fields are available before this is referenced.
+
+        const prefix = formFieldPrefix + refId + '_'; // $FlowFixMe[prop-missing]: FormData has forEach.
+
+        value.forEach((originalValue, originalKey) => {
+          data.append(prefix + originalKey, originalValue);
+        });
+        return serializeFormDataReference(refId);
+      }
+
+      if (value instanceof Map) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const mapId = nextPartId++;
+        formData.append(formFieldPrefix + mapId, partJSON);
+        return serializeMapID(mapId);
+      }
+
+      if (value instanceof Set) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const setId = nextPartId++;
+        formData.append(formFieldPrefix + setId, partJSON);
+        return serializeSetID(setId);
+      }
+
+      const iteratorFn = getIteratorFn(value);
+
+      if (iteratorFn) {
+        return Array.from(value);
+      } // Verify that this is a simple plain object.
+
+
+      const proto = getPrototypeOf(value);
+
+      if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+        throw new Error('Only plain objects, and a few built-ins, can be passed to Server Actions. ' + 'Classes or null prototypes are not supported.');
+      }
+
+
+      return value;
+    }
+
+    if (typeof value === 'string') {
+      // TODO: Maybe too clever. If we support URL there's no similar trick.
+      if (value[value.length - 1] === 'Z') {
+        // Possibly a Date, whose toJSON automatically calls toISOString
+        // $FlowFixMe[incompatible-use]
+        const originalValue = parent[key];
+
+        if (originalValue instanceof Date) {
+          return serializeDateFromDateJSON(value);
+        }
+      }
+
+      return escapeStringValue(value);
+    }
+
+    if (typeof value === 'boolean') {
+      return value;
+    }
+
+    if (typeof value === 'number') {
+      return serializeNumber(value);
+    }
+
+    if (typeof value === 'undefined') {
+      return serializeUndefined();
+    }
+
+    if (typeof value === 'function') {
+      const metaData = knownServerReferences.get(value);
+
+      if (metaData !== undefined) {
+        const metaDataJSON = JSON.stringify(metaData, resolveToJSON);
+
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        } // The reference to this function came from the same client so we can pass it back.
+
+
+        const refId = nextPartId++; // eslint-disable-next-line react-internal/safe-string-coercion
+
+        formData.set(formFieldPrefix + refId, metaDataJSON);
+        return serializeServerReferenceID(refId);
+      }
+
+      throw new Error('Client Functions cannot be passed directly to Server Functions. ' + 'Only Functions passed from the Server can be passed back again.');
+    }
+
+    if (typeof value === 'symbol') {
+      // $FlowFixMe[incompatible-type] `description` might be undefined
+      const name = value.description;
+
+      if (Symbol.for(name) !== value) {
+        throw new Error('Only global symbols received from Symbol.for(...) can be passed to Server Functions. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+        value.description + ") cannot be found among global symbols."));
+      }
+
+      return serializeSymbolReference(name);
+    }
+
+    if (typeof value === 'bigint') {
+      return serializeBigInt(value);
+    }
+
+    throw new Error("Type " + typeof value + " is not supported as an argument to a Server Function.");
+  } // $FlowFixMe[incompatible-type] it's not going to be undefined because we'll encode it.
+
+
+  const json = JSON.stringify(root, resolveToJSON);
+
+  if (formData === null) {
+    // If it's a simple data structure, we just use plain JSON.
+    resolve(json);
+  } else {
+    // Otherwise, we use FormData to let us stream in the result.
+    formData.set(formFieldPrefix + '0', json);
+
+    if (pendingParts === 0) {
+      // $FlowFixMe[incompatible-call] this has already been refined.
+      resolve(formData);
+    }
+  }
+}
+const boundCache = new WeakMap();
+
+function encodeFormData(reference) {
+  let resolve, reject; // We need to have a handle on the thenable so that we can synchronously set
+  // its status from processReply, when it can complete synchronously.
+
+  const thenable = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  processReply(reference, '', body => {
+    if (typeof body === 'string') {
+      const data = new FormData();
+      data.append('0', body);
+      body = data;
+    }
+
+    const fulfilled = thenable;
+    fulfilled.status = 'fulfilled';
+    fulfilled.value = body;
+    resolve(body);
+  }, e => {
+    const rejected = thenable;
+    rejected.status = 'rejected';
+    rejected.reason = e;
+    reject(e);
+  });
+  return thenable;
+}
+
+function encodeFormAction(identifierPrefix) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  let data = null;
+  let name;
+  const boundPromise = reference.bound;
+
+  if (boundPromise !== null) {
+    let thenable = boundCache.get(reference);
+
+    if (!thenable) {
+      thenable = encodeFormData(reference);
+      boundCache.set(reference, thenable);
+    }
+
+    if (thenable.status === 'rejected') {
+      throw thenable.reason;
+    } else if (thenable.status !== 'fulfilled') {
+      throw thenable;
+    }
+
+    const encodedFormData = thenable.value; // This is hacky but we need the identifier prefix to be added to
+    // all fields but the suspense cache would break since we might get
+    // a new identifier each time. So we just append it at the end instead.
+
+    const prefixedData = new FormData(); // $FlowFixMe[prop-missing]
+
+    encodedFormData.forEach((value, key) => {
+      prefixedData.append('$ACTION_' + identifierPrefix + ':' + key, value);
+    });
+    data = prefixedData; // We encode the name of the prefix containing the data.
+
+    name = '$ACTION_REF_' + identifierPrefix;
+  } else {
+    // This is the simple case so we can just encode the ID.
+    name = '$ACTION_ID_' + reference.id;
+  }
+
+  return {
+    name: name,
+    method: 'POST',
+    encType: 'multipart/form-data',
+    data: data
+  };
+}
+
+function isSignatureEqual(referenceId, numberOfBoundArgs) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  if (reference.id !== referenceId) {
+    // These are different functions.
+    return false;
+  } // Now check if the number of bound arguments is the same.
+
+
+  const boundPromise = reference.bound;
+
+  if (boundPromise === null) {
+    // No bound arguments.
+    return numberOfBoundArgs === 0;
+  } // Unwrap the bound arguments array by suspending, if necessary. As with
+  // encodeFormData, this means isSignatureEqual can only be called while React
+  // is rendering.
+
+
+  switch (boundPromise.status) {
+    case 'fulfilled':
+      {
+        const boundArgs = boundPromise.value;
+        return boundArgs.length === numberOfBoundArgs;
+      }
+
+    case 'pending':
+      {
+        throw boundPromise;
+      }
+
+    case 'rejected':
+      {
+        throw boundPromise.reason;
+      }
+
+    default:
+      {
+        if (typeof boundPromise.status === 'string') ; else {
+          const pendingThenable = boundPromise;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(boundArgs => {
+            const fulfilledThenable = boundPromise;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = boundArgs;
+          }, error => {
+            const rejectedThenable = boundPromise;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          });
+        }
+
+        throw boundPromise;
+      }
+  }
+}
+
+function registerServerReference(proxy, reference) {
+  // Expose encoder for use by SSR, as well as a special bind that can be used to
+  // keep server capabilities.
+  {
+    // Only expose this in builds that would actually use it. Not needed on the client.
+    Object.defineProperties(proxy, {
+      $$FORM_ACTION: {
+        value: encodeFormAction
+      },
+      $$IS_SIGNATURE_EQUAL: {
+        value: isSignatureEqual
+      },
+      bind: {
+        value: bind
+      }
+    });
+  }
+
+  knownServerReferences.set(proxy, reference);
+} // $FlowFixMe[method-unbinding]
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+  const reference = knownServerReferences.get(this);
+
+  if (reference) {
+    const args = ArraySlice.call(arguments, 1);
+    let boundPromise = null;
+
+    if (reference.bound !== null) {
+      boundPromise = Promise.resolve(reference.bound).then(boundArgs => boundArgs.concat(args));
+    } else {
+      boundPromise = Promise.resolve(args);
+    }
+
+    registerServerReference(newFn, {
+      id: reference.id,
+      bound: boundPromise
+    });
+  }
+
+  return newFn;
+}
+
+function createServerReference$1(id, callServer) {
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    return callServer(id, args);
+  };
+
+  registerServerReference(proxy, {
+    id,
+    bound: null
+  });
+  return proxy;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ROW_ID = 0;
+const ROW_TAG = 1;
+const ROW_LENGTH = 2;
+const ROW_CHUNK_BY_NEWLINE = 3;
+const ROW_CHUNK_BY_LENGTH = 4;
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const CYCLIC = 'cyclic';
+const RESOLVED_MODEL = 'resolved_model';
+const RESOLVED_MODULE = 'resolved_module';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function readChunk(chunk) {
+  // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      return chunk.value;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      // eslint-disable-next-line no-throw-literal
+      throw chunk;
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function createBlockedChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(BLOCKED, null, null, response);
+}
+
+function createErrorChunk(response, error) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(ERRORED, null, error, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function createResolvedModuleChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODULE, value, null, response);
+}
+
+function createInitializedTextChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function createInitializedBufferChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function resolveModuleChunk(chunk, value) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODULE;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    initializeModuleChunk(resolvedChunk);
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+  const resolvedModel = chunk.value; // We go to the CYCLIC state until we've fully resolved this.
+  // We do this before parsing in case we try to initialize the same chunk
+  // while parsing the model. Such as in a cyclic reference.
+
+  const cyclicChunk = chunk;
+  cyclicChunk.status = CYCLIC;
+  cyclicChunk.value = null;
+  cyclicChunk.reason = null;
+
+  try {
+    const value = parseModel(chunk._response, resolvedModel);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const resolveListeners = cyclicChunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, value);
+      }
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+}
+
+function initializeModuleChunk(chunk) {
+  try {
+    const value = requireModule(chunk.value);
+    const initializedChunk = chunk;
+    initializedChunk.status = INITIALIZED;
+    initializedChunk.value = value;
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function createElement(type, key, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: null,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: null
+  };
+
+  return element;
+}
+
+function createLazyChunkWrapper(chunk) {
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: chunk,
+    _init: readChunk
+  };
+  return lazyType;
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunk = createPendingChunk(response);
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key, cyclic) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+
+    if (!cyclic) {
+      blocked.deps++;
+    }
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: cyclic ? 0 : 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function createServerReferenceProxy(response, metaData) {
+  const callServer = response._callServer;
+
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    const p = metaData.bound;
+
+    if (!p) {
+      return callServer(metaData.id, args);
+    }
+
+    if (p.status === INITIALIZED) {
+      const bound = p.value;
+      return callServer(metaData.id, bound.concat(args));
+    } // Since this is a fake Promise whose .then doesn't chain, we have to wrap it.
+    // TODO: Remove the wrapper once that's fixed.
+
+
+    return Promise.resolve(p).then(function (bound) {
+      return callServer(metaData.id, bound.concat(args));
+    });
+  };
+
+  registerServerReference(proxy, metaData);
+  return proxy;
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      {
+        return chunk.value;
+      }
+    // We always encode it first in the stream so it won't be pending.
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    if (value === '$') {
+      // A very common symbol.
+      return REACT_ELEMENT_TYPE;
+    }
+
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case 'L':
+        {
+          // Lazy node
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id); // We create a React.lazy wrapper around any lazy values.
+          // When passed into React, we'll know how to suspend on this.
+
+          return createLazyChunkWrapper(chunk);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'P':
+        {
+          // Server Context Provider
+          return getOrCreateServerContext(value.slice(2)).Provider;
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16);
+          const metadata = getOutlinedModel(response, id);
+          return createServerReferenceProxy(response, metadata);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+
+            case RESOLVED_MODULE:
+              initializeModuleChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+            case CYCLIC:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key, chunk.status === CYCLIC), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function parseModelTuple(response, value) {
+  const tuple = value;
+
+  if (tuple[0] === REACT_ELEMENT_TYPE) {
+    // TODO: Consider having React just directly accept these arrays as elements.
+    // Or even change the ReactElement type to be an array.
+    return createElement(tuple[1], tuple[2], tuple[3]);
+  }
+
+  return value;
+}
+
+function missingCall() {
+  throw new Error('Trying to call a function from "use server" but the callServer option ' + 'was not implemented in your router runtime.');
+}
+
+function createResponse(bundlerConfig, moduleLoading, callServer, nonce) {
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _moduleLoading: moduleLoading,
+    _callServer: callServer !== undefined ? callServer : missingCall,
+    _nonce: nonce,
+    _chunks: chunks,
+    _stringDecoder: createStringDecoder(),
+    _fromJSON: null,
+    _rowState: 0,
+    _rowID: 0,
+    _rowTag: 0,
+    _rowLength: 0,
+    _buffer: []
+  }; // Don't inline this call because it causes closure to outline the call above.
+
+  response._fromJSON = createFromJSONCallback(response);
+  return response;
+}
+
+function resolveModel(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createResolvedModelChunk(response, model));
+  } else {
+    resolveModelChunk(chunk, model);
+  }
+}
+
+function resolveText(response, id, text) {
+  const chunks = response._chunks; // We assume that we always reference large strings after they've been
+  // emitted.
+
+  chunks.set(id, createInitializedTextChunk(response, text));
+}
+
+function resolveBuffer(response, id, buffer) {
+  const chunks = response._chunks; // We assume that we always reference buffers after they've been emitted.
+
+  chunks.set(id, createInitializedBufferChunk(response, buffer));
+}
+
+function resolveModule(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+  const clientReferenceMetadata = parseModel(response, model);
+  const clientReference = resolveClientReference(response._bundlerConfig, clientReferenceMetadata);
+  prepareDestinationForModule(response._moduleLoading, response._nonce, clientReferenceMetadata); // TODO: Add an option to encode modules that are lazy loaded.
+  // For now we preload all modules as early as possible since it's likely
+  // that we'll need them.
+
+  const promise = preloadModule(clientReference);
+
+  if (promise) {
+    let blockedChunk;
+
+    if (!chunk) {
+      // Technically, we should just treat promise as the chunk in this
+      // case. Because it'll just behave as any other promise.
+      blockedChunk = createBlockedChunk(response);
+      chunks.set(id, blockedChunk);
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+    }
+
+    promise.then(() => resolveModuleChunk(blockedChunk, clientReference), error => triggerErrorOnChunk(blockedChunk, error));
+  } else {
+    if (!chunk) {
+      chunks.set(id, createResolvedModuleChunk(response, clientReference));
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      resolveModuleChunk(chunk, clientReference);
+    }
+  }
+}
+
+function resolveErrorProd(response, id, digest) {
+
+  const error = new Error('An error occurred in the Server Components render. The specific message is omitted in production' + ' builds to avoid leaking sensitive details. A digest property is included on this error instance which' + ' may provide additional details about the nature of the error.');
+  error.stack = 'Error: ' + error.message;
+  error.digest = digest;
+  const errorWithDigest = error;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, errorWithDigest));
+  } else {
+    triggerErrorOnChunk(chunk, errorWithDigest);
+  }
+}
+
+function resolvePostponeProd(response, id) {
+
+  const error = new Error('A Server Component was postponed. The reason is omitted in production' + ' builds to avoid leaking sensitive details.');
+  const postponeInstance = error;
+  postponeInstance.$$typeof = REACT_POSTPONE_TYPE;
+  postponeInstance.stack = 'Error: ' + error.message;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, postponeInstance));
+  } else {
+    triggerErrorOnChunk(chunk, postponeInstance);
+  }
+}
+
+function resolveHint(response, code, model) {
+  const hintModel = parseModel(response, model);
+  dispatchHint(code, hintModel);
+}
+
+function mergeBuffer(buffer, lastChunk) {
+  const l = buffer.length; // Count the bytes we'll need
+
+  let byteLength = lastChunk.length;
+
+  for (let i = 0; i < l; i++) {
+    byteLength += buffer[i].byteLength;
+  } // Allocate enough contiguous space
+
+
+  const result = new Uint8Array(byteLength);
+  let offset = 0; // Copy all the buffers into it.
+
+  for (let i = 0; i < l; i++) {
+    const chunk = buffer[i];
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+
+  result.set(lastChunk, offset);
+  return result;
+}
+
+function resolveTypedArray(response, id, buffer, lastChunk, constructor, bytesPerElement) {
+  // If the view fits into one original buffer, we just reuse that buffer instead of
+  // copying it out to a separate copy. This means that it's not always possible to
+  // transfer these values to other threads without copying first since they may
+  // share array buffer. For this to work, it must also have bytes aligned to a
+  // multiple of a size of the type.
+  const chunk = buffer.length === 0 && lastChunk.byteOffset % bytesPerElement === 0 ? lastChunk : mergeBuffer(buffer, lastChunk); // TODO: The transfer protocol of RSC is little-endian. If the client isn't little-endian
+  // we should convert it instead. In practice big endian isn't really Web compatible so it's
+  // somewhat safe to assume that browsers aren't going to run it, but maybe there's some SSR
+  // server that's affected.
+
+  const view = new constructor(chunk.buffer, chunk.byteOffset, chunk.byteLength / bytesPerElement);
+  resolveBuffer(response, id, view);
+}
+
+function processFullRow(response, id, tag, buffer, chunk) {
+  {
+    switch (tag) {
+      case 65
+      /* "A" */
+      :
+        // We must always clone to extract it into a separate buffer instead of just a view.
+        resolveBuffer(response, id, mergeBuffer(buffer, chunk).buffer);
+        return;
+
+      case 67
+      /* "C" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int8Array, 1);
+        return;
+
+      case 99
+      /* "c" */
+      :
+        resolveBuffer(response, id, buffer.length === 0 ? chunk : mergeBuffer(buffer, chunk));
+        return;
+
+      case 85
+      /* "U" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint8ClampedArray, 1);
+        return;
+
+      case 83
+      /* "S" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int16Array, 2);
+        return;
+
+      case 115
+      /* "s" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint16Array, 2);
+        return;
+
+      case 76
+      /* "L" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Int32Array, 4);
+        return;
+
+      case 108
+      /* "l" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Uint32Array, 4);
+        return;
+
+      case 70
+      /* "F" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Float32Array, 4);
+        return;
+
+      case 68
+      /* "D" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, Float64Array, 8);
+        return;
+
+      case 78
+      /* "N" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, BigInt64Array, 8);
+        return;
+
+      case 109
+      /* "m" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, BigUint64Array, 8);
+        return;
+
+      case 86
+      /* "V" */
+      :
+        resolveTypedArray(response, id, buffer, chunk, DataView, 1);
+        return;
+    }
+  }
+
+  const stringDecoder = response._stringDecoder;
+  let row = '';
+
+  for (let i = 0; i < buffer.length; i++) {
+    row += readPartialStringChunk(stringDecoder, buffer[i]);
+  }
+
+  row += readFinalStringChunk(stringDecoder, chunk);
+
+  switch (tag) {
+    case 73
+    /* "I" */
+    :
+      {
+        resolveModule(response, id, row);
+        return;
+      }
+
+    case 72
+    /* "H" */
+    :
+      {
+        const code = row[0];
+        resolveHint(response, code, row.slice(1));
+        return;
+      }
+
+    case 69
+    /* "E" */
+    :
+      {
+        const errorInfo = JSON.parse(row);
+
+        {
+          resolveErrorProd(response, id, errorInfo.digest);
+        }
+
+        return;
+      }
+
+    case 84
+    /* "T" */
+    :
+      {
+        resolveText(response, id, row);
+        return;
+      }
+
+    case 80
+    /* "P" */
+    :
+      {
+        {
+          {
+            resolvePostponeProd(response, id);
+          }
+
+          return;
+        }
+      }
+    // Fallthrough
+
+    default:
+      /* """ "{" "[" "t" "f" "n" "0" - "9" */
+      {
+        // We assume anything else is JSON.
+        resolveModel(response, id, row);
+        return;
+      }
+  }
+}
+
+function processBinaryChunk(response, chunk) {
+  let i = 0;
+  let rowState = response._rowState;
+  let rowID = response._rowID;
+  let rowTag = response._rowTag;
+  let rowLength = response._rowLength;
+  const buffer = response._buffer;
+  const chunkLength = chunk.length;
+
+  while (i < chunkLength) {
+    let lastIdx = -1;
+
+    switch (rowState) {
+      case ROW_ID:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 58
+          /* ":" */
+          ) {
+              // Finished the rowID, next we'll parse the tag.
+              rowState = ROW_TAG;
+            } else {
+            rowID = rowID << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_TAG:
+        {
+          const resolvedRowTag = chunk[i];
+
+          if (resolvedRowTag === 84
+          /* "T" */
+          || (resolvedRowTag === 65
+          /* "A" */
+          || resolvedRowTag === 67
+          /* "C" */
+          || resolvedRowTag === 99
+          /* "c" */
+          || resolvedRowTag === 85
+          /* "U" */
+          || resolvedRowTag === 83
+          /* "S" */
+          || resolvedRowTag === 115
+          /* "s" */
+          || resolvedRowTag === 76
+          /* "L" */
+          || resolvedRowTag === 108
+          /* "l" */
+          || resolvedRowTag === 70
+          /* "F" */
+          || resolvedRowTag === 68
+          /* "D" */
+          || resolvedRowTag === 78
+          /* "N" */
+          || resolvedRowTag === 109
+          /* "m" */
+          || resolvedRowTag === 86)
+          /* "V" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_LENGTH;
+              i++;
+            } else if (resolvedRowTag > 64 && resolvedRowTag < 91
+          /* "A"-"Z" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_CHUNK_BY_NEWLINE;
+              i++;
+            } else {
+            rowTag = 0;
+            rowState = ROW_CHUNK_BY_NEWLINE; // This was an unknown tag so it was probably part of the data.
+          }
+
+          continue;
+        }
+
+      case ROW_LENGTH:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 44
+          /* "," */
+          ) {
+              // Finished the rowLength, next we'll buffer up to that length.
+              rowState = ROW_CHUNK_BY_LENGTH;
+            } else {
+            rowLength = rowLength << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_CHUNK_BY_NEWLINE:
+        {
+          // We're looking for a newline
+          lastIdx = chunk.indexOf(10
+          /* "\n" */
+          , i);
+          break;
+        }
+
+      case ROW_CHUNK_BY_LENGTH:
+        {
+          // We're looking for the remaining byte length
+          lastIdx = i + rowLength;
+
+          if (lastIdx > chunk.length) {
+            lastIdx = -1;
+          }
+
+          break;
+        }
+    }
+
+    const offset = chunk.byteOffset + i;
+
+    if (lastIdx > -1) {
+      // We found the last chunk of the row
+      const length = lastIdx - i;
+      const lastChunk = new Uint8Array(chunk.buffer, offset, length);
+      processFullRow(response, rowID, rowTag, buffer, lastChunk); // Reset state machine for a new row
+
+      i = lastIdx;
+
+      if (rowState === ROW_CHUNK_BY_NEWLINE) {
+        // If we're trailing by a newline we need to skip it.
+        i++;
+      }
+
+      rowState = ROW_ID;
+      rowTag = 0;
+      rowID = 0;
+      rowLength = 0;
+      buffer.length = 0;
+    } else {
+      // The rest of this row is in a future chunk. We stash the rest of the
+      // current chunk until we can process the full row.
+      const length = chunk.byteLength - i;
+      const remainingSlice = new Uint8Array(chunk.buffer, offset, length);
+      buffer.push(remainingSlice); // Update how many bytes we're still waiting for. If we're looking for
+      // a newline, this doesn't hurt since we'll just ignore it.
+
+      rowLength -= remainingSlice.byteLength;
+      break;
+    }
+  }
+
+  response._rowState = rowState;
+  response._rowID = rowID;
+  response._rowTag = rowTag;
+  response._rowLength = rowLength;
+}
+
+function parseModel(response, json) {
+  return JSON.parse(json, response._fromJSON);
+}
+
+function createFromJSONCallback(response) {
+  // $FlowFixMe[missing-this-annot]
+  return function (key, value) {
+    if (typeof value === 'string') {
+      // We can't use .bind here because we need the "this" value.
+      return parseModelString(response, this, key, value);
+    }
+
+    if (typeof value === 'object' && value !== null) {
+      return parseModelTuple(response, value);
+    }
+
+    return value;
+  };
+}
+
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function noServerCall() {
+  throw new Error('Server Functions cannot be called during initial render. ' + 'This would create a fetch waterfall. Try to use a Server Component ' + 'to pass data to Client Components instead.');
+}
+
+function createServerReference(id, callServer) {
+  return createServerReference$1(id, noServerCall);
+}
+
+function createFromNodeStream(stream, ssrManifest, options) {
+  const response = createResponse(ssrManifest.moduleMap, ssrManifest.moduleLoading, noServerCall, options && typeof options.nonce === 'string' ? options.nonce : undefined);
+  stream.on('data', chunk => {
+    processBinaryChunk(response, chunk);
+  });
+  stream.on('error', error => {
+    reportGlobalError(response, error);
+  });
+  stream.on('end', () => close(response));
+  return getRoot(response);
+}
+
+exports.createFromNodeStream = createFromNodeStream;
+exports.createServerReference = createServerReference;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.node.unbundled.production.min.js b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.node.unbundled.production.min.js
index c8cf04e2268bc..f58c0df367449 100644
--- a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.node.unbundled.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.node.unbundled.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-webpack-client.node.unbundled.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-webpack-client.node.unbundled.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var n=require("util"),q=require("react-dom"),r=require("react"),u={stream:!0};function v(a,b){var c=a[b[0]];if(a=c[b[2]])c=a.name;else{a=c["*"];if(!a)throw Error('Could not find the module "'+b[0]+'" in the React SSR Manifest. This is probably a bug in the React Server Components bundler.');c=b[2]}return{specifier:a.specifier,name:c,async:4===b.length}}var w=new Map;
 function x(a){var b=w.get(a.specifier);if(b)return"fulfilled"===b.status?null:b;var c=import(a.specifier);a.async&&(c=c.then(function(d){return d.default}));c.then(function(d){var e=c;e.status="fulfilled";e.value=d},function(d){var e=c;e.status="rejected";e.reason=d});w.set(a.specifier,c);return c}
 function y(a,b,c){if(null!==a)for(var d=1;d<b.length;d+=2){var e=c,g=A.current;if(g){var f=g.preinitScript,l=a.prefix+b[d];var k=a.crossOrigin;k="string"===typeof k?"use-credentials"===k?k:"":void 0;f.call(g,l,{crossOrigin:k,nonce:e})}}}
@@ -42,3 +42,5 @@ f.stack="Error: "+f.message;f.digest=c;c=a._chunks;(d=c.get(b))?P(d,f):c.set(b,n
 exports.createFromNodeStream=function(a,b,c){var d=xa(b.moduleMap,b.moduleLoading,Z,c&&"string"===typeof c.nonce?c.nonce:void 0);a.on("data",function(e){for(var g=0,f=d._rowState,l=d._rowID,k=d._rowTag,h=d._rowLength,t=d._buffer,F=e.length;g<F;){var m=-1;switch(f){case 0:m=e[g++];58===m?f=1:l=l<<4|(96<m?m-87:m-48);continue;case 1:f=e[g];84===f||65===f||67===f||99===f||85===f||83===f||115===f||76===f||108===f||70===f||68===f||78===f||109===f||86===f?(k=f,f=2,g++):64<f&&91>f?(k=f,f=3,g++):(k=0,f=3);
 continue;case 2:m=e[g++];44===m?f=4:h=h<<4|(96<m?m-87:m-48);continue;case 3:m=e.indexOf(10,g);break;case 4:m=g+h,m>e.length&&(m=-1)}var p=e.byteOffset+g;if(-1<m)h=new Uint8Array(e.buffer,p,m-g),Aa(d,l,k,t,h),g=m,3===f&&g++,h=l=k=f=0,t.length=0;else{e=new Uint8Array(e.buffer,p,e.byteLength-g);t.push(e);h-=e.byteLength;break}}d._rowState=f;d._rowID=l;d._rowTag=k;d._rowLength=h});a.on("error",function(e){T(d,e)});a.on("end",function(){T(d,Error("Connection closed."))});return U(d,0)};
 exports.createServerReference=function(a){return qa(a,Z)};
+
+//# sourceMappingURL=react-server-dom-webpack-client.node.unbundled.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-node-register.js b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-node-register.js
index a7b85c7916b06..03e91034030cb 100644
--- a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-node-register.js
+++ b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-node-register.js
@@ -1,15 +1,14 @@
-/**
- * @license React
- * react-server-dom-webpack-node-register.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-webpack-node-register.js
 
-'use strict';
+ Copyright (c) Meta Platforms, Inc. and affiliates.
 
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';const h=require("acorn-loose"),l=require("url"),q=require("module");
 module.exports=function(){const m=require("react-server-dom-webpack/server"),n=m.registerServerReference,r=m.createClientModuleProxy,f=q.prototype._compile;q.prototype._compile=function(k,p){if(-1===k.indexOf("use client")&&-1===k.indexOf("use server"))return f.apply(this,arguments);try{var a=h.parse(k,{ecmaVersion:"2024",sourceType:"source"}).body}catch(g){return console.error("Error parsing %s %s",l,g.message),f.apply(this,arguments)}var b=!1,d=!1;for(var c=0;c<a.length;c++){var e=a[c];if("ExpressionStatement"!==
 e.type||!e.directive)break;"use client"===e.directive&&(b=!0);"use server"===e.directive&&(d=!0)}if(!b&&!d)return f.apply(this,arguments);if(b&&d)throw Error('Cannot have both "use client" and "use server" directives in the same file.');b&&(a=l.pathToFileURL(p).href,this.exports=r(a));if(d)if(f.apply(this,arguments),d=l.pathToFileURL(p).href,a=this.exports,"function"===typeof a)n(a,d,null);else for(b=Object.keys(a),c=0;c<b.length;c++){e=b[c];const g=a[b[c]];"function"===typeof g&&n(g,d,e)}}};
+
+//# sourceMappingURL=react-server-dom-webpack-node-register.js.map
diff --git a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-plugin.js b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-plugin.js
index bac715532412f..31ceef305b42e 100644
--- a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-plugin.js
+++ b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-plugin.js
@@ -1,15 +1,12 @@
-/**
- * @license React
- * react-server-dom-webpack-plugin.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-webpack-plugin.js
 
-'use strict';
+ Copyright (c) Meta Platforms, Inc. and affiliates.
 
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var w=require("path"),x=require("url"),y=require("neo-async"),z=require("acorn-loose"),B=require("webpack/lib/dependencies/ModuleDependency"),C=require("webpack/lib/dependencies/NullDependency"),D=require("webpack/lib/Template"),E=require("webpack");
 function F(a,g){if(a){if("string"===typeof a)return G(a,g);var c=Object.prototype.toString.call(a).slice(8,-1);"Object"===c&&a.constructor&&(c=a.constructor.name);if("Map"===c||"Set"===c)return Array.from(a);if("Arguments"===c||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(c))return G(a,g)}}function G(a,g){if(null==g||g>a.length)g=a.length;for(var c=0,n=Array(g);c<g;c++)n[c]=a[c];return n}
 function H(a,g){var c;if("undefined"===typeof Symbol||null==a[Symbol.iterator]){if(Array.isArray(a)||(c=F(a))||g&&a&&"number"===typeof a.length){c&&(a=c);var n=0;g=function(){};return{s:g,n:function(){return n>=a.length?{done:!0}:{done:!1,value:a[n++]}},e:function(b){throw b;},f:g}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");}var d=!0,e=!1,p;return{s:function(){c=a[Symbol.iterator]()},
@@ -23,3 +20,5 @@ l)){const q={};b[l]={id:k,chunks:u,name:"*"};q["*"]={specifier:l,name:"*"};f[k]=
 var t=JSON.stringify(b,null,2);d.emitAsset(g.clientManifestFilename,new E.sources.RawSource(t,!1));e=JSON.stringify(e,null,2);d.emitAsset(g.ssrManifestFilename,new E.sources.RawSource(e,!1))}})})}resolveAllClientFiles(a,g,c,n,d,e){function p(b){if(-1===b.indexOf("use client"))return!1;let f;try{f=z.parse(b,{ecmaVersion:"2024",sourceType:"module"}).body}catch(h){return!1}for(b=0;b<f.length;b++){const h=f[b];if("ExpressionStatement"!==h.type||!h.directive)break;if("use client"===h.directive)return!0}return!1}
 y.map(this.clientReferences,(b,f)=>{"string"===typeof b?f(null,[new J(b)]):g.resolve({},a,b.directory,{},(h,t)=>{if(h)return f(h);d.resolveDependencies(n,{resource:t,resourceQuery:"",recursive:void 0===b.recursive?!0:b.recursive,regExp:b.include,include:void 0,exclude:b.exclude},(m,v)=>{if(m)return f(m);m=v.map(u=>{var k=w.join(t,u.userRequest);k=new J(k);k.userRequest=u.userRequest;return k});y.filter(m,(u,k)=>{c.resolve({},a,u.request,{},(l,q)=>{if(l||"string"!==typeof q)return k(null,!1);n.readFile(q,
 "utf-8",(r,A)=>{if(r||"string"!==typeof A)return k(null,!1);r=p(A);k(null,r)})})},f)})})},(b,f)=>{if(b)return e(b);b=[];for(let h=0;h<f.length;h++)b.push.apply(b,f[h]);e(null,b)})}}module.exports=L;
+
+//# sourceMappingURL=react-server-dom-webpack-plugin.js.map
diff --git a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.browser.production.js b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.browser.production.js
new file mode 100644
index 0000000000000..0e586e36579c8
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.browser.production.js
@@ -0,0 +1,3476 @@
+/**
+ * @license React
+ * react-server-dom-webpack-server.browser.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var ReactDOM = require('react-dom');
+var React = require('react');
+
+// -----------------------------------------------------------------------------
+const enablePostpone = true;
+
+function scheduleWork(callback) {
+  callback();
+}
+const VIEW_SIZE = 512;
+let currentView = null;
+let writtenBytes = 0;
+function beginWriting(destination) {
+  currentView = new Uint8Array(VIEW_SIZE);
+  writtenBytes = 0;
+}
+function writeChunk(destination, chunk) {
+  if (chunk.byteLength === 0) {
+    return;
+  }
+
+  if (chunk.byteLength > VIEW_SIZE) {
+    // one that is cached by the streaming renderer. We will enqueu
+    // it directly and expect it is not re-used
+
+
+    if (writtenBytes > 0) {
+      destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    destination.enqueue(chunk);
+    return;
+  }
+
+  let bytesToWrite = chunk;
+  const allowableBytes = currentView.length - writtenBytes;
+
+  if (allowableBytes < bytesToWrite.byteLength) {
+    // this chunk would overflow the current view. We enqueue a full view
+    // and start a new view with the remaining chunk
+    if (allowableBytes === 0) {
+      // the current view is already full, send it
+      destination.enqueue(currentView);
+    } else {
+      // fill up the current view and apply the remaining chunk bytes
+      // to a new view.
+      currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes); // writtenBytes += allowableBytes; // this can be skipped because we are going to immediately reset the view
+
+      destination.enqueue(currentView);
+      bytesToWrite = bytesToWrite.subarray(allowableBytes);
+    }
+
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+
+  currentView.set(bytesToWrite, writtenBytes);
+  writtenBytes += bytesToWrite.byteLength;
+}
+function writeChunkAndReturn(destination, chunk) {
+  writeChunk(destination, chunk); // in web streams there is no backpressure so we can alwas write more
+
+  return true;
+}
+function completeWriting(destination) {
+  if (currentView && writtenBytes > 0) {
+    destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+    currentView = null;
+    writtenBytes = 0;
+  }
+}
+function close$1(destination) {
+  destination.close();
+}
+const textEncoder = new TextEncoder();
+function stringToChunk(content) {
+  return textEncoder.encode(content);
+}
+function typedArrayToBinaryChunk(content) {
+  // Convert any non-Uint8Array array to Uint8Array. We could avoid this for Uint8Arrays.
+  // If we passed through this straight to enqueue we wouldn't have to convert it but since
+  // we need to copy the buffer in that case, we need to convert it to copy it.
+  // When we copy it into another array using set() it needs to be a Uint8Array.
+  const buffer = new Uint8Array(content.buffer, content.byteOffset, content.byteLength); // We clone large chunks so that we can transfer them when we write them.
+  // Others get copied into the target buffer.
+
+  return content.byteLength > VIEW_SIZE ? buffer.slice() : buffer;
+}
+function byteLengthOfChunk(chunk) {
+  return chunk.byteLength;
+}
+function byteLengthOfBinaryChunk(chunk) {
+  return chunk.byteLength;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[method-unbinding]
+  if (typeof destination.error === 'function') {
+    // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+    destination.error(error);
+  } else {
+    // Earlier implementations doesn't support this method. In that environment you're
+    // supposed to throw from a promise returned but we don't return a promise in our
+    // approach. We could fork this implementation but this is environment is an edge
+    // case to begin with. It's even less common to run this in an older environment.
+    // Even then, this is not where errors are supposed to happen and they get reported
+    // to a global callback in addition to this anyway. So it's fine just to close this.
+    destination.close();
+  }
+}
+
+// eslint-disable-next-line no-unused-vars
+const CLIENT_REFERENCE_TAG = Symbol.for('react.client.reference');
+const SERVER_REFERENCE_TAG = Symbol.for('react.server.reference');
+function isClientReference(reference) {
+  return reference.$$typeof === CLIENT_REFERENCE_TAG;
+}
+function isServerReference(reference) {
+  return reference.$$typeof === SERVER_REFERENCE_TAG;
+}
+function registerClientReference(proxyImplementation, id, exportName) {
+  return registerClientReferenceImpl(proxyImplementation, id + '#' + exportName, false);
+}
+
+function registerClientReferenceImpl(proxyImplementation, id, async) {
+  return Object.defineProperties(proxyImplementation, {
+    $$typeof: {
+      value: CLIENT_REFERENCE_TAG
+    },
+    $$id: {
+      value: id
+    },
+    $$async: {
+      value: async
+    }
+  });
+} // $FlowFixMe[method-unbinding]
+
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+
+  if (this.$$typeof === SERVER_REFERENCE_TAG) {
+    const args = ArraySlice.call(arguments, 1);
+    newFn.$$typeof = SERVER_REFERENCE_TAG;
+    newFn.$$id = this.$$id;
+    newFn.$$bound = this.$$bound ? this.$$bound.concat(args) : args;
+  }
+
+  return newFn;
+}
+
+function registerServerReference(reference, id, exportName) {
+  return Object.defineProperties(reference, {
+    $$typeof: {
+      value: SERVER_REFERENCE_TAG
+    },
+    $$id: {
+      value: exportName === null ? id : id + '#' + exportName
+    },
+    $$bound: {
+      value: null
+    },
+    bind: {
+      value: bind
+    }
+  });
+}
+const PROMISE_PROTOTYPE = Promise.prototype;
+const deepProxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        // These names are a little too common. We should probably have a way to
+        // have the Flight runtime extract the inner target instead.
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+
+      case 'displayName':
+        return undefined;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case 'Provider':
+        throw new Error("Cannot render a Client Context Provider on the Server. " + "Instead, you can export a Client Component wrapper " + "that itself renders a Client Context Provider.");
+    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+    const expression = String(target.name) + '.' + String(name);
+    throw new Error("Cannot access " + expression + " on the server. " + 'You cannot dot into a client module from a server component. ' + 'You can only pass the imported name through.');
+  },
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+
+function getReference(target, name) {
+  switch (name) {
+    // These names are read by the Flight runtime if you end up using the exports object.
+    case '$$typeof':
+      return target.$$typeof;
+
+    case '$$id':
+      return target.$$id;
+
+    case '$$async':
+      return target.$$async;
+
+    case 'name':
+      return target.name;
+    // We need to special case this because createElement reads it if we pass this
+    // reference.
+
+    case 'defaultProps':
+      return undefined;
+    // Avoid this attempting to be serialized.
+
+    case 'toJSON':
+      return undefined;
+
+    case Symbol.toPrimitive:
+      // $FlowFixMe[prop-missing]
+      return Object.prototype[Symbol.toPrimitive];
+
+    case '__esModule':
+      // Something is conditionally checking which export to use. We'll pretend to be
+      // an ESM compat module but then we'll check again on the client.
+      const moduleId = target.$$id;
+      target.default = registerClientReferenceImpl(function () {
+        throw new Error("Attempted to call the default export of " + moduleId + " from the server " + "but it's on the client. It's not possible to invoke a client function from " + "the server, it can only be rendered as a Component or passed to props of a " + "Client Component.");
+      }, target.$$id + '#', target.$$async);
+      return true;
+
+    case 'then':
+      if (target.then) {
+        // Use a cached value
+        return target.then;
+      }
+
+      if (!target.$$async) {
+        // If this module is expected to return a Promise (such as an AsyncModule) then
+        // we should resolve that with a client reference that unwraps the Promise on
+        // the client.
+        const clientReference = registerClientReferenceImpl({}, target.$$id, true);
+        const proxy = new Proxy(clientReference, proxyHandlers); // Treat this as a resolved Promise for React's use()
+
+        target.status = 'fulfilled';
+        target.value = proxy;
+        const then = target.then = registerClientReferenceImpl(function then(resolve, reject) {
+          // Expose to React.
+          return Promise.resolve(resolve(proxy));
+        }, // If this is not used as a Promise but is treated as a reference to a `.then`
+        // export then we should treat it as a reference to that name.
+        target.$$id + '#then', false);
+        return then;
+      } else {
+        // Since typeof .then === 'function' is a feature test we'd continue recursing
+        // indefinitely if we return a function. Instead, we return an object reference
+        // if we check further.
+        return undefined;
+      }
+
+  }
+
+  let cachedReference = target[name];
+
+  if (!cachedReference) {
+    const reference = registerClientReferenceImpl(function () {
+      throw new Error( // eslint-disable-next-line react-internal/safe-string-coercion
+      "Attempted to call " + String(name) + "() from the server but " + String(name) + " is on the client. " + "It's not possible to invoke a client function from the server, it can " + "only be rendered as a Component or passed to props of a Client Component.");
+    }, target.$$id + '#' + name, target.$$async);
+    Object.defineProperty(reference, 'name', {
+      value: name
+    });
+    cachedReference = target[name] = new Proxy(reference, deepProxyHandlers);
+  }
+
+  return cachedReference;
+}
+
+const proxyHandlers = {
+  get: function (target, name, receiver) {
+    return getReference(target, name);
+  },
+  getOwnPropertyDescriptor: function (target, name) {
+    let descriptor = Object.getOwnPropertyDescriptor(target, name);
+
+    if (!descriptor) {
+      descriptor = {
+        value: getReference(target, name),
+        writable: false,
+        configurable: false,
+        enumerable: false
+      };
+      Object.defineProperty(target, name, descriptor);
+    }
+
+    return descriptor;
+  },
+
+  getPrototypeOf(target) {
+    // Pretend to be a Promise in case anyone asks.
+    return PROMISE_PROTOTYPE;
+  },
+
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+function createClientModuleProxy(moduleId) {
+  const clientReference = registerClientReferenceImpl({}, // Represents the whole Module object instead of a particular import.
+  moduleId, false);
+  return new Proxy(clientReference, proxyHandlers);
+}
+
+function getClientReferenceKey(reference) {
+  return reference.$$async ? reference.$$id + '#async' : reference.$$id;
+}
+function resolveClientReferenceMetadata(config, clientReference) {
+  const modulePath = clientReference.$$id;
+  let name = '';
+  let resolvedModuleData = config[modulePath];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = modulePath.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = modulePath.slice(idx + 1);
+      resolvedModuleData = config[modulePath.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + modulePath + '" in the React Client Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  }
+
+  if (clientReference.$$async === true) {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1];
+  } else {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+  }
+}
+function getServerReferenceId(config, serverReference) {
+  return serverReference.$$id;
+}
+function getServerReferenceBoundArguments(config, serverReference) {
+  return serverReference.$$bound;
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMFlightServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule: preloadModule$1,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+
+function prefetchDNS(href) {
+  {
+    if (typeof href === 'string' && href) {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'D|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        emitHint(request, 'D', href);
+      }
+    }
+  }
+}
+
+function preconnect(href, crossOrigin) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = "C|" + (crossOrigin == null ? 'null' : crossOrigin) + "|" + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+
+        if (typeof crossOrigin === 'string') {
+          emitHint(request, 'C', [href, crossOrigin]);
+        } else {
+          emitHint(request, 'C', href);
+        }
+      }
+    }
+  }
+}
+
+function preload(href, as, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        let key = 'L';
+
+        if (as === 'image' && options) {
+          key += getImagePreloadKey(href, options.imageSrcSet, options.imageSizes);
+        } else {
+          key += "[" + as + "]" + href;
+        }
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          emitHint(request, 'L', [href, as, trimmed]);
+        } else {
+          emitHint(request, 'L', [href, as]);
+        }
+      }
+    }
+  }
+}
+
+function preloadModule$1(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'm|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'm', [href, trimmed]);
+        } else {
+          return emitHint(request, 'm', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'S|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'S', [href, typeof precedence === 'string' ? precedence : 0, trimmed]);
+        } else if (typeof precedence === 'string') {
+          return emitHint(request, 'S', [href, precedence]);
+        } else {
+          return emitHint(request, 'S', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'X|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'X', [href, trimmed]);
+        } else {
+          return emitHint(request, 'X', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitModuleScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'M|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'M', [href, trimmed]);
+        } else {
+          return emitHint(request, 'M', href);
+        }
+      }
+    }
+  }
+} // Flight normally encodes undefined as a special character however for directive option
+// arguments we don't want to send unnecessary keys and bloat the payload so we create a
+// trimmed object which omits any keys with null or undefined values.
+// This is only typesafe because these option objects have entirely optional fields where
+// null and undefined represent the same thing as no property.
+
+
+function trimOptions(options) {
+  if (options == null) return null;
+  let hasProperties = false;
+  const trimmed = {};
+
+  for (const key in options) {
+    if (options[key] != null) {
+      hasProperties = true;
+      trimmed[key] = options[key];
+    }
+  }
+
+  return hasProperties ? trimmed : null;
+}
+
+function getImagePreloadKey(href, imageSrcSet, imageSizes) {
+  let uniquePart = '';
+
+  if (typeof imageSrcSet === 'string' && imageSrcSet !== '') {
+    uniquePart += '[' + imageSrcSet + ']';
+
+    if (typeof imageSizes === 'string') {
+      uniquePart += '[' + imageSizes + ']';
+    }
+  } else {
+    uniquePart += '[][]' + href;
+  }
+
+  return "[image]" + uniquePart;
+}
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMFlightServerDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+// small, smaller than how we encode undefined, and is unambiguous. We could use
+// a different tuple structure to encode this instead but this makes the runtime
+// cost cheaper by eliminating a type checks in more positions.
+// prettier-ignore
+
+function createHints() {
+  return new Set();
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext); // On the way back, we push the new ones that weren't common.
+
+      pushNode(next);
+    }
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function pushProvider(context, nextValue) {
+  let prevValue;
+
+  {
+    prevValue = context._currentValue;
+    context._currentValue = nextValue;
+  }
+
+  const prevNode = currentActiveSnapshot;
+  const newNode = {
+    parent: prevNode,
+    depth: prevNode === null ? 0 : prevNode.depth + 1,
+    context: context,
+    parentValue: prevValue,
+    value: nextValue
+  };
+  currentActiveSnapshot = newNode;
+  return newNode;
+}
+function popProvider() {
+  const prevSnapshot = currentActiveSnapshot;
+
+  if (prevSnapshot === null) {
+    throw new Error('Tried to pop a Context at the root of the app. This is a bug in React.');
+  }
+
+  {
+    const value = prevSnapshot.parentValue;
+
+    if (value === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      prevSnapshot.context._currentValue = prevSnapshot.context._defaultValue;
+    } else {
+      prevSnapshot.context._currentValue = value;
+    }
+  }
+
+  return currentActiveSnapshot = prevSnapshot.parent;
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFizzWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop, noop);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+let currentRequest$1 = null;
+let thenableIndexCounter = 0;
+let thenableState = null;
+function prepareToUseHooksForRequest(request) {
+  currentRequest$1 = request;
+}
+function resetHooksForRequest() {
+  currentRequest$1 = null;
+}
+function prepareToUseHooksForComponent(prevThenableState) {
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+const HooksDispatcher = {
+  useMemo(nextCreate) {
+    return nextCreate();
+  },
+
+  useCallback(callback) {
+    return callback;
+  },
+
+  useDebugValue() {},
+
+  useDeferredValue: unsupportedHook,
+  useTransition: unsupportedHook,
+  readContext,
+  useContext: readContext,
+  useReducer: unsupportedHook,
+  useRef: unsupportedHook,
+  useState: unsupportedHook,
+  useInsertionEffect: unsupportedHook,
+  useLayoutEffect: unsupportedHook,
+  useImperativeHandle: unsupportedHook,
+  useEffect: unsupportedHook,
+  useId,
+  useSyncExternalStore: unsupportedHook,
+
+  useCacheRefresh() {
+    return unsupportedRefresh;
+  },
+
+  useMemoCache(size) {
+    const data = new Array(size);
+
+    for (let i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL;
+    }
+
+    return data;
+  },
+
+  use
+};
+
+function unsupportedHook() {
+  throw new Error('This Hook is not supported in Server Components.');
+}
+
+function unsupportedRefresh() {
+  throw new Error('Refreshing the cache is not supported in Server Components.');
+}
+
+function useId() {
+  if (currentRequest$1 === null) {
+    throw new Error('useId can only be used while React is rendering');
+  }
+
+  const id = currentRequest$1.identifierCount++; // use 'S' for Flight components to distinguish from 'R' and 'r' in Fizz/Client
+
+  return ':' + currentRequest$1.identifierPrefix + 'S' + id.toString(32) + ':';
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object' || typeof usable === 'function') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable; // Track the position of the thenable within this fiber.
+
+      const index = thenableIndexCounter;
+      thenableIndexCounter += 1;
+
+      if (thenableState === null) {
+        thenableState = createThenableState();
+      }
+
+      return trackUsedThenable(thenableState, thenable, index);
+    } else if (usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  }
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function createSignal() {
+  return new AbortController().signal;
+}
+
+function resolveCache() {
+  const request = resolveRequest();
+
+  if (request) {
+    return getCache(request);
+  }
+
+  return new Map();
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal() {
+    const cache = resolveCache();
+    let entry = cache.get(createSignal);
+
+    if (entry === undefined) {
+      entry = createSignal();
+      cache.set(createSignal, entry);
+    }
+
+    return entry;
+  },
+
+  getCacheForType(resourceType) {
+    const cache = resolveCache();
+    let entry = cache.get(resourceType);
+
+    if (entry === undefined) {
+      entry = resourceType(); // TODO: Warn if undefined?
+
+      cache.set(resourceType, entry);
+    }
+
+    return entry;
+  }
+
+};
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+function objectName(object) {
+  // $FlowFixMe[method-unbinding]
+  const name = Object.prototype.toString.call(object);
+  return name.replace(/^\[object (.*)\]$/, function (m, p0) {
+    return p0;
+  });
+}
+
+function describeKeyForErrorMessage(key) {
+  const encodedKey = JSON.stringify(key);
+  return '"' + key + '"' === encodedKey ? key : encodedKey;
+}
+
+function describeValueForErrorMessage(value) {
+  switch (typeof value) {
+    case 'string':
+      {
+        return JSON.stringify(value.length <= 10 ? value : value.slice(0, 10) + '...');
+      }
+
+    case 'object':
+      {
+        if (isArray(value)) {
+          return '[...]';
+        }
+
+        const name = objectName(value);
+
+        if (name === 'Object') {
+          return '{...}';
+        }
+
+        return name;
+      }
+
+    case 'function':
+      return 'function';
+
+    default:
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      return String(value);
+  }
+}
+
+function describeElementType(type) {
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        return describeElementType(type.render);
+
+      case REACT_MEMO_TYPE:
+        return describeElementType(type.type);
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            // Lazy may contain any component type so we recursively resolve it.
+            return describeElementType(init(payload));
+          } catch (x) {}
+        }
+    }
+  }
+
+  return '';
+}
+
+function describeObjectForErrorMessage(objectOrArray, expandedName) {
+  const objKind = objectName(objectOrArray);
+
+  if (objKind !== 'Object' && objKind !== 'Array') {
+    return objKind;
+  }
+
+  let str = '';
+  let start = -1;
+  let length = 0;
+
+  if (isArray(objectOrArray)) {
+    {
+      // Print Array
+      str = '[';
+      const array = objectOrArray;
+
+      for (let i = 0; i < array.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const value = array[i];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if ('' + i === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += ']';
+    }
+  } else {
+    if (objectOrArray.$$typeof === REACT_ELEMENT_TYPE) {
+      str = '<' + describeElementType(objectOrArray.type) + '/>';
+    } else {
+      // Print Object
+      str = '{';
+      const object = objectOrArray;
+      const names = Object.keys(object);
+
+      for (let i = 0; i < names.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const name = names[i];
+        str += describeKeyForErrorMessage(name) + ': ';
+        const value = object[name];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if (name === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += '}';
+    }
+  }
+
+  if (expandedName === undefined) {
+    return str;
+  }
+
+  if (start > -1 && length > 0) {
+    const highlight = ' '.repeat(start) + '^'.repeat(length);
+    return '\n  ' + str + '\n  ' + highlight;
+  }
+
+  return '\n  ' + str;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ReactSharedServerInternals = // $FlowFixMe: It's defined in the one we resolve to.
+React.__SECRET_SERVER_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+if (!ReactSharedServerInternals) {
+  throw new Error('The "react" package in this environment is not configured correctly. ' + 'The "react-server" condition must be enabled in any environment that ' + 'runs React Server Components.');
+}
+
+// Turns a TypedArray or ArrayBuffer into a string that can be used for comparison
+// in a Map to see if the bytes are the same.
+function binaryToComparableString(view) {
+  return String.fromCharCode.apply(String, new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+}
+
+const ObjectPrototype = Object.prototype;
+const stringify = JSON.stringify; // Serializable values
+// Thenable<ReactClientValue>
+
+const PENDING$1 = 0;
+const COMPLETED = 1;
+const ABORTED = 3;
+const ERRORED$1 = 4;
+const TaintRegistryObjects = ReactSharedServerInternals.TaintRegistryObjects,
+      TaintRegistryValues = ReactSharedServerInternals.TaintRegistryValues,
+      TaintRegistryByteLengths = ReactSharedServerInternals.TaintRegistryByteLengths,
+      TaintRegistryPendingRequests = ReactSharedServerInternals.TaintRegistryPendingRequests,
+      ReactCurrentCache = ReactSharedServerInternals.ReactCurrentCache;
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+
+function throwTaintViolation(message) {
+  // eslint-disable-next-line react-internal/prod-error-codes
+  throw new Error(message);
+}
+
+function cleanupTaintQueue(request) {
+  const cleanupQueue = request.taintCleanupQueue;
+  TaintRegistryPendingRequests.delete(cleanupQueue);
+
+  for (let i = 0; i < cleanupQueue.length; i++) {
+    const entryValue = cleanupQueue[i];
+    const entry = TaintRegistryValues.get(entryValue);
+
+    if (entry !== undefined) {
+      if (entry.count === 1) {
+        TaintRegistryValues.delete(entryValue);
+      } else {
+        entry.count--;
+      }
+    }
+  }
+
+  cleanupQueue.length = 0;
+}
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+}
+
+function defaultPostponeHandler(reason) {// Noop
+}
+
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2;
+function createRequest(model, bundlerConfig, onError, context, identifierPrefix, onPostpone) {
+  if (ReactCurrentCache.current !== null && ReactCurrentCache.current !== DefaultCacheDispatcher) {
+    throw new Error('Currently React only supports one RSC renderer at a time.');
+  }
+
+  prepareHostDispatcher();
+  ReactCurrentCache.current = DefaultCacheDispatcher;
+  const abortSet = new Set();
+  const pingedTasks = [];
+  const cleanupQueue = [];
+
+  {
+    TaintRegistryPendingRequests.add(cleanupQueue);
+  }
+
+  const hints = createHints();
+  const request = {
+    status: OPEN,
+    flushScheduled: false,
+    fatalError: null,
+    destination: null,
+    bundlerConfig,
+    cache: new Map(),
+    nextChunkId: 0,
+    pendingChunks: 0,
+    hints,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    completedImportChunks: [],
+    completedHintChunks: [],
+    completedRegularChunks: [],
+    completedErrorChunks: [],
+    writtenSymbols: new Map(),
+    writtenClientReferences: new Map(),
+    writtenServerReferences: new Map(),
+    writtenProviders: new Map(),
+    writtenObjects: new WeakMap(),
+    identifierPrefix: identifierPrefix || '',
+    identifierCount: 1,
+    taintCleanupQueue: cleanupQueue,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? defaultPostponeHandler : onPostpone,
+    // $FlowFixMe[missing-this-annot]
+    toJSON: function (key, value) {
+      return resolveModelToJSON(request, this, key, value);
+    }
+  };
+  request.pendingChunks++;
+  const rootContext = createRootContext(context);
+  const rootTask = createTask(request, model, rootContext, abortSet);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  return null;
+}
+
+function createRootContext(reqContext) {
+  return importServerContexts(reqContext);
+}
+
+const POP = {};
+
+function serializeThenable(request, thenable) {
+  request.pendingChunks++;
+  const newTask = createTask(request, null, getActiveContext(), request.abortableTasks);
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        // We have the resolved value, we can go ahead and schedule it for serialization.
+        newTask.model = thenable.value;
+        pingTask(request, newTask);
+        return newTask.id;
+      }
+
+    case 'rejected':
+      {
+        const x = thenable.reason;
+
+        if (typeof x === 'object' && x !== null && x.$$typeof === REACT_POSTPONE_TYPE) {
+          const postponeInstance = x;
+          logPostpone(request, postponeInstance.message);
+          emitPostponeChunk(request, newTask.id);
+        } else {
+          const digest = logRecoverableError(request, x);
+          emitErrorChunk(request, newTask.id, digest);
+        }
+
+        return newTask.id;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  thenable.then(value => {
+    newTask.model = value;
+    pingTask(request, newTask);
+  }, reason => {
+    newTask.status = ERRORED$1;
+    request.abortableTasks.delete(newTask); // TODO: We should ideally do this inside performWork so it's scheduled
+
+    const digest = logRecoverableError(request, reason);
+    emitErrorChunk(request, newTask.id, digest);
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  });
+  return newTask.id;
+}
+
+function emitHint(request, code, model) {
+  emitHintChunk(request, code, model);
+  enqueueFlush(request);
+}
+function getHints(request) {
+  return request.hints;
+}
+function getCache(request) {
+  return request.cache;
+}
+
+function readThenable(thenable) {
+  if (thenable.status === 'fulfilled') {
+    return thenable.value;
+  } else if (thenable.status === 'rejected') {
+    throw thenable.reason;
+  }
+
+  throw thenable;
+}
+
+function createLazyWrapperAroundWakeable(wakeable) {
+  // This is a temporary fork of the `use` implementation until we accept
+  // promises everywhere.
+  const thenable = wakeable;
+
+  switch (thenable.status) {
+    case 'fulfilled':
+    case 'rejected':
+      break;
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: thenable,
+    _init: readThenable
+  };
+  return lazyType;
+}
+
+function attemptResolveElement(request, type, key, ref, props, prevThenableState) {
+  if (ref !== null && ref !== undefined) {
+    // When the ref moves to the regular props object this will implicitly
+    // throw for functions. We could probably relax it to a DEV warning for other
+    // cases.
+    throw new Error('Refs cannot be used in Server Components, nor passed to Client Components.');
+  }
+
+  if (typeof type === 'function') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    } // This is a server-side component.
+
+
+    prepareToUseHooksForComponent(prevThenableState);
+    const result = type(props);
+
+    if (typeof result === 'object' && result !== null && typeof result.then === 'function') {
+      // When the return value is in children position we can resolve it immediately,
+      // to its value without a wrapper if it's synchronously available.
+      const thenable = result;
+
+      if (thenable.status === 'fulfilled') {
+        return thenable.value;
+      } // TODO: Once we accept Promises as children on the client, we can just return
+      // the thenable here.
+
+
+      return createLazyWrapperAroundWakeable(result);
+    }
+
+    return result;
+  } else if (typeof type === 'string') {
+    // This is a host element. E.g. HTML.
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (typeof type === 'symbol') {
+    if (type === REACT_FRAGMENT_TYPE) {
+      // For key-less fragments, we add a small optimization to avoid serializing
+      // it as a wrapper.
+      // TODO: If a key is specified, we should propagate its key to any children.
+      // Same as if a Server Component has a key.
+      return props.children;
+    } // This might be a built-in React component. We'll let the client decide.
+    // Any built-in works as long as its props are serializable.
+
+
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (type != null && typeof type === 'object') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    }
+
+    switch (type.$$typeof) {
+      case REACT_LAZY_TYPE:
+        {
+          const payload = type._payload;
+          const init = type._init;
+          const wrappedType = init(payload);
+          return attemptResolveElement(request, wrappedType, key, ref, props, prevThenableState);
+        }
+
+      case REACT_FORWARD_REF_TYPE:
+        {
+          const render = type.render;
+          prepareToUseHooksForComponent(prevThenableState);
+          return render(props, undefined);
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          return attemptResolveElement(request, type.type, key, ref, props, prevThenableState);
+        }
+
+      case REACT_PROVIDER_TYPE:
+        {
+          {
+            pushProvider(type._context, props.value);
+
+            return [REACT_ELEMENT_TYPE, type, key, // Rely on __popProvider being serialized last to pop the provider.
+            {
+              value: props.value,
+              children: props.children,
+              __pop: POP
+            }];
+          } // Fallthrough
+
+        }
+    }
+  }
+
+  throw new Error("Unsupported Server Component type: " + describeValueForErrorMessage(type));
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createTask(request, model, context, abortSet) {
+  const id = request.nextChunkId++;
+  const task = {
+    id,
+    status: PENDING$1,
+    model,
+    context,
+    ping: () => pingTask(request, task),
+    thenableState: null
+  };
+  abortSet.add(task);
+  return task;
+}
+
+function serializeByValueID(id) {
+  return '$' + id.toString(16);
+}
+
+function serializeLazyID(id) {
+  return '$L' + id.toString(16);
+}
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeProviderReference(name) {
+  return '$P' + name;
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeRowHeader(tag, id) {
+  return id.toString(16) + ':' + tag;
+}
+
+function encodeReferenceChunk(request, id, reference) {
+  const json = stringify(reference);
+  const row = id.toString(16) + ':' + json + '\n';
+  return stringToChunk(row);
+}
+
+function serializeClientReference(request, parent, key, clientReference) {
+  const clientReferenceKey = getClientReferenceKey(clientReference);
+  const writtenClientReferences = request.writtenClientReferences;
+  const existingId = writtenClientReferences.get(clientReferenceKey);
+
+  if (existingId !== undefined) {
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(existingId);
+    }
+
+    return serializeByValueID(existingId);
+  }
+
+  try {
+    const clientReferenceMetadata = resolveClientReferenceMetadata(request.bundlerConfig, clientReference);
+    request.pendingChunks++;
+    const importId = request.nextChunkId++;
+    emitImportChunk(request, importId, clientReferenceMetadata);
+    writtenClientReferences.set(clientReferenceKey, importId);
+
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(importId);
+    }
+
+    return serializeByValueID(importId);
+  } catch (x) {
+    request.pendingChunks++;
+    const errorId = request.nextChunkId++;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, errorId, digest);
+    return serializeByValueID(errorId);
+  }
+}
+
+function outlineModel(request, value) {
+  request.pendingChunks++;
+  const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+  retryTask(request, newTask);
+  return newTask.id;
+}
+
+function serializeServerReference(request, parent, key, serverReference) {
+  const writtenServerReferences = request.writtenServerReferences;
+  const existingId = writtenServerReferences.get(serverReference);
+
+  if (existingId !== undefined) {
+    return serializeServerReferenceID(existingId);
+  }
+
+  const bound = getServerReferenceBoundArguments(request.bundlerConfig, serverReference);
+  const serverReferenceMetadata = {
+    id: getServerReferenceId(request.bundlerConfig, serverReference),
+    bound: bound ? Promise.resolve(bound) : null
+  };
+  const metadataId = outlineModel(request, serverReferenceMetadata);
+  writtenServerReferences.set(serverReference, metadataId);
+  return serializeServerReferenceID(metadataId);
+}
+
+function serializeLargeTextString(request, text) {
+  request.pendingChunks += 2;
+  const textId = request.nextChunkId++;
+  const textChunk = stringToChunk(text);
+  const binaryLength = byteLengthOfChunk(textChunk);
+  const row = textId.toString(16) + ':T' + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, textChunk);
+  return serializeByValueID(textId);
+}
+
+function serializeMap(request, map) {
+  const entries = Array.from(map);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i][0];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$Q' + id.toString(16);
+}
+
+function serializeSet(request, set) {
+  const entries = Array.from(set);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$W' + id.toString(16);
+}
+
+function serializeTypedArray(request, tag, typedArray) {
+  {
+    if (TaintRegistryByteLengths.has(typedArray.byteLength)) {
+      // If we have had any tainted values of this length, we check
+      // to see if these bytes matches any entries in the registry.
+      const tainted = TaintRegistryValues.get(binaryToComparableString(typedArray));
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    }
+  }
+
+  request.pendingChunks += 2;
+  const bufferId = request.nextChunkId++; // TODO: Convert to little endian if that's not the server default.
+
+  const binaryChunk = typedArrayToBinaryChunk(typedArray);
+  const binaryLength = byteLengthOfBinaryChunk(binaryChunk);
+  const row = bufferId.toString(16) + ':' + tag + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, binaryChunk);
+  return serializeByValueID(bufferId);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+let modelRoot = false;
+
+function resolveModelToJSON(request, parent, key, value) {
+
+
+  switch (value) {
+    case REACT_ELEMENT_TYPE:
+      return '$';
+  }
+
+
+  while (typeof value === 'object' && value !== null && (value.$$typeof === REACT_ELEMENT_TYPE || value.$$typeof === REACT_LAZY_TYPE)) {
+
+    try {
+      switch (value.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const writtenObjects = request.writtenObjects;
+            const existingId = writtenObjects.get(value);
+
+            if (existingId !== undefined) {
+              if (existingId === -1) {
+                // Seen but not yet outlined.
+                const newId = outlineModel(request, value);
+                return serializeByValueID(newId);
+              } else if (modelRoot === value) {
+                // This is the ID we're currently emitting so we need to write it
+                // once but if we discover it again, we refer to it by id.
+                modelRoot = null;
+              } else {
+                // We've already emitted this as an outlined object, so we can
+                // just refer to that by its existing ID.
+                return serializeByValueID(existingId);
+              }
+            } else {
+              // This is the first time we've seen this object. We may never see it again
+              // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+              writtenObjects.set(value, -1);
+            } // TODO: Concatenate keys of parents onto children.
+
+
+            const element = value; // Attempt to render the Server Component.
+
+            value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, null);
+            break;
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = value._payload;
+            const init = value._init;
+            value = init(payload);
+            break;
+          }
+      }
+    } catch (thrownValue) {
+      const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          // Something suspended, we'll need to create a new task and resolve it later.
+          request.pendingChunks++;
+          const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+          const ping = newTask.ping;
+          x.then(ping, ping);
+          newTask.thenableState = getThenableStateAfterSuspending();
+          return serializeLazyID(newTask.id);
+        } else if (x.$$typeof === REACT_POSTPONE_TYPE) {
+          // Something postponed. We'll still send everything we have up until this point.
+          // We'll replace this element with a lazy reference that postpones on the client.
+          const postponeInstance = x;
+          request.pendingChunks++;
+          const postponeId = request.nextChunkId++;
+          logPostpone(request, postponeInstance.message);
+          emitPostponeChunk(request, postponeId);
+          return serializeLazyID(postponeId);
+        }
+      } // Something errored. We'll still send everything we have up until this point.
+      // We'll replace this element with a lazy reference that throws on the client
+      // once it gets rendered.
+
+
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+      const digest = logRecoverableError(request, x);
+      emitErrorChunk(request, errorId, digest);
+      return serializeLazyID(errorId);
+    }
+  }
+
+  if (value === null) {
+    return null;
+  }
+
+  if (typeof value === 'object') {
+    {
+      const tainted = TaintRegistryObjects.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted);
+      }
+    }
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    const writtenObjects = request.writtenObjects;
+    const existingId = writtenObjects.get(value); // $FlowFixMe[method-unbinding]
+
+    if (typeof value.then === 'function') {
+      if (existingId !== undefined) {
+        if (modelRoot === value) {
+          // This is the ID we're currently emitting so we need to write it
+          // once but if we discover it again, we refer to it by id.
+          modelRoot = null;
+        } else {
+          // We've seen this promise before, so we can just refer to the same result.
+          return serializePromiseID(existingId);
+        }
+      } // We assume that any object with a .then property is a "Thenable" type,
+      // or a Promise type. Either of which can be represented by a Promise.
+
+
+      const promiseId = serializeThenable(request, value);
+      writtenObjects.set(value, promiseId);
+      return serializePromiseID(promiseId);
+    }
+
+    {
+      if (value.$$typeof === REACT_PROVIDER_TYPE) {
+        const providerKey = value._context._globalName;
+        const writtenProviders = request.writtenProviders;
+        let providerId = writtenProviders.get(key);
+
+        if (providerId === undefined) {
+          request.pendingChunks++;
+          providerId = request.nextChunkId++;
+          writtenProviders.set(providerKey, providerId);
+          emitProviderChunk(request, providerId, providerKey);
+        }
+
+        return serializeByValueID(providerId);
+      } else if (value === POP) {
+        popProvider();
+
+        return undefined;
+      }
+    }
+
+    if (existingId !== undefined) {
+      if (existingId === -1) {
+        // Seen but not yet outlined.
+        const newId = outlineModel(request, value);
+        return serializeByValueID(newId);
+      } else if (modelRoot === value) {
+        // This is the ID we're currently emitting so we need to write it
+        // once but if we discover it again, we refer to it by id.
+        modelRoot = null;
+      } else {
+        // We've already emitted this as an outlined object, so we can
+        // just refer to that by its existing ID.
+        return serializeByValueID(existingId);
+      }
+    } else {
+      // This is the first time we've seen this object. We may never see it again
+      // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+      writtenObjects.set(value, -1);
+    }
+
+    if (isArray(value)) {
+      // $FlowFixMe[incompatible-return]
+      return value;
+    }
+
+    if (value instanceof Map) {
+      return serializeMap(request, value);
+    }
+
+    if (value instanceof Set) {
+      return serializeSet(request, value);
+    }
+
+    {
+      if (value instanceof ArrayBuffer) {
+        return serializeTypedArray(request, 'A', new Uint8Array(value));
+      }
+
+      if (value instanceof Int8Array) {
+        // char
+        return serializeTypedArray(request, 'C', value);
+      }
+
+      if (value instanceof Uint8Array) {
+        // unsigned char
+        return serializeTypedArray(request, 'c', value);
+      }
+
+      if (value instanceof Uint8ClampedArray) {
+        // unsigned clamped char
+        return serializeTypedArray(request, 'U', value);
+      }
+
+      if (value instanceof Int16Array) {
+        // sort
+        return serializeTypedArray(request, 'S', value);
+      }
+
+      if (value instanceof Uint16Array) {
+        // unsigned short
+        return serializeTypedArray(request, 's', value);
+      }
+
+      if (value instanceof Int32Array) {
+        // long
+        return serializeTypedArray(request, 'L', value);
+      }
+
+      if (value instanceof Uint32Array) {
+        // unsigned long
+        return serializeTypedArray(request, 'l', value);
+      }
+
+      if (value instanceof Float32Array) {
+        // float
+        return serializeTypedArray(request, 'F', value);
+      }
+
+      if (value instanceof Float64Array) {
+        // double
+        return serializeTypedArray(request, 'D', value);
+      }
+
+      if (value instanceof BigInt64Array) {
+        // number
+        return serializeTypedArray(request, 'N', value);
+      }
+
+      if (value instanceof BigUint64Array) {
+        // unsigned number
+        // We use "m" instead of "n" since JSON can start with "null"
+        return serializeTypedArray(request, 'm', value);
+      }
+
+      if (value instanceof DataView) {
+        return serializeTypedArray(request, 'V', value);
+      }
+    }
+
+    const iteratorFn = getIteratorFn(value);
+
+    if (iteratorFn) {
+      return Array.from(value);
+    } // Verify that this is a simple plain object.
+
+
+    const proto = getPrototypeOf(value);
+
+    if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+      throw new Error('Only plain objects, and a few built-ins, can be passed to Client Components ' + 'from Server Components. Classes or null prototypes are not supported.');
+    }
+
+
+    return value;
+  }
+
+  if (typeof value === 'string') {
+    {
+      const tainted = TaintRegistryValues.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    } // TODO: Maybe too clever. If we support URL there's no similar trick.
+
+
+    if (value[value.length - 1] === 'Z') {
+      // Possibly a Date, whose toJSON automatically calls toISOString
+      // $FlowFixMe[incompatible-use]
+      const originalValue = parent[key];
+
+      if (originalValue instanceof Date) {
+        return serializeDateFromDateJSON(value);
+      }
+    }
+
+    if (value.length >= 1024) {
+      // For large strings, we encode them outside the JSON payload so that we
+      // don't have to double encode and double parse the strings. This can also
+      // be more compact in case the string has a lot of escaped characters.
+      return serializeLargeTextString(request, value);
+    }
+
+    return escapeStringValue(value);
+  }
+
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  if (typeof value === 'number') {
+    return serializeNumber(value);
+  }
+
+  if (typeof value === 'undefined') {
+    return serializeUndefined();
+  }
+
+  if (typeof value === 'function') {
+    {
+      const tainted = TaintRegistryObjects.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted);
+      }
+    }
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    if (isServerReference(value)) {
+      return serializeServerReference(request, parent, key, value);
+    }
+
+    if (/^on[A-Z]/.test(key)) {
+      throw new Error('Event handlers cannot be passed to Client Component props.' + describeObjectForErrorMessage(parent, key) + '\nIf you need interactivity, consider converting part of this to a Client Component.');
+    } else {
+      throw new Error('Functions cannot be passed directly to Client Components ' + 'unless you explicitly expose it by marking it with "use server".' + describeObjectForErrorMessage(parent, key));
+    }
+  }
+
+  if (typeof value === 'symbol') {
+    const writtenSymbols = request.writtenSymbols;
+    const existingId = writtenSymbols.get(value);
+
+    if (existingId !== undefined) {
+      return serializeByValueID(existingId);
+    } // $FlowFixMe[incompatible-type] `description` might be undefined
+
+
+    const name = value.description;
+
+    if (Symbol.for(name) !== value) {
+      throw new Error('Only global symbols received from Symbol.for(...) can be passed to Client Components. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+      value.description + ") cannot be found among global symbols.") + describeObjectForErrorMessage(parent, key));
+    }
+
+    request.pendingChunks++;
+    const symbolId = request.nextChunkId++;
+    emitSymbolChunk(request, symbolId, name);
+    writtenSymbols.set(value, symbolId);
+    return serializeByValueID(symbolId);
+  }
+
+  if (typeof value === 'bigint') {
+    {
+      const tainted = TaintRegistryValues.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    }
+
+    return serializeBigInt(value);
+  }
+
+  throw new Error("Type " + typeof value + " is not supported in Client Component props." + describeObjectForErrorMessage(parent, key));
+}
+
+function logPostpone(request, reason) {
+  const onPostpone = request.onPostpone;
+  onPostpone(reason);
+}
+
+function logRecoverableError(request, error) {
+  const onError = request.onError;
+  const errorDigest = onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest || '';
+}
+
+function fatalError(request, error) {
+  {
+    cleanupTaintQueue(request);
+  } // This is called outside error handling code such as if an error happens in React internals.
+
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function emitPostponeChunk(request, id, postponeInstance) {
+  let row;
+
+  {
+    // No reason included in prod.
+    row = serializeRowHeader('P', id) + '\n';
+  }
+
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitErrorChunk(request, id, digest, error) {
+  let errorInfo;
+
+  {
+    errorInfo = {
+      digest
+    };
+  }
+
+  const row = serializeRowHeader('E', id) + stringify(errorInfo) + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitImportChunk(request, id, clientReferenceMetadata) {
+  // $FlowFixMe[incompatible-type] stringify can return null
+  const json = stringify(clientReferenceMetadata);
+  const row = serializeRowHeader('I', id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitHintChunk(request, code, model) {
+  const json = stringify(model);
+  const id = request.nextChunkId++;
+  const row = serializeRowHeader('H' + code, id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedHintChunks.push(processedChunk);
+}
+
+function emitSymbolChunk(request, id, name) {
+  const symbolReference = serializeSymbolReference(name);
+  const processedChunk = encodeReferenceChunk(request, id, symbolReference);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitProviderChunk(request, id, contextName) {
+  const contextReference = serializeProviderReference(contextName);
+  const processedChunk = encodeReferenceChunk(request, id, contextReference);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function emitModelChunk(request, id, model) {
+  // Track the root so we know that we have to emit this object even though it
+  // already has an ID. This is needed because we might see this object twice
+  // in the same toJSON if it is cyclic.
+  modelRoot = model; // $FlowFixMe[incompatible-type] stringify can return null
+
+  const json = stringify(model, request.toJSON);
+  const row = id.toString(16) + ':' + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function retryTask(request, task) {
+  if (task.status !== PENDING$1) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  }
+
+  switchContext(task.context);
+
+  try {
+    let value = task.model;
+
+    if (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+      request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+      const element = value; // When retrying a component, reuse the thenableState from the
+      // previous attempt.
+
+      const prevThenableState = task.thenableState; // Attempt to render the Server Component.
+      // Doing this here lets us reuse this same task if the next component
+      // also suspends.
+
+      task.model = value;
+      value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, prevThenableState); // Successfully finished this component. We're going to keep rendering
+      // using the same task, but we reset its thenable state before continuing.
+
+      task.thenableState = null; // Keep rendering and reuse the same task. This inner loop is separate
+      // from the render above because we don't need to reset the thenable state
+      // until the next time something suspends and retries.
+
+      while (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+        request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+        const nextElement = value;
+        task.model = value;
+        value = attemptResolveElement(request, nextElement.type, nextElement.key, nextElement.ref, nextElement.props, null);
+      }
+    } // Track that this object is outlined and has an id.
+
+
+    if (typeof value === 'object' && value !== null) {
+      request.writtenObjects.set(value, task.id);
+    }
+
+    emitModelChunk(request, task.id, value);
+    request.abortableTasks.delete(task);
+    task.status = COMPLETED;
+  } catch (thrownValue) {
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      } else if (x.$$typeof === REACT_POSTPONE_TYPE) {
+        request.abortableTasks.delete(task);
+        task.status = ERRORED$1;
+        const postponeInstance = x;
+        logPostpone(request, postponeInstance.message);
+        emitPostponeChunk(request, task.id);
+        return;
+      }
+    }
+
+    request.abortableTasks.delete(task);
+    task.status = ERRORED$1;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, task.id, digest);
+  }
+}
+
+function performWork(request) {
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  const prevRequest = currentRequest;
+  currentRequest = request;
+  prepareToUseHooksForRequest(request);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    request.pingedTasks = [];
+
+    for (let i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    ReactCurrentDispatcher.current = prevDispatcher;
+    resetHooksForRequest();
+    currentRequest = prevRequest;
+  }
+}
+
+function abortTask(task, request, errorId) {
+  task.status = ABORTED; // Instead of emitting an error per task.id, we emit a model that only
+  // has a single value referencing the error.
+
+  const ref = serializeByValueID(errorId);
+  const processedChunk = encodeReferenceChunk(request, task.id, ref);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function flushCompletedChunks(request, destination) {
+  beginWriting();
+
+  try {
+    // We emit module chunks first in the stream so that
+    // they can be preloaded as early as possible.
+    const importsChunks = request.completedImportChunks;
+    let i = 0;
+
+    for (; i < importsChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = importsChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    importsChunks.splice(0, i); // Next comes hints.
+
+    const hintChunks = request.completedHintChunks;
+    i = 0;
+
+    for (; i < hintChunks.length; i++) {
+      const chunk = hintChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    hintChunks.splice(0, i); // Next comes model data.
+
+    const regularChunks = request.completedRegularChunks;
+    i = 0;
+
+    for (; i < regularChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = regularChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    regularChunks.splice(0, i); // Finally, errors are sent. The idea is that it's ok to delay
+    // any error messages and prioritize display of other parts of
+    // the page.
+
+    const errorChunks = request.completedErrorChunks;
+    i = 0;
+
+    for (; i < errorChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = errorChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    errorChunks.splice(0, i);
+  } finally {
+    request.flushScheduled = false;
+    completeWriting(destination);
+  }
+
+  if (request.pendingChunks === 0) {
+    // We're done.
+    {
+      cleanupTaintQueue(request);
+    }
+
+    close$1(destination);
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  {
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    const destination = request.destination;
+    request.flushScheduled = true;
+    scheduleWork(() => flushCompletedChunks(request, destination));
+  }
+}
+
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedChunks(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function stopFlowing(request) {
+  request.destination = null;
+} // This is called to early terminate a request. It creates an error at all pending tasks.
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      // We have tasks to abort. We'll emit one error row and then emit a reference
+      // to that row from every row that's still remaining.
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+
+      if (enablePostpone && typeof reason === 'object' && reason !== null && reason.$$typeof === REACT_POSTPONE_TYPE) {
+        const postponeInstance = reason;
+        logPostpone(request, postponeInstance.message);
+        emitPostponeChunk(request, errorId, postponeInstance);
+      } else {
+        const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+        const digest = logRecoverableError(request, error);
+        emitErrorChunk(request, errorId, digest, error);
+      }
+
+      abortableTasks.forEach(task => abortTask(task, request, errorId));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function importServerContexts(contexts) {
+  if (contexts) {
+    const prevContext = getActiveContext();
+    switchContext(rootContextSnapshot);
+
+    for (let i = 0; i < contexts.length; i++) {
+      const _contexts$i = contexts[i],
+            name = _contexts$i[0],
+            value = _contexts$i[1];
+      const context = getOrCreateServerContext(name);
+      pushProvider(context, value);
+    }
+
+    const importedContext = getActiveContext();
+    switchContext(prevContext);
+    return importedContext;
+  }
+
+  return rootContextSnapshot;
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+function resolveServerReference(bundlerConfig, id) {
+  let name = '';
+  let resolvedModuleData = bundlerConfig[id];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = id.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = id.slice(idx + 1);
+      resolvedModuleData = bundlerConfig[id.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + id + '" in the React Server Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  } // TODO: This needs to return async: true if it's an async module.
+
+
+  return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+} // The chunk cache contains all the chunks we've preloaded so far.
+// If they're still pending they're a thenable. This map also exists
+// in Webpack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = __webpack_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+  let i = 0;
+
+  while (i < chunks.length) {
+    const chunkId = chunks[i++];
+    const chunkFilename = chunks[i++];
+    const entry = chunkCache.get(chunkId);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkId, chunkFilename);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkId, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkId, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = __webpack_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+const chunkMap = new Map();
+/**
+ * We patch the chunk filename function in webpack to insert our own resolution
+ * of chunks that come from Flight and may not be known to the webpack runtime
+ */
+
+const webpackGetChunkFilename = __webpack_require__.u;
+
+__webpack_require__.u = function (chunkId) {
+  const flightChunk = chunkMap.get(chunkId);
+
+  if (flightChunk !== undefined) {
+    return flightChunk;
+  }
+
+  return webpackGetChunkFilename(chunkId);
+};
+
+function loadChunk(chunkId, filename) {
+  chunkMap.set(chunkId, filename);
+  return __webpack_chunk_load__(chunkId);
+}
+
+// The server acts as a Client of itself when resolving Server References.
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const RESOLVED_MODEL = 'resolved_model';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function bindArgs$1(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference$1(response, id, bound, parentChunk, parentObject, key) {
+  const serverReference = resolveServerReference(response._bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+  let promise;
+
+  if (bound) {
+    promise = Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs$1(requireModule(serverReference), args);
+    });
+  } else {
+    if (preloadPromise) {
+      promise = Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+    } else {
+      // Synchronously available
+      return requireModule(serverReference);
+    }
+  }
+
+  promise.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk)); // We need a placeholder value that will be replaced later.
+
+  return null;
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+
+  try {
+    const value = JSON.parse(chunk.value, chunk._response._fromJSON);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    const prefix = response._prefix;
+    const key = prefix + id; // Check if we have this field in the backing store already.
+
+    const backingEntry = response._formData.get(key);
+
+    if (backingEntry != null) {
+      // We assume that this is a string entry for now.
+      chunk = createResolvedModelChunk(response, backingEntry);
+    } else {
+      // We're still waiting on this entry to stream in.
+      chunk = createPendingChunk(response);
+    }
+
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+    blocked.deps++;
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  if (chunk.status === RESOLVED_MODEL) {
+    initializeModelChunk(chunk);
+  }
+
+  if (chunk.status !== INITIALIZED) {
+    // We know that this is emitted earlier so otherwise it's an error.
+    throw chunk.reason;
+  }
+
+  return chunk.value;
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16); // TODO: Just encode this in the reference inline instead of as a model.
+
+          const metaData = getOutlinedModel(response, id);
+          return loadServerReference$1(response, metaData.id, metaData.bound, initializingChunk, parentObject, key);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'K':
+        {
+          // FormData
+          const stringId = value.slice(2);
+          const formPrefix = response._prefix + stringId + '_';
+          const data = new FormData();
+          const backingFormData = response._formData; // We assume that the reference to FormData always comes after each
+          // entry that it references so we can assume they all exist in the
+          // backing store already.
+          // $FlowFixMe[prop-missing] FormData has forEach on it.
+
+          backingFormData.forEach((entry, entryKey) => {
+            if (entryKey.startsWith(formPrefix)) {
+              data.append(entryKey.slice(formPrefix.length), entry);
+            }
+          });
+          return data;
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function createResponse(bundlerConfig, formFieldPrefix) {
+  let backingFormData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new FormData();
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _prefix: formFieldPrefix,
+    _formData: backingFormData,
+    _chunks: chunks,
+    _fromJSON: function (key, value) {
+      if (typeof value === 'string') {
+        // We can't use .bind here because we need the "this" value.
+        return parseModelString(response, this, key, value);
+      }
+
+      return value;
+    }
+  };
+  return response;
+}
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function bindArgs(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference(bundlerConfig, id, bound) {
+  const serverReference = resolveServerReference(bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+
+  if (bound) {
+    return Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs(requireModule(serverReference), args);
+    });
+  } else if (preloadPromise) {
+    return Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+  } else {
+    // Synchronously available
+    return Promise.resolve(requireModule(serverReference));
+  }
+}
+
+function decodeBoundActionMetaData(body, serverManifest, formFieldPrefix) {
+  // The data for this reference is encoded in multiple fields under this prefix.
+  const actionResponse = createResponse(serverManifest, formFieldPrefix, body);
+  close(actionResponse);
+  const refPromise = getRoot(actionResponse); // Force it to initialize
+  // $FlowFixMe
+
+  refPromise.then(() => {});
+
+  if (refPromise.status !== 'fulfilled') {
+    // $FlowFixMe
+    throw refPromise.reason;
+  }
+
+  return refPromise.value;
+}
+
+function decodeAction(body, serverManifest) {
+  // We're going to create a new formData object that holds all the fields except
+  // the implementation details of the action data.
+  const formData = new FormData();
+  let action = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (!key.startsWith('$ACTION_')) {
+      formData.append(key, value);
+      return;
+    } // Later actions may override earlier actions if a button is used to override the default
+    // form action.
+
+
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      const metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+      action = loadServerReference(serverManifest, metaData.id, metaData.bound);
+      return;
+    }
+
+    if (key.startsWith('$ACTION_ID_')) {
+      const id = key.slice(11);
+      action = loadServerReference(serverManifest, id, null);
+      return;
+    }
+  });
+
+  if (action === null) {
+    return null;
+  } // Return the action with the remaining FormData bound to the first argument.
+
+
+  return action.then(fn => fn.bind(null, formData));
+}
+function decodeFormState(actionResult, body, serverManifest) {
+  const keyPath = body.get('$ACTION_KEY');
+
+  if (typeof keyPath !== 'string') {
+    // This form submission did not include any form state.
+    return Promise.resolve(null);
+  } // Search through the form data object to get the reference id and the number
+  // of bound arguments. This repeats some of the work done in decodeAction.
+
+
+  let metaData = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+    } // We don't check for the simple $ACTION_ID_ case because form state actions
+    // are always bound to the state argument.
+
+  });
+
+  if (metaData === null) {
+    // Should be unreachable.
+    return Promise.resolve(null);
+  }
+
+  const referenceId = metaData.id;
+  return Promise.resolve(metaData.bound).then(bound => {
+    if (bound === null) {
+      // Should be unreachable because form state actions are always bound to the
+      // state argument.
+      return null;
+    } // The form action dispatch method is always bound to the initial state.
+    // But when comparing signatures, we compare to the original unbound action.
+    // Subtract one from the arity to account for this.
+
+
+    const boundArity = bound.length - 1;
+    return [actionResult, keyPath, referenceId, boundArity];
+  });
+}
+
+function renderToReadableStream(model, webpackMap, options) {
+  const request = createRequest(model, webpackMap, options ? options.onError : undefined, options ? options.context : undefined, options ? options.identifierPrefix : undefined, options ? options.onPostpone : undefined);
+
+  if (options && options.signal) {
+    const signal = options.signal;
+
+    if (signal.aborted) {
+      abort(request, signal.reason);
+    } else {
+      const listener = () => {
+        abort(request, signal.reason);
+        signal.removeEventListener('abort', listener);
+      };
+
+      signal.addEventListener('abort', listener);
+    }
+  }
+
+  const stream = new ReadableStream({
+    type: 'bytes',
+    start: controller => {
+      startWork(request);
+    },
+    pull: controller => {
+      startFlowing(request, controller);
+    },
+    cancel: reason => {
+      stopFlowing(request);
+      abort(request, reason);
+    }
+  }, // $FlowFixMe[prop-missing] size() methods are not allowed on byte streams.
+  {
+    highWaterMark: 0
+  });
+  return stream;
+}
+
+function decodeReply(body, webpackMap) {
+  if (typeof body === 'string') {
+    const form = new FormData();
+    form.append('0', body);
+    body = form;
+  }
+
+  const response = createResponse(webpackMap, '', body);
+  const root = getRoot(response);
+  close(response);
+  return root;
+}
+
+exports.createClientModuleProxy = createClientModuleProxy;
+exports.decodeAction = decodeAction;
+exports.decodeFormState = decodeFormState;
+exports.decodeReply = decodeReply;
+exports.registerClientReference = registerClientReference;
+exports.registerServerReference = registerServerReference;
+exports.renderToReadableStream = renderToReadableStream;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.browser.production.min.js b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.browser.production.min.js
index 548b5d1100959..4eb54b069e6fd 100644
--- a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.browser.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.browser.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-webpack-server.browser.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-webpack-server.browser.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var aa=require("react-dom"),ba=require("react"),l=null,n=0;function p(a,b){if(0!==b.byteLength)if(512<b.byteLength)0<n&&(a.enqueue(new Uint8Array(l.buffer,0,n)),l=new Uint8Array(512),n=0),a.enqueue(b);else{var d=l.length-n;d<b.byteLength&&(0===d?a.enqueue(l):(l.set(b.subarray(0,d),n),a.enqueue(l),b=b.subarray(d)),l=new Uint8Array(512),n=0);l.set(b,n);n+=b.byteLength}return!0}var q=new TextEncoder;function ca(a,b){"function"===typeof a.error?a.error(b):a.close()}
 var r=Symbol.for("react.client.reference"),t=Symbol.for("react.server.reference");function u(a,b,d){return Object.defineProperties(a,{$$typeof:{value:r},$$id:{value:b},$$async:{value:d}})}var da=Function.prototype.bind,ea=Array.prototype.slice;function fa(){var a=da.apply(this,arguments);if(this.$$typeof===t){var b=ea.call(arguments,1);a.$$typeof=t;a.$$id=this.$$id;a.$$bound=this.$$bound?this.$$bound.concat(b):b}return a}
 var ha=Promise.prototype,ia={get:function(a,b){switch(b){case "$$typeof":return a.$$typeof;case "$$id":return a.$$id;case "$$async":return a.$$async;case "name":return a.name;case "displayName":return;case "defaultProps":return;case "toJSON":return;case Symbol.toPrimitive:return Object.prototype[Symbol.toPrimitive];case "Provider":throw Error("Cannot render a Client Context Provider on the Server. Instead, you can export a Client Component wrapper that itself renders a Client Context Provider.");
@@ -81,3 +81,5 @@ exports.decodeFormState=function(a,b,d){var c=b.get("$ACTION_KEY");if("string"!=
 exports.registerClientReference=function(a,b,d){return u(a,b+"#"+d,!1)};exports.registerServerReference=function(a,b,d){return Object.defineProperties(a,{$$typeof:{value:t},$$id:{value:null===d?b:b+"#"+d},$$bound:{value:null},bind:{value:fa}})};
 exports.renderToReadableStream=function(a,b,d){var c=ob(a,b,d?d.onError:void 0,d?d.context:void 0,d?d.identifierPrefix:void 0,d?d.onPostpone:void 0);if(d&&d.signal){var e=d.signal;if(e.aborted)Eb(c,e.reason);else{var f=function(){Eb(c,e.reason);e.removeEventListener("abort",f)};e.addEventListener("abort",f)}}return new ReadableStream({type:"bytes",start:function(){c.flushScheduled=null!==c.destination;zb(c)},pull:function(g){if(1===c.status)c.status=2,ca(g,c.fatalError);else if(2!==c.status&&null===
 c.destination){c.destination=g;try{Q(c,g)}catch(h){O(c,h),Db(c,h)}}},cancel:function(g){c.destination=null;Eb(c,g)}},{highWaterMark:0})};
+
+//# sourceMappingURL=react-server-dom-webpack-server.browser.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.edge.production.js b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.edge.production.js
new file mode 100644
index 0000000000000..7cd06d231d8ec
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.edge.production.js
@@ -0,0 +1,3467 @@
+/**
+ * @license React
+ * react-server-dom-webpack-server.edge.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require('react');
+var ReactDOM = require('react-dom');
+
+// -----------------------------------------------------------------------------
+const enablePostpone = true;
+
+function scheduleWork(callback) {
+  setTimeout(callback, 0);
+}
+const VIEW_SIZE = 512;
+let currentView = null;
+let writtenBytes = 0;
+function beginWriting(destination) {
+  currentView = new Uint8Array(VIEW_SIZE);
+  writtenBytes = 0;
+}
+function writeChunk(destination, chunk) {
+  if (chunk.byteLength === 0) {
+    return;
+  }
+
+  if (chunk.byteLength > VIEW_SIZE) {
+    // one that is cached by the streaming renderer. We will enqueu
+    // it directly and expect it is not re-used
+
+
+    if (writtenBytes > 0) {
+      destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    destination.enqueue(chunk);
+    return;
+  }
+
+  let bytesToWrite = chunk;
+  const allowableBytes = currentView.length - writtenBytes;
+
+  if (allowableBytes < bytesToWrite.byteLength) {
+    // this chunk would overflow the current view. We enqueue a full view
+    // and start a new view with the remaining chunk
+    if (allowableBytes === 0) {
+      // the current view is already full, send it
+      destination.enqueue(currentView);
+    } else {
+      // fill up the current view and apply the remaining chunk bytes
+      // to a new view.
+      currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes); // writtenBytes += allowableBytes; // this can be skipped because we are going to immediately reset the view
+
+      destination.enqueue(currentView);
+      bytesToWrite = bytesToWrite.subarray(allowableBytes);
+    }
+
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+
+  currentView.set(bytesToWrite, writtenBytes);
+  writtenBytes += bytesToWrite.byteLength;
+}
+function writeChunkAndReturn(destination, chunk) {
+  writeChunk(destination, chunk); // in web streams there is no backpressure so we can alwas write more
+
+  return true;
+}
+function completeWriting(destination) {
+  if (currentView && writtenBytes > 0) {
+    destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+    currentView = null;
+    writtenBytes = 0;
+  }
+}
+function close$1(destination) {
+  destination.close();
+}
+const textEncoder = new TextEncoder();
+function stringToChunk(content) {
+  return textEncoder.encode(content);
+}
+function typedArrayToBinaryChunk(content) {
+  // Convert any non-Uint8Array array to Uint8Array. We could avoid this for Uint8Arrays.
+  // If we passed through this straight to enqueue we wouldn't have to convert it but since
+  // we need to copy the buffer in that case, we need to convert it to copy it.
+  // When we copy it into another array using set() it needs to be a Uint8Array.
+  const buffer = new Uint8Array(content.buffer, content.byteOffset, content.byteLength); // We clone large chunks so that we can transfer them when we write them.
+  // Others get copied into the target buffer.
+
+  return content.byteLength > VIEW_SIZE ? buffer.slice() : buffer;
+}
+function byteLengthOfChunk(chunk) {
+  return chunk.byteLength;
+}
+function byteLengthOfBinaryChunk(chunk) {
+  return chunk.byteLength;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[method-unbinding]
+  if (typeof destination.error === 'function') {
+    // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+    destination.error(error);
+  } else {
+    // Earlier implementations doesn't support this method. In that environment you're
+    // supposed to throw from a promise returned but we don't return a promise in our
+    // approach. We could fork this implementation but this is environment is an edge
+    // case to begin with. It's even less common to run this in an older environment.
+    // Even then, this is not where errors are supposed to happen and they get reported
+    // to a global callback in addition to this anyway. So it's fine just to close this.
+    destination.close();
+  }
+}
+
+// eslint-disable-next-line no-unused-vars
+const CLIENT_REFERENCE_TAG = Symbol.for('react.client.reference');
+const SERVER_REFERENCE_TAG = Symbol.for('react.server.reference');
+function isClientReference(reference) {
+  return reference.$$typeof === CLIENT_REFERENCE_TAG;
+}
+function isServerReference(reference) {
+  return reference.$$typeof === SERVER_REFERENCE_TAG;
+}
+function registerClientReference(proxyImplementation, id, exportName) {
+  return registerClientReferenceImpl(proxyImplementation, id + '#' + exportName, false);
+}
+
+function registerClientReferenceImpl(proxyImplementation, id, async) {
+  return Object.defineProperties(proxyImplementation, {
+    $$typeof: {
+      value: CLIENT_REFERENCE_TAG
+    },
+    $$id: {
+      value: id
+    },
+    $$async: {
+      value: async
+    }
+  });
+} // $FlowFixMe[method-unbinding]
+
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+
+  if (this.$$typeof === SERVER_REFERENCE_TAG) {
+    const args = ArraySlice.call(arguments, 1);
+    newFn.$$typeof = SERVER_REFERENCE_TAG;
+    newFn.$$id = this.$$id;
+    newFn.$$bound = this.$$bound ? this.$$bound.concat(args) : args;
+  }
+
+  return newFn;
+}
+
+function registerServerReference(reference, id, exportName) {
+  return Object.defineProperties(reference, {
+    $$typeof: {
+      value: SERVER_REFERENCE_TAG
+    },
+    $$id: {
+      value: exportName === null ? id : id + '#' + exportName
+    },
+    $$bound: {
+      value: null
+    },
+    bind: {
+      value: bind
+    }
+  });
+}
+const PROMISE_PROTOTYPE = Promise.prototype;
+const deepProxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        // These names are a little too common. We should probably have a way to
+        // have the Flight runtime extract the inner target instead.
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+
+      case 'displayName':
+        return undefined;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case 'Provider':
+        throw new Error("Cannot render a Client Context Provider on the Server. " + "Instead, you can export a Client Component wrapper " + "that itself renders a Client Context Provider.");
+    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+    const expression = String(target.name) + '.' + String(name);
+    throw new Error("Cannot access " + expression + " on the server. " + 'You cannot dot into a client module from a server component. ' + 'You can only pass the imported name through.');
+  },
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+
+function getReference(target, name) {
+  switch (name) {
+    // These names are read by the Flight runtime if you end up using the exports object.
+    case '$$typeof':
+      return target.$$typeof;
+
+    case '$$id':
+      return target.$$id;
+
+    case '$$async':
+      return target.$$async;
+
+    case 'name':
+      return target.name;
+    // We need to special case this because createElement reads it if we pass this
+    // reference.
+
+    case 'defaultProps':
+      return undefined;
+    // Avoid this attempting to be serialized.
+
+    case 'toJSON':
+      return undefined;
+
+    case Symbol.toPrimitive:
+      // $FlowFixMe[prop-missing]
+      return Object.prototype[Symbol.toPrimitive];
+
+    case '__esModule':
+      // Something is conditionally checking which export to use. We'll pretend to be
+      // an ESM compat module but then we'll check again on the client.
+      const moduleId = target.$$id;
+      target.default = registerClientReferenceImpl(function () {
+        throw new Error("Attempted to call the default export of " + moduleId + " from the server " + "but it's on the client. It's not possible to invoke a client function from " + "the server, it can only be rendered as a Component or passed to props of a " + "Client Component.");
+      }, target.$$id + '#', target.$$async);
+      return true;
+
+    case 'then':
+      if (target.then) {
+        // Use a cached value
+        return target.then;
+      }
+
+      if (!target.$$async) {
+        // If this module is expected to return a Promise (such as an AsyncModule) then
+        // we should resolve that with a client reference that unwraps the Promise on
+        // the client.
+        const clientReference = registerClientReferenceImpl({}, target.$$id, true);
+        const proxy = new Proxy(clientReference, proxyHandlers); // Treat this as a resolved Promise for React's use()
+
+        target.status = 'fulfilled';
+        target.value = proxy;
+        const then = target.then = registerClientReferenceImpl(function then(resolve, reject) {
+          // Expose to React.
+          return Promise.resolve(resolve(proxy));
+        }, // If this is not used as a Promise but is treated as a reference to a `.then`
+        // export then we should treat it as a reference to that name.
+        target.$$id + '#then', false);
+        return then;
+      } else {
+        // Since typeof .then === 'function' is a feature test we'd continue recursing
+        // indefinitely if we return a function. Instead, we return an object reference
+        // if we check further.
+        return undefined;
+      }
+
+  }
+
+  let cachedReference = target[name];
+
+  if (!cachedReference) {
+    const reference = registerClientReferenceImpl(function () {
+      throw new Error( // eslint-disable-next-line react-internal/safe-string-coercion
+      "Attempted to call " + String(name) + "() from the server but " + String(name) + " is on the client. " + "It's not possible to invoke a client function from the server, it can " + "only be rendered as a Component or passed to props of a Client Component.");
+    }, target.$$id + '#' + name, target.$$async);
+    Object.defineProperty(reference, 'name', {
+      value: name
+    });
+    cachedReference = target[name] = new Proxy(reference, deepProxyHandlers);
+  }
+
+  return cachedReference;
+}
+
+const proxyHandlers = {
+  get: function (target, name, receiver) {
+    return getReference(target, name);
+  },
+  getOwnPropertyDescriptor: function (target, name) {
+    let descriptor = Object.getOwnPropertyDescriptor(target, name);
+
+    if (!descriptor) {
+      descriptor = {
+        value: getReference(target, name),
+        writable: false,
+        configurable: false,
+        enumerable: false
+      };
+      Object.defineProperty(target, name, descriptor);
+    }
+
+    return descriptor;
+  },
+
+  getPrototypeOf(target) {
+    // Pretend to be a Promise in case anyone asks.
+    return PROMISE_PROTOTYPE;
+  },
+
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+function createClientModuleProxy(moduleId) {
+  const clientReference = registerClientReferenceImpl({}, // Represents the whole Module object instead of a particular import.
+  moduleId, false);
+  return new Proxy(clientReference, proxyHandlers);
+}
+
+function getClientReferenceKey(reference) {
+  return reference.$$async ? reference.$$id + '#async' : reference.$$id;
+}
+function resolveClientReferenceMetadata(config, clientReference) {
+  const modulePath = clientReference.$$id;
+  let name = '';
+  let resolvedModuleData = config[modulePath];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = modulePath.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = modulePath.slice(idx + 1);
+      resolvedModuleData = config[modulePath.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + modulePath + '" in the React Client Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  }
+
+  if (clientReference.$$async === true) {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1];
+  } else {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+  }
+}
+function getServerReferenceId(config, serverReference) {
+  return serverReference.$$id;
+}
+function getServerReferenceBoundArguments(config, serverReference) {
+  return serverReference.$$bound;
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMFlightServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule: preloadModule$1,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+
+function prefetchDNS(href) {
+  {
+    if (typeof href === 'string' && href) {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'D|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        emitHint(request, 'D', href);
+      }
+    }
+  }
+}
+
+function preconnect(href, crossOrigin) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = "C|" + (crossOrigin == null ? 'null' : crossOrigin) + "|" + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+
+        if (typeof crossOrigin === 'string') {
+          emitHint(request, 'C', [href, crossOrigin]);
+        } else {
+          emitHint(request, 'C', href);
+        }
+      }
+    }
+  }
+}
+
+function preload(href, as, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        let key = 'L';
+
+        if (as === 'image' && options) {
+          key += getImagePreloadKey(href, options.imageSrcSet, options.imageSizes);
+        } else {
+          key += "[" + as + "]" + href;
+        }
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          emitHint(request, 'L', [href, as, trimmed]);
+        } else {
+          emitHint(request, 'L', [href, as]);
+        }
+      }
+    }
+  }
+}
+
+function preloadModule$1(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'm|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'm', [href, trimmed]);
+        } else {
+          return emitHint(request, 'm', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'S|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'S', [href, typeof precedence === 'string' ? precedence : 0, trimmed]);
+        } else if (typeof precedence === 'string') {
+          return emitHint(request, 'S', [href, precedence]);
+        } else {
+          return emitHint(request, 'S', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'X|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'X', [href, trimmed]);
+        } else {
+          return emitHint(request, 'X', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitModuleScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'M|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'M', [href, trimmed]);
+        } else {
+          return emitHint(request, 'M', href);
+        }
+      }
+    }
+  }
+} // Flight normally encodes undefined as a special character however for directive option
+// arguments we don't want to send unnecessary keys and bloat the payload so we create a
+// trimmed object which omits any keys with null or undefined values.
+// This is only typesafe because these option objects have entirely optional fields where
+// null and undefined represent the same thing as no property.
+
+
+function trimOptions(options) {
+  if (options == null) return null;
+  let hasProperties = false;
+  const trimmed = {};
+
+  for (const key in options) {
+    if (options[key] != null) {
+      hasProperties = true;
+      trimmed[key] = options[key];
+    }
+  }
+
+  return hasProperties ? trimmed : null;
+}
+
+function getImagePreloadKey(href, imageSrcSet, imageSizes) {
+  let uniquePart = '';
+
+  if (typeof imageSrcSet === 'string' && imageSrcSet !== '') {
+    uniquePart += '[' + imageSrcSet + ']';
+
+    if (typeof imageSizes === 'string') {
+      uniquePart += '[' + imageSizes + ']';
+    }
+  } else {
+    uniquePart += '[][]' + href;
+  }
+
+  return "[image]" + uniquePart;
+}
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMFlightServerDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+// small, smaller than how we encode undefined, and is unambiguous. We could use
+// a different tuple structure to encode this instead but this makes the runtime
+// cost cheaper by eliminating a type checks in more positions.
+// prettier-ignore
+
+function createHints() {
+  return new Set();
+}
+
+const supportsRequestStorage = typeof AsyncLocalStorage === 'function';
+const requestStorage = supportsRequestStorage ? new AsyncLocalStorage() : null;
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext); // On the way back, we push the new ones that weren't common.
+
+      pushNode(next);
+    }
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function pushProvider(context, nextValue) {
+  let prevValue;
+
+  {
+    prevValue = context._currentValue;
+    context._currentValue = nextValue;
+  }
+
+  const prevNode = currentActiveSnapshot;
+  const newNode = {
+    parent: prevNode,
+    depth: prevNode === null ? 0 : prevNode.depth + 1,
+    context: context,
+    parentValue: prevValue,
+    value: nextValue
+  };
+  currentActiveSnapshot = newNode;
+  return newNode;
+}
+function popProvider() {
+  const prevSnapshot = currentActiveSnapshot;
+
+  if (prevSnapshot === null) {
+    throw new Error('Tried to pop a Context at the root of the app. This is a bug in React.');
+  }
+
+  {
+    const value = prevSnapshot.parentValue;
+
+    if (value === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      prevSnapshot.context._currentValue = prevSnapshot.context._defaultValue;
+    } else {
+      prevSnapshot.context._currentValue = value;
+    }
+  }
+
+  return currentActiveSnapshot = prevSnapshot.parent;
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFizzWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop, noop);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+let currentRequest$1 = null;
+let thenableIndexCounter = 0;
+let thenableState = null;
+function prepareToUseHooksForRequest(request) {
+  currentRequest$1 = request;
+}
+function resetHooksForRequest() {
+  currentRequest$1 = null;
+}
+function prepareToUseHooksForComponent(prevThenableState) {
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+const HooksDispatcher = {
+  useMemo(nextCreate) {
+    return nextCreate();
+  },
+
+  useCallback(callback) {
+    return callback;
+  },
+
+  useDebugValue() {},
+
+  useDeferredValue: unsupportedHook,
+  useTransition: unsupportedHook,
+  readContext,
+  useContext: readContext,
+  useReducer: unsupportedHook,
+  useRef: unsupportedHook,
+  useState: unsupportedHook,
+  useInsertionEffect: unsupportedHook,
+  useLayoutEffect: unsupportedHook,
+  useImperativeHandle: unsupportedHook,
+  useEffect: unsupportedHook,
+  useId,
+  useSyncExternalStore: unsupportedHook,
+
+  useCacheRefresh() {
+    return unsupportedRefresh;
+  },
+
+  useMemoCache(size) {
+    const data = new Array(size);
+
+    for (let i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL;
+    }
+
+    return data;
+  },
+
+  use
+};
+
+function unsupportedHook() {
+  throw new Error('This Hook is not supported in Server Components.');
+}
+
+function unsupportedRefresh() {
+  throw new Error('Refreshing the cache is not supported in Server Components.');
+}
+
+function useId() {
+  if (currentRequest$1 === null) {
+    throw new Error('useId can only be used while React is rendering');
+  }
+
+  const id = currentRequest$1.identifierCount++; // use 'S' for Flight components to distinguish from 'R' and 'r' in Fizz/Client
+
+  return ':' + currentRequest$1.identifierPrefix + 'S' + id.toString(32) + ':';
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object' || typeof usable === 'function') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable; // Track the position of the thenable within this fiber.
+
+      const index = thenableIndexCounter;
+      thenableIndexCounter += 1;
+
+      if (thenableState === null) {
+        thenableState = createThenableState();
+      }
+
+      return trackUsedThenable(thenableState, thenable, index);
+    } else if (usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  }
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function createSignal() {
+  return new AbortController().signal;
+}
+
+function resolveCache() {
+  const request = resolveRequest();
+
+  if (request) {
+    return getCache(request);
+  }
+
+  return new Map();
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal() {
+    const cache = resolveCache();
+    let entry = cache.get(createSignal);
+
+    if (entry === undefined) {
+      entry = createSignal();
+      cache.set(createSignal, entry);
+    }
+
+    return entry;
+  },
+
+  getCacheForType(resourceType) {
+    const cache = resolveCache();
+    let entry = cache.get(resourceType);
+
+    if (entry === undefined) {
+      entry = resourceType(); // TODO: Warn if undefined?
+
+      cache.set(resourceType, entry);
+    }
+
+    return entry;
+  }
+
+};
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+function objectName(object) {
+  // $FlowFixMe[method-unbinding]
+  const name = Object.prototype.toString.call(object);
+  return name.replace(/^\[object (.*)\]$/, function (m, p0) {
+    return p0;
+  });
+}
+
+function describeKeyForErrorMessage(key) {
+  const encodedKey = JSON.stringify(key);
+  return '"' + key + '"' === encodedKey ? key : encodedKey;
+}
+
+function describeValueForErrorMessage(value) {
+  switch (typeof value) {
+    case 'string':
+      {
+        return JSON.stringify(value.length <= 10 ? value : value.slice(0, 10) + '...');
+      }
+
+    case 'object':
+      {
+        if (isArray(value)) {
+          return '[...]';
+        }
+
+        const name = objectName(value);
+
+        if (name === 'Object') {
+          return '{...}';
+        }
+
+        return name;
+      }
+
+    case 'function':
+      return 'function';
+
+    default:
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      return String(value);
+  }
+}
+
+function describeElementType(type) {
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        return describeElementType(type.render);
+
+      case REACT_MEMO_TYPE:
+        return describeElementType(type.type);
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            // Lazy may contain any component type so we recursively resolve it.
+            return describeElementType(init(payload));
+          } catch (x) {}
+        }
+    }
+  }
+
+  return '';
+}
+
+function describeObjectForErrorMessage(objectOrArray, expandedName) {
+  const objKind = objectName(objectOrArray);
+
+  if (objKind !== 'Object' && objKind !== 'Array') {
+    return objKind;
+  }
+
+  let str = '';
+  let start = -1;
+  let length = 0;
+
+  if (isArray(objectOrArray)) {
+    {
+      // Print Array
+      str = '[';
+      const array = objectOrArray;
+
+      for (let i = 0; i < array.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const value = array[i];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if ('' + i === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += ']';
+    }
+  } else {
+    if (objectOrArray.$$typeof === REACT_ELEMENT_TYPE) {
+      str = '<' + describeElementType(objectOrArray.type) + '/>';
+    } else {
+      // Print Object
+      str = '{';
+      const object = objectOrArray;
+      const names = Object.keys(object);
+
+      for (let i = 0; i < names.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const name = names[i];
+        str += describeKeyForErrorMessage(name) + ': ';
+        const value = object[name];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if (name === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += '}';
+    }
+  }
+
+  if (expandedName === undefined) {
+    return str;
+  }
+
+  if (start > -1 && length > 0) {
+    const highlight = ' '.repeat(start) + '^'.repeat(length);
+    return '\n  ' + str + '\n  ' + highlight;
+  }
+
+  return '\n  ' + str;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ReactSharedServerInternals = // $FlowFixMe: It's defined in the one we resolve to.
+React.__SECRET_SERVER_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+if (!ReactSharedServerInternals) {
+  throw new Error('The "react" package in this environment is not configured correctly. ' + 'The "react-server" condition must be enabled in any environment that ' + 'runs React Server Components.');
+}
+
+// Turns a TypedArray or ArrayBuffer into a string that can be used for comparison
+// in a Map to see if the bytes are the same.
+function binaryToComparableString(view) {
+  return String.fromCharCode.apply(String, new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+}
+
+const ObjectPrototype = Object.prototype;
+const stringify = JSON.stringify; // Serializable values
+// Thenable<ReactClientValue>
+
+const PENDING$1 = 0;
+const COMPLETED = 1;
+const ABORTED = 3;
+const ERRORED$1 = 4;
+const TaintRegistryObjects = ReactSharedServerInternals.TaintRegistryObjects,
+      TaintRegistryValues = ReactSharedServerInternals.TaintRegistryValues,
+      TaintRegistryByteLengths = ReactSharedServerInternals.TaintRegistryByteLengths,
+      TaintRegistryPendingRequests = ReactSharedServerInternals.TaintRegistryPendingRequests,
+      ReactCurrentCache = ReactSharedServerInternals.ReactCurrentCache;
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+
+function throwTaintViolation(message) {
+  // eslint-disable-next-line react-internal/prod-error-codes
+  throw new Error(message);
+}
+
+function cleanupTaintQueue(request) {
+  const cleanupQueue = request.taintCleanupQueue;
+  TaintRegistryPendingRequests.delete(cleanupQueue);
+
+  for (let i = 0; i < cleanupQueue.length; i++) {
+    const entryValue = cleanupQueue[i];
+    const entry = TaintRegistryValues.get(entryValue);
+
+    if (entry !== undefined) {
+      if (entry.count === 1) {
+        TaintRegistryValues.delete(entryValue);
+      } else {
+        entry.count--;
+      }
+    }
+  }
+
+  cleanupQueue.length = 0;
+}
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+}
+
+function defaultPostponeHandler(reason) {// Noop
+}
+
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2;
+function createRequest(model, bundlerConfig, onError, context, identifierPrefix, onPostpone) {
+  if (ReactCurrentCache.current !== null && ReactCurrentCache.current !== DefaultCacheDispatcher) {
+    throw new Error('Currently React only supports one RSC renderer at a time.');
+  }
+
+  prepareHostDispatcher();
+  ReactCurrentCache.current = DefaultCacheDispatcher;
+  const abortSet = new Set();
+  const pingedTasks = [];
+  const cleanupQueue = [];
+
+  {
+    TaintRegistryPendingRequests.add(cleanupQueue);
+  }
+
+  const hints = createHints();
+  const request = {
+    status: OPEN,
+    flushScheduled: false,
+    fatalError: null,
+    destination: null,
+    bundlerConfig,
+    cache: new Map(),
+    nextChunkId: 0,
+    pendingChunks: 0,
+    hints,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    completedImportChunks: [],
+    completedHintChunks: [],
+    completedRegularChunks: [],
+    completedErrorChunks: [],
+    writtenSymbols: new Map(),
+    writtenClientReferences: new Map(),
+    writtenServerReferences: new Map(),
+    writtenProviders: new Map(),
+    writtenObjects: new WeakMap(),
+    identifierPrefix: identifierPrefix || '',
+    identifierCount: 1,
+    taintCleanupQueue: cleanupQueue,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? defaultPostponeHandler : onPostpone,
+    // $FlowFixMe[missing-this-annot]
+    toJSON: function (key, value) {
+      return resolveModelToJSON(request, this, key, value);
+    }
+  };
+  request.pendingChunks++;
+  const rootContext = createRootContext(context);
+  const rootTask = createTask(request, model, rootContext, abortSet);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  if (supportsRequestStorage) {
+    const store = requestStorage.getStore();
+    if (store) return store;
+  }
+
+  return null;
+}
+
+function createRootContext(reqContext) {
+  return importServerContexts(reqContext);
+}
+
+const POP = {};
+
+function serializeThenable(request, thenable) {
+  request.pendingChunks++;
+  const newTask = createTask(request, null, getActiveContext(), request.abortableTasks);
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        // We have the resolved value, we can go ahead and schedule it for serialization.
+        newTask.model = thenable.value;
+        pingTask(request, newTask);
+        return newTask.id;
+      }
+
+    case 'rejected':
+      {
+        const x = thenable.reason;
+
+        if (typeof x === 'object' && x !== null && x.$$typeof === REACT_POSTPONE_TYPE) {
+          const postponeInstance = x;
+          logPostpone(request, postponeInstance.message);
+          emitPostponeChunk(request, newTask.id);
+        } else {
+          const digest = logRecoverableError(request, x);
+          emitErrorChunk(request, newTask.id, digest);
+        }
+
+        return newTask.id;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  thenable.then(value => {
+    newTask.model = value;
+    pingTask(request, newTask);
+  }, reason => {
+    newTask.status = ERRORED$1;
+    request.abortableTasks.delete(newTask); // TODO: We should ideally do this inside performWork so it's scheduled
+
+    const digest = logRecoverableError(request, reason);
+    emitErrorChunk(request, newTask.id, digest);
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  });
+  return newTask.id;
+}
+
+function emitHint(request, code, model) {
+  emitHintChunk(request, code, model);
+  enqueueFlush(request);
+}
+function getHints(request) {
+  return request.hints;
+}
+function getCache(request) {
+  return request.cache;
+}
+
+function readThenable(thenable) {
+  if (thenable.status === 'fulfilled') {
+    return thenable.value;
+  } else if (thenable.status === 'rejected') {
+    throw thenable.reason;
+  }
+
+  throw thenable;
+}
+
+function createLazyWrapperAroundWakeable(wakeable) {
+  // This is a temporary fork of the `use` implementation until we accept
+  // promises everywhere.
+  const thenable = wakeable;
+
+  switch (thenable.status) {
+    case 'fulfilled':
+    case 'rejected':
+      break;
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: thenable,
+    _init: readThenable
+  };
+  return lazyType;
+}
+
+function attemptResolveElement(request, type, key, ref, props, prevThenableState) {
+  if (ref !== null && ref !== undefined) {
+    // When the ref moves to the regular props object this will implicitly
+    // throw for functions. We could probably relax it to a DEV warning for other
+    // cases.
+    throw new Error('Refs cannot be used in Server Components, nor passed to Client Components.');
+  }
+
+  if (typeof type === 'function') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    } // This is a server-side component.
+
+
+    prepareToUseHooksForComponent(prevThenableState);
+    const result = type(props);
+
+    if (typeof result === 'object' && result !== null && typeof result.then === 'function') {
+      // When the return value is in children position we can resolve it immediately,
+      // to its value without a wrapper if it's synchronously available.
+      const thenable = result;
+
+      if (thenable.status === 'fulfilled') {
+        return thenable.value;
+      } // TODO: Once we accept Promises as children on the client, we can just return
+      // the thenable here.
+
+
+      return createLazyWrapperAroundWakeable(result);
+    }
+
+    return result;
+  } else if (typeof type === 'string') {
+    // This is a host element. E.g. HTML.
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (typeof type === 'symbol') {
+    if (type === REACT_FRAGMENT_TYPE) {
+      // For key-less fragments, we add a small optimization to avoid serializing
+      // it as a wrapper.
+      // TODO: If a key is specified, we should propagate its key to any children.
+      // Same as if a Server Component has a key.
+      return props.children;
+    } // This might be a built-in React component. We'll let the client decide.
+    // Any built-in works as long as its props are serializable.
+
+
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (type != null && typeof type === 'object') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    }
+
+    switch (type.$$typeof) {
+      case REACT_LAZY_TYPE:
+        {
+          const payload = type._payload;
+          const init = type._init;
+          const wrappedType = init(payload);
+          return attemptResolveElement(request, wrappedType, key, ref, props, prevThenableState);
+        }
+
+      case REACT_FORWARD_REF_TYPE:
+        {
+          const render = type.render;
+          prepareToUseHooksForComponent(prevThenableState);
+          return render(props, undefined);
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          return attemptResolveElement(request, type.type, key, ref, props, prevThenableState);
+        }
+
+      case REACT_PROVIDER_TYPE:
+        {
+          {
+            pushProvider(type._context, props.value);
+
+            return [REACT_ELEMENT_TYPE, type, key, // Rely on __popProvider being serialized last to pop the provider.
+            {
+              value: props.value,
+              children: props.children,
+              __pop: POP
+            }];
+          } // Fallthrough
+
+        }
+    }
+  }
+
+  throw new Error("Unsupported Server Component type: " + describeValueForErrorMessage(type));
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createTask(request, model, context, abortSet) {
+  const id = request.nextChunkId++;
+  const task = {
+    id,
+    status: PENDING$1,
+    model,
+    context,
+    ping: () => pingTask(request, task),
+    thenableState: null
+  };
+  abortSet.add(task);
+  return task;
+}
+
+function serializeByValueID(id) {
+  return '$' + id.toString(16);
+}
+
+function serializeLazyID(id) {
+  return '$L' + id.toString(16);
+}
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeProviderReference(name) {
+  return '$P' + name;
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeRowHeader(tag, id) {
+  return id.toString(16) + ':' + tag;
+}
+
+function encodeReferenceChunk(request, id, reference) {
+  const json = stringify(reference);
+  const row = id.toString(16) + ':' + json + '\n';
+  return stringToChunk(row);
+}
+
+function serializeClientReference(request, parent, key, clientReference) {
+  const clientReferenceKey = getClientReferenceKey(clientReference);
+  const writtenClientReferences = request.writtenClientReferences;
+  const existingId = writtenClientReferences.get(clientReferenceKey);
+
+  if (existingId !== undefined) {
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(existingId);
+    }
+
+    return serializeByValueID(existingId);
+  }
+
+  try {
+    const clientReferenceMetadata = resolveClientReferenceMetadata(request.bundlerConfig, clientReference);
+    request.pendingChunks++;
+    const importId = request.nextChunkId++;
+    emitImportChunk(request, importId, clientReferenceMetadata);
+    writtenClientReferences.set(clientReferenceKey, importId);
+
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(importId);
+    }
+
+    return serializeByValueID(importId);
+  } catch (x) {
+    request.pendingChunks++;
+    const errorId = request.nextChunkId++;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, errorId, digest);
+    return serializeByValueID(errorId);
+  }
+}
+
+function outlineModel(request, value) {
+  request.pendingChunks++;
+  const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+  retryTask(request, newTask);
+  return newTask.id;
+}
+
+function serializeServerReference(request, parent, key, serverReference) {
+  const writtenServerReferences = request.writtenServerReferences;
+  const existingId = writtenServerReferences.get(serverReference);
+
+  if (existingId !== undefined) {
+    return serializeServerReferenceID(existingId);
+  }
+
+  const bound = getServerReferenceBoundArguments(request.bundlerConfig, serverReference);
+  const serverReferenceMetadata = {
+    id: getServerReferenceId(request.bundlerConfig, serverReference),
+    bound: bound ? Promise.resolve(bound) : null
+  };
+  const metadataId = outlineModel(request, serverReferenceMetadata);
+  writtenServerReferences.set(serverReference, metadataId);
+  return serializeServerReferenceID(metadataId);
+}
+
+function serializeLargeTextString(request, text) {
+  request.pendingChunks += 2;
+  const textId = request.nextChunkId++;
+  const textChunk = stringToChunk(text);
+  const binaryLength = byteLengthOfChunk(textChunk);
+  const row = textId.toString(16) + ':T' + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, textChunk);
+  return serializeByValueID(textId);
+}
+
+function serializeMap(request, map) {
+  const entries = Array.from(map);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i][0];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$Q' + id.toString(16);
+}
+
+function serializeSet(request, set) {
+  const entries = Array.from(set);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$W' + id.toString(16);
+}
+
+function serializeTypedArray(request, tag, typedArray) {
+  {
+    if (TaintRegistryByteLengths.has(typedArray.byteLength)) {
+      // If we have had any tainted values of this length, we check
+      // to see if these bytes matches any entries in the registry.
+      const tainted = TaintRegistryValues.get(binaryToComparableString(typedArray));
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    }
+  }
+
+  request.pendingChunks += 2;
+  const bufferId = request.nextChunkId++; // TODO: Convert to little endian if that's not the server default.
+
+  const binaryChunk = typedArrayToBinaryChunk(typedArray);
+  const binaryLength = byteLengthOfBinaryChunk(binaryChunk);
+  const row = bufferId.toString(16) + ':' + tag + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, binaryChunk);
+  return serializeByValueID(bufferId);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+let modelRoot = false;
+
+function resolveModelToJSON(request, parent, key, value) {
+
+
+  switch (value) {
+    case REACT_ELEMENT_TYPE:
+      return '$';
+  }
+
+
+  while (typeof value === 'object' && value !== null && (value.$$typeof === REACT_ELEMENT_TYPE || value.$$typeof === REACT_LAZY_TYPE)) {
+
+    try {
+      switch (value.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const writtenObjects = request.writtenObjects;
+            const existingId = writtenObjects.get(value);
+
+            if (existingId !== undefined) {
+              if (existingId === -1) {
+                // Seen but not yet outlined.
+                const newId = outlineModel(request, value);
+                return serializeByValueID(newId);
+              } else if (modelRoot === value) {
+                // This is the ID we're currently emitting so we need to write it
+                // once but if we discover it again, we refer to it by id.
+                modelRoot = null;
+              } else {
+                // We've already emitted this as an outlined object, so we can
+                // just refer to that by its existing ID.
+                return serializeByValueID(existingId);
+              }
+            } else {
+              // This is the first time we've seen this object. We may never see it again
+              // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+              writtenObjects.set(value, -1);
+            } // TODO: Concatenate keys of parents onto children.
+
+
+            const element = value; // Attempt to render the Server Component.
+
+            value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, null);
+            break;
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = value._payload;
+            const init = value._init;
+            value = init(payload);
+            break;
+          }
+      }
+    } catch (thrownValue) {
+      const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          // Something suspended, we'll need to create a new task and resolve it later.
+          request.pendingChunks++;
+          const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+          const ping = newTask.ping;
+          x.then(ping, ping);
+          newTask.thenableState = getThenableStateAfterSuspending();
+          return serializeLazyID(newTask.id);
+        } else if (x.$$typeof === REACT_POSTPONE_TYPE) {
+          // Something postponed. We'll still send everything we have up until this point.
+          // We'll replace this element with a lazy reference that postpones on the client.
+          const postponeInstance = x;
+          request.pendingChunks++;
+          const postponeId = request.nextChunkId++;
+          logPostpone(request, postponeInstance.message);
+          emitPostponeChunk(request, postponeId);
+          return serializeLazyID(postponeId);
+        }
+      } // Something errored. We'll still send everything we have up until this point.
+      // We'll replace this element with a lazy reference that throws on the client
+      // once it gets rendered.
+
+
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+      const digest = logRecoverableError(request, x);
+      emitErrorChunk(request, errorId, digest);
+      return serializeLazyID(errorId);
+    }
+  }
+
+  if (value === null) {
+    return null;
+  }
+
+  if (typeof value === 'object') {
+    {
+      const tainted = TaintRegistryObjects.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted);
+      }
+    }
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    const writtenObjects = request.writtenObjects;
+    const existingId = writtenObjects.get(value); // $FlowFixMe[method-unbinding]
+
+    if (typeof value.then === 'function') {
+      if (existingId !== undefined) {
+        if (modelRoot === value) {
+          // This is the ID we're currently emitting so we need to write it
+          // once but if we discover it again, we refer to it by id.
+          modelRoot = null;
+        } else {
+          // We've seen this promise before, so we can just refer to the same result.
+          return serializePromiseID(existingId);
+        }
+      } // We assume that any object with a .then property is a "Thenable" type,
+      // or a Promise type. Either of which can be represented by a Promise.
+
+
+      const promiseId = serializeThenable(request, value);
+      writtenObjects.set(value, promiseId);
+      return serializePromiseID(promiseId);
+    }
+
+    {
+      if (value.$$typeof === REACT_PROVIDER_TYPE) {
+        const providerKey = value._context._globalName;
+        const writtenProviders = request.writtenProviders;
+        let providerId = writtenProviders.get(key);
+
+        if (providerId === undefined) {
+          request.pendingChunks++;
+          providerId = request.nextChunkId++;
+          writtenProviders.set(providerKey, providerId);
+          emitProviderChunk(request, providerId, providerKey);
+        }
+
+        return serializeByValueID(providerId);
+      } else if (value === POP) {
+        popProvider();
+
+        return undefined;
+      }
+    }
+
+    if (existingId !== undefined) {
+      if (existingId === -1) {
+        // Seen but not yet outlined.
+        const newId = outlineModel(request, value);
+        return serializeByValueID(newId);
+      } else if (modelRoot === value) {
+        // This is the ID we're currently emitting so we need to write it
+        // once but if we discover it again, we refer to it by id.
+        modelRoot = null;
+      } else {
+        // We've already emitted this as an outlined object, so we can
+        // just refer to that by its existing ID.
+        return serializeByValueID(existingId);
+      }
+    } else {
+      // This is the first time we've seen this object. We may never see it again
+      // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+      writtenObjects.set(value, -1);
+    }
+
+    if (isArray(value)) {
+      // $FlowFixMe[incompatible-return]
+      return value;
+    }
+
+    if (value instanceof Map) {
+      return serializeMap(request, value);
+    }
+
+    if (value instanceof Set) {
+      return serializeSet(request, value);
+    }
+
+    {
+      if (value instanceof ArrayBuffer) {
+        return serializeTypedArray(request, 'A', new Uint8Array(value));
+      }
+
+      if (value instanceof Int8Array) {
+        // char
+        return serializeTypedArray(request, 'C', value);
+      }
+
+      if (value instanceof Uint8Array) {
+        // unsigned char
+        return serializeTypedArray(request, 'c', value);
+      }
+
+      if (value instanceof Uint8ClampedArray) {
+        // unsigned clamped char
+        return serializeTypedArray(request, 'U', value);
+      }
+
+      if (value instanceof Int16Array) {
+        // sort
+        return serializeTypedArray(request, 'S', value);
+      }
+
+      if (value instanceof Uint16Array) {
+        // unsigned short
+        return serializeTypedArray(request, 's', value);
+      }
+
+      if (value instanceof Int32Array) {
+        // long
+        return serializeTypedArray(request, 'L', value);
+      }
+
+      if (value instanceof Uint32Array) {
+        // unsigned long
+        return serializeTypedArray(request, 'l', value);
+      }
+
+      if (value instanceof Float32Array) {
+        // float
+        return serializeTypedArray(request, 'F', value);
+      }
+
+      if (value instanceof Float64Array) {
+        // double
+        return serializeTypedArray(request, 'D', value);
+      }
+
+      if (value instanceof BigInt64Array) {
+        // number
+        return serializeTypedArray(request, 'N', value);
+      }
+
+      if (value instanceof BigUint64Array) {
+        // unsigned number
+        // We use "m" instead of "n" since JSON can start with "null"
+        return serializeTypedArray(request, 'm', value);
+      }
+
+      if (value instanceof DataView) {
+        return serializeTypedArray(request, 'V', value);
+      }
+    }
+
+    const iteratorFn = getIteratorFn(value);
+
+    if (iteratorFn) {
+      return Array.from(value);
+    } // Verify that this is a simple plain object.
+
+
+    const proto = getPrototypeOf(value);
+
+    if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+      throw new Error('Only plain objects, and a few built-ins, can be passed to Client Components ' + 'from Server Components. Classes or null prototypes are not supported.');
+    }
+
+
+    return value;
+  }
+
+  if (typeof value === 'string') {
+    {
+      const tainted = TaintRegistryValues.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    } // TODO: Maybe too clever. If we support URL there's no similar trick.
+
+
+    if (value[value.length - 1] === 'Z') {
+      // Possibly a Date, whose toJSON automatically calls toISOString
+      // $FlowFixMe[incompatible-use]
+      const originalValue = parent[key];
+
+      if (originalValue instanceof Date) {
+        return serializeDateFromDateJSON(value);
+      }
+    }
+
+    if (value.length >= 1024) {
+      // For large strings, we encode them outside the JSON payload so that we
+      // don't have to double encode and double parse the strings. This can also
+      // be more compact in case the string has a lot of escaped characters.
+      return serializeLargeTextString(request, value);
+    }
+
+    return escapeStringValue(value);
+  }
+
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  if (typeof value === 'number') {
+    return serializeNumber(value);
+  }
+
+  if (typeof value === 'undefined') {
+    return serializeUndefined();
+  }
+
+  if (typeof value === 'function') {
+    {
+      const tainted = TaintRegistryObjects.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted);
+      }
+    }
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    if (isServerReference(value)) {
+      return serializeServerReference(request, parent, key, value);
+    }
+
+    if (/^on[A-Z]/.test(key)) {
+      throw new Error('Event handlers cannot be passed to Client Component props.' + describeObjectForErrorMessage(parent, key) + '\nIf you need interactivity, consider converting part of this to a Client Component.');
+    } else {
+      throw new Error('Functions cannot be passed directly to Client Components ' + 'unless you explicitly expose it by marking it with "use server".' + describeObjectForErrorMessage(parent, key));
+    }
+  }
+
+  if (typeof value === 'symbol') {
+    const writtenSymbols = request.writtenSymbols;
+    const existingId = writtenSymbols.get(value);
+
+    if (existingId !== undefined) {
+      return serializeByValueID(existingId);
+    } // $FlowFixMe[incompatible-type] `description` might be undefined
+
+
+    const name = value.description;
+
+    if (Symbol.for(name) !== value) {
+      throw new Error('Only global symbols received from Symbol.for(...) can be passed to Client Components. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+      value.description + ") cannot be found among global symbols.") + describeObjectForErrorMessage(parent, key));
+    }
+
+    request.pendingChunks++;
+    const symbolId = request.nextChunkId++;
+    emitSymbolChunk(request, symbolId, name);
+    writtenSymbols.set(value, symbolId);
+    return serializeByValueID(symbolId);
+  }
+
+  if (typeof value === 'bigint') {
+    {
+      const tainted = TaintRegistryValues.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    }
+
+    return serializeBigInt(value);
+  }
+
+  throw new Error("Type " + typeof value + " is not supported in Client Component props." + describeObjectForErrorMessage(parent, key));
+}
+
+function logPostpone(request, reason) {
+  const onPostpone = request.onPostpone;
+  onPostpone(reason);
+}
+
+function logRecoverableError(request, error) {
+  const onError = request.onError;
+  const errorDigest = onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest || '';
+}
+
+function fatalError(request, error) {
+  {
+    cleanupTaintQueue(request);
+  } // This is called outside error handling code such as if an error happens in React internals.
+
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function emitPostponeChunk(request, id, postponeInstance) {
+  let row;
+
+  {
+    // No reason included in prod.
+    row = serializeRowHeader('P', id) + '\n';
+  }
+
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitErrorChunk(request, id, digest, error) {
+  let errorInfo;
+
+  {
+    errorInfo = {
+      digest
+    };
+  }
+
+  const row = serializeRowHeader('E', id) + stringify(errorInfo) + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitImportChunk(request, id, clientReferenceMetadata) {
+  // $FlowFixMe[incompatible-type] stringify can return null
+  const json = stringify(clientReferenceMetadata);
+  const row = serializeRowHeader('I', id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitHintChunk(request, code, model) {
+  const json = stringify(model);
+  const id = request.nextChunkId++;
+  const row = serializeRowHeader('H' + code, id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedHintChunks.push(processedChunk);
+}
+
+function emitSymbolChunk(request, id, name) {
+  const symbolReference = serializeSymbolReference(name);
+  const processedChunk = encodeReferenceChunk(request, id, symbolReference);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitProviderChunk(request, id, contextName) {
+  const contextReference = serializeProviderReference(contextName);
+  const processedChunk = encodeReferenceChunk(request, id, contextReference);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function emitModelChunk(request, id, model) {
+  // Track the root so we know that we have to emit this object even though it
+  // already has an ID. This is needed because we might see this object twice
+  // in the same toJSON if it is cyclic.
+  modelRoot = model; // $FlowFixMe[incompatible-type] stringify can return null
+
+  const json = stringify(model, request.toJSON);
+  const row = id.toString(16) + ':' + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function retryTask(request, task) {
+  if (task.status !== PENDING$1) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  }
+
+  switchContext(task.context);
+
+  try {
+    let value = task.model;
+
+    if (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+      request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+      const element = value; // When retrying a component, reuse the thenableState from the
+      // previous attempt.
+
+      const prevThenableState = task.thenableState; // Attempt to render the Server Component.
+      // Doing this here lets us reuse this same task if the next component
+      // also suspends.
+
+      task.model = value;
+      value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, prevThenableState); // Successfully finished this component. We're going to keep rendering
+      // using the same task, but we reset its thenable state before continuing.
+
+      task.thenableState = null; // Keep rendering and reuse the same task. This inner loop is separate
+      // from the render above because we don't need to reset the thenable state
+      // until the next time something suspends and retries.
+
+      while (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+        request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+        const nextElement = value;
+        task.model = value;
+        value = attemptResolveElement(request, nextElement.type, nextElement.key, nextElement.ref, nextElement.props, null);
+      }
+    } // Track that this object is outlined and has an id.
+
+
+    if (typeof value === 'object' && value !== null) {
+      request.writtenObjects.set(value, task.id);
+    }
+
+    emitModelChunk(request, task.id, value);
+    request.abortableTasks.delete(task);
+    task.status = COMPLETED;
+  } catch (thrownValue) {
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      } else if (x.$$typeof === REACT_POSTPONE_TYPE) {
+        request.abortableTasks.delete(task);
+        task.status = ERRORED$1;
+        const postponeInstance = x;
+        logPostpone(request, postponeInstance.message);
+        emitPostponeChunk(request, task.id);
+        return;
+      }
+    }
+
+    request.abortableTasks.delete(task);
+    task.status = ERRORED$1;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, task.id, digest);
+  }
+}
+
+function performWork(request) {
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  const prevRequest = currentRequest;
+  currentRequest = request;
+  prepareToUseHooksForRequest(request);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    request.pingedTasks = [];
+
+    for (let i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    ReactCurrentDispatcher.current = prevDispatcher;
+    resetHooksForRequest();
+    currentRequest = prevRequest;
+  }
+}
+
+function abortTask(task, request, errorId) {
+  task.status = ABORTED; // Instead of emitting an error per task.id, we emit a model that only
+  // has a single value referencing the error.
+
+  const ref = serializeByValueID(errorId);
+  const processedChunk = encodeReferenceChunk(request, task.id, ref);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function flushCompletedChunks(request, destination) {
+  beginWriting();
+
+  try {
+    // We emit module chunks first in the stream so that
+    // they can be preloaded as early as possible.
+    const importsChunks = request.completedImportChunks;
+    let i = 0;
+
+    for (; i < importsChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = importsChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    importsChunks.splice(0, i); // Next comes hints.
+
+    const hintChunks = request.completedHintChunks;
+    i = 0;
+
+    for (; i < hintChunks.length; i++) {
+      const chunk = hintChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    hintChunks.splice(0, i); // Next comes model data.
+
+    const regularChunks = request.completedRegularChunks;
+    i = 0;
+
+    for (; i < regularChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = regularChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    regularChunks.splice(0, i); // Finally, errors are sent. The idea is that it's ok to delay
+    // any error messages and prioritize display of other parts of
+    // the page.
+
+    const errorChunks = request.completedErrorChunks;
+    i = 0;
+
+    for (; i < errorChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = errorChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    errorChunks.splice(0, i);
+  } finally {
+    request.flushScheduled = false;
+    completeWriting(destination);
+  }
+
+  if (request.pendingChunks === 0) {
+    // We're done.
+    {
+      cleanupTaintQueue(request);
+    }
+
+    close$1(destination);
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  if (supportsRequestStorage) {
+    scheduleWork(() => requestStorage.run(request, performWork, request));
+  } else {
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    const destination = request.destination;
+    request.flushScheduled = true;
+    scheduleWork(() => flushCompletedChunks(request, destination));
+  }
+}
+
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedChunks(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function stopFlowing(request) {
+  request.destination = null;
+} // This is called to early terminate a request. It creates an error at all pending tasks.
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      // We have tasks to abort. We'll emit one error row and then emit a reference
+      // to that row from every row that's still remaining.
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+
+      if (enablePostpone && typeof reason === 'object' && reason !== null && reason.$$typeof === REACT_POSTPONE_TYPE) {
+        const postponeInstance = reason;
+        logPostpone(request, postponeInstance.message);
+        emitPostponeChunk(request, errorId, postponeInstance);
+      } else {
+        const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+        const digest = logRecoverableError(request, error);
+        emitErrorChunk(request, errorId, digest, error);
+      }
+
+      abortableTasks.forEach(task => abortTask(task, request, errorId));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function importServerContexts(contexts) {
+  if (contexts) {
+    const prevContext = getActiveContext();
+    switchContext(rootContextSnapshot);
+
+    for (let i = 0; i < contexts.length; i++) {
+      const _contexts$i = contexts[i],
+            name = _contexts$i[0],
+            value = _contexts$i[1];
+      const context = getOrCreateServerContext(name);
+      pushProvider(context, value);
+    }
+
+    const importedContext = getActiveContext();
+    switchContext(prevContext);
+    return importedContext;
+  }
+
+  return rootContextSnapshot;
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+function resolveServerReference(bundlerConfig, id) {
+  let name = '';
+  let resolvedModuleData = bundlerConfig[id];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = id.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = id.slice(idx + 1);
+      resolvedModuleData = bundlerConfig[id.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + id + '" in the React Server Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  } // TODO: This needs to return async: true if it's an async module.
+
+
+  return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+} // The chunk cache contains all the chunks we've preloaded so far.
+// If they're still pending they're a thenable. This map also exists
+// in Webpack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = globalThis.__next_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+  let i = 0;
+
+  while (i < chunks.length) {
+    const chunkId = chunks[i++];
+    chunks[i++];
+    const entry = chunkCache.get(chunkId);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkId);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkId, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkId, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = globalThis.__next_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+function loadChunk(chunkId, filename) {
+  return __webpack_chunk_load__(chunkId);
+}
+
+// The server acts as a Client of itself when resolving Server References.
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const RESOLVED_MODEL = 'resolved_model';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function bindArgs$1(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference$1(response, id, bound, parentChunk, parentObject, key) {
+  const serverReference = resolveServerReference(response._bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+  let promise;
+
+  if (bound) {
+    promise = Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs$1(requireModule(serverReference), args);
+    });
+  } else {
+    if (preloadPromise) {
+      promise = Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+    } else {
+      // Synchronously available
+      return requireModule(serverReference);
+    }
+  }
+
+  promise.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk)); // We need a placeholder value that will be replaced later.
+
+  return null;
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+
+  try {
+    const value = JSON.parse(chunk.value, chunk._response._fromJSON);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    const prefix = response._prefix;
+    const key = prefix + id; // Check if we have this field in the backing store already.
+
+    const backingEntry = response._formData.get(key);
+
+    if (backingEntry != null) {
+      // We assume that this is a string entry for now.
+      chunk = createResolvedModelChunk(response, backingEntry);
+    } else {
+      // We're still waiting on this entry to stream in.
+      chunk = createPendingChunk(response);
+    }
+
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+    blocked.deps++;
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  if (chunk.status === RESOLVED_MODEL) {
+    initializeModelChunk(chunk);
+  }
+
+  if (chunk.status !== INITIALIZED) {
+    // We know that this is emitted earlier so otherwise it's an error.
+    throw chunk.reason;
+  }
+
+  return chunk.value;
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16); // TODO: Just encode this in the reference inline instead of as a model.
+
+          const metaData = getOutlinedModel(response, id);
+          return loadServerReference$1(response, metaData.id, metaData.bound, initializingChunk, parentObject, key);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'K':
+        {
+          // FormData
+          const stringId = value.slice(2);
+          const formPrefix = response._prefix + stringId + '_';
+          const data = new FormData();
+          const backingFormData = response._formData; // We assume that the reference to FormData always comes after each
+          // entry that it references so we can assume they all exist in the
+          // backing store already.
+          // $FlowFixMe[prop-missing] FormData has forEach on it.
+
+          backingFormData.forEach((entry, entryKey) => {
+            if (entryKey.startsWith(formPrefix)) {
+              data.append(entryKey.slice(formPrefix.length), entry);
+            }
+          });
+          return data;
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function createResponse(bundlerConfig, formFieldPrefix) {
+  let backingFormData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new FormData();
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _prefix: formFieldPrefix,
+    _formData: backingFormData,
+    _chunks: chunks,
+    _fromJSON: function (key, value) {
+      if (typeof value === 'string') {
+        // We can't use .bind here because we need the "this" value.
+        return parseModelString(response, this, key, value);
+      }
+
+      return value;
+    }
+  };
+  return response;
+}
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function bindArgs(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference(bundlerConfig, id, bound) {
+  const serverReference = resolveServerReference(bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+
+  if (bound) {
+    return Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs(requireModule(serverReference), args);
+    });
+  } else if (preloadPromise) {
+    return Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+  } else {
+    // Synchronously available
+    return Promise.resolve(requireModule(serverReference));
+  }
+}
+
+function decodeBoundActionMetaData(body, serverManifest, formFieldPrefix) {
+  // The data for this reference is encoded in multiple fields under this prefix.
+  const actionResponse = createResponse(serverManifest, formFieldPrefix, body);
+  close(actionResponse);
+  const refPromise = getRoot(actionResponse); // Force it to initialize
+  // $FlowFixMe
+
+  refPromise.then(() => {});
+
+  if (refPromise.status !== 'fulfilled') {
+    // $FlowFixMe
+    throw refPromise.reason;
+  }
+
+  return refPromise.value;
+}
+
+function decodeAction(body, serverManifest) {
+  // We're going to create a new formData object that holds all the fields except
+  // the implementation details of the action data.
+  const formData = new FormData();
+  let action = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (!key.startsWith('$ACTION_')) {
+      formData.append(key, value);
+      return;
+    } // Later actions may override earlier actions if a button is used to override the default
+    // form action.
+
+
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      const metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+      action = loadServerReference(serverManifest, metaData.id, metaData.bound);
+      return;
+    }
+
+    if (key.startsWith('$ACTION_ID_')) {
+      const id = key.slice(11);
+      action = loadServerReference(serverManifest, id, null);
+      return;
+    }
+  });
+
+  if (action === null) {
+    return null;
+  } // Return the action with the remaining FormData bound to the first argument.
+
+
+  return action.then(fn => fn.bind(null, formData));
+}
+function decodeFormState(actionResult, body, serverManifest) {
+  const keyPath = body.get('$ACTION_KEY');
+
+  if (typeof keyPath !== 'string') {
+    // This form submission did not include any form state.
+    return Promise.resolve(null);
+  } // Search through the form data object to get the reference id and the number
+  // of bound arguments. This repeats some of the work done in decodeAction.
+
+
+  let metaData = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+    } // We don't check for the simple $ACTION_ID_ case because form state actions
+    // are always bound to the state argument.
+
+  });
+
+  if (metaData === null) {
+    // Should be unreachable.
+    return Promise.resolve(null);
+  }
+
+  const referenceId = metaData.id;
+  return Promise.resolve(metaData.bound).then(bound => {
+    if (bound === null) {
+      // Should be unreachable because form state actions are always bound to the
+      // state argument.
+      return null;
+    } // The form action dispatch method is always bound to the initial state.
+    // But when comparing signatures, we compare to the original unbound action.
+    // Subtract one from the arity to account for this.
+
+
+    const boundArity = bound.length - 1;
+    return [actionResult, keyPath, referenceId, boundArity];
+  });
+}
+
+function renderToReadableStream(model, webpackMap, options) {
+  const request = createRequest(model, webpackMap, options ? options.onError : undefined, options ? options.context : undefined, options ? options.identifierPrefix : undefined, options ? options.onPostpone : undefined);
+
+  if (options && options.signal) {
+    const signal = options.signal;
+
+    if (signal.aborted) {
+      abort(request, signal.reason);
+    } else {
+      const listener = () => {
+        abort(request, signal.reason);
+        signal.removeEventListener('abort', listener);
+      };
+
+      signal.addEventListener('abort', listener);
+    }
+  }
+
+  const stream = new ReadableStream({
+    type: 'bytes',
+    start: controller => {
+      startWork(request);
+    },
+    pull: controller => {
+      startFlowing(request, controller);
+    },
+    cancel: reason => {
+      stopFlowing(request);
+      abort(request, reason);
+    }
+  }, // $FlowFixMe[prop-missing] size() methods are not allowed on byte streams.
+  {
+    highWaterMark: 0
+  });
+  return stream;
+}
+
+function decodeReply(body, webpackMap) {
+  if (typeof body === 'string') {
+    const form = new FormData();
+    form.append('0', body);
+    body = form;
+  }
+
+  const response = createResponse(webpackMap, '', body);
+  const root = getRoot(response);
+  close(response);
+  return root;
+}
+
+exports.createClientModuleProxy = createClientModuleProxy;
+exports.decodeAction = decodeAction;
+exports.decodeFormState = decodeFormState;
+exports.decodeReply = decodeReply;
+exports.registerClientReference = registerClientReference;
+exports.registerServerReference = registerServerReference;
+exports.renderToReadableStream = renderToReadableStream;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.edge.production.min.js b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.edge.production.min.js
index a1db0044c2692..12a68371dbe1f 100644
--- a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.edge.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.edge.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-webpack-server.edge.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-webpack-server.edge.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var aa=require("react"),ba=require("react-dom"),m=null,n=0;function p(a,b){if(0!==b.byteLength)if(512<b.byteLength)0<n&&(a.enqueue(new Uint8Array(m.buffer,0,n)),m=new Uint8Array(512),n=0),a.enqueue(b);else{var d=m.length-n;d<b.byteLength&&(0===d?a.enqueue(m):(m.set(b.subarray(0,d),n),a.enqueue(m),b=b.subarray(d)),m=new Uint8Array(512),n=0);m.set(b,n);n+=b.byteLength}return!0}var q=new TextEncoder;function ca(a,b){"function"===typeof a.error?a.error(b):a.close()}
 var r=Symbol.for("react.client.reference"),t=Symbol.for("react.server.reference");function u(a,b,d){return Object.defineProperties(a,{$$typeof:{value:r},$$id:{value:b},$$async:{value:d}})}var da=Function.prototype.bind,ea=Array.prototype.slice;function fa(){var a=da.apply(this,arguments);if(this.$$typeof===t){var b=ea.call(arguments,1);a.$$typeof=t;a.$$id=this.$$id;a.$$bound=this.$$bound?this.$$bound.concat(b):b}return a}
 var ha=Promise.prototype,ia={get:function(a,b){switch(b){case "$$typeof":return a.$$typeof;case "$$id":return a.$$id;case "$$async":return a.$$async;case "name":return a.name;case "displayName":return;case "defaultProps":return;case "toJSON":return;case Symbol.toPrimitive:return Object.prototype[Symbol.toPrimitive];case "Provider":throw Error("Cannot render a Client Context Provider on the Server. Instead, you can export a Client Component wrapper that itself renders a Client Context Provider.");
@@ -82,3 +82,5 @@ exports.decodeFormState=function(a,b,d){var c=b.get("$ACTION_KEY");if("string"!=
 exports.registerClientReference=function(a,b,d){return u(a,b+"#"+d,!1)};exports.registerServerReference=function(a,b,d){return Object.defineProperties(a,{$$typeof:{value:t},$$id:{value:null===d?b:b+"#"+d},$$bound:{value:null},bind:{value:fa}})};
 exports.renderToReadableStream=function(a,b,d){var c=rb(a,b,d?d.onError:void 0,d?d.context:void 0,d?d.identifierPrefix:void 0,d?d.onPostpone:void 0);if(d&&d.signal){var e=d.signal;if(e.aborted)Jb(c,e.reason);else{var f=function(){Jb(c,e.reason);e.removeEventListener("abort",f)};e.addEventListener("abort",f)}}return new ReadableStream({type:"bytes",start:function(){Ib(c)},pull:function(g){if(1===c.status)c.status=2,ca(g,c.fatalError);else if(2!==c.status&&null===c.destination){c.destination=g;try{Q(c,
 g)}catch(h){O(c,h),Hb(c,h)}}},cancel:function(g){c.destination=null;Jb(c,g)}},{highWaterMark:0})};
+
+//# sourceMappingURL=react-server-dom-webpack-server.edge.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.node.production.js b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.node.production.js
new file mode 100644
index 0000000000000..bc997c5dbd916
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.node.production.js
@@ -0,0 +1,3677 @@
+/**
+ * @license React
+ * react-server-dom-webpack-server.node.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var util = require('util');
+require('crypto');
+var async_hooks = require('async_hooks');
+var React = require('react');
+var ReactDOM = require('react-dom');
+
+// -----------------------------------------------------------------------------
+const enablePostpone = true;
+
+function scheduleWork(callback) {
+  setImmediate(callback);
+}
+function flushBuffered(destination) {
+  // If we don't have any more data to send right now.
+  // Flush whatever is in the buffer to the wire.
+  if (typeof destination.flush === 'function') {
+    // By convention the Zlib streams provide a flush function for this purpose.
+    // For Express, compression middleware adds this method.
+    destination.flush();
+  }
+}
+const VIEW_SIZE = 2048;
+let currentView = null;
+let writtenBytes = 0;
+let destinationHasCapacity = true;
+function beginWriting(destination) {
+  currentView = new Uint8Array(VIEW_SIZE);
+  writtenBytes = 0;
+  destinationHasCapacity = true;
+}
+
+function writeStringChunk(destination, stringChunk) {
+  if (stringChunk.length === 0) {
+    return;
+  } // maximum possible view needed to encode entire string
+
+
+  if (stringChunk.length * 3 > VIEW_SIZE) {
+    if (writtenBytes > 0) {
+      writeToDestination(destination, currentView.subarray(0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    writeToDestination(destination, textEncoder.encode(stringChunk));
+    return;
+  }
+
+  let target = currentView;
+
+  if (writtenBytes > 0) {
+    target = currentView.subarray(writtenBytes);
+  }
+
+  const _textEncoder$encodeIn = textEncoder.encodeInto(stringChunk, target),
+        read = _textEncoder$encodeIn.read,
+        written = _textEncoder$encodeIn.written;
+
+  writtenBytes += written;
+
+  if (read < stringChunk.length) {
+    writeToDestination(destination, currentView.subarray(0, writtenBytes));
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = textEncoder.encodeInto(stringChunk.slice(read), currentView).written;
+  }
+
+  if (writtenBytes === VIEW_SIZE) {
+    writeToDestination(destination, currentView);
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+}
+
+function writeViewChunk(destination, chunk) {
+  if (chunk.byteLength === 0) {
+    return;
+  }
+
+  if (chunk.byteLength > VIEW_SIZE) {
+    // one that is cached by the streaming renderer. We will enqueu
+    // it directly and expect it is not re-used
+
+
+    if (writtenBytes > 0) {
+      writeToDestination(destination, currentView.subarray(0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    writeToDestination(destination, chunk);
+    return;
+  }
+
+  let bytesToWrite = chunk;
+  const allowableBytes = currentView.length - writtenBytes;
+
+  if (allowableBytes < bytesToWrite.byteLength) {
+    // this chunk would overflow the current view. We enqueue a full view
+    // and start a new view with the remaining chunk
+    if (allowableBytes === 0) {
+      // the current view is already full, send it
+      writeToDestination(destination, currentView);
+    } else {
+      // fill up the current view and apply the remaining chunk bytes
+      // to a new view.
+      currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes);
+      writtenBytes += allowableBytes;
+      writeToDestination(destination, currentView);
+      bytesToWrite = bytesToWrite.subarray(allowableBytes);
+    }
+
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+
+  currentView.set(bytesToWrite, writtenBytes);
+  writtenBytes += bytesToWrite.byteLength;
+
+  if (writtenBytes === VIEW_SIZE) {
+    writeToDestination(destination, currentView);
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+}
+
+function writeChunk(destination, chunk) {
+  if (typeof chunk === 'string') {
+    writeStringChunk(destination, chunk);
+  } else {
+    writeViewChunk(destination, chunk);
+  }
+}
+
+function writeToDestination(destination, view) {
+  const currentHasCapacity = destination.write(view);
+  destinationHasCapacity = destinationHasCapacity && currentHasCapacity;
+}
+
+function writeChunkAndReturn(destination, chunk) {
+  writeChunk(destination, chunk);
+  return destinationHasCapacity;
+}
+function completeWriting(destination) {
+  if (currentView && writtenBytes > 0) {
+    destination.write(currentView.subarray(0, writtenBytes));
+  }
+
+  currentView = null;
+  writtenBytes = 0;
+  destinationHasCapacity = true;
+}
+function close$1(destination) {
+  destination.end();
+}
+const textEncoder = new util.TextEncoder();
+function stringToChunk(content) {
+  return content;
+}
+function typedArrayToBinaryChunk(content) {
+  // Convert any non-Uint8Array array to Uint8Array. We could avoid this for Uint8Arrays.
+  return new Uint8Array(content.buffer, content.byteOffset, content.byteLength);
+}
+function byteLengthOfChunk(chunk) {
+  return typeof chunk === 'string' ? Buffer.byteLength(chunk, 'utf8') : chunk.byteLength;
+}
+function byteLengthOfBinaryChunk(chunk) {
+  return chunk.byteLength;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+  destination.destroy(error);
+}
+
+// eslint-disable-next-line no-unused-vars
+const CLIENT_REFERENCE_TAG = Symbol.for('react.client.reference');
+const SERVER_REFERENCE_TAG = Symbol.for('react.server.reference');
+function isClientReference(reference) {
+  return reference.$$typeof === CLIENT_REFERENCE_TAG;
+}
+function isServerReference(reference) {
+  return reference.$$typeof === SERVER_REFERENCE_TAG;
+}
+function registerClientReference(proxyImplementation, id, exportName) {
+  return registerClientReferenceImpl(proxyImplementation, id + '#' + exportName, false);
+}
+
+function registerClientReferenceImpl(proxyImplementation, id, async) {
+  return Object.defineProperties(proxyImplementation, {
+    $$typeof: {
+      value: CLIENT_REFERENCE_TAG
+    },
+    $$id: {
+      value: id
+    },
+    $$async: {
+      value: async
+    }
+  });
+} // $FlowFixMe[method-unbinding]
+
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+
+  if (this.$$typeof === SERVER_REFERENCE_TAG) {
+    const args = ArraySlice.call(arguments, 1);
+    newFn.$$typeof = SERVER_REFERENCE_TAG;
+    newFn.$$id = this.$$id;
+    newFn.$$bound = this.$$bound ? this.$$bound.concat(args) : args;
+  }
+
+  return newFn;
+}
+
+function registerServerReference(reference, id, exportName) {
+  return Object.defineProperties(reference, {
+    $$typeof: {
+      value: SERVER_REFERENCE_TAG
+    },
+    $$id: {
+      value: exportName === null ? id : id + '#' + exportName
+    },
+    $$bound: {
+      value: null
+    },
+    bind: {
+      value: bind
+    }
+  });
+}
+const PROMISE_PROTOTYPE = Promise.prototype;
+const deepProxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        // These names are a little too common. We should probably have a way to
+        // have the Flight runtime extract the inner target instead.
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+
+      case 'displayName':
+        return undefined;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case 'Provider':
+        throw new Error("Cannot render a Client Context Provider on the Server. " + "Instead, you can export a Client Component wrapper " + "that itself renders a Client Context Provider.");
+    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+    const expression = String(target.name) + '.' + String(name);
+    throw new Error("Cannot access " + expression + " on the server. " + 'You cannot dot into a client module from a server component. ' + 'You can only pass the imported name through.');
+  },
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+
+function getReference(target, name) {
+  switch (name) {
+    // These names are read by the Flight runtime if you end up using the exports object.
+    case '$$typeof':
+      return target.$$typeof;
+
+    case '$$id':
+      return target.$$id;
+
+    case '$$async':
+      return target.$$async;
+
+    case 'name':
+      return target.name;
+    // We need to special case this because createElement reads it if we pass this
+    // reference.
+
+    case 'defaultProps':
+      return undefined;
+    // Avoid this attempting to be serialized.
+
+    case 'toJSON':
+      return undefined;
+
+    case Symbol.toPrimitive:
+      // $FlowFixMe[prop-missing]
+      return Object.prototype[Symbol.toPrimitive];
+
+    case '__esModule':
+      // Something is conditionally checking which export to use. We'll pretend to be
+      // an ESM compat module but then we'll check again on the client.
+      const moduleId = target.$$id;
+      target.default = registerClientReferenceImpl(function () {
+        throw new Error("Attempted to call the default export of " + moduleId + " from the server " + "but it's on the client. It's not possible to invoke a client function from " + "the server, it can only be rendered as a Component or passed to props of a " + "Client Component.");
+      }, target.$$id + '#', target.$$async);
+      return true;
+
+    case 'then':
+      if (target.then) {
+        // Use a cached value
+        return target.then;
+      }
+
+      if (!target.$$async) {
+        // If this module is expected to return a Promise (such as an AsyncModule) then
+        // we should resolve that with a client reference that unwraps the Promise on
+        // the client.
+        const clientReference = registerClientReferenceImpl({}, target.$$id, true);
+        const proxy = new Proxy(clientReference, proxyHandlers); // Treat this as a resolved Promise for React's use()
+
+        target.status = 'fulfilled';
+        target.value = proxy;
+        const then = target.then = registerClientReferenceImpl(function then(resolve, reject) {
+          // Expose to React.
+          return Promise.resolve(resolve(proxy));
+        }, // If this is not used as a Promise but is treated as a reference to a `.then`
+        // export then we should treat it as a reference to that name.
+        target.$$id + '#then', false);
+        return then;
+      } else {
+        // Since typeof .then === 'function' is a feature test we'd continue recursing
+        // indefinitely if we return a function. Instead, we return an object reference
+        // if we check further.
+        return undefined;
+      }
+
+  }
+
+  let cachedReference = target[name];
+
+  if (!cachedReference) {
+    const reference = registerClientReferenceImpl(function () {
+      throw new Error( // eslint-disable-next-line react-internal/safe-string-coercion
+      "Attempted to call " + String(name) + "() from the server but " + String(name) + " is on the client. " + "It's not possible to invoke a client function from the server, it can " + "only be rendered as a Component or passed to props of a Client Component.");
+    }, target.$$id + '#' + name, target.$$async);
+    Object.defineProperty(reference, 'name', {
+      value: name
+    });
+    cachedReference = target[name] = new Proxy(reference, deepProxyHandlers);
+  }
+
+  return cachedReference;
+}
+
+const proxyHandlers = {
+  get: function (target, name, receiver) {
+    return getReference(target, name);
+  },
+  getOwnPropertyDescriptor: function (target, name) {
+    let descriptor = Object.getOwnPropertyDescriptor(target, name);
+
+    if (!descriptor) {
+      descriptor = {
+        value: getReference(target, name),
+        writable: false,
+        configurable: false,
+        enumerable: false
+      };
+      Object.defineProperty(target, name, descriptor);
+    }
+
+    return descriptor;
+  },
+
+  getPrototypeOf(target) {
+    // Pretend to be a Promise in case anyone asks.
+    return PROMISE_PROTOTYPE;
+  },
+
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+function createClientModuleProxy(moduleId) {
+  const clientReference = registerClientReferenceImpl({}, // Represents the whole Module object instead of a particular import.
+  moduleId, false);
+  return new Proxy(clientReference, proxyHandlers);
+}
+
+function getClientReferenceKey(reference) {
+  return reference.$$async ? reference.$$id + '#async' : reference.$$id;
+}
+function resolveClientReferenceMetadata(config, clientReference) {
+  const modulePath = clientReference.$$id;
+  let name = '';
+  let resolvedModuleData = config[modulePath];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = modulePath.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = modulePath.slice(idx + 1);
+      resolvedModuleData = config[modulePath.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + modulePath + '" in the React Client Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  }
+
+  if (clientReference.$$async === true) {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1];
+  } else {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+  }
+}
+function getServerReferenceId(config, serverReference) {
+  return serverReference.$$id;
+}
+function getServerReferenceBoundArguments(config, serverReference) {
+  return serverReference.$$bound;
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMFlightServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule: preloadModule$1,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+
+function prefetchDNS(href) {
+  {
+    if (typeof href === 'string' && href) {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'D|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        emitHint(request, 'D', href);
+      }
+    }
+  }
+}
+
+function preconnect(href, crossOrigin) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = "C|" + (crossOrigin == null ? 'null' : crossOrigin) + "|" + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+
+        if (typeof crossOrigin === 'string') {
+          emitHint(request, 'C', [href, crossOrigin]);
+        } else {
+          emitHint(request, 'C', href);
+        }
+      }
+    }
+  }
+}
+
+function preload(href, as, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        let key = 'L';
+
+        if (as === 'image' && options) {
+          key += getImagePreloadKey(href, options.imageSrcSet, options.imageSizes);
+        } else {
+          key += "[" + as + "]" + href;
+        }
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          emitHint(request, 'L', [href, as, trimmed]);
+        } else {
+          emitHint(request, 'L', [href, as]);
+        }
+      }
+    }
+  }
+}
+
+function preloadModule$1(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'm|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'm', [href, trimmed]);
+        } else {
+          return emitHint(request, 'm', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'S|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'S', [href, typeof precedence === 'string' ? precedence : 0, trimmed]);
+        } else if (typeof precedence === 'string') {
+          return emitHint(request, 'S', [href, precedence]);
+        } else {
+          return emitHint(request, 'S', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'X|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'X', [href, trimmed]);
+        } else {
+          return emitHint(request, 'X', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitModuleScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'M|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'M', [href, trimmed]);
+        } else {
+          return emitHint(request, 'M', href);
+        }
+      }
+    }
+  }
+} // Flight normally encodes undefined as a special character however for directive option
+// arguments we don't want to send unnecessary keys and bloat the payload so we create a
+// trimmed object which omits any keys with null or undefined values.
+// This is only typesafe because these option objects have entirely optional fields where
+// null and undefined represent the same thing as no property.
+
+
+function trimOptions(options) {
+  if (options == null) return null;
+  let hasProperties = false;
+  const trimmed = {};
+
+  for (const key in options) {
+    if (options[key] != null) {
+      hasProperties = true;
+      trimmed[key] = options[key];
+    }
+  }
+
+  return hasProperties ? trimmed : null;
+}
+
+function getImagePreloadKey(href, imageSrcSet, imageSizes) {
+  let uniquePart = '';
+
+  if (typeof imageSrcSet === 'string' && imageSrcSet !== '') {
+    uniquePart += '[' + imageSrcSet + ']';
+
+    if (typeof imageSizes === 'string') {
+      uniquePart += '[' + imageSizes + ']';
+    }
+  } else {
+    uniquePart += '[][]' + href;
+  }
+
+  return "[image]" + uniquePart;
+}
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMFlightServerDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+// small, smaller than how we encode undefined, and is unambiguous. We could use
+// a different tuple structure to encode this instead but this makes the runtime
+// cost cheaper by eliminating a type checks in more positions.
+// prettier-ignore
+
+function createHints() {
+  return new Set();
+}
+
+const requestStorage = new async_hooks.AsyncLocalStorage();
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext); // On the way back, we push the new ones that weren't common.
+
+      pushNode(next);
+    }
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function pushProvider(context, nextValue) {
+  let prevValue;
+
+  {
+    prevValue = context._currentValue;
+    context._currentValue = nextValue;
+  }
+
+  const prevNode = currentActiveSnapshot;
+  const newNode = {
+    parent: prevNode,
+    depth: prevNode === null ? 0 : prevNode.depth + 1,
+    context: context,
+    parentValue: prevValue,
+    value: nextValue
+  };
+  currentActiveSnapshot = newNode;
+  return newNode;
+}
+function popProvider() {
+  const prevSnapshot = currentActiveSnapshot;
+
+  if (prevSnapshot === null) {
+    throw new Error('Tried to pop a Context at the root of the app. This is a bug in React.');
+  }
+
+  {
+    const value = prevSnapshot.parentValue;
+
+    if (value === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      prevSnapshot.context._currentValue = prevSnapshot.context._defaultValue;
+    } else {
+      prevSnapshot.context._currentValue = value;
+    }
+  }
+
+  return currentActiveSnapshot = prevSnapshot.parent;
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFizzWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop, noop);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+let currentRequest$1 = null;
+let thenableIndexCounter = 0;
+let thenableState = null;
+function prepareToUseHooksForRequest(request) {
+  currentRequest$1 = request;
+}
+function resetHooksForRequest() {
+  currentRequest$1 = null;
+}
+function prepareToUseHooksForComponent(prevThenableState) {
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+const HooksDispatcher = {
+  useMemo(nextCreate) {
+    return nextCreate();
+  },
+
+  useCallback(callback) {
+    return callback;
+  },
+
+  useDebugValue() {},
+
+  useDeferredValue: unsupportedHook,
+  useTransition: unsupportedHook,
+  readContext,
+  useContext: readContext,
+  useReducer: unsupportedHook,
+  useRef: unsupportedHook,
+  useState: unsupportedHook,
+  useInsertionEffect: unsupportedHook,
+  useLayoutEffect: unsupportedHook,
+  useImperativeHandle: unsupportedHook,
+  useEffect: unsupportedHook,
+  useId,
+  useSyncExternalStore: unsupportedHook,
+
+  useCacheRefresh() {
+    return unsupportedRefresh;
+  },
+
+  useMemoCache(size) {
+    const data = new Array(size);
+
+    for (let i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL;
+    }
+
+    return data;
+  },
+
+  use
+};
+
+function unsupportedHook() {
+  throw new Error('This Hook is not supported in Server Components.');
+}
+
+function unsupportedRefresh() {
+  throw new Error('Refreshing the cache is not supported in Server Components.');
+}
+
+function useId() {
+  if (currentRequest$1 === null) {
+    throw new Error('useId can only be used while React is rendering');
+  }
+
+  const id = currentRequest$1.identifierCount++; // use 'S' for Flight components to distinguish from 'R' and 'r' in Fizz/Client
+
+  return ':' + currentRequest$1.identifierPrefix + 'S' + id.toString(32) + ':';
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object' || typeof usable === 'function') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable; // Track the position of the thenable within this fiber.
+
+      const index = thenableIndexCounter;
+      thenableIndexCounter += 1;
+
+      if (thenableState === null) {
+        thenableState = createThenableState();
+      }
+
+      return trackUsedThenable(thenableState, thenable, index);
+    } else if (usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  }
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function createSignal() {
+  return new AbortController().signal;
+}
+
+function resolveCache() {
+  const request = resolveRequest();
+
+  if (request) {
+    return getCache(request);
+  }
+
+  return new Map();
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal() {
+    const cache = resolveCache();
+    let entry = cache.get(createSignal);
+
+    if (entry === undefined) {
+      entry = createSignal();
+      cache.set(createSignal, entry);
+    }
+
+    return entry;
+  },
+
+  getCacheForType(resourceType) {
+    const cache = resolveCache();
+    let entry = cache.get(resourceType);
+
+    if (entry === undefined) {
+      entry = resourceType(); // TODO: Warn if undefined?
+
+      cache.set(resourceType, entry);
+    }
+
+    return entry;
+  }
+
+};
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+function objectName(object) {
+  // $FlowFixMe[method-unbinding]
+  const name = Object.prototype.toString.call(object);
+  return name.replace(/^\[object (.*)\]$/, function (m, p0) {
+    return p0;
+  });
+}
+
+function describeKeyForErrorMessage(key) {
+  const encodedKey = JSON.stringify(key);
+  return '"' + key + '"' === encodedKey ? key : encodedKey;
+}
+
+function describeValueForErrorMessage(value) {
+  switch (typeof value) {
+    case 'string':
+      {
+        return JSON.stringify(value.length <= 10 ? value : value.slice(0, 10) + '...');
+      }
+
+    case 'object':
+      {
+        if (isArray(value)) {
+          return '[...]';
+        }
+
+        const name = objectName(value);
+
+        if (name === 'Object') {
+          return '{...}';
+        }
+
+        return name;
+      }
+
+    case 'function':
+      return 'function';
+
+    default:
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      return String(value);
+  }
+}
+
+function describeElementType(type) {
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        return describeElementType(type.render);
+
+      case REACT_MEMO_TYPE:
+        return describeElementType(type.type);
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            // Lazy may contain any component type so we recursively resolve it.
+            return describeElementType(init(payload));
+          } catch (x) {}
+        }
+    }
+  }
+
+  return '';
+}
+
+function describeObjectForErrorMessage(objectOrArray, expandedName) {
+  const objKind = objectName(objectOrArray);
+
+  if (objKind !== 'Object' && objKind !== 'Array') {
+    return objKind;
+  }
+
+  let str = '';
+  let start = -1;
+  let length = 0;
+
+  if (isArray(objectOrArray)) {
+    {
+      // Print Array
+      str = '[';
+      const array = objectOrArray;
+
+      for (let i = 0; i < array.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const value = array[i];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if ('' + i === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += ']';
+    }
+  } else {
+    if (objectOrArray.$$typeof === REACT_ELEMENT_TYPE) {
+      str = '<' + describeElementType(objectOrArray.type) + '/>';
+    } else {
+      // Print Object
+      str = '{';
+      const object = objectOrArray;
+      const names = Object.keys(object);
+
+      for (let i = 0; i < names.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const name = names[i];
+        str += describeKeyForErrorMessage(name) + ': ';
+        const value = object[name];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if (name === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += '}';
+    }
+  }
+
+  if (expandedName === undefined) {
+    return str;
+  }
+
+  if (start > -1 && length > 0) {
+    const highlight = ' '.repeat(start) + '^'.repeat(length);
+    return '\n  ' + str + '\n  ' + highlight;
+  }
+
+  return '\n  ' + str;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ReactSharedServerInternals = // $FlowFixMe: It's defined in the one we resolve to.
+React.__SECRET_SERVER_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+if (!ReactSharedServerInternals) {
+  throw new Error('The "react" package in this environment is not configured correctly. ' + 'The "react-server" condition must be enabled in any environment that ' + 'runs React Server Components.');
+}
+
+// Turns a TypedArray or ArrayBuffer into a string that can be used for comparison
+// in a Map to see if the bytes are the same.
+function binaryToComparableString(view) {
+  return String.fromCharCode.apply(String, new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+}
+
+const ObjectPrototype = Object.prototype;
+const stringify = JSON.stringify; // Serializable values
+// Thenable<ReactClientValue>
+
+const PENDING$1 = 0;
+const COMPLETED = 1;
+const ABORTED = 3;
+const ERRORED$1 = 4;
+const TaintRegistryObjects = ReactSharedServerInternals.TaintRegistryObjects,
+      TaintRegistryValues = ReactSharedServerInternals.TaintRegistryValues,
+      TaintRegistryByteLengths = ReactSharedServerInternals.TaintRegistryByteLengths,
+      TaintRegistryPendingRequests = ReactSharedServerInternals.TaintRegistryPendingRequests,
+      ReactCurrentCache = ReactSharedServerInternals.ReactCurrentCache;
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+
+function throwTaintViolation(message) {
+  // eslint-disable-next-line react-internal/prod-error-codes
+  throw new Error(message);
+}
+
+function cleanupTaintQueue(request) {
+  const cleanupQueue = request.taintCleanupQueue;
+  TaintRegistryPendingRequests.delete(cleanupQueue);
+
+  for (let i = 0; i < cleanupQueue.length; i++) {
+    const entryValue = cleanupQueue[i];
+    const entry = TaintRegistryValues.get(entryValue);
+
+    if (entry !== undefined) {
+      if (entry.count === 1) {
+        TaintRegistryValues.delete(entryValue);
+      } else {
+        entry.count--;
+      }
+    }
+  }
+
+  cleanupQueue.length = 0;
+}
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+}
+
+function defaultPostponeHandler(reason) {// Noop
+}
+
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2;
+function createRequest(model, bundlerConfig, onError, context, identifierPrefix, onPostpone) {
+  if (ReactCurrentCache.current !== null && ReactCurrentCache.current !== DefaultCacheDispatcher) {
+    throw new Error('Currently React only supports one RSC renderer at a time.');
+  }
+
+  prepareHostDispatcher();
+  ReactCurrentCache.current = DefaultCacheDispatcher;
+  const abortSet = new Set();
+  const pingedTasks = [];
+  const cleanupQueue = [];
+
+  {
+    TaintRegistryPendingRequests.add(cleanupQueue);
+  }
+
+  const hints = createHints();
+  const request = {
+    status: OPEN,
+    flushScheduled: false,
+    fatalError: null,
+    destination: null,
+    bundlerConfig,
+    cache: new Map(),
+    nextChunkId: 0,
+    pendingChunks: 0,
+    hints,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    completedImportChunks: [],
+    completedHintChunks: [],
+    completedRegularChunks: [],
+    completedErrorChunks: [],
+    writtenSymbols: new Map(),
+    writtenClientReferences: new Map(),
+    writtenServerReferences: new Map(),
+    writtenProviders: new Map(),
+    writtenObjects: new WeakMap(),
+    identifierPrefix: identifierPrefix || '',
+    identifierCount: 1,
+    taintCleanupQueue: cleanupQueue,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? defaultPostponeHandler : onPostpone,
+    // $FlowFixMe[missing-this-annot]
+    toJSON: function (key, value) {
+      return resolveModelToJSON(request, this, key, value);
+    }
+  };
+  request.pendingChunks++;
+  const rootContext = createRootContext(context);
+  const rootTask = createTask(request, model, rootContext, abortSet);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  {
+    const store = requestStorage.getStore();
+    if (store) return store;
+  }
+
+  return null;
+}
+
+function createRootContext(reqContext) {
+  return importServerContexts(reqContext);
+}
+
+const POP = {};
+
+function serializeThenable(request, thenable) {
+  request.pendingChunks++;
+  const newTask = createTask(request, null, getActiveContext(), request.abortableTasks);
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        // We have the resolved value, we can go ahead and schedule it for serialization.
+        newTask.model = thenable.value;
+        pingTask(request, newTask);
+        return newTask.id;
+      }
+
+    case 'rejected':
+      {
+        const x = thenable.reason;
+
+        if (typeof x === 'object' && x !== null && x.$$typeof === REACT_POSTPONE_TYPE) {
+          const postponeInstance = x;
+          logPostpone(request, postponeInstance.message);
+          emitPostponeChunk(request, newTask.id);
+        } else {
+          const digest = logRecoverableError(request, x);
+          emitErrorChunk(request, newTask.id, digest);
+        }
+
+        return newTask.id;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  thenable.then(value => {
+    newTask.model = value;
+    pingTask(request, newTask);
+  }, reason => {
+    newTask.status = ERRORED$1;
+    request.abortableTasks.delete(newTask); // TODO: We should ideally do this inside performWork so it's scheduled
+
+    const digest = logRecoverableError(request, reason);
+    emitErrorChunk(request, newTask.id, digest);
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  });
+  return newTask.id;
+}
+
+function emitHint(request, code, model) {
+  emitHintChunk(request, code, model);
+  enqueueFlush(request);
+}
+function getHints(request) {
+  return request.hints;
+}
+function getCache(request) {
+  return request.cache;
+}
+
+function readThenable(thenable) {
+  if (thenable.status === 'fulfilled') {
+    return thenable.value;
+  } else if (thenable.status === 'rejected') {
+    throw thenable.reason;
+  }
+
+  throw thenable;
+}
+
+function createLazyWrapperAroundWakeable(wakeable) {
+  // This is a temporary fork of the `use` implementation until we accept
+  // promises everywhere.
+  const thenable = wakeable;
+
+  switch (thenable.status) {
+    case 'fulfilled':
+    case 'rejected':
+      break;
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: thenable,
+    _init: readThenable
+  };
+  return lazyType;
+}
+
+function attemptResolveElement(request, type, key, ref, props, prevThenableState) {
+  if (ref !== null && ref !== undefined) {
+    // When the ref moves to the regular props object this will implicitly
+    // throw for functions. We could probably relax it to a DEV warning for other
+    // cases.
+    throw new Error('Refs cannot be used in Server Components, nor passed to Client Components.');
+  }
+
+  if (typeof type === 'function') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    } // This is a server-side component.
+
+
+    prepareToUseHooksForComponent(prevThenableState);
+    const result = type(props);
+
+    if (typeof result === 'object' && result !== null && typeof result.then === 'function') {
+      // When the return value is in children position we can resolve it immediately,
+      // to its value without a wrapper if it's synchronously available.
+      const thenable = result;
+
+      if (thenable.status === 'fulfilled') {
+        return thenable.value;
+      } // TODO: Once we accept Promises as children on the client, we can just return
+      // the thenable here.
+
+
+      return createLazyWrapperAroundWakeable(result);
+    }
+
+    return result;
+  } else if (typeof type === 'string') {
+    // This is a host element. E.g. HTML.
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (typeof type === 'symbol') {
+    if (type === REACT_FRAGMENT_TYPE) {
+      // For key-less fragments, we add a small optimization to avoid serializing
+      // it as a wrapper.
+      // TODO: If a key is specified, we should propagate its key to any children.
+      // Same as if a Server Component has a key.
+      return props.children;
+    } // This might be a built-in React component. We'll let the client decide.
+    // Any built-in works as long as its props are serializable.
+
+
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (type != null && typeof type === 'object') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    }
+
+    switch (type.$$typeof) {
+      case REACT_LAZY_TYPE:
+        {
+          const payload = type._payload;
+          const init = type._init;
+          const wrappedType = init(payload);
+          return attemptResolveElement(request, wrappedType, key, ref, props, prevThenableState);
+        }
+
+      case REACT_FORWARD_REF_TYPE:
+        {
+          const render = type.render;
+          prepareToUseHooksForComponent(prevThenableState);
+          return render(props, undefined);
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          return attemptResolveElement(request, type.type, key, ref, props, prevThenableState);
+        }
+
+      case REACT_PROVIDER_TYPE:
+        {
+          {
+            pushProvider(type._context, props.value);
+
+            return [REACT_ELEMENT_TYPE, type, key, // Rely on __popProvider being serialized last to pop the provider.
+            {
+              value: props.value,
+              children: props.children,
+              __pop: POP
+            }];
+          } // Fallthrough
+
+        }
+    }
+  }
+
+  throw new Error("Unsupported Server Component type: " + describeValueForErrorMessage(type));
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createTask(request, model, context, abortSet) {
+  const id = request.nextChunkId++;
+  const task = {
+    id,
+    status: PENDING$1,
+    model,
+    context,
+    ping: () => pingTask(request, task),
+    thenableState: null
+  };
+  abortSet.add(task);
+  return task;
+}
+
+function serializeByValueID(id) {
+  return '$' + id.toString(16);
+}
+
+function serializeLazyID(id) {
+  return '$L' + id.toString(16);
+}
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeProviderReference(name) {
+  return '$P' + name;
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeRowHeader(tag, id) {
+  return id.toString(16) + ':' + tag;
+}
+
+function encodeReferenceChunk(request, id, reference) {
+  const json = stringify(reference);
+  const row = id.toString(16) + ':' + json + '\n';
+  return stringToChunk(row);
+}
+
+function serializeClientReference(request, parent, key, clientReference) {
+  const clientReferenceKey = getClientReferenceKey(clientReference);
+  const writtenClientReferences = request.writtenClientReferences;
+  const existingId = writtenClientReferences.get(clientReferenceKey);
+
+  if (existingId !== undefined) {
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(existingId);
+    }
+
+    return serializeByValueID(existingId);
+  }
+
+  try {
+    const clientReferenceMetadata = resolveClientReferenceMetadata(request.bundlerConfig, clientReference);
+    request.pendingChunks++;
+    const importId = request.nextChunkId++;
+    emitImportChunk(request, importId, clientReferenceMetadata);
+    writtenClientReferences.set(clientReferenceKey, importId);
+
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(importId);
+    }
+
+    return serializeByValueID(importId);
+  } catch (x) {
+    request.pendingChunks++;
+    const errorId = request.nextChunkId++;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, errorId, digest);
+    return serializeByValueID(errorId);
+  }
+}
+
+function outlineModel(request, value) {
+  request.pendingChunks++;
+  const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+  retryTask(request, newTask);
+  return newTask.id;
+}
+
+function serializeServerReference(request, parent, key, serverReference) {
+  const writtenServerReferences = request.writtenServerReferences;
+  const existingId = writtenServerReferences.get(serverReference);
+
+  if (existingId !== undefined) {
+    return serializeServerReferenceID(existingId);
+  }
+
+  const bound = getServerReferenceBoundArguments(request.bundlerConfig, serverReference);
+  const serverReferenceMetadata = {
+    id: getServerReferenceId(request.bundlerConfig, serverReference),
+    bound: bound ? Promise.resolve(bound) : null
+  };
+  const metadataId = outlineModel(request, serverReferenceMetadata);
+  writtenServerReferences.set(serverReference, metadataId);
+  return serializeServerReferenceID(metadataId);
+}
+
+function serializeLargeTextString(request, text) {
+  request.pendingChunks += 2;
+  const textId = request.nextChunkId++;
+  const textChunk = stringToChunk(text);
+  const binaryLength = byteLengthOfChunk(textChunk);
+  const row = textId.toString(16) + ':T' + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, textChunk);
+  return serializeByValueID(textId);
+}
+
+function serializeMap(request, map) {
+  const entries = Array.from(map);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i][0];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$Q' + id.toString(16);
+}
+
+function serializeSet(request, set) {
+  const entries = Array.from(set);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$W' + id.toString(16);
+}
+
+function serializeTypedArray(request, tag, typedArray) {
+  {
+    if (TaintRegistryByteLengths.has(typedArray.byteLength)) {
+      // If we have had any tainted values of this length, we check
+      // to see if these bytes matches any entries in the registry.
+      const tainted = TaintRegistryValues.get(binaryToComparableString(typedArray));
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    }
+  }
+
+  request.pendingChunks += 2;
+  const bufferId = request.nextChunkId++; // TODO: Convert to little endian if that's not the server default.
+
+  const binaryChunk = typedArrayToBinaryChunk(typedArray);
+  const binaryLength = byteLengthOfBinaryChunk(binaryChunk);
+  const row = bufferId.toString(16) + ':' + tag + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, binaryChunk);
+  return serializeByValueID(bufferId);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+let modelRoot = false;
+
+function resolveModelToJSON(request, parent, key, value) {
+
+
+  switch (value) {
+    case REACT_ELEMENT_TYPE:
+      return '$';
+  }
+
+
+  while (typeof value === 'object' && value !== null && (value.$$typeof === REACT_ELEMENT_TYPE || value.$$typeof === REACT_LAZY_TYPE)) {
+
+    try {
+      switch (value.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const writtenObjects = request.writtenObjects;
+            const existingId = writtenObjects.get(value);
+
+            if (existingId !== undefined) {
+              if (existingId === -1) {
+                // Seen but not yet outlined.
+                const newId = outlineModel(request, value);
+                return serializeByValueID(newId);
+              } else if (modelRoot === value) {
+                // This is the ID we're currently emitting so we need to write it
+                // once but if we discover it again, we refer to it by id.
+                modelRoot = null;
+              } else {
+                // We've already emitted this as an outlined object, so we can
+                // just refer to that by its existing ID.
+                return serializeByValueID(existingId);
+              }
+            } else {
+              // This is the first time we've seen this object. We may never see it again
+              // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+              writtenObjects.set(value, -1);
+            } // TODO: Concatenate keys of parents onto children.
+
+
+            const element = value; // Attempt to render the Server Component.
+
+            value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, null);
+            break;
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = value._payload;
+            const init = value._init;
+            value = init(payload);
+            break;
+          }
+      }
+    } catch (thrownValue) {
+      const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          // Something suspended, we'll need to create a new task and resolve it later.
+          request.pendingChunks++;
+          const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+          const ping = newTask.ping;
+          x.then(ping, ping);
+          newTask.thenableState = getThenableStateAfterSuspending();
+          return serializeLazyID(newTask.id);
+        } else if (x.$$typeof === REACT_POSTPONE_TYPE) {
+          // Something postponed. We'll still send everything we have up until this point.
+          // We'll replace this element with a lazy reference that postpones on the client.
+          const postponeInstance = x;
+          request.pendingChunks++;
+          const postponeId = request.nextChunkId++;
+          logPostpone(request, postponeInstance.message);
+          emitPostponeChunk(request, postponeId);
+          return serializeLazyID(postponeId);
+        }
+      } // Something errored. We'll still send everything we have up until this point.
+      // We'll replace this element with a lazy reference that throws on the client
+      // once it gets rendered.
+
+
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+      const digest = logRecoverableError(request, x);
+      emitErrorChunk(request, errorId, digest);
+      return serializeLazyID(errorId);
+    }
+  }
+
+  if (value === null) {
+    return null;
+  }
+
+  if (typeof value === 'object') {
+    {
+      const tainted = TaintRegistryObjects.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted);
+      }
+    }
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    const writtenObjects = request.writtenObjects;
+    const existingId = writtenObjects.get(value); // $FlowFixMe[method-unbinding]
+
+    if (typeof value.then === 'function') {
+      if (existingId !== undefined) {
+        if (modelRoot === value) {
+          // This is the ID we're currently emitting so we need to write it
+          // once but if we discover it again, we refer to it by id.
+          modelRoot = null;
+        } else {
+          // We've seen this promise before, so we can just refer to the same result.
+          return serializePromiseID(existingId);
+        }
+      } // We assume that any object with a .then property is a "Thenable" type,
+      // or a Promise type. Either of which can be represented by a Promise.
+
+
+      const promiseId = serializeThenable(request, value);
+      writtenObjects.set(value, promiseId);
+      return serializePromiseID(promiseId);
+    }
+
+    {
+      if (value.$$typeof === REACT_PROVIDER_TYPE) {
+        const providerKey = value._context._globalName;
+        const writtenProviders = request.writtenProviders;
+        let providerId = writtenProviders.get(key);
+
+        if (providerId === undefined) {
+          request.pendingChunks++;
+          providerId = request.nextChunkId++;
+          writtenProviders.set(providerKey, providerId);
+          emitProviderChunk(request, providerId, providerKey);
+        }
+
+        return serializeByValueID(providerId);
+      } else if (value === POP) {
+        popProvider();
+
+        return undefined;
+      }
+    }
+
+    if (existingId !== undefined) {
+      if (existingId === -1) {
+        // Seen but not yet outlined.
+        const newId = outlineModel(request, value);
+        return serializeByValueID(newId);
+      } else if (modelRoot === value) {
+        // This is the ID we're currently emitting so we need to write it
+        // once but if we discover it again, we refer to it by id.
+        modelRoot = null;
+      } else {
+        // We've already emitted this as an outlined object, so we can
+        // just refer to that by its existing ID.
+        return serializeByValueID(existingId);
+      }
+    } else {
+      // This is the first time we've seen this object. We may never see it again
+      // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+      writtenObjects.set(value, -1);
+    }
+
+    if (isArray(value)) {
+      // $FlowFixMe[incompatible-return]
+      return value;
+    }
+
+    if (value instanceof Map) {
+      return serializeMap(request, value);
+    }
+
+    if (value instanceof Set) {
+      return serializeSet(request, value);
+    }
+
+    {
+      if (value instanceof ArrayBuffer) {
+        return serializeTypedArray(request, 'A', new Uint8Array(value));
+      }
+
+      if (value instanceof Int8Array) {
+        // char
+        return serializeTypedArray(request, 'C', value);
+      }
+
+      if (value instanceof Uint8Array) {
+        // unsigned char
+        return serializeTypedArray(request, 'c', value);
+      }
+
+      if (value instanceof Uint8ClampedArray) {
+        // unsigned clamped char
+        return serializeTypedArray(request, 'U', value);
+      }
+
+      if (value instanceof Int16Array) {
+        // sort
+        return serializeTypedArray(request, 'S', value);
+      }
+
+      if (value instanceof Uint16Array) {
+        // unsigned short
+        return serializeTypedArray(request, 's', value);
+      }
+
+      if (value instanceof Int32Array) {
+        // long
+        return serializeTypedArray(request, 'L', value);
+      }
+
+      if (value instanceof Uint32Array) {
+        // unsigned long
+        return serializeTypedArray(request, 'l', value);
+      }
+
+      if (value instanceof Float32Array) {
+        // float
+        return serializeTypedArray(request, 'F', value);
+      }
+
+      if (value instanceof Float64Array) {
+        // double
+        return serializeTypedArray(request, 'D', value);
+      }
+
+      if (value instanceof BigInt64Array) {
+        // number
+        return serializeTypedArray(request, 'N', value);
+      }
+
+      if (value instanceof BigUint64Array) {
+        // unsigned number
+        // We use "m" instead of "n" since JSON can start with "null"
+        return serializeTypedArray(request, 'm', value);
+      }
+
+      if (value instanceof DataView) {
+        return serializeTypedArray(request, 'V', value);
+      }
+    }
+
+    const iteratorFn = getIteratorFn(value);
+
+    if (iteratorFn) {
+      return Array.from(value);
+    } // Verify that this is a simple plain object.
+
+
+    const proto = getPrototypeOf(value);
+
+    if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+      throw new Error('Only plain objects, and a few built-ins, can be passed to Client Components ' + 'from Server Components. Classes or null prototypes are not supported.');
+    }
+
+
+    return value;
+  }
+
+  if (typeof value === 'string') {
+    {
+      const tainted = TaintRegistryValues.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    } // TODO: Maybe too clever. If we support URL there's no similar trick.
+
+
+    if (value[value.length - 1] === 'Z') {
+      // Possibly a Date, whose toJSON automatically calls toISOString
+      // $FlowFixMe[incompatible-use]
+      const originalValue = parent[key];
+
+      if (originalValue instanceof Date) {
+        return serializeDateFromDateJSON(value);
+      }
+    }
+
+    if (value.length >= 1024) {
+      // For large strings, we encode them outside the JSON payload so that we
+      // don't have to double encode and double parse the strings. This can also
+      // be more compact in case the string has a lot of escaped characters.
+      return serializeLargeTextString(request, value);
+    }
+
+    return escapeStringValue(value);
+  }
+
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  if (typeof value === 'number') {
+    return serializeNumber(value);
+  }
+
+  if (typeof value === 'undefined') {
+    return serializeUndefined();
+  }
+
+  if (typeof value === 'function') {
+    {
+      const tainted = TaintRegistryObjects.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted);
+      }
+    }
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    if (isServerReference(value)) {
+      return serializeServerReference(request, parent, key, value);
+    }
+
+    if (/^on[A-Z]/.test(key)) {
+      throw new Error('Event handlers cannot be passed to Client Component props.' + describeObjectForErrorMessage(parent, key) + '\nIf you need interactivity, consider converting part of this to a Client Component.');
+    } else {
+      throw new Error('Functions cannot be passed directly to Client Components ' + 'unless you explicitly expose it by marking it with "use server".' + describeObjectForErrorMessage(parent, key));
+    }
+  }
+
+  if (typeof value === 'symbol') {
+    const writtenSymbols = request.writtenSymbols;
+    const existingId = writtenSymbols.get(value);
+
+    if (existingId !== undefined) {
+      return serializeByValueID(existingId);
+    } // $FlowFixMe[incompatible-type] `description` might be undefined
+
+
+    const name = value.description;
+
+    if (Symbol.for(name) !== value) {
+      throw new Error('Only global symbols received from Symbol.for(...) can be passed to Client Components. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+      value.description + ") cannot be found among global symbols.") + describeObjectForErrorMessage(parent, key));
+    }
+
+    request.pendingChunks++;
+    const symbolId = request.nextChunkId++;
+    emitSymbolChunk(request, symbolId, name);
+    writtenSymbols.set(value, symbolId);
+    return serializeByValueID(symbolId);
+  }
+
+  if (typeof value === 'bigint') {
+    {
+      const tainted = TaintRegistryValues.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    }
+
+    return serializeBigInt(value);
+  }
+
+  throw new Error("Type " + typeof value + " is not supported in Client Component props." + describeObjectForErrorMessage(parent, key));
+}
+
+function logPostpone(request, reason) {
+  const onPostpone = request.onPostpone;
+  onPostpone(reason);
+}
+
+function logRecoverableError(request, error) {
+  const onError = request.onError;
+  const errorDigest = onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest || '';
+}
+
+function fatalError(request, error) {
+  {
+    cleanupTaintQueue(request);
+  } // This is called outside error handling code such as if an error happens in React internals.
+
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function emitPostponeChunk(request, id, postponeInstance) {
+  let row;
+
+  {
+    // No reason included in prod.
+    row = serializeRowHeader('P', id) + '\n';
+  }
+
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitErrorChunk(request, id, digest, error) {
+  let errorInfo;
+
+  {
+    errorInfo = {
+      digest
+    };
+  }
+
+  const row = serializeRowHeader('E', id) + stringify(errorInfo) + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitImportChunk(request, id, clientReferenceMetadata) {
+  // $FlowFixMe[incompatible-type] stringify can return null
+  const json = stringify(clientReferenceMetadata);
+  const row = serializeRowHeader('I', id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitHintChunk(request, code, model) {
+  const json = stringify(model);
+  const id = request.nextChunkId++;
+  const row = serializeRowHeader('H' + code, id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedHintChunks.push(processedChunk);
+}
+
+function emitSymbolChunk(request, id, name) {
+  const symbolReference = serializeSymbolReference(name);
+  const processedChunk = encodeReferenceChunk(request, id, symbolReference);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitProviderChunk(request, id, contextName) {
+  const contextReference = serializeProviderReference(contextName);
+  const processedChunk = encodeReferenceChunk(request, id, contextReference);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function emitModelChunk(request, id, model) {
+  // Track the root so we know that we have to emit this object even though it
+  // already has an ID. This is needed because we might see this object twice
+  // in the same toJSON if it is cyclic.
+  modelRoot = model; // $FlowFixMe[incompatible-type] stringify can return null
+
+  const json = stringify(model, request.toJSON);
+  const row = id.toString(16) + ':' + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function retryTask(request, task) {
+  if (task.status !== PENDING$1) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  }
+
+  switchContext(task.context);
+
+  try {
+    let value = task.model;
+
+    if (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+      request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+      const element = value; // When retrying a component, reuse the thenableState from the
+      // previous attempt.
+
+      const prevThenableState = task.thenableState; // Attempt to render the Server Component.
+      // Doing this here lets us reuse this same task if the next component
+      // also suspends.
+
+      task.model = value;
+      value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, prevThenableState); // Successfully finished this component. We're going to keep rendering
+      // using the same task, but we reset its thenable state before continuing.
+
+      task.thenableState = null; // Keep rendering and reuse the same task. This inner loop is separate
+      // from the render above because we don't need to reset the thenable state
+      // until the next time something suspends and retries.
+
+      while (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+        request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+        const nextElement = value;
+        task.model = value;
+        value = attemptResolveElement(request, nextElement.type, nextElement.key, nextElement.ref, nextElement.props, null);
+      }
+    } // Track that this object is outlined and has an id.
+
+
+    if (typeof value === 'object' && value !== null) {
+      request.writtenObjects.set(value, task.id);
+    }
+
+    emitModelChunk(request, task.id, value);
+    request.abortableTasks.delete(task);
+    task.status = COMPLETED;
+  } catch (thrownValue) {
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      } else if (x.$$typeof === REACT_POSTPONE_TYPE) {
+        request.abortableTasks.delete(task);
+        task.status = ERRORED$1;
+        const postponeInstance = x;
+        logPostpone(request, postponeInstance.message);
+        emitPostponeChunk(request, task.id);
+        return;
+      }
+    }
+
+    request.abortableTasks.delete(task);
+    task.status = ERRORED$1;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, task.id, digest);
+  }
+}
+
+function performWork(request) {
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  const prevRequest = currentRequest;
+  currentRequest = request;
+  prepareToUseHooksForRequest(request);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    request.pingedTasks = [];
+
+    for (let i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    ReactCurrentDispatcher.current = prevDispatcher;
+    resetHooksForRequest();
+    currentRequest = prevRequest;
+  }
+}
+
+function abortTask(task, request, errorId) {
+  task.status = ABORTED; // Instead of emitting an error per task.id, we emit a model that only
+  // has a single value referencing the error.
+
+  const ref = serializeByValueID(errorId);
+  const processedChunk = encodeReferenceChunk(request, task.id, ref);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function flushCompletedChunks(request, destination) {
+  beginWriting();
+
+  try {
+    // We emit module chunks first in the stream so that
+    // they can be preloaded as early as possible.
+    const importsChunks = request.completedImportChunks;
+    let i = 0;
+
+    for (; i < importsChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = importsChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    importsChunks.splice(0, i); // Next comes hints.
+
+    const hintChunks = request.completedHintChunks;
+    i = 0;
+
+    for (; i < hintChunks.length; i++) {
+      const chunk = hintChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    hintChunks.splice(0, i); // Next comes model data.
+
+    const regularChunks = request.completedRegularChunks;
+    i = 0;
+
+    for (; i < regularChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = regularChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    regularChunks.splice(0, i); // Finally, errors are sent. The idea is that it's ok to delay
+    // any error messages and prioritize display of other parts of
+    // the page.
+
+    const errorChunks = request.completedErrorChunks;
+    i = 0;
+
+    for (; i < errorChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = errorChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    errorChunks.splice(0, i);
+  } finally {
+    request.flushScheduled = false;
+    completeWriting(destination);
+  }
+
+  flushBuffered(destination);
+
+  if (request.pendingChunks === 0) {
+    // We're done.
+    {
+      cleanupTaintQueue(request);
+    }
+
+    close$1(destination);
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  {
+    scheduleWork(() => requestStorage.run(request, performWork, request));
+  }
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    const destination = request.destination;
+    request.flushScheduled = true;
+    scheduleWork(() => flushCompletedChunks(request, destination));
+  }
+}
+
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedChunks(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function stopFlowing(request) {
+  request.destination = null;
+} // This is called to early terminate a request. It creates an error at all pending tasks.
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      // We have tasks to abort. We'll emit one error row and then emit a reference
+      // to that row from every row that's still remaining.
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+
+      if (enablePostpone && typeof reason === 'object' && reason !== null && reason.$$typeof === REACT_POSTPONE_TYPE) {
+        const postponeInstance = reason;
+        logPostpone(request, postponeInstance.message);
+        emitPostponeChunk(request, errorId, postponeInstance);
+      } else {
+        const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+        const digest = logRecoverableError(request, error);
+        emitErrorChunk(request, errorId, digest, error);
+      }
+
+      abortableTasks.forEach(task => abortTask(task, request, errorId));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function importServerContexts(contexts) {
+  if (contexts) {
+    const prevContext = getActiveContext();
+    switchContext(rootContextSnapshot);
+
+    for (let i = 0; i < contexts.length; i++) {
+      const _contexts$i = contexts[i],
+            name = _contexts$i[0],
+            value = _contexts$i[1];
+      const context = getOrCreateServerContext(name);
+      pushProvider(context, value);
+    }
+
+    const importedContext = getActiveContext();
+    switchContext(prevContext);
+    return importedContext;
+  }
+
+  return rootContextSnapshot;
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+function resolveServerReference(bundlerConfig, id) {
+  let name = '';
+  let resolvedModuleData = bundlerConfig[id];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = id.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = id.slice(idx + 1);
+      resolvedModuleData = bundlerConfig[id.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + id + '" in the React Server Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  } // TODO: This needs to return async: true if it's an async module.
+
+
+  return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+} // The chunk cache contains all the chunks we've preloaded so far.
+// If they're still pending they're a thenable. This map also exists
+// in Webpack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = globalThis.__next_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+  let i = 0;
+
+  while (i < chunks.length) {
+    const chunkId = chunks[i++];
+    chunks[i++];
+    const entry = chunkCache.get(chunkId);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkId);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkId, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkId, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = globalThis.__next_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+function loadChunk(chunkId, filename) {
+  return __webpack_chunk_load__(chunkId);
+}
+
+// The server acts as a Client of itself when resolving Server References.
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const RESOLVED_MODEL = 'resolved_model';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function bindArgs$1(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference$1(response, id, bound, parentChunk, parentObject, key) {
+  const serverReference = resolveServerReference(response._bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+  let promise;
+
+  if (bound) {
+    promise = Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs$1(requireModule(serverReference), args);
+    });
+  } else {
+    if (preloadPromise) {
+      promise = Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+    } else {
+      // Synchronously available
+      return requireModule(serverReference);
+    }
+  }
+
+  promise.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk)); // We need a placeholder value that will be replaced later.
+
+  return null;
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+
+  try {
+    const value = JSON.parse(chunk.value, chunk._response._fromJSON);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    const prefix = response._prefix;
+    const key = prefix + id; // Check if we have this field in the backing store already.
+
+    const backingEntry = response._formData.get(key);
+
+    if (backingEntry != null) {
+      // We assume that this is a string entry for now.
+      chunk = createResolvedModelChunk(response, backingEntry);
+    } else {
+      // We're still waiting on this entry to stream in.
+      chunk = createPendingChunk(response);
+    }
+
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+    blocked.deps++;
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  if (chunk.status === RESOLVED_MODEL) {
+    initializeModelChunk(chunk);
+  }
+
+  if (chunk.status !== INITIALIZED) {
+    // We know that this is emitted earlier so otherwise it's an error.
+    throw chunk.reason;
+  }
+
+  return chunk.value;
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16); // TODO: Just encode this in the reference inline instead of as a model.
+
+          const metaData = getOutlinedModel(response, id);
+          return loadServerReference$1(response, metaData.id, metaData.bound, initializingChunk, parentObject, key);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'K':
+        {
+          // FormData
+          const stringId = value.slice(2);
+          const formPrefix = response._prefix + stringId + '_';
+          const data = new FormData();
+          const backingFormData = response._formData; // We assume that the reference to FormData always comes after each
+          // entry that it references so we can assume they all exist in the
+          // backing store already.
+          // $FlowFixMe[prop-missing] FormData has forEach on it.
+
+          backingFormData.forEach((entry, entryKey) => {
+            if (entryKey.startsWith(formPrefix)) {
+              data.append(entryKey.slice(formPrefix.length), entry);
+            }
+          });
+          return data;
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function createResponse(bundlerConfig, formFieldPrefix) {
+  let backingFormData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new FormData();
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _prefix: formFieldPrefix,
+    _formData: backingFormData,
+    _chunks: chunks,
+    _fromJSON: function (key, value) {
+      if (typeof value === 'string') {
+        // We can't use .bind here because we need the "this" value.
+        return parseModelString(response, this, key, value);
+      }
+
+      return value;
+    }
+  };
+  return response;
+}
+function resolveField(response, key, value) {
+  // Add this field to the backing store.
+  response._formData.append(key, value);
+
+  const prefix = response._prefix;
+
+  if (key.startsWith(prefix)) {
+    const chunks = response._chunks;
+    const id = +key.slice(prefix.length);
+    const chunk = chunks.get(id);
+
+    if (chunk) {
+      // We were waiting on this key so now we can resolve it.
+      resolveModelChunk(chunk, value);
+    }
+  }
+}
+function resolveFileInfo(response, key, filename, mime) {
+  return {
+    chunks: [],
+    filename,
+    mime
+  };
+}
+function resolveFileChunk(response, handle, chunk) {
+  handle.chunks.push(chunk);
+}
+function resolveFileComplete(response, key, handle) {
+  // Add this file to the backing store.
+  // Node.js doesn't expose a global File constructor so we need to use
+  // the append() form that takes the file name as the third argument,
+  // to create a File object.
+  const blob = new Blob(handle.chunks, {
+    type: handle.mime
+  });
+
+  response._formData.append(key, blob, handle.filename);
+}
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function bindArgs(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference(bundlerConfig, id, bound) {
+  const serverReference = resolveServerReference(bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+
+  if (bound) {
+    return Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs(requireModule(serverReference), args);
+    });
+  } else if (preloadPromise) {
+    return Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+  } else {
+    // Synchronously available
+    return Promise.resolve(requireModule(serverReference));
+  }
+}
+
+function decodeBoundActionMetaData(body, serverManifest, formFieldPrefix) {
+  // The data for this reference is encoded in multiple fields under this prefix.
+  const actionResponse = createResponse(serverManifest, formFieldPrefix, body);
+  close(actionResponse);
+  const refPromise = getRoot(actionResponse); // Force it to initialize
+  // $FlowFixMe
+
+  refPromise.then(() => {});
+
+  if (refPromise.status !== 'fulfilled') {
+    // $FlowFixMe
+    throw refPromise.reason;
+  }
+
+  return refPromise.value;
+}
+
+function decodeAction(body, serverManifest) {
+  // We're going to create a new formData object that holds all the fields except
+  // the implementation details of the action data.
+  const formData = new FormData();
+  let action = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (!key.startsWith('$ACTION_')) {
+      formData.append(key, value);
+      return;
+    } // Later actions may override earlier actions if a button is used to override the default
+    // form action.
+
+
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      const metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+      action = loadServerReference(serverManifest, metaData.id, metaData.bound);
+      return;
+    }
+
+    if (key.startsWith('$ACTION_ID_')) {
+      const id = key.slice(11);
+      action = loadServerReference(serverManifest, id, null);
+      return;
+    }
+  });
+
+  if (action === null) {
+    return null;
+  } // Return the action with the remaining FormData bound to the first argument.
+
+
+  return action.then(fn => fn.bind(null, formData));
+}
+function decodeFormState(actionResult, body, serverManifest) {
+  const keyPath = body.get('$ACTION_KEY');
+
+  if (typeof keyPath !== 'string') {
+    // This form submission did not include any form state.
+    return Promise.resolve(null);
+  } // Search through the form data object to get the reference id and the number
+  // of bound arguments. This repeats some of the work done in decodeAction.
+
+
+  let metaData = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+    } // We don't check for the simple $ACTION_ID_ case because form state actions
+    // are always bound to the state argument.
+
+  });
+
+  if (metaData === null) {
+    // Should be unreachable.
+    return Promise.resolve(null);
+  }
+
+  const referenceId = metaData.id;
+  return Promise.resolve(metaData.bound).then(bound => {
+    if (bound === null) {
+      // Should be unreachable because form state actions are always bound to the
+      // state argument.
+      return null;
+    } // The form action dispatch method is always bound to the initial state.
+    // But when comparing signatures, we compare to the original unbound action.
+    // Subtract one from the arity to account for this.
+
+
+    const boundArity = bound.length - 1;
+    return [actionResult, keyPath, referenceId, boundArity];
+  });
+}
+
+function createDrainHandler(destination, request) {
+  return () => startFlowing(request, destination);
+}
+
+function createCancelHandler(request, reason) {
+  return () => {
+    stopFlowing(request); // eslint-disable-next-line react-internal/prod-error-codes
+
+    abort(request, new Error(reason));
+  };
+}
+
+function renderToPipeableStream(model, webpackMap, options) {
+  const request = createRequest(model, webpackMap, options ? options.onError : undefined, options ? options.context : undefined, options ? options.identifierPrefix : undefined, options ? options.onPostpone : undefined);
+  let hasStartedFlowing = false;
+  startWork(request);
+  return {
+    pipe(destination) {
+      if (hasStartedFlowing) {
+        throw new Error('React currently only supports piping to one writable stream.');
+      }
+
+      hasStartedFlowing = true;
+      startFlowing(request, destination);
+      destination.on('drain', createDrainHandler(destination, request));
+      destination.on('error', createCancelHandler(request, 'The destination stream errored while writing data.'));
+      destination.on('close', createCancelHandler(request, 'The destination stream closed early.'));
+      return destination;
+    },
+
+    abort(reason) {
+      abort(request, reason);
+    }
+
+  };
+}
+
+function decodeReplyFromBusboy(busboyStream, webpackMap) {
+  const response = createResponse(webpackMap, '');
+  let pendingFiles = 0;
+  const queuedFields = [];
+  busboyStream.on('field', (name, value) => {
+    if (pendingFiles > 0) {
+      // Because the 'end' event fires two microtasks after the next 'field'
+      // we would resolve files and fields out of order. To handle this properly
+      // we queue any fields we receive until the previous file is done.
+      queuedFields.push(name, value);
+    } else {
+      resolveField(response, name, value);
+    }
+  });
+  busboyStream.on('file', (name, value, _ref) => {
+    let filename = _ref.filename,
+        encoding = _ref.encoding,
+        mimeType = _ref.mimeType;
+
+    if (encoding.toLowerCase() === 'base64') {
+      throw new Error("React doesn't accept base64 encoded file uploads because we don't expect " + "form data passed from a browser to ever encode data that way. If that's " + 'the wrong assumption, we can easily fix it.');
+    }
+
+    pendingFiles++;
+    const file = resolveFileInfo(response, name, filename, mimeType);
+    value.on('data', chunk => {
+      resolveFileChunk(response, file, chunk);
+    });
+    value.on('end', () => {
+      resolveFileComplete(response, name, file);
+      pendingFiles--;
+
+      if (pendingFiles === 0) {
+        // Release any queued fields
+        for (let i = 0; i < queuedFields.length; i += 2) {
+          resolveField(response, queuedFields[i], queuedFields[i + 1]);
+        }
+
+        queuedFields.length = 0;
+      }
+    });
+  });
+  busboyStream.on('finish', () => {
+    close(response);
+  });
+  busboyStream.on('error', err => {
+    reportGlobalError(response, // $FlowFixMe[incompatible-call] types Error and mixed are incompatible
+    err);
+  });
+  return getRoot(response);
+}
+
+function decodeReply(body, webpackMap) {
+  if (typeof body === 'string') {
+    const form = new FormData();
+    form.append('0', body);
+    body = form;
+  }
+
+  const response = createResponse(webpackMap, '', body);
+  const root = getRoot(response);
+  close(response);
+  return root;
+}
+
+exports.createClientModuleProxy = createClientModuleProxy;
+exports.decodeAction = decodeAction;
+exports.decodeFormState = decodeFormState;
+exports.decodeReply = decodeReply;
+exports.decodeReplyFromBusboy = decodeReplyFromBusboy;
+exports.registerClientReference = registerClientReference;
+exports.registerServerReference = registerServerReference;
+exports.renderToPipeableStream = renderToPipeableStream;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.node.production.min.js b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.node.production.min.js
index eb4093b127bcd..4b9e68f673d5f 100644
--- a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.node.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.node.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-webpack-server.node.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-webpack-server.node.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var aa=require("util");require("crypto");var ba=require("async_hooks"),ca=require("react"),da=require("react-dom"),l=null,m=0,p=!0;function q(a,b){a=a.write(b);p=p&&a}
 function r(a,b){if("string"===typeof b){if(0!==b.length)if(2048<3*b.length)0<m&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=0),q(a,ea.encode(b));else{var d=l;0<m&&(d=l.subarray(m));d=ea.encodeInto(b,d);var c=d.read;m+=d.written;c<b.length&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=ea.encodeInto(b.slice(c),l).written);2048===m&&(q(a,l),l=new Uint8Array(2048),m=0)}}else 0!==b.byteLength&&(2048<b.byteLength?(0<m&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=0),q(a,b)):(d=l.length-m,d<b.byteLength&&
 (0===d?q(a,l):(l.set(b.subarray(0,d),m),m+=d,q(a,l),b=b.subarray(d)),l=new Uint8Array(2048),m=0),l.set(b,m),m+=b.byteLength,2048===m&&(q(a,l),l=new Uint8Array(2048),m=0)));return p}var ea=new aa.TextEncoder,t=Symbol.for("react.client.reference"),v=Symbol.for("react.server.reference");function x(a,b,d){return Object.defineProperties(a,{$$typeof:{value:t},$$id:{value:b},$$async:{value:d}})}var fa=Function.prototype.bind,ha=Array.prototype.slice;
@@ -86,3 +86,5 @@ exports.decodeFormState=function(a,b,d){var c=b.get("$ACTION_KEY");if("string"!=
 exports.decodeReplyFromBusboy=function(a,b){var d=bc(b,""),c=0,e=[];a.on("field",function(f,g){0<c?e.push(f,g):cc(d,f,g)});a.on("file",function(f,g,h){var k=h.filename,n=h.mimeType;if("base64"===h.encoding.toLowerCase())throw Error("React doesn't accept base64 encoded file uploads because we don't expect form data passed from a browser to ever encode data that way. If that's the wrong assumption, we can easily fix it.");c++;var w=[];g.on("data",function(u){w.push(u)});g.on("end",function(){var u=
 new Blob(w,{type:n});d._formData.append(f,u,k);c--;if(0===c){for(u=0;u<e.length;u+=2)cc(d,e[u],e[u+1]);e.length=0}})});a.on("finish",function(){gc(d)});a.on("error",function(f){Zb(d,f)});return Z(d,0)};exports.registerClientReference=function(a,b,d){return x(a,b+"#"+d,!1)};exports.registerServerReference=function(a,b,d){return Object.defineProperties(a,{$$typeof:{value:v},$$id:{value:null===d?b:b+"#"+d},$$bound:{value:null},bind:{value:ia}})};
 exports.renderToPipeableStream=function(a,b,d){var c=tb(a,b,d?d.onError:void 0,d?d.context:void 0,d?d.identifierPrefix:void 0,d?d.onPostpone:void 0),e=!1;Kb(c);return{pipe:function(f){if(e)throw Error("React currently only supports piping to one writable stream.");e=!0;Lb(c,f);f.on("drain",jc(f,c));f.on("error",kc(c,"The destination stream errored while writing data."));f.on("close",kc(c,"The destination stream closed early."));return f},abort:function(f){Mb(c,f)}}};
+
+//# sourceMappingURL=react-server-dom-webpack-server.node.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.node.unbundled.production.js b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.node.unbundled.production.js
new file mode 100644
index 0000000000000..eaf95c060aaaf
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.node.unbundled.production.js
@@ -0,0 +1,3604 @@
+/**
+ * @license React
+ * react-server-dom-webpack-server.node.unbundled.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var util = require('util');
+require('crypto');
+var async_hooks = require('async_hooks');
+var React = require('react');
+var ReactDOM = require('react-dom');
+
+// -----------------------------------------------------------------------------
+const enablePostpone = true;
+
+function scheduleWork(callback) {
+  setImmediate(callback);
+}
+function flushBuffered(destination) {
+  // If we don't have any more data to send right now.
+  // Flush whatever is in the buffer to the wire.
+  if (typeof destination.flush === 'function') {
+    // By convention the Zlib streams provide a flush function for this purpose.
+    // For Express, compression middleware adds this method.
+    destination.flush();
+  }
+}
+const VIEW_SIZE = 2048;
+let currentView = null;
+let writtenBytes = 0;
+let destinationHasCapacity = true;
+function beginWriting(destination) {
+  currentView = new Uint8Array(VIEW_SIZE);
+  writtenBytes = 0;
+  destinationHasCapacity = true;
+}
+
+function writeStringChunk(destination, stringChunk) {
+  if (stringChunk.length === 0) {
+    return;
+  } // maximum possible view needed to encode entire string
+
+
+  if (stringChunk.length * 3 > VIEW_SIZE) {
+    if (writtenBytes > 0) {
+      writeToDestination(destination, currentView.subarray(0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    writeToDestination(destination, textEncoder.encode(stringChunk));
+    return;
+  }
+
+  let target = currentView;
+
+  if (writtenBytes > 0) {
+    target = currentView.subarray(writtenBytes);
+  }
+
+  const _textEncoder$encodeIn = textEncoder.encodeInto(stringChunk, target),
+        read = _textEncoder$encodeIn.read,
+        written = _textEncoder$encodeIn.written;
+
+  writtenBytes += written;
+
+  if (read < stringChunk.length) {
+    writeToDestination(destination, currentView.subarray(0, writtenBytes));
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = textEncoder.encodeInto(stringChunk.slice(read), currentView).written;
+  }
+
+  if (writtenBytes === VIEW_SIZE) {
+    writeToDestination(destination, currentView);
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+}
+
+function writeViewChunk(destination, chunk) {
+  if (chunk.byteLength === 0) {
+    return;
+  }
+
+  if (chunk.byteLength > VIEW_SIZE) {
+    // one that is cached by the streaming renderer. We will enqueu
+    // it directly and expect it is not re-used
+
+
+    if (writtenBytes > 0) {
+      writeToDestination(destination, currentView.subarray(0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    writeToDestination(destination, chunk);
+    return;
+  }
+
+  let bytesToWrite = chunk;
+  const allowableBytes = currentView.length - writtenBytes;
+
+  if (allowableBytes < bytesToWrite.byteLength) {
+    // this chunk would overflow the current view. We enqueue a full view
+    // and start a new view with the remaining chunk
+    if (allowableBytes === 0) {
+      // the current view is already full, send it
+      writeToDestination(destination, currentView);
+    } else {
+      // fill up the current view and apply the remaining chunk bytes
+      // to a new view.
+      currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes);
+      writtenBytes += allowableBytes;
+      writeToDestination(destination, currentView);
+      bytesToWrite = bytesToWrite.subarray(allowableBytes);
+    }
+
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+
+  currentView.set(bytesToWrite, writtenBytes);
+  writtenBytes += bytesToWrite.byteLength;
+
+  if (writtenBytes === VIEW_SIZE) {
+    writeToDestination(destination, currentView);
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+}
+
+function writeChunk(destination, chunk) {
+  if (typeof chunk === 'string') {
+    writeStringChunk(destination, chunk);
+  } else {
+    writeViewChunk(destination, chunk);
+  }
+}
+
+function writeToDestination(destination, view) {
+  const currentHasCapacity = destination.write(view);
+  destinationHasCapacity = destinationHasCapacity && currentHasCapacity;
+}
+
+function writeChunkAndReturn(destination, chunk) {
+  writeChunk(destination, chunk);
+  return destinationHasCapacity;
+}
+function completeWriting(destination) {
+  if (currentView && writtenBytes > 0) {
+    destination.write(currentView.subarray(0, writtenBytes));
+  }
+
+  currentView = null;
+  writtenBytes = 0;
+  destinationHasCapacity = true;
+}
+function close$1(destination) {
+  destination.end();
+}
+const textEncoder = new util.TextEncoder();
+function stringToChunk(content) {
+  return content;
+}
+function typedArrayToBinaryChunk(content) {
+  // Convert any non-Uint8Array array to Uint8Array. We could avoid this for Uint8Arrays.
+  return new Uint8Array(content.buffer, content.byteOffset, content.byteLength);
+}
+function byteLengthOfChunk(chunk) {
+  return typeof chunk === 'string' ? Buffer.byteLength(chunk, 'utf8') : chunk.byteLength;
+}
+function byteLengthOfBinaryChunk(chunk) {
+  return chunk.byteLength;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+  destination.destroy(error);
+}
+
+// eslint-disable-next-line no-unused-vars
+const CLIENT_REFERENCE_TAG = Symbol.for('react.client.reference');
+const SERVER_REFERENCE_TAG = Symbol.for('react.server.reference');
+function isClientReference(reference) {
+  return reference.$$typeof === CLIENT_REFERENCE_TAG;
+}
+function isServerReference(reference) {
+  return reference.$$typeof === SERVER_REFERENCE_TAG;
+}
+function registerClientReference(proxyImplementation, id, exportName) {
+  return registerClientReferenceImpl(proxyImplementation, id + '#' + exportName, false);
+}
+
+function registerClientReferenceImpl(proxyImplementation, id, async) {
+  return Object.defineProperties(proxyImplementation, {
+    $$typeof: {
+      value: CLIENT_REFERENCE_TAG
+    },
+    $$id: {
+      value: id
+    },
+    $$async: {
+      value: async
+    }
+  });
+} // $FlowFixMe[method-unbinding]
+
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+
+  if (this.$$typeof === SERVER_REFERENCE_TAG) {
+    const args = ArraySlice.call(arguments, 1);
+    newFn.$$typeof = SERVER_REFERENCE_TAG;
+    newFn.$$id = this.$$id;
+    newFn.$$bound = this.$$bound ? this.$$bound.concat(args) : args;
+  }
+
+  return newFn;
+}
+
+function registerServerReference(reference, id, exportName) {
+  return Object.defineProperties(reference, {
+    $$typeof: {
+      value: SERVER_REFERENCE_TAG
+    },
+    $$id: {
+      value: exportName === null ? id : id + '#' + exportName
+    },
+    $$bound: {
+      value: null
+    },
+    bind: {
+      value: bind
+    }
+  });
+}
+const PROMISE_PROTOTYPE = Promise.prototype;
+const deepProxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        // These names are a little too common. We should probably have a way to
+        // have the Flight runtime extract the inner target instead.
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+
+      case 'displayName':
+        return undefined;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case 'Provider':
+        throw new Error("Cannot render a Client Context Provider on the Server. " + "Instead, you can export a Client Component wrapper " + "that itself renders a Client Context Provider.");
+    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+    const expression = String(target.name) + '.' + String(name);
+    throw new Error("Cannot access " + expression + " on the server. " + 'You cannot dot into a client module from a server component. ' + 'You can only pass the imported name through.');
+  },
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+
+function getReference(target, name) {
+  switch (name) {
+    // These names are read by the Flight runtime if you end up using the exports object.
+    case '$$typeof':
+      return target.$$typeof;
+
+    case '$$id':
+      return target.$$id;
+
+    case '$$async':
+      return target.$$async;
+
+    case 'name':
+      return target.name;
+    // We need to special case this because createElement reads it if we pass this
+    // reference.
+
+    case 'defaultProps':
+      return undefined;
+    // Avoid this attempting to be serialized.
+
+    case 'toJSON':
+      return undefined;
+
+    case Symbol.toPrimitive:
+      // $FlowFixMe[prop-missing]
+      return Object.prototype[Symbol.toPrimitive];
+
+    case '__esModule':
+      // Something is conditionally checking which export to use. We'll pretend to be
+      // an ESM compat module but then we'll check again on the client.
+      const moduleId = target.$$id;
+      target.default = registerClientReferenceImpl(function () {
+        throw new Error("Attempted to call the default export of " + moduleId + " from the server " + "but it's on the client. It's not possible to invoke a client function from " + "the server, it can only be rendered as a Component or passed to props of a " + "Client Component.");
+      }, target.$$id + '#', target.$$async);
+      return true;
+
+    case 'then':
+      if (target.then) {
+        // Use a cached value
+        return target.then;
+      }
+
+      if (!target.$$async) {
+        // If this module is expected to return a Promise (such as an AsyncModule) then
+        // we should resolve that with a client reference that unwraps the Promise on
+        // the client.
+        const clientReference = registerClientReferenceImpl({}, target.$$id, true);
+        const proxy = new Proxy(clientReference, proxyHandlers); // Treat this as a resolved Promise for React's use()
+
+        target.status = 'fulfilled';
+        target.value = proxy;
+        const then = target.then = registerClientReferenceImpl(function then(resolve, reject) {
+          // Expose to React.
+          return Promise.resolve(resolve(proxy));
+        }, // If this is not used as a Promise but is treated as a reference to a `.then`
+        // export then we should treat it as a reference to that name.
+        target.$$id + '#then', false);
+        return then;
+      } else {
+        // Since typeof .then === 'function' is a feature test we'd continue recursing
+        // indefinitely if we return a function. Instead, we return an object reference
+        // if we check further.
+        return undefined;
+      }
+
+  }
+
+  let cachedReference = target[name];
+
+  if (!cachedReference) {
+    const reference = registerClientReferenceImpl(function () {
+      throw new Error( // eslint-disable-next-line react-internal/safe-string-coercion
+      "Attempted to call " + String(name) + "() from the server but " + String(name) + " is on the client. " + "It's not possible to invoke a client function from the server, it can " + "only be rendered as a Component or passed to props of a Client Component.");
+    }, target.$$id + '#' + name, target.$$async);
+    Object.defineProperty(reference, 'name', {
+      value: name
+    });
+    cachedReference = target[name] = new Proxy(reference, deepProxyHandlers);
+  }
+
+  return cachedReference;
+}
+
+const proxyHandlers = {
+  get: function (target, name, receiver) {
+    return getReference(target, name);
+  },
+  getOwnPropertyDescriptor: function (target, name) {
+    let descriptor = Object.getOwnPropertyDescriptor(target, name);
+
+    if (!descriptor) {
+      descriptor = {
+        value: getReference(target, name),
+        writable: false,
+        configurable: false,
+        enumerable: false
+      };
+      Object.defineProperty(target, name, descriptor);
+    }
+
+    return descriptor;
+  },
+
+  getPrototypeOf(target) {
+    // Pretend to be a Promise in case anyone asks.
+    return PROMISE_PROTOTYPE;
+  },
+
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+function createClientModuleProxy(moduleId) {
+  const clientReference = registerClientReferenceImpl({}, // Represents the whole Module object instead of a particular import.
+  moduleId, false);
+  return new Proxy(clientReference, proxyHandlers);
+}
+
+function getClientReferenceKey(reference) {
+  return reference.$$async ? reference.$$id + '#async' : reference.$$id;
+}
+function resolveClientReferenceMetadata(config, clientReference) {
+  const modulePath = clientReference.$$id;
+  let name = '';
+  let resolvedModuleData = config[modulePath];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = modulePath.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = modulePath.slice(idx + 1);
+      resolvedModuleData = config[modulePath.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + modulePath + '" in the React Client Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  }
+
+  if (clientReference.$$async === true) {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1];
+  } else {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+  }
+}
+function getServerReferenceId(config, serverReference) {
+  return serverReference.$$id;
+}
+function getServerReferenceBoundArguments(config, serverReference) {
+  return serverReference.$$bound;
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMFlightServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule: preloadModule$1,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+
+function prefetchDNS(href) {
+  {
+    if (typeof href === 'string' && href) {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'D|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        emitHint(request, 'D', href);
+      }
+    }
+  }
+}
+
+function preconnect(href, crossOrigin) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = "C|" + (crossOrigin == null ? 'null' : crossOrigin) + "|" + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+
+        if (typeof crossOrigin === 'string') {
+          emitHint(request, 'C', [href, crossOrigin]);
+        } else {
+          emitHint(request, 'C', href);
+        }
+      }
+    }
+  }
+}
+
+function preload(href, as, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        let key = 'L';
+
+        if (as === 'image' && options) {
+          key += getImagePreloadKey(href, options.imageSrcSet, options.imageSizes);
+        } else {
+          key += "[" + as + "]" + href;
+        }
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          emitHint(request, 'L', [href, as, trimmed]);
+        } else {
+          emitHint(request, 'L', [href, as]);
+        }
+      }
+    }
+  }
+}
+
+function preloadModule$1(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'm|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'm', [href, trimmed]);
+        } else {
+          return emitHint(request, 'm', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'S|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'S', [href, typeof precedence === 'string' ? precedence : 0, trimmed]);
+        } else if (typeof precedence === 'string') {
+          return emitHint(request, 'S', [href, precedence]);
+        } else {
+          return emitHint(request, 'S', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'X|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'X', [href, trimmed]);
+        } else {
+          return emitHint(request, 'X', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitModuleScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'M|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'M', [href, trimmed]);
+        } else {
+          return emitHint(request, 'M', href);
+        }
+      }
+    }
+  }
+} // Flight normally encodes undefined as a special character however for directive option
+// arguments we don't want to send unnecessary keys and bloat the payload so we create a
+// trimmed object which omits any keys with null or undefined values.
+// This is only typesafe because these option objects have entirely optional fields where
+// null and undefined represent the same thing as no property.
+
+
+function trimOptions(options) {
+  if (options == null) return null;
+  let hasProperties = false;
+  const trimmed = {};
+
+  for (const key in options) {
+    if (options[key] != null) {
+      hasProperties = true;
+      trimmed[key] = options[key];
+    }
+  }
+
+  return hasProperties ? trimmed : null;
+}
+
+function getImagePreloadKey(href, imageSrcSet, imageSizes) {
+  let uniquePart = '';
+
+  if (typeof imageSrcSet === 'string' && imageSrcSet !== '') {
+    uniquePart += '[' + imageSrcSet + ']';
+
+    if (typeof imageSizes === 'string') {
+      uniquePart += '[' + imageSizes + ']';
+    }
+  } else {
+    uniquePart += '[][]' + href;
+  }
+
+  return "[image]" + uniquePart;
+}
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMFlightServerDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+// small, smaller than how we encode undefined, and is unambiguous. We could use
+// a different tuple structure to encode this instead but this makes the runtime
+// cost cheaper by eliminating a type checks in more positions.
+// prettier-ignore
+
+function createHints() {
+  return new Set();
+}
+
+const requestStorage = new async_hooks.AsyncLocalStorage();
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext); // On the way back, we push the new ones that weren't common.
+
+      pushNode(next);
+    }
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function pushProvider(context, nextValue) {
+  let prevValue;
+
+  {
+    prevValue = context._currentValue;
+    context._currentValue = nextValue;
+  }
+
+  const prevNode = currentActiveSnapshot;
+  const newNode = {
+    parent: prevNode,
+    depth: prevNode === null ? 0 : prevNode.depth + 1,
+    context: context,
+    parentValue: prevValue,
+    value: nextValue
+  };
+  currentActiveSnapshot = newNode;
+  return newNode;
+}
+function popProvider() {
+  const prevSnapshot = currentActiveSnapshot;
+
+  if (prevSnapshot === null) {
+    throw new Error('Tried to pop a Context at the root of the app. This is a bug in React.');
+  }
+
+  {
+    const value = prevSnapshot.parentValue;
+
+    if (value === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      prevSnapshot.context._currentValue = prevSnapshot.context._defaultValue;
+    } else {
+      prevSnapshot.context._currentValue = value;
+    }
+  }
+
+  return currentActiveSnapshot = prevSnapshot.parent;
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFizzWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop, noop);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+let currentRequest$1 = null;
+let thenableIndexCounter = 0;
+let thenableState = null;
+function prepareToUseHooksForRequest(request) {
+  currentRequest$1 = request;
+}
+function resetHooksForRequest() {
+  currentRequest$1 = null;
+}
+function prepareToUseHooksForComponent(prevThenableState) {
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+const HooksDispatcher = {
+  useMemo(nextCreate) {
+    return nextCreate();
+  },
+
+  useCallback(callback) {
+    return callback;
+  },
+
+  useDebugValue() {},
+
+  useDeferredValue: unsupportedHook,
+  useTransition: unsupportedHook,
+  readContext,
+  useContext: readContext,
+  useReducer: unsupportedHook,
+  useRef: unsupportedHook,
+  useState: unsupportedHook,
+  useInsertionEffect: unsupportedHook,
+  useLayoutEffect: unsupportedHook,
+  useImperativeHandle: unsupportedHook,
+  useEffect: unsupportedHook,
+  useId,
+  useSyncExternalStore: unsupportedHook,
+
+  useCacheRefresh() {
+    return unsupportedRefresh;
+  },
+
+  useMemoCache(size) {
+    const data = new Array(size);
+
+    for (let i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL;
+    }
+
+    return data;
+  },
+
+  use
+};
+
+function unsupportedHook() {
+  throw new Error('This Hook is not supported in Server Components.');
+}
+
+function unsupportedRefresh() {
+  throw new Error('Refreshing the cache is not supported in Server Components.');
+}
+
+function useId() {
+  if (currentRequest$1 === null) {
+    throw new Error('useId can only be used while React is rendering');
+  }
+
+  const id = currentRequest$1.identifierCount++; // use 'S' for Flight components to distinguish from 'R' and 'r' in Fizz/Client
+
+  return ':' + currentRequest$1.identifierPrefix + 'S' + id.toString(32) + ':';
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object' || typeof usable === 'function') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable; // Track the position of the thenable within this fiber.
+
+      const index = thenableIndexCounter;
+      thenableIndexCounter += 1;
+
+      if (thenableState === null) {
+        thenableState = createThenableState();
+      }
+
+      return trackUsedThenable(thenableState, thenable, index);
+    } else if (usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  }
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function createSignal() {
+  return new AbortController().signal;
+}
+
+function resolveCache() {
+  const request = resolveRequest();
+
+  if (request) {
+    return getCache(request);
+  }
+
+  return new Map();
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal() {
+    const cache = resolveCache();
+    let entry = cache.get(createSignal);
+
+    if (entry === undefined) {
+      entry = createSignal();
+      cache.set(createSignal, entry);
+    }
+
+    return entry;
+  },
+
+  getCacheForType(resourceType) {
+    const cache = resolveCache();
+    let entry = cache.get(resourceType);
+
+    if (entry === undefined) {
+      entry = resourceType(); // TODO: Warn if undefined?
+
+      cache.set(resourceType, entry);
+    }
+
+    return entry;
+  }
+
+};
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+function objectName(object) {
+  // $FlowFixMe[method-unbinding]
+  const name = Object.prototype.toString.call(object);
+  return name.replace(/^\[object (.*)\]$/, function (m, p0) {
+    return p0;
+  });
+}
+
+function describeKeyForErrorMessage(key) {
+  const encodedKey = JSON.stringify(key);
+  return '"' + key + '"' === encodedKey ? key : encodedKey;
+}
+
+function describeValueForErrorMessage(value) {
+  switch (typeof value) {
+    case 'string':
+      {
+        return JSON.stringify(value.length <= 10 ? value : value.slice(0, 10) + '...');
+      }
+
+    case 'object':
+      {
+        if (isArray(value)) {
+          return '[...]';
+        }
+
+        const name = objectName(value);
+
+        if (name === 'Object') {
+          return '{...}';
+        }
+
+        return name;
+      }
+
+    case 'function':
+      return 'function';
+
+    default:
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      return String(value);
+  }
+}
+
+function describeElementType(type) {
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        return describeElementType(type.render);
+
+      case REACT_MEMO_TYPE:
+        return describeElementType(type.type);
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            // Lazy may contain any component type so we recursively resolve it.
+            return describeElementType(init(payload));
+          } catch (x) {}
+        }
+    }
+  }
+
+  return '';
+}
+
+function describeObjectForErrorMessage(objectOrArray, expandedName) {
+  const objKind = objectName(objectOrArray);
+
+  if (objKind !== 'Object' && objKind !== 'Array') {
+    return objKind;
+  }
+
+  let str = '';
+  let start = -1;
+  let length = 0;
+
+  if (isArray(objectOrArray)) {
+    {
+      // Print Array
+      str = '[';
+      const array = objectOrArray;
+
+      for (let i = 0; i < array.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const value = array[i];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if ('' + i === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += ']';
+    }
+  } else {
+    if (objectOrArray.$$typeof === REACT_ELEMENT_TYPE) {
+      str = '<' + describeElementType(objectOrArray.type) + '/>';
+    } else {
+      // Print Object
+      str = '{';
+      const object = objectOrArray;
+      const names = Object.keys(object);
+
+      for (let i = 0; i < names.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const name = names[i];
+        str += describeKeyForErrorMessage(name) + ': ';
+        const value = object[name];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if (name === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += '}';
+    }
+  }
+
+  if (expandedName === undefined) {
+    return str;
+  }
+
+  if (start > -1 && length > 0) {
+    const highlight = ' '.repeat(start) + '^'.repeat(length);
+    return '\n  ' + str + '\n  ' + highlight;
+  }
+
+  return '\n  ' + str;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ReactSharedServerInternals = // $FlowFixMe: It's defined in the one we resolve to.
+React.__SECRET_SERVER_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+if (!ReactSharedServerInternals) {
+  throw new Error('The "react" package in this environment is not configured correctly. ' + 'The "react-server" condition must be enabled in any environment that ' + 'runs React Server Components.');
+}
+
+// Turns a TypedArray or ArrayBuffer into a string that can be used for comparison
+// in a Map to see if the bytes are the same.
+function binaryToComparableString(view) {
+  return String.fromCharCode.apply(String, new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+}
+
+const ObjectPrototype = Object.prototype;
+const stringify = JSON.stringify; // Serializable values
+// Thenable<ReactClientValue>
+
+const PENDING$1 = 0;
+const COMPLETED = 1;
+const ABORTED = 3;
+const ERRORED$1 = 4;
+const TaintRegistryObjects = ReactSharedServerInternals.TaintRegistryObjects,
+      TaintRegistryValues = ReactSharedServerInternals.TaintRegistryValues,
+      TaintRegistryByteLengths = ReactSharedServerInternals.TaintRegistryByteLengths,
+      TaintRegistryPendingRequests = ReactSharedServerInternals.TaintRegistryPendingRequests,
+      ReactCurrentCache = ReactSharedServerInternals.ReactCurrentCache;
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+
+function throwTaintViolation(message) {
+  // eslint-disable-next-line react-internal/prod-error-codes
+  throw new Error(message);
+}
+
+function cleanupTaintQueue(request) {
+  const cleanupQueue = request.taintCleanupQueue;
+  TaintRegistryPendingRequests.delete(cleanupQueue);
+
+  for (let i = 0; i < cleanupQueue.length; i++) {
+    const entryValue = cleanupQueue[i];
+    const entry = TaintRegistryValues.get(entryValue);
+
+    if (entry !== undefined) {
+      if (entry.count === 1) {
+        TaintRegistryValues.delete(entryValue);
+      } else {
+        entry.count--;
+      }
+    }
+  }
+
+  cleanupQueue.length = 0;
+}
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+}
+
+function defaultPostponeHandler(reason) {// Noop
+}
+
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2;
+function createRequest(model, bundlerConfig, onError, context, identifierPrefix, onPostpone) {
+  if (ReactCurrentCache.current !== null && ReactCurrentCache.current !== DefaultCacheDispatcher) {
+    throw new Error('Currently React only supports one RSC renderer at a time.');
+  }
+
+  prepareHostDispatcher();
+  ReactCurrentCache.current = DefaultCacheDispatcher;
+  const abortSet = new Set();
+  const pingedTasks = [];
+  const cleanupQueue = [];
+
+  {
+    TaintRegistryPendingRequests.add(cleanupQueue);
+  }
+
+  const hints = createHints();
+  const request = {
+    status: OPEN,
+    flushScheduled: false,
+    fatalError: null,
+    destination: null,
+    bundlerConfig,
+    cache: new Map(),
+    nextChunkId: 0,
+    pendingChunks: 0,
+    hints,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    completedImportChunks: [],
+    completedHintChunks: [],
+    completedRegularChunks: [],
+    completedErrorChunks: [],
+    writtenSymbols: new Map(),
+    writtenClientReferences: new Map(),
+    writtenServerReferences: new Map(),
+    writtenProviders: new Map(),
+    writtenObjects: new WeakMap(),
+    identifierPrefix: identifierPrefix || '',
+    identifierCount: 1,
+    taintCleanupQueue: cleanupQueue,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? defaultPostponeHandler : onPostpone,
+    // $FlowFixMe[missing-this-annot]
+    toJSON: function (key, value) {
+      return resolveModelToJSON(request, this, key, value);
+    }
+  };
+  request.pendingChunks++;
+  const rootContext = createRootContext(context);
+  const rootTask = createTask(request, model, rootContext, abortSet);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  {
+    const store = requestStorage.getStore();
+    if (store) return store;
+  }
+
+  return null;
+}
+
+function createRootContext(reqContext) {
+  return importServerContexts(reqContext);
+}
+
+const POP = {};
+
+function serializeThenable(request, thenable) {
+  request.pendingChunks++;
+  const newTask = createTask(request, null, getActiveContext(), request.abortableTasks);
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        // We have the resolved value, we can go ahead and schedule it for serialization.
+        newTask.model = thenable.value;
+        pingTask(request, newTask);
+        return newTask.id;
+      }
+
+    case 'rejected':
+      {
+        const x = thenable.reason;
+
+        if (typeof x === 'object' && x !== null && x.$$typeof === REACT_POSTPONE_TYPE) {
+          const postponeInstance = x;
+          logPostpone(request, postponeInstance.message);
+          emitPostponeChunk(request, newTask.id);
+        } else {
+          const digest = logRecoverableError(request, x);
+          emitErrorChunk(request, newTask.id, digest);
+        }
+
+        return newTask.id;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  thenable.then(value => {
+    newTask.model = value;
+    pingTask(request, newTask);
+  }, reason => {
+    newTask.status = ERRORED$1;
+    request.abortableTasks.delete(newTask); // TODO: We should ideally do this inside performWork so it's scheduled
+
+    const digest = logRecoverableError(request, reason);
+    emitErrorChunk(request, newTask.id, digest);
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  });
+  return newTask.id;
+}
+
+function emitHint(request, code, model) {
+  emitHintChunk(request, code, model);
+  enqueueFlush(request);
+}
+function getHints(request) {
+  return request.hints;
+}
+function getCache(request) {
+  return request.cache;
+}
+
+function readThenable(thenable) {
+  if (thenable.status === 'fulfilled') {
+    return thenable.value;
+  } else if (thenable.status === 'rejected') {
+    throw thenable.reason;
+  }
+
+  throw thenable;
+}
+
+function createLazyWrapperAroundWakeable(wakeable) {
+  // This is a temporary fork of the `use` implementation until we accept
+  // promises everywhere.
+  const thenable = wakeable;
+
+  switch (thenable.status) {
+    case 'fulfilled':
+    case 'rejected':
+      break;
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: thenable,
+    _init: readThenable
+  };
+  return lazyType;
+}
+
+function attemptResolveElement(request, type, key, ref, props, prevThenableState) {
+  if (ref !== null && ref !== undefined) {
+    // When the ref moves to the regular props object this will implicitly
+    // throw for functions. We could probably relax it to a DEV warning for other
+    // cases.
+    throw new Error('Refs cannot be used in Server Components, nor passed to Client Components.');
+  }
+
+  if (typeof type === 'function') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    } // This is a server-side component.
+
+
+    prepareToUseHooksForComponent(prevThenableState);
+    const result = type(props);
+
+    if (typeof result === 'object' && result !== null && typeof result.then === 'function') {
+      // When the return value is in children position we can resolve it immediately,
+      // to its value without a wrapper if it's synchronously available.
+      const thenable = result;
+
+      if (thenable.status === 'fulfilled') {
+        return thenable.value;
+      } // TODO: Once we accept Promises as children on the client, we can just return
+      // the thenable here.
+
+
+      return createLazyWrapperAroundWakeable(result);
+    }
+
+    return result;
+  } else if (typeof type === 'string') {
+    // This is a host element. E.g. HTML.
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (typeof type === 'symbol') {
+    if (type === REACT_FRAGMENT_TYPE) {
+      // For key-less fragments, we add a small optimization to avoid serializing
+      // it as a wrapper.
+      // TODO: If a key is specified, we should propagate its key to any children.
+      // Same as if a Server Component has a key.
+      return props.children;
+    } // This might be a built-in React component. We'll let the client decide.
+    // Any built-in works as long as its props are serializable.
+
+
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (type != null && typeof type === 'object') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    }
+
+    switch (type.$$typeof) {
+      case REACT_LAZY_TYPE:
+        {
+          const payload = type._payload;
+          const init = type._init;
+          const wrappedType = init(payload);
+          return attemptResolveElement(request, wrappedType, key, ref, props, prevThenableState);
+        }
+
+      case REACT_FORWARD_REF_TYPE:
+        {
+          const render = type.render;
+          prepareToUseHooksForComponent(prevThenableState);
+          return render(props, undefined);
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          return attemptResolveElement(request, type.type, key, ref, props, prevThenableState);
+        }
+
+      case REACT_PROVIDER_TYPE:
+        {
+          {
+            pushProvider(type._context, props.value);
+
+            return [REACT_ELEMENT_TYPE, type, key, // Rely on __popProvider being serialized last to pop the provider.
+            {
+              value: props.value,
+              children: props.children,
+              __pop: POP
+            }];
+          } // Fallthrough
+
+        }
+    }
+  }
+
+  throw new Error("Unsupported Server Component type: " + describeValueForErrorMessage(type));
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createTask(request, model, context, abortSet) {
+  const id = request.nextChunkId++;
+  const task = {
+    id,
+    status: PENDING$1,
+    model,
+    context,
+    ping: () => pingTask(request, task),
+    thenableState: null
+  };
+  abortSet.add(task);
+  return task;
+}
+
+function serializeByValueID(id) {
+  return '$' + id.toString(16);
+}
+
+function serializeLazyID(id) {
+  return '$L' + id.toString(16);
+}
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeProviderReference(name) {
+  return '$P' + name;
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeRowHeader(tag, id) {
+  return id.toString(16) + ':' + tag;
+}
+
+function encodeReferenceChunk(request, id, reference) {
+  const json = stringify(reference);
+  const row = id.toString(16) + ':' + json + '\n';
+  return stringToChunk(row);
+}
+
+function serializeClientReference(request, parent, key, clientReference) {
+  const clientReferenceKey = getClientReferenceKey(clientReference);
+  const writtenClientReferences = request.writtenClientReferences;
+  const existingId = writtenClientReferences.get(clientReferenceKey);
+
+  if (existingId !== undefined) {
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(existingId);
+    }
+
+    return serializeByValueID(existingId);
+  }
+
+  try {
+    const clientReferenceMetadata = resolveClientReferenceMetadata(request.bundlerConfig, clientReference);
+    request.pendingChunks++;
+    const importId = request.nextChunkId++;
+    emitImportChunk(request, importId, clientReferenceMetadata);
+    writtenClientReferences.set(clientReferenceKey, importId);
+
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(importId);
+    }
+
+    return serializeByValueID(importId);
+  } catch (x) {
+    request.pendingChunks++;
+    const errorId = request.nextChunkId++;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, errorId, digest);
+    return serializeByValueID(errorId);
+  }
+}
+
+function outlineModel(request, value) {
+  request.pendingChunks++;
+  const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+  retryTask(request, newTask);
+  return newTask.id;
+}
+
+function serializeServerReference(request, parent, key, serverReference) {
+  const writtenServerReferences = request.writtenServerReferences;
+  const existingId = writtenServerReferences.get(serverReference);
+
+  if (existingId !== undefined) {
+    return serializeServerReferenceID(existingId);
+  }
+
+  const bound = getServerReferenceBoundArguments(request.bundlerConfig, serverReference);
+  const serverReferenceMetadata = {
+    id: getServerReferenceId(request.bundlerConfig, serverReference),
+    bound: bound ? Promise.resolve(bound) : null
+  };
+  const metadataId = outlineModel(request, serverReferenceMetadata);
+  writtenServerReferences.set(serverReference, metadataId);
+  return serializeServerReferenceID(metadataId);
+}
+
+function serializeLargeTextString(request, text) {
+  request.pendingChunks += 2;
+  const textId = request.nextChunkId++;
+  const textChunk = stringToChunk(text);
+  const binaryLength = byteLengthOfChunk(textChunk);
+  const row = textId.toString(16) + ':T' + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, textChunk);
+  return serializeByValueID(textId);
+}
+
+function serializeMap(request, map) {
+  const entries = Array.from(map);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i][0];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$Q' + id.toString(16);
+}
+
+function serializeSet(request, set) {
+  const entries = Array.from(set);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$W' + id.toString(16);
+}
+
+function serializeTypedArray(request, tag, typedArray) {
+  {
+    if (TaintRegistryByteLengths.has(typedArray.byteLength)) {
+      // If we have had any tainted values of this length, we check
+      // to see if these bytes matches any entries in the registry.
+      const tainted = TaintRegistryValues.get(binaryToComparableString(typedArray));
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    }
+  }
+
+  request.pendingChunks += 2;
+  const bufferId = request.nextChunkId++; // TODO: Convert to little endian if that's not the server default.
+
+  const binaryChunk = typedArrayToBinaryChunk(typedArray);
+  const binaryLength = byteLengthOfBinaryChunk(binaryChunk);
+  const row = bufferId.toString(16) + ':' + tag + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, binaryChunk);
+  return serializeByValueID(bufferId);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+let modelRoot = false;
+
+function resolveModelToJSON(request, parent, key, value) {
+
+
+  switch (value) {
+    case REACT_ELEMENT_TYPE:
+      return '$';
+  }
+
+
+  while (typeof value === 'object' && value !== null && (value.$$typeof === REACT_ELEMENT_TYPE || value.$$typeof === REACT_LAZY_TYPE)) {
+
+    try {
+      switch (value.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const writtenObjects = request.writtenObjects;
+            const existingId = writtenObjects.get(value);
+
+            if (existingId !== undefined) {
+              if (existingId === -1) {
+                // Seen but not yet outlined.
+                const newId = outlineModel(request, value);
+                return serializeByValueID(newId);
+              } else if (modelRoot === value) {
+                // This is the ID we're currently emitting so we need to write it
+                // once but if we discover it again, we refer to it by id.
+                modelRoot = null;
+              } else {
+                // We've already emitted this as an outlined object, so we can
+                // just refer to that by its existing ID.
+                return serializeByValueID(existingId);
+              }
+            } else {
+              // This is the first time we've seen this object. We may never see it again
+              // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+              writtenObjects.set(value, -1);
+            } // TODO: Concatenate keys of parents onto children.
+
+
+            const element = value; // Attempt to render the Server Component.
+
+            value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, null);
+            break;
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = value._payload;
+            const init = value._init;
+            value = init(payload);
+            break;
+          }
+      }
+    } catch (thrownValue) {
+      const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          // Something suspended, we'll need to create a new task and resolve it later.
+          request.pendingChunks++;
+          const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+          const ping = newTask.ping;
+          x.then(ping, ping);
+          newTask.thenableState = getThenableStateAfterSuspending();
+          return serializeLazyID(newTask.id);
+        } else if (x.$$typeof === REACT_POSTPONE_TYPE) {
+          // Something postponed. We'll still send everything we have up until this point.
+          // We'll replace this element with a lazy reference that postpones on the client.
+          const postponeInstance = x;
+          request.pendingChunks++;
+          const postponeId = request.nextChunkId++;
+          logPostpone(request, postponeInstance.message);
+          emitPostponeChunk(request, postponeId);
+          return serializeLazyID(postponeId);
+        }
+      } // Something errored. We'll still send everything we have up until this point.
+      // We'll replace this element with a lazy reference that throws on the client
+      // once it gets rendered.
+
+
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+      const digest = logRecoverableError(request, x);
+      emitErrorChunk(request, errorId, digest);
+      return serializeLazyID(errorId);
+    }
+  }
+
+  if (value === null) {
+    return null;
+  }
+
+  if (typeof value === 'object') {
+    {
+      const tainted = TaintRegistryObjects.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted);
+      }
+    }
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    const writtenObjects = request.writtenObjects;
+    const existingId = writtenObjects.get(value); // $FlowFixMe[method-unbinding]
+
+    if (typeof value.then === 'function') {
+      if (existingId !== undefined) {
+        if (modelRoot === value) {
+          // This is the ID we're currently emitting so we need to write it
+          // once but if we discover it again, we refer to it by id.
+          modelRoot = null;
+        } else {
+          // We've seen this promise before, so we can just refer to the same result.
+          return serializePromiseID(existingId);
+        }
+      } // We assume that any object with a .then property is a "Thenable" type,
+      // or a Promise type. Either of which can be represented by a Promise.
+
+
+      const promiseId = serializeThenable(request, value);
+      writtenObjects.set(value, promiseId);
+      return serializePromiseID(promiseId);
+    }
+
+    {
+      if (value.$$typeof === REACT_PROVIDER_TYPE) {
+        const providerKey = value._context._globalName;
+        const writtenProviders = request.writtenProviders;
+        let providerId = writtenProviders.get(key);
+
+        if (providerId === undefined) {
+          request.pendingChunks++;
+          providerId = request.nextChunkId++;
+          writtenProviders.set(providerKey, providerId);
+          emitProviderChunk(request, providerId, providerKey);
+        }
+
+        return serializeByValueID(providerId);
+      } else if (value === POP) {
+        popProvider();
+
+        return undefined;
+      }
+    }
+
+    if (existingId !== undefined) {
+      if (existingId === -1) {
+        // Seen but not yet outlined.
+        const newId = outlineModel(request, value);
+        return serializeByValueID(newId);
+      } else if (modelRoot === value) {
+        // This is the ID we're currently emitting so we need to write it
+        // once but if we discover it again, we refer to it by id.
+        modelRoot = null;
+      } else {
+        // We've already emitted this as an outlined object, so we can
+        // just refer to that by its existing ID.
+        return serializeByValueID(existingId);
+      }
+    } else {
+      // This is the first time we've seen this object. We may never see it again
+      // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+      writtenObjects.set(value, -1);
+    }
+
+    if (isArray(value)) {
+      // $FlowFixMe[incompatible-return]
+      return value;
+    }
+
+    if (value instanceof Map) {
+      return serializeMap(request, value);
+    }
+
+    if (value instanceof Set) {
+      return serializeSet(request, value);
+    }
+
+    {
+      if (value instanceof ArrayBuffer) {
+        return serializeTypedArray(request, 'A', new Uint8Array(value));
+      }
+
+      if (value instanceof Int8Array) {
+        // char
+        return serializeTypedArray(request, 'C', value);
+      }
+
+      if (value instanceof Uint8Array) {
+        // unsigned char
+        return serializeTypedArray(request, 'c', value);
+      }
+
+      if (value instanceof Uint8ClampedArray) {
+        // unsigned clamped char
+        return serializeTypedArray(request, 'U', value);
+      }
+
+      if (value instanceof Int16Array) {
+        // sort
+        return serializeTypedArray(request, 'S', value);
+      }
+
+      if (value instanceof Uint16Array) {
+        // unsigned short
+        return serializeTypedArray(request, 's', value);
+      }
+
+      if (value instanceof Int32Array) {
+        // long
+        return serializeTypedArray(request, 'L', value);
+      }
+
+      if (value instanceof Uint32Array) {
+        // unsigned long
+        return serializeTypedArray(request, 'l', value);
+      }
+
+      if (value instanceof Float32Array) {
+        // float
+        return serializeTypedArray(request, 'F', value);
+      }
+
+      if (value instanceof Float64Array) {
+        // double
+        return serializeTypedArray(request, 'D', value);
+      }
+
+      if (value instanceof BigInt64Array) {
+        // number
+        return serializeTypedArray(request, 'N', value);
+      }
+
+      if (value instanceof BigUint64Array) {
+        // unsigned number
+        // We use "m" instead of "n" since JSON can start with "null"
+        return serializeTypedArray(request, 'm', value);
+      }
+
+      if (value instanceof DataView) {
+        return serializeTypedArray(request, 'V', value);
+      }
+    }
+
+    const iteratorFn = getIteratorFn(value);
+
+    if (iteratorFn) {
+      return Array.from(value);
+    } // Verify that this is a simple plain object.
+
+
+    const proto = getPrototypeOf(value);
+
+    if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+      throw new Error('Only plain objects, and a few built-ins, can be passed to Client Components ' + 'from Server Components. Classes or null prototypes are not supported.');
+    }
+
+
+    return value;
+  }
+
+  if (typeof value === 'string') {
+    {
+      const tainted = TaintRegistryValues.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    } // TODO: Maybe too clever. If we support URL there's no similar trick.
+
+
+    if (value[value.length - 1] === 'Z') {
+      // Possibly a Date, whose toJSON automatically calls toISOString
+      // $FlowFixMe[incompatible-use]
+      const originalValue = parent[key];
+
+      if (originalValue instanceof Date) {
+        return serializeDateFromDateJSON(value);
+      }
+    }
+
+    if (value.length >= 1024) {
+      // For large strings, we encode them outside the JSON payload so that we
+      // don't have to double encode and double parse the strings. This can also
+      // be more compact in case the string has a lot of escaped characters.
+      return serializeLargeTextString(request, value);
+    }
+
+    return escapeStringValue(value);
+  }
+
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  if (typeof value === 'number') {
+    return serializeNumber(value);
+  }
+
+  if (typeof value === 'undefined') {
+    return serializeUndefined();
+  }
+
+  if (typeof value === 'function') {
+    {
+      const tainted = TaintRegistryObjects.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted);
+      }
+    }
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    if (isServerReference(value)) {
+      return serializeServerReference(request, parent, key, value);
+    }
+
+    if (/^on[A-Z]/.test(key)) {
+      throw new Error('Event handlers cannot be passed to Client Component props.' + describeObjectForErrorMessage(parent, key) + '\nIf you need interactivity, consider converting part of this to a Client Component.');
+    } else {
+      throw new Error('Functions cannot be passed directly to Client Components ' + 'unless you explicitly expose it by marking it with "use server".' + describeObjectForErrorMessage(parent, key));
+    }
+  }
+
+  if (typeof value === 'symbol') {
+    const writtenSymbols = request.writtenSymbols;
+    const existingId = writtenSymbols.get(value);
+
+    if (existingId !== undefined) {
+      return serializeByValueID(existingId);
+    } // $FlowFixMe[incompatible-type] `description` might be undefined
+
+
+    const name = value.description;
+
+    if (Symbol.for(name) !== value) {
+      throw new Error('Only global symbols received from Symbol.for(...) can be passed to Client Components. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+      value.description + ") cannot be found among global symbols.") + describeObjectForErrorMessage(parent, key));
+    }
+
+    request.pendingChunks++;
+    const symbolId = request.nextChunkId++;
+    emitSymbolChunk(request, symbolId, name);
+    writtenSymbols.set(value, symbolId);
+    return serializeByValueID(symbolId);
+  }
+
+  if (typeof value === 'bigint') {
+    {
+      const tainted = TaintRegistryValues.get(value);
+
+      if (tainted !== undefined) {
+        throwTaintViolation(tainted.message);
+      }
+    }
+
+    return serializeBigInt(value);
+  }
+
+  throw new Error("Type " + typeof value + " is not supported in Client Component props." + describeObjectForErrorMessage(parent, key));
+}
+
+function logPostpone(request, reason) {
+  const onPostpone = request.onPostpone;
+  onPostpone(reason);
+}
+
+function logRecoverableError(request, error) {
+  const onError = request.onError;
+  const errorDigest = onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest || '';
+}
+
+function fatalError(request, error) {
+  {
+    cleanupTaintQueue(request);
+  } // This is called outside error handling code such as if an error happens in React internals.
+
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function emitPostponeChunk(request, id, postponeInstance) {
+  let row;
+
+  {
+    // No reason included in prod.
+    row = serializeRowHeader('P', id) + '\n';
+  }
+
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitErrorChunk(request, id, digest, error) {
+  let errorInfo;
+
+  {
+    errorInfo = {
+      digest
+    };
+  }
+
+  const row = serializeRowHeader('E', id) + stringify(errorInfo) + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitImportChunk(request, id, clientReferenceMetadata) {
+  // $FlowFixMe[incompatible-type] stringify can return null
+  const json = stringify(clientReferenceMetadata);
+  const row = serializeRowHeader('I', id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitHintChunk(request, code, model) {
+  const json = stringify(model);
+  const id = request.nextChunkId++;
+  const row = serializeRowHeader('H' + code, id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedHintChunks.push(processedChunk);
+}
+
+function emitSymbolChunk(request, id, name) {
+  const symbolReference = serializeSymbolReference(name);
+  const processedChunk = encodeReferenceChunk(request, id, symbolReference);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitProviderChunk(request, id, contextName) {
+  const contextReference = serializeProviderReference(contextName);
+  const processedChunk = encodeReferenceChunk(request, id, contextReference);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function emitModelChunk(request, id, model) {
+  // Track the root so we know that we have to emit this object even though it
+  // already has an ID. This is needed because we might see this object twice
+  // in the same toJSON if it is cyclic.
+  modelRoot = model; // $FlowFixMe[incompatible-type] stringify can return null
+
+  const json = stringify(model, request.toJSON);
+  const row = id.toString(16) + ':' + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function retryTask(request, task) {
+  if (task.status !== PENDING$1) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  }
+
+  switchContext(task.context);
+
+  try {
+    let value = task.model;
+
+    if (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+      request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+      const element = value; // When retrying a component, reuse the thenableState from the
+      // previous attempt.
+
+      const prevThenableState = task.thenableState; // Attempt to render the Server Component.
+      // Doing this here lets us reuse this same task if the next component
+      // also suspends.
+
+      task.model = value;
+      value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, prevThenableState); // Successfully finished this component. We're going to keep rendering
+      // using the same task, but we reset its thenable state before continuing.
+
+      task.thenableState = null; // Keep rendering and reuse the same task. This inner loop is separate
+      // from the render above because we don't need to reset the thenable state
+      // until the next time something suspends and retries.
+
+      while (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+        request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+        const nextElement = value;
+        task.model = value;
+        value = attemptResolveElement(request, nextElement.type, nextElement.key, nextElement.ref, nextElement.props, null);
+      }
+    } // Track that this object is outlined and has an id.
+
+
+    if (typeof value === 'object' && value !== null) {
+      request.writtenObjects.set(value, task.id);
+    }
+
+    emitModelChunk(request, task.id, value);
+    request.abortableTasks.delete(task);
+    task.status = COMPLETED;
+  } catch (thrownValue) {
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      } else if (x.$$typeof === REACT_POSTPONE_TYPE) {
+        request.abortableTasks.delete(task);
+        task.status = ERRORED$1;
+        const postponeInstance = x;
+        logPostpone(request, postponeInstance.message);
+        emitPostponeChunk(request, task.id);
+        return;
+      }
+    }
+
+    request.abortableTasks.delete(task);
+    task.status = ERRORED$1;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, task.id, digest);
+  }
+}
+
+function performWork(request) {
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  const prevRequest = currentRequest;
+  currentRequest = request;
+  prepareToUseHooksForRequest(request);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    request.pingedTasks = [];
+
+    for (let i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    ReactCurrentDispatcher.current = prevDispatcher;
+    resetHooksForRequest();
+    currentRequest = prevRequest;
+  }
+}
+
+function abortTask(task, request, errorId) {
+  task.status = ABORTED; // Instead of emitting an error per task.id, we emit a model that only
+  // has a single value referencing the error.
+
+  const ref = serializeByValueID(errorId);
+  const processedChunk = encodeReferenceChunk(request, task.id, ref);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function flushCompletedChunks(request, destination) {
+  beginWriting();
+
+  try {
+    // We emit module chunks first in the stream so that
+    // they can be preloaded as early as possible.
+    const importsChunks = request.completedImportChunks;
+    let i = 0;
+
+    for (; i < importsChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = importsChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    importsChunks.splice(0, i); // Next comes hints.
+
+    const hintChunks = request.completedHintChunks;
+    i = 0;
+
+    for (; i < hintChunks.length; i++) {
+      const chunk = hintChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    hintChunks.splice(0, i); // Next comes model data.
+
+    const regularChunks = request.completedRegularChunks;
+    i = 0;
+
+    for (; i < regularChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = regularChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    regularChunks.splice(0, i); // Finally, errors are sent. The idea is that it's ok to delay
+    // any error messages and prioritize display of other parts of
+    // the page.
+
+    const errorChunks = request.completedErrorChunks;
+    i = 0;
+
+    for (; i < errorChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = errorChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    errorChunks.splice(0, i);
+  } finally {
+    request.flushScheduled = false;
+    completeWriting(destination);
+  }
+
+  flushBuffered(destination);
+
+  if (request.pendingChunks === 0) {
+    // We're done.
+    {
+      cleanupTaintQueue(request);
+    }
+
+    close$1(destination);
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  {
+    scheduleWork(() => requestStorage.run(request, performWork, request));
+  }
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    const destination = request.destination;
+    request.flushScheduled = true;
+    scheduleWork(() => flushCompletedChunks(request, destination));
+  }
+}
+
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedChunks(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function stopFlowing(request) {
+  request.destination = null;
+} // This is called to early terminate a request. It creates an error at all pending tasks.
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      // We have tasks to abort. We'll emit one error row and then emit a reference
+      // to that row from every row that's still remaining.
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+
+      if (enablePostpone && typeof reason === 'object' && reason !== null && reason.$$typeof === REACT_POSTPONE_TYPE) {
+        const postponeInstance = reason;
+        logPostpone(request, postponeInstance.message);
+        emitPostponeChunk(request, errorId, postponeInstance);
+      } else {
+        const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+        const digest = logRecoverableError(request, error);
+        emitErrorChunk(request, errorId, digest, error);
+      }
+
+      abortableTasks.forEach(task => abortTask(task, request, errorId));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function importServerContexts(contexts) {
+  if (contexts) {
+    const prevContext = getActiveContext();
+    switchContext(rootContextSnapshot);
+
+    for (let i = 0; i < contexts.length; i++) {
+      const _contexts$i = contexts[i],
+            name = _contexts$i[0],
+            value = _contexts$i[1];
+      const context = getOrCreateServerContext(name);
+      pushProvider(context, value);
+    }
+
+    const importedContext = getActiveContext();
+    switchContext(prevContext);
+    return importedContext;
+  }
+
+  return rootContextSnapshot;
+}
+
+function resolveServerReference(bundlerConfig, id) {
+  const idx = id.lastIndexOf('#');
+  const specifier = id.slice(0, idx);
+  const name = id.slice(idx + 1);
+  return {
+    specifier,
+    name
+  };
+}
+const asyncModuleCache = new Map();
+function preloadModule(metadata) {
+  const existingPromise = asyncModuleCache.get(metadata.specifier);
+
+  if (existingPromise) {
+    if (existingPromise.status === 'fulfilled') {
+      return null;
+    }
+
+    return existingPromise;
+  } else {
+    // $FlowFixMe[unsupported-syntax]
+    let modulePromise = import(metadata.specifier);
+
+    if (metadata.async) {
+      // If the module is async, it must have been a CJS module.
+      // CJS modules are accessed through the default export in
+      // Node.js so we have to get the default export to get the
+      // full module exports.
+      modulePromise = modulePromise.then(function (value) {
+        return value.default;
+      });
+    }
+
+    modulePromise.then(value => {
+      const fulfilledThenable = modulePromise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = modulePromise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    asyncModuleCache.set(metadata.specifier, modulePromise);
+    return modulePromise;
+  }
+}
+function requireModule(metadata) {
+  let moduleExports; // We assume that preloadModule has been called before, which
+  // should have added something to the module cache.
+
+  const promise = asyncModuleCache.get(metadata.specifier);
+
+  if (promise.status === 'fulfilled') {
+    moduleExports = promise.value;
+  } else {
+    throw promise.reason;
+  }
+
+  if (metadata.name === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata.name === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.default;
+  }
+
+  return moduleExports[metadata.name];
+}
+
+// The server acts as a Client of itself when resolving Server References.
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const RESOLVED_MODEL = 'resolved_model';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function bindArgs$1(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference$1(response, id, bound, parentChunk, parentObject, key) {
+  const serverReference = resolveServerReference(response._bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+  let promise;
+
+  if (bound) {
+    promise = Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs$1(requireModule(serverReference), args);
+    });
+  } else {
+    if (preloadPromise) {
+      promise = Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+    } else {
+      // Synchronously available
+      return requireModule(serverReference);
+    }
+  }
+
+  promise.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk)); // We need a placeholder value that will be replaced later.
+
+  return null;
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+
+  try {
+    const value = JSON.parse(chunk.value, chunk._response._fromJSON);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    const prefix = response._prefix;
+    const key = prefix + id; // Check if we have this field in the backing store already.
+
+    const backingEntry = response._formData.get(key);
+
+    if (backingEntry != null) {
+      // We assume that this is a string entry for now.
+      chunk = createResolvedModelChunk(response, backingEntry);
+    } else {
+      // We're still waiting on this entry to stream in.
+      chunk = createPendingChunk(response);
+    }
+
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+    blocked.deps++;
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  if (chunk.status === RESOLVED_MODEL) {
+    initializeModelChunk(chunk);
+  }
+
+  if (chunk.status !== INITIALIZED) {
+    // We know that this is emitted earlier so otherwise it's an error.
+    throw chunk.reason;
+  }
+
+  return chunk.value;
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16); // TODO: Just encode this in the reference inline instead of as a model.
+
+          const metaData = getOutlinedModel(response, id);
+          return loadServerReference$1(response, metaData.id, metaData.bound, initializingChunk, parentObject, key);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'K':
+        {
+          // FormData
+          const stringId = value.slice(2);
+          const formPrefix = response._prefix + stringId + '_';
+          const data = new FormData();
+          const backingFormData = response._formData; // We assume that the reference to FormData always comes after each
+          // entry that it references so we can assume they all exist in the
+          // backing store already.
+          // $FlowFixMe[prop-missing] FormData has forEach on it.
+
+          backingFormData.forEach((entry, entryKey) => {
+            if (entryKey.startsWith(formPrefix)) {
+              data.append(entryKey.slice(formPrefix.length), entry);
+            }
+          });
+          return data;
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function createResponse(bundlerConfig, formFieldPrefix) {
+  let backingFormData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new FormData();
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _prefix: formFieldPrefix,
+    _formData: backingFormData,
+    _chunks: chunks,
+    _fromJSON: function (key, value) {
+      if (typeof value === 'string') {
+        // We can't use .bind here because we need the "this" value.
+        return parseModelString(response, this, key, value);
+      }
+
+      return value;
+    }
+  };
+  return response;
+}
+function resolveField(response, key, value) {
+  // Add this field to the backing store.
+  response._formData.append(key, value);
+
+  const prefix = response._prefix;
+
+  if (key.startsWith(prefix)) {
+    const chunks = response._chunks;
+    const id = +key.slice(prefix.length);
+    const chunk = chunks.get(id);
+
+    if (chunk) {
+      // We were waiting on this key so now we can resolve it.
+      resolveModelChunk(chunk, value);
+    }
+  }
+}
+function resolveFileInfo(response, key, filename, mime) {
+  return {
+    chunks: [],
+    filename,
+    mime
+  };
+}
+function resolveFileChunk(response, handle, chunk) {
+  handle.chunks.push(chunk);
+}
+function resolveFileComplete(response, key, handle) {
+  // Add this file to the backing store.
+  // Node.js doesn't expose a global File constructor so we need to use
+  // the append() form that takes the file name as the third argument,
+  // to create a File object.
+  const blob = new Blob(handle.chunks, {
+    type: handle.mime
+  });
+
+  response._formData.append(key, blob, handle.filename);
+}
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function bindArgs(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference(bundlerConfig, id, bound) {
+  const serverReference = resolveServerReference(bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+
+  if (bound) {
+    return Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs(requireModule(serverReference), args);
+    });
+  } else if (preloadPromise) {
+    return Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+  } else {
+    // Synchronously available
+    return Promise.resolve(requireModule(serverReference));
+  }
+}
+
+function decodeBoundActionMetaData(body, serverManifest, formFieldPrefix) {
+  // The data for this reference is encoded in multiple fields under this prefix.
+  const actionResponse = createResponse(serverManifest, formFieldPrefix, body);
+  close(actionResponse);
+  const refPromise = getRoot(actionResponse); // Force it to initialize
+  // $FlowFixMe
+
+  refPromise.then(() => {});
+
+  if (refPromise.status !== 'fulfilled') {
+    // $FlowFixMe
+    throw refPromise.reason;
+  }
+
+  return refPromise.value;
+}
+
+function decodeAction(body, serverManifest) {
+  // We're going to create a new formData object that holds all the fields except
+  // the implementation details of the action data.
+  const formData = new FormData();
+  let action = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (!key.startsWith('$ACTION_')) {
+      formData.append(key, value);
+      return;
+    } // Later actions may override earlier actions if a button is used to override the default
+    // form action.
+
+
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      const metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+      action = loadServerReference(serverManifest, metaData.id, metaData.bound);
+      return;
+    }
+
+    if (key.startsWith('$ACTION_ID_')) {
+      const id = key.slice(11);
+      action = loadServerReference(serverManifest, id, null);
+      return;
+    }
+  });
+
+  if (action === null) {
+    return null;
+  } // Return the action with the remaining FormData bound to the first argument.
+
+
+  return action.then(fn => fn.bind(null, formData));
+}
+function decodeFormState(actionResult, body, serverManifest) {
+  const keyPath = body.get('$ACTION_KEY');
+
+  if (typeof keyPath !== 'string') {
+    // This form submission did not include any form state.
+    return Promise.resolve(null);
+  } // Search through the form data object to get the reference id and the number
+  // of bound arguments. This repeats some of the work done in decodeAction.
+
+
+  let metaData = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+    } // We don't check for the simple $ACTION_ID_ case because form state actions
+    // are always bound to the state argument.
+
+  });
+
+  if (metaData === null) {
+    // Should be unreachable.
+    return Promise.resolve(null);
+  }
+
+  const referenceId = metaData.id;
+  return Promise.resolve(metaData.bound).then(bound => {
+    if (bound === null) {
+      // Should be unreachable because form state actions are always bound to the
+      // state argument.
+      return null;
+    } // The form action dispatch method is always bound to the initial state.
+    // But when comparing signatures, we compare to the original unbound action.
+    // Subtract one from the arity to account for this.
+
+
+    const boundArity = bound.length - 1;
+    return [actionResult, keyPath, referenceId, boundArity];
+  });
+}
+
+function createDrainHandler(destination, request) {
+  return () => startFlowing(request, destination);
+}
+
+function createCancelHandler(request, reason) {
+  return () => {
+    stopFlowing(request); // eslint-disable-next-line react-internal/prod-error-codes
+
+    abort(request, new Error(reason));
+  };
+}
+
+function renderToPipeableStream(model, webpackMap, options) {
+  const request = createRequest(model, webpackMap, options ? options.onError : undefined, options ? options.context : undefined, options ? options.identifierPrefix : undefined, options ? options.onPostpone : undefined);
+  let hasStartedFlowing = false;
+  startWork(request);
+  return {
+    pipe(destination) {
+      if (hasStartedFlowing) {
+        throw new Error('React currently only supports piping to one writable stream.');
+      }
+
+      hasStartedFlowing = true;
+      startFlowing(request, destination);
+      destination.on('drain', createDrainHandler(destination, request));
+      destination.on('error', createCancelHandler(request, 'The destination stream errored while writing data.'));
+      destination.on('close', createCancelHandler(request, 'The destination stream closed early.'));
+      return destination;
+    },
+
+    abort(reason) {
+      abort(request, reason);
+    }
+
+  };
+}
+
+function decodeReplyFromBusboy(busboyStream, webpackMap) {
+  const response = createResponse(webpackMap, '');
+  let pendingFiles = 0;
+  const queuedFields = [];
+  busboyStream.on('field', (name, value) => {
+    if (pendingFiles > 0) {
+      // Because the 'end' event fires two microtasks after the next 'field'
+      // we would resolve files and fields out of order. To handle this properly
+      // we queue any fields we receive until the previous file is done.
+      queuedFields.push(name, value);
+    } else {
+      resolveField(response, name, value);
+    }
+  });
+  busboyStream.on('file', (name, value, _ref) => {
+    let filename = _ref.filename,
+        encoding = _ref.encoding,
+        mimeType = _ref.mimeType;
+
+    if (encoding.toLowerCase() === 'base64') {
+      throw new Error("React doesn't accept base64 encoded file uploads because we don't expect " + "form data passed from a browser to ever encode data that way. If that's " + 'the wrong assumption, we can easily fix it.');
+    }
+
+    pendingFiles++;
+    const file = resolveFileInfo(response, name, filename, mimeType);
+    value.on('data', chunk => {
+      resolveFileChunk(response, file, chunk);
+    });
+    value.on('end', () => {
+      resolveFileComplete(response, name, file);
+      pendingFiles--;
+
+      if (pendingFiles === 0) {
+        // Release any queued fields
+        for (let i = 0; i < queuedFields.length; i += 2) {
+          resolveField(response, queuedFields[i], queuedFields[i + 1]);
+        }
+
+        queuedFields.length = 0;
+      }
+    });
+  });
+  busboyStream.on('finish', () => {
+    close(response);
+  });
+  busboyStream.on('error', err => {
+    reportGlobalError(response, // $FlowFixMe[incompatible-call] types Error and mixed are incompatible
+    err);
+  });
+  return getRoot(response);
+}
+
+function decodeReply(body, webpackMap) {
+  if (typeof body === 'string') {
+    const form = new FormData();
+    form.append('0', body);
+    body = form;
+  }
+
+  const response = createResponse(webpackMap, '', body);
+  const root = getRoot(response);
+  close(response);
+  return root;
+}
+
+exports.createClientModuleProxy = createClientModuleProxy;
+exports.decodeAction = decodeAction;
+exports.decodeFormState = decodeFormState;
+exports.decodeReply = decodeReply;
+exports.decodeReplyFromBusboy = decodeReplyFromBusboy;
+exports.registerClientReference = registerClientReference;
+exports.registerServerReference = registerServerReference;
+exports.renderToPipeableStream = renderToPipeableStream;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.node.unbundled.production.min.js b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.node.unbundled.production.min.js
index b9682ba39cca0..16e8a2f7150b6 100644
--- a/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.node.unbundled.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-server.node.unbundled.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-webpack-server.node.unbundled.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-webpack-server.node.unbundled.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var aa=require("util");require("crypto");var ba=require("async_hooks"),ca=require("react"),da=require("react-dom"),l=null,m=0,p=!0;function q(a,b){a=a.write(b);p=p&&a}
 function r(a,b){if("string"===typeof b){if(0!==b.length)if(2048<3*b.length)0<m&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=0),q(a,ea.encode(b));else{var d=l;0<m&&(d=l.subarray(m));d=ea.encodeInto(b,d);var c=d.read;m+=d.written;c<b.length&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=ea.encodeInto(b.slice(c),l).written);2048===m&&(q(a,l),l=new Uint8Array(2048),m=0)}}else 0!==b.byteLength&&(2048<b.byteLength?(0<m&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=0),q(a,b)):(d=l.length-m,d<b.byteLength&&
 (0===d?q(a,l):(l.set(b.subarray(0,d),m),m+=d,q(a,l),b=b.subarray(d)),l=new Uint8Array(2048),m=0),l.set(b,m),m+=b.byteLength,2048===m&&(q(a,l),l=new Uint8Array(2048),m=0)));return p}var ea=new aa.TextEncoder,t=Symbol.for("react.client.reference"),v=Symbol.for("react.server.reference");function x(a,b,d){return Object.defineProperties(a,{$$typeof:{value:t},$$id:{value:b},$$async:{value:d}})}var fa=Function.prototype.bind,ha=Array.prototype.slice;
@@ -83,3 +83,5 @@ exports.decodeFormState=function(a,b,d){var c=b.get("$ACTION_KEY");if("string"!=
 exports.decodeReplyFromBusboy=function(a,b){var d=$b(b,""),c=0,e=[];a.on("field",function(f,g){0<c?e.push(f,g):ac(d,f,g)});a.on("file",function(f,g,h){var k=h.filename,n=h.mimeType;if("base64"===h.encoding.toLowerCase())throw Error("React doesn't accept base64 encoded file uploads because we don't expect form data passed from a browser to ever encode data that way. If that's the wrong assumption, we can easily fix it.");c++;var w=[];g.on("data",function(u){w.push(u)});g.on("end",function(){var u=
 new Blob(w,{type:n});d._formData.append(f,u,k);c--;if(0===c){for(u=0;u<e.length;u+=2)ac(d,e[u],e[u+1]);e.length=0}})});a.on("finish",function(){bc(d)});a.on("error",function(f){Xb(d,f)});return Z(d,0)};exports.registerClientReference=function(a,b,d){return x(a,b+"#"+d,!1)};exports.registerServerReference=function(a,b,d){return Object.defineProperties(a,{$$typeof:{value:v},$$id:{value:null===d?b:b+"#"+d},$$bound:{value:null},bind:{value:ia}})};
 exports.renderToPipeableStream=function(a,b,d){var c=tb(a,b,d?d.onError:void 0,d?d.context:void 0,d?d.identifierPrefix:void 0,d?d.onPostpone:void 0),e=!1;Kb(c);return{pipe:function(f){if(e)throw Error("React currently only supports piping to one writable stream.");e=!0;Lb(c,f);f.on("drain",hc(f,c));f.on("error",ic(c,"The destination stream errored while writing data."));f.on("close",ic(c,"The destination stream closed early."));return f},abort:function(f){Mb(c,f)}}};
+
+//# sourceMappingURL=react-server-dom-webpack-server.node.unbundled.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-webpack-experimental/package.json b/packages/next/src/compiled/react-server-dom-webpack-experimental/package.json
index ff7d965b4da5a..d75ffdecba7cb 100644
--- a/packages/next/src/compiled/react-server-dom-webpack-experimental/package.json
+++ b/packages/next/src/compiled/react-server-dom-webpack-experimental/package.json
@@ -47,8 +47,8 @@
     "loose-envify": "^1.1.0"
   },
   "peerDependencies": {
-    "react": "0.0.0-experimental-2983249dd-20231107",
-    "react-dom": "0.0.0-experimental-2983249dd-20231107",
+    "react": "0.0.0-experimental-7508dcd5c-20231108",
+    "react-dom": "0.0.0-experimental-7508dcd5c-20231108",
     "webpack": "^5.59.0"
   }
 }
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.browser.production.js b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.browser.production.js
new file mode 100644
index 0000000000000..b9473602ca682
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.browser.production.js
@@ -0,0 +1,1638 @@
+/**
+ * @license React
+ * react-server-dom-webpack-client.browser.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var ReactDOM = require('react-dom');
+var React = require('react');
+
+// -----------------------------------------------------------------------------
+const enableBinaryFlight = false;
+
+function createStringDecoder() {
+  return new TextDecoder();
+}
+const decoderOptions = {
+  stream: true
+};
+function readPartialStringChunk(decoder, buffer) {
+  return decoder.decode(buffer, decoderOptions);
+}
+function readFinalStringChunk(decoder, buffer) {
+  return decoder.decode(buffer);
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+function resolveClientReference(bundlerConfig, metadata) {
+  if (bundlerConfig) {
+    const moduleExports = bundlerConfig[metadata[ID]];
+    let resolvedModuleData = moduleExports[metadata[NAME]];
+    let name;
+
+    if (resolvedModuleData) {
+      // The potentially aliased name.
+      name = resolvedModuleData.name;
+    } else {
+      // If we don't have this specific name, we might have the full module.
+      resolvedModuleData = moduleExports['*'];
+
+      if (!resolvedModuleData) {
+        throw new Error('Could not find the module "' + metadata[ID] + '" in the React SSR Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+      }
+
+      name = metadata[NAME];
+    }
+
+    if (isAsyncImport(metadata)) {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1
+      /* async */
+      ];
+    } else {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+    }
+  }
+
+  return metadata;
+}
+// If they're still pending they're a thenable. This map also exists
+// in Webpack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = __webpack_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+  let i = 0;
+
+  while (i < chunks.length) {
+    const chunkId = chunks[i++];
+    const chunkFilename = chunks[i++];
+    const entry = chunkCache.get(chunkId);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkId, chunkFilename);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkId, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkId, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = __webpack_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+const chunkMap = new Map();
+/**
+ * We patch the chunk filename function in webpack to insert our own resolution
+ * of chunks that come from Flight and may not be known to the webpack runtime
+ */
+
+const webpackGetChunkFilename = __webpack_require__.u;
+
+__webpack_require__.u = function (chunkId) {
+  const flightChunk = chunkMap.get(chunkId);
+
+  if (flightChunk !== undefined) {
+    return flightChunk;
+  }
+
+  return webpackGetChunkFilename(chunkId);
+};
+
+function loadChunk(chunkId, filename) {
+  chunkMap.set(chunkId, filename);
+  return __webpack_chunk_load__(chunkId);
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+// This client file is in the shared folder because it applies to both SSR and browser contexts.
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function dispatchHint(code, model) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    switch (code) {
+      case 'D':
+        {
+          const refined = refineModel(code, model);
+          const href = refined;
+          dispatcher.prefetchDNS(href);
+          return;
+        }
+
+      case 'C':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preconnect(href);
+          } else {
+            const href = refined[0];
+            const crossOrigin = refined[1];
+            dispatcher.preconnect(href, crossOrigin);
+          }
+
+          return;
+        }
+
+      case 'L':
+        {
+          const refined = refineModel(code, model);
+          const href = refined[0];
+          const as = refined[1];
+
+          if (refined.length === 3) {
+            const options = refined[2];
+            dispatcher.preload(href, as, options);
+          } else {
+            dispatcher.preload(href, as);
+          }
+
+          return;
+        }
+
+      case 'm':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preloadModule(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preloadModule(href, options);
+          }
+
+          return;
+        }
+
+      case 'S':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitStyle(href);
+          } else {
+            const href = refined[0];
+            const precedence = refined[1] === 0 ? undefined : refined[1];
+            const options = refined.length === 3 ? refined[2] : undefined;
+            dispatcher.preinitStyle(href, precedence, options);
+          }
+
+          return;
+        }
+
+      case 'X':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitScript(href, options);
+          }
+
+          return;
+        }
+
+      case 'M':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitModuleScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitModuleScript(href, options);
+          }
+
+          return;
+        }
+    }
+  }
+} // Flow is having troulbe refining the HintModels so we help it a bit.
+// This should be compiled out in the production build.
+
+function refineModel(code, model) {
+  return model;
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+const ObjectPrototype = Object.prototype;
+const knownServerReferences = new WeakMap(); // Serializable values
+// Thenable<ReactServerValue>
+// function serializeByValueID(id: number): string {
+//   return '$' + id.toString(16);
+// }
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeFormDataReference(id) {
+  // Why K? F is "Function". D is "Date". What else?
+  return '$K' + id.toString(16);
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeMapID(id) {
+  return '$Q' + id.toString(16);
+}
+
+function serializeSetID(id) {
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+
+function processReply(root, formFieldPrefix, resolve, reject) {
+  let nextPartId = 1;
+  let pendingParts = 0;
+  let formData = null;
+
+  function resolveToJSON(key, value) {
+    const parent = this; // Make sure that `parent[key]` wasn't JSONified before `value` was passed to us
+
+    if (value === null) {
+      return null;
+    }
+
+    if (typeof value === 'object') {
+      // $FlowFixMe[method-unbinding]
+      if (typeof value.then === 'function') {
+        // We assume that any object with a .then property is a "Thenable" type,
+        // or a Promise type. Either of which can be represented by a Promise.
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        }
+
+        pendingParts++;
+        const promiseId = nextPartId++;
+        const thenable = value;
+        thenable.then(partValue => {
+          const partJSON = JSON.stringify(partValue, resolveToJSON); // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
+
+          const data = formData; // eslint-disable-next-line react-internal/safe-string-coercion
+
+          data.append(formFieldPrefix + promiseId, partJSON);
+          pendingParts--;
+
+          if (pendingParts === 0) {
+            resolve(data);
+          }
+        }, reason => {
+          // In the future we could consider serializing this as an error
+          // that throws on the server instead.
+          reject(reason);
+        });
+        return serializePromiseID(promiseId);
+      }
+
+      if (isArray(value)) {
+        // $FlowFixMe[incompatible-return]
+        return value;
+      } // TODO: Should we the Object.prototype.toString.call() to test for cross-realm objects?
+
+
+      if (value instanceof FormData) {
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to use rich objects as its values.
+          formData = new FormData();
+        }
+
+        const data = formData;
+        const refId = nextPartId++; // Copy all the form fields with a prefix for this reference.
+        // These must come first in the form order because we assume that all the
+        // fields are available before this is referenced.
+
+        const prefix = formFieldPrefix + refId + '_'; // $FlowFixMe[prop-missing]: FormData has forEach.
+
+        value.forEach((originalValue, originalKey) => {
+          data.append(prefix + originalKey, originalValue);
+        });
+        return serializeFormDataReference(refId);
+      }
+
+      if (value instanceof Map) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const mapId = nextPartId++;
+        formData.append(formFieldPrefix + mapId, partJSON);
+        return serializeMapID(mapId);
+      }
+
+      if (value instanceof Set) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const setId = nextPartId++;
+        formData.append(formFieldPrefix + setId, partJSON);
+        return serializeSetID(setId);
+      }
+
+      const iteratorFn = getIteratorFn(value);
+
+      if (iteratorFn) {
+        return Array.from(value);
+      } // Verify that this is a simple plain object.
+
+
+      const proto = getPrototypeOf(value);
+
+      if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+        throw new Error('Only plain objects, and a few built-ins, can be passed to Server Actions. ' + 'Classes or null prototypes are not supported.');
+      }
+
+
+      return value;
+    }
+
+    if (typeof value === 'string') {
+      // TODO: Maybe too clever. If we support URL there's no similar trick.
+      if (value[value.length - 1] === 'Z') {
+        // Possibly a Date, whose toJSON automatically calls toISOString
+        // $FlowFixMe[incompatible-use]
+        const originalValue = parent[key];
+
+        if (originalValue instanceof Date) {
+          return serializeDateFromDateJSON(value);
+        }
+      }
+
+      return escapeStringValue(value);
+    }
+
+    if (typeof value === 'boolean') {
+      return value;
+    }
+
+    if (typeof value === 'number') {
+      return serializeNumber(value);
+    }
+
+    if (typeof value === 'undefined') {
+      return serializeUndefined();
+    }
+
+    if (typeof value === 'function') {
+      const metaData = knownServerReferences.get(value);
+
+      if (metaData !== undefined) {
+        const metaDataJSON = JSON.stringify(metaData, resolveToJSON);
+
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        } // The reference to this function came from the same client so we can pass it back.
+
+
+        const refId = nextPartId++; // eslint-disable-next-line react-internal/safe-string-coercion
+
+        formData.set(formFieldPrefix + refId, metaDataJSON);
+        return serializeServerReferenceID(refId);
+      }
+
+      throw new Error('Client Functions cannot be passed directly to Server Functions. ' + 'Only Functions passed from the Server can be passed back again.');
+    }
+
+    if (typeof value === 'symbol') {
+      // $FlowFixMe[incompatible-type] `description` might be undefined
+      const name = value.description;
+
+      if (Symbol.for(name) !== value) {
+        throw new Error('Only global symbols received from Symbol.for(...) can be passed to Server Functions. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+        value.description + ") cannot be found among global symbols."));
+      }
+
+      return serializeSymbolReference(name);
+    }
+
+    if (typeof value === 'bigint') {
+      return serializeBigInt(value);
+    }
+
+    throw new Error("Type " + typeof value + " is not supported as an argument to a Server Function.");
+  } // $FlowFixMe[incompatible-type] it's not going to be undefined because we'll encode it.
+
+
+  const json = JSON.stringify(root, resolveToJSON);
+
+  if (formData === null) {
+    // If it's a simple data structure, we just use plain JSON.
+    resolve(json);
+  } else {
+    // Otherwise, we use FormData to let us stream in the result.
+    formData.set(formFieldPrefix + '0', json);
+
+    if (pendingParts === 0) {
+      // $FlowFixMe[incompatible-call] this has already been refined.
+      resolve(formData);
+    }
+  }
+}
+
+function registerServerReference(proxy, reference) {
+
+  knownServerReferences.set(proxy, reference);
+} // $FlowFixMe[method-unbinding]
+
+function createServerReference(id, callServer) {
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    return callServer(id, args);
+  };
+
+  registerServerReference(proxy, {
+    id,
+    bound: null
+  });
+  return proxy;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ROW_ID = 0;
+const ROW_TAG = 1;
+const ROW_LENGTH = 2;
+const ROW_CHUNK_BY_NEWLINE = 3;
+const ROW_CHUNK_BY_LENGTH = 4;
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const CYCLIC = 'cyclic';
+const RESOLVED_MODEL = 'resolved_model';
+const RESOLVED_MODULE = 'resolved_module';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function readChunk(chunk) {
+  // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      return chunk.value;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      // eslint-disable-next-line no-throw-literal
+      throw chunk;
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function createBlockedChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(BLOCKED, null, null, response);
+}
+
+function createErrorChunk(response, error) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(ERRORED, null, error, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function createResolvedModuleChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODULE, value, null, response);
+}
+
+function createInitializedTextChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function resolveModuleChunk(chunk, value) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODULE;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    initializeModuleChunk(resolvedChunk);
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+  const resolvedModel = chunk.value; // We go to the CYCLIC state until we've fully resolved this.
+  // We do this before parsing in case we try to initialize the same chunk
+  // while parsing the model. Such as in a cyclic reference.
+
+  const cyclicChunk = chunk;
+  cyclicChunk.status = CYCLIC;
+  cyclicChunk.value = null;
+  cyclicChunk.reason = null;
+
+  try {
+    const value = parseModel(chunk._response, resolvedModel);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const resolveListeners = cyclicChunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, value);
+      }
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+}
+
+function initializeModuleChunk(chunk) {
+  try {
+    const value = requireModule(chunk.value);
+    const initializedChunk = chunk;
+    initializedChunk.status = INITIALIZED;
+    initializedChunk.value = value;
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function createElement(type, key, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: null,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: null
+  };
+
+  return element;
+}
+
+function createLazyChunkWrapper(chunk) {
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: chunk,
+    _init: readChunk
+  };
+  return lazyType;
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunk = createPendingChunk(response);
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key, cyclic) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+
+    if (!cyclic) {
+      blocked.deps++;
+    }
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: cyclic ? 0 : 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function createServerReferenceProxy(response, metaData) {
+  const callServer = response._callServer;
+
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    const p = metaData.bound;
+
+    if (!p) {
+      return callServer(metaData.id, args);
+    }
+
+    if (p.status === INITIALIZED) {
+      const bound = p.value;
+      return callServer(metaData.id, bound.concat(args));
+    } // Since this is a fake Promise whose .then doesn't chain, we have to wrap it.
+    // TODO: Remove the wrapper once that's fixed.
+
+
+    return Promise.resolve(p).then(function (bound) {
+      return callServer(metaData.id, bound.concat(args));
+    });
+  };
+
+  registerServerReference(proxy, metaData);
+  return proxy;
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      {
+        return chunk.value;
+      }
+    // We always encode it first in the stream so it won't be pending.
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    if (value === '$') {
+      // A very common symbol.
+      return REACT_ELEMENT_TYPE;
+    }
+
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case 'L':
+        {
+          // Lazy node
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id); // We create a React.lazy wrapper around any lazy values.
+          // When passed into React, we'll know how to suspend on this.
+
+          return createLazyChunkWrapper(chunk);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'P':
+        {
+          // Server Context Provider
+          return getOrCreateServerContext(value.slice(2)).Provider;
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16);
+          const metadata = getOutlinedModel(response, id);
+          return createServerReferenceProxy(response, metadata);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+
+            case RESOLVED_MODULE:
+              initializeModuleChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+            case CYCLIC:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key, chunk.status === CYCLIC), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function parseModelTuple(response, value) {
+  const tuple = value;
+
+  if (tuple[0] === REACT_ELEMENT_TYPE) {
+    // TODO: Consider having React just directly accept these arrays as elements.
+    // Or even change the ReactElement type to be an array.
+    return createElement(tuple[1], tuple[2], tuple[3]);
+  }
+
+  return value;
+}
+
+function missingCall() {
+  throw new Error('Trying to call a function from "use server" but the callServer option ' + 'was not implemented in your router runtime.');
+}
+
+function createResponse(bundlerConfig, moduleLoading, callServer, nonce) {
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _moduleLoading: moduleLoading,
+    _callServer: callServer !== undefined ? callServer : missingCall,
+    _nonce: nonce,
+    _chunks: chunks,
+    _stringDecoder: createStringDecoder(),
+    _fromJSON: null,
+    _rowState: 0,
+    _rowID: 0,
+    _rowTag: 0,
+    _rowLength: 0,
+    _buffer: []
+  }; // Don't inline this call because it causes closure to outline the call above.
+
+  response._fromJSON = createFromJSONCallback(response);
+  return response;
+}
+
+function resolveModel(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createResolvedModelChunk(response, model));
+  } else {
+    resolveModelChunk(chunk, model);
+  }
+}
+
+function resolveText(response, id, text) {
+  const chunks = response._chunks; // We assume that we always reference large strings after they've been
+  // emitted.
+
+  chunks.set(id, createInitializedTextChunk(response, text));
+}
+
+function resolveModule(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+  const clientReferenceMetadata = parseModel(response, model);
+  const clientReference = resolveClientReference(response._bundlerConfig, clientReferenceMetadata);
+  // For now we preload all modules as early as possible since it's likely
+  // that we'll need them.
+
+  const promise = preloadModule(clientReference);
+
+  if (promise) {
+    let blockedChunk;
+
+    if (!chunk) {
+      // Technically, we should just treat promise as the chunk in this
+      // case. Because it'll just behave as any other promise.
+      blockedChunk = createBlockedChunk(response);
+      chunks.set(id, blockedChunk);
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+    }
+
+    promise.then(() => resolveModuleChunk(blockedChunk, clientReference), error => triggerErrorOnChunk(blockedChunk, error));
+  } else {
+    if (!chunk) {
+      chunks.set(id, createResolvedModuleChunk(response, clientReference));
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      resolveModuleChunk(chunk, clientReference);
+    }
+  }
+}
+
+function resolveErrorProd(response, id, digest) {
+
+  const error = new Error('An error occurred in the Server Components render. The specific message is omitted in production' + ' builds to avoid leaking sensitive details. A digest property is included on this error instance which' + ' may provide additional details about the nature of the error.');
+  error.stack = 'Error: ' + error.message;
+  error.digest = digest;
+  const errorWithDigest = error;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, errorWithDigest));
+  } else {
+    triggerErrorOnChunk(chunk, errorWithDigest);
+  }
+}
+
+function resolveHint(response, code, model) {
+  const hintModel = parseModel(response, model);
+  dispatchHint(code, hintModel);
+}
+
+function processFullRow(response, id, tag, buffer, chunk) {
+
+  const stringDecoder = response._stringDecoder;
+  let row = '';
+
+  for (let i = 0; i < buffer.length; i++) {
+    row += readPartialStringChunk(stringDecoder, buffer[i]);
+  }
+
+  row += readFinalStringChunk(stringDecoder, chunk);
+
+  switch (tag) {
+    case 73
+    /* "I" */
+    :
+      {
+        resolveModule(response, id, row);
+        return;
+      }
+
+    case 72
+    /* "H" */
+    :
+      {
+        const code = row[0];
+        resolveHint(response, code, row.slice(1));
+        return;
+      }
+
+    case 69
+    /* "E" */
+    :
+      {
+        const errorInfo = JSON.parse(row);
+
+        {
+          resolveErrorProd(response, id, errorInfo.digest);
+        }
+
+        return;
+      }
+
+    case 84
+    /* "T" */
+    :
+      {
+        resolveText(response, id, row);
+        return;
+      }
+
+    case 80
+    /* "P" */
+    :
+    // Fallthrough
+
+    default:
+      /* """ "{" "[" "t" "f" "n" "0" - "9" */
+      {
+        // We assume anything else is JSON.
+        resolveModel(response, id, row);
+        return;
+      }
+  }
+}
+
+function processBinaryChunk(response, chunk) {
+  let i = 0;
+  let rowState = response._rowState;
+  let rowID = response._rowID;
+  let rowTag = response._rowTag;
+  let rowLength = response._rowLength;
+  const buffer = response._buffer;
+  const chunkLength = chunk.length;
+
+  while (i < chunkLength) {
+    let lastIdx = -1;
+
+    switch (rowState) {
+      case ROW_ID:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 58
+          /* ":" */
+          ) {
+              // Finished the rowID, next we'll parse the tag.
+              rowState = ROW_TAG;
+            } else {
+            rowID = rowID << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_TAG:
+        {
+          const resolvedRowTag = chunk[i];
+
+          if (resolvedRowTag === 84
+          /* "T" */
+          || enableBinaryFlight 
+          /* "V" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_LENGTH;
+              i++;
+            } else if (resolvedRowTag > 64 && resolvedRowTag < 91
+          /* "A"-"Z" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_CHUNK_BY_NEWLINE;
+              i++;
+            } else {
+            rowTag = 0;
+            rowState = ROW_CHUNK_BY_NEWLINE; // This was an unknown tag so it was probably part of the data.
+          }
+
+          continue;
+        }
+
+      case ROW_LENGTH:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 44
+          /* "," */
+          ) {
+              // Finished the rowLength, next we'll buffer up to that length.
+              rowState = ROW_CHUNK_BY_LENGTH;
+            } else {
+            rowLength = rowLength << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_CHUNK_BY_NEWLINE:
+        {
+          // We're looking for a newline
+          lastIdx = chunk.indexOf(10
+          /* "\n" */
+          , i);
+          break;
+        }
+
+      case ROW_CHUNK_BY_LENGTH:
+        {
+          // We're looking for the remaining byte length
+          lastIdx = i + rowLength;
+
+          if (lastIdx > chunk.length) {
+            lastIdx = -1;
+          }
+
+          break;
+        }
+    }
+
+    const offset = chunk.byteOffset + i;
+
+    if (lastIdx > -1) {
+      // We found the last chunk of the row
+      const length = lastIdx - i;
+      const lastChunk = new Uint8Array(chunk.buffer, offset, length);
+      processFullRow(response, rowID, rowTag, buffer, lastChunk); // Reset state machine for a new row
+
+      i = lastIdx;
+
+      if (rowState === ROW_CHUNK_BY_NEWLINE) {
+        // If we're trailing by a newline we need to skip it.
+        i++;
+      }
+
+      rowState = ROW_ID;
+      rowTag = 0;
+      rowID = 0;
+      rowLength = 0;
+      buffer.length = 0;
+    } else {
+      // The rest of this row is in a future chunk. We stash the rest of the
+      // current chunk until we can process the full row.
+      const length = chunk.byteLength - i;
+      const remainingSlice = new Uint8Array(chunk.buffer, offset, length);
+      buffer.push(remainingSlice); // Update how many bytes we're still waiting for. If we're looking for
+      // a newline, this doesn't hurt since we'll just ignore it.
+
+      rowLength -= remainingSlice.byteLength;
+      break;
+    }
+  }
+
+  response._rowState = rowState;
+  response._rowID = rowID;
+  response._rowTag = rowTag;
+  response._rowLength = rowLength;
+}
+
+function parseModel(response, json) {
+  return JSON.parse(json, response._fromJSON);
+}
+
+function createFromJSONCallback(response) {
+  // $FlowFixMe[missing-this-annot]
+  return function (key, value) {
+    if (typeof value === 'string') {
+      // We can't use .bind here because we need the "this" value.
+      return parseModelString(response, this, key, value);
+    }
+
+    if (typeof value === 'object' && value !== null) {
+      return parseModelTuple(response, value);
+    }
+
+    return value;
+  };
+}
+
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function createResponseFromOptions(options) {
+  return createResponse(null, null, options && options.callServer ? options.callServer : undefined, undefined // nonce
+  );
+}
+
+function startReadingFromStream(response, stream) {
+  const reader = stream.getReader();
+
+  function progress(_ref) {
+    let done = _ref.done,
+        value = _ref.value;
+
+    if (done) {
+      close(response);
+      return;
+    }
+
+    const buffer = value;
+    processBinaryChunk(response, buffer);
+    return reader.read().then(progress).catch(error);
+  }
+
+  function error(e) {
+    reportGlobalError(response, e);
+  }
+
+  reader.read().then(progress).catch(error);
+}
+
+function createFromReadableStream(stream, options) {
+  const response = createResponseFromOptions(options);
+  startReadingFromStream(response, stream);
+  return getRoot(response);
+}
+
+function createFromFetch(promiseForResponse, options) {
+  const response = createResponseFromOptions(options);
+  promiseForResponse.then(function (r) {
+    startReadingFromStream(response, r.body);
+  }, function (e) {
+    reportGlobalError(response, e);
+  });
+  return getRoot(response);
+}
+
+function encodeReply(value)
+/* We don't use URLSearchParams yet but maybe */
+{
+  return new Promise((resolve, reject) => {
+    processReply(value, '', resolve, reject);
+  });
+}
+
+exports.createFromFetch = createFromFetch;
+exports.createFromReadableStream = createFromReadableStream;
+exports.createServerReference = createServerReference;
+exports.encodeReply = encodeReply;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.browser.production.min.js b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.browser.production.min.js
index 7b0d87fe7f746..6a4517f0b7899 100644
--- a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.browser.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.browser.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-webpack-client.browser.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-webpack-client.browser.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var r=require("react-dom"),t=require("react"),u={stream:!0};function v(a,b){if(a){var c=a[b[0]];if(a=c[b[2]])c=a.name;else{a=c["*"];if(!a)throw Error('Could not find the module "'+b[0]+'" in the React SSR Manifest. This is probably a bug in the React Server Components bundler.');c=b[2]}return 4===b.length?[a.id,a.chunks,c,1]:[a.id,a.chunks,c]}return b}var w=new Map;
 function x(a){var b=__webpack_require__(a);if("function"!==typeof b.then||"fulfilled"===b.status)return null;b.then(function(c){b.status="fulfilled";b.value=c},function(c){b.status="rejected";b.reason=c});return b}function y(){}
 function z(a){for(var b=a[1],c=[],e=0;e<b.length;){var l=b[e++],k=b[e++],n=w.get(l);void 0===n?(A.set(l,k),k=__webpack_chunk_load__(l),c.push(k),n=w.set.bind(w,l,null),k.then(n,y),w.set(l,k)):null!==n&&c.push(n)}return 4===a.length?0===c.length?x(a[0]):Promise.all(c).then(function(){return x(a[0])}):0<c.length?Promise.all(c):null}var A=new Map,B=__webpack_require__.u;__webpack_require__.u=function(a){var b=A.get(a);return void 0!==b?b:B(a)};
@@ -35,3 +35,5 @@ break;case "S":"string"===typeof f?h.preinitStyle(f):h.preinitStyle(f[0],0===f[1
 h.stack="Error: "+h.message;h.digest=g;g=f._chunks;(q=g.get(d))?Q(q,h):g.set(d,new L("rejected",null,h,f));break;case 84:f._chunks.set(d,new L("fulfilled",h,null,f));break;default:g=f._chunks,(q=g.get(d))?(f=q,d=h,"pending"===f.status&&(h=f.value,g=f.reason,f.status="resolved_model",f.value=d,null!==h&&(M(f),P(f,h,g)))):g.set(d,new L("resolved_model",h,null,f))}g=p;3===m&&g++;f=d=h=m=0;k.length=0}else{n=new Uint8Array(n.buffer,q,n.byteLength-g);k.push(n);f-=n.byteLength;break}}a._rowState=m;a._rowID=
 d;a._rowTag=h;a._rowLength=f;return l.read().then(c).catch(e)}}function e(k){V(a,k)}var l=b.getReader();l.read().then(c).catch(e)}exports.createFromFetch=function(a,b){var c=Y(null,null,b&&b.callServer?b.callServer:void 0,void 0);a.then(function(e){Z(c,e.body)},function(e){V(c,e)});return W(c,0)};exports.createFromReadableStream=function(a,b){b=Y(null,null,b&&b.callServer?b.callServer:void 0,void 0);Z(b,a);return W(b,0)};
 exports.createServerReference=function(a,b){function c(){var e=Array.prototype.slice.call(arguments);return b(a,e)}J(c,{id:a,bound:null});return c};exports.encodeReply=function(a){return new Promise(function(b,c){ja(a,"",b,c)})};
+
+//# sourceMappingURL=react-server-dom-webpack-client.browser.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.edge.production.js b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.edge.production.js
new file mode 100644
index 0000000000000..a2d2decc59117
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.edge.production.js
@@ -0,0 +1,1848 @@
+/**
+ * @license React
+ * react-server-dom-webpack-client.edge.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var ReactDOM = require('react-dom');
+var React = require('react');
+
+// -----------------------------------------------------------------------------
+const enableBinaryFlight = false;
+
+function createStringDecoder() {
+  return new TextDecoder();
+}
+const decoderOptions = {
+  stream: true
+};
+function readPartialStringChunk(decoder, buffer) {
+  return decoder.decode(buffer, decoderOptions);
+}
+function readFinalStringChunk(decoder, buffer) {
+  return decoder.decode(buffer);
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+// The reason this function needs to defined here in this file instead of just
+// being exported directly from the WebpackDestination... file is because the
+// ClientReferenceMetadata is opaque and we can't unwrap it there.
+// This should get inlined and we could also just implement an unwrapping function
+// though that risks it getting used in places it shouldn't be. This is unfortunate
+// but currently it seems to be the best option we have.
+
+function prepareDestinationForModule(moduleLoading, nonce, metadata) {
+  prepareDestinationWithChunks(moduleLoading, metadata[CHUNKS], nonce);
+}
+function resolveClientReference(bundlerConfig, metadata) {
+  if (bundlerConfig) {
+    const moduleExports = bundlerConfig[metadata[ID]];
+    let resolvedModuleData = moduleExports[metadata[NAME]];
+    let name;
+
+    if (resolvedModuleData) {
+      // The potentially aliased name.
+      name = resolvedModuleData.name;
+    } else {
+      // If we don't have this specific name, we might have the full module.
+      resolvedModuleData = moduleExports['*'];
+
+      if (!resolvedModuleData) {
+        throw new Error('Could not find the module "' + metadata[ID] + '" in the React SSR Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+      }
+
+      name = metadata[NAME];
+    }
+
+    if (isAsyncImport(metadata)) {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1
+      /* async */
+      ];
+    } else {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+    }
+  }
+
+  return metadata;
+}
+// If they're still pending they're a thenable. This map also exists
+// in Webpack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = globalThis.__next_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+  let i = 0;
+
+  while (i < chunks.length) {
+    const chunkId = chunks[i++];
+    chunks[i++];
+    const entry = chunkCache.get(chunkId);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkId);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkId, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkId, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = globalThis.__next_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+function loadChunk(chunkId, filename) {
+  return __webpack_chunk_load__(chunkId);
+}
+
+function prepareDestinationWithChunks(moduleLoading, // Chunks are double-indexed [..., idx, filenamex, idy, filenamey, ...]
+chunks, nonce) {
+  if (moduleLoading !== null) {
+    for (let i = 1; i < chunks.length; i += 2) {
+      preinitScriptForSSR(moduleLoading.prefix + chunks[i], nonce, moduleLoading.crossOrigin);
+    }
+  }
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// This client file is in the shared folder because it applies to both SSR and browser contexts.
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function dispatchHint(code, model) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    switch (code) {
+      case 'D':
+        {
+          const refined = refineModel(code, model);
+          const href = refined;
+          dispatcher.prefetchDNS(href);
+          return;
+        }
+
+      case 'C':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preconnect(href);
+          } else {
+            const href = refined[0];
+            const crossOrigin = refined[1];
+            dispatcher.preconnect(href, crossOrigin);
+          }
+
+          return;
+        }
+
+      case 'L':
+        {
+          const refined = refineModel(code, model);
+          const href = refined[0];
+          const as = refined[1];
+
+          if (refined.length === 3) {
+            const options = refined[2];
+            dispatcher.preload(href, as, options);
+          } else {
+            dispatcher.preload(href, as);
+          }
+
+          return;
+        }
+
+      case 'm':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preloadModule(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preloadModule(href, options);
+          }
+
+          return;
+        }
+
+      case 'S':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitStyle(href);
+          } else {
+            const href = refined[0];
+            const precedence = refined[1] === 0 ? undefined : refined[1];
+            const options = refined.length === 3 ? refined[2] : undefined;
+            dispatcher.preinitStyle(href, precedence, options);
+          }
+
+          return;
+        }
+
+      case 'X':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitScript(href, options);
+          }
+
+          return;
+        }
+
+      case 'M':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitModuleScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitModuleScript(href, options);
+          }
+
+          return;
+        }
+    }
+  }
+} // Flow is having troulbe refining the HintModels so we help it a bit.
+// This should be compiled out in the production build.
+
+function refineModel(code, model) {
+  return model;
+}
+function preinitScriptForSSR(href, nonce, crossOrigin) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    dispatcher.preinitScript(href, {
+      crossOrigin: getCrossOriginString(crossOrigin),
+      nonce
+    });
+  }
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+const ObjectPrototype = Object.prototype;
+const knownServerReferences = new WeakMap(); // Serializable values
+// Thenable<ReactServerValue>
+// function serializeByValueID(id: number): string {
+//   return '$' + id.toString(16);
+// }
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeFormDataReference(id) {
+  // Why K? F is "Function". D is "Date". What else?
+  return '$K' + id.toString(16);
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeMapID(id) {
+  return '$Q' + id.toString(16);
+}
+
+function serializeSetID(id) {
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+
+function processReply(root, formFieldPrefix, resolve, reject) {
+  let nextPartId = 1;
+  let pendingParts = 0;
+  let formData = null;
+
+  function resolveToJSON(key, value) {
+    const parent = this; // Make sure that `parent[key]` wasn't JSONified before `value` was passed to us
+
+    if (value === null) {
+      return null;
+    }
+
+    if (typeof value === 'object') {
+      // $FlowFixMe[method-unbinding]
+      if (typeof value.then === 'function') {
+        // We assume that any object with a .then property is a "Thenable" type,
+        // or a Promise type. Either of which can be represented by a Promise.
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        }
+
+        pendingParts++;
+        const promiseId = nextPartId++;
+        const thenable = value;
+        thenable.then(partValue => {
+          const partJSON = JSON.stringify(partValue, resolveToJSON); // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
+
+          const data = formData; // eslint-disable-next-line react-internal/safe-string-coercion
+
+          data.append(formFieldPrefix + promiseId, partJSON);
+          pendingParts--;
+
+          if (pendingParts === 0) {
+            resolve(data);
+          }
+        }, reason => {
+          // In the future we could consider serializing this as an error
+          // that throws on the server instead.
+          reject(reason);
+        });
+        return serializePromiseID(promiseId);
+      }
+
+      if (isArray(value)) {
+        // $FlowFixMe[incompatible-return]
+        return value;
+      } // TODO: Should we the Object.prototype.toString.call() to test for cross-realm objects?
+
+
+      if (value instanceof FormData) {
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to use rich objects as its values.
+          formData = new FormData();
+        }
+
+        const data = formData;
+        const refId = nextPartId++; // Copy all the form fields with a prefix for this reference.
+        // These must come first in the form order because we assume that all the
+        // fields are available before this is referenced.
+
+        const prefix = formFieldPrefix + refId + '_'; // $FlowFixMe[prop-missing]: FormData has forEach.
+
+        value.forEach((originalValue, originalKey) => {
+          data.append(prefix + originalKey, originalValue);
+        });
+        return serializeFormDataReference(refId);
+      }
+
+      if (value instanceof Map) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const mapId = nextPartId++;
+        formData.append(formFieldPrefix + mapId, partJSON);
+        return serializeMapID(mapId);
+      }
+
+      if (value instanceof Set) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const setId = nextPartId++;
+        formData.append(formFieldPrefix + setId, partJSON);
+        return serializeSetID(setId);
+      }
+
+      const iteratorFn = getIteratorFn(value);
+
+      if (iteratorFn) {
+        return Array.from(value);
+      } // Verify that this is a simple plain object.
+
+
+      const proto = getPrototypeOf(value);
+
+      if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+        throw new Error('Only plain objects, and a few built-ins, can be passed to Server Actions. ' + 'Classes or null prototypes are not supported.');
+      }
+
+
+      return value;
+    }
+
+    if (typeof value === 'string') {
+      // TODO: Maybe too clever. If we support URL there's no similar trick.
+      if (value[value.length - 1] === 'Z') {
+        // Possibly a Date, whose toJSON automatically calls toISOString
+        // $FlowFixMe[incompatible-use]
+        const originalValue = parent[key];
+
+        if (originalValue instanceof Date) {
+          return serializeDateFromDateJSON(value);
+        }
+      }
+
+      return escapeStringValue(value);
+    }
+
+    if (typeof value === 'boolean') {
+      return value;
+    }
+
+    if (typeof value === 'number') {
+      return serializeNumber(value);
+    }
+
+    if (typeof value === 'undefined') {
+      return serializeUndefined();
+    }
+
+    if (typeof value === 'function') {
+      const metaData = knownServerReferences.get(value);
+
+      if (metaData !== undefined) {
+        const metaDataJSON = JSON.stringify(metaData, resolveToJSON);
+
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        } // The reference to this function came from the same client so we can pass it back.
+
+
+        const refId = nextPartId++; // eslint-disable-next-line react-internal/safe-string-coercion
+
+        formData.set(formFieldPrefix + refId, metaDataJSON);
+        return serializeServerReferenceID(refId);
+      }
+
+      throw new Error('Client Functions cannot be passed directly to Server Functions. ' + 'Only Functions passed from the Server can be passed back again.');
+    }
+
+    if (typeof value === 'symbol') {
+      // $FlowFixMe[incompatible-type] `description` might be undefined
+      const name = value.description;
+
+      if (Symbol.for(name) !== value) {
+        throw new Error('Only global symbols received from Symbol.for(...) can be passed to Server Functions. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+        value.description + ") cannot be found among global symbols."));
+      }
+
+      return serializeSymbolReference(name);
+    }
+
+    if (typeof value === 'bigint') {
+      return serializeBigInt(value);
+    }
+
+    throw new Error("Type " + typeof value + " is not supported as an argument to a Server Function.");
+  } // $FlowFixMe[incompatible-type] it's not going to be undefined because we'll encode it.
+
+
+  const json = JSON.stringify(root, resolveToJSON);
+
+  if (formData === null) {
+    // If it's a simple data structure, we just use plain JSON.
+    resolve(json);
+  } else {
+    // Otherwise, we use FormData to let us stream in the result.
+    formData.set(formFieldPrefix + '0', json);
+
+    if (pendingParts === 0) {
+      // $FlowFixMe[incompatible-call] this has already been refined.
+      resolve(formData);
+    }
+  }
+}
+const boundCache = new WeakMap();
+
+function encodeFormData(reference) {
+  let resolve, reject; // We need to have a handle on the thenable so that we can synchronously set
+  // its status from processReply, when it can complete synchronously.
+
+  const thenable = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  processReply(reference, '', body => {
+    if (typeof body === 'string') {
+      const data = new FormData();
+      data.append('0', body);
+      body = data;
+    }
+
+    const fulfilled = thenable;
+    fulfilled.status = 'fulfilled';
+    fulfilled.value = body;
+    resolve(body);
+  }, e => {
+    const rejected = thenable;
+    rejected.status = 'rejected';
+    rejected.reason = e;
+    reject(e);
+  });
+  return thenable;
+}
+
+function encodeFormAction(identifierPrefix) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  let data = null;
+  let name;
+  const boundPromise = reference.bound;
+
+  if (boundPromise !== null) {
+    let thenable = boundCache.get(reference);
+
+    if (!thenable) {
+      thenable = encodeFormData(reference);
+      boundCache.set(reference, thenable);
+    }
+
+    if (thenable.status === 'rejected') {
+      throw thenable.reason;
+    } else if (thenable.status !== 'fulfilled') {
+      throw thenable;
+    }
+
+    const encodedFormData = thenable.value; // This is hacky but we need the identifier prefix to be added to
+    // all fields but the suspense cache would break since we might get
+    // a new identifier each time. So we just append it at the end instead.
+
+    const prefixedData = new FormData(); // $FlowFixMe[prop-missing]
+
+    encodedFormData.forEach((value, key) => {
+      prefixedData.append('$ACTION_' + identifierPrefix + ':' + key, value);
+    });
+    data = prefixedData; // We encode the name of the prefix containing the data.
+
+    name = '$ACTION_REF_' + identifierPrefix;
+  } else {
+    // This is the simple case so we can just encode the ID.
+    name = '$ACTION_ID_' + reference.id;
+  }
+
+  return {
+    name: name,
+    method: 'POST',
+    encType: 'multipart/form-data',
+    data: data
+  };
+}
+
+function isSignatureEqual(referenceId, numberOfBoundArgs) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  if (reference.id !== referenceId) {
+    // These are different functions.
+    return false;
+  } // Now check if the number of bound arguments is the same.
+
+
+  const boundPromise = reference.bound;
+
+  if (boundPromise === null) {
+    // No bound arguments.
+    return numberOfBoundArgs === 0;
+  } // Unwrap the bound arguments array by suspending, if necessary. As with
+  // encodeFormData, this means isSignatureEqual can only be called while React
+  // is rendering.
+
+
+  switch (boundPromise.status) {
+    case 'fulfilled':
+      {
+        const boundArgs = boundPromise.value;
+        return boundArgs.length === numberOfBoundArgs;
+      }
+
+    case 'pending':
+      {
+        throw boundPromise;
+      }
+
+    case 'rejected':
+      {
+        throw boundPromise.reason;
+      }
+
+    default:
+      {
+        if (typeof boundPromise.status === 'string') ; else {
+          const pendingThenable = boundPromise;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(boundArgs => {
+            const fulfilledThenable = boundPromise;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = boundArgs;
+          }, error => {
+            const rejectedThenable = boundPromise;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          });
+        }
+
+        throw boundPromise;
+      }
+  }
+}
+
+function registerServerReference(proxy, reference) {
+  // Expose encoder for use by SSR, as well as a special bind that can be used to
+  // keep server capabilities.
+  {
+    // Only expose this in builds that would actually use it. Not needed on the client.
+    Object.defineProperties(proxy, {
+      $$FORM_ACTION: {
+        value: encodeFormAction
+      },
+      $$IS_SIGNATURE_EQUAL: {
+        value: isSignatureEqual
+      },
+      bind: {
+        value: bind
+      }
+    });
+  }
+
+  knownServerReferences.set(proxy, reference);
+} // $FlowFixMe[method-unbinding]
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+  const reference = knownServerReferences.get(this);
+
+  if (reference) {
+    const args = ArraySlice.call(arguments, 1);
+    let boundPromise = null;
+
+    if (reference.bound !== null) {
+      boundPromise = Promise.resolve(reference.bound).then(boundArgs => boundArgs.concat(args));
+    } else {
+      boundPromise = Promise.resolve(args);
+    }
+
+    registerServerReference(newFn, {
+      id: reference.id,
+      bound: boundPromise
+    });
+  }
+
+  return newFn;
+}
+
+function createServerReference$1(id, callServer) {
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    return callServer(id, args);
+  };
+
+  registerServerReference(proxy, {
+    id,
+    bound: null
+  });
+  return proxy;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ROW_ID = 0;
+const ROW_TAG = 1;
+const ROW_LENGTH = 2;
+const ROW_CHUNK_BY_NEWLINE = 3;
+const ROW_CHUNK_BY_LENGTH = 4;
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const CYCLIC = 'cyclic';
+const RESOLVED_MODEL = 'resolved_model';
+const RESOLVED_MODULE = 'resolved_module';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function readChunk(chunk) {
+  // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      return chunk.value;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      // eslint-disable-next-line no-throw-literal
+      throw chunk;
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function createBlockedChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(BLOCKED, null, null, response);
+}
+
+function createErrorChunk(response, error) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(ERRORED, null, error, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function createResolvedModuleChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODULE, value, null, response);
+}
+
+function createInitializedTextChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function resolveModuleChunk(chunk, value) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODULE;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    initializeModuleChunk(resolvedChunk);
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+  const resolvedModel = chunk.value; // We go to the CYCLIC state until we've fully resolved this.
+  // We do this before parsing in case we try to initialize the same chunk
+  // while parsing the model. Such as in a cyclic reference.
+
+  const cyclicChunk = chunk;
+  cyclicChunk.status = CYCLIC;
+  cyclicChunk.value = null;
+  cyclicChunk.reason = null;
+
+  try {
+    const value = parseModel(chunk._response, resolvedModel);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const resolveListeners = cyclicChunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, value);
+      }
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+}
+
+function initializeModuleChunk(chunk) {
+  try {
+    const value = requireModule(chunk.value);
+    const initializedChunk = chunk;
+    initializedChunk.status = INITIALIZED;
+    initializedChunk.value = value;
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function createElement(type, key, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: null,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: null
+  };
+
+  return element;
+}
+
+function createLazyChunkWrapper(chunk) {
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: chunk,
+    _init: readChunk
+  };
+  return lazyType;
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunk = createPendingChunk(response);
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key, cyclic) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+
+    if (!cyclic) {
+      blocked.deps++;
+    }
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: cyclic ? 0 : 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function createServerReferenceProxy(response, metaData) {
+  const callServer = response._callServer;
+
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    const p = metaData.bound;
+
+    if (!p) {
+      return callServer(metaData.id, args);
+    }
+
+    if (p.status === INITIALIZED) {
+      const bound = p.value;
+      return callServer(metaData.id, bound.concat(args));
+    } // Since this is a fake Promise whose .then doesn't chain, we have to wrap it.
+    // TODO: Remove the wrapper once that's fixed.
+
+
+    return Promise.resolve(p).then(function (bound) {
+      return callServer(metaData.id, bound.concat(args));
+    });
+  };
+
+  registerServerReference(proxy, metaData);
+  return proxy;
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      {
+        return chunk.value;
+      }
+    // We always encode it first in the stream so it won't be pending.
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    if (value === '$') {
+      // A very common symbol.
+      return REACT_ELEMENT_TYPE;
+    }
+
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case 'L':
+        {
+          // Lazy node
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id); // We create a React.lazy wrapper around any lazy values.
+          // When passed into React, we'll know how to suspend on this.
+
+          return createLazyChunkWrapper(chunk);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'P':
+        {
+          // Server Context Provider
+          return getOrCreateServerContext(value.slice(2)).Provider;
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16);
+          const metadata = getOutlinedModel(response, id);
+          return createServerReferenceProxy(response, metadata);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+
+            case RESOLVED_MODULE:
+              initializeModuleChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+            case CYCLIC:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key, chunk.status === CYCLIC), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function parseModelTuple(response, value) {
+  const tuple = value;
+
+  if (tuple[0] === REACT_ELEMENT_TYPE) {
+    // TODO: Consider having React just directly accept these arrays as elements.
+    // Or even change the ReactElement type to be an array.
+    return createElement(tuple[1], tuple[2], tuple[3]);
+  }
+
+  return value;
+}
+
+function missingCall() {
+  throw new Error('Trying to call a function from "use server" but the callServer option ' + 'was not implemented in your router runtime.');
+}
+
+function createResponse(bundlerConfig, moduleLoading, callServer, nonce) {
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _moduleLoading: moduleLoading,
+    _callServer: callServer !== undefined ? callServer : missingCall,
+    _nonce: nonce,
+    _chunks: chunks,
+    _stringDecoder: createStringDecoder(),
+    _fromJSON: null,
+    _rowState: 0,
+    _rowID: 0,
+    _rowTag: 0,
+    _rowLength: 0,
+    _buffer: []
+  }; // Don't inline this call because it causes closure to outline the call above.
+
+  response._fromJSON = createFromJSONCallback(response);
+  return response;
+}
+
+function resolveModel(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createResolvedModelChunk(response, model));
+  } else {
+    resolveModelChunk(chunk, model);
+  }
+}
+
+function resolveText(response, id, text) {
+  const chunks = response._chunks; // We assume that we always reference large strings after they've been
+  // emitted.
+
+  chunks.set(id, createInitializedTextChunk(response, text));
+}
+
+function resolveModule(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+  const clientReferenceMetadata = parseModel(response, model);
+  const clientReference = resolveClientReference(response._bundlerConfig, clientReferenceMetadata);
+  prepareDestinationForModule(response._moduleLoading, response._nonce, clientReferenceMetadata); // TODO: Add an option to encode modules that are lazy loaded.
+  // For now we preload all modules as early as possible since it's likely
+  // that we'll need them.
+
+  const promise = preloadModule(clientReference);
+
+  if (promise) {
+    let blockedChunk;
+
+    if (!chunk) {
+      // Technically, we should just treat promise as the chunk in this
+      // case. Because it'll just behave as any other promise.
+      blockedChunk = createBlockedChunk(response);
+      chunks.set(id, blockedChunk);
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+    }
+
+    promise.then(() => resolveModuleChunk(blockedChunk, clientReference), error => triggerErrorOnChunk(blockedChunk, error));
+  } else {
+    if (!chunk) {
+      chunks.set(id, createResolvedModuleChunk(response, clientReference));
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      resolveModuleChunk(chunk, clientReference);
+    }
+  }
+}
+
+function resolveErrorProd(response, id, digest) {
+
+  const error = new Error('An error occurred in the Server Components render. The specific message is omitted in production' + ' builds to avoid leaking sensitive details. A digest property is included on this error instance which' + ' may provide additional details about the nature of the error.');
+  error.stack = 'Error: ' + error.message;
+  error.digest = digest;
+  const errorWithDigest = error;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, errorWithDigest));
+  } else {
+    triggerErrorOnChunk(chunk, errorWithDigest);
+  }
+}
+
+function resolveHint(response, code, model) {
+  const hintModel = parseModel(response, model);
+  dispatchHint(code, hintModel);
+}
+
+function processFullRow(response, id, tag, buffer, chunk) {
+
+  const stringDecoder = response._stringDecoder;
+  let row = '';
+
+  for (let i = 0; i < buffer.length; i++) {
+    row += readPartialStringChunk(stringDecoder, buffer[i]);
+  }
+
+  row += readFinalStringChunk(stringDecoder, chunk);
+
+  switch (tag) {
+    case 73
+    /* "I" */
+    :
+      {
+        resolveModule(response, id, row);
+        return;
+      }
+
+    case 72
+    /* "H" */
+    :
+      {
+        const code = row[0];
+        resolveHint(response, code, row.slice(1));
+        return;
+      }
+
+    case 69
+    /* "E" */
+    :
+      {
+        const errorInfo = JSON.parse(row);
+
+        {
+          resolveErrorProd(response, id, errorInfo.digest);
+        }
+
+        return;
+      }
+
+    case 84
+    /* "T" */
+    :
+      {
+        resolveText(response, id, row);
+        return;
+      }
+
+    case 80
+    /* "P" */
+    :
+    // Fallthrough
+
+    default:
+      /* """ "{" "[" "t" "f" "n" "0" - "9" */
+      {
+        // We assume anything else is JSON.
+        resolveModel(response, id, row);
+        return;
+      }
+  }
+}
+
+function processBinaryChunk(response, chunk) {
+  let i = 0;
+  let rowState = response._rowState;
+  let rowID = response._rowID;
+  let rowTag = response._rowTag;
+  let rowLength = response._rowLength;
+  const buffer = response._buffer;
+  const chunkLength = chunk.length;
+
+  while (i < chunkLength) {
+    let lastIdx = -1;
+
+    switch (rowState) {
+      case ROW_ID:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 58
+          /* ":" */
+          ) {
+              // Finished the rowID, next we'll parse the tag.
+              rowState = ROW_TAG;
+            } else {
+            rowID = rowID << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_TAG:
+        {
+          const resolvedRowTag = chunk[i];
+
+          if (resolvedRowTag === 84
+          /* "T" */
+          || enableBinaryFlight 
+          /* "V" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_LENGTH;
+              i++;
+            } else if (resolvedRowTag > 64 && resolvedRowTag < 91
+          /* "A"-"Z" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_CHUNK_BY_NEWLINE;
+              i++;
+            } else {
+            rowTag = 0;
+            rowState = ROW_CHUNK_BY_NEWLINE; // This was an unknown tag so it was probably part of the data.
+          }
+
+          continue;
+        }
+
+      case ROW_LENGTH:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 44
+          /* "," */
+          ) {
+              // Finished the rowLength, next we'll buffer up to that length.
+              rowState = ROW_CHUNK_BY_LENGTH;
+            } else {
+            rowLength = rowLength << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_CHUNK_BY_NEWLINE:
+        {
+          // We're looking for a newline
+          lastIdx = chunk.indexOf(10
+          /* "\n" */
+          , i);
+          break;
+        }
+
+      case ROW_CHUNK_BY_LENGTH:
+        {
+          // We're looking for the remaining byte length
+          lastIdx = i + rowLength;
+
+          if (lastIdx > chunk.length) {
+            lastIdx = -1;
+          }
+
+          break;
+        }
+    }
+
+    const offset = chunk.byteOffset + i;
+
+    if (lastIdx > -1) {
+      // We found the last chunk of the row
+      const length = lastIdx - i;
+      const lastChunk = new Uint8Array(chunk.buffer, offset, length);
+      processFullRow(response, rowID, rowTag, buffer, lastChunk); // Reset state machine for a new row
+
+      i = lastIdx;
+
+      if (rowState === ROW_CHUNK_BY_NEWLINE) {
+        // If we're trailing by a newline we need to skip it.
+        i++;
+      }
+
+      rowState = ROW_ID;
+      rowTag = 0;
+      rowID = 0;
+      rowLength = 0;
+      buffer.length = 0;
+    } else {
+      // The rest of this row is in a future chunk. We stash the rest of the
+      // current chunk until we can process the full row.
+      const length = chunk.byteLength - i;
+      const remainingSlice = new Uint8Array(chunk.buffer, offset, length);
+      buffer.push(remainingSlice); // Update how many bytes we're still waiting for. If we're looking for
+      // a newline, this doesn't hurt since we'll just ignore it.
+
+      rowLength -= remainingSlice.byteLength;
+      break;
+    }
+  }
+
+  response._rowState = rowState;
+  response._rowID = rowID;
+  response._rowTag = rowTag;
+  response._rowLength = rowLength;
+}
+
+function parseModel(response, json) {
+  return JSON.parse(json, response._fromJSON);
+}
+
+function createFromJSONCallback(response) {
+  // $FlowFixMe[missing-this-annot]
+  return function (key, value) {
+    if (typeof value === 'string') {
+      // We can't use .bind here because we need the "this" value.
+      return parseModelString(response, this, key, value);
+    }
+
+    if (typeof value === 'object' && value !== null) {
+      return parseModelTuple(response, value);
+    }
+
+    return value;
+  };
+}
+
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function noServerCall() {
+  throw new Error('Server Functions cannot be called during initial render. ' + 'This would create a fetch waterfall. Try to use a Server Component ' + 'to pass data to Client Components instead.');
+}
+
+function createServerReference(id, callServer) {
+  return createServerReference$1(id, noServerCall);
+}
+
+function createResponseFromOptions(options) {
+  return createResponse(options.ssrManifest.moduleMap, options.ssrManifest.moduleLoading, noServerCall, typeof options.nonce === 'string' ? options.nonce : undefined);
+}
+
+function startReadingFromStream(response, stream) {
+  const reader = stream.getReader();
+
+  function progress(_ref) {
+    let done = _ref.done,
+        value = _ref.value;
+
+    if (done) {
+      close(response);
+      return;
+    }
+
+    const buffer = value;
+    processBinaryChunk(response, buffer);
+    return reader.read().then(progress).catch(error);
+  }
+
+  function error(e) {
+    reportGlobalError(response, e);
+  }
+
+  reader.read().then(progress).catch(error);
+}
+
+function createFromReadableStream(stream, options) {
+  const response = createResponseFromOptions(options);
+  startReadingFromStream(response, stream);
+  return getRoot(response);
+}
+
+function createFromFetch(promiseForResponse, options) {
+  const response = createResponseFromOptions(options);
+  promiseForResponse.then(function (r) {
+    startReadingFromStream(response, r.body);
+  }, function (e) {
+    reportGlobalError(response, e);
+  });
+  return getRoot(response);
+}
+
+function encodeReply(value)
+/* We don't use URLSearchParams yet but maybe */
+{
+  return new Promise((resolve, reject) => {
+    processReply(value, '', resolve, reject);
+  });
+}
+
+exports.createFromFetch = createFromFetch;
+exports.createFromReadableStream = createFromReadableStream;
+exports.createServerReference = createServerReference;
+exports.encodeReply = encodeReply;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.edge.production.min.js b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.edge.production.min.js
index cf884b0e0b155..7b8dea9ec15ea 100644
--- a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.edge.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.edge.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-webpack-client.edge.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-webpack-client.edge.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var r=require("react-dom"),t=require("react"),u={stream:!0};function v(a,b){if(a){var c=a[b[0]];if(a=c[b[2]])c=a.name;else{a=c["*"];if(!a)throw Error('Could not find the module "'+b[0]+'" in the React SSR Manifest. This is probably a bug in the React Server Components bundler.');c=b[2]}return 4===b.length?[a.id,a.chunks,c,1]:[a.id,a.chunks,c]}return b}var w=new Map;
 function x(a){var b=globalThis.__next_require__(a);if("function"!==typeof b.then||"fulfilled"===b.status)return null;b.then(function(c){b.status="fulfilled";b.value=c},function(c){b.status="rejected";b.reason=c});return b}function aa(){}
 function ba(a){for(var b=a[1],c=[],d=0;d<b.length;){var f=b[d++];b[d++];var h=w.get(f);if(void 0===h){h=__webpack_chunk_load__(f);c.push(h);var n=w.set.bind(w,f,null);h.then(n,aa);w.set(f,h)}else null!==h&&c.push(h)}return 4===a.length?0===c.length?x(a[0]):Promise.all(c).then(function(){return x(a[0])}):0<c.length?Promise.all(c):null}
@@ -39,3 +39,5 @@ new Uint8Array(n.buffer,q,p-k);g=a;q=l;var V=g._stringDecoder;l="";for(var K=0;K
 break;case "S":"string"===typeof g?l.preinitStyle(g):l.preinitStyle(g[0],0===g[1]?void 0:g[1],3===g.length?g[2]:void 0);break;case "X":"string"===typeof g?l.preinitScript(g):l.preinitScript(g[0],g[1]);break;case "M":"string"===typeof g?l.preinitModuleScript(g):l.preinitModuleScript(g[0],g[1])}break;case 69:l=JSON.parse(l);k=l.digest;l=Error("An error occurred in the Server Components render. The specific message is omitted in production builds to avoid leaking sensitive details. A digest property is included on this error instance which may provide additional details about the nature of the error.");
 l.stack="Error: "+l.message;l.digest=k;k=g._chunks;(q=k.get(e))?P(q,l):k.set(e,new J("rejected",null,l,g));break;case 84:g._chunks.set(e,new J("fulfilled",l,null,g));break;default:k=g._chunks,(q=k.get(e))?(g=q,e=l,"pending"===g.status&&(l=g.value,k=g.reason,g.status="resolved_model",g.value=e,null!==l&&(L(g),O(g,l,k)))):k.set(e,new J("resolved_model",l,null,g))}k=p;3===m&&k++;g=e=l=m=0;h.length=0}else{n=new Uint8Array(n.buffer,q,n.byteLength-k);h.push(n);g-=n.byteLength;break}}a._rowState=m;a._rowID=
 e;a._rowTag=l;a._rowLength=g;return f.read().then(c).catch(d)}}function d(h){T(a,h)}var f=b.getReader();f.read().then(c).catch(d)}exports.createFromFetch=function(a,b){var c=Y(b);a.then(function(d){Z(c,d.body)},function(d){T(c,d)});return U(c,0)};exports.createFromReadableStream=function(a,b){b=Y(b);Z(b,a);return U(b,0)};exports.createServerReference=function(a){return ra(a,X)};exports.encodeReply=function(a){return new Promise(function(b,c){F(a,"",b,c)})};
+
+//# sourceMappingURL=react-server-dom-webpack-client.edge.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.node.production.js b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.node.production.js
new file mode 100644
index 0000000000000..16b8bf9a122bb
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.node.production.js
@@ -0,0 +1,1807 @@
+/**
+ * @license React
+ * react-server-dom-webpack-client.node.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var util = require('util');
+var ReactDOM = require('react-dom');
+var React = require('react');
+
+// -----------------------------------------------------------------------------
+const enableBinaryFlight = false;
+
+function createStringDecoder() {
+  return new util.TextDecoder();
+}
+const decoderOptions = {
+  stream: true
+};
+function readPartialStringChunk(decoder, buffer) {
+  return decoder.decode(buffer, decoderOptions);
+}
+function readFinalStringChunk(decoder, buffer) {
+  return decoder.decode(buffer);
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+// The reason this function needs to defined here in this file instead of just
+// being exported directly from the WebpackDestination... file is because the
+// ClientReferenceMetadata is opaque and we can't unwrap it there.
+// This should get inlined and we could also just implement an unwrapping function
+// though that risks it getting used in places it shouldn't be. This is unfortunate
+// but currently it seems to be the best option we have.
+
+function prepareDestinationForModule(moduleLoading, nonce, metadata) {
+  prepareDestinationWithChunks(moduleLoading, metadata[CHUNKS], nonce);
+}
+function resolveClientReference(bundlerConfig, metadata) {
+  if (bundlerConfig) {
+    const moduleExports = bundlerConfig[metadata[ID]];
+    let resolvedModuleData = moduleExports[metadata[NAME]];
+    let name;
+
+    if (resolvedModuleData) {
+      // The potentially aliased name.
+      name = resolvedModuleData.name;
+    } else {
+      // If we don't have this specific name, we might have the full module.
+      resolvedModuleData = moduleExports['*'];
+
+      if (!resolvedModuleData) {
+        throw new Error('Could not find the module "' + metadata[ID] + '" in the React SSR Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+      }
+
+      name = metadata[NAME];
+    }
+
+    if (isAsyncImport(metadata)) {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1
+      /* async */
+      ];
+    } else {
+      return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+    }
+  }
+
+  return metadata;
+}
+// If they're still pending they're a thenable. This map also exists
+// in Webpack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = globalThis.__next_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+  let i = 0;
+
+  while (i < chunks.length) {
+    const chunkId = chunks[i++];
+    chunks[i++];
+    const entry = chunkCache.get(chunkId);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkId);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkId, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkId, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = globalThis.__next_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+function loadChunk(chunkId, filename) {
+  return __webpack_chunk_load__(chunkId);
+}
+
+function prepareDestinationWithChunks(moduleLoading, // Chunks are double-indexed [..., idx, filenamex, idy, filenamey, ...]
+chunks, nonce) {
+  if (moduleLoading !== null) {
+    for (let i = 1; i < chunks.length; i += 2) {
+      preinitScriptForSSR(moduleLoading.prefix + chunks[i], nonce, moduleLoading.crossOrigin);
+    }
+  }
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// This client file is in the shared folder because it applies to both SSR and browser contexts.
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function dispatchHint(code, model) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    switch (code) {
+      case 'D':
+        {
+          const refined = refineModel(code, model);
+          const href = refined;
+          dispatcher.prefetchDNS(href);
+          return;
+        }
+
+      case 'C':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preconnect(href);
+          } else {
+            const href = refined[0];
+            const crossOrigin = refined[1];
+            dispatcher.preconnect(href, crossOrigin);
+          }
+
+          return;
+        }
+
+      case 'L':
+        {
+          const refined = refineModel(code, model);
+          const href = refined[0];
+          const as = refined[1];
+
+          if (refined.length === 3) {
+            const options = refined[2];
+            dispatcher.preload(href, as, options);
+          } else {
+            dispatcher.preload(href, as);
+          }
+
+          return;
+        }
+
+      case 'm':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preloadModule(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preloadModule(href, options);
+          }
+
+          return;
+        }
+
+      case 'S':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitStyle(href);
+          } else {
+            const href = refined[0];
+            const precedence = refined[1] === 0 ? undefined : refined[1];
+            const options = refined.length === 3 ? refined[2] : undefined;
+            dispatcher.preinitStyle(href, precedence, options);
+          }
+
+          return;
+        }
+
+      case 'X':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitScript(href, options);
+          }
+
+          return;
+        }
+
+      case 'M':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitModuleScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitModuleScript(href, options);
+          }
+
+          return;
+        }
+    }
+  }
+} // Flow is having troulbe refining the HintModels so we help it a bit.
+// This should be compiled out in the production build.
+
+function refineModel(code, model) {
+  return model;
+}
+function preinitScriptForSSR(href, nonce, crossOrigin) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    dispatcher.preinitScript(href, {
+      crossOrigin: getCrossOriginString(crossOrigin),
+      nonce
+    });
+  }
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+const ObjectPrototype = Object.prototype;
+const knownServerReferences = new WeakMap(); // Serializable values
+// Thenable<ReactServerValue>
+// function serializeByValueID(id: number): string {
+//   return '$' + id.toString(16);
+// }
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeFormDataReference(id) {
+  // Why K? F is "Function". D is "Date". What else?
+  return '$K' + id.toString(16);
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeMapID(id) {
+  return '$Q' + id.toString(16);
+}
+
+function serializeSetID(id) {
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+
+function processReply(root, formFieldPrefix, resolve, reject) {
+  let nextPartId = 1;
+  let pendingParts = 0;
+  let formData = null;
+
+  function resolveToJSON(key, value) {
+    const parent = this; // Make sure that `parent[key]` wasn't JSONified before `value` was passed to us
+
+    if (value === null) {
+      return null;
+    }
+
+    if (typeof value === 'object') {
+      // $FlowFixMe[method-unbinding]
+      if (typeof value.then === 'function') {
+        // We assume that any object with a .then property is a "Thenable" type,
+        // or a Promise type. Either of which can be represented by a Promise.
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        }
+
+        pendingParts++;
+        const promiseId = nextPartId++;
+        const thenable = value;
+        thenable.then(partValue => {
+          const partJSON = JSON.stringify(partValue, resolveToJSON); // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
+
+          const data = formData; // eslint-disable-next-line react-internal/safe-string-coercion
+
+          data.append(formFieldPrefix + promiseId, partJSON);
+          pendingParts--;
+
+          if (pendingParts === 0) {
+            resolve(data);
+          }
+        }, reason => {
+          // In the future we could consider serializing this as an error
+          // that throws on the server instead.
+          reject(reason);
+        });
+        return serializePromiseID(promiseId);
+      }
+
+      if (isArray(value)) {
+        // $FlowFixMe[incompatible-return]
+        return value;
+      } // TODO: Should we the Object.prototype.toString.call() to test for cross-realm objects?
+
+
+      if (value instanceof FormData) {
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to use rich objects as its values.
+          formData = new FormData();
+        }
+
+        const data = formData;
+        const refId = nextPartId++; // Copy all the form fields with a prefix for this reference.
+        // These must come first in the form order because we assume that all the
+        // fields are available before this is referenced.
+
+        const prefix = formFieldPrefix + refId + '_'; // $FlowFixMe[prop-missing]: FormData has forEach.
+
+        value.forEach((originalValue, originalKey) => {
+          data.append(prefix + originalKey, originalValue);
+        });
+        return serializeFormDataReference(refId);
+      }
+
+      if (value instanceof Map) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const mapId = nextPartId++;
+        formData.append(formFieldPrefix + mapId, partJSON);
+        return serializeMapID(mapId);
+      }
+
+      if (value instanceof Set) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const setId = nextPartId++;
+        formData.append(formFieldPrefix + setId, partJSON);
+        return serializeSetID(setId);
+      }
+
+      const iteratorFn = getIteratorFn(value);
+
+      if (iteratorFn) {
+        return Array.from(value);
+      } // Verify that this is a simple plain object.
+
+
+      const proto = getPrototypeOf(value);
+
+      if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+        throw new Error('Only plain objects, and a few built-ins, can be passed to Server Actions. ' + 'Classes or null prototypes are not supported.');
+      }
+
+
+      return value;
+    }
+
+    if (typeof value === 'string') {
+      // TODO: Maybe too clever. If we support URL there's no similar trick.
+      if (value[value.length - 1] === 'Z') {
+        // Possibly a Date, whose toJSON automatically calls toISOString
+        // $FlowFixMe[incompatible-use]
+        const originalValue = parent[key];
+
+        if (originalValue instanceof Date) {
+          return serializeDateFromDateJSON(value);
+        }
+      }
+
+      return escapeStringValue(value);
+    }
+
+    if (typeof value === 'boolean') {
+      return value;
+    }
+
+    if (typeof value === 'number') {
+      return serializeNumber(value);
+    }
+
+    if (typeof value === 'undefined') {
+      return serializeUndefined();
+    }
+
+    if (typeof value === 'function') {
+      const metaData = knownServerReferences.get(value);
+
+      if (metaData !== undefined) {
+        const metaDataJSON = JSON.stringify(metaData, resolveToJSON);
+
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        } // The reference to this function came from the same client so we can pass it back.
+
+
+        const refId = nextPartId++; // eslint-disable-next-line react-internal/safe-string-coercion
+
+        formData.set(formFieldPrefix + refId, metaDataJSON);
+        return serializeServerReferenceID(refId);
+      }
+
+      throw new Error('Client Functions cannot be passed directly to Server Functions. ' + 'Only Functions passed from the Server can be passed back again.');
+    }
+
+    if (typeof value === 'symbol') {
+      // $FlowFixMe[incompatible-type] `description` might be undefined
+      const name = value.description;
+
+      if (Symbol.for(name) !== value) {
+        throw new Error('Only global symbols received from Symbol.for(...) can be passed to Server Functions. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+        value.description + ") cannot be found among global symbols."));
+      }
+
+      return serializeSymbolReference(name);
+    }
+
+    if (typeof value === 'bigint') {
+      return serializeBigInt(value);
+    }
+
+    throw new Error("Type " + typeof value + " is not supported as an argument to a Server Function.");
+  } // $FlowFixMe[incompatible-type] it's not going to be undefined because we'll encode it.
+
+
+  const json = JSON.stringify(root, resolveToJSON);
+
+  if (formData === null) {
+    // If it's a simple data structure, we just use plain JSON.
+    resolve(json);
+  } else {
+    // Otherwise, we use FormData to let us stream in the result.
+    formData.set(formFieldPrefix + '0', json);
+
+    if (pendingParts === 0) {
+      // $FlowFixMe[incompatible-call] this has already been refined.
+      resolve(formData);
+    }
+  }
+}
+const boundCache = new WeakMap();
+
+function encodeFormData(reference) {
+  let resolve, reject; // We need to have a handle on the thenable so that we can synchronously set
+  // its status from processReply, when it can complete synchronously.
+
+  const thenable = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  processReply(reference, '', body => {
+    if (typeof body === 'string') {
+      const data = new FormData();
+      data.append('0', body);
+      body = data;
+    }
+
+    const fulfilled = thenable;
+    fulfilled.status = 'fulfilled';
+    fulfilled.value = body;
+    resolve(body);
+  }, e => {
+    const rejected = thenable;
+    rejected.status = 'rejected';
+    rejected.reason = e;
+    reject(e);
+  });
+  return thenable;
+}
+
+function encodeFormAction(identifierPrefix) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  let data = null;
+  let name;
+  const boundPromise = reference.bound;
+
+  if (boundPromise !== null) {
+    let thenable = boundCache.get(reference);
+
+    if (!thenable) {
+      thenable = encodeFormData(reference);
+      boundCache.set(reference, thenable);
+    }
+
+    if (thenable.status === 'rejected') {
+      throw thenable.reason;
+    } else if (thenable.status !== 'fulfilled') {
+      throw thenable;
+    }
+
+    const encodedFormData = thenable.value; // This is hacky but we need the identifier prefix to be added to
+    // all fields but the suspense cache would break since we might get
+    // a new identifier each time. So we just append it at the end instead.
+
+    const prefixedData = new FormData(); // $FlowFixMe[prop-missing]
+
+    encodedFormData.forEach((value, key) => {
+      prefixedData.append('$ACTION_' + identifierPrefix + ':' + key, value);
+    });
+    data = prefixedData; // We encode the name of the prefix containing the data.
+
+    name = '$ACTION_REF_' + identifierPrefix;
+  } else {
+    // This is the simple case so we can just encode the ID.
+    name = '$ACTION_ID_' + reference.id;
+  }
+
+  return {
+    name: name,
+    method: 'POST',
+    encType: 'multipart/form-data',
+    data: data
+  };
+}
+
+function isSignatureEqual(referenceId, numberOfBoundArgs) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  if (reference.id !== referenceId) {
+    // These are different functions.
+    return false;
+  } // Now check if the number of bound arguments is the same.
+
+
+  const boundPromise = reference.bound;
+
+  if (boundPromise === null) {
+    // No bound arguments.
+    return numberOfBoundArgs === 0;
+  } // Unwrap the bound arguments array by suspending, if necessary. As with
+  // encodeFormData, this means isSignatureEqual can only be called while React
+  // is rendering.
+
+
+  switch (boundPromise.status) {
+    case 'fulfilled':
+      {
+        const boundArgs = boundPromise.value;
+        return boundArgs.length === numberOfBoundArgs;
+      }
+
+    case 'pending':
+      {
+        throw boundPromise;
+      }
+
+    case 'rejected':
+      {
+        throw boundPromise.reason;
+      }
+
+    default:
+      {
+        if (typeof boundPromise.status === 'string') ; else {
+          const pendingThenable = boundPromise;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(boundArgs => {
+            const fulfilledThenable = boundPromise;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = boundArgs;
+          }, error => {
+            const rejectedThenable = boundPromise;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          });
+        }
+
+        throw boundPromise;
+      }
+  }
+}
+
+function registerServerReference(proxy, reference) {
+  // Expose encoder for use by SSR, as well as a special bind that can be used to
+  // keep server capabilities.
+  {
+    // Only expose this in builds that would actually use it. Not needed on the client.
+    Object.defineProperties(proxy, {
+      $$FORM_ACTION: {
+        value: encodeFormAction
+      },
+      $$IS_SIGNATURE_EQUAL: {
+        value: isSignatureEqual
+      },
+      bind: {
+        value: bind
+      }
+    });
+  }
+
+  knownServerReferences.set(proxy, reference);
+} // $FlowFixMe[method-unbinding]
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+  const reference = knownServerReferences.get(this);
+
+  if (reference) {
+    const args = ArraySlice.call(arguments, 1);
+    let boundPromise = null;
+
+    if (reference.bound !== null) {
+      boundPromise = Promise.resolve(reference.bound).then(boundArgs => boundArgs.concat(args));
+    } else {
+      boundPromise = Promise.resolve(args);
+    }
+
+    registerServerReference(newFn, {
+      id: reference.id,
+      bound: boundPromise
+    });
+  }
+
+  return newFn;
+}
+
+function createServerReference$1(id, callServer) {
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    return callServer(id, args);
+  };
+
+  registerServerReference(proxy, {
+    id,
+    bound: null
+  });
+  return proxy;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ROW_ID = 0;
+const ROW_TAG = 1;
+const ROW_LENGTH = 2;
+const ROW_CHUNK_BY_NEWLINE = 3;
+const ROW_CHUNK_BY_LENGTH = 4;
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const CYCLIC = 'cyclic';
+const RESOLVED_MODEL = 'resolved_model';
+const RESOLVED_MODULE = 'resolved_module';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function readChunk(chunk) {
+  // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      return chunk.value;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      // eslint-disable-next-line no-throw-literal
+      throw chunk;
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function createBlockedChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(BLOCKED, null, null, response);
+}
+
+function createErrorChunk(response, error) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(ERRORED, null, error, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function createResolvedModuleChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODULE, value, null, response);
+}
+
+function createInitializedTextChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function resolveModuleChunk(chunk, value) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODULE;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    initializeModuleChunk(resolvedChunk);
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+  const resolvedModel = chunk.value; // We go to the CYCLIC state until we've fully resolved this.
+  // We do this before parsing in case we try to initialize the same chunk
+  // while parsing the model. Such as in a cyclic reference.
+
+  const cyclicChunk = chunk;
+  cyclicChunk.status = CYCLIC;
+  cyclicChunk.value = null;
+  cyclicChunk.reason = null;
+
+  try {
+    const value = parseModel(chunk._response, resolvedModel);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const resolveListeners = cyclicChunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, value);
+      }
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+}
+
+function initializeModuleChunk(chunk) {
+  try {
+    const value = requireModule(chunk.value);
+    const initializedChunk = chunk;
+    initializedChunk.status = INITIALIZED;
+    initializedChunk.value = value;
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function createElement(type, key, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: null,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: null
+  };
+
+  return element;
+}
+
+function createLazyChunkWrapper(chunk) {
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: chunk,
+    _init: readChunk
+  };
+  return lazyType;
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunk = createPendingChunk(response);
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key, cyclic) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+
+    if (!cyclic) {
+      blocked.deps++;
+    }
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: cyclic ? 0 : 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function createServerReferenceProxy(response, metaData) {
+  const callServer = response._callServer;
+
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    const p = metaData.bound;
+
+    if (!p) {
+      return callServer(metaData.id, args);
+    }
+
+    if (p.status === INITIALIZED) {
+      const bound = p.value;
+      return callServer(metaData.id, bound.concat(args));
+    } // Since this is a fake Promise whose .then doesn't chain, we have to wrap it.
+    // TODO: Remove the wrapper once that's fixed.
+
+
+    return Promise.resolve(p).then(function (bound) {
+      return callServer(metaData.id, bound.concat(args));
+    });
+  };
+
+  registerServerReference(proxy, metaData);
+  return proxy;
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      {
+        return chunk.value;
+      }
+    // We always encode it first in the stream so it won't be pending.
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    if (value === '$') {
+      // A very common symbol.
+      return REACT_ELEMENT_TYPE;
+    }
+
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case 'L':
+        {
+          // Lazy node
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id); // We create a React.lazy wrapper around any lazy values.
+          // When passed into React, we'll know how to suspend on this.
+
+          return createLazyChunkWrapper(chunk);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'P':
+        {
+          // Server Context Provider
+          return getOrCreateServerContext(value.slice(2)).Provider;
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16);
+          const metadata = getOutlinedModel(response, id);
+          return createServerReferenceProxy(response, metadata);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+
+            case RESOLVED_MODULE:
+              initializeModuleChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+            case CYCLIC:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key, chunk.status === CYCLIC), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function parseModelTuple(response, value) {
+  const tuple = value;
+
+  if (tuple[0] === REACT_ELEMENT_TYPE) {
+    // TODO: Consider having React just directly accept these arrays as elements.
+    // Or even change the ReactElement type to be an array.
+    return createElement(tuple[1], tuple[2], tuple[3]);
+  }
+
+  return value;
+}
+
+function missingCall() {
+  throw new Error('Trying to call a function from "use server" but the callServer option ' + 'was not implemented in your router runtime.');
+}
+
+function createResponse(bundlerConfig, moduleLoading, callServer, nonce) {
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _moduleLoading: moduleLoading,
+    _callServer: callServer !== undefined ? callServer : missingCall,
+    _nonce: nonce,
+    _chunks: chunks,
+    _stringDecoder: createStringDecoder(),
+    _fromJSON: null,
+    _rowState: 0,
+    _rowID: 0,
+    _rowTag: 0,
+    _rowLength: 0,
+    _buffer: []
+  }; // Don't inline this call because it causes closure to outline the call above.
+
+  response._fromJSON = createFromJSONCallback(response);
+  return response;
+}
+
+function resolveModel(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createResolvedModelChunk(response, model));
+  } else {
+    resolveModelChunk(chunk, model);
+  }
+}
+
+function resolveText(response, id, text) {
+  const chunks = response._chunks; // We assume that we always reference large strings after they've been
+  // emitted.
+
+  chunks.set(id, createInitializedTextChunk(response, text));
+}
+
+function resolveModule(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+  const clientReferenceMetadata = parseModel(response, model);
+  const clientReference = resolveClientReference(response._bundlerConfig, clientReferenceMetadata);
+  prepareDestinationForModule(response._moduleLoading, response._nonce, clientReferenceMetadata); // TODO: Add an option to encode modules that are lazy loaded.
+  // For now we preload all modules as early as possible since it's likely
+  // that we'll need them.
+
+  const promise = preloadModule(clientReference);
+
+  if (promise) {
+    let blockedChunk;
+
+    if (!chunk) {
+      // Technically, we should just treat promise as the chunk in this
+      // case. Because it'll just behave as any other promise.
+      blockedChunk = createBlockedChunk(response);
+      chunks.set(id, blockedChunk);
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+    }
+
+    promise.then(() => resolveModuleChunk(blockedChunk, clientReference), error => triggerErrorOnChunk(blockedChunk, error));
+  } else {
+    if (!chunk) {
+      chunks.set(id, createResolvedModuleChunk(response, clientReference));
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      resolveModuleChunk(chunk, clientReference);
+    }
+  }
+}
+
+function resolveErrorProd(response, id, digest) {
+
+  const error = new Error('An error occurred in the Server Components render. The specific message is omitted in production' + ' builds to avoid leaking sensitive details. A digest property is included on this error instance which' + ' may provide additional details about the nature of the error.');
+  error.stack = 'Error: ' + error.message;
+  error.digest = digest;
+  const errorWithDigest = error;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, errorWithDigest));
+  } else {
+    triggerErrorOnChunk(chunk, errorWithDigest);
+  }
+}
+
+function resolveHint(response, code, model) {
+  const hintModel = parseModel(response, model);
+  dispatchHint(code, hintModel);
+}
+
+function processFullRow(response, id, tag, buffer, chunk) {
+
+  const stringDecoder = response._stringDecoder;
+  let row = '';
+
+  for (let i = 0; i < buffer.length; i++) {
+    row += readPartialStringChunk(stringDecoder, buffer[i]);
+  }
+
+  row += readFinalStringChunk(stringDecoder, chunk);
+
+  switch (tag) {
+    case 73
+    /* "I" */
+    :
+      {
+        resolveModule(response, id, row);
+        return;
+      }
+
+    case 72
+    /* "H" */
+    :
+      {
+        const code = row[0];
+        resolveHint(response, code, row.slice(1));
+        return;
+      }
+
+    case 69
+    /* "E" */
+    :
+      {
+        const errorInfo = JSON.parse(row);
+
+        {
+          resolveErrorProd(response, id, errorInfo.digest);
+        }
+
+        return;
+      }
+
+    case 84
+    /* "T" */
+    :
+      {
+        resolveText(response, id, row);
+        return;
+      }
+
+    case 80
+    /* "P" */
+    :
+    // Fallthrough
+
+    default:
+      /* """ "{" "[" "t" "f" "n" "0" - "9" */
+      {
+        // We assume anything else is JSON.
+        resolveModel(response, id, row);
+        return;
+      }
+  }
+}
+
+function processBinaryChunk(response, chunk) {
+  let i = 0;
+  let rowState = response._rowState;
+  let rowID = response._rowID;
+  let rowTag = response._rowTag;
+  let rowLength = response._rowLength;
+  const buffer = response._buffer;
+  const chunkLength = chunk.length;
+
+  while (i < chunkLength) {
+    let lastIdx = -1;
+
+    switch (rowState) {
+      case ROW_ID:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 58
+          /* ":" */
+          ) {
+              // Finished the rowID, next we'll parse the tag.
+              rowState = ROW_TAG;
+            } else {
+            rowID = rowID << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_TAG:
+        {
+          const resolvedRowTag = chunk[i];
+
+          if (resolvedRowTag === 84
+          /* "T" */
+          || enableBinaryFlight 
+          /* "V" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_LENGTH;
+              i++;
+            } else if (resolvedRowTag > 64 && resolvedRowTag < 91
+          /* "A"-"Z" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_CHUNK_BY_NEWLINE;
+              i++;
+            } else {
+            rowTag = 0;
+            rowState = ROW_CHUNK_BY_NEWLINE; // This was an unknown tag so it was probably part of the data.
+          }
+
+          continue;
+        }
+
+      case ROW_LENGTH:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 44
+          /* "," */
+          ) {
+              // Finished the rowLength, next we'll buffer up to that length.
+              rowState = ROW_CHUNK_BY_LENGTH;
+            } else {
+            rowLength = rowLength << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_CHUNK_BY_NEWLINE:
+        {
+          // We're looking for a newline
+          lastIdx = chunk.indexOf(10
+          /* "\n" */
+          , i);
+          break;
+        }
+
+      case ROW_CHUNK_BY_LENGTH:
+        {
+          // We're looking for the remaining byte length
+          lastIdx = i + rowLength;
+
+          if (lastIdx > chunk.length) {
+            lastIdx = -1;
+          }
+
+          break;
+        }
+    }
+
+    const offset = chunk.byteOffset + i;
+
+    if (lastIdx > -1) {
+      // We found the last chunk of the row
+      const length = lastIdx - i;
+      const lastChunk = new Uint8Array(chunk.buffer, offset, length);
+      processFullRow(response, rowID, rowTag, buffer, lastChunk); // Reset state machine for a new row
+
+      i = lastIdx;
+
+      if (rowState === ROW_CHUNK_BY_NEWLINE) {
+        // If we're trailing by a newline we need to skip it.
+        i++;
+      }
+
+      rowState = ROW_ID;
+      rowTag = 0;
+      rowID = 0;
+      rowLength = 0;
+      buffer.length = 0;
+    } else {
+      // The rest of this row is in a future chunk. We stash the rest of the
+      // current chunk until we can process the full row.
+      const length = chunk.byteLength - i;
+      const remainingSlice = new Uint8Array(chunk.buffer, offset, length);
+      buffer.push(remainingSlice); // Update how many bytes we're still waiting for. If we're looking for
+      // a newline, this doesn't hurt since we'll just ignore it.
+
+      rowLength -= remainingSlice.byteLength;
+      break;
+    }
+  }
+
+  response._rowState = rowState;
+  response._rowID = rowID;
+  response._rowTag = rowTag;
+  response._rowLength = rowLength;
+}
+
+function parseModel(response, json) {
+  return JSON.parse(json, response._fromJSON);
+}
+
+function createFromJSONCallback(response) {
+  // $FlowFixMe[missing-this-annot]
+  return function (key, value) {
+    if (typeof value === 'string') {
+      // We can't use .bind here because we need the "this" value.
+      return parseModelString(response, this, key, value);
+    }
+
+    if (typeof value === 'object' && value !== null) {
+      return parseModelTuple(response, value);
+    }
+
+    return value;
+  };
+}
+
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function noServerCall() {
+  throw new Error('Server Functions cannot be called during initial render. ' + 'This would create a fetch waterfall. Try to use a Server Component ' + 'to pass data to Client Components instead.');
+}
+
+function createServerReference(id, callServer) {
+  return createServerReference$1(id, noServerCall);
+}
+
+function createFromNodeStream(stream, ssrManifest, options) {
+  const response = createResponse(ssrManifest.moduleMap, ssrManifest.moduleLoading, noServerCall, options && typeof options.nonce === 'string' ? options.nonce : undefined);
+  stream.on('data', chunk => {
+    processBinaryChunk(response, chunk);
+  });
+  stream.on('error', error => {
+    reportGlobalError(response, error);
+  });
+  stream.on('end', () => close(response));
+  return getRoot(response);
+}
+
+exports.createFromNodeStream = createFromNodeStream;
+exports.createServerReference = createServerReference;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.node.production.min.js b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.node.production.min.js
index 2d3274320b65a..dfeb36656b3d6 100644
--- a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.node.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.node.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-webpack-client.node.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-webpack-client.node.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var p=require("util"),r=require("react-dom"),u=require("react"),v={stream:!0};function w(a,b){if(a){var c=a[b[0]];if(a=c[b[2]])c=a.name;else{a=c["*"];if(!a)throw Error('Could not find the module "'+b[0]+'" in the React SSR Manifest. This is probably a bug in the React Server Components bundler.');c=b[2]}return 4===b.length?[a.id,a.chunks,c,1]:[a.id,a.chunks,c]}return b}var x=new Map;
 function y(a){var b=globalThis.__next_require__(a);if("function"!==typeof b.then||"fulfilled"===b.status)return null;b.then(function(c){b.status="fulfilled";b.value=c},function(c){b.status="rejected";b.reason=c});return b}function z(){}
 function A(a){for(var b=a[1],c=[],d=0;d<b.length;){var g=b[d++];b[d++];var h=x.get(g);if(void 0===h){h=__webpack_chunk_load__(g);c.push(h);var l=x.set.bind(x,g,null);h.then(l,z);x.set(g,h)}else null!==h&&c.push(h)}return 4===a.length?0===c.length?y(a[0]):Promise.all(c).then(function(){return y(a[0])}):0<c.length?Promise.all(c):null}
@@ -39,3 +39,5 @@ h+f,m>g.length&&(m=-1)}var n=g.byteOffset+h;if(-1<m){f=new Uint8Array(g.buffer,n
 f.preloadModule(e):f.preloadModule(e[0],e[1]);break;case "S":"string"===typeof e?f.preinitStyle(e):f.preinitStyle(e[0],0===e[1]?void 0:e[1],3===e.length?e[2]:void 0);break;case "X":"string"===typeof e?f.preinitScript(e):f.preinitScript(e[0],e[1]);break;case "M":"string"===typeof e?f.preinitModuleScript(e):f.preinitModuleScript(e[0],e[1])}break;case 69:e=JSON.parse(e);f=e.digest;e=Error("An error occurred in the Server Components render. The specific message is omitted in production builds to avoid leaking sensitive details. A digest property is included on this error instance which may provide additional details about the nature of the error.");
 e.stack="Error: "+e.message;e.digest=f;f=d._chunks;(h=f.get(k))?S(h,e):f.set(k,new N("rejected",null,e,d));break;case 84:d._chunks.set(k,new N("fulfilled",e,null,d));break;default:f=d._chunks,(h=f.get(k))?(k=h,"pending"===k.status&&(f=k.value,h=k.reason,k.status="resolved_model",k.value=e,null!==f&&(O(k),R(k,f,h)))):f.set(k,new N("resolved_model",e,null,d))}h=m;3===l&&h++;f=k=e=l=0;t.length=0}else{g=new Uint8Array(g.buffer,n,g.byteLength-h);t.push(g);f-=g.byteLength;break}}d._rowState=l;d._rowID=
 k;d._rowTag=e;d._rowLength=f});a.on("error",function(g){W(d,g)});a.on("end",function(){W(d,Error("Connection closed."))});return X(d,0)};exports.createServerReference=function(a){return oa(a,Z)};
+
+//# sourceMappingURL=react-server-dom-webpack-client.node.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.node.unbundled.production.js b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.node.unbundled.production.js
new file mode 100644
index 0000000000000..22b927976c89b
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.node.unbundled.production.js
@@ -0,0 +1,1760 @@
+/**
+ * @license React
+ * react-server-dom-webpack-client.node.unbundled.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var util = require('util');
+var ReactDOM = require('react-dom');
+var React = require('react');
+
+// -----------------------------------------------------------------------------
+const enableBinaryFlight = false;
+
+function createStringDecoder() {
+  return new util.TextDecoder();
+}
+const decoderOptions = {
+  stream: true
+};
+function readPartialStringChunk(decoder, buffer) {
+  return decoder.decode(buffer, decoderOptions);
+}
+function readFinalStringChunk(decoder, buffer) {
+  return decoder.decode(buffer);
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+// The reason this function needs to defined here in this file instead of just
+// being exported directly from the WebpackDestination... file is because the
+// ClientReferenceMetadata is opaque and we can't unwrap it there.
+// This should get inlined and we could also just implement an unwrapping function
+// though that risks it getting used in places it shouldn't be. This is unfortunate
+// but currently it seems to be the best option we have.
+
+function prepareDestinationForModule(moduleLoading, nonce, metadata) {
+  prepareDestinationWithChunks(moduleLoading, metadata[CHUNKS], nonce);
+}
+function resolveClientReference(bundlerConfig, metadata) {
+  const moduleExports = bundlerConfig[metadata[ID]];
+  let resolvedModuleData = moduleExports[metadata[NAME]];
+  let name;
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // If we don't have this specific name, we might have the full module.
+    resolvedModuleData = moduleExports['*'];
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + metadata[ID] + '" in the React SSR Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+
+    name = metadata[NAME];
+  }
+
+  return {
+    specifier: resolvedModuleData.specifier,
+    name: name,
+    async: isAsyncImport(metadata)
+  };
+}
+const asyncModuleCache = new Map();
+function preloadModule(metadata) {
+  const existingPromise = asyncModuleCache.get(metadata.specifier);
+
+  if (existingPromise) {
+    if (existingPromise.status === 'fulfilled') {
+      return null;
+    }
+
+    return existingPromise;
+  } else {
+    // $FlowFixMe[unsupported-syntax]
+    let modulePromise = import(metadata.specifier);
+
+    if (metadata.async) {
+      // If the module is async, it must have been a CJS module.
+      // CJS modules are accessed through the default export in
+      // Node.js so we have to get the default export to get the
+      // full module exports.
+      modulePromise = modulePromise.then(function (value) {
+        return value.default;
+      });
+    }
+
+    modulePromise.then(value => {
+      const fulfilledThenable = modulePromise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = modulePromise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    asyncModuleCache.set(metadata.specifier, modulePromise);
+    return modulePromise;
+  }
+}
+function requireModule(metadata) {
+  let moduleExports; // We assume that preloadModule has been called before, which
+  // should have added something to the module cache.
+
+  const promise = asyncModuleCache.get(metadata.specifier);
+
+  if (promise.status === 'fulfilled') {
+    moduleExports = promise.value;
+  } else {
+    throw promise.reason;
+  }
+
+  if (metadata.name === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata.name === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.default;
+  }
+
+  return moduleExports[metadata.name];
+}
+
+function prepareDestinationWithChunks(moduleLoading, // Chunks are double-indexed [..., idx, filenamex, idy, filenamey, ...]
+chunks, nonce) {
+  if (moduleLoading !== null) {
+    for (let i = 1; i < chunks.length; i += 2) {
+      preinitScriptForSSR(moduleLoading.prefix + chunks[i], nonce, moduleLoading.crossOrigin);
+    }
+  }
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+function getCrossOriginString(input) {
+  if (typeof input === 'string') {
+    return input === 'use-credentials' ? input : '';
+  }
+
+  return undefined;
+}
+
+// This client file is in the shared folder because it applies to both SSR and browser contexts.
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function dispatchHint(code, model) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    switch (code) {
+      case 'D':
+        {
+          const refined = refineModel(code, model);
+          const href = refined;
+          dispatcher.prefetchDNS(href);
+          return;
+        }
+
+      case 'C':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preconnect(href);
+          } else {
+            const href = refined[0];
+            const crossOrigin = refined[1];
+            dispatcher.preconnect(href, crossOrigin);
+          }
+
+          return;
+        }
+
+      case 'L':
+        {
+          const refined = refineModel(code, model);
+          const href = refined[0];
+          const as = refined[1];
+
+          if (refined.length === 3) {
+            const options = refined[2];
+            dispatcher.preload(href, as, options);
+          } else {
+            dispatcher.preload(href, as);
+          }
+
+          return;
+        }
+
+      case 'm':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preloadModule(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preloadModule(href, options);
+          }
+
+          return;
+        }
+
+      case 'S':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitStyle(href);
+          } else {
+            const href = refined[0];
+            const precedence = refined[1] === 0 ? undefined : refined[1];
+            const options = refined.length === 3 ? refined[2] : undefined;
+            dispatcher.preinitStyle(href, precedence, options);
+          }
+
+          return;
+        }
+
+      case 'X':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitScript(href, options);
+          }
+
+          return;
+        }
+
+      case 'M':
+        {
+          const refined = refineModel(code, model);
+
+          if (typeof refined === 'string') {
+            const href = refined;
+            dispatcher.preinitModuleScript(href);
+          } else {
+            const href = refined[0];
+            const options = refined[1];
+            dispatcher.preinitModuleScript(href, options);
+          }
+
+          return;
+        }
+    }
+  }
+} // Flow is having troulbe refining the HintModels so we help it a bit.
+// This should be compiled out in the production build.
+
+function refineModel(code, model) {
+  return model;
+}
+function preinitScriptForSSR(href, nonce, crossOrigin) {
+  const dispatcher = ReactDOMCurrentDispatcher.current;
+
+  if (dispatcher) {
+    dispatcher.preinitScript(href, {
+      crossOrigin: getCrossOriginString(crossOrigin),
+      nonce
+    });
+  }
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+const ObjectPrototype = Object.prototype;
+const knownServerReferences = new WeakMap(); // Serializable values
+// Thenable<ReactServerValue>
+// function serializeByValueID(id: number): string {
+//   return '$' + id.toString(16);
+// }
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeFormDataReference(id) {
+  // Why K? F is "Function". D is "Date". What else?
+  return '$K' + id.toString(16);
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeMapID(id) {
+  return '$Q' + id.toString(16);
+}
+
+function serializeSetID(id) {
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+
+function processReply(root, formFieldPrefix, resolve, reject) {
+  let nextPartId = 1;
+  let pendingParts = 0;
+  let formData = null;
+
+  function resolveToJSON(key, value) {
+    const parent = this; // Make sure that `parent[key]` wasn't JSONified before `value` was passed to us
+
+    if (value === null) {
+      return null;
+    }
+
+    if (typeof value === 'object') {
+      // $FlowFixMe[method-unbinding]
+      if (typeof value.then === 'function') {
+        // We assume that any object with a .then property is a "Thenable" type,
+        // or a Promise type. Either of which can be represented by a Promise.
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        }
+
+        pendingParts++;
+        const promiseId = nextPartId++;
+        const thenable = value;
+        thenable.then(partValue => {
+          const partJSON = JSON.stringify(partValue, resolveToJSON); // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
+
+          const data = formData; // eslint-disable-next-line react-internal/safe-string-coercion
+
+          data.append(formFieldPrefix + promiseId, partJSON);
+          pendingParts--;
+
+          if (pendingParts === 0) {
+            resolve(data);
+          }
+        }, reason => {
+          // In the future we could consider serializing this as an error
+          // that throws on the server instead.
+          reject(reason);
+        });
+        return serializePromiseID(promiseId);
+      }
+
+      if (isArray(value)) {
+        // $FlowFixMe[incompatible-return]
+        return value;
+      } // TODO: Should we the Object.prototype.toString.call() to test for cross-realm objects?
+
+
+      if (value instanceof FormData) {
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to use rich objects as its values.
+          formData = new FormData();
+        }
+
+        const data = formData;
+        const refId = nextPartId++; // Copy all the form fields with a prefix for this reference.
+        // These must come first in the form order because we assume that all the
+        // fields are available before this is referenced.
+
+        const prefix = formFieldPrefix + refId + '_'; // $FlowFixMe[prop-missing]: FormData has forEach.
+
+        value.forEach((originalValue, originalKey) => {
+          data.append(prefix + originalKey, originalValue);
+        });
+        return serializeFormDataReference(refId);
+      }
+
+      if (value instanceof Map) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const mapId = nextPartId++;
+        formData.append(formFieldPrefix + mapId, partJSON);
+        return serializeMapID(mapId);
+      }
+
+      if (value instanceof Set) {
+        const partJSON = JSON.stringify(Array.from(value), resolveToJSON);
+
+        if (formData === null) {
+          formData = new FormData();
+        }
+
+        const setId = nextPartId++;
+        formData.append(formFieldPrefix + setId, partJSON);
+        return serializeSetID(setId);
+      }
+
+      const iteratorFn = getIteratorFn(value);
+
+      if (iteratorFn) {
+        return Array.from(value);
+      } // Verify that this is a simple plain object.
+
+
+      const proto = getPrototypeOf(value);
+
+      if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+        throw new Error('Only plain objects, and a few built-ins, can be passed to Server Actions. ' + 'Classes or null prototypes are not supported.');
+      }
+
+
+      return value;
+    }
+
+    if (typeof value === 'string') {
+      // TODO: Maybe too clever. If we support URL there's no similar trick.
+      if (value[value.length - 1] === 'Z') {
+        // Possibly a Date, whose toJSON automatically calls toISOString
+        // $FlowFixMe[incompatible-use]
+        const originalValue = parent[key];
+
+        if (originalValue instanceof Date) {
+          return serializeDateFromDateJSON(value);
+        }
+      }
+
+      return escapeStringValue(value);
+    }
+
+    if (typeof value === 'boolean') {
+      return value;
+    }
+
+    if (typeof value === 'number') {
+      return serializeNumber(value);
+    }
+
+    if (typeof value === 'undefined') {
+      return serializeUndefined();
+    }
+
+    if (typeof value === 'function') {
+      const metaData = knownServerReferences.get(value);
+
+      if (metaData !== undefined) {
+        const metaDataJSON = JSON.stringify(metaData, resolveToJSON);
+
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        } // The reference to this function came from the same client so we can pass it back.
+
+
+        const refId = nextPartId++; // eslint-disable-next-line react-internal/safe-string-coercion
+
+        formData.set(formFieldPrefix + refId, metaDataJSON);
+        return serializeServerReferenceID(refId);
+      }
+
+      throw new Error('Client Functions cannot be passed directly to Server Functions. ' + 'Only Functions passed from the Server can be passed back again.');
+    }
+
+    if (typeof value === 'symbol') {
+      // $FlowFixMe[incompatible-type] `description` might be undefined
+      const name = value.description;
+
+      if (Symbol.for(name) !== value) {
+        throw new Error('Only global symbols received from Symbol.for(...) can be passed to Server Functions. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+        value.description + ") cannot be found among global symbols."));
+      }
+
+      return serializeSymbolReference(name);
+    }
+
+    if (typeof value === 'bigint') {
+      return serializeBigInt(value);
+    }
+
+    throw new Error("Type " + typeof value + " is not supported as an argument to a Server Function.");
+  } // $FlowFixMe[incompatible-type] it's not going to be undefined because we'll encode it.
+
+
+  const json = JSON.stringify(root, resolveToJSON);
+
+  if (formData === null) {
+    // If it's a simple data structure, we just use plain JSON.
+    resolve(json);
+  } else {
+    // Otherwise, we use FormData to let us stream in the result.
+    formData.set(formFieldPrefix + '0', json);
+
+    if (pendingParts === 0) {
+      // $FlowFixMe[incompatible-call] this has already been refined.
+      resolve(formData);
+    }
+  }
+}
+const boundCache = new WeakMap();
+
+function encodeFormData(reference) {
+  let resolve, reject; // We need to have a handle on the thenable so that we can synchronously set
+  // its status from processReply, when it can complete synchronously.
+
+  const thenable = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  processReply(reference, '', body => {
+    if (typeof body === 'string') {
+      const data = new FormData();
+      data.append('0', body);
+      body = data;
+    }
+
+    const fulfilled = thenable;
+    fulfilled.status = 'fulfilled';
+    fulfilled.value = body;
+    resolve(body);
+  }, e => {
+    const rejected = thenable;
+    rejected.status = 'rejected';
+    rejected.reason = e;
+    reject(e);
+  });
+  return thenable;
+}
+
+function encodeFormAction(identifierPrefix) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  let data = null;
+  let name;
+  const boundPromise = reference.bound;
+
+  if (boundPromise !== null) {
+    let thenable = boundCache.get(reference);
+
+    if (!thenable) {
+      thenable = encodeFormData(reference);
+      boundCache.set(reference, thenable);
+    }
+
+    if (thenable.status === 'rejected') {
+      throw thenable.reason;
+    } else if (thenable.status !== 'fulfilled') {
+      throw thenable;
+    }
+
+    const encodedFormData = thenable.value; // This is hacky but we need the identifier prefix to be added to
+    // all fields but the suspense cache would break since we might get
+    // a new identifier each time. So we just append it at the end instead.
+
+    const prefixedData = new FormData(); // $FlowFixMe[prop-missing]
+
+    encodedFormData.forEach((value, key) => {
+      prefixedData.append('$ACTION_' + identifierPrefix + ':' + key, value);
+    });
+    data = prefixedData; // We encode the name of the prefix containing the data.
+
+    name = '$ACTION_REF_' + identifierPrefix;
+  } else {
+    // This is the simple case so we can just encode the ID.
+    name = '$ACTION_ID_' + reference.id;
+  }
+
+  return {
+    name: name,
+    method: 'POST',
+    encType: 'multipart/form-data',
+    data: data
+  };
+}
+
+function isSignatureEqual(referenceId, numberOfBoundArgs) {
+  const reference = knownServerReferences.get(this);
+
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
+
+  if (reference.id !== referenceId) {
+    // These are different functions.
+    return false;
+  } // Now check if the number of bound arguments is the same.
+
+
+  const boundPromise = reference.bound;
+
+  if (boundPromise === null) {
+    // No bound arguments.
+    return numberOfBoundArgs === 0;
+  } // Unwrap the bound arguments array by suspending, if necessary. As with
+  // encodeFormData, this means isSignatureEqual can only be called while React
+  // is rendering.
+
+
+  switch (boundPromise.status) {
+    case 'fulfilled':
+      {
+        const boundArgs = boundPromise.value;
+        return boundArgs.length === numberOfBoundArgs;
+      }
+
+    case 'pending':
+      {
+        throw boundPromise;
+      }
+
+    case 'rejected':
+      {
+        throw boundPromise.reason;
+      }
+
+    default:
+      {
+        if (typeof boundPromise.status === 'string') ; else {
+          const pendingThenable = boundPromise;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(boundArgs => {
+            const fulfilledThenable = boundPromise;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = boundArgs;
+          }, error => {
+            const rejectedThenable = boundPromise;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          });
+        }
+
+        throw boundPromise;
+      }
+  }
+}
+
+function registerServerReference(proxy, reference) {
+  // Expose encoder for use by SSR, as well as a special bind that can be used to
+  // keep server capabilities.
+  {
+    // Only expose this in builds that would actually use it. Not needed on the client.
+    Object.defineProperties(proxy, {
+      $$FORM_ACTION: {
+        value: encodeFormAction
+      },
+      $$IS_SIGNATURE_EQUAL: {
+        value: isSignatureEqual
+      },
+      bind: {
+        value: bind
+      }
+    });
+  }
+
+  knownServerReferences.set(proxy, reference);
+} // $FlowFixMe[method-unbinding]
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+  const reference = knownServerReferences.get(this);
+
+  if (reference) {
+    const args = ArraySlice.call(arguments, 1);
+    let boundPromise = null;
+
+    if (reference.bound !== null) {
+      boundPromise = Promise.resolve(reference.bound).then(boundArgs => boundArgs.concat(args));
+    } else {
+      boundPromise = Promise.resolve(args);
+    }
+
+    registerServerReference(newFn, {
+      id: reference.id,
+      bound: boundPromise
+    });
+  }
+
+  return newFn;
+}
+
+function createServerReference$1(id, callServer) {
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    return callServer(id, args);
+  };
+
+  registerServerReference(proxy, {
+    id,
+    bound: null
+  });
+  return proxy;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    const context = {
+      $$typeof: REACT_SERVER_CONTEXT_TYPE,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      _defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null,
+      _globalName: globalName
+    };
+    context.Provider = {
+      $$typeof: REACT_PROVIDER_TYPE,
+      _context: context
+    };
+
+    ContextRegistry[globalName] = context;
+  }
+
+  return ContextRegistry[globalName];
+}
+
+const ROW_ID = 0;
+const ROW_TAG = 1;
+const ROW_LENGTH = 2;
+const ROW_CHUNK_BY_NEWLINE = 3;
+const ROW_CHUNK_BY_LENGTH = 4;
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const CYCLIC = 'cyclic';
+const RESOLVED_MODEL = 'resolved_model';
+const RESOLVED_MODULE = 'resolved_module';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function readChunk(chunk) {
+  // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      return chunk.value;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      // eslint-disable-next-line no-throw-literal
+      throw chunk;
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function createBlockedChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(BLOCKED, null, null, response);
+}
+
+function createErrorChunk(response, error) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(ERRORED, null, error, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function createResolvedModuleChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODULE, value, null, response);
+}
+
+function createInitializedTextChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(INITIALIZED, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function resolveModuleChunk(chunk, value) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODULE;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    initializeModuleChunk(resolvedChunk);
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+  const resolvedModel = chunk.value; // We go to the CYCLIC state until we've fully resolved this.
+  // We do this before parsing in case we try to initialize the same chunk
+  // while parsing the model. Such as in a cyclic reference.
+
+  const cyclicChunk = chunk;
+  cyclicChunk.status = CYCLIC;
+  cyclicChunk.value = null;
+  cyclicChunk.reason = null;
+
+  try {
+    const value = parseModel(chunk._response, resolvedModel);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const resolveListeners = cyclicChunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, value);
+      }
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+}
+
+function initializeModuleChunk(chunk) {
+  try {
+    const value = requireModule(chunk.value);
+    const initializedChunk = chunk;
+    initializedChunk.status = INITIALIZED;
+    initializedChunk.value = value;
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function createElement(type, key, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: null,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: null
+  };
+
+  return element;
+}
+
+function createLazyChunkWrapper(chunk) {
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: chunk,
+    _init: readChunk
+  };
+  return lazyType;
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunk = createPendingChunk(response);
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key, cyclic) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+
+    if (!cyclic) {
+      blocked.deps++;
+    }
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: cyclic ? 0 : 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function createServerReferenceProxy(response, metaData) {
+  const callServer = response._callServer;
+
+  const proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    const args = Array.prototype.slice.call(arguments);
+    const p = metaData.bound;
+
+    if (!p) {
+      return callServer(metaData.id, args);
+    }
+
+    if (p.status === INITIALIZED) {
+      const bound = p.value;
+      return callServer(metaData.id, bound.concat(args));
+    } // Since this is a fake Promise whose .then doesn't chain, we have to wrap it.
+    // TODO: Remove the wrapper once that's fixed.
+
+
+    return Promise.resolve(p).then(function (bound) {
+      return callServer(metaData.id, bound.concat(args));
+    });
+  };
+
+  registerServerReference(proxy, metaData);
+  return proxy;
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      {
+        return chunk.value;
+      }
+    // We always encode it first in the stream so it won't be pending.
+
+    default:
+      throw chunk.reason;
+  }
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    if (value === '$') {
+      // A very common symbol.
+      return REACT_ELEMENT_TYPE;
+    }
+
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case 'L':
+        {
+          // Lazy node
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id); // We create a React.lazy wrapper around any lazy values.
+          // When passed into React, we'll know how to suspend on this.
+
+          return createLazyChunkWrapper(chunk);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'P':
+        {
+          // Server Context Provider
+          return getOrCreateServerContext(value.slice(2)).Provider;
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16);
+          const metadata = getOutlinedModel(response, id);
+          return createServerReferenceProxy(response, metadata);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+
+            case RESOLVED_MODULE:
+              initializeModuleChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+            case CYCLIC:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key, chunk.status === CYCLIC), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function parseModelTuple(response, value) {
+  const tuple = value;
+
+  if (tuple[0] === REACT_ELEMENT_TYPE) {
+    // TODO: Consider having React just directly accept these arrays as elements.
+    // Or even change the ReactElement type to be an array.
+    return createElement(tuple[1], tuple[2], tuple[3]);
+  }
+
+  return value;
+}
+
+function missingCall() {
+  throw new Error('Trying to call a function from "use server" but the callServer option ' + 'was not implemented in your router runtime.');
+}
+
+function createResponse(bundlerConfig, moduleLoading, callServer, nonce) {
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _moduleLoading: moduleLoading,
+    _callServer: callServer !== undefined ? callServer : missingCall,
+    _nonce: nonce,
+    _chunks: chunks,
+    _stringDecoder: createStringDecoder(),
+    _fromJSON: null,
+    _rowState: 0,
+    _rowID: 0,
+    _rowTag: 0,
+    _rowLength: 0,
+    _buffer: []
+  }; // Don't inline this call because it causes closure to outline the call above.
+
+  response._fromJSON = createFromJSONCallback(response);
+  return response;
+}
+
+function resolveModel(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createResolvedModelChunk(response, model));
+  } else {
+    resolveModelChunk(chunk, model);
+  }
+}
+
+function resolveText(response, id, text) {
+  const chunks = response._chunks; // We assume that we always reference large strings after they've been
+  // emitted.
+
+  chunks.set(id, createInitializedTextChunk(response, text));
+}
+
+function resolveModule(response, id, model) {
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+  const clientReferenceMetadata = parseModel(response, model);
+  const clientReference = resolveClientReference(response._bundlerConfig, clientReferenceMetadata);
+  prepareDestinationForModule(response._moduleLoading, response._nonce, clientReferenceMetadata); // TODO: Add an option to encode modules that are lazy loaded.
+  // For now we preload all modules as early as possible since it's likely
+  // that we'll need them.
+
+  const promise = preloadModule(clientReference);
+
+  if (promise) {
+    let blockedChunk;
+
+    if (!chunk) {
+      // Technically, we should just treat promise as the chunk in this
+      // case. Because it'll just behave as any other promise.
+      blockedChunk = createBlockedChunk(response);
+      chunks.set(id, blockedChunk);
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+    }
+
+    promise.then(() => resolveModuleChunk(blockedChunk, clientReference), error => triggerErrorOnChunk(blockedChunk, error));
+  } else {
+    if (!chunk) {
+      chunks.set(id, createResolvedModuleChunk(response, clientReference));
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      resolveModuleChunk(chunk, clientReference);
+    }
+  }
+}
+
+function resolveErrorProd(response, id, digest) {
+
+  const error = new Error('An error occurred in the Server Components render. The specific message is omitted in production' + ' builds to avoid leaking sensitive details. A digest property is included on this error instance which' + ' may provide additional details about the nature of the error.');
+  error.stack = 'Error: ' + error.message;
+  error.digest = digest;
+  const errorWithDigest = error;
+  const chunks = response._chunks;
+  const chunk = chunks.get(id);
+
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, errorWithDigest));
+  } else {
+    triggerErrorOnChunk(chunk, errorWithDigest);
+  }
+}
+
+function resolveHint(response, code, model) {
+  const hintModel = parseModel(response, model);
+  dispatchHint(code, hintModel);
+}
+
+function processFullRow(response, id, tag, buffer, chunk) {
+
+  const stringDecoder = response._stringDecoder;
+  let row = '';
+
+  for (let i = 0; i < buffer.length; i++) {
+    row += readPartialStringChunk(stringDecoder, buffer[i]);
+  }
+
+  row += readFinalStringChunk(stringDecoder, chunk);
+
+  switch (tag) {
+    case 73
+    /* "I" */
+    :
+      {
+        resolveModule(response, id, row);
+        return;
+      }
+
+    case 72
+    /* "H" */
+    :
+      {
+        const code = row[0];
+        resolveHint(response, code, row.slice(1));
+        return;
+      }
+
+    case 69
+    /* "E" */
+    :
+      {
+        const errorInfo = JSON.parse(row);
+
+        {
+          resolveErrorProd(response, id, errorInfo.digest);
+        }
+
+        return;
+      }
+
+    case 84
+    /* "T" */
+    :
+      {
+        resolveText(response, id, row);
+        return;
+      }
+
+    case 80
+    /* "P" */
+    :
+    // Fallthrough
+
+    default:
+      /* """ "{" "[" "t" "f" "n" "0" - "9" */
+      {
+        // We assume anything else is JSON.
+        resolveModel(response, id, row);
+        return;
+      }
+  }
+}
+
+function processBinaryChunk(response, chunk) {
+  let i = 0;
+  let rowState = response._rowState;
+  let rowID = response._rowID;
+  let rowTag = response._rowTag;
+  let rowLength = response._rowLength;
+  const buffer = response._buffer;
+  const chunkLength = chunk.length;
+
+  while (i < chunkLength) {
+    let lastIdx = -1;
+
+    switch (rowState) {
+      case ROW_ID:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 58
+          /* ":" */
+          ) {
+              // Finished the rowID, next we'll parse the tag.
+              rowState = ROW_TAG;
+            } else {
+            rowID = rowID << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_TAG:
+        {
+          const resolvedRowTag = chunk[i];
+
+          if (resolvedRowTag === 84
+          /* "T" */
+          || enableBinaryFlight 
+          /* "V" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_LENGTH;
+              i++;
+            } else if (resolvedRowTag > 64 && resolvedRowTag < 91
+          /* "A"-"Z" */
+          ) {
+              rowTag = resolvedRowTag;
+              rowState = ROW_CHUNK_BY_NEWLINE;
+              i++;
+            } else {
+            rowTag = 0;
+            rowState = ROW_CHUNK_BY_NEWLINE; // This was an unknown tag so it was probably part of the data.
+          }
+
+          continue;
+        }
+
+      case ROW_LENGTH:
+        {
+          const byte = chunk[i++];
+
+          if (byte === 44
+          /* "," */
+          ) {
+              // Finished the rowLength, next we'll buffer up to that length.
+              rowState = ROW_CHUNK_BY_LENGTH;
+            } else {
+            rowLength = rowLength << 4 | (byte > 96 ? byte - 87 : byte - 48);
+          }
+
+          continue;
+        }
+
+      case ROW_CHUNK_BY_NEWLINE:
+        {
+          // We're looking for a newline
+          lastIdx = chunk.indexOf(10
+          /* "\n" */
+          , i);
+          break;
+        }
+
+      case ROW_CHUNK_BY_LENGTH:
+        {
+          // We're looking for the remaining byte length
+          lastIdx = i + rowLength;
+
+          if (lastIdx > chunk.length) {
+            lastIdx = -1;
+          }
+
+          break;
+        }
+    }
+
+    const offset = chunk.byteOffset + i;
+
+    if (lastIdx > -1) {
+      // We found the last chunk of the row
+      const length = lastIdx - i;
+      const lastChunk = new Uint8Array(chunk.buffer, offset, length);
+      processFullRow(response, rowID, rowTag, buffer, lastChunk); // Reset state machine for a new row
+
+      i = lastIdx;
+
+      if (rowState === ROW_CHUNK_BY_NEWLINE) {
+        // If we're trailing by a newline we need to skip it.
+        i++;
+      }
+
+      rowState = ROW_ID;
+      rowTag = 0;
+      rowID = 0;
+      rowLength = 0;
+      buffer.length = 0;
+    } else {
+      // The rest of this row is in a future chunk. We stash the rest of the
+      // current chunk until we can process the full row.
+      const length = chunk.byteLength - i;
+      const remainingSlice = new Uint8Array(chunk.buffer, offset, length);
+      buffer.push(remainingSlice); // Update how many bytes we're still waiting for. If we're looking for
+      // a newline, this doesn't hurt since we'll just ignore it.
+
+      rowLength -= remainingSlice.byteLength;
+      break;
+    }
+  }
+
+  response._rowState = rowState;
+  response._rowID = rowID;
+  response._rowTag = rowTag;
+  response._rowLength = rowLength;
+}
+
+function parseModel(response, json) {
+  return JSON.parse(json, response._fromJSON);
+}
+
+function createFromJSONCallback(response) {
+  // $FlowFixMe[missing-this-annot]
+  return function (key, value) {
+    if (typeof value === 'string') {
+      // We can't use .bind here because we need the "this" value.
+      return parseModelString(response, this, key, value);
+    }
+
+    if (typeof value === 'object' && value !== null) {
+      return parseModelTuple(response, value);
+    }
+
+    return value;
+  };
+}
+
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function noServerCall() {
+  throw new Error('Server Functions cannot be called during initial render. ' + 'This would create a fetch waterfall. Try to use a Server Component ' + 'to pass data to Client Components instead.');
+}
+
+function createServerReference(id, callServer) {
+  return createServerReference$1(id, noServerCall);
+}
+
+function createFromNodeStream(stream, ssrManifest, options) {
+  const response = createResponse(ssrManifest.moduleMap, ssrManifest.moduleLoading, noServerCall, options && typeof options.nonce === 'string' ? options.nonce : undefined);
+  stream.on('data', chunk => {
+    processBinaryChunk(response, chunk);
+  });
+  stream.on('error', error => {
+    reportGlobalError(response, error);
+  });
+  stream.on('end', () => close(response));
+  return getRoot(response);
+}
+
+exports.createFromNodeStream = createFromNodeStream;
+exports.createServerReference = createServerReference;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.node.unbundled.production.min.js b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.node.unbundled.production.min.js
index e5755da5faa4a..0b8079e7e3a48 100644
--- a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.node.unbundled.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-client.node.unbundled.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-webpack-client.node.unbundled.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-webpack-client.node.unbundled.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var p=require("util"),r=require("react-dom"),u=require("react"),v={stream:!0};function w(a,b){var d=a[b[0]];if(a=d[b[2]])d=a.name;else{a=d["*"];if(!a)throw Error('Could not find the module "'+b[0]+'" in the React SSR Manifest. This is probably a bug in the React Server Components bundler.');d=b[2]}return{specifier:a.specifier,name:d,async:4===b.length}}var x=new Map;
 function y(a){var b=x.get(a.specifier);if(b)return"fulfilled"===b.status?null:b;var d=import(a.specifier);a.async&&(d=d.then(function(c){return c.default}));d.then(function(c){var g=d;g.status="fulfilled";g.value=c},function(c){var g=d;g.status="rejected";g.reason=c});x.set(a.specifier,d);return d}
 function z(a,b,d){if(null!==a)for(var c=1;c<b.length;c+=2){var g=d,h=A.current;if(h){var l=h.preinitScript,k=a.prefix+b[c];var e=a.crossOrigin;e="string"===typeof e?"use-credentials"===e?e:"":void 0;l.call(h,k,{crossOrigin:e,nonce:g})}}}var A=r.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Dispatcher,B=Symbol.for("react.element"),C=Symbol.for("react.provider"),D=Symbol.for("react.server_context"),F=Symbol.for("react.lazy"),G=Symbol.for("react.default_value"),H=Symbol.iterator;
@@ -37,3 +37,5 @@ h+f,m>g.length&&(m=-1)}var n=g.byteOffset+h;if(-1<m){f=new Uint8Array(g.buffer,n
 f.preloadModule(e):f.preloadModule(e[0],e[1]);break;case "S":"string"===typeof e?f.preinitStyle(e):f.preinitStyle(e[0],0===e[1]?void 0:e[1],3===e.length?e[2]:void 0);break;case "X":"string"===typeof e?f.preinitScript(e):f.preinitScript(e[0],e[1]);break;case "M":"string"===typeof e?f.preinitModuleScript(e):f.preinitModuleScript(e[0],e[1])}break;case 69:e=JSON.parse(e);f=e.digest;e=Error("An error occurred in the Server Components render. The specific message is omitted in production builds to avoid leaking sensitive details. A digest property is included on this error instance which may provide additional details about the nature of the error.");
 e.stack="Error: "+e.message;e.digest=f;f=c._chunks;(h=f.get(k))?S(h,e):f.set(k,new N("rejected",null,e,c));break;case 84:c._chunks.set(k,new N("fulfilled",e,null,c));break;default:f=c._chunks,(h=f.get(k))?(k=h,"pending"===k.status&&(f=k.value,h=k.reason,k.status="resolved_model",k.value=e,null!==f&&(O(k),R(k,f,h)))):f.set(k,new N("resolved_model",e,null,c))}h=m;3===l&&h++;f=k=e=l=0;t.length=0}else{g=new Uint8Array(g.buffer,n,g.byteLength-h);t.push(g);f-=g.byteLength;break}}c._rowState=l;c._rowID=
 k;c._rowTag=e;c._rowLength=f});a.on("error",function(g){W(c,g)});a.on("end",function(){W(c,Error("Connection closed."))});return X(c,0)};exports.createServerReference=function(a){return ma(a,Z)};
+
+//# sourceMappingURL=react-server-dom-webpack-client.node.unbundled.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-node-register.js b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-node-register.js
index a7b85c7916b06..03e91034030cb 100644
--- a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-node-register.js
+++ b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-node-register.js
@@ -1,15 +1,14 @@
-/**
- * @license React
- * react-server-dom-webpack-node-register.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-webpack-node-register.js
 
-'use strict';
+ Copyright (c) Meta Platforms, Inc. and affiliates.
 
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';const h=require("acorn-loose"),l=require("url"),q=require("module");
 module.exports=function(){const m=require("react-server-dom-webpack/server"),n=m.registerServerReference,r=m.createClientModuleProxy,f=q.prototype._compile;q.prototype._compile=function(k,p){if(-1===k.indexOf("use client")&&-1===k.indexOf("use server"))return f.apply(this,arguments);try{var a=h.parse(k,{ecmaVersion:"2024",sourceType:"source"}).body}catch(g){return console.error("Error parsing %s %s",l,g.message),f.apply(this,arguments)}var b=!1,d=!1;for(var c=0;c<a.length;c++){var e=a[c];if("ExpressionStatement"!==
 e.type||!e.directive)break;"use client"===e.directive&&(b=!0);"use server"===e.directive&&(d=!0)}if(!b&&!d)return f.apply(this,arguments);if(b&&d)throw Error('Cannot have both "use client" and "use server" directives in the same file.');b&&(a=l.pathToFileURL(p).href,this.exports=r(a));if(d)if(f.apply(this,arguments),d=l.pathToFileURL(p).href,a=this.exports,"function"===typeof a)n(a,d,null);else for(b=Object.keys(a),c=0;c<b.length;c++){e=b[c];const g=a[b[c]];"function"===typeof g&&n(g,d,e)}}};
+
+//# sourceMappingURL=react-server-dom-webpack-node-register.js.map
diff --git a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-plugin.js b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-plugin.js
index bac715532412f..31ceef305b42e 100644
--- a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-plugin.js
+++ b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-plugin.js
@@ -1,15 +1,12 @@
-/**
- * @license React
- * react-server-dom-webpack-plugin.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-webpack-plugin.js
 
-'use strict';
+ Copyright (c) Meta Platforms, Inc. and affiliates.
 
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var w=require("path"),x=require("url"),y=require("neo-async"),z=require("acorn-loose"),B=require("webpack/lib/dependencies/ModuleDependency"),C=require("webpack/lib/dependencies/NullDependency"),D=require("webpack/lib/Template"),E=require("webpack");
 function F(a,g){if(a){if("string"===typeof a)return G(a,g);var c=Object.prototype.toString.call(a).slice(8,-1);"Object"===c&&a.constructor&&(c=a.constructor.name);if("Map"===c||"Set"===c)return Array.from(a);if("Arguments"===c||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(c))return G(a,g)}}function G(a,g){if(null==g||g>a.length)g=a.length;for(var c=0,n=Array(g);c<g;c++)n[c]=a[c];return n}
 function H(a,g){var c;if("undefined"===typeof Symbol||null==a[Symbol.iterator]){if(Array.isArray(a)||(c=F(a))||g&&a&&"number"===typeof a.length){c&&(a=c);var n=0;g=function(){};return{s:g,n:function(){return n>=a.length?{done:!0}:{done:!1,value:a[n++]}},e:function(b){throw b;},f:g}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");}var d=!0,e=!1,p;return{s:function(){c=a[Symbol.iterator]()},
@@ -23,3 +20,5 @@ l)){const q={};b[l]={id:k,chunks:u,name:"*"};q["*"]={specifier:l,name:"*"};f[k]=
 var t=JSON.stringify(b,null,2);d.emitAsset(g.clientManifestFilename,new E.sources.RawSource(t,!1));e=JSON.stringify(e,null,2);d.emitAsset(g.ssrManifestFilename,new E.sources.RawSource(e,!1))}})})}resolveAllClientFiles(a,g,c,n,d,e){function p(b){if(-1===b.indexOf("use client"))return!1;let f;try{f=z.parse(b,{ecmaVersion:"2024",sourceType:"module"}).body}catch(h){return!1}for(b=0;b<f.length;b++){const h=f[b];if("ExpressionStatement"!==h.type||!h.directive)break;if("use client"===h.directive)return!0}return!1}
 y.map(this.clientReferences,(b,f)=>{"string"===typeof b?f(null,[new J(b)]):g.resolve({},a,b.directory,{},(h,t)=>{if(h)return f(h);d.resolveDependencies(n,{resource:t,resourceQuery:"",recursive:void 0===b.recursive?!0:b.recursive,regExp:b.include,include:void 0,exclude:b.exclude},(m,v)=>{if(m)return f(m);m=v.map(u=>{var k=w.join(t,u.userRequest);k=new J(k);k.userRequest=u.userRequest;return k});y.filter(m,(u,k)=>{c.resolve({},a,u.request,{},(l,q)=>{if(l||"string"!==typeof q)return k(null,!1);n.readFile(q,
 "utf-8",(r,A)=>{if(r||"string"!==typeof A)return k(null,!1);r=p(A);k(null,r)})})},f)})})},(b,f)=>{if(b)return e(b);b=[];for(let h=0;h<f.length;h++)b.push.apply(b,f[h]);e(null,b)})}}module.exports=L;
+
+//# sourceMappingURL=react-server-dom-webpack-plugin.js.map
diff --git a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.browser.production.js b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.browser.production.js
new file mode 100644
index 0000000000000..8a117f8bfcaba
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.browser.production.js
@@ -0,0 +1,3139 @@
+/**
+ * @license React
+ * react-server-dom-webpack-server.browser.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var ReactDOM = require('react-dom');
+var React = require('react');
+
+// -----------------------------------------------------------------------------
+const enablePostpone = false;
+
+function scheduleWork(callback) {
+  callback();
+}
+const VIEW_SIZE = 512;
+let currentView = null;
+let writtenBytes = 0;
+function beginWriting(destination) {
+  currentView = new Uint8Array(VIEW_SIZE);
+  writtenBytes = 0;
+}
+function writeChunk(destination, chunk) {
+  if (chunk.byteLength === 0) {
+    return;
+  }
+
+  if (chunk.byteLength > VIEW_SIZE) {
+    // one that is cached by the streaming renderer. We will enqueu
+    // it directly and expect it is not re-used
+
+
+    if (writtenBytes > 0) {
+      destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    destination.enqueue(chunk);
+    return;
+  }
+
+  let bytesToWrite = chunk;
+  const allowableBytes = currentView.length - writtenBytes;
+
+  if (allowableBytes < bytesToWrite.byteLength) {
+    // this chunk would overflow the current view. We enqueue a full view
+    // and start a new view with the remaining chunk
+    if (allowableBytes === 0) {
+      // the current view is already full, send it
+      destination.enqueue(currentView);
+    } else {
+      // fill up the current view and apply the remaining chunk bytes
+      // to a new view.
+      currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes); // writtenBytes += allowableBytes; // this can be skipped because we are going to immediately reset the view
+
+      destination.enqueue(currentView);
+      bytesToWrite = bytesToWrite.subarray(allowableBytes);
+    }
+
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+
+  currentView.set(bytesToWrite, writtenBytes);
+  writtenBytes += bytesToWrite.byteLength;
+}
+function writeChunkAndReturn(destination, chunk) {
+  writeChunk(destination, chunk); // in web streams there is no backpressure so we can alwas write more
+
+  return true;
+}
+function completeWriting(destination) {
+  if (currentView && writtenBytes > 0) {
+    destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+    currentView = null;
+    writtenBytes = 0;
+  }
+}
+function close$1(destination) {
+  destination.close();
+}
+const textEncoder = new TextEncoder();
+function stringToChunk(content) {
+  return textEncoder.encode(content);
+}
+function byteLengthOfChunk(chunk) {
+  return chunk.byteLength;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[method-unbinding]
+  if (typeof destination.error === 'function') {
+    // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+    destination.error(error);
+  } else {
+    // Earlier implementations doesn't support this method. In that environment you're
+    // supposed to throw from a promise returned but we don't return a promise in our
+    // approach. We could fork this implementation but this is environment is an edge
+    // case to begin with. It's even less common to run this in an older environment.
+    // Even then, this is not where errors are supposed to happen and they get reported
+    // to a global callback in addition to this anyway. So it's fine just to close this.
+    destination.close();
+  }
+}
+
+// eslint-disable-next-line no-unused-vars
+const CLIENT_REFERENCE_TAG = Symbol.for('react.client.reference');
+const SERVER_REFERENCE_TAG = Symbol.for('react.server.reference');
+function isClientReference(reference) {
+  return reference.$$typeof === CLIENT_REFERENCE_TAG;
+}
+function isServerReference(reference) {
+  return reference.$$typeof === SERVER_REFERENCE_TAG;
+}
+function registerClientReference(proxyImplementation, id, exportName) {
+  return registerClientReferenceImpl(proxyImplementation, id + '#' + exportName, false);
+}
+
+function registerClientReferenceImpl(proxyImplementation, id, async) {
+  return Object.defineProperties(proxyImplementation, {
+    $$typeof: {
+      value: CLIENT_REFERENCE_TAG
+    },
+    $$id: {
+      value: id
+    },
+    $$async: {
+      value: async
+    }
+  });
+} // $FlowFixMe[method-unbinding]
+
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+
+  if (this.$$typeof === SERVER_REFERENCE_TAG) {
+    const args = ArraySlice.call(arguments, 1);
+    newFn.$$typeof = SERVER_REFERENCE_TAG;
+    newFn.$$id = this.$$id;
+    newFn.$$bound = this.$$bound ? this.$$bound.concat(args) : args;
+  }
+
+  return newFn;
+}
+
+function registerServerReference(reference, id, exportName) {
+  return Object.defineProperties(reference, {
+    $$typeof: {
+      value: SERVER_REFERENCE_TAG
+    },
+    $$id: {
+      value: exportName === null ? id : id + '#' + exportName
+    },
+    $$bound: {
+      value: null
+    },
+    bind: {
+      value: bind
+    }
+  });
+}
+const PROMISE_PROTOTYPE = Promise.prototype;
+const deepProxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        // These names are a little too common. We should probably have a way to
+        // have the Flight runtime extract the inner target instead.
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+
+      case 'displayName':
+        return undefined;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case 'Provider':
+        throw new Error("Cannot render a Client Context Provider on the Server. " + "Instead, you can export a Client Component wrapper " + "that itself renders a Client Context Provider.");
+    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+    const expression = String(target.name) + '.' + String(name);
+    throw new Error("Cannot access " + expression + " on the server. " + 'You cannot dot into a client module from a server component. ' + 'You can only pass the imported name through.');
+  },
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+
+function getReference(target, name) {
+  switch (name) {
+    // These names are read by the Flight runtime if you end up using the exports object.
+    case '$$typeof':
+      return target.$$typeof;
+
+    case '$$id':
+      return target.$$id;
+
+    case '$$async':
+      return target.$$async;
+
+    case 'name':
+      return target.name;
+    // We need to special case this because createElement reads it if we pass this
+    // reference.
+
+    case 'defaultProps':
+      return undefined;
+    // Avoid this attempting to be serialized.
+
+    case 'toJSON':
+      return undefined;
+
+    case Symbol.toPrimitive:
+      // $FlowFixMe[prop-missing]
+      return Object.prototype[Symbol.toPrimitive];
+
+    case '__esModule':
+      // Something is conditionally checking which export to use. We'll pretend to be
+      // an ESM compat module but then we'll check again on the client.
+      const moduleId = target.$$id;
+      target.default = registerClientReferenceImpl(function () {
+        throw new Error("Attempted to call the default export of " + moduleId + " from the server " + "but it's on the client. It's not possible to invoke a client function from " + "the server, it can only be rendered as a Component or passed to props of a " + "Client Component.");
+      }, target.$$id + '#', target.$$async);
+      return true;
+
+    case 'then':
+      if (target.then) {
+        // Use a cached value
+        return target.then;
+      }
+
+      if (!target.$$async) {
+        // If this module is expected to return a Promise (such as an AsyncModule) then
+        // we should resolve that with a client reference that unwraps the Promise on
+        // the client.
+        const clientReference = registerClientReferenceImpl({}, target.$$id, true);
+        const proxy = new Proxy(clientReference, proxyHandlers); // Treat this as a resolved Promise for React's use()
+
+        target.status = 'fulfilled';
+        target.value = proxy;
+        const then = target.then = registerClientReferenceImpl(function then(resolve, reject) {
+          // Expose to React.
+          return Promise.resolve(resolve(proxy));
+        }, // If this is not used as a Promise but is treated as a reference to a `.then`
+        // export then we should treat it as a reference to that name.
+        target.$$id + '#then', false);
+        return then;
+      } else {
+        // Since typeof .then === 'function' is a feature test we'd continue recursing
+        // indefinitely if we return a function. Instead, we return an object reference
+        // if we check further.
+        return undefined;
+      }
+
+  }
+
+  let cachedReference = target[name];
+
+  if (!cachedReference) {
+    const reference = registerClientReferenceImpl(function () {
+      throw new Error( // eslint-disable-next-line react-internal/safe-string-coercion
+      "Attempted to call " + String(name) + "() from the server but " + String(name) + " is on the client. " + "It's not possible to invoke a client function from the server, it can " + "only be rendered as a Component or passed to props of a Client Component.");
+    }, target.$$id + '#' + name, target.$$async);
+    Object.defineProperty(reference, 'name', {
+      value: name
+    });
+    cachedReference = target[name] = new Proxy(reference, deepProxyHandlers);
+  }
+
+  return cachedReference;
+}
+
+const proxyHandlers = {
+  get: function (target, name, receiver) {
+    return getReference(target, name);
+  },
+  getOwnPropertyDescriptor: function (target, name) {
+    let descriptor = Object.getOwnPropertyDescriptor(target, name);
+
+    if (!descriptor) {
+      descriptor = {
+        value: getReference(target, name),
+        writable: false,
+        configurable: false,
+        enumerable: false
+      };
+      Object.defineProperty(target, name, descriptor);
+    }
+
+    return descriptor;
+  },
+
+  getPrototypeOf(target) {
+    // Pretend to be a Promise in case anyone asks.
+    return PROMISE_PROTOTYPE;
+  },
+
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+function createClientModuleProxy(moduleId) {
+  const clientReference = registerClientReferenceImpl({}, // Represents the whole Module object instead of a particular import.
+  moduleId, false);
+  return new Proxy(clientReference, proxyHandlers);
+}
+
+function getClientReferenceKey(reference) {
+  return reference.$$async ? reference.$$id + '#async' : reference.$$id;
+}
+function resolveClientReferenceMetadata(config, clientReference) {
+  const modulePath = clientReference.$$id;
+  let name = '';
+  let resolvedModuleData = config[modulePath];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = modulePath.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = modulePath.slice(idx + 1);
+      resolvedModuleData = config[modulePath.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + modulePath + '" in the React Client Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  }
+
+  if (clientReference.$$async === true) {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1];
+  } else {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+  }
+}
+function getServerReferenceId(config, serverReference) {
+  return serverReference.$$id;
+}
+function getServerReferenceBoundArguments(config, serverReference) {
+  return serverReference.$$bound;
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMFlightServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule: preloadModule$1,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+
+function prefetchDNS(href) {
+  {
+    if (typeof href === 'string' && href) {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'D|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        emitHint(request, 'D', href);
+      }
+    }
+  }
+}
+
+function preconnect(href, crossOrigin) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = "C|" + (crossOrigin == null ? 'null' : crossOrigin) + "|" + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+
+        if (typeof crossOrigin === 'string') {
+          emitHint(request, 'C', [href, crossOrigin]);
+        } else {
+          emitHint(request, 'C', href);
+        }
+      }
+    }
+  }
+}
+
+function preload(href, as, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        let key = 'L';
+
+        if (as === 'image' && options) {
+          key += getImagePreloadKey(href, options.imageSrcSet, options.imageSizes);
+        } else {
+          key += "[" + as + "]" + href;
+        }
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          emitHint(request, 'L', [href, as, trimmed]);
+        } else {
+          emitHint(request, 'L', [href, as]);
+        }
+      }
+    }
+  }
+}
+
+function preloadModule$1(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'm|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'm', [href, trimmed]);
+        } else {
+          return emitHint(request, 'm', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'S|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'S', [href, typeof precedence === 'string' ? precedence : 0, trimmed]);
+        } else if (typeof precedence === 'string') {
+          return emitHint(request, 'S', [href, precedence]);
+        } else {
+          return emitHint(request, 'S', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'X|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'X', [href, trimmed]);
+        } else {
+          return emitHint(request, 'X', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitModuleScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'M|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'M', [href, trimmed]);
+        } else {
+          return emitHint(request, 'M', href);
+        }
+      }
+    }
+  }
+} // Flight normally encodes undefined as a special character however for directive option
+// arguments we don't want to send unnecessary keys and bloat the payload so we create a
+// trimmed object which omits any keys with null or undefined values.
+// This is only typesafe because these option objects have entirely optional fields where
+// null and undefined represent the same thing as no property.
+
+
+function trimOptions(options) {
+  if (options == null) return null;
+  let hasProperties = false;
+  const trimmed = {};
+
+  for (const key in options) {
+    if (options[key] != null) {
+      hasProperties = true;
+      trimmed[key] = options[key];
+    }
+  }
+
+  return hasProperties ? trimmed : null;
+}
+
+function getImagePreloadKey(href, imageSrcSet, imageSizes) {
+  let uniquePart = '';
+
+  if (typeof imageSrcSet === 'string' && imageSrcSet !== '') {
+    uniquePart += '[' + imageSrcSet + ']';
+
+    if (typeof imageSizes === 'string') {
+      uniquePart += '[' + imageSizes + ']';
+    }
+  } else {
+    uniquePart += '[][]' + href;
+  }
+
+  return "[image]" + uniquePart;
+}
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMFlightServerDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+// small, smaller than how we encode undefined, and is unambiguous. We could use
+// a different tuple structure to encode this instead but this makes the runtime
+// cost cheaper by eliminating a type checks in more positions.
+// prettier-ignore
+
+function createHints() {
+  return new Set();
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext); // On the way back, we push the new ones that weren't common.
+
+      pushNode(next);
+    }
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFizzWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop, noop);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+let currentRequest$1 = null;
+let thenableIndexCounter = 0;
+let thenableState = null;
+function prepareToUseHooksForRequest(request) {
+  currentRequest$1 = request;
+}
+function resetHooksForRequest() {
+  currentRequest$1 = null;
+}
+function prepareToUseHooksForComponent(prevThenableState) {
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+const HooksDispatcher = {
+  useMemo(nextCreate) {
+    return nextCreate();
+  },
+
+  useCallback(callback) {
+    return callback;
+  },
+
+  useDebugValue() {},
+
+  useDeferredValue: unsupportedHook,
+  useTransition: unsupportedHook,
+  readContext,
+  useContext: readContext,
+  useReducer: unsupportedHook,
+  useRef: unsupportedHook,
+  useState: unsupportedHook,
+  useInsertionEffect: unsupportedHook,
+  useLayoutEffect: unsupportedHook,
+  useImperativeHandle: unsupportedHook,
+  useEffect: unsupportedHook,
+  useId,
+  useSyncExternalStore: unsupportedHook,
+
+  useCacheRefresh() {
+    return unsupportedRefresh;
+  },
+
+  useMemoCache(size) {
+    const data = new Array(size);
+
+    for (let i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL;
+    }
+
+    return data;
+  },
+
+  use
+};
+
+function unsupportedHook() {
+  throw new Error('This Hook is not supported in Server Components.');
+}
+
+function unsupportedRefresh() {
+  throw new Error('Refreshing the cache is not supported in Server Components.');
+}
+
+function useId() {
+  if (currentRequest$1 === null) {
+    throw new Error('useId can only be used while React is rendering');
+  }
+
+  const id = currentRequest$1.identifierCount++; // use 'S' for Flight components to distinguish from 'R' and 'r' in Fizz/Client
+
+  return ':' + currentRequest$1.identifierPrefix + 'S' + id.toString(32) + ':';
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object' || typeof usable === 'function') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable; // Track the position of the thenable within this fiber.
+
+      const index = thenableIndexCounter;
+      thenableIndexCounter += 1;
+
+      if (thenableState === null) {
+        thenableState = createThenableState();
+      }
+
+      return trackUsedThenable(thenableState, thenable, index);
+    } else if (usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  }
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function createSignal() {
+  return new AbortController().signal;
+}
+
+function resolveCache() {
+  const request = resolveRequest();
+
+  if (request) {
+    return getCache(request);
+  }
+
+  return new Map();
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal() {
+    const cache = resolveCache();
+    let entry = cache.get(createSignal);
+
+    if (entry === undefined) {
+      entry = createSignal();
+      cache.set(createSignal, entry);
+    }
+
+    return entry;
+  },
+
+  getCacheForType(resourceType) {
+    const cache = resolveCache();
+    let entry = cache.get(resourceType);
+
+    if (entry === undefined) {
+      entry = resourceType(); // TODO: Warn if undefined?
+
+      cache.set(resourceType, entry);
+    }
+
+    return entry;
+  }
+
+};
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+function objectName(object) {
+  // $FlowFixMe[method-unbinding]
+  const name = Object.prototype.toString.call(object);
+  return name.replace(/^\[object (.*)\]$/, function (m, p0) {
+    return p0;
+  });
+}
+
+function describeKeyForErrorMessage(key) {
+  const encodedKey = JSON.stringify(key);
+  return '"' + key + '"' === encodedKey ? key : encodedKey;
+}
+
+function describeValueForErrorMessage(value) {
+  switch (typeof value) {
+    case 'string':
+      {
+        return JSON.stringify(value.length <= 10 ? value : value.slice(0, 10) + '...');
+      }
+
+    case 'object':
+      {
+        if (isArray(value)) {
+          return '[...]';
+        }
+
+        const name = objectName(value);
+
+        if (name === 'Object') {
+          return '{...}';
+        }
+
+        return name;
+      }
+
+    case 'function':
+      return 'function';
+
+    default:
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      return String(value);
+  }
+}
+
+function describeElementType(type) {
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        return describeElementType(type.render);
+
+      case REACT_MEMO_TYPE:
+        return describeElementType(type.type);
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            // Lazy may contain any component type so we recursively resolve it.
+            return describeElementType(init(payload));
+          } catch (x) {}
+        }
+    }
+  }
+
+  return '';
+}
+
+function describeObjectForErrorMessage(objectOrArray, expandedName) {
+  const objKind = objectName(objectOrArray);
+
+  if (objKind !== 'Object' && objKind !== 'Array') {
+    return objKind;
+  }
+
+  let str = '';
+  let start = -1;
+  let length = 0;
+
+  if (isArray(objectOrArray)) {
+    {
+      // Print Array
+      str = '[';
+      const array = objectOrArray;
+
+      for (let i = 0; i < array.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const value = array[i];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if ('' + i === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += ']';
+    }
+  } else {
+    if (objectOrArray.$$typeof === REACT_ELEMENT_TYPE) {
+      str = '<' + describeElementType(objectOrArray.type) + '/>';
+    } else {
+      // Print Object
+      str = '{';
+      const object = objectOrArray;
+      const names = Object.keys(object);
+
+      for (let i = 0; i < names.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const name = names[i];
+        str += describeKeyForErrorMessage(name) + ': ';
+        const value = object[name];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if (name === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += '}';
+    }
+  }
+
+  if (expandedName === undefined) {
+    return str;
+  }
+
+  if (start > -1 && length > 0) {
+    const highlight = ' '.repeat(start) + '^'.repeat(length);
+    return '\n  ' + str + '\n  ' + highlight;
+  }
+
+  return '\n  ' + str;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactSharedServerInternals = // $FlowFixMe: It's defined in the one we resolve to.
+React.__SECRET_SERVER_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+if (!ReactSharedServerInternals) {
+  throw new Error('The "react" package in this environment is not configured correctly. ' + 'The "react-server" condition must be enabled in any environment that ' + 'runs React Server Components.');
+}
+
+const ObjectPrototype = Object.prototype;
+const stringify = JSON.stringify; // Serializable values
+// Thenable<ReactClientValue>
+
+const PENDING$1 = 0;
+const COMPLETED = 1;
+const ABORTED = 3;
+const ERRORED$1 = 4;
+const ReactCurrentCache = ReactSharedServerInternals.ReactCurrentCache;
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+}
+
+function defaultPostponeHandler(reason) {// Noop
+}
+
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2;
+function createRequest(model, bundlerConfig, onError, context, identifierPrefix, onPostpone) {
+  if (ReactCurrentCache.current !== null && ReactCurrentCache.current !== DefaultCacheDispatcher) {
+    throw new Error('Currently React only supports one RSC renderer at a time.');
+  }
+
+  prepareHostDispatcher();
+  ReactCurrentCache.current = DefaultCacheDispatcher;
+  const abortSet = new Set();
+  const pingedTasks = [];
+  const cleanupQueue = [];
+
+  const hints = createHints();
+  const request = {
+    status: OPEN,
+    flushScheduled: false,
+    fatalError: null,
+    destination: null,
+    bundlerConfig,
+    cache: new Map(),
+    nextChunkId: 0,
+    pendingChunks: 0,
+    hints,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    completedImportChunks: [],
+    completedHintChunks: [],
+    completedRegularChunks: [],
+    completedErrorChunks: [],
+    writtenSymbols: new Map(),
+    writtenClientReferences: new Map(),
+    writtenServerReferences: new Map(),
+    writtenProviders: new Map(),
+    writtenObjects: new WeakMap(),
+    identifierPrefix: identifierPrefix || '',
+    identifierCount: 1,
+    taintCleanupQueue: cleanupQueue,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? defaultPostponeHandler : onPostpone,
+    // $FlowFixMe[missing-this-annot]
+    toJSON: function (key, value) {
+      return resolveModelToJSON(request, this, key, value);
+    }
+  };
+  request.pendingChunks++;
+  const rootContext = createRootContext();
+  const rootTask = createTask(request, model, rootContext, abortSet);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  return null;
+}
+
+function createRootContext(reqContext) {
+  return importServerContexts();
+}
+
+function serializeThenable(request, thenable) {
+  request.pendingChunks++;
+  const newTask = createTask(request, null, getActiveContext(), request.abortableTasks);
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        // We have the resolved value, we can go ahead and schedule it for serialization.
+        newTask.model = thenable.value;
+        pingTask(request, newTask);
+        return newTask.id;
+      }
+
+    case 'rejected':
+      {
+        const x = thenable.reason;
+
+        {
+          const digest = logRecoverableError(request, x);
+          emitErrorChunk(request, newTask.id, digest);
+        }
+
+        return newTask.id;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  thenable.then(value => {
+    newTask.model = value;
+    pingTask(request, newTask);
+  }, reason => {
+    newTask.status = ERRORED$1;
+    request.abortableTasks.delete(newTask); // TODO: We should ideally do this inside performWork so it's scheduled
+
+    const digest = logRecoverableError(request, reason);
+    emitErrorChunk(request, newTask.id, digest);
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  });
+  return newTask.id;
+}
+
+function emitHint(request, code, model) {
+  emitHintChunk(request, code, model);
+  enqueueFlush(request);
+}
+function getHints(request) {
+  return request.hints;
+}
+function getCache(request) {
+  return request.cache;
+}
+
+function readThenable(thenable) {
+  if (thenable.status === 'fulfilled') {
+    return thenable.value;
+  } else if (thenable.status === 'rejected') {
+    throw thenable.reason;
+  }
+
+  throw thenable;
+}
+
+function createLazyWrapperAroundWakeable(wakeable) {
+  // This is a temporary fork of the `use` implementation until we accept
+  // promises everywhere.
+  const thenable = wakeable;
+
+  switch (thenable.status) {
+    case 'fulfilled':
+    case 'rejected':
+      break;
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: thenable,
+    _init: readThenable
+  };
+  return lazyType;
+}
+
+function attemptResolveElement(request, type, key, ref, props, prevThenableState) {
+  if (ref !== null && ref !== undefined) {
+    // When the ref moves to the regular props object this will implicitly
+    // throw for functions. We could probably relax it to a DEV warning for other
+    // cases.
+    throw new Error('Refs cannot be used in Server Components, nor passed to Client Components.');
+  }
+
+  if (typeof type === 'function') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    } // This is a server-side component.
+
+
+    prepareToUseHooksForComponent(prevThenableState);
+    const result = type(props);
+
+    if (typeof result === 'object' && result !== null && typeof result.then === 'function') {
+      // When the return value is in children position we can resolve it immediately,
+      // to its value without a wrapper if it's synchronously available.
+      const thenable = result;
+
+      if (thenable.status === 'fulfilled') {
+        return thenable.value;
+      } // TODO: Once we accept Promises as children on the client, we can just return
+      // the thenable here.
+
+
+      return createLazyWrapperAroundWakeable(result);
+    }
+
+    return result;
+  } else if (typeof type === 'string') {
+    // This is a host element. E.g. HTML.
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (typeof type === 'symbol') {
+    if (type === REACT_FRAGMENT_TYPE) {
+      // For key-less fragments, we add a small optimization to avoid serializing
+      // it as a wrapper.
+      // TODO: If a key is specified, we should propagate its key to any children.
+      // Same as if a Server Component has a key.
+      return props.children;
+    } // This might be a built-in React component. We'll let the client decide.
+    // Any built-in works as long as its props are serializable.
+
+
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (type != null && typeof type === 'object') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    }
+
+    switch (type.$$typeof) {
+      case REACT_LAZY_TYPE:
+        {
+          const payload = type._payload;
+          const init = type._init;
+          const wrappedType = init(payload);
+          return attemptResolveElement(request, wrappedType, key, ref, props, prevThenableState);
+        }
+
+      case REACT_FORWARD_REF_TYPE:
+        {
+          const render = type.render;
+          prepareToUseHooksForComponent(prevThenableState);
+          return render(props, undefined);
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          return attemptResolveElement(request, type.type, key, ref, props, prevThenableState);
+        }
+    }
+  }
+
+  throw new Error("Unsupported Server Component type: " + describeValueForErrorMessage(type));
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createTask(request, model, context, abortSet) {
+  const id = request.nextChunkId++;
+  const task = {
+    id,
+    status: PENDING$1,
+    model,
+    context,
+    ping: () => pingTask(request, task),
+    thenableState: null
+  };
+  abortSet.add(task);
+  return task;
+}
+
+function serializeByValueID(id) {
+  return '$' + id.toString(16);
+}
+
+function serializeLazyID(id) {
+  return '$L' + id.toString(16);
+}
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeRowHeader(tag, id) {
+  return id.toString(16) + ':' + tag;
+}
+
+function encodeReferenceChunk(request, id, reference) {
+  const json = stringify(reference);
+  const row = id.toString(16) + ':' + json + '\n';
+  return stringToChunk(row);
+}
+
+function serializeClientReference(request, parent, key, clientReference) {
+  const clientReferenceKey = getClientReferenceKey(clientReference);
+  const writtenClientReferences = request.writtenClientReferences;
+  const existingId = writtenClientReferences.get(clientReferenceKey);
+
+  if (existingId !== undefined) {
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(existingId);
+    }
+
+    return serializeByValueID(existingId);
+  }
+
+  try {
+    const clientReferenceMetadata = resolveClientReferenceMetadata(request.bundlerConfig, clientReference);
+    request.pendingChunks++;
+    const importId = request.nextChunkId++;
+    emitImportChunk(request, importId, clientReferenceMetadata);
+    writtenClientReferences.set(clientReferenceKey, importId);
+
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(importId);
+    }
+
+    return serializeByValueID(importId);
+  } catch (x) {
+    request.pendingChunks++;
+    const errorId = request.nextChunkId++;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, errorId, digest);
+    return serializeByValueID(errorId);
+  }
+}
+
+function outlineModel(request, value) {
+  request.pendingChunks++;
+  const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+  retryTask(request, newTask);
+  return newTask.id;
+}
+
+function serializeServerReference(request, parent, key, serverReference) {
+  const writtenServerReferences = request.writtenServerReferences;
+  const existingId = writtenServerReferences.get(serverReference);
+
+  if (existingId !== undefined) {
+    return serializeServerReferenceID(existingId);
+  }
+
+  const bound = getServerReferenceBoundArguments(request.bundlerConfig, serverReference);
+  const serverReferenceMetadata = {
+    id: getServerReferenceId(request.bundlerConfig, serverReference),
+    bound: bound ? Promise.resolve(bound) : null
+  };
+  const metadataId = outlineModel(request, serverReferenceMetadata);
+  writtenServerReferences.set(serverReference, metadataId);
+  return serializeServerReferenceID(metadataId);
+}
+
+function serializeLargeTextString(request, text) {
+  request.pendingChunks += 2;
+  const textId = request.nextChunkId++;
+  const textChunk = stringToChunk(text);
+  const binaryLength = byteLengthOfChunk(textChunk);
+  const row = textId.toString(16) + ':T' + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, textChunk);
+  return serializeByValueID(textId);
+}
+
+function serializeMap(request, map) {
+  const entries = Array.from(map);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i][0];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$Q' + id.toString(16);
+}
+
+function serializeSet(request, set) {
+  const entries = Array.from(set);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+let modelRoot = false;
+
+function resolveModelToJSON(request, parent, key, value) {
+
+
+  switch (value) {
+    case REACT_ELEMENT_TYPE:
+      return '$';
+  }
+
+
+  while (typeof value === 'object' && value !== null && (value.$$typeof === REACT_ELEMENT_TYPE || value.$$typeof === REACT_LAZY_TYPE)) {
+
+    try {
+      switch (value.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const writtenObjects = request.writtenObjects;
+            const existingId = writtenObjects.get(value);
+
+            if (existingId !== undefined) {
+              if (existingId === -1) {
+                // Seen but not yet outlined.
+                const newId = outlineModel(request, value);
+                return serializeByValueID(newId);
+              } else if (modelRoot === value) {
+                // This is the ID we're currently emitting so we need to write it
+                // once but if we discover it again, we refer to it by id.
+                modelRoot = null;
+              } else {
+                // We've already emitted this as an outlined object, so we can
+                // just refer to that by its existing ID.
+                return serializeByValueID(existingId);
+              }
+            } else {
+              // This is the first time we've seen this object. We may never see it again
+              // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+              writtenObjects.set(value, -1);
+            } // TODO: Concatenate keys of parents onto children.
+
+
+            const element = value; // Attempt to render the Server Component.
+
+            value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, null);
+            break;
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = value._payload;
+            const init = value._init;
+            value = init(payload);
+            break;
+          }
+      }
+    } catch (thrownValue) {
+      const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          // Something suspended, we'll need to create a new task and resolve it later.
+          request.pendingChunks++;
+          const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+          const ping = newTask.ping;
+          x.then(ping, ping);
+          newTask.thenableState = getThenableStateAfterSuspending();
+          return serializeLazyID(newTask.id);
+        }
+      } // Something errored. We'll still send everything we have up until this point.
+      // We'll replace this element with a lazy reference that throws on the client
+      // once it gets rendered.
+
+
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+      const digest = logRecoverableError(request, x);
+      emitErrorChunk(request, errorId, digest);
+      return serializeLazyID(errorId);
+    }
+  }
+
+  if (value === null) {
+    return null;
+  }
+
+  if (typeof value === 'object') {
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    const writtenObjects = request.writtenObjects;
+    const existingId = writtenObjects.get(value); // $FlowFixMe[method-unbinding]
+
+    if (typeof value.then === 'function') {
+      if (existingId !== undefined) {
+        if (modelRoot === value) {
+          // This is the ID we're currently emitting so we need to write it
+          // once but if we discover it again, we refer to it by id.
+          modelRoot = null;
+        } else {
+          // We've seen this promise before, so we can just refer to the same result.
+          return serializePromiseID(existingId);
+        }
+      } // We assume that any object with a .then property is a "Thenable" type,
+      // or a Promise type. Either of which can be represented by a Promise.
+
+
+      const promiseId = serializeThenable(request, value);
+      writtenObjects.set(value, promiseId);
+      return serializePromiseID(promiseId);
+    }
+
+    if (existingId !== undefined) {
+      if (existingId === -1) {
+        // Seen but not yet outlined.
+        const newId = outlineModel(request, value);
+        return serializeByValueID(newId);
+      } else if (modelRoot === value) {
+        // This is the ID we're currently emitting so we need to write it
+        // once but if we discover it again, we refer to it by id.
+        modelRoot = null;
+      } else {
+        // We've already emitted this as an outlined object, so we can
+        // just refer to that by its existing ID.
+        return serializeByValueID(existingId);
+      }
+    } else {
+      // This is the first time we've seen this object. We may never see it again
+      // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+      writtenObjects.set(value, -1);
+    }
+
+    if (isArray(value)) {
+      // $FlowFixMe[incompatible-return]
+      return value;
+    }
+
+    if (value instanceof Map) {
+      return serializeMap(request, value);
+    }
+
+    if (value instanceof Set) {
+      return serializeSet(request, value);
+    }
+
+    const iteratorFn = getIteratorFn(value);
+
+    if (iteratorFn) {
+      return Array.from(value);
+    } // Verify that this is a simple plain object.
+
+
+    const proto = getPrototypeOf(value);
+
+    if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+      throw new Error('Only plain objects, and a few built-ins, can be passed to Client Components ' + 'from Server Components. Classes or null prototypes are not supported.');
+    }
+
+
+    return value;
+  }
+
+  if (typeof value === 'string') {
+
+
+    if (value[value.length - 1] === 'Z') {
+      // Possibly a Date, whose toJSON automatically calls toISOString
+      // $FlowFixMe[incompatible-use]
+      const originalValue = parent[key];
+
+      if (originalValue instanceof Date) {
+        return serializeDateFromDateJSON(value);
+      }
+    }
+
+    if (value.length >= 1024) {
+      // For large strings, we encode them outside the JSON payload so that we
+      // don't have to double encode and double parse the strings. This can also
+      // be more compact in case the string has a lot of escaped characters.
+      return serializeLargeTextString(request, value);
+    }
+
+    return escapeStringValue(value);
+  }
+
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  if (typeof value === 'number') {
+    return serializeNumber(value);
+  }
+
+  if (typeof value === 'undefined') {
+    return serializeUndefined();
+  }
+
+  if (typeof value === 'function') {
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    if (isServerReference(value)) {
+      return serializeServerReference(request, parent, key, value);
+    }
+
+    if (/^on[A-Z]/.test(key)) {
+      throw new Error('Event handlers cannot be passed to Client Component props.' + describeObjectForErrorMessage(parent, key) + '\nIf you need interactivity, consider converting part of this to a Client Component.');
+    } else {
+      throw new Error('Functions cannot be passed directly to Client Components ' + 'unless you explicitly expose it by marking it with "use server".' + describeObjectForErrorMessage(parent, key));
+    }
+  }
+
+  if (typeof value === 'symbol') {
+    const writtenSymbols = request.writtenSymbols;
+    const existingId = writtenSymbols.get(value);
+
+    if (existingId !== undefined) {
+      return serializeByValueID(existingId);
+    } // $FlowFixMe[incompatible-type] `description` might be undefined
+
+
+    const name = value.description;
+
+    if (Symbol.for(name) !== value) {
+      throw new Error('Only global symbols received from Symbol.for(...) can be passed to Client Components. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+      value.description + ") cannot be found among global symbols.") + describeObjectForErrorMessage(parent, key));
+    }
+
+    request.pendingChunks++;
+    const symbolId = request.nextChunkId++;
+    emitSymbolChunk(request, symbolId, name);
+    writtenSymbols.set(value, symbolId);
+    return serializeByValueID(symbolId);
+  }
+
+  if (typeof value === 'bigint') {
+
+    return serializeBigInt(value);
+  }
+
+  throw new Error("Type " + typeof value + " is not supported in Client Component props." + describeObjectForErrorMessage(parent, key));
+}
+
+function logPostpone(request, reason) {
+  const onPostpone = request.onPostpone;
+  onPostpone(reason);
+}
+
+function logRecoverableError(request, error) {
+  const onError = request.onError;
+  const errorDigest = onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest || '';
+}
+
+function fatalError(request, error) {
+
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function emitPostponeChunk(request, id, postponeInstance) {
+  let row;
+
+  {
+    // No reason included in prod.
+    row = serializeRowHeader('P', id) + '\n';
+  }
+
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitErrorChunk(request, id, digest, error) {
+  let errorInfo;
+
+  {
+    errorInfo = {
+      digest
+    };
+  }
+
+  const row = serializeRowHeader('E', id) + stringify(errorInfo) + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitImportChunk(request, id, clientReferenceMetadata) {
+  // $FlowFixMe[incompatible-type] stringify can return null
+  const json = stringify(clientReferenceMetadata);
+  const row = serializeRowHeader('I', id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitHintChunk(request, code, model) {
+  const json = stringify(model);
+  const id = request.nextChunkId++;
+  const row = serializeRowHeader('H' + code, id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedHintChunks.push(processedChunk);
+}
+
+function emitSymbolChunk(request, id, name) {
+  const symbolReference = serializeSymbolReference(name);
+  const processedChunk = encodeReferenceChunk(request, id, symbolReference);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitModelChunk(request, id, model) {
+  // Track the root so we know that we have to emit this object even though it
+  // already has an ID. This is needed because we might see this object twice
+  // in the same toJSON if it is cyclic.
+  modelRoot = model; // $FlowFixMe[incompatible-type] stringify can return null
+
+  const json = stringify(model, request.toJSON);
+  const row = id.toString(16) + ':' + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function retryTask(request, task) {
+  if (task.status !== PENDING$1) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  }
+
+  switchContext(task.context);
+
+  try {
+    let value = task.model;
+
+    if (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+      request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+      const element = value; // When retrying a component, reuse the thenableState from the
+      // previous attempt.
+
+      const prevThenableState = task.thenableState; // Attempt to render the Server Component.
+      // Doing this here lets us reuse this same task if the next component
+      // also suspends.
+
+      task.model = value;
+      value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, prevThenableState); // Successfully finished this component. We're going to keep rendering
+      // using the same task, but we reset its thenable state before continuing.
+
+      task.thenableState = null; // Keep rendering and reuse the same task. This inner loop is separate
+      // from the render above because we don't need to reset the thenable state
+      // until the next time something suspends and retries.
+
+      while (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+        request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+        const nextElement = value;
+        task.model = value;
+        value = attemptResolveElement(request, nextElement.type, nextElement.key, nextElement.ref, nextElement.props, null);
+      }
+    } // Track that this object is outlined and has an id.
+
+
+    if (typeof value === 'object' && value !== null) {
+      request.writtenObjects.set(value, task.id);
+    }
+
+    emitModelChunk(request, task.id, value);
+    request.abortableTasks.delete(task);
+    task.status = COMPLETED;
+  } catch (thrownValue) {
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    request.abortableTasks.delete(task);
+    task.status = ERRORED$1;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, task.id, digest);
+  }
+}
+
+function performWork(request) {
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  const prevRequest = currentRequest;
+  currentRequest = request;
+  prepareToUseHooksForRequest(request);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    request.pingedTasks = [];
+
+    for (let i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    ReactCurrentDispatcher.current = prevDispatcher;
+    resetHooksForRequest();
+    currentRequest = prevRequest;
+  }
+}
+
+function abortTask(task, request, errorId) {
+  task.status = ABORTED; // Instead of emitting an error per task.id, we emit a model that only
+  // has a single value referencing the error.
+
+  const ref = serializeByValueID(errorId);
+  const processedChunk = encodeReferenceChunk(request, task.id, ref);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function flushCompletedChunks(request, destination) {
+  beginWriting();
+
+  try {
+    // We emit module chunks first in the stream so that
+    // they can be preloaded as early as possible.
+    const importsChunks = request.completedImportChunks;
+    let i = 0;
+
+    for (; i < importsChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = importsChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    importsChunks.splice(0, i); // Next comes hints.
+
+    const hintChunks = request.completedHintChunks;
+    i = 0;
+
+    for (; i < hintChunks.length; i++) {
+      const chunk = hintChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    hintChunks.splice(0, i); // Next comes model data.
+
+    const regularChunks = request.completedRegularChunks;
+    i = 0;
+
+    for (; i < regularChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = regularChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    regularChunks.splice(0, i); // Finally, errors are sent. The idea is that it's ok to delay
+    // any error messages and prioritize display of other parts of
+    // the page.
+
+    const errorChunks = request.completedErrorChunks;
+    i = 0;
+
+    for (; i < errorChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = errorChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    errorChunks.splice(0, i);
+  } finally {
+    request.flushScheduled = false;
+    completeWriting(destination);
+  }
+
+  if (request.pendingChunks === 0) {
+
+    close$1(destination);
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  {
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    const destination = request.destination;
+    request.flushScheduled = true;
+    scheduleWork(() => flushCompletedChunks(request, destination));
+  }
+}
+
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedChunks(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function stopFlowing(request) {
+  request.destination = null;
+} // This is called to early terminate a request. It creates an error at all pending tasks.
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      // We have tasks to abort. We'll emit one error row and then emit a reference
+      // to that row from every row that's still remaining.
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+
+      if (enablePostpone && typeof reason === 'object' && reason !== null && reason.$$typeof === REACT_POSTPONE_TYPE) ; else {
+        const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+        const digest = logRecoverableError(request, error);
+        emitErrorChunk(request, errorId, digest, error);
+      }
+
+      abortableTasks.forEach(task => abortTask(task, request, errorId));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function importServerContexts(contexts) {
+
+  return rootContextSnapshot;
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+function resolveServerReference(bundlerConfig, id) {
+  let name = '';
+  let resolvedModuleData = bundlerConfig[id];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = id.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = id.slice(idx + 1);
+      resolvedModuleData = bundlerConfig[id.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + id + '" in the React Server Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  } // TODO: This needs to return async: true if it's an async module.
+
+
+  return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+} // The chunk cache contains all the chunks we've preloaded so far.
+// If they're still pending they're a thenable. This map also exists
+// in Webpack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = __webpack_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+  let i = 0;
+
+  while (i < chunks.length) {
+    const chunkId = chunks[i++];
+    const chunkFilename = chunks[i++];
+    const entry = chunkCache.get(chunkId);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkId, chunkFilename);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkId, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkId, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = __webpack_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+const chunkMap = new Map();
+/**
+ * We patch the chunk filename function in webpack to insert our own resolution
+ * of chunks that come from Flight and may not be known to the webpack runtime
+ */
+
+const webpackGetChunkFilename = __webpack_require__.u;
+
+__webpack_require__.u = function (chunkId) {
+  const flightChunk = chunkMap.get(chunkId);
+
+  if (flightChunk !== undefined) {
+    return flightChunk;
+  }
+
+  return webpackGetChunkFilename(chunkId);
+};
+
+function loadChunk(chunkId, filename) {
+  chunkMap.set(chunkId, filename);
+  return __webpack_chunk_load__(chunkId);
+}
+
+// The server acts as a Client of itself when resolving Server References.
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const RESOLVED_MODEL = 'resolved_model';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function bindArgs$1(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference$1(response, id, bound, parentChunk, parentObject, key) {
+  const serverReference = resolveServerReference(response._bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+  let promise;
+
+  if (bound) {
+    promise = Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs$1(requireModule(serverReference), args);
+    });
+  } else {
+    if (preloadPromise) {
+      promise = Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+    } else {
+      // Synchronously available
+      return requireModule(serverReference);
+    }
+  }
+
+  promise.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk)); // We need a placeholder value that will be replaced later.
+
+  return null;
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+
+  try {
+    const value = JSON.parse(chunk.value, chunk._response._fromJSON);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    const prefix = response._prefix;
+    const key = prefix + id; // Check if we have this field in the backing store already.
+
+    const backingEntry = response._formData.get(key);
+
+    if (backingEntry != null) {
+      // We assume that this is a string entry for now.
+      chunk = createResolvedModelChunk(response, backingEntry);
+    } else {
+      // We're still waiting on this entry to stream in.
+      chunk = createPendingChunk(response);
+    }
+
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+    blocked.deps++;
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  if (chunk.status === RESOLVED_MODEL) {
+    initializeModelChunk(chunk);
+  }
+
+  if (chunk.status !== INITIALIZED) {
+    // We know that this is emitted earlier so otherwise it's an error.
+    throw chunk.reason;
+  }
+
+  return chunk.value;
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16); // TODO: Just encode this in the reference inline instead of as a model.
+
+          const metaData = getOutlinedModel(response, id);
+          return loadServerReference$1(response, metaData.id, metaData.bound, initializingChunk, parentObject, key);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'K':
+        {
+          // FormData
+          const stringId = value.slice(2);
+          const formPrefix = response._prefix + stringId + '_';
+          const data = new FormData();
+          const backingFormData = response._formData; // We assume that the reference to FormData always comes after each
+          // entry that it references so we can assume they all exist in the
+          // backing store already.
+          // $FlowFixMe[prop-missing] FormData has forEach on it.
+
+          backingFormData.forEach((entry, entryKey) => {
+            if (entryKey.startsWith(formPrefix)) {
+              data.append(entryKey.slice(formPrefix.length), entry);
+            }
+          });
+          return data;
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function createResponse(bundlerConfig, formFieldPrefix) {
+  let backingFormData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new FormData();
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _prefix: formFieldPrefix,
+    _formData: backingFormData,
+    _chunks: chunks,
+    _fromJSON: function (key, value) {
+      if (typeof value === 'string') {
+        // We can't use .bind here because we need the "this" value.
+        return parseModelString(response, this, key, value);
+      }
+
+      return value;
+    }
+  };
+  return response;
+}
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function bindArgs(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference(bundlerConfig, id, bound) {
+  const serverReference = resolveServerReference(bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+
+  if (bound) {
+    return Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs(requireModule(serverReference), args);
+    });
+  } else if (preloadPromise) {
+    return Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+  } else {
+    // Synchronously available
+    return Promise.resolve(requireModule(serverReference));
+  }
+}
+
+function decodeBoundActionMetaData(body, serverManifest, formFieldPrefix) {
+  // The data for this reference is encoded in multiple fields under this prefix.
+  const actionResponse = createResponse(serverManifest, formFieldPrefix, body);
+  close(actionResponse);
+  const refPromise = getRoot(actionResponse); // Force it to initialize
+  // $FlowFixMe
+
+  refPromise.then(() => {});
+
+  if (refPromise.status !== 'fulfilled') {
+    // $FlowFixMe
+    throw refPromise.reason;
+  }
+
+  return refPromise.value;
+}
+
+function decodeAction(body, serverManifest) {
+  // We're going to create a new formData object that holds all the fields except
+  // the implementation details of the action data.
+  const formData = new FormData();
+  let action = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (!key.startsWith('$ACTION_')) {
+      formData.append(key, value);
+      return;
+    } // Later actions may override earlier actions if a button is used to override the default
+    // form action.
+
+
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      const metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+      action = loadServerReference(serverManifest, metaData.id, metaData.bound);
+      return;
+    }
+
+    if (key.startsWith('$ACTION_ID_')) {
+      const id = key.slice(11);
+      action = loadServerReference(serverManifest, id, null);
+      return;
+    }
+  });
+
+  if (action === null) {
+    return null;
+  } // Return the action with the remaining FormData bound to the first argument.
+
+
+  return action.then(fn => fn.bind(null, formData));
+}
+function decodeFormState(actionResult, body, serverManifest) {
+  const keyPath = body.get('$ACTION_KEY');
+
+  if (typeof keyPath !== 'string') {
+    // This form submission did not include any form state.
+    return Promise.resolve(null);
+  } // Search through the form data object to get the reference id and the number
+  // of bound arguments. This repeats some of the work done in decodeAction.
+
+
+  let metaData = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+    } // We don't check for the simple $ACTION_ID_ case because form state actions
+    // are always bound to the state argument.
+
+  });
+
+  if (metaData === null) {
+    // Should be unreachable.
+    return Promise.resolve(null);
+  }
+
+  const referenceId = metaData.id;
+  return Promise.resolve(metaData.bound).then(bound => {
+    if (bound === null) {
+      // Should be unreachable because form state actions are always bound to the
+      // state argument.
+      return null;
+    } // The form action dispatch method is always bound to the initial state.
+    // But when comparing signatures, we compare to the original unbound action.
+    // Subtract one from the arity to account for this.
+
+
+    const boundArity = bound.length - 1;
+    return [actionResult, keyPath, referenceId, boundArity];
+  });
+}
+
+function renderToReadableStream(model, webpackMap, options) {
+  const request = createRequest(model, webpackMap, options ? options.onError : undefined, options ? options.context : undefined, options ? options.identifierPrefix : undefined, options ? options.onPostpone : undefined);
+
+  if (options && options.signal) {
+    const signal = options.signal;
+
+    if (signal.aborted) {
+      abort(request, signal.reason);
+    } else {
+      const listener = () => {
+        abort(request, signal.reason);
+        signal.removeEventListener('abort', listener);
+      };
+
+      signal.addEventListener('abort', listener);
+    }
+  }
+
+  const stream = new ReadableStream({
+    type: 'bytes',
+    start: controller => {
+      startWork(request);
+    },
+    pull: controller => {
+      startFlowing(request, controller);
+    },
+    cancel: reason => {
+      stopFlowing(request);
+      abort(request, reason);
+    }
+  }, // $FlowFixMe[prop-missing] size() methods are not allowed on byte streams.
+  {
+    highWaterMark: 0
+  });
+  return stream;
+}
+
+function decodeReply(body, webpackMap) {
+  if (typeof body === 'string') {
+    const form = new FormData();
+    form.append('0', body);
+    body = form;
+  }
+
+  const response = createResponse(webpackMap, '', body);
+  const root = getRoot(response);
+  close(response);
+  return root;
+}
+
+exports.createClientModuleProxy = createClientModuleProxy;
+exports.decodeAction = decodeAction;
+exports.decodeFormState = decodeFormState;
+exports.decodeReply = decodeReply;
+exports.registerClientReference = registerClientReference;
+exports.registerServerReference = registerServerReference;
+exports.renderToReadableStream = renderToReadableStream;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.browser.production.min.js b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.browser.production.min.js
index b1d8792003545..4324326212452 100644
--- a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.browser.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.browser.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-webpack-server.browser.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-webpack-server.browser.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var aa=require("react-dom"),ba=require("react"),l=null,n=0;function p(a,b){if(0!==b.byteLength)if(512<b.byteLength)0<n&&(a.enqueue(new Uint8Array(l.buffer,0,n)),l=new Uint8Array(512),n=0),a.enqueue(b);else{var d=l.length-n;d<b.byteLength&&(0===d?a.enqueue(l):(l.set(b.subarray(0,d),n),a.enqueue(l),b=b.subarray(d)),l=new Uint8Array(512),n=0);l.set(b,n);n+=b.byteLength}return!0}var q=new TextEncoder;function ca(a,b){"function"===typeof a.error?a.error(b):a.close()}
 var r=Symbol.for("react.client.reference"),t=Symbol.for("react.server.reference");function u(a,b,d){return Object.defineProperties(a,{$$typeof:{value:r},$$id:{value:b},$$async:{value:d}})}var da=Function.prototype.bind,ea=Array.prototype.slice;function fa(){var a=da.apply(this,arguments);if(this.$$typeof===t){var b=ea.call(arguments,1);a.$$typeof=t;a.$$id=this.$$id;a.$$bound=this.$$bound?this.$$bound.concat(b):b}return a}
 var ha=Promise.prototype,ia={get:function(a,b){switch(b){case "$$typeof":return a.$$typeof;case "$$id":return a.$$id;case "$$async":return a.$$async;case "name":return a.name;case "displayName":return;case "defaultProps":return;case "toJSON":return;case Symbol.toPrimitive:return Object.prototype[Symbol.toPrimitive];case "Provider":throw Error("Cannot render a Client Context Provider on the Server. Instead, you can export a Client Component wrapper that itself renders a Client Context Provider.");
@@ -76,3 +76,5 @@ exports.decodeFormState=function(a,b,d){var c=b.get("$ACTION_KEY");if("string"!=
 exports.registerClientReference=function(a,b,d){return u(a,b+"#"+d,!1)};exports.registerServerReference=function(a,b,d){return Object.defineProperties(a,{$$typeof:{value:t},$$id:{value:null===d?b:b+"#"+d},$$bound:{value:null},bind:{value:fa}})};
 exports.renderToReadableStream=function(a,b,d){var c=db(a,b,d?d.onError:void 0,d?d.context:void 0,d?d.identifierPrefix:void 0,d?d.onPostpone:void 0);if(d&&d.signal){var e=d.signal;if(e.aborted)ob(c,e.reason);else{var g=function(){ob(c,e.reason);e.removeEventListener("abort",g)};e.addEventListener("abort",g)}}return new ReadableStream({type:"bytes",start:function(){c.flushScheduled=null!==c.destination;jb(c)},pull:function(f){if(1===c.status)c.status=2,ca(f,c.fatalError);else if(2!==c.status&&null===
 c.destination){c.destination=f;try{O(c,f)}catch(k){M(c,k),nb(c,k)}}},cancel:function(f){c.destination=null;ob(c,f)}},{highWaterMark:0})};
+
+//# sourceMappingURL=react-server-dom-webpack-server.browser.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.edge.production.js b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.edge.production.js
new file mode 100644
index 0000000000000..77ce42f078938
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.edge.production.js
@@ -0,0 +1,3130 @@
+/**
+ * @license React
+ * react-server-dom-webpack-server.edge.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require('react');
+var ReactDOM = require('react-dom');
+
+// -----------------------------------------------------------------------------
+const enablePostpone = false;
+
+function scheduleWork(callback) {
+  setTimeout(callback, 0);
+}
+const VIEW_SIZE = 512;
+let currentView = null;
+let writtenBytes = 0;
+function beginWriting(destination) {
+  currentView = new Uint8Array(VIEW_SIZE);
+  writtenBytes = 0;
+}
+function writeChunk(destination, chunk) {
+  if (chunk.byteLength === 0) {
+    return;
+  }
+
+  if (chunk.byteLength > VIEW_SIZE) {
+    // one that is cached by the streaming renderer. We will enqueu
+    // it directly and expect it is not re-used
+
+
+    if (writtenBytes > 0) {
+      destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    destination.enqueue(chunk);
+    return;
+  }
+
+  let bytesToWrite = chunk;
+  const allowableBytes = currentView.length - writtenBytes;
+
+  if (allowableBytes < bytesToWrite.byteLength) {
+    // this chunk would overflow the current view. We enqueue a full view
+    // and start a new view with the remaining chunk
+    if (allowableBytes === 0) {
+      // the current view is already full, send it
+      destination.enqueue(currentView);
+    } else {
+      // fill up the current view and apply the remaining chunk bytes
+      // to a new view.
+      currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes); // writtenBytes += allowableBytes; // this can be skipped because we are going to immediately reset the view
+
+      destination.enqueue(currentView);
+      bytesToWrite = bytesToWrite.subarray(allowableBytes);
+    }
+
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+
+  currentView.set(bytesToWrite, writtenBytes);
+  writtenBytes += bytesToWrite.byteLength;
+}
+function writeChunkAndReturn(destination, chunk) {
+  writeChunk(destination, chunk); // in web streams there is no backpressure so we can alwas write more
+
+  return true;
+}
+function completeWriting(destination) {
+  if (currentView && writtenBytes > 0) {
+    destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+    currentView = null;
+    writtenBytes = 0;
+  }
+}
+function close$1(destination) {
+  destination.close();
+}
+const textEncoder = new TextEncoder();
+function stringToChunk(content) {
+  return textEncoder.encode(content);
+}
+function byteLengthOfChunk(chunk) {
+  return chunk.byteLength;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[method-unbinding]
+  if (typeof destination.error === 'function') {
+    // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+    destination.error(error);
+  } else {
+    // Earlier implementations doesn't support this method. In that environment you're
+    // supposed to throw from a promise returned but we don't return a promise in our
+    // approach. We could fork this implementation but this is environment is an edge
+    // case to begin with. It's even less common to run this in an older environment.
+    // Even then, this is not where errors are supposed to happen and they get reported
+    // to a global callback in addition to this anyway. So it's fine just to close this.
+    destination.close();
+  }
+}
+
+// eslint-disable-next-line no-unused-vars
+const CLIENT_REFERENCE_TAG = Symbol.for('react.client.reference');
+const SERVER_REFERENCE_TAG = Symbol.for('react.server.reference');
+function isClientReference(reference) {
+  return reference.$$typeof === CLIENT_REFERENCE_TAG;
+}
+function isServerReference(reference) {
+  return reference.$$typeof === SERVER_REFERENCE_TAG;
+}
+function registerClientReference(proxyImplementation, id, exportName) {
+  return registerClientReferenceImpl(proxyImplementation, id + '#' + exportName, false);
+}
+
+function registerClientReferenceImpl(proxyImplementation, id, async) {
+  return Object.defineProperties(proxyImplementation, {
+    $$typeof: {
+      value: CLIENT_REFERENCE_TAG
+    },
+    $$id: {
+      value: id
+    },
+    $$async: {
+      value: async
+    }
+  });
+} // $FlowFixMe[method-unbinding]
+
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+
+  if (this.$$typeof === SERVER_REFERENCE_TAG) {
+    const args = ArraySlice.call(arguments, 1);
+    newFn.$$typeof = SERVER_REFERENCE_TAG;
+    newFn.$$id = this.$$id;
+    newFn.$$bound = this.$$bound ? this.$$bound.concat(args) : args;
+  }
+
+  return newFn;
+}
+
+function registerServerReference(reference, id, exportName) {
+  return Object.defineProperties(reference, {
+    $$typeof: {
+      value: SERVER_REFERENCE_TAG
+    },
+    $$id: {
+      value: exportName === null ? id : id + '#' + exportName
+    },
+    $$bound: {
+      value: null
+    },
+    bind: {
+      value: bind
+    }
+  });
+}
+const PROMISE_PROTOTYPE = Promise.prototype;
+const deepProxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        // These names are a little too common. We should probably have a way to
+        // have the Flight runtime extract the inner target instead.
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+
+      case 'displayName':
+        return undefined;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case 'Provider':
+        throw new Error("Cannot render a Client Context Provider on the Server. " + "Instead, you can export a Client Component wrapper " + "that itself renders a Client Context Provider.");
+    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+    const expression = String(target.name) + '.' + String(name);
+    throw new Error("Cannot access " + expression + " on the server. " + 'You cannot dot into a client module from a server component. ' + 'You can only pass the imported name through.');
+  },
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+
+function getReference(target, name) {
+  switch (name) {
+    // These names are read by the Flight runtime if you end up using the exports object.
+    case '$$typeof':
+      return target.$$typeof;
+
+    case '$$id':
+      return target.$$id;
+
+    case '$$async':
+      return target.$$async;
+
+    case 'name':
+      return target.name;
+    // We need to special case this because createElement reads it if we pass this
+    // reference.
+
+    case 'defaultProps':
+      return undefined;
+    // Avoid this attempting to be serialized.
+
+    case 'toJSON':
+      return undefined;
+
+    case Symbol.toPrimitive:
+      // $FlowFixMe[prop-missing]
+      return Object.prototype[Symbol.toPrimitive];
+
+    case '__esModule':
+      // Something is conditionally checking which export to use. We'll pretend to be
+      // an ESM compat module but then we'll check again on the client.
+      const moduleId = target.$$id;
+      target.default = registerClientReferenceImpl(function () {
+        throw new Error("Attempted to call the default export of " + moduleId + " from the server " + "but it's on the client. It's not possible to invoke a client function from " + "the server, it can only be rendered as a Component or passed to props of a " + "Client Component.");
+      }, target.$$id + '#', target.$$async);
+      return true;
+
+    case 'then':
+      if (target.then) {
+        // Use a cached value
+        return target.then;
+      }
+
+      if (!target.$$async) {
+        // If this module is expected to return a Promise (such as an AsyncModule) then
+        // we should resolve that with a client reference that unwraps the Promise on
+        // the client.
+        const clientReference = registerClientReferenceImpl({}, target.$$id, true);
+        const proxy = new Proxy(clientReference, proxyHandlers); // Treat this as a resolved Promise for React's use()
+
+        target.status = 'fulfilled';
+        target.value = proxy;
+        const then = target.then = registerClientReferenceImpl(function then(resolve, reject) {
+          // Expose to React.
+          return Promise.resolve(resolve(proxy));
+        }, // If this is not used as a Promise but is treated as a reference to a `.then`
+        // export then we should treat it as a reference to that name.
+        target.$$id + '#then', false);
+        return then;
+      } else {
+        // Since typeof .then === 'function' is a feature test we'd continue recursing
+        // indefinitely if we return a function. Instead, we return an object reference
+        // if we check further.
+        return undefined;
+      }
+
+  }
+
+  let cachedReference = target[name];
+
+  if (!cachedReference) {
+    const reference = registerClientReferenceImpl(function () {
+      throw new Error( // eslint-disable-next-line react-internal/safe-string-coercion
+      "Attempted to call " + String(name) + "() from the server but " + String(name) + " is on the client. " + "It's not possible to invoke a client function from the server, it can " + "only be rendered as a Component or passed to props of a Client Component.");
+    }, target.$$id + '#' + name, target.$$async);
+    Object.defineProperty(reference, 'name', {
+      value: name
+    });
+    cachedReference = target[name] = new Proxy(reference, deepProxyHandlers);
+  }
+
+  return cachedReference;
+}
+
+const proxyHandlers = {
+  get: function (target, name, receiver) {
+    return getReference(target, name);
+  },
+  getOwnPropertyDescriptor: function (target, name) {
+    let descriptor = Object.getOwnPropertyDescriptor(target, name);
+
+    if (!descriptor) {
+      descriptor = {
+        value: getReference(target, name),
+        writable: false,
+        configurable: false,
+        enumerable: false
+      };
+      Object.defineProperty(target, name, descriptor);
+    }
+
+    return descriptor;
+  },
+
+  getPrototypeOf(target) {
+    // Pretend to be a Promise in case anyone asks.
+    return PROMISE_PROTOTYPE;
+  },
+
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+function createClientModuleProxy(moduleId) {
+  const clientReference = registerClientReferenceImpl({}, // Represents the whole Module object instead of a particular import.
+  moduleId, false);
+  return new Proxy(clientReference, proxyHandlers);
+}
+
+function getClientReferenceKey(reference) {
+  return reference.$$async ? reference.$$id + '#async' : reference.$$id;
+}
+function resolveClientReferenceMetadata(config, clientReference) {
+  const modulePath = clientReference.$$id;
+  let name = '';
+  let resolvedModuleData = config[modulePath];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = modulePath.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = modulePath.slice(idx + 1);
+      resolvedModuleData = config[modulePath.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + modulePath + '" in the React Client Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  }
+
+  if (clientReference.$$async === true) {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1];
+  } else {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+  }
+}
+function getServerReferenceId(config, serverReference) {
+  return serverReference.$$id;
+}
+function getServerReferenceBoundArguments(config, serverReference) {
+  return serverReference.$$bound;
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMFlightServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule: preloadModule$1,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+
+function prefetchDNS(href) {
+  {
+    if (typeof href === 'string' && href) {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'D|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        emitHint(request, 'D', href);
+      }
+    }
+  }
+}
+
+function preconnect(href, crossOrigin) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = "C|" + (crossOrigin == null ? 'null' : crossOrigin) + "|" + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+
+        if (typeof crossOrigin === 'string') {
+          emitHint(request, 'C', [href, crossOrigin]);
+        } else {
+          emitHint(request, 'C', href);
+        }
+      }
+    }
+  }
+}
+
+function preload(href, as, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        let key = 'L';
+
+        if (as === 'image' && options) {
+          key += getImagePreloadKey(href, options.imageSrcSet, options.imageSizes);
+        } else {
+          key += "[" + as + "]" + href;
+        }
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          emitHint(request, 'L', [href, as, trimmed]);
+        } else {
+          emitHint(request, 'L', [href, as]);
+        }
+      }
+    }
+  }
+}
+
+function preloadModule$1(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'm|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'm', [href, trimmed]);
+        } else {
+          return emitHint(request, 'm', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'S|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'S', [href, typeof precedence === 'string' ? precedence : 0, trimmed]);
+        } else if (typeof precedence === 'string') {
+          return emitHint(request, 'S', [href, precedence]);
+        } else {
+          return emitHint(request, 'S', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'X|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'X', [href, trimmed]);
+        } else {
+          return emitHint(request, 'X', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitModuleScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'M|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'M', [href, trimmed]);
+        } else {
+          return emitHint(request, 'M', href);
+        }
+      }
+    }
+  }
+} // Flight normally encodes undefined as a special character however for directive option
+// arguments we don't want to send unnecessary keys and bloat the payload so we create a
+// trimmed object which omits any keys with null or undefined values.
+// This is only typesafe because these option objects have entirely optional fields where
+// null and undefined represent the same thing as no property.
+
+
+function trimOptions(options) {
+  if (options == null) return null;
+  let hasProperties = false;
+  const trimmed = {};
+
+  for (const key in options) {
+    if (options[key] != null) {
+      hasProperties = true;
+      trimmed[key] = options[key];
+    }
+  }
+
+  return hasProperties ? trimmed : null;
+}
+
+function getImagePreloadKey(href, imageSrcSet, imageSizes) {
+  let uniquePart = '';
+
+  if (typeof imageSrcSet === 'string' && imageSrcSet !== '') {
+    uniquePart += '[' + imageSrcSet + ']';
+
+    if (typeof imageSizes === 'string') {
+      uniquePart += '[' + imageSizes + ']';
+    }
+  } else {
+    uniquePart += '[][]' + href;
+  }
+
+  return "[image]" + uniquePart;
+}
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMFlightServerDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+// small, smaller than how we encode undefined, and is unambiguous. We could use
+// a different tuple structure to encode this instead but this makes the runtime
+// cost cheaper by eliminating a type checks in more positions.
+// prettier-ignore
+
+function createHints() {
+  return new Set();
+}
+
+const supportsRequestStorage = typeof AsyncLocalStorage === 'function';
+const requestStorage = supportsRequestStorage ? new AsyncLocalStorage() : null;
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext); // On the way back, we push the new ones that weren't common.
+
+      pushNode(next);
+    }
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFizzWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop, noop);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+let currentRequest$1 = null;
+let thenableIndexCounter = 0;
+let thenableState = null;
+function prepareToUseHooksForRequest(request) {
+  currentRequest$1 = request;
+}
+function resetHooksForRequest() {
+  currentRequest$1 = null;
+}
+function prepareToUseHooksForComponent(prevThenableState) {
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+const HooksDispatcher = {
+  useMemo(nextCreate) {
+    return nextCreate();
+  },
+
+  useCallback(callback) {
+    return callback;
+  },
+
+  useDebugValue() {},
+
+  useDeferredValue: unsupportedHook,
+  useTransition: unsupportedHook,
+  readContext,
+  useContext: readContext,
+  useReducer: unsupportedHook,
+  useRef: unsupportedHook,
+  useState: unsupportedHook,
+  useInsertionEffect: unsupportedHook,
+  useLayoutEffect: unsupportedHook,
+  useImperativeHandle: unsupportedHook,
+  useEffect: unsupportedHook,
+  useId,
+  useSyncExternalStore: unsupportedHook,
+
+  useCacheRefresh() {
+    return unsupportedRefresh;
+  },
+
+  useMemoCache(size) {
+    const data = new Array(size);
+
+    for (let i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL;
+    }
+
+    return data;
+  },
+
+  use
+};
+
+function unsupportedHook() {
+  throw new Error('This Hook is not supported in Server Components.');
+}
+
+function unsupportedRefresh() {
+  throw new Error('Refreshing the cache is not supported in Server Components.');
+}
+
+function useId() {
+  if (currentRequest$1 === null) {
+    throw new Error('useId can only be used while React is rendering');
+  }
+
+  const id = currentRequest$1.identifierCount++; // use 'S' for Flight components to distinguish from 'R' and 'r' in Fizz/Client
+
+  return ':' + currentRequest$1.identifierPrefix + 'S' + id.toString(32) + ':';
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object' || typeof usable === 'function') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable; // Track the position of the thenable within this fiber.
+
+      const index = thenableIndexCounter;
+      thenableIndexCounter += 1;
+
+      if (thenableState === null) {
+        thenableState = createThenableState();
+      }
+
+      return trackUsedThenable(thenableState, thenable, index);
+    } else if (usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  }
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function createSignal() {
+  return new AbortController().signal;
+}
+
+function resolveCache() {
+  const request = resolveRequest();
+
+  if (request) {
+    return getCache(request);
+  }
+
+  return new Map();
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal() {
+    const cache = resolveCache();
+    let entry = cache.get(createSignal);
+
+    if (entry === undefined) {
+      entry = createSignal();
+      cache.set(createSignal, entry);
+    }
+
+    return entry;
+  },
+
+  getCacheForType(resourceType) {
+    const cache = resolveCache();
+    let entry = cache.get(resourceType);
+
+    if (entry === undefined) {
+      entry = resourceType(); // TODO: Warn if undefined?
+
+      cache.set(resourceType, entry);
+    }
+
+    return entry;
+  }
+
+};
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+function objectName(object) {
+  // $FlowFixMe[method-unbinding]
+  const name = Object.prototype.toString.call(object);
+  return name.replace(/^\[object (.*)\]$/, function (m, p0) {
+    return p0;
+  });
+}
+
+function describeKeyForErrorMessage(key) {
+  const encodedKey = JSON.stringify(key);
+  return '"' + key + '"' === encodedKey ? key : encodedKey;
+}
+
+function describeValueForErrorMessage(value) {
+  switch (typeof value) {
+    case 'string':
+      {
+        return JSON.stringify(value.length <= 10 ? value : value.slice(0, 10) + '...');
+      }
+
+    case 'object':
+      {
+        if (isArray(value)) {
+          return '[...]';
+        }
+
+        const name = objectName(value);
+
+        if (name === 'Object') {
+          return '{...}';
+        }
+
+        return name;
+      }
+
+    case 'function':
+      return 'function';
+
+    default:
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      return String(value);
+  }
+}
+
+function describeElementType(type) {
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        return describeElementType(type.render);
+
+      case REACT_MEMO_TYPE:
+        return describeElementType(type.type);
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            // Lazy may contain any component type so we recursively resolve it.
+            return describeElementType(init(payload));
+          } catch (x) {}
+        }
+    }
+  }
+
+  return '';
+}
+
+function describeObjectForErrorMessage(objectOrArray, expandedName) {
+  const objKind = objectName(objectOrArray);
+
+  if (objKind !== 'Object' && objKind !== 'Array') {
+    return objKind;
+  }
+
+  let str = '';
+  let start = -1;
+  let length = 0;
+
+  if (isArray(objectOrArray)) {
+    {
+      // Print Array
+      str = '[';
+      const array = objectOrArray;
+
+      for (let i = 0; i < array.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const value = array[i];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if ('' + i === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += ']';
+    }
+  } else {
+    if (objectOrArray.$$typeof === REACT_ELEMENT_TYPE) {
+      str = '<' + describeElementType(objectOrArray.type) + '/>';
+    } else {
+      // Print Object
+      str = '{';
+      const object = objectOrArray;
+      const names = Object.keys(object);
+
+      for (let i = 0; i < names.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const name = names[i];
+        str += describeKeyForErrorMessage(name) + ': ';
+        const value = object[name];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if (name === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += '}';
+    }
+  }
+
+  if (expandedName === undefined) {
+    return str;
+  }
+
+  if (start > -1 && length > 0) {
+    const highlight = ' '.repeat(start) + '^'.repeat(length);
+    return '\n  ' + str + '\n  ' + highlight;
+  }
+
+  return '\n  ' + str;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactSharedServerInternals = // $FlowFixMe: It's defined in the one we resolve to.
+React.__SECRET_SERVER_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+if (!ReactSharedServerInternals) {
+  throw new Error('The "react" package in this environment is not configured correctly. ' + 'The "react-server" condition must be enabled in any environment that ' + 'runs React Server Components.');
+}
+
+const ObjectPrototype = Object.prototype;
+const stringify = JSON.stringify; // Serializable values
+// Thenable<ReactClientValue>
+
+const PENDING$1 = 0;
+const COMPLETED = 1;
+const ABORTED = 3;
+const ERRORED$1 = 4;
+const ReactCurrentCache = ReactSharedServerInternals.ReactCurrentCache;
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+}
+
+function defaultPostponeHandler(reason) {// Noop
+}
+
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2;
+function createRequest(model, bundlerConfig, onError, context, identifierPrefix, onPostpone) {
+  if (ReactCurrentCache.current !== null && ReactCurrentCache.current !== DefaultCacheDispatcher) {
+    throw new Error('Currently React only supports one RSC renderer at a time.');
+  }
+
+  prepareHostDispatcher();
+  ReactCurrentCache.current = DefaultCacheDispatcher;
+  const abortSet = new Set();
+  const pingedTasks = [];
+  const cleanupQueue = [];
+
+  const hints = createHints();
+  const request = {
+    status: OPEN,
+    flushScheduled: false,
+    fatalError: null,
+    destination: null,
+    bundlerConfig,
+    cache: new Map(),
+    nextChunkId: 0,
+    pendingChunks: 0,
+    hints,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    completedImportChunks: [],
+    completedHintChunks: [],
+    completedRegularChunks: [],
+    completedErrorChunks: [],
+    writtenSymbols: new Map(),
+    writtenClientReferences: new Map(),
+    writtenServerReferences: new Map(),
+    writtenProviders: new Map(),
+    writtenObjects: new WeakMap(),
+    identifierPrefix: identifierPrefix || '',
+    identifierCount: 1,
+    taintCleanupQueue: cleanupQueue,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? defaultPostponeHandler : onPostpone,
+    // $FlowFixMe[missing-this-annot]
+    toJSON: function (key, value) {
+      return resolveModelToJSON(request, this, key, value);
+    }
+  };
+  request.pendingChunks++;
+  const rootContext = createRootContext();
+  const rootTask = createTask(request, model, rootContext, abortSet);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  if (supportsRequestStorage) {
+    const store = requestStorage.getStore();
+    if (store) return store;
+  }
+
+  return null;
+}
+
+function createRootContext(reqContext) {
+  return importServerContexts();
+}
+
+function serializeThenable(request, thenable) {
+  request.pendingChunks++;
+  const newTask = createTask(request, null, getActiveContext(), request.abortableTasks);
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        // We have the resolved value, we can go ahead and schedule it for serialization.
+        newTask.model = thenable.value;
+        pingTask(request, newTask);
+        return newTask.id;
+      }
+
+    case 'rejected':
+      {
+        const x = thenable.reason;
+
+        {
+          const digest = logRecoverableError(request, x);
+          emitErrorChunk(request, newTask.id, digest);
+        }
+
+        return newTask.id;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  thenable.then(value => {
+    newTask.model = value;
+    pingTask(request, newTask);
+  }, reason => {
+    newTask.status = ERRORED$1;
+    request.abortableTasks.delete(newTask); // TODO: We should ideally do this inside performWork so it's scheduled
+
+    const digest = logRecoverableError(request, reason);
+    emitErrorChunk(request, newTask.id, digest);
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  });
+  return newTask.id;
+}
+
+function emitHint(request, code, model) {
+  emitHintChunk(request, code, model);
+  enqueueFlush(request);
+}
+function getHints(request) {
+  return request.hints;
+}
+function getCache(request) {
+  return request.cache;
+}
+
+function readThenable(thenable) {
+  if (thenable.status === 'fulfilled') {
+    return thenable.value;
+  } else if (thenable.status === 'rejected') {
+    throw thenable.reason;
+  }
+
+  throw thenable;
+}
+
+function createLazyWrapperAroundWakeable(wakeable) {
+  // This is a temporary fork of the `use` implementation until we accept
+  // promises everywhere.
+  const thenable = wakeable;
+
+  switch (thenable.status) {
+    case 'fulfilled':
+    case 'rejected':
+      break;
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: thenable,
+    _init: readThenable
+  };
+  return lazyType;
+}
+
+function attemptResolveElement(request, type, key, ref, props, prevThenableState) {
+  if (ref !== null && ref !== undefined) {
+    // When the ref moves to the regular props object this will implicitly
+    // throw for functions. We could probably relax it to a DEV warning for other
+    // cases.
+    throw new Error('Refs cannot be used in Server Components, nor passed to Client Components.');
+  }
+
+  if (typeof type === 'function') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    } // This is a server-side component.
+
+
+    prepareToUseHooksForComponent(prevThenableState);
+    const result = type(props);
+
+    if (typeof result === 'object' && result !== null && typeof result.then === 'function') {
+      // When the return value is in children position we can resolve it immediately,
+      // to its value without a wrapper if it's synchronously available.
+      const thenable = result;
+
+      if (thenable.status === 'fulfilled') {
+        return thenable.value;
+      } // TODO: Once we accept Promises as children on the client, we can just return
+      // the thenable here.
+
+
+      return createLazyWrapperAroundWakeable(result);
+    }
+
+    return result;
+  } else if (typeof type === 'string') {
+    // This is a host element. E.g. HTML.
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (typeof type === 'symbol') {
+    if (type === REACT_FRAGMENT_TYPE) {
+      // For key-less fragments, we add a small optimization to avoid serializing
+      // it as a wrapper.
+      // TODO: If a key is specified, we should propagate its key to any children.
+      // Same as if a Server Component has a key.
+      return props.children;
+    } // This might be a built-in React component. We'll let the client decide.
+    // Any built-in works as long as its props are serializable.
+
+
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (type != null && typeof type === 'object') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    }
+
+    switch (type.$$typeof) {
+      case REACT_LAZY_TYPE:
+        {
+          const payload = type._payload;
+          const init = type._init;
+          const wrappedType = init(payload);
+          return attemptResolveElement(request, wrappedType, key, ref, props, prevThenableState);
+        }
+
+      case REACT_FORWARD_REF_TYPE:
+        {
+          const render = type.render;
+          prepareToUseHooksForComponent(prevThenableState);
+          return render(props, undefined);
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          return attemptResolveElement(request, type.type, key, ref, props, prevThenableState);
+        }
+    }
+  }
+
+  throw new Error("Unsupported Server Component type: " + describeValueForErrorMessage(type));
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createTask(request, model, context, abortSet) {
+  const id = request.nextChunkId++;
+  const task = {
+    id,
+    status: PENDING$1,
+    model,
+    context,
+    ping: () => pingTask(request, task),
+    thenableState: null
+  };
+  abortSet.add(task);
+  return task;
+}
+
+function serializeByValueID(id) {
+  return '$' + id.toString(16);
+}
+
+function serializeLazyID(id) {
+  return '$L' + id.toString(16);
+}
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeRowHeader(tag, id) {
+  return id.toString(16) + ':' + tag;
+}
+
+function encodeReferenceChunk(request, id, reference) {
+  const json = stringify(reference);
+  const row = id.toString(16) + ':' + json + '\n';
+  return stringToChunk(row);
+}
+
+function serializeClientReference(request, parent, key, clientReference) {
+  const clientReferenceKey = getClientReferenceKey(clientReference);
+  const writtenClientReferences = request.writtenClientReferences;
+  const existingId = writtenClientReferences.get(clientReferenceKey);
+
+  if (existingId !== undefined) {
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(existingId);
+    }
+
+    return serializeByValueID(existingId);
+  }
+
+  try {
+    const clientReferenceMetadata = resolveClientReferenceMetadata(request.bundlerConfig, clientReference);
+    request.pendingChunks++;
+    const importId = request.nextChunkId++;
+    emitImportChunk(request, importId, clientReferenceMetadata);
+    writtenClientReferences.set(clientReferenceKey, importId);
+
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(importId);
+    }
+
+    return serializeByValueID(importId);
+  } catch (x) {
+    request.pendingChunks++;
+    const errorId = request.nextChunkId++;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, errorId, digest);
+    return serializeByValueID(errorId);
+  }
+}
+
+function outlineModel(request, value) {
+  request.pendingChunks++;
+  const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+  retryTask(request, newTask);
+  return newTask.id;
+}
+
+function serializeServerReference(request, parent, key, serverReference) {
+  const writtenServerReferences = request.writtenServerReferences;
+  const existingId = writtenServerReferences.get(serverReference);
+
+  if (existingId !== undefined) {
+    return serializeServerReferenceID(existingId);
+  }
+
+  const bound = getServerReferenceBoundArguments(request.bundlerConfig, serverReference);
+  const serverReferenceMetadata = {
+    id: getServerReferenceId(request.bundlerConfig, serverReference),
+    bound: bound ? Promise.resolve(bound) : null
+  };
+  const metadataId = outlineModel(request, serverReferenceMetadata);
+  writtenServerReferences.set(serverReference, metadataId);
+  return serializeServerReferenceID(metadataId);
+}
+
+function serializeLargeTextString(request, text) {
+  request.pendingChunks += 2;
+  const textId = request.nextChunkId++;
+  const textChunk = stringToChunk(text);
+  const binaryLength = byteLengthOfChunk(textChunk);
+  const row = textId.toString(16) + ':T' + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, textChunk);
+  return serializeByValueID(textId);
+}
+
+function serializeMap(request, map) {
+  const entries = Array.from(map);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i][0];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$Q' + id.toString(16);
+}
+
+function serializeSet(request, set) {
+  const entries = Array.from(set);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+let modelRoot = false;
+
+function resolveModelToJSON(request, parent, key, value) {
+
+
+  switch (value) {
+    case REACT_ELEMENT_TYPE:
+      return '$';
+  }
+
+
+  while (typeof value === 'object' && value !== null && (value.$$typeof === REACT_ELEMENT_TYPE || value.$$typeof === REACT_LAZY_TYPE)) {
+
+    try {
+      switch (value.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const writtenObjects = request.writtenObjects;
+            const existingId = writtenObjects.get(value);
+
+            if (existingId !== undefined) {
+              if (existingId === -1) {
+                // Seen but not yet outlined.
+                const newId = outlineModel(request, value);
+                return serializeByValueID(newId);
+              } else if (modelRoot === value) {
+                // This is the ID we're currently emitting so we need to write it
+                // once but if we discover it again, we refer to it by id.
+                modelRoot = null;
+              } else {
+                // We've already emitted this as an outlined object, so we can
+                // just refer to that by its existing ID.
+                return serializeByValueID(existingId);
+              }
+            } else {
+              // This is the first time we've seen this object. We may never see it again
+              // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+              writtenObjects.set(value, -1);
+            } // TODO: Concatenate keys of parents onto children.
+
+
+            const element = value; // Attempt to render the Server Component.
+
+            value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, null);
+            break;
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = value._payload;
+            const init = value._init;
+            value = init(payload);
+            break;
+          }
+      }
+    } catch (thrownValue) {
+      const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          // Something suspended, we'll need to create a new task and resolve it later.
+          request.pendingChunks++;
+          const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+          const ping = newTask.ping;
+          x.then(ping, ping);
+          newTask.thenableState = getThenableStateAfterSuspending();
+          return serializeLazyID(newTask.id);
+        }
+      } // Something errored. We'll still send everything we have up until this point.
+      // We'll replace this element with a lazy reference that throws on the client
+      // once it gets rendered.
+
+
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+      const digest = logRecoverableError(request, x);
+      emitErrorChunk(request, errorId, digest);
+      return serializeLazyID(errorId);
+    }
+  }
+
+  if (value === null) {
+    return null;
+  }
+
+  if (typeof value === 'object') {
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    const writtenObjects = request.writtenObjects;
+    const existingId = writtenObjects.get(value); // $FlowFixMe[method-unbinding]
+
+    if (typeof value.then === 'function') {
+      if (existingId !== undefined) {
+        if (modelRoot === value) {
+          // This is the ID we're currently emitting so we need to write it
+          // once but if we discover it again, we refer to it by id.
+          modelRoot = null;
+        } else {
+          // We've seen this promise before, so we can just refer to the same result.
+          return serializePromiseID(existingId);
+        }
+      } // We assume that any object with a .then property is a "Thenable" type,
+      // or a Promise type. Either of which can be represented by a Promise.
+
+
+      const promiseId = serializeThenable(request, value);
+      writtenObjects.set(value, promiseId);
+      return serializePromiseID(promiseId);
+    }
+
+    if (existingId !== undefined) {
+      if (existingId === -1) {
+        // Seen but not yet outlined.
+        const newId = outlineModel(request, value);
+        return serializeByValueID(newId);
+      } else if (modelRoot === value) {
+        // This is the ID we're currently emitting so we need to write it
+        // once but if we discover it again, we refer to it by id.
+        modelRoot = null;
+      } else {
+        // We've already emitted this as an outlined object, so we can
+        // just refer to that by its existing ID.
+        return serializeByValueID(existingId);
+      }
+    } else {
+      // This is the first time we've seen this object. We may never see it again
+      // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+      writtenObjects.set(value, -1);
+    }
+
+    if (isArray(value)) {
+      // $FlowFixMe[incompatible-return]
+      return value;
+    }
+
+    if (value instanceof Map) {
+      return serializeMap(request, value);
+    }
+
+    if (value instanceof Set) {
+      return serializeSet(request, value);
+    }
+
+    const iteratorFn = getIteratorFn(value);
+
+    if (iteratorFn) {
+      return Array.from(value);
+    } // Verify that this is a simple plain object.
+
+
+    const proto = getPrototypeOf(value);
+
+    if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+      throw new Error('Only plain objects, and a few built-ins, can be passed to Client Components ' + 'from Server Components. Classes or null prototypes are not supported.');
+    }
+
+
+    return value;
+  }
+
+  if (typeof value === 'string') {
+
+
+    if (value[value.length - 1] === 'Z') {
+      // Possibly a Date, whose toJSON automatically calls toISOString
+      // $FlowFixMe[incompatible-use]
+      const originalValue = parent[key];
+
+      if (originalValue instanceof Date) {
+        return serializeDateFromDateJSON(value);
+      }
+    }
+
+    if (value.length >= 1024) {
+      // For large strings, we encode them outside the JSON payload so that we
+      // don't have to double encode and double parse the strings. This can also
+      // be more compact in case the string has a lot of escaped characters.
+      return serializeLargeTextString(request, value);
+    }
+
+    return escapeStringValue(value);
+  }
+
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  if (typeof value === 'number') {
+    return serializeNumber(value);
+  }
+
+  if (typeof value === 'undefined') {
+    return serializeUndefined();
+  }
+
+  if (typeof value === 'function') {
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    if (isServerReference(value)) {
+      return serializeServerReference(request, parent, key, value);
+    }
+
+    if (/^on[A-Z]/.test(key)) {
+      throw new Error('Event handlers cannot be passed to Client Component props.' + describeObjectForErrorMessage(parent, key) + '\nIf you need interactivity, consider converting part of this to a Client Component.');
+    } else {
+      throw new Error('Functions cannot be passed directly to Client Components ' + 'unless you explicitly expose it by marking it with "use server".' + describeObjectForErrorMessage(parent, key));
+    }
+  }
+
+  if (typeof value === 'symbol') {
+    const writtenSymbols = request.writtenSymbols;
+    const existingId = writtenSymbols.get(value);
+
+    if (existingId !== undefined) {
+      return serializeByValueID(existingId);
+    } // $FlowFixMe[incompatible-type] `description` might be undefined
+
+
+    const name = value.description;
+
+    if (Symbol.for(name) !== value) {
+      throw new Error('Only global symbols received from Symbol.for(...) can be passed to Client Components. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+      value.description + ") cannot be found among global symbols.") + describeObjectForErrorMessage(parent, key));
+    }
+
+    request.pendingChunks++;
+    const symbolId = request.nextChunkId++;
+    emitSymbolChunk(request, symbolId, name);
+    writtenSymbols.set(value, symbolId);
+    return serializeByValueID(symbolId);
+  }
+
+  if (typeof value === 'bigint') {
+
+    return serializeBigInt(value);
+  }
+
+  throw new Error("Type " + typeof value + " is not supported in Client Component props." + describeObjectForErrorMessage(parent, key));
+}
+
+function logPostpone(request, reason) {
+  const onPostpone = request.onPostpone;
+  onPostpone(reason);
+}
+
+function logRecoverableError(request, error) {
+  const onError = request.onError;
+  const errorDigest = onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest || '';
+}
+
+function fatalError(request, error) {
+
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function emitPostponeChunk(request, id, postponeInstance) {
+  let row;
+
+  {
+    // No reason included in prod.
+    row = serializeRowHeader('P', id) + '\n';
+  }
+
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitErrorChunk(request, id, digest, error) {
+  let errorInfo;
+
+  {
+    errorInfo = {
+      digest
+    };
+  }
+
+  const row = serializeRowHeader('E', id) + stringify(errorInfo) + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitImportChunk(request, id, clientReferenceMetadata) {
+  // $FlowFixMe[incompatible-type] stringify can return null
+  const json = stringify(clientReferenceMetadata);
+  const row = serializeRowHeader('I', id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitHintChunk(request, code, model) {
+  const json = stringify(model);
+  const id = request.nextChunkId++;
+  const row = serializeRowHeader('H' + code, id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedHintChunks.push(processedChunk);
+}
+
+function emitSymbolChunk(request, id, name) {
+  const symbolReference = serializeSymbolReference(name);
+  const processedChunk = encodeReferenceChunk(request, id, symbolReference);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitModelChunk(request, id, model) {
+  // Track the root so we know that we have to emit this object even though it
+  // already has an ID. This is needed because we might see this object twice
+  // in the same toJSON if it is cyclic.
+  modelRoot = model; // $FlowFixMe[incompatible-type] stringify can return null
+
+  const json = stringify(model, request.toJSON);
+  const row = id.toString(16) + ':' + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function retryTask(request, task) {
+  if (task.status !== PENDING$1) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  }
+
+  switchContext(task.context);
+
+  try {
+    let value = task.model;
+
+    if (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+      request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+      const element = value; // When retrying a component, reuse the thenableState from the
+      // previous attempt.
+
+      const prevThenableState = task.thenableState; // Attempt to render the Server Component.
+      // Doing this here lets us reuse this same task if the next component
+      // also suspends.
+
+      task.model = value;
+      value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, prevThenableState); // Successfully finished this component. We're going to keep rendering
+      // using the same task, but we reset its thenable state before continuing.
+
+      task.thenableState = null; // Keep rendering and reuse the same task. This inner loop is separate
+      // from the render above because we don't need to reset the thenable state
+      // until the next time something suspends and retries.
+
+      while (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+        request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+        const nextElement = value;
+        task.model = value;
+        value = attemptResolveElement(request, nextElement.type, nextElement.key, nextElement.ref, nextElement.props, null);
+      }
+    } // Track that this object is outlined and has an id.
+
+
+    if (typeof value === 'object' && value !== null) {
+      request.writtenObjects.set(value, task.id);
+    }
+
+    emitModelChunk(request, task.id, value);
+    request.abortableTasks.delete(task);
+    task.status = COMPLETED;
+  } catch (thrownValue) {
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    request.abortableTasks.delete(task);
+    task.status = ERRORED$1;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, task.id, digest);
+  }
+}
+
+function performWork(request) {
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  const prevRequest = currentRequest;
+  currentRequest = request;
+  prepareToUseHooksForRequest(request);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    request.pingedTasks = [];
+
+    for (let i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    ReactCurrentDispatcher.current = prevDispatcher;
+    resetHooksForRequest();
+    currentRequest = prevRequest;
+  }
+}
+
+function abortTask(task, request, errorId) {
+  task.status = ABORTED; // Instead of emitting an error per task.id, we emit a model that only
+  // has a single value referencing the error.
+
+  const ref = serializeByValueID(errorId);
+  const processedChunk = encodeReferenceChunk(request, task.id, ref);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function flushCompletedChunks(request, destination) {
+  beginWriting();
+
+  try {
+    // We emit module chunks first in the stream so that
+    // they can be preloaded as early as possible.
+    const importsChunks = request.completedImportChunks;
+    let i = 0;
+
+    for (; i < importsChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = importsChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    importsChunks.splice(0, i); // Next comes hints.
+
+    const hintChunks = request.completedHintChunks;
+    i = 0;
+
+    for (; i < hintChunks.length; i++) {
+      const chunk = hintChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    hintChunks.splice(0, i); // Next comes model data.
+
+    const regularChunks = request.completedRegularChunks;
+    i = 0;
+
+    for (; i < regularChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = regularChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    regularChunks.splice(0, i); // Finally, errors are sent. The idea is that it's ok to delay
+    // any error messages and prioritize display of other parts of
+    // the page.
+
+    const errorChunks = request.completedErrorChunks;
+    i = 0;
+
+    for (; i < errorChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = errorChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) ;
+    }
+
+    errorChunks.splice(0, i);
+  } finally {
+    request.flushScheduled = false;
+    completeWriting(destination);
+  }
+
+  if (request.pendingChunks === 0) {
+
+    close$1(destination);
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  if (supportsRequestStorage) {
+    scheduleWork(() => requestStorage.run(request, performWork, request));
+  } else {
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    const destination = request.destination;
+    request.flushScheduled = true;
+    scheduleWork(() => flushCompletedChunks(request, destination));
+  }
+}
+
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedChunks(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function stopFlowing(request) {
+  request.destination = null;
+} // This is called to early terminate a request. It creates an error at all pending tasks.
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      // We have tasks to abort. We'll emit one error row and then emit a reference
+      // to that row from every row that's still remaining.
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+
+      if (enablePostpone && typeof reason === 'object' && reason !== null && reason.$$typeof === REACT_POSTPONE_TYPE) ; else {
+        const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+        const digest = logRecoverableError(request, error);
+        emitErrorChunk(request, errorId, digest, error);
+      }
+
+      abortableTasks.forEach(task => abortTask(task, request, errorId));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function importServerContexts(contexts) {
+
+  return rootContextSnapshot;
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+function resolveServerReference(bundlerConfig, id) {
+  let name = '';
+  let resolvedModuleData = bundlerConfig[id];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = id.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = id.slice(idx + 1);
+      resolvedModuleData = bundlerConfig[id.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + id + '" in the React Server Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  } // TODO: This needs to return async: true if it's an async module.
+
+
+  return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+} // The chunk cache contains all the chunks we've preloaded so far.
+// If they're still pending they're a thenable. This map also exists
+// in Webpack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = globalThis.__next_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+  let i = 0;
+
+  while (i < chunks.length) {
+    const chunkId = chunks[i++];
+    chunks[i++];
+    const entry = chunkCache.get(chunkId);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkId);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkId, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkId, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = globalThis.__next_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+function loadChunk(chunkId, filename) {
+  return __webpack_chunk_load__(chunkId);
+}
+
+// The server acts as a Client of itself when resolving Server References.
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const RESOLVED_MODEL = 'resolved_model';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function bindArgs$1(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference$1(response, id, bound, parentChunk, parentObject, key) {
+  const serverReference = resolveServerReference(response._bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+  let promise;
+
+  if (bound) {
+    promise = Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs$1(requireModule(serverReference), args);
+    });
+  } else {
+    if (preloadPromise) {
+      promise = Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+    } else {
+      // Synchronously available
+      return requireModule(serverReference);
+    }
+  }
+
+  promise.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk)); // We need a placeholder value that will be replaced later.
+
+  return null;
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+
+  try {
+    const value = JSON.parse(chunk.value, chunk._response._fromJSON);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    const prefix = response._prefix;
+    const key = prefix + id; // Check if we have this field in the backing store already.
+
+    const backingEntry = response._formData.get(key);
+
+    if (backingEntry != null) {
+      // We assume that this is a string entry for now.
+      chunk = createResolvedModelChunk(response, backingEntry);
+    } else {
+      // We're still waiting on this entry to stream in.
+      chunk = createPendingChunk(response);
+    }
+
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+    blocked.deps++;
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  if (chunk.status === RESOLVED_MODEL) {
+    initializeModelChunk(chunk);
+  }
+
+  if (chunk.status !== INITIALIZED) {
+    // We know that this is emitted earlier so otherwise it's an error.
+    throw chunk.reason;
+  }
+
+  return chunk.value;
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16); // TODO: Just encode this in the reference inline instead of as a model.
+
+          const metaData = getOutlinedModel(response, id);
+          return loadServerReference$1(response, metaData.id, metaData.bound, initializingChunk, parentObject, key);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'K':
+        {
+          // FormData
+          const stringId = value.slice(2);
+          const formPrefix = response._prefix + stringId + '_';
+          const data = new FormData();
+          const backingFormData = response._formData; // We assume that the reference to FormData always comes after each
+          // entry that it references so we can assume they all exist in the
+          // backing store already.
+          // $FlowFixMe[prop-missing] FormData has forEach on it.
+
+          backingFormData.forEach((entry, entryKey) => {
+            if (entryKey.startsWith(formPrefix)) {
+              data.append(entryKey.slice(formPrefix.length), entry);
+            }
+          });
+          return data;
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function createResponse(bundlerConfig, formFieldPrefix) {
+  let backingFormData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new FormData();
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _prefix: formFieldPrefix,
+    _formData: backingFormData,
+    _chunks: chunks,
+    _fromJSON: function (key, value) {
+      if (typeof value === 'string') {
+        // We can't use .bind here because we need the "this" value.
+        return parseModelString(response, this, key, value);
+      }
+
+      return value;
+    }
+  };
+  return response;
+}
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function bindArgs(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference(bundlerConfig, id, bound) {
+  const serverReference = resolveServerReference(bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+
+  if (bound) {
+    return Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs(requireModule(serverReference), args);
+    });
+  } else if (preloadPromise) {
+    return Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+  } else {
+    // Synchronously available
+    return Promise.resolve(requireModule(serverReference));
+  }
+}
+
+function decodeBoundActionMetaData(body, serverManifest, formFieldPrefix) {
+  // The data for this reference is encoded in multiple fields under this prefix.
+  const actionResponse = createResponse(serverManifest, formFieldPrefix, body);
+  close(actionResponse);
+  const refPromise = getRoot(actionResponse); // Force it to initialize
+  // $FlowFixMe
+
+  refPromise.then(() => {});
+
+  if (refPromise.status !== 'fulfilled') {
+    // $FlowFixMe
+    throw refPromise.reason;
+  }
+
+  return refPromise.value;
+}
+
+function decodeAction(body, serverManifest) {
+  // We're going to create a new formData object that holds all the fields except
+  // the implementation details of the action data.
+  const formData = new FormData();
+  let action = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (!key.startsWith('$ACTION_')) {
+      formData.append(key, value);
+      return;
+    } // Later actions may override earlier actions if a button is used to override the default
+    // form action.
+
+
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      const metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+      action = loadServerReference(serverManifest, metaData.id, metaData.bound);
+      return;
+    }
+
+    if (key.startsWith('$ACTION_ID_')) {
+      const id = key.slice(11);
+      action = loadServerReference(serverManifest, id, null);
+      return;
+    }
+  });
+
+  if (action === null) {
+    return null;
+  } // Return the action with the remaining FormData bound to the first argument.
+
+
+  return action.then(fn => fn.bind(null, formData));
+}
+function decodeFormState(actionResult, body, serverManifest) {
+  const keyPath = body.get('$ACTION_KEY');
+
+  if (typeof keyPath !== 'string') {
+    // This form submission did not include any form state.
+    return Promise.resolve(null);
+  } // Search through the form data object to get the reference id and the number
+  // of bound arguments. This repeats some of the work done in decodeAction.
+
+
+  let metaData = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+    } // We don't check for the simple $ACTION_ID_ case because form state actions
+    // are always bound to the state argument.
+
+  });
+
+  if (metaData === null) {
+    // Should be unreachable.
+    return Promise.resolve(null);
+  }
+
+  const referenceId = metaData.id;
+  return Promise.resolve(metaData.bound).then(bound => {
+    if (bound === null) {
+      // Should be unreachable because form state actions are always bound to the
+      // state argument.
+      return null;
+    } // The form action dispatch method is always bound to the initial state.
+    // But when comparing signatures, we compare to the original unbound action.
+    // Subtract one from the arity to account for this.
+
+
+    const boundArity = bound.length - 1;
+    return [actionResult, keyPath, referenceId, boundArity];
+  });
+}
+
+function renderToReadableStream(model, webpackMap, options) {
+  const request = createRequest(model, webpackMap, options ? options.onError : undefined, options ? options.context : undefined, options ? options.identifierPrefix : undefined, options ? options.onPostpone : undefined);
+
+  if (options && options.signal) {
+    const signal = options.signal;
+
+    if (signal.aborted) {
+      abort(request, signal.reason);
+    } else {
+      const listener = () => {
+        abort(request, signal.reason);
+        signal.removeEventListener('abort', listener);
+      };
+
+      signal.addEventListener('abort', listener);
+    }
+  }
+
+  const stream = new ReadableStream({
+    type: 'bytes',
+    start: controller => {
+      startWork(request);
+    },
+    pull: controller => {
+      startFlowing(request, controller);
+    },
+    cancel: reason => {
+      stopFlowing(request);
+      abort(request, reason);
+    }
+  }, // $FlowFixMe[prop-missing] size() methods are not allowed on byte streams.
+  {
+    highWaterMark: 0
+  });
+  return stream;
+}
+
+function decodeReply(body, webpackMap) {
+  if (typeof body === 'string') {
+    const form = new FormData();
+    form.append('0', body);
+    body = form;
+  }
+
+  const response = createResponse(webpackMap, '', body);
+  const root = getRoot(response);
+  close(response);
+  return root;
+}
+
+exports.createClientModuleProxy = createClientModuleProxy;
+exports.decodeAction = decodeAction;
+exports.decodeFormState = decodeFormState;
+exports.decodeReply = decodeReply;
+exports.registerClientReference = registerClientReference;
+exports.registerServerReference = registerServerReference;
+exports.renderToReadableStream = renderToReadableStream;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.edge.production.min.js b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.edge.production.min.js
index c5b6afab107ce..f6b4353e9d00a 100644
--- a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.edge.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.edge.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-webpack-server.edge.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-webpack-server.edge.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var aa=require("react"),ba=require("react-dom"),m=null,n=0;function p(a,b){if(0!==b.byteLength)if(512<b.byteLength)0<n&&(a.enqueue(new Uint8Array(m.buffer,0,n)),m=new Uint8Array(512),n=0),a.enqueue(b);else{var d=m.length-n;d<b.byteLength&&(0===d?a.enqueue(m):(m.set(b.subarray(0,d),n),a.enqueue(m),b=b.subarray(d)),m=new Uint8Array(512),n=0);m.set(b,n);n+=b.byteLength}return!0}var q=new TextEncoder;function ca(a,b){"function"===typeof a.error?a.error(b):a.close()}
 var r=Symbol.for("react.client.reference"),t=Symbol.for("react.server.reference");function u(a,b,d){return Object.defineProperties(a,{$$typeof:{value:r},$$id:{value:b},$$async:{value:d}})}var da=Function.prototype.bind,ea=Array.prototype.slice;function fa(){var a=da.apply(this,arguments);if(this.$$typeof===t){var b=ea.call(arguments,1);a.$$typeof=t;a.$$id=this.$$id;a.$$bound=this.$$bound?this.$$bound.concat(b):b}return a}
 var ha=Promise.prototype,ia={get:function(a,b){switch(b){case "$$typeof":return a.$$typeof;case "$$id":return a.$$id;case "$$async":return a.$$async;case "name":return a.name;case "displayName":return;case "defaultProps":return;case "toJSON":return;case Symbol.toPrimitive:return Object.prototype[Symbol.toPrimitive];case "Provider":throw Error("Cannot render a Client Context Provider on the Server. Instead, you can export a Client Component wrapper that itself renders a Client Context Provider.");
@@ -77,3 +77,5 @@ exports.decodeFormState=function(a,b,d){var c=b.get("$ACTION_KEY");if("string"!=
 exports.registerClientReference=function(a,b,d){return u(a,b+"#"+d,!1)};exports.registerServerReference=function(a,b,d){return Object.defineProperties(a,{$$typeof:{value:t},$$id:{value:null===d?b:b+"#"+d},$$bound:{value:null},bind:{value:fa}})};
 exports.renderToReadableStream=function(a,b,d){var c=fb(a,b,d?d.onError:void 0,d?d.context:void 0,d?d.identifierPrefix:void 0,d?d.onPostpone:void 0);if(d&&d.signal){var e=d.signal;if(e.aborted)sb(c,e.reason);else{var f=function(){sb(c,e.reason);e.removeEventListener("abort",f)};e.addEventListener("abort",f)}}return new ReadableStream({type:"bytes",start:function(){rb(c)},pull:function(g){if(1===c.status)c.status=2,ca(g,c.fatalError);else if(2!==c.status&&null===c.destination){c.destination=g;try{P(c,
 g)}catch(k){N(c,k),qb(c,k)}}},cancel:function(g){c.destination=null;sb(c,g)}},{highWaterMark:0})};
+
+//# sourceMappingURL=react-server-dom-webpack-server.edge.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.node.production.js b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.node.production.js
new file mode 100644
index 0000000000000..ba3ceda8e2a62
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.node.production.js
@@ -0,0 +1,3346 @@
+/**
+ * @license React
+ * react-server-dom-webpack-server.node.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var util = require('util');
+require('crypto');
+var async_hooks = require('async_hooks');
+var React = require('react');
+var ReactDOM = require('react-dom');
+
+// -----------------------------------------------------------------------------
+const enablePostpone = false;
+
+function scheduleWork(callback) {
+  setImmediate(callback);
+}
+function flushBuffered(destination) {
+  // If we don't have any more data to send right now.
+  // Flush whatever is in the buffer to the wire.
+  if (typeof destination.flush === 'function') {
+    // By convention the Zlib streams provide a flush function for this purpose.
+    // For Express, compression middleware adds this method.
+    destination.flush();
+  }
+}
+const VIEW_SIZE = 2048;
+let currentView = null;
+let writtenBytes = 0;
+let destinationHasCapacity = true;
+function beginWriting(destination) {
+  currentView = new Uint8Array(VIEW_SIZE);
+  writtenBytes = 0;
+  destinationHasCapacity = true;
+}
+
+function writeStringChunk(destination, stringChunk) {
+  if (stringChunk.length === 0) {
+    return;
+  } // maximum possible view needed to encode entire string
+
+
+  if (stringChunk.length * 3 > VIEW_SIZE) {
+    if (writtenBytes > 0) {
+      writeToDestination(destination, currentView.subarray(0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    writeToDestination(destination, textEncoder.encode(stringChunk));
+    return;
+  }
+
+  let target = currentView;
+
+  if (writtenBytes > 0) {
+    target = currentView.subarray(writtenBytes);
+  }
+
+  const _textEncoder$encodeIn = textEncoder.encodeInto(stringChunk, target),
+        read = _textEncoder$encodeIn.read,
+        written = _textEncoder$encodeIn.written;
+
+  writtenBytes += written;
+
+  if (read < stringChunk.length) {
+    writeToDestination(destination, currentView.subarray(0, writtenBytes));
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = textEncoder.encodeInto(stringChunk.slice(read), currentView).written;
+  }
+
+  if (writtenBytes === VIEW_SIZE) {
+    writeToDestination(destination, currentView);
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+}
+
+function writeViewChunk(destination, chunk) {
+  if (chunk.byteLength === 0) {
+    return;
+  }
+
+  if (chunk.byteLength > VIEW_SIZE) {
+    // one that is cached by the streaming renderer. We will enqueu
+    // it directly and expect it is not re-used
+
+
+    if (writtenBytes > 0) {
+      writeToDestination(destination, currentView.subarray(0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    writeToDestination(destination, chunk);
+    return;
+  }
+
+  let bytesToWrite = chunk;
+  const allowableBytes = currentView.length - writtenBytes;
+
+  if (allowableBytes < bytesToWrite.byteLength) {
+    // this chunk would overflow the current view. We enqueue a full view
+    // and start a new view with the remaining chunk
+    if (allowableBytes === 0) {
+      // the current view is already full, send it
+      writeToDestination(destination, currentView);
+    } else {
+      // fill up the current view and apply the remaining chunk bytes
+      // to a new view.
+      currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes);
+      writtenBytes += allowableBytes;
+      writeToDestination(destination, currentView);
+      bytesToWrite = bytesToWrite.subarray(allowableBytes);
+    }
+
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+
+  currentView.set(bytesToWrite, writtenBytes);
+  writtenBytes += bytesToWrite.byteLength;
+
+  if (writtenBytes === VIEW_SIZE) {
+    writeToDestination(destination, currentView);
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+}
+
+function writeChunk(destination, chunk) {
+  if (typeof chunk === 'string') {
+    writeStringChunk(destination, chunk);
+  } else {
+    writeViewChunk(destination, chunk);
+  }
+}
+
+function writeToDestination(destination, view) {
+  const currentHasCapacity = destination.write(view);
+  destinationHasCapacity = destinationHasCapacity && currentHasCapacity;
+}
+
+function writeChunkAndReturn(destination, chunk) {
+  writeChunk(destination, chunk);
+  return destinationHasCapacity;
+}
+function completeWriting(destination) {
+  if (currentView && writtenBytes > 0) {
+    destination.write(currentView.subarray(0, writtenBytes));
+  }
+
+  currentView = null;
+  writtenBytes = 0;
+  destinationHasCapacity = true;
+}
+function close$1(destination) {
+  destination.end();
+}
+const textEncoder = new util.TextEncoder();
+function stringToChunk(content) {
+  return content;
+}
+function byteLengthOfChunk(chunk) {
+  return typeof chunk === 'string' ? Buffer.byteLength(chunk, 'utf8') : chunk.byteLength;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+  destination.destroy(error);
+}
+
+// eslint-disable-next-line no-unused-vars
+const CLIENT_REFERENCE_TAG = Symbol.for('react.client.reference');
+const SERVER_REFERENCE_TAG = Symbol.for('react.server.reference');
+function isClientReference(reference) {
+  return reference.$$typeof === CLIENT_REFERENCE_TAG;
+}
+function isServerReference(reference) {
+  return reference.$$typeof === SERVER_REFERENCE_TAG;
+}
+function registerClientReference(proxyImplementation, id, exportName) {
+  return registerClientReferenceImpl(proxyImplementation, id + '#' + exportName, false);
+}
+
+function registerClientReferenceImpl(proxyImplementation, id, async) {
+  return Object.defineProperties(proxyImplementation, {
+    $$typeof: {
+      value: CLIENT_REFERENCE_TAG
+    },
+    $$id: {
+      value: id
+    },
+    $$async: {
+      value: async
+    }
+  });
+} // $FlowFixMe[method-unbinding]
+
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+
+  if (this.$$typeof === SERVER_REFERENCE_TAG) {
+    const args = ArraySlice.call(arguments, 1);
+    newFn.$$typeof = SERVER_REFERENCE_TAG;
+    newFn.$$id = this.$$id;
+    newFn.$$bound = this.$$bound ? this.$$bound.concat(args) : args;
+  }
+
+  return newFn;
+}
+
+function registerServerReference(reference, id, exportName) {
+  return Object.defineProperties(reference, {
+    $$typeof: {
+      value: SERVER_REFERENCE_TAG
+    },
+    $$id: {
+      value: exportName === null ? id : id + '#' + exportName
+    },
+    $$bound: {
+      value: null
+    },
+    bind: {
+      value: bind
+    }
+  });
+}
+const PROMISE_PROTOTYPE = Promise.prototype;
+const deepProxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        // These names are a little too common. We should probably have a way to
+        // have the Flight runtime extract the inner target instead.
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+
+      case 'displayName':
+        return undefined;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case 'Provider':
+        throw new Error("Cannot render a Client Context Provider on the Server. " + "Instead, you can export a Client Component wrapper " + "that itself renders a Client Context Provider.");
+    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+    const expression = String(target.name) + '.' + String(name);
+    throw new Error("Cannot access " + expression + " on the server. " + 'You cannot dot into a client module from a server component. ' + 'You can only pass the imported name through.');
+  },
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+
+function getReference(target, name) {
+  switch (name) {
+    // These names are read by the Flight runtime if you end up using the exports object.
+    case '$$typeof':
+      return target.$$typeof;
+
+    case '$$id':
+      return target.$$id;
+
+    case '$$async':
+      return target.$$async;
+
+    case 'name':
+      return target.name;
+    // We need to special case this because createElement reads it if we pass this
+    // reference.
+
+    case 'defaultProps':
+      return undefined;
+    // Avoid this attempting to be serialized.
+
+    case 'toJSON':
+      return undefined;
+
+    case Symbol.toPrimitive:
+      // $FlowFixMe[prop-missing]
+      return Object.prototype[Symbol.toPrimitive];
+
+    case '__esModule':
+      // Something is conditionally checking which export to use. We'll pretend to be
+      // an ESM compat module but then we'll check again on the client.
+      const moduleId = target.$$id;
+      target.default = registerClientReferenceImpl(function () {
+        throw new Error("Attempted to call the default export of " + moduleId + " from the server " + "but it's on the client. It's not possible to invoke a client function from " + "the server, it can only be rendered as a Component or passed to props of a " + "Client Component.");
+      }, target.$$id + '#', target.$$async);
+      return true;
+
+    case 'then':
+      if (target.then) {
+        // Use a cached value
+        return target.then;
+      }
+
+      if (!target.$$async) {
+        // If this module is expected to return a Promise (such as an AsyncModule) then
+        // we should resolve that with a client reference that unwraps the Promise on
+        // the client.
+        const clientReference = registerClientReferenceImpl({}, target.$$id, true);
+        const proxy = new Proxy(clientReference, proxyHandlers); // Treat this as a resolved Promise for React's use()
+
+        target.status = 'fulfilled';
+        target.value = proxy;
+        const then = target.then = registerClientReferenceImpl(function then(resolve, reject) {
+          // Expose to React.
+          return Promise.resolve(resolve(proxy));
+        }, // If this is not used as a Promise but is treated as a reference to a `.then`
+        // export then we should treat it as a reference to that name.
+        target.$$id + '#then', false);
+        return then;
+      } else {
+        // Since typeof .then === 'function' is a feature test we'd continue recursing
+        // indefinitely if we return a function. Instead, we return an object reference
+        // if we check further.
+        return undefined;
+      }
+
+  }
+
+  let cachedReference = target[name];
+
+  if (!cachedReference) {
+    const reference = registerClientReferenceImpl(function () {
+      throw new Error( // eslint-disable-next-line react-internal/safe-string-coercion
+      "Attempted to call " + String(name) + "() from the server but " + String(name) + " is on the client. " + "It's not possible to invoke a client function from the server, it can " + "only be rendered as a Component or passed to props of a Client Component.");
+    }, target.$$id + '#' + name, target.$$async);
+    Object.defineProperty(reference, 'name', {
+      value: name
+    });
+    cachedReference = target[name] = new Proxy(reference, deepProxyHandlers);
+  }
+
+  return cachedReference;
+}
+
+const proxyHandlers = {
+  get: function (target, name, receiver) {
+    return getReference(target, name);
+  },
+  getOwnPropertyDescriptor: function (target, name) {
+    let descriptor = Object.getOwnPropertyDescriptor(target, name);
+
+    if (!descriptor) {
+      descriptor = {
+        value: getReference(target, name),
+        writable: false,
+        configurable: false,
+        enumerable: false
+      };
+      Object.defineProperty(target, name, descriptor);
+    }
+
+    return descriptor;
+  },
+
+  getPrototypeOf(target) {
+    // Pretend to be a Promise in case anyone asks.
+    return PROMISE_PROTOTYPE;
+  },
+
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+function createClientModuleProxy(moduleId) {
+  const clientReference = registerClientReferenceImpl({}, // Represents the whole Module object instead of a particular import.
+  moduleId, false);
+  return new Proxy(clientReference, proxyHandlers);
+}
+
+function getClientReferenceKey(reference) {
+  return reference.$$async ? reference.$$id + '#async' : reference.$$id;
+}
+function resolveClientReferenceMetadata(config, clientReference) {
+  const modulePath = clientReference.$$id;
+  let name = '';
+  let resolvedModuleData = config[modulePath];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = modulePath.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = modulePath.slice(idx + 1);
+      resolvedModuleData = config[modulePath.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + modulePath + '" in the React Client Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  }
+
+  if (clientReference.$$async === true) {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1];
+  } else {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+  }
+}
+function getServerReferenceId(config, serverReference) {
+  return serverReference.$$id;
+}
+function getServerReferenceBoundArguments(config, serverReference) {
+  return serverReference.$$bound;
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMFlightServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule: preloadModule$1,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+
+function prefetchDNS(href) {
+  {
+    if (typeof href === 'string' && href) {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'D|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        emitHint(request, 'D', href);
+      }
+    }
+  }
+}
+
+function preconnect(href, crossOrigin) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = "C|" + (crossOrigin == null ? 'null' : crossOrigin) + "|" + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+
+        if (typeof crossOrigin === 'string') {
+          emitHint(request, 'C', [href, crossOrigin]);
+        } else {
+          emitHint(request, 'C', href);
+        }
+      }
+    }
+  }
+}
+
+function preload(href, as, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        let key = 'L';
+
+        if (as === 'image' && options) {
+          key += getImagePreloadKey(href, options.imageSrcSet, options.imageSizes);
+        } else {
+          key += "[" + as + "]" + href;
+        }
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          emitHint(request, 'L', [href, as, trimmed]);
+        } else {
+          emitHint(request, 'L', [href, as]);
+        }
+      }
+    }
+  }
+}
+
+function preloadModule$1(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'm|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'm', [href, trimmed]);
+        } else {
+          return emitHint(request, 'm', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'S|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'S', [href, typeof precedence === 'string' ? precedence : 0, trimmed]);
+        } else if (typeof precedence === 'string') {
+          return emitHint(request, 'S', [href, precedence]);
+        } else {
+          return emitHint(request, 'S', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'X|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'X', [href, trimmed]);
+        } else {
+          return emitHint(request, 'X', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitModuleScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'M|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'M', [href, trimmed]);
+        } else {
+          return emitHint(request, 'M', href);
+        }
+      }
+    }
+  }
+} // Flight normally encodes undefined as a special character however for directive option
+// arguments we don't want to send unnecessary keys and bloat the payload so we create a
+// trimmed object which omits any keys with null or undefined values.
+// This is only typesafe because these option objects have entirely optional fields where
+// null and undefined represent the same thing as no property.
+
+
+function trimOptions(options) {
+  if (options == null) return null;
+  let hasProperties = false;
+  const trimmed = {};
+
+  for (const key in options) {
+    if (options[key] != null) {
+      hasProperties = true;
+      trimmed[key] = options[key];
+    }
+  }
+
+  return hasProperties ? trimmed : null;
+}
+
+function getImagePreloadKey(href, imageSrcSet, imageSizes) {
+  let uniquePart = '';
+
+  if (typeof imageSrcSet === 'string' && imageSrcSet !== '') {
+    uniquePart += '[' + imageSrcSet + ']';
+
+    if (typeof imageSizes === 'string') {
+      uniquePart += '[' + imageSizes + ']';
+    }
+  } else {
+    uniquePart += '[][]' + href;
+  }
+
+  return "[image]" + uniquePart;
+}
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMFlightServerDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+// small, smaller than how we encode undefined, and is unambiguous. We could use
+// a different tuple structure to encode this instead but this makes the runtime
+// cost cheaper by eliminating a type checks in more positions.
+// prettier-ignore
+
+function createHints() {
+  return new Set();
+}
+
+const requestStorage = new async_hooks.AsyncLocalStorage();
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext); // On the way back, we push the new ones that weren't common.
+
+      pushNode(next);
+    }
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFizzWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop, noop);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+let currentRequest$1 = null;
+let thenableIndexCounter = 0;
+let thenableState = null;
+function prepareToUseHooksForRequest(request) {
+  currentRequest$1 = request;
+}
+function resetHooksForRequest() {
+  currentRequest$1 = null;
+}
+function prepareToUseHooksForComponent(prevThenableState) {
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+const HooksDispatcher = {
+  useMemo(nextCreate) {
+    return nextCreate();
+  },
+
+  useCallback(callback) {
+    return callback;
+  },
+
+  useDebugValue() {},
+
+  useDeferredValue: unsupportedHook,
+  useTransition: unsupportedHook,
+  readContext,
+  useContext: readContext,
+  useReducer: unsupportedHook,
+  useRef: unsupportedHook,
+  useState: unsupportedHook,
+  useInsertionEffect: unsupportedHook,
+  useLayoutEffect: unsupportedHook,
+  useImperativeHandle: unsupportedHook,
+  useEffect: unsupportedHook,
+  useId,
+  useSyncExternalStore: unsupportedHook,
+
+  useCacheRefresh() {
+    return unsupportedRefresh;
+  },
+
+  useMemoCache(size) {
+    const data = new Array(size);
+
+    for (let i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL;
+    }
+
+    return data;
+  },
+
+  use
+};
+
+function unsupportedHook() {
+  throw new Error('This Hook is not supported in Server Components.');
+}
+
+function unsupportedRefresh() {
+  throw new Error('Refreshing the cache is not supported in Server Components.');
+}
+
+function useId() {
+  if (currentRequest$1 === null) {
+    throw new Error('useId can only be used while React is rendering');
+  }
+
+  const id = currentRequest$1.identifierCount++; // use 'S' for Flight components to distinguish from 'R' and 'r' in Fizz/Client
+
+  return ':' + currentRequest$1.identifierPrefix + 'S' + id.toString(32) + ':';
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object' || typeof usable === 'function') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable; // Track the position of the thenable within this fiber.
+
+      const index = thenableIndexCounter;
+      thenableIndexCounter += 1;
+
+      if (thenableState === null) {
+        thenableState = createThenableState();
+      }
+
+      return trackUsedThenable(thenableState, thenable, index);
+    } else if (usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  }
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function createSignal() {
+  return new AbortController().signal;
+}
+
+function resolveCache() {
+  const request = resolveRequest();
+
+  if (request) {
+    return getCache(request);
+  }
+
+  return new Map();
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal() {
+    const cache = resolveCache();
+    let entry = cache.get(createSignal);
+
+    if (entry === undefined) {
+      entry = createSignal();
+      cache.set(createSignal, entry);
+    }
+
+    return entry;
+  },
+
+  getCacheForType(resourceType) {
+    const cache = resolveCache();
+    let entry = cache.get(resourceType);
+
+    if (entry === undefined) {
+      entry = resourceType(); // TODO: Warn if undefined?
+
+      cache.set(resourceType, entry);
+    }
+
+    return entry;
+  }
+
+};
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+function objectName(object) {
+  // $FlowFixMe[method-unbinding]
+  const name = Object.prototype.toString.call(object);
+  return name.replace(/^\[object (.*)\]$/, function (m, p0) {
+    return p0;
+  });
+}
+
+function describeKeyForErrorMessage(key) {
+  const encodedKey = JSON.stringify(key);
+  return '"' + key + '"' === encodedKey ? key : encodedKey;
+}
+
+function describeValueForErrorMessage(value) {
+  switch (typeof value) {
+    case 'string':
+      {
+        return JSON.stringify(value.length <= 10 ? value : value.slice(0, 10) + '...');
+      }
+
+    case 'object':
+      {
+        if (isArray(value)) {
+          return '[...]';
+        }
+
+        const name = objectName(value);
+
+        if (name === 'Object') {
+          return '{...}';
+        }
+
+        return name;
+      }
+
+    case 'function':
+      return 'function';
+
+    default:
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      return String(value);
+  }
+}
+
+function describeElementType(type) {
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        return describeElementType(type.render);
+
+      case REACT_MEMO_TYPE:
+        return describeElementType(type.type);
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            // Lazy may contain any component type so we recursively resolve it.
+            return describeElementType(init(payload));
+          } catch (x) {}
+        }
+    }
+  }
+
+  return '';
+}
+
+function describeObjectForErrorMessage(objectOrArray, expandedName) {
+  const objKind = objectName(objectOrArray);
+
+  if (objKind !== 'Object' && objKind !== 'Array') {
+    return objKind;
+  }
+
+  let str = '';
+  let start = -1;
+  let length = 0;
+
+  if (isArray(objectOrArray)) {
+    {
+      // Print Array
+      str = '[';
+      const array = objectOrArray;
+
+      for (let i = 0; i < array.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const value = array[i];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if ('' + i === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += ']';
+    }
+  } else {
+    if (objectOrArray.$$typeof === REACT_ELEMENT_TYPE) {
+      str = '<' + describeElementType(objectOrArray.type) + '/>';
+    } else {
+      // Print Object
+      str = '{';
+      const object = objectOrArray;
+      const names = Object.keys(object);
+
+      for (let i = 0; i < names.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const name = names[i];
+        str += describeKeyForErrorMessage(name) + ': ';
+        const value = object[name];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if (name === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += '}';
+    }
+  }
+
+  if (expandedName === undefined) {
+    return str;
+  }
+
+  if (start > -1 && length > 0) {
+    const highlight = ' '.repeat(start) + '^'.repeat(length);
+    return '\n  ' + str + '\n  ' + highlight;
+  }
+
+  return '\n  ' + str;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactSharedServerInternals = // $FlowFixMe: It's defined in the one we resolve to.
+React.__SECRET_SERVER_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+if (!ReactSharedServerInternals) {
+  throw new Error('The "react" package in this environment is not configured correctly. ' + 'The "react-server" condition must be enabled in any environment that ' + 'runs React Server Components.');
+}
+
+const ObjectPrototype = Object.prototype;
+const stringify = JSON.stringify; // Serializable values
+// Thenable<ReactClientValue>
+
+const PENDING$1 = 0;
+const COMPLETED = 1;
+const ABORTED = 3;
+const ERRORED$1 = 4;
+const ReactCurrentCache = ReactSharedServerInternals.ReactCurrentCache;
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+}
+
+function defaultPostponeHandler(reason) {// Noop
+}
+
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2;
+function createRequest(model, bundlerConfig, onError, context, identifierPrefix, onPostpone) {
+  if (ReactCurrentCache.current !== null && ReactCurrentCache.current !== DefaultCacheDispatcher) {
+    throw new Error('Currently React only supports one RSC renderer at a time.');
+  }
+
+  prepareHostDispatcher();
+  ReactCurrentCache.current = DefaultCacheDispatcher;
+  const abortSet = new Set();
+  const pingedTasks = [];
+  const cleanupQueue = [];
+
+  const hints = createHints();
+  const request = {
+    status: OPEN,
+    flushScheduled: false,
+    fatalError: null,
+    destination: null,
+    bundlerConfig,
+    cache: new Map(),
+    nextChunkId: 0,
+    pendingChunks: 0,
+    hints,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    completedImportChunks: [],
+    completedHintChunks: [],
+    completedRegularChunks: [],
+    completedErrorChunks: [],
+    writtenSymbols: new Map(),
+    writtenClientReferences: new Map(),
+    writtenServerReferences: new Map(),
+    writtenProviders: new Map(),
+    writtenObjects: new WeakMap(),
+    identifierPrefix: identifierPrefix || '',
+    identifierCount: 1,
+    taintCleanupQueue: cleanupQueue,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? defaultPostponeHandler : onPostpone,
+    // $FlowFixMe[missing-this-annot]
+    toJSON: function (key, value) {
+      return resolveModelToJSON(request, this, key, value);
+    }
+  };
+  request.pendingChunks++;
+  const rootContext = createRootContext();
+  const rootTask = createTask(request, model, rootContext, abortSet);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  {
+    const store = requestStorage.getStore();
+    if (store) return store;
+  }
+
+  return null;
+}
+
+function createRootContext(reqContext) {
+  return importServerContexts();
+}
+
+function serializeThenable(request, thenable) {
+  request.pendingChunks++;
+  const newTask = createTask(request, null, getActiveContext(), request.abortableTasks);
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        // We have the resolved value, we can go ahead and schedule it for serialization.
+        newTask.model = thenable.value;
+        pingTask(request, newTask);
+        return newTask.id;
+      }
+
+    case 'rejected':
+      {
+        const x = thenable.reason;
+
+        {
+          const digest = logRecoverableError(request, x);
+          emitErrorChunk(request, newTask.id, digest);
+        }
+
+        return newTask.id;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  thenable.then(value => {
+    newTask.model = value;
+    pingTask(request, newTask);
+  }, reason => {
+    newTask.status = ERRORED$1;
+    request.abortableTasks.delete(newTask); // TODO: We should ideally do this inside performWork so it's scheduled
+
+    const digest = logRecoverableError(request, reason);
+    emitErrorChunk(request, newTask.id, digest);
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  });
+  return newTask.id;
+}
+
+function emitHint(request, code, model) {
+  emitHintChunk(request, code, model);
+  enqueueFlush(request);
+}
+function getHints(request) {
+  return request.hints;
+}
+function getCache(request) {
+  return request.cache;
+}
+
+function readThenable(thenable) {
+  if (thenable.status === 'fulfilled') {
+    return thenable.value;
+  } else if (thenable.status === 'rejected') {
+    throw thenable.reason;
+  }
+
+  throw thenable;
+}
+
+function createLazyWrapperAroundWakeable(wakeable) {
+  // This is a temporary fork of the `use` implementation until we accept
+  // promises everywhere.
+  const thenable = wakeable;
+
+  switch (thenable.status) {
+    case 'fulfilled':
+    case 'rejected':
+      break;
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: thenable,
+    _init: readThenable
+  };
+  return lazyType;
+}
+
+function attemptResolveElement(request, type, key, ref, props, prevThenableState) {
+  if (ref !== null && ref !== undefined) {
+    // When the ref moves to the regular props object this will implicitly
+    // throw for functions. We could probably relax it to a DEV warning for other
+    // cases.
+    throw new Error('Refs cannot be used in Server Components, nor passed to Client Components.');
+  }
+
+  if (typeof type === 'function') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    } // This is a server-side component.
+
+
+    prepareToUseHooksForComponent(prevThenableState);
+    const result = type(props);
+
+    if (typeof result === 'object' && result !== null && typeof result.then === 'function') {
+      // When the return value is in children position we can resolve it immediately,
+      // to its value without a wrapper if it's synchronously available.
+      const thenable = result;
+
+      if (thenable.status === 'fulfilled') {
+        return thenable.value;
+      } // TODO: Once we accept Promises as children on the client, we can just return
+      // the thenable here.
+
+
+      return createLazyWrapperAroundWakeable(result);
+    }
+
+    return result;
+  } else if (typeof type === 'string') {
+    // This is a host element. E.g. HTML.
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (typeof type === 'symbol') {
+    if (type === REACT_FRAGMENT_TYPE) {
+      // For key-less fragments, we add a small optimization to avoid serializing
+      // it as a wrapper.
+      // TODO: If a key is specified, we should propagate its key to any children.
+      // Same as if a Server Component has a key.
+      return props.children;
+    } // This might be a built-in React component. We'll let the client decide.
+    // Any built-in works as long as its props are serializable.
+
+
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (type != null && typeof type === 'object') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    }
+
+    switch (type.$$typeof) {
+      case REACT_LAZY_TYPE:
+        {
+          const payload = type._payload;
+          const init = type._init;
+          const wrappedType = init(payload);
+          return attemptResolveElement(request, wrappedType, key, ref, props, prevThenableState);
+        }
+
+      case REACT_FORWARD_REF_TYPE:
+        {
+          const render = type.render;
+          prepareToUseHooksForComponent(prevThenableState);
+          return render(props, undefined);
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          return attemptResolveElement(request, type.type, key, ref, props, prevThenableState);
+        }
+    }
+  }
+
+  throw new Error("Unsupported Server Component type: " + describeValueForErrorMessage(type));
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createTask(request, model, context, abortSet) {
+  const id = request.nextChunkId++;
+  const task = {
+    id,
+    status: PENDING$1,
+    model,
+    context,
+    ping: () => pingTask(request, task),
+    thenableState: null
+  };
+  abortSet.add(task);
+  return task;
+}
+
+function serializeByValueID(id) {
+  return '$' + id.toString(16);
+}
+
+function serializeLazyID(id) {
+  return '$L' + id.toString(16);
+}
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeRowHeader(tag, id) {
+  return id.toString(16) + ':' + tag;
+}
+
+function encodeReferenceChunk(request, id, reference) {
+  const json = stringify(reference);
+  const row = id.toString(16) + ':' + json + '\n';
+  return stringToChunk(row);
+}
+
+function serializeClientReference(request, parent, key, clientReference) {
+  const clientReferenceKey = getClientReferenceKey(clientReference);
+  const writtenClientReferences = request.writtenClientReferences;
+  const existingId = writtenClientReferences.get(clientReferenceKey);
+
+  if (existingId !== undefined) {
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(existingId);
+    }
+
+    return serializeByValueID(existingId);
+  }
+
+  try {
+    const clientReferenceMetadata = resolveClientReferenceMetadata(request.bundlerConfig, clientReference);
+    request.pendingChunks++;
+    const importId = request.nextChunkId++;
+    emitImportChunk(request, importId, clientReferenceMetadata);
+    writtenClientReferences.set(clientReferenceKey, importId);
+
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(importId);
+    }
+
+    return serializeByValueID(importId);
+  } catch (x) {
+    request.pendingChunks++;
+    const errorId = request.nextChunkId++;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, errorId, digest);
+    return serializeByValueID(errorId);
+  }
+}
+
+function outlineModel(request, value) {
+  request.pendingChunks++;
+  const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+  retryTask(request, newTask);
+  return newTask.id;
+}
+
+function serializeServerReference(request, parent, key, serverReference) {
+  const writtenServerReferences = request.writtenServerReferences;
+  const existingId = writtenServerReferences.get(serverReference);
+
+  if (existingId !== undefined) {
+    return serializeServerReferenceID(existingId);
+  }
+
+  const bound = getServerReferenceBoundArguments(request.bundlerConfig, serverReference);
+  const serverReferenceMetadata = {
+    id: getServerReferenceId(request.bundlerConfig, serverReference),
+    bound: bound ? Promise.resolve(bound) : null
+  };
+  const metadataId = outlineModel(request, serverReferenceMetadata);
+  writtenServerReferences.set(serverReference, metadataId);
+  return serializeServerReferenceID(metadataId);
+}
+
+function serializeLargeTextString(request, text) {
+  request.pendingChunks += 2;
+  const textId = request.nextChunkId++;
+  const textChunk = stringToChunk(text);
+  const binaryLength = byteLengthOfChunk(textChunk);
+  const row = textId.toString(16) + ':T' + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, textChunk);
+  return serializeByValueID(textId);
+}
+
+function serializeMap(request, map) {
+  const entries = Array.from(map);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i][0];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$Q' + id.toString(16);
+}
+
+function serializeSet(request, set) {
+  const entries = Array.from(set);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+let modelRoot = false;
+
+function resolveModelToJSON(request, parent, key, value) {
+
+
+  switch (value) {
+    case REACT_ELEMENT_TYPE:
+      return '$';
+  }
+
+
+  while (typeof value === 'object' && value !== null && (value.$$typeof === REACT_ELEMENT_TYPE || value.$$typeof === REACT_LAZY_TYPE)) {
+
+    try {
+      switch (value.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const writtenObjects = request.writtenObjects;
+            const existingId = writtenObjects.get(value);
+
+            if (existingId !== undefined) {
+              if (existingId === -1) {
+                // Seen but not yet outlined.
+                const newId = outlineModel(request, value);
+                return serializeByValueID(newId);
+              } else if (modelRoot === value) {
+                // This is the ID we're currently emitting so we need to write it
+                // once but if we discover it again, we refer to it by id.
+                modelRoot = null;
+              } else {
+                // We've already emitted this as an outlined object, so we can
+                // just refer to that by its existing ID.
+                return serializeByValueID(existingId);
+              }
+            } else {
+              // This is the first time we've seen this object. We may never see it again
+              // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+              writtenObjects.set(value, -1);
+            } // TODO: Concatenate keys of parents onto children.
+
+
+            const element = value; // Attempt to render the Server Component.
+
+            value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, null);
+            break;
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = value._payload;
+            const init = value._init;
+            value = init(payload);
+            break;
+          }
+      }
+    } catch (thrownValue) {
+      const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          // Something suspended, we'll need to create a new task and resolve it later.
+          request.pendingChunks++;
+          const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+          const ping = newTask.ping;
+          x.then(ping, ping);
+          newTask.thenableState = getThenableStateAfterSuspending();
+          return serializeLazyID(newTask.id);
+        }
+      } // Something errored. We'll still send everything we have up until this point.
+      // We'll replace this element with a lazy reference that throws on the client
+      // once it gets rendered.
+
+
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+      const digest = logRecoverableError(request, x);
+      emitErrorChunk(request, errorId, digest);
+      return serializeLazyID(errorId);
+    }
+  }
+
+  if (value === null) {
+    return null;
+  }
+
+  if (typeof value === 'object') {
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    const writtenObjects = request.writtenObjects;
+    const existingId = writtenObjects.get(value); // $FlowFixMe[method-unbinding]
+
+    if (typeof value.then === 'function') {
+      if (existingId !== undefined) {
+        if (modelRoot === value) {
+          // This is the ID we're currently emitting so we need to write it
+          // once but if we discover it again, we refer to it by id.
+          modelRoot = null;
+        } else {
+          // We've seen this promise before, so we can just refer to the same result.
+          return serializePromiseID(existingId);
+        }
+      } // We assume that any object with a .then property is a "Thenable" type,
+      // or a Promise type. Either of which can be represented by a Promise.
+
+
+      const promiseId = serializeThenable(request, value);
+      writtenObjects.set(value, promiseId);
+      return serializePromiseID(promiseId);
+    }
+
+    if (existingId !== undefined) {
+      if (existingId === -1) {
+        // Seen but not yet outlined.
+        const newId = outlineModel(request, value);
+        return serializeByValueID(newId);
+      } else if (modelRoot === value) {
+        // This is the ID we're currently emitting so we need to write it
+        // once but if we discover it again, we refer to it by id.
+        modelRoot = null;
+      } else {
+        // We've already emitted this as an outlined object, so we can
+        // just refer to that by its existing ID.
+        return serializeByValueID(existingId);
+      }
+    } else {
+      // This is the first time we've seen this object. We may never see it again
+      // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+      writtenObjects.set(value, -1);
+    }
+
+    if (isArray(value)) {
+      // $FlowFixMe[incompatible-return]
+      return value;
+    }
+
+    if (value instanceof Map) {
+      return serializeMap(request, value);
+    }
+
+    if (value instanceof Set) {
+      return serializeSet(request, value);
+    }
+
+    const iteratorFn = getIteratorFn(value);
+
+    if (iteratorFn) {
+      return Array.from(value);
+    } // Verify that this is a simple plain object.
+
+
+    const proto = getPrototypeOf(value);
+
+    if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+      throw new Error('Only plain objects, and a few built-ins, can be passed to Client Components ' + 'from Server Components. Classes or null prototypes are not supported.');
+    }
+
+
+    return value;
+  }
+
+  if (typeof value === 'string') {
+
+
+    if (value[value.length - 1] === 'Z') {
+      // Possibly a Date, whose toJSON automatically calls toISOString
+      // $FlowFixMe[incompatible-use]
+      const originalValue = parent[key];
+
+      if (originalValue instanceof Date) {
+        return serializeDateFromDateJSON(value);
+      }
+    }
+
+    if (value.length >= 1024) {
+      // For large strings, we encode them outside the JSON payload so that we
+      // don't have to double encode and double parse the strings. This can also
+      // be more compact in case the string has a lot of escaped characters.
+      return serializeLargeTextString(request, value);
+    }
+
+    return escapeStringValue(value);
+  }
+
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  if (typeof value === 'number') {
+    return serializeNumber(value);
+  }
+
+  if (typeof value === 'undefined') {
+    return serializeUndefined();
+  }
+
+  if (typeof value === 'function') {
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    if (isServerReference(value)) {
+      return serializeServerReference(request, parent, key, value);
+    }
+
+    if (/^on[A-Z]/.test(key)) {
+      throw new Error('Event handlers cannot be passed to Client Component props.' + describeObjectForErrorMessage(parent, key) + '\nIf you need interactivity, consider converting part of this to a Client Component.');
+    } else {
+      throw new Error('Functions cannot be passed directly to Client Components ' + 'unless you explicitly expose it by marking it with "use server".' + describeObjectForErrorMessage(parent, key));
+    }
+  }
+
+  if (typeof value === 'symbol') {
+    const writtenSymbols = request.writtenSymbols;
+    const existingId = writtenSymbols.get(value);
+
+    if (existingId !== undefined) {
+      return serializeByValueID(existingId);
+    } // $FlowFixMe[incompatible-type] `description` might be undefined
+
+
+    const name = value.description;
+
+    if (Symbol.for(name) !== value) {
+      throw new Error('Only global symbols received from Symbol.for(...) can be passed to Client Components. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+      value.description + ") cannot be found among global symbols.") + describeObjectForErrorMessage(parent, key));
+    }
+
+    request.pendingChunks++;
+    const symbolId = request.nextChunkId++;
+    emitSymbolChunk(request, symbolId, name);
+    writtenSymbols.set(value, symbolId);
+    return serializeByValueID(symbolId);
+  }
+
+  if (typeof value === 'bigint') {
+
+    return serializeBigInt(value);
+  }
+
+  throw new Error("Type " + typeof value + " is not supported in Client Component props." + describeObjectForErrorMessage(parent, key));
+}
+
+function logPostpone(request, reason) {
+  const onPostpone = request.onPostpone;
+  onPostpone(reason);
+}
+
+function logRecoverableError(request, error) {
+  const onError = request.onError;
+  const errorDigest = onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest || '';
+}
+
+function fatalError(request, error) {
+
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function emitPostponeChunk(request, id, postponeInstance) {
+  let row;
+
+  {
+    // No reason included in prod.
+    row = serializeRowHeader('P', id) + '\n';
+  }
+
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitErrorChunk(request, id, digest, error) {
+  let errorInfo;
+
+  {
+    errorInfo = {
+      digest
+    };
+  }
+
+  const row = serializeRowHeader('E', id) + stringify(errorInfo) + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitImportChunk(request, id, clientReferenceMetadata) {
+  // $FlowFixMe[incompatible-type] stringify can return null
+  const json = stringify(clientReferenceMetadata);
+  const row = serializeRowHeader('I', id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitHintChunk(request, code, model) {
+  const json = stringify(model);
+  const id = request.nextChunkId++;
+  const row = serializeRowHeader('H' + code, id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedHintChunks.push(processedChunk);
+}
+
+function emitSymbolChunk(request, id, name) {
+  const symbolReference = serializeSymbolReference(name);
+  const processedChunk = encodeReferenceChunk(request, id, symbolReference);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitModelChunk(request, id, model) {
+  // Track the root so we know that we have to emit this object even though it
+  // already has an ID. This is needed because we might see this object twice
+  // in the same toJSON if it is cyclic.
+  modelRoot = model; // $FlowFixMe[incompatible-type] stringify can return null
+
+  const json = stringify(model, request.toJSON);
+  const row = id.toString(16) + ':' + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function retryTask(request, task) {
+  if (task.status !== PENDING$1) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  }
+
+  switchContext(task.context);
+
+  try {
+    let value = task.model;
+
+    if (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+      request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+      const element = value; // When retrying a component, reuse the thenableState from the
+      // previous attempt.
+
+      const prevThenableState = task.thenableState; // Attempt to render the Server Component.
+      // Doing this here lets us reuse this same task if the next component
+      // also suspends.
+
+      task.model = value;
+      value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, prevThenableState); // Successfully finished this component. We're going to keep rendering
+      // using the same task, but we reset its thenable state before continuing.
+
+      task.thenableState = null; // Keep rendering and reuse the same task. This inner loop is separate
+      // from the render above because we don't need to reset the thenable state
+      // until the next time something suspends and retries.
+
+      while (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+        request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+        const nextElement = value;
+        task.model = value;
+        value = attemptResolveElement(request, nextElement.type, nextElement.key, nextElement.ref, nextElement.props, null);
+      }
+    } // Track that this object is outlined and has an id.
+
+
+    if (typeof value === 'object' && value !== null) {
+      request.writtenObjects.set(value, task.id);
+    }
+
+    emitModelChunk(request, task.id, value);
+    request.abortableTasks.delete(task);
+    task.status = COMPLETED;
+  } catch (thrownValue) {
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    request.abortableTasks.delete(task);
+    task.status = ERRORED$1;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, task.id, digest);
+  }
+}
+
+function performWork(request) {
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  const prevRequest = currentRequest;
+  currentRequest = request;
+  prepareToUseHooksForRequest(request);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    request.pingedTasks = [];
+
+    for (let i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    ReactCurrentDispatcher.current = prevDispatcher;
+    resetHooksForRequest();
+    currentRequest = prevRequest;
+  }
+}
+
+function abortTask(task, request, errorId) {
+  task.status = ABORTED; // Instead of emitting an error per task.id, we emit a model that only
+  // has a single value referencing the error.
+
+  const ref = serializeByValueID(errorId);
+  const processedChunk = encodeReferenceChunk(request, task.id, ref);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function flushCompletedChunks(request, destination) {
+  beginWriting();
+
+  try {
+    // We emit module chunks first in the stream so that
+    // they can be preloaded as early as possible.
+    const importsChunks = request.completedImportChunks;
+    let i = 0;
+
+    for (; i < importsChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = importsChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    importsChunks.splice(0, i); // Next comes hints.
+
+    const hintChunks = request.completedHintChunks;
+    i = 0;
+
+    for (; i < hintChunks.length; i++) {
+      const chunk = hintChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    hintChunks.splice(0, i); // Next comes model data.
+
+    const regularChunks = request.completedRegularChunks;
+    i = 0;
+
+    for (; i < regularChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = regularChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    regularChunks.splice(0, i); // Finally, errors are sent. The idea is that it's ok to delay
+    // any error messages and prioritize display of other parts of
+    // the page.
+
+    const errorChunks = request.completedErrorChunks;
+    i = 0;
+
+    for (; i < errorChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = errorChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    errorChunks.splice(0, i);
+  } finally {
+    request.flushScheduled = false;
+    completeWriting(destination);
+  }
+
+  flushBuffered(destination);
+
+  if (request.pendingChunks === 0) {
+
+    close$1(destination);
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  {
+    scheduleWork(() => requestStorage.run(request, performWork, request));
+  }
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    const destination = request.destination;
+    request.flushScheduled = true;
+    scheduleWork(() => flushCompletedChunks(request, destination));
+  }
+}
+
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedChunks(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function stopFlowing(request) {
+  request.destination = null;
+} // This is called to early terminate a request. It creates an error at all pending tasks.
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      // We have tasks to abort. We'll emit one error row and then emit a reference
+      // to that row from every row that's still remaining.
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+
+      if (enablePostpone && typeof reason === 'object' && reason !== null && reason.$$typeof === REACT_POSTPONE_TYPE) ; else {
+        const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+        const digest = logRecoverableError(request, error);
+        emitErrorChunk(request, errorId, digest, error);
+      }
+
+      abortableTasks.forEach(task => abortTask(task, request, errorId));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function importServerContexts(contexts) {
+
+  return rootContextSnapshot;
+}
+
+// This is the parsed shape of the wire format which is why it is
+// condensed to only the essentialy information
+const ID = 0;
+const CHUNKS = 1;
+const NAME = 2; // export const ASYNC = 3;
+// This logic is correct because currently only include the 4th tuple member
+// when the module is async. If that changes we will need to actually assert
+// the value is true. We don't index into the 4th slot because flow does not
+// like the potential out of bounds access
+
+function isAsyncImport(metadata) {
+  return metadata.length === 4;
+}
+
+function resolveServerReference(bundlerConfig, id) {
+  let name = '';
+  let resolvedModuleData = bundlerConfig[id];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = id.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = id.slice(idx + 1);
+      resolvedModuleData = bundlerConfig[id.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + id + '" in the React Server Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  } // TODO: This needs to return async: true if it's an async module.
+
+
+  return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+} // The chunk cache contains all the chunks we've preloaded so far.
+// If they're still pending they're a thenable. This map also exists
+// in Webpack but unfortunately it's not exposed so we have to
+// replicate it in user space. null means that it has already loaded.
+
+const chunkCache = new Map();
+
+function requireAsyncModule(id) {
+  // We've already loaded all the chunks. We can require the module.
+  const promise = globalThis.__next_require__(id);
+
+  if (typeof promise.then !== 'function') {
+    // This wasn't a promise after all.
+    return null;
+  } else if (promise.status === 'fulfilled') {
+    // This module was already resolved earlier.
+    return null;
+  } else {
+    // Instrument the Promise to stash the result.
+    promise.then(value => {
+      const fulfilledThenable = promise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = promise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    return promise;
+  }
+}
+
+function ignoreReject() {// We rely on rejected promises to be handled by another listener.
+} // Start preloading the modules since we might need them soon.
+// This function doesn't suspend.
+
+
+function preloadModule(metadata) {
+  const chunks = metadata[CHUNKS];
+  const promises = [];
+  let i = 0;
+
+  while (i < chunks.length) {
+    const chunkId = chunks[i++];
+    chunks[i++];
+    const entry = chunkCache.get(chunkId);
+
+    if (entry === undefined) {
+      const thenable = loadChunk(chunkId);
+      promises.push(thenable); // $FlowFixMe[method-unbinding]
+
+      const resolve = chunkCache.set.bind(chunkCache, chunkId, null);
+      thenable.then(resolve, ignoreReject);
+      chunkCache.set(chunkId, thenable);
+    } else if (entry !== null) {
+      promises.push(entry);
+    }
+  }
+
+  if (isAsyncImport(metadata)) {
+    if (promises.length === 0) {
+      return requireAsyncModule(metadata[ID]);
+    } else {
+      return Promise.all(promises).then(() => {
+        return requireAsyncModule(metadata[ID]);
+      });
+    }
+  } else if (promises.length > 0) {
+    return Promise.all(promises);
+  } else {
+    return null;
+  }
+} // Actually require the module or suspend if it's not yet ready.
+// Increase priority if necessary.
+
+function requireModule(metadata) {
+  let moduleExports = globalThis.__next_require__(metadata[ID]);
+
+  if (isAsyncImport(metadata)) {
+    if (typeof moduleExports.then !== 'function') ; else if (moduleExports.status === 'fulfilled') {
+      // This Promise should've been instrumented by preloadModule.
+      moduleExports = moduleExports.value;
+    } else {
+      throw moduleExports.reason;
+    }
+  }
+
+  if (metadata[NAME] === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata[NAME] === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.__esModule ? moduleExports.default : moduleExports;
+  }
+
+  return moduleExports[metadata[NAME]];
+}
+
+function loadChunk(chunkId, filename) {
+  return __webpack_chunk_load__(chunkId);
+}
+
+// The server acts as a Client of itself when resolving Server References.
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const RESOLVED_MODEL = 'resolved_model';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function bindArgs$1(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference$1(response, id, bound, parentChunk, parentObject, key) {
+  const serverReference = resolveServerReference(response._bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+  let promise;
+
+  if (bound) {
+    promise = Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs$1(requireModule(serverReference), args);
+    });
+  } else {
+    if (preloadPromise) {
+      promise = Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+    } else {
+      // Synchronously available
+      return requireModule(serverReference);
+    }
+  }
+
+  promise.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk)); // We need a placeholder value that will be replaced later.
+
+  return null;
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+
+  try {
+    const value = JSON.parse(chunk.value, chunk._response._fromJSON);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    const prefix = response._prefix;
+    const key = prefix + id; // Check if we have this field in the backing store already.
+
+    const backingEntry = response._formData.get(key);
+
+    if (backingEntry != null) {
+      // We assume that this is a string entry for now.
+      chunk = createResolvedModelChunk(response, backingEntry);
+    } else {
+      // We're still waiting on this entry to stream in.
+      chunk = createPendingChunk(response);
+    }
+
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+    blocked.deps++;
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  if (chunk.status === RESOLVED_MODEL) {
+    initializeModelChunk(chunk);
+  }
+
+  if (chunk.status !== INITIALIZED) {
+    // We know that this is emitted earlier so otherwise it's an error.
+    throw chunk.reason;
+  }
+
+  return chunk.value;
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16); // TODO: Just encode this in the reference inline instead of as a model.
+
+          const metaData = getOutlinedModel(response, id);
+          return loadServerReference$1(response, metaData.id, metaData.bound, initializingChunk, parentObject, key);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'K':
+        {
+          // FormData
+          const stringId = value.slice(2);
+          const formPrefix = response._prefix + stringId + '_';
+          const data = new FormData();
+          const backingFormData = response._formData; // We assume that the reference to FormData always comes after each
+          // entry that it references so we can assume they all exist in the
+          // backing store already.
+          // $FlowFixMe[prop-missing] FormData has forEach on it.
+
+          backingFormData.forEach((entry, entryKey) => {
+            if (entryKey.startsWith(formPrefix)) {
+              data.append(entryKey.slice(formPrefix.length), entry);
+            }
+          });
+          return data;
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function createResponse(bundlerConfig, formFieldPrefix) {
+  let backingFormData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new FormData();
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _prefix: formFieldPrefix,
+    _formData: backingFormData,
+    _chunks: chunks,
+    _fromJSON: function (key, value) {
+      if (typeof value === 'string') {
+        // We can't use .bind here because we need the "this" value.
+        return parseModelString(response, this, key, value);
+      }
+
+      return value;
+    }
+  };
+  return response;
+}
+function resolveField(response, key, value) {
+  // Add this field to the backing store.
+  response._formData.append(key, value);
+
+  const prefix = response._prefix;
+
+  if (key.startsWith(prefix)) {
+    const chunks = response._chunks;
+    const id = +key.slice(prefix.length);
+    const chunk = chunks.get(id);
+
+    if (chunk) {
+      // We were waiting on this key so now we can resolve it.
+      resolveModelChunk(chunk, value);
+    }
+  }
+}
+function resolveFileInfo(response, key, filename, mime) {
+  return {
+    chunks: [],
+    filename,
+    mime
+  };
+}
+function resolveFileChunk(response, handle, chunk) {
+  handle.chunks.push(chunk);
+}
+function resolveFileComplete(response, key, handle) {
+  // Add this file to the backing store.
+  // Node.js doesn't expose a global File constructor so we need to use
+  // the append() form that takes the file name as the third argument,
+  // to create a File object.
+  const blob = new Blob(handle.chunks, {
+    type: handle.mime
+  });
+
+  response._formData.append(key, blob, handle.filename);
+}
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function bindArgs(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference(bundlerConfig, id, bound) {
+  const serverReference = resolveServerReference(bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+
+  if (bound) {
+    return Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs(requireModule(serverReference), args);
+    });
+  } else if (preloadPromise) {
+    return Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+  } else {
+    // Synchronously available
+    return Promise.resolve(requireModule(serverReference));
+  }
+}
+
+function decodeBoundActionMetaData(body, serverManifest, formFieldPrefix) {
+  // The data for this reference is encoded in multiple fields under this prefix.
+  const actionResponse = createResponse(serverManifest, formFieldPrefix, body);
+  close(actionResponse);
+  const refPromise = getRoot(actionResponse); // Force it to initialize
+  // $FlowFixMe
+
+  refPromise.then(() => {});
+
+  if (refPromise.status !== 'fulfilled') {
+    // $FlowFixMe
+    throw refPromise.reason;
+  }
+
+  return refPromise.value;
+}
+
+function decodeAction(body, serverManifest) {
+  // We're going to create a new formData object that holds all the fields except
+  // the implementation details of the action data.
+  const formData = new FormData();
+  let action = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (!key.startsWith('$ACTION_')) {
+      formData.append(key, value);
+      return;
+    } // Later actions may override earlier actions if a button is used to override the default
+    // form action.
+
+
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      const metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+      action = loadServerReference(serverManifest, metaData.id, metaData.bound);
+      return;
+    }
+
+    if (key.startsWith('$ACTION_ID_')) {
+      const id = key.slice(11);
+      action = loadServerReference(serverManifest, id, null);
+      return;
+    }
+  });
+
+  if (action === null) {
+    return null;
+  } // Return the action with the remaining FormData bound to the first argument.
+
+
+  return action.then(fn => fn.bind(null, formData));
+}
+function decodeFormState(actionResult, body, serverManifest) {
+  const keyPath = body.get('$ACTION_KEY');
+
+  if (typeof keyPath !== 'string') {
+    // This form submission did not include any form state.
+    return Promise.resolve(null);
+  } // Search through the form data object to get the reference id and the number
+  // of bound arguments. This repeats some of the work done in decodeAction.
+
+
+  let metaData = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+    } // We don't check for the simple $ACTION_ID_ case because form state actions
+    // are always bound to the state argument.
+
+  });
+
+  if (metaData === null) {
+    // Should be unreachable.
+    return Promise.resolve(null);
+  }
+
+  const referenceId = metaData.id;
+  return Promise.resolve(metaData.bound).then(bound => {
+    if (bound === null) {
+      // Should be unreachable because form state actions are always bound to the
+      // state argument.
+      return null;
+    } // The form action dispatch method is always bound to the initial state.
+    // But when comparing signatures, we compare to the original unbound action.
+    // Subtract one from the arity to account for this.
+
+
+    const boundArity = bound.length - 1;
+    return [actionResult, keyPath, referenceId, boundArity];
+  });
+}
+
+function createDrainHandler(destination, request) {
+  return () => startFlowing(request, destination);
+}
+
+function createCancelHandler(request, reason) {
+  return () => {
+    stopFlowing(request); // eslint-disable-next-line react-internal/prod-error-codes
+
+    abort(request, new Error(reason));
+  };
+}
+
+function renderToPipeableStream(model, webpackMap, options) {
+  const request = createRequest(model, webpackMap, options ? options.onError : undefined, options ? options.context : undefined, options ? options.identifierPrefix : undefined, options ? options.onPostpone : undefined);
+  let hasStartedFlowing = false;
+  startWork(request);
+  return {
+    pipe(destination) {
+      if (hasStartedFlowing) {
+        throw new Error('React currently only supports piping to one writable stream.');
+      }
+
+      hasStartedFlowing = true;
+      startFlowing(request, destination);
+      destination.on('drain', createDrainHandler(destination, request));
+      destination.on('error', createCancelHandler(request, 'The destination stream errored while writing data.'));
+      destination.on('close', createCancelHandler(request, 'The destination stream closed early.'));
+      return destination;
+    },
+
+    abort(reason) {
+      abort(request, reason);
+    }
+
+  };
+}
+
+function decodeReplyFromBusboy(busboyStream, webpackMap) {
+  const response = createResponse(webpackMap, '');
+  let pendingFiles = 0;
+  const queuedFields = [];
+  busboyStream.on('field', (name, value) => {
+    if (pendingFiles > 0) {
+      // Because the 'end' event fires two microtasks after the next 'field'
+      // we would resolve files and fields out of order. To handle this properly
+      // we queue any fields we receive until the previous file is done.
+      queuedFields.push(name, value);
+    } else {
+      resolveField(response, name, value);
+    }
+  });
+  busboyStream.on('file', (name, value, _ref) => {
+    let filename = _ref.filename,
+        encoding = _ref.encoding,
+        mimeType = _ref.mimeType;
+
+    if (encoding.toLowerCase() === 'base64') {
+      throw new Error("React doesn't accept base64 encoded file uploads because we don't expect " + "form data passed from a browser to ever encode data that way. If that's " + 'the wrong assumption, we can easily fix it.');
+    }
+
+    pendingFiles++;
+    const file = resolveFileInfo(response, name, filename, mimeType);
+    value.on('data', chunk => {
+      resolveFileChunk(response, file, chunk);
+    });
+    value.on('end', () => {
+      resolveFileComplete(response, name, file);
+      pendingFiles--;
+
+      if (pendingFiles === 0) {
+        // Release any queued fields
+        for (let i = 0; i < queuedFields.length; i += 2) {
+          resolveField(response, queuedFields[i], queuedFields[i + 1]);
+        }
+
+        queuedFields.length = 0;
+      }
+    });
+  });
+  busboyStream.on('finish', () => {
+    close(response);
+  });
+  busboyStream.on('error', err => {
+    reportGlobalError(response, // $FlowFixMe[incompatible-call] types Error and mixed are incompatible
+    err);
+  });
+  return getRoot(response);
+}
+
+function decodeReply(body, webpackMap) {
+  if (typeof body === 'string') {
+    const form = new FormData();
+    form.append('0', body);
+    body = form;
+  }
+
+  const response = createResponse(webpackMap, '', body);
+  const root = getRoot(response);
+  close(response);
+  return root;
+}
+
+exports.createClientModuleProxy = createClientModuleProxy;
+exports.decodeAction = decodeAction;
+exports.decodeFormState = decodeFormState;
+exports.decodeReply = decodeReply;
+exports.decodeReplyFromBusboy = decodeReplyFromBusboy;
+exports.registerClientReference = registerClientReference;
+exports.registerServerReference = registerServerReference;
+exports.renderToPipeableStream = renderToPipeableStream;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.node.production.min.js b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.node.production.min.js
index b25c7ffd9b540..c55c15cd4fd75 100644
--- a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.node.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.node.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-webpack-server.node.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-webpack-server.node.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var ba=require("util");require("crypto");var ca=require("async_hooks"),da=require("react"),ea=require("react-dom"),l=null,m=0,p=!0;function q(a,b){a=a.write(b);p=p&&a}
 function r(a,b){if("string"===typeof b){if(0!==b.length)if(2048<3*b.length)0<m&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=0),q(a,fa.encode(b));else{var d=l;0<m&&(d=l.subarray(m));d=fa.encodeInto(b,d);var c=d.read;m+=d.written;c<b.length&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=fa.encodeInto(b.slice(c),l).written);2048===m&&(q(a,l),l=new Uint8Array(2048),m=0)}}else 0!==b.byteLength&&(2048<b.byteLength?(0<m&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=0),q(a,b)):(d=l.length-m,d<b.byteLength&&
 (0===d?q(a,l):(l.set(b.subarray(0,d),m),m+=d,q(a,l),b=b.subarray(d)),l=new Uint8Array(2048),m=0),l.set(b,m),m+=b.byteLength,2048===m&&(q(a,l),l=new Uint8Array(2048),m=0)));return p}var fa=new ba.TextEncoder,t=Symbol.for("react.client.reference"),v=Symbol.for("react.server.reference");function w(a,b,d){return Object.defineProperties(a,{$$typeof:{value:t},$$id:{value:b},$$async:{value:d}})}var ha=Function.prototype.bind,ia=Array.prototype.slice;
@@ -80,3 +80,5 @@ exports.decodeFormState=function(a,b,d){var c=b.get("$ACTION_KEY");if("string"!=
 exports.decodeReplyFromBusboy=function(a,b){var d=Lb(b,""),c=0,e=[];a.on("field",function(f,g){0<c?e.push(f,g):Mb(d,f,g)});a.on("file",function(f,g,k){var h=k.filename,n=k.mimeType;if("base64"===k.encoding.toLowerCase())throw Error("React doesn't accept base64 encoded file uploads because we don't expect form data passed from a browser to ever encode data that way. If that's the wrong assumption, we can easily fix it.");c++;var z=[];g.on("data",function(u){z.push(u)});g.on("end",function(){var u=
 new Blob(z,{type:n});d._formData.append(f,u,h);c--;if(0===c){for(u=0;u<e.length;u+=2)Mb(d,e[u],e[u+1]);e.length=0}})});a.on("finish",function(){Qb(d)});a.on("error",function(f){Ib(d,f)});return Z(d,0)};exports.registerClientReference=function(a,b,d){return w(a,b+"#"+d,!1)};exports.registerServerReference=function(a,b,d){return Object.defineProperties(a,{$$typeof:{value:v},$$id:{value:null===d?b:b+"#"+d},$$bound:{value:null},bind:{value:ja}})};
 exports.renderToPipeableStream=function(a,b,d){var c=hb(a,b,d?d.onError:void 0,d?d.context:void 0,d?d.identifierPrefix:void 0,d?d.onPostpone:void 0),e=!1;tb(c);return{pipe:function(f){if(e)throw Error("React currently only supports piping to one writable stream.");e=!0;ub(c,f);f.on("drain",Tb(f,c));f.on("error",Ub(c,"The destination stream errored while writing data."));f.on("close",Ub(c,"The destination stream closed early."));return f},abort:function(f){vb(c,f)}}};
+
+//# sourceMappingURL=react-server-dom-webpack-server.node.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.node.unbundled.production.js b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.node.unbundled.production.js
new file mode 100644
index 0000000000000..f12c89208cbe0
--- /dev/null
+++ b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.node.unbundled.production.js
@@ -0,0 +1,3273 @@
+/**
+ * @license React
+ * react-server-dom-webpack-server.node.unbundled.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var util = require('util');
+require('crypto');
+var async_hooks = require('async_hooks');
+var React = require('react');
+var ReactDOM = require('react-dom');
+
+// -----------------------------------------------------------------------------
+const enablePostpone = false;
+
+function scheduleWork(callback) {
+  setImmediate(callback);
+}
+function flushBuffered(destination) {
+  // If we don't have any more data to send right now.
+  // Flush whatever is in the buffer to the wire.
+  if (typeof destination.flush === 'function') {
+    // By convention the Zlib streams provide a flush function for this purpose.
+    // For Express, compression middleware adds this method.
+    destination.flush();
+  }
+}
+const VIEW_SIZE = 2048;
+let currentView = null;
+let writtenBytes = 0;
+let destinationHasCapacity = true;
+function beginWriting(destination) {
+  currentView = new Uint8Array(VIEW_SIZE);
+  writtenBytes = 0;
+  destinationHasCapacity = true;
+}
+
+function writeStringChunk(destination, stringChunk) {
+  if (stringChunk.length === 0) {
+    return;
+  } // maximum possible view needed to encode entire string
+
+
+  if (stringChunk.length * 3 > VIEW_SIZE) {
+    if (writtenBytes > 0) {
+      writeToDestination(destination, currentView.subarray(0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    writeToDestination(destination, textEncoder.encode(stringChunk));
+    return;
+  }
+
+  let target = currentView;
+
+  if (writtenBytes > 0) {
+    target = currentView.subarray(writtenBytes);
+  }
+
+  const _textEncoder$encodeIn = textEncoder.encodeInto(stringChunk, target),
+        read = _textEncoder$encodeIn.read,
+        written = _textEncoder$encodeIn.written;
+
+  writtenBytes += written;
+
+  if (read < stringChunk.length) {
+    writeToDestination(destination, currentView.subarray(0, writtenBytes));
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = textEncoder.encodeInto(stringChunk.slice(read), currentView).written;
+  }
+
+  if (writtenBytes === VIEW_SIZE) {
+    writeToDestination(destination, currentView);
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+}
+
+function writeViewChunk(destination, chunk) {
+  if (chunk.byteLength === 0) {
+    return;
+  }
+
+  if (chunk.byteLength > VIEW_SIZE) {
+    // one that is cached by the streaming renderer. We will enqueu
+    // it directly and expect it is not re-used
+
+
+    if (writtenBytes > 0) {
+      writeToDestination(destination, currentView.subarray(0, writtenBytes));
+      currentView = new Uint8Array(VIEW_SIZE);
+      writtenBytes = 0;
+    }
+
+    writeToDestination(destination, chunk);
+    return;
+  }
+
+  let bytesToWrite = chunk;
+  const allowableBytes = currentView.length - writtenBytes;
+
+  if (allowableBytes < bytesToWrite.byteLength) {
+    // this chunk would overflow the current view. We enqueue a full view
+    // and start a new view with the remaining chunk
+    if (allowableBytes === 0) {
+      // the current view is already full, send it
+      writeToDestination(destination, currentView);
+    } else {
+      // fill up the current view and apply the remaining chunk bytes
+      // to a new view.
+      currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes);
+      writtenBytes += allowableBytes;
+      writeToDestination(destination, currentView);
+      bytesToWrite = bytesToWrite.subarray(allowableBytes);
+    }
+
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+
+  currentView.set(bytesToWrite, writtenBytes);
+  writtenBytes += bytesToWrite.byteLength;
+
+  if (writtenBytes === VIEW_SIZE) {
+    writeToDestination(destination, currentView);
+    currentView = new Uint8Array(VIEW_SIZE);
+    writtenBytes = 0;
+  }
+}
+
+function writeChunk(destination, chunk) {
+  if (typeof chunk === 'string') {
+    writeStringChunk(destination, chunk);
+  } else {
+    writeViewChunk(destination, chunk);
+  }
+}
+
+function writeToDestination(destination, view) {
+  const currentHasCapacity = destination.write(view);
+  destinationHasCapacity = destinationHasCapacity && currentHasCapacity;
+}
+
+function writeChunkAndReturn(destination, chunk) {
+  writeChunk(destination, chunk);
+  return destinationHasCapacity;
+}
+function completeWriting(destination) {
+  if (currentView && writtenBytes > 0) {
+    destination.write(currentView.subarray(0, writtenBytes));
+  }
+
+  currentView = null;
+  writtenBytes = 0;
+  destinationHasCapacity = true;
+}
+function close$1(destination) {
+  destination.end();
+}
+const textEncoder = new util.TextEncoder();
+function stringToChunk(content) {
+  return content;
+}
+function byteLengthOfChunk(chunk) {
+  return typeof chunk === 'string' ? Buffer.byteLength(chunk, 'utf8') : chunk.byteLength;
+}
+function closeWithError(destination, error) {
+  // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+  destination.destroy(error);
+}
+
+// eslint-disable-next-line no-unused-vars
+const CLIENT_REFERENCE_TAG = Symbol.for('react.client.reference');
+const SERVER_REFERENCE_TAG = Symbol.for('react.server.reference');
+function isClientReference(reference) {
+  return reference.$$typeof === CLIENT_REFERENCE_TAG;
+}
+function isServerReference(reference) {
+  return reference.$$typeof === SERVER_REFERENCE_TAG;
+}
+function registerClientReference(proxyImplementation, id, exportName) {
+  return registerClientReferenceImpl(proxyImplementation, id + '#' + exportName, false);
+}
+
+function registerClientReferenceImpl(proxyImplementation, id, async) {
+  return Object.defineProperties(proxyImplementation, {
+    $$typeof: {
+      value: CLIENT_REFERENCE_TAG
+    },
+    $$id: {
+      value: id
+    },
+    $$async: {
+      value: async
+    }
+  });
+} // $FlowFixMe[method-unbinding]
+
+
+const FunctionBind = Function.prototype.bind; // $FlowFixMe[method-unbinding]
+
+const ArraySlice = Array.prototype.slice;
+
+function bind() {
+  // $FlowFixMe[unsupported-syntax]
+  const newFn = FunctionBind.apply(this, arguments);
+
+  if (this.$$typeof === SERVER_REFERENCE_TAG) {
+    const args = ArraySlice.call(arguments, 1);
+    newFn.$$typeof = SERVER_REFERENCE_TAG;
+    newFn.$$id = this.$$id;
+    newFn.$$bound = this.$$bound ? this.$$bound.concat(args) : args;
+  }
+
+  return newFn;
+}
+
+function registerServerReference(reference, id, exportName) {
+  return Object.defineProperties(reference, {
+    $$typeof: {
+      value: SERVER_REFERENCE_TAG
+    },
+    $$id: {
+      value: exportName === null ? id : id + '#' + exportName
+    },
+    $$bound: {
+      value: null
+    },
+    bind: {
+      value: bind
+    }
+  });
+}
+const PROMISE_PROTOTYPE = Promise.prototype;
+const deepProxyHandlers = {
+  get: function (target, name, receiver) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        // These names are a little too common. We should probably have a way to
+        // have the Flight runtime extract the inner target instead.
+        return target.$$typeof;
+
+      case '$$id':
+        return target.$$id;
+
+      case '$$async':
+        return target.$$async;
+
+      case 'name':
+        return target.name;
+
+      case 'displayName':
+        return undefined;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+
+      case 'toJSON':
+        return undefined;
+
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+
+      case 'Provider':
+        throw new Error("Cannot render a Client Context Provider on the Server. " + "Instead, you can export a Client Component wrapper " + "that itself renders a Client Context Provider.");
+    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+    const expression = String(target.name) + '.' + String(name);
+    throw new Error("Cannot access " + expression + " on the server. " + 'You cannot dot into a client module from a server component. ' + 'You can only pass the imported name through.');
+  },
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+
+function getReference(target, name) {
+  switch (name) {
+    // These names are read by the Flight runtime if you end up using the exports object.
+    case '$$typeof':
+      return target.$$typeof;
+
+    case '$$id':
+      return target.$$id;
+
+    case '$$async':
+      return target.$$async;
+
+    case 'name':
+      return target.name;
+    // We need to special case this because createElement reads it if we pass this
+    // reference.
+
+    case 'defaultProps':
+      return undefined;
+    // Avoid this attempting to be serialized.
+
+    case 'toJSON':
+      return undefined;
+
+    case Symbol.toPrimitive:
+      // $FlowFixMe[prop-missing]
+      return Object.prototype[Symbol.toPrimitive];
+
+    case '__esModule':
+      // Something is conditionally checking which export to use. We'll pretend to be
+      // an ESM compat module but then we'll check again on the client.
+      const moduleId = target.$$id;
+      target.default = registerClientReferenceImpl(function () {
+        throw new Error("Attempted to call the default export of " + moduleId + " from the server " + "but it's on the client. It's not possible to invoke a client function from " + "the server, it can only be rendered as a Component or passed to props of a " + "Client Component.");
+      }, target.$$id + '#', target.$$async);
+      return true;
+
+    case 'then':
+      if (target.then) {
+        // Use a cached value
+        return target.then;
+      }
+
+      if (!target.$$async) {
+        // If this module is expected to return a Promise (such as an AsyncModule) then
+        // we should resolve that with a client reference that unwraps the Promise on
+        // the client.
+        const clientReference = registerClientReferenceImpl({}, target.$$id, true);
+        const proxy = new Proxy(clientReference, proxyHandlers); // Treat this as a resolved Promise for React's use()
+
+        target.status = 'fulfilled';
+        target.value = proxy;
+        const then = target.then = registerClientReferenceImpl(function then(resolve, reject) {
+          // Expose to React.
+          return Promise.resolve(resolve(proxy));
+        }, // If this is not used as a Promise but is treated as a reference to a `.then`
+        // export then we should treat it as a reference to that name.
+        target.$$id + '#then', false);
+        return then;
+      } else {
+        // Since typeof .then === 'function' is a feature test we'd continue recursing
+        // indefinitely if we return a function. Instead, we return an object reference
+        // if we check further.
+        return undefined;
+      }
+
+  }
+
+  let cachedReference = target[name];
+
+  if (!cachedReference) {
+    const reference = registerClientReferenceImpl(function () {
+      throw new Error( // eslint-disable-next-line react-internal/safe-string-coercion
+      "Attempted to call " + String(name) + "() from the server but " + String(name) + " is on the client. " + "It's not possible to invoke a client function from the server, it can " + "only be rendered as a Component or passed to props of a Client Component.");
+    }, target.$$id + '#' + name, target.$$async);
+    Object.defineProperty(reference, 'name', {
+      value: name
+    });
+    cachedReference = target[name] = new Proxy(reference, deepProxyHandlers);
+  }
+
+  return cachedReference;
+}
+
+const proxyHandlers = {
+  get: function (target, name, receiver) {
+    return getReference(target, name);
+  },
+  getOwnPropertyDescriptor: function (target, name) {
+    let descriptor = Object.getOwnPropertyDescriptor(target, name);
+
+    if (!descriptor) {
+      descriptor = {
+        value: getReference(target, name),
+        writable: false,
+        configurable: false,
+        enumerable: false
+      };
+      Object.defineProperty(target, name, descriptor);
+    }
+
+    return descriptor;
+  },
+
+  getPrototypeOf(target) {
+    // Pretend to be a Promise in case anyone asks.
+    return PROMISE_PROTOTYPE;
+  },
+
+  set: function () {
+    throw new Error('Cannot assign to a client module from a server module.');
+  }
+};
+function createClientModuleProxy(moduleId) {
+  const clientReference = registerClientReferenceImpl({}, // Represents the whole Module object instead of a particular import.
+  moduleId, false);
+  return new Proxy(clientReference, proxyHandlers);
+}
+
+function getClientReferenceKey(reference) {
+  return reference.$$async ? reference.$$id + '#async' : reference.$$id;
+}
+function resolveClientReferenceMetadata(config, clientReference) {
+  const modulePath = clientReference.$$id;
+  let name = '';
+  let resolvedModuleData = config[modulePath];
+
+  if (resolvedModuleData) {
+    // The potentially aliased name.
+    name = resolvedModuleData.name;
+  } else {
+    // We didn't find this specific export name but we might have the * export
+    // which contains this name as well.
+    // TODO: It's unfortunate that we now have to parse this string. We should
+    // probably go back to encoding path and name separately on the client reference.
+    const idx = modulePath.lastIndexOf('#');
+
+    if (idx !== -1) {
+      name = modulePath.slice(idx + 1);
+      resolvedModuleData = config[modulePath.slice(0, idx)];
+    }
+
+    if (!resolvedModuleData) {
+      throw new Error('Could not find the module "' + modulePath + '" in the React Client Manifest. ' + 'This is probably a bug in the React Server Components bundler.');
+    }
+  }
+
+  if (clientReference.$$async === true) {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1];
+  } else {
+    return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+  }
+}
+function getServerReferenceId(config, serverReference) {
+  return serverReference.$$id;
+}
+function getServerReferenceBoundArguments(config, serverReference) {
+  return serverReference.$$bound;
+}
+
+const ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactDOMFlightServerDispatcher = {
+  prefetchDNS,
+  preconnect,
+  preload,
+  preloadModule: preloadModule$1,
+  preinitStyle,
+  preinitScript,
+  preinitModuleScript
+};
+
+function prefetchDNS(href) {
+  {
+    if (typeof href === 'string' && href) {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'D|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        emitHint(request, 'D', href);
+      }
+    }
+  }
+}
+
+function preconnect(href, crossOrigin) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = "C|" + (crossOrigin == null ? 'null' : crossOrigin) + "|" + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+
+        if (typeof crossOrigin === 'string') {
+          emitHint(request, 'C', [href, crossOrigin]);
+        } else {
+          emitHint(request, 'C', href);
+        }
+      }
+    }
+  }
+}
+
+function preload(href, as, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        let key = 'L';
+
+        if (as === 'image' && options) {
+          key += getImagePreloadKey(href, options.imageSrcSet, options.imageSizes);
+        } else {
+          key += "[" + as + "]" + href;
+        }
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          emitHint(request, 'L', [href, as, trimmed]);
+        } else {
+          emitHint(request, 'L', [href, as]);
+        }
+      }
+    }
+  }
+}
+
+function preloadModule$1(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'm|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'm', [href, trimmed]);
+        } else {
+          return emitHint(request, 'm', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitStyle(href, precedence, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'S|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'S', [href, typeof precedence === 'string' ? precedence : 0, trimmed]);
+        } else if (typeof precedence === 'string') {
+          return emitHint(request, 'S', [href, precedence]);
+        } else {
+          return emitHint(request, 'S', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'X|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'X', [href, trimmed]);
+        } else {
+          return emitHint(request, 'X', href);
+        }
+      }
+    }
+  }
+}
+
+function preinitModuleScript(href, options) {
+  {
+    if (typeof href === 'string') {
+      const request = resolveRequest();
+
+      if (request) {
+        const hints = getHints(request);
+        const key = 'M|' + href;
+
+        if (hints.has(key)) {
+          // duplicate hint
+          return;
+        }
+
+        hints.add(key);
+        const trimmed = trimOptions(options);
+
+        if (trimmed) {
+          return emitHint(request, 'M', [href, trimmed]);
+        } else {
+          return emitHint(request, 'M', href);
+        }
+      }
+    }
+  }
+} // Flight normally encodes undefined as a special character however for directive option
+// arguments we don't want to send unnecessary keys and bloat the payload so we create a
+// trimmed object which omits any keys with null or undefined values.
+// This is only typesafe because these option objects have entirely optional fields where
+// null and undefined represent the same thing as no property.
+
+
+function trimOptions(options) {
+  if (options == null) return null;
+  let hasProperties = false;
+  const trimmed = {};
+
+  for (const key in options) {
+    if (options[key] != null) {
+      hasProperties = true;
+      trimmed[key] = options[key];
+    }
+  }
+
+  return hasProperties ? trimmed : null;
+}
+
+function getImagePreloadKey(href, imageSrcSet, imageSizes) {
+  let uniquePart = '';
+
+  if (typeof imageSrcSet === 'string' && imageSrcSet !== '') {
+    uniquePart += '[' + imageSrcSet + ']';
+
+    if (typeof imageSizes === 'string') {
+      uniquePart += '[' + imageSizes + ']';
+    }
+  } else {
+    uniquePart += '[][]' + href;
+  }
+
+  return "[image]" + uniquePart;
+}
+
+const ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+function prepareHostDispatcher() {
+  ReactDOMCurrentDispatcher.current = ReactDOMFlightServerDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+// small, smaller than how we encode undefined, and is unambiguous. We could use
+// a different tuple structure to encode this instead but this makes the runtime
+// cost cheaper by eliminating a type checks in more positions.
+// prettier-ignore
+
+function createHints() {
+  return new Set();
+}
+
+const requestStorage = new async_hooks.AsyncLocalStorage();
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+// Forming a reverse tree.
+// The structure of a context snapshot is an implementation of this file.
+// Currently, it's implemented as tracking the current active node.
+
+
+const rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
+// This global (actually thread local) state represents what state all those "current",
+// fields are currently in.
+
+let currentActiveSnapshot = null;
+
+function popNode(prev) {
+  {
+    prev.context._currentValue = prev.parentValue;
+  }
+}
+
+function pushNode(next) {
+  {
+    next.context._currentValue = next.value;
+  }
+}
+
+function popToNearestCommonAncestor(prev, next) {
+  if (prev === next) ; else {
+    popNode(prev);
+    const parentPrev = prev.parent;
+    const parentNext = next.parent;
+
+    if (parentPrev === null) {
+      if (parentNext !== null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+    } else {
+      if (parentNext === null) {
+        throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
+      }
+
+      popToNearestCommonAncestor(parentPrev, parentNext); // On the way back, we push the new ones that weren't common.
+
+      pushNode(next);
+    }
+  }
+}
+
+function popAllPrevious(prev) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev !== null) {
+    popAllPrevious(parentPrev);
+  }
+}
+
+function pushAllNext(next) {
+  const parentNext = next.parent;
+
+  if (parentNext !== null) {
+    pushAllNext(parentNext);
+  }
+
+  pushNode(next);
+}
+
+function popPreviousToCommonLevel(prev, next) {
+  popNode(prev);
+  const parentPrev = prev.parent;
+
+  if (parentPrev === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (parentPrev.depth === next.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(parentPrev, next);
+  } else {
+    // We must still be deeper.
+    popPreviousToCommonLevel(parentPrev, next);
+  }
+}
+
+function popNextToCommonLevel(prev, next) {
+  const parentNext = next.parent;
+
+  if (parentNext === null) {
+    throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
+  }
+
+  if (prev.depth === parentNext.depth) {
+    // We found the same level. Now we just need to find a shared ancestor.
+    popToNearestCommonAncestor(prev, parentNext);
+  } else {
+    // We must still be deeper.
+    popNextToCommonLevel(prev, parentNext);
+  }
+
+  pushNode(next);
+} // Perform context switching to the new snapshot.
+// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
+// updating all the context's current values. That way reads, always just read the current value.
+// At the cost of updating contexts even if they're never read by this subtree.
+
+
+function switchContext(newSnapshot) {
+  // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
+  // We also need to update any new contexts that are now on the stack with the deepest value.
+  // The easiest way to update new contexts is to just reapply them in reverse order from the
+  // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
+  // for that. Therefore this algorithm is recursive.
+  // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
+  // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
+  // 3) Then we reapply new contexts on the way back up the stack.
+  const prev = currentActiveSnapshot;
+  const next = newSnapshot;
+
+  if (prev !== next) {
+    if (prev === null) {
+      // $FlowFixMe[incompatible-call]: This has to be non-null since it's not equal to prev.
+      pushAllNext(next);
+    } else if (next === null) {
+      popAllPrevious(prev);
+    } else if (prev.depth === next.depth) {
+      popToNearestCommonAncestor(prev, next);
+    } else if (prev.depth > next.depth) {
+      popPreviousToCommonLevel(prev, next);
+    } else {
+      popNextToCommonLevel(prev, next);
+    }
+
+    currentActiveSnapshot = next;
+  }
+}
+function getActiveContext() {
+  return currentActiveSnapshot;
+}
+function readContext$1(context) {
+  const value = context._currentValue ;
+  return value;
+}
+
+// Corresponds to ReactFiberWakeable and ReactFizzWakeable modules. Generally,
+// changes to one module should be reflected in the others.
+// TODO: Rename this module and the corresponding Fiber one to "Thenable"
+// instead of "Wakeable". Or some other more appropriate name.
+// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
+const SuspenseException = new Error("Suspense Exception: This is not a real error! It's an implementation " + 'detail of `use` to interrupt the current render. You must either ' + 'rethrow it immediately, or move the `use` call outside of the ' + '`try/catch` block. Capturing without rethrowing will lead to ' + 'unexpected behavior.\n\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+
+function noop() {}
+
+function trackUsedThenable(thenableState, thenable, index) {
+  const previous = thenableState[index];
+
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop, noop);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
+
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        const fulfilledValue = thenable.value;
+        return fulfilledValue;
+      }
+
+    case 'rejected':
+      {
+        const rejectedError = thenable.reason;
+        throw rejectedError;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') ; else {
+          const pendingThenable = thenable;
+          pendingThenable.status = 'pending';
+          pendingThenable.then(fulfilledValue => {
+            if (thenable.status === 'pending') {
+              const fulfilledThenable = thenable;
+              fulfilledThenable.status = 'fulfilled';
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, error => {
+            if (thenable.status === 'pending') {
+              const rejectedThenable = thenable;
+              rejectedThenable.status = 'rejected';
+              rejectedThenable.reason = error;
+            }
+          }); // Check one more time in case the thenable resolved synchronously
+
+          switch (thenable.status) {
+            case 'fulfilled':
+              {
+                const fulfilledThenable = thenable;
+                return fulfilledThenable.value;
+              }
+
+            case 'rejected':
+              {
+                const rejectedThenable = thenable;
+                throw rejectedThenable.reason;
+              }
+          }
+        } // Suspend.
+        //
+        // Throwing here is an implementation detail that allows us to unwind the
+        // call stack. But we shouldn't allow it to leak into userspace. Throw an
+        // opaque placeholder value instead of the actual thenable. If it doesn't
+        // get captured by the work loop, log a warning, because that means
+        // something in userspace must have caught it.
+
+
+        suspendedThenable = thenable;
+        throw SuspenseException;
+      }
+  }
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
+
+let suspendedThenable = null;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
+  }
+
+  const thenable = suspendedThenable;
+  suspendedThenable = null;
+  return thenable;
+}
+
+let currentRequest$1 = null;
+let thenableIndexCounter = 0;
+let thenableState = null;
+function prepareToUseHooksForRequest(request) {
+  currentRequest$1 = request;
+}
+function resetHooksForRequest() {
+  currentRequest$1 = null;
+}
+function prepareToUseHooksForComponent(prevThenableState) {
+  thenableIndexCounter = 0;
+  thenableState = prevThenableState;
+}
+function getThenableStateAfterSuspending() {
+  const state = thenableState;
+  thenableState = null;
+  return state;
+}
+
+function readContext(context) {
+
+  return readContext$1(context);
+}
+
+const HooksDispatcher = {
+  useMemo(nextCreate) {
+    return nextCreate();
+  },
+
+  useCallback(callback) {
+    return callback;
+  },
+
+  useDebugValue() {},
+
+  useDeferredValue: unsupportedHook,
+  useTransition: unsupportedHook,
+  readContext,
+  useContext: readContext,
+  useReducer: unsupportedHook,
+  useRef: unsupportedHook,
+  useState: unsupportedHook,
+  useInsertionEffect: unsupportedHook,
+  useLayoutEffect: unsupportedHook,
+  useImperativeHandle: unsupportedHook,
+  useEffect: unsupportedHook,
+  useId,
+  useSyncExternalStore: unsupportedHook,
+
+  useCacheRefresh() {
+    return unsupportedRefresh;
+  },
+
+  useMemoCache(size) {
+    const data = new Array(size);
+
+    for (let i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL;
+    }
+
+    return data;
+  },
+
+  use
+};
+
+function unsupportedHook() {
+  throw new Error('This Hook is not supported in Server Components.');
+}
+
+function unsupportedRefresh() {
+  throw new Error('Refreshing the cache is not supported in Server Components.');
+}
+
+function useId() {
+  if (currentRequest$1 === null) {
+    throw new Error('useId can only be used while React is rendering');
+  }
+
+  const id = currentRequest$1.identifierCount++; // use 'S' for Flight components to distinguish from 'R' and 'r' in Fizz/Client
+
+  return ':' + currentRequest$1.identifierPrefix + 'S' + id.toString(32) + ':';
+}
+
+function use(usable) {
+  if (usable !== null && typeof usable === 'object' || typeof usable === 'function') {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === 'function') {
+      // This is a thenable.
+      const thenable = usable; // Track the position of the thenable within this fiber.
+
+      const index = thenableIndexCounter;
+      thenableIndexCounter += 1;
+
+      if (thenableState === null) {
+        thenableState = createThenableState();
+      }
+
+      return trackUsedThenable(thenableState, thenable, index);
+    } else if (usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
+      const context = usable;
+      return readContext(context);
+    }
+  }
+
+
+  throw new Error('An unsupported type was passed to use(): ' + String(usable));
+}
+
+function createSignal() {
+  return new AbortController().signal;
+}
+
+function resolveCache() {
+  const request = resolveRequest();
+
+  if (request) {
+    return getCache(request);
+  }
+
+  return new Map();
+}
+
+const DefaultCacheDispatcher = {
+  getCacheSignal() {
+    const cache = resolveCache();
+    let entry = cache.get(createSignal);
+
+    if (entry === undefined) {
+      entry = createSignal();
+      cache.set(createSignal, entry);
+    }
+
+    return entry;
+  },
+
+  getCacheForType(resourceType) {
+    const cache = resolveCache();
+    let entry = cache.get(resourceType);
+
+    if (entry === undefined) {
+      entry = resourceType(); // TODO: Warn if undefined?
+
+      cache.set(resourceType, entry);
+    }
+
+    return entry;
+  }
+
+};
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+function objectName(object) {
+  // $FlowFixMe[method-unbinding]
+  const name = Object.prototype.toString.call(object);
+  return name.replace(/^\[object (.*)\]$/, function (m, p0) {
+    return p0;
+  });
+}
+
+function describeKeyForErrorMessage(key) {
+  const encodedKey = JSON.stringify(key);
+  return '"' + key + '"' === encodedKey ? key : encodedKey;
+}
+
+function describeValueForErrorMessage(value) {
+  switch (typeof value) {
+    case 'string':
+      {
+        return JSON.stringify(value.length <= 10 ? value : value.slice(0, 10) + '...');
+      }
+
+    case 'object':
+      {
+        if (isArray(value)) {
+          return '[...]';
+        }
+
+        const name = objectName(value);
+
+        if (name === 'Object') {
+          return '{...}';
+        }
+
+        return name;
+      }
+
+    case 'function':
+      return 'function';
+
+    default:
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      return String(value);
+  }
+}
+
+function describeElementType(type) {
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        return describeElementType(type.render);
+
+      case REACT_MEMO_TYPE:
+        return describeElementType(type.type);
+
+      case REACT_LAZY_TYPE:
+        {
+          const lazyComponent = type;
+          const payload = lazyComponent._payload;
+          const init = lazyComponent._init;
+
+          try {
+            // Lazy may contain any component type so we recursively resolve it.
+            return describeElementType(init(payload));
+          } catch (x) {}
+        }
+    }
+  }
+
+  return '';
+}
+
+function describeObjectForErrorMessage(objectOrArray, expandedName) {
+  const objKind = objectName(objectOrArray);
+
+  if (objKind !== 'Object' && objKind !== 'Array') {
+    return objKind;
+  }
+
+  let str = '';
+  let start = -1;
+  let length = 0;
+
+  if (isArray(objectOrArray)) {
+    {
+      // Print Array
+      str = '[';
+      const array = objectOrArray;
+
+      for (let i = 0; i < array.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const value = array[i];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if ('' + i === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += ']';
+    }
+  } else {
+    if (objectOrArray.$$typeof === REACT_ELEMENT_TYPE) {
+      str = '<' + describeElementType(objectOrArray.type) + '/>';
+    } else {
+      // Print Object
+      str = '{';
+      const object = objectOrArray;
+      const names = Object.keys(object);
+
+      for (let i = 0; i < names.length; i++) {
+        if (i > 0) {
+          str += ', ';
+        }
+
+        const name = names[i];
+        str += describeKeyForErrorMessage(name) + ': ';
+        const value = object[name];
+        let substr;
+
+        if (typeof value === 'object' && value !== null) {
+          substr = describeObjectForErrorMessage(value);
+        } else {
+          substr = describeValueForErrorMessage(value);
+        }
+
+        if (name === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 10 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '...';
+        }
+      }
+
+      str += '}';
+    }
+  }
+
+  if (expandedName === undefined) {
+    return str;
+  }
+
+  if (start > -1 && length > 0) {
+    const highlight = ' '.repeat(start) + '^'.repeat(length);
+    return '\n  ' + str + '\n  ' + highlight;
+  }
+
+  return '\n  ' + str;
+}
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+const ReactSharedServerInternals = // $FlowFixMe: It's defined in the one we resolve to.
+React.__SECRET_SERVER_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+if (!ReactSharedServerInternals) {
+  throw new Error('The "react" package in this environment is not configured correctly. ' + 'The "react-server" condition must be enabled in any environment that ' + 'runs React Server Components.');
+}
+
+const ObjectPrototype = Object.prototype;
+const stringify = JSON.stringify; // Serializable values
+// Thenable<ReactClientValue>
+
+const PENDING$1 = 0;
+const COMPLETED = 1;
+const ABORTED = 3;
+const ERRORED$1 = 4;
+const ReactCurrentCache = ReactSharedServerInternals.ReactCurrentCache;
+const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+
+function defaultErrorHandler(error) {
+  console['error'](error); // Don't transform to our wrapper
+}
+
+function defaultPostponeHandler(reason) {// Noop
+}
+
+const OPEN = 0;
+const CLOSING = 1;
+const CLOSED = 2;
+function createRequest(model, bundlerConfig, onError, context, identifierPrefix, onPostpone) {
+  if (ReactCurrentCache.current !== null && ReactCurrentCache.current !== DefaultCacheDispatcher) {
+    throw new Error('Currently React only supports one RSC renderer at a time.');
+  }
+
+  prepareHostDispatcher();
+  ReactCurrentCache.current = DefaultCacheDispatcher;
+  const abortSet = new Set();
+  const pingedTasks = [];
+  const cleanupQueue = [];
+
+  const hints = createHints();
+  const request = {
+    status: OPEN,
+    flushScheduled: false,
+    fatalError: null,
+    destination: null,
+    bundlerConfig,
+    cache: new Map(),
+    nextChunkId: 0,
+    pendingChunks: 0,
+    hints,
+    abortableTasks: abortSet,
+    pingedTasks: pingedTasks,
+    completedImportChunks: [],
+    completedHintChunks: [],
+    completedRegularChunks: [],
+    completedErrorChunks: [],
+    writtenSymbols: new Map(),
+    writtenClientReferences: new Map(),
+    writtenServerReferences: new Map(),
+    writtenProviders: new Map(),
+    writtenObjects: new WeakMap(),
+    identifierPrefix: identifierPrefix || '',
+    identifierCount: 1,
+    taintCleanupQueue: cleanupQueue,
+    onError: onError === undefined ? defaultErrorHandler : onError,
+    onPostpone: onPostpone === undefined ? defaultPostponeHandler : onPostpone,
+    // $FlowFixMe[missing-this-annot]
+    toJSON: function (key, value) {
+      return resolveModelToJSON(request, this, key, value);
+    }
+  };
+  request.pendingChunks++;
+  const rootContext = createRootContext();
+  const rootTask = createTask(request, model, rootContext, abortSet);
+  pingedTasks.push(rootTask);
+  return request;
+}
+let currentRequest = null;
+function resolveRequest() {
+  if (currentRequest) return currentRequest;
+
+  {
+    const store = requestStorage.getStore();
+    if (store) return store;
+  }
+
+  return null;
+}
+
+function createRootContext(reqContext) {
+  return importServerContexts();
+}
+
+function serializeThenable(request, thenable) {
+  request.pendingChunks++;
+  const newTask = createTask(request, null, getActiveContext(), request.abortableTasks);
+
+  switch (thenable.status) {
+    case 'fulfilled':
+      {
+        // We have the resolved value, we can go ahead and schedule it for serialization.
+        newTask.model = thenable.value;
+        pingTask(request, newTask);
+        return newTask.id;
+      }
+
+    case 'rejected':
+      {
+        const x = thenable.reason;
+
+        {
+          const digest = logRecoverableError(request, x);
+          emitErrorChunk(request, newTask.id, digest);
+        }
+
+        return newTask.id;
+      }
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  thenable.then(value => {
+    newTask.model = value;
+    pingTask(request, newTask);
+  }, reason => {
+    newTask.status = ERRORED$1;
+    request.abortableTasks.delete(newTask); // TODO: We should ideally do this inside performWork so it's scheduled
+
+    const digest = logRecoverableError(request, reason);
+    emitErrorChunk(request, newTask.id, digest);
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  });
+  return newTask.id;
+}
+
+function emitHint(request, code, model) {
+  emitHintChunk(request, code, model);
+  enqueueFlush(request);
+}
+function getHints(request) {
+  return request.hints;
+}
+function getCache(request) {
+  return request.cache;
+}
+
+function readThenable(thenable) {
+  if (thenable.status === 'fulfilled') {
+    return thenable.value;
+  } else if (thenable.status === 'rejected') {
+    throw thenable.reason;
+  }
+
+  throw thenable;
+}
+
+function createLazyWrapperAroundWakeable(wakeable) {
+  // This is a temporary fork of the `use` implementation until we accept
+  // promises everywhere.
+  const thenable = wakeable;
+
+  switch (thenable.status) {
+    case 'fulfilled':
+    case 'rejected':
+      break;
+
+    default:
+      {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          break;
+        }
+
+        const pendingThenable = thenable;
+        pendingThenable.status = 'pending';
+        pendingThenable.then(fulfilledValue => {
+          if (thenable.status === 'pending') {
+            const fulfilledThenable = thenable;
+            fulfilledThenable.status = 'fulfilled';
+            fulfilledThenable.value = fulfilledValue;
+          }
+        }, error => {
+          if (thenable.status === 'pending') {
+            const rejectedThenable = thenable;
+            rejectedThenable.status = 'rejected';
+            rejectedThenable.reason = error;
+          }
+        });
+        break;
+      }
+  }
+
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: thenable,
+    _init: readThenable
+  };
+  return lazyType;
+}
+
+function attemptResolveElement(request, type, key, ref, props, prevThenableState) {
+  if (ref !== null && ref !== undefined) {
+    // When the ref moves to the regular props object this will implicitly
+    // throw for functions. We could probably relax it to a DEV warning for other
+    // cases.
+    throw new Error('Refs cannot be used in Server Components, nor passed to Client Components.');
+  }
+
+  if (typeof type === 'function') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    } // This is a server-side component.
+
+
+    prepareToUseHooksForComponent(prevThenableState);
+    const result = type(props);
+
+    if (typeof result === 'object' && result !== null && typeof result.then === 'function') {
+      // When the return value is in children position we can resolve it immediately,
+      // to its value without a wrapper if it's synchronously available.
+      const thenable = result;
+
+      if (thenable.status === 'fulfilled') {
+        return thenable.value;
+      } // TODO: Once we accept Promises as children on the client, we can just return
+      // the thenable here.
+
+
+      return createLazyWrapperAroundWakeable(result);
+    }
+
+    return result;
+  } else if (typeof type === 'string') {
+    // This is a host element. E.g. HTML.
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (typeof type === 'symbol') {
+    if (type === REACT_FRAGMENT_TYPE) {
+      // For key-less fragments, we add a small optimization to avoid serializing
+      // it as a wrapper.
+      // TODO: If a key is specified, we should propagate its key to any children.
+      // Same as if a Server Component has a key.
+      return props.children;
+    } // This might be a built-in React component. We'll let the client decide.
+    // Any built-in works as long as its props are serializable.
+
+
+    return [REACT_ELEMENT_TYPE, type, key, props];
+  } else if (type != null && typeof type === 'object') {
+    if (isClientReference(type)) {
+      // This is a reference to a Client Component.
+      return [REACT_ELEMENT_TYPE, type, key, props];
+    }
+
+    switch (type.$$typeof) {
+      case REACT_LAZY_TYPE:
+        {
+          const payload = type._payload;
+          const init = type._init;
+          const wrappedType = init(payload);
+          return attemptResolveElement(request, wrappedType, key, ref, props, prevThenableState);
+        }
+
+      case REACT_FORWARD_REF_TYPE:
+        {
+          const render = type.render;
+          prepareToUseHooksForComponent(prevThenableState);
+          return render(props, undefined);
+        }
+
+      case REACT_MEMO_TYPE:
+        {
+          return attemptResolveElement(request, type.type, key, ref, props, prevThenableState);
+        }
+    }
+  }
+
+  throw new Error("Unsupported Server Component type: " + describeValueForErrorMessage(type));
+}
+
+function pingTask(request, task) {
+  const pingedTasks = request.pingedTasks;
+  pingedTasks.push(task);
+
+  if (pingedTasks.length === 1) {
+    request.flushScheduled = request.destination !== null;
+    scheduleWork(() => performWork(request));
+  }
+}
+
+function createTask(request, model, context, abortSet) {
+  const id = request.nextChunkId++;
+  const task = {
+    id,
+    status: PENDING$1,
+    model,
+    context,
+    ping: () => pingTask(request, task),
+    thenableState: null
+  };
+  abortSet.add(task);
+  return task;
+}
+
+function serializeByValueID(id) {
+  return '$' + id.toString(16);
+}
+
+function serializeLazyID(id) {
+  return '$L' + id.toString(16);
+}
+
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
+
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
+
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
+
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
+
+function serializeUndefined() {
+  return '$undefined';
+}
+
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
+
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
+
+function serializeRowHeader(tag, id) {
+  return id.toString(16) + ':' + tag;
+}
+
+function encodeReferenceChunk(request, id, reference) {
+  const json = stringify(reference);
+  const row = id.toString(16) + ':' + json + '\n';
+  return stringToChunk(row);
+}
+
+function serializeClientReference(request, parent, key, clientReference) {
+  const clientReferenceKey = getClientReferenceKey(clientReference);
+  const writtenClientReferences = request.writtenClientReferences;
+  const existingId = writtenClientReferences.get(clientReferenceKey);
+
+  if (existingId !== undefined) {
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(existingId);
+    }
+
+    return serializeByValueID(existingId);
+  }
+
+  try {
+    const clientReferenceMetadata = resolveClientReferenceMetadata(request.bundlerConfig, clientReference);
+    request.pendingChunks++;
+    const importId = request.nextChunkId++;
+    emitImportChunk(request, importId, clientReferenceMetadata);
+    writtenClientReferences.set(clientReferenceKey, importId);
+
+    if (parent[0] === REACT_ELEMENT_TYPE && key === '1') {
+      // If we're encoding the "type" of an element, we can refer
+      // to that by a lazy reference instead of directly since React
+      // knows how to deal with lazy values. This lets us suspend
+      // on this component rather than its parent until the code has
+      // loaded.
+      return serializeLazyID(importId);
+    }
+
+    return serializeByValueID(importId);
+  } catch (x) {
+    request.pendingChunks++;
+    const errorId = request.nextChunkId++;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, errorId, digest);
+    return serializeByValueID(errorId);
+  }
+}
+
+function outlineModel(request, value) {
+  request.pendingChunks++;
+  const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+  retryTask(request, newTask);
+  return newTask.id;
+}
+
+function serializeServerReference(request, parent, key, serverReference) {
+  const writtenServerReferences = request.writtenServerReferences;
+  const existingId = writtenServerReferences.get(serverReference);
+
+  if (existingId !== undefined) {
+    return serializeServerReferenceID(existingId);
+  }
+
+  const bound = getServerReferenceBoundArguments(request.bundlerConfig, serverReference);
+  const serverReferenceMetadata = {
+    id: getServerReferenceId(request.bundlerConfig, serverReference),
+    bound: bound ? Promise.resolve(bound) : null
+  };
+  const metadataId = outlineModel(request, serverReferenceMetadata);
+  writtenServerReferences.set(serverReference, metadataId);
+  return serializeServerReferenceID(metadataId);
+}
+
+function serializeLargeTextString(request, text) {
+  request.pendingChunks += 2;
+  const textId = request.nextChunkId++;
+  const textChunk = stringToChunk(text);
+  const binaryLength = byteLengthOfChunk(textChunk);
+  const row = textId.toString(16) + ':T' + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, textChunk);
+  return serializeByValueID(textId);
+}
+
+function serializeMap(request, map) {
+  const entries = Array.from(map);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i][0];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$Q' + id.toString(16);
+}
+
+function serializeSet(request, set) {
+  const entries = Array.from(set);
+
+  for (let i = 0; i < entries.length; i++) {
+    const key = entries[i];
+
+    if (typeof key === 'object' && key !== null) {
+      const writtenObjects = request.writtenObjects;
+      const existingId = writtenObjects.get(key);
+
+      if (existingId === undefined) {
+        // Mark all object keys as seen so that they're always outlined.
+        writtenObjects.set(key, -1);
+      }
+    }
+  }
+
+  const id = outlineModel(request, entries);
+  return '$W' + id.toString(16);
+}
+
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
+let modelRoot = false;
+
+function resolveModelToJSON(request, parent, key, value) {
+
+
+  switch (value) {
+    case REACT_ELEMENT_TYPE:
+      return '$';
+  }
+
+
+  while (typeof value === 'object' && value !== null && (value.$$typeof === REACT_ELEMENT_TYPE || value.$$typeof === REACT_LAZY_TYPE)) {
+
+    try {
+      switch (value.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          {
+            const writtenObjects = request.writtenObjects;
+            const existingId = writtenObjects.get(value);
+
+            if (existingId !== undefined) {
+              if (existingId === -1) {
+                // Seen but not yet outlined.
+                const newId = outlineModel(request, value);
+                return serializeByValueID(newId);
+              } else if (modelRoot === value) {
+                // This is the ID we're currently emitting so we need to write it
+                // once but if we discover it again, we refer to it by id.
+                modelRoot = null;
+              } else {
+                // We've already emitted this as an outlined object, so we can
+                // just refer to that by its existing ID.
+                return serializeByValueID(existingId);
+              }
+            } else {
+              // This is the first time we've seen this object. We may never see it again
+              // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+              writtenObjects.set(value, -1);
+            } // TODO: Concatenate keys of parents onto children.
+
+
+            const element = value; // Attempt to render the Server Component.
+
+            value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, null);
+            break;
+          }
+
+        case REACT_LAZY_TYPE:
+          {
+            const payload = value._payload;
+            const init = value._init;
+            value = init(payload);
+            break;
+          }
+      }
+    } catch (thrownValue) {
+      const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+      // reasons, the rest of the Suspense implementation expects the thrown
+      // value to be a thenable, because before `use` existed that was the
+      // (unstable) API for suspending. This implementation detail can change
+      // later, once we deprecate the old API in favor of `use`.
+      getSuspendedThenable() : thrownValue;
+
+      if (typeof x === 'object' && x !== null) {
+        // $FlowFixMe[method-unbinding]
+        if (typeof x.then === 'function') {
+          // Something suspended, we'll need to create a new task and resolve it later.
+          request.pendingChunks++;
+          const newTask = createTask(request, value, getActiveContext(), request.abortableTasks);
+          const ping = newTask.ping;
+          x.then(ping, ping);
+          newTask.thenableState = getThenableStateAfterSuspending();
+          return serializeLazyID(newTask.id);
+        }
+      } // Something errored. We'll still send everything we have up until this point.
+      // We'll replace this element with a lazy reference that throws on the client
+      // once it gets rendered.
+
+
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+      const digest = logRecoverableError(request, x);
+      emitErrorChunk(request, errorId, digest);
+      return serializeLazyID(errorId);
+    }
+  }
+
+  if (value === null) {
+    return null;
+  }
+
+  if (typeof value === 'object') {
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    const writtenObjects = request.writtenObjects;
+    const existingId = writtenObjects.get(value); // $FlowFixMe[method-unbinding]
+
+    if (typeof value.then === 'function') {
+      if (existingId !== undefined) {
+        if (modelRoot === value) {
+          // This is the ID we're currently emitting so we need to write it
+          // once but if we discover it again, we refer to it by id.
+          modelRoot = null;
+        } else {
+          // We've seen this promise before, so we can just refer to the same result.
+          return serializePromiseID(existingId);
+        }
+      } // We assume that any object with a .then property is a "Thenable" type,
+      // or a Promise type. Either of which can be represented by a Promise.
+
+
+      const promiseId = serializeThenable(request, value);
+      writtenObjects.set(value, promiseId);
+      return serializePromiseID(promiseId);
+    }
+
+    if (existingId !== undefined) {
+      if (existingId === -1) {
+        // Seen but not yet outlined.
+        const newId = outlineModel(request, value);
+        return serializeByValueID(newId);
+      } else if (modelRoot === value) {
+        // This is the ID we're currently emitting so we need to write it
+        // once but if we discover it again, we refer to it by id.
+        modelRoot = null;
+      } else {
+        // We've already emitted this as an outlined object, so we can
+        // just refer to that by its existing ID.
+        return serializeByValueID(existingId);
+      }
+    } else {
+      // This is the first time we've seen this object. We may never see it again
+      // so we'll inline it. Mark it as seen. If we see it again, we'll outline.
+      writtenObjects.set(value, -1);
+    }
+
+    if (isArray(value)) {
+      // $FlowFixMe[incompatible-return]
+      return value;
+    }
+
+    if (value instanceof Map) {
+      return serializeMap(request, value);
+    }
+
+    if (value instanceof Set) {
+      return serializeSet(request, value);
+    }
+
+    const iteratorFn = getIteratorFn(value);
+
+    if (iteratorFn) {
+      return Array.from(value);
+    } // Verify that this is a simple plain object.
+
+
+    const proto = getPrototypeOf(value);
+
+    if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
+      throw new Error('Only plain objects, and a few built-ins, can be passed to Client Components ' + 'from Server Components. Classes or null prototypes are not supported.');
+    }
+
+
+    return value;
+  }
+
+  if (typeof value === 'string') {
+
+
+    if (value[value.length - 1] === 'Z') {
+      // Possibly a Date, whose toJSON automatically calls toISOString
+      // $FlowFixMe[incompatible-use]
+      const originalValue = parent[key];
+
+      if (originalValue instanceof Date) {
+        return serializeDateFromDateJSON(value);
+      }
+    }
+
+    if (value.length >= 1024) {
+      // For large strings, we encode them outside the JSON payload so that we
+      // don't have to double encode and double parse the strings. This can also
+      // be more compact in case the string has a lot of escaped characters.
+      return serializeLargeTextString(request, value);
+    }
+
+    return escapeStringValue(value);
+  }
+
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  if (typeof value === 'number') {
+    return serializeNumber(value);
+  }
+
+  if (typeof value === 'undefined') {
+    return serializeUndefined();
+  }
+
+  if (typeof value === 'function') {
+
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, key, value);
+    }
+
+    if (isServerReference(value)) {
+      return serializeServerReference(request, parent, key, value);
+    }
+
+    if (/^on[A-Z]/.test(key)) {
+      throw new Error('Event handlers cannot be passed to Client Component props.' + describeObjectForErrorMessage(parent, key) + '\nIf you need interactivity, consider converting part of this to a Client Component.');
+    } else {
+      throw new Error('Functions cannot be passed directly to Client Components ' + 'unless you explicitly expose it by marking it with "use server".' + describeObjectForErrorMessage(parent, key));
+    }
+  }
+
+  if (typeof value === 'symbol') {
+    const writtenSymbols = request.writtenSymbols;
+    const existingId = writtenSymbols.get(value);
+
+    if (existingId !== undefined) {
+      return serializeByValueID(existingId);
+    } // $FlowFixMe[incompatible-type] `description` might be undefined
+
+
+    const name = value.description;
+
+    if (Symbol.for(name) !== value) {
+      throw new Error('Only global symbols received from Symbol.for(...) can be passed to Client Components. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+      value.description + ") cannot be found among global symbols.") + describeObjectForErrorMessage(parent, key));
+    }
+
+    request.pendingChunks++;
+    const symbolId = request.nextChunkId++;
+    emitSymbolChunk(request, symbolId, name);
+    writtenSymbols.set(value, symbolId);
+    return serializeByValueID(symbolId);
+  }
+
+  if (typeof value === 'bigint') {
+
+    return serializeBigInt(value);
+  }
+
+  throw new Error("Type " + typeof value + " is not supported in Client Component props." + describeObjectForErrorMessage(parent, key));
+}
+
+function logPostpone(request, reason) {
+  const onPostpone = request.onPostpone;
+  onPostpone(reason);
+}
+
+function logRecoverableError(request, error) {
+  const onError = request.onError;
+  const errorDigest = onError(error);
+
+  if (errorDigest != null && typeof errorDigest !== 'string') {
+    // eslint-disable-next-line react-internal/prod-error-codes
+    throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
+  }
+
+  return errorDigest || '';
+}
+
+function fatalError(request, error) {
+
+
+  if (request.destination !== null) {
+    request.status = CLOSED;
+    closeWithError(request.destination, error);
+  } else {
+    request.status = CLOSING;
+    request.fatalError = error;
+  }
+}
+
+function emitPostponeChunk(request, id, postponeInstance) {
+  let row;
+
+  {
+    // No reason included in prod.
+    row = serializeRowHeader('P', id) + '\n';
+  }
+
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitErrorChunk(request, id, digest, error) {
+  let errorInfo;
+
+  {
+    errorInfo = {
+      digest
+    };
+  }
+
+  const row = serializeRowHeader('E', id) + stringify(errorInfo) + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function emitImportChunk(request, id, clientReferenceMetadata) {
+  // $FlowFixMe[incompatible-type] stringify can return null
+  const json = stringify(clientReferenceMetadata);
+  const row = serializeRowHeader('I', id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitHintChunk(request, code, model) {
+  const json = stringify(model);
+  const id = request.nextChunkId++;
+  const row = serializeRowHeader('H' + code, id) + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedHintChunks.push(processedChunk);
+}
+
+function emitSymbolChunk(request, id, name) {
+  const symbolReference = serializeSymbolReference(name);
+  const processedChunk = encodeReferenceChunk(request, id, symbolReference);
+  request.completedImportChunks.push(processedChunk);
+}
+
+function emitModelChunk(request, id, model) {
+  // Track the root so we know that we have to emit this object even though it
+  // already has an ID. This is needed because we might see this object twice
+  // in the same toJSON if it is cyclic.
+  modelRoot = model; // $FlowFixMe[incompatible-type] stringify can return null
+
+  const json = stringify(model, request.toJSON);
+  const row = id.toString(16) + ':' + json + '\n';
+  const processedChunk = stringToChunk(row);
+  request.completedRegularChunks.push(processedChunk);
+}
+
+function retryTask(request, task) {
+  if (task.status !== PENDING$1) {
+    // We completed this by other means before we had a chance to retry it.
+    return;
+  }
+
+  switchContext(task.context);
+
+  try {
+    let value = task.model;
+
+    if (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+      request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+      const element = value; // When retrying a component, reuse the thenableState from the
+      // previous attempt.
+
+      const prevThenableState = task.thenableState; // Attempt to render the Server Component.
+      // Doing this here lets us reuse this same task if the next component
+      // also suspends.
+
+      task.model = value;
+      value = attemptResolveElement(request, element.type, element.key, element.ref, element.props, prevThenableState); // Successfully finished this component. We're going to keep rendering
+      // using the same task, but we reset its thenable state before continuing.
+
+      task.thenableState = null; // Keep rendering and reuse the same task. This inner loop is separate
+      // from the render above because we don't need to reset the thenable state
+      // until the next time something suspends and retries.
+
+      while (typeof value === 'object' && value !== null && value.$$typeof === REACT_ELEMENT_TYPE) {
+        request.writtenObjects.set(value, task.id); // TODO: Concatenate keys of parents onto children.
+
+        const nextElement = value;
+        task.model = value;
+        value = attemptResolveElement(request, nextElement.type, nextElement.key, nextElement.ref, nextElement.props, null);
+      }
+    } // Track that this object is outlined and has an id.
+
+
+    if (typeof value === 'object' && value !== null) {
+      request.writtenObjects.set(value, task.id);
+    }
+
+    emitModelChunk(request, task.id, value);
+    request.abortableTasks.delete(task);
+    task.status = COMPLETED;
+  } catch (thrownValue) {
+    const x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown
+    // value to be a thenable, because before `use` existed that was the
+    // (unstable) API for suspending. This implementation detail can change
+    // later, once we deprecate the old API in favor of `use`.
+    getSuspendedThenable() : thrownValue;
+
+    if (typeof x === 'object' && x !== null) {
+      // $FlowFixMe[method-unbinding]
+      if (typeof x.then === 'function') {
+        // Something suspended again, let's pick it back up later.
+        const ping = task.ping;
+        x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
+        return;
+      }
+    }
+
+    request.abortableTasks.delete(task);
+    task.status = ERRORED$1;
+    const digest = logRecoverableError(request, x);
+    emitErrorChunk(request, task.id, digest);
+  }
+}
+
+function performWork(request) {
+  const prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = HooksDispatcher;
+  const prevRequest = currentRequest;
+  currentRequest = request;
+  prepareToUseHooksForRequest(request);
+
+  try {
+    const pingedTasks = request.pingedTasks;
+    request.pingedTasks = [];
+
+    for (let i = 0; i < pingedTasks.length; i++) {
+      const task = pingedTasks[i];
+      retryTask(request, task);
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  } finally {
+    ReactCurrentDispatcher.current = prevDispatcher;
+    resetHooksForRequest();
+    currentRequest = prevRequest;
+  }
+}
+
+function abortTask(task, request, errorId) {
+  task.status = ABORTED; // Instead of emitting an error per task.id, we emit a model that only
+  // has a single value referencing the error.
+
+  const ref = serializeByValueID(errorId);
+  const processedChunk = encodeReferenceChunk(request, task.id, ref);
+  request.completedErrorChunks.push(processedChunk);
+}
+
+function flushCompletedChunks(request, destination) {
+  beginWriting();
+
+  try {
+    // We emit module chunks first in the stream so that
+    // they can be preloaded as early as possible.
+    const importsChunks = request.completedImportChunks;
+    let i = 0;
+
+    for (; i < importsChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = importsChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    importsChunks.splice(0, i); // Next comes hints.
+
+    const hintChunks = request.completedHintChunks;
+    i = 0;
+
+    for (; i < hintChunks.length; i++) {
+      const chunk = hintChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    hintChunks.splice(0, i); // Next comes model data.
+
+    const regularChunks = request.completedRegularChunks;
+    i = 0;
+
+    for (; i < regularChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = regularChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    regularChunks.splice(0, i); // Finally, errors are sent. The idea is that it's ok to delay
+    // any error messages and prioritize display of other parts of
+    // the page.
+
+    const errorChunks = request.completedErrorChunks;
+    i = 0;
+
+    for (; i < errorChunks.length; i++) {
+      request.pendingChunks--;
+      const chunk = errorChunks[i];
+      const keepWriting = writeChunkAndReturn(destination, chunk);
+
+      if (!keepWriting) {
+        request.destination = null;
+        i++;
+        break;
+      }
+    }
+
+    errorChunks.splice(0, i);
+  } finally {
+    request.flushScheduled = false;
+    completeWriting(destination);
+  }
+
+  flushBuffered(destination);
+
+  if (request.pendingChunks === 0) {
+
+    close$1(destination);
+  }
+}
+
+function startWork(request) {
+  request.flushScheduled = request.destination !== null;
+
+  {
+    scheduleWork(() => requestStorage.run(request, performWork, request));
+  }
+}
+
+function enqueueFlush(request) {
+  if (request.flushScheduled === false && // If there are pinged tasks we are going to flush anyway after work completes
+  request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
+  // happen when we start flowing again
+  request.destination !== null) {
+    const destination = request.destination;
+    request.flushScheduled = true;
+    scheduleWork(() => flushCompletedChunks(request, destination));
+  }
+}
+
+function startFlowing(request, destination) {
+  if (request.status === CLOSING) {
+    request.status = CLOSED;
+    closeWithError(destination, request.fatalError);
+    return;
+  }
+
+  if (request.status === CLOSED) {
+    return;
+  }
+
+  if (request.destination !== null) {
+    // We're already flowing.
+    return;
+  }
+
+  request.destination = destination;
+
+  try {
+    flushCompletedChunks(request, destination);
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+function stopFlowing(request) {
+  request.destination = null;
+} // This is called to early terminate a request. It creates an error at all pending tasks.
+
+function abort(request, reason) {
+  try {
+    const abortableTasks = request.abortableTasks;
+
+    if (abortableTasks.size > 0) {
+      // We have tasks to abort. We'll emit one error row and then emit a reference
+      // to that row from every row that's still remaining.
+      request.pendingChunks++;
+      const errorId = request.nextChunkId++;
+
+      if (enablePostpone && typeof reason === 'object' && reason !== null && reason.$$typeof === REACT_POSTPONE_TYPE) ; else {
+        const error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+        const digest = logRecoverableError(request, error);
+        emitErrorChunk(request, errorId, digest, error);
+      }
+
+      abortableTasks.forEach(task => abortTask(task, request, errorId));
+      abortableTasks.clear();
+    }
+
+    if (request.destination !== null) {
+      flushCompletedChunks(request, request.destination);
+    }
+  } catch (error) {
+    logRecoverableError(request, error);
+    fatalError(request, error);
+  }
+}
+
+function importServerContexts(contexts) {
+
+  return rootContextSnapshot;
+}
+
+function resolveServerReference(bundlerConfig, id) {
+  const idx = id.lastIndexOf('#');
+  const specifier = id.slice(0, idx);
+  const name = id.slice(idx + 1);
+  return {
+    specifier,
+    name
+  };
+}
+const asyncModuleCache = new Map();
+function preloadModule(metadata) {
+  const existingPromise = asyncModuleCache.get(metadata.specifier);
+
+  if (existingPromise) {
+    if (existingPromise.status === 'fulfilled') {
+      return null;
+    }
+
+    return existingPromise;
+  } else {
+    // $FlowFixMe[unsupported-syntax]
+    let modulePromise = import(metadata.specifier);
+
+    if (metadata.async) {
+      // If the module is async, it must have been a CJS module.
+      // CJS modules are accessed through the default export in
+      // Node.js so we have to get the default export to get the
+      // full module exports.
+      modulePromise = modulePromise.then(function (value) {
+        return value.default;
+      });
+    }
+
+    modulePromise.then(value => {
+      const fulfilledThenable = modulePromise;
+      fulfilledThenable.status = 'fulfilled';
+      fulfilledThenable.value = value;
+    }, reason => {
+      const rejectedThenable = modulePromise;
+      rejectedThenable.status = 'rejected';
+      rejectedThenable.reason = reason;
+    });
+    asyncModuleCache.set(metadata.specifier, modulePromise);
+    return modulePromise;
+  }
+}
+function requireModule(metadata) {
+  let moduleExports; // We assume that preloadModule has been called before, which
+  // should have added something to the module cache.
+
+  const promise = asyncModuleCache.get(metadata.specifier);
+
+  if (promise.status === 'fulfilled') {
+    moduleExports = promise.value;
+  } else {
+    throw promise.reason;
+  }
+
+  if (metadata.name === '*') {
+    // This is a placeholder value that represents that the caller imported this
+    // as a CommonJS module as is.
+    return moduleExports;
+  }
+
+  if (metadata.name === '') {
+    // This is a placeholder value that represents that the caller accessed the
+    // default property of this if it was an ESM interop module.
+    return moduleExports.default;
+  }
+
+  return moduleExports[metadata.name];
+}
+
+// The server acts as a Client of itself when resolving Server References.
+const PENDING = 'pending';
+const BLOCKED = 'blocked';
+const RESOLVED_MODEL = 'resolved_model';
+const INITIALIZED = 'fulfilled';
+const ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
+
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
+
+
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
+
+Chunk.prototype.then = function (resolve, reject) {
+  const chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
+
+
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
+
+        chunk.value.push(resolve);
+      }
+
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
+
+        chunk.reason.push(reject);
+      }
+
+      break;
+
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
+
+function getRoot(response) {
+  const chunk = getChunk(response, 0);
+  return chunk;
+}
+
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (let i = 0; i < listeners.length; i++) {
+    const listener = listeners[i];
+    listener(value);
+  }
+}
+
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
+
+    case PENDING:
+    case BLOCKED:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
+
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
+
+      break;
+  }
+}
+
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const listeners = chunk.reason;
+  const erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
+
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
+
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
+
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
+
+  const resolveListeners = chunk.value;
+  const rejectListeners = chunk.reason;
+  const resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
+
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
+
+function bindArgs$1(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference$1(response, id, bound, parentChunk, parentObject, key) {
+  const serverReference = resolveServerReference(response._bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+  let promise;
+
+  if (bound) {
+    promise = Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs$1(requireModule(serverReference), args);
+    });
+  } else {
+    if (preloadPromise) {
+      promise = Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+    } else {
+      // Synchronously available
+      return requireModule(serverReference);
+    }
+  }
+
+  promise.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk)); // We need a placeholder value that will be replaced later.
+
+  return null;
+}
+
+let initializingChunk = null;
+let initializingChunkBlockedModel = null;
+
+function initializeModelChunk(chunk) {
+  const prevChunk = initializingChunk;
+  const prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
+
+  try {
+    const value = JSON.parse(chunk.value, chunk._response._fromJSON);
+
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
+
+      const blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+    }
+  } catch (error) {
+    const erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
+
+
+function reportGlobalError(response, error) {
+  response._chunks.forEach(chunk => {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
+
+function getChunk(response, id) {
+  const chunks = response._chunks;
+  let chunk = chunks.get(id);
+
+  if (!chunk) {
+    const prefix = response._prefix;
+    const key = prefix + id; // Check if we have this field in the backing store already.
+
+    const backingEntry = response._formData.get(key);
+
+    if (backingEntry != null) {
+      // We assume that this is a string entry for now.
+      chunk = createResolvedModelChunk(response, backingEntry);
+    } else {
+      // We're still waiting on this entry to stream in.
+      chunk = createPendingChunk(response);
+    }
+
+    chunks.set(id, chunk);
+  }
+
+  return chunk;
+}
+
+function createModelResolver(chunk, parentObject, key) {
+  let blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+    blocked.deps++;
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: 1,
+      value: null
+    };
+  }
+
+  return value => {
+    parentObject[key] = value;
+    blocked.deps--;
+
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
+
+      const resolveListeners = chunk.value;
+      const initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
+}
+
+function createModelReject(chunk) {
+  return error => triggerErrorOnChunk(chunk, error);
+}
+
+function getOutlinedModel(response, id) {
+  const chunk = getChunk(response, id);
+
+  if (chunk.status === RESOLVED_MODEL) {
+    initializeModelChunk(chunk);
+  }
+
+  if (chunk.status !== INITIALIZED) {
+    // We know that this is emitted earlier so otherwise it's an error.
+    throw chunk.reason;
+  }
+
+  return chunk.value;
+}
+
+function parseModelString(response, parentObject, key, value) {
+  if (value[0] === '$') {
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
+
+      case '@':
+        {
+          // Promise
+          const id = parseInt(value.slice(2), 16);
+          const chunk = getChunk(response, id);
+          return chunk;
+        }
+
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
+
+      case 'F':
+        {
+          // Server Reference
+          const id = parseInt(value.slice(2), 16); // TODO: Just encode this in the reference inline instead of as a model.
+
+          const metaData = getOutlinedModel(response, id);
+          return loadServerReference$1(response, metaData.id, metaData.bound, initializingChunk, parentObject, key);
+        }
+
+      case 'Q':
+        {
+          // Map
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Map(data);
+        }
+
+      case 'W':
+        {
+          // Set
+          const id = parseInt(value.slice(2), 16);
+          const data = getOutlinedModel(response, id);
+          return new Set(data);
+        }
+
+      case 'K':
+        {
+          // FormData
+          const stringId = value.slice(2);
+          const formPrefix = response._prefix + stringId + '_';
+          const data = new FormData();
+          const backingFormData = response._formData; // We assume that the reference to FormData always comes after each
+          // entry that it references so we can assume they all exist in the
+          // backing store already.
+          // $FlowFixMe[prop-missing] FormData has forEach on it.
+
+          backingFormData.forEach((entry, entryKey) => {
+            if (entryKey.startsWith(formPrefix)) {
+              data.append(entryKey.slice(formPrefix.length), entry);
+            }
+          });
+          return data;
+        }
+
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
+
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
+
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
+
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
+
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
+        }
+
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          const id = parseInt(value.slice(1), 16);
+          const chunk = getChunk(response, id);
+
+          switch (chunk.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(chunk);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (chunk.status) {
+            case INITIALIZED:
+              return chunk.value;
+
+            case PENDING:
+            case BLOCKED:
+              const parentChunk = initializingChunk;
+              chunk.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk));
+              return null;
+
+            default:
+              throw chunk.reason;
+          }
+        }
+    }
+  }
+
+  return value;
+}
+
+function createResponse(bundlerConfig, formFieldPrefix) {
+  let backingFormData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new FormData();
+  const chunks = new Map();
+  const response = {
+    _bundlerConfig: bundlerConfig,
+    _prefix: formFieldPrefix,
+    _formData: backingFormData,
+    _chunks: chunks,
+    _fromJSON: function (key, value) {
+      if (typeof value === 'string') {
+        // We can't use .bind here because we need the "this" value.
+        return parseModelString(response, this, key, value);
+      }
+
+      return value;
+    }
+  };
+  return response;
+}
+function resolveField(response, key, value) {
+  // Add this field to the backing store.
+  response._formData.append(key, value);
+
+  const prefix = response._prefix;
+
+  if (key.startsWith(prefix)) {
+    const chunks = response._chunks;
+    const id = +key.slice(prefix.length);
+    const chunk = chunks.get(id);
+
+    if (chunk) {
+      // We were waiting on this key so now we can resolve it.
+      resolveModelChunk(chunk, value);
+    }
+  }
+}
+function resolveFileInfo(response, key, filename, mime) {
+  return {
+    chunks: [],
+    filename,
+    mime
+  };
+}
+function resolveFileChunk(response, handle, chunk) {
+  handle.chunks.push(chunk);
+}
+function resolveFileComplete(response, key, handle) {
+  // Add this file to the backing store.
+  // Node.js doesn't expose a global File constructor so we need to use
+  // the append() form that takes the file name as the third argument,
+  // to create a File object.
+  const blob = new Blob(handle.chunks, {
+    type: handle.mime
+  });
+
+  response._formData.append(key, blob, handle.filename);
+}
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
+
+function bindArgs(fn, args) {
+  return fn.bind.apply(fn, [null].concat(args));
+}
+
+function loadServerReference(bundlerConfig, id, bound) {
+  const serverReference = resolveServerReference(bundlerConfig, id); // We expect most servers to not really need this because you'd just have all
+  // the relevant modules already loaded but it allows for lazy loading of code
+  // if needed.
+
+  const preloadPromise = preloadModule(serverReference);
+
+  if (bound) {
+    return Promise.all([bound, preloadPromise]).then((_ref) => {
+      let args = _ref[0];
+      return bindArgs(requireModule(serverReference), args);
+    });
+  } else if (preloadPromise) {
+    return Promise.resolve(preloadPromise).then(() => requireModule(serverReference));
+  } else {
+    // Synchronously available
+    return Promise.resolve(requireModule(serverReference));
+  }
+}
+
+function decodeBoundActionMetaData(body, serverManifest, formFieldPrefix) {
+  // The data for this reference is encoded in multiple fields under this prefix.
+  const actionResponse = createResponse(serverManifest, formFieldPrefix, body);
+  close(actionResponse);
+  const refPromise = getRoot(actionResponse); // Force it to initialize
+  // $FlowFixMe
+
+  refPromise.then(() => {});
+
+  if (refPromise.status !== 'fulfilled') {
+    // $FlowFixMe
+    throw refPromise.reason;
+  }
+
+  return refPromise.value;
+}
+
+function decodeAction(body, serverManifest) {
+  // We're going to create a new formData object that holds all the fields except
+  // the implementation details of the action data.
+  const formData = new FormData();
+  let action = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (!key.startsWith('$ACTION_')) {
+      formData.append(key, value);
+      return;
+    } // Later actions may override earlier actions if a button is used to override the default
+    // form action.
+
+
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      const metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+      action = loadServerReference(serverManifest, metaData.id, metaData.bound);
+      return;
+    }
+
+    if (key.startsWith('$ACTION_ID_')) {
+      const id = key.slice(11);
+      action = loadServerReference(serverManifest, id, null);
+      return;
+    }
+  });
+
+  if (action === null) {
+    return null;
+  } // Return the action with the remaining FormData bound to the first argument.
+
+
+  return action.then(fn => fn.bind(null, formData));
+}
+function decodeFormState(actionResult, body, serverManifest) {
+  const keyPath = body.get('$ACTION_KEY');
+
+  if (typeof keyPath !== 'string') {
+    // This form submission did not include any form state.
+    return Promise.resolve(null);
+  } // Search through the form data object to get the reference id and the number
+  // of bound arguments. This repeats some of the work done in decodeAction.
+
+
+  let metaData = null; // $FlowFixMe[prop-missing]
+
+  body.forEach((value, key) => {
+    if (key.startsWith('$ACTION_REF_')) {
+      const formFieldPrefix = '$ACTION_' + key.slice(12) + ':';
+      metaData = decodeBoundActionMetaData(body, serverManifest, formFieldPrefix);
+    } // We don't check for the simple $ACTION_ID_ case because form state actions
+    // are always bound to the state argument.
+
+  });
+
+  if (metaData === null) {
+    // Should be unreachable.
+    return Promise.resolve(null);
+  }
+
+  const referenceId = metaData.id;
+  return Promise.resolve(metaData.bound).then(bound => {
+    if (bound === null) {
+      // Should be unreachable because form state actions are always bound to the
+      // state argument.
+      return null;
+    } // The form action dispatch method is always bound to the initial state.
+    // But when comparing signatures, we compare to the original unbound action.
+    // Subtract one from the arity to account for this.
+
+
+    const boundArity = bound.length - 1;
+    return [actionResult, keyPath, referenceId, boundArity];
+  });
+}
+
+function createDrainHandler(destination, request) {
+  return () => startFlowing(request, destination);
+}
+
+function createCancelHandler(request, reason) {
+  return () => {
+    stopFlowing(request); // eslint-disable-next-line react-internal/prod-error-codes
+
+    abort(request, new Error(reason));
+  };
+}
+
+function renderToPipeableStream(model, webpackMap, options) {
+  const request = createRequest(model, webpackMap, options ? options.onError : undefined, options ? options.context : undefined, options ? options.identifierPrefix : undefined, options ? options.onPostpone : undefined);
+  let hasStartedFlowing = false;
+  startWork(request);
+  return {
+    pipe(destination) {
+      if (hasStartedFlowing) {
+        throw new Error('React currently only supports piping to one writable stream.');
+      }
+
+      hasStartedFlowing = true;
+      startFlowing(request, destination);
+      destination.on('drain', createDrainHandler(destination, request));
+      destination.on('error', createCancelHandler(request, 'The destination stream errored while writing data.'));
+      destination.on('close', createCancelHandler(request, 'The destination stream closed early.'));
+      return destination;
+    },
+
+    abort(reason) {
+      abort(request, reason);
+    }
+
+  };
+}
+
+function decodeReplyFromBusboy(busboyStream, webpackMap) {
+  const response = createResponse(webpackMap, '');
+  let pendingFiles = 0;
+  const queuedFields = [];
+  busboyStream.on('field', (name, value) => {
+    if (pendingFiles > 0) {
+      // Because the 'end' event fires two microtasks after the next 'field'
+      // we would resolve files and fields out of order. To handle this properly
+      // we queue any fields we receive until the previous file is done.
+      queuedFields.push(name, value);
+    } else {
+      resolveField(response, name, value);
+    }
+  });
+  busboyStream.on('file', (name, value, _ref) => {
+    let filename = _ref.filename,
+        encoding = _ref.encoding,
+        mimeType = _ref.mimeType;
+
+    if (encoding.toLowerCase() === 'base64') {
+      throw new Error("React doesn't accept base64 encoded file uploads because we don't expect " + "form data passed from a browser to ever encode data that way. If that's " + 'the wrong assumption, we can easily fix it.');
+    }
+
+    pendingFiles++;
+    const file = resolveFileInfo(response, name, filename, mimeType);
+    value.on('data', chunk => {
+      resolveFileChunk(response, file, chunk);
+    });
+    value.on('end', () => {
+      resolveFileComplete(response, name, file);
+      pendingFiles--;
+
+      if (pendingFiles === 0) {
+        // Release any queued fields
+        for (let i = 0; i < queuedFields.length; i += 2) {
+          resolveField(response, queuedFields[i], queuedFields[i + 1]);
+        }
+
+        queuedFields.length = 0;
+      }
+    });
+  });
+  busboyStream.on('finish', () => {
+    close(response);
+  });
+  busboyStream.on('error', err => {
+    reportGlobalError(response, // $FlowFixMe[incompatible-call] types Error and mixed are incompatible
+    err);
+  });
+  return getRoot(response);
+}
+
+function decodeReply(body, webpackMap) {
+  if (typeof body === 'string') {
+    const form = new FormData();
+    form.append('0', body);
+    body = form;
+  }
+
+  const response = createResponse(webpackMap, '', body);
+  const root = getRoot(response);
+  close(response);
+  return root;
+}
+
+exports.createClientModuleProxy = createClientModuleProxy;
+exports.decodeAction = decodeAction;
+exports.decodeFormState = decodeFormState;
+exports.decodeReply = decodeReply;
+exports.decodeReplyFromBusboy = decodeReplyFromBusboy;
+exports.registerClientReference = registerClientReference;
+exports.registerServerReference = registerServerReference;
+exports.renderToPipeableStream = renderToPipeableStream;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.node.unbundled.production.min.js b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.node.unbundled.production.min.js
index 55ede59760aba..cf55ed4954c05 100644
--- a/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.node.unbundled.production.min.js
+++ b/packages/next/src/compiled/react-server-dom-webpack/cjs/react-server-dom-webpack-server.node.unbundled.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react-server-dom-webpack-server.node.unbundled.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-server-dom-webpack-server.node.unbundled.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var ba=require("util");require("crypto");var ca=require("async_hooks"),da=require("react"),ea=require("react-dom"),l=null,m=0,p=!0;function q(a,b){a=a.write(b);p=p&&a}
 function r(a,b){if("string"===typeof b){if(0!==b.length)if(2048<3*b.length)0<m&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=0),q(a,fa.encode(b));else{var d=l;0<m&&(d=l.subarray(m));d=fa.encodeInto(b,d);var c=d.read;m+=d.written;c<b.length&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=fa.encodeInto(b.slice(c),l).written);2048===m&&(q(a,l),l=new Uint8Array(2048),m=0)}}else 0!==b.byteLength&&(2048<b.byteLength?(0<m&&(q(a,l.subarray(0,m)),l=new Uint8Array(2048),m=0),q(a,b)):(d=l.length-m,d<b.byteLength&&
 (0===d?q(a,l):(l.set(b.subarray(0,d),m),m+=d,q(a,l),b=b.subarray(d)),l=new Uint8Array(2048),m=0),l.set(b,m),m+=b.byteLength,2048===m&&(q(a,l),l=new Uint8Array(2048),m=0)));return p}var fa=new ba.TextEncoder,t=Symbol.for("react.client.reference"),v=Symbol.for("react.server.reference");function w(a,b,d){return Object.defineProperties(a,{$$typeof:{value:t},$$id:{value:b},$$async:{value:d}})}var ha=Function.prototype.bind,ia=Array.prototype.slice;
@@ -77,3 +77,5 @@ exports.decodeFormState=function(a,b,d){var c=b.get("$ACTION_KEY");if("string"!=
 exports.decodeReplyFromBusboy=function(a,b){var d=Jb(b,""),c=0,e=[];a.on("field",function(f,g){0<c?e.push(f,g):Kb(d,f,g)});a.on("file",function(f,g,k){var h=k.filename,n=k.mimeType;if("base64"===k.encoding.toLowerCase())throw Error("React doesn't accept base64 encoded file uploads because we don't expect form data passed from a browser to ever encode data that way. If that's the wrong assumption, we can easily fix it.");c++;var z=[];g.on("data",function(u){z.push(u)});g.on("end",function(){var u=
 new Blob(z,{type:n});d._formData.append(f,u,h);c--;if(0===c){for(u=0;u<e.length;u+=2)Kb(d,e[u],e[u+1]);e.length=0}})});a.on("finish",function(){Lb(d)});a.on("error",function(f){Gb(d,f)});return Z(d,0)};exports.registerClientReference=function(a,b,d){return w(a,b+"#"+d,!1)};exports.registerServerReference=function(a,b,d){return Object.defineProperties(a,{$$typeof:{value:v},$$id:{value:null===d?b:b+"#"+d},$$bound:{value:null},bind:{value:ja}})};
 exports.renderToPipeableStream=function(a,b,d){var c=hb(a,b,d?d.onError:void 0,d?d.context:void 0,d?d.identifierPrefix:void 0,d?d.onPostpone:void 0),e=!1;tb(c);return{pipe:function(f){if(e)throw Error("React currently only supports piping to one writable stream.");e=!0;ub(c,f);f.on("drain",Rb(f,c));f.on("error",Sb(c,"The destination stream errored while writing data."));f.on("close",Sb(c,"The destination stream closed early."));return f},abort:function(f){vb(c,f)}}};
+
+//# sourceMappingURL=react-server-dom-webpack-server.node.unbundled.production.min.js.map
diff --git a/packages/next/src/compiled/react-server-dom-webpack/package.json b/packages/next/src/compiled/react-server-dom-webpack/package.json
index 8c5c393a0d078..7d0287d2c2d71 100644
--- a/packages/next/src/compiled/react-server-dom-webpack/package.json
+++ b/packages/next/src/compiled/react-server-dom-webpack/package.json
@@ -47,8 +47,8 @@
     "loose-envify": "^1.1.0"
   },
   "peerDependencies": {
-    "react": "18.3.0-canary-2983249dd-20231107",
-    "react-dom": "18.3.0-canary-2983249dd-20231107",
+    "react": "18.3.0-canary-7508dcd5c-20231108",
+    "react-dom": "18.3.0-canary-7508dcd5c-20231108",
     "webpack": "^5.59.0"
   }
 }
\ No newline at end of file
diff --git a/packages/next/src/compiled/react/cjs/react-jsx-dev-runtime.development.js b/packages/next/src/compiled/react/cjs/react-jsx-dev-runtime.development.js
index ee92edad3be79..ca47d5c7f2735 100644
--- a/packages/next/src/compiled/react/cjs/react-jsx-dev-runtime.development.js
+++ b/packages/next/src/compiled/react/cjs/react-jsx-dev-runtime.development.js
@@ -350,6 +350,18 @@ var componentFrameCache;
   var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
   componentFrameCache = new PossiblyWeakMap();
 }
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
@@ -365,7 +377,6 @@ function describeNativeComponentFrame(fn, construct) {
     }
   }
 
-  var control;
   reentry = true;
   var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
 
@@ -379,81 +390,140 @@ function describeNativeComponentFrame(fn, construct) {
     ReactCurrentDispatcher.current = null;
     disableLogs();
   }
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
+
+
+  var RunInRootFrame = {
+    DetermineComponentFrameRoot: function () {
+      var control;
 
-  try {
-    // This should throw.
-    if (construct) {
-      // Something should be setting the props in the constructor.
-      var Fake = function () {
-        throw Error();
-      }; // $FlowFixMe[prop-missing]
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          var Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
+
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
 
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
 
-      Object.defineProperty(Fake.prototype, 'props', {
-        set: function () {
-          // We use a throwing setter instead of frozen or non-writable props
-          // because that won't throw in a non-strict mode function.
-          throw Error();
-        }
-      });
 
-      if (typeof Reflect === 'object' && Reflect.construct) {
-        // We construct a different control for this case to include any extra
-        // frames added by the construct call.
-        try {
-          Reflect.construct(Fake, []);
-        } catch (x) {
-          control = x;
-        }
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
 
-        Reflect.construct(fn, [], Fake);
-      } else {
-        try {
-          Fake.call();
-        } catch (x) {
-          control = x;
-        } // $FlowFixMe[prop-missing] found when upgrading Flow
 
+          var maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
 
-        fn.call(Fake.prototype);
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(function () {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
       }
-    } else {
-      try {
-        throw Error();
-      } catch (x) {
-        control = x;
-      } // TODO(luna): This will currently only throw if the function component
-      // tries to access React/ReactDOM/props. We should probably make this throw
-      // in simple components too
 
+      return [null, null];
+    }
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
 
-      var maybePromise = fn(); // If the function component returns a promise, it's likely an async
-      // component, which we don't yet support. Attach a noop catch handler to
-      // silence the error.
-      // TODO: Implement component stacks for async client components?
+  try {
+    var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
 
-      if (maybePromise && typeof maybePromise.catch === 'function') {
-        maybePromise.catch(function () {});
-      }
-    }
-  } catch (sample) {
-    // This is inlined manually because closure doesn't do it for us.
-    if (sample && control && typeof sample.stack === 'string') {
+    if (sampleStack && controlStack) {
       // This extracts the first frame from the sample that isn't also in the control.
       // Skipping one frame that we assume is the frame that calls the two.
-      var sampleLines = sample.stack.split('\n');
-      var controlLines = control.stack.split('\n');
-      var s = sampleLines.length - 1;
-      var c = controlLines.length - 1;
-
-      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
-        // We expect at least one stack frame to be shared.
-        // Typically this will be the root most one. However, stack frames may be
-        // cut off due to maximum stack limits. In this case, one maybe cut off
-        // earlier than the other. We assume that the sample is longer or the same
-        // and there for cut off earlier. So we should find the root most frame in
-        // the sample somewhere in the control.
-        c--;
+      var sampleLines = sampleStack.split('\n');
+      var controlLines = controlStack.split('\n');
+      var s = 0;
+      var c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
       }
 
       for (; s >= 1 && c >= 0; s--, c--) {
@@ -482,7 +552,7 @@ function describeNativeComponentFrame(fn, construct) {
                   _frame = _frame.replace('<anonymous>', fn.displayName);
                 }
 
-                {
+                if (true) {
                   if (typeof fn === 'function') {
                     componentFrameCache.set(fn, _frame);
                   }
diff --git a/packages/next/src/compiled/react/cjs/react-jsx-dev-runtime.production.js b/packages/next/src/compiled/react/cjs/react-jsx-dev-runtime.production.js
new file mode 100644
index 0000000000000..ac19aaf473d40
--- /dev/null
+++ b/packages/next/src/compiled/react/cjs/react-jsx-dev-runtime.production.js
@@ -0,0 +1,18 @@
+/**
+ * @license React
+ * react-jsx-dev-runtime.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+// ATTENTION
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+
+const jsxDEV = undefined;
+
+exports.Fragment = REACT_FRAGMENT_TYPE;
+exports.jsxDEV = jsxDEV;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react/cjs/react-jsx-dev-runtime.production.min.js b/packages/next/src/compiled/react/cjs/react-jsx-dev-runtime.production.min.js
index c242817c5c8dc..c2da84bbaa687 100644
--- a/packages/next/src/compiled/react/cjs/react-jsx-dev-runtime.production.min.js
+++ b/packages/next/src/compiled/react/cjs/react-jsx-dev-runtime.production.min.js
@@ -1,10 +1,12 @@
-/**
- * @license React
- * react-jsx-dev-runtime.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-jsx-dev-runtime.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var a=Symbol.for("react.fragment");exports.Fragment=a;exports.jsxDEV=void 0;
+
+//# sourceMappingURL=react-jsx-dev-runtime.production.min.js.map
diff --git a/packages/next/src/compiled/react/cjs/react-jsx-dev-runtime.profiling.js b/packages/next/src/compiled/react/cjs/react-jsx-dev-runtime.profiling.js
new file mode 100644
index 0000000000000..d26abc62ad2cb
--- /dev/null
+++ b/packages/next/src/compiled/react/cjs/react-jsx-dev-runtime.profiling.js
@@ -0,0 +1,18 @@
+/**
+ * @license React
+ * react-jsx-dev-runtime.profiling.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+// ATTENTION
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+
+const jsxDEV = undefined;
+
+exports.Fragment = REACT_FRAGMENT_TYPE;
+exports.jsxDEV = jsxDEV;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react/cjs/react-jsx-dev-runtime.profiling.min.js b/packages/next/src/compiled/react/cjs/react-jsx-dev-runtime.profiling.min.js
index aad106163bd89..2029bbb579bd7 100644
--- a/packages/next/src/compiled/react/cjs/react-jsx-dev-runtime.profiling.min.js
+++ b/packages/next/src/compiled/react/cjs/react-jsx-dev-runtime.profiling.min.js
@@ -1,10 +1,12 @@
-/**
- * @license React
- * react-jsx-dev-runtime.profiling.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-jsx-dev-runtime.profiling.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var a=Symbol.for("react.fragment");exports.Fragment=a;exports.jsxDEV=void 0;
+
+//# sourceMappingURL=react-jsx-dev-runtime.profiling.min.js.map
diff --git a/packages/next/src/compiled/react/cjs/react-jsx-runtime.development.js b/packages/next/src/compiled/react/cjs/react-jsx-runtime.development.js
index d6ce97ab26c0c..052a83f138e3f 100644
--- a/packages/next/src/compiled/react/cjs/react-jsx-runtime.development.js
+++ b/packages/next/src/compiled/react/cjs/react-jsx-runtime.development.js
@@ -350,6 +350,18 @@ var componentFrameCache;
   var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
   componentFrameCache = new PossiblyWeakMap();
 }
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
@@ -365,7 +377,6 @@ function describeNativeComponentFrame(fn, construct) {
     }
   }
 
-  var control;
   reentry = true;
   var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
 
@@ -379,81 +390,140 @@ function describeNativeComponentFrame(fn, construct) {
     ReactCurrentDispatcher.current = null;
     disableLogs();
   }
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
+
+
+  var RunInRootFrame = {
+    DetermineComponentFrameRoot: function () {
+      var control;
 
-  try {
-    // This should throw.
-    if (construct) {
-      // Something should be setting the props in the constructor.
-      var Fake = function () {
-        throw Error();
-      }; // $FlowFixMe[prop-missing]
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          var Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
+
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
 
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
 
-      Object.defineProperty(Fake.prototype, 'props', {
-        set: function () {
-          // We use a throwing setter instead of frozen or non-writable props
-          // because that won't throw in a non-strict mode function.
-          throw Error();
-        }
-      });
 
-      if (typeof Reflect === 'object' && Reflect.construct) {
-        // We construct a different control for this case to include any extra
-        // frames added by the construct call.
-        try {
-          Reflect.construct(Fake, []);
-        } catch (x) {
-          control = x;
-        }
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
 
-        Reflect.construct(fn, [], Fake);
-      } else {
-        try {
-          Fake.call();
-        } catch (x) {
-          control = x;
-        } // $FlowFixMe[prop-missing] found when upgrading Flow
 
+          var maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
 
-        fn.call(Fake.prototype);
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(function () {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
       }
-    } else {
-      try {
-        throw Error();
-      } catch (x) {
-        control = x;
-      } // TODO(luna): This will currently only throw if the function component
-      // tries to access React/ReactDOM/props. We should probably make this throw
-      // in simple components too
 
+      return [null, null];
+    }
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
 
-      var maybePromise = fn(); // If the function component returns a promise, it's likely an async
-      // component, which we don't yet support. Attach a noop catch handler to
-      // silence the error.
-      // TODO: Implement component stacks for async client components?
+  try {
+    var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
 
-      if (maybePromise && typeof maybePromise.catch === 'function') {
-        maybePromise.catch(function () {});
-      }
-    }
-  } catch (sample) {
-    // This is inlined manually because closure doesn't do it for us.
-    if (sample && control && typeof sample.stack === 'string') {
+    if (sampleStack && controlStack) {
       // This extracts the first frame from the sample that isn't also in the control.
       // Skipping one frame that we assume is the frame that calls the two.
-      var sampleLines = sample.stack.split('\n');
-      var controlLines = control.stack.split('\n');
-      var s = sampleLines.length - 1;
-      var c = controlLines.length - 1;
-
-      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
-        // We expect at least one stack frame to be shared.
-        // Typically this will be the root most one. However, stack frames may be
-        // cut off due to maximum stack limits. In this case, one maybe cut off
-        // earlier than the other. We assume that the sample is longer or the same
-        // and there for cut off earlier. So we should find the root most frame in
-        // the sample somewhere in the control.
-        c--;
+      var sampleLines = sampleStack.split('\n');
+      var controlLines = controlStack.split('\n');
+      var s = 0;
+      var c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
       }
 
       for (; s >= 1 && c >= 0; s--, c--) {
@@ -482,7 +552,7 @@ function describeNativeComponentFrame(fn, construct) {
                   _frame = _frame.replace('<anonymous>', fn.displayName);
                 }
 
-                {
+                if (true) {
                   if (typeof fn === 'function') {
                     componentFrameCache.set(fn, _frame);
                   }
diff --git a/packages/next/src/compiled/react/cjs/react-jsx-runtime.production.js b/packages/next/src/compiled/react/cjs/react-jsx-runtime.production.js
new file mode 100644
index 0000000000000..cb2f42adf4449
--- /dev/null
+++ b/packages/next/src/compiled/react/cjs/react-jsx-runtime.production.js
@@ -0,0 +1,142 @@
+/**
+ * @license React
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require("next/dist/compiled/react");
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+const ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
+const RESERVED_PROPS = {
+  key: true,
+  ref: true,
+  __self: true,
+  __source: true
+};
+
+function hasValidRef(config) {
+
+  return config.ref !== undefined;
+}
+
+function hasValidKey(config) {
+
+  return config.key !== undefined;
+}
+/**
+ * Factory method to create a new React element. This no longer adheres to
+ * the class pattern, so do not use new to call it. Also, instanceof check
+ * will not work. Instead test $$typeof field against Symbol.for('react.element') to check
+ * if something is a React Element.
+ *
+ * @param {*} type
+ * @param {*} props
+ * @param {*} key
+ * @param {string|object} ref
+ * @param {*} owner
+ * @param {*} self A *temporary* helper to detect places where `this` is
+ * different from the `owner` when React.createElement is called, so that we
+ * can warn. We want to get rid of owner and replace string `ref`s with arrow
+ * functions, and as long as `this` and owner are the same, there will be no
+ * change in behavior.
+ * @param {*} source An annotation object (added by a transpiler or otherwise)
+ * indicating filename, line number, and/or other information.
+ * @internal
+ */
+
+
+function ReactElement(type, key, ref, self, source, owner, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type,
+    key,
+    ref,
+    props,
+    // Record the component responsible for creating this element.
+    _owner: owner
+  };
+
+  return element;
+}
+/**
+ * https://github.com/reactjs/rfcs/pull/107
+ * @param {*} type
+ * @param {object} props
+ * @param {string} key
+ */
+
+
+function jsx$1(type, config, maybeKey) {
+  let propName; // Reserved names are extracted
+
+  const props = {};
+  let key = null;
+  let ref = null; // Currently, key can be spread in as a prop. This causes a potential
+  // issue if key is also explicitly declared (ie. <div {...props} key="Hi" />
+  // or <div key="Hi" {...props} /> ). We want to deprecate key spread,
+  // but as an intermediary step, we will use jsxDEV for everything except
+  // <div {...props} key="Hi" />, because we aren't currently able to tell if
+  // key is explicitly declared to be undefined or not.
+
+  if (maybeKey !== undefined) {
+
+    key = '' + maybeKey;
+  }
+
+  if (hasValidKey(config)) {
+
+    key = '' + config.key;
+  }
+
+  if (hasValidRef(config)) {
+    ref = config.ref;
+  } // Remaining properties are added to a new props object
+
+
+  for (propName in config) {
+    if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+      props[propName] = config[propName];
+    }
+  } // Resolve default props
+
+
+  if (type && type.defaultProps) {
+    const defaultProps = type.defaultProps;
+
+    for (propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+  }
+
+  return ReactElement(type, key, ref, undefined, undefined, ReactCurrentOwner.current, props);
+}
+
+const jsx = jsx$1; // we may want to special case jsxs internally to take advantage of static children.
+// for now we can ship identical prod functions
+
+const jsxs = jsx$1;
+
+exports.Fragment = REACT_FRAGMENT_TYPE;
+exports.jsx = jsx;
+exports.jsxs = jsxs;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react/cjs/react-jsx-runtime.production.min.js b/packages/next/src/compiled/react/cjs/react-jsx-runtime.production.min.js
index 2c15ab3ac1155..3a7f082e26e83 100644
--- a/packages/next/src/compiled/react/cjs/react-jsx-runtime.production.min.js
+++ b/packages/next/src/compiled/react/cjs/react-jsx-runtime.production.min.js
@@ -1,11 +1,13 @@
-/**
- * @license React
- * react-jsx-runtime.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-jsx-runtime.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var f=require("next/dist/compiled/react"),k=Symbol.for("react.element"),l=Symbol.for("react.fragment"),m=Object.prototype.hasOwnProperty,n=f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,p={key:!0,ref:!0,__self:!0,__source:!0};
 function q(c,a,g){var b,d={},e=null,h=null;void 0!==g&&(e=""+g);void 0!==a.key&&(e=""+a.key);void 0!==a.ref&&(h=a.ref);for(b in a)m.call(a,b)&&!p.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return{$$typeof:k,type:c,key:e,ref:h,props:d,_owner:n.current}}exports.Fragment=l;exports.jsx=q;exports.jsxs=q;
+
+//# sourceMappingURL=react-jsx-runtime.production.min.js.map
diff --git a/packages/next/src/compiled/react/cjs/react-jsx-runtime.profiling.js b/packages/next/src/compiled/react/cjs/react-jsx-runtime.profiling.js
new file mode 100644
index 0000000000000..1153d19e2ad40
--- /dev/null
+++ b/packages/next/src/compiled/react/cjs/react-jsx-runtime.profiling.js
@@ -0,0 +1,142 @@
+/**
+ * @license React
+ * react-jsx-runtime.profiling.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var React = require("next/dist/compiled/react");
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+
+const ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+const ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
+const RESERVED_PROPS = {
+  key: true,
+  ref: true,
+  __self: true,
+  __source: true
+};
+
+function hasValidRef(config) {
+
+  return config.ref !== undefined;
+}
+
+function hasValidKey(config) {
+
+  return config.key !== undefined;
+}
+/**
+ * Factory method to create a new React element. This no longer adheres to
+ * the class pattern, so do not use new to call it. Also, instanceof check
+ * will not work. Instead test $$typeof field against Symbol.for('react.element') to check
+ * if something is a React Element.
+ *
+ * @param {*} type
+ * @param {*} props
+ * @param {*} key
+ * @param {string|object} ref
+ * @param {*} owner
+ * @param {*} self A *temporary* helper to detect places where `this` is
+ * different from the `owner` when React.createElement is called, so that we
+ * can warn. We want to get rid of owner and replace string `ref`s with arrow
+ * functions, and as long as `this` and owner are the same, there will be no
+ * change in behavior.
+ * @param {*} source An annotation object (added by a transpiler or otherwise)
+ * indicating filename, line number, and/or other information.
+ * @internal
+ */
+
+
+function ReactElement(type, key, ref, self, source, owner, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type,
+    key,
+    ref,
+    props,
+    // Record the component responsible for creating this element.
+    _owner: owner
+  };
+
+  return element;
+}
+/**
+ * https://github.com/reactjs/rfcs/pull/107
+ * @param {*} type
+ * @param {object} props
+ * @param {string} key
+ */
+
+
+function jsx$1(type, config, maybeKey) {
+  let propName; // Reserved names are extracted
+
+  const props = {};
+  let key = null;
+  let ref = null; // Currently, key can be spread in as a prop. This causes a potential
+  // issue if key is also explicitly declared (ie. <div {...props} key="Hi" />
+  // or <div key="Hi" {...props} /> ). We want to deprecate key spread,
+  // but as an intermediary step, we will use jsxDEV for everything except
+  // <div {...props} key="Hi" />, because we aren't currently able to tell if
+  // key is explicitly declared to be undefined or not.
+
+  if (maybeKey !== undefined) {
+
+    key = '' + maybeKey;
+  }
+
+  if (hasValidKey(config)) {
+
+    key = '' + config.key;
+  }
+
+  if (hasValidRef(config)) {
+    ref = config.ref;
+  } // Remaining properties are added to a new props object
+
+
+  for (propName in config) {
+    if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+      props[propName] = config[propName];
+    }
+  } // Resolve default props
+
+
+  if (type && type.defaultProps) {
+    const defaultProps = type.defaultProps;
+
+    for (propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+  }
+
+  return ReactElement(type, key, ref, undefined, undefined, ReactCurrentOwner.current, props);
+}
+
+const jsx = jsx$1; // we may want to special case jsxs internally to take advantage of static children.
+// for now we can ship identical prod functions
+
+const jsxs = jsx$1;
+
+exports.Fragment = REACT_FRAGMENT_TYPE;
+exports.jsx = jsx;
+exports.jsxs = jsxs;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react/cjs/react-jsx-runtime.profiling.min.js b/packages/next/src/compiled/react/cjs/react-jsx-runtime.profiling.min.js
index 5936004d767cc..ebee0365c35b9 100644
--- a/packages/next/src/compiled/react/cjs/react-jsx-runtime.profiling.min.js
+++ b/packages/next/src/compiled/react/cjs/react-jsx-runtime.profiling.min.js
@@ -1,11 +1,13 @@
-/**
- * @license React
- * react-jsx-runtime.profiling.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react-jsx-runtime.profiling.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var f=require("next/dist/compiled/react"),k=Symbol.for("react.element"),l=Symbol.for("react.fragment"),m=Object.prototype.hasOwnProperty,n=f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,p={key:!0,ref:!0,__self:!0,__source:!0};
 function q(c,a,g){var b,d={},e=null,h=null;void 0!==g&&(e=""+g);void 0!==a.key&&(e=""+a.key);void 0!==a.ref&&(h=a.ref);for(b in a)m.call(a,b)&&!p.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return{$$typeof:k,type:c,key:e,ref:h,props:d,_owner:n.current}}exports.Fragment=l;exports.jsx=q;exports.jsxs=q;
+
+//# sourceMappingURL=react-jsx-runtime.profiling.min.js.map
diff --git a/packages/next/src/compiled/react/cjs/react.development.js b/packages/next/src/compiled/react/cjs/react.development.js
index 9dfdebf2f7477..b84cf950fdddf 100644
--- a/packages/next/src/compiled/react/cjs/react.development.js
+++ b/packages/next/src/compiled/react/cjs/react.development.js
@@ -23,7 +23,7 @@ if (
 ) {
   __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
 }
-          var ReactVersion = '18.3.0-canary-2983249dd-20231107';
+          var ReactVersion = '18.3.0-canary-7508dcd5c-20231108';
 
 // ATTENTION
 // When adding new symbols to this file,
@@ -1929,6 +1929,18 @@ var componentFrameCache;
   var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
   componentFrameCache = new PossiblyWeakMap();
 }
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
@@ -1944,7 +1956,6 @@ function describeNativeComponentFrame(fn, construct) {
     }
   }
 
-  var control;
   reentry = true;
   var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
 
@@ -1958,81 +1969,140 @@ function describeNativeComponentFrame(fn, construct) {
     ReactCurrentDispatcher.current = null;
     disableLogs();
   }
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
 
-  try {
-    // This should throw.
-    if (construct) {
-      // Something should be setting the props in the constructor.
-      var Fake = function () {
-        throw Error();
-      }; // $FlowFixMe[prop-missing]
 
+  var RunInRootFrame = {
+    DetermineComponentFrameRoot: function () {
+      var control;
 
-      Object.defineProperty(Fake.prototype, 'props', {
-        set: function () {
-          // We use a throwing setter instead of frozen or non-writable props
-          // because that won't throw in a non-strict mode function.
-          throw Error();
-        }
-      });
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          var Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
 
-      if (typeof Reflect === 'object' && Reflect.construct) {
-        // We construct a different control for this case to include any extra
-        // frames added by the construct call.
-        try {
-          Reflect.construct(Fake, []);
-        } catch (x) {
-          control = x;
-        }
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
 
-        Reflect.construct(fn, [], Fake);
-      } else {
-        try {
-          Fake.call();
-        } catch (x) {
-          control = x;
-        } // $FlowFixMe[prop-missing] found when upgrading Flow
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
 
 
-        fn.call(Fake.prototype);
-      }
-    } else {
-      try {
-        throw Error();
-      } catch (x) {
-        control = x;
-      } // TODO(luna): This will currently only throw if the function component
-      // tries to access React/ReactDOM/props. We should probably make this throw
-      // in simple components too
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
 
 
-      var maybePromise = fn(); // If the function component returns a promise, it's likely an async
-      // component, which we don't yet support. Attach a noop catch handler to
-      // silence the error.
-      // TODO: Implement component stacks for async client components?
+          var maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
 
-      if (maybePromise && typeof maybePromise.catch === 'function') {
-        maybePromise.catch(function () {});
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(function () {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
       }
+
+      return [null, null];
     }
-  } catch (sample) {
-    // This is inlined manually because closure doesn't do it for us.
-    if (sample && control && typeof sample.stack === 'string') {
+  }; // $FlowFixMe[prop-missing]
+
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
+
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
+
+  try {
+    var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
+
+    if (sampleStack && controlStack) {
       // This extracts the first frame from the sample that isn't also in the control.
       // Skipping one frame that we assume is the frame that calls the two.
-      var sampleLines = sample.stack.split('\n');
-      var controlLines = control.stack.split('\n');
-      var s = sampleLines.length - 1;
-      var c = controlLines.length - 1;
-
-      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
-        // We expect at least one stack frame to be shared.
-        // Typically this will be the root most one. However, stack frames may be
-        // cut off due to maximum stack limits. In this case, one maybe cut off
-        // earlier than the other. We assume that the sample is longer or the same
-        // and there for cut off earlier. So we should find the root most frame in
-        // the sample somewhere in the control.
-        c--;
+      var sampleLines = sampleStack.split('\n');
+      var controlLines = controlStack.split('\n');
+      var s = 0;
+      var c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
       }
 
       for (; s >= 1 && c >= 0; s--, c--) {
@@ -2061,7 +2131,7 @@ function describeNativeComponentFrame(fn, construct) {
                   _frame = _frame.replace('<anonymous>', fn.displayName);
                 }
 
-                {
+                if (true) {
                   if (typeof fn === 'function') {
                     componentFrameCache.set(fn, _frame);
                   }
diff --git a/packages/next/src/compiled/react/cjs/react.production.js b/packages/next/src/compiled/react/cjs/react.production.js
new file mode 100644
index 0000000000000..824be01349657
--- /dev/null
+++ b/packages/next/src/compiled/react/cjs/react.production.js
@@ -0,0 +1,1101 @@
+/**
+ * @license React
+ * react.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var ReactVersion = '18.3.0-canary-7508dcd5c-20231108';
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+const REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+const REACT_CONTEXT_TYPE = Symbol.for('react.context');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+/**
+ * This is the abstract API for an update queue.
+ */
+
+
+const ReactNoopUpdateQueue = {
+  /**
+   * Checks whether or not this composite component is mounted.
+   * @param {ReactClass} publicInstance The instance we want to test.
+   * @return {boolean} True if mounted, false otherwise.
+   * @protected
+   * @final
+   */
+  isMounted: function (publicInstance) {
+    return false;
+  },
+
+  /**
+   * Forces an update. This should only be invoked when it is known with
+   * certainty that we are **not** in a DOM transaction.
+   *
+   * You may want to call this when you know that some deeper aspect of the
+   * component's state has changed but `setState` was not called.
+   *
+   * This will not invoke `shouldComponentUpdate`, but it will invoke
+   * `componentWillUpdate` and `componentDidUpdate`.
+   *
+   * @param {ReactClass} publicInstance The instance that should rerender.
+   * @param {?function} callback Called after component is updated.
+   * @param {?string} callerName name of the calling function in the public API.
+   * @internal
+   */
+  enqueueForceUpdate: function (publicInstance, callback, callerName) {
+  },
+
+  /**
+   * Replaces all of the state. Always use this or `setState` to mutate state.
+   * You should treat `this.state` as immutable.
+   *
+   * There is no guarantee that `this.state` will be immediately updated, so
+   * accessing `this.state` after calling this method may return the old value.
+   *
+   * @param {ReactClass} publicInstance The instance that should rerender.
+   * @param {object} completeState Next state.
+   * @param {?function} callback Called after component is updated.
+   * @param {?string} callerName name of the calling function in the public API.
+   * @internal
+   */
+  enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {
+  },
+
+  /**
+   * Sets a subset of the state. This only exists because _pendingState is
+   * internal. This provides a merging strategy that is not available to deep
+   * properties which is confusing. TODO: Expose pendingState or don't use it
+   * during the merge.
+   *
+   * @param {ReactClass} publicInstance The instance that should rerender.
+   * @param {object} partialState Next partial state to be merged with state.
+   * @param {?function} callback Called after component is updated.
+   * @param {?string} Name of the calling function in the public API.
+   * @internal
+   */
+  enqueueSetState: function (publicInstance, partialState, callback, callerName) {
+  }
+};
+
+const assign = Object.assign;
+
+const emptyObject = {};
+/**
+ * Base class helpers for the updating state of a component.
+ */
+
+
+function Component(props, context, updater) {
+  this.props = props;
+  this.context = context; // If a component has string refs, we will assign a different object later.
+
+  this.refs = emptyObject; // We initialize the default updater but the real one gets injected by the
+  // renderer.
+
+  this.updater = updater || ReactNoopUpdateQueue;
+}
+
+Component.prototype.isReactComponent = {};
+/**
+ * Sets a subset of the state. Always use this to mutate
+ * state. You should treat `this.state` as immutable.
+ *
+ * There is no guarantee that `this.state` will be immediately updated, so
+ * accessing `this.state` after calling this method may return the old value.
+ *
+ * There is no guarantee that calls to `setState` will run synchronously,
+ * as they may eventually be batched together.  You can provide an optional
+ * callback that will be executed when the call to setState is actually
+ * completed.
+ *
+ * When a function is provided to setState, it will be called at some point in
+ * the future (not synchronously). It will be called with the up to date
+ * component arguments (state, props, context). These values can be different
+ * from this.* because your function may be called after receiveProps but before
+ * shouldComponentUpdate, and this new state, props, and context will not yet be
+ * assigned to this.
+ *
+ * @param {object|function} partialState Next partial state or function to
+ *        produce next partial state to be merged with current state.
+ * @param {?function} callback Called after state is updated.
+ * @final
+ * @protected
+ */
+
+Component.prototype.setState = function (partialState, callback) {
+  if (typeof partialState !== 'object' && typeof partialState !== 'function' && partialState != null) {
+    throw new Error('setState(...): takes an object of state variables to update or a ' + 'function which returns an object of state variables.');
+  }
+
+  this.updater.enqueueSetState(this, partialState, callback, 'setState');
+};
+/**
+ * Forces an update. This should only be invoked when it is known with
+ * certainty that we are **not** in a DOM transaction.
+ *
+ * You may want to call this when you know that some deeper aspect of the
+ * component's state has changed but `setState` was not called.
+ *
+ * This will not invoke `shouldComponentUpdate`, but it will invoke
+ * `componentWillUpdate` and `componentDidUpdate`.
+ *
+ * @param {?function} callback Called after update is complete.
+ * @final
+ * @protected
+ */
+
+
+Component.prototype.forceUpdate = function (callback) {
+  this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');
+};
+
+function ComponentDummy() {}
+
+ComponentDummy.prototype = Component.prototype;
+/**
+ * Convenience component with default shallow equality check for sCU.
+ */
+
+function PureComponent(props, context, updater) {
+  this.props = props;
+  this.context = context; // If a component has string refs, we will assign a different object later.
+
+  this.refs = emptyObject;
+  this.updater = updater || ReactNoopUpdateQueue;
+}
+
+const pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
+pureComponentPrototype.constructor = PureComponent; // Avoid an extra prototype jump for these methods.
+
+assign(pureComponentPrototype, Component.prototype);
+pureComponentPrototype.isPureReactComponent = true;
+
+// an immutable object with a single mutable value
+function createRef() {
+  const refObject = {
+    current: null
+  };
+
+  return refObject;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/**
+ * Keeps track of the current owner.
+ *
+ * The current owner is the component who should own any components that are
+ * currently being constructed.
+ */
+const ReactCurrentOwner = {
+  /**
+   * @internal
+   * @type {ReactComponent}
+   */
+  current: null
+};
+
+const RESERVED_PROPS = {
+  key: true,
+  ref: true,
+  __self: true,
+  __source: true
+};
+
+function hasValidRef(config) {
+
+  return config.ref !== undefined;
+}
+
+function hasValidKey(config) {
+
+  return config.key !== undefined;
+}
+/**
+ * Factory method to create a new React element. This no longer adheres to
+ * the class pattern, so do not use new to call it. Also, instanceof check
+ * will not work. Instead test $$typeof field against Symbol.for('react.element') to check
+ * if something is a React Element.
+ *
+ * @param {*} type
+ * @param {*} props
+ * @param {*} key
+ * @param {string|object} ref
+ * @param {*} owner
+ * @param {*} self A *temporary* helper to detect places where `this` is
+ * different from the `owner` when React.createElement is called, so that we
+ * can warn. We want to get rid of owner and replace string `ref`s with arrow
+ * functions, and as long as `this` and owner are the same, there will be no
+ * change in behavior.
+ * @param {*} source An annotation object (added by a transpiler or otherwise)
+ * indicating filename, line number, and/or other information.
+ * @internal
+ */
+
+
+function ReactElement(type, key, ref, self, source, owner, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: ref,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: owner
+  };
+
+  return element;
+}
+/**
+ * Create and return a new ReactElement of the given type.
+ * See https://reactjs.org/docs/react-api.html#createelement
+ */
+
+function createElement$1(type, config, children) {
+  let propName; // Reserved names are extracted
+
+  const props = {};
+  let key = null;
+  let ref = null;
+  let self = null;
+  let source = null;
+
+  if (config != null) {
+    if (hasValidRef(config)) {
+      ref = config.ref;
+    }
+
+    if (hasValidKey(config)) {
+
+      key = '' + config.key;
+    }
+
+    self = config.__self === undefined ? null : config.__self;
+    source = config.__source === undefined ? null : config.__source; // Remaining properties are added to a new props object
+
+    for (propName in config) {
+      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+        props[propName] = config[propName];
+      }
+    }
+  } // Children can be more than one argument, and those are transferred onto
+  // the newly allocated props object.
+
+
+  const childrenLength = arguments.length - 2;
+
+  if (childrenLength === 1) {
+    props.children = children;
+  } else if (childrenLength > 1) {
+    const childArray = Array(childrenLength);
+
+    for (let i = 0; i < childrenLength; i++) {
+      childArray[i] = arguments[i + 2];
+    }
+
+    props.children = childArray;
+  } // Resolve default props
+
+
+  if (type && type.defaultProps) {
+    const defaultProps = type.defaultProps;
+
+    for (propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+  }
+
+  return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
+}
+/**
+ * Return a function that produces ReactElements of a given type.
+ * See https://reactjs.org/docs/react-api.html#createfactory
+ */
+
+function createFactory$1(type) {
+  const factory = createElement$1.bind(null, type); // Expose the type on the factory and the prototype so that it can be
+  // easily accessed on elements. E.g. `<Foo />.type === Foo`.
+  // This should not be named `constructor` since this may not be the function
+  // that created the element, and it may not even be a constructor.
+  // Legacy hook: remove it
+
+  factory.type = type;
+  return factory;
+}
+function cloneAndReplaceKey(oldElement, newKey) {
+  const newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
+  return newElement;
+}
+/**
+ * Clone and return a new ReactElement using element as the starting point.
+ * See https://reactjs.org/docs/react-api.html#cloneelement
+ */
+
+function cloneElement$1(element, config, children) {
+  if (element === null || element === undefined) {
+    throw new Error("React.cloneElement(...): The argument must be a React element, but you passed " + element + ".");
+  }
+
+  let propName; // Original props are copied
+
+  const props = assign({}, element.props); // Reserved names are extracted
+
+  let key = element.key;
+  let ref = element.ref; // Self is preserved since the owner is preserved.
+
+  const self = element._self; // Source is preserved since cloneElement is unlikely to be targeted by a
+  // transpiler, and the original source is probably a better indicator of the
+  // true owner.
+
+  const source = element._source; // Owner will be preserved, unless ref is overridden
+
+  let owner = element._owner;
+
+  if (config != null) {
+    if (hasValidRef(config)) {
+      // Silently steal the ref from the parent.
+      ref = config.ref;
+      owner = ReactCurrentOwner.current;
+    }
+
+    if (hasValidKey(config)) {
+
+      key = '' + config.key;
+    } // Remaining properties override existing props
+
+
+    let defaultProps;
+
+    if (element.type && element.type.defaultProps) {
+      defaultProps = element.type.defaultProps;
+    }
+
+    for (propName in config) {
+      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+        if (config[propName] === undefined && defaultProps !== undefined) {
+          // Resolve default props
+          props[propName] = defaultProps[propName];
+        } else {
+          props[propName] = config[propName];
+        }
+      }
+    }
+  } // Children can be more than one argument, and those are transferred onto
+  // the newly allocated props object.
+
+
+  const childrenLength = arguments.length - 2;
+
+  if (childrenLength === 1) {
+    props.children = children;
+  } else if (childrenLength > 1) {
+    const childArray = Array(childrenLength);
+
+    for (let i = 0; i < childrenLength; i++) {
+      childArray[i] = arguments[i + 2];
+    }
+
+    props.children = childArray;
+  }
+
+  return ReactElement(element.type, key, ref, self, source, owner, props);
+}
+/**
+ * Verifies the object is a ReactElement.
+ * See https://reactjs.org/docs/react-api.html#isvalidelement
+ * @param {?object} object
+ * @return {boolean} True if `object` is a ReactElement.
+ * @final
+ */
+
+function isValidElement(object) {
+  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+}
+
+const SEPARATOR = '.';
+const SUBSEPARATOR = ':';
+/**
+ * Escape and wrap key so it is safe to use as a reactid
+ *
+ * @param {string} key to be escaped.
+ * @return {string} the escaped key.
+ */
+
+function escape(key) {
+  const escapeRegex = /[=:]/g;
+  const escaperLookup = {
+    '=': '=0',
+    ':': '=2'
+  };
+  const escapedString = key.replace(escapeRegex, function (match) {
+    return escaperLookup[match];
+  });
+  return '$' + escapedString;
+}
+const userProvidedKeyEscapeRegex = /\/+/g;
+
+function escapeUserProvidedKey(text) {
+  return text.replace(userProvidedKeyEscapeRegex, '$&/');
+}
+/**
+ * Generate a key string that identifies a element within a set.
+ *
+ * @param {*} element A element that could contain a manual key.
+ * @param {number} index Index that is used if a manual key is not provided.
+ * @return {string}
+ */
+
+
+function getElementKey(element, index) {
+  // Do some typechecking here since we call this blindly. We want to ensure
+  // that we don't block potential future ES APIs.
+  if (typeof element === 'object' && element !== null && element.key != null) {
+
+    return escape('' + element.key);
+  } // Implicit key determined by the index in the set
+
+
+  return index.toString(36);
+}
+
+function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
+  const type = typeof children;
+
+  if (type === 'undefined' || type === 'boolean') {
+    // All of the above are perceived as null.
+    children = null;
+  }
+
+  let invokeCallback = false;
+
+  if (children === null) {
+    invokeCallback = true;
+  } else {
+    switch (type) {
+      case 'string':
+      case 'number':
+        invokeCallback = true;
+        break;
+
+      case 'object':
+        switch (children.$$typeof) {
+          case REACT_ELEMENT_TYPE:
+          case REACT_PORTAL_TYPE:
+            invokeCallback = true;
+        }
+
+    }
+  }
+
+  if (invokeCallback) {
+    const child = children;
+    let mappedChild = callback(child); // If it's the only child, treat the name as if it was wrapped in an array
+    // so that it's consistent if the number of children grows:
+
+    const childKey = nameSoFar === '' ? SEPARATOR + getElementKey(child, 0) : nameSoFar;
+
+    if (isArray(mappedChild)) {
+      let escapedChildKey = '';
+
+      if (childKey != null) {
+        escapedChildKey = escapeUserProvidedKey(childKey) + '/';
+      }
+
+      mapIntoArray(mappedChild, array, escapedChildKey, '', c => c);
+    } else if (mappedChild != null) {
+      if (isValidElement(mappedChild)) {
+
+        mappedChild = cloneAndReplaceKey(mappedChild, // Keep both the (mapped) and old keys if they differ, just as
+        // traverseAllChildren used to do for objects as children
+        escapedPrefix + ( // $FlowFixMe[incompatible-type] Flow incorrectly thinks React.Portal doesn't have a key
+        mappedChild.key && (!child || child.key !== mappedChild.key) ? escapeUserProvidedKey( // $FlowFixMe[unsafe-addition]
+        '' + mappedChild.key // eslint-disable-line react-internal/safe-string-coercion
+        ) + '/' : '') + childKey);
+      }
+
+      array.push(mappedChild);
+    }
+
+    return 1;
+  }
+
+  let child;
+  let nextName;
+  let subtreeCount = 0; // Count of children found in the current subtree.
+
+  const nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;
+
+  if (isArray(children)) {
+    for (let i = 0; i < children.length; i++) {
+      child = children[i];
+      nextName = nextNamePrefix + getElementKey(child, i);
+      subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
+    }
+  } else {
+    const iteratorFn = getIteratorFn(children);
+
+    if (typeof iteratorFn === 'function') {
+      const iterableChildren = children;
+
+      const iterator = iteratorFn.call(iterableChildren);
+      let step;
+      let ii = 0; // $FlowFixMe[incompatible-use] `iteratorFn` might return null according to typing.
+
+      while (!(step = iterator.next()).done) {
+        child = step.value;
+        nextName = nextNamePrefix + getElementKey(child, ii++);
+        subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
+      }
+    } else if (type === 'object') {
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      const childrenString = String(children);
+      throw new Error("Objects are not valid as a React child (found: " + (childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString) + "). " + 'If you meant to render a collection of children, use an array ' + 'instead.');
+    }
+  }
+
+  return subtreeCount;
+}
+/**
+ * Maps children that are typically specified as `props.children`.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrenmap
+ *
+ * The provided mapFunction(child, index) will be called for each
+ * leaf child.
+ *
+ * @param {?*} children Children tree container.
+ * @param {function(*, int)} func The map function.
+ * @param {*} context Context for mapFunction.
+ * @return {object} Object containing the ordered map of results.
+ */
+
+
+function mapChildren(children, func, context) {
+  if (children == null) {
+    return children;
+  }
+
+  const result = [];
+  let count = 0;
+  mapIntoArray(children, result, '', '', function (child) {
+    return func.call(context, child, count++);
+  });
+  return result;
+}
+/**
+ * Count the number of children that are typically specified as
+ * `props.children`.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrencount
+ *
+ * @param {?*} children Children tree container.
+ * @return {number} The number of children.
+ */
+
+
+function countChildren(children) {
+  let n = 0;
+  mapChildren(children, () => {
+    n++; // Don't return anything
+  });
+  return n;
+}
+/**
+ * Iterates through children that are typically specified as `props.children`.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrenforeach
+ *
+ * The provided forEachFunc(child, index) will be called for each
+ * leaf child.
+ *
+ * @param {?*} children Children tree container.
+ * @param {function(*, int)} forEachFunc
+ * @param {*} forEachContext Context for forEachContext.
+ */
+
+
+function forEachChildren(children, forEachFunc, forEachContext) {
+  mapChildren(children, // $FlowFixMe[missing-this-annot]
+  function () {
+    forEachFunc.apply(this, arguments); // Don't return anything.
+  }, forEachContext);
+}
+/**
+ * Flatten a children object (typically specified as `props.children`) and
+ * return an array with appropriately re-keyed children.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrentoarray
+ */
+
+
+function toArray(children) {
+  return mapChildren(children, child => child) || [];
+}
+/**
+ * Returns the first child in a collection of children and verifies that there
+ * is only one child in the collection.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrenonly
+ *
+ * The current implementation of this function assumes that a single child gets
+ * passed without a wrapper, but the purpose of this helper function is to
+ * abstract away the particular structure of children.
+ *
+ * @param {?object} children Child collection structure.
+ * @return {ReactElement} The first and only `ReactElement` contained in the
+ * structure.
+ */
+
+
+function onlyChild(children) {
+  if (!isValidElement(children)) {
+    throw new Error('React.Children.only expected to receive a single React element child.');
+  }
+
+  return children;
+}
+
+function createContext(defaultValue) {
+  // TODO: Second argument used to be an optional `calculateChangedBits`
+  // function. Warn to reserve for future use?
+  const context = {
+    $$typeof: REACT_CONTEXT_TYPE,
+    // As a workaround to support multiple concurrent renderers, we categorize
+    // some renderers as primary and others as secondary. We only expect
+    // there to be two concurrent renderers at most: React Native (primary) and
+    // Fabric (secondary); React DOM (primary) and React ART (secondary).
+    // Secondary renderers store their context values on separate fields.
+    _currentValue: defaultValue,
+    _currentValue2: defaultValue,
+    // Used to track how many concurrent renderers this context currently
+    // supports within in a single renderer. Such as parallel server rendering.
+    _threadCount: 0,
+    // These are circular
+    Provider: null,
+    Consumer: null,
+    // Add these to use same hidden class in VM as ServerContext
+    _defaultValue: null,
+    _globalName: null
+  };
+  context.Provider = {
+    $$typeof: REACT_PROVIDER_TYPE,
+    _context: context
+  };
+
+  {
+    context.Consumer = context;
+  }
+
+  return context;
+}
+
+const Uninitialized = -1;
+const Pending = 0;
+const Resolved = 1;
+const Rejected = 2;
+
+function lazyInitializer(payload) {
+  if (payload._status === Uninitialized) {
+    const ctor = payload._result;
+    const thenable = ctor(); // Transition to the next state.
+    // This might throw either because it's missing or throws. If so, we treat it
+    // as still uninitialized and try again next time. Which is the same as what
+    // happens if the ctor or any wrappers processing the ctor throws. This might
+    // end up fixing it if the resolution was a concurrency bug.
+
+    thenable.then(moduleObject => {
+      if (payload._status === Pending || payload._status === Uninitialized) {
+        // Transition to the next state.
+        const resolved = payload;
+        resolved._status = Resolved;
+        resolved._result = moduleObject;
+      }
+    }, error => {
+      if (payload._status === Pending || payload._status === Uninitialized) {
+        // Transition to the next state.
+        const rejected = payload;
+        rejected._status = Rejected;
+        rejected._result = error;
+      }
+    });
+
+    if (payload._status === Uninitialized) {
+      // In case, we're still uninitialized, then we're waiting for the thenable
+      // to resolve. Set it as pending in the meantime.
+      const pending = payload;
+      pending._status = Pending;
+      pending._result = thenable;
+    }
+  }
+
+  if (payload._status === Resolved) {
+    const moduleObject = payload._result;
+
+    return moduleObject.default;
+  } else {
+    throw payload._result;
+  }
+}
+
+function lazy(ctor) {
+  const payload = {
+    // We use these fields to store the result.
+    _status: Uninitialized,
+    _result: ctor
+  };
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: payload,
+    _init: lazyInitializer
+  };
+
+  return lazyType;
+}
+
+function forwardRef(render) {
+
+  const elementType = {
+    $$typeof: REACT_FORWARD_REF_TYPE,
+    render
+  };
+
+  return elementType;
+}
+
+function memo(type, compare) {
+
+  const elementType = {
+    $$typeof: REACT_MEMO_TYPE,
+    type,
+    compare: compare === undefined ? null : compare
+  };
+
+  return elementType;
+}
+
+/**
+ * Keeps track of the current Cache dispatcher.
+ */
+const ReactCurrentCache = {
+  current: null
+};
+
+const UNTERMINATED = 0;
+const TERMINATED = 1;
+const ERRORED = 2;
+
+function createCacheRoot() {
+  return new WeakMap();
+}
+
+function createCacheNode() {
+  return {
+    s: UNTERMINATED,
+    // status, represents whether the cached computation returned a value or threw an error
+    v: undefined,
+    // value, either the cached result or an error, depending on s
+    o: null,
+    // object cache, a WeakMap where non-primitive arguments are stored
+    p: null // primitive cache, a regular Map where primitive arguments are stored.
+
+  };
+}
+
+function cache(fn) {
+  return function () {
+    const dispatcher = ReactCurrentCache.current;
+
+    if (!dispatcher) {
+      // If there is no dispatcher, then we treat this as not being cached.
+      // $FlowFixMe[incompatible-call]: We don't want to use rest arguments since we transpile the code.
+      return fn.apply(null, arguments);
+    }
+
+    const fnMap = dispatcher.getCacheForType(createCacheRoot);
+    const fnNode = fnMap.get(fn);
+    let cacheNode;
+
+    if (fnNode === undefined) {
+      cacheNode = createCacheNode();
+      fnMap.set(fn, cacheNode);
+    } else {
+      cacheNode = fnNode;
+    }
+
+    for (let i = 0, l = arguments.length; i < l; i++) {
+      const arg = arguments[i];
+
+      if (typeof arg === 'function' || typeof arg === 'object' && arg !== null) {
+        // Objects go into a WeakMap
+        let objectCache = cacheNode.o;
+
+        if (objectCache === null) {
+          cacheNode.o = objectCache = new WeakMap();
+        }
+
+        const objectNode = objectCache.get(arg);
+
+        if (objectNode === undefined) {
+          cacheNode = createCacheNode();
+          objectCache.set(arg, cacheNode);
+        } else {
+          cacheNode = objectNode;
+        }
+      } else {
+        // Primitives go into a regular Map
+        let primitiveCache = cacheNode.p;
+
+        if (primitiveCache === null) {
+          cacheNode.p = primitiveCache = new Map();
+        }
+
+        const primitiveNode = primitiveCache.get(arg);
+
+        if (primitiveNode === undefined) {
+          cacheNode = createCacheNode();
+          primitiveCache.set(arg, cacheNode);
+        } else {
+          cacheNode = primitiveNode;
+        }
+      }
+    }
+
+    if (cacheNode.s === TERMINATED) {
+      return cacheNode.v;
+    }
+
+    if (cacheNode.s === ERRORED) {
+      throw cacheNode.v;
+    }
+
+    try {
+      // $FlowFixMe[incompatible-call]: We don't want to use rest arguments since we transpile the code.
+      const result = fn.apply(null, arguments);
+      const terminatedNode = cacheNode;
+      terminatedNode.s = TERMINATED;
+      terminatedNode.v = result;
+      return result;
+    } catch (error) {
+      // We store the first error that's thrown and rethrow it.
+      const erroredNode = cacheNode;
+      erroredNode.s = ERRORED;
+      erroredNode.v = error;
+      throw error;
+    }
+  };
+}
+
+/**
+ * Keeps track of the current dispatcher.
+ */
+const ReactCurrentDispatcher = {
+  current: null
+};
+
+function resolveDispatcher() {
+  const dispatcher = ReactCurrentDispatcher.current;
+  // intentionally don't throw our own error because this is in a hot path.
+  // Also helps ensure this is inlined.
+
+
+  return dispatcher;
+}
+function useContext(Context) {
+  const dispatcher = resolveDispatcher();
+
+  return dispatcher.useContext(Context);
+}
+function useState(initialState) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useState(initialState);
+}
+function useReducer(reducer, initialArg, init) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useReducer(reducer, initialArg, init);
+}
+function useRef(initialValue) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useRef(initialValue);
+}
+function useEffect(create, deps) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useEffect(create, deps);
+}
+function useInsertionEffect(create, deps) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useInsertionEffect(create, deps);
+}
+function useLayoutEffect(create, deps) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useLayoutEffect(create, deps);
+}
+function useCallback(callback, deps) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useCallback(callback, deps);
+}
+function useMemo(create, deps) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useMemo(create, deps);
+}
+function useImperativeHandle(ref, create, deps) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useImperativeHandle(ref, create, deps);
+}
+function useDebugValue(value, formatterFn) {
+}
+function useTransition() {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useTransition();
+}
+function useDeferredValue(value, initialValue) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useDeferredValue(value, initialValue);
+}
+function useId() {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useId();
+}
+function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+}
+function useCacheRefresh() {
+  const dispatcher = resolveDispatcher(); // $FlowFixMe[not-a-function] This is unstable, thus optional
+
+  return dispatcher.useCacheRefresh();
+}
+function use(usable) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.use(usable);
+}
+function useOptimistic(passthrough, reducer) {
+  const dispatcher = resolveDispatcher(); // $FlowFixMe[not-a-function] This is unstable, thus optional
+
+  return dispatcher.useOptimistic(passthrough, reducer);
+}
+
+/**
+ * Keeps track of the current batch's configuration such as how long an update
+ * should suspend for if it needs to.
+ */
+const ReactCurrentBatchConfig = {
+  transition: null
+};
+
+const ReactSharedInternals = {
+  ReactCurrentDispatcher,
+  ReactCurrentCache,
+  ReactCurrentBatchConfig,
+  ReactCurrentOwner
+};
+
+function startTransition(scope, options) {
+  const prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = {};
+
+  try {
+    scope();
+  } finally {
+    ReactCurrentBatchConfig.transition = prevTransition;
+  }
+}
+
+function act(callback) {
+  {
+    throw new Error('act(...) is not supported in production builds of React.');
+  }
+}
+
+const createElement = createElement$1;
+const cloneElement = cloneElement$1;
+const createFactory = createFactory$1;
+const Children = {
+  map: mapChildren,
+  forEach: forEachChildren,
+  count: countChildren,
+  toArray,
+  only: onlyChild
+};
+
+exports.Children = Children;
+exports.Component = Component;
+exports.Fragment = REACT_FRAGMENT_TYPE;
+exports.Profiler = REACT_PROFILER_TYPE;
+exports.PureComponent = PureComponent;
+exports.StrictMode = REACT_STRICT_MODE_TYPE;
+exports.Suspense = REACT_SUSPENSE_TYPE;
+exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternals;
+exports.cache = cache;
+exports.cloneElement = cloneElement;
+exports.createContext = createContext;
+exports.createElement = createElement;
+exports.createFactory = createFactory;
+exports.createRef = createRef;
+exports.forwardRef = forwardRef;
+exports.isValidElement = isValidElement;
+exports.lazy = lazy;
+exports.memo = memo;
+exports.startTransition = startTransition;
+exports.unstable_act = act;
+exports.unstable_useCacheRefresh = useCacheRefresh;
+exports.use = use;
+exports.useCallback = useCallback;
+exports.useContext = useContext;
+exports.useDebugValue = useDebugValue;
+exports.useDeferredValue = useDeferredValue;
+exports.useEffect = useEffect;
+exports.useId = useId;
+exports.useImperativeHandle = useImperativeHandle;
+exports.useInsertionEffect = useInsertionEffect;
+exports.useLayoutEffect = useLayoutEffect;
+exports.useMemo = useMemo;
+exports.useOptimistic = useOptimistic;
+exports.useReducer = useReducer;
+exports.useRef = useRef;
+exports.useState = useState;
+exports.useSyncExternalStore = useSyncExternalStore;
+exports.useTransition = useTransition;
+exports.version = ReactVersion;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react/cjs/react.production.min.js b/packages/next/src/compiled/react/cjs/react.production.min.js
index 78e5325a093a9..1ce9646a02f0e 100644
--- a/packages/next/src/compiled/react/cjs/react.production.min.js
+++ b/packages/next/src/compiled/react/cjs/react.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var l=Symbol.for("react.element"),n=Symbol.for("react.portal"),p=Symbol.for("react.fragment"),q=Symbol.for("react.strict_mode"),r=Symbol.for("react.profiler"),t=Symbol.for("react.provider"),u=Symbol.for("react.context"),v=Symbol.for("react.forward_ref"),w=Symbol.for("react.suspense"),x=Symbol.for("react.memo"),y=Symbol.for("react.lazy"),z=Symbol.iterator;function A(a){if(null===a||"object"!==typeof a)return null;a=z&&a[z]||a["@@iterator"];return"function"===typeof a?a:null}
 var B={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},C=Object.assign,D={};function E(a,b,c){this.props=a;this.context=b;this.refs=D;this.updater=c||B}E.prototype.isReactComponent={};
 E.prototype.setState=function(a,b){if("object"!==typeof a&&"function"!==typeof a&&null!=a)throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");this.updater.enqueueSetState(this,a,b,"setState")};E.prototype.forceUpdate=function(a){this.updater.enqueueForceUpdate(this,a,"forceUpdate")};function F(){}F.prototype=E.prototype;function G(a,b,c){this.props=a;this.context=b;this.refs=D;this.updater=c||B}var H=G.prototype=new F;
@@ -26,4 +26,6 @@ for(var m=0;m<k;m++)h[m]=arguments[m+2];f.children=h}return{$$typeof:l,type:a.ty
 exports.forwardRef=function(a){return{$$typeof:v,render:a}};exports.isValidElement=O;exports.lazy=function(a){return{$$typeof:y,_payload:{_status:-1,_result:a},_init:T}};exports.memo=function(a,b){return{$$typeof:x,type:a,compare:void 0===b?null:b}};exports.startTransition=function(a){var b=Y.transition;Y.transition={};try{a()}finally{Y.transition=b}};exports.unstable_act=function(){throw Error("act(...) is not supported in production builds of React.");};exports.unstable_useCacheRefresh=function(){return X.current.useCacheRefresh()};
 exports.use=function(a){return X.current.use(a)};exports.useCallback=function(a,b){return X.current.useCallback(a,b)};exports.useContext=function(a){return X.current.useContext(a)};exports.useDebugValue=function(){};exports.useDeferredValue=function(a,b){return X.current.useDeferredValue(a,b)};exports.useEffect=function(a,b){return X.current.useEffect(a,b)};exports.useId=function(){return X.current.useId()};exports.useImperativeHandle=function(a,b,c){return X.current.useImperativeHandle(a,b,c)};
 exports.useInsertionEffect=function(a,b){return X.current.useInsertionEffect(a,b)};exports.useLayoutEffect=function(a,b){return X.current.useLayoutEffect(a,b)};exports.useMemo=function(a,b){return X.current.useMemo(a,b)};exports.useOptimistic=function(a,b){return X.current.useOptimistic(a,b)};exports.useReducer=function(a,b,c){return X.current.useReducer(a,b,c)};exports.useRef=function(a){return X.current.useRef(a)};exports.useState=function(a){return X.current.useState(a)};
-exports.useSyncExternalStore=function(a,b,c){return X.current.useSyncExternalStore(a,b,c)};exports.useTransition=function(){return X.current.useTransition()};exports.version="18.3.0-canary-2983249dd-20231107";
+exports.useSyncExternalStore=function(a,b,c){return X.current.useSyncExternalStore(a,b,c)};exports.useTransition=function(){return X.current.useTransition()};exports.version="18.3.0-canary-7508dcd5c-20231108";
+
+//# sourceMappingURL=react.production.min.js.map
diff --git a/packages/next/src/compiled/react/cjs/react.shared-subset.development.js b/packages/next/src/compiled/react/cjs/react.shared-subset.development.js
index 9cbab6610fa87..93e0e3981e1d7 100644
--- a/packages/next/src/compiled/react/cjs/react.shared-subset.development.js
+++ b/packages/next/src/compiled/react/cjs/react.shared-subset.development.js
@@ -281,7 +281,7 @@ var ReactServerSharedInternals = {
   ReactCurrentCache: ReactCurrentCache
 };
 
-var ReactVersion = '18.3.0-canary-2983249dd-20231107';
+var ReactVersion = '18.3.0-canary-7508dcd5c-20231108';
 
 // ATTENTION
 // When adding new symbols to this file,
@@ -1861,6 +1861,18 @@ var componentFrameCache;
   var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
   componentFrameCache = new PossiblyWeakMap();
 }
+/**
+ * Leverages native browser/VM stack frames to get proper details (e.g.
+ * filename, line + col number) for a single component in a component stack. We
+ * do this by:
+ *   (1) throwing and catching an error in the function - this will be our
+ *       control error.
+ *   (2) calling the component which will eventually throw an error that we'll
+ *       catch - this will be our sample error.
+ *   (3) diffing the control and sample error stacks to find the stack frame
+ *       which represents our component.
+ */
+
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
@@ -1876,7 +1888,6 @@ function describeNativeComponentFrame(fn, construct) {
     }
   }
 
-  var control;
   reentry = true;
   var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
 
@@ -1890,81 +1901,140 @@ function describeNativeComponentFrame(fn, construct) {
     ReactCurrentDispatcher.current = null;
     disableLogs();
   }
+  /**
+   * Finding a common stack frame between sample and control errors can be
+   * tricky given the different types and levels of stack trace truncation from
+   * different JS VMs. So instead we'll attempt to control what that common
+   * frame should be through this object method:
+   * Having both the sample and control errors be in the function under the
+   * `DescribeNativeComponentFrameRoot` property, + setting the `name` and
+   * `displayName` properties of the function ensures that a stack
+   * frame exists that has the method name `DescribeNativeComponentFrameRoot` in
+   * it for both control and sample stacks.
+   */
 
-  try {
-    // This should throw.
-    if (construct) {
-      // Something should be setting the props in the constructor.
-      var Fake = function () {
-        throw Error();
-      }; // $FlowFixMe[prop-missing]
 
+  var RunInRootFrame = {
+    DetermineComponentFrameRoot: function () {
+      var control;
 
-      Object.defineProperty(Fake.prototype, 'props', {
-        set: function () {
-          // We use a throwing setter instead of frozen or non-writable props
-          // because that won't throw in a non-strict mode function.
-          throw Error();
-        }
-      });
+      try {
+        // This should throw.
+        if (construct) {
+          // Something should be setting the props in the constructor.
+          var Fake = function () {
+            throw Error();
+          }; // $FlowFixMe[prop-missing]
+
+
+          Object.defineProperty(Fake.prototype, 'props', {
+            set: function () {
+              // We use a throwing setter instead of frozen or non-writable props
+              // because that won't throw in a non-strict mode function.
+              throw Error();
+            }
+          });
 
-      if (typeof Reflect === 'object' && Reflect.construct) {
-        // We construct a different control for this case to include any extra
-        // frames added by the construct call.
-        try {
-          Reflect.construct(Fake, []);
-        } catch (x) {
-          control = x;
-        }
+          if (typeof Reflect === 'object' && Reflect.construct) {
+            // We construct a different control for this case to include any extra
+            // frames added by the construct call.
+            try {
+              Reflect.construct(Fake, []);
+            } catch (x) {
+              control = x;
+            }
+
+            Reflect.construct(fn, [], Fake);
+          } else {
+            try {
+              Fake.call();
+            } catch (x) {
+              control = x;
+            } // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+            fn.call(Fake.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            control = x;
+          } // TODO(luna): This will currently only throw if the function component
+          // tries to access React/ReactDOM/props. We should probably make this throw
+          // in simple components too
 
-        Reflect.construct(fn, [], Fake);
-      } else {
-        try {
-          Fake.call();
-        } catch (x) {
-          control = x;
-        } // $FlowFixMe[prop-missing] found when upgrading Flow
 
+          var maybePromise = fn(); // If the function component returns a promise, it's likely an async
+          // component, which we don't yet support. Attach a noop catch handler to
+          // silence the error.
+          // TODO: Implement component stacks for async client components?
 
-        fn.call(Fake.prototype);
+          if (maybePromise && typeof maybePromise.catch === 'function') {
+            maybePromise.catch(function () {});
+          }
+        }
+      } catch (sample) {
+        // This is inlined manually because closure doesn't do it for us.
+        if (sample && control && typeof sample.stack === 'string') {
+          return [sample.stack, control.stack];
+        }
       }
-    } else {
-      try {
-        throw Error();
-      } catch (x) {
-        control = x;
-      } // TODO(luna): This will currently only throw if the function component
-      // tries to access React/ReactDOM/props. We should probably make this throw
-      // in simple components too
 
+      return [null, null];
+    }
+  }; // $FlowFixMe[prop-missing]
 
-      var maybePromise = fn(); // If the function component returns a promise, it's likely an async
-      // component, which we don't yet support. Attach a noop catch handler to
-      // silence the error.
-      // TODO: Implement component stacks for async client components?
+  RunInRootFrame.DetermineComponentFrameRoot.displayName = 'DetermineComponentFrameRoot';
+  var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, 'name'); // Before ES6, the `name` property was not configurable.
 
-      if (maybePromise && typeof maybePromise.catch === 'function') {
-        maybePromise.catch(function () {});
-      }
-    }
-  } catch (sample) {
-    // This is inlined manually because closure doesn't do it for us.
-    if (sample && control && typeof sample.stack === 'string') {
+  if (namePropDescriptor && namePropDescriptor.configurable) {
+    // V8 utilizes a function's `name` property when generating a stack trace.
+    Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
+    // is set to `false`.
+    // $FlowFixMe[cannot-write]
+    'name', {
+      value: 'DetermineComponentFrameRoot'
+    });
+  }
+
+  try {
+    var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
+
+    if (sampleStack && controlStack) {
       // This extracts the first frame from the sample that isn't also in the control.
       // Skipping one frame that we assume is the frame that calls the two.
-      var sampleLines = sample.stack.split('\n');
-      var controlLines = control.stack.split('\n');
-      var s = sampleLines.length - 1;
-      var c = controlLines.length - 1;
-
-      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
-        // We expect at least one stack frame to be shared.
-        // Typically this will be the root most one. However, stack frames may be
-        // cut off due to maximum stack limits. In this case, one maybe cut off
-        // earlier than the other. We assume that the sample is longer or the same
-        // and there for cut off earlier. So we should find the root most frame in
-        // the sample somewhere in the control.
-        c--;
+      var sampleLines = sampleStack.split('\n');
+      var controlLines = controlStack.split('\n');
+      var s = 0;
+      var c = 0;
+
+      while (s < sampleLines.length && !sampleLines[s].includes('DetermineComponentFrameRoot')) {
+        s++;
+      }
+
+      while (c < controlLines.length && !controlLines[c].includes('DetermineComponentFrameRoot')) {
+        c++;
+      } // We couldn't find our intentionally injected common root frame, attempt
+      // to find another common root frame by search from the bottom of the
+      // control stack...
+
+
+      if (s === sampleLines.length || c === controlLines.length) {
+        s = sampleLines.length - 1;
+        c = controlLines.length - 1;
+
+        while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+          // We expect at least one stack frame to be shared.
+          // Typically this will be the root most one. However, stack frames may be
+          // cut off due to maximum stack limits. In this case, one maybe cut off
+          // earlier than the other. We assume that the sample is longer or the same
+          // and there for cut off earlier. So we should find the root most frame in
+          // the sample somewhere in the control.
+          c--;
+        }
       }
 
       for (; s >= 1 && c >= 0; s--, c--) {
@@ -1993,7 +2063,7 @@ function describeNativeComponentFrame(fn, construct) {
                   _frame = _frame.replace('<anonymous>', fn.displayName);
                 }
 
-                {
+                if (true) {
                   if (typeof fn === 'function') {
                     componentFrameCache.set(fn, _frame);
                   }
diff --git a/packages/next/src/compiled/react/cjs/react.shared-subset.production.js b/packages/next/src/compiled/react/cjs/react.shared-subset.production.js
new file mode 100644
index 0000000000000..b865b6c379276
--- /dev/null
+++ b/packages/next/src/compiled/react/cjs/react.shared-subset.production.js
@@ -0,0 +1,1107 @@
+/**
+ * @license React
+ * react.shared-subset.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+const assign = Object.assign;
+
+/**
+ * Keeps track of the current Cache dispatcher.
+ */
+const ReactCurrentCache = {
+  current: null
+};
+
+function createFetchCache() {
+  return new Map();
+}
+
+const simpleCacheKey = '["GET",[],null,"follow",null,null,null,null]'; // generateCacheKey(new Request('https://blank'));
+
+function generateCacheKey(request) {
+  // We pick the fields that goes into the key used to dedupe requests.
+  // We don't include the `cache` field, because we end up using whatever
+  // caching resulted from the first request.
+  // Notably we currently don't consider non-standard (or future) options.
+  // This might not be safe. TODO: warn for non-standard extensions differing.
+  // IF YOU CHANGE THIS UPDATE THE simpleCacheKey ABOVE.
+  return JSON.stringify([request.method, Array.from(request.headers.entries()), request.mode, request.redirect, request.credentials, request.referrer, request.referrerPolicy, request.integrity]);
+}
+
+{
+  if (typeof fetch === 'function') {
+    const originalFetch = fetch;
+
+    const cachedFetch = function fetch(resource, options) {
+      const dispatcher = ReactCurrentCache.current;
+
+      if (!dispatcher) {
+        // We're outside a cached scope.
+        return originalFetch(resource, options);
+      }
+
+      if (options && options.signal && options.signal !== dispatcher.getCacheSignal()) {
+        // If we're passed a signal that is not ours, then we assume that
+        // someone else controls the lifetime of this object and opts out of
+        // caching. It's effectively the opt-out mechanism.
+        // Ideally we should be able to check this on the Request but
+        // it always gets initialized with its own signal so we don't
+        // know if it's supposed to override - unless we also override the
+        // Request constructor.
+        return originalFetch(resource, options);
+      } // Normalize the Request
+
+
+      let url;
+      let cacheKey;
+
+      if (typeof resource === 'string' && !options) {
+        // Fast path.
+        cacheKey = simpleCacheKey;
+        url = resource;
+      } else {
+        // Normalize the request.
+        // if resource is not a string or a URL (its an instance of Request)
+        // then do not instantiate a new Request but instead
+        // reuse the request as to not disturb the body in the event it's a ReadableStream.
+        const request = typeof resource === 'string' || resource instanceof URL ? new Request(resource, options) : resource;
+
+        if (request.method !== 'GET' && request.method !== 'HEAD' || // $FlowFixMe[prop-missing]: keepalive is real
+        request.keepalive) {
+          // We currently don't dedupe requests that might have side-effects. Those
+          // have to be explicitly cached. We assume that the request doesn't have a
+          // body if it's GET or HEAD.
+          // keepalive gets treated the same as if you passed a custom cache signal.
+          return originalFetch(resource, options);
+        }
+
+        cacheKey = generateCacheKey(request);
+        url = request.url;
+      }
+
+      const cache = dispatcher.getCacheForType(createFetchCache);
+      const cacheEntries = cache.get(url);
+      let match;
+
+      if (cacheEntries === undefined) {
+        // We pass the original arguments here in case normalizing the Request
+        // doesn't include all the options in this environment.
+        match = originalFetch(resource, options);
+        cache.set(url, [cacheKey, match]);
+      } else {
+        // We use an array as the inner data structure since it's lighter and
+        // we typically only expect to see one or two entries here.
+        for (let i = 0, l = cacheEntries.length; i < l; i += 2) {
+          const key = cacheEntries[i];
+          const value = cacheEntries[i + 1];
+
+          if (key === cacheKey) {
+            match = value; // I would've preferred a labelled break but lint says no.
+
+            return match.then(response => response.clone());
+          }
+        }
+
+        match = originalFetch(resource, options);
+        cacheEntries.push(cacheKey, match);
+      } // We clone the response so that each time you call this you get a new read
+      // of the body so that it can be read multiple times.
+
+
+      return match.then(response => response.clone());
+    }; // We don't expect to see any extra properties on fetch but if there are any,
+    // copy them over. Useful for extended fetch environments or mocks.
+
+
+    assign(cachedFetch, originalFetch);
+
+    try {
+      // eslint-disable-next-line no-native-reassign
+      fetch = cachedFetch;
+    } catch (error1) {
+      try {
+        // In case assigning it globally fails, try globalThis instead just in case it exists.
+        globalThis.fetch = cachedFetch;
+      } catch (error2) {
+        // Log even in production just to make sure this is seen if only prod is frozen.
+        // eslint-disable-next-line react-internal/no-production-logging
+        console.warn('React was unable to patch the fetch() function in this environment. ' + 'Suspensey APIs might not work correctly as a result.');
+      }
+    }
+  }
+}
+
+/**
+ * Keeps track of the current dispatcher.
+ */
+const ReactCurrentDispatcher = {
+  current: null
+};
+
+/**
+ * Keeps track of the current owner.
+ *
+ * The current owner is the component who should own any components that are
+ * currently being constructed.
+ */
+const ReactCurrentOwner = {
+  /**
+   * @internal
+   * @type {ReactComponent}
+   */
+  current: null
+};
+
+const ReactSharedInternals = {
+  ReactCurrentDispatcher,
+  ReactCurrentOwner
+};
+
+const ReactServerSharedInternals = {
+  ReactCurrentCache
+};
+
+var ReactVersion = '18.3.0-canary-7508dcd5c-20231108';
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+const REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+const REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+const REACT_MEMO_TYPE = Symbol.for('react.memo');
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+const FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+// Do not require this module directly! Use normal `invariant` calls with
+// template literal strings. The messages will be replaced with error codes
+// during build.
+function formatProdErrorMessage(code) {
+  let url = 'https://reactjs.org/docs/error-decoder.html?invariant=' + code;
+
+  for (let i = 1; i < arguments.length; i++) {
+    url += '&args[]=' + encodeURIComponent(arguments[i]);
+  }
+
+  return "Minified React error #" + code + "; visit " + url + " for the full message or " + 'use the non-minified dev environment for full errors and additional ' + 'helpful warnings.';
+}
+
+/**
+ * This is the abstract API for an update queue.
+ */
+
+
+const ReactNoopUpdateQueue = {
+  /**
+   * Checks whether or not this composite component is mounted.
+   * @param {ReactClass} publicInstance The instance we want to test.
+   * @return {boolean} True if mounted, false otherwise.
+   * @protected
+   * @final
+   */
+  isMounted: function (publicInstance) {
+    return false;
+  },
+
+  /**
+   * Forces an update. This should only be invoked when it is known with
+   * certainty that we are **not** in a DOM transaction.
+   *
+   * You may want to call this when you know that some deeper aspect of the
+   * component's state has changed but `setState` was not called.
+   *
+   * This will not invoke `shouldComponentUpdate`, but it will invoke
+   * `componentWillUpdate` and `componentDidUpdate`.
+   *
+   * @param {ReactClass} publicInstance The instance that should rerender.
+   * @param {?function} callback Called after component is updated.
+   * @param {?string} callerName name of the calling function in the public API.
+   * @internal
+   */
+  enqueueForceUpdate: function (publicInstance, callback, callerName) {
+  },
+
+  /**
+   * Replaces all of the state. Always use this or `setState` to mutate state.
+   * You should treat `this.state` as immutable.
+   *
+   * There is no guarantee that `this.state` will be immediately updated, so
+   * accessing `this.state` after calling this method may return the old value.
+   *
+   * @param {ReactClass} publicInstance The instance that should rerender.
+   * @param {object} completeState Next state.
+   * @param {?function} callback Called after component is updated.
+   * @param {?string} callerName name of the calling function in the public API.
+   * @internal
+   */
+  enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {
+  },
+
+  /**
+   * Sets a subset of the state. This only exists because _pendingState is
+   * internal. This provides a merging strategy that is not available to deep
+   * properties which is confusing. TODO: Expose pendingState or don't use it
+   * during the merge.
+   *
+   * @param {ReactClass} publicInstance The instance that should rerender.
+   * @param {object} partialState Next partial state to be merged with state.
+   * @param {?function} callback Called after component is updated.
+   * @param {?string} Name of the calling function in the public API.
+   * @internal
+   */
+  enqueueSetState: function (publicInstance, partialState, callback, callerName) {
+  }
+};
+
+const emptyObject = {};
+/**
+ * Base class helpers for the updating state of a component.
+ */
+
+
+function Component(props, context, updater) {
+  this.props = props;
+  this.context = context; // If a component has string refs, we will assign a different object later.
+
+  this.refs = emptyObject; // We initialize the default updater but the real one gets injected by the
+  // renderer.
+
+  this.updater = updater || ReactNoopUpdateQueue;
+}
+
+Component.prototype.isReactComponent = {};
+/**
+ * Sets a subset of the state. Always use this to mutate
+ * state. You should treat `this.state` as immutable.
+ *
+ * There is no guarantee that `this.state` will be immediately updated, so
+ * accessing `this.state` after calling this method may return the old value.
+ *
+ * There is no guarantee that calls to `setState` will run synchronously,
+ * as they may eventually be batched together.  You can provide an optional
+ * callback that will be executed when the call to setState is actually
+ * completed.
+ *
+ * When a function is provided to setState, it will be called at some point in
+ * the future (not synchronously). It will be called with the up to date
+ * component arguments (state, props, context). These values can be different
+ * from this.* because your function may be called after receiveProps but before
+ * shouldComponentUpdate, and this new state, props, and context will not yet be
+ * assigned to this.
+ *
+ * @param {object|function} partialState Next partial state or function to
+ *        produce next partial state to be merged with current state.
+ * @param {?function} callback Called after state is updated.
+ * @final
+ * @protected
+ */
+
+Component.prototype.setState = function (partialState, callback) {
+  if (typeof partialState !== 'object' && typeof partialState !== 'function' && partialState != null) {
+    throw Error(formatProdErrorMessage(85));
+  }
+
+  this.updater.enqueueSetState(this, partialState, callback, 'setState');
+};
+/**
+ * Forces an update. This should only be invoked when it is known with
+ * certainty that we are **not** in a DOM transaction.
+ *
+ * You may want to call this when you know that some deeper aspect of the
+ * component's state has changed but `setState` was not called.
+ *
+ * This will not invoke `shouldComponentUpdate`, but it will invoke
+ * `componentWillUpdate` and `componentDidUpdate`.
+ *
+ * @param {?function} callback Called after update is complete.
+ * @final
+ * @protected
+ */
+
+
+Component.prototype.forceUpdate = function (callback) {
+  this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');
+};
+
+function ComponentDummy() {}
+
+ComponentDummy.prototype = Component.prototype;
+/**
+ * Convenience component with default shallow equality check for sCU.
+ */
+
+function PureComponent(props, context, updater) {
+  this.props = props;
+  this.context = context; // If a component has string refs, we will assign a different object later.
+
+  this.refs = emptyObject;
+  this.updater = updater || ReactNoopUpdateQueue;
+}
+
+const pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
+pureComponentPrototype.constructor = PureComponent; // Avoid an extra prototype jump for these methods.
+
+assign(pureComponentPrototype, Component.prototype);
+pureComponentPrototype.isPureReactComponent = true;
+
+// an immutable object with a single mutable value
+function createRef() {
+  const refObject = {
+    current: null
+  };
+
+  return refObject;
+}
+
+const isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+// $FlowFixMe[method-unbinding]
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+const RESERVED_PROPS = {
+  key: true,
+  ref: true,
+  __self: true,
+  __source: true
+};
+
+function hasValidRef(config) {
+
+  return config.ref !== undefined;
+}
+
+function hasValidKey(config) {
+
+  return config.key !== undefined;
+}
+/**
+ * Factory method to create a new React element. This no longer adheres to
+ * the class pattern, so do not use new to call it. Also, instanceof check
+ * will not work. Instead test $$typeof field against Symbol.for('react.element') to check
+ * if something is a React Element.
+ *
+ * @param {*} type
+ * @param {*} props
+ * @param {*} key
+ * @param {string|object} ref
+ * @param {*} owner
+ * @param {*} self A *temporary* helper to detect places where `this` is
+ * different from the `owner` when React.createElement is called, so that we
+ * can warn. We want to get rid of owner and replace string `ref`s with arrow
+ * functions, and as long as `this` and owner are the same, there will be no
+ * change in behavior.
+ * @param {*} source An annotation object (added by a transpiler or otherwise)
+ * indicating filename, line number, and/or other information.
+ * @internal
+ */
+
+
+function ReactElement(type, key, ref, self, source, owner, props) {
+  const element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: ref,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: owner
+  };
+
+  return element;
+}
+/**
+ * Create and return a new ReactElement of the given type.
+ * See https://reactjs.org/docs/react-api.html#createelement
+ */
+
+function createElement$1(type, config, children) {
+  let propName; // Reserved names are extracted
+
+  const props = {};
+  let key = null;
+  let ref = null;
+  let self = null;
+  let source = null;
+
+  if (config != null) {
+    if (hasValidRef(config)) {
+      ref = config.ref;
+    }
+
+    if (hasValidKey(config)) {
+
+      key = '' + config.key;
+    }
+
+    self = config.__self === undefined ? null : config.__self;
+    source = config.__source === undefined ? null : config.__source; // Remaining properties are added to a new props object
+
+    for (propName in config) {
+      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+        props[propName] = config[propName];
+      }
+    }
+  } // Children can be more than one argument, and those are transferred onto
+  // the newly allocated props object.
+
+
+  const childrenLength = arguments.length - 2;
+
+  if (childrenLength === 1) {
+    props.children = children;
+  } else if (childrenLength > 1) {
+    const childArray = Array(childrenLength);
+
+    for (let i = 0; i < childrenLength; i++) {
+      childArray[i] = arguments[i + 2];
+    }
+
+    props.children = childArray;
+  } // Resolve default props
+
+
+  if (type && type.defaultProps) {
+    const defaultProps = type.defaultProps;
+
+    for (propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+  }
+
+  return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
+}
+function cloneAndReplaceKey(oldElement, newKey) {
+  const newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
+  return newElement;
+}
+/**
+ * Clone and return a new ReactElement using element as the starting point.
+ * See https://reactjs.org/docs/react-api.html#cloneelement
+ */
+
+function cloneElement$1(element, config, children) {
+  if (element === null || element === undefined) {
+    throw Error(formatProdErrorMessage(267, element));
+  }
+
+  let propName; // Original props are copied
+
+  const props = assign({}, element.props); // Reserved names are extracted
+
+  let key = element.key;
+  let ref = element.ref; // Self is preserved since the owner is preserved.
+
+  const self = element._self; // Source is preserved since cloneElement is unlikely to be targeted by a
+  // transpiler, and the original source is probably a better indicator of the
+  // true owner.
+
+  const source = element._source; // Owner will be preserved, unless ref is overridden
+
+  let owner = element._owner;
+
+  if (config != null) {
+    if (hasValidRef(config)) {
+      // Silently steal the ref from the parent.
+      ref = config.ref;
+      owner = ReactCurrentOwner.current;
+    }
+
+    if (hasValidKey(config)) {
+
+      key = '' + config.key;
+    } // Remaining properties override existing props
+
+
+    let defaultProps;
+
+    if (element.type && element.type.defaultProps) {
+      defaultProps = element.type.defaultProps;
+    }
+
+    for (propName in config) {
+      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+        if (config[propName] === undefined && defaultProps !== undefined) {
+          // Resolve default props
+          props[propName] = defaultProps[propName];
+        } else {
+          props[propName] = config[propName];
+        }
+      }
+    }
+  } // Children can be more than one argument, and those are transferred onto
+  // the newly allocated props object.
+
+
+  const childrenLength = arguments.length - 2;
+
+  if (childrenLength === 1) {
+    props.children = children;
+  } else if (childrenLength > 1) {
+    const childArray = Array(childrenLength);
+
+    for (let i = 0; i < childrenLength; i++) {
+      childArray[i] = arguments[i + 2];
+    }
+
+    props.children = childArray;
+  }
+
+  return ReactElement(element.type, key, ref, self, source, owner, props);
+}
+/**
+ * Verifies the object is a ReactElement.
+ * See https://reactjs.org/docs/react-api.html#isvalidelement
+ * @param {?object} object
+ * @return {boolean} True if `object` is a ReactElement.
+ * @final
+ */
+
+function isValidElement(object) {
+  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+}
+
+const SEPARATOR = '.';
+const SUBSEPARATOR = ':';
+/**
+ * Escape and wrap key so it is safe to use as a reactid
+ *
+ * @param {string} key to be escaped.
+ * @return {string} the escaped key.
+ */
+
+function escape(key) {
+  const escapeRegex = /[=:]/g;
+  const escaperLookup = {
+    '=': '=0',
+    ':': '=2'
+  };
+  const escapedString = key.replace(escapeRegex, function (match) {
+    return escaperLookup[match];
+  });
+  return '$' + escapedString;
+}
+const userProvidedKeyEscapeRegex = /\/+/g;
+
+function escapeUserProvidedKey(text) {
+  return text.replace(userProvidedKeyEscapeRegex, '$&/');
+}
+/**
+ * Generate a key string that identifies a element within a set.
+ *
+ * @param {*} element A element that could contain a manual key.
+ * @param {number} index Index that is used if a manual key is not provided.
+ * @return {string}
+ */
+
+
+function getElementKey(element, index) {
+  // Do some typechecking here since we call this blindly. We want to ensure
+  // that we don't block potential future ES APIs.
+  if (typeof element === 'object' && element !== null && element.key != null) {
+
+    return escape('' + element.key);
+  } // Implicit key determined by the index in the set
+
+
+  return index.toString(36);
+}
+
+function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
+  const type = typeof children;
+
+  if (type === 'undefined' || type === 'boolean') {
+    // All of the above are perceived as null.
+    children = null;
+  }
+
+  let invokeCallback = false;
+
+  if (children === null) {
+    invokeCallback = true;
+  } else {
+    switch (type) {
+      case 'string':
+      case 'number':
+        invokeCallback = true;
+        break;
+
+      case 'object':
+        switch (children.$$typeof) {
+          case REACT_ELEMENT_TYPE:
+          case REACT_PORTAL_TYPE:
+            invokeCallback = true;
+        }
+
+    }
+  }
+
+  if (invokeCallback) {
+    const child = children;
+    let mappedChild = callback(child); // If it's the only child, treat the name as if it was wrapped in an array
+    // so that it's consistent if the number of children grows:
+
+    const childKey = nameSoFar === '' ? SEPARATOR + getElementKey(child, 0) : nameSoFar;
+
+    if (isArray(mappedChild)) {
+      let escapedChildKey = '';
+
+      if (childKey != null) {
+        escapedChildKey = escapeUserProvidedKey(childKey) + '/';
+      }
+
+      mapIntoArray(mappedChild, array, escapedChildKey, '', c => c);
+    } else if (mappedChild != null) {
+      if (isValidElement(mappedChild)) {
+
+        mappedChild = cloneAndReplaceKey(mappedChild, // Keep both the (mapped) and old keys if they differ, just as
+        // traverseAllChildren used to do for objects as children
+        escapedPrefix + ( // $FlowFixMe[incompatible-type] Flow incorrectly thinks React.Portal doesn't have a key
+        mappedChild.key && (!child || child.key !== mappedChild.key) ? escapeUserProvidedKey( // $FlowFixMe[unsafe-addition]
+        '' + mappedChild.key // eslint-disable-line react-internal/safe-string-coercion
+        ) + '/' : '') + childKey);
+      }
+
+      array.push(mappedChild);
+    }
+
+    return 1;
+  }
+
+  let child;
+  let nextName;
+  let subtreeCount = 0; // Count of children found in the current subtree.
+
+  const nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;
+
+  if (isArray(children)) {
+    for (let i = 0; i < children.length; i++) {
+      child = children[i];
+      nextName = nextNamePrefix + getElementKey(child, i);
+      subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
+    }
+  } else {
+    const iteratorFn = getIteratorFn(children);
+
+    if (typeof iteratorFn === 'function') {
+      const iterableChildren = children;
+
+      const iterator = iteratorFn.call(iterableChildren);
+      let step;
+      let ii = 0; // $FlowFixMe[incompatible-use] `iteratorFn` might return null according to typing.
+
+      while (!(step = iterator.next()).done) {
+        child = step.value;
+        nextName = nextNamePrefix + getElementKey(child, ii++);
+        subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
+      }
+    } else if (type === 'object') {
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      const childrenString = String(children);
+      throw Error(formatProdErrorMessage(31, childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString));
+    }
+  }
+
+  return subtreeCount;
+}
+/**
+ * Maps children that are typically specified as `props.children`.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrenmap
+ *
+ * The provided mapFunction(child, index) will be called for each
+ * leaf child.
+ *
+ * @param {?*} children Children tree container.
+ * @param {function(*, int)} func The map function.
+ * @param {*} context Context for mapFunction.
+ * @return {object} Object containing the ordered map of results.
+ */
+
+
+function mapChildren(children, func, context) {
+  if (children == null) {
+    return children;
+  }
+
+  const result = [];
+  let count = 0;
+  mapIntoArray(children, result, '', '', function (child) {
+    return func.call(context, child, count++);
+  });
+  return result;
+}
+/**
+ * Count the number of children that are typically specified as
+ * `props.children`.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrencount
+ *
+ * @param {?*} children Children tree container.
+ * @return {number} The number of children.
+ */
+
+
+function countChildren(children) {
+  let n = 0;
+  mapChildren(children, () => {
+    n++; // Don't return anything
+  });
+  return n;
+}
+/**
+ * Iterates through children that are typically specified as `props.children`.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrenforeach
+ *
+ * The provided forEachFunc(child, index) will be called for each
+ * leaf child.
+ *
+ * @param {?*} children Children tree container.
+ * @param {function(*, int)} forEachFunc
+ * @param {*} forEachContext Context for forEachContext.
+ */
+
+
+function forEachChildren(children, forEachFunc, forEachContext) {
+  mapChildren(children, // $FlowFixMe[missing-this-annot]
+  function () {
+    forEachFunc.apply(this, arguments); // Don't return anything.
+  }, forEachContext);
+}
+/**
+ * Flatten a children object (typically specified as `props.children`) and
+ * return an array with appropriately re-keyed children.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrentoarray
+ */
+
+
+function toArray(children) {
+  return mapChildren(children, child => child) || [];
+}
+/**
+ * Returns the first child in a collection of children and verifies that there
+ * is only one child in the collection.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrenonly
+ *
+ * The current implementation of this function assumes that a single child gets
+ * passed without a wrapper, but the purpose of this helper function is to
+ * abstract away the particular structure of children.
+ *
+ * @param {?object} children Child collection structure.
+ * @return {ReactElement} The first and only `ReactElement` contained in the
+ * structure.
+ */
+
+
+function onlyChild(children) {
+  if (!isValidElement(children)) {
+    throw Error(formatProdErrorMessage(143));
+  }
+
+  return children;
+}
+
+const Uninitialized = -1;
+const Pending = 0;
+const Resolved = 1;
+const Rejected = 2;
+
+function lazyInitializer(payload) {
+  if (payload._status === Uninitialized) {
+    const ctor = payload._result;
+    const thenable = ctor(); // Transition to the next state.
+    // This might throw either because it's missing or throws. If so, we treat it
+    // as still uninitialized and try again next time. Which is the same as what
+    // happens if the ctor or any wrappers processing the ctor throws. This might
+    // end up fixing it if the resolution was a concurrency bug.
+
+    thenable.then(moduleObject => {
+      if (payload._status === Pending || payload._status === Uninitialized) {
+        // Transition to the next state.
+        const resolved = payload;
+        resolved._status = Resolved;
+        resolved._result = moduleObject;
+      }
+    }, error => {
+      if (payload._status === Pending || payload._status === Uninitialized) {
+        // Transition to the next state.
+        const rejected = payload;
+        rejected._status = Rejected;
+        rejected._result = error;
+      }
+    });
+
+    if (payload._status === Uninitialized) {
+      // In case, we're still uninitialized, then we're waiting for the thenable
+      // to resolve. Set it as pending in the meantime.
+      const pending = payload;
+      pending._status = Pending;
+      pending._result = thenable;
+    }
+  }
+
+  if (payload._status === Resolved) {
+    const moduleObject = payload._result;
+
+    return moduleObject.default;
+  } else {
+    throw payload._result;
+  }
+}
+
+function lazy(ctor) {
+  const payload = {
+    // We use these fields to store the result.
+    _status: Uninitialized,
+    _result: ctor
+  };
+  const lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: payload,
+    _init: lazyInitializer
+  };
+
+  return lazyType;
+}
+
+function forwardRef(render) {
+
+  const elementType = {
+    $$typeof: REACT_FORWARD_REF_TYPE,
+    render
+  };
+
+  return elementType;
+}
+
+function memo(type, compare) {
+
+  const elementType = {
+    $$typeof: REACT_MEMO_TYPE,
+    type,
+    compare: compare === undefined ? null : compare
+  };
+
+  return elementType;
+}
+
+const UNTERMINATED = 0;
+const TERMINATED = 1;
+const ERRORED = 2;
+
+function createCacheRoot() {
+  return new WeakMap();
+}
+
+function createCacheNode() {
+  return {
+    s: UNTERMINATED,
+    // status, represents whether the cached computation returned a value or threw an error
+    v: undefined,
+    // value, either the cached result or an error, depending on s
+    o: null,
+    // object cache, a WeakMap where non-primitive arguments are stored
+    p: null // primitive cache, a regular Map where primitive arguments are stored.
+
+  };
+}
+
+function cache(fn) {
+  return function () {
+    const dispatcher = ReactCurrentCache.current;
+
+    if (!dispatcher) {
+      // If there is no dispatcher, then we treat this as not being cached.
+      // $FlowFixMe[incompatible-call]: We don't want to use rest arguments since we transpile the code.
+      return fn.apply(null, arguments);
+    }
+
+    const fnMap = dispatcher.getCacheForType(createCacheRoot);
+    const fnNode = fnMap.get(fn);
+    let cacheNode;
+
+    if (fnNode === undefined) {
+      cacheNode = createCacheNode();
+      fnMap.set(fn, cacheNode);
+    } else {
+      cacheNode = fnNode;
+    }
+
+    for (let i = 0, l = arguments.length; i < l; i++) {
+      const arg = arguments[i];
+
+      if (typeof arg === 'function' || typeof arg === 'object' && arg !== null) {
+        // Objects go into a WeakMap
+        let objectCache = cacheNode.o;
+
+        if (objectCache === null) {
+          cacheNode.o = objectCache = new WeakMap();
+        }
+
+        const objectNode = objectCache.get(arg);
+
+        if (objectNode === undefined) {
+          cacheNode = createCacheNode();
+          objectCache.set(arg, cacheNode);
+        } else {
+          cacheNode = objectNode;
+        }
+      } else {
+        // Primitives go into a regular Map
+        let primitiveCache = cacheNode.p;
+
+        if (primitiveCache === null) {
+          cacheNode.p = primitiveCache = new Map();
+        }
+
+        const primitiveNode = primitiveCache.get(arg);
+
+        if (primitiveNode === undefined) {
+          cacheNode = createCacheNode();
+          primitiveCache.set(arg, cacheNode);
+        } else {
+          cacheNode = primitiveNode;
+        }
+      }
+    }
+
+    if (cacheNode.s === TERMINATED) {
+      return cacheNode.v;
+    }
+
+    if (cacheNode.s === ERRORED) {
+      throw cacheNode.v;
+    }
+
+    try {
+      // $FlowFixMe[incompatible-call]: We don't want to use rest arguments since we transpile the code.
+      const result = fn.apply(null, arguments);
+      const terminatedNode = cacheNode;
+      terminatedNode.s = TERMINATED;
+      terminatedNode.v = result;
+      return result;
+    } catch (error) {
+      // We store the first error that's thrown and rethrow it.
+      const erroredNode = cacheNode;
+      erroredNode.s = ERRORED;
+      erroredNode.v = error;
+      throw error;
+    }
+  };
+}
+
+function resolveDispatcher() {
+  const dispatcher = ReactCurrentDispatcher.current;
+  // intentionally don't throw our own error because this is in a hot path.
+  // Also helps ensure this is inlined.
+
+
+  return dispatcher;
+}
+function useContext(Context) {
+  const dispatcher = resolveDispatcher();
+
+  return dispatcher.useContext(Context);
+}
+function useCallback(callback, deps) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useCallback(callback, deps);
+}
+function useMemo(create, deps) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useMemo(create, deps);
+}
+function useDebugValue(value, formatterFn) {
+}
+function useId() {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.useId();
+}
+function use(usable) {
+  const dispatcher = resolveDispatcher();
+  return dispatcher.use(usable);
+}
+
+function createServerContext(globalName, defaultValue) {
+  {
+    throw Error(formatProdErrorMessage(248));
+  }
+}
+
+function startTransition(scope, options) {
+
+  try {
+    scope();
+  } finally {
+  }
+}
+
+const createElement = createElement$1;
+const cloneElement = cloneElement$1;
+const Children = {
+  map: mapChildren,
+  forEach: forEachChildren,
+  count: countChildren,
+  toArray,
+  only: onlyChild
+};
+
+exports.Children = Children;
+exports.Fragment = REACT_FRAGMENT_TYPE;
+exports.Profiler = REACT_PROFILER_TYPE;
+exports.StrictMode = REACT_STRICT_MODE_TYPE;
+exports.Suspense = REACT_SUSPENSE_TYPE;
+exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternals;
+exports.__SECRET_SERVER_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactServerSharedInternals;
+exports.cache = cache;
+exports.cloneElement = cloneElement;
+exports.createElement = createElement;
+exports.createRef = createRef;
+exports.createServerContext = createServerContext;
+exports.forwardRef = forwardRef;
+exports.isValidElement = isValidElement;
+exports.lazy = lazy;
+exports.memo = memo;
+exports.startTransition = startTransition;
+exports.use = use;
+exports.useCallback = useCallback;
+exports.useContext = useContext;
+exports.useDebugValue = useDebugValue;
+exports.useId = useId;
+exports.useMemo = useMemo;
+exports.version = ReactVersion;
\ No newline at end of file
diff --git a/packages/next/src/compiled/react/cjs/react.shared-subset.production.min.js b/packages/next/src/compiled/react/cjs/react.shared-subset.production.min.js
index 4d27f3e73d5c0..060d90520b2d6 100644
--- a/packages/next/src/compiled/react/cjs/react.shared-subset.production.min.js
+++ b/packages/next/src/compiled/react/cjs/react.shared-subset.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * react.shared-subset.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ react.shared-subset.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var m=Object.assign,n={current:null};function p(){return new Map}
 if("function"===typeof fetch){var q=fetch,r=function(a,b){var d=n.current;if(!d||b&&b.signal&&b.signal!==d.getCacheSignal())return q(a,b);if("string"!==typeof a||b){var c="string"===typeof a||a instanceof URL?new Request(a,b):a;if("GET"!==c.method&&"HEAD"!==c.method||c.keepalive)return q(a,b);var e=JSON.stringify([c.method,Array.from(c.headers.entries()),c.mode,c.redirect,c.credentials,c.referrer,c.referrerPolicy,c.integrity]);c=c.url}else e='["GET",[],null,"follow",null,null,null,null]',c=a;var f=
 d.getCacheForType(p);d=f.get(c);if(void 0===d)a=q(a,b),f.set(c,[e,a]);else{c=0;for(f=d.length;c<f;c+=2){var h=d[c+1];if(d[c]===e)return a=h,a.then(function(g){return g.clone()})}a=q(a,b);d.push(e,a)}return a.then(function(g){return g.clone()})};m(r,q);try{fetch=r}catch(a){try{globalThis.fetch=r}catch(b){console.warn("React was unable to patch the fetch() function in this environment. Suspensey APIs might not work correctly as a result.")}}}
@@ -24,4 +24,6 @@ arguments);d=b;d.s=1;return d.v=h}catch(g){throw h=b,h.s=2,h.v=g,g;}}};
 exports.cloneElement=function(a,b,d){if(null===a||void 0===a)throw Error(I(267,a));var c=m({},a.props),e=a.key,f=a.ref,h=a._owner;if(null!=b){void 0!==b.ref&&(f=b.ref,h=u.current);void 0!==b.key&&(e=""+b.key);if(a.type&&a.type.defaultProps)var g=a.type.defaultProps;for(k in b)Q.call(b,k)&&!R.hasOwnProperty(k)&&(c[k]=void 0===b[k]&&void 0!==g?g[k]:b[k])}var k=arguments.length-2;if(1===k)c.children=d;else if(1<k){g=Array(k);for(var l=0;l<k;l++)g[l]=arguments[l+2];c.children=g}return{$$typeof:x,type:a.type,
 key:e,ref:f,props:c,_owner:h}};exports.createElement=function(a,b,d){var c,e={},f=null,h=null;if(null!=b)for(c in void 0!==b.ref&&(h=b.ref),void 0!==b.key&&(f=""+b.key),b)Q.call(b,c)&&!R.hasOwnProperty(c)&&(e[c]=b[c]);var g=arguments.length-2;if(1===g)e.children=d;else if(1<g){for(var k=Array(g),l=0;l<g;l++)k[l]=arguments[l+2];e.children=k}if(a&&a.defaultProps)for(c in g=a.defaultProps,g)void 0===e[c]&&(e[c]=g[c]);return{$$typeof:x,type:a,key:f,ref:h,props:e,_owner:u.current}};exports.createRef=function(){return{current:null}};
 exports.createServerContext=function(){throw Error(I(248));};exports.forwardRef=function(a){return{$$typeof:C,render:a}};exports.isValidElement=T;exports.lazy=function(a){return{$$typeof:F,_payload:{_status:-1,_result:a},_init:Y}};exports.memo=function(a,b){return{$$typeof:E,type:a,compare:void 0===b?null:b}};exports.startTransition=function(a){a()};exports.use=function(a){return t.current.use(a)};exports.useCallback=function(a,b){return t.current.useCallback(a,b)};exports.useContext=function(a){return t.current.useContext(a)};
-exports.useDebugValue=function(){};exports.useId=function(){return t.current.useId()};exports.useMemo=function(a,b){return t.current.useMemo(a,b)};exports.version="18.3.0-canary-2983249dd-20231107";
+exports.useDebugValue=function(){};exports.useId=function(){return t.current.useId()};exports.useMemo=function(a,b){return t.current.useMemo(a,b)};exports.version="18.3.0-canary-7508dcd5c-20231108";
+
+//# sourceMappingURL=react.shared-subset.production.min.js.map
diff --git a/packages/next/src/compiled/scheduler-experimental/cjs/scheduler-unstable_mock.production.js b/packages/next/src/compiled/scheduler-experimental/cjs/scheduler-unstable_mock.production.js
new file mode 100644
index 0000000000000..37da65f72d00f
--- /dev/null
+++ b/packages/next/src/compiled/scheduler-experimental/cjs/scheduler-unstable_mock.production.js
@@ -0,0 +1,704 @@
+/**
+ * @license React
+ * scheduler-unstable_mock.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+const enableSchedulerDebugging = false;
+const enableProfiling = false;
+
+function push(heap, node) {
+  const index = heap.length;
+  heap.push(node);
+  siftUp(heap, node, index);
+}
+function peek(heap) {
+  return heap.length === 0 ? null : heap[0];
+}
+function pop(heap) {
+  if (heap.length === 0) {
+    return null;
+  }
+
+  const first = heap[0];
+  const last = heap.pop();
+
+  if (last !== first) {
+    heap[0] = last;
+    siftDown(heap, last, 0);
+  }
+
+  return first;
+}
+
+function siftUp(heap, node, i) {
+  let index = i;
+
+  while (index > 0) {
+    const parentIndex = index - 1 >>> 1;
+    const parent = heap[parentIndex];
+
+    if (compare(parent, node) > 0) {
+      // The parent is larger. Swap positions.
+      heap[parentIndex] = node;
+      heap[index] = parent;
+      index = parentIndex;
+    } else {
+      // The parent is smaller. Exit.
+      return;
+    }
+  }
+}
+
+function siftDown(heap, node, i) {
+  let index = i;
+  const length = heap.length;
+  const halfLength = length >>> 1;
+
+  while (index < halfLength) {
+    const leftIndex = (index + 1) * 2 - 1;
+    const left = heap[leftIndex];
+    const rightIndex = leftIndex + 1;
+    const right = heap[rightIndex]; // If the left or right node is smaller, swap with the smaller of those.
+
+    if (compare(left, node) < 0) {
+      if (rightIndex < length && compare(right, left) < 0) {
+        heap[index] = right;
+        heap[rightIndex] = node;
+        index = rightIndex;
+      } else {
+        heap[index] = left;
+        heap[leftIndex] = node;
+        index = leftIndex;
+      }
+    } else if (rightIndex < length && compare(right, node) < 0) {
+      heap[index] = right;
+      heap[rightIndex] = node;
+      index = rightIndex;
+    } else {
+      // Neither child is smaller. Exit.
+      return;
+    }
+  }
+}
+
+function compare(a, b) {
+  // Compare sort index first, then task id.
+  const diff = a.sortIndex - b.sortIndex;
+  return diff !== 0 ? diff : a.id - b.id;
+}
+
+// TODO: Use symbols?
+const ImmediatePriority = 1;
+const UserBlockingPriority = 2;
+const NormalPriority = 3;
+const LowPriority = 4;
+const IdlePriority = 5;
+
+function markTaskErrored(task, ms) {
+}
+
+/* eslint-disable no-var */
+// Math.pow(2, 30) - 1
+// 0b111111111111111111111111111111
+
+var maxSigned31BitInt = 1073741823; // Times out immediately
+
+var IMMEDIATE_PRIORITY_TIMEOUT = -1; // Eventually times out
+
+var USER_BLOCKING_PRIORITY_TIMEOUT = 250;
+var NORMAL_PRIORITY_TIMEOUT = 5000;
+var LOW_PRIORITY_TIMEOUT = 10000; // Never times out
+
+var IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt; // Tasks are stored on a min heap
+
+var taskQueue = [];
+var timerQueue = []; // Incrementing id counter. Used to maintain insertion order.
+
+var taskIdCounter = 1; // Pausing the scheduler is useful for debugging.
+var currentTask = null;
+var currentPriorityLevel = NormalPriority; // This is set while performing work, to prevent re-entrance.
+
+var isPerformingWork = false;
+var isHostCallbackScheduled = false;
+var isHostTimeoutScheduled = false;
+let currentMockTime = 0;
+let scheduledCallback = null;
+let scheduledTimeout = null;
+let timeoutTime = -1;
+let yieldedValues = null;
+let expectedNumberOfYields = -1;
+let didStop = false;
+let isFlushing = false;
+let needsPaint = false;
+let shouldYieldForPaint = false;
+var disableYieldValue = false;
+
+function setDisableYieldValue(newValue) {
+  disableYieldValue = newValue;
+}
+
+function advanceTimers(currentTime) {
+  // Check for tasks that are no longer delayed and add them to the queue.
+  let timer = peek(timerQueue);
+
+  while (timer !== null) {
+    if (timer.callback === null) {
+      // Timer was cancelled.
+      pop(timerQueue);
+    } else if (timer.startTime <= currentTime) {
+      // Timer fired. Transfer to the task queue.
+      pop(timerQueue);
+      timer.sortIndex = timer.expirationTime;
+      push(taskQueue, timer);
+    } else {
+      // Remaining timers are pending.
+      return;
+    }
+
+    timer = peek(timerQueue);
+  }
+}
+
+function handleTimeout(currentTime) {
+  isHostTimeoutScheduled = false;
+  advanceTimers(currentTime);
+
+  if (!isHostCallbackScheduled) {
+    if (peek(taskQueue) !== null) {
+      isHostCallbackScheduled = true;
+      requestHostCallback(flushWork);
+    } else {
+      const firstTimer = peek(timerQueue);
+
+      if (firstTimer !== null) {
+        requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
+      }
+    }
+  }
+}
+
+function flushWork(hasTimeRemaining, initialTime) {
+
+
+  isHostCallbackScheduled = false;
+
+  if (isHostTimeoutScheduled) {
+    // We scheduled a timeout but it's no longer needed. Cancel it.
+    isHostTimeoutScheduled = false;
+    cancelHostTimeout();
+  }
+
+  isPerformingWork = true;
+  const previousPriorityLevel = currentPriorityLevel;
+
+  try {
+    if (enableProfiling) ; else {
+      // No catch in prod code path.
+      return workLoop(hasTimeRemaining, initialTime);
+    }
+  } finally {
+    currentTask = null;
+    currentPriorityLevel = previousPriorityLevel;
+    isPerformingWork = false;
+  }
+}
+
+function workLoop(hasTimeRemaining, initialTime) {
+  let currentTime = initialTime;
+  advanceTimers(currentTime);
+  currentTask = peek(taskQueue);
+
+  while (currentTask !== null && !(enableSchedulerDebugging )) {
+    if (currentTask.expirationTime > currentTime && (!hasTimeRemaining || shouldYieldToHost())) {
+      // This currentTask hasn't expired, and we've reached the deadline.
+      break;
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    const callback = currentTask.callback;
+
+    if (typeof callback === 'function') {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      currentTask.callback = null; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+      currentPriorityLevel = currentTask.priorityLevel; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+      const didUserCallbackTimeout = currentTask.expirationTime <= currentTime;
+
+      const continuationCallback = callback(didUserCallbackTimeout);
+      currentTime = getCurrentTime();
+
+      if (typeof continuationCallback === 'function') {
+        // If a continuation is returned, immediately yield to the main thread
+        // regardless of how much time is left in the current time slice.
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        currentTask.callback = continuationCallback;
+
+        advanceTimers(currentTime);
+
+        if (shouldYieldForPaint) {
+          needsPaint = true;
+          return true;
+        }
+      } else {
+
+        if (currentTask === peek(taskQueue)) {
+          pop(taskQueue);
+        }
+
+        advanceTimers(currentTime);
+      }
+    } else {
+      pop(taskQueue);
+    }
+
+    currentTask = peek(taskQueue);
+  } // Return whether there's additional work
+
+
+  if (currentTask !== null) {
+    return true;
+  } else {
+    const firstTimer = peek(timerQueue);
+
+    if (firstTimer !== null) {
+      requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
+    }
+
+    return false;
+  }
+}
+
+function unstable_runWithPriority(priorityLevel, eventHandler) {
+  switch (priorityLevel) {
+    case ImmediatePriority:
+    case UserBlockingPriority:
+    case NormalPriority:
+    case LowPriority:
+    case IdlePriority:
+      break;
+
+    default:
+      priorityLevel = NormalPriority;
+  }
+
+  var previousPriorityLevel = currentPriorityLevel;
+  currentPriorityLevel = priorityLevel;
+
+  try {
+    return eventHandler();
+  } finally {
+    currentPriorityLevel = previousPriorityLevel;
+  }
+}
+
+function unstable_next(eventHandler) {
+  var priorityLevel;
+
+  switch (currentPriorityLevel) {
+    case ImmediatePriority:
+    case UserBlockingPriority:
+    case NormalPriority:
+      // Shift down to normal priority
+      priorityLevel = NormalPriority;
+      break;
+
+    default:
+      // Anything lower than normal priority should remain at the current level.
+      priorityLevel = currentPriorityLevel;
+      break;
+  }
+
+  var previousPriorityLevel = currentPriorityLevel;
+  currentPriorityLevel = priorityLevel;
+
+  try {
+    return eventHandler();
+  } finally {
+    currentPriorityLevel = previousPriorityLevel;
+  }
+}
+
+function unstable_wrapCallback(callback) {
+  var parentPriorityLevel = currentPriorityLevel; // $FlowFixMe[incompatible-return]
+  // $FlowFixMe[missing-this-annot]
+
+  return function () {
+    // This is a fork of runWithPriority, inlined for performance.
+    var previousPriorityLevel = currentPriorityLevel;
+    currentPriorityLevel = parentPriorityLevel;
+
+    try {
+      return callback.apply(this, arguments);
+    } finally {
+      currentPriorityLevel = previousPriorityLevel;
+    }
+  };
+}
+
+function unstable_scheduleCallback(priorityLevel, callback, options) {
+  var currentTime = getCurrentTime();
+  var startTime;
+
+  if (typeof options === 'object' && options !== null) {
+    var delay = options.delay;
+
+    if (typeof delay === 'number' && delay > 0) {
+      startTime = currentTime + delay;
+    } else {
+      startTime = currentTime;
+    }
+  } else {
+    startTime = currentTime;
+  }
+
+  var timeout;
+
+  switch (priorityLevel) {
+    case ImmediatePriority:
+      timeout = IMMEDIATE_PRIORITY_TIMEOUT;
+      break;
+
+    case UserBlockingPriority:
+      timeout = USER_BLOCKING_PRIORITY_TIMEOUT;
+      break;
+
+    case IdlePriority:
+      timeout = IDLE_PRIORITY_TIMEOUT;
+      break;
+
+    case LowPriority:
+      timeout = LOW_PRIORITY_TIMEOUT;
+      break;
+
+    case NormalPriority:
+    default:
+      timeout = NORMAL_PRIORITY_TIMEOUT;
+      break;
+  }
+
+  var expirationTime = startTime + timeout;
+  var newTask = {
+    id: taskIdCounter++,
+    callback,
+    priorityLevel,
+    startTime,
+    expirationTime,
+    sortIndex: -1
+  };
+
+  if (startTime > currentTime) {
+    // This is a delayed task.
+    newTask.sortIndex = startTime;
+    push(timerQueue, newTask);
+
+    if (peek(taskQueue) === null && newTask === peek(timerQueue)) {
+      // All tasks are delayed, and this is the task with the earliest delay.
+      if (isHostTimeoutScheduled) {
+        // Cancel an existing timeout.
+        cancelHostTimeout();
+      } else {
+        isHostTimeoutScheduled = true;
+      } // Schedule a timeout.
+
+
+      requestHostTimeout(handleTimeout, startTime - currentTime);
+    }
+  } else {
+    newTask.sortIndex = expirationTime;
+    push(taskQueue, newTask);
+    // wait until the next time we yield.
+
+
+    if (!isHostCallbackScheduled && !isPerformingWork) {
+      isHostCallbackScheduled = true;
+      requestHostCallback(flushWork);
+    }
+  }
+
+  return newTask;
+}
+
+function unstable_pauseExecution() {
+}
+
+function unstable_continueExecution() {
+
+  if (!isHostCallbackScheduled && !isPerformingWork) {
+    isHostCallbackScheduled = true;
+    requestHostCallback(flushWork);
+  }
+}
+
+function unstable_getFirstCallbackNode() {
+  return peek(taskQueue);
+}
+
+function unstable_cancelCallback(task) {
+  // remove from the queue because you can't remove arbitrary nodes from an
+  // array based heap, only the first one.)
+
+
+  task.callback = null;
+}
+
+function unstable_getCurrentPriorityLevel() {
+  return currentPriorityLevel;
+}
+
+function requestHostCallback(callback) {
+  scheduledCallback = callback;
+}
+
+function requestHostTimeout(callback, ms) {
+  scheduledTimeout = callback;
+  timeoutTime = currentMockTime + ms;
+}
+
+function cancelHostTimeout() {
+  scheduledTimeout = null;
+  timeoutTime = -1;
+}
+
+function shouldYieldToHost() {
+  if (expectedNumberOfYields === 0 && yieldedValues === null || expectedNumberOfYields !== -1 && yieldedValues !== null && yieldedValues.length >= expectedNumberOfYields || shouldYieldForPaint && needsPaint) {
+    // We yielded at least as many values as expected. Stop flushing.
+    didStop = true;
+    return true;
+  }
+
+  return false;
+}
+
+function getCurrentTime() {
+  return currentMockTime;
+}
+
+function forceFrameRate() {// No-op
+}
+
+function reset() {
+  if (isFlushing) {
+    throw new Error('Cannot reset while already flushing work.');
+  }
+
+  currentMockTime = 0;
+  scheduledCallback = null;
+  scheduledTimeout = null;
+  timeoutTime = -1;
+  yieldedValues = null;
+  expectedNumberOfYields = -1;
+  didStop = false;
+  isFlushing = false;
+  needsPaint = false;
+} // Should only be used via an assertion helper that inspects the yielded values.
+
+
+function unstable_flushNumberOfYields(count) {
+  if (isFlushing) {
+    throw new Error('Already flushing work.');
+  }
+
+  if (scheduledCallback !== null) {
+    const cb = scheduledCallback;
+    expectedNumberOfYields = count;
+    isFlushing = true;
+
+    try {
+      let hasMoreWork = true;
+
+      do {
+        hasMoreWork = cb(true, currentMockTime);
+      } while (hasMoreWork && !didStop);
+
+      if (!hasMoreWork) {
+        scheduledCallback = null;
+      }
+    } finally {
+      expectedNumberOfYields = -1;
+      didStop = false;
+      isFlushing = false;
+    }
+  }
+}
+
+function unstable_flushUntilNextPaint() {
+  if (isFlushing) {
+    throw new Error('Already flushing work.');
+  }
+
+  if (scheduledCallback !== null) {
+    const cb = scheduledCallback;
+    shouldYieldForPaint = true;
+    needsPaint = false;
+    isFlushing = true;
+
+    try {
+      let hasMoreWork = true;
+
+      do {
+        hasMoreWork = cb(true, currentMockTime);
+      } while (hasMoreWork && !didStop);
+
+      if (!hasMoreWork) {
+        scheduledCallback = null;
+      }
+    } finally {
+      shouldYieldForPaint = false;
+      didStop = false;
+      isFlushing = false;
+    }
+  }
+
+  return false;
+}
+
+function unstable_hasPendingWork() {
+  return scheduledCallback !== null;
+}
+
+function unstable_flushExpired() {
+  if (isFlushing) {
+    throw new Error('Already flushing work.');
+  }
+
+  if (scheduledCallback !== null) {
+    isFlushing = true;
+
+    try {
+      const hasMoreWork = scheduledCallback(false, currentMockTime);
+
+      if (!hasMoreWork) {
+        scheduledCallback = null;
+      }
+    } finally {
+      isFlushing = false;
+    }
+  }
+}
+
+function unstable_flushAllWithoutAsserting() {
+  // Returns false if no work was flushed.
+  if (isFlushing) {
+    throw new Error('Already flushing work.');
+  }
+
+  if (scheduledCallback !== null) {
+    const cb = scheduledCallback;
+    isFlushing = true;
+
+    try {
+      let hasMoreWork = true;
+
+      do {
+        hasMoreWork = cb(true, currentMockTime);
+      } while (hasMoreWork);
+
+      if (!hasMoreWork) {
+        scheduledCallback = null;
+      }
+
+      return true;
+    } finally {
+      isFlushing = false;
+    }
+  } else {
+    return false;
+  }
+}
+
+function unstable_clearLog() {
+  if (yieldedValues === null) {
+    return [];
+  }
+
+  const values = yieldedValues;
+  yieldedValues = null;
+  return values;
+}
+
+function unstable_flushAll() {
+  if (yieldedValues !== null) {
+    throw new Error('Log is not empty. Assert on the log of yielded values before ' + 'flushing additional work.');
+  }
+
+  unstable_flushAllWithoutAsserting();
+
+  if (yieldedValues !== null) {
+    throw new Error('While flushing work, something yielded a value. Use an ' + 'assertion helper to assert on the log of yielded values, e.g. ' + 'expect(Scheduler).toFlushAndYield([...])');
+  }
+}
+
+function log(value) {
+  // eslint-disable-next-line react-internal/no-production-logging
+  if (console.log.name === 'disabledLog' || disableYieldValue) {
+    // If console.log has been patched, we assume we're in render
+    // replaying and we ignore any values yielding in the second pass.
+    return;
+  }
+
+  if (yieldedValues === null) {
+    yieldedValues = [value];
+  } else {
+    yieldedValues.push(value);
+  }
+}
+
+function unstable_advanceTime(ms) {
+  // eslint-disable-next-line react-internal/no-production-logging
+  if (console.log.name === 'disabledLog' || disableYieldValue) {
+    // If console.log has been patched, we assume we're in render
+    // replaying and we ignore any time advancing in the second pass.
+    return;
+  }
+
+  currentMockTime += ms;
+
+  if (scheduledTimeout !== null && timeoutTime <= currentMockTime) {
+    scheduledTimeout(currentMockTime);
+    timeoutTime = -1;
+    scheduledTimeout = null;
+  }
+}
+
+function requestPaint() {
+  needsPaint = true;
+}
+const unstable_Profiling = null;
+
+exports.log = log;
+exports.reset = reset;
+exports.unstable_IdlePriority = IdlePriority;
+exports.unstable_ImmediatePriority = ImmediatePriority;
+exports.unstable_LowPriority = LowPriority;
+exports.unstable_NormalPriority = NormalPriority;
+exports.unstable_Profiling = unstable_Profiling;
+exports.unstable_UserBlockingPriority = UserBlockingPriority;
+exports.unstable_advanceTime = unstable_advanceTime;
+exports.unstable_cancelCallback = unstable_cancelCallback;
+exports.unstable_clearLog = unstable_clearLog;
+exports.unstable_continueExecution = unstable_continueExecution;
+exports.unstable_flushAll = unstable_flushAll;
+exports.unstable_flushAllWithoutAsserting = unstable_flushAllWithoutAsserting;
+exports.unstable_flushExpired = unstable_flushExpired;
+exports.unstable_flushNumberOfYields = unstable_flushNumberOfYields;
+exports.unstable_flushUntilNextPaint = unstable_flushUntilNextPaint;
+exports.unstable_forceFrameRate = forceFrameRate;
+exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
+exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
+exports.unstable_hasPendingWork = unstable_hasPendingWork;
+exports.unstable_next = unstable_next;
+exports.unstable_now = getCurrentTime;
+exports.unstable_pauseExecution = unstable_pauseExecution;
+exports.unstable_requestPaint = requestPaint;
+exports.unstable_runWithPriority = unstable_runWithPriority;
+exports.unstable_scheduleCallback = unstable_scheduleCallback;
+exports.unstable_setDisableYieldValue = setDisableYieldValue;
+exports.unstable_shouldYield = shouldYieldToHost;
+exports.unstable_wrapCallback = unstable_wrapCallback;
\ No newline at end of file
diff --git a/packages/next/src/compiled/scheduler-experimental/cjs/scheduler-unstable_mock.production.min.js b/packages/next/src/compiled/scheduler-experimental/cjs/scheduler-unstable_mock.production.min.js
index 92dfc9eea69d5..61bc18c5e5336 100644
--- a/packages/next/src/compiled/scheduler-experimental/cjs/scheduler-unstable_mock.production.min.js
+++ b/packages/next/src/compiled/scheduler-experimental/cjs/scheduler-unstable_mock.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * scheduler-unstable_mock.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ scheduler-unstable_mock.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';function f(a,b){var c=a.length;a.push(b);a:for(;0<c;){var d=c-1>>>1,e=a[d];if(0<g(e,b))a[d]=b,a[c]=e,c=d;else break a}}function h(a){return 0===a.length?null:a[0]}function k(a){if(0===a.length)return null;var b=a[0],c=a.pop();if(c!==b){a[0]=c;a:for(var d=0,e=a.length,z=e>>>1;d<z;){var u=2*(d+1)-1,A=a[u],v=u+1,F=a[v];if(0>g(A,c))v<e&&0>g(F,A)?(a[d]=F,a[v]=c,d=v):(a[d]=A,a[u]=c,d=u);else if(v<e&&0>g(F,c))a[d]=F,a[v]=c,d=v;else break a}}return b}
 function g(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}var l=[],m=[],n=1,p=null,q=3,r=!1,t=!1,w=!1,x=0,y=null,B=null,C=-1,D=null,E=-1,G=!1,H=!1,I=!1,J=!1,K=!1;function L(a){for(var b=h(m);null!==b;){if(null===b.callback)k(m);else if(b.startTime<=a)k(m),b.sortIndex=b.expirationTime,f(l,b);else break;b=h(m)}}function M(a){w=!1;L(a);if(!t)if(null!==h(l))t=!0,y=N;else{var b=h(m);null!==b&&(a=b.startTime-a,B=M,C=x+a)}}
 function N(a,b){t=!1;w&&(w=!1,B=null,C=-1);r=!0;var c=q;try{a:{L(b);for(p=h(l);null!==p&&(!(p.expirationTime>b)||a&&!O());){var d=p.callback;if("function"===typeof d){p.callback=null;q=p.priorityLevel;var e=d(p.expirationTime<=b);b=x;if("function"===typeof e){if(p.callback=e,L(b),J){var z=I=!0;break a}}else p===h(l)&&k(l),L(b)}else k(l);p=h(l)}if(null!==p)z=!0;else{var u=h(m);if(null!==u){var A=u.startTime-b;B=M;C=x+A}z=!1}}return z}finally{p=null,q=c,r=!1}}
@@ -18,3 +18,5 @@ exports.unstable_flushUntilNextPaint=function(){if(H)throw Error("Already flushi
 exports.unstable_next=function(a){switch(q){case 1:case 2:case 3:var b=3;break;default:b=q}var c=q;q=b;try{return a()}finally{q=c}};exports.unstable_now=function(){return x};exports.unstable_pauseExecution=function(){};exports.unstable_requestPaint=function(){I=!0};exports.unstable_runWithPriority=function(a,b){switch(a){case 1:case 2:case 3:case 4:case 5:break;default:a=3}var c=q;q=a;try{return b()}finally{q=c}};
 exports.unstable_scheduleCallback=function(a,b,c){var d=x;"object"===typeof c&&null!==c?(c=c.delay,c="number"===typeof c&&0<c?d+c:d):c=d;switch(a){case 1:var e=-1;break;case 2:e=250;break;case 5:e=1073741823;break;case 4:e=1E4;break;default:e=5E3}e=c+e;a={id:n++,callback:b,priorityLevel:a,startTime:c,expirationTime:e,sortIndex:-1};c>d?(a.sortIndex=c,f(m,a),null===h(l)&&a===h(m)&&(w?(B=null,C=-1):w=!0,B=M,C=x+(c-d))):(a.sortIndex=e,f(l,a),t||r||(t=!0,y=N));return a};
 exports.unstable_setDisableYieldValue=function(a){K=a};exports.unstable_shouldYield=O;exports.unstable_wrapCallback=function(a){var b=q;return function(){var c=q;q=b;try{return a.apply(this,arguments)}finally{q=c}}};
+
+//# sourceMappingURL=scheduler-unstable_mock.production.min.js.map
diff --git a/packages/next/src/compiled/scheduler-experimental/cjs/scheduler-unstable_post_task.production.js b/packages/next/src/compiled/scheduler-experimental/cjs/scheduler-unstable_post_task.production.js
new file mode 100644
index 0000000000000..e34f6064c6d19
--- /dev/null
+++ b/packages/next/src/compiled/scheduler-experimental/cjs/scheduler-unstable_post_task.production.js
@@ -0,0 +1,202 @@
+/**
+ * @license React
+ * scheduler-unstable_post_task.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+// TODO: Use symbols?
+const ImmediatePriority = 1;
+const UserBlockingPriority = 2;
+const NormalPriority = 3;
+const LowPriority = 4;
+const IdlePriority = 5;
+
+const perf = window.performance;
+const setTimeout = window.setTimeout; // Use experimental Chrome Scheduler postTask API.
+
+const scheduler = global.scheduler;
+const getCurrentTime = perf.now.bind(perf);
+const unstable_now = getCurrentTime; // Scheduler periodically yields in case there is other work on the main
+// thread, like user events. By default, it yields multiple times per frame.
+// It does not attempt to align with frame boundaries, since most tasks don't
+// need to be frame aligned; for those that do, use requestAnimationFrame.
+
+const yieldInterval = 5;
+let deadline = 0;
+let currentPriorityLevel_DEPRECATED = NormalPriority; // `isInputPending` is not available. Since we have no way of knowing if
+// there's pending input, always yield at the end of the frame.
+
+function unstable_shouldYield() {
+  return getCurrentTime() >= deadline;
+}
+function unstable_requestPaint() {// Since we yield every frame regardless, `requestPaint` has no effect.
+}
+function unstable_scheduleCallback(priorityLevel, callback, options) {
+  let postTaskPriority;
+
+  switch (priorityLevel) {
+    case ImmediatePriority:
+    case UserBlockingPriority:
+      postTaskPriority = 'user-blocking';
+      break;
+
+    case LowPriority:
+    case NormalPriority:
+      postTaskPriority = 'user-visible';
+      break;
+
+    case IdlePriority:
+      postTaskPriority = 'background';
+      break;
+
+    default:
+      postTaskPriority = 'user-visible';
+      break;
+  }
+
+  const controller = new TaskController({
+    priority: postTaskPriority
+  });
+  const postTaskOptions = {
+    delay: typeof options === 'object' && options !== null ? options.delay : 0,
+    signal: controller.signal
+  };
+  const node = {
+    _controller: controller
+  };
+  scheduler.postTask(runTask.bind(null, priorityLevel, postTaskPriority, node, callback), postTaskOptions).catch(handleAbortError);
+  return node;
+}
+
+function runTask(priorityLevel, postTaskPriority, node, callback) {
+  deadline = getCurrentTime() + yieldInterval;
+
+  try {
+    currentPriorityLevel_DEPRECATED = priorityLevel;
+    const didTimeout_DEPRECATED = false;
+    const result = callback(didTimeout_DEPRECATED);
+
+    if (typeof result === 'function') {
+      // Assume this is a continuation
+      const continuation = result;
+      const continuationOptions = {
+        signal: node._controller.signal
+      };
+      const nextTask = runTask.bind(null, priorityLevel, postTaskPriority, node, continuation);
+
+      if (scheduler.yield !== undefined) {
+        scheduler.yield(continuationOptions).then(nextTask).catch(handleAbortError);
+      } else {
+        scheduler.postTask(nextTask, continuationOptions).catch(handleAbortError);
+      }
+    }
+  } catch (error) {
+    // We're inside a `postTask` promise. If we don't handle this error, then it
+    // will trigger an "Unhandled promise rejection" error. We don't want that,
+    // but we do want the default error reporting behavior that normal
+    // (non-Promise) tasks get for unhandled errors.
+    //
+    // So we'll re-throw the error inside a regular browser task.
+    setTimeout(() => {
+      throw error;
+    });
+  } finally {
+    currentPriorityLevel_DEPRECATED = NormalPriority;
+  }
+}
+
+function handleAbortError(error) {// Abort errors are an implementation detail. We don't expose the
+  // TaskController to the user, nor do we expose the promise that is returned
+  // from `postTask`. So we should suppress them, since there's no way for the
+  // user to handle them.
+}
+
+function unstable_cancelCallback(node) {
+  const controller = node._controller;
+  controller.abort();
+}
+function unstable_runWithPriority(priorityLevel, callback) {
+  const previousPriorityLevel = currentPriorityLevel_DEPRECATED;
+  currentPriorityLevel_DEPRECATED = priorityLevel;
+
+  try {
+    return callback();
+  } finally {
+    currentPriorityLevel_DEPRECATED = previousPriorityLevel;
+  }
+}
+function unstable_getCurrentPriorityLevel() {
+  return currentPriorityLevel_DEPRECATED;
+}
+function unstable_next(callback) {
+  let priorityLevel;
+
+  switch (currentPriorityLevel_DEPRECATED) {
+    case ImmediatePriority:
+    case UserBlockingPriority:
+    case NormalPriority:
+      // Shift down to normal priority
+      priorityLevel = NormalPriority;
+      break;
+
+    default:
+      // Anything lower than normal priority should remain at the current level.
+      priorityLevel = currentPriorityLevel_DEPRECATED;
+      break;
+  }
+
+  const previousPriorityLevel = currentPriorityLevel_DEPRECATED;
+  currentPriorityLevel_DEPRECATED = priorityLevel;
+
+  try {
+    return callback();
+  } finally {
+    currentPriorityLevel_DEPRECATED = previousPriorityLevel;
+  }
+}
+function unstable_wrapCallback(callback) {
+  const parentPriorityLevel = currentPriorityLevel_DEPRECATED;
+  return () => {
+    const previousPriorityLevel = currentPriorityLevel_DEPRECATED;
+    currentPriorityLevel_DEPRECATED = parentPriorityLevel;
+
+    try {
+      return callback();
+    } finally {
+      currentPriorityLevel_DEPRECATED = previousPriorityLevel;
+    }
+  };
+}
+function unstable_forceFrameRate() {}
+function unstable_pauseExecution() {}
+function unstable_continueExecution() {}
+function unstable_getFirstCallbackNode() {
+  return null;
+} // Currently no profiling build
+
+const unstable_Profiling = null;
+
+exports.unstable_IdlePriority = IdlePriority;
+exports.unstable_ImmediatePriority = ImmediatePriority;
+exports.unstable_LowPriority = LowPriority;
+exports.unstable_NormalPriority = NormalPriority;
+exports.unstable_Profiling = unstable_Profiling;
+exports.unstable_UserBlockingPriority = UserBlockingPriority;
+exports.unstable_cancelCallback = unstable_cancelCallback;
+exports.unstable_continueExecution = unstable_continueExecution;
+exports.unstable_forceFrameRate = unstable_forceFrameRate;
+exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
+exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
+exports.unstable_next = unstable_next;
+exports.unstable_now = unstable_now;
+exports.unstable_pauseExecution = unstable_pauseExecution;
+exports.unstable_requestPaint = unstable_requestPaint;
+exports.unstable_runWithPriority = unstable_runWithPriority;
+exports.unstable_scheduleCallback = unstable_scheduleCallback;
+exports.unstable_shouldYield = unstable_shouldYield;
+exports.unstable_wrapCallback = unstable_wrapCallback;
\ No newline at end of file
diff --git a/packages/next/src/compiled/scheduler-experimental/cjs/scheduler-unstable_post_task.production.min.js b/packages/next/src/compiled/scheduler-experimental/cjs/scheduler-unstable_post_task.production.min.js
index d721933ddac72..61c83e75c1942 100644
--- a/packages/next/src/compiled/scheduler-experimental/cjs/scheduler-unstable_post_task.production.min.js
+++ b/packages/next/src/compiled/scheduler-experimental/cjs/scheduler-unstable_post_task.production.min.js
@@ -1,14 +1,16 @@
-/**
- * @license React
- * scheduler-unstable_post_task.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ scheduler-unstable_post_task.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var a=window.performance,g=window.setTimeout,h=global.scheduler,k=a.now.bind(a),l=0,m=3;function n(c,d,b,f){l=k()+5;try{m=c;var e=f(!1);if("function"===typeof e){var p={signal:b._controller.signal},q=n.bind(null,c,d,b,e);void 0!==h.yield?h.yield(p).then(q).catch(r):h.postTask(q,p).catch(r)}}catch(t){g(function(){throw t;})}finally{m=3}}function r(){}exports.unstable_IdlePriority=5;exports.unstable_ImmediatePriority=1;exports.unstable_LowPriority=4;exports.unstable_NormalPriority=3;
 exports.unstable_Profiling=null;exports.unstable_UserBlockingPriority=2;exports.unstable_cancelCallback=function(c){c._controller.abort()};exports.unstable_continueExecution=function(){};exports.unstable_forceFrameRate=function(){};exports.unstable_getCurrentPriorityLevel=function(){return m};exports.unstable_getFirstCallbackNode=function(){return null};exports.unstable_next=function(c){switch(m){case 1:case 2:case 3:var d=3;break;default:d=m}var b=m;m=d;try{return c()}finally{m=b}};
 exports.unstable_now=k;exports.unstable_pauseExecution=function(){};exports.unstable_requestPaint=function(){};exports.unstable_runWithPriority=function(c,d){var b=m;m=c;try{return d()}finally{m=b}};
 exports.unstable_scheduleCallback=function(c,d,b){switch(c){case 1:case 2:var f="user-blocking";break;case 4:case 3:f="user-visible";break;case 5:f="background";break;default:f="user-visible"}var e=new TaskController({priority:f});b={delay:"object"===typeof b&&null!==b?b.delay:0,signal:e.signal};e={_controller:e};h.postTask(n.bind(null,c,f,e,d),b).catch(r);return e};exports.unstable_shouldYield=function(){return k()>=l};
 exports.unstable_wrapCallback=function(c){var d=m;return function(){var b=m;m=d;try{return c()}finally{m=b}}};
+
+//# sourceMappingURL=scheduler-unstable_post_task.production.min.js.map
diff --git a/packages/next/src/compiled/scheduler-experimental/cjs/scheduler.native.production.js b/packages/next/src/compiled/scheduler-experimental/cjs/scheduler.native.production.js
new file mode 100644
index 0000000000000..4da95b88005a4
--- /dev/null
+++ b/packages/next/src/compiled/scheduler-experimental/cjs/scheduler.native.production.js
@@ -0,0 +1,533 @@
+/**
+ * @license React
+ * scheduler.native.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+const enableSchedulerDebugging = false;
+const enableProfiling = false;
+const frameYieldMs = 5;
+
+function push(heap, node) {
+  const index = heap.length;
+  heap.push(node);
+  siftUp(heap, node, index);
+}
+function peek(heap) {
+  return heap.length === 0 ? null : heap[0];
+}
+function pop(heap) {
+  if (heap.length === 0) {
+    return null;
+  }
+
+  const first = heap[0];
+  const last = heap.pop();
+
+  if (last !== first) {
+    heap[0] = last;
+    siftDown(heap, last, 0);
+  }
+
+  return first;
+}
+
+function siftUp(heap, node, i) {
+  let index = i;
+
+  while (index > 0) {
+    const parentIndex = index - 1 >>> 1;
+    const parent = heap[parentIndex];
+
+    if (compare(parent, node) > 0) {
+      // The parent is larger. Swap positions.
+      heap[parentIndex] = node;
+      heap[index] = parent;
+      index = parentIndex;
+    } else {
+      // The parent is smaller. Exit.
+      return;
+    }
+  }
+}
+
+function siftDown(heap, node, i) {
+  let index = i;
+  const length = heap.length;
+  const halfLength = length >>> 1;
+
+  while (index < halfLength) {
+    const leftIndex = (index + 1) * 2 - 1;
+    const left = heap[leftIndex];
+    const rightIndex = leftIndex + 1;
+    const right = heap[rightIndex]; // If the left or right node is smaller, swap with the smaller of those.
+
+    if (compare(left, node) < 0) {
+      if (rightIndex < length && compare(right, left) < 0) {
+        heap[index] = right;
+        heap[rightIndex] = node;
+        index = rightIndex;
+      } else {
+        heap[index] = left;
+        heap[leftIndex] = node;
+        index = leftIndex;
+      }
+    } else if (rightIndex < length && compare(right, node) < 0) {
+      heap[index] = right;
+      heap[rightIndex] = node;
+      index = rightIndex;
+    } else {
+      // Neither child is smaller. Exit.
+      return;
+    }
+  }
+}
+
+function compare(a, b) {
+  // Compare sort index first, then task id.
+  const diff = a.sortIndex - b.sortIndex;
+  return diff !== 0 ? diff : a.id - b.id;
+}
+
+// TODO: Use symbols?
+const ImmediatePriority = 1;
+const UserBlockingPriority = 2;
+const NormalPriority = 3;
+const LowPriority = 4;
+const IdlePriority = 5;
+
+function markTaskErrored(task, ms) {
+}
+
+/* eslint-disable no-var */
+let getCurrentTime;
+const hasPerformanceNow = // $FlowFixMe[method-unbinding]
+typeof performance === 'object' && typeof performance.now === 'function';
+
+if (hasPerformanceNow) {
+  const localPerformance = performance;
+
+  getCurrentTime = () => localPerformance.now();
+} else {
+  const localDate = Date;
+  const initialTime = localDate.now();
+
+  getCurrentTime = () => localDate.now() - initialTime;
+} // Max 31 bit integer. The max integer size in V8 for 32-bit systems.
+// Math.pow(2, 30) - 1
+// 0b111111111111111111111111111111
+
+
+var maxSigned31BitInt = 1073741823; // Times out immediately
+
+var IMMEDIATE_PRIORITY_TIMEOUT = -1; // Eventually times out
+
+var USER_BLOCKING_PRIORITY_TIMEOUT = 250;
+var NORMAL_PRIORITY_TIMEOUT = 5000;
+var LOW_PRIORITY_TIMEOUT = 10000; // Never times out
+
+var IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt; // Tasks are stored on a min heap
+
+var taskQueue = [];
+var timerQueue = []; // Incrementing id counter. Used to maintain insertion order.
+
+var taskIdCounter = 1; // Pausing the scheduler is useful for debugging.
+var currentTask = null;
+var currentPriorityLevel = NormalPriority; // This is set while performing work, to prevent re-entrance.
+
+var isPerformingWork = false;
+var isHostCallbackScheduled = false;
+var isHostTimeoutScheduled = false; // Capture local references to native APIs, in case a polyfill overrides them.
+
+const localSetTimeout = typeof setTimeout === 'function' ? setTimeout : null;
+const localClearTimeout = typeof clearTimeout === 'function' ? clearTimeout : null;
+const localSetImmediate = typeof setImmediate !== 'undefined' ? setImmediate : null; // IE and Node.js + jsdom
+
+typeof navigator !== 'undefined' && // $FlowFixMe[prop-missing]
+navigator.scheduling !== undefined && // $FlowFixMe[incompatible-type]
+navigator.scheduling.isInputPending !== undefined ? navigator.scheduling.isInputPending.bind(navigator.scheduling) : null;
+
+function advanceTimers(currentTime) {
+  // Check for tasks that are no longer delayed and add them to the queue.
+  let timer = peek(timerQueue);
+
+  while (timer !== null) {
+    if (timer.callback === null) {
+      // Timer was cancelled.
+      pop(timerQueue);
+    } else if (timer.startTime <= currentTime) {
+      // Timer fired. Transfer to the task queue.
+      pop(timerQueue);
+      timer.sortIndex = timer.expirationTime;
+      push(taskQueue, timer);
+    } else {
+      // Remaining timers are pending.
+      return;
+    }
+
+    timer = peek(timerQueue);
+  }
+}
+
+function handleTimeout(currentTime) {
+  isHostTimeoutScheduled = false;
+  advanceTimers(currentTime);
+
+  if (!isHostCallbackScheduled) {
+    if (peek(taskQueue) !== null) {
+      isHostCallbackScheduled = true;
+      requestHostCallback();
+    } else {
+      const firstTimer = peek(timerQueue);
+
+      if (firstTimer !== null) {
+        requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
+      }
+    }
+  }
+}
+
+function flushWork(initialTime) {
+
+
+  isHostCallbackScheduled = false;
+
+  if (isHostTimeoutScheduled) {
+    // We scheduled a timeout but it's no longer needed. Cancel it.
+    isHostTimeoutScheduled = false;
+    cancelHostTimeout();
+  }
+
+  isPerformingWork = true;
+  const previousPriorityLevel = currentPriorityLevel;
+
+  try {
+    if (enableProfiling) ; else {
+      // No catch in prod code path.
+      return workLoop(initialTime);
+    }
+  } finally {
+    currentTask = null;
+    currentPriorityLevel = previousPriorityLevel;
+    isPerformingWork = false;
+  }
+}
+
+function workLoop(initialTime) {
+  let currentTime = initialTime;
+  advanceTimers(currentTime);
+  currentTask = peek(taskQueue);
+
+  while (currentTask !== null && !(enableSchedulerDebugging )) {
+    if (currentTask.expirationTime > currentTime && shouldYieldToHost()) {
+      // This currentTask hasn't expired, and we've reached the deadline.
+      break;
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    const callback = currentTask.callback;
+
+    if (typeof callback === 'function') {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      currentTask.callback = null; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+      currentPriorityLevel = currentTask.priorityLevel; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+      const didUserCallbackTimeout = currentTask.expirationTime <= currentTime;
+
+      const continuationCallback = callback(didUserCallbackTimeout);
+      currentTime = getCurrentTime();
+
+      if (typeof continuationCallback === 'function') {
+        // If a continuation is returned, immediately yield to the main thread
+        // regardless of how much time is left in the current time slice.
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        currentTask.callback = continuationCallback;
+
+        advanceTimers(currentTime);
+        return true;
+      } else {
+
+        if (currentTask === peek(taskQueue)) {
+          pop(taskQueue);
+        }
+
+        advanceTimers(currentTime);
+      }
+    } else {
+      pop(taskQueue);
+    }
+
+    currentTask = peek(taskQueue);
+  } // Return whether there's additional work
+
+
+  if (currentTask !== null) {
+    return true;
+  } else {
+    const firstTimer = peek(timerQueue);
+
+    if (firstTimer !== null) {
+      requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
+    }
+
+    return false;
+  }
+}
+
+function unstable_scheduleCallback$1(priorityLevel, callback, options) {
+  var currentTime = getCurrentTime();
+  var startTime;
+
+  if (typeof options === 'object' && options !== null) {
+    var delay = options.delay;
+
+    if (typeof delay === 'number' && delay > 0) {
+      startTime = currentTime + delay;
+    } else {
+      startTime = currentTime;
+    }
+  } else {
+    startTime = currentTime;
+  }
+
+  var timeout;
+
+  switch (priorityLevel) {
+    case ImmediatePriority:
+      timeout = IMMEDIATE_PRIORITY_TIMEOUT;
+      break;
+
+    case UserBlockingPriority:
+      timeout = USER_BLOCKING_PRIORITY_TIMEOUT;
+      break;
+
+    case IdlePriority:
+      timeout = IDLE_PRIORITY_TIMEOUT;
+      break;
+
+    case LowPriority:
+      timeout = LOW_PRIORITY_TIMEOUT;
+      break;
+
+    case NormalPriority:
+    default:
+      timeout = NORMAL_PRIORITY_TIMEOUT;
+      break;
+  }
+
+  var expirationTime = startTime + timeout;
+  var newTask = {
+    id: taskIdCounter++,
+    callback,
+    priorityLevel,
+    startTime,
+    expirationTime,
+    sortIndex: -1
+  };
+
+  if (startTime > currentTime) {
+    // This is a delayed task.
+    newTask.sortIndex = startTime;
+    push(timerQueue, newTask);
+
+    if (peek(taskQueue) === null && newTask === peek(timerQueue)) {
+      // All tasks are delayed, and this is the task with the earliest delay.
+      if (isHostTimeoutScheduled) {
+        // Cancel an existing timeout.
+        cancelHostTimeout();
+      } else {
+        isHostTimeoutScheduled = true;
+      } // Schedule a timeout.
+
+
+      requestHostTimeout(handleTimeout, startTime - currentTime);
+    }
+  } else {
+    newTask.sortIndex = expirationTime;
+    push(taskQueue, newTask);
+    // wait until the next time we yield.
+
+
+    if (!isHostCallbackScheduled && !isPerformingWork) {
+      isHostCallbackScheduled = true;
+      requestHostCallback();
+    }
+  }
+
+  return newTask;
+}
+
+function unstable_cancelCallback$1(task) {
+  // remove from the queue because you can't remove arbitrary nodes from an
+  // array based heap, only the first one.)
+
+
+  task.callback = null;
+}
+
+function unstable_getCurrentPriorityLevel$1() {
+  return currentPriorityLevel;
+}
+
+let isMessageLoopRunning = false;
+let taskTimeoutID = -1; // Scheduler periodically yields in case there is other work on the main
+// thread, like user events. By default, it yields multiple times per frame.
+// It does not attempt to align with frame boundaries, since most tasks don't
+// need to be frame aligned; for those that do, use requestAnimationFrame.
+
+let frameInterval = frameYieldMs;
+let startTime = -1;
+
+function shouldYieldToHost() {
+  const timeElapsed = getCurrentTime() - startTime;
+
+  if (timeElapsed < frameInterval) {
+    // The main thread has only been blocked for a really short amount of time;
+    // smaller than a single frame. Don't yield yet.
+    return false;
+  } // The main thread has been blocked for a non-negligible amount of time. We
+
+
+  return true;
+}
+
+function requestPaint() {
+
+}
+
+const performWorkUntilDeadline = () => {
+  if (isMessageLoopRunning) {
+    const currentTime = getCurrentTime(); // Keep track of the start time so we can measure how long the main thread
+    // has been blocked.
+
+    startTime = currentTime; // If a scheduler task throws, exit the current browser task so the
+    // error can be observed.
+    //
+    // Intentionally not using a try-catch, since that makes some debugging
+    // techniques harder. Instead, if `flushWork` errors, then `hasMoreWork` will
+    // remain true, and we'll continue the work loop.
+
+    let hasMoreWork = true;
+
+    try {
+      hasMoreWork = flushWork(currentTime);
+    } finally {
+      if (hasMoreWork) {
+        // If there's more work, schedule the next message event at the end
+        // of the preceding one.
+        schedulePerformWorkUntilDeadline();
+      } else {
+        isMessageLoopRunning = false;
+      }
+    }
+  } // Yielding to the browser will give it a chance to paint, so we can
+};
+
+let schedulePerformWorkUntilDeadline;
+
+if (typeof localSetImmediate === 'function') {
+  // Node.js and old IE.
+  // There's a few reasons for why we prefer setImmediate.
+  //
+  // Unlike MessageChannel, it doesn't prevent a Node.js process from exiting.
+  // (Even though this is a DOM fork of the Scheduler, you could get here
+  // with a mix of Node.js 15+, which has a MessageChannel, and jsdom.)
+  // https://github.com/facebook/react/issues/20756
+  //
+  // But also, it runs earlier which is the semantic we want.
+  // If other browsers ever implement it, it's better to use it.
+  // Although both of these would be inferior to native scheduling.
+  schedulePerformWorkUntilDeadline = () => {
+    localSetImmediate(performWorkUntilDeadline);
+  };
+} else if (typeof MessageChannel !== 'undefined') {
+  // DOM and Worker environments.
+  // We prefer MessageChannel because of the 4ms setTimeout clamping.
+  const channel = new MessageChannel();
+  const port = channel.port2;
+  channel.port1.onmessage = performWorkUntilDeadline;
+
+  schedulePerformWorkUntilDeadline = () => {
+    port.postMessage(null);
+  };
+} else {
+  // We should only fallback here in non-browser environments.
+  schedulePerformWorkUntilDeadline = () => {
+    // $FlowFixMe[not-a-function] nullable value
+    localSetTimeout(performWorkUntilDeadline, 0);
+  };
+}
+
+function requestHostCallback() {
+  if (!isMessageLoopRunning) {
+    isMessageLoopRunning = true;
+    schedulePerformWorkUntilDeadline();
+  }
+}
+
+function requestHostTimeout(callback, ms) {
+  // $FlowFixMe[not-a-function] nullable value
+  taskTimeoutID = localSetTimeout(() => {
+    callback(getCurrentTime());
+  }, ms);
+}
+
+function cancelHostTimeout() {
+  // $FlowFixMe[not-a-function] nullable value
+  localClearTimeout(taskTimeoutID);
+  taskTimeoutID = -1;
+}
+
+// https://github.com/facebook/react-native/blob/main/packages/react-native/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerBinding.cpp
+
+const unstable_UserBlockingPriority = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_UserBlockingPriority : UserBlockingPriority;
+const unstable_NormalPriority = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_NormalPriority : NormalPriority;
+const unstable_IdlePriority = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_IdlePriority : IdlePriority;
+const unstable_LowPriority = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_LowPriority : LowPriority;
+const unstable_ImmediatePriority = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_ImmediatePriority : ImmediatePriority;
+const unstable_scheduleCallback = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_scheduleCallback : unstable_scheduleCallback$1;
+const unstable_cancelCallback = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_cancelCallback : unstable_cancelCallback$1;
+const unstable_getCurrentPriorityLevel = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_getCurrentPriorityLevel : unstable_getCurrentPriorityLevel$1;
+const unstable_shouldYield = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_shouldYield : shouldYieldToHost;
+const unstable_requestPaint = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_requestPaint : requestPaint;
+const unstable_now = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_now : getCurrentTime; // These were never implemented on the native scheduler because React never calls them.
+// For consistency, let's disable them altogether and make them throw.
+
+const unstable_next = throwNotImplemented;
+const unstable_runWithPriority = throwNotImplemented;
+const unstable_wrapCallback = throwNotImplemented;
+const unstable_continueExecution = throwNotImplemented;
+const unstable_pauseExecution = throwNotImplemented;
+const unstable_getFirstCallbackNode = throwNotImplemented;
+const unstable_forceFrameRate = throwNotImplemented;
+const unstable_Profiling = null;
+
+function throwNotImplemented() {
+  throw Error('Not implemented.');
+} // Flow magic to verify the exports of this file match the original version.
+
+exports.unstable_IdlePriority = unstable_IdlePriority;
+exports.unstable_ImmediatePriority = unstable_ImmediatePriority;
+exports.unstable_LowPriority = unstable_LowPriority;
+exports.unstable_NormalPriority = unstable_NormalPriority;
+exports.unstable_Profiling = unstable_Profiling;
+exports.unstable_UserBlockingPriority = unstable_UserBlockingPriority;
+exports.unstable_cancelCallback = unstable_cancelCallback;
+exports.unstable_continueExecution = unstable_continueExecution;
+exports.unstable_forceFrameRate = unstable_forceFrameRate;
+exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
+exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
+exports.unstable_next = unstable_next;
+exports.unstable_now = unstable_now;
+exports.unstable_pauseExecution = unstable_pauseExecution;
+exports.unstable_requestPaint = unstable_requestPaint;
+exports.unstable_runWithPriority = unstable_runWithPriority;
+exports.unstable_scheduleCallback = unstable_scheduleCallback;
+exports.unstable_shouldYield = unstable_shouldYield;
+exports.unstable_wrapCallback = unstable_wrapCallback;
\ No newline at end of file
diff --git a/packages/next/src/compiled/scheduler-experimental/cjs/scheduler.native.production.min.js b/packages/next/src/compiled/scheduler-experimental/cjs/scheduler.native.production.min.js
index 32e6f2edefde2..6e5c36e9e32ee 100644
--- a/packages/next/src/compiled/scheduler-experimental/cjs/scheduler.native.production.min.js
+++ b/packages/next/src/compiled/scheduler-experimental/cjs/scheduler.native.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * scheduler.native.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ scheduler.native.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';function f(a,c){var b=a.length;a.push(c);a:for(;0<b;){var d=b-1>>>1,e=a[d];if(0<g(e,c))a[d]=c,a[b]=e,b=d;else break a}}function h(a){return 0===a.length?null:a[0]}function k(a){if(0===a.length)return null;var c=a[0],b=a.pop();if(b!==c){a[0]=b;a:for(var d=0,e=a.length,x=e>>>1;d<x;){var y=2*(d+1)-1,D=a[y],m=y+1,z=a[m];if(0>g(D,b))m<e&&0>g(z,D)?(a[d]=z,a[m]=b,d=m):(a[d]=D,a[y]=b,d=y);else if(m<e&&0>g(z,b))a[d]=z,a[m]=b,d=m;else break a}}return c}
 function g(a,c){var b=a.sortIndex-c.sortIndex;return 0!==b?b:a.id-c.id}var l;if("object"===typeof performance&&"function"===typeof performance.now){var n=performance;l=function(){return n.now()}}else{var p=Date,q=p.now();l=function(){return p.now()-q}}var r=[],t=[],u=1,v=null,w=3,A=!1,B=!1,C=!1,E="function"===typeof setTimeout?setTimeout:null,F="function"===typeof clearTimeout?clearTimeout:null,G="undefined"!==typeof setImmediate?setImmediate:null;
 "undefined"!==typeof navigator&&void 0!==navigator.scheduling&&void 0!==navigator.scheduling.isInputPending?navigator.scheduling.isInputPending.bind(navigator.scheduling):null;function H(a){for(var c=h(t);null!==c;){if(null===c.callback)k(t);else if(c.startTime<=a)k(t),c.sortIndex=c.expirationTime,f(r,c);else break;c=h(t)}}function I(a){C=!1;H(a);if(!B)if(null!==h(r))B=!0,J||(J=!0,K());else{var c=h(t);null!==c&&L(I,c.startTime-a)}}
@@ -18,3 +18,5 @@ var W="undefined"!==typeof nativeRuntimeScheduler?nativeRuntimeScheduler.unstabl
 typeof nativeRuntimeScheduler?nativeRuntimeScheduler.unstable_cancelCallback:O,da="undefined"!==typeof nativeRuntimeScheduler?nativeRuntimeScheduler.unstable_getCurrentPriorityLevel:P,ea="undefined"!==typeof nativeRuntimeScheduler?nativeRuntimeScheduler.unstable_shouldYield:R,fa="undefined"!==typeof nativeRuntimeScheduler?nativeRuntimeScheduler.unstable_requestPaint:S,ha="undefined"!==typeof nativeRuntimeScheduler?nativeRuntimeScheduler.unstable_now:l;
 function Z(){throw Error("Not implemented.");}exports.unstable_IdlePriority="undefined"!==typeof nativeRuntimeScheduler?nativeRuntimeScheduler.unstable_IdlePriority:5;exports.unstable_ImmediatePriority=aa;exports.unstable_LowPriority=Y;exports.unstable_NormalPriority=X;exports.unstable_Profiling=null;exports.unstable_UserBlockingPriority=W;exports.unstable_cancelCallback=ca;exports.unstable_continueExecution=Z;exports.unstable_forceFrameRate=Z;exports.unstable_getCurrentPriorityLevel=da;
 exports.unstable_getFirstCallbackNode=Z;exports.unstable_next=Z;exports.unstable_now=ha;exports.unstable_pauseExecution=Z;exports.unstable_requestPaint=fa;exports.unstable_runWithPriority=Z;exports.unstable_scheduleCallback=ba;exports.unstable_shouldYield=ea;exports.unstable_wrapCallback=Z;
+
+//# sourceMappingURL=scheduler.native.production.min.js.map
diff --git a/packages/next/src/compiled/scheduler-experimental/cjs/scheduler.production.js b/packages/next/src/compiled/scheduler-experimental/cjs/scheduler.production.js
new file mode 100644
index 0000000000000..25954cf1f0165
--- /dev/null
+++ b/packages/next/src/compiled/scheduler-experimental/cjs/scheduler.production.js
@@ -0,0 +1,602 @@
+/**
+ * @license React
+ * scheduler.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+const enableSchedulerDebugging = false;
+const enableProfiling = false;
+const frameYieldMs = 5;
+
+function push(heap, node) {
+  const index = heap.length;
+  heap.push(node);
+  siftUp(heap, node, index);
+}
+function peek(heap) {
+  return heap.length === 0 ? null : heap[0];
+}
+function pop(heap) {
+  if (heap.length === 0) {
+    return null;
+  }
+
+  const first = heap[0];
+  const last = heap.pop();
+
+  if (last !== first) {
+    heap[0] = last;
+    siftDown(heap, last, 0);
+  }
+
+  return first;
+}
+
+function siftUp(heap, node, i) {
+  let index = i;
+
+  while (index > 0) {
+    const parentIndex = index - 1 >>> 1;
+    const parent = heap[parentIndex];
+
+    if (compare(parent, node) > 0) {
+      // The parent is larger. Swap positions.
+      heap[parentIndex] = node;
+      heap[index] = parent;
+      index = parentIndex;
+    } else {
+      // The parent is smaller. Exit.
+      return;
+    }
+  }
+}
+
+function siftDown(heap, node, i) {
+  let index = i;
+  const length = heap.length;
+  const halfLength = length >>> 1;
+
+  while (index < halfLength) {
+    const leftIndex = (index + 1) * 2 - 1;
+    const left = heap[leftIndex];
+    const rightIndex = leftIndex + 1;
+    const right = heap[rightIndex]; // If the left or right node is smaller, swap with the smaller of those.
+
+    if (compare(left, node) < 0) {
+      if (rightIndex < length && compare(right, left) < 0) {
+        heap[index] = right;
+        heap[rightIndex] = node;
+        index = rightIndex;
+      } else {
+        heap[index] = left;
+        heap[leftIndex] = node;
+        index = leftIndex;
+      }
+    } else if (rightIndex < length && compare(right, node) < 0) {
+      heap[index] = right;
+      heap[rightIndex] = node;
+      index = rightIndex;
+    } else {
+      // Neither child is smaller. Exit.
+      return;
+    }
+  }
+}
+
+function compare(a, b) {
+  // Compare sort index first, then task id.
+  const diff = a.sortIndex - b.sortIndex;
+  return diff !== 0 ? diff : a.id - b.id;
+}
+
+// TODO: Use symbols?
+const ImmediatePriority = 1;
+const UserBlockingPriority = 2;
+const NormalPriority = 3;
+const LowPriority = 4;
+const IdlePriority = 5;
+
+function markTaskErrored(task, ms) {
+}
+
+/* eslint-disable no-var */
+exports.unstable_now = void 0;
+const hasPerformanceNow = // $FlowFixMe[method-unbinding]
+typeof performance === 'object' && typeof performance.now === 'function';
+
+if (hasPerformanceNow) {
+  const localPerformance = performance;
+
+  exports.unstable_now = () => localPerformance.now();
+} else {
+  const localDate = Date;
+  const initialTime = localDate.now();
+
+  exports.unstable_now = () => localDate.now() - initialTime;
+} // Max 31 bit integer. The max integer size in V8 for 32-bit systems.
+// Math.pow(2, 30) - 1
+// 0b111111111111111111111111111111
+
+
+var maxSigned31BitInt = 1073741823; // Times out immediately
+
+var IMMEDIATE_PRIORITY_TIMEOUT = -1; // Eventually times out
+
+var USER_BLOCKING_PRIORITY_TIMEOUT = 250;
+var NORMAL_PRIORITY_TIMEOUT = 5000;
+var LOW_PRIORITY_TIMEOUT = 10000; // Never times out
+
+var IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt; // Tasks are stored on a min heap
+
+var taskQueue = [];
+var timerQueue = []; // Incrementing id counter. Used to maintain insertion order.
+
+var taskIdCounter = 1; // Pausing the scheduler is useful for debugging.
+var currentTask = null;
+var currentPriorityLevel = NormalPriority; // This is set while performing work, to prevent re-entrance.
+
+var isPerformingWork = false;
+var isHostCallbackScheduled = false;
+var isHostTimeoutScheduled = false; // Capture local references to native APIs, in case a polyfill overrides them.
+
+const localSetTimeout = typeof setTimeout === 'function' ? setTimeout : null;
+const localClearTimeout = typeof clearTimeout === 'function' ? clearTimeout : null;
+const localSetImmediate = typeof setImmediate !== 'undefined' ? setImmediate : null; // IE and Node.js + jsdom
+
+typeof navigator !== 'undefined' && // $FlowFixMe[prop-missing]
+navigator.scheduling !== undefined && // $FlowFixMe[incompatible-type]
+navigator.scheduling.isInputPending !== undefined ? navigator.scheduling.isInputPending.bind(navigator.scheduling) : null;
+
+function advanceTimers(currentTime) {
+  // Check for tasks that are no longer delayed and add them to the queue.
+  let timer = peek(timerQueue);
+
+  while (timer !== null) {
+    if (timer.callback === null) {
+      // Timer was cancelled.
+      pop(timerQueue);
+    } else if (timer.startTime <= currentTime) {
+      // Timer fired. Transfer to the task queue.
+      pop(timerQueue);
+      timer.sortIndex = timer.expirationTime;
+      push(taskQueue, timer);
+    } else {
+      // Remaining timers are pending.
+      return;
+    }
+
+    timer = peek(timerQueue);
+  }
+}
+
+function handleTimeout(currentTime) {
+  isHostTimeoutScheduled = false;
+  advanceTimers(currentTime);
+
+  if (!isHostCallbackScheduled) {
+    if (peek(taskQueue) !== null) {
+      isHostCallbackScheduled = true;
+      requestHostCallback();
+    } else {
+      const firstTimer = peek(timerQueue);
+
+      if (firstTimer !== null) {
+        requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
+      }
+    }
+  }
+}
+
+function flushWork(initialTime) {
+
+
+  isHostCallbackScheduled = false;
+
+  if (isHostTimeoutScheduled) {
+    // We scheduled a timeout but it's no longer needed. Cancel it.
+    isHostTimeoutScheduled = false;
+    cancelHostTimeout();
+  }
+
+  isPerformingWork = true;
+  const previousPriorityLevel = currentPriorityLevel;
+
+  try {
+    if (enableProfiling) ; else {
+      // No catch in prod code path.
+      return workLoop(initialTime);
+    }
+  } finally {
+    currentTask = null;
+    currentPriorityLevel = previousPriorityLevel;
+    isPerformingWork = false;
+  }
+}
+
+function workLoop(initialTime) {
+  let currentTime = initialTime;
+  advanceTimers(currentTime);
+  currentTask = peek(taskQueue);
+
+  while (currentTask !== null && !(enableSchedulerDebugging )) {
+    if (currentTask.expirationTime > currentTime && shouldYieldToHost()) {
+      // This currentTask hasn't expired, and we've reached the deadline.
+      break;
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    const callback = currentTask.callback;
+
+    if (typeof callback === 'function') {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      currentTask.callback = null; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+      currentPriorityLevel = currentTask.priorityLevel; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+      const didUserCallbackTimeout = currentTask.expirationTime <= currentTime;
+
+      const continuationCallback = callback(didUserCallbackTimeout);
+      currentTime = exports.unstable_now();
+
+      if (typeof continuationCallback === 'function') {
+        // If a continuation is returned, immediately yield to the main thread
+        // regardless of how much time is left in the current time slice.
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        currentTask.callback = continuationCallback;
+
+        advanceTimers(currentTime);
+        return true;
+      } else {
+
+        if (currentTask === peek(taskQueue)) {
+          pop(taskQueue);
+        }
+
+        advanceTimers(currentTime);
+      }
+    } else {
+      pop(taskQueue);
+    }
+
+    currentTask = peek(taskQueue);
+  } // Return whether there's additional work
+
+
+  if (currentTask !== null) {
+    return true;
+  } else {
+    const firstTimer = peek(timerQueue);
+
+    if (firstTimer !== null) {
+      requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
+    }
+
+    return false;
+  }
+}
+
+function unstable_runWithPriority(priorityLevel, eventHandler) {
+  switch (priorityLevel) {
+    case ImmediatePriority:
+    case UserBlockingPriority:
+    case NormalPriority:
+    case LowPriority:
+    case IdlePriority:
+      break;
+
+    default:
+      priorityLevel = NormalPriority;
+  }
+
+  var previousPriorityLevel = currentPriorityLevel;
+  currentPriorityLevel = priorityLevel;
+
+  try {
+    return eventHandler();
+  } finally {
+    currentPriorityLevel = previousPriorityLevel;
+  }
+}
+
+function unstable_next(eventHandler) {
+  var priorityLevel;
+
+  switch (currentPriorityLevel) {
+    case ImmediatePriority:
+    case UserBlockingPriority:
+    case NormalPriority:
+      // Shift down to normal priority
+      priorityLevel = NormalPriority;
+      break;
+
+    default:
+      // Anything lower than normal priority should remain at the current level.
+      priorityLevel = currentPriorityLevel;
+      break;
+  }
+
+  var previousPriorityLevel = currentPriorityLevel;
+  currentPriorityLevel = priorityLevel;
+
+  try {
+    return eventHandler();
+  } finally {
+    currentPriorityLevel = previousPriorityLevel;
+  }
+}
+
+function unstable_wrapCallback(callback) {
+  var parentPriorityLevel = currentPriorityLevel; // $FlowFixMe[incompatible-return]
+  // $FlowFixMe[missing-this-annot]
+
+  return function () {
+    // This is a fork of runWithPriority, inlined for performance.
+    var previousPriorityLevel = currentPriorityLevel;
+    currentPriorityLevel = parentPriorityLevel;
+
+    try {
+      return callback.apply(this, arguments);
+    } finally {
+      currentPriorityLevel = previousPriorityLevel;
+    }
+  };
+}
+
+function unstable_scheduleCallback(priorityLevel, callback, options) {
+  var currentTime = exports.unstable_now();
+  var startTime;
+
+  if (typeof options === 'object' && options !== null) {
+    var delay = options.delay;
+
+    if (typeof delay === 'number' && delay > 0) {
+      startTime = currentTime + delay;
+    } else {
+      startTime = currentTime;
+    }
+  } else {
+    startTime = currentTime;
+  }
+
+  var timeout;
+
+  switch (priorityLevel) {
+    case ImmediatePriority:
+      timeout = IMMEDIATE_PRIORITY_TIMEOUT;
+      break;
+
+    case UserBlockingPriority:
+      timeout = USER_BLOCKING_PRIORITY_TIMEOUT;
+      break;
+
+    case IdlePriority:
+      timeout = IDLE_PRIORITY_TIMEOUT;
+      break;
+
+    case LowPriority:
+      timeout = LOW_PRIORITY_TIMEOUT;
+      break;
+
+    case NormalPriority:
+    default:
+      timeout = NORMAL_PRIORITY_TIMEOUT;
+      break;
+  }
+
+  var expirationTime = startTime + timeout;
+  var newTask = {
+    id: taskIdCounter++,
+    callback,
+    priorityLevel,
+    startTime,
+    expirationTime,
+    sortIndex: -1
+  };
+
+  if (startTime > currentTime) {
+    // This is a delayed task.
+    newTask.sortIndex = startTime;
+    push(timerQueue, newTask);
+
+    if (peek(taskQueue) === null && newTask === peek(timerQueue)) {
+      // All tasks are delayed, and this is the task with the earliest delay.
+      if (isHostTimeoutScheduled) {
+        // Cancel an existing timeout.
+        cancelHostTimeout();
+      } else {
+        isHostTimeoutScheduled = true;
+      } // Schedule a timeout.
+
+
+      requestHostTimeout(handleTimeout, startTime - currentTime);
+    }
+  } else {
+    newTask.sortIndex = expirationTime;
+    push(taskQueue, newTask);
+    // wait until the next time we yield.
+
+
+    if (!isHostCallbackScheduled && !isPerformingWork) {
+      isHostCallbackScheduled = true;
+      requestHostCallback();
+    }
+  }
+
+  return newTask;
+}
+
+function unstable_pauseExecution() {
+}
+
+function unstable_continueExecution() {
+
+  if (!isHostCallbackScheduled && !isPerformingWork) {
+    isHostCallbackScheduled = true;
+    requestHostCallback();
+  }
+}
+
+function unstable_getFirstCallbackNode() {
+  return peek(taskQueue);
+}
+
+function unstable_cancelCallback(task) {
+  // remove from the queue because you can't remove arbitrary nodes from an
+  // array based heap, only the first one.)
+
+
+  task.callback = null;
+}
+
+function unstable_getCurrentPriorityLevel() {
+  return currentPriorityLevel;
+}
+
+let isMessageLoopRunning = false;
+let taskTimeoutID = -1; // Scheduler periodically yields in case there is other work on the main
+// thread, like user events. By default, it yields multiple times per frame.
+// It does not attempt to align with frame boundaries, since most tasks don't
+// need to be frame aligned; for those that do, use requestAnimationFrame.
+
+let frameInterval = frameYieldMs;
+let startTime = -1;
+
+function shouldYieldToHost() {
+  const timeElapsed = exports.unstable_now() - startTime;
+
+  if (timeElapsed < frameInterval) {
+    // The main thread has only been blocked for a really short amount of time;
+    // smaller than a single frame. Don't yield yet.
+    return false;
+  } // The main thread has been blocked for a non-negligible amount of time. We
+
+
+  return true;
+}
+
+function requestPaint() {
+
+}
+
+function forceFrameRate(fps) {
+  if (fps < 0 || fps > 125) {
+    // Using console['error'] to evade Babel and ESLint
+    console['error']('forceFrameRate takes a positive int between 0 and 125, ' + 'forcing frame rates higher than 125 fps is not supported');
+    return;
+  }
+
+  if (fps > 0) {
+    frameInterval = Math.floor(1000 / fps);
+  } else {
+    // reset the framerate
+    frameInterval = frameYieldMs;
+  }
+}
+
+const performWorkUntilDeadline = () => {
+  if (isMessageLoopRunning) {
+    const currentTime = exports.unstable_now(); // Keep track of the start time so we can measure how long the main thread
+    // has been blocked.
+
+    startTime = currentTime; // If a scheduler task throws, exit the current browser task so the
+    // error can be observed.
+    //
+    // Intentionally not using a try-catch, since that makes some debugging
+    // techniques harder. Instead, if `flushWork` errors, then `hasMoreWork` will
+    // remain true, and we'll continue the work loop.
+
+    let hasMoreWork = true;
+
+    try {
+      hasMoreWork = flushWork(currentTime);
+    } finally {
+      if (hasMoreWork) {
+        // If there's more work, schedule the next message event at the end
+        // of the preceding one.
+        schedulePerformWorkUntilDeadline();
+      } else {
+        isMessageLoopRunning = false;
+      }
+    }
+  } // Yielding to the browser will give it a chance to paint, so we can
+};
+
+let schedulePerformWorkUntilDeadline;
+
+if (typeof localSetImmediate === 'function') {
+  // Node.js and old IE.
+  // There's a few reasons for why we prefer setImmediate.
+  //
+  // Unlike MessageChannel, it doesn't prevent a Node.js process from exiting.
+  // (Even though this is a DOM fork of the Scheduler, you could get here
+  // with a mix of Node.js 15+, which has a MessageChannel, and jsdom.)
+  // https://github.com/facebook/react/issues/20756
+  //
+  // But also, it runs earlier which is the semantic we want.
+  // If other browsers ever implement it, it's better to use it.
+  // Although both of these would be inferior to native scheduling.
+  schedulePerformWorkUntilDeadline = () => {
+    localSetImmediate(performWorkUntilDeadline);
+  };
+} else if (typeof MessageChannel !== 'undefined') {
+  // DOM and Worker environments.
+  // We prefer MessageChannel because of the 4ms setTimeout clamping.
+  const channel = new MessageChannel();
+  const port = channel.port2;
+  channel.port1.onmessage = performWorkUntilDeadline;
+
+  schedulePerformWorkUntilDeadline = () => {
+    port.postMessage(null);
+  };
+} else {
+  // We should only fallback here in non-browser environments.
+  schedulePerformWorkUntilDeadline = () => {
+    // $FlowFixMe[not-a-function] nullable value
+    localSetTimeout(performWorkUntilDeadline, 0);
+  };
+}
+
+function requestHostCallback() {
+  if (!isMessageLoopRunning) {
+    isMessageLoopRunning = true;
+    schedulePerformWorkUntilDeadline();
+  }
+}
+
+function requestHostTimeout(callback, ms) {
+  // $FlowFixMe[not-a-function] nullable value
+  taskTimeoutID = localSetTimeout(() => {
+    callback(exports.unstable_now());
+  }, ms);
+}
+
+function cancelHostTimeout() {
+  // $FlowFixMe[not-a-function] nullable value
+  localClearTimeout(taskTimeoutID);
+  taskTimeoutID = -1;
+}
+const unstable_Profiling = null;
+
+exports.unstable_IdlePriority = IdlePriority;
+exports.unstable_ImmediatePriority = ImmediatePriority;
+exports.unstable_LowPriority = LowPriority;
+exports.unstable_NormalPriority = NormalPriority;
+exports.unstable_Profiling = unstable_Profiling;
+exports.unstable_UserBlockingPriority = UserBlockingPriority;
+exports.unstable_cancelCallback = unstable_cancelCallback;
+exports.unstable_continueExecution = unstable_continueExecution;
+exports.unstable_forceFrameRate = forceFrameRate;
+exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
+exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
+exports.unstable_next = unstable_next;
+exports.unstable_pauseExecution = unstable_pauseExecution;
+exports.unstable_requestPaint = requestPaint;
+exports.unstable_runWithPriority = unstable_runWithPriority;
+exports.unstable_scheduleCallback = unstable_scheduleCallback;
+exports.unstable_shouldYield = shouldYieldToHost;
+exports.unstable_wrapCallback = unstable_wrapCallback;
\ No newline at end of file
diff --git a/packages/next/src/compiled/scheduler-experimental/cjs/scheduler.production.min.js b/packages/next/src/compiled/scheduler-experimental/cjs/scheduler.production.min.js
index e60ea2257d010..325279db98640 100644
--- a/packages/next/src/compiled/scheduler-experimental/cjs/scheduler.production.min.js
+++ b/packages/next/src/compiled/scheduler-experimental/cjs/scheduler.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * scheduler.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ scheduler.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';function f(a,c){var b=a.length;a.push(c);a:for(;0<b;){var d=b-1>>>1,e=a[d];if(0<g(e,c))a[d]=c,a[b]=e,b=d;else break a}}function h(a){return 0===a.length?null:a[0]}function k(a){if(0===a.length)return null;var c=a[0],b=a.pop();if(b!==c){a[0]=b;a:for(var d=0,e=a.length,v=e>>>1;d<v;){var w=2*(d+1)-1,C=a[w],m=w+1,x=a[m];if(0>g(C,b))m<e&&0>g(x,C)?(a[d]=x,a[m]=b,d=m):(a[d]=C,a[w]=b,d=w);else if(m<e&&0>g(x,b))a[d]=x,a[m]=b,d=m;else break a}}return c}
 function g(a,c){var b=a.sortIndex-c.sortIndex;return 0!==b?b:a.id-c.id}exports.unstable_now=void 0;if("object"===typeof performance&&"function"===typeof performance.now){var l=performance;exports.unstable_now=function(){return l.now()}}else{var n=Date,p=n.now();exports.unstable_now=function(){return n.now()-p}}
 var q=[],r=[],t=1,u=null,y=3,z=!1,A=!1,B=!1,D="function"===typeof setTimeout?setTimeout:null,E="function"===typeof clearTimeout?clearTimeout:null,F="undefined"!==typeof setImmediate?setImmediate:null;"undefined"!==typeof navigator&&void 0!==navigator.scheduling&&void 0!==navigator.scheduling.isInputPending?navigator.scheduling.isInputPending.bind(navigator.scheduling):null;
@@ -17,3 +17,5 @@ exports.unstable_UserBlockingPriority=2;exports.unstable_cancelCallback=function
 exports.unstable_next=function(a){switch(y){case 1:case 2:case 3:var c=3;break;default:c=y}var b=y;y=c;try{return a()}finally{y=b}};exports.unstable_pauseExecution=function(){};exports.unstable_requestPaint=function(){};exports.unstable_runWithPriority=function(a,c){switch(a){case 1:case 2:case 3:case 4:case 5:break;default:a=3}var b=y;y=a;try{return c()}finally{y=b}};
 exports.unstable_scheduleCallback=function(a,c,b){var d=exports.unstable_now();"object"===typeof b&&null!==b?(b=b.delay,b="number"===typeof b&&0<b?d+b:d):b=d;switch(a){case 1:var e=-1;break;case 2:e=250;break;case 5:e=1073741823;break;case 4:e=1E4;break;default:e=5E3}e=b+e;a={id:t++,callback:c,priorityLevel:a,startTime:b,expirationTime:e,sortIndex:-1};b>d?(a.sortIndex=b,f(r,a),null===h(q)&&a===h(r)&&(B?(E(L),L=-1):B=!0,J(H,b-d))):(a.sortIndex=e,f(q,a),A||z||(A=!0,I()));return a};
 exports.unstable_shouldYield=O;exports.unstable_wrapCallback=function(a){var c=y;return function(){var b=y;y=c;try{return a.apply(this,arguments)}finally{y=b}}};
+
+//# sourceMappingURL=scheduler.production.min.js.map
diff --git a/packages/next/src/compiled/scheduler/cjs/scheduler-unstable_mock.production.js b/packages/next/src/compiled/scheduler/cjs/scheduler-unstable_mock.production.js
new file mode 100644
index 0000000000000..37da65f72d00f
--- /dev/null
+++ b/packages/next/src/compiled/scheduler/cjs/scheduler-unstable_mock.production.js
@@ -0,0 +1,704 @@
+/**
+ * @license React
+ * scheduler-unstable_mock.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+const enableSchedulerDebugging = false;
+const enableProfiling = false;
+
+function push(heap, node) {
+  const index = heap.length;
+  heap.push(node);
+  siftUp(heap, node, index);
+}
+function peek(heap) {
+  return heap.length === 0 ? null : heap[0];
+}
+function pop(heap) {
+  if (heap.length === 0) {
+    return null;
+  }
+
+  const first = heap[0];
+  const last = heap.pop();
+
+  if (last !== first) {
+    heap[0] = last;
+    siftDown(heap, last, 0);
+  }
+
+  return first;
+}
+
+function siftUp(heap, node, i) {
+  let index = i;
+
+  while (index > 0) {
+    const parentIndex = index - 1 >>> 1;
+    const parent = heap[parentIndex];
+
+    if (compare(parent, node) > 0) {
+      // The parent is larger. Swap positions.
+      heap[parentIndex] = node;
+      heap[index] = parent;
+      index = parentIndex;
+    } else {
+      // The parent is smaller. Exit.
+      return;
+    }
+  }
+}
+
+function siftDown(heap, node, i) {
+  let index = i;
+  const length = heap.length;
+  const halfLength = length >>> 1;
+
+  while (index < halfLength) {
+    const leftIndex = (index + 1) * 2 - 1;
+    const left = heap[leftIndex];
+    const rightIndex = leftIndex + 1;
+    const right = heap[rightIndex]; // If the left or right node is smaller, swap with the smaller of those.
+
+    if (compare(left, node) < 0) {
+      if (rightIndex < length && compare(right, left) < 0) {
+        heap[index] = right;
+        heap[rightIndex] = node;
+        index = rightIndex;
+      } else {
+        heap[index] = left;
+        heap[leftIndex] = node;
+        index = leftIndex;
+      }
+    } else if (rightIndex < length && compare(right, node) < 0) {
+      heap[index] = right;
+      heap[rightIndex] = node;
+      index = rightIndex;
+    } else {
+      // Neither child is smaller. Exit.
+      return;
+    }
+  }
+}
+
+function compare(a, b) {
+  // Compare sort index first, then task id.
+  const diff = a.sortIndex - b.sortIndex;
+  return diff !== 0 ? diff : a.id - b.id;
+}
+
+// TODO: Use symbols?
+const ImmediatePriority = 1;
+const UserBlockingPriority = 2;
+const NormalPriority = 3;
+const LowPriority = 4;
+const IdlePriority = 5;
+
+function markTaskErrored(task, ms) {
+}
+
+/* eslint-disable no-var */
+// Math.pow(2, 30) - 1
+// 0b111111111111111111111111111111
+
+var maxSigned31BitInt = 1073741823; // Times out immediately
+
+var IMMEDIATE_PRIORITY_TIMEOUT = -1; // Eventually times out
+
+var USER_BLOCKING_PRIORITY_TIMEOUT = 250;
+var NORMAL_PRIORITY_TIMEOUT = 5000;
+var LOW_PRIORITY_TIMEOUT = 10000; // Never times out
+
+var IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt; // Tasks are stored on a min heap
+
+var taskQueue = [];
+var timerQueue = []; // Incrementing id counter. Used to maintain insertion order.
+
+var taskIdCounter = 1; // Pausing the scheduler is useful for debugging.
+var currentTask = null;
+var currentPriorityLevel = NormalPriority; // This is set while performing work, to prevent re-entrance.
+
+var isPerformingWork = false;
+var isHostCallbackScheduled = false;
+var isHostTimeoutScheduled = false;
+let currentMockTime = 0;
+let scheduledCallback = null;
+let scheduledTimeout = null;
+let timeoutTime = -1;
+let yieldedValues = null;
+let expectedNumberOfYields = -1;
+let didStop = false;
+let isFlushing = false;
+let needsPaint = false;
+let shouldYieldForPaint = false;
+var disableYieldValue = false;
+
+function setDisableYieldValue(newValue) {
+  disableYieldValue = newValue;
+}
+
+function advanceTimers(currentTime) {
+  // Check for tasks that are no longer delayed and add them to the queue.
+  let timer = peek(timerQueue);
+
+  while (timer !== null) {
+    if (timer.callback === null) {
+      // Timer was cancelled.
+      pop(timerQueue);
+    } else if (timer.startTime <= currentTime) {
+      // Timer fired. Transfer to the task queue.
+      pop(timerQueue);
+      timer.sortIndex = timer.expirationTime;
+      push(taskQueue, timer);
+    } else {
+      // Remaining timers are pending.
+      return;
+    }
+
+    timer = peek(timerQueue);
+  }
+}
+
+function handleTimeout(currentTime) {
+  isHostTimeoutScheduled = false;
+  advanceTimers(currentTime);
+
+  if (!isHostCallbackScheduled) {
+    if (peek(taskQueue) !== null) {
+      isHostCallbackScheduled = true;
+      requestHostCallback(flushWork);
+    } else {
+      const firstTimer = peek(timerQueue);
+
+      if (firstTimer !== null) {
+        requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
+      }
+    }
+  }
+}
+
+function flushWork(hasTimeRemaining, initialTime) {
+
+
+  isHostCallbackScheduled = false;
+
+  if (isHostTimeoutScheduled) {
+    // We scheduled a timeout but it's no longer needed. Cancel it.
+    isHostTimeoutScheduled = false;
+    cancelHostTimeout();
+  }
+
+  isPerformingWork = true;
+  const previousPriorityLevel = currentPriorityLevel;
+
+  try {
+    if (enableProfiling) ; else {
+      // No catch in prod code path.
+      return workLoop(hasTimeRemaining, initialTime);
+    }
+  } finally {
+    currentTask = null;
+    currentPriorityLevel = previousPriorityLevel;
+    isPerformingWork = false;
+  }
+}
+
+function workLoop(hasTimeRemaining, initialTime) {
+  let currentTime = initialTime;
+  advanceTimers(currentTime);
+  currentTask = peek(taskQueue);
+
+  while (currentTask !== null && !(enableSchedulerDebugging )) {
+    if (currentTask.expirationTime > currentTime && (!hasTimeRemaining || shouldYieldToHost())) {
+      // This currentTask hasn't expired, and we've reached the deadline.
+      break;
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    const callback = currentTask.callback;
+
+    if (typeof callback === 'function') {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      currentTask.callback = null; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+      currentPriorityLevel = currentTask.priorityLevel; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+      const didUserCallbackTimeout = currentTask.expirationTime <= currentTime;
+
+      const continuationCallback = callback(didUserCallbackTimeout);
+      currentTime = getCurrentTime();
+
+      if (typeof continuationCallback === 'function') {
+        // If a continuation is returned, immediately yield to the main thread
+        // regardless of how much time is left in the current time slice.
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        currentTask.callback = continuationCallback;
+
+        advanceTimers(currentTime);
+
+        if (shouldYieldForPaint) {
+          needsPaint = true;
+          return true;
+        }
+      } else {
+
+        if (currentTask === peek(taskQueue)) {
+          pop(taskQueue);
+        }
+
+        advanceTimers(currentTime);
+      }
+    } else {
+      pop(taskQueue);
+    }
+
+    currentTask = peek(taskQueue);
+  } // Return whether there's additional work
+
+
+  if (currentTask !== null) {
+    return true;
+  } else {
+    const firstTimer = peek(timerQueue);
+
+    if (firstTimer !== null) {
+      requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
+    }
+
+    return false;
+  }
+}
+
+function unstable_runWithPriority(priorityLevel, eventHandler) {
+  switch (priorityLevel) {
+    case ImmediatePriority:
+    case UserBlockingPriority:
+    case NormalPriority:
+    case LowPriority:
+    case IdlePriority:
+      break;
+
+    default:
+      priorityLevel = NormalPriority;
+  }
+
+  var previousPriorityLevel = currentPriorityLevel;
+  currentPriorityLevel = priorityLevel;
+
+  try {
+    return eventHandler();
+  } finally {
+    currentPriorityLevel = previousPriorityLevel;
+  }
+}
+
+function unstable_next(eventHandler) {
+  var priorityLevel;
+
+  switch (currentPriorityLevel) {
+    case ImmediatePriority:
+    case UserBlockingPriority:
+    case NormalPriority:
+      // Shift down to normal priority
+      priorityLevel = NormalPriority;
+      break;
+
+    default:
+      // Anything lower than normal priority should remain at the current level.
+      priorityLevel = currentPriorityLevel;
+      break;
+  }
+
+  var previousPriorityLevel = currentPriorityLevel;
+  currentPriorityLevel = priorityLevel;
+
+  try {
+    return eventHandler();
+  } finally {
+    currentPriorityLevel = previousPriorityLevel;
+  }
+}
+
+function unstable_wrapCallback(callback) {
+  var parentPriorityLevel = currentPriorityLevel; // $FlowFixMe[incompatible-return]
+  // $FlowFixMe[missing-this-annot]
+
+  return function () {
+    // This is a fork of runWithPriority, inlined for performance.
+    var previousPriorityLevel = currentPriorityLevel;
+    currentPriorityLevel = parentPriorityLevel;
+
+    try {
+      return callback.apply(this, arguments);
+    } finally {
+      currentPriorityLevel = previousPriorityLevel;
+    }
+  };
+}
+
+function unstable_scheduleCallback(priorityLevel, callback, options) {
+  var currentTime = getCurrentTime();
+  var startTime;
+
+  if (typeof options === 'object' && options !== null) {
+    var delay = options.delay;
+
+    if (typeof delay === 'number' && delay > 0) {
+      startTime = currentTime + delay;
+    } else {
+      startTime = currentTime;
+    }
+  } else {
+    startTime = currentTime;
+  }
+
+  var timeout;
+
+  switch (priorityLevel) {
+    case ImmediatePriority:
+      timeout = IMMEDIATE_PRIORITY_TIMEOUT;
+      break;
+
+    case UserBlockingPriority:
+      timeout = USER_BLOCKING_PRIORITY_TIMEOUT;
+      break;
+
+    case IdlePriority:
+      timeout = IDLE_PRIORITY_TIMEOUT;
+      break;
+
+    case LowPriority:
+      timeout = LOW_PRIORITY_TIMEOUT;
+      break;
+
+    case NormalPriority:
+    default:
+      timeout = NORMAL_PRIORITY_TIMEOUT;
+      break;
+  }
+
+  var expirationTime = startTime + timeout;
+  var newTask = {
+    id: taskIdCounter++,
+    callback,
+    priorityLevel,
+    startTime,
+    expirationTime,
+    sortIndex: -1
+  };
+
+  if (startTime > currentTime) {
+    // This is a delayed task.
+    newTask.sortIndex = startTime;
+    push(timerQueue, newTask);
+
+    if (peek(taskQueue) === null && newTask === peek(timerQueue)) {
+      // All tasks are delayed, and this is the task with the earliest delay.
+      if (isHostTimeoutScheduled) {
+        // Cancel an existing timeout.
+        cancelHostTimeout();
+      } else {
+        isHostTimeoutScheduled = true;
+      } // Schedule a timeout.
+
+
+      requestHostTimeout(handleTimeout, startTime - currentTime);
+    }
+  } else {
+    newTask.sortIndex = expirationTime;
+    push(taskQueue, newTask);
+    // wait until the next time we yield.
+
+
+    if (!isHostCallbackScheduled && !isPerformingWork) {
+      isHostCallbackScheduled = true;
+      requestHostCallback(flushWork);
+    }
+  }
+
+  return newTask;
+}
+
+function unstable_pauseExecution() {
+}
+
+function unstable_continueExecution() {
+
+  if (!isHostCallbackScheduled && !isPerformingWork) {
+    isHostCallbackScheduled = true;
+    requestHostCallback(flushWork);
+  }
+}
+
+function unstable_getFirstCallbackNode() {
+  return peek(taskQueue);
+}
+
+function unstable_cancelCallback(task) {
+  // remove from the queue because you can't remove arbitrary nodes from an
+  // array based heap, only the first one.)
+
+
+  task.callback = null;
+}
+
+function unstable_getCurrentPriorityLevel() {
+  return currentPriorityLevel;
+}
+
+function requestHostCallback(callback) {
+  scheduledCallback = callback;
+}
+
+function requestHostTimeout(callback, ms) {
+  scheduledTimeout = callback;
+  timeoutTime = currentMockTime + ms;
+}
+
+function cancelHostTimeout() {
+  scheduledTimeout = null;
+  timeoutTime = -1;
+}
+
+function shouldYieldToHost() {
+  if (expectedNumberOfYields === 0 && yieldedValues === null || expectedNumberOfYields !== -1 && yieldedValues !== null && yieldedValues.length >= expectedNumberOfYields || shouldYieldForPaint && needsPaint) {
+    // We yielded at least as many values as expected. Stop flushing.
+    didStop = true;
+    return true;
+  }
+
+  return false;
+}
+
+function getCurrentTime() {
+  return currentMockTime;
+}
+
+function forceFrameRate() {// No-op
+}
+
+function reset() {
+  if (isFlushing) {
+    throw new Error('Cannot reset while already flushing work.');
+  }
+
+  currentMockTime = 0;
+  scheduledCallback = null;
+  scheduledTimeout = null;
+  timeoutTime = -1;
+  yieldedValues = null;
+  expectedNumberOfYields = -1;
+  didStop = false;
+  isFlushing = false;
+  needsPaint = false;
+} // Should only be used via an assertion helper that inspects the yielded values.
+
+
+function unstable_flushNumberOfYields(count) {
+  if (isFlushing) {
+    throw new Error('Already flushing work.');
+  }
+
+  if (scheduledCallback !== null) {
+    const cb = scheduledCallback;
+    expectedNumberOfYields = count;
+    isFlushing = true;
+
+    try {
+      let hasMoreWork = true;
+
+      do {
+        hasMoreWork = cb(true, currentMockTime);
+      } while (hasMoreWork && !didStop);
+
+      if (!hasMoreWork) {
+        scheduledCallback = null;
+      }
+    } finally {
+      expectedNumberOfYields = -1;
+      didStop = false;
+      isFlushing = false;
+    }
+  }
+}
+
+function unstable_flushUntilNextPaint() {
+  if (isFlushing) {
+    throw new Error('Already flushing work.');
+  }
+
+  if (scheduledCallback !== null) {
+    const cb = scheduledCallback;
+    shouldYieldForPaint = true;
+    needsPaint = false;
+    isFlushing = true;
+
+    try {
+      let hasMoreWork = true;
+
+      do {
+        hasMoreWork = cb(true, currentMockTime);
+      } while (hasMoreWork && !didStop);
+
+      if (!hasMoreWork) {
+        scheduledCallback = null;
+      }
+    } finally {
+      shouldYieldForPaint = false;
+      didStop = false;
+      isFlushing = false;
+    }
+  }
+
+  return false;
+}
+
+function unstable_hasPendingWork() {
+  return scheduledCallback !== null;
+}
+
+function unstable_flushExpired() {
+  if (isFlushing) {
+    throw new Error('Already flushing work.');
+  }
+
+  if (scheduledCallback !== null) {
+    isFlushing = true;
+
+    try {
+      const hasMoreWork = scheduledCallback(false, currentMockTime);
+
+      if (!hasMoreWork) {
+        scheduledCallback = null;
+      }
+    } finally {
+      isFlushing = false;
+    }
+  }
+}
+
+function unstable_flushAllWithoutAsserting() {
+  // Returns false if no work was flushed.
+  if (isFlushing) {
+    throw new Error('Already flushing work.');
+  }
+
+  if (scheduledCallback !== null) {
+    const cb = scheduledCallback;
+    isFlushing = true;
+
+    try {
+      let hasMoreWork = true;
+
+      do {
+        hasMoreWork = cb(true, currentMockTime);
+      } while (hasMoreWork);
+
+      if (!hasMoreWork) {
+        scheduledCallback = null;
+      }
+
+      return true;
+    } finally {
+      isFlushing = false;
+    }
+  } else {
+    return false;
+  }
+}
+
+function unstable_clearLog() {
+  if (yieldedValues === null) {
+    return [];
+  }
+
+  const values = yieldedValues;
+  yieldedValues = null;
+  return values;
+}
+
+function unstable_flushAll() {
+  if (yieldedValues !== null) {
+    throw new Error('Log is not empty. Assert on the log of yielded values before ' + 'flushing additional work.');
+  }
+
+  unstable_flushAllWithoutAsserting();
+
+  if (yieldedValues !== null) {
+    throw new Error('While flushing work, something yielded a value. Use an ' + 'assertion helper to assert on the log of yielded values, e.g. ' + 'expect(Scheduler).toFlushAndYield([...])');
+  }
+}
+
+function log(value) {
+  // eslint-disable-next-line react-internal/no-production-logging
+  if (console.log.name === 'disabledLog' || disableYieldValue) {
+    // If console.log has been patched, we assume we're in render
+    // replaying and we ignore any values yielding in the second pass.
+    return;
+  }
+
+  if (yieldedValues === null) {
+    yieldedValues = [value];
+  } else {
+    yieldedValues.push(value);
+  }
+}
+
+function unstable_advanceTime(ms) {
+  // eslint-disable-next-line react-internal/no-production-logging
+  if (console.log.name === 'disabledLog' || disableYieldValue) {
+    // If console.log has been patched, we assume we're in render
+    // replaying and we ignore any time advancing in the second pass.
+    return;
+  }
+
+  currentMockTime += ms;
+
+  if (scheduledTimeout !== null && timeoutTime <= currentMockTime) {
+    scheduledTimeout(currentMockTime);
+    timeoutTime = -1;
+    scheduledTimeout = null;
+  }
+}
+
+function requestPaint() {
+  needsPaint = true;
+}
+const unstable_Profiling = null;
+
+exports.log = log;
+exports.reset = reset;
+exports.unstable_IdlePriority = IdlePriority;
+exports.unstable_ImmediatePriority = ImmediatePriority;
+exports.unstable_LowPriority = LowPriority;
+exports.unstable_NormalPriority = NormalPriority;
+exports.unstable_Profiling = unstable_Profiling;
+exports.unstable_UserBlockingPriority = UserBlockingPriority;
+exports.unstable_advanceTime = unstable_advanceTime;
+exports.unstable_cancelCallback = unstable_cancelCallback;
+exports.unstable_clearLog = unstable_clearLog;
+exports.unstable_continueExecution = unstable_continueExecution;
+exports.unstable_flushAll = unstable_flushAll;
+exports.unstable_flushAllWithoutAsserting = unstable_flushAllWithoutAsserting;
+exports.unstable_flushExpired = unstable_flushExpired;
+exports.unstable_flushNumberOfYields = unstable_flushNumberOfYields;
+exports.unstable_flushUntilNextPaint = unstable_flushUntilNextPaint;
+exports.unstable_forceFrameRate = forceFrameRate;
+exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
+exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
+exports.unstable_hasPendingWork = unstable_hasPendingWork;
+exports.unstable_next = unstable_next;
+exports.unstable_now = getCurrentTime;
+exports.unstable_pauseExecution = unstable_pauseExecution;
+exports.unstable_requestPaint = requestPaint;
+exports.unstable_runWithPriority = unstable_runWithPriority;
+exports.unstable_scheduleCallback = unstable_scheduleCallback;
+exports.unstable_setDisableYieldValue = setDisableYieldValue;
+exports.unstable_shouldYield = shouldYieldToHost;
+exports.unstable_wrapCallback = unstable_wrapCallback;
\ No newline at end of file
diff --git a/packages/next/src/compiled/scheduler/cjs/scheduler-unstable_mock.production.min.js b/packages/next/src/compiled/scheduler/cjs/scheduler-unstable_mock.production.min.js
index 92dfc9eea69d5..61bc18c5e5336 100644
--- a/packages/next/src/compiled/scheduler/cjs/scheduler-unstable_mock.production.min.js
+++ b/packages/next/src/compiled/scheduler/cjs/scheduler-unstable_mock.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * scheduler-unstable_mock.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ scheduler-unstable_mock.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';function f(a,b){var c=a.length;a.push(b);a:for(;0<c;){var d=c-1>>>1,e=a[d];if(0<g(e,b))a[d]=b,a[c]=e,c=d;else break a}}function h(a){return 0===a.length?null:a[0]}function k(a){if(0===a.length)return null;var b=a[0],c=a.pop();if(c!==b){a[0]=c;a:for(var d=0,e=a.length,z=e>>>1;d<z;){var u=2*(d+1)-1,A=a[u],v=u+1,F=a[v];if(0>g(A,c))v<e&&0>g(F,A)?(a[d]=F,a[v]=c,d=v):(a[d]=A,a[u]=c,d=u);else if(v<e&&0>g(F,c))a[d]=F,a[v]=c,d=v;else break a}}return b}
 function g(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}var l=[],m=[],n=1,p=null,q=3,r=!1,t=!1,w=!1,x=0,y=null,B=null,C=-1,D=null,E=-1,G=!1,H=!1,I=!1,J=!1,K=!1;function L(a){for(var b=h(m);null!==b;){if(null===b.callback)k(m);else if(b.startTime<=a)k(m),b.sortIndex=b.expirationTime,f(l,b);else break;b=h(m)}}function M(a){w=!1;L(a);if(!t)if(null!==h(l))t=!0,y=N;else{var b=h(m);null!==b&&(a=b.startTime-a,B=M,C=x+a)}}
 function N(a,b){t=!1;w&&(w=!1,B=null,C=-1);r=!0;var c=q;try{a:{L(b);for(p=h(l);null!==p&&(!(p.expirationTime>b)||a&&!O());){var d=p.callback;if("function"===typeof d){p.callback=null;q=p.priorityLevel;var e=d(p.expirationTime<=b);b=x;if("function"===typeof e){if(p.callback=e,L(b),J){var z=I=!0;break a}}else p===h(l)&&k(l),L(b)}else k(l);p=h(l)}if(null!==p)z=!0;else{var u=h(m);if(null!==u){var A=u.startTime-b;B=M;C=x+A}z=!1}}return z}finally{p=null,q=c,r=!1}}
@@ -18,3 +18,5 @@ exports.unstable_flushUntilNextPaint=function(){if(H)throw Error("Already flushi
 exports.unstable_next=function(a){switch(q){case 1:case 2:case 3:var b=3;break;default:b=q}var c=q;q=b;try{return a()}finally{q=c}};exports.unstable_now=function(){return x};exports.unstable_pauseExecution=function(){};exports.unstable_requestPaint=function(){I=!0};exports.unstable_runWithPriority=function(a,b){switch(a){case 1:case 2:case 3:case 4:case 5:break;default:a=3}var c=q;q=a;try{return b()}finally{q=c}};
 exports.unstable_scheduleCallback=function(a,b,c){var d=x;"object"===typeof c&&null!==c?(c=c.delay,c="number"===typeof c&&0<c?d+c:d):c=d;switch(a){case 1:var e=-1;break;case 2:e=250;break;case 5:e=1073741823;break;case 4:e=1E4;break;default:e=5E3}e=c+e;a={id:n++,callback:b,priorityLevel:a,startTime:c,expirationTime:e,sortIndex:-1};c>d?(a.sortIndex=c,f(m,a),null===h(l)&&a===h(m)&&(w?(B=null,C=-1):w=!0,B=M,C=x+(c-d))):(a.sortIndex=e,f(l,a),t||r||(t=!0,y=N));return a};
 exports.unstable_setDisableYieldValue=function(a){K=a};exports.unstable_shouldYield=O;exports.unstable_wrapCallback=function(a){var b=q;return function(){var c=q;q=b;try{return a.apply(this,arguments)}finally{q=c}}};
+
+//# sourceMappingURL=scheduler-unstable_mock.production.min.js.map
diff --git a/packages/next/src/compiled/scheduler/cjs/scheduler-unstable_post_task.production.js b/packages/next/src/compiled/scheduler/cjs/scheduler-unstable_post_task.production.js
new file mode 100644
index 0000000000000..e34f6064c6d19
--- /dev/null
+++ b/packages/next/src/compiled/scheduler/cjs/scheduler-unstable_post_task.production.js
@@ -0,0 +1,202 @@
+/**
+ * @license React
+ * scheduler-unstable_post_task.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+// TODO: Use symbols?
+const ImmediatePriority = 1;
+const UserBlockingPriority = 2;
+const NormalPriority = 3;
+const LowPriority = 4;
+const IdlePriority = 5;
+
+const perf = window.performance;
+const setTimeout = window.setTimeout; // Use experimental Chrome Scheduler postTask API.
+
+const scheduler = global.scheduler;
+const getCurrentTime = perf.now.bind(perf);
+const unstable_now = getCurrentTime; // Scheduler periodically yields in case there is other work on the main
+// thread, like user events. By default, it yields multiple times per frame.
+// It does not attempt to align with frame boundaries, since most tasks don't
+// need to be frame aligned; for those that do, use requestAnimationFrame.
+
+const yieldInterval = 5;
+let deadline = 0;
+let currentPriorityLevel_DEPRECATED = NormalPriority; // `isInputPending` is not available. Since we have no way of knowing if
+// there's pending input, always yield at the end of the frame.
+
+function unstable_shouldYield() {
+  return getCurrentTime() >= deadline;
+}
+function unstable_requestPaint() {// Since we yield every frame regardless, `requestPaint` has no effect.
+}
+function unstable_scheduleCallback(priorityLevel, callback, options) {
+  let postTaskPriority;
+
+  switch (priorityLevel) {
+    case ImmediatePriority:
+    case UserBlockingPriority:
+      postTaskPriority = 'user-blocking';
+      break;
+
+    case LowPriority:
+    case NormalPriority:
+      postTaskPriority = 'user-visible';
+      break;
+
+    case IdlePriority:
+      postTaskPriority = 'background';
+      break;
+
+    default:
+      postTaskPriority = 'user-visible';
+      break;
+  }
+
+  const controller = new TaskController({
+    priority: postTaskPriority
+  });
+  const postTaskOptions = {
+    delay: typeof options === 'object' && options !== null ? options.delay : 0,
+    signal: controller.signal
+  };
+  const node = {
+    _controller: controller
+  };
+  scheduler.postTask(runTask.bind(null, priorityLevel, postTaskPriority, node, callback), postTaskOptions).catch(handleAbortError);
+  return node;
+}
+
+function runTask(priorityLevel, postTaskPriority, node, callback) {
+  deadline = getCurrentTime() + yieldInterval;
+
+  try {
+    currentPriorityLevel_DEPRECATED = priorityLevel;
+    const didTimeout_DEPRECATED = false;
+    const result = callback(didTimeout_DEPRECATED);
+
+    if (typeof result === 'function') {
+      // Assume this is a continuation
+      const continuation = result;
+      const continuationOptions = {
+        signal: node._controller.signal
+      };
+      const nextTask = runTask.bind(null, priorityLevel, postTaskPriority, node, continuation);
+
+      if (scheduler.yield !== undefined) {
+        scheduler.yield(continuationOptions).then(nextTask).catch(handleAbortError);
+      } else {
+        scheduler.postTask(nextTask, continuationOptions).catch(handleAbortError);
+      }
+    }
+  } catch (error) {
+    // We're inside a `postTask` promise. If we don't handle this error, then it
+    // will trigger an "Unhandled promise rejection" error. We don't want that,
+    // but we do want the default error reporting behavior that normal
+    // (non-Promise) tasks get for unhandled errors.
+    //
+    // So we'll re-throw the error inside a regular browser task.
+    setTimeout(() => {
+      throw error;
+    });
+  } finally {
+    currentPriorityLevel_DEPRECATED = NormalPriority;
+  }
+}
+
+function handleAbortError(error) {// Abort errors are an implementation detail. We don't expose the
+  // TaskController to the user, nor do we expose the promise that is returned
+  // from `postTask`. So we should suppress them, since there's no way for the
+  // user to handle them.
+}
+
+function unstable_cancelCallback(node) {
+  const controller = node._controller;
+  controller.abort();
+}
+function unstable_runWithPriority(priorityLevel, callback) {
+  const previousPriorityLevel = currentPriorityLevel_DEPRECATED;
+  currentPriorityLevel_DEPRECATED = priorityLevel;
+
+  try {
+    return callback();
+  } finally {
+    currentPriorityLevel_DEPRECATED = previousPriorityLevel;
+  }
+}
+function unstable_getCurrentPriorityLevel() {
+  return currentPriorityLevel_DEPRECATED;
+}
+function unstable_next(callback) {
+  let priorityLevel;
+
+  switch (currentPriorityLevel_DEPRECATED) {
+    case ImmediatePriority:
+    case UserBlockingPriority:
+    case NormalPriority:
+      // Shift down to normal priority
+      priorityLevel = NormalPriority;
+      break;
+
+    default:
+      // Anything lower than normal priority should remain at the current level.
+      priorityLevel = currentPriorityLevel_DEPRECATED;
+      break;
+  }
+
+  const previousPriorityLevel = currentPriorityLevel_DEPRECATED;
+  currentPriorityLevel_DEPRECATED = priorityLevel;
+
+  try {
+    return callback();
+  } finally {
+    currentPriorityLevel_DEPRECATED = previousPriorityLevel;
+  }
+}
+function unstable_wrapCallback(callback) {
+  const parentPriorityLevel = currentPriorityLevel_DEPRECATED;
+  return () => {
+    const previousPriorityLevel = currentPriorityLevel_DEPRECATED;
+    currentPriorityLevel_DEPRECATED = parentPriorityLevel;
+
+    try {
+      return callback();
+    } finally {
+      currentPriorityLevel_DEPRECATED = previousPriorityLevel;
+    }
+  };
+}
+function unstable_forceFrameRate() {}
+function unstable_pauseExecution() {}
+function unstable_continueExecution() {}
+function unstable_getFirstCallbackNode() {
+  return null;
+} // Currently no profiling build
+
+const unstable_Profiling = null;
+
+exports.unstable_IdlePriority = IdlePriority;
+exports.unstable_ImmediatePriority = ImmediatePriority;
+exports.unstable_LowPriority = LowPriority;
+exports.unstable_NormalPriority = NormalPriority;
+exports.unstable_Profiling = unstable_Profiling;
+exports.unstable_UserBlockingPriority = UserBlockingPriority;
+exports.unstable_cancelCallback = unstable_cancelCallback;
+exports.unstable_continueExecution = unstable_continueExecution;
+exports.unstable_forceFrameRate = unstable_forceFrameRate;
+exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
+exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
+exports.unstable_next = unstable_next;
+exports.unstable_now = unstable_now;
+exports.unstable_pauseExecution = unstable_pauseExecution;
+exports.unstable_requestPaint = unstable_requestPaint;
+exports.unstable_runWithPriority = unstable_runWithPriority;
+exports.unstable_scheduleCallback = unstable_scheduleCallback;
+exports.unstable_shouldYield = unstable_shouldYield;
+exports.unstable_wrapCallback = unstable_wrapCallback;
\ No newline at end of file
diff --git a/packages/next/src/compiled/scheduler/cjs/scheduler-unstable_post_task.production.min.js b/packages/next/src/compiled/scheduler/cjs/scheduler-unstable_post_task.production.min.js
index d721933ddac72..61c83e75c1942 100644
--- a/packages/next/src/compiled/scheduler/cjs/scheduler-unstable_post_task.production.min.js
+++ b/packages/next/src/compiled/scheduler/cjs/scheduler-unstable_post_task.production.min.js
@@ -1,14 +1,16 @@
-/**
- * @license React
- * scheduler-unstable_post_task.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ scheduler-unstable_post_task.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';var a=window.performance,g=window.setTimeout,h=global.scheduler,k=a.now.bind(a),l=0,m=3;function n(c,d,b,f){l=k()+5;try{m=c;var e=f(!1);if("function"===typeof e){var p={signal:b._controller.signal},q=n.bind(null,c,d,b,e);void 0!==h.yield?h.yield(p).then(q).catch(r):h.postTask(q,p).catch(r)}}catch(t){g(function(){throw t;})}finally{m=3}}function r(){}exports.unstable_IdlePriority=5;exports.unstable_ImmediatePriority=1;exports.unstable_LowPriority=4;exports.unstable_NormalPriority=3;
 exports.unstable_Profiling=null;exports.unstable_UserBlockingPriority=2;exports.unstable_cancelCallback=function(c){c._controller.abort()};exports.unstable_continueExecution=function(){};exports.unstable_forceFrameRate=function(){};exports.unstable_getCurrentPriorityLevel=function(){return m};exports.unstable_getFirstCallbackNode=function(){return null};exports.unstable_next=function(c){switch(m){case 1:case 2:case 3:var d=3;break;default:d=m}var b=m;m=d;try{return c()}finally{m=b}};
 exports.unstable_now=k;exports.unstable_pauseExecution=function(){};exports.unstable_requestPaint=function(){};exports.unstable_runWithPriority=function(c,d){var b=m;m=c;try{return d()}finally{m=b}};
 exports.unstable_scheduleCallback=function(c,d,b){switch(c){case 1:case 2:var f="user-blocking";break;case 4:case 3:f="user-visible";break;case 5:f="background";break;default:f="user-visible"}var e=new TaskController({priority:f});b={delay:"object"===typeof b&&null!==b?b.delay:0,signal:e.signal};e={_controller:e};h.postTask(n.bind(null,c,f,e,d),b).catch(r);return e};exports.unstable_shouldYield=function(){return k()>=l};
 exports.unstable_wrapCallback=function(c){var d=m;return function(){var b=m;m=d;try{return c()}finally{m=b}}};
+
+//# sourceMappingURL=scheduler-unstable_post_task.production.min.js.map
diff --git a/packages/next/src/compiled/scheduler/cjs/scheduler.native.production.js b/packages/next/src/compiled/scheduler/cjs/scheduler.native.production.js
new file mode 100644
index 0000000000000..4da95b88005a4
--- /dev/null
+++ b/packages/next/src/compiled/scheduler/cjs/scheduler.native.production.js
@@ -0,0 +1,533 @@
+/**
+ * @license React
+ * scheduler.native.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+const enableSchedulerDebugging = false;
+const enableProfiling = false;
+const frameYieldMs = 5;
+
+function push(heap, node) {
+  const index = heap.length;
+  heap.push(node);
+  siftUp(heap, node, index);
+}
+function peek(heap) {
+  return heap.length === 0 ? null : heap[0];
+}
+function pop(heap) {
+  if (heap.length === 0) {
+    return null;
+  }
+
+  const first = heap[0];
+  const last = heap.pop();
+
+  if (last !== first) {
+    heap[0] = last;
+    siftDown(heap, last, 0);
+  }
+
+  return first;
+}
+
+function siftUp(heap, node, i) {
+  let index = i;
+
+  while (index > 0) {
+    const parentIndex = index - 1 >>> 1;
+    const parent = heap[parentIndex];
+
+    if (compare(parent, node) > 0) {
+      // The parent is larger. Swap positions.
+      heap[parentIndex] = node;
+      heap[index] = parent;
+      index = parentIndex;
+    } else {
+      // The parent is smaller. Exit.
+      return;
+    }
+  }
+}
+
+function siftDown(heap, node, i) {
+  let index = i;
+  const length = heap.length;
+  const halfLength = length >>> 1;
+
+  while (index < halfLength) {
+    const leftIndex = (index + 1) * 2 - 1;
+    const left = heap[leftIndex];
+    const rightIndex = leftIndex + 1;
+    const right = heap[rightIndex]; // If the left or right node is smaller, swap with the smaller of those.
+
+    if (compare(left, node) < 0) {
+      if (rightIndex < length && compare(right, left) < 0) {
+        heap[index] = right;
+        heap[rightIndex] = node;
+        index = rightIndex;
+      } else {
+        heap[index] = left;
+        heap[leftIndex] = node;
+        index = leftIndex;
+      }
+    } else if (rightIndex < length && compare(right, node) < 0) {
+      heap[index] = right;
+      heap[rightIndex] = node;
+      index = rightIndex;
+    } else {
+      // Neither child is smaller. Exit.
+      return;
+    }
+  }
+}
+
+function compare(a, b) {
+  // Compare sort index first, then task id.
+  const diff = a.sortIndex - b.sortIndex;
+  return diff !== 0 ? diff : a.id - b.id;
+}
+
+// TODO: Use symbols?
+const ImmediatePriority = 1;
+const UserBlockingPriority = 2;
+const NormalPriority = 3;
+const LowPriority = 4;
+const IdlePriority = 5;
+
+function markTaskErrored(task, ms) {
+}
+
+/* eslint-disable no-var */
+let getCurrentTime;
+const hasPerformanceNow = // $FlowFixMe[method-unbinding]
+typeof performance === 'object' && typeof performance.now === 'function';
+
+if (hasPerformanceNow) {
+  const localPerformance = performance;
+
+  getCurrentTime = () => localPerformance.now();
+} else {
+  const localDate = Date;
+  const initialTime = localDate.now();
+
+  getCurrentTime = () => localDate.now() - initialTime;
+} // Max 31 bit integer. The max integer size in V8 for 32-bit systems.
+// Math.pow(2, 30) - 1
+// 0b111111111111111111111111111111
+
+
+var maxSigned31BitInt = 1073741823; // Times out immediately
+
+var IMMEDIATE_PRIORITY_TIMEOUT = -1; // Eventually times out
+
+var USER_BLOCKING_PRIORITY_TIMEOUT = 250;
+var NORMAL_PRIORITY_TIMEOUT = 5000;
+var LOW_PRIORITY_TIMEOUT = 10000; // Never times out
+
+var IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt; // Tasks are stored on a min heap
+
+var taskQueue = [];
+var timerQueue = []; // Incrementing id counter. Used to maintain insertion order.
+
+var taskIdCounter = 1; // Pausing the scheduler is useful for debugging.
+var currentTask = null;
+var currentPriorityLevel = NormalPriority; // This is set while performing work, to prevent re-entrance.
+
+var isPerformingWork = false;
+var isHostCallbackScheduled = false;
+var isHostTimeoutScheduled = false; // Capture local references to native APIs, in case a polyfill overrides them.
+
+const localSetTimeout = typeof setTimeout === 'function' ? setTimeout : null;
+const localClearTimeout = typeof clearTimeout === 'function' ? clearTimeout : null;
+const localSetImmediate = typeof setImmediate !== 'undefined' ? setImmediate : null; // IE and Node.js + jsdom
+
+typeof navigator !== 'undefined' && // $FlowFixMe[prop-missing]
+navigator.scheduling !== undefined && // $FlowFixMe[incompatible-type]
+navigator.scheduling.isInputPending !== undefined ? navigator.scheduling.isInputPending.bind(navigator.scheduling) : null;
+
+function advanceTimers(currentTime) {
+  // Check for tasks that are no longer delayed and add them to the queue.
+  let timer = peek(timerQueue);
+
+  while (timer !== null) {
+    if (timer.callback === null) {
+      // Timer was cancelled.
+      pop(timerQueue);
+    } else if (timer.startTime <= currentTime) {
+      // Timer fired. Transfer to the task queue.
+      pop(timerQueue);
+      timer.sortIndex = timer.expirationTime;
+      push(taskQueue, timer);
+    } else {
+      // Remaining timers are pending.
+      return;
+    }
+
+    timer = peek(timerQueue);
+  }
+}
+
+function handleTimeout(currentTime) {
+  isHostTimeoutScheduled = false;
+  advanceTimers(currentTime);
+
+  if (!isHostCallbackScheduled) {
+    if (peek(taskQueue) !== null) {
+      isHostCallbackScheduled = true;
+      requestHostCallback();
+    } else {
+      const firstTimer = peek(timerQueue);
+
+      if (firstTimer !== null) {
+        requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
+      }
+    }
+  }
+}
+
+function flushWork(initialTime) {
+
+
+  isHostCallbackScheduled = false;
+
+  if (isHostTimeoutScheduled) {
+    // We scheduled a timeout but it's no longer needed. Cancel it.
+    isHostTimeoutScheduled = false;
+    cancelHostTimeout();
+  }
+
+  isPerformingWork = true;
+  const previousPriorityLevel = currentPriorityLevel;
+
+  try {
+    if (enableProfiling) ; else {
+      // No catch in prod code path.
+      return workLoop(initialTime);
+    }
+  } finally {
+    currentTask = null;
+    currentPriorityLevel = previousPriorityLevel;
+    isPerformingWork = false;
+  }
+}
+
+function workLoop(initialTime) {
+  let currentTime = initialTime;
+  advanceTimers(currentTime);
+  currentTask = peek(taskQueue);
+
+  while (currentTask !== null && !(enableSchedulerDebugging )) {
+    if (currentTask.expirationTime > currentTime && shouldYieldToHost()) {
+      // This currentTask hasn't expired, and we've reached the deadline.
+      break;
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    const callback = currentTask.callback;
+
+    if (typeof callback === 'function') {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      currentTask.callback = null; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+      currentPriorityLevel = currentTask.priorityLevel; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+      const didUserCallbackTimeout = currentTask.expirationTime <= currentTime;
+
+      const continuationCallback = callback(didUserCallbackTimeout);
+      currentTime = getCurrentTime();
+
+      if (typeof continuationCallback === 'function') {
+        // If a continuation is returned, immediately yield to the main thread
+        // regardless of how much time is left in the current time slice.
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        currentTask.callback = continuationCallback;
+
+        advanceTimers(currentTime);
+        return true;
+      } else {
+
+        if (currentTask === peek(taskQueue)) {
+          pop(taskQueue);
+        }
+
+        advanceTimers(currentTime);
+      }
+    } else {
+      pop(taskQueue);
+    }
+
+    currentTask = peek(taskQueue);
+  } // Return whether there's additional work
+
+
+  if (currentTask !== null) {
+    return true;
+  } else {
+    const firstTimer = peek(timerQueue);
+
+    if (firstTimer !== null) {
+      requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
+    }
+
+    return false;
+  }
+}
+
+function unstable_scheduleCallback$1(priorityLevel, callback, options) {
+  var currentTime = getCurrentTime();
+  var startTime;
+
+  if (typeof options === 'object' && options !== null) {
+    var delay = options.delay;
+
+    if (typeof delay === 'number' && delay > 0) {
+      startTime = currentTime + delay;
+    } else {
+      startTime = currentTime;
+    }
+  } else {
+    startTime = currentTime;
+  }
+
+  var timeout;
+
+  switch (priorityLevel) {
+    case ImmediatePriority:
+      timeout = IMMEDIATE_PRIORITY_TIMEOUT;
+      break;
+
+    case UserBlockingPriority:
+      timeout = USER_BLOCKING_PRIORITY_TIMEOUT;
+      break;
+
+    case IdlePriority:
+      timeout = IDLE_PRIORITY_TIMEOUT;
+      break;
+
+    case LowPriority:
+      timeout = LOW_PRIORITY_TIMEOUT;
+      break;
+
+    case NormalPriority:
+    default:
+      timeout = NORMAL_PRIORITY_TIMEOUT;
+      break;
+  }
+
+  var expirationTime = startTime + timeout;
+  var newTask = {
+    id: taskIdCounter++,
+    callback,
+    priorityLevel,
+    startTime,
+    expirationTime,
+    sortIndex: -1
+  };
+
+  if (startTime > currentTime) {
+    // This is a delayed task.
+    newTask.sortIndex = startTime;
+    push(timerQueue, newTask);
+
+    if (peek(taskQueue) === null && newTask === peek(timerQueue)) {
+      // All tasks are delayed, and this is the task with the earliest delay.
+      if (isHostTimeoutScheduled) {
+        // Cancel an existing timeout.
+        cancelHostTimeout();
+      } else {
+        isHostTimeoutScheduled = true;
+      } // Schedule a timeout.
+
+
+      requestHostTimeout(handleTimeout, startTime - currentTime);
+    }
+  } else {
+    newTask.sortIndex = expirationTime;
+    push(taskQueue, newTask);
+    // wait until the next time we yield.
+
+
+    if (!isHostCallbackScheduled && !isPerformingWork) {
+      isHostCallbackScheduled = true;
+      requestHostCallback();
+    }
+  }
+
+  return newTask;
+}
+
+function unstable_cancelCallback$1(task) {
+  // remove from the queue because you can't remove arbitrary nodes from an
+  // array based heap, only the first one.)
+
+
+  task.callback = null;
+}
+
+function unstable_getCurrentPriorityLevel$1() {
+  return currentPriorityLevel;
+}
+
+let isMessageLoopRunning = false;
+let taskTimeoutID = -1; // Scheduler periodically yields in case there is other work on the main
+// thread, like user events. By default, it yields multiple times per frame.
+// It does not attempt to align with frame boundaries, since most tasks don't
+// need to be frame aligned; for those that do, use requestAnimationFrame.
+
+let frameInterval = frameYieldMs;
+let startTime = -1;
+
+function shouldYieldToHost() {
+  const timeElapsed = getCurrentTime() - startTime;
+
+  if (timeElapsed < frameInterval) {
+    // The main thread has only been blocked for a really short amount of time;
+    // smaller than a single frame. Don't yield yet.
+    return false;
+  } // The main thread has been blocked for a non-negligible amount of time. We
+
+
+  return true;
+}
+
+function requestPaint() {
+
+}
+
+const performWorkUntilDeadline = () => {
+  if (isMessageLoopRunning) {
+    const currentTime = getCurrentTime(); // Keep track of the start time so we can measure how long the main thread
+    // has been blocked.
+
+    startTime = currentTime; // If a scheduler task throws, exit the current browser task so the
+    // error can be observed.
+    //
+    // Intentionally not using a try-catch, since that makes some debugging
+    // techniques harder. Instead, if `flushWork` errors, then `hasMoreWork` will
+    // remain true, and we'll continue the work loop.
+
+    let hasMoreWork = true;
+
+    try {
+      hasMoreWork = flushWork(currentTime);
+    } finally {
+      if (hasMoreWork) {
+        // If there's more work, schedule the next message event at the end
+        // of the preceding one.
+        schedulePerformWorkUntilDeadline();
+      } else {
+        isMessageLoopRunning = false;
+      }
+    }
+  } // Yielding to the browser will give it a chance to paint, so we can
+};
+
+let schedulePerformWorkUntilDeadline;
+
+if (typeof localSetImmediate === 'function') {
+  // Node.js and old IE.
+  // There's a few reasons for why we prefer setImmediate.
+  //
+  // Unlike MessageChannel, it doesn't prevent a Node.js process from exiting.
+  // (Even though this is a DOM fork of the Scheduler, you could get here
+  // with a mix of Node.js 15+, which has a MessageChannel, and jsdom.)
+  // https://github.com/facebook/react/issues/20756
+  //
+  // But also, it runs earlier which is the semantic we want.
+  // If other browsers ever implement it, it's better to use it.
+  // Although both of these would be inferior to native scheduling.
+  schedulePerformWorkUntilDeadline = () => {
+    localSetImmediate(performWorkUntilDeadline);
+  };
+} else if (typeof MessageChannel !== 'undefined') {
+  // DOM and Worker environments.
+  // We prefer MessageChannel because of the 4ms setTimeout clamping.
+  const channel = new MessageChannel();
+  const port = channel.port2;
+  channel.port1.onmessage = performWorkUntilDeadline;
+
+  schedulePerformWorkUntilDeadline = () => {
+    port.postMessage(null);
+  };
+} else {
+  // We should only fallback here in non-browser environments.
+  schedulePerformWorkUntilDeadline = () => {
+    // $FlowFixMe[not-a-function] nullable value
+    localSetTimeout(performWorkUntilDeadline, 0);
+  };
+}
+
+function requestHostCallback() {
+  if (!isMessageLoopRunning) {
+    isMessageLoopRunning = true;
+    schedulePerformWorkUntilDeadline();
+  }
+}
+
+function requestHostTimeout(callback, ms) {
+  // $FlowFixMe[not-a-function] nullable value
+  taskTimeoutID = localSetTimeout(() => {
+    callback(getCurrentTime());
+  }, ms);
+}
+
+function cancelHostTimeout() {
+  // $FlowFixMe[not-a-function] nullable value
+  localClearTimeout(taskTimeoutID);
+  taskTimeoutID = -1;
+}
+
+// https://github.com/facebook/react-native/blob/main/packages/react-native/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerBinding.cpp
+
+const unstable_UserBlockingPriority = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_UserBlockingPriority : UserBlockingPriority;
+const unstable_NormalPriority = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_NormalPriority : NormalPriority;
+const unstable_IdlePriority = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_IdlePriority : IdlePriority;
+const unstable_LowPriority = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_LowPriority : LowPriority;
+const unstable_ImmediatePriority = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_ImmediatePriority : ImmediatePriority;
+const unstable_scheduleCallback = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_scheduleCallback : unstable_scheduleCallback$1;
+const unstable_cancelCallback = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_cancelCallback : unstable_cancelCallback$1;
+const unstable_getCurrentPriorityLevel = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_getCurrentPriorityLevel : unstable_getCurrentPriorityLevel$1;
+const unstable_shouldYield = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_shouldYield : shouldYieldToHost;
+const unstable_requestPaint = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_requestPaint : requestPaint;
+const unstable_now = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_now : getCurrentTime; // These were never implemented on the native scheduler because React never calls them.
+// For consistency, let's disable them altogether and make them throw.
+
+const unstable_next = throwNotImplemented;
+const unstable_runWithPriority = throwNotImplemented;
+const unstable_wrapCallback = throwNotImplemented;
+const unstable_continueExecution = throwNotImplemented;
+const unstable_pauseExecution = throwNotImplemented;
+const unstable_getFirstCallbackNode = throwNotImplemented;
+const unstable_forceFrameRate = throwNotImplemented;
+const unstable_Profiling = null;
+
+function throwNotImplemented() {
+  throw Error('Not implemented.');
+} // Flow magic to verify the exports of this file match the original version.
+
+exports.unstable_IdlePriority = unstable_IdlePriority;
+exports.unstable_ImmediatePriority = unstable_ImmediatePriority;
+exports.unstable_LowPriority = unstable_LowPriority;
+exports.unstable_NormalPriority = unstable_NormalPriority;
+exports.unstable_Profiling = unstable_Profiling;
+exports.unstable_UserBlockingPriority = unstable_UserBlockingPriority;
+exports.unstable_cancelCallback = unstable_cancelCallback;
+exports.unstable_continueExecution = unstable_continueExecution;
+exports.unstable_forceFrameRate = unstable_forceFrameRate;
+exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
+exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
+exports.unstable_next = unstable_next;
+exports.unstable_now = unstable_now;
+exports.unstable_pauseExecution = unstable_pauseExecution;
+exports.unstable_requestPaint = unstable_requestPaint;
+exports.unstable_runWithPriority = unstable_runWithPriority;
+exports.unstable_scheduleCallback = unstable_scheduleCallback;
+exports.unstable_shouldYield = unstable_shouldYield;
+exports.unstable_wrapCallback = unstable_wrapCallback;
\ No newline at end of file
diff --git a/packages/next/src/compiled/scheduler/cjs/scheduler.native.production.min.js b/packages/next/src/compiled/scheduler/cjs/scheduler.native.production.min.js
index 32e6f2edefde2..6e5c36e9e32ee 100644
--- a/packages/next/src/compiled/scheduler/cjs/scheduler.native.production.min.js
+++ b/packages/next/src/compiled/scheduler/cjs/scheduler.native.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * scheduler.native.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ scheduler.native.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';function f(a,c){var b=a.length;a.push(c);a:for(;0<b;){var d=b-1>>>1,e=a[d];if(0<g(e,c))a[d]=c,a[b]=e,b=d;else break a}}function h(a){return 0===a.length?null:a[0]}function k(a){if(0===a.length)return null;var c=a[0],b=a.pop();if(b!==c){a[0]=b;a:for(var d=0,e=a.length,x=e>>>1;d<x;){var y=2*(d+1)-1,D=a[y],m=y+1,z=a[m];if(0>g(D,b))m<e&&0>g(z,D)?(a[d]=z,a[m]=b,d=m):(a[d]=D,a[y]=b,d=y);else if(m<e&&0>g(z,b))a[d]=z,a[m]=b,d=m;else break a}}return c}
 function g(a,c){var b=a.sortIndex-c.sortIndex;return 0!==b?b:a.id-c.id}var l;if("object"===typeof performance&&"function"===typeof performance.now){var n=performance;l=function(){return n.now()}}else{var p=Date,q=p.now();l=function(){return p.now()-q}}var r=[],t=[],u=1,v=null,w=3,A=!1,B=!1,C=!1,E="function"===typeof setTimeout?setTimeout:null,F="function"===typeof clearTimeout?clearTimeout:null,G="undefined"!==typeof setImmediate?setImmediate:null;
 "undefined"!==typeof navigator&&void 0!==navigator.scheduling&&void 0!==navigator.scheduling.isInputPending?navigator.scheduling.isInputPending.bind(navigator.scheduling):null;function H(a){for(var c=h(t);null!==c;){if(null===c.callback)k(t);else if(c.startTime<=a)k(t),c.sortIndex=c.expirationTime,f(r,c);else break;c=h(t)}}function I(a){C=!1;H(a);if(!B)if(null!==h(r))B=!0,J||(J=!0,K());else{var c=h(t);null!==c&&L(I,c.startTime-a)}}
@@ -18,3 +18,5 @@ var W="undefined"!==typeof nativeRuntimeScheduler?nativeRuntimeScheduler.unstabl
 typeof nativeRuntimeScheduler?nativeRuntimeScheduler.unstable_cancelCallback:O,da="undefined"!==typeof nativeRuntimeScheduler?nativeRuntimeScheduler.unstable_getCurrentPriorityLevel:P,ea="undefined"!==typeof nativeRuntimeScheduler?nativeRuntimeScheduler.unstable_shouldYield:R,fa="undefined"!==typeof nativeRuntimeScheduler?nativeRuntimeScheduler.unstable_requestPaint:S,ha="undefined"!==typeof nativeRuntimeScheduler?nativeRuntimeScheduler.unstable_now:l;
 function Z(){throw Error("Not implemented.");}exports.unstable_IdlePriority="undefined"!==typeof nativeRuntimeScheduler?nativeRuntimeScheduler.unstable_IdlePriority:5;exports.unstable_ImmediatePriority=aa;exports.unstable_LowPriority=Y;exports.unstable_NormalPriority=X;exports.unstable_Profiling=null;exports.unstable_UserBlockingPriority=W;exports.unstable_cancelCallback=ca;exports.unstable_continueExecution=Z;exports.unstable_forceFrameRate=Z;exports.unstable_getCurrentPriorityLevel=da;
 exports.unstable_getFirstCallbackNode=Z;exports.unstable_next=Z;exports.unstable_now=ha;exports.unstable_pauseExecution=Z;exports.unstable_requestPaint=fa;exports.unstable_runWithPriority=Z;exports.unstable_scheduleCallback=ba;exports.unstable_shouldYield=ea;exports.unstable_wrapCallback=Z;
+
+//# sourceMappingURL=scheduler.native.production.min.js.map
diff --git a/packages/next/src/compiled/scheduler/cjs/scheduler.production.js b/packages/next/src/compiled/scheduler/cjs/scheduler.production.js
new file mode 100644
index 0000000000000..25954cf1f0165
--- /dev/null
+++ b/packages/next/src/compiled/scheduler/cjs/scheduler.production.js
@@ -0,0 +1,602 @@
+/**
+ * @license React
+ * scheduler.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+const enableSchedulerDebugging = false;
+const enableProfiling = false;
+const frameYieldMs = 5;
+
+function push(heap, node) {
+  const index = heap.length;
+  heap.push(node);
+  siftUp(heap, node, index);
+}
+function peek(heap) {
+  return heap.length === 0 ? null : heap[0];
+}
+function pop(heap) {
+  if (heap.length === 0) {
+    return null;
+  }
+
+  const first = heap[0];
+  const last = heap.pop();
+
+  if (last !== first) {
+    heap[0] = last;
+    siftDown(heap, last, 0);
+  }
+
+  return first;
+}
+
+function siftUp(heap, node, i) {
+  let index = i;
+
+  while (index > 0) {
+    const parentIndex = index - 1 >>> 1;
+    const parent = heap[parentIndex];
+
+    if (compare(parent, node) > 0) {
+      // The parent is larger. Swap positions.
+      heap[parentIndex] = node;
+      heap[index] = parent;
+      index = parentIndex;
+    } else {
+      // The parent is smaller. Exit.
+      return;
+    }
+  }
+}
+
+function siftDown(heap, node, i) {
+  let index = i;
+  const length = heap.length;
+  const halfLength = length >>> 1;
+
+  while (index < halfLength) {
+    const leftIndex = (index + 1) * 2 - 1;
+    const left = heap[leftIndex];
+    const rightIndex = leftIndex + 1;
+    const right = heap[rightIndex]; // If the left or right node is smaller, swap with the smaller of those.
+
+    if (compare(left, node) < 0) {
+      if (rightIndex < length && compare(right, left) < 0) {
+        heap[index] = right;
+        heap[rightIndex] = node;
+        index = rightIndex;
+      } else {
+        heap[index] = left;
+        heap[leftIndex] = node;
+        index = leftIndex;
+      }
+    } else if (rightIndex < length && compare(right, node) < 0) {
+      heap[index] = right;
+      heap[rightIndex] = node;
+      index = rightIndex;
+    } else {
+      // Neither child is smaller. Exit.
+      return;
+    }
+  }
+}
+
+function compare(a, b) {
+  // Compare sort index first, then task id.
+  const diff = a.sortIndex - b.sortIndex;
+  return diff !== 0 ? diff : a.id - b.id;
+}
+
+// TODO: Use symbols?
+const ImmediatePriority = 1;
+const UserBlockingPriority = 2;
+const NormalPriority = 3;
+const LowPriority = 4;
+const IdlePriority = 5;
+
+function markTaskErrored(task, ms) {
+}
+
+/* eslint-disable no-var */
+exports.unstable_now = void 0;
+const hasPerformanceNow = // $FlowFixMe[method-unbinding]
+typeof performance === 'object' && typeof performance.now === 'function';
+
+if (hasPerformanceNow) {
+  const localPerformance = performance;
+
+  exports.unstable_now = () => localPerformance.now();
+} else {
+  const localDate = Date;
+  const initialTime = localDate.now();
+
+  exports.unstable_now = () => localDate.now() - initialTime;
+} // Max 31 bit integer. The max integer size in V8 for 32-bit systems.
+// Math.pow(2, 30) - 1
+// 0b111111111111111111111111111111
+
+
+var maxSigned31BitInt = 1073741823; // Times out immediately
+
+var IMMEDIATE_PRIORITY_TIMEOUT = -1; // Eventually times out
+
+var USER_BLOCKING_PRIORITY_TIMEOUT = 250;
+var NORMAL_PRIORITY_TIMEOUT = 5000;
+var LOW_PRIORITY_TIMEOUT = 10000; // Never times out
+
+var IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt; // Tasks are stored on a min heap
+
+var taskQueue = [];
+var timerQueue = []; // Incrementing id counter. Used to maintain insertion order.
+
+var taskIdCounter = 1; // Pausing the scheduler is useful for debugging.
+var currentTask = null;
+var currentPriorityLevel = NormalPriority; // This is set while performing work, to prevent re-entrance.
+
+var isPerformingWork = false;
+var isHostCallbackScheduled = false;
+var isHostTimeoutScheduled = false; // Capture local references to native APIs, in case a polyfill overrides them.
+
+const localSetTimeout = typeof setTimeout === 'function' ? setTimeout : null;
+const localClearTimeout = typeof clearTimeout === 'function' ? clearTimeout : null;
+const localSetImmediate = typeof setImmediate !== 'undefined' ? setImmediate : null; // IE and Node.js + jsdom
+
+typeof navigator !== 'undefined' && // $FlowFixMe[prop-missing]
+navigator.scheduling !== undefined && // $FlowFixMe[incompatible-type]
+navigator.scheduling.isInputPending !== undefined ? navigator.scheduling.isInputPending.bind(navigator.scheduling) : null;
+
+function advanceTimers(currentTime) {
+  // Check for tasks that are no longer delayed and add them to the queue.
+  let timer = peek(timerQueue);
+
+  while (timer !== null) {
+    if (timer.callback === null) {
+      // Timer was cancelled.
+      pop(timerQueue);
+    } else if (timer.startTime <= currentTime) {
+      // Timer fired. Transfer to the task queue.
+      pop(timerQueue);
+      timer.sortIndex = timer.expirationTime;
+      push(taskQueue, timer);
+    } else {
+      // Remaining timers are pending.
+      return;
+    }
+
+    timer = peek(timerQueue);
+  }
+}
+
+function handleTimeout(currentTime) {
+  isHostTimeoutScheduled = false;
+  advanceTimers(currentTime);
+
+  if (!isHostCallbackScheduled) {
+    if (peek(taskQueue) !== null) {
+      isHostCallbackScheduled = true;
+      requestHostCallback();
+    } else {
+      const firstTimer = peek(timerQueue);
+
+      if (firstTimer !== null) {
+        requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
+      }
+    }
+  }
+}
+
+function flushWork(initialTime) {
+
+
+  isHostCallbackScheduled = false;
+
+  if (isHostTimeoutScheduled) {
+    // We scheduled a timeout but it's no longer needed. Cancel it.
+    isHostTimeoutScheduled = false;
+    cancelHostTimeout();
+  }
+
+  isPerformingWork = true;
+  const previousPriorityLevel = currentPriorityLevel;
+
+  try {
+    if (enableProfiling) ; else {
+      // No catch in prod code path.
+      return workLoop(initialTime);
+    }
+  } finally {
+    currentTask = null;
+    currentPriorityLevel = previousPriorityLevel;
+    isPerformingWork = false;
+  }
+}
+
+function workLoop(initialTime) {
+  let currentTime = initialTime;
+  advanceTimers(currentTime);
+  currentTask = peek(taskQueue);
+
+  while (currentTask !== null && !(enableSchedulerDebugging )) {
+    if (currentTask.expirationTime > currentTime && shouldYieldToHost()) {
+      // This currentTask hasn't expired, and we've reached the deadline.
+      break;
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+
+    const callback = currentTask.callback;
+
+    if (typeof callback === 'function') {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      currentTask.callback = null; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+      currentPriorityLevel = currentTask.priorityLevel; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+      const didUserCallbackTimeout = currentTask.expirationTime <= currentTime;
+
+      const continuationCallback = callback(didUserCallbackTimeout);
+      currentTime = exports.unstable_now();
+
+      if (typeof continuationCallback === 'function') {
+        // If a continuation is returned, immediately yield to the main thread
+        // regardless of how much time is left in the current time slice.
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        currentTask.callback = continuationCallback;
+
+        advanceTimers(currentTime);
+        return true;
+      } else {
+
+        if (currentTask === peek(taskQueue)) {
+          pop(taskQueue);
+        }
+
+        advanceTimers(currentTime);
+      }
+    } else {
+      pop(taskQueue);
+    }
+
+    currentTask = peek(taskQueue);
+  } // Return whether there's additional work
+
+
+  if (currentTask !== null) {
+    return true;
+  } else {
+    const firstTimer = peek(timerQueue);
+
+    if (firstTimer !== null) {
+      requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
+    }
+
+    return false;
+  }
+}
+
+function unstable_runWithPriority(priorityLevel, eventHandler) {
+  switch (priorityLevel) {
+    case ImmediatePriority:
+    case UserBlockingPriority:
+    case NormalPriority:
+    case LowPriority:
+    case IdlePriority:
+      break;
+
+    default:
+      priorityLevel = NormalPriority;
+  }
+
+  var previousPriorityLevel = currentPriorityLevel;
+  currentPriorityLevel = priorityLevel;
+
+  try {
+    return eventHandler();
+  } finally {
+    currentPriorityLevel = previousPriorityLevel;
+  }
+}
+
+function unstable_next(eventHandler) {
+  var priorityLevel;
+
+  switch (currentPriorityLevel) {
+    case ImmediatePriority:
+    case UserBlockingPriority:
+    case NormalPriority:
+      // Shift down to normal priority
+      priorityLevel = NormalPriority;
+      break;
+
+    default:
+      // Anything lower than normal priority should remain at the current level.
+      priorityLevel = currentPriorityLevel;
+      break;
+  }
+
+  var previousPriorityLevel = currentPriorityLevel;
+  currentPriorityLevel = priorityLevel;
+
+  try {
+    return eventHandler();
+  } finally {
+    currentPriorityLevel = previousPriorityLevel;
+  }
+}
+
+function unstable_wrapCallback(callback) {
+  var parentPriorityLevel = currentPriorityLevel; // $FlowFixMe[incompatible-return]
+  // $FlowFixMe[missing-this-annot]
+
+  return function () {
+    // This is a fork of runWithPriority, inlined for performance.
+    var previousPriorityLevel = currentPriorityLevel;
+    currentPriorityLevel = parentPriorityLevel;
+
+    try {
+      return callback.apply(this, arguments);
+    } finally {
+      currentPriorityLevel = previousPriorityLevel;
+    }
+  };
+}
+
+function unstable_scheduleCallback(priorityLevel, callback, options) {
+  var currentTime = exports.unstable_now();
+  var startTime;
+
+  if (typeof options === 'object' && options !== null) {
+    var delay = options.delay;
+
+    if (typeof delay === 'number' && delay > 0) {
+      startTime = currentTime + delay;
+    } else {
+      startTime = currentTime;
+    }
+  } else {
+    startTime = currentTime;
+  }
+
+  var timeout;
+
+  switch (priorityLevel) {
+    case ImmediatePriority:
+      timeout = IMMEDIATE_PRIORITY_TIMEOUT;
+      break;
+
+    case UserBlockingPriority:
+      timeout = USER_BLOCKING_PRIORITY_TIMEOUT;
+      break;
+
+    case IdlePriority:
+      timeout = IDLE_PRIORITY_TIMEOUT;
+      break;
+
+    case LowPriority:
+      timeout = LOW_PRIORITY_TIMEOUT;
+      break;
+
+    case NormalPriority:
+    default:
+      timeout = NORMAL_PRIORITY_TIMEOUT;
+      break;
+  }
+
+  var expirationTime = startTime + timeout;
+  var newTask = {
+    id: taskIdCounter++,
+    callback,
+    priorityLevel,
+    startTime,
+    expirationTime,
+    sortIndex: -1
+  };
+
+  if (startTime > currentTime) {
+    // This is a delayed task.
+    newTask.sortIndex = startTime;
+    push(timerQueue, newTask);
+
+    if (peek(taskQueue) === null && newTask === peek(timerQueue)) {
+      // All tasks are delayed, and this is the task with the earliest delay.
+      if (isHostTimeoutScheduled) {
+        // Cancel an existing timeout.
+        cancelHostTimeout();
+      } else {
+        isHostTimeoutScheduled = true;
+      } // Schedule a timeout.
+
+
+      requestHostTimeout(handleTimeout, startTime - currentTime);
+    }
+  } else {
+    newTask.sortIndex = expirationTime;
+    push(taskQueue, newTask);
+    // wait until the next time we yield.
+
+
+    if (!isHostCallbackScheduled && !isPerformingWork) {
+      isHostCallbackScheduled = true;
+      requestHostCallback();
+    }
+  }
+
+  return newTask;
+}
+
+function unstable_pauseExecution() {
+}
+
+function unstable_continueExecution() {
+
+  if (!isHostCallbackScheduled && !isPerformingWork) {
+    isHostCallbackScheduled = true;
+    requestHostCallback();
+  }
+}
+
+function unstable_getFirstCallbackNode() {
+  return peek(taskQueue);
+}
+
+function unstable_cancelCallback(task) {
+  // remove from the queue because you can't remove arbitrary nodes from an
+  // array based heap, only the first one.)
+
+
+  task.callback = null;
+}
+
+function unstable_getCurrentPriorityLevel() {
+  return currentPriorityLevel;
+}
+
+let isMessageLoopRunning = false;
+let taskTimeoutID = -1; // Scheduler periodically yields in case there is other work on the main
+// thread, like user events. By default, it yields multiple times per frame.
+// It does not attempt to align with frame boundaries, since most tasks don't
+// need to be frame aligned; for those that do, use requestAnimationFrame.
+
+let frameInterval = frameYieldMs;
+let startTime = -1;
+
+function shouldYieldToHost() {
+  const timeElapsed = exports.unstable_now() - startTime;
+
+  if (timeElapsed < frameInterval) {
+    // The main thread has only been blocked for a really short amount of time;
+    // smaller than a single frame. Don't yield yet.
+    return false;
+  } // The main thread has been blocked for a non-negligible amount of time. We
+
+
+  return true;
+}
+
+function requestPaint() {
+
+}
+
+function forceFrameRate(fps) {
+  if (fps < 0 || fps > 125) {
+    // Using console['error'] to evade Babel and ESLint
+    console['error']('forceFrameRate takes a positive int between 0 and 125, ' + 'forcing frame rates higher than 125 fps is not supported');
+    return;
+  }
+
+  if (fps > 0) {
+    frameInterval = Math.floor(1000 / fps);
+  } else {
+    // reset the framerate
+    frameInterval = frameYieldMs;
+  }
+}
+
+const performWorkUntilDeadline = () => {
+  if (isMessageLoopRunning) {
+    const currentTime = exports.unstable_now(); // Keep track of the start time so we can measure how long the main thread
+    // has been blocked.
+
+    startTime = currentTime; // If a scheduler task throws, exit the current browser task so the
+    // error can be observed.
+    //
+    // Intentionally not using a try-catch, since that makes some debugging
+    // techniques harder. Instead, if `flushWork` errors, then `hasMoreWork` will
+    // remain true, and we'll continue the work loop.
+
+    let hasMoreWork = true;
+
+    try {
+      hasMoreWork = flushWork(currentTime);
+    } finally {
+      if (hasMoreWork) {
+        // If there's more work, schedule the next message event at the end
+        // of the preceding one.
+        schedulePerformWorkUntilDeadline();
+      } else {
+        isMessageLoopRunning = false;
+      }
+    }
+  } // Yielding to the browser will give it a chance to paint, so we can
+};
+
+let schedulePerformWorkUntilDeadline;
+
+if (typeof localSetImmediate === 'function') {
+  // Node.js and old IE.
+  // There's a few reasons for why we prefer setImmediate.
+  //
+  // Unlike MessageChannel, it doesn't prevent a Node.js process from exiting.
+  // (Even though this is a DOM fork of the Scheduler, you could get here
+  // with a mix of Node.js 15+, which has a MessageChannel, and jsdom.)
+  // https://github.com/facebook/react/issues/20756
+  //
+  // But also, it runs earlier which is the semantic we want.
+  // If other browsers ever implement it, it's better to use it.
+  // Although both of these would be inferior to native scheduling.
+  schedulePerformWorkUntilDeadline = () => {
+    localSetImmediate(performWorkUntilDeadline);
+  };
+} else if (typeof MessageChannel !== 'undefined') {
+  // DOM and Worker environments.
+  // We prefer MessageChannel because of the 4ms setTimeout clamping.
+  const channel = new MessageChannel();
+  const port = channel.port2;
+  channel.port1.onmessage = performWorkUntilDeadline;
+
+  schedulePerformWorkUntilDeadline = () => {
+    port.postMessage(null);
+  };
+} else {
+  // We should only fallback here in non-browser environments.
+  schedulePerformWorkUntilDeadline = () => {
+    // $FlowFixMe[not-a-function] nullable value
+    localSetTimeout(performWorkUntilDeadline, 0);
+  };
+}
+
+function requestHostCallback() {
+  if (!isMessageLoopRunning) {
+    isMessageLoopRunning = true;
+    schedulePerformWorkUntilDeadline();
+  }
+}
+
+function requestHostTimeout(callback, ms) {
+  // $FlowFixMe[not-a-function] nullable value
+  taskTimeoutID = localSetTimeout(() => {
+    callback(exports.unstable_now());
+  }, ms);
+}
+
+function cancelHostTimeout() {
+  // $FlowFixMe[not-a-function] nullable value
+  localClearTimeout(taskTimeoutID);
+  taskTimeoutID = -1;
+}
+const unstable_Profiling = null;
+
+exports.unstable_IdlePriority = IdlePriority;
+exports.unstable_ImmediatePriority = ImmediatePriority;
+exports.unstable_LowPriority = LowPriority;
+exports.unstable_NormalPriority = NormalPriority;
+exports.unstable_Profiling = unstable_Profiling;
+exports.unstable_UserBlockingPriority = UserBlockingPriority;
+exports.unstable_cancelCallback = unstable_cancelCallback;
+exports.unstable_continueExecution = unstable_continueExecution;
+exports.unstable_forceFrameRate = forceFrameRate;
+exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
+exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
+exports.unstable_next = unstable_next;
+exports.unstable_pauseExecution = unstable_pauseExecution;
+exports.unstable_requestPaint = requestPaint;
+exports.unstable_runWithPriority = unstable_runWithPriority;
+exports.unstable_scheduleCallback = unstable_scheduleCallback;
+exports.unstable_shouldYield = shouldYieldToHost;
+exports.unstable_wrapCallback = unstable_wrapCallback;
\ No newline at end of file
diff --git a/packages/next/src/compiled/scheduler/cjs/scheduler.production.min.js b/packages/next/src/compiled/scheduler/cjs/scheduler.production.min.js
index e60ea2257d010..325279db98640 100644
--- a/packages/next/src/compiled/scheduler/cjs/scheduler.production.min.js
+++ b/packages/next/src/compiled/scheduler/cjs/scheduler.production.min.js
@@ -1,12 +1,12 @@
-/**
- * @license React
- * scheduler.production.min.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/*
+ React
+ scheduler.production.min.js
+
+ Copyright (c) Meta Platforms, Inc. and affiliates.
+
+ This source code is licensed under the MIT license found in the
+ LICENSE file in the root directory of this source tree.
+*/
 'use strict';function f(a,c){var b=a.length;a.push(c);a:for(;0<b;){var d=b-1>>>1,e=a[d];if(0<g(e,c))a[d]=c,a[b]=e,b=d;else break a}}function h(a){return 0===a.length?null:a[0]}function k(a){if(0===a.length)return null;var c=a[0],b=a.pop();if(b!==c){a[0]=b;a:for(var d=0,e=a.length,v=e>>>1;d<v;){var w=2*(d+1)-1,C=a[w],m=w+1,x=a[m];if(0>g(C,b))m<e&&0>g(x,C)?(a[d]=x,a[m]=b,d=m):(a[d]=C,a[w]=b,d=w);else if(m<e&&0>g(x,b))a[d]=x,a[m]=b,d=m;else break a}}return c}
 function g(a,c){var b=a.sortIndex-c.sortIndex;return 0!==b?b:a.id-c.id}exports.unstable_now=void 0;if("object"===typeof performance&&"function"===typeof performance.now){var l=performance;exports.unstable_now=function(){return l.now()}}else{var n=Date,p=n.now();exports.unstable_now=function(){return n.now()-p}}
 var q=[],r=[],t=1,u=null,y=3,z=!1,A=!1,B=!1,D="function"===typeof setTimeout?setTimeout:null,E="function"===typeof clearTimeout?clearTimeout:null,F="undefined"!==typeof setImmediate?setImmediate:null;"undefined"!==typeof navigator&&void 0!==navigator.scheduling&&void 0!==navigator.scheduling.isInputPending?navigator.scheduling.isInputPending.bind(navigator.scheduling):null;
@@ -17,3 +17,5 @@ exports.unstable_UserBlockingPriority=2;exports.unstable_cancelCallback=function
 exports.unstable_next=function(a){switch(y){case 1:case 2:case 3:var c=3;break;default:c=y}var b=y;y=c;try{return a()}finally{y=b}};exports.unstable_pauseExecution=function(){};exports.unstable_requestPaint=function(){};exports.unstable_runWithPriority=function(a,c){switch(a){case 1:case 2:case 3:case 4:case 5:break;default:a=3}var b=y;y=a;try{return c()}finally{y=b}};
 exports.unstable_scheduleCallback=function(a,c,b){var d=exports.unstable_now();"object"===typeof b&&null!==b?(b=b.delay,b="number"===typeof b&&0<b?d+b:d):b=d;switch(a){case 1:var e=-1;break;case 2:e=250;break;case 5:e=1073741823;break;case 4:e=1E4;break;default:e=5E3}e=b+e;a={id:t++,callback:c,priorityLevel:a,startTime:b,expirationTime:e,sortIndex:-1};b>d?(a.sortIndex=b,f(r,a),null===h(q)&&a===h(r)&&(B?(E(L),L=-1):B=!0,J(H,b-d))):(a.sortIndex=e,f(q,a),A||z||(A=!0,I()));return a};
 exports.unstable_shouldYield=O;exports.unstable_wrapCallback=function(a){var c=y;return function(){var b=y;y=c;try{return a.apply(this,arguments)}finally{y=b}}};
+
+//# sourceMappingURL=scheduler.production.min.js.map
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 2988544029b4a..3257873ca77c3 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -426,8 +426,8 @@ importers:
         specifier: npm:react@17.0.2
         version: /react@17.0.2
       react-builtin:
-        specifier: npm:react@18.3.0-canary-2983249dd-20231107
-        version: /react@18.3.0-canary-2983249dd-20231107
+        specifier: npm:react@18.3.0-canary-7508dcd5c-20231108
+        version: /react@18.3.0-canary-7508dcd5c-20231108
       react-dom:
         specifier: 18.2.0
         version: 18.2.0(react@18.2.0)
@@ -435,26 +435,26 @@ importers:
         specifier: npm:react-dom@17.0.2
         version: /react-dom@17.0.2(react@18.2.0)
       react-dom-builtin:
-        specifier: npm:react-dom@18.3.0-canary-2983249dd-20231107
-        version: /react-dom@18.3.0-canary-2983249dd-20231107(react@18.2.0)
+        specifier: npm:react-dom@18.3.0-canary-7508dcd5c-20231108
+        version: /react-dom@18.3.0-canary-7508dcd5c-20231108(react@18.2.0)
       react-dom-experimental-builtin:
-        specifier: npm:react-dom@0.0.0-experimental-2983249dd-20231107
-        version: /react-dom@0.0.0-experimental-2983249dd-20231107(react@18.2.0)
+        specifier: npm:react-dom@0.0.0-experimental-7508dcd5c-20231108
+        version: /react-dom@0.0.0-experimental-7508dcd5c-20231108(react@18.2.0)
       react-experimental-builtin:
-        specifier: npm:react@0.0.0-experimental-2983249dd-20231107
-        version: /react@0.0.0-experimental-2983249dd-20231107
+        specifier: npm:react@0.0.0-experimental-7508dcd5c-20231108
+        version: /react@0.0.0-experimental-7508dcd5c-20231108
       react-server-dom-turbopack:
-        specifier: 18.3.0-canary-2983249dd-20231107
-        version: 18.3.0-canary-2983249dd-20231107(react-dom@18.2.0)(react@18.2.0)
+        specifier: 18.3.0-canary-7508dcd5c-20231108
+        version: 18.3.0-canary-7508dcd5c-20231108(react-dom@18.2.0)(react@18.2.0)
       react-server-dom-turbopack-experimental:
-        specifier: npm:react-server-dom-turbopack@0.0.0-experimental-2983249dd-20231107
-        version: /react-server-dom-turbopack@0.0.0-experimental-2983249dd-20231107(react-dom@18.2.0)(react@18.2.0)
+        specifier: npm:react-server-dom-turbopack@0.0.0-experimental-7508dcd5c-20231108
+        version: /react-server-dom-turbopack@0.0.0-experimental-7508dcd5c-20231108(react-dom@18.2.0)(react@18.2.0)
       react-server-dom-webpack:
-        specifier: 18.3.0-canary-2983249dd-20231107
-        version: 18.3.0-canary-2983249dd-20231107(react-dom@18.2.0)(react@18.2.0)(webpack@5.86.0)
+        specifier: 18.3.0-canary-7508dcd5c-20231108
+        version: 18.3.0-canary-7508dcd5c-20231108(react-dom@18.2.0)(react@18.2.0)(webpack@5.86.0)
       react-server-dom-webpack-experimental:
-        specifier: npm:react-server-dom-webpack@0.0.0-experimental-2983249dd-20231107
-        version: /react-server-dom-webpack@0.0.0-experimental-2983249dd-20231107(react-dom@18.2.0)(react@18.2.0)(webpack@5.86.0)
+        specifier: npm:react-server-dom-webpack@0.0.0-experimental-7508dcd5c-20231108
+        version: /react-server-dom-webpack@0.0.0-experimental-7508dcd5c-20231108(react-dom@18.2.0)(react@18.2.0)(webpack@5.86.0)
       react-ssr-prepass:
         specifier: 1.0.8
         version: 1.0.8(react-is@16.13.1)(react@18.2.0)
@@ -483,11 +483,11 @@ importers:
         specifier: 0.10.6
         version: 0.10.6
       scheduler-builtin:
-        specifier: npm:scheduler@0.24.0-canary-2983249dd-20231107
-        version: /scheduler@0.24.0-canary-2983249dd-20231107
+        specifier: npm:scheduler@0.24.0-canary-7508dcd5c-20231108
+        version: /scheduler@0.24.0-canary-7508dcd5c-20231108
       scheduler-experimental-builtin:
-        specifier: npm:scheduler@0.0.0-experimental-2983249dd-20231107
-        version: /scheduler@0.0.0-experimental-2983249dd-20231107
+        specifier: npm:scheduler@0.0.0-experimental-7508dcd5c-20231108
+        version: /scheduler@0.0.0-experimental-7508dcd5c-20231108
       seedrandom:
         specifier: 3.0.5
         version: 3.0.5
@@ -20227,14 +20227,14 @@ packages:
       strip-json-comments: 2.0.1
     dev: true
 
-  /react-dom@0.0.0-experimental-2983249dd-20231107(react@18.2.0):
-    resolution: {integrity: sha512-KgIDwFpIT3WDPZLLmvYOtrOKzbu9tGw1cNCDAdtkZkAJsSS0OKQUw0WoT451nFGJpENiXJk57/VQoldCIKW6rQ==}
+  /react-dom@0.0.0-experimental-7508dcd5c-20231108(react@18.2.0):
+    resolution: {integrity: sha512-Rf1bMaUldlaeCMm8XjA15BofuUmX8iXa9fm0etARz5bzUn8A5d6cGUWLi8xq2/ca7xlptKbcVFCX/v2ZTTZ5eQ==}
     peerDependencies:
-      react: 0.0.0-experimental-2983249dd-20231107
+      react: 0.0.0-experimental-7508dcd5c-20231108
     dependencies:
       loose-envify: 1.4.0
       react: 18.2.0
-      scheduler: 0.0.0-experimental-2983249dd-20231107
+      scheduler: 0.0.0-experimental-7508dcd5c-20231108
     dev: true
 
   /react-dom@17.0.2(react@17.0.2):
@@ -20268,14 +20268,14 @@ packages:
       react: 18.2.0
       scheduler: 0.23.0
 
-  /react-dom@18.3.0-canary-2983249dd-20231107(react@18.2.0):
-    resolution: {integrity: sha512-5HPCAnNRNsCmUlkeGkMp0/I9q+ZSipvZ3MaQYOFvufXygjTRBTDGTuVSUA4kW4TPnxTt++iujUK5AoMeG6UO8A==}
+  /react-dom@18.3.0-canary-7508dcd5c-20231108(react@18.2.0):
+    resolution: {integrity: sha512-aMf9FXaUx1dt6tyhKSZmywCUqMMECdaDfHl+oB0fQQIgXOVOnPLi9LL7wPu161hp3T7e4ST+DuIf3hX9EEfa2Q==}
     peerDependencies:
-      react: 18.3.0-canary-2983249dd-20231107
+      react: 18.3.0-canary-7508dcd5c-20231108
     dependencies:
       loose-envify: 1.4.0
       react: 18.2.0
-      scheduler: 0.24.0-canary-2983249dd-20231107
+      scheduler: 0.24.0-canary-7508dcd5c-20231108
     dev: true
 
   /react-is@16.13.1:
@@ -20298,12 +20298,12 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
-  /react-server-dom-turbopack@0.0.0-experimental-2983249dd-20231107(react-dom@18.2.0)(react@18.2.0):
-    resolution: {integrity: sha512-bgxsOmNIOjhQ0HHVJW5aBxQpvO3rwQC877+f5EksOOf57T6jHw8BgDSWij4x+pU3SuXYpjb7zugWmk+dMxZfOQ==}
+  /react-server-dom-turbopack@0.0.0-experimental-7508dcd5c-20231108(react-dom@18.2.0)(react@18.2.0):
+    resolution: {integrity: sha512-7TP7FQewyHtCyolWgGS+Pi2L9vNseB05KVAOAbdhFS+c8qK1NWYs83f9gTSIVjRwnqYNXuSSn1k5Iv8jWeimPw==}
     engines: {node: '>=0.10.0'}
     peerDependencies:
-      react: 0.0.0-experimental-2983249dd-20231107
-      react-dom: 0.0.0-experimental-2983249dd-20231107
+      react: 0.0.0-experimental-7508dcd5c-20231108
+      react-dom: 0.0.0-experimental-7508dcd5c-20231108
     dependencies:
       acorn-loose: 8.3.0
       loose-envify: 1.4.0
@@ -20312,12 +20312,12 @@ packages:
       react-dom: 18.2.0(react@18.2.0)
     dev: true
 
-  /react-server-dom-turbopack@18.3.0-canary-2983249dd-20231107(react-dom@18.2.0)(react@18.2.0):
-    resolution: {integrity: sha512-w/5IMYvI5fRF5dgMonmNxi7btXtdupOlMYGzGYOCnKnGcx0+pVAFvWl6lk8p4Gi9wf2OuCmx+Jb7Yx4kQGcCVg==}
+  /react-server-dom-turbopack@18.3.0-canary-7508dcd5c-20231108(react-dom@18.2.0)(react@18.2.0):
+    resolution: {integrity: sha512-r4wkecj1tnkOki8IPGjSl4FiY+qZMDOFd9JdooS9S7gJ/QDdIjBgbndFT+CKCq4Ni6OR5OA8o9SFJl2A4nIzUA==}
     engines: {node: '>=0.10.0'}
     peerDependencies:
-      react: 18.3.0-canary-2983249dd-20231107
-      react-dom: 18.3.0-canary-2983249dd-20231107
+      react: 18.3.0-canary-7508dcd5c-20231108
+      react-dom: 18.3.0-canary-7508dcd5c-20231108
     dependencies:
       acorn-loose: 8.3.0
       loose-envify: 1.4.0
@@ -20326,12 +20326,12 @@ packages:
       react-dom: 18.2.0(react@18.2.0)
     dev: true
 
-  /react-server-dom-webpack@0.0.0-experimental-2983249dd-20231107(react-dom@18.2.0)(react@18.2.0)(webpack@5.86.0):
-    resolution: {integrity: sha512-+5it8GArVlTNIvSj9xUI9R8lxVPotWA3MCHeIt3pU8n6rTR+KcAAw3goDh33iE2GQiFt6kJWYzwxZgXcqcJk8Q==}
+  /react-server-dom-webpack@0.0.0-experimental-7508dcd5c-20231108(react-dom@18.2.0)(react@18.2.0)(webpack@5.86.0):
+    resolution: {integrity: sha512-b80uv3Syt0bHQXuVx8GauumYPi3OH+585Ecf88Xnp3OwnbCwMDZRaCqAejTi5MwnKkrd33+CyQDep1ibMD1q8Q==}
     engines: {node: '>=0.10.0'}
     peerDependencies:
-      react: 0.0.0-experimental-2983249dd-20231107
-      react-dom: 0.0.0-experimental-2983249dd-20231107
+      react: 0.0.0-experimental-7508dcd5c-20231108
+      react-dom: 0.0.0-experimental-7508dcd5c-20231108
       webpack: 5.86.0
     dependencies:
       acorn-loose: 8.3.0
@@ -20342,12 +20342,12 @@ packages:
       webpack: 5.86.0(@swc/core@1.3.85)
     dev: true
 
-  /react-server-dom-webpack@18.3.0-canary-2983249dd-20231107(react-dom@18.2.0)(react@18.2.0)(webpack@5.86.0):
-    resolution: {integrity: sha512-XU4IS+xVvw9/uaPWNP02vB6wXtd2gB4l4sXiqeH7jjc00v3wdxuyt+dmIPCjrp0Ca6ewjUjwrkbJbE2TX+EDyQ==}
+  /react-server-dom-webpack@18.3.0-canary-7508dcd5c-20231108(react-dom@18.2.0)(react@18.2.0)(webpack@5.86.0):
+    resolution: {integrity: sha512-KzVUptsk72wMXxi+gplVei2vS8hSXmJo39rsHO2UFB4tz6lfHtTBcv0opZZx8TEUiv9agGOZ1JZj/ESkeR6trA==}
     engines: {node: '>=0.10.0'}
     peerDependencies:
-      react: 18.3.0-canary-2983249dd-20231107
-      react-dom: 18.3.0-canary-2983249dd-20231107
+      react: 18.3.0-canary-7508dcd5c-20231108
+      react-dom: 18.3.0-canary-7508dcd5c-20231108
       webpack: 5.86.0
     dependencies:
       acorn-loose: 8.3.0
@@ -20385,8 +20385,8 @@ packages:
       react-lifecycles-compat: 3.0.4
     dev: true
 
-  /react@0.0.0-experimental-2983249dd-20231107:
-    resolution: {integrity: sha512-P74exL+kgkc2XMjBa6yMAOKmDya5sRJzrH+N4kU4VH2QtsT+zWddd5cx8AXRFrxmKWFMfbHjCi/o1JXhkh/LMw==}
+  /react@0.0.0-experimental-7508dcd5c-20231108:
+    resolution: {integrity: sha512-FSEEs4TxYoUZSbVA3xxzxA+zDLT3DFXUC08hnG47iqP01tXTucveeHZA5KoJma3w0CnoGM7xFwCpMfzZ0ARPUQ==}
     engines: {node: '>=0.10.0'}
     dependencies:
       loose-envify: 1.4.0
@@ -20405,8 +20405,8 @@ packages:
     dependencies:
       loose-envify: 1.4.0
 
-  /react@18.3.0-canary-2983249dd-20231107:
-    resolution: {integrity: sha512-OrgP8k//esvNiQ1PD39BwIZTwbj4KIFQ7jY2tJEvyvEhqnu4T/6kRxZeYrg7EVw6AQjASLMcmZjFYora8+pY1A==}
+  /react@18.3.0-canary-7508dcd5c-20231108:
+    resolution: {integrity: sha512-i248i3Fz13YJMv77eQZYOTkH39U9d/LQB+1podYpkWEi5xjLSe1JX2h4hU+R3tJOm9vR+26CTyk2lguNoWKNCQ==}
     engines: {node: '>=0.10.0'}
     dependencies:
       loose-envify: 1.4.0
@@ -21428,8 +21428,8 @@ packages:
       xmlchars: 2.2.0
     dev: true
 
-  /scheduler@0.0.0-experimental-2983249dd-20231107:
-    resolution: {integrity: sha512-G2Hum0eFcDvKIf5OcdQvJeslqePsIt7I5nd2zDzciusHQvOl62/FteqgAU6nUYWhYLJHiqBKL0iZp4H/KJIKeQ==}
+  /scheduler@0.0.0-experimental-7508dcd5c-20231108:
+    resolution: {integrity: sha512-1ieRxTPucHczGSzz3xmHjKE4nxDaIznZ64P1LuaWUbJ3bT3pbvZWXPgEcA5COVqVqg9fMHHrCesg0NbuHFxjgA==}
     dependencies:
       loose-envify: 1.4.0
     dev: true
@@ -21445,8 +21445,8 @@ packages:
     dependencies:
       loose-envify: 1.4.0
 
-  /scheduler@0.24.0-canary-2983249dd-20231107:
-    resolution: {integrity: sha512-nHvVSSy/0l6k4mnq6F6pFyV2LO7+gKNaEWGI0MF0jNmeTXan3hmGXTsVLAbspFR3OvCroSlvMAs7hRB72vNB0A==}
+  /scheduler@0.24.0-canary-7508dcd5c-20231108:
+    resolution: {integrity: sha512-KCNls/0m0VC4IuBcoAHxXe0NxbDpmXvGlRmLuGHOOh+oPtv1M9bEGQB2E5sp7gvCD6FeYrkXWCyrwUQk/4dqcQ==}
     dependencies:
       loose-envify: 1.4.0
     dev: true